diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/samples/widget_pose.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/samples/widget_pose.cpp
new file mode 100644
index 00000000..130044f1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/samples/widget_pose.cpp
@@ -0,0 +1,99 @@
+/**
+ * @file widget_pose.cpp
+ * @brief Setting pose of a widget
+ * @author Ozan Cagri Tonkal
+ */
+
+#include <opencv2/viz.hpp>
+#include <opencv2/calib3d.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function help
+ * @brief Display instructions to use this tutorial program
+ */
+static void help()
+{
+    cout
+    << "--------------------------------------------------------------------------"   << endl
+    << "This program shows how to visualize a cube rotated around (1,1,1) and shifted "
+    << "using Rodrigues vector."                                                      << endl
+    << "Usage:"                                                                       << endl
+    << "./widget_pose"                                                                << endl
+    << endl;
+}
+
+/**
+ * @function main
+ */
+int main()
+{
+    help();
+
+    /// Create a window
+    viz::Viz3d myWindow("Coordinate Frame");
+
+    /// Add coordinate axes
+    myWindow.showWidget("Coordinate Widget", viz::WCoordinateSystem());
+
+    /// Add line to represent (1,1,1) axis
+    viz::WLine axis(Point3f(-1.0f,-1.0f,-1.0f), Point3f(1.0f,1.0f,1.0f));
+    axis.setRenderingProperty(viz::LINE_WIDTH, 4.0);
+    myWindow.showWidget("Line Widget", axis);
+
+    /// Construct a cube widget
+    viz::WCube cube_widget(Point3f(0.5,0.5,0.0), Point3f(0.0,0.0,-0.5), true, viz::Color::blue());
+    cube_widget.setRenderingProperty(viz::LINE_WIDTH, 4.0);
+    myWindow.showWidget("Cube Widget", cube_widget);
+
+    /// Rodrigues vector
+    Mat rot_vec = Mat::zeros(1,3,CV_32F);
+    float translation_phase = 0.0, translation = 0.0;
+
+    rot_vec.at<float>(0, 0) += (float)CV_PI * 0.01f;
+    rot_vec.at<float>(0, 1) += (float)CV_PI * 0.01f;
+    rot_vec.at<float>(0, 2) += (float)CV_PI * 0.01f;
+
+    /// Shift on (1,1,1)
+    translation_phase += (float)CV_PI * 0.01f;
+    translation = sin(translation_phase);
+
+    Mat rot_mat;
+    Rodrigues(rot_vec, rot_mat);
+    cout << "rot_mat = " << rot_mat << endl;
+    /// Construct pose
+    Affine3f pose(rot_mat, Vec3f(translation, translation, translation));
+    Affine3f pose2(pose.matrix);
+    cout << "pose = " << pose.matrix << endl;
+    cout << "pose = " << pose2.matrix << endl;
+
+
+
+    while(!myWindow.wasStopped())
+    {
+        /* Rotation using rodrigues */
+        /// Rotate around (1,1,1)
+        rot_vec.at<float>(0,0) += (float)CV_PI * 0.01f;
+        rot_vec.at<float>(0,1) += (float)CV_PI * 0.01f;
+        rot_vec.at<float>(0,2) += (float)CV_PI * 0.01f;
+
+        /// Shift on (1,1,1)
+        translation_phase += (float)CV_PI * 0.01f;
+        translation = sin(translation_phase);
+
+        Mat rot_mat1;
+        Rodrigues(rot_vec, rot_mat1);
+
+        /// Construct pose
+        Affine3f pose1(rot_mat1, Vec3f(translation, translation, translation));
+
+        myWindow.setWidgetPose("Cube Widget", pose1);
+
+        myWindow.spinOnce(1, true);
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/clouds.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/clouds.cpp
new file mode 100644
index 00000000..c9a13fcf
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/clouds.cpp
@@ -0,0 +1,530 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "precomp.hpp"
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Point Cloud Widget implementation
+
+cv::viz::WCloud::WCloud(InputArray cloud, InputArray colors)
+{
+    WCloud cloud_widget(cloud, colors, cv::noArray());
+    *this = cloud_widget;
+}
+
+cv::viz::WCloud::WCloud(InputArray cloud, const Color &color)
+{
+    WCloud cloud_widget(cloud, Mat(cloud.size(), CV_8UC3, color));
+    *this = cloud_widget;
+}
+
+cv::viz::WCloud::WCloud(InputArray cloud, const Color &color, InputArray normals)
+{
+    WCloud cloud_widget(cloud, Mat(cloud.size(), CV_8UC3, color), normals);
+    *this = cloud_widget;
+}
+
+cv::viz::WCloud::WCloud(cv::InputArray cloud, cv::InputArray colors, cv::InputArray normals)
+{
+    CV_Assert(!cloud.empty() && !colors.empty());
+
+    vtkSmartPointer<vtkCloudMatSource> cloud_source = vtkSmartPointer<vtkCloudMatSource>::New();
+    cloud_source->SetColorCloudNormals(cloud, colors, normals);
+    cloud_source->Update();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, cloud_source->GetOutput());
+    mapper->SetScalarModeToUsePointData();
+#if VTK_MAJOR_VERSION < 8
+    mapper->ImmediateModeRenderingOff();
+#endif
+    mapper->SetScalarRange(0, 255);
+    mapper->ScalarVisibilityOn();
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->GetProperty()->SetInterpolationToFlat();
+    actor->GetProperty()->BackfaceCullingOn();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WCloud cv::viz::Widget::cast<cv::viz::WCloud>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WCloud&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Painted Cloud Widget implementation
+
+cv::viz::WPaintedCloud::WPaintedCloud(InputArray cloud)
+{
+    vtkSmartPointer<vtkCloudMatSource> cloud_source = vtkSmartPointer<vtkCloudMatSource>::New();
+    cloud_source->SetCloud(cloud);
+    cloud_source->Update();
+
+    Vec6d bounds(cloud_source->GetOutput()->GetPoints()->GetBounds());
+
+    vtkSmartPointer<vtkElevationFilter> elevation = vtkSmartPointer<vtkElevationFilter>::New();
+    elevation->SetInputConnection(cloud_source->GetOutputPort());
+    elevation->SetLowPoint(bounds[0], bounds[2], bounds[4]);
+    elevation->SetHighPoint(bounds[1], bounds[3], bounds[5]);
+    elevation->SetScalarRange(0.0, 1.0);
+    elevation->Update();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, vtkPolyData::SafeDownCast(elevation->GetOutput()));
+#if VTK_MAJOR_VERSION < 8
+    mapper->ImmediateModeRenderingOff();
+#endif
+    mapper->ScalarVisibilityOn();
+    mapper->SetColorModeToMapScalars();
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->GetProperty()->SetInterpolationToFlat();
+    actor->GetProperty()->BackfaceCullingOn();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WPaintedCloud::WPaintedCloud(InputArray cloud, const Point3d& p1, const Point3d& p2)
+{
+    vtkSmartPointer<vtkCloudMatSource> cloud_source = vtkSmartPointer<vtkCloudMatSource>::New();
+    cloud_source->SetCloud(cloud);
+
+    vtkSmartPointer<vtkElevationFilter> elevation = vtkSmartPointer<vtkElevationFilter>::New();
+    elevation->SetInputConnection(cloud_source->GetOutputPort());
+    elevation->SetLowPoint(p1.x, p1.y, p1.z);
+    elevation->SetHighPoint(p2.x, p2.y, p2.z);
+    elevation->SetScalarRange(0.0, 1.0);
+    elevation->Update();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, vtkPolyData::SafeDownCast(elevation->GetOutput()));
+#if VTK_MAJOR_VERSION < 8
+    mapper->ImmediateModeRenderingOff();
+#endif
+    mapper->ScalarVisibilityOn();
+    mapper->SetColorModeToMapScalars();
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->GetProperty()->SetInterpolationToFlat();
+    actor->GetProperty()->BackfaceCullingOn();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WPaintedCloud::WPaintedCloud(InputArray cloud, const Point3d& p1, const Point3d& p2, const Color& c1, const Color c2)
+{
+    vtkSmartPointer<vtkCloudMatSource> cloud_source = vtkSmartPointer<vtkCloudMatSource>::New();
+    cloud_source->SetCloud(cloud);
+
+    vtkSmartPointer<vtkElevationFilter> elevation = vtkSmartPointer<vtkElevationFilter>::New();
+    elevation->SetInputConnection(cloud_source->GetOutputPort());
+    elevation->SetLowPoint(p1.x, p1.y, p1.z);
+    elevation->SetHighPoint(p2.x, p2.y, p2.z);
+    elevation->SetScalarRange(0.0, 1.0);
+    elevation->Update();
+
+    Color vc1 = vtkcolor(c1), vc2 = vtkcolor(c2);
+    vtkSmartPointer<vtkColorTransferFunction> color_transfer = vtkSmartPointer<vtkColorTransferFunction>::New();
+    color_transfer->SetColorSpaceToRGB();
+    color_transfer->AddRGBPoint(0.0, vc1[0], vc1[1], vc1[2]);
+    color_transfer->AddRGBPoint(1.0, vc2[0], vc2[1], vc2[2]);
+    color_transfer->SetScaleToLinear();
+    color_transfer->Build();
+
+    //if in future some need to replace color table with real scalars, then this can be done usine next calls:
+    //vtkDataArray *float_scalars = vtkPolyData::SafeDownCast(elevation->GetOutput())->GetPointData()->GetArray("Elevation");
+    //vtkSmartPointer<vtkPolyData> polydata = cloud_source->GetOutput();
+    //polydata->GetPointData()->SetScalars(color_transfer->MapScalars(float_scalars, VTK_COLOR_MODE_DEFAULT, 0));
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, vtkPolyData::SafeDownCast(elevation->GetOutput()));
+#if VTK_MAJOR_VERSION < 8
+    mapper->ImmediateModeRenderingOff();
+#endif
+    mapper->ScalarVisibilityOn();
+    mapper->SetColorModeToMapScalars();
+    mapper->SetLookupTable(color_transfer);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->GetProperty()->SetInterpolationToFlat();
+    actor->GetProperty()->BackfaceCullingOn();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WPaintedCloud cv::viz::Widget::cast<cv::viz::WPaintedCloud>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WPaintedCloud&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Cloud Collection Widget implementation
+
+cv::viz::WCloudCollection::WCloudCollection()
+{
+    vtkSmartPointer<vtkAppendPolyData> append_filter = vtkSmartPointer<vtkAppendPolyData>::New();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    mapper->SetInputConnection(append_filter->GetOutputPort());
+    mapper->SetScalarModeToUsePointData();
+#if VTK_MAJOR_VERSION < 8
+    mapper->ImmediateModeRenderingOff();
+#endif
+    mapper->SetScalarRange(0, 255);
+    mapper->ScalarVisibilityOn();
+
+    vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
+    actor->SetNumberOfCloudPoints(1);
+    actor->GetProperty()->SetInterpolationToFlat();
+    actor->GetProperty()->BackfaceCullingOn();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+void cv::viz::WCloudCollection::addCloud(InputArray cloud, InputArray colors, const Affine3d &pose)
+{
+    vtkSmartPointer<vtkCloudMatSource> source = vtkSmartPointer<vtkCloudMatSource>::New();
+    source->SetColorCloud(cloud, colors);
+
+    vtkSmartPointer<vtkPolyData> polydata = VtkUtils::TransformPolydata(source->GetOutputPort(), pose);
+
+    vtkSmartPointer<vtkLODActor> actor = vtkLODActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Correctness check." && actor);
+
+    vtkSmartPointer<vtkAlgorithm> producer = actor->GetMapper()->GetInputConnection(0, 0)->GetProducer();
+    vtkSmartPointer<vtkAppendPolyData> append_filter = vtkAppendPolyData::SafeDownCast(producer);
+    VtkUtils::AddInputData(append_filter, polydata);
+
+    actor->SetNumberOfCloudPoints(std::max<vtkIdType>(1, actor->GetNumberOfCloudPoints() + polydata->GetNumberOfPoints()/10));
+}
+
+void cv::viz::WCloudCollection::addCloud(InputArray cloud, const Color &color, const Affine3d &pose)
+{
+    addCloud(cloud, Mat(cloud.size(), CV_8UC3, color), pose);
+}
+
+void cv::viz::WCloudCollection::finalize()
+{
+    vtkSmartPointer<vtkLODActor> actor = vtkLODActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Incompatible widget type." && actor);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
+    CV_Assert("Need to add at least one cloud." && mapper);
+
+    vtkSmartPointer<vtkAlgorithm> producer = mapper->GetInputConnection(0, 0)->GetProducer();
+    vtkSmartPointer<vtkAppendPolyData> append_filter = vtkAppendPolyData::SafeDownCast(producer);
+    append_filter->Update();
+
+    vtkSmartPointer<vtkPolyData> polydata = append_filter->GetOutput();
+    mapper->RemoveInputConnection(0, 0);
+    VtkUtils::SetInputData(mapper, polydata);
+}
+
+template<> cv::viz::WCloudCollection cv::viz::Widget::cast<cv::viz::WCloudCollection>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WCloudCollection&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Cloud Normals Widget implementation
+
+cv::viz::WCloudNormals::WCloudNormals(InputArray _cloud, InputArray _normals, int level, double scale, const Color &color)
+{
+    Mat cloud = _cloud.getMat();
+    Mat normals = _normals.getMat();
+
+    CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
+    CV_Assert(cloud.size() == normals.size() && cloud.type() == normals.type());
+
+    int sqlevel = (int)std::sqrt((double)level);
+    int ystep = (cloud.cols > 1 && cloud.rows > 1) ? sqlevel : 1;
+    int xstep = (cloud.cols > 1 && cloud.rows > 1) ? sqlevel : level;
+
+    vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+    points->SetDataType(cloud.depth() == CV_32F ? VTK_FLOAT : VTK_DOUBLE);
+
+    vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
+
+    int s_chs = cloud.channels();
+    int n_chs = normals.channels();
+    int total = 0;
+
+    for(int y = 0; y < cloud.rows; y += ystep)
+    {
+        if (cloud.depth() == CV_32F)
+        {
+            const float *srow = cloud.ptr<float>(y);
+            const float *send = srow + cloud.cols * s_chs;
+            const float *nrow = normals.ptr<float>(y);
+
+            for (; srow < send; srow += xstep * s_chs, nrow += xstep * n_chs)
+                if (!isNan(srow) && !isNan(nrow))
+                {
+                    Vec3f endp = Vec3f(srow) + Vec3f(nrow) * (float)scale;
+
+                    points->InsertNextPoint(srow);
+                    points->InsertNextPoint(endp.val);
+
+                    lines->InsertNextCell(2);
+                    lines->InsertCellPoint(total++);
+                    lines->InsertCellPoint(total++);
+                }
+        }
+        else
+        {
+            const double *srow = cloud.ptr<double>(y);
+            const double *send = srow + cloud.cols * s_chs;
+            const double *nrow = normals.ptr<double>(y);
+
+            for (; srow < send; srow += xstep * s_chs, nrow += xstep * n_chs)
+                if (!isNan(srow) && !isNan(nrow))
+                {
+                    Vec3d endp = Vec3d(srow) + Vec3d(nrow) * (double)scale;
+
+                    points->InsertNextPoint(srow);
+                    points->InsertNextPoint(endp.val);
+
+                    lines->InsertNextCell(2);
+                    lines->InsertCellPoint(total++);
+                    lines->InsertCellPoint(total++);
+                }
+        }
+    }
+
+    vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();
+    polydata->SetPoints(points);
+    polydata->SetLines(lines);
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WCloudNormals cv::viz::Widget::cast<cv::viz::WCloudNormals>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WCloudNormals&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Mesh Widget implementation
+
+cv::viz::WMesh::WMesh(const Mesh &mesh)
+{
+    CV_Assert(mesh.cloud.rows == 1 && mesh.polygons.type() == CV_32SC1);
+
+    vtkSmartPointer<vtkCloudMatSource> source = vtkSmartPointer<vtkCloudMatSource>::New();
+    source->SetColorCloudNormalsTCoords(mesh.cloud, mesh.colors, mesh.normals, mesh.tcoords);
+    source->Update();
+
+    Mat lookup_buffer(1, (int)mesh.cloud.total(), CV_32SC1);
+    int *lookup = lookup_buffer.ptr<int>();
+    for(int y = 0, index = 0; y < mesh.cloud.rows; ++y)
+    {
+        int s_chs = mesh.cloud.channels();
+
+        if (mesh.cloud.depth() == CV_32F)
+        {
+            const float* srow = mesh.cloud.ptr<float>(y);
+            const float* send = srow + mesh.cloud.cols * s_chs;
+
+            for (; srow != send; srow += s_chs, ++lookup)
+                if (!isNan(srow[0]) && !isNan(srow[1]) && !isNan(srow[2]))
+                    *lookup = index++;
+        }
+
+        if (mesh.cloud.depth() == CV_64F)
+        {
+            const double* srow = mesh.cloud.ptr<double>(y);
+            const double* send = srow + mesh.cloud.cols * s_chs;
+
+            for (; srow != send; srow += s_chs, ++lookup)
+                if (!isNan(srow[0]) && !isNan(srow[1]) && !isNan(srow[2]))
+                    *lookup = index++;
+        }
+    }
+    lookup = lookup_buffer.ptr<int>();
+
+    vtkSmartPointer<vtkPolyData> polydata = source->GetOutput();
+    polydata->SetVerts(0);
+
+    const int * polygons = mesh.polygons.ptr<int>();
+    vtkSmartPointer<vtkCellArray> cell_array = vtkSmartPointer<vtkCellArray>::New();
+
+    int idx = 0;
+    size_t polygons_size = mesh.polygons.total();
+    for (size_t i = 0; i < polygons_size; ++idx)
+    {
+        int n_points = polygons[i++];
+
+        cell_array->InsertNextCell(n_points);
+        for (int j = 0; j < n_points; ++j, ++idx)
+            cell_array->InsertCellPoint(lookup[polygons[i++]]);
+    }
+    cell_array->GetData()->SetNumberOfValues(idx);
+    cell_array->Squeeze();
+    polydata->SetStrips(cell_array);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    mapper->SetScalarModeToUsePointData();
+#if VTK_MAJOR_VERSION < 8
+    mapper->ImmediateModeRenderingOff();
+#endif
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    //actor->SetNumberOfCloudPoints(std::max(1, polydata->GetNumberOfPoints() / 10));
+    actor->GetProperty()->SetRepresentationToSurface();
+    actor->GetProperty()->BackfaceCullingOff(); // Backface culling is off for higher efficiency
+    actor->GetProperty()->SetInterpolationToFlat();
+    actor->GetProperty()->EdgeVisibilityOff();
+    actor->GetProperty()->ShadingOff();
+    actor->SetMapper(mapper);
+
+    if (!mesh.texture.empty())
+    {
+        vtkSmartPointer<vtkImageMatSource> image_source = vtkSmartPointer<vtkImageMatSource>::New();
+        image_source->SetImage(mesh.texture);
+
+        vtkSmartPointer<vtkTexture> texture = vtkSmartPointer<vtkTexture>::New();
+        texture->SetInputConnection(image_source->GetOutputPort());
+        actor->SetTexture(texture);
+    }
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WMesh::WMesh(InputArray cloud, InputArray polygons, InputArray colors, InputArray normals)
+{
+    Mesh mesh;
+    mesh.cloud = cloud.getMat();
+    mesh.colors = colors.getMat();
+    mesh.normals = normals.getMat();
+    mesh.polygons = polygons.getMat();
+    *this = WMesh(mesh);
+}
+
+template<> CV_EXPORTS cv::viz::WMesh cv::viz::Widget::cast<cv::viz::WMesh>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WMesh&>(widget);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Widget Merger implementation
+
+cv::viz::WWidgetMerger::WWidgetMerger()
+{
+    vtkSmartPointer<vtkAppendPolyData> append_filter = vtkSmartPointer<vtkAppendPolyData>::New();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    mapper->SetInputConnection(append_filter->GetOutputPort());
+    mapper->SetScalarModeToUsePointData();
+#if VTK_MAJOR_VERSION < 8
+    mapper->ImmediateModeRenderingOff();
+#endif
+    mapper->SetScalarRange(0, 255);
+    mapper->ScalarVisibilityOn();
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->GetProperty()->SetInterpolationToFlat();
+    actor->GetProperty()->BackfaceCullingOn();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+void cv::viz::WWidgetMerger::addWidget(const Widget3D& widget, const Affine3d &pose)
+{
+    vtkActor *widget_actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(widget));
+    CV_Assert("Widget is not 3D actor." && widget_actor);
+
+    vtkSmartPointer<vtkPolyDataMapper> widget_mapper = vtkPolyDataMapper::SafeDownCast(widget_actor->GetMapper());
+    CV_Assert("Widget doesn't have a polydata mapper" && widget_mapper);
+    widget_mapper->Update();
+
+    vtkSmartPointer<vtkActor> actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    vtkSmartPointer<vtkAlgorithm> producer = actor->GetMapper()->GetInputConnection(0, 0)->GetProducer();
+    vtkSmartPointer<vtkAppendPolyData> append_filter = vtkAppendPolyData::SafeDownCast(producer);
+    CV_Assert("Correctness check" && append_filter);
+
+    VtkUtils::AddInputData(append_filter, VtkUtils::TransformPolydata(widget_mapper->GetInput(), pose));
+}
+
+void cv::viz::WWidgetMerger::finalize()
+{
+    vtkSmartPointer<vtkActor> actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    vtkSmartPointer<vtkAlgorithm> producer = actor->GetMapper()->GetInputConnection(0, 0)->GetProducer();
+    vtkSmartPointer<vtkAppendPolyData> append_filter = vtkAppendPolyData::SafeDownCast(producer);
+    CV_Assert("Correctness check" && append_filter);
+    append_filter->Update();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
+    mapper->RemoveInputConnection(0, 0);
+    VtkUtils::SetInputData(mapper, append_filter->GetOutput());
+    mapper->Modified();
+}
+
+template<> CV_EXPORTS cv::viz::WWidgetMerger cv::viz::Widget::cast<cv::viz::WWidgetMerger>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WWidgetMerger&>(widget);
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/precomp.hpp
new file mode 100644
index 00000000..4c4bf7c5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/precomp.hpp
@@ -0,0 +1,350 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef __OPENCV_VIZ_PRECOMP_HPP__
+#define __OPENCV_VIZ_PRECOMP_HPP__
+
+#include <map>
+#include <ctime>
+#include <list>
+#include <vector>
+#include <iomanip>
+#include <limits>
+
+#include <vtkVersionMacros.h>
+#include <vtkAppendPolyData.h>
+#include <vtkAssemblyPath.h>
+#include <vtkCellData.h>
+#include <vtkLineSource.h>
+#include <vtkPropPicker.h>
+#include <vtkSmartPointer.h>
+#include <vtkDataSet.h>
+#include <vtkPolygon.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkDiskSource.h>
+#include <vtkPlaneSource.h>
+#include <vtkSphereSource.h>
+#include <vtkArrowSource.h>
+#include <vtkOutlineSource.h>
+#include <vtkTransform.h>
+#include <vtkTransformPolyDataFilter.h>
+#include <vtkTubeFilter.h>
+#include <vtkCubeSource.h>
+#include <vtkAxes.h>
+#include <vtkFloatArray.h>
+#include <vtkDoubleArray.h>
+#include <vtkPointData.h>
+#include <vtkPolyData.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkDataSetMapper.h>
+#include <vtkCellArray.h>
+#include <vtkCommand.h>
+#include <vtkPLYReader.h>
+#include <vtkPolyLine.h>
+#include <vtkVectorText.h>
+#include <vtkFollower.h>
+#include <vtkInteractorStyle.h>
+#include <vtkUnsignedCharArray.h>
+#include <vtkRendererCollection.h>
+#include <vtkPNGWriter.h>
+#include <vtkWindowToImageFilter.h>
+#include <vtkInteractorStyleTrackballCamera.h>
+#include <vtkProperty.h>
+#include <vtkCamera.h>
+#include <vtkPlanes.h>
+#include <vtkImageFlip.h>
+#include <vtkRenderWindow.h>
+#include <vtkTextProperty.h>
+#include <vtkProperty2D.h>
+#include <vtkLODActor.h>
+#include <vtkActor.h>
+#include <vtkTextActor.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkMath.h>
+#include <vtkExtractEdges.h>
+#include <vtkFrustumSource.h>
+#include <vtkTexture.h>
+#include <vtkTextureMapToPlane.h>
+#include <vtkPolyDataNormals.h>
+#include <vtkAlgorithmOutput.h>
+#include <vtkImageMapper.h>
+#include <vtkPoints.h>
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
+#include <vtkObjectFactory.h>
+#include <vtkPolyDataAlgorithm.h>
+#include <vtkMergeFilter.h>
+#include <vtkErrorCode.h>
+#include <vtkPLYWriter.h>
+#include <vtkSTLWriter.h>
+#include <vtkPLYReader.h>
+#include <vtkOBJReader.h>
+#include <vtkSTLReader.h>
+#include <vtkPNGReader.h>
+#include <vtkOBJExporter.h>
+#include <vtkVRMLExporter.h>
+#include <vtkTensorGlyph.h>
+#include <vtkImageAlgorithm.h>
+#include <vtkTransformFilter.h>
+#include <vtkConeSource.h>
+#include <vtkElevationFilter.h>
+#include <vtkColorTransferFunction.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+#include <vtkLight.h>
+#include <vtkCallbackCommand.h>
+#include <vtkVersion.h>
+
+#if !defined(_WIN32) || defined(__CYGWIN__)
+# include <unistd.h> /* unlink */
+#else
+# include <io.h> /* unlink */
+#endif
+
+#include "vtk/vtkOBJWriter.h"
+#include "vtk/vtkXYZWriter.h"
+#include "vtk/vtkXYZReader.h"
+#include "vtk/vtkCloudMatSink.h"
+#include "vtk/vtkCloudMatSource.h"
+#include "vtk/vtkTrajectorySource.h"
+#include "vtk/vtkImageMatSource.h"
+
+#if VTK_MAJOR_VERSION >= 9
+typedef vtkIdType const * CellIterT;
+#else
+typedef vtkIdType * CellIterT;
+#endif
+
+#include <opencv2/core.hpp>
+#include <opencv2/viz.hpp>
+#include <opencv2/viz/widget_accessor.hpp>
+#include <opencv2/core/utility.hpp>
+
+
+namespace cv
+{
+    namespace viz
+    {
+        typedef std::map<String, vtkSmartPointer<vtkProp> > WidgetActorMap;
+
+        struct VizMap
+        {
+            typedef std::map<String, Viz3d> type;
+            typedef type::iterator iterator;
+
+            type m;
+            ~VizMap();
+            void replace_clear();
+        };
+
+        class VizStorage
+        {
+        public:
+            static void unregisterAll();
+
+            //! window names automatically have Viz - prefix even though not provided by the users
+            static String generateWindowName(const String &window_name);
+
+        private:
+            VizStorage(); // Static
+
+            static void add(const Viz3d& window);
+            static Viz3d& get(const String &window_name);
+            static void remove(const String &window_name);
+            static bool windowExists(const String &window_name);
+            static void removeUnreferenced();
+
+            static VizMap storage;
+            friend class Viz3d;
+
+            static VizStorage init;
+        };
+
+        template<typename _Tp> inline _Tp normalized(const _Tp& v) { return v * 1/norm(v); }
+
+        template<typename _Tp> inline bool isNan(const _Tp* data)
+        {
+            return isNan(data[0]) || isNan(data[1]) || isNan(data[2]);
+        }
+
+        inline vtkSmartPointer<vtkActor> getActor(const Widget3D& widget)
+        {
+            return vtkActor::SafeDownCast(WidgetAccessor::getProp(widget));
+        }
+
+        inline vtkSmartPointer<vtkPolyData> getPolyData(const Widget3D& widget)
+        {
+            vtkSmartPointer<vtkMapper> mapper = getActor(widget)->GetMapper();
+            return vtkPolyData::SafeDownCast(mapper->GetInput());
+        }
+
+        inline vtkSmartPointer<vtkMatrix4x4> vtkmatrix(const cv::Matx44d &matrix)
+        {
+            vtkSmartPointer<vtkMatrix4x4> vtk_matrix = vtkSmartPointer<vtkMatrix4x4>::New();
+            vtk_matrix->DeepCopy(matrix.val);
+            return vtk_matrix;
+        }
+
+        inline Color vtkcolor(const Color& color)
+        {
+            Color scaled_color = color * (1.0/255.0);
+            std::swap(scaled_color[0], scaled_color[2]);
+            return scaled_color;
+        }
+
+        inline Vec3d get_random_vec(double from = -10.0, double to = 10.0)
+        {
+            RNG& rng = theRNG();
+            return Vec3d(rng.uniform(from, to), rng.uniform(from, to), rng.uniform(from, to));
+        }
+
+        struct VtkUtils
+        {
+            template<class Filter>
+            static void SetInputData(vtkSmartPointer<Filter> filter, vtkPolyData* polydata)
+            {
+            #if VTK_MAJOR_VERSION <= 5
+                filter->SetInput(polydata);
+            #else
+                filter->SetInputData(polydata);
+            #endif
+            }
+            template<class Filter>
+            static void SetSourceData(vtkSmartPointer<Filter> filter, vtkPolyData* polydata)
+            {
+            #if VTK_MAJOR_VERSION <= 5
+                filter->SetSource(polydata);
+            #else
+                filter->SetSourceData(polydata);
+            #endif
+            }
+
+            template<class Filter>
+            static void SetInputData(vtkSmartPointer<Filter> filter, vtkImageData* polydata)
+            {
+            #if VTK_MAJOR_VERSION <= 5
+                filter->SetInput(polydata);
+            #else
+                filter->SetInputData(polydata);
+            #endif
+            }
+
+            template<class Filter>
+            static void AddInputData(vtkSmartPointer<Filter> filter, vtkPolyData *polydata)
+            {
+            #if VTK_MAJOR_VERSION <= 5
+                filter->AddInput(polydata);
+            #else
+                filter->AddInputData(polydata);
+            #endif
+            }
+
+            static vtkSmartPointer<vtkUnsignedCharArray> FillScalars(size_t size, const Color& color)
+            {
+                Vec3b rgb = Vec3d(color[2], color[1], color[0]);
+                Vec3b* color_data = new Vec3b[size];
+                std::fill(color_data, color_data + size, rgb);
+
+                vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
+                scalars->SetName("Colors");
+                scalars->SetNumberOfComponents(3);
+                scalars->SetNumberOfTuples((vtkIdType)size);
+                scalars->SetArray(color_data->val, (vtkIdType)(size * 3), 0, vtkUnsignedCharArray::VTK_DATA_ARRAY_DELETE);
+                return scalars;
+            }
+
+            static vtkSmartPointer<vtkPolyData> FillScalars(vtkSmartPointer<vtkPolyData> polydata, const Color& color)
+            {
+                return polydata->GetPointData()->SetScalars(FillScalars(polydata->GetNumberOfPoints(), color)), polydata;
+            }
+
+            static vtkSmartPointer<vtkPolyData> ComputeNormals(vtkSmartPointer<vtkPolyData> polydata)
+            {
+                vtkSmartPointer<vtkPolyDataNormals> normals_generator = vtkSmartPointer<vtkPolyDataNormals>::New();
+                normals_generator->ComputePointNormalsOn();
+                normals_generator->ComputeCellNormalsOff();
+                normals_generator->SetFeatureAngle(0.1);
+                normals_generator->SetSplitting(0);
+                normals_generator->SetConsistency(1);
+                normals_generator->SetAutoOrientNormals(0);
+                normals_generator->SetFlipNormals(0);
+                normals_generator->SetNonManifoldTraversal(1);
+                VtkUtils::SetInputData(normals_generator, polydata);
+                normals_generator->Update();
+                return normals_generator->GetOutput();
+            }
+
+            static vtkSmartPointer<vtkPolyData> TransformPolydata(vtkSmartPointer<vtkAlgorithmOutput> algorithm_output_port, const Affine3d& pose)
+            {
+                vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
+                transform->SetMatrix(vtkmatrix(pose.matrix));
+
+                vtkSmartPointer<vtkTransformPolyDataFilter> transform_filter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+                transform_filter->SetTransform(transform);
+                transform_filter->SetInputConnection(algorithm_output_port);
+                transform_filter->Update();
+                return transform_filter->GetOutput();
+            }
+
+            static vtkSmartPointer<vtkPolyData> TransformPolydata(vtkSmartPointer<vtkPolyData> polydata, const Affine3d& pose)
+            {
+                vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
+                transform->SetMatrix(vtkmatrix(pose.matrix));
+
+                vtkSmartPointer<vtkTransformPolyDataFilter> transform_filter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+                VtkUtils::SetInputData(transform_filter, polydata);
+                transform_filter->SetTransform(transform);
+                transform_filter->Update();
+                return transform_filter->GetOutput();
+            }
+        };
+
+        vtkSmartPointer<vtkRenderWindowInteractor> vtkCocoaRenderWindowInteractorNew();
+    }
+}
+
+#include "vtk/vtkVizInteractorStyle.hpp"
+#include "vizimpl.hpp"
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/shapes.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/shapes.cpp
new file mode 100644
index 00000000..399106dd
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/shapes.cpp
@@ -0,0 +1,1107 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "precomp.hpp"
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// line widget implementation
+cv::viz::WLine::WLine(const Point3d &pt1, const Point3d &pt2, const Color &color)
+{
+    vtkSmartPointer<vtkLineSource> line = vtkSmartPointer<vtkLineSource>::New();
+    line->SetPoint1(pt1.x, pt1.y, pt1.z);
+    line->SetPoint2(pt2.x, pt2.y, pt2.z);
+    line->Update();
+
+    vtkSmartPointer<vtkPolyData> polydata = line->GetOutput();
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WLine cv::viz::Widget::cast<cv::viz::WLine>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WLine&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// sphere widget implementation
+
+cv::viz::WSphere::WSphere(const Point3d &center, double radius, int sphere_resolution, const Color &color)
+{
+    vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
+    sphere->SetRadius(radius);
+    sphere->SetCenter(center.x, center.y, center.z);
+    sphere->SetPhiResolution(sphere_resolution);
+    sphere->SetThetaResolution(sphere_resolution);
+    sphere->LatLongTessellationOff();
+    sphere->Update();
+
+    vtkSmartPointer<vtkPolyData> polydata = sphere->GetOutput();
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WSphere cv::viz::Widget::cast<cv::viz::WSphere>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WSphere&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// plane widget implementation
+
+cv::viz::WPlane::WPlane(const Size2d& size, const Color &color)
+{
+    vtkSmartPointer<vtkPlaneSource> plane = vtkSmartPointer<vtkPlaneSource>::New();
+    plane->SetOrigin(-0.5 * size.width, -0.5 * size.height, 0.0);
+    plane->SetPoint1( 0.5 * size.width, -0.5 * size.height, 0.0);
+    plane->SetPoint2(-0.5 * size.width,  0.5 * size.height, 0.0);
+    plane->Update();
+
+    vtkSmartPointer<vtkPolyData> polydata = plane->GetOutput();
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+    actor->GetProperty()->LightingOff();
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WPlane::WPlane(const Point3d& center, const Vec3d& normal, const Vec3d& new_yaxis, const Size2d& size, const Color &color)
+{
+    Vec3d zvec = normalize(normal);
+    Vec3d xvec = normalize(new_yaxis.cross(zvec));
+    Vec3d yvec = zvec.cross(xvec);
+
+    WPlane plane(size, color);
+    plane.applyTransform(makeTransformToGlobal(xvec, yvec, zvec, center));
+    *this = plane;
+}
+
+template<> cv::viz::WPlane cv::viz::Widget::cast<cv::viz::WPlane>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WPlane&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// arrow widget implementation
+
+cv::viz::WArrow::WArrow(const Point3d& pt1, const Point3d& pt2, double thickness, const Color &color)
+{
+    vtkSmartPointer<vtkArrowSource> arrow_source = vtkSmartPointer<vtkArrowSource>::New();
+    arrow_source->SetShaftRadius(thickness);
+    arrow_source->SetTipRadius(thickness * 3.0);
+    arrow_source->SetTipLength(thickness * 10.0);
+
+    Vec3d arbitrary = get_random_vec();
+    Vec3d start_point(pt1.x, pt1.y, pt1.z), end_point(pt2.x, pt2.y, pt2.z);
+
+    double length = norm(end_point - start_point);
+
+    Vec3d xvec = normalized(end_point - start_point);
+    Vec3d zvec = normalized(xvec.cross(arbitrary));
+    Vec3d yvec = zvec.cross(xvec);
+
+    Matx33d R = makeTransformToGlobal(xvec, yvec, zvec).rotation();
+    Affine3d transform_with_scale(R * length, start_point);
+
+    vtkSmartPointer<vtkPolyData> polydata = VtkUtils::TransformPolydata(arrow_source->GetOutputPort(), transform_with_scale);
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WArrow cv::viz::Widget::cast<cv::viz::WArrow>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WArrow&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// circle widget implementation
+
+cv::viz::WCircle::WCircle(double radius, double thickness, const Color &color)
+{
+    vtkSmartPointer<vtkDiskSource> disk = vtkSmartPointer<vtkDiskSource>::New();
+    disk->SetCircumferentialResolution(30);
+    disk->SetInnerRadius(radius - thickness);
+    disk->SetOuterRadius(radius + thickness);
+    disk->Update();
+
+    vtkSmartPointer<vtkPolyData> polydata = disk->GetOutput();
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->GetProperty()->LightingOff();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WCircle::WCircle(double radius, const Point3d& center, const Vec3d& normal, double thickness, const Color &color)
+{
+    Vec3d arbitrary = get_random_vec();
+    Vec3d zvec = normalized(normal);
+    Vec3d xvec = normalized(zvec.cross(arbitrary));
+    Vec3d yvec = zvec.cross(xvec);
+
+    WCircle circle(radius, thickness, color);
+    circle.applyTransform(makeTransformToGlobal(xvec, yvec, zvec, center));
+    *this = circle;
+}
+
+template<> cv::viz::WCircle cv::viz::Widget::cast<cv::viz::WCircle>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WCircle&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// WCone widget implementation
+
+cv::viz::WCone::WCone(double length, double radius, int resolution, const Color &color)
+{
+    vtkSmartPointer<vtkConeSource> cone_source = vtkSmartPointer<vtkConeSource>::New();
+    cone_source->SetCenter(length*0.5, 0.0, 0.0);
+    cone_source->SetHeight(length);
+    cone_source->SetRadius(radius);
+    cone_source->SetResolution(resolution);
+    cone_source->Update();
+
+    vtkSmartPointer<vtkPolyData> polydata = cone_source->GetOutput();
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WCone::WCone(double radius, const Point3d& center, const Point3d& tip, int resolution, const Color &color)
+{
+    Vec3d arbitrary = get_random_vec();
+    Vec3d xvec = normalized(Vec3d(tip - center));
+    Vec3d zvec = normalized(xvec.cross(arbitrary));
+    Vec3d yvec = zvec.cross(xvec);
+
+    WCone circle(norm(tip - center), radius, resolution, color);
+    circle.applyTransform(makeTransformToGlobal(xvec, yvec, zvec, center));
+    *this = circle;
+}
+
+template<> cv::viz::WCone cv::viz::Widget::cast<cv::viz::WCone>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WCone&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// cylinder widget implementation
+
+cv::viz::WCylinder::WCylinder(const Point3d& axis_point1, const Point3d& axis_point2, double radius, int numsides, const Color &color)
+{
+    vtkSmartPointer<vtkLineSource> line = vtkSmartPointer<vtkLineSource>::New();
+    line->SetPoint1(axis_point1.x, axis_point1.y, axis_point1.z);
+    line->SetPoint2(axis_point2.x, axis_point2.y, axis_point2.z);
+
+    vtkSmartPointer<vtkTubeFilter> tuber = vtkSmartPointer<vtkTubeFilter>::New();
+    tuber->SetInputConnection(line->GetOutputPort());
+    tuber->SetNumberOfSides(numsides);
+    tuber->SetRadius(radius);
+    tuber->Update();
+
+    vtkSmartPointer<vtkPolyData> polydata = tuber->GetOutput();
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WCylinder cv::viz::Widget::cast<cv::viz::WCylinder>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WCylinder&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// cylinder widget implementation
+
+cv::viz::WCube::WCube(const Point3d& min_point, const Point3d& max_point, bool wire_frame, const Color &color)
+{
+    double bounds[6];
+    bounds[0] = std::min(min_point.x, max_point.x);
+    bounds[1] = std::max(min_point.x, max_point.x);
+    bounds[2] = std::min(min_point.y, max_point.y);
+    bounds[3] = std::max(min_point.y, max_point.y);
+    bounds[4] = std::min(min_point.z, max_point.z);
+    bounds[5] = std::max(min_point.z, max_point.z);
+
+    vtkSmartPointer<vtkPolyDataAlgorithm> cube;
+    if (wire_frame)
+    {
+        cube = vtkSmartPointer<vtkOutlineSource>::New();
+        vtkOutlineSource::SafeDownCast(cube)->SetBounds(bounds);
+    }
+    else
+    {
+        cube = vtkSmartPointer<vtkCubeSource>::New();
+        vtkCubeSource::SafeDownCast(cube)->SetBounds(bounds);
+    }
+    cube->Update();
+    vtkSmartPointer<vtkPolyData> polydata =cube->GetOutput();
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WCube cv::viz::Widget::cast<cv::viz::WCube>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WCube&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// coordinate system widget implementation
+
+cv::viz::WCoordinateSystem::WCoordinateSystem(double scale)
+{
+    vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New();
+    axes->SetOrigin(0, 0, 0);
+    axes->SetScaleFactor(scale);
+    axes->Update();
+
+    vtkSmartPointer<vtkUnsignedCharArray> colors = vtkSmartPointer<vtkUnsignedCharArray>::New();
+    colors->SetNumberOfComponents(3);
+    colors->InsertNextTuple3(255, 0, 0);
+    colors->InsertNextTuple3(255, 0, 0);
+    colors->InsertNextTuple3(0, 255, 0);
+    colors->InsertNextTuple3(0, 255, 0);
+    colors->InsertNextTuple3(0, 0, 255);
+    colors->InsertNextTuple3(0, 0, 255);
+
+    vtkSmartPointer<vtkPolyData> polydata = axes->GetOutput();
+    polydata->GetPointData()->SetScalars(colors);
+
+    vtkSmartPointer<vtkTubeFilter> tube_filter = vtkSmartPointer<vtkTubeFilter>::New();
+    VtkUtils::SetInputData(tube_filter, polydata);
+    tube_filter->SetRadius(axes->GetScaleFactor() / 50.0);
+    tube_filter->SetNumberOfSides(6);
+    tube_filter->Update();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    mapper->SetScalarModeToUsePointData();
+    VtkUtils::SetInputData(mapper, tube_filter->GetOutput());
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WCoordinateSystem cv::viz::Widget::cast<cv::viz::WCoordinateSystem>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WCoordinateSystem&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// polyline widget implementation
+
+cv::viz::WPolyLine::WPolyLine(InputArray points, InputArray colors)
+{
+    vtkSmartPointer<vtkCloudMatSource> cloud_source = vtkSmartPointer<vtkCloudMatSource>::New();
+    cloud_source->SetColorCloud(points, colors);
+    cloud_source->Update();
+
+    vtkSmartPointer<vtkPolyData> polydata = cloud_source->GetOutput();
+
+    vtkSmartPointer<vtkCellArray> cell_array = vtkSmartPointer<vtkCellArray>::New();
+    cell_array->Allocate(cell_array->EstimateSize(1, polydata->GetNumberOfPoints()));
+    cell_array->InsertNextCell(polydata->GetNumberOfPoints());
+    for(vtkIdType i = 0; i < polydata->GetNumberOfPoints(); ++i)
+        cell_array->InsertCellPoint(i);
+
+    polydata->SetLines(cell_array);
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+    mapper->SetScalarRange(0, 255);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WPolyLine::WPolyLine(InputArray points, const Color &color)
+{
+    WPolyLine polyline(points, Mat(points.size(), CV_8UC3, color));
+    *this = polyline;
+}
+
+template<> cv::viz::WPolyLine cv::viz::Widget::cast<cv::viz::WPolyLine>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WPolyLine&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// grid widget implementation
+
+
+cv::viz::WGrid::WGrid(const Vec2i &cells, const Vec2d &cells_spacing, const Color &color)
+{
+    vtkSmartPointer<vtkImageData> grid_data = vtkSmartPointer<vtkImageData>::New();
+
+    // Add 1 to dimensions because in ImageData dimensions is the number of lines
+    // - however here it means number of cells
+    grid_data->SetDimensions(cells[0]+1, cells[1]+1, 1);
+    grid_data->SetSpacing(cells_spacing[0], cells_spacing[1], 0.);
+
+    // Set origin of the grid to be the middle of the grid
+    grid_data->SetOrigin(cells[0] * cells_spacing[0] * (-0.5), cells[1] * cells_spacing[1] * (-0.5), 0);
+
+    // Extract the edges so we have the grid
+    vtkSmartPointer<vtkExtractEdges> extract_edges = vtkSmartPointer<vtkExtractEdges>::New();
+    VtkUtils::SetInputData(extract_edges, grid_data);
+    extract_edges->Update();
+
+    vtkSmartPointer<vtkPolyData> polydata = extract_edges->GetOutput();
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WGrid::WGrid(const Point3d& center, const Vec3d& normal, const Vec3d& new_yaxis, const Vec2i &cells, const Vec2d &cells_spacing, const Color &color)
+{
+    Vec3d zvec = normalize(normal);
+    Vec3d xvec = normalize(new_yaxis.cross(zvec));
+    Vec3d yvec = zvec.cross(xvec);
+
+    WGrid grid(cells, cells_spacing, color);
+    grid.applyTransform(makeTransformToGlobal(xvec, yvec, zvec, center));
+    *this = grid;
+}
+
+template<> cv::viz::WGrid cv::viz::Widget::cast<cv::viz::WGrid>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WGrid&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// text3D widget implementation
+
+cv::viz::WText3D::WText3D(const String &text, const Point3d &position, double text_scale, bool face_camera, const Color &color)
+{
+    vtkSmartPointer<vtkVectorText> textSource = vtkSmartPointer<vtkVectorText>::New();
+    textSource->SetText(text.c_str());
+    textSource->Update();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    mapper->SetInputConnection(textSource->GetOutputPort());
+
+    if (face_camera)
+    {
+        vtkSmartPointer<vtkFollower> actor = vtkSmartPointer<vtkFollower>::New();
+        actor->SetMapper(mapper);
+        actor->SetPosition(position.x, position.y, position.z);
+        actor->SetScale(text_scale);
+        WidgetAccessor::setProp(*this, actor);
+    }
+    else
+    {
+        vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+        actor->SetMapper(mapper);
+        actor->SetPosition(position.x, position.y, position.z);
+        actor->SetScale(text_scale);
+        actor->GetProperty()->LightingOff();
+        WidgetAccessor::setProp(*this, actor);
+    }
+
+    setColor(color);
+}
+
+void cv::viz::WText3D::setText(const String &text)
+{
+    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("This widget does not support text." && actor);
+
+    // Update text source
+    vtkPolyDataMapper *mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
+    vtkVectorText * textSource = vtkVectorText::SafeDownCast(mapper->GetInputConnection(0,0)->GetProducer());
+    CV_Assert("This widget does not support text." && textSource);
+
+    textSource->SetText(text.c_str());
+    textSource->Modified();
+    textSource->Update();
+}
+
+cv::String cv::viz::WText3D::getText() const
+{
+    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("This widget does not support text." && actor);
+
+    vtkPolyDataMapper *mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
+    vtkVectorText * textSource = vtkVectorText::SafeDownCast(mapper->GetInputConnection(0,0)->GetProducer());
+    CV_Assert("This widget does not support text." && textSource);
+
+    return textSource->GetText();
+}
+
+template<> cv::viz::WText3D cv::viz::Widget::cast<cv::viz::WText3D>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WText3D&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// text widget implementation
+
+cv::viz::WText::WText(const String &text, const Point &pos, int font_size, const Color &color)
+{
+    vtkSmartPointer<vtkTextActor> actor = vtkSmartPointer<vtkTextActor>::New();
+    actor->SetDisplayPosition(pos.x, pos.y);
+    actor->SetInput(text.c_str());
+
+    actor->GetProperty()->SetDisplayLocationToForeground();
+
+    vtkSmartPointer<vtkTextProperty> tprop = actor->GetTextProperty();
+    tprop->SetFontSize(font_size);
+    tprop->SetFontFamilyToCourier();
+    tprop->SetJustificationToLeft();
+    tprop->BoldOn();
+
+    Color c = vtkcolor(color);
+    tprop->SetColor(c.val);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WText cv::viz::Widget::cast<cv::viz::WText>() const
+{
+    Widget2D widget = this->cast<Widget2D>();
+    return static_cast<WText&>(widget);
+}
+
+void cv::viz::WText::setText(const String &text)
+{
+    vtkTextActor *actor = vtkTextActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("This widget does not support text." && actor);
+    actor->SetInput(text.c_str());
+}
+
+cv::String cv::viz::WText::getText() const
+{
+    vtkTextActor *actor = vtkTextActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("This widget does not support text." && actor);
+    return actor->GetInput();
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// image overlay widget implementation
+
+cv::viz::WImageOverlay::WImageOverlay(InputArray image, const Rect &rect)
+{
+    CV_Assert(!image.empty() && image.depth() == CV_8U);
+    vtkSmartPointer<vtkImageMatSource> source = vtkSmartPointer<vtkImageMatSource>::New();
+    source->SetImage(image);
+    Size sz = image.size();
+
+    // Scale the image based on the Rect, and flip to match y-ais orientation
+    vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
+    transform->Scale(sz.width/(double)rect.width, sz.height/(double)rect.height, 1.0);
+    transform->RotateX(180);
+
+    vtkSmartPointer<vtkImageReslice> image_reslice = vtkSmartPointer<vtkImageReslice>::New();
+    image_reslice->SetResliceTransform(transform);
+    image_reslice->SetInputConnection(source->GetOutputPort());
+    image_reslice->SetOutputDimensionality(2);
+    image_reslice->InterpolateOn();
+    image_reslice->AutoCropOutputOn();
+    image_reslice->Update();
+
+    vtkSmartPointer<vtkImageMapper> image_mapper = vtkSmartPointer<vtkImageMapper>::New();
+    image_mapper->SetInputConnection(image_reslice->GetOutputPort());
+    image_mapper->SetColorWindow(255); // OpenCV color
+    image_mapper->SetColorLevel(127.5);
+
+    vtkSmartPointer<vtkActor2D> actor = vtkSmartPointer<vtkActor2D>::New();
+    actor->SetMapper(image_mapper);
+    actor->SetPosition(rect.x, rect.y);
+    actor->GetProperty()->SetDisplayLocationToForeground();
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+void cv::viz::WImageOverlay::setImage(InputArray image)
+{
+    CV_Assert(!image.empty() && image.depth() == CV_8U);
+
+    vtkActor2D *actor = vtkActor2D::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("This widget does not support overlay image." && actor);
+
+    vtkImageMapper *mapper = vtkImageMapper::SafeDownCast(actor->GetMapper());
+    CV_Assert("This widget does not support overlay image." && mapper);
+    \
+    Vec6i extent;
+    mapper->GetInput()->GetExtent(extent.val);
+    Size size(extent[1], extent[3]);
+
+    // Create the vtk image and set its parameters based on input image
+    vtkSmartPointer<vtkImageMatSource> source = vtkSmartPointer<vtkImageMatSource>::New();
+    source->SetImage(image);
+    Size sz = image.size();
+
+    // Scale the image based on the Rect, and flip to match y-ais orientation
+    vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
+    transform->Scale(sz.width/(double)size.width, sz.height/(double)size.height, 1.0);
+    transform->RotateX(180);
+
+    vtkSmartPointer<vtkImageReslice> image_reslice = vtkSmartPointer<vtkImageReslice>::New();
+    image_reslice->SetResliceTransform(transform);
+    image_reslice->SetInputConnection(source->GetOutputPort());
+    image_reslice->SetOutputDimensionality(2);
+    image_reslice->InterpolateOn();
+    image_reslice->AutoCropOutputOn();
+    image_reslice->Update();
+
+    mapper->SetInputConnection(image_reslice->GetOutputPort());
+}
+
+template<> cv::viz::WImageOverlay cv::viz::Widget::cast<cv::viz::WImageOverlay>() const
+{
+    Widget2D widget = this->cast<Widget2D>();
+    return static_cast<WImageOverlay&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// image 3D widget implementation
+
+cv::viz::WImage3D::WImage3D(InputArray image, const Size2d &size)
+{
+    CV_Assert(!image.empty() && image.depth() == CV_8U);
+
+    vtkSmartPointer<vtkImageMatSource> source = vtkSmartPointer<vtkImageMatSource>::New();
+    source->SetImage(image);
+
+    vtkSmartPointer<vtkTexture> texture = vtkSmartPointer<vtkTexture>::New();
+    texture->SetInputConnection(source->GetOutputPort());
+
+    vtkSmartPointer<vtkPlaneSource> plane = vtkSmartPointer<vtkPlaneSource>::New();
+    plane->SetOrigin(-0.5 * size.width, -0.5 * size.height, 0.0);
+    plane->SetPoint1( 0.5 * size.width, -0.5 * size.height, 0.0);
+    plane->SetPoint2(-0.5 * size.width,  0.5 * size.height, 0.0);
+
+    vtkSmartPointer<vtkTextureMapToPlane> textured_plane = vtkSmartPointer<vtkTextureMapToPlane>::New();
+    textured_plane->SetInputConnection(plane->GetOutputPort());
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    mapper->SetInputConnection(textured_plane->GetOutputPort());
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+    actor->SetTexture(texture);
+    actor->GetProperty()->ShadingOff();
+    actor->GetProperty()->LightingOff();
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WImage3D::WImage3D(InputArray image, const Size2d &size, const Vec3d &center, const Vec3d &normal, const Vec3d &up_vector)
+{
+    CV_Assert(!image.empty() && image.depth() == CV_8U);
+
+    // Compute the transformation matrix for drawing the camera frame in a scene
+    Vec3d n = normalize(normal);
+    Vec3d u = normalize(up_vector.cross(n));
+    Vec3d v = n.cross(u);
+    Affine3d pose = makeTransformToGlobal(u, v, n, center);
+
+    WImage3D image3d(image, size);
+    image3d.applyTransform(pose);
+    *this = image3d;
+}
+
+void cv::viz::WImage3D::setImage(InputArray image)
+{
+    CV_Assert(!image.empty() && image.depth() == CV_8U);
+
+    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("This widget does not support 3D image." && actor);
+
+    vtkSmartPointer<vtkImageMatSource> source = vtkSmartPointer<vtkImageMatSource>::New();
+    source->SetImage(image);
+
+    vtkSmartPointer<vtkTexture> texture = vtkSmartPointer<vtkTexture>::New();
+    texture->SetInputConnection(source->GetOutputPort());
+
+    actor->SetTexture(texture);
+}
+
+void cv::viz::WImage3D::setSize(const cv::Size& size)
+{
+    vtkSmartPointer<vtkActor> actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
+    vtkSmartPointer<vtkTextureMapToPlane> textured_plane;
+    vtkSmartPointer<vtkPlaneSource> plane;
+    #if VTK_MAJOR_VERSION <= 5
+        textured_plane = vtkTextureMapToPlane::SafeDownCast(mapper->GetInputConnection(0,0)->GetProducer());
+        plane = vtkPlaneSource::SafeDownCast(textured_plane->GetInputConnection(0,0)->GetProducer());
+    #else
+        textured_plane = vtkTextureMapToPlane::SafeDownCast(mapper->GetInputAlgorithm());
+        plane = vtkPlaneSource::SafeDownCast(textured_plane->GetInputAlgorithm());
+    #endif
+    plane->SetOrigin(-0.5 * size.width, -0.5 * size.height, 0.0);
+    plane->SetPoint1( 0.5 * size.width, -0.5 * size.height, 0.0);
+    plane->SetPoint2(-0.5 * size.width,  0.5 * size.height, 0.0);
+}
+
+template<> cv::viz::WImage3D cv::viz::Widget::cast<cv::viz::WImage3D>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WImage3D&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// camera position widget implementation
+
+namespace  cv  { namespace viz { namespace
+{
+    struct CameraPositionUtils
+    {
+        static vtkSmartPointer<vtkPolyData> createFrustum(double aspect_ratio, double fovy, double scale)
+        {
+            vtkSmartPointer<vtkCamera> camera = vtkSmartPointer<vtkCamera>::New();
+            camera->SetViewAngle(fovy);
+            camera->SetPosition(0.0, 0.0, 0.0);
+            camera->SetViewUp(0.0, 1.0, 0.0);
+            camera->SetFocalPoint(0.0, 0.0, 1.0);
+            camera->SetClippingRange(1e-9, scale);
+
+            double planes_array[24];
+            camera->GetFrustumPlanes(aspect_ratio, planes_array);
+
+            vtkSmartPointer<vtkPlanes> planes = vtkSmartPointer<vtkPlanes>::New();
+            planes->SetFrustumPlanes(planes_array);
+
+            vtkSmartPointer<vtkFrustumSource> frustumSource = vtkSmartPointer<vtkFrustumSource>::New();
+            frustumSource->SetPlanes(planes);
+
+            vtkSmartPointer<vtkExtractEdges> extract_edges = vtkSmartPointer<vtkExtractEdges>::New();
+            extract_edges->SetInputConnection(frustumSource->GetOutputPort());
+            extract_edges->Update();
+
+            return extract_edges->GetOutput();
+        }
+
+        static Mat ensureColorImage(InputArray image)
+        {
+            Mat color(image.size(), CV_8UC3);
+            if (image.channels() == 1)
+            {
+                Vec3b *drow = color.ptr<Vec3b>();
+                for(int y = 0; y < color.rows; ++y)
+                {
+                    const unsigned char *srow = image.getMat().ptr<unsigned char>(y);
+                    const unsigned char *send = srow + color.cols;
+                    for(;srow < send;)
+                        *drow++ = Vec3b::all(*srow++);
+                }
+            }
+            else
+                image.copyTo(color);
+            return color;
+        }
+    };
+}}}
+
+cv::viz::WCameraPosition::WCameraPosition(double scale)
+{
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, getPolyData(WCoordinateSystem(scale)));
+    mapper->SetScalarModeToUsePointData();
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WCameraPosition::WCameraPosition(const Matx33d &K, double scale, const Color &color)
+{
+    double f_x = K(0,0), f_y = K(1,1), c_y = K(1,2);
+
+    // Assuming that this is an ideal camera (c_y and c_x are at the center of the image)
+    double fovy = 2.0 * atan2(c_y, f_y) * 180 / CV_PI;
+    double aspect_ratio = f_y / f_x;
+
+    vtkSmartPointer<vtkPolyData> polydata = CameraPositionUtils::createFrustum(aspect_ratio, fovy, scale);
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WCameraPosition::WCameraPosition(const Vec2d &fov, double scale, const Color &color)
+{
+    double aspect_ratio = tan(fov[0] * 0.5) / tan(fov[1] * 0.5);
+    double fovy = fov[1] * 180 / CV_PI;
+
+    vtkSmartPointer<vtkPolyData> polydata = CameraPositionUtils::createFrustum(aspect_ratio, fovy, scale);
+    VtkUtils::FillScalars(polydata, color);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, polydata);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WCameraPosition::WCameraPosition(const Matx33d &K, InputArray _image, double scale, const Color &color)
+{
+    CV_Assert(!_image.empty() && _image.depth() == CV_8U);
+    Mat image = CameraPositionUtils::ensureColorImage(_image);
+    image.at<Vec3b>(0, 0) = Vec3d(color.val); //workaround of VTK limitation
+
+    double f_y = K(1,1), c_y = K(1,2);
+    // Assuming that this is an ideal camera (c_y and c_x are at the center of the image)
+    double fovy = 2.0 * atan2(c_y, f_y) * 180.0 / CV_PI;
+    double far_end_height = 2.00 * c_y * scale / f_y;
+    double aspect_ratio = image.cols/(double)image.rows;
+    double image_scale = far_end_height/image.rows;
+
+    WImage3D image_widget(image, Size2d(image.size()) * image_scale);
+    image_widget.applyTransform(Affine3d().translate(Vec3d(0, 0, scale)));
+    vtkSmartPointer<vtkPolyData> plane = getPolyData(image_widget);
+
+    vtkSmartPointer<vtkPolyData> frustum = CameraPositionUtils::createFrustum(aspect_ratio, fovy, scale);
+
+    // Frustum needs to be textured or else it can't be combined with image
+    vtkSmartPointer<vtkTextureMapToPlane> frustum_texture = vtkSmartPointer<vtkTextureMapToPlane>::New();
+    VtkUtils::SetInputData(frustum_texture, frustum);
+    frustum_texture->SetSRange(0.0, 0.0); // Texture mapping with only one pixel
+    frustum_texture->SetTRange(0.0, 0.0); // from the image to have constant color
+
+    vtkSmartPointer<vtkAppendPolyData> append_filter = vtkSmartPointer<vtkAppendPolyData>::New();
+    append_filter->AddInputConnection(frustum_texture->GetOutputPort());
+    VtkUtils::AddInputData(append_filter, plane);
+
+    vtkSmartPointer<vtkActor> actor = getActor(image_widget);
+    actor->GetMapper()->SetInputConnection(append_filter->GetOutputPort());
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WCameraPosition::WCameraPosition(const Vec2d &fov, InputArray _image, double scale, const Color &color)
+{
+    CV_Assert(!_image.empty() && _image.depth() == CV_8U);
+    Mat image = CameraPositionUtils::ensureColorImage(_image);
+    image.at<Vec3b>(0, 0) = Vec3d(color.val); //workaround of VTK limitation
+
+    double fovy = fov[1] * 180.0 / CV_PI;
+    double far_end_height = 2.0 * scale * tan(fov[1] * 0.5);
+    double aspect_ratio = image.cols/(double)image.rows;
+    double image_scale = far_end_height/image.rows;
+
+    WImage3D image_widget(image, Size2d(image.size()) * image_scale);
+    image_widget.applyTransform(Affine3d().translate(Vec3d(0, 0, scale)));
+    vtkSmartPointer<vtkPolyData> plane = getPolyData(image_widget);
+
+    vtkSmartPointer<vtkPolyData> frustum = CameraPositionUtils::createFrustum(aspect_ratio, fovy, scale);
+
+    // Frustum needs to be textured or else it can't be combined with image
+    vtkSmartPointer<vtkTextureMapToPlane> frustum_texture = vtkSmartPointer<vtkTextureMapToPlane>::New();
+    VtkUtils::SetInputData(frustum_texture, frustum);
+    frustum_texture->SetSRange(0.0, 0.0); // Texture mapping with only one pixel
+    frustum_texture->SetTRange(0.0, 0.0); // from the image to have constant color
+
+    vtkSmartPointer<vtkAppendPolyData> append_filter = vtkSmartPointer<vtkAppendPolyData>::New();
+    append_filter->AddInputConnection(frustum_texture->GetOutputPort());
+    VtkUtils::AddInputData(append_filter, plane);
+
+    vtkSmartPointer<vtkActor> actor = getActor(image_widget);
+    actor->GetMapper()->SetInputConnection(append_filter->GetOutputPort());
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WCameraPosition cv::viz::Widget::cast<cv::viz::WCameraPosition>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WCameraPosition&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// trajectory widget implementation
+
+cv::viz::WTrajectory::WTrajectory(InputArray _path, int display_mode, double scale, const Color &color)
+{
+    vtkSmartPointer<vtkAppendPolyData> append_filter = vtkSmartPointer<vtkAppendPolyData>::New();
+
+    // Bitwise and with 3 in order to limit the domain to 2 bits
+    if (display_mode & WTrajectory::PATH)
+    {
+        Mat points = vtkTrajectorySource::ExtractPoints(_path);
+        vtkSmartPointer<vtkPolyData> polydata = getPolyData(WPolyLine(points, color));
+        VtkUtils::AddInputData(append_filter, polydata);
+    }
+
+    if (display_mode & WTrajectory::FRAMES)
+    {
+        vtkSmartPointer<vtkTrajectorySource> source = vtkSmartPointer<vtkTrajectorySource>::New();
+        source->SetTrajectory(_path);
+
+        vtkSmartPointer<vtkPolyData> glyph = getPolyData(WCoordinateSystem(scale));
+
+        vtkSmartPointer<vtkTensorGlyph> tensor_glyph = vtkSmartPointer<vtkTensorGlyph>::New();
+        tensor_glyph->SetInputConnection(source->GetOutputPort());
+        VtkUtils::SetSourceData(tensor_glyph, glyph);
+        tensor_glyph->ExtractEigenvaluesOff();  // Treat as a rotation matrix, not as something with eigenvalues
+        tensor_glyph->ThreeGlyphsOff();
+        tensor_glyph->SymmetricOff();
+        tensor_glyph->ColorGlyphsOff();
+
+        append_filter->AddInputConnection(tensor_glyph->GetOutputPort());
+    }
+    append_filter->Update();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, append_filter->GetOutput());
+    mapper->SetScalarModeToUsePointData();
+    mapper->SetScalarRange(0, 255);
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WTrajectory cv::viz::Widget::cast<cv::viz::WTrajectory>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WTrajectory&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// WTrajectoryFrustums widget implementation
+
+cv::viz::WTrajectoryFrustums::WTrajectoryFrustums(InputArray _path, const Matx33d &K, double scale, const Color &color)
+{
+    vtkSmartPointer<vtkTrajectorySource> source = vtkSmartPointer<vtkTrajectorySource>::New();
+    source->SetTrajectory(_path);
+
+    vtkSmartPointer<vtkPolyData> glyph = getPolyData(WCameraPosition(K, scale));
+    VtkUtils::FillScalars(glyph, color);
+
+    vtkSmartPointer<vtkTensorGlyph> tensor_glyph = vtkSmartPointer<vtkTensorGlyph>::New();
+    tensor_glyph->SetInputConnection(source->GetOutputPort());
+    VtkUtils::SetSourceData(tensor_glyph, glyph);
+    tensor_glyph->ExtractEigenvaluesOff();  // Treat as a rotation matrix, not as something with eigenvalues
+    tensor_glyph->ThreeGlyphsOff();
+    tensor_glyph->SymmetricOff();
+    tensor_glyph->ColorGlyphsOff();
+    tensor_glyph->Update();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, tensor_glyph->GetOutput());
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+cv::viz::WTrajectoryFrustums::WTrajectoryFrustums(InputArray _path, const Vec2d &fov, double scale, const Color &color)
+{
+    vtkSmartPointer<vtkTrajectorySource> source = vtkSmartPointer<vtkTrajectorySource>::New();
+    source->SetTrajectory(_path);
+
+    vtkSmartPointer<vtkPolyData> glyph = getPolyData(WCameraPosition(fov, scale));
+    VtkUtils::FillScalars(glyph, color);
+
+    vtkSmartPointer<vtkTensorGlyph> tensor_glyph = vtkSmartPointer<vtkTensorGlyph>::New();
+    tensor_glyph->SetInputConnection(source->GetOutputPort());
+    VtkUtils::SetSourceData(tensor_glyph, glyph);
+    tensor_glyph->ExtractEigenvaluesOff();  // Treat as a rotation matrix, not as something with eigenvalues
+    tensor_glyph->ThreeGlyphsOff();
+    tensor_glyph->SymmetricOff();
+    tensor_glyph->ColorGlyphsOff();
+    tensor_glyph->Update();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    VtkUtils::SetInputData(mapper, tensor_glyph->GetOutput());
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WTrajectoryFrustums cv::viz::Widget::cast<cv::viz::WTrajectoryFrustums>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WTrajectoryFrustums&>(widget);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// WTrajectorySpheres widget implementation
+
+cv::viz::WTrajectorySpheres::WTrajectorySpheres(InputArray _path, double line_length, double radius, const Color &from, const Color &to)
+{
+    CV_Assert(_path.kind() == _InputArray::STD_VECTOR || _path.kind() == _InputArray::MAT);
+    CV_Assert(_path.type() == CV_32FC(16) || _path.type() == CV_64FC(16));
+
+    Mat path64;
+    _path.getMat().convertTo(path64, CV_64F);
+    Affine3d *traj = path64.ptr<Affine3d>();
+    size_t total = path64.total();
+
+    vtkSmartPointer<vtkAppendPolyData> append_filter = vtkSmartPointer<vtkAppendPolyData>::New();
+
+    for(size_t i = 0; i < total; ++i)
+    {
+        Vec3d curr = traj[i].translation();
+
+        vtkSmartPointer<vtkSphereSource> sphere_source = vtkSmartPointer<vtkSphereSource>::New();
+        sphere_source->SetCenter(curr.val);
+        sphere_source->SetRadius( (i == 0) ? 2 * radius : radius );
+        sphere_source->Update();
+
+        double alpha = static_cast<double>(i)/total;
+        Color c = from * (1 - alpha) + to * alpha;
+
+        vtkSmartPointer<vtkPolyData> polydata = sphere_source->GetOutput();
+        polydata->GetCellData()->SetScalars(VtkUtils::FillScalars(polydata->GetNumberOfCells(), c));
+        VtkUtils::AddInputData(append_filter, polydata);
+
+        if (i > 0)
+        {
+            Vec3d prev = traj[i-1].translation();
+            Vec3d lvec = prev - curr;
+
+            if(norm(lvec) > line_length)
+                lvec = normalize(lvec) * line_length;
+
+            Vec3d lend = curr + lvec;
+
+            vtkSmartPointer<vtkLineSource> line_source = vtkSmartPointer<vtkLineSource>::New();
+            line_source->SetPoint1(curr.val);
+            line_source->SetPoint2(lend.val);
+            line_source->Update();
+            vtkSmartPointer<vtkPolyData> polydata_ = line_source->GetOutput();
+            polydata_->GetCellData()->SetScalars(VtkUtils::FillScalars(polydata_->GetNumberOfCells(), c));
+            VtkUtils::AddInputData(append_filter, polydata_);
+        }
+    }
+    append_filter->Update();
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    mapper->SetScalarModeToUseCellData();
+    VtkUtils::SetInputData(mapper, append_filter->GetOutput());
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> cv::viz::WTrajectorySpheres cv::viz::Widget::cast<cv::viz::WTrajectorySpheres>() const
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<WTrajectorySpheres&>(widget);
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/types.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/types.cpp
new file mode 100644
index 00000000..e9a470cf
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/types.cpp
@@ -0,0 +1,230 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "precomp.hpp"
+
+////////////////////////////////////////////////////////////////////
+/// Events
+
+cv::viz::KeyboardEvent::KeyboardEvent(Action _action, const String& _symbol, unsigned char _code, int _modifiers)
+  : action(_action), symbol(_symbol), code(_code), modifiers(_modifiers) {}
+
+cv::viz::MouseEvent::MouseEvent(const Type& _type, const MouseButton& _button, const Point& _pointer, int _modifiers)
+    : type(_type), button(_button), pointer(_pointer), modifiers(_modifiers) {}
+
+////////////////////////////////////////////////////////////////////
+/// cv::viz::Mesh3d
+
+cv::viz::Mesh cv::viz::Mesh::load(const String& file, int type)
+{
+    vtkSmartPointer<vtkPolyDataAlgorithm> reader = vtkSmartPointer<vtkPolyDataAlgorithm>::New();
+    switch (type) {
+      case LOAD_AUTO:
+      {
+        CV_Error(Error::StsError, "cv::viz::Mesh::LOAD_AUTO: Not implemented yet");
+      }
+      case LOAD_PLY:
+      {
+        vtkSmartPointer<vtkPLYReader> ply_reader = vtkSmartPointer<vtkPLYReader>::New();
+        ply_reader->SetFileName(file.c_str());
+        ply_reader->Update();
+        reader = ply_reader;
+        break;
+      }
+      case LOAD_OBJ:
+      {
+        vtkSmartPointer<vtkOBJReader> obj_reader = vtkSmartPointer<vtkOBJReader>::New();
+        obj_reader->SetFileName(file.c_str());
+        obj_reader->Update();
+        reader = obj_reader;
+        break;
+      }
+      default:
+        CV_Error(Error::StsError, "cv::viz::Mesh::load: Unknown file type");
+    }
+
+    vtkSmartPointer<vtkPolyData> polydata = reader->GetOutput();
+    CV_Assert("File does not exist or file format is not supported." && polydata);
+
+    Mesh mesh;
+    vtkSmartPointer<vtkCloudMatSink> sink = vtkSmartPointer<vtkCloudMatSink>::New();
+    sink->SetOutput(mesh.cloud, mesh.colors, mesh.normals, mesh.tcoords);
+    sink->SetInputConnection(reader->GetOutputPort());
+    sink->Write();
+
+    // Now handle the polygons
+    vtkSmartPointer<vtkCellArray> polygons = polydata->GetPolys();
+    mesh.polygons.create(1, polygons->GetSize(), CV_32SC1);
+    mesh.polygons = 0;
+    int* poly_ptr = mesh.polygons.ptr<int>();
+
+    polygons->InitTraversal();
+    vtkIdType nr_cell_points;
+    CellIterT cell_points;
+    while (polygons->GetNextCell(nr_cell_points, cell_points))
+    {
+        *poly_ptr++ = nr_cell_points;
+        for (vtkIdType i = 0; i < nr_cell_points; ++i)
+            *poly_ptr++ = (int)cell_points[i];
+    }
+
+    return mesh;
+}
+
+////////////////////////////////////////////////////////////////////
+/// Camera implementation
+
+cv::viz::Camera::Camera(double fx, double fy, double cx, double cy, const Size &window_size)
+{
+    init(fx, fy, cx, cy, window_size);
+}
+
+cv::viz::Camera::Camera(const Vec2d &fov, const Size &window_size)
+{
+    CV_Assert(window_size.width > 0 && window_size.height > 0);
+    setClip(Vec2d(0.01, 1000.01)); // Default clipping
+    setFov(fov);
+    window_size_ = window_size;
+    // Principal point at the center
+    principal_point_ = Vec2f(static_cast<float>(window_size.width)*0.5f, static_cast<float>(window_size.height)*0.5f);
+    focal_ = Vec2f(principal_point_[0] / tan(fov_[0]*0.5f), principal_point_[1] / tan(fov_[1]*0.5f));
+}
+
+cv::viz::Camera::Camera(const cv::Matx33d & K, const Size &window_size)
+{
+    double f_x = K(0,0);
+    double f_y = K(1,1);
+    double c_x = K(0,2);
+    double c_y = K(1,2);
+    init(f_x, f_y, c_x, c_y, window_size);
+}
+
+cv::viz::Camera::Camera(const Matx44d &proj, const Size &window_size)
+{
+    CV_Assert(window_size.width > 0 && window_size.height > 0);
+
+    double near = proj(2,3) / (proj(2,2) - 1.0);
+    double far = near * (proj(2,2) - 1.0) / (proj(2,2) + 1.0);
+    double left = near * (proj(0,2)-1) / proj(0,0);
+    double right = 2.0 * near / proj(0,0) + left;
+    double bottom = near * (proj(1,2)-1) / proj(1,1);
+    double top = 2.0 * near / proj(1,1) + bottom;
+
+    double epsilon = 2.2204460492503131e-16;
+
+    principal_point_[0] = fabs(left-right) < epsilon ? window_size.width  * 0.5 : (left * window_size.width) / (left - right);
+    principal_point_[1] = fabs(top-bottom) < epsilon ? window_size.height * 0.5 : (top * window_size.height) / (top - bottom);
+
+    focal_[0] = -near * principal_point_[0] / left;
+    focal_[1] =  near * principal_point_[1] / top;
+
+    setClip(Vec2d(near, far));
+    fov_[0] = atan2(principal_point_[0], focal_[0]) + atan2(window_size.width-principal_point_[0],  focal_[0]);
+    fov_[1] = atan2(principal_point_[1], focal_[1]) + atan2(window_size.height-principal_point_[1], focal_[1]);
+
+    window_size_ = window_size;
+}
+
+void cv::viz::Camera::init(double fx, double fy, double cx, double cy, const Size &window_size)
+{
+    CV_Assert(window_size.width > 0 && window_size.height > 0);
+    setClip(Vec2d(0.01, 1000.01));// Default clipping
+
+    fov_[0] = atan2(cx, fx) + atan2(window_size.width  - cx, fx);
+    fov_[1] = atan2(cy, fy) + atan2(window_size.height - cy, fy);
+
+    principal_point_[0] = cx;
+    principal_point_[1] = cy;
+
+    focal_[0] = fx;
+    focal_[1] = fy;
+
+    window_size_ = window_size;
+}
+
+void cv::viz::Camera::setWindowSize(const Size &window_size)
+{
+    CV_Assert(window_size.width > 0 && window_size.height > 0);
+
+    // Get the scale factor and update the principal points
+    float scalex = static_cast<float>(window_size.width) / static_cast<float>(window_size_.width);
+    float scaley = static_cast<float>(window_size.height) / static_cast<float>(window_size_.height);
+
+    principal_point_[0] *= scalex;
+    principal_point_[1] *= scaley;
+    focal_ *= scaley;
+    // Vertical field of view is fixed!  Update horizontal field of view
+    fov_[0] = (atan2(principal_point_[0],focal_[0]) + atan2(window_size.width-principal_point_[0],focal_[0]));
+
+    window_size_ = window_size;
+}
+
+void cv::viz::Camera::computeProjectionMatrix(Matx44d &proj) const
+{
+    double top = clip_[0] * principal_point_[1] / focal_[1];
+    double left = -clip_[0] * principal_point_[0] / focal_[0];
+    double right = clip_[0] * (window_size_.width - principal_point_[0]) / focal_[0];
+    double bottom = -clip_[0] * (window_size_.height - principal_point_[1]) / focal_[1];
+
+    double temp1 = 2.0 * clip_[0];
+    double temp2 = 1.0 / (right - left);
+    double temp3 = 1.0 / (top - bottom);
+    double temp4 = 1.0 / (clip_[0] - clip_[1]);
+
+    proj = Matx44d::zeros();
+    proj(0,0) = temp1 * temp2;
+    proj(1,1) = temp1 * temp3;
+    proj(0,2) = (right + left) * temp2;
+    proj(1,2) = (top + bottom) * temp3;
+    proj(2,2) = (clip_[1]+clip_[0]) * temp4;
+    proj(3,2) = -1.0;
+    proj(2,3) = (temp1 * clip_[1]) * temp4;
+}
+
+cv::viz::Camera cv::viz::Camera::KinectCamera(const Size &window_size)
+{
+    Matx33d K(525.0, 0.0, 320.0, 0.0, 525.0, 240.0, 0.0, 0.0, 1.0);
+    return Camera(K, window_size);
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/viz3d.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/viz3d.cpp
new file mode 100644
index 00000000..62e570e6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/viz3d.cpp
@@ -0,0 +1,156 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "precomp.hpp"
+
+cv::viz::Viz3d::Viz3d(const String& window_name) : impl_(0) { create(window_name); }
+
+cv::viz::Viz3d::Viz3d(const Viz3d& other) : impl_(other.impl_)
+{
+    if (impl_)
+        CV_XADD(&impl_->ref_counter, 1);
+}
+
+cv::viz::Viz3d& cv::viz::Viz3d::operator=(const Viz3d& other)
+{
+    if (this != &other)
+    {
+        release();
+        impl_ = other.impl_;
+        if (impl_)
+            CV_XADD(&impl_->ref_counter, 1);
+    }
+    return *this;
+}
+
+cv::viz::Viz3d::~Viz3d() { release(); }
+
+void cv::viz::Viz3d::create(const String &window_name)
+{
+    if (impl_)
+        release();
+
+    if (VizStorage::windowExists(window_name))
+        *this = VizStorage::get(window_name);
+    else
+    {
+        impl_ = new VizImpl(window_name);
+        impl_->ref_counter = 1;
+
+        // Register the window
+        VizStorage::add(*this);
+    }
+}
+
+void cv::viz::Viz3d::release()
+{
+    if (impl_ && CV_XADD(&impl_->ref_counter, -1) == 1)
+    {
+        delete impl_;
+        impl_ = 0;
+    }
+
+    if (impl_ && impl_->ref_counter == 1)
+        VizStorage::removeUnreferenced();
+
+    impl_ = 0;
+}
+
+void cv::viz::Viz3d::spin() { impl_->spin(); }
+void cv::viz::Viz3d::spinOnce(int time, bool force_redraw) { impl_->spinOnce(time, force_redraw); }
+void cv::viz::Viz3d::setOffScreenRendering() { impl_->setOffScreenRendering(); }
+void cv::viz::Viz3d::removeAllLights() { impl_->removeAllLights(); }
+void cv::viz::Viz3d::addLight(const Vec3d &position, const Vec3d &focalPoint, const Color &color,
+                              const Color &diffuseColor, const Color &ambientColor, const Color &specularColor)
+{  impl_->addLight(position, focalPoint, color, diffuseColor, ambientColor, specularColor);  }
+bool cv::viz::Viz3d::wasStopped() const { return impl_->wasStopped(); }
+void cv::viz::Viz3d::close() { impl_->close(); }
+
+void cv::viz::Viz3d::registerKeyboardCallback(KeyboardCallback callback, void* cookie)
+{ impl_->registerKeyboardCallback(callback, cookie); }
+
+void cv::viz::Viz3d::registerMouseCallback(MouseCallback callback, void* cookie)
+{ impl_->registerMouseCallback(callback, cookie); }
+
+void cv::viz::Viz3d::showWidget(const String &id, const Widget &widget, const Affine3d &pose) { impl_->showWidget(id, widget, pose); }
+void cv::viz::Viz3d::removeWidget(const String &id) { impl_->removeWidget(id); }
+cv::viz::Widget cv::viz::Viz3d::getWidget(const String &id) const { return impl_->getWidget(id); }
+void cv::viz::Viz3d::removeAllWidgets() { impl_->removeAllWidgets(); }
+
+void cv::viz::Viz3d::showImage(InputArray image, const Size& window_size) { impl_->showImage(image, window_size); }
+
+void cv::viz::Viz3d::setWidgetPose(const String &id, const Affine3d &pose) { impl_->setWidgetPose(id, pose); }
+void cv::viz::Viz3d::updateWidgetPose(const String &id, const Affine3d &pose) { impl_->updateWidgetPose(id, pose); }
+cv::Affine3d cv::viz::Viz3d::getWidgetPose(const String &id) const { return impl_->getWidgetPose(id); }
+
+void cv::viz::Viz3d::setCamera(const Camera &camera) { impl_->setCamera(camera); }
+cv::viz::Camera cv::viz::Viz3d::getCamera() const { return impl_->getCamera(); }
+void cv::viz::Viz3d::setViewerPose(const Affine3d &pose) { impl_->setViewerPose(pose); }
+cv::Affine3d cv::viz::Viz3d::getViewerPose() const { return impl_->getViewerPose(); }
+
+void cv::viz::Viz3d::resetCameraViewpoint(const String &id) { impl_->resetCameraViewpoint(id); }
+void cv::viz::Viz3d::resetCamera() { impl_->resetCamera(); }
+
+void cv::viz::Viz3d::convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord) { impl_->convertToWindowCoordinates(pt, window_coord); }
+void cv::viz::Viz3d::converTo3DRay(const Point3d &window_coord, Point3d &origin, Vec3d &direction) { impl_->converTo3DRay(window_coord, origin, direction); }
+
+cv::Size cv::viz::Viz3d::getWindowSize() const { return impl_->getWindowSize(); }
+void cv::viz::Viz3d::setWindowSize(const Size &window_size) { impl_->setWindowSize(window_size); }
+cv::String cv::viz::Viz3d::getWindowName() const { return impl_->getWindowName(); }
+cv::Mat cv::viz::Viz3d::getScreenshot() const { return impl_->getScreenshot(); }
+void cv::viz::Viz3d::saveScreenshot(const String &file) { impl_->saveScreenshot(file); }
+void cv::viz::Viz3d::setWindowPosition(const Point& window_position) { impl_->setWindowPosition(window_position); }
+void cv::viz::Viz3d::setFullScreen(bool mode) { impl_->setFullScreen(mode); }
+void cv::viz::Viz3d::setBackgroundColor(const Color& color, const Color& color2) { impl_->setBackgroundColor(color, color2); }
+
+void cv::viz::Viz3d::setBackgroundTexture(InputArray image) { impl_->setBackgroundTexture(image); }
+void cv::viz::Viz3d::setBackgroundMeshLab() {impl_->setBackgroundMeshLab(); }
+
+void cv::viz::Viz3d::setRenderingProperty(const String &id, int property, double value) { getWidget(id).setRenderingProperty(property, value); }
+double cv::viz::Viz3d::getRenderingProperty(const String &id, int property) { return getWidget(id).getRenderingProperty(property); }
+
+void cv::viz::Viz3d::setRepresentation(int representation) { impl_->setRepresentation(representation); }
+
+void cv::viz::Viz3d::setGlobalWarnings(bool enabled) { vtkObject::SetGlobalWarningDisplay(enabled ? 1 : 0); }
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vizcore.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vizcore.cpp
new file mode 100644
index 00000000..a0ca4980
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vizcore.cpp
@@ -0,0 +1,352 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "precomp.hpp"
+
+cv::Affine3d cv::viz::makeTransformToGlobal(const Vec3d& axis_x, const Vec3d& axis_y, const Vec3d& axis_z, const Vec3d& origin)
+{
+    Affine3d::Mat3 R(axis_x[0], axis_y[0], axis_z[0],
+                     axis_x[1], axis_y[1], axis_z[1],
+                     axis_x[2], axis_y[2], axis_z[2]);
+
+    return Affine3d(R, origin);
+}
+
+cv::Affine3d cv::viz::makeCameraPose(const Vec3d& position, const Vec3d& focal_point, const Vec3d& y_dir)
+{
+    // Compute the transformation matrix for drawing the camera frame in a scene
+    Vec3d n = normalize(focal_point - position);
+    Vec3d u = normalize(y_dir.cross(n));
+    Vec3d v = n.cross(u);
+
+    return makeTransformToGlobal(u, v, n, position);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// VizStorage implementation
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+
+    #include <windows.h>
+
+    static BOOL WINAPI ConsoleHandlerRoutine(DWORD /*dwCtrlType*/)
+    {
+        vtkObject::GlobalWarningDisplayOff();
+        return FALSE;
+    }
+
+    static void register_console_handler()
+    {
+        HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+        CONSOLE_SCREEN_BUFFER_INFO hOutInfo;
+        if (GetConsoleScreenBufferInfo(hOut, &hOutInfo))
+            SetConsoleCtrlHandler(ConsoleHandlerRoutine, TRUE);
+    }
+
+#else
+
+    void register_console_handler();
+    void register_console_handler() {}
+
+#endif
+
+
+cv::viz::VizStorage cv::viz::VizStorage::init;
+cv::viz::VizMap cv::viz::VizStorage::storage;
+
+void cv::viz::VizMap::replace_clear() { type().swap(m); }
+cv::viz::VizMap::~VizMap() { replace_clear(); }
+
+cv::viz::VizStorage::VizStorage()
+{
+    register_console_handler();
+}
+void cv::viz::VizStorage::unregisterAll() { storage.replace_clear(); }
+
+cv::viz::Viz3d& cv::viz::VizStorage::get(const String &window_name)
+{
+    String name = generateWindowName(window_name);
+    VizMap::iterator vm_itr = storage.m.find(name);
+    CV_Assert(vm_itr != storage.m.end());
+    return vm_itr->second;
+}
+
+void cv::viz::VizStorage::add(const Viz3d& window)
+{
+    String window_name = window.getWindowName();
+    VizMap::iterator vm_itr = storage.m.find(window_name);
+    CV_Assert(vm_itr == storage.m.end());
+    storage.m.insert(std::make_pair(window_name, window));
+}
+
+bool cv::viz::VizStorage::windowExists(const String &window_name)
+{
+    String name = generateWindowName(window_name);
+    return storage.m.find(name) != storage.m.end();
+}
+
+void cv::viz::VizStorage::removeUnreferenced()
+{
+    for(VizMap::iterator pos = storage.m.begin(); pos != storage.m.end();)
+        if(pos->second.impl_->ref_counter == 1)
+            storage.m.erase(pos++);
+        else
+            ++pos;
+}
+
+cv::String cv::viz::VizStorage::generateWindowName(const String &window_name)
+{
+    String output = "Viz";
+    // Already is Viz
+    if (window_name == output)
+        return output;
+
+    String prefixed = output + " - ";
+    if (window_name.substr(0, prefixed.length()) == prefixed)
+        output = window_name; // Already has "Viz - "
+    else if (window_name.substr(0, output.length()) == output)
+        output = prefixed + window_name; // Doesn't have prefix
+    else
+        output = (window_name == "" ? output : prefixed + window_name);
+
+    return output;
+}
+
+cv::viz::Viz3d cv::viz::getWindowByName(const String &window_name) { return Viz3d (window_name); }
+void cv::viz::unregisterAllWindows() { VizStorage::unregisterAll(); }
+
+cv::viz::Viz3d cv::viz::imshow(const String& window_name, InputArray image, const Size& window_size)
+{
+    Viz3d viz = getWindowByName(window_name);
+    viz.showImage(image, window_size);
+    return viz;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Read/write clouds. Supported formats: ply, stl, xyz, obj
+
+void cv::viz::writeCloud(const String& file, InputArray cloud, InputArray colors, InputArray normals, bool binary)
+{
+    CV_Assert(file.size() > 4 && "Extension is required");
+    String extension = file.substr(file.size()-4);
+
+    vtkSmartPointer<vtkCloudMatSource> source = vtkSmartPointer<vtkCloudMatSource>::New();
+    source->SetColorCloudNormals(cloud, colors, normals);
+
+    vtkSmartPointer<vtkWriter> writer;
+    if (extension == ".xyz")
+    {
+        writer = vtkSmartPointer<vtkXYZWriter>::New();
+        vtkXYZWriter::SafeDownCast(writer)->SetFileName(file.c_str());
+    }
+    else if (extension == ".ply")
+    {
+        writer = vtkSmartPointer<vtkPLYWriter>::New();
+        vtkPLYWriter::SafeDownCast(writer)->SetFileName(file.c_str());
+        vtkPLYWriter::SafeDownCast(writer)->SetFileType(binary ? VTK_BINARY : VTK_ASCII);
+        vtkPLYWriter::SafeDownCast(writer)->SetArrayName("Colors");
+    }
+    else if (extension == ".obj")
+    {
+        writer = vtkSmartPointer<vtkOBJWriter>::New();
+        vtkOBJWriter::SafeDownCast(writer)->SetFileName(file.c_str());
+    }
+    else
+        CV_Error(Error::StsError, "Unsupported format");
+
+    writer->SetInputConnection(source->GetOutputPort());
+    writer->Write();
+}
+
+cv::Mat cv::viz::readCloud(const String& file, OutputArray colors, OutputArray normals)
+{
+    CV_Assert(file.size() > 4 && "Extension is required");
+    String extension = file.substr(file.size()-4);
+
+    vtkSmartPointer<vtkPolyDataAlgorithm> reader;
+    if (extension == ".xyz")
+    {
+        reader = vtkSmartPointer<vtkXYZReader>::New();
+        vtkXYZReader::SafeDownCast(reader)->SetFileName(file.c_str());
+    }
+    else if (extension == ".ply")
+    {
+        reader = vtkSmartPointer<vtkPLYReader>::New();
+        CV_Assert(vtkPLYReader::CanReadFile(file.c_str()));
+        vtkPLYReader::SafeDownCast(reader)->SetFileName(file.c_str());
+    }
+    else if (extension == ".obj")
+    {
+        reader = vtkSmartPointer<vtkOBJReader>::New();
+        vtkOBJReader::SafeDownCast(reader)->SetFileName(file.c_str());
+    }
+    else if (extension == ".stl")
+    {
+        reader = vtkSmartPointer<vtkSTLReader>::New();
+        vtkSTLReader::SafeDownCast(reader)->SetFileName(file.c_str());
+    }
+    else
+        CV_Error(Error::StsError, "Unsupported format");
+
+    cv::Mat cloud;
+
+    vtkSmartPointer<vtkCloudMatSink> sink = vtkSmartPointer<vtkCloudMatSink>::New();
+    sink->SetInputConnection(reader->GetOutputPort());
+    sink->SetOutput(cloud, colors, normals);
+    sink->Write();
+
+    return cloud;
+}
+
+cv::viz::Mesh cv::viz::readMesh(const String& file) { return Mesh::load(file); }
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Read/write poses and trajectories
+
+bool cv::viz::readPose(const String& file, Affine3d& pose, const String& tag)
+{
+    FileStorage fs(file, FileStorage::READ);
+    if (!fs.isOpened())
+        return false;
+
+    Mat hdr(pose.matrix, false);
+    fs[tag] >> hdr;
+    if (hdr.empty() || hdr.cols != pose.matrix.cols || hdr.rows != pose.matrix.rows)
+        return false;
+
+    hdr.convertTo(pose.matrix, CV_64F);
+    return true;
+}
+
+void cv::viz::writePose(const String& file, const Affine3d& pose, const String& tag)
+{
+    FileStorage fs(file, FileStorage::WRITE);
+    fs << tag << Mat(pose.matrix, false);
+}
+
+void cv::viz::readTrajectory(OutputArray _traj, const String& files_format, int start, int end, const String& tag)
+{
+    CV_Assert(_traj.kind() == _InputArray::STD_VECTOR || _traj.kind() == _InputArray::MAT);
+
+    start = max(0, std::min(start, end));
+    end = std::max(start, end);
+
+    std::vector<Affine3d> traj;
+
+    for(int i = start; i < end; ++i)
+    {
+        Affine3d affine;
+        bool ok = readPose(cv::format(files_format.c_str(), i), affine, tag);
+        if (!ok)
+            break;
+
+        traj.push_back(affine);
+    }
+
+    Mat(traj).convertTo(_traj, _traj.depth());
+}
+
+void cv::viz::writeTrajectory(InputArray _traj, const String& files_format, int start, const String& tag)
+{
+    if (_traj.kind() == _InputArray::STD_VECTOR_MAT)
+    {
+#if CV_MAJOR_VERSION < 3
+        std::vector<Mat>& v = *(std::vector<Mat>*)_traj.obj;
+#else
+        std::vector<Mat>& v = *(std::vector<Mat>*)_traj.getObj();
+#endif
+
+        for(size_t i = 0, index = max(0, start); i < v.size(); ++i, ++index)
+        {
+            Affine3d affine;
+            Mat pose = v[i];
+            CV_Assert(pose.type() == CV_32FC(16) || pose.type() == CV_64FC(16));
+            pose.copyTo(affine.matrix);
+            writePose(cv::format(files_format.c_str(), index), affine, tag);
+        }
+        return;
+    }
+
+    if (_traj.kind() == _InputArray::STD_VECTOR || _traj.kind() == _InputArray::MAT)
+    {
+        CV_Assert(_traj.type() == CV_32FC(16) || _traj.type() == CV_64FC(16));
+
+        Mat traj = _traj.getMat();
+
+        if (traj.depth() == CV_32F)
+            for(size_t i = 0, index = max(0, start); i < traj.total(); ++i, ++index)
+                writePose(cv::format(files_format.c_str(), index), traj.at<Affine3f>((int)i), tag);
+
+        if (traj.depth() == CV_64F)
+            for(size_t i = 0, index = max(0, start); i < traj.total(); ++i, ++index)
+                writePose(cv::format(files_format.c_str(), index), traj.at<Affine3d>((int)i), tag);
+        return;
+    }
+
+    CV_Error(Error::StsError, "Unsupported array kind");
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Computing normals for mesh
+
+void cv::viz::computeNormals(const Mesh& mesh, OutputArray _normals)
+{
+    vtkSmartPointer<vtkPolyData> polydata = getPolyData(WMesh(mesh));
+    vtkSmartPointer<vtkPolyData> with_normals = VtkUtils::ComputeNormals(polydata);
+
+    vtkSmartPointer<vtkDataArray> generic_normals = with_normals->GetPointData()->GetNormals();
+    if(generic_normals)
+    {
+        Mat normals(1, generic_normals->GetNumberOfTuples(), CV_64FC3);
+        Vec3d *optr = normals.ptr<Vec3d>();
+
+        for(int i = 0; i < generic_normals->GetNumberOfTuples(); ++i, ++optr)
+            generic_normals->GetTuple(i, optr->val);
+
+        normals.convertTo(_normals, mesh.cloud.type());
+    }
+    else
+        _normals.release();
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vizimpl.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vizimpl.cpp
new file mode 100644
index 00000000..2c7ce997
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vizimpl.cpp
@@ -0,0 +1,631 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "precomp.hpp"
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+cv::viz::Viz3d::VizImpl::VizImpl(const String &name) : spin_once_state_(false),
+    window_position_(Vec2i(std::numeric_limits<int>::min())), widget_actor_map_(new WidgetActorMap)
+{
+    renderer_ = vtkSmartPointer<vtkRenderer>::New();
+    window_name_ = VizStorage::generateWindowName(name);
+
+    // Create render window
+    window_ = vtkSmartPointer<vtkRenderWindow>::New();
+    int * sz = window_->GetScreenSize();
+    if (sz)
+    {
+        cv::Vec2i window_size = cv::Vec2i(sz) / 2;
+        window_->SetSize(window_size.val);
+    }
+    else
+    {
+        int new_sz[2] = { 640, 480 };
+        window_->SetSize(new_sz);
+    }
+    window_->AddRenderer(renderer_);
+
+    // Create the interactor style
+    style_ = vtkSmartPointer<vtkVizInteractorStyle>::New();
+    style_->setWidgetActorMap(widget_actor_map_);
+    style_->UseTimersOn();
+
+    timer_callback_ = vtkSmartPointer<TimerCallback>::New();
+    exit_callback_ = vtkSmartPointer<ExitCallback>::New();
+    exit_callback_->viz = this;
+
+    offScreenMode_ = false;
+
+    setBackgroundMeshLab();
+}
+
+cv::viz::Viz3d::VizImpl::~VizImpl() { close(); }
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::TimerCallback::Execute(vtkObject* caller, unsigned long event_id, void* cookie)
+{
+    if (event_id == vtkCommand::TimerEvent && timer_id == *reinterpret_cast<int*>(cookie))
+    {
+        vtkSmartPointer<vtkRenderWindowInteractor> interactor = vtkRenderWindowInteractor::SafeDownCast(caller);
+        interactor->TerminateApp();
+    }
+}
+
+void cv::viz::Viz3d::VizImpl::ExitCallback::Execute(vtkObject*, unsigned long event_id, void*)
+{
+    if (event_id == vtkCommand::ExitEvent && viz->interactor_)
+    {
+        viz->interactor_->TerminateApp();
+        viz->interactor_ = 0;
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+bool cv::viz::Viz3d::VizImpl::wasStopped() const
+{
+    bool stopped = spin_once_state_ ? interactor_ == 0 : false;
+    spin_once_state_ &= !stopped;
+    return stopped;
+}
+
+void cv::viz::Viz3d::VizImpl::close()
+{
+    if (!interactor_)
+        return;
+    interactor_->GetRenderWindow()->Finalize();
+    interactor_->TerminateApp(); // This tends to close the window...
+    interactor_ = 0;
+}
+
+void cv::viz::Viz3d::VizImpl::recreateRenderWindow()
+{
+#if !defined _MSC_VER && !defined __APPLE__
+    //recreating is workaround for Ubuntu -- a crash in x-server
+    Vec2i window_size(window_->GetSize());
+    int fullscreen = window_->GetFullScreen();
+
+    window_->Finalize();
+    window_ = vtkSmartPointer<vtkRenderWindow>::New();
+    if (window_position_[0] != std::numeric_limits<int>::min()) //also workaround
+        window_->SetPosition(window_position_.val);
+
+    window_->SetSize(window_size.val);
+    window_->SetFullScreen(fullscreen);
+    window_->AddRenderer(renderer_);
+#endif
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::spin()
+{
+    recreateRenderWindow();
+#if defined __APPLE__
+    interactor_ = vtkCocoaRenderWindowInteractorNew();
+#else
+    interactor_ = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+#endif
+    interactor_->SetRenderWindow(window_);
+    interactor_->SetInteractorStyle(style_);
+    window_->AlphaBitPlanesOff();
+    window_->PointSmoothingOff();
+    window_->LineSmoothingOff();
+    window_->PolygonSmoothingOff();
+    window_->SwapBuffersOn();
+    window_->SetStereoTypeToAnaglyph();
+    window_->Render();
+    window_->SetWindowName(window_name_.c_str());
+    interactor_->Start();
+    interactor_ = 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::spinOnce(int time, bool force_redraw)
+{
+    if (interactor_ == 0)
+    {
+        spin_once_state_ = true;
+        recreateRenderWindow();
+#if defined __APPLE__
+        interactor_ = vtkCocoaRenderWindowInteractorNew();
+#else
+        interactor_ = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+#endif
+        interactor_->SetRenderWindow(window_);
+        interactor_->SetInteractorStyle(style_);
+        interactor_->AddObserver(vtkCommand::TimerEvent, timer_callback_);
+        interactor_->AddObserver(vtkCommand::ExitEvent, exit_callback_);
+        window_->AlphaBitPlanesOff();
+        window_->PointSmoothingOff();
+        window_->LineSmoothingOff();
+        window_->PolygonSmoothingOff();
+        window_->SwapBuffersOn();
+        window_->SetStereoTypeToAnaglyph();
+        window_->Render();
+        window_->SetWindowName(window_name_.c_str());
+    }
+
+    vtkSmartPointer<vtkRenderWindowInteractor> local = interactor_;
+
+    if (force_redraw)
+        local->Render();
+
+    timer_callback_->timer_id = local->CreateRepeatingTimer(std::max(1, time));
+    local->Start();
+    local->DestroyTimer(timer_callback_->timer_id);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::setOffScreenRendering()
+{
+    window_->SetOffScreenRendering(1);
+    offScreenMode_ = true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::removeAllLights()
+{
+    renderer_->RemoveAllLights();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::addLight(Vec3d position, Vec3d focalPoint, const Color &color, const Color &diffuseColor,
+                                       const Color &ambientColor, const Color &specularColor)
+{
+    Color color_  = vtkcolor(color);
+    Color diffuseColor_ = vtkcolor(diffuseColor);
+    Color ambientColor_ = vtkcolor(ambientColor);
+    Color specularColor_ = vtkcolor(specularColor);
+
+    vtkSmartPointer<vtkLight> light = vtkSmartPointer<vtkLight>::New();
+    light->SetPosition(position.val);
+    light->SetFocalPoint(focalPoint.val);
+    light->SetColor(color_.val);
+    light->SetDiffuseColor(diffuseColor_.val);
+    light->SetAmbientColor(ambientColor_.val);
+    light->SetSpecularColor(specularColor_.val);
+
+    renderer_->AddLight(light);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::showWidget(const String &id, const Widget &widget, const Affine3d &pose)
+{
+    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    if (exists)
+    {
+        // Remove it if it exists and add it again
+        removeActorFromRenderer(wam_itr->second);
+    }
+    // Get the actor and set the user matrix
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(widget));
+    if (actor)
+    {
+        // If the actor is 3D, apply pose
+        vtkSmartPointer<vtkMatrix4x4> matrix = vtkmatrix(pose.matrix);
+        actor->SetUserMatrix(matrix);
+        actor->Modified();
+    }
+    // If the actor is a vtkFollower, then it should always face the camera
+    vtkFollower *follower = vtkFollower::SafeDownCast(actor);
+    if (follower)
+    {
+        follower->SetCamera(renderer_->GetActiveCamera());
+    }
+
+    renderer_->AddActor(WidgetAccessor::getProp(widget));
+    (*widget_actor_map_)[id] = WidgetAccessor::getProp(widget);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::removeWidget(const String &id)
+{
+    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    CV_Assert("Widget does not exist." && exists);
+    CV_Assert("Widget could not be removed." && removeActorFromRenderer(wam_itr->second));
+    widget_actor_map_->erase(wam_itr);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+cv::viz::Widget cv::viz::Viz3d::VizImpl::getWidget(const String &id) const
+{
+    WidgetActorMap::const_iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    CV_Assert("Widget does not exist." && exists);
+
+    Widget widget;
+    WidgetAccessor::setProp(widget, wam_itr->second);
+    return widget;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::setWidgetPose(const String &id, const Affine3d &pose)
+{
+    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    CV_Assert("Widget does not exist." && exists);
+
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(wam_itr->second);
+    CV_Assert("Widget is not 3D." && actor);
+
+    vtkSmartPointer<vtkMatrix4x4> matrix = vtkmatrix(pose.matrix);
+    actor->SetUserMatrix(matrix);
+    actor->Modified();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::updateWidgetPose(const String &id, const Affine3d &pose)
+{
+    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    CV_Assert("Widget does not exist." && exists);
+
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(wam_itr->second);
+    CV_Assert("Widget is not 3D." && actor);
+
+    vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
+    if (!matrix)
+    {
+        setWidgetPose(id, pose);
+        return ;
+    }
+    Affine3d updated_pose = pose * Affine3d(*matrix->Element);
+    matrix = vtkmatrix(updated_pose.matrix);
+
+    actor->SetUserMatrix(matrix);
+    actor->Modified();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+cv::Affine3d cv::viz::Viz3d::VizImpl::getWidgetPose(const String &id) const
+{
+    WidgetActorMap::const_iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    CV_Assert("Widget does not exist." && exists);
+
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(wam_itr->second);
+    CV_Assert("Widget is not 3D." && actor);
+
+    return Affine3d(*actor->GetUserMatrix()->Element);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::saveScreenshot(const String &file) { style_->saveScreenshot(file.c_str()); }
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+cv::Mat cv::viz::Viz3d::VizImpl::getScreenshot() const
+{
+    vtkSmartPointer<vtkWindowToImageFilter> windowToImageFilter =
+        vtkSmartPointer<vtkWindowToImageFilter>::New();
+    windowToImageFilter->SetInput(window_);
+    windowToImageFilter->ReadFrontBufferOff(); // read from the back buffer
+    windowToImageFilter->Update();
+
+    vtkImageData *resultImage = windowToImageFilter->GetOutput();
+    int * dim  = resultImage->GetDimensions();
+    cv::Mat image(dim[1], dim[0], CV_8UC3);
+
+    Vec3b* dptr = reinterpret_cast<Vec3b*>(resultImage->GetScalarPointer());
+    size_t elem_step = resultImage->GetIncrements()[1]/sizeof(Vec3b);
+
+    for (int y = 0; y < image.rows; ++y)
+    {
+        const Vec3b* drow = dptr + elem_step * y;
+        unsigned char *srow = image.ptr<unsigned char>(image.rows - y - 1);
+        for (int x = 0; x < image.cols; ++x, srow += image.channels())
+        {
+          srow[0] = drow[x][2];
+          srow[1] = drow[x][1];
+          srow[2] = drow[x][0];
+        }
+    }
+
+    resultImage = 0;
+
+    return image;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::registerMouseCallback(MouseCallback callback, void* cookie)
+{ style_->registerMouseCallback(callback, cookie); }
+
+void cv::viz::Viz3d::VizImpl::registerKeyboardCallback(KeyboardCallback callback, void* cookie)
+{ style_->registerKeyboardCallback(callback, cookie); }
+
+
+//////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::removeAllWidgets()
+{
+    widget_actor_map_->clear();
+    renderer_->RemoveAllViewProps();
+}
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::showImage(InputArray image, const Size& window_size)
+{
+    removeAllWidgets();
+    if (window_size.width > 0 && window_size.height > 0)
+        setWindowSize(window_size);
+
+    showWidget("showImage", WImageOverlay(image, Rect(Point(0,0), getWindowSize())));
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+bool cv::viz::Viz3d::VizImpl::removeActorFromRenderer(vtkSmartPointer<vtkProp> actor)
+{
+    vtkPropCollection* actors = renderer_->GetViewProps();
+    actors->InitTraversal();
+    vtkProp* current_actor = NULL;
+    while ((current_actor = actors->GetNextProp()) != NULL)
+        if (current_actor == actor)
+        {
+            renderer_->RemoveActor(actor);
+            return true;
+        }
+    return false;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::setBackgroundColor(const Color& color, const Color& color2)
+{
+    Color c = vtkcolor(color), c2 = vtkcolor(color2);
+    bool gradient = color2[0] >= 0 && color2[1] >= 0 && color2[2] >= 0;
+
+    if (gradient)
+    {
+        renderer_->SetBackground(c2.val);
+        renderer_->SetBackground2(c.val);
+        renderer_->GradientBackgroundOn();
+    }
+    else
+    {
+        renderer_->SetBackground(c.val);
+        renderer_->GradientBackgroundOff();
+    }
+}
+
+void cv::viz::Viz3d::VizImpl::setBackgroundMeshLab()
+{ setBackgroundColor(Color(2, 1, 1), Color(240, 120, 120)); }
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::setBackgroundTexture(InputArray image)
+{
+    if (image.empty())
+    {
+        renderer_->SetBackgroundTexture(0);
+        renderer_->TexturedBackgroundOff();
+        return;
+    }
+
+    vtkSmartPointer<vtkImageMatSource> source = vtkSmartPointer<vtkImageMatSource>::New();
+    source->SetImage(image);
+
+    vtkSmartPointer<vtkImageFlip> image_flip = vtkSmartPointer<vtkImageFlip>::New();
+    image_flip->SetFilteredAxis(1); // Vertical flip
+    image_flip->SetInputConnection(source->GetOutputPort());
+
+    vtkSmartPointer<vtkTexture> texture = vtkSmartPointer<vtkTexture>::New();
+    texture->SetInputConnection(image_flip->GetOutputPort());
+    //texture->Update();
+
+    renderer_->SetBackgroundTexture(texture);
+    renderer_->TexturedBackgroundOn();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::setCamera(const Camera &camera)
+{
+    vtkSmartPointer<vtkCamera> active_camera = renderer_->GetActiveCamera();
+
+    // Set the intrinsic parameters of the camera
+    window_->SetSize(camera.getWindowSize().width, camera.getWindowSize().height);
+    double aspect_ratio = static_cast<double>(camera.getWindowSize().width)/static_cast<double>(camera.getWindowSize().height);
+
+    Matx44d proj_mat;
+    camera.computeProjectionMatrix(proj_mat);
+
+    // Use the intrinsic parameters of the camera to simulate more realistically
+    vtkSmartPointer<vtkMatrix4x4> vtk_matrix = active_camera->GetProjectionTransformMatrix(aspect_ratio, -1.0, 1.0);
+    Matx44d old_proj_mat(*vtk_matrix->Element);
+
+    // This is a hack around not being able to set Projection Matrix
+    vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
+    transform->SetMatrix(vtkmatrix(proj_mat * old_proj_mat.inv()));
+    active_camera->SetUserTransform(transform);
+
+    renderer_->ResetCameraClippingRange();
+    renderer_->Render();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+cv::viz::Camera cv::viz::Viz3d::VizImpl::getCamera() const
+{
+    vtkSmartPointer<vtkCamera> active_camera = renderer_->GetActiveCamera();
+
+    Size window_size(renderer_->GetRenderWindow()->GetSize()[0],
+                     renderer_->GetRenderWindow()->GetSize()[1]);
+    double aspect_ratio = window_size.width / (double)window_size.height;
+
+    vtkSmartPointer<vtkMatrix4x4> proj_matrix = active_camera->GetProjectionTransformMatrix(aspect_ratio, -1.0f, 1.0f);
+    return Camera(Matx44d(*proj_matrix->Element), window_size);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::setViewerPose(const Affine3d &pose)
+{
+    vtkCamera& camera = *renderer_->GetActiveCamera();
+
+    // Position = extrinsic translation
+    cv::Vec3d pos_vec = pose.translation();
+
+    // Rotate the view vector
+    cv::Matx33d rotation = pose.rotation();
+    cv::Vec3d y_axis(0.0, -1.0, 0.0); // In Computer Vision Camera Y-axis is oriented down
+    cv::Vec3d up_vec(rotation * y_axis);
+
+    // Compute the new focal point
+    cv::Vec3d z_axis(0.0, 0.0, 1.0);
+    cv::Vec3d focal_vec = pose * z_axis;
+
+    camera.SetPosition(pos_vec.val);
+    camera.SetFocalPoint(focal_vec.val);
+    camera.SetViewUp(up_vec.val);
+
+    renderer_->ResetCameraClippingRange();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+cv::Affine3d cv::viz::Viz3d::VizImpl::getViewerPose() const
+{
+    vtkCamera& camera = *renderer_->GetActiveCamera();
+
+    Vec3d pos(camera.GetPosition());
+    Vec3d view_up(camera.GetViewUp());
+    Vec3d focal(camera.GetFocalPoint());
+
+    Vec3d y_axis = normalized(-view_up); // In Computer Vision Camera Y-axis is oriented down
+    Vec3d z_axis = normalized(focal - pos);
+    Vec3d x_axis = normalized(y_axis.cross(z_axis));
+
+    return makeTransformToGlobal(x_axis, y_axis, z_axis, pos);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord)
+{
+    Vec3d window_pt;
+    vtkInteractorObserver::ComputeWorldToDisplay(renderer_, pt.x, pt.y, pt.z, window_pt.val);
+    window_coord = window_pt;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::converTo3DRay(const Point3d &window_coord, Point3d &origin, Vec3d &direction)
+{
+    Vec4d world_pt;
+    vtkInteractorObserver::ComputeDisplayToWorld(renderer_, window_coord.x, window_coord.y, window_coord.z, world_pt.val);
+    Vec3d cam_pos(renderer_->GetActiveCamera()->GetPosition());
+    origin = cam_pos;
+    direction = normalize(Vec3d(world_pt.val) - cam_pos);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::resetCameraViewpoint(const String &id)
+{
+    vtkSmartPointer<vtkMatrix4x4> camera_pose;
+    static WidgetActorMap::iterator it = widget_actor_map_->find(id);
+    if (it != widget_actor_map_->end())
+    {
+        vtkProp3D *actor = vtkProp3D::SafeDownCast(it->second);
+        CV_Assert("Widget is not 3D." && actor);
+        camera_pose = actor->GetUserMatrix();
+    }
+    else
+        return;
+
+    // Prevent a segfault
+    if (!camera_pose) return;
+
+    vtkSmartPointer<vtkCamera> cam = renderer_->GetActiveCamera();
+    cam->SetPosition(camera_pose->GetElement(0, 3),
+                     camera_pose->GetElement(1, 3),
+                     camera_pose->GetElement(2, 3));
+
+    cam->SetFocalPoint(camera_pose->GetElement(0, 3) - camera_pose->GetElement(0, 2),
+                       camera_pose->GetElement(1, 3) - camera_pose->GetElement(1, 2),
+                       camera_pose->GetElement(2, 3) - camera_pose->GetElement(2, 2));
+
+    cam->SetViewUp(camera_pose->GetElement(0, 1),
+                   camera_pose->GetElement(1, 1),
+                   camera_pose->GetElement(2, 1));
+
+    renderer_->SetActiveCamera(cam);
+    renderer_->ResetCameraClippingRange();
+    renderer_->ResetCamera();
+    renderer_->Render();
+}
+
+///////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::resetCamera()
+{
+    renderer_->ResetCamera();
+}
+
+///////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::setRepresentation(int representation)
+{
+    vtkActorCollection * actors = renderer_->GetActors();
+    actors->InitTraversal();
+    vtkActor * actor;
+    switch (representation)
+    {
+        case REPRESENTATION_POINTS:
+        {
+            while ((actor = actors->GetNextActor()) != NULL)
+                actor->GetProperty()->SetRepresentationToPoints();
+            break;
+        }
+        case REPRESENTATION_SURFACE:
+        {
+            while ((actor = actors->GetNextActor()) != NULL)
+                actor->GetProperty()->SetRepresentationToSurface();
+            break;
+        }
+        case REPRESENTATION_WIREFRAME:
+        {
+            while ((actor = actors->GetNextActor()) != NULL)
+                actor->GetProperty()->SetRepresentationToWireframe();
+            break;
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+cv::String cv::viz::Viz3d::VizImpl::getWindowName() const { return window_name_; }
+void cv::viz::Viz3d::VizImpl::setFullScreen(bool mode) { window_->SetFullScreen(mode); }
+void cv::viz::Viz3d::VizImpl::setWindowPosition(const Point& position) { window_position_ = position; window_->SetPosition(position.x, position.y); }
+void cv::viz::Viz3d::VizImpl::setWindowSize(const Size& window_size) { window_->SetSize(window_size.width, window_size.height); }
+cv::Size cv::viz::Viz3d::VizImpl::getWindowSize() const { return Size(Point(Vec2i(window_->GetSize()))); }
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vizimpl.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vizimpl.hpp
new file mode 100644
index 00000000..b39bc497
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vizimpl.hpp
@@ -0,0 +1,146 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef __OPENCV_VIZ_VIZ3D_IMPL_HPP__
+#define __OPENCV_VIZ_VIZ3D_IMPL_HPP__
+
+struct cv::viz::Viz3d::VizImpl
+{
+public:
+    typedef Viz3d::KeyboardCallback KeyboardCallback;
+    typedef Viz3d::MouseCallback MouseCallback;
+
+    int ref_counter;
+
+    VizImpl(const String &name);
+    virtual ~VizImpl();
+
+    bool wasStopped() const;
+    void close();
+
+    void spin();
+    void spinOnce(int time = 1, bool force_redraw = false);
+    void setOffScreenRendering();
+
+    void removeAllLights();
+    void addLight(Vec3d position, Vec3d focalPoint, const Color &color, const Color &diffuseColor,
+                  const Color &ambientColor, const Color &specularColor);
+
+    void showWidget(const String &id, const Widget &widget, const Affine3d &pose = Affine3d::Identity());
+    void removeWidget(const String &id);
+    Widget getWidget(const String &id) const;
+    void removeAllWidgets();
+
+    void showImage(InputArray image, const Size& window_size);
+
+    void setWidgetPose(const String &id, const Affine3d &pose);
+    void updateWidgetPose(const String &id, const Affine3d &pose);
+    Affine3d getWidgetPose(const String &id) const;
+
+    void setRepresentation(int representation);
+
+    void setCamera(const Camera &camera);
+    Camera getCamera() const;
+
+    /** \brief Reset the camera to a given widget */
+    void resetCameraViewpoint(const String& id);
+    void resetCamera();
+
+    void setViewerPose(const Affine3d &pose);
+    Affine3d getViewerPose() const;
+
+    void convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord);
+    void converTo3DRay(const Point3d &window_coord, Point3d &origin, Vec3d &direction);
+
+    Mat getScreenshot() const;
+    void saveScreenshot(const String &file);
+    void setWindowPosition(const Point& position);
+    Size getWindowSize() const;
+    void setWindowSize(const Size& window_size);
+    void setFullScreen(bool mode);
+    String getWindowName() const;
+    void setBackgroundColor(const Color& color, const Color& color2);
+    void setBackgroundTexture(InputArray image);
+    void setBackgroundMeshLab();
+
+    void registerKeyboardCallback(KeyboardCallback callback, void* cookie = 0);
+    void registerMouseCallback(MouseCallback callback, void* cookie = 0);
+
+private:
+    struct TimerCallback : public vtkCommand
+    {
+        static TimerCallback* New() { return new TimerCallback; }
+        virtual void Execute(vtkObject* caller, unsigned long event_id, void* cookie);
+        int timer_id;
+    };
+
+    struct ExitCallback : public vtkCommand
+    {
+        static ExitCallback* New() { return new ExitCallback; }
+        virtual void Execute(vtkObject*, unsigned long event_id, void*);
+        VizImpl* viz;
+    };
+
+    mutable bool spin_once_state_;
+    vtkSmartPointer<vtkRenderWindowInteractor> interactor_;
+
+    vtkSmartPointer<vtkRenderWindow> window_;
+    String window_name_;
+    Vec2i window_position_;
+
+    vtkSmartPointer<TimerCallback> timer_callback_;
+    vtkSmartPointer<ExitCallback> exit_callback_;
+
+    vtkSmartPointer<vtkRenderer> renderer_;
+    vtkSmartPointer<vtkVizInteractorStyle> style_;
+    Ptr<WidgetActorMap> widget_actor_map_;
+
+    bool offScreenMode_;
+
+    bool removeActorFromRenderer(vtkSmartPointer<vtkProp> actor);
+    void recreateRenderWindow();
+};
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSink.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSink.cpp
new file mode 100644
index 00000000..aa3d34ca
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSink.cpp
@@ -0,0 +1,174 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "../precomp.hpp"
+
+namespace cv { namespace viz
+{
+    vtkStandardNewMacro(vtkCloudMatSink);
+}}
+
+cv::viz::vtkCloudMatSink::vtkCloudMatSink() {}
+cv::viz::vtkCloudMatSink::~vtkCloudMatSink() {}
+
+void cv::viz::vtkCloudMatSink::SetOutput(OutputArray _cloud, OutputArray _colors, OutputArray _normals, OutputArray _tcoords)
+{
+    cloud = _cloud;
+    colors = _colors;
+    normals = _normals;
+    tcoords = _tcoords;
+}
+
+void cv::viz::vtkCloudMatSink::WriteData()
+{
+    vtkPolyData *input = this->GetInput();
+    if (!input)
+        return;
+
+    vtkSmartPointer<vtkPoints> points_Data = input->GetPoints();
+
+    if (cloud.needed() && points_Data)
+    {
+        int vtktype = points_Data->GetDataType();
+        CV_Assert(vtktype == VTK_FLOAT || vtktype == VTK_DOUBLE);
+
+        cloud.create(1, points_Data->GetNumberOfPoints(), vtktype == VTK_FLOAT ? CV_32FC3 : CV_64FC3);
+        Vec3d *ddata = cloud.getMat().ptr<Vec3d>();
+        Vec3f *fdata = cloud.getMat().ptr<Vec3f>();
+
+        if (cloud.depth() == CV_32F)
+            for(size_t i = 0; i < cloud.total(); ++i)
+                *fdata++ = Vec3d(points_Data->GetPoint((vtkIdType)i));
+
+        if (cloud.depth() == CV_64F)
+            for(size_t i = 0; i < cloud.total(); ++i)
+                *ddata++ = Vec3d(points_Data->GetPoint((vtkIdType)i));
+    }
+    else
+        cloud.release();
+
+    vtkSmartPointer<vtkDataArray> scalars_data = input->GetPointData() ? input->GetPointData()->GetScalars() : 0;
+
+    if (colors.needed() && scalars_data)
+    {
+        int channels = scalars_data->GetNumberOfComponents();
+        int vtktype = scalars_data->GetDataType();
+
+        CV_Assert((channels == 3 || channels == 4) && "Only 3- or 4-channel color data support is implemented");
+        CV_Assert(cloud.total() == (size_t)scalars_data->GetNumberOfTuples());
+
+        Mat buffer(cloud.size(), CV_64FC(channels));
+        Vec3d *cptr = buffer.ptr<Vec3d>();
+        for(size_t i = 0; i < buffer.total(); ++i)
+            *cptr++ = Vec3d(scalars_data->GetTuple((vtkIdType)i));
+
+        buffer.convertTo(colors, CV_8U, vtktype == VTK_FLOAT || VTK_FLOAT == VTK_DOUBLE ?  255.0 : 1.0);
+    }
+    else
+        colors.release();
+
+    vtkSmartPointer<vtkDataArray> normals_data = input->GetPointData() ? input->GetPointData()->GetNormals() : 0;
+
+    if (normals.needed() && normals_data)
+    {
+        int channels = normals_data->GetNumberOfComponents();
+        int vtktype = normals_data->GetDataType();
+
+        CV_Assert((vtktype == VTK_FLOAT || VTK_FLOAT == VTK_DOUBLE) && (channels == 3 || channels == 4));
+        CV_Assert(cloud.total() == (size_t)normals_data->GetNumberOfTuples());
+
+        Mat buffer(cloud.size(), CV_64FC(channels));
+        Vec3d *cptr = buffer.ptr<Vec3d>();
+        for(size_t i = 0; i < buffer.total(); ++i)
+            *cptr++ = Vec3d(normals_data->GetTuple((vtkIdType)i));
+
+        buffer.convertTo(normals, vtktype == VTK_FLOAT ? CV_32F : CV_64F);
+    }
+    else
+        normals.release();
+
+    vtkSmartPointer<vtkDataArray> coords_data = input->GetPointData() ? input->GetPointData()->GetTCoords() : 0;
+
+    if (tcoords.needed() && coords_data)
+    {
+        int vtktype = coords_data->GetDataType();
+
+        CV_Assert(vtktype == VTK_FLOAT || VTK_FLOAT == VTK_DOUBLE);
+        CV_Assert(cloud.total() == (size_t)coords_data->GetNumberOfTuples());
+
+        Mat buffer(cloud.size(), CV_64FC2);
+        Vec2d *cptr = buffer.ptr<Vec2d>();
+        for(size_t i = 0; i < buffer.total(); ++i)
+            *cptr++ = Vec2d(coords_data->GetTuple((vtkIdType)i));
+
+        buffer.convertTo(tcoords, vtktype == VTK_FLOAT ? CV_32F : CV_64F);
+
+    }
+    else
+        tcoords.release();
+}
+
+void cv::viz::vtkCloudMatSink::PrintSelf(ostream& os, vtkIndent indent)
+{
+  Superclass::PrintSelf(os, indent);
+  os << indent << "Cloud: " << cloud.needed() << "\n";
+  os << indent << "Colors: " << colors.needed() << "\n";
+  os << indent << "Normals: " << normals.needed() << "\n";
+}
+
+int cv::viz::vtkCloudMatSink::FillInputPortInformation(int, vtkInformation *info)
+{
+    info->Set(vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE(), "vtkPolyData");
+    return 1;
+}
+
+vtkPolyData* cv::viz::vtkCloudMatSink::GetInput()
+{
+    return vtkPolyData::SafeDownCast(this->Superclass::GetInput());
+}
+
+vtkPolyData* cv::viz::vtkCloudMatSink::GetInput(int port)
+{
+    return vtkPolyData::SafeDownCast(this->Superclass::GetInput(port));
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSink.h b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSink.h
new file mode 100644
index 00000000..997e6984
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSink.h
@@ -0,0 +1,88 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef __vtkCloudMatSink_h
+#define __vtkCloudMatSink_h
+
+#include <opencv2/core.hpp>
+#include <vtkWriter.h>
+
+namespace cv
+{
+    namespace viz
+    {
+        class vtkCloudMatSink : public vtkWriter
+        {
+        public:
+          static vtkCloudMatSink *New();
+          vtkTypeMacro(vtkCloudMatSink,vtkWriter)
+          void PrintSelf(ostream& os, vtkIndent indent);
+
+          void SetOutput(OutputArray cloud, OutputArray colors = noArray(), OutputArray normals = noArray(), OutputArray tcoords = noArray());
+
+          // Description:
+          // Get the input to this writer.
+          vtkPolyData* GetInput();
+          vtkPolyData* GetInput(int port);
+
+        protected:
+          vtkCloudMatSink();
+          ~vtkCloudMatSink();
+
+          void WriteData();
+          int FillInputPortInformation(int port, vtkInformation *info);
+
+          _OutputArray cloud; //!< point coordinates of type CV_32FC3 or CV_64FC3 with only 1 row
+          _OutputArray colors; //!< point color of type CV_8UC3 or CV_8UC4 with only 1 row
+          _OutputArray normals; //!< point normal of type CV_32FC3, CV_32FC4, CV_64FC3 or CV_64FC4 with only 1 row
+          _OutputArray tcoords; //!< texture coordinates of type CV_32FC2 or CV_64FC2 with only 1 row
+
+        private:
+          vtkCloudMatSink(const vtkCloudMatSink&);  // Not implemented.
+          void operator=(const vtkCloudMatSink&);  // Not implemented.
+        };
+    } // end namespace viz
+} // end namespace cv
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSource.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSource.cpp
new file mode 100644
index 00000000..5f1cecbf
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSource.cpp
@@ -0,0 +1,286 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "../precomp.hpp"
+
+namespace cv { namespace viz
+{
+    vtkStandardNewMacro(vtkCloudMatSource);
+
+    template<typename _Tp> struct VtkDepthTraits;
+
+    template<> struct VtkDepthTraits<float>
+    {
+        const static int data_type = VTK_FLOAT;
+        typedef vtkFloatArray array_type;
+    };
+
+    template<> struct VtkDepthTraits<double>
+    {
+        const static int data_type = VTK_DOUBLE;
+        typedef vtkDoubleArray array_type;
+    };
+}}
+
+cv::viz::vtkCloudMatSource::vtkCloudMatSource() { SetNumberOfInputPorts(0); }
+cv::viz::vtkCloudMatSource::~vtkCloudMatSource() {}
+
+int cv::viz::vtkCloudMatSource::SetCloud(InputArray _cloud)
+{
+    CV_Assert(_cloud.depth() == CV_32F || _cloud.depth() == CV_64F);
+    CV_Assert(_cloud.channels() == 3 || _cloud.channels() == 4);
+
+    Mat cloud = _cloud.getMat();
+
+    int total = _cloud.depth() == CV_32F ? filterNanCopy<float>(cloud) : filterNanCopy<double>(cloud);
+
+    vertices = vtkSmartPointer<vtkCellArray>::New();
+    vertices->Allocate(vertices->EstimateSize(1, total));
+    vertices->InsertNextCell(total);
+    for(int i = 0; i < total; ++i)
+        vertices->InsertCellPoint(i);
+
+    return total;
+}
+
+int cv::viz::vtkCloudMatSource::SetColorCloud(InputArray _cloud, InputArray _colors)
+{
+    int total = SetCloud(_cloud);
+
+    if (_colors.empty())
+        return total;
+
+    CV_Assert(_colors.depth() == CV_8U && _colors.channels() <= 4 && _colors.channels() != 2);
+    CV_Assert(_colors.size() == _cloud.size());
+
+    Mat cloud = _cloud.getMat();
+    Mat colors = _colors.getMat();
+
+    if (cloud.depth() == CV_32F)
+        filterNanColorsCopy<float>(colors, cloud, total);
+    else if (cloud.depth() == CV_64F)
+        filterNanColorsCopy<double>(colors, cloud, total);
+
+    return total;
+}
+
+int cv::viz::vtkCloudMatSource::SetColorCloudNormals(InputArray _cloud, InputArray _colors, InputArray _normals)
+{
+    int total = SetColorCloud(_cloud, _colors);
+
+    if (_normals.empty())
+        return total;
+
+    CV_Assert(_normals.depth() == CV_32F || _normals.depth() == CV_64F);
+    CV_Assert(_normals.channels() == 3 || _normals.channels() == 4);
+    CV_Assert(_normals.size() == _cloud.size());
+
+    Mat c = _cloud.getMat();
+    Mat n = _normals.getMat();
+
+    if (n.depth() == CV_32F && c.depth() == CV_32F)
+        filterNanNormalsCopy<float, float>(n, c, total);
+    else if (n.depth() == CV_32F && c.depth() == CV_64F)
+        filterNanNormalsCopy<float, double>(n, c, total);
+    else if (n.depth() == CV_64F && c.depth() == CV_32F)
+        filterNanNormalsCopy<double, float>(n, c, total);
+    else if (n.depth() == CV_64F && c.depth() == CV_64F)
+        filterNanNormalsCopy<double, double>(n, c, total);
+    else
+        CV_Error(Error::StsError, "Unsupported normals/cloud type");
+
+    return total;
+}
+
+int cv::viz::vtkCloudMatSource::SetColorCloudNormalsTCoords(InputArray _cloud, InputArray _colors, InputArray _normals, InputArray _tcoords)
+{
+    int total = SetColorCloudNormals(_cloud, _colors, _normals);
+
+    if (_tcoords.empty())
+        return total;
+
+    CV_Assert(_tcoords.depth() == CV_32F || _tcoords.depth() == CV_64F);
+    CV_Assert(_tcoords.channels() == 2 && _tcoords.size() == _cloud.size());
+
+    Mat cl = _cloud.getMat();
+    Mat tc = _tcoords.getMat();
+
+    if (tc.depth() == CV_32F && cl.depth() == CV_32F)
+        filterNanTCoordsCopy<float, float>(tc, cl, total);
+    else if (tc.depth() == CV_32F && cl.depth() == CV_64F)
+        filterNanTCoordsCopy<float, double>(tc, cl, total);
+    else if (tc.depth() == CV_64F && cl.depth() == CV_32F)
+        filterNanTCoordsCopy<double, float>(tc, cl, total);
+    else if (tc.depth() == CV_64F && cl.depth() == CV_64F)
+        filterNanTCoordsCopy<double, double>(tc, cl, total);
+    else
+        CV_Error(Error::StsError, "Unsupported tcoords/cloud type");
+
+    return total;
+}
+
+int cv::viz::vtkCloudMatSource::RequestData(vtkInformation *vtkNotUsed(request), vtkInformationVector **vtkNotUsed(inputVector), vtkInformationVector *outputVector)
+{
+    vtkInformation *outInfo = outputVector->GetInformationObject(0);
+    vtkPolyData *output = vtkPolyData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));
+
+    output->SetPoints(points);
+    output->SetVerts(vertices);
+    if (scalars)
+        output->GetPointData()->SetScalars(scalars);
+
+    if (normals)
+        output->GetPointData()->SetNormals(normals);
+
+    if (tcoords)
+        output->GetPointData()->SetTCoords(tcoords);
+
+    return 1;
+}
+
+template<typename _Tp>
+int cv::viz::vtkCloudMatSource::filterNanCopy(const Mat& cloud)
+{
+    CV_DbgAssert(DataType<_Tp>::depth == cloud.depth());
+    points = vtkSmartPointer<vtkPoints>::New();
+    points->SetDataType(VtkDepthTraits<_Tp>::data_type);
+    points->Allocate((vtkIdType)cloud.total());
+    points->SetNumberOfPoints((vtkIdType)cloud.total());
+
+    int s_chs = cloud.channels();
+    int total = 0;
+    for (int y = 0; y < cloud.rows; ++y)
+    {
+        const _Tp* srow = cloud.ptr<_Tp>(y);
+        const _Tp* send = srow + cloud.cols * s_chs;
+
+        for (; srow != send; srow += s_chs)
+            if (!isNan(srow))
+                points->SetPoint(total++, srow);
+    }
+    points->SetNumberOfPoints(total);
+    points->Squeeze();
+    return total;
+}
+
+template<typename _Msk>
+void cv::viz::vtkCloudMatSource::filterNanColorsCopy(const Mat& cloud_colors, const Mat& mask, int total)
+{
+    Vec3b* array = new Vec3b[total];
+    Vec3b* pos = array;
+
+    int s_chs = cloud_colors.channels();
+    int m_chs = mask.channels();
+    for (int y = 0; y < cloud_colors.rows; ++y)
+    {
+        const unsigned char* srow = cloud_colors.ptr<unsigned char>(y);
+        const unsigned char* send = srow + cloud_colors.cols * s_chs;
+        const _Msk* mrow = mask.ptr<_Msk>(y);
+
+        if (cloud_colors.channels() == 1)
+        {
+            for (; srow != send; srow += s_chs, mrow += m_chs)
+                if (!isNan(mrow))
+                    *pos++ = Vec3b(srow[0], srow[0], srow[0]);
+        }
+        else
+            for (; srow != send; srow += s_chs, mrow += m_chs)
+                if (!isNan(mrow))
+                    *pos++ = Vec3b(srow[2], srow[1], srow[0]);
+
+    }
+
+    scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
+    scalars->SetName("Colors");
+    scalars->SetNumberOfComponents(3);
+    scalars->SetNumberOfTuples(total);
+    scalars->SetArray(array->val, total * 3, 0, vtkUnsignedCharArray::VTK_DATA_ARRAY_DELETE);
+}
+
+template<typename _Tn, typename _Msk>
+void cv::viz::vtkCloudMatSource::filterNanNormalsCopy(const Mat& cloud_normals, const Mat& mask, int total)
+{
+    normals = vtkSmartPointer< typename VtkDepthTraits<_Tn>::array_type >::New();
+    normals->SetName("Normals");
+    normals->SetNumberOfComponents(3);
+    normals->SetNumberOfTuples(total);
+
+    int s_chs = cloud_normals.channels();
+    int m_chs = mask.channels();
+
+    int pos = 0;
+    for (int y = 0; y < cloud_normals.rows; ++y)
+    {
+        const _Tn* srow = cloud_normals.ptr<_Tn>(y);
+        const _Tn* send = srow + cloud_normals.cols * s_chs;
+
+        const _Msk* mrow = mask.ptr<_Msk>(y);
+
+        for (; srow != send; srow += s_chs, mrow += m_chs)
+            if (!isNan(mrow))
+                normals->SetTuple(pos++, srow);
+    }
+}
+
+template<typename _Tn, typename _Msk>
+void cv::viz::vtkCloudMatSource::filterNanTCoordsCopy(const Mat& _tcoords, const Mat& mask, int total)
+{
+    typedef Vec<_Tn, 2> Vec2;
+    tcoords = vtkSmartPointer< typename VtkDepthTraits<_Tn>::array_type >::New();
+    tcoords->SetName("TextureCoordinates");
+    tcoords->SetNumberOfComponents(2);
+    tcoords->SetNumberOfTuples(total);
+
+    int pos = 0;
+    for (int y = 0; y < mask.rows; ++y)
+    {
+        const Vec2* srow = _tcoords.ptr<Vec2>(y);
+        const Vec2* send = srow + _tcoords.cols;
+        const _Msk* mrow = mask.ptr<_Msk>(y);
+
+        for (; srow != send; ++srow, mrow += mask.channels())
+            if (!isNan(mrow))
+                tcoords->SetTuple(pos++, srow->val);
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSource.h b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSource.h
new file mode 100644
index 00000000..56bd93e0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCloudMatSource.h
@@ -0,0 +1,96 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef __vtkCloudMatSource_h
+#define __vtkCloudMatSource_h
+
+#include <opencv2/core.hpp>
+#include <vtkPolyDataAlgorithm.h>
+#include <vtkSmartPointer.h>
+#include <vtkPoints.h>
+#include <vtkCellArray.h>
+
+namespace cv
+{
+    namespace viz
+    {
+        class vtkCloudMatSource : public vtkPolyDataAlgorithm
+        {
+        public:
+            static vtkCloudMatSource *New();
+            vtkTypeMacro(vtkCloudMatSource,vtkPolyDataAlgorithm)
+
+            virtual int SetCloud(InputArray cloud);
+            virtual int SetColorCloud(InputArray cloud, InputArray colors);
+            virtual int SetColorCloudNormals(InputArray cloud, InputArray colors, InputArray normals);
+            virtual int SetColorCloudNormalsTCoords(InputArray cloud, InputArray colors, InputArray normals, InputArray tcoords);
+
+        protected:
+            vtkCloudMatSource();
+            ~vtkCloudMatSource();
+
+            int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
+
+            vtkSmartPointer<vtkPoints> points;
+            vtkSmartPointer<vtkCellArray> vertices;
+            vtkSmartPointer<vtkUnsignedCharArray> scalars;
+            vtkSmartPointer<vtkDataArray> normals;
+            vtkSmartPointer<vtkDataArray> tcoords;
+        private:
+            vtkCloudMatSource(const vtkCloudMatSource&);  // Not implemented.
+            void operator=(const vtkCloudMatSource&);  // Not implemented.
+
+            template<typename _Tp> int filterNanCopy(const Mat& cloud);
+            template<typename _Msk> void filterNanColorsCopy(const Mat& cloud_colors, const Mat& mask, int total);
+
+            template<typename _Tn, typename _Msk>
+            void filterNanNormalsCopy(const Mat& cloud_normals, const Mat& mask, int total);
+
+            template<typename _Tn, typename _Msk>
+            void filterNanTCoordsCopy(const Mat& tcoords, const Mat& mask, int total);
+        };
+    }
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCocoaInteractorFix.mm b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCocoaInteractorFix.mm
new file mode 100644
index 00000000..294556fe
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkCocoaInteractorFix.mm
@@ -0,0 +1,227 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//  This workaround code was taken from PCL library(www.pointclouds.org)
+//
+//M*/
+
+#import <Cocoa/Cocoa.h>
+#include <vtkCocoaRenderWindow.h>
+#include <vtkCocoaRenderWindowInteractor.h>
+#include <vtkObjectFactory.h>
+#include <vtkSmartPointer.h>
+#include <vtkVersion.h>
+
+namespace cv { namespace viz {
+    vtkSmartPointer<vtkRenderWindowInteractor> vtkCocoaRenderWindowInteractorNew();
+}} // namespace
+
+#if ((VTK_MAJOR_VERSION < 6) || ((VTK_MAJOR_VERSION == 6) && (VTK_MINOR_VERSION < 2)))
+
+
+//----------------------------------------------------------------------------
+@interface vtkCocoaServerFix : NSObject
+{
+    vtkCocoaRenderWindow* renWin;
+}
+
++ (id)cocoaServerWithRenderWindow:(vtkCocoaRenderWindow*)inRenderWindow;
+
+- (void)start;
+- (void)stop;
+- (void)breakEventLoop;
+
+@end
+
+//----------------------------------------------------------------------------
+@implementation vtkCocoaServerFix
+
+//----------------------------------------------------------------------------
+- (id)initWithRenderWindow:(vtkCocoaRenderWindow *)inRenderWindow
+{
+    self = [super init];
+    if (self)
+        renWin = inRenderWindow;
+    return self;
+}
+
+//----------------------------------------------------------------------------
++ (id)cocoaServerWithRenderWindow:(vtkCocoaRenderWindow *)inRenderWindow
+{
+    vtkCocoaServerFix *server = [[[vtkCocoaServerFix alloc] initWithRenderWindow:inRenderWindow] autorelease];
+    return server;
+}
+
+//----------------------------------------------------------------------------
+- (void)start
+{
+    // Retrieve the NSWindow.
+    NSWindow *win = nil;
+    if (renWin)
+    {
+        win = reinterpret_cast<NSWindow*> (renWin->GetRootWindow ());
+
+        // We don't want to be informed of every window closing, so check for nil.
+        if (win != nil)
+        {
+            // Register for the windowWillClose notification in order to stop the run loop if the window closes.
+            NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+            [nc addObserver:self selector:@selector(windowWillClose:) name:NSWindowWillCloseNotification object:win];
+        }
+    }
+    // Start the NSApplication's run loop
+    NSApplication* application = [NSApplication sharedApplication];
+    [application run];
+}
+
+//----------------------------------------------------------------------------
+- (void)stop
+{
+    [self breakEventLoop];
+}
+
+//----------------------------------------------------------------------------
+- (void)breakEventLoop
+{
+    NSApplication* application = [NSApplication sharedApplication];
+    [application stop:application];
+
+    NSEvent *event = [NSEvent otherEventWithType:NSApplicationDefined
+            location:NSMakePoint(0.0,0.0)
+            modifierFlags:0
+            timestamp:0
+            windowNumber:-1
+            context:nil
+            subtype:0
+            data1:0
+            data2:0];
+    [application postEvent:event atStart:YES];
+}
+
+//----------------------------------------------------------------------------
+- (void)windowWillClose:(NSNotification*)aNotification
+{
+    (void)aNotification;
+
+    NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+    [nc removeObserver:self name:NSWindowWillCloseNotification object:nil];
+
+    if (renWin)
+    {
+        int windowCreated = renWin->GetWindowCreated ();
+        if (windowCreated)
+        {
+            [self breakEventLoop];
+
+            // The NSWindow is closing, so prevent anyone from accidentally using it
+            renWin->SetRootWindow(NULL);
+        }
+    }
+}
+
+@end
+
+//----------------------------------------------------------------------------
+
+namespace cv { namespace viz
+{
+    class vtkCocoaRenderWindowInteractorFix : public vtkCocoaRenderWindowInteractor
+    {
+    public:
+        static vtkCocoaRenderWindowInteractorFix *New ();
+        vtkTypeMacro (vtkCocoaRenderWindowInteractorFix, vtkCocoaRenderWindowInteractor)
+
+        virtual void Start ();
+        virtual void TerminateApp ();
+
+    protected:
+        vtkCocoaRenderWindowInteractorFix () {}
+        ~vtkCocoaRenderWindowInteractorFix () {}
+
+    private:
+        vtkCocoaRenderWindowInteractorFix (const vtkCocoaRenderWindowInteractorFix&);  // Not implemented.
+        void operator = (const vtkCocoaRenderWindowInteractorFix&);  // Not implemented.
+    };
+
+    vtkStandardNewMacro (vtkCocoaRenderWindowInteractorFix)
+}}
+
+void cv::viz::vtkCocoaRenderWindowInteractorFix::Start ()
+{
+    vtkCocoaRenderWindow* renWin = vtkCocoaRenderWindow::SafeDownCast(this->GetRenderWindow ());
+    if (renWin != NULL)
+    {
+        vtkCocoaServerFix *server = reinterpret_cast<vtkCocoaServerFix*> (this->GetCocoaServer ());
+        if (!this->GetCocoaServer ())
+        {
+            server = [vtkCocoaServerFix cocoaServerWithRenderWindow:renWin];
+            this->SetCocoaServer (reinterpret_cast<void*> (server));
+        }
+
+        [server start];
+    }
+}
+
+void cv::viz::vtkCocoaRenderWindowInteractorFix::TerminateApp ()
+{
+    vtkCocoaRenderWindow *renWin = vtkCocoaRenderWindow::SafeDownCast (this->RenderWindow);
+    if (renWin)
+    {
+        vtkCocoaServerFix *server = reinterpret_cast<vtkCocoaServerFix*> (this->GetCocoaServer ());
+        [server stop];
+    }
+}
+
+vtkSmartPointer<vtkRenderWindowInteractor> cv::viz::vtkCocoaRenderWindowInteractorNew()
+{
+    return vtkSmartPointer<vtkCocoaRenderWindowInteractorFix>::New();
+}
+
+
+#else
+
+vtkSmartPointer<vtkRenderWindowInteractor> cv::viz::vtkCocoaRenderWindowInteractorNew()
+{
+    return vtkSmartPointer<vtkCocoaRenderWindowInteractor>::New();
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkImageMatSource.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkImageMatSource.cpp
new file mode 100644
index 00000000..d9de698d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkImageMatSource.cpp
@@ -0,0 +1,143 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "../precomp.hpp"
+
+namespace cv { namespace viz
+{
+    vtkStandardNewMacro(vtkImageMatSource);
+}}
+
+cv::viz::vtkImageMatSource::vtkImageMatSource()
+{
+    this->SetNumberOfInputPorts(0);
+    this->ImageData = vtkSmartPointer<vtkImageData>::New();
+}
+
+int cv::viz::vtkImageMatSource::RequestInformation(vtkInformation *, vtkInformationVector**, vtkInformationVector *outputVector)
+{
+    vtkInformation* outInfo = outputVector->GetInformationObject(0);
+
+    outInfo->Set(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT(), this->ImageData->GetExtent(), 6);
+    outInfo->Set(vtkDataObject::SPACING(), 1.0, 1.0, 1.0);
+    outInfo->Set(vtkDataObject::ORIGIN(),  0.0, 0.0, 0.0);
+
+    vtkDataObject::SetPointDataActiveScalarInfo(outInfo, this->ImageData->GetScalarType(), this->ImageData->GetNumberOfScalarComponents());
+    return 1;
+}
+
+int cv::viz::vtkImageMatSource::RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector *outputVector)
+{
+     vtkInformation *outInfo = outputVector->GetInformationObject(0);
+
+     vtkImageData *output = vtkImageData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()) );
+     output->ShallowCopy(this->ImageData);
+     return 1;
+}
+
+void cv::viz::vtkImageMatSource::SetImage(InputArray _image)
+{
+    CV_Assert(_image.depth() == CV_8U && (_image.channels() == 1 || _image.channels() == 3 || _image.channels() == 4));
+
+    Mat image = _image.getMat();
+
+    this->ImageData->SetDimensions(image.cols, image.rows, 1);
+#if VTK_MAJOR_VERSION <= 5
+    this->ImageData->SetNumberOfScalarComponents(image.channels());
+    this->ImageData->SetScalarTypeToUnsignedChar();
+    this->ImageData->AllocateScalars();
+#else
+    this->ImageData->AllocateScalars(VTK_UNSIGNED_CHAR, image.channels());
+#endif
+
+    switch(image.channels())
+    {
+    case 1: copyGrayImage(image, this->ImageData); break;
+    case 3: copyRGBImage (image, this->ImageData); break;
+    case 4: copyRGBAImage(image, this->ImageData); break;
+    }
+    this->ImageData->Modified();
+}
+
+void cv::viz::vtkImageMatSource::copyGrayImage(const Mat &source, vtkSmartPointer<vtkImageData> output)
+{
+    unsigned char* dptr = reinterpret_cast<unsigned char*>(output->GetScalarPointer());
+    size_t elem_step = output->GetIncrements()[1]/sizeof(unsigned char);
+
+    for (int y = 0; y < source.rows; ++y)
+    {
+        unsigned char* drow = dptr + elem_step * y;
+        const unsigned char *srow = source.ptr<unsigned char>(y);
+        for (int x = 0; x < source.cols; ++x)
+            drow[x] = *srow++;
+    }
+}
+
+void cv::viz::vtkImageMatSource::copyRGBImage(const Mat &source, vtkSmartPointer<vtkImageData> output)
+{
+    Vec3b* dptr = reinterpret_cast<Vec3b*>(output->GetScalarPointer());
+    size_t elem_step = output->GetIncrements()[1]/sizeof(Vec3b);
+
+    for (int y = 0; y < source.rows; ++y)
+    {
+        Vec3b* drow = dptr + elem_step * y;
+        const unsigned char *srow = source.ptr<unsigned char>(y);
+        for (int x = 0; x < source.cols; ++x, srow += source.channels())
+            drow[x] = Vec3b(srow[2], srow[1], srow[0]);
+    }
+}
+
+void cv::viz::vtkImageMatSource::copyRGBAImage(const Mat &source, vtkSmartPointer<vtkImageData> output)
+{
+    Vec4b* dptr = reinterpret_cast<Vec4b*>(output->GetScalarPointer());
+    size_t elem_step = output->GetIncrements()[1]/sizeof(Vec4b);
+
+    for (int y = 0; y < source.rows; ++y)
+    {
+        Vec4b* drow = dptr + elem_step * y;
+        const unsigned char *srow = source.ptr<unsigned char>(y);
+        for (int x = 0; x < source.cols; ++x, srow += source.channels())
+            drow[x] = Vec4b(srow[2], srow[1], srow[0], srow[3]);
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkImageMatSource.h b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkImageMatSource.h
new file mode 100644
index 00000000..a7a41e08
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkImageMatSource.h
@@ -0,0 +1,82 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "../precomp.hpp"
+
+#ifndef __vtkImageMatSource_h
+#define __vtkImageMatSource_h
+
+namespace cv
+{
+    namespace viz
+    {
+        class vtkImageMatSource : public vtkImageAlgorithm
+        {
+        public:
+            static vtkImageMatSource *New();
+            vtkTypeMacro(vtkImageMatSource,vtkImageAlgorithm);
+
+            void SetImage(InputArray image);
+
+        protected:
+            vtkImageMatSource();
+            ~vtkImageMatSource() {}
+
+            vtkSmartPointer<vtkImageData> ImageData;
+
+            int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*);
+            int RequestData (vtkInformation*, vtkInformationVector**, vtkInformationVector*);
+        private:
+            vtkImageMatSource(const vtkImageMatSource&);  // Not implemented.
+            void operator=(const vtkImageMatSource&);  // Not implemented.
+
+            static void copyGrayImage(const Mat &source, vtkSmartPointer<vtkImageData> output);
+            static void copyRGBImage (const Mat &source, vtkSmartPointer<vtkImageData> output);
+            static void copyRGBAImage(const Mat &source, vtkSmartPointer<vtkImageData> output);
+        };
+    }
+}
+
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkOBJWriter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkOBJWriter.cpp
new file mode 100644
index 00000000..2e5764fc
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkOBJWriter.cpp
@@ -0,0 +1,274 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "../precomp.hpp"
+
+namespace cv { namespace viz
+{
+    vtkStandardNewMacro(vtkOBJWriter);
+}}
+
+cv::viz::vtkOBJWriter::vtkOBJWriter()
+{
+    std::ofstream fout; // only used to extract the default precision
+    this->DecimalPrecision = fout.precision();
+    this->FileName = NULL;
+}
+
+cv::viz::vtkOBJWriter::~vtkOBJWriter(){}
+
+void cv::viz::vtkOBJWriter::WriteData()
+{
+    vtkPolyData *input = this->GetInput();
+    if (!input)
+        return;
+
+    if (!this->FileName )
+    {
+        vtkErrorMacro(<< "No FileName specified! Can't write!");
+        this->SetErrorCode(vtkErrorCode::NoFileNameError);
+        return;
+    }
+
+    vtkDebugMacro(<<"Opening vtk file for writing...");
+    std::ostream *outfilep = new std::ofstream(this->FileName, ios::out);
+    if (outfilep->fail())
+    {
+        vtkErrorMacro(<< "Unable to open file: "<< this->FileName);
+        this->SetErrorCode(vtkErrorCode::CannotOpenFileError);
+        delete outfilep;
+        return;
+    }
+
+    std::ostream& outfile = *outfilep;
+
+    //write header
+    outfile << "# wavefront obj file written by opencv viz module" << std::endl << std::endl;
+    outfile << "mtllib NONE" << std::endl << std::endl;
+
+    // write out the points
+    for (int i = 0; i < input->GetNumberOfPoints(); i++)
+    {
+        Vec3d p;
+        input->GetPoint(i, p.val);
+        outfile << std::setprecision(this->DecimalPrecision) << "v " << p[0] << " " << p[1] << " " << p[2] << std::endl;
+    }
+
+    const int idStart = 1;
+
+    // write out the point data
+    vtkSmartPointer<vtkDataArray> normals = input->GetPointData()->GetNormals();
+    if(normals)
+    {
+        for (int i = 0; i < normals->GetNumberOfTuples(); i++)
+        {
+            Vec3d p;
+            normals->GetTuple(i, p.val);
+            outfile << std::setprecision(this->DecimalPrecision) << "vn " << p[0] << " " << p[1] << " " << p[2] << std::endl;
+        }
+    }
+
+    vtkSmartPointer<vtkDataArray> tcoords = input->GetPointData()->GetTCoords();
+    if (tcoords)
+    {
+        for (int i = 0; i < tcoords->GetNumberOfTuples(); i++)
+        {
+            Vec2d p;
+            tcoords->GetTuple(i, p.val);
+            outfile << std::setprecision(this->DecimalPrecision) << "vt " << p[0] << " " << p[1] << std::endl;
+        }
+    }
+
+    // write out a group name and material
+    outfile << std::endl << "g grp" << idStart << std::endl;
+    outfile << "usemtl mtlNONE" << std::endl;
+
+    // write out verts if any
+    if (input->GetNumberOfVerts() > 0)
+    {
+        vtkIdType npts = 0;
+        CellIterT index = 0;
+        vtkCellArray *cells = input->GetVerts();
+        for (cells->InitTraversal(); cells->GetNextCell(npts, index); )
+        {
+            outfile << "p ";
+            for (int i = 0; i < npts; i++)
+                outfile << index[i] + idStart << " ";
+            outfile << std::endl;
+        }
+    }
+
+    // write out lines if any
+    if (input->GetNumberOfLines() > 0)
+    {
+        vtkIdType npts = 0;
+        CellIterT index = 0;
+        vtkCellArray *cells = input->GetLines();
+        for (cells->InitTraversal(); cells->GetNextCell(npts, index); )
+        {
+            outfile << "l ";
+            if (tcoords)
+            {
+                for (int i = 0; i < npts; i++)
+                    outfile << index[i] + idStart << "/" << index[i] + idStart << " ";
+            }
+            else
+                for (int i = 0; i < npts; i++)
+                    outfile << index[i] + idStart << " ";
+
+            outfile << std::endl;
+        }
+    }
+
+    // write out polys if any
+    if (input->GetNumberOfPolys() > 0)
+    {
+        vtkIdType npts = 0;
+        CellIterT index = 0;
+        vtkCellArray *cells = input->GetPolys();
+        for (cells->InitTraversal(); cells->GetNextCell(npts, index); )
+        {
+            outfile << "f ";
+            for (int i = 0; i < npts; i++)
+            {
+                if (normals)
+                {
+                    if (tcoords)
+                        outfile << index[i] + idStart << "/"  << index[i] + idStart << "/" << index[i] + idStart << " ";
+                    else
+                        outfile << index[i] + idStart << "//" << index[i] + idStart << " ";
+                }
+                else
+                {
+                    if (tcoords)
+                        outfile << index[i] + idStart << " " << index[i] + idStart << " ";
+                    else
+                        outfile << index[i] + idStart << " ";
+                }
+            }
+            outfile << std::endl;
+        }
+    }
+
+    // write out tstrips if any
+    if (input->GetNumberOfStrips() > 0)
+    {
+        vtkIdType npts = 0;
+        CellIterT index = 0;
+        vtkCellArray *cells = input->GetStrips();
+        for (cells->InitTraversal(); cells->GetNextCell(npts, index); )
+        {
+            for (int i = 2, i1, i2; i < npts; ++i)
+            {
+                if (i % 2)
+                {
+                    i1 = i - 1;
+                    i2 = i - 2;
+                }
+                else
+                {
+                    i1 = i - 1;
+                    i2 = i - 2;
+                }
+
+                if(normals)
+                {
+                    if (tcoords)
+                    {
+                        outfile << "f " << index[i1] + idStart << "/" << index[i1] + idStart << "/" << index[i1] + idStart << " "
+                            << index[i2]+ idStart << "/" << index[i2] + idStart << "/" << index[i2] + idStart << " "
+                            << index[i] + idStart << "/" << index[i]  + idStart << "/" << index[i]  + idStart << std::endl;
+                    }
+                    else
+                    {
+                        outfile << "f " << index[i1] + idStart << "//" << index[i1] + idStart << " " << index[i2] + idStart
+                                << "//" << index[i2] + idStart << " "  << index[i]  + idStart << "//" << index[i] + idStart << std::endl;
+                    }
+                }
+                else
+                {
+                    if (tcoords)
+                    {
+                        outfile << "f " << index[i1] + idStart << "/" << index[i1] + idStart << " " << index[i2] + idStart
+                                << "/" << index[i2] + idStart << " "  << index[i]  + idStart << "/" << index[i]  + idStart << std::endl;
+                    }
+                    else
+                        outfile << "f " << index[i1] + idStart << " " << index[i2] + idStart << " " << index[i] + idStart << std::endl;
+                }
+            } /* for (int i = 2; i < npts; ++i) */
+        }
+    } /* if (input->GetNumberOfStrips() > 0) */
+
+    vtkDebugMacro(<<"Closing vtk file\n");
+    delete outfilep;
+
+    // Delete the file if an error occurred
+    if (this->ErrorCode == vtkErrorCode::OutOfDiskSpaceError)
+    {
+        vtkErrorMacro("Ran out of disk space; deleting file: " << this->FileName);
+        unlink(this->FileName);
+    }
+}
+
+void cv::viz::vtkOBJWriter::PrintSelf(ostream& os, vtkIndent indent)
+{
+    Superclass::PrintSelf(os, indent);
+    os << indent << "DecimalPrecision: " << DecimalPrecision << "\n";
+}
+
+int cv::viz::vtkOBJWriter::FillInputPortInformation(int, vtkInformation *info)
+{
+    info->Set(vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE(), "vtkPolyData");
+    return 1;
+}
+
+vtkPolyData* cv::viz::vtkOBJWriter::GetInput()
+{
+    return vtkPolyData::SafeDownCast(this->Superclass::GetInput());
+}
+
+vtkPolyData* cv::viz::vtkOBJWriter::GetInput(int port)
+{
+    return vtkPolyData::SafeDownCast(this->Superclass::GetInput(port));
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkOBJWriter.h b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkOBJWriter.h
new file mode 100644
index 00000000..7ad0f17b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkOBJWriter.h
@@ -0,0 +1,91 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef __vtkOBJWriter_h
+#define __vtkOBJWriter_h
+
+#include <vtkWriter.h>
+
+namespace cv
+{
+    namespace viz
+    {
+        class vtkOBJWriter : public vtkWriter
+        {
+        public:
+          static vtkOBJWriter *New();
+          vtkTypeMacro(vtkOBJWriter,vtkWriter)
+          void PrintSelf(ostream& os, vtkIndent indent);
+
+          vtkGetMacro(DecimalPrecision, int)
+          vtkSetMacro(DecimalPrecision, int)
+
+          // Description:
+          // Specify file name of data file to write.
+          vtkSetStringMacro(FileName)
+          vtkGetStringMacro(FileName)
+
+          // Description:
+          // Get the input to this writer.
+          vtkPolyData* GetInput();
+          vtkPolyData* GetInput(int port);
+
+        protected:
+          vtkOBJWriter();
+          ~vtkOBJWriter();
+
+          void WriteData();
+          int FillInputPortInformation(int port, vtkInformation *info);
+
+          int DecimalPrecision;
+          char *FileName;
+
+        private:
+          vtkOBJWriter(const vtkOBJWriter&);  // Not implemented.
+          void operator=(const vtkOBJWriter&);  // Not implemented.
+        };
+    }
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkTrajectorySource.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkTrajectorySource.cpp
new file mode 100644
index 00000000..d0e180a9
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkTrajectorySource.cpp
@@ -0,0 +1,110 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "../precomp.hpp"
+
+namespace cv { namespace viz
+{
+    vtkStandardNewMacro(vtkTrajectorySource);
+}}
+
+cv::viz::vtkTrajectorySource::vtkTrajectorySource() { SetNumberOfInputPorts(0); }
+cv::viz::vtkTrajectorySource::~vtkTrajectorySource() {}
+
+void cv::viz::vtkTrajectorySource::SetTrajectory(InputArray _traj)
+{
+    CV_Assert(_traj.kind() == _InputArray::STD_VECTOR || _traj.kind() == _InputArray::MAT);
+    CV_Assert(_traj.type() == CV_32FC(16) || _traj.type() == CV_64FC(16));
+
+    Mat traj;
+    _traj.getMat().convertTo(traj, CV_64F);
+    const Affine3d* dpath = traj.ptr<Affine3d>();
+    size_t total = traj.total();
+
+    points = vtkSmartPointer<vtkPoints>::New();
+    points->SetDataType(VTK_DOUBLE);
+    points->SetNumberOfPoints((vtkIdType)total);
+
+    tensors = vtkSmartPointer<vtkDoubleArray>::New();
+    tensors->SetNumberOfComponents(9);
+    tensors->SetNumberOfTuples((vtkIdType)total);
+
+    for(size_t i = 0; i < total; ++i, ++dpath)
+    {
+        Matx33d R = dpath->rotation().t();  // transposed because of
+        tensors->SetTuple((vtkIdType)i, R.val);        // column major order
+
+        Vec3d p = dpath->translation();
+        points->SetPoint((vtkIdType)i, p.val);
+    }
+}
+
+cv::Mat cv::viz::vtkTrajectorySource::ExtractPoints(InputArray _traj)
+{
+    CV_Assert(_traj.kind() == _InputArray::STD_VECTOR || _traj.kind() == _InputArray::MAT);
+    CV_Assert(_traj.type() == CV_32FC(16) || _traj.type() == CV_64FC(16));
+
+    Mat points(1, (int)_traj.total(), CV_MAKETYPE(_traj.depth(), 3));
+    const Affine3d* dpath = _traj.getMat().ptr<Affine3d>();
+    const Affine3f* fpath = _traj.getMat().ptr<Affine3f>();
+
+    if (_traj.depth() == CV_32F)
+        for(int i = 0; i < points.cols; ++i)
+            points.at<Vec3f>(i) = fpath[i].translation();
+
+    if (_traj.depth() == CV_64F)
+        for(int i = 0; i < points.cols; ++i)
+            points.at<Vec3d>(i) = dpath[i].translation();
+
+    return points;
+}
+
+int cv::viz::vtkTrajectorySource::RequestData(vtkInformation *vtkNotUsed(request), vtkInformationVector **vtkNotUsed(inputVector), vtkInformationVector *outputVector)
+{
+    vtkInformation *outInfo = outputVector->GetInformationObject(0);
+    vtkPolyData *output = vtkPolyData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));
+    output->SetPoints(points);
+    output->GetPointData()->SetTensors(tensors);
+    return 1;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkTrajectorySource.h b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkTrajectorySource.h
new file mode 100644
index 00000000..f6c9c77b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkTrajectorySource.h
@@ -0,0 +1,84 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef __vtkTrajectorySource_h
+#define __vtkTrajectorySource_h
+
+#include <opencv2/core/mat.hpp>
+#include <vtkPolyDataAlgorithm.h>
+#include <vtkSmartPointer.h>
+#include <vtkPoints.h>
+#include <vtkCellArray.h>
+
+namespace cv
+{
+    namespace viz
+    {
+        class vtkTrajectorySource : public vtkPolyDataAlgorithm
+        {
+        public:
+            static vtkTrajectorySource *New();
+            vtkTypeMacro(vtkTrajectorySource,vtkPolyDataAlgorithm)
+
+            virtual void SetTrajectory(InputArray trajectory);
+
+            static Mat ExtractPoints(InputArray trajectory);
+
+        protected:
+            vtkTrajectorySource();
+            ~vtkTrajectorySource();
+
+            vtkSmartPointer<vtkPoints> points;
+            vtkSmartPointer<vtkDoubleArray> tensors;
+
+            int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
+        private:
+            vtkTrajectorySource(const vtkTrajectorySource&);  // Not implemented.
+            void operator=(const vtkTrajectorySource&);  // Not implemented.
+
+        };
+    }
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkVizInteractorStyle.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkVizInteractorStyle.cpp
new file mode 100644
index 00000000..e2d33806
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkVizInteractorStyle.cpp
@@ -0,0 +1,1076 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "../precomp.hpp"
+
+namespace cv { namespace viz
+{
+    vtkStandardNewMacro(vtkVizInteractorStyle)
+}}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+cv::viz::vtkVizInteractorStyle::vtkVizInteractorStyle()
+{
+    FlyMode = false;
+    MotionFactor = 10.0;
+
+    keyboardCallback_ = 0;
+    keyboard_callback_cookie_ = 0;
+
+    mouseCallback_ = 0;
+    mouse_callback_cookie_ = 0;
+
+    // Set windows size (width, height) to unknown (-1)
+    win_size_ = Vec2i(-1, -1);
+    win_pos_ = Vec2i(0, 0);
+    max_win_size_ = Vec2i(-1, -1);
+
+    stereo_anaglyph_redblue_ = true;
+
+    //from fly
+    KeysDown     = 0;
+    UseTimers    = 1;
+
+    DiagonalLength           = 1.0;
+    MotionStepSize           = 1.0/100.0;
+    MotionUserScale          = 1.0;  // +/- key adjustment
+    MotionAccelerationFactor = 10.0;
+    AngleStepSize            = 1.0;
+}
+
+cv::viz::vtkVizInteractorStyle::~vtkVizInteractorStyle() {}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::saveScreenshot(const String &file)
+{
+    FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
+
+    vtkSmartPointer<vtkWindowToImageFilter> wif = vtkSmartPointer<vtkWindowToImageFilter>::New();
+    wif->SetInput(Interactor->GetRenderWindow());
+
+    vtkSmartPointer<vtkPNGWriter> snapshot_writer = vtkSmartPointer<vtkPNGWriter>::New();
+    snapshot_writer->SetInputConnection(wif->GetOutputPort());
+    snapshot_writer->SetFileName(file.c_str());
+    snapshot_writer->Write();
+
+    cout << "Screenshot successfully captured (" << file.c_str() << ")" << endl;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::exportScene(const String &file)
+{
+    vtkSmartPointer<vtkExporter> exporter;
+    if (file.size() > 5 && file.substr(file.size() - 5) == ".vrml")
+    {
+        exporter = vtkSmartPointer<vtkVRMLExporter>::New();
+        vtkVRMLExporter::SafeDownCast(exporter)->SetFileName(file.c_str());
+    }
+    else
+    {
+        exporter = vtkSmartPointer<vtkOBJExporter>::New();
+        vtkOBJExporter::SafeDownCast(exporter)->SetFilePrefix(file.c_str());
+    }
+
+    exporter->SetInput(Interactor->GetRenderWindow());
+    exporter->Write();
+
+    cout << "Scene successfully exported (" << file.c_str() << ")" << endl;
+}
+
+void cv::viz::vtkVizInteractorStyle::exportScene()
+{
+    // Export scene as in obj or vrml format
+    String format = Interactor->GetAltKey() ? "scene-%d.vrml" : "scene-%d";
+    exportScene(cv::format(format.c_str(), (unsigned int)time(0)));
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::changePointsSize(float delta)
+{
+    vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors();
+    vtkCollectionSimpleIterator ait;
+
+    for (ac->InitTraversal(ait); vtkActor* actor = ac->GetNextActor(ait); )
+        for (actor->InitPathTraversal(); vtkAssemblyPath* path = actor->GetNextPath(); )
+        {
+            vtkActor* apart = vtkActor::SafeDownCast(path->GetLastNode()->GetViewProp());
+            float psize = apart->GetProperty()->GetPointSize() + delta;
+            psize = std::max(1.f, std::min(63.f, psize));
+            apart->GetProperty()->SetPointSize(psize);
+        }
+}
+
+void cv::viz::vtkVizInteractorStyle::setRepresentationToPoints()
+{
+    vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors();
+    vtkCollectionSimpleIterator ait;
+    for (ac->InitTraversal(ait); vtkActor* actor = ac->GetNextActor(ait); )
+        for (actor->InitPathTraversal(); vtkAssemblyPath* path = actor->GetNextPath(); )
+        {
+            vtkActor* apart = vtkActor::SafeDownCast(path->GetLastNode()->GetViewProp());
+            apart->GetProperty()->SetRepresentationToPoints();
+        }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::printCameraParams()
+{
+    vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow()->GetRenderers()->GetFirstRenderer()->GetActiveCamera();
+
+    Vec2d clip(cam->GetClippingRange());
+    Vec3d focal(cam->GetFocalPoint()), pos(cam->GetPosition()), view(cam->GetViewUp());
+    Vec2i win_pos(Interactor->GetRenderWindow()->GetPosition());
+    Vec2i win_size(Interactor->GetRenderWindow()->GetSize());
+    double angle = cam->GetViewAngle () / 180.0 * CV_PI;
+
+    String data = cv::format("clip(%f,%f) focal(%f,%f,%f) pos(%f,%f,%f) view(%f,%f,%f) angle(%f) winsz(%d,%d) winpos(%d,%d)",
+                             clip[0], clip[1], focal[0], focal[1], focal[2], pos[0], pos[1], pos[2], view[0], view[1], view[2],
+                             angle, win_size[0], win_size[1], win_pos[0], win_pos[1]);
+
+    std::cout << data.c_str() << std::endl;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::toggleFullScreen()
+{
+    Vec2i screen_size(Interactor->GetRenderWindow()->GetScreenSize());
+    Vec2i win_size(Interactor->GetRenderWindow()->GetSize());
+
+    // Is window size = max?
+    if (win_size == max_win_size_)
+    {
+        Interactor->GetRenderWindow()->SetSize(win_size_.val);
+        Interactor->GetRenderWindow()->SetPosition(win_pos_.val);
+        Interactor->Render();
+    }
+    // Set to max
+    else
+    {
+        win_pos_ = Vec2i(Interactor->GetRenderWindow()->GetPosition());
+        win_size_ = win_size;
+
+        Interactor->GetRenderWindow()->SetSize(screen_size.val);
+        Interactor->Render();
+        max_win_size_ = Vec2i(Interactor->GetRenderWindow()->GetSize());
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::resetViewerPose()
+{
+    WidgetActorMap::iterator it = widget_actor_map_->begin();
+    // it might be that some actors don't have a valid transformation set -> we skip them to avoid a seg fault.
+    for (; it != widget_actor_map_->end();  ++it)
+    {
+        vtkProp3D * actor = vtkProp3D::SafeDownCast(it->second);
+        if (actor && actor->GetUserMatrix())
+            break;
+    }
+
+    vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
+
+    // if a valid transformation was found, use it otherwise fall back to default view point.
+    if (it != widget_actor_map_->end())
+    {
+        vtkMatrix4x4* m = vtkProp3D::SafeDownCast(it->second)->GetUserMatrix();
+
+        cam->SetFocalPoint(m->GetElement(0, 3) - m->GetElement(0, 2),
+                           m->GetElement(1, 3) - m->GetElement(1, 2),
+                           m->GetElement(2, 3) - m->GetElement(2, 2));
+
+        cam->SetViewUp  (m->GetElement(0, 1), m->GetElement(1, 1), m->GetElement(2, 1));
+        cam->SetPosition(m->GetElement(0, 3), m->GetElement(1, 3), m->GetElement(2, 3));
+    }
+    else
+    {
+        cam->SetPosition(0, 0, 0);
+        cam->SetFocalPoint(0, 0, 1);
+        cam->SetViewUp(0, -1, 0);
+    }
+
+    // go to the next actor for the next key-press event.
+    if (it != widget_actor_map_->end())
+        ++it;
+    else
+        it = widget_actor_map_->begin();
+
+    CurrentRenderer->SetActiveCamera(cam);
+    CurrentRenderer->ResetCameraClippingRange();
+    Interactor->Render();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::toggleStereo()
+{
+    vtkSmartPointer<vtkRenderWindow> window = Interactor->GetRenderWindow();
+    if (!window->GetStereoRender())
+    {
+        static Vec2i red_blue(4, 3), magenta_green(2, 5);
+        window->SetAnaglyphColorMask (stereo_anaglyph_redblue_ ? red_blue.val : magenta_green.val);
+        stereo_anaglyph_redblue_ = !stereo_anaglyph_redblue_;
+    }
+    window->SetStereoRender(!window->GetStereoRender());
+    Interactor->Render();
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::printHelp()
+{
+    std::cout << "| Help:\n"
+                 "-------\n"
+                 "          p, P   : switch to a point-based representation\n"
+                 "          w, W   : switch to a wireframe-based representation (where available)\n"
+                 "          s, S   : switch to a surface-based representation (where available)\n"
+                 "\n"
+                 "          j, J   : take a .PNG snapshot of the current window view\n"
+                 "          k, K   : export scene to Wavefront .obj format\n"
+                 "    ALT + k, K   : export scene to VRML format\n"
+                 "          c, C   : display current camera/window parameters\n"
+                 "          F5     : enable/disable fly mode (changes control style)\n"
+                 "\n"
+                 "          e, E   : exit the interactor\n"
+                 "          q, Q   : stop and call VTK's TerminateApp\n"
+                 "\n"
+                 "           +/-   : increment/decrement overall point size\n"
+                 "     +/- [+ ALT] : zoom in/out \n"
+                 "\n"
+                 "    r, R [+ ALT] : reset camera [to viewpoint = {0, 0, 0} -> center_{x, y, z}]\n"
+                 "\n"
+                 "    ALT + s, S   : turn stereo mode on/off\n"
+                 "    ALT + f, F   : switch between maximized window mode and original size\n"
+                 "\n"
+              << std::endl;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::zoomIn()
+{
+    FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
+    // Zoom in
+    StartDolly();
+    double factor = 10.0 * 0.2 * .5;
+    Dolly(std::pow(1.1, factor));
+    EndDolly();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::zoomOut()
+{
+    FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
+    // Zoom out
+    StartDolly();
+    double factor = 10.0 * -0.2 * .5;
+    Dolly(std::pow(1.1, factor));
+    EndDolly();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnChar()
+{
+    FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
+
+    String key(Interactor->GetKeySym());
+    if (key.find("XF86ZoomIn") != String::npos)
+        zoomIn();
+    else if (key.find("XF86ZoomOut") != String::npos)
+        zoomOut();
+
+    switch (Interactor->GetKeyCode())
+    {
+//    // All of the options below simply exit
+//    case 'l': case 'L': case 'j': case 'J': case 'c': case 'C': case 'q': case 'Q':
+//    case 'f': case 'F': case 'g': case 'G': case 'o': case 'O': case 'u': case 'U':
+    case 'p': case 'P':
+        break;
+
+    case '+':
+        if (FlyMode)
+            MotionUserScale = std::min(16.0, MotionUserScale*2.0);
+        break;
+    case '-':
+        if (FlyMode)
+            MotionUserScale = std::max(MotionUserScale * 0.5, 0.0625);
+        break;
+
+    case 'r': case 'R': case 's': case 'S':
+        if (!Interactor->GetAltKey())
+            Superclass::OnChar();
+        break;
+    default:
+        Superclass::OnChar();
+        break;
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
+{
+    mouseCallback_ = callback;
+    mouse_callback_cookie_ = cookie;
+}
+
+void cv::viz::vtkVizInteractorStyle::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void *cookie)
+{
+    keyboardCallback_ = callback;
+    keyboard_callback_cookie_ = cookie;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+int cv::viz::vtkVizInteractorStyle::getModifiers()
+{
+    int modifiers = KeyboardEvent::NONE;
+
+    if (Interactor->GetAltKey())
+        modifiers |= KeyboardEvent::ALT;
+
+    if (Interactor->GetControlKey())
+        modifiers |= KeyboardEvent::CTRL;
+
+    if (Interactor->GetShiftKey())
+        modifiers |= KeyboardEvent::SHIFT;
+    return modifiers;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnKeyDown()
+{
+    FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
+
+    String key(Interactor->GetKeySym());
+    if (key.find("XF86ZoomIn") != String::npos)
+        zoomIn();
+    else if (key.find("XF86ZoomOut") != String::npos)
+        zoomOut();
+    else if (key.find("F5") != String::npos)
+    {
+        FlyMode = !FlyMode;
+        std::cout << (FlyMode ? "Fly mode: on" : "Fly mode: off") << std::endl;
+    }
+
+    // Save the initial windows width/height
+    if (win_size_[0] == -1 || win_size_[1] == -1)
+        win_size_ = Vec2i(Interactor->GetRenderWindow()->GetSize());
+
+    switch (Interactor->GetKeyCode())
+    {
+    case 'a': case 'A' : KeysDown |=16; break;
+    case 'z': case 'Z' : KeysDown |=32; break;
+    case 'h': case 'H' : printHelp();   break;
+    case 'p': case 'P' : setRepresentationToPoints(); break;
+    case 'k': case 'K' : exportScene(); break;
+    case 'j': case 'J' : saveScreenshot(cv::format("screenshot-%d.png", (unsigned int)time(0))); break;
+    case 'c': case 'C' : printCameraParams(); break;
+    case '=':           zoomIn();            break;
+    case 43:        // KEY_PLUS
+    {
+        if (FlyMode)
+            break;
+        if (Interactor->GetAltKey())
+            zoomIn();
+        else
+            changePointsSize(+1.f);
+        break;
+    }
+    case 45:        // KEY_MINUS
+    {
+        if (FlyMode)
+            break;
+        if (Interactor->GetAltKey())
+            zoomOut();
+        else
+           changePointsSize(-1.f);
+        break;
+    }
+        // Switch between maximize and original window size
+    case 'f': case 'F':
+    {
+        if (Interactor->GetAltKey())
+            toggleFullScreen();
+        break;
+    }
+        // 's'/'S' w/out ALT
+    case 's': case 'S':
+    {
+        if (Interactor->GetAltKey())
+            toggleStereo();
+        break;
+    }
+
+    case 'o': case 'O':
+    {
+        vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
+        cam->SetParallelProjection(!cam->GetParallelProjection());
+        Interactor->Render();
+        break;
+    }
+
+    // Overwrite the camera reset
+    case 'r': case 'R':
+    {
+        if (Interactor->GetAltKey())
+            resetViewerPose();
+        break;
+    }
+    case 'q': case 'Q':
+        Interactor->ExitCallback(); return;
+    default:
+        Superclass::OnKeyDown(); break;
+    }
+
+    KeyboardEvent event(KeyboardEvent::KEY_DOWN, Interactor->GetKeySym(), Interactor->GetKeyCode(), getModifiers());
+    if (keyboardCallback_)
+        keyboardCallback_(event, keyboard_callback_cookie_);
+
+    if (FlyMode && (KeysDown & (32+16)) == (32+16))
+    {
+        if (State == VTKIS_FORWARDFLY || State == VTKIS_REVERSEFLY)
+            StopState();
+    }
+    else if (FlyMode && (KeysDown & 32) == 32)
+    {
+        if (State == VTKIS_FORWARDFLY)
+            StopState();
+
+        if (State == VTKIS_NONE)
+            StartState(VTKIS_REVERSEFLY);
+    }
+    else if (FlyMode && (KeysDown & 16) == 16)
+    {
+        if (State == VTKIS_REVERSEFLY)
+            StopState();
+
+        if (State == VTKIS_NONE)
+            StartState(VTKIS_FORWARDFLY);
+    }
+
+    Interactor->Render();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnKeyUp()
+{
+    KeyboardEvent event(KeyboardEvent::KEY_UP, Interactor->GetKeySym(), Interactor->GetKeyCode(), getModifiers());
+    if (keyboardCallback_)
+        keyboardCallback_(event, keyboard_callback_cookie_);
+
+    switch (Interactor->GetKeyCode())
+    {
+    case 'a': case 'A' : KeysDown &= ~16; break;
+    case 'z': case 'Z' : KeysDown &= ~32; break;
+    }
+
+    if (State == VTKIS_FORWARDFLY && (KeysDown & 16) == 0)
+        StopState();
+
+    if (State == VTKIS_REVERSEFLY && (KeysDown & 32) == 0)
+        StopState();
+
+    Superclass::OnKeyUp();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnMouseMove()
+{
+    Vec2i p(Interactor->GetEventPosition());
+    MouseEvent event(MouseEvent::MouseMove, MouseEvent::NoButton, p, getModifiers());
+    if (mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+
+    FindPokedRenderer(p[0], p[1]);
+
+    if (State == VTKIS_ROTATE || State == VTKIS_PAN || State == VTKIS_DOLLY || State == VTKIS_SPIN)
+    {
+        switch (State)
+        {
+        case VTKIS_ROTATE: Rotate(); break;
+        case VTKIS_PAN:    Pan();    break;
+        case VTKIS_DOLLY:  Dolly();  break;
+        case VTKIS_SPIN:   Spin();   break;
+        }
+
+        InvokeEvent(vtkCommand::InteractionEvent, NULL);
+    }
+
+    if (State == VTKIS_FORWARDFLY || State == VTKIS_REVERSEFLY)
+    {
+        vtkCamera *cam = CurrentRenderer->GetActiveCamera();
+        Vec2i thispos(Interactor->GetEventPosition());
+        Vec2i lastpos(Interactor->GetLastEventPosition());
+
+        // we want to steer by an amount proportional to window viewangle and size
+        // compute dx and dy increments relative to last mouse click
+        Vec2i size(Interactor->GetSize());
+        double scalefactor = 5*cam->GetViewAngle()/size[0];
+
+        double dx = - (thispos[0] - lastpos[0])*scalefactor*AngleStepSize;
+        double dy =   (thispos[1] - lastpos[1])*scalefactor*AngleStepSize;
+
+        // Temporary until I get smooth flight working
+        DeltaPitch = dy;
+        DeltaYaw = dx;
+
+        InvokeEvent(vtkCommand::InteractionEvent, NULL);
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnLeftButtonDown()
+{
+    Vec2i p(Interactor->GetEventPosition());
+    MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
+    MouseEvent event(type, MouseEvent::LeftButton, p, getModifiers());
+    if (mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+
+    FindPokedRenderer(p[0], p[1]);
+    if (!CurrentRenderer)
+        return;
+
+    GrabFocus(EventCallbackCommand);
+
+    if (FlyMode)
+    {
+        if(State == VTKIS_REVERSEFLY)
+            State = VTKIS_FORWARDFLY;
+        else
+        {
+            SetupMotionVars();
+            if (State == VTKIS_NONE)
+                StartState(VTKIS_FORWARDFLY);
+        }
+    }
+    else
+    {
+        if (Interactor->GetShiftKey())
+        {
+            if (Interactor->GetControlKey())
+                StartDolly();
+            else
+                StartPan();
+        }
+        else
+        {
+            if (Interactor->GetControlKey())
+                StartSpin();
+            else
+                StartRotate();
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnLeftButtonUp()
+{
+    Vec2i p(Interactor->GetEventPosition());
+    MouseEvent event(MouseEvent::MouseButtonRelease, MouseEvent::LeftButton, p, getModifiers());
+    if (mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+
+    switch (State)
+    {
+    case VTKIS_DOLLY:      EndDolly();  break;
+    case VTKIS_PAN:        EndPan();    break;
+    case VTKIS_SPIN:       EndSpin();   break;
+    case VTKIS_ROTATE:     EndRotate(); break;
+    case VTKIS_FORWARDFLY: StopState(); break;
+    }
+
+    if (Interactor )
+        ReleaseFocus();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnMiddleButtonDown()
+{
+    Vec2i p(Interactor->GetEventPosition());
+    MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
+    MouseEvent event(type, MouseEvent::MiddleButton, p, getModifiers());
+    if (mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+
+    FindPokedRenderer(p[0], p[1]);
+    if (!CurrentRenderer)
+        return;
+
+    GrabFocus(EventCallbackCommand);
+    StartPan();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnMiddleButtonUp()
+{
+    Vec2i p(Interactor->GetEventPosition());
+    MouseEvent event(MouseEvent::MouseButtonRelease, MouseEvent::MiddleButton, p, getModifiers());
+    if (mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+
+    if (State == VTKIS_PAN)
+    {
+        EndPan();
+        if (Interactor)
+            ReleaseFocus();
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnRightButtonDown()
+{
+    Vec2i p(Interactor->GetEventPosition());
+    MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
+    MouseEvent event(type, MouseEvent::RightButton, p, getModifiers());
+    if (mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+
+    FindPokedRenderer(p[0], p[1]);
+    if (!CurrentRenderer)
+        return;
+
+    GrabFocus(EventCallbackCommand);
+
+    if (FlyMode)
+    {
+        if (State == VTKIS_FORWARDFLY)
+            State = VTKIS_REVERSEFLY;
+        else
+        {
+            SetupMotionVars();
+            if (State == VTKIS_NONE)
+                StartState(VTKIS_REVERSEFLY);
+        }
+
+    }
+    else
+        StartDolly();
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnRightButtonUp()
+{
+    Vec2i p(Interactor->GetEventPosition());
+    MouseEvent event(MouseEvent::MouseButtonRelease, MouseEvent::RightButton, p, getModifiers());
+    if (mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+
+    if(State == VTKIS_DOLLY)
+    {
+        EndDolly();
+        if (Interactor)
+            ReleaseFocus();
+    }
+
+    if (State == VTKIS_REVERSEFLY)
+    {
+        StopState();
+        if (Interactor)
+            ReleaseFocus();
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnMouseWheelForward()
+{
+    Vec2i p(Interactor->GetEventPosition());
+    MouseEvent event(MouseEvent::MouseScrollUp, MouseEvent::VScroll, p, getModifiers());
+    if (mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+    if (Interactor->GetRepeatCount() && mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+
+    if (Interactor->GetAltKey())
+    {
+        // zoom
+        vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
+        double opening_angle = cam->GetViewAngle();
+        if (opening_angle > 15.0)
+            opening_angle -= 1.0;
+
+        cam->SetViewAngle(opening_angle);
+        cam->Modified();
+        CurrentRenderer->ResetCameraClippingRange();
+        CurrentRenderer->Modified();
+        Interactor->Render();
+    }
+    else
+    {
+        FindPokedRenderer(p[0], p[1]);
+        if (!CurrentRenderer)
+            return;
+
+        GrabFocus(EventCallbackCommand);
+        StartDolly();
+        Dolly(pow(1.1, MotionFactor * 0.2 * MouseWheelMotionFactor));
+        EndDolly();
+        ReleaseFocus();
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnMouseWheelBackward()
+{
+    Vec2i p(Interactor->GetEventPosition());
+    MouseEvent event(MouseEvent::MouseScrollDown, MouseEvent::VScroll, p, getModifiers());
+    if (mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+
+    if (Interactor->GetRepeatCount() && mouseCallback_)
+        mouseCallback_(event, mouse_callback_cookie_);
+
+    if (Interactor->GetAltKey())
+    {
+        // zoom
+        vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
+        double opening_angle = cam->GetViewAngle();
+        if (opening_angle < 170.0)
+            opening_angle += 1.0;
+
+        cam->SetViewAngle(opening_angle);
+        cam->Modified();
+        CurrentRenderer->ResetCameraClippingRange();
+        CurrentRenderer->Modified();
+        Interactor->Render();
+    }
+    else
+    {
+        FindPokedRenderer(p[0], p[1]);
+        if (!CurrentRenderer)
+            return;
+
+        GrabFocus(EventCallbackCommand);
+        StartDolly();
+        Dolly(pow(1.1, MotionFactor * -0.2 * MouseWheelMotionFactor));
+        EndDolly();
+        ReleaseFocus();
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::OnTimer()
+{
+    if  (State == VTKIS_FORWARDFLY || State == VTKIS_REVERSEFLY)
+        Fly();
+
+    Interactor->Render();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::Rotate()
+{
+    if (!CurrentRenderer)
+        return;
+
+    Vec2i dxy = Vec2i(Interactor->GetEventPosition()) - Vec2i(Interactor->GetLastEventPosition());
+    Vec2i size(CurrentRenderer->GetRenderWindow()->GetSize());
+
+    double delta_elevation = -20.0 / size[1];
+    double delta_azimuth   = -20.0 / size[0];
+
+    double rxf = dxy[0] * delta_azimuth * MotionFactor;
+    double ryf = dxy[1] * delta_elevation * MotionFactor;
+
+    vtkCamera *camera = CurrentRenderer->GetActiveCamera();
+    camera->Azimuth(rxf);
+    camera->Elevation(ryf);
+    camera->OrthogonalizeViewUp();
+
+    if (AutoAdjustCameraClippingRange)
+        CurrentRenderer->ResetCameraClippingRange();
+
+    if (Interactor->GetLightFollowCamera())
+        CurrentRenderer->UpdateLightsGeometryToFollowCamera();
+
+    Interactor->Render();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::Spin()
+{
+    if (!CurrentRenderer)
+        return;
+
+    vtkRenderWindowInteractor *rwi = Interactor;
+
+    double *center = CurrentRenderer->GetCenter();
+
+    double newAngle = vtkMath::DegreesFromRadians( atan2( rwi->GetEventPosition()[1]     - center[1], rwi->GetEventPosition()[0]     - center[0] ) );
+    double oldAngle = vtkMath::DegreesFromRadians( atan2( rwi->GetLastEventPosition()[1] - center[1], rwi->GetLastEventPosition()[0] - center[0] ) );
+
+    vtkCamera *camera = CurrentRenderer->GetActiveCamera();
+    camera->Roll( newAngle - oldAngle );
+    camera->OrthogonalizeViewUp();
+
+    rwi->Render();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::vtkVizInteractorStyle::Pan()
+{
+    if (!CurrentRenderer)
+        return;
+
+    vtkRenderWindowInteractor *rwi = Interactor;
+
+    double viewFocus[4], focalDepth, viewPoint[3];
+    double newPickPoint[4], oldPickPoint[4], motionVector[3];
+
+    // Calculate the focal depth since we'll be using it a lot
+
+    vtkCamera *camera = CurrentRenderer->GetActiveCamera();
+    camera->GetFocalPoint(viewFocus);
+    ComputeWorldToDisplay(viewFocus[0], viewFocus[1], viewFocus[2], viewFocus);
+    focalDepth = viewFocus[2];
+
+    ComputeDisplayToWorld(rwi->GetEventPosition()[0], rwi->GetEventPosition()[1], focalDepth, newPickPoint);
+
+    // Has to recalc old mouse point since the viewport has moved, so can't move it outside the loop
+    ComputeDisplayToWorld(rwi->GetLastEventPosition()[0], rwi->GetLastEventPosition()[1], focalDepth, oldPickPoint);
+
+    // Camera motion is reversed
+    motionVector[0] = oldPickPoint[0] - newPickPoint[0];
+    motionVector[1] = oldPickPoint[1] - newPickPoint[1];
+    motionVector[2] = oldPickPoint[2] - newPickPoint[2];
+
+    camera->GetFocalPoint(viewFocus);
+    camera->GetPosition(viewPoint);
+    camera->SetFocalPoint(motionVector[0] + viewFocus[0], motionVector[1] + viewFocus[1], motionVector[2] + viewFocus[2]);
+    camera->SetPosition(  motionVector[0] + viewPoint[0], motionVector[1] + viewPoint[1], motionVector[2] + viewPoint[2]);
+
+    if (Interactor->GetLightFollowCamera())
+        CurrentRenderer->UpdateLightsGeometryToFollowCamera();
+
+    Interactor->Render();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::Dolly()
+{
+    if (!CurrentRenderer)
+        return;
+
+    int dy = Interactor->GetEventPosition()[1] - Interactor->GetLastEventPosition()[1];
+    Dolly(pow(1.1, MotionFactor * dy / CurrentRenderer->GetCenter()[1]));
+}
+
+void cv::viz::vtkVizInteractorStyle::Dolly(double factor)
+{
+    if (!CurrentRenderer)
+        return;
+
+    vtkCamera *camera = CurrentRenderer->GetActiveCamera();
+    if (camera->GetParallelProjection())
+        camera->SetParallelScale(camera->GetParallelScale() / factor);
+    else
+    {
+        camera->Dolly(factor);
+        if (AutoAdjustCameraClippingRange)
+            CurrentRenderer->ResetCameraClippingRange();
+    }
+
+    if (Interactor->GetLightFollowCamera())
+        CurrentRenderer->UpdateLightsGeometryToFollowCamera();
+
+    Interactor->Render();
+}
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::Fly()
+{
+    if (CurrentRenderer == NULL)
+        return;
+
+    if (KeysDown)
+        FlyByKey();
+    else
+        FlyByMouse();
+
+    CurrentRenderer->GetActiveCamera()->OrthogonalizeViewUp();
+
+    if (AutoAdjustCameraClippingRange)
+        CurrentRenderer->ResetCameraClippingRange();
+
+    if (Interactor->GetLightFollowCamera())
+        CurrentRenderer->UpdateLightsGeometryToFollowCamera();
+}
+
+void cv::viz::vtkVizInteractorStyle::SetupMotionVars()
+{
+    Vec6d bounds;
+    CurrentRenderer->ComputeVisiblePropBounds(bounds.val);
+
+    if ( !vtkMath::AreBoundsInitialized(bounds.val) )
+        DiagonalLength = 1.0;
+    else
+        DiagonalLength = norm(Vec3d(bounds[0], bounds[2], bounds[4]) - Vec3d(bounds[1], bounds[3], bounds[5]));
+}
+
+void cv::viz::vtkVizInteractorStyle::MotionAlongVector(const Vec3d& vector, double amount, vtkCamera* cam)
+{
+    // move camera and focus along DirectionOfProjection
+    Vec3d campos = Vec3d(cam->GetPosition())   - amount * vector;
+    Vec3d camfoc = Vec3d(cam->GetFocalPoint()) - amount * vector;
+
+    cam->SetPosition(campos.val);
+    cam->SetFocalPoint(camfoc.val);
+}
+
+void cv::viz::vtkVizInteractorStyle::FlyByMouse()
+{
+    vtkCamera* cam = CurrentRenderer->GetActiveCamera();
+    double speed  = DiagonalLength * MotionStepSize * MotionUserScale;
+    speed = speed * ( Interactor->GetShiftKey() ? MotionAccelerationFactor : 1.0);
+
+    // Sidestep
+    if (Interactor->GetAltKey())
+    {
+        if (DeltaYaw!=0.0)
+        {
+            vtkMatrix4x4 *vtm = cam->GetViewTransformMatrix();
+            Vec3d a_vector(vtm->GetElement(0,0), vtm->GetElement(0,1), vtm->GetElement(0,2));
+
+            MotionAlongVector(a_vector, -DeltaYaw*speed, cam);
+        }
+        if (DeltaPitch!=0.0)
+        {
+            Vec3d a_vector(cam->GetViewUp());
+            MotionAlongVector(a_vector, DeltaPitch*speed, cam);
+        }
+    }
+    else
+    {
+        cam->Yaw(DeltaYaw);
+        cam->Pitch(DeltaPitch);
+        DeltaYaw = 0;
+        DeltaPitch = 0;
+    }
+    //
+    if (!Interactor->GetControlKey())
+    {
+        Vec3d a_vector(cam->GetDirectionOfProjection()); // reversed (use -speed)
+        switch (State)
+        {
+        case VTKIS_FORWARDFLY: MotionAlongVector(a_vector, -speed, cam); break;
+        case VTKIS_REVERSEFLY: MotionAlongVector(a_vector, speed, cam); break;
+        }
+    }
+}
+
+void cv::viz::vtkVizInteractorStyle::FlyByKey()
+{
+    vtkCamera* cam = CurrentRenderer->GetActiveCamera();
+
+    double speed  = DiagonalLength * MotionStepSize * MotionUserScale;
+    speed = speed * ( Interactor->GetShiftKey() ? MotionAccelerationFactor : 1.0);
+
+    // Left and right
+    if (Interactor->GetAltKey())
+    { // Sidestep
+        vtkMatrix4x4 *vtm = cam->GetViewTransformMatrix();
+        Vec3d a_vector(vtm->GetElement(0,0), vtm->GetElement(0,1), vtm->GetElement(0,2));
+
+        if (KeysDown & 1)
+            MotionAlongVector(a_vector, -speed, cam);
+
+        if (KeysDown & 2)
+            MotionAlongVector(a_vector,  speed, cam);
+    }
+    else
+    {
+        if (KeysDown & 1)
+            cam->Yaw( AngleStepSize);
+
+        if (KeysDown & 2)
+            cam->Yaw(-AngleStepSize);
+    }
+
+    // Up and Down
+    if (Interactor->GetControlKey())
+    { // Sidestep
+        Vec3d a_vector = Vec3d(cam->GetViewUp());
+        if (KeysDown & 4)
+            MotionAlongVector(a_vector,-speed, cam);
+
+        if (KeysDown & 8)
+            MotionAlongVector(a_vector, speed, cam);
+    }
+    else
+    {
+        if (KeysDown & 4)
+            cam->Pitch(-AngleStepSize);
+
+        if (KeysDown & 8)
+            cam->Pitch( AngleStepSize);
+    }
+
+    // forward and backward
+    Vec3d a_vector(cam->GetDirectionOfProjection());
+    if (KeysDown & 16)
+        MotionAlongVector(a_vector, speed, cam);
+
+    if (KeysDown & 32)
+        MotionAlongVector(a_vector,-speed, cam);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void cv::viz::vtkVizInteractorStyle::PrintSelf(ostream& os, vtkIndent indent)
+{
+    Superclass::PrintSelf(os, indent);
+    os << indent << "MotionFactor: " << MotionFactor << "\n";
+    os << indent << "MotionStepSize: " << MotionStepSize << "\n";
+    os << indent << "MotionAccelerationFactor: "<< MotionAccelerationFactor << "\n";
+    os << indent << "AngleStepSize: " << AngleStepSize << "\n";
+    os << indent << "MotionUserScale: "<< MotionUserScale << "\n";
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkVizInteractorStyle.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkVizInteractorStyle.hpp
new file mode 100644
index 00000000..c9458ae0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkVizInteractorStyle.hpp
@@ -0,0 +1,169 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef __OPENCV_VIZ_INTERACTOR_STYLE_H__
+#define __OPENCV_VIZ_INTERACTOR_STYLE_H__
+
+#include <vtkInteractorStyle.h>
+
+namespace cv
+{
+    namespace viz
+    {
+        class vtkVizInteractorStyle : public vtkInteractorStyle
+        {
+        public:
+            static vtkVizInteractorStyle *New();
+            vtkTypeMacro(vtkVizInteractorStyle, vtkInteractorStyle)
+            void PrintSelf(ostream& os, vtkIndent indent);
+
+            virtual void OnChar();
+            virtual void OnKeyDown();
+            virtual void OnKeyUp();
+
+            virtual void OnMouseMove();
+            virtual void OnLeftButtonDown();
+            virtual void OnLeftButtonUp();
+            virtual void OnMiddleButtonDown();
+            virtual void OnMiddleButtonUp();
+            virtual void OnRightButtonDown();
+            virtual void OnRightButtonUp();
+            virtual void OnMouseWheelForward();
+            virtual void OnMouseWheelBackward();
+            virtual void OnTimer();
+
+            virtual void Rotate();
+            virtual void Spin();
+            virtual void Pan();
+            virtual void Dolly();
+
+            vtkSetMacro(FlyMode,bool)
+            vtkGetMacro(FlyMode,bool)
+
+
+            vtkSetMacro(MotionFactor, double)
+            vtkGetMacro(MotionFactor, double)
+
+            void registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie = 0);
+            void registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void * cookie = 0);
+
+            void setWidgetActorMap(const Ptr<WidgetActorMap>& actors) { widget_actor_map_ = actors; }
+            void saveScreenshot(const String &file);
+            void exportScene(const String &file);
+            void exportScene();
+            void changePointsSize(float delta);
+            void setRepresentationToPoints();
+            void printCameraParams();
+            void toggleFullScreen();
+            void resetViewerPose();
+            void toggleStereo();
+            void printHelp();
+
+            // Set the basic unit step size : by default 1/250 of bounding diagonal
+            vtkSetMacro(MotionStepSize,double)
+            vtkGetMacro(MotionStepSize,double)
+
+            // Set acceleration factor when shift key is applied : default 10
+            vtkSetMacro(MotionAccelerationFactor,double)
+            vtkGetMacro(MotionAccelerationFactor,double)
+
+            // Set the basic angular unit for turning : default 1 degree
+            vtkSetMacro(AngleStepSize,double)
+            vtkGetMacro(AngleStepSize,double)
+
+        private:
+            Ptr<WidgetActorMap> widget_actor_map_;
+
+            Vec2i win_size_;
+            Vec2i win_pos_;
+            Vec2i max_win_size_;
+
+            void zoomIn();
+            void zoomOut();
+
+        protected:
+            vtkVizInteractorStyle();
+            ~vtkVizInteractorStyle();
+
+            virtual void Dolly(double factor);
+
+            void Fly();
+            void FlyByMouse();
+            void FlyByKey();
+            void SetupMotionVars();
+            void MotionAlongVector(const Vec3d& vector, double amount, vtkCamera* cam);
+
+        private:
+            vtkVizInteractorStyle(const vtkVizInteractorStyle&);
+            vtkVizInteractorStyle& operator=(const vtkVizInteractorStyle&);
+
+            //! True for red-blue colors, false for magenta-green.
+            bool stereo_anaglyph_redblue_;
+
+            void (*keyboardCallback_)(const KeyboardEvent&, void*);
+            void *keyboard_callback_cookie_;
+
+            void (*mouseCallback_)(const MouseEvent&, void*);
+            void *mouse_callback_cookie_;
+
+            bool FlyMode;
+            double MotionFactor;
+
+            int getModifiers();
+
+            // from fly
+            unsigned char KeysDown;
+            double        DiagonalLength;
+            double        MotionStepSize;
+            double        MotionUserScale;
+            double        MotionAccelerationFactor;
+            double        AngleStepSize;
+            double        DeltaYaw;
+            double        DeltaPitch;
+        };
+    } // end namespace viz
+} // end namespace cv
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZReader.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZReader.cpp
new file mode 100644
index 00000000..3b9265fe
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZReader.cpp
@@ -0,0 +1,107 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "../precomp.hpp"
+
+namespace cv { namespace viz
+{
+    vtkStandardNewMacro(vtkXYZReader);
+}}
+
+
+cv::viz::vtkXYZReader::vtkXYZReader()
+{
+    this->FileName = 0;
+    this->SetNumberOfInputPorts(0);
+}
+
+cv::viz::vtkXYZReader::~vtkXYZReader()
+{
+    this->SetFileName(0);
+}
+
+void cv::viz::vtkXYZReader::PrintSelf(ostream& os, vtkIndent indent)
+{
+    this->Superclass::PrintSelf(os,indent);
+    os << indent << "FileName: " << (this->FileName ? this->FileName : "(none)") << "\n";
+}
+
+int cv::viz::vtkXYZReader::RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector* outputVector)
+{
+    // Make sure we have a file to read.
+    if(!this->FileName)
+    {
+        vtkErrorMacro("A FileName must be specified.");
+        return 0;
+    }
+
+    // Open the input file.
+    std::ifstream fin(this->FileName);
+    if(!fin)
+    {
+        vtkErrorMacro("Error opening file " << this->FileName);
+        return 0;
+    }
+
+    // Allocate objects to hold points and vertex cells.
+    vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+    vtkSmartPointer<vtkCellArray> verts = vtkSmartPointer<vtkCellArray>::New();
+
+    // Read points from the file.
+    vtkDebugMacro("Reading points from file " << this->FileName);
+    double x[3];
+    while(fin >> x[0] >> x[1] >> x[2])
+    {
+        vtkIdType id = points->InsertNextPoint(x);
+        verts->InsertNextCell(1, &id);
+    }
+    vtkDebugMacro("Read " << points->GetNumberOfPoints() << " points.");
+
+    // Store the points and cells in the output data object.
+    vtkPolyData* output = vtkPolyData::GetData(outputVector);
+    output->SetPoints(points);
+    output->SetVerts(verts);
+
+    return 1;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZReader.h b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZReader.h
new file mode 100644
index 00000000..13ae048e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZReader.h
@@ -0,0 +1,80 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef __vtkXYZReader_h
+#define __vtkXYZReader_h
+
+#include "vtkPolyDataAlgorithm.h"
+
+namespace cv
+{
+    namespace viz
+    {
+        class vtkXYZReader : public vtkPolyDataAlgorithm
+        {
+        public:
+          static vtkXYZReader* New();
+          vtkTypeMacro(vtkXYZReader,vtkPolyDataAlgorithm)
+          void PrintSelf(ostream& os, vtkIndent indent);
+
+          // Description:
+          // Set/Get the name of the file from which to read points.
+          vtkSetStringMacro(FileName)
+          vtkGetStringMacro(FileName)
+
+        protected:
+          vtkXYZReader();
+          ~vtkXYZReader();
+
+          char* FileName;
+
+          int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*);
+        private:
+          vtkXYZReader(const vtkXYZReader&);  // Not implemented.
+          void operator=(const vtkXYZReader&);  // Not implemented.
+        };
+    }
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZWriter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZWriter.cpp
new file mode 100644
index 00000000..56a26b38
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZWriter.cpp
@@ -0,0 +1,122 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "../precomp.hpp"
+
+namespace cv { namespace viz
+{
+    vtkStandardNewMacro(vtkXYZWriter);
+}}
+
+cv::viz::vtkXYZWriter::vtkXYZWriter()
+{
+    std::ofstream fout; // only used to extract the default precision
+    this->DecimalPrecision = fout.precision();
+}
+
+void cv::viz::vtkXYZWriter::WriteData()
+{
+    vtkPolyData *input = this->GetInput();
+    if (!input)
+        return;
+
+    if (!this->FileName )
+    {
+        vtkErrorMacro(<< "No FileName specified! Can't write!");
+        this->SetErrorCode(vtkErrorCode::NoFileNameError);
+        return;
+    }
+
+    vtkDebugMacro(<<"Opening vtk file for writing...");
+    std::ostream *outfilep = new std::ofstream(this->FileName, ios::out);
+    if (outfilep->fail())
+    {
+        vtkErrorMacro(<< "Unable to open file: "<< this->FileName);
+        this->SetErrorCode(vtkErrorCode::CannotOpenFileError);
+        delete outfilep;
+        return;
+    }
+
+    ostream &outfile = *outfilep;
+
+    for(vtkIdType i = 0; i < input->GetNumberOfPoints(); ++i)
+    {
+        Vec3d p;
+        input->GetPoint(i, p.val);
+        outfile << std::setprecision(this->DecimalPrecision) << p[0] << " " << p[1] << " " << p[2] << std::endl;
+    }
+
+    // Close the file
+    vtkDebugMacro(<<"Closing vtk file\n");
+    delete outfilep;
+
+    // Delete the file if an error occurred
+    if (this->ErrorCode == vtkErrorCode::OutOfDiskSpaceError)
+    {
+        vtkErrorMacro("Ran out of disk space; deleting file: " << this->FileName);
+        unlink(this->FileName);
+    }
+}
+
+int cv::viz::vtkXYZWriter::FillInputPortInformation(int, vtkInformation *info)
+{
+    info->Set(vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE(), "vtkPolyData");
+    return 1;
+}
+
+void cv::viz::vtkXYZWriter::PrintSelf(ostream& os, vtkIndent indent)
+{
+    this->Superclass::PrintSelf(os,indent);
+    os << indent << "DecimalPrecision: " << this->DecimalPrecision << "\n";
+}
+
+vtkPolyData* cv::viz::vtkXYZWriter::GetInput()
+{
+    return vtkPolyData::SafeDownCast(this->Superclass::GetInput());
+}
+
+vtkPolyData* cv::viz::vtkXYZWriter::GetInput(int port)
+{
+    return vtkPolyData::SafeDownCast(this->Superclass::GetInput(port));
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZWriter.h b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZWriter.h
new file mode 100644
index 00000000..91d0c8f6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/vtk/vtkXYZWriter.h
@@ -0,0 +1,90 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef __vtkXYZWriter_h
+#define __vtkXYZWriter_h
+
+#include "vtkWriter.h"
+
+namespace cv
+{
+    namespace viz
+    {
+        class vtkXYZWriter : public vtkWriter
+        {
+        public:
+            static vtkXYZWriter *New();
+            vtkTypeMacro(vtkXYZWriter,vtkWriter)
+            void PrintSelf(ostream& os, vtkIndent indent);
+
+            vtkGetMacro(DecimalPrecision, int)
+            vtkSetMacro(DecimalPrecision, int)
+
+            // Description:
+            // Specify file name of data file to write.
+            vtkSetStringMacro(FileName)
+            vtkGetStringMacro(FileName)
+
+            // Description:
+            // Get the input to this writer.
+            vtkPolyData* GetInput();
+            vtkPolyData* GetInput(int port);
+
+        protected:
+            vtkXYZWriter();
+            ~vtkXYZWriter(){}
+
+            void WriteData();
+            int FillInputPortInformation(int port, vtkInformation *info);
+
+            int DecimalPrecision;
+            char *FileName;
+
+        private:
+            vtkXYZWriter(const vtkXYZWriter&);  // Not implemented.
+            void operator=(const vtkXYZWriter&);  // Not implemented.
+        };
+    }
+}
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/widget.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/widget.cpp
new file mode 100644
index 00000000..b46d3d1c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/src/widget.cpp
@@ -0,0 +1,352 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#include "precomp.hpp"
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// widget implementation
+
+class cv::viz::Widget::Impl
+{
+public:
+    vtkSmartPointer<vtkProp> prop;
+    Impl() : prop(0) {}
+};
+
+cv::viz::Widget::Widget() : impl_( new Impl() ) { }
+
+cv::viz::Widget::Widget(const Widget& other) : impl_( new Impl() )
+{
+    if (other.impl_ && other.impl_->prop)
+        impl_->prop = other.impl_->prop;
+}
+
+cv::viz::Widget& cv::viz::Widget::operator=(const Widget& other)
+{
+    if (!impl_)
+        impl_ = new Impl();
+
+    if (other.impl_)
+        impl_->prop = other.impl_->prop;
+    return *this;
+}
+
+cv::viz::Widget::~Widget()
+{
+    if (impl_)
+    {
+        delete impl_;
+        impl_ = 0;
+    }
+}
+
+cv::viz::Widget cv::viz::Widget::fromPlyFile(const String &file_name)
+{
+    CV_Assert(vtkPLYReader::CanReadFile(file_name.c_str()));
+
+    vtkSmartPointer<vtkPLYReader> reader = vtkSmartPointer<vtkPLYReader>::New();
+    reader->SetFileName(file_name.c_str());
+
+    vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
+    mapper->SetInputConnection( reader->GetOutputPort() );
+#if VTK_MAJOR_VERSION < 8
+    mapper->ImmediateModeRenderingOff();
+#endif
+
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->GetProperty()->SetInterpolationToFlat();
+    actor->GetProperty()->BackfaceCullingOn();
+    actor->SetMapper(mapper);
+
+    Widget widget;
+    WidgetAccessor::setProp(widget, actor);
+    return widget;
+}
+
+void cv::viz::Widget::setRenderingProperty(int property, double value)
+{
+    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget type is not supported." && actor);
+
+    switch (property)
+    {
+        case POINT_SIZE:          actor->GetProperty()->SetPointSize(float(value)); break;
+        case OPACITY:             actor->GetProperty()->SetOpacity(value);          break;
+        case LINE_WIDTH:          actor->GetProperty()->SetLineWidth(float(value)); break;
+#if VTK_MAJOR_VERSION < 8
+        case IMMEDIATE_RENDERING: actor->GetMapper()->SetImmediateModeRendering(int(value)); break;
+#else
+        case IMMEDIATE_RENDERING: std::cerr << "this property has no effect" << std::endl; break;
+#endif
+        case AMBIENT:             actor->GetProperty()->SetAmbient(float(value)); break;
+        case LIGHTING:
+        {
+            if (value == 0)
+                actor->GetProperty()->LightingOff();
+            else
+                actor->GetProperty()->LightingOn();
+            break;
+        }
+        case FONT_SIZE:
+        {
+            vtkTextActor* text_actor = vtkTextActor::SafeDownCast(actor);
+            CV_Assert("Widget does not have text content." && text_actor);
+            text_actor->GetTextProperty()->SetFontSize(int(value));
+            break;
+        }
+        case REPRESENTATION:
+        {
+            switch (int(value))
+            {
+                case REPRESENTATION_POINTS:    actor->GetProperty()->SetRepresentationToPoints(); break;
+                case REPRESENTATION_WIREFRAME: actor->GetProperty()->SetRepresentationToWireframe(); break;
+                case REPRESENTATION_SURFACE:   actor->GetProperty()->SetRepresentationToSurface();  break;
+            }
+            break;
+        }
+        case SHADING:
+        {
+            switch (int(value))
+            {
+                case SHADING_FLAT: actor->GetProperty()->SetInterpolationToFlat(); break;
+                case SHADING_GOURAUD:
+                {
+                    if (!actor->GetMapper()->GetInput()->GetPointData()->GetNormals())
+                    {
+                        vtkSmartPointer<vtkPolyDataMapper> mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
+                        CV_Assert("Can't set shading property for such type of widget" && mapper);
+
+                        vtkSmartPointer<vtkPolyData> with_normals = VtkUtils::ComputeNormals(mapper->GetInput());
+                        VtkUtils::SetInputData(mapper, with_normals);
+                    }
+                    actor->GetProperty()->SetInterpolationToGouraud();
+                    break;
+                }
+                case SHADING_PHONG:
+                {
+                    if (!actor->GetMapper()->GetInput()->GetPointData()->GetNormals())
+                    {
+                        vtkSmartPointer<vtkPolyDataMapper> mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
+                        CV_Assert("Can't set shading property for such type of widget" && mapper);
+
+                        vtkSmartPointer<vtkPolyData> with_normals = VtkUtils::ComputeNormals(mapper->GetInput());
+                        VtkUtils::SetInputData(mapper, with_normals);
+                    }
+                    actor->GetProperty()->SetInterpolationToPhong();
+                    break;
+                }
+            }
+            break;
+        }
+        default:
+            CV_Assert("setRenderingProperty: Unknown property");
+    }
+    actor->Modified();
+}
+
+double cv::viz::Widget::getRenderingProperty(int property) const
+{
+    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget type is not supported." && actor);
+
+    double value = 0.0;
+    switch (property)
+    {
+        case POINT_SIZE: value = actor->GetProperty()->GetPointSize(); break;
+        case OPACITY:    value = actor->GetProperty()->GetOpacity();   break;
+        case LINE_WIDTH: value = actor->GetProperty()->GetLineWidth(); break;
+#if VTK_MAJOR_VERSION < 8
+        case IMMEDIATE_RENDERING:  value = actor->GetMapper()->GetImmediateModeRendering();  break;
+#else
+        case IMMEDIATE_RENDERING: std::cerr << "this property has no effect" << std::endl; break;
+#endif
+        case AMBIENT: value = actor->GetProperty()->GetAmbient(); break;
+        case LIGHTING: value = actor->GetProperty()->GetLighting(); break;
+        case FONT_SIZE:
+        {
+            vtkTextActor* text_actor = vtkTextActor::SafeDownCast(actor);
+            CV_Assert("Widget does not have text content." && text_actor);
+            value = text_actor->GetTextProperty()->GetFontSize();;
+            break;
+        }
+        case REPRESENTATION:
+        {
+            switch (actor->GetProperty()->GetRepresentation())
+            {
+                case VTK_POINTS:    value = REPRESENTATION_POINTS; break;
+                case VTK_WIREFRAME: value = REPRESENTATION_WIREFRAME; break;
+                case VTK_SURFACE:   value = REPRESENTATION_SURFACE; break;
+            }
+            break;
+        }
+        case SHADING:
+        {
+            switch (actor->GetProperty()->GetInterpolation())
+            {
+                case VTK_FLAT:      value = SHADING_FLAT; break;
+                case VTK_GOURAUD:   value = SHADING_GOURAUD; break;
+                case VTK_PHONG:     value = SHADING_PHONG; break;
+            }
+            break;
+        }
+        default:
+            CV_Assert("getRenderingProperty: Unknown property");
+    }
+    return value;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// widget accessor implementation
+
+vtkSmartPointer<vtkProp> cv::viz::WidgetAccessor::getProp(const Widget& widget)
+{
+    return widget.impl_->prop;
+}
+
+void cv::viz::WidgetAccessor::setProp(Widget& widget, vtkSmartPointer<vtkProp> prop)
+{
+    widget.impl_->prop = prop;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// widget3D implementation
+
+void cv::viz::Widget3D::setPose(const Affine3d &pose)
+{
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget is not 3D." && actor);
+
+    vtkSmartPointer<vtkMatrix4x4> matrix = vtkmatrix(pose.matrix);
+    actor->SetUserMatrix(matrix);
+    actor->Modified();
+}
+
+void cv::viz::Widget3D::updatePose(const Affine3d &pose)
+{
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget is not 3D." && actor);
+
+    vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
+    if (!matrix)
+    {
+        setPose(pose);
+        return;
+    }
+
+    Affine3d updated_pose = pose * Affine3d(*matrix->Element);
+    matrix = vtkmatrix(updated_pose.matrix);
+
+    actor->SetUserMatrix(matrix);
+    actor->Modified();
+}
+
+cv::Affine3d cv::viz::Widget3D::getPose() const
+{
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget is not 3D." && actor);
+    if (!actor->GetUserMatrix())
+    {
+        return Affine3d(); // empty user matrix, return an identity transform.
+    }
+    return Affine3d(*actor->GetUserMatrix()->Element);
+}
+
+void cv::viz::Widget3D::applyTransform(const Affine3d &transform)
+{
+    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget is not 3D actor." && actor);
+
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
+    CV_Assert("Widget doesn't have a polydata mapper" && mapper);
+
+    mapper->Update(); // #10945
+    VtkUtils::SetInputData(mapper, VtkUtils::TransformPolydata(mapper->GetInput(), transform));
+    mapper->Update();
+}
+
+void cv::viz::Widget3D::setColor(const Color &color)
+{
+    // Cast to actor instead of prop3d since prop3d doesn't provide getproperty
+    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget type is not supported." && actor);
+
+    Color c = vtkcolor(color);
+    actor->GetMapper()->ScalarVisibilityOff();
+    actor->GetProperty()->SetColor(c.val);
+    actor->GetProperty()->SetEdgeColor(c.val);
+    actor->Modified();
+}
+
+template<> cv::viz::Widget3D cv::viz::Widget::cast<cv::viz::Widget3D>() const
+{
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget cannot be cast." && actor);
+
+    Widget3D widget;
+    WidgetAccessor::setProp(widget, actor);
+    return widget;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// widget2D implementation
+
+void cv::viz::Widget2D::setColor(const Color &color)
+{
+    vtkActor2D *actor = vtkActor2D::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget type is not supported." && actor);
+    Color c = vtkcolor(color);
+    actor->GetProperty()->SetColor(c.val);
+    actor->Modified();
+}
+
+template<> cv::viz::Widget2D cv::viz::Widget::cast<cv::viz::Widget2D>() const
+{
+    vtkActor2D *actor = vtkActor2D::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget cannot be cast." && actor);
+
+    Widget2D widget;
+    WidgetAccessor::setProp(widget, actor);
+    return widget;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_common.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_common.cpp
new file mode 100644
index 00000000..ac0cea4b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_common.cpp
@@ -0,0 +1,27 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+cv::String cv::Path::combine(const String& item1, const String& item2)
+{
+    if (item1.empty())
+        return item2;
+
+    if (item2.empty())
+        return item1;
+
+    char last = item1[item1.size()-1];
+
+    bool need_append = last != '/' && last != '\\';
+    return item1 + (need_append ? "/" : "") + item2;
+}
+
+cv::String cv::Path::combine(const String& item1, const String& item2, const String& item3)
+{ return combine(combine(item1, item2), item3); }
+
+cv::String cv::Path::change_extension(const String& file, const String& ext)
+{
+    String::size_type pos = file.find_last_of('.');
+    return pos == String::npos ? file : file.substr(0, pos+1) + ext;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_common.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_common.hpp
new file mode 100644
index 00000000..bfd6d13c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_common.hpp
@@ -0,0 +1,87 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Ozan Tonkal, ozantonkal@gmail.com
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef OPENCV_VIZ_TEST_COMMON_HPP
+#define OPENCV_VIZ_TEST_COMMON_HPP
+
+#include <opencv2/viz/vizcore.hpp>
+
+namespace cv
+{
+    struct Path
+    {
+        static String combine(const String& item1, const String& item2);
+        static String combine(const String& item1, const String& item2, const String& item3);
+        static String change_extension(const String& file, const String& ext);
+    };
+
+    inline cv::String get_dragon_ply_file_path()
+    {
+        return Path::combine(cvtest::TS::ptr()->get_data_path(), "dragon.ply");
+    }
+
+    template<typename _Tp>
+    inline std::vector< Affine3<_Tp> > generate_test_trajectory()
+    {
+        std::vector< Affine3<_Tp> > result;
+
+        for (int i = 0, j = 0; i <= 270; i += 3, j += 10)
+        {
+            double x = 2 * cos(i * 3 * CV_PI/180.0) * (1.0 + 0.5 * cos(1.2 + i * 1.2 * CV_PI/180.0));
+            double y = 0.25 + i/270.0 + sin(j * CV_PI/180.0) * 0.2 * sin(0.6 + j * 1.5 * CV_PI/180.0);
+            double z = 2 * sin(i * 3 * CV_PI/180.0) * (1.0 + 0.5 * cos(1.2 + i * CV_PI/180.0));
+            result.push_back(viz::makeCameraPose(Vec3d(x, y, z), Vec3d::all(0.0), Vec3d(0.0, 1.0, 0.0)));
+        }
+        return result;
+    }
+
+    inline Mat make_gray(const Mat& image)
+    {
+        Mat chs[3]; split(image, chs);
+        return 0.114 * chs[0] + 0.58 * chs[1] + 0.3 * chs[2];
+    }
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_main.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_main.cpp
new file mode 100644
index 00000000..656b1d4f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_main.cpp
@@ -0,0 +1,6 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("viz")
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_precomp.hpp
new file mode 100644
index 00000000..954f0335
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_precomp.hpp
@@ -0,0 +1,10 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "opencv2/ts.hpp"
+#include "test_common.hpp"
+
+namespace opencv_test
+{
+using namespace cv::viz;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_tutorial2.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_tutorial2.cpp
new file mode 100644
index 00000000..a4b5b995
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_tutorial2.cpp
@@ -0,0 +1,58 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static void tutorial2()
+{
+    /// Create a window
+    viz::Viz3d myWindow("Coordinate Frame");
+
+    /// Add coordinate axes
+    myWindow.showWidget("Coordinate Widget", viz::WCoordinateSystem());
+
+    /// Add line to represent (1,1,1) axis
+    viz::WLine axis(Point3f(-1.0, -1.0, -1.0), Point3d(1.0, 1.0, 1.0));
+    axis.setRenderingProperty(viz::LINE_WIDTH, 4.0);
+    myWindow.showWidget("Line Widget", axis);
+
+    /// Construct a cube widget
+    viz::WCube cube_widget(Point3d(0.5, 0.5, 0.0), Point3d(0.0, 0.0, -0.5), true, viz::Color::blue());
+    cube_widget.setRenderingProperty(viz::LINE_WIDTH, 4.0);
+
+    /// Display widget (update if already displayed)
+    myWindow.showWidget("Cube Widget", cube_widget);
+
+    /// Rodrigues vector
+    Vec3d rot_vec = Vec3d::all(0);
+    double translation_phase = 0.0, translation = 0.0;
+    for(unsigned num = 0; num < 50; ++num)
+    {
+        /* Rotation using rodrigues */
+        /// Rotate around (1,1,1)
+        rot_vec[0] += CV_PI * 0.01;
+        rot_vec[1] += CV_PI * 0.01;
+        rot_vec[2] += CV_PI * 0.01;
+
+        /// Shift on (1,1,1)
+        translation_phase += CV_PI * 0.01;
+        translation = sin(translation_phase);
+
+        /// Construct pose
+        Affine3d pose(rot_vec, Vec3d(translation, translation, translation));
+
+        myWindow.setWidgetPose("Cube Widget", pose);
+
+        myWindow.spinOnce(100, true);
+    }
+}
+
+
+TEST(Viz, DISABLED_tutorial2_pose_of_widget)
+{
+    tutorial2();
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_tutorial3.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_tutorial3.cpp
new file mode 100644
index 00000000..32e33b19
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_tutorial3.cpp
@@ -0,0 +1,64 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+/**
+ * @function main
+ */
+static void tutorial3(bool camera_pov)
+{
+    /// Create a window
+    viz::Viz3d myWindow("Coordinate Frame");
+
+    /// Add coordinate axes
+    myWindow.showWidget("Coordinate Widget", viz::WCoordinateSystem());
+
+    /// Let's assume camera has the following properties
+    Point3d cam_origin(3.0, 3.0, 3.0), cam_focal_point(3.0, 3.0, 2.0), cam_y_dir(-1.0, 0.0, 0.0);
+
+    /// We can get the pose of the cam using makeCameraPose
+    Affine3d camera_pose = viz::makeCameraPose(cam_origin, cam_focal_point, cam_y_dir);
+
+    /// We can get the transformation matrix from camera coordinate system to global using
+    /// - makeTransformToGlobal. We need the axes of the camera
+    Affine3d transform = viz::makeTransformToGlobal(Vec3d(0.0, -1.0, 0.0), Vec3d(-1.0, 0.0, 0.0), Vec3d(0.0, 0.0, -1.0), cam_origin);
+
+    /// Create a cloud widget.
+    Mat dragon_cloud = viz::readCloud(get_dragon_ply_file_path());
+    viz::WCloud cloud_widget(dragon_cloud, viz::Color::green());
+
+    /// Pose of the widget in camera frame
+    Affine3d cloud_pose = Affine3d().rotate(Vec3d(0.0, CV_PI/2, 0.0)).rotate(Vec3d(0.0, 0.0, CV_PI)).translate(Vec3d(0.0, 0.0, 3.0));
+    /// Pose of the widget in global frame
+    Affine3d cloud_pose_global = transform * cloud_pose;
+
+    /// Visualize camera frame
+    myWindow.showWidget("CPW_FRUSTUM", viz::WCameraPosition(Vec2f(0.889484f, 0.523599f)), camera_pose);
+    if (!camera_pov)
+        myWindow.showWidget("CPW", viz::WCameraPosition(0.5), camera_pose);
+
+    /// Visualize widget
+    myWindow.showWidget("bunny", cloud_widget, cloud_pose_global);
+
+    /// Set the viewer pose to that of camera
+    if (camera_pov)
+        myWindow.setViewerPose(camera_pose);
+
+    /// Start event loop.
+    myWindow.spinOnce(500, true);
+}
+
+TEST(Viz, tutorial3_global_view)
+{
+    tutorial3(false);
+}
+
+TEST(Viz, tutorial3_camera_view)
+{
+    tutorial3(true);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_viz3d.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_viz3d.cpp
new file mode 100644
index 00000000..4ab05c3e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/test_viz3d.cpp
@@ -0,0 +1,65 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ // Copyright (C) 2008-2013, Willow Garage Inc., all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and / or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(Viz_viz3d, DISABLED_develop)
+{
+    cv::Mat cloud = cv::viz::readCloud(get_dragon_ply_file_path());
+
+    cv::viz::Viz3d viz("abc");
+    viz.setBackgroundMeshLab();
+    viz.showWidget("coo", cv::viz::WCoordinateSystem(1));
+    viz.showWidget("cloud", cv::viz::WPaintedCloud(cloud));
+
+    //---->>>>> <to_test_in_future>
+    //std::vector<cv::Affine3d> gt, es;
+    //cv::viz::readTrajectory(gt, "d:/Datasets/trajs/gt%05d.xml");
+    //cv::viz::readTrajectory(es, "d:/Datasets/trajs/es%05d.xml");
+    //cv::Mat cloud = cv::viz::readCloud(get_dragon_ply_file_path());
+    //---->>>>> </to_test_in_future>
+
+    viz.spinOnce(500, true);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/tests_simple.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/tests_simple.cpp
new file mode 100644
index 00000000..5584483f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/test/tests_simple.cpp
@@ -0,0 +1,454 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ // Copyright (C) 2008-2013, Willow Garage Inc., all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and / or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(Viz, show_cloud_bluberry)
+{
+    Mat dragon_cloud = readCloud(get_dragon_ply_file_path());
+
+    Affine3d pose = Affine3d().rotate(Vec3d(0, 0.8, 0));
+
+    Viz3d viz("show_cloud_bluberry");
+    viz.setBackgroundColor(Color::black());
+    viz.showWidget("coosys", WCoordinateSystem());
+    viz.showWidget("dragon", WCloud(dragon_cloud, Color::bluberry()), pose);
+
+    viz.showWidget("text2d", WText("Bluberry cloud", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_cloud_random_color)
+{
+    Mat dragon_cloud = readCloud(get_dragon_ply_file_path());
+
+    Mat colors(dragon_cloud.size(), CV_8UC3);
+    theRNG().fill(colors, RNG::UNIFORM, 0, 255);
+
+    Affine3d pose = Affine3d().rotate(Vec3d(0, 0.8, 0));
+
+    Viz3d viz("show_cloud_random_color");
+    viz.setBackgroundMeshLab();
+    viz.showWidget("coosys", WCoordinateSystem());
+    viz.showWidget("dragon", WCloud(dragon_cloud, colors), pose);
+    viz.showWidget("text2d", WText("Random color cloud", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_cloud_masked)
+{
+    Mat dragon_cloud = readCloud(get_dragon_ply_file_path());
+
+    Vec3f qnan = Vec3f::all(std::numeric_limits<float>::quiet_NaN());
+    for(int i = 0; i < (int)dragon_cloud.total(); ++i)
+        if (i % 15 != 0)
+            dragon_cloud.at<Vec3f>(i) = qnan;
+
+    Affine3d pose = Affine3d().rotate(Vec3d(0, 0.8, 0));
+
+    Viz3d viz("show_cloud_masked");
+    viz.showWidget("coosys", WCoordinateSystem());
+    viz.showWidget("dragon", WCloud(dragon_cloud), pose);
+    viz.showWidget("text2d", WText("Nan masked cloud", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_cloud_collection)
+{
+    Mat cloud = readCloud(get_dragon_ply_file_path());
+
+    WCloudCollection ccol;
+    ccol.addCloud(cloud, Color::white(), Affine3d().translate(Vec3d(0, 0, 0)).rotate(Vec3d(CV_PI/2, 0, 0)));
+    ccol.addCloud(cloud, Color::blue(),  Affine3d().translate(Vec3d(1, 0, 0)));
+    ccol.addCloud(cloud, Color::red(),   Affine3d().translate(Vec3d(2, 0, 0)));
+    ccol.finalize();
+
+    Viz3d viz("show_cloud_collection");
+    viz.setBackgroundColor(Color::mlab());
+    viz.showWidget("coosys", WCoordinateSystem());
+    viz.showWidget("ccol", ccol);
+    viz.showWidget("text2d", WText("Cloud collection", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_painted_clouds)
+{
+    Mat cloud = readCloud(get_dragon_ply_file_path());
+
+    Viz3d viz("show_painted_clouds");
+    viz.setBackgroundMeshLab();
+    viz.showWidget("coosys", WCoordinateSystem());
+    viz.showWidget("cloud1", WPaintedCloud(cloud), Affine3d(Vec3d(0.0, -CV_PI/2, 0.0), Vec3d(-1.5, 0.0, 0.0)));
+    viz.showWidget("cloud2", WPaintedCloud(cloud, Vec3d(0.0, -0.75, -1.0), Vec3d(0.0, 0.75, 0.0)), Affine3d(Vec3d(0.0, CV_PI/2, 0.0), Vec3d(1.5, 0.0, 0.0)));
+    viz.showWidget("cloud3", WPaintedCloud(cloud, Vec3d(0.0, 0.0, -1.0), Vec3d(0.0, 0.0, 1.0), Color::blue(), Color::red()));
+    viz.showWidget("arrow", WArrow(Vec3d(0.0, 1.0, -1.0), Vec3d(0.0, 1.0, 1.0), 0.009, Color::raspberry()));
+    viz.showWidget("text2d", WText("Painted clouds", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_mesh)
+{
+    Mesh mesh = Mesh::load(get_dragon_ply_file_path());
+
+    Affine3d pose = Affine3d().rotate(Vec3d(0, 0.8, 0));
+
+    Viz3d viz("show_mesh");
+    viz.showWidget("coosys", WCoordinateSystem());
+    viz.showWidget("mesh", WMesh(mesh), pose);
+    viz.showWidget("text2d", WText("Just mesh", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_mesh_random_colors)
+{
+    Mesh mesh = Mesh::load(get_dragon_ply_file_path());
+    theRNG().fill(mesh.colors, RNG::UNIFORM, 0, 255);
+
+    Affine3d pose = Affine3d().rotate(Vec3d(0, 0.8, 0));
+
+    Viz3d viz("show_mesh_random_color");
+    viz.showWidget("coosys", WCoordinateSystem());
+    viz.showWidget("mesh", WMesh(mesh), pose);
+    viz.setRenderingProperty("mesh", SHADING, SHADING_PHONG);
+    viz.showWidget("text2d", WText("Random color mesh", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_widget_merger)
+{
+    WWidgetMerger merger;
+    merger.addWidget(WCube(Vec3d::all(0.0), Vec3d::all(1.0), true, Color::gold()));
+
+    RNG& rng = theRNG();
+    for(int i = 0; i < 77; ++i)
+    {
+        Vec3b c;
+        rng.fill(c, RNG::NORMAL, Scalar::all(128), Scalar::all(48), true);
+        merger.addWidget(WSphere(Vec3d(c)*(1.0/255.0), 7.0/255.0, 10, Color(c[2], c[1], c[0])));
+    }
+    merger.finalize();
+
+    Viz3d viz("show_mesh_random_color");
+    viz.showWidget("coo", WCoordinateSystem());
+    viz.showWidget("merger", merger);
+    viz.showWidget("text2d", WText("Widget merger", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_textured_mesh)
+{
+    Mat lena = imread(Path::combine(cvtest::TS::ptr()->get_data_path(), "lena.png"));
+
+    std::vector<Vec3d> points;
+    std::vector<Vec2d> tcoords;
+    std::vector<int> polygons;
+    for(size_t i = 0; i < 64; ++i)
+    {
+        double angle = CV_PI/2 * i/64.0;
+        points.push_back(Vec3d(0.00, cos(angle), sin(angle))*0.75);
+        points.push_back(Vec3d(1.57, cos(angle), sin(angle))*0.75);
+        tcoords.push_back(Vec2d(0.0, i/64.0));
+        tcoords.push_back(Vec2d(1.0, i/64.0));
+    }
+
+    for(int i = 0; i < (int)points.size()/2-1; ++i)
+    {
+        int polys[] = {3, 2*i, 2*i+1, 2*i+2, 3, 2*i+1, 2*i+2, 2*i+3};
+        polygons.insert(polygons.end(), polys, polys + sizeof(polys)/sizeof(polys[0]));
+    }
+
+    cv::viz::Mesh mesh;
+    mesh.cloud = Mat(points, true).reshape(3, 1);
+    mesh.tcoords = Mat(tcoords, true).reshape(2, 1);
+    mesh.polygons = Mat(polygons, true).reshape(1, 1);
+    mesh.texture = lena;
+
+    Viz3d viz("show_textured_mesh");
+    viz.setBackgroundMeshLab();
+    viz.showWidget("coosys", WCoordinateSystem());
+    viz.showWidget("mesh", WMesh(mesh));
+    viz.setRenderingProperty("mesh", SHADING, SHADING_PHONG);
+    viz.showWidget("text2d", WText("Textured mesh", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_polyline)
+{
+    const Color palette[] = { Color::red(), Color::green(), Color::blue(), Color::gold(), Color::raspberry(), Color::bluberry(), Color::lime() };
+    size_t palette_size = sizeof(palette)/sizeof(palette[0]);
+
+    Mat polyline(1, 32, CV_64FC3), colors(1, 32, CV_8UC3);
+    for(int i = 0; i < (int)polyline.total(); ++i)
+    {
+        polyline.at<Vec3d>(i) = Vec3d(i/16.0, cos(i * CV_PI/6), sin(i * CV_PI/6));
+        colors.at<Vec3b>(i) = palette[i & palette_size];
+    }
+
+    Viz3d viz("show_polyline");
+    viz.showWidget("polyline", WPolyLine(polyline, colors));
+    viz.showWidget("coosys", WCoordinateSystem());
+    viz.showWidget("text2d", WText("Polyline", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_sampled_normals)
+{
+    Mesh mesh = Mesh::load(get_dragon_ply_file_path());
+    computeNormals(mesh, mesh.normals);
+
+    Affine3d pose = Affine3d().rotate(Vec3d(0, 0.8, 0));
+
+    Viz3d viz("show_sampled_normals");
+    viz.showWidget("mesh", WMesh(mesh), pose);
+    viz.showWidget("normals", WCloudNormals(mesh.cloud, mesh.normals, 30, 0.1f, Color::green()), pose);
+    viz.setRenderingProperty("normals", LINE_WIDTH, 2.0);
+    viz.showWidget("text2d", WText("Cloud or mesh normals", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_cloud_shaded_by_normals)
+{
+    Mesh mesh = Mesh::load(get_dragon_ply_file_path());
+    computeNormals(mesh, mesh.normals);
+
+    Affine3d pose = Affine3d().rotate(Vec3d(0, 0.8, 0));
+
+    WCloud cloud(mesh.cloud, Color::white(), mesh.normals);
+    cloud.setRenderingProperty(SHADING, SHADING_GOURAUD);
+
+    Viz3d viz("show_cloud_shaded_by_normals");
+    viz.showWidget("cloud", cloud, pose);
+    viz.showWidget("text2d", WText("Cloud shaded by normals", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_trajectories)
+{
+    std::vector<Affine3d> path = generate_test_trajectory<double>(), sub0, sub1, sub2, sub3, sub4, sub5;
+    int size =(int)path.size();
+
+    Mat(path).rowRange(0, size/10+1).copyTo(sub0);
+    Mat(path).rowRange(size/10, size/5+1).copyTo(sub1);
+    Mat(path).rowRange(size/5, 11*size/12).copyTo(sub2);
+    Mat(path).rowRange(11*size/12, size).copyTo(sub3);
+    Mat(path).rowRange(3*size/4, 33*size/40).copyTo(sub4);
+    Mat(path).rowRange(33*size/40, 9*size/10).copyTo(sub5);
+    Matx33d K(1024.0, 0.0, 320.0, 0.0, 1024.0, 240.0, 0.0, 0.0, 1.0);
+
+    Viz3d viz("show_trajectories");
+    viz.showWidget("coos", WCoordinateSystem());
+    viz.showWidget("sub0", WTrajectorySpheres(sub0, 0.25, 0.07));
+    viz.showWidget("sub1", WTrajectory(sub1, WTrajectory::PATH, 0.2, Color::brown()));
+    viz.showWidget("sub2", WTrajectory(sub2, WTrajectory::FRAMES, 0.2));
+    viz.showWidget("sub3", WTrajectory(sub3, WTrajectory::BOTH, 0.2, Color::green()));
+    viz.showWidget("sub4", WTrajectoryFrustums(sub4, K, 0.3, Color::yellow()));
+    viz.showWidget("sub5", WTrajectoryFrustums(sub5, Vec2d(0.78, 0.78), 0.15));
+    viz.showWidget("text2d", WText("Different kinds of supported trajectories", Point(20, 20), 20, Color::green()));
+
+    int i = 0;
+    for(unsigned num = 0; num < 50; ++num)
+    {
+        double a = --i % 360;
+        Vec3d pose(sin(a * CV_PI/180), 0.7, cos(a * CV_PI/180));
+        viz.setViewerPose(makeCameraPose(pose * 7.5, Vec3d(0.0, 0.5, 0.0), Vec3d(0.0, 0.1, 0.0)));
+        viz.spinOnce(100, true);
+    }
+    viz.resetCamera();
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_trajectory_reposition)
+{
+    std::vector<Affine3f> path = generate_test_trajectory<float>();
+
+    Viz3d viz("show_trajectory_reposition_to_origin");
+    viz.showWidget("coos", WCoordinateSystem());
+    viz.showWidget("sub3", WTrajectory(Mat(path).rowRange(0, (int)path.size()/3), WTrajectory::BOTH, 0.2, Color::brown()), path.front().inv());
+    viz.showWidget("text2d", WText("Trajectory resposition to origin", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_camera_positions)
+{
+    Matx33d K(1024.0, 0.0, 320.0, 0.0, 1024.0, 240.0, 0.0, 0.0, 1.0);
+    Mat lena = imread(Path::combine(cvtest::TS::ptr()->get_data_path(), "lena.png"));
+    Mat gray = make_gray(lena);
+
+    Affine3d poses[2];
+    for(int i = 0; i < 2; ++i)
+    {
+        Vec3d pose = 5 * Vec3d(sin(3.14 + 2.7 + i*60 * CV_PI/180), 0.4 - i*0.3, cos(3.14 + 2.7 + i*60 * CV_PI/180));
+        poses[i] = makeCameraPose(pose, Vec3d(0.0, 0.0, 0.0), Vec3d(0.0, -0.1, 0.0));
+    }
+
+    Viz3d viz("show_camera_positions");
+    viz.showWidget("sphe", WSphere(Point3d(0,0,0), 1.0, 10, Color::orange_red()));
+    viz.showWidget("coos", WCoordinateSystem(1.5));
+    viz.showWidget("pos1", WCameraPosition(0.75), poses[0]);
+    viz.showWidget("pos2", WCameraPosition(Vec2d(0.78, 0.78), lena, 2.2, Color::green()), poses[0]);
+    viz.showWidget("pos3", WCameraPosition(0.75), poses[1]);
+    viz.showWidget("pos4", WCameraPosition(K, gray, 3, Color::indigo()), poses[1]);
+    viz.showWidget("text2d", WText("Camera positions with images", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_overlay_image)
+{
+    Mat lena = imread(Path::combine(cvtest::TS::ptr()->get_data_path(), "lena.png"));
+    Mat gray = make_gray(lena);
+
+    Size2d half_lsize = Size2d(lena.size()) * 0.5;
+
+    Viz3d viz("show_overlay_image");
+    viz.setBackgroundMeshLab();
+    Size vsz = viz.getWindowSize();
+
+    viz.showWidget("coos", WCoordinateSystem());
+    viz.showWidget("cube", WCube());
+    viz.showWidget("img1", WImageOverlay(lena, Rect(Point(10, 10), half_lsize)));
+    viz.showWidget("img2", WImageOverlay(gray, Rect(Point(vsz.width-10-lena.cols/2, 10), half_lsize)));
+    viz.showWidget("img3", WImageOverlay(gray, Rect(Point(10, vsz.height-10-lena.rows/2), half_lsize)));
+    viz.showWidget("img5", WImageOverlay(lena, Rect(Point(vsz.width-10-lena.cols/2, vsz.height-10-lena.rows/2), half_lsize)));
+    viz.showWidget("text2d", WText("Overlay images", Point(20, 20), 20, Color::green()));
+
+    int i = 0;
+    for(unsigned num = 0; num < 50; ++num)
+    {
+        double a = ++i % 360;
+        Vec3d pose(sin(a * CV_PI/180), 0.7, cos(a * CV_PI/180));
+        viz.setViewerPose(makeCameraPose(pose * 3, Vec3d(0.0, 0.5, 0.0), Vec3d(0.0, 0.1, 0.0)));
+        viz.getWidget("img1").cast<WImageOverlay>().setImage(lena * pow(sin(i*10*CV_PI/180) * 0.5 + 0.5, 1.0));
+        viz.spinOnce(100, true);
+    }
+    viz.showWidget("text2d", WText("Overlay images (stopped)", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+
+TEST(Viz, show_image_method)
+{
+    Mat lena = imread(Path::combine(cvtest::TS::ptr()->get_data_path(), "lena.png"));
+
+    Viz3d viz("show_image_method");
+    viz.showImage(lena);
+    viz.spinOnce(1500, true);
+    viz.showImage(lena, lena.size());
+    viz.spinOnce(1500, true);
+
+    cv::viz::imshow("show_image_method", make_gray(lena)).spinOnce(500, true);
+}
+
+TEST(Viz, show_image_3d)
+{
+    Mat lena = imread(Path::combine(cvtest::TS::ptr()->get_data_path(), "lena.png"));
+    Mat gray = make_gray(lena);
+
+    Viz3d viz("show_image_3d");
+    viz.setBackgroundMeshLab();
+    viz.showWidget("coos", WCoordinateSystem());
+    viz.showWidget("cube", WCube());
+    viz.showWidget("arr0", WArrow(Vec3d(0.5, 0.0, 0.0), Vec3d(1.5, 0.0, 0.0), 0.009, Color::raspberry()));
+    viz.showWidget("img0", WImage3D(lena, Size2d(1.0, 1.0)), Affine3d(Vec3d(0.0, CV_PI/2, 0.0), Vec3d(.5, 0.0, 0.0)));
+    viz.showWidget("arr1", WArrow(Vec3d(-0.5, -0.5, 0.0), Vec3d(0.2, 0.2, 0.0), 0.009, Color::raspberry()));
+    viz.showWidget("img1", WImage3D(gray, Size2d(1.0, 1.0), Vec3d(-0.5, -0.5, 0.0), Vec3d(1.0, 1.0, 0.0), Vec3d(0.0, 1.0, 0.0)));
+
+    viz.showWidget("arr3", WArrow(Vec3d::all(-0.5), Vec3d::all(0.5), 0.009, Color::raspberry()));
+
+    viz.showWidget("text2d", WText("Images in 3D", Point(20, 20), 20, Color::green()));
+
+    int i = 0;
+    for(unsigned num = 0; num < 50; ++num)
+    {
+        viz.getWidget("img0").cast<WImage3D>().setImage(lena * pow(sin(i++*7.5*CV_PI/180) * 0.5 + 0.5, 1.0));
+        viz.spinOnce(100, true);
+    }
+    viz.showWidget("text2d", WText("Images in 3D (stopped)", Point(20, 20), 20, Color::green()));
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_simple_widgets)
+{
+    Viz3d viz("show_simple_widgets");
+    viz.setBackgroundMeshLab();
+
+    viz.showWidget("coos", WCoordinateSystem());
+    viz.showWidget("cube", WCube());
+    viz.showWidget("cub0", WCube(Vec3d::all(-1.0), Vec3d::all(-0.5), false, Color::indigo()));
+    viz.showWidget("arro", WArrow(Vec3d::all(-0.5), Vec3d::all(0.5), 0.009, Color::raspberry()));
+    viz.showWidget("cir1", WCircle(0.5, 0.01, Color::bluberry()));
+    viz.showWidget("cir2", WCircle(0.5, Point3d(0.5, 0.0, 0.0), Vec3d(1.0, 0.0, 0.0), 0.01, Color::apricot()));
+
+    viz.showWidget("cyl0", WCylinder(Vec3d(-0.5, 0.5, -0.5), Vec3d(0.5, 0.5, -0.5), 0.125, 30, Color::brown()));
+    viz.showWidget("con0", WCone(0.25, 0.125, 6, Color::azure()));
+    viz.showWidget("con1", WCone(0.125, Point3d(0.5, -0.5, 0.5), Point3d(0.5, -1.0, 0.5), 6, Color::turquoise()));
+
+    viz.showWidget("text2d", WText("Different simple widgets", Point(20, 20), 20, Color::green()));
+    viz.showWidget("text3d", WText3D("Simple 3D text", Point3d( 0.5,  0.5, 0.5), 0.125, false, Color::green()));
+
+    viz.showWidget("plane1", WPlane(Size2d(0.25, 0.75)));
+    viz.showWidget("plane2", WPlane(Vec3d(0.5, -0.5, -0.5), Vec3d(0.0, 1.0, 1.0), Vec3d(1.0, 1.0, 0.0), Size2d(1.0, 0.5), Color::gold()));
+
+    viz.showWidget("grid1", WGrid(Vec2i(7,7), Vec2d::all(0.75), Color::gray()), Affine3d().translate(Vec3d(0.0, 0.0, -1.0)));
+
+    viz.spinOnce(500, true);
+    viz.getWidget("text2d").cast<WText>().setText("Different simple widgets (updated)");
+    viz.getWidget("text3d").cast<WText3D>().setText("Updated text 3D");
+    viz.spinOnce(500, true);
+}
+
+TEST(Viz, show_follower)
+{
+    Viz3d viz("show_follower");
+
+    viz.showWidget("coos", WCoordinateSystem());
+    viz.showWidget("cube", WCube());
+    viz.showWidget("t3d_2", WText3D("Simple 3D follower", Point3d(-0.5, -0.5, 0.5), 0.125, true,  Color::green()));
+    viz.showWidget("text2d", WText("Follower: text always facing camera", Point(20, 20), 20, Color::green()));
+    viz.setBackgroundMeshLab();
+    viz.spinOnce(500, true);
+    viz.getWidget("t3d_2").cast<WText3D>().setText("Updated follower 3D");
+    viz.spinOnce(500, true);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/creating_widgets/creating_widgets.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/creating_widgets/creating_widgets.markdown
new file mode 100644
index 00000000..3e97a06f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/creating_widgets/creating_widgets.markdown
@@ -0,0 +1,58 @@
+Creating Widgets {#tutorial_creating_widgets}
+================
+
+@prev_tutorial{tutorial_transformations}
+@next_tutorial{tutorial_histo3D}
+
+Goal
+----
+
+In this tutorial you will learn how to
+
+-   Create your own widgets using WidgetAccessor and VTK.
+-   Show your widget in the visualization window.
+
+Code
+----
+
+You can download the code from [here ](https://github.com/opencv/opencv_contrib/tree/master/modules/viz/samples/creating_widgets.cpp).
+@include viz/samples/creating_widgets.cpp
+
+Explanation
+-----------
+
+Here is the general structure of the program:
+
+-   Extend Widget3D class to create a new 3D widget.
+    @code{.cpp}
+    class WTriangle : public viz::Widget3D
+    {
+        public:
+            WTriangle(const Point3f &pt1, const Point3f &pt2, const Point3f &pt3, const viz::Color & color = viz::Color::white());
+    };
+    @endcode
+-   Assign a VTK actor to the widget.
+    @code{.cpp}
+    // Store this actor in the widget in order that visualizer can access it
+    viz::WidgetAccessor::setProp(*this, actor);
+    @endcode
+-   Set color of the widget.
+    @code{.cpp}
+    // Set the color of the widget. This has to be called after WidgetAccessor.
+    setColor(color);
+    @endcode
+-   Construct a triangle widget and display it in the window.
+    @code{.cpp}
+    /// Create a triangle widget
+    WTriangle tw(Point3f(0.0,0.0,0.0), Point3f(1.0,1.0,1.0), Point3f(0.0,1.0,0.0), viz::Color::red());
+
+    /// Show widget in the visualizer window
+    myWindow.showWidget("TRIANGLE", tw);
+    @endcode
+
+Results
+-------
+
+Here is the result of the program.
+
+![](images/red_triangle.png)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/creating_widgets/images/red_triangle.png b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/creating_widgets/images/red_triangle.png
new file mode 100644
index 00000000..7da6ad06
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/creating_widgets/images/red_triangle.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/histo3D/histo3D.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/histo3D/histo3D.markdown
new file mode 100644
index 00000000..ff77c9cf
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/histo3D/histo3D.markdown
@@ -0,0 +1,53 @@
+Creating a 3D histogram {#tutorial_histo3D}
+================
+
+@prev_tutorial{tutorial_creating_widgets}
+
+Goal
+----
+
+In this tutorial you will learn how to
+
+-   Create your own callback keyboard function for viz window.
+-   Show your 3D histogram in a viz window.
+
+Code
+----
+
+You can download the code from [here ](https://github.com/opencv/opencv_contrib/tree/master/modules/viz/samples/histo3D.cpp).
+@include viz/samples/histo3D.cpp
+
+Explanation
+-----------
+
+Here is the general structure of the program:
+
+-   You can give full path to an image in command line
+    @snippet histo3D.cpp command_line_parser
+
+    or without path, a synthetic image is generated with pixel values are a gaussian distribution @ref cv::RNG::fill center(60+/-10,40+/-5,50+/-20) in first quadrant,
+    (160+/-20,10+/-5,50+/-10) in second quadrant, (90+/-10,100+/-20,50+/-20) in third quadrant, (100+/-10,10+/-5,150+/-40) in last quadrant.
+    @snippet histo3D.cpp synthetic_image
+    Image tridimensional histogram is calculated using opencv @ref cv::calcHist and @ref cv::normalize between 0 and 100.
+    @snippet histo3D.cpp calchist_for_histo3d
+    channel are 2, 1 and 0 to synchronise color with Viz axis color in objetc cv::viz::WCoordinateSystem.
+
+    A slidebar is inserted in image window. Init slidebar value is 90, it means that only histogram cell greater than 9/100000.0 (23 pixels for an 512X512 pixels) will be display.
+    @snippet histo3D.cpp slide_bar_for_thresh
+    We are ready to open a viz window with a callback function to capture keyboard event in viz window. Using @ref cv::viz::Viz3d::spinOnce enable keyboard event to be capture in @ref cv::imshow window too.
+    @snippet histo3D.cpp manage_viz_imshow_window
+    The function DrawHistogram3D processes histogram Mat to display it in a Viz window. Number of plan, row and column in [three dimensional Mat](@ref CVMat_Details ) can be found using  this code :
+    @snippet histo3D.cpp get_cube_size
+    To get histogram value at a specific location we use @ref cv::Mat::at(int i0,int i1, int i2)  method with three arguments k, i and j where k is plane number, i row number and j column number.
+    @snippet histo3D.cpp get_cube_values
+
+-   Callback function
+    Principle are as mouse callback function. Key code pressed is in field code of class @ref cv::viz::KeyboardEvent.
+    @snippet histo3D.cpp viz_keyboard_callback
+
+Results
+-------
+
+Here is the result of the program with no argument and threshold equal to 50.
+
+![](images/histo50.png)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/histo3D/images/histo50.png b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/histo3D/images/histo50.png
new file mode 100644
index 00000000..b2b4416c
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/histo3D/images/histo50.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/images/facedetect.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/images/facedetect.jpg
new file mode 100644
index 00000000..788b7d82
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/images/facedetect.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/images/image_effects.png b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/images/image_effects.png
new file mode 100644
index 00000000..25edb668
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/images/image_effects.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/images/intro.png b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/images/intro.png
new file mode 100644
index 00000000..5f2dc1aa
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/images/intro.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/launching_viz/images/window_demo.png b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/launching_viz/images/window_demo.png
new file mode 100644
index 00000000..b853fe29
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/launching_viz/images/window_demo.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/launching_viz/launching_viz.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/launching_viz/launching_viz.markdown
new file mode 100644
index 00000000..661821ef
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/launching_viz/launching_viz.markdown
@@ -0,0 +1,66 @@
+Launching Viz {#tutorial_launching_viz}
+=============
+
+@next_tutorial{tutorial_widget_pose}
+
+Goal
+----
+
+In this tutorial you will learn how to
+
+-   Open a visualization window.
+-   Access a window by its name.
+-   Start event loop.
+-   Start event loop for a given amount of time.
+
+Code
+----
+
+You can download the code from [here ](https://github.com/opencv/opencv_contrib/tree/master/modules/viz/samples/launching_viz.cpp).
+@include viz/samples/launching_viz.cpp
+
+Explanation
+-----------
+
+Here is the general structure of the program:
+
+-   Create a window.
+    @code{.cpp}
+    /// Create a window
+    viz::Viz3d myWindow("Viz Demo");
+    @endcode
+-   Start event loop. This event loop will run until user terminates it by pressing **e**, **E**,
+    **q**, **Q**.
+    @code{.cpp}
+    /// Start event loop
+    myWindow.spin();
+    @endcode
+-   Access same window via its name. Since windows are implicitly shared, **sameWindow** is exactly
+    the same with **myWindow**. If the name does not exist, a new window is created.
+    @code{.cpp}
+    /// Access window via its name
+    viz::Viz3d sameWindow = viz::getWindowByName("Viz Demo");
+    @endcode
+-   Start a controlled event loop. Once it starts, **wasStopped** is set to false. Inside the while
+    loop, in each iteration, **spinOnce** is called to prevent event loop from completely stopping.
+    Inside the while loop, user can execute other statements including those which interact with the
+    window.
+    @code{.cpp}
+    /// Event loop is over when pressed q, Q, e, E
+    /// Start event loop once for 1 millisecond
+    sameWindow.spinOnce(1, true);
+    while(!sameWindow.wasStopped())
+    {
+        /// Interact with window
+
+        /// Event loop for 1 millisecond
+        sameWindow.spinOnce(1, true);
+    }
+    @endcode
+
+Results
+-------
+
+Here is the result of the program.
+
+![](images/window_demo.png)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/table_of_content_viz.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/table_of_content_viz.markdown
new file mode 100644
index 00000000..bcbebd15
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/table_of_content_viz.markdown
@@ -0,0 +1,52 @@
+OpenCV Viz {#tutorial_table_of_content_viz}
+==========
+
+-   @subpage tutorial_launching_viz
+
+    *Languages:* C++
+
+    *Compatibility:* \> OpenCV 3.0.0
+
+    *Author:* Ozan Tonkal
+
+    You will learn how to launch a viz window.
+
+-   @subpage tutorial_widget_pose
+
+    *Languages:* C++
+
+    *Compatibility:* \> OpenCV 3.0.0
+
+    *Author:* Ozan Tonkal
+
+    You will learn how to change pose of a widget.
+
+-   @subpage tutorial_transformations
+
+    *Languages:* C++
+
+    *Compatibility:* \> OpenCV 3.0.0
+
+    *Author:* Ozan Tonkal
+
+    You will learn how to transform between global and camera frames.
+
+-   @subpage tutorial_creating_widgets
+
+    *Languages:* C++
+
+    *Compatibility:* \> OpenCV 3.0.0
+
+    *Author:* Ozan Tonkal
+
+    You will learn how to create your own widgets.
+
+-   @subpage tutorial_histo3D
+
+    *Languages:* C++
+
+    *Compatibility:* \> OpenCV 3.0.0
+
+    *Author:* Laurent Berger
+
+    You will learn how to plot a 3D histogram.
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/transformations/images/camera_view_point.png b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/transformations/images/camera_view_point.png
new file mode 100644
index 00000000..e2ac5b0f
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/transformations/images/camera_view_point.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/transformations/images/global_view_point.png b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/transformations/images/global_view_point.png
new file mode 100644
index 00000000..fc6de2c1
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/transformations/images/global_view_point.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/transformations/transformations.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/transformations/transformations.markdown
new file mode 100644
index 00000000..b5c73db8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/transformations/transformations.markdown
@@ -0,0 +1,91 @@
+Transformations {#tutorial_transformations}
+===============
+
+@prev_tutorial{tutorial_widget_pose}
+@next_tutorial{tutorial_creating_widgets}
+
+Goal
+----
+
+In this tutorial you will learn how to
+
+-   How to use makeTransformToGlobal to compute pose
+-   How to use makeCameraPose and Viz3d::setViewerPose
+-   How to visualize camera position by axes and by viewing frustum
+
+Code
+----
+
+You can download the code from [here ](https://github.com/opencv/opencv_contrib/tree/master/modules/viz/samples/transformations.cpp).
+@include viz/samples/transformations.cpp
+
+Explanation
+-----------
+
+Here is the general structure of the program:
+
+-   Create a visualization window.
+    @code{.cpp}
+    /// Create a window
+    viz::Viz3d myWindow("Transformations");
+    @endcode
+-   Get camera pose from camera position, camera focal point and y direction.
+    @code{.cpp}
+    /// Let's assume camera has the following properties
+    Point3f cam_pos(3.0f,3.0f,3.0f), cam_focal_point(3.0f,3.0f,2.0f), cam_y_dir(-1.0f,0.0f,0.0f);
+
+    /// We can get the pose of the cam using makeCameraPose
+    Affine3f cam_pose = viz::makeCameraPose(cam_pos, cam_focal_point, cam_y_dir);
+    @endcode
+-   Obtain transform matrix knowing the axes of camera coordinate system.
+    @code{.cpp}
+    /// We can get the transformation matrix from camera coordinate system to global using
+    /// - makeTransformToGlobal. We need the axes of the camera
+    Affine3f transform = viz::makeTransformToGlobal(Vec3f(0.0f,-1.0f,0.0f), Vec3f(-1.0f,0.0f,0.0f), Vec3f(0.0f,0.0f,-1.0f), cam_pos);
+    @endcode
+-   Create a cloud widget from bunny.ply file
+    @code{.cpp}
+    /// Create a cloud widget.
+    Mat bunny_cloud = cvcloud_load();
+    viz::WCloud cloud_widget(bunny_cloud, viz::Color::green());
+    @endcode
+-   Given the pose in camera coordinate system, estimate the global pose.
+    @code{.cpp}
+    /// Pose of the widget in camera frame
+    Affine3f cloud_pose = Affine3f().translate(Vec3f(0.0f,0.0f,3.0f));
+    /// Pose of the widget in global frame
+    Affine3f cloud_pose_global = transform * cloud_pose;
+    @endcode
+-   If the view point is set to be global, visualize camera coordinate frame and viewing frustum.
+    @code{.cpp}
+    /// Visualize camera frame
+    if (!camera_pov)
+    {
+        viz::WCameraPosition cpw(0.5); // Coordinate axes
+        viz::WCameraPosition cpw_frustum(Vec2f(0.889484, 0.523599)); // Camera frustum
+        myWindow.showWidget("CPW", cpw, cam_pose);
+        myWindow.showWidget("CPW_FRUSTUM", cpw_frustum, cam_pose);
+    }
+    @endcode
+-   Visualize the cloud widget with the estimated global pose
+    @code{.cpp}
+    /// Visualize widget
+    myWindow.showWidget("bunny", cloud_widget, cloud_pose_global);
+    @endcode
+-   If the view point is set to be camera's, set viewer pose to **cam_pose**.
+    @code{.cpp}
+    /// Set the viewer pose to that of camera
+    if (camera_pov)
+        myWindow.setViewerPose(cam_pose);
+    @endcode
+
+Results
+-------
+
+-#  Here is the result from the camera point of view.
+
+![](images/camera_view_point.png)
+
+-#  Here is the result from global point of view.
+
+![](images/global_view_point.png)
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/widget_pose/images/widgetpose.png b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/widget_pose/images/widgetpose.png
new file mode 100644
index 00000000..ef8a5937
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/widget_pose/images/widgetpose.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/widget_pose/widget_pose.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/widget_pose/widget_pose.markdown
new file mode 100644
index 00000000..d9b5ff59
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/viz/tutorials/widget_pose/widget_pose.markdown
@@ -0,0 +1,88 @@
+Pose of a widget {#tutorial_widget_pose}
+================
+
+@prev_tutorial{tutorial_launching_viz}
+@next_tutorial{tutorial_transformations}
+
+Goal
+----
+
+In this tutorial you will learn how to
+
+-   Add widgets to the visualization window
+-   Use Affine3 to set pose of a widget
+-   Rotating and translating a widget along an axis
+
+Code
+----
+
+You can download the code from [here ](https://github.com/opencv/opencv_contrib/tree/master/modules/viz/samples/widget_pose.cpp).
+@include viz/samples/widget_pose.cpp
+
+Explanation
+-----------
+
+Here is the general structure of the program:
+
+-   Create a visualization window.
+    @code{.cpp}
+    /// Create a window
+    viz::Viz3d myWindow("Coordinate Frame");
+    @endcode
+-   Show coordinate axes in the window using CoordinateSystemWidget.
+    @code{.cpp}
+    /// Add coordinate axes
+    myWindow.showWidget("Coordinate Widget", viz::WCoordinateSystem());
+    @endcode
+-   Display a line representing the axis (1,1,1).
+    @code{.cpp}
+    /// Add line to represent (1,1,1) axis
+    viz::WLine axis(Point3f(-1.0f,-1.0f,-1.0f), Point3f(1.0f,1.0f,1.0f));
+    axis.setRenderingProperty(viz::LINE_WIDTH, 4.0);
+    myWindow.showWidget("Line Widget", axis);
+    @endcode
+-   Construct a cube.
+    @code{.cpp}
+    /// Construct a cube widget
+    viz::WCube cube_widget(Point3f(0.5,0.5,0.0), Point3f(0.0,0.0,-0.5), true, viz::Color::blue());
+    cube_widget.setRenderingProperty(viz::LINE_WIDTH, 4.0);
+    myWindow.showWidget("Cube Widget", cube_widget);
+    @endcode
+-   Create rotation matrix from rodrigues vector
+    @code{.cpp}
+    /// Rotate around (1,1,1)
+    rot_vec.at<float>(0,0) += CV_PI * 0.01f;
+    rot_vec.at<float>(0,1) += CV_PI * 0.01f;
+    rot_vec.at<float>(0,2) += CV_PI * 0.01f;
+
+    ...
+
+    Mat rot_mat;
+    Rodrigues(rot_vec, rot_mat);
+    @endcode
+-   Use Affine3f to set pose of the cube.
+    @code{.cpp}
+    /// Construct pose
+    Affine3f pose(rot_mat, Vec3f(translation, translation, translation));
+    myWindow.setWidgetPose("Cube Widget", pose);
+    @endcode
+-   Animate the rotation using wasStopped and spinOnce
+    @code{.cpp}
+    while(!myWindow.wasStopped())
+    {
+        ...
+
+        myWindow.spinOnce(1, true);
+    }
+    @endcode
+
+Results
+-------
+
+Here is the result of the program.
+
+\htmlonly
+<div align="center">
+<iframe width="420" height="315" src="https://www.youtube.com/embed/22HKMN657U0" frameborder="0" allowfullscreen></iframe>
+</div>
+\endhtmlonly
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/CMakeLists.txt b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/CMakeLists.txt
new file mode 100644
index 00000000..a15c4337
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/CMakeLists.txt
@@ -0,0 +1,40 @@
+set(the_description "WeChat QR code Detector")
+ocv_define_module(wechat_qrcode opencv_core opencv_imgproc opencv_objdetect opencv_dnn WRAP java objc python js)
+
+# iconv support isn't automatic on some systems
+if(CMAKE_VERSION VERSION_GREATER "3.11")
+  find_package(Iconv QUIET)
+  if(Iconv_FOUND)
+    ocv_target_link_libraries(${the_module} Iconv::Iconv)
+  else()
+    ocv_target_compile_definitions(${the_module} PRIVATE "NO_ICONV=1")
+  endif()
+endif()
+
+# need to change
+set(wechat_qrcode_commit_hash "a8b69ccc738421293254aec5ddb38bd523503252")
+set(hash_detect_caffemodel "238e2b2d6f3c18d6c3a30de0c31e23cf")
+set(hash_detect_prototxt "6fb4976b32695f9f5c6305c19f12537d")
+set(hash_sr_caffemodel "cbfcd60361a73beb8c583eea7e8e6664")
+set(hash_sr_prototxt "69db99927a70df953b471daaba03fbef")
+
+set(model_types caffemodel prototxt)
+set(model_names detect sr)
+
+foreach(model_name ${model_names})
+    foreach(model_type ${model_types})
+        ocv_download(FILENAME ${model_name}.${model_type}
+                        HASH ${hash_${model_name}_${model_type}}
+                        URL
+                        "${OPENCV_WECHAT_QRCODE_URL}"
+                        "$ENV{OPENCV_WECHAT_QRCODE_URL}"
+                        "https://raw.githubusercontent.com/WeChatCV/opencv_3rdparty/${wechat_qrcode_commit_hash}/"
+                        DESTINATION_DIR "${CMAKE_BINARY_DIR}/downloads/wechat_qrcode"
+                        ID "wechat_qrcode"
+                        RELATIVE_URL
+                        STATUS res)
+        if(NOT res)
+            message(WARNING "WeChatQRCode: Can't get ${model_name} ${model_type} file for wechat qrcode.")
+        endif()
+    endforeach()
+endforeach()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/LICENSE b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/LICENSE
new file mode 100644
index 00000000..303fddb1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/LICENSE
@@ -0,0 +1,253 @@
+Tencent is pleased to support the open source community by making WeChat QRCode available.
+
+Copyright (C) 2021 THL A29 Limited, a Tencent company.  All rights reserved.
+The below software in this distribution may have been modified by THL A29 Limited ("Tencent Modifications").
+All Tencent Modifications are Copyright (C) THL A29 Limited.
+
+WeChat QRCode is licensed under the Apache License Version 2.0, except for the third-party components listed below.
+
+Terms of the Apache License Version 2.0
+--------------------------------------------------------------------
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+
+
+Other dependencies and licenses:
+
+Open Source Software Licensed under the Apache License Version 2.0:
+--------------------------------------------------------------------
+1. zxing
+Copyright (c) zxing authors and contributors
+Please note this software may have been modified by Tencent.
+
+Terms of the Apache License Version 2.0:
+--------------------------------------------------------------------
+Apache License
+
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; and
+You must cause any modified files to carry prominent notices stating that You changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/README.md b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/README.md
new file mode 100644
index 00000000..38a0935e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/README.md
@@ -0,0 +1,12 @@
+WeChat QR code detector for detecting and parsing QR code.
+================================================
+
+WeChat QR code detector is a high-performance and lightweight QR code detect and decode library, which is contributed by WeChat Computer Vision Team (WeChatCV). It has been widely used in various Tencent applications, including WeChat, WeCom, QQ, QQ Browser, and so on. There are four primary features of WeChat QR code detector:
+
+1. CNN-based QR code detector. Different from the traditional detector, we introduce a tiny CNN model for multiple code detection. The detector is based on SSD architecture with a MobileNetV2-like backbone, which is run on caffe inference framework.
+
+2. CNN-based QR code enhancement. To improve the performance of tiny QR code, we design a lighten super-resolution CNN model for QR code, called QRSR. Depth-wise convolution, DenseNet concat and deconvolution are the core techniques in the QRSR model.
+
+3. More robust finder pattern detection. Besides traditional horizontal line searching, we propose an area size based finder pattern detection method. we calculate the area size of black and white block to locate the finder pattern by the pre-computed connected cells.
+
+4. Massive engineering optimization. Based on [zxing-cpp](https://github.com/glassechidna/zxing-cpp), we conduct massive engineering optimization to boost the decoding success rate, such as trying more binarization methods, supporting N:1:3:1:1 finder pattern detection, finding more alignment pattern, clustering similar size finder pattern, and etc.
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/include/opencv2/wechat_qrcode.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/include/opencv2/wechat_qrcode.hpp
new file mode 100644
index 00000000..676104cd
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/include/opencv2/wechat_qrcode.hpp
@@ -0,0 +1,77 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __OPENCV_WECHAT_QRCODE_HPP__
+#define __OPENCV_WECHAT_QRCODE_HPP__
+#include "opencv2/core.hpp"
+/** @defgroup wechat_qrcode WeChat QR code detector for detecting and parsing QR code.
+ */
+namespace cv {
+namespace wechat_qrcode {
+//! @addtogroup wechat_qrcode
+//! @{
+/**
+ * @brief  WeChat QRCode includes two CNN-based models:
+ * A object detection model and a super resolution model.
+ * Object detection model is applied to detect QRCode with the bounding box.
+ * super resolution model is applied to zoom in QRCode when it is small.
+ *
+ */
+class CV_EXPORTS_W WeChatQRCode {
+public:
+    /**
+     * @brief Initialize the WeChatQRCode.
+     * It includes two models, which are packaged with caffe format.
+     * Therefore, there are prototxt and caffe models (In total, four paramenters).
+     *
+     * @param detector_prototxt_path prototxt file path for the detector
+     * @param detector_caffe_model_path caffe model file path for the detector
+     * @param super_resolution_prototxt_path prototxt file path for the super resolution model
+     * @param super_resolution_caffe_model_path caffe file path for the super resolution model
+     */
+    CV_WRAP WeChatQRCode(const std::string& detector_prototxt_path = "",
+                         const std::string& detector_caffe_model_path = "",
+                         const std::string& super_resolution_prototxt_path = "",
+                         const std::string& super_resolution_caffe_model_path = "");
+    ~WeChatQRCode(){};
+
+    /**
+     * @brief  Both detects and decodes QR code.
+     * To simplify the usage, there is a only API: detectAndDecode
+     *
+     * @param img supports grayscale or color (BGR) image.
+     * @param points optional output array of vertices of the found QR code quadrangle. Will be
+     * empty if not found.
+     * @return list of decoded string.
+     */
+    CV_WRAP std::vector<std::string> detectAndDecode(InputArray img, OutputArrayOfArrays points = noArray());
+
+    /**
+    * @brief set scale factor
+    * QR code detector use neural network to detect QR.
+    * Before running the neural network, the input image is pre-processed by scaling.
+    * By default, the input image is scaled to an image with an area of 160000 pixels.
+    * The scale factor allows to use custom scale the input image:
+    * width = scaleFactor*width
+    * height = scaleFactor*width
+    *
+    * scaleFactor valuse must be > 0 and <= 1, otherwise the scaleFactor value is set to -1
+    * and use default scaled to an image with an area of 160000 pixels.
+    */
+    CV_WRAP void setScaleFactor(float _scalingFactor);
+
+    CV_WRAP float getScaleFactor();
+
+protected:
+    class Impl;
+    Ptr<Impl> p;
+};
+
+//! @}
+}  // namespace wechat_qrcode
+}  // namespace cv
+#endif  // __OPENCV_WECHAT_QRCODE_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode.py b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode.py
new file mode 100644
index 00000000..7713734f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode.py
@@ -0,0 +1,53 @@
+import cv2
+import sys
+
+print(sys.argv[0])
+print('A demo program of WeChat QRCode Detector:')
+camIdx = -1
+if len(sys.argv) > 1:
+    if sys.argv[1] == "-camera":
+        camIdx = int(sys.argv[2]) if len(sys.argv)>2 else 0
+    img = cv2.imread(sys.argv[1])
+else:
+    print("    Usage: " + sys.argv[0] + "  <input_image>")
+    exit(0)
+
+# For python API generator, it follows the template: {module_name}_{class_name},
+# so it is a little weird.
+# The model is downloaded to ${CMAKE_BINARY_DIR}/downloads/wechat_qrcode if cmake runs without warnings,
+# otherwise you can download them from https://github.com/WeChatCV/opencv_3rdparty/tree/wechat_qrcode.
+try:
+    detector = cv2.wechat_qrcode_WeChatQRCode(
+        "detect.prototxt", "detect.caffemodel", "sr.prototxt", "sr.caffemodel")
+except:
+    print("---------------------------------------------------------------")
+    print("Failed to initialize WeChatQRCode.")
+    print("Please, download 'detector.*' and 'sr.*' from")
+    print("https://github.com/WeChatCV/opencv_3rdparty/tree/wechat_qrcode")
+    print("and put them into the current directory.")
+    print("---------------------------------------------------------------")
+    exit(0)
+
+prevstr = ""
+
+if camIdx < 0:
+    res, points = detector.detectAndDecode(img)
+    print(res,points)
+else:
+    cap = cv2.VideoCapture(camIdx)
+    while True:
+        res, img = cap.read()
+        if img is None:
+            break
+        res, points = detector.detectAndDecode(img)
+        for t in res:
+            if t != prevstr:
+                print(t)
+        if res:
+            prevstr = res[-1]
+        cv2.imshow("image", img)
+        if cv2.waitKey(30) >= 0:
+            break
+    # When everything done, release the capture
+    cap.release()
+    cv2.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode_example.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode_example.cpp
new file mode 100644
index 00000000..046525b9
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode_example.cpp
@@ -0,0 +1,70 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+
+using namespace std;
+using namespace cv;
+
+#include <opencv2/wechat_qrcode.hpp>
+int main(int argc, char* argv[]) {
+    cout << endl << argv[0] << endl << endl;
+    cout << "A demo program of WeChat QRCode Detector: " << endl;
+
+    Mat img;
+    int camIdx = -1;
+    if (argc > 1) {
+        bool live = strcmp(argv[1], "-camera") == 0;
+        if (live) {
+            camIdx = argc > 2 ? atoi(argv[2]) : 0;
+        } else {
+            img = imread(argv[1]);
+        }
+    } else {
+        cout << "    Usage: " << argv[0] << " <input_image>" << endl;
+        return 0;
+    }
+    // The model is downloaded to ${CMAKE_BINARY_DIR}/downloads/wechat_qrcode if cmake runs without warnings,
+    // otherwise you can download them from https://github.com/WeChatCV/opencv_3rdparty/tree/wechat_qrcode.
+    Ptr<wechat_qrcode::WeChatQRCode> detector;
+
+    try {
+        detector = makePtr<wechat_qrcode::WeChatQRCode>("detect.prototxt", "detect.caffemodel",
+                                                        "sr.prototxt", "sr.caffemodel");
+    } catch (const std::exception& e) {
+        cout <<
+            "\n---------------------------------------------------------------\n"
+            "Failed to initialize WeChatQRCode.\n"
+            "Please, download 'detector.*' and 'sr.*' from\n"
+            "https://github.com/WeChatCV/opencv_3rdparty/tree/wechat_qrcode\n"
+            "and put them into the current directory.\n"
+            "---------------------------------------------------------------\n";
+        cout << e.what() << endl;
+        return 0;
+    }
+    string prevstr = "";
+    vector<Mat> points;
+
+    if (camIdx < 0) {
+        auto res = detector->detectAndDecode(img, points);
+        for (const auto& t : res) cout << t << endl;
+    } else {
+        VideoCapture cap(camIdx);
+        for(;;) {
+            cap >> img;
+            if (img.empty())
+                break;
+            auto res = detector->detectAndDecode(img, points);
+            for (const auto& t : res) {
+                if (t != prevstr)
+                    cout << t << endl;
+            }
+            if (!res.empty())
+                prevstr = res.back();
+            imshow("image", img);
+            if (waitKey(30) >= 0)
+                break;
+        }
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode_example_without_nn.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode_example_without_nn.cpp
new file mode 100644
index 00000000..7428d0dd
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode_example_without_nn.cpp
@@ -0,0 +1,67 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+
+using namespace std;
+using namespace cv;
+
+#include <opencv2/wechat_qrcode.hpp>
+
+int main(int argc, char* argv[]) {
+    cout << endl << argv[0] << endl << endl;
+    cout << "A demo program of WeChat QRCode Detector: " << endl;
+
+    Mat img;
+    int camIdx = -1;
+    if (argc > 1) {
+        bool live = strcmp(argv[1], "-camera") == 0;
+        if (live) {
+            camIdx = argc > 2 ? atoi(argv[2]) : 0;
+        } else {
+            img = imread(argv[1]);
+        }
+    } else {
+        cout << "    Usage: " << argv[0] << " <input_image>" << endl;
+        return 0;
+    }
+    // The model is downloaded to ${CMAKE_BINARY_DIR}/downloads/wechat_qrcode if cmake runs without warnings,
+    // otherwise you can download them from https://github.com/WeChatCV/opencv_3rdparty/tree/wechat_qrcode.
+    Ptr<wechat_qrcode::WeChatQRCode> detector;
+
+    try {
+        detector = makePtr<wechat_qrcode::WeChatQRCode>("", "", "", "");
+    } catch (const std::exception& e) {
+        cout <<
+            "\n---------------------------------------------------------------\n"
+            "Failed to initialize WeChatQRCode.\n"
+            "---------------------------------------------------------------\n";
+        cout << e.what() << endl;
+        return 0;
+    }
+    string prevstr = "";
+    vector<Mat> points;
+
+    if (camIdx < 0) {
+        auto res = detector->detectAndDecode(img, points);
+        for (const auto& t : res) cout << t << endl;
+    } else {
+        VideoCapture cap(camIdx);
+        for(;;) {
+            cap >> img;
+            if (img.empty())
+                break;
+            auto res = detector->detectAndDecode(img, points);
+            for (const auto& t : res) {
+                if (t != prevstr)
+                    cout << t << endl;
+            }
+            if (!res.empty())
+                prevstr = res.back();
+            imshow("image", img);
+            if (waitKey(30) >= 0)
+                break;
+        }
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode_without_nn.py b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode_without_nn.py
new file mode 100644
index 00000000..9b8feb52
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/samples/qrcode_without_nn.py
@@ -0,0 +1,50 @@
+import cv2
+import sys
+
+print(sys.argv[0])
+print('A demo program of WeChat QRCode Detector:')
+camIdx = -1
+if len(sys.argv) > 1:
+    if sys.argv[1] == "-camera":
+        camIdx = int(sys.argv[2]) if len(sys.argv)>2 else 0
+    img = cv2.imread(sys.argv[1])
+else:
+    print("    Usage: " + sys.argv[0] + "  <input_image>")
+    exit(0)
+
+# For python API generator, it follows the template: {module_name}_{class_name},
+# so it is a little weird.
+# The model is downloaded to ${CMAKE_BINARY_DIR}/downloads/wechat_qrcode if cmake runs without warnings,
+# otherwise you can download them from https://github.com/WeChatCV/opencv_3rdparty/tree/wechat_qrcode.
+try:
+    detector = cv2.wechat_qrcode_WeChatQRCode(
+        "", "", "", "")
+except:
+    print("---------------------------------------------------------------")
+    print("Failed to initialize WeChatQRCode.")
+    print("---------------------------------------------------------------")
+    exit(0)
+
+prevstr = ""
+
+if camIdx < 0:
+    res, points = detector.detectAndDecode(img)
+    print(res,points)
+else:
+    cap = cv2.VideoCapture(camIdx)
+    while True:
+        res, img = cap.read()
+        if img is None:
+            break
+        res, points = detector.detectAndDecode(img)
+        for t in res:
+            if t != prevstr:
+                print(t)
+        if res:
+            prevstr = res[-1]
+        cv2.imshow("image", img)
+        if cv2.waitKey(30) >= 0:
+            break
+    # When everything done, release the capture
+    cap.release()
+    cv2.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/binarizermgr.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/binarizermgr.cpp
new file mode 100644
index 00000000..db019cd5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/binarizermgr.cpp
@@ -0,0 +1,70 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "precomp.hpp"
+#include "binarizermgr.hpp"
+#include "imgsource.hpp"
+
+
+using zxing::Binarizer;
+using zxing::LuminanceSource;
+namespace cv {
+namespace wechat_qrcode {
+BinarizerMgr::BinarizerMgr() : m_iNowRotateIndex(0), m_iNextOnceBinarizer(-1) {
+    m_vecRotateBinarizer.push_back(Hybrid);
+    m_vecRotateBinarizer.push_back(FastWindow);
+    m_vecRotateBinarizer.push_back(SimpleAdaptive);
+    m_vecRotateBinarizer.push_back(AdaptiveThreshold);
+}
+
+BinarizerMgr::~BinarizerMgr() {}
+
+zxing::Ref<Binarizer> BinarizerMgr::Binarize(zxing::Ref<LuminanceSource> source) {
+    BINARIZER binarizerIdx = m_vecRotateBinarizer[m_iNowRotateIndex];
+    if (m_iNextOnceBinarizer >= 0) {
+        binarizerIdx = (BINARIZER)m_iNextOnceBinarizer;
+    }
+
+    zxing::Ref<Binarizer> binarizer;
+    switch (binarizerIdx) {
+        case Hybrid:
+            binarizer = new zxing::HybridBinarizer(source);
+            break;
+        case FastWindow:
+            binarizer = new zxing::FastWindowBinarizer(source);
+            break;
+        case SimpleAdaptive:
+            binarizer = new zxing::SimpleAdaptiveBinarizer(source);
+            break;
+        case AdaptiveThreshold:
+            binarizer = new zxing::AdaptiveThresholdMeanBinarizer(source);
+            break;
+        default:
+            binarizer = new zxing::HybridBinarizer(source);
+            break;
+    }
+
+    return binarizer;
+}
+
+void BinarizerMgr::SwitchBinarizer() {
+    m_iNowRotateIndex = (m_iNowRotateIndex + 1) % m_vecRotateBinarizer.size();
+}
+
+int BinarizerMgr::GetCurBinarizer() {
+    if (m_iNextOnceBinarizer != -1) return m_iNextOnceBinarizer;
+    return m_vecRotateBinarizer[m_iNowRotateIndex];
+}
+
+void BinarizerMgr::SetNextOnceBinarizer(int iBinarizerIndex) {
+    m_iNextOnceBinarizer = iBinarizerIndex;
+}
+
+void BinarizerMgr::SetBinarizer(vector<BINARIZER> vecRotateBinarizer) {
+    m_vecRotateBinarizer = vecRotateBinarizer;
+}
+}  // namespace wechat_qrcode
+}  // namespace cv
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/binarizermgr.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/binarizermgr.hpp
new file mode 100644
index 00000000..a8a1e4ba
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/binarizermgr.hpp
@@ -0,0 +1,51 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __OPENCV_WECHAT_QRCODE_BINARIZERMGR_HPP__
+#define __OPENCV_WECHAT_QRCODE_BINARIZERMGR_HPP__
+
+#include "zxing/binarizer.hpp"
+#include "zxing/common/binarizer/adaptive_threshold_mean_binarizer.hpp"
+#include "zxing/common/counted.hpp"
+#include "zxing/common/binarizer/fast_window_binarizer.hpp"
+#include "zxing/common/binarizer/hybrid_binarizer.hpp"
+#include "zxing/common/binarizer/simple_adaptive_binarizer.hpp"
+#include "zxing/zxing.hpp"
+
+namespace cv {
+namespace wechat_qrcode {
+class BinarizerMgr {
+public:
+    enum BINARIZER {
+        Hybrid = 0,
+        FastWindow = 1,
+        SimpleAdaptive = 2,
+        AdaptiveThreshold = 3
+    };
+
+public:
+    BinarizerMgr();
+    ~BinarizerMgr();
+
+    zxing::Ref<zxing::Binarizer> Binarize(zxing::Ref<zxing::LuminanceSource> source);
+
+    void SwitchBinarizer();
+
+    int GetCurBinarizer();
+
+    void SetNextOnceBinarizer(int iBinarizerIndex);
+
+    void SetBinarizer(vector<BINARIZER> vecRotateBinarizer);
+
+private:
+    int m_iNowRotateIndex;
+    int m_iNextOnceBinarizer;
+    vector<BINARIZER> m_vecRotateBinarizer;
+};
+}  // namespace wechat_qrcode
+}  // namespace cv
+#endif  // __OPENCV_WECHAT_QRCODE_BINARIZERMGR_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/decodermgr.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/decodermgr.cpp
new file mode 100644
index 00000000..1e93aa15
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/decodermgr.cpp
@@ -0,0 +1,92 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "precomp.hpp"
+#include "decodermgr.hpp"
+
+
+using zxing::ArrayRef;
+using zxing::BinaryBitmap;
+using zxing::DecodeHints;
+using zxing::ErrorHandler;
+using zxing::LuminanceSource;
+using zxing::Ref;
+using zxing::Result;
+using zxing::UnicomBlock;
+namespace cv {
+namespace wechat_qrcode {
+int DecoderMgr::decodeImage(cv::Mat src, bool use_nn_detector, vector<string>& results, vector<vector<Point2f>>& zxing_points) {
+    int width = src.cols;
+    int height = src.rows;
+    if (width <= 20 || height <= 20)
+        return -1;  // image data is not enough for providing reliable results
+
+    std::vector<uint8_t> scaled_img_data(src.data, src.data + width * height);
+    zxing::ArrayRef<uint8_t> scaled_img_zx =
+        zxing::ArrayRef<uint8_t>(new zxing::Array<uint8_t>(scaled_img_data));
+
+    vector<zxing::Ref<zxing::Result>> zx_results;
+
+    decode_hints_.setUseNNDetector(use_nn_detector);
+
+    Ref<ImgSource> source;
+    qbarUicomBlock_ = new UnicomBlock(width, height);
+
+    // Four Binarizers
+    int tryBinarizeTime = 4;
+    for (int tb = 0; tb < tryBinarizeTime; tb++) {
+        if (source == NULL || height * width > source->getMaxSize()) {
+            source = ImgSource::create(scaled_img_zx.data(), width, height);
+        } else {
+            source->reset(scaled_img_zx.data(), width, height);
+        }
+        int ret = TryDecode(source, zx_results);
+        if (!ret) {
+            for(size_t k = 0; k < zx_results.size(); k++) {
+                results.emplace_back(zx_results[k]->getText()->getText());
+                vector<Point2f> tmp_qr_points;
+                auto tmp_zx_points = zx_results[k]->getResultPoints();
+                for (int i = 0; i < tmp_zx_points->size() / 4; i++) {
+                    const int ind = i * 4;
+                    for (int j = 1; j < 4; j++){
+                        tmp_qr_points.emplace_back(tmp_zx_points[ind + j]->getX(), tmp_zx_points[ind + j]->getY());
+                    }
+                    tmp_qr_points.emplace_back(tmp_zx_points[ind]->getX(), tmp_zx_points[ind]->getY());
+                }
+                zxing_points.push_back(tmp_qr_points);
+            }
+            return ret;
+        }
+        // try different binarizers
+        binarizer_mgr_.SwitchBinarizer();
+    }
+    return -1;
+}
+
+int DecoderMgr::TryDecode(Ref<LuminanceSource> source, vector<Ref<Result>>& results) {
+    int res = -1;
+    string cell_result;
+
+    // get binarizer
+    zxing::Ref<zxing::Binarizer> binarizer = binarizer_mgr_.Binarize(source);
+    zxing::Ref<zxing::BinaryBitmap> binary_bitmap(new BinaryBitmap(binarizer));
+    binary_bitmap->m_poUnicomBlock = qbarUicomBlock_;
+
+    results = Decode(binary_bitmap, decode_hints_);
+    res = (results.size() == 0) ? 1 : 0;
+
+    if (res == 0) {
+        results[0]->setBinaryMethod(int(binarizer_mgr_.GetCurBinarizer()));
+    }
+
+    return res;
+}
+
+vector<Ref<Result>> DecoderMgr::Decode(Ref<BinaryBitmap> image, DecodeHints hints) {
+    return reader_->decode(image, hints);
+}
+}  // namespace wechat_qrcode
+}  // namespace cv
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/decodermgr.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/decodermgr.hpp
new file mode 100644
index 00000000..1e04203b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/decodermgr.hpp
@@ -0,0 +1,46 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __OPENCV_WECHAT_QRCODE_DECODERMGR_HPP__
+#define __OPENCV_WECHAT_QRCODE_DECODERMGR_HPP__
+
+// zxing
+#include "zxing/binarizer.hpp"
+#include "zxing/binarybitmap.hpp"
+#include "zxing/decodehints.hpp"
+#include "zxing/qrcode/qrcode_reader.hpp"
+#include "zxing/result.hpp"
+
+// qbar
+#include "binarizermgr.hpp"
+#include "imgsource.hpp"
+namespace cv {
+namespace wechat_qrcode {
+
+class DecoderMgr {
+public:
+    DecoderMgr() { reader_ = new zxing::qrcode::QRCodeReader(); };
+    ~DecoderMgr(){};
+
+    int decodeImage(cv::Mat src, bool use_nn_detector, vector<string>& result, vector<vector<Point2f>>& zxing_points);
+
+private:
+    zxing::Ref<zxing::UnicomBlock> qbarUicomBlock_;
+    zxing::DecodeHints decode_hints_;
+
+    zxing::Ref<zxing::qrcode::QRCodeReader> reader_;
+    BinarizerMgr binarizer_mgr_;
+
+    vector<zxing::Ref<zxing::Result>> Decode(zxing::Ref<zxing::BinaryBitmap> image,
+                                     zxing::DecodeHints hints);
+
+    int TryDecode(zxing::Ref<zxing::LuminanceSource> source, vector<zxing::Ref<zxing::Result>>& result);
+};
+
+}  // namespace wechat_qrcode
+}  // namespace cv
+#endif  // __OPENCV_WECHAT_QRCODE_DECODERMGR_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/align.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/align.cpp
new file mode 100644
index 00000000..05ab5335
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/align.cpp
@@ -0,0 +1,66 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "../precomp.hpp"
+#include "align.hpp"
+
+using std::max;
+using std::min;
+namespace cv {
+namespace wechat_qrcode {
+Align::Align() { rotate90_ = false; }
+
+Mat Align::calcWarpMatrix(const Mat src, const Mat dst) {
+    M_ = getPerspectiveTransform(src, dst);
+    M_inv_ = M_.inv();
+    return M_;
+}
+
+vector<Point2f> Align::warpBack(const vector<Point2f> &dst_pts) {
+    vector<Point2f> src_pts;
+    for (size_t j = 0; j < dst_pts.size(); j++) {
+        auto src_x = (rotate90_ ? dst_pts[j].y : dst_pts[j].x) + crop_x_;
+        auto src_y = (rotate90_ ? dst_pts[j].x : dst_pts[j].y) + crop_y_;
+        src_pts.push_back(Point2f(src_x, src_y));
+    }
+    return src_pts;
+}
+
+Mat Align::crop(const Mat &inputImg, const int width, const int height) {
+    Mat warp_dst = Mat::zeros(height, width, inputImg.type());
+
+    warpPerspective(inputImg, warp_dst, M_, warp_dst.size(), INTER_LINEAR, BORDER_CONSTANT, 255);
+
+    return warp_dst;
+}
+
+Mat Align::crop(const Mat &inputImg, const Mat &srcPts, const float paddingW, const float paddingH,
+                const int minPadding) {
+    int x0 = srcPts.at<float>(0, 0);
+    int y0 = srcPts.at<float>(0, 1);
+    int x2 = srcPts.at<float>(2, 0);
+    int y2 = srcPts.at<float>(2, 1);
+
+    int width = x2 - x0 + 1;
+    int height = y2 - y0 + 1;
+
+    int padx = max(paddingW * width, static_cast<float>(minPadding));
+    int pady = max(paddingH * height, static_cast<float>(minPadding));
+
+    crop_x_ = max(x0 - padx, 0);
+    crop_y_ = max(y0 - pady, 0);
+    int end_x = min(x2 + padx, inputImg.cols - 1);
+    int end_y = min(y2 + pady, inputImg.rows - 1);
+
+    Rect crop_roi(crop_x_, crop_y_, end_x - crop_x_ + 1, end_y - crop_y_ + 1);
+
+    Mat dst = inputImg(crop_roi).clone();
+    if (rotate90_) dst = dst.t();  // transpose
+    return dst;
+}
+
+}  // namespace wechat_qrcode
+}  // namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/align.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/align.hpp
new file mode 100644
index 00000000..2ad88a5b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/align.hpp
@@ -0,0 +1,41 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __DETECTOR_ALIGN_HPP_
+#define __DETECTOR_ALIGN_HPP_
+
+#include <stdio.h>
+#include <fstream>
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+
+namespace cv {
+namespace wechat_qrcode {
+
+class Align {
+public:
+    Align();
+    Mat calcWarpMatrix(const Mat src, const Mat dst);
+    std::vector<Point2f> warpBack(const std::vector<Point2f> &dst_pts);
+    Mat crop(const Mat &inputImg, const Mat &srcPts, const float paddingW, const float paddingH,
+             const int minPadding);
+
+    void setRotate90(bool v) { rotate90_ = v; }
+
+private:
+    Mat crop(const Mat &inputImg, const int width, const int height);
+    Mat M_;
+    Mat M_inv_;
+
+    int crop_x_;
+    int crop_y_;
+    bool rotate90_;
+};
+
+}  // namespace wechat_qrcode
+}  // namespace cv
+#endif  // __DETECTOR_ALIGN_HPP_
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/ssd_detector.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/ssd_detector.cpp
new file mode 100644
index 00000000..dca1851a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/ssd_detector.cpp
@@ -0,0 +1,57 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "../precomp.hpp"
+#include "ssd_detector.hpp"
+#define CLIP(x, x1, x2) max(x1, min(x, x2))
+namespace cv {
+namespace wechat_qrcode {
+int SSDDetector::init(const string& proto_path, const string& model_path) {
+    net_ = dnn::readNetFromCaffe(proto_path, model_path);
+    return 0;
+}
+
+vector<Mat> SSDDetector::forward(Mat img, const int target_width, const int target_height) {
+    int img_w = img.cols;
+    int img_h = img.rows;
+    Mat input;
+    resize(img, input, Size(target_width, target_height), 0, 0, INTER_CUBIC);
+
+    dnn::blobFromImage(input, input, 1.0 / 255, Size(input.cols, input.rows), {0.0f, 0.0f, 0.0f},
+                       false, false);
+    net_.setInput(input, "data");
+
+    auto prob = net_.forward("detection_output");
+    vector<Mat> point_list;
+    // the shape is (1,1,100,7)=>(batch,channel,count,dim)
+    for (int row = 0; row < prob.size[2]; row++) {
+        const float* prob_score = prob.ptr<float>(0, 0, row);
+        // prob_score[0] is not used.
+        // prob_score[1]==1 stands for qrcode
+        if (prob_score[1] == 1 && prob_score[2] > 1E-5) {
+            // add a safe score threshold due to https://github.com/opencv/opencv_contrib/issues/2877
+            // prob_score[2] is the probability of the qrcode, which is not used.
+            auto point = Mat(4, 2, CV_32FC1);
+            float x0 = CLIP(prob_score[3] * img_w, 0.0f, img_w - 1.0f);
+            float y0 = CLIP(prob_score[4] * img_h, 0.0f, img_h - 1.0f);
+            float x1 = CLIP(prob_score[5] * img_w, 0.0f, img_w - 1.0f);
+            float y1 = CLIP(prob_score[6] * img_h, 0.0f, img_h - 1.0f);
+
+            point.at<float>(0, 0) = x0;
+            point.at<float>(0, 1) = y0;
+            point.at<float>(1, 0) = x1;
+            point.at<float>(1, 1) = y0;
+            point.at<float>(2, 0) = x1;
+            point.at<float>(2, 1) = y1;
+            point.at<float>(3, 0) = x0;
+            point.at<float>(3, 1) = y1;
+            point_list.push_back(point);
+        }
+    }
+    return point_list;
+}
+}  // namespace wechat_qrcode
+}  // namespace cv
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/ssd_detector.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/ssd_detector.hpp
new file mode 100644
index 00000000..e510cb32
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/detector/ssd_detector.hpp
@@ -0,0 +1,31 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __DETECTOR_SSD_DETECTOR_HPP_
+#define __DETECTOR_SSD_DETECTOR_HPP_
+
+#include <stdio.h>
+
+#include "opencv2/dnn.hpp"
+#include "opencv2/imgproc.hpp"
+namespace cv {
+namespace wechat_qrcode {
+
+class SSDDetector {
+public:
+    SSDDetector(){};
+    ~SSDDetector(){};
+    int init(const std::string& proto_path, const std::string& model_path);
+    std::vector<Mat> forward(Mat img, const int target_width, const int target_height);
+
+private:
+    dnn::Net net_;
+};
+
+}  // namespace wechat_qrcode
+}  // namespace cv
+#endif  // __DETECTOR_SSD_DETECTOR_HPP_
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/imgsource.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/imgsource.cpp
new file mode 100644
index 00000000..bd49de4e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/imgsource.cpp
@@ -0,0 +1,188 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "precomp.hpp"
+#include "imgsource.hpp"
+
+using zxing::ArrayRef;
+using zxing::ByteMatrix;
+using zxing::ErrorHandler;
+using zxing::LuminanceSource;
+using zxing::Ref;
+namespace cv {
+namespace wechat_qrcode {
+
+// Initialize the ImgSource
+ImgSource::ImgSource(unsigned char* pixels, int width, int height)
+    : Super(width, height) {
+    luminances = new unsigned char[width * height];
+    memset(luminances, 0, width * height);
+
+    rgbs = pixels;
+
+    dataWidth = width;
+    dataHeight = height;
+    left = 0;
+    top = 0;
+
+    // Make gray luminances first
+    makeGray();
+}
+
+// Added for crop function
+ImgSource::ImgSource(unsigned char* pixels, int width, int height, int left_, int top_,
+                     int cropWidth, int cropHeight,
+                     ErrorHandler& err_handler)
+    : Super(cropWidth, cropHeight) {
+    rgbs = pixels;
+
+    dataWidth = width;
+    dataHeight = height;
+    left = left_;
+    top = top_;
+
+    // super(width, height);
+    if ((left_ + cropWidth) > dataWidth || (top_ + cropHeight) > dataHeight || top_ < 0 ||
+        left_ < 0) {
+        err_handler =
+            zxing::IllegalArgumentErrorHandler("Crop rectangle does not fit within image data.");
+        return;
+    }
+
+    luminances = new unsigned char[width * height];
+
+    // Make gray luminances first
+    makeGray();
+}
+
+ImgSource::~ImgSource() {
+    if (luminances != NULL) {
+        delete[] luminances;
+    }
+}
+
+Ref<ImgSource> ImgSource::create(unsigned char* pixels, int width, int height) {
+    return Ref<ImgSource>(new ImgSource(pixels, width, height));
+}
+
+Ref<ImgSource> ImgSource::create(unsigned char* pixels, int width, int height, int left, int top,
+                                 int cropWidth, int cropHeight,
+                                 zxing::ErrorHandler& err_handler) {
+    return Ref<ImgSource>(new ImgSource(pixels, width, height, left, top, cropWidth, cropHeight, err_handler));
+}
+
+void ImgSource::reset(unsigned char* pixels, int width, int height) {
+    rgbs = pixels;
+    left = 0;
+    top = 0;
+
+    setWidth(width);
+    setHeight(height);
+    dataWidth = width;
+    dataHeight = height;
+    makeGrayReset();
+}
+
+ArrayRef<char> ImgSource::getRow(int y, zxing::ArrayRef<char> row,
+                                 zxing::ErrorHandler& err_handler) const {
+    if (y < 0 || y >= getHeight()) {
+        err_handler = zxing::IllegalArgumentErrorHandler("Requested row is outside the image");
+        return ArrayRef<char>();
+    }
+
+    int width = getWidth();
+    if (row->data() == NULL || row->empty() || row->size() < width) {
+        row = zxing::ArrayRef<char>(width);
+    }
+    int offset = (y + top) * dataWidth + left;
+
+    char* rowPtr = &row[0];
+    arrayCopy(luminances, offset, rowPtr, 0, width);
+
+    return row;
+}
+
+/** This is a more efficient implementation. */
+ArrayRef<char> ImgSource::getMatrix() const {
+    int width = getWidth();
+    int height = getHeight();
+
+    int area = width * height;
+
+    // If the caller asks for the entire underlying image, save the copy and
+    // give them the original data. The docs specifically warn that
+    // result.length must be ignored.
+    if (width == dataWidth && height == dataHeight) {
+        return _matrix;
+    }
+
+    zxing::ArrayRef<char> newMatrix = zxing::ArrayRef<char>(area);
+
+    int inputOffset = top * dataWidth + left;
+
+    // If the width matches the full width of the underlying data, perform a
+    // single copy.
+    if (width == dataWidth) {
+        arrayCopy(luminances, inputOffset, &newMatrix[0], 0, area);
+        return newMatrix;
+    }
+
+    // Otherwise copy one cropped row at a time.
+    for (int y = 0; y < height; y++) {
+        int outputOffset = y * width;
+        arrayCopy(luminances, inputOffset, &newMatrix[0], outputOffset, width);
+        inputOffset += dataWidth;
+    }
+    return newMatrix;
+}
+
+
+void ImgSource::makeGray() {
+    int area = dataWidth * dataHeight;
+    _matrix = zxing::ArrayRef<char>(area);
+    arrayCopy(rgbs, 0, &_matrix[0], 0, area);
+}
+
+void ImgSource::makeGrayReset() {
+    int area = dataWidth * dataHeight;
+    arrayCopy(rgbs, 0, &_matrix[0], 0, area);
+}
+
+void ImgSource::arrayCopy(unsigned char* src, int inputOffset, char* dst, int outputOffset,
+                          int length) const {
+    const unsigned char* srcPtr = src + inputOffset;
+    char* dstPtr = dst + outputOffset;
+
+    memcpy(dstPtr, srcPtr, length * sizeof(unsigned char));
+}
+
+bool ImgSource::isCropSupported() const { return true; }
+
+Ref<LuminanceSource> ImgSource::crop(int left_, int top_, int width, int height,
+                                     ErrorHandler& err_handler) const {
+    return ImgSource::create(rgbs, dataWidth, dataHeight, left + left_, top + top_, width, height, err_handler);
+}
+
+bool ImgSource::isRotateSupported() const { return false; }
+
+Ref<LuminanceSource> ImgSource::rotateCounterClockwise(ErrorHandler& err_handler) const {
+    // Intentionally flip the left, top, width, and height arguments as
+    // needed. dataWidth and dataHeight are always kept unrotated.
+    int width = getWidth();
+    int height = getHeight();
+
+    return ImgSource::create(rgbs, dataWidth, dataHeight, top, left, height, width, err_handler);
+}
+
+
+Ref<ByteMatrix> ImgSource::getByteMatrix() const {
+    return Ref<ByteMatrix>(new ByteMatrix(getWidth(), getHeight(), getMatrix()));
+}
+}  // namespace wechat_qrcode
+}  // namespace cv
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/imgsource.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/imgsource.hpp
new file mode 100644
index 00000000..ec62dc6a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/imgsource.hpp
@@ -0,0 +1,63 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __OPENCV_WECHAT_QRCODE_IMGSOURCE_HPP__
+#define __OPENCV_WECHAT_QRCODE_IMGSOURCE_HPP__
+#include "zxing/common/bytematrix.hpp"
+#include "zxing/errorhandler.hpp"
+#include "zxing/luminance_source.hpp"
+namespace cv {
+namespace wechat_qrcode {
+class ImgSource : public zxing::LuminanceSource {
+private:
+    typedef LuminanceSource Super;
+    zxing::ArrayRef<char> _matrix;
+    unsigned char* rgbs;
+    unsigned char* luminances;
+    int dataWidth;
+    int dataHeight;
+    int left;
+    int top;
+    void makeGray();
+    void makeGrayReset();
+
+    void arrayCopy(unsigned char* src, int inputOffset, char* dst, int outputOffset,
+                   int length) const;
+
+
+    ~ImgSource();
+
+public:
+    ImgSource(unsigned char* pixels, int width, int height);
+    ImgSource(unsigned char* pixels, int width, int height, int left, int top, int cropWidth,
+              int cropHeight, zxing::ErrorHandler& err_handler);
+
+    static zxing::Ref<ImgSource> create(unsigned char* pixels, int width, int height);
+    static zxing::Ref<ImgSource> create(unsigned char* pixels, int width, int height, int left,
+                                        int top, int cropWidth, int cropHeight, zxing::ErrorHandler& err_handler);
+    void reset(unsigned char* pixels, int width, int height);
+    zxing::ArrayRef<char> getRow(int y, zxing::ArrayRef<char> row,
+                                    zxing::ErrorHandler& err_handler) const override;
+    zxing::ArrayRef<char> getMatrix() const override;
+    zxing::Ref<zxing::ByteMatrix> getByteMatrix() const override;
+
+    bool isCropSupported() const override;
+    zxing::Ref<LuminanceSource> crop(int left, int top, int width, int height,
+                                     zxing::ErrorHandler& err_handler) const override;
+
+    bool isRotateSupported() const override;
+    zxing::Ref<LuminanceSource> rotateCounterClockwise(
+        zxing::ErrorHandler& err_handler) const override;
+
+    int getMaxSize() { return dataHeight * dataWidth; }
+};
+}  // namespace wechat_qrcode
+}  // namespace cv
+#endif  // __OPENCV_WECHAT_QRCODE_IMGSOURCE_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/precomp.hpp
new file mode 100644
index 00000000..1fc21c0f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/precomp.hpp
@@ -0,0 +1,29 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __OPENCV_WECHAT_QRCODE_PRECOMP_HPP__
+#define __OPENCV_WECHAT_QRCODE_PRECOMP_HPP__
+#ifdef _MSC_VER
+#pragma warning(disable: 4244)
+#pragma warning(disable: 4267)
+#endif
+#include <stdint.h>
+#include <stdio.h>
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+#include <map>
+#include "imgsource.hpp"
+using std::ostringstream;
+using std::string;
+using std::vector;
+#endif  // __OPENCV_WECHAT_QRCODE_PRECOMP_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/scale/super_scale.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/scale/super_scale.cpp
new file mode 100644
index 00000000..8b3b1138
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/scale/super_scale.cpp
@@ -0,0 +1,63 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "../precomp.hpp"
+#include "super_scale.hpp"
+
+
+#define CLIP(x, x1, x2) max(x1, min(x, x2))
+namespace cv {
+namespace wechat_qrcode {
+int SuperScale::init(const std::string &proto_path, const std::string &model_path) {
+    srnet_ = dnn::readNetFromCaffe(proto_path, model_path);
+    net_loaded_ = true;
+    return 0;
+}
+
+Mat SuperScale::processImageScale(const Mat &src, float scale, const bool &use_sr,
+                                  int sr_max_size) {
+    Mat dst = src;
+    if (scale == 1.0) {  // src
+        return dst;
+    }
+
+    int width = src.cols;
+    int height = src.rows;
+    if (scale == 2.0) {  // upsample
+        int SR_TH = sr_max_size;
+        if (use_sr && (int)sqrt(width * height * 1.0) < SR_TH && net_loaded_) {
+            int ret = superResoutionScale(src, dst);
+            if (ret == 0) return dst;
+        }
+
+        { resize(src, dst, Size(), scale, scale, INTER_CUBIC); }
+    } else if (scale < 1.0) {  // downsample
+        resize(src, dst, Size(), scale, scale, INTER_AREA);
+    }
+
+    return dst;
+}
+
+int SuperScale::superResoutionScale(const Mat &src, Mat &dst) {
+    Mat blob;
+    dnn::blobFromImage(src, blob, 1.0 / 255, Size(src.cols, src.rows), {0.0f}, false, false);
+
+    srnet_.setInput(blob);
+    auto prob = srnet_.forward();
+
+    dst = Mat(prob.size[2], prob.size[3], CV_8UC1);
+
+    for (int row = 0; row < prob.size[2]; row++) {
+        const float *prob_score = prob.ptr<float>(0, 0, row);
+        for (int col = 0; col < prob.size[3]; col++) {
+            float pixel = prob_score[col] * 255.0;
+            dst.at<uint8_t>(row, col) = static_cast<uint8_t>(CLIP(pixel, 0.0f, 255.0f));
+        }
+    }
+    return 0;
+}
+}  // namespace wechat_qrcode
+}  // namespace cv
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/scale/super_scale.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/scale/super_scale.hpp
new file mode 100644
index 00000000..2717932c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/scale/super_scale.hpp
@@ -0,0 +1,32 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __SCALE_SUPER_SCALE_HPP_
+#define __SCALE_SUPER_SCALE_HPP_
+
+#include <stdio.h>
+#include "opencv2/dnn.hpp"
+#include "opencv2/imgproc.hpp"
+namespace cv {
+namespace wechat_qrcode {
+
+class SuperScale {
+public:
+    SuperScale(){};
+    ~SuperScale(){};
+    int init(const std::string &proto_path, const std::string &model_path);
+    Mat processImageScale(const Mat &src, float scale, const bool &use_sr, int sr_max_size = 160);
+
+private:
+    dnn::Net srnet_;
+    bool net_loaded_ = false;
+    int superResoutionScale(const cv::Mat &src, cv::Mat &dst);
+};
+
+}  // namespace wechat_qrcode
+}  // namespace cv
+#endif  // __SCALE_SUPER_SCALE_HPP_
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/wechat_qrcode.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/wechat_qrcode.cpp
new file mode 100644
index 00000000..f4bec7c2
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/wechat_qrcode.cpp
@@ -0,0 +1,247 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "precomp.hpp"
+#include "opencv2/wechat_qrcode.hpp"
+#include "decodermgr.hpp"
+#include "detector/align.hpp"
+#include "detector/ssd_detector.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/core/utils/filesystem.hpp"
+#include "scale/super_scale.hpp"
+#include "zxing/result.hpp"
+namespace cv {
+namespace wechat_qrcode {
+class WeChatQRCode::Impl {
+public:
+    Impl() {}
+    ~Impl() {}
+    /**
+     * @brief detect QR codes from the given image
+     *
+     * @param img supports grayscale or color (BGR) image.
+     * @return vector<Mat> detected QR code bounding boxes.
+     */
+    std::vector<Mat> detect(const Mat& img);
+    /**
+     * @brief decode QR codes from detected points
+     *
+     * @param img supports grayscale or color (BGR) image.
+     * @param candidate_points detected points. we name it "candidate points" which means no
+     * all the qrcode can be decoded.
+     * @param points succussfully decoded qrcode with bounding box points.
+     * @return vector<string>
+     */
+    std::vector<std::string> decode(const Mat& img, std::vector<Mat>& candidate_points,
+                                    std::vector<Mat>& points);
+    int applyDetector(const Mat& img, std::vector<Mat>& points);
+    Mat cropObj(const Mat& img, const Mat& point, Align& aligner);
+    std::vector<float> getScaleList(const int width, const int height);
+    std::shared_ptr<SSDDetector> detector_;
+    std::shared_ptr<SuperScale> super_resolution_model_;
+    bool use_nn_detector_, use_nn_sr_;
+    float scaleFactor = -1.f;
+};
+
+WeChatQRCode::WeChatQRCode(const String& detector_prototxt_path,
+                           const String& detector_caffe_model_path,
+                           const String& super_resolution_prototxt_path,
+                           const String& super_resolution_caffe_model_path) {
+    p = makePtr<WeChatQRCode::Impl>();
+    if (!detector_caffe_model_path.empty() && !detector_prototxt_path.empty()) {
+        // initialize detector model (caffe)
+        p->use_nn_detector_ = true;
+        CV_Assert(utils::fs::exists(detector_prototxt_path));
+        CV_Assert(utils::fs::exists(detector_caffe_model_path));
+        p->detector_ = make_shared<SSDDetector>();
+        auto ret = p->detector_->init(detector_prototxt_path, detector_caffe_model_path);
+        CV_Assert(ret == 0);
+    } else {
+        p->use_nn_detector_ = false;
+        p->detector_ = NULL;
+    }
+    // initialize super_resolution_model
+    // it could also support non model weights by cubic resizing
+    // so, we initialize it first.
+    p->super_resolution_model_ = make_shared<SuperScale>();
+    if (!super_resolution_prototxt_path.empty() && !super_resolution_caffe_model_path.empty()) {
+        p->use_nn_sr_ = true;
+        // initialize dnn model (caffe format)
+        CV_Assert(utils::fs::exists(super_resolution_prototxt_path));
+        CV_Assert(utils::fs::exists(super_resolution_caffe_model_path));
+        auto ret = p->super_resolution_model_->init(super_resolution_prototxt_path,
+                                                    super_resolution_caffe_model_path);
+        CV_Assert(ret == 0);
+    } else {
+        p->use_nn_sr_ = false;
+    }
+}
+
+vector<string> WeChatQRCode::detectAndDecode(InputArray img, OutputArrayOfArrays points) {
+    CV_Assert(!img.empty());
+    CV_CheckDepthEQ(img.depth(), CV_8U, "");
+
+    if (img.cols() <= 20 || img.rows() <= 20) {
+        return vector<string>();  // image data is not enough for providing reliable results
+    }
+    Mat input_img;
+    int incn = img.channels();
+    CV_Check(incn, incn == 1 || incn == 3 || incn == 4, "");
+    if (incn == 3 || incn == 4) {
+        cvtColor(img, input_img, COLOR_BGR2GRAY);
+    } else {
+        input_img = img.getMat();
+    }
+    auto candidate_points = p->detect(input_img);
+    auto res_points = vector<Mat>();
+    auto ret = p->decode(input_img, candidate_points, res_points);
+    // opencv type convert
+    vector<Mat> tmp_points;
+    if (points.needed()) {
+        for (size_t i = 0; i < res_points.size(); i++) {
+            Mat tmp_point;
+            tmp_points.push_back(tmp_point);
+            res_points[i].convertTo(((OutputArray)tmp_points[i]), CV_32FC2);
+        }
+        points.createSameSize(tmp_points, CV_32FC2);
+        points.assign(tmp_points);
+    }
+    return ret;
+}
+
+void WeChatQRCode::setScaleFactor(float _scaleFactor) {
+    if (_scaleFactor > 0 && _scaleFactor <= 1.f)
+        p->scaleFactor = _scaleFactor;
+    else
+        p->scaleFactor = -1.f;
+};
+
+float WeChatQRCode::getScaleFactor() {
+    return p->scaleFactor;
+};
+
+vector<string> WeChatQRCode::Impl::decode(const Mat& img, vector<Mat>& candidate_points,
+                                          vector<Mat>& points) {
+    if (candidate_points.size() == 0) {
+        return vector<string>();
+    }
+    vector<string> decode_results;
+    for (auto& point : candidate_points) {
+        Mat cropped_img;
+        Align aligner;
+        if (use_nn_detector_) {
+            cropped_img = cropObj(img, point, aligner);
+        } else {
+            cropped_img = img;
+        }
+        // scale_list contains different scale ratios
+        auto scale_list = getScaleList(cropped_img.cols, cropped_img.rows);
+        for (auto cur_scale : scale_list) {
+            Mat scaled_img =
+                super_resolution_model_->processImageScale(cropped_img, cur_scale, use_nn_sr_);
+            string result;
+            DecoderMgr decodemgr;
+            vector<vector<Point2f>> zxing_points, check_points;
+            auto ret = decodemgr.decodeImage(scaled_img, use_nn_detector_, decode_results, zxing_points);
+            if (ret == 0) {
+                for(size_t i = 0; i <zxing_points.size(); i++){
+                    vector<Point2f> points_qr = zxing_points[i];
+                    for (auto&& pt: points_qr) {
+                        pt /= cur_scale;
+                    }
+
+                    if (use_nn_detector_)
+                        points_qr = aligner.warpBack(points_qr);
+                    for (int j = 0; j < 4; ++j) {
+                        point.at<float>(j, 0) = points_qr[j].x;
+                        point.at<float>(j, 1) = points_qr[j].y;
+                    }
+                    // try to find duplicate qr corners
+                    bool isDuplicate = false;
+                    for (const auto &tmp_points: check_points) {
+                        const float eps = 10.f;
+                        for (size_t j = 0; j < tmp_points.size(); j++) {
+                            if (abs(tmp_points[j].x - points_qr[j].x) < eps &&
+                                abs(tmp_points[j].y - points_qr[j].y) < eps) {
+                                isDuplicate = true;
+                            }
+                            else {
+                                isDuplicate = false;
+                                break;
+                            }
+                        }
+                    }
+                    if (isDuplicate == false) {
+                        points.push_back(point);
+                        check_points.push_back(points_qr);
+                    }
+                    else {
+                        decode_results.erase(decode_results.begin() + i, decode_results.begin() + i + 1);
+                    }
+                }
+                break;
+            }
+        }
+    }
+
+    return decode_results;
+}
+
+vector<Mat> WeChatQRCode::Impl::detect(const Mat& img) {
+    auto points = vector<Mat>();
+
+    if (use_nn_detector_) {
+        // use cnn detector
+        auto ret = applyDetector(img, points);
+        CV_Assert(ret == 0);
+    } else {
+        auto width = img.cols, height = img.rows;
+        // if there is no detector, use the full image as input
+        auto point = Mat(4, 2, CV_32FC1);
+        point.at<float>(0, 0) = 0;
+        point.at<float>(0, 1) = 0;
+        point.at<float>(1, 0) = width - 1;
+        point.at<float>(1, 1) = 0;
+        point.at<float>(2, 0) = width - 1;
+        point.at<float>(2, 1) = height - 1;
+        point.at<float>(3, 0) = 0;
+        point.at<float>(3, 1) = height - 1;
+        points.push_back(point);
+    }
+    return points;
+}
+
+int WeChatQRCode::Impl::applyDetector(const Mat& img, vector<Mat>& points) {
+    int img_w = img.cols;
+    int img_h = img.rows;
+
+    const float targetArea = 400.f * 400.f;
+    // hard code input size
+    const float tmpScaleFactor = scaleFactor == -1.f ? min(1.f, sqrt(targetArea / (img_w * img_h))) : scaleFactor;
+    int detect_width = img_w * tmpScaleFactor;
+    int detect_height = img_h * tmpScaleFactor;
+
+    points = detector_->forward(img, detect_width, detect_height);
+
+    return 0;
+}
+
+Mat WeChatQRCode::Impl::cropObj(const Mat& img, const Mat& point, Align& aligner) {
+    // make some padding to boost the qrcode details recall.
+    float padding_w = 0.1f, padding_h = 0.1f;
+    auto min_padding = 15;
+    auto cropped = aligner.crop(img, point, padding_w, padding_h, min_padding);
+    return cropped;
+}
+
+// empirical rules
+vector<float> WeChatQRCode::Impl::getScaleList(const int width, const int height) {
+    if (width < 320 || height < 320) return {1.0, 2.0, 0.5};
+    if (width < 640 && height < 640) return {1.0, 0.5};
+    return {0.5, 1.0};
+}
+}  // namespace wechat_qrcode
+}  // namespace cv
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarizer.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarizer.cpp
new file mode 100644
index 00000000..68508287
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarizer.cpp
@@ -0,0 +1,88 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../precomp.hpp"
+#include "binarizer.hpp"
+
+namespace zxing {
+
+Binarizer::Binarizer(Ref<LuminanceSource> source) : source_(source) {
+    dataWidth = source->getWidth();
+    dataHeight = source->getHeight();
+
+    width = dataWidth;
+    height = dataHeight;
+
+    matrix_ = NULL;
+    matrix0_ = NULL;
+    matrixInverted_ = NULL;
+
+    histogramBinarized = false;
+    usingHistogram = false;
+}
+
+Binarizer::~Binarizer() {}
+
+Ref<LuminanceSource> Binarizer::getLuminanceSource() const { return source_; }
+
+int Binarizer::getWidth() const {
+    return width;
+}
+
+int Binarizer::getHeight() const {
+    return height;
+}
+
+int Binarizer::rotateCounterClockwise() { return 0; }
+
+int Binarizer::rotateCounterClockwise45() { return 0; }
+
+Ref<BitMatrix> Binarizer::getInvertedMatrix(ErrorHandler& err_handler) {
+    if (!matrix_) {
+        return Ref<BitMatrix>();
+    }
+
+    if (matrixInverted_ == NULL) {
+        matrixInverted_ = new BitMatrix(matrix_->getWidth(), matrix_->getHeight(), err_handler);
+        matrixInverted_->copyOf(matrix_, err_handler);
+        matrixInverted_->flipAll();
+    }
+
+    return matrixInverted_;
+}
+
+// Return different black matrix according to cacheMode
+Ref<BitMatrix> Binarizer::getBlackMatrix(ErrorHandler& err_handler) {
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+    matrix_ = matrix0_;
+    return matrix_;
+}
+
+Ref<BitArray> Binarizer::getBlackRow(int y, Ref<BitArray> row, ErrorHandler& err_handler) {
+    if (!matrix_) {
+        matrix_ = getBlackMatrix(err_handler);
+        if (err_handler.ErrCode()) return Ref<BitArray>();
+    }
+
+    matrix_->getRow(y, row);
+    return row;
+}
+
+ArrayRef<BINARIZER_BLOCK> Binarizer::getBlockArray(int size) {
+    ArrayRef<BINARIZER_BLOCK> blocks(new Array<BINARIZER_BLOCK>(size));
+
+    for (int i = 0; i < blocks->size(); i++) {
+        blocks[i].sum = 0;
+        blocks[i].min = 0xFF;
+        blocks[i].max = 0;
+    }
+
+    return blocks;
+}
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarizer.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarizer.hpp
new file mode 100644
index 00000000..7e444c52
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarizer.hpp
@@ -0,0 +1,88 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_BINARIZER_HPP__
+#define __ZXING_BINARIZER_HPP__
+
+#include "common/bitarray.hpp"
+#include "common/bitmatrix.hpp"
+#include "common/counted.hpp"
+#include "errorhandler.hpp"
+#include "luminance_source.hpp"
+
+#define ONED_ENABLE_LINE_BINARIZER
+
+namespace zxing {
+
+// typedef unsigned char uint8_t;
+
+struct BINARIZER_BLOCK {
+    int sum;
+    int min;
+    int max;
+    int threshold;
+    // int average;
+};
+
+#ifdef ONED_ENABLE_LINE_BINARIZER
+struct DecodeTipInfo {
+    int class_id;
+};
+#endif
+
+class Binarizer : public Counted {
+private:
+    Ref<LuminanceSource> source_;
+    bool histogramBinarized;
+    bool usingHistogram;
+
+public:
+    explicit Binarizer(Ref<LuminanceSource> source);
+    virtual ~Binarizer();
+
+    // Added for store binarized result
+
+    int dataWidth;
+    int dataHeight;
+    int width;
+    int height;
+
+    // Store dynamicalli choice of which matrix is currently used
+    Ref<BitMatrix> matrix_;
+
+    // Restore 0 degree result
+    Ref<BitMatrix> matrix0_;
+
+    Ref<BitMatrix> matrixInverted_;
+
+    bool isRotateSupported() const { return false; }
+
+    // rotate counter clockwise 45 & 90 degree from binarized cache
+    int rotateCounterClockwise();
+    int rotateCounterClockwise45();
+
+    virtual Ref<BitMatrix> getBlackMatrix(ErrorHandler& err_handler);
+    virtual Ref<BitMatrix> getInvertedMatrix(ErrorHandler& err_handler);
+    virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row, ErrorHandler& err_handler);
+
+    Ref<LuminanceSource> getLuminanceSource() const;
+    // virtual Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source) = 0;
+    virtual Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source) {
+        return Ref<Binarizer>(new Binarizer(source));
+    };
+
+    int getWidth() const;
+    int getHeight() const;
+
+    ArrayRef<BINARIZER_BLOCK> getBlockArray(int size);
+};
+
+}  // namespace zxing
+#endif  // __ZXING_BINARIZER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarybitmap.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarybitmap.cpp
new file mode 100644
index 00000000..28352ca8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarybitmap.cpp
@@ -0,0 +1,66 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../precomp.hpp"
+#include "binarybitmap.hpp"
+
+using zxing::BinaryBitmap;
+using zxing::BitArray;
+using zxing::BitMatrix;
+using zxing::ErrorHandler;
+using zxing::LuminanceSource;
+using zxing::Ref;
+
+// VC++
+using zxing::Binarizer;
+
+BinaryBitmap::BinaryBitmap(Ref<Binarizer> binarizer) : binarizer_(binarizer) {}
+
+BinaryBitmap::~BinaryBitmap() {}
+
+Ref<BitArray> BinaryBitmap::getBlackRow(int y, Ref<BitArray> row, ErrorHandler& err_handler) {
+    Ref<BitArray> bitary = binarizer_->getBlackRow(y, row, err_handler);
+    if (err_handler.ErrCode()) return Ref<BitArray>();
+    return bitary;
+}
+
+Ref<BitMatrix> BinaryBitmap::getBlackMatrix(ErrorHandler& err_handler) {
+    Ref<BitMatrix> bitmtx = binarizer_->getBlackMatrix(err_handler);
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+    return bitmtx;
+}
+
+Ref<BitMatrix> BinaryBitmap::getInvertedMatrix(ErrorHandler& err_handler) {
+    Ref<BitMatrix> bitmtx = binarizer_->getInvertedMatrix(err_handler);
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+    return bitmtx;
+}
+
+int BinaryBitmap::getWidth() const { return binarizer_->getWidth(); }
+
+int BinaryBitmap::getHeight() const { return binarizer_->getHeight(); }
+
+Ref<LuminanceSource> BinaryBitmap::getLuminanceSource() const {
+    return binarizer_->getLuminanceSource();
+}
+
+bool BinaryBitmap::isCropSupported() const { return getLuminanceSource()->isCropSupported(); }
+
+Ref<BinaryBitmap> BinaryBitmap::crop(int left, int top, int width, int height,
+                                     ErrorHandler& err_handler) {
+    return Ref<BinaryBitmap>(new BinaryBitmap(binarizer_->createBinarizer(
+        getLuminanceSource()->crop(left, top, width, height, err_handler))));
+}
+
+bool BinaryBitmap::isRotateSupported() const { return binarizer_->isRotateSupported(); }
+
+Ref<BinaryBitmap> BinaryBitmap::rotateCounterClockwise() {
+    binarizer_->rotateCounterClockwise();
+    return Ref<BinaryBitmap>(new BinaryBitmap(binarizer_));
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarybitmap.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarybitmap.hpp
new file mode 100644
index 00000000..d483fcd3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/binarybitmap.hpp
@@ -0,0 +1,53 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_BINARYBITMAP_HPP__
+#define __ZXING_BINARYBITMAP_HPP__
+
+#include "binarizer.hpp"
+#include "common/bitarray.hpp"
+#include "common/bitmatrix.hpp"
+#include "common/counted.hpp"
+#include "common/unicomblock.hpp"
+#include "errorhandler.hpp"
+
+namespace zxing {
+
+class BinaryBitmap : public Counted {
+private:
+    Ref<Binarizer> binarizer_;
+
+public:
+    explicit BinaryBitmap(Ref<Binarizer> binarizer);
+    virtual ~BinaryBitmap();
+
+    Ref<BitArray> getBlackRow(int y, Ref<BitArray> row, ErrorHandler& err_handler);
+    Ref<BitMatrix> getBlackMatrix(ErrorHandler& err_handler);
+    Ref<BitMatrix> getInvertedMatrix(ErrorHandler& err_handler);
+
+    Ref<LuminanceSource> getLuminanceSource() const;
+    Ref<UnicomBlock> m_poUnicomBlock;
+
+    int getWidth() const;
+    int getHeight() const;
+
+    bool isRotateSupported() const;
+    Ref<BinaryBitmap> rotateCounterClockwise();
+
+    bool isCropSupported() const;
+    Ref<BinaryBitmap> crop(int left, int top, int width, int height, ErrorHandler& err_handler);
+
+    bool isHistogramBinarized() const;
+    bool ifUseHistogramBinarize() const;
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_BINARYBITMAP_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/array.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/array.hpp
new file mode 100644
index 00000000..9187937e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/array.hpp
@@ -0,0 +1,113 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_ARRAY_HPP__
+#define __ZXING_COMMON_ARRAY_HPP__
+
+#include "counted.hpp"
+
+namespace zxing {
+
+template <typename T>
+class Array : public Counted {
+protected:
+public:
+    std::vector<T> values_;
+    Array() {}
+    explicit Array(int n) : Counted(), values_(n, T()) {}
+    Array(T const *ts, int n) : Counted(), values_(ts, ts + n) {}
+    Array(T const *ts, T const *te) : Counted(), values_(ts, te) {}
+    Array(T v, int n) : Counted(), values_(n, v) {}
+    explicit Array(std::vector<T> &v) : Counted(), values_(v) {}
+    Array(Array<T> &other) : Counted(), values_(other.values_) {}
+    explicit Array(Array<T> *other) : Counted(), values_(other->values_) {}
+    virtual ~Array() {}
+    Array<T> &operator=(const Array<T> &other) {
+        values_ = other.values_;
+        return *this;
+    }
+    Array<T> &operator=(const std::vector<T> &array) {
+        values_ = array;
+        return *this;
+    }
+    T const &operator[](int i) const { return values_[i]; }
+    T &operator[](int i) { return values_[i]; }
+    int size() const { return values_.size(); }
+    bool empty() const { return values_.size() == 0; }
+    std::vector<T> const &values() const { return values_; }
+    std::vector<T> &values() { return values_; }
+
+    T *data() {
+        // return values_.data();
+        return &values_[0];
+    }
+    void append(T value) { values_.push_back(value); }
+};
+
+template <typename T>
+class ArrayRef : public Counted {
+private:
+public:
+    Array<T> *array_;
+    ArrayRef() : array_(0) {}
+    explicit ArrayRef(int n) : array_(0) { reset(new Array<T>(n)); }
+    ArrayRef(T *ts, int n) : array_(0) { reset(new Array<T>(ts, n)); }
+    explicit ArrayRef(Array<T> *a) : array_(0) { reset(a); }
+    ArrayRef(const ArrayRef &other) : Counted(), array_(0) { reset(other.array_); }
+
+    ~ArrayRef() {
+        if (array_) {
+            array_->release();
+        }
+        array_ = 0;
+    }
+
+    T const &operator[](int i) const { return (*array_)[i]; }
+
+    T &operator[](int i) { return (*array_)[i]; }
+
+    void reset(Array<T> *a) {
+        if (a) {
+            a->retain();
+        }
+        if (array_) {
+            array_->release();
+        }
+        array_ = a;
+    }
+    void reset(const ArrayRef<T> &other) { reset(other.array_); }
+    ArrayRef<T> &operator=(const ArrayRef<T> &other) {
+        reset(other);
+        return *this;
+    }
+    ArrayRef<T> &operator=(Array<T> *a) {
+        reset(a);
+        return *this;
+    }
+
+    Array<T> &operator*() const { return *array_; }
+
+    Array<T> *operator->() const { return array_; }
+
+    operator bool() const { return array_ != 0; }
+    bool operator!() const { return array_ == 0; }
+
+    T *data() { return array_->data(); }
+
+    void clear() {
+        T *ptr = array_->data();
+        memset(ptr, 0, array_->size());
+    }
+    void append(T value) { array_->append(value); }
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_ARRAY_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/adaptive_threshold_mean_binarizer.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/adaptive_threshold_mean_binarizer.cpp
new file mode 100644
index 00000000..38a79b37
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/adaptive_threshold_mean_binarizer.cpp
@@ -0,0 +1,99 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "../../../precomp.hpp"
+#include "adaptive_threshold_mean_binarizer.hpp"
+using zxing::AdaptiveThresholdMeanBinarizer;
+
+namespace {
+const int BLOCK_SIZE = 25;
+const int Bias = 10;
+}  // namespace
+
+AdaptiveThresholdMeanBinarizer::AdaptiveThresholdMeanBinarizer(Ref<LuminanceSource> source)
+    : GlobalHistogramBinarizer(source) {}
+
+AdaptiveThresholdMeanBinarizer::~AdaptiveThresholdMeanBinarizer() {}
+
+Ref<Binarizer> AdaptiveThresholdMeanBinarizer::createBinarizer(Ref<LuminanceSource> source) {
+    return Ref<Binarizer>(new AdaptiveThresholdMeanBinarizer(source));
+}
+
+Ref<BitArray> AdaptiveThresholdMeanBinarizer::getBlackRow(int y, Ref<BitArray> row,
+                                                          ErrorHandler& err_handler) {
+    // First call binarize image in child class to get matrix0_ and binCache
+    if (!matrix0_) {
+        binarizeImage(err_handler);
+        if (err_handler.ErrCode()) return Ref<BitArray>();
+    }
+
+    // Call parent getBlackMatrix to get current matrix
+    return Binarizer::getBlackRow(y, row, err_handler);
+}
+
+Ref<BitMatrix> AdaptiveThresholdMeanBinarizer::getBlackMatrix(ErrorHandler& err_handler) {
+    // First call binarize image in child class to get matrix0_ and binCache
+    if (!matrix0_) {
+        binarizeImage(err_handler);
+        if (err_handler.ErrCode()) return Ref<BitMatrix>();
+    }
+    return Binarizer::getBlackMatrix(err_handler);
+}
+
+int AdaptiveThresholdMeanBinarizer::binarizeImage(ErrorHandler& err_handler) {
+    if (width >= BLOCK_SIZE && height >= BLOCK_SIZE) {
+        LuminanceSource& source = *getLuminanceSource();
+        Ref<BitMatrix> matrix(new BitMatrix(width, height, err_handler));
+        if (err_handler.ErrCode()) return -1;
+        auto src = (unsigned char*)source.getMatrix()->data();
+        auto dst = matrix->getPtr();
+        cv::Mat mDst;
+        mDst = cv::Mat::zeros(cv::Size(width, height), CV_8UC1);
+        TransBufferToMat(src, mDst, width, height);
+        cv::Mat result;
+        int bs = width / 10;
+        bs = bs + bs % 2 - 1;
+        if (!(bs % 2 == 1 && bs > 1)) return -1;
+        cv::adaptiveThreshold(mDst, result, 255, cv::ADAPTIVE_THRESH_GAUSSIAN_C, cv::THRESH_BINARY,
+                              bs, Bias);
+        TransMatToBuffer(result, dst, width, height);
+        if (err_handler.ErrCode()) return -1;
+        matrix0_ = matrix;
+    } else {
+        matrix0_ = GlobalHistogramBinarizer::getBlackMatrix(err_handler);
+        if (err_handler.ErrCode()) return 1;
+    }
+    return 0;
+}
+
+int AdaptiveThresholdMeanBinarizer::TransBufferToMat(unsigned char* pBuffer, cv::Mat& mDst,
+                                                     int nWidth, int nHeight) {
+    for (int j = 0; j < nHeight; ++j) {
+        unsigned char* data = mDst.ptr<unsigned char>(j);
+        unsigned char* pSubBuffer = pBuffer + (nHeight - 1 - j) * nWidth;
+        memcpy(data, pSubBuffer, nWidth);
+    }
+    return 0;
+}
+
+int AdaptiveThresholdMeanBinarizer::TransMatToBuffer(cv::Mat mSrc, unsigned char* ppBuffer,
+                                                     int& nWidth, int& nHeight) {
+    nWidth = mSrc.cols;
+    // nWidth = ((nWidth + 3) / 4) * 4;
+    nHeight = mSrc.rows;
+    for (int j = 0; j < nHeight; ++j) {
+        unsigned char* pdi = ppBuffer + j * nWidth;
+        for (int z = 0; z < nWidth; ++z) {
+            int nj = nHeight - j - 1;
+            int value = *(uchar*)(mSrc.ptr<uchar>(nj) + z);
+            if (value > 120)
+                pdi[z] = 0;
+            else
+                pdi[z] = 1;
+        }
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/adaptive_threshold_mean_binarizer.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/adaptive_threshold_mean_binarizer.hpp
new file mode 100644
index 00000000..bd51dde8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/adaptive_threshold_mean_binarizer.hpp
@@ -0,0 +1,38 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __ZXING_COMMON_ADAPTIVE_THRESHOLD_MEAN_BINARIZER_HPP__
+#define __ZXING_COMMON_ADAPTIVE_THRESHOLD_MEAN_BINARIZER_HPP__
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include "../../binarizer.hpp"
+#include "../../errorhandler.hpp"
+#include "../bitarray.hpp"
+#include "../bitmatrix.hpp"
+#include "../bytematrix.hpp"
+#include "global_histogram_binarizer.hpp"
+
+
+namespace zxing {
+
+class AdaptiveThresholdMeanBinarizer : public GlobalHistogramBinarizer {
+public:
+    explicit AdaptiveThresholdMeanBinarizer(Ref<LuminanceSource> source);
+    virtual ~AdaptiveThresholdMeanBinarizer();
+
+    virtual Ref<BitMatrix> getBlackMatrix(ErrorHandler& err_handler) override;
+    virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row, ErrorHandler& err_handler) override;
+    Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source) override;
+
+private:
+    int binarizeImage(ErrorHandler& err_handler);
+    int TransBufferToMat(unsigned char* pBuffer, cv::Mat& mDst, int nWidth, int nHeight);
+    int TransMatToBuffer(cv::Mat mSrc, unsigned char* ppBuffer, int& nWidth, int& nHeight);
+};
+
+}  // namespace zxing
+#endif  // __ZXING_COMMON_ADAPTIVE_THRESHOLD_MEAN_BINARIZER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/fast_window_binarizer.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/fast_window_binarizer.cpp
new file mode 100644
index 00000000..b0d9f657
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/fast_window_binarizer.cpp
@@ -0,0 +1,285 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "fast_window_binarizer.hpp"
+using zxing::FastWindowBinarizer;
+
+
+namespace {
+const int BLOCK_SIZE = 6;
+// const int BLOCK_SIZE = 8; // not as good as BLOCK_SIZE = 6
+const float WINDOW_FRACTION = 0.13f;
+
+static int min(int a, int b) { return a < b ? a : b; }
+
+static int max(int a, int b) { return a > b ? a : b; }
+
+}  // namespace
+
+FastWindowBinarizer::FastWindowBinarizer(Ref<LuminanceSource> source)
+    : GlobalHistogramBinarizer(source), matrix_(NULL), cached_row_(NULL) {
+    width = source->getWidth();
+    height = source->getHeight();
+    int aw = width / BLOCK_SIZE;
+    int ah = height / BLOCK_SIZE;
+
+    int ah2 = ah;
+    int ow2 = aw + 1;
+
+    _luminancesInt = new int[width * height];
+    _blockTotals = new int[ah * aw];
+    _totals = new int[(ah + 1) * (aw + 1)];
+    _rowTotals = new int[ah2 * ow2];
+
+    _internal = new unsigned int[(height + 1) * (width + 1)];
+}
+
+FastWindowBinarizer::~FastWindowBinarizer() {
+    delete[] _totals;
+    delete[] _blockTotals;
+    delete[] _luminancesInt;
+    delete[] _rowTotals;
+
+    delete[] _internal;
+}
+
+Ref<Binarizer> FastWindowBinarizer::createBinarizer(Ref<LuminanceSource> source) {
+    return Ref<Binarizer>(new FastWindowBinarizer(source));
+}
+
+/**
+ * Calculates the final BitMatrix once for all requests. This could be called
+ * once from the constructor instead, but there are some advantages to doing it
+ * lazily, such as making profiling easier, and not doing heavy lifting when
+ * callers don't expect it.
+ */
+Ref<BitMatrix> FastWindowBinarizer::getBlackMatrix(ErrorHandler& err_handler) {
+    if (!matrix0_) {
+        binarizeImage1(err_handler);
+        if (err_handler.ErrCode()) return Ref<BitMatrix>();
+    }
+
+    return Binarizer::getBlackMatrix(err_handler);
+}
+
+/**
+ * Calculate black row from BitMatrix
+ * If BitMatrix has been calculated then just get the row
+ * If BitMatrix has not been calculated then call getBlackMatrix first
+ */
+
+Ref<BitArray> FastWindowBinarizer::getBlackRow(int y, Ref<BitArray> row,
+                                               ErrorHandler& err_handler) {
+    if (!matrix0_) {
+        binarizeImage1(err_handler);
+        if (err_handler.ErrCode()) return Ref<BitArray>();
+    }
+    // Call parent getBlackMatrix to get current matrix
+    return Binarizer::getBlackRow(y, row, err_handler);
+}
+
+void FastWindowBinarizer::calcBlockTotals(int* luminancesInt, int* output, int aw, int ah) {
+    for (int by = 0; by < ah; by++) {
+        int ey = (by + 1) * BLOCK_SIZE;
+        for (int bx = 0; bx < aw; bx++) {
+            int t = 0;
+            for (int y = by * BLOCK_SIZE; y < ey; y++) {
+                int offset = y * width + bx * BLOCK_SIZE;
+                int ex = offset + BLOCK_SIZE;
+                for (; offset < ex; offset++) {
+                    // int v = luminancesInt[offset] & 0xff;
+                    t += luminancesInt[offset];
+                }
+            }
+            output[by * aw + bx] = t;
+        }
+    }
+}
+
+void FastWindowBinarizer::cumulative(int* data, int* output, int _width, int _height) {
+    int ah = _height;
+    int aw = _width;
+    int ow = _width + 1;
+    // int[][] totals = new int[ah + 1][aw + 1];
+    // int* rowTotals = new int[ah*ow];
+
+    for (int y = 0; y < ah; y++) {
+        int* row = _rowTotals + (y * ow);
+        int* rowdata = data + (y * aw);
+        int t = 0;
+        row[0] = t;
+
+        for (int x = 0; x < aw; x++) {
+            t += rowdata[x];
+            row[x + 1] = t;
+        }
+    }
+
+    for (int x = 0; x <= aw; x++) {
+        output[x] = 0;  // First row
+        int t = 0;
+
+        for (int y = 0; y < ah; y++) {
+            t += _rowTotals[y * ow + x];
+            output[(y + 1) * ow + x] = t;
+        }
+    }
+}
+
+void FastWindowBinarizer::fastIntegral(const unsigned char* inputMatrix,
+                                       unsigned int* outputMatrix) {
+    // memset(outputMatrix,0,sizeof(int)*(height+1)*(width+1));
+    // unsigned int *columnSum = new unsigned int[width]; // sum of each column
+    // calculate integral of the first line
+    outputMatrix[0] = outputMatrix[width + 1] = 0;
+    for (int i = 0; i < width; i++) {
+        // columnSum[i]=inputMatrix[i];
+        outputMatrix[i + 1] = 0;
+        outputMatrix[width + 1 + i + 1] = outputMatrix[width + 1 + i] + inputMatrix[i];
+    }
+    for (int i = 1; i < height; i++) {
+        const unsigned char* psi = inputMatrix + i * width;
+        unsigned int* pdi = outputMatrix + (i + 1) * (width + 1);
+        // first column of each line
+        pdi[0] = 0;
+        pdi[1] = psi[0];
+        int row_sum = psi[0];
+        // other columns
+        for (int j = 1; j < width; j++) {
+            row_sum += psi[j];
+            pdi[j + 1] = pdi[j + 1 - width - 1] + row_sum;
+        }
+    }
+    return;
+}
+
+int FastWindowBinarizer::binarizeImage1(ErrorHandler& err_handler) {
+    LuminanceSource& source = *getLuminanceSource();
+    Ref<BitMatrix> matrix(new BitMatrix(width, height, err_handler));
+    if (err_handler.ErrCode()) return -1;
+
+    ArrayRef<char> localLuminances = source.getMatrix();
+
+    unsigned char* src = (unsigned char*)localLuminances->data();
+    unsigned char* dst = matrix->getPtr();
+    fastWindow(src, dst, err_handler);
+    if (err_handler.ErrCode()) return -1;
+
+    matrix0_ = matrix;
+    return 0;
+}
+
+void FastWindowBinarizer::fastWindow(const unsigned char* src, unsigned char* dst,
+                                     ErrorHandler& err_handler) {
+    int r = (int)(min(width, height) * WINDOW_FRACTION / BLOCK_SIZE / 2 + 1);
+    const int NEWH_BLOCK_SIZE = BLOCK_SIZE * r;
+    if (height < NEWH_BLOCK_SIZE || width < NEWH_BLOCK_SIZE) {
+        matrix_ = GlobalHistogramBinarizer::getBlackMatrix(err_handler);
+        return;
+    }
+    const unsigned char* _img = src;
+    fastIntegral(_img, _internal);
+    int aw = width / BLOCK_SIZE;
+    int ah = height / BLOCK_SIZE;
+    memset(dst, 0, sizeof(char) * height * width);
+    for (int ai = 0; ai < ah; ai++) {
+        int top = max(0, ((ai - r + 1) * BLOCK_SIZE));
+        int bottom = min(height, (ai + r) * BLOCK_SIZE);
+        unsigned int* pt = _internal + top * (width + 1);
+        unsigned int* pb = _internal + bottom * (width + 1);
+        for (int aj = 0; aj < aw; aj++) {
+            int left = max(0, (aj - r + 1) * BLOCK_SIZE);
+            int right = min(width, (aj + r) * BLOCK_SIZE);
+            unsigned int block = pb[right] + pt[left] - pt[right] - pb[left];
+            int pixels = (bottom - top) * (right - left);
+            int avg = (int)block / pixels;
+            for (int bi = ai * BLOCK_SIZE; bi < height && bi < (ai + 1) * BLOCK_SIZE; bi++) {
+                const unsigned char* psi = src + bi * width;
+                unsigned char* pdi = dst + bi * width;
+                for (int bj = aj * BLOCK_SIZE; bj < width && bj < (aj + 1) * BLOCK_SIZE; bj++) {
+                    if ((int)psi[bj] < avg)
+                        pdi[bj] = 1;
+                    else
+                        pdi[bj] = 0;
+                }
+            }
+        }
+    }
+    // delete [] _internal;
+    return;
+}
+
+int FastWindowBinarizer::binarizeImage0(ErrorHandler& err_handler) {
+    // if (matrix_) {
+    //	return matrix_;
+    //}
+
+    LuminanceSource& source = *getLuminanceSource();
+    if (width >= BLOCK_SIZE && height >= BLOCK_SIZE) {
+        int r = (int)(min(width, height) * WINDOW_FRACTION / BLOCK_SIZE / 2 + 1);
+
+        int aw = width / BLOCK_SIZE;
+        int ah = height / BLOCK_SIZE;
+        int ow = aw + 1;
+
+        ArrayRef<char> _luminances = source.getMatrix();
+
+        // Get luminances for int value first
+        for (int i = 0; i < width * height; i++) {
+            _luminancesInt[i] = _luminances[i] & 0xff;
+        }
+
+        calcBlockTotals(_luminancesInt, _blockTotals, aw, ah);
+
+        cumulative(_blockTotals, _totals, aw, ah);
+
+        Ref<BitMatrix> newMatrix(new BitMatrix(width, height, err_handler));
+        if (err_handler.ErrCode()) return -1;
+        unsigned char* newimg = newMatrix->getPtr();
+        for (int by = 0; by < ah; by++) {
+            int top = max(0, by - r + 1);
+            int bottom = min(ah, by + r);
+
+            for (int bx = 0; bx < aw; bx++) {
+                int left = max(0, bx - r + 1);
+                int right = min(aw, bx + r);
+
+                int block = _totals[bottom * ow + right] + _totals[top * ow + left] -
+                            _totals[top * ow + right] - _totals[bottom * ow + left];
+
+                int pixels = (bottom - top) * (right - left) * BLOCK_SIZE * BLOCK_SIZE;
+                int avg = block / pixels;
+
+                for (int y = by * BLOCK_SIZE; y < (by + 1) * BLOCK_SIZE; y++) {
+                    // int offset = y*width;
+                    int* plumint = _luminancesInt + y * width;
+                    unsigned char* pn = newimg + y * width;
+                    for (int x = bx * BLOCK_SIZE; x < (bx + 1) * BLOCK_SIZE; x++) {
+                        // int pixel = luminances[y*width + x] & 0xff;
+                        // if(plumint[x] < avg)
+                        // newMatrix->set(x, y);
+                        if (plumint[x] < avg)
+                            pn[x] = 1;
+                        else
+                            pn[x] = 0;
+                    }
+                }
+            }
+        }
+        // delete[] data;
+        matrix_ = newMatrix;
+    } else {
+        // If the image is too small, fall back to the global histogram
+        // approach.
+        matrix_ = GlobalHistogramBinarizer::getBlackMatrix(err_handler);
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/fast_window_binarizer.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/fast_window_binarizer.hpp
new file mode 100644
index 00000000..a18c186e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/fast_window_binarizer.hpp
@@ -0,0 +1,56 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_DETECTOR_RESULT_HPP__
+#define __ZXING_COMMON_DETECTOR_RESULT_HPP__
+
+#include "../../binarizer.hpp"
+#include "../../errorhandler.hpp"
+#include "../bitarray.hpp"
+#include "../bitmatrix.hpp"
+#include "global_histogram_binarizer.hpp"
+
+#include <vector>
+
+namespace zxing {
+
+class FastWindowBinarizer : public GlobalHistogramBinarizer {
+private:
+    Ref<BitMatrix> matrix_;
+    Ref<BitArray> cached_row_;
+
+    int* _luminancesInt;
+    int* _blockTotals;
+    int* _totals;
+    int* _rowTotals;
+
+    unsigned int* _internal;
+
+public:
+    explicit FastWindowBinarizer(Ref<LuminanceSource> source);
+    virtual ~FastWindowBinarizer();
+
+    virtual Ref<BitMatrix> getBlackMatrix(ErrorHandler& err_handler) override;
+    virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row, ErrorHandler& err_handler) override;
+
+    Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source) override;
+
+private:
+    void calcBlockTotals(int* luminancesInt, int* output, int aw, int ah);
+    void cumulative(int* data, int* output, int _width, int _height);
+    int binarizeImage0(ErrorHandler& err_handler);
+    void fastIntegral(const unsigned char* inputMatrix, unsigned int* outputMatrix);
+    int binarizeImage1(ErrorHandler& err_handler);
+    void fastWindow(const unsigned char* src, unsigned char* dst, ErrorHandler& err_handler);
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_DETECTOR_RESULT_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/global_histogram_binarizer.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/global_histogram_binarizer.cpp
new file mode 100644
index 00000000..0f1aa056
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/global_histogram_binarizer.cpp
@@ -0,0 +1,308 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "global_histogram_binarizer.hpp"
+using zxing::GlobalHistogramBinarizer;
+
+namespace {
+const int LUMINANCE_BITS = 5;
+const int LUMINANCE_SHIFT = 8 - LUMINANCE_BITS;
+const int LUMINANCE_BUCKETS = 1 << LUMINANCE_BITS;
+const ArrayRef<char> EMPTY(0);
+}  // namespace
+
+GlobalHistogramBinarizer::GlobalHistogramBinarizer(Ref<LuminanceSource> source)
+    : Binarizer(source), luminances(EMPTY), buckets(LUMINANCE_BUCKETS) {
+    filtered = false;
+}
+
+GlobalHistogramBinarizer::~GlobalHistogramBinarizer() {}
+
+void GlobalHistogramBinarizer::initArrays(int luminanceSize) {
+    if (luminances->size() < luminanceSize) {
+        luminances = ArrayRef<char>(luminanceSize);
+    }
+    for (int x = 0; x < LUMINANCE_BUCKETS; x++) {
+        buckets[x] = 0;
+    }
+}
+
+// Applies simple sharpening to the row data to improve performance of the 1D
+// readers.
+Ref<BitArray> GlobalHistogramBinarizer::getBlackRow(int y, Ref<BitArray> row,
+                                                    ErrorHandler& err_handler) {
+    // First call binarize image in child class to get matrix0_ and binCache
+    if (!matrix0_) {
+        binarizeImage0(err_handler);
+        if (err_handler.ErrCode()) return Ref<BitArray>();
+    }
+    // Call parent getBlackMatrix to get current matrix
+    return Binarizer::getBlackRow(y, row, err_handler);
+}
+
+// Does not sharpen the data, as this call is intended to only be used by 2D
+// readers.
+Ref<BitMatrix> GlobalHistogramBinarizer::getBlackMatrix(ErrorHandler& err_handler) {
+    binarizeImage0(err_handler);
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+    // First call binarize image in child class to get matrix0_ and binCache
+    // Call parent getBlackMatrix to get current matrix
+    return Binarizer::getBlackMatrix(err_handler);
+}
+
+using namespace std;
+
+int GlobalHistogramBinarizer::estimateBlackPoint(ArrayRef<int> const& _buckets,
+                                                 ErrorHandler& err_handler) {
+    // Find tallest peak in histogram
+    int numBuckets = _buckets->size();
+    int maxBucketCount = 0;
+    int firstPeak = 0;
+    int firstPeakSize = 0;
+    for (int x = 0; x < numBuckets; x++) {
+        if (_buckets[x] > firstPeakSize) {
+            firstPeak = x;
+            firstPeakSize = _buckets[x];
+        }
+        if (_buckets[x] > maxBucketCount) {
+            maxBucketCount = _buckets[x];
+        }
+    }
+
+    // Find second-tallest peak -- well, another peak that is tall and not
+    // so close to the first one
+    int secondPeak = 0;
+    int secondPeakScore = 0;
+    for (int x = 0; x < numBuckets; x++) {
+        int distanceToBiggest = x - firstPeak;
+        // Encourage more distant second peaks by multiplying by square of
+        // distance
+        int score = _buckets[x] * distanceToBiggest * distanceToBiggest;
+        if (score > secondPeakScore) {
+            secondPeak = x;
+            secondPeakScore = score;
+        }
+    }
+    // Make sure firstPeak corresponds to the black peak.
+    if (firstPeak > secondPeak) {
+        int temp = firstPeak;
+        firstPeak = secondPeak;
+        secondPeak = temp;
+    }
+
+    // Kind of arbitrary; if the two peaks are very close, then we figure there
+    // is so little dynamic range in the image, that discriminating black and
+    // white is too error-prone. Decoding the image/line is either pointless, or
+    // may in some cases lead to a false positive for 1D formats, which are
+    // relatively lenient. We arbitrarily say "close" is  "<= 1/16 of the total
+    // histogram buckets apart" std::cerr << "! " << secondPeak << " " <<
+    // firstPeak << " " << numBuckets << std::endl;
+    if (secondPeak - firstPeak <= numBuckets >> 4) {
+        err_handler = NotFoundErrorHandler("NotFound GlobalHistogramBinarizer");
+        return -1;
+    }
+
+    // Find a valley between them that is low and closer to the white peak
+    int bestValley = secondPeak - 1;
+    int bestValleyScore = -1;
+    for (int x = secondPeak - 1; x > firstPeak; x--) {
+        int fromFirst = x - firstPeak;
+        // Favor a "valley" that is not too close to either peak -- especially
+        // not the black peak -- and that has a low value of course
+        int score = fromFirst * fromFirst * (secondPeak - x) * (maxBucketCount - buckets[x]);
+        if (score > bestValleyScore) {
+            bestValley = x;
+            bestValleyScore = score;
+        }
+    }
+
+    // std::cerr << "bps " << (bestValley << LUMINANCE_SHIFT) << std::endl;
+    return bestValley << LUMINANCE_SHIFT;
+}
+
+// codes from sagazhou, only works well on one dataset
+int GlobalHistogramBinarizer::estimateBlackPoint2(ArrayRef<int> const& _buckets) {
+    int midValue = LUMINANCE_BUCKETS / 2 + 1;
+    // Find tallest and lowest peaks in histogram
+    // const int numBuckets = buckets->size();
+    int maxPointArray[LUMINANCE_BUCKETS] = {0};
+    int maxCrusor = 0;
+    int maxValue = 0, maxIndex = 0;
+    int minPointArray[LUMINANCE_BUCKETS] = {0};
+    int minCrusor = 0;
+
+    for (int i = 2; i < LUMINANCE_BUCKETS - 3; i++) {
+        if (_buckets[i] < _buckets[i + 1] && _buckets[i] < _buckets[i + 2] &&
+            _buckets[i] < _buckets[i - 1] && _buckets[i] < _buckets[i - 2]) {
+            minPointArray[minCrusor++] = i;
+        } else if (_buckets[i] > _buckets[i + 1] && _buckets[i] > _buckets[i + 2] &&
+                   _buckets[i] > _buckets[i - 1] && _buckets[i] > _buckets[i - 2]) {
+            maxPointArray[maxCrusor++] = i;
+            if (_buckets[i] > maxValue) {
+                maxValue = _buckets[i];
+                maxIndex = i;
+            }
+        }
+    }
+    bool bSlantBlack = true;
+    // most pixels are black
+    for (int i = 0; i < maxCrusor; ++i) {
+        if (maxPointArray[i] > midValue) {
+            bSlantBlack = false;
+            break;
+        }
+    }
+
+    bool bSlantWhite = true;
+    // most pixels are white
+    for (int i = 0; i < maxCrusor; ++i) {
+        if (maxPointArray[i] < midValue) {
+            bSlantWhite = false;
+            break;
+        }
+    }
+
+    if (bSlantBlack) {
+        int start = maxIndex + 30;
+        int end = midValue;
+
+        if (minCrusor == 0)  // unimodal
+        {
+            return 255;
+        } else {
+            int mostLeftIndex = 0;
+            bool bFind = false;
+
+            for (int i = 0; i < minCrusor; ++i)  // wave motion
+            {
+                if (minPointArray[i] > start && minPointArray[i] < end) {
+                    mostLeftIndex = minPointArray[i];
+                    bFind = true;
+                    break;
+                }
+            }
+
+            if (bFind) {
+                return mostLeftIndex;
+            } else {
+                return 255;
+            }
+        }
+    }
+
+    if (bSlantWhite) {
+        int start = midValue;
+        int end = maxIndex - 30;
+
+        if (minCrusor == 0)  // unimodal
+        {
+            return 0;
+        } else {
+            int mostRightIndex = 0;
+            bool bFind = false;
+
+            for (int i = 0; i < minCrusor; ++i)  // wave motion
+            {
+                if (minPointArray[i] > start && minPointArray[i] < end) {
+                    mostRightIndex = i;
+                    bFind = true;
+                }
+            }
+
+            if (bFind) {
+                return mostRightIndex;
+            } else {
+                return 0;
+            }
+        }
+    }
+
+    // balanced distribution
+    if (maxIndex < midValue) {
+        // the minest min value
+        if (minCrusor == 0) {
+            return 255;  // all black
+        } else {
+            int start = maxIndex + 30;
+            int end = 253;
+
+            for (int i = 0; i < minCrusor; ++i)  // wave motion
+            {
+                if (minPointArray[i] > start && minPointArray[i] < end) {
+                    return minPointArray[i];
+                }
+            }
+        }
+    } else {
+        // maxest min value
+        if (minCrusor == 0) {
+            return 0;  // white
+        } else {
+            int start = 0;
+            int end = maxIndex - 30;
+            int mostRightIndex = 0;
+
+            for (int i = 0; i < minCrusor; ++i)  // wave motion
+            {
+                if (minPointArray[i] > start && minPointArray[i] < end) {
+                    mostRightIndex = minPointArray[i];
+                }
+            }
+
+            return mostRightIndex;
+        }
+    }
+    return 0;
+}
+
+int GlobalHistogramBinarizer::binarizeImage0(ErrorHandler& err_handler) {
+    LuminanceSource& source = *getLuminanceSource();
+    Ref<BitMatrix> matrix(new BitMatrix(width, height, err_handler));
+    if (err_handler.ErrCode()) return -1;
+    // Quickly calculates the histogram by sampling four rows from the image.
+    // This proved to be more robust on the blackbox tests than sampling a
+    // diagonal as we used to do.
+    initArrays(width);
+    ArrayRef<int> localBuckets = buckets;
+
+    for (int y = 1; y < 5; y++) {
+        int row = height * y / 5;
+        ArrayRef<char> localLuminances = source.getRow(row, luminances, err_handler);
+        if (err_handler.ErrCode()) return -1;
+        int right = (width << 2) / 5;
+        for (int x = width / 5; x < right; x++) {
+            int pixel = localLuminances[x] & 0xff;
+            localBuckets[pixel >> LUMINANCE_SHIFT]++;
+        }
+    }
+
+
+    int blackPoint = estimateBlackPoint(localBuckets, err_handler);
+    if (err_handler.ErrCode()) return -1;
+
+    ArrayRef<char> localLuminances = source.getMatrix();
+    for (int y = 0; y < height; y++) {
+        int offset = y * width;
+        for (int x = 0; x < width; x++) {
+            int pixel = localLuminances[offset + x] & 0xff;
+            if (pixel < blackPoint) {
+                matrix->set(x, y);
+            }
+        }
+    }
+
+    matrix0_ = matrix;
+
+    return 0;
+}
+
+Ref<Binarizer> GlobalHistogramBinarizer::createBinarizer(Ref<LuminanceSource> source) {
+    return Ref<Binarizer>(new GlobalHistogramBinarizer(source));
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/global_histogram_binarizer.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/global_histogram_binarizer.hpp
new file mode 100644
index 00000000..f61b3cfe
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/global_histogram_binarizer.hpp
@@ -0,0 +1,55 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_GLOBAL_HISTOGRAM_BINARIZER_HPP__
+#define __ZXING_COMMON_GLOBAL_HISTOGRAM_BINARIZER_HPP__
+
+#include "../../binarizer.hpp"
+#include "../../errorhandler.hpp"
+#include "../array.hpp"
+#include "../bitarray.hpp"
+#include "../bitmatrix.hpp"
+#include "../bytematrix.hpp"
+
+using zxing::ArrayRef;
+using zxing::Binarizer;
+using zxing::BitArray;
+using zxing::BitMatrix;
+using zxing::ByteMatrix;
+using zxing::ErrorHandler;
+using zxing::LuminanceSource;
+using zxing::Ref;
+
+namespace zxing {
+
+class GlobalHistogramBinarizer : public Binarizer {
+protected:
+    ArrayRef<char> luminances;
+    ArrayRef<int> buckets;
+
+public:
+    explicit GlobalHistogramBinarizer(Ref<LuminanceSource> source);
+    virtual ~GlobalHistogramBinarizer();
+
+    virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row, ErrorHandler &err_handler) override;
+    virtual Ref<BitMatrix> getBlackMatrix(ErrorHandler &err_handler) override;
+    int estimateBlackPoint(ArrayRef<int> const &buckets, ErrorHandler &err_handler);
+    int estimateBlackPoint2(ArrayRef<int> const &buckets);
+    Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source) override;
+
+private:
+    int binarizeImage0(ErrorHandler &err_handler);
+    void initArrays(int luminanceSize);
+    bool filtered;
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_GLOBAL_HISTOGRAM_BINARIZER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/hybrid_binarizer.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/hybrid_binarizer.cpp
new file mode 100644
index 00000000..fb55ed8f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/hybrid_binarizer.cpp
@@ -0,0 +1,419 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "hybrid_binarizer.hpp"
+
+using zxing::HybridBinarizer;
+using zxing::BINARIZER_BLOCK;
+
+// This class uses 5*5 blocks to compute local luminance, where each block is
+// 8*8 pixels So this is the smallest dimension in each axis we can accept.
+namespace {
+const int BLOCK_SIZE_POWER = 3;
+const int BLOCK_SIZE = 1 << BLOCK_SIZE_POWER;  // ...0100...00
+const int BLOCK_SIZE_MASK = BLOCK_SIZE - 1;    // ...0011...11
+const int MINIMUM_DIMENSION = BLOCK_SIZE * 5;
+#ifdef USE_SET_INT
+const int BITS_PER_BYTE = 8;
+const int BITS_PER_WORD = BitMatrix::bitsPerWord;
+#endif
+}  // namespace
+
+HybridBinarizer::HybridBinarizer(Ref<LuminanceSource> source) : GlobalHistogramBinarizer(source) {
+    int subWidth = width >> BLOCK_SIZE_POWER;
+    if ((width & BLOCK_SIZE_MASK) != 0) {
+        subWidth++;
+    }
+    int subHeight = height >> BLOCK_SIZE_POWER;
+    if ((height & BLOCK_SIZE_MASK) != 0) {
+        subHeight++;
+    }
+
+    grayByte_ = source->getByteMatrix();
+
+    blocks_ = getBlockArray(subWidth * subHeight);
+
+    subWidth_ = subWidth;
+    subHeight_ = subHeight;
+
+    initBlocks();
+    initBlockIntegral();
+}
+
+HybridBinarizer::~HybridBinarizer() {
+}
+
+Ref<Binarizer> HybridBinarizer::createBinarizer(Ref<LuminanceSource> source) {
+    return Ref<Binarizer>(new GlobalHistogramBinarizer(source));
+}
+
+int HybridBinarizer::initBlockIntegral() {
+    blockIntegralWidth = subWidth_ + 1;
+    blockIntegralHeight = subHeight_ + 1;
+    blockIntegral_ = new Array<int>(blockIntegralWidth * blockIntegralHeight);
+
+    int* integral = blockIntegral_->data();
+
+    // unsigned char* therow = grayByte_->getByteRow(0);
+
+    // first row only
+    int rs = 0;
+
+    for (int j = 0; j < blockIntegralWidth; j++) {
+        integral[j] = 0;
+    }
+
+    for (int i = 0; i < blockIntegralHeight; i++) {
+        integral[i * blockIntegralWidth] = 0;
+    }
+
+    // remaining cells are sum above and to the left
+    int offsetBlock = 0;
+    int offsetIntegral = 0;
+
+    for (int i = 0; i < subHeight_; ++i) {
+        // therow = grayByte_->getByteRow(i);
+        offsetBlock = i * subWidth_;
+        offsetIntegral = (i + 1) * blockIntegralWidth;
+        rs = 0;
+
+        for (int j = 0; j < subWidth_; ++j) {
+            rs += blocks_[offsetBlock + j].threshold;
+            integral[offsetIntegral + j + 1] = rs + integral[offsetIntegral - blockIntegralWidth + j + 1];
+        }
+    }
+
+    return 1;
+}
+
+/**
+ * Calculates the final BitMatrix once for all requests. This could be called
+ * once from the constructor instead, but there are some advantages to doing it
+ * lazily, such as making profiling easier, and not doing heavy lifting when
+ * callers don't expect it.
+ */
+Ref<BitMatrix> HybridBinarizer::getBlackMatrix(ErrorHandler& err_handler) {
+    // First call binarize image in child class to get matrix0_ and binCache
+    if (!matrix0_) {
+        binarizeByBlock(err_handler);
+        if (err_handler.ErrCode()) return Ref<BitMatrix>();
+    }
+
+    // First call binarize image in child class to get matrix0_ and binCache
+    // Call parent getBlackMatrix to get current matrix
+    return Binarizer::getBlackMatrix(err_handler);
+}
+
+#if 1
+/**
+ * Calculate black row from BitMatrix
+ * If BitMatrix has been calculated then just get the row
+ * If BitMatrix has not been calculated then call getBlackMatrix first
+ */
+Ref<BitArray> HybridBinarizer::getBlackRow(int y, Ref<BitArray> row, ErrorHandler& err_handler) {
+    // First call binarize image in child class to get matrix0_ and binCache
+    if (!matrix0_) {
+        binarizeByBlock(err_handler);
+        if (err_handler.ErrCode()) return Ref<BitArray>();
+    }
+
+    // Call parent getBlackMatrix to get current matrix
+    return Binarizer::getBlackRow(y, row, err_handler);
+}
+#endif
+
+namespace {
+inline int cap(int value, int min, int max) {
+    return value < min ? min : value > max ? max : value;
+}
+}  // namespace
+
+
+// For each block in the image, calculates the average black point using a 5*5
+// grid of the blocks around it. Also handles the corner cases (fractional
+// blocks are computed based on the last pixels in the row/column which are also
+// used in the previous block.)
+
+#define THRES_BLOCKSIZE 2
+
+// No use of level now
+ArrayRef<int> HybridBinarizer::getBlackPoints() {
+    int blackWidth, blackHeight;
+
+    blackWidth = subWidth_;
+    blackHeight = subHeight_;
+
+    ArrayRef<int> blackPoints(blackWidth * blackHeight);
+
+    int* blackArray = blackPoints->data();
+
+    int offset = 0;
+    for (int i = 0; i < blackHeight; i++) {
+        offset = i * blackWidth;
+        for (int j = 0; j < blackWidth; j++) {
+            blackArray[offset + j] = blocks_[offset + j].threshold;
+        }
+    }
+
+    return blackPoints;
+}
+
+// Original code 20140606
+void HybridBinarizer::calculateThresholdForBlock(Ref<ByteMatrix>& _luminances, int subWidth,
+                                                 int subHeight, int SIZE_POWER,
+                                                 // ArrayRef<int> &blackPoints,
+                                                 Ref<BitMatrix> const& matrix,
+                                                 ErrorHandler& err_handler) {
+    int block_size = 1 << SIZE_POWER;
+
+    int maxYOffset = height - block_size;
+    int maxXOffset = width - block_size;
+
+    int* blockIntegral = blockIntegral_->data();
+
+    int blockArea = ((2 * THRES_BLOCKSIZE + 1) * (2 * THRES_BLOCKSIZE + 1));
+
+    for (int y = 0; y < subHeight; y++) {
+        int yoffset = y << SIZE_POWER;
+        if (yoffset > maxYOffset) {
+            yoffset = maxYOffset;
+        }
+        for (int x = 0; x < subWidth; x++) {
+            int xoffset = x << SIZE_POWER;
+            if (xoffset > maxXOffset) {
+                xoffset = maxXOffset;
+            }
+            int left = cap(x, THRES_BLOCKSIZE, subWidth - THRES_BLOCKSIZE - 1);
+            int top = cap(y, THRES_BLOCKSIZE, subHeight - THRES_BLOCKSIZE - 1);
+
+            int sum = 0;
+            // int sum2 = 0;
+
+            int offset1 = (top - THRES_BLOCKSIZE) * blockIntegralWidth + left - THRES_BLOCKSIZE;
+            int offset2 = (top + THRES_BLOCKSIZE + 1) * blockIntegralWidth + left - THRES_BLOCKSIZE;
+
+            int blocksize = THRES_BLOCKSIZE * 2 + 1;
+
+            sum = blockIntegral[offset1] - blockIntegral[offset1 + blocksize] -
+                  blockIntegral[offset2] + blockIntegral[offset2 + blocksize];
+
+            int average = sum / blockArea;
+            thresholdBlock(_luminances, xoffset, yoffset, average, matrix, err_handler);
+            if (err_handler.ErrCode()) return;
+        }
+    }
+}
+
+#ifdef USE_SET_INT
+void HybridBinarizer::thresholdFourBlocks(Ref<ByteMatrix>& luminances, int xoffset, int yoffset,
+                                          int* thresholds, int stride,
+                                          Ref<BitMatrix> const& matrix) {
+    int setIntCircle = BITS_PER_WORD / BITS_PER_BYTE;
+    for (int y = 0; y < BLOCK_SIZE; y++) {
+        unsigned char* pTemp = luminances->getByteRow(yoffset + y);
+        pTemp = pTemp + xoffset;
+        unsigned int valueInt = 0;
+        int bitPosition = 0;
+        for (int k = 0; k < setIntCircle; k++) {
+            for (int x = 0; x < BLOCK_SIZE; x++) {
+                int pixel = *pTemp++;
+                if (pixel <= thresholds[k]) {
+                    // bitPosition=(3-k)*8+x;
+                    valueInt |= (unsigned int)1 << bitPosition;
+                }
+                bitPosition++;
+            }
+        }
+        matrix->setIntOneTime(xoffset, yoffset + y, valueInt);
+    }
+    return;
+}
+#endif
+
+// Applies a single threshold to a block of pixels
+void HybridBinarizer::thresholdBlock(Ref<ByteMatrix>& _luminances, int xoffset, int yoffset,
+                                     int threshold, Ref<BitMatrix> const& matrix,
+                                     ErrorHandler& err_handler) {
+    int rowBitsSize = matrix->getRowBitsSize();
+    int rowSize = width;
+
+    int rowBitStep = rowBitsSize - BLOCK_SIZE;
+    int rowStep = rowSize - BLOCK_SIZE;
+
+    unsigned char* pTemp = _luminances->getByteRow(yoffset, err_handler);
+    if (err_handler.ErrCode()) return;
+    bool* bpTemp = matrix->getRowBoolPtr(yoffset);
+
+    pTemp += xoffset;
+    bpTemp += xoffset;
+
+    for (int y = 0; y < BLOCK_SIZE; y++) {
+        for (int x = 0; x < BLOCK_SIZE; x++) {
+            // comparison needs to be <= so that black == 0 pixels are black
+            // even if the threshold is 0.
+            *bpTemp++ = (*pTemp++ <= threshold) ? true : false;
+        }
+
+        pTemp += rowBitStep;
+        bpTemp += rowStep;
+    }
+}
+
+void HybridBinarizer::thresholdIrregularBlock(Ref<ByteMatrix>& _luminances, int xoffset,
+                                              int yoffset, int blockWidth, int blockHeight,
+                                              int threshold, Ref<BitMatrix> const& matrix,
+                                              ErrorHandler& err_handler) {
+    for (int y = 0; y < blockHeight; y++) {
+        unsigned char* pTemp = _luminances->getByteRow(yoffset + y, err_handler);
+        if (err_handler.ErrCode()) return;
+        pTemp = pTemp + xoffset;
+        for (int x = 0; x < blockWidth; x++) {
+            // comparison needs to be <= so that black == 0 pixels are black
+            // even if the threshold is 0.
+            int pixel = *pTemp++;
+            if (pixel <= threshold) {
+                matrix->set(xoffset + x, yoffset + y);
+            }
+        }
+    }
+}
+
+namespace {
+
+inline int getBlackPointFromNeighbors(ArrayRef<BINARIZER_BLOCK> block, int subWidth, int x, int y) {
+    return (block[(y - 1) * subWidth + x].threshold + 2 * block[y * subWidth + x - 1].threshold +
+            block[(y - 1) * subWidth + x - 1].threshold) >>
+           2;
+}
+
+}  // namespace
+
+
+#define MIN_DYNAMIC_RANGE 24
+
+// Calculates a single black point for each block of pixels and saves it away.
+int HybridBinarizer::initBlocks() {
+    Ref<ByteMatrix>& _luminances = grayByte_;
+    int subWidth = subWidth_;
+    int subHeight = subHeight_;
+
+    unsigned char* bytes = _luminances->bytes;
+
+    const int minDynamicRange = 24;
+
+    for (int y = 0; y < subHeight; y++) {
+        int yoffset = y << BLOCK_SIZE_POWER;
+        int maxYOffset = height - BLOCK_SIZE;
+        if (yoffset > maxYOffset) yoffset = maxYOffset;
+        for (int x = 0; x < subWidth; x++) {
+            int xoffset = x << BLOCK_SIZE_POWER;
+            int maxXOffset = width - BLOCK_SIZE;
+            if (xoffset > maxXOffset) xoffset = maxXOffset;
+            int sum = 0;
+            int min = 0xFF;
+            int max = 0;
+            for (int yy = 0, offset = yoffset * width + xoffset; yy < BLOCK_SIZE;
+                 yy++, offset += width) {
+                for (int xx = 0; xx < BLOCK_SIZE; xx++) {
+                    // int pixel = luminances->bytes[offset + xx] & 0xFF;
+                    int pixel = bytes[offset + xx];
+                    sum += pixel;
+
+                    // still looking for good contrast
+                    if (pixel < min) {
+                        min = pixel;
+                    }
+                    if (pixel > max) {
+                        max = pixel;
+                    }
+                }
+
+                // short-circuit min/max tests once dynamic range is met
+                if (max - min > minDynamicRange) {
+                    // finish the rest of the rows quickly
+                    for (yy++, offset += width; yy < BLOCK_SIZE; yy++, offset += width) {
+                        for (int xx = 0; xx < BLOCK_SIZE; xx += 2) {
+                            sum += bytes[offset + xx];
+                            sum += bytes[offset + xx + 1];
+                        }
+                    }
+                }
+            }
+
+            blocks_[y * subWidth + x].min = min;
+            blocks_[y * subWidth + x].max = max;
+            blocks_[y * subWidth + x].sum = sum;
+            blocks_[y * subWidth + x].threshold =
+                getBlockThreshold(x, y, subWidth, sum, min, max, minDynamicRange, BLOCK_SIZE_POWER);
+        }
+    }
+
+    return 1;
+}
+
+int HybridBinarizer::getBlockThreshold(int x, int y, int subWidth, int sum, int min, int max,
+                                       int minDynamicRange, int SIZE_POWER) {
+    // See
+    // http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0
+
+    // The default estimate is the average of the values in the block.
+    int average = sum >> (SIZE_POWER * 2);
+    if (max - min <= minDynamicRange) {
+        // If variation within the block is low, assume this is a block withe
+        // only light or only dark pixels. In that case we do not want to use
+        // the average, as it would divide this low contrast area into black and
+        // white pixels, essentially creating data out of noise. The default
+        // assumption is that the block is light/background. Since no estimate
+        // for the level of dark pixels exists locally, use half the min for the
+        // block.
+        average = min >> 1;
+        if (y > 0 && x > 0) {
+            // Correct the "white background" assumption for blocks that have
+            // neighbors by comparing the pixels in this block to the previously
+            // calculated black points. This is based on the fact that dark
+            // barcode symbology is always surrounded by some amout of light
+            // background for which reasonable black point estimates were made.
+            // The bp estimated at the boundaries is used for the interior.
+            int bp = getBlackPointFromNeighbors(blocks_, subWidth, x, y);
+            // The (min<bp) is arbitrary but works better than other heuristics
+            // that were tried.
+            if (min < bp) {
+                average = bp;
+            }
+        }
+    }
+
+    // blocks_[y * subWidth + x].average = average;
+    // blocks_[y * subWidth + x].threshold = average;
+
+    return average;
+}
+
+
+int HybridBinarizer::binarizeByBlock(ErrorHandler& err_handler) {
+    if (width >= MINIMUM_DIMENSION && height >= MINIMUM_DIMENSION) {
+        Ref<BitMatrix> newMatrix(new BitMatrix(width, height, err_handler));
+        if (err_handler.ErrCode()) return -1;
+
+        calculateThresholdForBlock(grayByte_, subWidth_, subHeight_, BLOCK_SIZE_POWER, newMatrix,
+                                   err_handler);
+        if (err_handler.ErrCode()) return -1;
+
+        matrix0_ = newMatrix;
+
+    } else {
+        // If the image is too small, fall back to the global histogram
+        // approach.
+        matrix0_ = GlobalHistogramBinarizer::getBlackMatrix(err_handler);
+        if (err_handler.ErrCode()) return 1;
+    }
+    // return matrix0_;
+    return 1;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/hybrid_binarizer.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/hybrid_binarizer.hpp
new file mode 100644
index 00000000..c134918c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/hybrid_binarizer.hpp
@@ -0,0 +1,85 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_HYBRID_BINARIZER_HPP__
+#define __ZXING_COMMON_HYBRID_BINARIZER_HPP__
+
+#include "../../binarizer.hpp"
+#include "../../errorhandler.hpp"
+#include "../bitarray.hpp"
+#include "../bitmatrix.hpp"
+#include "../bytematrix.hpp"
+#include "global_histogram_binarizer.hpp"
+
+#include <vector>
+
+
+namespace zxing {
+
+class HybridBinarizer : public GlobalHistogramBinarizer {
+private:
+    Ref<ByteMatrix> grayByte_;
+    // ArrayRef<int> integral_;
+    ArrayRef<int> blockIntegral_;
+    ArrayRef<BINARIZER_BLOCK> blocks_;
+
+    ArrayRef<int> blackPoints_;
+    int level_;
+
+    int subWidth_;
+    int subHeight_;
+    int blockIntegralWidth;
+    int blockIntegralHeight;
+
+public:
+    explicit HybridBinarizer(Ref<LuminanceSource> source);
+    virtual ~HybridBinarizer();
+
+    virtual Ref<BitMatrix> getBlackMatrix(ErrorHandler& err_handler) override;
+    virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row, ErrorHandler& err_handler) override;
+
+    Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source) override;
+
+private:
+    int initIntegral();
+    int initBlockIntegral();
+    int initBlocks();
+
+    // int calculateBlackPoints();
+    ArrayRef<int> getBlackPoints();
+    int getBlockThreshold(int x, int y, int subWidth, int sum, int min, int max,
+                          int minDynamicRange, int SIZE_POWER);
+
+
+    void calculateThresholdForBlock(Ref<ByteMatrix>& luminances, int subWidth, int subHeight,
+                                    int SIZE_POWER, Ref<BitMatrix> const& matrix,
+                                    ErrorHandler& err_handler);
+
+
+    void thresholdBlock(Ref<ByteMatrix>& luminances, int xoffset, int yoffset, int threshold,
+                        Ref<BitMatrix> const& matrix, ErrorHandler& err_handler);
+
+    void thresholdIrregularBlock(Ref<ByteMatrix>& luminances, int xoffset, int yoffset,
+                                 int blockWidth, int blockHeight, int threshold,
+                                 Ref<BitMatrix> const& matrix, ErrorHandler& err_handler);
+
+#ifdef USE_SET_INT
+    void thresholdFourBlocks(Ref<ByteMatrix>& luminances, int xoffset, int yoffset, int* thresholds,
+                             int stride, Ref<BitMatrix> const& matrix);
+#endif
+
+    // Add for binarize image when call getBlackMatrix
+    // By Skylook
+    int binarizeByBlock(ErrorHandler& err_handler);
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_HYBRID_BINARIZER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/simple_adaptive_binarizer.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/simple_adaptive_binarizer.cpp
new file mode 100644
index 00000000..2364bc39
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/simple_adaptive_binarizer.cpp
@@ -0,0 +1,155 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "simple_adaptive_binarizer.hpp"
+
+using zxing::SimpleAdaptiveBinarizer;
+
+
+SimpleAdaptiveBinarizer::SimpleAdaptiveBinarizer(Ref<LuminanceSource> source)
+    : GlobalHistogramBinarizer(source) {
+    filtered = false;
+}
+
+SimpleAdaptiveBinarizer::~SimpleAdaptiveBinarizer() {}
+
+// Applies simple sharpening to the row data to improve performance of the 1D
+// readers.
+Ref<BitArray> SimpleAdaptiveBinarizer::getBlackRow(int y, Ref<BitArray> row,
+                                                   ErrorHandler &err_handler) {
+    // First call binarize image in child class to get matrix0_ and binCache
+    if (!matrix0_) {
+        binarizeImage0(err_handler);
+        if (err_handler.ErrCode()) return Ref<BitArray>();
+    }
+    // Call parent getBlackMatrix to get current matrix
+    return Binarizer::getBlackRow(y, row, err_handler);
+}
+
+// Does not sharpen the data, as this call is intended to only be used by 2D
+// readers.
+Ref<BitMatrix> SimpleAdaptiveBinarizer::getBlackMatrix(ErrorHandler &err_handler) {
+    // First call binarize image in child class to get matrix0_ and binCache
+    if (!matrix0_) {
+        binarizeImage0(err_handler);
+        if (err_handler.ErrCode()) return Ref<BitMatrix>();
+    }
+
+    // First call binarize image in child class to get matrix0_ and binCache
+    // Call parent getBlackMatrix to get current matrix
+    return Binarizer::getBlackMatrix(err_handler);
+}
+
+using namespace std;
+
+int SimpleAdaptiveBinarizer::binarizeImage0(ErrorHandler &err_handler) {
+    LuminanceSource &source = *getLuminanceSource();
+
+    Ref<BitMatrix> matrix(new BitMatrix(width, height, err_handler));
+    if (err_handler.ErrCode()) return -1;
+
+    ArrayRef<char> localLuminances = source.getMatrix();
+
+    unsigned char *src = (unsigned char *)localLuminances->data();
+    unsigned char *dst = matrix->getPtr();
+
+    qrBinarize(src, dst);
+
+    matrix0_ = matrix;
+
+    return 0;
+}
+
+/*A simplified adaptive thresholder.
+  This compares the current pixel value to the mean value of a (large) window
+   surrounding it.*/
+int SimpleAdaptiveBinarizer::qrBinarize(const unsigned char *src, unsigned char *dst) {
+    unsigned char *mask = dst;
+
+    if (width > 0 && height > 0) {
+        unsigned *col_sums;
+        int logwindw;
+        int logwindh;
+        int windw;
+        int windh;
+        int y0offs;
+        int y1offs;
+        unsigned g;
+        int x;
+        int y;
+        /*We keep the window size fairly large to ensure it doesn't fit
+           completely inside the center of a finder pattern of a version 1 QR
+           code at full resolution.*/
+        for (logwindw = 4; logwindw < 8 && (1 << logwindw) < ((width + 7) >> 3); logwindw++)
+            ;
+        for (logwindh = 4; logwindh < 8 && (1 << logwindh) < ((height + 7) >> 3); logwindh++)
+            ;
+        windw = 1 << logwindw;
+        windh = 1 << logwindh;
+
+        int logwinds = (logwindw + logwindh);
+
+        col_sums = (unsigned *)malloc(width * sizeof(*col_sums));
+        /*Initialize sums down each column.*/
+        for (x = 0; x < width; x++) {
+            g = src[x];
+            col_sums[x] = (g << (logwindh - 1)) + g;
+        }
+        for (y = 1; y < (windh >> 1); y++) {
+            y1offs = min(y, height - 1) * width;
+            for (x = 0; x < width; x++) {
+                g = src[y1offs + x];
+                col_sums[x] += g;
+            }
+        }
+        for (y = 0; y < height; y++) {
+            unsigned m;
+            int x0;
+            int x1;
+            /*Initialize the sum over the window.*/
+            m = (col_sums[0] << (logwindw - 1)) + col_sums[0];
+            for (x = 1; x < (windw >> 1); x++) {
+                x1 = min(x, width - 1);
+                m += col_sums[x1];
+            }
+
+            int offset = y * width;
+
+            for (x = 0; x < width; x++) {
+                /*Perform the test against the threshold T = (m/n)-D,
+                   where n=windw*windh and D=3.*/
+                g = src[offset + x];
+                mask[offset + x] = ((g + 3) << (logwinds) < m);
+                /*Update the window sum.*/
+                if (x + 1 < width) {
+                    x0 = max(0, x - (windw >> 1));
+                    x1 = min(x + (windw >> 1), width - 1);
+                    m += col_sums[x1] - col_sums[x0];
+                }
+            }
+            /*Update the column sums.*/
+            if (y + 1 < height) {
+                y0offs = max(0, y - (windh >> 1)) * width;
+                y1offs = min(y + (windh >> 1), height - 1) * width;
+                for (x = 0; x < width; x++) {
+                    col_sums[x] -= src[y0offs + x];
+                    col_sums[x] += src[y1offs + x];
+                }
+            }
+        }
+        free(col_sums);
+    }
+
+    return 1;
+}
+
+Ref<Binarizer> SimpleAdaptiveBinarizer::createBinarizer(Ref<LuminanceSource> source) {
+    return Ref<Binarizer>(new SimpleAdaptiveBinarizer(source));
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/simple_adaptive_binarizer.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/simple_adaptive_binarizer.hpp
new file mode 100644
index 00000000..956e87ee
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/binarizer/simple_adaptive_binarizer.hpp
@@ -0,0 +1,40 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_SIMPLEADAPTIVEBINARIZER_HPP__
+#define __ZXING_COMMON_SIMPLEADAPTIVEBINARIZER_HPP__
+
+#include "../../binarizer.hpp"
+#include "../array.hpp"
+#include "../bitarray.hpp"
+#include "../bitmatrix.hpp"
+#include "global_histogram_binarizer.hpp"
+
+
+namespace zxing {
+
+class SimpleAdaptiveBinarizer : public GlobalHistogramBinarizer {
+public:
+    explicit SimpleAdaptiveBinarizer(Ref<LuminanceSource> source);
+    virtual ~SimpleAdaptiveBinarizer();
+
+    virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row, ErrorHandler &err_handler) override;
+    virtual Ref<BitMatrix> getBlackMatrix(ErrorHandler &err_handler) override;
+    Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source) override;
+
+private:
+    int binarizeImage0(ErrorHandler &err_handler);
+    int qrBinarize(const unsigned char *src, unsigned char *dst);
+    bool filtered;
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_SIMPLEADAPTIVEBINARIZER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitarray.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitarray.cpp
new file mode 100644
index 00000000..e0cb9417
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitarray.cpp
@@ -0,0 +1,233 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "bitarray.hpp"
+
+using zxing::ArrayRef;
+using zxing::BitArray;
+using zxing::ErrorHandler;
+using zxing::Ref;
+
+BitArray::BitArray(int size_) : size(size_), bits(size_), nextSets(size_), nextUnSets(size_) {}
+
+void BitArray::setUnchar(int i, unsigned char newBits) { bits[i] = newBits; }
+
+bool BitArray::isRange(int start, int end, bool value, ErrorHandler &err_handler) {
+    if (end < start) {
+        err_handler = IllegalArgumentErrorHandler("isRange");
+        return false;
+    }
+    if (start < 0 || end >= bits->size()) {
+        err_handler = IllegalArgumentErrorHandler("isRange");
+        return false;
+    }
+    if (end == start) {
+        return true;  // empty range matches
+    }
+
+    bool startBool = bits[start] != (unsigned char)0;
+
+    int end2 = start;
+
+    if (startBool) {
+        end2 = getNextUnset(start);
+    } else {
+        end2 = getNextSet(start);
+    }
+
+    if (startBool == value) {
+        if (end2 < end) {
+            return false;
+        }
+    } else {
+        return false;
+    }
+
+    return true;
+}
+
+void BitArray::reverse() {
+    bool *rowBits = getRowBoolPtr();
+    bool tempBit;
+
+    for (int i = 0; i < size / 2; i++) {
+        tempBit = rowBits[i];
+        rowBits[i] = rowBits[size - i - 1];
+        rowBits[size - i - 1] = tempBit;
+    }
+}
+
+void BitArray::initAllNextSets() {
+    bool *rowBits = getRowBoolPtr();
+
+    int *nextSetArray = nextSets->data();
+    int *nextUnsetArray = nextUnSets->data();
+
+    // Init the last one
+    if (rowBits[size - 1]) {
+        nextSetArray[size - 1] = size - 1;
+        nextUnsetArray[size - 1] = size;
+    } else {
+        nextUnsetArray[size - 1] = size - 1;
+        nextSetArray[size - 1] = size;
+    }
+
+    // do inits
+    for (int i = size - 2; i >= 0; i--) {
+        if (rowBits[i]) {
+            nextSetArray[i] = i;
+            nextUnsetArray[i] = nextUnsetArray[i + 1];
+        } else {
+            nextUnsetArray[i] = i;
+            nextSetArray[i] = nextSetArray[i + 1];
+        }
+    }
+}
+
+void BitArray::initAllNextSetsFromCounters(std::vector<int> counters) {
+    bool *rowBits = getRowBoolPtr();
+    bool isWhite = rowBits[0];
+    int c = 0;
+    int offset = 0;
+    int count = 0;
+    int prevCount = 0;
+    int currCount = 0;
+    int _size = counters.size();
+
+    int *nextSetArray = nextSets->data();
+    int *nextUnsetArray = nextUnSets->data();
+
+    // int* countersArray = counters.data();
+    int *countersArray = &counters[0];
+
+    while (c < _size) {
+        currCount = countersArray[c];
+
+        count += currCount;
+
+        if (isWhite) {
+            for (int i = 0; i < currCount; i++) {
+                offset = prevCount + i;
+                nextSetArray[offset] = prevCount + i;
+                nextUnsetArray[offset] = count;
+            }
+        } else {
+            for (int i = 0; i < currCount; i++) {
+                offset = prevCount + i;
+                nextSetArray[offset] = count;
+                nextUnsetArray[offset] = prevCount + i;
+            }
+        }
+
+        isWhite = !isWhite;
+
+        prevCount += currCount;
+
+        c++;
+    }
+}
+
+int BitArray::getNextSet(int from) {
+    if (from >= size) {
+        return size;
+    }
+    return nextSets[from];
+}
+
+int BitArray::getNextUnset(int from) {
+    if (from >= size) {
+        return size;
+    }
+    return nextUnSets[from];
+}
+
+BitArray::~BitArray() {}
+
+int BitArray::getSize() const { return size; }
+
+void BitArray::clear() {
+    int max = bits->size();
+    for (int i = 0; i < max; i++) {
+        bits[i] = 0;
+    }
+}
+
+BitArray::Reverse::Reverse(Ref<BitArray> array_) : array(array_) { array->reverse(); }
+
+BitArray::Reverse::~Reverse() { array->reverse(); }
+
+void BitArray::appendBit(bool value) {
+    ArrayRef<unsigned char> newBits(size + 1);
+    for (int i = 0; i < size; i++) {
+        newBits[i] = bits[i];
+    }
+    bits = newBits;
+    if (value) {
+        set(size);
+    }
+    ++size;
+}
+
+int BitArray::getSizeInBytes() const { return size; }
+
+// Appends the least-significant bits, from value, in order from
+// most-significant to least-significant. For example, appending 6 bits
+// from 0x000001E will append the bits 0, 1, 1, 1, 1, 0 in that order.
+void BitArray::appendBits(int value, int numBits, ErrorHandler &err_handler) {
+    if (numBits < 0 || numBits > 32) {
+        err_handler = IllegalArgumentErrorHandler("Number of bits must be between 0 and 32");
+        return;
+    }
+    ArrayRef<unsigned char> newBits(size + numBits);
+    for (int i = 0; i < size; i++) newBits[i] = bits[i];
+    bits = newBits;
+    for (int numBitsLeft = numBits; numBitsLeft > 0; numBitsLeft--) {
+        if (((value >> (numBitsLeft - 1)) & 0x01) == 1) {
+            set(size);
+        }
+        ++size;
+    }
+    return;
+}
+
+void BitArray::appendBitArray(const BitArray &array) {
+    ArrayRef<unsigned char> newBits(size + array.getSize());
+    for (int i = 0; i < size; ++i) {
+        newBits[i] = bits[i];
+    }
+    bits = newBits;
+    for (int i = 0; i < array.getSize(); ++i) {
+        if (array.get(i)) {
+            set(size);
+        }
+        ++size;
+    }
+}
+
+void BitArray::toBytes(int bitOffset, ArrayRef<int> &array, int offset, int numBytes) {
+    for (int i = 0; i < numBytes; i++) {
+        int theByte = 0;
+        if (get(bitOffset)) {
+            theByte = 1;
+        }
+        bitOffset++;
+        array[offset + i] = theByte;
+    }
+}
+void BitArray::bitXOR(const BitArray &other, ErrorHandler &err_handler) {
+    if (size != other.size) {
+        err_handler = IllegalArgumentErrorHandler("Sizes don't match");
+        return;
+    }
+
+    for (int i = 0; i < bits->size(); i++) {
+        bits[i] = bits[i] == other.bits[i] ? 0 : 1;
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitarray.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitarray.hpp
new file mode 100644
index 00000000..b6f1f560
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitarray.hpp
@@ -0,0 +1,88 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_BITARRAY_HPP__
+#define __ZXING_COMMON_BITARRAY_HPP__
+
+#include "../errorhandler.hpp"
+#include "../zxing.hpp"
+#include "array.hpp"
+#include "counted.hpp"
+#include <cstring>
+
+namespace zxing {
+
+class BitArray : public Counted {
+private:
+    int size;
+    ArrayRef<unsigned char> bits;
+    ArrayRef<int> nextSets;
+    ArrayRef<int> nextUnSets;
+    // bool nextSetsInited;
+
+public:
+    explicit BitArray(int size);
+    ~BitArray();
+    int getSize() const;
+
+    bool get(int i) const { return bits[i] != 0; }
+    void set(int i) {
+        // bits[i] |= 0xFF;
+        bits[i] = true;
+    }
+    void setOneRow(unsigned char* rowBits, int length) {
+        unsigned char* dst = bits->data();
+        memcpy(dst, rowBits, length);
+    }
+
+    bool* getRowBoolPtr() {
+        // return (bool*)bits.data();
+        return (bool*)bits->data();
+    }
+
+    // Init for next sets and unsets to speed up
+    void initAllNextSets();
+    void initAllNextSetsFromCounters(std::vector<int> counters);
+
+    int getNextSet(int from);
+    int getNextUnset(int from);
+
+    void setUnchar(int i, unsigned char newBist);
+
+    void clear();
+    bool isRange(int start, int end, bool value, ErrorHandler& err_handler);
+
+    void reverse();
+
+    class Reverse {
+    private:
+        Ref<BitArray> array;
+
+    public:
+        explicit Reverse(Ref<BitArray> array);
+        ~Reverse();
+    };
+
+    void appendBit(bool value);
+    int getSizeInBytes() const;
+    void appendBits(int value, int numberOfBits, ErrorHandler& err_handler);
+    void appendBitArray(const BitArray& array);
+    void toBytes(int bitOffset, ArrayRef<int>& array, int offset, int numBytes);
+    void bitXOR(const BitArray& other, ErrorHandler& err_handler);
+
+#ifndef USE_BYTE_FOR_BIT
+private:
+    static int makeArraySize(int size);
+#endif
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_BITARRAY_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitmatrix.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitmatrix.cpp
new file mode 100644
index 00000000..53df192a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitmatrix.cpp
@@ -0,0 +1,397 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "bitmatrix.hpp"
+
+using zxing::ArrayRef;
+using zxing::BitArray;
+using zxing::BitMatrix;
+using zxing::ErrorHandler;
+using zxing::Ref;
+
+void BitMatrix::init(int _width, int _height, ErrorHandler& err_handler) {
+    if (_width < 1 || _height < 1) {
+        err_handler = IllegalArgumentErrorHandler("Both dimensions must be greater than 0");
+        return;
+    }
+    width = _width;
+    height = _height;
+    this->rowBitsSize = width;
+    bits = ArrayRef<unsigned char>(width * height);
+    rowOffsets = ArrayRef<int>(height);
+
+    // offsetRowSize = new int[height];
+    rowOffsets[0] = 0;
+    for (int i = 1; i < height; i++) {
+        rowOffsets[i] = rowOffsets[i - 1] + width;
+    }
+
+    isInitRowCounters = false;
+    isInitColsCounters = false;
+}
+
+void BitMatrix::init(int _width, int _height, unsigned char* bitsPtr, ErrorHandler& err_handler) {
+    init(_width, _height, err_handler);
+    if (err_handler.ErrCode()) return;
+    memcpy(bits->data(), bitsPtr, width * height * sizeof(unsigned char));
+}
+
+void BitMatrix::initRowCounters() {
+    if (isInitRowCounters == true) {
+        return;
+    }
+
+    row_counters = vector<COUNTER_TYPE>(width * height, 0);
+    row_counters_offset = vector<COUNTER_TYPE>(width * height, 0);
+    row_point_offset = vector<COUNTER_TYPE>(width * height, 0);
+    row_counter_offset_end = vector<COUNTER_TYPE>(height, 0);
+
+    row_counters_recorded = vector<bool>(height, false);
+
+    isInitRowCounters = true;
+}
+void BitMatrix::initColsCounters() {
+    if (isInitColsCounters == true) {
+        return;
+    }
+
+    cols_counters = vector<COUNTER_TYPE>(width * height, 0);
+    cols_counters_offset = vector<COUNTER_TYPE>(width * height, 0);
+    cols_point_offset = vector<COUNTER_TYPE>(width * height, 0);
+    cols_counter_offset_end = vector<COUNTER_TYPE>(width, 0);
+
+    cols_counters_recorded = vector<bool>(width, false);
+
+    isInitColsCounters = true;
+}
+
+BitMatrix::BitMatrix(int dimension, ErrorHandler& err_handler) {
+    init(dimension, dimension, err_handler);
+}
+
+BitMatrix::BitMatrix(int _width, int _height, ErrorHandler& err_handler) {
+    init(_width, _height, err_handler);
+}
+
+BitMatrix::BitMatrix(int _width, int _height, unsigned char* bitsPtr, ErrorHandler& err_handler) {
+    init(_width, _height, bitsPtr, err_handler);
+}
+// Copy bitMatrix
+void BitMatrix::copyOf(Ref<BitMatrix> _bits, ErrorHandler& err_handler) {
+    int _width = _bits->getWidth();
+    int _height = _bits->getHeight();
+    init(_width, _height, err_handler);
+
+    for (int y = 0; y < height; y++) {
+        bool* rowPtr = _bits->getRowBoolPtr(y);
+        setRowBool(y, rowPtr);
+    }
+}
+
+void BitMatrix::xxor(Ref<BitMatrix> _bits) {
+    if (width != _bits->getWidth() || height != _bits->getHeight()) {
+        return;
+    }
+
+    for (int y = 0; y < height && y < _bits->getHeight(); ++y) {
+        bool* rowPtrA = _bits->getRowBoolPtr(y);
+        bool* rowPtrB = getRowBoolPtr(y);
+
+        for (int x = 0; x < width && x < _bits->getWidth(); ++x) {
+            rowPtrB[x] = rowPtrB[x] ^ rowPtrA[x];
+        }
+        setRowBool(y, rowPtrB);
+    }
+}
+
+BitMatrix::~BitMatrix() {}
+
+void BitMatrix::flip(int x, int y) {
+    bits[rowOffsets[y] + x] = (bits[rowOffsets[y] + x] == (unsigned char)0);
+}
+
+void BitMatrix::flipAll() {
+    bool* matrixBits = (bool*)bits->data();
+    for (int i = 0; i < bits->size(); i++) {
+        matrixBits[i] = !matrixBits[i];
+    }
+}
+
+void BitMatrix::flipRegion(int left, int top, int _width, int _height, ErrorHandler& err_handler) {
+    if (top < 0 || left < 0) {
+        err_handler = IllegalArgumentErrorHandler("Left and top must be nonnegative");
+        return;
+    }
+    if (_height < 1 || _width < 1) {
+        err_handler = IllegalArgumentErrorHandler("Height and width must be at least 1");
+        return;
+    }
+    int right = left + _width;
+    int bottom = top + _height;
+    if (bottom > this->height || right > this->width) {
+        err_handler = IllegalArgumentErrorHandler("The region must fit inside the matrix");
+        return;
+    }
+
+    for (int y = top; y < bottom; y++) {
+        for (int x = left; x < right; x++) {
+            bits[rowOffsets[y] + x] ^= 1;
+        }
+    }
+}
+
+void BitMatrix::setRegion(int left, int top, int _width, int _height, ErrorHandler& err_handler) {
+    if (top < 0 || left < 0) {
+        err_handler = IllegalArgumentErrorHandler("Left and top must be nonnegative");
+        return;
+    }
+    if (_height < 1 || _width < 1) {
+        err_handler = IllegalArgumentErrorHandler("Height and width must be at least 1");
+        return;
+    }
+    int right = left + _width;
+    int bottom = top + _height;
+    if (bottom > this->height || right > this->width) {
+        err_handler = IllegalArgumentErrorHandler("The region must fit inside the matrix");
+        return;
+    }
+
+    for (int y = top; y < bottom; y++) {
+        for (int x = left; x < right; x++) {
+            bits[rowOffsets[y] + x] = true;
+            // bits[rowOffsets[y]+x] |= 0xFF;
+        }
+    }
+}
+
+Ref<BitArray> BitMatrix::getRow(int y, Ref<BitArray> row) {
+    if (row.empty() || row->getSize() < width) {
+        row = new BitArray(width);
+    }
+
+    // row->
+    unsigned char* src = bits.data() + rowOffsets[y];
+    row->setOneRow(src, width);
+
+    return row;
+}
+
+ArrayRef<int> BitMatrix::getTopLeftOnBit() const {
+    int bitsOffset = 0;
+    while (bitsOffset < bits->size() && bits[bitsOffset] == 0) {
+        bitsOffset++;
+    }
+    if (bitsOffset == bits->size()) {
+        return ArrayRef<int>();
+    }
+    int y = bitsOffset / width;
+    int x = bitsOffset % width;
+    ArrayRef<int> res(2);
+    res[0] = x;
+    res[1] = y;
+    return res;
+}
+
+ArrayRef<int> BitMatrix::getBottomRightOnBit() const {
+    int bitsOffset = bits->size() - 1;
+    while (bitsOffset >= 0 && bits[bitsOffset] == 0) {
+        bitsOffset--;
+    }
+    if (bitsOffset < 0) {
+        return ArrayRef<int>();
+    }
+
+    int y = bitsOffset / width;
+    int x = bitsOffset % width;
+    ArrayRef<int> res(2);
+    res[0] = x;
+    res[1] = y;
+    return res;
+}
+
+void BitMatrix::getRowBool(int y, bool* getrow) {
+    int offset = rowOffsets[y];
+    unsigned char* src = bits.data() + offset;
+    memcpy(getrow, src, rowBitsSize * sizeof(bool));
+}
+
+void BitMatrix::setRowBool(int y, bool* row) {
+    int offset = rowOffsets[y];
+    unsigned char* dst = bits.data() + offset;
+    memcpy(dst, row, rowBitsSize * sizeof(bool));
+
+    return;
+}
+
+bool* BitMatrix::getRowBoolPtr(int y) {
+    int offset = y * rowBitsSize;
+    unsigned char* src = bits.data() + offset;
+    return (bool*)src;
+}
+
+void BitMatrix::clear() {
+    int size = bits->size();
+
+    unsigned char* dst = bits->data();
+    memset(dst, 0, size * sizeof(unsigned char));
+}
+
+int BitMatrix::getWidth() const { return width; }
+
+int BitMatrix::getHeight() const { return height; }
+
+COUNTER_TYPE* BitMatrix::getRowPointInRecords(int y) {
+    if (!row_point_offset[y]) {
+        setRowRecords(y);
+    }
+    int offset = y * width;
+    COUNTER_TYPE* counters = &row_point_offset[0] + offset;
+    return (COUNTER_TYPE*)counters;
+}
+
+COUNTER_TYPE* BitMatrix::getRowRecords(int y) {
+    if (!row_counters_recorded[y]) {
+        setRowRecords(y);
+    }
+    int offset = y * width;
+    COUNTER_TYPE* counters = &row_counters[0] + offset;
+    return (COUNTER_TYPE*)counters;
+}
+
+COUNTER_TYPE* BitMatrix::getRowRecordsOffset(int y) {
+    if (!row_counters_recorded[y]) {
+        setRowRecords(y);
+    }
+    int offset = y * width;
+    COUNTER_TYPE* counters = &row_counters_offset[0] + offset;
+    return (COUNTER_TYPE*)counters;
+}
+
+bool BitMatrix::getRowFirstIsWhite(int y) {
+    bool is_white = !get(0, y);
+    return is_white;
+}
+
+bool BitMatrix::getRowLastIsWhite(int y) {
+    bool last_is_white = !get(width - 1, y);
+    return last_is_white;
+}
+
+COUNTER_TYPE BitMatrix::getRowCounterOffsetEnd(int y) {
+    if (!row_counters_recorded[y]) {
+        setRowRecords(y);
+    }
+    return row_counter_offset_end[y];
+}
+
+void BitMatrix::setRowRecords(int y) {
+    COUNTER_TYPE* cur_row_counters = &row_counters[0] + y * width;
+    COUNTER_TYPE* cur_row_counters_offset = &row_counters_offset[0] + y * width;
+    COUNTER_TYPE* cur_row_point_in_counters = &row_point_offset[0] + y * width;
+    int end = width;
+
+    bool* rowBit = getRowBoolPtr(y);
+    bool isWhite = !rowBit[0];
+    int counterPosition = 0;
+    int i = 0;
+    cur_row_counters_offset[0] = 0;
+    while (i < end) {
+        if (rowBit[i] ^ isWhite) {  // that is, exactly one is true
+            cur_row_counters[counterPosition]++;
+        } else {
+            counterPosition++;
+            if (counterPosition == end) {
+                break;
+            } else {
+                cur_row_counters[counterPosition] = 1;
+                isWhite = !isWhite;
+                cur_row_counters_offset[counterPosition] = i;
+            }
+        }
+        cur_row_point_in_counters[i] = counterPosition;
+        i++;
+    }
+
+    // use the last row__onedReaderData->counter_size to record
+    // _onedReaderData->counter_size
+    row_counter_offset_end[y] = counterPosition < end ? (counterPosition + 1) : end;
+
+    row_counters_recorded[y] = true;
+    return;
+}
+
+COUNTER_TYPE* BitMatrix::getColsPointInRecords(int x) {
+    if (!cols_point_offset[x]) {
+        setColsRecords(x);
+    }
+    int offset = x * height;
+    COUNTER_TYPE* counters = &cols_point_offset[0] + offset;
+    return (COUNTER_TYPE*)counters;
+}
+
+COUNTER_TYPE* BitMatrix::getColsRecords(int x) {
+    if (!cols_counters_recorded[x]) {
+        setColsRecords(x);
+    }
+    int offset = x * height;
+    COUNTER_TYPE* counters = &cols_counters[0] + offset;
+    return (COUNTER_TYPE*)counters;
+}
+
+COUNTER_TYPE* BitMatrix::getColsRecordsOffset(int x) {
+    if (!cols_counters_recorded[x]) {
+        setColsRecords(x);
+    }
+    int offset = x * height;
+    COUNTER_TYPE* counters = &cols_counters_offset[0] + offset;
+    return (COUNTER_TYPE*)counters;
+}
+
+COUNTER_TYPE BitMatrix::getColsCounterOffsetEnd(int x) {
+    if (!cols_counters_recorded[x]) {
+        setColsRecords(x);
+    }
+    return cols_counter_offset_end[x];
+}
+
+void BitMatrix::setColsRecords(int x) {
+    COUNTER_TYPE* cur_cols_counters = &cols_counters[0] + x * height;
+    COUNTER_TYPE* cur_cols_counters_offset = &cols_counters_offset[0] + x * height;
+    COUNTER_TYPE* cur_cols_point_in_counters = &cols_point_offset[0] + x * height;
+    int end = height;
+
+    bool* rowBit = getRowBoolPtr(0);
+    bool isWhite = !rowBit[0];
+    int counterPosition = 0;
+    int i = 0;
+    cur_cols_counters_offset[0] = 0;
+    while (i < end) {
+        if (rowBit[i] ^ isWhite) {  // that is, exactly one is true
+            cur_cols_counters[counterPosition]++;
+        } else {
+            counterPosition++;
+            if (counterPosition == end) {
+                break;
+            } else {
+                cur_cols_counters[counterPosition] = 1;
+                isWhite = !isWhite;
+                cur_cols_counters_offset[counterPosition] = i;
+            }
+        }
+        cur_cols_point_in_counters[i] = counterPosition;
+        i++;
+        rowBit += width;
+    }
+
+    cols_counter_offset_end[x] = counterPosition < end ? (counterPosition + 1) : end;
+
+    cols_counters_recorded[x] = true;
+    return;
+};
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitmatrix.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitmatrix.hpp
new file mode 100644
index 00000000..3cf7ec3c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitmatrix.hpp
@@ -0,0 +1,115 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_BITMATRIX_HPP__
+#define __ZXING_COMMON_BITMATRIX_HPP__
+
+#include "../errorhandler.hpp"
+#include "array.hpp"
+#include "bitarray.hpp"
+#include "counted.hpp"
+using namespace std;
+
+namespace zxing {
+
+class BitMatrix : public Counted {
+public:
+    static const int bitsPerWord = std::numeric_limits<unsigned int>::digits;
+
+private:
+    int width;
+    int height;
+    int rowBitsSize;
+
+    vector<COUNTER_TYPE> row_counters;
+    vector<COUNTER_TYPE> row_counters_offset;
+    vector<bool> row_counters_recorded;
+    vector<COUNTER_TYPE> row_counter_offset_end;
+    vector<COUNTER_TYPE> row_point_offset;
+
+    vector<COUNTER_TYPE> cols_counters;
+    vector<COUNTER_TYPE> cols_counters_offset;
+    vector<bool> cols_counters_recorded;
+    vector<COUNTER_TYPE> cols_counter_offset_end;
+    vector<COUNTER_TYPE> cols_point_offset;
+
+    ArrayRef<unsigned char> bits;
+    ArrayRef<int> rowOffsets;
+
+public:
+    BitMatrix(int _width, int _height, unsigned char* bitsPtr, ErrorHandler& err_handler);
+    BitMatrix(int dimension, ErrorHandler& err_handler);
+    BitMatrix(int _width, int _height, ErrorHandler& err_handler);
+
+    void copyOf(Ref<BitMatrix> _bits, ErrorHandler& err_handler);
+    void xxor(Ref<BitMatrix> _bits);
+
+    ~BitMatrix();
+
+    unsigned char get(int x, int y) const { return bits[width * y + x]; }
+
+    void set(int x, int y) { bits[rowOffsets[y] + x] = (unsigned char)1; }
+
+    void set(int x, int y, unsigned char value) { bits[rowOffsets[y] + x] = value; }
+
+    void swap(int srcX, int srcY, int dstX, int dstY) {
+        auto temp = bits[width * srcY + srcX];
+        bits[width * srcY + srcX] = bits[width * dstY + dstX];
+        bits[width * dstY + dstX] = temp;
+    }
+
+    void getRowBool(int y, bool* row);
+    bool* getRowBoolPtr(int y);
+    void setRowBool(int y, bool* row);
+    int getRowBitsSize() { return rowBitsSize; }
+    unsigned char* getPtr() { return bits->data(); }
+
+    void flip(int x, int y);
+    void flipAll();
+    void clear();
+    void setRegion(int left, int top, int _width, int _height, ErrorHandler& err_handler);
+    void flipRegion(int left, int top, int _width, int _height, ErrorHandler& err_handler);
+    Ref<BitArray> getRow(int y, Ref<BitArray> row);
+
+    int getWidth() const;
+    int getHeight() const;
+
+    ArrayRef<int> getTopLeftOnBit() const;
+    ArrayRef<int> getBottomRightOnBit() const;
+
+    bool isInitRowCounters;
+    void initRowCounters();
+    COUNTER_TYPE* getRowRecords(int y);
+    COUNTER_TYPE* getRowRecordsOffset(int y);
+    bool getRowFirstIsWhite(int y);
+    COUNTER_TYPE getRowCounterOffsetEnd(int y);
+    bool getRowLastIsWhite(int y);
+    COUNTER_TYPE* getRowPointInRecords(int y);
+
+    bool isInitColsCounters;
+    void initColsCounters();
+    COUNTER_TYPE* getColsRecords(int x);
+    COUNTER_TYPE* getColsRecordsOffset(int x);
+    COUNTER_TYPE* getColsPointInRecords(int x);
+    COUNTER_TYPE getColsCounterOffsetEnd(int x);
+
+private:
+    inline void init(int, int, ErrorHandler& err_handler);
+    inline void init(int _width, int _height, unsigned char* bitsPtr, ErrorHandler& err_handler);
+
+    void setRowRecords(int y);
+    void setColsRecords(int x);
+
+    BitMatrix(const BitMatrix&, ErrorHandler& err_handler);
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_BITMATRIX_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitsource.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitsource.cpp
new file mode 100644
index 00000000..52187e1d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitsource.cpp
@@ -0,0 +1,62 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "bitsource.hpp"
+#include <sstream>
+
+namespace zxing {
+
+int BitSource::readBits(int numBits, ErrorHandler& err_handler) {
+    if (numBits < 0 || numBits > 32 || numBits > available()) {
+        std::ostringstream oss;
+        oss << numBits;
+        err_handler = IllegalArgumentErrorHandler(oss.str().c_str());
+        return -1;
+    }
+
+    int result = 0;
+
+    // First, read remainder from current byte
+    if (bitOffset_ > 0) {
+        int bitsLeft = 8 - bitOffset_;
+        int toRead = numBits < bitsLeft ? numBits : bitsLeft;
+        int bitsToNotRead = bitsLeft - toRead;
+        int mask = (0xFF >> (8 - toRead)) << bitsToNotRead;
+        result = (bytes_[byteOffset_] & mask) >> bitsToNotRead;
+        numBits -= toRead;
+        bitOffset_ += toRead;
+        if (bitOffset_ == 8) {
+            bitOffset_ = 0;
+            byteOffset_++;
+        }
+    }
+
+    // Next read whole bytes
+    if (numBits > 0) {
+        while (numBits >= 8) {
+            result = (result << 8) | (bytes_[byteOffset_] & 0xFF);
+            byteOffset_++;
+            numBits -= 8;
+        }
+
+        // Finally read a partial byte
+        if (numBits > 0) {
+            int bitsToNotRead = 8 - numBits;
+            int mask = (0xFF >> bitsToNotRead) << bitsToNotRead;
+            result = (result << numBits) | ((bytes_[byteOffset_] & mask) >> bitsToNotRead);
+            bitOffset_ += numBits;
+        }
+    }
+
+    return result;
+}
+
+int BitSource::available() { return 8 * (bytes_->size() - byteOffset_) - bitOffset_; }
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitsource.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitsource.hpp
new file mode 100644
index 00000000..797c2b5c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bitsource.hpp
@@ -0,0 +1,57 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_BITSOURCE_HPP__
+#define __ZXING_COMMON_BITSOURCE_HPP__
+
+#include "../errorhandler.hpp"
+#include "array.hpp"
+
+namespace zxing {
+/**
+ * <p>This provides an easy abstraction to read bits at a time from a sequence
+ * of bytes, where the number of bits read is not often a multiple of 8.</p>
+ *
+ * <p>This class is not thread-safe.</p>
+ *
+ * @author srowen@google.com (Sean Owen)
+ * @author christian.brunschen@gmail.com (Christian Brunschen)
+ */
+class BitSource : public Counted {
+    typedef char byte;
+
+private:
+    ArrayRef<byte> bytes_;
+    int byteOffset_;
+    int bitOffset_;
+
+public:
+    /**
+     * @param bytes bytes from which this will read bits. Bits will be read from
+     * the first byte first. Bits are read within a byte from most-significant
+     * to least-significant bit.
+     */
+    explicit BitSource(ArrayRef<byte> &bytes) : bytes_(bytes), byteOffset_(0), bitOffset_(0) {}
+
+    int getBitOffset() { return bitOffset_; }
+
+    int getByteOffset() { return byteOffset_; }
+
+    int readBits(int numBits, ErrorHandler &err_handler);
+
+    /**
+     * @return number of bits that can be read successfully
+     */
+    int available();
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_BITSOURCE_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bytematrix.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bytematrix.cpp
new file mode 100644
index 00000000..61cf2517
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bytematrix.cpp
@@ -0,0 +1,50 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "../../precomp.hpp"
+#include "bytematrix.hpp"
+
+using zxing::ArrayRef;
+using zxing::ByteMatrix;
+using zxing::ErrorHandler;
+using zxing::Ref;
+
+void ByteMatrix::init(int _width, int _height) {
+    if (_width < 1 || _height < 1) {
+        return;
+    }
+    this->width = _width;
+    this->height = _height;
+    bytes = new unsigned char[width * height];
+    row_offsets = new int[height];
+    row_offsets[0] = 0;
+    for (int i = 1; i < height; i++) {
+        row_offsets[i] = row_offsets[i - 1] + width;
+    }
+}
+
+ByteMatrix::ByteMatrix(int dimension) { init(dimension, dimension); }
+
+ByteMatrix::ByteMatrix(int _width, int _height) { init(_width, _height); }
+
+ByteMatrix::ByteMatrix(int _width, int _height, ArrayRef<char> source) {
+    init(_width, _height);
+    int size = _width * _height;
+    memcpy(&bytes[0], &source[0], size);
+}
+
+ByteMatrix::~ByteMatrix() {
+    if (bytes) delete[] bytes;
+    if (row_offsets) delete[] row_offsets;
+}
+
+unsigned char* ByteMatrix::getByteRow(int y, ErrorHandler& err_handler) {
+    if (y < 0 || y >= getHeight()) {
+        err_handler = IllegalArgumentErrorHandler("Requested row is outside the image.");
+        return NULL;
+    }
+    return &bytes[row_offsets[y]];
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bytematrix.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bytematrix.hpp
new file mode 100644
index 00000000..c3ee35ea
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/bytematrix.hpp
@@ -0,0 +1,58 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __ZXING_COMMON_BYTEMATRIX_HPP__
+#define __ZXING_COMMON_BYTEMATRIX_HPP__
+
+#include "../errorhandler.hpp"
+#include "array.hpp"
+#include "bitarray.hpp"
+#include "counted.hpp"
+
+namespace zxing {
+
+class ByteMatrix : public Counted {
+public:
+    explicit ByteMatrix(int dimension);
+    ByteMatrix(int _width, int _height);
+    ByteMatrix(int _width, int _height, ArrayRef<char> source);
+    ~ByteMatrix();
+
+    char get(int x, int y) const {
+        int offset = row_offsets[y] + x;
+        return bytes[offset];
+    }
+
+    void set(int x, int y, char char_value) {
+        int offset = row_offsets[y] + x;
+        bytes[offset] = char_value & 0XFF;
+    }
+
+    unsigned char* getByteRow(int y, ErrorHandler& err_handler);
+
+    int getWidth() const { return width; }
+    int getHeight() const { return height; }
+
+    unsigned char* bytes;
+
+private:
+    int width;
+    int height;
+
+    // ArrayRef<char> bytes;
+    // ArrayRef<int> row_offsets;
+    int* row_offsets;
+
+private:
+    inline void init(int, int);
+    ByteMatrix(const ByteMatrix&);
+    ByteMatrix& operator=(const ByteMatrix&);
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_BYTEMATRIX_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/characterseteci.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/characterseteci.cpp
new file mode 100644
index 00000000..acef2044
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/characterseteci.cpp
@@ -0,0 +1,111 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "characterseteci.hpp"
+using zxing::common::CharacterSetECI;
+
+// Fix memory leak
+// https://github.com/ukeller/zxing-cpp/commit/c632ffe47ca7342f894ae533263be249cbdfd37e
+// std::map<int, CharacterSetECI*> CharacterSetECI::VALUE_TO_ECI;
+// std::map<std::string, CharacterSetECI*> CharacterSetECI::NAME_TO_ECI;
+std::map<int, zxing::Ref<CharacterSetECI> > CharacterSetECI::VALUE_TO_ECI;
+std::map<std::string, zxing::Ref<CharacterSetECI> > CharacterSetECI::NAME_TO_ECI;
+
+const bool CharacterSetECI::inited = CharacterSetECI::init_tables();
+
+#define ADD_CHARACTER_SET(VALUES, STRINGS)           \
+    {                                                \
+        static int values[] = {VALUES, -1};          \
+        static char const* strings[] = {STRINGS, 0}; \
+        addCharacterSet(values, strings);            \
+    }
+
+#define XC ,
+
+bool CharacterSetECI::init_tables() {
+    ADD_CHARACTER_SET(0 XC 2, "Cp437");
+    ADD_CHARACTER_SET(1 XC 3, "ISO8859_1" XC "ISO-8859-1");
+    ADD_CHARACTER_SET(4, "ISO8859_2" XC "ISO-8859-2");
+    ADD_CHARACTER_SET(5, "ISO8859_3" XC "ISO-8859-3");
+    ADD_CHARACTER_SET(6, "ISO8859_4" XC "ISO-8859-4");
+    ADD_CHARACTER_SET(7, "ISO8859_5" XC "ISO-8859-5");
+    ADD_CHARACTER_SET(8, "ISO8859_6" XC "ISO-8859-6");
+    ADD_CHARACTER_SET(9, "ISO8859_7" XC "ISO-8859-7");
+    ADD_CHARACTER_SET(10, "ISO8859_8" XC "ISO-8859-8");
+    ADD_CHARACTER_SET(11, "ISO8859_9" XC "ISO-8859-9");
+    ADD_CHARACTER_SET(12, "ISO8859_10" XC "ISO-8859-10");
+    ADD_CHARACTER_SET(13, "ISO8859_11" XC "ISO-8859-11");
+    ADD_CHARACTER_SET(15, "ISO8859_13" XC "ISO-8859-13");
+    ADD_CHARACTER_SET(16, "ISO8859_14" XC "ISO-8859-14");
+    ADD_CHARACTER_SET(17, "ISO8859_15" XC "ISO-8859-15");
+    ADD_CHARACTER_SET(18, "ISO8859_16" XC "ISO-8859-16");
+    ADD_CHARACTER_SET(20, "SJIS" XC "Shift_JIS");
+    ADD_CHARACTER_SET(21, "Cp1250" XC "windows-1250");
+    ADD_CHARACTER_SET(22, "Cp1251" XC "windows-1251");
+    ADD_CHARACTER_SET(23, "Cp1252" XC "windows-1252");
+    ADD_CHARACTER_SET(24, "Cp1256" XC "windows-1256");
+    ADD_CHARACTER_SET(25, "UnicodeBigUnmarked" XC "UTF-16BE" XC "UnicodeBig");
+    ADD_CHARACTER_SET(26, "UTF8" XC "UTF-8");
+    ADD_CHARACTER_SET(27 XC 170, "ASCII" XC "US-ASCII");
+    ADD_CHARACTER_SET(28, "Big5");
+    ADD_CHARACTER_SET(29, "GB18030" XC "GB2312" XC "EUC_CN" XC "GBK");
+    ADD_CHARACTER_SET(30, "EUC_KR" XC "EUC-KR");
+    return true;
+}
+
+#undef XC
+
+CharacterSetECI::CharacterSetECI(int const* values, char const* const* names)
+    : values_(values), names_(names) {
+    zxing::Ref<CharacterSetECI> this_ref(this);
+
+    for (int const* p_values = values_; *p_values != -1; p_values++) {
+        // VALUE_TO_ECI[*values] = this;
+        VALUE_TO_ECI[*p_values] = this_ref;
+    }
+    for (char const* const* p_names = names_; *p_names; p_names++) {
+        // NAME_TO_ECI[string(*names)] = this;
+        NAME_TO_ECI[string(*p_names)] = this_ref;
+    }
+}
+
+char const* CharacterSetECI::name() const { return names_[0]; }
+
+int CharacterSetECI::getValue() const { return values_[0]; }
+
+void CharacterSetECI::addCharacterSet(int const* values, char const* const* names) {
+    new CharacterSetECI(values, names);
+}
+
+CharacterSetECI* CharacterSetECI::getCharacterSetECIByValueFind(int value) {
+    if (value < 0 || value >= 900) {
+        return zxing::Ref<CharacterSetECI>(0);
+    }
+
+    std::map<int, zxing::Ref<CharacterSetECI> >::iterator iter;
+    iter = VALUE_TO_ECI.find(value);
+
+    if (iter != VALUE_TO_ECI.end()) {
+        return iter->second;
+    } else {
+        return zxing::Ref<CharacterSetECI>(0);
+    }
+}
+
+CharacterSetECI* CharacterSetECI::getCharacterSetECIByName(string const& name) {
+    std::map<std::string, zxing::Ref<CharacterSetECI> >::iterator iter;
+    iter = NAME_TO_ECI.find(name);
+
+    if (iter != NAME_TO_ECI.end()) {
+        return iter->second;
+    } else {
+        return zxing::Ref<CharacterSetECI>(0);
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/characterseteci.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/characterseteci.hpp
new file mode 100644
index 00000000..9b44f14d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/characterseteci.hpp
@@ -0,0 +1,46 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_CHARACTERSETECI_HPP__
+#define __ZXING_COMMON_CHARACTERSETECI_HPP__
+
+#include <map>
+#include "../decodehints.hpp"
+#include "counted.hpp"
+
+namespace zxing {
+namespace common {
+
+class CharacterSetECI : public Counted {
+private:
+    static std::map<int, zxing::Ref<CharacterSetECI> > VALUE_TO_ECI;
+    static std::map<std::string, zxing::Ref<CharacterSetECI> > NAME_TO_ECI;
+    static const bool inited;
+    static bool init_tables();
+
+    int const* const values_;
+    char const* const* const names_;
+
+    CharacterSetECI(int const* values, char const* const* names);
+
+    static void addCharacterSet(int const* value, char const* const* encodingNames);
+
+public:
+    char const* name() const;
+    int getValue() const;
+
+    static CharacterSetECI* getCharacterSetECIByValueFind(int value);
+    static CharacterSetECI* getCharacterSetECIByName(std::string const& name);
+};
+
+}  // namespace common
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_CHARACTERSETECI_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/counted.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/counted.hpp
new file mode 100644
index 00000000..d40d62a3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/counted.hpp
@@ -0,0 +1,110 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_COUNTED_HPP__
+#define __ZXING_COMMON_COUNTED_HPP__
+
+#include <cstddef>
+#include <algorithm>
+namespace zxing {
+
+/* base class for reference-counted objects */
+class Counted {
+private:
+    unsigned int count_;
+
+public:
+    Counted() : count_(0) {}
+    virtual ~Counted() {}
+    Counted* retain() {
+        count_++;
+        return this;
+    }
+    void release() {
+        count_--;
+        if (count_ == 0) {
+            count_ = 0xDEADF001;
+            delete this;
+        }
+    }
+
+    /* return the current count for denugging purposes or similar */
+    int count() const { return count_; }
+};
+
+/* counting reference to reference-counted objects */
+template <typename T>
+class Ref {
+private:
+public:
+    T* object_;
+    explicit Ref(T* o = 0) : object_(0) { reset(o); }
+    Ref(const Ref& other) : object_(0) { reset(other.object_); }
+
+    template <class Y>
+    Ref(const Ref<Y>& other) : object_(0) {
+        reset(other.object_);
+    }
+
+    ~Ref() {
+        if (object_) {
+            object_->release();
+        }
+    }
+
+    void reset(T* o) {
+        if (o) {
+            o->retain();
+        }
+        if (object_ != 0) {
+            object_->release();
+        }
+        object_ = o;
+    }
+    Ref& operator=(const Ref& other) {
+        reset(other.object_);
+        return *this;
+    }
+    template <class Y>
+    Ref& operator=(const Ref<Y>& other) {
+        reset(other.object_);
+        return *this;
+    }
+    Ref& operator=(T* o) {
+        reset(o);
+        return *this;
+    }
+    template <class Y>
+    Ref& operator=(Y* o) {
+        reset(o);
+        return *this;
+    }
+
+    T& operator*() { return *object_; }
+    T* operator->() const { return object_; }
+    operator T*() const { return object_; }
+
+    bool operator==(const T* that) { return object_ == that; }
+    bool operator==(const Ref& other) const {
+        return object_ == other.object_ || *object_ == *(other.object_);
+    }
+    template <class Y>
+    bool operator==(const Ref<Y>& other) const {
+        return object_ == other.object_ || *object_ == *(other.object_);
+    }
+
+    bool operator!=(const T* that) { return !(*this == that); }
+
+    bool empty() const { return object_ == 0; }
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_COUNTED_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/decoder_result.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/decoder_result.cpp
new file mode 100644
index 00000000..3de6656f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/decoder_result.cpp
@@ -0,0 +1,65 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "decoder_result.hpp"
+
+using zxing::DecoderResult;
+using zxing::Ref;
+using zxing::ArrayRef;
+using zxing::String;
+DecoderResult::DecoderResult(ArrayRef<char> rawBytes, Ref<String> text,
+                             ArrayRef<ArrayRef<char> >& byteSegments, string const& ecLevel)
+    : rawBytes_(rawBytes), text_(text), byteSegments_(byteSegments), ecLevel_(ecLevel) {
+    outputCharset_ = "UTF-8";
+    otherClassName = "";
+    qrcodeVersion_ = -1;
+}
+
+DecoderResult::DecoderResult(ArrayRef<char> rawBytes, Ref<String> text,
+                             ArrayRef<ArrayRef<char> >& byteSegments, string const& ecLevel,
+                             string outputCharset)
+    : rawBytes_(rawBytes),
+      text_(text),
+      byteSegments_(byteSegments),
+      ecLevel_(ecLevel),
+      outputCharset_(outputCharset) {
+    otherClassName = "";
+    qrcodeVersion_ = -1;
+}
+
+DecoderResult::DecoderResult(ArrayRef<char> rawBytes, Ref<String> text,
+                             ArrayRef<ArrayRef<char> >& byteSegments, string const& ecLevel,
+                             string outputCharset, int qrcodeVersion, string& charsetMode)
+    : rawBytes_(rawBytes),
+      text_(text),
+      byteSegments_(byteSegments),
+      ecLevel_(ecLevel),
+      outputCharset_(outputCharset),
+      qrcodeVersion_(qrcodeVersion),
+      charsetMode_(charsetMode) {
+    otherClassName = "";
+}
+
+DecoderResult::DecoderResult(ArrayRef<char> rawBytes, Ref<String> text)
+    : rawBytes_(rawBytes), text_(text) {
+    outputCharset_ = "UTF-8";
+    otherClassName = "";
+}
+
+DecoderResult::DecoderResult(ArrayRef<char> rawBytes, Ref<String> text, std::string outputCharset)
+    : rawBytes_(rawBytes), text_(text), outputCharset_(outputCharset) {
+    otherClassName = "";
+}
+
+ArrayRef<char> DecoderResult::getRawBytes() { return rawBytes_; }
+
+Ref<String> DecoderResult::getText() { return text_; }
+
+string DecoderResult::getCharset() { return outputCharset_; }
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/decoder_result.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/decoder_result.hpp
new file mode 100644
index 00000000..7ffd002c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/decoder_result.hpp
@@ -0,0 +1,77 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_DECODER_RESULT_HPP__
+#define __ZXING_COMMON_DECODER_RESULT_HPP__
+
+#include "../qrcode/decoder/qrcode_decoder_metadata.hpp"
+#include "array.hpp"
+#include "counted.hpp"
+#include "str.hpp"
+
+namespace zxing {
+
+class DecoderResult : public Counted {
+private:
+    ArrayRef<char> rawBytes_;
+    Ref<String> text_;
+    ArrayRef<ArrayRef<char> > byteSegments_;
+    std::string ecLevel_;
+    std::string outputCharset_;
+    int qrcodeVersion_;
+    std::string charsetMode_;
+
+    Ref<qrcode::QRCodeDecoderMetaData> other_;
+    string otherClassName;
+
+public:
+    DecoderResult(ArrayRef<char> rawBytes, Ref<String> text,
+                  ArrayRef<ArrayRef<char> >& byteSegments, std::string const& ecLevel);
+
+    DecoderResult(ArrayRef<char> rawBytes, Ref<String> text,
+                  ArrayRef<ArrayRef<char> >& byteSegments, std::string const& ecLevel,
+                  std::string outputCharset);
+
+    DecoderResult(ArrayRef<char> rawBytes, Ref<String> text,
+                  ArrayRef<ArrayRef<char> >& byteSegments, std::string const& ecLevel,
+                  std::string outputCharset, int qrcodeVersion, std::string& charsetMode);
+
+    DecoderResult(ArrayRef<char> rawBytes, Ref<String> text);
+
+    DecoderResult(ArrayRef<char> rawBytes, Ref<String> text, std::string outputCharset);
+
+    ArrayRef<char> getRawBytes();
+    Ref<String> getText();
+    std::string getCharset();
+
+    void setOther(Ref<qrcode::QRCodeDecoderMetaData> other) {
+        other_ = other;
+        otherClassName = "QRCodeDecoderMetaData";
+    };
+
+    Ref<qrcode::QRCodeDecoderMetaData> getOther() {
+        // className = otherClassName;
+        return other_;
+    };
+
+    string getOtherClassName() { return otherClassName; };
+
+    int getQRCodeVersion() const { return qrcodeVersion_; };
+
+    void setText(Ref<String> text) { text_ = text; };
+
+    string getEcLevel() { return ecLevel_; }
+
+    string getCharsetMode() { return charsetMode_; }
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_DECODER_RESULT_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/detector_result.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/detector_result.cpp
new file mode 100644
index 00000000..2e50a5dc
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/detector_result.cpp
@@ -0,0 +1,27 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "detector_result.hpp"
+
+namespace zxing {
+
+DetectorResult::DetectorResult(Ref<BitMatrix> bits, ArrayRef<Ref<ResultPoint> > points,
+                               int dimension, float modulesize)
+    : bits_(bits), points_(points), dimension_(dimension), modulesize_(modulesize) {}
+
+void DetectorResult::SetGray(Ref<ByteMatrix> gray) { gray_ = gray; }
+
+Ref<BitMatrix> DetectorResult::getBits() { return bits_; }
+
+Ref<ByteMatrix> DetectorResult::getGray() { return gray_; }
+
+ArrayRef<Ref<ResultPoint> > DetectorResult::getPoints() { return points_; }
+
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/detector_result.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/detector_result.hpp
new file mode 100644
index 00000000..c48e9efe
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/detector_result.hpp
@@ -0,0 +1,42 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_DETECTOR_RESULT_HPP__
+#define __ZXING_COMMON_DETECTOR_RESULT_HPP__
+
+#include "../resultpoint.hpp"
+#include "array.hpp"
+#include "bitmatrix.hpp"
+#include "bytematrix.hpp"
+#include "counted.hpp"
+
+namespace zxing {
+
+class DetectorResult : public Counted {
+private:
+    Ref<BitMatrix> bits_;
+    Ref<ByteMatrix> gray_;
+    ArrayRef<Ref<ResultPoint> > points_;
+
+public:
+    DetectorResult(Ref<BitMatrix> bits, ArrayRef<Ref<ResultPoint> > points, int dimension = 0,
+                   float modulesize = 0);
+    DetectorResult(Ref<ByteMatrix> gray, ArrayRef<Ref<ResultPoint> > points, int dimension = 0,
+                   float modulesize = 0);
+    Ref<BitMatrix> getBits();
+    Ref<ByteMatrix> getGray();
+    void SetGray(Ref<ByteMatrix> gray);
+    ArrayRef<Ref<ResultPoint> > getPoints();
+    int dimension_;
+    float modulesize_;
+};
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_DETECTOR_RESULT_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_luminance_source.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_luminance_source.cpp
new file mode 100644
index 00000000..cf35ccbc
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_luminance_source.cpp
@@ -0,0 +1,77 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "greyscale_luminance_source.hpp"
+#include "bytematrix.hpp"
+#include "greyscale_rotated_luminance_source.hpp"
+using zxing::ArrayRef;
+using zxing::ByteMatrix;
+using zxing::ErrorHandler;
+using zxing::GreyscaleLuminanceSource;
+using zxing::LuminanceSource;
+using zxing::Ref;
+
+GreyscaleLuminanceSource::GreyscaleLuminanceSource(ArrayRef<char> greyData, int dataWidth,
+                                                   int dataHeight, int left, int top, int width,
+                                                   int height, ErrorHandler& err_handler)
+    : Super(width, height),
+      greyData_(greyData),
+      dataWidth_(dataWidth),
+      dataHeight_(dataHeight),
+      left_(left),
+      top_(top) {
+    if (left + width > dataWidth || top + height > dataHeight || top < 0 || left < 0) {
+        err_handler = IllegalArgumentErrorHandler("Crop rectangle does not fit within image data.");
+    }
+}
+
+ArrayRef<char> GreyscaleLuminanceSource::getRow(int y, ArrayRef<char> row,
+                                                ErrorHandler& err_handler) const {
+    if (y < 0 || y >= this->getHeight()) {
+        err_handler = IllegalArgumentErrorHandler("Requested row is outside the image.");
+        return ArrayRef<char>();
+    }
+    int width = getWidth();
+    if (!row || row->size() < width) {
+        ArrayRef<char> temp(width);
+        row = temp;
+    }
+    int offset = (y + top_) * dataWidth_ + left_;
+    memcpy(&row[0], &greyData_[offset], width);
+    return row;
+}
+
+ArrayRef<char> GreyscaleLuminanceSource::getMatrix() const {
+    int size = getWidth() * getHeight();
+    ArrayRef<char> result(size);
+    if (left_ == 0 && top_ == 0 && dataWidth_ == getWidth() && dataHeight_ == getHeight()) {
+        memcpy(&result[0], &greyData_[0], size);
+    } else {
+        for (int row = 0; row < getHeight(); row++) {
+            memcpy(&result[row * getWidth()], &greyData_[(top_ + row) * dataWidth_ + left_],
+                   getWidth());
+        }
+    }
+    return result;
+}
+
+Ref<LuminanceSource> GreyscaleLuminanceSource::rotateCounterClockwise(
+    ErrorHandler& err_handler) const {
+    // Intentionally flip the left, top, width, and height arguments as
+    // needed. dataWidth and dataHeight are always kept unrotated.
+    Ref<LuminanceSource> result(new GreyscaleRotatedLuminanceSource(
+        greyData_, dataWidth_, dataHeight_, top_, left_, getHeight(), getWidth(), err_handler));
+    if (err_handler.ErrCode()) return Ref<LuminanceSource>();
+    return result;
+}
+
+Ref<ByteMatrix> GreyscaleLuminanceSource::getByteMatrix() const {
+    return Ref<ByteMatrix>(new ByteMatrix(getWidth(), getHeight(), getMatrix()));
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_luminance_source.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_luminance_source.hpp
new file mode 100644
index 00000000..438b14e3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_luminance_source.hpp
@@ -0,0 +1,44 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_GREYSCALE_LUMINANCE_SOURCE_HPP__
+#define __ZXING_COMMON_GREYSCALE_LUMINANCE_SOURCE_HPP__
+
+#include "../errorhandler.hpp"
+#include "../luminance_source.hpp"
+#include "bytematrix.hpp"
+
+namespace zxing {
+
+class GreyscaleLuminanceSource : public LuminanceSource {
+private:
+    typedef LuminanceSource Super;
+    ArrayRef<char> greyData_;
+    const int dataWidth_;
+    const int dataHeight_;
+    const int left_;
+    const int top_;
+
+public:
+    GreyscaleLuminanceSource(ArrayRef<char> greyData, int dataWidth, int dataHeight, int left,
+                             int top, int width, int height, ErrorHandler& err_handler);
+
+    ArrayRef<char> getRow(int y, ArrayRef<char> row, ErrorHandler& err_handler) const override;
+    ArrayRef<char> getMatrix() const override;
+    Ref<ByteMatrix> getByteMatrix() const override;
+
+    bool isRotateSupported() const override { return true; }
+
+    Ref<LuminanceSource> rotateCounterClockwise(ErrorHandler& err_handler) const override;
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_GREYSCALE_LUMINANCE_SOURCE_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_rotated_luminance_source.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_rotated_luminance_source.cpp
new file mode 100644
index 00000000..4f9e6261
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_rotated_luminance_source.cpp
@@ -0,0 +1,67 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "greyscale_rotated_luminance_source.hpp"
+#include "bytematrix.hpp"
+using zxing::ArrayRef;
+using zxing::ByteMatrix;
+using zxing::ErrorHandler;
+using zxing::GreyscaleRotatedLuminanceSource;
+using zxing::Ref;
+
+// Note that dataWidth and dataHeight are not reversed, as we need to
+// be able to traverse the greyData correctly, which does not get
+// rotated.
+GreyscaleRotatedLuminanceSource::GreyscaleRotatedLuminanceSource(ArrayRef<char> greyData,
+                                                                 int dataWidth, int dataHeight,
+                                                                 int left, int top, int _width,
+                                                                 int _height,
+                                                                 ErrorHandler& err_handler)
+    : Super(_width, _height), greyData_(greyData), dataWidth_(dataWidth), left_(left), top_(top) {
+    // Intentionally comparing to the opposite dimension since we're rotated.
+    if (left + _width > dataHeight || top + _height > dataWidth) {
+        err_handler = IllegalArgumentErrorHandler("Crop rectangle does not fit within image data.");
+    }
+}
+
+// The API asks for rows, but we're rotated, so we return columns.
+ArrayRef<char> GreyscaleRotatedLuminanceSource::getRow(int y, ArrayRef<char> row,
+                                                       ErrorHandler& err_handler) const {
+    if (y < 0 || y >= getHeight()) {
+        err_handler = IllegalArgumentErrorHandler("Requested row is outside the image.");
+        return ArrayRef<char>();
+    }
+    if (!row || row->size() < getWidth()) {
+        row = ArrayRef<char>(getWidth());
+    }
+    int offset = (left_ * dataWidth_) + (dataWidth_ - 1 - (y + top_));
+    for (int x = 0; x < getWidth(); x++) {
+        row[x] = greyData_[offset];
+        offset += dataWidth_;
+    }
+    return row;
+}
+
+ArrayRef<char> GreyscaleRotatedLuminanceSource::getMatrix() const {
+    ArrayRef<char> result(getWidth() * getHeight());
+    for (int y = 0; y < getHeight(); y++) {
+        char* row = &result[y * getWidth()];
+        int offset = (left_ * dataWidth_) + (dataWidth_ - 1 - (y + top_));
+        for (int x = 0; x < getWidth(); x++) {
+            row[x] = greyData_[offset];
+            offset += dataWidth_;
+        }
+    }
+    return result;
+}
+
+Ref<ByteMatrix> GreyscaleRotatedLuminanceSource::getByteMatrix() const {
+    return Ref<ByteMatrix>(new ByteMatrix(getWidth(), getHeight(), getMatrix()));
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_rotated_luminance_source.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_rotated_luminance_source.hpp
new file mode 100644
index 00000000..2e1c8f67
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/greyscale_rotated_luminance_source.hpp
@@ -0,0 +1,39 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_GREYSCALE_ROTATED_LUMINANCE_SOURCE_HPP__
+#define __ZXING_COMMON_GREYSCALE_ROTATED_LUMINANCE_SOURCE_HPP__
+
+#include "../errorhandler.hpp"
+#include "../luminance_source.hpp"
+#include "bytematrix.hpp"
+namespace zxing {
+
+class GreyscaleRotatedLuminanceSource : public LuminanceSource {
+private:
+    typedef LuminanceSource Super;
+    ArrayRef<char> greyData_;
+    const int dataWidth_;
+    const int left_;
+    const int top_;
+
+public:
+    GreyscaleRotatedLuminanceSource(ArrayRef<char> greyData, int dataWidth, int dataHeight,
+                                    int left, int top, int _width, int _height,
+                                    ErrorHandler& err_handler);
+
+    ArrayRef<char> getRow(int y, ArrayRef<char> row, ErrorHandler& err_handler) const override;
+    ArrayRef<char> getMatrix() const override;
+    Ref<ByteMatrix> getByteMatrix() const override;
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_GREYSCALE_ROTATED_LUMINANCE_SOURCE_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/grid_sampler.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/grid_sampler.cpp
new file mode 100644
index 00000000..52564f2f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/grid_sampler.cpp
@@ -0,0 +1,119 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "grid_sampler.hpp"
+#include "perspective_transform.hpp"
+#include <sstream>
+
+namespace zxing {
+
+GridSampler GridSampler::gridSampler;
+
+GridSampler::GridSampler() {}
+
+// Samples an image for a rectangular matrix of bits of the given dimension.
+Ref<BitMatrix> GridSampler::sampleGrid(Ref<BitMatrix> image, int dimension,
+                                       Ref<PerspectiveTransform> transform,
+                                       ErrorHandler &err_handler) {
+    Ref<BitMatrix> bits(new BitMatrix(dimension, err_handler));
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+
+    vector<float> points(dimension << 1, 0.0f);
+
+    int outlier = 0;
+    int maxOutlier = dimension * dimension * 3 / 10 - 1;
+
+    for (int y = 0; y < dimension; y++) {
+        int max = points.size();
+        float yValue = (float)y + 0.5f;
+        for (int x = 0; x < max; x += 2) {
+            points[x] = (float)(x >> 1) + 0.5f;
+            points[x + 1] = yValue;
+        }
+        transform->transformPoints(points);
+        // Quick check to see if points transformed to something inside the
+        // image; sufficient to check the endpoings
+        outlier += checkAndNudgePoints(image->getWidth(), image->getHeight(), points, err_handler);
+        if (err_handler.ErrCode()) return Ref<BitMatrix>();
+
+        if (outlier >= maxOutlier) {
+            ostringstream s;
+            s << "Over 30% points out of bounds.";
+            err_handler = ReaderErrorHandler(s.str().c_str());
+            return Ref<BitMatrix>();
+        }
+
+        for (int x = 0; x < max; x += 2) {
+            if (image->get((int)points[x], (int)points[x + 1])) {
+                // Black (-ish) pixel
+                bits->set(x >> 1, y);
+            }
+        }
+    }
+    return bits;
+}
+
+int GridSampler::checkAndNudgePoints(int width, int height, vector<float> &points,
+                                     ErrorHandler &err_handler) {
+    // Modified to support stlport
+    float *pts = NULL;
+
+    if (points.size() > 0) {
+        pts = &points[0];
+    } else {
+        err_handler = ReaderErrorHandler("checkAndNudgePoints:: no points!");
+        return -1;
+    }
+
+    int size = (int)points.size() / 2;
+
+    // The Java code assumes that if the start and end points are in bounds, the
+    // rest will also be. However, in some unusual cases points in the middle
+    // may also be out of bounds. Since we can't rely on an
+    // ArrayIndexOutOfBoundsException like Java, we check every point.
+
+    int outCount = 0;
+    // int maxError = (int)(size/2/3 - 1);
+
+    float maxborder = width / size * 3;
+
+    for (size_t offset = 0; offset < points.size(); offset += 2) {
+        int x = (int)pts[offset];
+        int y = (int)pts[offset + 1];
+        // if((int)offset==0)
+        //	cout<<"checkAndNudgePoints "<<(int)offset<<": ("<<x<<",
+        //"<<y<<")"<<endl;
+
+        if (x < -1 || x > width || y < -1 || y > height) {
+            outCount++;
+            if (x > width + maxborder || y > height + maxborder || x < -maxborder ||
+                y < -maxborder) {
+                err_handler = ReaderErrorHandler("checkAndNudgePoints::Out of bounds!");
+                return -1;
+            }
+        }
+
+        if (x <= -1) {
+            points[offset] = 0.0f;
+        } else if (x >= width) {
+            points[offset] = float(width - 1);
+        }
+        if (y <= -1) {
+            points[offset + 1] = 0.0f;
+        } else if (y >= height) {
+            points[offset + 1] = float(height - 1);
+        }
+    }
+
+    return outCount;
+}
+
+GridSampler &GridSampler::getInstance() { return gridSampler; }
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/grid_sampler.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/grid_sampler.hpp
new file mode 100644
index 00000000..c697d1c0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/grid_sampler.hpp
@@ -0,0 +1,34 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_GRID_SAMPLER_HPP__
+#define __ZXING_COMMON_GRID_SAMPLER_HPP__
+
+#include "bitmatrix.hpp"
+#include "bytematrix.hpp"
+#include "counted.hpp"
+#include "perspective_transform.hpp"
+
+namespace zxing {
+class GridSampler {
+private:
+    static GridSampler gridSampler;
+    GridSampler();
+
+public:
+    Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image, int dimension,
+                              Ref<PerspectiveTransform> transform, ErrorHandler &err_handler);
+    static int checkAndNudgePoints(int width, int height, vector<float> &points,
+                                   ErrorHandler &err_handler);
+    static GridSampler &getInstance();
+};
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_GRID_SAMPLER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/imagecut.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/imagecut.cpp
new file mode 100644
index 00000000..86fdf7f3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/imagecut.cpp
@@ -0,0 +1,66 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "../../precomp.hpp"
+#include "imagecut.hpp"
+
+
+namespace zxing {
+
+ImageCut::ImageCut() {}
+
+ImageCut::~ImageCut() {}
+
+int ImageCut::Cut(uint8_t* poImageData, int iWidth, int iHeight, int iTopLeftX, int iTopLeftY,
+                  int iBottomRightX, int iBottomRightY, ImageCutResult& result) {
+    if (iTopLeftX < 0 || iTopLeftX > iBottomRightX || iBottomRightX >= iWidth) return -1;
+    if (iTopLeftY < 0 || iTopLeftY > iBottomRightY || iBottomRightY >= iHeight) return -1;
+    int iNewWidth = iBottomRightX - iTopLeftX + 1;
+    int iNewHeight = iBottomRightY - iTopLeftY + 1;
+
+    result.arrImage = new Array<uint8_t>(iNewWidth * iNewHeight);
+    result.iHeight = iNewHeight;
+    result.iWidth = iNewWidth;
+
+    int idx = 0;
+    for (int y = 0; y < iHeight; ++y) {
+        if (y < iTopLeftY || y > iBottomRightY) continue;
+        for (int x = 0; x < iWidth; ++x) {
+            if (x < iTopLeftX || x > iBottomRightX) continue;
+            result.arrImage[idx++] = poImageData[y * iWidth + x];
+        }
+    }
+    return 0;
+}
+
+int ImageCut::Cut(Ref<ByteMatrix> matrix, float fRatio, ImageCutResult& result) {
+    int iWidth = matrix->getWidth();
+    int iHeight = matrix->getHeight();
+
+    int iMinX = iWidth * (1 - fRatio) / 2;
+    int iMinY = iHeight * (1 - fRatio) / 2;
+    int iMaxX = iWidth * (1 + fRatio) / 2 - 1;
+    int iMaxY = iHeight * (1 + fRatio) / 2 - 1;
+
+    if (iMinY < 0 || iMinY > iMaxX || iMaxX >= iWidth) return -1;
+    if (iMinX < 0 || iMinX > iMaxX || iMaxX >= iWidth) return -1;
+    int iNewHeight = iMaxY - iMinY + 1;
+    int iNewWidth = iMaxX - iMinX + 1;
+
+    result.arrImage = new Array<uint8_t>(iNewWidth * iNewHeight);
+    result.iWidth = iNewWidth;
+    result.iHeight = iNewHeight;
+
+    int idx = 0;
+    for (int y = 0; y < iNewHeight; ++y) {
+        for (int x = 0; x < iNewWidth; ++x) {
+            result.arrImage[idx++] = matrix->get(x + iMinX, y + iMinY);
+        }
+    }
+    return 0;
+}
+
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/imagecut.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/imagecut.hpp
new file mode 100644
index 00000000..377191ff
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/imagecut.hpp
@@ -0,0 +1,32 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __ZXING_COMMON_IMAGECUT_HPP__
+#define __ZXING_COMMON_IMAGECUT_HPP__
+#include "bytematrix.hpp"
+#include "counted.hpp"
+
+namespace zxing {
+
+typedef struct _ImageCutResult {
+    ArrayRef<uint8_t> arrImage;
+    int iWidth;
+    int iHeight;
+} ImageCutResult;
+
+class ImageCut {
+public:
+    ImageCut();
+    ~ImageCut();
+
+    static int Cut(uint8_t* poImageData, int iWidth, int iHeight, int iTopLeftX, int iTopLeftY,
+                   int iBottomRightX, int iBottomRightY, ImageCutResult& result);
+    static int Cut(Ref<ByteMatrix> matrix, float fRatio, ImageCutResult& result);
+};
+
+}  // namespace zxing
+#endif  // __ZXING_COMMON_IMAGECUT_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/kmeans.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/kmeans.cpp
new file mode 100644
index 00000000..2c55edc3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/kmeans.cpp
@@ -0,0 +1,89 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "../../precomp.hpp"
+#include "kmeans.hpp"
+
+typedef unsigned int uint;
+
+namespace zxing {
+
+double cal_distance(vector<double> a, vector<double> b) {
+    const float KMEANS_COUNT_FACTOR = 0;
+    const float KMEANS_MS_FACTOR = 1;
+
+    uint da = a.size();
+    double val = 0.0;
+    for (uint i = 0; i < da; i++) {
+        if (i == 1)
+            val += KMEANS_MS_FACTOR * pow((a[i] - b[i]), 2);
+        else if (i == 0)
+            val += KMEANS_COUNT_FACTOR * pow((a[i] - b[i]), 2);
+        else
+            val += pow((a[i] - b[i]), 2);
+    }
+    return pow(val, 0.5);
+}
+
+/*
+ * maxepoches max iteration epochs
+ * minchanged min central change times
+ */
+vector<Cluster> k_means(vector<vector<double> > trainX, uint k, uint maxepoches, uint minchanged) {
+    const uint row_num = trainX.size();
+    const uint col_num = trainX[0].size();
+
+    // initialize the cluster central
+    vector<Cluster> clusters(k);
+    int step = trainX.size() / k;
+
+    for (uint i = 0; i < k; i++) {
+        clusters[i].centroid = trainX[i * step];
+    }
+
+    // try max epochs times iteration untill convergence
+    for (uint it = 0; it < maxepoches; it++) {
+        for (uint i = 0; i < k; i++) {
+            clusters[i].samples.clear();
+        }
+        for (uint j = 0; j < row_num; j++) {
+            uint c = 0;
+            double min_distance = cal_distance(trainX[j], clusters[c].centroid);
+            for (uint i = 1; i < k; i++) {
+                double distance = cal_distance(trainX[j], clusters[i].centroid);
+                if (distance < min_distance) {
+                    min_distance = distance;
+                    c = i;
+                }
+            }
+            clusters[c].samples.push_back(j);
+        }
+
+        uint changed = 0;
+        // update cluster central
+        for (uint i = 0; i < k; i++) {
+            vector<double> val(col_num, 0.0);
+            for (uint j = 0; j < clusters[i].samples.size(); j++) {
+                uint sample = clusters[i].samples[j];
+                for (uint d = 0; d < col_num; d++) {
+                    val[d] += trainX[sample][d];
+                    if (j == clusters[i].samples.size() - 1) {
+                        double value = val[d] / clusters[i].samples.size();
+                        if (clusters[i].centroid[d] != value) {
+                            clusters[i].centroid[d] = value;
+                            changed++;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (changed <= minchanged) return clusters;
+    }
+    return clusters;
+}
+
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/kmeans.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/kmeans.hpp
new file mode 100644
index 00000000..5d656dfb
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/kmeans.hpp
@@ -0,0 +1,26 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __ZXING_COMMON_KMEANS_HPP__
+#define __ZXING_COMMON_KMEANS_HPP__
+#include <vector>
+
+namespace zxing {
+
+using namespace std;
+typedef unsigned int uint;
+
+struct Cluster {
+    vector<double> centroid;
+    vector<uint> samples;
+};
+
+double cal_distance(vector<double> a, vector<double> b);
+vector<Cluster> k_means(vector<vector<double> > trainX, uint k, uint maxepoches, uint minchanged);
+
+}  // namespace zxing
+#endif  // __ZXING_COMMON_KMEANS_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/mathutils.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/mathutils.hpp
new file mode 100644
index 00000000..bd466224
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/mathutils.hpp
@@ -0,0 +1,95 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_MATHUTILS_HPP__
+#define __ZXING_COMMON_MATHUTILS_HPP__
+
+#include <cmath>
+#if (defined __GNUC__ && defined __x86_64__ && defined __SSE2__ && !defined __APPLE__ && \
+     !defined __GXX_WEAK__)
+#include <ammintrin.h>
+#elif defined _MSC_VER && (defined _M_X64 || defined _M_IX86)
+#include <emmintrin.h>
+#endif
+
+#include <algorithm>
+#include <numeric>
+#include <vector>
+
+namespace zxing {
+namespace common {
+
+class MathUtils {
+private:
+    MathUtils();
+    ~MathUtils();
+
+public:
+    static inline float distance(float aX, float aY, float bX, float bY) {
+        float xDiff = aX - bX;
+        float yDiff = aY - bY;
+        return sqrt(float(xDiff * xDiff + yDiff * yDiff));
+    }
+
+    static inline float distance_4_int(int aX, int aY, int bX, int bY) {
+        return sqrt(float((aX - bX) * (aX - bX) + (aY - bY) * (aY - bY)));
+    }
+
+    static inline void getRangeValues(int& minValue, int& maxValue, int min, int max) {
+        int finalMinValue, finalMaxValue;
+
+        if (minValue < maxValue) {
+            finalMinValue = minValue;
+            finalMaxValue = maxValue;
+        } else {
+            finalMinValue = maxValue;
+            finalMaxValue = minValue;
+        }
+
+        finalMinValue = finalMinValue > min ? finalMinValue : min;
+        finalMaxValue = finalMaxValue < max ? finalMaxValue : max;
+
+        minValue = finalMinValue;
+        maxValue = finalMaxValue;
+    }
+
+    static inline bool isInRange(float x, float y, float width, float height) {
+        if ((x >= 0.0 && x <= (width - 1.0)) && (y >= 0.0 && y <= (height - 1.0))) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    static inline float distance(int aX, int aY, int bX, int bY) {
+        int xDiff = aX - bX;
+        int yDiff = aY - bY;
+        return sqrt(float(xDiff * xDiff + yDiff * yDiff));
+    }
+
+    static inline float VecCross(float* v1, float* v2) { return v1[0] * v2[1] - v1[1] * v2[0]; }
+
+    static inline void Stddev(std::vector<float>& resultSet, float& avg, float& stddev) {
+        double sum = std::accumulate(resultSet.begin(), resultSet.end(), 0.0);
+        avg = sum / resultSet.size();
+
+        double accum = 0.0;
+        for (std::size_t i = 0; i < resultSet.size(); i++) {
+            accum += (resultSet[i] - avg) * (resultSet[i] - avg);
+        }
+
+        stddev = sqrt(accum / (resultSet.size()));
+    }
+};
+
+}  // namespace common
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_MATHUTILS_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/perspective_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/perspective_transform.cpp
new file mode 100644
index 00000000..74ac2cd7
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/perspective_transform.cpp
@@ -0,0 +1,120 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "perspective_transform.hpp"
+
+
+namespace zxing {
+
+// This class implements a perspective transform in two dimensions. Given four
+// source and four destination points, it will compute the transformation
+// implied between them. The code is based directly upon section 3.4.2 of George
+// Wolberg's "Digital Image Warping"; see pages 54-56
+PerspectiveTransform::PerspectiveTransform(float inA11, float inA21, float inA31, float inA12,
+                                           float inA22, float inA32, float inA13, float inA23,
+                                           float inA33)
+    : a11(inA11),
+      a12(inA12),
+      a13(inA13),
+      a21(inA21),
+      a22(inA22),
+      a23(inA23),
+      a31(inA31),
+      a32(inA32),
+      a33(inA33) {}
+
+Ref<PerspectiveTransform> PerspectiveTransform::quadrilateralToQuadrilateral(
+    float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float x0p,
+    float y0p, float x1p, float y1p, float x2p, float y2p, float x3p, float y3p) {
+    Ref<PerspectiveTransform> qToS =
+        PerspectiveTransform::quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);
+    Ref<PerspectiveTransform> sToQ =
+        PerspectiveTransform::squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);
+    return sToQ->times(qToS);
+}
+
+Ref<PerspectiveTransform> PerspectiveTransform::squareToQuadrilateral(float x0, float y0, float x1,
+                                                                      float y1, float x2, float y2,
+                                                                      float x3, float y3) {
+    float dx3 = x0 - x1 + x2 - x3;
+    float dy3 = y0 - y1 + y2 - y3;
+    if (fabs(dx3) <= 1e-6 && fabs(dy3) <= 1e-6) {
+        Ref<PerspectiveTransform> result(
+            new PerspectiveTransform(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0.0f, 0.0f, 1.0f));
+        return result;
+    } else {
+        float dx1 = x1 - x2;
+        float dx2 = x3 - x2;
+        float dy1 = y1 - y2;
+        float dy2 = y3 - y2;
+        float denominator = dx1 * dy2 - dx2 * dy1;
+        float a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
+        float a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
+        Ref<PerspectiveTransform> result(
+            new PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0 + a13 * y1,
+                                     y3 - y0 + a23 * y3, y0, a13, a23, 1.0f));
+        return result;
+    }
+}
+
+Ref<PerspectiveTransform> PerspectiveTransform::quadrilateralToSquare(float x0, float y0, float x1,
+                                                                      float y1, float x2, float y2,
+                                                                      float x3, float y3) {
+    // Here, the adjoint serves as the inverse:
+    return squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3)->buildAdjoint();
+}
+
+Ref<PerspectiveTransform> PerspectiveTransform::buildAdjoint() {
+    // Adjoint is the transpose of the cofactor matrix:
+    Ref<PerspectiveTransform> result(new PerspectiveTransform(
+        a22 * a33 - a23 * a32, a23 * a31 - a21 * a33, a21 * a32 - a22 * a31, a13 * a32 - a12 * a33,
+        a11 * a33 - a13 * a31, a12 * a31 - a11 * a32, a12 * a23 - a13 * a22, a13 * a21 - a11 * a23,
+        a11 * a22 - a12 * a21));
+    return result;
+}
+
+Ref<PerspectiveTransform> PerspectiveTransform::times(Ref<PerspectiveTransform> other) {
+    Ref<PerspectiveTransform> result(
+        new PerspectiveTransform(a11 * other->a11 + a21 * other->a12 + a31 * other->a13,
+                                 a11 * other->a21 + a21 * other->a22 + a31 * other->a23,
+                                 a11 * other->a31 + a21 * other->a32 + a31 * other->a33,
+                                 a12 * other->a11 + a22 * other->a12 + a32 * other->a13,
+                                 a12 * other->a21 + a22 * other->a22 + a32 * other->a23,
+                                 a12 * other->a31 + a22 * other->a32 + a32 * other->a33,
+                                 a13 * other->a11 + a23 * other->a12 + a33 * other->a13,
+                                 a13 * other->a21 + a23 * other->a22 + a33 * other->a23,
+                                 a13 * other->a31 + a23 * other->a32 + a33 * other->a33));
+    return result;
+}
+
+void PerspectiveTransform::transformPoints(vector<float>& points) {
+    int max = points.size();
+
+    // Modified to support stlport
+    float* pts = NULL;
+
+    if (points.size() > 0) {
+        pts = &points[0];
+    }
+
+    for (int i = 0; i < max; i += 2) {
+        float x = pts[i];
+        float y = pts[i + 1];
+
+        float denominator = a13 * x + a23 * y + a33;
+
+        float w = 1.0f / denominator;
+
+        pts[i] = (a11 * x + a21 * y + a31) * w;
+        pts[i + 1] = (a12 * x + a22 * y + a32) * w;
+    }
+}
+
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/perspective_transform.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/perspective_transform.hpp
new file mode 100644
index 00000000..59e1db6f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/perspective_transform.hpp
@@ -0,0 +1,39 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_PERSPECTIVETRANSFORM_HPP__
+#define __ZXING_COMMON_PERSPECTIVETRANSFORM_HPP__
+
+#include "counted.hpp"
+
+#include <vector>
+
+namespace zxing {
+class PerspectiveTransform : public Counted {
+private:
+    float a11, a12, a13, a21, a22, a23, a31, a32, a33;
+    PerspectiveTransform(float a11, float a21, float a31, float a12, float a22, float a32,
+                         float a13, float a23, float a33);
+
+public:
+    static Ref<PerspectiveTransform> quadrilateralToQuadrilateral(
+        float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float x0p,
+        float y0p, float x1p, float y1p, float x2p, float y2p, float x3p, float y3p);
+    static Ref<PerspectiveTransform> squareToQuadrilateral(float x0, float y0, float x1, float y1,
+                                                           float x2, float y2, float x3, float y3);
+    static Ref<PerspectiveTransform> quadrilateralToSquare(float x0, float y0, float x1, float y1,
+                                                           float x2, float y2, float x3, float y3);
+    Ref<PerspectiveTransform> buildAdjoint();
+    Ref<PerspectiveTransform> times(Ref<PerspectiveTransform> other);
+    void transformPoints(std::vector<float>& points);
+};
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_PERSPECTIVETRANSFORM_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgf.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgf.cpp
new file mode 100644
index 00000000..8e3ad184
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgf.cpp
@@ -0,0 +1,99 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "genericgf.hpp"
+#include "genericgfpoly.hpp"
+
+using zxing::ErrorHandler;
+using zxing::GenericGF;
+using zxing::GenericGFPoly;
+using zxing::Ref;
+
+GenericGF::GenericGF(int primitive_, int size_, int b, ErrorHandler &err_handler)
+    : size(size_), primitive(primitive_), generatorBase(b) {
+    expTable.resize(size);
+    logTable.resize(size);
+
+    int x = 1;
+
+    for (int i = 0; i < size; i++) {
+        expTable[i] = x;
+        x <<= 1;  // x = x * 2; we're assuming the generator alpha is 2
+        if (x >= size) {
+            x ^= primitive;
+            x &= size - 1;
+        }
+    }
+    for (int i = 0; i < size - 1; i++) {
+        logTable[expTable[i]] = i;
+    }
+    // logTable[0] == 0 but this should never be used
+    zero =
+        Ref<GenericGFPoly>(new GenericGFPoly(*this, ArrayRef<int>(new Array<int>(1)), err_handler));
+    zero->getCoefficients()[0] = 0;
+    one =
+        Ref<GenericGFPoly>(new GenericGFPoly(*this, ArrayRef<int>(new Array<int>(1)), err_handler));
+    one->getCoefficients()[0] = 1;
+    if (err_handler.ErrCode()) return;
+    //  initialized = true;
+}
+
+Ref<GenericGFPoly> GenericGF::getZero() { return zero; }
+
+Ref<GenericGFPoly> GenericGF::getOne() { return one; }
+
+Ref<GenericGFPoly> GenericGF::buildMonomial(int degree, int coefficient,
+                                            ErrorHandler &err_handler) {
+    if (degree < 0) {
+        err_handler = IllegalArgumentErrorHandler("Degree must be non-negative");
+        return Ref<GenericGFPoly>();
+    }
+    if (coefficient == 0) {
+        return zero;
+    }
+    ArrayRef<int> coefficients(new Array<int>(degree + 1));
+    coefficients[0] = coefficient;
+
+    Ref<GenericGFPoly> gfpoly(new GenericGFPoly(*this, coefficients, err_handler));
+    if (err_handler.ErrCode()) return Ref<GenericGFPoly>();
+    return gfpoly;
+}
+
+int GenericGF::addOrSubtract(int a, int b) { return a ^ b; }
+
+int GenericGF::exp(int a) { return expTable[a]; }
+
+int GenericGF::log(int a, ErrorHandler &err_handler) {
+    if (a == 0) {
+        err_handler = IllegalArgumentErrorHandler("cannot give log(0)");
+        return -1;
+    }
+    return logTable[a];
+}
+
+int GenericGF::inverse(int a, ErrorHandler &err_handler) {
+    if (a == 0) {
+        err_handler = IllegalArgumentErrorHandler("Cannot calculate the inverse of 0");
+        return -1;
+    }
+    return expTable[size - logTable[a] - 1];
+}
+
+int GenericGF::multiply(int a, int b) {
+    if (a == 0 || b == 0) {
+        return 0;
+    }
+
+    return expTable[(logTable[a] + logTable[b]) % (size - 1)];
+}
+
+int GenericGF::getSize() { return size; }
+
+int GenericGF::getGeneratorBase() { return generatorBase; }
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgf.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgf.hpp
new file mode 100644
index 00000000..aabbeaf0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgf.hpp
@@ -0,0 +1,58 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_REEDSOLOMON_GENERICGF_HPP__
+#define __ZXING_COMMON_REEDSOLOMON_GENERICGF_HPP__
+
+#include "../../errorhandler.hpp"
+#include "../counted.hpp"
+
+namespace zxing {
+class GenericGFPoly;
+
+static zxing::ErrorHandler gf_err_handler_;
+#define GF_AZTEC_DATA_12 (new GenericGF(0x1069, 4096, 1, gf_err_handler_))
+#define GF_AZTEC_DATA_10 (new GenericGF(0x409, 1024, 1, gf_err_handler_))
+#define GF_AZTEC_DATA_6 (new GenericGF(0x43, 64, 1, gf_err_handler_))
+#define GF_AZTEC_PARAM (new GenericGF(0x13, 16, 1, gf_err_handler_))
+#define GF_QR_CODE_FIELD_256 (new GenericGF(0x011D, 256, 0, gf_err_handler_))
+#define GF_DATA_MATRIX_FIELD_256 (new GenericGF(0x012D, 256, 1, gf_err_handler_))
+#define GF_AZTEC_DATA_8 (new GenericGF(0x012D, 256, 1, gf_err_handler_))
+#define GF_MAXICODE_FIELD_64 (new GenericGF(0x43, 64, 1, gf_err_handler_))
+// #define GF_WXCODE (new GenericGF(0x011D, 256, 0, gf_err_handler_))
+
+class GenericGF : public Counted {
+private:
+    std::vector<int> expTable;
+    std::vector<int> logTable;
+    Ref<GenericGFPoly> zero;
+    Ref<GenericGFPoly> one;
+    int size;
+    int primitive;
+    int generatorBase;
+
+public:
+    GenericGF(int primitive, int size, int b, ErrorHandler &err_handler);
+
+    Ref<GenericGFPoly> getZero();
+    Ref<GenericGFPoly> getOne();
+    int getSize();
+    int getGeneratorBase();
+    Ref<GenericGFPoly> buildMonomial(int degree, int coefficient, ErrorHandler &err_handler);
+
+    static int addOrSubtract(int a, int b);
+    int exp(int a);
+    int log(int a, ErrorHandler &err_handler);
+    int inverse(int a, ErrorHandler &err_handler);
+    int multiply(int a, int b);
+};
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_REEDSOLOMON_GENERICGF_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgfpoly.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgfpoly.cpp
new file mode 100644
index 00000000..4098a379
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgfpoly.cpp
@@ -0,0 +1,231 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "genericgfpoly.hpp"
+#include "genericgf.hpp"
+
+using zxing::ArrayRef;
+using zxing::ErrorHandler;
+using zxing::GenericGFPoly;
+using zxing::Ref;
+
+// VC++
+using zxing::GenericGF;
+
+GenericGFPoly::GenericGFPoly(GenericGF &field, ArrayRef<int> coefficients,
+                             ErrorHandler &err_handler)
+    : field_(field) {
+    if (coefficients->size() == 0) {
+        err_handler = IllegalArgumentErrorHandler("need coefficients");
+        return;
+    }
+    int coefficientsLength = coefficients->size();
+    if (coefficientsLength > 1 && coefficients[0] == 0) {
+        // Leading term must be non-zero for anything except the constant
+        // polynomial "0"
+        int firstNonZero = 1;
+        while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) {
+            firstNonZero++;
+        }
+        if (firstNonZero == coefficientsLength) {
+            coefficients_ = field.getZero()->getCoefficients();
+        } else {
+            coefficients_ = ArrayRef<int>(new Array<int>(coefficientsLength - firstNonZero));
+            for (int i = 0; i < (int)coefficients_->size(); i++) {
+                coefficients_[i] = coefficients[i + firstNonZero];
+            }
+        }
+    } else {
+        coefficients_ = coefficients;
+    }
+}
+
+ArrayRef<int> GenericGFPoly::getCoefficients() { return coefficients_; }
+
+int GenericGFPoly::getDegree() { return coefficients_->size() - 1; }
+
+bool GenericGFPoly::isZero() { return coefficients_[0] == 0; }
+
+int GenericGFPoly::getCoefficient(int degree) {
+    return coefficients_[coefficients_->size() - 1 - degree];
+}
+
+int GenericGFPoly::evaluateAt(int a) {
+    if (a == 0) {
+        // Just return the x^0 coefficient
+        return getCoefficient(0);
+    }
+
+    int size = coefficients_->size();
+    if (a == 1) {
+        // Just the sum of the coefficients
+        int result = 0;
+        for (int i = 0; i < size; i++) {
+            result = GenericGF::addOrSubtract(result, coefficients_[i]);
+        }
+        return result;
+    }
+    int result = coefficients_[0];
+    for (int i = 1; i < size; i++) {
+        result = GenericGF::addOrSubtract(field_.multiply(a, result), coefficients_[i]);
+    }
+    return result;
+}
+
+Ref<GenericGFPoly> GenericGFPoly::addOrSubtract(Ref<zxing::GenericGFPoly> other,
+                                                ErrorHandler &err_handler) {
+    if (!(&field_ == &other->field_)) {
+        err_handler =
+            IllegalArgumentErrorHandler("GenericGFPolys do not have same GenericGF field");
+        return Ref<GenericGFPoly>();
+    }
+    if (isZero()) {
+        return other;
+    }
+    if (other->isZero()) {
+        return Ref<GenericGFPoly>(this);
+    }
+
+    ArrayRef<int> smallerCoefficients = coefficients_;
+    ArrayRef<int> largerCoefficients = other->getCoefficients();
+    if (smallerCoefficients->size() > largerCoefficients->size()) {
+        ArrayRef<int> temp = smallerCoefficients;
+        smallerCoefficients = largerCoefficients;
+        largerCoefficients = temp;
+    }
+
+    ArrayRef<int> sumDiff(new Array<int>(largerCoefficients->size()));
+    int lengthDiff = largerCoefficients->size() - smallerCoefficients->size();
+    // Copy high-order terms only found in higher-degree polynomial's
+    // coefficients
+    for (int i = 0; i < lengthDiff; i++) {
+        sumDiff[i] = largerCoefficients[i];
+    }
+
+    for (int i = lengthDiff; i < (int)largerCoefficients->size(); i++) {
+        sumDiff[i] =
+            GenericGF::addOrSubtract(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
+    }
+
+    // return Ref<GenericGFPoly>(new GenericGFPoly(field_, sumDiff));
+    Ref<GenericGFPoly> gfpoly(new GenericGFPoly(field_, sumDiff, err_handler));
+    if (err_handler.ErrCode()) return Ref<GenericGFPoly>();
+    return gfpoly;
+}
+
+Ref<GenericGFPoly> GenericGFPoly::multiply(Ref<zxing::GenericGFPoly> other,
+                                           ErrorHandler &err_handler) {
+    if (!(&field_ == &other->field_)) {
+        err_handler =
+            IllegalArgumentErrorHandler("GenericGFPolys do not have same GenericGF field");
+        return Ref<GenericGFPoly>();
+    }
+
+    if (isZero() || other->isZero()) {
+        return field_.getZero();
+    }
+
+    ArrayRef<int> aCoefficients = coefficients_;
+    int aLength = aCoefficients->size();
+
+    ArrayRef<int> bCoefficients = other->getCoefficients();
+    int bLength = bCoefficients->size();
+
+    ArrayRef<int> product(new Array<int>(aLength + bLength - 1));
+    for (int i = 0; i < aLength; i++) {
+        int aCoeff = aCoefficients[i];
+        for (int j = 0; j < bLength; j++) {
+            product[i + j] =
+                GenericGF::addOrSubtract(product[i + j], field_.multiply(aCoeff, bCoefficients[j]));
+        }
+    }
+
+    // return Ref<GenericGFPoly>(new GenericGFPoly(field_, product));
+    Ref<GenericGFPoly> gfpoly(new GenericGFPoly(field_, product, err_handler));
+    if (err_handler.ErrCode()) return Ref<GenericGFPoly>();
+    return gfpoly;
+}
+
+Ref<GenericGFPoly> GenericGFPoly::multiply(int scalar, ErrorHandler &err_handler) {
+    if (scalar == 0) {
+        return field_.getZero();
+    }
+    if (scalar == 1) {
+        return Ref<GenericGFPoly>(this);
+    }
+    int size = coefficients_->size();
+    ArrayRef<int> product(new Array<int>(size));
+    for (int i = 0; i < size; i++) {
+        product[i] = field_.multiply(coefficients_[i], scalar);
+    }
+    // return Ref<GenericGFPoly>(new GenericGFPoly(field_, product));
+    Ref<GenericGFPoly> gfpoly(new GenericGFPoly(field_, product, err_handler));
+    if (err_handler.ErrCode()) return Ref<GenericGFPoly>();
+    return gfpoly;
+}
+
+Ref<GenericGFPoly> GenericGFPoly::multiplyByMonomial(int degree, int coefficient,
+                                                     ErrorHandler &err_handler) {
+    if (degree < 0) {
+        err_handler = IllegalArgumentErrorHandler("degree must not be less then 0");
+        return Ref<GenericGFPoly>();
+    }
+    if (coefficient == 0) {
+        return field_.getZero();
+    }
+    int size = coefficients_->size();
+    ArrayRef<int> product(new Array<int>(size + degree));
+    for (int i = 0; i < size; i++) {
+        product[i] = field_.multiply(coefficients_[i], coefficient);
+    }
+    // return Ref<GenericGFPoly>(new GenericGFPoly(field_, product));
+    Ref<GenericGFPoly> gfpoly(new GenericGFPoly(field_, product, err_handler));
+    if (err_handler.ErrCode()) return Ref<GenericGFPoly>();
+    return gfpoly;
+}
+
+std::vector<Ref<GenericGFPoly>> GenericGFPoly::divide(Ref<GenericGFPoly> other,
+                                                      ErrorHandler &err_handler) {
+    if (!(&field_ == &other->field_)) {
+        err_handler =
+            IllegalArgumentErrorHandler("GenericGFPolys do not have same GenericGF field");
+        return std::vector<Ref<GenericGFPoly>>();
+    }
+    if (other->isZero()) {
+        err_handler = IllegalArgumentErrorHandler("divide by 0");
+        return std::vector<Ref<GenericGFPoly>>();
+    }
+
+    Ref<GenericGFPoly> quotient = field_.getZero();
+    Ref<GenericGFPoly> remainder = Ref<GenericGFPoly>(this);
+
+    int denominatorLeadingTerm = other->getCoefficient(other->getDegree());
+    int inverseDenominatorLeadingTerm = field_.inverse(denominatorLeadingTerm, err_handler);
+    if (err_handler.ErrCode()) return std::vector<Ref<GenericGFPoly>>();
+
+    while (remainder->getDegree() >= other->getDegree() && !remainder->isZero()) {
+        int degreeDifference = remainder->getDegree() - other->getDegree();
+        int scale = field_.multiply(remainder->getCoefficient(remainder->getDegree()),
+                                    inverseDenominatorLeadingTerm);
+        Ref<GenericGFPoly> term = other->multiplyByMonomial(degreeDifference, scale, err_handler);
+        if (err_handler.ErrCode()) return std::vector<Ref<GenericGFPoly>>();
+        Ref<GenericGFPoly> iterationQuotiont =
+            field_.buildMonomial(degreeDifference, scale, err_handler);
+        if (err_handler.ErrCode()) return std::vector<Ref<GenericGFPoly>>();
+        quotient = quotient->addOrSubtract(iterationQuotiont, err_handler);
+        remainder = remainder->addOrSubtract(term, err_handler);
+        if (err_handler.ErrCode()) return std::vector<Ref<GenericGFPoly>>();
+    }
+
+    std::vector<Ref<GenericGFPoly>> returnValue(2);
+    returnValue[0] = quotient;
+    returnValue[1] = remainder;
+    return returnValue;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgfpoly.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgfpoly.hpp
new file mode 100644
index 00000000..031c0b7b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/genericgfpoly.hpp
@@ -0,0 +1,43 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_REEDSOLOMON_GENERICGFPOLY_HPP__
+#define __ZXING_COMMON_REEDSOLOMON_GENERICGFPOLY_HPP__
+
+#include "../../errorhandler.hpp"
+#include "../array.hpp"
+#include "../counted.hpp"
+
+namespace zxing {
+
+class GenericGF;
+
+class GenericGFPoly : public Counted {
+private:
+    GenericGF &field_;
+    ArrayRef<int> coefficients_;
+
+public:
+    GenericGFPoly(GenericGF &field, ArrayRef<int> coefficients, ErrorHandler &err_handler);
+    ArrayRef<int> getCoefficients();
+    int getDegree();
+    bool isZero();
+    int getCoefficient(int degree);
+    int evaluateAt(int a);
+    Ref<GenericGFPoly> addOrSubtract(Ref<GenericGFPoly> other, ErrorHandler &err_handler);
+    Ref<GenericGFPoly> multiply(Ref<GenericGFPoly> other, ErrorHandler &err_handler);
+    Ref<GenericGFPoly> multiply(int scalar, ErrorHandler &err_handler);
+    Ref<GenericGFPoly> multiplyByMonomial(int degree, int coefficient, ErrorHandler &err_handler);
+    std::vector<Ref<GenericGFPoly>> divide(Ref<GenericGFPoly> other, ErrorHandler &err_handler);
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_REEDSOLOMON_GENERICGFPOLY_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/reed_solomon_decoder.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/reed_solomon_decoder.cpp
new file mode 100644
index 00000000..fec9c828
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/reed_solomon_decoder.cpp
@@ -0,0 +1,185 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "reed_solomon_decoder.hpp"
+
+using zxing::ArrayRef;
+using zxing::ErrorHandler;
+using zxing::GenericGFPoly;
+using zxing::ReedSolomonDecoder;
+using zxing::Ref;
+using zxing::GenericGF;
+
+ReedSolomonDecoder::ReedSolomonDecoder(Ref<GenericGF> field_) : field(field_) {}
+
+ReedSolomonDecoder::~ReedSolomonDecoder() {}
+
+void ReedSolomonDecoder::decode(ArrayRef<int> received, int twoS, ErrorHandler &err_handler) {
+    Ref<GenericGFPoly> poly(new GenericGFPoly(*field, received, err_handler));
+    if (err_handler.ErrCode()) return;
+    ArrayRef<int> syndromeCoefficients(twoS);
+    bool noError = true;
+    for (int i = 0; i < twoS; i++) {
+        int eval = poly->evaluateAt(field->exp(i + field->getGeneratorBase()));
+        syndromeCoefficients[syndromeCoefficients->size() - 1 - i] = eval;
+        if (eval != 0) {
+            noError = false;
+        }
+    }
+    if (noError) {
+        return;
+    }
+    Ref<GenericGFPoly> syndrome(new GenericGFPoly(*field, syndromeCoefficients, err_handler));
+    Ref<GenericGFPoly> monomial = field->buildMonomial(twoS, 1, err_handler);
+    if (!monomial || err_handler.ErrCode()) {
+        err_handler = ErrorHandler("buildMonomial was zero");
+        return;
+    }
+    vector<Ref<GenericGFPoly>> sigmaOmega =
+        runEuclideanAlgorithm(monomial, syndrome, twoS, err_handler);
+    if (err_handler.ErrCode()) return;
+
+    Ref<GenericGFPoly> sigma = sigmaOmega[0];
+    Ref<GenericGFPoly> omega = sigmaOmega[1];
+    ArrayRef<int> errorLocations = findErrorLocations(sigma, err_handler);
+    if (err_handler.ErrCode()) return;
+
+    ArrayRef<int> errorMagitudes = findErrorMagnitudes(omega, errorLocations, err_handler);
+    if (err_handler.ErrCode()) return;
+    for (int i = 0; i < errorLocations->size(); i++) {
+        int position = received->size() - 1 - field->log(errorLocations[i], err_handler);
+        if (position < 0 || err_handler.ErrCode()) {
+            err_handler = ErrorHandler("Bad error location");
+            return;
+        }
+        received[position] = GenericGF::addOrSubtract(received[position], errorMagitudes[i]);
+    }
+}
+
+vector<Ref<GenericGFPoly>> ReedSolomonDecoder::runEuclideanAlgorithm(Ref<GenericGFPoly> a,
+                                                                     Ref<GenericGFPoly> b, int R,
+                                                                     ErrorHandler &err_handler) {
+    vector<Ref<GenericGFPoly>> result(2);
+
+    // Assume a's degree is >= b's
+    if (a->getDegree() < b->getDegree()) {
+        Ref<GenericGFPoly> tmp = a;
+        a = b;
+        b = tmp;
+    }
+
+    Ref<GenericGFPoly> rLast(a);
+    Ref<GenericGFPoly> r(b);
+    Ref<GenericGFPoly> tLast(field->getZero());
+    Ref<GenericGFPoly> t(field->getOne());
+
+    // Run Euclidean algorithm until r's degree is less than R/2
+    while (r->getDegree() >= R / 2) {
+        Ref<GenericGFPoly> rLastLast(rLast);
+        Ref<GenericGFPoly> tLastLast(tLast);
+        rLast = r;
+        tLast = t;
+
+        // Divide rLastLast by rLast, with quotient q and remainder r
+        if (rLast->isZero()) {
+            // Oops, Euclidean algorithm already terminated?
+            err_handler = ErrorHandler("r_{i-1} was zero");
+            return vector<Ref<GenericGFPoly>>();
+        }
+        r = rLastLast;
+        Ref<GenericGFPoly> q = field->getZero();
+        int denominatorLeadingTerm = rLast->getCoefficient(rLast->getDegree());
+        int dltInverse = field->inverse(denominatorLeadingTerm, err_handler);
+        if (err_handler.ErrCode()) return vector<Ref<GenericGFPoly>>();
+        while (r->getDegree() >= rLast->getDegree() && !r->isZero()) {
+            int degreeDiff = r->getDegree() - rLast->getDegree();
+            int scale = field->multiply(r->getCoefficient(r->getDegree()), dltInverse);
+            q = q->addOrSubtract(field->buildMonomial(degreeDiff, scale, err_handler), err_handler);
+            r = r->addOrSubtract(rLast->multiplyByMonomial(degreeDiff, scale, err_handler),
+                                 err_handler);
+            if (err_handler.ErrCode()) return vector<Ref<GenericGFPoly>>();
+        }
+
+        Ref<GenericGFPoly> tmp = q->multiply(tLast, err_handler);
+        if (err_handler.ErrCode()) return vector<Ref<GenericGFPoly>>();
+        t = tmp->addOrSubtract(tLastLast, err_handler);
+        if (err_handler.ErrCode()) return vector<Ref<GenericGFPoly>>();
+
+        if (r->getDegree() >= rLast->getDegree()) {
+            err_handler = ErrorHandler("Division algorithm failed to reduce polynomial?");
+            return vector<Ref<GenericGFPoly>>();
+        }
+    }
+
+    int sigmaTildeAtZero = t->getCoefficient(0);
+    if (sigmaTildeAtZero == 0) {
+        err_handler = ErrorHandler("sigmaTilde(0) was zero");
+        return vector<Ref<GenericGFPoly>>();
+    }
+
+    int inverse = field->inverse(sigmaTildeAtZero, err_handler);
+    Ref<GenericGFPoly> sigma(t->multiply(inverse, err_handler));
+    Ref<GenericGFPoly> omega(r->multiply(inverse, err_handler));
+    if (err_handler.ErrCode()) return vector<Ref<GenericGFPoly>>();
+
+    result[0] = sigma;
+    result[1] = omega;
+    return result;
+}
+
+ArrayRef<int> ReedSolomonDecoder::findErrorLocations(Ref<GenericGFPoly> errorLocator,
+                                                     ErrorHandler &err_handler) {
+    // This is a direct application of Chien's search
+    int numErrors = errorLocator->getDegree();
+    if (numErrors == 1) {  // shortcut
+        ArrayRef<int> result(new Array<int>(1));
+        result[0] = errorLocator->getCoefficient(1);
+        return result;
+    }
+    ArrayRef<int> result(new Array<int>(numErrors));
+    int e = 0;
+    for (int i = 1; i < field->getSize() && e < numErrors; i++) {
+        if (errorLocator->evaluateAt(i) == 0) {
+            result[e] = field->inverse(i, err_handler);
+            e++;
+        }
+    }
+    if (e != numErrors || err_handler.ErrCode()) {
+        err_handler = ErrorHandler("Error locator degree does not match number of root");
+        return ArrayRef<int>();
+    }
+    return result;
+}
+
+ArrayRef<int> ReedSolomonDecoder::findErrorMagnitudes(Ref<GenericGFPoly> errorEvaluator,
+                                                      ArrayRef<int> errorLocations,
+                                                      ErrorHandler &err_handler) {
+    // This is directly applying Forney's Formula
+    int s = errorLocations->size();
+    ArrayRef<int> result(new Array<int>(s));
+    for (int i = 0; i < s; i++) {
+        int xiInverse = field->inverse(errorLocations[i], err_handler);
+        int denominator = 1;
+        for (int j = 0; j < s; j++) {
+            if (i != j) {
+                int term = field->multiply(errorLocations[j], xiInverse);
+                int termPlus1 = (term & 0x1) == 0 ? term | 1 : term & ~1;
+                denominator = field->multiply(denominator, termPlus1);
+            }
+        }
+        result[i] = field->multiply(errorEvaluator->evaluateAt(xiInverse),
+                                    field->inverse(denominator, err_handler));
+        if (field->getGeneratorBase() != 0) {
+            result[i] = field->multiply(result[i], xiInverse);
+        }
+    }
+    if (err_handler.ErrCode()) return ArrayRef<int>();
+    return result;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/reed_solomon_decoder.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/reed_solomon_decoder.hpp
new file mode 100644
index 00000000..15271dd0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/reedsolomon/reed_solomon_decoder.hpp
@@ -0,0 +1,43 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_REEDSOLOMON_REEDSOLOMONDECODER_HPP__
+#define __ZXING_COMMON_REEDSOLOMON_REEDSOLOMONDECODER_HPP__
+
+#include "../../errorhandler.hpp"
+#include "../array.hpp"
+#include "../counted.hpp"
+#include "genericgf.hpp"
+#include "genericgfpoly.hpp"
+
+namespace zxing {
+class GenericGFPoly;
+class GenericGF;
+
+class ReedSolomonDecoder {
+private:
+    Ref<GenericGF> field;
+
+public:
+    explicit ReedSolomonDecoder(Ref<GenericGF> fld);
+    ~ReedSolomonDecoder();
+    void decode(ArrayRef<int> received, int twoS, ErrorHandler &err_handler);
+    std::vector<Ref<GenericGFPoly>> runEuclideanAlgorithm(Ref<GenericGFPoly> a,
+                                                          Ref<GenericGFPoly> b, int R,
+                                                          ErrorHandler &err_handler);
+
+private:
+    ArrayRef<int> findErrorLocations(Ref<GenericGFPoly> errorLocator, ErrorHandler &err_handler);
+    ArrayRef<int> findErrorMagnitudes(Ref<GenericGFPoly> errorEvaluator,
+                                      ArrayRef<int> errorLocations, ErrorHandler &err_handler);
+};
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_REEDSOLOMON_REEDSOLOMONDECODER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/str.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/str.cpp
new file mode 100644
index 00000000..1de3dd02
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/str.cpp
@@ -0,0 +1,96 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "str.hpp"
+
+using zxing::Ref;
+using zxing::String;
+using zxing::StrUtil;
+String::String(const std::string& text) : text_(text) {}
+
+String::String(int capacity) { text_.reserve(capacity); }
+
+const std::string& String::getText() const { return text_; }
+
+char String::charAt(int i) const { return text_[i]; }
+
+int String::size() const { return text_.size(); }
+
+int String::length() const { return text_.size(); }
+
+Ref<String> String::substring(int i) const { return Ref<String>(new String(text_.substr(i))); }
+
+Ref<String> String::substring(int start, int end) const {
+    return Ref<String>(new String(text_.substr(start, (end - start))));
+}
+
+void String::append(const std::string& tail) { text_.append(tail); }
+
+void String::append(char c) { text_.append(1, c); }
+
+void String::append(int d) {
+    string str = StrUtil::numberToString(d);
+    text_.append(str);
+}
+
+void String::append(Ref<String> str) { append(str->getText()); }
+
+string StrUtil::COMBINE_STRING(string str1, string str2) {
+    string str = str1;
+    str += str2;
+    return str;
+}
+
+string StrUtil::COMBINE_STRING(string str1, char c) {
+    string str = str1;
+    str += c;
+    return str;
+}
+
+string StrUtil::COMBINE_STRING(string str1, int d) {
+    string str = str1;
+    str += numberToString(d);
+    return str;
+}
+
+Ref<String> StrUtil::COMBINE_STRING(char c1, Ref<String> content, char c2) {
+    Ref<String> str(new String(0));
+    str->append(c1);
+    str->append(content);
+    str->append(c2);
+
+    return str;
+}
+
+template <typename T>
+string StrUtil::numberToString(T Number) {
+    ostringstream ss;
+    ss << Number;
+    return ss.str();
+}
+
+template <typename T>
+T StrUtil::stringToNumber(const string& Text) {
+    std::istringstream ss(Text);
+    T result;
+    return ss >> result ? result : 0;
+}
+
+int StrUtil::indexOf(const char* str, char c) {
+    int len = strlen(str);
+
+    for (int i = 0; i < len; i++) {
+        if (str[i] == c) {
+            return i;
+        }
+    }
+
+    return -1;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/str.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/str.hpp
new file mode 100644
index 00000000..3d20910f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/str.hpp
@@ -0,0 +1,58 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_STR_HPP__
+#define __ZXING_COMMON_STR_HPP__
+
+#include "counted.hpp"
+
+#include <sstream>
+#include <string>
+using std::string;
+namespace zxing {
+
+class String : public Counted {
+private:
+    std::string text_;
+
+public:
+    explicit String(const std::string& text);
+    explicit String(int);
+    char charAt(int) const;
+    Ref<String> substring(int) const;
+    Ref<String> substring(int, int) const;
+    const std::string& getText() const;
+    int size() const;
+    void append(std::string const& tail);
+    void append(char c);
+    void append(int d);
+    void append(Ref<String> str);
+    int length() const;
+};
+
+class StrUtil {
+public:
+    static string COMBINE_STRING(string str1, string str2);
+    static string COMBINE_STRING(string str1, char c);
+    static string COMBINE_STRING(string str1, int d);
+    static Ref<String> COMBINE_STRING(char c1, Ref<String> content, char c2);
+
+    template <typename T>
+    static string numberToString(T Number);
+
+    template <typename T>
+    static T stringToNumber(const string& Text);
+
+    static int indexOf(const char* str, char c);
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_COMMON_STR_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/stringutils.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/stringutils.cpp
new file mode 100644
index 00000000..ed9fe3e9
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/stringutils.cpp
@@ -0,0 +1,683 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "../common/stringutils.hpp"
+#include "../decodehints.hpp"
+
+using namespace zxing::common;
+
+// N.B.: these are the iconv strings for at least some versions of iconv
+
+char const* const StringUtils::PLATFORM_DEFAULT_ENCODING = "ANY";
+char const* const StringUtils::ASCII = "ASCII";
+char const* const StringUtils::SHIFT_JIS = "SHIFT-JIS";
+char const* const StringUtils::GBK = "GBK";
+char const* const StringUtils::EUC_JP = "EUC-JP";
+char const* const StringUtils::UTF8 = "UTF-8";
+char const* const StringUtils::ISO88591 = "ISO8859-1";
+char const* const StringUtils::GB2312 = "GB2312";
+char const* const StringUtils::BIG5 = "BIG5";
+char const* const StringUtils::GB18030 = "GB18030";
+
+const bool StringUtils::ASSUME_SHIFT_JIS = false;
+
+#ifdef USE_UCHARDET
+#include "uchardet/uchardet.h"
+#endif
+
+// Added convertString
+#ifndef NO_ICONV
+#include <iconv.h>
+
+// Required for compatibility. TODO: test on Symbian
+//#ifdef ZXING_ICONV_CONST
+#undef ICONV_CONST
+#define ICONV_CONST const
+//#endif
+
+#ifndef ICONV_CONST
+#define ICONV_CONST /**/
+#endif
+
+// Add this to fix both Mac and Windows compilers
+// by Skylook
+template <class T>
+class sloppy {};
+
+// convert between T** and const T**
+template <class T>
+class sloppy<T**> {
+    T** t;
+
+public:
+    sloppy(T** mt) : t(mt) {}
+    sloppy(const T** mt) : t(const_cast<T**>(mt)) {}
+
+    operator T* *() const { return t; }
+    operator const T* *() const { return const_cast<const T**>(t); }
+};
+#endif
+
+string StringUtils::convertString(const char* rawData, int length, const char* fromCharset,
+                                  const char* toCharset) {
+    string result;
+    const char* bufIn = rawData;
+    int nIn = length;
+
+    // If from and to charset are the same, return
+    int ret = strcmp(fromCharset, toCharset);
+    if (ret == 0) {
+        result.append((const char*)bufIn, nIn);
+        return result;
+    }
+
+#ifndef NO_ICONV
+    if (nIn == 0) {
+        return "";
+    }
+    iconv_t cd;
+    // cout<<src<<endl;
+    cd = iconv_open(toCharset, fromCharset);
+
+    // iconv_t cd = iconv_open(StringUtils::GBK, src);
+    if (cd == (iconv_t)-1) {
+        // result.append((const char *)bufIn, nIn);
+        result = "";
+        return result;
+    }
+
+    const int maxOut = 4 * nIn + 1;
+    char* bufOut = new char[maxOut];
+
+    ICONV_CONST char* fromPtr = (ICONV_CONST char*)bufIn;
+    size_t nFrom = nIn;
+    char* toPtr = (char*)bufOut;
+    size_t nTo = maxOut;
+
+    size_t oneway = -1;
+
+    if (nFrom > 0) {
+        // size_t oneway = iconv(cd, &fromPtr, &nFrom, &toPtr, &nTo);
+        oneway = iconv(cd, sloppy<char**>(&fromPtr), &nFrom, sloppy<char**>(&toPtr), &nTo);
+    }
+    iconv_close(cd);
+
+    int nResult = maxOut - nTo;
+    bufOut[nResult] = '\0';
+    result.append((const char*)bufOut);
+    delete[] bufOut;
+
+    // Cannot convert string
+    if (oneway == (size_t)(-1)) {
+        // result.append((const char *)bufIn, nIn);
+        result = "";
+    }
+#else
+    result.append((const char*)bufIn, nIn);
+#endif
+
+    return result;
+}
+
+string StringUtils::guessEncoding(char* bytes, int length) {
+#ifdef USE_UCHARDET
+    if (length < 10) {
+        return guessEncodingZXing(bytes, length);
+    } else {
+        return guessEncodingUCharDet(bytes, length);
+    }
+#else
+    return guessEncodingZXing(bytes, length);
+#endif
+}
+
+#ifdef USE_UCHARDET
+
+string StringUtils::guessEncodingUCharDet(char* bytes, int length) {
+    uchardet_t handle = uchardet_new();
+
+    int retval = uchardet_handle_data(handle, bytes, length);
+
+    if (retval != 0) {
+        fprintf(stderr, "Handle data error.\n");
+        exit(0);
+    }
+
+    uchardet_data_end(handle);
+
+    const char* charset = uchardet_get_charset(handle);
+
+    string charsetStr(charset);
+
+    uchardet_delete(handle);
+
+    if (charsetStr.size() != 0) {
+        return charsetStr;
+    } else {
+        return guessEncodingZXing(bytes, length);
+    }
+
+    // Otherwise, we take a wild guess with platform encoding
+    // return PLATFORM_DEFAULT_ENCODING;
+}
+#endif
+
+string StringUtils::guessEncodingZXing(char* bytes, int length) {
+    //
+    // typedef bool boolean;
+    // For now, merely tries to distinguish ISO-8859-1, UTF-8 and Shift_JIS,
+    // which should be by far the most common encodings.
+    bool canBeISO88591 = true;
+    bool canBeShiftJIS = true;
+    bool canBeUTF8 = true;
+    bool canBeGB2312 = true;
+    bool canBeGBK = true;
+    bool canBeBIG5 = true;
+    bool canBeASCII = true;
+
+    int utf8BytesLeft = 0;
+    int utf2BytesChars = 0;
+    int utf3BytesChars = 0;
+    int utf4BytesChars = 0;
+    int sjisBytesLeft = 0;
+    int sjisKatakanaChars = 0;
+    int sjisCurKatakanaWordLength = 0;
+    int sjisCurDoubleBytesWordLength = 0;
+    int sjisMaxKatakanaWordLength = 0;
+    int sjisMaxDoubleBytesWordLength = 0;
+    int isoHighOther = 0;
+
+    int gb2312SCByteChars = 0;
+    int big5TWBytesChars = 0;
+
+    bool utf8bom = length > 3 && (unsigned char)bytes[0] == 0xEF &&
+                   (unsigned char)bytes[1] == 0xBB && (unsigned char)bytes[2] == 0xBF;
+
+    for (int i = 0; i < length && (canBeISO88591 || canBeShiftJIS || canBeUTF8 || canBeGBK); i++) {
+        int value = bytes[i] & 0xFF;
+
+        // UTF-8 stuff
+        if (canBeUTF8) {
+            if (utf8BytesLeft > 0) {
+                if ((value & 0x80) == 0) {
+                    canBeUTF8 = false;
+                } else {
+                    utf8BytesLeft--;
+                }
+            } else if ((value & 0x80) != 0) {
+                if ((value & 0x40) == 0) {
+                    canBeUTF8 = false;
+                } else {
+                    utf8BytesLeft++;
+                    if ((value & 0x20) == 0) {
+                        utf2BytesChars++;
+                    } else {
+                        utf8BytesLeft++;
+                        if ((value & 0x10) == 0) {
+                            utf3BytesChars++;
+                        } else {
+                            utf8BytesLeft++;
+                            if ((value & 0x08) == 0) {
+                                utf4BytesChars++;
+                            } else {
+                                canBeUTF8 = false;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Shift_JIS stuff
+        if (canBeShiftJIS) {
+            if (sjisBytesLeft > 0) {
+                if (value < 0x40 || value == 0x7F || value > 0xFC) {
+                    canBeShiftJIS = false;
+                } else {
+                    sjisBytesLeft--;
+                }
+            } else if (value == 0x80 || value == 0xA0 || value > 0xEF) {
+                canBeShiftJIS = false;
+            } else if (value > 0xA0 && value < 0xE0) {
+                sjisKatakanaChars++;
+                sjisCurDoubleBytesWordLength = 0;
+                sjisCurKatakanaWordLength++;
+                if (sjisCurKatakanaWordLength > sjisMaxKatakanaWordLength) {
+                    sjisMaxKatakanaWordLength = sjisCurKatakanaWordLength;
+                }
+            } else if (value > 0x7F) {
+                sjisBytesLeft++;
+                // sjisDoubleBytesChars++;
+                sjisCurKatakanaWordLength = 0;
+                sjisCurDoubleBytesWordLength++;
+                if (sjisCurDoubleBytesWordLength > sjisMaxDoubleBytesWordLength) {
+                    sjisMaxDoubleBytesWordLength = sjisCurDoubleBytesWordLength;
+                }
+            } else {
+                // sjisLowChars++;
+                sjisCurKatakanaWordLength = 0;
+                sjisCurDoubleBytesWordLength = 0;
+            }
+        }
+
+        // ISO-8859-1 stuff
+        if (canBeISO88591) {
+            if (value > 0x7F && value < 0xA0) {
+                canBeISO88591 = false;
+            } else if (value > 0x9F) {
+                if (value < 0xC0 || value == 0xD7 || value == 0xF7) {
+                    isoHighOther++;
+                }
+            }
+        }
+    }
+
+    // Get how many chinese sc & tw words
+    gb2312SCByteChars = is_gb2312_code(bytes, length);
+    big5TWBytesChars = is_big5_code(bytes, length);
+
+    if (gb2312SCByteChars <= 0) {
+        canBeGB2312 = false;
+    }
+
+    if (big5TWBytesChars <= 0) {
+        canBeBIG5 = false;
+    }
+
+    if (!is_gbk_code(bytes, length)) {
+        canBeGBK = false;
+    }
+
+    if (canBeUTF8 && utf8BytesLeft > 0) {
+        canBeUTF8 = false;
+    }
+    if (canBeShiftJIS && sjisBytesLeft > 0) {
+        canBeShiftJIS = false;
+    }
+
+    if (is_ascii_code(bytes, length) <= 0) {
+        canBeASCII = false;
+    }
+
+    // Easy -- if there is BOM or at least 1 valid not-single byte character
+    // (and no evidence it can't be UTF-8), done
+    if (canBeUTF8 && (utf8bom || utf2BytesChars + utf3BytesChars + utf4BytesChars > 0)) {
+        return UTF8;
+    }
+
+    // if ( canBeBIG5 == false && canBeGB2312 == false )
+    int chineseWordLen =
+        gb2312SCByteChars > big5TWBytesChars ? gb2312SCByteChars : big5TWBytesChars;
+    int chineseByteLen = chineseWordLen * 2;
+    int japaneseByteLen = sjisMaxKatakanaWordLength + sjisMaxDoubleBytesWordLength * 2;
+
+    // if ( chineseByteLen < japaneseByteLen || (japaneseByteLen == 0 &&
+    // chineseByteLen == 0) ) if ( (gb2312SCByteChars < sjisKatakanaChars) &&
+    // (big5TWBytesChars < sjisKatakanaChars) )
+    //{
+    // Easy -- if assuming Shift_JIS or at least 3 valid consecutive not-ascii
+    // characters (and no evidence it can't be), done
+    if (canBeShiftJIS &&
+        (ASSUME_SHIFT_JIS || sjisMaxKatakanaWordLength >= 3 || sjisMaxDoubleBytesWordLength >= 3)) {
+        // return SHIFT_JIS;
+        if (chineseByteLen <= japaneseByteLen) {
+            if (chineseByteLen == japaneseByteLen) {
+                if (chineseWordLen < sjisKatakanaChars) {
+                    return SHIFT_JIS;
+                }
+            } else {
+                return SHIFT_JIS;
+            }
+        }
+    }
+
+    // Distinguishing Shift_JIS and ISO-8859-1 can be a little tough for short
+    // words. The crude heuristic is:
+    // - If we saw
+    //   - only two consecutive katakana chars in the whole text, or
+    //   - at least 10% of bytes that could be "upper" not-alphanumeric Latin1,
+    // - then we conclude Shift_JIS, else ISO-8859-1
+    if (canBeISO88591 && canBeShiftJIS) {
+        if ((sjisMaxKatakanaWordLength == 2 && sjisKatakanaChars == 2) ||
+            isoHighOther * 10 >= length) {
+            /*
+            if ( chineseByteLen < japaneseByteLen )
+            {
+                return SHIFT_JIS;
+            }
+            */
+            if (chineseByteLen <= japaneseByteLen) {
+                if (chineseByteLen == japaneseByteLen) {
+                    if (chineseWordLen < sjisKatakanaChars) {
+                        return SHIFT_JIS;
+                    }
+                } else {
+                    return SHIFT_JIS;
+                }
+            }
+        } else {
+            if (chineseByteLen <= 0 && !canBeGB2312 && !canBeBIG5) {
+                return ISO88591;
+            }
+        }
+    }
+    //}
+
+    // Otherwise, try in order ISO-8859-1, Shift JIS, UTF-8 and fall back to
+    // default platform encoding
+    if (canBeGB2312) {
+        return GB2312;
+    }
+
+    if (canBeBIG5) {
+        return BIG5;
+    }
+
+    if (canBeShiftJIS) {
+        return SHIFT_JIS;
+    }
+
+    if (canBeGBK) {
+        return GBK;
+    }
+
+    if (canBeISO88591) {
+        return ISO88591;
+    }
+
+    if (canBeUTF8) {
+        return UTF8;
+    }
+
+    if (canBeASCII) {
+        return ASCII;
+    }
+
+    // Otherwise, we take a wild guess with platform encoding
+    return PLATFORM_DEFAULT_ENCODING;
+}
+
+// judge the byte whether begin with binary 10
+int StringUtils::is_utf8_special_byte(unsigned char c) {
+    unsigned char special_byte = 0X02;  // binary 00000010
+    if (c >> 6 == special_byte) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+int StringUtils::is_utf8_code(char* str, int length) {
+    unsigned char one_byte = 0X00;    // binary 00000000
+    unsigned char two_byte = 0X06;    // binary 00000110
+    unsigned char three_byte = 0X0E;  // binary 00001110
+    unsigned char four_byte = 0X1E;   // binary 00011110
+    unsigned char five_byte = 0X3E;   // binary 00111110
+    unsigned char six_byte = 0X7E;    // binary 01111110
+
+    int utf8_yes = 0;
+    int utf8_no = 0;
+
+    unsigned char k = 0;
+    unsigned char m = 0;
+    unsigned char n = 0;
+    unsigned char p = 0;
+    unsigned char q = 0;
+
+    unsigned char c = 0;
+    for (int i = 0; i < length;) {
+        c = (unsigned char)str[i];
+        if (c >> 7 == one_byte) {
+            i++;
+            continue;
+        } else if (c >> 5 == two_byte) {
+            k = (unsigned char)str[i + 1];
+            if (is_utf8_special_byte(k)) {
+                utf8_yes++;
+                i += 2;
+                continue;
+            }
+        } else if (c >> 4 == three_byte) {
+            m = (unsigned char)str[i + 1];
+            n = (unsigned char)str[i + 2];
+            if (is_utf8_special_byte(m) && is_utf8_special_byte(n)) {
+                utf8_yes++;
+                i += 3;
+                continue;
+            }
+        } else if (c >> 3 == four_byte) {
+            k = (unsigned char)str[i + 1];
+            m = (unsigned char)str[i + 2];
+            n = (unsigned char)str[i + 3];
+            if (is_utf8_special_byte(k) && is_utf8_special_byte(m) && is_utf8_special_byte(n)) {
+                utf8_yes++;
+                i += 4;
+                continue;
+            }
+        } else if (c >> 2 == five_byte) {
+            k = (unsigned char)str[i + 1];
+            m = (unsigned char)str[i + 2];
+            n = (unsigned char)str[i + 3];
+            p = (unsigned char)str[i + 4];
+            if (is_utf8_special_byte(k) && is_utf8_special_byte(m) && is_utf8_special_byte(n) &&
+                is_utf8_special_byte(p)) {
+                utf8_yes++;
+                i += 5;
+                continue;
+            }
+        } else if (c >> 1 == six_byte) {
+            k = (unsigned char)str[i + 1];
+            m = (unsigned char)str[i + 2];
+            n = (unsigned char)str[i + 3];
+            p = (unsigned char)str[i + 4];
+            q = (unsigned char)str[i + 5];
+            if (is_utf8_special_byte(k) && is_utf8_special_byte(m) && is_utf8_special_byte(n) &&
+                is_utf8_special_byte(p) && is_utf8_special_byte(q)) {
+                utf8_yes++;
+                i += 6;
+                continue;
+            }
+        }
+
+        utf8_no++;
+        i++;
+    }
+
+    // printf("uft8_yes: %d utf8_no:%d\n", utf8_yes, utf8_no);
+    if ((utf8_yes + utf8_no) != 0) {
+        int ret = (100 * utf8_yes) / (utf8_yes + utf8_no);
+        if (ret > 90) {
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+    return 0;
+}
+int StringUtils::is_gb2312_code(char* str, int length) {
+    unsigned char one_byte = 0X00;  // binary 00000000
+
+    int gb2312_yes = 0;
+    int gb2312_no = 0;
+
+    unsigned char k = 0;
+
+    unsigned char c = 0;
+    for (int i = 0; i < length;) {
+        c = (unsigned char)str[i];
+        if (c >> 7 == one_byte) {
+            i++;
+            continue;
+        } else if (c >= 0XA1 && c <= 0XF7) {
+            k = (unsigned char)str[i + 1];
+            if (k >= 0XA1 && k <= 0XFE) {
+                gb2312_yes++;
+                i += 2;
+                continue;
+            }
+        }
+
+        gb2312_no++;
+        i += 2;
+    }
+
+    // printf("gb2312_yes: %d gb2312_no:%d\n", gb2312_yes, gb2312_no);
+    if ((gb2312_yes + gb2312_no) > 0) {
+        int ret = (100 * gb2312_yes) / (gb2312_yes + gb2312_no);
+        if (ret == 100) {
+            // if (ret > 90) {
+            // gb2312SCByteChars = gb2312_yes;
+            return gb2312_yes;
+        } else {
+            return 0;
+        }
+    }
+    return 0;
+}
+
+int StringUtils::is_big5_code(char* str, int length) {
+    unsigned char one_byte = 0X00;  // binary 00000000
+
+    int big5_yes = 0;
+    int big5_no = 0;
+
+    unsigned char k = 0;
+
+    unsigned char c = 0;
+    for (int i = 0; i < length;) {
+        c = (unsigned char)str[i];
+        if (c >> 7 == one_byte) {
+            i++;
+            continue;
+        } else if (c >= 0XA1 && c <= 0XF9) {
+            k = (unsigned char)str[i + 1];
+            if ((k >= 0X40 && k <= 0X7E) || (k >= 0XA1 && k <= 0XFE)) {
+                big5_yes++;
+                i += 2;
+                continue;
+            }
+        }
+
+        big5_no++;
+        i += 2;
+    }
+
+    // printf("%d %d\n", big5_yes, big5_no);
+    if ((big5_yes + big5_no) > 0) {
+        int ret = (100 * big5_yes) / (big5_yes + big5_no);
+        if (ret == 100) {
+            // if (ret > 90) {
+            // big5TWBytesChars = big5_yes;
+            return big5_yes;
+        } else {
+            return 0;
+        }
+    }
+    return 0;
+}
+
+int StringUtils::is_gbk_code(char* str, int length) {
+    unsigned char one_byte = 0X00;  // binary 00000000
+
+    int gbk_yes = 0;
+    int gbk_no = 0;
+
+    unsigned char k = 0;
+
+    unsigned char c = 0;
+    for (int i = 0; i < length;) {
+        c = (unsigned char)str[i];
+        if (c >> 7 == one_byte) {
+            i++;
+            continue;
+        } else if (c >= 0X81 && c <= 0XFE) {
+            k = (unsigned char)str[i + 1];
+            if (k >= 0X40 && k <= 0XFE) {
+                gbk_yes++;
+                i += 2;
+                continue;
+            }
+        }
+
+        gbk_no++;
+        i += 2;
+    }
+
+    // printf("gbk_yes: %d gbk_no:%d\n", gbk_yes, gbk_no);
+    if ((gbk_yes + gbk_no) > 0) {
+        int ret = (100 * gbk_yes) / (gbk_yes + gbk_no);
+        if (ret == 100) {
+            // if (ret > 90) {
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+    return 0;
+}
+
+int StringUtils::is_ascii_code(char* str, int length) {
+    unsigned char c = 0;
+
+    bool isASCII = true;
+
+    for (int i = 0; i < length; i++) {
+        c = (unsigned char)str[i];
+
+        if ((c > 127)) {
+            isASCII = false;
+        }
+    }
+    return (isASCII ? 1 : -1);
+}
+
+//#define DEBUG
+
+int StringUtils::shift_jis_to_jis(const unsigned char* may_be_shift_jis, int* jis_first_ptr,
+                                  int* jis_second_ptr) {
+    int status = 0;
+    unsigned char first = may_be_shift_jis[0];
+    unsigned char second = may_be_shift_jis[1];
+    int jis_first = 0;
+    int jis_second = 0;
+    /* Check first byte is valid shift JIS. */
+    if ((first >= 0x81 && first <= 0x84) || (first >= 0x87 && first <= 0x9f)) {
+        jis_first = 2 * (first - 0x70) - 1;
+        if (second >= 0x40 && second <= 0x9e) {
+            jis_second = second - 31;
+            if (jis_second > 95) {
+                jis_second -= 1;
+            }
+
+            status = 1;
+        } else if (second >= 0x9f && second <= 0xfc) {
+            jis_second = second - 126;
+            jis_first += 1;
+            status = 1;
+        } else {
+        }
+    } else if (first >= 0xe0 && first <= 0xef) {
+        jis_first = 2 * (first - 0xb0) - 1;
+        if (second >= 0x40 && second <= 0x9e) {
+            jis_second = second - 31;
+            if (jis_second > 95) {
+                jis_second -= 1;
+            }
+            status = 1;
+        } else if (second >= 0x9f && second <= 0xfc) {
+            jis_second = second - 126;
+            jis_first += 1;
+            status = 1;
+        }
+    } else {
+    }
+    *jis_first_ptr = jis_first;
+    *jis_second_ptr = jis_second;
+    return status;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/stringutils.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/stringutils.hpp
new file mode 100644
index 00000000..cf58cbd4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/stringutils.hpp
@@ -0,0 +1,65 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_COMMON_STRINGUTILS_HPP__
+#define __ZXING_COMMON_STRINGUTILS_HPP__
+
+#include "../decodehints.hpp"
+#include "../zxing.hpp"
+
+#include <map>
+#include <string>
+
+namespace zxing {
+namespace common {
+class StringUtils;
+}
+}  // namespace zxing
+using namespace std;
+
+class zxing::common::StringUtils {
+private:
+    static char const* const PLATFORM_DEFAULT_ENCODING;
+
+public:
+    static char const* const ASCII;
+    static char const* const SHIFT_JIS;
+    static char const* const GB2312;
+    static char const* const EUC_JP;
+    static char const* const UTF8;
+    static char const* const ISO88591;
+    static char const* const GBK;
+    static char const* const GB18030;
+    static char const* const BIG5;
+
+    static const bool ASSUME_SHIFT_JIS;
+
+    static std::string guessEncoding(char* bytes, int length);
+    static std::string guessEncodingZXing(char* bytes, int length);
+
+#ifdef USE_UCHARDET
+    static std::string guessEncodingUCharDet(char* bytes, int length);
+#endif
+
+    static int is_utf8_special_byte(unsigned char c);
+    // static int is_utf8_code(const string& str);
+    static int is_utf8_code(char* str, int length);
+    static int is_gb2312_code(char* str, int length);
+    static int is_big5_code(char* str, int length);
+    static int is_gbk_code(char* str, int length);
+    static int is_ascii_code(char* str, int length);
+    static int shift_jis_to_jis(const unsigned char* may_be_shift_jis, int* jis_first_ptr,
+                                int* jis_second_ptr);
+
+    static std::string convertString(const char* rawData, int length, const char* fromCharset,
+                                     const char* toCharset);
+};
+
+#endif  // __ZXING_COMMON_STRINGUTILS_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/unicomblock.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/unicomblock.cpp
new file mode 100644
index 00000000..652458e9
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/unicomblock.cpp
@@ -0,0 +1,127 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "../../precomp.hpp"
+#include "unicomblock.hpp"
+
+namespace zxing {
+short UnicomBlock::SEARCH_POS[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+UnicomBlock::UnicomBlock(int iMaxHeight, int iMaxWidth)
+    : m_iHeight(iMaxHeight), m_iWidth(iMaxWidth), m_bInit(false) {}
+
+UnicomBlock::~UnicomBlock() {}
+
+void UnicomBlock::Init() {
+    if (m_bInit) return;
+    m_vcIndex = std::vector<unsigned int>(m_iHeight * m_iWidth, 0);
+    m_vcCount = std::vector<unsigned int>(m_iHeight * m_iWidth, 0);
+    m_vcMinPnt = std::vector<int>(m_iHeight * m_iWidth, 0);
+    m_vcMaxPnt = std::vector<int>(m_iHeight * m_iWidth, 0);
+    m_vcQueue = std::vector<int>(m_iHeight * m_iWidth, 0);
+    m_bInit = true;
+}
+
+void UnicomBlock::Reset(Ref<BitMatrix> poImage) {
+    m_poImage = poImage;
+    memset(&m_vcIndex[0], 0, m_vcIndex.size() * sizeof(short));
+    m_iNowIdx = 0;
+}
+
+unsigned short UnicomBlock::GetUnicomBlockIndex(int y, int x) {
+    if (y >= m_iHeight || x >= m_iWidth) return 0;
+    if (m_vcIndex[y * m_iWidth + x]) return m_vcIndex[y * m_iWidth + x];
+    Bfs(y, x);
+    return m_vcIndex[y * m_iWidth + x];
+}
+
+int UnicomBlock::GetUnicomBlockSize(int y, int x) {
+    if (y >= m_iHeight || x >= m_iWidth) return 0;
+    if (m_vcIndex[y * m_iWidth + x]) return m_vcCount[y * m_iWidth + x];
+    Bfs(y, x);
+    return m_vcCount[y * m_iWidth + x];
+}
+
+int UnicomBlock::GetMinPoint(int y, int x, int &iMinY, int &iMinX) {
+    if (y >= m_iHeight || x >= m_iWidth) return -1;
+    if (m_vcIndex[y * m_iWidth + x]) {
+        iMinY = m_vcMinPnt[y * m_iWidth + x] >> 16;
+        iMinX = m_vcMinPnt[y * m_iWidth + x] & (0xFFFF);
+        return 0;
+    }
+    Bfs(y, x);
+    iMinY = m_vcMinPnt[y * m_iWidth + x] >> 16;
+    iMinX = m_vcMinPnt[y * m_iWidth + x] & (0xFFFF);
+    return 0;
+}
+
+int UnicomBlock::GetMaxPoint(int y, int x, int &iMaxY, int &iMaxX) {
+    if (y >= m_iHeight || x >= m_iWidth) return -1;
+    if (m_vcIndex[y * m_iWidth + x]) {
+        iMaxY = m_vcMaxPnt[y * m_iWidth + x] >> 16;
+        iMaxX = m_vcMaxPnt[y * m_iWidth + x] & (0xFFFF);
+        return 0;
+    }
+    Bfs(y, x);
+    iMaxY = m_vcMaxPnt[y * m_iWidth + x] >> 16;
+    iMaxX = m_vcMaxPnt[y * m_iWidth + x] & (0xFFFF);
+    return 0;
+}
+
+void UnicomBlock::Bfs(int y, int x) {
+    m_iNowIdx++;
+
+    int iFront = 0;
+    int iTail = 0;
+    int iCount = 1;
+
+    int iMaxX = x, iMaxY = y;
+    int iMinX = x, iMinY = y;
+
+    const bool bValue = (m_poImage->get(x, y) != (unsigned char)0);
+
+    m_vcIndex[y * m_iWidth + x] = m_iNowIdx;
+    m_vcQueue[iTail++] = y << 16 | x;
+
+    while (iFront < iTail) {
+        int iNode = m_vcQueue[iFront++];
+        int iX = iNode & (0xFFFF);
+        int iY = iNode >> 16;
+        iMaxX = max(iX, iMaxX);
+        iMaxY = max(iY, iMaxY);
+        iMinX = min(iX, iMinX);
+        iMinY = min(iY, iMinY);
+
+        iCount++;
+
+        for (int i = 0; i < 4; ++i) {
+            const int iNextX = iX + SEARCH_POS[i][0], iNextY = iY + SEARCH_POS[i][1];
+            const int iPosition = iNextY * m_iWidth + iNextX;
+
+            if (iPosition >= 0 && iPosition < int(m_vcIndex.size()) && 0 == m_vcIndex[iPosition]) {
+                if (iNextX < 0 || iNextX >= m_poImage->getWidth() || iNextY < 0 ||
+                    iNextY >= m_poImage->getHeight() ||
+                    bValue != (m_poImage->get(iNextX, iNextY) != (unsigned char)0))
+                    continue;
+
+                m_vcIndex[iPosition] = m_iNowIdx;
+                m_vcQueue[iTail++] = iNextY << 16 | iNextX;
+            }
+        }
+    }
+
+    if (iCount >= (1 << 16) - 1) iCount = 0xFFFF;
+
+    const int iMinCombine = iMinY << 16 | iMinX;
+    const int iMaxCombine = iMaxY << 16 | iMaxX;
+    for (int i = 0; i < iTail; ++i) {
+        const int iPosition = (m_vcQueue[i] >> 16) * m_iWidth + (m_vcQueue[i] & (0xFFFF));
+
+        m_vcCount[iPosition] = iCount;
+        m_vcMinPnt[iPosition] = iMinCombine;
+        m_vcMaxPnt[iPosition] = iMaxCombine;
+    }
+}
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/unicomblock.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/unicomblock.hpp
new file mode 100644
index 00000000..28eedbdd
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/common/unicomblock.hpp
@@ -0,0 +1,47 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __ZXING_COMMON_UNICOMBLOCK_HPP__
+#define __ZXING_COMMON_UNICOMBLOCK_HPP__
+#include "bitmatrix.hpp"
+#include "counted.hpp"
+
+namespace zxing {
+class UnicomBlock : public Counted {
+public:
+    UnicomBlock(int iMaxHeight, int iMaxWidth);
+    ~UnicomBlock();
+
+    void Init();
+    void Reset(Ref<BitMatrix> poImage);
+
+    unsigned short GetUnicomBlockIndex(int y, int x);
+
+    int GetUnicomBlockSize(int y, int x);
+
+    int GetMinPoint(int y, int x, int &iMinY, int &iMinX);
+    int GetMaxPoint(int y, int x, int &iMaxY, int &iMaxX);
+
+private:
+    void Bfs(int y, int x);
+
+    int m_iHeight;
+    int m_iWidth;
+
+    unsigned int m_iNowIdx;
+    bool m_bInit;
+    std::vector<unsigned int> m_vcIndex;
+    std::vector<unsigned int> m_vcCount;
+    std::vector<int> m_vcMinPnt;
+    std::vector<int> m_vcMaxPnt;
+    std::vector<int> m_vcQueue;
+    static short SEARCH_POS[4][2];
+
+    Ref<BitMatrix> m_poImage;
+};
+}  // namespace zxing
+#endif  // __ZXING_COMMON_UNICOMBLOCK_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/decodehints.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/decodehints.hpp
new file mode 100644
index 00000000..ed1830b5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/decodehints.hpp
@@ -0,0 +1,30 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_DECODEHINTS_HPP__
+#define __ZXING_DECODEHINTS_HPP__
+
+#include "errorhandler.hpp"
+
+namespace zxing {
+class DecodeHints {
+private:
+    bool use_nn_detector_;
+
+public:
+    explicit DecodeHints(bool use_nn_detector = false) : use_nn_detector_(use_nn_detector){};
+
+    bool getUseNNDetector() const { return use_nn_detector_; }
+    void setUseNNDetector(bool use_nn_detector) { use_nn_detector_ = use_nn_detector; }
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_DECODEHINTS_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/errorhandler.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/errorhandler.cpp
new file mode 100644
index 00000000..c8604ab6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/errorhandler.cpp
@@ -0,0 +1,49 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+#include "../precomp.hpp"
+#include "errorhandler.hpp"
+
+namespace zxing {
+
+ErrorHandler::ErrorHandler() : err_code_(0), err_msg_("") { Init(); }
+
+ErrorHandler::ErrorHandler(const char* err_msg) : err_code_(-1), err_msg_(err_msg) { Init(); }
+
+ErrorHandler::ErrorHandler(std::string& err_msg) : err_code_(-1), err_msg_(err_msg) { Init(); }
+
+ErrorHandler::ErrorHandler(int err_code) : err_code_(err_code), err_msg_("error") { Init(); }
+
+ErrorHandler::ErrorHandler(int err_code, const char* err_msg)
+    : err_code_(err_code), err_msg_(err_msg) {
+    Init();
+}
+
+ErrorHandler::ErrorHandler(const ErrorHandler& other) {
+    err_code_ = other.ErrCode();
+    err_msg_.assign(other.ErrMsg());
+    Init();
+}
+
+ErrorHandler& ErrorHandler::operator=(const ErrorHandler& other) {
+    err_code_ = other.ErrCode();
+    err_msg_.assign(other.ErrMsg());
+    Init();
+    return *this;
+}
+
+void ErrorHandler::Init() { handler_type_ = KErrorHandler; }
+
+void ErrorHandler::Reset() {
+    err_code_ = 0;
+    err_msg_.assign("");
+}
+
+void ErrorHandler::PrintInfo() {
+    printf("handler_tpye %d, error code %d, errmsg %s\n", handler_type_, err_code_,
+           err_msg_.c_str());
+}
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/errorhandler.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/errorhandler.hpp
new file mode 100644
index 00000000..486786b0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/errorhandler.hpp
@@ -0,0 +1,89 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __ZXING_ERRORHANDLER_HPP__
+#define __ZXING_ERRORHANDLER_HPP__
+
+#include <string>
+
+namespace zxing {
+
+enum {
+    KErrorHandler = 0,
+    KErrorHandler_NotFound = 1,
+    KErrorHandler_CheckSum = 2,
+    KErrorHandler_Reader = 3,
+    KErrorHandler_IllegalArgument = 4,
+    KErrorHandler_ReedSolomon = 5,
+    KErrorHandler_Format = 6,
+    KErrorHandler_Detector = 7,
+    KErrorHandler_IllegalState = 8,
+};
+
+class ErrorHandler {
+public:
+    ErrorHandler();
+    explicit ErrorHandler(std::string& err_msg);
+    explicit ErrorHandler(const char* err_msg);
+    explicit ErrorHandler(int err_code);
+    ErrorHandler(int err_code, std::string& err_msg);
+    ErrorHandler(int err_code, const char* err_msg);
+
+    virtual ~ErrorHandler(){};
+
+    virtual inline int ErrCode() const { return err_code_; }
+    virtual inline const std::string& ErrMsg() const { return err_msg_; }
+    virtual inline int HandlerType() const { return handler_type_; }
+
+    virtual void Init();
+    ErrorHandler(const ErrorHandler& other);
+    ErrorHandler& operator=(const ErrorHandler& other);
+
+    virtual void PrintInfo();
+    virtual void Reset();
+
+protected:
+    int handler_type_;
+
+private:
+    int err_code_;
+    std::string err_msg_;
+};
+
+#define DECLARE_ERROR_HANDLER(__HANDLER__)                                                      \
+    class __HANDLER__##ErrorHandler : public ErrorHandler {                                     \
+    public:                                                                                     \
+        __HANDLER__##ErrorHandler() : ErrorHandler() { Init(); };                               \
+        __HANDLER__##ErrorHandler(std::string& err_msg) : ErrorHandler(err_msg) { Init(); };    \
+        __HANDLER__##ErrorHandler(const char* err_msg) : ErrorHandler(err_msg) { Init(); };     \
+        __HANDLER__##ErrorHandler(int err_code) : ErrorHandler(err_code) { Init(); };           \
+        __HANDLER__##ErrorHandler(int err_code, std::string& err_msg)                           \
+            : ErrorHandler(err_code, err_msg) {                                                 \
+            Init();                                                                             \
+        };                                                                                      \
+        __HANDLER__##ErrorHandler(int err_code, const char* err_msg)                            \
+            : ErrorHandler(err_code, err_msg) {                                                 \
+            Init();                                                                             \
+        };                                                                                      \
+        __HANDLER__##ErrorHandler(const ErrorHandler& other) : ErrorHandler(other) { Init(); }; \
+        void Init() override { handler_type_ = KErrorHandler_##__HANDLER__; }                            \
+    };
+
+DECLARE_ERROR_HANDLER(Reader)
+DECLARE_ERROR_HANDLER(IllegalArgument)
+DECLARE_ERROR_HANDLER(ReedSolomon)
+DECLARE_ERROR_HANDLER(Format)
+DECLARE_ERROR_HANDLER(Detector)
+DECLARE_ERROR_HANDLER(NotFound)
+DECLARE_ERROR_HANDLER(CheckSum)
+DECLARE_ERROR_HANDLER(IllegalState)
+
+#undef DECLARE_ERROR_HANDLER
+
+}  // namespace zxing
+
+#endif  // __ZXING_ERRORHANDLER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/luminance_source.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/luminance_source.cpp
new file mode 100644
index 00000000..bb0b41b5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/luminance_source.cpp
@@ -0,0 +1,59 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../precomp.hpp"
+#include "luminance_source.hpp"
+#include <sstream>
+
+using zxing::LuminanceSource;
+using zxing::Ref;
+
+LuminanceSource::LuminanceSource(int width, int height)
+    : width_(width), height_(height) {}
+
+LuminanceSource::~LuminanceSource() {}
+
+bool LuminanceSource::isCropSupported() const { return false; }
+
+Ref<LuminanceSource> LuminanceSource::crop(int, int, int, int, zxing::ErrorHandler&) const {
+    return Ref<LuminanceSource>();
+}
+
+bool LuminanceSource::isRotateSupported() const { return false; }
+
+Ref<LuminanceSource> LuminanceSource::rotateCounterClockwise(zxing::ErrorHandler&) const {
+    return Ref<LuminanceSource>();
+}
+
+LuminanceSource::operator std::string() const {
+    ArrayRef<char> row;
+    std::ostringstream oss;
+    zxing::ErrorHandler err_handler;
+    for (int y = 0; y < getHeight(); y++) {
+        err_handler.Reset();
+        row = getRow(y, row, err_handler);
+        if (err_handler.ErrCode()) continue;
+        for (int x = 0; x < getWidth(); x++) {
+            int luminance = row[x] & 0xFF;
+            char c;
+            if (luminance < 0x40) {
+                c = '#';
+            } else if (luminance < 0x80) {
+                c = '+';
+            } else if (luminance < 0xC0) {
+                c = '.';
+            } else {
+                c = ' ';
+            }
+            oss << c;
+        }
+        oss << '\n';
+    }
+    return oss.str();
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/luminance_source.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/luminance_source.hpp
new file mode 100644
index 00000000..e3435723
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/luminance_source.hpp
@@ -0,0 +1,57 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_LUMINANCE_SOURCE_HPP__
+#define __ZXING_LUMINANCE_SOURCE_HPP__
+
+#include <string.h>
+#include "common/array.hpp"
+#include "common/bytematrix.hpp"
+#include "common/counted.hpp"
+#include "errorhandler.hpp"
+
+namespace zxing {
+
+class LuminanceSource : public Counted {
+protected:
+    int width_;
+    int height_;
+
+public:
+    LuminanceSource(int width, int height);
+    virtual ~LuminanceSource();
+
+    int getWidth() const { return width_; }
+    int getHeight() const { return height_; }
+    void setWidth(int w) { width_ = w; }
+    void setHeight(int h) { height_ = h; }
+    void filter();
+
+    // Callers take ownership of the returned memory and must call delete [] on
+    // it themselves.
+    virtual ArrayRef<char> getRow(int y, ArrayRef<char> row,
+                                  zxing::ErrorHandler& err_handler) const = 0;
+    virtual ArrayRef<char> getMatrix() const = 0;
+    virtual Ref<ByteMatrix> getByteMatrix() const = 0;
+
+    virtual bool isCropSupported() const;
+    virtual Ref<LuminanceSource> crop(int left, int top, int width, int height,
+                                      zxing::ErrorHandler& err_handler) const;
+
+    virtual bool isRotateSupported() const;
+
+    virtual Ref<LuminanceSource> rotateCounterClockwise(zxing::ErrorHandler& err_handler) const;
+
+    operator std::string() const;
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_LUMINANCE_SOURCE_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/bitmatrixparser.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/bitmatrixparser.cpp
new file mode 100644
index 00000000..6d426d07
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/bitmatrixparser.cpp
@@ -0,0 +1,240 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "bitmatrixparser.hpp"
+#include "datamask.hpp"
+
+using zxing::ErrorHandler;
+
+namespace zxing {
+namespace qrcode {
+
+int BitMatrixParser::copyBit(size_t x, size_t y, int versionBits) {
+    bool bit = ((mirror_ ? bitMatrix_->get(y, x) : bitMatrix_->get(x, y)) != (unsigned char)0);
+    return bit ? (versionBits << 1) | 0x1 : versionBits << 1;
+}
+
+BitMatrixParser::BitMatrixParser(Ref<BitMatrix> bitMatrix, ErrorHandler &err_handler)
+    : bitMatrix_(bitMatrix), parsedVersion_(0), parsedFormatInfo_() {
+    mirror_ = false;
+    size_t dimension = bitMatrix->getHeight();
+
+    if ((dimension < 21) || (dimension & 0x03) != 1) {
+        err_handler = zxing::ReaderErrorHandler("Dimension must be 1 mod 4 and >= 21");
+        return;
+    }
+}
+
+Ref<FormatInformation> BitMatrixParser::readFormatInformation(ErrorHandler &err_handler) {
+    if (parsedFormatInfo_ != 0) {
+        return parsedFormatInfo_;
+    }
+
+    // Read top-left format info bits
+    int formatInfoBits1 = 0;
+    for (int i = 0; i < 6; i++) {
+        formatInfoBits1 = copyBit(i, 8, formatInfoBits1);
+    }
+    // .. and skip a bit in the timing pattern ...
+    formatInfoBits1 = copyBit(7, 8, formatInfoBits1);
+    formatInfoBits1 = copyBit(8, 8, formatInfoBits1);
+    formatInfoBits1 = copyBit(8, 7, formatInfoBits1);
+    // .. and skip a bit in the timing pattern ...
+    for (int j = 5; j >= 0; j--) {
+        formatInfoBits1 = copyBit(8, j, formatInfoBits1);
+    }
+
+    // Read the top-right/bottom-left pattern
+    int dimension = bitMatrix_->getHeight();
+    int formatInfoBits2 = 0;
+    int jMin = dimension - 7;
+    for (int j = dimension - 1; j >= jMin; j--) {
+        formatInfoBits2 = copyBit(8, j, formatInfoBits2);
+    }
+    for (int i = dimension - 8; i < dimension; i++) {
+        formatInfoBits2 = copyBit(i, 8, formatInfoBits2);
+    }
+
+    parsedFormatInfo_ =
+        FormatInformation::decodeFormatInformation(formatInfoBits1, formatInfoBits2);
+    if (parsedFormatInfo_ != 0) {
+        return parsedFormatInfo_;
+    }
+    err_handler = zxing::ReaderErrorHandler("Could not decode format information");
+    return Ref<FormatInformation>();
+}
+
+Version *BitMatrixParser::readVersion(ErrorHandler &err_handler) {
+    if (parsedVersion_ != 0) {
+        return parsedVersion_;
+    }
+
+    int dimension = bitMatrix_->getHeight();
+
+    int provisionalVersion = (dimension - 17) >> 2;
+    if (provisionalVersion <= 6) {
+        Version *version = Version::getVersionForNumber(provisionalVersion, err_handler);
+        if (err_handler.ErrCode()) return NULL;
+        return version;
+    }
+
+    // Read top-right version info: 3 wide by 6 tall
+    int versionBits = 0;
+    for (int y = 5; y >= 0; y--) {
+        int xMin = dimension - 11;
+        for (int x = dimension - 9; x >= xMin; x--) {
+            versionBits = copyBit(x, y, versionBits);
+        }
+    }
+
+    parsedVersion_ = Version::decodeVersionInformation(versionBits);
+    if (parsedVersion_ != 0 && parsedVersion_->getDimensionForVersion(err_handler) == dimension) {
+        return parsedVersion_;
+    }
+
+    // Hmm, failed. Try bottom left: 6 wide by 3 tall
+    versionBits = 0;
+    for (int x = 5; x >= 0; x--) {
+        int yMin = dimension - 11;
+        for (int y = dimension - 9; y >= yMin; y--) {
+            versionBits = copyBit(x, y, versionBits);
+        }
+    }
+
+    parsedVersion_ = Version::decodeVersionInformation(versionBits);
+    if (parsedVersion_ == NULL) {
+        err_handler = zxing::ReaderErrorHandler("Could not decode version");
+        return NULL;
+    }
+
+    if (parsedVersion_ != 0 && parsedVersion_->getDimensionForVersion(err_handler) == dimension) {
+        return parsedVersion_;
+    }
+
+    err_handler = zxing::ReaderErrorHandler("Could not decode version");
+    return NULL;
+}
+
+/**
+ * <p>Reads the bits in the {@link BitMatrix} representing the finder pattern in
+ * the correct order in order to reconstruct the codewords bytes contained
+ * within the QR Code.</p>
+ *
+ * @return bytes encoded within the QR Code
+ */
+ArrayRef<char> BitMatrixParser::readCodewords(ErrorHandler &err_handler) {
+    Ref<FormatInformation> formatInfo = readFormatInformation(err_handler);
+    if (err_handler.ErrCode()) return ArrayRef<char>();
+
+    Version *version = readVersion(err_handler);
+    if (err_handler.ErrCode()) return ArrayRef<char>();
+
+    DataMask &dataMask = DataMask::forReference((int)formatInfo->getDataMask(), err_handler);
+    if (err_handler.ErrCode()) return ArrayRef<char>();
+    //	cout << (int)formatInfo->getDataMask() << endl;
+    int dimension = bitMatrix_->getHeight();
+
+    dataMask.unmaskBitMatrix(*bitMatrix_, dimension);
+
+    //		cerr << *bitMatrix_ << endl;
+    //	cerr << version->getTotalCodewords() << endl;
+
+    Ref<BitMatrix> functionPattern = version->buildFunctionPattern(err_handler);
+    if (err_handler.ErrCode()) return ArrayRef<char>();
+
+    //	cout << *functionPattern << endl;
+
+    bool readingUp = true;
+    ArrayRef<char> result(version->getTotalCodewords());
+    int resultOffset = 0;
+    int currentByte = 0;
+    int bitsRead = 0;
+    // Read columns in pairs, from right to left
+    for (int x = dimension - 1; x > 0; x -= 2) {
+        if (x == 6) {
+            // Skip whole column with vertical alignment pattern;
+            // saves time and makes the other code proceed more cleanly
+            x--;
+        }
+        // Read alternatingly from bottom to top then top to bottom
+        for (int counter = 0; counter < dimension; counter++) {
+            int y = readingUp ? dimension - 1 - counter : counter;
+            for (int col = 0; col < 2; col++) {
+                // Ignore bits covered by the function pattern
+                if (!functionPattern->get(x - col, y)) {
+                    // Read a bit
+                    bitsRead++;
+                    currentByte <<= 1;
+                    if (bitMatrix_->get(x - col, y)) {
+                        currentByte |= 1;
+                    }
+                    // If we've made a whole byte, save it off
+                    if (bitsRead == 8) {
+                        result[resultOffset++] = (char)currentByte;
+                        bitsRead = 0;
+                        currentByte = 0;
+                    }
+                }
+            }
+        }
+        readingUp = !readingUp;  // switch directions
+    }
+
+    if (resultOffset != version->getTotalCodewords()) {
+        err_handler = zxing::ReaderErrorHandler("Did not read all codewords");
+        return ArrayRef<char>();
+    }
+
+    return result;
+}
+
+/**
+ * Revert the mask removal done while reading the code words. The bit matrix
+ * should revert to its original state.
+ */
+void BitMatrixParser::remask() {
+    if (parsedFormatInfo_ == NULL) {
+        return;  // We have no format information, and have no data mask
+    }
+    ErrorHandler err_handler;
+    DataMask &dataMask = DataMask::forReference(parsedFormatInfo_->getDataMask(), err_handler);
+    if (err_handler.ErrCode()) return;
+    int dimension = bitMatrix_->getHeight();
+    dataMask.unmaskBitMatrix(*bitMatrix_, dimension);
+}
+
+/**
+ * Prepare the parser for a mirrored operation.
+ * This flag has effect only on the {@link #readFormatInformation()} and the
+ * {@link #readVersion()}. Before proceeding with {@link #readCodewords()} the
+ * {@link #mirror()} method should be called.
+ *
+ * @param mirror Whether to read version and format information mirrored.
+ */
+void BitMatrixParser::setMirror(bool mirror) {
+    parsedVersion_ = NULL;
+    parsedFormatInfo_ = NULL;
+    mirror_ = mirror;
+}
+
+/** Mirror the bit matrix in order to attempt a second reading. */
+void BitMatrixParser::mirror() {
+    for (int x = 0; x < bitMatrix_->getWidth(); x++) {
+        for (int y = x + 1; y < bitMatrix_->getHeight(); y++) {
+            if (bitMatrix_->get(x, y) != bitMatrix_->get(y, x)) {
+                bitMatrix_->flip(y, x);
+                bitMatrix_->flip(x, y);
+            }
+        }
+    }
+}
+
+}  // namespace qrcode
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/bitmatrixparser.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/bitmatrixparser.hpp
new file mode 100644
index 00000000..ff5beec1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/bitmatrixparser.hpp
@@ -0,0 +1,53 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DECODER_BITMATRIXPARSER_HPP__
+#define __ZXING_QRCODE_DECODER_BITMATRIXPARSER_HPP__
+
+#include "../../common/array.hpp"
+#include "../../common/bitmatrix.hpp"
+#include "../../common/counted.hpp"
+#include "../../errorhandler.hpp"
+#include "../format_information.hpp"
+#include "../version.hpp"
+
+namespace zxing {
+namespace qrcode {
+
+class BitMatrixParser : public Counted {
+private:
+    Ref<BitMatrix> bitMatrix_;
+    Version *parsedVersion_;
+    Ref<FormatInformation> parsedFormatInfo_;
+    bool mirror_;
+
+    int copyBit(size_t x, size_t y, int versionBits);
+
+public:
+    BitMatrixParser(Ref<BitMatrix> bitMatrix, ErrorHandler &err_handler);
+    Ref<FormatInformation> readFormatInformation(ErrorHandler &err_handler);
+    Version *readVersion(ErrorHandler &err_handler);
+    ArrayRef<char> readCodewords(ErrorHandler &err_handler);
+
+public:
+    void remask();
+    void setMirror(bool mirror);
+    void mirror();
+    void mirrorH();
+
+private:
+    BitMatrixParser(const BitMatrixParser &);
+    BitMatrixParser &operator=(const BitMatrixParser &);
+};
+
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DECODER_BITMATRIXPARSER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datablock.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datablock.cpp
new file mode 100644
index 00000000..da6afaa5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datablock.cpp
@@ -0,0 +1,103 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "datablock.hpp"
+namespace zxing {
+namespace qrcode {
+
+using zxing::ErrorHandler;
+
+DataBlock::DataBlock(int numDataCodewords, ArrayRef<char> codewords)
+    : numDataCodewords_(numDataCodewords), codewords_(codewords) {}
+
+int DataBlock::getNumDataCodewords() { return numDataCodewords_; }
+
+ArrayRef<char> DataBlock::getCodewords() { return codewords_; }
+
+std::vector<Ref<DataBlock> > DataBlock::getDataBlocks(ArrayRef<char> rawCodewords, Version *version,
+                                                      ErrorCorrectionLevel &ecLevel,
+                                                      ErrorHandler &err_handler) {
+    // Figure out the number and size of data blocks used by this version and
+    // error correction level
+    ECBlocks &ecBlocks = version->getECBlocksForLevel(ecLevel);
+
+    // First count the total number of data blocks
+    int totalBlocks = 0;
+    vector<ECB *> ecBlockArray = ecBlocks.getECBlocks();
+    for (size_t i = 0; i < ecBlockArray.size(); i++) {
+        totalBlocks += ecBlockArray[i]->getCount();
+    }
+
+    // Now establish DataBlocks of the appropriate size and number of data
+    // codewords
+    std::vector<Ref<DataBlock> > result(totalBlocks);
+    int numResultBlocks = 0;
+    for (size_t j = 0; j < ecBlockArray.size(); j++) {
+        ECB *ecBlock = ecBlockArray[j];
+        for (int i = 0; i < ecBlock->getCount(); i++) {
+            int numDataCodewords = ecBlock->getDataCodewords();
+            int numBlockCodewords = ecBlocks.getECCodewords() + numDataCodewords;
+            ArrayRef<char> buffer(numBlockCodewords);
+            Ref<DataBlock> blockRef(new DataBlock(numDataCodewords, buffer));
+            result[numResultBlocks++] = blockRef;
+        }
+    }
+
+    // All blocks have the same amount of data, except that the last n
+    // (where n may be 0) have 1 more byte. Figure out where these start.
+    int shorterBlocksTotalCodewords = result[0]->codewords_->size();
+    int longerBlocksStartAt = result.size() - 1;
+    while (longerBlocksStartAt >= 0) {
+        int numCodewords = result[longerBlocksStartAt]->codewords_->size();
+        if (numCodewords == shorterBlocksTotalCodewords) {
+            break;
+        }
+        if (numCodewords != shorterBlocksTotalCodewords + 1) {
+            err_handler =
+                zxing::IllegalArgumentErrorHandler("Data block sizes differ by more than 1");
+            return std::vector<Ref<DataBlock> >();
+        }
+        longerBlocksStartAt--;
+    }
+    longerBlocksStartAt++;
+
+    int shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks.getECCodewords();
+    // The last elements of result may be 1 element longer;
+    // first fill out as many elements as all of them have
+    int rawCodewordsOffset = 0;
+    for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {
+        for (int j = 0; j < numResultBlocks; j++) {
+            result[j]->codewords_[i] = rawCodewords[rawCodewordsOffset++];
+        }
+    }
+    // Fill out the last data block in the longer ones
+    for (int j = longerBlocksStartAt; j < numResultBlocks; j++) {
+        result[j]->codewords_[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++];
+    }
+    // Now add in error correction blocks
+    int max = result[0]->codewords_->size();
+    for (int i = shorterBlocksNumDataCodewords; i < max; i++) {
+        for (int j = 0; j < numResultBlocks; j++) {
+            int iOffset = j < longerBlocksStartAt ? i : i + 1;
+            result[j]->codewords_[iOffset] = rawCodewords[rawCodewordsOffset++];
+        }
+    }
+
+    if (rawCodewordsOffset != rawCodewords->size()) {
+        err_handler =
+            zxing::IllegalArgumentErrorHandler("rawCodewordsOffset != rawCodewords.length");
+        return std::vector<Ref<DataBlock> >();
+    }
+
+    return result;
+}
+
+}  // namespace qrcode
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datablock.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datablock.hpp
new file mode 100644
index 00000000..f95a29e4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datablock.hpp
@@ -0,0 +1,43 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DECODER_DATABLOCK_HPP__
+#define __ZXING_QRCODE_DECODER_DATABLOCK_HPP__
+
+#include "../../common/array.hpp"
+#include "../../common/counted.hpp"
+#include "../../errorhandler.hpp"
+#include "../error_correction_level.hpp"
+#include "../version.hpp"
+
+
+namespace zxing {
+namespace qrcode {
+
+class DataBlock : public Counted {
+private:
+    int numDataCodewords_;
+    ArrayRef<char> codewords_;
+
+    DataBlock(int numDataCodewords, ArrayRef<char> codewords);
+
+public:
+    static std::vector<Ref<DataBlock> > getDataBlocks(ArrayRef<char> rawCodewords, Version *version,
+                                                      ErrorCorrectionLevel &ecLevel,
+                                                      ErrorHandler &err_handler);
+
+    int getNumDataCodewords();
+    ArrayRef<char> getCodewords();
+};
+
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DECODER_DATABLOCK_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datamask.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datamask.cpp
new file mode 100644
index 00000000..68ccb6ff
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datamask.cpp
@@ -0,0 +1,120 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "datamask.hpp"
+namespace zxing {
+namespace qrcode {
+
+using zxing::ErrorHandler;
+
+DataMask::DataMask() {}
+
+DataMask::~DataMask() {}
+
+DataMask& DataMask::forReference(int reference, ErrorHandler& err_handler) {
+    if (reference < 0 || reference > 7) {
+        err_handler = zxing::IllegalArgumentErrorHandler("reference must be between 0 and 7");
+        return *DATA_MASKS[0];
+    }
+    return *DATA_MASKS[reference];
+}
+
+void DataMask::unmaskBitMatrix(BitMatrix& bits, size_t dimension) {
+    for (size_t y = 0; y < dimension; y++) {
+        for (size_t x = 0; x < dimension; x++) {
+            // TODO: check why the coordinates have to be swapped
+            if (isMasked(y, x)) {
+                bits.flip(x, y);
+            }
+        }
+    }
+}
+
+/**
+ * 000: mask bits for which (x + y) mod 2 == 0
+ */
+class DataMask000 : public DataMask {
+public:
+    bool isMasked(size_t x, size_t y) override { return ((x + y) % 2) == 0; }
+};
+
+/**
+ * 001: mask bits for which x mod 2 == 0
+ */
+class DataMask001 : public DataMask {
+public:
+    bool isMasked(size_t x, size_t) override { return (x % 2) == 0; }
+};
+
+/**
+ * 010: mask bits for which y mod 3 == 0
+ */
+class DataMask010 : public DataMask {
+public:
+    bool isMasked(size_t, size_t y) override { return y % 3 == 0; }
+};
+
+/**
+ * 011: mask bits for which (x + y) mod 3 == 0
+ */
+class DataMask011 : public DataMask {
+public:
+    bool isMasked(size_t x, size_t y) override { return (x + y) % 3 == 0; }
+};
+
+/**
+ * 100: mask bits for which (x/2 + y/3) mod 2 == 0
+ */
+class DataMask100 : public DataMask {
+public:
+    bool isMasked(size_t x, size_t y) override { return (((x >> 1) + (y / 3)) % 2) == 0; }
+};
+
+/**
+ * 101: mask bits for which xy mod 2 + xy mod 3 == 0
+ */
+class DataMask101 : public DataMask {
+public:
+    bool isMasked(size_t x, size_t y) override {
+        size_t temp = x * y;
+        return (temp % 2) + (temp % 3) == 0;
+    }
+};
+
+/**
+ * 110: mask bits for which (xy mod 2 + xy mod 3) mod 2 == 0
+ */
+class DataMask110 : public DataMask {
+public:
+    bool isMasked(size_t x, size_t y) override {
+        size_t temp = x * y;
+        return (((temp % 2) + (temp % 3)) % 2) == 0;
+    }
+};
+
+/**
+ * 111: mask bits for which ((x+y)mod 2 + xy mod 3) mod 2 == 0
+ */
+class DataMask111 : public DataMask {
+public:
+    bool isMasked(size_t x, size_t y) override {
+        return ((((x + y) % 2) + ((x * y) % 3)) % 2) == 0;
+    }
+};
+
+vector<Ref<DataMask> > DataMask::DATA_MASKS = {
+    Ref<DataMask>(new DataMask000()), Ref<DataMask>(new DataMask001()),
+    Ref<DataMask>(new DataMask010()), Ref<DataMask>(new DataMask011()),
+    Ref<DataMask>(new DataMask100()), Ref<DataMask>(new DataMask101()),
+    Ref<DataMask>(new DataMask110()), Ref<DataMask>(new DataMask111()),
+};
+
+}  // namespace qrcode
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datamask.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datamask.hpp
new file mode 100644
index 00000000..c8f276fd
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/datamask.hpp
@@ -0,0 +1,37 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DECODER_DATAMASK_HPP__
+#define __ZXING_QRCODE_DECODER_DATAMASK_HPP__
+
+#include "../../common/array.hpp"
+#include "../../common/bitmatrix.hpp"
+#include "../../common/counted.hpp"
+#include "../../errorhandler.hpp"
+namespace zxing {
+namespace qrcode {
+
+class DataMask : public Counted {
+private:
+    static std::vector<Ref<DataMask> > DATA_MASKS;
+
+protected:
+public:
+    DataMask();
+    virtual ~DataMask();
+    void unmaskBitMatrix(BitMatrix& matrix, size_t dimension);
+    virtual bool isMasked(size_t x, size_t y) = 0;
+    static DataMask& forReference(int reference, ErrorHandler& err_handler);
+};
+
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DECODER_DATAMASK_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoded_bit_stream_parser.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoded_bit_stream_parser.cpp
new file mode 100644
index 00000000..05de793c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoded_bit_stream_parser.cpp
@@ -0,0 +1,490 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "decoded_bit_stream_parser.hpp"
+#include "../../common/stringutils.hpp"
+#include "../../zxing.hpp"
+#ifndef NO_ICONV_INSIDE
+#include <iconv.h>
+#endif
+#include <iomanip>
+
+#undef ICONV_CONST
+#define ICONV_CONST const
+
+#ifndef ICONV_CONST
+#define ICONV_CONST /**/
+#endif
+
+using zxing::ErrorHandler;
+
+// Add this to fix both Mac and Windows compilers
+template <class T>
+class sloppy {};
+
+// convert between T** and const T**
+template <class T>
+class sloppy<T**> {
+    T** t;
+
+public:
+    explicit sloppy(T** mt) : t(mt) {}
+    explicit sloppy(const T** mt) : t(const_cast<T**>(mt)) {}
+
+    operator T* *() const { return t; }
+    operator const T* *() const { return const_cast<const T**>(t); }
+};
+
+using namespace std;
+using namespace zxing;
+using namespace zxing::qrcode;
+using namespace zxing::common;
+
+const char DecodedBitStreamParser::ALPHANUMERIC_CHARS[] = {
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E',
+    'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+    'U', 'V', 'W', 'X', 'Y', 'Z', ' ', '$', '%', '*', '+', '-', '.', '/', ':'};
+
+// string DecodedBitStreamParser::outputCharset = "UTF-8";
+
+namespace {
+int GB2312_SUBSET = 1;
+}
+
+void DecodedBitStreamParser::append(std::string& result, string const& in,
+                                    ErrorHandler& err_handler) {
+    append(result, (char const*)in.c_str(), in.length(), err_handler);
+}
+
+void DecodedBitStreamParser::append(std::string& result, const char* bufIn, size_t nIn,
+                                    ErrorHandler& err_handler) {
+    if (err_handler.ErrCode()) return;
+#ifndef NO_ICONV_INSIDE
+    if (nIn == 0) {
+        return;
+    }
+    iconv_t cd;
+    // cout<<src<<endl;
+    cd = iconv_open(StringUtils::UTF8, src);
+
+    // iconv_t cd = iconv_open(StringUtils::GBK, src);
+    if (cd == (iconv_t)-1) {
+        result.append((const char*)bufIn, nIn);
+        return;
+    }
+
+    const int maxOut = 4 * nIn + 1;
+    char* bufOut = new char[maxOut];
+
+    ICONV_CONST char* fromPtr = (ICONV_CONST char*)bufIn;
+    size_t nFrom = nIn;
+    char* toPtr = (char*)bufOut;
+    size_t nTo = maxOut;
+
+    while (nFrom > 0) {
+        size_t oneway = iconv(cd, sloppy<char**>(&fromPtr), &nFrom, sloppy<char**>(&toPtr), &nTo);
+
+        if (oneway == (size_t)(-1)) {
+            iconv_close(cd);
+            delete[] bufOut;
+            err_handler = zxing::ReaderErrorHandler("error converting characters");
+            return;
+        }
+    }
+    iconv_close(cd);
+
+    int nResult = maxOut - nTo;
+    bufOut[nResult] = '\0';
+    result.append((const char*)bufOut);
+    delete[] bufOut;
+#else
+    result.append((const char*)bufIn, nIn);
+#endif
+}
+
+void DecodedBitStreamParser::decodeHanziSegment(Ref<BitSource> bits_, string& result, int count,
+                                                ErrorHandler& err_handler) {
+    BitSource& bits(*bits_);
+    // Don't crash trying to read more bits than we have available.
+    if (count * 13 > bits.available()) {
+        err_handler = zxing::FormatErrorHandler("decodeKanjiSegment");
+        return;
+    }
+
+    // Each character will require 2 bytes. Read the characters as 2-byte pairs
+    // and decode as GB2312 afterwards
+    size_t nBytes = 2 * count;
+    char* buffer = new char[nBytes];
+    int offset = 0;
+    while (count > 0) {
+        // Each 13 bits encodes a 2-byte character
+        int twoBytes = bits.readBits(13, err_handler);
+        if (err_handler.ErrCode()) return;
+        int assembledTwoBytes = ((twoBytes / 0x060) << 8) | (twoBytes % 0x060);
+        if (assembledTwoBytes < 0x003BF) {
+            // In the 0xA1A1 to 0xAAFE range
+            assembledTwoBytes += 0x0A1A1;
+        } else {
+            // In the 0xB0A1 to 0xFAFE range
+            assembledTwoBytes += 0x0A6A1;
+        }
+        buffer[offset] = (char)((assembledTwoBytes >> 8) & 0xFF);
+        buffer[offset + 1] = (char)(assembledTwoBytes & 0xFF);
+        offset += 2;
+        count--;
+    }
+    // for(int i=0;i<nBytes;i++)
+    // cout<<buffer[i]<<endl;
+    append(result, buffer, nBytes, err_handler);
+    if (err_handler.ErrCode()) {
+        delete[] buffer;
+        return;
+    }
+
+    delete[] buffer;
+}
+
+void DecodedBitStreamParser::decodeKanjiSegment(Ref<BitSource> bits, std::string& result, int count,
+                                                ErrorHandler& err_handler) {
+    // Each character will require 2 bytes. Read the characters as 2-byte pairs
+    // and decode as Shift_JIS afterwards
+    size_t nBytes = 2 * count;
+    char* buffer = new char[nBytes];
+    int offset = 0;
+    while (count > 0) {
+        // Each 13 bits encodes a 2-byte character
+
+        int twoBytes = bits->readBits(13, err_handler);
+        if (err_handler.ErrCode()) return;
+        int assembledTwoBytes = ((twoBytes / 0x0C0) << 8) | (twoBytes % 0x0C0);
+        if (assembledTwoBytes < 0x01F00) {
+            // In the 0x8140 to 0x9FFC range
+            assembledTwoBytes += 0x08140;
+        } else {
+            // In the 0xE040 to 0xEBBF range
+            assembledTwoBytes += 0x0C140;
+        }
+        buffer[offset] = (char)(assembledTwoBytes >> 8);
+        buffer[offset + 1] = (char)assembledTwoBytes;
+        offset += 2;
+        count--;
+    }
+
+    append(result, buffer, nBytes, err_handler);
+    if (err_handler.ErrCode()) {
+        delete[] buffer;
+        return;
+    }
+    // cout<<buffer<<endl;
+    delete[] buffer;
+}
+
+void DecodedBitStreamParser::decodeByteSegment(Ref<BitSource> bits_, string& result, int count,
+                                               CharacterSetECI* currentCharacterSetECI,
+                                               ArrayRef<ArrayRef<char> >& byteSegments,
+                                               ErrorHandler& err_handler) {
+    int nBytes = count;
+    BitSource& bits(*bits_);
+    // Don't crash trying to read more bits than we have available.
+    int available = bits.available();
+    // try to repair count data if count data is invalid
+    if (count * 8 > available) {
+        count = (available + 7 / 8);
+    }
+
+    ArrayRef<char> bytes_(count);
+    char* readBytes = &(*bytes_)[0];
+    for (int i = 0; i < count; i++) {
+        //    readBytes[i] = (char) bits.readBits(8);
+        int readBits = available < 8 ? available : 8;
+        readBytes[i] = (char)bits.readBits(readBits, err_handler);
+    }
+    if (err_handler.ErrCode()) return;
+    // vector<string> encoding;
+    string encoding;
+
+    if (currentCharacterSetECI == 0) {
+        // The spec isn't clear on this mode; see
+        // section 6.4.5: t does not say which encoding to assuming
+        // upon decoding. I have seen ISO-8859-1 used as well as
+        // Shift_JIS -- without anything like an ECI designator to
+        // give a hint.
+        encoding = outputCharset;
+
+    } else {
+        // encoding .push_back(currentCharacterSetECI->name());
+        encoding = currentCharacterSetECI->name();
+    }
+    // cout<<"encoding: "<<encoding<<endl;
+
+    append(result, readBytes, nBytes, err_handler);
+    if (err_handler.ErrCode()) return;
+
+    byteSegments->values().push_back(bytes_);
+}
+
+void DecodedBitStreamParser::decodeNumericSegment(Ref<BitSource> bits, std::string& result,
+                                                  int count, ErrorHandler& err_handler) {
+    int nBytes = count;
+    // char* bytes = new char[nBytes];
+    ArrayRef<char> bytes = ArrayRef<char>(new Array<char>(nBytes));
+    int i = 0;
+    // Read three digits at a time
+    while (count >= 3) {
+        // Each 10 bits encodes three digits
+        if (bits->available() < 10) {
+            err_handler = zxing::ReaderErrorHandler("format exception");
+            return;
+        }
+        int threeDigitsBits = bits->readBits(10, err_handler);
+        if (err_handler.ErrCode()) return;
+        if (threeDigitsBits >= 1000) {
+            ostringstream s;
+            s << "Illegal value for 3-digit unit: " << threeDigitsBits;
+            err_handler = zxing::ReaderErrorHandler(s.str().c_str());
+            return;
+        }
+        bytes[i++] = ALPHANUMERIC_CHARS[threeDigitsBits / 100];
+        bytes[i++] = ALPHANUMERIC_CHARS[(threeDigitsBits / 10) % 10];
+        bytes[i++] = ALPHANUMERIC_CHARS[threeDigitsBits % 10];
+        count -= 3;
+    }
+    if (count == 2) {
+        if (bits->available() < 7) {
+            err_handler = zxing::ReaderErrorHandler("format exception");
+            return;
+        }
+        // Two digits left over to read, encoded in 7 bits
+        int twoDigitsBits = bits->readBits(7, err_handler);
+        if (err_handler.ErrCode()) return;
+        if (twoDigitsBits >= 100) {
+            ostringstream s;
+            s << "Illegal value for 2-digit unit: " << twoDigitsBits;
+            err_handler = zxing::ReaderErrorHandler(s.str().c_str());
+            return;
+        }
+        bytes[i++] = ALPHANUMERIC_CHARS[twoDigitsBits / 10];
+        bytes[i++] = ALPHANUMERIC_CHARS[twoDigitsBits % 10];
+    } else if (count == 1) {
+        if (bits->available() < 4) {
+            err_handler = zxing::ReaderErrorHandler("format exception");
+            return;
+        }
+        // One digit left over to read
+        int digitBits = bits->readBits(4, err_handler);
+        if (err_handler.ErrCode()) return;
+        if (digitBits >= 10) {
+            ostringstream s;
+            s << "Illegal value for digit unit: " << digitBits;
+            err_handler = zxing::ReaderErrorHandler(s.str().c_str());
+            return;
+        }
+        bytes[i++] = ALPHANUMERIC_CHARS[digitBits];
+    }
+    append(result, bytes->data(), nBytes, err_handler);
+    if (err_handler.ErrCode()) return;
+}
+
+char DecodedBitStreamParser::toAlphaNumericChar(size_t value, ErrorHandler& err_handler) {
+    if (value >= sizeof(DecodedBitStreamParser::ALPHANUMERIC_CHARS)) {
+        err_handler = zxing::FormatErrorHandler("toAlphaNumericChar");
+        return 0;
+    }
+    return ALPHANUMERIC_CHARS[value];
+}
+
+void DecodedBitStreamParser::decodeAlphanumericSegment(Ref<BitSource> bits_, string& result,
+                                                       int count, bool fc1InEffect,
+                                                       ErrorHandler& err_handler) {
+    BitSource& bits(*bits_);
+    ostringstream bytes;
+    // Read two characters at a time
+    while (count > 1) {
+        if (bits.available() < 11) {
+            err_handler = zxing::FormatErrorHandler("decodeAlphanumericSegment");
+            return;
+        }
+        int nextTwoCharsBits = bits.readBits(11, err_handler);
+        bytes << toAlphaNumericChar(nextTwoCharsBits / 45, err_handler);
+        bytes << toAlphaNumericChar(nextTwoCharsBits % 45, err_handler);
+        if (err_handler.ErrCode()) return;
+        count -= 2;
+    }
+    if (count == 1) {
+        // special case: one character left
+        if (bits.available() < 6) {
+            err_handler = zxing::FormatErrorHandler("decodeAlphanumericSegment");
+            return;
+        }
+        bytes << toAlphaNumericChar(bits.readBits(6, err_handler), err_handler);
+        if (err_handler.ErrCode()) return;
+    }
+    // See section 6.4.8.1, 6.4.8.2
+    string s = bytes.str();
+    if (fc1InEffect) {
+        // We need to massage the result a bit if in an FNC1 mode:
+        ostringstream r;
+        for (size_t i = 0; i < s.length(); i++) {
+            if (s[i] != '%') {
+                r << s[i];
+            } else {
+                if (i < s.length() - 1 && s[i + 1] == '%') {
+                    // %% is rendered as %
+                    r << s[i++];
+                } else {
+                    // In alpha mode, % should be converted to FNC1 separator
+                    // 0x1D
+                    r << (char)0x1D;
+                }
+            }
+        }
+        s = r.str();
+    }
+    append(result, s, err_handler);
+    if (err_handler.ErrCode()) return;
+}
+
+namespace {
+int parseECIValue(BitSource& bits, ErrorHandler& err_handler) {
+    int firstByte = bits.readBits(8, err_handler);
+    if (err_handler.ErrCode()) return 0;
+    if ((firstByte & 0x80) == 0) {
+        // just one byte
+        return firstByte & 0x7F;
+    }
+    if ((firstByte & 0xC0) == 0x80) {
+        // two bytes
+        int secondByte = bits.readBits(8, err_handler);
+        if (err_handler.ErrCode()) return 0;
+        return ((firstByte & 0x3F) << 8) | secondByte;
+    }
+    if ((firstByte & 0xE0) == 0xC0) {
+        // three bytes
+        int secondThirdBytes = bits.readBits(16, err_handler);
+        if (err_handler.ErrCode()) return 0;
+        return ((firstByte & 0x1F) << 16) | secondThirdBytes;
+    }
+    err_handler = zxing::FormatErrorHandler("parseECIValue");
+    return 0;
+}
+}  // namespace
+
+Ref<DecoderResult> DecodedBitStreamParser::decode(ArrayRef<char> bytes, Version* version,
+                                                  ErrorCorrectionLevel const& ecLevel,
+                                                  ErrorHandler& err_handler, int iVersion) {
+    Ref<BitSource> bits_(new BitSource(bytes));
+    BitSource& bits(*bits_);
+    string result;
+    result.reserve(50);
+    Mode* mode = 0;
+    string modeName;
+    ArrayRef<ArrayRef<char> > byteSegments(0);
+
+    CharacterSetECI* currentCharacterSetECI = 0;
+    bool fc1InEffect = false;
+
+    outputCharset = "UTF-8";
+    do {
+        // While still another segment to read...
+        if (bits.available() < 4) {
+            // OK, assume we're done. Really, a TERMINATOR mode should have been
+            // recorded here
+            mode = &Mode::TERMINATOR;
+        } else {
+            mode = &Mode::forBits(bits.readBits(4, err_handler),
+                                  err_handler);  // mode is encoded by 4 bits
+            if (err_handler.ErrCode()) return Ref<DecoderResult>();
+        }
+
+        if (mode != &Mode::TERMINATOR) {
+            if ((mode == &Mode::FNC1_FIRST_POSITION) || (mode == &Mode::FNC1_SECOND_POSITION)) {
+                // We do little with FNC1 except alter the parsed result a bit
+                // according to the spec
+                fc1InEffect = true;
+            } else if (mode == &Mode::STRUCTURED_APPEND) {
+                if (bits.available() < 16) {
+                    err_handler = zxing::FormatErrorHandler("decode");
+                    return Ref<DecoderResult>();
+                }
+                // not really supported; all we do is ignore it
+                // Read next 8 bits (symbol sequence #) and 8 bits (parity
+                // data), then continue
+                bits.readBits(16, err_handler);
+                if (err_handler.ErrCode()) return Ref<DecoderResult>();
+            } else if (mode == &Mode::ECI) {
+                // Count doesn't apply to ECI
+                int value = parseECIValue(bits, err_handler);
+                if (err_handler.ErrCode()) Ref<DecoderResult>();
+                currentCharacterSetECI = CharacterSetECI::getCharacterSetECIByValueFind(value);
+                if (currentCharacterSetECI == 0) {
+                    err_handler = zxing::FormatErrorHandler("decode");
+                    return Ref<DecoderResult>();
+                }
+            } else {
+                // First handle Hanzi mode which does not start with character
+                // count
+                if (mode == &Mode::HANZI) {
+                    // chinese mode contains a sub set indicator right after
+                    // mode indicator
+                    int subset = bits.readBits(4, err_handler);
+                    int countHanzi =
+                        bits.readBits(mode->getCharacterCountBits(version), err_handler);
+                    if (err_handler.ErrCode()) return Ref<DecoderResult>();
+                    if (subset == GB2312_SUBSET) {
+                        decodeHanziSegment(bits_, result, countHanzi, err_handler);
+                        if (err_handler.ErrCode()) Ref<DecoderResult>();
+                        outputCharset = "GB2312";
+                        modeName = mode->getName();
+                    }
+                } else {
+                    // "Normal" QR code modes:
+                    // How many characters will follow, encoded in this mode?
+                    int count = bits.readBits(mode->getCharacterCountBits(version), err_handler);
+                    if (err_handler.ErrCode()) return Ref<DecoderResult>();
+                    if (mode == &Mode::NUMERIC) {
+                        decodeNumericSegment(bits_, result, count, err_handler);
+                        if (err_handler.ErrCode()) {
+                            err_handler = zxing::FormatErrorHandler("decode");
+                            return Ref<DecoderResult>();
+                        }
+                        modeName = mode->getName();
+                    } else if (mode == &Mode::ALPHANUMERIC) {
+                        decodeAlphanumericSegment(bits_, result, count, fc1InEffect, err_handler);
+                        if (err_handler.ErrCode()) Ref<DecoderResult>();
+                        modeName = mode->getName();
+                    } else if (mode == &Mode::BYTE) {
+                        decodeByteSegment(bits_, result, count, currentCharacterSetECI,
+                                          byteSegments, err_handler);
+                        if (err_handler.ErrCode()) {
+                            err_handler = zxing::FormatErrorHandler("decode");
+                            return Ref<DecoderResult>();
+                        }
+                        modeName = mode->getName();
+                        // outputCharset = getResultCharset();
+                    } else if (mode == &Mode::KANJI) {
+                        // int countKanji =
+                        // bits.readBits(mode->getCharacterCountBits(version));
+                        // cout<<"countKanji: "<<countKanji<<endl;
+                        // decodeKanjiSegment(bits_, result, countKanji);
+                        decodeKanjiSegment(bits_, result, count, err_handler);
+                        if (err_handler.ErrCode()) Ref<DecoderResult>();
+                        modeName = mode->getName();
+                    } else {
+                        err_handler = zxing::FormatErrorHandler("decode");
+                        return Ref<DecoderResult>();
+                    }
+                }
+            }
+        }
+    } while (mode != &Mode::TERMINATOR);
+    return Ref<DecoderResult>(new DecoderResult(bytes, Ref<String>(new String(result)),
+                                                byteSegments, (string)ecLevel,
+                                                (string)outputCharset, iVersion, modeName));
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoded_bit_stream_parser.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoded_bit_stream_parser.hpp
new file mode 100644
index 00000000..e8887ef6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoded_bit_stream_parser.hpp
@@ -0,0 +1,66 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DECODER_DECODEDBITSTREAMPARSER_HPP__
+#define __ZXING_QRCODE_DECODER_DECODEDBITSTREAMPARSER_HPP__
+
+#include "../../common/array.hpp"
+#include "../../common/bitsource.hpp"
+#include "../../common/characterseteci.hpp"
+#include "../../common/counted.hpp"
+#include "../../common/decoder_result.hpp"
+#include "../../decodehints.hpp"
+#include "../../errorhandler.hpp"
+#include "mode.hpp"
+
+
+namespace zxing {
+namespace qrcode {
+
+class DecodedBitStreamParser {
+public:
+    DecodedBitStreamParser() : outputCharset("UTF-8") {}
+
+private:
+    static char const ALPHANUMERIC_CHARS[];
+
+    string outputCharset;
+    // string outputCharset;
+
+    char toAlphaNumericChar(size_t value, ErrorHandler& err_handler);
+
+    void decodeHanziSegment(Ref<BitSource> bits, std::string& result, int count,
+                            ErrorHandler& err_handler);
+    void decodeKanjiSegment(Ref<BitSource> bits, std::string& result, int count,
+                            ErrorHandler& err_handler);
+    void decodeByteSegment(Ref<BitSource> bits, std::string& result, int count);
+    void decodeByteSegment(Ref<BitSource> bits_, std::string& result, int count,
+                           zxing::common::CharacterSetECI* currentCharacterSetECI,
+                           ArrayRef<ArrayRef<char> >& byteSegments, ErrorHandler& err_handler);
+    void decodeAlphanumericSegment(Ref<BitSource> bits, std::string& result, int count,
+                                   bool fc1InEffect, ErrorHandler& err_handler);
+    void decodeNumericSegment(Ref<BitSource> bits, std::string& result, int count,
+                              ErrorHandler& err_handler);
+
+    void append(std::string& ost, const char* bufIn, size_t nIn, ErrorHandler& err_handler);
+    void append(std::string& ost, std::string const& in, ErrorHandler& err_handler);
+
+public:
+    Ref<DecoderResult> decode(ArrayRef<char> bytes, Version* version,
+                              ErrorCorrectionLevel const& ecLevel, ErrorHandler& err_handler,
+                              int iVersion = -1);
+
+    // string getResultCharset();
+};
+
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DECODER_DECODEDBITSTREAMPARSER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoder.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoder.cpp
new file mode 100644
index 00000000..4ebe4754
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoder.cpp
@@ -0,0 +1,223 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "decoder.hpp"
+#include "../error_correction_level.hpp"
+#include "../version.hpp"
+#include "datablock.hpp"
+#include "decoded_bit_stream_parser.hpp"
+#include "qrcode_decoder_metadata.hpp"
+
+using zxing::DecoderResult;
+using zxing::Ref;
+using zxing::qrcode::Decoder;
+
+// VC++
+// The main class which implements QR Code decoding -- as opposed to locating
+// and extracting the QR Code from an image.
+using zxing::ArrayRef;
+using zxing::BitMatrix;
+using zxing::DetectorResult;
+using zxing::ErrorHandler;
+
+Decoder::Decoder() : rsDecoder_(Ref<GenericGF>(GF_QR_CODE_FIELD_256)) {
+    possibleVersion_ = 0;
+    possibleFix_ = 0;
+    decoderState_ = NOTSTART;
+}
+
+// Convenience method that can decode a QR Code represented as a 2D array of
+// booleans. "true" is taken to mean a black module.
+Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits, ErrorHandler &err_handler) {
+    string errMsg = "";
+
+    // Used for mirrored qrcode
+    int width = bits->getWidth();
+    int height = bits->getHeight();
+
+    Ref<BitMatrix> bits2(new BitMatrix(width, height, bits->getPtr(), err_handler));
+    if (err_handler.ErrCode()) return Ref<DecoderResult>();
+    Ref<DecoderResult> rst = decode(bits, false, err_handler);
+    if (err_handler.ErrCode() || rst == NULL) {
+        errMsg = err_handler.ErrMsg();
+    } else {
+        return rst;
+    }
+
+    err_handler.Reset();
+    Ref<DecoderResult> result = decode(bits2, true, err_handler);
+    if (err_handler.ErrCode()) {
+        return Ref<DecoderResult>();
+    } else {
+        // Success! Notify the caller that the code was mirrored.
+        result->setOther(Ref<QRCodeDecoderMetaData>(new QRCodeDecoderMetaData(true)));
+        return result;
+    }
+};
+
+Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits, bool isMirror, ErrorHandler &err_handler) {
+    // Ref<DecoderResult> Decoder::decode(BitMatrixParser& parser) {
+    // Construct a parser and read version, error-correction level
+    BitMatrixParser parser(bits, err_handler);
+    if (err_handler.ErrCode()) return Ref<DecoderResult>();
+
+    if (isMirror == true) {
+        // Revert the bit matrix
+        parser.remask();
+
+        // Will be attempting a mirrored reading of the version and format info.
+        parser.setMirror(true);
+
+        // Preemptively read the version.
+        parser.readVersion(err_handler);
+        if (err_handler.ErrCode()) {
+            err_handler = zxing::ReaderErrorHandler("Decoder::decode mirror & no mirror");
+            return Ref<DecoderResult>();
+        }
+
+        // Preemptively read the format information.
+        parser.readFormatInformation(err_handler);
+        if (err_handler.ErrCode()) return Ref<DecoderResult>();
+
+        /*
+         * Since we're here, this means we have successfully detected some kind
+         * of version and format information when mirrored. This is a good sign,
+         * that the QR code may be mirrored, and we should try once more with a
+         * mirrored content.
+         */
+        // Prepare for a mirrored reading.
+        parser.mirror();
+    }
+
+    decoderState_ = START;
+    possibleFix_ = 0;
+    Version *version = parser.readVersion(err_handler);
+    if (err_handler.ErrCode() || version == NULL) {
+        err_handler = ReaderErrorHandler("Decoder::decode mirror & no mirror");
+        return Ref<DecoderResult>();
+    }
+    decoderState_ = READVERSION;
+    float fixedPatternScore = estimateFixedPattern(bits, version, err_handler);
+    if (err_handler.ErrCode()) return Ref<DecoderResult>();
+
+    Ref<FormatInformation> formatInfo = parser.readFormatInformation(err_handler);
+    if (err_handler.ErrCode()) return Ref<DecoderResult>();
+    ErrorCorrectionLevel &ecLevel = formatInfo->getErrorCorrectionLevel();
+
+    decoderState_ = READERRORCORRECTIONLEVEL;
+
+    // Read codewords
+    ArrayRef<char> codewords(parser.readCodewords(err_handler));
+    if (err_handler.ErrCode()) {
+        err_handler = zxing::ReaderErrorHandler("Decoder::decode mirror & no mirror");
+        return Ref<DecoderResult>();
+    }
+
+    decoderState_ = READCODEWORDSORRECTIONLEVEL;
+    possibleFix_ = fixedPatternScore;
+
+    // Separate into data blocks
+    std::vector<Ref<DataBlock> > dataBlocks(
+        DataBlock::getDataBlocks(codewords, version, ecLevel, err_handler));
+    if (err_handler.ErrCode()) return Ref<DecoderResult>();
+
+    // Count total number of data bytes
+    int totalBytes = 0;
+    for (size_t i = 0; i < dataBlocks.size(); i++) {
+        totalBytes += dataBlocks[i]->getNumDataCodewords();
+    }
+    ArrayRef<char> resultBytes(totalBytes);
+    int resultOffset = 0;
+
+    // Error-correct and copy data blocks together into a stream of bytes
+    for (size_t j = 0; j < dataBlocks.size(); j++) {
+        err_handler.Reset();
+        Ref<DataBlock> dataBlock(dataBlocks[j]);
+        ArrayRef<char> codewordBytes = dataBlock->getCodewords();
+        int numDataCodewords = dataBlock->getNumDataCodewords();
+
+        correctErrors(codewordBytes, numDataCodewords, err_handler);
+        if (err_handler.ErrCode()) return Ref<DecoderResult>();
+
+        for (int i = 0; i < numDataCodewords; i++) {
+            resultBytes[resultOffset++] = codewordBytes[i];
+        }
+    }
+
+    decoderState_ = FINISH;
+    // return DecodedBitStreamParser::decode(resultBytes,
+    DecodedBitStreamParser dbs_parser;
+    Ref<DecoderResult> rst =
+        dbs_parser.decode(resultBytes, version, ecLevel, err_handler, version->getVersionNumber());
+
+    if (err_handler.ErrCode()) return Ref<DecoderResult>();
+    return rst;
+}
+
+// Given data and error-correction codewords received, possibly corrupted by
+// errors, attempts to correct the errors in-place using Reed-Solomon error
+// correction.</p> codewordBytes: data and error correction codewords
+// numDataCodewords: number of codewords that are data bytes
+void Decoder::correctErrors(ArrayRef<char> codewordBytes, int numDataCodewords,
+                            ErrorHandler &err_handler) {
+    // First read into an arrya of ints
+    int numCodewords = codewordBytes->size();
+    ArrayRef<int> codewordInts(numCodewords);
+    for (int i = 0; i < numCodewords; i++) {
+        codewordInts[i] = codewordBytes[i] & 0xff;
+    }
+    int numECCodewords = numCodewords - numDataCodewords;
+    bool correctErrorsFinishished = false;
+
+    rsDecoder_.decode(codewordInts, numECCodewords, err_handler);
+    if (err_handler.ErrCode()) {
+        return;
+    }
+
+    correctErrorsFinishished = true;
+
+    // Copy back into array of bytes -- only need to worry about the bytes that
+    // were data We don't care about errors in the error-correction codewords
+    if (correctErrorsFinishished) {
+        for (int i = 0; i < numDataCodewords; i++) {
+            codewordBytes[i] = (char)codewordInts[i];
+        }
+    }
+}
+
+unsigned int Decoder::getPossibleVersion() { return possibleVersion_; }
+
+float Decoder::estimateFixedPattern(Ref<BitMatrix> bits, zxing::qrcode::Version *version,
+                                    ErrorHandler &err_handler) {
+    Ref<BitMatrix> fixedPatternValue = version->buildFixedPatternValue(err_handler);
+    if (err_handler.ErrCode()) {
+        err_handler = zxing::ReaderErrorHandler("Decoder::decode mirror & no mirror");
+        return -1.0;
+    }
+    Ref<BitMatrix> fixedPatternTemplate = version->buildFixedPatternTemplate(err_handler);
+    if (err_handler.ErrCode()) {
+        err_handler = zxing::ReaderErrorHandler("Decoder::decode mirror & no mirror");
+        return -1.0;
+    }
+
+    int iSum = 0;
+    int iCount = 0;
+    for (int i = 0; i < bits->getHeight(); ++i) {
+        for (int j = 0; j < bits->getWidth(); ++j) {
+            if (fixedPatternTemplate->get(i, j)) {
+                iSum++;
+                if (bits->get(i, j) == fixedPatternValue->get(i, j)) iCount++;
+            }
+        }
+    }
+
+    float possbielFix = 2.0 * iCount / iSum - 1;
+    return possbielFix > 0 ? possbielFix : 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoder.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoder.hpp
new file mode 100644
index 00000000..3ce67f77
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/decoder.hpp
@@ -0,0 +1,65 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DECODER_DECODER_HPP__
+#define __ZXING_QRCODE_DECODER_DECODER_HPP__
+
+#include "../../common/array.hpp"
+#include "../../common/bitmatrix.hpp"
+#include "../../common/counted.hpp"
+#include "../../common/decoder_result.hpp"
+#include "../../common/detector_result.hpp"
+#include "../../common/reedsolomon/reed_solomon_decoder.hpp"
+#include "../../errorhandler.hpp"
+#include "../version.hpp"
+#include "bitmatrixparser.hpp"
+
+namespace zxing {
+namespace qrcode {
+
+class Decoder {
+public:
+    enum DecoderState {
+        NOTSTART = 19,
+        START = 20,
+        READVERSION = 21,
+        READERRORCORRECTIONLEVEL = 22,
+        READCODEWORDSORRECTIONLEVEL = 23,
+        FINISH = 24
+    };
+
+private:
+    DecoderState decoderState_;
+    float possibleFix_;
+    ReedSolomonDecoder rsDecoder_;
+    void correctErrors(ArrayRef<char> bytes, int numDataCodewords, ErrorHandler& err_handler);
+
+public:
+    Decoder();
+    Ref<DecoderResult> decode(Ref<BitMatrix> bits, ErrorHandler& err_handler);
+
+private:
+    Ref<DecoderResult> decode(Ref<BitMatrix> bits, bool isMirror, ErrorHandler& err_handler);
+
+    float estimateFixedPattern(Ref<BitMatrix> bits, Version* version, ErrorHandler& err_handler);
+
+private:
+    unsigned int possibleVersion_;
+
+public:
+    unsigned int getPossibleVersion();
+    DecoderState getState() { return decoderState_; }
+    float getPossibleFix() { return possibleFix_; }
+};
+
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DECODER_DECODER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/mode.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/mode.cpp
new file mode 100644
index 00000000..f96b63b3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/mode.cpp
@@ -0,0 +1,91 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "mode.hpp"
+#include "../../common/counted.hpp"
+#include "../../zxing.hpp"
+#include "../version.hpp"
+
+#include <sstream>
+
+using std::ostringstream;
+using zxing::qrcode::Mode;
+
+// VC++
+using zxing::ErrorHandler;
+using zxing::qrcode::Version;
+
+Mode Mode::TERMINATOR(0, 0, 0, 0x00, "TERMINATOR");
+Mode Mode::NUMERIC(10, 12, 14, 0x01, "NUMERIC");
+Mode Mode::ALPHANUMERIC(9, 11, 13, 0x02, "ALPHANUMERIC");
+Mode Mode::STRUCTURED_APPEND(0, 0, 0, 0x03, "STRUCTURED_APPEND");
+Mode Mode::BYTE(8, 16, 16, 0x04, "BYTE");
+Mode Mode::ECI(0, 0, 0, 0x07, "ECI");
+Mode Mode::KANJI(8, 10, 12, 0x08, "KANJI");
+Mode Mode::FNC1_FIRST_POSITION(0, 0, 0, 0x05, "FNC1_FIRST_POSITION");
+Mode Mode::FNC1_SECOND_POSITION(0, 0, 0, 0x09, "FNC1_SECOND_POSITION");
+Mode Mode::HANZI(8, 10, 12, 0x0D, "HANZI");
+
+// Mode::Mode(int cbv0_9, int cbv10_26, int cbv27, int /* bits */, char const*
+// name) :
+Mode::Mode(int cbv0_9, int cbv10_26, int cbv27, int bits, char const* name)
+    : characterCountBitsForVersions0To9_(cbv0_9),
+      characterCountBitsForVersions10To26_(cbv10_26),
+      // characterCountBitsForVersions27AndHigher_(cbv27), name_(name) {
+      characterCountBitsForVersions27AndHigher_(cbv27),
+      bits_(bits),
+      name_(name) {}
+
+Mode& Mode::forBits(int bits, ErrorHandler& err_handler) {
+    switch (bits) {
+        case 0x0:
+            return TERMINATOR;
+        case 0x1:
+            return NUMERIC;
+        case 0x2:
+            return ALPHANUMERIC;
+        case 0x3:
+            return STRUCTURED_APPEND;
+        case 0x4:
+            return BYTE;
+        case 0x5:
+            return FNC1_FIRST_POSITION;
+        case 0x7:
+            return ECI;
+        case 0x8:
+            return KANJI;
+        case 0x9:
+            return FNC1_SECOND_POSITION;
+        case 0xD:
+            // 0xD is defined in GBT 18284-2000, may not be supported in foreign
+            // country
+            return HANZI;
+        default:
+            ostringstream s;
+            s << "Illegal mode bits: " << bits;
+            err_handler = zxing::ReaderErrorHandler(s.str().c_str());
+            return TERMINATOR;
+    }
+}
+
+int Mode::getCharacterCountBits(Version* version) const {
+    int number = version->getVersionNumber();
+    if (number <= 9) {
+        return characterCountBitsForVersions0To9_;
+    } else if (number <= 26) {
+        return characterCountBitsForVersions10To26_;
+    } else {
+        return characterCountBitsForVersions27AndHigher_;
+    }
+}
+
+int Mode::getBits() const { return bits_; }
+
+string zxing::qrcode::Mode::getName() const { return name_; }
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/mode.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/mode.hpp
new file mode 100644
index 00000000..2b3b146a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/mode.hpp
@@ -0,0 +1,52 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DECODER_MODE_HPP__
+#define __ZXING_QRCODE_DECODER_MODE_HPP__
+
+#include "../../common/counted.hpp"
+#include "../../errorhandler.hpp"
+#include "../version.hpp"
+
+namespace zxing {
+namespace qrcode {
+
+class Mode {
+private:
+    int characterCountBitsForVersions0To9_;
+    int characterCountBitsForVersions10To26_;
+    int characterCountBitsForVersions27AndHigher_;
+    int bits_;
+    std::string name_;
+
+    Mode(int cbv0_9, int cbv10_26, int cbv27, int bits, char const* name);
+
+public:
+    static Mode TERMINATOR;
+    static Mode NUMERIC;
+    static Mode ALPHANUMERIC;
+    static Mode STRUCTURED_APPEND;
+    static Mode BYTE;
+    static Mode ECI;
+    static Mode KANJI;
+    static Mode FNC1_FIRST_POSITION;
+    static Mode FNC1_SECOND_POSITION;
+    static Mode HANZI;
+
+    static Mode& forBits(int bits, ErrorHandler& err_handler);
+    // int getCharacterCountBits(Version *version);
+    int getCharacterCountBits(Version* version) const;
+    int getBits() const;
+    string getName() const;
+};
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DECODER_MODE_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/qrcode_decoder_metadata.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/qrcode_decoder_metadata.hpp
new file mode 100644
index 00000000..e7718931
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/decoder/qrcode_decoder_metadata.hpp
@@ -0,0 +1,64 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DECODER_QRCODEDECODERMETADATA_HPP__
+#define __ZXING_QRCODE_DECODER_QRCODEDECODERMETADATA_HPP__
+
+#include "../../common/array.hpp"
+#include "../../common/counted.hpp"
+#include "../../resultpoint.hpp"
+
+// VC++
+// The main class which implements QR Code decoding -- as opposed to locating
+// and extracting the QR Code from an image.
+
+namespace zxing {
+namespace qrcode {
+
+/**
+ * Meta-data container for QR Code decoding. Instances of this class may be used
+ * to convey information back to the decoding caller. Callers are expected to
+ * process this.
+ *
+ * @see com.google.zxing.common.DecoderResult#getOther()
+ */
+class QRCodeDecoderMetaData : public Counted {
+private:
+    bool mirrored_;
+
+public:
+    explicit QRCodeDecoderMetaData(bool mirrored) : mirrored_(mirrored) {}
+
+public:
+    /**
+     * @return true if the QR Code was mirrored.
+     */
+    bool isMirrored() { return mirrored_; };
+
+    /**
+     * Apply the result points' order correction due to mirroring.
+     *
+     * @param points Array of points to apply mirror correction to.
+     */
+    void applyMirroredCorrection(ArrayRef<Ref<ResultPoint> >& points) {
+        if (!mirrored_ || points->size() < 3) {
+            return;
+        }
+        Ref<ResultPoint> bottomLeft = points[0];
+        points[0] = points[2];
+        points[2] = bottomLeft;
+        // No need to 'fix' top-left and alignment pattern.
+    };
+};
+
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DECODER_QRCODEDECODERMETADATA_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern.cpp
new file mode 100644
index 00000000..deefeeb6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern.cpp
@@ -0,0 +1,42 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "alignment_pattern.hpp"
+using zxing::Ref;
+using zxing::qrcode::AlignmentPattern;
+namespace zxing {
+namespace qrcode {
+AlignmentPattern::AlignmentPattern(float posX, float posY, float estimatedModuleSize)
+    : ResultPoint(posX, posY), estimatedModuleSize_(estimatedModuleSize) {}
+
+// Determines if this alignment pattern "about equals" an alignment pattern at
+// the stated position and size -- meaning, it is at nearly the same center with
+// nearly the same size.
+bool AlignmentPattern::aboutEquals(float moduleSize, float i, float j) const {
+    if (abs(i - getY()) <= moduleSize && abs(j - getX()) <= moduleSize) {
+        float moduleSizeDiff = abs(moduleSize - estimatedModuleSize_);
+        return moduleSizeDiff <= 1.0f || moduleSizeDiff <= estimatedModuleSize_;
+    }
+    return false;
+}
+
+// Combines this object's current estimate of a finder pattern position and
+// module size with a new estimate. It returns a new {@code FinderPattern}
+// containing an average of the two.
+Ref<AlignmentPattern> AlignmentPattern::combineEstimate(float i, float j,
+                                                        float newModuleSize) const {
+    float combinedX = (getX() + j) / 2.0f;
+    float combinedY = (getY() + i) / 2.0f;
+    float combinedModuleSize = (estimatedModuleSize_ + newModuleSize) / 2.0f;
+    Ref<AlignmentPattern> result(new AlignmentPattern(combinedX, combinedY, combinedModuleSize));
+    return result;
+}
+}  // namespace qrcode
+}  // namespace zxing
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern.hpp
new file mode 100644
index 00000000..74a15e32
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern.hpp
@@ -0,0 +1,34 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DETECTOR_ALIGNMENT_PATTERN_HPP_
+#define __ZXING_QRCODE_DETECTOR_ALIGNMENT_PATTERN_HPP_
+
+#include "../../common/bitmatrix.hpp"
+#include "../../resultpoint.hpp"
+namespace zxing {
+namespace qrcode {
+
+class AlignmentPattern : public ResultPoint {
+private:
+    float estimatedModuleSize_;
+
+public:
+    AlignmentPattern(float posX, float posY, float estimatedModuleSize);
+    bool aboutEquals(float moduleSize, float i, float j) const;
+    float getModuleSize() { return estimatedModuleSize_; };
+
+    Ref<AlignmentPattern> combineEstimate(float i, float j, float newModuleSize) const;
+};
+
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DETECTOR_ALIGNMENT_PATTERN_HPP_
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern_finder.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern_finder.cpp
new file mode 100644
index 00000000..072371da
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern_finder.cpp
@@ -0,0 +1,231 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "alignment_pattern_finder.hpp"
+
+using zxing::ErrorHandler;
+using zxing::ReaderErrorHandler;
+using zxing::Ref;
+using zxing::qrcode::AlignmentPattern;
+using zxing::qrcode::AlignmentPatternFinder;
+using zxing::qrcode::FinderPattern;
+
+// VC++
+// This class attempts to find alignment patterns in a QR Code. Alignment
+// patterns look like finder patterns but are smaller and appear at regular
+// intervals throughout the image. At the moment this only looks for the
+// bottom-right alignment pattern. This is mostly a simplified copy of {@link
+// FinderPatternFinder}. It is copied, pasted and stripped down here for maximum
+// performance but does unfortunately duplicat some code. This class is
+// thread-safe but not reentrant. Each thread must allocate its own object.
+using zxing::BitMatrix;
+
+// Creates a finder that will look in a portion of the whole image.
+AlignmentPatternFinder::AlignmentPatternFinder(Ref<BitMatrix> image, int startX, int startY,
+                                               int width, int height, float moduleSize)
+    : image_(image),
+      possibleCenters_(new vector<AlignmentPattern *>()),
+      startX_(startX),
+      startY_(startY),
+      width_(width),
+      height_(height),
+      moduleSize_(moduleSize) {}
+
+AlignmentPatternFinder::AlignmentPatternFinder(Ref<BitMatrix> image, float moduleSize)
+    : image_(image),
+      moduleSize_(moduleSize) {}
+
+// This method attempts to find the bottom-right alignment pattern in the image.
+// It is a bit messy since it's pretty performance-critical and so is written to
+// be fast foremost.
+Ref<AlignmentPattern> AlignmentPatternFinder::find(ErrorHandler &err_handler) {
+    int maxJ = startX_ + width_;
+    int middleI = startY_ + (height_ >> 1);
+    // We are looking for black/white/black modules in 1:1:1 ratio;
+    // this tracks the number of black/white/black modules seen so far
+    vector<int> stateCount(3, 0);
+    for (int iGen = 0; iGen < height_; iGen++) {
+        // Search from middle outwards
+        int i = middleI + ((iGen & 0x01) == 0 ? ((iGen + 1) >> 1) : -((iGen + 1) >> 1));
+        stateCount[0] = 0;
+        stateCount[1] = 0;
+        stateCount[2] = 0;
+        int j = startX_;
+        // Burn off leading white pixels before anything else; if we start in
+        // the middle of a white run, it doesn't make sense to count its length,
+        // since we don't know if the white run continued to the left of the
+        // start point
+        while (j < maxJ && !image_->get(j, i)) {
+            j++;
+        }
+        int currentState = 0;
+        while (j < maxJ) {
+            if (image_->get(j, i)) {
+                // Black pixel
+                if (currentState == 1) {  // Counting black pixels
+                    stateCount[currentState]++;
+                } else {                                      // Counting white pixels
+                    if (currentState == 2) {                  // A winner?
+                        if (foundPatternCross(stateCount)) {  // Yes
+                            Ref<AlignmentPattern> confirmed(handlePossibleCenter(stateCount, i, j));
+                            if (confirmed != 0) {
+                                return confirmed;
+                            }
+                        }
+                        stateCount[0] = stateCount[2];
+                        stateCount[1] = 1;
+                        stateCount[2] = 0;
+                        currentState = 1;
+                    } else {
+                        stateCount[++currentState]++;
+                    }
+                }
+            } else {                      // White pixel
+                if (currentState == 1) {  // Counting black pixels
+                    currentState++;
+                }
+                stateCount[currentState]++;
+            }
+            j++;
+        }
+        if (foundPatternCross(stateCount)) {
+            Ref<AlignmentPattern> confirmed(handlePossibleCenter(stateCount, i, maxJ));
+            if (confirmed != 0) {
+                return confirmed;
+            }
+        }
+    }
+    // Nothing we saw was observed and confirmed twice. If we had any guess at
+    // all, return it.
+    if (possibleCenters_->size() > 0) {
+        Ref<AlignmentPattern> center((*possibleCenters_)[0]);
+        return center;
+    }
+    err_handler = ReaderErrorHandler("Could not find alignment pattern");
+    return Ref<AlignmentPattern>();
+}
+
+
+// Given a count of black/white/black pixels just seen and an end position,
+// figures the location of the center of this black/white/black run.
+float AlignmentPatternFinder::centerFromEnd(vector<int> &stateCount, int end) {
+    return (float)(end - stateCount[2]) - stateCount[1] / 2.0f;
+}
+
+
+
+bool AlignmentPatternFinder::foundPatternCross(vector<int> &stateCount) {
+    float maxVariance = moduleSize_ / 2.0f;
+    for (int i = 0; i < 3; i++) {
+        if (abs(moduleSize_ - stateCount[i]) >= maxVariance) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// After a horizontal scan finds a potential alignment pattern, this method
+// "cross-checks" by scanning down vertically through the center of the possible
+// alignment pattern to see if the same proportion is detected. return vertical
+// center of alignment pattern, or nan() if not found startI: row where an
+// alignment pattern was detected centerJ: center of the section that appears to
+// cross an alignment pattern
+// maxCount: maximum reasonable number of modules that should be observed in any
+// reading state,
+// based on the results of the horizontal scan
+float AlignmentPatternFinder::crossCheckVertical(int startI, int centerJ, int maxCount,
+                                                 int originalStateCountTotal) {
+    // This is slightly faster than using the Ref. Efficiency is important here
+    BitMatrix &matrix = *image_;
+
+    int maxI = matrix.getHeight();
+    vector<int> stateCount(3, 0);
+    // Start counting up from center
+    int i = startI;
+    while (i >= 0 && matrix.get(centerJ, i) && stateCount[1] <= maxCount) {
+        stateCount[1]++;
+        i--;
+    }
+    // If already too many modules in this state or ran off the edge:
+    if (i < 0 || stateCount[1] > maxCount) {
+        return nan();
+    }
+    while (i >= 0 && !matrix.get(centerJ, i) && stateCount[0] <= maxCount) {
+        stateCount[0]++;
+        i--;
+    }
+    if (stateCount[0] > maxCount) {
+        return nan();
+    }
+
+    // Now also count down from center
+    i = startI + 1;
+    while (i < maxI && matrix.get(centerJ, i) && stateCount[1] <= maxCount) {
+        stateCount[1]++;
+        i++;
+    }
+    if (i == maxI || stateCount[1] > maxCount) {
+        return nan();
+    }
+    while (i < maxI && !matrix.get(centerJ, i) && stateCount[2] <= maxCount) {
+        stateCount[2]++;
+        i++;
+    }
+    if (stateCount[2] > maxCount) {
+        return nan();
+    }
+
+    int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
+    if (5 * abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
+        return nan();
+    }
+    return foundPatternCross(stateCount) ? centerFromEnd(stateCount, i) : nan();
+}
+
+
+// This is called when a horizontal scan finds a possible alignment pattern. It
+// will cross check with a vertical scan, and if successful, will see if this
+// pattern had been found on a previous horizontal scan. If so, we consider it
+// confirmed and conclude we have found the alignment pattern. return {@link
+// AlignmentPattern} if we have found the same pattern twice, or null if not i:
+// row where alignment pattern may be found j: end of possible alignment pattern
+// in row
+Ref<AlignmentPattern> AlignmentPatternFinder::handlePossibleCenter(vector<int> &stateCount, int i,
+                                                                   int j) {
+    int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
+    float centerJ = centerFromEnd(stateCount, j);
+    float centerI = crossCheckVertical(i, (int)centerJ, 2 * stateCount[1], stateCountTotal);
+    if (!isnan(centerI)) {
+        float estimatedModuleSize = (float)(stateCount[0] + stateCount[1] + stateCount[2]) / 3.0f;
+        int max = possibleCenters_->size();
+        for (int index = 0; index < max; index++) {
+            Ref<AlignmentPattern> center((*possibleCenters_)[index]);
+            // Look for about the same center and module size:
+            if (center->aboutEquals(estimatedModuleSize, centerI, centerJ)) {
+                return center->combineEstimate(centerI, centerJ, estimatedModuleSize);
+            }
+        }
+        // Hadn't found this before; save it
+        AlignmentPattern *tmp = new AlignmentPattern(centerJ, centerI, estimatedModuleSize);
+        tmp->retain();
+        possibleCenters_->push_back(tmp);
+    }
+    Ref<AlignmentPattern> result;
+    return result;
+}
+
+
+AlignmentPatternFinder::~AlignmentPatternFinder() {
+    for (int i = 0; i < int(possibleCenters_->size()); i++) {
+        (*possibleCenters_)[i]->release();
+        (*possibleCenters_)[i] = 0;
+    }
+    delete possibleCenters_;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern_finder.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern_finder.hpp
new file mode 100644
index 00000000..ace3064a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/alignment_pattern_finder.hpp
@@ -0,0 +1,60 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DETECTOR_ALIGNMENT_PATTERN_FINDER_HPP_
+#define __ZXING_QRCODE_DETECTOR_ALIGNMENT_PATTERN_FINDER_HPP_
+
+#include "../../common/bitmatrix.hpp"
+#include "../../common/counted.hpp"
+#include "../../errorhandler.hpp"
+#include "alignment_pattern.hpp"
+#include "finder_pattern.hpp"
+
+namespace zxing {
+namespace qrcode {
+
+class AlignmentPatternFinder : public Counted {
+private:
+    static int CENTER_QUORUM;
+    static int MIN_SKIP;
+    static int MAX_MODULES;
+
+    Ref<BitMatrix> image_;
+    std::vector<AlignmentPattern *> *possibleCenters_;
+
+    int startX_;
+    int startY_;
+    int width_;
+    int height_;
+    float moduleSize_;
+    static float centerFromEnd(std::vector<int> &stateCount, int end);
+    float crossCheckVertical(int startI, int centerJ, int maxCount, int originalStateCountTotal);
+
+
+public:
+    AlignmentPatternFinder(Ref<BitMatrix> image, int startX, int startY, int width, int height,
+                           float moduleSize);
+    AlignmentPatternFinder(Ref<BitMatrix> image, float moduleSize);
+    ~AlignmentPatternFinder();
+
+    Ref<AlignmentPattern> find(ErrorHandler &err_handler);
+    bool foundPatternCross(std::vector<int> &stateCount);
+    Ref<AlignmentPattern> handlePossibleCenter(std::vector<int> &stateCount, int i, int j);
+
+
+private:
+    AlignmentPatternFinder(const AlignmentPatternFinder &);
+    AlignmentPatternFinder &operator=(const AlignmentPatternFinder &);
+
+};
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DETECTOR_ALIGNMENT_PATTERN_FINDER_HPP_
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/detector.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/detector.cpp
new file mode 100644
index 00000000..e22a852f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/detector.cpp
@@ -0,0 +1,1065 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "detector.hpp"
+#include <sstream>
+#include "../../common/grid_sampler.hpp"
+#include "../../common/mathutils.hpp"
+#include "../../decodehints.hpp"
+#include "../version.hpp"
+#include "alignment_pattern.hpp"
+#include "alignment_pattern_finder.hpp"
+#include "finder_pattern.hpp"
+#include "finder_pattern_finder.hpp"
+#include "opencv2/core.hpp"
+
+using zxing::BitMatrix;
+using zxing::DetectorResult;
+using zxing::ErrorHandler;
+using zxing::PerspectiveTransform;
+using zxing::Ref;
+using zxing::common::MathUtils;
+using zxing::qrcode::AlignmentPattern;
+using zxing::qrcode::Detector;
+using zxing::qrcode::FinderPattern;
+
+// VC++
+using zxing::DecodeHints;
+using zxing::ResultPoint;
+using zxing::UnicomBlock;
+using zxing::qrcode::FinderPatternFinder;
+using zxing::qrcode::FinderPatternInfo;
+using zxing::qrcode::PatternResult;
+
+// Encapsulates logic that can detect a QR Code in an image,
+// even if the QR Code is rotated or skewed, or partially obscured.
+Detector::Detector(Ref<BitMatrix> image, Ref<UnicomBlock> block) : image_(image), block_(block) {
+    detectorState_ = START;
+    possiblePatternResults_.clear();
+}
+
+Ref<BitMatrix> Detector::getImage() const { return image_; }
+
+// Detects a QR Code in an image
+void Detector::detect(DecodeHints const &hints, ErrorHandler &err_handler) {
+    FinderPatternFinder finder(image_, block_);
+    std::vector<Ref<FinderPatternInfo> > finderInfos = finder.find(hints, err_handler);
+    if (err_handler.ErrCode()) return;
+
+    // Get all possible results
+    possiblePatternResults_.clear();
+
+    for (size_t i = 0; i < finderInfos.size(); i++) {
+        Ref<PatternResult> result(new PatternResult(finderInfos[i]));
+        result->possibleVersion = 0;
+        result->possibleFix = 0.0f;
+        result->possibleModuleSize = 0.0f;
+
+        possiblePatternResults_.push_back(result);
+    }
+    detectorState_ = FINDFINDERPATTERN;
+}
+
+int Detector::getPossibleAlignmentCount(int idx) {
+    if (idx >= int(possiblePatternResults_.size())) {
+        return -1;
+    }
+
+    ErrorHandler err_handler;
+    // If it is first time to get, process it now
+    if (possiblePatternResults_[idx]->possibleAlignmentPatterns.size() == 0) {
+        Ref<PatternResult> result =
+            processFinderPatternInfo(possiblePatternResults_[idx]->finderPatternInfo, err_handler);
+        if (err_handler.ErrCode()) return -1;
+
+        possiblePatternResults_[idx] = result;
+    }
+
+    return possiblePatternResults_[idx]->possibleAlignmentPatterns.size();
+}
+
+Ref<DetectorResult> Detector::getResultViaAlignment(int patternIdx, int alignmentIdx,
+                                                    int possibleDimension,
+                                                    ErrorHandler &err_handler) {
+    if (patternIdx >= int(possiblePatternResults_.size()) || patternIdx < 0) {
+        return Ref<DetectorResult>(NULL);
+    }
+
+    if (alignmentIdx >=
+            int(possiblePatternResults_[patternIdx]->possibleAlignmentPatterns.size()) ||
+        alignmentIdx < 0) {
+        return Ref<DetectorResult>(NULL);
+    }
+
+    // Default is the dimension
+    if (possibleDimension <= 0) {
+        possibleDimension = possiblePatternResults_[patternIdx]->getDimension();
+    }
+
+    Ref<FinderPattern> topLeft(
+        possiblePatternResults_[patternIdx]->finderPatternInfo->getTopLeft());
+    Ref<FinderPattern> topRight(
+        possiblePatternResults_[patternIdx]->finderPatternInfo->getTopRight());
+    Ref<FinderPattern> bottomLeft(
+        possiblePatternResults_[patternIdx]->finderPatternInfo->getBottomLeft());
+
+    Ref<AlignmentPattern> alignment(
+        possiblePatternResults_[patternIdx]->possibleAlignmentPatterns[alignmentIdx]);
+    Ref<PerspectiveTransform> transform =
+        createTransform(topLeft, topRight, bottomLeft, alignment, possibleDimension);
+    Ref<BitMatrix> bits(sampleGrid(image_, possibleDimension, transform, err_handler));
+    if (err_handler.ErrCode()) return Ref<DetectorResult>();
+
+    ArrayRef<Ref<ResultPoint> > corrners(new Array<Ref<ResultPoint> >(4));
+    vector<float> points(8, 0.0f);
+    points[0] = 0.0f;
+    points[1] = possibleDimension;  // bottomLeft
+    points[2] = 0.0f;
+    points[3] = 0.0f;  // topLeft
+    points[4] = possibleDimension;
+    points[5] = 0.0f;  // topRight
+    points[6] = possibleDimension;
+    points[7] = possibleDimension;  // bottomRight
+    transform->transformPoints(points);
+    corrners[0].reset(Ref<FinderPattern>(new FinderPattern(points[0], points[1], 0)));
+    corrners[1].reset(Ref<FinderPattern>(new FinderPattern(points[2], points[3], 0)));
+    corrners[2].reset(Ref<FinderPattern>(new FinderPattern(points[4], points[5], 0)));
+    corrners[3].reset(Ref<FinderPattern>(new FinderPattern(points[6], points[7], 0)));
+
+    Ref<DetectorResult> result(new DetectorResult(bits, corrners, possibleDimension));
+    return result;
+}
+
+bool Detector::hasSameResult(vector<Ref<AlignmentPattern> > possibleAlignmentPatterns,
+                             Ref<AlignmentPattern> alignmentPattern) {
+    float moduleSize = alignmentPattern->getModuleSize() / 5.0;
+
+    if (moduleSize < 1.0) {
+        moduleSize = 1.0;
+    }
+
+    for (size_t i = 0; i < possibleAlignmentPatterns.size(); i++) {
+        if (possibleAlignmentPatterns[i]->aboutEquals(moduleSize, alignmentPattern->getY(),
+                                                      alignmentPattern->getX())) {
+            return true;
+        }
+    }
+    return false;
+}
+
+Ref<AlignmentPattern> Detector::getNearestAlignmentPattern(int tryFindRange, float moduleSize,
+                                                           int estAlignmentX, int estAlignmentY) {
+    Ref<AlignmentPattern> alignmentPattern;
+
+    ErrorHandler err_handler;
+    for (int i = 2; i <= tryFindRange; i <<= 1) {
+        err_handler.Reset();
+        alignmentPattern =
+            findAlignmentInRegion(moduleSize, estAlignmentX, estAlignmentY, (float)i, err_handler);
+        if (err_handler.ErrCode() == 0) break;
+    }
+
+    return alignmentPattern;
+}
+
+Ref<PatternResult> Detector::processFinderPatternInfo(Ref<FinderPatternInfo> info,
+                                                      ErrorHandler &err_handler) {
+    Ref<FinderPattern> topLeft(info->getTopLeft());
+    Ref<FinderPattern> topRight(info->getTopRight());
+    Ref<FinderPattern> bottomLeft(info->getBottomLeft());
+
+    Ref<PatternResult> result(new PatternResult(info));
+    result->finderPatternInfo = info;
+    result->possibleAlignmentPatterns.clear();
+
+    float moduleSizeX_ = calculateModuleSizeOneWay(
+        topLeft, topRight, topLeft->getHorizontalCheckState(), topRight->getHorizontalCheckState());
+    float moduleSizeY_ = calculateModuleSizeOneWay(
+        topLeft, bottomLeft, topLeft->getVerticalCheckState(), bottomLeft->getVerticalCheckState());
+
+    if (moduleSizeX_ < 1.0f || moduleSizeY_ < 1.0f) {
+        err_handler = ReaderErrorHandler("bad midule size");
+        return Ref<PatternResult>();
+    }
+
+    float moduleSize = (moduleSizeX_ + moduleSizeY_) / 2.0f;
+
+    if (moduleSize > topLeft->getEstimatedModuleSize() * 1.05 &&
+        moduleSize > topRight->getEstimatedModuleSize() * 1.05 &&
+        moduleSize > bottomLeft->getEstimatedModuleSize() * 1.05) {
+        moduleSize = (topLeft->getEstimatedModuleSize() + topRight->getEstimatedModuleSize() +
+                      bottomLeft->getEstimatedModuleSize()) /
+                     3;
+        moduleSizeX_ = moduleSize;
+        moduleSizeY_ = moduleSize;
+    }
+    result->possibleModuleSize = moduleSize;
+
+    if (moduleSize < 1.0f) {
+        err_handler = ReaderErrorHandler("bad midule size");
+        return Ref<PatternResult>();
+    }
+    int dimension = computeDimension(topLeft, topRight, bottomLeft, moduleSizeX_, moduleSizeY_);
+    Version *provisionalVersion = NULL;
+
+    // Try demension around if it cannot get a version
+    int dimensionDiff[5] = {0, 1, -1, 2, -2};
+
+    int oriDimension = dimension;
+
+    for (int i = 0; i < 5; i++) {
+        err_handler.Reset();
+        dimension = oriDimension + dimensionDiff[i];
+
+        provisionalVersion = Version::getProvisionalVersionForDimension(dimension, err_handler);
+        if (err_handler.ErrCode() == 0) break;
+    }
+    if (provisionalVersion == NULL) {
+        err_handler = zxing::ReaderErrorHandler("Cannot get version number");
+        return Ref<PatternResult>();
+    }
+
+    result->possibleDimension = dimension;
+
+    result->possibleVersion = provisionalVersion->getVersionNumber();
+
+    int modulesBetweenFPCenters = provisionalVersion->getDimensionForVersion(err_handler) - 7;
+    if (err_handler.ErrCode()) return Ref<PatternResult>();
+
+    Ref<AlignmentPattern> alignmentPattern;
+
+    // Guess where a "bottom right" finder pattern would have been
+    float bottomRightX = topRight->getX() - topLeft->getX() + bottomLeft->getX();
+    float bottomRightY = topRight->getY() - topLeft->getY() + bottomLeft->getY();
+    // Estimate that alignment pattern is closer by 3 modules from "bottom
+    // right" to known top left location
+    float correctionToTopLeft = 1.0f - 3.0f / (float)modulesBetweenFPCenters;
+    int estAlignmentX =
+        (int)(topLeft->getX() + correctionToTopLeft * (bottomRightX - topLeft->getX()));
+    int estAlignmentY =
+        (int)(topLeft->getY() + correctionToTopLeft * (bottomRightY - topLeft->getY()));
+
+    Ref<AlignmentPattern> estimateCenter(
+        new AlignmentPattern(estAlignmentX, estAlignmentY, moduleSize));
+
+    bool foundFitLine = false;
+    Ref<AlignmentPattern> fitLineCenter;
+
+    fitLineCenter =
+        findAlignmentWithFitLine(topLeft, topRight, bottomLeft, moduleSize, err_handler);
+    if (err_handler.ErrCode() == 0) {
+        if (fitLineCenter != NULL &&
+            MathUtils::isInRange(fitLineCenter->getX(), fitLineCenter->getY(), image_->getWidth(),
+                                 image_->getHeight())) {
+            foundFitLine = true;
+        }
+    }
+    err_handler.Reset();
+
+    Ref<AlignmentPattern> fitAP, estAP;
+
+    // Anything above version 1 has an alignment pattern
+    if (provisionalVersion->getAlignmentPatternCenters().size()) {
+        // if(alignmentPattern!=NULL&&alignmentPattern->getX()>0&&alignmentPattern->getY()>0){
+        int tryFindRange = provisionalVersion->getDimensionForVersion(err_handler) / 2;
+        if (err_handler.ErrCode()) return Ref<PatternResult>();
+
+        if (foundFitLine == true) {
+            fitAP = getNearestAlignmentPattern(tryFindRange, moduleSize, fitLineCenter->getX(),
+                                               fitLineCenter->getY());
+
+            if (fitAP != NULL && !hasSameResult(result->possibleAlignmentPatterns, fitAP))
+            // if (fitAP != NULL &&
+            // !hasSameResult(result->possibleAlignmentPatterns, fitAP) &&
+            // checkConvexQuadrilateral(topLeft, topRight, bottomLeft, fitAP))
+            {
+                result->possibleAlignmentPatterns.push_back(fitAP);
+            }
+        }
+
+        estAP = getNearestAlignmentPattern(tryFindRange, moduleSize, estimateCenter->getX(),
+                                           estimateCenter->getY());
+
+        if (estAP != NULL && !hasSameResult(result->possibleAlignmentPatterns, estAP))
+        // if (estAP != NULL &&
+        // !hasSameResult(result->possibleAlignmentPatterns, estAP) &&
+        // checkConvexQuadrilateral(topLeft, topRight, bottomLeft, estAP))
+        {
+            result->possibleAlignmentPatterns.push_back(estAP);
+        }
+    }
+
+    // Any way use the fit line result
+    if (foundFitLine == true && !hasSameResult(result->possibleAlignmentPatterns, fitLineCenter)) {
+        float alignmentX = fitLineCenter->getX();
+        float alignmentY = fitLineCenter->getY();
+        fixAlignmentPattern(alignmentX, alignmentY, moduleSize);
+        Ref<AlignmentPattern> fitLineCenterFixed =
+            Ref<AlignmentPattern>(new AlignmentPattern(alignmentX, alignmentY, moduleSize));
+        if (!hasSameResult(result->possibleAlignmentPatterns, fitLineCenterFixed)) {
+            result->possibleAlignmentPatterns.push_back(fitLineCenterFixed);
+        }
+
+        if (!hasSameResult(result->possibleAlignmentPatterns, fitLineCenter)) {
+            result->possibleAlignmentPatterns.push_back(fitLineCenter);
+        }
+    }
+
+    if (!hasSameResult(result->possibleAlignmentPatterns, estimateCenter)) {
+        float alignmentX = estimateCenter->getX();
+        float alignmentY = estimateCenter->getY();
+        fixAlignmentPattern(alignmentX, alignmentY, moduleSize);
+        Ref<AlignmentPattern> estimateCenterFixed =
+            Ref<AlignmentPattern>(new AlignmentPattern(alignmentX, alignmentY, moduleSize));
+        if (!hasSameResult(result->possibleAlignmentPatterns, estimateCenterFixed)) {
+            result->possibleAlignmentPatterns.push_back(estimateCenterFixed);
+        }
+
+        if (!hasSameResult(result->possibleAlignmentPatterns, estimateCenter)) {
+            result->possibleAlignmentPatterns.push_back(estimateCenter);
+        }
+    }
+    Ref<AlignmentPattern> NoneEstimateCenter =
+        Ref<AlignmentPattern>(new AlignmentPattern(0, 0, moduleSize));
+    result->possibleAlignmentPatterns.push_back(NoneEstimateCenter);
+
+    if (result->possibleAlignmentPatterns.size() > 0) {
+        result->confirmedAlignmentPattern = result->possibleAlignmentPatterns[0];
+    }
+    detectorState_ = FINDALIGNPATTERN;
+
+    return result;
+}
+
+// Computes an average estimated module size based on estimated derived from the
+// positions of the three finder patterns.
+float Detector::calculateModuleSize(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
+                                    Ref<ResultPoint> bottomLeft) {
+    // Take the average
+    return (calculateModuleSizeOneWay(topLeft, topRight, NORMAL, NORMAL) +
+            calculateModuleSizeOneWay(topLeft, bottomLeft, NORMAL, NORMAL)) /
+           2.0f;
+}
+
+// Estimates module size based on two finder patterns
+// it uses sizeOfBlackWhiteBlackRunBothWays() to figure the width of each,
+// measuring along the axis between their centers.
+float Detector::calculateModuleSizeOneWay(Ref<ResultPoint> pattern, Ref<ResultPoint> otherPattern,
+                                          int patternState, int otherPatternState) {
+    float moduleSizeEst1 = sizeOfBlackWhiteBlackRunBothWays(
+        (int)pattern->getX(), (int)pattern->getY(), (int)otherPattern->getX(),
+        (int)otherPattern->getY(), patternState, false);
+    float moduleSizeEst2 = sizeOfBlackWhiteBlackRunBothWays(
+        (int)otherPattern->getX(), (int)otherPattern->getY(), (int)pattern->getX(),
+        (int)pattern->getY(), otherPatternState, true);
+    if (zxing::isnan(moduleSizeEst1)) {
+        return moduleSizeEst2 / 7.0f;
+    }
+    if (zxing::isnan(moduleSizeEst2)) {
+        return moduleSizeEst1 / 7.0f;
+    }
+    // Average them, and divide by 7 since we've counted the width of 3 black
+    // modules, and 1 white and 1 black module on either side. Ergo, divide sum
+    // by 14.
+    return (moduleSizeEst1 + moduleSizeEst2) / 14.0f;
+}
+
+// Computes the total width of a finder pattern by looking for a
+// black-white-black run from the center in the direction of another point
+// (another finder pattern center), and in the opposite direction too.
+float Detector::sizeOfBlackWhiteBlackRunBothWays(int fromX, int fromY, int toX, int toY,
+                                                 int patternState, bool isReverse) {
+    float result1 = sizeOfBlackWhiteBlackRun(fromX, fromY, toX, toY);
+    float result = 0.0;
+    // Now count other way -- don't run off image though of course
+    float scale = 1.0f;
+    int otherToX = fromX - (toX - fromX);
+    if (otherToX < 0) {
+        scale = (float)fromX / (float)(fromX - otherToX);
+        otherToX = 0;
+    } else if (otherToX >= (int)image_->getWidth()) {
+        scale = (float)(image_->getWidth() - 1 - fromX) / (float)(otherToX - fromX);
+        otherToX = image_->getWidth() - 1;
+    }
+    int otherToY = (int)(fromY - (toY - fromY) * scale);
+
+    scale = 1.0f;
+    if (otherToY < 0) {
+        scale = (float)fromY / (float)(fromY - otherToY);
+        otherToY = 0;
+    } else if (otherToY >= (int)image_->getHeight()) {
+        scale = (float)(image_->getHeight() - 1 - fromY) / (float)(otherToY - fromY);
+        otherToY = image_->getHeight() - 1;
+    }
+    otherToX = (int)(fromX + (otherToX - fromX) * scale);
+
+    float result2 = sizeOfBlackWhiteBlackRun(fromX, fromY, otherToX, otherToY);
+
+    if (patternState == FinderPattern::HORIZONTAL_STATE_LEFT_SPILL ||
+        patternState == FinderPattern::VERTICAL_STATE_UP_SPILL) {
+        if (!isReverse)
+            result = result1 * 2;
+        else
+            result = result2 * 2;
+    } else if (patternState == FinderPattern::HORIZONTAL_STATE_RIGHT_SPILL ||
+               patternState == FinderPattern::VERTICAL_STATE_DOWN_SPILL) {
+        if (!isReverse)
+            result = result2 * 2;
+        else
+            result = result1 * 2;
+    } else {
+        result = result1 + result2;
+    }
+    // Middle pixel is double-counted this way; subtract 1
+    return result - 1.0f;
+}
+
+Ref<BitMatrix> Detector::sampleGrid(Ref<BitMatrix> image, int dimension,
+                                    Ref<PerspectiveTransform> transform,
+                                    ErrorHandler &err_handler) {
+    GridSampler &sampler = GridSampler::getInstance();
+    // return sampler.sampleGrid(image, dimension, transform);
+    Ref<BitMatrix> bits = sampler.sampleGrid(image, dimension, transform, err_handler);
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+    return bits;
+}
+
+// This method traces a line from a point in the image, in the direction towards
+// another point. It begins in a black region, and keeps going until it finds
+// white, then black, then white again. It reports the distance from the start
+// to this point.
+float Detector::sizeOfBlackWhiteBlackRun(int fromX, int fromY, int toX, int toY) {
+    // Mild variant of Bresenham's algorithm;
+    // see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
+    bool steep = abs(toY - fromY) > abs(toX - fromX);
+    if (steep) {
+        // swap(fromX,fromY)
+        int temp = fromX;
+        fromX = fromY;
+        fromY = temp;
+        // swap(toX,toY)
+        temp = toX;
+        toX = toY;
+        toY = temp;
+    }
+
+    int dx = abs(toX - fromX);
+    int dy = abs(toY - fromY);
+    int error = -dx >> 1;
+    int xstep = fromX < toX ? 1 : -1;
+    int ystep = fromY < toY ? 1 : -1;
+    // In black pixels, looking for white, first or second time.
+    int state = 0;
+    // Loop up until x == toX, but not beyond
+    int xLimit = toX + xstep;
+    for (int x = fromX, y = fromY; x != xLimit; x += xstep) {
+        int realX = steep ? y : x;
+        int realY = steep ? x : y;
+
+        // Does current pixel mean we have moved white to black or vice versa?
+        // Scanning black in state 0,2 and white in state 1, so if we find the
+        // wrong color, advance to next state or end if we are in state 2
+        // already
+        if (!((state == 1) ^ image_->get(realX, realY))) {
+            if (state == 2) {
+                return MathUtils::distance(x, y, fromX, fromY);
+            }
+            state++;
+        }
+
+        error += dy;
+        if (error > 0) {
+            if (y == toY) {
+                break;
+            }
+            y += ystep;
+            error -= dx;
+        }
+    }
+    // Found black-white-black; give the benefit of the doubt that the next
+    // pixel outside the image is "white" so this last point at (toX+xStep,toY)
+    // is the right ending. This is really a small approximation;
+    // (toX+xStep,toY+yStep) might be really correct. Ignore this.
+    if (state == 2) {
+        return MathUtils::distance(toX + xstep, toY, fromX, fromY);
+    }
+    // else we didn't find even black-white-black; no estimate is really
+    // possible
+    return nan();
+}
+
+// Attempts to locate an alignment pattern in a limited region of the image,
+// which is guessed to contain it.
+Ref<AlignmentPattern> Detector::findAlignmentInRegion(float overallEstModuleSize, int estAlignmentX,
+                                                      int estAlignmentY, float allowanceFactor,
+                                                      ErrorHandler &err_handler) {
+    // Look for an alignment pattern (3 modules in size) around where it should
+    // be
+    int allowance = (int)(allowanceFactor * overallEstModuleSize);
+    int alignmentAreaLeftX = max(0, estAlignmentX - allowance);
+    int alignmentAreaRightX = min((int)(image_->getWidth() - 1), estAlignmentX + allowance);
+    if (alignmentAreaRightX - alignmentAreaLeftX < overallEstModuleSize * 3) {
+        err_handler = ReaderErrorHandler("region too small to hold alignment pattern");
+        return Ref<AlignmentPattern>();
+    }
+    int alignmentAreaTopY = max(0, estAlignmentY - allowance);
+    int alignmentAreaBottomY = min((int)(image_->getHeight() - 1), estAlignmentY + allowance);
+    if (alignmentAreaBottomY - alignmentAreaTopY < overallEstModuleSize * 3) {
+        err_handler = ReaderErrorHandler("region too small to hold alignment pattern");
+        return Ref<AlignmentPattern>();
+    }
+
+    AlignmentPatternFinder alignmentFinder(
+        image_, alignmentAreaLeftX, alignmentAreaTopY, alignmentAreaRightX - alignmentAreaLeftX,
+        alignmentAreaBottomY - alignmentAreaTopY, overallEstModuleSize);
+
+    Ref<AlignmentPattern> ap = alignmentFinder.find(err_handler);
+    if (err_handler.ErrCode()) return Ref<AlignmentPattern>();
+    return ap;
+
+}
+
+Ref<AlignmentPattern> Detector::findAlignmentWithFitLine(Ref<ResultPoint> topLeft,
+                                                         Ref<ResultPoint> topRight,
+                                                         Ref<ResultPoint> bottomLeft,
+                                                         float moduleSize,
+                                                         ErrorHandler &err_handler) {
+    float alignmentX = 0.0f, alignmentY = 0.0f;
+    int imgWidth = image_->getWidth();
+    int imgHeight = image_->getHeight();
+    Rect bottomLeftRect, topRightRect;
+    double rectSize = moduleSize * 7;
+    bottomLeftRect.x =
+        (bottomLeft->getX() - rectSize / 2.0f) > 0 ? (bottomLeft->getX() - rectSize / 2.0f) : 0;
+    bottomLeftRect.y =
+        (bottomLeft->getY() - rectSize / 2.0f) > 0 ? (bottomLeft->getY() - rectSize / 2.0f) : 0;
+    bottomLeftRect.width = (bottomLeft->getX() - bottomLeftRect.x) * 2;
+    if (bottomLeftRect.x + bottomLeftRect.width > imgWidth)
+        bottomLeftRect.width = imgWidth - bottomLeftRect.x;
+    bottomLeftRect.height = (bottomLeft->getY() - bottomLeftRect.y) * 2;
+    if (bottomLeftRect.y + bottomLeftRect.height > imgHeight)
+        bottomLeftRect.height = imgHeight - bottomLeftRect.y;
+
+    topRightRect.x =
+        (topRight->getX() - rectSize / 2.0f) > 0 ? (topRight->getX() - rectSize / 2.0f) : 0;
+    topRightRect.y =
+        (topRight->getY() - rectSize / 2.0f) > 0 ? (topRight->getY() - rectSize / 2.0f) : 0;
+    topRightRect.width = (topRight->getX() - topRightRect.x) * 2;
+    if (topRightRect.x + topRightRect.width > imgWidth)
+        topRightRect.width = imgWidth - topRightRect.x;
+    topRightRect.height = (topRight->getY() - topRightRect.y) * 2;
+    if (topRightRect.y + topRightRect.height > imgHeight)
+        topRightRect.height = imgHeight - topRightRect.y;
+
+    vector<Ref<ResultPoint> > topRightPoints;
+    vector<Ref<ResultPoint> > bottomLeftPoints;
+
+    findPointsForLine(topLeft, topRight, bottomLeft, topRightRect, bottomLeftRect, topRightPoints,
+                      bottomLeftPoints, moduleSize);
+
+    int a1;
+    float k1, b1;
+    int fitResult = fitLine(topRightPoints, k1, b1, a1);
+    if (fitResult < 0) {
+        err_handler = ReaderErrorHandler("Cannot find a valid divide for line fit");
+        return Ref<AlignmentPattern>();
+    }
+
+    int a2;
+    float k2, b2;
+    int fitResult2 = fitLine(bottomLeftPoints, k2, b2, a2);
+    if (fitResult2 < 0) {
+        err_handler = ReaderErrorHandler("Cannot find a valid divide for line fit");
+        return Ref<AlignmentPattern>();
+    }
+
+    int hasResult = 1;
+    if (a1 == 0) {
+        if (a2 == 0) {
+            hasResult = 0;
+        } else {
+            alignmentX = -b1;
+            alignmentY = b2 - b1 * k2;
+        }
+    } else {
+        if (a2 == 0) {
+            alignmentX = -b2;
+            alignmentY = b1 - b2 * k1;
+        } else {
+            if (k1 == k2) {
+                hasResult = 0;
+            } else {
+                alignmentX = (b2 - b1) / (k1 - k2);
+                alignmentY = k1 * alignmentX + b1;
+            }
+        }
+    }
+
+    // Donot have a valid divide
+    if (hasResult == 0) {
+        err_handler = ReaderErrorHandler("Cannot find a valid divide for line fit");
+        return Ref<AlignmentPattern>();
+    }
+    Ref<AlignmentPattern> result(new AlignmentPattern(alignmentX, alignmentY, moduleSize));
+    return result;
+}
+
+void Detector::fixAlignmentPattern(float &alignmentX, float &alignmentY, float moduleSize) {
+    int imgWidth = image_->getWidth();
+    int imgHeight = image_->getHeight();
+    int maxFixStep = moduleSize * 2;
+    int fixStep = 0;
+    while (alignmentX < imgWidth && alignmentY < imgHeight && alignmentX > 0 && alignmentY > 0 &&
+           !image_->get(alignmentX, alignmentY) && fixStep < maxFixStep) {
+        ++fixStep;
+        // Newest Version:  The fix process is like this:
+        // 1  2  3
+        // 4  0  5
+        // 6  7  8
+        for (int y = alignmentY - fixStep; y <= alignmentY + fixStep; y++) {
+            if (y == alignmentY - fixStep || y == alignmentY + fixStep) {
+                for (int x = alignmentX - fixStep; x <= alignmentX + fixStep; x++) {
+                    if (x < imgWidth && y < imgHeight && x > 0 && y > 0 && image_->get(x, y)) {
+                        alignmentX = x;
+                        alignmentY = y;
+                        return;
+                    }
+                }
+            } else {
+                int x = alignmentX - fixStep;
+                if (x < imgWidth && y < imgHeight && x > 0 && y > 0 && image_->get(x, y)) {
+                    alignmentX = x;
+                    alignmentY = y;
+                    return;
+                }
+                x = alignmentX + fixStep;
+                if (x < imgWidth && y < imgHeight && x > 0 && y > 0 && image_->get(x, y)) {
+                    alignmentX = x;
+                    alignmentY = y;
+                    return;
+                }
+            }
+        }
+    }
+
+    return;
+}
+
+int Detector::fitLine(vector<Ref<ResultPoint> > &oldPoints, float &k, float &b, int &a) {
+    a = 1;
+    k = 0.0f;
+    b = 0.0f;
+    int old_num = oldPoints.size();
+    if (old_num < 2) {
+        return -1;
+    }
+    float tolerance = 2.0f;
+    vector<Ref<ResultPoint> > fitPoints;
+    float pre_diff = -1;
+    for (vector<Ref<ResultPoint> >::iterator it = oldPoints.begin() + 1; it != oldPoints.end() - 1;
+         it++) {
+        float diff_x = 0.0f, diff_y = 0.0f, diff = 0.0f;
+        if (pre_diff < 0) {
+            diff_x = (*(it - 1))->getX() - (*it)->getX();
+            diff_y = (*(it - 1))->getY() - (*it)->getY();
+            diff = (diff_x * diff_x + diff_y * diff_y);
+            pre_diff = diff;
+        }
+        diff_x = (*(it + 1))->getX() - (*it)->getX();
+        diff_y = (*(it + 1))->getY() - (*it)->getY();
+        diff = (diff_x * diff_x + diff_y * diff_y);
+        if (pre_diff <= tolerance && diff <= tolerance) {
+            fitPoints.push_back(*(it));
+        }
+        pre_diff = diff;
+    }
+
+    int num = fitPoints.size();
+    if (num < 2) return -1;
+
+    double x = 0, y = 0, xx = 0, xy = 0, yy = 0, tem = 0;
+    for (int i = 0; i < num; i++) {
+        int point_x = fitPoints[i]->getX();
+        int point_y = fitPoints[i]->getY();
+        x += point_x;
+        y += point_y;
+        xx += point_x * point_x;
+        xy += point_x * point_y;
+        yy += point_y * point_y;
+    }
+
+    tem = xx * num - x * x;
+    if (abs(tem) < 0.0000001) {
+        // Set b as average x
+        b = -x / num;
+        a = 0;
+        k = 1;
+
+        return 1;
+    }
+
+    k = (num * xy - x * y) / tem;
+    b = (y - k * x) / num;
+    a = 1;
+    if (abs(k) < 0.01) k = 0;
+    return 1;
+}
+
+bool Detector::checkTolerance(Ref<ResultPoint> &topLeft, Ref<ResultPoint> &topRight,
+                              Rect &topRightRect, double modelSize, Ref<ResultPoint> &p, int flag) {
+    int topLeftX = topLeft->getX(), topLeftY = topLeft->getY(), topRightX = topRight->getX(),
+        topRightY = topRight->getY();
+    double left_right_k = 0.0f, left_right_b = 0.0f, left_right_b_tolerance, tolerance_b1 = 0.0f,
+           tolerance_b2 = 0.0f;
+    if (flag < 2) {
+        double tolerance_y1 = 0.0f, tolerance_y2 = 0.0f;
+        double tolerance_x = topRightRect.x;
+        if (flag == 1) tolerance_x = topRightRect.x + topRightRect.width;
+        if (topRightX != topLeftX) {
+            left_right_k = (topRightY - topLeftY) / (double)(topRightX - topLeftX);
+            left_right_b = (topRightY - left_right_k * topRightX);
+            double tmp_1 = modelSize * 2.5f;
+            double tmp_2 = tmp_1 * left_right_k;
+
+            left_right_b_tolerance = sqrt(tmp_1 * tmp_1 + tmp_2 * tmp_2);
+            tolerance_b1 = left_right_b - left_right_b_tolerance;
+            tolerance_b2 = left_right_b + left_right_b_tolerance;
+            tolerance_y1 = left_right_k * tolerance_x + tolerance_b1;
+            tolerance_y2 = left_right_k * tolerance_x + tolerance_b2;
+        } else {
+            return false;
+        }
+        if (p->getY() < tolerance_y1 || p->getY() > tolerance_y2) return false;
+        return true;
+    } else {
+        double tolerance_x1 = 0.0f, tolerance_x2 = 0.0f;
+        if (topRightY != topLeftY) {
+            double tolerance_y = topRightRect.y;
+            if (flag == 3) tolerance_y = topRightRect.y + topRightRect.height;
+            left_right_k = (topRightX - topLeftX) / (double)(topRightY - topLeftY);
+            left_right_b = (topRightX - left_right_k * topRightY);
+            double tmp_1 = modelSize * 2.5f;
+            double tmp_2 = tmp_1 / left_right_k;
+            left_right_b_tolerance = sqrt(tmp_1 * tmp_1 + tmp_2 * tmp_2);
+            tolerance_b1 = left_right_b - left_right_b_tolerance;
+            tolerance_b2 = left_right_b + left_right_b_tolerance;
+            tolerance_x1 = left_right_k * tolerance_y + tolerance_b1;
+            tolerance_x2 = left_right_k * tolerance_y + tolerance_b2;
+            if (p->getX() < tolerance_x1 || p->getX() > tolerance_x2) return false;
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+void Detector::findPointsForLine(Ref<ResultPoint> &topLeft, Ref<ResultPoint> &topRight,
+                                 Ref<ResultPoint> &bottomLeft, Rect topRightRect,
+                                 Rect bottomLeftRect, vector<Ref<ResultPoint> > &topRightPoints,
+                                 vector<Ref<ResultPoint> > &bottomLeftPoints, float modelSize) {
+    int topLeftX = topLeft->getX(), topLeftY = topLeft->getY(), topRightX = topRight->getX(),
+        topRightY = topRight->getY();
+    if (!topRightPoints.empty()) topRightPoints.clear();
+    if (!bottomLeftPoints.empty()) bottomLeftPoints.clear();
+
+    int xMin = 0;
+    int xMax = 0;
+    int yMin = 0;
+    int yMax = 0;
+
+    int imgWidth = image_->getWidth();
+    int imgHeight = image_->getHeight();
+
+    // [-45, 45] or [135, 180) or [-180, -45)
+    if (topLeftY == topRightY || abs((topRightX - topLeftX) / (topRightY - topLeftY)) >= 1) {
+        if (topLeftX < topRightX) {
+            xMin = topRightRect.x;
+            xMax = topRightRect.x + modelSize * 2;
+            yMin = topRightRect.y + modelSize;
+            yMax = topRightRect.y - modelSize + topRightRect.height;
+            // [-45, 45] TopRight: left, black->white points; BottomLeft: top, black->white points
+            MathUtils::getRangeValues(xMin, xMax, 0, imgWidth - 1);
+            MathUtils::getRangeValues(yMin, yMax, 0, imgHeight - 1);
+
+            for (int i = yMin; i < yMax; i++) {
+                for (int j = xMin; j < xMax; j++) {
+                    // left->right, black->white
+                    if (image_->get(j, i) && !image_->get(j + 1, i)) {
+                        Ref<ResultPoint> topRightPoint(new ResultPoint(j, i));
+                        if (checkTolerance(topLeft, topRight, topRightRect, modelSize,
+                                           topRightPoint, 0)) {
+                            topRightPoints.push_back(topRightPoint);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            xMin = bottomLeftRect.x + modelSize;
+            xMax = bottomLeftRect.x - modelSize + bottomLeftRect.width;
+            yMin = bottomLeftRect.y;
+            yMax = bottomLeftRect.y + 2 * modelSize;
+
+            MathUtils::getRangeValues(xMin, xMax, 0, imgWidth - 1);
+            MathUtils::getRangeValues(yMin, yMax, 0, imgHeight - 1);
+
+            for (int j = xMin; j < xMax; j++) {
+                for (int i = yMin; i < yMax; i++) {
+                    // top to down, black->white
+                    if (image_->get(j, i) && !image_->get(j, i + 1)) {
+                        Ref<ResultPoint> bottomLeftPoint(new ResultPoint(j, i));
+                        if (checkTolerance(topLeft, bottomLeft, bottomLeftRect, modelSize,
+                                           bottomLeftPoint, 2)) {
+                            bottomLeftPoints.push_back(bottomLeftPoint);
+                            break;
+                        }
+                    }
+                }
+            }
+        } else {
+            // white->black points
+            xMin = topRightRect.x + topRightRect.width - 2 * modelSize;
+            xMax = topRightRect.x + topRightRect.width;
+            yMin = topRightRect.y + modelSize;
+            yMax = topRightRect.y - modelSize + topRightRect.height;
+            // [135, 180) or [-180, -45)  TopRight: right, white->black points; BottomLeft: bottom,
+            MathUtils::getRangeValues(xMin, xMax, 0, imgWidth - 1);
+            MathUtils::getRangeValues(yMin, yMax, 0, imgHeight - 1);
+
+            for (int i = yMin; i < yMax; i++) {
+                for (int j = xMin; j < xMax; j++) {
+                    // left->right, white->black
+                    if (!image_->get(j, i) && image_->get(j + 1, i)) {
+                        Ref<ResultPoint> topRightPoint(new ResultPoint(j, i));
+                        if (checkTolerance(topLeft, topRight, topRightRect, modelSize,
+                                           topRightPoint, 1)) {
+                            topRightPoints.push_back(topRightPoint);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            xMin = bottomLeftRect.x + modelSize;
+            xMax = bottomLeftRect.x - modelSize + bottomLeftRect.width;
+            yMin = bottomLeftRect.y + bottomLeftRect.height - 2 * modelSize;
+            yMax = bottomLeftRect.y + bottomLeftRect.height;
+
+            MathUtils::getRangeValues(xMin, xMax, 0, imgWidth - 1);
+            MathUtils::getRangeValues(yMin, yMax, 0, imgHeight - 1);
+
+            for (int j = xMin; j < xMax; j++) {
+                for (int i = yMin; i < yMax; i++) {
+                    // top to down, white->black
+                    if (!image_->get(j, i) && image_->get(j, i + 1)) {
+                        Ref<ResultPoint> bottomLeftPoint(new ResultPoint(j, i));
+                        if (checkTolerance(topLeft, bottomLeft, bottomLeftRect, modelSize,
+                                           bottomLeftPoint, 3)) {
+                            bottomLeftPoints.push_back(bottomLeftPoint);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    } else {
+        // (45, 135) or (-45, -135)
+        // (45, 135) TopRight: top, black->white; BottomRight: right, black->white
+        if (topLeftY < topRightY) {
+            xMin = topRightRect.x + modelSize;
+            xMax = topRightRect.x - modelSize + topRightRect.width;
+            yMin = topRightRect.y;
+            yMax = topRightRect.y + 2 * modelSize;
+
+            MathUtils::getRangeValues(xMin, xMax, 0, imgWidth - 1);
+            MathUtils::getRangeValues(yMin, yMax, 0, imgHeight - 1);
+
+            for (int j = xMin; j < xMax; j++) {
+                for (int i = yMin; i < yMax; i++) {
+                    // top to down, black->white
+                    if (image_->get(j, i) && !image_->get(j, i + 1)) {
+                        Ref<ResultPoint> topRightPoint(new ResultPoint(j, i));
+                        if (checkTolerance(topLeft, topRight, topRightRect, modelSize,
+                                           topRightPoint, 2)) {
+                            topRightPoints.push_back(topRightPoint);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            xMin = topRightRect.x + topRightRect.width - 2 * modelSize;
+            xMax = topRightRect.x + topRightRect.width;
+            yMin = topRightRect.y + modelSize;
+            yMax = topRightRect.y - modelSize + topRightRect.height;
+
+            MathUtils::getRangeValues(xMin, xMax, 0, imgWidth - 1);
+            MathUtils::getRangeValues(yMin, yMax, 0, imgHeight - 1);
+
+            for (int i = yMin; i < yMax; i++) {
+                for (int j = xMin; j < xMax; j++) {
+                    // left to right, white-> black
+                    if (!image_->get(j, i) && image_->get(j + 1, i)) {
+                        Ref<ResultPoint> bottomLeftPoint(new ResultPoint(j, i));
+                        if (checkTolerance(topLeft, bottomLeft, bottomLeftRect, modelSize,
+                                           bottomLeftPoint, 1)) {
+                            bottomLeftPoints.push_back(bottomLeftPoint);
+                            break;
+                        }
+                    }
+                }
+            }
+        } else {
+            // (-45, -135) TopRight: bottom, white->black; BottomRight: left, black->white
+            xMin = topRightRect.x + modelSize;
+            xMax = topRightRect.x - modelSize + topRightRect.width;
+            yMin = topRightRect.y + topRightRect.height - 2 * modelSize;
+            yMax = topRightRect.y + topRightRect.height;
+
+            MathUtils::getRangeValues(xMin, xMax, 0, imgWidth - 1);
+            MathUtils::getRangeValues(yMin, yMax, 0, imgHeight - 1);
+
+            for (int j = xMin; j < xMax; j++) {
+                for (int i = yMin; i < yMax; i++) {
+                    // top to down, white->balck
+                    if (!image_->get(j, i) && image_->get(j, i + 1)) {
+                        Ref<ResultPoint> topRightPoint(new ResultPoint(j, i));
+                        if (checkTolerance(topLeft, topRight, topRightRect, modelSize,
+                                           topRightPoint, 3)) {
+                            topRightPoints.push_back(topRightPoint);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            xMin = bottomLeftRect.x;
+            xMax = bottomLeftRect.x + 2 * modelSize;
+            yMin = bottomLeftRect.y + modelSize;
+            yMax = bottomLeftRect.y + bottomLeftRect.height - modelSize;
+
+            MathUtils::getRangeValues(xMin, xMax, 0, imgWidth - 1);
+            MathUtils::getRangeValues(yMin, yMax, 0, imgHeight - 1);
+
+            for (int i = yMin; i < yMax; i++) {
+                for (int j = xMin; j < xMax; j++) {
+                    // left to right, black->white
+                    if (image_->get(j, i) && !image_->get(j + 1, i)) {
+                        Ref<ResultPoint> bottomLeftPoint(new ResultPoint(j, i));
+                        if (checkTolerance(topLeft, bottomLeft, bottomLeftRect, modelSize,
+                                           bottomLeftPoint, 0)) {
+                            bottomLeftPoints.push_back(bottomLeftPoint);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+Ref<PerspectiveTransform> Detector::createTransform(Ref<FinderPatternInfo> info,
+                                                    Ref<ResultPoint> alignmentPattern,
+                                                    int dimension) {
+    Ref<FinderPattern> topLeft(info->getTopLeft());
+    Ref<FinderPattern> topRight(info->getTopRight());
+    Ref<FinderPattern> bottomLeft(info->getBottomLeft());
+    Ref<PerspectiveTransform> transform =
+        createTransform(topLeft, topRight, bottomLeft, alignmentPattern, dimension);
+    return transform;
+}
+
+Ref<PerspectiveTransform> Detector::createTransform(Ref<ResultPoint> topLeft,
+                                                    Ref<ResultPoint> topRight,
+                                                    Ref<ResultPoint> bottomLeft,
+                                                    Ref<ResultPoint> alignmentPattern,
+                                                    int dimension) {
+    float dimMinusThree = (float)dimension - 3.5f;
+    float bottomRightX;
+    float bottomRightY;
+    float sourceBottomRightX;
+    float sourceBottomRightY;
+    if (alignmentPattern && alignmentPattern->getX()) {
+        bottomRightX = alignmentPattern->getX();
+        bottomRightY = alignmentPattern->getY();
+        sourceBottomRightX = dimMinusThree - 3.0f;
+        sourceBottomRightY = sourceBottomRightX;
+    } else {
+        // Don't have an alignment pattern, just make up the bottom-right point
+        bottomRightX = (topRight->getX() - topLeft->getX()) + bottomLeft->getX();
+        bottomRightY = (topRight->getY() - topLeft->getY()) + bottomLeft->getY();
+        float deltaX = topLeft->getX() - bottomLeft->getX();
+        float deltaY = topLeft->getY() - bottomLeft->getY();
+        if (fabs(deltaX) < fabs(deltaY))
+            deltaY = topLeft->getY() - topRight->getY();
+        else
+            deltaX = topLeft->getX() - topRight->getX();
+        bottomRightX += 2 * deltaX;
+        bottomRightY += 2 * deltaY;
+        sourceBottomRightX = dimMinusThree;
+        sourceBottomRightY = dimMinusThree;
+    }
+    Ref<PerspectiveTransform> transform(PerspectiveTransform::quadrilateralToQuadrilateral(
+        3.5f, 3.5f, dimMinusThree, 3.5f, sourceBottomRightX, sourceBottomRightY, 3.5f,
+        dimMinusThree, topLeft->getX(), topLeft->getY(), topRight->getX(), topRight->getY(),
+        bottomRightX, bottomRightY, bottomLeft->getX(), bottomLeft->getY()));
+    return transform;
+}
+
+// Computes the dimension (number of modules on a size) of the QR code based on
+// the position of the finder patterns and estimated module size.
+int Detector::computeDimension(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
+                               Ref<ResultPoint> bottomLeft, float moduleSizeX, float moduleSizeY) {
+    int tltrCentersDimension = ResultPoint::distance(topLeft, topRight) / moduleSizeX;
+    int tlblCentersDimension = ResultPoint::distance(topLeft, bottomLeft) / moduleSizeY;
+
+    float tmp_dimension = ((tltrCentersDimension + tlblCentersDimension) / 2.0) + 7.0;
+    int dimension = cvRound(tmp_dimension);
+    int mod = dimension & 0x03;  // mod 4
+
+    switch (mod) {  // mod 4
+        case 0:
+            dimension++;
+            break;
+            // 1? do nothing
+        case 2:
+            dimension--;
+            break;
+    }
+    return dimension;
+}
+
+bool Detector::checkConvexQuadrilateral(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
+                                        Ref<ResultPoint> bottomLeft, Ref<ResultPoint> bottomRight) {
+    float v1[2];
+    float v2[2];
+    float v3[2];
+    float v4[2];
+
+    v1[0] = topLeft->getX() - topRight->getX();
+    v1[1] = topLeft->getY() - topRight->getY();
+    v2[0] = topRight->getX() - bottomRight->getX();
+    v2[1] = topRight->getY() - bottomRight->getY();
+    v3[0] = bottomRight->getX() - bottomLeft->getX();
+    v3[1] = bottomRight->getY() - bottomLeft->getY();
+    v4[0] = bottomLeft->getX() - topLeft->getX();
+    v4[1] = bottomLeft->getY() - topLeft->getY();
+
+    float c1 = MathUtils::VecCross(v1, v2);
+    float c2 = MathUtils::VecCross(v2, v3);
+    float c3 = MathUtils::VecCross(v3, v4);
+    float c4 = MathUtils::VecCross(v4, v1);
+
+    if ((c1 < 0.0 && c2 < 0.0 && c3 < 0.0 && c4 < 0.0) ||
+        (c1 > 0.0 && c2 > 0.0 && c3 > 0.0 && c4 > 0.0))
+        return true;
+    else
+        return false;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/detector.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/detector.hpp
new file mode 100644
index 00000000..fbb8147d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/detector.hpp
@@ -0,0 +1,145 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DETECTOR_DETECTOR_HPP_
+#define __ZXING_QRCODE_DETECTOR_DETECTOR_HPP_
+
+#include "../../common/bitmatrix.hpp"
+#include "../../common/counted.hpp"
+#include "../../common/detector_result.hpp"
+#include "../../common/perspective_transform.hpp"
+#include "../../common/unicomblock.hpp"
+#include "../../errorhandler.hpp"
+#include "alignment_pattern.hpp"
+#include "finder_pattern.hpp"
+#include "finder_pattern_info.hpp"
+#include "pattern_result.hpp"
+
+namespace zxing {
+class DecodeHints;
+
+namespace qrcode {
+
+// Possible Detect Result
+
+class Detector : public Counted {
+public:
+    enum DetectorState {
+        START = 10,
+        FINDFINDERPATTERN = 11,
+        FINDALIGNPATTERN = 12,
+    };
+
+    // Fix module size error when LEFT_SPILL or RIGHT_SPILL
+    enum FinderPatternMode {
+        NORMAL = 0,
+        LEFT_SPILL = 1,
+        RIGHT_SPILL = 2,
+        UP_SPILL = 3,
+        DOWN_SPILL = 4,
+    };
+
+    typedef struct Rect_ {
+        int x;
+        int y;
+        int width;
+        int height;
+    } Rect;
+
+private:
+    Ref<BitMatrix> image_;
+    Ref<UnicomBlock> block_;
+
+    vector<Ref<PatternResult> > possiblePatternResults_;
+
+
+    DetectorState detectorState_;
+
+protected:
+    Ref<BitMatrix> getImage() const;
+    static int computeDimension(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
+                                Ref<ResultPoint> bottomLeft, float moduleSizeX, float moduleSizeY);
+    float calculateModuleSize(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
+                              Ref<ResultPoint> bottomLeft);
+    float calculateModuleSizeOneWay(Ref<ResultPoint> pattern, Ref<ResultPoint> otherPattern,
+                                    int patternState, int otherPatternState);
+    float sizeOfBlackWhiteBlackRunBothWays(int fromX, int fromY, int toX, int toY, int patternState,
+                                           bool isReverse);
+    float sizeOfBlackWhiteBlackRunBothWays(int fromX, int fromY, int toX, int toY);
+    float sizeOfBlackWhiteBlackRun(int fromX, int fromY, int toX, int toY);
+    Ref<AlignmentPattern> findAlignmentInRegion(float overallEstModuleSize, int estAlignmentX,
+                                                int estAlignmentY, float allowanceFactor,
+                                                ErrorHandler &err_handler);
+    Ref<AlignmentPattern> findAlignmentWithFitLine(Ref<ResultPoint> topLeft,
+                                                   Ref<ResultPoint> topRight,
+                                                   Ref<ResultPoint> bottomLeft, float moduleSize,
+                                                   ErrorHandler &err_handler);
+    int fitLine(vector<Ref<ResultPoint> > &oldPoints, float &k, float &b, int &a);
+    bool checkTolerance(Ref<ResultPoint> &topLeft, Ref<ResultPoint> &topRight, Rect &topRightRect,
+                        double modelSize, Ref<ResultPoint> &p, int flag);
+    void findPointsForLine(Ref<ResultPoint> &topLeft, Ref<ResultPoint> &topRight,
+                           Ref<ResultPoint> &bottomLeft, Rect topRightRect, Rect bottomLeftRect,
+                           vector<Ref<ResultPoint> > &topRightPoints,
+                           vector<Ref<ResultPoint> > &bottomLeftPoints, float modelSize);
+    bool checkConvexQuadrilateral(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
+                                  Ref<ResultPoint> bottomLeft, Ref<ResultPoint> bottomRight);
+
+public:
+    virtual Ref<PerspectiveTransform> createTransform(Ref<ResultPoint> topLeft,
+                                                      Ref<ResultPoint> topRight,
+                                                      Ref<ResultPoint> bottomLeft,
+                                                      Ref<ResultPoint> alignmentPattern,
+                                                      int dimension);
+    Ref<PerspectiveTransform> createTransform(Ref<FinderPatternInfo> finderPatternInfo,
+                                              Ref<ResultPoint> alignmentPattern, int dimension);
+
+    static Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image, int dimension, Ref<PerspectiveTransform>,
+                                     ErrorHandler &err_handler);
+
+    Detector(Ref<BitMatrix> image, Ref<UnicomBlock> block);
+    void detect(DecodeHints const &hints, ErrorHandler &err_handler);
+    Ref<DetectorResult> getResultViaAlignment(int patternIdx, int alignmentIndex,
+                                              int possibleDimension, ErrorHandler &err_handler);
+
+    int getPossiblePatternCount() { return possiblePatternResults_.size(); }
+    int getPossibleAlignmentCount(int idx);
+
+    Ref<AlignmentPattern> getNearestAlignmentPattern(int tryFindRange, float moduleSize,
+                                                     int estAlignmentX, int estAlignmentY);
+    bool hasSameResult(vector<Ref<AlignmentPattern> > possibleAlignmentPatterns,
+                       Ref<AlignmentPattern> alignmentPattern);
+    void fixAlignmentPattern(float &alignmentX, float &alignmentY, float moduleSize);
+
+    Ref<PatternResult> processFinderPatternInfo(Ref<FinderPatternInfo> info,
+                                                ErrorHandler &err_handler);
+
+public:
+    Ref<FinderPatternInfo> getFinderPatternInfo(int idx) {
+        return possiblePatternResults_[idx]->finderPatternInfo;
+    }
+    Ref<AlignmentPattern> getAlignmentPattern(int patternIdx, int alignmentIdx) {
+        return possiblePatternResults_[patternIdx]->possibleAlignmentPatterns[alignmentIdx];
+    }
+
+    DetectorState getState() { return detectorState_; }
+
+    unsigned int getPossibleVersion(int idx) {
+        return possiblePatternResults_[idx]->possibleVersion;
+    }
+    float getPossibleFix(int idx) { return possiblePatternResults_[idx]->possibleFix; }
+    float getPossibleModuleSize(int idx) {
+        return possiblePatternResults_[idx]->possibleModuleSize;
+    }
+    int getDimension(int idx) { return possiblePatternResults_[idx]->possibleDimension; }
+};
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DETECTOR_DETECTOR_HPP_
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern.cpp
new file mode 100644
index 00000000..c357f312
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern.cpp
@@ -0,0 +1,91 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "finder_pattern.hpp"
+
+using zxing::Ref;
+
+namespace zxing {
+namespace qrcode {
+
+FinderPattern::FinderPattern(float posX, float posY, float estimatedModuleSize)
+    : ResultPoint(posX, posY),
+      estimatedModuleSize_(estimatedModuleSize),
+      count_(1),
+      horizontalState_(FinderPattern::HORIZONTAL_STATE_NORMAL),
+      verticalState_(FinderPattern::VERTICAL_STATE_NORMAL) {
+    fix_ = -1.0f;
+}
+
+FinderPattern::FinderPattern(float posX, float posY, float estimatedModuleSize, int count)
+    : ResultPoint(posX, posY),
+      estimatedModuleSize_(estimatedModuleSize),
+      count_(count),
+      horizontalState_(FinderPattern::HORIZONTAL_STATE_NORMAL),
+      verticalState_(FinderPattern::VERTICAL_STATE_NORMAL) {
+    fix_ = -1.0f;
+}
+int FinderPattern::getCount() const { return count_; }
+void FinderPattern::incrementCount() { count_++; }
+
+bool FinderPattern::aboutEquals(float moduleSize, float i, float j) const {
+    if (abs(i - getY()) <= moduleSize && abs(j - getX()) <= moduleSize) {
+        float moduleSizeDiff = abs(moduleSize - estimatedModuleSize_);
+        return moduleSizeDiff <= 1.0f || moduleSizeDiff <= estimatedModuleSize_;
+    }
+    return false;
+}
+
+float FinderPattern::getEstimatedModuleSize() const { return estimatedModuleSize_; }
+
+Ref<FinderPattern> FinderPattern::combineEstimate(float i, float j, float newModuleSize) const {
+    int combinedCount = count_ + 1;
+    float combinedX = getX();
+    float combinedY = getY();
+    float combinedModuleSize = getEstimatedModuleSize();
+    if (combinedCount <= 3) {
+        combinedX = (count_ * getX() + j) / combinedCount;
+        combinedY = (count_ * getY() + i) / combinedCount;
+        combinedModuleSize = (count_ * getEstimatedModuleSize() + newModuleSize) / combinedCount;
+    }
+    return Ref<FinderPattern>(
+        new FinderPattern(combinedX, combinedY, combinedModuleSize, combinedCount));
+}
+
+void FinderPattern::setHorizontalCheckState(int state) {
+    switch (state) {
+        case 0:
+            horizontalState_ = FinderPattern::HORIZONTAL_STATE_NORMAL;
+            break;
+        case 1:
+            horizontalState_ = FinderPattern::HORIZONTAL_STATE_LEFT_SPILL;
+            break;
+        case 2:
+            horizontalState_ = FinderPattern::HORIZONTAL_STATE_RIGHT_SPILL;
+            break;
+    }
+    return;
+}
+void FinderPattern::setVerticalCheckState(int state) {
+    switch (state) {
+        case 0:
+            verticalState_ = FinderPattern::VERTICAL_STATE_NORMAL;
+            break;
+        case 1:
+            verticalState_ = FinderPattern::VERTICAL_STATE_UP_SPILL;
+            break;
+        case 2:
+            verticalState_ = FinderPattern::VERTICAL_STATE_DOWN_SPILL;
+            break;
+    }
+    return;
+}
+}  // namespace qrcode
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern.hpp
new file mode 100644
index 00000000..d7733e0c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern.hpp
@@ -0,0 +1,59 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DETECTOR_FINDER_PATTERN_HPP_
+#define __ZXING_QRCODE_DETECTOR_FINDER_PATTERN_HPP_
+
+#include "../../common/bitmatrix.hpp"
+#include "../../resultpoint.hpp"
+
+namespace zxing {
+namespace qrcode {
+
+class FinderPattern : public ResultPoint {
+public:
+    enum CheckState {
+        HORIZONTAL_STATE_NORMAL = 0,
+        HORIZONTAL_STATE_LEFT_SPILL = 1,
+        HORIZONTAL_STATE_RIGHT_SPILL = 2,
+        VERTICAL_STATE_NORMAL = 3,
+        VERTICAL_STATE_UP_SPILL = 4,
+        VERTICAL_STATE_DOWN_SPILL = 5
+    };
+
+private:
+    float estimatedModuleSize_;
+    int count_;
+
+    FinderPattern(float posX, float posY, float estimatedModuleSize, int count);
+
+public:
+    FinderPattern(float posX, float posY, float estimatedModuleSize);
+    int getCount() const;
+    float getEstimatedModuleSize() const;
+    void incrementCount();
+    bool aboutEquals(float moduleSize, float i, float j) const;
+    Ref<FinderPattern> combineEstimate(float i, float j, float newModuleSize) const;
+
+    void setHorizontalCheckState(int state);
+    void setVerticalCheckState(int state);
+
+    int getHorizontalCheckState() { return horizontalState_; }
+    int getVerticalCheckState() { return verticalState_; }
+
+private:
+    float fix_;
+    CheckState horizontalState_;
+    CheckState verticalState_;
+};
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DETECTOR_FINDER_PATTERN_HPP_
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_finder.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_finder.cpp
new file mode 100644
index 00000000..438928c0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_finder.cpp
@@ -0,0 +1,1508 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "finder_pattern_finder.hpp"
+#include "../../common/kmeans.hpp"
+#include "../../common/mathutils.hpp"
+#include "../../decodehints.hpp"
+#include "../../errorhandler.hpp"
+
+using zxing::Ref;
+using zxing::qrcode::FinderPattern;
+using zxing::qrcode::FinderPatternFinder;
+using zxing::qrcode::FinderPatternInfo;
+
+// VC++
+
+using zxing::BitMatrix;
+using zxing::DecodeHints;
+using zxing::ResultPoint;
+
+namespace zxing {
+
+namespace qrcode {
+
+
+namespace {
+class FurthestFromAverageComparator {
+private:
+    const float averageModuleSize_;
+
+public:
+    explicit FurthestFromAverageComparator(float averageModuleSize)
+        : averageModuleSize_(averageModuleSize) {}
+    bool operator()(Ref<FinderPattern> a, Ref<FinderPattern> b) {
+        float dA = abs(a->getEstimatedModuleSize() - averageModuleSize_);
+        float dB = abs(b->getEstimatedModuleSize() - averageModuleSize_);
+        return dA > dB;
+    }
+};
+
+// Orders by furthes from average
+class CenterComparator {
+    const float averageModuleSize_;
+
+public:
+    explicit CenterComparator(float averageModuleSize) : averageModuleSize_(averageModuleSize) {}
+    bool operator()(Ref<FinderPattern> a, Ref<FinderPattern> b) {
+        // N.B.: we want the result in descending order ...
+        if (a->getCount() != b->getCount()) {
+            return a->getCount() > b->getCount();
+        } else {
+            float dA = abs(a->getEstimatedModuleSize() - averageModuleSize_);
+            float dB = abs(b->getEstimatedModuleSize() - averageModuleSize_);
+            return dA < dB;
+        }
+    }
+};
+
+class CountComparator {
+public:
+    bool operator()(Ref<FinderPattern> a, Ref<FinderPattern> b) {
+        return a->getCount() > b->getCount();
+    }
+};
+
+class ModuleSizeComparator {
+public:
+    bool operator()(Ref<FinderPattern> a, Ref<FinderPattern> b) {
+        return a->getEstimatedModuleSize() > b->getEstimatedModuleSize();
+    }
+};
+
+class BestComparator {
+public:
+    bool operator()(Ref<FinderPattern> a, Ref<FinderPattern> b) {
+        if (a->getCount() != b->getCount()) {
+            return a->getCount() > b->getCount();
+        } else {
+            return a->getEstimatedModuleSize() > b->getEstimatedModuleSize();
+        }
+    }
+};
+class BestComparator2 {
+public:
+    bool operator()(Ref<FinderPattern> a, Ref<FinderPattern> b) {
+        if (a->getCount() != b->getCount()) {
+            return a->getCount() > b->getCount();
+        } else {
+            int aErr = 0, bErr = 0;
+            if (a->getHorizontalCheckState() != FinderPattern::HORIZONTAL_STATE_NORMAL) aErr++;
+            if (a->getVerticalCheckState() != FinderPattern::VERTICAL_STATE_NORMAL) aErr++;
+            if (b->getHorizontalCheckState() != FinderPattern::HORIZONTAL_STATE_NORMAL) bErr++;
+            if (b->getVerticalCheckState() != FinderPattern::VERTICAL_STATE_NORMAL) bErr++;
+
+            if (aErr != bErr) {
+                return aErr < bErr;
+            } else {
+                return a->getEstimatedModuleSize() > b->getEstimatedModuleSize();
+            }
+        }
+    }
+};
+
+class XComparator {
+public:
+    bool operator()(Ref<FinderPattern> a, Ref<FinderPattern> b) { return a->getX() < b->getX(); }
+};
+
+class YComparator {
+public:
+    bool operator()(Ref<FinderPattern> a, Ref<FinderPattern> b) { return a->getY() < b->getY(); }
+};
+
+}  // namespace
+
+int FinderPatternFinder::CENTER_QUORUM = 2;
+int FinderPatternFinder::MIN_SKIP = 1;       // 1 pixel/module times MIN_SKIP modules/center
+int FinderPatternFinder::MAX_MODULES = 177;  // support up to version 40  which has 177 modules
+int FinderPatternFinder::INTEGER_MATH_SHIFT = 8;
+int FinderPatternFinder::FP_INPUT_CNN_MAX_NUM = 10;
+int FinderPatternFinder::FP_IS_SELECT_BEST = 1;
+int FinderPatternFinder::FP_IS_SELECT_FILE_BEST = 1;
+int FinderPatternFinder::FP_INPUT_MAX_NUM = 100;
+int FinderPatternFinder::FP_FILTER_SIZE = 100;
+int FinderPatternFinder::FPS_CLUSTER_MAX = 4;
+int FinderPatternFinder::FPS_RESULT_MAX = 12;
+int FinderPatternFinder::K_FACTOR = 2;
+
+float FinderPatternFinder::FPS_MS_VAL = 1.0f;
+float FinderPatternFinder::FP_COUNT_MIN = 2.0f;
+float FinderPatternFinder::FP_MS_MIN = 1.0f;
+float FinderPatternFinder::FP_RIGHT_ANGLE = 0.342f;
+float FinderPatternFinder::FP_SMALL_ANGLE1 = 0.8191f;
+float FinderPatternFinder::FP_SMALL_ANGLE2 = 0.5736f;
+float FinderPatternFinder::QR_MIN_FP_AREA_ERR = 3;
+float FinderPatternFinder::QR_MIN_FP_MS_ERR = 1;
+int FinderPatternFinder::QR_MIN_FP_ACCEPT = 4;
+
+std::vector<Ref<FinderPatternInfo>> FinderPatternFinder::find(DecodeHints const& hints,
+                                                              ErrorHandler& err_handler) {
+    bool tryHarder = true;
+
+    size_t maxI = image_->getHeight();
+    size_t maxJ = image_->getWidth();
+    // Init pre check result
+    _horizontalCheckedResult.clear();
+    _horizontalCheckedResult.resize(maxJ);
+    // As this is used often, we use an integer array instead of vector
+    int stateCount[5];
+
+    // Let's assume that the maximum version QR Code we support
+    // (Version 40, 177modules, and finder pattern start at: 0~7) takes up 1/4
+    // the height of the image, and then account for the center being 3
+    // modules in size. This gives the smallest number of pixels the center
+    // could be, so skip this often. When trying harder, look for all
+    // QR versions regardless of how dense they are.
+    int iSkip = (3 * maxI) / (4 * MAX_MODULES);
+    if (iSkip < MIN_SKIP || tryHarder) {
+        iSkip = MIN_SKIP;
+    }
+
+    // This is slightly faster than using the Ref. Efficiency is important here
+    BitMatrix& matrix = *image_;
+
+    // If we need to use getRowRecords or getRowCounterOffsetEnd, we should call
+    // initRowCounters first
+    matrix.initRowCounters();
+
+    // scan line algorithm
+    for (size_t i = iSkip - 1; i < maxI; i += iSkip) {
+        COUNTER_TYPE* irow_states = matrix.getRowRecords(i);
+        COUNTER_TYPE* irow_offsets = matrix.getRowRecordsOffset(i);
+
+        size_t rj = matrix.getRowFirstIsWhite(i) ? 1 : 0;
+        COUNTER_TYPE row_counter_width = matrix.getRowCounterOffsetEnd(i);
+        // because the rj is black, rj+1 must be white, so we can skip it by +2
+        for (; (rj + 4) < size_t(row_counter_width) && (rj + 4) < maxJ; rj += 2) {
+            stateCount[0] = irow_states[rj];
+            stateCount[1] = irow_states[rj + 1];
+            stateCount[2] = irow_states[rj + 2];
+            stateCount[3] = irow_states[rj + 3];
+            stateCount[4] = irow_states[rj + 4];
+
+            size_t j = irow_offsets[rj + 4] + stateCount[4];
+            if (j > maxJ) {
+                rj = row_counter_width - 1;
+                continue;
+            }
+            if (foundPatternCross(stateCount)) {
+                if (j == maxJ) {
+                    // check whether it is the "true" central
+                    bool confirmed = handlePossibleCenter(stateCount, i, maxJ);
+                    if (confirmed) {
+                        iSkip = int(possibleCenters_.back()->getEstimatedModuleSize());
+                        if (iSkip < 1) iSkip = 1;
+                    }
+                    rj = row_counter_width - 1;
+                    continue;
+                } else {
+                    bool confirmed = handlePossibleCenter(stateCount, i, j);
+                    if (confirmed) {
+                        // Start examining every other line. Checking each line
+                        // turned out to be too expensive and didn't improve
+                        // performance.
+                        iSkip = 2;
+                        if (!hasSkipped_) {
+                            int rowSkip = findRowSkip();
+                            if (rowSkip > stateCount[2]) {
+                                // Skip rows between row of lower confirmed
+                                // center and top of presumed third confirmed
+                                // center but back up a bit to get a full chance
+                                // of detecting it, entire width of center of
+                                // finder pattern Skip by rowSkip, but back off
+                                // by stateCount[2] (size of last center of
+                                // pattern we saw) to be conservative, and also
+                                // back off by iSkip which is about to be
+                                // re-added
+                                i += rowSkip - stateCount[2] - iSkip;
+                                rj = row_counter_width - 1;
+                                j = maxJ - 1;
+                            }
+                        }
+                    } else {
+                        continue;
+                    }
+                    rj += 4;
+                }
+            }
+        }
+    }
+    // use connected cells algorithm
+    {
+        for (size_t i = iSkip - 1; i < maxI; i += iSkip) {
+            COUNTER_TYPE* irow_states = matrix.getRowRecords(i);
+            COUNTER_TYPE* irow_offsets = matrix.getRowRecordsOffset(i);
+            COUNTER_TYPE row_counter_width = matrix.getRowCounterOffsetEnd(i);
+
+            for (size_t rj = matrix.getRowFirstIsWhite(i) ? 1 : 0;
+                 (rj + 4) < size_t(row_counter_width); rj += 2) {
+                if (block_->GetUnicomBlockIndex(i, irow_offsets[rj]) ==
+                        block_->GetUnicomBlockIndex(i, irow_offsets[rj + 4]) &&
+                    block_->GetUnicomBlockIndex(i, irow_offsets[rj + 1]) ==
+                        block_->GetUnicomBlockIndex(i, irow_offsets[rj + 3]) &&
+                    block_->GetUnicomBlockIndex(i, irow_offsets[rj]) !=
+                        block_->GetUnicomBlockIndex(i, irow_offsets[rj + 2])) {
+                    const int iBlackCir = block_->GetUnicomBlockSize(i, irow_offsets[rj]);
+                    const int iWhiteCir = block_->GetUnicomBlockSize(i, irow_offsets[rj + 1]);
+                    const int iBlackPnt = block_->GetUnicomBlockSize(i, irow_offsets[rj + 2]);
+
+                    if (-1 == iBlackCir || -1 == iWhiteCir) continue;
+
+                    const float fBlackCir = sqrt(iBlackCir / 24.0);
+                    const float fWhiteCir = sqrt(iWhiteCir / 16.0);
+                    const float fBlackPnt = sqrt(iBlackPnt / 9.0);
+
+                    // use center 1:3:1, because the border may be padded.
+                    // a plan for MS
+                    const float fRealMS = sqrt((iWhiteCir + iBlackPnt) / 25.0);
+
+                    // b plan for MS
+                    int iTotalCount = 0;
+                    for (int j = 1; j < 4; ++j) iTotalCount += irow_states[rj + j];
+                    const float fEstRowMS = iTotalCount / 5.0;
+
+                    if (fabs(fBlackCir - fWhiteCir) <= QR_MIN_FP_AREA_ERR &&
+                        fabs(fWhiteCir - fBlackPnt) <= QR_MIN_FP_AREA_ERR &&
+                        fabs(fRealMS - fEstRowMS) < QR_MIN_FP_MS_ERR) {
+                        int centerI = 0;
+                        int centerJ = 0;
+                        if (fRealMS < QR_MIN_FP_ACCEPT) {
+                            centerI = i;
+                            centerJ = irow_offsets[rj + 2] + irow_states[rj + 2] / 2;
+                        } else {
+                            int iMinX = 0, iMinY = 0, iMaxX = 0, iMaxY = 0;
+                            block_->GetMinPoint(i, irow_offsets[rj + 1], iMinY, iMinX);
+                            block_->GetMaxPoint(i, irow_offsets[rj + 3], iMaxY, iMaxX);
+                            centerI = (iMaxY + iMinY) / 2.0;  // y
+                            centerJ = (iMaxX + iMinX) / 2.0;  // x
+                        }
+                        tryToPushToCenters(centerI, centerJ, fRealMS);
+                        int rowSkip = findRowSkip();
+                        if (rowSkip > irow_states[rj + 2]) {
+                            // Skip rows between row of lower confirmed center
+                            // and top of presumed third confirmed center but
+                            // back up a bit to get a full chance of detecting
+                            // it, entire width of center of finder pattern Skip
+                            // by rowSkip, but back off by stateCount[2] (size
+                            // of last center of pattern we saw) to be
+                            // conservative, and also back off by iSkip which is
+                            // about to be re-added
+                            i += rowSkip - irow_states[rj + 2] - iSkip;
+                            rj = row_counter_width - 1;
+                        }
+                        rj += 4;
+                    }
+                }
+            }
+        }
+    }
+
+    vector<Ref<FinderPatternInfo>> patternInfos = getPatternInfosFileMode(hints, err_handler);
+    if (err_handler.ErrCode()) {
+        return std::vector<Ref<FinderPatternInfo>>();
+    }
+    // sort with score
+    sort(patternInfos.begin(), patternInfos.end(),
+         [](Ref<FinderPatternInfo> a, Ref<FinderPatternInfo> b) {
+             return a->getPossibleFix() > b->getPossibleFix();
+         });
+
+    return patternInfos;
+}
+
+bool FinderPatternFinder::tryToPushToCenters(float centerI, float centerJ,
+                                             float estimatedModuleSize,
+                                             CrossCheckState horizontalState,
+                                             CrossCheckState verticalState) {
+    for (size_t index = 0; index < possibleCenters_.size(); index++) {
+        Ref<FinderPattern> center = possibleCenters_[index];
+        // Look for about the same center and module size:
+        if (center->aboutEquals(estimatedModuleSize, centerI, centerJ)) {
+            possibleCenters_[index] =
+                center->combineEstimate(centerI, centerJ, estimatedModuleSize);
+            possibleCenters_[index]->setHorizontalCheckState(
+                horizontalState == FinderPatternFinder::NORMAL ? center->getHorizontalCheckState()
+                                                               : horizontalState);
+            possibleCenters_[index]->setVerticalCheckState(
+                verticalState == FinderPatternFinder::NORMAL ? center->getVerticalCheckState()
+                                                             : verticalState);
+            return false;
+        }
+    }
+    Ref<FinderPattern> newPattern(new FinderPattern(centerJ, centerI, estimatedModuleSize));
+    newPattern->setHorizontalCheckState(horizontalState);
+    newPattern->setVerticalCheckState(verticalState);
+    possibleCenters_.push_back(newPattern);
+    return true;
+}
+
+bool FinderPatternFinder::isEqualResult(Ref<FinderPatternInfo> src, Ref<FinderPatternInfo> dst) {
+    if (src == NULL) {
+        return false;
+    }
+
+    if (dst == NULL) {
+        return true;
+    }
+
+    auto topLeft = src->getTopLeft();
+    auto bottomLeft = src->getBottomLeft();
+    auto topRight = src->getTopRight();
+
+    return topLeft->aboutEquals(1.0, dst->getTopLeft()->getY(), dst->getTopLeft()->getX()) &&
+           bottomLeft->aboutEquals(1.0, dst->getBottomLeft()->getY(),
+                                   dst->getBottomLeft()->getX()) &&
+           topRight->aboutEquals(1.0, dst->getTopRight()->getY(), dst->getTopRight()->getX());
+}
+
+bool FinderPatternFinder::IsPossibleFindPatterInfo(Ref<FinderPattern> a, Ref<FinderPattern> b,
+                                                   Ref<FinderPattern> c) {
+    // check variance
+    float aMs = a->getEstimatedModuleSize();
+    float bMs = b->getEstimatedModuleSize();
+    float cMs = c->getEstimatedModuleSize();
+
+    float avg = (aMs + bMs + cMs) / 3.0;
+    float val =
+        sqrt((aMs - avg) * (aMs - avg) + (bMs - avg) * (bMs - avg) + (cMs - avg) * (cMs - avg));
+
+    if (val >= FPS_MS_VAL) return false;
+
+    float longSize = 0.0;
+
+    return checkIsoscelesRightTriangle(a, b, c, longSize);
+}
+
+void FinderPatternFinder::PushToResult(Ref<FinderPattern> a, Ref<FinderPattern> b,
+                                       Ref<FinderPattern> c,
+                                       vector<Ref<FinderPatternInfo>>& patternInfos) {
+    vector<Ref<FinderPattern>> finderPatterns;
+    finderPatterns.push_back(a);
+    finderPatterns.push_back(b);
+    finderPatterns.push_back(c);
+    vector<Ref<FinderPattern>> finderPattern = orderBestPatterns(finderPatterns);
+
+    Ref<FinderPatternInfo> patternInfo(new FinderPatternInfo(finderPattern));
+
+    for (size_t j = 0; j < patternInfos.size(); j++) {
+        if (isEqualResult(patternInfos[j], patternInfo)) {
+            return;
+        }
+    }
+    patternInfos.push_back(patternInfo);
+}
+
+vector<Ref<FinderPatternInfo>> FinderPatternFinder::getPatternInfosFileMode(
+    DecodeHints const& hints, ErrorHandler& err_handler) {
+    size_t startSize = possibleCenters_.size();
+
+    if (startSize < 3) {
+        // Couldn't find enough finder patterns
+        err_handler = ReaderErrorHandler("Could not find three finder patterns");
+        return vector<Ref<FinderPatternInfo>>();
+    }
+
+    std::vector<Ref<FinderPatternInfo>> patternInfos;
+
+    if (startSize == 3) {
+        PushToResult(possibleCenters_[0], possibleCenters_[1], possibleCenters_[2], patternInfos);
+        return patternInfos;
+    }
+
+    vector<Ref<FinderPattern>> finderPatterns;
+    Ref<FinderPatternInfo> resultBest;
+
+    // select best
+    if (FP_IS_SELECT_BEST) {
+        finderPatterns = selectBestPatterns(err_handler);
+        if (err_handler.ErrCode() == 0)
+            PushToResult(finderPatterns[0], finderPatterns[1], finderPatterns[2], patternInfos);
+    }
+
+    if (FP_IS_SELECT_FILE_BEST) {
+        finderPatterns = selectFileBestPatterns(err_handler);
+        if (err_handler.ErrCode() == 0)
+            PushToResult(finderPatterns[0], finderPatterns[1], finderPatterns[2], patternInfos);
+    }
+
+    // sort and filter
+    sort(possibleCenters_.begin(), possibleCenters_.end(), ModuleSizeComparator());
+    std::vector<Ref<FinderPattern>> standardCenters;
+
+    for (size_t i = 0; i < possibleCenters_.size(); i++) {
+        if (possibleCenters_[i]->getEstimatedModuleSize() >= FP_MS_MIN &&
+            possibleCenters_[i]->getCount() >= FP_COUNT_MIN) {
+            standardCenters.push_back(possibleCenters_[i]);
+            if (standardCenters.size() >= size_t(FP_INPUT_MAX_NUM)) break;
+            if (hints.getUseNNDetector() && standardCenters.size() >= size_t(FP_INPUT_CNN_MAX_NUM))
+                break;
+        }
+    }
+
+    if (standardCenters.size() < 3) {
+        err_handler = ReaderErrorHandler("Could not find three finder patterns");
+        return vector<Ref<FinderPatternInfo>>();
+    }
+
+    if (standardCenters.size() <= size_t(FP_INPUT_CNN_MAX_NUM)) {
+        for (size_t x = 0; x < standardCenters.size(); x++) {
+            for (size_t y = x + 1; y < standardCenters.size(); y++) {
+                for (size_t z = y + 1; z < standardCenters.size(); z++) {
+                    bool check_result = IsPossibleFindPatterInfo(
+                        standardCenters[x], standardCenters[y], standardCenters[z]);
+                    if (check_result) {
+                        PushToResult(standardCenters[x], standardCenters[y], standardCenters[z],
+                                     patternInfos);
+                    }
+                }
+            }
+        }
+        return patternInfos;
+    }
+
+    // Kmeans
+    const int maxepoches = 100;
+    const int minchanged = 0;
+    // calculate K
+    int k = log(float(standardCenters.size())) * K_FACTOR - 1;
+    if (k < 1) k = 1;
+
+    vector<vector<double>> trainX;
+    for (size_t i = 0; i < standardCenters.size(); i++) {
+        vector<double> tmp;
+        tmp.push_back(standardCenters[i]->getCount());
+        tmp.push_back(standardCenters[i]->getEstimatedModuleSize());
+        trainX.push_back(tmp);
+    }
+
+    vector<Cluster> clusters_out = k_means(trainX, k, maxepoches, minchanged);
+
+    for (size_t i = 0; i < clusters_out.size(); i++) {
+        int cluster_select = 0;
+
+        if (clusters_out[i].samples.size() < 3) {
+            if (i < clusters_out.size() - 1 && clusters_out[i + 1].samples.size() < 3) {
+                for (size_t j = 0; j < clusters_out[i].samples.size(); j++)
+                    clusters_out[i + 1].samples.push_back(clusters_out[i].samples[j]);
+            }
+            continue;
+        }
+
+        vector<Ref<FinderPattern>> clusterPatterns;
+        for (size_t j = 0; j < clusters_out[i].samples.size(); j++) {
+            clusterPatterns.push_back(standardCenters[clusters_out[i].samples[j]]);
+        }
+
+        sort(clusterPatterns.begin(), clusterPatterns.end(), BestComparator2());
+
+        for (size_t x = 0;
+             x < clusters_out[i].samples.size() && cluster_select <= FPS_CLUSTER_MAX &&
+             patternInfos.size() <= size_t(FPS_RESULT_MAX);
+             x++) {
+            for (size_t y = x + 1;
+                 y < clusters_out[i].samples.size() && cluster_select <= FPS_CLUSTER_MAX &&
+                 patternInfos.size() <= size_t(FPS_RESULT_MAX);
+                 y++) {
+                for (size_t z = y + 1;
+                     z < clusters_out[i].samples.size() && cluster_select <= FPS_CLUSTER_MAX &&
+                     patternInfos.size() <= size_t(FPS_RESULT_MAX);
+                     z++) {
+                    bool check_result = IsPossibleFindPatterInfo(
+                        clusterPatterns[x], clusterPatterns[y], clusterPatterns[z]);
+                    if (check_result) {
+                        PushToResult(clusterPatterns[x], clusterPatterns[y], clusterPatterns[z],
+                                     patternInfos);
+                        cluster_select++;
+                    }
+                }
+            }
+        }
+    }
+    return patternInfos;
+}
+
+// Given a count of black/white/black/white/black pixels just seen and an end
+// position, figures the location of the center of this run.
+float FinderPatternFinder::centerFromEnd(int* stateCount, int end) {
+    // calculate the center by pattern 1:3:1 is better than pattern 3
+    // because the finder pattern is irregular in some case
+    return (float)(end - stateCount[4]) - (stateCount[3] + stateCount[2] + stateCount[1]) / 2.0f;
+}
+
+// return if the proportions of the counts is close enough to 1/1/3/1/1 ratios
+// used by finder patterns to be considered a match
+bool FinderPatternFinder::foundPatternCross(int* stateCount) {
+    int totalModuleSize = 0;
+
+    int stateCountINT[5];
+
+    int minModuleSizeINT = 3;
+    minModuleSizeINT <<= INTEGER_MATH_SHIFT;
+
+    for (int i = 0; i < 5; i++) {
+        if (stateCount[i] <= 0) {
+            return false;
+        }
+        stateCountINT[i] = stateCount[i] << INTEGER_MATH_SHIFT;
+        totalModuleSize += stateCount[i];
+    }
+    if (totalModuleSize < 7) {
+        return false;
+    }
+
+    CURRENT_CHECK_STATE = FinderPatternFinder::NOT_PATTERN;
+
+    totalModuleSize = totalModuleSize << INTEGER_MATH_SHIFT;
+
+    // Newer version to check 1 time, use 3 points
+    int moduleSize = ((totalModuleSize - stateCountINT[0] - stateCountINT[4])) / 5;
+
+    int maxVariance = moduleSize;
+
+    if (moduleSize > minModuleSizeINT) maxVariance = moduleSize / 2;
+
+    int startCountINT = stateCountINT[0];
+    int endCountINT = stateCountINT[4];
+
+    bool leftFit = (abs(moduleSize - startCountINT) <= maxVariance);
+    bool rightFit = (abs(moduleSize - endCountINT) <= maxVariance);
+
+    if (leftFit) {
+        if (rightFit) {
+            moduleSize = totalModuleSize / 7;
+            CURRENT_CHECK_STATE = FinderPatternFinder::NORMAL;
+        } else {
+            moduleSize = (totalModuleSize - stateCountINT[4]) / 6;
+            CURRENT_CHECK_STATE = FinderPatternFinder::RIHGT_SPILL;
+        }
+    } else {
+        if (rightFit) {
+            moduleSize = (totalModuleSize - stateCountINT[0]) / 6;
+            CURRENT_CHECK_STATE = FinderPatternFinder::LEFT_SPILL;
+        } else {
+            // return false;
+            CURRENT_CHECK_STATE = FinderPatternFinder::LEFT_RIGHT_SPILL;
+        }
+    }
+
+    // 1:1:3:1:1 || n:1:3:1:1 || 1:1:3:1:n
+    if (abs(moduleSize - stateCountINT[1]) <= maxVariance &&
+        abs(3 * moduleSize - stateCountINT[2]) <= 3 * maxVariance &&
+        abs(moduleSize - stateCountINT[3]) <= maxVariance) {
+        return true;
+    }
+    return false;
+}
+
+int FinderPatternFinder::getMinModuleSize() {
+    int minModuleSize = (3 * min(image_->getWidth(), image_->getHeight())) / (4 * MAX_MODULES);
+
+    if (minModuleSize < MIN_SKIP) {
+        minModuleSize = MIN_SKIP;
+    }
+
+    return minModuleSize;
+}
+
+/**
+ * After a vertical and horizontal scan finds a potential finder pattern, this
+ * method "cross-cross-cross-checks" by scanning down diagonally through the
+ * center of the possible finder pattern to see if the same proportion is
+ * detected.
+ *
+ * @param startI row where a finder pattern was detected
+ * @param centerJ center of the section that appears to cross a finder pattern
+ * @param maxCount maximum reasonable number of modules that should be
+ *  observed in any reading state, based on the results of the horizontal scan
+ * @param originalStateCountTotal The original state count total.
+ * @return true if proportions are withing expected limits
+ */
+bool FinderPatternFinder::crossCheckDiagonal(int startI, int centerJ, int maxCount,
+                                             int originalStateCountTotal) {
+    int maxI = image_->getHeight();
+    int maxJ = image_->getWidth();
+
+    if ((startI < 0) || (startI > maxI - 1) || (centerJ < 0) || (centerJ > maxJ - 1)) {
+        return false;
+    }
+
+    int stateCount[5];
+    stateCount[0] = 0;
+    stateCount[1] = 0;
+    stateCount[2] = 0;
+    stateCount[3] = 0;
+    stateCount[4] = 0;
+
+    if (!image_->get(centerJ, startI)) {
+        if (startI + 1 < maxI && image_->get(centerJ, startI + 1))
+            startI = startI + 1;
+        else if (0 < startI - 1 && image_->get(centerJ, startI - 1))
+            startI = startI - 1;
+        else
+            return false;
+    }
+
+    // This is slightly faster than using the Ref. Efficiency is important here
+    BitMatrix& matrix = *image_;
+
+    // Start counting up, left from center finding black center mass
+    int i = 0;
+    // Fix possible crash 20140418
+    // while (startI - i >= 0 && image.get(centerJ - i, startI - i)) {
+    while ((startI - i >= 0) && (centerJ - i >= 0) && matrix.get(centerJ - i, startI - i)) {
+        stateCount[2]++;
+        i++;
+    }
+
+    if ((startI - i < 0) || (centerJ - i < 0)) {
+        return false;
+    }
+
+    // Continue up, left finding white space
+    while ((startI - i >= 0) && (centerJ - i >= 0) && !matrix.get(centerJ - i, startI - i) &&
+           stateCount[1] <= maxCount) {
+        stateCount[1]++;
+        i++;
+    }
+
+    // If already too many modules in this state or ran off the edge:
+    if ((startI - i < 0) || (centerJ - i < 0) || stateCount[1] > maxCount) {
+        return false;
+    }
+
+    CrossCheckState tmpCheckState = FinderPatternFinder::NORMAL;
+
+    // Continue up, left finding black border
+    while ((startI - i >= 0) && (centerJ - i >= 0) && matrix.get(centerJ - i, startI - i) &&
+           stateCount[0] <= maxCount) {
+        stateCount[0]++;
+        i++;
+    }
+
+    if (stateCount[0] >= maxCount) {
+        tmpCheckState = FinderPatternFinder::LEFT_SPILL;
+    }
+
+    // Now also count down, right from center
+    i = 1;
+    while ((startI + i < maxI) && (centerJ + i < maxJ) && matrix.get(centerJ + i, startI + i)) {
+        stateCount[2]++;
+        i++;
+    }
+
+    // Ran off the edge?
+    if ((startI + i >= maxI) || (centerJ + i >= maxJ)) {
+        return false;
+    }
+
+    while ((startI + i < maxI) && (centerJ + i < maxJ) && !matrix.get(centerJ + i, startI + i) &&
+           stateCount[3] < maxCount) {
+        stateCount[3]++;
+        i++;
+    }
+
+    if ((startI + i >= maxI) || (centerJ + i >= maxJ) || stateCount[3] >= maxCount) {
+        return false;
+    }
+
+    while ((startI + i < maxI) && (centerJ + i < maxJ) && matrix.get(centerJ + i, startI + i) &&
+           stateCount[4] < maxCount) {
+        stateCount[4]++;
+        i++;
+    }
+
+    if (stateCount[4] >= maxCount) {
+        tmpCheckState = tmpCheckState == FinderPatternFinder::LEFT_SPILL
+                            ? FinderPatternFinder::LEFT_RIGHT_SPILL
+                            : FinderPatternFinder::RIHGT_SPILL;
+    }
+
+    bool diagonal_check = foundPatternCross(stateCount);
+    if (!diagonal_check) return false;
+
+    if (CURRENT_CHECK_STATE == FinderPatternFinder::LEFT_SPILL &&
+        tmpCheckState == FinderPatternFinder::RIHGT_SPILL)
+        return false;
+
+    if (CURRENT_CHECK_STATE == FinderPatternFinder::RIHGT_SPILL &&
+        tmpCheckState == FinderPatternFinder::LEFT_SPILL)
+        return false;
+
+    int stateCountTotal = getStateCountTotal(stateCount, CURRENT_CHECK_STATE);
+
+    if (abs(stateCountTotal - originalStateCountTotal) < 2 * originalStateCountTotal) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+int FinderPatternFinder::getStateCountTotal(int* stateCount, const CrossCheckState& check_state) {
+    int stateCountTotal = stateCount[1] + stateCount[2] + stateCount[3];
+    if (check_state == FinderPatternFinder::NORMAL) {
+        stateCountTotal = stateCountTotal + stateCount[0] + stateCount[4];
+    } else if (check_state == FinderPatternFinder::LEFT_SPILL) {
+        stateCountTotal = stateCountTotal + stateCount[1] + stateCount[4];
+    } else if (check_state == FinderPatternFinder::RIHGT_SPILL) {
+        stateCountTotal = stateCountTotal + stateCount[0] + stateCount[3];
+    } else if (check_state == FinderPatternFinder::LEFT_RIGHT_SPILL) {
+        stateCountTotal = stateCountTotal + stateCount[1] + stateCount[3];
+    }
+    return stateCountTotal;
+}
+// After a horizontal scan finds a potential finder pattern, this method
+// "cross-checks" by scanning down vertically through the center of the possible
+// finder pattern to see if the same proportion is detected.
+float FinderPatternFinder::crossCheckVertical(size_t startI, size_t centerJ, int maxCount,
+                                              int originalStateCountTotal,
+                                              float& estimatedVerticalModuleSize) {
+    int maxI = image_->getHeight();
+
+    int stateCount[5];
+    for (int i = 0; i < 5; i++) stateCount[i] = 0;
+
+    if (!image_->get(centerJ, startI)) {
+        if ((int)startI + 1 < maxI && image_->get(centerJ, startI + 1))
+            startI = startI + 1;
+        else if (0 < (int)startI - 1 && image_->get(centerJ, startI - 1))
+            startI = startI - 1;
+        else
+            return nan();
+    }
+
+    // This is slightly faster than using the Ref. Efficiency is important here
+    BitMatrix& matrix = *image_;
+
+    bool* imageRow0 = matrix.getRowBoolPtr(0);
+    bool* p = imageRow0;
+    int imgWidth = matrix.getWidth();
+
+    // Start counting up from center
+    int ii = startI;
+
+    p = imageRow0 + ii * imgWidth + centerJ;
+
+    while (ii >= 0 && *p) {
+        stateCount[2]++;
+        ii--;
+        p -= imgWidth;
+    }
+    if (ii < 0) {
+        return nan();
+    }
+    while (ii >= 0 && !*p && stateCount[1] <= maxCount) {
+        stateCount[1]++;
+        ii--;
+        p -= imgWidth;
+    }
+    // If already too many modules in this state or ran off the edge:
+    if (ii < 0 || stateCount[1] > maxCount) {
+        return nan();
+    }
+
+    CrossCheckState tmpCheckState = FinderPatternFinder::NORMAL;
+
+    while (ii >= 0 && *p /*&& stateCount[0] <= maxCount*/) {  // n:1:3:1:1
+        stateCount[0]++;
+        ii--;
+        p -= imgWidth;
+    }
+
+    if (stateCount[0] >= maxCount) {
+        tmpCheckState = FinderPatternFinder::LEFT_SPILL;
+    }
+
+    // Now also count down from center
+    ii = startI + 1;
+
+    p = imageRow0 + ii * imgWidth + centerJ;
+
+    while (ii < maxI && *p) {  // 1:1:"3":1:1
+                               // while (ii < maxI && matrix.get(centerJ, ii)) {
+        stateCount[2]++;
+        ii++;
+
+        p += imgWidth;
+    }
+    if (ii == maxI) {
+        return nan();
+    }
+    while (ii < maxI && !*p && stateCount[3] < maxCount) {  // 1:1:3:"1":1
+        stateCount[3]++;
+        ii++;
+
+        p += imgWidth;
+    }
+    if (ii == maxI || stateCount[3] >= maxCount) {
+        return nan();
+    }
+
+    if (tmpCheckState == FinderPatternFinder::LEFT_SPILL) {
+        while (ii < maxI && *p && stateCount[4] < maxCount) {  // 1:1:3:1:"1"
+            stateCount[4]++;
+            ii++;
+
+            p += imgWidth;
+        }
+        if (stateCount[4] >= maxCount) {
+            return nan();
+        }
+    } else {  // 1:1:3:1:"n"
+        while (ii < maxI && *p) {
+            stateCount[4]++;
+            ii++;
+
+            p += imgWidth;
+        }
+        if (stateCount[4] >= maxCount) {
+            tmpCheckState = FinderPatternFinder::RIHGT_SPILL;
+        }
+    }
+
+    bool vertical_check = foundPatternCross(stateCount);
+    if (!vertical_check) return nan();
+
+    if ((CURRENT_CHECK_STATE == FinderPatternFinder::LEFT_SPILL &&
+         tmpCheckState == FinderPatternFinder::RIHGT_SPILL) ||
+        (CURRENT_CHECK_STATE == FinderPatternFinder::RIHGT_SPILL &&
+         tmpCheckState == FinderPatternFinder::LEFT_SPILL)) {
+        return nan();
+    }
+
+    int stateCountTotal = getStateCountTotal(stateCount, CURRENT_CHECK_STATE);
+
+    // If we found a finder-pattern-like section, but its size is more than 40%
+    // different than the original, assume it's a false positive
+    if (5 * abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
+        return nan();
+    }
+
+    estimatedVerticalModuleSize = (float)stateCountTotal / 7.0f;
+
+    return centerFromEnd(stateCount, ii);
+}
+
+// Like #crossCheckVertical(), and in fact is basically identical,
+// except it reads horizontally instead of vertically. This is used to
+// cross-cross check a vertical cross check and locate the real center of the
+// alignment pattern.
+float FinderPatternFinder::crossCheckHorizontal(size_t startJ, size_t centerI, int maxCount,
+                                                int originalStateCountTotal,
+                                                float& estimatedHorizontalModuleSize) {
+    int maxJ = image_->getWidth();
+
+    int stateCount[5];
+    for (int i = 0; i < 5; i++) stateCount[i] = 0;
+
+    if (!image_->get(startJ, centerI)) {
+        if ((int)startJ + 1 < maxJ && image_->get(startJ + 1, centerI))
+            startJ = startJ + 1;
+        else if (0 < (int)startJ - 1 && image_->get(startJ - 1, centerI))
+            startJ = startJ - 1;
+        else
+            return nan();
+    }
+
+    // This is slightly faster than using the Ref. Efficiency is important here
+    BitMatrix& matrix = *image_;
+    int j = startJ;
+
+    bool* centerIrow = NULL;
+
+    centerIrow = matrix.getRowBoolPtr(centerI);
+
+    //	while (j >= 0 &&matrix.get(j, centerI)) {
+    while (j >= 0 && centerIrow[j]) {
+        stateCount[2]++;
+        j--;
+    }
+    if (j < 0) {
+        return nan();
+    }
+    while (j >= 0 && !centerIrow[j] && stateCount[1] <= maxCount) {
+        stateCount[1]++;
+        j--;
+    }
+    if (j < 0 || stateCount[1] > maxCount) {
+        return nan();
+    }
+    CrossCheckState tmpCheckState = FinderPatternFinder::NORMAL;
+
+    while (j >= 0 && centerIrow[j] /* && stateCount[0] <= maxCount*/) {
+        stateCount[0]++;
+        j--;
+    }
+    if (stateCount[0] >= maxCount) {
+        tmpCheckState = FinderPatternFinder::LEFT_SPILL;
+    }
+
+    j = startJ + 1;
+    while (j < maxJ && centerIrow[j]) {
+        stateCount[2]++;
+        j++;
+    }
+    if (j == maxJ) {
+        return nan();
+    }
+    while (j < maxJ && !centerIrow[j] && stateCount[3] < maxCount) {
+        stateCount[3]++;
+        j++;
+    }
+    if (j == maxJ || stateCount[3] >= maxCount) {
+        return nan();
+    }
+
+    if (tmpCheckState == LEFT_SPILL) {
+        while (j < maxJ && centerIrow[j] && stateCount[4] <= maxCount) {
+            stateCount[4]++;
+            j++;
+        }
+        if (stateCount[4] >= maxCount) {
+            return nan();
+        }
+    } else {
+        while (j < maxJ && centerIrow[j]) {
+            stateCount[4]++;
+            j++;
+        }
+        if (stateCount[4] >= maxCount) {
+            tmpCheckState = RIHGT_SPILL;
+        }
+    }
+
+    while (j < maxJ && centerIrow[j] /*&& stateCount[4] < maxCount*/) {
+        stateCount[4]++;
+        j++;
+    }
+
+    // If we found a finder-pattern-like section, but its size is significantly
+    // different than the original, assume it's a false positive
+    // int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] +
+    // stateCount[3] + stateCount[4];
+    bool horizontal_check = foundPatternCross(stateCount);
+    if (!horizontal_check) return nan();
+
+    /*
+    if(tmpCheckState!=CURRENT_CHECK_STATE)
+        return nan();*/
+
+    // Cannot be a LEFT-RIGHT center
+    if ((CURRENT_CHECK_STATE == FinderPatternFinder::LEFT_SPILL &&
+         tmpCheckState == FinderPatternFinder::RIHGT_SPILL) ||
+        (CURRENT_CHECK_STATE == FinderPatternFinder::RIHGT_SPILL &&
+         tmpCheckState == FinderPatternFinder::LEFT_SPILL)) {
+        return nan();
+    }
+
+    int stateCountTotal = getStateCountTotal(stateCount, CURRENT_CHECK_STATE);
+    if (5 * abs(stateCountTotal - originalStateCountTotal) >= originalStateCountTotal) {
+        return nan();
+    }
+
+    estimatedHorizontalModuleSize = (float)stateCountTotal / 7.0f;
+    return centerFromEnd(stateCount, j);
+}
+
+float FinderPatternFinder::hasHorizontalCheckedResult(size_t startJ, size_t centerI) {
+    for (size_t i = 0; i < _horizontalCheckedResult[startJ].size(); i++) {
+        if (_horizontalCheckedResult[startJ][i].centerI == centerI) {
+            return _horizontalCheckedResult[startJ][i].centerJ;
+        }
+    }
+
+    return -1.0;
+}
+
+int FinderPatternFinder::addHorizontalCheckedResult(size_t startJ, size_t centerI, float centerJ) {
+    HorizontalCheckedResult result;
+    result.centerI = centerI;
+    result.centerJ = centerJ;
+
+    _horizontalCheckedResult[startJ].push_back(result);
+
+    return 1;
+}
+
+#define CENTER_CHECK_TIME 3
+
+/**
+ * <p>This is called when a horizontal scan finds a possible alignment pattern.
+ * It will cross check with a vertical scan, and if successful, will, ah,
+ * cross-cross-check with another horizontal scan. This is needed primarily to
+ * locate the real horizontal center of the pattern in cases of extreme skew.
+ * And then we cross-cross-cross check with another diagonal scan.</p>
+ *
+ * <p>If that succeeds the finder pattern location is added to a list that
+ * tracks the number of times each location has been nearly-matched as a finder
+ * pattern. Each additional find is more evidence that the location is in fact a
+ * finder pattern center
+ *
+ * @param stateCount reading state module counts from horizontal scan
+ * @param i row where finder pattern may be found
+ * @param j end of possible finder pattern in row
+ * @return true if a finder pattern candidate was found this time
+ */
+bool FinderPatternFinder::handlePossibleCenter(int* stateCount, size_t i, size_t j) {
+    CrossCheckState tmpHorizontalState = CURRENT_CHECK_STATE;
+    float centerJ = centerFromEnd(stateCount, j);
+    int stateCountTotal = stateCount[1] + stateCount[2] + stateCount[3];
+    if (tmpHorizontalState == FinderPatternFinder::NORMAL) {
+        // 1:1:3:1:1
+        stateCountTotal = stateCountTotal + stateCount[0] + stateCount[4];
+    } else if (tmpHorizontalState == FinderPatternFinder::LEFT_SPILL) {
+        // n:1:3:1:1
+        stateCountTotal = stateCountTotal + stateCount[1] + stateCount[4];
+    } else if (tmpHorizontalState == FinderPatternFinder::RIHGT_SPILL) {
+        // 1:1:3:1:n
+        stateCountTotal = stateCountTotal + stateCount[0] + stateCount[3];
+    }
+    float estimatedHorizontalModuleSize = (float)stateCountTotal / 7.0f;
+
+    float estimatedVerticalModuleSize;
+
+    // try different size according to the estimatedHorizontalModuleSize
+    float tolerateModuleSize =
+        estimatedHorizontalModuleSize > 4.0 ? estimatedHorizontalModuleSize / 2.0f : 1.0f;
+    float possbileCenterJs[7] = {centerJ,
+                                 centerJ - tolerateModuleSize,
+                                 centerJ + tolerateModuleSize,
+                                 centerJ - 2 * tolerateModuleSize,
+                                 centerJ + 2 * tolerateModuleSize,
+                                 centerJ - 3 * tolerateModuleSize,
+                                 centerJ + 3 * tolerateModuleSize};
+    int image_height = image_->getHeight();
+    int image_width = image_->getWidth();
+    for (int k = 0; k < CENTER_CHECK_TIME; k++) {
+        float possibleCenterJ = possbileCenterJs[k];
+        if (possibleCenterJ < 0 || possibleCenterJ >= image_width) continue;
+        float centerI = crossCheckVertical(i, (size_t)possibleCenterJ, stateCount[2],
+                                           stateCountTotal, estimatedVerticalModuleSize);
+
+        if (!isnan(centerI) && centerI >= 0.0) {
+            CrossCheckState tmpVerticalState = CURRENT_CHECK_STATE;
+
+            float moduleSizeDiff = abs(estimatedHorizontalModuleSize - estimatedVerticalModuleSize);
+
+            if (moduleSizeDiff > estimatedHorizontalModuleSize ||
+                moduleSizeDiff > estimatedVerticalModuleSize)
+                return false;
+
+            tolerateModuleSize =
+                estimatedVerticalModuleSize > 4.0 ? estimatedVerticalModuleSize / 2.0f : 1.0f;
+
+            float possbileCenterIs[7] = {centerI,
+                                         centerI - tolerateModuleSize,
+                                         centerI + tolerateModuleSize,
+                                         centerI - 2 * tolerateModuleSize,
+                                         centerI + 2 * tolerateModuleSize,
+                                         centerI - 3 * tolerateModuleSize,
+                                         centerI + 3 * tolerateModuleSize};
+
+            for (int l = 0; l < CENTER_CHECK_TIME; l++) {
+                float possibleCenterI = possbileCenterIs[l];
+                if (possibleCenterI < 0 || possibleCenterI >= image_height) continue;
+                // Re-cross check
+                float reEstimatedHorizontalModuleSize;
+                float cJ = hasHorizontalCheckedResult(centerJ, possibleCenterI);
+
+                if (!isnan(cJ) && cJ >= 0.0) {
+                    centerJ = cJ;
+                } else {
+                    cJ = centerJ;
+
+                    float ccj =
+                        crossCheckHorizontal((size_t)cJ, (size_t)possibleCenterI, stateCount[2],
+                                             stateCountTotal, reEstimatedHorizontalModuleSize);
+
+                    if (!isnan(ccj)) {
+                        centerJ = ccj;
+                        addHorizontalCheckedResult(cJ, possibleCenterI, ccj);
+                    }
+                }
+                if (!isnan(centerJ)) {
+                    tryToPushToCenters(
+                        centerI, centerJ,
+                        (estimatedHorizontalModuleSize + estimatedVerticalModuleSize) / 2.0,
+                        tmpHorizontalState, tmpVerticalState);
+                    return true;
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+// return the number of rows we could safely skip during scanning, based on the
+// first two finder patterns that have been located. In some cases their
+// position will allow us to infer that the third pattern must lie below a
+// certain point farther down the image.
+int FinderPatternFinder::findRowSkip() {
+    int max = possibleCenters_.size();
+    if (max <= 1) {
+        return 0;
+    }
+
+    if (max <= compared_finder_counts) return 0;
+
+    Ref<FinderPattern> firstConfirmedCenter, secondConfirmedCenter;
+
+    for (int i = 0; i < max - 1; i++) {
+        firstConfirmedCenter = possibleCenters_[i];
+        if (firstConfirmedCenter->getCount() >= CENTER_QUORUM) {
+            float firstModuleSize = firstConfirmedCenter->getEstimatedModuleSize();
+            int j_start = (i < compared_finder_counts) ? compared_finder_counts : i + 1;
+            for (int j = j_start; j < max; j++) {
+                secondConfirmedCenter = possibleCenters_[j];
+                if (secondConfirmedCenter->getCount() >= CENTER_QUORUM) {
+                    float secondModuleSize = secondConfirmedCenter->getEstimatedModuleSize();
+                    float moduleSizeDiff = abs(firstModuleSize - secondModuleSize);
+                    if (moduleSizeDiff < 1.0f) {
+                        hasSkipped_ = true;
+                        return (int)(abs(firstConfirmedCenter->getX() -
+                                         secondConfirmedCenter->getX()) -
+                                     abs(firstConfirmedCenter->getY() -
+                                         secondConfirmedCenter->getY())) /
+                               2;
+                    }
+                }
+            }
+        }
+    }
+
+    compared_finder_counts = max;
+
+    return 0;
+}
+
+// return the 3 finder patterns from our list of candidates. The "best" are
+// those that have been detected at least #CENTER_QUORUM times, and whose module
+// size differs from the average among those patterns the least. //
+vector<Ref<FinderPattern>> FinderPatternFinder::selectBestPatterns(ErrorHandler& err_handler) {
+    size_t startSize = possibleCenters_.size();
+
+    if (startSize < 3) {
+        // Couldn't find enough finder patterns
+        err_handler = ReaderErrorHandler("Could not find three finder patterns");
+        return vector<Ref<FinderPattern>>();
+    }
+
+    vector<Ref<FinderPattern>> result(3);
+
+    if (startSize == 3) {
+        result[0] = possibleCenters_[0];
+        result[1] = possibleCenters_[1];
+        result[2] = possibleCenters_[2];
+        return result;
+    }
+
+    sort(possibleCenters_.begin(), possibleCenters_.end(), CountComparator());
+    if ((possibleCenters_[2]->getCount() - possibleCenters_[3]->getCount()) > 1 &&
+        possibleCenters_[2]->getCount() > 1) {
+        result[0] = possibleCenters_[0];
+        result[1] = possibleCenters_[1];
+        result[2] = possibleCenters_[2];
+        return result;
+    } else if (possibleCenters_[3]->getCount() > 1) {
+        float totalModuleSize = 0.0f;
+        for (int i = 0; i < 4; i++) {
+            totalModuleSize += possibleCenters_[i]->getEstimatedModuleSize();
+        }
+        float everageModuleSize = totalModuleSize / 4.0f;
+        float maxDiffModuleSize = 0.0f;
+        int maxID = 0;
+        for (int i = 0; i < 4; i++) {
+            float diff = abs(possibleCenters_[i]->getEstimatedModuleSize() - everageModuleSize);
+            if (diff > maxDiffModuleSize) {
+                maxDiffModuleSize = diff;
+                maxID = i;
+            }
+        }
+        switch (maxID) {
+            case 0:
+                result[0] = possibleCenters_[1];
+                result[1] = possibleCenters_[2];
+                result[2] = possibleCenters_[3];
+                break;
+            case 1:
+                result[0] = possibleCenters_[0];
+                result[1] = possibleCenters_[2];
+                result[2] = possibleCenters_[3];
+                break;
+            case 2:
+                result[0] = possibleCenters_[0];
+                result[1] = possibleCenters_[1];
+                result[2] = possibleCenters_[3];
+                break;
+            default:
+                result[0] = possibleCenters_[0];
+                result[1] = possibleCenters_[1];
+                result[2] = possibleCenters_[2];
+                break;
+        }
+
+        return result;
+    } else if (possibleCenters_[1]->getCount() > 1 && possibleCenters_[2]->getCount() == 1) {
+        vector<Ref<FinderPattern>> possibleThirdCenter;
+        float possibleModuleSize = (possibleCenters_[0]->getEstimatedModuleSize() +
+                                    possibleCenters_[1]->getEstimatedModuleSize()) /
+                                   2.0f;
+        for (size_t i = 2; i < startSize; i++) {
+            if (abs(possibleCenters_[i]->getEstimatedModuleSize() - possibleModuleSize) <
+                0.5 * possibleModuleSize)
+                possibleThirdCenter.push_back(possibleCenters_[i]);
+        }
+        float longestSide = 0.0f;
+        size_t longestId = 0;
+        for (size_t i = 0; i < possibleThirdCenter.size(); i++) {
+            float tmpLongSide = 0.0f;
+            if (checkIsoscelesRightTriangle(possibleCenters_[0], possibleCenters_[1],
+                                            possibleThirdCenter[i], tmpLongSide)) {
+                if (tmpLongSide >= longestSide) {
+                    longestSide = tmpLongSide;
+                    longestId = i;
+                }
+            }
+        }
+        result[0] = possibleCenters_[0];
+        result[1] = possibleCenters_[1];
+
+        // Error with decoding
+        if (longestId >= possibleThirdCenter.size()) {
+            err_handler = ReaderErrorHandler("Not find any available possibleThirdCenter");
+            return vector<Ref<FinderPattern>>();
+        } else {
+            result[2] = possibleThirdCenter[longestId];
+        }
+
+        return result;
+    }
+
+    // Filter outlier possibilities whose module size is too different
+    if (startSize > 3) {
+        // But we can only afford to do so if we have at least 4 possibilities
+        // to choose from
+        float totalModuleSize = 0.0f;
+        float square = 0.0f;
+        for (size_t i = 0; i < startSize; i++) {
+            float size = possibleCenters_[i]->getEstimatedModuleSize();
+            totalModuleSize += size;
+            square += size * size;
+        }
+        float average = totalModuleSize / (float)startSize;
+        float stdDev = (float)sqrt(square / startSize - average * average);
+
+        sort(possibleCenters_.begin(), possibleCenters_.end(),
+             FurthestFromAverageComparator(average));
+
+        // float limit = max(0.2f * average, stdDev);
+        float limit = max(0.5f * average, stdDev);
+
+        for (size_t i = 0; i < possibleCenters_.size() && possibleCenters_.size() > 3; i++) {
+            if (abs(possibleCenters_[i]->getEstimatedModuleSize() - average) > limit) {
+                possibleCenters_.erase(possibleCenters_.begin() + i);
+                i--;
+            }
+        }
+    }
+
+    int tryHardPossibleCenterSize = 15;
+    int possibleCenterSize = 12;
+
+    if (possibleCenters_.size() > size_t(tryHardPossibleCenterSize)) {
+        sort(possibleCenters_.begin(), possibleCenters_.end(), CountComparator());
+        possibleCenters_.erase(possibleCenters_.begin() + tryHardPossibleCenterSize,
+                               possibleCenters_.end());
+    } else if (possibleCenters_.size() > size_t(possibleCenterSize)) {
+        sort(possibleCenters_.begin(), possibleCenters_.end(), CountComparator());
+        possibleCenters_.erase(possibleCenters_.begin() + possibleCenterSize,
+                               possibleCenters_.end());
+    }
+
+    if (possibleCenters_.size() >= 6) {
+        sort(possibleCenters_.begin(), possibleCenters_.end(), XComparator());
+        possibleCenters_.erase(possibleCenters_.begin() + 4, possibleCenters_.end() - 2);
+        sort(possibleCenters_.begin(), possibleCenters_.begin() + 4, YComparator());
+        possibleCenters_.erase(possibleCenters_.begin() + 1, possibleCenters_.begin() + 3);
+        sort(possibleCenters_.end() - 2, possibleCenters_.end(), YComparator());
+        possibleCenters_.erase(possibleCenters_.end() - 1, possibleCenters_.end());
+    } else if (possibleCenters_.size() > 3) {
+        // Throw away all but those first size candidate points we found.
+        float totalModuleSize = 0.0f;
+        for (size_t i = 0; i < possibleCenters_.size(); i++) {
+            float size = possibleCenters_[i]->getEstimatedModuleSize();
+            totalModuleSize += size;
+        }
+        float average = totalModuleSize / (float)possibleCenters_.size();
+        sort(possibleCenters_.begin(), possibleCenters_.end(), CenterComparator(average));
+        possibleCenters_.erase(possibleCenters_.begin() + 3, possibleCenters_.end());
+    }
+
+    result[0] = possibleCenters_[0];
+    result[1] = possibleCenters_[1];
+    result[2] = possibleCenters_[2];
+
+    return result;
+}
+
+vector<Ref<FinderPattern>> FinderPatternFinder::selectFileBestPatterns(ErrorHandler& err_handler) {
+    size_t startSize = possibleCenters_.size();
+
+    if (startSize < 3) {
+        // Couldn't find enough finder patterns
+        err_handler = ReaderErrorHandler("Could not find three finder patterns");
+        return vector<Ref<FinderPattern>>();
+    }
+
+    vector<Ref<FinderPattern>> result(3);
+
+    if (startSize == 3) {
+        result[0] = possibleCenters_[0];
+        result[1] = possibleCenters_[1];
+        result[2] = possibleCenters_[2];
+        return result;
+    }
+
+    sort(possibleCenters_.begin(), possibleCenters_.end(), BestComparator());
+
+    result[0] = possibleCenters_[0];
+    result[1] = possibleCenters_[1];
+    result[2] = possibleCenters_[2];
+
+    for (size_t i = 0; i < possibleCenters_.size() - 2; ++i) {
+        float tmpLongSide = 0;
+
+        int iCountDiff = 0;
+        float fModuleSizeDiff = 0;
+        for (size_t j = 0; j < 3; ++j) {
+            iCountDiff += abs(possibleCenters_[i + j]->getCount() -
+                              possibleCenters_[i + ((j + 1) % 3)]->getCount());
+            fModuleSizeDiff += fabs(possibleCenters_[i + j]->getEstimatedModuleSize() -
+                                    possibleCenters_[i + ((j + 1) % 3)]->getEstimatedModuleSize());
+        }
+
+        if (iCountDiff > 2) continue;
+        if (fModuleSizeDiff > 5) continue;
+
+        if (checkIsoscelesRightTriangle(possibleCenters_[i], possibleCenters_[i + 1],
+                                        possibleCenters_[i + 2], tmpLongSide)) {
+            result[0] = possibleCenters_[i];
+            result[1] = possibleCenters_[i + 1];
+            result[2] = possibleCenters_[i + 2];
+
+            break;
+        }
+    }
+
+    return result;
+}
+
+// Orders an array of three patterns in an order [A,B,C] such that
+// AB<AC and BC<AC and the angle between BC and BA is less than 180 degrees.
+vector<Ref<FinderPattern>> FinderPatternFinder::orderBestPatterns(
+    vector<Ref<FinderPattern>> patterns) {
+    // Find distances between pattern centers
+    float abDistance = distance(patterns[0], patterns[1]);
+    float bcDistance = distance(patterns[1], patterns[2]);
+    float acDistance = distance(patterns[0], patterns[2]);
+
+    Ref<FinderPattern> topLeft;
+    Ref<FinderPattern> topRight;
+    Ref<FinderPattern> bottomLeft;
+    // Assume one closest to other two is top left;
+    // topRight and bottomLeft will just be guesses below at first
+    if (bcDistance >= abDistance && bcDistance >= acDistance) {
+        topLeft = patterns[0];
+        topRight = patterns[1];
+        bottomLeft = patterns[2];
+    } else if (acDistance >= bcDistance && acDistance >= abDistance) {
+        topLeft = patterns[1];
+        topRight = patterns[0];
+        bottomLeft = patterns[2];
+    } else {
+        topLeft = patterns[2];
+        topRight = patterns[0];
+        bottomLeft = patterns[1];
+    }
+
+    // Use cross product to figure out which of other1/2 is the bottom left
+    // pattern. The vector "top_left -> bottom_left" x "top_left -> top_right"
+    // should yield a vector with positive z component
+    if ((bottomLeft->getY() - topLeft->getY()) * (topRight->getX() - topLeft->getX()) <
+        (bottomLeft->getX() - topLeft->getX()) * (topRight->getY() - topLeft->getY())) {
+        Ref<FinderPattern> temp = topRight;
+        topRight = bottomLeft;
+        bottomLeft = temp;
+    }
+
+    vector<Ref<FinderPattern>> results(3);
+    results[0] = bottomLeft;
+    results[1] = topLeft;
+    results[2] = topRight;
+
+    return results;
+}
+
+bool FinderPatternFinder::checkIsoscelesRightTriangle(Ref<FinderPattern> centerA,
+                                                      Ref<FinderPattern> centerB,
+                                                      Ref<FinderPattern> centerC, float& longSide) {
+    float shortSide1, shortSide2;
+    FinderPatternInfo::calculateSides(centerA, centerB, centerC, longSide, shortSide1, shortSide2);
+
+    auto minAmongThree = [](float a, float b, float c) { return min(min(a, b), c); };
+    auto maxAmongThree = [](float a, float b, float c) { return max(max(a, b), c); };
+
+    float shortSideSqrt1 = sqrt(shortSide1);
+    float shortSideSqrt2 = sqrt(shortSide2);
+    float longSideSqrt = sqrt(longSide);
+    auto minSide = minAmongThree(shortSideSqrt1, shortSideSqrt2, longSideSqrt);
+    auto maxModuleSize =
+        maxAmongThree(centerA->getEstimatedModuleSize(), centerB->getEstimatedModuleSize(),
+                      centerC->getEstimatedModuleSize());
+    // if edge length smaller than 14 * module size
+    if (minSide <= maxModuleSize * 14) return false;
+
+    float CosLong = (shortSide1 + shortSide2 - longSide) / (2 * shortSideSqrt1 * shortSideSqrt2);
+    float CosShort1 = (longSide + shortSide1 - shortSide2) / (2 * longSideSqrt * shortSideSqrt1);
+    float CosShort2 = (longSide + shortSide2 - shortSide1) / (2 * longSideSqrt * shortSideSqrt2);
+
+    if (abs(CosLong) > FP_RIGHT_ANGLE ||
+        (CosShort1 < FP_SMALL_ANGLE2 || CosShort1 > FP_SMALL_ANGLE1) ||
+        (CosShort2 < FP_SMALL_ANGLE2 || CosShort2 > FP_SMALL_ANGLE1)) {
+        return false;
+    }
+
+    return true;
+}
+
+// return distance between two points
+float FinderPatternFinder::distance(Ref<ResultPoint> p1, Ref<ResultPoint> p2) {
+    float dx = p1->getX() - p2->getX();
+    float dy = p1->getY() - p2->getY();
+    return (float)sqrt(dx * dx + dy * dy);
+}
+
+FinderPatternFinder::FinderPatternFinder(Ref<BitMatrix> image, Ref<UnicomBlock> block)
+    : finder_time(0),
+      compared_finder_counts(0),
+      image_(image),
+      possibleCenters_(),
+      hasSkipped_(false),
+      block_(block) {
+    CURRENT_CHECK_STATE = FinderPatternFinder::NORMAL;
+}
+
+Ref<BitMatrix> FinderPatternFinder::getImage() { return image_; }
+
+vector<Ref<FinderPattern>>& FinderPatternFinder::getPossibleCenters() { return possibleCenters_; }
+
+}  // namespace qrcode
+}  // namespace zxing
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_finder.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_finder.hpp
new file mode 100644
index 00000000..442198bf
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_finder.hpp
@@ -0,0 +1,136 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DETECTOR_FINDER_PATTERN_FINDER_HPP_
+#define __ZXING_QRCODE_DETECTOR_FINDER_PATTERN_FINDER_HPP_
+
+#include "../../common/bitmatrix.hpp"
+#include "../../common/counted.hpp"
+#include "../../common/unicomblock.hpp"
+#include "../../errorhandler.hpp"
+#include "finder_pattern.hpp"
+#include "finder_pattern_info.hpp"
+using zxing::ErrorHandler;
+using zxing::ReaderErrorHandler;
+
+namespace zxing {
+
+class DecodeHints;
+
+namespace qrcode {
+
+class FinderPatternFinder {
+public:
+    enum CrossCheckState {
+        NORMAL = 0,
+        LEFT_SPILL = 1,
+        RIHGT_SPILL = 2,
+        LEFT_RIGHT_SPILL = 3,
+        NOT_PATTERN = 4,
+    };
+
+private:
+    static int CENTER_QUORUM;
+    static int MIN_SKIP;
+    static int MAX_MODULES;
+    static int INTEGER_MATH_SHIFT;
+    static int FP_INPUT_CNN_MAX_NUM;
+    static int FP_IS_SELECT_BEST;
+    static int FP_IS_SELECT_FILE_BEST;
+    static int FP_INPUT_MAX_NUM;
+    static int FP_FILTER_SIZE;
+    static int FPS_CLUSTER_MAX;
+    static int FPS_RESULT_MAX;
+    static int K_FACTOR;
+
+    static float FPS_MS_VAL;
+    static float FP_COUNT_MIN;
+    static float FP_MS_MIN;
+    static float FP_RIGHT_ANGLE;
+    static float FP_SMALL_ANGLE1;
+    static float FP_SMALL_ANGLE2;
+    static float QR_MIN_FP_AREA_ERR;
+    static float QR_MIN_FP_MS_ERR;
+    static int QR_MIN_FP_ACCEPT;
+
+    int finder_time;
+    CrossCheckState CURRENT_CHECK_STATE;
+    int compared_finder_counts;
+
+    struct HorizontalCheckedResult {
+        size_t centerI;
+        float centerJ;
+    };
+
+    vector<vector<HorizontalCheckedResult> > _horizontalCheckedResult;
+
+    // INI CONFIG
+
+protected:
+    Ref<BitMatrix> image_;
+    std::vector<Ref<FinderPattern> > possibleCenters_;
+
+    bool hasSkipped_;
+    Ref<UnicomBlock> block_;
+
+    /** stateCount must be int[5] */
+    float centerFromEnd(int* stateCount, int end);
+    // check if satisfies finder pattern
+    bool foundPatternCross(int* stateCount);
+
+    // try to insert to possibleCenters_
+    int getStateCountTotal(int* stateCount, const CrossCheckState& check_state);
+    bool tryToPushToCenters(float posX, float posY, float estimatedModuleSize,
+                            CrossCheckState horizontalState = FinderPatternFinder::NORMAL,
+                            CrossCheckState verticalState = FinderPatternFinder::NORMAL);
+    bool crossCheckDiagonal(int startI, int centerJ, int maxCount, int originalStateCountTotal);
+    float crossCheckVertical(size_t startI, size_t centerJ, int maxCount,
+                             int originalStateCountTota, float& estimatedVerticalModuleSize);
+    float crossCheckHorizontal(size_t startJ, size_t centerI, int maxCount,
+                               int originalStateCountTotal, float& estimatedHorizontalModuleSize);
+
+    float hasHorizontalCheckedResult(size_t startJ, size_t centerI);
+    int addHorizontalCheckedResult(size_t startJ, size_t centerI, float centerJ);
+    int getMinModuleSize();
+
+    bool isEqualResult(Ref<FinderPatternInfo> src, Ref<FinderPatternInfo> dst);
+
+    /** stateCount must be int[5] */
+    bool handlePossibleCenter(int* stateCount, size_t i, size_t j);
+    int findRowSkip();
+
+    std::vector<Ref<FinderPattern> > selectBestPatterns(ErrorHandler& err_handler);
+    std::vector<Ref<FinderPattern> > selectFileBestPatterns(ErrorHandler& err_handler);
+    std::vector<Ref<FinderPattern> > orderBestPatterns(std::vector<Ref<FinderPattern> > patterns);
+
+    vector<Ref<FinderPatternInfo> > getPatternInfosFileMode(DecodeHints const& hints,
+                                                            ErrorHandler& err_handler);
+
+    bool IsPossibleFindPatterInfo(Ref<FinderPattern> a, Ref<FinderPattern> b, Ref<FinderPattern> c);
+    void PushToResult(Ref<FinderPattern> a, Ref<FinderPattern> b, Ref<FinderPattern> c,
+                      vector<Ref<FinderPatternInfo> >& patternInfos);
+
+    Ref<BitMatrix> getImage();
+    std::vector<Ref<FinderPattern> >& getPossibleCenters();
+
+public:
+    void InitConfig();
+    float distance(Ref<ResultPoint> p1, Ref<ResultPoint> p2);
+    FinderPatternFinder(Ref<BitMatrix> image, Ref<UnicomBlock> block);
+
+    std::vector<Ref<FinderPatternInfo> > find(DecodeHints const& hints, ErrorHandler& err_handler);
+
+    bool checkIsoscelesRightTriangle(Ref<FinderPattern> centerA, Ref<FinderPattern> centerB,
+                                     Ref<FinderPattern> centerC, float& longSide);
+};
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DETECTOR_FINDER_PATTERN_FINDER_HPP_
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_info.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_info.cpp
new file mode 100644
index 00000000..2e121f97
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_info.cpp
@@ -0,0 +1,96 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "finder_pattern_info.hpp"
+
+namespace zxing {
+namespace qrcode {
+FinderPatternInfo::FinderPatternInfo(std::vector<Ref<FinderPattern> > patternCenters)
+    : bottomLeft_(patternCenters[0]),
+      topLeft_(patternCenters[1]),
+      topRight_(patternCenters[2]),
+      possibleFix_(0) {
+    estimateFinderPatternInfo();
+}
+
+Ref<FinderPattern> FinderPatternInfo::getBottomLeft() { return bottomLeft_; }
+
+Ref<FinderPattern> FinderPatternInfo::getTopLeft() { return topLeft_; }
+
+Ref<FinderPattern> FinderPatternInfo::getTopRight() { return topRight_; }
+
+
+float FinderPatternInfo::getPossibleFix() { return possibleFix_; }
+
+float FinderPatternInfo::getAnglePossibleFix() { return anglePossibleFix_; }
+
+// bottomLeft_ => centerA
+void FinderPatternInfo::calculateSides(Ref<FinderPattern> centerA, Ref<FinderPattern> centerB,
+                                       Ref<FinderPattern> centerC, float &longSide,
+                                       float &shortSide1, float &shortSide2) {
+    float a_m_b_x = centerA->getX() - centerB->getX();
+    float a_m_b_y = centerA->getY() - centerB->getY();
+    float ab_s = a_m_b_x * a_m_b_x + a_m_b_y * a_m_b_y;
+    float a_m_c_x = centerA->getX() - centerC->getX();
+    float a_m_c_y = centerA->getY() - centerC->getY();
+    float ac_s = a_m_c_x * a_m_c_x + a_m_c_y * a_m_c_y;
+    float b_m_c_x = centerB->getX() - centerC->getX();
+    float b_m_c_y = centerB->getY() - centerC->getY();
+    float bc_s = b_m_c_x * b_m_c_x + b_m_c_y * b_m_c_y;
+
+    if (ab_s > bc_s && ab_s > ac_s) {
+        longSide = ab_s;
+        shortSide1 = ac_s;
+        shortSide2 = bc_s;
+
+    } else if (bc_s > ab_s && bc_s > ac_s) {
+        longSide = bc_s;
+        shortSide1 = ab_s;
+        shortSide2 = ac_s;
+    } else {
+        longSide = ac_s;
+        shortSide1 = ab_s;
+        shortSide2 = bc_s;
+    }
+}
+void FinderPatternInfo::estimateFinderPatternInfo() {
+    float longSide, shortSide1, shortSide2;
+    calculateSides(bottomLeft_, topLeft_, topRight_, longSide, shortSide1, shortSide2);
+
+    float CosLong =
+        (shortSide1 + shortSide2 - longSide) / (2 * sqrt(shortSide1) * sqrt(shortSide2));
+    float CosShort1 =
+        (longSide + shortSide1 - shortSide2) / (2 * sqrt(longSide) * sqrt(shortSide1));
+    float CosShort2 =
+        (longSide + shortSide2 - shortSide1) / (2 * sqrt(longSide) * sqrt(shortSide2));
+
+    float fAngleLong = acos(CosLong) * 180 / acos(-1.0);
+    float fAngleShort1 = acos(CosShort1) * 180 / acos(-1.0);
+    float fAngleShort2 = acos(CosShort2) * 180 / acos(-1.0);
+    if (fAngleShort1 < fAngleShort2) swap(fAngleShort1, fAngleShort2);
+
+    float fLongDiff = fabs(fAngleLong - 90);
+    float fLongScore = 100.0 - fLongDiff;
+
+    float fShortDiff = std::max(fabs(fAngleShort1 - 45), fabs(fAngleShort2 - 45));
+    float fShortScore = 100.0 - 2 * fShortDiff;
+
+    float fFinalScore = std::min(fShortScore, fLongScore);
+
+    anglePossibleFix_ = fFinalScore / 100.0;
+
+    int totalCount = (bottomLeft_->getCount() + topLeft_->getCount() + topRight_->getCount());
+
+    float fCountScore = (max(3, min(totalCount, 10)) - 3) / (10.0 - 3.0);
+
+    possibleFix_ = anglePossibleFix_ * 0.5 + fCountScore * 0.5;
+}
+}  // namespace qrcode
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_info.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_info.hpp
new file mode 100644
index 00000000..223524e2
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/finder_pattern_info.hpp
@@ -0,0 +1,46 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DETECTOR_FINDER_PATTERN_INFO_HPP_
+#define __ZXING_QRCODE_DETECTOR_FINDER_PATTERN_INFO_HPP_
+
+#include "../../common/array.hpp"
+#include "../../common/counted.hpp"
+#include "finder_pattern.hpp"
+
+namespace zxing {
+namespace qrcode {
+
+class FinderPatternInfo : public Counted {
+private:
+    Ref<FinderPattern> bottomLeft_;
+    Ref<FinderPattern> topLeft_;
+    Ref<FinderPattern> topRight_;
+    float possibleFix_;
+    float anglePossibleFix_;
+
+public:
+    explicit FinderPatternInfo(std::vector<Ref<FinderPattern> > patternCenters);
+
+    Ref<FinderPattern> getBottomLeft();
+    Ref<FinderPattern> getTopLeft();
+    Ref<FinderPattern> getTopRight();
+    void estimateFinderPatternInfo();
+    float getPossibleFix();
+    float getAnglePossibleFix();
+    // to void code duplicated
+    static void calculateSides(Ref<FinderPattern> centerA, Ref<FinderPattern> centerB,
+                               Ref<FinderPattern> centerC, float &longSide, float &shortSide1,
+                               float &shortSide2);
+};
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DETECTOR_FINDER_PATTERN_INFO_HPP_
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/pattern_result.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/pattern_result.cpp
new file mode 100644
index 00000000..b44349ee
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/pattern_result.cpp
@@ -0,0 +1,28 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../../precomp.hpp"
+#include "pattern_result.hpp"
+
+
+using zxing::Ref;
+using zxing::ResultPoint;
+using zxing::qrcode::FinderPattern;
+using zxing::qrcode::FinderPatternInfo;
+using zxing::qrcode::PatternResult;
+
+PatternResult::PatternResult(Ref<FinderPatternInfo> info) {
+    finderPatternInfo = info;
+    possibleAlignmentPatterns.clear();
+}
+
+void PatternResult::setConfirmedAlignmentPattern(int index) {
+    if (index >= int(possibleAlignmentPatterns.size())) return;
+    confirmedAlignmentPattern = possibleAlignmentPatterns[index];
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/pattern_result.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/pattern_result.hpp
new file mode 100644
index 00000000..93a4f2ba
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/detector/pattern_result.hpp
@@ -0,0 +1,48 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_DETECTOR_PATTERN_RESULT_HPP_
+#define __ZXING_QRCODE_DETECTOR_PATTERN_RESULT_HPP_
+
+#include "../../common/array.hpp"
+#include "../../common/bitmatrix.hpp"
+#include "../../common/counted.hpp"
+#include "../../common/detector_result.hpp"
+#include "../../resultpoint.hpp"
+#include "alignment_pattern.hpp"
+#include "finder_pattern.hpp"
+#include "finder_pattern_info.hpp"
+namespace zxing {
+namespace qrcode {
+class PatternResult : public Counted {
+public:
+    Ref<FinderPatternInfo> finderPatternInfo;
+    vector<Ref<AlignmentPattern> > possibleAlignmentPatterns;
+    Ref<AlignmentPattern> confirmedAlignmentPattern;
+    int possibleDimension;
+    // vector<int> possibleDimensions;
+    unsigned int possibleVersion;
+    float possibleFix;
+    float possibleModuleSize;
+
+    explicit PatternResult(Ref<FinderPatternInfo> info);
+    void setConfirmedAlignmentPattern(int index);
+    int getPossibleAlignmentCount() { return possibleAlignmentPatterns.size(); }
+    // int getPossibleDimensionCount();
+public:
+    unsigned int getPossibleVersion() { return possibleVersion; }
+    float getPossibleFix() { return possibleFix; }
+    float getPossibleModuleSize() { return possibleModuleSize; }
+    int getDimension() { return possibleDimension; }
+};
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_DETECTOR_PATTERN_RESULT_HPP_
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/error_correction_level.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/error_correction_level.cpp
new file mode 100644
index 00000000..1b2c63de
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/error_correction_level.cpp
@@ -0,0 +1,44 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "error_correction_level.hpp"
+using zxing::ErrorHandler;
+
+namespace zxing {
+namespace qrcode {
+
+ErrorCorrectionLevel::ErrorCorrectionLevel(int inOrdinal, int bits, char const* name)
+    : ordinal_(inOrdinal), bits_(bits), name_(name) {}
+
+int ErrorCorrectionLevel::ordinal() const { return ordinal_; }
+
+int ErrorCorrectionLevel::bits() const { return bits_; }
+
+string const& ErrorCorrectionLevel::name() const { return name_; }
+
+ErrorCorrectionLevel::operator string const &() const { return name_; }
+
+ErrorCorrectionLevel& ErrorCorrectionLevel::forBits(int bits, ErrorHandler& err_handler) {
+    if (bits < 0 || bits >= N_LEVELS) {
+        err_handler = zxing::ReaderErrorHandler("Ellegal error correction level bits");
+        return *FOR_BITS[0];
+    }
+    return *FOR_BITS[bits];
+}
+
+ErrorCorrectionLevel ErrorCorrectionLevel::L(0, 0x01, "L");
+ErrorCorrectionLevel ErrorCorrectionLevel::M(1, 0x00, "M");
+ErrorCorrectionLevel ErrorCorrectionLevel::Q(2, 0x03, "Q");
+ErrorCorrectionLevel ErrorCorrectionLevel::H(3, 0x02, "H");
+ErrorCorrectionLevel* ErrorCorrectionLevel::FOR_BITS[] = {&M, &L, &H, &Q};
+int ErrorCorrectionLevel::N_LEVELS = 4;
+
+}  // namespace qrcode
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/error_correction_level.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/error_correction_level.hpp
new file mode 100644
index 00000000..67344a83
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/error_correction_level.hpp
@@ -0,0 +1,44 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_ERROR_CORRECTION_LEVEL_HPP__
+#define __ZXING_QRCODE_ERROR_CORRECTION_LEVEL_HPP__
+
+#include "../errorhandler.hpp"
+
+namespace zxing {
+namespace qrcode {
+
+class ErrorCorrectionLevel {
+private:
+    int ordinal_;
+    int bits_;
+    std::string name_;
+    ErrorCorrectionLevel(int inOrdinal, int bits, char const* name);
+    static ErrorCorrectionLevel* FOR_BITS[];
+    static int N_LEVELS;
+
+public:
+    static ErrorCorrectionLevel L;
+    static ErrorCorrectionLevel M;
+    static ErrorCorrectionLevel Q;
+    static ErrorCorrectionLevel H;
+
+    int ordinal() const;
+    int bits() const;
+    std::string const& name() const;
+    operator std::string const &() const;
+
+    static ErrorCorrectionLevel& forBits(int bits, ErrorHandler& err_handler);
+};
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_ERROR_CORRECTION_LEVEL_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/format_information.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/format_information.cpp
new file mode 100644
index 00000000..5395f791
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/format_information.cpp
@@ -0,0 +1,114 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "format_information.hpp"
+
+#include <limits>
+
+using zxing::ErrorHandler;
+
+namespace zxing {
+namespace qrcode {
+
+int FormatInformation::FORMAT_INFO_MASK_QR = 0x5412;
+int FormatInformation::FORMAT_INFO_DECODE_LOOKUP[][2] = {
+    {0x5412, 0x00}, {0x5125, 0x01}, {0x5E7C, 0x02}, {0x5B4B, 0x03}, {0x45F9, 0x04}, {0x40CE, 0x05},
+    {0x4F97, 0x06}, {0x4AA0, 0x07}, {0x77C4, 0x08}, {0x72F3, 0x09}, {0x7DAA, 0x0A}, {0x789D, 0x0B},
+    {0x662F, 0x0C}, {0x6318, 0x0D}, {0x6C41, 0x0E}, {0x6976, 0x0F}, {0x1689, 0x10}, {0x13BE, 0x11},
+    {0x1CE7, 0x12}, {0x19D0, 0x13}, {0x0762, 0x14}, {0x0255, 0x15}, {0x0D0C, 0x16}, {0x083B, 0x17},
+    {0x355F, 0x18}, {0x3068, 0x19}, {0x3F31, 0x1A}, {0x3A06, 0x1B}, {0x24B4, 0x1C}, {0x2183, 0x1D},
+    {0x2EDA, 0x1E}, {0x2BED, 0x1F},
+};
+int FormatInformation::N_FORMAT_INFO_DECODE_LOOKUPS = 32;
+
+int FormatInformation::BITS_SET_IN_HALF_BYTE[] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
+
+FormatInformation::FormatInformation(int formatInfo, float possiableFix, ErrorHandler& err_handler)
+    : errorCorrectionLevel_(ErrorCorrectionLevel::forBits((formatInfo >> 3) & 0x03, err_handler)),
+      dataMask_((char)(formatInfo & 0x07)) {
+    possiableFix_ = possiableFix;
+    if (err_handler.ErrCode()) return;
+}
+
+ErrorCorrectionLevel& FormatInformation::getErrorCorrectionLevel() { return errorCorrectionLevel_; }
+
+char FormatInformation::getDataMask() { return dataMask_; }
+
+float FormatInformation::getPossiableFix() { return possiableFix_; }
+
+int FormatInformation::numBitsDiffering(int a, int b) {
+    a ^= b;
+    return BITS_SET_IN_HALF_BYTE[a & 0x0F] + BITS_SET_IN_HALF_BYTE[(a >> 4 & 0x0F)] +
+           BITS_SET_IN_HALF_BYTE[(a >> 8 & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 12 & 0x0F)] +
+           BITS_SET_IN_HALF_BYTE[(a >> 16 & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 20 & 0x0F)] +
+           BITS_SET_IN_HALF_BYTE[(a >> 24 & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 28 & 0x0F)];
+}
+
+Ref<FormatInformation> FormatInformation::decodeFormatInformation(int maskedFormatInfo1,
+                                                                  int maskedFormatInfo2) {
+    Ref<FormatInformation> result(doDecodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2));
+    if (result != 0) {
+        return result;
+    }
+    // Should return null, but, some QR codes apparently
+    // do not mask this info. Try again by actually masking the pattern
+    // first
+    return doDecodeFormatInformation(maskedFormatInfo1 ^ FORMAT_INFO_MASK_QR,
+                                     maskedFormatInfo2 ^ FORMAT_INFO_MASK_QR);
+}
+Ref<FormatInformation> FormatInformation::doDecodeFormatInformation(int maskedFormatInfo1,
+                                                                    int maskedFormatInfo2) {
+    ErrorHandler err_handler;
+    int distance = numBitsDiffering(maskedFormatInfo1, maskedFormatInfo2);
+    float possiableFix_ = (16.0 - (distance > 16 ? 16 : distance)) / 16.0;
+
+    // Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing
+    int bestDifference = std::numeric_limits<int>::max();
+    int bestFormatInfo = 0;
+    for (int i = 0; i < N_FORMAT_INFO_DECODE_LOOKUPS; i++) {
+        int* decodeInfo = FORMAT_INFO_DECODE_LOOKUP[i];
+        int targetInfo = decodeInfo[0];
+        if (targetInfo == maskedFormatInfo1 || targetInfo == maskedFormatInfo2) {
+            // Found an exact match
+            Ref<FormatInformation> result(
+                new FormatInformation(decodeInfo[1], possiableFix_, err_handler));
+            if (err_handler.ErrCode()) return Ref<FormatInformation>();
+            return result;
+        }
+        int bitsDifference = numBitsDiffering(maskedFormatInfo1, targetInfo);
+        if (bitsDifference < bestDifference) {
+            bestFormatInfo = decodeInfo[1];
+            bestDifference = bitsDifference;
+        }
+        if (maskedFormatInfo1 != maskedFormatInfo2) {
+            // also try the other option
+            bitsDifference = numBitsDiffering(maskedFormatInfo2, targetInfo);
+            if (bitsDifference < bestDifference) {
+                bestFormatInfo = decodeInfo[1];
+                bestDifference = bitsDifference;
+            }
+        }
+    }
+    if (bestDifference <= 3) {
+        Ref<FormatInformation> result(
+            new FormatInformation(bestFormatInfo, possiableFix_, err_handler));
+        if (err_handler.ErrCode()) return Ref<FormatInformation>();
+        return result;
+    }
+    Ref<FormatInformation> result;
+    return result;
+}
+
+bool operator==(const FormatInformation& a, const FormatInformation& b) {
+    return &(a.errorCorrectionLevel_) == &(b.errorCorrectionLevel_) && a.dataMask_ == b.dataMask_;
+}
+
+}  // namespace qrcode
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/format_information.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/format_information.hpp
new file mode 100644
index 00000000..249c35b7
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/format_information.hpp
@@ -0,0 +1,48 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_FORMAT_INFORMATION_HPP__
+#define __ZXING_QRCODE_FORMAT_INFORMATION_HPP__
+
+#include "../common/counted.hpp"
+#include "../errorhandler.hpp"
+#include "error_correction_level.hpp"
+
+namespace zxing {
+namespace qrcode {
+
+class FormatInformation : public Counted {
+private:
+    static int FORMAT_INFO_MASK_QR;
+    static int FORMAT_INFO_DECODE_LOOKUP[][2];
+    static int N_FORMAT_INFO_DECODE_LOOKUPS;
+    static int BITS_SET_IN_HALF_BYTE[];
+
+    ErrorCorrectionLevel &errorCorrectionLevel_;
+    char dataMask_;
+    float possiableFix_;
+
+    FormatInformation(int formatInfo, float possiableFix, ErrorHandler &err_handler);
+
+public:
+    static int numBitsDiffering(int a, int b);
+    static Ref<FormatInformation> decodeFormatInformation(int maskedFormatInfo1,
+                                                          int maskedFormatInfo2);
+    static Ref<FormatInformation> doDecodeFormatInformation(int maskedFormatInfo1,
+                                                            int maskedFormatInfo2);
+    ErrorCorrectionLevel &getErrorCorrectionLevel();
+    char getDataMask();
+    float getPossiableFix();
+    friend bool operator==(const FormatInformation &a, const FormatInformation &b);
+};
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_FORMAT_INFORMATION_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/qrcode_reader.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/qrcode_reader.cpp
new file mode 100644
index 00000000..b6c4c4f7
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/qrcode_reader.cpp
@@ -0,0 +1,500 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "qrcode_reader.hpp"
+#include <ctime>
+#include "../common/bitarray.hpp"
+#include "detector/detector.hpp"
+
+
+using zxing::ErrorHandler;
+
+namespace zxing {
+namespace qrcode {
+
+QRCodeReader::QRCodeReader() : decoder_() {
+    readerState_ = QRCodeReader::READER_START;
+    detectedDimension_ = -1;
+    lastDecodeTime_ = 0;
+    lastDecodeID_ = 0;
+    decodeID_ = 0;
+    lastPossibleAPCount_ = 0;
+    possibleAPCount_ = 0;
+    lastSamePossibleAPCountTimes_ = 0;
+    samePossibleAPCountTimes_ = 0;
+    lastRecommendedImageSizeType_ = 0;
+    recommendedImageSizeType_ = 0;
+    smoothMaxMultiple_ = 40;
+}
+
+vector<Ref<Result>> QRCodeReader::decode(Ref<BinaryBitmap> image) { return decode(image, DecodeHints()); }
+
+vector<Ref<Result>> QRCodeReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
+    // Binarize image using the Histogram Binarized method and be binarized
+    ErrorHandler err_handler;
+    vector<Ref<Result>> result_list;
+    Ref<BitMatrix> imageBitMatrix = image->getBlackMatrix(err_handler);
+    if (err_handler.ErrCode() || imageBitMatrix == NULL) return result_list;
+
+    vector<Ref<Result>> rst = decodeMore(image, imageBitMatrix, hints, err_handler);
+    if (err_handler.ErrCode() || rst.empty()) {
+        // black white mirro!!!
+        Ref<BitMatrix> invertedMatrix = image->getInvertedMatrix(err_handler);
+        if (err_handler.ErrCode() || invertedMatrix == NULL) return result_list;
+        vector<Ref<Result>> tmp_rst = decodeMore(image, invertedMatrix, hints, err_handler);
+        if (err_handler.ErrCode() || tmp_rst.empty()) return tmp_rst;
+    }
+
+    return rst;
+}
+
+vector<Ref<Result>> QRCodeReader::decodeMore(Ref<BinaryBitmap> image, Ref<BitMatrix> imageBitMatrix,
+                                     DecodeHints hints, ErrorHandler &err_handler) {
+    nowHints_ = hints;
+    std::string ept;
+    vector<Ref<Result>> result_list;
+    if (imageBitMatrix == NULL) return result_list;
+    image->m_poUnicomBlock->Init();
+    image->m_poUnicomBlock->Reset(imageBitMatrix);
+
+    for (int tryTimes = 0; tryTimes < 1; tryTimes++) {
+        Ref<Detector> detector(new Detector(imageBitMatrix, image->m_poUnicomBlock));
+        err_handler.Reset();
+
+        detector->detect(hints, err_handler);
+        if (err_handler.ErrCode()) {
+            err_handler = zxing::ReaderErrorHandler("error detect");
+            setReaderState(detector->getState());
+            ept = err_handler.ErrMsg();
+            continue;
+        }
+
+        setReaderState(detector->getState());
+
+        int possiblePatternCount = detector->getPossiblePatternCount();
+
+        if (possiblePatternCount <= 0) {
+            continue;
+        }
+        for (int i = 0; i < possiblePatternCount; i++) {
+            // filter and perserve the highest score.
+            Ref<FinderPatternInfo> patternInfo = detector->getFinderPatternInfo(i);
+            setPatternFix(patternInfo->getPossibleFix());
+            if (patternInfo->getAnglePossibleFix() < 0.6 && i) continue;
+            bool patternFoundFlag = false;
+            int possibleAlignmentCount = 0;
+            possibleAlignmentCount = detector->getPossibleAlignmentCount(i);
+            if (possibleAlignmentCount < 0) continue;
+
+            detectedDimension_ = detector->getDimension(i);
+            possibleModuleSize_ = detector->getPossibleModuleSize(i);
+            setPossibleAPCountByVersion(detector->getPossibleVersion(i));
+
+            vector<bool> needTryVariousDeimensions(possibleAlignmentCount, false);
+            for (int j = 0; j < possibleAlignmentCount; j++) {
+                if (patternFoundFlag){break;}
+                ArrayRef<Ref<ResultPoint> > points;
+                err_handler.Reset();
+                Ref<DetectorResult> detectorResult =
+                    detector->getResultViaAlignment(i, j, detectedDimension_, err_handler);
+                if (err_handler.ErrCode()) {
+                    ept = err_handler.ErrCode();
+                    setDecoderFix(decoder_.getPossibleFix(), points);
+                    setReaderState(decoder_.getState());
+
+                    if ((patternInfo->getPossibleFix() > 0.9 && decoder_.getPossibleFix() < 0.1)) {
+                        needTryVariousDeimensions[j] = true;
+                    }
+                    continue;
+                }
+
+                points = detectorResult->getPoints();
+                Ref<DecoderResult> decoderResult(
+                    decoder_.decode(detectorResult->getBits(), err_handler));
+                if (err_handler.ErrCode()) {
+                    ept = err_handler.ErrCode();
+                    setDecoderFix(decoder_.getPossibleFix(), points);
+                    setReaderState(decoder_.getState());
+
+                    if ((patternInfo->getPossibleFix() > 0.9 && decoder_.getPossibleFix() < 0.1)) {
+                        needTryVariousDeimensions[j] = true;
+                    }
+                    continue;
+                }
+
+                // If the code was mirrored: swap the bottom-left and the
+                // top-right points.
+                if (decoderResult->getOtherClassName() == "QRCodeDecoderMetaData") {
+                    decoderResult->getOther()->applyMirroredCorrection(points);
+                }
+
+                setDecoderFix(decoder_.getPossibleFix(), points);
+                setReaderState(decoder_.getState());
+
+                Ref<Result> result(
+                    new Result(decoderResult->getText(), decoderResult->getRawBytes(), points,
+                               decoderResult->getCharset(), decoderResult->getQRCodeVersion(),
+                               decoderResult->getEcLevel(), decoderResult->getCharsetMode()));
+                setSuccFix(points);
+                result_list.push_back(result);
+                patternFoundFlag = true;
+                if (nowHints_.getUseNNDetector()) {
+                    return result_list;
+                }
+            }
+            // try different dimentions
+            for (int j = 0; j < possibleAlignmentCount; j++) {
+                if (patternFoundFlag){break;}
+                err_handler.Reset();
+                ArrayRef<Ref<ResultPoint> > points;
+                if (needTryVariousDeimensions[j]) {
+                    vector<int> possibleDimensions = getPossibleDimentions(detectedDimension_);
+                    for (size_t k = 1; k < possibleDimensions.size(); k++) {
+                        err_handler.Reset();
+                        int dimension = possibleDimensions[k];
+
+                        Ref<DetectorResult> detectorResult =
+                            detector->getResultViaAlignment(i, j, dimension, err_handler);
+                        if (err_handler.ErrCode() || detectorResult == NULL) {
+                            ept = err_handler.ErrMsg();
+                            setDecoderFix(decoder_.getPossibleFix(), points);
+                            setReaderState(decoder_.getState());
+                            continue;
+                        }
+
+                        points = detectorResult->getPoints();
+                        Ref<DecoderResult> decoderResult(
+                            decoder_.decode(detectorResult->getBits(), err_handler));
+                        if (err_handler.ErrCode() || decoderResult == NULL) {
+                            ept = err_handler.ErrMsg();
+                            setDecoderFix(decoder_.getPossibleFix(), points);
+                            setReaderState(decoder_.getState());
+                            continue;
+                        }
+
+                        if (decoderResult->getOtherClassName() == "QRCodeDecoderMetaData") {
+                            decoderResult->getOther()->applyMirroredCorrection(points);
+                        }
+
+                        setDecoderFix(decoder_.getPossibleFix(), points);
+                        setReaderState(decoder_.getState());
+
+                        detectedDimension_ = possibleDimensions[k];
+                        Ref<Result> result(new Result(
+                            decoderResult->getText(), decoderResult->getRawBytes(), points,
+                            decoderResult->getCharset(), decoderResult->getQRCodeVersion(),
+                            decoderResult->getEcLevel(), decoderResult->getCharsetMode()));
+
+                        setSuccFix(points);
+                        result_list.push_back(result);
+                        patternFoundFlag = true;
+                        if (nowHints_.getUseNNDetector()) {
+                            return result_list;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return result_list;
+}
+
+vector<int> QRCodeReader::getPossibleDimentions(int detectDimension) {
+    vector<int> possibleDimentions;
+    possibleDimentions.clear();
+
+    if (detectDimension < 0) {
+        return possibleDimentions;
+    }
+
+    possibleDimentions.push_back(detectDimension);
+
+    if (detectDimension <= 169 && detectDimension >= 73) {
+        possibleDimentions.push_back(detectDimension + 4);
+        possibleDimentions.push_back(detectDimension - 4);
+        possibleDimentions.push_back(detectDimension - 8);
+        possibleDimentions.push_back(detectDimension + 8);
+    } else if (detectDimension <= 69 && detectDimension >= 45) {
+        possibleDimentions.push_back(detectDimension + 4);
+        possibleDimentions.push_back(detectDimension - 4);
+    }
+
+    if (detectDimension == 19) {
+        possibleDimentions.push_back(21);
+    }
+
+    return possibleDimentions;
+}
+
+void QRCodeReader::setPossibleAPCountByVersion(unsigned int version) {
+    // cout<<"setPossibleAPCountByVersion"<<endl;
+    if (version < 2)
+        possibleAPCount_ = 0;
+    else if (version < 7)
+        possibleAPCount_ = 1;
+    else if (version < 14)
+        possibleAPCount_ = 2;
+    else if (version < 21)
+        possibleAPCount_ = 3;
+    else if (version < 28)
+        possibleAPCount_ = 4;
+    else if (version < 35)
+        possibleAPCount_ = 5;
+    else
+        possibleAPCount_ = 6;
+}
+
+float QRCodeReader::getPossibleFix() { return possibleQrcodeInfo_.possibleFix; }
+
+int QRCodeReader::smooth(unsigned int *integral, Ref<BitMatrix> input, Ref<BitMatrix> output,
+                         int window) {
+    BitMatrix &imatrix = *input;
+    BitMatrix &omatrix = *output;
+    window >>= 1;
+    int count = 0;
+    int width = input->getWidth();
+    int height = input->getHeight();
+    int bitsize = imatrix.getRowBitsSize();
+
+    bool *jrowtoset = new bool[bitsize];
+
+    bool *jrow = NULL;
+
+    jrow = NULL;
+
+    unsigned int size = window * window;
+
+    for (int j = (window + 1); j < (height - 1 - window); ++j) {
+        int y1 = j - window - 1;
+        int y2 = j + window;
+
+        int offset1 = y1 * width;
+        int offset2 = y2 * width;
+
+        jrow = imatrix.getRowBoolPtr(j);
+
+        memcpy(jrowtoset, jrow, bitsize * sizeof(bool));
+
+        for (int i = (window + 1); i < (width - 1 - window); ++i) {
+            int x1 = i - window - 1;
+            int x2 = i + window;
+            unsigned int sum = integral[offset2 + x2] - integral[offset2 + x1] +
+                               integral[offset1 + x2] - integral[offset1 + x1];
+            bool b = jrow[i];
+            bool result;
+            // the middle 1/3 contains informations of corner, these
+            // informations is useful for finding the finder pattern
+            int sum3 = 3 * sum;
+            if ((unsigned int)sum3 <= size) {
+                result = false;
+            } else if ((unsigned int)sum3 >= size * 2) {
+                result = true;
+            } else {
+                result = b;
+            }
+
+            if (result) {
+                jrowtoset[i] = true;
+            }
+            count += (result ^ b) == 1 ? 1U : 0U;
+        }
+        omatrix.setRowBool(j, jrowtoset);
+    }
+
+    delete[] jrowtoset;
+    return count;
+}
+
+void QRCodeReader::initIntegralOld(unsigned int *integral, Ref<BitMatrix> input) {
+    BitMatrix &matrix = *input;
+    int width = input->getWidth();
+    int height = input->getHeight();
+
+    bool *therow = NULL;
+
+    therow = matrix.getRowBoolPtr(0);
+
+    integral[0] = therow[0];
+
+    int *s = new int[width];
+
+    memset(s, 0, width * sizeof(int));
+
+    integral[0] = therow[0];
+    for (int j = 1; j < width; j++) {
+        integral[j] = integral[j - 1] + therow[j];
+        s[j] += therow[j];
+    }
+
+    int offset = width;
+    unsigned int prevSum = 0;
+
+    for (int i = 1; i < height; i++) {
+        offset = i * width;
+        therow = matrix.getRowBoolPtr(i);
+
+        integral[offset] = integral[offset - width] + therow[0];
+        offset++;
+
+        for (int j = 1; j < width; j++) {
+            s[j] += therow[j];
+            integral[offset] = prevSum + s[j];
+            prevSum = integral[offset];
+            offset++;
+        }
+    }
+
+    delete[] s;
+
+    return;
+}
+
+void QRCodeReader::initIntegral(unsigned int *integral, Ref<BitMatrix> input) {
+    BitMatrix &matrix = *input;
+    int width = input->getWidth();
+    int height = input->getHeight();
+
+    bool *therow = NULL;
+
+    therow = matrix.getRowBoolPtr(0);
+
+    // first row only
+    int rs = 0;
+    for (int j = 0; j < width; j++) {
+        rs += therow[j];
+        integral[j] = rs;
+    }
+
+    // remaining cells are sum above and to the left
+    int offset = 0;
+
+    for (int i = 1; i < height; ++i) {
+        therow = matrix.getRowBoolPtr(i);
+
+        rs = 0;
+
+        offset += width;
+
+        for (int j = 0; j < width; ++j) {
+            rs += therow[j];
+            integral[offset + j] = rs + integral[offset - width + j];
+        }
+    }
+
+    return;
+}
+
+int QRCodeReader::getRecommendedImageSizeTypeInteral() {
+    if (time(0) - lastDecodeTime_ > 30) recommendedImageSizeType_ = 0;
+    return recommendedImageSizeType_;
+}
+
+unsigned int QRCodeReader::getDecodeID() { return decodeID_; }
+
+void QRCodeReader::setDecodeID(unsigned int id) {
+    lastDecodeTime_ = time(0);
+
+    decodeID_ = id;
+    if (decodeID_ != lastDecodeID_) {
+        lastDecodeID_ = decodeID_;
+        lastPossibleAPCount_ = possibleAPCount_;
+        lastSamePossibleAPCountTimes_ = samePossibleAPCountTimes_;
+        lastRecommendedImageSizeType_ = getRecommendedImageSizeTypeInteral();
+        possibleAPCount_ = 0;
+        recommendedImageSizeType_ = 0;
+    }
+}
+
+QRCodeReader::~QRCodeReader() {}
+Decoder &QRCodeReader::getDecoder() { return decoder_; }
+
+unsigned int QRCodeReader::getPossibleAPType() {
+    int version = (detectedDimension_ - 21) / 4 + 1;
+    setPossibleAPCountByVersion(version);
+    return possibleAPCount_;
+}
+int QRCodeReader::getPossibleFixType() { return possibleQrcodeInfo_.possibleFix > 0.0 ? 1 : 0; }
+
+void QRCodeReader::setPatternFix(float possibleFix) {
+    possibleQrcodeInfo_.patternPossibleFix = possibleFix;
+}
+
+void QRCodeReader::setDecoderFix(float possibleFix, ArrayRef<Ref<ResultPoint> > border) {
+    float realFix = possibleFix;
+    if (possibleQrcodeInfo_.possibleFix < realFix) {
+        possibleQrcodeInfo_.possibleFix = realFix;
+        possibleQrcodeInfo_.qrcodeBorder.clear();
+        possibleQrcodeInfo_.possibleModuleSize = possibleModuleSize_;
+        if (border) {
+            for (int i = 0; i < 4; ++i) {
+                possibleQrcodeInfo_.qrcodeBorder.push_back(border[i]);
+            }
+        }
+    }
+}
+void QRCodeReader::setSuccFix(ArrayRef<Ref<ResultPoint> > border) {
+    possibleQrcodeInfo_.qrcodeBorder.clear();
+    possibleQrcodeInfo_.possibleModuleSize = possibleModuleSize_;
+    if (border) {
+        for (int i = 0; i < 4; ++i) {
+            possibleQrcodeInfo_.qrcodeBorder.push_back(border[i]);
+        }
+    }
+}
+
+void QRCodeReader::setReaderState(Detector::DetectorState state) {
+    switch (state) {
+        case Detector::START:
+            this->readerState_ = QRCodeReader::DETECT_START;
+            break;
+        case Detector::FINDFINDERPATTERN:
+            this->readerState_ = QRCodeReader::DETECT_FINDFINDERPATTERN;
+            break;
+        case Detector::FINDALIGNPATTERN:
+            this->readerState_ = QRCodeReader::DETECT_FINDALIGNPATTERN;
+            break;
+    }
+    return;
+}
+void QRCodeReader::setReaderState(Decoder::DecoderState state) {
+    switch (state) {
+        case Decoder::NOTSTART:
+            this->readerState_ = QRCodeReader::DETECT_FAILD;
+            break;
+        case Decoder::START:
+            if (this->readerState_ < QRCodeReader::DECODE_START) {
+                this->readerState_ = QRCodeReader::DECODE_START;
+            }
+            break;
+        case Decoder::READVERSION:
+            if (this->readerState_ < QRCodeReader::DECODE_READVERSION) {
+                this->readerState_ = QRCodeReader::DECODE_READVERSION;
+            }
+            break;
+        case Decoder::READERRORCORRECTIONLEVEL:
+            if (this->readerState_ < QRCodeReader::DECODE_READERRORCORRECTIONLEVEL) {
+                this->readerState_ = QRCodeReader::DECODE_READERRORCORRECTIONLEVEL;
+            }
+            break;
+        case Decoder::READCODEWORDSORRECTIONLEVEL:
+            if (this->readerState_ < QRCodeReader::DECODE_READCODEWORDSORRECTIONLEVEL) {
+                this->readerState_ = QRCodeReader::DECODE_READCODEWORDSORRECTIONLEVEL;
+            }
+            break;
+        case Decoder::FINISH:
+            if (this->readerState_ < QRCodeReader::DECODE_FINISH) {
+                this->readerState_ = QRCodeReader::DECODE_FINISH;
+            }
+            break;
+    }
+    return;
+}
+}  // namespace qrcode
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/qrcode_reader.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/qrcode_reader.hpp
new file mode 100644
index 00000000..613286c2
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/qrcode_reader.hpp
@@ -0,0 +1,131 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_QRCODE_READER_HPP__
+#define __ZXING_QRCODE_QRCODE_READER_HPP__
+
+#include "../decodehints.hpp"
+#include "../errorhandler.hpp"
+#include "../reader.hpp"
+#include "decoder/decoder.hpp"
+#include "decoder/qrcode_decoder_metadata.hpp"
+#include "detector/detector.hpp"
+
+namespace zxing {
+namespace qrcode {
+
+struct QBAR_QRCODE_DETECT_INFO {
+    int possibleFixIndex;
+    unsigned int possibleAPType;
+
+    // QRCodeReader Info
+    float possibleFix;
+    float patternPossibleFix;
+    int pyramidLev;
+    float possibleModuleSize;
+    std::vector<Ref<ResultPoint> > qrcodeBorder;
+
+    QBAR_QRCODE_DETECT_INFO() { clear(); }
+
+    void clear() {
+        possibleFixIndex = -1;
+        possibleAPType = 0;
+        possibleModuleSize = 0;
+
+        possibleFix = 0;
+        patternPossibleFix = 0;
+        pyramidLev = 0;
+        qrcodeBorder.clear();
+    }
+};
+
+class QRCodeReader : public Reader {
+public:
+    enum ReaderState {
+        READER_START = -1,
+        DETECT_START = 0,
+        DETECT_FINDFINDERPATTERN = 1,
+        DETECT_FINDALIGNPATTERN = 2,
+        DETECT_FAILD = 3,
+        DECODE_START = 4,
+        DECODE_READVERSION = 5,
+        DECODE_READERRORCORRECTIONLEVEL = 6,
+        DECODE_READCODEWORDSORRECTIONLEVEL = 7,
+        DECODE_FINISH = 8
+    };
+
+private:
+    Decoder decoder_;
+    int detectedDimension_;
+    ReaderState readerState_;
+    DecodeHints nowHints_;
+
+protected:
+    Decoder& getDecoder();
+
+public:
+    QRCodeReader();
+    virtual ~QRCodeReader();
+    string name() override { return "qrcode"; }
+
+    vector<Ref<Result>> decode(Ref<BinaryBitmap> image) override;
+    vector<Ref<Result>> decode(Ref<BinaryBitmap> image, DecodeHints hints) override;
+
+    vector<Ref<Result>> decodeMore(Ref<BinaryBitmap> image, Ref<BitMatrix> imageBitMatrix,
+                           DecodeHints hints, ErrorHandler& err_handler);
+
+private:
+    QBAR_QRCODE_DETECT_INFO possibleQrcodeInfo_;
+
+protected:
+    void setPossibleAPCountByVersion(unsigned int version);
+    int getRecommendedImageSizeTypeInteral();
+    static void initIntegralOld(unsigned int* integral, Ref<BitMatrix> input);
+    static void initIntegral(unsigned int* integral, Ref<BitMatrix> input);
+    static int smooth(unsigned int* integral, Ref<BitMatrix> input, Ref<BitMatrix> output,
+                      int window);
+    unsigned int lastDecodeTime_;
+    unsigned int lastDecodeID_;
+    unsigned int decodeID_;
+    int lastPossibleAPCount_;
+    int possibleAPCount_;
+    int possibleModuleSize_;
+    unsigned int lastSamePossibleAPCountTimes_;
+    unsigned int samePossibleAPCountTimes_;
+    unsigned int lastRecommendedImageSizeType_;
+    unsigned int recommendedImageSizeType_;
+    unsigned int smoothMaxMultiple_;
+
+public:
+    virtual unsigned int getDecodeID() override;
+    virtual void setDecodeID(unsigned int id) override;
+    virtual float getPossibleFix() override;
+    virtual unsigned int getPossibleAPType();
+    virtual int getPossibleFixType();
+
+    void setReaderState(Detector::DetectorState state);
+    void setReaderState(Decoder::DecoderState state);
+
+    void setPatternFix(float possibleFix);
+    void setDecoderFix(float possibleFix, ArrayRef<Ref<ResultPoint> > border);
+    void setSuccFix(ArrayRef<Ref<ResultPoint> > border);
+
+    ReaderState getReaderState() { return this->readerState_; }
+    float calQrcodeArea(Ref<DetectorResult> detectorResult);
+    float calTriangleArea(Ref<ResultPoint> centerA, Ref<ResultPoint> centerB,
+                          Ref<ResultPoint> centerC);
+
+    vector<int> getPossibleDimentions(int detectDimension);
+};
+
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_QRCODE_READER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/version.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/version.cpp
new file mode 100644
index 00000000..1f08a6b6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/version.cpp
@@ -0,0 +1,500 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../../precomp.hpp"
+#include "version.hpp"
+#include "format_information.hpp"
+
+#include <cstdarg>
+using std::numeric_limits;
+using zxing::ErrorHandler;
+
+namespace zxing {
+namespace qrcode {
+
+ECB::ECB(int count, int dataCodewords) : count_(count), dataCodewords_(dataCodewords) {}
+
+int ECB::getCount() { return count_; }
+
+int ECB::getDataCodewords() { return dataCodewords_; }
+
+ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks)
+    : ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks) {}
+
+ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks1, ECB *ecBlocks2)
+    : ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks1) {
+    ecBlocks_.push_back(ecBlocks2);
+}
+
+int ECBlocks::getECCodewords() { return ecCodewords_; }
+
+std::vector<ECB *> &ECBlocks::getECBlocks() { return ecBlocks_; }
+
+ECBlocks::~ECBlocks() {
+    for (size_t i = 0; i < ecBlocks_.size(); i++) {
+        delete ecBlocks_[i];
+    }
+}
+
+unsigned int Version::VERSION_DECODE_INFO[] = {
+    0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6, 0x0C762, 0x0D847, 0x0E60D, 0x0F928,
+    0x10B78, 0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683, 0x168C9, 0x177EC, 0x18EC4,
+    0x191E1, 0x1AFAB, 0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75, 0x1F250, 0x209D5, 0x216F0,
+    0x228BA, 0x2379F, 0x24B0B, 0x2542E, 0x26A64, 0x27541, 0x28C69};
+int Version::N_VERSION_DECODE_INFOS = 34;
+
+vector<Ref<Version> > Version::VERSIONS;
+static int N_VERSIONS = Version::buildVersions();
+
+int Version::getVersionNumber() { return versionNumber_; }
+
+vector<int> &Version::getAlignmentPatternCenters() { return alignmentPatternCenters_; }
+
+int Version::getTotalCodewords() { return totalCodewords_; }
+
+int Version::getDimensionForVersion(ErrorHandler &err_handler) {
+    if (versionNumber_ < 1 || versionNumber_ > N_VERSIONS) {
+        err_handler = zxing::ReaderErrorHandler("versionNumber must be between 1 and 40");
+        return -1;
+    }
+    return 17 + 4 * versionNumber_;
+}
+
+ECBlocks &Version::getECBlocksForLevel(ErrorCorrectionLevel &ecLevel) {
+    return *ecBlocks_[ecLevel.ordinal()];
+}
+
+static vector<int> *intArray(size_t n...) {
+    va_list ap;
+    va_start(ap, n);
+    vector<int> *result = new vector<int>(n);
+    for (size_t i = 0; i < n; i++) {
+        (*result)[i] = va_arg(ap, int);
+    }
+    va_end(ap);
+    return result;
+}
+
+Version *Version::getProvisionalVersionForDimension(int dimension, ErrorHandler &err_handler) {
+    if (dimension % 4 != 1) {
+        err_handler = zxing::FormatErrorHandler("dimension % 4 != 1");
+        return NULL;
+    }
+
+    // return Version::getVersionForNumber((dimension - 17) >> 2);
+    Version *version = Version::getVersionForNumber((dimension - 17) >> 2, err_handler);
+    if (err_handler.ErrCode()) {
+        err_handler = zxing::FormatErrorHandler("err format");
+        return NULL;
+    }
+    return version;
+}
+
+Version *Version::getVersionForNumber(int versionNumber, ErrorHandler &err_handler) {
+    if (versionNumber < 1 || versionNumber > N_VERSIONS) {
+        err_handler = zxing::ReaderErrorHandler("versionNumber must be between 1 and 40");
+        return NULL;
+    }
+    return VERSIONS[versionNumber - 1];
+}
+
+Version::Version(int versionNumber, vector<int> *alignmentPatternCenters, ECBlocks *ecBlocks1,
+                 ECBlocks *ecBlocks2, ECBlocks *ecBlocks3, ECBlocks *ecBlocks4)
+    : versionNumber_(versionNumber),
+      alignmentPatternCenters_(*alignmentPatternCenters),
+      ecBlocks_(4),
+      totalCodewords_(0) {
+    ecBlocks_[0] = ecBlocks1;
+    ecBlocks_[1] = ecBlocks2;
+    ecBlocks_[2] = ecBlocks3;
+    ecBlocks_[3] = ecBlocks4;
+
+    int total = 0;
+    int ecCodewords = ecBlocks1->getECCodewords();
+    vector<ECB *> &ecbArray = ecBlocks1->getECBlocks();
+    for (size_t i = 0; i < ecbArray.size(); i++) {
+        ECB *ecBlock = ecbArray[i];
+        total += ecBlock->getCount() * (ecBlock->getDataCodewords() + ecCodewords);
+    }
+    totalCodewords_ = total;
+}
+
+Version::~Version() {
+    delete &alignmentPatternCenters_;
+    for (size_t i = 0; i < ecBlocks_.size(); i++) {
+        delete ecBlocks_[i];
+    }
+}
+
+Version *Version::decodeVersionInformation(unsigned int versionBits) {
+    int bestDifference = numeric_limits<int>::max();
+    size_t bestVersion = 0;
+    ErrorHandler err_handler;
+    for (int i = 0; i < N_VERSION_DECODE_INFOS; i++) {
+        unsigned targetVersion = VERSION_DECODE_INFO[i];
+        // Do the version info bits match exactly? done.
+        if (targetVersion == versionBits) {
+            // return getVersionForNumber(i + 7 );
+            Version *version = getVersionForNumber(i + 7, err_handler);
+            if (err_handler.ErrCode()) return 0;
+            return version;
+        }
+        // Otherwise see if this is the closest to a real version info bit
+        // string we have seen so far
+        int bitsDifference = FormatInformation::numBitsDiffering(versionBits, targetVersion);
+        if (bitsDifference < bestDifference) {
+            bestVersion = i + 7;
+            bestDifference = bitsDifference;
+        }
+    }
+    // We can tolerate up to 3 bits of error since no two version info codewords
+    // will differ in less than 4 bits.
+    if (bestDifference <= 3) {
+        // return getVersionForNumber(bestVersion);
+        Version *version = getVersionForNumber(bestVersion, err_handler);
+        if (err_handler.ErrCode()) return 0;
+        return version;
+    }
+    // If we didn't find a close enough match, fail
+    return 0;
+}
+
+Ref<BitMatrix> Version::buildFixedPatternValue(ErrorHandler &err_handler) {
+    int dimension = getDimensionForVersion(err_handler);
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+
+    Ref<BitMatrix> fixedInfo(new BitMatrix(dimension, err_handler));
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+
+    // first timming patterns
+    for (int i = 0; i < dimension; i += 2) fixedInfo->set(i, 6);
+    for (int i = 0; i < dimension; i += 2) fixedInfo->set(6, i);
+
+    // FP top left
+    fixedInfo->setRegion(0, 0, 8, 8, err_handler);
+    fixedInfo->flipRegion(0, 0, 8, 8, err_handler);
+    fixedInfo->flipRegion(0, 0, 7, 7, err_handler);
+    fixedInfo->flipRegion(1, 1, 5, 5, err_handler);
+    fixedInfo->flipRegion(2, 2, 3, 3, err_handler);
+
+    // FP top right
+    fixedInfo->setRegion(dimension - 8, 0, 8, 8, err_handler);
+    fixedInfo->flipRegion(dimension - 8, 0, 8, 8, err_handler);
+    fixedInfo->flipRegion(dimension - 7, 0, 7, 7, err_handler);
+    fixedInfo->flipRegion(dimension - 6, 1, 5, 5, err_handler);
+    fixedInfo->flipRegion(dimension - 5, 2, 3, 3, err_handler);
+
+    // FP bottom left
+    fixedInfo->setRegion(0, dimension - 8, 8, 8, err_handler);
+    fixedInfo->flipRegion(0, dimension - 8, 8, 8, err_handler);
+    fixedInfo->flipRegion(0, dimension - 7, 7, 7, err_handler);
+    fixedInfo->flipRegion(1, dimension - 6, 5, 5, err_handler);
+    fixedInfo->flipRegion(2, dimension - 5, 3, 3, err_handler);
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+
+    // Alignment patterns
+    size_t max = alignmentPatternCenters_.size();
+    for (size_t x = 0; x < max; x++) {
+        int i = alignmentPatternCenters_[x] - 2;
+        for (size_t y = 0; y < max; y++) {
+            if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) {
+                // No alignment patterns near the three finder patterns
+                continue;
+            }
+            fixedInfo->setRegion(alignmentPatternCenters_[y] - 2, i, 5, 5, err_handler);
+            // fixedInfo->flipRegion(alignmentPatternCenters_[y] - 2, i, 5, 5);
+            fixedInfo->flipRegion(alignmentPatternCenters_[y] - 1, i + 1, 3, 3, err_handler);
+            fixedInfo->flipRegion(alignmentPatternCenters_[y], i + 2, 1, 1, err_handler);
+            if (err_handler.ErrCode()) return Ref<BitMatrix>();
+        }
+    }
+    return fixedInfo;
+}
+
+Ref<BitMatrix> Version::buildFixedPatternTemplate(ErrorHandler &err_handler) {
+    int dimension = getDimensionForVersion(err_handler);
+    Ref<BitMatrix> functionPattern(new BitMatrix(dimension, err_handler));
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+
+    // Top left finder pattern + separator + format
+    functionPattern->setRegion(0, 0, 8, 8, err_handler);
+    // Top right finder pattern + separator + format
+    functionPattern->setRegion(dimension - 8, 0, 8, 8, err_handler);
+    // Bottom left finder pattern + separator + format
+    functionPattern->setRegion(0, dimension - 8, 8, 8, err_handler);
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+
+    // Alignment patterns
+    size_t max = alignmentPatternCenters_.size();
+    for (size_t x = 0; x < max; x++) {
+        int i = alignmentPatternCenters_[x] - 2;
+        for (size_t y = 0; y < max; y++) {
+            if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) {
+                // No alignment patterns near the three finder patterns
+                continue;
+            }
+            functionPattern->setRegion(alignmentPatternCenters_[y] - 2, i, 5, 5, err_handler);
+        }
+    }
+
+    // Vertical timing pattern
+    functionPattern->setRegion(6, 8, 1, dimension - 16, err_handler);
+    // Horizontal timing pattern
+    functionPattern->setRegion(8, 6, dimension - 16, 1, err_handler);
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+
+    return functionPattern;
+}
+
+Ref<BitMatrix> Version::buildFunctionPattern(ErrorHandler &err_handler) {
+    int dimension = getDimensionForVersion(err_handler);
+    Ref<BitMatrix> functionPattern(new BitMatrix(dimension, err_handler));
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+
+    // Top left finder pattern + separator + format
+    functionPattern->setRegion(0, 0, 9, 9, err_handler);
+    // Top right finder pattern + separator + format
+    functionPattern->setRegion(dimension - 8, 0, 8, 9, err_handler);
+    // Bottom left finder pattern + separator + format
+    functionPattern->setRegion(0, dimension - 8, 9, 8, err_handler);
+
+    // Alignment patterns
+    size_t max = alignmentPatternCenters_.size();
+    for (size_t x = 0; x < max; x++) {
+        int i = alignmentPatternCenters_[x] - 2;
+        for (size_t y = 0; y < max; y++) {
+            if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) {
+                // No alignment patterns near the three finder patterns
+                continue;
+            }
+            functionPattern->setRegion(alignmentPatternCenters_[y] - 2, i, 5, 5, err_handler);
+        }
+    }
+
+    // Vertical timing pattern
+    functionPattern->setRegion(6, 9, 1, dimension - 17, err_handler);
+    // Horizontal timing pattern
+    functionPattern->setRegion(9, 6, dimension - 17, 1, err_handler);
+    if (err_handler.ErrCode()) return Ref<BitMatrix>();
+
+    if (versionNumber_ > 6) {
+        // Version info, top right
+        functionPattern->setRegion(dimension - 11, 0, 3, 6, err_handler);
+        // Version info, bottom left
+        functionPattern->setRegion(0, dimension - 11, 6, 3, err_handler);
+        if (err_handler.ErrCode()) return Ref<BitMatrix>();
+    }
+
+    return functionPattern;
+}
+
+int Version::buildVersions() {
+    VERSIONS.push_back(Ref<Version>(new Version(
+        1, intArray(0), new ECBlocks(7, new ECB(1, 19)), new ECBlocks(10, new ECB(1, 16)),
+        new ECBlocks(13, new ECB(1, 13)), new ECBlocks(17, new ECB(1, 9)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        2, intArray(2, 6, 18), new ECBlocks(10, new ECB(1, 34)), new ECBlocks(16, new ECB(1, 28)),
+        new ECBlocks(22, new ECB(1, 22)), new ECBlocks(28, new ECB(1, 16)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        3, intArray(2, 6, 22), new ECBlocks(15, new ECB(1, 55)), new ECBlocks(26, new ECB(1, 44)),
+        new ECBlocks(18, new ECB(2, 17)), new ECBlocks(22, new ECB(2, 13)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        4, intArray(2, 6, 26), new ECBlocks(20, new ECB(1, 80)), new ECBlocks(18, new ECB(2, 32)),
+        new ECBlocks(26, new ECB(2, 24)), new ECBlocks(16, new ECB(4, 9)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        5, intArray(2, 6, 30), new ECBlocks(26, new ECB(1, 108)), new ECBlocks(24, new ECB(2, 43)),
+        new ECBlocks(18, new ECB(2, 15), new ECB(2, 16)),
+        new ECBlocks(22, new ECB(2, 11), new ECB(2, 12)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        6, intArray(2, 6, 34), new ECBlocks(18, new ECB(2, 68)), new ECBlocks(16, new ECB(4, 27)),
+        new ECBlocks(24, new ECB(4, 19)), new ECBlocks(28, new ECB(4, 15)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        7, intArray(3, 6, 22, 38), new ECBlocks(20, new ECB(2, 78)),
+        new ECBlocks(18, new ECB(4, 31)), new ECBlocks(18, new ECB(2, 14), new ECB(4, 15)),
+        new ECBlocks(26, new ECB(4, 13), new ECB(1, 14)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(8, intArray(3, 6, 24, 42), new ECBlocks(24, new ECB(2, 97)),
+                                 new ECBlocks(22, new ECB(2, 38), new ECB(2, 39)),
+                                 new ECBlocks(22, new ECB(4, 18), new ECB(2, 19)),
+                                 new ECBlocks(26, new ECB(4, 14), new ECB(2, 15)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(9, intArray(3, 6, 26, 46), new ECBlocks(30, new ECB(2, 116)),
+                                 new ECBlocks(22, new ECB(3, 36), new ECB(2, 37)),
+                                 new ECBlocks(20, new ECB(4, 16), new ECB(4, 17)),
+                                 new ECBlocks(24, new ECB(4, 12), new ECB(4, 13)))));
+    VERSIONS.push_back(Ref<Version>(new Version(10, intArray(3, 6, 28, 50),
+                                                new ECBlocks(18, new ECB(2, 68), new ECB(2, 69)),
+                                                new ECBlocks(26, new ECB(4, 43), new ECB(1, 44)),
+                                                new ECBlocks(24, new ECB(6, 19), new ECB(2, 20)),
+                                                new ECBlocks(28, new ECB(6, 15), new ECB(2, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(11, intArray(3, 6, 30, 54), new ECBlocks(20, new ECB(4, 81)),
+                                 new ECBlocks(30, new ECB(1, 50), new ECB(4, 51)),
+                                 new ECBlocks(28, new ECB(4, 22), new ECB(4, 23)),
+                                 new ECBlocks(24, new ECB(3, 12), new ECB(8, 13)))));
+    VERSIONS.push_back(Ref<Version>(new Version(12, intArray(3, 6, 32, 58),
+                                                new ECBlocks(24, new ECB(2, 92), new ECB(2, 93)),
+                                                new ECBlocks(22, new ECB(6, 36), new ECB(2, 37)),
+                                                new ECBlocks(26, new ECB(4, 20), new ECB(6, 21)),
+                                                new ECBlocks(28, new ECB(7, 14), new ECB(4, 15)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(13, intArray(3, 6, 34, 62), new ECBlocks(26, new ECB(4, 107)),
+                                 new ECBlocks(22, new ECB(8, 37), new ECB(1, 38)),
+                                 new ECBlocks(24, new ECB(8, 20), new ECB(4, 21)),
+                                 new ECBlocks(22, new ECB(12, 11), new ECB(4, 12)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        14, intArray(4, 6, 26, 46, 66), new ECBlocks(30, new ECB(3, 115), new ECB(1, 116)),
+        new ECBlocks(24, new ECB(4, 40), new ECB(5, 41)),
+        new ECBlocks(20, new ECB(11, 16), new ECB(5, 17)),
+        new ECBlocks(24, new ECB(11, 12), new ECB(5, 13)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        15, intArray(4, 6, 26, 48, 70), new ECBlocks(22, new ECB(5, 87), new ECB(1, 88)),
+        new ECBlocks(24, new ECB(5, 41), new ECB(5, 42)),
+        new ECBlocks(30, new ECB(5, 24), new ECB(7, 25)),
+        new ECBlocks(24, new ECB(11, 12), new ECB(7, 13)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        16, intArray(4, 6, 26, 50, 74), new ECBlocks(24, new ECB(5, 98), new ECB(1, 99)),
+        new ECBlocks(28, new ECB(7, 45), new ECB(3, 46)),
+        new ECBlocks(24, new ECB(15, 19), new ECB(2, 20)),
+        new ECBlocks(30, new ECB(3, 15), new ECB(13, 16)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        17, intArray(4, 6, 30, 54, 78), new ECBlocks(28, new ECB(1, 107), new ECB(5, 108)),
+        new ECBlocks(28, new ECB(10, 46), new ECB(1, 47)),
+        new ECBlocks(28, new ECB(1, 22), new ECB(15, 23)),
+        new ECBlocks(28, new ECB(2, 14), new ECB(17, 15)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        18, intArray(4, 6, 30, 56, 82), new ECBlocks(30, new ECB(5, 120), new ECB(1, 121)),
+        new ECBlocks(26, new ECB(9, 43), new ECB(4, 44)),
+        new ECBlocks(28, new ECB(17, 22), new ECB(1, 23)),
+        new ECBlocks(28, new ECB(2, 14), new ECB(19, 15)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        19, intArray(4, 6, 30, 58, 86), new ECBlocks(28, new ECB(3, 113), new ECB(4, 114)),
+        new ECBlocks(26, new ECB(3, 44), new ECB(11, 45)),
+        new ECBlocks(26, new ECB(17, 21), new ECB(4, 22)),
+        new ECBlocks(26, new ECB(9, 13), new ECB(16, 14)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        20, intArray(4, 6, 34, 62, 90), new ECBlocks(28, new ECB(3, 107), new ECB(5, 108)),
+        new ECBlocks(26, new ECB(3, 41), new ECB(13, 42)),
+        new ECBlocks(30, new ECB(15, 24), new ECB(5, 25)),
+        new ECBlocks(28, new ECB(15, 15), new ECB(10, 16)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        21, intArray(5, 6, 28, 50, 72, 94), new ECBlocks(28, new ECB(4, 116), new ECB(4, 117)),
+        new ECBlocks(26, new ECB(17, 42)), new ECBlocks(28, new ECB(17, 22), new ECB(6, 23)),
+        new ECBlocks(30, new ECB(19, 16), new ECB(6, 17)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        22, intArray(5, 6, 26, 50, 74, 98), new ECBlocks(28, new ECB(2, 111), new ECB(7, 112)),
+        new ECBlocks(28, new ECB(17, 46)), new ECBlocks(30, new ECB(7, 24), new ECB(16, 25)),
+        new ECBlocks(24, new ECB(34, 13)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        23, intArray(5, 6, 30, 54, 78, 102), new ECBlocks(30, new ECB(4, 121), new ECB(5, 122)),
+        new ECBlocks(28, new ECB(4, 47), new ECB(14, 48)),
+        new ECBlocks(30, new ECB(11, 24), new ECB(14, 25)),
+        new ECBlocks(30, new ECB(16, 15), new ECB(14, 16)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        24, intArray(5, 6, 28, 54, 80, 106), new ECBlocks(30, new ECB(6, 117), new ECB(4, 118)),
+        new ECBlocks(28, new ECB(6, 45), new ECB(14, 46)),
+        new ECBlocks(30, new ECB(11, 24), new ECB(16, 25)),
+        new ECBlocks(30, new ECB(30, 16), new ECB(2, 17)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        25, intArray(5, 6, 32, 58, 84, 110), new ECBlocks(26, new ECB(8, 106), new ECB(4, 107)),
+        new ECBlocks(28, new ECB(8, 47), new ECB(13, 48)),
+        new ECBlocks(30, new ECB(7, 24), new ECB(22, 25)),
+        new ECBlocks(30, new ECB(22, 15), new ECB(13, 16)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        26, intArray(5, 6, 30, 58, 86, 114), new ECBlocks(28, new ECB(10, 114), new ECB(2, 115)),
+        new ECBlocks(28, new ECB(19, 46), new ECB(4, 47)),
+        new ECBlocks(28, new ECB(28, 22), new ECB(6, 23)),
+        new ECBlocks(30, new ECB(33, 16), new ECB(4, 17)))));
+    VERSIONS.push_back(Ref<Version>(new Version(
+        27, intArray(5, 6, 34, 62, 90, 118), new ECBlocks(30, new ECB(8, 122), new ECB(4, 123)),
+        new ECBlocks(28, new ECB(22, 45), new ECB(3, 46)),
+        new ECBlocks(30, new ECB(8, 23), new ECB(26, 24)),
+        new ECBlocks(30, new ECB(12, 15), new ECB(28, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(28, intArray(6, 6, 26, 50, 74, 98, 122),
+                                 new ECBlocks(30, new ECB(3, 117), new ECB(10, 118)),
+                                 new ECBlocks(28, new ECB(3, 45), new ECB(23, 46)),
+                                 new ECBlocks(30, new ECB(4, 24), new ECB(31, 25)),
+                                 new ECBlocks(30, new ECB(11, 15), new ECB(31, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(29, intArray(6, 6, 30, 54, 78, 102, 126),
+                                 new ECBlocks(30, new ECB(7, 116), new ECB(7, 117)),
+                                 new ECBlocks(28, new ECB(21, 45), new ECB(7, 46)),
+                                 new ECBlocks(30, new ECB(1, 23), new ECB(37, 24)),
+                                 new ECBlocks(30, new ECB(19, 15), new ECB(26, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(30, intArray(6, 6, 26, 52, 78, 104, 130),
+                                 new ECBlocks(30, new ECB(5, 115), new ECB(10, 116)),
+                                 new ECBlocks(28, new ECB(19, 47), new ECB(10, 48)),
+                                 new ECBlocks(30, new ECB(15, 24), new ECB(25, 25)),
+                                 new ECBlocks(30, new ECB(23, 15), new ECB(25, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(31, intArray(6, 6, 30, 56, 82, 108, 134),
+                                 new ECBlocks(30, new ECB(13, 115), new ECB(3, 116)),
+                                 new ECBlocks(28, new ECB(2, 46), new ECB(29, 47)),
+                                 new ECBlocks(30, new ECB(42, 24), new ECB(1, 25)),
+                                 new ECBlocks(30, new ECB(23, 15), new ECB(28, 16)))));
+    VERSIONS.push_back(Ref<Version>(
+        new Version(32, intArray(6, 6, 34, 60, 86, 112, 138), new ECBlocks(30, new ECB(17, 115)),
+                    new ECBlocks(28, new ECB(10, 46), new ECB(23, 47)),
+                    new ECBlocks(30, new ECB(10, 24), new ECB(35, 25)),
+                    new ECBlocks(30, new ECB(19, 15), new ECB(35, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(33, intArray(6, 6, 30, 58, 86, 114, 142),
+                                 new ECBlocks(30, new ECB(17, 115), new ECB(1, 116)),
+                                 new ECBlocks(28, new ECB(14, 46), new ECB(21, 47)),
+                                 new ECBlocks(30, new ECB(29, 24), new ECB(19, 25)),
+                                 new ECBlocks(30, new ECB(11, 15), new ECB(46, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(34, intArray(6, 6, 34, 62, 90, 118, 146),
+                                 new ECBlocks(30, new ECB(13, 115), new ECB(6, 116)),
+                                 new ECBlocks(28, new ECB(14, 46), new ECB(23, 47)),
+                                 new ECBlocks(30, new ECB(44, 24), new ECB(7, 25)),
+                                 new ECBlocks(30, new ECB(59, 16), new ECB(1, 17)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(35, intArray(7, 6, 30, 54, 78, 102, 126, 150),
+                                 new ECBlocks(30, new ECB(12, 121), new ECB(7, 122)),
+                                 new ECBlocks(28, new ECB(12, 47), new ECB(26, 48)),
+                                 new ECBlocks(30, new ECB(39, 24), new ECB(14, 25)),
+                                 new ECBlocks(30, new ECB(22, 15), new ECB(41, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(36, intArray(7, 6, 24, 50, 76, 102, 128, 154),
+                                 new ECBlocks(30, new ECB(6, 121), new ECB(14, 122)),
+                                 new ECBlocks(28, new ECB(6, 47), new ECB(34, 48)),
+                                 new ECBlocks(30, new ECB(46, 24), new ECB(10, 25)),
+                                 new ECBlocks(30, new ECB(2, 15), new ECB(64, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(37, intArray(7, 6, 28, 54, 80, 106, 132, 158),
+                                 new ECBlocks(30, new ECB(17, 122), new ECB(4, 123)),
+                                 new ECBlocks(28, new ECB(29, 46), new ECB(14, 47)),
+                                 new ECBlocks(30, new ECB(49, 24), new ECB(10, 25)),
+                                 new ECBlocks(30, new ECB(24, 15), new ECB(46, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(38, intArray(7, 6, 32, 58, 84, 110, 136, 162),
+                                 new ECBlocks(30, new ECB(4, 122), new ECB(18, 123)),
+                                 new ECBlocks(28, new ECB(13, 46), new ECB(32, 47)),
+                                 new ECBlocks(30, new ECB(48, 24), new ECB(14, 25)),
+                                 new ECBlocks(30, new ECB(42, 15), new ECB(32, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(39, intArray(7, 6, 26, 54, 82, 110, 138, 166),
+                                 new ECBlocks(30, new ECB(20, 117), new ECB(4, 118)),
+                                 new ECBlocks(28, new ECB(40, 47), new ECB(7, 48)),
+                                 new ECBlocks(30, new ECB(43, 24), new ECB(22, 25)),
+                                 new ECBlocks(30, new ECB(10, 15), new ECB(67, 16)))));
+    VERSIONS.push_back(
+        Ref<Version>(new Version(40, intArray(7, 6, 30, 58, 86, 114, 142, 170),
+                                 new ECBlocks(30, new ECB(19, 118), new ECB(6, 119)),
+                                 new ECBlocks(28, new ECB(18, 47), new ECB(31, 48)),
+                                 new ECBlocks(30, new ECB(34, 24), new ECB(34, 25)),
+                                 new ECBlocks(30, new ECB(20, 15), new ECB(61, 16)))));
+    return VERSIONS.size();
+}
+
+}  // namespace qrcode
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/version.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/version.hpp
new file mode 100644
index 00000000..68bb7674
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/qrcode/version.hpp
@@ -0,0 +1,86 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_QRCODE_VERSION_HPP__
+#define __ZXING_QRCODE_VERSION_HPP__
+
+#include "../common/bitmatrix.hpp"
+#include "../common/counted.hpp"
+#include "../errorhandler.hpp"
+#include "error_correction_level.hpp"
+
+namespace zxing {
+namespace qrcode {
+
+// Encapsualtes the parameters for one error-correction block in one symbol
+// version. This includes the number of data codewords, and the number of times
+// a block with these parameters is used consecutively in the QR code version's
+// format.
+class ECB {
+private:
+    int count_;
+    int dataCodewords_;
+
+public:
+    ECB(int count, int dataCodewords);
+    int getCount();
+    int getDataCodewords();
+};
+
+// Encapsulates a set of error-correction blocks in one symbol version. Most
+// versions will use blocks of differing sizes within one version, so, this
+// encapsulates the parameters for each set of blocks. It also holds the number
+// of error-correction codewords per block since it will be the same across all
+// blocks within one version.</p>
+class ECBlocks {
+private:
+    int ecCodewords_;
+    std::vector<ECB *> ecBlocks_;
+
+public:
+    ECBlocks(int ecCodewords, ECB *ecBlocks);
+    ECBlocks(int ecCodewords, ECB *ecBlocks1, ECB *ecBlocks2);
+    int getECCodewords();
+    std::vector<ECB *> &getECBlocks();
+    ~ECBlocks();
+};
+
+class Version : public Counted {
+private:
+    int versionNumber_;
+    std::vector<int> &alignmentPatternCenters_;
+    std::vector<ECBlocks *> ecBlocks_;
+    int totalCodewords_;
+    Version(int versionNumber, std::vector<int> *alignmentPatternCenters, ECBlocks *ecBlocks1,
+            ECBlocks *ecBlocks2, ECBlocks *ecBlocks3, ECBlocks *ecBlocks4);
+
+public:
+    static unsigned int VERSION_DECODE_INFO[];
+    static int N_VERSION_DECODE_INFOS;
+    static std::vector<Ref<Version> > VERSIONS;
+
+    ~Version();
+    int getVersionNumber();
+    std::vector<int> &getAlignmentPatternCenters();
+    int getTotalCodewords();
+    int getDimensionForVersion(ErrorHandler &err_handler);
+    ECBlocks &getECBlocksForLevel(ErrorCorrectionLevel &ecLevel);
+    static Version *getProvisionalVersionForDimension(int dimension, ErrorHandler &err_handler);
+    static Version *getVersionForNumber(int versionNumber, ErrorHandler &err_handler);
+    static Version *decodeVersionInformation(unsigned int versionBits);
+    Ref<BitMatrix> buildFunctionPattern(ErrorHandler &err_handler);
+    Ref<BitMatrix> buildFixedPatternValue(ErrorHandler &err_handler);
+    Ref<BitMatrix> buildFixedPatternTemplate(ErrorHandler &err_handler);
+    static int buildVersions();
+};
+}  // namespace qrcode
+}  // namespace zxing
+
+#endif  // __ZXING_QRCODE_VERSION_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/reader.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/reader.cpp
new file mode 100644
index 00000000..7fa6b65f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/reader.cpp
@@ -0,0 +1,28 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../precomp.hpp"
+#include "reader.hpp"
+
+namespace zxing {
+
+Reader::~Reader() {}
+
+vector<Ref<Result>> Reader::decode(Ref<BinaryBitmap> image) { return decode(image, DecodeHints()); }
+
+unsigned int Reader::getDecodeID() { return 0; }
+
+void Reader::setDecodeID(unsigned int) {}
+
+float Reader::getPossibleFix() { return 0.0; }
+
+
+string Reader::name() { return "unknow"; }
+
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/reader.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/reader.hpp
new file mode 100644
index 00000000..e958013c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/reader.hpp
@@ -0,0 +1,39 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_READER_HPP__
+#define __ZXING_READER_HPP__
+
+#include "binarybitmap.hpp"
+#include "decodehints.hpp"
+#include "errorhandler.hpp"
+#include "result.hpp"
+
+namespace zxing {
+
+class Reader : public Counted {
+protected:
+    Reader() {}
+
+public:
+    virtual vector<Ref<Result>> decode(Ref<BinaryBitmap> image);
+    virtual vector<Ref<Result>> decode(Ref<BinaryBitmap> image, DecodeHints hints) = 0;
+
+    virtual ~Reader();
+    virtual string name();
+    virtual unsigned int getDecodeID();
+    virtual void setDecodeID(unsigned int id);
+
+    virtual float getPossibleFix();
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_READER_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/result.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/result.cpp
new file mode 100644
index 00000000..e33c2c51
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/result.cpp
@@ -0,0 +1,71 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../precomp.hpp"
+#include "result.hpp"
+
+using zxing::ArrayRef;
+using zxing::Ref;
+using zxing::Result;
+using zxing::ResultPoint;
+using zxing::String;
+
+Result::Result(Ref<String> text, ArrayRef<char> rawBytes, ArrayRef<Ref<ResultPoint> > resultPoints)
+    : text_(text), rawBytes_(rawBytes), resultPoints_(resultPoints) {
+    charset_ = "UTF-8";
+
+    qrcodeVersion_ = -1;
+    pyramidLv_ = -1;
+    binaryMethod_ = -1;
+    ecLevel_ = '0';
+}
+
+Result::Result(Ref<String> text, ArrayRef<char> rawBytes, ArrayRef<Ref<ResultPoint> > resultPoints,
+               std::string charset)
+    : text_(text), rawBytes_(rawBytes), resultPoints_(resultPoints), charset_(charset) {
+    qrcodeVersion_ = -1;
+    pyramidLv_ = -1;
+    binaryMethod_ = -1;
+    ecLevel_ = '0';
+}
+
+Result::Result(Ref<String> text, ArrayRef<char> rawBytes, ArrayRef<Ref<ResultPoint> > resultPoints,
+               std::string charset, int QRCodeVersion, string ecLevel, string charsetMode)
+    : text_(text),
+      rawBytes_(rawBytes),
+      resultPoints_(resultPoints),
+      charset_(charset),
+      qrcodeVersion_(QRCodeVersion),
+      ecLevel_(ecLevel),
+      charsetMode_(charsetMode) {
+    pyramidLv_ = -1;
+    binaryMethod_ = -1;
+}
+
+Result::~Result() {}
+
+Ref<String> Result::getText() { return text_; }
+
+ArrayRef<char> Result::getRawBytes() { return rawBytes_; }
+
+ArrayRef<Ref<ResultPoint> > const& Result::getResultPoints() const { return resultPoints_; }
+
+ArrayRef<Ref<ResultPoint> >& Result::getResultPoints() { return resultPoints_; }
+
+void Result::enlargeResultPoints(int scale) {
+    for (int i = 0; i < resultPoints_->size(); i++) {
+        resultPoints_[i] = Ref<ResultPoint>(new ResultPoint(
+            resultPoints_[i]->getX() * (float)scale, resultPoints_[i]->getY() * (float)scale));
+    }
+    return;
+}
+
+std::string Result::getCharset() const { return charset_; }
+
+std::string zxing::Result::getChartsetMode() const { return charsetMode_; }
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/result.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/result.hpp
new file mode 100644
index 00000000..6bf053c0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/result.hpp
@@ -0,0 +1,78 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_RESULT_HPP__
+#define __ZXING_RESULT_HPP__
+
+#include <stdint.h>
+#include "common/array.hpp"
+#include "common/counted.hpp"
+#include "common/str.hpp"
+#include "resultpoint.hpp"
+
+#include <string>
+
+namespace zxing {
+
+class Result : public Counted {
+private:
+    Ref<String> text_;
+    ArrayRef<char> rawBytes_;
+    ArrayRef<Ref<ResultPoint> > resultPoints_;
+    std::string charset_;
+    int qrcodeVersion_;
+    int pyramidLv_;
+    int binaryMethod_;
+    string ecLevel_;
+    string charsetMode_;
+    string scale_list_;
+    float decode_scale_;
+    uint32_t detect_time_;
+    uint32_t sr_time_;
+
+public:
+    Result(Ref<String> text, ArrayRef<char> rawBytes, ArrayRef<Ref<ResultPoint> > resultPoints);
+
+    Result(Ref<String> text, ArrayRef<char> rawBytes, ArrayRef<Ref<ResultPoint> > resultPoints,
+           std::string charset);
+
+    Result(Ref<String> text, ArrayRef<char> rawBytes, ArrayRef<Ref<ResultPoint> > resultPoints,
+           std::string charset, int QRCodeVersion, string ecLevel, string charsetMode);
+
+    ~Result();
+
+    Ref<String> getText();
+    ArrayRef<char> getRawBytes();
+    ArrayRef<Ref<ResultPoint> > const& getResultPoints() const;
+    ArrayRef<Ref<ResultPoint> >& getResultPoints();
+    std::string getCharset() const;
+    std::string getChartsetMode() const;
+    void enlargeResultPoints(int scale);
+
+    int getQRCodeVersion() const { return qrcodeVersion_; };
+    void setQRCodeVersion(int QRCodeVersion) { qrcodeVersion_ = QRCodeVersion; };
+    int getPyramidLv() const { return pyramidLv_; };
+    void setPyramidLv(int pyramidLv) { pyramidLv_ = pyramidLv; };
+    int getBinaryMethod() const { return binaryMethod_; };
+    void setBinaryMethod(int binaryMethod) { binaryMethod_ = binaryMethod; };
+    string getEcLevel() const { return ecLevel_; }
+    void setEcLevel(char ecLevel) { ecLevel_ = ecLevel; }
+    std::string getScaleList() { return scale_list_; };
+    void setScaleList(const std::string& scale_list) { scale_list_ = scale_list; };
+    float getDecodeScale() { return decode_scale_; };
+    void setDecodeScale(float decode_scale) { decode_scale_ = decode_scale; };
+    uint32_t getDetectTime() { return detect_time_; };
+    void setDetectTime(uint32_t detect_time) { detect_time_ = detect_time; };
+    uint32_t getSrTime() { return sr_time_; };
+    void setSrTime(uint32_t sr_time) { sr_time_ = sr_time; };
+};
+
+}  // namespace zxing
+#endif  // __ZXING_RESULT_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/resultpoint.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/resultpoint.cpp
new file mode 100644
index 00000000..0fab518d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/resultpoint.cpp
@@ -0,0 +1,101 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+#include "../precomp.hpp"
+#include "resultpoint.hpp"
+#include "common/mathutils.hpp"
+
+using zxing::common::MathUtils;
+
+namespace zxing {
+
+ResultPoint::ResultPoint() : posX_(0), posY_(0) {}
+
+ResultPoint::ResultPoint(float x, float y) : posX_(x), posY_(y) {}
+
+ResultPoint::ResultPoint(int x, int y) : posX_(float(x)), posY_(float(y)) {}
+
+ResultPoint::~ResultPoint() {}
+
+float ResultPoint::getX() const { return posX_; }
+
+float ResultPoint::getY() const { return posY_; }
+
+void ResultPoint::SetX(float fX) { posX_ = fX; }
+
+void ResultPoint::SetY(float fY) { posY_ = fY; }
+
+bool ResultPoint::equals(Ref<ResultPoint> other) {
+    return (fabs(posX_ - other->getX()) <= 1e-6) && (fabs(posY_ - other->getY()) <= 1e-6);
+}
+
+/**
+ * <p>Orders an array of three ResultPoints in an order [A,B,C] such that AB <
+ * AC and BC < AC and the angle between BC and BA is less than 180 degrees.
+ */
+void ResultPoint::orderBestPatterns(std::vector<Ref<ResultPoint> > &patterns) {
+    // Find distances between pattern centers
+    float zeroOneDistance = distance(patterns[0]->getX(), patterns[1]->getX(), patterns[0]->getY(),
+                                     patterns[1]->getY());
+    float oneTwoDistance = distance(patterns[1]->getX(), patterns[2]->getX(), patterns[1]->getY(),
+                                    patterns[2]->getY());
+    float zeroTwoDistance = distance(patterns[0]->getX(), patterns[2]->getX(), patterns[0]->getY(),
+                                     patterns[2]->getY());
+
+    Ref<ResultPoint> pointA, pointB, pointC;
+    // Assume one closest to other two is B; A and C will just be guesses at
+    // first
+    if (oneTwoDistance >= zeroOneDistance && oneTwoDistance >= zeroTwoDistance) {
+        pointB = patterns[0];
+        pointA = patterns[1];
+        pointC = patterns[2];
+    } else if (zeroTwoDistance >= oneTwoDistance && zeroTwoDistance >= zeroOneDistance) {
+        pointB = patterns[1];
+        pointA = patterns[0];
+        pointC = patterns[2];
+    } else {
+        pointB = patterns[2];
+        pointA = patterns[0];
+        pointC = patterns[1];
+    }
+
+    // Use cross product to figure out whether A and C are correct or flipped.
+    // This asks whether BC x BA has a positive z component, which is the
+    // arrangement we want for A, B, C. If it's negative, then we've got it
+    // flipped around and should swap A and C.
+    if (crossProductZ(pointA, pointB, pointC) < 0.0f) {
+        Ref<ResultPoint> temp = pointA;
+        pointA = pointC;
+        pointC = temp;
+    }
+
+    patterns[0] = pointA;
+    patterns[1] = pointB;
+    patterns[2] = pointC;
+}
+
+float ResultPoint::distance(Ref<ResultPoint> pattern1, Ref<ResultPoint> pattern2) {
+    return MathUtils::distance(pattern1->posX_, pattern1->posY_, pattern2->posX_, pattern2->posY_);
+}
+
+float ResultPoint::distance(float x1, float x2, float y1, float y2) {
+    float xDiff = x1 - x2;
+    float yDiff = y1 - y2;
+    return (float)sqrt((double)(xDiff * xDiff + yDiff * yDiff));
+}
+
+float ResultPoint::crossProductZ(Ref<ResultPoint> pointA, Ref<ResultPoint> pointB,
+                                 Ref<ResultPoint> pointC) {
+    float bX = pointB->getX();
+    float bY = pointB->getY();
+    return ((pointC->getX() - bX) * (pointA->getY() - bY)) -
+           ((pointC->getY() - bY) * (pointA->getX() - bX));
+}
+}  // namespace zxing
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/resultpoint.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/resultpoint.hpp
new file mode 100644
index 00000000..cb5d05d0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/resultpoint.hpp
@@ -0,0 +1,47 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_RESULTPOINT_HPP__
+#define __ZXING_RESULTPOINT_HPP__
+
+#include "common/counted.hpp"
+
+namespace zxing {
+
+class ResultPoint : public Counted {
+protected:
+    float posX_;
+    float posY_;
+
+public:
+    ResultPoint();
+    ResultPoint(float x, float y);
+    ResultPoint(int x, int y);
+    virtual ~ResultPoint();
+
+    virtual float getX() const;
+    virtual float getY() const;
+    virtual void SetX(float fX);
+    virtual void SetY(float fY);
+
+    bool equals(Ref<ResultPoint> other);
+
+    static void orderBestPatterns(std::vector<Ref<ResultPoint> > &patterns);
+    static float distance(Ref<ResultPoint> point1, Ref<ResultPoint> point2);
+    static float distance(float x1, float x2, float y1, float y2);
+
+private:
+    static float crossProductZ(Ref<ResultPoint> pointA, Ref<ResultPoint> pointB,
+                               Ref<ResultPoint> pointC);
+};
+
+}  // namespace zxing
+
+#endif  // __ZXING_RESULTPOINT_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/zxing.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/zxing.hpp
new file mode 100644
index 00000000..76efae22
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/src/zxing/zxing.hpp
@@ -0,0 +1,69 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef __ZXING_ZXING_HPP__
+#define __ZXING_ZXING_HPP__
+
+
+#define COUNTER_TYPE short
+
+
+#define ZXING_ARRAY_LEN(v) ((int)(sizeof(v) / sizeof(v[0])))
+#define ZX_LOG_DIGITS(digits) \
+    ((digits == 8)            \
+         ? 3                  \
+         : ((digits == 16)    \
+                ? 4           \
+                : ((digits == 32) ? 5 : ((digits == 64) ? 6 : ((digits == 128) ? 7 : (-1))))))
+
+#ifndef USE_QRCODE_ONLY
+#define USE_ONED_WRITER 1
+#endif
+
+#if defined(__ANDROID_API__) || defined(_MSC_VER)
+
+#ifndef NO_ICONV
+#define NO_ICONV
+#endif
+
+#endif
+
+
+
+#ifndef NO_ICONV_INSIDE
+#define NO_ICONV_INSIDE
+#endif
+
+#define ZXING_MAX_WIDTH 2048
+#define ZXING_MAX_HEIGHT 2048
+
+namespace zxing {
+typedef char byte;
+typedef unsigned char boolean;
+// typedef unsigned short ushort;
+}  // namespace zxing
+
+#include <limits>
+#include <cmath>
+
+namespace zxing {
+inline bool isnan(float v) { return std::isnan(v); }
+inline bool isnan(double v) { return std::isnan(v); }
+inline float nan() { return std::numeric_limits<float>::quiet_NaN(); }
+}  // namespace zxing
+
+#ifndef ZXING_TIME
+#define ZXING_TIME(string) (void)0
+#endif
+#ifndef ZXING_TIME_MARK
+#define ZXING_TIME_MARK(string) (void)0
+#endif
+
+#endif  // __ZXING_ZXING_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/test/test_main.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/test/test_main.cpp
new file mode 100644
index 00000000..02b3a26f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/test/test_main.cpp
@@ -0,0 +1,29 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#include "test_precomp.hpp"
+
+#if defined(HAVE_HPX)
+#include <hpx/hpx_main.hpp>
+#endif
+
+static
+void initTests()
+{
+#ifdef HAVE_OPENCV_DNN
+    const char* extraTestDataPath =
+#ifdef WINRT
+        NULL;
+#else
+        getenv("OPENCV_DNN_TEST_DATA_PATH");
+#endif
+    if (extraTestDataPath)
+        cvtest::addDataSearchPath(extraTestDataPath);
+#endif  // HAVE_OPENCV_DNN
+}
+
+CV_TEST_MAIN("cv", initTests())
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/test/test_precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/test/test_precomp.hpp
new file mode 100644
index 00000000..0f5ee5ba
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/test/test_precomp.hpp
@@ -0,0 +1,14 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/wechat_qrcode.hpp"
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/test/test_qrcode.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/test/test_qrcode.cpp
new file mode 100644
index 00000000..d59932b8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/wechat_qrcode/test/test_qrcode.cpp
@@ -0,0 +1,459 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#include "test_precomp.hpp"
+#include "opencv2/objdetect.hpp"
+
+namespace opencv_test {
+namespace {
+std::string qrcode_images_name[] = {
+    "version_1_down.jpg", /*"version_1_left.jpg",  "version_1_right.jpg", "version_1_up.jpg",*/
+    "version_1_top.jpg",
+    /*"version_2_down.jpg",*/ "version_2_left.jpg", /*"version_2_right.jpg",*/
+    "version_2_up.jpg",
+    "version_2_top.jpg",
+    "version_3_down.jpg",
+    "version_3_left.jpg",
+    /*"version_3_right.jpg",*/ "version_3_up.jpg",
+    "version_3_top.jpg",
+    "version_4_down.jpg",
+    "version_4_left.jpg",
+    /*"version_4_right.jpg",*/ "version_4_up.jpg",
+    "version_4_top.jpg",
+    "version_5_down.jpg",
+    "version_5_left.jpg",
+    /*"version_5_right.jpg",*/ "version_5_up.jpg",
+    "version_5_top.jpg",
+    "russian.jpg",
+    "kanji.jpg", /*"link_github_ocv.jpg",*/
+    "link_ocv.jpg",
+    "link_wiki_cv.jpg"};
+
+std::string qrcode_images_close[] = {/*"close_1.png",*/ "close_2.png", "close_3.png", "close_4.png",
+                                     "close_5.png"};
+std::string qrcode_images_monitor[] = {"monitor_1.png", "monitor_2.png", "monitor_3.png",
+                                       "monitor_4.png", "monitor_5.png"};
+std::string qrcode_images_curved[] = {"curved_1.jpg", /*"curved_2.jpg", "curved_3.jpg",
+                                      "curved_4.jpg",*/
+                                      "curved_5.jpg", "curved_6.jpg",
+                                      /*"curved_7.jpg", "curved_8.jpg"*/};
+std::string qrcode_images_multiple[] = {/*"2_qrcodes.png",*/ "3_close_qrcodes.png", /*"3_qrcodes.png",
+                                          "4_qrcodes.png", "5_qrcodes.png",  "6_qrcodes.png",*/
+                                          "7_qrcodes.png"/*, "8_close_qrcodes.png"*/};
+
+typedef testing::TestWithParam<std::string> Objdetect_QRCode;
+TEST_P(Objdetect_QRCode, regression) {
+    const std::string name_current_image = GetParam();
+    const std::string root = "qrcode/";
+
+    std::string image_path = findDataFile(root + name_current_image);
+    Mat src = imread(image_path, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+
+    vector<Mat> points;
+    // can not find the model file
+    // so we temporarily comment it out
+    // auto detector = wechat_qrcode::WeChatQRCode(
+    //     findDataFile("detect.prototxt", false), findDataFile("detect.caffemodel", false),
+    //     findDataFile("sr.prototxt", false), findDataFile("sr.caffemodel", false));
+    auto detector = wechat_qrcode::WeChatQRCode();
+    auto decoded_info = detector.detectAndDecode(src, points);
+
+    const std::string dataset_config = findDataFile(root + "dataset_config.json");
+    FileStorage file_config(dataset_config, FileStorage::READ);
+    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
+    {
+        FileNode images_list = file_config["test_images"];
+        size_t images_count = static_cast<size_t>(images_list.size());
+        ASSERT_GT(images_count, 0u)
+            << "Can't find validation data entries in 'test_images': " << dataset_config;
+
+        for (size_t index = 0; index < images_count; index++) {
+            FileNode config = images_list[(int)index];
+            std::string name_test_image = config["image_name"];
+            if (name_test_image == name_current_image) {
+                std::string original_info = config["info"];
+                string decoded_str;
+                if (decoded_info.size()) {
+                    decoded_str = decoded_info[0];
+                }
+                EXPECT_EQ(decoded_str, original_info);
+                return;  // done
+            }
+        }
+        std::cerr << "Not found results for '" << name_current_image
+                  << "' image in config file:" << dataset_config << std::endl
+                  << "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data."
+                  << std::endl;
+    }
+}
+
+typedef testing::TestWithParam<std::string> Objdetect_QRCode_Close;
+TEST_P(Objdetect_QRCode_Close, regression) {
+    const std::string name_current_image = GetParam();
+    const std::string root = "qrcode/close/";
+
+    std::string image_path = findDataFile(root + name_current_image);
+    Mat src = imread(image_path, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+
+    vector<Mat> points;
+    // can not find the model file
+    // so we temporarily comment it out
+    // auto detector = wechat_qrcode::WeChatQRCode(
+    //     findDataFile("detect.prototxt", false), findDataFile("detect.caffemodel", false),
+    //     findDataFile("sr.prototxt", false), findDataFile("sr.caffemodel", false));
+    auto detector = wechat_qrcode::WeChatQRCode();
+    auto decoded_info = detector.detectAndDecode(src, points);
+
+    const std::string dataset_config = findDataFile(root + "dataset_config.json");
+    FileStorage file_config(dataset_config, FileStorage::READ);
+    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
+    {
+        FileNode images_list = file_config["close_images"];
+        size_t images_count = static_cast<size_t>(images_list.size());
+        ASSERT_GT(images_count, 0u)
+            << "Can't find validation data entries in 'close_images': " << dataset_config;
+
+        for (size_t index = 0; index < images_count; index++) {
+            FileNode config = images_list[(int)index];
+            std::string name_test_image = config["image_name"];
+            if (name_test_image == name_current_image) {
+                std::string original_info = config["info"];
+                string decoded_str;
+                if (decoded_info.size()) {
+                    decoded_str = decoded_info[0];
+                }
+                EXPECT_EQ(decoded_str, original_info);
+                return;  // done
+            }
+        }
+        std::cerr << "Not found results for '" << name_current_image
+                  << "' image in config file:" << dataset_config << std::endl
+                  << "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data."
+                  << std::endl;
+    }
+}
+
+typedef testing::TestWithParam<std::string> Objdetect_QRCode_Monitor;
+TEST_P(Objdetect_QRCode_Monitor, regression) {
+    const std::string name_current_image = GetParam();
+    const std::string root = "qrcode/monitor/";
+
+    std::string image_path = findDataFile(root + name_current_image);
+    Mat src = imread(image_path, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+
+    vector<Mat> points;
+    // can not find the model file
+    // so we temporarily comment it out
+    // auto detector = wechat_qrcode::WeChatQRCode(
+    //     findDataFile("detect.prototxt", false), findDataFile("detect.caffemodel", false),
+    //     findDataFile("sr.prototxt", false), findDataFile("sr.caffemodel", false));
+    auto detector = wechat_qrcode::WeChatQRCode();
+    auto decoded_info = detector.detectAndDecode(src, points);
+
+    const std::string dataset_config = findDataFile(root + "dataset_config.json");
+    FileStorage file_config(dataset_config, FileStorage::READ);
+    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
+    {
+        FileNode images_list = file_config["monitor_images"];
+        size_t images_count = static_cast<size_t>(images_list.size());
+        ASSERT_GT(images_count, 0u)
+            << "Can't find validation data entries in 'monitor_images': " << dataset_config;
+
+        for (size_t index = 0; index < images_count; index++) {
+            FileNode config = images_list[(int)index];
+            std::string name_test_image = config["image_name"];
+            if (name_test_image == name_current_image) {
+                std::string original_info = config["info"];
+                string decoded_str;
+                if (decoded_info.size()) {
+                    decoded_str = decoded_info[0];
+                }
+                EXPECT_EQ(decoded_str, original_info);
+                return;  // done
+            }
+        }
+        std::cerr << "Not found results for '" << name_current_image
+                  << "' image in config file:" << dataset_config << std::endl
+                  << "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data."
+                  << std::endl;
+    }
+}
+
+typedef testing::TestWithParam<std::string> Objdetect_QRCode_Curved;
+TEST_P(Objdetect_QRCode_Curved, regression) {
+    const std::string name_current_image = GetParam();
+    const std::string root = "qrcode/curved/";
+
+    std::string image_path = findDataFile(root + name_current_image);
+    Mat src = imread(image_path, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+
+    vector<Mat> points;
+    // can not find the model file
+    // so we temporarily comment it out
+    // auto detector = wechat_qrcode::WeChatQRCode(
+    //     findDataFile("detect.prototxt", false), findDataFile("detect.caffemodel", false),
+    //     findDataFile("sr.prototxt", false), findDataFile("sr.caffemodel", false));
+    auto detector = wechat_qrcode::WeChatQRCode();
+    auto decoded_info = detector.detectAndDecode(src, points);
+
+    const std::string dataset_config = findDataFile(root + "dataset_config.json");
+    FileStorage file_config(dataset_config, FileStorage::READ);
+    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
+    {
+        FileNode images_list = file_config["test_images"];
+        size_t images_count = static_cast<size_t>(images_list.size());
+        ASSERT_GT(images_count, 0u)
+            << "Can't find validation data entries in 'test_images': " << dataset_config;
+
+        for (size_t index = 0; index < images_count; index++) {
+            FileNode config = images_list[(int)index];
+            std::string name_test_image = config["image_name"];
+            if (name_test_image == name_current_image) {
+                std::string original_info = config["info"];
+                string decoded_str;
+                if (decoded_info.size()) {
+                    decoded_str = decoded_info[0];
+                }
+                EXPECT_EQ(decoded_str, original_info);
+                return;  // done
+            }
+        }
+        std::cerr << "Not found results for '" << name_current_image
+                  << "' image in config file:" << dataset_config << std::endl
+                  << "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data."
+                  << std::endl;
+    }
+}
+
+typedef testing::TestWithParam<std::string> Objdetect_QRCode_Multi;
+TEST_P(Objdetect_QRCode_Multi, regression) {
+    const std::string name_current_image = GetParam();
+    const std::string root = "qrcode/multiple/";
+    string path_detect_prototxt, path_detect_caffemodel, path_sr_prototxt, path_sr_caffemodel;
+    string model_version = "_2021-01";
+    path_detect_prototxt = findDataFile("dnn/wechat"+model_version+"/detect.prototxt", false);
+    path_detect_caffemodel = findDataFile("dnn/wechat"+model_version+"/detect.caffemodel", false);
+    path_sr_prototxt = findDataFile("dnn/wechat"+model_version+"/sr.prototxt", false);
+    path_sr_caffemodel = findDataFile("dnn/wechat"+model_version+"/sr.caffemodel", false);
+
+    std::string image_path = findDataFile(root + name_current_image);
+    Mat src = imread(image_path);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+
+    vector<Mat> points;
+    auto detector = wechat_qrcode::WeChatQRCode(path_detect_prototxt, path_detect_caffemodel, path_sr_prototxt,
+                                                path_sr_caffemodel);
+    vector<string> decoded_info = detector.detectAndDecode(src, points);
+
+    const std::string dataset_config = findDataFile(root + "dataset_config.json");
+    FileStorage file_config(dataset_config, FileStorage::READ);
+    ASSERT_TRUE(file_config.isOpened()) << "Can't read validation data: " << dataset_config;
+    {
+        FileNode images_list = file_config["multiple_images"];
+        size_t images_count = static_cast<size_t>(images_list.size());
+        ASSERT_GT(images_count, 0u)
+            << "Can't find validation data entries in 'test_images': " << dataset_config;
+        for (size_t index = 0; index < images_count; index++) {
+            FileNode config = images_list[(int)index];
+            std::string name_test_image = config["image_name"];
+            if (name_test_image == name_current_image) {
+                size_t count_eq_info = 0;
+                for (int i = 0; i < int(decoded_info.size()); i++) {
+                    for (int j = 0; j < int(config["info"].size()); j++) {
+                        std::string original_info = config["info"][j];
+                        if (original_info == decoded_info[i]) {
+                            count_eq_info++;
+                            break;
+                        }
+                    }
+                }
+                EXPECT_EQ(config["info"].size(), count_eq_info);
+                return;  // done
+            }
+        }
+        std::cerr << "Not found results for '" << name_current_image
+                  << "' image in config file:" << dataset_config << std::endl
+                  << "Re-run tests with enabled UPDATE_QRCODE_TEST_DATA macro to update test data."
+                  << std::endl;
+    }
+}
+
+TEST(Objdetect_QRCode_points_position, rotate45) {
+    string path_detect_prototxt, path_detect_caffemodel, path_sr_prototxt, path_sr_caffemodel;
+    string model_version = "_2021-01";
+    path_detect_prototxt = findDataFile("dnn/wechat"+model_version+"/detect.prototxt", false);
+    path_detect_caffemodel = findDataFile("dnn/wechat"+model_version+"/detect.caffemodel", false);
+    path_sr_prototxt = findDataFile("dnn/wechat"+model_version+"/sr.prototxt", false);
+    path_sr_caffemodel = findDataFile("dnn/wechat"+model_version+"/sr.caffemodel", false);
+
+    auto detector = wechat_qrcode::WeChatQRCode(path_detect_prototxt, path_detect_caffemodel, path_sr_prototxt,
+                                                path_sr_caffemodel);
+
+    const cv::String expect_msg = "OpenCV";
+    QRCodeEncoder::Params params;
+    params.version = 5; // 37x37
+    Ptr<QRCodeEncoder> qrcode_enc = cv::QRCodeEncoder::create(params);
+    Mat qrImage;
+    qrcode_enc->encode(expect_msg, qrImage);
+    Mat image(800, 800, CV_8UC1);
+    const int pixInBlob = 4;
+    Size qrSize = Size((21+(params.version-1)*4)*pixInBlob,(21+(params.version-1)*4)*pixInBlob);
+    Rect2f rec(static_cast<float>((image.cols - qrSize.width)/2),
+               static_cast<float>((image.rows - qrSize.height)/2),
+               static_cast<float>(qrSize.width),
+               static_cast<float>(qrSize.height));
+    vector<float> goldCorners = {rec.x, rec.y,
+                                 rec.x+rec.width, rec.y,
+                                 rec.x+rec.width, rec.y+rec.height,
+                                 rec.x, rec.y+rec.height};
+    Mat roiImage = image(rec);
+    cv::resize(qrImage, roiImage, qrSize, 1., 1., INTER_NEAREST);
+
+    vector<Mat> points1;
+    auto decoded_info1 = detector.detectAndDecode(image, points1);
+    ASSERT_EQ(1ull, decoded_info1.size());
+    ASSERT_EQ(expect_msg, decoded_info1[0]);
+    EXPECT_NEAR(0, cvtest::norm(Mat(goldCorners), points1[0].reshape(1, 8), NORM_INF), 8.);
+
+    const double angle = 45;
+    Point2f pc(image.cols/2.f, image.rows/2.f);
+    Mat rot = getRotationMatrix2D(pc, angle, 1.);
+    warpAffine(image, image, rot, image.size());
+    vector<float> rotateGoldCorners;
+    for (int i = 0; i < static_cast<int>(goldCorners.size()); i+= 2) {
+        rotateGoldCorners.push_back(static_cast<float>(rot.at<double>(0, 0) * goldCorners[i] +
+                                    rot.at<double>(0, 1) * goldCorners[i+1] + rot.at<double>(0, 2)));
+        rotateGoldCorners.push_back(static_cast<float>(rot.at<double>(1, 0) * goldCorners[i] +
+                                    rot.at<double>(1, 1) * goldCorners[i+1] + rot.at<double>(1, 2)));
+    }
+    vector<Mat> points2;
+    auto decoded_info2 = detector.detectAndDecode(image, points2);
+    ASSERT_EQ(1ull, decoded_info2.size());
+    ASSERT_EQ(expect_msg, decoded_info2[0]);
+    EXPECT_NEAR(0, cvtest::norm(Mat(rotateGoldCorners), points2[0].reshape(1, 8), NORM_INF), 11.);
+}
+
+INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode, testing::ValuesIn(qrcode_images_name));
+INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_Close, testing::ValuesIn(qrcode_images_close));
+INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_Monitor, testing::ValuesIn(qrcode_images_monitor));
+INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_Curved, testing::ValuesIn(qrcode_images_curved));
+INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_Multi, testing::ValuesIn(qrcode_images_multiple));
+
+TEST(Objdetect_QRCode_Big, regression) {
+    string path_detect_prototxt, path_detect_caffemodel, path_sr_prototxt, path_sr_caffemodel;
+    string model_version = "_2021-01";
+    path_detect_prototxt = findDataFile("dnn/wechat"+model_version+"/detect.prototxt", false);
+    path_detect_caffemodel = findDataFile("dnn/wechat"+model_version+"/detect.caffemodel", false);
+    path_sr_prototxt = findDataFile("dnn/wechat"+model_version+"/sr.prototxt", false);
+    path_sr_caffemodel = findDataFile("dnn/wechat"+model_version+"/sr.caffemodel", false);
+
+    auto detector = wechat_qrcode::WeChatQRCode(path_detect_prototxt, path_detect_caffemodel, path_sr_prototxt,
+                                                path_sr_caffemodel);
+
+    const cv::String expect_msg = "OpenCV";
+    QRCodeEncoder::Params params;
+    params.version = 4; // 33x33
+    Ptr<QRCodeEncoder> qrcode_enc = cv::QRCodeEncoder::create(params);
+    Mat qrImage;
+    qrcode_enc->encode(expect_msg, qrImage);
+    Mat largeImage(4032, 3024, CV_8UC1);
+    const int pixInBlob = 4;
+    Size qrSize = Size((21+(params.version-1)*4)*pixInBlob,(21+(params.version-1)*4)*pixInBlob);
+    Mat roiImage = largeImage(Rect((largeImage.cols - qrSize.width)/2, (largeImage.rows - qrSize.height)/2,
+                                   qrSize.width, qrSize.height));
+    cv::resize(qrImage, roiImage, qrSize, 1., 1., INTER_NEAREST);
+
+    vector<Mat> points;
+    detector.setScaleFactor(0.25f);
+    auto decoded_info = detector.detectAndDecode(largeImage, points);
+    ASSERT_EQ(1ull, decoded_info.size());
+    ASSERT_EQ(expect_msg, decoded_info[0]);
+}
+
+TEST(Objdetect_QRCode_Tiny, regression) {
+    string path_detect_prototxt, path_detect_caffemodel, path_sr_prototxt, path_sr_caffemodel;
+    string model_version = "_2021-01";
+    path_detect_prototxt = findDataFile("dnn/wechat"+model_version+"/detect.prototxt", false);
+    path_detect_caffemodel = findDataFile("dnn/wechat"+model_version+"/detect.caffemodel", false);
+    path_sr_prototxt = findDataFile("dnn/wechat"+model_version+"/sr.prototxt", false);
+    path_sr_caffemodel = findDataFile("dnn/wechat"+model_version+"/sr.caffemodel", false);
+
+    auto detector = wechat_qrcode::WeChatQRCode(path_detect_prototxt, path_detect_caffemodel, path_sr_prototxt,
+                                                path_sr_caffemodel);
+
+    const cv::String expect_msg = "OpenCV";
+    QRCodeEncoder::Params params;
+    params.version = 4; // 33x33
+    Ptr<QRCodeEncoder> qrcode_enc = cv::QRCodeEncoder::create(params);
+    Mat qrImage;
+    qrcode_enc->encode(expect_msg, qrImage);
+    Mat tinyImage(80, 80, CV_8UC1);
+    const int pixInBlob = 2;
+    Size qrSize = Size((21+(params.version-1)*4)*pixInBlob,(21+(params.version-1)*4)*pixInBlob);
+    Mat roiImage = tinyImage(Rect((tinyImage.cols - qrSize.width)/2, (tinyImage.rows - qrSize.height)/2,
+                                   qrSize.width, qrSize.height));
+    cv::resize(qrImage, roiImage, qrSize, 1., 1., INTER_NEAREST);
+
+    vector<Mat> points;
+    auto decoded_info = detector.detectAndDecode(tinyImage, points);
+    ASSERT_EQ(1ull, decoded_info.size());
+    ASSERT_EQ(expect_msg, decoded_info[0]);
+}
+
+
+typedef testing::TestWithParam<std::string> Objdetect_QRCode_Easy_Multi;
+TEST_P(Objdetect_QRCode_Easy_Multi, regression) {
+    string path_detect_prototxt, path_detect_caffemodel, path_sr_prototxt, path_sr_caffemodel;
+    string model_path = GetParam();
+
+    if (!model_path.empty()) {
+        path_detect_prototxt = findDataFile(model_path + "/detect.prototxt", false);
+        path_detect_caffemodel = findDataFile(model_path + "/detect.caffemodel", false);
+        path_sr_prototxt = findDataFile(model_path + "/sr.prototxt", false);
+        path_sr_caffemodel = findDataFile(model_path + "/sr.caffemodel", false);
+    }
+
+    auto detector = wechat_qrcode::WeChatQRCode(path_detect_prototxt, path_detect_caffemodel, path_sr_prototxt,
+                                                path_sr_caffemodel);
+
+    const cv::String expect_msg1 = "OpenCV1", expect_msg2 = "OpenCV2";
+    QRCodeEncoder::Params params;
+    params.version = 4; // 33x33
+    Ptr<QRCodeEncoder> qrcode_enc = cv::QRCodeEncoder::create(params);
+    Mat qrImage1, qrImage2;
+    qrcode_enc->encode(expect_msg1, qrImage1);
+    qrcode_enc->encode(expect_msg2, qrImage2);
+    const int pixInBlob = 2;
+    const int offset = 14;
+    const int qr_size = (params.version - 1) * 4 + 21;
+    Mat tinyImage = Mat::zeros(qr_size*pixInBlob+offset, (qr_size*pixInBlob+offset)*2, CV_8UC1);
+    Size qrSize = Size(qrImage1.cols, qrImage1.rows);
+
+    Mat roiImage = tinyImage(Rect((tinyImage.cols/2 - qrSize.width)/2, (tinyImage.rows - qrSize.height)/2,
+                                   qrSize.width, qrSize.height));
+    cv::resize(qrImage1, roiImage, qrSize, 1., 1., INTER_NEAREST);
+
+    roiImage = tinyImage(Rect((tinyImage.cols/2 - qrSize.width)/2+tinyImage.cols/2, (tinyImage.rows - qrSize.height)/2,
+                                   qrSize.width, qrSize.height));
+    cv::resize(qrImage2, roiImage, qrSize, 1., 1., INTER_NEAREST);
+
+    vector<Mat> points;
+    auto decoded_info = detector.detectAndDecode(tinyImage, points);
+    ASSERT_EQ(2ull, decoded_info.size());
+    ASSERT_TRUE((expect_msg1 == decoded_info[0] && expect_msg2 == decoded_info[1]) ||
+                (expect_msg1 == decoded_info[1] && expect_msg2 == decoded_info[0]));
+}
+
+std::string qrcode_model_path[] = {"", "dnn/wechat_2021-01"};
+INSTANTIATE_TEST_CASE_P(/**/, Objdetect_QRCode_Easy_Multi, testing::ValuesIn(qrcode_model_path));
+
+}  // namespace
+}  // namespace opencv_test
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/CMakeLists.txt b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/CMakeLists.txt
new file mode 100644
index 00000000..f30d2ed8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/CMakeLists.txt
@@ -0,0 +1,38 @@
+set(the_description "Contributed/Experimental Algorithms for Salient 2D Features Detection")
+
+if(HAVE_CUDA)
+  ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef)
+endif()
+ocv_define_module(xfeatures2d opencv_core opencv_imgproc opencv_features2d opencv_calib3d OPTIONAL opencv_shape opencv_ml opencv_cudaarithm WRAP python java objc)
+
+if(NOT OPENCV_SKIP_FEATURES2D_DOWNLOADING)
+  include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/download_vgg.cmake)
+  include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/download_boostdesc.cmake)
+  set(DOWNLOAD_DIR "${OpenCV_BINARY_DIR}/downloads/xfeatures2d")
+  download_boost_descriptors("${DOWNLOAD_DIR}" boost_status)
+  download_vgg_descriptors("${DOWNLOAD_DIR}" vgg_status)
+  if(boost_status)
+    ocv_append_source_file_compile_definitions(${CMAKE_CURRENT_SOURCE_DIR}/src/boostdesc.cpp "OPENCV_XFEATURES2D_HAS_BOOST_DATA=1")
+  else()
+    message(WARNING "features2d: Boost descriptor implementation is not available due to missing data (download failed: https://github.com/opencv/opencv_contrib/issues/1301)")
+  endif()
+  if(vgg_status)
+    ocv_append_source_file_compile_definitions(${CMAKE_CURRENT_SOURCE_DIR}/src/vgg.cpp "OPENCV_XFEATURES2D_HAS_VGG_DATA=1")
+  else()
+    message(WARNING "features2d: VGG descriptor implementation is not available due to missing data (download failed: https://github.com/opencv/opencv_contrib/issues/1301)")
+  endif()
+
+  if(boost_status OR vgg_status)
+    ocv_module_include_directories("${DOWNLOAD_DIR}")
+  endif()
+endif()
+
+if(TARGET opencv_test_${name})
+  ocv_target_include_directories(opencv_test_${name} "${OpenCV_SOURCE_DIR}/modules")  # use common files from features2d tests
+  if(boost_status)
+    ocv_target_compile_definitions(opencv_test_${name} PRIVATE "OPENCV_XFEATURES2D_HAS_BOOST_DATA=1")
+  endif()
+  if(vgg_status)
+    ocv_target_compile_definitions(opencv_test_${name} PRIVATE "OPENCV_XFEATURES2D_HAS_VGG_DATA=1")
+  endif()
+endif()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/README.md b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/README.md
new file mode 100644
index 00000000..29214fd6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/README.md
@@ -0,0 +1,8 @@
+Extra 2D Features Framework
+===========================
+
+1. Experimental 2D feature algorithms
+2. Non-free 2D feature algorithms
+
+Extra 2D Features Framework containing experimental and non-free 2D feature detector/descriptor algorithms:
+ SURF, BRIEF, Censure, Freak, LUCID, Daisy, BEBLID, TEBLID, Self-similar.
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/cmake/download_boostdesc.cmake b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/cmake/download_boostdesc.cmake
new file mode 100644
index 00000000..87bedf98
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/cmake/download_boostdesc.cmake
@@ -0,0 +1,36 @@
+function(download_boost_descriptors dst_dir status_var)
+  set(OPENCV_3RDPARTY_COMMIT "34e4206aef44d50e6bbcd0ab06354b52e7466d26")
+
+  set(ids BGM BGM_BI BGM_HD BINBOOST_064 BINBOOST_128 BINBOOST_256 LBGM)
+  set(name_BGM boostdesc_bgm.i)
+  set(name_BGM_BI boostdesc_bgm_bi.i)
+  set(name_BGM_HD boostdesc_bgm_hd.i)
+  set(name_BINBOOST_064 boostdesc_binboost_064.i)
+  set(name_BINBOOST_128 boostdesc_binboost_128.i)
+  set(name_BINBOOST_256 boostdesc_binboost_256.i)
+  set(name_LBGM boostdesc_lbgm.i)
+  set(hash_BGM "0ea90e7a8f3f7876d450e4149c97c74f")
+  set(hash_BGM_BI "232c966b13651bd0e46a1497b0852191")
+  set(hash_BGM_HD "324426a24fa56ad9c5b8e3e0b3e5303e")
+  set(hash_BINBOOST_064 "202e1b3e9fec871b04da31f7f016679f")
+  set(hash_BINBOOST_128 "98ea99d399965c03d555cef3ea502a0b")
+  set(hash_BINBOOST_256 "e6dcfa9f647779eb1ce446a8d759b6ea")
+  set(hash_LBGM "0ae0675534aa318d9668f2a179c2a052")
+
+  set(${status_var} TRUE PARENT_SCOPE)
+  foreach(id ${ids})
+    ocv_download(FILENAME ${name_${id}}
+                 HASH ${hash_${id}}
+                 URL
+                   "${OPENCV_BOOSTDESC_URL}"
+                   "$ENV{OPENCV_BOOSTDESC_URL}"
+                   "https://raw.githubusercontent.com/opencv/opencv_3rdparty/${OPENCV_3RDPARTY_COMMIT}/"
+                 DESTINATION_DIR ${dst_dir}
+                 ID "xfeatures2d/boostdesc"
+                 RELATIVE_URL
+                 STATUS res)
+    if(NOT res)
+      set(${status_var} FALSE PARENT_SCOPE)
+    endif()
+  endforeach()
+endfunction()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/cmake/download_vgg.cmake b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/cmake/download_vgg.cmake
new file mode 100644
index 00000000..67e1f8f0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/cmake/download_vgg.cmake
@@ -0,0 +1,30 @@
+function(download_vgg_descriptors dst_dir status_var)
+  set(OPENCV_3RDPARTY_COMMIT "fccf7cd6a4b12079f73bbfb21745f9babcd4eb1d")
+
+  set(ids VGG_48 VGG_64 VGG_80 VGG_120)
+  set(name_VGG_48 "vgg_generated_48.i")
+  set(name_VGG_64 "vgg_generated_64.i")
+  set(name_VGG_80 "vgg_generated_80.i")
+  set(name_VGG_120 "vgg_generated_120.i")
+  set(hash_VGG_48 "e8d0dcd54d1bcfdc29203d011a797179")
+  set(hash_VGG_64 "7126a5d9a8884ebca5aea5d63d677225")
+  set(hash_VGG_80 "7cd47228edec52b6d82f46511af325c5")
+  set(hash_VGG_120 "151805e03568c9f490a5e3a872777b75")
+
+  set(${status_var} TRUE PARENT_SCOPE)
+  foreach(id ${ids})
+    ocv_download(FILENAME ${name_${id}}
+                 HASH ${hash_${id}}
+                 URL
+                   "${OPENCV_VGGDESC_URL}"
+                   "$ENV{OPENCV_VGGDESC_URL}"
+                   "https://raw.githubusercontent.com/opencv/opencv_3rdparty/${OPENCV_3RDPARTY_COMMIT}/"
+                 DESTINATION_DIR "${dst_dir}"
+                 ID "xfeatures2d/vgg"
+                 RELATIVE_URL
+                 STATUS res)
+    if(NOT res)
+      set(${status_var} FALSE PARENT_SCOPE)
+    endif()
+  endforeach()
+endfunction()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/doc/xfeatures2d.bib b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/doc/xfeatures2d.bib
new file mode 100644
index 00000000..7d3f146c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/doc/xfeatures2d.bib
@@ -0,0 +1,175 @@
+@incollection{Agrawal08,
+  title = {Censure: Center surround extremas for realtime feature detection and matching},
+  author = {Agrawal, Motilal and Konolige, Kurt and Blas, Morten Rufus},
+  booktitle = {Computer Vision--ECCV 2008},
+  pages = {102--115},
+  year = {2008},
+  publisher = {Springer}
+}
+
+@inproceedings{AOV12,
+  title = {Freak: Fast retina keypoint},
+  author = {Alahi, Alexandre and Ortiz, Raphael and Vandergheynst, Pierre},
+  booktitle = {Computer Vision and Pattern Recognition (CVPR), 2012 IEEE Conference on},
+  pages = {510--517},
+  year = {2012},
+  organization = {IEEE}
+}
+
+@article{Bay06,
+  title = {Surf: Speeded up robust features},
+  author = {Bay, Herbert and Tuytelaars, Tinne and Van Gool, Luc},
+  journal = {Computer Vision--ECCV 2006},
+  pages = {404--417},
+  year = {2006},
+  publisher = {Springer Berlin Heidelberg}
+}
+
+@inproceedings{BeecksUS10,
+  author = {Christian Beecks and Merih Seran Uysal and Thomas Seidl},
+  title = {Signature Quadratic Form Distance},
+  booktitle = {CIVR},
+  pages = {438--445},
+  publisher = {ACM},
+  year = {2010}
+}
+
+@inproceedings{Bian2017gms,
+  title = {GMS: Grid-based Motion Statistics for Fast, Ultra-robust Feature Correspondence},
+  author = {JiaWang Bian and Wen-Yan Lin and Yasuyuki Matsushita and Sai-Kit Yeung and Tan Dat Nguyen and Ming-Ming Cheng},
+  booktitle = {IEEE Conference on Computer Vision and Pattern Recognition},
+  year = {2017}
+}
+
+@incollection{calon2010,
+  title = {Brief: Binary robust independent elementary features},
+  author = {Calonder, Michael and Lepetit, Vincent and Strecha, Christoph and Fua, Pascal},
+  booktitle = {Computer Vision--ECCV 2010},
+  pages = {778--792},
+  year = {2010},
+  publisher = {Springer}
+}
+
+@article{KrulisLS16,
+  author = {Martin Krulis and Jakub Lokoc and Tomas Skopal},
+  title = {Efficient extraction of clustering-based feature signatures using {GPU} architectures},
+  journal = {Multimedia Tools Appl.},
+  volume = {75},
+  number = {13},
+  pages = {8071--8103},
+  year = {2016}
+}
+
+@article{Lowry2018LOGOSLG,
+  title = {LOGOS: Local Geometric Support for High-Outlier Spatial Verification},
+  author = {Stephanie Lowry and Henrik Andreasson},
+  journal = {2018 IEEE International Conference on Robotics and Automation (ICRA)},
+  year = {2018},
+  pages = {7262-7269},
+  doi = {10.1109/ICRA.2018.8460988},
+}
+
+@article{Mikolajczyk2004,
+  title = {Scale \& affine invariant interest point detectors},
+  author = {Mikolajczyk, Krystian and Schmid, Cordelia},
+  journal = {International journal of computer vision},
+  volume = {60},
+  number = {1},
+  pages = {63--86},
+  year = {2004},
+  publisher = {Springer}
+}
+
+@ARTICLE{Najman2014,
+  author={Y. {Xu} and P. {Monasse} and T. {Géraud} and L. {Najman}},
+  journal={IEEE Transactions on Image Processing},
+  title={Tree-Based Morse Regions: A Topological Approach to Local Feature Detection},
+  year={2014},
+  volume={23},
+  number={12},
+  pages={5612-5625},
+  abstract={This paper introduces a topological approach to local invariant feature detection motivated by Morse theory. We use the critical points of the graph of the intensity image, revealing directly the topology information as initial interest points. Critical points are selected from what we call a tree-based shape-space. In particular, they are selected from both the connected components of the upper level sets of the image (the Max-tree) and those of the lower level sets (the Min-tree). They correspond to specific nodes on those two trees: 1) to the leaves (extrema) and 2) to the nodes having bifurcation (saddle points). We then associate to each critical point the largest region that contains it and is topologically equivalent in its tree. We call such largest regions the tree-based Morse regions (TBMRs). The TBMR can be seen as a variant of maximally stable extremal region (MSER), which are contrasted regions. Contrarily to MSER, TBMR relies only on topological information and thus fully inherit the invariance properties of the space of shapes (e.g., invariance to affine contrast changes and covariance to continuous transformations). In particular, TBMR extracts the regions independently of the contrast, which makes it truly contrast invariant. Furthermore, it is quasi-parameter free. TBMR extraction is fast, having the same complexity as MSER. Experimentally, TBMR achieves a repeatability on par with state-of-the-art methods, but obtains a significantly higher number of features. Both the accuracy and robustness of TBMR are demonstrated by applications to image registration and 3D reconstruction.},
+  keywords={feature extraction;image reconstruction;image registration;trees (mathematics);tree-based Morse regions;topological approach;local invariant feature detection;Morse theory;intensity image;initial interest points;critical points;tree-based shape-space;upper level image sets;Max-tree;lower level sets;Min-tree;saddle points;bifurcation;maximally stable extremal region variant;MSER;topological information;TBMR extraction;3D reconstruction;image registration;Feature extraction;Detectors;Shape;Time complexity;Level set;Three-dimensional displays;Image registration;Min/Max tree;local features;affine region detectors;image registration;3D reconstruction;Min/Max tree;local features;affine region detectors;image registration;3D reconstruction},
+  doi={10.1109/TIP.2014.2364127},
+  ISSN={1941-0042},
+  month={Dec},}
+
+@article{Simonyan14,
+  author = {Simonyan, K. and Vedaldi, A. and Zisserman, A.},
+  title = {Learning Local Feature Descriptors Using Convex Optimisation},
+  journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence},
+  year = {2014}
+}
+
+@article{Tola10,
+  author = {E. Tola and V. Lepetit and P. Fua},
+  title = {DAISY: An Efficient Dense Descriptor Applied to Wide Baseline Stereo},
+  journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence},
+  year = {2010},
+  month = {May},
+  pages = {815--830},
+  volume = {32},
+  number = {5}
+}
+
+@inproceedings{Tombari14,
+  title = {Interest Points via Maximal Self-Dissimilarities},
+  author = {Tombari, Federico and Di Stefano, Luigi},
+  booktitle = {Asian Conference on Computer Vision -- ACCV 2014},
+  year = {2014}
+}
+
+@inproceedings{Trzcinski13a,
+  author = {T. Trzcinski, M. Christoudias, V. Lepetit and P. Fua},
+  title = {Boosting Binary Keypoint Descriptors},
+  booktitle = {Computer Vision and Pattern Recognition},
+  year = {2013}
+}
+
+@article{Trzcinski13b,
+  author = {T. Trzcinski, M. Christoudias and V. Lepetit},
+  title = {Learning Image Descriptors with Boosting},
+  journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI)},
+  year = {2013}
+}
+
+@incollection{LUCID,
+  title = {Locally uniform comparison image descriptor},
+  author = {Ziegler, Andrew, Eric Christiansen, David Kriegman, and Serge J. Belongie}
+  booktitle = {Advances in Neural Information Processing Systems}
+  pages = {1--9}
+  year = {2012}
+  publisher = {NIPS}
+}
+
+@article{Suarez2020BEBLID,
+  title = {{BEBLID: Boosted Efficient Binary Local Image Descriptor}},
+  journal = {Pattern Recognition Letters},
+  volume = {133},
+  pages = {366--372},
+  year = {2020},
+  issn = {0167-8655},
+  doi = {https://doi.org/10.1016/j.patrec.2020.04.005},
+  url = {https://raw.githubusercontent.com/iago-suarez/BEBLID/master/BEBLID_Boosted_Efficient_Binary_Local_Image_Descriptor.pdf},
+  author = {Iago Su\'arez and Ghesn Sfeir and Jos\'e M. Buenaposada and Luis Baumela},
+}
+
+@article{Suarez2021TEBLID,
+  title = {Revisiting Binary Local Image Description for Resource Limited Devices},
+  journal = {IEEE Robotics and Automation Letters},
+  volume = {6},
+  pages = {8317--8324},
+  year = {2021},
+  number = {4},
+  doi = {https://doi.org/10.1109/LRA.2021.3107024},
+  url = {https://arxiv.org/pdf/2108.08380.pdf},
+  author = {Iago Su\'arez and Jos\'e M. Buenaposada and Luis Baumela},
+}
+
+@inproceedings{winder2007learning,
+  title= {Learning Local Image Descriptors},
+  author= {Winder, Simon AJ and Brown, Matthew},
+  booktitle= {Computer Vision and Pattern Recognition},
+  pages={1--8},
+  year={2007},
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/include/opencv2/xfeatures2d.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/include/opencv2/xfeatures2d.hpp
new file mode 100644
index 00000000..cf0980dd
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/include/opencv2/xfeatures2d.hpp
@@ -0,0 +1,1279 @@
+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#ifndef __OPENCV_XFEATURES2D_HPP__
+#define __OPENCV_XFEATURES2D_HPP__
+
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d/nonfree.hpp"
+
+/** @defgroup xfeatures2d Extra 2D Features Framework
+@{
+    @defgroup xfeatures2d_experiment Experimental 2D Features Algorithms
+
+This section describes experimental algorithms for 2d feature detection.
+
+    @defgroup xfeatures2d_nonfree Non-free 2D Features Algorithms
+
+This section describes two popular algorithms for 2d feature detection, SIFT and SURF, that are
+known to be patented. You need to set the OPENCV_ENABLE_NONFREE option in cmake to use those. Use them at your own risk.
+
+    @defgroup xfeatures2d_match Experimental 2D Features Matching Algorithm
+
+This section describes the following matching strategies:
+    - GMS: Grid-based Motion Statistics, @cite Bian2017gms
+    - LOGOS: Local geometric support for high-outlier spatial verification, @cite Lowry2018LOGOSLG
+
+@}
+*/
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+//! @addtogroup xfeatures2d_experiment
+//! @{
+
+/** @brief Class implementing the FREAK (*Fast Retina Keypoint*) keypoint descriptor, described in @cite AOV12 .
+
+The algorithm propose a novel keypoint descriptor inspired by the human visual system and more
+precisely the retina, coined Fast Retina Key- point (FREAK). A cascade of binary strings is
+computed by efficiently comparing image intensities over a retinal sampling pattern. FREAKs are in
+general faster to compute with lower memory load and also more robust than SIFT, SURF or BRISK.
+They are competitive alternatives to existing keypoints in particular for embedded applications.
+
+@note
+   -   An example on how to use the FREAK descriptor can be found at
+        opencv_source_code/samples/cpp/freak_demo.cpp
+ */
+class CV_EXPORTS_W FREAK : public Feature2D
+{
+public:
+
+    static const int    NB_SCALES        = 64;
+    static const int    NB_PAIRS         = 512;
+    static const int    NB_ORIENPAIRS    = 45;
+
+    /**
+    @param orientationNormalized Enable orientation normalization.
+    @param scaleNormalized Enable scale normalization.
+    @param patternScale Scaling of the description pattern.
+    @param nOctaves Number of octaves covered by the detected keypoints.
+    @param selectedPairs (Optional) user defined selected pairs indexes,
+     */
+    CV_WRAP static Ptr<FREAK> create(bool orientationNormalized = true,
+                             bool scaleNormalized = true,
+                             float patternScale = 22.0f,
+                             int nOctaves = 4,
+                             const std::vector<int>& selectedPairs = std::vector<int>());
+
+    CV_WRAP virtual void setOrientationNormalized(bool orientationNormalized) = 0;
+    CV_WRAP virtual bool getOrientationNormalized() const = 0;
+
+    CV_WRAP virtual void setScaleNormalized(bool scaleNormalized) = 0;
+    CV_WRAP virtual bool getScaleNormalized() const = 0;
+
+    CV_WRAP virtual void setPatternScale(double patternScale) = 0;
+    CV_WRAP virtual double getPatternScale() const = 0;
+
+    CV_WRAP virtual void setNOctaves(int nOctaves) = 0;
+    CV_WRAP virtual int getNOctaves() const = 0;
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+};
+
+
+/** @brief The class implements the keypoint detector introduced by @cite Agrawal08, synonym of StarDetector. :
+ */
+class CV_EXPORTS_W StarDetector : public Feature2D
+{
+public:
+    //! the full constructor
+    CV_WRAP static Ptr<StarDetector> create(int maxSize=45, int responseThreshold=30,
+                         int lineThresholdProjected=10,
+                         int lineThresholdBinarized=8,
+                         int suppressNonmaxSize=5);
+
+    CV_WRAP virtual void setMaxSize(int _maxSize) = 0;
+    CV_WRAP virtual int getMaxSize() const = 0;
+
+    CV_WRAP virtual void setResponseThreshold(int _responseThreshold) = 0;
+    CV_WRAP virtual int getResponseThreshold() const = 0;
+
+    CV_WRAP virtual void setLineThresholdProjected(int _lineThresholdProjected) = 0;
+    CV_WRAP virtual int getLineThresholdProjected() const = 0;
+
+    CV_WRAP virtual void setLineThresholdBinarized(int _lineThresholdBinarized) = 0;
+    CV_WRAP virtual int getLineThresholdBinarized() const = 0;
+
+    CV_WRAP virtual void setSuppressNonmaxSize(int _suppressNonmaxSize) = 0;
+    CV_WRAP virtual int getSuppressNonmaxSize() const = 0;
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+};
+
+/*
+ * BRIEF Descriptor
+ */
+
+/** @brief Class for computing BRIEF descriptors described in @cite calon2010 .
+
+@param bytes legth of the descriptor in bytes, valid values are: 16, 32 (default) or 64 .
+@param use_orientation sample patterns using keypoints orientation, disabled by default.
+
+ */
+class CV_EXPORTS_W BriefDescriptorExtractor : public Feature2D
+{
+public:
+    CV_WRAP static Ptr<BriefDescriptorExtractor> create( int bytes = 32, bool use_orientation = false );
+
+    CV_WRAP virtual void setDescriptorSize(int bytes) = 0;
+    CV_WRAP virtual int getDescriptorSize() const = 0;
+
+    CV_WRAP virtual void setUseOrientation(bool use_orientation) = 0;
+    CV_WRAP virtual bool getUseOrientation() const = 0;
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+};
+
+/** @brief Class implementing the locally uniform comparison image descriptor, described in @cite LUCID
+
+An image descriptor that can be computed very fast, while being
+about as robust as, for example, SURF or BRIEF.
+
+@note It requires a color image as input.
+ */
+class CV_EXPORTS_W LUCID : public Feature2D
+{
+public:
+    /**
+     * @param lucid_kernel kernel for descriptor construction, where 1=3x3, 2=5x5, 3=7x7 and so forth
+     * @param blur_kernel kernel for blurring image prior to descriptor construction, where 1=3x3, 2=5x5, 3=7x7 and so forth
+     */
+    CV_WRAP static Ptr<LUCID> create(const int lucid_kernel = 1, const int blur_kernel = 2);
+
+    CV_WRAP virtual void setLucidKernel(int lucid_kernel) = 0;
+    CV_WRAP virtual int getLucidKernel() const = 0;
+
+    CV_WRAP virtual void setBlurKernel(int blur_kernel) = 0;
+    CV_WRAP virtual int getBlurKernel() const = 0;
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+};
+
+
+/*
+* LATCH Descriptor
+*/
+
+/** latch Class for computing the LATCH descriptor.
+If you find this code useful, please add a reference to the following paper in your work:
+Gil Levi and Tal Hassner, "LATCH: Learned Arrangements of Three Patch Codes", arXiv preprint arXiv:1501.03719, 15 Jan. 2015
+
+LATCH is a binary descriptor based on learned comparisons of triplets of image patches.
+
+* bytes is the size of the descriptor - can be 64, 32, 16, 8, 4, 2 or 1
+* rotationInvariance - whether or not the descriptor should compansate for orientation changes.
+* half_ssd_size - the size of half of the mini-patches size. For example, if we would like to compare triplets of patches of size 7x7x
+    then the half_ssd_size should be (7-1)/2 = 3.
+* sigma - sigma value for GaussianBlur smoothing of the source image. Source image will be used without smoothing in case sigma value is 0.
+
+Note: the descriptor can be coupled with any keypoint extractor. The only demand is that if you use set rotationInvariance = True then
+    you will have to use an extractor which estimates the patch orientation (in degrees). Examples for such extractors are ORB and SIFT.
+
+Note: a complete example can be found under /samples/cpp/tutorial_code/xfeatures2D/latch_match.cpp
+
+*/
+class CV_EXPORTS_W LATCH : public Feature2D
+{
+public:
+    CV_WRAP static Ptr<LATCH> create(int bytes = 32, bool rotationInvariance = true, int half_ssd_size = 3, double sigma = 2.0);
+
+    CV_WRAP virtual void setBytes(int bytes) = 0;
+    CV_WRAP virtual int getBytes() const = 0;
+
+    CV_WRAP virtual void setRotationInvariance(bool rotationInvariance) = 0;
+    CV_WRAP virtual bool getRotationInvariance() const = 0;
+
+    CV_WRAP virtual void setHalfSSDsize(int half_ssd_size) = 0;
+    CV_WRAP virtual int getHalfSSDsize() const = 0;
+
+    CV_WRAP virtual void setSigma(double sigma) = 0;
+    CV_WRAP virtual double getSigma() const = 0;
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+};
+
+/** @brief Class implementing BEBLID (Boosted Efficient Binary Local Image Descriptor),
+ * described in @cite Suarez2020BEBLID .
+
+BEBLID \cite Suarez2020BEBLID is a efficient binary descriptor learned with boosting.
+It is able to describe keypoints from any detector just by changing the scale_factor parameter.
+In several benchmarks it has proved to largely improve other binary descriptors like ORB or
+BRISK with the same efficiency. BEBLID describes using the difference of mean gray values in
+different regions of the image around the KeyPoint, the descriptor is specifically optimized for
+image matching and patch retrieval addressing the asymmetries of these problems.
+
+If you find this code useful, please add a reference to the following paper:
+<BLOCKQUOTE> Iago Suárez, Ghesn Sfeir, José M. Buenaposada, and Luis Baumela.
+BEBLID: Boosted efficient binary local image descriptor.
+Pattern Recognition Letters, 133:366–372, 2020. </BLOCKQUOTE>
+
+The descriptor was trained using 1 million of randomly sampled pairs of patches
+(20% positives and 80% negatives) from the Liberty split of the UBC datasets
+\cite winder2007learning as described in the paper @cite Suarez2020BEBLID.
+You can check in the [AKAZE example](https://raw.githubusercontent.com/opencv/opencv/master/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp)
+how well BEBLID works. Detecting 10000 keypoints with ORB and describing with BEBLID obtains
+561 inliers (75%) whereas describing with ORB obtains only 493 inliers (63%).
+*/
+class CV_EXPORTS_W BEBLID : public Feature2D
+{
+public:
+    /**
+     * @brief  Descriptor number of bits, each bit is a boosting weak-learner.
+     * The user can choose between 512 or 256 bits.
+     */
+    enum BeblidSize
+    {
+        SIZE_512_BITS = 100, SIZE_256_BITS = 101,
+    };
+    /** @brief Creates the BEBLID descriptor.
+    @param scale_factor Adjust the sampling window around detected keypoints:
+    - <b> 1.00f </b> should be the scale for ORB keypoints
+    - <b> 6.75f </b> should be the scale for SIFT detected keypoints
+    - <b> 6.25f </b> is default and fits for KAZE, SURF detected keypoints
+    - <b> 5.00f </b> should be the scale for AKAZE, MSD, AGAST, FAST, BRISK keypoints
+    @param n_bits Determine the number of bits in the descriptor. Should be either
+     BEBLID::SIZE_512_BITS or BEBLID::SIZE_256_BITS.
+    */
+    CV_WRAP static Ptr<BEBLID> create(float scale_factor, int n_bits = BEBLID::SIZE_512_BITS);
+
+    CV_WRAP virtual void setScaleFactor(float scale_factor) = 0;
+    CV_WRAP virtual float getScaleFactor() const = 0;
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+};
+
+/** @brief Class implementing TEBLID (Triplet-based Efficient Binary Local Image Descriptor),
+ * described in @cite Suarez2021TEBLID.
+
+TEBLID stands for Triplet-based Efficient Binary Local Image Descriptor, although originally it was called BAD
+\cite Suarez2021TEBLID. It is an improvement over BEBLID \cite Suarez2020BEBLID, that uses triplet loss,
+hard negative mining, and anchor swap to improve the image matching results.
+It is able to describe keypoints from any detector just by changing the scale_factor parameter.
+TEBLID is as efficient as ORB, BEBLID or BRISK, but the triplet-based training objective selected more
+discriminative features that explain the accuracy gain. It is also more compact than BEBLID,
+when running the [AKAZE example](https://github.com/opencv/opencv/blob/4.x/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp)
+with 10000 keypoints detected by ORB, BEBLID obtains 561 inliers (75%) with 512 bits, whereas
+TEBLID obtains 621 (75.2%) with 256 bits. ORB obtains only 493 inliers (63%).
+
+If you find this code useful, please add a reference to the following paper:
+<BLOCKQUOTE> Iago Suárez, José M. Buenaposada, and Luis Baumela.
+Revisiting Binary Local Image Description for Resource Limited Devices.
+IEEE Robotics and Automation Letters, vol. 6, no. 4, pp. 8317-8324, Oct. 2021. </BLOCKQUOTE>
+
+The descriptor was trained in Liberty split of the UBC datasets \cite winder2007learning .
+*/
+class CV_EXPORTS_W TEBLID : public Feature2D
+{
+public:
+    /**
+     * @brief  Descriptor number of bits, each bit is a box average difference.
+     * The user can choose between 256 or 512 bits.
+     */
+    enum TeblidSize
+    {
+        SIZE_256_BITS = 102, SIZE_512_BITS = 103,
+    };
+    /** @brief Creates the TEBLID descriptor.
+    @param scale_factor Adjust the sampling window around detected keypoints:
+    - <b> 1.00f </b> should be the scale for ORB keypoints
+    - <b> 6.75f </b> should be the scale for SIFT detected keypoints
+    - <b> 6.25f </b> is default and fits for KAZE, SURF detected keypoints
+    - <b> 5.00f </b> should be the scale for AKAZE, MSD, AGAST, FAST, BRISK keypoints
+    @param n_bits Determine the number of bits in the descriptor. Should be either
+     TEBLID::SIZE_256_BITS or TEBLID::SIZE_512_BITS.
+    */
+    CV_WRAP static Ptr<TEBLID> create(float scale_factor, int n_bits = TEBLID::SIZE_256_BITS);
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+};
+
+/** @brief Class implementing DAISY descriptor, described in @cite Tola10
+
+@param radius radius of the descriptor at the initial scale
+@param q_radius amount of radial range division quantity
+@param q_theta amount of angular range division quantity
+@param q_hist amount of gradient orientations range division quantity
+@param norm choose descriptors normalization type, where
+DAISY::NRM_NONE will not do any normalization (default),
+DAISY::NRM_PARTIAL mean that histograms are normalized independently for L2 norm equal to 1.0,
+DAISY::NRM_FULL mean that descriptors are normalized for L2 norm equal to 1.0,
+DAISY::NRM_SIFT mean that descriptors are normalized for L2 norm equal to 1.0 but no individual one is bigger than 0.154 as in SIFT
+@param H optional 3x3 homography matrix used to warp the grid of daisy but sampling keypoints remains unwarped on image
+@param interpolation switch to disable interpolation for speed improvement at minor quality loss
+@param use_orientation sample patterns using keypoints orientation, disabled by default.
+
+ */
+class CV_EXPORTS_W DAISY : public Feature2D
+{
+public:
+    enum NormalizationType
+    {
+        NRM_NONE = 100, NRM_PARTIAL = 101, NRM_FULL = 102, NRM_SIFT = 103,
+    };
+    CV_WRAP static Ptr<DAISY> create( float radius = 15, int q_radius = 3, int q_theta = 8,
+                int q_hist = 8, DAISY::NormalizationType norm = DAISY::NRM_NONE, InputArray H = noArray(),
+                bool interpolation = true, bool use_orientation = false );
+
+    CV_WRAP virtual void setRadius(float radius) = 0;
+    CV_WRAP virtual float getRadius() const = 0;
+
+    CV_WRAP virtual void setQRadius(int q_radius) = 0;
+    CV_WRAP virtual int getQRadius() const = 0;
+
+    CV_WRAP virtual void setQTheta(int q_theta) = 0;
+    CV_WRAP virtual int getQTheta() const = 0;
+
+    CV_WRAP virtual void setQHist(int q_hist) = 0;
+    CV_WRAP virtual int getQHist() const = 0;
+
+    CV_WRAP virtual void setNorm(int norm) = 0;
+    CV_WRAP virtual int getNorm() const = 0;
+
+    CV_WRAP virtual void setH(InputArray H) = 0;
+    CV_WRAP virtual cv::Mat getH() const = 0;
+
+    CV_WRAP virtual void setInterpolation(bool interpolation) = 0;
+    CV_WRAP virtual bool getInterpolation() const = 0;
+
+    CV_WRAP virtual void setUseOrientation(bool use_orientation) = 0;
+    CV_WRAP virtual bool getUseOrientation() const = 0;
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+
+    /** @overload
+     * @param image image to extract descriptors
+     * @param keypoints of interest within image
+     * @param descriptors resulted descriptors array
+     */
+    virtual void compute( InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors ) CV_OVERRIDE = 0;
+
+    virtual void compute( InputArrayOfArrays images,
+                          std::vector<std::vector<KeyPoint> >& keypoints,
+                          OutputArrayOfArrays descriptors ) CV_OVERRIDE;
+
+    /** @overload
+     * @param image image to extract descriptors
+     * @param roi region of interest within image
+     * @param descriptors resulted descriptors array for roi image pixels
+     */
+    virtual void compute( InputArray image, Rect roi, OutputArray descriptors ) = 0;
+
+    /**@overload
+     * @param image image to extract descriptors
+     * @param descriptors resulted descriptors array for all image pixels
+     */
+    virtual void compute( InputArray image, OutputArray descriptors ) = 0;
+
+    /**
+     * @param y position y on image
+     * @param x position x on image
+     * @param orientation orientation on image (0->360)
+     * @param descriptor supplied array for descriptor storage
+     */
+    virtual void GetDescriptor( double y, double x, int orientation, float* descriptor ) const = 0;
+
+    /**
+     * @param y position y on image
+     * @param x position x on image
+     * @param orientation orientation on image (0->360)
+     * @param descriptor supplied array for descriptor storage
+     * @param H homography matrix for warped grid
+     */
+    virtual bool GetDescriptor( double y, double x, int orientation, float* descriptor, double* H ) const = 0;
+
+    /**
+     * @param y position y on image
+     * @param x position x on image
+     * @param orientation orientation on image (0->360)
+     * @param descriptor supplied array for descriptor storage
+     */
+    virtual void GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor ) const = 0;
+
+    /**
+     * @param y position y on image
+     * @param x position x on image
+     * @param orientation orientation on image (0->360)
+     * @param descriptor supplied array for descriptor storage
+     * @param H homography matrix for warped grid
+     */
+    virtual bool GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor , double *H ) const = 0;
+
+};
+
+/** @brief Class implementing the MSD (*Maximal Self-Dissimilarity*) keypoint detector, described in @cite Tombari14.
+
+The algorithm implements a novel interest point detector stemming from the intuition that image patches
+which are highly dissimilar over a relatively large extent of their surroundings hold the property of
+being repeatable and distinctive. This concept of "contextual self-dissimilarity" reverses the key
+paradigm of recent successful techniques such as the Local Self-Similarity descriptor and the Non-Local
+Means filter, which build upon the presence of similar - rather than dissimilar - patches. Moreover,
+it extends to contextual information the local self-dissimilarity notion embedded in established
+detectors of corner-like interest points, thereby achieving enhanced repeatability, distinctiveness and
+localization accuracy.
+
+*/
+
+class CV_EXPORTS_W MSDDetector : public Feature2D {
+
+public:
+
+    CV_WRAP static Ptr<MSDDetector> create(int m_patch_radius = 3, int m_search_area_radius = 5,
+            int m_nms_radius = 5, int m_nms_scale_radius = 0, float m_th_saliency = 250.0f, int m_kNN = 4,
+            float m_scale_factor = 1.25f, int m_n_scales = -1, bool m_compute_orientation = false);
+
+    CV_WRAP virtual void setPatchRadius(int patch_radius) = 0;
+    CV_WRAP virtual int getPatchRadius() const = 0;
+
+    CV_WRAP virtual void setSearchAreaRadius(int use_orientation) = 0;
+    CV_WRAP virtual int getSearchAreaRadius() const = 0;
+
+    CV_WRAP virtual void setNmsRadius(int nms_radius) = 0;
+    CV_WRAP virtual int getNmsRadius() const = 0;
+
+    CV_WRAP virtual void setNmsScaleRadius(int nms_scale_radius) = 0;
+    CV_WRAP virtual int getNmsScaleRadius() const = 0;
+
+    CV_WRAP virtual void setThSaliency(float th_saliency) = 0;
+    CV_WRAP virtual float getThSaliency() const = 0;
+
+    CV_WRAP virtual void setKNN(int kNN) = 0;
+    CV_WRAP virtual int getKNN() const = 0;
+
+    CV_WRAP virtual void setScaleFactor(float scale_factor) = 0;
+    CV_WRAP virtual float getScaleFactor() const = 0;
+
+    CV_WRAP virtual void setNScales(int use_orientation) = 0;
+    CV_WRAP virtual int getNScales() const = 0;
+
+    CV_WRAP virtual void setComputeOrientation(bool compute_orientation) = 0;
+    CV_WRAP virtual bool getComputeOrientation() const = 0;
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+};
+
+/** @brief Class implementing VGG (Oxford Visual Geometry Group) descriptor trained end to end
+using "Descriptor Learning Using Convex Optimisation" (DLCO) aparatus described in @cite Simonyan14.
+
+@param desc type of descriptor to use, VGG::VGG_120 is default (120 dimensions float)
+Available types are VGG::VGG_120, VGG::VGG_80, VGG::VGG_64, VGG::VGG_48
+@param isigma gaussian kernel value for image blur (default is 1.4f)
+@param img_normalize use image sample intensity normalization (enabled by default)
+@param use_orientation sample patterns using keypoints orientation, enabled by default
+@param scale_factor adjust the sampling window of detected keypoints to 64.0f (VGG sampling window)
+6.25f is default and fits for KAZE, SURF detected keypoints window ratio
+6.75f should be the scale for SIFT detected keypoints window ratio
+5.00f should be the scale for AKAZE, MSD, AGAST, FAST, BRISK keypoints window ratio
+0.75f should be the scale for ORB keypoints ratio
+
+@param dsc_normalize clamp descriptors to 255 and convert to uchar CV_8UC1 (disabled by default)
+
+ */
+class CV_EXPORTS_W VGG : public Feature2D
+{
+public:
+
+    CV_WRAP enum
+    {
+        VGG_120 = 100, VGG_80 = 101, VGG_64 = 102, VGG_48 = 103,
+    };
+
+    CV_WRAP static Ptr<VGG> create( int desc = VGG::VGG_120, float isigma = 1.4f,
+                                    bool img_normalize = true, bool use_scale_orientation = true,
+                                    float scale_factor = 6.25f, bool dsc_normalize = false );
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+
+    CV_WRAP virtual void setSigma(const float isigma) = 0;
+    CV_WRAP virtual float getSigma() const = 0;
+
+    CV_WRAP virtual void setUseNormalizeImage(const bool img_normalize) = 0;
+    CV_WRAP virtual bool getUseNormalizeImage() const = 0;
+
+    CV_WRAP virtual void setUseScaleOrientation(const bool use_scale_orientation) = 0;
+    CV_WRAP virtual bool getUseScaleOrientation() const = 0;
+
+    CV_WRAP virtual void setScaleFactor(const float scale_factor) = 0;
+    CV_WRAP virtual float getScaleFactor() const = 0;
+
+    CV_WRAP virtual void setUseNormalizeDescriptor(const bool dsc_normalize) = 0;
+    CV_WRAP virtual bool getUseNormalizeDescriptor() const = 0;
+};
+
+/** @brief Class implementing BoostDesc (Learning Image Descriptors with Boosting), described in
+@cite Trzcinski13a and @cite Trzcinski13b.
+
+@param desc type of descriptor to use, BoostDesc::BINBOOST_256 is default (256 bit long dimension)
+Available types are: BoostDesc::BGM, BoostDesc::BGM_HARD, BoostDesc::BGM_BILINEAR, BoostDesc::LBGM,
+BoostDesc::BINBOOST_64, BoostDesc::BINBOOST_128, BoostDesc::BINBOOST_256
+@param use_orientation sample patterns using keypoints orientation, enabled by default
+@param scale_factor adjust the sampling window of detected keypoints
+6.25f is default and fits for KAZE, SURF detected keypoints window ratio
+6.75f should be the scale for SIFT detected keypoints window ratio
+5.00f should be the scale for AKAZE, MSD, AGAST, FAST, BRISK keypoints window ratio
+0.75f should be the scale for ORB keypoints ratio
+1.50f was the default in original implementation
+
+@note BGM is the base descriptor where each binary dimension is computed as the output of a single weak learner.
+BGM_HARD and BGM_BILINEAR refers to same BGM but use different type of gradient binning. In the BGM_HARD that
+use ASSIGN_HARD binning type the gradient is assigned to the nearest orientation bin. In the BGM_BILINEAR that use
+ASSIGN_BILINEAR binning type the gradient is assigned to the two neighbouring bins. In the BGM and all other modes that use
+ASSIGN_SOFT binning type the gradient is assigned to 8 nearest bins according to the cosine value between the gradient
+angle and the bin center. LBGM (alias FP-Boost) is the floating point extension where each dimension is computed
+as a linear combination of the weak learner responses. BINBOOST and subvariants are the binary extensions of LBGM
+where each bit is computed as a thresholded linear combination of a set of weak learners.
+BoostDesc header files (boostdesc_*.i) was exported from original binaries with export-boostdesc.py script from
+samples subfolder.
+
+*/
+
+class CV_EXPORTS_W BoostDesc : public Feature2D
+{
+public:
+
+    CV_WRAP enum
+    {
+       BGM = 100, BGM_HARD = 101, BGM_BILINEAR = 102, LBGM = 200,
+       BINBOOST_64 = 300, BINBOOST_128 = 301, BINBOOST_256 = 302
+    };
+
+    CV_WRAP static Ptr<BoostDesc> create( int desc = BoostDesc::BINBOOST_256,
+                    bool use_scale_orientation = true, float scale_factor = 6.25f );
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+
+    CV_WRAP virtual void setUseScaleOrientation(const bool use_scale_orientation) = 0;
+    CV_WRAP virtual bool getUseScaleOrientation() const = 0;
+
+    CV_WRAP virtual void setScaleFactor(const float scale_factor) = 0;
+    CV_WRAP virtual float getScaleFactor() const = 0;
+};
+
+
+/*
+* Position-Color-Texture signatures
+*/
+
+/**
+* @brief Class implementing PCT (position-color-texture) signature extraction
+*       as described in @cite KrulisLS16.
+*       The algorithm is divided to a feature sampler and a clusterizer.
+*       Feature sampler produces samples at given set of coordinates.
+*       Clusterizer then produces clusters of these samples using k-means algorithm.
+*       Resulting set of clusters is the signature of the input image.
+*
+*       A signature is an array of SIGNATURE_DIMENSION-dimensional points.
+*       Used dimensions are:
+*       weight, x, y position; lab color, contrast, entropy.
+* @cite KrulisLS16
+* @cite BeecksUS10
+*/
+class CV_EXPORTS_W PCTSignatures : public Algorithm
+{
+public:
+    /**
+    * @brief Lp distance function selector.
+    */
+    enum DistanceFunction
+    {
+        L0_25, L0_5, L1, L2, L2SQUARED, L5, L_INFINITY
+    };
+
+    /**
+    * @brief Point distributions supported by random point generator.
+    */
+    enum PointDistribution
+    {
+        UNIFORM,    //!< Generate numbers uniformly.
+        REGULAR,    //!< Generate points in a regular grid.
+        NORMAL      //!< Generate points with normal (gaussian) distribution.
+    };
+
+    /**
+    * @brief Similarity function selector.
+    * @see
+    *       Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    *       Signature quadratic form distance.
+    *       In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    *       ACM, 2010.
+    * @cite BeecksUS10
+    * @note For selected distance function: \f[ d(c_i, c_j) \f]  and parameter: \f[ \alpha \f]
+    */
+    enum SimilarityFunction
+    {
+        MINUS,      //!< \f[ -d(c_i, c_j) \f]
+        GAUSSIAN,   //!< \f[ e^{ -\alpha * d^2(c_i, c_j)} \f]
+        HEURISTIC   //!< \f[ \frac{1}{\alpha + d(c_i, c_j)} \f]
+    };
+
+
+    /**
+    * @brief Creates PCTSignatures algorithm using sample and seed count.
+    *       It generates its own sets of sampling points and clusterization seed indexes.
+    * @param initSampleCount Number of points used for image sampling.
+    * @param initSeedCount Number of initial clusterization seeds.
+    *       Must be lower or equal to initSampleCount
+    * @param pointDistribution Distribution of generated points. Default: UNIFORM.
+    *       Available: UNIFORM, REGULAR, NORMAL.
+    * @return Created algorithm.
+    */
+    CV_WRAP static Ptr<PCTSignatures> create(
+        const int initSampleCount = 2000,
+        const int initSeedCount = 400,
+        const int pointDistribution = 0);
+
+    /**
+    * @brief Creates PCTSignatures algorithm using pre-generated sampling points
+    *       and number of clusterization seeds. It uses the provided
+    *       sampling points and generates its own clusterization seed indexes.
+    * @param initSamplingPoints Sampling points used in image sampling.
+    * @param initSeedCount Number of initial clusterization seeds.
+    *       Must be lower or equal to initSamplingPoints.size().
+    * @return Created algorithm.
+    */
+    CV_WRAP static Ptr<PCTSignatures> create(
+        const std::vector<Point2f>& initSamplingPoints,
+        const int initSeedCount);
+
+    /**
+    * @brief Creates PCTSignatures algorithm using pre-generated sampling points
+    *       and clusterization seeds indexes.
+    * @param initSamplingPoints Sampling points used in image sampling.
+    * @param initClusterSeedIndexes Indexes of initial clusterization seeds.
+    *       Its size must be lower or equal to initSamplingPoints.size().
+    * @return Created algorithm.
+    */
+    CV_WRAP static Ptr<PCTSignatures> create(
+        const std::vector<Point2f>& initSamplingPoints,
+        const std::vector<int>& initClusterSeedIndexes);
+
+
+
+    /**
+    * @brief Computes signature of given image.
+    * @param image Input image of CV_8U type.
+    * @param signature Output computed signature.
+    */
+    CV_WRAP virtual void computeSignature(
+        InputArray image,
+        OutputArray signature) const = 0;
+
+    /**
+    * @brief Computes signatures for multiple images in parallel.
+    * @param images Vector of input images of CV_8U type.
+    * @param signatures Vector of computed signatures.
+    */
+    CV_WRAP virtual void computeSignatures(
+        const std::vector<Mat>& images,
+        std::vector<Mat>& signatures) const = 0;
+
+    /**
+    * @brief Draws signature in the source image and outputs the result.
+    *       Signatures are visualized as a circle
+    *       with radius based on signature weight
+    *       and color based on signature color.
+    *       Contrast and entropy are not visualized.
+    * @param source Source image.
+    * @param signature Image signature.
+    * @param result Output result.
+    * @param radiusToShorterSideRatio Determines maximal radius of signature in the output image.
+    * @param borderThickness Border thickness of the visualized signature.
+    */
+    CV_WRAP static void drawSignature(
+        InputArray source,
+        InputArray signature,
+        OutputArray result,
+        float radiusToShorterSideRatio = 1.0 / 8,
+        int borderThickness = 1);
+
+    /**
+    * @brief Generates initial sampling points according to selected point distribution.
+    * @param initPoints Output vector where the generated points will be saved.
+    * @param count Number of points to generate.
+    * @param pointDistribution Point distribution selector.
+    *       Available: UNIFORM, REGULAR, NORMAL.
+    * @note Generated coordinates are in range [0..1)
+    */
+    CV_WRAP static void generateInitPoints(
+        std::vector<Point2f>& initPoints,
+        const int count,
+        int pointDistribution);
+
+
+    /**** sampler ****/
+
+    /**
+    * @brief Number of initial samples taken from the image.
+    */
+    CV_WRAP virtual int getSampleCount() const = 0;
+
+    /**
+    * @brief Color resolution of the greyscale bitmap represented in allocated bits
+    *       (i.e., value 4 means that 16 shades of grey are used).
+    *       The greyscale bitmap is used for computing contrast and entropy values.
+    */
+    CV_WRAP virtual int getGrayscaleBits() const = 0;
+    /**
+    * @brief Color resolution of the greyscale bitmap represented in allocated bits
+    *       (i.e., value 4 means that 16 shades of grey are used).
+    *       The greyscale bitmap is used for computing contrast and entropy values.
+    */
+    CV_WRAP virtual void setGrayscaleBits(int grayscaleBits) = 0;
+
+    /**
+    * @brief Size of the texture sampling window used to compute contrast and entropy
+    *       (center of the window is always in the pixel selected by x,y coordinates
+    *       of the corresponding feature sample).
+    */
+    CV_WRAP virtual int getWindowRadius() const = 0;
+    /**
+    * @brief Size of the texture sampling window used to compute contrast and entropy
+    *       (center of the window is always in the pixel selected by x,y coordinates
+    *       of the corresponding feature sample).
+    */
+    CV_WRAP virtual void setWindowRadius(int radius) = 0;
+
+
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual float getWeightX() const = 0;
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual void setWeightX(float weight) = 0;
+
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual float getWeightY() const = 0;
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual void setWeightY(float weight) = 0;
+
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual float getWeightL() const = 0;
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual void setWeightL(float weight) = 0;
+
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual float getWeightA() const = 0;
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual void setWeightA(float weight) = 0;
+
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual float getWeightB() const = 0;
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual void setWeightB(float weight) = 0;
+
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual float getWeightContrast() const = 0;
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual void setWeightContrast(float weight) = 0;
+
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual float getWeightEntropy() const = 0;
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space
+    *       (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)
+    */
+    CV_WRAP virtual void setWeightEntropy(float weight) = 0;
+
+    /**
+    * @brief Initial samples taken from the image.
+    *       These sampled features become the input for clustering.
+    */
+    CV_WRAP virtual std::vector<Point2f> getSamplingPoints() const = 0;
+
+
+
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space.
+    * @param idx ID of the weight
+    * @param value Value of the weight
+    * @note
+    *       WEIGHT_IDX = 0;
+    *       X_IDX = 1;
+    *       Y_IDX = 2;
+    *       L_IDX = 3;
+    *       A_IDX = 4;
+    *       B_IDX = 5;
+    *       CONTRAST_IDX = 6;
+    *       ENTROPY_IDX = 7;
+    */
+    CV_WRAP virtual void setWeight(int idx, float value) = 0;
+    /**
+    * @brief Weights (multiplicative constants) that linearly stretch individual axes of the feature space.
+    * @param weights Values of all weights.
+    * @note
+    *       WEIGHT_IDX = 0;
+    *       X_IDX = 1;
+    *       Y_IDX = 2;
+    *       L_IDX = 3;
+    *       A_IDX = 4;
+    *       B_IDX = 5;
+    *       CONTRAST_IDX = 6;
+    *       ENTROPY_IDX = 7;
+    */
+    CV_WRAP virtual void setWeights(const std::vector<float>& weights) = 0;
+
+    /**
+    * @brief Translations of the individual axes of the feature space.
+    * @param idx ID of the translation
+    * @param value Value of the translation
+    * @note
+    *       WEIGHT_IDX = 0;
+    *       X_IDX = 1;
+    *       Y_IDX = 2;
+    *       L_IDX = 3;
+    *       A_IDX = 4;
+    *       B_IDX = 5;
+    *       CONTRAST_IDX = 6;
+    *       ENTROPY_IDX = 7;
+    */
+    CV_WRAP virtual void setTranslation(int idx, float value) = 0;
+    /**
+    * @brief Translations of the individual axes of the feature space.
+    * @param translations Values of all translations.
+    * @note
+    *       WEIGHT_IDX = 0;
+    *       X_IDX = 1;
+    *       Y_IDX = 2;
+    *       L_IDX = 3;
+    *       A_IDX = 4;
+    *       B_IDX = 5;
+    *       CONTRAST_IDX = 6;
+    *       ENTROPY_IDX = 7;
+    */
+    CV_WRAP virtual void setTranslations(const std::vector<float>& translations) = 0;
+
+    /**
+    * @brief Sets sampling points used to sample the input image.
+    * @param samplingPoints Vector of sampling points in range [0..1)
+    * @note Number of sampling points must be greater or equal to clusterization seed count.
+    */
+    CV_WRAP virtual void setSamplingPoints(std::vector<Point2f> samplingPoints) = 0;
+
+
+
+    /**** clusterizer ****/
+    /**
+    * @brief Initial seeds (initial number of clusters) for the k-means algorithm.
+    */
+    CV_WRAP virtual std::vector<int> getInitSeedIndexes() const = 0;
+    /**
+    * @brief Initial seed indexes for the k-means algorithm.
+    */
+    CV_WRAP virtual void setInitSeedIndexes(std::vector<int> initSeedIndexes) = 0;
+    /**
+    * @brief Number of initial seeds (initial number of clusters) for the k-means algorithm.
+    */
+    CV_WRAP virtual int getInitSeedCount() const = 0;
+
+    /**
+    * @brief Number of iterations of the k-means clustering.
+    *       We use fixed number of iterations, since the modified clustering is pruning clusters
+    *       (not iteratively refining k clusters).
+    */
+    CV_WRAP virtual int getIterationCount() const = 0;
+    /**
+    * @brief Number of iterations of the k-means clustering.
+    *       We use fixed number of iterations, since the modified clustering is pruning clusters
+    *       (not iteratively refining k clusters).
+    */
+    CV_WRAP virtual void setIterationCount(int iterationCount) = 0;
+
+    /**
+    * @brief Maximal number of generated clusters. If the number is exceeded,
+    *       the clusters are sorted by their weights and the smallest clusters are cropped.
+    */
+    CV_WRAP virtual int getMaxClustersCount() const = 0;
+    /**
+    * @brief Maximal number of generated clusters. If the number is exceeded,
+    *       the clusters are sorted by their weights and the smallest clusters are cropped.
+    */
+    CV_WRAP virtual void setMaxClustersCount(int maxClustersCount) = 0;
+
+    /**
+    * @brief This parameter multiplied by the index of iteration gives lower limit for cluster size.
+    *       Clusters containing fewer points than specified by the limit have their centroid dismissed
+    *       and points are reassigned.
+    */
+    CV_WRAP virtual int getClusterMinSize() const = 0;
+    /**
+    * @brief This parameter multiplied by the index of iteration gives lower limit for cluster size.
+    *       Clusters containing fewer points than specified by the limit have their centroid dismissed
+    *       and points are reassigned.
+    */
+    CV_WRAP virtual void setClusterMinSize(int clusterMinSize) = 0;
+
+    /**
+    * @brief Threshold euclidean distance between two centroids.
+    *       If two cluster centers are closer than this distance,
+    *       one of the centroid is dismissed and points are reassigned.
+    */
+    CV_WRAP virtual float getJoiningDistance() const = 0;
+    /**
+    * @brief Threshold euclidean distance between two centroids.
+    *       If two cluster centers are closer than this distance,
+    *       one of the centroid is dismissed and points are reassigned.
+    */
+    CV_WRAP virtual void setJoiningDistance(float joiningDistance) = 0;
+
+    /**
+    * @brief Remove centroids in k-means whose weight is lesser or equal to given threshold.
+    */
+    CV_WRAP virtual float getDropThreshold() const = 0;
+    /**
+    * @brief Remove centroids in k-means whose weight is lesser or equal to given threshold.
+    */
+    CV_WRAP virtual void setDropThreshold(float dropThreshold) = 0;
+
+    /**
+    * @brief Distance function selector used for measuring distance between two points in k-means.
+    */
+    CV_WRAP virtual int getDistanceFunction() const = 0;
+    /**
+    * @brief Distance function selector used for measuring distance between two points in k-means.
+    *       Available: L0_25, L0_5, L1, L2, L2SQUARED, L5, L_INFINITY.
+    */
+    CV_WRAP virtual void setDistanceFunction(int distanceFunction) = 0;
+
+};
+
+/**
+* @brief Class implementing Signature Quadratic Form Distance (SQFD).
+* @see Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+*   Signature quadratic form distance.
+*   In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+*   ACM, 2010.
+* @cite BeecksUS10
+*/
+class CV_EXPORTS_W PCTSignaturesSQFD : public Algorithm
+{
+public:
+
+    /**
+    * @brief Creates the algorithm instance using selected distance function,
+    *       similarity function and similarity function parameter.
+    * @param distanceFunction Distance function selector. Default: L2
+    *       Available: L0_25, L0_5, L1, L2, L2SQUARED, L5, L_INFINITY
+    * @param similarityFunction Similarity function selector. Default: HEURISTIC
+    *       Available: MINUS, GAUSSIAN, HEURISTIC
+    * @param similarityParameter Parameter of the similarity function.
+    */
+    CV_WRAP static Ptr<PCTSignaturesSQFD> create(
+        const int distanceFunction = 3,
+        const int similarityFunction = 2,
+        const float similarityParameter = 1.0f);
+
+    /**
+    * @brief Computes Signature Quadratic Form Distance of two signatures.
+    * @param _signature0 The first signature.
+    * @param _signature1 The second signature.
+    */
+    CV_WRAP virtual float computeQuadraticFormDistance(
+        InputArray _signature0,
+        InputArray _signature1) const = 0;
+
+    /**
+    * @brief Computes Signature Quadratic Form Distance between the reference signature
+    *       and each of the other image signatures.
+    * @param sourceSignature The signature to measure distance of other signatures from.
+    * @param imageSignatures Vector of signatures to measure distance from the source signature.
+    * @param distances Output vector of measured distances.
+    */
+    CV_WRAP virtual void computeQuadraticFormDistances(
+        const Mat& sourceSignature,
+        const std::vector<Mat>& imageSignatures,
+        std::vector<float>& distances) const = 0;
+
+};
+
+/**
+* @brief Elliptic region around an interest point.
+*/
+class CV_EXPORTS Elliptic_KeyPoint : public KeyPoint
+{
+public:
+    Size_<float> axes; //!< the lengths of the major and minor ellipse axes
+    float si;  //!< the integration scale at which the parameters were estimated
+    Matx23f transf; //!< the transformation between image space and local patch space
+    Elliptic_KeyPoint();
+    Elliptic_KeyPoint(Point2f pt, float angle, Size axes, float size, float si);
+    virtual ~Elliptic_KeyPoint();
+};
+
+/**
+ * @brief Class implementing the Harris-Laplace feature detector as described in @cite Mikolajczyk2004.
+ */
+class CV_EXPORTS_W HarrisLaplaceFeatureDetector : public Feature2D
+{
+public:
+    /**
+     * @brief Creates a new implementation instance.
+     *
+     * @param numOctaves the number of octaves in the scale-space pyramid
+     * @param corn_thresh the threshold for the Harris cornerness measure
+     * @param DOG_thresh the threshold for the Difference-of-Gaussians scale selection
+     * @param maxCorners the maximum number of corners to consider
+     * @param num_layers the number of intermediate scales per octave
+     */
+    CV_WRAP static Ptr<HarrisLaplaceFeatureDetector> create(
+            int numOctaves=6,
+            float corn_thresh=0.01f,
+            float DOG_thresh=0.01f,
+            int maxCorners=5000,
+            int num_layers=4);
+
+    CV_WRAP virtual void setNumOctaves(int numOctaves_) = 0;
+    CV_WRAP virtual int getNumOctaves() const = 0;
+
+    CV_WRAP virtual void setCornThresh(float corn_thresh_) = 0;
+    CV_WRAP virtual float getCornThresh() const = 0;
+
+    CV_WRAP virtual void setDOGThresh(float DOG_thresh_) = 0;
+    CV_WRAP virtual float getDOGThresh() const = 0;
+
+    CV_WRAP virtual void setMaxCorners(int maxCorners_) = 0;
+    CV_WRAP virtual int getMaxCorners() const = 0;
+
+    CV_WRAP virtual void setNumLayers(int num_layers_) = 0;
+    CV_WRAP virtual int getNumLayers() const = 0;
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+};
+
+/**
+ * @brief Class implementing affine adaptation for key points.
+ *
+ * A @ref FeatureDetector and a @ref DescriptorExtractor are wrapped to augment the
+ * detected points with their affine invariant elliptic region and to compute
+ * the feature descriptors on the regions after warping them into circles.
+ *
+ * The interface is equivalent to @ref Feature2D, adding operations for
+ * @ref Elliptic_KeyPoint "Elliptic_KeyPoints" instead of @ref KeyPoint "KeyPoints".
+ */
+class CV_EXPORTS_W AffineFeature2D : public Feature2D
+{
+public:
+    /**
+     * @brief Creates an instance wrapping the given keypoint detector and
+     * descriptor extractor.
+     */
+    static Ptr<AffineFeature2D> create(
+        Ptr<FeatureDetector> keypoint_detector,
+        Ptr<DescriptorExtractor> descriptor_extractor);
+
+    /**
+     * @brief Creates an instance where keypoint detector and descriptor
+     * extractor are identical.
+     */
+    static Ptr<AffineFeature2D> create(
+        Ptr<FeatureDetector> keypoint_detector)
+    {
+        return create(keypoint_detector, keypoint_detector);
+    }
+
+    using Feature2D::detect; // overload, don't hide
+    /**
+     * @brief Detects keypoints in the image using the wrapped detector and
+     * performs affine adaptation to augment them with their elliptic regions.
+     */
+    virtual void detect(
+        InputArray image,
+        CV_OUT std::vector<Elliptic_KeyPoint>& keypoints,
+        InputArray mask=noArray() ) = 0;
+
+    using Feature2D::detectAndCompute; // overload, don't hide
+    /**
+     * @brief Detects keypoints and computes descriptors for their surrounding
+     * regions, after warping them into circles.
+     */
+    virtual void detectAndCompute(
+        InputArray image,
+        InputArray mask,
+        CV_OUT std::vector<Elliptic_KeyPoint>& keypoints,
+        OutputArray descriptors,
+        bool useProvidedKeypoints=false ) = 0;
+};
+
+/**
+@brief Class implementing the Tree Based Morse Regions (TBMR) as described in
+@cite Najman2014 extended with scaled extraction ability.
+
+@param min_area prune areas smaller than minArea
+@param max_area_relative prune areas bigger than maxArea = max_area_relative *
+input_image_size
+@param scale_factor scale factor for scaled extraction.
+@param n_scales number of applications of the scale factor (octaves).
+
+@note This algorithm is based on Component Tree (Min/Max) as well as MSER but
+uses a Morse-theory approach to extract features.
+
+Features are ellipses (similar to MSER, however a MSER feature can never be a
+TBMR feature and vice versa).
+
+*/
+class CV_EXPORTS_W TBMR : public AffineFeature2D
+{
+public:
+    CV_WRAP static Ptr<TBMR> create(int min_area = 60,
+        float max_area_relative = 0.01f,
+        float scale_factor = 1.25f,
+        int n_scales = -1);
+
+    CV_WRAP virtual void setMinArea(int minArea) = 0;
+    CV_WRAP virtual int getMinArea() const = 0;
+    CV_WRAP virtual void setMaxAreaRelative(float maxArea) = 0;
+    CV_WRAP virtual float getMaxAreaRelative() const = 0;
+    CV_WRAP virtual void setScaleFactor(float scale_factor) = 0;
+    CV_WRAP virtual float getScaleFactor() const = 0;
+    CV_WRAP virtual void setNScales(int n_scales) = 0;
+    CV_WRAP virtual int getNScales() const = 0;
+};
+
+/** @brief Estimates cornerness for prespecified KeyPoints using the FAST algorithm
+
+@param image grayscale image where keypoints (corners) are detected.
+@param keypoints keypoints which should be tested to fit the FAST criteria. Keypoints not being
+detected as corners are removed.
+@param threshold threshold on difference between intensity of the central pixel and pixels of a
+circle around this pixel.
+@param nonmaxSuppression if true, non-maximum suppression is applied to detected corners
+(keypoints).
+@param type one of the three neighborhoods as defined in the paper:
+FastFeatureDetector::TYPE_9_16, FastFeatureDetector::TYPE_7_12,
+FastFeatureDetector::TYPE_5_8
+
+Detects corners using the FAST algorithm by @cite Rosten06 .
+ */
+CV_EXPORTS void FASTForPointSet( InputArray image, CV_IN_OUT std::vector<KeyPoint>& keypoints,
+                      int threshold, bool nonmaxSuppression=true, cv::FastFeatureDetector::DetectorType type=FastFeatureDetector::TYPE_9_16);
+
+
+//! @}
+
+
+//! @addtogroup xfeatures2d_match
+//! @{
+
+/** @brief GMS (Grid-based Motion Statistics) feature matching strategy described in @cite Bian2017gms .
+    @param size1 Input size of image1.
+    @param size2 Input size of image2.
+    @param keypoints1 Input keypoints of image1.
+    @param keypoints2 Input keypoints of image2.
+    @param matches1to2 Input 1-nearest neighbor matches.
+    @param matchesGMS Matches returned by the GMS matching strategy.
+    @param withRotation Take rotation transformation into account.
+    @param withScale Take scale transformation into account.
+    @param thresholdFactor The higher, the less matches.
+    @note
+        Since GMS works well when the number of features is large, we recommend to use the ORB feature and set FastThreshold to 0 to get as many as possible features quickly.
+        If matching results are not satisfying, please add more features. (We use 10000 for images with 640 X 480).
+        If your images have big rotation and scale changes, please set withRotation or withScale to true.
+ */
+CV_EXPORTS_W void matchGMS(const Size& size1, const Size& size2, const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
+                           const std::vector<DMatch>& matches1to2, CV_OUT std::vector<DMatch>& matchesGMS, const bool withRotation = false,
+                           const bool withScale = false, const double thresholdFactor = 6.0);
+
+/** @brief LOGOS (Local geometric support for high-outlier spatial verification) feature matching strategy described in @cite Lowry2018LOGOSLG .
+    @param keypoints1 Input keypoints of image1.
+    @param keypoints2 Input keypoints of image2.
+    @param nn1 Index to the closest BoW centroid for each descriptors of image1.
+    @param nn2 Index to the closest BoW centroid for each descriptors of image2.
+    @param matches1to2 Matches returned by the LOGOS matching strategy.
+    @note
+        This matching strategy is suitable for features matching against large scale database.
+        First step consists in constructing the bag-of-words (BoW) from a representative image database.
+        Image descriptors are then represented by their closest codevector (nearest BoW centroid).
+ */
+CV_EXPORTS_W void matchLOGOS(const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
+                             const std::vector<int>& nn1, const std::vector<int>& nn2,
+                             std::vector<DMatch>& matches1to2);
+
+//! @}
+
+}
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/include/opencv2/xfeatures2d/cuda.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/include/opencv2/xfeatures2d/cuda.hpp
new file mode 100644
index 00000000..ea4a3238
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/include/opencv2/xfeatures2d/cuda.hpp
@@ -0,0 +1,202 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_XFEATURES2D_CUDA_HPP__
+#define __OPENCV_XFEATURES2D_CUDA_HPP__
+
+#include "opencv2/core/cuda.hpp"
+
+namespace cv { namespace cuda {
+
+//! @addtogroup xfeatures2d_nonfree
+//! @{
+
+/** @brief Class used for extracting Speeded Up Robust Features (SURF) from an image. :
+
+The class SURF_CUDA implements Speeded Up Robust Features descriptor. There is a fast multi-scale
+Hessian keypoint detector that can be used to find the keypoints (which is the default option). But
+the descriptors can also be computed for the user-specified keypoints. Only 8-bit grayscale images
+are supported.
+
+The class SURF_CUDA can store results in the GPU and CPU memory. It provides functions to convert
+results between CPU and GPU version ( uploadKeypoints, downloadKeypoints, downloadDescriptors ). The
+format of CPU results is the same as SURF results. GPU results are stored in GpuMat. The keypoints
+matrix is \f$\texttt{nFeatures} \times 7\f$ matrix with the CV_32FC1 type.
+
+-   keypoints.ptr\<float\>(X_ROW)[i] contains x coordinate of the i-th feature.
+-   keypoints.ptr\<float\>(Y_ROW)[i] contains y coordinate of the i-th feature.
+-   keypoints.ptr\<float\>(LAPLACIAN_ROW)[i] contains the laplacian sign of the i-th feature.
+-   keypoints.ptr\<float\>(OCTAVE_ROW)[i] contains the octave of the i-th feature.
+-   keypoints.ptr\<float\>(SIZE_ROW)[i] contains the size of the i-th feature.
+-   keypoints.ptr\<float\>(ANGLE_ROW)[i] contain orientation of the i-th feature.
+-   keypoints.ptr\<float\>(HESSIAN_ROW)[i] contains the response of the i-th feature.
+
+The descriptors matrix is \f$\texttt{nFeatures} \times \texttt{descriptorSize}\f$ matrix with the
+CV_32FC1 type.
+
+The class SURF_CUDA uses some buffers and provides access to it. All buffers can be safely released
+between function calls.
+
+@sa SURF
+
+@note
+   -   An example for using the SURF keypoint matcher on GPU can be found at
+        opencv_source_code/samples/gpu/surf_keypoint_matcher.cpp
+
+ */
+class CV_EXPORTS_W SURF_CUDA
+{
+public:
+    enum KeypointLayout
+    {
+        X_ROW = 0,
+        Y_ROW,
+        LAPLACIAN_ROW,
+        OCTAVE_ROW,
+        SIZE_ROW,
+        ANGLE_ROW,
+        HESSIAN_ROW,
+        ROWS_COUNT
+    };
+
+    //! the default constructor
+    SURF_CUDA();
+    //! the full constructor taking all the necessary parameters
+    explicit SURF_CUDA(double _hessianThreshold, int _nOctaves=4,
+         int _nOctaveLayers=2, bool _extended=false, float _keypointsRatio=0.01f, bool _upright = false);
+
+    /**
+    @param _hessianThreshold Threshold for hessian keypoint detector used in SURF.
+    @param _nOctaves Number of pyramid octaves the keypoint detector will use.
+    @param _nOctaveLayers Number of octave layers within each octave.
+    @param _extended Extended descriptor flag (true - use extended 128-element descriptors; false - use
+    64-element descriptors).
+    @param _keypointsRatio
+    @param _upright Up-right or rotated features flag (true - do not compute orientation of features;
+    false - compute orientation).
+    */
+    CV_WRAP static Ptr<SURF_CUDA> create(double _hessianThreshold, int _nOctaves = 4,
+        int _nOctaveLayers = 2, bool _extended = false, float _keypointsRatio = 0.01f, bool _upright = false);
+
+    //! returns the descriptor size in float's (64 or 128)
+    CV_WRAP int descriptorSize() const;
+    //! returns the default norm type
+    CV_WRAP int defaultNorm() const;
+
+    //! upload host keypoints to device memory
+    void uploadKeypoints(const std::vector<KeyPoint>& keypoints, GpuMat& keypointsGPU);
+    //! download keypoints from device to host memory
+    CV_WRAP void downloadKeypoints(const GpuMat& keypointsGPU, CV_OUT std::vector<KeyPoint>& keypoints);
+
+    //! download descriptors from device to host memory
+    void downloadDescriptors(const GpuMat& descriptorsGPU, std::vector<float>& descriptors);
+
+    //! finds the keypoints using fast hessian detector used in SURF
+    //! supports CV_8UC1 images
+    //! keypoints will have nFeature cols and 6 rows
+    //! keypoints.ptr<float>(X_ROW)[i] will contain x coordinate of i'th feature
+    //! keypoints.ptr<float>(Y_ROW)[i] will contain y coordinate of i'th feature
+    //! keypoints.ptr<float>(LAPLACIAN_ROW)[i] will contain laplacian sign of i'th feature
+    //! keypoints.ptr<float>(OCTAVE_ROW)[i] will contain octave of i'th feature
+    //! keypoints.ptr<float>(SIZE_ROW)[i] will contain size of i'th feature
+    //! keypoints.ptr<float>(ANGLE_ROW)[i] will contain orientation of i'th feature
+    //! keypoints.ptr<float>(HESSIAN_ROW)[i] will contain response of i'th feature
+    void operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints);
+    //! finds the keypoints and computes their descriptors.
+    //! Optionally it can compute descriptors for the user-provided keypoints and recompute keypoints direction
+    void operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints, GpuMat& descriptors,
+        bool useProvidedKeypoints = false);
+
+    /** @brief Finds the keypoints using fast hessian detector used in SURF
+
+    @param img Source image, currently supports only CV_8UC1 images.
+    @param mask A mask image same size as src and of type CV_8UC1.
+    @param keypoints Detected keypoints.
+     */
+    CV_WRAP inline void detect(const GpuMat& img, const GpuMat& mask, CV_OUT GpuMat& keypoints) {
+        (*this)(img, mask, keypoints);
+    }
+
+    void operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints);
+    void operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints, GpuMat& descriptors,
+        bool useProvidedKeypoints = false);
+
+    /** @brief Finds the keypoints and computes their descriptors using fast hessian detector used in SURF
+
+    @param img Source image, currently supports only CV_8UC1 images.
+    @param mask A mask image same size as src and of type CV_8UC1.
+    @param keypoints Detected keypoints.
+    @param descriptors Keypoint descriptors.
+    @param useProvidedKeypoints Compute descriptors for the user-provided keypoints and recompute keypoints direction.
+     */
+    CV_WRAP inline void detectWithDescriptors(const GpuMat& img, const GpuMat& mask, CV_OUT GpuMat& keypoints, CV_OUT GpuMat& descriptors,
+        bool useProvidedKeypoints = false) {
+        (*this)(img, mask, keypoints, descriptors, useProvidedKeypoints);
+    }
+
+    void operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints, std::vector<float>& descriptors,
+        bool useProvidedKeypoints = false);
+
+    void releaseMemory();
+
+    // SURF parameters
+    CV_PROP double hessianThreshold;
+    CV_PROP int nOctaves;
+    CV_PROP int nOctaveLayers;
+    CV_PROP bool extended;
+    CV_PROP bool upright;
+
+    //! max keypoints = min(keypointsRatio * img.size().area(), 65535)
+    CV_PROP float keypointsRatio;
+
+    GpuMat sum, mask1, maskSum;
+
+    GpuMat det, trace;
+
+    GpuMat maxPosBuffer;
+};
+
+//! @}
+
+}} // namespace cv { namespace cuda {
+
+#endif // __OPENCV_XFEATURES2D_CUDA_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/include/opencv2/xfeatures2d/nonfree.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/include/opencv2/xfeatures2d/nonfree.hpp
new file mode 100644
index 00000000..8eb11aa6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/include/opencv2/xfeatures2d/nonfree.hpp
@@ -0,0 +1,124 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_XFEATURES2D_FEATURES_2D_HPP__
+#define __OPENCV_XFEATURES2D_FEATURES_2D_HPP__
+
+#include "opencv2/features2d.hpp"
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+/** @brief Class for extracting Speeded Up Robust Features from an image @cite Bay06 .
+
+The algorithm parameters:
+-   member int extended
+    -   0 means that the basic descriptors (64 elements each) shall be computed
+    -   1 means that the extended descriptors (128 elements each) shall be computed
+-   member int upright
+    -   0 means that detector computes orientation of each feature.
+    -   1 means that the orientation is not computed (which is much, much faster). For example,
+if you match images from a stereo pair, or do image stitching, the matched features
+likely have very similar angles, and you can speed up feature extraction by setting
+upright=1.
+-   member double hessianThreshold
+Threshold for the keypoint detector. Only features, whose hessian is larger than
+hessianThreshold are retained by the detector. Therefore, the larger the value, the less
+keypoints you will get. A good default value could be from 300 to 500, depending from the
+image contrast.
+-   member int nOctaves
+The number of a gaussian pyramid octaves that the detector uses. It is set to 4 by default.
+If you want to get very large features, use the larger value. If you want just small
+features, decrease it.
+-   member int nOctaveLayers
+The number of images within each octave of a gaussian pyramid. It is set to 2 by default.
+@note
+   -   An example using the SURF feature detector can be found at
+        opencv_source_code/samples/cpp/generic_descriptor_match.cpp
+    -   Another example using the SURF feature detector, extractor and matcher can be found at
+        opencv_source_code/samples/cpp/matcher_simple.cpp
+ */
+class CV_EXPORTS_W SURF : public Feature2D
+{
+public:
+    /**
+    @param hessianThreshold Threshold for hessian keypoint detector used in SURF.
+    @param nOctaves Number of pyramid octaves the keypoint detector will use.
+    @param nOctaveLayers Number of octave layers within each octave.
+    @param extended Extended descriptor flag (true - use extended 128-element descriptors; false - use
+    64-element descriptors).
+    @param upright Up-right or rotated features flag (true - do not compute orientation of features;
+    false - compute orientation).
+     */
+    CV_WRAP static Ptr<SURF> create(double hessianThreshold=100,
+                  int nOctaves = 4, int nOctaveLayers = 3,
+                  bool extended = false, bool upright = false);
+
+    CV_WRAP virtual void setHessianThreshold(double hessianThreshold) = 0;
+    CV_WRAP virtual double getHessianThreshold() const = 0;
+
+    CV_WRAP virtual void setNOctaves(int nOctaves) = 0;
+    CV_WRAP virtual int getNOctaves() const = 0;
+
+    CV_WRAP virtual void setNOctaveLayers(int nOctaveLayers) = 0;
+    CV_WRAP virtual int getNOctaveLayers() const = 0;
+
+    CV_WRAP virtual void setExtended(bool extended) = 0;
+    CV_WRAP virtual bool getExtended() const = 0;
+
+    CV_WRAP virtual void setUpright(bool upright) = 0;
+    CV_WRAP virtual bool getUpright() const = 0;
+
+    CV_WRAP String getDefaultName() const CV_OVERRIDE;
+};
+
+typedef SURF SurfFeatureDetector;
+typedef SURF SurfDescriptorExtractor;
+
+//! @}
+
+}
+} /* namespace cv */
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/DAISYDescriptorExtractorTest.java b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/DAISYDescriptorExtractorTest.java
new file mode 100644
index 00000000..97d3063c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/DAISYDescriptorExtractorTest.java
@@ -0,0 +1,67 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.xfeatures2d.DAISY;
+
+public class DAISYDescriptorExtractorTest extends OpenCVTestCase {
+
+    DAISY extractor;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        extractor = DAISY.create(); // default (15, 3, 8, 8, 100, noArray, true, false)
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.DAISY\"\nradius: 16.\nq_radius: 4\nq_theta: 9\nq_hist: 10\nnorm_type: 101\nenable_interpolation: 0\nuse_orientation: 1\n");
+
+        extractor.read(filename);
+
+        assertEquals(16.0f, extractor.getRadius());
+        assertEquals(4, extractor.getQRadius());
+        assertEquals(9, extractor.getQTheta());
+        assertEquals(10, extractor.getQHist());
+        assertEquals(101, extractor.getNorm());
+        assertEquals(false, extractor.getInterpolation());
+        assertEquals(true, extractor.getUseOrientation());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.DAISY\"\nradius: 15.\nq_radius: 3\nq_theta: 8\nq_hist: 8\nnorm_type: 100\nenable_interpolation: 1\nuse_orientation: 0\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e([+-])0(\\d\\d)", "e$1$2"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/FREAKDescriptorExtractorTest.java b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/FREAKDescriptorExtractorTest.java
new file mode 100644
index 00000000..4793a487
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/FREAKDescriptorExtractorTest.java
@@ -0,0 +1,64 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.xfeatures2d.FREAK;
+
+public class FREAKDescriptorExtractorTest extends OpenCVTestCase {
+
+    FREAK extractor;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        extractor = FREAK.create(); // default (true,true,22,4)
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.FREAK\"\norientationNormalized: 0\nscaleNormalized: 0\npatternScale: 23.\nnOctaves: 5\n");
+
+        extractor.read(filename);
+
+        assertEquals(false, extractor.getOrientationNormalized());
+        assertEquals(false, extractor.getScaleNormalized());
+        assertEquals(23.0, extractor.getPatternScale());
+        assertEquals(5, extractor.getNOctaves());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.FREAK\"\norientationNormalized: 1\nscaleNormalized: 1\npatternScale: 22.\nnOctaves: 4\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e([+-])0(\\d\\d)", "e$1$2"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/HARRISFeatureDetectorTest.java b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/HARRISFeatureDetectorTest.java
new file mode 100644
index 00000000..2f45a88b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/HARRISFeatureDetectorTest.java
@@ -0,0 +1,65 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.xfeatures2d.HarrisLaplaceFeatureDetector;
+
+public class HARRISFeatureDetectorTest extends OpenCVTestCase {
+
+    HarrisLaplaceFeatureDetector detector;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = HarrisLaplaceFeatureDetector.create(); // default constructor have (6, 0.01, 0.01, 5000, 4)
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.HARRIS-LAPLACE\"\nnumOctaves: 5\ncorn_thresh: 0.02\nDOG_thresh: 0.03\nmaxCorners: 4000\nnum_layers: 2\n");
+        detector.read(filename);
+
+        assertEquals(5, detector.getNumOctaves());
+        assertEquals(0.02f, detector.getCornThresh());
+        assertEquals(0.03f, detector.getDOGThresh());
+        assertEquals(4000, detector.getMaxCorners());
+        assertEquals(2, detector.getNumLayers());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.HARRIS-LAPLACE\"\nnumOctaves: 6\ncorn_thresh: 9.9999997764825821e-03\nDOG_thresh: 9.9999997764825821e-03\nmaxCorners: 5000\nnum_layers: 4\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e([+-])0(\\d\\d)", "e$1$2"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/LATCHDescriptorExtractorTest.java b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/LATCHDescriptorExtractorTest.java
new file mode 100644
index 00000000..10802d21
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/LATCHDescriptorExtractorTest.java
@@ -0,0 +1,64 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.xfeatures2d.LATCH;
+
+public class LATCHDescriptorExtractorTest extends OpenCVTestCase {
+
+    LATCH extractor;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        extractor = LATCH.create(); // default (32,true,3,2.0)
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.LATCH\"\ndescriptorSize: 64\nrotationInvariance: 0\nhalf_ssd_size: 5\nsigma: 3.\n");
+
+        extractor.read(filename);
+
+        assertEquals(64, extractor.getBytes());
+        assertEquals(false, extractor.getRotationInvariance());
+        assertEquals(5, extractor.getHalfSSDsize());
+        assertEquals(3.0, extractor.getSigma());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.LATCH\"\ndescriptorSize: 32\nrotationInvariance: 1\nhalf_ssd_size: 3\nsigma: 2.\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e([+-])0(\\d\\d)", "e$1$2"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/LUCIDDescriptorExtractorTest.java b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/LUCIDDescriptorExtractorTest.java
new file mode 100644
index 00000000..295fc215
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/LUCIDDescriptorExtractorTest.java
@@ -0,0 +1,62 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.xfeatures2d.LUCID;
+
+public class LUCIDDescriptorExtractorTest extends OpenCVTestCase {
+
+    LUCID extractor;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        extractor = LUCID.create(); // default (1,2)
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.LUCID\"\nlucid_kernel: 2\nblur_kernel: 3\n");
+
+        extractor.read(filename);
+
+        assertEquals(2, extractor.getLucidKernel());
+        assertEquals(3, extractor.getBlurKernel());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.LUCID\"\nlucid_kernel: 1\nblur_kernel: 2\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e([+-])0(\\d\\d)", "e$1$2"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/MSDFeatureDetectorTest.java b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/MSDFeatureDetectorTest.java
new file mode 100644
index 00000000..8e37e013
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/MSDFeatureDetectorTest.java
@@ -0,0 +1,69 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.xfeatures2d.MSDDetector;
+
+public class MSDFeatureDetectorTest extends OpenCVTestCase {
+
+    MSDDetector detector;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = MSDDetector.create(); // default (3,5,5,0,250.4,',1.25,-1,false)
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.MSD\"\npatch_radius: 4\nsearch_area_radius: 6\nnms_radius: 7\nnms_scale_radius: 1\nth_saliency: 251.\nkNN: 2\nscale_factor: 1.26\nn_scales: 3\ncompute_orientation: 1\n");
+
+        detector.read(filename);
+
+        assertEquals(4, detector.getPatchRadius());
+        assertEquals(6, detector.getSearchAreaRadius());
+        assertEquals(7, detector.getNmsRadius());
+        assertEquals(1, detector.getNmsScaleRadius());
+        assertEquals(251.0f, detector.getThSaliency());
+        assertEquals(2, detector.getKNN());
+        assertEquals(1.26f, detector.getScaleFactor());
+        assertEquals(3, detector.getNScales());
+        assertEquals(true, detector.getComputeOrientation());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.MSD\"\npatch_radius: 3\nsearch_area_radius: 5\nnms_radius: 5\nnms_scale_radius: 0\nth_saliency: 250.\nkNN: 4\nscale_factor: 1.2500000000000000e+00\nn_scales: -1\ncompute_orientation: 0\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e([+-])0(\\d\\d)", "e$1$2"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/STARFeatureDetectorTest.java b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/STARFeatureDetectorTest.java
new file mode 100644
index 00000000..88d3dade
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/STARFeatureDetectorTest.java
@@ -0,0 +1,128 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.xfeatures2d.StarDetector;
+
+public class STARFeatureDetectorTest extends OpenCVTestCase {
+
+    StarDetector detector;
+    int matSize;
+    KeyPoint[] truth;
+
+    private Mat getMaskImg() {
+        Mat mask = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Mat right = mask.submat(0, matSize, matSize / 2, matSize);
+        right.setTo(new Scalar(0));
+        return mask;
+    }
+
+    private Mat getTestImg() {
+        Scalar color = new Scalar(0);
+        int center = matSize / 2;
+        int radius = 6;
+        int offset = 40;
+
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.circle(img, new Point(center - offset, center), radius, color, -1);
+        Imgproc.circle(img, new Point(center + offset, center), radius, color, -1);
+        Imgproc.circle(img, new Point(center, center - offset), radius, color, -1);
+        Imgproc.circle(img, new Point(center, center + offset), radius, color, -1);
+        Imgproc.circle(img, new Point(center, center), radius, color, -1);
+        return img;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = createClassInstance(XFEATURES2D+"StarDetector", DEFAULT_FACTORY, null, null);
+        matSize = 200;
+        truth = new KeyPoint[] {
+                new KeyPoint( 95,  80, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint(105,  80, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint( 80,  95, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint(120,  95, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint(100, 100,  8, -1, 30.f,     0, -1),
+                new KeyPoint( 80, 105, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint(120, 105, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint( 95, 120, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint(105, 120, 22, -1, 31.5957f, 0, -1)
+            };
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        Mat img = getTestImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+
+        detector.detect(img, keypoints);
+
+        assertListKeyPointEquals(Arrays.asList(truth), keypoints.toList(), EPS);
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        Mat img = getTestImg();
+        Mat mask = getMaskImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+
+        detector.detect(img, keypoints, mask);
+
+        assertListKeyPointEquals(Arrays.asList(truth[0], truth[2], truth[5], truth[7]), keypoints.toList(), EPS);
+    }
+
+    public void testEmpty() {
+//        assertFalse(detector.empty());
+        fail("Not yet implemented");
+    }
+
+    public void testReadYml() {
+        Mat img = getTestImg();
+
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint();
+        detector.detect(img, keypoints1);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.STAR\"\nmaxSize: 45\nresponseThreshold: 150\nlineThresholdProjected: 10\nlineThresholdBinarized: 8\nsuppressNonmaxSize: 5\n");
+        detector.read(filename);
+
+        assertEquals(45, detector.getMaxSize());
+        assertEquals(150, detector.getResponseThreshold());
+        assertEquals(10, detector.getLineThresholdProjected());
+        assertEquals(8, detector.getLineThresholdBinarized());
+        assertEquals(5, detector.getSuppressNonmaxSize());
+
+        MatOfKeyPoint keypoints2 = new MatOfKeyPoint();
+        detector.detect(img, keypoints2);
+
+        assertTrue(keypoints2.total() <= keypoints1.total());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.STAR\"\nmaxSize: 45\nresponseThreshold: 30\nlineThresholdProjected: 10\nlineThresholdBinarized: 8\nsuppressNonmaxSize: 5\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/SURFDescriptorExtractorTest.java b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/SURFDescriptorExtractorTest.java
new file mode 100644
index 00000000..e2bac918
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/SURFDescriptorExtractorTest.java
@@ -0,0 +1,115 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.xfeatures2d.SURF;
+
+public class SURFDescriptorExtractorTest extends OpenCVTestCase {
+
+    SURF extractor;
+    int matSize;
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        Class[] cParams = {double.class, int.class, int.class, boolean.class, boolean.class};
+        Object[] oValues = {100, 2, 4, true, false};
+        extractor = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, cParams, oValues);
+
+        matSize = 100;
+    }
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        KeyPoint point = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        MatOfKeyPoint keypoints = new MatOfKeyPoint(point);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        extractor.compute(img, keypoints, descriptors);
+
+        Mat truth = new Mat(1, 128, CvType.CV_32FC1) {
+            {
+                put(0, 0,
+                          0, 0, 0, 0, 0, 0, 0, 0, 0.058821894, 0.058821894, -0.045962855, 0.046261817, 0.0085156476,
+                          0.0085754395, -0.0064509804, 0.0064509804, 0.00044069235, 0.00044069235, 0, 0, 0.00025723741,
+                          0.00025723741, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00025723741, 0.00025723741, -0.00044069235,
+                          0.00044069235, 0, 0, 0.36278215, 0.36278215, -0.24688604, 0.26173124, 0.052068226, 0.052662034,
+                          -0.032815345, 0.032815345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.0064523756,
+                          0.0064523756, 0.0082002236, 0.0088908644, -0.059001274, 0.059001274, 0.045789491, 0.04648013,
+                          0.11961588, 0.22789426, -0.01322381, 0.18291828, -0.14042182, 0.23973691, 0.073782086, 0.23769434,
+                          -0.027880307, 0.027880307, 0.049587864, 0.049587864, -0.33991757, 0.33991757, 0.21437603, 0.21437603,
+                          -0.0020763327, 0.0020763327, 0.006245892, 0.006245892, -0.04067041, 0.04067041, 0.019361559,
+                          0.019361559, 0, 0, -0.0035977389, 0.0035977389, 0, 0, -0.00099993451, 0.00099993451, 0.040670406,
+                          0.040670406, -0.019361559, 0.019361559, 0.006245892, 0.006245892, -0.0020763327, 0.0020763327,
+                          -0.00034532088, 0.00034532088, 0, 0, 0, 0, 0.00034532088, 0.00034532088, -0.00099993451,
+                          0.00099993451, 0, 0, 0, 0, 0.0035977389, 0.0035977389
+                    );
+            }
+        };
+
+        assertMatEqual(truth, descriptors, EPS);
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDescriptorSize() {
+        assertEquals(128, extractor.descriptorSize());
+    }
+
+    public void testDescriptorType() {
+        assertEquals(CvType.CV_32F, extractor.descriptorType());
+    }
+
+    public void testEmpty() {
+//        assertFalse(extractor.empty());
+        fail("Not yet implemented");
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.SURF\"\nhessianThreshold: 100.\nextended: 1\nupright: 0\nnOctaves: 2\nnOctaveLayers: 4\n");
+
+        extractor.read(filename);
+
+        assertEquals(128, extractor.descriptorSize());
+        assertEquals(true, extractor.getExtended());
+        assertEquals(false, extractor.getUpright());
+        assertEquals(2, extractor.getNOctaves());
+        assertEquals(4, extractor.getNOctaveLayers());
+        assertEquals(100., extractor.getHessianThreshold());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.SURF\"\nhessianThreshold: 100.\nextended: 1\nupright: 0\nnOctaves: 2\nnOctaveLayers: 4\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e([+-])0(\\d\\d)", "e$1$2"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/SURFFeatureDetectorTest.java b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/SURFFeatureDetectorTest.java
new file mode 100644
index 00000000..6e46371b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/java/test/SURFFeatureDetectorTest.java
@@ -0,0 +1,176 @@
+package org.opencv.test.features2d;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.xfeatures2d.SURF;
+
+public class SURFFeatureDetectorTest extends OpenCVTestCase {
+
+    SURF detector;
+    int matSize;
+    KeyPoint[] truth;
+
+    private Mat getMaskImg() {
+        Mat mask = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Mat right = mask.submat(0, matSize, matSize / 2, matSize);
+        right.setTo(new Scalar(0));
+        return mask;
+    }
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    private void order(List<KeyPoint> points) {
+        Collections.sort(points, new Comparator<KeyPoint>() {
+            public int compare(KeyPoint p1, KeyPoint p2) {
+                if (p1.angle < p2.angle)
+                    return -1;
+                if (p1.angle > p2.angle)
+                    return 1;
+                return 0;
+            }
+        });
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = createClassInstance(XFEATURES2D + "SURF", DEFAULT_FACTORY, null, null);
+        matSize = 100;
+        truth = new KeyPoint[] {
+                new KeyPoint(55.775578f, 55.775578f, 16, 80.245735f, 8617.8633f, 0, -1),
+                new KeyPoint(44.224422f, 55.775578f, 16, 170.24574f, 8617.8633f, 0, -1),
+                new KeyPoint(44.224422f, 44.224422f, 16, 260.24573f, 8617.8633f, 0, -1),
+                new KeyPoint(55.775578f, 44.224422f, 16, 350.24573f, 8617.8633f, 0, -1)
+            };
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+
+        setProperty(detector, "hessianThreshold", "double", 8000);
+        setProperty(detector, "nOctaves", "int", 3);
+        setProperty(detector, "nOctaveLayers", "int", 4);
+        setProperty(detector, "upright", "boolean", false);
+        setProperty(detector, "extended", "boolean", true);
+
+        List<MatOfKeyPoint> keypoints = new ArrayList<MatOfKeyPoint>();
+        Mat cross = getTestImg();
+        List<Mat> crosses = new ArrayList<Mat>(3);
+        crosses.add(cross);
+        crosses.add(cross);
+        crosses.add(cross);
+
+        detector.detect(crosses, keypoints);
+
+        assertEquals(3, keypoints.size());
+
+        for (MatOfKeyPoint mkp : keypoints) {
+            List<KeyPoint> lkp = mkp.toList();
+            order(lkp);
+            assertListKeyPointEquals(Arrays.asList(truth), lkp, EPS);
+        }
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+
+        setProperty(detector, "hessianThreshold", "double", 8000);
+        setProperty(detector, "nOctaves", "int", 3);
+        setProperty(detector, "nOctaveLayers", "int", 4);
+        setProperty(detector, "upright", "boolean", false);
+
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+        Mat cross = getTestImg();
+
+        detector.detect(cross, keypoints);
+
+        List<KeyPoint> lkp = keypoints.toList();
+        order(lkp);
+        assertListKeyPointEquals(Arrays.asList(truth), lkp, EPS);
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+
+        setProperty(detector, "hessianThreshold", "double", 8000);
+        setProperty(detector, "nOctaves", "int", 3);
+        setProperty(detector, "nOctaveLayers", "int", 4);
+        setProperty(detector, "upright", "boolean", false);
+        setProperty(detector, "extended", "boolean", true);
+
+        Mat img = getTestImg();
+        Mat mask = getMaskImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+
+        detector.detect(img, keypoints, mask);
+
+        List<KeyPoint> lkp = keypoints.toList();
+        order(lkp);
+        assertListKeyPointEquals(Arrays.asList(truth[1], truth[2]), lkp, EPS);
+    }
+
+    public void testEmpty() {
+//        assertFalse(detector.empty());
+        fail("Not yet implemented");
+    }
+
+    public void testReadYml() {
+        Mat cross = getTestImg();
+
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint();
+        detector.detect(cross, keypoints1);
+
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+        writeFile(filename, "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.SURF</name>\n<hessianThreshold>8000.</hessianThreshold>\n<extended>1</extended>\n<upright>0</upright>\n<nOctaves>3</nOctaves>\n<nOctaveLayers>4</nOctaveLayers>\n</opencv_storage>\n");
+
+        detector.read(filename);
+
+        assertEquals(128, detector.descriptorSize());
+        assertEquals(8000., detector.getHessianThreshold());
+        assertEquals(true, detector.getExtended());
+        assertEquals(false, detector.getUpright());
+        assertEquals(3, detector.getNOctaves());
+        assertEquals(4, detector.getNOctaveLayers());
+
+        MatOfKeyPoint keypoints2 = new MatOfKeyPoint();
+        detector.detect(cross, keypoints2);
+
+        assertTrue(keypoints2.total() <= keypoints1.total());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.SURF\"\nhessianThreshold: 100.\nextended: 0\nupright: 0\nnOctaves: 4\nnOctaveLayers: 3\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e([+-])0(\\d\\d)", "e$1$2"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/objc/gen_dict.json b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/objc/gen_dict.json
new file mode 100644
index 00000000..5d278b92
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/objc/gen_dict.json
@@ -0,0 +1,17 @@
+{
+    "class_ignore_list" : [
+        "SURF_CUDA"
+    ],
+    "AdditionalImports" : {
+        "*" : [ "\"xfeatures2d.hpp\"" ]
+    },
+    "func_arg_fix" : {
+        "DAISY" : {
+            "create" : { "norm" : { "ctype" : "NormalizationType",
+                                    "defval" : "cv::xfeatures2d::DAISY::NRM_NONE"} }
+        },
+        "PCTSignatures" : {
+            "(PCTSignatures*)create:(NSArray<Point2f*>*)initSamplingPoints initSeedCount:(int)initSeedCount" : { "create" : {"name" : "create2"} }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/pyopencv_sift.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/pyopencv_sift.hpp
new file mode 100644
index 00000000..2a15f5ef
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/pyopencv_sift.hpp
@@ -0,0 +1,2 @@
+// Compatibility
+#include "shadow_sift.hpp"
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/pyopencv_xfeatures2d.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/pyopencv_xfeatures2d.hpp
new file mode 100644
index 00000000..17d90674
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/pyopencv_xfeatures2d.hpp
@@ -0,0 +1,7 @@
+#ifdef HAVE_OPENCV_XFEATURES2D
+
+#include "opencv2/xfeatures2d.hpp"
+using cv::xfeatures2d::DAISY;
+
+typedef DAISY::NormalizationType DAISY_NormalizationType;
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/shadow_sift.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/shadow_sift.hpp
new file mode 100644
index 00000000..d7fd2324
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/shadow_sift.hpp
@@ -0,0 +1,20 @@
+// Compatibility
+// SIFT is moved to the main repository
+
+namespace cv {
+namespace xfeatures2d {
+
+/** Use cv.SIFT_create() instead */
+CV_WRAP static inline
+Ptr<cv::SIFT> SIFT_create(int nfeatures = 0, int nOctaveLayers = 3,
+        double contrastThreshold = 0.04, double edgeThreshold = 10,
+        double sigma = 1.6)
+{
+    CV_LOG_ONCE_WARNING(NULL, "DEPRECATED: cv.xfeatures2d.SIFT_create() is deprecated due SIFT tranfer to the main repository. "
+                              "https://github.com/opencv/opencv/issues/16736"
+    );
+
+    return SIFT::create(nfeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma);
+}
+
+}}  // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/test/test_cuda_xfeatures2d.py b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/test/test_cuda_xfeatures2d.py
new file mode 100644
index 00000000..16c8e565
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/test/test_cuda_xfeatures2d.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+import os
+import cv2 as cv
+import numpy as np
+
+from tests_common import NewOpenCVTests, unittest
+
+class xfeatures2d_test(NewOpenCVTests):
+    def setUp(self):
+        super(xfeatures2d_test, self).setUp()
+        if not cv.cuda.getCudaEnabledDeviceCount():
+            self.skipTest("No CUDA-capable device is detected")
+
+    @unittest.skipIf('OPENCV_TEST_DATA_PATH' not in os.environ,
+                     "OPENCV_TEST_DATA_PATH is not defined")
+    def test_surf(self):
+        img_path = os.environ['OPENCV_TEST_DATA_PATH'] + "/gpu/features2d/aloe.png"
+        hessianThreshold = 100
+        nOctaves = 3
+        nOctaveLayers = 2
+        extended = False
+        keypointsRatio = 0.05
+        upright = False
+
+        npMat = cv.cvtColor(cv.imread(img_path),cv.COLOR_BGR2GRAY)
+        cuMat = cv.cuda_GpuMat(npMat)
+
+        try:
+            cuSurf = cv.cuda_SURF_CUDA.create(hessianThreshold,nOctaves,nOctaveLayers,extended,keypointsRatio,upright)
+            surf = cv.xfeatures2d_SURF.create(hessianThreshold,nOctaves,nOctaveLayers,extended,upright)
+        except cv.error as e:
+            self.assertEqual(e.code, cv.Error.StsNotImplemented)
+            self.skipTest("OPENCV_ENABLE_NONFREE is not enabled in this build.")
+
+        cuKeypoints = cuSurf.detect(cuMat,cv.cuda_GpuMat())
+        keypointsHost = cuSurf.downloadKeypoints(cuKeypoints)
+        keypoints = surf.detect(npMat)
+        self.assertTrue(len(keypointsHost) == len(keypoints))
+
+        cuKeypoints, cuDescriptors = cuSurf.detectWithDescriptors(cuMat,cv.cuda_GpuMat(),cuKeypoints,useProvidedKeypoints=True)
+        keypointsHost = cuSurf.downloadKeypoints(cuKeypoints)
+        descriptorsHost = cuDescriptors.download()
+        keypoints, descriptors = surf.compute(npMat,keypoints)
+
+        self.assertTrue(len(keypointsHost) == len(keypoints) and descriptorsHost.shape == descriptors.shape)
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/test/test_descriptors.py b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/test/test_descriptors.py
new file mode 100644
index 00000000..ca8bbcbc
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/test/test_descriptors.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import os
+import numpy as np
+import cv2 as cv
+
+from tests_common import NewOpenCVTests
+
+class MSDDetector_test(NewOpenCVTests):
+
+    def test_create(self):
+
+        msd = cv.xfeatures2d.MSDDetector_create()
+        self.assertFalse(msd is None)
+
+        img1 = np.zeros((100, 100, 3), dtype=np.uint8)
+        kp1_ = msd.detect(img1, None)
+
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/test/test_sift_compatibility.py b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/test/test_sift_compatibility.py
new file mode 100644
index 00000000..96e22094
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/misc/python/test/test_sift_compatibility.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import os
+import numpy as np
+import cv2 as cv
+
+from tests_common import NewOpenCVTests
+
+class sift_compatibility_test(NewOpenCVTests):
+
+    def test_create(self):
+
+        sift = cv.xfeatures2d.SIFT_create()
+        self.assertFalse(sift is None)
+
+        img1 = np.zeros((100, 100, 3), dtype=np.uint8)
+        kp1_, des1_ = sift.detectAndCompute(img1, None)
+
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_beblid.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_beblid.cpp
new file mode 100644
index 00000000..2e2d3eb5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_beblid.cpp
@@ -0,0 +1,36 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> beblid;
+
+#define BEBLID_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+#ifdef OPENCV_ENABLE_NONFREE
+PERF_TEST_P(beblid, extract, testing::Values(BEBLID_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+    detector->detect(frame, points, mask);
+
+    Ptr<BEBLID> descriptor = BEBLID::create(6.25f);
+    cv::Mat descriptors;
+    TEST_CYCLE() descriptor->compute(frame, points, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+#endif // NONFREE
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_daisy.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_daisy.cpp
new file mode 100644
index 00000000..154d8eb1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_daisy.cpp
@@ -0,0 +1,33 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> daisy;
+
+#define DAISY_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(daisy, extract, testing::Values(DAISY_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<DAISY> descriptor = DAISY::create();
+
+    vector<KeyPoint> points;
+    Mat_<float> descriptors;
+    // compute all daisies in image
+    TEST_CYCLE() descriptor->compute(frame, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_latch.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_latch.cpp
new file mode 100644
index 00000000..ac5dcd73
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_latch.cpp
@@ -0,0 +1,36 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> latch;
+
+#define LATCH_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+#ifdef OPENCV_ENABLE_NONFREE
+PERF_TEST_P(latch, extract, testing::Values(LATCH_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+    detector->detect(frame, points, mask);
+
+    Ptr<LATCH> descriptor = LATCH::create();
+    vector<uchar> descriptors;
+    TEST_CYCLE() descriptor->compute(frame, points, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+#endif // NONFREE
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_main.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_main.cpp
new file mode 100644
index 00000000..2c3cc5aa
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_main.cpp
@@ -0,0 +1,14 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+#include "opencv2/ts/cuda_perf.hpp"
+
+static const char * impls[] = {
+#ifdef HAVE_CUDA
+    "cuda",
+#endif
+    "plain"
+};
+
+CV_PERF_TEST_MAIN_WITH_IMPLS(xfeatures2d, impls, perf::printCudaInfo())
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_msd.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_msd.cpp
new file mode 100644
index 00000000..0505d692
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_msd.cpp
@@ -0,0 +1,33 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> msd;
+
+#define MSD_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(msd, detect, testing::Values(MSD_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+
+    if (frame.empty())
+        FAIL() << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame);
+    Ptr<MSDDetector> detector = MSDDetector::create();
+    vector<KeyPoint> points;
+
+    TEST_CYCLE() detector->detect(frame, points, mask);
+
+    sort(points.begin(), points.end(), comparators::KeypointGreater());
+    SANITY_CHECK_KEYPOINTS(points, 1e-3);
+}
+
+}} // namespace
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_precomp.hpp
new file mode 100644
index 00000000..249d0798
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_precomp.hpp
@@ -0,0 +1,25 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#ifndef __OPENCV_PERF_PRECOMP_HPP__
+#define __OPENCV_PERF_PRECOMP_HPP__
+
+#include "cvconfig.h"
+
+#include "opencv2/ts.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+#ifdef HAVE_OPENCV_OCL
+#  include "opencv2/ocl.hpp"
+#endif
+
+#ifdef HAVE_CUDA
+#  include "opencv2/xfeatures2d/cuda.hpp"
+#endif
+
+namespace opencv_test {
+using namespace cv::xfeatures2d;
+using namespace perf;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_surf.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_surf.cpp
new file mode 100644
index 00000000..814fb1da
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_surf.cpp
@@ -0,0 +1,68 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+#ifdef OPENCV_ENABLE_NONFREE
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> surf;
+
+#define SURF_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(surf, detect, testing::Values(SURF_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+
+    TEST_CYCLE() detector->detect(frame, points, mask);
+
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P(surf, extract, testing::Values(SURF_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+    Mat descriptors;
+    detector->detect(frame, points, mask);
+
+    TEST_CYCLE() detector->compute(frame, points, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P(surf, full, testing::Values(SURF_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+    Mat descriptors;
+
+    TEST_CYCLE() detector->detectAndCompute(frame, mask, points, descriptors, false);
+
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
+#endif // NONFREE
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_surf.cuda.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_surf.cuda.cpp
new file mode 100644
index 00000000..7421642c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_surf.cuda.cpp
@@ -0,0 +1,102 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+
+#if defined(HAVE_CUDA) && defined(OPENCV_ENABLE_NONFREE)
+
+#include "opencv2/ts/cuda_perf.hpp"
+
+namespace opencv_test { namespace {
+
+//////////////////////////////////////////////////////////////////////
+// SURF
+
+#ifdef HAVE_OPENCV_CUDAARITHM
+
+DEF_PARAM_TEST_1(Image, string);
+
+PERF_TEST_P(Image, CUDA_SURF,
+            Values<std::string>("gpu/perf/aloe.png"))
+{
+    declare.time(50.0);
+
+    const cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
+
+    if (PERF_RUN_CUDA())
+    {
+        cv::cuda::SURF_CUDA d_surf;
+
+        const cv::cuda::GpuMat d_img(img);
+        cv::cuda::GpuMat d_keypoints, d_descriptors;
+
+        TEST_CYCLE() d_surf(d_img, cv::cuda::GpuMat(), d_keypoints, d_descriptors);
+
+        std::vector<cv::KeyPoint> gpu_keypoints;
+        d_surf.downloadKeypoints(d_keypoints, gpu_keypoints);
+
+        cv::Mat gpu_descriptors(d_descriptors);
+
+        sortKeyPoints(gpu_keypoints, gpu_descriptors);
+
+        SANITY_CHECK_KEYPOINTS(gpu_keypoints);
+        SANITY_CHECK(gpu_descriptors, 1e-3);
+    }
+    else
+    {
+        cv::Ptr<cv::Feature2D> surf = cv::xfeatures2d::SURF::create();
+        std::vector<cv::KeyPoint> cpu_keypoints;
+        cv::Mat cpu_descriptors;
+
+        TEST_CYCLE() surf->detect(img, cpu_keypoints);
+        TEST_CYCLE() surf->compute(img, cpu_keypoints, cpu_descriptors);
+
+        SANITY_CHECK_KEYPOINTS(cpu_keypoints);
+        SANITY_CHECK(cpu_descriptors);
+    }
+}
+
+#endif // HAVE_OPENCV_CUDAARITHM
+
+}} // namespace
+#endif // HAVE_CUDA && OPENCV_ENABLE_NONFREE
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_surf.ocl.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_surf.ocl.cpp
new file mode 100644
index 00000000..2ba92a97
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_surf.ocl.cpp
@@ -0,0 +1,108 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+
+#if defined(HAVE_OPENCV_OCL) && defined(OPENCV_ENABLE_NONFREE)
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> OCL_SURF;
+
+#define SURF_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(OCL_SURF, DISABLED_with_data_transfer, testing::Values(SURF_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat img = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
+
+    SURF_OCL d_surf;
+    oclMat d_keypoints;
+    oclMat d_descriptors;
+    Mat cpu_kp;
+    Mat cpu_dp;
+
+    declare.time(60);
+
+    TEST_CYCLE()
+    {
+        oclMat d_src(img);
+
+        d_surf(d_src, oclMat(), d_keypoints, d_descriptors);
+
+        d_keypoints.download(cpu_kp);
+        d_descriptors.download(cpu_dp);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P(OCL_SURF, DISABLED_without_data_transfer, testing::Values(SURF_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat img = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
+
+    SURF_OCL d_surf;
+    oclMat d_keypoints;
+    oclMat d_descriptors;
+    oclMat d_src(img);
+
+    declare.time(60);
+
+    TEST_CYCLE() d_surf(d_src, oclMat(), d_keypoints, d_descriptors);
+
+    Mat cpu_kp;
+    Mat cpu_dp;
+    d_keypoints.download(cpu_kp);
+    d_descriptors.download(cpu_dp);
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
+#endif // HAVE_OPENCV_OCL && OPENCV_ENABLE_NONFREE
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_teblid.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_teblid.cpp
new file mode 100644
index 00000000..01a84336
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_teblid.cpp
@@ -0,0 +1,36 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> teblid;
+
+#define TEBLID_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+#ifdef OPENCV_ENABLE_NONFREE
+PERF_TEST_P(teblid, extract, testing::Values(TEBLID_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+    detector->detect(frame, points, mask);
+
+    Ptr<TEBLID> descriptor = TEBLID::create(6.25f);
+    cv::Mat descriptors;
+    TEST_CYCLE() descriptor->compute(frame, points, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+#endif // NONFREE
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_vgg.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_vgg.cpp
new file mode 100644
index 00000000..095a745d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/perf/perf_vgg.cpp
@@ -0,0 +1,39 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+#ifdef OPENCV_XFEATURES2D_HAS_VGG_DATA
+
+typedef perf::TestBaseWithParam<std::string> vgg;
+
+#define VGG_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(vgg, extract, testing::Values(VGG_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<KAZE> detector = KAZE::create();
+    vector<KeyPoint> points;
+    detector->detect(frame, points, mask);
+
+    Ptr<VGG> descriptor = VGG::create();
+    Mat_<float> descriptors;
+    // compute keypoints descriptor
+    TEST_CYCLE() descriptor->compute(frame, points, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+
+#endif  // OPENCV_XFEATURES2D_HAS_VGG_DATA
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/bagofwords_classification.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/bagofwords_classification.cpp
new file mode 100644
index 00000000..222c949b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/bagofwords_classification.cpp
@@ -0,0 +1,2646 @@
+#include <iostream>
+#include "opencv2/opencv_modules.hpp"
+
+#ifdef HAVE_OPENCV_ML
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+#include "opencv2/ml.hpp"
+
+#include <fstream>
+#include <memory>
+#include <functional>
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef min
+#undef max
+#include "sys/types.h"
+#endif
+#include <sys/stat.h>
+
+#define DEBUG_DESC_PROGRESS
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+using namespace cv::ml;
+using namespace std;
+
+const string paramsFile = "params.xml";
+const string vocabularyFile = "vocabulary.xml.gz";
+const string bowImageDescriptorsDir = "/bowImageDescriptors";
+const string svmsDir = "/svms";
+const string plotsDir = "/plots";
+
+static void help(char** argv)
+{
+    cout << "\nThis program shows how to read in, train on and produce test results for the PASCAL VOC (Visual Object Challenge) data. \n"
+     << "It shows how to use detectors, descriptors and recognition methods \n"
+        "Using OpenCV version %s\n" << CV_VERSION << "\n"
+     << "Call: \n"
+    << "Format:\n ./" << argv[0] << " [VOC path] [result directory]  \n"
+    << "       or:  \n"
+    << " ./" << argv[0] << " [VOC path] [result directory] [feature detector] [descriptor extractor] [descriptor matcher] \n"
+    << "\n"
+    << "Input parameters: \n"
+    << "[VOC path]             Path to Pascal VOC data (e.g. /home/my/VOCdevkit/VOC2010). Note: VOC2007-VOC2010 are supported. \n"
+    << "[result directory]     Path to result diractory. Following folders will be created in [result directory]: \n"
+    << "                         bowImageDescriptors - to store image descriptors, \n"
+    << "                         svms - to store trained svms, \n"
+    << "                         plots - to store files for plots creating. \n"
+    << "[feature detector]     Feature detector name (e.g. SURF, FAST...) - see createFeatureDetector() function in detectors.cpp \n"
+    << "                         Currently 12/2010, this is FAST, STAR, SIFT, SURF, MSER, GFTT, HARRIS \n"
+    << "[descriptor extractor] Descriptor extractor name (e.g. SURF, SIFT) - see createDescriptorExtractor() function in descriptors.cpp \n"
+    << "                         Currently 12/2010, this is SURF, OpponentSIFT, SIFT, OpponentSURF, BRIEF \n"
+    << "[descriptor matcher]   Descriptor matcher name (e.g. BruteForce) - see createDescriptorMatcher() function in matchers.cpp \n"
+    << "                         Currently 12/2010, this is BruteForce, BruteForce-L1, FlannBased, BruteForce-Hamming, BruteForce-HammingLUT \n"
+    << "\n";
+}
+
+static void makeDir( const string& dir )
+{
+#if defined WIN32 || defined _WIN32
+    CreateDirectory( dir.c_str(), 0 );
+#else
+    mkdir( dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH );
+#endif
+}
+
+static void makeUsedDirs( const string& rootPath )
+{
+    makeDir(rootPath + bowImageDescriptorsDir);
+    makeDir(rootPath + svmsDir);
+    makeDir(rootPath + plotsDir);
+}
+
+/****************************************************************************************\
+*                    Classes to work with PASCAL VOC dataset                             *
+\****************************************************************************************/
+//
+// TODO: refactor this part of the code
+//
+
+
+//used to specify the (sub-)dataset over which operations are performed
+enum ObdDatasetType {CV_OBD_TRAIN, CV_OBD_TEST};
+
+class ObdObject
+{
+public:
+    string object_class;
+    Rect boundingBox;
+};
+
+//extended object data specific to VOC
+enum VocPose {CV_VOC_POSE_UNSPECIFIED, CV_VOC_POSE_FRONTAL, CV_VOC_POSE_REAR, CV_VOC_POSE_LEFT, CV_VOC_POSE_RIGHT};
+class VocObjectData
+{
+public:
+    bool difficult;
+    bool occluded;
+    bool truncated;
+    VocPose pose;
+};
+//enum VocDataset {CV_VOC2007, CV_VOC2008, CV_VOC2009, CV_VOC2010};
+enum VocPlotType {CV_VOC_PLOT_SCREEN, CV_VOC_PLOT_PNG};
+enum VocGT {CV_VOC_GT_NONE, CV_VOC_GT_DIFFICULT, CV_VOC_GT_PRESENT};
+enum VocConfCond {CV_VOC_CCOND_RECALL, CV_VOC_CCOND_SCORETHRESH};
+enum VocTask {CV_VOC_TASK_CLASSIFICATION, CV_VOC_TASK_DETECTION};
+
+class ObdImage
+{
+public:
+    ObdImage(string p_id, string p_path) : id(p_id), path(p_path) {}
+    string id;
+    string path;
+};
+
+//used by getDetectorGroundTruth to sort a two dimensional list of floats in descending order
+class ObdScoreIndexSorter
+{
+public:
+    float score;
+    int image_idx;
+    int obj_idx;
+    bool operator < (const ObdScoreIndexSorter& compare) const {return (score < compare.score);}
+};
+
+class VocData
+{
+public:
+    VocData( const string& vocPath, bool useTestDataset )
+        { initVoc( vocPath, useTestDataset ); }
+    ~VocData(){}
+    /* functions for returning classification/object data for multiple images given an object class */
+    void getClassImages(const string& obj_class, const ObdDatasetType dataset, vector<ObdImage>& images, vector<char>& object_present);
+    void getClassObjects(const string& obj_class, const ObdDatasetType dataset, vector<ObdImage>& images, vector<vector<ObdObject> >& objects);
+    void getClassObjects(const string& obj_class, const ObdDatasetType dataset, vector<ObdImage>& images, vector<vector<ObdObject> >& objects, vector<vector<VocObjectData> >& object_data, vector<VocGT>& ground_truth);
+    /* functions for returning object data for a single image given an image id */
+    ObdImage getObjects(const string& id, vector<ObdObject>& objects);
+    ObdImage getObjects(const string& id, vector<ObdObject>& objects, vector<VocObjectData>& object_data);
+    ObdImage getObjects(const string& obj_class, const string& id, vector<ObdObject>& objects, vector<VocObjectData>& object_data, VocGT& ground_truth);
+    /* functions for returning the ground truth (present/absent) for groups of images */
+    void getClassifierGroundTruth(const string& obj_class, const vector<ObdImage>& images, vector<char>& ground_truth);
+    void getClassifierGroundTruth(const string& obj_class, const vector<string>& images, vector<char>& ground_truth);
+    int getDetectorGroundTruth(const string& obj_class, const ObdDatasetType dataset, const vector<ObdImage>& images, const vector<vector<Rect> >& bounding_boxes, const vector<vector<float> >& scores, vector<vector<char> >& ground_truth, vector<vector<char> >& detection_difficult, bool ignore_difficult = true);
+    /* functions for writing VOC-compatible results files */
+    void writeClassifierResultsFile(const string& out_dir, const string& obj_class, const ObdDatasetType dataset, const vector<ObdImage>& images, const vector<float>& scores, const int competition = 1, const bool overwrite_ifexists = false);
+    /* functions for calculating metrics from a set of classification/detection results */
+    string getResultsFilename(const string& obj_class, const VocTask task, const ObdDatasetType dataset, const int competition = -1, const int number = -1);
+    void calcClassifierPrecRecall(const string& obj_class, const vector<ObdImage>& images, const vector<float>& scores, vector<float>& precision, vector<float>& recall, float& ap, vector<size_t>& ranking);
+    void calcClassifierPrecRecall(const string& obj_class, const vector<ObdImage>& images, const vector<float>& scores, vector<float>& precision, vector<float>& recall, float& ap);
+    void calcClassifierPrecRecall(const string& input_file, vector<float>& precision, vector<float>& recall, float& ap, bool outputRankingFile = false);
+    /* functions for calculating confusion matrices */
+    void calcClassifierConfMatRow(const string& obj_class, const vector<ObdImage>& images, const vector<float>& scores, const VocConfCond cond, const float threshold, vector<string>& output_headers, vector<float>& output_values);
+    void calcDetectorConfMatRow(const string& obj_class, const ObdDatasetType dataset, const vector<ObdImage>& images, const vector<vector<float> >& scores, const vector<vector<Rect> >& bounding_boxes, const VocConfCond cond, const float threshold, vector<string>& output_headers, vector<float>& output_values, bool ignore_difficult = true);
+    /* functions for outputting gnuplot output files */
+    void savePrecRecallToGnuplot(const string& output_file, const vector<float>& precision, const vector<float>& recall, const float ap, const string title = string(), const VocPlotType plot_type = CV_VOC_PLOT_SCREEN);
+    /* functions for reading in result/ground truth files */
+    void readClassifierGroundTruth(const string& obj_class, const ObdDatasetType dataset, vector<ObdImage>& images, vector<char>& object_present);
+    void readClassifierResultsFile(const std:: string& input_file, vector<ObdImage>& images, vector<float>& scores);
+    void readDetectorResultsFile(const string& input_file, vector<ObdImage>& images, vector<vector<float> >& scores, vector<vector<Rect> >& bounding_boxes);
+    /* functions for getting dataset info */
+    const vector<string>& getObjectClasses();
+    string getResultsDirectory();
+protected:
+    void initVoc( const string& vocPath, const bool useTestDataset );
+    void initVoc2007to2010( const string& vocPath, const bool useTestDataset);
+    void readClassifierGroundTruth(const string& filename, vector<string>& image_codes, vector<char>& object_present);
+    void readClassifierResultsFile(const string& input_file, vector<string>& image_codes, vector<float>& scores);
+    void readDetectorResultsFile(const string& input_file, vector<string>& image_codes, vector<vector<float> >& scores, vector<vector<Rect> >& bounding_boxes);
+    void extractVocObjects(const string filename, vector<ObdObject>& objects, vector<VocObjectData>& object_data);
+    string getImagePath(const string& input_str);
+
+    void getClassImages_impl(const string& obj_class, const string& dataset_str, vector<ObdImage>& images, vector<char>& object_present);
+    void calcPrecRecall_impl(const vector<char>& ground_truth, const vector<float>& scores, vector<float>& precision, vector<float>& recall, float& ap, vector<size_t>& ranking, int recall_normalization = -1);
+
+    //test two bounding boxes to see if they meet the overlap criteria defined in the VOC documentation
+    float testBoundingBoxesForOverlap(const Rect detection, const Rect ground_truth);
+    //extract class and dataset name from a VOC-standard classification/detection results filename
+    void extractDataFromResultsFilename(const string& input_file, string& class_name, string& dataset_name);
+    //get classifier ground truth for a single image
+    bool getClassifierGroundTruthImage(const string& obj_class, const string& id);
+
+    //utility functions
+    void getSortOrder(const vector<float>& values, vector<size_t>& order, bool descending = true);
+    int stringToInteger(const string input_str);
+    void readFileToString(const string filename, string& file_contents);
+    string integerToString(const int input_int);
+    string checkFilenamePathsep(const string filename, bool add_trailing_slash = false);
+    void convertImageCodesToObdImages(const vector<string>& image_codes, vector<ObdImage>& images);
+    int extractXMLBlock(const string src, const string tag, const int searchpos, string& tag_contents);
+    //utility sorter
+    struct orderingSorter
+    {
+        bool operator ()(std::pair<size_t, vector<float>::const_iterator> const& a, std::pair<size_t, vector<float>::const_iterator> const& b)
+        {
+            return (*a.second) > (*b.second);
+        }
+    };
+    //data members
+    string m_vocPath;
+    string m_vocName;
+    //string m_resPath;
+
+    string m_annotation_path;
+    string m_image_path;
+    string m_imageset_path;
+    string m_class_imageset_path;
+
+    vector<string> m_classifier_gt_all_ids;
+    vector<char> m_classifier_gt_all_present;
+    string m_classifier_gt_class;
+
+    //data members
+    string m_train_set;
+    string m_test_set;
+
+    vector<string> m_object_classes;
+
+
+    float m_min_overlap;
+    bool m_sampled_ap;
+};
+
+
+//Return the classification ground truth data for all images of a given VOC object class
+//--------------------------------------------------------------------------------------
+//INPUTS:
+// - obj_class          The VOC object class identifier string
+// - dataset            Specifies whether to extract images from the training or test set
+//OUTPUTS:
+// - images             An array of ObdImage containing info of all images extracted from the ground truth file
+// - object_present     An array of bools specifying whether the object defined by 'obj_class' is present in each image or not
+//NOTES:
+// This function is primarily useful for the classification task, where only
+// whether a given object is present or not in an image is required, and not each object instance's
+// position etc.
+void VocData::getClassImages(const string& obj_class, const ObdDatasetType dataset, vector<ObdImage>& images, vector<char>& object_present)
+{
+    string dataset_str;
+    //generate the filename of the classification ground-truth textfile for the object class
+    if (dataset == CV_OBD_TRAIN)
+    {
+        dataset_str = m_train_set;
+    } else {
+        dataset_str = m_test_set;
+    }
+
+    getClassImages_impl(obj_class, dataset_str, images, object_present);
+}
+
+void VocData::getClassImages_impl(const string& obj_class, const string& dataset_str, vector<ObdImage>& images, vector<char>& object_present)
+{
+    //generate the filename of the classification ground-truth textfile for the object class
+    string gtFilename = m_class_imageset_path;
+    gtFilename.replace(gtFilename.find("%s"),2,obj_class);
+    gtFilename.replace(gtFilename.find("%s"),2,dataset_str);
+
+    //parse the ground truth file, storing in two separate vectors
+    //for the image code and the ground truth value
+    vector<string> image_codes;
+    readClassifierGroundTruth(gtFilename, image_codes, object_present);
+
+    //prepare output arrays
+    images.clear();
+
+    convertImageCodesToObdImages(image_codes, images);
+}
+
+//Return the object data for all images of a given VOC object class
+//-----------------------------------------------------------------
+//INPUTS:
+// - obj_class          The VOC object class identifier string
+// - dataset            Specifies whether to extract images from the training or test set
+//OUTPUTS:
+// - images             An array of ObdImage containing info of all images in chosen dataset (tag, path etc.)
+// - objects            Contains the extended object info (bounding box etc.) for each object instance in each image
+// - object_data        Contains VOC-specific extended object info (marked difficult etc.)
+// - ground_truth       Specifies whether there are any difficult/non-difficult instances of the current
+//                          object class within each image
+//NOTES:
+// This function returns extended object information in addition to the absent/present
+// classification data returned by getClassImages. The objects returned for each image in the 'objects'
+// array are of all object classes present in the image, and not just the class defined by 'obj_class'.
+// 'ground_truth' can be used to determine quickly whether an object instance of the given class is present
+// in an image or not.
+void VocData::getClassObjects(const string& obj_class, const ObdDatasetType dataset, vector<ObdImage>& images, vector<vector<ObdObject> >& objects)
+{
+    vector<vector<VocObjectData> > object_data;
+    vector<VocGT> ground_truth;
+
+    getClassObjects(obj_class,dataset,images,objects,object_data,ground_truth);
+}
+
+void VocData::getClassObjects(const string& obj_class, const ObdDatasetType dataset, vector<ObdImage>& images, vector<vector<ObdObject> >& objects, vector<vector<VocObjectData> >& object_data, vector<VocGT>& ground_truth)
+{
+    //generate the filename of the classification ground-truth textfile for the object class
+    string gtFilename = m_class_imageset_path;
+    gtFilename.replace(gtFilename.find("%s"),2,obj_class);
+    if (dataset == CV_OBD_TRAIN)
+    {
+        gtFilename.replace(gtFilename.find("%s"),2,m_train_set);
+    } else {
+        gtFilename.replace(gtFilename.find("%s"),2,m_test_set);
+    }
+
+    //parse the ground truth file, storing in two separate vectors
+    //for the image code and the ground truth value
+    vector<string> image_codes;
+    vector<char> object_present;
+    readClassifierGroundTruth(gtFilename, image_codes, object_present);
+
+    //prepare output arrays
+    images.clear();
+    objects.clear();
+    object_data.clear();
+    ground_truth.clear();
+
+    string annotationFilename;
+    vector<ObdObject> image_objects;
+    vector<VocObjectData> image_object_data;
+    VocGT image_gt;
+
+    //transfer to output arrays and read in object data for each image
+    for (size_t i = 0; i < image_codes.size(); ++i)
+    {
+        ObdImage image = getObjects(obj_class, image_codes[i], image_objects, image_object_data, image_gt);
+
+        images.push_back(image);
+        objects.push_back(image_objects);
+        object_data.push_back(image_object_data);
+        ground_truth.push_back(image_gt);
+    }
+}
+
+//Return ground truth data for the objects present in an image with a given UID
+//-----------------------------------------------------------------------------
+//INPUTS:
+// - id                 VOC Dataset unique identifier (string code in form YYYY_XXXXXX where YYYY is the year)
+//OUTPUTS:
+// - obj_class (*3)     Specifies the object class to use to resolve 'ground_truth'
+// - objects            Contains the extended object info (bounding box etc.) for each object in the image
+// - object_data (*2,3) Contains VOC-specific extended object info (marked difficult etc.)
+// - ground_truth (*3)  Specifies whether there are any difficult/non-difficult instances of the current
+//                          object class within the image
+//RETURN VALUE:
+// ObdImage containing path and other details of image file with given code
+//NOTES:
+// There are three versions of this function
+//  * One returns a simple array of objects given an id [1]
+//  * One returns the same as (1) plus VOC specific object data [2]
+//  * One returns the same as (2) plus the ground_truth flag. This also requires an extra input obj_class [3]
+ObdImage VocData::getObjects(const string& id, vector<ObdObject>& objects)
+{
+    vector<VocObjectData> object_data;
+    ObdImage image = getObjects(id, objects, object_data);
+
+    return image;
+}
+
+ObdImage VocData::getObjects(const string& id, vector<ObdObject>& objects, vector<VocObjectData>& object_data)
+{
+    //first generate the filename of the annotation file
+    string annotationFilename = m_annotation_path;
+
+    annotationFilename.replace(annotationFilename.find("%s"),2,id);
+
+    //extract objects contained in the current image from the xml
+    extractVocObjects(annotationFilename,objects,object_data);
+
+    //generate image path from extracted string code
+    string path = getImagePath(id);
+
+    ObdImage image(id, path);
+    return image;
+}
+
+ObdImage VocData::getObjects(const string& obj_class, const string& id, vector<ObdObject>& objects, vector<VocObjectData>& object_data, VocGT& ground_truth)
+{
+
+    //extract object data (except for ground truth flag)
+    ObdImage image = getObjects(id,objects,object_data);
+
+    //pregenerate a flag to indicate whether the current class is present or not in the image
+    ground_truth = CV_VOC_GT_NONE;
+    //iterate through all objects in current image
+    for (size_t j = 0; j < objects.size(); ++j)
+    {
+        if (objects[j].object_class == obj_class)
+        {
+            if (object_data[j].difficult == false)
+            {
+                //if at least one non-difficult example is present, this flag is always set to CV_VOC_GT_PRESENT
+                ground_truth = CV_VOC_GT_PRESENT;
+                break;
+            } else {
+                //set if at least one object instance is present, but it is marked difficult
+                ground_truth = CV_VOC_GT_DIFFICULT;
+            }
+        }
+    }
+
+    return image;
+}
+
+//Return ground truth data for the presence/absence of a given object class in an arbitrary array of images
+//---------------------------------------------------------------------------------------------------------
+//INPUTS:
+// - obj_class          The VOC object class identifier string
+// - images             An array of ObdImage OR strings containing the images for which ground truth
+//                          will be computed
+//OUTPUTS:
+// - ground_truth       An output array indicating the presence/absence of obj_class within each image
+void VocData::getClassifierGroundTruth(const string& obj_class, const vector<ObdImage>& images, vector<char>& ground_truth)
+{
+    vector<char>(images.size()).swap(ground_truth);
+
+    vector<ObdObject> objects;
+    vector<VocObjectData> object_data;
+    vector<char>::iterator gt_it = ground_truth.begin();
+    for (vector<ObdImage>::const_iterator it = images.begin(); it != images.end(); ++it, ++gt_it)
+    {
+        //getObjects(obj_class, it->id, objects, object_data, voc_ground_truth);
+        (*gt_it) = (getClassifierGroundTruthImage(obj_class, it->id));
+    }
+}
+
+void VocData::getClassifierGroundTruth(const string& obj_class, const vector<string>& images, vector<char>& ground_truth)
+{
+    vector<char>(images.size()).swap(ground_truth);
+
+    vector<ObdObject> objects;
+    vector<VocObjectData> object_data;
+    vector<char>::iterator gt_it = ground_truth.begin();
+    for (vector<string>::const_iterator it = images.begin(); it != images.end(); ++it, ++gt_it)
+    {
+        //getObjects(obj_class, (*it), objects, object_data, voc_ground_truth);
+        (*gt_it) = (getClassifierGroundTruthImage(obj_class, (*it)));
+    }
+}
+
+//Return ground truth data for the accuracy of detection results
+//--------------------------------------------------------------
+//INPUTS:
+// - obj_class          The VOC object class identifier string
+// - images             An array of ObdImage containing the images for which ground truth
+//                          will be computed
+// - bounding_boxes     A 2D input array containing the bounding box rects of the objects of
+//                          obj_class which were detected in each image
+//OUTPUTS:
+// - ground_truth       A 2D output array indicating whether each object detection was accurate
+//                          or not
+// - detection_difficult A 2D output array indicating whether the detection fired on an object
+//                          marked as 'difficult'. This allows it to be ignored if necessary
+//                          (the voc documentation specifies objects marked as difficult
+//                          have no effects on the results and are effectively ignored)
+// - (ignore_difficult) If set to true, objects marked as difficult will be ignored when returning
+//                          the number of hits for p-r normalization (default = true)
+//RETURN VALUE:
+//                      Returns the number of object hits in total in the gt to allow proper normalization
+//                          of a p-r curve
+//NOTES:
+// As stated in the VOC documentation, multiple detections of the same object in an image are
+// considered FALSE detections e.g. 5 detections of a single object is counted as 1 correct
+// detection and 4 false detections - it is the responsibility of the participant's system
+// to filter multiple detections from its output
+int VocData::getDetectorGroundTruth(const string& obj_class, const ObdDatasetType dataset, const vector<ObdImage>& images, const vector<vector<Rect> >& bounding_boxes, const vector<vector<float> >& scores, vector<vector<char> >& ground_truth, vector<vector<char> >& detection_difficult, bool ignore_difficult)
+{
+    int recall_normalization = 0;
+
+    /* first create a list of indices referring to the elements of bounding_boxes and scores in
+     * descending order of scores */
+    vector<ObdScoreIndexSorter> sorted_ids;
+    {
+        /* first count how many objects to allow preallocation */
+        size_t obj_count = 0;
+        CV_Assert(images.size() == bounding_boxes.size());
+        CV_Assert(scores.size() == bounding_boxes.size());
+        for (size_t im_idx = 0; im_idx < scores.size(); ++im_idx)
+        {
+            CV_Assert(scores[im_idx].size() == bounding_boxes[im_idx].size());
+            obj_count += scores[im_idx].size();
+        }
+        /* preallocate id vector */
+        sorted_ids.resize(obj_count);
+        /* now copy across scores and indexes to preallocated vector */
+        int flat_pos = 0;
+        for (size_t im_idx = 0; im_idx < scores.size(); ++im_idx)
+        {
+            for (size_t ob_idx = 0; ob_idx < scores[im_idx].size(); ++ob_idx)
+            {
+                sorted_ids[flat_pos].score = scores[im_idx][ob_idx];
+                sorted_ids[flat_pos].image_idx = (int)im_idx;
+                sorted_ids[flat_pos].obj_idx = (int)ob_idx;
+                ++flat_pos;
+            }
+        }
+        /* and sort the vector in descending order of score */
+        std::sort(sorted_ids.begin(),sorted_ids.end());
+        std::reverse(sorted_ids.begin(),sorted_ids.end());
+    }
+
+    /* prepare ground truth + difficult vector (1st dimension) */
+    vector<vector<char> >(images.size()).swap(ground_truth);
+    vector<vector<char> >(images.size()).swap(detection_difficult);
+    vector<vector<char> > detected(images.size());
+
+    vector<vector<ObdObject> > img_objects(images.size());
+    vector<vector<VocObjectData> > img_object_data(images.size());
+    /* preload object ground truth bounding box data */
+    {
+        vector<vector<ObdObject> > img_objects_all(images.size());
+        vector<vector<VocObjectData> > img_object_data_all(images.size());
+        for (size_t image_idx = 0; image_idx < images.size(); ++image_idx)
+        {
+            /* prepopulate ground truth bounding boxes */
+            getObjects(images[image_idx].id, img_objects_all[image_idx], img_object_data_all[image_idx]);
+            /* meanwhile, also set length of target ground truth + difficult vector to same as number of object detections (2nd dimension) */
+            ground_truth[image_idx].resize(bounding_boxes[image_idx].size());
+            detection_difficult[image_idx].resize(bounding_boxes[image_idx].size());
+        }
+
+        /* save only instances of the object class concerned */
+        for (size_t image_idx = 0; image_idx < images.size(); ++image_idx)
+        {
+            for (size_t obj_idx = 0; obj_idx < img_objects_all[image_idx].size(); ++obj_idx)
+            {
+                if (img_objects_all[image_idx][obj_idx].object_class == obj_class)
+                {
+                    img_objects[image_idx].push_back(img_objects_all[image_idx][obj_idx]);
+                    img_object_data[image_idx].push_back(img_object_data_all[image_idx][obj_idx]);
+                }
+            }
+            detected[image_idx].resize(img_objects[image_idx].size(), false);
+        }
+    }
+
+    /* calculate the total number of objects in the ground truth for the current dataset */
+    {
+        vector<ObdImage> gt_images;
+        vector<char> gt_object_present;
+        getClassImages(obj_class, dataset, gt_images, gt_object_present);
+
+        for (size_t image_idx = 0; image_idx < gt_images.size(); ++image_idx)
+        {
+            vector<ObdObject> gt_img_objects;
+            vector<VocObjectData> gt_img_object_data;
+            getObjects(gt_images[image_idx].id, gt_img_objects, gt_img_object_data);
+            for (size_t obj_idx = 0; obj_idx < gt_img_objects.size(); ++obj_idx)
+            {
+                if (gt_img_objects[obj_idx].object_class == obj_class)
+                {
+                    if ((gt_img_object_data[obj_idx].difficult == false) || (ignore_difficult == false))
+                        ++recall_normalization;
+                }
+            }
+        }
+    }
+
+#ifdef PR_DEBUG
+    int printed_count = 0;
+#endif
+    /* now iterate through detections in descending order of score, assigning to ground truth bounding boxes if possible */
+    for (size_t detect_idx = 0; detect_idx < sorted_ids.size(); ++detect_idx)
+    {
+        //read in indexes to make following code easier to read
+        int im_idx = sorted_ids[detect_idx].image_idx;
+        int ob_idx = sorted_ids[detect_idx].obj_idx;
+        //set ground truth for the current object to false by default
+        ground_truth[im_idx][ob_idx] = false;
+        detection_difficult[im_idx][ob_idx] = false;
+        float maxov = -1.0;
+        bool max_is_difficult = false;
+        int max_gt_obj_idx = -1;
+        //-- for each detected object iterate through objects present in the bounding box ground truth --
+        for (size_t gt_obj_idx = 0; gt_obj_idx < img_objects[im_idx].size(); ++gt_obj_idx)
+        {
+            if (detected[im_idx][gt_obj_idx] == false)
+            {
+                //check if the detected object and ground truth object overlap by a sufficient margin
+                float ov = testBoundingBoxesForOverlap(bounding_boxes[im_idx][ob_idx], img_objects[im_idx][gt_obj_idx].boundingBox);
+                if (ov != -1.0)
+                {
+                    //if all conditions are met store the overlap score and index (as objects are assigned to the highest scoring match)
+                    if (ov > maxov)
+                    {
+                        maxov = ov;
+                        max_gt_obj_idx = (int)gt_obj_idx;
+                        //store whether the maximum detection is marked as difficult or not
+                        max_is_difficult = (img_object_data[im_idx][gt_obj_idx].difficult);
+                    }
+                }
+            }
+        }
+        //-- if a match was found, set the ground truth of the current object to true --
+        if (maxov != -1.0)
+        {
+            CV_Assert(max_gt_obj_idx != -1);
+            ground_truth[im_idx][ob_idx] = true;
+            //store whether the maximum detection was marked as 'difficult' or not
+            detection_difficult[im_idx][ob_idx] = max_is_difficult;
+            //remove the ground truth object so it doesn't match with subsequent detected objects
+            //** this is the behaviour defined by the voc documentation **
+            detected[im_idx][max_gt_obj_idx] = true;
+        }
+#ifdef PR_DEBUG
+        if (printed_count < 10)
+        {
+            cout << printed_count << ": id=" << images[im_idx].id << ", score=" << scores[im_idx][ob_idx] << " (" << ob_idx << ") [" << bounding_boxes[im_idx][ob_idx].x << "," <<
+                    bounding_boxes[im_idx][ob_idx].y << "," << bounding_boxes[im_idx][ob_idx].width + bounding_boxes[im_idx][ob_idx].x <<
+                    "," << bounding_boxes[im_idx][ob_idx].height + bounding_boxes[im_idx][ob_idx].y << "] detected=" << ground_truth[im_idx][ob_idx] <<
+                    ", difficult=" << detection_difficult[im_idx][ob_idx] << endl;
+            ++printed_count;
+            /* print ground truth */
+            for (int gt_obj_idx = 0; gt_obj_idx < img_objects[im_idx].size(); ++gt_obj_idx)
+            {
+                cout << "    GT: [" << img_objects[im_idx][gt_obj_idx].boundingBox.x << "," <<
+                        img_objects[im_idx][gt_obj_idx].boundingBox.y << "," << img_objects[im_idx][gt_obj_idx].boundingBox.width + img_objects[im_idx][gt_obj_idx].boundingBox.x <<
+                        "," << img_objects[im_idx][gt_obj_idx].boundingBox.height + img_objects[im_idx][gt_obj_idx].boundingBox.y << "]";
+                if (gt_obj_idx == max_gt_obj_idx) cout << " <--- (" << maxov << " overlap)";
+                cout << endl;
+            }
+        }
+#endif
+    }
+
+    return recall_normalization;
+}
+
+//Write VOC-compliant classifier results file
+//-------------------------------------------
+//INPUTS:
+// - obj_class          The VOC object class identifier string
+// - dataset            Specifies whether working with the training or test set
+// - images             An array of ObdImage containing the images for which data will be saved to the result file
+// - scores             A corresponding array of confidence scores given a query
+// - (competition)      If specified, defines which competition the results are for (see VOC documentation - default 1)
+//NOTES:
+// The result file path and filename are determined automatically using m_results_directory as a base
+void VocData::writeClassifierResultsFile( const string& out_dir, const string& obj_class, const ObdDatasetType dataset, const vector<ObdImage>& images, const vector<float>& scores, const int competition, const bool overwrite_ifexists)
+{
+    CV_Assert(images.size() == scores.size());
+
+    string output_file_base, output_file;
+    if (dataset == CV_OBD_TRAIN)
+    {
+        output_file_base = out_dir + "/comp" + integerToString(competition) + "_cls_" + m_train_set + "_" + obj_class;
+    } else {
+        output_file_base = out_dir + "/comp" + integerToString(competition) + "_cls_" + m_test_set + "_" + obj_class;
+    }
+    output_file = output_file_base + ".txt";
+
+    //check if file exists, and if so create a numbered new file instead
+    if (overwrite_ifexists == false)
+    {
+        struct stat stFileInfo;
+        if (stat(output_file.c_str(),&stFileInfo) == 0)
+        {
+            string output_file_new;
+            int filenum = 0;
+            do
+            {
+                ++filenum;
+                output_file_new = output_file_base + "_" + integerToString(filenum);
+                output_file = output_file_new + ".txt";
+            } while (stat(output_file.c_str(),&stFileInfo) == 0);
+        }
+    }
+
+    //output data to file
+    std::ofstream result_file(output_file.c_str());
+    if (result_file.is_open())
+    {
+        for (size_t i = 0; i < images.size(); ++i)
+        {
+            result_file << images[i].id << " " << scores[i] << endl;
+        }
+        result_file.close();
+    } else {
+        string err_msg = "could not open classifier results file '" + output_file + "' for writing. Before running for the first time, a 'results' subdirectory should be created within the VOC dataset base directory. e.g. if the VOC data is stored in /VOC/VOC2010 then the path /VOC/results must be created.";
+        CV_Error(Error::StsError,err_msg.c_str());
+    }
+}
+
+//---------------------------------------
+//CALCULATE METRICS FROM VOC RESULTS DATA
+//---------------------------------------
+
+//Utility function to construct a VOC-standard classification results filename
+//----------------------------------------------------------------------------
+//INPUTS:
+// - obj_class          The VOC object class identifier string
+// - task               Specifies whether to generate a filename for the classification or detection task
+// - dataset            Specifies whether working with the training or test set
+// - (competition)      If specified, defines which competition the results are for (see VOC documentation
+//                      default of -1 means this is set to 1 for the classification task and 3 for the detection task)
+// - (number)           If specified and above 0, defines which of a number of duplicate results file produced for a given set of
+//                      of settings should be used (this number will be added as a postfix to the filename)
+//NOTES:
+// This is primarily useful for returning the filename of a classification file previously computed using writeClassifierResultsFile
+// for example when calling calcClassifierPrecRecall
+string VocData::getResultsFilename(const string& obj_class, const VocTask task, const ObdDatasetType dataset, const int competition, const int number)
+{
+    if ((competition < 1) && (competition != -1))
+        CV_Error(Error::StsBadArg,"competition argument should be a positive non-zero number or -1 to accept the default");
+    if ((number < 1) && (number != -1))
+        CV_Error(Error::StsBadArg,"number argument should be a positive non-zero number or -1 to accept the default");
+
+    string dset, task_type;
+
+    if (dataset == CV_OBD_TRAIN)
+    {
+        dset = m_train_set;
+    } else {
+        dset = m_test_set;
+    }
+
+    int comp = competition;
+    if (task == CV_VOC_TASK_CLASSIFICATION)
+    {
+        task_type = "cls";
+        if (comp == -1) comp = 1;
+    } else {
+        task_type = "det";
+        if (comp == -1) comp = 3;
+    }
+
+    stringstream ss;
+    if (number < 1)
+    {
+        ss << "comp" << comp << "_" << task_type << "_" << dset << "_" << obj_class << ".txt";
+    } else {
+        ss << "comp" << comp << "_" << task_type << "_" << dset << "_" << obj_class << "_" << number << ".txt";
+    }
+
+    string filename = ss.str();
+    return filename;
+}
+
+//Calculate metrics for classification results
+//--------------------------------------------
+//INPUTS:
+// - ground_truth       A vector of booleans determining whether the currently tested class is present in each input image
+// - scores             A vector containing the similarity score for each input image (higher is more similar)
+//OUTPUTS:
+// - precision          A vector containing the precision calculated at each datapoint of a p-r curve generated from the result set
+// - recall             A vector containing the recall calculated at each datapoint of a p-r curve generated from the result set
+// - ap                The ap metric calculated from the result set
+// - (ranking)          A vector of the same length as 'ground_truth' and 'scores' containing the order of the indices in both of
+//                      these arrays when sorting by the ranking score in descending order
+//NOTES:
+// The result file path and filename are determined automatically using m_results_directory as a base
+void VocData::calcClassifierPrecRecall(const string& obj_class, const vector<ObdImage>& images, const vector<float>& scores, vector<float>& precision, vector<float>& recall, float& ap, vector<size_t>& ranking)
+{
+    vector<char> res_ground_truth;
+    getClassifierGroundTruth(obj_class, images, res_ground_truth);
+
+    calcPrecRecall_impl(res_ground_truth, scores, precision, recall, ap, ranking);
+}
+
+void VocData::calcClassifierPrecRecall(const string& obj_class, const vector<ObdImage>& images, const vector<float>& scores, vector<float>& precision, vector<float>& recall, float& ap)
+{
+    vector<char> res_ground_truth;
+    getClassifierGroundTruth(obj_class, images, res_ground_truth);
+
+    vector<size_t> ranking;
+    calcPrecRecall_impl(res_ground_truth, scores, precision, recall, ap, ranking);
+}
+
+//< Overloaded version which accepts VOC classification result file input instead of array of scores/ground truth >
+//INPUTS:
+// - input_file         The path to the VOC standard results file to use for calculating precision/recall
+//                      If a full path is not specified, it is assumed this file is in the VOC standard results directory
+//                      A VOC standard filename can be retrieved (as used by writeClassifierResultsFile) by calling  getClassifierResultsFilename
+
+void VocData::calcClassifierPrecRecall(const string& input_file, vector<float>& precision, vector<float>& recall, float& ap, bool outputRankingFile)
+{
+    //read in classification results file
+    vector<string> res_image_codes;
+    vector<float> res_scores;
+
+    string input_file_std = checkFilenamePathsep(input_file);
+    readClassifierResultsFile(input_file_std, res_image_codes, res_scores);
+
+    //extract the object class and dataset from the results file filename
+    string class_name, dataset_name;
+    extractDataFromResultsFilename(input_file_std, class_name, dataset_name);
+
+    //generate the ground truth for the images extracted from the results file
+    vector<char> res_ground_truth;
+
+    getClassifierGroundTruth(class_name, res_image_codes, res_ground_truth);
+
+    if (outputRankingFile)
+    {
+        /* 1. store sorting order by score (descending) in 'order' */
+        vector<std::pair<size_t, vector<float>::const_iterator> > order(res_scores.size());
+
+        size_t n = 0;
+        for (vector<float>::const_iterator it = res_scores.begin(); it != res_scores.end(); ++it, ++n)
+            order[n] = make_pair(n, it);
+
+        std::sort(order.begin(),order.end(),orderingSorter());
+
+        /* 2. save ranking results to text file */
+        string input_file_std1 = checkFilenamePathsep(input_file);
+        size_t fnamestart = input_file_std1.rfind("/");
+        string scoregt_file_str = input_file_std1.substr(0,fnamestart+1) + "scoregt_" + class_name + ".txt";
+        std::ofstream scoregt_file(scoregt_file_str.c_str());
+        if (scoregt_file.is_open())
+        {
+            for (size_t i = 0; i < res_scores.size(); ++i)
+            {
+                scoregt_file << res_image_codes[order[i].first] << " " << res_scores[order[i].first] << " " << res_ground_truth[order[i].first] << endl;
+            }
+            scoregt_file.close();
+        } else {
+            string err_msg = "could not open scoregt file '" + scoregt_file_str + "' for writing.";
+            CV_Error(Error::StsError,err_msg.c_str());
+        }
+    }
+
+    //finally, calculate precision+recall+ap
+    vector<size_t> ranking;
+    calcPrecRecall_impl(res_ground_truth,res_scores,precision,recall,ap,ranking);
+}
+
+//< Protected implementation of Precision-Recall calculation used by both calcClassifierPrecRecall and calcDetectorPrecRecall >
+
+void VocData::calcPrecRecall_impl(const vector<char>& ground_truth, const vector<float>& scores, vector<float>& precision, vector<float>& recall, float& ap, vector<size_t>& ranking, int recall_normalization)
+{
+    CV_Assert(ground_truth.size() == scores.size());
+
+    //add extra element for p-r at 0 recall (in case that first retrieved is positive)
+    vector<float>(scores.size()+1).swap(precision);
+    vector<float>(scores.size()+1).swap(recall);
+
+    // SORT RESULTS BY THEIR SCORE
+    /* 1. store sorting order in 'order' */
+    VocData::getSortOrder(scores, ranking);
+
+#ifdef PR_DEBUG
+    std::ofstream scoregt_file("D:/pr.txt");
+    if (scoregt_file.is_open())
+    {
+       for (int i = 0; i < scores.size(); ++i)
+       {
+           scoregt_file << scores[ranking[i]] << " " << ground_truth[ranking[i]] << endl;
+       }
+       scoregt_file.close();
+    }
+#endif
+
+    // CALCULATE PRECISION+RECALL
+
+    int retrieved_hits = 0;
+
+    int recall_norm;
+    if (recall_normalization != -1)
+    {
+        recall_norm = recall_normalization;
+    } else {
+#ifdef CV_CXX11
+        recall_norm = (int)std::count_if(ground_truth.begin(),ground_truth.end(),
+                [](const char a) { return a == (char)1; });
+#else
+        recall_norm = (int)std::count_if(ground_truth.begin(),ground_truth.end(),std::bind2nd(std::equal_to<char>(),(char)1));
+#endif
+    }
+
+    ap = 0;
+    recall[0] = 0;
+    for (size_t idx = 0; idx < ground_truth.size(); ++idx)
+    {
+        if (ground_truth[ranking[idx]] != 0) ++retrieved_hits;
+
+        precision[idx+1] = static_cast<float>(retrieved_hits)/static_cast<float>(idx+1);
+        recall[idx+1] = static_cast<float>(retrieved_hits)/static_cast<float>(recall_norm);
+
+        if (idx == 0)
+        {
+            //add further point at 0 recall with the same precision value as the first computed point
+            precision[idx] = precision[idx+1];
+        }
+        if (recall[idx+1] == 1.0)
+        {
+            //if recall = 1, then end early as all positive images have been found
+            recall.resize(idx+2);
+            precision.resize(idx+2);
+            break;
+        }
+    }
+
+    /* ap calculation */
+    if (m_sampled_ap == false)
+    {
+        // FOR VOC2010+ AP IS CALCULATED FROM ALL DATAPOINTS
+        /* make precision monotonically decreasing for purposes of calculating ap */
+        vector<float> precision_monot(precision.size());
+        vector<float>::iterator prec_m_it = precision_monot.begin();
+        for (vector<float>::iterator prec_it = precision.begin(); prec_it != precision.end(); ++prec_it, ++prec_m_it)
+        {
+            vector<float>::iterator max_elem;
+            max_elem = std::max_element(prec_it,precision.end());
+            (*prec_m_it) = (*max_elem);
+        }
+        /* calculate ap */
+        for (size_t idx = 0; idx < (recall.size()-1); ++idx)
+        {
+            ap += (recall[idx+1] - recall[idx])*precision_monot[idx+1] +   //no need to take min of prec - is monotonically decreasing
+                    0.5f*(recall[idx+1] - recall[idx])*std::abs(precision_monot[idx+1] - precision_monot[idx]);
+        }
+    } else {
+        // FOR BEFORE VOC2010 AP IS CALCULATED BY SAMPLING PRECISION AT RECALL 0.0,0.1,..,1.0
+
+        for (float recall_pos = 0.f; recall_pos <= 1.f; recall_pos += 0.1f)
+        {
+            //find iterator of the precision corresponding to the first recall >= recall_pos
+            vector<float>::iterator recall_it = recall.begin();
+            vector<float>::iterator prec_it = precision.begin();
+
+            while ((*recall_it) < recall_pos)
+            {
+                ++recall_it;
+                ++prec_it;
+                if (recall_it == recall.end()) break;
+            }
+
+            /* if no recall >= recall_pos found, this level of recall is never reached so stop adding to ap */
+            if (recall_it == recall.end()) break;
+
+            /* if the prec_it is valid, compute the max precision at this level of recall or higher */
+            vector<float>::iterator max_prec = std::max_element(prec_it,precision.end());
+
+            ap += (*max_prec)/11;
+        }
+    }
+}
+
+/* functions for calculating confusion matrix rows */
+
+//Calculate rows of a confusion matrix
+//------------------------------------
+//INPUTS:
+// - obj_class          The VOC object class identifier string for the confusion matrix row to compute
+// - images             An array of ObdImage containing the images to use for the computation
+// - scores             A corresponding array of confidence scores for the presence of obj_class in each image
+// - cond               Defines whether to use a cut off point based on recall (CV_VOC_CCOND_RECALL) or score
+//                      (CV_VOC_CCOND_SCORETHRESH) the latter is useful for classifier detections where positive
+//                      values are positive detections and negative values are negative detections
+// - threshold          Threshold value for cond. In case of CV_VOC_CCOND_RECALL, is proportion recall (e.g. 0.5).
+//                      In the case of CV_VOC_CCOND_SCORETHRESH is the value above which to count results.
+//OUTPUTS:
+// - output_headers     An output vector of object class headers for the confusion matrix row
+// - output_values      An output vector of values for the confusion matrix row corresponding to the classes
+//                      defined in output_headers
+//NOTES:
+// The methodology used by the classifier version of this function is that true positives have a single unit
+// added to the obj_class column in the confusion matrix row, whereas false positives have a single unit
+// distributed in proportion between all the columns in the confusion matrix row corresponding to the objects
+// present in the image.
+void VocData::calcClassifierConfMatRow(const string& obj_class, const vector<ObdImage>& images, const vector<float>& scores, const VocConfCond cond, const float threshold, vector<string>& output_headers, vector<float>& output_values)
+{
+    CV_Assert(images.size() == scores.size());
+
+    // SORT RESULTS BY THEIR SCORE
+    /* 1. store sorting order in 'ranking' */
+    vector<size_t> ranking;
+    VocData::getSortOrder(scores, ranking);
+
+    // CALCULATE CONFUSION MATRIX ENTRIES
+    /* prepare object category headers */
+    output_headers = m_object_classes;
+    vector<float>(output_headers.size(),0.0).swap(output_values);
+    /* find the index of the target object class in the headers for later use */
+    int target_idx;
+    {
+        vector<string>::iterator target_idx_it = std::find(output_headers.begin(),output_headers.end(),obj_class);
+        /* if the target class can not be found, raise an exception */
+        if (target_idx_it == output_headers.end())
+        {
+            string err_msg = "could not find the target object class '" + obj_class + "' in list of valid classes.";
+            CV_Error(Error::StsError,err_msg.c_str());
+        }
+        /* convert iterator to index */
+        target_idx = (int)std::distance(output_headers.begin(),target_idx_it);
+    }
+
+    /* prepare variables related to calculating recall if using the recall threshold */
+    int retrieved_hits = 0;
+    int total_relevant = 0;
+    if (cond == CV_VOC_CCOND_RECALL)
+    {
+        vector<char> ground_truth;
+        /* in order to calculate the total number of relevant images for normalization of recall
+            it's necessary to extract the ground truth for the images under consideration */
+        getClassifierGroundTruth(obj_class, images, ground_truth);
+#ifdef CV_CXX11
+        total_relevant = (int)std::count_if(ground_truth.begin(),ground_truth.end(),
+                [](const char a) { return a == (char)1; });
+#else
+        total_relevant = (int)std::count_if(ground_truth.begin(),ground_truth.end(),std::bind2nd(std::equal_to<char>(),(char)1));
+#endif
+    }
+
+    /* iterate through images */
+    vector<ObdObject> img_objects;
+    vector<VocObjectData> img_object_data;
+    int total_images = 0;
+    for (size_t image_idx = 0; image_idx < images.size(); ++image_idx)
+    {
+        /* if using the score as the break condition, check for it now */
+        if (cond == CV_VOC_CCOND_SCORETHRESH)
+        {
+            if (scores[ranking[image_idx]] <= threshold) break;
+        }
+        /* if continuing for this iteration, increment the image counter for later normalization */
+        ++total_images;
+        /* for each image retrieve the objects contained */
+        getObjects(images[ranking[image_idx]].id, img_objects, img_object_data);
+        //check if the tested for object class is present
+        if (getClassifierGroundTruthImage(obj_class, images[ranking[image_idx]].id))
+        {
+            //if the target class is present, assign fully to the target class element in the confusion matrix row
+            output_values[target_idx] += 1.0;
+            if (cond == CV_VOC_CCOND_RECALL) ++retrieved_hits;
+        } else {
+            //first delete all objects marked as difficult
+            for (size_t obj_idx = 0; obj_idx < img_objects.size(); ++obj_idx)
+            {
+                if (img_object_data[obj_idx].difficult == true)
+                {
+                    vector<ObdObject>::iterator it1 = img_objects.begin();
+                    std::advance(it1,obj_idx);
+                    img_objects.erase(it1);
+                    vector<VocObjectData>::iterator it2 = img_object_data.begin();
+                    std::advance(it2,obj_idx);
+                    img_object_data.erase(it2);
+                    --obj_idx;
+                }
+            }
+            //if the target class is not present, add values to the confusion matrix row in equal proportions to all objects present in the image
+            for (size_t obj_idx = 0; obj_idx < img_objects.size(); ++obj_idx)
+            {
+                //find the index of the currently considered object
+                vector<string>::iterator class_idx_it = std::find(output_headers.begin(),output_headers.end(),img_objects[obj_idx].object_class);
+                //if the class name extracted from the ground truth file could not be found in the list of available classes, raise an exception
+                if (class_idx_it == output_headers.end())
+                {
+                    string err_msg = "could not find object class '" + img_objects[obj_idx].object_class + "' specified in the ground truth file of '" + images[ranking[image_idx]].id +"'in list of valid classes.";
+                    CV_Error(Error::StsError,err_msg.c_str());
+                }
+                /* convert iterator to index */
+                int class_idx = (int)std::distance(output_headers.begin(),class_idx_it);
+                //add to confusion matrix row in proportion
+                output_values[class_idx] += 1.f/static_cast<float>(img_objects.size());
+            }
+        }
+        //check break conditions if breaking on certain level of recall
+        if (cond == CV_VOC_CCOND_RECALL)
+        {
+            if(static_cast<float>(retrieved_hits)/static_cast<float>(total_relevant) >= threshold) break;
+        }
+    }
+    /* finally, normalize confusion matrix row */
+    for (vector<float>::iterator it = output_values.begin(); it < output_values.end(); ++it)
+    {
+        (*it) /= static_cast<float>(total_images);
+    }
+}
+
+// NOTE: doesn't ignore repeated detections
+void VocData::calcDetectorConfMatRow(const string& obj_class, const ObdDatasetType dataset, const vector<ObdImage>& images, const vector<vector<float> >& scores, const vector<vector<Rect> >& bounding_boxes, const VocConfCond cond, const float threshold, vector<string>& output_headers, vector<float>& output_values, bool ignore_difficult)
+{
+    CV_Assert(images.size() == scores.size());
+    CV_Assert(images.size() == bounding_boxes.size());
+
+    //collapse scores and ground_truth vectors into 1D vectors to allow ranking
+    /* define final flat vectors */
+    vector<string> images_flat;
+    vector<float> scores_flat;
+    vector<Rect> bounding_boxes_flat;
+    {
+        /* first count how many objects to allow preallocation */
+        int obj_count = 0;
+        CV_Assert(scores.size() == bounding_boxes.size());
+        for (size_t img_idx = 0; img_idx < scores.size(); ++img_idx)
+        {
+            CV_Assert(scores[img_idx].size() == bounding_boxes[img_idx].size());
+            for (size_t obj_idx = 0; obj_idx < scores[img_idx].size(); ++obj_idx)
+            {
+                ++obj_count;
+            }
+        }
+        /* preallocate vectors */
+        images_flat.resize(obj_count);
+        scores_flat.resize(obj_count);
+        bounding_boxes_flat.resize(obj_count);
+        /* now copy across to preallocated vectors */
+        int flat_pos = 0;
+        for (size_t img_idx = 0; img_idx < scores.size(); ++img_idx)
+        {
+            for (size_t obj_idx = 0; obj_idx < scores[img_idx].size(); ++obj_idx)
+            {
+                images_flat[flat_pos] = images[img_idx].id;
+                scores_flat[flat_pos] = scores[img_idx][obj_idx];
+                bounding_boxes_flat[flat_pos] = bounding_boxes[img_idx][obj_idx];
+                ++flat_pos;
+            }
+        }
+    }
+
+    // SORT RESULTS BY THEIR SCORE
+    /* 1. store sorting order in 'ranking' */
+    vector<size_t> ranking;
+    VocData::getSortOrder(scores_flat, ranking);
+
+    // CALCULATE CONFUSION MATRIX ENTRIES
+    /* prepare object category headers */
+    output_headers = m_object_classes;
+    output_headers.push_back("background");
+    vector<float>(output_headers.size(),0.0).swap(output_values);
+
+    /* prepare variables related to calculating recall if using the recall threshold */
+    int retrieved_hits = 0;
+    int total_relevant = 0;
+    if (cond == CV_VOC_CCOND_RECALL)
+    {
+//        vector<char> ground_truth;
+//        /* in order to calculate the total number of relevant images for normalization of recall
+//            it's necessary to extract the ground truth for the images under consideration */
+//        getClassifierGroundTruth(obj_class, images, ground_truth);
+//        total_relevant = std::count_if(ground_truth.begin(),ground_truth.end(),std::bind2nd(std::equal_to<bool>(),true));
+        /* calculate the total number of objects in the ground truth for the current dataset */
+        vector<ObdImage> gt_images;
+        vector<char> gt_object_present;
+        getClassImages(obj_class, dataset, gt_images, gt_object_present);
+
+        for (size_t image_idx = 0; image_idx < gt_images.size(); ++image_idx)
+        {
+            vector<ObdObject> gt_img_objects;
+            vector<VocObjectData> gt_img_object_data;
+            getObjects(gt_images[image_idx].id, gt_img_objects, gt_img_object_data);
+            for (size_t obj_idx = 0; obj_idx < gt_img_objects.size(); ++obj_idx)
+            {
+                if (gt_img_objects[obj_idx].object_class == obj_class)
+                {
+                    if ((gt_img_object_data[obj_idx].difficult == false) || (ignore_difficult == false))
+                        ++total_relevant;
+                }
+            }
+        }
+    }
+
+    /* iterate through objects */
+    vector<ObdObject> img_objects;
+    vector<VocObjectData> img_object_data;
+    int total_objects = 0;
+    for (size_t image_idx = 0; image_idx < images.size(); ++image_idx)
+    {
+        /* if using the score as the break condition, check for it now */
+        if (cond == CV_VOC_CCOND_SCORETHRESH)
+        {
+            if (scores_flat[ranking[image_idx]] <= threshold) break;
+        }
+        /* increment the image counter for later normalization */
+        ++total_objects;
+        /* for each image retrieve the objects contained */
+        getObjects(images[ranking[image_idx]].id, img_objects, img_object_data);
+
+        //find the ground truth object which has the highest overlap score with the detected object
+        float maxov = -1.0;
+        int max_gt_obj_idx = -1;
+        //-- for each detected object iterate through objects present in ground truth --
+        for (size_t gt_obj_idx = 0; gt_obj_idx < img_objects.size(); ++gt_obj_idx)
+        {
+            //check difficulty flag
+            if (ignore_difficult || (img_object_data[gt_obj_idx].difficult == false))
+            {
+                //if the class matches, then check if the detected object and ground truth object overlap by a sufficient margin
+                float ov = testBoundingBoxesForOverlap(bounding_boxes_flat[ranking[image_idx]], img_objects[gt_obj_idx].boundingBox);
+                if (ov != -1.f)
+                {
+                    //if all conditions are met store the overlap score and index (as objects are assigned to the highest scoring match)
+                    if (ov > maxov)
+                    {
+                        maxov = ov;
+                        max_gt_obj_idx = (int)gt_obj_idx;
+                    }
+                }
+            }
+        }
+
+        //assign to appropriate object class if an object was detected
+        if (maxov != -1.0)
+        {
+            //find the index of the currently considered object
+            vector<string>::iterator class_idx_it = std::find(output_headers.begin(),output_headers.end(),img_objects[max_gt_obj_idx].object_class);
+            //if the class name extracted from the ground truth file could not be found in the list of available classes, raise an exception
+            if (class_idx_it == output_headers.end())
+            {
+                string err_msg = "could not find object class '" + img_objects[max_gt_obj_idx].object_class + "' specified in the ground truth file of '" + images[ranking[image_idx]].id +"'in list of valid classes.";
+                CV_Error(Error::StsError,err_msg.c_str());
+            }
+            /* convert iterator to index */
+            int class_idx = (int)std::distance(output_headers.begin(),class_idx_it);
+            //add to confusion matrix row in proportion
+            output_values[class_idx] += 1.0;
+        } else {
+            //otherwise assign to background class
+            output_values[output_values.size()-1] += 1.0;
+        }
+
+        //check break conditions if breaking on certain level of recall
+        if (cond == CV_VOC_CCOND_RECALL)
+        {
+            if(static_cast<float>(retrieved_hits)/static_cast<float>(total_relevant) >= threshold) break;
+        }
+    }
+
+    /* finally, normalize confusion matrix row */
+    for (vector<float>::iterator it = output_values.begin(); it < output_values.end(); ++it)
+    {
+        (*it) /= static_cast<float>(total_objects);
+    }
+}
+
+//Save Precision-Recall results to a p-r curve in GNUPlot format
+//--------------------------------------------------------------
+//INPUTS:
+// - output_file        The file to which to save the GNUPlot data file. If only a filename is specified, the data
+//                      file is saved to the standard VOC results directory.
+// - precision          Vector of precisions as returned from calcClassifier/DetectorPrecRecall
+// - recall             Vector of recalls as returned from calcClassifier/DetectorPrecRecall
+// - ap                ap as returned from calcClassifier/DetectorPrecRecall
+// - (title)            Title to use for the plot (if not specified, just the ap is printed as the title)
+//                      This also specifies the filename of the output file if printing to pdf
+// - (plot_type)        Specifies whether to instruct GNUPlot to save to a PDF file (CV_VOC_PLOT_PDF) or directly
+//                      to screen (CV_VOC_PLOT_SCREEN) in the datafile
+//NOTES:
+// The GNUPlot data file can be executed using GNUPlot from the commandline in the following way:
+//      >> GNUPlot <output_file>
+// This will then display the p-r curve on the screen or save it to a pdf file depending on plot_type
+
+void VocData::savePrecRecallToGnuplot(const string& output_file, const vector<float>& precision, const vector<float>& recall, const float ap, const string title, const VocPlotType plot_type)
+{
+    string output_file_std = checkFilenamePathsep(output_file);
+
+    //if no directory is specified, by default save the output file in the results directory
+//    if (output_file_std.find("/") == output_file_std.npos)
+//    {
+//        output_file_std = m_results_directory + output_file_std;
+//    }
+
+    std::ofstream plot_file(output_file_std.c_str());
+
+    if (plot_file.is_open())
+    {
+        plot_file << "set xrange [0:1]" << endl;
+        plot_file << "set yrange [0:1]" << endl;
+        plot_file << "set size square" << endl;
+        string title_text = title;
+        if (title_text.size() == 0) title_text = "Precision-Recall Curve";
+        plot_file << "set title \"" << title_text << " (ap: " << ap << ")\"" << endl;
+        plot_file << "set xlabel \"Recall\"" << endl;
+        plot_file << "set ylabel \"Precision\"" << endl;
+        plot_file << "set style data lines" << endl;
+        plot_file << "set nokey" << endl;
+        if (plot_type == CV_VOC_PLOT_PNG)
+        {
+            plot_file << "set terminal png" << endl;
+            string pdf_filename;
+            if (title.size() != 0)
+            {
+                pdf_filename = title;
+            } else {
+                pdf_filename = "prcurve";
+            }
+            plot_file << "set out \"" << title << ".png\"" << endl;
+        }
+        plot_file << "plot \"-\" using 1:2" << endl;
+        plot_file << "# X Y" << endl;
+        CV_Assert(precision.size() == recall.size());
+        for (size_t i = 0; i < precision.size(); ++i)
+        {
+            plot_file << "  " << recall[i] << " " << precision[i] << endl;
+        }
+        plot_file << "end" << endl;
+        if (plot_type == CV_VOC_PLOT_SCREEN)
+        {
+            plot_file << "pause -1" << endl;
+        }
+        plot_file.close();
+    } else {
+        string err_msg = "could not open plot file '" + output_file_std + "' for writing.";
+        CV_Error(Error::StsError,err_msg.c_str());
+    }
+}
+
+void VocData::readClassifierGroundTruth(const string& obj_class, const ObdDatasetType dataset, vector<ObdImage>& images, vector<char>& object_present)
+{
+    images.clear();
+
+    string gtFilename = m_class_imageset_path;
+    gtFilename.replace(gtFilename.find("%s"),2,obj_class);
+    if (dataset == CV_OBD_TRAIN)
+    {
+        gtFilename.replace(gtFilename.find("%s"),2,m_train_set);
+    } else {
+        gtFilename.replace(gtFilename.find("%s"),2,m_test_set);
+    }
+
+    vector<string> image_codes;
+    readClassifierGroundTruth(gtFilename, image_codes, object_present);
+
+    convertImageCodesToObdImages(image_codes, images);
+}
+
+void VocData::readClassifierResultsFile(const std:: string& input_file, vector<ObdImage>& images, vector<float>& scores)
+{
+    images.clear();
+
+    string input_file_std = checkFilenamePathsep(input_file);
+
+    //if no directory is specified, by default search for the input file in the results directory
+//    if (input_file_std.find("/") == input_file_std.npos)
+//    {
+//        input_file_std = m_results_directory + input_file_std;
+//    }
+
+    vector<string> image_codes;
+    readClassifierResultsFile(input_file_std, image_codes, scores);
+
+    convertImageCodesToObdImages(image_codes, images);
+}
+
+void VocData::readDetectorResultsFile(const string& input_file, vector<ObdImage>& images, vector<vector<float> >& scores, vector<vector<Rect> >& bounding_boxes)
+{
+    images.clear();
+
+    string input_file_std = checkFilenamePathsep(input_file);
+
+    //if no directory is specified, by default search for the input file in the results directory
+//    if (input_file_std.find("/") == input_file_std.npos)
+//    {
+//        input_file_std = m_results_directory + input_file_std;
+//    }
+
+    vector<string> image_codes;
+    readDetectorResultsFile(input_file_std, image_codes, scores, bounding_boxes);
+
+    convertImageCodesToObdImages(image_codes, images);
+}
+
+const vector<string>& VocData::getObjectClasses()
+{
+    return m_object_classes;
+}
+
+//string VocData::getResultsDirectory()
+//{
+//    return m_results_directory;
+//}
+
+//---------------------------------------------------------
+// Protected Functions ------------------------------------
+//---------------------------------------------------------
+
+static string getVocName( const string& vocPath )
+{
+    size_t found = vocPath.rfind( '/' );
+    if( found == string::npos )
+    {
+        found = vocPath.rfind( '\\' );
+        if( found == string::npos )
+            return vocPath;
+    }
+    return vocPath.substr(found + 1, vocPath.size() - found);
+}
+
+void VocData::initVoc( const string& vocPath, const bool useTestDataset )
+{
+    initVoc2007to2010( vocPath, useTestDataset );
+}
+
+//Initialize file paths and settings for the VOC 2010 dataset
+//-----------------------------------------------------------
+void VocData::initVoc2007to2010( const string& vocPath, const bool useTestDataset )
+{
+    //check format of root directory and modify if necessary
+
+    m_vocName = getVocName( vocPath );
+
+    CV_Assert( !m_vocName.compare("VOC2007") || !m_vocName.compare("VOC2008") ||
+               !m_vocName.compare("VOC2009") || !m_vocName.compare("VOC2010") );
+
+    m_vocPath = checkFilenamePathsep( vocPath, true );
+
+    if (useTestDataset)
+    {
+        m_train_set = "trainval";
+        m_test_set = "test";
+    } else {
+        m_train_set = "train";
+        m_test_set = "val";
+    }
+
+    // initialize main classification/detection challenge paths
+    m_annotation_path = m_vocPath + "/Annotations/%s.xml";
+    m_image_path = m_vocPath + "/JPEGImages/%s.jpg";
+    m_imageset_path = m_vocPath + "/ImageSets/Main/%s.txt";
+    m_class_imageset_path = m_vocPath + "/ImageSets/Main/%s_%s.txt";
+
+    //define available object_classes for VOC2010 dataset
+    m_object_classes.push_back("aeroplane");
+    m_object_classes.push_back("bicycle");
+    m_object_classes.push_back("bird");
+    m_object_classes.push_back("boat");
+    m_object_classes.push_back("bottle");
+    m_object_classes.push_back("bus");
+    m_object_classes.push_back("car");
+    m_object_classes.push_back("cat");
+    m_object_classes.push_back("chair");
+    m_object_classes.push_back("cow");
+    m_object_classes.push_back("diningtable");
+    m_object_classes.push_back("dog");
+    m_object_classes.push_back("horse");
+    m_object_classes.push_back("motorbike");
+    m_object_classes.push_back("person");
+    m_object_classes.push_back("pottedplant");
+    m_object_classes.push_back("sheep");
+    m_object_classes.push_back("sofa");
+    m_object_classes.push_back("train");
+    m_object_classes.push_back("tvmonitor");
+
+    m_min_overlap = 0.5;
+
+    //up until VOC 2010, ap was calculated by sampling p-r curve, not taking complete curve
+    m_sampled_ap = ((m_vocName == "VOC2007") || (m_vocName == "VOC2008") || (m_vocName == "VOC2009"));
+}
+
+//Read a VOC classification ground truth text file for a given object class and dataset
+//-------------------------------------------------------------------------------------
+//INPUTS:
+// - filename           The path of the text file to read
+//OUTPUTS:
+// - image_codes        VOC image codes extracted from the GT file in the form 20XX_XXXXXX where the first four
+//                          digits specify the year of the dataset, and the last group specifies a unique ID
+// - object_present     For each image in the 'image_codes' array, specifies whether the object class described
+//                          in the loaded GT file is present or not
+void VocData::readClassifierGroundTruth(const string& filename, vector<string>& image_codes, vector<char>& object_present)
+{
+    image_codes.clear();
+    object_present.clear();
+
+    std::ifstream gtfile(filename.c_str());
+    if (!gtfile.is_open())
+    {
+        string err_msg = "could not open VOC ground truth textfile '" + filename + "'.";
+        CV_Error(Error::StsError,err_msg.c_str());
+    }
+
+    string line;
+    string image;
+    int obj_present = 0;
+    while (!gtfile.eof())
+    {
+        std::getline(gtfile,line);
+        std::istringstream iss(line);
+        iss >> image >> obj_present;
+        if (!iss.fail())
+        {
+            image_codes.push_back(image);
+            object_present.push_back(obj_present == 1);
+        } else {
+            if (!gtfile.eof()) CV_Error(Error::StsParseError,"error parsing VOC ground truth textfile.");
+        }
+    }
+    gtfile.close();
+}
+
+void VocData::readClassifierResultsFile(const string& input_file, vector<string>& image_codes, vector<float>& scores)
+{
+    //check if results file exists
+    std::ifstream result_file(input_file.c_str());
+    if (result_file.is_open())
+    {
+        string line;
+        string image;
+        float score;
+        //read in the results file
+        while (!result_file.eof())
+        {
+            std::getline(result_file,line);
+            std::istringstream iss(line);
+            iss >> image >> score;
+            if (!iss.fail())
+            {
+                image_codes.push_back(image);
+                scores.push_back(score);
+            } else {
+                if(!result_file.eof()) CV_Error(Error::StsParseError,"error parsing VOC classifier results file.");
+            }
+        }
+        result_file.close();
+    } else {
+        string err_msg = "could not open classifier results file '" + input_file + "' for reading.";
+        CV_Error(Error::StsError,err_msg.c_str());
+    }
+}
+
+void VocData::readDetectorResultsFile(const string& input_file, vector<string>& image_codes, vector<vector<float> >& scores, vector<vector<Rect> >& bounding_boxes)
+{
+    image_codes.clear();
+    scores.clear();
+    bounding_boxes.clear();
+
+    //check if results file exists
+    std::ifstream result_file(input_file.c_str());
+    if (result_file.is_open())
+    {
+        string line;
+        string image;
+        Rect bounding_box;
+        float score;
+        //read in the results file
+        while (!result_file.eof())
+        {
+            std::getline(result_file,line);
+            std::istringstream iss(line);
+            iss >> image >> score >> bounding_box.x >> bounding_box.y >> bounding_box.width >> bounding_box.height;
+            if (!iss.fail())
+            {
+                //convert right and bottom positions to width and height
+                bounding_box.width -= bounding_box.x;
+                bounding_box.height -= bounding_box.y;
+                //convert to 0-indexing
+                bounding_box.x -= 1;
+                bounding_box.y -= 1;
+                //store in output vectors
+                /* first check if the current image code has been seen before */
+                vector<string>::iterator image_codes_it = std::find(image_codes.begin(),image_codes.end(),image);
+                if (image_codes_it == image_codes.end())
+                {
+                    image_codes.push_back(image);
+                    vector<float> score_vect(1);
+                    score_vect[0] = score;
+                    scores.push_back(score_vect);
+                    vector<Rect> bounding_box_vect(1);
+                    bounding_box_vect[0] = bounding_box;
+                    bounding_boxes.push_back(bounding_box_vect);
+                } else {
+                    /* if the image index has been seen before, add the current object below it in the 2D arrays */
+                    int image_idx = (int)std::distance(image_codes.begin(),image_codes_it);
+                    scores[image_idx].push_back(score);
+                    bounding_boxes[image_idx].push_back(bounding_box);
+                }
+            } else {
+                if(!result_file.eof()) CV_Error(Error::StsParseError,"error parsing VOC detector results file.");
+            }
+        }
+        result_file.close();
+    } else {
+        string err_msg = "could not open detector results file '" + input_file + "' for reading.";
+        CV_Error(Error::StsError,err_msg.c_str());
+    }
+}
+
+
+//Read a VOC annotation xml file for a given image
+//------------------------------------------------
+//INPUTS:
+// - filename           The path of the xml file to read
+//OUTPUTS:
+// - objects            Array of VocObject describing all object instances present in the given image
+void VocData::extractVocObjects(const string filename, vector<ObdObject>& objects, vector<VocObjectData>& object_data)
+{
+#ifdef PR_DEBUG
+    int block = 1;
+    cout << "SAMPLE VOC OBJECT EXTRACTION for " << filename << ":" << endl;
+#endif
+    objects.clear();
+    object_data.clear();
+
+    string contents, object_contents, tag_contents;
+
+    readFileToString(filename, contents);
+
+    //keep on extracting 'object' blocks until no more can be found
+    if (extractXMLBlock(contents, "annotation", 0, contents) != -1)
+    {
+        int searchpos = 0;
+        searchpos = extractXMLBlock(contents, "object", searchpos, object_contents);
+        while (searchpos != -1)
+        {
+#ifdef PR_DEBUG
+            cout << "SEARCHPOS:" << searchpos << endl;
+            cout << "start block " << block << " ---------" << endl;
+            cout << object_contents << endl;
+            cout << "end block " << block << " -----------" << endl;
+            ++block;
+#endif
+
+            ObdObject object;
+            VocObjectData object_d;
+
+            //object class -------------
+
+            if (extractXMLBlock(object_contents, "name", 0, tag_contents) == -1) CV_Error(Error::StsError,"missing <name> tag in object definition of '" + filename + "'");
+            object.object_class.swap(tag_contents);
+
+            //object bounding box -------------
+
+            int xmax, xmin, ymax, ymin;
+
+            if (extractXMLBlock(object_contents, "xmax", 0, tag_contents) == -1) CV_Error(Error::StsError,"missing <xmax> tag in object definition of '" + filename + "'");
+            xmax = stringToInteger(tag_contents);
+
+            if (extractXMLBlock(object_contents, "xmin", 0, tag_contents) == -1) CV_Error(Error::StsError,"missing <xmin> tag in object definition of '" + filename + "'");
+            xmin = stringToInteger(tag_contents);
+
+            if (extractXMLBlock(object_contents, "ymax", 0, tag_contents) == -1) CV_Error(Error::StsError,"missing <ymax> tag in object definition of '" + filename + "'");
+            ymax = stringToInteger(tag_contents);
+
+            if (extractXMLBlock(object_contents, "ymin", 0, tag_contents) == -1) CV_Error(Error::StsError,"missing <ymin> tag in object definition of '" + filename + "'");
+            ymin = stringToInteger(tag_contents);
+
+            object.boundingBox.x = xmin-1;      //convert to 0-based indexing
+            object.boundingBox.width = xmax - xmin;
+            object.boundingBox.y = ymin-1;
+            object.boundingBox.height = ymax - ymin;
+
+            CV_Assert(xmin != 0);
+            CV_Assert(xmax > xmin);
+            CV_Assert(ymin != 0);
+            CV_Assert(ymax > ymin);
+
+
+            //object tags -------------
+
+            if (extractXMLBlock(object_contents, "difficult", 0, tag_contents) != -1)
+            {
+                object_d.difficult = (tag_contents == "1");
+            } else object_d.difficult = false;
+            if (extractXMLBlock(object_contents, "occluded", 0, tag_contents) != -1)
+            {
+                object_d.occluded = (tag_contents == "1");
+            } else object_d.occluded = false;
+            if (extractXMLBlock(object_contents, "truncated", 0, tag_contents) != -1)
+            {
+                object_d.truncated = (tag_contents == "1");
+            } else object_d.truncated = false;
+            if (extractXMLBlock(object_contents, "pose", 0, tag_contents) != -1)
+            {
+                if (tag_contents == "Frontal") object_d.pose = CV_VOC_POSE_FRONTAL;
+                if (tag_contents == "Rear") object_d.pose = CV_VOC_POSE_REAR;
+                if (tag_contents == "Left") object_d.pose = CV_VOC_POSE_LEFT;
+                if (tag_contents == "Right") object_d.pose = CV_VOC_POSE_RIGHT;
+            }
+
+            //add to array of objects
+            objects.push_back(object);
+            object_data.push_back(object_d);
+
+            //extract next 'object' block from file if it exists
+            searchpos = extractXMLBlock(contents, "object", searchpos, object_contents);
+        }
+    }
+}
+
+//Converts an image identifier string in the format YYYY_XXXXXX to a single index integer of form XXXXXXYYYY
+//where Y represents a year and returns the image path
+//----------------------------------------------------------------------------------------------------------
+string VocData::getImagePath(const string& input_str)
+{
+    string path = m_image_path;
+    path.replace(path.find("%s"),2,input_str);
+    return path;
+}
+
+//Tests two boundary boxes for overlap (using the intersection over union metric) and returns the overlap if the objects
+//defined by the two bounding boxes are considered to be matched according to the criterion outlined in
+//the VOC documentation [namely intersection/union > some threshold] otherwise returns -1.0 (no match)
+//----------------------------------------------------------------------------------------------------------
+float VocData::testBoundingBoxesForOverlap(const Rect detection, const Rect ground_truth)
+{
+    int detection_x2 = detection.x + detection.width;
+    int detection_y2 = detection.y + detection.height;
+    int ground_truth_x2 = ground_truth.x + ground_truth.width;
+    int ground_truth_y2 = ground_truth.y + ground_truth.height;
+    //first calculate the boundaries of the intersection of the rectangles
+    int intersection_x = std::max(detection.x, ground_truth.x); //rightmost left
+    int intersection_y = std::max(detection.y, ground_truth.y); //bottommost top
+    int intersection_x2 = std::min(detection_x2, ground_truth_x2); //leftmost right
+    int intersection_y2 = std::min(detection_y2, ground_truth_y2); //topmost bottom
+    //then calculate the width and height of the intersection rect
+    int intersection_width = intersection_x2 - intersection_x + 1;
+    int intersection_height = intersection_y2 - intersection_y + 1;
+    //if there is no overlap then return false straight away
+    if ((intersection_width <= 0) || (intersection_height <= 0)) return -1.0;
+    //otherwise calculate the intersection
+    int intersection_area = intersection_width*intersection_height;
+
+    //now calculate the union
+    int union_area = (detection.width+1)*(detection.height+1) + (ground_truth.width+1)*(ground_truth.height+1) - intersection_area;
+
+    //calculate the intersection over union and use as threshold as per VOC documentation
+    float overlap = static_cast<float>(intersection_area)/static_cast<float>(union_area);
+    if (overlap > m_min_overlap)
+    {
+        return overlap;
+    } else {
+        return -1.0;
+    }
+}
+
+//Extracts the object class and dataset from the filename of a VOC standard results text file, which takes
+//the format 'comp<n>_{cls/det}_<dataset>_<objclass>.txt'
+//----------------------------------------------------------------------------------------------------------
+void VocData::extractDataFromResultsFilename(const string& input_file, string& class_name, string& dataset_name)
+{
+    string input_file_std = checkFilenamePathsep(input_file);
+
+    size_t fnamestart = input_file_std.rfind("/");
+    size_t fnameend = input_file_std.rfind(".txt");
+
+    if ((fnamestart == input_file_std.npos) || (fnameend == input_file_std.npos))
+        CV_Error(Error::StsError,"Could not extract filename of results file.");
+
+    ++fnamestart;
+    if (fnamestart >= fnameend)
+        CV_Error(Error::StsError,"Could not extract filename of results file.");
+
+    //extract dataset and class names, triggering exception if the filename format is not correct
+    string filename = input_file_std.substr(fnamestart, fnameend-fnamestart);
+    size_t datasetstart = filename.find("_");
+    datasetstart = filename.find("_",datasetstart+1);
+    size_t classstart = filename.find("_",datasetstart+1);
+    //allow for appended index after a further '_' by discarding this part if it exists
+    size_t classend = filename.find("_",classstart+1);
+    if (classend == filename.npos) classend = filename.size();
+    if ((datasetstart == filename.npos) || (classstart == filename.npos))
+        CV_Error(Error::StsError,"Error parsing results filename. Is it in standard format of 'comp<n>_{cls/det}_<dataset>_<objclass>.txt'?");
+    ++datasetstart;
+    ++classstart;
+    if (((datasetstart-classstart) < 1) || ((classend-datasetstart) < 1))
+        CV_Error(Error::StsError,"Error parsing results filename. Is it in standard format of 'comp<n>_{cls/det}_<dataset>_<objclass>.txt'?");
+
+    dataset_name = filename.substr(datasetstart,classstart-datasetstart-1);
+    class_name = filename.substr(classstart,classend-classstart);
+}
+
+bool VocData::getClassifierGroundTruthImage(const string& obj_class, const string& id)
+{
+    /* if the classifier ground truth data for all images of the current class has not been loaded yet, load it now */
+    if (m_classifier_gt_all_ids.empty() || (m_classifier_gt_class != obj_class))
+    {
+        m_classifier_gt_all_ids.clear();
+        m_classifier_gt_all_present.clear();
+        m_classifier_gt_class = obj_class;
+        for (int i=0; i<2; ++i) //run twice (once over test set and once over training set)
+        {
+            //generate the filename of the classification ground-truth textfile for the object class
+            string gtFilename = m_class_imageset_path;
+            gtFilename.replace(gtFilename.find("%s"),2,obj_class);
+            if (i == 0)
+            {
+                gtFilename.replace(gtFilename.find("%s"),2,m_train_set);
+            } else {
+                gtFilename.replace(gtFilename.find("%s"),2,m_test_set);
+            }
+
+            //parse the ground truth file, storing in two separate vectors
+            //for the image code and the ground truth value
+            vector<string> image_codes;
+            vector<char> object_present;
+            readClassifierGroundTruth(gtFilename, image_codes, object_present);
+
+            m_classifier_gt_all_ids.insert(m_classifier_gt_all_ids.end(),image_codes.begin(),image_codes.end());
+            m_classifier_gt_all_present.insert(m_classifier_gt_all_present.end(),object_present.begin(),object_present.end());
+
+            CV_Assert(m_classifier_gt_all_ids.size() == m_classifier_gt_all_present.size());
+        }
+    }
+
+
+    //search for the image code
+    vector<string>::iterator it = find (m_classifier_gt_all_ids.begin(), m_classifier_gt_all_ids.end(), id);
+    if (it != m_classifier_gt_all_ids.end())
+    {
+        //image found, so return corresponding ground truth
+        return m_classifier_gt_all_present[std::distance(m_classifier_gt_all_ids.begin(),it)] != 0;
+    }
+    string err_msg = "could not find classifier ground truth for image '" + id + "' and class '" + obj_class + "'";
+    CV_Error(Error::StsError,err_msg.c_str());
+}
+
+//-------------------------------------------------------------------
+// Protected Functions (utility) ------------------------------------
+//-------------------------------------------------------------------
+
+//returns a vector containing indexes of the input vector in sorted ascending/descending order
+void VocData::getSortOrder(const vector<float>& values, vector<size_t>& order, bool descending)
+{
+    /* 1. store sorting order in 'order_pair' */
+    vector<std::pair<size_t, vector<float>::const_iterator> > order_pair(values.size());
+
+    size_t n = 0;
+    for (vector<float>::const_iterator it = values.begin(); it != values.end(); ++it, ++n)
+        order_pair[n] = make_pair(n, it);
+
+    std::sort(order_pair.begin(),order_pair.end(),orderingSorter());
+    if (descending == false) std::reverse(order_pair.begin(),order_pair.end());
+
+    vector<size_t>(order_pair.size()).swap(order);
+    for (size_t i = 0; i < order_pair.size(); ++i)
+    {
+        order[i] = order_pair[i].first;
+    }
+}
+
+void VocData::readFileToString(const string filename, string& file_contents)
+{
+    std::ifstream ifs(filename.c_str());
+    if (!ifs.is_open()) CV_Error(Error::StsError,"could not open text file");
+
+    stringstream oss;
+    oss << ifs.rdbuf();
+
+    file_contents = oss.str();
+}
+
+int VocData::stringToInteger(const string input_str)
+{
+    int result = 0;
+
+    stringstream ss(input_str);
+    if ((ss >> result).fail())
+    {
+        CV_Error(Error::StsBadArg,"could not perform string to integer conversion");
+    }
+    return result;
+}
+
+string VocData::integerToString(const int input_int)
+{
+    string result;
+
+    stringstream ss;
+    if ((ss << input_int).fail())
+    {
+        CV_Error(Error::StsBadArg,"could not perform integer to string conversion");
+    }
+    result = ss.str();
+    return result;
+}
+
+string VocData::checkFilenamePathsep( const string filename, bool add_trailing_slash )
+{
+    string filename_new = filename;
+
+    size_t pos = filename_new.find("\\\\");
+    while (pos != filename_new.npos)
+    {
+        filename_new.replace(pos,2,"/");
+        pos = filename_new.find("\\\\", pos);
+    }
+    pos = filename_new.find("\\");
+    while (pos != filename_new.npos)
+    {
+        filename_new.replace(pos,1,"/");
+        pos = filename_new.find("\\", pos);
+    }
+    if (add_trailing_slash)
+    {
+        //add training slash if this is missing
+        if (filename_new.rfind("/") != filename_new.length()-1) filename_new += "/";
+    }
+
+    return filename_new;
+}
+
+void VocData::convertImageCodesToObdImages(const vector<string>& image_codes, vector<ObdImage>& images)
+{
+    images.clear();
+    images.reserve(image_codes.size());
+
+    string path;
+    //transfer to output arrays
+    for (size_t i = 0; i < image_codes.size(); ++i)
+    {
+        //generate image path and indices from extracted string code
+        path = getImagePath(image_codes[i]);
+        images.push_back(ObdImage(image_codes[i], path));
+    }
+}
+
+//Extract text from within a given tag from an XML file
+//-----------------------------------------------------
+//INPUTS:
+// - src            XML source file
+// - tag            XML tag delimiting block to extract
+// - searchpos      position within src at which to start search
+//OUTPUTS:
+// - tag_contents   text extracted between <tag> and </tag> tags
+//RETURN VALUE:
+// - the position of the final character extracted in tag_contents within src
+//      (can be used to call extractXMLBlock recursively to extract multiple blocks)
+//      returns -1 if the tag could not be found
+int VocData::extractXMLBlock(const string src, const string tag, const int searchpos, string& tag_contents)
+{
+    size_t startpos, next_startpos, endpos;
+    int embed_count = 1;
+
+    //find position of opening tag
+    startpos = src.find("<" + tag + ">", searchpos);
+    if (startpos == string::npos) return -1;
+
+    //initialize endpos -
+    // start searching for end tag anywhere after opening tag
+    endpos = startpos;
+
+    //find position of next opening tag
+    next_startpos = src.find("<" + tag + ">", startpos+1);
+
+    //match opening tags with closing tags, and only
+    //accept final closing tag of same level as original
+    //opening tag
+    while (embed_count > 0)
+    {
+        endpos = src.find("</" + tag + ">", endpos+1);
+        if (endpos == string::npos) return -1;
+
+        //the next code is only executed if there are embedded tags with the same name
+        if (next_startpos != string::npos)
+        {
+            while (next_startpos<endpos)
+            {
+                //counting embedded start tags
+                ++embed_count;
+                next_startpos = src.find("<" + tag + ">", next_startpos+1);
+                if (next_startpos == string::npos) break;
+            }
+        }
+        //passing end tag so decrement nesting level
+        --embed_count;
+    }
+
+    //finally, extract the tag region
+    startpos += tag.length() + 2;
+    if (startpos > src.length()) return -1;
+    if (endpos > src.length()) return -1;
+    tag_contents = src.substr(startpos,endpos-startpos);
+    return static_cast<int>(endpos);
+}
+
+/****************************************************************************************\
+*                            Sample on image classification                             *
+\****************************************************************************************/
+//
+// This part of the code was a little refactor
+//
+struct DDMParams
+{
+    DDMParams() : detectorType("SURF"), descriptorType("SURF"), matcherType("BruteForce") {}
+    DDMParams( const string _detectorType, const string _descriptorType, const string& _matcherType ) :
+        detectorType(_detectorType), descriptorType(_descriptorType), matcherType(_matcherType){}
+    void read( const FileNode& fn )
+    {
+        fn["detectorType"] >> detectorType;
+        fn["descriptorType"] >> descriptorType;
+        fn["matcherType"] >> matcherType;
+    }
+    void write( FileStorage& fs ) const
+    {
+        fs << "detectorType" << detectorType;
+        fs << "descriptorType" << descriptorType;
+        fs << "matcherType" << matcherType;
+    }
+    void print() const
+    {
+        cout << "detectorType: " << detectorType << endl;
+        cout << "descriptorType: " << descriptorType << endl;
+        cout << "matcherType: " << matcherType << endl;
+    }
+
+    string detectorType;
+    string descriptorType;
+    string matcherType;
+};
+
+struct VocabTrainParams
+{
+    VocabTrainParams() : trainObjClass("chair"), vocabSize(1000), memoryUse(200), descProportion(0.3f) {}
+    VocabTrainParams( const string _trainObjClass, size_t _vocabSize, size_t _memoryUse, float _descProportion ) :
+            trainObjClass(_trainObjClass), vocabSize((int)_vocabSize), memoryUse((int)_memoryUse), descProportion(_descProportion) {}
+    void read( const FileNode& fn )
+    {
+        fn["trainObjClass"] >> trainObjClass;
+        fn["vocabSize"] >> vocabSize;
+        fn["memoryUse"] >> memoryUse;
+        fn["descProportion"] >> descProportion;
+    }
+    void write( FileStorage& fs ) const
+    {
+        fs << "trainObjClass" << trainObjClass;
+        fs << "vocabSize" << vocabSize;
+        fs << "memoryUse" << memoryUse;
+        fs << "descProportion" << descProportion;
+    }
+    void print() const
+    {
+        cout << "trainObjClass: " << trainObjClass << endl;
+        cout << "vocabSize: " << vocabSize << endl;
+        cout << "memoryUse: " << memoryUse << endl;
+        cout << "descProportion: " << descProportion << endl;
+    }
+
+
+    string trainObjClass; // Object class used for training visual vocabulary.
+                          // It shouldn't matter which object class is specified here - visual vocab will still be the same.
+    int vocabSize; //number of visual words in vocabulary to train
+    int memoryUse; // Memory to preallocate (in MB) when training vocab.
+                   // Change this depending on the size of the dataset/available memory.
+    float descProportion; // Specifies the number of descriptors to use from each image as a proportion of the total num descs.
+};
+
+struct SVMTrainParamsExt
+{
+    SVMTrainParamsExt() : descPercent(0.5f), targetRatio(0.4f), balanceClasses(true) {}
+    SVMTrainParamsExt( float _descPercent, float _targetRatio, bool _balanceClasses ) :
+            descPercent(_descPercent), targetRatio(_targetRatio), balanceClasses(_balanceClasses) {}
+    void read( const FileNode& fn )
+    {
+        fn["descPercent"] >> descPercent;
+        fn["targetRatio"] >> targetRatio;
+        fn["balanceClasses"] >> balanceClasses;
+    }
+    void write( FileStorage& fs ) const
+    {
+        fs << "descPercent" << descPercent;
+        fs << "targetRatio" << targetRatio;
+        fs << "balanceClasses" << balanceClasses;
+    }
+    void print() const
+    {
+        cout << "descPercent: " << descPercent << endl;
+        cout << "targetRatio: " << targetRatio << endl;
+        cout << "balanceClasses: " << balanceClasses << endl;
+    }
+
+    float descPercent; // Percentage of extracted descriptors to use for training.
+    float targetRatio; // Try to get this ratio of positive to negative samples (minimum).
+    bool balanceClasses;    // Balance class weights by number of samples in each (if true cSvmTrainTargetRatio is ignored).
+};
+
+static void readUsedParams( const FileNode& fn, string& vocName, DDMParams& ddmParams, VocabTrainParams& vocabTrainParams, SVMTrainParamsExt& svmTrainParamsExt )
+{
+    fn["vocName"] >> vocName;
+
+    FileNode currFn = fn;
+
+    currFn = fn["ddmParams"];
+    ddmParams.read( currFn );
+
+    currFn = fn["vocabTrainParams"];
+    vocabTrainParams.read( currFn );
+
+    currFn = fn["svmTrainParamsExt"];
+    svmTrainParamsExt.read( currFn );
+}
+
+static void writeUsedParams( FileStorage& fs, const string& vocName, const DDMParams& ddmParams, const VocabTrainParams& vocabTrainParams, const SVMTrainParamsExt& svmTrainParamsExt )
+{
+    fs << "vocName" << vocName;
+
+    fs << "ddmParams" << "{";
+    ddmParams.write(fs);
+    fs << "}";
+
+    fs << "vocabTrainParams" << "{";
+    vocabTrainParams.write(fs);
+    fs << "}";
+
+    fs << "svmTrainParamsExt" << "{";
+    svmTrainParamsExt.write(fs);
+    fs << "}";
+}
+
+static void printUsedParams( const string& vocPath, const string& resDir,
+                      const DDMParams& ddmParams, const VocabTrainParams& vocabTrainParams,
+                      const SVMTrainParamsExt& svmTrainParamsExt )
+{
+    cout << "CURRENT CONFIGURATION" << endl;
+    cout << "----------------------------------------------------------------" << endl;
+    cout << "vocPath: " << vocPath << endl;
+    cout << "resDir: " << resDir << endl;
+    cout << endl; ddmParams.print();
+    cout << endl; vocabTrainParams.print();
+    cout << endl; svmTrainParamsExt.print();
+    cout << "----------------------------------------------------------------" << endl << endl;
+}
+
+static bool readVocabulary( const string& filename, Mat& vocabulary )
+{
+    cout << "Reading vocabulary...";
+    FileStorage fs( filename, FileStorage::READ );
+    if( fs.isOpened() )
+    {
+        fs["vocabulary"] >> vocabulary;
+        cout << "done" << endl;
+        return true;
+    }
+    return false;
+}
+
+static bool writeVocabulary( const string& filename, const Mat& vocabulary )
+{
+    cout << "Saving vocabulary..." << endl;
+    FileStorage fs( filename, FileStorage::WRITE );
+    if( fs.isOpened() )
+    {
+        fs << "vocabulary" << vocabulary;
+        return true;
+    }
+    return false;
+}
+
+static Mat trainVocabulary( const string& filename, VocData& vocData, const VocabTrainParams& trainParams,
+                     const Ptr<FeatureDetector>& fdetector, const Ptr<DescriptorExtractor>& dextractor )
+{
+    Mat vocabulary;
+    if( !readVocabulary( filename, vocabulary) )
+    {
+        CV_Assert( dextractor->descriptorType() == CV_32FC1 );
+        const int elemSize = CV_ELEM_SIZE(dextractor->descriptorType());
+        const int descByteSize = dextractor->descriptorSize() * elemSize;
+        const int bytesInMB = 1048576;
+        const int maxDescCount = (trainParams.memoryUse * bytesInMB) / descByteSize; // Total number of descs to use for training.
+
+        cout << "Extracting VOC data..." << endl;
+        vector<ObdImage> images;
+        vector<char> objectPresent;
+        vocData.getClassImages( trainParams.trainObjClass, CV_OBD_TRAIN, images, objectPresent );
+
+        cout << "Computing descriptors..." << endl;
+        RNG& rng = theRNG();
+        TermCriteria terminate_criterion;
+        terminate_criterion.epsilon = FLT_EPSILON;
+        BOWKMeansTrainer bowTrainer( trainParams.vocabSize, terminate_criterion, 3, KMEANS_PP_CENTERS );
+
+        while( images.size() > 0 )
+        {
+            if( bowTrainer.descriptorsCount() > maxDescCount )
+            {
+#ifdef DEBUG_DESC_PROGRESS
+                cout << "Breaking due to full memory ( descriptors count = " << bowTrainer.descriptorsCount()
+                        << "; descriptor size in bytes = " << descByteSize << "; all used memory = "
+                        << bowTrainer.descriptorsCount()*descByteSize << endl;
+#endif
+                break;
+            }
+
+            // Randomly pick an image from the dataset which hasn't yet been seen
+            // and compute the descriptors from that image.
+            int randImgIdx = rng( (unsigned)images.size() );
+            Mat colorImage = imread( images[randImgIdx].path );
+            vector<KeyPoint> imageKeypoints;
+            fdetector->detect( colorImage, imageKeypoints );
+            Mat imageDescriptors;
+            dextractor->compute( colorImage, imageKeypoints, imageDescriptors );
+
+            //check that there were descriptors calculated for the current image
+            if( !imageDescriptors.empty() )
+            {
+                int descCount = imageDescriptors.rows;
+                // Extract trainParams.descProportion descriptors from the image, breaking if the 'allDescriptors' matrix becomes full
+                int descsToExtract = static_cast<int>(trainParams.descProportion * static_cast<float>(descCount));
+                // Fill mask of used descriptors
+                vector<char> usedMask( descCount, false );
+                fill( usedMask.begin(), usedMask.begin() + descsToExtract, true );
+                for( int i = 0; i < descCount; i++ )
+                {
+                    int i1 = rng(descCount), i2 = rng(descCount);
+                    char tmp = usedMask[i1]; usedMask[i1] = usedMask[i2]; usedMask[i2] = tmp;
+                }
+
+                for( int i = 0; i < descCount; i++ )
+                {
+                    if( usedMask[i] && bowTrainer.descriptorsCount() < maxDescCount )
+                        bowTrainer.add( imageDescriptors.row(i) );
+                }
+            }
+
+#ifdef DEBUG_DESC_PROGRESS
+            cout << images.size() << " images left, " << images[randImgIdx].id << " processed - "
+                    <</* descs_extracted << "/" << image_descriptors.rows << " extracted - " << */
+                    cvRound((static_cast<double>(bowTrainer.descriptorsCount())/static_cast<double>(maxDescCount))*100.0)
+                    << " % memory used" << ( imageDescriptors.empty() ? " -> no descriptors extracted, skipping" : "") << endl;
+#endif
+
+            // Delete the current element from images so it is not added again
+            images.erase( images.begin() + randImgIdx );
+        }
+
+        cout << "Maximum allowed descriptor count: " << maxDescCount << ", Actual descriptor count: " << bowTrainer.descriptorsCount() << endl;
+
+        cout << "Training vocabulary..." << endl;
+        vocabulary = bowTrainer.cluster();
+
+        if( !writeVocabulary(filename, vocabulary) )
+        {
+            cout << "Error: file " << filename << " can not be opened to write" << endl;
+            exit(-1);
+        }
+    }
+    return vocabulary;
+}
+
+static bool readBowImageDescriptor( const string& file, Mat& bowImageDescriptor )
+{
+    FileStorage fs( file, FileStorage::READ );
+    if( fs.isOpened() )
+    {
+        fs["imageDescriptor"] >> bowImageDescriptor;
+        return true;
+    }
+    return false;
+}
+
+static bool writeBowImageDescriptor( const string& file, const Mat& bowImageDescriptor )
+{
+    FileStorage fs( file, FileStorage::WRITE );
+    if( fs.isOpened() )
+    {
+        fs << "imageDescriptor" << bowImageDescriptor;
+        return true;
+    }
+    return false;
+}
+
+// Load in the bag of words vectors for a set of images, from file if possible
+static void calculateImageDescriptors( const vector<ObdImage>& images, vector<Mat>& imageDescriptors,
+                                Ptr<BOWImgDescriptorExtractor>& bowExtractor, const Ptr<FeatureDetector>& fdetector,
+                                const string& resPath )
+{
+    CV_Assert( !bowExtractor->getVocabulary().empty() );
+    imageDescriptors.resize( images.size() );
+
+    for( size_t i = 0; i < images.size(); i++ )
+    {
+        string filename = resPath + bowImageDescriptorsDir + "/" + images[i].id + ".xml.gz";
+        if( readBowImageDescriptor( filename, imageDescriptors[i] ) )
+        {
+#ifdef DEBUG_DESC_PROGRESS
+            cout << "Loaded bag of word vector for image " << i+1 << " of " << images.size() << " (" << images[i].id << ")" << endl;
+#endif
+        }
+        else
+        {
+            Mat colorImage = imread( images[i].path );
+#ifdef DEBUG_DESC_PROGRESS
+            cout << "Computing descriptors for image " << i+1 << " of " << images.size() << " (" << images[i].id << ")" << flush;
+#endif
+            vector<KeyPoint> keypoints;
+            fdetector->detect( colorImage, keypoints );
+#ifdef DEBUG_DESC_PROGRESS
+                cout << " + generating BoW vector" << std::flush;
+#endif
+            bowExtractor->compute( colorImage, keypoints, imageDescriptors[i] );
+#ifdef DEBUG_DESC_PROGRESS
+            cout << " ...DONE " << static_cast<int>(static_cast<float>(i+1)/static_cast<float>(images.size())*100.0)
+                 << " % complete" << endl;
+#endif
+            if( !imageDescriptors[i].empty() )
+            {
+                if( !writeBowImageDescriptor( filename, imageDescriptors[i] ) )
+                {
+                    cout << "Error: file " << filename << "can not be opened to write bow image descriptor" << endl;
+                    exit(-1);
+                }
+            }
+        }
+    }
+}
+
+static void removeEmptyBowImageDescriptors( vector<ObdImage>& images, vector<Mat>& bowImageDescriptors,
+                                     vector<char>& objectPresent )
+{
+    CV_Assert( !images.empty() );
+    for( int i = (int)images.size() - 1; i >= 0; i-- )
+    {
+        bool res = bowImageDescriptors[i].empty();
+        if( res )
+        {
+            cout << "Removing image " << images[i].id << " due to no descriptors..." << endl;
+            images.erase( images.begin() + i );
+            bowImageDescriptors.erase( bowImageDescriptors.begin() + i );
+            objectPresent.erase( objectPresent.begin() + i );
+        }
+    }
+}
+
+static void removeBowImageDescriptorsByCount( vector<ObdImage>& images, vector<Mat> bowImageDescriptors, vector<char> objectPresent,
+                                       const SVMTrainParamsExt& svmParamsExt, int descsToDelete )
+{
+    RNG& rng = theRNG();
+    int pos_ex = (int)std::count( objectPresent.begin(), objectPresent.end(), (char)1 );
+    int neg_ex = (int)std::count( objectPresent.begin(), objectPresent.end(), (char)0 );
+
+    while( descsToDelete != 0 )
+    {
+        int randIdx = rng((unsigned)images.size());
+
+        // Prefer positive training examples according to svmParamsExt.targetRatio if required
+        if( objectPresent[randIdx] )
+        {
+            if( (static_cast<float>(pos_ex)/static_cast<float>(neg_ex+pos_ex)  < svmParamsExt.targetRatio) &&
+                (neg_ex > 0) && (svmParamsExt.balanceClasses == false) )
+            { continue; }
+            else
+            { pos_ex--; }
+        }
+        else
+        { neg_ex--; }
+
+        images.erase( images.begin() + randIdx );
+        bowImageDescriptors.erase( bowImageDescriptors.begin() + randIdx );
+        objectPresent.erase( objectPresent.begin() + randIdx );
+
+        descsToDelete--;
+    }
+    CV_Assert( bowImageDescriptors.size() == objectPresent.size() );
+}
+
+static void setSVMParams( Ptr<SVM> & svm, const Mat& responses, bool balanceClasses )
+{
+    int pos_ex = countNonZero(responses == 1);
+    int neg_ex = countNonZero(responses == -1);
+    cout << pos_ex << " positive training samples; " << neg_ex << " negative training samples" << endl;
+
+    svm->setType(SVM::C_SVC);
+    svm->setKernel(SVM::RBF);
+    if( balanceClasses )
+    {
+        Mat class_wts( 2, 1, CV_32FC1 );
+        // The first training sample determines the '+1' class internally, even if it is negative,
+        // so store whether this is the case so that the class weights can be reversed accordingly.
+        bool reversed_classes = (responses.at<float>(0) < 0.f);
+        if( reversed_classes == false )
+        {
+            class_wts.at<float>(0) = static_cast<float>(pos_ex)/static_cast<float>(pos_ex+neg_ex); // weighting for costs of positive class + 1 (i.e. cost of false positive - larger gives greater cost)
+            class_wts.at<float>(1) = static_cast<float>(neg_ex)/static_cast<float>(pos_ex+neg_ex); // weighting for costs of negative class - 1 (i.e. cost of false negative)
+        }
+        else
+        {
+            class_wts.at<float>(0) = static_cast<float>(neg_ex)/static_cast<float>(pos_ex+neg_ex);
+            class_wts.at<float>(1) = static_cast<float>(pos_ex)/static_cast<float>(pos_ex+neg_ex);
+        }
+        svm->setClassWeights(class_wts);
+    }
+}
+
+static void setSVMTrainAutoParams( ParamGrid& c_grid, ParamGrid& gamma_grid,
+                            ParamGrid& p_grid, ParamGrid& nu_grid,
+                            ParamGrid& coef_grid, ParamGrid& degree_grid )
+{
+    c_grid = SVM::getDefaultGrid(SVM::C);
+
+    gamma_grid = SVM::getDefaultGrid(SVM::GAMMA);
+
+    p_grid = SVM::getDefaultGrid(SVM::P);
+    p_grid.logStep = 0;
+
+    nu_grid = SVM::getDefaultGrid(SVM::NU);
+    nu_grid.logStep = 0;
+
+    coef_grid = SVM::getDefaultGrid(SVM::COEF);
+    coef_grid.logStep = 0;
+
+    degree_grid = SVM::getDefaultGrid(SVM::DEGREE);
+    degree_grid.logStep = 0;
+}
+
+static Ptr<SVM> trainSVMClassifier( const SVMTrainParamsExt& svmParamsExt, const string& objClassName, VocData& vocData,
+                         Ptr<BOWImgDescriptorExtractor>& bowExtractor, const Ptr<FeatureDetector>& fdetector,
+                         const string& resPath )
+{
+    /* first check if a previously trained svm for the current class has been saved to file */
+    string svmFilename = resPath + svmsDir + "/" + objClassName + ".xml.gz";
+    Ptr<SVM> svm;
+
+    FileStorage fs( svmFilename, FileStorage::READ);
+    if( fs.isOpened() )
+    {
+        cout << "*** LOADING SVM CLASSIFIER FOR CLASS " << objClassName << " ***" << endl;
+        svm = StatModel::load<SVM>( svmFilename );
+    }
+    else
+    {
+        cout << "*** TRAINING CLASSIFIER FOR CLASS " << objClassName << " ***" << endl;
+        cout << "CALCULATING BOW VECTORS FOR TRAINING SET OF " << objClassName << "..." << endl;
+
+        // Get classification ground truth for images in the training set
+        vector<ObdImage> images;
+        vector<Mat> bowImageDescriptors;
+        vector<char> objectPresent;
+        vocData.getClassImages( objClassName, CV_OBD_TRAIN, images, objectPresent );
+
+        // Compute the bag of words vector for each image in the training set.
+        calculateImageDescriptors( images, bowImageDescriptors, bowExtractor, fdetector, resPath );
+
+        // Remove any images for which descriptors could not be calculated
+        removeEmptyBowImageDescriptors( images, bowImageDescriptors, objectPresent );
+
+        CV_Assert( svmParamsExt.descPercent > 0.f && svmParamsExt.descPercent <= 1.f );
+        if( svmParamsExt.descPercent < 1.f )
+        {
+            int descsToDelete = static_cast<int>(static_cast<float>(images.size())*(1.0-svmParamsExt.descPercent));
+
+            cout << "Using " << (images.size() - descsToDelete) << " of " << images.size() <<
+                    " descriptors for training (" << svmParamsExt.descPercent*100.0 << " %)" << endl;
+            removeBowImageDescriptorsByCount( images, bowImageDescriptors, objectPresent, svmParamsExt, descsToDelete );
+        }
+
+        // Prepare the input matrices for SVM training.
+        Mat trainData( (int)images.size(), bowExtractor->getVocabulary().rows, CV_32FC1 );
+        Mat responses( (int)images.size(), 1, CV_32SC1 );
+
+        // Transfer bag of words vectors and responses across to the training data matrices
+        for( size_t imageIdx = 0; imageIdx < images.size(); imageIdx++ )
+        {
+            // Transfer image descriptor (bag of words vector) to training data matrix
+            Mat submat = trainData.row((int)imageIdx);
+            if( bowImageDescriptors[imageIdx].cols != bowExtractor->descriptorSize() )
+            {
+                cout << "Error: computed bow image descriptor size " << bowImageDescriptors[imageIdx].cols
+                     << " differs from vocabulary size" << bowExtractor->getVocabulary().cols << endl;
+                exit(-1);
+            }
+            bowImageDescriptors[imageIdx].copyTo( submat );
+
+            // Set response value
+            responses.at<int>((int)imageIdx) = objectPresent[imageIdx] ? 1 : -1;
+        }
+
+        cout << "TRAINING SVM FOR CLASS ..." << objClassName << "..." << endl;
+        svm = SVM::create();
+        setSVMParams( svm, responses, svmParamsExt.balanceClasses );
+        ParamGrid c_grid, gamma_grid, p_grid, nu_grid, coef_grid, degree_grid;
+        setSVMTrainAutoParams( c_grid, gamma_grid,  p_grid, nu_grid, coef_grid, degree_grid );
+
+        svm->trainAuto(TrainData::create(trainData, ROW_SAMPLE, responses), 10,
+                       c_grid, gamma_grid, p_grid, nu_grid, coef_grid, degree_grid);
+        cout << "SVM TRAINING FOR CLASS " << objClassName << " COMPLETED" << endl;
+
+        svm->save( svmFilename );
+        cout << "SAVED CLASSIFIER TO FILE" << endl;
+    }
+    return svm;
+}
+
+static void computeConfidences( const Ptr<SVM>& svm, const string& objClassName, VocData& vocData,
+                         Ptr<BOWImgDescriptorExtractor>& bowExtractor, const Ptr<FeatureDetector>& fdetector,
+                         const string& resPath )
+{
+    cout << "*** CALCULATING CONFIDENCES FOR CLASS " << objClassName << " ***" << endl;
+    cout << "CALCULATING BOW VECTORS FOR TEST SET OF " << objClassName << "..." << endl;
+    // Get classification ground truth for images in the test set
+    vector<ObdImage> images;
+    vector<Mat> bowImageDescriptors;
+    vector<char> objectPresent;
+    vocData.getClassImages( objClassName, CV_OBD_TEST, images, objectPresent );
+
+    // Compute the bag of words vector for each image in the test set
+    calculateImageDescriptors( images, bowImageDescriptors, bowExtractor, fdetector, resPath );
+    // Remove any images for which descriptors could not be calculated
+    removeEmptyBowImageDescriptors( images, bowImageDescriptors, objectPresent);
+
+    // Use the bag of words vectors to calculate classifier output for each image in test set
+    cout << "CALCULATING CONFIDENCE SCORES FOR CLASS " << objClassName << "..." << endl;
+    vector<float> confidences( images.size() );
+    float signMul = 1.f;
+    for( size_t imageIdx = 0; imageIdx < images.size(); imageIdx++ )
+    {
+        if( imageIdx == 0 )
+        {
+            // In the first iteration, determine the sign of the positive class
+            float classVal = confidences[imageIdx] = svm->predict( bowImageDescriptors[imageIdx], noArray(), 0 );
+            float scoreVal = confidences[imageIdx] = svm->predict( bowImageDescriptors[imageIdx], noArray(), StatModel::RAW_OUTPUT );
+            signMul = (classVal < 0) == (scoreVal < 0) ? 1.f : -1.f;
+        }
+        // svm output of decision function
+        confidences[imageIdx] = signMul * svm->predict( bowImageDescriptors[imageIdx], noArray(), StatModel::RAW_OUTPUT );
+    }
+
+    cout << "WRITING QUERY RESULTS TO VOC RESULTS FILE FOR CLASS " << objClassName << "..." << endl;
+    vocData.writeClassifierResultsFile( resPath + plotsDir, objClassName, CV_OBD_TEST, images, confidences, 1, true );
+
+    cout << "DONE - " << objClassName << endl;
+    cout << "---------------------------------------------------------------" << endl;
+}
+
+static void computeGnuPlotOutput( const string& resPath, const string& objClassName, VocData& vocData )
+{
+    vector<float> precision, recall;
+    float ap;
+
+    const string resultFile = vocData.getResultsFilename( objClassName, CV_VOC_TASK_CLASSIFICATION, CV_OBD_TEST);
+    const string plotFile = resultFile.substr(0, resultFile.size()-4) + ".plt";
+
+    cout << "Calculating precision recall curve for class '" <<objClassName << "'" << endl;
+    vocData.calcClassifierPrecRecall( resPath + plotsDir + "/" + resultFile, precision, recall, ap, true );
+    cout << "Outputting to GNUPlot file..." << endl;
+    vocData.savePrecRecallToGnuplot( resPath + plotsDir + "/" + plotFile, precision, recall, ap, objClassName, CV_VOC_PLOT_PNG );
+}
+
+static Ptr<Feature2D> createByName(const String& name)
+{
+    if( name == "SIFT" )
+        return SIFT::create();
+    if( name == "SURF" )
+        return SURF::create();
+    if( name == "ORB" )
+        return ORB::create();
+    if( name == "BRISK" )
+        return BRISK::create();
+    if( name == "KAZE" )
+        return KAZE::create();
+    if( name == "AKAZE" )
+        return AKAZE::create();
+    return Ptr<Feature2D>();
+}
+
+int main(int argc, char** argv)
+{
+    if( argc != 3 && argc != 6 )
+    {
+        help(argv);
+        return -1;
+    }
+
+    const string vocPath = argv[1], resPath = argv[2];
+
+    // Read or set default parameters
+    string vocName;
+    DDMParams ddmParams;
+    VocabTrainParams vocabTrainParams;
+    SVMTrainParamsExt svmTrainParamsExt;
+
+    makeUsedDirs( resPath );
+
+    FileStorage paramsFS( resPath + "/" + paramsFile, FileStorage::READ );
+    if( paramsFS.isOpened() )
+    {
+       readUsedParams( paramsFS.root(), vocName, ddmParams, vocabTrainParams, svmTrainParamsExt );
+       CV_Assert( vocName == getVocName(vocPath) );
+    }
+    else
+    {
+        vocName = getVocName(vocPath);
+        if( argc!= 6 )
+        {
+            cout << "Feature detector, descriptor extractor, descriptor matcher must be set" << endl;
+            return -1;
+        }
+        ddmParams = DDMParams( argv[3], argv[4], argv[5] ); // from command line
+        // vocabTrainParams and svmTrainParamsExt is set by defaults
+        paramsFS.open( resPath + "/" + paramsFile, FileStorage::WRITE );
+        if( paramsFS.isOpened() )
+        {
+            writeUsedParams( paramsFS, vocName, ddmParams, vocabTrainParams, svmTrainParamsExt );
+            paramsFS.release();
+        }
+        else
+        {
+            cout << "File " << (resPath + "/" + paramsFile) << "can not be opened to write" << endl;
+            return -1;
+        }
+    }
+
+    // Create detector, descriptor, matcher.
+    if( ddmParams.detectorType != ddmParams.descriptorType )
+    {
+        cout << "detector and descriptor should be the same\n";
+        return -1;
+    }
+    Ptr<Feature2D> featureDetector = createByName( ddmParams.detectorType );
+    Ptr<DescriptorExtractor> descExtractor = featureDetector;
+    Ptr<BOWImgDescriptorExtractor> bowExtractor;
+    if( !featureDetector || !descExtractor )
+    {
+        cout << "featureDetector or descExtractor was not created" << endl;
+        return -1;
+    }
+    {
+        Ptr<DescriptorMatcher> descMatcher = DescriptorMatcher::create( ddmParams.matcherType );
+        if( !featureDetector || !descExtractor || !descMatcher )
+        {
+            cout << "descMatcher was not created" << endl;
+            return -1;
+        }
+        bowExtractor = makePtr<BOWImgDescriptorExtractor>( descExtractor, descMatcher );
+    }
+
+    // Print configuration to screen
+    printUsedParams( vocPath, resPath, ddmParams, vocabTrainParams, svmTrainParamsExt );
+    // Create object to work with VOC
+    VocData vocData( vocPath, false );
+
+    // 1. Train visual word vocabulary if a pre-calculated vocabulary file doesn't already exist from previous run
+    Mat vocabulary = trainVocabulary( resPath + "/" + vocabularyFile, vocData, vocabTrainParams,
+                                      featureDetector, descExtractor );
+    bowExtractor->setVocabulary( vocabulary );
+
+    // 2. Train a classifier and run a sample query for each object class
+    const vector<string>& objClasses = vocData.getObjectClasses(); // object class list
+    for( size_t classIdx = 0; classIdx < objClasses.size(); ++classIdx )
+    {
+        // Train a classifier on train dataset
+        Ptr<SVM> svm = trainSVMClassifier( svmTrainParamsExt, objClasses[classIdx], vocData,
+                                           bowExtractor, featureDetector, resPath );
+
+        // Now use the classifier over all images on the test dataset and rank according to score order
+        // also calculating precision-recall etc.
+        computeConfidences( svm, objClasses[classIdx], vocData,
+                            bowExtractor, featureDetector, resPath );
+        // Calculate precision/recall/ap and use GNUPlot to output to a pdf file
+        computeGnuPlotOutput( resPath, objClasses[classIdx], vocData );
+    }
+    return 0;
+}
+
+#else
+
+int main()
+{
+    std::cerr << "OpenCV was built without ml module" << std::endl;
+    return 0;
+}
+
+#endif // HAVE_OPENCV_ML
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/export-boostdesc.py b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/export-boostdesc.py
new file mode 100644
index 00000000..0d89c812
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/export-boostdesc.py
@@ -0,0 +1,293 @@
+#!/usr/bin/python
+
+"""
+
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2016
+ *
+ * Balint Cristian <cristian dot balint at gmail dot com>
+ *
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the copyright holders nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+/* export-boostdesc.py */
+/* Export C headers from binary data */
+// [http://infoscience.epfl.ch/record/186246/files/boostDesc_1.0.tar.gz]
+
+"""
+
+import sys
+import struct
+
+
+
+def float_to_hex(f):
+  return struct.unpack( '<I', struct.pack('<f', f) )[0]
+
+def main():
+
+  # usage
+  if ( len(sys.argv) < 3 ):
+    print( "Usage: %s <binary-type (BGM, LBGM, BINBOOST)> <boostdesc-binary-filename>" % sys.argv[0] )
+    sys.exit(0)
+
+
+  if ( ( sys.argv[1] != "BGM" ) and
+       ( sys.argv[1] != "LBGM" ) and
+       ( sys.argv[1] != "BINBOOST" ) ):
+    print( "Invalid type [%s]" % sys.argv[1] )
+    sys.exit(0)
+
+  # enum literals
+  Assign = [ "ASSIGN_HARD",
+             "ASSIGN_BILINEAR",
+             "ASSIGN_SOFT",
+             "ASSIGN_HARD_MAGN",
+             "ASSIGN_SOFT_MAGN" ]
+
+  # open binary data file
+  f = open( sys.argv[2], 'rb' )
+
+  # header
+  print "/*"
+  print " *"
+  print " * Header exported from binary."
+  print " * [%s %s %s]" % ( sys.argv[0], sys.argv[1], sys.argv[2] )
+  print " *"
+  print " */"
+
+  # ini
+  nDim = 1;
+  nWLs = 0;
+
+  # dimensionality (where is the case)
+  if ( ( sys.argv[1] == "LBGM" ) or
+       ( sys.argv[1] == "BINBOOST" ) ):
+    nDim = struct.unpack( '<i', f.read(4) )[0]
+
+  print
+  print "// dimensionality of learner"
+  print "static const int nDim = %i;" % nDim
+
+  # week learners (where is the case)
+  if ( sys.argv[1] != "BINBOOST" ):
+    nWLs = struct.unpack( '<i', f.read(4) )[0]
+
+  # common header
+  orientQuant     = struct.unpack( '<i', f.read(4) )[0]
+  patchSize       = struct.unpack( '<i', f.read(4) )[0]
+  iGradAssignType = struct.unpack( '<i', f.read(4) )[0]
+
+  print
+  print "// orientations"
+  print "static const int orientQuant = %i;" % orientQuant
+
+  print
+  print "// patch size"
+  print "static const int patchSize = %i;" % patchSize
+
+  print
+  print "// gradient assignment type"
+  print "static const int iGradAssignType = %s;" % Assign[iGradAssignType]
+
+  arr_thresh = ""
+  arr_orient = ""
+
+  arr__y_min = ""
+  arr__y_max = ""
+  arr__x_min = ""
+  arr__x_max = ""
+
+  arr__alpha = ""
+  arr___beta = ""
+
+
+  dims = nDim
+  if ( sys.argv[1] == "LBGM" ):
+    dims = 1
+
+  # iterate each dimension
+  for d in range( 0, dims ):
+
+    if ( sys.argv[1] == "BINBOOST" ):
+      nWLs   = struct.unpack( '<i', f.read(4) )[0]
+
+    if ( d == 0 ):
+      print
+      print "// number of weak learners"
+      print "static const int nWLs = %i;" % nWLs
+
+    # iterate each members
+    for i in range( 0, nWLs ):
+
+      # unpack structure array
+      thresh = struct.unpack( '<f', f.read(4) )[0]
+      orient = struct.unpack( '<i', f.read(4) )[0]
+
+      y_min  = struct.unpack( '<i', f.read(4) )[0]
+      y_max  = struct.unpack( '<i', f.read(4) )[0]
+      x_min  = struct.unpack( '<i', f.read(4) )[0]
+      x_max  = struct.unpack( '<i', f.read(4) )[0]
+
+      alpha  = struct.unpack( '<f', f.read(4) )[0]
+
+      beta = 0
+      if ( sys.argv[1] == "BINBOOST" ):
+        beta = struct.unpack( '<f', f.read(4) )[0]
+
+      # first entry
+      if ( d*dims + i == 0 ):
+
+        arr_thresh += "\n"
+        arr_thresh += "// threshold array (%s x %s)\n" % (dims,nWLs)
+        arr_thresh += "static const unsigned int thresh[] =\n{\n"
+
+        arr_orient += "\n"
+        arr_orient += "// orientation array (%s x %s)\n" % (dims,nWLs)
+        arr_orient += "static const int orient[] =\n{\n"
+
+        arr__y_min += "\n"
+        arr__y_min += "// Y min array (%s x %s)\n" % (dims,nWLs)
+        arr__y_min += "static const int y_min[] =\n{\n"
+
+        arr__y_max += "\n"
+        arr__y_max += "// Y max array (%s x %s)\n" % (dims,nWLs)
+        arr__y_max += "static const int y_max[] =\n{\n"
+
+        arr__x_min += "\n"
+        arr__x_min += "// X min array (%s x %s)\n" % (dims,nWLs)
+        arr__x_min += "static const int x_min[] =\n{\n"
+
+        arr__x_max += "\n"
+        arr__x_max += "// X max array (%s x %s)\n" % (dims,nWLs)
+        arr__x_max += "static const int x_max[] =\n{\n"
+
+        arr__alpha += "\n"
+        arr__alpha += "// alpha array (%s x %s)\n" % (dims,nWLs)
+        arr__alpha += "static const unsigned int alpha[] =\n{\n"
+
+        if ( sys.argv[1] == "BINBOOST" ):
+          arr___beta += "\n"
+          arr___beta += "// beta array (%s x %s)\n" % (dims,nWLs)
+          arr___beta += "static const unsigned int beta[] =\n{\n"
+
+      # last entry
+      if ( i == nWLs - 1 ) and ( d == dims - 1):
+
+        arr_thresh += " 0x%08x\n};" % float_to_hex(thresh)
+        arr_orient += " 0x%02x\n};" % orient
+
+        arr__y_min += " 0x%02x\n};" % y_min
+        arr__y_max += " 0x%02x\n};" % y_max
+        arr__x_min += " 0x%02x\n};" % x_min
+        arr__x_max += " 0x%02x\n};" % x_max
+
+        arr__alpha += " 0x%08x\n};" % float_to_hex(alpha)
+
+        if ( sys.argv[1] == "BINBOOST" ):
+          arr___beta += " 0x%08x\n};" % float_to_hex(beta)
+
+        break
+
+      # align entries
+      if ( (d*dims + i + 1) % 8 ):
+
+        arr_thresh += " 0x%08x," % float_to_hex(thresh)
+        arr_orient += " 0x%02x," % orient
+
+        arr__y_min += " 0x%02x," % y_min
+        arr__y_max += " 0x%02x," % y_max
+        arr__x_min += " 0x%02x," % x_min
+        arr__x_max += " 0x%02x," % x_max
+
+        arr__alpha += " 0x%08x," % float_to_hex(alpha)
+
+        if ( sys.argv[1] == "BINBOOST" ):
+          arr___beta += " 0x%08x," % float_to_hex(beta)
+
+      else:
+
+        arr_thresh += " 0x%08x,\n" % float_to_hex(thresh)
+        arr_orient += " 0x%02x,\n" % orient
+
+        arr__y_min += " 0x%02x,\n" % y_min
+        arr__y_max += " 0x%02x,\n" % y_max
+        arr__x_min += " 0x%02x,\n" % x_min
+        arr__x_max += " 0x%02x,\n" % x_max
+
+        arr__alpha += " 0x%08x,\n" % float_to_hex(alpha)
+
+        if ( sys.argv[1] == "BINBOOST" ):
+          arr___beta += " 0x%08x,\n" % float_to_hex(beta)
+
+  # extra array (when LBGM)
+  if ( sys.argv[1] == "LBGM" ):
+
+    arr___beta += "\n"
+    arr___beta += "// beta array (%s x %s)\n" % (nWLs,nDim)
+    arr___beta += "static const unsigned int beta[] =\n{\n"
+
+    for i in range( 0, nWLs ):
+      for d in range( 0, nDim ):
+        beta = struct.unpack( '<f', f.read(4) )[0]
+
+        # last entry
+        if ( i == nWLs-1 ) and ( d == nDim-1 ):
+          arr___beta += " 0x%08x\n};" % float_to_hex(beta)
+          break
+
+        # align entries
+        if ( (i*nDim + d + 1) % 8 ):
+          arr___beta += " 0x%08x," % float_to_hex(beta)
+        else:
+          arr___beta += " 0x%08x,\n" % float_to_hex(beta)
+
+  # release
+  f.close()
+
+  # dump on screen
+  print arr_thresh
+  print arr_orient
+
+  print arr__y_min
+  print arr__y_max
+  print arr__x_min
+  print arr__x_max
+
+  print arr__alpha
+
+  if ( ( sys.argv[1] == "LBGM" ) or
+       ( sys.argv[1] == "BINBOOST" ) ):
+    print arr___beta
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/gms_matcher.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/gms_matcher.cpp
new file mode 100644
index 00000000..007d264d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/gms_matcher.cpp
@@ -0,0 +1,138 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/features2d.hpp>
+#include <opencv2/flann.hpp>
+#include <opencv2/xfeatures2d.hpp>
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+
+////////////////////////////////////////////////////
+// This program demonstrates the GMS matching strategy.
+int main(int argc, char* argv[])
+{
+    const char* keys =
+        "{ h help        |                  | print help message  }"
+        "{ l left        |                  | specify left (reference) image  }"
+        "{ r right       |                  | specify right (query) image }"
+        "{ camera        | 0                | specify the camera device number }"
+        "{ nfeatures     | 10000            | specify the maximum number of ORB features }"
+        "{ fastThreshold | 20               | specify the FAST threshold }"
+        "{ drawSimple    | true             | do not draw not matched keypoints }"
+        "{ withRotation  | false            | take rotation into account }"
+        "{ withScale     | false            | take scale into account }";
+
+    CommandLineParser cmd(argc, argv, keys);
+    if (cmd.has("help"))
+    {
+        std::cout << "Usage: gms_matcher [options]" << std::endl;
+        std::cout << "Available options:" << std::endl;
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+
+    Ptr<Feature2D> orb = ORB::create(cmd.get<int>("nfeatures"));
+    orb.dynamicCast<cv::ORB>()->setFastThreshold(cmd.get<int>("fastThreshold"));
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-Hamming");
+
+    if (!cmd.get<String>("left").empty() && !cmd.get<String>("right").empty())
+    {
+        Mat imgL = imread(cmd.get<String>("left"));
+        Mat imgR = imread(cmd.get<String>("right"));
+
+        std::vector<KeyPoint> kpRef, kpCur;
+        Mat descRef, descCur;
+        orb->detectAndCompute(imgL, noArray(), kpRef, descRef);
+        orb->detectAndCompute(imgR, noArray(), kpCur, descCur);
+
+        std::vector<DMatch> matchesAll, matchesGMS;
+        matcher->match(descCur, descRef, matchesAll);
+
+        matchGMS(imgR.size(), imgL.size(), kpCur, kpRef, matchesAll, matchesGMS, cmd.get<bool>("withRotation"), cmd.get<bool>("withScale"));
+        std::cout << "matchesGMS: " << matchesGMS.size() << std::endl;
+
+        Mat frameMatches;
+        if (cmd.get<bool>("drawSimple"))
+            drawMatches(imgR, kpCur, imgL, kpRef, matchesGMS, frameMatches, Scalar::all(-1), Scalar::all(-1),
+                        std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
+        else
+            drawMatches(imgR, kpCur, imgL, kpRef, matchesGMS, frameMatches);
+        imshow("Matches GMS", frameMatches);
+        waitKey();
+    }
+    else
+    {
+        std::vector<KeyPoint> kpRef;
+        Mat descRef;
+
+        VideoCapture capture(cmd.get<int>("camera"));
+        //Camera warm-up
+        for (int i = 0; i < 10; i++)
+        {
+            Mat frame;
+            capture >> frame;
+        }
+
+        Mat frameRef;
+        for (;;)
+        {
+            Mat frame;
+            capture >> frame;
+
+            if (frameRef.empty())
+            {
+                frame.copyTo(frameRef);
+                orb->detectAndCompute(frameRef, noArray(), kpRef, descRef);
+            }
+
+            TickMeter tm;
+            tm.start();
+            std::vector<KeyPoint> kp;
+            Mat desc;
+            orb->detectAndCompute(frame, noArray(), kp, desc);
+            tm.stop();
+            double t_orb = tm.getTimeMilli();
+
+            tm.reset();
+            tm.start();
+            std::vector<DMatch> matchesAll, matchesGMS;
+            matcher->match(desc, descRef, matchesAll);
+            tm.stop();
+            double t_match = tm.getTimeMilli();
+
+            matchGMS(frame.size(), frameRef.size(), kp, kpRef, matchesAll, matchesGMS, cmd.get<bool>("withRotation"), cmd.get<bool>("withScale"));
+            tm.stop();
+            Mat frameMatches;
+            if (cmd.get<bool>("drawSimple"))
+                 drawMatches(frame, kp, frameRef, kpRef, matchesGMS, frameMatches, Scalar::all(-1), Scalar::all(-1),
+                            std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
+            else
+                 drawMatches(frame, kp, frameRef, kpRef, matchesGMS, frameMatches);
+
+            String label = format("ORB: %.2f ms", t_orb);
+            putText(frameMatches, label, Point(20, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0,0,255));
+            label = format("Matching: %.2f ms", t_match);
+            putText(frameMatches, label, Point(20, 40), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0,0,255));
+            label = format("GMS matching: %.2f ms", tm.getTimeMilli());
+            putText(frameMatches, label, Point(20, 60), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0,0,255));
+            putText(frameMatches, "Press r to reinitialize the reference image.", Point(frameMatches.cols-380, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0,0,255));
+            putText(frameMatches, "Press esc to quit.", Point(frameMatches.cols-180, 40), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0,0,255));
+
+            imshow("Matches GMS", frameMatches);
+            int c = waitKey(30);
+            if (c == 27)
+                break;
+            else if (c == 'r')
+            {
+                frame.copyTo(frameRef);
+                orb->detectAndCompute(frameRef, noArray(), kpRef, descRef);
+            }
+        }
+
+    }
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/pct_signatures.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/pct_signatures.cpp
new file mode 100644
index 00000000..adbc34a8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/pct_signatures.cpp
@@ -0,0 +1,172 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/xfeatures2d.hpp>
+
+#include <iostream>
+#include <string>
+
+using namespace std;
+using namespace cv;
+using namespace xfeatures2d;
+
+
+void printHelpMessage(void);
+void printHelpMessage(void)
+{
+    cout << "Example of the PCTSignatures algorithm computing and visualizing\n"
+        "image signature for one image, or comparing multiple images with the first\n"
+        "image using the signature quadratic form distance.\n\n"
+        "Usage: pct_signatures ImageToProcessAndDisplay\n"
+        "or:    pct_signatures ReferenceImage [ImagesToCompareWithTheReferenceImage]\n\n"
+        "The program has 2 modes:\n"
+        "- single argument: program computes and visualizes the image signature\n"
+        "- multiple arguments: program compares the first image to the others\n"
+        "  using pct signatures and signature quadratic form distance (SQFD)";
+}
+
+/** @brief
+
+Example of the PCTSignatures algorithm.
+
+The program has 2 modes:
+- single argument mode, where the program computes and visualizes the image signature
+- multiple argument mode, where the program compares the first image to the others
+using signatures and signature quadratic form distance (SQFD)
+
+*/
+int main(int argc, char** argv)
+{
+    if (argc < 2)                               // Check arguments
+    {
+        printHelpMessage();
+        return 1;
+    }
+
+    Mat source;
+    source = imread(argv[1]);                   // Read the file
+
+    if (!source.data)                           // Check for invalid input
+    {
+        cerr << "Could not open or find the image: " << argv[1];
+        return -1;
+    }
+
+    Mat signature, result;                      // define variables
+    int initSampleCount = 2000;
+    int initSeedCount = 400;
+    int grayscaleBitsPerPixel = 4;
+    vector<Point2f> initPoints;
+
+    namedWindow("Source", WINDOW_AUTOSIZE);     // Create windows for display.
+    namedWindow("Result", WINDOW_AUTOSIZE);
+
+                                                // create the algorithm
+    PCTSignatures::generateInitPoints(initPoints, initSampleCount, PCTSignatures::UNIFORM);
+    Ptr<PCTSignatures> pctSignatures = PCTSignatures::create(initPoints, initSeedCount);
+    pctSignatures->setGrayscaleBits(grayscaleBitsPerPixel);
+
+                                                // compute and visualize the first image
+    double start = (double)getTickCount();
+    pctSignatures->computeSignature(source, signature);
+    double end = (double)getTickCount();
+    cout << "Signature of the reference image computed in " << (end - start) / (getTickFrequency() * 1.0f) << " seconds." << endl;
+    PCTSignatures::drawSignature(source, signature, result);
+
+    imshow("Source", source);                   // show the result
+    imshow("Result", result);
+
+    if (argc == 2)          // single image -> finish right after the visualization
+    {
+        waitKey(0);         // Wait for user input
+        return 0;
+    }
+    // multiple images -> compare to the first one
+    else
+    {
+        vector<Mat> images;
+        vector<Mat> signatures;
+        vector<float> distances;
+
+        for (int i = 2; i < argc; i++)
+        {
+            Mat image = imread(argv[i]);
+            if (!source.data)                               // Check for invalid input
+            {
+                cerr << "Could not open or find the image: " << argv[i] << std::endl;
+                return 1;
+            }
+            images.push_back(image);
+        }
+
+        pctSignatures->computeSignatures(images, signatures);
+        Ptr<PCTSignaturesSQFD> pctSQFD = PCTSignaturesSQFD::create();
+        pctSQFD->computeQuadraticFormDistances(signature, signatures, distances);
+
+        for (int i = 0; i < (int)(distances.size()); i++)
+        {
+            cout << "Image: " << argv[i + 2] << ", similarity: " << distances[i] << endl;
+        }
+        waitKey(0); // Wait for user input
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/pct_webcam.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/pct_webcam.cpp
new file mode 100644
index 00000000..a524eb1f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/pct_webcam.cpp
@@ -0,0 +1,170 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/xfeatures2d.hpp>
+
+#include <iostream>
+#include <string>
+
+using namespace std;
+using namespace cv;
+using namespace xfeatures2d;
+
+
+void printHelpMessage(void);
+void printHelpMessage(void)
+{
+    cout << "Example of the PCTSignatures algorithm.\n\n"
+        "This program computes and visualizes position-color-texture signatures\n"
+        "using images from webcam if available.\n\n"
+        "Usage:\n"
+        "pct_webcam [sample_count] [seed_count]\n"
+        "Note: sample_count must be greater or equal to seed_count.";
+}
+
+
+/** @brief
+
+Example of the PCTSignatures algorithm.
+
+This program computes and visualizes position-color-texture signatures
+of images taken from webcam if available.
+*/
+int main(int argc, char** argv)
+{
+    // define variables
+    Mat frame, signature, result;
+    int initSampleCount = 2000;
+    int initSeedCount = 400;
+    int grayscaleBitsPerPixel = 4;
+
+    // parse for help argument
+    {
+        for (int i = 1; i < argc; i++)
+        {
+            if ((string)argv[i] == "-h" || (string)argv[i] == "--help")
+            {
+                printHelpMessage();
+                return 0;
+            }
+        }
+    }
+
+    // parse optional arguments
+    if (argc > 1)               // sample count
+    {
+        initSampleCount = atoi(argv[1]);
+        if (initSampleCount <= 0)
+        {
+            cerr << "Sample count have to be a positive integer: " << argv[1] << endl;
+            return 1;
+        }
+        initSeedCount = (int)floor(static_cast<float>(initSampleCount / 4));
+        initSeedCount = std::max(1, initSeedCount);     // fallback if sample count == 1
+    }
+    if (argc > 2)               // seed count
+    {
+        initSeedCount = atoi(argv[2]);
+        if (initSeedCount <= 0)
+        {
+            cerr << "Seed count have to be a positive integer: " << argv[2] << endl;
+            return 1;
+        }
+        if (initSeedCount > initSampleCount)
+        {
+            cerr << "Seed count have to be lower or equal to sample count!" << endl;
+            return 1;
+        }
+    }
+
+    // create algorithm
+    Ptr<PCTSignatures> pctSignatures = PCTSignatures::create(initSampleCount, initSeedCount, PCTSignatures::UNIFORM);
+    pctSignatures->setGrayscaleBits(grayscaleBitsPerPixel);
+
+    // open video capture device
+    VideoCapture videoCapture;
+    if (!videoCapture.open(0))
+    {
+        cerr << "Unable to open the first video capture device with ID = 0!" << endl;
+        return 1;
+    }
+
+    // Create windows for display.
+    namedWindow("Source", WINDOW_AUTOSIZE);
+    namedWindow("Result", WINDOW_AUTOSIZE);
+
+    // run drawing loop
+    for (;;)
+    {
+        videoCapture >> frame;
+        if (frame.empty()) break; // end of video stream
+
+        pctSignatures->computeSignature(frame, signature);
+        PCTSignatures::drawSignature(Mat::zeros(frame.size(), frame.type()), signature, result);
+
+        imshow("Source", frame);                // Show our images inside the windows.
+        imshow("Result", result);
+
+        if (waitKey(1) == 27) break;            // stop videocapturing by pressing ESC
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/shape_transformation.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/shape_transformation.cpp
new file mode 100644
index 00000000..35526c77
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/shape_transformation.cpp
@@ -0,0 +1,89 @@
+/*
+ * shape_context.cpp -- Shape context demo for shape matching
+ */
+#include <iostream>
+#include "opencv2/opencv_modules.hpp"
+
+#ifdef HAVE_OPENCV_SHAPE
+
+#include "opencv2/shape.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+#include "opencv2/core/utility.hpp"
+#include <string>
+
+using namespace std;
+using namespace cv;
+using namespace cv::xfeatures2d;
+
+static void help()
+{
+    printf("\nThis program demonstrates how to use common interface for shape transformers\n"
+           "Call\n"
+           "shape_transformation [image1] [image2]\n");
+}
+
+int main(int argc, char** argv)
+{
+    help();
+    if (argc < 3)
+    {
+      printf("Not enough parameters\n");
+      return -1;
+    }
+    Mat img1 = imread(argv[1], IMREAD_GRAYSCALE);
+    Mat img2 = imread(argv[2], IMREAD_GRAYSCALE);
+    if(img1.empty() || img2.empty())
+    {
+        printf("Can't read one of the images\n");
+        return -1;
+    }
+
+    // detecting keypoints & computing descriptors
+    Ptr<SURF> surf = SURF::create(5000);
+    vector<KeyPoint> keypoints1, keypoints2;
+    Mat descriptors1, descriptors2;
+    surf->detectAndCompute(img1, Mat(), keypoints1, descriptors1);
+    surf->detectAndCompute(img2, Mat(), keypoints2, descriptors2);
+
+    // matching descriptors
+    BFMatcher matcher(surf->defaultNorm());
+    vector<DMatch> matches;
+    matcher.match(descriptors1, descriptors2, matches);
+
+    // drawing the results
+    namedWindow("matches", 1);
+    Mat img_matches;
+    drawMatches(img1, keypoints1, img2, keypoints2, matches, img_matches);
+    imshow("matches", img_matches);
+
+    // extract points
+    vector<Point2f> pts1, pts2;
+    for (size_t ii=0; ii<keypoints1.size(); ii++)
+        pts1.push_back( keypoints1[ii].pt );
+    for (size_t ii=0; ii<keypoints2.size(); ii++)
+        pts2.push_back( keypoints2[ii].pt );
+
+    // Apply TPS
+    Ptr<ThinPlateSplineShapeTransformer> mytps = createThinPlateSplineShapeTransformer(25000); //TPS with a relaxed constraint
+    mytps->estimateTransformation(pts1, pts2, matches);
+    mytps->warpImage(img2, img2);
+
+    imshow("Tranformed", img2);
+    waitKey(0);
+
+    return 0;
+}
+
+#else
+
+int main()
+{
+    std::cerr << "OpenCV was built without shape module" << std::endl;
+    return 0;
+}
+
+#endif // HAVE_OPENCV_SHAPE
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/surf_matcher.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/surf_matcher.cpp
new file mode 100644
index 00000000..5e3d5924
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/surf_matcher.cpp
@@ -0,0 +1,225 @@
+#include <iostream>
+#include <stdio.h>
+#include "opencv2/core.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/calib3d.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+
+const int LOOP_NUM = 10;
+const int GOOD_PTS_MAX = 50;
+const float GOOD_PORTION = 0.15f;
+
+int64 work_begin = 0;
+int64 work_end = 0;
+
+static void workBegin()
+{
+    work_begin = getTickCount();
+}
+
+static void workEnd()
+{
+    work_end = getTickCount() - work_begin;
+}
+
+static double getTime()
+{
+    return work_end /((double)getTickFrequency() )* 1000.;
+}
+
+struct SURFDetector
+{
+    Ptr<Feature2D> surf;
+    SURFDetector(double hessian = 800.0)
+    {
+        surf = SURF::create(hessian);
+    }
+    template<class T>
+    void operator()(const T& in, const T& mask, std::vector<cv::KeyPoint>& pts, T& descriptors, bool useProvided = false)
+    {
+        surf->detectAndCompute(in, mask, pts, descriptors, useProvided);
+    }
+};
+
+template<class KPMatcher>
+struct SURFMatcher
+{
+    KPMatcher matcher;
+    template<class T>
+    void match(const T& in1, const T& in2, std::vector<cv::DMatch>& matches)
+    {
+        matcher.match(in1, in2, matches);
+    }
+};
+
+static Mat drawGoodMatches(
+    const Mat& img1,
+    const Mat& img2,
+    const std::vector<KeyPoint>& keypoints1,
+    const std::vector<KeyPoint>& keypoints2,
+    std::vector<DMatch>& matches,
+    std::vector<Point2f>& scene_corners_
+    )
+{
+    //-- Sort matches and preserve top 10% matches
+    std::sort(matches.begin(), matches.end());
+    std::vector< DMatch > good_matches;
+    double minDist = matches.front().distance;
+    double maxDist = matches.back().distance;
+
+    const int ptsPairs = std::min(GOOD_PTS_MAX, (int)(matches.size() * GOOD_PORTION));
+    for( int i = 0; i < ptsPairs; i++ )
+    {
+        good_matches.push_back( matches[i] );
+    }
+    std::cout << "\nMax distance: " << maxDist << std::endl;
+    std::cout << "Min distance: " << minDist << std::endl;
+
+    std::cout << "Calculating homography using " << ptsPairs << " point pairs." << std::endl;
+
+    // drawing the results
+    Mat img_matches;
+
+    drawMatches( img1, keypoints1, img2, keypoints2,
+                 good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
+                 std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS  );
+
+    //-- Localize the object
+    std::vector<Point2f> obj;
+    std::vector<Point2f> scene;
+
+    for( size_t i = 0; i < good_matches.size(); i++ )
+    {
+        //-- Get the keypoints from the good matches
+        obj.push_back( keypoints1[ good_matches[i].queryIdx ].pt );
+        scene.push_back( keypoints2[ good_matches[i].trainIdx ].pt );
+    }
+    //-- Get the corners from the image_1 ( the object to be "detected" )
+    std::vector<Point2f> obj_corners(4);
+    obj_corners[0] = Point(0,0);
+    obj_corners[1] = Point( img1.cols, 0 );
+    obj_corners[2] = Point( img1.cols, img1.rows );
+    obj_corners[3] = Point( 0, img1.rows );
+    std::vector<Point2f> scene_corners(4);
+
+    Mat H = findHomography( obj, scene, RANSAC );
+    perspectiveTransform( obj_corners, scene_corners, H);
+
+    scene_corners_ = scene_corners;
+
+    //-- Draw lines between the corners (the mapped object in the scene - image_2 )
+    line( img_matches,
+          scene_corners[0] + Point2f( (float)img1.cols, 0), scene_corners[1] + Point2f( (float)img1.cols, 0),
+          Scalar( 0, 255, 0), 2, LINE_AA );
+    line( img_matches,
+          scene_corners[1] + Point2f( (float)img1.cols, 0), scene_corners[2] + Point2f( (float)img1.cols, 0),
+          Scalar( 0, 255, 0), 2, LINE_AA );
+    line( img_matches,
+          scene_corners[2] + Point2f( (float)img1.cols, 0), scene_corners[3] + Point2f( (float)img1.cols, 0),
+          Scalar( 0, 255, 0), 2, LINE_AA );
+    line( img_matches,
+          scene_corners[3] + Point2f( (float)img1.cols, 0), scene_corners[0] + Point2f( (float)img1.cols, 0),
+          Scalar( 0, 255, 0), 2, LINE_AA );
+    return img_matches;
+}
+
+////////////////////////////////////////////////////
+// This program demonstrates the usage of SURF_OCL.
+// use cpu findHomography interface to calculate the transformation matrix
+int main(int argc, char* argv[])
+{
+    const char* keys =
+        "{ h help     |                  | print help message  }"
+        "{ l left     | box.png          | specify left image  }"
+        "{ r right    | box_in_scene.png | specify right image }"
+        "{ o output   | SURF_output.jpg  | specify output save path }"
+        "{ m cpu_mode |                  | run without OpenCL }";
+
+    CommandLineParser cmd(argc, argv, keys);
+    if (cmd.has("help"))
+    {
+        std::cout << "Usage: surf_matcher [options]" << std::endl;
+        std::cout << "Available options:" << std::endl;
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+    if (cmd.has("cpu_mode"))
+    {
+        ocl::setUseOpenCL(false);
+        std::cout << "OpenCL was disabled" << std::endl;
+    }
+
+    UMat img1, img2;
+
+    std::string outpath = cmd.get<std::string>("o");
+
+    std::string leftName = cmd.get<std::string>("l");
+    imread(leftName, IMREAD_GRAYSCALE).copyTo(img1);
+    if(img1.empty())
+    {
+        std::cout << "Couldn't load " << leftName << std::endl;
+        cmd.printMessage();
+        return EXIT_FAILURE;
+    }
+
+    std::string rightName = cmd.get<std::string>("r");
+    imread(rightName, IMREAD_GRAYSCALE).copyTo(img2);
+    if(img2.empty())
+    {
+        std::cout << "Couldn't load " << rightName << std::endl;
+        cmd.printMessage();
+        return EXIT_FAILURE;
+    }
+
+    double surf_time = 0.;
+
+    //declare input/output
+    std::vector<KeyPoint> keypoints1, keypoints2;
+    std::vector<DMatch> matches;
+
+    UMat _descriptors1, _descriptors2;
+    Mat descriptors1 = _descriptors1.getMat(ACCESS_RW),
+        descriptors2 = _descriptors2.getMat(ACCESS_RW);
+
+    //instantiate detectors/matchers
+    SURFDetector surf;
+
+    SURFMatcher<BFMatcher> matcher;
+
+    //-- start of timing section
+
+    for (int i = 0; i <= LOOP_NUM; i++)
+    {
+        if(i == 1) workBegin();
+        surf(img1.getMat(ACCESS_READ), Mat(), keypoints1, descriptors1);
+        surf(img2.getMat(ACCESS_READ), Mat(), keypoints2, descriptors2);
+        matcher.match(descriptors1, descriptors2, matches);
+    }
+    workEnd();
+    std::cout << "FOUND " << keypoints1.size() << " keypoints on first image" << std::endl;
+    std::cout << "FOUND " << keypoints2.size() << " keypoints on second image" << std::endl;
+
+    surf_time = getTime();
+    std::cout << "SURF run time: " << surf_time / LOOP_NUM << " ms" << std::endl<<"\n";
+
+
+    std::vector<Point2f> corner;
+    Mat img_matches = drawGoodMatches(img1.getMat(ACCESS_READ), img2.getMat(ACCESS_READ), keypoints1, keypoints2, matches, corner);
+
+    //-- Show detected matches
+
+    namedWindow("surf matches", 0);
+    imshow("surf matches", img_matches);
+    imwrite(outpath, img_matches);
+
+    waitKey(0);
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/video_homography.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/video_homography.cpp
new file mode 100644
index 00000000..709936e6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/samples/video_homography.cpp
@@ -0,0 +1,248 @@
+/*
+* video_homography.cpp
+*
+*  Created on: Oct 18, 2010
+*      Author: erublee
+*/
+
+#include <iostream>
+#include "opencv2/opencv_modules.hpp"
+
+#ifdef HAVE_OPENCV_CALIB3D
+
+#include "opencv2/calib3d.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+#include <list>
+#include <vector>
+
+using namespace std;
+using namespace cv;
+using namespace cv::xfeatures2d;
+
+static void help(char **av)
+{
+    cout << "\nThis program demonstrated the use of features2d with the Fast corner detector and brief descriptors\n"
+        << "to track planar objects by computing their homography from the key (training) image to the query (test) image\n\n" << endl;
+    cout << "usage: " << av[0] << " <video device number>\n" << endl;
+    cout << "The following keys do stuff:" << endl;
+    cout << "  t : grabs a reference frame to match against" << endl;
+    cout << "  l : makes the reference frame new every frame" << endl;
+    cout << "  q or escape: quit" << endl;
+}
+
+namespace
+{
+    void drawMatchesRelative(const vector<KeyPoint>& train, const vector<KeyPoint>& query,
+        std::vector<cv::DMatch>& matches, Mat& img, const vector<unsigned char>& mask = vector<
+        unsigned char> ())
+    {
+        for (int i = 0; i < (int)matches.size(); i++)
+        {
+            if (mask.empty() || mask[i])
+            {
+                Point2f pt_new = query[matches[i].queryIdx].pt;
+                Point2f pt_old = train[matches[i].trainIdx].pt;
+
+                cv::line(img, pt_new, pt_old, Scalar(125, 255, 125), 1);
+                cv::circle(img, pt_new, 2, Scalar(255, 0, 125), 1);
+
+            }
+        }
+    }
+
+    //Takes a descriptor and turns it into an xy point
+    void keypoints2points(const vector<KeyPoint>& in, vector<Point2f>& out)
+    {
+        out.clear();
+        out.reserve(in.size());
+        for (size_t i = 0; i < in.size(); ++i)
+        {
+            out.push_back(in[i].pt);
+        }
+    }
+
+    //Takes an xy point and appends that to a keypoint structure
+    void points2keypoints(const vector<Point2f>& in, vector<KeyPoint>& out)
+    {
+        out.clear();
+        out.reserve(in.size());
+        for (size_t i = 0; i < in.size(); ++i)
+        {
+            out.push_back(KeyPoint(in[i], 1));
+        }
+    }
+
+    //Uses computed homography H to warp original input points to new planar position
+    void warpKeypoints(const Mat& H, const vector<KeyPoint>& in, vector<KeyPoint>& out)
+    {
+        vector<Point2f> pts;
+        keypoints2points(in, pts);
+        vector<Point2f> pts_w(pts.size());
+        Mat m_pts_w(pts_w);
+        perspectiveTransform(Mat(pts), m_pts_w, H);
+        points2keypoints(pts_w, out);
+    }
+
+    //Converts matching indices to xy points
+    void matches2points(const vector<KeyPoint>& train, const vector<KeyPoint>& query,
+        const std::vector<cv::DMatch>& matches, std::vector<cv::Point2f>& pts_train,
+        std::vector<Point2f>& pts_query)
+    {
+
+        pts_train.clear();
+        pts_query.clear();
+        pts_train.reserve(matches.size());
+        pts_query.reserve(matches.size());
+
+        size_t i = 0;
+
+        for (; i < matches.size(); i++)
+        {
+
+            const DMatch & dmatch = matches[i];
+
+            pts_query.push_back(query[dmatch.queryIdx].pt);
+            pts_train.push_back(train[dmatch.trainIdx].pt);
+
+        }
+
+    }
+
+    void resetH(Mat&H)
+    {
+        H = Mat::eye(3, 3, CV_32FC1);
+    }
+}
+
+int main(int ac, char ** av)
+{
+
+    if (ac != 2)
+    {
+        help(av);
+        return 1;
+    }
+
+    Ptr<BriefDescriptorExtractor> brief = BriefDescriptorExtractor::create(32);
+
+    VideoCapture capture;
+    capture.open(atoi(av[1]));
+    if (!capture.isOpened())
+    {
+        help(av);
+        cout << "capture device " << atoi(av[1]) << " failed to open!" << endl;
+        return 1;
+    }
+
+    cout << "following keys do stuff:" << endl;
+    cout << "t : grabs a reference frame to match against" << endl;
+    cout << "l : makes the reference frame new every frame" << endl;
+    cout << "q or escape: quit" << endl;
+
+    Mat frame;
+
+    vector<DMatch> matches;
+
+    BFMatcher desc_matcher(brief->defaultNorm());
+
+    vector<Point2f> train_pts, query_pts;
+    vector<KeyPoint> train_kpts, query_kpts;
+    vector<unsigned char> match_mask;
+
+    Mat gray;
+
+    bool ref_live = true;
+
+    Mat train_desc, query_desc;
+    Ptr<FastFeatureDetector> detector = FastFeatureDetector::create(10, true);
+
+    Mat H_prev = Mat::eye(3, 3, CV_32FC1);
+    for (;;)
+    {
+        capture >> frame;
+        if (frame.empty())
+            break;
+
+        cvtColor(frame, gray, COLOR_RGB2GRAY);
+
+        detector->detect(gray, query_kpts); //Find interest points
+        brief->compute(gray, query_kpts, query_desc); //Compute brief descriptors at each keypoint location
+
+        if (!train_kpts.empty())
+        {
+
+            vector<KeyPoint> test_kpts;
+            warpKeypoints(H_prev.inv(), query_kpts, test_kpts);
+
+            //Mat mask = windowedMatchingMask(test_kpts, train_kpts, 25, 25);
+            desc_matcher.match(query_desc, train_desc, matches, Mat());
+            drawKeypoints(frame, test_kpts, frame, Scalar(255, 0, 0), DrawMatchesFlags::DRAW_OVER_OUTIMG);
+
+            matches2points(train_kpts, query_kpts, matches, train_pts, query_pts);
+
+            if (matches.size() > 5)
+            {
+                Mat H = findHomography(train_pts, query_pts, RANSAC, 4, match_mask);
+                if (countNonZero(Mat(match_mask)) > 15)
+                {
+                    H_prev = H;
+                }
+                else
+                    resetH(H_prev);
+                drawMatchesRelative(train_kpts, query_kpts, matches, frame, match_mask);
+            }
+            else
+                resetH(H_prev);
+
+        }
+        else
+        {
+            H_prev = Mat::eye(3, 3, CV_32FC1);
+            Mat out;
+            drawKeypoints(gray, query_kpts, out);
+            frame = out;
+        }
+
+        imshow("frame", frame);
+
+        if (ref_live)
+        {
+            train_kpts = query_kpts;
+            query_desc.copyTo(train_desc);
+        }
+        char key = (char)waitKey(2);
+        switch (key)
+        {
+        case 'l':
+            ref_live = true;
+            resetH(H_prev);
+            break;
+        case 't':
+            ref_live = false;
+            train_kpts = query_kpts;
+            query_desc.copyTo(train_desc);
+            resetH(H_prev);
+            break;
+        case 27:
+        case 'q':
+            return 0;
+            break;
+        }
+
+    }
+    return 0;
+}
+
+#else
+
+int main()
+{
+    std::cerr << "OpenCV was built without calib3d module" << std::endl;
+    return 0;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/affine_feature2d.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/affine_feature2d.cpp
new file mode 100644
index 00000000..7c7e1873
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/affine_feature2d.cpp
@@ -0,0 +1,686 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+/*
+ * Functions to perform affine adaptation of keypoint and to calculate descriptors of elliptic regions
+ */
+
+#include "precomp.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgproc/types_c.h"
+
+namespace {
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+
+/*
+* Functions to perform affine adaptation of circular keypoint
+*/
+void calcAffineCovariantRegions(const Mat& image, const std::vector<KeyPoint>& keypoints, std::vector<Elliptic_KeyPoint>& affRegions);
+void calcAffineCovariantDescriptors( const Ptr<DescriptorExtractor>& dextractor, const Mat& img, std::vector<Elliptic_KeyPoint>& affRegions, Mat& descriptors );
+
+void calcSecondMomentMatrix(const Mat & dx2, const Mat & dxy, const Mat & dy2, Point p, Matx22f& M);
+bool calcAffineAdaptation(const Mat & image, Elliptic_KeyPoint& keypoint);
+float selIntegrationScale(const Mat & image, float si, Point c);
+float selDifferentiationScale(const Mat & image, Mat & Lxm2smooth, Mat & Lxmysmooth, Mat & Lym2smooth, float si, Point c);
+float calcSecondMomentSqrt(const Mat & dx2, const Mat & dxy, const Mat & dy2, Point p, Matx22f& Mk);
+float normMaxEval(Matx22f & U, Mat& uVal, Mat& uVect);
+
+/*
+ * Calculates second moments matrix in point p
+ */
+void calcSecondMomentMatrix(const Mat & dx2, const Mat & dxy, const Mat & dy2, Point p, Matx22f & M)
+{
+    int x = p.x;
+    int y = p.y;
+
+    M(0, 0) = dx2.at<float> (y, x);
+    M(0, 1) = M(1, 0) = dxy.at<float> (y, x);
+    M(1, 1) = dy2.at<float> (y, x);
+}
+
+/*
+ * Performs affine adaptation
+ */
+bool calcAffineAdaptation(const Mat & fimage, Elliptic_KeyPoint & keypoint)
+{
+    Matx23f transf; /*Transformation matrix*/
+    Matx21f   size; /*Image size after transformation*/
+    Matx21f      c; /*Transformed point*/
+    Matx21f      p; /*Image point*/
+
+    Matx22f U(1.f, 0.f, 0.f, 1.f); /*Normalization matrix*/
+
+    Mat warpedImg, Lxm2smooth, Lym2smooth, Lxmysmooth, img_roi;
+    Matx22f Mk;
+    float Qinv = 1, q, si = keypoint.si;
+    bool divergence = false, convergence = false;
+    int i = 0;
+
+    //Coordinates in image
+    int py = (int) keypoint.pt.y;
+    int px = (int) keypoint.pt.x;
+
+    //Roi coordinates
+    int roix, roiy;
+
+    //Coordinates in U-trasformation
+    int cx = px;
+    int cy = py;
+    int cxPr = cx;
+    int cyPr = cy;
+
+    float radius = keypoint.size / 2 * 1.4f;
+    float half_width, half_height;
+
+    Rect roi;
+    float ax1, ax2;
+    float phi = 0;
+    ax1 = ax2 = keypoint.size / 2;
+    Mat drawImg;
+
+    //Affine adaptation
+    while (i <= 10 && !divergence && !convergence)
+    {
+        //Transformation matrix
+        transf = Matx23f(
+            U(0,0), U(0,1), 0.f,
+            U(1,0), U(1,1), 0.f
+        );
+        keypoint.transf = transf;
+
+        Size_<float> boundingBox;
+
+        float ac_b2 = float(determinant(U));
+        boundingBox.width  = ceil(U(1, 1)/ac_b2 * 3 * si*1.4f );
+        boundingBox.height = ceil(U(0, 0)/ac_b2 * 3 * si*1.4f );
+
+        //Create window around interest point
+        half_width = std::min((float) std::min(fimage.cols - px-1, px), boundingBox.width);
+        half_height = std::min((float) std::min(fimage.rows - py-1, py), boundingBox.height);
+        roix = max(px - (int) boundingBox.width, 0);
+        roiy = max(py - (int) boundingBox.height, 0);
+        roi = Rect(roix, roiy, px - roix + int(half_width)+1, py - roiy + int(half_height)+1);
+
+        //create ROI
+        img_roi = fimage(roi);
+
+
+        //Point within the ROI
+        p(0, 0) = float(px - roix);
+        p(1, 0) = float(py - roiy);
+
+        if (half_width <= 0 || half_height <= 0)
+            return divergence;
+
+        //Find coordinates of square's angles to find size of warped ellipse's bounding box
+        float u00 = U(0, 0);
+        float u01 = U(0, 1);
+        float u10 = U(1, 0);
+        float u11 = U(1, 1);
+
+        float minx = u01 * img_roi.rows < 0 ? u01 * img_roi.rows : 0;
+        float miny = u10 * img_roi.cols < 0 ? u10 * img_roi.cols : 0;
+        float maxx = (u00 * img_roi.cols > u00 * img_roi.cols + u01 * img_roi.rows ? u00
+                * img_roi.cols : u00 * img_roi.cols + u01 * img_roi.rows) - minx;
+        float maxy = (u11 * img_roi.rows > u10 * img_roi.cols + u11 * img_roi.rows ? u11
+                * img_roi.rows : u10 * img_roi.cols + u11 * img_roi.rows) - miny;
+
+        //Shift
+        transf(0, 2) = -minx;
+        transf(1, 2) = -miny;
+
+        /*float min_width = minx >= 0 ? u00 * img_roi.cols - u01 * img_roi.rows : u00 * img_roi.cols
+                + u01 * img_roi.rows;
+        float min_height = miny >= 0 ? u11 * img_roi.rows - u10 * img_roi.cols : u10 * img_roi.cols
+                + u11 * img_roi.rows;*/
+
+        if (maxx >=  2*radius+1 && maxy >=  2*radius+1)
+        {
+            //Size of normalized window must be 2*radius
+            //Transformation
+            Mat warpedImgRoi;
+            warpAffine(img_roi, warpedImgRoi, transf, Size(int(maxx), int(maxy)),INTER_AREA, BORDER_REPLICATE);
+
+            //Point in U-Normalized coordinates
+            c = U * p;
+            cx = int(c(0, 0) - minx);
+            cy = int(c(1, 0) - miny);
+
+            if (warpedImgRoi.rows > 2 * radius+1 && warpedImgRoi.cols > 2 * radius+1)
+            {
+                //Cut around normalized patch
+                roix = std::max(cx - int(ceil(radius)), 0);
+                roiy = std::max(cy - int(ceil(radius)), 0);
+                roi = Rect(roix, roiy,
+                        cx - roix + std::min(int(ceil(radius)), warpedImgRoi.cols - cx-1)+1,
+                        cy - roiy + std::min(int(ceil(radius)), warpedImgRoi.rows - cy-1)+1);
+                warpedImg = warpedImgRoi(roi);
+
+                //Coordinates in cutted ROI
+                cx = cx - roix;
+                cy = cy - roiy;
+            } else
+                warpedImgRoi.copyTo(warpedImg);
+
+            //Integration Scale selection
+            si = selIntegrationScale(warpedImg, si, Point(cx, cy));
+            //Differentation scale selection
+            selDifferentiationScale(warpedImg, Lxm2smooth, Lxmysmooth, Lym2smooth, si,
+                    Point(cx, cy));
+            if (Lym2smooth.empty()) {
+                divergence = true;
+                continue;
+            }
+
+            //Spatial Localization
+            cxPr = cx; //Previous iteration point in normalized window
+            cyPr = cy;
+
+            float cornMax = 0;
+            for (int j = 0; j < 3; j++)
+            {
+                for (int t = 0; t < 3; t++)
+                {
+                    float dx2 = Lxm2smooth.at<float> (cyPr - 1 + j, cxPr - 1 + t);
+                    float dy2 = Lym2smooth.at<float> (cyPr - 1 + j, cxPr - 1 + t);
+                    float dxy = Lxmysmooth.at<float> (cyPr - 1 + j, cxPr - 1 + t);
+                    float det = dx2 * dy2 - dxy * dxy;
+                    float tr = dx2 + dy2;
+                    float cornerness = det - (0.04f * tr*tr);
+                    if (cornerness > cornMax)
+                    {
+                        cornMax = cornerness;
+                        cx = cxPr - 1 + t;
+                        cy = cyPr - 1 + j;
+                    }
+                }
+            }
+
+            //Transform point in image coordinates
+            p(0, 0) = float(px);
+            p(1, 0) = float(py);
+            //Displacement vector
+            c(0, 0) = float(cx - cxPr);
+            c(1, 0) = float(cy - cyPr);
+            //New interest point location in image
+            p = p + Matx22f(Matx22d(U).inv()) * c;
+            px = int(p(0, 0));
+            py = int(p(1, 0));
+
+            q = calcSecondMomentSqrt(Lxm2smooth, Lxmysmooth, Lym2smooth, Point(cx, cy), Mk);
+
+            float ratio = 1 - q;
+
+            //if ratio == 1 means q == 0 and one axes equals to 0
+            if (!cvIsNaN(ratio) && ratio != 1)
+            {
+                //Update U matrix
+                U = U * Mk;
+
+                Mat uVal, uV;
+                eigen(U, uVal, uV);
+
+                Qinv = normMaxEval(U, uVal, uV);
+
+                //Keypoint doesn't converge
+                if (Qinv >= 6)
+                    divergence = true;
+
+                //Keypoint converges
+                else if (ratio <= 0.05f)
+                {
+                    convergence = true;
+
+                    //Set transformation matrix
+                    transf = Matx23f(
+                        U(0,0), U(0,1), 0.f,
+                        U(1,0), U(1,1), 0.f
+                    );
+                    keypoint.transf = transf;
+
+                    ax1 = 1.f / std::abs(uVal.at<float> (0, 0)) * 3 * si;
+                    ax2 = 1.f / std::abs(uVal.at<float> (1, 0)) * 3 * si;
+                    phi = float(atan(uV.at<float> (1, 0) / uV.at<float> (0, 0)) * (180) / CV_PI);
+                    keypoint.axes = Size_<float> (ax1, ax2);
+                    keypoint.angle = phi;
+                    keypoint.pt = Point2f( (float) px, (float) py);
+                    keypoint.si = si;
+                    keypoint.size = 2 * 3 * si;
+
+                } else
+                    radius = 3 * si * 1.4f;
+
+            } else divergence = true;
+
+        } else divergence = true;
+
+        ++i;
+    }
+
+    return convergence;
+}
+
+/*
+ * Selects the integration scale that maximize LoG in point c
+ */
+float selIntegrationScale(const Mat & image, float si, Point c)
+{
+    Mat Lap, L;
+    int cx = c.x;
+    int cy = c.y;
+    float maxLap = 0;
+    float maxsx = si;
+    int gsize;
+    float sigma, sigma_prev = 0;
+
+    image.copyTo(L);
+    /* Search best integration scale between previous and successive layer
+     */
+    for (float u = 0.7f; u <= 1.41f; u += 0.1f)
+    {
+        float sik = u * si;
+        sigma = sqrt(powf(sik, 2) - powf(sigma_prev, 2));
+
+        gsize = int(ceil(sigma * 3)) * 2 + 1;
+
+        GaussianBlur(L, L, Size(gsize, gsize), sigma);
+        sigma_prev = sik;
+
+        Laplacian(L, Lap, CV_32F, 3);
+
+        float lapVal = sik * sik * std::abs(Lap.at<float> (cy, cx));
+
+        if (u == 0.7f)
+            maxLap = lapVal;
+
+        if (lapVal >= maxLap)
+        {
+            maxLap = lapVal;
+            maxsx = sik;
+        }
+    }
+    return maxsx;
+}
+
+/*
+ * Calculates second moments matrix square root
+ */
+float calcSecondMomentSqrt(const Mat & dx2, const Mat & dxy, const Mat & dy2, Point p, Matx22f & Mk)
+{
+    Mat V, eigVal, Vinv, D;
+    Matx22f M;
+
+    calcSecondMomentMatrix(dx2, dxy, dy2, p, M);
+
+    /* *
+     * M = V * D * V.inv()
+     * V has eigenvectors as columns
+     * D is a diagonal Matrix with eigenvalues as elements
+     * V.inv() is the inverse of V
+     * */
+
+    eigen(M, eigVal, V);
+    V = V.t();
+    Vinv = V.inv();
+
+    float eval1 = eigVal.at<float> (0, 0) = sqrt(eigVal.at<float> (0, 0));
+    float eval2 = eigVal.at<float> (1, 0) = sqrt(eigVal.at<float> (1, 0));
+
+    D = Mat::diag(eigVal);
+
+    //square root of M
+    Mk = Mat(V * D * Vinv);
+    //return q isotropic measure
+    return min(eval1, eval2) / max(eval1, eval2);
+}
+
+float normMaxEval(Matx22f & U, Mat & uVal, Mat & uVec)
+{
+    /* *
+     * Decomposition:
+     * U = V * D * V.inv()
+     * V has eigenvectors as columns
+     * D is a diagonal Matrix with eigenvalues as elements
+     * V.inv() is the inverse of V
+     * */
+    uVec = uVec.t();
+    Mat uVinv = uVec.inv();
+
+    //Normalize min eigenvalue to 1 to expand patch in the direction of min eigenvalue of U.inv()
+    float uval1 = uVal.at<float> (0, 0);
+    float uval2 = uVal.at<float> (1, 0);
+
+    if (std::abs(uval1) < std::abs(uval2))
+    {
+        uVal.at<float> (0, 0) = 1;
+        uVal.at<float> (1, 0) = uval2 / uval1;
+    } else
+    {
+        uVal.at<float> (1, 0) = 1;
+        uVal.at<float> (0, 0) = uval1 / uval2;
+    }
+
+    Mat D = Mat::diag(uVal);
+    //U normalized
+    U = Mat(uVec * D * uVinv);
+
+    return max(std::abs(uVal.at<float> (0, 0)), std::abs(uVal.at<float> (1, 0))) / min(
+            std::abs(uVal.at<float> (0, 0)), std::abs(uVal.at<float> (1, 0))); //define the direction of warping
+}
+
+/*
+ * Selects diffrentiation scale
+ */
+float selDifferentiationScale(const Mat & img, Mat & Lxm2smooth, Mat & Lxmysmooth,
+        Mat & Lym2smooth, float si, Point c)
+{
+    float s = 0.5f;
+    float sdk = s * si;
+    float sigma_prev = 0, sigma;
+
+    Mat L, dx2, dxy, dy2;
+
+    double qMax = 0;
+
+    //Gaussian kernel size
+    int gsize;
+    Size ksize;
+
+    img.copyTo(L);
+
+    while (s <= 0.751f)
+    {
+        Matx22f M;
+        float sd = s * si;
+
+        //Smooth previous smoothed image L
+        sigma = sqrt(powf(sd, 2) - powf(sigma_prev, 2));
+
+        gsize = int(ceil(sigma * 3)) * 2 + 1;
+
+        GaussianBlur(L, L, Size(gsize, gsize), sigma);
+
+        sigma_prev = sd;
+
+        //X and Y derivatives
+        Mat Lx, Ly;
+        Sobel(L, Lx, L.depth(), 1, 0, 1);
+        Lx = Lx * sd;
+        Sobel(L, Ly, L.depth(), 0, 1, 1);
+        Ly = Ly * sd;
+
+        //Size of gaussian kernel
+        gsize = int(ceil(si * 3)) * 2 + 1;
+        ksize = Size(gsize, gsize);
+
+        Mat Lxm2 = Lx.mul(Lx);
+        GaussianBlur(Lxm2, dx2, ksize, si);
+
+        Mat Lym2 = Ly.mul(Ly);
+        GaussianBlur(Lym2, dy2, ksize, si);
+
+        Mat Lxmy = Lx.mul(Ly);
+        GaussianBlur(Lxmy, dxy, ksize, si);
+
+        calcSecondMomentMatrix(dx2, dxy, dy2, Point(c.x, c.y), M);
+
+        //calc eigenvalues
+        Mat eval;
+        eigen(M, eval);
+        double eval1 = std::abs(eval.at<float> (0, 0));
+        double eval2 = std::abs(eval.at<float> (1, 0));
+        double m = max(eval1, eval2);
+        double q = (m == 0) ? -1 : min(eval1, eval2) / m;
+
+        if (q >= qMax)
+        {
+            qMax = q;
+            sdk = sd;
+            dx2.copyTo(Lxm2smooth);
+            dxy.copyTo(Lxmysmooth);
+            dy2.copyTo(Lym2smooth);
+
+        }
+        s += 0.05f;
+    }
+
+    return sdk;
+}
+
+void calcAffineCovariantRegions(const Mat & image, const std::vector<KeyPoint> & keypoints,
+        std::vector<Elliptic_KeyPoint> & affRegions)
+{
+    for (size_t i = 0; i < keypoints.size(); ++i)
+    {
+        KeyPoint kp = keypoints[i];
+        Elliptic_KeyPoint ex(kp.pt, 0, Size_<float> (kp.size / 2, kp.size / 2), kp.size,
+                kp.size / 6);
+
+        if (calcAffineAdaptation(image, ex))
+            affRegions.push_back(ex);
+    }
+    //Erase similar keypoint
+    float maxDiff = 4;
+    Mat colorimg;
+    for (size_t i = 0; i < affRegions.size(); i++)
+    {
+        Elliptic_KeyPoint kp1 = affRegions[i];
+        for (size_t j = i+1; j < affRegions.size(); j++){
+
+            Elliptic_KeyPoint kp2 = affRegions[j];
+
+            if(norm(kp1.pt-kp2.pt)<=maxDiff){
+                float phi1, phi2;
+                Size axes1, axes2;
+                float si1, si2;
+                phi1 = kp1.angle;
+                phi2 = kp2.angle;
+                axes1 = kp1.axes;
+                axes2 = kp2.axes;
+                si1 = kp1.si;
+                si2 = kp2.si;
+                if(std::abs(phi1-phi2)<15 && std::max(si1,si2)/std::min(si1,si2)<1.4f && axes1.width-axes2.width<5 && axes1.height-axes2.height<5){
+                    affRegions.erase(affRegions.begin()+j);
+                    j--;
+                }
+            }
+        }
+    }
+}
+
+void calcAffineCovariantDescriptors(const Ptr<DescriptorExtractor>& dextractor, const Mat& img,
+        std::vector<Elliptic_KeyPoint>& affRegions, Mat& descriptors)
+{
+
+    assert(!affRegions.empty());
+    int descriptorSize = dextractor->descriptorSize();
+    int descriptorType = dextractor->descriptorType();
+    descriptors.create(Size(descriptorSize, int(affRegions.size())), descriptorType);
+    descriptors.setTo(0);
+
+    int i = 0;
+
+    for (std::vector<Elliptic_KeyPoint>::iterator it = affRegions.begin(); it < affRegions.end(); ++it)
+    {
+        Point p = it->pt;
+
+        Matx21f size;
+        size(0, 0) = size(1, 0) = it->size;
+
+        //U matrix
+        Matx23f transf = it->transf;
+        Matx22f U(
+            transf(0,0), transf(0,1),
+            transf(1,0), transf(1,1)
+        );
+
+        float radius = it->size / 2;
+        float si = it->si;
+
+        Size_<float> boundingBox;
+
+        float ac_b2 = float(determinant(U));
+        boundingBox.width  = ceil(U(1, 1)/ac_b2 * 3 * si );
+        boundingBox.height = ceil(U(0, 0)/ac_b2 * 3 * si );
+
+        //Create window around interest point
+        float half_width = std::min((float) std::min(img.cols - p.x-1, p.x), boundingBox.width);
+        float half_height = std::min((float) std::min(img.rows - p.y-1, p.y), boundingBox.height);
+        int roix = max(p.x - (int) boundingBox.width, 0);
+        int roiy = max(p.y - (int) boundingBox.height, 0);
+        Rect roi = Rect(roix, roiy, p.x - roix + int(half_width)+1, p.y - roiy + int(half_height)+1);
+
+        Mat img_roi = img(roi);
+
+        size(0, 0) = float(img_roi.cols);
+        size(1, 0) = float(img_roi.rows);
+
+        size = U * size;
+
+        Mat transfImgRoi, transfImg;
+        warpAffine(img_roi, transfImgRoi, transf, Size(int(ceil(size(0, 0))), int(ceil(size(1, 0)))),
+                INTER_AREA, BORDER_DEFAULT);
+
+        Matx21f c; //Transformed point
+        Matx21f pt; //Image point
+        //Point within the Roi
+        pt(0, 0) = float(p.x - roix);
+        pt(1, 0) = float(p.y - roiy);
+
+        //Point in U-Normalized coordinates
+        c = U * pt;
+        float cx = c(0, 0);
+        float cy = c(1, 0);
+
+        //Cut around point to have patch of 2*keypoint->size
+
+        roix = std::max(int(ceil(cx - radius)), 0);
+        roiy = std::max(int(ceil(cy - radius)), 0);
+
+        roi = Rect(roix, roiy, int(ceil(std::min(cx - roix + radius, size(0, 0)))),
+                int(ceil(std::min(cy - roiy + radius, size(1, 0)))));
+        transfImg = transfImgRoi(roi);
+
+        cx = c(0, 0) - roix;
+        cy = c(1, 0) - roiy;
+
+        Mat tmpDesc;
+        KeyPoint kp(Point(int(cx), int(cy)), it->size);
+
+        std::vector<KeyPoint> k(1, kp);
+
+        transfImg.convertTo(transfImg, CV_8U);
+        dextractor->compute(transfImg, k, tmpDesc);
+
+        tmpDesc.row(0).copyTo(descriptors.row(i));
+
+        i++;
+
+    }
+
+}
+
+} // anonymous namespace
+
+namespace cv
+{
+namespace xfeatures2d
+{
+class AffineFeature2D_Impl CV_FINAL : public AffineFeature2D
+{
+public:
+    AffineFeature2D_Impl(
+        Ptr<FeatureDetector> keypoint_detector,
+        Ptr<DescriptorExtractor> descriptor_extractor
+    ) : m_keypoint_detector(keypoint_detector)
+      , m_descriptor_extractor(descriptor_extractor) {}
+protected:
+    using Feature2D::detect; // overload, don't hide
+    void detect(InputArray image, std::vector<Elliptic_KeyPoint>& keypoints, InputArray mask) CV_OVERRIDE;
+    void detectAndCompute(InputArray image, InputArray mask, std::vector<Elliptic_KeyPoint>& keypoints, OutputArray descriptors, bool useProvidedKeypoints) CV_OVERRIDE;
+    void detectAndCompute(InputArray image, InputArray mask, std::vector<KeyPoint>& keypoints, OutputArray descriptors, bool useProvidedKeypoints) CV_OVERRIDE;
+    int descriptorSize() const CV_OVERRIDE;
+    int descriptorType() const CV_OVERRIDE;
+    int defaultNorm() const CV_OVERRIDE;
+private:
+    Ptr<FeatureDetector> m_keypoint_detector;
+    Ptr<DescriptorExtractor> m_descriptor_extractor;
+};
+
+Ptr<AffineFeature2D> AffineFeature2D::create(
+    Ptr<FeatureDetector> keypoint_detector,
+    Ptr<DescriptorExtractor> descriptor_extractor)
+{
+    return makePtr<AffineFeature2D_Impl>(keypoint_detector, descriptor_extractor);
+}
+
+void AffineFeature2D_Impl::detect(
+    InputArray image,
+    std::vector<Elliptic_KeyPoint>& keypoints,
+    InputArray mask)
+{
+    std::vector<KeyPoint> non_elliptic_keypoints;
+    m_keypoint_detector->detect(image, non_elliptic_keypoints, mask);
+    Mat fimage;
+    image.getMat().convertTo(fimage, CV_32F, 1.f/255);
+    calcAffineCovariantRegions(fimage, non_elliptic_keypoints, keypoints);
+}
+
+void AffineFeature2D_Impl::detectAndCompute(
+        InputArray image,
+        InputArray mask,
+        std::vector<Elliptic_KeyPoint>& keypoints,
+        OutputArray descriptors,
+        bool useProvidedKeypoints)
+{
+    if(!useProvidedKeypoints)
+    {
+        std::vector<KeyPoint> non_elliptic_keypoints;
+        m_keypoint_detector->detect(image, non_elliptic_keypoints, mask);
+        Mat fimage;
+        image.getMat().convertTo(fimage, CV_32F, 1.f/255);
+        calcAffineCovariantRegions(fimage, non_elliptic_keypoints, keypoints);
+    }
+    if(descriptors.needed())calcAffineCovariantDescriptors(m_descriptor_extractor, image.getMat(), keypoints, descriptors.getMatRef());
+}
+
+void AffineFeature2D_Impl::detectAndCompute(
+        InputArray image,
+        InputArray mask,
+        std::vector<KeyPoint>& keypoints,
+        OutputArray descriptors,
+        bool useProvidedKeypoints)
+{
+    if(!useProvidedKeypoints)
+    {
+        m_keypoint_detector->detect(image, keypoints, mask);
+    }
+    if(descriptors.needed()) {
+        Mat fimage;
+        image.getMat().convertTo(fimage, CV_32F, 1.f/255);
+        std::vector<Elliptic_KeyPoint> elliptic_keypoints;
+        calcAffineCovariantRegions(fimage, keypoints, elliptic_keypoints);
+        calcAffineCovariantDescriptors(m_descriptor_extractor, image.getMat(), elliptic_keypoints, descriptors.getMatRef());
+    }
+}
+
+int AffineFeature2D_Impl::descriptorSize() const
+{
+    return m_descriptor_extractor->descriptorSize();
+}
+
+int AffineFeature2D_Impl::descriptorType() const
+{
+    return m_descriptor_extractor->descriptorType();
+}
+
+int AffineFeature2D_Impl::defaultNorm() const
+{
+    return m_descriptor_extractor->defaultNorm();
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/beblid.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/beblid.cpp
new file mode 100644
index 00000000..00812cd1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/beblid.cpp
@@ -0,0 +1,484 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Author: Iago Suarez <iago.suarez.canosa@alumnos.upm.es>
+
+// Implementation of the article:
+//     Iago Suarez, Ghesn Sfeir, Jose M. Buenaposada, and Luis Baumela.
+//     BEBLID: Boosted Efficient Binary Local Image Descriptor.
+//     Pattern Recognition Letters, 133:366–372, 2020.
+
+#include "precomp.hpp"
+
+#define CV_BEBLID_PARALLEL
+
+#define CV_ROUNDNUM(x) ((int)(x + 0.5f))
+#define CV_DEGREES_TO_RADS 0.017453292519943295 // (M_PI / 180.0)
+#define CV_BEBLID_EXTRA_RATIO_MARGIN 1.75f
+
+using namespace cv;
+using namespace std;
+
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+// Struct containing the 6 parameters that define an Average Box weak-learner
+struct ABWLParams
+{
+    int x1, y1, x2, y2, boxRadius, th;
+};
+// Same as previous with floating point threshold
+struct ABWLParamsFloatTh
+{
+    int x1, y1, x2, y2, boxRadius;
+    float th;
+};
+
+// BEBLID implementation
+template <class WeakLearnerT>
+class BEBLID_Impl CV_FINAL: public BEBLID
+{
+public:
+
+    // constructor
+    explicit BEBLID_Impl(float scale_factor, const std::vector<WeakLearnerT>& wl_params);
+
+    // destructor
+    ~BEBLID_Impl() CV_OVERRIDE = default;
+
+    // returns the descriptor length in bytes
+    int descriptorSize() const CV_OVERRIDE { return int(wl_params_.size() / 8); }
+
+    // returns the descriptor type
+    int descriptorType() const CV_OVERRIDE { return CV_8UC1; }
+
+    // returns the default norm type
+    int defaultNorm() const CV_OVERRIDE { return cv::NORM_HAMMING;  }
+
+    void setScaleFactor(float scale_factor) CV_OVERRIDE { scale_factor_ = scale_factor; }
+    float getScaleFactor() const { return scale_factor_;}
+
+    // compute descriptors given keypoints
+    void compute(InputArray image, vector<KeyPoint> &keypoints, OutputArray descriptors) CV_OVERRIDE;
+
+private:
+    std::vector<WeakLearnerT> wl_params_;
+    float scale_factor_;
+    cv::Size patch_size_;
+
+    void computeBoxDiffsDescriptor(const cv::Mat &integralImg,
+                                   const std::vector<cv::KeyPoint> &keypoints,
+                                   cv::Mat &descriptors);
+}; // END BEBLID_Impl CLASS
+
+
+// TEBLID implementation
+class TEBLID_Impl CV_FINAL: public TEBLID
+{
+public:
+
+    // constructor
+    explicit TEBLID_Impl(float scale_factor, const std::vector<ABWLParamsFloatTh>& wl_params) :
+        impl(scale_factor, wl_params){}
+
+    // destructor
+    ~TEBLID_Impl() CV_OVERRIDE = default;
+
+    // returns the descriptor length in bytes
+    int descriptorSize() const CV_OVERRIDE { return impl.descriptorSize(); }
+
+    // returns the descriptor type
+    int descriptorType() const CV_OVERRIDE { return impl.descriptorType(); }
+
+    // returns the default norm type
+    int defaultNorm() const CV_OVERRIDE { return impl.defaultNorm();  }
+
+    // compute descriptors given keypoints
+    void compute(InputArray image, vector<KeyPoint> &keypoints, OutputArray descriptors) CV_OVERRIDE
+    {
+        impl.compute(image, keypoints, descriptors);
+    }
+
+private:
+    BEBLID_Impl<ABWLParamsFloatTh> impl;
+}; // END TEBLID_Impl CLASS
+
+Ptr<TEBLID> TEBLID::create(float scale_factor, int n_bits)
+{
+    if (n_bits == TEBLID::SIZE_512_BITS)
+    {
+        #include "teblid.p512.hpp"
+        return makePtr<TEBLID_Impl>(scale_factor, teblid_wl_params_512);
+    }
+    else if(n_bits == TEBLID::SIZE_256_BITS)
+    {
+        #include "teblid.p256.hpp"
+        return makePtr<TEBLID_Impl>(scale_factor, teblid_wl_params_256);
+    }
+    else
+    {
+        CV_Error(Error::StsBadArg, "n_bits should be either TEBLID::SIZE_512_BITS or TEBLID::SIZE_256_BITS");
+    }
+}
+
+/**
+ * @brief Function that determines if a keypoint is close to the image border.
+ * @param kp The detected keypoint
+ * @param imgSize The size of the image
+ * @param patchSize The size of the normalized patch where the measurement functions were learnt.
+ * @param scaleFactor A scale factor that magnifies the measurement functions w.r.t. the keypoint.
+ * @return true if the keypoint is in the border, false otherwise
+ */
+static inline bool isKeypointInTheBorder(const cv::KeyPoint &kp,
+                                         const cv::Size &imgSize,
+                                         const cv::Size &patchSize = {32, 32},
+                                         float scaleFactor = 1)
+{
+    // This would be the correct measure but since we will compare with half of the size, use this as border size
+    float s = scaleFactor * kp.size / (patchSize.width + patchSize.height);
+    cv::Size2f border(patchSize.width * s * CV_BEBLID_EXTRA_RATIO_MARGIN,
+                      patchSize.height * s * CV_BEBLID_EXTRA_RATIO_MARGIN);
+
+    if (kp.pt.x < border.width || kp.pt.x + border.width >= imgSize.width)
+        return true;
+
+    if (kp.pt.y < border.height || kp.pt.y + border.height >= imgSize.height)
+        return true;
+
+    return false;
+}
+
+/**
+ * @brief Rectifies the coordinates of the measurement functions that conform the descriptor
+ * with the keypoint location parameters.
+ * @param wlPatchParams The input weak learner parameters learnt for the normalized patch
+ * @param wlImageParams The output  weak learner parameters adapted to the keypoint location
+ * @param kp The keypoint defining the offset, rotation and scale to be applied
+ * @param scaleFactor A scale factor that magnifies the measurement functions w.r.t. the keypoint.
+ * @param patchSize The size of the normalized patch where the measurement functions were learnt.
+ */
+template< typename WeakLearnerT>
+static inline void rectifyABWL(const std::vector<WeakLearnerT> &wlPatchParams,
+                               std::vector<WeakLearnerT> &wlImageParams,
+                               const cv::KeyPoint &kp,
+                               float scaleFactor = 1,
+                               const cv::Size &patchSize = cv::Size(32, 32))
+{
+    float m00, m01, m02, m10, m11, m12;
+    float s, cosine, sine;
+
+    s = scaleFactor * kp.size / (0.5f * (patchSize.width + patchSize.height));
+    wlImageParams.resize(wlPatchParams.size());
+
+    if (kp.angle == -1)
+    {
+        m00 = s;
+        m01 = 0.0f;
+        m02 = -0.5f * s * patchSize.width + kp.pt.x;
+        m10 = 0.0f;
+        m11 = s;
+        m12 = -s * 0.5f * patchSize.height + kp.pt.y;
+    }
+    else
+    {
+        cosine = (kp.angle >= 0) ? float(cos(kp.angle * CV_DEGREES_TO_RADS)) : 1.f;
+        sine = (kp.angle >= 0) ? float(sin(kp.angle * CV_DEGREES_TO_RADS)) : 0.f;
+
+        m00 = s * cosine;
+        m01 = -s * sine;
+        m02 = (-s * cosine + s * sine) * patchSize.width * 0.5f + kp.pt.x;
+        m10 = s * sine;
+        m11 = s * cosine;
+        m12 = (-s * sine - s * cosine) * patchSize.height * 0.5f + kp.pt.y;
+    }
+
+    for (size_t i = 0; i < wlPatchParams.size(); i++)
+    {
+        wlImageParams[i].x1 = CV_ROUNDNUM(m00 * wlPatchParams[i].x1 + m01 * wlPatchParams[i].y1 + m02);
+        wlImageParams[i].y1 = CV_ROUNDNUM(m10 * wlPatchParams[i].x1 + m11 * wlPatchParams[i].y1 + m12);
+        wlImageParams[i].x2 = CV_ROUNDNUM(m00 * wlPatchParams[i].x2 + m01 * wlPatchParams[i].y2 + m02);
+        wlImageParams[i].y2 = CV_ROUNDNUM(m10 * wlPatchParams[i].x2 + m11 * wlPatchParams[i].y2 + m12);
+        wlImageParams[i].boxRadius = CV_ROUNDNUM(s * wlPatchParams[i].boxRadius);
+    }
+}
+
+/**
+ * @brief Computes the Average Box Weak-Learner response, measuring the difference of
+ * gray level in the two square regions.
+ * @param wlImageParams The weak-learner parameter defining the size and locations of each box.
+ * @param integralImage The integral image used to compute the average gray value in the square regions.
+ * @return The difference of gray level in the two squares defined by wlImageParams
+ */
+template <typename WeakLearnerT>
+static inline float computeABWLResponse(const WeakLearnerT &wlImageParams,
+                                        const cv::Mat &integralImage)
+{
+    CV_DbgAssert(!integralImage.empty());
+    CV_DbgAssert(integralImage.type() == CV_32SC1);
+
+    int frameWidth, frameHeight, box1x1, box1y1, box1x2, box1y2, box2x1, box2y1, box2x2, box2y2;
+    int A, B, C, D;
+    int box_area1, box_area2;
+    float sum1, sum2, average1, average2;
+    // Since the integral image has one extra row and col, calculate the patch dimensions
+    frameWidth = integralImage.cols;
+    frameHeight = integralImage.rows;
+
+    // For the first box, we calculate its margin coordinates
+    box1x1 = wlImageParams.x1 - wlImageParams.boxRadius;
+    if (box1x1 < 0)
+        box1x1 = 0;
+    else if (box1x1 >= frameWidth - 1)
+        box1x1 = frameWidth - 2;
+    box1y1 = wlImageParams.y1 - wlImageParams.boxRadius;
+    if (box1y1 < 0)
+        box1y1 = 0;
+    else if (box1y1 >= frameHeight - 1)
+        box1y1 = frameHeight - 2;
+    box1x2 = wlImageParams.x1 + wlImageParams.boxRadius + 1;
+    if (box1x2 <= 0)
+        box1x2 = 1;
+    else if (box1x2 >= frameWidth)
+        box1x2 = frameWidth - 1;
+    box1y2 = wlImageParams.y1 + wlImageParams.boxRadius + 1;
+    if (box1y2 <= 0)
+        box1y2 = 1;
+    else if (box1y2 >= frameHeight)
+        box1y2 = frameHeight - 1;
+    CV_DbgAssert((box1x1 < box1x2 && box1y1 < box1y2) && "Box 1 has size 0");
+
+    // For the second box, we calculate its margin coordinates
+    box2x1 = wlImageParams.x2 - wlImageParams.boxRadius;
+    if (box2x1 < 0)
+        box2x1 = 0;
+    else if (box2x1 >= frameWidth - 1)
+        box2x1 = frameWidth - 2;
+    box2y1 = wlImageParams.y2 - wlImageParams.boxRadius;
+    if (box2y1 < 0)
+        box2y1 = 0;
+    else if (box2y1 >= frameHeight - 1)
+        box2y1 = frameHeight - 2;
+    box2x2 = wlImageParams.x2 + wlImageParams.boxRadius + 1;
+    if (box2x2 <= 0)
+        box2x2 = 1;
+    else if (box2x2 >= frameWidth)
+        box2x2 = frameWidth - 1;
+    box2y2 = wlImageParams.y2 + wlImageParams.boxRadius + 1;
+    if (box2y2 <= 0)
+        box2y2 = 1;
+    else if (box2y2 >= frameHeight)
+        box2y2 = frameHeight - 1;
+    CV_DbgAssert((box2x1 < box2x2 && box2y1 < box2y2) && "Box 2 has size 0");
+
+    // Read the integral image values for the first box
+    A = integralImage.at<int>(box1y1, box1x1);
+    B = integralImage.at<int>(box1y1, box1x2);
+    C = integralImage.at<int>(box1y2, box1x1);
+    D = integralImage.at<int>(box1y2, box1x2);
+
+    // Calculate the mean intensity value of the pixels in the box
+    sum1 = float(A + D - B - C);
+    box_area1 = (box1y2 - box1y1) * (box1x2 - box1x1);
+    CV_DbgAssert(box_area1 > 0);
+    average1 = sum1 / box_area1;
+
+    // Calculate the indices on the integral image where the box falls
+    A = integralImage.at<int>(box2y1, box2x1);
+    B = integralImage.at<int>(box2y1, box2x2);
+    C = integralImage.at<int>(box2y2, box2x1);
+    D = integralImage.at<int>(box2y2, box2x2);
+
+    // Calculate the mean intensity value of the pixels in the box
+    sum2 = float(A + D - B - C);
+    box_area2 = (box2y2 - box2y1) * (box2x2 - box2x1);
+    CV_DbgAssert(box_area2 > 0);
+    average2 = sum2 / box_area2;
+
+    return average1 - average2;
+}
+
+// descriptor computation using keypoints
+template <class WeakLearnerT>
+void BEBLID_Impl<WeakLearnerT>::compute(InputArray _image, vector<KeyPoint> &keypoints, OutputArray _descriptors)
+{
+    Mat image = _image.getMat();
+
+    if (image.empty())
+        return;
+
+    if (keypoints.empty())
+    {
+        // clean output buffer (it may be reused with "allocated" data)
+        _descriptors.release();
+        return;
+    }
+
+    Mat grayImage;
+    switch (image.type()) {
+    case CV_8UC1:
+        grayImage = image;
+        break;
+    case CV_8UC3:
+        cvtColor(image, grayImage, COLOR_BGR2GRAY);
+        break;
+    case CV_8UC4:
+        cvtColor(image, grayImage, COLOR_BGRA2GRAY);
+        break;
+    default:
+        CV_Error(Error::StsBadArg, "Image should be 8UC1, 8UC3 or 8UC4");
+    }
+
+    cv::Mat integralImg;
+
+    // compute the integral image
+    cv::integral(grayImage, integralImg);
+
+    // Create the output array of descriptors
+    _descriptors.create((int)keypoints.size(), descriptorSize(), descriptorType());
+
+    // descriptor storage
+    cv::Mat descriptors = _descriptors.getMat();
+    CV_DbgAssert(descriptors.type() == CV_8UC1);
+
+    // Compute the BEBLID descriptors
+    computeBoxDiffsDescriptor(integralImg, keypoints, descriptors);
+}
+
+// constructor
+template <class WeakLearnerT>
+BEBLID_Impl<WeakLearnerT>::BEBLID_Impl(float scale_factor, const std::vector<WeakLearnerT>& wl_params)
+    :  wl_params_(wl_params), scale_factor_(scale_factor), patch_size_(32, 32)
+{
+}
+
+// Internal function that implements the core of BEBLID descriptor
+template<class WeakLearnerT>
+void BEBLID_Impl<WeakLearnerT>::computeBoxDiffsDescriptor(const cv::Mat &integralImg,
+                                                          const std::vector<cv::KeyPoint> &keypoints,
+                                                          cv::Mat &descriptors)
+{
+    CV_DbgAssert(!integralImg.empty());
+    CV_DbgAssert(size_t(descriptors.rows) == keypoints.size());
+    const int *integralPtr = integralImg.ptr<int>();
+    cv::Size frameSize(integralImg.cols - 1, integralImg.rows - 1);
+
+    // Parallel Loop to process descriptors
+#ifndef CV_BEBLID_PARALLEL
+    const cv::Range range(0, keypoints.size());
+#else
+    cv::parallel_for_(cv::Range(0, int(keypoints.size())), [&](const Range &range)
+#endif
+    {
+        // Get a pointer to the first element in the range
+        WeakLearnerT *wl;
+        float responseFun;
+        int areaResponseFun, kpIdx;
+        size_t wlIdx;
+        int box1x1, box1y1, box1x2, box1y2, box2x1, box2y1, box2x2, box2y2, bit_idx, side;
+        uchar byte = 0;
+        std::vector<WeakLearnerT> imgWLParams(wl_params_.size());
+        uchar *d = &descriptors.at<uchar>(range.start, 0);
+
+        for (kpIdx = range.start; kpIdx < range.end; kpIdx++)
+        {
+            // Rectify the weak learners coordinates using the keypoint information
+            rectifyABWL(wl_params_, imgWLParams, keypoints[kpIdx], scale_factor_, patch_size_);
+            if (isKeypointInTheBorder(keypoints[kpIdx], frameSize, patch_size_, scale_factor_))
+            {
+                // Code to process the keypoints in the image margins
+                for (wlIdx = 0; wlIdx < wl_params_.size(); wlIdx++) {
+                    bit_idx = 7 - int(wlIdx % 8);
+                    responseFun = computeABWLResponse(imgWLParams[wlIdx], integralImg);
+                    // Set the bit to 1 if the response function is less or equal to the threshod
+                    byte |= (responseFun <= wl_params_[wlIdx].th) << bit_idx;
+                    // If we filled the byte, save it
+                    if (bit_idx == 0)
+                    {
+                        *d = byte;
+                        byte = 0;
+                        d++;
+                    }
+                }
+            }
+            else
+            {
+                // Code to process the keypoints in the image center
+                wl = imgWLParams.data();
+                for (wlIdx = 0; wlIdx < wl_params_.size(); wlIdx++)
+                {
+                    bit_idx = 7 - int(wlIdx % 8);
+
+                    // For the first box, we calculate its margin coordinates
+                    box1x1 = wl->x1 - wl->boxRadius;
+                    box1y1 = (wl->y1 - wl->boxRadius) * integralImg.cols;
+                    box1x2 = wl->x1 + wl->boxRadius + 1;
+                    box1y2 = (wl->y1 + wl->boxRadius + 1) * integralImg.cols;
+                    // For the second box, we calculate its margin coordinates
+                    box2x1 = wl->x2 - wl->boxRadius;
+                    box2y1 = (wl->y2 - wl->boxRadius) * integralImg.cols;
+                    box2x2 = wl->x2 + wl->boxRadius + 1;
+                    box2y2 = (wl->y2 + wl->boxRadius + 1) * integralImg.cols;
+                    side = 1 + (wl->boxRadius << 1);
+
+                    // Get the difference between the average level of the two boxes
+                    areaResponseFun = (integralPtr[box1y1 + box1x1]  // A of Box1
+                        + integralPtr[box1y2 + box1x2]               // D of Box1
+                        - integralPtr[box1y1 + box1x2]               // B of Box1
+                        - integralPtr[box1y2 + box1x1]               // C of Box1
+                        - integralPtr[box2y1 + box2x1]               // A of Box2
+                        - integralPtr[box2y2 + box2x2]               // D of Box2
+                        + integralPtr[box2y1 + box2x2]               // B of Box2
+                        + integralPtr[box2y2 + box2x1]);             // C of Box2
+
+                    // Set the bit to 1 if the response function is less or equal to the threshod
+                    byte |= (areaResponseFun <= (wl_params_[wlIdx].th * (side * side))) << bit_idx;
+                    wl++;
+                    // If we filled the byte, save it
+                    if (bit_idx == 0)
+                    {
+                        *d = byte;
+                        byte = 0;
+                        d++;
+                    }
+                }  // End of for each dimension
+            }  // End of else (of pixels in the image center)
+        }  // End of for each keypoint
+    }  // End of thread scope
+#ifdef CV_BEBLID_PARALLEL
+    );
+#endif
+}
+
+Ptr<BEBLID> BEBLID::create(float scale_factor, int n_bits)
+{
+    if (n_bits == BEBLID::SIZE_512_BITS)
+    {
+        #include "beblid.p512.hpp"
+        return makePtr<BEBLID_Impl<ABWLParams>>(scale_factor, beblid_wl_params_512);
+    }
+    else if(n_bits == BEBLID::SIZE_256_BITS)
+    {
+        #include "beblid.p256.hpp"
+        return makePtr<BEBLID_Impl<ABWLParams>>(scale_factor, beblid_wl_params_256);
+    }
+    else
+    {
+        CV_Error(Error::StsBadArg, "n_bits should be either BEBLID::SIZE_512_BITS or BEBLID::SIZE_256_BITS");
+    }
+}
+
+String BEBLID::getDefaultName() const
+{
+  return (Feature2D::getDefaultName() + ".BEBLID");
+}
+
+String TEBLID::getDefaultName() const
+{
+  return (Feature2D::getDefaultName() + ".TEBLID");
+}
+
+} // END NAMESPACE XFEATURES2D
+} // END NAMESPACE CV
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/beblid.p256.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/beblid.p256.hpp
new file mode 100644
index 00000000..be95345e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/beblid.p256.hpp
@@ -0,0 +1,83 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Author: Iago Suarez <iago.suarez.canosa@alumnos.upm.es>
+
+// Implementation of the article:
+//     Iago Suarez, Ghesn Sfeir, Jose M. Buenaposada, and Luis Baumela.
+//     BEBLID: Boosted Efficient Binary Local Image Descriptor.
+//     Pattern Recognition Letters, 133:366–372, 2020.
+
+// ABWLParams: x1, y1, x2, y2, boxRadius, th
+
+// Pre-trained parameters of BEBLID-256 trained in Liberty data set with
+// a million of patch pairs, 20% positives and 80% negatives
+static const ABWLParams beblid_wl_params_256_[] = {
+    {26, 20, 14, 16, 5, 16}, {17, 17, 15, 15, 2, 7}, {18, 16, 8, 13, 3, 18},
+    {19, 15, 13, 14, 3, 17}, {16, 16, 5, 15, 4, 10}, {25, 10, 16, 16, 6, 11},
+    {16, 15, 12, 15, 1, 12}, {18, 17, 14, 17, 1, 13}, {15, 14, 5, 21, 5, 6}, {14, 14, 11, 7, 4, 2},
+    {23, 27, 16, 17, 4, 8}, {12, 17, 10, 24, 5, 0}, {15, 15, 13, 14, 1, 6}, {16, 16, 14, 16, 1, 7},
+    {19, 18, 16, 15, 1, 6}, {24, 7, 19, 15, 6, 4}, {15, 16, 6, 8, 5, 6}, {24, 16, 8, 15, 7, 22},
+    {15, 6, 13, 16, 4, 6}, {17, 19, 15, 15, 1, 6}, {17, 12, 16, 16, 1, 2}, {11, 15, 7, 25, 6, 0},
+    {15, 15, 14, 10, 2, 2}, {26, 15, 18, 17, 4, 6}, {18, 12, 17, 27, 4, 3}, {9, 15, 6, 8, 6, 1},
+    {15, 17, 14, 23, 3, 1}, {11, 17, 4, 14, 4, 1}, {22, 18, 19, 5, 5, 5}, {11, 18, 11, 5, 5, 3},
+    {22, 5, 19, 19, 5, 2}, {12, 26, 6, 15, 3, 5}, {16, 16, 14, 18, 1, 7}, {22, 26, 22, 13, 5, 2},
+    {18, 13, 16, 16, 1, 4}, {14, 26, 13, 10, 5, 3}, {17, 13, 14, 14, 1, 10}, {21, 16, 19, 7, 3, 4},
+    {14, 15, 14, 13, 1, 0}, {26, 26, 20, 18, 5, 1}, {12, 10, 8, 21, 4, 3}, {14, 17, 13, 7, 3, 0},
+    {13, 12, 10, 19, 2, 4}, {17, 20, 17, 13, 2, 0}, {8, 25, 6, 11, 6, 2}, {27, 11, 20, 24, 4, 3},
+    {14, 18, 12, 14, 2, 5}, {22, 19, 18, 20, 2, 5}, {18, 4, 17, 14, 3, 1}, {13, 28, 13, 18, 3, 3},
+    {15, 12, 14, 17, 1, 4}, {13, 20, 10, 11, 2, 3}, {10, 5, 4, 17, 4, 2}, {7, 18, 3, 18, 3, 2},
+    {21, 11, 15, 2, 2, 11}, {20, 15, 17, 17, 1, 6}, {10, 20, 4, 27, 4, 3}, {24, 25, 23, 7, 6, 0},
+    {18, 15, 18, 12, 2, 0}, {17, 16, 16, 13, 1, 3}, {14, 20, 14, 15, 1, 1}, {17, 17, 17, 14, 1, 0},
+    {7, 15, 6, 5, 5, 3}, {11, 21, 11, 13, 2, 1}, {18, 16, 15, 9, 1, 7}, {19, 19, 18, 15, 1, 2},
+    {28, 19, 20, 16, 3, 1}, {14, 16, 11, 10, 1, 3}, {22, 13, 19, 14, 1, 2}, {9, 10, 4, 4, 4, 3},
+    {20, 26, 10, 29, 2, 12}, {14, 17, 12, 19, 1, 3}, {21, 18, 18, 24, 2, 6}, {16, 15, 15, 19, 1, 4},
+    {27, 4, 24, 15, 4, 2}, {15, 22, 14, 6, 2, 2}, {13, 16, 9, 12, 1, 2}, {12, 12, 11, 18, 1, 2},
+    {22, 17, 20, 11, 2, 2}, {18, 28, 17, 23, 3, 1}, {6, 9, 5, 21, 4, 0}, {12, 3, 8, 11, 3, 5},
+    {21, 16, 19, 16, 1, 2}, {18, 16, 17, 19, 1, 2}, {27, 12, 22, 3, 3, 2}, {13, 27, 4, 26, 4, 3},
+    {5, 22, 3, 26, 3, 2}, {24, 28, 23, 20, 3, 2}, {11, 17, 8, 19, 2, 0}, {13, 16, 11, 16, 1, 3},
+    {18, 15, 18, 8, 2, 1}, {15, 17, 14, 14, 1, 3}, {19, 14, 17, 12, 1, 4}, {25, 10, 22, 20, 2, 0},
+    {14, 12, 13, 9, 1, 1}, {9, 10, 3, 9, 3, 2}, {20, 22, 19, 17, 1, 0}, {16, 24, 16, 10, 2, 0},
+    {15, 23, 13, 29, 2, 2}, {15, 20, 14, 17, 1, 4}, {27, 27, 22, 27, 4, 1}, {14, 7, 6, 3, 3, 3},
+    {21, 3, 20, 7, 3, 0}, {29, 5, 25, 11, 2, 1}, {15, 21, 15, 20, 1, 0}, {8, 17, 8, 11, 2, 1},
+    {17, 13, 17, 8, 1, 0}, {7, 25, 3, 21, 3, 0}, {7, 11, 7, 8, 3, 1}, {4, 11, 3, 26, 3, 2},
+    {15, 18, 15, 11, 1, 1}, {23, 15, 20, 19, 2, 2}, {5, 9, 3, 4, 3, 2}, {28, 18, 25, 8, 3, 0},
+    {20, 22, 17, 30, 1, 5}, {29, 29, 28, 16, 2, 1}, {28, 11, 24, 15, 2, 1}, {20, 7, 18, 9, 1, 2},
+    {19, 12, 18, 16, 1, 2}, {11, 20, 11, 17, 2, 1}, {13, 16, 13, 13, 1, 0}, {29, 3, 23, 5, 2, 0},
+    {19, 21, 17, 18, 1, 3}, {12, 8, 12, 3, 2, 2}, {14, 13, 13, 20, 1, 2}, {11, 21, 9, 29, 2, 3},
+    {7, 30, 6, 22, 1, 2}, {11, 9, 10, 15, 1, 3}, {8, 3, 2, 9, 2, 0}, {19, 7, 18, 3, 3, 2},
+    {21, 9, 19, 11, 1, 1}, {18, 10, 17, 13, 1, 2}, {6, 17, 1, 30, 1, 6}, {17, 29, 16, 28, 2, 1},
+    {17, 20, 17, 18, 1, 0}, {15, 9, 13, 23, 1, 4}, {12, 14, 11, 16, 1, 1}, {7, 17, 5, 14, 2, 1},
+    {30, 30, 23, 12, 1, 2}, {29, 18, 26, 20, 2, 0}, {10, 20, 9, 17, 2, 1}, {4, 15, 2, 8, 2, 2},
+    {7, 7, 7, 3, 3, 1}, {9, 19, 8, 24, 1, 2}, {28, 25, 27, 25, 3, 0}, {13, 15, 12, 18, 1, 1},
+    {25, 2, 19, 5, 2, 2}, {15, 4, 15, 3, 3, 0}, {25, 19, 24, 29, 2, 2}, {18, 24, 18, 20, 1, 1},
+    {4, 10, 1, 2, 1, 3}, {5, 18, 1, 18, 1, 2}, {13, 22, 13, 19, 1, 1}, {10, 26, 8, 28, 2, 0},
+    {24, 13, 24, 6, 1, 1}, {15, 19, 14, 15, 1, 4}, {5, 8, 2, 16, 2, 0}, {12, 4, 11, 2, 2, 0},
+    {14, 29, 14, 24, 1, 1}, {3, 20, 1, 22, 1, 1}, {17, 5, 12, 1, 1, 5}, {21, 16, 20, 23, 1, 2},
+    {25, 17, 22, 13, 1, 0}, {6, 21, 5, 16, 1, 0}, {7, 15, 6, 19, 1, 1}, {20, 17, 19, 15, 1, 1},
+    {3, 29, 3, 23, 2, 1}, {16, 25, 16, 22, 1, 0}, {28, 20, 28, 12, 3, 0}, {27, 13, 23, 10, 1, 0},
+    {24, 24, 17, 29, 1, 5}, {13, 2, 11, 4, 1, 2}, {22, 23, 21, 21, 1, 0}, {19, 30, 19, 24, 1, 1},
+    {30, 30, 26, 27, 1, 0}, {17, 5, 17, 1, 1, 0}, {26, 7, 24, 1, 1, 1}, {28, 6, 28, 3, 3, 0},
+    {3, 15, 1, 13, 1, 1}, {7, 8, 5, 6, 1, 1}, {19, 16, 19, 15, 1, 0}, {12, 9, 11, 7, 1, 0},
+    {17, 22, 16, 20, 1, 2}, {12, 14, 12, 11, 1, 1}, {25, 29, 23, 26, 1, 0}, {15, 19, 15, 18, 1, 0},
+    {13, 22, 12, 25, 1, 0}, {1, 22, 1, 11, 1, 0}, {14, 12, 14, 9, 1, 1}, {10, 27, 9, 23, 1, 2},
+    {9, 4, 6, 1, 1, 1}, {22, 12, 21, 16, 1, 0}, {5, 27, 1, 28, 1, 1}, {30, 14, 28, 7, 1, 0},
+    {17, 9, 16, 21, 1, 2}, {17, 9, 17, 6, 1, 0}, {4, 4, 1, 1, 1, 1}, {30, 2, 28, 5, 1, 0},
+    {18, 4, 17, 7, 1, 1}, {15, 13, 15, 10, 1, 1}, {12, 30, 11, 26, 1, 2}, {16, 28, 15, 29, 1, 1},
+    {30, 11, 28, 11, 1, 0}, {9, 12, 8, 10, 1, 1}, {22, 19, 21, 16, 1, 0}, {30, 20, 29, 26, 1, 0},
+    {22, 10, 20, 7, 1, 2}, {2, 2, 1, 5, 1, 0}, {9, 9, 7, 9, 1, 0}, {27, 1, 25, 3, 1, 0},
+    {21, 23, 20, 25, 1, 1}, {10, 3, 8, 5, 1, 1}, {24, 1, 23, 3, 1, 0}, {5, 29, 4, 28, 1, 0},
+    {27, 23, 26, 18, 1, 1}, {22, 2, 22, 1, 1, 0}, {7, 20, 6, 19, 1, 0}, {12, 26, 9, 25, 1, 2},
+    {7, 1, 5, 2, 1, 0}, {2, 21, 1, 18, 1, 0}, {2, 24, 1, 21, 1, 0}, {8, 17, 8, 14, 1, 0},
+    {30, 1, 28, 2, 1, 0}, {15, 30, 15, 28, 1, 0}, {2, 5, 1, 9, 1, 0}, {18, 28, 17, 26, 1, 1},
+    {7, 29, 1, 30, 1, 1}, {17, 2, 17, 1, 1, 0}, {21, 13, 21, 9, 1, 1}, {29, 15, 27, 15, 1, 0},
+    {28, 8, 27, 7, 2, 0}, {29, 14, 28, 18, 1, 0}, {2, 26, 1, 30, 1, 1}, {16, 8, 16, 6, 1, 0},
+    {30, 26, 26, 24, 1, 0}, {15, 17, 15, 16, 6, 0}, {30, 29, 27, 30, 1, 0}, {3, 30, 1, 28, 1, 0},
+    {17, 1, 16, 2, 1, 1}, {14, 30, 12, 30, 1, 1}, {12, 17, 12, 16, 1, 0}, {4, 18, 4, 16, 1, 0},
+    {11, 4, 11, 1, 1, 1}, {21, 2, 18, 1, 1, 2}, {16, 17, 16, 15, 5, 0}, {3, 1, 2, 2, 1, 0},
+    {23, 17, 23, 16, 1, 0}, {18, 12, 18, 11, 1, 0}, {10, 28, 8, 30, 1, 0}, {12, 10, 12, 8, 1, 1},
+    {2, 14, 1, 9, 1, 1}, {6, 25, 6, 21, 1, 1}, {6, 2, 2, 1, 1, 1}, {30, 19, 29, 20, 1, 0},
+    {25, 21, 23, 20, 1, 0}, {16, 10, 16, 9, 1, 0}
+};
+static const std::vector<ABWLParams> beblid_wl_params_256(std::begin(beblid_wl_params_256_),
+                                                          std::end(beblid_wl_params_256_));
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/beblid.p512.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/beblid.p512.hpp
new file mode 100644
index 00000000..57c97ecc
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/beblid.p512.hpp
@@ -0,0 +1,148 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Author: Iago Suarez <iago.suarez.canosa@alumnos.upm.es>
+
+// Implementation of the article:
+//     Iago Suarez, Ghesn Sfeir, Jose M. Buenaposada, and Luis Baumela.
+//     BEBLID: Boosted Efficient Binary Local Image Descriptor.
+//     Pattern Recognition Letters, 133:366–372, 2020.
+
+// ABWLParams: x1, y1, x2, y2, boxRadius, th
+
+// Pre-trained parameters of BEBLID-512 trained in Liberty data set with
+// a million of patch pairs, 20% positives and 80% negatives
+static const ABWLParams beblid_wl_params_512_[] = {
+    {24, 18, 15, 17, 6, 13}, {19, 14, 13, 17, 2, 18}, {23, 19, 12, 15, 6, 19},
+    {24, 14, 16, 16, 6, 11}, {16, 15, 12, 16, 1, 12}, {16, 15, 7, 10, 4, 10},
+    {17, 12, 8, 17, 3, 16}, {24, 12, 11, 17, 7, 19}, {19, 17, 14, 11, 3, 13},
+    {16, 15, 13, 15, 1, 10}, {16, 14, 6, 18, 5, 10}, {25, 5, 14, 15, 5, 15},
+    {17, 18, 14, 16, 2, 10}, {17, 14, 14, 13, 2, 9}, {15, 14, 6, 22, 5, 7}, {14, 16, 5, 17, 5, 5},
+    {16, 13, 15, 16, 1, 4}, {18, 17, 15, 15, 1, 9}, {26, 26, 15, 14, 5, 12}, {18, 18, 16, 16, 1, 4},
+    {15, 14, 14, 27, 4, 0}, {17, 13, 15, 16, 1, 6}, {15, 15, 13, 14, 1, 6}, {18, 17, 16, 16, 1, 4},
+    {14, 13, 6, 7, 5, 4}, {27, 12, 17, 15, 4, 8}, {12, 13, 7, 24, 7, 2}, {17, 18, 15, 15, 1, 6},
+    {16, 16, 12, 17, 1, 12}, {27, 20, 16, 16, 4, 11}, {12, 14, 7, 5, 5, 0}, {12, 16, 7, 26, 5, 0},
+    {15, 15, 15, 7, 4, -1}, {16, 17, 14, 17, 2, 6}, {16, 13, 10, 6, 4, 7}, {15, 26, 15, 19, 4, 1},
+    {26, 5, 17, 13, 5, 7}, {15, 23, 5, 12, 5, 8}, {17, 14, 10, 11, 3, 14}, {21, 27, 17, 16, 4, 5},
+    {15, 16, 14, 16, 1, 3}, {14, 11, 12, 26, 5, 1}, {12, 14, 12, 5, 4, -3}, {16, 16, 14, 12, 1, 7},
+    {13, 20, 7, 13, 3, 4}, {19, 6, 17, 16, 6, 3}, {11, 9, 10, 19, 4, 2}, {14, 15, 13, 9, 3, 1},
+    {16, 16, 14, 25, 3, 3}, {8, 26, 8, 13, 4, 3}, {16, 14, 15, 19, 2, 3}, {18, 15, 15, 16, 1, 9},
+    {26, 23, 19, 16, 5, 4}, {11, 21, 4, 13, 4, 1}, {20, 16, 20, 5, 4, 2}, {15, 16, 15, 13, 1, 0},
+    {16, 20, 16, 15, 2, 0}, {22, 13, 17, 14, 2, 8}, {18, 17, 14, 15, 1, 13}, {21, 12, 20, 26, 4, 3},
+    {10, 7, 8, 18, 5, 3}, {11, 26, 11, 20, 5, 2}, {13, 21, 13, 17, 3, 1}, {10, 23, 6, 7, 6, 1},
+    {10, 14, 5, 14, 5, 0}, {23, 25, 16, 6, 6, 8}, {18, 16, 18, 5, 4, 1}, {16, 16, 16, 14, 1, 0},
+    {11, 15, 4, 23, 4, -2}, {17, 14, 16, 16, 1, 2}, {26, 4, 20, 24, 4, 2}, {20, 19, 18, 14, 2, 3},
+    {14, 17, 10, 15, 2, 6}, {17, 13, 17, 9, 3, 0}, {26, 21, 5, 24, 5, 20}, {20, 15, 19, 25, 5, 3},
+    {27, 15, 19, 5, 4, 5}, {10, 14, 10, 6, 6, -2}, {12, 22, 11, 10, 3, 2}, {17, 16, 16, 20, 2, 3},
+    {15, 15, 12, 19, 1, 7}, {15, 11, 14, 17, 2, 4}, {14, 20, 10, 15, 2, 7}, {10, 14, 3, 7, 3, -5},
+    {12, 16, 9, 11, 3, 1}, {19, 17, 17, 11, 2, 5}, {26, 7, 19, 26, 5, 4}, {20, 10, 19, 18, 3, 1},
+    {17, 13, 16, 16, 1, 2}, {17, 11, 16, 4, 4, 2}, {15, 19, 14, 12, 2, 3}, {17, 18, 16, 13, 1, 3},
+    {11, 9, 4, 27, 4, -1}, {21, 23, 18, 17, 3, 3}, {7, 21, 6, 7, 5, -1}, {25, 27, 21, 18, 4, -1},
+    {14, 17, 14, 14, 2, 0}, {12, 11, 8, 19, 3, 3}, {14, 15, 13, 22, 2, 0}, {8, 23, 5, 17, 5, 1},
+    {15, 16, 14, 8, 2, 1}, {16, 24, 15, 18, 3, 3}, {19, 25, 19, 18, 5, -1}, {11, 23, 10, 13, 2, 3},
+    {19, 14, 18, 22, 2, 3}, {26, 15, 22, 6, 4, 2}, {24, 17, 19, 8, 3, 5}, {21, 15, 16, 15, 1, 10},
+    {15, 14, 14, 20, 1, 2}, {16, 27, 13, 5, 4, 5}, {10, 4, 5, 13, 4, 3}, {12, 14, 10, 10, 2, 0},
+    {14, 18, 14, 11, 1, -1}, {23, 6, 22, 20, 5, 0}, {14, 12, 10, 19, 2, 6}, {17, 18, 17, 15, 2, 0},
+    {16, 15, 15, 18, 1, 4}, {11, 13, 3, 4, 3, -4}, {15, 14, 15, 8, 2, -1}, {11, 23, 5, 26, 5, 0},
+    {20, 20, 19, 17, 2, 1}, {22, 19, 19, 20, 2, 3}, {16, 5, 15, 24, 4, 2}, {18, 15, 16, 12, 1, 5},
+    {28, 27, 23, 15, 3, -2}, {7, 25, 6, 18, 6, 2}, {12, 19, 12, 13, 3, 0}, {9, 7, 4, 17, 4, 1},
+    {14, 18, 13, 12, 1, 2}, {13, 16, 10, 23, 2, 1}, {24, 25, 23, 13, 6, -1}, {8, 13, 7, 4, 4, -3},
+    {17, 15, 17, 11, 2, 0}, {20, 13, 18, 15, 1, 3}, {28, 3, 23, 15, 3, -2}, {13, 17, 12, 11, 1, 0},
+    {16, 18, 16, 11, 1, 0}, {26, 16, 24, 26, 5, 2}, {14, 14, 11, 15, 1, 6}, {15, 9, 15, 3, 3, -1},
+    {12, 28, 10, 19, 3, 6}, {18, 17, 18, 14, 2, 0}, {16, 14, 14, 15, 1, 7}, {20, 18, 19, 10, 2, 2},
+    {27, 28, 18, 24, 3, 4}, {15, 11, 14, 25, 2, 1}, {16, 18, 15, 16, 1, 3}, {5, 27, 4, 6, 4, 0},
+    {17, 20, 17, 14, 1, 0}, {13, 15, 9, 14, 1, 3}, {9, 23, 3, 23, 3, -1}, {9, 10, 3, 9, 3, -2},
+    {16, 27, 16, 9, 3, 0}, {13, 17, 11, 15, 1, 3}, {14, 18, 14, 15, 1, 0}, {28, 12, 20, 21, 3, 2},
+    {23, 7, 4, 27, 4, 16}, {16, 18, 16, 16, 1, -1}, {13, 16, 12, 19, 1, 1}, {20, 11, 19, 18, 2, 1},
+    {23, 14, 19, 13, 1, 2}, {23, 10, 19, 3, 3, 5}, {15, 18, 13, 15, 1, 6}, {8, 14, 3, 19, 3, -3},
+    {7, 18, 3, 17, 3, -2}, {22, 4, 21, 7, 4, 0}, {3, 28, 3, 18, 3, 2}, {19, 20, 17, 14, 1, 4},
+    {16, 22, 15, 6, 2, 2}, {22, 20, 19, 29, 2, 5}, {11, 21, 9, 14, 2, 2}, {7, 9, 6, 4, 4, -2},
+    {26, 19, 23, 9, 4, 1}, {16, 17, 16, 12, 2, 0}, {15, 5, 3, 4, 3, 4}, {18, 14, 17, 17, 1, 2},
+    {19, 11, 17, 13, 1, 4}, {11, 17, 10, 10, 2, -1}, {15, 23, 12, 29, 2, 3},
+    {28, 20, 24, 17, 3, -1}, {13, 10, 11, 2, 2, -1}, {28, 11, 23, 15, 3, -1},
+    {16, 21, 16, 20, 2, 0}, {8, 8, 7, 17, 2, 2}, {15, 19, 14, 16, 1, 4}, {17, 11, 17, 10, 2, 0},
+    {22, 21, 19, 16, 1, 1}, {13, 17, 13, 14, 1, 0}, {19, 13, 18, 16, 1, 2}, {6, 25, 5, 27, 4, -1},
+    {16, 29, 16, 22, 2, 0}, {23, 27, 23, 22, 4, -1}, {29, 2, 22, 10, 2, -1}, {22, 10, 22, 5, 5, 1},
+    {20, 16, 19, 15, 1, 1}, {20, 9, 19, 14, 1, 0}, {29, 29, 23, 22, 2, -1}, {12, 11, 10, 18, 1, 3},
+    {4, 16, 4, 2, 2, -2}, {14, 8, 13, 2, 2, 0}, {16, 3, 15, 6, 3, 2}, {23, 8, 15, 2, 2, 10},
+    {18, 19, 18, 16, 1, 0}, {12, 21, 6, 18, 1, 2}, {18, 15, 16, 19, 1, 5}, {16, 21, 16, 8, 2, 0},
+    {18, 26, 17, 23, 2, 1}, {7, 8, 3, 3, 3, -3}, {6, 24, 3, 28, 3, -2}, {10, 19, 9, 26, 2, -3},
+    {17, 9, 16, 13, 1, 2}, {13, 15, 13, 10, 1, -2}, {18, 16, 18, 12, 1, 0}, {17, 13, 17, 11, 1, 0},
+    {6, 16, 3, 12, 3, -2}, {15, 21, 15, 20, 1, 0}, {23, 17, 20, 15, 2, 1}, {28, 22, 25, 8, 3, 0},
+    {5, 16, 3, 25, 3, -3}, {14, 13, 13, 20, 1, 2}, {28, 28, 20, 27, 3, 2}, {15, 29, 8, 25, 2, 7},
+    {10, 28, 5, 24, 3, 2}, {19, 14, 18, 13, 1, 2}, {19, 26, 14, 28, 3, 7}, {18, 21, 17, 18, 1, 2},
+    {13, 17, 9, 20, 1, 2}, {15, 13, 13, 11, 1, 4}, {27, 7, 25, 15, 4, -1}, {12, 15, 11, 17, 1, 1},
+    {13, 20, 12, 15, 1, 3}, {15, 20, 14, 22, 1, 2}, {19, 29, 17, 27, 2, 2}, {19, 3, 18, 5, 3, 1},
+    {9, 21, 9, 17, 2, 1}, {19, 18, 17, 18, 1, 4}, {25, 13, 24, 18, 3, 0}, {11, 15, 10, 13, 1, 0},
+    {9, 9, 8, 3, 2, -2}, {6, 8, 3, 8, 3, -1}, {28, 19, 23, 28, 3, 2}, {10, 30, 9, 23, 1, 3},
+    {5, 5, 3, 18, 3, 1}, {14, 17, 12, 20, 1, 3}, {29, 16, 23, 15, 2, -1}, {23, 15, 21, 22, 2, 2},
+    {28, 3, 25, 5, 3, 0}, {12, 20, 11, 17, 1, 2}, {20, 22, 18, 20, 1, 2}, {5, 9, 2, 2, 2, -3},
+    {7, 27, 3, 19, 3, 1}, {13, 2, 7, 6, 2, 4}, {18, 29, 17, 25, 2, 1}, {15, 21, 14, 17, 1, 4},
+    {13, 29, 12, 26, 2, 2}, {5, 22, 4, 12, 2, 0}, {16, 21, 16, 11, 1, 0}, {16, 23, 16, 10, 1, 0},
+    {11, 5, 10, 11, 2, 3}, {15, 10, 14, 21, 1, 3}, {10, 18, 9, 18, 1, 0}, {17, 9, 16, 5, 2, 2},
+    {19, 19, 19, 12, 1, 0}, {25, 12, 22, 4, 2, 2}, {6, 18, 1, 20, 1, -3}, {10, 13, 10, 10, 2, -1},
+    {25, 16, 22, 16, 1, 0}, {18, 13, 18, 12, 1, 0}, {14, 13, 12, 11, 1, 3}, {10, 27, 1, 29, 1, -1},
+    {13, 8, 11, 6, 1, 1}, {24, 24, 21, 28, 3, 2}, {22, 17, 20, 17, 1, 1}, {12, 13, 11, 18, 1, 1},
+    {23, 3, 21, 7, 3, 0}, {18, 12, 17, 13, 1, 2}, {7, 28, 7, 25, 3, 1}, {28, 28, 28, 15, 3, -1},
+    {17, 7, 17, 2, 2, 0}, {19, 9, 17, 11, 1, 3}, {14, 23, 14, 9, 1, 0}, {7, 22, 7, 19, 2, 1},
+    {29, 24, 29, 2, 2, 0}, {28, 15, 25, 11, 3, 0}, {5, 11, 1, 10, 1, -2}, {2, 22, 2, 2, 2, -1},
+    {22, 30, 16, 27, 1, 5}, {20, 15, 19, 13, 1, 1}, {23, 19, 22, 14, 2, 0}, {5, 7, 5, 3, 3, -1},
+    {19, 20, 18, 18, 1, 1}, {29, 9, 25, 13, 2, -1}, {29, 23, 26, 23, 2, 0}, {9, 13, 8, 8, 1, -2},
+    {21, 22, 21, 18, 2, -1}, {29, 12, 28, 20, 2, 0}, {18, 5, 1, 4, 1, 9}, {17, 4, 17, 2, 2, 0},
+    {28, 29, 24, 25, 2, 0}, {14, 23, 13, 29, 1, 0}, {13, 5, 13, 1, 1, -1}, {20, 25, 20, 21, 1, -1},
+    {6, 5, 2, 11, 2, 0}, {10, 14, 9, 21, 1, -1}, {13, 16, 13, 14, 1, 0}, {19, 17, 18, 14, 1, 2},
+    {14, 21, 14, 17, 1, 1}, {20, 10, 18, 12, 1, 2}, {20, 4, 19, 3, 3, 1}, {3, 15, 1, 30, 1, -3},
+    {13, 4, 8, 1, 1, 2}, {10, 18, 9, 14, 1, 0}, {6, 15, 1, 12, 1, -3}, {10, 25, 10, 20, 1, 2},
+    {14, 11, 14, 7, 1, -1}, {22, 9, 20, 4, 1, 2}, {15, 27, 8, 30, 1, 4}, {10, 5, 10, 2, 2, -1},
+    {17, 16, 16, 12, 1, 3}, {15, 18, 15, 10, 1, -1}, {20, 30, 20, 23, 1, -1}, {14, 9, 13, 22, 1, 2},
+    {14, 22, 12, 25, 1, 2}, {5, 23, 2, 23, 2, -1}, {10, 16, 9, 16, 1, 0}, {26, 2, 19, 4, 1, 2},
+    {3, 23, 2, 13, 2, 0}, {3, 17, 3, 7, 2, -1}, {15, 26, 15, 23, 1, 0}, {22, 14, 22, 8, 1, 1},
+    {28, 9, 27, 6, 3, 0}, {26, 22, 25, 28, 3, 1}, {17, 10, 17, 5, 1, 1}, {11, 21, 10, 17, 1, 2},
+    {20, 18, 20, 16, 1, 0}, {7, 20, 5, 20, 1, -1}, {17, 24, 17, 8, 1, 0}, {24, 9, 20, 9, 1, 1},
+    {4, 13, 1, 16, 1, -1}, {30, 1, 28, 16, 1, -1}, {17, 21, 17, 17, 1, 0}, {19, 4, 11, 2, 1, 9},
+    {30, 5, 24, 6, 1, 0}, {22, 19, 22, 12, 1, 0}, {9, 16, 9, 12, 1, -1}, {12, 16, 12, 12, 1, -1},
+    {12, 24, 11, 29, 1, -1}, {3, 6, 1, 4, 1, -1}, {23, 29, 20, 27, 2, 1}, {23, 17, 22, 16, 1, 0},
+    {30, 20, 26, 22, 1, 0}, {9, 2, 6, 5, 2, 1}, {20, 17, 19, 16, 1, 1}, {18, 26, 17, 30, 1, 1},
+    {29, 14, 28, 14, 2, 0}, {20, 13, 19, 14, 1, 1}, {15, 23, 15, 21, 1, 0}, {8, 26, 2, 30, 1, -2},
+    {4, 5, 3, 2, 2, -1}, {7, 16, 6, 12, 1, -1}, {29, 9, 23, 2, 2, 1}, {13, 2, 12, 5, 2, 2},
+    {20, 18, 19, 21, 1, 2}, {7, 29, 2, 25, 2, 0}, {20, 3, 18, 8, 1, 1}, {14, 14, 14, 11, 1, -1},
+    {12, 12, 12, 10, 1, -1}, {17, 27, 15, 30, 1, 2}, {22, 27, 20, 29, 2, 1}, {7, 12, 5, 9, 1, -2},
+    {30, 30, 24, 24, 1, 0}, {19, 3, 19, 2, 2, 0}, {13, 19, 12, 18, 1, 2}, {3, 30, 2, 24, 1, 1},
+    {9, 14, 7, 19, 1, -1}, {17, 22, 17, 18, 1, 0}, {18, 24, 17, 22, 1, 1}, {2, 18, 1, 23, 1, -1},
+    {30, 23, 24, 19, 1, -1}, {11, 10, 11, 5, 1, -2}, {9, 30, 9, 27, 1, 1}, {21, 13, 20, 8, 1, 2},
+    {6, 3, 2, 2, 2, -1}, {23, 22, 22, 26, 1, 1}, {12, 26, 11, 25, 1, 1}, {22, 1, 19, 5, 1, 1},
+    {4, 24, 1, 25, 1, -1}, {5, 13, 5, 7, 1, -1}, {26, 22, 24, 16, 1, -1}, {27, 8, 27, 3, 2, 0},
+    {13, 18, 13, 16, 1, 0}, {19, 15, 18, 17, 1, 2}, {30, 29, 26, 28, 1, 0}, {20, 15, 20, 14, 1, 0},
+    {3, 18, 1, 15, 1, -1}, {18, 11, 17, 10, 1, 2}, {4, 18, 4, 16, 1, 0}, {8, 27, 5, 30, 1, -1},
+    {30, 15, 28, 22, 1, 0}, {9, 19, 8, 22, 1, -1}, {30, 4, 29, 4, 1, 0}, {17, 10, 17, 8, 1, 0},
+    {22, 6, 22, 1, 1, 1}, {2, 11, 1, 15, 1, 0}, {3, 16, 1, 17, 1, -1}, {9, 3, 8, 2, 2, 0},
+    {3, 11, 1, 10, 1, -1}, {16, 29, 15, 28, 1, 1}, {15, 20, 15, 19, 1, 0}, {20, 17, 19, 17, 1, 1},
+    {10, 3, 9, 8, 1, 2}, {10, 22, 7, 26, 1, -1}, {8, 16, 6, 16, 1, -1}, {16, 28, 16, 25, 1, 0},
+    {12, 25, 10, 21, 1, 3}, {8, 9, 7, 7, 1, -1}, {3, 1, 1, 6, 1, 0}, {16, 7, 15, 9, 1, 2},
+    {30, 23, 29, 23, 1, 0}, {22, 24, 21, 29, 1, 1}, {15, 1, 14, 3, 1, 1}, {18, 6, 17, 9, 1, 1},
+    {26, 25, 25, 19, 1, -1}, {25, 13, 22, 18, 1, 0}, {11, 1, 10, 3, 1, 1}, {29, 28, 28, 30, 1, 0},
+    {16, 17, 16, 13, 5, 0}, {28, 18, 28, 12, 2, 0}, {3, 22, 1, 23, 1, -1}, {10, 11, 10, 9, 1, -1},
+    {7, 13, 6, 20, 1, -1}, {1, 15, 1, 6, 1, -1}, {16, 12, 16, 11, 1, 0}, {3, 26, 2, 30, 1, -1},
+    {28, 30, 26, 23, 1, -1}, {17, 22, 16, 25, 1, 2}, {30, 13, 26, 7, 1, 0}, {10, 8, 7, 10, 1, 1},
+    {2, 27, 1, 22, 1, 0}, {30, 7, 27, 8, 1, 0}, {22, 19, 21, 22, 1, 1}, {5, 19, 4, 21, 1, -1},
+    {24, 6, 23, 11, 1, -1}, {24, 17, 23, 14, 1, 0}, {30, 7, 28, 1, 1, 0}, {11, 16, 11, 15, 1, 0},
+    {29, 2, 26, 4, 1, 0}, {20, 4, 18, 1, 1, 2}, {18, 2, 17, 3, 1, 1}, {20, 30, 18, 29, 1, 1},
+    {29, 15, 29, 9, 2, 0}, {14, 8, 14, 5, 1, -1}, {17, 15, 16, 18, 1, 3}, {12, 4, 11, 2, 2, 0},
+    {23, 8, 21, 11, 1, 0}, {8, 30, 7, 24, 1, 2}, {2, 20, 1, 16, 1, 0}, {15, 26, 14, 29, 1, 1},
+    {4, 30, 3, 29, 1, 0}, {19, 17, 19, 16, 1, 0}, {13, 17, 13, 15, 1, 0}, {2, 9, 1, 1, 1, -1},
+    {30, 28, 27, 27, 1, 0}, {27, 4, 26, 1, 1, 0}, {19, 23, 19, 20, 1, -1}, {15, 24, 15, 23, 1, 0},
+    {2, 29, 1, 28, 1, 0}, {2, 5, 1, 6, 1, 0}, {24, 29, 23, 26, 1, 0}, {13, 12, 12, 11, 1, 1},
+    {12, 17, 12, 15, 1, 0}, {24, 26, 24, 22, 1, -1}, {11, 3, 10, 5, 1, 1}, {30, 2, 30, 1, 1, 0},
+    {18, 30, 18, 29, 1, 0}, {30, 25, 29, 29, 1, 0}, {12, 30, 10, 28, 1, 1}, {24, 12, 22, 14, 1, 0},
+    {6, 13, 4, 15, 1, -1}, {2, 26, 2, 23, 1, 0}, {8, 9, 7, 13, 1, 1}, {30, 1, 27, 1, 1, 0},
+    {26, 29, 24, 30, 1, 0}, {18, 11, 18, 10, 1, 0}, {30, 19, 29, 17, 1, 0}, {20, 27, 19, 24, 1, 0},
+    {28, 20, 26, 24, 1, 0}, {25, 9, 24, 9, 1, 0}, {27, 4, 24, 6, 1, 0}, {23, 21, 22, 19, 1, 0},
+    {7, 13, 7, 10, 1, -1}, {12, 11, 11, 11, 1, 1}, {28, 26, 26, 26, 1, 0}, {8, 4, 6, 4, 1, 0},
+    {15, 30, 15, 28, 1, 0}, {30, 14, 28, 14, 1, 0}, {17, 7, 17, 5, 1, 0}, {29, 10, 28, 6, 1, 0},
+    {12, 17, 11, 17, 1, 1}, {16, 3, 16, 1, 1, 0}, {21, 3, 19, 3, 1, 1}, {12, 30, 11, 28, 1, 1},
+    {18, 16, 18, 15, 1, 0}, {8, 18, 7, 20, 1, -1}, {5, 4, 1, 1, 1, -1}, {3, 27, 1, 30, 1, -1},
+    {26, 4, 26, 1, 1, 0}, {5, 21, 2, 20, 1, -1}, {14, 1, 13, 3, 1, 1}, {30, 9, 28, 8, 1, 0},
+    {13, 15, 12, 12, 1, 1}, {7, 23, 6, 25, 1, -1}
+};
+static const std::vector<ABWLParams> beblid_wl_params_512(std::begin(beblid_wl_params_512_),
+                                                          std::end(beblid_wl_params_512_));
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/boostdesc.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/boostdesc.cpp
new file mode 100644
index 00000000..0e744590
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/boostdesc.cpp
@@ -0,0 +1,778 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2013, 2016
+ *
+ * Tomasz Trzcinski <t dot trzcinski at ii dot pw dot edu dot pl>
+ * Mario Christoudias <mariochristoudias at gmail dot com>
+ * Vincent Lepetit <lepetit at icg dot tugraz dot at>
+ *
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the copyright holders nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+/*
+
+ "Learning Image Descriptors with Boosting"
+ T. Trzcinski, M. Christoudias and V. Lepetit
+ IEEE Transactions on Pattern Analysis and Machine Intelligence, 2013
+
+ "Boosting Binary Keypoint Descriptors"
+ T. Trzcinski, M. Christoudias, V. Lepetit and P. Fua
+ Computer Vision and Pattern Recognition (CVPR), 2013
+
+ Original code: Tomasz Trzcinski <t dot trzcinski at ii dot pw dot edu dot pl>
+ OpenCV port by: Cristian Balint <cristian dot balint at gmail dot com>
+
+ */
+
+#include <bitset>
+#include "precomp.hpp"
+
+
+
+using namespace cv;
+using namespace std;
+
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+#ifdef OPENCV_XFEATURES2D_HAS_BOOST_DATA
+
+/*
+ !BoostDesc implementation
+ */
+class BoostDesc_Impl CV_FINAL : public BoostDesc
+{
+
+public:
+
+    // constructor
+    explicit BoostDesc_Impl( int desc = BINBOOST_256,
+                             bool use_scale_orientation = true,
+                             float scale_factor = 6.25f );
+
+    // destructor
+    ~BoostDesc_Impl() CV_OVERRIDE;
+
+    void read( const FileNode& fn ) CV_OVERRIDE;
+    void write( FileStorage& fs ) const CV_OVERRIDE;
+
+    // returns the descriptor length in bytes
+    int descriptorSize() const CV_OVERRIDE { return m_descriptor_size; }
+
+    // returns the descriptor type
+    int descriptorType() const CV_OVERRIDE { return m_descriptor_type; }
+
+    // returns the default norm type
+    int defaultNorm()    const CV_OVERRIDE { return m_descriptor_norm; }
+
+    // compute descriptors given keypoints
+    void compute( InputArray image, vector<KeyPoint>& keypoints, OutputArray descriptors ) CV_OVERRIDE;
+
+    // getter / setter
+    void setUseScaleOrientation(const bool use_scale_orientation) CV_OVERRIDE { m_use_scale_orientation = use_scale_orientation; }
+    bool getUseScaleOrientation() const CV_OVERRIDE { return m_use_scale_orientation; }
+
+    void setScaleFactor(const float scale_factor) CV_OVERRIDE { m_scale_factor = scale_factor; }
+    float getScaleFactor() const CV_OVERRIDE { return m_scale_factor; }
+
+protected:
+
+    /*
+     * BoostDesc parameters
+     */
+
+    // size, type, norm
+    int m_descriptor_size;
+    int m_descriptor_type;
+    int m_descriptor_norm;
+
+    // desc type
+    int m_desc_type;
+
+    // gradient
+    // assignment types
+    enum Assign
+    {
+      ASSIGN_HARD      = 0,
+      ASSIGN_BILINEAR  = 1,
+      ASSIGN_SOFT      = 2,
+      ASSIGN_HARD_MAGN = 3,
+      ASSIGN_SOFT_MAGN = 4
+    };
+
+    // dims
+    int m_Dims;
+
+    // no. weak
+    // learners
+    int m_nWLs;
+
+    // gradient type
+    int m_grad_atype;
+
+    // patch size
+    int m_patch_size;
+
+    // orient quantity
+    int m_orient_q;
+
+    // patch scale factor
+    float m_scale_factor;
+
+    /*
+     * BoostDesc switches
+     */
+
+    // switch to enable sample by keypoints orientation
+    bool m_use_scale_orientation;
+
+
+    /*
+     * BoostDesc arrays
+     */
+
+    // image
+    Mat m_image;
+
+    // parameters
+    // weak learner
+    Mat m_wl_thresh;
+    Mat m_wl_orient;
+    Mat m_wl_x_min, m_wl_x_max;
+    Mat m_wl_y_min, m_wl_y_max;
+    Mat m_wl_alpha, m_wl_beta;
+
+private:
+
+    /*
+     * BoostDesc functions
+     */
+
+     // initialize parameters
+     inline void ini_params( const int orientQuant, const int patchSize,
+                             const int iGradAssignType,
+                             const int nDim, const int nWLs,
+                             const unsigned int thresh[], const int orient[],
+                             const int x_min[], const int x_max[],
+                             const int y_min[], const int y_max[],
+                             const unsigned int alpha[],  const unsigned int beta[] );
+
+}; // END BoostDesc_Impl CLASS
+
+// -------------------------------------------------
+/* BoostDesc internal routines */
+
+static void computeGradientMaps( const Mat& im,
+                                 const int gradAssignType,
+                                 const int orientQuant,
+                                 vector<Mat>& gradMap )
+{
+    enum Assign
+    {
+      ASSIGN_HARD      = 0,
+      ASSIGN_BILINEAR  = 1,
+      ASSIGN_SOFT      = 2,
+      ASSIGN_HARD_MAGN = 3,
+      ASSIGN_SOFT_MAGN = 4
+    };
+
+    Mat derivx( im.size(), CV_32FC1 );
+    Mat derivy( im.size(), CV_32FC1 );
+
+    Sobel( im, derivx, derivx.depth(), 1, 0 );
+    Sobel( im, derivy, derivy.depth(), 0, 1 );
+
+    for ( int i = 0; i < orientQuant; i++ )
+      gradMap.push_back( Mat::zeros( im.size(), CV_8UC1 ) );
+
+    int index, index2;
+    double binCenter, weight;
+    double binSize = (2 * CV_PI) / orientQuant;
+
+    // fill in temp matrices with
+    // respones to edge detection
+    const float* pDerivx = derivx.ptr<float>();
+    const float* pDerivy = derivy.ptr<float>();
+
+    for ( int i = 0; i < im.rows; i++ )
+    {
+      for ( int j = 0; j < im.cols; j++ )
+      {
+        float gradMagnitude = sqrt( (*pDerivx) * (*pDerivx)
+                                  + (*pDerivy) * (*pDerivy) );
+        if ( gradMagnitude > 20 )
+        {
+          double theta = atan2( *pDerivy, *pDerivx );
+          theta = ( theta < 0 ) ? theta + 2*CV_PI : theta;
+          index = int( theta / binSize );
+          index = ( index == orientQuant ) ? 0 : index;
+
+          switch ( gradAssignType )
+          {
+            case ASSIGN_HARD:
+              gradMap[index].at<uchar>(i,j) = 1;
+              break;
+
+            case ASSIGN_HARD_MAGN:
+              gradMap[index].at<uchar>(i,j) = (uchar) cvRound( gradMagnitude );
+              break;
+
+            case ASSIGN_BILINEAR:
+              index2 = (int) ceil( theta / binSize );
+              index2 = ( index2 == orientQuant ) ? 0 : index2;
+              binCenter  = ( index + 0.5f ) * binSize;
+              weight = 1 - abs( theta - binCenter ) / binSize;
+              gradMap[index ].at<uchar>(i,j) = (uchar) cvRound( 255 * weight );
+              gradMap[index2].at<uchar>(i,j) = (uchar) cvRound( 255 * ( 1 - weight ) );
+              break;
+
+            case ASSIGN_SOFT:
+              for ( int binNum = 0; binNum < orientQuant/2 + 1; binNum++ )
+              {
+                index2 = ( binNum + index + orientQuant - orientQuant/4 ) % orientQuant;
+                binCenter = ( index2 + 0.5f ) * binSize;
+                weight = cos( theta - binCenter );
+                weight = ( weight < 0 ) ? 0 : weight;
+                gradMap[index2].at<uchar>(i,j) = (uchar) cvRound( 255 * weight );
+              }
+              break;
+
+            case ASSIGN_SOFT_MAGN:
+              for ( int binNum = 0; binNum < orientQuant/2 + 1; binNum++ )
+              {
+                index2 = ( binNum + index + orientQuant - orientQuant/4 ) % orientQuant;
+                binCenter = ( index2 + 0.5f ) * binSize;
+                weight = cos( theta - binCenter );
+                weight = ( weight < 0 ) ? 0 : weight;
+                gradMap[index2].at<uchar>(i,j) = (uchar) cvRound( gradMagnitude * weight );
+              }
+              break;
+          } // end switch
+        }
+        ++pDerivy;
+        ++pDerivx;
+      }
+    }
+}
+
+static void computeIntegrals( const vector<Mat>& gradMap,
+                              const int orientQuant,
+                              vector<Mat>& integralMap )
+{
+    // init integral images
+    int rows = gradMap[0].rows;
+    int cols = gradMap[0].cols;
+
+    for ( int i = 0; i < orientQuant+1; i++ )
+      integralMap.push_back( Mat::zeros( rows+1, cols+1, CV_8UC1 ) );
+
+    // generate corresponding integral images
+    for( int i = 0; i < orientQuant; i++ )
+      integral( gradMap[i], integralMap[i] );
+
+    // copy the values from the first quantization bin
+    integralMap[0].copyTo( integralMap[orientQuant] );
+
+    int* ptrSum, *ptr;
+    for ( int k = 1; k < orientQuant; k++ )
+    {
+      ptr    = (int*) integralMap[k].ptr<int>();
+      ptrSum = (int*) integralMap[orientQuant].ptr<int>();
+      for (int i=0; i<(rows+1)*(cols+1); ++i)
+      {
+        *ptrSum += *ptr;
+        ++ptrSum;
+        ++ptr;
+      }
+    }
+}
+
+static float computeWLResponse( const int x_min,  const int x_max,
+                                const int y_min,  const int y_max,
+                                const int orient, const float thresh,
+                                const int orientQuant,
+                                const vector<Mat>& integralMap )
+{
+    const int width = integralMap[0].cols;
+
+    const int idx1 = (y_min    ) * width + x_min;
+    const int idx2 = (y_min    ) * width + x_max + 1;
+    const int idx3 = (y_max + 1) * width + x_min;
+    const int idx4 = (y_max + 1) * width + x_max + 1;
+
+    const int* ptr = integralMap[orient].ptr<int>();
+
+    int A, B ,C, D;
+    A = ptr[idx1]; B = ptr[idx2];
+    C = ptr[idx3]; D = ptr[idx4];
+
+    const float current = float(D + A - B - C);
+
+    ptr = integralMap[orientQuant].ptr<int>();
+
+    A = ptr[idx1]; B = ptr[idx2];
+    C = ptr[idx3]; D = ptr[idx4];
+
+    const float total = float(D + A - B - C);
+
+    return total ? ( (current / total) - thresh ) : 0.f;
+}
+
+static void rectifyPatch( const Mat& image, const KeyPoint& kp,
+                          const int& patchSize, Mat& patch,
+                          const bool use_scale_orientation,
+                          const float scale_factor )
+{
+    Mat M;
+    if ( use_scale_orientation )
+    {
+      const float s = scale_factor * (float) kp.size / (float) patchSize;
+
+      const float cosine = (kp.angle>=0) ? cos(kp.angle*(float)CV_PI/180.0f) : 1.f;
+      const float sine   = (kp.angle>=0) ? sin(kp.angle*(float)CV_PI/180.0f) : 0.f;
+
+      float M_[] = {
+          s*cosine, -s*sine,   (-s*cosine + s*sine  ) * patchSize/2.0f + kp.pt.x,
+          s*sine,    s*cosine, (-s*sine   - s*cosine) * patchSize/2.0f + kp.pt.y
+      };
+      M = Mat( 2, 3, CV_32FC1, M_ ).clone();
+    }
+    else
+    {
+        const float s = scale_factor * (float)kp.size / (float)patchSize;
+        float M_[] = {
+          s,  0.f, -s * patchSize/2.0f + kp.pt.x,
+          0.f,  s, -s * patchSize/2.0f + kp.pt.y
+      };
+      M = Mat( 2, 3, CV_32FC1, M_ ).clone();
+    }
+
+    warpAffine( image, patch, M, Size( patchSize, patchSize ),
+                WARP_INVERSE_MAP + INTER_CUBIC + WARP_FILL_OUTLIERS );
+}
+
+// -------------------------------------------------
+/* BoostDesc interface implementation */
+
+struct ComputeBoostDescInvoker : ParallelLoopBody
+{
+    ComputeBoostDescInvoker( const Mat& _image, Mat* _descriptors,
+                        const vector<KeyPoint>& _keypoints,
+                        const int _desc_type, const int _grad_atype,
+                        const int _orient_q, const int _patch_size,
+                        const int _nWLs, const int _Dims,
+                        const Mat& _wl_x_min, const Mat& _wl_x_max,
+                        const Mat& _wl_y_min, const Mat& _wl_y_max,
+                        const Mat& _wl_thresh, const Mat& _wl_orient,
+                        const Mat& _wl_alpha, const Mat& _wl_beta,
+                        const bool _use_scale_orientation,
+                        const float _scale_factor )
+    {
+      nWLs = _nWLs;
+      Dims = _Dims;
+      image = _image;
+      orient_q = _orient_q;
+      desc_type = _desc_type;
+      keypoints = _keypoints;
+      grad_atype = _grad_atype;
+      patch_size = _patch_size;
+      descriptors = _descriptors;
+
+      wl_beta = _wl_beta;
+      wl_alpha = _wl_alpha;
+      wl_x_min = _wl_x_min;
+      wl_x_max = _wl_x_max;
+      wl_y_min = _wl_y_min;
+      wl_y_max = _wl_y_max;
+      wl_thresh = _wl_thresh;
+      wl_orient = _wl_orient;
+
+      scale_factor = _scale_factor;
+      use_scale_orientation  = _use_scale_orientation;
+    }
+
+    void operator ()( const cv::Range& range ) const CV_OVERRIDE
+    {
+      // maps
+      vector<Mat> gradMap, integralMap;
+
+      // small binary map
+      uchar binLookUp[8];
+      for ( unsigned int i = 0; i < 8; i++ )
+        binLookUp[i] = (uchar) 1 << i;
+
+      for ( int i = range.start; i < range.end; i++ )
+      {
+
+        Mat patch;
+        // rectify the patch around a given keypoint
+        rectifyPatch( image, keypoints[i], patch_size,
+                      patch, use_scale_orientation, scale_factor );
+
+        // compute gradient maps (and integral gradient maps)
+        computeGradientMaps( patch, grad_atype, orient_q, gradMap );
+        computeIntegrals( gradMap, orient_q, integralMap );
+
+        float WLR;
+
+        /*
+         * BGM
+         */
+        if ( ( desc_type == BGM ) ||
+             ( desc_type == BGM_HARD ) ||
+             ( desc_type == BGM_BILINEAR )
+           )
+        {
+          uchar* desc = descriptors->ptr<uchar>(i);
+          for ( int j = 0; j < nWLs; j++ )
+          {
+            WLR = computeWLResponse( wl_x_min.at<int>(0,j), wl_x_max.at<int>(0,j),
+                                     wl_y_min.at<int>(0,j), wl_y_max.at<int>(0,j),
+                                     wl_orient.at<int>(0,j), wl_thresh.at<float>(0,j),
+                                     orient_q, integralMap );
+            desc[j/8] |=  ( WLR >= 0 ) ? binLookUp[ j % 8 ] : 0;
+          }
+        } // end BGM
+
+        /*
+         * LBGM
+         */
+        if ( desc_type == LBGM )
+        {
+          std::bitset<512> wlResponses;
+
+          for ( int j = 0; j < nWLs; j++ )
+          {
+            WLR = computeWLResponse( wl_x_min.at<int>(0,j), wl_x_max.at<int>(0,j),
+                                     wl_y_min.at<int>(0,j), wl_y_max.at<int>(0,j),
+                                     wl_orient.at<int>(0,j), wl_thresh.at<float>(0,j),
+                                     orient_q, integralMap );
+            wlResponses[j] = ( WLR >= 0 ) ? 1 : 0;
+        }
+
+          float* desc = descriptors->ptr<float>(i);
+          for ( int d = 0; d < Dims; d++ )
+          {
+            for ( int wl = 0; wl < nWLs; wl++ )
+            {
+              desc[d] += ( wlResponses[wl] ) ? wl_beta.at<float>(wl,d) : -wl_beta.at<float>(wl,d);
+            }
+          }
+        } // end LBGM
+
+        /*
+         * BINBOOST
+         */
+        if ( ( desc_type == BINBOOST_64  ) ||
+             ( desc_type == BINBOOST_128 ) ||
+             ( desc_type == BINBOOST_256 )
+           )
+        {
+          float resp;
+          for ( int d = 0; d < Dims; d++ )
+          {
+            resp = 0;
+            uchar* desc = descriptors->ptr<uchar>(i);
+            for ( int wl = 0; wl < nWLs; wl++ )
+            {
+              WLR = computeWLResponse( wl_x_min.at<int>(d,wl), wl_x_max.at<int>(d,wl),
+                                       wl_y_min.at<int>(d,wl), wl_y_max.at<int>(d,wl),
+                                       wl_orient.at<int>(d,wl), wl_thresh.at<float>(d,wl),
+                                       orient_q, integralMap );
+              resp += ( WLR >= 0 ) ? wl_beta.at<float>(d,wl) : -wl_beta.at<float>(d,wl);
+            }
+            desc[d/8] |= ( resp >= 0 ) ? binLookUp[d%8] : 0;
+          }
+        } // end BINBOOST
+
+        // clean-up
+        patch.release();
+        gradMap.clear();
+        integralMap.clear();
+
+      } // end for loop
+    } // end operator
+
+    int nWLs;
+    int Dims;
+    int orient_q;
+    int desc_type;
+    int patch_size;
+    int grad_atype;
+    int patch_szie;
+
+    Mat image;
+    Mat *descriptors;
+    vector<KeyPoint> keypoints;
+
+    Mat wl_x_min, wl_x_max, wl_y_min, wl_y_max;
+    Mat wl_thresh, wl_orient, wl_alpha, wl_beta;
+
+    float scale_factor;
+    bool use_scale_orientation;
+
+    enum
+    {
+      BGM = 100, BGM_HARD = 101, BGM_BILINEAR = 102, LBGM = 200,
+      BINBOOST_64 = 300, BINBOOST_128 = 301, BINBOOST_256 = 302
+    };
+};
+
+// descriptor computation using keypoints
+void BoostDesc_Impl::compute( InputArray _image, vector<KeyPoint>& keypoints, OutputArray _descriptors )
+{
+    // do nothing if no image
+    if( _image.getMat().empty() )
+      return;
+
+    if( keypoints.empty() )
+      return;
+
+    m_image = _image.getMat().clone();
+
+    // Only 8bit images
+    CV_Assert( m_image.depth() == CV_8U );
+
+    // convert to gray inplace
+    if( m_image.channels() > 1 )
+      cvtColor( m_image, m_image, COLOR_BGR2GRAY );
+
+    // initialize the variables
+    _descriptors.create( (int)keypoints.size(), descriptorSize(), descriptorType() );
+    _descriptors.setTo( Scalar::all(0) );
+
+    // descriptor storage
+    Mat descriptors = _descriptors.getMat();
+
+    parallel_for_( Range( 0, (int) keypoints.size() ),
+        ComputeBoostDescInvoker( m_image, &descriptors, keypoints,
+                            m_desc_type, m_grad_atype, m_orient_q,
+                            m_patch_size, m_nWLs, m_Dims,
+                            m_wl_x_min, m_wl_x_max, m_wl_y_min, m_wl_y_max,
+                            m_wl_thresh, m_wl_orient, m_wl_alpha, m_wl_beta,
+                            m_use_scale_orientation, m_scale_factor )
+    );
+}
+
+void BoostDesc_Impl::ini_params( const int orientQuant, const int patchSize,
+                                 const int iGradAssignType,
+                                 const int nDim, const int nWLs,
+                                 const unsigned int thresh[], const int orient[],
+                                 const int x_min[], const int x_max[],
+                                 const int y_min[], const int y_max[],
+                                 const unsigned int alpha[], const unsigned int beta[] )
+{
+    // desc type, norm, size
+    if ( m_desc_type == LBGM )
+    {
+      m_descriptor_size = nDim;
+      m_descriptor_norm = NORM_L2;
+      m_descriptor_type = CV_32FC1;
+    }
+    else
+    {
+      if ( ( m_desc_type == BGM ) ||
+           ( m_desc_type == BGM_HARD ) ||
+           ( m_desc_type == BGM_BILINEAR )
+         )
+        m_descriptor_size = nWLs / 8;
+      else
+        m_descriptor_size = nDim / 8;
+
+      m_descriptor_type = CV_8UC1;
+      m_descriptor_norm = NORM_HAMMING;
+    }
+
+    // 2d array dim
+    int dim0 = nDim;
+    int dim1 = nWLs;
+
+    // override beta dim0 on LBGM
+    if ( m_desc_type == LBGM ) dim0 = 1;
+
+    m_Dims = nDim;
+    m_nWLs = nWLs;
+    m_orient_q = orientQuant;
+    m_patch_size = patchSize;
+    m_grad_atype = iGradAssignType;
+
+    // cast into opencv Mat type as float
+    m_wl_thresh = Mat( dim0, dim1, CV_32F, reinterpret_cast<float *>(const_cast<unsigned int *>(thresh)) );
+    m_wl_alpha  = Mat( dim0, dim1, CV_32F, reinterpret_cast<float *>(const_cast<unsigned int *>(alpha )) );
+
+    // cast into opencv Mat type as integer
+    m_wl_orient = Mat( dim0, dim1, CV_32S, const_cast<int *>(orient) );
+    m_wl_x_min  = Mat( dim0, dim1, CV_32S, const_cast<int *>(x_min ) );
+    m_wl_x_max  = Mat( dim0, dim1, CV_32S, const_cast<int *>(x_max ) );
+    m_wl_y_min  = Mat( dim0, dim1, CV_32S, const_cast<int *>(y_min ) );
+    m_wl_y_max  = Mat( dim0, dim1, CV_32S, const_cast<int *>(y_max ) );
+
+    // no beta
+    if ( beta == NULL ) return;
+
+    if ( m_desc_type == LBGM )
+      m_wl_beta = Mat( dim1, nDim, CV_32F, reinterpret_cast<float *>(const_cast<unsigned int *>(beta)) );
+    else
+      m_wl_beta = Mat( dim0, dim1, CV_32F, reinterpret_cast<float *>(const_cast<unsigned int *>(beta)) );
+}
+
+// constructor
+BoostDesc_Impl::BoostDesc_Impl( int _desc, bool _use_scale_orientation, float _scale_factor )
+               : m_desc_type( _desc ), m_scale_factor( _scale_factor ),
+                 m_use_scale_orientation( _use_scale_orientation )
+{
+    // desc type
+    switch ( m_desc_type )
+    {
+      case BGM:
+        {
+          #include "boostdesc_bgm.i"
+          ini_params( orientQuant, patchSize,
+                      iGradAssignType,
+                      nDim, nWLs, thresh, orient,
+                      x_min, x_max, y_min, y_max,
+                      alpha, NULL );
+        }
+        break;
+      case BGM_HARD:
+        {
+          #include "boostdesc_bgm_hd.i"
+          ini_params( orientQuant, patchSize,
+                      iGradAssignType,
+                      nDim, nWLs, thresh, orient,
+                      x_min, x_max, y_min, y_max,
+                      alpha, NULL );
+        }
+        break;
+      case BGM_BILINEAR:
+        {
+          #include "boostdesc_bgm_bi.i"
+          ini_params( orientQuant, patchSize,
+                      iGradAssignType,
+                      nDim, nWLs, thresh, orient,
+                      x_min, x_max, y_min, y_max,
+                      alpha, NULL );
+        }
+        break;
+      case LBGM:
+        {
+          #include "boostdesc_lbgm.i"
+          ini_params( orientQuant, patchSize,
+                      iGradAssignType,
+                      nDim, nWLs, thresh, orient,
+                      x_min, x_max, y_min, y_max,
+                      alpha, beta );
+        }
+        break;
+      case BINBOOST_64:
+        {
+          #include "boostdesc_binboost_064.i"
+          ini_params( orientQuant, patchSize,
+                      iGradAssignType,
+                      nDim, nWLs, thresh, orient,
+                      x_min, x_max, y_min, y_max,
+                      alpha, beta );
+        }
+        break;
+      case BINBOOST_128:
+        {
+          #include "boostdesc_binboost_128.i"
+          ini_params( orientQuant, patchSize,
+                      iGradAssignType,
+                      nDim, nWLs, thresh, orient,
+                      x_min, x_max, y_min, y_max,
+                      alpha, beta );
+        }
+        break;
+      case BINBOOST_256:
+        {
+          #include "boostdesc_binboost_256.i"
+          ini_params( orientQuant, patchSize,
+                      iGradAssignType,
+                      nDim, nWLs, thresh, orient,
+                      x_min, x_max, y_min, y_max,
+                      alpha, beta );
+        }
+        break;
+      default:
+        CV_Error( Error::StsInternal, "Unknown Descriptor Type." );
+    }
+}
+
+// destructor
+BoostDesc_Impl::~BoostDesc_Impl()
+{
+}
+
+void BoostDesc_Impl::read (const FileNode& fn)
+{
+    // if node is empty, keep previous value
+    if (!fn["desc_type"].empty())
+        fn["desc_type"] >> m_desc_type;
+    if (!fn["scale_factor"].empty())
+        fn["scale_factor"] >> m_scale_factor;
+    if (!fn["use_scale_orientation"].empty())
+        fn["use_scale_orientation"] >> m_use_scale_orientation;
+}
+
+void BoostDesc_Impl::write (FileStorage& fs) const
+{
+    if(fs.isOpened())
+    {
+        fs << "name" << getDefaultName();
+        fs << "desc_type" << m_desc_type;
+        fs << "scale_factor" << m_scale_factor;
+        fs << "use_scale_orientation" << m_use_scale_orientation;
+    }
+}
+
+#endif  // OPENCV_XFEATURES2D_HAS_BOOST_DATA
+
+Ptr<BoostDesc> BoostDesc::create( int desc, bool use_scale_orientation, float scale_factor )
+{
+#ifdef OPENCV_XFEATURES2D_HAS_BOOST_DATA
+    return makePtr<BoostDesc_Impl>( desc, use_scale_orientation, scale_factor );
+#else
+    CV_UNUSED(desc); CV_UNUSED(use_scale_orientation); CV_UNUSED(scale_factor);
+    CV_Error(Error::StsNotImplemented, "The OpenCV xfeatures2d binaries is built without downloaded Boost decriptor features: https://github.com/opencv/opencv_contrib/issues/1301");
+#endif
+}
+
+String BoostDesc::getDefaultName() const
+{
+  return (Feature2D::getDefaultName() + ".BOOST");
+}
+
+
+} // END NAMESPACE XFEATURES2D
+} // END NAMESPACE CV
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/brief.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/brief.cpp
new file mode 100644
index 00000000..43c92077
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/brief.cpp
@@ -0,0 +1,296 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include <algorithm>
+#include <vector>
+
+#include <iostream>
+#include <iomanip>
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+/*
+ * BRIEF Descriptor
+ */
+class BriefDescriptorExtractorImpl : public BriefDescriptorExtractor
+{
+public:
+    enum { PATCH_SIZE = 48, KERNEL_SIZE = 9 };
+
+    // bytes is a length of descriptor in bytes. It can be equal 16, 32 or 64 bytes.
+    BriefDescriptorExtractorImpl( int bytes = 32, bool use_orientation = false );
+
+    void read( const FileNode& ) CV_OVERRIDE;
+    void write( FileStorage& ) const CV_OVERRIDE;
+
+    int descriptorSize() const CV_OVERRIDE;
+    int descriptorType() const CV_OVERRIDE;
+    int defaultNorm() const CV_OVERRIDE;
+
+    void setDescriptorSize(int bytes) CV_OVERRIDE;
+    int getDescriptorSize() const CV_OVERRIDE { return bytes_;}
+
+    void setUseOrientation(bool use_orientation) CV_OVERRIDE { use_orientation_ = use_orientation; }
+    bool getUseOrientation() const CV_OVERRIDE { return use_orientation_; };
+
+    void compute(InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors) CV_OVERRIDE;
+
+protected:
+    typedef void(*PixelTestFn)(InputArray, const std::vector<KeyPoint>&, OutputArray, bool use_orientation );
+
+    int bytes_;
+    bool use_orientation_;
+    PixelTestFn test_fn_;
+};
+
+Ptr<BriefDescriptorExtractor> BriefDescriptorExtractor::create( int bytes, bool use_orientation )
+{
+    return makePtr<BriefDescriptorExtractorImpl>(bytes, use_orientation );
+}
+
+String BriefDescriptorExtractor::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".BRIEF");
+}
+
+inline int smoothedSum(const Mat& sum, const KeyPoint& pt, int y, int x, bool use_orientation, Matx21f R)
+{
+    static const int HALF_KERNEL = BriefDescriptorExtractorImpl::KERNEL_SIZE / 2;
+
+    if ( use_orientation )
+    {
+      int rx = (int)(((float)x)*R(1,0) - ((float)y)*R(0,0));
+      int ry = (int)(((float)x)*R(0,0) + ((float)y)*R(1,0));
+      if (rx > 24) rx = 24;
+      if (rx < -24) rx = -24;
+      if (ry > 24) ry = 24;
+      if (ry < -24) ry = -24;
+      x = rx; y = ry;
+    }
+    const int img_y = (int)(pt.pt.y + 0.5) + y;
+    const int img_x = (int)(pt.pt.x + 0.5) + x;
+    return   sum.at<int>(img_y + HALF_KERNEL + 1, img_x + HALF_KERNEL + 1)
+           - sum.at<int>(img_y + HALF_KERNEL + 1, img_x - HALF_KERNEL)
+           - sum.at<int>(img_y - HALF_KERNEL, img_x + HALF_KERNEL + 1)
+           + sum.at<int>(img_y - HALF_KERNEL, img_x - HALF_KERNEL);
+}
+
+static void pixelTests16(InputArray _sum, const std::vector<KeyPoint>& keypoints, OutputArray _descriptors, bool use_orientation )
+{
+    Matx21f R;
+    Mat sum = _sum.getMat(), descriptors = _descriptors.getMat();
+    for (size_t i = 0; i < keypoints.size(); ++i)
+    {
+        uchar* desc = descriptors.ptr(static_cast<int>(i));
+        const KeyPoint& pt = keypoints[i];
+        if ( use_orientation )
+        {
+          float angle = pt.angle;
+          angle *= (float)(CV_PI/180.f);
+          R(0,0) = sin(angle);
+          R(1,0) = cos(angle);
+        }
+
+#include "generated_16.i"
+    }
+}
+
+static void pixelTests32(InputArray _sum, const std::vector<KeyPoint>& keypoints, OutputArray _descriptors, bool use_orientation)
+{
+    Matx21f R;
+    Mat sum = _sum.getMat(), descriptors = _descriptors.getMat();
+    for (size_t i = 0; i < keypoints.size(); ++i)
+    {
+        uchar* desc = descriptors.ptr(static_cast<int>(i));
+        const KeyPoint& pt = keypoints[i];
+        if ( use_orientation )
+        {
+          float angle = pt.angle;
+          angle *= (float)(CV_PI / 180.f);
+          R(0,0) = sin(angle);
+          R(1,0) = cos(angle);
+        }
+
+#include "generated_32.i"
+    }
+}
+
+static void pixelTests64(InputArray _sum, const std::vector<KeyPoint>& keypoints, OutputArray _descriptors, bool use_orientation)
+{
+    Matx21f R;
+    Mat sum = _sum.getMat(), descriptors = _descriptors.getMat();
+    for (size_t i = 0; i < keypoints.size(); ++i)
+    {
+        uchar* desc = descriptors.ptr(static_cast<int>(i));
+        const KeyPoint& pt = keypoints[i];
+        if ( use_orientation )
+        {
+          float angle = pt.angle;
+          angle *= (float)(CV_PI/180.f);
+          R(0,0) = sin(angle);
+          R(1,0) = cos(angle);
+        }
+
+#include "generated_64.i"
+    }
+}
+
+BriefDescriptorExtractorImpl::BriefDescriptorExtractorImpl(int bytes, bool use_orientation) :
+    bytes_(bytes), use_orientation_(use_orientation), test_fn_(NULL)
+{
+    switch (bytes)
+    {
+        case 16:
+            test_fn_ = pixelTests16;
+            break;
+        case 32:
+            test_fn_ = pixelTests32;
+            break;
+        case 64:
+            test_fn_ = pixelTests64;
+            break;
+        default:
+            CV_Error(Error::StsBadArg, "bytes must be 16, 32, or 64");
+    }
+}
+
+void BriefDescriptorExtractorImpl::setDescriptorSize(int bytes)
+{
+    bytes_ = bytes;
+    switch (bytes)
+    {
+        case 16:
+            test_fn_ = pixelTests16;
+            break;
+        case 32:
+            test_fn_ = pixelTests32;
+            break;
+        case 64:
+            test_fn_ = pixelTests64;
+            break;
+        default:
+            CV_Error(Error::StsBadArg, "bytes must be 16, 32, or 64");
+    }
+}
+
+int BriefDescriptorExtractorImpl::descriptorSize() const
+{
+    return bytes_;
+}
+
+int BriefDescriptorExtractorImpl::descriptorType() const
+{
+    return CV_8UC1;
+}
+
+int BriefDescriptorExtractorImpl::defaultNorm() const
+{
+    return NORM_HAMMING;
+}
+
+void BriefDescriptorExtractorImpl::read( const FileNode& fn)
+{
+    // if node is empty, keep previous value
+    if (!fn["descriptorSize"].empty())
+    {
+        int dSize = fn["descriptorSize"];
+        switch (dSize)
+        {
+            case 16:
+                test_fn_ = pixelTests16;
+                break;
+            case 32:
+                test_fn_ = pixelTests32;
+                break;
+            case 64:
+                test_fn_ = pixelTests64;
+                break;
+            default:
+                CV_Error(Error::StsBadArg, "descriptorSize must be 16, 32, or 64");
+        }
+        bytes_ = dSize;
+    }
+    if (!fn["use_orientation"].empty())
+        fn["use_orientation"] >> use_orientation_;
+}
+
+void BriefDescriptorExtractorImpl::write( FileStorage& fs) const
+{
+    if ( fs.isOpened() )
+    {
+        fs << "name" << getDefaultName();
+        fs << "descriptorSize" << bytes_;
+        fs << "use_orientation" << use_orientation_;
+    }
+}
+
+void BriefDescriptorExtractorImpl::compute(InputArray image,
+                                           std::vector<KeyPoint>& keypoints,
+                                           OutputArray descriptors)
+{
+    // Construct integral image for fast smoothing (box filter)
+    Mat sum;
+
+    Mat grayImage = image.getMat();
+    if( image.type() != CV_8U ) cvtColor( image, grayImage, COLOR_BGR2GRAY );
+
+    ///TODO allow the user to pass in a precomputed integral image
+    //if(image.type() == CV_32S)
+    //  sum = image;
+    //else
+
+    integral( grayImage, sum, CV_32S);
+
+    //Remove keypoints very close to the border
+    KeyPointsFilter::runByImageBorder(keypoints, image.size(), PATCH_SIZE/2 + KERNEL_SIZE/2);
+
+    descriptors.create((int)keypoints.size(), bytes_, CV_8U);
+    descriptors.setTo(Scalar::all(0));
+    test_fn_(sum, keypoints, descriptors, use_orientation_);
+}
+
+}
+} // namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/cuda/surf.cu b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/cuda/surf.cu
new file mode 100644
index 00000000..6576ca73
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/cuda/surf.cu
@@ -0,0 +1,942 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "opencv2/opencv_modules.hpp"
+
+#ifdef HAVE_OPENCV_CUDAARITHM
+
+#include "opencv2/core/cuda/common.hpp"
+#include "opencv2/core/cuda/limits.hpp"
+#include "opencv2/core/cuda/saturate_cast.hpp"
+#include "opencv2/core/cuda/reduce.hpp"
+#include "opencv2/core/cuda/utility.hpp"
+#include "opencv2/core/cuda/functional.hpp"
+#include "opencv2/core/cuda/filters.hpp"
+#include <opencv2/cudev/ptr2d/texture.hpp>
+
+namespace cv { namespace cuda { namespace device
+{
+    namespace surf
+    {
+        void loadGlobalConstants(int maxCandidates, int maxFeatures, int img_rows, int img_cols, int nOctaveLayers, float hessianThreshold);
+        void loadOctaveConstants(int octave, int layer_rows, int layer_cols);
+
+        void icvCalcLayerDetAndTrace_gpu(const PtrStepSz<unsigned int>& sum, const PtrStepf& det, const PtrStepf& trace, int img_rows, int img_cols,
+            int octave, int nOctaveLayer);
+
+        void icvFindMaximaInLayer_gpu(const PtrStepSz<unsigned int>& maskSum, const PtrStepf& det, const PtrStepf& trace, int4* maxPosBuffer, unsigned int* maxCounter,
+            int img_rows, int img_cols, int octave, bool use_mask, int nLayers);
+
+        void icvInterpolateKeypoint_gpu(const PtrStepf& det, const int4* maxPosBuffer, unsigned int maxCounter,
+            float* featureX, float* featureY, int* featureLaplacian, int* featureOctave, float* featureSize, float* featureHessian,
+            unsigned int* featureCounter);
+
+        void icvCalcOrientation_gpu(const PtrStepSz<unsigned int>& sum, const float* featureX, const float* featureY, const float* featureSize, float* featureDir, int nFeatures);
+
+        void compute_descriptors_gpu(const PtrStepSzb& img, PtrStepSz<float4> descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir, int nFeatures);
+    }
+}}}
+
+namespace cv { namespace cuda { namespace device
+{
+    namespace surf
+    {
+        ////////////////////////////////////////////////////////////////////////
+        // Global parameters
+
+        // The maximum number of features (before subpixel interpolation) that memory is reserved for.
+        __constant__ int c_max_candidates;
+        // The maximum number of features that memory is reserved for.
+        __constant__ int c_max_features;
+        // The image size.
+        __constant__ int c_img_rows;
+        __constant__ int c_img_cols;
+        // The number of layers.
+        __constant__ int c_nOctaveLayers;
+        // The hessian threshold.
+        __constant__ float c_hessianThreshold;
+
+        // The current octave.
+        __constant__ int c_octave;
+        // The current layer size.
+        __constant__ int c_layer_rows;
+        __constant__ int c_layer_cols;
+
+        void loadGlobalConstants(int maxCandidates, int maxFeatures, int img_rows, int img_cols, int nOctaveLayers, float hessianThreshold)
+        {
+            cudaSafeCall( cudaMemcpyToSymbol(c_max_candidates, &maxCandidates, sizeof(maxCandidates)) );
+            cudaSafeCall( cudaMemcpyToSymbol(c_max_features, &maxFeatures, sizeof(maxFeatures)) );
+            cudaSafeCall( cudaMemcpyToSymbol(c_img_rows, &img_rows, sizeof(img_rows)) );
+            cudaSafeCall( cudaMemcpyToSymbol(c_img_cols, &img_cols, sizeof(img_cols)) );
+            cudaSafeCall( cudaMemcpyToSymbol(c_nOctaveLayers, &nOctaveLayers, sizeof(nOctaveLayers)) );
+            cudaSafeCall( cudaMemcpyToSymbol(c_hessianThreshold, &hessianThreshold, sizeof(hessianThreshold)) );
+        }
+
+        void loadOctaveConstants(int octave, int layer_rows, int layer_cols)
+        {
+            cudaSafeCall( cudaMemcpyToSymbol(c_octave, &octave, sizeof(octave)) );
+            cudaSafeCall( cudaMemcpyToSymbol(c_layer_rows, &layer_rows, sizeof(layer_rows)) );
+            cudaSafeCall( cudaMemcpyToSymbol(c_layer_cols, &layer_cols, sizeof(layer_cols)) );
+        }
+
+
+        template <int N> __device__ float icvCalcHaarPatternSum(cudev::TexturePtr<unsigned int> texSum, const float src[][5], int oldSize, int newSize, int y, int x)
+        {
+        #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 200
+            typedef double real_t;
+        #else
+            typedef float  real_t;
+        #endif
+
+            float ratio = (float)newSize / oldSize;
+
+            real_t d = 0;
+
+            #pragma unroll
+            for (int k = 0; k < N; ++k)
+            {
+                int dx1 = __float2int_rn(ratio * src[k][0]);
+                int dy1 = __float2int_rn(ratio * src[k][1]);
+                int dx2 = __float2int_rn(ratio * src[k][2]);
+                int dy2 = __float2int_rn(ratio * src[k][3]);
+
+                real_t t = 0;
+                t += texSum(y + dy1, x + dx1);
+                t -= texSum(y + dy2, x + dx1);
+                t -= texSum(y + dy1, x + dx2);
+                t += texSum(y + dy2, x + dx2);
+
+                d += t * src[k][4] / ((dx2 - dx1) * (dy2 - dy1));
+            }
+
+            return (float)d;
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Hessian
+
+        __constant__ float c_DX [3][5] = { {0, 2, 3, 7, 1}, {3, 2, 6, 7, -2}, {6, 2, 9, 7, 1} };
+        __constant__ float c_DY [3][5] = { {2, 0, 7, 3, 1}, {2, 3, 7, 6, -2}, {2, 6, 7, 9, 1} };
+        __constant__ float c_DXY[4][5] = { {1, 1, 4, 4, 1}, {5, 1, 8, 4, -1}, {1, 5, 4, 8, -1}, {5, 5, 8, 8, 1} };
+
+        __host__ __device__ __forceinline__ int calcSize(int octave, int layer)
+        {
+            /* Wavelet size at first layer of first octave. */
+            const int HAAR_SIZE0 = 9;
+
+            /* Wavelet size increment between layers. This should be an even number,
+             such that the wavelet sizes in an octave are either all even or all odd.
+             This ensures that when looking for the neighbours of a sample, the layers
+             above and below are aligned correctly. */
+            const int HAAR_SIZE_INC = 6;
+
+            return (HAAR_SIZE0 + HAAR_SIZE_INC * layer) << octave;
+        }
+
+        __global__ void icvCalcLayerDetAndTrace(cudev::TexturePtr<unsigned int> texSum, PtrStepf det, PtrStepf trace)
+        {
+            // Determine the indices
+            const int gridDim_y = gridDim.y / (c_nOctaveLayers + 2);
+            const int blockIdx_y = blockIdx.y % gridDim_y;
+            const int blockIdx_z = blockIdx.y / gridDim_y;
+
+            const int j = threadIdx.x + blockIdx.x * blockDim.x;
+            const int i = threadIdx.y + blockIdx_y * blockDim.y;
+            const int layer = blockIdx_z;
+
+            const int size = calcSize(c_octave, layer);
+
+            const int samples_i = 1 + ((c_img_rows - size) >> c_octave);
+            const int samples_j = 1 + ((c_img_cols - size) >> c_octave);
+
+            // Ignore pixels where some of the kernel is outside the image
+            const int margin = (size >> 1) >> c_octave;
+
+            if (size <= c_img_rows && size <= c_img_cols && i < samples_i && j < samples_j)
+            {
+                const float dx  = icvCalcHaarPatternSum<3>(texSum, c_DX , 9, size, (i << c_octave), (j << c_octave));
+                const float dy  = icvCalcHaarPatternSum<3>(texSum, c_DY , 9, size, (i << c_octave), (j << c_octave));
+                const float dxy = icvCalcHaarPatternSum<4>(texSum, c_DXY, 9, size, (i << c_octave), (j << c_octave));
+
+                det.ptr(layer * c_layer_rows + i + margin)[j + margin] = dx * dy - 0.81f * dxy * dxy;
+                trace.ptr(layer * c_layer_rows + i + margin)[j + margin] = dx + dy;
+            }
+        }
+
+        void icvCalcLayerDetAndTrace_gpu(const PtrStepSz<unsigned int>& sum, const PtrStepf& det, const PtrStepf& trace, int img_rows, int img_cols,
+            int octave, int nOctaveLayers)
+        {
+            const int min_size = calcSize(octave, 0);
+            const int max_samples_i = 1 + ((img_rows - min_size) >> octave);
+            const int max_samples_j = 1 + ((img_cols - min_size) >> octave);
+            cudev::Texture<unsigned int> texSum(sum);
+            dim3 threads(16, 16);
+
+            dim3 grid;
+            grid.x = divUp(max_samples_j, threads.x);
+            grid.y = divUp(max_samples_i, threads.y) * (nOctaveLayers + 2);
+
+            icvCalcLayerDetAndTrace<<<grid, threads>>>(texSum, det, trace);
+            cudaSafeCall( cudaGetLastError() );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // NONMAX
+
+        __constant__ float c_DM[5] = {0, 0, 9, 9, 1};
+
+        template<bool useMask = true>
+        struct Mask
+        {
+            __host__ Mask(){};
+            __host__ Mask(cudev::TexturePtr<unsigned int> tex_): tex(tex_) {};
+            __device__ bool check(int sum_i, int sum_j, int size)
+            {
+                if (!useMask) return true;
+                float ratio = (float)size / 9.0f;
+
+                float d = 0;
+
+                int dx1 = __float2int_rn(ratio * c_DM[0]);
+                int dy1 = __float2int_rn(ratio * c_DM[1]);
+                int dx2 = __float2int_rn(ratio * c_DM[2]);
+                int dy2 = __float2int_rn(ratio * c_DM[3]);
+
+                float t = 0;
+                t += tex(sum_i + dy1, sum_j + dx1);
+                t -= tex(sum_i + dy2, sum_j + dx1);
+                t -= tex(sum_i + dy1, sum_j + dx2);
+                t += tex(sum_i + dy2, sum_j + dx2);
+
+                d += t * c_DM[4] / ((dx2 - dx1) * (dy2 - dy1));
+
+                return (d >= 0.5f);
+            }
+            cudev::TexturePtr<unsigned int> tex;
+        };
+
+        template<class T>
+        __global__ void icvFindMaximaInLayer(T mask, const PtrStepf det, const PtrStepf trace, int4* maxPosBuffer,
+            unsigned int* maxCounter)
+        {
+            #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 110
+
+            extern __shared__ float N9[];
+
+            // The hidx variables are the indices to the hessian buffer.
+            const int gridDim_y = gridDim.y / c_nOctaveLayers;
+            const int blockIdx_y = blockIdx.y % gridDim_y;
+            const int blockIdx_z = blockIdx.y / gridDim_y;
+
+            const int layer = blockIdx_z + 1;
+
+            const int size = calcSize(c_octave, layer);
+
+            // Ignore pixels without a 3x3x3 neighbourhood in the layer above
+            const int margin = ((calcSize(c_octave, layer + 1) >> 1) >> c_octave) + 1;
+
+            const int j = threadIdx.x + blockIdx.x * (blockDim.x - 2) + margin - 1;
+            const int i = threadIdx.y + blockIdx_y * (blockDim.y - 2) + margin - 1;
+
+            // Is this thread within the hessian buffer?
+            const int zoff = blockDim.x * blockDim.y;
+            const int localLin = threadIdx.x + threadIdx.y * blockDim.x + zoff;
+            N9[localLin - zoff] = det.ptr(c_layer_rows * (layer - 1) + ::min(::max(i, 0), c_img_rows - 1))[::min(::max(j, 0), c_img_cols - 1)];
+            N9[localLin       ] = det.ptr(c_layer_rows * (layer    ) + ::min(::max(i, 0), c_img_rows - 1))[::min(::max(j, 0), c_img_cols - 1)];
+            N9[localLin + zoff] = det.ptr(c_layer_rows * (layer + 1) + ::min(::max(i, 0), c_img_rows - 1))[::min(::max(j, 0), c_img_cols - 1)];
+            __syncthreads();
+
+            if (i < c_layer_rows - margin && j < c_layer_cols - margin && threadIdx.x > 0 && threadIdx.x < blockDim.x - 1 && threadIdx.y > 0 && threadIdx.y < blockDim.y - 1)
+            {
+                float val0 = N9[localLin];
+
+                if (val0 > c_hessianThreshold)
+                {
+                    // Coordinates for the start of the wavelet in the sum image. There
+                    // is some integer division involved, so don't try to simplify this
+                    // (cancel out sampleStep) without checking the result is the same
+                    const int sum_i = (i - ((size >> 1) >> c_octave)) << c_octave;
+                    const int sum_j = (j - ((size >> 1) >> c_octave)) << c_octave;
+
+                    if (mask.check(sum_i, sum_j, size))
+                    {
+                        // Check to see if we have a max (in its 26 neighbours)
+                        const bool condmax = val0 > N9[localLin - 1 - blockDim.x - zoff]
+                        &&                   val0 > N9[localLin     - blockDim.x - zoff]
+                        &&                   val0 > N9[localLin + 1 - blockDim.x - zoff]
+                        &&                   val0 > N9[localLin - 1              - zoff]
+                        &&                   val0 > N9[localLin                  - zoff]
+                        &&                   val0 > N9[localLin + 1              - zoff]
+                        &&                   val0 > N9[localLin - 1 + blockDim.x - zoff]
+                        &&                   val0 > N9[localLin     + blockDim.x - zoff]
+                        &&                   val0 > N9[localLin + 1 + blockDim.x - zoff]
+
+                        &&                   val0 > N9[localLin - 1 - blockDim.x]
+                        &&                   val0 > N9[localLin     - blockDim.x]
+                        &&                   val0 > N9[localLin + 1 - blockDim.x]
+                        &&                   val0 > N9[localLin - 1             ]
+                        &&                   val0 > N9[localLin + 1             ]
+                        &&                   val0 > N9[localLin - 1 + blockDim.x]
+                        &&                   val0 > N9[localLin     + blockDim.x]
+                        &&                   val0 > N9[localLin + 1 + blockDim.x]
+
+                        &&                   val0 > N9[localLin - 1 - blockDim.x + zoff]
+                        &&                   val0 > N9[localLin     - blockDim.x + zoff]
+                        &&                   val0 > N9[localLin + 1 - blockDim.x + zoff]
+                        &&                   val0 > N9[localLin - 1              + zoff]
+                        &&                   val0 > N9[localLin                  + zoff]
+                        &&                   val0 > N9[localLin + 1              + zoff]
+                        &&                   val0 > N9[localLin - 1 + blockDim.x + zoff]
+                        &&                   val0 > N9[localLin     + blockDim.x + zoff]
+                        &&                   val0 > N9[localLin + 1 + blockDim.x + zoff]
+                        ;
+
+                        if(condmax)
+                        {
+                            unsigned int ind = atomicInc(maxCounter,(unsigned int) -1);
+
+                            if (ind < c_max_candidates)
+                            {
+                                const int laplacian = (int) copysignf(1.0f, trace.ptr(layer * c_layer_rows + i)[j]);
+
+                                maxPosBuffer[ind] = make_int4(j, i, layer, laplacian);
+                            }
+                        }
+                    }
+                }
+            }
+
+            #endif
+        }
+
+        void icvFindMaximaInLayer_gpu(const PtrStepSz<unsigned int>& maskSum, const PtrStepf& det, const PtrStepf& trace, int4* maxPosBuffer, unsigned int* maxCounter,
+            int img_rows, int img_cols, int octave, bool use_mask, int nOctaveLayers)
+        {
+            const int layer_rows = img_rows >> octave;
+            const int layer_cols = img_cols >> octave;
+
+            const int min_margin = ((calcSize(octave, 2) >> 1) >> octave) + 1;
+
+            dim3 threads(16, 16);
+
+            dim3 grid;
+            grid.x = divUp(layer_cols - 2 * min_margin, threads.x - 2);
+            grid.y = divUp(layer_rows - 2 * min_margin, threads.y - 2) * nOctaveLayers;
+
+            const size_t smem_size = threads.x * threads.y * 3 * sizeof(float);
+
+            if (use_mask) {
+                cudev::Texture<unsigned int> texMaskSum(maskSum);
+                Mask<true> mask(texMaskSum);
+                icvFindMaximaInLayer<<<grid, threads, smem_size>>>(mask, det, trace, maxPosBuffer, maxCounter);
+            }
+            else {
+                Mask<false> mask;
+                icvFindMaximaInLayer<<<grid, threads, smem_size>>>(mask, det, trace, maxPosBuffer, maxCounter);
+            }
+
+            cudaSafeCall( cudaGetLastError() );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // INTERPOLATION
+
+        __global__ void icvInterpolateKeypoint(const PtrStepf det, const int4* maxPosBuffer,
+            float* featureX, float* featureY, int* featureLaplacian, int* featureOctave, float* featureSize, float* featureHessian,
+            unsigned int* featureCounter)
+        {
+            #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 110
+
+            const int4 maxPos = maxPosBuffer[blockIdx.x];
+
+            const int j = maxPos.x - 1 + threadIdx.x;
+            const int i = maxPos.y - 1 + threadIdx.y;
+            const int layer = maxPos.z - 1 + threadIdx.z;
+
+            __shared__ float N9[3][3][3];
+
+            N9[threadIdx.z][threadIdx.y][threadIdx.x] = det.ptr(c_layer_rows * layer + i)[j];
+            __syncthreads();
+
+            if (threadIdx.x == 0 && threadIdx.y == 0 && threadIdx.z == 0)
+            {
+                __shared__ float dD[3];
+
+                //dx
+                dD[0] = -0.5f * (N9[1][1][2] - N9[1][1][0]);
+                //dy
+                dD[1] = -0.5f * (N9[1][2][1] - N9[1][0][1]);
+                //ds
+                dD[2] = -0.5f * (N9[2][1][1] - N9[0][1][1]);
+
+                __shared__ float H[3][3];
+
+                //dxx
+                H[0][0] = N9[1][1][0] - 2.0f * N9[1][1][1] + N9[1][1][2];
+                //dxy
+                H[0][1]= 0.25f * (N9[1][2][2] - N9[1][2][0] - N9[1][0][2] + N9[1][0][0]);
+                //dxs
+                H[0][2]= 0.25f * (N9[2][1][2] - N9[2][1][0] - N9[0][1][2] + N9[0][1][0]);
+                //dyx = dxy
+                H[1][0] = H[0][1];
+                //dyy
+                H[1][1] = N9[1][0][1] - 2.0f * N9[1][1][1] + N9[1][2][1];
+                //dys
+                H[1][2]= 0.25f * (N9[2][2][1] - N9[2][0][1] - N9[0][2][1] + N9[0][0][1]);
+                //dsx = dxs
+                H[2][0] = H[0][2];
+                //dsy = dys
+                H[2][1] = H[1][2];
+                //dss
+                H[2][2] = N9[0][1][1] - 2.0f * N9[1][1][1] + N9[2][1][1];
+
+                __shared__ float x[3];
+
+                if (solve3x3(H, dD, x))
+                {
+                    if (::fabs(x[0]) <= 1.f && ::fabs(x[1]) <= 1.f && ::fabs(x[2]) <= 1.f)
+                    {
+                        // if the step is within the interpolation region, perform it
+
+                        const int size = calcSize(c_octave, maxPos.z);
+
+                        const int sum_i = (maxPos.y - ((size >> 1) >> c_octave)) << c_octave;
+                        const int sum_j = (maxPos.x - ((size >> 1) >> c_octave)) << c_octave;
+
+                        const float center_i = sum_i + (float)(size - 1) / 2;
+                        const float center_j = sum_j + (float)(size - 1) / 2;
+
+                        const float px = center_j + x[0] * (1 << c_octave);
+                        const float py = center_i + x[1] * (1 << c_octave);
+
+                        const int ds = size - calcSize(c_octave, maxPos.z - 1);
+                        const float psize = roundf(size + x[2] * ds);
+
+                        /* The sampling intervals and wavelet sized for selecting an orientation
+                         and building the keypoint descriptor are defined relative to 's' */
+                        const float s = psize * 1.2f / 9.0f;
+
+                        /* To find the dominant orientation, the gradients in x and y are
+                         sampled in a circle of radius 6s using wavelets of size 4s.
+                         We ensure the gradient wavelet size is even to ensure the
+                         wavelet pattern is balanced and symmetric around its center */
+                        const int grad_wav_size = 2 * __float2int_rn(2.0f * s);
+
+                        // check when grad_wav_size is too big
+                        if ((c_img_rows + 1) >= grad_wav_size && (c_img_cols + 1) >= grad_wav_size)
+                        {
+                            // Get a new feature index.
+                            unsigned int ind = atomicInc(featureCounter, (unsigned int)-1);
+
+                            if (ind < c_max_features)
+                            {
+                                featureX[ind] = px;
+                                featureY[ind] = py;
+                                featureLaplacian[ind] = maxPos.w;
+                                featureOctave[ind] = c_octave;
+                                featureSize[ind] = psize;
+                                featureHessian[ind] = N9[1][1][1];
+                            }
+                        } // grad_wav_size check
+                    } // If the subpixel interpolation worked
+                }
+            } // If this is thread 0.
+
+            #endif
+        }
+
+        void icvInterpolateKeypoint_gpu(const PtrStepf& det, const int4* maxPosBuffer, unsigned int maxCounter,
+            float* featureX, float* featureY, int* featureLaplacian, int* featureOctave, float* featureSize, float* featureHessian,
+            unsigned int* featureCounter)
+        {
+            dim3 threads;
+            threads.x = 3;
+            threads.y = 3;
+            threads.z = 3;
+
+            dim3 grid;
+            grid.x = maxCounter;
+
+            icvInterpolateKeypoint<<<grid, threads>>>(det, maxPosBuffer, featureX, featureY, featureLaplacian, featureOctave, featureSize, featureHessian, featureCounter);
+            cudaSafeCall( cudaGetLastError() );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Orientation
+
+        #define ORI_SEARCH_INC 5
+        #define ORI_WIN        60
+        #define ORI_SAMPLES    113
+
+        __constant__ float c_aptX[ORI_SAMPLES] = {-6, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 6};
+        __constant__ float c_aptY[ORI_SAMPLES] = {0, -3, -2, -1, 0, 1, 2, 3, -4, -3, -2, -1, 0, 1, 2, 3, 4, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3, 0};
+        __constant__ float c_aptW[ORI_SAMPLES] = {0.001455130288377404f, 0.001707611023448408f, 0.002547456417232752f, 0.003238451667129993f, 0.0035081731621176f, 0.003238451667129993f, 0.002547456417232752f, 0.001707611023448408f, 0.002003900473937392f, 0.0035081731621176f, 0.005233579315245152f, 0.00665318313986063f, 0.00720730796456337f, 0.00665318313986063f, 0.005233579315245152f, 0.0035081731621176f, 0.002003900473937392f, 0.001707611023448408f, 0.0035081731621176f, 0.006141661666333675f, 0.009162282571196556f, 0.01164754293859005f, 0.01261763460934162f, 0.01164754293859005f, 0.009162282571196556f, 0.006141661666333675f, 0.0035081731621176f, 0.001707611023448408f, 0.002547456417232752f, 0.005233579315245152f, 0.009162282571196556f, 0.01366852037608624f, 0.01737609319388866f, 0.0188232995569706f, 0.01737609319388866f, 0.01366852037608624f, 0.009162282571196556f, 0.005233579315245152f, 0.002547456417232752f, 0.003238451667129993f, 0.00665318313986063f, 0.01164754293859005f, 0.01737609319388866f, 0.02208934165537357f, 0.02392910048365593f, 0.02208934165537357f, 0.01737609319388866f, 0.01164754293859005f, 0.00665318313986063f, 0.003238451667129993f, 0.001455130288377404f, 0.0035081731621176f, 0.00720730796456337f, 0.01261763460934162f, 0.0188232995569706f, 0.02392910048365593f, 0.02592208795249462f, 0.02392910048365593f, 0.0188232995569706f, 0.01261763460934162f, 0.00720730796456337f, 0.0035081731621176f, 0.001455130288377404f, 0.003238451667129993f, 0.00665318313986063f, 0.01164754293859005f, 0.01737609319388866f, 0.02208934165537357f, 0.02392910048365593f, 0.02208934165537357f, 0.01737609319388866f, 0.01164754293859005f, 0.00665318313986063f, 0.003238451667129993f, 0.002547456417232752f, 0.005233579315245152f, 0.009162282571196556f, 0.01366852037608624f, 0.01737609319388866f, 0.0188232995569706f, 0.01737609319388866f, 0.01366852037608624f, 0.009162282571196556f, 0.005233579315245152f, 0.002547456417232752f, 0.001707611023448408f, 0.0035081731621176f, 0.006141661666333675f, 0.009162282571196556f, 0.01164754293859005f, 0.01261763460934162f, 0.01164754293859005f, 0.009162282571196556f, 0.006141661666333675f, 0.0035081731621176f, 0.001707611023448408f, 0.002003900473937392f, 0.0035081731621176f, 0.005233579315245152f, 0.00665318313986063f, 0.00720730796456337f, 0.00665318313986063f, 0.005233579315245152f, 0.0035081731621176f, 0.002003900473937392f, 0.001707611023448408f, 0.002547456417232752f, 0.003238451667129993f, 0.0035081731621176f, 0.003238451667129993f, 0.002547456417232752f, 0.001707611023448408f, 0.001455130288377404f};
+
+        __constant__ float c_NX[2][5] = {{0, 0, 2, 4, -1}, {2, 0, 4, 4, 1}};
+        __constant__ float c_NY[2][5] = {{0, 0, 4, 2, 1}, {0, 2, 4, 4, -1}};
+
+        __global__ void icvCalcOrientation(cudev::TexturePtr<unsigned int> texSum, const float* featureX, const float* featureY, const float* featureSize, float* featureDir)
+        {
+            __shared__ float s_X[128];
+            __shared__ float s_Y[128];
+            __shared__ float s_angle[128];
+
+            __shared__ float s_sumx[32 * 4];
+            __shared__ float s_sumy[32 * 4];
+
+            /* The sampling intervals and wavelet sized for selecting an orientation
+             and building the keypoint descriptor are defined relative to 's' */
+            const float s = featureSize[blockIdx.x] * 1.2f / 9.0f;
+
+            /* To find the dominant orientation, the gradients in x and y are
+             sampled in a circle of radius 6s using wavelets of size 4s.
+             We ensure the gradient wavelet size is even to ensure the
+             wavelet pattern is balanced and symmetric around its center */
+            const int grad_wav_size = 2 * __float2int_rn(2.0f * s);
+
+            // check when grad_wav_size is too big
+            if ((c_img_rows + 1) < grad_wav_size || (c_img_cols + 1) < grad_wav_size)
+                return;
+
+            // Calc X, Y, angle and store it to shared memory
+            const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+
+            float X = 0.0f, Y = 0.0f, angle = 0.0f;
+
+            if (tid < ORI_SAMPLES)
+            {
+                const float margin = (float)(grad_wav_size - 1) / 2.0f;
+                const int x = __float2int_rn(featureX[blockIdx.x] + c_aptX[tid] * s - margin);
+                const int y = __float2int_rn(featureY[blockIdx.x] + c_aptY[tid] * s - margin);
+
+                if (y >= 0 && y < (c_img_rows + 1) - grad_wav_size &&
+                    x >= 0 && x < (c_img_cols + 1) - grad_wav_size)
+                {
+                    X = c_aptW[tid] * icvCalcHaarPatternSum<2>(texSum, c_NX, 4, grad_wav_size, y, x);
+                    Y = c_aptW[tid] * icvCalcHaarPatternSum<2>(texSum, c_NY, 4, grad_wav_size, y, x);
+
+                    angle = atan2f(Y, X);
+                    if (angle < 0)
+                        angle += 2.0f * CV_PI_F;
+                    angle *= 180.0f / CV_PI_F;
+                }
+            }
+            s_X[tid] = X;
+            s_Y[tid] = Y;
+            s_angle[tid] = angle;
+            __syncthreads();
+
+            float bestx = 0, besty = 0, best_mod = 0;
+
+        #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 200
+            #pragma unroll
+        #endif
+            for (int i = 0; i < 18; ++i)
+            {
+                const int dir = (i * 4 + threadIdx.y) * ORI_SEARCH_INC;
+
+                float sumx = 0.0f, sumy = 0.0f;
+                int d = ::abs(__float2int_rn(s_angle[threadIdx.x]) - dir);
+                if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
+                {
+                    sumx = s_X[threadIdx.x];
+                    sumy = s_Y[threadIdx.x];
+                }
+                d = ::abs(__float2int_rn(s_angle[threadIdx.x + 32]) - dir);
+                if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
+                {
+                    sumx += s_X[threadIdx.x + 32];
+                    sumy += s_Y[threadIdx.x + 32];
+                }
+                d = ::abs(__float2int_rn(s_angle[threadIdx.x + 64]) - dir);
+                if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
+                {
+                    sumx += s_X[threadIdx.x + 64];
+                    sumy += s_Y[threadIdx.x + 64];
+                }
+                d = ::abs(__float2int_rn(s_angle[threadIdx.x + 96]) - dir);
+                if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
+                {
+                    sumx += s_X[threadIdx.x + 96];
+                    sumy += s_Y[threadIdx.x + 96];
+                }
+
+                plus<float> op;
+                device::reduce<32>(smem_tuple(s_sumx + threadIdx.y * 32, s_sumy + threadIdx.y * 32),
+                                   thrust::tie(sumx, sumy), threadIdx.x, thrust::make_tuple(op, op));
+
+                const float temp_mod = sumx * sumx + sumy * sumy;
+                if (temp_mod > best_mod)
+                {
+                    best_mod = temp_mod;
+                    bestx = sumx;
+                    besty = sumy;
+                }
+
+                __syncthreads();
+            }
+
+            if (threadIdx.x == 0)
+            {
+                s_X[threadIdx.y] = bestx;
+                s_Y[threadIdx.y] = besty;
+                s_angle[threadIdx.y] = best_mod;
+            }
+            __syncthreads();
+
+            if (threadIdx.x == 0 && threadIdx.y == 0)
+            {
+                int bestIdx = 0;
+
+                if (s_angle[1] > s_angle[bestIdx])
+                    bestIdx = 1;
+                if (s_angle[2] > s_angle[bestIdx])
+                    bestIdx = 2;
+                if (s_angle[3] > s_angle[bestIdx])
+                    bestIdx = 3;
+
+                float kp_dir = atan2f(s_Y[bestIdx], s_X[bestIdx]);
+                if (kp_dir < 0)
+                    kp_dir += 2.0f * CV_PI_F;
+                kp_dir *= 180.0f / CV_PI_F;
+
+                kp_dir = 360.0f - kp_dir;
+                if (::fabsf(kp_dir - 360.f) < numeric_limits<float>::epsilon())
+                    kp_dir = 0.f;
+
+                featureDir[blockIdx.x] = kp_dir;
+            }
+        }
+
+        #undef ORI_SEARCH_INC
+        #undef ORI_WIN
+        #undef ORI_SAMPLES
+
+        void icvCalcOrientation_gpu(const PtrStepSz<unsigned int>& sum, const float* featureX, const float* featureY, const float* featureSize, float* featureDir, int nFeatures)
+        {
+            cudev::Texture<unsigned int> texSum(sum);
+            dim3 threads;
+            threads.x = 32;
+            threads.y = 4;
+
+            dim3 grid;
+            grid.x = nFeatures;
+
+            icvCalcOrientation<<<grid, threads>>>(texSum, featureX, featureY, featureSize, featureDir);
+            cudaSafeCall( cudaGetLastError() );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Descriptors
+
+        #define PATCH_SZ 20
+
+        __constant__ float c_DW[PATCH_SZ * PATCH_SZ] =
+        {
+            3.695352233989979e-006f, 8.444558261544444e-006f, 1.760426494001877e-005f, 3.34794785885606e-005f, 5.808438800158911e-005f, 9.193058212986216e-005f, 0.0001327334757661447f, 0.0001748319627949968f, 0.0002100782439811155f, 0.0002302826324012131f, 0.0002302826324012131f, 0.0002100782439811155f, 0.0001748319627949968f, 0.0001327334757661447f, 9.193058212986216e-005f, 5.808438800158911e-005f, 3.34794785885606e-005f, 1.760426494001877e-005f, 8.444558261544444e-006f, 3.695352233989979e-006f,
+            8.444558261544444e-006f, 1.929736572492402e-005f, 4.022897701361217e-005f, 7.650675252079964e-005f, 0.0001327334903180599f, 0.0002100782585330308f, 0.0003033203829545528f, 0.0003995231236331165f, 0.0004800673632416874f, 0.0005262381164357066f, 0.0005262381164357066f, 0.0004800673632416874f, 0.0003995231236331165f, 0.0003033203829545528f, 0.0002100782585330308f, 0.0001327334903180599f, 7.650675252079964e-005f, 4.022897701361217e-005f, 1.929736572492402e-005f, 8.444558261544444e-006f,
+            1.760426494001877e-005f, 4.022897701361217e-005f, 8.386484114453197e-005f, 0.0001594926579855382f, 0.0002767078403849155f, 0.0004379475140012801f, 0.0006323281559161842f, 0.0008328808471560478f, 0.001000790391117334f, 0.001097041997127235f, 0.001097041997127235f, 0.001000790391117334f, 0.0008328808471560478f, 0.0006323281559161842f, 0.0004379475140012801f, 0.0002767078403849155f, 0.0001594926579855382f, 8.386484114453197e-005f, 4.022897701361217e-005f, 1.760426494001877e-005f,
+            3.34794785885606e-005f, 7.650675252079964e-005f, 0.0001594926579855382f, 0.0003033203247468919f, 0.0005262380582280457f, 0.0008328807889483869f, 0.001202550483867526f, 0.001583957928232849f, 0.001903285388834775f, 0.002086334861814976f, 0.002086334861814976f, 0.001903285388834775f, 0.001583957928232849f, 0.001202550483867526f, 0.0008328807889483869f, 0.0005262380582280457f, 0.0003033203247468919f, 0.0001594926579855382f, 7.650675252079964e-005f, 3.34794785885606e-005f,
+            5.808438800158911e-005f, 0.0001327334903180599f, 0.0002767078403849155f, 0.0005262380582280457f, 0.0009129836107604206f, 0.001444985857233405f, 0.002086335094645619f, 0.002748048631474376f, 0.00330205773934722f, 0.003619635012000799f, 0.003619635012000799f, 0.00330205773934722f, 0.002748048631474376f, 0.002086335094645619f, 0.001444985857233405f, 0.0009129836107604206f, 0.0005262380582280457f, 0.0002767078403849155f, 0.0001327334903180599f, 5.808438800158911e-005f,
+            9.193058212986216e-005f, 0.0002100782585330308f, 0.0004379475140012801f, 0.0008328807889483869f, 0.001444985857233405f, 0.002286989474669099f, 0.00330205773934722f, 0.004349356517195702f, 0.00522619066759944f, 0.005728822201490402f, 0.005728822201490402f, 0.00522619066759944f, 0.004349356517195702f, 0.00330205773934722f, 0.002286989474669099f, 0.001444985857233405f, 0.0008328807889483869f, 0.0004379475140012801f, 0.0002100782585330308f, 9.193058212986216e-005f,
+            0.0001327334757661447f, 0.0003033203829545528f, 0.0006323281559161842f, 0.001202550483867526f, 0.002086335094645619f, 0.00330205773934722f, 0.004767658654600382f, 0.006279794964939356f, 0.007545807864516974f, 0.008271530270576477f, 0.008271530270576477f, 0.007545807864516974f, 0.006279794964939356f, 0.004767658654600382f, 0.00330205773934722f, 0.002086335094645619f, 0.001202550483867526f, 0.0006323281559161842f, 0.0003033203829545528f, 0.0001327334757661447f,
+            0.0001748319627949968f, 0.0003995231236331165f, 0.0008328808471560478f, 0.001583957928232849f, 0.002748048631474376f, 0.004349356517195702f, 0.006279794964939356f, 0.008271529339253902f, 0.009939077310264111f, 0.01089497376233339f, 0.01089497376233339f, 0.009939077310264111f, 0.008271529339253902f, 0.006279794964939356f, 0.004349356517195702f, 0.002748048631474376f, 0.001583957928232849f, 0.0008328808471560478f, 0.0003995231236331165f, 0.0001748319627949968f,
+            0.0002100782439811155f, 0.0004800673632416874f, 0.001000790391117334f, 0.001903285388834775f, 0.00330205773934722f, 0.00522619066759944f, 0.007545807864516974f, 0.009939077310264111f, 0.01194280479103327f, 0.01309141051024199f, 0.01309141051024199f, 0.01194280479103327f, 0.009939077310264111f, 0.007545807864516974f, 0.00522619066759944f, 0.00330205773934722f, 0.001903285388834775f, 0.001000790391117334f, 0.0004800673632416874f, 0.0002100782439811155f,
+            0.0002302826324012131f, 0.0005262381164357066f, 0.001097041997127235f, 0.002086334861814976f, 0.003619635012000799f, 0.005728822201490402f, 0.008271530270576477f, 0.01089497376233339f, 0.01309141051024199f, 0.01435048412531614f, 0.01435048412531614f, 0.01309141051024199f, 0.01089497376233339f, 0.008271530270576477f, 0.005728822201490402f, 0.003619635012000799f, 0.002086334861814976f, 0.001097041997127235f, 0.0005262381164357066f, 0.0002302826324012131f,
+            0.0002302826324012131f, 0.0005262381164357066f, 0.001097041997127235f, 0.002086334861814976f, 0.003619635012000799f, 0.005728822201490402f, 0.008271530270576477f, 0.01089497376233339f, 0.01309141051024199f, 0.01435048412531614f, 0.01435048412531614f, 0.01309141051024199f, 0.01089497376233339f, 0.008271530270576477f, 0.005728822201490402f, 0.003619635012000799f, 0.002086334861814976f, 0.001097041997127235f, 0.0005262381164357066f, 0.0002302826324012131f,
+            0.0002100782439811155f, 0.0004800673632416874f, 0.001000790391117334f, 0.001903285388834775f, 0.00330205773934722f, 0.00522619066759944f, 0.007545807864516974f, 0.009939077310264111f, 0.01194280479103327f, 0.01309141051024199f, 0.01309141051024199f, 0.01194280479103327f, 0.009939077310264111f, 0.007545807864516974f, 0.00522619066759944f, 0.00330205773934722f, 0.001903285388834775f, 0.001000790391117334f, 0.0004800673632416874f, 0.0002100782439811155f,
+            0.0001748319627949968f, 0.0003995231236331165f, 0.0008328808471560478f, 0.001583957928232849f, 0.002748048631474376f, 0.004349356517195702f, 0.006279794964939356f, 0.008271529339253902f, 0.009939077310264111f, 0.01089497376233339f, 0.01089497376233339f, 0.009939077310264111f, 0.008271529339253902f, 0.006279794964939356f, 0.004349356517195702f, 0.002748048631474376f, 0.001583957928232849f, 0.0008328808471560478f, 0.0003995231236331165f, 0.0001748319627949968f,
+            0.0001327334757661447f, 0.0003033203829545528f, 0.0006323281559161842f, 0.001202550483867526f, 0.002086335094645619f, 0.00330205773934722f, 0.004767658654600382f, 0.006279794964939356f, 0.007545807864516974f, 0.008271530270576477f, 0.008271530270576477f, 0.007545807864516974f, 0.006279794964939356f, 0.004767658654600382f, 0.00330205773934722f, 0.002086335094645619f, 0.001202550483867526f, 0.0006323281559161842f, 0.0003033203829545528f, 0.0001327334757661447f,
+            9.193058212986216e-005f, 0.0002100782585330308f, 0.0004379475140012801f, 0.0008328807889483869f, 0.001444985857233405f, 0.002286989474669099f, 0.00330205773934722f, 0.004349356517195702f, 0.00522619066759944f, 0.005728822201490402f, 0.005728822201490402f, 0.00522619066759944f, 0.004349356517195702f, 0.00330205773934722f, 0.002286989474669099f, 0.001444985857233405f, 0.0008328807889483869f, 0.0004379475140012801f, 0.0002100782585330308f, 9.193058212986216e-005f,
+            5.808438800158911e-005f, 0.0001327334903180599f, 0.0002767078403849155f, 0.0005262380582280457f, 0.0009129836107604206f, 0.001444985857233405f, 0.002086335094645619f, 0.002748048631474376f, 0.00330205773934722f, 0.003619635012000799f, 0.003619635012000799f, 0.00330205773934722f, 0.002748048631474376f, 0.002086335094645619f, 0.001444985857233405f, 0.0009129836107604206f, 0.0005262380582280457f, 0.0002767078403849155f, 0.0001327334903180599f, 5.808438800158911e-005f,
+            3.34794785885606e-005f, 7.650675252079964e-005f, 0.0001594926579855382f, 0.0003033203247468919f, 0.0005262380582280457f, 0.0008328807889483869f, 0.001202550483867526f, 0.001583957928232849f, 0.001903285388834775f, 0.002086334861814976f, 0.002086334861814976f, 0.001903285388834775f, 0.001583957928232849f, 0.001202550483867526f, 0.0008328807889483869f, 0.0005262380582280457f, 0.0003033203247468919f, 0.0001594926579855382f, 7.650675252079964e-005f, 3.34794785885606e-005f,
+            1.760426494001877e-005f, 4.022897701361217e-005f, 8.386484114453197e-005f, 0.0001594926579855382f, 0.0002767078403849155f, 0.0004379475140012801f, 0.0006323281559161842f, 0.0008328808471560478f, 0.001000790391117334f, 0.001097041997127235f, 0.001097041997127235f, 0.001000790391117334f, 0.0008328808471560478f, 0.0006323281559161842f, 0.0004379475140012801f, 0.0002767078403849155f, 0.0001594926579855382f, 8.386484114453197e-005f, 4.022897701361217e-005f, 1.760426494001877e-005f,
+            8.444558261544444e-006f, 1.929736572492402e-005f, 4.022897701361217e-005f, 7.650675252079964e-005f, 0.0001327334903180599f, 0.0002100782585330308f, 0.0003033203829545528f, 0.0003995231236331165f, 0.0004800673632416874f, 0.0005262381164357066f, 0.0005262381164357066f, 0.0004800673632416874f, 0.0003995231236331165f, 0.0003033203829545528f, 0.0002100782585330308f, 0.0001327334903180599f, 7.650675252079964e-005f, 4.022897701361217e-005f, 1.929736572492402e-005f, 8.444558261544444e-006f,
+            3.695352233989979e-006f, 8.444558261544444e-006f, 1.760426494001877e-005f, 3.34794785885606e-005f, 5.808438800158911e-005f, 9.193058212986216e-005f, 0.0001327334757661447f, 0.0001748319627949968f, 0.0002100782439811155f, 0.0002302826324012131f, 0.0002302826324012131f, 0.0002100782439811155f, 0.0001748319627949968f, 0.0001327334757661447f, 9.193058212986216e-005f, 5.808438800158911e-005f, 3.34794785885606e-005f, 1.760426494001877e-005f, 8.444558261544444e-006f, 3.695352233989979e-006f
+        };
+
+        struct WinReader
+        {
+            typedef uchar elem_type;
+
+            __device__ WinReader(cudev::TexturePtr<uchar> tex_) : tex(tex_) {};
+
+            __device__ __forceinline__ uchar operator ()(int i, int j) const
+            {
+                float pixel_x = centerX + (win_offset + j) * cos_dir + (win_offset + i) * sin_dir;
+                float pixel_y = centerY - (win_offset + j) * sin_dir + (win_offset + i) * cos_dir;
+
+                return tex(pixel_y, pixel_x);
+            }
+
+            float centerX;
+            float centerY;
+            float win_offset;
+            float cos_dir;
+            float sin_dir;
+            int width;
+            int height;
+            cudev::TexturePtr<uchar> tex;
+        };
+
+        __device__ void calc_dx_dy(cudev::TexturePtr<uchar> tex, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir,
+                                   float& dx, float& dy)
+        {
+            __shared__ float s_PATCH[PATCH_SZ + 1][PATCH_SZ + 1];
+
+            dx = dy = 0.0f;
+
+            WinReader win(tex);
+
+            win.centerX = featureX[blockIdx.x];
+            win.centerY = featureY[blockIdx.x];
+
+            // The sampling intervals and wavelet sized for selecting an orientation
+            // and building the keypoint descriptor are defined relative to 's'
+            const float s = featureSize[blockIdx.x] * 1.2f / 9.0f;
+
+            // Extract a window of pixels around the keypoint of size 20s
+            const int win_size = (int)((PATCH_SZ + 1) * s);
+
+            win.width = win.height = win_size;
+
+            // Nearest neighbour version (faster)
+            win.win_offset = -(win_size - 1.0f) / 2.0f;
+
+            float descriptor_dir = 360.0f - featureDir[blockIdx.x];
+            if (::fabsf(descriptor_dir - 360.f) < numeric_limits<float>::epsilon())
+                descriptor_dir = 0.f;
+            descriptor_dir *= CV_PI_F / 180.0f;
+            sincosf(descriptor_dir, &win.sin_dir, &win.cos_dir);
+
+            const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+
+            const int xLoadInd = tid % (PATCH_SZ + 1);
+            const int yLoadInd = tid / (PATCH_SZ + 1);
+
+            if (yLoadInd < (PATCH_SZ + 1))
+            {
+                if (s > 1)
+                {
+                    AreaFilter<WinReader> filter(win, s, s);
+                    s_PATCH[yLoadInd][xLoadInd] = filter(yLoadInd, xLoadInd);
+                }
+                else
+                {
+                    LinearFilter<WinReader> filter(win);
+                    s_PATCH[yLoadInd][xLoadInd] = filter(yLoadInd * s, xLoadInd * s);
+                }
+            }
+
+            __syncthreads();
+
+            const int xPatchInd = threadIdx.x % 5;
+            const int yPatchInd = threadIdx.x / 5;
+
+            if (yPatchInd < 5)
+            {
+                const int xBlockInd = threadIdx.y % 4;
+                const int yBlockInd = threadIdx.y / 4;
+
+                const int xInd = xBlockInd * 5 + xPatchInd;
+                const int yInd = yBlockInd * 5 + yPatchInd;
+
+                const float dw = c_DW[yInd * PATCH_SZ + xInd];
+
+                dx = (s_PATCH[yInd    ][xInd + 1] - s_PATCH[yInd][xInd] + s_PATCH[yInd + 1][xInd + 1] - s_PATCH[yInd + 1][xInd    ]) * dw;
+                dy = (s_PATCH[yInd + 1][xInd    ] - s_PATCH[yInd][xInd] + s_PATCH[yInd + 1][xInd + 1] - s_PATCH[yInd    ][xInd + 1]) * dw;
+            }
+        }
+
+        __global__ void compute_descriptors_64(cudev::TexturePtr<uchar> texImg, PtrStep<float4> descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir)
+        {
+            __shared__ float smem[32 * 16];
+
+            float* sRow = smem + threadIdx.y * 32;
+
+            float dx, dy;
+            calc_dx_dy(texImg, featureX, featureY, featureSize, featureDir, dx, dy);
+
+            float dxabs = ::fabsf(dx);
+            float dyabs = ::fabsf(dy);
+
+            plus<float> op;
+
+            reduce<32>(sRow, dx, threadIdx.x, op);
+            reduce<32>(sRow, dy, threadIdx.x, op);
+            reduce<32>(sRow, dxabs, threadIdx.x, op);
+            reduce<32>(sRow, dyabs, threadIdx.x, op);
+
+            float4* descriptors_block = descriptors.ptr(blockIdx.x) + threadIdx.y;
+
+            // write dx, dy, |dx|, |dy|
+            if (threadIdx.x == 0)
+                *descriptors_block = make_float4(dx, dy, dxabs, dyabs);
+        }
+
+        __global__ void compute_descriptors_128(cudev::TexturePtr<uchar> texImg, PtrStep<float4> descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir)
+        {
+            __shared__ float smem[32 * 16];
+
+            float* sRow = smem + threadIdx.y * 32;
+
+            float dx, dy;
+            calc_dx_dy(texImg, featureX, featureY, featureSize, featureDir, dx, dy);
+
+            float4* descriptors_block = descriptors.ptr(blockIdx.x) + threadIdx.y * 2;
+
+            plus<float> op;
+
+            float d1 = 0.0f;
+            float d2 = 0.0f;
+            float abs1 = 0.0f;
+            float abs2 = 0.0f;
+
+            if (dy >= 0)
+            {
+                d1 = dx;
+                abs1 = ::fabsf(dx);
+            }
+            else
+            {
+                d2 = dx;
+                abs2 = ::fabsf(dx);
+            }
+
+            reduce<32>(sRow, d1, threadIdx.x, op);
+            reduce<32>(sRow, d2, threadIdx.x, op);
+            reduce<32>(sRow, abs1, threadIdx.x, op);
+            reduce<32>(sRow, abs2, threadIdx.x, op);
+
+            // write dx (dy >= 0), |dx| (dy >= 0), dx (dy < 0), |dx| (dy < 0)
+            if (threadIdx.x == 0)
+                descriptors_block[0] = make_float4(d1, abs1, d2, abs2);
+
+            if (dx >= 0)
+            {
+                d1 = dy;
+                abs1 = ::fabsf(dy);
+                d2 = 0.0f;
+                abs2 = 0.0f;
+            }
+            else
+            {
+                d1 = 0.0f;
+                abs1 = 0.0f;
+                d2 = dy;
+                abs2 = ::fabsf(dy);
+            }
+
+            reduce<32>(sRow, d1, threadIdx.x, op);
+            reduce<32>(sRow, d2, threadIdx.x, op);
+            reduce<32>(sRow, abs1, threadIdx.x, op);
+            reduce<32>(sRow, abs2, threadIdx.x, op);
+
+            // write dy (dx >= 0), |dy| (dx >= 0), dy (dx < 0), |dy| (dx < 0)
+            if (threadIdx.x == 0)
+                descriptors_block[1] = make_float4(d1, abs1, d2, abs2);
+        }
+
+        template <int BLOCK_DIM_X> __global__ void normalize_descriptors(PtrStepf descriptors)
+        {
+            __shared__ float smem[BLOCK_DIM_X];
+            __shared__ float s_len;
+
+            // no need for thread ID
+            float* descriptor_base = descriptors.ptr(blockIdx.x);
+
+            // read in the unnormalized descriptor values (squared)
+            const float val = descriptor_base[threadIdx.x];
+
+            float len = val * val;
+            reduce<BLOCK_DIM_X>(smem, len, threadIdx.x, plus<float>());
+
+            if (threadIdx.x == 0)
+                s_len = ::sqrtf(len);
+
+            __syncthreads();
+
+            // normalize and store in output
+            descriptor_base[threadIdx.x] = val / s_len;
+        }
+
+        void compute_descriptors_gpu(const PtrStepSzb& img, PtrStepSz<float4> descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir, int nFeatures)
+        {
+            // compute unnormalized descriptors, then normalize them - odd indexing since grid must be 2D
+            cudev::Texture<unsigned char> texImg(img);
+            if (descriptors.cols == 64)
+            {
+                compute_descriptors_64<<<nFeatures, dim3(32, 16)>>>(texImg, descriptors, featureX, featureY, featureSize, featureDir);
+                cudaSafeCall( cudaGetLastError() );
+
+                cudaSafeCall( cudaDeviceSynchronize() );
+
+                normalize_descriptors<64><<<nFeatures, 64>>>((PtrStepSzf) descriptors);
+                cudaSafeCall( cudaGetLastError() );
+
+                cudaSafeCall( cudaDeviceSynchronize() );
+            }
+            else
+            {
+                compute_descriptors_128<<<nFeatures, dim3(32, 16)>>>(texImg, descriptors, featureX, featureY, featureSize, featureDir);
+                cudaSafeCall( cudaGetLastError() );
+
+                cudaSafeCall( cudaDeviceSynchronize() );
+
+                normalize_descriptors<128><<<nFeatures, 128>>>((PtrStepSzf) descriptors);
+                cudaSafeCall( cudaGetLastError() );
+
+                cudaSafeCall( cudaDeviceSynchronize() );
+            }
+        }
+    } // namespace surf
+}}} // namespace cv { namespace cuda { namespace cudev
+
+#endif // HAVE_OPENCV_CUDAARITHM
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/daisy.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/daisy.cpp
new file mode 100644
index 00000000..ff4dccd4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/daisy.cpp
@@ -0,0 +1,1694 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2009
+ * Engin Tola
+ * web : http://www.engintola.com
+ * email : engin.tola+libdaisy@gmail.com
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the Willow Garage nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+/*
+ "DAISY: An Efficient Dense Descriptor Applied to Wide Baseline Stereo"
+ by Engin Tola, Vincent Lepetit and Pascal Fua. IEEE Transactions on
+ Pattern Analysis and achine Intelligence, 31 Mar. 2009.
+ IEEE computer Society Digital Library. IEEE Computer Society,
+ http:doi.ieeecomputersociety.org/10.1109/TPAMI.2009.77
+
+ "A fast local descriptor for dense matching" by Engin Tola, Vincent
+ Lepetit, and Pascal Fua. Intl. Conf. on Computer Vision and Pattern
+ Recognition, Alaska, USA, June 2008
+
+ OpenCV port by: Cristian Balint <cristian dot balint at gmail dot com>
+ */
+
+#include "precomp.hpp"
+
+#include <fstream>
+#include <stdlib.h>
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+// constants
+const double g_sigma_0 = 1;
+const double g_sigma_1 = sqrt(2.0);
+const double g_sigma_step = std::pow(2,1.0/2);
+const int g_scale_st = int( (log(g_sigma_1/g_sigma_0)) / log(g_sigma_step) );
+static int g_scale_en = 1;
+
+const double g_sigma_init = 1.6;
+const static int g_grid_orientation_resolution = 360;
+
+static const int MAX_CUBE_NO = 64;
+static const int MAX_NORMALIZATION_ITER = 5;
+
+int g_selected_cubes[MAX_CUBE_NO]; // m_rad_q_no < MAX_CUBE_NO
+
+void DAISY::compute( InputArrayOfArrays images,
+                     std::vector<std::vector<KeyPoint> >& keypoints,
+                     OutputArrayOfArrays descriptors )
+{
+    DescriptorExtractor::compute(images, keypoints, descriptors);
+}
+
+/*
+ !DAISY implementation
+ */
+class DAISY_Impl CV_FINAL : public DAISY
+{
+
+public:
+    /** Constructor
+     * @param radius radius of the descriptor at the initial scale
+     * @param q_radius amount of radial range divisions
+     * @param q_theta amount of angular range divisions
+     * @param q_hist amount of gradient orientations range divisions
+     * @param norm normalization type
+     * @param H optional 3x3 homography matrix used to warp the grid of daisy but sampling keypoints remains unwarped on image
+     * @param interpolation switch to disable interpolation at minor costs of quality (default is true)
+     * @param use_orientation sample patterns using keypoints orientation, disabled by default.
+     */
+    explicit DAISY_Impl(float radius=15, int q_radius=3, int q_theta=8, int q_hist=8,
+                        DAISY::NormalizationType norm = DAISY::NRM_NONE, InputArray H = noArray(),
+                        bool interpolation = true, bool use_orientation = false);
+
+    virtual ~DAISY_Impl() CV_OVERRIDE;
+
+    void read( const FileNode& fn) CV_OVERRIDE;
+    void write( FileStorage& fs) const CV_OVERRIDE;
+
+    void setRadius(float radius) CV_OVERRIDE { m_rad = radius; }
+    float getRadius() const CV_OVERRIDE { return m_rad; }
+
+    void setQRadius(int q_radius) CV_OVERRIDE { m_rad_q_no = q_radius; }
+    int getQRadius() const CV_OVERRIDE { return m_rad_q_no; }
+
+    void setQTheta(int q_theta) CV_OVERRIDE { m_th_q_no = q_theta; }
+    int getQTheta() const CV_OVERRIDE { return m_th_q_no; }
+
+    void setQHist(int q_hist) CV_OVERRIDE { m_hist_th_q_no = q_hist; }
+    int getQHist() const CV_OVERRIDE { return m_hist_th_q_no; }
+
+    void setNorm(int norm) CV_OVERRIDE {
+      switch(norm)
+      {
+        case NRM_NONE:
+        case NRM_PARTIAL:
+        case NRM_FULL:
+        case NRM_SIFT:
+          break;
+        default:
+          CV_Error(cv::Error::StsBadArg, "norm should be one of {NRM_NONE, NRM_PARTIAL, NRM_FULL, NRM_SIFT}");
+          return;
+      }
+      m_nrm_type = (DAISY::NormalizationType)norm;
+    }
+    int getNorm() const CV_OVERRIDE { return (int)m_nrm_type; }
+
+    void setH(InputArray H) CV_OVERRIDE { m_h_matrix = H.getMat(); }
+    cv::Mat getH() const CV_OVERRIDE { return m_h_matrix; }
+
+    void setInterpolation(bool interpolation) CV_OVERRIDE { m_enable_interpolation = interpolation; }
+    bool getInterpolation() const CV_OVERRIDE { return m_enable_interpolation; }
+
+    void setUseOrientation(bool use_orientation) CV_OVERRIDE { m_use_orientation = use_orientation; }
+    bool getUseOrientation() const CV_OVERRIDE { return m_use_orientation; }
+
+    /** returns the descriptor length in bytes */
+    virtual int descriptorSize() const CV_OVERRIDE {
+        // +1 is for center pixel
+        return ( (m_rad_q_no * m_th_q_no + 1) * m_hist_th_q_no );
+    };
+
+    /** returns the descriptor type */
+    virtual int descriptorType() const CV_OVERRIDE { return CV_32F; }
+
+    /** returns the default norm type */
+    virtual int defaultNorm() const CV_OVERRIDE { return NORM_L2; }
+
+    /**
+     * @param image image to extract descriptors
+     * @param keypoints of interest within image
+     * @param descriptors resulted descriptors array
+     */
+    virtual void compute( InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors ) CV_OVERRIDE;
+
+    /** @overload
+     * @param image image to extract descriptors
+     * @param roi region of interest within image
+     * @param descriptors resulted descriptors array
+     */
+    virtual void compute( InputArray image, Rect roi, OutputArray descriptors ) CV_OVERRIDE;
+
+    /** @overload
+     * @param image image to extract descriptors
+     * @param descriptors resulted descriptors array
+     */
+    virtual void compute( InputArray image, OutputArray descriptors ) CV_OVERRIDE;
+
+    /**
+     * @param y position y on image
+     * @param x position x on image
+     * @param orientation orientation on image (0->360)
+     * @param descriptor supplied array for descriptor storage
+     */
+    virtual void GetDescriptor( double y, double x, int orientation, float* descriptor ) const CV_OVERRIDE;
+
+    /**
+     * @param y position y on image
+     * @param x position x on image
+     * @param orientation orientation on image (0->360)
+     * @param descriptor supplied array for descriptor storage
+     * @param H homography matrix for warped grid
+     */
+    virtual bool GetDescriptor( double y, double x, int orientation, float* descriptor, double* H ) const CV_OVERRIDE;
+
+    /**
+     * @param y position y on image
+     * @param x position x on image
+     * @param orientation orientation on image (0->360)
+     * @param descriptor supplied array for descriptor storage
+     */
+    virtual void GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor ) const CV_OVERRIDE;
+
+    /**
+     * @param y position y on image
+     * @param x position x on image
+     * @param orientation orientation on image (0->360)
+     * @param descriptor supplied array for descriptor storage
+     * @param H homography matrix for warped grid
+     */
+    virtual bool GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor, double* H ) const CV_OVERRIDE;
+
+protected:
+
+    /*
+     * DAISY parameters
+     */
+
+    // maximum radius of the descriptor region.
+    float m_rad;
+
+    // the number of quantizations of the radius.
+    int m_rad_q_no;
+
+    // the number of quantizations of the angle.
+    int m_th_q_no;
+
+    // the number of quantizations of the gradient orientations.
+    int m_hist_th_q_no;
+
+    // holds the type of the normalization to apply; equals to NRM_PARTIAL by
+    // default. change the value using set_normalization() function.
+    DAISY::NormalizationType m_nrm_type;
+
+    // the size of the descriptor vector
+    int m_descriptor_size;
+
+    // the number of grid locations
+    int m_grid_point_number;
+
+    // number of bins in the histograms while computing orientation
+    int m_orientation_resolution;
+
+
+    /*
+     * DAISY switches
+     */
+
+    // if set to true, descriptors are scale invariant
+    bool m_scale_invariant;
+
+    // if set to true, descriptors are rotation invariant
+    bool m_rotation_invariant;
+
+    // if enabled, descriptors are computed with casting non-integer locations
+    // to integer positions otherwise we use interpolation.
+    bool m_enable_interpolation;
+
+    // switch to enable sample by keypoints orientation
+    bool m_use_orientation;
+
+    /*
+     * DAISY arrays
+     */
+
+    // holds optional H matrix
+    Mat m_h_matrix;
+
+    // internal float image.
+    Mat m_image;
+
+    // image roi
+    Rect m_roi;
+
+    // stores the layered gradients in successively smoothed form :
+    // layer[n] = m_gradient_layers * gaussian( sigma_n );
+    // n>= 1; layer[0] is the layered_gradient
+    std::vector<Mat> m_smoothed_gradient_layers;
+
+    // hold the scales of the pixels
+    Mat m_scale_map;
+
+    // holds the orientaitons of the pixels
+    Mat m_orientation_map;
+
+    // Holds the oriented coordinates (y,x) of the grid points of the region.
+    Mat m_oriented_grid_points;
+
+    // holds the gaussian sigmas for radius quantizations for an incremental
+    // application
+    Mat m_cube_sigmas;
+
+    // Holds the coordinates (y,x) of the grid points of the region.
+    Mat m_grid_points;
+
+    // holds the amount of shift that's required for histogram computation
+    double m_orientation_shift_table[360];
+
+
+private:
+
+    /*
+     * DAISY functions
+     */
+
+    // initializes the class: computes gradient and structure-points
+    inline void initialize();
+
+    // initializes for get_descriptor(double, double, int) mode: pre-computes
+    // convolutions of gradient layers in m_smoothed_gradient_layers
+    inline void initialize_single_descriptor_mode();
+
+    // set & precompute parameters
+    inline void set_parameters();
+
+    // image set image as working
+    inline void set_image( InputArray image );
+
+    // releases all the used memory; call this if you want to process
+    // multiple images within a loop.
+    inline void reset();
+
+    // releases unused memory after descriptor computation is completed.
+    inline void release_auxiliary();
+
+    // computes the descriptors for every pixel in the image.
+    inline void compute_descriptors( Mat* m_dense_descriptors );
+
+    // computes scales for every pixel and scales the structure grid so that the
+    // resulting descriptors are scale invariant.  you must set
+    // m_scale_invariant flag to 1 for the program to call this function
+    inline void compute_scales();
+
+    // compute the smoothed gradient layers.
+    inline void compute_smoothed_gradient_layers();
+
+    // computes pixel orientations and rotates the structure grid so that
+    // resulting descriptors are rotation invariant. If the scales is also
+    // detected, then orientations are computed at the computed scales. you must
+    // set m_rotation_invariant flag to 1 for the program to call this function
+    inline void compute_orientations();
+
+    // computes the histogram at yx; the size of histogram is m_hist_th_q_no
+    inline void compute_histogram( float* hcube, int y, int x, float* histogram );
+
+    // reorganizes the cube data so that histograms are sequential in memory.
+    inline void compute_histograms();
+
+    // computes the sigma's of layers from descriptor parameters if the user did
+    // not sets it. these define the size of the petals of the descriptor.
+    inline void compute_cube_sigmas();
+
+    // Computes the locations of the unscaled unrotated points where the
+    // histograms are going to be computed according to the given parameters.
+    inline void compute_grid_points();
+
+    // Computes the locations of the unscaled rotated points where the
+    // histograms are going to be computed according to the given parameters.
+    inline void compute_oriented_grid_points();
+
+    // applies one of the normalizations (partial,full,sift) to the desciptors.
+    inline void normalize_descriptors( Mat* m_dense_descriptors );
+
+    inline void update_selected_cubes();
+
+}; // END DAISY_Impl CLASS
+
+
+// -------------------------------------------------
+/* DAISY computation routines */
+
+inline void DAISY_Impl::reset()
+{
+    m_image.release();
+
+    m_scale_map.release();
+    m_orientation_map.release();
+
+    for (size_t i=0; i<m_smoothed_gradient_layers.size(); i++)
+      m_smoothed_gradient_layers[i].release();
+    m_smoothed_gradient_layers.clear();
+}
+
+inline void DAISY_Impl::release_auxiliary()
+{
+    reset();
+
+    m_cube_sigmas.release();
+    m_grid_points.release();
+    m_oriented_grid_points.release();
+}
+
+static int filter_size( double sigma, double factor )
+{
+    int fsz = (int)( factor * sigma );
+    // kernel size must be odd
+    if( fsz%2 == 0 ) fsz++;
+    // kernel size cannot be smaller than 3
+    if( fsz < 3 ) fsz = 3;
+
+    return fsz;
+}
+
+// transform a point via the homography
+static void pt_H( double* H, double x, double y, double &u, double &v )
+{
+    double kxp = H[0]*x + H[1]*y + H[2];
+    double kyp = H[3]*x + H[4]*y + H[5];
+    double kp  = H[6]*x + H[7]*y + H[8];
+    u = kxp / kp; v = kyp / kp;
+}
+
+
+static float interpolate_peak( float left, float center, float right )
+{
+    if( center < 0.0 )
+    {
+      left = -left;
+      center = -center;
+      right = -right;
+    }
+    CV_Assert(center >= left  &&  center >= right);
+
+    float den = (float) (left - 2.0 * center + right);
+
+    if( den == 0 ) return 0;
+    else           return (float) (0.5*(left -right)/den);
+}
+
+static void smooth_histogram( Mat* hist, int hsz )
+{
+    int i;
+    float prev, temp;
+
+    prev = hist->at<float>(hsz - 1);
+    for (i = 0; i < hsz; i++)
+    {
+      temp = hist->at<float>(i);
+      hist->at<float>(i) = (prev + hist->at<float>(i) + hist->at<float>( (i + 1 == hsz) ? 0 : i + 1) ) / 3.0f;
+      prev = temp;
+    }
+}
+
+struct LayeredGradientInvoker : ParallelLoopBody
+{
+    LayeredGradientInvoker( Mat* _layers, Mat& _dy, Mat& _dx )
+    {
+      dy = _dy;
+      dx = _dx;
+      layers = _layers;
+      layer_no = layers->size[0];
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      for (int l = range.start; l < range.end; ++l)
+      {
+        double angle = l * 2 * (float)CV_PI / layer_no;
+        Mat layer( dx.rows, dx.cols, CV_32F, layers->ptr<float>(l,0,0) );
+        addWeighted( dx, cos( angle ), dy, sin( angle ), 0.0f, layer, CV_32F );
+        max( layer, 0.0f, layer );
+      }
+    }
+
+    Mat dy, dx;
+    Mat *layers;
+    int layer_no;
+};
+
+static void layered_gradient( Mat& data, Mat* layers )
+{
+    Mat cvO, dx, dy;
+    int layer_no = layers->size[0];
+
+    GaussianBlur( data, cvO, Size(5, 5), 0.5f, 0.5f, BORDER_REPLICATE );
+    Sobel( cvO, dx, CV_32F, 1, 0, 1, 0.5f, 0.0f, BORDER_REPLICATE );
+    Sobel( cvO, dy, CV_32F, 0, 1, 1, 0.5f, 0.0f, BORDER_REPLICATE );
+
+    parallel_for_( Range(0, layer_no), LayeredGradientInvoker( layers, dy, dx ) );
+}
+
+struct SmoothLayersInvoker : ParallelLoopBody
+{
+    SmoothLayersInvoker( Mat* _layers, const float _sigma )
+    {
+      layers = _layers;
+      sigma = _sigma;
+
+      h = layers->size[1];
+      w = layers->size[2];
+      ks = filter_size( sigma, 5.0f );
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      for (int l = range.start; l < range.end; ++l)
+      {
+        Mat layer( h, w, CV_32FC1, layers->ptr<float>(l,0,0) );
+        GaussianBlur( layer, layer, Size(ks, ks), sigma, sigma, BORDER_REPLICATE );
+      }
+    }
+
+    float sigma;
+    int ks, h, w;
+    Mat *layers;
+};
+
+static void smooth_layers( Mat* layers, float sigma )
+{
+    int layer_no = layers->size[0];
+    parallel_for_( Range(0, layer_no), SmoothLayersInvoker( layers, sigma ) );
+}
+
+static int quantize_radius( float rad, const int _rad_q_no, const Mat& _cube_sigmas )
+{
+    if( rad <= _cube_sigmas.at<double>(0) )
+        return 0;
+    if( rad >= _cube_sigmas.at<double>(_rad_q_no-1) )
+        return _rad_q_no-1;
+
+    int idx_min[2];
+    minMaxIdx( abs( _cube_sigmas - rad ), NULL, NULL, idx_min );
+
+    return idx_min[1];
+}
+
+static void normalize_partial( float* desc, const int _grid_point_number, const int _hist_th_q_no )
+{
+    for( int h=0; h<_grid_point_number; h++ )
+    {
+      // l2 norm
+      double sum = 0.0f;
+      for( int i=0; i<_hist_th_q_no; i++ )
+      {
+          sum += desc[h*_hist_th_q_no + i]
+               * desc[h*_hist_th_q_no + i];
+      }
+
+      float norm = (float)sqrt( sum );
+
+      if( norm != 0.0 )
+      // divide with norm
+      for( int i=0; i<_hist_th_q_no; i++ )
+      {
+          desc[h*_hist_th_q_no + i] /= norm;
+      }
+    }
+}
+
+static void normalize_sift_way( float* desc, const int _descriptor_size )
+{
+    int h;
+    int iter = 0;
+    bool changed = true;
+    while( changed && iter < MAX_NORMALIZATION_ITER )
+    {
+      iter++;
+      changed = false;
+
+      double sum = 0.0f;
+      for( int i=0; i<_descriptor_size; i++ )
+      {
+          sum += desc[i] * desc[i];
+      }
+
+      float norm = (float)sqrt( sum );
+
+      if( norm > 1e-5 )
+      // divide with norm
+      for( int i=0; i<_descriptor_size; i++ )
+      {
+          desc[i] /= norm;
+      }
+
+      for( h=0; h<_descriptor_size; h++ )
+      {  // sift magical number
+         if( desc[ h ] > 0.154f )
+         {
+            desc[ h ] = 0.154f;
+            changed = true;
+         }
+      }
+    }
+}
+
+static void normalize_full( float* desc, const int _descriptor_size )
+{
+    // l2 norm
+    double sum = 0.0f;
+    for( int i=0; i<_descriptor_size; i++ )
+    {
+        sum += desc[i] * desc[i];
+    }
+
+    float norm = (float)sqrt( sum );
+
+    if( norm != 0.0 )
+    // divide with norm
+    for( int i=0; i<_descriptor_size; i++ )
+    {
+        desc[i] /= norm;
+    }
+}
+
+static void normalize_descriptor( float* desc, const DAISY::NormalizationType nrm_type, const int _grid_point_number,
+                                  const int _hist_th_q_no, const int _descriptor_size  )
+{
+    if( nrm_type == DAISY::NRM_NONE ) return;
+    else if( nrm_type == DAISY::NRM_PARTIAL ) normalize_partial(desc,_grid_point_number,_hist_th_q_no);
+    else if( nrm_type == DAISY::NRM_FULL    ) normalize_full(desc,_descriptor_size);
+    else if( nrm_type == DAISY::NRM_SIFT    ) normalize_sift_way(desc,_descriptor_size);
+    else
+        CV_Error( Error::StsInternal, "No such normalization" );
+}
+
+static void ni_get_histogram( float* histogram, const int y, const int x, const int shift, const Mat* hcube )
+{
+
+    if ( ! Point( x, y ).inside(
+           Rect( 0, 0, hcube->size[1]-1, hcube->size[0]-1 ) )
+       ) return;
+
+    int _hist_th_q_no = hcube->size[2];
+    const float* hptr = hcube->ptr<float>(y,x,0);
+    for( int h=0; h<_hist_th_q_no; h++ )
+    {
+      int hi = h+shift;
+      if( hi >= _hist_th_q_no ) hi -= _hist_th_q_no;
+      histogram[h] = hptr[hi];
+    }
+}
+
+static void bi_get_histogram( float* histogram, const double y, const double x, const int shift, const Mat* hcube )
+{
+    int mnx = int( x );
+    int mny = int( y );
+    int _hist_th_q_no = hcube->size[2];
+    if( mnx >= hcube->size[1]-2  || mny >= hcube->size[0]-2 )
+    {
+      memset(histogram, 0, sizeof(float)*_hist_th_q_no);
+      return;
+    }
+
+    // A C --> pixel positions
+    // B D
+    const float* A = hcube->ptr<float>( mny   ,  mnx   , 0);
+    const float* B = hcube->ptr<float>((mny+1),  mnx   , 0);
+    const float* C = hcube->ptr<float>( mny   , (mnx+1), 0);
+    const float* D = hcube->ptr<float>((mny+1), (mnx+1), 0);
+
+    double alpha = mnx+1-x;
+    double beta  = mny+1-y;
+
+    float w0 = (float) ( alpha * beta );
+    float w1 = (float) ( beta - w0    );         // (1-alpha)*beta;
+    float w2 = (float) ( alpha - w0   );         // (1-beta)*alpha;
+    float w3 = (float) ( 1 + w0 - alpha - beta); // (1-beta)*(1-alpha);
+
+    int h;
+
+    for( h=0; h<_hist_th_q_no; h++ ) {
+      if( h+shift < _hist_th_q_no ) histogram[h] = w0 * A[h+shift];
+      else                          histogram[h] = w0 * A[h+shift-_hist_th_q_no];
+    }
+    for( h=0; h<_hist_th_q_no; h++ ) {
+      if( h+shift < _hist_th_q_no ) histogram[h] += w1 * C[h+shift];
+      else                          histogram[h] += w1 * C[h+shift-_hist_th_q_no];
+    }
+    for( h=0; h<_hist_th_q_no; h++ ) {
+      if( h+shift < _hist_th_q_no ) histogram[h] += w2 * B[h+shift];
+      else                          histogram[h] += w2 * B[h+shift-_hist_th_q_no];
+    }
+    for( h=0; h<_hist_th_q_no; h++ ) {
+      if( h+shift < _hist_th_q_no ) histogram[h] += w3 * D[h+shift];
+      else                          histogram[h] += w3 * D[h+shift-_hist_th_q_no];
+    }
+}
+
+static void ti_get_histogram( float* histogram, const double y, const double x, const double shift, const Mat* hcube )
+{
+    int ishift = int( shift );
+    double layer_alpha  = shift - ishift;
+
+    float thist[MAX_CUBE_NO];
+    bi_get_histogram( thist, y, x, ishift, hcube );
+
+    int _hist_th_q_no = hcube->size[2];
+    for( int h=0; h<_hist_th_q_no-1; h++ )
+      histogram[h] = (float) ((1-layer_alpha)*thist[h]+layer_alpha*thist[h+1]);
+    histogram[_hist_th_q_no-1] = (float) ((1-layer_alpha)*thist[_hist_th_q_no-1]+layer_alpha*thist[0]);
+}
+
+static void i_get_histogram( float* histogram, const double y, const double x, const double shift, const Mat* hcube )
+{
+    int ishift = (int)shift;
+    double fshift = shift-ishift;
+    if     ( fshift < 0.01 ) bi_get_histogram( histogram, y, x, ishift  , hcube );
+    else if( fshift > 0.99 ) bi_get_histogram( histogram, y, x, ishift+1, hcube );
+    else                     ti_get_histogram( histogram, y, x,  shift  , hcube );
+}
+
+static void ni_get_descriptor( const double y, const double x, const int orientation, float* descriptor, const std::vector<Mat>* layers,
+                               const Mat* _oriented_grid_points, const double* _orientation_shift_table, const int _th_q_no )
+{
+    CV_Assert( y >= 0 && y < layers->at(0).size[0] );
+    CV_Assert( x >= 0 && x < layers->at(0).size[1] );
+    CV_Assert( orientation >= 0 && orientation < 360 );
+    CV_Assert( !layers->empty() );
+    CV_Assert( !_oriented_grid_points->empty() );
+    CV_Assert( descriptor != NULL );
+
+    int _rad_q_no = (int) layers->size();
+    int _hist_th_q_no = layers->at(0).size[2];
+    double shift = _orientation_shift_table[orientation];
+    int ishift = (int)shift;
+    if( shift - ishift > 0.5  ) ishift++;
+
+    int iy = (int)y; if( y - iy > 0.5 ) iy++;
+    int ix = (int)x; if( x - ix > 0.5 ) ix++;
+
+    // center
+    ni_get_histogram( descriptor, iy, ix, ishift, &layers->at(g_selected_cubes[0]) );
+
+    double yy, xx;
+    float* histogram=0;
+    // petals of the flower
+    int r, rdt, region;
+    Mat grid = _oriented_grid_points->row( orientation );
+    for( r=0; r<_rad_q_no; r++ )
+    {
+      rdt = r*_th_q_no+1;
+      for( region=rdt; region<rdt+_th_q_no; region++ )
+      {
+         yy = y + grid.at<double>(2*region  );
+         xx = x + grid.at<double>(2*region+1);
+         iy = (int)yy; if( yy - iy > 0.5 ) iy++;
+         ix = (int)xx; if( xx - ix > 0.5 ) ix++;
+
+         if ( ! Point2f( (float)xx, (float)yy ).inside(
+                Rect( 0, 0, layers->at(0).size[1]-1, layers->at(0).size[0]-1 ) )
+            ) continue;
+
+         histogram = descriptor + region*_hist_th_q_no;
+         ni_get_histogram( histogram, iy, ix, ishift, &layers->at(g_selected_cubes[r]) );
+      }
+    }
+}
+
+static void i_get_descriptor( const double y, const double x, const int orientation, float* descriptor, const std::vector<Mat>* layers,
+                              const Mat* _oriented_grid_points, const double *_orientation_shift_table, const int _th_q_no )
+{
+    CV_Assert( y >= 0 && y < layers->at(0).size[0] );
+    CV_Assert( x >= 0 && x < layers->at(0).size[1] );
+    CV_Assert( orientation >= 0 && orientation < 360 );
+    CV_Assert( !layers->empty() );
+    CV_Assert( !_oriented_grid_points->empty() );
+    CV_Assert( descriptor != NULL );
+
+    int _rad_q_no = (int) layers->size();
+    int _hist_th_q_no = layers->at(0).size[2];
+    double shift = _orientation_shift_table[orientation];
+
+    i_get_histogram( descriptor, y, x, shift, &layers->at(g_selected_cubes[0]) );
+
+    int r, rdt, region;
+    double yy, xx;
+    float* histogram = 0;
+
+    Mat grid = _oriented_grid_points->row( orientation );
+
+    // petals of the flower
+    for( r=0; r<_rad_q_no; r++ )
+    {
+      rdt  = r*_th_q_no+1;
+      for( region=rdt; region<rdt+_th_q_no; region++ )
+      {
+         yy = y + grid.at<double>(2*region    );
+         xx = x + grid.at<double>(2*region + 1);
+
+         if ( ! Point2f( (float)xx, (float)yy ).inside(
+                Rect( 0, 0, layers->at(0).size[1]-1, layers->at(0).size[0]-1 ) )
+            ) continue;
+
+         histogram = descriptor + region*_hist_th_q_no;
+         i_get_histogram( histogram, yy, xx, shift, &layers->at(r) );
+      }
+    }
+}
+
+static bool ni_get_descriptor_h( const double y, const double x, const int orientation, double* H, float* descriptor, const std::vector<Mat>* layers,
+                                 const Mat& _cube_sigmas, const Mat* _grid_points, const double* _orientation_shift_table, const int _th_q_no )
+{
+    CV_Assert( orientation >= 0 && orientation < 360 );
+    CV_Assert( !layers->empty() );
+    CV_Assert( descriptor != NULL );
+
+    int hradius[MAX_CUBE_NO];
+
+    double hy, hx, ry, rx;
+
+    pt_H(H, x, y, hx, hy );
+
+    if ( ! Point2f( (float)hx, (float)hy ).inside(
+                Rect( 0, 0, layers->at(0).size[1]-1, layers->at(0).size[0]-1 ) )
+       ) return false;
+
+    int _rad_q_no = (int) layers->size();
+    int _hist_th_q_no = layers->at(0).size[2];
+    double shift = _orientation_shift_table[orientation];
+    int  ishift = (int)shift; if( shift - ishift > 0.5  ) ishift++;
+
+    pt_H(H, x+_cube_sigmas.at<double>(g_selected_cubes[0]), y, rx, ry);
+    double d0 = rx - hx; double d1 = ry - hy;
+    double radius = sqrt( d0*d0 + d1*d1 );
+    hradius[0] = quantize_radius( (float) radius, _rad_q_no, _cube_sigmas );
+
+    int ihx = (int)hx; if( hx - ihx > 0.5 ) ihx++;
+    int ihy = (int)hy; if( hy - ihy > 0.5 ) ihy++;
+
+    int r, rdt, th, region;
+    double gy, gx;
+    float* histogram=0;
+    ni_get_histogram( descriptor, ihy, ihx, ishift, &layers->at(hradius[0]) );
+    for( r=0; r<_rad_q_no; r++)
+    {
+      rdt = r*_th_q_no + 1;
+      for( th=0; th<_th_q_no; th++ )
+      {
+         region = rdt + th;
+
+         gy = y + _grid_points->at<double>(region,0);
+         gx = x + _grid_points->at<double>(region,1);
+
+         pt_H(H, gx, gy, hx, hy);
+         if( th == 0 )
+         {
+            pt_H(H, gx+_cube_sigmas.at<double>(g_selected_cubes[r]), gy, rx, ry);
+            d0 = rx - hx; d1 = ry - hy;
+            radius = sqrt( d0*d0 + d1*d1 );
+            hradius[r] = quantize_radius( (float) radius, _rad_q_no, _cube_sigmas );
+         }
+
+         ihx = (int)hx; if( hx - ihx > 0.5 ) ihx++;
+         ihy = (int)hy; if( hy - ihy > 0.5 ) ihy++;
+
+         if ( ! Point( ihx, ihy ).inside(
+                Rect( 0, 0, layers->at(0).size[1]-1, layers->at(0).size[0]-1 ) )
+            ) continue;
+
+         histogram = descriptor + region*_hist_th_q_no;
+         ni_get_histogram( histogram, ihy, ihx, ishift, &layers->at(hradius[r]) );
+      }
+    }
+    return true;
+}
+
+static bool i_get_descriptor_h( const double y, const double x, const int orientation, double* H, float* descriptor, const std::vector<Mat>* layers,
+                                const Mat _cube_sigmas, const Mat* _grid_points, const double* _orientation_shift_table, const int _th_q_no )
+{
+    CV_Assert( orientation >= 0 && orientation < 360 );
+    CV_Assert( !layers->empty() );
+    CV_Assert( descriptor != NULL );
+
+    int hradius[MAX_CUBE_NO];
+
+    double hy, hx, ry, rx;
+    pt_H( H, x, y, hx, hy );
+
+    if ( ! Point2f( (float)hx, (float)hy ).inside(
+                Rect( 0, 0, layers->at(0).size[1]-1, layers->at(0).size[0]-1 ) )
+       ) return false;
+
+    int _rad_q_no = (int) layers->size();
+    int _hist_th_q_no = layers->at(0).size[0];
+    pt_H( H, x+_cube_sigmas.at<double>(g_selected_cubes[0]), y, rx, ry);
+    double d0 = rx - hx; double d1 = ry - hy;
+    double radius = sqrt( d0*d0 + d1*d1 );
+    hradius[0] = quantize_radius( (float) radius, _rad_q_no, _cube_sigmas );
+
+    double shift = _orientation_shift_table[orientation];
+    i_get_histogram( descriptor, hy, hx, shift, &layers->at(hradius[0]) );
+
+    double gy, gx;
+    int r, rdt, th, region;
+    float* histogram=0;
+    for( r=0; r<_rad_q_no; r++)
+    {
+      rdt = r*_th_q_no + 1;
+      for( th=0; th<_th_q_no; th++ )
+      {
+         region = rdt + th;
+
+         gy = y + _grid_points->at<double>(region,0);
+         gx = x + _grid_points->at<double>(region,1);
+
+         pt_H(H, gx, gy, hx, hy);
+         if( th == 0 )
+         {
+            pt_H(H, gx+_cube_sigmas.at<double>(g_selected_cubes[r]), gy, rx, ry);
+            d0 = rx - hx; d1 = ry - hy;
+            radius = sqrt( d0*d0 + d1*d1 );
+            hradius[r] = quantize_radius( (float) radius, _rad_q_no, _cube_sigmas );
+         }
+
+         if ( ! Point2f( (float)hx, (float)hy ).inside(
+                Rect( 0, 0, layers->at(0).size[1]-1, layers->at(0).size[0]-1 ) )
+            ) continue;
+
+         histogram = descriptor + region*_hist_th_q_no;
+         i_get_histogram( histogram, hy, hx, shift, &layers->at(hradius[r]) );
+      }
+    }
+    return true;
+}
+
+static void get_unnormalized_descriptor( const double y, const double x, const int orientation, float* descriptor,
+            const std::vector<Mat>* m_smoothed_gradient_layers, const Mat* m_oriented_grid_points,
+            const double* m_orientation_shift_table, const int m_th_q_no, const bool m_enable_interpolation )
+{
+    if( m_enable_interpolation )
+      i_get_descriptor( y, x, orientation, descriptor, m_smoothed_gradient_layers,
+                        m_oriented_grid_points, m_orientation_shift_table, m_th_q_no );
+    else
+     ni_get_descriptor( y, x, orientation, descriptor, m_smoothed_gradient_layers,
+                        m_oriented_grid_points, m_orientation_shift_table, m_th_q_no);
+}
+
+static void get_descriptor( const double y, const double x, const int orientation, float* descriptor,
+            const std::vector<Mat>* m_smoothed_gradient_layers, const Mat* m_oriented_grid_points,
+            const double* m_orientation_shift_table, const int m_th_q_no, const int m_hist_th_q_no,
+            const int m_grid_point_number, const int m_descriptor_size, const bool m_enable_interpolation,
+            const DAISY::NormalizationType m_nrm_type)
+{
+    get_unnormalized_descriptor( y, x, orientation, descriptor, m_smoothed_gradient_layers,
+                                 m_oriented_grid_points, m_orientation_shift_table, m_th_q_no, m_enable_interpolation );
+    normalize_descriptor( descriptor, m_nrm_type, m_grid_point_number, m_hist_th_q_no, m_descriptor_size );
+}
+
+static bool get_unnormalized_descriptor_h( const double y, const double x, const int orientation, float* descriptor, double* H,
+            const std::vector<Mat>* m_smoothed_gradient_layers, const Mat& m_cube_sigmas,
+            const Mat* m_grid_points, const double* m_orientation_shift_table, const int m_th_q_no, const bool m_enable_interpolation )
+
+{
+    if( m_enable_interpolation )
+      return  i_get_descriptor_h( y, x, orientation, H, descriptor, m_smoothed_gradient_layers, m_cube_sigmas,
+                                  m_grid_points, m_orientation_shift_table, m_th_q_no );
+    else
+      return ni_get_descriptor_h( y, x, orientation, H, descriptor, m_smoothed_gradient_layers, m_cube_sigmas,
+                                  m_grid_points, m_orientation_shift_table, m_th_q_no );
+}
+
+static bool get_descriptor_h( const double y, const double x, const int orientation, float* descriptor, double* H,
+            const std::vector<Mat>* m_smoothed_gradient_layers, const Mat& m_cube_sigmas,
+            const Mat* m_grid_points, const double* m_orientation_shift_table, const int m_th_q_no,
+            const int m_hist_th_q_no, const int m_grid_point_number, const int m_descriptor_size,
+            const bool m_enable_interpolation, const DAISY::NormalizationType m_nrm_type)
+
+{
+    bool rval =
+      get_unnormalized_descriptor_h( y, x, orientation, descriptor, H, m_smoothed_gradient_layers, m_cube_sigmas,
+                                   m_grid_points, m_orientation_shift_table, m_th_q_no, m_enable_interpolation );
+
+    if( rval )
+      normalize_descriptor( descriptor, m_nrm_type, m_grid_point_number, m_hist_th_q_no, m_descriptor_size );
+
+    return rval;
+}
+
+void DAISY_Impl::GetDescriptor( double y, double x, int orientation, float* descriptor ) const
+{
+    get_descriptor( y, x, orientation, descriptor, &m_smoothed_gradient_layers,
+                    &m_oriented_grid_points, m_orientation_shift_table, m_th_q_no,
+                    m_hist_th_q_no, m_grid_point_number, m_descriptor_size, m_enable_interpolation,
+                    m_nrm_type );
+}
+
+bool DAISY_Impl::GetDescriptor( double y, double x, int orientation, float* descriptor, double* H ) const
+{
+  return
+  get_descriptor_h( y, x, orientation, descriptor, H, &m_smoothed_gradient_layers,
+                    m_cube_sigmas, &m_grid_points, m_orientation_shift_table, m_th_q_no,
+                    m_hist_th_q_no, m_grid_point_number, m_descriptor_size, m_enable_interpolation,
+                    m_nrm_type );
+}
+
+void DAISY_Impl::GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor ) const
+{
+    get_unnormalized_descriptor( y, x, orientation, descriptor, &m_smoothed_gradient_layers,
+                                 &m_oriented_grid_points, m_orientation_shift_table, m_th_q_no,
+                                 m_enable_interpolation );
+}
+
+bool DAISY_Impl::GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor, double* H ) const
+{
+  return
+  get_unnormalized_descriptor_h( y, x, orientation, descriptor, H, &m_smoothed_gradient_layers,
+                                 m_cube_sigmas, &m_grid_points, m_orientation_shift_table, m_th_q_no,
+                                 m_enable_interpolation );
+}
+
+inline void DAISY_Impl::compute_grid_points()
+{
+    double r_step = m_rad / (double)m_rad_q_no;
+    double t_step = 2*CV_PI / m_th_q_no;
+
+    m_grid_points.release();
+    m_grid_points = Mat( m_grid_point_number, 2, CV_64F );
+
+    for( int y=0; y<m_grid_point_number; y++ )
+    {
+      m_grid_points.at<double>(y,0) = 0;
+      m_grid_points.at<double>(y,1) = 0;
+    }
+
+    for( int r=0; r<m_rad_q_no; r++ )
+    {
+      int region = r*m_th_q_no+1;
+      for( int t=0; t<m_th_q_no; t++ )
+      {
+         m_grid_points.at<double>(region+t,0) = (r+1)*r_step * sin( t*t_step );
+         m_grid_points.at<double>(region+t,1) = (r+1)*r_step * cos( t*t_step );
+      }
+    }
+
+    compute_oriented_grid_points();
+}
+
+struct ComputeDescriptorsInvoker : ParallelLoopBody
+{
+    ComputeDescriptorsInvoker( Mat* _descriptors, Mat* _image, Rect* _roi,
+                               std::vector<Mat>* _layers, Mat* _orientation_map,
+                               Mat* _oriented_grid_points, double* _orientation_shift_table,
+                               int _th_q_no, bool _enable_interpolation )
+    {
+      x_off = _roi->x;
+      x_end = _roi->x + _roi->width;
+      image = _image;
+      layers = _layers;
+      th_q_no = _th_q_no;
+      descriptors = _descriptors;
+      orientation_map = _orientation_map;
+      enable_interpolation = _enable_interpolation;
+      oriented_grid_points = _oriented_grid_points;
+      orientation_shift_table = _orientation_shift_table;
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      int index, orientation;
+      for (int y = range.start; y < range.end; ++y)
+      {
+        for( int x = x_off; x < x_end; x++ )
+        {
+          index = y*image->cols + x;
+          orientation = 0;
+          if( !orientation_map->empty() )
+              orientation = (int) orientation_map->at<ushort>( y, x );
+          if( !( orientation >= 0 && orientation < g_grid_orientation_resolution ) )
+              orientation = 0;
+          get_unnormalized_descriptor( y, x, orientation, descriptors->ptr<float>( index ),
+                                       layers, oriented_grid_points, orientation_shift_table,
+                                       th_q_no, enable_interpolation );
+        }
+      }
+    }
+
+    int th_q_no;
+    int x_off, x_end;
+    std::vector<Mat>* layers;
+    Mat *descriptors;
+    Mat *orientation_map;
+    bool enable_interpolation;
+    double* orientation_shift_table;
+    Mat *image, *oriented_grid_points;
+};
+
+// Computes the descriptor by sampling convoluted orientation maps.
+inline void DAISY_Impl::compute_descriptors( Mat* m_dense_descriptors )
+{
+    int y_off = m_roi.y;
+    int y_end = m_roi.y + m_roi.height;
+
+    if( m_scale_invariant    ) compute_scales();
+    if( m_rotation_invariant ) compute_orientations();
+
+    m_dense_descriptors->setTo( Scalar(0) );
+
+    parallel_for_( Range(y_off, y_end),
+        ComputeDescriptorsInvoker( m_dense_descriptors, &m_image, &m_roi, &m_smoothed_gradient_layers,
+                                   &m_orientation_map, &m_oriented_grid_points, m_orientation_shift_table,
+                                   m_th_q_no, m_enable_interpolation )
+    );
+
+}
+
+struct NormalizeDescriptorsInvoker : ParallelLoopBody
+{
+    NormalizeDescriptorsInvoker( Mat* _descriptors, DAISY::NormalizationType _nrm_type, int _grid_point_number,
+                                 int _hist_th_q_no, int _descriptor_size )
+    {
+      descriptors = _descriptors;
+      nrm_type = _nrm_type;
+      grid_point_number = _grid_point_number;
+      hist_th_q_no = _hist_th_q_no;
+      descriptor_size = _descriptor_size;
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      for (int d = range.start; d < range.end; ++d)
+      {
+        normalize_descriptor( descriptors->ptr<float>(d), nrm_type,
+                              grid_point_number, hist_th_q_no, descriptor_size );
+      }
+    }
+
+    Mat *descriptors;
+    DAISY::NormalizationType nrm_type;
+    int grid_point_number;
+    int hist_th_q_no;
+    int descriptor_size;
+};
+
+inline void DAISY_Impl::normalize_descriptors( Mat* m_dense_descriptors )
+{
+    CV_Assert( !m_dense_descriptors->empty() );
+    int number_of_descriptors =  m_roi.width * m_roi.height;
+
+    parallel_for_( Range(0, number_of_descriptors),
+        NormalizeDescriptorsInvoker( m_dense_descriptors, m_nrm_type, m_grid_point_number, m_hist_th_q_no, m_descriptor_size )
+    );
+}
+
+inline void DAISY_Impl::initialize()
+{
+    // no image ?
+    CV_Assert(m_image.rows != 0);
+    CV_Assert(m_image.cols != 0);
+
+    // (m_rad_q_no + 1) cubes
+    // 3 dims tensor (idhist, img_y, img_x);
+    m_smoothed_gradient_layers.resize( m_rad_q_no + 1 );
+
+    int dims[3] = { m_hist_th_q_no, m_image.rows, m_image.cols };
+    for ( int c=0; c<=m_rad_q_no; c++)
+      m_smoothed_gradient_layers[c] = Mat( 3, dims, CV_32F );
+
+    layered_gradient( m_image, &m_smoothed_gradient_layers[0] );
+
+    // assuming a 0.5 image smoothness, we pull this to 1.6 as in sift
+    smooth_layers( &m_smoothed_gradient_layers[0], (float)sqrt(g_sigma_init*g_sigma_init-0.25f) );
+
+}
+
+inline void DAISY_Impl::compute_cube_sigmas()
+{
+    if( m_cube_sigmas.empty() )
+    {
+
+      m_cube_sigmas = Mat(1, m_rad_q_no, CV_64F);
+
+      double r_step = (double)m_rad / m_rad_q_no / 2;
+      for( int r=0; r<m_rad_q_no; r++ )
+      {
+        m_cube_sigmas.at<double>(r) = (r+1) * r_step;
+      }
+    }
+    update_selected_cubes();
+}
+
+inline void DAISY_Impl::update_selected_cubes()
+{
+    double scale = m_rad/m_rad_q_no/2.0;
+    for( int r=0; r<m_rad_q_no; r++ )
+    {
+      double seed_sigma = ((double)r+1) * scale;
+      g_selected_cubes[r] = quantize_radius( (float)seed_sigma, m_rad_q_no, m_cube_sigmas );
+    }
+}
+
+struct ComputeHistogramsInvoker : ParallelLoopBody
+{
+    ComputeHistogramsInvoker( std::vector<Mat>* _layers, int _r )
+    {
+      r = _r;
+      layers = _layers;
+      _hist_th_q_no = layers->at(r).size[2];
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      for (int y = range.start; y < range.end; ++y)
+      {
+        for( int x = 0; x < layers->at(r).size[1]; x++ )
+        {
+          float* hist = layers->at(r).ptr<float>(y,x,0);
+          for( int h = 0; h < _hist_th_q_no; h++ )
+          {
+            hist[h] = layers->at(r+1).at<float>(h,y,x);
+          }
+        }
+      }
+    }
+
+    int r, _hist_th_q_no;
+    std::vector<Mat> *layers;
+};
+
+inline void DAISY_Impl::compute_histograms()
+{
+    for( int r=0; r<m_rad_q_no; r++ )
+    {
+      // remap cubes from Mat(h,y,x) -> Mat(y,x,h)
+      // final sampling is speeded up by aligned h dim
+      int m_h = m_smoothed_gradient_layers.at(r).size[0];
+      int m_y = m_smoothed_gradient_layers.at(r).size[1];
+      int m_x = m_smoothed_gradient_layers.at(r).size[2];
+
+      // empty targeted cube
+      m_smoothed_gradient_layers.at(r).release();
+
+      // recreate cube space
+      int dims[3] = { m_y, m_x, m_h };
+      m_smoothed_gradient_layers.at(r) = Mat( 3, dims, CV_32F );
+
+      // copy backward all cubes and realign structure
+      parallel_for_( Range(0, m_image.rows), ComputeHistogramsInvoker( &m_smoothed_gradient_layers, r ) );
+    }
+    // trim unused region from collection of cubes
+    m_smoothed_gradient_layers[m_rad_q_no].release();
+    m_smoothed_gradient_layers.pop_back();
+}
+
+inline void DAISY_Impl::compute_smoothed_gradient_layers()
+{
+    double sigma;
+    for( int r=0; r<m_rad_q_no; r++ )
+    {
+      // incremental smoothing
+      if( r == 0 )
+        sigma = m_cube_sigmas.at<double>(0);
+      else
+        sigma = sqrt( m_cube_sigmas.at<double>(r  ) * m_cube_sigmas.at<double>(r  )
+                    - m_cube_sigmas.at<double>(r-1) * m_cube_sigmas.at<double>(r-1) );
+
+      int ks = filter_size( sigma, 5.0f );
+
+      for( int th=0; th<m_hist_th_q_no; th++ )
+      {
+        Mat cvI( m_image.rows, m_image.cols, CV_32F, m_smoothed_gradient_layers[r  ].ptr<float>(th,0,0) );
+        Mat cvO( m_image.rows, m_image.cols, CV_32F, m_smoothed_gradient_layers[r+1].ptr<float>(th,0,0) );
+        GaussianBlur( cvI, cvO, Size(ks, ks), sigma, sigma, BORDER_REPLICATE );
+      }
+    }
+    compute_histograms();
+}
+
+inline void DAISY_Impl::compute_oriented_grid_points()
+{
+    m_oriented_grid_points =
+        Mat( g_grid_orientation_resolution, m_grid_point_number*2, CV_64F );
+
+    for( int i=0; i<g_grid_orientation_resolution; i++ )
+    {
+      double angle = -i*2.0*CV_PI/g_grid_orientation_resolution;
+
+      double kos = cos( angle );
+      double zin = sin( angle );
+
+      Mat point_list = m_oriented_grid_points.row( i );
+
+      for( int k=0; k<m_grid_point_number; k++ )
+      {
+         double y = m_grid_points.at<double>(k,0);
+         double x = m_grid_points.at<double>(k,1);
+
+         point_list.at<double>(2*k+1) =  x*kos + y*zin; // x
+         point_list.at<double>(2*k  ) = -x*zin + y*kos; // y
+      }
+    }
+}
+
+struct MaxDoGInvoker : ParallelLoopBody
+{
+    MaxDoGInvoker( Mat* _next_sim, Mat* _sim, Mat* _max_dog, Mat* _scale_map, int _i, int _r )
+    {
+      i = _i;
+      r = _r;
+      sim = _sim;
+      max_dog = _max_dog;
+      next_sim = _next_sim;
+      scale_map = _scale_map;
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      for (int c = range.start; c < range.end; ++c)
+      {
+        float dog = (float) fabs( next_sim->at<float>(r,c) - sim->at<float>(r,c) );
+        if( dog > max_dog->at<float>(r,c) )
+        {
+          max_dog->at<float>(r,c) = dog;
+          scale_map->at<float>(r,c) = (float) i;
+        }
+      }
+    }
+    int i, r;
+    Mat* max_dog;
+    Mat* scale_map;
+    Mat *sim, *next_sim;
+};
+
+struct RoundingInvoker : ParallelLoopBody
+{
+    RoundingInvoker( Mat* _scale_map, int _r )
+    {
+      r = _r;
+      scale_map = _scale_map;
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      for (int c = range.start; c < range.end; ++c)
+      {
+        scale_map->at<float>(r,c) = (float) cvRound( scale_map->at<float>(r,c) );
+      }
+    }
+    int r;
+    Mat* scale_map;
+};
+
+inline void DAISY_Impl::compute_scales()
+{
+    //###############################################################################
+    //# scale detection is work-in-progress! do not use it if you're not Engin Tola #
+    //###############################################################################
+
+    Mat sim, next_sim;
+    float sigma = (float) ( pow( g_sigma_step, g_scale_st)*g_sigma_0 );
+
+    int ks = filter_size( sigma, 3.0f );
+    GaussianBlur( m_image, sim, Size(ks, ks), sigma, sigma, BORDER_REPLICATE );
+
+    Mat max_dog( m_image.rows, m_image.cols, CV_32F, Scalar(0) );
+    m_scale_map = Mat( m_image.rows, m_image.cols, CV_32F, Scalar(0) );
+
+
+    float sigma_prev;
+    float sigma_new;
+    float sigma_inc;
+
+    sigma_prev = (float) g_sigma_0;
+    for( int i=0; i<g_scale_en; i++ )
+    {
+      sigma_new  = (float) ( pow( g_sigma_step, g_scale_st + i  ) * g_sigma_0 );
+      sigma_inc  = sqrt( sigma_new*sigma_new - sigma_prev*sigma_prev );
+      sigma_prev = sigma_new;
+
+      ks = filter_size( sigma_inc, 3.0f );
+
+      GaussianBlur( sim, next_sim, Size(ks, ks), sigma_inc, sigma_inc, BORDER_REPLICATE );
+
+      for( int r=0; r<m_image.rows; r++ )
+      {
+        parallel_for_( Range(0, m_image.cols), MaxDoGInvoker( &next_sim, &sim, &max_dog, &m_scale_map, i, r ) );
+      }
+      sim.release();
+      sim = next_sim;
+    }
+
+    ks = filter_size( 10.0f, 3.0f );
+    GaussianBlur( m_scale_map, m_scale_map, Size(ks, ks), 10.0f, 10.0f, BORDER_REPLICATE );
+
+    for( int r=0; r<m_image.rows; r++ )
+    {
+      parallel_for_( Range(0, m_image.cols), RoundingInvoker( &m_scale_map, r ) );
+    }
+}
+
+
+inline void DAISY_Impl::compute_orientations()
+{
+    //#####################################################################################
+    //# orientation detection is work-in-progress! do not use it if you're not Engin Tola #
+    //#####################################################################################
+
+    CV_Assert( !m_image.empty() );
+
+    int dims[4] = { 1, m_orientation_resolution, m_image.rows, m_image.cols };
+    Mat rotation_layers(4, dims, CV_32F);
+    layered_gradient( m_image, &rotation_layers );
+
+    m_orientation_map = Mat(m_image.rows, m_image.cols, CV_16U, Scalar(0));
+
+    int ori, max_ind;
+    float max_val;
+
+    int next, prev;
+    float peak, angle;
+
+    int x, y, kk;
+
+    Mat hist;
+
+    float sigma_inc;
+    float sigma_prev = 0.0f;
+    float sigma_new;
+
+    for( int scale=0; scale<g_scale_en; scale++ )
+    {
+
+      sigma_new  = (float)( pow( g_sigma_step, scale  ) * m_rad / 3.0f );
+      sigma_inc  = sqrt( sigma_new*sigma_new - sigma_prev*sigma_prev );
+      sigma_prev = sigma_new;
+
+      smooth_layers( &rotation_layers, sigma_inc );
+
+      for( y=0; y<m_image.rows; y ++ )
+      {
+         hist = Mat(1, m_orientation_resolution, CV_32F);
+
+         for( x=0; x<m_image.cols; x++ )
+         {
+            if( m_scale_invariant && m_scale_map.at<float>(y,x) != scale ) continue;
+
+            for (ori = 0; ori < m_orientation_resolution; ori++)
+            {
+              hist.at<float>(ori) = rotation_layers.at<float>(ori, y, x);
+            }
+            for( kk=0; kk<6; kk++ )
+               smooth_histogram( &hist, m_orientation_resolution );
+
+            max_val = -1;
+            max_ind =  0;
+            for( ori=0; ori<m_orientation_resolution; ori++ )
+            {
+               if( hist.at<float>(ori) > max_val )
+               {
+                  max_val = hist.at<float>(ori);
+                  max_ind = ori;
+               }
+            }
+
+            prev = max_ind-1;
+            if( prev < 0 )
+               prev += m_orientation_resolution;
+
+            next = max_ind+1;
+            if( next >= m_orientation_resolution )
+               next -= m_orientation_resolution;
+
+            peak = interpolate_peak(hist.at<float>(prev), hist.at<float>(max_ind), hist.at<float>(next));
+            angle = (float)( ((float)max_ind + peak)*360.0/m_orientation_resolution );
+
+            int iangle = int(angle);
+
+            if( iangle <    0 ) iangle += 360;
+            if( iangle >= 360 ) iangle -= 360;
+
+            if( !(iangle >= 0.0 && iangle < 360.0) )
+            {
+               angle = 0;
+            }
+            m_orientation_map.at<float>(y,x) = (float)iangle;
+         }
+         hist.release();
+      }
+    }
+    compute_oriented_grid_points();
+}
+
+
+inline void DAISY_Impl::initialize_single_descriptor_mode( )
+{
+    initialize();
+    compute_smoothed_gradient_layers();
+}
+
+inline void DAISY_Impl::set_parameters( )
+{
+    m_grid_point_number = m_rad_q_no * m_th_q_no + 1; // +1 is for center pixel
+    m_descriptor_size = m_grid_point_number * m_hist_th_q_no;
+
+    for( int i=0; i<360; i++ )
+    {
+      m_orientation_shift_table[i] = i/360.0 * m_hist_th_q_no;
+    }
+
+    compute_cube_sigmas();
+    compute_grid_points();
+}
+
+// set/convert image array for daisy internal routines
+// daisy internals use CV_32F image with norm to 1.0f
+inline void DAISY_Impl::set_image( InputArray _image )
+{
+    // release previous image
+    // and previous workspace
+    reset();
+    // fetch new image
+    Mat image = _image.getMat();
+    // image cannot be empty
+    CV_Assert( ! image.empty() );
+    // clone image for conversion
+    if ( image.depth() != CV_32F ) {
+
+      m_image = image.clone();
+      // convert to gray inplace
+      if( m_image.channels() > 1 )
+          cvtColor( m_image, m_image, COLOR_BGR2GRAY );
+      // convert and normalize
+      m_image.convertTo( m_image, CV_32F );
+      m_image /= 255.0f;
+    } else
+      // use original user supplied CV_32F image
+      // should be a normalized one (cannot check)
+      m_image = image;
+}
+
+
+// -------------------------------------------------
+/* DAISY interface implementation */
+
+// keypoint scope
+void DAISY_Impl::compute( InputArray _image, std::vector<KeyPoint>& keypoints, OutputArray _descriptors )
+{
+    // do nothing if no image
+    if( _image.getMat().empty() )
+      return;
+
+    set_image( _image );
+
+    // whole image
+    m_roi = Rect( 0, 0, m_image.cols, m_image.rows );
+
+    // get homography
+    Mat H = m_h_matrix;
+
+    // convert to double if case
+    if ( H.depth() != CV_64F )
+        H.convertTo( H, CV_64F );
+
+    set_parameters();
+
+    initialize_single_descriptor_mode();
+
+    // allocate array
+    _descriptors.create( (int) keypoints.size(), m_descriptor_size, CV_32F );
+
+    // prepare descriptors
+    Mat descriptors = _descriptors.getMat();
+    descriptors.setTo( Scalar(0) );
+
+    // iterate over keypoints
+    // and fill computed descriptors
+    if ( H.empty() )
+      for (int k = 0; k < (int) keypoints.size(); k++)
+      {
+          get_descriptor( keypoints[k].pt.y, keypoints[k].pt.x,
+                          m_use_orientation ? (int) keypoints[k].angle : 0,
+                          &descriptors.at<float>( k, 0 ), &m_smoothed_gradient_layers,
+                          &m_oriented_grid_points, m_orientation_shift_table, m_th_q_no,
+                          m_hist_th_q_no, m_grid_point_number, m_descriptor_size, m_enable_interpolation,
+                          m_nrm_type );
+      }
+    else
+      for (int k = 0; k < (int) keypoints.size(); k++)
+      {
+        get_descriptor_h( keypoints[k].pt.y, keypoints[k].pt.x,
+                          m_use_orientation ? (int) keypoints[k].angle : 0,
+                          &descriptors.at<float>( k, 0 ), &H.at<double>( 0 ), &m_smoothed_gradient_layers,
+                          m_cube_sigmas, &m_grid_points, m_orientation_shift_table, m_th_q_no,
+                          m_hist_th_q_no, m_grid_point_number, m_descriptor_size, m_enable_interpolation,
+                          m_nrm_type );
+      }
+
+}
+
+// full scope with roi
+void DAISY_Impl::compute( InputArray _image, Rect roi, OutputArray _descriptors )
+{
+    // do nothing if no image
+    if( _image.getMat().empty() )
+      return;
+
+    CV_Assert( m_h_matrix.empty() );
+    CV_Assert( ! m_use_orientation );
+
+    set_image( _image );
+
+    m_roi = roi;
+
+    set_parameters();
+    initialize_single_descriptor_mode();
+
+    _descriptors.create( m_roi.width*m_roi.height, m_descriptor_size, CV_32F );
+
+    Mat descriptors = _descriptors.getMat();
+
+    // compute full desc
+    compute_descriptors( &descriptors );
+    normalize_descriptors( &descriptors );
+}
+
+// full scope
+void DAISY_Impl::compute( InputArray _image, OutputArray _descriptors )
+{
+    // do nothing if no image
+    if( _image.getMat().empty() )
+      return;
+
+    CV_Assert( m_h_matrix.empty() );
+    CV_Assert( ! m_use_orientation );
+
+    set_image( _image );
+
+    // whole image
+    m_roi = Rect( 0, 0, m_image.cols, m_image.rows );
+
+    set_parameters();
+    initialize_single_descriptor_mode();
+
+    _descriptors.create( m_roi.width*m_roi.height, m_descriptor_size, CV_32F );
+
+    Mat descriptors = _descriptors.getMat();
+
+    // compute full desc
+    compute_descriptors( &descriptors );
+    normalize_descriptors( &descriptors );
+}
+
+// constructor
+DAISY_Impl::DAISY_Impl( float _radius, int _q_radius, int _q_theta, int _q_hist,
+             DAISY::NormalizationType _norm, InputArray _H, bool _interpolation, bool _use_orientation )
+           : m_rad(_radius), m_rad_q_no(_q_radius), m_th_q_no(_q_theta), m_hist_th_q_no(_q_hist),
+             m_nrm_type(_norm), m_enable_interpolation(_interpolation), m_use_orientation(_use_orientation)
+{
+
+    m_descriptor_size = 0;
+    m_grid_point_number = 0;
+
+    m_scale_invariant = false;
+    m_rotation_invariant = false;
+    m_orientation_resolution = 36;
+
+    m_h_matrix = _H.getMat();
+}
+
+// destructor
+DAISY_Impl::~DAISY_Impl()
+{
+    release_auxiliary();
+}
+
+void DAISY_Impl::read( const FileNode& fn)
+{
+  fn["radius"] >> m_rad;
+  fn["q_radius"] >> m_rad_q_no;
+  fn["q_theta"] >> m_th_q_no;
+  fn["q_hist"] >> m_hist_th_q_no;
+  int norm_type;
+  fn["norm_type"] >> norm_type;
+  setNorm(norm_type);
+  fn["enable_interpolation"] >> m_enable_interpolation;
+  fn["use_orientation"] >> m_use_orientation;
+}
+void DAISY_Impl::write( FileStorage& fs) const
+{
+  if(fs.isOpened())
+  {
+    fs << "name" << getDefaultName();
+    fs << "radius" << m_rad;
+    fs << "q_radius" << m_rad_q_no;
+    fs << "q_theta" << m_th_q_no;
+    fs << "q_hist" << m_hist_th_q_no;
+    fs << "norm_type" << (int)m_nrm_type;
+    fs << "enable_interpolation" << m_enable_interpolation;
+    fs << "use_orientation" << m_use_orientation;
+  }
+}
+
+Ptr<DAISY> DAISY::create( float radius, int q_radius, int q_theta, int q_hist,
+             DAISY::NormalizationType norm, InputArray H, bool interpolation, bool use_orientation)
+{
+    return makePtr<DAISY_Impl>(radius, q_radius, q_theta, q_hist, norm, H, interpolation, use_orientation);
+}
+
+String DAISY::getDefaultName() const
+{
+  return (Feature2D::getDefaultName() + ".DAISY");
+}
+
+
+} // END NAMESPACE XFEATURES2D
+} // END NAMESPACE CV
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/ellipticKeyPoint.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/ellipticKeyPoint.cpp
new file mode 100644
index 00000000..d71b0026
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/ellipticKeyPoint.cpp
@@ -0,0 +1,22 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+
+namespace cv {
+namespace xfeatures2d {
+
+Elliptic_KeyPoint::Elliptic_KeyPoint(Point2f _pt, float _angle, Size _axes, float _size, float _si) :
+    KeyPoint(_pt,_size,_angle), axes(_axes), si(_si) {
+}
+
+Elliptic_KeyPoint::Elliptic_KeyPoint(){
+
+}
+
+Elliptic_KeyPoint::~Elliptic_KeyPoint() {
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/fast.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/fast.cpp
new file mode 100644
index 00000000..fdec0b3b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/fast.cpp
@@ -0,0 +1,480 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include <opencv2/xfeatures2d.hpp>
+
+#ifndef VERIFY_CORNERS
+#define VERIFY_CORNERS 0
+#endif
+
+namespace {
+    using namespace cv;
+    #if VERIFY_CORNERS
+    void testCorner(const uchar* ptr, const int pixel[], int K, int N, int threshold) {
+        // check that with the computed "threshold" the pixel is still a corner
+        // and that with the increased-by-1 "threshold" the pixel is not a corner anymore
+        for( int delta = 0; delta <= 1; delta++ )
+        {
+            int v0 = std::min(ptr[0] + threshold + delta, 255);
+            int v1 = std::max(ptr[0] - threshold - delta, 0);
+            int c0 = 0, c1 = 0;
+
+            for( int k = 0; k < N; k++ )
+            {
+                int x = ptr[pixel[k]];
+                if(x > v0)
+                {
+                    if( ++c0 > K )
+                        break;
+                    c1 = 0;
+                }
+                else if( x < v1 )
+                {
+                    if( ++c1 > K )
+                        break;
+                    c0 = 0;
+                }
+                else
+                {
+                    c0 = c1 = 0;
+                }
+            }
+            CV_Assert( (delta == 0 && std::max(c0, c1) > K) ||
+                        (delta == 1 && std::max(c0, c1) <= K) );
+        }
+    }
+    #endif
+
+    template<int patternSize>
+    int cornerScore(const uchar* ptr, const int pixel[], int threshold);
+
+    template<>
+    int cornerScore<16>(const uchar* ptr, const int pixel[], int threshold)
+    {
+        const int K = 8, N = K*3 + 1;
+        int k, v = ptr[0];
+        short d[N];
+        for( k = 0; k < N; k++ )
+            d[k] = (short)(v - ptr[pixel[k]]);
+
+    #if CV_SSE2
+        __m128i q0 = _mm_set1_epi16(-1000), q1 = _mm_set1_epi16(1000);
+        for( k = 0; k < 16; k += 8 )
+        {
+            __m128i v0 = _mm_loadu_si128((__m128i*)(d+k+1));
+            __m128i v1 = _mm_loadu_si128((__m128i*)(d+k+2));
+            __m128i a = _mm_min_epi16(v0, v1);
+            __m128i b = _mm_max_epi16(v0, v1);
+            v0 = _mm_loadu_si128((__m128i*)(d+k+3));
+            a = _mm_min_epi16(a, v0);
+            b = _mm_max_epi16(b, v0);
+            v0 = _mm_loadu_si128((__m128i*)(d+k+4));
+            a = _mm_min_epi16(a, v0);
+            b = _mm_max_epi16(b, v0);
+            v0 = _mm_loadu_si128((__m128i*)(d+k+5));
+            a = _mm_min_epi16(a, v0);
+            b = _mm_max_epi16(b, v0);
+            v0 = _mm_loadu_si128((__m128i*)(d+k+6));
+            a = _mm_min_epi16(a, v0);
+            b = _mm_max_epi16(b, v0);
+            v0 = _mm_loadu_si128((__m128i*)(d+k+7));
+            a = _mm_min_epi16(a, v0);
+            b = _mm_max_epi16(b, v0);
+            v0 = _mm_loadu_si128((__m128i*)(d+k+8));
+            a = _mm_min_epi16(a, v0);
+            b = _mm_max_epi16(b, v0);
+            v0 = _mm_loadu_si128((__m128i*)(d+k));
+            q0 = _mm_max_epi16(q0, _mm_min_epi16(a, v0));
+            q1 = _mm_min_epi16(q1, _mm_max_epi16(b, v0));
+            v0 = _mm_loadu_si128((__m128i*)(d+k+9));
+            q0 = _mm_max_epi16(q0, _mm_min_epi16(a, v0));
+            q1 = _mm_min_epi16(q1, _mm_max_epi16(b, v0));
+        }
+        q0 = _mm_max_epi16(q0, _mm_sub_epi16(_mm_setzero_si128(), q1));
+        q0 = _mm_max_epi16(q0, _mm_unpackhi_epi64(q0, q0));
+        q0 = _mm_max_epi16(q0, _mm_srli_si128(q0, 4));
+        q0 = _mm_max_epi16(q0, _mm_srli_si128(q0, 2));
+        threshold = (short)_mm_cvtsi128_si32(q0) - 1;
+    #else
+        int a0 = threshold;
+        for( k = 0; k < 16; k += 2 )
+        {
+            int a = std::min((int)d[k+1], (int)d[k+2]);
+            a = std::min(a, (int)d[k+3]);
+            if( a <= a0 )
+                continue;
+            a = std::min(a, (int)d[k+4]);
+            a = std::min(a, (int)d[k+5]);
+            a = std::min(a, (int)d[k+6]);
+            a = std::min(a, (int)d[k+7]);
+            a = std::min(a, (int)d[k+8]);
+            a0 = std::max(a0, std::min(a, (int)d[k]));
+            a0 = std::max(a0, std::min(a, (int)d[k+9]));
+        }
+
+        int b0 = -a0;
+        for( k = 0; k < 16; k += 2 )
+        {
+            int b = std::max((int)d[k+1], (int)d[k+2]);
+            b = std::max(b, (int)d[k+3]);
+            b = std::max(b, (int)d[k+4]);
+            b = std::max(b, (int)d[k+5]);
+            if( b >= b0 )
+                continue;
+            b = std::max(b, (int)d[k+6]);
+            b = std::max(b, (int)d[k+7]);
+            b = std::max(b, (int)d[k+8]);
+
+            b0 = std::min(b0, std::max(b, (int)d[k]));
+            b0 = std::min(b0, std::max(b, (int)d[k+9]));
+        }
+
+        threshold = -b0-1;
+    #endif
+
+    #if VERIFY_CORNERS
+        testCorner(ptr, pixel, K, N, threshold);
+    #endif
+        return threshold;
+    }
+
+    template<>
+    int cornerScore<12>(const uchar* ptr, const int pixel[], int threshold)
+    {
+        const int K = 6, N = K*3 + 1;
+        int k, v = ptr[0];
+        short d[N + 4];
+        for( k = 0; k < N; k++ )
+            d[k] = (short)(v - ptr[pixel[k]]);
+    #if CV_SSE2
+        for( k = 0; k < 4; k++ )
+            d[N+k] = d[k];
+    #endif
+
+    #if CV_SSE2
+        __m128i q0 = _mm_set1_epi16(-1000), q1 = _mm_set1_epi16(1000);
+        for( k = 0; k < 16; k += 8 )
+        {
+            __m128i v0 = _mm_loadu_si128((__m128i*)(d+k+1));
+            __m128i v1 = _mm_loadu_si128((__m128i*)(d+k+2));
+            __m128i a = _mm_min_epi16(v0, v1);
+            __m128i b = _mm_max_epi16(v0, v1);
+            v0 = _mm_loadu_si128((__m128i*)(d+k+3));
+            a = _mm_min_epi16(a, v0);
+            b = _mm_max_epi16(b, v0);
+            v0 = _mm_loadu_si128((__m128i*)(d+k+4));
+            a = _mm_min_epi16(a, v0);
+            b = _mm_max_epi16(b, v0);
+            v0 = _mm_loadu_si128((__m128i*)(d+k+5));
+            a = _mm_min_epi16(a, v0);
+            b = _mm_max_epi16(b, v0);
+            v0 = _mm_loadu_si128((__m128i*)(d+k+6));
+            a = _mm_min_epi16(a, v0);
+            b = _mm_max_epi16(b, v0);
+            v0 = _mm_loadu_si128((__m128i*)(d+k));
+            q0 = _mm_max_epi16(q0, _mm_min_epi16(a, v0));
+            q1 = _mm_min_epi16(q1, _mm_max_epi16(b, v0));
+            v0 = _mm_loadu_si128((__m128i*)(d+k+7));
+            q0 = _mm_max_epi16(q0, _mm_min_epi16(a, v0));
+            q1 = _mm_min_epi16(q1, _mm_max_epi16(b, v0));
+        }
+        q0 = _mm_max_epi16(q0, _mm_sub_epi16(_mm_setzero_si128(), q1));
+        q0 = _mm_max_epi16(q0, _mm_unpackhi_epi64(q0, q0));
+        q0 = _mm_max_epi16(q0, _mm_srli_si128(q0, 4));
+        q0 = _mm_max_epi16(q0, _mm_srli_si128(q0, 2));
+        threshold = (short)_mm_cvtsi128_si32(q0) - 1;
+    #else
+        int a0 = threshold;
+        for( k = 0; k < 12; k += 2 )
+        {
+            int a = std::min((int)d[k+1], (int)d[k+2]);
+            if( a <= a0 )
+                continue;
+            a = std::min(a, (int)d[k+3]);
+            a = std::min(a, (int)d[k+4]);
+            a = std::min(a, (int)d[k+5]);
+            a = std::min(a, (int)d[k+6]);
+            a0 = std::max(a0, std::min(a, (int)d[k]));
+            a0 = std::max(a0, std::min(a, (int)d[k+7]));
+        }
+
+        int b0 = -a0;
+        for( k = 0; k < 12; k += 2 )
+        {
+            int b = std::max((int)d[k+1], (int)d[k+2]);
+            b = std::max(b, (int)d[k+3]);
+            b = std::max(b, (int)d[k+4]);
+            if( b >= b0 )
+                continue;
+            b = std::max(b, (int)d[k+5]);
+            b = std::max(b, (int)d[k+6]);
+
+            b0 = std::min(b0, std::max(b, (int)d[k]));
+            b0 = std::min(b0, std::max(b, (int)d[k+7]));
+        }
+
+        threshold = -b0-1;
+    #endif
+
+    #if VERIFY_CORNERS
+        testCorner(ptr, pixel, K, N, threshold);
+    #endif
+        return threshold;
+    }
+
+    template<>
+    int cornerScore<8>(const uchar* ptr, const int pixel[], int threshold)
+    {
+        const int K = 4, N = K*3 + 1;
+        int k, v = ptr[0];
+        short d[N];
+        for( k = 0; k < N; k++ )
+            d[k] = (short)(v - ptr[pixel[k]]);
+
+    #if CV_SSE2
+        __m128i v0 = _mm_loadu_si128((__m128i*)(d+1));
+        __m128i v1 = _mm_loadu_si128((__m128i*)(d+2));
+        __m128i a = _mm_min_epi16(v0, v1);
+        __m128i b = _mm_max_epi16(v0, v1);
+        v0 = _mm_loadu_si128((__m128i*)(d+3));
+        a = _mm_min_epi16(a, v0);
+        b = _mm_max_epi16(b, v0);
+        v0 = _mm_loadu_si128((__m128i*)(d+4));
+        a = _mm_min_epi16(a, v0);
+        b = _mm_max_epi16(b, v0);
+        v0 = _mm_loadu_si128((__m128i*)(d));
+        __m128i q0 = _mm_min_epi16(a, v0);
+        __m128i q1 = _mm_max_epi16(b, v0);
+        v0 = _mm_loadu_si128((__m128i*)(d+5));
+        q0 = _mm_max_epi16(q0, _mm_min_epi16(a, v0));
+        q1 = _mm_min_epi16(q1, _mm_max_epi16(b, v0));
+        q0 = _mm_max_epi16(q0, _mm_sub_epi16(_mm_setzero_si128(), q1));
+        q0 = _mm_max_epi16(q0, _mm_unpackhi_epi64(q0, q0));
+        q0 = _mm_max_epi16(q0, _mm_srli_si128(q0, 4));
+        q0 = _mm_max_epi16(q0, _mm_srli_si128(q0, 2));
+        threshold = (short)_mm_cvtsi128_si32(q0) - 1;
+    #else
+        int a0 = threshold;
+        for( k = 0; k < 8; k += 2 )
+        {
+            int a = std::min((int)d[k+1], (int)d[k+2]);
+            if( a <= a0 )
+                continue;
+            a = std::min(a, (int)d[k+3]);
+            a = std::min(a, (int)d[k+4]);
+            a0 = std::max(a0, std::min(a, (int)d[k]));
+            a0 = std::max(a0, std::min(a, (int)d[k+5]));
+        }
+
+        int b0 = -a0;
+        for( k = 0; k < 8; k += 2 )
+        {
+            int b = std::max((int)d[k+1], (int)d[k+2]);
+            b = std::max(b, (int)d[k+3]);
+            if( b >= b0 )
+                continue;
+            b = std::max(b, (int)d[k+4]);
+
+            b0 = std::min(b0, std::max(b, (int)d[k]));
+            b0 = std::min(b0, std::max(b, (int)d[k+5]));
+        }
+
+        threshold = -b0-1;
+    #endif
+
+    #if VERIFY_CORNERS
+        testCorner(ptr, pixel, K, N, threshold);
+    #endif
+        return threshold;
+    }
+
+    void makeOffsets(int pixel[25], int rowStride, int patternSize)
+    {
+        static const int offsets16[][2] =
+        {
+            {0,  3}, { 1,  3}, { 2,  2}, { 3,  1}, { 3, 0}, { 3, -1}, { 2, -2}, { 1, -3},
+            {0, -3}, {-1, -3}, {-2, -2}, {-3, -1}, {-3, 0}, {-3,  1}, {-2,  2}, {-1,  3}
+        };
+
+        static const int offsets12[][2] =
+        {
+            {0,  2}, { 1,  2}, { 2,  1}, { 2, 0}, { 2, -1}, { 1, -2},
+            {0, -2}, {-1, -2}, {-2, -1}, {-2, 0}, {-2,  1}, {-1,  2}
+        };
+
+        static const int offsets8[][2] =
+        {
+            {0,  1}, { 1,  1}, { 1, 0}, { 1, -1},
+            {0, -1}, {-1, -1}, {-1, 0}, {-1,  1}
+        };
+
+        const int (*offsets)[2] = patternSize == 16 ? offsets16 :
+                                    patternSize == 12 ? offsets12 :
+                                    patternSize == 8  ? offsets8  : 0;
+
+        CV_Assert(pixel && offsets);
+
+        int k = 0;
+        for( ; k < patternSize; k++ )
+            pixel[k] = offsets[k][0] + offsets[k][1] * rowStride;
+        for( ; k < 25; k++ )
+            pixel[k] = pixel[k - patternSize];
+    }
+
+    template<int patternSize>
+    void FASTForPointSet_t( InputArray image, std::vector<KeyPoint>& keypoints, int threshold, bool nonmaxSuppression ) {
+
+        Mat img = image.getMat();
+        const int K = patternSize/2, N = patternSize + K + 1;
+
+        int i, k, pixel[25];
+        makeOffsets(pixel, (int)img.step, patternSize);
+
+        threshold = std::min(std::max(threshold, 0), 255);
+
+        uchar threshold_tab[512];
+        for( i = -255; i <= 255; i++ )
+            threshold_tab[i+255] = (uchar)(i < -threshold ? 1 : i > threshold ? 2 : 0);
+
+        AutoBuffer<uchar> _buf((img.cols+16)*3*(sizeof(int) + sizeof(uchar)) + 128);
+        uchar* buf[3];
+        buf[0] = _buf.data(); buf[1] = buf[0] + img.cols; buf[2] = buf[1] + img.cols;
+        int* cpbuf[3];
+        cpbuf[0] = (int*)alignPtr(buf[2] + img.cols, sizeof(int)) + 1;
+        cpbuf[1] = cpbuf[0] + img.cols + 1;
+        cpbuf[2] = cpbuf[1] + img.cols + 1;
+        memset(buf[0], 0, img.cols*3);
+
+        // Calculate threshold for the keypoints
+        for (size_t keyPointIdx=0; keyPointIdx < keypoints.size(); keyPointIdx++) {
+            // Set response to -1:
+            // All keypoints with response <= 0 will be removed afterwards
+            keypoints[keyPointIdx].response = -1;
+
+            // Poiter to keyPoint in image
+            Point keyPoint = keypoints[keyPointIdx].pt;
+            const uchar* ptr = img.ptr<uchar>(keyPoint.y, keyPoint.x);
+
+            // value of the pixel at certain position
+            int v = ptr[0];
+
+            // Initialize Lookup table
+            // If k=v --> tab[k] is at the center of the thrshold table
+            // The threshold table is made as follows:
+            // -255         -threshold         0        +threshold        255
+            // 111111111111111111|0000000000000|0000000000000|222222222222222
+            const uchar* tab = &threshold_tab[0] - v + 255;
+
+            // Calculate the fast value
+            int d = tab[ptr[pixel[0]]] | tab[ptr[pixel[8]]];
+
+            if( d == 0 )
+                continue;
+
+            d &= tab[ptr[pixel[2]]] | tab[ptr[pixel[10]]];
+            d &= tab[ptr[pixel[4]]] | tab[ptr[pixel[12]]];
+            d &= tab[ptr[pixel[6]]] | tab[ptr[pixel[14]]];
+
+            if( d == 0 )
+                continue;
+
+            d &= tab[ptr[pixel[1]]] | tab[ptr[pixel[9]]];
+            d &= tab[ptr[pixel[3]]] | tab[ptr[pixel[11]]];
+            d &= tab[ptr[pixel[5]]] | tab[ptr[pixel[13]]];
+            d &= tab[ptr[pixel[7]]] | tab[ptr[pixel[15]]];
+
+            // For at least half pixels darker than v count the number
+            if( d & 1 )
+            {
+                int vt = v - threshold, count = 0;
+
+                for(k = 0; k < N; k++ )
+                {
+                    int x = ptr[pixel[k]];
+                    if(x < vt)
+                    {
+                        if( ++count > K )
+                        {
+                            // Calculate score
+                            keypoints[keyPointIdx].response = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);
+                            // Non Maxima Supression I
+                            if (nonmaxSuppression && keyPointIdx>0 && keypoints[keyPointIdx-1].response < keypoints[keyPointIdx].response) {
+                                keypoints[keyPointIdx-1].response = -1;
+                            }
+                            break;
+                        }
+                    }
+                    else
+                        count = 0;
+                }
+            }
+
+            // For at least half pixels brighter than v count the number
+            if(d & 2 )
+            {
+                int vt = v + threshold, count = 0;
+
+                for(k = 0; k < N; k++ )
+                {
+                    int x = ptr[pixel[k]];
+                    if(x > vt)
+                    {
+                        if( ++count > K )
+                        {
+                            // Calculate score
+                            keypoints[keyPointIdx].response = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);
+                            // Non Maxima Suppression I
+                            if (nonmaxSuppression && keyPointIdx>0 &&keypoints[keyPointIdx-1].response < keypoints[keyPointIdx].response) {
+                                keypoints[keyPointIdx-1].response = -1;
+                            }
+                            break;
+                        }
+                    }
+                    else
+                        count = 0;
+                }
+            }
+
+        }
+
+        // Remove unused Keypoints
+        size_t maxKeypointSize = keypoints.size();
+        for (size_t keyPointIdx=maxKeypointSize; keyPointIdx > 0;) {
+            keyPointIdx--;
+            if (keypoints[keyPointIdx].response <= 0) {
+                keypoints.erase(keypoints.begin() + keyPointIdx);
+            } else if (nonmaxSuppression && keyPointIdx>0 && keypoints[keyPointIdx-1].response > keypoints[keyPointIdx].response) {
+                // Non Maxima Suppression II
+                keypoints.erase(keypoints.begin() + keyPointIdx);
+            }
+        }
+    }
+
+}
+
+namespace cv {
+    namespace xfeatures2d {
+
+        void FASTForPointSet(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, FastFeatureDetector::DetectorType type)
+        {
+            if (keypoints.empty()) {
+                FAST(_img, keypoints, threshold, nonmax_suppression, type);
+                return;
+            }
+
+            switch(type) {
+            case FastFeatureDetector::TYPE_5_8:
+                FASTForPointSet_t<8>(_img, keypoints, threshold, nonmax_suppression);
+                break;
+            case FastFeatureDetector::TYPE_7_12:
+                FASTForPointSet_t<12>(_img, keypoints, threshold, nonmax_suppression);
+                break;
+            case FastFeatureDetector::TYPE_9_16:
+                FASTForPointSet_t<16>(_img, keypoints, threshold, nonmax_suppression);
+                break;
+            }
+        }
+
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/freak.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/freak.cpp
new file mode 100644
index 00000000..793836b0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/freak.cpp
@@ -0,0 +1,888 @@
+//  freak.cpp
+//
+//  Copyright (C) 2011-2012  Signal processing laboratory 2, EPFL,
+//  Kirell Benzi (kirell.benzi@epfl.ch),
+//  Raphael Ortiz (raphael.ortiz@a3.epfl.ch)
+//  Alexandre Alahi (alexandre.alahi@epfl.ch)
+//  and Pierre Vandergheynst (pierre.vandergheynst@epfl.ch)
+//
+//  Redistribution and use in source and binary forms, with or without modification,
+//  are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+//  This software is provided by the copyright holders and contributors "as is" and
+//  any express or implied warranties, including, but not limited to, the implied
+//  warranties of merchantability and fitness for a particular purpose are disclaimed.
+//  In no event shall the Intel Corporation or contributors be liable for any direct,
+//  indirect, incidental, special, exemplary, or consequential damages
+//  (including, but not limited to, procurement of substitute goods or services;
+//  loss of use, data, or profits; or business interruption) however caused
+//  and on any theory of liability, whether in contract, strict liability,
+//  or tort (including negligence or otherwise) arising in any way out of
+//  the use of this software, even if advised of the possibility of such damage.
+
+#include "precomp.hpp"
+#include <fstream>
+#include <stdlib.h>
+#include <algorithm>
+#include <iostream>
+#include <bitset>
+#include <sstream>
+#include <algorithm>
+#include <iomanip>
+#include <string.h>
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+/*!
+ FREAK implementation
+ */
+class FREAK_Impl CV_FINAL : public FREAK
+{
+public:
+    /** Constructor
+     * @param orientationNormalized enable orientation normalization
+     * @param scaleNormalized enable scale normalization
+     * @param patternScale scaling of the description pattern
+     * @param nbOctave number of octaves covered by the detected keypoints
+     * @param selectedPairs (optional) user defined selected pairs
+     */
+    explicit FREAK_Impl( bool orientationNormalized = true,
+                   bool scaleNormalized = true,
+                   float patternScale = 22.0f,
+                   int nOctaves = 4,
+                   const std::vector<int>& selectedPairs = std::vector<int>());
+
+    virtual ~FREAK_Impl();
+
+    void read( const FileNode& fn) CV_OVERRIDE;
+    void write( FileStorage& fs) const CV_OVERRIDE;
+
+    void setOrientationNormalized(bool _orientationNormalized) CV_OVERRIDE {orientationNormalized = _orientationNormalized;}
+    bool getOrientationNormalized() const CV_OVERRIDE { return orientationNormalized; }
+
+    void setScaleNormalized(bool _scaleNormalized) CV_OVERRIDE {scaleNormalized = _scaleNormalized;}
+    bool getScaleNormalized() const CV_OVERRIDE { return scaleNormalized; }
+
+    void setPatternScale(double _patternScale) CV_OVERRIDE {patternScale = _patternScale;}
+    double getPatternScale() const CV_OVERRIDE { return patternScale; }
+
+    void setNOctaves(int _nOctaves) CV_OVERRIDE {nOctaves = _nOctaves;}
+    int getNOctaves() const CV_OVERRIDE { return nOctaves; }
+
+    /** returns the descriptor length in bytes */
+    virtual int descriptorSize() const CV_OVERRIDE;
+
+    /** returns the descriptor type */
+    virtual int descriptorType() const CV_OVERRIDE;
+
+    /** returns the default norm type */
+    virtual int defaultNorm() const CV_OVERRIDE;
+
+    /** select the 512 "best description pairs"
+     * @param images grayscale images set
+     * @param keypoints set of detected keypoints
+     * @param corrThresh correlation threshold
+     * @param verbose print construction information
+     * @return list of best pair indexes
+     */
+    std::vector<int> selectPairs( const std::vector<Mat>& images, std::vector<std::vector<KeyPoint> >& keypoints,
+                                 const double corrThresh = 0.7, bool verbose = true );
+    virtual void compute( InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors ) CV_OVERRIDE;
+
+protected:
+
+    void buildPattern();
+
+    template <typename imgType, typename iiType>
+    imgType meanIntensity( InputArray image, InputArray integral, const float kp_x, const float kp_y,
+                          const unsigned int scale, const unsigned int rot, const unsigned int point );
+
+    template <typename srcMatType, typename iiMatType>
+    void computeDescriptors( InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors );
+
+    template <typename srcMatType>
+    void extractDescriptor(srcMatType *pointsValue, void ** ptr);
+
+    bool orientationNormalized; //true if the orientation is normalized, false otherwise
+    bool scaleNormalized; //true if the scale is normalized, false otherwise
+    double patternScale; //scaling of the pattern
+    int nOctaves; //number of octaves
+    bool extAll; // true if all pairs need to be extracted for pairs selection
+
+    double patternScale0;
+    int nOctaves0;
+    std::vector<int> selectedPairs0;
+
+    struct PatternPoint
+    {
+        float x; // x coordinate relative to center
+        float y; // x coordinate relative to center
+        float sigma; // Gaussian smoothing sigma
+    };
+
+    struct DescriptionPair
+    {
+        uchar i; // index of the first point
+        uchar j; // index of the second point
+    };
+
+    struct OrientationPair
+    {
+        uchar i; // index of the first point
+        uchar j; // index of the second point
+        int weight_dx; // dx/(norm_sq))*4096
+        int weight_dy; // dy/(norm_sq))*4096
+    };
+
+    std::vector<PatternPoint> patternLookup; // look-up table for the pattern points (position+sigma of all points at all scales and orientation)
+    int patternSizes[NB_SCALES]; // size of the pattern at a specific scale (used to check if a point is within image boundaries)
+    DescriptionPair descriptionPairs[NB_PAIRS];
+    OrientationPair orientationPairs[NB_ORIENPAIRS];
+};
+
+static const double FREAK_LOG2 = 0.693147180559945;
+static const int FREAK_NB_ORIENTATION = 256;
+static const int FREAK_NB_POINTS = 43;
+static const int FREAK_SMALLEST_KP_SIZE = 7; // smallest size of keypoints
+
+// default pairs
+static const int FREAK_DEF_PAIRS[FREAK_Impl::NB_PAIRS] =
+{
+     404,431,818,511,181,52,311,874,774,543,719,230,417,205,11,
+     560,149,265,39,306,165,857,250,8,61,15,55,717,44,412,
+     592,134,761,695,660,782,625,487,549,516,271,665,762,392,178,
+     796,773,31,672,845,548,794,677,654,241,831,225,238,849,83,
+     691,484,826,707,122,517,583,731,328,339,571,475,394,472,580,
+     381,137,93,380,327,619,729,808,218,213,459,141,806,341,95,
+     382,568,124,750,193,749,706,843,79,199,317,329,768,198,100,
+     466,613,78,562,783,689,136,838,94,142,164,679,219,419,366,
+     418,423,77,89,523,259,683,312,555,20,470,684,123,458,453,833,
+     72,113,253,108,313,25,153,648,411,607,618,128,305,232,301,84,
+     56,264,371,46,407,360,38,99,176,710,114,578,66,372,653,
+     129,359,424,159,821,10,323,393,5,340,891,9,790,47,0,175,346,
+     236,26,172,147,574,561,32,294,429,724,755,398,787,288,299,
+     769,565,767,722,757,224,465,723,498,467,235,127,802,446,233,
+     544,482,800,318,16,532,801,441,554,173,60,530,713,469,30,
+     212,630,899,170,266,799,88,49,512,399,23,500,107,524,90,
+     194,143,135,192,206,345,148,71,119,101,563,870,158,254,214,
+     276,464,332,725,188,385,24,476,40,231,620,171,258,67,109,
+     844,244,187,388,701,690,50,7,850,479,48,522,22,154,12,659,
+     736,655,577,737,830,811,174,21,237,335,353,234,53,270,62,
+     182,45,177,245,812,673,355,556,612,166,204,54,248,365,226,
+     242,452,700,685,573,14,842,481,468,781,564,416,179,405,35,
+     819,608,624,367,98,643,448,2,460,676,440,240,130,146,184,
+     185,430,65,807,377,82,121,708,239,310,138,596,730,575,477,
+     851,797,247,27,85,586,307,779,326,494,856,324,827,96,748,
+     13,397,125,688,702,92,293,716,277,140,112,4,80,855,839,1,
+     413,347,584,493,289,696,19,751,379,76,73,115,6,590,183,734,
+     197,483,217,344,330,400,186,243,587,220,780,200,793,246,824,
+     41,735,579,81,703,322,760,720,139,480,490,91,814,813,163,
+     152,488,763,263,425,410,576,120,319,668,150,160,302,491,515,
+     260,145,428,97,251,395,272,252,18,106,358,854,485,144,550,
+     131,133,378,68,102,104,58,361,275,209,697,582,338,742,589,
+     325,408,229,28,304,191,189,110,126,486,211,547,533,70,215,
+     670,249,36,581,389,605,331,518,442,822
+};
+
+// used to sort pairs during pairs selection
+struct PairStat
+{
+    double mean;
+    int idx;
+};
+
+struct sortMean
+{
+    bool operator()( const PairStat& a, const PairStat& b ) const
+    {
+        return a.mean < b.mean;
+    }
+};
+
+void FREAK_Impl::buildPattern()
+{
+    if( patternScale == patternScale0 && nOctaves == nOctaves0 && !patternLookup.empty() )
+        return;
+
+    nOctaves0 = nOctaves;
+    patternScale0 = patternScale;
+
+    patternLookup.resize(FREAK::NB_SCALES*FREAK_NB_ORIENTATION*FREAK_NB_POINTS);
+    double scaleStep = std::pow(2.0, (double)(nOctaves)/FREAK::NB_SCALES ); // 2 ^ ( (nOctaves-1) /nbScales)
+    double scalingFactor, alpha, beta, theta = 0;
+
+    // pattern definition, radius normalized to 1.0 (outer point position+sigma=1.0)
+    const int n[8] = {6,6,6,6,6,6,6,1}; // number of points on each concentric circle (from outer to inner)
+    const double bigR(2.0/3.0); // bigger radius
+    const double smallR(2.0/24.0); // smaller radius
+    const double unitSpace( (bigR-smallR)/21.0 ); // define spaces between concentric circles (from center to outer: 1,2,3,4,5,6)
+    // radii of the concentric cirles (from outer to inner)
+    const double radius[8] = {bigR, bigR-6*unitSpace, bigR-11*unitSpace, bigR-15*unitSpace, bigR-18*unitSpace, bigR-20*unitSpace, smallR, 0.0};
+    // sigma of pattern points (each group of 6 points on a concentric cirle has the same sigma)
+    const double sigma[8] = {radius[0]/2.0, radius[1]/2.0, radius[2]/2.0,
+                             radius[3]/2.0, radius[4]/2.0, radius[5]/2.0,
+                             radius[6]/2.0, radius[6]/2.0
+                            };
+    // fill the lookup table
+    for( int scaleIdx=0; scaleIdx < FREAK::NB_SCALES; ++scaleIdx )
+    {
+        patternSizes[scaleIdx] = 0; // proper initialization
+        scalingFactor = std::pow(scaleStep,scaleIdx); //scale of the pattern, scaleStep ^ scaleIdx
+
+        for( int orientationIdx = 0; orientationIdx < FREAK_NB_ORIENTATION; ++orientationIdx )
+        {
+            theta = double(orientationIdx)* 2*CV_PI/double(FREAK_NB_ORIENTATION); // orientation of the pattern
+            int pointIdx = 0;
+
+            PatternPoint* patternLookupPtr = &patternLookup[0];
+            for( size_t i = 0; i < 8; ++i )
+            {
+                for( int k = 0 ; k < n[i]; ++k )
+                {
+                    beta = CV_PI/n[i] * (i%2); // orientation offset so that groups of points on each circles are staggered
+                    alpha = double(k)* 2*CV_PI/double(n[i])+beta+theta;
+
+                    // add the point to the look-up table
+                    PatternPoint& point = patternLookupPtr[ scaleIdx*FREAK_NB_ORIENTATION*FREAK_NB_POINTS+orientationIdx*FREAK_NB_POINTS+pointIdx ];
+                    point.x = static_cast<float>(radius[i] * cos(alpha) * scalingFactor * patternScale);
+                    point.y = static_cast<float>(radius[i] * sin(alpha) * scalingFactor * patternScale);
+                    point.sigma = static_cast<float>(sigma[i] * scalingFactor * patternScale);
+
+                    // adapt the sizeList if necessary
+                    const int sizeMax = static_cast<int>(ceil((radius[i]+sigma[i])*scalingFactor*patternScale)) + 1;
+                    if( patternSizes[scaleIdx] < sizeMax )
+                        patternSizes[scaleIdx] = sizeMax;
+
+                    ++pointIdx;
+                }
+            }
+        }
+    }
+
+    // build the list of orientation pairs
+    orientationPairs[0].i=0; orientationPairs[0].j=3; orientationPairs[1].i=1; orientationPairs[1].j=4; orientationPairs[2].i=2; orientationPairs[2].j=5;
+    orientationPairs[3].i=0; orientationPairs[3].j=2; orientationPairs[4].i=1; orientationPairs[4].j=3; orientationPairs[5].i=2; orientationPairs[5].j=4;
+    orientationPairs[6].i=3; orientationPairs[6].j=5; orientationPairs[7].i=4; orientationPairs[7].j=0; orientationPairs[8].i=5; orientationPairs[8].j=1;
+
+    orientationPairs[9].i=6; orientationPairs[9].j=9; orientationPairs[10].i=7; orientationPairs[10].j=10; orientationPairs[11].i=8; orientationPairs[11].j=11;
+    orientationPairs[12].i=6; orientationPairs[12].j=8; orientationPairs[13].i=7; orientationPairs[13].j=9; orientationPairs[14].i=8; orientationPairs[14].j=10;
+    orientationPairs[15].i=9; orientationPairs[15].j=11; orientationPairs[16].i=10; orientationPairs[16].j=6; orientationPairs[17].i=11; orientationPairs[17].j=7;
+
+    orientationPairs[18].i=12; orientationPairs[18].j=15; orientationPairs[19].i=13; orientationPairs[19].j=16; orientationPairs[20].i=14; orientationPairs[20].j=17;
+    orientationPairs[21].i=12; orientationPairs[21].j=14; orientationPairs[22].i=13; orientationPairs[22].j=15; orientationPairs[23].i=14; orientationPairs[23].j=16;
+    orientationPairs[24].i=15; orientationPairs[24].j=17; orientationPairs[25].i=16; orientationPairs[25].j=12; orientationPairs[26].i=17; orientationPairs[26].j=13;
+
+    orientationPairs[27].i=18; orientationPairs[27].j=21; orientationPairs[28].i=19; orientationPairs[28].j=22; orientationPairs[29].i=20; orientationPairs[29].j=23;
+    orientationPairs[30].i=18; orientationPairs[30].j=20; orientationPairs[31].i=19; orientationPairs[31].j=21; orientationPairs[32].i=20; orientationPairs[32].j=22;
+    orientationPairs[33].i=21; orientationPairs[33].j=23; orientationPairs[34].i=22; orientationPairs[34].j=18; orientationPairs[35].i=23; orientationPairs[35].j=19;
+
+    orientationPairs[36].i=24; orientationPairs[36].j=27; orientationPairs[37].i=25; orientationPairs[37].j=28; orientationPairs[38].i=26; orientationPairs[38].j=29;
+    orientationPairs[39].i=30; orientationPairs[39].j=33; orientationPairs[40].i=31; orientationPairs[40].j=34; orientationPairs[41].i=32; orientationPairs[41].j=35;
+    orientationPairs[42].i=36; orientationPairs[42].j=39; orientationPairs[43].i=37; orientationPairs[43].j=40; orientationPairs[44].i=38; orientationPairs[44].j=41;
+
+    for( unsigned m = FREAK::NB_ORIENPAIRS; m--; )
+    {
+        const float dx = patternLookup[orientationPairs[m].i].x-patternLookup[orientationPairs[m].j].x;
+        const float dy = patternLookup[orientationPairs[m].i].y-patternLookup[orientationPairs[m].j].y;
+        const float norm_sq = (dx*dx+dy*dy);
+        orientationPairs[m].weight_dx = cvRound((dx/(norm_sq))*4096.0);
+        orientationPairs[m].weight_dy = cvRound((dy/(norm_sq))*4096.0);
+    }
+
+    // build the list of description pairs
+    std::vector<DescriptionPair> allPairs;
+    for( unsigned int i = 1; i < (unsigned int)FREAK_NB_POINTS; ++i )
+    {
+        // (generate all the pairs)
+        for( unsigned int j = 0; (unsigned int)j < i; ++j )
+        {
+            DescriptionPair pair = {(uchar)i,(uchar)j};
+            allPairs.push_back(pair);
+        }
+    }
+    // Input vector provided
+    if( !selectedPairs0.empty() )
+    {
+        if( (int)selectedPairs0.size() == FREAK::NB_PAIRS )
+        {
+            for( int i = 0; i < FREAK::NB_PAIRS; ++i )
+                 descriptionPairs[i] = allPairs[selectedPairs0.at(i)];
+        }
+        else
+        {
+            CV_Error(Error::StsVecLengthErr, "Input vector does not match the required size");
+        }
+    }
+    else // default selected pairs
+    {
+        for( int i = 0; i < FREAK::NB_PAIRS; ++i )
+             descriptionPairs[i] = allPairs[FREAK_DEF_PAIRS[i]];
+    }
+}
+
+void FREAK_Impl::compute( InputArray _image, std::vector<KeyPoint>& keypoints, OutputArray _descriptors )
+{
+    Mat image = _image.getMat();
+    if( image.empty() )
+        return;
+    if( keypoints.empty() )
+        return;
+
+    ((FREAK_Impl*)this)->buildPattern();
+
+    // Convert to gray if not already
+    Mat grayImage;
+    if( image.channels() == 3 || image.channels() == 4 )
+        cvtColor(image, grayImage, COLOR_BGR2GRAY);
+    else {
+        CV_Assert(image.channels() == 1);
+        grayImage = image;
+    }
+
+    // Use 32-bit integers if we won't overflow in the integral image
+    if ((image.depth() == CV_8U || image.depth() == CV_8S) &&
+        (image.rows * image.cols) < 8388608 ) // 8388608 = 2 ^ (32 - 8(bit depth) - 1(sign bit))
+    {
+        // Create the integral image appropriate for our type & usage
+        if (image.depth() == CV_8U)
+            computeDescriptors<uchar, int>(grayImage, keypoints, _descriptors);
+        else if (image.depth() == CV_8S)
+            computeDescriptors<char, int>(grayImage, keypoints, _descriptors);
+        else
+            CV_Error( Error::StsUnsupportedFormat, "" );
+    } else {
+        // Create the integral image appropriate for our type & usage
+        if ( image.depth() == CV_8U )
+            computeDescriptors<uchar, double>(grayImage, keypoints, _descriptors);
+        else if ( image.depth() == CV_8S )
+            computeDescriptors<char, double>(grayImage, keypoints, _descriptors);
+        else if ( image.depth() == CV_16U )
+            computeDescriptors<ushort, double>(grayImage, keypoints, _descriptors);
+        else if ( image.depth() == CV_16S )
+            computeDescriptors<short, double>(grayImage, keypoints, _descriptors);
+        else
+            CV_Error( Error::StsUnsupportedFormat, "" );
+    }
+}
+
+template <typename srcMatType>
+void FREAK_Impl::extractDescriptor(srcMatType *pointsValue, void ** ptr)
+{
+    std::bitset<FREAK::NB_PAIRS>** ptrScalar = (std::bitset<FREAK::NB_PAIRS>**) ptr;
+
+    // extracting descriptor preserving the order of SSE version
+    int cnt = 0;
+    for( int n = 7; n < FREAK::NB_PAIRS; n += 128)
+    {
+        for( int m = 8; m--; )
+        {
+            int nm = n-m;
+            for(int kk = nm+15*8; kk >= nm; kk-=8, ++cnt)
+            {
+                (*ptrScalar)->set(kk, pointsValue[descriptionPairs[cnt].i] >= pointsValue[descriptionPairs[cnt].j]);
+            }
+        }
+    }
+    --(*ptrScalar);
+}
+
+#if CV_SSE2
+template <>
+void FREAK_Impl::extractDescriptor(uchar *pointsValue, void ** ptr)
+{
+    __m128i** ptrSSE = (__m128i**) ptr;
+
+    // note that comparisons order is modified in each block (but first 128 comparisons remain globally the same-->does not affect the 128,384 bits segmanted matching strategy)
+    int cnt = 0;
+    for( int n = FREAK::NB_PAIRS/128; n-- ; )
+    {
+        __m128i result128 = _mm_setzero_si128();
+        for( int m = 128/16; m--; cnt += 16 )
+        {
+            __m128i operand1 = _mm_set_epi8(pointsValue[descriptionPairs[cnt+0].i],
+                                            pointsValue[descriptionPairs[cnt+1].i],
+                                            pointsValue[descriptionPairs[cnt+2].i],
+                                            pointsValue[descriptionPairs[cnt+3].i],
+                                            pointsValue[descriptionPairs[cnt+4].i],
+                                            pointsValue[descriptionPairs[cnt+5].i],
+                                            pointsValue[descriptionPairs[cnt+6].i],
+                                            pointsValue[descriptionPairs[cnt+7].i],
+                                            pointsValue[descriptionPairs[cnt+8].i],
+                                            pointsValue[descriptionPairs[cnt+9].i],
+                                            pointsValue[descriptionPairs[cnt+10].i],
+                                            pointsValue[descriptionPairs[cnt+11].i],
+                                            pointsValue[descriptionPairs[cnt+12].i],
+                                            pointsValue[descriptionPairs[cnt+13].i],
+                                            pointsValue[descriptionPairs[cnt+14].i],
+                                            pointsValue[descriptionPairs[cnt+15].i]);
+
+            __m128i operand2 = _mm_set_epi8(pointsValue[descriptionPairs[cnt+0].j],
+                                            pointsValue[descriptionPairs[cnt+1].j],
+                                            pointsValue[descriptionPairs[cnt+2].j],
+                                            pointsValue[descriptionPairs[cnt+3].j],
+                                            pointsValue[descriptionPairs[cnt+4].j],
+                                            pointsValue[descriptionPairs[cnt+5].j],
+                                            pointsValue[descriptionPairs[cnt+6].j],
+                                            pointsValue[descriptionPairs[cnt+7].j],
+                                            pointsValue[descriptionPairs[cnt+8].j],
+                                            pointsValue[descriptionPairs[cnt+9].j],
+                                            pointsValue[descriptionPairs[cnt+10].j],
+                                            pointsValue[descriptionPairs[cnt+11].j],
+                                            pointsValue[descriptionPairs[cnt+12].j],
+                                            pointsValue[descriptionPairs[cnt+13].j],
+                                            pointsValue[descriptionPairs[cnt+14].j],
+                                            pointsValue[descriptionPairs[cnt+15].j]);
+
+            __m128i workReg = _mm_min_epu8(operand1, operand2); // emulated "not less than" for 8-bit UNSIGNED integers
+            workReg = _mm_cmpeq_epi8(workReg, operand2);        // emulated "not less than" for 8-bit UNSIGNED integers
+
+            workReg = _mm_and_si128(_mm_set1_epi16(short(0x8080 >> m)), workReg); // merge the last 16 bits with the 128bits std::vector until full
+            result128 = _mm_or_si128(result128, workReg);
+        }
+        (**ptrSSE) = result128;
+        ++(*ptrSSE);
+    }
+    (*ptrSSE) -= 8;
+}
+#endif
+
+template <typename srcMatType, typename iiMatType>
+void FREAK_Impl::computeDescriptors( InputArray _image, std::vector<KeyPoint>& keypoints, OutputArray _descriptors ){
+
+    Mat image = _image.getMat();
+    Mat imgIntegral;
+    integral(image, imgIntegral, DataType<iiMatType>::type);
+    std::vector<int> kpScaleIdx(keypoints.size()); // used to save pattern scale index corresponding to each keypoints
+    const std::vector<int>::iterator ScaleIdxBegin = kpScaleIdx.begin(); // used in std::vector erase function
+    const std::vector<cv::KeyPoint>::iterator kpBegin = keypoints.begin(); // used in std::vector erase function
+    const float sizeCst = static_cast<float>(FREAK::NB_SCALES/(FREAK_LOG2* nOctaves));
+    srcMatType pointsValue[FREAK_NB_POINTS];
+    int thetaIdx = 0;
+    int direction0;
+    int direction1;
+
+    // compute the scale index corresponding to the keypoint size and remove keypoints close to the border
+    if( scaleNormalized )
+    {
+        for( size_t k = keypoints.size(); k--; )
+        {
+            //Is k non-zero? If so, decrement it and continue"
+            kpScaleIdx[k] = std::max( (int)(std::log(keypoints[k].size/FREAK_SMALLEST_KP_SIZE)*sizeCst+0.5) ,0);
+            if( kpScaleIdx[k] >= FREAK::NB_SCALES )
+                kpScaleIdx[k] = FREAK::NB_SCALES-1;
+
+            if( keypoints[k].pt.x <= patternSizes[kpScaleIdx[k]] || //check if the description at this specific position and scale fits inside the image
+                 keypoints[k].pt.y <= patternSizes[kpScaleIdx[k]] ||
+                 keypoints[k].pt.x >= image.cols-patternSizes[kpScaleIdx[k]] ||
+                 keypoints[k].pt.y >= image.rows-patternSizes[kpScaleIdx[k]]
+               )
+            {
+                keypoints.erase(kpBegin+k);
+                kpScaleIdx.erase(ScaleIdxBegin+k);
+            }
+        }
+    }
+    else
+    {
+        const int scIdx = std::max( cvRound(1.0986122886681*sizeCst) ,0);
+        for( size_t k = keypoints.size(); k--; )
+        {
+            kpScaleIdx[k] = scIdx; // equivalent to the formule when the scale is normalized with a constant size of keypoints[k].size=3*SMALLEST_KP_SIZE
+            if( kpScaleIdx[k] >= FREAK::NB_SCALES )
+            {
+                kpScaleIdx[k] = FREAK::NB_SCALES-1;
+            }
+            if( keypoints[k].pt.x <= patternSizes[kpScaleIdx[k]] ||
+                keypoints[k].pt.y <= patternSizes[kpScaleIdx[k]] ||
+                keypoints[k].pt.x >= image.cols-patternSizes[kpScaleIdx[k]] ||
+                keypoints[k].pt.y >= image.rows-patternSizes[kpScaleIdx[k]]
+               )
+            {
+                keypoints.erase(kpBegin+k);
+                kpScaleIdx.erase(ScaleIdxBegin+k);
+            }
+        }
+    }
+
+    // allocate descriptor memory, estimate orientations, extract descriptors
+    if( !extAll )
+    {
+        // extract the best comparisons only
+        _descriptors.create((int)keypoints.size(), FREAK::NB_PAIRS/8, CV_8U);
+        _descriptors.setTo(Scalar::all(0));
+        Mat descriptors = _descriptors.getMat();
+
+        void *ptr = descriptors.data+(keypoints.size()-1)*descriptors.step[0];
+
+        for( size_t k = keypoints.size(); k--; ) {
+            // estimate orientation (gradient)
+            if( !orientationNormalized )
+            {
+                thetaIdx = 0; // assign 0° to all keypoints
+                keypoints[k].angle = 0.0;
+            }
+            else
+            {
+                // get the points intensity value in the un-rotated pattern
+                for( int i = FREAK_NB_POINTS; i--; ) {
+                    pointsValue[i] = meanIntensity<srcMatType, iiMatType>(image, imgIntegral,
+                                                                          keypoints[k].pt.x, keypoints[k].pt.y,
+                                                                          kpScaleIdx[k], 0, i);
+                }
+                direction0 = 0;
+                direction1 = 0;
+                for( int m = 45; m--; )
+                {
+                    //iterate through the orientation pairs
+                    const int delta = (pointsValue[ orientationPairs[m].i ]-pointsValue[ orientationPairs[m].j ]);
+                    direction0 += delta*(orientationPairs[m].weight_dx)/2048;
+                    direction1 += delta*(orientationPairs[m].weight_dy)/2048;
+                }
+
+                keypoints[k].angle = static_cast<float>(atan2((float)direction1,(float)direction0)*(180.0/CV_PI));//estimate orientation
+
+                thetaIdx = cvRound(FREAK_NB_ORIENTATION*keypoints[k].angle*(1/360.0));
+
+                if( thetaIdx < 0 )
+                    thetaIdx += FREAK_NB_ORIENTATION;
+
+                if( thetaIdx >= FREAK_NB_ORIENTATION )
+                    thetaIdx -= FREAK_NB_ORIENTATION;
+            }
+            // extract descriptor at the computed orientation
+            for( int i = FREAK_NB_POINTS; i--; ) {
+                pointsValue[i] = meanIntensity<srcMatType, iiMatType>(image, imgIntegral,
+                                                                      keypoints[k].pt.x, keypoints[k].pt.y,
+                                                                      kpScaleIdx[k], thetaIdx, i);
+            }
+
+            // Extract descriptor
+            extractDescriptor<srcMatType>(pointsValue, &ptr);
+        }
+    }
+    else // extract all possible comparisons for selection
+    {
+        _descriptors.create((int)keypoints.size(), 128, CV_8U);
+        _descriptors.setTo(Scalar::all(0));
+        Mat descriptors = _descriptors.getMat();
+        std::bitset<1024>* ptr = (std::bitset<1024>*) (descriptors.data+(keypoints.size()-1)*descriptors.step[0]);
+
+        for( size_t k = keypoints.size(); k--; )
+        {
+            //estimate orientation (gradient)
+            if( !orientationNormalized )
+            {
+                thetaIdx = 0;//assign 0° to all keypoints
+                keypoints[k].angle = 0.0;
+            }
+            else
+            {
+                //get the points intensity value in the un-rotated pattern
+                for( int i = FREAK_NB_POINTS;i--; )
+                    pointsValue[i] = meanIntensity<srcMatType, iiMatType>(image, imgIntegral,
+                                                                          keypoints[k].pt.x,keypoints[k].pt.y,
+                                                                          kpScaleIdx[k], 0, i);
+
+                direction0 = 0;
+                direction1 = 0;
+                for( int m = 45; m--; )
+                {
+                    //iterate through the orientation pairs
+                    const int delta = (pointsValue[ orientationPairs[m].i ]-pointsValue[ orientationPairs[m].j ]);
+                    direction0 += delta*(orientationPairs[m].weight_dx)/2048;
+                    direction1 += delta*(orientationPairs[m].weight_dy)/2048;
+                }
+
+                keypoints[k].angle = static_cast<float>(atan2((float)direction1,(float)direction0)*(180.0/CV_PI)); //estimate orientation
+
+                thetaIdx = cvRound(FREAK_NB_ORIENTATION*keypoints[k].angle*(1/360.0));
+
+                if( thetaIdx < 0 )
+                    thetaIdx += FREAK_NB_ORIENTATION;
+
+                if( thetaIdx >= FREAK_NB_ORIENTATION )
+                    thetaIdx -= FREAK_NB_ORIENTATION;
+            }
+            // get the points intensity value in the rotated pattern
+            for( int i = FREAK_NB_POINTS; i--; ) {
+                pointsValue[i] = meanIntensity<srcMatType, iiMatType>(image, imgIntegral,
+                                                                      keypoints[k].pt.x, keypoints[k].pt.y,
+                                                                      kpScaleIdx[k], thetaIdx, i);
+            }
+
+            int cnt(0);
+            for( int i = 1; i < FREAK_NB_POINTS; ++i )
+            {
+                //(generate all the pairs)
+                for( int j = 0; j < i; ++j )
+                {
+                    ptr->set(cnt, pointsValue[i] >= pointsValue[j] );
+                    ++cnt;
+                }
+            }
+            --ptr;
+        }
+    }
+}
+
+// simply take average on a square patch, not even gaussian approx
+template <typename imgType, typename iiType>
+imgType FREAK_Impl::meanIntensity( InputArray _image, InputArray _integral,
+                              const float kp_x,
+                              const float kp_y,
+                              const unsigned int scale,
+                              const unsigned int rot,
+                              const unsigned int point)
+{
+    Mat image = _image.getMat(), integral = _integral.getMat();
+    // get point position in image
+    const PatternPoint& FreakPoint = patternLookup[scale*FREAK_NB_ORIENTATION*FREAK_NB_POINTS + rot*FREAK_NB_POINTS + point];
+    const float xf = FreakPoint.x+kp_x;
+    const float yf = FreakPoint.y+kp_y;
+    const int x = int(xf);
+    const int y = int(yf);
+
+    // get the sigma:
+    const float radius = FreakPoint.sigma;
+
+    // calculate output:
+    if( radius < 0.5 )
+    {
+        // interpolation multipliers:
+        const int r_x = static_cast<int>((xf-x)*1024);
+        const int r_y = static_cast<int>((yf-y)*1024);
+        const int r_x_1 = (1024-r_x);
+        const int r_y_1 = (1024-r_y);
+        unsigned int ret_val;
+        // linear interpolation:
+        ret_val = r_x_1*r_y_1*int(image.at<imgType>(y  , x  ))
+                + r_x  *r_y_1*int(image.at<imgType>(y  , x+1))
+                + r_x_1*r_y  *int(image.at<imgType>(y+1, x  ))
+                + r_x  *r_y  *int(image.at<imgType>(y+1, x+1));
+        //return the rounded mean
+        ret_val += 2 * 1024 * 1024;
+        return static_cast<imgType>(ret_val / (4 * 1024 * 1024));
+    }
+
+    // expected case:
+
+    // calculate borders
+    const int x_left = cvRound(xf-radius);
+    const int y_top = cvRound(yf-radius);
+    const int x_right = cvRound(xf+radius+1);//integral image is 1px wider
+    const int y_bottom = cvRound(yf+radius+1);//integral image is 1px higher
+    iiType ret_val;
+
+    ret_val = integral.at<iiType>(y_bottom,x_right);//bottom right corner
+    ret_val -= integral.at<iiType>(y_bottom,x_left);
+    ret_val += integral.at<iiType>(y_top,x_left);
+    ret_val -= integral.at<iiType>(y_top,x_right);
+    const int area = (x_right - x_left) * (y_bottom - y_top);
+    ret_val = (ret_val + area/2) / area;
+    //~ std::cout<<integral.step[1]<<std::endl;
+    return static_cast<imgType>(ret_val);
+}
+
+// pair selection algorithm from a set of training images and corresponding keypoints
+std::vector<int> FREAK_Impl::selectPairs(const std::vector<Mat>& images
+                                        , std::vector<std::vector<KeyPoint> >& keypoints
+                                        , const double corrTresh
+                                        , bool verbose )
+{
+    extAll = true;
+    // compute descriptors with all pairs
+    Mat descriptors;
+
+    if( verbose )
+        std::cout << "Number of images: " << images.size() << std::endl;
+
+    for( size_t i = 0;i < images.size(); ++i )
+    {
+        Mat descriptorsTmp;
+        compute(images[i],keypoints[i],descriptorsTmp);
+        descriptors.push_back(descriptorsTmp);
+    }
+
+    if( verbose )
+        std::cout << "number of keypoints: " << descriptors.rows << std::endl;
+
+    //descriptor in floating point format (each bit is a float)
+    Mat descriptorsFloat = Mat::zeros(descriptors.rows, 903, CV_32F);
+
+    std::bitset<1024>* ptr = (std::bitset<1024>*) (descriptors.data+(descriptors.rows-1)*descriptors.step[0]);
+    for( int m = descriptors.rows; m--; )
+    {
+        for( int n = 903; n--; )
+        {
+            if( ptr->test(n) == true )
+                descriptorsFloat.at<float>(m,n)=1.0f;
+        }
+        --ptr;
+    }
+
+    std::vector<PairStat> pairStat;
+    for( int n = 903; n--; )
+    {
+        // the higher the variance, the better --> mean = 0.5
+        PairStat tmp = { fabs( mean(descriptorsFloat.col(n))[0]-0.5 ) ,n};
+        pairStat.push_back(tmp);
+    }
+
+    std::sort( pairStat.begin(),pairStat.end(), sortMean() );
+
+    std::vector<PairStat> bestPairs;
+    for( int m = 0; m < 903; ++m )
+    {
+        if( verbose )
+            std::cout << m << ":" << bestPairs.size() << " " << std::flush;
+        double corrMax(0);
+
+        for( size_t n = 0; n < bestPairs.size(); ++n )
+        {
+            int idxA = bestPairs[n].idx;
+            int idxB = pairStat[m].idx;
+            double corr(0);
+            // compute correlation between 2 pairs
+            corr = fabs(compareHist(descriptorsFloat.col(idxA), descriptorsFloat.col(idxB), HISTCMP_CORREL));
+
+            if( corr > corrMax )
+            {
+                corrMax = corr;
+                if( corrMax >= corrTresh )
+                    break;
+            }
+        }
+
+        if( corrMax < corrTresh/*0.7*/ )
+            bestPairs.push_back(pairStat[m]);
+
+        if( bestPairs.size() >= 512 )
+        {
+            if( verbose )
+                std::cout << m << std::endl;
+            break;
+        }
+    }
+
+    std::vector<int> idxBestPairs;
+    if( (int)bestPairs.size() >= FREAK::NB_PAIRS )
+    {
+        for( int i = 0; i < FREAK::NB_PAIRS; ++i )
+            idxBestPairs.push_back(bestPairs[i].idx);
+    }
+    else
+    {
+        if( verbose )
+            std::cout << "correlation threshold too small (restrictive)" << std::endl;
+        CV_Error(Error::StsError, "correlation threshold too small (restrictive)");
+    }
+    extAll = false;
+    return idxBestPairs;
+}
+
+
+/*
+// create an image showing the brisk pattern
+void FREAKImpl::drawPattern()
+{
+    Mat pattern = Mat::zeros(1000, 1000, CV_8UC3) + Scalar(255,255,255);
+    int sFac = 500 / patternScale;
+    for( int n = 0; n < kNB_POINTS; ++n )
+    {
+        PatternPoint& pt = patternLookup[n];
+        circle(pattern, Point( pt.x*sFac,pt.y*sFac)+Point(500,500), pt.sigma*sFac, Scalar(0,0,255),2);
+        // rectangle(pattern, Point( (pt.x-pt.sigma)*sFac,(pt.y-pt.sigma)*sFac)+Point(500,500), Point( (pt.x+pt.sigma)*sFac,(pt.y+pt.sigma)*sFac)+Point(500,500), Scalar(0,0,255),2);
+
+        circle(pattern, Point( pt.x*sFac,pt.y*sFac)+Point(500,500), 1, Scalar(0,0,0),3);
+        std::ostringstream oss;
+        oss << n;
+        putText( pattern, oss.str(), Point( pt.x*sFac,pt.y*sFac)+Point(500,500), FONT_HERSHEY_SIMPLEX,0.5, Scalar(0,0,0), 1);
+    }
+    imshow( "FreakDescriptorExtractor pattern", pattern );
+    waitKey(0);
+}
+*/
+
+// -------------------------------------------------
+/* FREAK interface implementation */
+FREAK_Impl::FREAK_Impl( bool _orientationNormalized, bool _scaleNormalized
+            , float _patternScale, int _nOctaves, const std::vector<int>& _selectedPairs )
+    : orientationNormalized(_orientationNormalized), scaleNormalized(_scaleNormalized),
+    patternScale(_patternScale), nOctaves(_nOctaves), extAll(false),
+    patternScale0(0.0), nOctaves0(0), selectedPairs0(_selectedPairs)
+{
+}
+
+FREAK_Impl::~FREAK_Impl()
+{
+}
+
+void FREAK_Impl::read( const FileNode& fn)
+{
+  // if node is empty, keep previous value
+  if (!fn["orientationNormalized"].empty())
+    fn["orientationNormalized"] >> orientationNormalized;
+  if (!fn["scaleNormalized"].empty())
+    fn["scaleNormalized"] >> scaleNormalized;
+  if (!fn["patternScale"].empty())
+    fn["patternScale"] >> patternScale;
+  if (!fn["nOctaves"].empty())
+    fn["nOctaves"] >> nOctaves;
+}
+void FREAK_Impl::write( FileStorage& fs) const
+{
+  if(fs.isOpened())
+  {
+    fs << "name" << getDefaultName();
+    fs << "orientationNormalized" << orientationNormalized;
+    fs << "scaleNormalized" << scaleNormalized;
+    fs << "patternScale" << patternScale;
+    fs << "nOctaves" << nOctaves;
+  }
+}
+
+int FREAK_Impl::descriptorSize() const
+{
+    return FREAK::NB_PAIRS / 8; // descriptor length in bytes
+}
+
+int FREAK_Impl::descriptorType() const
+{
+    return CV_8U;
+}
+
+int FREAK_Impl::defaultNorm() const
+{
+    return NORM_HAMMING;
+}
+
+Ptr<FREAK> FREAK::create(bool orientationNormalized,
+                         bool scaleNormalized,
+                         float patternScale,
+                         int nOctaves,
+                         const std::vector<int>& selectedPairs)
+{
+    return makePtr<FREAK_Impl>(orientationNormalized, scaleNormalized,
+                               patternScale, nOctaves, selectedPairs);
+}
+
+String FREAK::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".FREAK");
+}
+
+}
+} // END NAMESPACE CV
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/gms.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/gms.cpp
new file mode 100644
index 00000000..c13ffe47
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/gms.cpp
@@ -0,0 +1,460 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+/*********************************************************************
+* This is the implementation of the paper
+*    GMS: Grid-based Motion Statistics for Fast, Ultra-robust Feature Correspondence.
+*    JiaWang Bian, Wen-Yan Lin, Yasuyuki Matsushita, Sai-Kit Yeung, Tan Dat Nguyen, Ming-Ming Cheng
+*    IEEE CVPR, 2017
+*    ProjectPage: http://jwbian.net/gms
+*********************************************************************/
+
+#include "precomp.hpp"
+#include <algorithm>
+
+using namespace std;
+
+namespace cv
+{
+namespace xfeatures2d
+{
+// 8 possible rotation and each one is 3 X 3
+const int mRotationPatterns[8][9] = {
+    {
+        1,2,3,
+        4,5,6,
+        7,8,9
+    },
+    {
+        4,1,2,
+        7,5,3,
+        8,9,6
+    },
+    {
+        7,4,1,
+        8,5,2,
+        9,6,3
+    },
+    {
+        8,7,4,
+        9,5,1,
+        6,3,2
+    },
+    {
+        9,8,7,
+        6,5,4,
+        3,2,1
+    },
+    {
+        6,9,8,
+        3,5,7,
+        2,1,4
+    },
+    {
+        3,6,9,
+        2,5,8,
+        1,4,7
+    },
+    {
+        2,3,6,
+        1,5,9,
+        4,7,8
+    }
+};
+
+// 5 level scales
+const double mScaleRatios[5] = { 1.0, 1.0 / 2, 1.0 / std::sqrt(2.0), std::sqrt(2.0), 2.0 };
+
+class GMSMatcher
+{
+public:
+    // OpenCV Keypoints & Correspond Image Size & Nearest Neighbor Matches
+    GMSMatcher(const vector<KeyPoint>& vkp1, const Size& size1, const vector<KeyPoint>& vkp2, const Size& size2,
+               const vector<DMatch>& vDMatches, const double thresholdFactor) : mThresholdFactor(thresholdFactor)
+    {
+        // Input initialize
+        normalizePoints(vkp1, size1, mvP1);
+        normalizePoints(vkp2, size2, mvP2);
+        mNumberMatches = vDMatches.size();
+        convertMatches(vDMatches, mvMatches);
+
+        // Grid initialize
+        mGridSizeLeft = Size(20, 20);
+        mGridNumberLeft = mGridSizeLeft.width * mGridSizeLeft.height;
+
+        // Initialize the neighbor of left grid
+        mGridNeighborLeft = Mat::zeros(mGridNumberLeft, 9, CV_32SC1);
+        initalizeNeighbors(mGridNeighborLeft, mGridSizeLeft);
+    }
+
+    ~GMSMatcher() {}
+
+    // Get Inlier Mask
+    // Return number of inliers
+    int getInlierMask(vector<bool> &vbInliers, const bool withRotation = false, const bool withScale = false);
+
+
+private:
+    // Normalized Points
+    vector<Point2f> mvP1, mvP2;
+
+    // Matches
+    vector<pair<int, int> > mvMatches;
+
+    // Number of Matches
+    size_t mNumberMatches;
+
+    // Grid Size
+    Size mGridSizeLeft, mGridSizeRight;
+    int mGridNumberLeft;
+    int mGridNumberRight;
+
+    // x      : left grid idx
+    // y      : right grid idx
+    // value  : how many matches from idx_left to idx_right
+    Mat mMotionStatistics;
+
+    //
+    vector<int> mNumberPointsInPerCellLeft;
+
+    // Inldex  : grid_idx_left
+    // Value   : grid_idx_right
+    vector<int> mCellPairs;
+
+    // Every Matches has a cell-pair
+    // first  : grid_idx_left
+    // second : grid_idx_right
+    vector<pair<int, int> > mvMatchPairs;
+
+    // Inlier Mask for output
+    vector<bool> mvbInlierMask;
+
+    //
+    Mat mGridNeighborLeft;
+    Mat mGridNeighborRight;
+
+    double mThresholdFactor;
+
+
+    // Assign Matches to Cell Pairs
+    void assignMatchPairs(const int GridType);
+
+    void convertMatches(const vector<DMatch> &vDMatches, vector<pair<int, int> > &vMatches);
+
+    int getGridIndexLeft(const Point2f &pt, const int type);
+
+    int getGridIndexRight(const Point2f &pt);
+
+    vector<int> getNB9(const int idx, const Size& GridSize);
+
+    void initalizeNeighbors(Mat &neighbor, const Size& GridSize);
+
+    void normalizePoints(const vector<KeyPoint> &kp, const Size &size, vector<Point2f> &npts);
+
+    // Run
+    int run(const int rotationType);
+
+    void setScale(const int scale);
+
+    // Verify Cell Pairs
+    void verifyCellPairs(const int rotationType);
+};
+
+void GMSMatcher::assignMatchPairs(const int gridType)
+{
+    for (size_t i = 0; i < mNumberMatches; i++)
+    {
+        Point2f &lp = mvP1[mvMatches[i].first];
+        Point2f &rp = mvP2[mvMatches[i].second];
+
+        int lgidx = mvMatchPairs[i].first = getGridIndexLeft(lp, gridType);
+        int rgidx = -1;
+
+        if (gridType == 1)
+        {
+            rgidx = mvMatchPairs[i].second = getGridIndexRight(rp);
+        }
+        else
+        {
+            rgidx = mvMatchPairs[i].second;
+        }
+
+        if (lgidx < 0 || rgidx < 0) continue;
+
+        mMotionStatistics.at<int>(lgidx, rgidx)++;
+        mNumberPointsInPerCellLeft[lgidx]++;
+    }
+}
+
+// Convert OpenCV DMatch to Match (pair<int, int>)
+void GMSMatcher::convertMatches(const vector<DMatch> &vDMatches, vector<pair<int, int> > &vMatches)
+{
+    vMatches.resize(mNumberMatches);
+    for (size_t i = 0; i < mNumberMatches; i++)
+        vMatches[i] = pair<int, int>(vDMatches[i].queryIdx, vDMatches[i].trainIdx);
+}
+
+int GMSMatcher::getGridIndexLeft(const Point2f &pt, const int type)
+{
+    int x = 0, y = 0;
+
+    if (type == 1) {
+        x = cvFloor(pt.x * mGridSizeLeft.width);
+        y = cvFloor(pt.y * mGridSizeLeft.height);
+    }
+
+    if (type == 2) {
+        x = cvFloor(pt.x * mGridSizeLeft.width + 0.5);
+        y = cvFloor(pt.y * mGridSizeLeft.height);
+    }
+
+    if (type == 3) {
+        x = cvFloor(pt.x * mGridSizeLeft.width);
+        y = cvFloor(pt.y * mGridSizeLeft.height + 0.5);
+    }
+
+    if (type == 4) {
+        x = cvFloor(pt.x * mGridSizeLeft.width + 0.5);
+        y = cvFloor(pt.y * mGridSizeLeft.height + 0.5);
+    }
+
+
+    if (x >= mGridSizeLeft.width || y >= mGridSizeLeft.height)
+        return -1;
+
+    return x + y * mGridSizeLeft.width;
+}
+
+int GMSMatcher::getGridIndexRight(const Point2f &pt)
+{
+    int x = cvFloor(pt.x * mGridSizeRight.width);
+    int y = cvFloor(pt.y * mGridSizeRight.height);
+
+    return x + y * mGridSizeRight.width;
+}
+
+int GMSMatcher::getInlierMask(vector<bool> &vbInliers, const bool withRotation, const bool withScale)
+{
+    int max_inlier = 0;
+
+    if (!withScale && !withRotation)
+    {
+        setScale(0);
+        max_inlier = run(1);
+        vbInliers = mvbInlierMask;
+        return max_inlier;
+    }
+
+    if (withRotation && withScale)
+    {
+        for (int scale = 0; scale < 5; scale++)
+        {
+            setScale(scale);
+            for (int rotationType = 1; rotationType <= 8; rotationType++)
+            {
+                int num_inlier = run(rotationType);
+
+                if (num_inlier > max_inlier)
+                {
+                    vbInliers = mvbInlierMask;
+                    max_inlier = num_inlier;
+                }
+            }
+        }
+        return max_inlier;
+    }
+
+    if (withRotation && !withScale)
+    {
+        setScale(0);
+        for (int rotationType = 1; rotationType <= 8; rotationType++)
+        {
+            int num_inlier = run(rotationType);
+
+            if (num_inlier > max_inlier)
+            {
+                vbInliers = mvbInlierMask;
+                max_inlier = num_inlier;
+            }
+        }
+        return max_inlier;
+    }
+
+    if (!withRotation && withScale)
+    {
+        for (int scale = 0; scale < 5; scale++)
+        {
+            setScale(scale);
+            int num_inlier = run(1);
+
+            if (num_inlier > max_inlier)
+            {
+                vbInliers = mvbInlierMask;
+                max_inlier = num_inlier;
+            }
+
+        }
+        return max_inlier;
+    }
+
+    return max_inlier;
+}
+
+// Get Neighbor 9
+vector<int> GMSMatcher::getNB9(const int idx, const Size& gridSize)
+{
+    vector<int> NB9(9, -1);
+
+    int idx_x = idx % gridSize.width;
+    int idx_y = idx / gridSize.width;
+
+    for (int yi = -1; yi <= 1; yi++)
+    {
+        for (int xi = -1; xi <= 1; xi++)
+        {
+            int idx_xx = idx_x + xi;
+            int idx_yy = idx_y + yi;
+
+            if (idx_xx < 0 || idx_xx >= gridSize.width || idx_yy < 0 || idx_yy >= gridSize.height)
+                continue;
+
+            NB9[xi + 4 + yi * 3] = idx_xx + idx_yy * gridSize.width;
+        }
+    }
+    return NB9;
+}
+
+void GMSMatcher::initalizeNeighbors(Mat &neighbor, const Size& gridSize)
+{
+    for (int i = 0; i < neighbor.rows; i++)
+    {
+        vector<int> NB9 = getNB9(i, gridSize);
+        int *data = neighbor.ptr<int>(i);
+        memcpy(data, &NB9[0], sizeof(int) * 9);
+    }
+}
+
+// Normalize Key Points to Range(0 - 1)
+void GMSMatcher::normalizePoints(const vector<KeyPoint> &kp, const Size &size, vector<Point2f> &npts)
+{
+    const size_t numP = kp.size();
+    const int width   = size.width;
+    const int height  = size.height;
+    npts.resize(numP);
+
+    for (size_t i = 0; i < numP; i++)
+    {
+        npts[i].x = kp[i].pt.x / width;
+        npts[i].y = kp[i].pt.y / height;
+    }
+}
+
+int GMSMatcher::run(const int rotationType)
+{
+    mvbInlierMask.assign(mNumberMatches, false);
+
+    // Initialize Motion Statisctics
+    mMotionStatistics = Mat::zeros(mGridNumberLeft, mGridNumberRight, CV_32SC1);
+    mvMatchPairs.assign(mNumberMatches, pair<int, int>(0, 0));
+
+    for (int gridType = 1; gridType <= 4; gridType++)
+    {
+        // initialize
+        mMotionStatistics.setTo(0);
+        mCellPairs.assign(mGridNumberLeft, -1);
+        mNumberPointsInPerCellLeft.assign(mGridNumberLeft, 0);
+
+        assignMatchPairs(gridType);
+        verifyCellPairs(rotationType);
+
+        // Mark inliers
+        for (size_t i = 0; i < mNumberMatches; i++)
+        {
+            if (mvMatchPairs[i].first >= 0 && mCellPairs[mvMatchPairs[i].first] == mvMatchPairs[i].second)
+                mvbInlierMask[i] = true;
+        }
+    }
+
+    return (int) count(mvbInlierMask.begin(), mvbInlierMask.end(), true); //number of inliers
+}
+
+void GMSMatcher::setScale(const int scale)
+{
+    // Set Scale
+    mGridSizeRight.width = cvRound(mGridSizeLeft.width  * mScaleRatios[scale]);
+    mGridSizeRight.height = cvRound(mGridSizeLeft.height * mScaleRatios[scale]);
+    mGridNumberRight = mGridSizeRight.width * mGridSizeRight.height;
+
+    // Initialize the neighbor of right grid
+    mGridNeighborRight = Mat::zeros(mGridNumberRight, 9, CV_32SC1);
+    initalizeNeighbors(mGridNeighborRight, mGridSizeRight);
+}
+
+void GMSMatcher::verifyCellPairs(const int rotationType)
+{
+    const int *CurrentRP = mRotationPatterns[rotationType - 1];
+
+    for (int i = 0; i < mGridNumberLeft; i++)
+    {
+        if (sum(mMotionStatistics.row(i))[0] == 0)
+        {
+            mCellPairs[i] = -1;
+            continue;
+        }
+
+        int max_number = 0;
+        for (int j = 0; j < mGridNumberRight; j++)
+        {
+            int *value = mMotionStatistics.ptr<int>(i);
+            if (value[j] > max_number)
+            {
+                mCellPairs[i] = j;
+                max_number = value[j];
+            }
+        }
+
+        int idx_grid_rt = mCellPairs[i];
+
+        const int *NB9_lt = mGridNeighborLeft.ptr<int>(i);
+        const int *NB9_rt = mGridNeighborRight.ptr<int>(idx_grid_rt);
+
+        int score = 0;
+        double thresh = 0;
+        int numpair = 0;
+
+        for (size_t j = 0; j < 9; j++)
+        {
+            int ll = NB9_lt[j];
+            int rr = NB9_rt[CurrentRP[j] - 1];
+            if (ll == -1 || rr == -1)
+                continue;
+
+            score += mMotionStatistics.at<int>(ll, rr);
+            thresh += mNumberPointsInPerCellLeft[ll];
+            numpair++;
+        }
+
+        thresh = mThresholdFactor * std::sqrt(thresh / numpair);
+
+        if (score < thresh)
+            mCellPairs[i] = -2;
+    }
+}
+
+void matchGMS( const Size& size1, const Size& size2, const vector<KeyPoint>& keypoints1, const vector<KeyPoint>& keypoints2,
+               const vector<DMatch>& matches1to2, vector<DMatch>& matchesGMS, const bool withRotation, const bool withScale,
+               const double thresholdFactor )
+{
+    GMSMatcher gms(keypoints1, size1, keypoints2, size2, matches1to2, thresholdFactor);
+    vector<bool> inlierMask;
+    gms.getInlierMask(inlierMask, withRotation, withScale);
+
+    matchesGMS.clear();
+    for (size_t i = 0; i < inlierMask.size(); i++) {
+        if (inlierMask[i])
+            matchesGMS.push_back(matches1to2[i]);
+    }
+}
+
+} //namespace xfeatures2d
+} //namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/harris_lapace_detector.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/harris_lapace_detector.cpp
new file mode 100644
index 00000000..1e9dc7c3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/harris_lapace_detector.cpp
@@ -0,0 +1,599 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+
+namespace {
+
+using namespace cv;
+
+bool sort_func(KeyPoint kp1, KeyPoint kp2)
+{
+    return (kp1.response > kp2.response);
+}
+
+class Pyramid
+{
+
+protected:
+    class Octave
+    {
+    public:
+        std::vector<Mat> layers;
+        Octave(std::vector<Mat> layers);
+        virtual ~Octave();
+        Mat getLayerAt(int i);
+    };
+
+    class DOGOctave
+    {
+    public:
+        std::vector<Mat> layers;
+
+        DOGOctave(std::vector<Mat> layers);
+        virtual ~DOGOctave();
+        Mat getLayerAt(int i);
+    };
+
+private:
+    std::vector<Octave> octaves;
+    std::vector<DOGOctave> DOG_octaves;
+    void build(const Mat& img, bool DOG);
+public:
+    class Params
+    {
+    public:
+        int octavesN;
+        int layersN;
+        float sigma0;
+        int omin;
+        float step;
+        Params(int octavesN, int layersN, float sigma0, int omin);
+        void clear();
+    };
+    Params params;
+
+    Pyramid(const Mat& img, int octavesN, int layersN = 2, float sigma0 = 1, int omin = 0,
+            bool DOG = false);
+    Mat getLayer(int octave, int layer);
+    Mat getDOGLayer(int octave, int layer);
+    float getSigma(int layer);
+
+    virtual ~Pyramid();
+    void clear();
+};
+
+/**
+ * Pyramid class constructor
+ * octavesN_: number of octaves
+ * layersN_: number of layers before subsampling layer
+ * sigma0_: starting sigma (depends on detector's type, i.e. SIFT sigma0 = 1.6, Harris sigma0 = 1)
+ * omin_: if omin<0 an octave is added before first octave. In this octave the image size is doubled
+ * _DOG: if true, a DOG pyramid is build
+ */
+Pyramid::Pyramid(const Mat & img, int octavesN_, int layersN_, float sigma0_, int omin_, bool _DOG) :
+    params(
+        //Need to set the octavesN parameter globally. See issue #1513
+        MIN(octavesN_, int(floor(log((double)MIN(img.size().width, img.size().height)) / log(2.0f)))),
+        layersN_,
+        sigma0_,
+        omin_
+    )
+{
+    build(img, _DOG);
+}
+
+/**
+ * Build gaussian pyramid with layersN_ + 3 layers and 2^(1/layersN_) step between layers
+ * each octave is downsampled of a factor of 2
+ */
+
+void Pyramid::build(const Mat& img, bool DOG)
+{
+
+    Size ksize(0, 0);
+    int gsize;
+
+    float sigma0 = params.sigma0;
+    float sigma = sigma0;
+    int layersN = params.layersN + 3;
+    int omin = params.omin;
+    float k = params.step;
+
+    /*layer to downsample*/
+    int down_lay = int(1 / log(k));
+
+    int octave, layer;
+    double sigmaN = 0.5;
+
+    std::vector<Mat> layers, DOG_layers;
+    /* standard deviation of current layer*/
+    float sigma_curr = sigma;
+    /* standard deviation of previous layer*/
+    float sigma_prev = sigma;
+
+    if (omin < 0)
+    {
+        omin = -1;
+        Mat tmp_img;
+        Mat blurred_img;
+        gsize = int(ceil(sigmaN * 3)) * 2 + 1;
+        GaussianBlur(img, blurred_img, Size(gsize,gsize), sigmaN);
+        resize(blurred_img, tmp_img, ksize, 2, 2, INTER_AREA);
+        layers.push_back(tmp_img);
+
+        for (layer = 1; layer < layersN; layer++)
+        {
+            sigma_curr = getSigma(layer);
+            sigma = sqrt(powf(sigma_curr, 2) - powf(sigma_prev, 2));
+            Mat prev_lay = layers[layer - 1], curr_lay, DOG_lay;
+            /* smoothing is applied on previous layer so sigma_curr^2 = sigma^2 + sigma_prev^2 */
+            gsize = int(ceil(sigma * 3)) * 2 + 1;
+            GaussianBlur(prev_lay, curr_lay, Size(gsize,gsize), sigma);
+            layers.push_back(curr_lay);
+            if (DOG)
+            {
+                absdiff(curr_lay, prev_lay, DOG_lay);
+                DOG_layers.push_back(DOG_lay);
+            }
+            sigma_prev = sigma_curr;
+
+        }
+        Octave tmp_oct(layers);
+        octaves.push_back(tmp_oct);
+        layers.clear();
+
+        if (DOG)
+        {
+            DOGOctave tmp_DOG_Oct(DOG_layers);
+            DOG_octaves.push_back(tmp_DOG_Oct);
+            DOG_layers.clear();
+        }
+
+    }
+
+    /* Presmoothing on first layer */
+    float sb = float(sigmaN) / powf(2.0f, (float) omin);
+    sigma = sigma0;
+    if (sigma0 > sb)
+        sigma = sqrt(sigma0 * sigma0 - sb * sb);
+
+    /*1° step on image*/
+    Mat tmpImg;
+    gsize = int(ceil(sigma * 3)) * 2 + 1;
+    GaussianBlur(img, tmpImg, Size(gsize,gsize), sigma);
+    layers.push_back(tmpImg);
+
+    /*for every octave build layers*/
+    sigma_prev = sigma;
+
+    for (octave = 0; octave < params.octavesN; octave++)
+    {
+        for (layer = 1; layer < layersN; layer++)
+        {
+            sigma_curr = getSigma(layer);
+            sigma = sqrt(powf(sigma_curr, 2) - powf(sigma_prev, 2));
+
+            Mat prev_lay = layers[layer - 1], curr_lay, DOG_lay;
+            gsize = int(ceil(sigma * 3)) * 2 + 1;
+            GaussianBlur(prev_lay, curr_lay, Size(gsize,gsize), sigma);
+            layers.push_back(curr_lay);
+
+            if (DOG)
+            {
+                absdiff(curr_lay, prev_lay, DOG_lay);
+                DOG_layers.push_back(DOG_lay);
+            }
+            sigma_prev = sigma_curr;
+        }
+
+        Mat resized_lay;
+        resize(layers[down_lay], resized_lay, ksize, 1.0f / 2, 1.0f / 2, INTER_AREA);
+
+        Octave tmp_oct(layers);
+        octaves.push_back(tmp_oct);
+        if (DOG)
+        {
+            DOGOctave tmp_DOG_Oct(DOG_layers);
+            DOG_octaves.push_back(tmp_DOG_Oct);
+            DOG_layers.clear();
+        }
+        sigma_curr = sigma_prev = sigma0;
+        layers.clear();
+        layers.push_back(resized_lay);
+
+    }
+
+}
+
+/**
+ * Return layer at indicated octave and layer numbers
+ */
+Mat Pyramid::getLayer(int octave, int layer)
+{
+    return octaves[octave].getLayerAt(layer);
+}
+
+/**
+ * Return DOG layer at indicated octave and layer numbers
+ */
+Mat Pyramid::getDOGLayer(int octave, int layer)
+{
+    CV_Assert(!DOG_octaves.empty());
+    return DOG_octaves[octave].getLayerAt(layer);
+}
+
+/**
+ * Return sigma value of indicated layer
+ * sigma value of layer is the same at each octave
+ * i.e. sigma of first layer at each octave is sigma0
+ */
+float Pyramid::getSigma(int layer)
+{
+
+    return powf(params.step, float(layer)) * params.sigma0;
+}
+
+/**
+ * Destructor of Pyramid class
+ */
+Pyramid::~Pyramid()
+{
+    clear();
+}
+
+/**
+ * Clear octaves and params
+ */
+void Pyramid::clear()
+{
+    octaves.clear();
+    params.clear();
+}
+
+/**
+ * Params for Pyramid class
+ *
+ */
+Pyramid::Params::Params(int octavesN_, int layersN_, float sigma0_, int omin_) :
+    octavesN(octavesN_), layersN(layersN_), sigma0(sigma0_), omin(omin_)
+{
+    CV_Assert(layersN > 0 && octavesN_>0);
+    step = powf(2, 1.0f / layersN);
+}
+
+/**
+ * Set to zero all params
+ */
+void Pyramid::Params::clear()
+{
+    octavesN = 0;
+    layersN = 0;
+    sigma0 = 0;
+    omin = 0;
+    step = 0;
+}
+
+/**
+ * Create an Octave with layers
+ */
+Pyramid::Octave::Octave(std::vector<Mat> _layers) : layers(_layers) {}
+
+/**
+ * Return the Octave's layer at index i
+ */
+Mat Pyramid::Octave::getLayerAt(int i)
+{
+    CV_Assert(i < (int) layers.size());
+    return layers[i];
+}
+
+Pyramid::Octave::~Octave()
+{
+}
+
+Pyramid::DOGOctave::DOGOctave(std::vector<Mat> _layers) : layers(_layers) {}
+
+Pyramid::DOGOctave::~DOGOctave()
+{
+}
+
+Mat Pyramid::DOGOctave::getLayerAt(int i)
+{
+    CV_Assert(i < (int) layers.size());
+    return layers[i];
+}
+
+} // anonymous namespace
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+/*
+ *  HarrisLaplaceFeatureDetector_Impl
+ */
+class HarrisLaplaceFeatureDetector_Impl CV_FINAL : public HarrisLaplaceFeatureDetector
+{
+public:
+    HarrisLaplaceFeatureDetector_Impl(
+        int numOctaves=6,
+        float corn_thresh=0.01,
+        float DOG_thresh=0.01,
+        int maxCorners=5000,
+        int num_layers=4
+    );
+    void read( const FileNode& fn ) CV_OVERRIDE;
+    void write( FileStorage& fs ) const CV_OVERRIDE;
+
+    void setNumOctaves(int numOctaves_) CV_OVERRIDE {numOctaves = numOctaves_;}
+    int getNumOctaves() const CV_OVERRIDE {return numOctaves;}
+
+    void setCornThresh(float corn_thresh_) CV_OVERRIDE {corn_thresh = corn_thresh_;}
+    float getCornThresh() const CV_OVERRIDE {return corn_thresh;}
+
+    void setDOGThresh(float DOG_thresh_) CV_OVERRIDE {DOG_thresh = DOG_thresh_;}
+    float getDOGThresh() const CV_OVERRIDE {return DOG_thresh;}
+
+    void setMaxCorners(int maxCorners_) CV_OVERRIDE {maxCorners = maxCorners_;}
+    int getMaxCorners() const CV_OVERRIDE {return maxCorners;}
+
+    void setNumLayers(int num_layers_) CV_OVERRIDE {num_layers = num_layers_; CV_Assert(num_layers == 2 || num_layers==4);}
+    int getNumLayers() const CV_OVERRIDE {return num_layers;}
+
+protected:
+    void detect( InputArray image, std::vector<KeyPoint>& keypoints, InputArray mask=noArray() ) CV_OVERRIDE;
+
+    int numOctaves;
+    float corn_thresh;
+    float DOG_thresh;
+    int maxCorners;
+    int num_layers;
+};
+
+Ptr<HarrisLaplaceFeatureDetector> HarrisLaplaceFeatureDetector::create(
+    int numOctaves,
+    float corn_thresh,
+    float DOG_thresh,
+    int maxCorners,
+    int num_layers)
+{
+    return makePtr<HarrisLaplaceFeatureDetector_Impl>(numOctaves, corn_thresh, DOG_thresh, maxCorners, num_layers);
+}
+
+CV_WRAP String HarrisLaplaceFeatureDetector::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".HARRIS-LAPLACE");
+}
+
+HarrisLaplaceFeatureDetector_Impl::HarrisLaplaceFeatureDetector_Impl(
+    int _numOctaves,
+    float _corn_thresh,
+    float _DOG_thresh,
+    int _maxCorners,
+    int _num_layers
+) :
+    numOctaves(_numOctaves),
+    corn_thresh(_corn_thresh),
+    DOG_thresh(_DOG_thresh),
+    maxCorners(_maxCorners),
+    num_layers(_num_layers)
+{
+    CV_Assert(num_layers == 2 || num_layers==4);
+}
+
+void HarrisLaplaceFeatureDetector_Impl::read (const FileNode& fn)
+{
+    // if node is empty, keep previous value
+    if (!fn["numOctaves"].empty())
+        fn["numOctaves"] >> numOctaves;
+    if (!fn["corn_thresh"].empty())
+        fn["corn_thresh"] >> corn_thresh;
+    if (!fn["corn_thresh"].empty())
+        fn["DOG_thresh"] >> DOG_thresh;
+    if (!fn["maxCorners"].empty())
+        fn["maxCorners"] >> maxCorners;
+    if (!fn["num_layers"].empty())
+        fn["num_layers"] >> num_layers;
+}
+
+void HarrisLaplaceFeatureDetector_Impl::write (FileStorage& fs) const
+{
+    if ( fs.isOpened() )
+    {
+        fs << "name" << getDefaultName();
+        fs << "numOctaves" << numOctaves;
+        fs << "corn_thresh" << corn_thresh;
+        fs << "DOG_thresh" << DOG_thresh;
+        fs << "maxCorners" << maxCorners;
+        fs << "num_layers" << num_layers;
+    }
+}
+
+/*
+ * Detect method
+ * The method detect Harris corners on scale space as described in
+ * "K. Mikolajczyk and C. Schmid.
+ * Scale & affine invariant interest point detectors.
+ * International Journal of Computer Vision, 2004"
+ */
+void HarrisLaplaceFeatureDetector_Impl::detect(InputArray img, std::vector<KeyPoint>& keypoints, InputArray msk )
+{
+    Mat image = img.getMat();
+    if( image.empty() )
+    {
+        keypoints.clear();
+        return;
+    }
+    Mat mask = msk.getMat();
+    if( !mask.empty() )
+    {
+        CV_Assert(mask.type() == CV_8UC1);
+        CV_Assert(mask.size == image.size);
+    }
+    Mat_<float> dx2, dy2, dxy;
+    Mat Lx, Ly;
+    float si, sd;
+    int gsize;
+    Mat fimage;
+    image.convertTo(fimage, CV_32F, 1.f/255);
+    /*Build gaussian pyramid*/
+    Pyramid pyr(fimage, numOctaves, num_layers, 1, -1, true);
+    keypoints = std::vector<KeyPoint> (0);
+
+    /*Find Harris corners on each layer*/
+    //Use pyr.params.octavesN instead of numOctaves. See issue #1513
+    for (int octave = 0; octave <= pyr.params.octavesN; octave++)
+    {
+        for (int layer = 1; layer <= num_layers; layer++)
+        {
+            if (octave == 0)
+                layer = num_layers;
+
+            Mat Lxm2smooth, Lxmysmooth, Lym2smooth;
+
+            si = powf(2.f, layer / (float) num_layers);
+            sd = si * 0.7f;
+
+            Mat curr_layer;
+            if (num_layers == 4)
+            {
+                if (layer == 1)
+                {
+                    Mat tmp = pyr.getLayer(octave - 1, num_layers - 1);
+                    resize(tmp, curr_layer, Size(0, 0), 0.5, 0.5, INTER_AREA);
+
+                } else
+                    curr_layer = pyr.getLayer(octave, layer - 2);
+            } else /*if num_layer==2*/
+            {
+
+                curr_layer = pyr.getLayer(octave, layer - 1);
+            }
+
+            /*Calculates second moment matrix*/
+
+            /*Derivatives*/
+            Sobel(curr_layer, Lx, CV_32F, 1, 0, 1);
+            Sobel(curr_layer, Ly, CV_32F, 0, 1, 1);
+
+            /*Normalization*/
+            Lx = Lx * sd;
+            Ly = Ly * sd;
+
+            Mat Lxm2 = Lx.mul(Lx);
+            Mat Lym2 = Ly.mul(Ly);
+            Mat Lxmy = Lx.mul(Ly);
+
+            gsize = int(ceil(si * 3)) * 2 + 1;
+
+            /*Convolution*/
+            GaussianBlur(Lxm2, Lxm2smooth, Size(gsize, gsize), si, si, BORDER_REPLICATE);
+            GaussianBlur(Lym2, Lym2smooth, Size(gsize, gsize), si, si, BORDER_REPLICATE);
+            GaussianBlur(Lxmy, Lxmysmooth, Size(gsize, gsize), si, si, BORDER_REPLICATE);
+
+            Mat cornern_mat(curr_layer.size(), CV_32F);
+
+            /*Calculates cornerness in each pixel of the image*/
+            for (int row = 0; row < curr_layer.rows; row++)
+            {
+                for (int col = 0; col < curr_layer.cols; col++)
+                {
+                    float dx2f = Lxm2smooth.at<float> (row, col);
+                    float dy2f = Lym2smooth.at<float> (row, col);
+                    float dxyf = Lxmysmooth.at<float> (row, col);
+                    float det = dx2f * dy2f - dxyf * dxyf;
+                    float tr = dx2f + dy2f;
+                    float cornerness = det - (0.04f * tr * tr);
+                    cornern_mat.at<float> (row, col) = cornerness;
+                }
+            }
+
+            double maxVal = 0;
+            Mat corn_dilate;
+
+            /*Find max cornerness value and rejects all corners that are lower than a threshold*/
+            minMaxLoc(cornern_mat, 0, &maxVal, 0, 0);
+            threshold(cornern_mat, cornern_mat, maxVal * corn_thresh, 0, THRESH_TOZERO);
+            dilate(cornern_mat, corn_dilate, Mat());
+
+            Size imgsize = curr_layer.size();
+
+            /*Verify for each of the initial points whether the DoG attains a maximum at the scale of the point*/
+            Mat prevDOG, curDOG, succDOG;
+            prevDOG = pyr.getDOGLayer(octave, layer - 1);
+            curDOG = pyr.getDOGLayer(octave, layer);
+            succDOG = pyr.getDOGLayer(octave, layer + 1);
+
+            for (int y = 1; y < imgsize.height - 1; y++)
+            {
+                for (int x = 1; x < imgsize.width - 1; x++)
+                {
+                    float val = cornern_mat.at<float> (y, x);
+                    if (val != 0 && val == corn_dilate.at<float> (y, x))
+                    {
+
+                        float curVal = curDOG.at<float> (y, x);
+                        float prevVal =  prevDOG.at<float> (y, x);
+                        float succVal = succDOG.at<float> (y, x);
+
+                        KeyPoint kp(
+                                Point2f(x * powf(2.0f, (float) octave - 1) + powf(2.0f, (float) octave - 1) / 2,
+                                        y * powf(2.0f, (float) octave - 1) + powf(2.0f, (float) octave - 1) / 2),
+                                3 * powf(2.0f, (float) octave - 1) * si * 2, 0, val, octave);
+
+                        if(!mask.empty() && mask.at<unsigned char>(int(kp.pt.y), int(kp.pt.x)) == 0)
+                        {
+                            // ignore keypoints where mask is zero
+                            continue;
+                        }
+
+                        /*Check whether keypoint size is inside the image*/
+                        float start_kp_x = kp.pt.x - kp.size / 2;
+                        float start_kp_y = kp.pt.y - kp.size / 2;
+                        float end_kp_x = start_kp_x + kp.size;
+                        float end_kp_y = start_kp_y + kp.size;
+
+                        if (curVal > prevVal && curVal > succVal && curVal >= DOG_thresh
+                                && start_kp_x > 0 && start_kp_y > 0 && end_kp_x < image.cols
+                                && end_kp_y < image.rows)
+                            keypoints.push_back(kp);
+
+                    }
+                }
+            }
+
+        }
+
+    }
+
+    /*Sort keypoints in decreasing cornerness order*/
+    sort(keypoints.begin(), keypoints.end(), sort_func);
+    for (size_t i = 1; i < keypoints.size(); i++)
+    {
+        float max_diff = powf(2, keypoints[i].octave + 1.f / 2);
+
+        if (keypoints[i].response == keypoints[i - 1].response && norm(
+                keypoints[i].pt - keypoints[i - 1].pt) <= max_diff)
+        {
+
+            float x = (keypoints[i].pt.x + keypoints[i - 1].pt.x) / 2;
+            float y = (keypoints[i].pt.y + keypoints[i - 1].pt.y) / 2;
+
+            keypoints[i].pt = Point2f(x, y);
+            --i;
+            keypoints.erase(keypoints.begin() + i);
+
+        }
+    }
+
+    /*Select strongest keypoints*/
+    if (maxCorners > 0 && maxCorners < (int) keypoints.size())
+        keypoints.resize(maxCorners);
+}
+
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/latch.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/latch.cpp
new file mode 100644
index 00000000..da5041fa
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/latch.cpp
@@ -0,0 +1,1082 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// If you find this code useful, please add a reference to the following paper in your work:
+// Gil Levi and Tal Hassner, "LATCH: Learned Arrangements of Three Patch Codes", arXiv preprint arXiv:1501.03719, 15 Jan. 2015
+
+//M*/
+
+#include "precomp.hpp"
+#include <algorithm>
+#include <vector>
+
+#include <iostream>
+#include <iomanip>
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+
+        /*
+        * LATCH Descriptor
+        */
+        class LATCHDescriptorExtractorImpl CV_FINAL : public LATCH
+        {
+        public:
+            enum { PATCH_SIZE = 48 };
+
+            LATCHDescriptorExtractorImpl(int bytes = 32, bool rotationInvariance = true, int half_ssd_size = 3, double sigma = 2.0);
+
+            virtual void read( const FileNode& ) CV_OVERRIDE;
+            virtual void write( FileStorage& ) const CV_OVERRIDE;
+
+            void setBytes(int bytes) CV_OVERRIDE;
+            int getBytes() const CV_OVERRIDE { return bytes_; }
+
+            void setRotationInvariance(bool rotationInvariance) CV_OVERRIDE { rotationInvariance_ = rotationInvariance; }
+            bool getRotationInvariance() const CV_OVERRIDE { return rotationInvariance_; }
+
+            void setHalfSSDsize(int half_ssd_size) CV_OVERRIDE { half_ssd_size_ = half_ssd_size; }
+            int getHalfSSDsize() const CV_OVERRIDE { return half_ssd_size_; }
+
+            void setSigma(double sigma) CV_OVERRIDE { sigma_ = sigma; }
+            double getSigma() const CV_OVERRIDE { return sigma_; }
+
+            virtual int descriptorSize() const CV_OVERRIDE;
+            virtual int descriptorType() const CV_OVERRIDE;
+            virtual int defaultNorm() const CV_OVERRIDE;
+
+            virtual void compute(InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors) CV_OVERRIDE;
+
+        protected:
+            typedef void(*PixelTestFn)(const Mat& input_image, const std::vector<KeyPoint>& keypoints, OutputArray, const std::vector<int> &points, bool rotationInvariance, int half_ssd_size);
+            void setSamplingPoints();
+            int bytes_;
+            PixelTestFn test_fn_;
+            bool rotationInvariance_;
+            int half_ssd_size_;
+            double sigma_;
+
+
+            std::vector<int> sampling_points_ ;
+        };
+
+        Ptr<LATCH> LATCH::create(int bytes, bool rotationInvariance, int half_ssd_size, double sigma)
+        {
+            return makePtr<LATCHDescriptorExtractorImpl>(bytes, rotationInvariance, half_ssd_size, sigma);
+        }
+        String LATCH::getDefaultName() const
+        {
+            return (Feature2D::getDefaultName() + ".LATCH");
+        }
+        void CalcuateSums(int count, const std::vector<int> &points, bool rotationInvariance, const Mat &grayImage, const KeyPoint &pt, int &suma, int &sumc, float cos_theta, float sin_theta, int half_ssd_size);
+
+
+        static void pixelTests1(const Mat& grayImage, const std::vector<KeyPoint>& keypoints, OutputArray _descriptors, const std::vector<int> &points, bool rotationInvariance, int half_ssd_size)
+        {
+            Mat descriptors = _descriptors.getMat();
+            for (int i = 0; i < (int)keypoints.size(); ++i)
+            {
+                uchar* desc = descriptors.ptr(i);
+                const KeyPoint& pt = keypoints[i];
+                int count = 0;
+
+                //handling keypoint orientation
+                float angle = pt.angle;
+                angle *= (float)(CV_PI / 180.f);
+                float cos_theta = cos(angle);
+                float sin_theta = sin(angle);
+                for (int ix = 0; ix < 1; ix++){
+                    desc[ix] = 0;
+                    for (int j = 7; j >= 0; j--){
+
+                        int suma = 0;
+                        int sumc = 0;
+
+                        CalcuateSums(count, points, rotationInvariance, grayImage, pt, suma, sumc, cos_theta, sin_theta, half_ssd_size);
+                        desc[ix] += (uchar)((suma < sumc) << j);
+
+                        count += 6;
+                    }
+                }
+            }
+        }
+
+
+        static void pixelTests2(const Mat& grayImage, const std::vector<KeyPoint>& keypoints, OutputArray _descriptors, const std::vector<int> &points, bool rotationInvariance, int half_ssd_size)
+        {
+            Mat descriptors = _descriptors.getMat();
+            for (int i = 0; i < (int)keypoints.size(); ++i)
+            {
+                uchar* desc = descriptors.ptr(i);
+                const KeyPoint& pt = keypoints[i];
+                int count = 0;
+
+                //handling keypoint orientation
+                float angle = pt.angle;
+                angle *= (float)(CV_PI / 180.f);
+                float cos_theta = cos(angle);
+                float sin_theta = sin(angle);
+                for (int ix = 0; ix < 2; ix++){
+                    desc[ix] = 0;
+                    for (int j = 7; j >= 0; j--){
+
+                        int suma = 0;
+                        int sumc = 0;
+
+                        CalcuateSums(count, points, rotationInvariance, grayImage, pt, suma, sumc, cos_theta, sin_theta, half_ssd_size);
+                        desc[ix] += (uchar)((suma < sumc) << j);
+
+                        count += 6;
+                    }
+                }
+            }
+        }
+
+
+        static void pixelTests4(const Mat& grayImage, const std::vector<KeyPoint>& keypoints, OutputArray _descriptors, const std::vector<int> &points, bool rotationInvariance, int half_ssd_size)
+        {
+            Mat descriptors = _descriptors.getMat();
+            for (int i = 0; i < (int)keypoints.size(); ++i)
+            {
+                uchar* desc = descriptors.ptr(i);
+                const KeyPoint& pt = keypoints[i];
+                int count = 0;
+
+                //handling keypoint orientation
+                float angle = pt.angle;
+                angle *= (float)(CV_PI / 180.f);
+                float cos_theta = cos(angle);
+                float sin_theta = sin(angle);
+                for (int ix = 0; ix < 4; ix++){
+                    desc[ix] = 0;
+                    for (int j = 7; j >= 0; j--){
+
+                        int suma = 0;
+                        int sumc = 0;
+
+                        CalcuateSums(count, points, rotationInvariance, grayImage, pt, suma, sumc, cos_theta, sin_theta, half_ssd_size);
+                        desc[ix] += (uchar)((suma < sumc) << j);
+
+                        count += 6;
+                    }
+                }
+            }
+        }
+
+
+
+        static void pixelTests8(const Mat& grayImage, const std::vector<KeyPoint>& keypoints, OutputArray _descriptors, const std::vector<int> &points, bool rotationInvariance, int half_ssd_size)
+        {
+            Mat descriptors = _descriptors.getMat();
+            for (int i = 0; i < (int)keypoints.size(); ++i)
+            {
+                uchar* desc = descriptors.ptr(i);
+                const KeyPoint& pt = keypoints[i];
+                int count = 0;
+
+                //handling keypoint orientation
+                float angle = pt.angle;
+                angle *= (float)(CV_PI / 180.f);
+                float cos_theta = cos(angle);
+                float sin_theta = sin(angle);
+                for (int ix = 0; ix < 8; ix++){
+                    desc[ix] = 0;
+                    for (int j = 7; j >= 0; j--){
+
+                        int suma = 0;
+                        int sumc = 0;
+
+                        CalcuateSums(count, points, rotationInvariance, grayImage, pt, suma, sumc, cos_theta, sin_theta, half_ssd_size);
+                        desc[ix] += (uchar)((suma < sumc) << j);
+
+                        count += 6;
+                    }
+                }
+            }
+        }
+
+
+        static void pixelTests16(const Mat& grayImage, const std::vector<KeyPoint>& keypoints, OutputArray _descriptors, const std::vector<int> &points, bool rotationInvariance, int half_ssd_size)
+        {
+            Mat descriptors = _descriptors.getMat();
+            for (int i = 0; i < (int)keypoints.size(); ++i)
+            {
+                uchar* desc = descriptors.ptr(i);
+                const KeyPoint& pt = keypoints[i];
+                int count = 0;
+
+                //handling keypoint orientation
+                float angle = pt.angle;
+                angle *= (float)(CV_PI / 180.f);
+                float cos_theta = cos(angle);
+                float sin_theta = sin(angle);
+                for (int ix = 0; ix < 16; ix++){
+                    desc[ix] = 0;
+                    for (int j = 7; j >= 0; j--){
+
+                        int suma = 0;
+                        int sumc = 0;
+
+                        CalcuateSums(count, points, rotationInvariance, grayImage, pt, suma, sumc, cos_theta, sin_theta, half_ssd_size);
+                        desc[ix] += (uchar)((suma < sumc) << j);
+
+                        count += 6;
+                    }
+                }
+            }
+        }
+
+
+        static void pixelTests32(const Mat& grayImage, const std::vector<KeyPoint>& keypoints, OutputArray _descriptors, const std::vector<int> &points, bool rotationInvariance, int half_ssd_size)
+        {
+            Mat descriptors = _descriptors.getMat();
+            for (int i = 0; i < (int)keypoints.size(); ++i)
+            {
+                uchar* desc = descriptors.ptr(i);
+                const KeyPoint& pt = keypoints[i];
+                int count = 0;
+
+                float angle = pt.angle;
+                angle *= (float)(CV_PI / 180.f);
+                float cos_theta = cos(angle);
+                float sin_theta = sin(angle);
+                for (int ix = 0; ix < 32; ix++){
+                    desc[ix] = 0;
+                    for (int j = 7; j >= 0; j--){
+
+                        int suma = 0;
+                        int sumc = 0;
+
+                        CalcuateSums(count, points, rotationInvariance, grayImage, pt, suma, sumc, cos_theta, sin_theta, half_ssd_size);
+                        desc[ix] += (uchar)((suma < sumc) << j);
+
+                        count += 6;
+                    }
+                }
+            }
+        }
+
+
+        static void pixelTests64(const Mat& grayImage, const std::vector<KeyPoint>& keypoints, OutputArray _descriptors, const std::vector<int> &points, bool rotationInvariance, int half_ssd_size)
+        {
+            Mat descriptors = _descriptors.getMat();
+            for (int i = 0; i < (int)keypoints.size(); ++i)
+            {
+                uchar* desc = descriptors.ptr(i);
+                const KeyPoint& pt = keypoints[i];
+                int count = 0;
+
+                //handling keypoint orientation
+                float angle = pt.angle;
+                angle *= (float)(CV_PI / 180.f);
+                float cos_theta = cos(angle);
+                float sin_theta = sin(angle);
+                for (int ix = 0; ix < 64; ix++){
+                    desc[ix] = 0;
+                    for (int j = 7; j >= 0; j--){
+
+                        int suma = 0;
+                        int sumc = 0;
+
+                        CalcuateSums(count, points, rotationInvariance, grayImage, pt, suma, sumc, cos_theta, sin_theta, half_ssd_size);
+                        desc[ix] += (uchar)((suma < sumc) << j);
+
+                        count += 6;
+                    }
+                }
+            }
+        }
+
+        void CalcuateSums(int count, const std::vector<int> &points, bool rotationInvariance, const Mat &grayImage, const KeyPoint &pt, int &suma, int &sumc, float cos_theta, float sin_theta, int half_ssd_size)
+
+        {
+            int ax = points[count];
+            int ay = points[count + 1];
+
+            int	bx = points[count + 2];
+            int	by = points[count + 3];
+
+            int cx = points[count + 4];
+            int cy = points[count + 5];
+
+            int ax2 = ax;
+            int ay2 = ay;
+            int bx2 = bx;
+            int by2 = by;
+            int cx2 = cx;
+            int cy2 = cy;
+
+            if (rotationInvariance){
+
+
+                ax2 =(int)(((float)ax)*cos_theta - ((float)ay)*sin_theta);
+                ay2 = (int)(((float)ax)*sin_theta + ((float)ay)*cos_theta);
+                bx2 = (int)(((float)bx)*cos_theta - ((float)by)*sin_theta);
+                by2 = (int)(((float)bx)*sin_theta + ((float)by)*cos_theta);
+                cx2 = (int)(((float)cx)*cos_theta - ((float)cy)*sin_theta);
+                cy2 = (int)(((float)cx)*sin_theta + ((float)cy)*cos_theta);
+
+
+                if (ax2 > 24)
+                    ax2 = 24;
+                if (ax2<-24)
+                    ax2 = -24;
+
+                if (ay2>24)
+                    ay2 = 24;
+                if (ay2<-24)
+                    ay2 = -24;
+
+                if (bx2>24)
+                    bx2 = 24;
+                if (bx2<-24)
+                    bx2 = -24;
+
+                if (by2>24)
+                    by2 = 24;
+                if (by2<-24)
+                    by2 = -24;
+
+                if (cx2>24)
+                    cx2 = 24;
+                if (cx2<-24)
+                    cx2 = -24;
+
+                if (cy2>24)
+                    cy2 = 24;
+                if (cy2 < -24)
+                    cy2 = -24;
+
+            }
+
+
+            ax2 += (int)(pt.pt.x + 0.5);
+            ay2 += (int)(pt.pt.y + 0.5);
+
+            bx2 += (int)(pt.pt.x + 0.5);
+            by2 += (int)(pt.pt.y + 0.5);
+
+            cx2 += (int)(pt.pt.x + 0.5);
+            cy2 += (int)(pt.pt.y + 0.5);
+
+
+            int K = half_ssd_size;
+            for (int iy = -K; iy <= K; iy++)
+            {
+                const uchar * Mi_a = grayImage.ptr<uchar>(ay2 + iy);
+                const uchar * Mi_b = grayImage.ptr<uchar>(by2 + iy);
+                const uchar * Mi_c = grayImage.ptr<uchar>(cy2 + iy);
+
+                for (int ix = -K; ix <= K; ix++)
+                {
+                    double difa = Mi_a[ax2 + ix] - Mi_b[bx2 + ix];
+                    suma += (int)((difa)*(difa));
+
+                    double difc = Mi_c[cx2 + ix] - Mi_b[bx2 + ix];
+                    sumc += (int)((difc)*(difc));
+                }
+            }
+
+        }
+
+
+
+        void LATCHDescriptorExtractorImpl::setBytes(int bytes)
+        {
+          switch (bytes)
+          {
+          case 1:
+              test_fn_ = pixelTests1;
+              break;
+          case 2:
+              test_fn_ = pixelTests2;
+              break;
+          case 4:
+              test_fn_ = pixelTests4;
+              break;
+          case 8:
+              test_fn_ = pixelTests8;
+              break;
+          case 16:
+              test_fn_ = pixelTests16;
+              break;
+          case 32:
+              test_fn_ = pixelTests32;
+              break;
+          case 64:
+              test_fn_ = pixelTests64;
+              break;
+          default:
+              CV_Error(Error::StsBadArg, "descriptorSize must be 1,2, 4, 8, 16, 32, or 64");
+          }
+          bytes_ = bytes;
+          setSamplingPoints();
+        }
+
+        LATCHDescriptorExtractorImpl::LATCHDescriptorExtractorImpl(int bytes, bool rotationInvariance, int half_ssd_size, double sigma) :
+            bytes_(bytes), test_fn_(NULL), rotationInvariance_(rotationInvariance), half_ssd_size_(half_ssd_size), sigma_(sigma)
+        {
+            setBytes(bytes_);
+        }
+
+        int LATCHDescriptorExtractorImpl::descriptorSize() const
+        {
+            return bytes_;
+        }
+
+        int LATCHDescriptorExtractorImpl::descriptorType() const
+        {
+            return CV_8UC1;
+        }
+
+        int LATCHDescriptorExtractorImpl::defaultNorm() const
+        {
+            return NORM_HAMMING;
+        }
+
+        void LATCHDescriptorExtractorImpl::read(const FileNode& fn)
+        {
+            // if node is empty, keep previous value
+            if (!fn["descriptorSize"].empty())
+            {
+                int bytes = fn["descriptorSize"];
+                setBytes(bytes);
+            }
+            if (!fn["rotationInvariance"].empty())
+              fn["rotationInvariance"] >> rotationInvariance_;
+            if (!fn["half_ssd_size"].empty())
+              fn["half_ssd_size"] >> half_ssd_size_;
+            if (!fn["sigma"].empty())
+              fn["sigma"] >> sigma_;
+        }
+
+        void LATCHDescriptorExtractorImpl::write(FileStorage& fs) const
+        {
+          if ( fs.isOpened() )
+          {
+              fs << "name" << getDefaultName();
+              fs << "descriptorSize" << bytes_;
+              fs << "rotationInvariance" << rotationInvariance_;
+              fs << "half_ssd_size" << half_ssd_size_;
+              fs << "sigma" << sigma_;
+
+          }
+        }
+
+        void LATCHDescriptorExtractorImpl::compute(InputArray _image,
+            std::vector<KeyPoint>& keypoints,
+            OutputArray _descriptors)
+        {
+            Mat image = _image.getMat();
+
+            if ( image.empty() )
+                return;
+
+            if ( keypoints.empty() )
+                return;
+
+
+            Mat grayImage;
+            switch (image.type())
+            {
+            case CV_8UC1:
+                grayImage = image;
+                break;
+            case CV_8UC3:
+                cvtColor(image, grayImage, COLOR_BGR2GRAY);
+                break;
+            case CV_8UC4:
+                cvtColor(image, grayImage, COLOR_BGRA2GRAY);
+                break;
+            default:
+                CV_Error(Error::StsBadArg, "Image should be 8UC1, 8UC3 or 8UC4");
+            }
+
+            if (sigma_ != 0.)
+                GaussianBlur(grayImage, grayImage, cv::Size(3, 3), sigma_, sigma_);
+
+            //Remove keypoints very close to the border
+            KeyPointsFilter::runByImageBorder(keypoints, image.size(), PATCH_SIZE / 2 + half_ssd_size_);
+
+            bool _1d = false;
+            Mat descriptors;
+
+            _1d = _descriptors.kind() == _InputArray::STD_VECTOR && _descriptors.type() == CV_8U;
+            if( _1d )
+            {
+                _descriptors.create((int)keypoints.size()*bytes_, 1, CV_8U);
+                descriptors = _descriptors.getMat().reshape(1, (int)keypoints.size());
+            }
+            else
+            {
+                _descriptors.create((int)keypoints.size(), bytes_, CV_8U);
+                descriptors = _descriptors.getMat();
+            }
+
+            //_descriptors.create((int)keypoints.size(), bytes_, CV_8U);
+            // prepare descriptors as mat
+            //Mat descriptors = _descriptors.getMat();
+
+
+            test_fn_(grayImage, keypoints, descriptors, sampling_points_, rotationInvariance_, half_ssd_size_);
+        }
+
+
+        void LATCHDescriptorExtractorImpl::setSamplingPoints(){
+            int sampling_points_arr[]= { 13, -6, 19, 19, 23, -4,
+                4, 16, 24, -11, 4, -21,
+                22, -14, -2, -20, 23, 5,
+                17, -10, 2, 10, 14, -18,
+                -22, 2, -12, 12, -22, 21,
+                11, 6, 7, 15, 3, -11,
+                -7, 16, -10, -14, -3, 9,
+                -5, 1, -16, 16, -9, -21,
+                -19, 2, -2, -9, -22, 24,
+                19, 12, -1, -19, 15, -9,
+                7, -2, 22, -23, 13, 20,
+                -3, 9, -17, -1, -5, -19,
+                -3, -14, 5, -21, 10, 19,
+                12, -9, 24, 20, 20, -20,
+                -5, 18, 19, 11, -6, -16,
+                22, 7, 1, -8, -10, 6,
+                19, -4, 3, 8, -2, 19,
+                -17, 10, -11, -12, -21, -17,
+                24, -13, 18, -14, 14, -19,
+                -24, -15, 15, -14, -23, -11,
+                -6, 22, -1, -11, 6, -14,
+                16, 18, 10, -23, 20, 4,
+                23, 8, 4, 7, 17, -19,
+                -2, -21, -11, -18, -3, 7,
+                -23, 10, -11, 5, -16, 19,
+                -24, 4, 15, -16, -19, -5,
+                -19, -4, -1, 5, -20, 2,
+                20, 12, 11, -24, 9, 22,
+                9, 13, -6, -23, 10, 15,
+                -22, -8, -4, -5, -15, 20,
+                -6, -13, 1, 16, -6, 23,
+                -18, -3, -8, -15, -18, 5,
+                14, -12, 9, 13, 19, 12,
+                -22, 16, -1, 19, 16, -12,
+                1, 8, -1, -4, -3, 7,
+                3, 15, 23, -23, 5, -9,
+                2, -7, 14, -13, 6, 20,
+                -18, 11, 16, -10, -12, 4,
+                -15, 2, -9, 21, -21, 20,
+                -3, 5, -22, 23, -7, -22,
+                -17, 13, 24, -14, -24, -24,
+                24, 15, 3, -22, -16, 7,
+                -14, -20, 1, -7, -12, -2,
+                19, 17, 0, 18, -12, -7,
+                -12, 10, 8, 5, -21, -18,
+                -15, 9, 13, 3, -18, -17,
+                0, 5, 11, -22, 8, 18,
+                21, 2, -22, -17, 15, 3,
+                -22, -15, 18, 23, -23, 21,
+                -24, 16, 10, -3, -8, -1,
+                -19, 19, 22, 23, -14, -2,
+                20, 15, -2, -19, 19, -15,
+                -10, 12, 0, -9, -9, -16,
+                13, -22, 16, 16, 0, -14,
+                -8, -13, -1, 20, -5, -22,
+                -7, -23, -4, 10, -1, 20,
+                16, -1, -13, -16, 24, -18,
+                -18, 12, 8, 19, -24, -14,
+                -15, 24, 6, 2, -21, -22,
+                20, -2, 8, 0, 17, -10,
+                -19, 21, -7, 20, -14, 3,
+                19, 17, 0, -16, -18, -19,
+                -17, -19, 12, -23, -12, -8,
+                9, 10, 9, -23, 21, -24,
+                9, 19, -15, -18, 7, -19,
+                5, 3, -3, -16, 4, -2,
+                15, -10, -24, 16, 24, 11,
+                17, 16, -9, 1, 18, -15,
+                11, -5, 0, 24, -20, -12,
+                -14, -19, 24, -16, -9, -6,
+                22, -14, 2, -22, 16, 11,
+                23, -1, 4, -10, 20, 22,
+                -10, -9, 17, 13, -13, -13,
+                -15, 13, 11, 9, -13, 9,
+                22, 15, 2, 18, -12, -10,
+                3, 23, 18, 15, 20, -24,
+                7, -6, 16, 11, 8, 1,
+                13, 16, 24, -20, 9, -4,
+                -8, -3, 17, 24, -19, 17,
+                11, 6, -5, 22, 14, -10,
+                -5, -11, -15, -10, -22, 9,
+                7, 18, -12, 8, 13, -24,
+                9, 0, 2, 3, 7, 12,
+                21, 14, 0, -8, -17, 2,
+                22, 20, -5, 16, 19, -23,
+                22, -18, -19, -3, 24, -15,
+                18, 0, -11, 16, 17, 11,
+                22, 15, -11, 7, 20, -9,
+                -16, 10, 2, 1, -19, 20,
+                -19, -4, 2, -3, -24, 17,
+                -3, 21, 22, -12, -1, 3,
+                -3, -20, -7, 23, -1, -9,
+                -11, 3, -20, -5, -9, -8,
+                19, -17, 21, 21, 21, -13,
+                -10, 6, 2, -2, -17, -21,
+                19, 24, 20, 6, 24, -11,
+                10, -23, -1, -9, 8, -5,
+                22, -20, -3, 24, 19, 5,
+                -24, 6, 0, -13, -23, -15,
+                10, 20, -22, -4, 9, -20,
+                -24, 10, 5, -15, -24, -20,
+                22, 6, 8, -7, 11, 22,
+                -18, 7, -9, 19, -12, -5,
+                -9, 21, -20, -17, -17, 22,
+                -23, 6, -22, -12, -17, 7,
+                -18, 3, 1, 24, -24, 20,
+                -10, -9, 2, 15, 18, 18,
+                16, -13, -18, 11, 9, -6,
+                24, 24, -24, 22, 12, -12,
+                20, 7, -21, 15, 22, -5,
+                -9, -7, 23, -13, -17, -20,
+                -9, -6, 23, 0, -22, 13,
+                -15, -18, 1, -22, -17, 10,
+                0, 4, 4, -8, 18, -8,
+                -7, -6, -20, 18, -20, -3,
+                -20, -14, 4, -9, -17, -8,
+                -18, -7, 3, 8, -16, 5,
+                7, -12, 10, 19, 20, 21,
+                -22, 24, 4, 8, -22, 2,
+                -19, -18, -18, 22, -2, 13,
+                10, 9, -15, 15, 21, 16,
+                16, 11, -24, -2, 24, 21,
+                -7, -12, 1, 14, 9, 17,
+                20, 17, 7, 7, 5, -24,
+                -13, -8, 21, 18, -15, 11,
+                -22, 8, 12, -8, -18, 23,
+                14, 10, 6, -24, 17, -10,
+                8, 13, 21, 17, 24, -3,
+                -21, -24, 18, 11, -8, 5,
+                -10, -23, -2, 23, -13, 5,
+                11, 7, -1, -21, -10, -4,
+                21, -22, -15, 6, 6, -4,
+                16, -7, -7, -23, 19, 6,
+                -1, 21, 23, -14, -2, -17,
+                22, -13, -22, 4, 14, 3,
+                -10, 3, 14, -11, -22, 8,
+                11, 13, -24, 10, 24, 21,
+                12, 2, 13, -16, 15, 1,
+                -1, -4, 20, -22, -6, -19,
+                -14, -20, 2, -11, -20, 24,
+                -23, -10, 12, 1, -24, 2,
+                -24, -23, -16, 13, -1, -11,
+                -8, 6, 19, -13, -23, 23,
+                -18, -24, 23, -16, -21, 16,
+                -12, 19, -10, 6, -6, -16,
+                0, -15, -13, 24, -2, 9,
+                19, -4, 0, 21, 21, 16,
+                -10, -24, -24, -20, -13, -5,
+                24, 7, -13, 7, 18, 19,
+                0, 22, -21, 20, 0, 18,
+                23, 10, -13, -14, 16, 10,
+                -10, -12, 8, 10, -13, 24,
+                -22, -6, -17, 14, -6, 11,
+                17, 17, -7, 17, 17, -12,
+                22, -1, -2, -3, -24, 22,
+                12, 0, 1, -11, 12, -16,
+                -20, -6, -11, 17, -5, -19,
+                18, 7, -8, 3, 23, -11,
+                24, -7, -18, 24, 20, -1,
+                -10, 4, -4, -22, -14, -8,
+                15, -8, -16, 20, 17, 23,
+                12, 15, 15, -19, 5, 4,
+                -16, 21, 3, -3, -17, -15,
+                -18, 14, -20, -22, -18, 12,
+                21, 13, -18, 0, 12, -12,
+                -20, 23, 15, -10, -14, -16,
+                -24, 16, 12, -5, -16, 13,
+                -11, -13, -4, -9, -2, -18,
+                3, -12, -24, 0, -2, -3,
+                -14, -14, 22, 9, -21, 17,
+                18, 10, 2, 23, 15, 6,
+                -8, -18, 15, 23, -11, 23,
+                -24, 13, 4, 16, -24, -13,
+                9, 0, 21, -23, 6, -24,
+                -22, 13, 21, 19, -21, -10,
+                -21, 19, 7, -2, -7, 1,
+                2, -21, 8, 20, 11, -12,
+                19, -19, -2, 24, 17, 1,
+                -3, -7, 3, 17, -4, -13,
+                -23, -5, -15, -14, -7, 11,
+                -15, -23, 24, 22, -17, 18,
+                5, -7, 11, -22, 18, -5,
+                20, -11, -20, 0, 11, 4,
+                18, 18, -9, 7, 19, 17,
+                1, -17, 24, -24, 4, 3,
+                -19, -23, 9, 23, -10, 9,
+                7, -2, -13, 5, 16, -5,
+                8, -13, -9, -23, 12, 13,
+                6, -21, -1, 0, -4, 18,
+                9, -17, -24, -22, 9, 17,
+                -19, 2, 20, -14, -22, 23,
+                22, 11, -9, -14, 8, -4,
+                12, -22, -2, 13, 8, 21,
+                9, -8, 14, 18, 5, -9,
+                16, -13, -7, -7, 21, -12,
+                13, -12, -10, 11, 7, 11,
+                3, 8, 5, -6, 2, 14,
+                24, -22, 8, 23, -7, -10,
+                22, 11, 6, 20, -6, -9,
+                10, -5, -2, -1, 12, 15,
+                -14, 14, -23, 6, -13, -3,
+                -9, 2, 22, -1, -24, -10,
+                -17, 22, 6, -9, -12, -13,
+                -12, 1, -4, 9, -14, -2,
+                13, 2, 23, -2, 12, 5,
+                16, -14, -4, -22, 18, 17,
+                -13, -8, 7, -5, -21, -17,
+                3, -1, -3, -2, -10, 19,
+                18, 6, -14, 24, 20, 10,
+                -7, -20, -23, 10, -4, -8,
+                -20, -9, -10, 16, -14, -21,
+                9, 17, -12, 21, 16, 24,
+                19, -22, -11, -12, 24, -20,
+                5, -15, 14, 12, 3, -13,
+                -6, 20, 4, 22, 3, -20,
+                -23, -12, 7, 12, -23, 16,
+                22, 3, -4, 18, 22, 8,
+                1, 1, 16, 9, -5, 18,
+                21, -7, -5, -15, 24, -6,
+                -13, 14, -12, 23, -17, 18,
+                12, 18, -1, 0, 20, 7,
+                14, -7, -15, -17, 18, -2,
+                -18, -12, -11, 14, -15, -21,
+                -2, -21, 4, -16, 10, -2,
+                22, -23, -19, -17, 19, 16,
+                8, 22, 7, -22, 22, -22,
+                8, -17, -17, 0, 12, 22,
+                13, 8, -6, 19, 19, -6,
+                19, -4, -23, -10, 23, -13,
+                -16, -19, -6, 18, -19, 23,
+                5, -18, -4, -12, -18, -24,
+                -10, 9, 6, 4, -16, -24,
+                -7, -15, 0, 3, -1, 24,
+                -5, 12, 10, -24, 24, 22,
+                -13, 9, 1, 18, 15, 7,
+                -18, -3, -11, -22, -18, -5,
+                -9, 7, 14, 24, -6, -1,
+                -1, -24, 22, 19, -1, 13,
+                -19, 3, -15, -16, -12, 1,
+                0, 12, 21, 21, 13, -22,
+                -19, -9, 14, 12, -23, 17,
+                13, -11, 22, 3, 24, -14,
+                -19, 5, -1, 20, 18, 15,
+                19, -19, -16, 24, 23, 7,
+                -20, -13, 22, 21, -23, -3,
+                -20, 19, 16, -2, -20, -19,
+                18, 18, -12, -16, 14, -5,
+                21, -16, -23, -5, 19, 8,
+                -12, 12, -20, -5, -7, -6,
+                -10, -24, -3, 18, -11, -5,
+                8, 14, 2, -3, 9, 6,
+                24, 2, -2, -6, 24, -12,
+                7, -8, 0, 8, -3, 21,
+                22, 1, 17, -12, 14, -23,
+                19, -18, -1, 23, -21, -10,
+                -6, -1, 14, -22, -9, -9,
+                20, -24, -16, -11, 21, 19,
+                -24, 9, -8, 17, -19, -7,
+                -12, -3, 19, -24, -15, 0,
+                -1, -21, -9, 22, -21, -4,
+                23, 4, -3, 11, 9, 4,
+                -10, 10, 10, 4, -8, 7,
+                5, -15, 21, -23, 9, -12,
+                -17, -21, -2, -15, -17, -15,
+                21, 12, 9, 23, 1, -9,
+                21, 20, 19, -6, 5, -1,
+                -16, -21, 19, -3, -12, 15,
+                14, 3, -2, 2, -20, -17,
+                -3, -16, -15, -13, -21, 11,
+                -18, 21, -5, -17, 5, 11,
+                23, 7, -9, 17, 20, -6,
+                11, -14, -21, 23, 19, -21,
+                -9, -6, 23, -24, -16, 7,
+                -22, 21, 7, 12, -19, -12,
+                -3, 19, 23, 10, -3, -18,
+                -2, 22, -8, -16, -5, 23,
+                14, 21, 22, -19, 6, -9,
+                -6, -24, -12, -13, -23, 9,
+                4, -21, 14, -4, 23, 18,
+                9, 7, -6, 6, 22, 0,
+                14, -13, 8, 24, 16, -14,
+                2, -20, 4, -13, 11, -11,
+                14, -12, 23, 7, 10, 21,
+                14, -4, 14, 22, 13, -14,
+                11, -12, 21, 19, 20, -8,
+                3, -20, 23, -13, 23, 23,
+                4, 18, -2, 10, -11, 20,
+                1, 21, 6, 15, 14, -3,
+                16, 24, 8, -11, 18, 23,
+                21, -3, 15, -23, 5, -5,
+                7, 9, -12, -4, 14, 18,
+                1, -24, 11, -9, -1, 10,
+                -16, -10, -7, 22, -14, 5,
+                -22, 18, -15, -24, -1, 8,
+                -17, 16, 4, 0, -17, 24,
+                -9, -8, 17, -3, -13, 21,
+                24, 10, 12, 12, 3, -15,
+                21, 6, -1, -5, 19, 19,
+                -21, -15, 12, 14, -24, -15,
+                -24, 10, 5, -11, -16, -6,
+                16, -8, -5, -20, 15, -7,
+                -4, 20, -5, 12, -9, 20,
+                -18, 12, 10, -14, -14, 24,
+                17, -12, -1, 13, 18, 19,
+                -13, 22, 2, 9, -14, 19,
+                13, -12, 5, 18, 4, -24,
+                -23, -5, -1, -11, 19, 13,
+                14, -11, -21, -8, 22, -22,
+                -24, 21, -8, -21, 5, 14,
+                11, -4, -9, -10, 16, 2,
+                19, -12, -8, 14, 22, -23,
+                -22, -13, 1, -4, -17, 4,
+                -21, 10, 5, 3, -19, 18,
+                -3, -18, 13, 15, 19, -23,
+                -2, 12, 23, -19, -1, -10,
+                15, -7, 0, -20, 7, 0,
+                -17, -1, -5, 15, -16, -20,
+                11, -21, 2, -15, 4, 2,
+                -3, 5, 4, -2, -3, -14,
+                13, 22, -15, 19, 9, -17,
+                -4, 18, 21, 7, -2, 5,
+                15, 22, 7, -23, 19, 14,
+                11, 14, 24, -23, 11, 6,
+                17, 21, -8, -13, 15, 11,
+                -12, -23, 10, 8, -8, -11,
+                12, -5, -16, -19, 18, -6,
+                -20, -24, -1, -22, -24, -9,
+                -17, -12, 9, 19, -16, 24,
+                14, -9, -6, 7, 20, -23,
+                7, 19, 24, 0, 9, 23,
+                -23, 22, 11, 7, -24, 22,
+                -21, 0, -8, 14, -20, 23,
+                14, -8, -16, -15, 18, 11,
+                2, -6, 24, 7, 6, 24,
+                -14, 24, -4, 3, -21, 2,
+                23, 10, 24, -24, 10, 10,
+                11, 5, -2, 15, 12, 7,
+                24, 11, -5, 6, 21, 12,
+                12, 22, -1, 13, -15, -18,
+                14, -23, 20, 1, 19, 23,
+                -19, -22, 4, -2, -19, 20,
+                8, 2, -9, 10, 23, 21,
+                -11, -11, -1, 15, 9, 23,
+                20, 1, 9, 9, 13, 21,
+                9, -22, -5, -16, 5, -11,
+                -17, -23, -7, 9, -24, 23,
+                7, -9, 23, 2, 20, -16,
+                15, -18, -22, 18, 16, 14,
+                -13, -18, -23, -8, -22, 13,
+                12, -9, 12, 20, 14, -12,
+                -18, -5, -15, 3, -19, 8,
+                -16, -13, 10, 10, -15, 17,
+                -9, 5, -23, 16, -9, 3,
+                -16, -19, 14, 21, -19, -22,
+                -1, 5, 23, 13, 1, -24,
+                -10, 19, -1, -23, -19, -23,
+                4, -19, 8, 4, 7, 18,
+                17, 12, 1, 7, -6, 18,
+                11, -24, 8, 18, 16, -14,
+                -22, 11, -11, -2, -20, 14,
+                -5, 9, 9, -23, 16, 24,
+                -12, -8, 14, -6, -11, 5,
+                23, -6, -16, -5, 21, -15,
+                21, -22, -24, -2, 13, -8,
+                17, 19, 24, -4, 10, 6,
+                -14, -21, -8, 13, -5, -1,
+                -21, -12, 23, -24, -21, -17,
+                12, 11, 21, 15, 13, 23,
+                -9, 16, -23, -2, -6, 2,
+                19, 4, 18, -24, 23, 6,
+                8, -23, 15, -2, 7, 20,
+                24, 10, 8, 24, 4, -3,
+                -23, 5, 19, -3, -23, 23,
+                -19, -20, 3, 15, -12, 6,
+                -10, 23, 0, 3, 18, -22,
+                12, 8, -24, 19, 22, 2,
+                12, 0, -4, -24, 21, 16,
+                -9, -3, 14, 14, -14, 4,
+                18, 11, -9, -14, 21, -23,
+                11, 22, 1, 4, 17, -3,
+                13, -22, -17, 23, 11, 15,
+                11, -14, 3, 9, -4, -12,
+                -6, 16, 2, 5, 20, 6,
+                10, -1, 7, 21, 12, 7,
+                -21, 12, -14, -21, -23, 13,
+                16, 24, 0, -10, -14, -16,
+                -12, -6, 23, 8, -10, 9,
+                14, -18, 2, 24, -9, -5,
+                16, 17, 0, -1, 10, 21,
+                7, 0, -12, -15, 13, -11,
+                14, -20, -22, -13, 0, 1,
+                -21, -15, 6, -23, -16, -20,
+                -9, 24, 2, -17, -5, 4,
+                -21, 18, 18, -22, -21, -6,
+                8, -3, 5, 17, 18, 10,
+                3, 0, 11, 22, -4, -12,
+                -24, 10, 18, 20, -21, -24,
+                -8, -19, 6, -24, 17, 7,
+                1, 8, 19, 8, 13, -23,
+                -21, -24, 21, 2, -21, -15,
+                20, 17, 21, -3, 21, 18,
+                -18, -10, 17, -18, -18, 10,
+                5, -6, 19, 10, 11, 22,
+                6, 24, 8, 13, 3, -8,
+                -3, -12, -13, 4, -21, 23,
+                -10, 5, -2, -22, 5, -9,
+                20, -17, -24, 16, 5, -3,
+                2, 5, 6, -24, 5, 21,
+                -15, 22, 1, 7, -16, 0,
+                -19, -21, -7, 10, 0, -23,
+                -15, -6, -2, -18, -20, -8,
+                -16, 19, 1, 15, 18, 4,
+                5, 4, -21, -14, 4, 2,
+                2, 19, 0, -8, 5, 7,
+                -16, -18, 22, 2, -18, 22,
+                -23, 2, 15, -21, -19, -10,
+                -15, 12, -8, -14, -20, -11,
+                -11, 3, 1, 20, -24, 20,
+                2, 3, -1, 24, 17, 19,
+                -22, 2, 9, -23, -20, -3,
+                -11, -11, 11, -20, -13, -23,
+                5, -1, 16, -7, 3, 9,
+                23, -2, 14, 23, 13, -2,
+                20, -12, 12, 18, 22, 1,
+                16, -19, 11, 8, 7, 23,
+                9, 9, 2, -20, 15, -23,
+                10, 0, -10, 23, 9, 4,
+                -24, -18, 3, 15, -16, -7,
+                19, -17, -17, 1, 23, 11,
+                22, -7, 0, 24, 0, -3,
+                -24, -22, 15, 9, -8, -4,
+                20, -14, -8, -14, 19, 9,
+                24, -2, -8, -4, 24, 14,
+                17, -1, 10, -23, 1, 15,
+                9, -1, 0, -24, 13, -12,
+                -5, 10, -18, -6, -23, 11,
+                -20, 21, 18, 4, -9, -7,
+                24, 15, 7, -3, -2, 11,
+                -10, -24, 11, 2, -10, 13,
+                17, -17, -14, -18, 21, -14,
+                -9, -17, -4, -9, -10, -2,
+                22, -21, 8, -11, 1, 23,
+                -3, -15, -21, -20, -14, 19,
+                3, -10, -11, 22, 3, -21,
+                -23, -15, 0, 9, -19, 12,
+                -24, -3, -5, 22, -23, 15,
+                16, -9, -19, -18, 11, -1,
+                -18, 6, 0, -24, 18, -23,
+                15, -11, -24, 4, 16, 1,
+                10, -21, 23, 1, 2, -10,
+                18, -2, 1, 5, -7, -23,
+                24, -16, -11, -22, 24, -19,
+                19, 12, -23, 2, 12, 0,
+                17, 9, 12, -12, 8, 11,
+                -16, -16, 19, 0, -19, -21,
+                15, 20, 20, -24, 9, 3,
+                24, 1, 6, 21, 18, -19,
+                -22, 21, -2, -14, 19, 22,
+                0, -17, 18, -12, -2, 10,
+                -21, -8, -9, -7, -18, -15,
+                -19, -1, -7, -21, -23, -15,
+                -23, -5, 13, 21, -18, 1,
+                12, 6, 15, -12, 10, -20,
+                16, -13, -20, -6, 14, 13,
+                -9, -2, 11, -14, -13, -5,
+                15, -4, 13, 17, 22, -3,
+                19, -17, -2, 11, -23, 22,
+                12, 16, 12, -4, 18, 9,
+                0, 9, 11, -20, 11, 1,
+                12, -11, 22, -9, 24, -23,
+                -14, -13, -3, 5, 4, 12,
+                14, 12, -14, 3, 15, 17,
+                -11, -24, 18, -23, -5, 3,
+                18, 9, 9, 20, 9, 3,
+                -21, -10, 8, -1, -24, -23,
+                13, 4, -3, -19, 19, 1,
+                18, -18, 2, -21, 10, 13,
+                -10, -17, 0, 12, 8, 19,
+                21, 8, 2, -23, -19, 8,
+                5, -4, -12, 18, 14, -12,
+                19, -19, 14, 5, 9, 21,
+                -21, -21, -8, 1, -1, 14,
+                13, 6, 16, -24, 15, 14,
+                -5, 21, -14, -8, -2, 11,
+                -14, -21, -23, 19, -6, -6,
+                10, -10, -23, -2, 16, 16,
+                13, -14, 3, -15, 13, -23,
+                -15, -13, 17, 12, -19, 19,
+                -5, 18, -12, 10, -4, -16,
+                -22, -15, -9, -18, -10, 16,
+                -7, -5, 13, -18, -18, -23,
+                -23, 22, -3, -24, 14, 20,
+                12, 16, 21, -11, 19, 19,
+                12, -18, -3, -17, 9, -14,
+                -19, -11, 14, -13, -21, 23,
+                8, -6, -18, 12, 17, 1,
+                -4, -1, 4, 19, -12, -7,
+                21, 3, -24, 21, 13, 8,
+                17, 23, 2, 15, 21, -4,
+                4, 16, -15, -20, 1, 6,
+                16, -22, 6, 11, 18, -12,
+                -24, -1, -18, 8, -13, -2,
+                16, -6, -1, -7, -20, -20,
+                9, -10, -15, 6, 17, 16,
+                -19, 17, 19, 0, -18, -8,
+                15, -23, 12, -6, 1, 11,
+                21, -15, 6, 19, 10, -24,
+                -16, 23, -1, -8, -17, -14,
+                11, 2, -1, 7, 14, -2,
+                11, 20, -1, -4, -3, -23,
+                -19, 20, -11, -2, -20, -24,
+                11, -12, 5, -21, -2, -13};
+
+            sampling_points_.assign(&sampling_points_arr[0],&sampling_points_arr[0]+sizeof(sampling_points_arr)/4); }
+
+    }
+
+} // namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos.cpp
new file mode 100644
index 00000000..0f4b3908
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos.cpp
@@ -0,0 +1,69 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#include "precomp.hpp"
+#include "logos/Logos.hpp"
+
+namespace cv
+{
+namespace xfeatures2d
+{
+void matchLOGOS(const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
+                const std::vector<int>& nn1, const std::vector<int>& nn2, std::vector<DMatch>& matches1to2)
+{
+    CV_CheckEQ(keypoints1.size(), nn1.size(), "Number of keypoints1 must be equal to the number of nn1.");
+    CV_CheckEQ(keypoints2.size(), nn2.size(), "Number of keypoints2 must be equal to the number of nn2.");
+    if (keypoints1.empty() || keypoints2.empty())
+    {
+        return;
+    }
+
+    std::vector<logos::Point*> vP1, vP2;
+    vP1.reserve(keypoints1.size());
+    vP2.reserve(keypoints2.size());
+
+    for (size_t i = 0; i < keypoints1.size(); i++)
+    {
+        logos::Point* pt1 = new logos::Point(keypoints1[i].pt.x, keypoints1[i].pt.y,
+                                             static_cast<float>(keypoints1[i].angle*CV_PI/180),
+                                             keypoints1[i].size, nn1[i]);
+        vP1.push_back(pt1);
+    }
+
+    for (size_t i = 0; i < keypoints2.size(); i++)
+    {
+        logos::Point* pt2 = new logos::Point(keypoints2[i].pt.x, keypoints2[i].pt.y,
+                                             static_cast<float>(keypoints2[i].angle*CV_PI/180),
+                                             keypoints2[i].size, nn2[i]);
+        vP2.push_back(pt2);
+    }
+
+    logos::Logos logos;
+    std::vector<logos::PointPair*> globalMatches;
+    logos.estimateMatches(vP1, vP2, globalMatches);
+
+    matches1to2.clear();
+    matches1to2.reserve(globalMatches.size());
+    for (size_t i = 0; i < globalMatches.size(); i++)
+    {
+        logos::PointPair* pp = globalMatches[i];
+        matches1to2.push_back(DMatch(pp->getPos1(), pp->getPos2(), 0));
+    }
+
+    for (size_t i = 0; i < globalMatches.size(); i++)
+    {
+        delete globalMatches[i];
+    }
+
+    for (size_t i = 0; i < vP1.size(); i++)
+    {
+        delete vP1[i];
+    }
+
+    for (size_t i = 0; i < vP2.size(); i++)
+    {
+        delete vP2[i];
+    }
+}
+} //namespace xfeatures2d
+} //namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Logos.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Logos.cpp
new file mode 100644
index 00000000..b4c8773a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Logos.cpp
@@ -0,0 +1,189 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Stephanie Lowry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <cmath>
+#include "Logos.hpp"
+#include <opencv2/core.hpp>
+
+namespace logos
+{
+Logos::Logos()
+{
+    LogosParameters defaultParams;
+    init(defaultParams);
+}
+
+Logos::Logos(const LogosParameters& p)
+{
+    init(p);
+}
+
+void Logos::init(const LogosParameters& p)
+{
+    setParams(p);
+    LB = static_cast<float>(-CV_PI);
+    BINSIZE = logosParams.GLOBALORILIMIT/3;
+    BINNUMBER = static_cast<unsigned int>(ceil(2*CV_PI/BINSIZE));
+    bins.resize(BINNUMBER);
+    std::fill(bins.begin(), bins.end(), 0);
+}
+
+int Logos::estimateMatches(std::vector<Point*> vP1, std::vector<Point*> vP2, std::vector<PointPair*>& globalmatches)
+{
+    matches.clear();
+
+    // for each point
+    int count1 = 0;
+
+    for (std::vector<Point*>::iterator pit1 = vP1.begin(); pit1 != vP1.end(); ++pit1, count1++)
+    {
+        (*pit1)->nearestNeighbours(vP1, count1, getNum1());
+        int count2 = 0;
+
+        // find possible matches
+        for (std::vector<Point*>::iterator pit2 = vP2.begin(); pit2 != vP2.end(); ++pit2, count2++)
+        {
+            if ((*pit1)->getLabel() != (*pit2)->getLabel())
+            {
+                continue;
+            }
+            // this is a possible match in Image 2
+            // get nearest neighbours
+            (*pit2)->nearestNeighbours(vP2, count2, getNum2());
+
+            PointPair* ptpr = new PointPair(*pit1, *pit2);
+            ptpr->addPositions(count1, count2);
+            ptpr->computeLocalSupport(pp, getNum2());
+
+            // calc matches
+            int support = 0;
+            for (std::vector<PointPair*>::const_iterator it = pp.begin(); it < pp.end(); ++it)
+            {
+                Match m(ptpr, *it);
+                if (evaluateMatch(m))
+                {
+                    support++;
+                }
+            }
+            for (size_t i = 0; i < pp.size(); i++)
+            {
+                delete pp[i];
+            }
+            pp.clear();
+            if (support > 0)
+            {
+                ptpr->setSupport(support);
+                matches.push_back(ptpr);
+                updateBin(ptpr->getRelOri());
+            }
+            else
+            {
+                delete ptpr;
+                ptpr = NULL;
+            }
+        }
+    }
+
+    // do global orientation
+    double maxang = calcGlobalOrientation();
+
+    // find which matches are within global orientation limit
+    int numinliers = 0;
+    globalmatches.clear();
+    for (std::vector<PointPair*>::iterator it = matches.begin(); it != matches.end(); ++it)
+    {
+        if (std::fabs((*it)->getRelOri() - maxang) < logosParams.GLOBALORILIMIT)
+        {
+            numinliers++;
+            globalmatches.push_back(*it);
+        }
+        else
+        {
+            delete *it;
+            *it = NULL;
+        }
+    }
+
+    return numinliers;
+}
+
+bool Logos::evaluateMatch(const Match& m) const
+{
+    return ((m.getRelOrientation() < getIntraOriLimit()) &&
+            (m.getRelScale() < getIntraScaleLimit()) &&
+            (m.getInterOrientation() < getInterOriLimit()) &&
+            (m.getInterScale() < getInterScaleLimit()));
+}
+
+void Logos::updateBin(float input)
+{
+    unsigned int binnumber = static_cast<unsigned int>(cvFloor((input-LB) / BINSIZE));
+    // compare binnumber to BINNUMBER
+    if (binnumber < BINNUMBER)
+    {
+        bins[binnumber]++;
+    }
+    else
+    {
+        bins[BINNUMBER-1]++;
+    }
+}
+
+float Logos::calcGlobalOrientation()
+{
+    // find max bin
+    // check BINNUMBER is big enough
+    if (BINNUMBER < 3)
+    {
+        return 0;
+    }
+
+    std::vector<int> bins2(BINNUMBER);
+    int maxval = 0;
+    unsigned int maxix = 0;
+    bins2[0] = bins[0] + bins[1] + bins[BINNUMBER-1];
+    maxval = bins2[0];
+    for (unsigned int i = 1; i < BINNUMBER; i++)
+    {
+        if (i == BINNUMBER-1)
+        {
+            bins2[i] = bins[i]+bins[i-1]+bins[0];
+        }
+        else
+        {
+            bins2[i] = bins[i]+bins[i-1]+bins[i+1];
+        }
+        if (bins2[i] > maxval)
+        {
+            maxval = bins2[i];
+            maxix = i;
+        }
+    }
+
+    // convert to an angle
+    return LB + maxix*BINSIZE + BINSIZE/2;
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Logos.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Logos.hpp
new file mode 100644
index 00000000..1d0fdf62
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Logos.hpp
@@ -0,0 +1,87 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Stephanie Lowry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef LOGOS_HPP
+#define LOGOS_HPP
+
+#include "Point.hpp"
+#include "Match.hpp"
+#include "PointPair.hpp"
+
+namespace logos
+{
+struct LogosParameters
+{
+    LogosParameters() :
+        INTRAORILIMIT(0.1f), INTRASCALELIMIT(0.1f), INTERORILIMIT(0.1f), INTERSCALELIMIT(0.1f), GLOBALORILIMIT(0.1f),
+        NUM1(5), NUM2(5) {}
+
+    float INTRAORILIMIT;
+    float INTRASCALELIMIT;
+    float INTERORILIMIT;
+    float INTERSCALELIMIT;
+    float GLOBALORILIMIT;
+    int NUM1;
+    int NUM2;
+};
+
+class Logos
+{
+private:
+    std::vector<PointPair*> pp;
+    std::vector<PointPair*> matches;
+
+    LogosParameters logosParams;
+    float LB;
+    float BINSIZE;
+    unsigned int BINNUMBER;
+    std::vector<int> bins;
+
+public:
+    Logos();
+    Logos(const LogosParameters& p);
+
+    void init(const LogosParameters& p);
+
+    int estimateMatches(std::vector<Point*> vP1, std::vector<Point*> vP2, std::vector<PointPair*>& globalmatches);
+    bool evaluateMatch(const Match& m) const;
+
+    inline float getIntraOriLimit() const { return logosParams.INTRAORILIMIT; }
+    inline float getIntraScaleLimit() const { return logosParams.INTRASCALELIMIT; }
+    inline float getInterOriLimit() const { return logosParams.INTERORILIMIT; }
+    inline float getInterScaleLimit() const { return logosParams.INTERSCALELIMIT; }
+    inline float getGlobalOriLimit() const { return logosParams.GLOBALORILIMIT; }
+    inline int getNum1() const { return logosParams.NUM1; }
+    inline int getNum2() const { return logosParams.NUM2; }
+
+    void updateBin(float input);
+    float calcGlobalOrientation();
+
+    inline void setParams(const LogosParameters& p) { logosParams = p; }
+};
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Match.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Match.cpp
new file mode 100644
index 00000000..e70e19ac
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Match.cpp
@@ -0,0 +1,103 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Stephanie Lowry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <algorithm>    // std::min
+#include <cmath>        // log, acos
+#include <iostream>
+#include <opencv2/core.hpp>
+#include "Match.hpp"
+
+namespace logos
+{
+Match::Match(PointPair* r_, PointPair* s_) :
+    r(r_), s(s_)
+{
+    calculateInternalVariables();
+    setRelOrientation();
+    setRelScale();
+    interOrientationAndScale();
+}
+
+void Match::calculateInternalVariables()
+{
+    vijx = r->getx1() - s->getx1();
+    vijy = r->gety1() - s->gety1();
+    vmnx = r->getx2() - s->getx2();
+    vmny = r->gety2() - s->gety2();
+}
+
+void Match::setRelOrientation()
+{
+    relOrientation = angleAbsDiff(r->getRelOri(), s->getRelOri());
+}
+
+void Match::setRelScale()
+{
+    relScale = std::fabs(r->getRelScale() - s->getRelScale());
+}
+
+float Match::angleAbsDiff(float a1, float a2)
+{
+    float ad = std::fabs(a1-a2);
+    while (ad > 2*CV_PI)
+    {
+        ad = static_cast<float>(ad-2*CV_PI);
+    }
+    ad = std::min(std::fabs(ad), std::fabs(static_cast<float>(2*CV_PI-std::fabs(ad))));
+
+    return ad;
+}
+
+void Match::interOrientationAndScale()
+{
+    float cp =  vijx*vmny - vijy*vmnx; // analogous to 2D cross product
+    float nmij = std::sqrt(vijx*vijx + vijy*vijy);
+    float nmnm = std::sqrt(vmnx*vmnx + vmny*vmny);
+
+    float fr = (vijx*vmnx+vijy*vmny) / (nmij*nmnm);  // numerator equivalent to dot product
+    fr = std::min(std::max(fr, -1.0f), 1.0f);
+    ro3 = std::acos(fr)*sign(cp);
+
+    rs3 = std::log(nmij) - std::log(nmnm);
+
+    interOrientation = angleAbsDiff(r->getRelOri(), ro3);
+    interScale = std::fabs(r->getRelScale() - rs3);
+}
+
+void Match::printMatch() const
+{
+    std::cout << "Relative Orientation: " << relOrientation << std::endl;
+    std::cout << "Relative Scale: " << relScale << std::endl;
+    std::cout << "Inter Orientation: " << interOrientation << std::endl;
+    std::cout << "Inter Scale: " << interScale << std::endl;
+    std::cout << "Global Relative Orientation: " << r->getRelOri() << std::endl;
+}
+
+int Match::sign(float x)
+{
+    return (x > 0) - (x < 0);
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Match.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Match.hpp
new file mode 100644
index 00000000..8c01cead
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Match.hpp
@@ -0,0 +1,73 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Stephanie Lowry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef MATCH_HPP
+#define MATCH_HPP
+
+#include "PointPair.hpp"
+
+namespace logos
+{
+class Match
+{
+private:
+    PointPair* r;
+    PointPair* s;
+    float relOrientation;
+    float relScale;
+    float interOrientation;
+    float interScale;
+
+    // Internal variables
+    float ro3;
+    float rs3;
+    float vijx;
+    float vijy;
+    float vmnx;
+    float vmny;
+
+    // Internal functions
+    void calculateInternalVariables();
+    void setRelOrientation();
+    void setRelScale();
+    float angleDiff(float a1,float a2);
+    float angleAbsDiff(float a1, float a2);
+    void interOrientationAndScale();
+    int sign(float x);
+
+public:
+    Match(PointPair* r, PointPair* s);
+
+    inline float getRelOrientation() const { return relOrientation; }
+    inline float getRelScale() const { return relScale; }
+    inline float getInterOrientation() const { return interOrientation; }
+    inline float getInterScale() const { return interScale; }
+
+    void printMatch() const;
+};
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Point.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Point.cpp
new file mode 100644
index 00000000..2966de28
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Point.cpp
@@ -0,0 +1,120 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Stephanie Lowry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <iostream>
+#include <algorithm> // std::sort
+#include "Point.hpp"
+
+namespace logos
+{
+static bool cMP(const MatchPoint& m, const MatchPoint& n)
+{
+    return (m.sd < n.sd);
+}
+
+Point::Point() :
+    x(0), y(0), orientation(0), scale(1), nnVector(), nnFound(false), label(0)
+{
+}
+
+Point::Point(float x_, float y_, float orientation_, float scale_, int label_) :
+    x(x_), y(y_), orientation(orientation_), scale(scale_), nnVector(), nnFound(false), label(label_)
+{
+}
+
+void Point::nearestNeighbours(const std::vector<Point*>& vP, int index, int N)
+{
+    nearestNeighboursNaive(vP, index, N);
+}
+
+void Point::nearestNeighboursNaive(const std::vector<Point*>& vP, int index, int N)
+{
+    // only want to calculate once.
+    if (nnFound)
+    {
+        return;
+    }
+
+    std::vector<MatchPoint> minMatch;
+    minMatch.reserve(vP.size());
+
+    int i = 0;
+    for (std::vector<Point*>::const_iterator it = vP.begin(); it != vP.end(); ++it, i++)
+    {
+        // A point is not it's own neighbour
+        if (i == index)
+        {
+            continue;
+        }
+        float sd = squareDist(getx(), gety(), (*it)->getx(), (*it)->gety());
+        MatchPoint mP(sd, i);
+        minMatch.push_back(mP);
+    }
+
+    std::sort(minMatch.begin(), minMatch.end(), cMP);
+    nnVector.resize(static_cast<size_t>(N));
+    int count = 0;
+    for (std::vector<MatchPoint>::const_iterator mmit = minMatch.begin(); count < N; ++mmit, count++)
+    {
+        nnVector[static_cast<size_t>(count)] = vP[static_cast<size_t>(mmit->index)];
+    }
+
+    nnFound = true;
+}
+
+void Point::matchLabel(int label_, std::vector<Point*>& matchNN)
+{
+    for (std::vector<Point*>::const_iterator nnIterator = nnVector.begin();
+         nnIterator != nnVector.end(); ++nnIterator)
+    {
+        if ((*nnIterator)->label == label_)
+        {
+            matchNN.push_back(*nnIterator);
+        }
+    }
+}
+
+void Point::printPoint() const
+{
+    std::cout << getx() << " "
+              << gety() << " " << getOrientation() << " "
+              << getScale() << " " << getLabel() << std::endl;
+}
+
+void Point::printNN() const
+{
+    for(std::vector<Point*>::const_iterator nnIterator = nnVector.begin();
+        nnIterator != nnVector.end(); ++nnIterator)
+    {
+        (*nnIterator)->printPoint();
+    }
+}
+
+float Point::squareDist(float x1, float y1, float x2, float y2)
+{
+    return (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2);
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Point.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Point.hpp
new file mode 100644
index 00000000..5d0e3d7e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/Point.hpp
@@ -0,0 +1,79 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Stephanie Lowry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef POINT_HPP
+#define POINT_HPP
+
+#include <vector>
+
+namespace logos
+{
+struct MatchPoint
+{
+    float sd;
+    int index;
+
+    MatchPoint(float sd_, int idx) :
+        sd(sd_), index(idx) {}
+};
+
+class Point
+{
+private:
+    float x;
+    float y;
+    float orientation;
+    float scale;
+    std::vector<Point*> nnVector;
+    bool nnFound;
+    int label;
+
+public:
+    Point();
+    Point(float x_, float y_, float orientation_, float scale_, int label_ = 0);
+
+    inline float getx() const { return x; }
+    inline float gety() const { return y; }
+    inline float getOrientation() const { return orientation; }
+    inline float getScale() const { return scale; }
+
+    inline int getLabel() const { return label; }
+    inline void setLabel(int label_) { label = label_; }
+
+    inline void getNNVector(std::vector<Point*>& nnv) const { nnv = nnVector; }
+    void matchLabel(int label, std::vector<Point*>& mNN);
+
+    void nearestNeighbours(const std::vector<Point*>& vP, int index, int N);
+    void nearestNeighboursNaive(const std::vector<Point*>& vP, int index, int N);
+
+    void printPoint() const;
+    void printNN() const;
+
+    float squareDist(float x1, float y1, float x2, float y2);
+};
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/PointPair.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/PointPair.cpp
new file mode 100644
index 00000000..0db95570
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/PointPair.cpp
@@ -0,0 +1,77 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Stephanie Lowry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include <opencv2/core.hpp>
+#include "PointPair.hpp"
+
+namespace logos
+{
+PointPair::PointPair(Point* p_, Point* q_) :
+    p(p_), q(q_), support(0), pos1(0), pos2(0)
+{
+    calculateInternalVariables();
+}
+
+void PointPair::computeLocalSupport(std::vector<PointPair*>& pp, int N)
+{
+    std::vector<Point*> nnVector;
+    p->getNNVector(nnVector); // Exposes the nearest neighbours
+
+    // for each nearest neighbour
+    for (std::vector<Point*>::iterator nnIterator = nnVector.begin(); nnIterator != nnVector.end(); ++nnIterator)
+    {
+        // is there a matching nearestNeighbour?
+        std::vector<Point*> matchNN;
+        matchNN.reserve(static_cast<size_t>(N));
+        q->matchLabel((*nnIterator)->getLabel(), matchNN);
+        for (std::vector<Point*>::const_iterator mit = matchNN.begin(); mit != matchNN.end(); ++mit)
+        {
+            PointPair* m = new PointPair(*nnIterator, *mit);
+            pp.push_back(m);
+        }
+    }
+}
+
+void PointPair::calculateInternalVariables()
+{
+    relOri = angleDiff(p->getOrientation(), q->getOrientation());
+    relScale = std::log(p->getScale()) - std::log(q->getScale());
+}
+
+float PointPair::angleDiff(float a1, float a2)
+{
+    float ad = a1 - a2;
+    while (ad > CV_PI)
+    {
+        ad = static_cast<float>(ad-2*CV_PI);
+    }
+    while (ad < -CV_PI)
+    {
+        ad = static_cast<float>(ad + 2*CV_PI);
+    }
+    return ad;
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/PointPair.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/PointPair.hpp
new file mode 100644
index 00000000..1669adc5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/logos/PointPair.hpp
@@ -0,0 +1,71 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Stephanie Lowry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef POINTPAIR_HPP
+#define POINTPAIR_HPP
+
+#include "Point.hpp"
+
+namespace logos
+{
+class PointPair
+{
+private:
+    Point* p;
+    Point* q;
+    int support;
+    float relOri;
+    float relScale;
+    int pos1;
+    int pos2;
+
+    float angleDiff(float a1, float a2);
+
+public:
+    PointPair(Point* p_, Point* q_);
+
+    void computeLocalSupport(std::vector<PointPair*>& pp, int N);
+
+    void calculateInternalVariables();
+
+    float getRelOri() const { return relOri; }
+    float getRelScale() const { return relScale; }
+
+    float getx1() const { return p->getx(); }
+    float getx2() const { return q->getx(); }
+    float gety1() const { return p->gety(); }
+    float gety2() const { return q->gety(); }
+
+    void addPositions(int pos1_, int pos2_) { pos1 = pos1_; pos2 = pos2_; }
+    int getPos1() const { return pos1; }
+    int getPos2() const { return pos2; }
+
+    int getSupport() const { return support; }
+    void setSupport(int support_) { support = support_; }
+};
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/lucid.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/lucid.cpp
new file mode 100644
index 00000000..18a68b6d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/lucid.cpp
@@ -0,0 +1,195 @@
+// This implementation of, and any deviation from, the original algorithm as
+// proposed by Ziegler et al. is not endorsed by Ziegler et al. nor does it
+// claim to represent their definition of locally uniform comparison image
+// descriptor. The original LUCID algorithm as proposed by Ziegler et al. remains
+// the property of its respective authors. This implementation is an adaptation of
+// said algorithm and contributed to OpenCV by Str3iber.
+
+// References:
+// Ziegler, Andrew, Eric Christiansen, David Kriegman, and Serge J. Belongie.
+// "Locally uniform comparison image descriptor." In Advances in Neural Information
+// Processing Systems, pp. 1-9. 2012.
+
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#include "precomp.hpp"
+
+namespace cv {
+    namespace xfeatures2d {
+        /*!
+         LUCID implementation
+         */
+        class LUCIDImpl : public LUCID {
+            public:
+                /** Constructor
+                 * @param lucid_kernel kernel for descriptor construction, where 1=3x3, 2=5x5, 3=7x7 and so forth
+                 * @param blur_kernel kernel for blurring image prior to descriptor construction, where 1=3x3, 2=5x5, 3=7x7 and so forth
+                 */
+                LUCIDImpl(const int lucid_kernel = 1, const int blur_kernel = 2);
+
+                void read( const FileNode& fn) CV_OVERRIDE;
+                void write( FileStorage& fs) const CV_OVERRIDE;
+
+                /**
+                 * @param lucid_kernel kernel for descriptor construction, where 1=3x3, 2=5x5, 3=7x7 and so forth
+                 */
+                void setLucidKernel(int lucid_kernel) CV_OVERRIDE { l_kernel = lucid_kernel; }
+                /**
+                 * @return lucid kernel, where 1=3x3, 2=5x5, 3=7x7 and so forth
+                 */
+                int getLucidKernel() const CV_OVERRIDE { return l_kernel; }
+
+                /**
+                 * @param blur_kernel kernel for blurring image prior to descriptor construction, where 1=3x3, 2=5x5, 3=7x7 and so forth
+                 */
+                void setBlurKernel(int blur_kernel) CV_OVERRIDE { b_kernel = blur_kernel*2+1; }
+                /**
+                 * @return blur kernel, where 1=3x3, 2=5x5, 3=7x7 and so forth
+                 */
+                int getBlurKernel() const CV_OVERRIDE { return (b_kernel-1)/2; }
+
+                /** returns the descriptor length */
+                virtual int descriptorSize() const CV_OVERRIDE;
+
+                /** returns the descriptor type */
+                virtual int descriptorType() const CV_OVERRIDE;
+
+                /** returns the default norm type */
+                virtual int defaultNorm() const CV_OVERRIDE;
+
+                virtual void compute(InputArray _src, std::vector<KeyPoint> &keypoints, OutputArray _desc) CV_OVERRIDE;
+
+            protected:
+                int l_kernel, b_kernel;
+        };
+
+        Ptr<LUCID> LUCID::create(const int lucid_kernel, const int blur_kernel) {
+            return makePtr<LUCIDImpl>(lucid_kernel, blur_kernel);
+        }
+
+        LUCIDImpl::LUCIDImpl(const int lucid_kernel, const int blur_kernel) {
+            l_kernel = lucid_kernel;
+            b_kernel = blur_kernel*2+1;
+        }
+
+        void LUCIDImpl::read( const FileNode& fn)
+        {
+          // if node is empty, keep previous value
+          if (!fn["lucid_kernel"].empty())
+              fn["lucid_kernel"] >> l_kernel;
+          if (!fn["blur_kernel"].empty())
+          {
+              int _b_kernel;
+              fn["blur_kernel"] >> _b_kernel;
+              b_kernel = _b_kernel*2+1;
+          }
+        }
+        void LUCIDImpl::write( FileStorage& fs) const
+        {
+            if(fs.isOpened())
+            {
+                fs << "name" << getDefaultName();
+                fs << "lucid_kernel" << l_kernel;
+                fs << "blur_kernel" << (b_kernel-1)/2;
+            }
+        }
+
+        int LUCIDImpl::descriptorSize() const {
+            return (l_kernel*2+1)*(l_kernel*2+1)*3;
+        }
+
+        int LUCIDImpl::descriptorType() const {
+            return CV_8UC1;
+        }
+
+        int LUCIDImpl::defaultNorm() const {
+            return NORM_HAMMING;
+        }
+
+        // gliese581h suggested filling a cv::Mat with descriptors to enable BFmatcher compatibility
+        // speed-ups and enhancements by gliese581h
+        void LUCIDImpl::compute(InputArray _src, std::vector<KeyPoint> &keypoints, OutputArray _desc) {
+            if (_src.empty()) return;
+            CV_Assert(_src.depth() == CV_8U);
+            cv::Mat src_input;
+            if (_src.channels() == 4)
+                cvtColor(_src, src_input, COLOR_BGRA2BGR);
+            else {
+                CV_Assert(_src.channels() == 3);
+                src_input = _src.getMat();
+            }
+
+            Mat_<Vec3b> src;
+
+            blur(src_input, src, cv::Size(b_kernel, b_kernel));
+
+            int x, y, j, d, p, m = (l_kernel*2+1)*(l_kernel*2+1)*3, width = src.cols, height = src.rows, r, c;
+
+            Mat_<uchar> desc(static_cast<int>(keypoints.size()), m);
+
+            for (std::size_t i = 0; i < keypoints.size(); ++i) {
+                x = static_cast<int>(keypoints[i].pt.x)-l_kernel, y = static_cast<int>(keypoints[i].pt.y)-l_kernel, d = x+2*l_kernel, p = y+2*l_kernel, j = x, r = static_cast<int>(i), c = 0;
+
+                while (x <= d) {
+                    Vec3b &pix = src((y < 0 ? height+y : y >= height ? y-height : y), (x < 0 ? width+x : x >= width ? x-width : x));
+
+                    desc(r, c++) = pix[0];
+                    desc(r, c++) = pix[1];
+                    desc(r, c++) = pix[2];
+
+                    ++x;
+                    if (x > d) {
+                        if (y < p) {
+                            ++y;
+                            x = j;
+                        }
+                        else
+                            break;
+                    }
+                }
+            }
+
+            if (_desc.needed())
+                sort(desc, _desc, SORT_EVERY_ROW | SORT_ASCENDING);
+        }
+
+        String LUCID::getDefaultName() const
+        {
+          return (Feature2D::getDefaultName() + ".LUCID");
+        }
+    }
+} // END NAMESPACE CV
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/msd.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/msd.cpp
new file mode 100644
index 00000000..c63815af
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/msd.cpp
@@ -0,0 +1,788 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+License Agreement
+For Open Source Computer Vision Library
+(3-clause BSD License)
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+ * Neither the names of the copyright holders nor the names of the contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+
+***********************************************************************************
+Maximal Self-Dissimilarity (MSD) Interest Point Detector
+
+This is an implementation of the MSD interest point detector
+presented in the scientific publication:
+
+[1] F. Tombari, L. Di Stefano
+"Interest Points via Maximal Self-Dissimilarities"
+12th Asian Conference on Computer Vision (ACCV), 2014
+
+The code is ported from the stand-alone implementation available
+at this repository:
+www.github.com/fedassa/msdDetector
+
+AUTHORS:  Federico Tombari (fedassa@gmail.com) (original code),
+          Daniele De Gregorio (degregorio.daniele@gmail.com) (OpenCV porting)
+
+University of Bologna, Open Perception
+
+ */
+
+#include "precomp.hpp"
+#include "msd_pyramid.hpp"
+#include <limits>
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+
+
+        /*!
+            MSD Implementation.
+         */
+        class MSDDetector_Impl : public MSDDetector
+        {
+        public:
+
+            // Multi-threaded contextualSelfDissimilarity method
+            struct MSDSelfDissimilarityScan : ParallelLoopBody
+            {
+
+                MSDSelfDissimilarityScan(MSDDetector_Impl& _detector, std::vector< std::vector<float> >* _saliency, cv::Mat& _img, int _level, int _border, int _split)
+                {
+                    detector = &_detector;
+                    saliency = _saliency;
+                    img = &_img;
+                    split = _split;
+                    level = _level;
+                    border = _border;
+                    int w = img->cols - border * 2;
+                    chunkSize = w / split;
+                    remains = w - chunkSize*split;
+                }
+
+                void operator()(const Range& range) const CV_OVERRIDE
+                {
+                    for (int i = range.start; i < range.end; i++)
+                    {
+                        int start = border + i*chunkSize;
+                        int end = border + (i + 1) * chunkSize;
+                        if (remains > 0)
+                            if (i == split - 1)
+                            {
+                                end = img->cols - border;
+                            }
+                        detector->contextualSelfDissimilarity(*img, start, end, &saliency->at(level)[0]);
+                    }
+                }
+
+                MSDDetector_Impl* detector;
+                std::vector< std::vector<float> >* saliency;
+                cv::Mat* img;
+                int level;
+                int split;
+                int border;
+                int chunkSize;
+                int remains;
+            };
+
+            /**
+             * Constructor
+             * @param patch_radius Patch radius
+             * @param search_area_radius Search Area radius
+             * @param nms_radius  Non Maxima Suppression spatial radius
+             * @param nms_scale_radius Non Maxima Suppression scale radius
+             * @param th_saliency Saliency threshold
+             * @param kNN number of nearest neighbors (k)
+             * @param scale_factor Scale factor for building up the image pyramid
+             * @param n_scales Number of scales number of scales for building up the image pyramid (if set to -1, this number is automatically determined)
+             * @param compute_orientation Flag for associating a canoncial orientation to each keypoint
+             */
+            MSDDetector_Impl(int patch_radius, int search_area_radius,
+                    int nms_radius, int nms_scale_radius, float th_saliency, int kNN, float scale_factor,
+                    int n_scales, bool compute_orientation)
+            : m_patch_radius(patch_radius), m_search_area_radius(search_area_radius), m_nms_radius(nms_radius),
+              m_nms_scale_radius(nms_scale_radius), m_th_saliency(th_saliency), m_kNN(kNN), m_scale_factor(scale_factor),
+              m_n_scales(n_scales), m_compute_orientation(compute_orientation)
+
+            {
+            }
+
+            void setPatchRadius(int patch_radius)  CV_OVERRIDE { m_patch_radius = patch_radius; }
+            int getPatchRadius() const CV_OVERRIDE { return m_patch_radius; }
+
+            void setSearchAreaRadius(int search_area_radius)  CV_OVERRIDE { m_search_area_radius = search_area_radius; }
+            int getSearchAreaRadius() const CV_OVERRIDE { return m_search_area_radius; }
+
+            void setNmsRadius(int nms_radius)  CV_OVERRIDE { m_nms_radius = nms_radius; }
+            int getNmsRadius() const CV_OVERRIDE { return m_nms_radius; }
+
+            void setNmsScaleRadius(int nms_scale_radius)  CV_OVERRIDE { m_nms_scale_radius = nms_scale_radius; }
+            int getNmsScaleRadius() const CV_OVERRIDE { return m_nms_scale_radius; }
+
+            void setThSaliency(float th_saliency)  CV_OVERRIDE { m_th_saliency = th_saliency; }
+            float getThSaliency() const CV_OVERRIDE { return m_th_saliency; }
+
+            void setKNN(int kNN)  CV_OVERRIDE { m_kNN = kNN; }
+            int getKNN() const CV_OVERRIDE { return m_kNN; }
+
+            void setScaleFactor(float scale_factor)  CV_OVERRIDE { m_scale_factor = scale_factor; }
+            float getScaleFactor() const CV_OVERRIDE { return m_scale_factor; }
+
+            void setNScales(int n_scales)  CV_OVERRIDE { m_n_scales = n_scales; }
+            int getNScales() const CV_OVERRIDE { return m_n_scales; }
+
+            void setComputeOrientation(bool compute_orientation)  CV_OVERRIDE { m_compute_orientation = compute_orientation; }
+            bool getComputeOrientation() const CV_OVERRIDE { return m_compute_orientation; }
+
+            void read( const FileNode& fn) CV_OVERRIDE
+            {
+              // if node is empty, keep previous value
+              if (!fn["patch_radius"].empty())
+                fn["patch_radius"] >> m_patch_radius;
+              if (!fn["search_area_radius"].empty())
+                fn["search_area_radius"] >> m_search_area_radius;
+              if (!fn["nms_radius"].empty())
+                fn["nms_radius"] >> m_nms_radius;
+              if (!fn["nms_scale_radius"].empty())
+                fn["nms_scale_radius"] >> m_nms_scale_radius;
+              if (!fn["th_saliency"].empty())
+                fn["th_saliency"] >> m_th_saliency;
+              if (!fn["kNN"].empty())
+                fn["kNN"] >> m_kNN;
+              if (!fn["scale_factor"].empty())
+                fn["scale_factor"] >> m_scale_factor;
+              if (!fn["n_scales"].empty())
+                fn["n_scales"] >> m_n_scales;
+              if (!fn["compute_orientation"].empty())
+                fn["compute_orientation"] >> m_compute_orientation;
+            }
+            void write( FileStorage& fs) const CV_OVERRIDE
+            {
+              if(fs.isOpened())
+              {
+                fs << "name" << getDefaultName();
+                fs << "patch_radius" << m_patch_radius;
+                fs << "search_area_radius" << m_search_area_radius;
+                fs << "nms_radius" << m_nms_radius;
+                fs << "nms_scale_radius" << m_nms_scale_radius;
+                fs << "th_saliency" << m_th_saliency;
+                fs << "kNN" << m_kNN;
+                fs << "scale_factor" << m_scale_factor;
+                fs << "n_scales" << m_n_scales;
+                fs << "compute_orientation" << m_compute_orientation;
+              }
+            }
+
+            void detect(InputArray _image, std::vector<KeyPoint>& keypoints, InputArray _mask) CV_OVERRIDE
+            {
+                m_mask = _mask.getMat();
+
+                int border = m_search_area_radius + m_patch_radius;
+
+                cv::Mat img = _image.getMat();
+                if (m_n_scales == -1)
+                    m_cur_n_scales = cvFloor(std::log(cv::min(img.cols, img.rows) / ((m_patch_radius + m_search_area_radius)*2.0 + 1)) / std::log(m_scale_factor));
+                else
+                    m_cur_n_scales = m_n_scales;
+
+                cv::Mat imgG;
+                if (img.channels() == 1)
+                    imgG = img;
+                else
+                    cv::cvtColor(img, imgG, cv::COLOR_BGR2GRAY);
+
+                MSDImagePyramid scaleSpacer(imgG, m_cur_n_scales, m_scale_factor);
+                m_scaleSpace = scaleSpacer.getImPyr();
+
+                keypoints.clear();
+                std::vector< std::vector<float> > saliency;
+                saliency.resize(m_cur_n_scales);
+
+                for (int r = 0; r < m_cur_n_scales; r++)
+                {
+                    saliency[r].resize(m_scaleSpace[r].rows * m_scaleSpace[r].cols);
+                    fill(saliency[r].begin(), saliency[r].end(), 0.0f);
+                }
+
+                for (int r = 0; r < m_cur_n_scales; r++)
+                {
+                    int steps = cv::getNumThreads();
+                    parallel_for_(Range(0, steps), MSDSelfDissimilarityScan((*this), &saliency, m_scaleSpace[r], r, border, steps));
+                }
+
+                nonMaximaSuppression(saliency, keypoints);
+
+                for (int r = 0; r < m_cur_n_scales; r++)
+                {
+                    saliency[r].clear();
+                }
+
+                m_scaleSpace.clear();
+
+            }
+
+        protected:
+
+            // Patch radius
+            int m_patch_radius;
+            // Search area radius
+            int m_search_area_radius;
+            // Non Maxima Suppression Spatial Radius
+            int m_nms_radius;
+            // Non Maxima Suppression Scale Radius
+            int m_nms_scale_radius;
+            //Saliency threshold
+            float m_th_saliency;
+            //k nearest neighbors
+            int m_kNN;
+            //Scale factor
+            float m_scale_factor;
+            //Number of scales
+            int m_n_scales;
+            //Current number of scales
+            int m_cur_n_scales;
+            //Compute orientation flag
+            bool m_compute_orientation;
+
+        private:
+
+
+            // Scale-space image pyramid
+            std::vector<cv::Mat> m_scaleSpace;
+            // Input binary mask
+            cv::Mat m_mask;
+
+            /**
+             * Computes the normalized average value of input vector
+             * @param minVals input vector
+             * @param den normalization factor (pre-multiplied by the number of elements of the input vector, assumed constant)
+             * @return normalized average value
+             */
+            inline float computeAvgDistance(std::vector<int> &minVals, int den)
+            {
+                float avg_dist = 0.0f;
+                for (unsigned int i = 0; i < minVals.size(); i++)
+                    avg_dist += minVals[i];
+
+                avg_dist /= den;
+                return avg_dist;
+            }
+
+            /**
+             * Computer the Contextual Self-Dissimilarity (CSD, [1]) for a specific range of image pixels (row-wise)
+             * @param img input image
+             * @param xmin left-most range limit for the image pixels being processed
+             * @param xmax right-most range limit for the image pixels being processed
+             * @param saliency output array being filled with the CSD value computed at each input pixel
+             */
+            void contextualSelfDissimilarity(cv::Mat &img, int xmin, int xmax, float* saliency);
+
+            /**
+             * Associates a canonical orientation (computed as in [1]) to each extracted key-point
+             * @param img input image
+             * @param x column index of the key-point on the input image
+             * @param y row index of the key-point on the input image
+             * @param circle pre-computed LUT used in the function
+             * @return angle of the canonical orientation (in radians)
+             */
+            float computeOrientation(cv::Mat &img, int x, int y, std::vector<cv::Point2f> circle);
+
+            /**
+             * Computes the Non-Maxima Suppression (NMS) over the scale-space as in [1] for all elements of the image pyramid
+             * @param saliency input saliency associated to each element of the image pyramid
+             * @param keypoints key-points obtained as local maxima of the saliency
+             */
+            void nonMaximaSuppression(std::vector< std::vector<float> > & saliency, std::vector<cv::KeyPoint> & keypoints);
+
+            /**
+             * Computes the floating point interpolation of a key-point coordinates
+             * @param x column index of the key-point at its scale of the image pyramid
+             * @param yrow index of the key-point at its scale of the image pyramid
+             * @param scale scale of the key-point over the image pyramid
+             * @param saliency pointer to the saliency array
+             * @param p_res interpolated coordinates of the key-point referred to the lowest level of the pyramid (i.e. in the ref. frame of the input image)
+             * @return false if the current key-point has to be rejected, true otherwise
+             */
+            bool rescalePoint(int x, int y, int scale, std::vector< std::vector<float> > & saliency, cv::Point2f & p_res);
+
+        };
+
+        bool MSDDetector_Impl::rescalePoint(int i, int j, int scale, std::vector< std::vector<float> > & saliency, cv::Point2f &p_res)
+        {
+
+            const float deriv_scale = 0.5f;
+            int width_s = m_scaleSpace[scale].cols;
+            //const float second_deriv_scale = 1.0f;
+            const float cross_deriv_scale = 0.25f;
+
+            cv::Vec2f dD((saliency[scale][j * width_s + i + 1] - saliency[scale][j * width_s + i - 1]) * deriv_scale,
+                    (saliency[scale][(j + 1) * width_s + i] - saliency[scale][(j - 1) * width_s + i]) * deriv_scale);
+
+            float cc = saliency[scale][j * width_s + i] * 2;
+            float dxx = (saliency[scale][j * width_s + i + 1] + saliency[scale][j * width_s + i - 1] - cc); // * second_deriv_scale;
+            float dyy = (saliency[scale][(j + 1) * width_s + i] + saliency[scale][(j - 1) * width_s + i] - cc); // * second_deriv_scale;
+            float dxy = (saliency[scale][(j + 1) * width_s + i + 1] - saliency[scale][(j + 1) * width_s + i - 1] -
+                    saliency[scale][(j - 1) * width_s + i + 1] + saliency[scale][(j - 1) * width_s + i - 1]) * cross_deriv_scale;
+
+            cv::Matx22f H(dxx, dxy, dxy, dyy);
+
+            cv::Vec2f X;
+            cv::solve(H, dD, X, cv::DECOMP_LU);
+
+            float xr = -X[1];
+            float xc = -X[0];
+
+            if (std::abs(xr) > 5 || std::abs(xc) > 5)
+                return false;
+
+            if (scale == 0)
+            {
+                p_res.x = i + xc + 0.5f;
+                p_res.y = j + xr + 0.5f;
+            } else
+            {
+                float effectiveScaleFactor = std::pow(m_scale_factor, (float)scale);
+                p_res.x = (i + xc + 0.5f) * effectiveScaleFactor;
+                p_res.y = (j + xr + 0.5f) * effectiveScaleFactor;
+
+                p_res.x -= 0.5f;
+                p_res.y -= 0.5f;
+
+                if (p_res.x < 0 || p_res.x >= m_scaleSpace[0].cols || p_res.y < 0 || p_res.y >= m_scaleSpace[0].rows)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        void MSDDetector_Impl::contextualSelfDissimilarity(cv::Mat &img, int xmin, int xmax, float* saliency)
+        {
+            int r_s = m_patch_radius;
+            int r_b = m_search_area_radius;
+            int k = m_kNN;
+
+            int w = img.cols;
+            int h = img.rows;
+
+            int side_s = 2 * r_s + 1;
+            int side_b = 2 * r_b + 1;
+            int border = r_s + r_b;
+            int temp;
+            int den = side_s * side_s * k;
+
+            std::vector<int> minVals(k);
+            int *acc = new int[side_b * side_b];
+            int **vCol = new int *[w];
+            for (int i = 0; i < w; i++)
+                vCol[i] = new int[side_b * side_b];
+
+            //first position
+            int x = xmin;
+            int y = border;
+
+            int ctrInd = 0;
+            for (int kk = 0; kk < k; kk++)
+                minVals[kk] = std::numeric_limits<int>::max();
+
+            for (int j = y - r_b; j <= y + r_b; j++)
+            {
+
+                for (int i = x - r_b; i <= x + r_b; i++)
+                {
+                    if (j == y && i == x)
+                        continue;
+
+                    acc[ctrInd] = 0;
+                    for (int u = -r_s; u <= r_s; u++)
+                    {
+                        vCol[x + u][ctrInd] = 0;
+                        for (int v = -r_s; v <= r_s; v++)
+                        {
+
+                            temp = img.at<unsigned char>(j + v, i + u) - img.at<unsigned char>(y + v, x + u);
+                            vCol[x + u][ctrInd] += (temp * temp);
+                        }
+                        acc[ctrInd] += vCol[x + u][ctrInd];
+                    }
+
+                    if (acc[ctrInd] < minVals[k - 1])
+                    {
+                        minVals[k - 1] = acc[ctrInd];
+
+                        for (int kk = k - 2; kk >= 0; kk--)
+                        {
+                            if (minVals[kk] > minVals[kk + 1])
+                            {
+                                std::swap(minVals[kk], minVals[kk + 1]);
+                            } else
+                                break;
+                        }
+                    }
+
+                    ctrInd++;
+                }
+            }
+            saliency[y * w + x] = computeAvgDistance(minVals, den);
+
+            for (x = xmin + 1; x < xmax; x++)
+            {
+                ctrInd = 0;
+                for (int kk = 0; kk < k; kk++)
+                    minVals[kk] = std::numeric_limits<int>::max();
+
+                for (int j = y - r_b; j <= y + r_b; j++)
+                {
+                    for (int i = x - r_b; i <= x + r_b; i++)
+                    {
+                        if (j == y && i == x)
+                            continue;
+
+                        vCol[x + r_s][ctrInd] = 0;
+                        for (int v = -r_s; v <= r_s; v++)
+                        {
+                            temp = img.at<unsigned char>(j + v, i + r_s) - img.at<unsigned char>(y + v, x + r_s);
+                            vCol[x + r_s][ctrInd] += (temp * temp);
+                        }
+
+                        acc[ctrInd] = acc[ctrInd] + vCol[x + r_s][ctrInd] - vCol[x - r_s - 1][ctrInd];
+
+                        if (acc[ctrInd] < minVals[k - 1])
+                        {
+                            minVals[k - 1] = acc[ctrInd];
+                            for (int kk = k - 2; kk >= 0; kk--)
+                            {
+                                if (minVals[kk] > minVals[kk + 1])
+                                {
+                                    std::swap(minVals[kk], minVals[kk + 1]);
+                                } else
+                                    break;
+                            }
+                        }
+
+                        ctrInd++;
+                    }
+                }
+                saliency[y * w + x] = computeAvgDistance(minVals, den);
+            }
+
+            for (y = border + 1; y < h - border; y++)
+            {
+                ctrInd = 0;
+                for (int kk = 0; kk < k; kk++)
+                    minVals[kk] = std::numeric_limits<int>::max();
+                x = xmin;
+
+                for (int j = y - r_b; j <= y + r_b; j++)
+                {
+                    for (int i = x - r_b; i <= x + r_b; i++)
+                    {
+                        if (j == y && i == x)
+                            continue;
+
+                        acc[ctrInd] = 0;
+                        for (int u = -r_s; u <= r_s; u++)
+                        {
+                            temp = img.at<unsigned char>(j + r_s, i + u) - img.at<unsigned char>(y + r_s, x + u);
+                            vCol[x + u][ctrInd] += (temp * temp);
+
+                            temp = img.at<unsigned char>(j - r_s - 1, i + u) - img.at<unsigned char>(y - r_s - 1, x + u);
+                            vCol[x + u][ctrInd] -= (temp * temp);
+
+                            acc[ctrInd] += vCol[x + u][ctrInd];
+                        }
+
+                        if (acc[ctrInd] < minVals[k - 1])
+                        {
+                            minVals[k - 1] = acc[ctrInd];
+
+                            for (int kk = k - 2; kk >= 0; kk--)
+                            {
+                                if (minVals[kk] > minVals[kk + 1])
+                                {
+                                    std::swap(minVals[kk], minVals[kk + 1]);
+                                } else
+                                    break;
+                            }
+                        }
+
+                        ctrInd++;
+                    }
+                }
+                saliency[y * w + x] = computeAvgDistance(minVals, den);
+
+                for (x = xmin + 1; x < xmax; x++)
+                {
+                    ctrInd = 0;
+                    for (int kk = 0; kk < k; kk++)
+                        minVals[kk] = std::numeric_limits<int>::max();
+
+                    for (int j = y - r_b; j <= y + r_b; j++)
+                    {
+                        for (int i = x - r_b; i <= x + r_b; i++)
+                        {
+                            if (j == y && i == x)
+                                continue;
+
+                            temp = img.at<unsigned char>(j + r_s, i + r_s) - img.at<unsigned char>(y + r_s, x + r_s);
+                            vCol[x + r_s][ctrInd] += (temp * temp);
+
+                            temp = img.at<unsigned char>(j - r_s - 1, i + r_s) - img.at<unsigned char>(y - r_s - 1, x + r_s);
+                            vCol[x + r_s][ctrInd] -= (temp * temp);
+
+                            acc[ctrInd] = acc[ctrInd] + vCol[x + r_s][ctrInd] - vCol[x - r_s - 1][ctrInd];
+
+                            if (acc[ctrInd] < minVals[k - 1])
+                            {
+                                minVals[k - 1] = acc[ctrInd];
+
+                                for (int kk = k - 2; kk >= 0; kk--)
+                                {
+                                    if (minVals[kk] > minVals[kk + 1])
+                                    {
+                                        std::swap(minVals[kk], minVals[kk + 1]);
+                                    } else
+                                        break;
+                                }
+                            }
+                            ctrInd++;
+                        }
+                    }
+                    saliency[y * w + x] = computeAvgDistance(minVals, den);
+                }
+            }
+
+            for (int i = 0; i < w; i++)
+                delete[] vCol[i];
+            delete[] vCol;
+            delete[] acc;
+        }
+
+        float MSDDetector_Impl::computeOrientation(cv::Mat &img, int x, int y, std::vector<cv::Point2f> circle)
+        {
+            int temp;
+
+            int nBins = 36;
+            float step = float((2 * CV_PI) / nBins);
+            std::vector<float> hist(nBins, 0);
+            std::vector<int> dists(circle.size(), 0);
+
+            int minDist = std::numeric_limits<int>::max();
+            int maxDist = -1;
+
+            for (int k = 0; k < (int) circle.size(); k++)
+            {
+
+                int j = y + static_cast<int> (circle[k].y);
+                int i = x + static_cast<int> (circle[k].x);
+
+                for (int v = -m_patch_radius; v <= m_patch_radius; v++)
+                {
+                    for (int u = -m_patch_radius; u <= m_patch_radius; u++)
+                    {
+                        temp = img.at<unsigned char>(j + v, i + u) - img.at<unsigned char>(y + v, x + u);
+                        dists[k] += temp*temp;
+                    }
+                }
+
+                if (dists[k] > maxDist)
+                    maxDist = dists[k];
+                if (dists[k] < minDist)
+                    minDist = dists[k];
+            }
+
+            float deltaAngle = 0.0f;
+            for (int k = 0; k < (int) circle.size(); k++)
+            {
+                float angle = deltaAngle;
+                float weight = (1.0f * maxDist - dists[k]) / (maxDist - minDist);
+
+                float binF;
+                if (angle >= 2 * CV_PI)
+                    binF = 0.0f;
+                else
+                    binF = angle / step;
+                int bin = static_cast<int> (std::floor(binF));
+
+                CV_Assert(bin >= 0 && bin < nBins);
+                float binDist = abs(binF - bin - 0.5f);
+
+                float weightA = weight * (1.0f - binDist);
+                float weightB = weight * binDist;
+                hist[bin] += weightA;
+
+                if (2 * (binF - bin) < step)
+                    hist[(bin + nBins - 1) % nBins] += weightB;
+                else
+                    hist[(bin + 1) % nBins] += weightB;
+
+                deltaAngle += step;
+            }
+
+            int bestBin = -1;
+            float maxBin = -1;
+            for (int i = 0; i < nBins; i++)
+            {
+                if (hist[i] > maxBin)
+                {
+                    maxBin = hist[i];
+                    bestBin = i;
+                }
+            }
+
+            int l = (bestBin == 0) ? nBins - 1 : bestBin - 1;
+            int r = (bestBin + 1) % nBins;
+            float bestAngle2 = bestBin + 0.5f * ((hist[l]) - (hist[r])) / ((hist[l]) - 2.0f * (hist[bestBin]) + (hist[r]));
+            bestAngle2 = (bestAngle2 < 0) ? nBins + bestAngle2 : (bestAngle2 >= nBins) ? bestAngle2 - nBins : bestAngle2;
+            bestAngle2 *= step;
+
+            return bestAngle2;
+        }
+
+        void MSDDetector_Impl::nonMaximaSuppression(std::vector< std::vector<float> > & saliency, std::vector<cv::KeyPoint> & keypoints)
+        {
+            cv::KeyPoint kp_temp;
+            int border = m_search_area_radius + m_patch_radius;
+
+            std::vector<cv::Point2f> orientPoints;
+            if (m_compute_orientation)
+            {
+                int nBins = 36;
+                float step = float((2 * CV_PI) / nBins);
+                float deltaAngle = 0.0f;
+
+                for (int i = 0; i < nBins; i++)
+                {
+                    cv::Point2f pt;
+                    pt.x = m_search_area_radius * cos(deltaAngle);
+                    pt.y = m_search_area_radius * sin(deltaAngle);
+
+                    orientPoints.push_back(pt);
+
+                    deltaAngle += step;
+                }
+            }
+
+            for (int r = 0; r < m_cur_n_scales; r++)
+            {
+                int cW = m_scaleSpace[r].cols;
+                int cH = m_scaleSpace[r].rows;
+
+                for (int j = border; j < cH - border; j++)
+                {
+                    for (int i = border; i < cW - border; i++)
+                    {
+                        if (saliency[r][j * cW + i] <= m_th_saliency)
+                            continue;
+
+                        if (m_mask.rows > 0)
+                        {
+                            int j_full = cvRound(j * std::pow(m_scale_factor, r));
+                            int i_full = cvRound(i * std::pow(m_scale_factor, r));
+                            if ((int) m_mask.at<unsigned char>(j_full, i_full) == 0)
+                                continue;
+                        }
+
+                        bool is_max = true;
+
+                        for (int k = cv::max(0, r - m_nms_scale_radius); k <= cv::min(m_cur_n_scales - 1, r + m_nms_scale_radius); k++)
+                        {
+                            if (k != r)
+                            {
+                                int j_sc = cvRound(j * std::pow(m_scale_factor, r - k));
+                                int i_sc = cvRound(i * std::pow(m_scale_factor, r - k));
+
+                                if (saliency[r][j * cW + i] < saliency[k][j_sc * cW + i_sc])
+                                {
+                                    is_max = false;
+                                    break;
+                                }
+                            }
+                        }
+
+                        for (int v = cv::max(border, j - m_nms_radius); v <= cv::min(cH - border - 1, j + m_nms_radius); v++)
+                        {
+                            for (int u = cv::max(border, i - m_nms_radius); u <= cv::min(cW - border - 1, i + m_nms_radius); u++)
+                            {
+                                if (saliency[r][j * cW + i] < saliency[r][v * cW + u])
+                                {
+                                    is_max = false;
+                                    break;
+                                }
+                            }
+
+                            if (!is_max)
+                                break;
+                        }
+
+                        if (is_max)
+                        {
+                            bool resInt = rescalePoint(i, j, r, saliency, kp_temp.pt);
+                            if (!resInt)
+                                continue;
+
+
+                            if (m_mask.rows > 0)
+                            {
+                                if (m_mask.at<unsigned char>((int) kp_temp.pt.y, (int) kp_temp.pt.x) == 0)
+                                    continue;
+                            }
+                            kp_temp.response = saliency[r][j * cW + i];
+                            kp_temp.size = (m_patch_radius * 2.0f + 1) * std::pow(m_scale_factor, (float)r);
+                            kp_temp.octave = r;
+                            if (m_compute_orientation)
+                                kp_temp.angle = computeOrientation(m_scaleSpace[r], i, j, orientPoints);
+
+                            keypoints.push_back(kp_temp);
+                        }
+                    }
+                }
+            }
+
+        }
+
+        Ptr<MSDDetector> MSDDetector::create(int m_patch_radius, int m_search_area_radius,
+                int m_nms_radius, int m_nms_scale_radius, float m_th_saliency, int m_kNN, float m_scale_factor,
+                int m_n_scales, bool m_compute_orientation)
+        {
+            return makePtr<MSDDetector_Impl>(m_patch_radius, m_search_area_radius,
+                    m_nms_radius, m_nms_scale_radius, m_th_saliency, m_kNN, m_scale_factor,
+                    m_n_scales, m_compute_orientation);
+        }
+
+        String MSDDetector::getDefaultName() const
+        {
+            return (Feature2D::getDefaultName() + ".MSD");
+        }
+
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/msd_pyramid.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/msd_pyramid.hpp
new file mode 100644
index 00000000..9b1d9037
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/msd_pyramid.hpp
@@ -0,0 +1,77 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_XFEATURES2D_MSD_PYRAMID_HPP__
+#define __OPENCV_XFEATURES2D_MSD_PYRAMID_HPP__
+
+#include "precomp.hpp"
+
+namespace cv
+{
+namespace xfeatures2d
+{
+/*!
+    MSD Image Pyramid.
+ */
+class MSDImagePyramid
+{
+    // Multi-threaded construction of the scale-space pyramid
+    struct MSDImagePyramidBuilder : ParallelLoopBody
+    {
+
+        MSDImagePyramidBuilder(const cv::Mat& _im, std::vector<cv::Mat>* _m_imPyr, float _scaleFactor)
+        {
+            im = &_im;
+            m_imPyr = _m_imPyr;
+            scaleFactor = _scaleFactor;
+
+        }
+
+        void operator()(const Range& range) const CV_OVERRIDE
+        {
+            for (int lvl = range.start; lvl < range.end; lvl++)
+            {
+                float scale = 1 / std::pow(scaleFactor, (float) lvl);
+                (*m_imPyr)[lvl] = cv::Mat(cv::Size(cvRound(im->cols * scale), cvRound(im->rows * scale)), im->type());
+                cv::resize(*im, (*m_imPyr)[lvl], cv::Size((*m_imPyr)[lvl].cols, (*m_imPyr)[lvl].rows), 0.0, 0.0, cv::INTER_AREA);
+            }
+        }
+        const cv::Mat* im;
+        std::vector<cv::Mat>* m_imPyr;
+        float scaleFactor;
+    };
+
+public:
+
+    MSDImagePyramid(const cv::Mat &im, const int nLevels, const float scaleFactor = 1.6f)
+    {
+        m_nLevels = nLevels;
+        m_scaleFactor = scaleFactor;
+        m_imPyr.clear();
+        m_imPyr.resize(nLevels);
+
+        m_imPyr[0] = im.clone();
+
+        if (m_nLevels > 1)
+        {
+            parallel_for_(Range(1, nLevels), MSDImagePyramidBuilder(im, &m_imPyr, scaleFactor));
+        }
+    }
+    ~MSDImagePyramid() {};
+
+    std::vector<cv::Mat> getImPyr() const
+    {
+        return m_imPyr;
+    };
+
+private:
+
+    std::vector<cv::Mat> m_imPyr;
+    int m_nLevels;
+    float m_scaleFactor;
+};
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/opencl/surf.cl b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/opencl/surf.cl
new file mode 100644
index 00000000..e428f042
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/opencl/surf.cl
@@ -0,0 +1,1405 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Copyright (C) 2013, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//    Sen Liu, swjtuls1987@126.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+// The number of degrees between orientation samples in calcOrientation
+#define ORI_SEARCH_INC  5
+
+// The local size of the calcOrientation kernel
+#define ORI_LOCAL_SIZE  (360 / ORI_SEARCH_INC)
+
+// specialized for non-image2d_t supported platform, intel HD4000, for example
+#ifndef HAVE_IMAGE2D
+__inline uint read_sumTex_(__global uint* sumTex, int sum_step, int img_rows, int img_cols, int2 coord)
+{
+    int x = clamp(coord.x, 0, img_cols);
+    int y = clamp(coord.y, 0, img_rows);
+    return sumTex[sum_step * y + x];
+}
+
+__inline uchar read_imgTex_(__global uchar* imgTex, int img_step, int img_rows, int img_cols, float2 coord)
+{
+    int x = clamp(convert_int_rte(coord.x), 0, img_cols-1);
+    int y = clamp(convert_int_rte(coord.y), 0, img_rows-1);
+    return imgTex[img_step * y + x];
+}
+
+#define read_sumTex(coord) read_sumTex_(sumTex, sum_step, img_rows, img_cols, coord)
+#define read_imgTex(coord) read_imgTex_(imgTex, img_step, img_rows, img_cols, coord)
+
+#define __PARAM_sumTex__ __global uint* sumTex, int sum_step, int sum_offset
+#define __PARAM_imgTex__ __global uchar* imgTex, int img_step, int img_offset
+
+#define __PASS_sumTex__ sumTex, sum_step, sum_offset
+#define __PASS_imgTex__ imgTex, img_step, img_offset
+
+#else
+__inline uint read_sumTex_(image2d_t sumTex, sampler_t sam, int2 coord)
+{
+    return read_imageui(sumTex, sam, coord).x;
+}
+
+__inline uchar read_imgTex_(image2d_t imgTex, sampler_t sam, float2 coord)
+{
+    return (uchar)read_imageui(imgTex, sam, coord).x;
+}
+
+#define read_sumTex(coord) read_sumTex_(sumTex, sampler, coord)
+#define read_imgTex(coord) read_imgTex_(imgTex, sampler, coord)
+
+#define __PARAM_sumTex__ image2d_t sumTex
+#define __PARAM_imgTex__ image2d_t imgTex
+
+#define __PASS_sumTex__ sumTex
+#define __PASS_imgTex__ imgTex
+
+#endif
+
+// dynamically change the precision used for floating type
+
+#if defined (DOUBLE_SUPPORT)
+#ifdef cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64:enable
+#elif defined (cl_amd_fp64)
+#pragma OPENCL EXTENSION cl_amd_fp64:enable
+#endif
+#define F double
+#else
+#define F float
+#endif
+
+// Image read mode
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+#ifndef FLT_EPSILON
+#define FLT_EPSILON (1e-15)
+#endif
+
+#ifndef CV_PI_F
+#define CV_PI_F 3.14159265f
+#endif
+
+////////////////////////////////////////////////////////////////////////
+// Hessian
+
+__inline int calcSize(int octave, int layer)
+{
+    /* Wavelet size at first layer of first octave. */
+    const int HAAR_SIZE0 = 9;
+
+    /* Wavelet size increment between layers. This should be an even number,
+    such that the wavelet sizes in an octave are either all even or all odd.
+    This ensures that when looking for the neighbours of a sample, the layers
+    above and below are aligned correctly. */
+    const int HAAR_SIZE_INC = 6;
+
+    return (HAAR_SIZE0 + HAAR_SIZE_INC * layer) << octave;
+}
+
+// Calculate a derivative in an axis-aligned direction (x or y).  The "plus1"
+// boxes contribute 1 * (area), and the "minus2" box contributes -2 * (area).
+// So the final computation is plus1a + plus1b - 2 * minus2.  The corners are
+// labeled A, B, C, and D, with A being the top left, B being top right, C
+// being bottom left, and D being bottom right.
+F calcAxisAlignedDerivative(
+        int plus1a_A, int plus1a_B, int plus1a_C, int plus1a_D, F plus1a_scale,
+        int plus1b_A, int plus1b_B, int plus1b_C, int plus1b_D, F plus1b_scale,
+        int minus2_A, int minus2_B, int minus2_C, int minus2_D, F minus2_scale)
+{
+    F plus1a = plus1a_A - plus1a_B - plus1a_C + plus1a_D;
+    F plus1b = plus1b_A - plus1b_B - plus1b_C + plus1b_D;
+    F minus2 = minus2_A - minus2_B - minus2_C + minus2_D;
+
+    return (plus1a / plus1a_scale -
+            2.0f * minus2 / minus2_scale +
+            plus1b / plus1b_scale);
+}
+
+//calculate targeted layer per-pixel determinant and trace with an integral image
+__kernel void SURF_calcLayerDetAndTrace(
+    __PARAM_sumTex__, // input integral image
+    int img_rows, int img_cols,
+    int c_nOctaveLayers, int c_octave, int c_layer_rows,
+
+    __global float * det,      // output determinant
+    int det_step, int det_offset,
+    __global float * trace,    // output trace
+    int trace_step, int trace_offset)
+{
+    det_step   /= sizeof(*det);
+    trace_step /= sizeof(*trace);
+    #ifndef HAVE_IMAGE2D
+    sum_step/= sizeof(uint);
+    #endif
+    // Determine the indices
+    const int gridDim_y  = get_num_groups(1) / (c_nOctaveLayers + 2);
+    const int blockIdx_y = get_group_id(1) % gridDim_y;
+    const int blockIdx_z = get_group_id(1) / gridDim_y;
+
+    const int j = get_local_id(0) + get_group_id(0) * get_local_size(0);
+    const int i = get_local_id(1) + blockIdx_y * get_local_size(1);
+    const int layer = blockIdx_z;
+
+    const int size = calcSize(c_octave, layer);
+
+    const int samples_i = 1 + ((img_rows - size) >> c_octave);
+    const int samples_j = 1 + ((img_cols - size) >> c_octave);
+
+    // Ignore pixels where some of the kernel is outside the image
+    const int margin = (size >> 1) >> c_octave;
+
+    if (size <= img_rows && size <= img_cols && i < samples_i && j < samples_j)
+    {
+        int x = j << c_octave;
+        int y = i << c_octave;
+
+        float ratio = (float)size / 9;
+
+        // Precompute some commonly used values, which are used to offset
+        // texture coordinates in the integral image.
+        int r1 = round(ratio);
+        int r2 = round(ratio * 2.0f);
+        int r3 = round(ratio * 3.0f);
+        int r4 = round(ratio * 4.0f);
+        int r5 = round(ratio * 5.0f);
+        int r6 = round(ratio * 6.0f);
+        int r7 = round(ratio * 7.0f);
+        int r8 = round(ratio * 8.0f);
+        int r9 = round(ratio * 9.0f);
+
+        // Calculate the approximated derivative in the x-direction
+        F d = 0;
+        {
+            // Some of the pixels needed to compute the derivative are
+            // repeated, so we only don't duplicate the fetch here.
+            int t02 = read_sumTex( (int2)(x, y + r2));
+            int t07 = read_sumTex( (int2)(x, y + r7));
+            int t32 = read_sumTex( (int2)(x + r3, y + r2));
+            int t37 = read_sumTex( (int2)(x + r3, y + r7));
+            int t62 = read_sumTex( (int2)(x + r6, y + r2));
+            int t67 = read_sumTex( (int2)(x + r6, y + r7));
+            int t92 = read_sumTex( (int2)(x + r9, y + r2));
+            int t97 = read_sumTex( (int2)(x + r9, y + r7));
+
+            d = calcAxisAlignedDerivative(t02, t07, t32, t37, (r3) * (r7 - r2),
+                                          t62, t67, t92, t97, (r9 - r6) * (r7 - r2),
+                                          t32, t37, t62, t67, (r6 - r3) * (r7 - r2));
+        }
+        const float dx  = (float)d;
+
+        // Calculate the approximated derivative in the y-direction
+        d = 0;
+        {
+            // Some of the pixels needed to compute the derivative are
+            // repeated, so we only don't duplicate the fetch here.
+            int t20 = read_sumTex( (int2)(x + r2, y) );
+            int t23 = read_sumTex( (int2)(x + r2, y + r3) );
+            int t70 = read_sumTex( (int2)(x + r7, y) );
+            int t73 = read_sumTex( (int2)(x + r7, y + r3) );
+            int t26 = read_sumTex( (int2)(x + r2, y + r6) );
+            int t76 = read_sumTex( (int2)(x + r7, y + r6) );
+            int t29 = read_sumTex( (int2)(x + r2, y + r9) );
+            int t79 = read_sumTex( (int2)(x + r7, y + r9) );
+
+            d = calcAxisAlignedDerivative(t20, t23, t70, t73, (r7 - r2) * (r3),
+                                          t26, t29, t76, t79, (r7 - r2) * (r9 - r6),
+                                          t23, t26, t73, t76, (r7 - r2) * (r6 - r3));
+        }
+        const float dy  = (float)d;
+
+        // Calculate the approximated derivative in the xy-direction
+        d = 0;
+        {
+            // There's no saving us here, we just have to get all of the pixels in
+            // separate fetches
+            F t = 0;
+            t += read_sumTex( (int2)(x + r1, y + r1) );
+            t -= read_sumTex( (int2)(x + r1, y + r4) );
+            t -= read_sumTex( (int2)(x + r4, y + r1) );
+            t += read_sumTex( (int2)(x + r4, y + r4) );
+            d += t / ((r4 - r1) * (r4 - r1));
+
+            t = 0;
+            t += read_sumTex( (int2)(x + r5, y + r1) );
+            t -= read_sumTex( (int2)(x + r5, y + r4) );
+            t -= read_sumTex( (int2)(x + r8, y + r1) );
+            t += read_sumTex( (int2)(x + r8, y + r4) );
+            d -= t / ((r8 - r5) * (r4 - r1));
+
+            t = 0;
+            t += read_sumTex( (int2)(x + r1, y + r5) );
+            t -= read_sumTex( (int2)(x + r1, y + r8) );
+            t -= read_sumTex( (int2)(x + r4, y + r5) );
+            t += read_sumTex( (int2)(x + r4, y + r8) );
+            d -= t / ((r4 - r1) * (r8 - r5));
+
+            t = 0;
+            t += read_sumTex( (int2)(x + r5, y + r5) );
+            t -= read_sumTex( (int2)(x + r5, y + r8) );
+            t -= read_sumTex( (int2)(x + r8, y + r5) );
+            t += read_sumTex( (int2)(x + r8, y + r8) );
+            d += t / ((r8 - r5) * (r8 - r5));
+        }
+        const float dxy = (float)d;
+
+        det  [j + margin + det_step   * (layer * c_layer_rows + i + margin)] = dx * dy - 0.81f * dxy * dxy;
+        trace[j + margin + trace_step * (layer * c_layer_rows + i + margin)] = dx + dy;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////
+// NONMAX
+
+__kernel
+void SURF_findMaximaInLayer(
+    __global float * det,
+    int det_step, int det_offset,
+    __global float * trace,
+    int trace_step, int trace_offset,
+    __global int4 * maxPosBuffer,
+    volatile __global  int* maxCounter,
+    int counter_offset,
+    int img_rows,
+    int img_cols,
+    int c_nOctaveLayers,
+    int c_octave,
+    int c_layer_rows,
+    int c_layer_cols,
+    int c_max_candidates,
+    float c_hessianThreshold
+)
+{
+    volatile __local  float N9[768]; // threads.x * threads.y * 3
+
+    det_step   /= sizeof(float);
+    trace_step /= sizeof(float);
+    maxCounter += counter_offset;
+
+    // Determine the indices
+    const int gridDim_y  = get_num_groups(1) / c_nOctaveLayers;
+    const int blockIdx_y = get_group_id(1)   % gridDim_y;
+    const int blockIdx_z = get_group_id(1)   / gridDim_y;
+
+    const int layer = blockIdx_z + 1;
+
+    const int size = calcSize(c_octave, layer);
+
+    // Ignore pixels without a 3x3x3 neighbourhood in the layer above
+    const int margin = ((calcSize(c_octave, layer + 1) >> 1) >> c_octave) + 1;
+
+    const int j = get_local_id(0) + get_group_id(0) * (get_local_size(0) - 2) + margin - 1;
+    const int i = get_local_id(1) + blockIdx_y      * (get_local_size(1) - 2) + margin - 1;
+
+    // Is this thread within the hessian buffer?
+    const int zoff     = get_local_size(0) * get_local_size(1);
+    const int localLin = get_local_id(0) + get_local_id(1) * get_local_size(0) + zoff;
+
+    int l_x = min(max(j, 0), img_cols - 1);
+    int l_y = c_layer_rows * layer + min(max(i, 0), img_rows - 1);
+
+    N9[localLin - zoff] =
+        det[det_step * (l_y - c_layer_rows) + l_x];
+    N9[localLin       ] =
+        det[det_step * (l_y               ) + l_x];
+    N9[localLin + zoff] =
+        det[det_step * (l_y + c_layer_rows) + l_x];
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (i < c_layer_rows - margin
+            && j < c_layer_cols - margin
+            && get_local_id(0) > 0
+            && get_local_id(0) < get_local_size(0) - 1
+            && get_local_id(1) > 0
+            && get_local_id(1) < get_local_size(1) - 1 // these are unnecessary conditions ported from CUDA
+       )
+    {
+        float val0 = N9[localLin];
+        if (val0 > c_hessianThreshold)
+        {
+            // Coordinates for the start of the wavelet in the sum image. There
+            // is some integer division involved, so don't try to simplify this
+            // (cancel out sampleStep) without checking the result is the same
+
+            // Check to see if we have a max (in its 26 neighbours)
+            const bool condmax = val0 > N9[localLin - 1 - get_local_size(0) - zoff]
+                                 &&                   val0 > N9[localLin     - get_local_size(0) - zoff]
+                                 &&                   val0 > N9[localLin + 1 - get_local_size(0) - zoff]
+                                 &&                   val0 > N9[localLin - 1                     - zoff]
+                                 &&                   val0 > N9[localLin                         - zoff]
+                                 &&                   val0 > N9[localLin + 1                     - zoff]
+                                 &&                   val0 > N9[localLin - 1 + get_local_size(0) - zoff]
+                                 &&                   val0 > N9[localLin     + get_local_size(0) - zoff]
+                                 &&                   val0 > N9[localLin + 1 + get_local_size(0) - zoff]
+
+                                 &&                   val0 > N9[localLin - 1 - get_local_size(0)]
+                                 &&                   val0 > N9[localLin     - get_local_size(0)]
+                                 &&                   val0 > N9[localLin + 1 - get_local_size(0)]
+                                 &&                   val0 > N9[localLin - 1                    ]
+                                 &&                   val0 > N9[localLin + 1                    ]
+                                 &&                   val0 > N9[localLin - 1 + get_local_size(0)]
+                                 &&                   val0 > N9[localLin     + get_local_size(0)]
+                                 &&                   val0 > N9[localLin + 1 + get_local_size(0)]
+
+                                 &&                   val0 > N9[localLin - 1 - get_local_size(0) + zoff]
+                                 &&                   val0 > N9[localLin     - get_local_size(0) + zoff]
+                                 &&                   val0 > N9[localLin + 1 - get_local_size(0) + zoff]
+                                 &&                   val0 > N9[localLin - 1                     + zoff]
+                                 &&                   val0 > N9[localLin                         + zoff]
+                                 &&                   val0 > N9[localLin + 1                     + zoff]
+                                 &&                   val0 > N9[localLin - 1 + get_local_size(0) + zoff]
+                                 &&                   val0 > N9[localLin     + get_local_size(0) + zoff]
+                                 &&                   val0 > N9[localLin + 1 + get_local_size(0) + zoff]
+                                 ;
+
+            if(condmax)
+            {
+                int ind = atomic_inc(maxCounter);
+
+                if (ind < c_max_candidates)
+                {
+                    const int laplacian = (int) copysign(1.0f, trace[trace_step* (layer * c_layer_rows + i) + j]);
+
+                    maxPosBuffer[ind] = (int4)(j, i, layer, laplacian);
+                }
+            }
+        }
+    }
+}
+
+// solve 3x3 linear system Ax=b for floating point input
+inline bool solve3x3_float(const float4 *A, const float *b, float *x)
+{
+    float det = A[0].x * (A[1].y * A[2].z - A[1].z * A[2].y)
+                - A[0].y * (A[1].x * A[2].z - A[1].z * A[2].x)
+                + A[0].z * (A[1].x * A[2].y - A[1].y * A[2].x);
+
+    if (det != 0)
+    {
+        F invdet = 1.0f / det;
+
+        x[0] = invdet *
+               (b[0]    * (A[1].y * A[2].z - A[1].z * A[2].y) -
+                A[0].y * (b[1]    * A[2].z - A[1].z * b[2]   ) +
+                A[0].z * (b[1]    * A[2].y - A[1].y * b[2]   ));
+
+        x[1] = invdet *
+               (A[0].x * (b[1]    * A[2].z - A[1].z * b[2]   ) -
+                b[0]    * (A[1].x * A[2].z - A[1].z * A[2].x) +
+                A[0].z * (A[1].x * b[2]    - b[1]    * A[2].x));
+
+        x[2] = invdet *
+               (A[0].x * (A[1].y * b[2]    - b[1]    * A[2].y) -
+                A[0].y * (A[1].x * b[2]    - b[1]    * A[2].x) +
+                b[0]    * (A[1].x * A[2].y - A[1].y * A[2].x));
+
+        return true;
+    }
+    return false;
+}
+
+#define X_ROW          0
+#define Y_ROW          1
+#define LAPLACIAN_ROW  2
+#define OCTAVE_ROW     3
+#define SIZE_ROW       4
+#define ANGLE_ROW      5
+#define HESSIAN_ROW    6
+#define ROWS_COUNT     7
+
+////////////////////////////////////////////////////////////////////////
+// INTERPOLATION
+__kernel
+void SURF_interpolateKeypoint(
+    __global const float * det,
+    int det_step, int det_offset,
+    __global const int4 * maxPosBuffer,
+    __global float * keypoints,
+    int keypoints_step, int keypoints_offset,
+    volatile __global int* featureCounter,
+    int img_rows,
+    int img_cols,
+    int c_octave,
+    int c_layer_rows,
+    int c_max_features
+)
+{
+    det_step /= sizeof(*det);
+    keypoints_step /= sizeof(*keypoints);
+    __global float * featureX       = keypoints + X_ROW * keypoints_step;
+    __global float * featureY       = keypoints + Y_ROW * keypoints_step;
+    __global int * featureLaplacian = (__global int *)keypoints + LAPLACIAN_ROW * keypoints_step;
+    __global int * featureOctave    = (__global int *)keypoints + OCTAVE_ROW * keypoints_step;
+    __global float * featureSize    = keypoints + SIZE_ROW * keypoints_step;
+    __global float * featureHessian = keypoints + HESSIAN_ROW * keypoints_step;
+
+    const int4 maxPos = maxPosBuffer[get_group_id(0)];
+
+    const int j = maxPos.x - 1 + get_local_id(0);
+    const int i = maxPos.y - 1 + get_local_id(1);
+    const int layer = maxPos.z - 1 + get_local_id(2);
+
+    volatile __local  float N9[3][3][3];
+
+    N9[get_local_id(2)][get_local_id(1)][get_local_id(0)] =
+        det[det_step * (c_layer_rows * layer + i) + j];
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (get_local_id(0) == 0 && get_local_id(1) == 0 && get_local_id(2) == 0)
+    {
+        float dD[3];
+
+        //dx
+        dD[0] = -0.5f * (N9[1][1][2] - N9[1][1][0]);
+        //dy
+        dD[1] = -0.5f * (N9[1][2][1] - N9[1][0][1]);
+        //ds
+        dD[2] = -0.5f * (N9[2][1][1] - N9[0][1][1]);
+
+        float4 H[3];
+
+        //dxx
+        H[0].x = N9[1][1][0] - 2.0f * N9[1][1][1] + N9[1][1][2];
+        //dxy
+        H[0].y= 0.25f * (N9[1][2][2] - N9[1][2][0] - N9[1][0][2] + N9[1][0][0]);
+        //dxs
+        H[0].z= 0.25f * (N9[2][1][2] - N9[2][1][0] - N9[0][1][2] + N9[0][1][0]);
+        //dyx = dxy
+        H[1].x = H[0].y;
+        //dyy
+        H[1].y = N9[1][0][1] - 2.0f * N9[1][1][1] + N9[1][2][1];
+        //dys
+        H[1].z= 0.25f * (N9[2][2][1] - N9[2][0][1] - N9[0][2][1] + N9[0][0][1]);
+        //dsx = dxs
+        H[2].x = H[0].z;
+        //dsy = dys
+        H[2].y = H[1].z;
+        //dss
+        H[2].z = N9[0][1][1] - 2.0f * N9[1][1][1] + N9[2][1][1];
+
+        float x[3];
+
+        if (solve3x3_float(H, dD, x))
+        {
+            if (fabs(x[0]) <= 1.f && fabs(x[1]) <= 1.f && fabs(x[2]) <= 1.f)
+            {
+                // if the step is within the interpolation region, perform it
+
+                const int size = calcSize(c_octave, maxPos.z);
+
+                const int sum_i = (maxPos.y - ((size >> 1) >> c_octave)) << c_octave;
+                const int sum_j = (maxPos.x - ((size >> 1) >> c_octave)) << c_octave;
+
+                const float center_i = sum_i + (float)(size - 1) / 2;
+                const float center_j = sum_j + (float)(size - 1) / 2;
+
+                const float px = center_j + x[0] * (1 << c_octave);
+                const float py = center_i + x[1] * (1 << c_octave);
+
+                const int ds = size - calcSize(c_octave, maxPos.z - 1);
+                const float psize = round(size + x[2] * ds);
+
+                /* The sampling intervals and wavelet sized for selecting an orientation
+                and building the keypoint descriptor are defined relative to 's' */
+                const float s = psize * 1.2f / 9.0f;
+
+                /* To find the dominant orientation, the gradients in x and y are
+                sampled in a circle of radius 6s using wavelets of size 4s.
+                We ensure the gradient wavelet size is even to ensure the
+                wavelet pattern is balanced and symmetric around its center */
+                const int grad_wav_size = 2 * round(2.0f * s);
+
+                // check when grad_wav_size is too big
+                if ((img_rows + 1) >= grad_wav_size && (img_cols + 1) >= grad_wav_size)
+                {
+                    // Get a new feature index.
+                    int ind = atomic_inc(featureCounter);
+
+                    if (ind < c_max_features)
+                    {
+                        featureX[ind] = px;
+                        featureY[ind] = py;
+                        featureLaplacian[ind] = maxPos.w;
+                        featureOctave[ind] = c_octave;
+                        featureSize[ind] = psize;
+                        featureHessian[ind] = N9[1][1][1];
+                    }
+                } // grad_wav_size check
+            } // If the subpixel interpolation worked
+        }
+    } // If this is thread 0.
+}
+
+////////////////////////////////////////////////////////////////////////
+// Orientation
+
+#define ORI_WIN			 60
+#define ORI_SAMPLES		 113
+
+// The distance between samples in the beginning of the the reduction
+#define ORI_RESPONSE_REDUCTION_WIDTH		 48
+#define ORI_RESPONSE_ARRAY_SIZE			     (ORI_RESPONSE_REDUCTION_WIDTH * 2)
+
+__constant float c_aptX[ORI_SAMPLES] = {-6, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 6};
+__constant float c_aptY[ORI_SAMPLES] = {0, -3, -2, -1, 0, 1, 2, 3, -4, -3, -2, -1, 0, 1, 2, 3, 4, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3, 0};
+__constant float c_aptW[ORI_SAMPLES] = {0.001455130288377404f, 0.001707611023448408f, 0.002547456417232752f, 0.003238451667129993f, 0.0035081731621176f,
+                                        0.003238451667129993f, 0.002547456417232752f, 0.001707611023448408f, 0.002003900473937392f, 0.0035081731621176f, 0.005233579315245152f,
+                                        0.00665318313986063f, 0.00720730796456337f, 0.00665318313986063f, 0.005233579315245152f, 0.0035081731621176f,
+                                        0.002003900473937392f, 0.001707611023448408f, 0.0035081731621176f, 0.006141661666333675f, 0.009162282571196556f,
+                                        0.01164754293859005f, 0.01261763460934162f, 0.01164754293859005f, 0.009162282571196556f, 0.006141661666333675f,
+                                        0.0035081731621176f, 0.001707611023448408f, 0.002547456417232752f, 0.005233579315245152f, 0.009162282571196556f,
+                                        0.01366852037608624f, 0.01737609319388866f, 0.0188232995569706f, 0.01737609319388866f, 0.01366852037608624f,
+                                        0.009162282571196556f, 0.005233579315245152f, 0.002547456417232752f, 0.003238451667129993f, 0.00665318313986063f,
+                                        0.01164754293859005f, 0.01737609319388866f, 0.02208934165537357f, 0.02392910048365593f, 0.02208934165537357f,
+                                        0.01737609319388866f, 0.01164754293859005f, 0.00665318313986063f, 0.003238451667129993f, 0.001455130288377404f,
+                                        0.0035081731621176f, 0.00720730796456337f, 0.01261763460934162f, 0.0188232995569706f, 0.02392910048365593f,
+                                        0.02592208795249462f, 0.02392910048365593f, 0.0188232995569706f, 0.01261763460934162f, 0.00720730796456337f,
+                                        0.0035081731621176f, 0.001455130288377404f, 0.003238451667129993f, 0.00665318313986063f, 0.01164754293859005f,
+                                        0.01737609319388866f, 0.02208934165537357f, 0.02392910048365593f, 0.02208934165537357f, 0.01737609319388866f,
+                                        0.01164754293859005f, 0.00665318313986063f, 0.003238451667129993f, 0.002547456417232752f, 0.005233579315245152f,
+                                        0.009162282571196556f, 0.01366852037608624f, 0.01737609319388866f, 0.0188232995569706f, 0.01737609319388866f,
+                                        0.01366852037608624f, 0.009162282571196556f, 0.005233579315245152f, 0.002547456417232752f, 0.001707611023448408f,
+                                        0.0035081731621176f, 0.006141661666333675f, 0.009162282571196556f, 0.01164754293859005f, 0.01261763460934162f,
+                                        0.01164754293859005f, 0.009162282571196556f, 0.006141661666333675f, 0.0035081731621176f, 0.001707611023448408f,
+                                        0.002003900473937392f, 0.0035081731621176f, 0.005233579315245152f, 0.00665318313986063f, 0.00720730796456337f,
+                                        0.00665318313986063f, 0.005233579315245152f, 0.0035081731621176f, 0.002003900473937392f, 0.001707611023448408f,
+                                        0.002547456417232752f, 0.003238451667129993f, 0.0035081731621176f, 0.003238451667129993f, 0.002547456417232752f,
+                                        0.001707611023448408f, 0.001455130288377404f
+                                       };
+
+__constant float2 c_NX[5] = { (float2)(0, 2), (float2)(0, 0), (float2)(2, 4), (float2)(4, 4), (float2)(-1, 1) };
+__constant float2 c_NY[5] = { (float2)(0, 0), (float2)(0, 2), (float2)(4, 4), (float2)(2, 4), (float2)(1, -1) };
+
+void reduce_32_sum(volatile __local  float * data, volatile float* partial_reduction, int tid)
+{
+#define op(A, B) (*A)+(B)
+    data[tid] = *partial_reduction;
+    barrier(CLK_LOCAL_MEM_FENCE);
+#ifndef WAVE_SIZE
+#define WAVE_SIZE 1
+#endif
+    if (tid < 16)
+    {
+        data[tid] = *partial_reduction = op(partial_reduction, data[tid + 16]);
+#if WAVE_SIZE < 16
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 8)
+    {
+#endif
+        data[tid] = *partial_reduction = op(partial_reduction, data[tid + 8]);
+#if WAVE_SIZE < 8
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 4)
+    {
+#endif
+        data[tid] = *partial_reduction = op(partial_reduction, data[tid + 4]);
+#if WAVE_SIZE < 4
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 2)
+    {
+#endif
+        data[tid] = *partial_reduction = op(partial_reduction, data[tid + 2 ]);
+#if WAVE_SIZE < 2
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 1)
+    {
+#endif
+        data[tid] = *partial_reduction = op(partial_reduction, data[tid + 1 ]);
+    }
+#undef WAVE_SIZE
+#undef op
+}
+
+__kernel
+void SURF_calcOrientation(
+    __PARAM_sumTex__, int img_rows, int img_cols,
+    __global float * keypoints, int keypoints_step, int keypoints_offset )
+{
+    keypoints_step /= sizeof(*keypoints);
+    #ifndef HAVE_IMAGE2D
+    sum_step       /= sizeof(uint);
+    #endif
+    __global float* featureX    = keypoints + X_ROW * keypoints_step;
+    __global float* featureY    = keypoints + Y_ROW * keypoints_step;
+    __global float* featureSize = keypoints + SIZE_ROW * keypoints_step;
+    __global float* featureDir  = keypoints + ANGLE_ROW * keypoints_step;
+
+    __local  float s_X[ORI_SAMPLES];
+    __local  float s_Y[ORI_SAMPLES];
+    __local  float s_angle[ORI_SAMPLES];
+
+    // Need to allocate enough to make the reduction work without accessing
+    // past the end of the array.
+    __local  float s_sumx[ORI_RESPONSE_ARRAY_SIZE];
+    __local  float s_sumy[ORI_RESPONSE_ARRAY_SIZE];
+    __local  float s_mod[ORI_RESPONSE_ARRAY_SIZE];
+
+    /* The sampling intervals and wavelet sized for selecting an orientation
+    and building the keypoint descriptor are defined relative to 's' */
+    const float s = featureSize[get_group_id(0)] * 1.2f / 9.0f;
+
+    /* To find the dominant orientation, the gradients in x and y are
+    sampled in a circle of radius 6s using wavelets of size 4s.
+    We ensure the gradient wavelet size is even to ensure the
+    wavelet pattern is balanced and symmetric around its center */
+    const int grad_wav_size = 2 * round(2.0f * s);
+
+    // check when grad_wav_size is too big
+    if ((img_rows + 1) < grad_wav_size || (img_cols + 1) < grad_wav_size)
+        return;
+
+    // Calc X, Y, angle and store it to shared memory
+    const int tid = get_local_id(0);
+    // Initialize values that are only used as part of the reduction later.
+    if (tid < ORI_RESPONSE_ARRAY_SIZE - ORI_LOCAL_SIZE) {
+        s_mod[tid + ORI_LOCAL_SIZE] = 0.0f;
+    }
+
+    float ratio = (float)grad_wav_size / 4;
+
+    int r2 = round(ratio * 2.0f);
+    int r4 = round(ratio * 4.0f);
+    for (int i = tid; i < ORI_SAMPLES; i += ORI_LOCAL_SIZE )
+    {
+        float X = 0.0f, Y = 0.0f, angle = 0.0f;
+        const float margin = (float)(grad_wav_size - 1) / 2.0f;
+        const int x = round(featureX[get_group_id(0)] + c_aptX[i] * s - margin);
+        const int y = round(featureY[get_group_id(0)] + c_aptY[i] * s - margin);
+
+        if (y >= 0 && y < (img_rows + 1) - grad_wav_size &&
+            x >= 0 && x < (img_cols + 1) - grad_wav_size)
+        {
+            float apt = c_aptW[i];
+
+            // Compute the haar sum without fetching duplicate pixels.
+            float t00 = read_sumTex( (int2)(x, y));
+            float t02 = read_sumTex( (int2)(x, y + r2));
+            float t04 = read_sumTex( (int2)(x, y + r4));
+            float t20 = read_sumTex( (int2)(x + r2, y));
+            float t24 = read_sumTex( (int2)(x + r2, y + r4));
+            float t40 = read_sumTex( (int2)(x + r4, y));
+            float t42 = read_sumTex( (int2)(x + r4, y + r2));
+            float t44 = read_sumTex( (int2)(x + r4, y + r4));
+
+            F t = t00 - t04 - t20 + t24;
+            X -= t / ((r2) * (r4));
+
+            t = t20 - t24 - t40 + t44;
+            X += t / ((r4 - r2) * (r4));
+
+            t = t00 - t02 - t40 + t42;
+            Y += t / ((r2) * (r4));
+
+            t = t02 - t04 - t42 + t44;
+            Y -= t  / ((r4) * (r4 - r2));
+
+            X = apt*X;
+            Y = apt*Y;
+
+            angle = atan2(Y, X);
+
+            if (angle < 0)
+                angle += 2.0f * CV_PI_F;
+            angle *= 180.0f / CV_PI_F;
+
+        }
+
+        s_X[i] = X;
+        s_Y[i] = Y;
+        s_angle[i] = angle;
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    float bestx = 0, besty = 0, best_mod = 0;
+    float sumx = 0.0f, sumy = 0.0f;
+    const int dir = tid * ORI_SEARCH_INC;
+    #pragma unroll
+    for (int i = 0; i < ORI_SAMPLES; ++i) {
+        int angle = round(s_angle[i]);
+
+        int d = abs(angle - dir);
+        if (d < ORI_WIN / 2 || d > 360 - ORI_WIN / 2)
+        {
+            sumx += s_X[i];
+            sumy += s_Y[i];
+        }
+    }
+    s_sumx[tid] = sumx;
+    s_sumy[tid] = sumy;
+    s_mod[tid] = sumx*sumx + sumy*sumy;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // This reduction searches for the longest wavelet response vector.  The first
+    // step uses all of the work items in the workgroup to narrow the search
+    // down to the three candidates.  It requires s_mod to have a few more
+    // elements allocated past the work-group size, which are pre-initialized to
+    // 0.0f above.
+    for(int t = ORI_RESPONSE_REDUCTION_WIDTH; t >= 3; t /= 2) {
+        if (tid < t) {
+            if (s_mod[tid] < s_mod[tid + t]) {
+                s_mod[tid] = s_mod[tid + t];
+                s_sumx[tid] = s_sumx[tid + t];
+                s_sumy[tid] = s_sumy[tid + t];
+            }
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+
+    // Do the final reduction and write out the result.
+    if (tid == 0)
+    {
+        int bestIdx = 0;
+
+        // The loop above narrowed the search of the longest vector to three
+        // possibilities.  Pick the best here.
+        if (s_mod[1] > s_mod[bestIdx])
+            bestIdx = 1;
+        if (s_mod[2] > s_mod[bestIdx])
+            bestIdx = 2;
+
+        float kp_dir = atan2(s_sumy[bestIdx], s_sumx[bestIdx]);
+        if (kp_dir < 0)
+            kp_dir += 2.0f * CV_PI_F;
+        kp_dir *= 180.0f / CV_PI_F;
+
+        kp_dir = 360.0f - kp_dir;
+        if (fabs(kp_dir - 360.f) < FLT_EPSILON)
+            kp_dir = 0.f;
+
+        featureDir[get_group_id(0)] = kp_dir;
+    }
+}
+
+__kernel
+void SURF_setUpRight(
+    __global float * keypoints,
+    int keypoints_step, int keypoints_offset,
+    int rows, int cols )
+{
+    int i = get_global_id(0);
+    keypoints_step /= sizeof(*keypoints);
+
+    if(i < cols)
+    {
+        keypoints[mad24(keypoints_step, ANGLE_ROW, i)] = 270.f;
+    }
+}
+
+
+#undef ORI_SEARCH_INC
+#undef ORI_WIN
+#undef ORI_SAMPLES
+
+////////////////////////////////////////////////////////////////////////
+// Descriptors
+
+#define PATCH_SZ 20
+
+__constant float c_DW[PATCH_SZ * PATCH_SZ] =
+{
+    3.695352233989979e-006f, 8.444558261544444e-006f, 1.760426494001877e-005f, 3.34794785885606e-005f, 5.808438800158911e-005f, 9.193058212986216e-005f, 0.0001327334757661447f, 0.0001748319627949968f, 0.0002100782439811155f, 0.0002302826324012131f, 0.0002302826324012131f, 0.0002100782439811155f, 0.0001748319627949968f, 0.0001327334757661447f, 9.193058212986216e-005f, 5.808438800158911e-005f, 3.34794785885606e-005f, 1.760426494001877e-005f, 8.444558261544444e-006f, 3.695352233989979e-006f,
+    8.444558261544444e-006f, 1.929736572492402e-005f, 4.022897701361217e-005f, 7.650675252079964e-005f, 0.0001327334903180599f, 0.0002100782585330308f, 0.0003033203829545528f, 0.0003995231236331165f, 0.0004800673632416874f, 0.0005262381164357066f, 0.0005262381164357066f, 0.0004800673632416874f, 0.0003995231236331165f, 0.0003033203829545528f, 0.0002100782585330308f, 0.0001327334903180599f, 7.650675252079964e-005f, 4.022897701361217e-005f, 1.929736572492402e-005f, 8.444558261544444e-006f,
+    1.760426494001877e-005f, 4.022897701361217e-005f, 8.386484114453197e-005f, 0.0001594926579855382f, 0.0002767078403849155f, 0.0004379475140012801f, 0.0006323281559161842f, 0.0008328808471560478f, 0.001000790391117334f, 0.001097041997127235f, 0.001097041997127235f, 0.001000790391117334f, 0.0008328808471560478f, 0.0006323281559161842f, 0.0004379475140012801f, 0.0002767078403849155f, 0.0001594926579855382f, 8.386484114453197e-005f, 4.022897701361217e-005f, 1.760426494001877e-005f,
+    3.34794785885606e-005f, 7.650675252079964e-005f, 0.0001594926579855382f, 0.0003033203247468919f, 0.0005262380582280457f, 0.0008328807889483869f, 0.001202550483867526f, 0.001583957928232849f, 0.001903285388834775f, 0.002086334861814976f, 0.002086334861814976f, 0.001903285388834775f, 0.001583957928232849f, 0.001202550483867526f, 0.0008328807889483869f, 0.0005262380582280457f, 0.0003033203247468919f, 0.0001594926579855382f, 7.650675252079964e-005f, 3.34794785885606e-005f,
+    5.808438800158911e-005f, 0.0001327334903180599f, 0.0002767078403849155f, 0.0005262380582280457f, 0.0009129836107604206f, 0.001444985857233405f, 0.002086335094645619f, 0.002748048631474376f, 0.00330205773934722f, 0.003619635012000799f, 0.003619635012000799f, 0.00330205773934722f, 0.002748048631474376f, 0.002086335094645619f, 0.001444985857233405f, 0.0009129836107604206f, 0.0005262380582280457f, 0.0002767078403849155f, 0.0001327334903180599f, 5.808438800158911e-005f,
+    9.193058212986216e-005f, 0.0002100782585330308f, 0.0004379475140012801f, 0.0008328807889483869f, 0.001444985857233405f, 0.002286989474669099f, 0.00330205773934722f, 0.004349356517195702f, 0.00522619066759944f, 0.005728822201490402f, 0.005728822201490402f, 0.00522619066759944f, 0.004349356517195702f, 0.00330205773934722f, 0.002286989474669099f, 0.001444985857233405f, 0.0008328807889483869f, 0.0004379475140012801f, 0.0002100782585330308f, 9.193058212986216e-005f,
+    0.0001327334757661447f, 0.0003033203829545528f, 0.0006323281559161842f, 0.001202550483867526f, 0.002086335094645619f, 0.00330205773934722f, 0.004767658654600382f, 0.006279794964939356f, 0.007545807864516974f, 0.008271530270576477f, 0.008271530270576477f, 0.007545807864516974f, 0.006279794964939356f, 0.004767658654600382f, 0.00330205773934722f, 0.002086335094645619f, 0.001202550483867526f, 0.0006323281559161842f, 0.0003033203829545528f, 0.0001327334757661447f,
+    0.0001748319627949968f, 0.0003995231236331165f, 0.0008328808471560478f, 0.001583957928232849f, 0.002748048631474376f, 0.004349356517195702f, 0.006279794964939356f, 0.008271529339253902f, 0.009939077310264111f, 0.01089497376233339f, 0.01089497376233339f, 0.009939077310264111f, 0.008271529339253902f, 0.006279794964939356f, 0.004349356517195702f, 0.002748048631474376f, 0.001583957928232849f, 0.0008328808471560478f, 0.0003995231236331165f, 0.0001748319627949968f,
+    0.0002100782439811155f, 0.0004800673632416874f, 0.001000790391117334f, 0.001903285388834775f, 0.00330205773934722f, 0.00522619066759944f, 0.007545807864516974f, 0.009939077310264111f, 0.01194280479103327f, 0.01309141051024199f, 0.01309141051024199f, 0.01194280479103327f, 0.009939077310264111f, 0.007545807864516974f, 0.00522619066759944f, 0.00330205773934722f, 0.001903285388834775f, 0.001000790391117334f, 0.0004800673632416874f, 0.0002100782439811155f,
+    0.0002302826324012131f, 0.0005262381164357066f, 0.001097041997127235f, 0.002086334861814976f, 0.003619635012000799f, 0.005728822201490402f, 0.008271530270576477f, 0.01089497376233339f, 0.01309141051024199f, 0.01435048412531614f, 0.01435048412531614f, 0.01309141051024199f, 0.01089497376233339f, 0.008271530270576477f, 0.005728822201490402f, 0.003619635012000799f, 0.002086334861814976f, 0.001097041997127235f, 0.0005262381164357066f, 0.0002302826324012131f,
+    0.0002302826324012131f, 0.0005262381164357066f, 0.001097041997127235f, 0.002086334861814976f, 0.003619635012000799f, 0.005728822201490402f, 0.008271530270576477f, 0.01089497376233339f, 0.01309141051024199f, 0.01435048412531614f, 0.01435048412531614f, 0.01309141051024199f, 0.01089497376233339f, 0.008271530270576477f, 0.005728822201490402f, 0.003619635012000799f, 0.002086334861814976f, 0.001097041997127235f, 0.0005262381164357066f, 0.0002302826324012131f,
+    0.0002100782439811155f, 0.0004800673632416874f, 0.001000790391117334f, 0.001903285388834775f, 0.00330205773934722f, 0.00522619066759944f, 0.007545807864516974f, 0.009939077310264111f, 0.01194280479103327f, 0.01309141051024199f, 0.01309141051024199f, 0.01194280479103327f, 0.009939077310264111f, 0.007545807864516974f, 0.00522619066759944f, 0.00330205773934722f, 0.001903285388834775f, 0.001000790391117334f, 0.0004800673632416874f, 0.0002100782439811155f,
+    0.0001748319627949968f, 0.0003995231236331165f, 0.0008328808471560478f, 0.001583957928232849f, 0.002748048631474376f, 0.004349356517195702f, 0.006279794964939356f, 0.008271529339253902f, 0.009939077310264111f, 0.01089497376233339f, 0.01089497376233339f, 0.009939077310264111f, 0.008271529339253902f, 0.006279794964939356f, 0.004349356517195702f, 0.002748048631474376f, 0.001583957928232849f, 0.0008328808471560478f, 0.0003995231236331165f, 0.0001748319627949968f,
+    0.0001327334757661447f, 0.0003033203829545528f, 0.0006323281559161842f, 0.001202550483867526f, 0.002086335094645619f, 0.00330205773934722f, 0.004767658654600382f, 0.006279794964939356f, 0.007545807864516974f, 0.008271530270576477f, 0.008271530270576477f, 0.007545807864516974f, 0.006279794964939356f, 0.004767658654600382f, 0.00330205773934722f, 0.002086335094645619f, 0.001202550483867526f, 0.0006323281559161842f, 0.0003033203829545528f, 0.0001327334757661447f,
+    9.193058212986216e-005f, 0.0002100782585330308f, 0.0004379475140012801f, 0.0008328807889483869f, 0.001444985857233405f, 0.002286989474669099f, 0.00330205773934722f, 0.004349356517195702f, 0.00522619066759944f, 0.005728822201490402f, 0.005728822201490402f, 0.00522619066759944f, 0.004349356517195702f, 0.00330205773934722f, 0.002286989474669099f, 0.001444985857233405f, 0.0008328807889483869f, 0.0004379475140012801f, 0.0002100782585330308f, 9.193058212986216e-005f,
+    5.808438800158911e-005f, 0.0001327334903180599f, 0.0002767078403849155f, 0.0005262380582280457f, 0.0009129836107604206f, 0.001444985857233405f, 0.002086335094645619f, 0.002748048631474376f, 0.00330205773934722f, 0.003619635012000799f, 0.003619635012000799f, 0.00330205773934722f, 0.002748048631474376f, 0.002086335094645619f, 0.001444985857233405f, 0.0009129836107604206f, 0.0005262380582280457f, 0.0002767078403849155f, 0.0001327334903180599f, 5.808438800158911e-005f,
+    3.34794785885606e-005f, 7.650675252079964e-005f, 0.0001594926579855382f, 0.0003033203247468919f, 0.0005262380582280457f, 0.0008328807889483869f, 0.001202550483867526f, 0.001583957928232849f, 0.001903285388834775f, 0.002086334861814976f, 0.002086334861814976f, 0.001903285388834775f, 0.001583957928232849f, 0.001202550483867526f, 0.0008328807889483869f, 0.0005262380582280457f, 0.0003033203247468919f, 0.0001594926579855382f, 7.650675252079964e-005f, 3.34794785885606e-005f,
+    1.760426494001877e-005f, 4.022897701361217e-005f, 8.386484114453197e-005f, 0.0001594926579855382f, 0.0002767078403849155f, 0.0004379475140012801f, 0.0006323281559161842f, 0.0008328808471560478f, 0.001000790391117334f, 0.001097041997127235f, 0.001097041997127235f, 0.001000790391117334f, 0.0008328808471560478f, 0.0006323281559161842f, 0.0004379475140012801f, 0.0002767078403849155f, 0.0001594926579855382f, 8.386484114453197e-005f, 4.022897701361217e-005f, 1.760426494001877e-005f,
+    8.444558261544444e-006f, 1.929736572492402e-005f, 4.022897701361217e-005f, 7.650675252079964e-005f, 0.0001327334903180599f, 0.0002100782585330308f, 0.0003033203829545528f, 0.0003995231236331165f, 0.0004800673632416874f, 0.0005262381164357066f, 0.0005262381164357066f, 0.0004800673632416874f, 0.0003995231236331165f, 0.0003033203829545528f, 0.0002100782585330308f, 0.0001327334903180599f, 7.650675252079964e-005f, 4.022897701361217e-005f, 1.929736572492402e-005f, 8.444558261544444e-006f,
+    3.695352233989979e-006f, 8.444558261544444e-006f, 1.760426494001877e-005f, 3.34794785885606e-005f, 5.808438800158911e-005f, 9.193058212986216e-005f, 0.0001327334757661447f, 0.0001748319627949968f, 0.0002100782439811155f, 0.0002302826324012131f, 0.0002302826324012131f, 0.0002100782439811155f, 0.0001748319627949968f, 0.0001327334757661447f, 9.193058212986216e-005f, 5.808438800158911e-005f, 3.34794785885606e-005f, 1.760426494001877e-005f, 8.444558261544444e-006f, 3.695352233989979e-006f
+};
+
+// utility for linear filter
+#define readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, i, j) \
+    read_imgTex((float2)(centerX + (win_offset + j) * cos_dir + (win_offset + i) * sin_dir, \
+                         centerY - (win_offset + j) * sin_dir + (win_offset + i) * cos_dir))
+
+inline float linearFilter(
+    __PARAM_imgTex__, int img_rows, int img_cols,
+    float centerX, float centerY, float win_offset,
+    float cos_dir, float sin_dir, float y, float x )
+{
+    float out = 0.0f;
+
+    const int x1 = round(x);
+    const int y1 = round(y);
+    const int x2 = x1 + 1;
+    const int y2 = y1 + 1;
+
+    uchar src_reg = readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, y1, x1);
+    out = out + src_reg * ((x2 - x) * (y2 - y));
+
+    src_reg = readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, y1, x2);
+    out = out + src_reg * ((x - x1) * (y2 - y));
+
+    src_reg = readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, y2, x1);
+    out = out + src_reg * ((x2 - x) * (y - y1));
+
+    src_reg = readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, y2, x2);
+    out = out + src_reg * ((x - x1) * (y - y1));
+
+    return out;
+}
+
+inline float areaFilter( __PARAM_imgTex__, int img_rows, int img_cols,
+    float centerX, float centerY, float win_offset,
+    float cos_dir, float sin_dir, float x, float y, float s)
+{
+    float fsx1 = x * s;
+    float fsx2 = fsx1 + s;
+
+    int sx1 = convert_int_rtp(fsx1);
+    int sx2 = convert_int_rtn(fsx2);
+
+    float fsy1 = y * s;
+    float fsy2 = fsy1 + s;
+
+    int sy1 = convert_int_rtp(fsy1);
+    int sy2 = convert_int_rtn(fsy2);
+
+    float scale = 1.f / (s * s);
+    float out = 0.f;
+
+    for (int dy = sy1; dy < sy2; ++dy)
+    {
+        for (int dx = sx1; dx < sx2; ++dx)
+            out = out + readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, dy, dx) * scale;
+
+        if (sx1 > fsx1)
+            out = out + readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, dy, (sx1 -1)) * ((sx1 - fsx1) * scale);
+
+        if (sx2 < fsx2)
+            out = out + readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, dy, sx2) * ((fsx2 -sx2) * scale);
+    }
+
+    if (sy1 > fsy1)
+        for (int dx = sx1; dx < sx2; ++dx)
+            out = out + readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, (sy1 - 1) , dx) * ((sy1 -fsy1) * scale);
+
+    if (sy2 < fsy2)
+        for (int dx = sx1; dx < sx2; ++dx)
+            out = out + readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, sy2, dx) * ((fsy2 -sy2) * scale);
+
+    if ((sy1 > fsy1) &&  (sx1 > fsx1))
+        out = out + readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, (sy1 - 1) , (sx1 - 1)) * ((sy1 -fsy1) * (sx1 -fsx1) * scale);
+
+    if ((sy1 > fsy1) &&  (sx2 < fsx2))
+        out = out + readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, (sy1 - 1) , sx2) * ((sy1 -fsy1) * (fsx2 -sx2) * scale);
+
+    if ((sy2 < fsy2) &&  (sx2 < fsx2))
+        out = out + readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, sy2, sx2) * ((fsy2 -sy2) * (fsx2 -sx2) * scale);
+
+    if ((sy2 < fsy2) &&  (sx1 > fsx1))
+        out = out + readerGet(centerX, centerY, win_offset, cos_dir, sin_dir, sy2, (sx1 - 1)) * ((fsy2 -sy2) * (sx1 -fsx1) * scale);
+
+    return out;
+}
+
+void calc_dx_dy(
+    __PARAM_imgTex__,
+    int img_rows, int img_cols,
+    volatile __local  float *s_dx_bin,
+    volatile __local  float *s_dy_bin,
+    volatile __local  float *s_PATCH,
+    __global const float* featureX,
+    __global const float* featureY,
+    __global const float* featureSize,
+    __global const float* featureDir )
+{
+    const float centerX = featureX[get_group_id(0)];
+    const float centerY = featureY[get_group_id(0)];
+    const float size = featureSize[get_group_id(0)];
+    float descriptor_dir = 360.0f - featureDir[get_group_id(0)];
+    if(fabs(descriptor_dir - 360.0f) < FLT_EPSILON)
+    {
+        descriptor_dir = 0.0f;
+    }
+
+    descriptor_dir *= (float)(CV_PI_F / 180.0f);
+
+    /* The sampling intervals and wavelet sized for selecting an orientation
+    and building the keypoint descriptor are defined relative to 's' */
+    const float s = size * 1.2f / 9.0f;
+
+    /* Extract a window of pixels around the keypoint of size 20s */
+    const int win_size = (int)((PATCH_SZ + 1) * s);
+
+    float sin_dir;
+    float cos_dir;
+    sin_dir = sincos(descriptor_dir, &cos_dir);
+
+    /* Nearest neighbour version (faster) */
+    const float win_offset = -(float)(win_size - 1) / 2;
+
+    // Compute sampling points
+    // since grids are 2D, need to compute xBlock and yBlock indices
+    const int xBlock = (get_group_id(1) & 3);  // get_group_id(1) % 4
+    const int yBlock = (get_group_id(1) >> 2); // floor(get_group_id(1)/4)
+    const int xIndex = xBlock * 5 + get_local_id(0);
+    const int yIndex = yBlock * 5 + get_local_id(1);
+
+    const float icoo = ((float)yIndex / (PATCH_SZ + 1)) * win_size;
+    const float jcoo = ((float)xIndex / (PATCH_SZ + 1)) * win_size;
+
+    if (s > 1)
+    {
+        s_PATCH[get_local_id(1) * 6 + get_local_id(0)] =
+            areaFilter(__PASS_imgTex__, img_rows, img_cols, centerX, centerY,
+                win_offset, cos_dir, sin_dir, xIndex, yIndex, s);
+    }
+    else
+    {
+        s_PATCH[get_local_id(1) * 6 + get_local_id(0)] =
+            linearFilter(__PASS_imgTex__, img_rows, img_cols, centerX, centerY,
+                win_offset, cos_dir, sin_dir, icoo, jcoo);
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (get_local_id(0) < 5 && get_local_id(1) < 5)
+    {
+        const int tid = get_local_id(1) * 5 + get_local_id(0);
+
+        const float dw = c_DW[yIndex * PATCH_SZ + xIndex];
+
+        const float vx = (
+                             s_PATCH[      get_local_id(1) * 6 + get_local_id(0) + 1] -
+                             s_PATCH[      get_local_id(1) * 6 + get_local_id(0)    ] +
+                             s_PATCH[(get_local_id(1) + 1) * 6 + get_local_id(0) + 1] -
+                             s_PATCH[(get_local_id(1) + 1) * 6 + get_local_id(0)    ])
+                         * dw;
+        const float vy = (
+                             s_PATCH[(get_local_id(1) + 1) * 6 + get_local_id(0)    ] -
+                             s_PATCH[      get_local_id(1) * 6 + get_local_id(0)    ] +
+                             s_PATCH[(get_local_id(1) + 1) * 6 + get_local_id(0) + 1] -
+                             s_PATCH[      get_local_id(1) * 6 + get_local_id(0) + 1])
+                         * dw;
+        s_dx_bin[tid] = vx;
+        s_dy_bin[tid] = vy;
+    }
+}
+
+void reduce_sum25(
+    volatile __local  float* sdata1,
+    volatile __local  float* sdata2,
+    volatile __local  float* sdata3,
+    volatile __local  float* sdata4,
+    int tid
+)
+{
+#ifndef WAVE_SIZE
+#define WAVE_SIZE 1
+#endif
+    // first step is to reduce from 25 to 16
+    if (tid < 9)
+    {
+        sdata1[tid] += sdata1[tid + 16];
+        sdata2[tid] += sdata2[tid + 16];
+        sdata3[tid] += sdata3[tid + 16];
+        sdata4[tid] += sdata4[tid + 16];
+#if WAVE_SIZE < 16
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 8)
+    {
+#endif
+        sdata1[tid] += sdata1[tid + 8];
+        sdata2[tid] += sdata2[tid + 8];
+        sdata3[tid] += sdata3[tid + 8];
+        sdata4[tid] += sdata4[tid + 8];
+#if WAVE_SIZE < 8
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 4)
+    {
+#endif
+        sdata1[tid] += sdata1[tid + 4];
+        sdata2[tid] += sdata2[tid + 4];
+        sdata3[tid] += sdata3[tid + 4];
+        sdata4[tid] += sdata4[tid + 4];
+#if WAVE_SIZE < 4
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 2)
+    {
+#endif
+        sdata1[tid] += sdata1[tid + 2];
+        sdata2[tid] += sdata2[tid + 2];
+        sdata3[tid] += sdata3[tid + 2];
+        sdata4[tid] += sdata4[tid + 2];
+#if WAVE_SIZE < 2
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 1)
+    {
+#endif
+        sdata1[tid] += sdata1[tid + 1];
+        sdata2[tid] += sdata2[tid + 1];
+        sdata3[tid] += sdata3[tid + 1];
+        sdata4[tid] += sdata4[tid + 1];
+    }
+#undef WAVE_SIZE
+}
+
+__kernel
+void SURF_computeDescriptors64(
+    __PARAM_imgTex__,
+    int img_rows, int img_cols,
+    __global const float* keypoints,
+    int keypoints_step, int keypoints_offset,
+    __global float * descriptors,
+    int descriptors_step, int descriptors_offset)
+{
+    descriptors_step /= sizeof(float);
+    keypoints_step   /= sizeof(float);
+    __global const float * featureX    = keypoints + X_ROW * keypoints_step;
+    __global const float * featureY    = keypoints + Y_ROW * keypoints_step;
+    __global const float * featureSize = keypoints + SIZE_ROW * keypoints_step;
+    __global const float * featureDir  = keypoints + ANGLE_ROW * keypoints_step;
+
+    // 2 floats (dx,dy) for each thread (5x5 sample points in each sub-region)
+    volatile __local  float sdx[25];
+    volatile __local  float sdy[25];
+    volatile __local  float sdxabs[25];
+    volatile __local  float sdyabs[25];
+    volatile __local  float s_PATCH[6*6];
+
+    calc_dx_dy(__PASS_imgTex__, img_rows, img_cols, sdx, sdy, s_PATCH, featureX, featureY, featureSize, featureDir);
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    const int tid = get_local_id(1) * get_local_size(0) + get_local_id(0);
+
+    if (tid < 25)
+    {
+        sdxabs[tid] = fabs(sdx[tid]); // |dx| array
+        sdyabs[tid] = fabs(sdy[tid]); // |dy| array
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    reduce_sum25(sdx, sdy, sdxabs, sdyabs, tid);
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid == 0)
+    {
+        __global float* descriptors_block = descriptors + descriptors_step * get_group_id(0) + (get_group_id(1) << 2);
+
+        // write dx, dy, |dx|, |dy|
+
+        descriptors_block[0] = sdx[0];
+        descriptors_block[1] = sdy[0];
+        descriptors_block[2] = sdxabs[0];
+        descriptors_block[3] = sdyabs[0];
+    }
+}
+
+__kernel
+void SURF_computeDescriptors128(
+    __PARAM_imgTex__,
+    int img_rows, int img_cols,
+    __global const float* keypoints,
+    int keypoints_step, int keypoints_offset,
+    __global float* descriptors,
+    int descriptors_step, int descriptors_offset)
+{
+    descriptors_step /= sizeof(*descriptors);
+    keypoints_step   /= sizeof(*keypoints);
+
+    __global const float * featureX   = keypoints + X_ROW * keypoints_step;
+    __global const float * featureY   = keypoints + Y_ROW * keypoints_step;
+    __global const float* featureSize = keypoints + SIZE_ROW * keypoints_step;
+    __global const float* featureDir  = keypoints + ANGLE_ROW * keypoints_step;
+
+    // 2 floats (dx,dy) for each thread (5x5 sample points in each sub-region)
+    volatile __local  float sdx[25];
+    volatile __local  float sdy[25];
+
+    // sum (reduce) 5x5 area response
+    volatile __local  float sd1[25];
+    volatile __local  float sd2[25];
+    volatile __local  float sdabs1[25];
+    volatile __local  float sdabs2[25];
+    volatile __local  float s_PATCH[6*6];
+
+    calc_dx_dy(__PASS_imgTex__, img_rows, img_cols, sdx, sdy, s_PATCH, featureX, featureY, featureSize, featureDir);
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    const int tid = get_local_id(1) * get_local_size(0) + get_local_id(0);
+
+    if (tid < 25)
+    {
+        if (sdy[tid] >= 0)
+        {
+            sd1[tid] = sdx[tid];
+            sdabs1[tid] = fabs(sdx[tid]);
+            sd2[tid] = 0;
+            sdabs2[tid] = 0;
+        }
+        else
+        {
+            sd1[tid] = 0;
+            sdabs1[tid] = 0;
+            sd2[tid] = sdx[tid];
+            sdabs2[tid] = fabs(sdx[tid]);
+        }
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    reduce_sum25(sd1, sd2, sdabs1, sdabs2, tid);
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    __global float* descriptors_block = descriptors + descriptors_step * get_group_id(0) + (get_group_id(1) << 3);
+    if (tid < 25)
+    {
+        // write dx (dy >= 0), |dx| (dy >= 0), dx (dy < 0), |dx| (dy < 0)
+        if (tid == 0)
+        {
+            descriptors_block[0] = sd1[0];
+            descriptors_block[1] = sdabs1[0];
+            descriptors_block[2] = sd2[0];
+            descriptors_block[3] = sdabs2[0];
+        }
+
+        if (sdx[tid] >= 0)
+        {
+            sd1[tid] = sdy[tid];
+            sdabs1[tid] = fabs(sdy[tid]);
+            sd2[tid] = 0;
+            sdabs2[tid] = 0;
+        }
+        else
+        {
+            sd1[tid] = 0;
+            sdabs1[tid] = 0;
+            sd2[tid] = sdy[tid];
+            sdabs2[tid] = fabs(sdy[tid]);
+        }
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    reduce_sum25(sd1, sd2, sdabs1, sdabs2, tid);
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (tid < 25)
+    {
+        // write dy (dx >= 0), |dy| (dx >= 0), dy (dx < 0), |dy| (dx < 0)
+        if (tid == 0)
+        {
+            descriptors_block[4] = sd1[0];
+            descriptors_block[5] = sdabs1[0];
+            descriptors_block[6] = sd2[0];
+            descriptors_block[7] = sdabs2[0];
+        }
+    }
+}
+
+void reduce_sum128(volatile __local  float* smem, int tid)
+{
+#ifndef WAVE_SIZE
+#define WAVE_SIZE 1
+#endif
+
+    if (tid < 64)
+    {
+        smem[tid] += smem[tid + 64];
+#if WAVE_SIZE < 64
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 32)
+    {
+#endif
+        smem[tid] += smem[tid + 32];
+#if WAVE_SIZE < 32
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 16)
+    {
+#endif
+        smem[tid] += smem[tid + 16];
+#if WAVE_SIZE < 16
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 8)
+    {
+#endif
+        smem[tid] += smem[tid + 8];
+#if WAVE_SIZE < 8
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 4)
+    {
+#endif
+        smem[tid] += smem[tid + 4];
+#if WAVE_SIZE < 4
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 2)
+    {
+#endif
+        smem[tid] += smem[tid + 2];
+#if WAVE_SIZE < 2
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 1)
+    {
+#endif
+        smem[tid] += smem[tid + 1];
+    }
+}
+
+
+void reduce_sum64(volatile __local  float* smem, int tid)
+{
+#ifndef WAVE_SIZE
+#define WAVE_SIZE 1
+#endif
+    if (tid < 32)
+    {
+        smem[tid] += smem[tid + 32];
+#if WAVE_SIZE < 32
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 16)
+    {
+#endif
+        smem[tid] += smem[tid + 16];
+#if WAVE_SIZE < 16
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 8)
+    {
+#endif
+        smem[tid] += smem[tid + 8];
+#if WAVE_SIZE < 8
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 4)
+    {
+#endif
+        smem[tid] += smem[tid + 4];
+#if WAVE_SIZE < 4
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 2)
+    {
+#endif
+        smem[tid] += smem[tid + 2];
+#if WAVE_SIZE < 2
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 1)
+    {
+#endif
+        smem[tid] += smem[tid + 1];
+    }
+}
+
+__kernel
+void SURF_normalizeDescriptors128(__global float * descriptors, int descriptors_step, int descriptors_offset)
+{
+    descriptors_step /= sizeof(*descriptors);
+    // no need for thread ID
+    __global float* descriptor_base = descriptors + descriptors_step * get_group_id(0);
+
+    // read in the unnormalized descriptor values (squared)
+    volatile __local  float sqDesc[128];
+    const float lookup = descriptor_base[get_local_id(0)];
+    sqDesc[get_local_id(0)] = lookup * lookup;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    reduce_sum128(sqDesc, get_local_id(0));
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // compute length (square root)
+    volatile __local  float len;
+    if (get_local_id(0) == 0)
+    {
+        len = sqrt(sqDesc[0]);
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // normalize and store in output
+    descriptor_base[get_local_id(0)] = lookup / len;
+}
+
+__kernel
+void SURF_normalizeDescriptors64(__global float * descriptors, int descriptors_step, int descriptors_offset)
+{
+    descriptors_step /= sizeof(*descriptors);
+    // no need for thread ID
+    __global float* descriptor_base = descriptors + descriptors_step * get_group_id(0);
+
+    // read in the unnormalized descriptor values (squared)
+    volatile __local  float sqDesc[64];
+    const float lookup = descriptor_base[get_local_id(0)];
+    sqDesc[get_local_id(0)] = lookup * lookup;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    reduce_sum64(sqDesc, get_local_id(0));
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // compute length (square root)
+    volatile __local  float len;
+    if (get_local_id(0) == 0)
+    {
+        len = sqrt(sqDesc[0]);
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // normalize and store in output
+    descriptor_base[get_local_id(0)] = lookup / len;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures.cpp
new file mode 100644
index 00000000..a5afe785
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures.cpp
@@ -0,0 +1,443 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+#include "precomp.hpp"
+
+#include "pct_signatures/constants.hpp"
+#include "pct_signatures/pct_sampler.hpp"
+#include "pct_signatures/pct_clusterizer.hpp"
+
+using namespace cv::xfeatures2d::pct_signatures;
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+            class PCTSignatures_Impl : public PCTSignatures
+            {
+            public:
+                PCTSignatures_Impl(const std::vector<Point2f>& initSamplingPoints, int initSeedCount)
+                {
+                    if (initSamplingPoints.size() == 0)
+                    {
+                        CV_Error(Error::StsBadArg, "No sampling points provided!");
+                    }
+                    if (initSeedCount <= 0)
+                    {
+                        CV_Error(Error::StsBadArg, "Not enough initial seeds, at least 1 required.");
+                    }
+
+                    mSampler = PCTSampler::create(initSamplingPoints);
+
+                    initSeedCount = std::min(initSeedCount, (int)initSamplingPoints.size());
+                    std::vector<int> initClusterSeedIndexes = pickRandomClusterSeedIndexes(initSeedCount);
+                    mClusterizer = PCTClusterizer::create(initClusterSeedIndexes);
+                }
+
+                PCTSignatures_Impl(
+                    const std::vector<Point2f>& initSamplingPoints,
+                    const std::vector<int>& initClusterSeedIndexes)
+                {
+                    if (initSamplingPoints.size() == 0)
+                    {
+                        CV_Error(Error::StsBadArg, "No sampling points provided!");
+                    }
+                    if (initClusterSeedIndexes.size() == 0)
+                    {
+                        CV_Error(Error::StsBadArg, "Not enough initial seeds, at least 1 required.");
+                    }
+                    if (initClusterSeedIndexes.size() > initSamplingPoints.size())
+                    {
+                        CV_Error(Error::StsBadArg, "Too much cluster seeds or not enough sampling points.");
+                    }
+                    for (int iCluster = 0; iCluster < (int)(initClusterSeedIndexes.size()); iCluster++)
+                    {
+                        if (initClusterSeedIndexes[iCluster] < 0
+                            || initClusterSeedIndexes[iCluster] >= (int)(initSamplingPoints.size()))
+                        {
+                            CV_Error(Error::StsBadArg,
+                                "Initial cluster seed indexes contain an index outside the range of the sampling point list.");
+                        }
+                    }
+
+                    mSampler = PCTSampler::create(initSamplingPoints);
+                    mClusterizer = PCTClusterizer::create(initClusterSeedIndexes);
+                }
+
+                void computeSignature(InputArray image, OutputArray signature) const CV_OVERRIDE;
+
+                void computeSignatures(const std::vector<Mat>& images, std::vector<Mat>& signatures) const CV_OVERRIDE;
+
+                void getGrayscaleBitmap(OutputArray _grayscaleBitmap, bool normalize) const;
+
+                /**** sampler ****/
+
+                int getSampleCount() const CV_OVERRIDE                      { return mSampler->getGrayscaleBits(); }
+                int getGrayscaleBits() const CV_OVERRIDE                    { return mSampler->getGrayscaleBits(); }
+                int getWindowRadius() const CV_OVERRIDE                     { return mSampler->getWindowRadius(); }
+                float getWeightX() const CV_OVERRIDE                        { return mSampler->getWeightX(); }
+                float getWeightY() const CV_OVERRIDE                        { return mSampler->getWeightY(); }
+                float getWeightL() const CV_OVERRIDE                        { return mSampler->getWeightL(); }
+                float getWeightA() const CV_OVERRIDE                        { return mSampler->getWeightA(); }
+                float getWeightB() const CV_OVERRIDE                        { return mSampler->getWeightB(); }
+                float getWeightContrast() const CV_OVERRIDE                 { return mSampler->getWeightContrast(); }
+                float getWeightEntropy() const CV_OVERRIDE                  { return mSampler->getWeightEntropy(); }
+
+                std::vector<Point2f> getSamplingPoints() const CV_OVERRIDE  { return mSampler->getSamplingPoints(); }
+
+
+                void setGrayscaleBits(int grayscaleBits) CV_OVERRIDE        { mSampler->setGrayscaleBits(grayscaleBits); }
+                void setWindowRadius(int windowRadius) CV_OVERRIDE          { mSampler->setWindowRadius(windowRadius); }
+                void setWeightX(float weight) CV_OVERRIDE                   { mSampler->setWeightX(weight); }
+                void setWeightY(float weight) CV_OVERRIDE                   { mSampler->setWeightY(weight); }
+                void setWeightL(float weight) CV_OVERRIDE                   { mSampler->setWeightL(weight); }
+                void setWeightA(float weight) CV_OVERRIDE                   { mSampler->setWeightA(weight); }
+                void setWeightB(float weight) CV_OVERRIDE                   { mSampler->setWeightB(weight); }
+                void setWeightContrast(float weight) CV_OVERRIDE            { mSampler->setWeightContrast(weight); }
+                void setWeightEntropy(float weight) CV_OVERRIDE             { mSampler->setWeightEntropy(weight); }
+
+                void setWeight(int idx, float value) CV_OVERRIDE                           { mSampler->setWeight(idx, value); }
+                void setWeights(const std::vector<float>& weights) CV_OVERRIDE             { mSampler->setWeights(weights); }
+                void setTranslation(int idx, float value) CV_OVERRIDE                      { mSampler->setTranslation(idx, value); }
+                void setTranslations(const std::vector<float>& translations) CV_OVERRIDE   { mSampler->setTranslations(translations); }
+
+                void setSamplingPoints(std::vector<Point2f> samplingPoints) CV_OVERRIDE    { mSampler->setSamplingPoints(samplingPoints); }
+
+
+                /**** clusterizer ****/
+
+                int getIterationCount() const CV_OVERRIDE                       { return mClusterizer->getIterationCount(); }
+                std::vector<int> getInitSeedIndexes() const CV_OVERRIDE         { return mClusterizer->getInitSeedIndexes(); }
+                int getInitSeedCount() const CV_OVERRIDE                        { return (int)mClusterizer->getInitSeedIndexes().size(); }
+                int getMaxClustersCount() const CV_OVERRIDE                     { return mClusterizer->getMaxClustersCount(); }
+                int getClusterMinSize() const CV_OVERRIDE                       { return mClusterizer->getClusterMinSize(); }
+                float getJoiningDistance() const CV_OVERRIDE                    { return mClusterizer->getJoiningDistance(); }
+                float getDropThreshold() const CV_OVERRIDE                      { return mClusterizer->getDropThreshold(); }
+                int getDistanceFunction() const CV_OVERRIDE
+                                                                    { return mClusterizer->getDistanceFunction(); }
+
+                void setIterationCount(int iterations) CV_OVERRIDE              { mClusterizer->setIterationCount(iterations); }
+                void setInitSeedIndexes(std::vector<int> initSeedIndexes) CV_OVERRIDE
+                                                                    { mClusterizer->setInitSeedIndexes(initSeedIndexes); }
+                void setMaxClustersCount(int maxClusters) CV_OVERRIDE           { mClusterizer->setMaxClustersCount(maxClusters); }
+                void setClusterMinSize(int clusterMinSize) CV_OVERRIDE          { mClusterizer->setClusterMinSize(clusterMinSize); }
+                void setJoiningDistance(float joiningDistance) CV_OVERRIDE      { mClusterizer->setJoiningDistance(joiningDistance); }
+                void setDropThreshold(float dropThreshold) CV_OVERRIDE          { mClusterizer->setDropThreshold(dropThreshold); }
+                void setDistanceFunction(int distanceFunction) CV_OVERRIDE
+                                                                    { mClusterizer->setDistanceFunction(distanceFunction); }
+
+            private:
+                /**
+                * @brief Samples used for sampling the input image and producing list of samples.
+                */
+                Ptr<PCTSampler> mSampler;
+
+                /**
+                * @brief Clusterizer using k-means algorithm to produce list of centroids from sampled points - the image signature.
+                */
+                Ptr<PCTClusterizer> mClusterizer;
+
+                /**
+                * @brief Creates vector of random indexes of sampling points
+                *       which will be used as initial centroids for k-means clusterization.
+                * @param initSeedCount Number of indexes of initial centroids to be produced.
+                * @return The generated vector of random indexes.
+                */
+                static std::vector<int> pickRandomClusterSeedIndexes(int initSeedCount)
+                {
+                    std::vector<int> seedIndexes;
+                    for (int iSeed = 0; iSeed < initSeedCount; iSeed++)
+                    {
+                        seedIndexes.push_back(iSeed);
+                    }
+
+                    randShuffle(seedIndexes);
+                    return seedIndexes;
+                }
+            };
+
+
+            /**
+            * @brief Class implementing parallel computing of signatures for multiple images.
+            */
+            class Parallel_computeSignatures : public ParallelLoopBody
+            {
+            private:
+                const PCTSignatures* mPctSignaturesAlgorithm;
+                const std::vector<Mat>* mImages;
+                std::vector<Mat>* mSignatures;
+
+            public:
+                Parallel_computeSignatures(
+                    const PCTSignatures* pctSignaturesAlgorithm,
+                    const std::vector<Mat>* images,
+                    std::vector<Mat>* signatures)
+                    : mPctSignaturesAlgorithm(pctSignaturesAlgorithm),
+                    mImages(images),
+                    mSignatures(signatures)
+                {
+                    mSignatures->resize(images->size());
+                }
+
+                void operator()(const Range& range) const CV_OVERRIDE
+                {
+                    for (int i = range.start; i < range.end; i++)
+                    {
+                        mPctSignaturesAlgorithm->computeSignature((*mImages)[i], (*mSignatures)[i]);
+                    }
+                }
+            };
+
+
+            /**
+            * @brief Computes signature for one image.
+            */
+            void PCTSignatures_Impl::computeSignature(InputArray _image, OutputArray _signature) const
+            {
+                if (_image.empty())
+                {
+                    _signature.create(_image.size(), CV_32FC1);
+                    return;
+                }
+
+                Mat image = _image.getMat();
+                CV_Assert(image.depth() == CV_8U);
+
+                // TODO: OpenCL
+                //if (ocl::useOpenCL())
+                //{
+                //}
+
+                // sample features
+                Mat samples;
+                mSampler->sample(image, samples);               // HOT PATH: 40%
+
+                // kmeans clusterize, use feature samples, produce signature clusters
+                Mat signature;
+                mClusterizer->clusterize(samples, signature);   // HOT PATH: 60%
+
+
+                // set result
+                _signature.create(signature.size(), signature.type());
+                Mat result = _signature.getMat();
+                signature.copyTo(result);
+            }
+
+            /**
+            * @brief Parallel function computing signatures for multiple images.
+            */
+            void PCTSignatures_Impl::computeSignatures(const std::vector<Mat>& images, std::vector<Mat>& signatures) const
+            {
+                parallel_for_(Range(0, (int)images.size()), Parallel_computeSignatures(this, &images, &signatures));
+            }
+
+        } // end of namespace pct_signatures
+
+
+
+        Ptr<PCTSignatures> PCTSignatures::create(
+            const int initSampleCount,
+            const int initSeedCount,
+            const int pointDistribution)
+        {
+            std::vector<Point2f> initPoints;
+            generateInitPoints(initPoints, initSampleCount, pointDistribution);
+            return create(initPoints, initSeedCount);
+        }
+
+        Ptr<PCTSignatures> PCTSignatures::create(
+            const std::vector<Point2f>& initPoints,
+            const int initSeedCount)
+        {
+            return makePtr<PCTSignatures_Impl>(initPoints, initSeedCount);
+        }
+
+        Ptr<PCTSignatures> PCTSignatures::create(
+            const std::vector<Point2f>& initPoints,
+            const std::vector<int>& initClusterSeedIndexes)
+        {
+            return makePtr<PCTSignatures_Impl>(initPoints, initClusterSeedIndexes);
+        }
+
+
+        void PCTSignatures::drawSignature(
+            InputArray _source,
+            InputArray _signature,
+            OutputArray _result,
+            float radiusToShorterSideRatio,
+            int borderThickness)
+        {
+            // check source
+            if (_source.empty())
+            {
+                return;
+            }
+            Mat source = _source.getMat();
+
+            // create result
+            _result.create(source.size(), source.type());
+            Mat result = _result.getMat();
+            source.copyTo(result);
+
+            // check signature
+            if (_signature.empty())
+            {
+                return;
+            }
+            Mat signature = _signature.getMat();
+            if (signature.type() != CV_32F || signature.cols != SIGNATURE_DIMENSION)
+            {
+                CV_Error_(Error::StsBadArg, ("Invalid signature format. Type must be CV_32F and signature.cols must be %d.", SIGNATURE_DIMENSION));
+            }
+
+            // compute max radius using given ratio of shorter image side
+            float maxRadius = ((source.rows < source.cols) ? source.rows : source.cols) * radiusToShorterSideRatio;
+
+            // draw signature
+            for (int i = 0; i < signature.rows; i++)
+            {
+                Vec3f labColor(
+                    signature.at<float>(i, L_IDX) * L_COLOR_RANGE,      // convert Lab pixel to BGR
+                    signature.at<float>(i, A_IDX) * A_COLOR_RANGE,
+                    signature.at<float>(i, B_IDX) * B_COLOR_RANGE);
+                Mat labPixel(1, 1, CV_32FC3);
+                labPixel.at<Vec3f>(0, 0) = labColor;
+                Mat rgbPixel;
+                cvtColor(labPixel, rgbPixel, COLOR_Lab2BGR);
+                rgbPixel.convertTo(rgbPixel, CV_8UC3, 255);
+                Vec3b rgbColor = rgbPixel.at<Vec3b>(0, 0);
+
+                // precompute variables
+                Point center((int)(signature.at<float>(i, X_IDX) * source.cols), (int)(signature.at<float>(i, Y_IDX) * source.rows));
+                int radius = (int)(maxRadius * signature.at<float>(i, WEIGHT_IDX));
+                Vec3b borderColor(0, 0, 0);
+
+                // draw filled circle
+                circle(result, center, radius, rgbColor, -1);
+                // draw circle outline
+                circle(result, center, radius, borderColor, borderThickness);
+            }
+        }
+
+
+        void PCTSignatures::generateInitPoints(
+            std::vector<Point2f>& initPoints,
+            const int count,
+            const int pointDistribution)
+        {
+            RNG random;
+            random.state = getTickCount();
+            initPoints.resize(count);
+
+            switch (pointDistribution)
+            {
+            case UNIFORM:
+                for (int i = 0; i < count; i++)
+                {
+                    // returns uniformly distributed float random number from [0, 1) range
+                    initPoints[i] = (Point2f(random.uniform((float)0.0, (float)1.0), random.uniform((float)0.0, (float)1.0)));
+                }
+                break;
+            case REGULAR:
+            {
+                int gridSize = (int)ceil(sqrt((float)count));
+                const float step = 1.0f / gridSize;
+                const float halfStep = step / 2;
+                float x = halfStep;
+                float y = halfStep;
+                for (int i = 0; i < count; i++)
+                {
+                    // returns regular grid
+                    initPoints[i] = Point2f(x, y);
+                    if ((i + 1) % gridSize == 0)
+                    {
+                        x = halfStep;
+                        y += step;
+                    }
+                    else
+                    {
+                        x += step;
+                    }
+                }
+                break;
+            }
+            case NORMAL:
+                for (int i = 0; i < count; i++)
+                {
+                    // returns normally distributed float random number from (0, 1) range with mean 0.5
+                    float sigma = 0.2f;
+                    float x = (float)random.gaussian(sigma);
+                    float y = (float)random.gaussian(sigma);
+                    while (x <= -0.5f || x >= 0.5f)
+                        x = (float)random.gaussian(sigma);
+                    while (y <= -0.5f || y >= 0.5f)
+                        y = (float)random.gaussian(sigma);
+                    initPoints[i] = Point2f(x, y) + Point2f(0.5, 0.5);
+                }
+                break;
+            default:
+                CV_Error(Error::StsNotImplemented, "Generation of this init point distribution is not implemented!");
+                break;
+            }
+        }
+
+
+    } // end of namespace xfeatures2d
+} // end of namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/constants.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/constants.hpp
new file mode 100644
index 00000000..29c22bd3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/constants.hpp
@@ -0,0 +1,96 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+
+#ifndef _OPENCV_XFEATURES_2D_PCT_SIGNATURES_CONSTANTS_HPP_
+#define _OPENCV_XFEATURES_2D_PCT_SIGNATURES_CONSTANTS_HPP_
+
+#ifdef __cplusplus
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+            const int SIGNATURE_DIMENSION = 8;
+
+            const int WEIGHT_IDX = 0;
+            const int X_IDX = 1;
+            const int Y_IDX = 2;
+            const int L_IDX = 3;
+            const int A_IDX = 4;
+            const int B_IDX = 5;
+            const int CONTRAST_IDX = 6;
+            const int ENTROPY_IDX = 7;
+
+            const float L_COLOR_RANGE = 100;
+            const float A_COLOR_RANGE = 127;
+            const float B_COLOR_RANGE = 127;
+
+            const float SAMPLER_CONTRAST_NORMALIZER = 25.0;   // both determined empirically
+            const float SAMPLER_ENTROPY_NORMALIZER = 4.0;
+
+        }
+    }
+}
+
+#endif
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/distance.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/distance.hpp
new file mode 100644
index 00000000..2c224af8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/distance.hpp
@@ -0,0 +1,217 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+
+#ifndef _OPENCV_XFEATURES_2D_PCT_SIGNATURES_DISTANCE_HPP_
+#define _OPENCV_XFEATURES_2D_PCT_SIGNATURES_DISTANCE_HPP_
+
+#ifdef __cplusplus
+#include "constants.hpp"
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+
+            static inline float distanceL0_25(
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                float result = (float)0.0;
+                for (int d = 1; d < SIGNATURE_DIMENSION; ++d)
+                {
+                    float difference = points1.at<float>(idx1, d) - points2.at<float>(idx2, d);
+                    result += std::sqrt(std::sqrt(std::abs(difference)));
+                }
+                result *= result;
+                return result * result;
+            }
+
+
+            static inline float distanceL0_5(
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                float result = (float)0.0;
+                for (int d = 1; d < SIGNATURE_DIMENSION; ++d)
+                {
+                    float difference = points1.at<float>(idx1, d) - points2.at<float>(idx2, d);
+                    result += std::sqrt(std::abs(difference));
+                }
+                return result * result;
+            }
+
+
+            static inline float distanceL1(
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                float result = (float)0.0;
+                for (int d = 1; d < SIGNATURE_DIMENSION; ++d)
+                {
+                    float difference = points1.at<float>(idx1, d) - points2.at<float>(idx2, d);
+                    result += std::abs(difference);
+                }
+                return result;
+            }
+
+
+            static inline float distanceL2(
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                float result = (float)0.0;
+                for (int d = 1; d < SIGNATURE_DIMENSION; ++d)
+                {
+                    float difference = points1.at<float>(idx1, d) - points2.at<float>(idx2, d);
+                    result += difference * difference;
+                }
+                return (float)std::sqrt(result);
+            }
+
+
+            static inline float distanceL2Squared(
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                float result = (float)0.0;
+                for (int d = 1; d < SIGNATURE_DIMENSION; ++d)
+                {
+                    float difference = points1.at<float>(idx1, d) - points2.at<float>(idx2, d);
+                    result += difference * difference;
+                }
+                return result;
+            }
+
+
+            static inline float distanceL5(
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                float result = (float)0.0;
+                for (int d = 1; d < SIGNATURE_DIMENSION; ++d)
+                {
+                    float difference = points1.at<float>(idx1, d) - points2.at<float>(idx2, d);
+                    result += std::abs(difference) * difference * difference * difference * difference;
+                }
+                return std::pow(result, (float)0.2);
+            }
+
+
+            static inline float distanceLInfinity(
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                float result = (float)0.0;
+                for (int d = 1; d < SIGNATURE_DIMENSION; ++d)
+                {
+                    float difference = points1.at<float>(idx1, d) - points2.at<float>(idx2, d);
+                    if (difference > result)
+                    {
+                        result = difference;
+                    }
+                }
+                return result;
+            }
+
+
+            /**
+            * @brief Computed distance between two centroids using given distance function.
+            * @param distanceFunction Distance function selector.
+            * @param points1 The first signature matrix - one centroid in each row.
+            * @param idx1 ID of centroid in the first signature
+            * @param points2 The second signature matrix - one centroid in each row.
+            * @param idx2 ID of centroid in the first signature
+            * @note The first column of a signature contains weights,
+            *       so only rows 1 to SIGNATURE_DIMENSION are used.
+            */
+            static inline float computeDistance(
+                const int distanceFunction,
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                switch (distanceFunction)
+                {
+                case PCTSignatures::L0_25:
+                    return distanceL0_25(points1, idx1, points2, idx2);
+                case PCTSignatures::L0_5:
+                    return distanceL0_5(points1, idx1, points2, idx2);
+                case PCTSignatures::L1:
+                    return distanceL1(points1, idx1, points2, idx2);
+                case PCTSignatures::L2:
+                    return distanceL2(points1, idx1, points2, idx2);
+                case PCTSignatures::L2SQUARED:
+                    return distanceL2Squared(points1, idx1, points2, idx2);
+                case PCTSignatures::L5:
+                    return distanceL5(points1, idx1, points2, idx2);
+                case PCTSignatures::L_INFINITY:
+                    return distanceLInfinity(points1, idx1, points2, idx2);
+                }
+                CV_Error(Error::StsBadArg, "Distance function not implemented!");
+            }
+        }
+    }
+}
+
+
+#endif
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/grayscale_bitmap.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/grayscale_bitmap.cpp
new file mode 100644
index 00000000..4553fa93
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/grayscale_bitmap.cpp
@@ -0,0 +1,181 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+#include "../precomp.hpp"
+
+#include "grayscale_bitmap.hpp"
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+            GrayscaleBitmap::GrayscaleBitmap(InputArray _bitmap, int bitsPerPixel)
+                : mBitsPerPixel(bitsPerPixel)
+            {
+                Mat bitmap = _bitmap.getMat();
+                if (bitmap.empty())
+                {
+                    CV_Error(Error::StsBadArg, "Input bitmap is empty");
+                }
+                if (bitmap.depth() != CV_8U && bitmap.depth() != CV_16U)
+                {
+                    CV_Error(Error::StsUnsupportedFormat, "Input bitmap depth must be CV_8U or CV_16U");
+                }
+                if (bitmap.depth() == CV_8U)
+                {
+                    bitmap.convertTo(bitmap, CV_16U, 257);
+                }
+
+                Mat grayscaleBitmap;
+                cvtColor(bitmap, grayscaleBitmap, COLOR_BGR2GRAY);
+
+                mWidth = bitmap.cols;
+                mHeight = bitmap.rows;
+
+                if (bitsPerPixel <= 0 || bitsPerPixel > 8)
+                {
+                    CV_Error_(Error::StsBadArg, ("Invalid number of bits per pixel %d. Only values in range [1..8] are accepted.", bitsPerPixel));
+                }
+
+                // Allocate space for pixel data.
+                int pixelsPerItem = 32 / mBitsPerPixel;
+                mData.resize((mWidth*mHeight + pixelsPerItem - 1) / pixelsPerItem);
+
+                // Convert the bitmap to grayscale and fill the pixel data.
+                CV_Assert(grayscaleBitmap.depth() == CV_16U);
+                for (int y = 0; y < mHeight; y++)
+                {
+                    for (int x = 0; x < mWidth; x++)
+                    {
+                        uint grayVal = ((uint)grayscaleBitmap.at<ushort>((int)y, (int)x)) >> (16 - mBitsPerPixel);
+                        setPixel(x, y, grayVal);
+                    }
+                }
+                // Prepare the preallocated contrast matrix for contrast-entropy computations
+                mCoOccurrenceMatrix.resize((int)(1 << (mBitsPerPixel * 2)));   // mCoOccurrenceMatrix size = maxPixelValue^2
+            }
+
+
+            // HOT PATH 30%
+            void GrayscaleBitmap::getContrastEntropy(int x, int y, float& contrast, float& entropy, int radius)
+            {
+                int fromX = (x > radius) ? x - radius : 0;
+                int fromY = (y > radius) ? y - radius : 0;
+                int toX = std::min<int>(mWidth - 1, x + radius + 1);
+                int toY = std::min<int>(mHeight - 1, y + radius + 1);
+                for (int j = fromY; j < toY; ++j)
+                {
+                    for (int i = fromX; i < toX; ++i)                               // for each pixel in the window
+                    {
+                        updateCoOccurrenceMatrix(getPixel(i, j), getPixel(i, j + 1));        // match every pixel with all 8 its neighbours
+                        updateCoOccurrenceMatrix(getPixel(i, j), getPixel(i + 1, j));
+                        updateCoOccurrenceMatrix(getPixel(i, j), getPixel(i + 1, j + 1));
+                        updateCoOccurrenceMatrix(getPixel(i + 1, j), getPixel(i, j + 1));    // 4 updates per pixel in the window
+                    }
+                }
+
+                contrast = 0.0;
+                entropy = 0.0;
+
+                uint pixelsScale = 1 << mBitsPerPixel;
+                float normalizer = (float)((toX - fromX) * (toY - fromY) * 4);            // four increments per pixel in the window (see above)
+                for (int j = 0; j < (int)pixelsScale; ++j)                              // iterate row in a 2D histogram
+                {
+                    for (int i = 0; i <= j; ++i)                                        // iterate column up to the diagonal in 2D histogram
+                    {
+                        if (mCoOccurrenceMatrix[j*pixelsScale + i] != 0)                // consider only non-zero values
+                        {
+                            float value = (float)mCoOccurrenceMatrix[j*pixelsScale + i] / normalizer; // normalize value by number of histogram updates
+                            contrast += (i - j) * (i - j) * value;          // compute contrast
+                            entropy -= value * std::log(value);             // compute entropy
+                            mCoOccurrenceMatrix[j*pixelsScale + i] = 0;     // clear the histogram array for the next computation
+                        }
+                    }
+                }
+            }
+
+
+            void GrayscaleBitmap::convertToMat(OutputArray _bitmap, bool normalize) const
+            {
+                _bitmap.create((int)getHeight(), (int)getWidth(), CV_8U);
+                Mat bitmap = _bitmap.getMat();
+
+                for (int y = 0; y < getHeight(); ++y)
+                {
+                    for (int x = 0; x < getWidth(); ++x)
+                    {
+                        uint pixel = getPixel(x, y);
+                        if (normalize && mBitsPerPixel < 8)
+                        {
+                            pixel <<= 8 - mBitsPerPixel;
+                        }
+                        else if (normalize && mBitsPerPixel > 8)
+                        {
+                            pixel >>= mBitsPerPixel - 8;
+                        }
+                        bitmap.at<uchar>((int)y, (int)x) = (uchar)pixel;
+                    }
+                }
+            }
+
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/grayscale_bitmap.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/grayscale_bitmap.hpp
new file mode 100644
index 00000000..32320915
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/grayscale_bitmap.hpp
@@ -0,0 +1,219 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+
+#ifndef _OPENCV_XFEATURES_2D_PCT_SIGNATURES_GRAYSCALE_BITMAP_HPP_
+#define _OPENCV_XFEATURES_2D_PCT_SIGNATURES_GRAYSCALE_BITMAP_HPP_
+
+#ifdef __cplusplus
+
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+            /**
+            * @brief Specific implementation of grayscale bitmap. This bitmap is used
+            *       to compute contrast and entropy features from surroundings of a pixel.
+            */
+            class GrayscaleBitmap
+            {
+            public:
+                /**
+                * @brief Initialize the grayscale bitmap from regular bitmap.
+                * @param bitmap Bitmap used as source of data.
+                * @param bitsPerPixel How many bits occupy one pixel in grayscale (e.g., 8 ~ 256 grayscale values).
+                *       Must be within [1..8] range.
+                */
+                GrayscaleBitmap(InputArray bitmap, int bitsPerPixel = 4);
+
+                /**
+                * @brief Return the width of the image in pixels.
+                */
+                int getWidth() const
+                {
+                    return mWidth;
+                }
+
+                /**
+                * @brief Return the height of the image in pixels.
+                */
+                int getHeight() const
+                {
+                    return mHeight;
+                }
+
+                /**
+                * @brief Return the height of the image in pixels.
+                */
+                int getBitsPerPixel() const
+                {
+                    return mBitsPerPixel;
+                }
+
+
+                /**
+                * @brief Compute contrast and entropy at selected coordinates.
+                * @param x The horizontal coordinate of the pixel (0..width-1).
+                * @param y The vertical coordinate of the pixel (0..height-1).
+                * @param contrast Output variable where contrast value is saved.
+                * @param entropy Output variable where entropy value is saved.
+                * @param radius Radius of the rectangular window around selected pixel used for computing
+                *       contrast and entropy. Size of the window side is (2*radius + 1).
+                *       The window is cropped if [x,y] is too near the image border.
+                */
+                void getContrastEntropy(
+                    int x,
+                    int y,
+                    float& contrast,
+                    float& entropy,
+                    int windowRadius = 3);
+
+                /**
+                * @brief Converts to OpenCV CV_8U Mat for debug and visualization purposes.
+                * @param bitmap OutputArray proxy where Mat will be written.
+                * @param normalize Whether to normalize the bitmap to the whole range of 255 values
+                *       to improve contrast.
+                */
+                void convertToMat(OutputArray bitmap, bool normalize = true) const;
+
+
+            private:
+                /**
+                * @brief Width of the image.
+                */
+                int mWidth;
+
+                /**
+                * @brief Height of the image.
+                */
+                int mHeight;
+
+                /**
+                * @brief Number of bits per pixel.
+                */
+                int mBitsPerPixel;
+
+                /**
+                * @brief Pixel data packed in 32-bit uints.
+                */
+                std::vector<uint> mData;
+
+                /**
+                * @brief Tmp matrix used for computing contrast and entropy.
+                */
+                std::vector<uint> mCoOccurrenceMatrix;
+
+
+                /**
+                * @brief Get pixel from packed data vector.
+                * @param x The horizontal coordinate of the pixel (0..width-1).
+                * @param y The vertical coordinate of the pixel (0..height-1).
+                * @return Grayscale value (0 ~ black, 2^bitPerPixel - 1 ~ white).
+                */
+                uint inline getPixel(int x, int y) const
+                {
+                    int pixelsPerItem = 32 / mBitsPerPixel;
+                    int offset = y*mWidth + x;
+                    int shift = (offset % pixelsPerItem) * mBitsPerPixel;
+                    uint mask = (1 << mBitsPerPixel) - 1;
+                    return (mData[offset / pixelsPerItem] >> shift) & mask;
+                }
+
+                /**
+                * @brief Set pixel in the packed data vector.
+                * @param x The horizontal coordinate of the pixel (0..width-1).
+                * @param y The vertical coordinate of the pixel (0..height-1).
+                * @param val Grayscale value (0 ~ black, 2^bitPerPixel - 1 ~ white).
+                */
+                void inline setPixel(int x, int y, uint val)
+                {
+                    int pixelsPerItem = 32 / mBitsPerPixel;
+                    int offset = y*mWidth + x;
+                    int shift = (offset % pixelsPerItem) * mBitsPerPixel;
+                    uint mask = (1 << mBitsPerPixel) - 1;
+                    val &= mask;
+                    mData[offset / pixelsPerItem] &= ~(mask << shift);
+                    mData[offset / pixelsPerItem] |= val << shift;
+                }
+
+                /**
+                * @brief Perform an update of contrast matrix.
+                */
+                void inline updateCoOccurrenceMatrix(uint a, uint b)
+                {
+                    // co-occurrence matrix is symmetric
+                    // merge to a variable with greater higher bits
+                    // to accumulate just in upper triangle in co-occurrence matrix for efficiency
+                    int offset = (int)((a > b) ? (a << mBitsPerPixel) + b : a + (b << mBitsPerPixel));
+                    mCoOccurrenceMatrix[offset]++;
+                }
+
+
+            };
+        }
+    }
+}
+
+
+#endif
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_clusterizer.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_clusterizer.cpp
new file mode 100644
index 00000000..dbd88f61
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_clusterizer.cpp
@@ -0,0 +1,452 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+#include "../precomp.hpp"
+
+#include "pct_clusterizer.hpp"
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+            class PCTClusterizer_Impl CV_FINAL : public PCTClusterizer
+            {
+            public:
+
+                PCTClusterizer_Impl(
+                    const std::vector<int>& initSeedIndexes,
+                    int iterationCount,
+                    int maxClustersCount,
+                    int clusterMinSize,
+                    float joiningDistance,
+                    float dropThreshold,
+                    int distanceFunction)
+                    : mInitSeedIndexes(initSeedIndexes),
+                    mIterationCount(iterationCount),
+                    mMaxClustersCount(maxClustersCount),
+                    mClusterMinSize(clusterMinSize),
+                    mJoiningDistance(joiningDistance),
+                    mDropThreshold(dropThreshold),
+                    mDistanceFunction(distanceFunction)
+                {
+                }
+
+                ~PCTClusterizer_Impl()
+                {
+                }
+
+
+                int getIterationCount() const CV_OVERRIDE                       { return mIterationCount; }
+                std::vector<int> getInitSeedIndexes() const CV_OVERRIDE         { return mInitSeedIndexes; }
+                int getMaxClustersCount() const CV_OVERRIDE                     { return mMaxClustersCount; }
+                int getClusterMinSize() const CV_OVERRIDE                       { return mClusterMinSize; }
+                float getJoiningDistance() const CV_OVERRIDE                    { return mJoiningDistance; }
+                float getDropThreshold() const CV_OVERRIDE                      { return mDropThreshold; }
+                int getDistanceFunction() const CV_OVERRIDE                     { return mDistanceFunction; }
+
+                void setIterationCount(int iterationCount) CV_OVERRIDE                  { mIterationCount = iterationCount; }
+                void setInitSeedIndexes(std::vector<int> initSeedIndexes) CV_OVERRIDE   { mInitSeedIndexes = initSeedIndexes; }
+                void setMaxClustersCount(int maxClustersCount) CV_OVERRIDE              { mMaxClustersCount = maxClustersCount; }
+                void setClusterMinSize(int clusterMinSize) CV_OVERRIDE                  { mClusterMinSize = clusterMinSize; }
+                void setJoiningDistance(float joiningDistance) CV_OVERRIDE              { mJoiningDistance = joiningDistance; }
+                void setDropThreshold(float dropThreshold) CV_OVERRIDE                  { mDropThreshold = dropThreshold; }
+                void setDistanceFunction(int distanceFunction) CV_OVERRIDE              { mDistanceFunction = distanceFunction; }
+
+
+                /**
+                * @brief K-means algorithm over the sampled points producing centroids as signatures.
+                * @param samples List of sampled points.
+                * @param signature Output list of computed centroids - the signature of the image.
+                */
+                void clusterize(InputArray _samples, OutputArray _signature) CV_OVERRIDE
+                {
+                    CV_Assert(!_samples.empty());
+
+                    // prepare matrices
+                    Mat samples = _samples.getMat();
+
+                    if ((int)(this->mInitSeedIndexes.size()) > samples.rows)
+                    {
+                        CV_Error_(Error::StsBadArg, ("Number of seeds %zu must be less or equal to the number of samples %d.",
+                            mInitSeedIndexes.size(), samples.rows));
+                    }
+
+                    // Prepare initial centroids.
+                    Mat clusters;
+                    pickRandomClusters(samples, clusters);
+                    clusters(Rect(WEIGHT_IDX, 0, 1, clusters.rows)) = 1;    // set initial weight to 1
+
+
+                    // prepare for iterating
+                    joinCloseClusters(clusters);
+                    dropLightPoints(clusters);
+
+
+                    // Main iterations cycle. Our implementation has fixed number of iterations.
+                    for (int iteration = 0; iteration < mIterationCount; iteration++)
+                    {
+                        // Prepare space for new centroid values.
+                        Mat tmpCentroids(clusters.size(), clusters.type());
+                        tmpCentroids.setTo(cv::Scalar::all(0));
+
+                        // Clear weights for new iteration.
+                        clusters(Rect(WEIGHT_IDX, 0, 1, clusters.rows)).setTo(cv::Scalar::all(0));
+
+                        // Compute affiliation of points and sum new coordinates for centroids.
+                        for (int iSample = 0; iSample < samples.rows; iSample++)
+                        {
+                            int iClosest = findClosestCluster(clusters, samples, iSample);
+                            for (int iDimension = 1; iDimension < SIGNATURE_DIMENSION; iDimension++)
+                            {
+                                tmpCentroids.at<float>(iClosest, iDimension) += samples.at<float>(iSample, iDimension);
+                            }
+                            clusters.at<float>(iClosest, WEIGHT_IDX)++;
+                        }
+
+                        // Compute average from tmp coordinates and throw away too small clusters.
+                        int lastIdx = 0;
+                        for (int i = 0; (int)i < tmpCentroids.rows; ++i)
+                        {
+                            // Skip clusters that are too small (large-enough clusters are packed right away)
+                            if (clusters.at<float>(i, WEIGHT_IDX) >(iteration + 1) * this->mClusterMinSize)
+                            {
+                                for (int d = 1; d < SIGNATURE_DIMENSION; d++)
+                                {
+                                    clusters.at<float>(lastIdx, d) = tmpCentroids.at<float>(i, d) / clusters.at<float>(i, WEIGHT_IDX);
+                                }
+                                // weights must be compacted as well
+                                clusters.at<float>(lastIdx, WEIGHT_IDX) = clusters.at<float>(i, WEIGHT_IDX);
+                                lastIdx++;
+                            }
+                        }
+
+                        // Crop the arrays if some centroids were dropped.
+                        clusters.resize(lastIdx);
+                        if (clusters.rows == 0)
+                        {
+                            break;
+                        }
+
+                        // Finally join clusters with too close centroids.
+                        joinCloseClusters(clusters);
+                        dropLightPoints(clusters);
+                    }
+
+                    // The result must not be empty!
+                    if (clusters.rows == 0)
+                    {
+                        singleClusterFallback(samples, clusters);
+                    }
+
+                    cropClusters(clusters);
+
+                    normalizeWeights(clusters);
+
+                    // save the result
+                    _signature.create(clusters.rows, SIGNATURE_DIMENSION, clusters.type());
+                    Mat signature = _signature.getMat();
+                    clusters.copyTo(signature);
+                }
+
+
+            private:
+
+                /**
+                * @brief Join clusters that are closer than joining distance.
+                *       If two clusters are joined one of them gets its weight set to 0.
+                * @param clusters List of clusters to be scaned and joined.
+                */
+                void joinCloseClusters(Mat& clusters)
+                {
+                    for (int i = 0; i < clusters.rows - 1; i++)
+                    {
+                        if (clusters.at<float>(i, WEIGHT_IDX) == 0)
+                        {
+                            continue;
+                        }
+
+                        for (int j = i + 1; j < clusters.rows; j++)
+                        {
+                            if (clusters.at<float>(j, WEIGHT_IDX) > 0
+                                && computeDistance(mDistanceFunction, clusters, i, clusters, j) <= mJoiningDistance)
+                            {
+                                clusters.at<float>(i, WEIGHT_IDX) = 0;
+                                break;
+                            }
+                        }
+                    }
+                }
+
+
+                /**
+                * @brief Remove points whose weight is lesser or equal to given threshold.
+                *       The point list is compacted and relative order of points is maintained.
+                * @param clusters List of clusters to be scaned and dropped.
+                */
+                void dropLightPoints(Mat& clusters)
+                {
+                    int frontIdx = 0;
+
+                    // Skip leading continuous part of weighted-enough points.
+                    while (frontIdx < clusters.rows && clusters.at<float>(frontIdx, WEIGHT_IDX) > mDropThreshold)
+                    {
+                        ++frontIdx;
+                    }
+
+                    // Mark first emptied position and advance front index.
+                    int tailIdx = frontIdx++;
+
+                    while (frontIdx < clusters.rows)
+                    {
+                        if (clusters.at<float>(frontIdx, WEIGHT_IDX) > mDropThreshold)
+                        {
+                            // Current (front) item is not dropped -> copy it to the tail.
+                            clusters.row(frontIdx).copyTo(clusters.row(tailIdx));
+                            ++tailIdx;  // grow the tail
+                        }
+                        ++frontIdx;
+                    }
+                    clusters.resize(tailIdx);
+                }
+
+
+                /**
+                * @brief Find closest cluster to selected point.
+                * @param clusters List of cluster centroids.
+                * @param points List of points.
+                * @param pointIdx Index to the list of points (the point for which the closest cluster is being found).
+                * @return Index to clusters list pointing at the closest cluster.
+                */
+                int findClosestCluster(const Mat& clusters, const Mat& points, const int pointIdx) const    // HOT PATH: 35%
+                {
+                    int iClosest = 0;
+                    float minDistance = computeDistance(mDistanceFunction, clusters, 0, points, pointIdx);
+
+                    for (int iCluster = 1; iCluster < clusters.rows; iCluster++)
+                    {
+                        float distance = computeDistance(mDistanceFunction, clusters, iCluster, points, pointIdx);
+                        if (distance < minDistance)
+                        {
+                            iClosest = iCluster;
+                            minDistance = distance;
+                        }
+                    }
+                    return iClosest;
+                }
+
+
+                /**
+                * @brief Make sure that the number of clusters does not exceed maxClusters parameter.
+                *       If it does, the clusters are sorted by their weights and the smallest clusters
+                *       are cropped.
+                * @param clusters List of clusters being scanned and cropped.
+                * @note This method does nothing iff the number of clusters is within the range.
+                */
+                void cropClusters(Mat& clusters) const
+                {
+                    if (clusters.rows > mMaxClustersCount)
+                    {
+                        Mat duplicate(clusters);                // save original clusters
+                        Mat sortedIdx;                          // sort using weight column
+                        sortIdx(clusters(Rect(WEIGHT_IDX, 0, 1, clusters.rows)), sortedIdx, SORT_EVERY_COLUMN + SORT_DESCENDING);
+
+                        clusters.resize(mMaxClustersCount);     // crop to max clusters
+                        for (int i = 0; i < mMaxClustersCount; i++)
+                        {                                       // copy sorted rows
+                            duplicate.row(sortedIdx.at<int>(i, 0)).copyTo(clusters.row(i));
+                        }
+                    }
+                }
+
+
+                /**
+                * @brief Fallback procedure invoked when the clustering eradicates all clusters.
+                *       Single cluster consisting of all points is then created.
+                * @param points List of sampled points.
+                * @param clusters Output list of clusters where the single cluster will be written.
+                */
+                void singleClusterFallback(const Mat& points, Mat& clusters) const
+                {
+                    if (clusters.rows != 0)
+                    {
+                        return;
+                    }
+                    clusters.create(1, points.cols, CV_32FC1);
+
+                    // Sum all points.
+                    reduce(points, clusters, 0, REDUCE_SUM, CV_32FC1);
+
+                    // Sum all weights, all points have the same weight -> sum is the point count
+                    clusters.at<float>(0, WEIGHT_IDX) = static_cast<float>(points.rows);
+
+                    // Divide centroid by number of points -> compute average in each dimension.
+                    clusters /= clusters.at<float>(0, WEIGHT_IDX);
+                }
+
+
+                /**
+                * @brief Normalizes cluster weights, so they fall into range [0..1]
+                *       The other values are preserved.
+                * @param clusters List of clusters which will be normalized.
+                * @note Only weight of the clusters will be changed (the first column);
+                */
+                void normalizeWeights(Mat& clusters)
+                {
+                    // get max weight
+                    float maxWeight = clusters.at<float>(0, WEIGHT_IDX);
+                    for (int i = 1; i < clusters.rows; i++)
+                    {
+                        if (clusters.at<float>(i, WEIGHT_IDX) > maxWeight)
+                        {
+                            maxWeight = clusters.at<float>(i, WEIGHT_IDX);
+                        }
+                    }
+
+                    // normalize weight
+                    float weightNormalizer = 1 / maxWeight;
+                    for (int i = 0; i < clusters.rows; i++)
+                    {
+                        clusters.at<float>(i, WEIGHT_IDX) = clusters.at<float>(i, WEIGHT_IDX) * weightNormalizer;
+                    }
+                }
+
+
+                /**
+                * @brief Chooses which sample points will be used as cluster centers,
+                *       using list of random indexes that is stored in mInitSeedIndexes.
+                * @param samples List of sampled points.
+                * @param clusters Output list of random sampled points.
+                */
+                void pickRandomClusters(Mat& samples, Mat& clusters)
+                {
+                    clusters.create(0, SIGNATURE_DIMENSION, samples.type());
+                    clusters.reserve(mInitSeedIndexes.size());
+
+                    for (int iSeed = 0; iSeed < (int)(mInitSeedIndexes.size()); iSeed++)
+                    {
+                        clusters.push_back(samples.row(mInitSeedIndexes[iSeed]));
+                    }
+                }
+
+
+
+                /**
+                * @brief Indexes of initial clusters from sampling points.
+                */
+                std::vector<int> mInitSeedIndexes;
+
+                /**
+                * @brief Number of iterations performed (the number is fixed).
+                */
+                int mIterationCount;
+
+                /**
+                * @brief Maximal number of clusters. If the number of clusters is exceeded after
+                *       all iterations are completed, the smallest clusters are thrown away.
+                */
+                int mMaxClustersCount;
+
+                /**
+                * @brief Minimal size of the cluster. After each (i-th) iteration, the cluster sizes are checked.
+                *       Cluster smaller than i*mClusterMinSize are disposed of.
+                */
+                int mClusterMinSize;
+
+                /**
+                * @brief Distance threshold between two centroids. If two centroids become closer
+                *       than this distance, the clusters are joined.
+                */
+                float mJoiningDistance;
+
+                /**
+                * @brief Weight threshold of centroids. If weight of a centroid is below this value at the end of the iteration, it is thrown away.
+                */
+                float mDropThreshold;
+
+                /**
+                * @brief L_p metric is used for computing distances.
+                */
+                int mDistanceFunction;
+
+            };
+
+
+            Ptr<PCTClusterizer> PCTClusterizer::create(
+                const std::vector<int>& initSeedIndexes,
+                int iterationCount,
+                int maxClustersCount,
+                int clusterMinSize,
+                float joiningDistance,
+                float dropThreshold,
+                int distanceFunction)
+            {
+                return makePtr<PCTClusterizer_Impl>(
+                    initSeedIndexes,
+                    iterationCount,
+                    maxClustersCount,
+                    clusterMinSize,
+                    joiningDistance,
+                    dropThreshold,
+                    distanceFunction);
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_clusterizer.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_clusterizer.hpp
new file mode 100644
index 00000000..3a07b27f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_clusterizer.hpp
@@ -0,0 +1,124 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+
+#ifndef _OPENCV_XFEATURES_2D_PCT_SIGNATURES_CLUSTERIZER_HPP_
+#define _OPENCV_XFEATURES_2D_PCT_SIGNATURES_CLUSTERIZER_HPP_
+
+#ifdef __cplusplus
+
+
+#include "constants.hpp"
+#include "distance.hpp"
+
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+            class PCTClusterizer : public Algorithm
+            {
+            public:
+
+                static Ptr<PCTClusterizer> create(
+                    const std::vector<int>& initSeedIndexes,
+                    int iterations = 10,
+                    int maxClusters = 768,  // max for Fermi GPU architecture
+                    int clusterMinSize = 2,
+                    float joiningDistance = 0.2,
+                    float dropThreshold = 0,
+                    int distanceFunction = PCTSignatures::L2);
+
+
+                /**** Accessors ****/
+
+                virtual int getIterationCount() const = 0;
+                virtual std::vector<int> getInitSeedIndexes() const = 0;
+                virtual int getMaxClustersCount() const = 0;
+                virtual int getClusterMinSize() const = 0;
+                virtual float getJoiningDistance() const = 0;
+                virtual float getDropThreshold() const = 0;
+                virtual int getDistanceFunction() const = 0;
+
+
+                virtual void setIterationCount(int iterationCount) = 0;
+                virtual void setInitSeedIndexes(std::vector<int> initSeedIndexes) = 0;
+                virtual void setMaxClustersCount(int maxClustersCount) = 0;
+                virtual void setClusterMinSize(int clusterMinSize) = 0;
+                virtual void setJoiningDistance(float joiningDistance) = 0;
+                virtual void setDropThreshold(float dropThreshold) = 0;
+                virtual void setDistanceFunction(int distanceFunction) = 0;
+
+                /**
+                * @brief K-means algorithm over the sampled points producing centroids as signatures.
+                * @param samples List of sampled points.
+                * @param signature Output list of computed centroids - the signature of the image.
+                */
+                virtual void clusterize(InputArray samples, OutputArray signature) = 0;
+            };
+        }
+    }
+}
+
+
+#endif
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_sampler.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_sampler.cpp
new file mode 100644
index 00000000..1f36ab30
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_sampler.cpp
@@ -0,0 +1,248 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+#include "../precomp.hpp"
+
+#include "pct_sampler.hpp"
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+            class PCTSampler_Impl CV_FINAL : public PCTSampler
+            {
+            private:
+                /**
+                * @brief Initial sampling point coordinates.
+                */
+                std::vector<Point2f> mInitSamplingPoints;
+
+                /**
+                * @brief Number of bits per pixel in grayscale image used for computing contrast and entropy.
+                */
+                int mGrayscaleBits;
+
+                /**
+                * @brief Radius of scanning window around a sampled point used for computing contrast and entropy.
+                */
+                int mWindowRadius;
+
+                /**
+                * @brief Weights of different feauture dimensions.
+                *       Default values are 1;
+                */
+                std::vector<float> mWeights;
+
+                /**
+                * @brief Translation of different feauture dimensions.
+                *       Default values are 0;
+                */
+                std::vector<float> mTranslations;
+
+
+            public:
+
+                PCTSampler_Impl(
+                    const std::vector<Point2f>& initSamplingPoints,
+                    int grayscaleBits,
+                    int windowRadius)
+                    : mInitSamplingPoints(initSamplingPoints),
+                    mGrayscaleBits(grayscaleBits),
+                    mWindowRadius(windowRadius)
+                {
+                    // Initialize weights and translation vectors to neutral values.
+                    for (int i = 0; i < SIGNATURE_DIMENSION; i++)
+                    {
+                        mWeights.push_back(1.0);
+                        mTranslations.push_back(0.0);
+                    }
+                }
+
+
+                /**** Acessors ****/
+
+                int getSampleCount() const CV_OVERRIDE      { return (int)mInitSamplingPoints.size(); }
+                int getGrayscaleBits() const CV_OVERRIDE    { return mGrayscaleBits; }
+                int getWindowRadius() const CV_OVERRIDE     { return mWindowRadius; }
+
+                float getWeightX() const CV_OVERRIDE               { return mWeights[X_IDX]; }
+                float getWeightY() const CV_OVERRIDE               { return mWeights[Y_IDX]; }
+                float getWeightL() const CV_OVERRIDE               { return mWeights[L_IDX]; }
+                float getWeightA() const CV_OVERRIDE               { return mWeights[A_IDX]; }
+                float getWeightB() const CV_OVERRIDE               { return mWeights[B_IDX]; }
+                float getWeightContrast() const CV_OVERRIDE        { return mWeights[CONTRAST_IDX]; }
+                float getWeightEntropy() const CV_OVERRIDE         { return mWeights[ENTROPY_IDX]; }
+
+                std::vector<Point2f> getSamplingPoints() const CV_OVERRIDE
+                                                        { return mInitSamplingPoints; }
+
+
+                void setGrayscaleBits(int grayscaleBits) CV_OVERRIDE    { mGrayscaleBits = grayscaleBits; }
+                void setWindowRadius(int windowRadius) CV_OVERRIDE      { mWindowRadius = windowRadius; }
+
+                void setWeightX(float weight) CV_OVERRIDE          { mWeights[X_IDX] = weight; }
+                void setWeightY(float weight) CV_OVERRIDE          { mWeights[Y_IDX] = weight; }
+                void setWeightL(float weight) CV_OVERRIDE          { mWeights[L_IDX] = weight; }
+                void setWeightA(float weight) CV_OVERRIDE          { mWeights[A_IDX] = weight; }
+                void setWeightB(float weight) CV_OVERRIDE          { mWeights[B_IDX] = weight; }
+                void setWeightContrast(float weight) CV_OVERRIDE   { mWeights[CONTRAST_IDX] = weight; }
+                void setWeightEntropy(float weight) CV_OVERRIDE    { mWeights[ENTROPY_IDX] = weight; }
+
+
+                void setWeight(int idx, float value) CV_OVERRIDE
+                {
+                    mWeights[idx] = value;
+                }
+
+                void setWeights(const std::vector<float>& weights) CV_OVERRIDE
+                {
+                    if (weights.size() != mWeights.size())
+                    {
+                        CV_Error_(Error::StsUnmatchedSizes,
+                            ("Invalid weights dimension %zu (max %zu)", weights.size(), mWeights.size()));
+                    }
+                    else
+                    {
+                        for (int i = 0; i < (int)(mWeights.size()); ++i)
+                        {
+                            mWeights[i] = weights[i];
+                        }
+                    }
+                }
+
+                void setTranslation(int idx, float value) CV_OVERRIDE
+                {
+                    mTranslations[idx] = value;
+                }
+
+                void setTranslations(const std::vector<float>& translations) CV_OVERRIDE
+                {
+                    if (translations.size() != mTranslations.size())
+                    {
+                        CV_Error_(Error::StsUnmatchedSizes,
+                            ("Invalid translations dimension %zu (max %zu)", translations.size(), mTranslations.size()));
+                    }
+                    else
+                    {
+                        for (int i = 0; i < (int)(mTranslations.size()); ++i)
+                        {
+                            mTranslations[i] = translations[i];
+                        }
+                    }
+                }
+
+                void setSamplingPoints(std::vector<Point2f> samplingPoints) CV_OVERRIDE { mInitSamplingPoints = samplingPoints; }
+
+
+                void sample(InputArray _image, OutputArray _samples) const CV_OVERRIDE
+                {
+                    // prepare matrices
+                    Mat image = _image.getMat();
+                    _samples.create((int)(mInitSamplingPoints.size()), SIGNATURE_DIMENSION, CV_32F);
+                    Mat samples = _samples.getMat();
+                    GrayscaleBitmap grayscaleBitmap(image, mGrayscaleBits);
+
+                    // sample each sample point
+                    for (int iSample = 0; iSample < (int)(mInitSamplingPoints.size()); iSample++)
+                    {
+                        // sampling points are in range [0..1)
+                        int x = (int)(mInitSamplingPoints[iSample].x * (image.cols));
+                        int y = (int)(mInitSamplingPoints[iSample].y * (image.rows));
+
+                        // x, y normalized
+                        samples.at<float>(iSample, X_IDX) = (float)((float)x / (float)image.cols * mWeights[X_IDX] + mTranslations[X_IDX]);
+                        samples.at<float>(iSample, Y_IDX) = (float)((float)y / (float)image.rows * mWeights[Y_IDX] + mTranslations[Y_IDX]);
+
+                        // get Lab pixel color
+                        Mat rgbPixel(image, Rect(x, y, 1, 1));
+                        Mat labPixel;
+                        rgbPixel.convertTo(rgbPixel, CV_32FC3, 1.0 / 255);
+                        cvtColor(rgbPixel, labPixel, COLOR_BGR2Lab);
+                        Vec3f labColor = labPixel.at<Vec3f>(0, 0);
+
+                        // Lab color normalized
+                        samples.at<float>(iSample, L_IDX) = (float)(std::floor(labColor[0] + 0.5) / L_COLOR_RANGE * mWeights[L_IDX] + mTranslations[L_IDX]);
+                        samples.at<float>(iSample, A_IDX) = (float)(std::floor(labColor[1] + 0.5) / A_COLOR_RANGE * mWeights[A_IDX] + mTranslations[A_IDX]);
+                        samples.at<float>(iSample, B_IDX) = (float)(std::floor(labColor[2] + 0.5) / B_COLOR_RANGE * mWeights[B_IDX] + mTranslations[B_IDX]);
+
+                        // contrast and entropy
+                        float contrast = 0.0, entropy = 0.0;
+                        grayscaleBitmap.getContrastEntropy(x, y, contrast, entropy, mWindowRadius);     // HOT PATH: 30%
+                        samples.at<float>(iSample, CONTRAST_IDX)
+                            = (float)(contrast / SAMPLER_CONTRAST_NORMALIZER * mWeights[CONTRAST_IDX] + mTranslations[CONTRAST_IDX]);
+                        samples.at<float>(iSample, ENTROPY_IDX)
+                            = (float)(entropy / SAMPLER_ENTROPY_NORMALIZER * mWeights[ENTROPY_IDX] + mTranslations[ENTROPY_IDX]);
+                    }
+                }
+
+            };
+
+
+            Ptr<PCTSampler> PCTSampler::create(
+                const std::vector<Point2f>& initPoints,
+                int                         grayscaleBits,
+                int                         windowRadius)
+            {
+                return makePtr<PCTSampler_Impl>(initPoints, grayscaleBits, windowRadius);
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_sampler.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_sampler.hpp
new file mode 100644
index 00000000..75e7dab1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/pct_sampler.hpp
@@ -0,0 +1,138 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+
+#ifndef _OPENCV_XFEATURES_2D_PCT_SIGNATURES_SAMPLER_HPP_
+#define _OPENCV_XFEATURES_2D_PCT_SIGNATURES_SAMPLER_HPP_
+
+#ifdef __cplusplus
+
+
+#include "constants.hpp"
+#include "grayscale_bitmap.hpp"
+
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+            class PCTSampler : public Algorithm
+            {
+            public:
+
+                static Ptr<PCTSampler> create(
+                    const std::vector<Point2f>& initSamplingPoints,
+                    int                     grayscaleBits = 4,
+                    int                     windowRadius = 3);
+
+
+                /**
+                * @brief Sampling algorithm that produces samples of the input image
+                *       using the stored sampling point locations.
+                * @param image Input image.
+                * @param signature Output list of computed image samples.
+                */
+                virtual void sample(InputArray image, OutputArray samples) const = 0;
+
+
+                /**** accessors ****/
+
+                virtual int getSampleCount() const = 0;
+                virtual int getGrayscaleBits() const = 0;
+                virtual int getWindowRadius() const = 0;
+                virtual float getWeightX() const = 0;
+                virtual float getWeightY() const = 0;
+                virtual float getWeightL() const = 0;
+                virtual float getWeightA() const = 0;
+                virtual float getWeightB() const = 0;
+                virtual float getWeightContrast() const = 0;
+                virtual float getWeightEntropy() const = 0;
+
+                virtual std::vector<Point2f> getSamplingPoints() const = 0;
+
+
+                virtual void setGrayscaleBits(int grayscaleBits) = 0;
+                virtual void setWindowRadius(int radius) = 0;
+                virtual void setWeightX(float weight) = 0;
+                virtual void setWeightY(float weight) = 0;
+                virtual void setWeightL(float weight) = 0;
+                virtual void setWeightA(float weight) = 0;
+                virtual void setWeightB(float weight) = 0;
+                virtual void setWeightContrast(float weight) = 0;
+                virtual void setWeightEntropy(float weight) = 0;
+
+                virtual void setWeight(int idx, float value) = 0;
+                virtual void setWeights(const std::vector<float>& weights) = 0;
+                virtual void setTranslation(int idx, float value) = 0;
+                virtual void setTranslations(const std::vector<float>& translations) = 0;
+
+                virtual void setSamplingPoints(std::vector<Point2f> samplingPoints) = 0;
+
+            };
+
+        }
+    }
+}
+
+
+#endif
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/similarity.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/similarity.hpp
new file mode 100644
index 00000000..90fa0a74
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures/similarity.hpp
@@ -0,0 +1,129 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+
+#ifndef _OPENCV_XFEATURES_2D_PCT_SIGNATURES_SIMILARITY_HPP_
+#define _OPENCV_XFEATURES_2D_PCT_SIGNATURES_SIMILARITY_HPP_
+
+#ifdef __cplusplus
+
+#include "distance.hpp"
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+
+            static inline float minusSimilarity(
+                const int distancefunction,
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                return -computeDistance(distancefunction, points1, idx1, points2, idx2);
+            }
+
+
+            static inline float gaussianSimilarity(
+                const int distancefunction,
+                const float alpha,
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                float distance = computeDistance(distancefunction, points1, idx1, points2, idx2);
+                return exp(-alpha * distance * distance);
+            }
+
+
+            static inline float heuristicSimilarity(
+                const int distancefunction,
+                const float alpha,
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                return 1 / (alpha + computeDistance(distancefunction, points1, idx1, points2, idx2));
+            }
+
+
+
+            static inline float computeSimilarity(
+                const int distancefunction,
+                const int similarity,
+                const float similarityParameter,
+                const Mat& points1, int idx1,
+                const Mat& points2, int idx2)
+            {
+                switch (similarity)
+                {
+                case PCTSignatures::MINUS:
+                    return minusSimilarity(distancefunction, points1, idx1, points2, idx2);
+                case PCTSignatures::GAUSSIAN:
+                    return gaussianSimilarity(distancefunction, similarityParameter, points1, idx1, points2, idx2);
+                case PCTSignatures::HEURISTIC:
+                    return heuristicSimilarity(distancefunction, similarityParameter, points1, idx1, points2, idx2);
+                }
+                CV_Error(Error::StsNotImplemented, "Similarity function not implemented!");
+            }
+        }
+    }
+}
+
+#endif
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures_sqfd.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures_sqfd.cpp
new file mode 100644
index 00000000..daf21b6c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/pct_signatures_sqfd.cpp
@@ -0,0 +1,224 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*
+Contributed by Gregor Kovalcik <gregor dot kovalcik at gmail dot com>
+    based on code provided by Martin Krulis, Jakub Lokoc and Tomas Skopal.
+
+References:
+    Martin Krulis, Jakub Lokoc, Tomas Skopal.
+    Efficient Extraction of Clustering-Based Feature Signatures Using GPU Architectures.
+    Multimedia tools and applications, 75(13), pp.: 8071�8103, Springer, ISSN: 1380-7501, 2016
+
+    Christian Beecks, Merih Seran Uysal, Thomas Seidl.
+    Signature quadratic form distance.
+    In Proceedings of the ACM International Conference on Image and Video Retrieval, pages 438-445.
+    ACM, 2010.
+*/
+#include "precomp.hpp"
+
+#include "pct_signatures/constants.hpp"
+#include "pct_signatures/similarity.hpp"
+
+namespace cv
+{
+    namespace xfeatures2d
+    {
+        namespace pct_signatures
+        {
+            class PCTSignaturesSQFD_Impl : public PCTSignaturesSQFD
+            {
+            public:
+                PCTSignaturesSQFD_Impl(
+                    const int distanceFunction,
+                    const int similarityFunction,
+                    const float similarityParameter)
+                    : mDistanceFunction(distanceFunction),
+                    mSimilarityFunction(similarityFunction),
+                    mSimilarityParameter(similarityParameter)
+                {
+
+                }
+
+
+                float computeQuadraticFormDistance(
+                    InputArray _signature0,
+                    InputArray _signature1) const CV_OVERRIDE;
+
+                void computeQuadraticFormDistances(
+                    const Mat& sourceSignature,
+                    const std::vector<Mat>& imageSignatures,
+                    std::vector<float>& distances) const CV_OVERRIDE;
+
+
+            private:
+                int mDistanceFunction;
+                int mSimilarityFunction;
+                float mSimilarityParameter;
+
+                float computePartialSQFD(
+                    const Mat& signature0,
+                    const Mat& signature1) const;
+
+            };
+
+
+            /**
+            * @brief Class implementing parallel computing of SQFD distance for multiple images.
+            */
+            class Parallel_computeSQFDs : public ParallelLoopBody
+            {
+            private:
+                const PCTSignaturesSQFD* mPctSignaturesSQFDAlgorithm;
+                const Mat* mSourceSignature;
+                const std::vector<Mat>* mImageSignatures;
+                std::vector<float>* mDistances;
+
+            public:
+                Parallel_computeSQFDs(
+                    const PCTSignaturesSQFD* pctSignaturesSQFDAlgorithm,
+                    const Mat* sourceSignature,
+                    const std::vector<Mat>* imageSignatures,
+                    std::vector<float>* distances)
+                    : mPctSignaturesSQFDAlgorithm(pctSignaturesSQFDAlgorithm),
+                    mSourceSignature(sourceSignature),
+                    mImageSignatures(imageSignatures),
+                    mDistances(distances)
+                {
+                    mDistances->resize(imageSignatures->size());
+                }
+
+                void operator()(const Range& range) const CV_OVERRIDE
+                {
+                    if (mSourceSignature->empty())
+                    {
+                        CV_Error(Error::StsBadArg, "Source signature is empty!");
+                    }
+
+                    for (int i = range.start; i < range.end; i++)
+                    {
+                        if (mImageSignatures[i].empty())
+                        {
+                            CV_Error_(Error::StsBadArg, ("Signature ID: %d is empty!", i));
+                        }
+
+                        (*mDistances)[i] = mPctSignaturesSQFDAlgorithm->computeQuadraticFormDistance(
+                            *mSourceSignature, (*mImageSignatures)[i]);
+                    }
+                }
+            };
+
+
+            float PCTSignaturesSQFD_Impl::computeQuadraticFormDistance(
+                      InputArray _signature0,
+                      InputArray _signature1) const
+            {
+                // check input
+                if (_signature0.empty() || _signature1.empty())
+                {
+                    CV_Error(Error::StsBadArg, "Empty signature!");
+                }
+
+                Mat signature0 = _signature0.getMat();
+                Mat signature1 = _signature1.getMat();
+
+                if (signature0.cols != SIGNATURE_DIMENSION || signature1.cols != SIGNATURE_DIMENSION)
+                {
+                    CV_Error_(Error::StsBadArg, ("Signature dimension must be %d!", SIGNATURE_DIMENSION));
+                }
+
+                if (signature0.rows <= 0 || signature1.rows <= 0)
+                {
+                    CV_Error(Error::StsBadArg, "Signature count must be greater than 0!");
+                }
+
+                // compute sqfd
+                float result = 0;
+                result += computePartialSQFD(signature0, signature0);
+                result += computePartialSQFD(signature1, signature1);
+                result -= computePartialSQFD(signature0, signature1) * 2;
+
+                return sqrt(result);
+            }
+
+            void PCTSignaturesSQFD_Impl::computeQuadraticFormDistances(
+                      const Mat& sourceSignature,
+                      const std::vector<Mat>& imageSignatures,
+                      std::vector<float>& distances) const
+            {
+                parallel_for_(Range(0, (int)imageSignatures.size()),
+                    Parallel_computeSQFDs(this, &sourceSignature, &imageSignatures, &distances));
+            }
+
+            float PCTSignaturesSQFD_Impl::computePartialSQFD(
+                      const Mat& signature0,
+                      const Mat& signature1) const
+            {
+                float result = 0;
+                for (int i = 0; i < signature0.rows; i++)
+                {
+                    for (int j = 0; j < signature1.rows; j++)
+                    {
+                        result += signature0.at<float>(i, WEIGHT_IDX) * signature1.at<float>(j, WEIGHT_IDX)
+                            * computeSimilarity(mDistanceFunction, mSimilarityFunction, mSimilarityParameter, signature0, i, signature1, j);
+                    }
+                }
+                return result;
+            }
+
+
+
+        }// end of namespace pct_signatures
+
+
+        Ptr<PCTSignaturesSQFD> PCTSignaturesSQFD::create(
+            const int distanceFunction,
+            const int similarityFunction,
+            const float similarityParameter)
+        {
+            return makePtr<pct_signatures::PCTSignaturesSQFD_Impl>(distanceFunction, similarityFunction, similarityParameter);
+        }
+
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/precomp.hpp
new file mode 100644
index 00000000..37699960
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/precomp.hpp
@@ -0,0 +1,64 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/xfeatures2d/cuda.hpp"
+
+#include "opencv2/xfeatures2d.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/private.hpp"
+#include "opencv2/core/private.cuda.hpp"
+#include "opencv2/core/ocl.hpp"
+
+#include "opencv2/opencv_modules.hpp"
+
+#ifdef HAVE_OPENCV_CUDAARITHM
+#  include "opencv2/cudaarithm.hpp"
+#endif
+
+#include "opencv2/core/private.hpp"
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/stardetector.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/stardetector.cpp
new file mode 100644
index 00000000..c6080452
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/stardetector.cpp
@@ -0,0 +1,570 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+/*!
+ The "Star" Detector.
+
+ The class implements the keypoint detector introduced by K. Konolige.
+ */
+class StarDetectorImpl : public StarDetector
+{
+public:
+    //! the full constructor
+    StarDetectorImpl(int _maxSize=45, int _responseThreshold=30,
+                         int _lineThresholdProjected=10,
+                         int _lineThresholdBinarized=8,
+                         int _suppressNonmaxSize=5);
+
+    void setMaxSize(int _maxSize) CV_OVERRIDE { maxSize = _maxSize; }
+    int getMaxSize() const CV_OVERRIDE { return maxSize; }
+
+    void setResponseThreshold(int _responseThreshold) CV_OVERRIDE { responseThreshold = _responseThreshold; }
+    int getResponseThreshold() const CV_OVERRIDE { return responseThreshold; }
+
+    void setLineThresholdProjected(int _lineThresholdProjected) CV_OVERRIDE { lineThresholdProjected = _lineThresholdProjected; }
+    int getLineThresholdProjected() const CV_OVERRIDE { return lineThresholdProjected; }
+
+    void setLineThresholdBinarized(int _lineThresholdBinarized) CV_OVERRIDE { lineThresholdBinarized = _lineThresholdBinarized; }
+    int getLineThresholdBinarized() const CV_OVERRIDE { return lineThresholdBinarized; }
+
+    void setSuppressNonmaxSize(int _suppressNonmaxSize) CV_OVERRIDE { suppressNonmaxSize = _suppressNonmaxSize; }
+    int getSuppressNonmaxSize() const CV_OVERRIDE { return suppressNonmaxSize; }
+
+    void read( const FileNode& fn ) CV_OVERRIDE;
+    void write( FileStorage& fs ) const CV_OVERRIDE;
+
+    void detect( InputArray image, std::vector<KeyPoint>& keypoints, InputArray mask=noArray() ) CV_OVERRIDE;
+
+protected:
+    int maxSize;
+    int responseThreshold;
+    int lineThresholdProjected;
+    int lineThresholdBinarized;
+    int suppressNonmaxSize;
+};
+
+Ptr<StarDetector> StarDetector::create(int _maxSize,
+                                       int _responseThreshold,
+                                       int _lineThresholdProjected,
+                                       int _lineThresholdBinarized,
+                                       int _suppressNonmaxSize)
+{
+    return makePtr<StarDetectorImpl>(_maxSize, _responseThreshold,
+                                     _lineThresholdProjected,
+                                     _lineThresholdBinarized,
+                                     _suppressNonmaxSize);
+}
+
+void StarDetectorImpl::read( const FileNode& fn)
+{
+  // if node is empty, keep previous value
+  if (!fn["maxSize"].empty())
+    fn["maxSize"] >> maxSize;
+  if (!fn["responseThreshold"].empty())
+      fn["responseThreshold"] >> responseThreshold;
+  if (!fn["lineThresholdProjected"].empty())
+      fn["lineThresholdProjected"] >> lineThresholdProjected;
+  if (!fn["lineThresholdBinarized"].empty())
+      fn["lineThresholdBinarized"] >> lineThresholdBinarized;
+  if (!fn["suppressNonmaxSize"].empty())
+      fn["suppressNonmaxSize"] >> suppressNonmaxSize;
+}
+void StarDetectorImpl::write( FileStorage& fs) const
+{
+  if(fs.isOpened())
+  {
+    fs << "name" << getDefaultName();
+    fs << "maxSize" << maxSize;
+    fs << "responseThreshold" << responseThreshold;
+    fs << "lineThresholdProjected" << lineThresholdProjected;
+    fs << "lineThresholdBinarized" << lineThresholdBinarized;
+    fs << "suppressNonmaxSize" << suppressNonmaxSize;
+  }
+}
+
+String StarDetector::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".STAR");
+}
+
+
+template <typename inMatType, typename outMatType> static void
+computeIntegralImages( const Mat& matI, Mat& matS, Mat& matT, Mat& _FT,
+                       int iiType )
+{
+    int x, y, rows = matI.rows, cols = matI.cols;
+
+    matS.create(rows + 1, cols + 1, iiType );
+    matT.create(rows + 1, cols + 1, iiType );
+    _FT.create(rows + 1, cols + 1, iiType );
+
+    const inMatType* I = matI.ptr<inMatType>();
+
+    outMatType *S = matS.ptr<outMatType>();
+    outMatType *T = matT.ptr<outMatType>();
+    outMatType *FT = _FT.ptr<outMatType>();
+
+    int istep = (int)(matI.step/matI.elemSize());
+    int step = (int)(matS.step/matS.elemSize());
+
+    for( x = 0; x <= cols; x++ )
+        S[x] = T[x] = FT[x] = 0;
+
+    S += step; T += step; FT += step;
+    S[0] = T[0] = 0;
+    FT[0] = I[0];
+    for( x = 1; x < cols; x++ )
+    {
+        S[x] = S[x-1] + I[x-1];
+        T[x] = I[x-1];
+        FT[x] = I[x] + I[x-1];
+    }
+    S[cols] = S[cols-1] + I[cols-1];
+    T[cols] = FT[cols] = I[cols-1];
+
+    for( y = 2; y <= rows; y++ )
+    {
+        I += istep, S += step, T += step, FT += step;
+
+        S[0] = S[-step]; S[1] = S[-step+1] + I[0];
+        T[0] = T[-step + 1];
+        T[1] = FT[0] = T[-step + 2] + I[-istep] + I[0];
+        FT[1] = FT[-step + 2] + I[-istep] + I[1] + I[0];
+
+        for( x = 2; x < cols; x++ )
+        {
+            S[x] = S[x - 1] + S[-step + x] - S[-step + x - 1] + I[x - 1];
+            T[x] = T[-step + x - 1] + T[-step + x + 1] - T[-step*2 + x] + I[-istep + x - 1] + I[x - 1];
+            FT[x] = FT[-step + x - 1] + FT[-step + x + 1] - FT[-step*2 + x] + I[x] + I[x-1];
+        }
+
+        S[cols] = S[cols - 1] + S[-step + cols] - S[-step + cols - 1] + I[cols - 1];
+        T[cols] = FT[cols] = T[-step + cols - 1] + I[-istep + cols - 1] + I[cols - 1];
+    }
+}
+
+template <typename iiMatType> static int
+StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes,
+                              int maxSize, int iiType )
+{
+    const int MAX_PATTERN = 17;
+    static const int sizes0[] = {1, 2, 3, 4, 6, 8, 11, 12, 16, 22, 23, 32, 45, 46, 64, 90, 128, -1};
+    static const int pairs[12][2] = {{1, 0}, {3, 1}, {4, 2}, {5, 3}, {7, 4}, {8, 5}, {9, 6},
+                                     {11, 8}, {13, 10}, {14, 11}, {15, 12}, {16, 14}};
+    const int MAX_PAIR = sizeof(pairs)/sizeof(pairs[0]);
+    float invSizes[MAX_PATTERN][2];
+    int sizes1[MAX_PATTERN];
+
+#if CV_SSE2
+    __m128 invSizes4[MAX_PATTERN][2];
+    __m128 sizes1_4[MAX_PATTERN];
+    union { int i; float f; } absmask;
+    absmask.i = 0x7fffffff;
+    volatile bool useSIMD = cv::checkHardwareSupport(CV_CPU_SSE2) && iiType == CV_32S;
+#endif
+
+    struct StarFeature
+    {
+        int area;
+        iiMatType* p[8];
+    };
+
+    StarFeature f[MAX_PATTERN];
+
+    Mat sum, tilted, flatTilted;
+    int y, rows = img.rows, cols = img.cols;
+    int border, npatterns=0, maxIdx=0;
+
+    responses.create( img.size(), CV_32F );
+    sizes.create( img.size(), CV_16S );
+
+    while( npatterns < MAX_PAIR && !
+          ( sizes0[pairs[npatterns][0]] >= maxSize
+           || sizes0[pairs[npatterns+1][0]] + sizes0[pairs[npatterns+1][0]]/2 >= std::min(rows, cols) ) )
+    {
+        ++npatterns;
+    }
+
+    if (npatterns-1 < MAX_PAIR)
+        ++npatterns;
+    maxIdx = pairs[npatterns-1][0];
+
+    // Create the integral image appropriate for our type & usage
+    if ( img.type() == CV_8U )
+        computeIntegralImages<uchar, iiMatType>( img, sum, tilted, flatTilted, iiType );
+    else if ( img.type() == CV_8S )
+        computeIntegralImages<char, iiMatType>( img, sum, tilted, flatTilted, iiType );
+    else if ( img.type() == CV_16U )
+        computeIntegralImages<ushort, iiMatType>( img, sum, tilted, flatTilted, iiType );
+    else if ( img.type() == CV_16S )
+        computeIntegralImages<short, iiMatType>( img, sum, tilted, flatTilted, iiType );
+    else
+        CV_Error( Error::StsUnsupportedFormat, "" );
+
+    int step = (int)(sum.step/sum.elemSize());
+
+    for(int i = 0; i <= maxIdx; i++ )
+    {
+        int ur_size = sizes0[i], t_size = sizes0[i] + sizes0[i]/2;
+        int ur_area = (2*ur_size + 1)*(2*ur_size + 1);
+        int t_area = t_size*t_size + (t_size + 1)*(t_size + 1);
+
+        f[i].p[0] = sum.ptr<iiMatType>() + (ur_size + 1)*step + ur_size + 1;
+        f[i].p[1] = sum.ptr<iiMatType>() - ur_size*step + ur_size + 1;
+        f[i].p[2] = sum.ptr<iiMatType>() + (ur_size + 1)*step - ur_size;
+        f[i].p[3] = sum.ptr<iiMatType>() - ur_size*step - ur_size;
+
+        f[i].p[4] = tilted.ptr<iiMatType>() + (t_size + 1)*step + 1;
+        f[i].p[5] = flatTilted.ptr<iiMatType>() - t_size;
+        f[i].p[6] = flatTilted.ptr<iiMatType>() + t_size + 1;
+        f[i].p[7] = tilted.ptr<iiMatType>() - t_size*step + 1;
+
+        f[i].area = ur_area + t_area;
+        sizes1[i] = sizes0[i];
+    }
+    // negate end points of the size range
+    // for a faster rejection of very small or very large features in non-maxima suppression.
+    sizes1[0] = -sizes1[0];
+    sizes1[1] = -sizes1[1];
+    sizes1[maxIdx] = -sizes1[maxIdx];
+    border = sizes0[maxIdx] + sizes0[maxIdx]/2;
+
+    for(int i = 0; i < npatterns; i++ )
+    {
+        int innerArea = f[pairs[i][1]].area;
+#if 0  // workaround MSVS2019 bug: error C2109: subscript requires array or pointer type
+        int outerArea = f[pairs[i][0]].area - innerArea;
+#else
+        int outerArea = f[pairs[i][0]].area;
+        outerArea -= innerArea;
+#endif
+        invSizes[i][0] = 1.f/outerArea;
+        invSizes[i][1] = 1.f/innerArea;
+    }
+
+#if CV_SSE2
+    if( useSIMD )
+    {
+        for(int i = 0; i < npatterns; i++ )
+        {
+            _mm_store_ps((float*)&invSizes4[i][0], _mm_set1_ps(invSizes[i][0]));
+            _mm_store_ps((float*)&invSizes4[i][1], _mm_set1_ps(invSizes[i][1]));
+        }
+
+        for(int i = 0; i <= maxIdx; i++ )
+            _mm_store_ps((float*)&sizes1_4[i], _mm_set1_ps((float)sizes1[i]));
+    }
+#endif
+
+    for( y = 0; y < border; y++ )
+    {
+        float* r_ptr = responses.ptr<float>(y);
+        float* r_ptr2 = responses.ptr<float>(rows - 1 - y);
+        short* s_ptr = sizes.ptr<short>(y);
+        short* s_ptr2 = sizes.ptr<short>(rows - 1 - y);
+
+        memset( r_ptr, 0, cols*sizeof(r_ptr[0]));
+        memset( r_ptr2, 0, cols*sizeof(r_ptr2[0]));
+        memset( s_ptr, 0, cols*sizeof(s_ptr[0]));
+        memset( s_ptr2, 0, cols*sizeof(s_ptr2[0]));
+    }
+
+    for( y = border; y < rows - border; y++ )
+    {
+        int x = border;
+        float* r_ptr = responses.ptr<float>(y);
+        short* s_ptr = sizes.ptr<short>(y);
+
+        memset( r_ptr, 0, border*sizeof(r_ptr[0]));
+        memset( s_ptr, 0, border*sizeof(s_ptr[0]));
+        memset( r_ptr + cols - border, 0, border*sizeof(r_ptr[0]));
+        memset( s_ptr + cols - border, 0, border*sizeof(s_ptr[0]));
+
+#if CV_SSE2
+        if( useSIMD )
+        {
+            __m128 absmask4 = _mm_set1_ps(absmask.f);
+            for( ; x <= cols - border - 4; x += 4 )
+            {
+                int ofs = y*step + x;
+                __m128 vals[MAX_PATTERN];
+                __m128 bestResponse = _mm_setzero_ps();
+                __m128 bestSize = _mm_setzero_ps();
+
+                for(int i = 0; i <= maxIdx; i++ )
+                {
+                    const iiMatType** p = (const iiMatType**)f[i].p;
+                    __m128i r0 = _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(p[0]+ofs)),
+                                               _mm_loadu_si128((const __m128i*)(p[1]+ofs)));
+                    __m128i r1 = _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(p[3]+ofs)),
+                                               _mm_loadu_si128((const __m128i*)(p[2]+ofs)));
+                    __m128i r2 = _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(p[4]+ofs)),
+                                               _mm_loadu_si128((const __m128i*)(p[5]+ofs)));
+                    __m128i r3 = _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(p[7]+ofs)),
+                                               _mm_loadu_si128((const __m128i*)(p[6]+ofs)));
+                    r0 = _mm_add_epi32(_mm_add_epi32(r0,r1), _mm_add_epi32(r2,r3));
+                    _mm_store_ps((float*)&vals[i], _mm_cvtepi32_ps(r0));
+                }
+
+                for(int i = 0; i < npatterns; i++ )
+                {
+                    __m128 inner_sum = vals[pairs[i][1]];
+                    __m128 outer_sum = _mm_sub_ps(vals[pairs[i][0]], inner_sum);
+                    __m128 response = _mm_sub_ps(_mm_mul_ps(inner_sum, invSizes4[i][1]),
+                        _mm_mul_ps(outer_sum, invSizes4[i][0]));
+                    __m128 swapmask = _mm_cmpgt_ps(_mm_and_ps(response,absmask4),
+                        _mm_and_ps(bestResponse,absmask4));
+                    bestResponse = _mm_xor_ps(bestResponse,
+                        _mm_and_ps(_mm_xor_ps(response,bestResponse), swapmask));
+                    bestSize = _mm_xor_ps(bestSize,
+                        _mm_and_ps(_mm_xor_ps(sizes1_4[pairs[i][0]], bestSize), swapmask));
+                }
+
+                _mm_storeu_ps(r_ptr + x, bestResponse);
+                _mm_storel_epi64((__m128i*)(s_ptr + x),
+                    _mm_packs_epi32(_mm_cvtps_epi32(bestSize),_mm_setzero_si128()));
+            }
+        }
+#endif
+        for( ; x < cols - border; x++ )
+        {
+            int ofs = y*step + x;
+            int vals[MAX_PATTERN];
+            float bestResponse = 0;
+            int bestSize = 0;
+
+            for(int i = 0; i <= maxIdx; i++ )
+            {
+                const iiMatType** p = (const iiMatType**)f[i].p;
+                vals[i] = (int)(p[0][ofs] - p[1][ofs] - p[2][ofs] + p[3][ofs] +
+                    p[4][ofs] - p[5][ofs] - p[6][ofs] + p[7][ofs]);
+            }
+            for(int i = 0; i < npatterns; i++ )
+            {
+                int inner_sum = vals[pairs[i][1]];
+                int outer_sum = vals[pairs[i][0]] - inner_sum;
+                float response = inner_sum*invSizes[i][1] - outer_sum*invSizes[i][0];
+                if( fabs(response) > fabs(bestResponse) )
+                {
+                    bestResponse = response;
+                    bestSize = sizes1[pairs[i][0]];
+                }
+            }
+
+            r_ptr[x] = bestResponse;
+            s_ptr[x] = (short)bestSize;
+        }
+    }
+
+    return border;
+}
+
+
+static bool StarDetectorSuppressLines( const Mat& responses, const Mat& sizes, Point pt,
+                                       int lineThresholdProjected, int lineThresholdBinarized )
+{
+    const float* r_ptr = responses.ptr<float>();
+    int rstep = (int)(responses.step/sizeof(r_ptr[0]));
+    const short* s_ptr = sizes.ptr<short>();
+    int sstep = (int)(sizes.step/sizeof(s_ptr[0]));
+    int sz = s_ptr[pt.y*sstep + pt.x];
+    int x, y, delta = sz/4, radius = delta*4;
+    float Lxx = 0, Lyy = 0, Lxy = 0;
+    int Lxxb = 0, Lyyb = 0, Lxyb = 0;
+
+    for( y = pt.y - radius; y <= pt.y + radius; y += delta )
+        for( x = pt.x - radius; x <= pt.x + radius; x += delta )
+        {
+            float Lx = r_ptr[y*rstep + x + 1] - r_ptr[y*rstep + x - 1];
+            float Ly = r_ptr[(y+1)*rstep + x] - r_ptr[(y-1)*rstep + x];
+            Lxx += Lx*Lx; Lyy += Ly*Ly; Lxy += Lx*Ly;
+        }
+
+    if( (Lxx + Lyy)*(Lxx + Lyy) >= lineThresholdProjected*(Lxx*Lyy - Lxy*Lxy) )
+        return true;
+
+    for( y = pt.y - radius; y <= pt.y + radius; y += delta )
+        for( x = pt.x - radius; x <= pt.x + radius; x += delta )
+        {
+            int Lxb = (s_ptr[y*sstep + x + 1] == sz) - (s_ptr[y*sstep + x - 1] == sz);
+            int Lyb = (s_ptr[(y+1)*sstep + x] == sz) - (s_ptr[(y-1)*sstep + x] == sz);
+            Lxxb += Lxb * Lxb; Lyyb += Lyb * Lyb; Lxyb += Lxb * Lyb;
+        }
+
+    if( (Lxxb + Lyyb)*(Lxxb + Lyyb) >= lineThresholdBinarized*(Lxxb*Lyyb - Lxyb*Lxyb) )
+        return true;
+
+    return false;
+}
+
+
+static void
+StarDetectorSuppressNonmax( const Mat& responses, const Mat& sizes,
+                            std::vector<KeyPoint>& keypoints, int border,
+                            int responseThreshold,
+                            int lineThresholdProjected,
+                            int lineThresholdBinarized,
+                            int suppressNonmaxSize )
+{
+    int x, y, x1, y1, delta = suppressNonmaxSize/2;
+    int rows = responses.rows, cols = responses.cols;
+    const float* r_ptr = responses.ptr<float>();
+    int rstep = (int)(responses.step/sizeof(r_ptr[0]));
+    const short* s_ptr = sizes.ptr<short>();
+    int sstep = (int)(sizes.step/sizeof(s_ptr[0]));
+    short featureSize = 0;
+
+    for( y = border; y < rows - border; y += delta+1 )
+        for( x = border; x < cols - border; x += delta+1 )
+        {
+            float maxResponse = (float)responseThreshold;
+            float minResponse = (float)-responseThreshold;
+            Point maxPt(-1, -1), minPt(-1, -1);
+            int tileEndY = MIN(y + delta, rows - border - 1);
+            int tileEndX = MIN(x + delta, cols - border - 1);
+
+            for( y1 = y; y1 <= tileEndY; y1++ )
+                for( x1 = x; x1 <= tileEndX; x1++ )
+                {
+                    float val = r_ptr[y1*rstep + x1];
+                    if( maxResponse < val )
+                    {
+                        maxResponse = val;
+                        maxPt = Point(x1, y1);
+                    }
+                    else if( minResponse > val )
+                    {
+                        minResponse = val;
+                        minPt = Point(x1, y1);
+                    }
+                }
+
+            if( maxPt.x >= 0 )
+            {
+                for( y1 = maxPt.y - delta; y1 <= maxPt.y + delta; y1++ )
+                    for( x1 = maxPt.x - delta; x1 <= maxPt.x + delta; x1++ )
+                    {
+                        float val = r_ptr[y1*rstep + x1];
+                        if( val >= maxResponse && (y1 != maxPt.y || x1 != maxPt.x))
+                            goto skip_max;
+                    }
+
+                if( (featureSize = s_ptr[maxPt.y*sstep + maxPt.x]) >= 4 &&
+                    !StarDetectorSuppressLines( responses, sizes, maxPt, lineThresholdProjected,
+                                                lineThresholdBinarized ))
+                {
+                    KeyPoint kpt((float)maxPt.x, (float)maxPt.y, featureSize, -1, maxResponse);
+                    keypoints.push_back(kpt);
+                }
+            }
+        skip_max:
+            if( minPt.x >= 0 )
+            {
+                for( y1 = minPt.y - delta; y1 <= minPt.y + delta; y1++ )
+                    for( x1 = minPt.x - delta; x1 <= minPt.x + delta; x1++ )
+                    {
+                        float val = r_ptr[y1*rstep + x1];
+                        if( val <= minResponse && (y1 != minPt.y || x1 != minPt.x))
+                            goto skip_min;
+                    }
+
+                if( (featureSize = s_ptr[minPt.y*sstep + minPt.x]) >= 4 &&
+                    !StarDetectorSuppressLines( responses, sizes, minPt,
+                                               lineThresholdProjected, lineThresholdBinarized))
+                {
+                    KeyPoint kpt((float)minPt.x, (float)minPt.y, featureSize, -1, maxResponse);
+                    keypoints.push_back(kpt);
+                }
+            }
+        skip_min:
+            ;
+        }
+}
+
+StarDetectorImpl::StarDetectorImpl(int _maxSize, int _responseThreshold,
+                           int _lineThresholdProjected,
+                           int _lineThresholdBinarized,
+                           int _suppressNonmaxSize)
+: maxSize(_maxSize), responseThreshold(_responseThreshold),
+    lineThresholdProjected(_lineThresholdProjected),
+    lineThresholdBinarized(_lineThresholdBinarized),
+    suppressNonmaxSize(_suppressNonmaxSize)
+{}
+
+
+void StarDetectorImpl::detect( InputArray _image, std::vector<KeyPoint>& keypoints, InputArray _mask )
+{
+    Mat image = _image.getMat(), mask = _mask.getMat(), grayImage = image;
+    if( image.empty() )
+    {
+        keypoints.clear();
+        return;
+    }
+    if( image.channels() > 1 ) cvtColor( image, grayImage, COLOR_BGR2GRAY );
+
+    Mat responses, sizes;
+    int border;
+
+    // Use 32-bit integers if we won't overflow in the integral image
+    if ((grayImage.depth() == CV_8U || grayImage.depth() == CV_8S) &&
+        (int)grayImage.total() < 8388608 ) // 8388608 = 2 ^ (32 - 8(bit depth) - 1(sign bit))
+        border = StarDetectorComputeResponses<int>( grayImage, responses, sizes, maxSize, CV_32S );
+    else
+        border = StarDetectorComputeResponses<double>( grayImage, responses, sizes, maxSize, CV_64F );
+
+    keypoints.clear();
+    if( border >= 0 )
+        StarDetectorSuppressNonmax( responses, sizes, keypoints, border,
+                                   responseThreshold, lineThresholdProjected,
+                                   lineThresholdBinarized, suppressNonmaxSize );
+    KeyPointsFilter::runByPixelsMask( keypoints, mask );
+}
+
+}
+}
+
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.cpp
new file mode 100644
index 00000000..54abcd07
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.cpp
@@ -0,0 +1,1039 @@
+/* Original code has been submitted by Liu Liu. Here is the copyright.
+----------------------------------------------------------------------------------
+ * An OpenCV Implementation of SURF
+ * Further Information Refer to "SURF: Speed-Up Robust Feature"
+ * Author: Liu Liu
+ * liuliu.1987+opencv@gmail.com
+ *
+ * There are still serveral lacks for this experimental implementation:
+ * 1.The interpolation of sub-pixel mentioned in article was not implemented yet;
+ * 2.A comparison with original libSurf.so shows that the hessian detector is not a 100% match to their implementation;
+ * 3.Due to above reasons, I recommanded the original one for study and reuse;
+ *
+ * However, the speed of this implementation is something comparable to original one.
+ *
+ * Copyright© 2008, Liu Liu All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *  Redistributions of source code must retain the above
+ *  copyright notice, this list of conditions and the following
+ *  disclaimer.
+ *  Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following
+ *  disclaimer in the documentation and/or other materials
+ *  provided with the distribution.
+ *  The name of Contributor may not be used to endorse or
+ *  promote products derived from this software without
+ *  specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ */
+
+/*
+   The following changes have been made, comparing to the original contribution:
+   1. A lot of small optimizations, less memory allocations, got rid of global buffers
+   2. Reversed order of cvGetQuadrangleSubPix and cvResize calls; probably less accurate, but much faster
+   3. The descriptor computing part (which is most expensive) is threaded using OpenMP
+   (subpixel-accurate keypoint localization and scale estimation are still TBD)
+*/
+
+/*
+KeyPoint position and scale interpolation has been implemented as described in
+the Brown and Lowe paper cited by the SURF paper.
+
+The sampling step along the x and y axes of the image for the determinant of the
+Hessian is now the same for each layer in an octave. While this increases the
+computation time, it ensures that a true 3x3x3 neighbourhood exists, with
+samples calculated at the same position in the layers above and below. This
+results in improved maxima detection and non-maxima suppression, and I think it
+is consistent with the description in the SURF paper.
+
+The wavelet size sampling interval has also been made consistent. The wavelet
+size at the first layer of the first octave is now 9 instead of 7. Along with
+regular position sampling steps, this makes location and scale interpolation
+easy. I think this is consistent with the SURF paper and original
+implementation.
+
+The scaling of the wavelet parameters has been fixed to ensure that the patterns
+are symmetric around the centre. Previously the truncation caused by integer
+division in the scaling ratio caused a bias towards the top left of the wavelet,
+resulting in inconsistent keypoint positions.
+
+The matrices for the determinant and trace of the Hessian are now reused in each
+octave.
+
+The extraction of the patch of pixels surrounding a keypoint used to build a
+descriptor has been simplified.
+
+KeyPoint descriptor normalisation has been changed from normalising each 4x4
+cell (resulting in a descriptor of magnitude 16) to normalising the entire
+descriptor to magnitude 1.
+
+The default number of octaves has been increased from 3 to 4 to match the
+original SURF binary default. The increase in computation time is minimal since
+the higher octaves are sampled sparsely.
+
+The default number of layers per octave has been reduced from 3 to 2, to prevent
+redundant calculation of similar sizes in consecutive octaves.  This decreases
+computation time. The number of features extracted may be less, however the
+additional features were mostly redundant.
+
+The radius of the circle of gradient samples used to assign an orientation has
+been increased from 4 to 6 to match the description in the SURF paper. This is
+now defined by ORI_RADIUS, and could be made into a parameter.
+
+The size of the sliding window used in orientation assignment has been reduced
+from 120 to 60 degrees to match the description in the SURF paper. This is now
+defined by ORI_WIN, and could be made into a parameter.
+
+Other options like  HAAR_SIZE0, HAAR_SIZE_INC, SAMPLE_STEP0, ORI_SEARCH_INC,
+ORI_SIGMA and DESC_SIGMA have been separated from the code and documented.
+These could also be made into parameters.
+
+Modifications by Ian Mahon
+
+*/
+#include "precomp.hpp"
+#include "surf.hpp"
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+#ifdef OPENCV_ENABLE_NONFREE
+
+static const int   SURF_ORI_SEARCH_INC = 5;
+static const float SURF_ORI_SIGMA      = 2.5f;
+static const float SURF_DESC_SIGMA     = 3.3f;
+
+// Wavelet size at first layer of first octave.
+static const int SURF_HAAR_SIZE0 = 9;
+
+// Wavelet size increment between layers. This should be an even number,
+// such that the wavelet sizes in an octave are either all even or all odd.
+// This ensures that when looking for the neighbours of a sample, the layers
+// above and below are aligned correctly.
+static const int SURF_HAAR_SIZE_INC = 6;
+
+
+struct SurfHF
+{
+    int p0, p1, p2, p3;
+    float w;
+
+    SurfHF(): p0(0), p1(0), p2(0), p3(0), w(0) {}
+};
+
+inline float calcHaarPattern( const int* origin, const SurfHF* f, int n )
+{
+    double d = 0;
+    for( int k = 0; k < n; k++ )
+        d += (origin[f[k].p0] + origin[f[k].p3] - origin[f[k].p1] - origin[f[k].p2])*f[k].w;
+    return (float)d;
+}
+
+static void
+resizeHaarPattern( const int src[][5], SurfHF* dst, int n, int oldSize, int newSize, int widthStep )
+{
+    float ratio = (float)newSize/oldSize;
+    for( int k = 0; k < n; k++ )
+    {
+        int dx1 = cvRound( ratio*src[k][0] );
+        int dy1 = cvRound( ratio*src[k][1] );
+        int dx2 = cvRound( ratio*src[k][2] );
+        int dy2 = cvRound( ratio*src[k][3] );
+        dst[k].p0 = dy1*widthStep + dx1;
+        dst[k].p1 = dy2*widthStep + dx1;
+        dst[k].p2 = dy1*widthStep + dx2;
+        dst[k].p3 = dy2*widthStep + dx2;
+        dst[k].w = src[k][4]/((float)(dx2-dx1)*(dy2-dy1));
+    }
+}
+
+/*
+ * Calculate the determinant and trace of the Hessian for a layer of the
+ * scale-space pyramid
+ */
+static void calcLayerDetAndTrace( const Mat& sum, int size, int sampleStep,
+                                  Mat& det, Mat& trace )
+{
+    const int NX=3, NY=3, NXY=4;
+    const int dx_s[NX][5] = { {0, 2, 3, 7, 1}, {3, 2, 6, 7, -2}, {6, 2, 9, 7, 1} };
+    const int dy_s[NY][5] = { {2, 0, 7, 3, 1}, {2, 3, 7, 6, -2}, {2, 6, 7, 9, 1} };
+    const int dxy_s[NXY][5] = { {1, 1, 4, 4, 1}, {5, 1, 8, 4, -1}, {1, 5, 4, 8, -1}, {5, 5, 8, 8, 1} };
+
+    SurfHF Dx[NX], Dy[NY], Dxy[NXY];
+
+    if( size > sum.rows-1 || size > sum.cols-1 )
+       return;
+
+    resizeHaarPattern( dx_s , Dx , NX , 9, size, sum.cols );
+    resizeHaarPattern( dy_s , Dy , NY , 9, size, sum.cols );
+    resizeHaarPattern( dxy_s, Dxy, NXY, 9, size, sum.cols );
+
+    /* The integral image 'sum' is one pixel bigger than the source image */
+    int samples_i = 1+(sum.rows-1-size)/sampleStep;
+    int samples_j = 1+(sum.cols-1-size)/sampleStep;
+
+    /* Ignore pixels where some of the kernel is outside the image */
+    int margin = (size/2)/sampleStep;
+
+    for( int i = 0; i < samples_i; i++ )
+    {
+        const int* sum_ptr = sum.ptr<int>(i*sampleStep);
+        float* det_ptr = &det.at<float>(i+margin, margin);
+        float* trace_ptr = &trace.at<float>(i+margin, margin);
+        for( int j = 0; j < samples_j; j++ )
+        {
+            float dx  = calcHaarPattern( sum_ptr, Dx , 3 );
+            float dy  = calcHaarPattern( sum_ptr, Dy , 3 );
+            float dxy = calcHaarPattern( sum_ptr, Dxy, 4 );
+            sum_ptr += sampleStep;
+            det_ptr[j] = dx*dy - 0.81f*dxy*dxy;
+            trace_ptr[j] = dx + dy;
+        }
+    }
+}
+
+
+/*
+ * Maxima location interpolation as described in "Invariant Features from
+ * Interest Point Groups" by Matthew Brown and David Lowe. This is performed by
+ * fitting a 3D quadratic to a set of neighbouring samples.
+ *
+ * The gradient vector and Hessian matrix at the initial keypoint location are
+ * approximated using central differences. The linear system Ax = b is then
+ * solved, where A is the Hessian, b is the negative gradient, and x is the
+ * offset of the interpolated maxima coordinates from the initial estimate.
+ * This is equivalent to an iteration of Netwon's optimisation algorithm.
+ *
+ * N9 contains the samples in the 3x3x3 neighbourhood of the maxima
+ * dx is the sampling step in x
+ * dy is the sampling step in y
+ * ds is the sampling step in size
+ * point contains the keypoint coordinates and scale to be modified
+ *
+ * Return value is 1 if interpolation was successful, 0 on failure.
+ */
+static int
+interpolateKeypoint( float N9[3][9], int dx, int dy, int ds, KeyPoint& kpt )
+{
+    Vec3f b(-(N9[1][5]-N9[1][3])/2,  // Negative 1st deriv with respect to x
+            -(N9[1][7]-N9[1][1])/2,  // Negative 1st deriv with respect to y
+            -(N9[2][4]-N9[0][4])/2); // Negative 1st deriv with respect to s
+
+    Matx33f A(
+        N9[1][3]-2*N9[1][4]+N9[1][5],            // 2nd deriv x, x
+        (N9[1][8]-N9[1][6]-N9[1][2]+N9[1][0])/4, // 2nd deriv x, y
+        (N9[2][5]-N9[2][3]-N9[0][5]+N9[0][3])/4, // 2nd deriv x, s
+        (N9[1][8]-N9[1][6]-N9[1][2]+N9[1][0])/4, // 2nd deriv x, y
+        N9[1][1]-2*N9[1][4]+N9[1][7],            // 2nd deriv y, y
+        (N9[2][7]-N9[2][1]-N9[0][7]+N9[0][1])/4, // 2nd deriv y, s
+        (N9[2][5]-N9[2][3]-N9[0][5]+N9[0][3])/4, // 2nd deriv x, s
+        (N9[2][7]-N9[2][1]-N9[0][7]+N9[0][1])/4, // 2nd deriv y, s
+        N9[0][4]-2*N9[1][4]+N9[2][4]);           // 2nd deriv s, s
+
+    Vec3f x = A.solve(b, DECOMP_LU);
+
+    bool ok = (x[0] != 0 || x[1] != 0 || x[2] != 0) &&
+        std::abs(x[0]) <= 1 && std::abs(x[1]) <= 1 && std::abs(x[2]) <= 1;
+
+    if( ok )
+    {
+        kpt.pt.x += x[0]*dx;
+        kpt.pt.y += x[1]*dy;
+        kpt.size = (float)cvRound( kpt.size + x[2]*ds );
+    }
+    return ok;
+}
+
+// Multi-threaded construction of the scale-space pyramid
+struct SURFBuildInvoker : ParallelLoopBody
+{
+    SURFBuildInvoker( const Mat& _sum, const std::vector<int>& _sizes,
+                      const std::vector<int>& _sampleSteps,
+                      std::vector<Mat>& _dets, std::vector<Mat>& _traces )
+    {
+        sum = &_sum;
+        sizes = &_sizes;
+        sampleSteps = &_sampleSteps;
+        dets = &_dets;
+        traces = &_traces;
+    }
+
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        for( int i=range.start; i<range.end; i++ )
+            calcLayerDetAndTrace( *sum, (*sizes)[i], (*sampleSteps)[i], (*dets)[i], (*traces)[i] );
+    }
+
+    const Mat *sum;
+    const std::vector<int> *sizes;
+    const std::vector<int> *sampleSteps;
+    std::vector<Mat>* dets;
+    std::vector<Mat>* traces;
+};
+
+// Multi-threaded search of the scale-space pyramid for keypoints
+struct SURFFindInvoker : ParallelLoopBody
+{
+    SURFFindInvoker( const Mat& _sum, const Mat& _mask_sum,
+                     const std::vector<Mat>& _dets, const std::vector<Mat>& _traces,
+                     const std::vector<int>& _sizes, const std::vector<int>& _sampleSteps,
+                     const std::vector<int>& _middleIndices, std::vector<KeyPoint>& _keypoints,
+                     int _nOctaveLayers, float _hessianThreshold )
+    {
+        sum = &_sum;
+        mask_sum = &_mask_sum;
+        dets = &_dets;
+        traces = &_traces;
+        sizes = &_sizes;
+        sampleSteps = &_sampleSteps;
+        middleIndices = &_middleIndices;
+        keypoints = &_keypoints;
+        nOctaveLayers = _nOctaveLayers;
+        hessianThreshold = _hessianThreshold;
+    }
+
+    static void findMaximaInLayer( const Mat& sum, const Mat& mask_sum,
+                   const std::vector<Mat>& dets, const std::vector<Mat>& traces,
+                   const std::vector<int>& sizes, std::vector<KeyPoint>& keypoints,
+                   int octave, int layer, float hessianThreshold, int sampleStep );
+
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        for( int i=range.start; i<range.end; i++ )
+        {
+            int layer = (*middleIndices)[i];
+            int octave = i / nOctaveLayers;
+            findMaximaInLayer( *sum, *mask_sum, *dets, *traces, *sizes,
+                               *keypoints, octave, layer, hessianThreshold,
+                               (*sampleSteps)[layer] );
+        }
+    }
+
+    const Mat *sum;
+    const Mat *mask_sum;
+    const std::vector<Mat>* dets;
+    const std::vector<Mat>* traces;
+    const std::vector<int>* sizes;
+    const std::vector<int>* sampleSteps;
+    const std::vector<int>* middleIndices;
+    std::vector<KeyPoint>* keypoints;
+    int nOctaveLayers;
+    float hessianThreshold;
+
+    static Mutex findMaximaInLayer_m;
+};
+
+Mutex SURFFindInvoker::findMaximaInLayer_m;
+
+
+/*
+ * Find the maxima in the determinant of the Hessian in a layer of the
+ * scale-space pyramid
+ */
+void SURFFindInvoker::findMaximaInLayer( const Mat& sum, const Mat& mask_sum,
+                   const std::vector<Mat>& dets, const std::vector<Mat>& traces,
+                   const std::vector<int>& sizes, std::vector<KeyPoint>& keypoints,
+                   int octave, int layer, float hessianThreshold, int sampleStep )
+{
+    // Wavelet Data
+    const int NM=1;
+    const int dm[NM][5] = { {0, 0, 9, 9, 1} };
+    SurfHF Dm;
+
+    int size = sizes[layer];
+
+    // The integral image 'sum' is one pixel bigger than the source image
+    int layer_rows = (sum.rows-1)/sampleStep;
+    int layer_cols = (sum.cols-1)/sampleStep;
+
+    // Ignore pixels without a 3x3x3 neighbourhood in the layer above
+    int margin = (sizes[layer+1]/2)/sampleStep+1;
+
+    if( !mask_sum.empty() )
+       resizeHaarPattern( dm, &Dm, NM, 9, size, mask_sum.cols );
+
+    int step = (int)(dets[layer].step/dets[layer].elemSize());
+
+    for( int i = margin; i < layer_rows - margin; i++ )
+    {
+        const float* det_ptr = dets[layer].ptr<float>(i);
+        const float* trace_ptr = traces[layer].ptr<float>(i);
+        for( int j = margin; j < layer_cols-margin; j++ )
+        {
+            float val0 = det_ptr[j];
+            if( val0 > hessianThreshold )
+            {
+                /* Coordinates for the start of the wavelet in the sum image. There
+                   is some integer division involved, so don't try to simplify this
+                   (cancel out sampleStep) without checking the result is the same */
+                int sum_i = sampleStep*(i-(size/2)/sampleStep);
+                int sum_j = sampleStep*(j-(size/2)/sampleStep);
+
+                /* The 3x3x3 neighbouring samples around the maxima.
+                   The maxima is included at N9[1][4] */
+
+                const float *det1 = &dets[layer-1].at<float>(i, j);
+                const float *det2 = &dets[layer].at<float>(i, j);
+                const float *det3 = &dets[layer+1].at<float>(i, j);
+                float N9[3][9] = { { det1[-step-1], det1[-step], det1[-step+1],
+                                     det1[-1]  , det1[0] , det1[1],
+                                     det1[step-1] , det1[step] , det1[step+1]  },
+                                   { det2[-step-1], det2[-step], det2[-step+1],
+                                     det2[-1]  , det2[0] , det2[1],
+                                     det2[step-1] , det2[step] , det2[step+1]  },
+                                   { det3[-step-1], det3[-step], det3[-step+1],
+                                     det3[-1]  , det3[0] , det3[1],
+                                     det3[step-1] , det3[step] , det3[step+1]  } };
+
+                /* Check the mask - why not just check the mask at the center of the wavelet? */
+                if( !mask_sum.empty() )
+                {
+                    const int* mask_ptr = &mask_sum.at<int>(sum_i, sum_j);
+                    float mval = calcHaarPattern( mask_ptr, &Dm, 1 );
+                    if( mval < 0.5 )
+                        continue;
+                }
+
+                /* Non-maxima suppression. val0 is at N9[1][4]*/
+                if( val0 > N9[0][0] && val0 > N9[0][1] && val0 > N9[0][2] &&
+                    val0 > N9[0][3] && val0 > N9[0][4] && val0 > N9[0][5] &&
+                    val0 > N9[0][6] && val0 > N9[0][7] && val0 > N9[0][8] &&
+                    val0 > N9[1][0] && val0 > N9[1][1] && val0 > N9[1][2] &&
+                    val0 > N9[1][3]                    && val0 > N9[1][5] &&
+                    val0 > N9[1][6] && val0 > N9[1][7] && val0 > N9[1][8] &&
+                    val0 > N9[2][0] && val0 > N9[2][1] && val0 > N9[2][2] &&
+                    val0 > N9[2][3] && val0 > N9[2][4] && val0 > N9[2][5] &&
+                    val0 > N9[2][6] && val0 > N9[2][7] && val0 > N9[2][8] )
+                {
+                    /* Calculate the wavelet center coordinates for the maxima */
+                    float center_i = sum_i + (size-1)*0.5f;
+                    float center_j = sum_j + (size-1)*0.5f;
+
+                    KeyPoint kpt( center_j, center_i, (float)sizes[layer],
+                                  -1, val0, octave, (trace_ptr[j] > 0) - (trace_ptr[j] < 0) );
+
+                    /* Interpolate maxima location within the 3x3x3 neighbourhood  */
+                    int ds = size - sizes[layer-1];
+                    int interp_ok = interpolateKeypoint( N9, sampleStep, sampleStep, ds, kpt );
+
+                    /* Sometimes the interpolation step gives a negative size etc. */
+                    if( interp_ok  )
+                    {
+                        /*printf( "KeyPoint %f %f %d\n", point.pt.x, point.pt.y, point.size );*/
+                        cv::AutoLock lock(findMaximaInLayer_m);
+                        keypoints.push_back(kpt);
+                    }
+                }
+            }
+        }
+    }
+}
+
+struct KeypointGreater
+{
+    inline bool operator()(const KeyPoint& kp1, const KeyPoint& kp2) const
+    {
+        if(kp1.response > kp2.response) return true;
+        if(kp1.response < kp2.response) return false;
+        if(kp1.size > kp2.size) return true;
+        if(kp1.size < kp2.size) return false;
+        if(kp1.octave > kp2.octave) return true;
+        if(kp1.octave < kp2.octave) return false;
+        if(kp1.pt.y < kp2.pt.y) return false;
+        if(kp1.pt.y > kp2.pt.y) return true;
+        return kp1.pt.x < kp2.pt.x;
+    }
+};
+
+
+static void fastHessianDetector( const Mat& sum, const Mat& mask_sum, std::vector<KeyPoint>& keypoints,
+                                 int nOctaves, int nOctaveLayers, float hessianThreshold )
+{
+    /* Sampling step along image x and y axes at first octave. This is doubled
+       for each additional octave. WARNING: Increasing this improves speed,
+       however keypoint extraction becomes unreliable. */
+    const int SAMPLE_STEP0 = 1;
+
+    int nTotalLayers = (nOctaveLayers+2)*nOctaves;
+    int nMiddleLayers = nOctaveLayers*nOctaves;
+
+    std::vector<Mat> dets(nTotalLayers);
+    std::vector<Mat> traces(nTotalLayers);
+    std::vector<int> sizes(nTotalLayers);
+    std::vector<int> sampleSteps(nTotalLayers);
+    std::vector<int> middleIndices(nMiddleLayers);
+
+    keypoints.clear();
+
+    // Allocate space and calculate properties of each layer
+    int index = 0, middleIndex = 0, step = SAMPLE_STEP0;
+
+    for( int octave = 0; octave < nOctaves; octave++ )
+    {
+        for( int layer = 0; layer < nOctaveLayers+2; layer++ )
+        {
+            /* The integral image sum is one pixel bigger than the source image*/
+            dets[index].create( (sum.rows-1)/step, (sum.cols-1)/step, CV_32F );
+            traces[index].create( (sum.rows-1)/step, (sum.cols-1)/step, CV_32F );
+            sizes[index] = (SURF_HAAR_SIZE0 + SURF_HAAR_SIZE_INC*layer) << octave;
+            sampleSteps[index] = step;
+
+            if( 0 < layer && layer <= nOctaveLayers )
+                middleIndices[middleIndex++] = index;
+            index++;
+        }
+        step *= 2;
+    }
+
+    // Calculate hessian determinant and trace samples in each layer
+    parallel_for_( Range(0, nTotalLayers),
+                   SURFBuildInvoker(sum, sizes, sampleSteps, dets, traces) );
+
+    // Find maxima in the determinant of the hessian
+    parallel_for_( Range(0, nMiddleLayers),
+                   SURFFindInvoker(sum, mask_sum, dets, traces, sizes,
+                                   sampleSteps, middleIndices, keypoints,
+                                   nOctaveLayers, hessianThreshold) );
+
+    std::sort(keypoints.begin(), keypoints.end(), KeypointGreater());
+}
+
+
+struct SURFInvoker : ParallelLoopBody
+{
+    enum { ORI_RADIUS = 6, ORI_WIN = 60, PATCH_SZ = 20 };
+
+    SURFInvoker( const Mat& _img, const Mat& _sum,
+                 std::vector<KeyPoint>& _keypoints, Mat& _descriptors,
+                 bool _extended, bool _upright )
+    {
+        keypoints = &_keypoints;
+        descriptors = &_descriptors;
+        img = &_img;
+        sum = &_sum;
+        extended = _extended;
+        upright = _upright;
+
+        // Simple bound for number of grid points in circle of radius ORI_RADIUS
+        const int nOriSampleBound = (2*ORI_RADIUS+1)*(2*ORI_RADIUS+1);
+
+        // Allocate arrays
+        apt.resize(nOriSampleBound);
+        aptw.resize(nOriSampleBound);
+        DW.resize(PATCH_SZ*PATCH_SZ);
+
+        /* Coordinates and weights of samples used to calculate orientation */
+        Mat G_ori = getGaussianKernel( 2*ORI_RADIUS+1, SURF_ORI_SIGMA, CV_32F );
+        nOriSamples = 0;
+        for( int i = -ORI_RADIUS; i <= ORI_RADIUS; i++ )
+        {
+            for( int j = -ORI_RADIUS; j <= ORI_RADIUS; j++ )
+            {
+                if( i*i + j*j <= ORI_RADIUS*ORI_RADIUS )
+                {
+                    apt[nOriSamples] = Point(i,j);
+                    aptw[nOriSamples++] = G_ori.at<float>(i+ORI_RADIUS,0) * G_ori.at<float>(j+ORI_RADIUS,0);
+                }
+            }
+        }
+        CV_Assert( nOriSamples <= nOriSampleBound );
+
+        /* Gaussian used to weight descriptor samples */
+        Mat G_desc = getGaussianKernel( PATCH_SZ, SURF_DESC_SIGMA, CV_32F );
+        for( int i = 0; i < PATCH_SZ; i++ )
+        {
+            for( int j = 0; j < PATCH_SZ; j++ )
+                DW[i*PATCH_SZ+j] = G_desc.at<float>(i,0) * G_desc.at<float>(j,0);
+        }
+    }
+
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        /* X and Y gradient wavelet data */
+        const int NX=2, NY=2;
+        const int dx_s[NX][5] = {{0, 0, 2, 4, -1}, {2, 0, 4, 4, 1}};
+        const int dy_s[NY][5] = {{0, 0, 4, 2, 1}, {0, 2, 4, 4, -1}};
+
+        // Optimisation is better using nOriSampleBound than nOriSamples for
+        // array lengths.  Maybe because it is a constant known at compile time
+        const int nOriSampleBound =(2*ORI_RADIUS+1)*(2*ORI_RADIUS+1);
+
+        float X[nOriSampleBound], Y[nOriSampleBound], angle[nOriSampleBound];
+        uchar PATCH[PATCH_SZ+1][PATCH_SZ+1];
+        float DX[PATCH_SZ][PATCH_SZ], DY[PATCH_SZ][PATCH_SZ];
+        Mat _patch(PATCH_SZ+1, PATCH_SZ+1, CV_8U, PATCH);
+
+        int dsize = extended ? 128 : 64;
+
+        int k, k1 = range.start, k2 = range.end;
+        float maxSize = 0;
+        for( k = k1; k < k2; k++ )
+        {
+            maxSize = std::max(maxSize, (*keypoints)[k].size);
+        }
+        int imaxSize = std::max(cvCeil((PATCH_SZ+1)*maxSize*1.2f/9.0f), 1);
+        cv::AutoBuffer<uchar> winbuf(imaxSize*imaxSize);
+
+        for( k = k1; k < k2; k++ )
+        {
+            int i, j, kk, nangle;
+            float* vec;
+            SurfHF dx_t[NX], dy_t[NY];
+            KeyPoint& kp = (*keypoints)[k];
+            float size = kp.size;
+            Point2f center = kp.pt;
+            /* The sampling intervals and wavelet sized for selecting an orientation
+             and building the keypoint descriptor are defined relative to 's' */
+            float s = size*1.2f/9.0f;
+            /* To find the dominant orientation, the gradients in x and y are
+             sampled in a circle of radius 6s using wavelets of size 4s.
+             We ensure the gradient wavelet size is even to ensure the
+             wavelet pattern is balanced and symmetric around its center */
+            int grad_wav_size = 2*cvRound( 2*s );
+            if( sum->rows < grad_wav_size || sum->cols < grad_wav_size )
+            {
+                /* when grad_wav_size is too big,
+                 * the sampling of gradient will be meaningless
+                 * mark keypoint for deletion. */
+                kp.size = -1;
+                continue;
+            }
+
+            float descriptor_dir = 360.f - 90.f;
+            if (upright == 0)
+            {
+                resizeHaarPattern( dx_s, dx_t, NX, 4, grad_wav_size, sum->cols );
+                resizeHaarPattern( dy_s, dy_t, NY, 4, grad_wav_size, sum->cols );
+                for( kk = 0, nangle = 0; kk < nOriSamples; kk++ )
+                {
+                    int x = cvRound( center.x + apt[kk].x*s - (float)(grad_wav_size-1)/2 );
+                    int y = cvRound( center.y + apt[kk].y*s - (float)(grad_wav_size-1)/2 );
+                    if( y < 0 || y >= sum->rows - grad_wav_size ||
+                        x < 0 || x >= sum->cols - grad_wav_size )
+                        continue;
+                    const int* ptr = &sum->at<int>(y, x);
+                    float vx = calcHaarPattern( ptr, dx_t, 2 );
+                    float vy = calcHaarPattern( ptr, dy_t, 2 );
+                    X[nangle] = vx*aptw[kk];
+                    Y[nangle] = vy*aptw[kk];
+                    nangle++;
+                }
+                if( nangle == 0 )
+                {
+                    // No gradient could be sampled because the keypoint is too
+                    // near too one or more of the sides of the image. As we
+                    // therefore cannot find a dominant direction, we skip this
+                    // keypoint and mark it for later deletion from the sequence.
+                    kp.size = -1;
+                    continue;
+                }
+
+                phase( Mat(1, nangle, CV_32F, X), Mat(1, nangle, CV_32F, Y), Mat(1, nangle, CV_32F, angle), true );
+
+                float bestx = 0, besty = 0, descriptor_mod = 0;
+                for( i = 0; i < 360; i += SURF_ORI_SEARCH_INC )
+                {
+                    float sumx = 0, sumy = 0, temp_mod;
+                    for( j = 0; j < nangle; j++ )
+                    {
+                        int d = std::abs(cvRound(angle[j]) - i);
+                        if( d < ORI_WIN/2 || d > 360-ORI_WIN/2 )
+                        {
+                            sumx += X[j];
+                            sumy += Y[j];
+                        }
+                    }
+                    temp_mod = sumx*sumx + sumy*sumy;
+                    if( temp_mod > descriptor_mod )
+                    {
+                        descriptor_mod = temp_mod;
+                        bestx = sumx;
+                        besty = sumy;
+                    }
+                }
+                descriptor_dir = fastAtan2( -besty, bestx );
+            }
+            kp.angle = descriptor_dir;
+            if( !descriptors || !descriptors->data )
+                continue;
+
+            /* Extract a window of pixels around the keypoint of size 20s */
+            int win_size = (int)((PATCH_SZ+1)*s);
+            CV_Assert( imaxSize >= win_size );
+            Mat win(win_size, win_size, CV_8U, winbuf.data());
+
+            if( !upright )
+            {
+                descriptor_dir *= (float)(CV_PI/180);
+                float sin_dir = -std::sin(descriptor_dir);
+                float cos_dir =  std::cos(descriptor_dir);
+
+                /* Subpixel interpolation version (slower). Subpixel not required since
+                the pixels will all get averaged when we scale down to 20 pixels */
+                /*
+                float w[] = { cos_dir, sin_dir, center.x,
+                -sin_dir, cos_dir , center.y };
+                CvMat W = cvMat(2, 3, CV_32F, w);
+                cvGetQuadrangleSubPix( img, &win, &W );
+                */
+
+                float win_offset = -(float)(win_size-1)/2;
+                float start_x = center.x + win_offset*cos_dir + win_offset*sin_dir;
+                float start_y = center.y - win_offset*sin_dir + win_offset*cos_dir;
+                uchar* WIN = win.data;
+#if 0
+                // Nearest neighbour version (faster)
+                for( i = 0; i < win_size; i++, start_x += sin_dir, start_y += cos_dir )
+                {
+                    float pixel_x = start_x;
+                    float pixel_y = start_y;
+                    for( j = 0; j < win_size; j++, pixel_x += cos_dir, pixel_y -= sin_dir )
+                    {
+                        int x = std::min(std::max(cvRound(pixel_x), 0), img->cols-1);
+                        int y = std::min(std::max(cvRound(pixel_y), 0), img->rows-1);
+                        WIN[i*win_size + j] = img->at<uchar>(y, x);
+                    }
+                }
+#else
+                int ncols1 = img->cols-1, nrows1 = img->rows-1;
+                size_t imgstep = img->step;
+                for( i = 0; i < win_size; i++, start_x += sin_dir, start_y += cos_dir )
+                {
+                    double pixel_x = start_x;
+                    double pixel_y = start_y;
+                    for( j = 0; j < win_size; j++, pixel_x += cos_dir, pixel_y -= sin_dir )
+                    {
+                        int ix = cvFloor(pixel_x), iy = cvFloor(pixel_y);
+                        if( (unsigned)ix < (unsigned)ncols1 &&
+                            (unsigned)iy < (unsigned)nrows1 )
+                        {
+                            float a = (float)(pixel_x - ix), b = (float)(pixel_y - iy);
+                            const uchar* imgptr = &img->at<uchar>(iy, ix);
+                            WIN[i*win_size + j] = (uchar)
+                                cvRound(imgptr[0]*(1.f - a)*(1.f - b) +
+                                        imgptr[1]*a*(1.f - b) +
+                                        imgptr[imgstep]*(1.f - a)*b +
+                                        imgptr[imgstep+1]*a*b);
+                        }
+                        else
+                        {
+                            int x = std::min(std::max(cvRound(pixel_x), 0), ncols1);
+                            int y = std::min(std::max(cvRound(pixel_y), 0), nrows1);
+                            WIN[i*win_size + j] = img->at<uchar>(y, x);
+                        }
+                    }
+                }
+#endif
+            }
+            else
+            {
+                // extract rect - slightly optimized version of the code above
+                // TODO: find faster code, as this is simply an extract rect operation,
+                //       e.g. by using cvGetSubRect, problem is the border processing
+                // descriptor_dir == 90 grad
+                // sin_dir == 1
+                // cos_dir == 0
+
+                float win_offset = -(float)(win_size-1)/2;
+                int start_x = cvRound(center.x + win_offset);
+                int start_y = cvRound(center.y - win_offset);
+                uchar* WIN = win.data;
+                for( i = 0; i < win_size; i++, start_x++ )
+                {
+                    int pixel_x = start_x;
+                    int pixel_y = start_y;
+                    for( j = 0; j < win_size; j++, pixel_y-- )
+                    {
+                        int x = MAX( pixel_x, 0 );
+                        int y = MAX( pixel_y, 0 );
+                        x = MIN( x, img->cols-1 );
+                        y = MIN( y, img->rows-1 );
+                        WIN[i*win_size + j] = img->at<uchar>(y, x);
+                    }
+                }
+            }
+            // Scale the window to size PATCH_SZ so each pixel's size is s. This
+            // makes calculating the gradients with wavelets of size 2s easy
+            resize(win, _patch, _patch.size(), 0, 0, INTER_AREA);
+
+            // Calculate gradients in x and y with wavelets of size 2s
+            for( i = 0; i < PATCH_SZ; i++ )
+                for( j = 0; j < PATCH_SZ; j++ )
+                {
+                    float dw = DW[i*PATCH_SZ + j];
+                    float vx = (PATCH[i][j+1] - PATCH[i][j] + PATCH[i+1][j+1] - PATCH[i+1][j])*dw;
+                    float vy = (PATCH[i+1][j] - PATCH[i][j] + PATCH[i+1][j+1] - PATCH[i][j+1])*dw;
+                    DX[i][j] = vx;
+                    DY[i][j] = vy;
+                }
+
+            // Construct the descriptor
+            vec = descriptors->ptr<float>(k);
+            for( kk = 0; kk < dsize; kk++ )
+                vec[kk] = 0;
+            double square_mag = 0;
+            if( extended )
+            {
+                // 128-bin descriptor
+                for( i = 0; i < 4; i++ )
+                    for( j = 0; j < 4; j++ )
+                    {
+                        for(int y = i*5; y < i*5+5; y++ )
+                        {
+                            for(int x = j*5; x < j*5+5; x++ )
+                            {
+                                float tx = DX[y][x], ty = DY[y][x];
+                                if( ty >= 0 )
+                                {
+                                    vec[0] += tx;
+                                    vec[1] += (float)fabs(tx);
+                                } else {
+                                    vec[2] += tx;
+                                    vec[3] += (float)fabs(tx);
+                                }
+                                if ( tx >= 0 )
+                                {
+                                    vec[4] += ty;
+                                    vec[5] += (float)fabs(ty);
+                                } else {
+                                    vec[6] += ty;
+                                    vec[7] += (float)fabs(ty);
+                                }
+                            }
+                        }
+                        for( kk = 0; kk < 8; kk++ )
+                            square_mag += vec[kk]*vec[kk];
+                        vec += 8;
+                    }
+            }
+            else
+            {
+                // 64-bin descriptor
+                for( i = 0; i < 4; i++ )
+                    for( j = 0; j < 4; j++ )
+                    {
+                        for(int y = i*5; y < i*5+5; y++ )
+                        {
+                            for(int x = j*5; x < j*5+5; x++ )
+                            {
+                                float tx = DX[y][x], ty = DY[y][x];
+                                vec[0] += tx; vec[1] += ty;
+                                vec[2] += (float)fabs(tx); vec[3] += (float)fabs(ty);
+                            }
+                        }
+                        for( kk = 0; kk < 4; kk++ )
+                            square_mag += vec[kk]*vec[kk];
+                        vec+=4;
+                    }
+            }
+
+            // unit vector is essential for contrast invariance
+            vec = descriptors->ptr<float>(k);
+            float scale = (float)(1./(std::sqrt(square_mag) + FLT_EPSILON));
+            for( kk = 0; kk < dsize; kk++ )
+                vec[kk] *= scale;
+        }
+    }
+
+    // Parameters
+    const Mat* img;
+    const Mat* sum;
+    std::vector<KeyPoint>* keypoints;
+    Mat* descriptors;
+    bool extended;
+    bool upright;
+
+    // Pre-calculated values
+    int nOriSamples;
+    std::vector<Point> apt;
+    std::vector<float> aptw;
+    std::vector<float> DW;
+};
+
+
+SURF_Impl::SURF_Impl(double _threshold, int _nOctaves, int _nOctaveLayers, bool _extended, bool _upright)
+{
+    hessianThreshold = _threshold;
+    extended = _extended;
+    upright = _upright;
+    nOctaves = _nOctaves;
+    nOctaveLayers = _nOctaveLayers;
+}
+
+int SURF_Impl::descriptorSize() const { return extended ? 128 : 64; }
+int SURF_Impl::descriptorType() const { return CV_32F; }
+int SURF_Impl::defaultNorm() const { return NORM_L2; }
+
+
+void SURF_Impl::detectAndCompute(InputArray _img, InputArray _mask,
+                      CV_OUT std::vector<KeyPoint>& keypoints,
+                      OutputArray _descriptors,
+                      bool useProvidedKeypoints)
+{
+    int imgtype = _img.type(), imgcn = CV_MAT_CN(imgtype);
+    bool doDescriptors = _descriptors.needed();
+
+    CV_Assert(!_img.empty() && CV_MAT_DEPTH(imgtype) == CV_8U && (imgcn == 1 || imgcn == 3 || imgcn == 4));
+    CV_Assert(_descriptors.needed() || !useProvidedKeypoints);
+
+#ifdef HAVE_OPENCL
+    if( ocl::useOpenCL() && _img.isUMat())
+    {
+        SURF_OCL ocl_surf;
+        UMat gpu_kpt;
+        bool ok = ocl_surf.init(this);
+
+        if( ok )
+        {
+            if( !_descriptors.needed() )
+            {
+                ok = ocl_surf.detect(_img, _mask, gpu_kpt);
+            }
+            else
+            {
+                if(useProvidedKeypoints)
+                    ocl_surf.uploadKeypoints(keypoints, gpu_kpt);
+                ok = ocl_surf.detectAndCompute(_img, _mask, gpu_kpt, _descriptors, useProvidedKeypoints);
+            }
+        }
+        if( ok )
+        {
+            if(!useProvidedKeypoints)
+                ocl_surf.downloadKeypoints(gpu_kpt, keypoints);
+            return;
+        }
+    }
+#endif // HAVE_OPENCL
+
+    Mat img = _img.getMat(), mask = _mask.getMat(), mask1, sum, msum;
+
+    if( imgcn > 1 )
+        cvtColor(img, img, COLOR_BGR2GRAY);
+
+    CV_Assert(mask.empty() || (mask.type() == CV_8U && mask.size() == img.size()));
+    CV_Assert(hessianThreshold >= 0);
+    CV_Assert(nOctaves > 0);
+    CV_Assert(nOctaveLayers > 0);
+
+    integral(img, sum, CV_32S);
+
+    // Compute keypoints only if we are not asked for evaluating the descriptors are some given locations:
+    if( !useProvidedKeypoints )
+    {
+        if( !mask.empty() )
+        {
+            cv::min(mask, 1, mask1);
+            integral(mask1, msum, CV_32S);
+        }
+        fastHessianDetector( sum, msum, keypoints, nOctaves, nOctaveLayers, (float)hessianThreshold );
+        if (!mask.empty())
+        {
+            for (size_t i = 0; i < keypoints.size(); )
+            {
+                Point pt(keypoints[i].pt);
+                if (mask.at<uchar>(pt.y, pt.x) == 0)
+                {
+                    keypoints.erase(keypoints.begin() + i);
+                    continue; // keep "i"
+                }
+                i++;
+            }
+        }
+    }
+
+    int i, j, N = (int)keypoints.size();
+    if( N > 0 )
+    {
+        Mat descriptors;
+        bool _1d = false;
+        int dcols = extended ? 128 : 64;
+        size_t dsize = dcols*sizeof(float);
+
+        if( doDescriptors )
+        {
+            _1d = _descriptors.kind() == _InputArray::STD_VECTOR && _descriptors.type() == CV_32F;
+            if( _1d )
+            {
+                _descriptors.create(N*dcols, 1, CV_32F);
+                descriptors = _descriptors.getMat().reshape(1, N);
+            }
+            else
+            {
+                _descriptors.create(N, dcols, CV_32F);
+                descriptors = _descriptors.getMat();
+            }
+        }
+
+        // we call SURFInvoker in any case, even if we do not need descriptors,
+        // since it computes orientation of each feature.
+        parallel_for_(Range(0, N), SURFInvoker(img, sum, keypoints, descriptors, extended, upright) );
+
+        // remove keypoints that were marked for deletion
+        for( i = j = 0; i < N; i++ )
+        {
+            if( keypoints[i].size > 0 )
+            {
+                if( i > j )
+                {
+                    keypoints[j] = keypoints[i];
+                    if( doDescriptors )
+                        memcpy( descriptors.ptr(j), descriptors.ptr(i), dsize);
+                }
+                j++;
+            }
+        }
+        if( N > j )
+        {
+            N = j;
+            keypoints.resize(N);
+            if( doDescriptors )
+            {
+                Mat d = descriptors.rowRange(0, N);
+                if( _1d )
+                    d = d.reshape(1, N*dcols);
+                d.copyTo(_descriptors);
+            }
+        }
+    }
+}
+
+Ptr<SURF> SURF::create(double _threshold, int _nOctaves, int _nOctaveLayers, bool _extended, bool _upright)
+{
+    return makePtr<SURF_Impl>(_threshold, _nOctaves, _nOctaveLayers, _extended, _upright);
+}
+
+#else // ! #ifdef OPENCV_ENABLE_NONFREE
+Ptr<SURF> SURF::create(double, int, int, bool, bool)
+{
+    CV_Error(Error::StsNotImplemented,
+        "This algorithm is patented and is excluded in this configuration; "
+        "Set OPENCV_ENABLE_NONFREE CMake option and rebuild the library");
+}
+#endif
+
+String SURF::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".SURF");
+}
+
+}
+}
+
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.cuda.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.cuda.cpp
new file mode 100644
index 00000000..b64016b0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.cuda.cpp
@@ -0,0 +1,452 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+#if 1
+
+using namespace cv;
+using namespace cv::cuda;
+
+#ifndef OPENCV_ENABLE_NONFREE
+#define throw_no_nonfree     CV_Error(Error::StsNotImplemented, \
+        "This algorithm is patented and is excluded in this configuration; " \
+        "Set OPENCV_ENABLE_NONFREE CMake option and rebuild the library");
+
+cv::cuda::SURF_CUDA::SURF_CUDA() { throw_no_nonfree }
+cv::cuda::SURF_CUDA::SURF_CUDA(double, int, int, bool, float, bool) { throw_no_nonfree }
+Ptr<SURF_CUDA> cv::cuda::SURF_CUDA::create(double, int, int, bool, float, bool) { throw_no_nonfree }
+int cv::cuda::SURF_CUDA::descriptorSize() const { throw_no_nonfree }
+int cv::cuda::SURF_CUDA::defaultNorm() const { throw_no_nonfree }
+void cv::cuda::SURF_CUDA::uploadKeypoints(const std::vector<KeyPoint>&, GpuMat&) { throw_no_nonfree }
+void cv::cuda::SURF_CUDA::downloadKeypoints(const GpuMat&, std::vector<KeyPoint>&) { throw_no_nonfree }
+void cv::cuda::SURF_CUDA::downloadDescriptors(const GpuMat&, std::vector<float>&) { throw_no_nonfree }
+void cv::cuda::SURF_CUDA::operator()(const GpuMat&, const GpuMat&, GpuMat&) { throw_no_nonfree }
+void cv::cuda::SURF_CUDA::operator()(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool) { throw_no_nonfree }
+void cv::cuda::SURF_CUDA::operator()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&) { throw_no_nonfree }
+void cv::cuda::SURF_CUDA::operator()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&, GpuMat&, bool) { throw_no_nonfree }
+void cv::cuda::SURF_CUDA::operator()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&, std::vector<float>&, bool) { throw_no_nonfree }
+void cv::cuda::SURF_CUDA::releaseMemory() { throw_no_nonfree }
+
+
+#elif (!defined (HAVE_CUDA) || !defined (HAVE_OPENCV_CUDAARITHM))
+
+cv::cuda::SURF_CUDA::SURF_CUDA() { throw_no_cuda(); }
+cv::cuda::SURF_CUDA::SURF_CUDA(double, int, int, bool, float, bool) { throw_no_cuda(); }
+Ptr<SURF_CUDA> cv::cuda::SURF_CUDA::create(double, int, int, bool, float, bool) { throw_no_cuda(); }
+int cv::cuda::SURF_CUDA::descriptorSize() const { throw_no_cuda(); }
+int cv::cuda::SURF_CUDA::defaultNorm() const { throw_no_cuda(); }
+void cv::cuda::SURF_CUDA::uploadKeypoints(const std::vector<KeyPoint>&, GpuMat&) { throw_no_cuda(); }
+void cv::cuda::SURF_CUDA::downloadKeypoints(const GpuMat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
+void cv::cuda::SURF_CUDA::downloadDescriptors(const GpuMat&, std::vector<float>&) { throw_no_cuda(); }
+void cv::cuda::SURF_CUDA::operator()(const GpuMat&, const GpuMat&, GpuMat&) { throw_no_cuda(); }
+void cv::cuda::SURF_CUDA::operator()(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool) { throw_no_cuda(); }
+void cv::cuda::SURF_CUDA::operator()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
+void cv::cuda::SURF_CUDA::operator()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&, GpuMat&, bool) { throw_no_cuda(); }
+void cv::cuda::SURF_CUDA::operator()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&, std::vector<float>&, bool) { throw_no_cuda(); }
+void cv::cuda::SURF_CUDA::releaseMemory() { throw_no_cuda(); }
+
+#else // OPENCV_ENABLE_NONFREE
+
+namespace cv { namespace cuda { namespace device
+{
+    namespace surf
+    {
+        void loadGlobalConstants(int maxCandidates, int maxFeatures, int img_rows, int img_cols, int nOctaveLayers, float hessianThreshold);
+        void loadOctaveConstants(int octave, int layer_rows, int layer_cols);
+
+        void icvCalcLayerDetAndTrace_gpu(const PtrStepSz<unsigned int>& sum, const PtrStepf& det, const PtrStepf& trace, int img_rows, int img_cols,
+            int octave, int nOctaveLayer);
+
+        void icvFindMaximaInLayer_gpu(const PtrStepSz<unsigned int>& maskSum, const PtrStepf& det, const PtrStepf& trace, int4* maxPosBuffer, unsigned int* maxCounter,
+            int img_rows, int img_cols, int octave, bool use_mask, int nLayers);
+
+        void icvInterpolateKeypoint_gpu(const PtrStepf& det, const int4* maxPosBuffer, unsigned int maxCounter,
+            float* featureX, float* featureY, int* featureLaplacian, int* featureOctave, float* featureSize, float* featureHessian,
+            unsigned int* featureCounter);
+
+        void icvCalcOrientation_gpu(const PtrStepSz<unsigned int>& sum, const float* featureX, const float* featureY, const float* featureSize, float* featureDir, int nFeatures);
+
+        void compute_descriptors_gpu(const PtrStepSzb& img, PtrStepSz<float4> descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir, int nFeatures);
+    }
+}}}
+
+using namespace ::cv::cuda::device::surf;
+
+namespace
+{
+    Mutex mtx;
+
+    int calcSize(int octave, int layer)
+    {
+        /* Wavelet size at first layer of first octave. */
+        const int HAAR_SIZE0 = 9;
+
+        /* Wavelet size increment between layers. This should be an even number,
+         such that the wavelet sizes in an octave are either all even or all odd.
+         This ensures that when looking for the neighbours of a sample, the layers
+
+         above and below are aligned correctly. */
+        const int HAAR_SIZE_INC = 6;
+
+        return (HAAR_SIZE0 + HAAR_SIZE_INC * layer) << octave;
+    }
+
+    class SURF_CUDA_Invoker
+    {
+    public:
+        SURF_CUDA_Invoker(cv::cuda::SURF_CUDA& surf, const GpuMat& img_, const GpuMat& mask) : surf_(surf), img(img_), img_cols(img_.cols), img_rows(img_.rows), use_mask(!mask.empty())
+        {
+            CV_Assert(!img.empty() && img.type() == CV_8UC1);
+            CV_Assert(mask.empty() || (mask.size() == img.size() && mask.type() == CV_8UC1));
+            CV_Assert(surf_.nOctaves > 0 && surf_.nOctaveLayers > 0);
+
+            const int min_size = calcSize(surf_.nOctaves - 1, 0);
+            CV_Assert(img_rows - min_size >= 0);
+            CV_Assert(img_cols - min_size >= 0);
+
+            const int layer_rows = img_rows >> (surf_.nOctaves - 1);
+            const int layer_cols = img_cols >> (surf_.nOctaves - 1);
+            const int min_margin = ((calcSize((surf_.nOctaves - 1), 2) >> 1) >> (surf_.nOctaves - 1)) + 1;
+            CV_Assert(layer_rows - 2 * min_margin > 0);
+            CV_Assert(layer_cols - 2 * min_margin > 0);
+
+            maxFeatures = std::min(static_cast<int>(img.size().area() * surf.keypointsRatio), 65535);
+            maxCandidates = std::min(static_cast<int>(1.5 * maxFeatures), 65535);
+
+            CV_Assert(maxFeatures > 0);
+
+            counters.create(1, surf_.nOctaves + 1, CV_32SC1);
+            counters.setTo(Scalar::all(0));
+
+            loadGlobalConstants(maxCandidates, maxFeatures, img_rows, img_cols, surf_.nOctaveLayers, static_cast<float>(surf_.hessianThreshold));
+
+            cuda::integral(img, surf_.sum);
+
+            if (use_mask)
+            {
+                cuda::min(mask, 1.0, surf_.mask1);
+                cuda::integral(surf_.mask1, surf_.maskSum);
+            }
+        }
+
+        void detectKeypoints(GpuMat& keypoints)
+        {
+            ensureSizeIsEnough(img_rows * (surf_.nOctaveLayers + 2), img_cols, CV_32FC1, surf_.det);
+            ensureSizeIsEnough(img_rows * (surf_.nOctaveLayers + 2), img_cols, CV_32FC1, surf_.trace);
+
+            ensureSizeIsEnough(1, maxCandidates, CV_32SC4, surf_.maxPosBuffer);
+            ensureSizeIsEnough(SURF_CUDA::ROWS_COUNT, maxFeatures, CV_32FC1, keypoints);
+            keypoints.setTo(Scalar::all(0));
+
+            for (int octave = 0; octave < surf_.nOctaves; ++octave)
+            {
+                const int layer_rows = img_rows >> octave;
+                const int layer_cols = img_cols >> octave;
+                loadOctaveConstants(octave, layer_rows, layer_cols);
+
+                icvCalcLayerDetAndTrace_gpu(surf_.sum, surf_.det, surf_.trace, img_rows, img_cols, octave, surf_.nOctaveLayers);
+
+                icvFindMaximaInLayer_gpu(surf_.maskSum, surf_.det, surf_.trace, surf_.maxPosBuffer.ptr<int4>(), counters.ptr<unsigned int>() + 1 + octave,
+                    img_rows, img_cols, octave, use_mask, surf_.nOctaveLayers);
+
+                unsigned int maxCounter;
+                cudaSafeCall( cudaMemcpy(&maxCounter, counters.ptr<unsigned int>() + 1 + octave, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+                maxCounter = std::min(maxCounter, static_cast<unsigned int>(maxCandidates));
+
+                if (maxCounter > 0)
+                {
+                    icvInterpolateKeypoint_gpu(surf_.det, surf_.maxPosBuffer.ptr<int4>(), maxCounter,
+                        keypoints.ptr<float>(SURF_CUDA::X_ROW), keypoints.ptr<float>(SURF_CUDA::Y_ROW),
+                        keypoints.ptr<int>(SURF_CUDA::LAPLACIAN_ROW), keypoints.ptr<int>(SURF_CUDA::OCTAVE_ROW),
+                        keypoints.ptr<float>(SURF_CUDA::SIZE_ROW), keypoints.ptr<float>(SURF_CUDA::HESSIAN_ROW),
+                        counters.ptr<unsigned int>());
+                }
+            }
+            unsigned int featureCounter;
+            cudaSafeCall( cudaMemcpy(&featureCounter, counters.ptr<unsigned int>(), sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+            featureCounter = std::min(featureCounter, static_cast<unsigned int>(maxFeatures));
+
+            keypoints.cols = featureCounter;
+
+            if (surf_.upright)
+                keypoints.row(SURF_CUDA::ANGLE_ROW).setTo(Scalar::all(360.0 - 90.0));
+            else
+                findOrientation(keypoints);
+        }
+
+        void findOrientation(GpuMat& keypoints)
+        {
+            const int nFeatures = keypoints.cols;
+            if (nFeatures > 0)
+            {
+                icvCalcOrientation_gpu(surf_.sum, keypoints.ptr<float>(SURF_CUDA::X_ROW), keypoints.ptr<float>(SURF_CUDA::Y_ROW),
+                    keypoints.ptr<float>(SURF_CUDA::SIZE_ROW), keypoints.ptr<float>(SURF_CUDA::ANGLE_ROW), nFeatures);
+            }
+        }
+
+        void computeDescriptors(const GpuMat& keypoints, GpuMat& descriptors, int descriptorSize)
+        {
+            const int nFeatures = keypoints.cols;
+            if (nFeatures > 0)
+            {
+                ensureSizeIsEnough(nFeatures, descriptorSize, CV_32F, descriptors);
+                compute_descriptors_gpu(img, descriptors, keypoints.ptr<float>(SURF_CUDA::X_ROW), keypoints.ptr<float>(SURF_CUDA::Y_ROW),
+                    keypoints.ptr<float>(SURF_CUDA::SIZE_ROW), keypoints.ptr<float>(SURF_CUDA::ANGLE_ROW), nFeatures);
+            }
+        }
+
+    private:
+        SURF_CUDA_Invoker(const SURF_CUDA_Invoker&);
+        SURF_CUDA_Invoker& operator =(const SURF_CUDA_Invoker&);
+
+        SURF_CUDA& surf_;
+
+        GpuMat img;
+
+        int img_cols, img_rows;
+
+        bool use_mask;
+
+        int maxCandidates;
+        int maxFeatures;
+
+        GpuMat counters;
+    };
+}
+
+cv::cuda::SURF_CUDA::SURF_CUDA()
+{
+    hessianThreshold = 100;
+    extended = true;
+    nOctaves = 4;
+    nOctaveLayers = 2;
+    keypointsRatio = 0.01f;
+    upright = false;
+}
+
+cv::cuda::SURF_CUDA::SURF_CUDA(double _threshold, int _nOctaves, int _nOctaveLayers, bool _extended, float _keypointsRatio, bool _upright)
+{
+    hessianThreshold = _threshold;
+    extended = _extended;
+    nOctaves = _nOctaves;
+    nOctaveLayers = _nOctaveLayers;
+    keypointsRatio = _keypointsRatio;
+    upright = _upright;
+}
+
+int cv::cuda::SURF_CUDA::descriptorSize() const
+{
+    return extended ? 128 : 64;
+}
+
+int cv::cuda::SURF_CUDA::defaultNorm() const
+{
+    return NORM_L2;
+}
+
+void cv::cuda::SURF_CUDA::uploadKeypoints(const std::vector<KeyPoint>& keypoints, GpuMat& keypointsGPU)
+{
+    if (keypoints.empty())
+        keypointsGPU.release();
+    else
+    {
+        Mat keypointsCPU(SURF_CUDA::ROWS_COUNT, static_cast<int>(keypoints.size()), CV_32FC1);
+
+        float* kp_x = keypointsCPU.ptr<float>(SURF_CUDA::X_ROW);
+        float* kp_y = keypointsCPU.ptr<float>(SURF_CUDA::Y_ROW);
+        int* kp_laplacian = keypointsCPU.ptr<int>(SURF_CUDA::LAPLACIAN_ROW);
+        int* kp_octave = keypointsCPU.ptr<int>(SURF_CUDA::OCTAVE_ROW);
+        float* kp_size = keypointsCPU.ptr<float>(SURF_CUDA::SIZE_ROW);
+        float* kp_dir = keypointsCPU.ptr<float>(SURF_CUDA::ANGLE_ROW);
+        float* kp_hessian = keypointsCPU.ptr<float>(SURF_CUDA::HESSIAN_ROW);
+
+        for (size_t i = 0, size = keypoints.size(); i < size; ++i)
+        {
+            const KeyPoint& kp = keypoints[i];
+            kp_x[i] = kp.pt.x;
+            kp_y[i] = kp.pt.y;
+            kp_octave[i] = kp.octave;
+            kp_size[i] = kp.size;
+            kp_dir[i] = kp.angle;
+            kp_hessian[i] = kp.response;
+            kp_laplacian[i] = 1;
+        }
+
+        keypointsGPU.upload(keypointsCPU);
+    }
+}
+
+void cv::cuda::SURF_CUDA::downloadKeypoints(const GpuMat& keypointsGPU, std::vector<KeyPoint>& keypoints)
+{
+    const int nFeatures = keypointsGPU.cols;
+
+    if (nFeatures == 0)
+        keypoints.clear();
+    else
+    {
+        CV_Assert(keypointsGPU.type() == CV_32FC1 && keypointsGPU.rows == ROWS_COUNT);
+
+        Mat keypointsCPU(keypointsGPU);
+
+        keypoints.resize(nFeatures);
+
+        float* kp_x = keypointsCPU.ptr<float>(SURF_CUDA::X_ROW);
+        float* kp_y = keypointsCPU.ptr<float>(SURF_CUDA::Y_ROW);
+        int* kp_laplacian = keypointsCPU.ptr<int>(SURF_CUDA::LAPLACIAN_ROW);
+        int* kp_octave = keypointsCPU.ptr<int>(SURF_CUDA::OCTAVE_ROW);
+        float* kp_size = keypointsCPU.ptr<float>(SURF_CUDA::SIZE_ROW);
+        float* kp_dir = keypointsCPU.ptr<float>(SURF_CUDA::ANGLE_ROW);
+        float* kp_hessian = keypointsCPU.ptr<float>(SURF_CUDA::HESSIAN_ROW);
+
+        for (int i = 0; i < nFeatures; ++i)
+        {
+            KeyPoint& kp = keypoints[i];
+            kp.pt.x = kp_x[i];
+            kp.pt.y = kp_y[i];
+            kp.class_id = kp_laplacian[i];
+            kp.octave = kp_octave[i];
+            kp.size = kp_size[i];
+            kp.angle = kp_dir[i];
+            kp.response = kp_hessian[i];
+        }
+    }
+}
+
+void cv::cuda::SURF_CUDA::downloadDescriptors(const GpuMat& descriptorsGPU, std::vector<float>& descriptors)
+{
+    if (descriptorsGPU.empty())
+        descriptors.clear();
+    else
+    {
+        CV_Assert(descriptorsGPU.type() == CV_32F);
+
+        descriptors.resize(descriptorsGPU.rows * descriptorsGPU.cols);
+        Mat descriptorsCPU(descriptorsGPU.size(), CV_32F, &descriptors[0]);
+        descriptorsGPU.download(descriptorsCPU);
+    }
+}
+
+void cv::cuda::SURF_CUDA::operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints)
+{
+    AutoLock lock(mtx);
+    if (!img.empty())
+    {
+        SURF_CUDA_Invoker surf(*this, img, mask);
+
+        surf.detectKeypoints(keypoints);
+    }
+}
+
+void cv::cuda::SURF_CUDA::operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints, GpuMat& descriptors,
+                                   bool useProvidedKeypoints)
+{
+    AutoLock lock(mtx);
+    if (!img.empty())
+    {
+        SURF_CUDA_Invoker surf(*this, img, mask);
+
+        if (!useProvidedKeypoints)
+            surf.detectKeypoints(keypoints);
+        else if (!upright)
+        {
+            surf.findOrientation(keypoints);
+        }
+
+        surf.computeDescriptors(keypoints, descriptors, descriptorSize());
+    }
+}
+
+void cv::cuda::SURF_CUDA::operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints)
+{
+    AutoLock lock(mtx);
+    GpuMat keypointsGPU;
+
+    (*this)(img, mask, keypointsGPU);
+
+    downloadKeypoints(keypointsGPU, keypoints);
+}
+
+void cv::cuda::SURF_CUDA::operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints,
+    GpuMat& descriptors, bool useProvidedKeypoints)
+{
+    AutoLock lock(mtx);
+    GpuMat keypointsGPU;
+
+    if (useProvidedKeypoints)
+        uploadKeypoints(keypoints, keypointsGPU);
+
+    (*this)(img, mask, keypointsGPU, descriptors, useProvidedKeypoints);
+
+    downloadKeypoints(keypointsGPU, keypoints);
+}
+
+void cv::cuda::SURF_CUDA::operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints,
+    std::vector<float>& descriptors, bool useProvidedKeypoints)
+{
+    AutoLock lock(mtx);
+    GpuMat descriptorsGPU;
+
+    (*this)(img, mask, keypoints, descriptorsGPU, useProvidedKeypoints);
+
+    downloadDescriptors(descriptorsGPU, descriptors);
+}
+
+void cv::cuda::SURF_CUDA::releaseMemory()
+{
+    sum.release();
+    mask1.release();
+    maskSum.release();
+    det.release();
+    trace.release();
+    maxPosBuffer.release();
+}
+
+Ptr<SURF_CUDA> cv::cuda::SURF_CUDA::create(double _hessianThreshold, int _nOctaves,
+    int _nOctaveLayers, bool _extended, float _keypointsRatio, bool _upright)
+{
+    return makePtr<SURF_CUDA>(_hessianThreshold, _nOctaves, _nOctaveLayers, _extended, _keypointsRatio, _upright);
+}
+
+#endif // !defined (OPENCV_ENABLE_NONFREE)
+#endif
+
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.hpp
new file mode 100644
index 00000000..3293850e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.hpp
@@ -0,0 +1,204 @@
+///////////// see LICENSE.txt in the OpenCV root directory //////////////
+
+#ifndef __OPENCV_XFEATURES2D_SURF_HPP__
+#define __OPENCV_XFEATURES2D_SURF_HPP__
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+//! Speeded up robust features, port from CUDA module.
+////////////////////////////////// SURF //////////////////////////////////////////
+/*!
+ SURF implementation.
+
+ The class implements SURF algorithm by H. Bay et al.
+ */
+class SURF_Impl : public SURF
+{
+public:
+    //! the full constructor taking all the necessary parameters
+    explicit CV_WRAP SURF_Impl(double hessianThreshold,
+                               int nOctaves = 4, int nOctaveLayers = 2,
+                               bool extended = true, bool upright = false);
+
+    void read( const FileNode& fn)
+    {
+      // if node is empty, keep previous value
+      if (!fn["hessianThreshold"].empty())
+        fn["hessianThreshold"] >> hessianThreshold;
+      if (!fn["extended"].empty())
+        fn["extended"] >> extended;
+      if (!fn["upright"].empty())
+        fn["upright"] >> upright;
+      if (!fn["nOctaves"].empty())
+        fn["nOctaves"] >> nOctaves;
+      if (!fn["nOctaveLayers"].empty())
+        fn["nOctaveLayers"] >> nOctaveLayers;
+    }
+    void write( FileStorage& fs) const
+    {
+      if(fs.isOpened())
+      {
+        fs << "name" << getDefaultName();
+        fs << "hessianThreshold" << hessianThreshold;
+        fs << "extended" << extended;
+        fs << "upright" << upright;
+        fs << "nOctaves" << nOctaves;
+        fs << "nOctaveLayers" << nOctaveLayers;
+      }
+    }
+
+    //! returns the descriptor size in float's (64 or 128)
+    CV_WRAP int descriptorSize() const CV_OVERRIDE;
+
+    //! returns the descriptor type
+    CV_WRAP int descriptorType() const CV_OVERRIDE;
+
+    //! returns the descriptor type
+    CV_WRAP int defaultNorm() const CV_OVERRIDE;
+
+    void set(int, double);
+    double get(int) const;
+
+    //! finds the keypoints and computes their descriptors.
+    // Optionally it can compute descriptors for the user-provided keypoints
+    void detectAndCompute(InputArray img, InputArray mask,
+                          CV_OUT std::vector<KeyPoint>& keypoints,
+                          OutputArray descriptors,
+                          bool useProvidedKeypoints = false) CV_OVERRIDE;
+
+    void setHessianThreshold(double hessianThreshold_) CV_OVERRIDE { hessianThreshold = hessianThreshold_; }
+    double getHessianThreshold() const CV_OVERRIDE { return hessianThreshold; }
+
+    void setNOctaves(int nOctaves_) CV_OVERRIDE { nOctaves = nOctaves_; }
+    int getNOctaves() const CV_OVERRIDE { return nOctaves; }
+
+    void setNOctaveLayers(int nOctaveLayers_) CV_OVERRIDE { nOctaveLayers = nOctaveLayers_; }
+    int getNOctaveLayers() const CV_OVERRIDE { return nOctaveLayers; }
+
+    void setExtended(bool extended_) CV_OVERRIDE { extended = extended_; }
+    bool getExtended() const CV_OVERRIDE { return extended; }
+
+    void setUpright(bool upright_) CV_OVERRIDE { upright = upright_; }
+    bool getUpright() const CV_OVERRIDE { return upright; }
+
+    double hessianThreshold;
+    int nOctaves;
+    int nOctaveLayers;
+    bool extended;
+    bool upright;
+};
+
+#ifdef HAVE_OPENCL
+class SURF_OCL
+{
+public:
+    enum KeypointLayout
+    {
+        X_ROW = 0,
+        Y_ROW,
+        LAPLACIAN_ROW,
+        OCTAVE_ROW,
+        SIZE_ROW,
+        ANGLE_ROW,
+        HESSIAN_ROW,
+        ROWS_COUNT
+    };
+
+    //! the full constructor taking all the necessary parameters
+    SURF_OCL();
+
+    bool init(const SURF_Impl* params);
+
+    //! returns the descriptor size in float's (64 or 128)
+    int descriptorSize() const { return params->extended ? 128 : 64; }
+
+    void uploadKeypoints(const std::vector<KeyPoint> &keypoints, UMat &keypointsGPU);
+    void downloadKeypoints(const UMat &keypointsGPU, std::vector<KeyPoint> &keypoints);
+
+    //! finds the keypoints using fast hessian detector used in SURF
+    //! supports CV_8UC1 images
+    //! keypoints will have nFeature cols and 6 rows
+    //! keypoints.ptr<float>(X_ROW)[i] will contain x coordinate of i'th feature
+    //! keypoints.ptr<float>(Y_ROW)[i] will contain y coordinate of i'th feature
+    //! keypoints.ptr<float>(LAPLACIAN_ROW)[i] will contain laplacian sign of i'th feature
+    //! keypoints.ptr<float>(OCTAVE_ROW)[i] will contain octave of i'th feature
+    //! keypoints.ptr<float>(SIZE_ROW)[i] will contain size of i'th feature
+    //! keypoints.ptr<float>(ANGLE_ROW)[i] will contain orientation of i'th feature
+    //! keypoints.ptr<float>(HESSIAN_ROW)[i] will contain response of i'th feature
+    bool detect(InputArray img, InputArray mask, UMat& keypoints);
+    //! finds the keypoints and computes their descriptors.
+    //! Optionally it can compute descriptors for the user-provided keypoints and recompute keypoints direction
+    bool detectAndCompute(InputArray img, InputArray mask, UMat& keypoints,
+                          OutputArray descriptors, bool useProvidedKeypoints = false);
+
+protected:
+    bool setImage(InputArray img, InputArray mask);
+
+    // kernel callers declarations
+    bool calcLayerDetAndTrace(int octave, int layer_rows);
+
+    bool findMaximaInLayer(int counterOffset, int octave, int layer_rows, int layer_cols);
+
+    bool interpolateKeypoint(int maxCounter, UMat &keypoints, int octave, int layer_rows, int maxFeatures);
+
+    bool calcOrientation(UMat &keypoints);
+
+    bool setUpRight(UMat &keypoints);
+
+    bool computeDescriptors(const UMat &keypoints, OutputArray descriptors);
+
+    bool detectKeypoints(UMat &keypoints);
+
+    const SURF_Impl* params;
+
+    //! max keypoints = min(keypointsRatio * img.size().area(), 65535)
+    UMat sum, intBuffer;
+    UMat det, trace;
+    UMat maxPosBuffer;
+
+    int img_cols, img_rows;
+
+    int maxCandidates;
+    int maxFeatures;
+
+    UMat img, counters;
+
+    // texture buffers
+    ocl::Image2D imgTex, sumTex;
+    bool haveImageSupport;
+    String kerOpts;
+
+    int status;
+};
+#endif // HAVE_OPENCL
+
+/*
+template<typename _Tp> void copyVectorToUMat(const std::vector<_Tp>& v, UMat& um)
+{
+    if(v.empty())
+        um.release();
+    else
+        Mat(1, (int)(v.size()*sizeof(v[0])), CV_8U, (void*)&v[0]).copyTo(um);
+}
+
+template<typename _Tp> void copyUMatToVector(const UMat& um, std::vector<_Tp>& v)
+{
+    if(um.empty())
+        v.clear();
+    else
+    {
+        size_t sz = um.total()*um.elemSize();
+        CV_Assert(um.isContinuous() && (sz % sizeof(_Tp) == 0));
+        v.resize(sz/sizeof(_Tp));
+        Mat m(um.size(), um.type(), &v[0]);
+        um.copyTo(m);
+    }
+}*/
+
+}
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.ocl.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.ocl.cpp
new file mode 100644
index 00000000..1352c7ec
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/surf.ocl.cpp
@@ -0,0 +1,473 @@
+/*M/////////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#include "precomp.hpp"
+
+#ifdef HAVE_OPENCL
+
+#include "surf.hpp"
+
+#include <cstdio>
+#include <sstream>
+#include "opencl_kernels_xfeatures2d.hpp"
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+#ifdef OPENCV_ENABLE_NONFREE
+
+enum { ORI_SEARCH_INC=5, ORI_LOCAL_SIZE=(360 / ORI_SEARCH_INC) };
+
+static inline int calcSize(int octave, int layer)
+{
+    /* Wavelet size at first layer of first octave. */
+    const int HAAR_SIZE0 = 9;
+
+    /* Wavelet size increment between layers. This should be an even number,
+    such that the wavelet sizes in an octave are either all even or all odd.
+    This ensures that when looking for the neighbors of a sample, the layers
+
+    above and below are aligned correctly. */
+    const int HAAR_SIZE_INC = 6;
+
+    return (HAAR_SIZE0 + HAAR_SIZE_INC * layer) << octave;
+}
+
+
+SURF_OCL::SURF_OCL()
+{
+    img_cols = img_rows = maxCandidates = maxFeatures = 0;
+    haveImageSupport = false;
+    status = -1;
+}
+
+bool SURF_OCL::init(const SURF_Impl* p)
+{
+    params = p;
+    if(status < 0)
+    {
+        status = 0;
+        if(ocl::haveOpenCL())
+        {
+            const ocl::Device& dev = ocl::Device::getDefault();
+            if( dev.type() == ocl::Device::TYPE_CPU )
+                return false;
+            haveImageSupport = dev.imageSupport();
+            kerOpts = format("%s%s",
+				haveImageSupport ? "-D HAVE_IMAGE2D" : "",
+				dev.doubleFPConfig() > 0? " -D DOUBLE_SUPPORT": "");
+            status = 1;
+        }
+    }
+    return status > 0;
+}
+
+
+bool SURF_OCL::setImage(InputArray _img, InputArray _mask)
+{
+    if( status <= 0 )
+        return false;
+    if( !_mask.empty())
+        return false;
+    int imgtype = _img.type();
+    CV_Assert(!_img.empty());
+    CV_Assert(params && params->nOctaves > 0 && params->nOctaveLayers > 0);
+
+    int min_size = calcSize(params->nOctaves - 1, 0);
+    Size sz = _img.size();
+    img_cols = sz.width;
+    img_rows = sz.height;
+    CV_Assert(img_rows >= min_size && img_cols >= min_size);
+
+    const int layer_rows = img_rows >> (params->nOctaves - 1);
+    const int layer_cols = img_cols >> (params->nOctaves - 1);
+    const int min_margin = ((calcSize((params->nOctaves - 1), 2) >> 1) >> (params->nOctaves - 1)) + 1;
+    CV_Assert(layer_rows - 2 * min_margin > 0);
+    CV_Assert(layer_cols - 2 * min_margin > 0);
+
+    maxFeatures   = std::min(static_cast<int>(img_cols*img_rows * 0.01f), 65535);
+    maxCandidates = std::min(static_cast<int>(1.5 * maxFeatures), 65535);
+
+    CV_Assert(maxFeatures > 0);
+
+    counters.create(1, params->nOctaves + 1, CV_32SC1);
+    counters.setTo(Scalar::all(0));
+
+    img.release();
+    if(_img.isUMat() && imgtype == CV_8UC1)
+        img = _img.getUMat();
+    else if( imgtype == CV_8UC1 )
+        _img.copyTo(img);
+    else
+        cvtColor(_img, img, COLOR_BGR2GRAY);
+
+    integral(img, sum);
+
+    if(haveImageSupport)
+    {
+        imgTex = ocl::Image2D(img);
+        sumTex = ocl::Image2D(sum);
+    }
+
+    return true;
+}
+
+
+bool SURF_OCL::detectKeypoints(UMat &keypoints)
+{
+    // create image pyramid buffers
+    // different layers have same sized buffers, but they are sampled from Gaussian kernel.
+    det.create(img_rows * (params->nOctaveLayers + 2), img_cols, CV_32F);
+    trace.create(img_rows * (params->nOctaveLayers + 2), img_cols, CV_32FC1);
+
+    maxPosBuffer.create(1, maxCandidates, CV_32SC4);
+    keypoints.create(SURF_OCL::ROWS_COUNT, maxFeatures, CV_32F);
+    keypoints.setTo(Scalar::all(0));
+    Mat cpuCounters;
+
+    for (int octave = 0; octave < params->nOctaves; ++octave)
+    {
+        const int layer_rows = img_rows >> octave;
+        const int layer_cols = img_cols >> octave;
+
+        if(!calcLayerDetAndTrace(octave, layer_rows))
+            return false;
+
+        if(!findMaximaInLayer(1 + octave, octave, layer_rows, layer_cols))
+            return false;
+
+        cpuCounters = counters.getMat(ACCESS_READ);
+        int maxCounter = cpuCounters.at<int>(1 + octave);
+        maxCounter = std::min(maxCounter, maxCandidates);
+        cpuCounters.release();
+
+        if (maxCounter > 0)
+        {
+            if(!interpolateKeypoint(maxCounter, keypoints, octave, layer_rows, maxFeatures))
+                return false;
+        }
+    }
+
+    cpuCounters = counters.getMat(ACCESS_READ);
+    int featureCounter = cpuCounters.at<int>(0);
+    featureCounter = std::min(featureCounter, maxFeatures);
+    cpuCounters.release();
+
+    keypoints = UMat(keypoints, Rect(0, 0, featureCounter, keypoints.rows));
+
+    if (params->upright)
+        return setUpRight(keypoints);
+    else
+        return calcOrientation(keypoints);
+}
+
+
+bool SURF_OCL::setUpRight(UMat &keypoints)
+{
+    int nFeatures = keypoints.cols;
+    if( nFeatures == 0 )
+        return true;
+
+    size_t globalThreads[3] = {(size_t)nFeatures, 1};
+    ocl::Kernel kerUpRight("SURF_setUpRight", ocl::xfeatures2d::surf_oclsrc, kerOpts);
+    return kerUpRight.args(ocl::KernelArg::ReadWrite(keypoints)).run(2, globalThreads, 0, true);
+}
+
+bool SURF_OCL::computeDescriptors(const UMat &keypoints, OutputArray _descriptors)
+{
+    int dsize = params->descriptorSize();
+    int nFeatures = keypoints.cols;
+    if (nFeatures == 0)
+    {
+        _descriptors.release();
+        return true;
+    }
+    _descriptors.create(nFeatures, dsize, CV_32F);
+    UMat descriptors;
+    if( _descriptors.isUMat() )
+        descriptors = _descriptors.getUMat();
+    else
+        descriptors.create(nFeatures, dsize, CV_32F);
+
+    ocl::Kernel kerCalcDesc, kerNormDesc;
+
+    if( dsize == 64 )
+    {
+        kerCalcDesc.create("SURF_computeDescriptors64", ocl::xfeatures2d::surf_oclsrc, kerOpts);
+        kerNormDesc.create("SURF_normalizeDescriptors64", ocl::xfeatures2d::surf_oclsrc, kerOpts);
+    }
+    else
+    {
+        CV_Assert(dsize == 128);
+        kerCalcDesc.create("SURF_computeDescriptors128", ocl::xfeatures2d::surf_oclsrc, kerOpts);
+        kerNormDesc.create("SURF_normalizeDescriptors128", ocl::xfeatures2d::surf_oclsrc, kerOpts);
+    }
+
+    size_t localThreads[] = {6, 6};
+    size_t globalThreads[] = {nFeatures*localThreads[0], 16 * localThreads[1]};
+
+    if(haveImageSupport)
+    {
+        kerCalcDesc.args(imgTex,
+                         img_rows, img_cols,
+                         ocl::KernelArg::ReadOnlyNoSize(keypoints),
+                         ocl::KernelArg::WriteOnlyNoSize(descriptors));
+    }
+    else
+    {
+        kerCalcDesc.args(ocl::KernelArg::ReadOnlyNoSize(img),
+                         img_rows, img_cols,
+                         ocl::KernelArg::ReadOnlyNoSize(keypoints),
+                         ocl::KernelArg::WriteOnlyNoSize(descriptors));
+    }
+
+    if(!kerCalcDesc.run(2, globalThreads, localThreads, true))
+        return false;
+
+    size_t localThreads_n[] = {(size_t)dsize, 1};
+    size_t globalThreads_n[] = {nFeatures*localThreads_n[0], localThreads_n[1]};
+
+    globalThreads[0] = nFeatures * localThreads[0];
+    globalThreads[1] = localThreads[1];
+    bool ok = kerNormDesc.args(ocl::KernelArg::ReadWriteNoSize(descriptors)).
+                        run(2, globalThreads_n, localThreads_n, true);
+    if(ok && !_descriptors.isUMat())
+        descriptors.copyTo(_descriptors);
+    return ok;
+}
+
+
+void SURF_OCL::uploadKeypoints(const std::vector<KeyPoint> &keypoints, UMat &keypointsGPU)
+{
+    if (keypoints.empty())
+        keypointsGPU.release();
+    else
+    {
+        Mat keypointsCPU(SURF_OCL::ROWS_COUNT, static_cast<int>(keypoints.size()), CV_32FC1);
+
+        float *kp_x = keypointsCPU.ptr<float>(SURF_OCL::X_ROW);
+        float *kp_y = keypointsCPU.ptr<float>(SURF_OCL::Y_ROW);
+        int *kp_laplacian = keypointsCPU.ptr<int>(SURF_OCL::LAPLACIAN_ROW);
+        int *kp_octave = keypointsCPU.ptr<int>(SURF_OCL::OCTAVE_ROW);
+        float *kp_size = keypointsCPU.ptr<float>(SURF_OCL::SIZE_ROW);
+        float *kp_dir = keypointsCPU.ptr<float>(SURF_OCL::ANGLE_ROW);
+        float *kp_hessian = keypointsCPU.ptr<float>(SURF_OCL::HESSIAN_ROW);
+
+        for (size_t i = 0, size = keypoints.size(); i < size; ++i)
+        {
+            const KeyPoint &kp = keypoints[i];
+            kp_x[i] = kp.pt.x;
+            kp_y[i] = kp.pt.y;
+            kp_octave[i] = kp.octave;
+            kp_size[i] = kp.size;
+            kp_dir[i] = kp.angle;
+            kp_hessian[i] = kp.response;
+            kp_laplacian[i] = 1;
+        }
+
+        keypointsCPU.copyTo(keypointsGPU);
+    }
+}
+
+void SURF_OCL::downloadKeypoints(const UMat &keypointsGPU, std::vector<KeyPoint> &keypoints)
+{
+    const int nFeatures = keypointsGPU.cols;
+
+    if (nFeatures == 0)
+        keypoints.clear();
+    else
+    {
+        CV_Assert(keypointsGPU.type() == CV_32FC1 && keypointsGPU.rows == ROWS_COUNT);
+
+        Mat keypointsCPU = keypointsGPU.getMat(ACCESS_READ);
+        keypoints.resize(nFeatures);
+
+        float *kp_x = keypointsCPU.ptr<float>(SURF_OCL::X_ROW);
+        float *kp_y = keypointsCPU.ptr<float>(SURF_OCL::Y_ROW);
+        int *kp_laplacian = keypointsCPU.ptr<int>(SURF_OCL::LAPLACIAN_ROW);
+        int *kp_octave = keypointsCPU.ptr<int>(SURF_OCL::OCTAVE_ROW);
+        float *kp_size = keypointsCPU.ptr<float>(SURF_OCL::SIZE_ROW);
+        float *kp_dir = keypointsCPU.ptr<float>(SURF_OCL::ANGLE_ROW);
+        float *kp_hessian = keypointsCPU.ptr<float>(SURF_OCL::HESSIAN_ROW);
+
+        for (int i = 0; i < nFeatures; ++i)
+        {
+            KeyPoint &kp = keypoints[i];
+            kp.pt.x = kp_x[i];
+            kp.pt.y = kp_y[i];
+            kp.class_id = kp_laplacian[i];
+            kp.octave = kp_octave[i];
+            kp.size = kp_size[i];
+            kp.angle = kp_dir[i];
+            kp.response = kp_hessian[i];
+        }
+    }
+}
+
+bool SURF_OCL::detect(InputArray _img, InputArray _mask, UMat& keypoints)
+{
+    if( !setImage(_img, _mask) )
+        return false;
+
+    return detectKeypoints(keypoints);
+}
+
+
+bool SURF_OCL::detectAndCompute(InputArray _img, InputArray _mask, UMat& keypoints,
+                                OutputArray _descriptors, bool useProvidedKeypoints )
+{
+    if( !setImage(_img, _mask) )
+        return false;
+
+    if( !useProvidedKeypoints && !detectKeypoints(keypoints) )
+        return false;
+
+    return computeDescriptors(keypoints, _descriptors);
+}
+
+inline int divUp(int a, int b) { return (a + b-1)/b; }
+
+////////////////////////////
+// kernel caller definitions
+bool SURF_OCL::calcLayerDetAndTrace(int octave, int c_layer_rows)
+{
+    int nOctaveLayers = params->nOctaveLayers;
+    const int min_size = calcSize(octave, 0);
+    const int max_samples_i = 1 + ((img_rows - min_size) >> octave);
+    const int max_samples_j = 1 + ((img_cols - min_size) >> octave);
+
+    size_t localThreads[]  = {16, 16};
+    size_t globalThreads[] =
+    {
+        divUp(max_samples_j, (int)localThreads[0]) * localThreads[0],
+        divUp(max_samples_i, (int)localThreads[1]) * localThreads[1] * (nOctaveLayers + 2)
+    };
+    ocl::Kernel kerCalcDetTrace("SURF_calcLayerDetAndTrace", ocl::xfeatures2d::surf_oclsrc, kerOpts);
+    if(haveImageSupport)
+    {
+        kerCalcDetTrace.args(sumTex,
+                             img_rows, img_cols, nOctaveLayers,
+                             octave, c_layer_rows,
+                             ocl::KernelArg::WriteOnlyNoSize(det),
+                             ocl::KernelArg::WriteOnlyNoSize(trace));
+    }
+    else
+    {
+        kerCalcDetTrace.args(ocl::KernelArg::ReadOnlyNoSize(sum),
+                             img_rows, img_cols, nOctaveLayers,
+                             octave, c_layer_rows,
+                             ocl::KernelArg::WriteOnlyNoSize(det),
+                             ocl::KernelArg::WriteOnlyNoSize(trace));
+    }
+    return kerCalcDetTrace.run(2, globalThreads, localThreads, true);
+}
+
+bool SURF_OCL::findMaximaInLayer(int counterOffset, int octave,
+                                 int layer_rows, int layer_cols)
+{
+    const int min_margin = ((calcSize(octave, 2) >> 1) >> octave) + 1;
+    int nOctaveLayers = params->nOctaveLayers;
+
+    size_t localThreads[3]  = {16, 16};
+    size_t globalThreads[3] =
+    {
+        divUp(layer_cols - 2 * min_margin, (int)localThreads[0] - 2) * localThreads[0],
+        divUp(layer_rows - 2 * min_margin, (int)localThreads[1] - 2) * nOctaveLayers * localThreads[1]
+    };
+
+    ocl::Kernel kerFindMaxima("SURF_findMaximaInLayer", ocl::xfeatures2d::surf_oclsrc, kerOpts);
+    return kerFindMaxima.args(ocl::KernelArg::ReadOnlyNoSize(det),
+                              ocl::KernelArg::ReadOnlyNoSize(trace),
+                              ocl::KernelArg::PtrReadWrite(maxPosBuffer),
+                              ocl::KernelArg::PtrReadWrite(counters),
+                              counterOffset, img_rows, img_cols,
+                              nOctaveLayers, octave,
+                              layer_rows, layer_cols,
+                              maxCandidates,
+                              (float)params->hessianThreshold).run(2, globalThreads, localThreads, true);
+}
+
+bool SURF_OCL::interpolateKeypoint(int maxCounter, UMat &keypoints, int octave, int layer_rows, int max_features)
+{
+    size_t localThreads[3]  = {3, 3, 3};
+    size_t globalThreads[3] = {maxCounter*localThreads[0], localThreads[1], 3};
+
+    ocl::Kernel kerInterp("SURF_interpolateKeypoint", ocl::xfeatures2d::surf_oclsrc, kerOpts);
+
+    return kerInterp.args(ocl::KernelArg::ReadOnlyNoSize(det),
+                   ocl::KernelArg::PtrReadOnly(maxPosBuffer),
+                   ocl::KernelArg::ReadWriteNoSize(keypoints),
+                   ocl::KernelArg::PtrReadWrite(counters),
+                   img_rows, img_cols, octave, layer_rows, max_features).
+        run(3, globalThreads, localThreads, true);
+}
+
+bool SURF_OCL::calcOrientation(UMat &keypoints)
+{
+    int nFeatures = keypoints.cols;
+    if( nFeatures == 0 )
+        return true;
+    ocl::Kernel kerOri("SURF_calcOrientation", ocl::xfeatures2d::surf_oclsrc, kerOpts);
+
+    if( haveImageSupport )
+        kerOri.args(sumTex, img_rows, img_cols,
+                    ocl::KernelArg::ReadWriteNoSize(keypoints));
+    else
+        kerOri.args(ocl::KernelArg::ReadOnlyNoSize(sum),
+                    img_rows, img_cols,
+                    ocl::KernelArg::ReadWriteNoSize(keypoints));
+
+    size_t localThreads[3]  = {ORI_LOCAL_SIZE, 1};
+    size_t globalThreads[3] = {nFeatures * localThreads[0], 1};
+    return kerOri.run(2, globalThreads, localThreads, true);
+}
+
+#endif // ! #ifdef OPENCV_ENABLE_NONFREE
+
+}
+}
+
+#endif // HAVE_OPENCL
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/tbmr.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/tbmr.cpp
new file mode 100644
index 00000000..36a0a538
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/tbmr.cpp
@@ -0,0 +1,584 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include "msd_pyramid.hpp"
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+class TBMR_Impl CV_FINAL : public TBMR
+{
+  public:
+    struct Params
+    {
+        Params(int _min_area = 60, float _max_area_relative = 0.01,
+               float _scale = 1.5, int _n_scale = -1)
+        {
+            CV_Assert(_min_area >= 0);
+            CV_Assert(_max_area_relative >=
+                      std::numeric_limits<float>::epsilon());
+
+            minArea = _min_area;
+            maxAreaRelative = _max_area_relative;
+            scale = _scale;
+            n_scale = _n_scale;
+        }
+
+        uint minArea;
+        float maxAreaRelative;
+        int n_scale;
+        float scale;
+    };
+
+    explicit TBMR_Impl(const Params &_params) : params(_params) {}
+
+    virtual ~TBMR_Impl() CV_OVERRIDE {}
+
+    virtual void setMinArea(int minArea) CV_OVERRIDE
+    {
+        params.minArea = std::max(minArea, 0);
+    }
+    int getMinArea() const CV_OVERRIDE { return params.minArea; }
+
+    virtual void setMaxAreaRelative(float maxAreaRelative) CV_OVERRIDE
+    {
+        params.maxAreaRelative =
+            std::max(maxAreaRelative, std::numeric_limits<float>::epsilon());
+    }
+    virtual float getMaxAreaRelative() const CV_OVERRIDE
+    {
+        return params.maxAreaRelative;
+    }
+    virtual void setScaleFactor(float scale_factor) CV_OVERRIDE
+    {
+        params.scale = std::max(scale_factor, 1.f);
+    }
+    virtual float getScaleFactor() const CV_OVERRIDE { return params.scale; }
+    virtual void setNScales(int n_scales) CV_OVERRIDE
+    {
+        params.n_scale = n_scales;
+    }
+    virtual int getNScales() const CV_OVERRIDE { return params.n_scale; }
+
+    virtual void detect(InputArray image,
+                        CV_OUT std::vector<KeyPoint> &keypoints,
+                        InputArray mask = noArray()) CV_OVERRIDE;
+
+    virtual void detect(InputArray image,
+                        CV_OUT std::vector<Elliptic_KeyPoint> &keypoints,
+                        InputArray mask = noArray()) CV_OVERRIDE;
+
+    virtual void
+    detectAndCompute(InputArray image, InputArray mask,
+                     CV_OUT std::vector<Elliptic_KeyPoint> &keypoints,
+                     OutputArray descriptors,
+                     bool useProvidedKeypoints = false) CV_OVERRIDE;
+
+    CV_INLINE uint zfindroot(uint *parent, uint p)
+    {
+        if (parent[p] == p)
+            return p;
+        else
+            return parent[p] = zfindroot(parent, parent[p]);
+    }
+
+    // Calculate the Component tree. Based on the order of S, it will be a
+    // min or max tree.
+    void calcMinMaxTree(Mat ima)
+    {
+        int rs = ima.rows;
+        int cs = ima.cols;
+        uint imSize = (uint)rs * cs;
+
+        std::array<int, 4> offsets = {
+            -ima.cols, -1, 1, ima.cols
+        }; // {-1,0}, {0,-1}, {0,1}, {1,0} yx
+        std::array<Vec2i, 4> offsetsv = { Vec2i(0, -1), Vec2i(-1, 0),
+                                          Vec2i(1, 0), Vec2i(0, 1) }; //  xy
+        AutoBuffer<uint> zparb(imSize);
+        AutoBuffer<uint> rootb(imSize);
+        AutoBuffer<uint> rankb(imSize);
+        memset(rankb.data(), 0, imSize * sizeof(uint));
+        uint* zpar = zparb.data();
+        uint *root = rootb.data();
+        uint *rank = rankb.data();
+        parent = Mat(rs, cs, CV_32S); // unsigned
+        AutoBuffer<bool> dejaVub(imSize);
+        memset(dejaVub.data(), 0, imSize * sizeof(bool));
+        bool* dejaVu = dejaVub.data();
+
+        const uint *S_ptr = S.ptr<const uint>();
+        uint *parent_ptr = parent.ptr<uint>();
+        Vec<uint, 6> *imaAttribute = imaAttributes.ptr<Vec<uint, 6>>();
+
+        for (int i = imSize - 1; i >= 0; --i)
+        {
+            uint p = S_ptr[i];
+
+            Vec2i idx_p(p % cs, p / cs);
+            // make set
+            {
+                parent_ptr[p] = p;
+                zpar[p] = p;
+                root[p] = p;
+                dejaVu[p] = true;
+                imaAttribute[p][0] = 1;                   // area
+                imaAttribute[p][1] = idx_p[0];            // sum_x
+                imaAttribute[p][2] = idx_p[1];            // sum_y
+                imaAttribute[p][3] = idx_p[0] * idx_p[1]; // sum_xy
+                imaAttribute[p][4] = idx_p[0] * idx_p[0]; // sum_xx
+                imaAttribute[p][5] = idx_p[1] * idx_p[1]; // sum_yy
+            }
+
+            uint x = p; // zpar of p
+            for (unsigned k = 0; k < offsets.size(); ++k)
+            {
+                uint q = p + offsets[k];
+
+                Vec2i q_idx = idx_p + offsetsv[k];
+                bool inBorder = q_idx[0] >= 0 && q_idx[0] < ima.cols &&
+                                q_idx[1] >= 0 &&
+                                q_idx[1] < ima.rows; // filter out border cases
+
+                if (inBorder && dejaVu[q]) // remove first check
+                                           // obsolete
+                {
+                    uint r = zfindroot(zpar, q);
+                    if (r != x) // make union
+                    {
+                        parent_ptr[root[r]] = p;
+                        // accumulate information
+                        imaAttribute[p][0] += imaAttribute[root[r]][0]; // area
+                        imaAttribute[p][1] += imaAttribute[root[r]][1]; // sum_x
+                        imaAttribute[p][2] += imaAttribute[root[r]][2]; // sum_y
+                        imaAttribute[p][3] +=
+                            imaAttribute[root[r]][3]; // sum_xy
+                        imaAttribute[p][4] +=
+                            imaAttribute[root[r]][4]; // sum_xx
+                        imaAttribute[p][5] +=
+                            imaAttribute[root[r]][5]; // sum_yy
+
+                        if (rank[x] < rank[r])
+                        {
+                            // we merge p to r
+                            zpar[x] = r;
+                            root[r] = p;
+                            x = r;
+                        }
+                        else if (rank[r] < rank[p])
+                        {
+                            // merge r to p
+                            zpar[r] = p;
+                        }
+                        else
+                        {
+                            // same height
+                            zpar[r] = p;
+                            rank[p] += 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    void calculateTBMRs(const Mat &image, std::vector<Elliptic_KeyPoint> &tbmrs,
+                        const Mat &mask, float scale, int octave)
+    {
+        uint imSize = image.cols * image.rows;
+        uint maxArea =
+            static_cast<uint>(params.maxAreaRelative * imSize * scale);
+        uint minArea = static_cast<uint>(params.minArea * scale);
+
+        if (parent.empty() || parent.size != image.size)
+            parent = Mat(image.rows, image.cols, CV_32S);
+
+        if (imaAttributes.empty() || imaAttributes.size != image.size)
+            imaAttributes = Mat(image.rows, image.cols, CV_32SC(6));
+
+        calcMinMaxTree(image);
+
+        const Vec<uint, 6> *imaAttribute =
+            imaAttributes.ptr<const Vec<uint, 6>>();
+        const uint8_t *ima_ptr = image.ptr<const uint8_t>();
+        const uint *S_ptr = S.ptr<const uint>();
+        uint *parent_ptr = parent.ptr<uint>();
+
+        // canonization
+        for (uint i = 0; i < imSize; ++i)
+        {
+            uint p = S_ptr[i];
+            uint q = parent_ptr[p];
+            if (ima_ptr[parent_ptr[q]] == ima_ptr[q])
+                parent_ptr[p] = parent_ptr[q];
+        }
+
+        // TBMRs extraction
+        //------------------------------------------------------------------------
+        // small variant of the given algorithm in the paper. For each
+        // critical node having more than one child, we check if the
+        // largest region containing this node without any change of
+        // topology is above its parent, if not, discard this critical
+        // node.
+        //
+        // note also that we do not select the critical nodes themselves
+        // as final TBMRs
+        //--------------------------------------------------------------------------
+
+        AutoBuffer<uint> numSonsb(imSize);
+        memset(numSonsb.data(), 0, imSize * sizeof(uint));
+        uint* numSons = numSonsb.data();
+        uint vecNodesSize = imaAttribute[S_ptr[0]][0];               // area
+        AutoBuffer<uint> vecNodesb(vecNodesSize);
+        memset(vecNodesb.data(), 0, vecNodesSize * sizeof(uint));
+        uint *vecNodes = vecNodesb.data(); // area
+        uint numNodes = 0;
+
+        // leaf to root propagation to select the canonized nodes
+        for (int i = imSize - 1; i >= 0; --i)
+        {
+            uint p = S_ptr[i];
+            if (parent_ptr[p] == p || ima_ptr[p] != ima_ptr[parent_ptr[p]])
+            {
+                vecNodes[numNodes++] = p;
+                if (imaAttribute[p][0] >= minArea) // area
+                    numSons[parent_ptr[p]]++;
+            }
+        }
+
+        AutoBuffer<bool> isSeenb(imSize);
+        memset(isSeenb.data(), 0, imSize * sizeof(bool));
+        bool *isSeen = isSeenb.data();
+
+        // parent of critical leaf node
+        AutoBuffer<bool> isParentofLeafb(imSize);
+        memset(isParentofLeafb.data(), 0, imSize * sizeof(bool));
+        bool* isParentofLeaf = isParentofLeafb.data();
+
+        for (uint i = 0; i < vecNodesSize; i++)
+        {
+            uint p = vecNodes[i];
+            if (numSons[p] == 0 && numSons[parent_ptr[p]] == 1)
+                isParentofLeaf[parent_ptr[p]] = true;
+        }
+
+        uint numTbmrs = 0;
+        AutoBuffer<uint> vecTbmrsb(numNodes);
+        uint* vecTbmrs = vecTbmrsb.data();
+        for (uint i = 0; i < vecNodesSize; i++)
+        {
+            uint p = vecNodes[i];
+            if (numSons[p] == 1 && !isSeen[p] && imaAttribute[p][0] <= maxArea)
+            {
+                uint num_ancestors = 0;
+                uint pt = p;
+                uint po = pt;
+                while (numSons[pt] == 1 && imaAttribute[pt][0] <= maxArea)
+                {
+                    isSeen[pt] = true;
+                    num_ancestors++;
+                    po = pt;
+                    pt = parent_ptr[pt];
+                }
+                if (!isParentofLeaf[p] || num_ancestors > 1)
+                {
+                    vecTbmrs[numTbmrs++] = po;
+                }
+            }
+        }
+        // end of TBMRs extraction
+        //------------------------------------------------------------------------
+
+        // compute best fitting ellipses
+        //------------------------------------------------------------------------
+        for (uint i = 0; i < numTbmrs; i++)
+        {
+            uint p = vecTbmrs[i];
+            double area = static_cast<double>(imaAttribute[p][0]);
+            double sum_x = static_cast<double>(imaAttribute[p][1]);
+            double sum_y = static_cast<double>(imaAttribute[p][2]);
+            double sum_xy = static_cast<double>(imaAttribute[p][3]);
+            double sum_xx = static_cast<double>(imaAttribute[p][4]);
+            double sum_yy = static_cast<double>(imaAttribute[p][5]);
+
+            // Barycenter:
+            double x = sum_x / area;
+            double y = sum_y / area;
+
+            double i20 = sum_xx - area * x * x;
+            double i02 = sum_yy - area * y * y;
+            double i11 = sum_xy - area * x * y;
+            double n = i20 * i02 - i11 * i11;
+            if (n != 0)
+            {
+                double a = (i02 / n) * (area - 1) / 4;
+                double b = (-i11 / n) * (area - 1) / 4;
+                double c = (i20 / n) * (area - 1) / 4;
+
+                // filter out some non meaningful ellipses
+                double a1 = a;
+                double b1 = b;
+                double c1 = c;
+                uint ai = 0;
+                uint bi = 0;
+                uint ci = 0;
+                if (a > 0)
+                {
+                    if (a < 0.00005)
+                        a1 = 0;
+                    else if (a < 0.0001)
+                    {
+                        a1 = 0.0001;
+                    }
+                    else
+                    {
+                        ai = (uint)(10000 * a);
+                        a1 = (double)ai / 10000;
+                    }
+                }
+                else
+                {
+                    if (a > -0.00005)
+                        a1 = 0;
+                    else if (a > -0.0001)
+                        a1 = -0.0001;
+                    else
+                    {
+                        ai = (uint)(10000 * (-a));
+                        a1 = -(double)ai / 10000;
+                    }
+                }
+
+                if (b > 0)
+                {
+                    if (b < 0.00005)
+                        b1 = 0;
+                    else if (b < 0.0001)
+                    {
+                        b1 = 0.0001;
+                    }
+                    else
+                    {
+                        bi = (uint)(10000 * b);
+                        b1 = (double)bi / 10000;
+                    }
+                }
+                else
+                {
+                    if (b > -0.00005)
+                        b1 = 0;
+                    else if (b > -0.0001)
+                        b1 = -0.0001;
+                    else
+                    {
+                        bi = (uint)(10000 * (-b));
+                        b1 = -(double)bi / 10000;
+                    }
+                }
+
+                if (c > 0)
+                {
+                    if (c < 0.00005)
+                        c1 = 0;
+                    else if (c < 0.0001)
+                    {
+                        c1 = 0.0001;
+                    }
+                    else
+                    {
+                        ci = (uint)(10000 * c);
+                        c1 = (double)ci / 10000;
+                    }
+                }
+                else
+                {
+                    if (c > -0.00005)
+                        c1 = 0;
+                    else if (c > -0.0001)
+                        c1 = -0.0001;
+                    else
+                    {
+                        ci = (uint)(10000 * (-c));
+                        c1 = -(double)ci / 10000;
+                    }
+                }
+                double v =
+                    (a1 + c1 -
+                     std::sqrt(a1 * a1 + c1 * c1 + 4 * b1 * b1 - 2 * a1 * c1)) /
+                    2;
+
+                double l1 = 1. / std::sqrt((a + c +
+                                            std::sqrt(a * a + c * c +
+                                                      4 * b * b - 2 * a * c)) /
+                                           2);
+                double l2 = 1. / std::sqrt((a + c -
+                                            std::sqrt(a * a + c * c +
+                                                      4 * b * b - 2 * a * c)) /
+                                           2);
+                double minAxL = std::min(l1, l2);
+                double majAxL = std::max(l1, l2);
+
+                if (minAxL >= 1.5 && v != 0 &&
+                    (mask.empty() ||
+                     mask.at<uchar>(cvRound(y), cvRound(x)) != 0))
+                {
+                    double theta = 0;
+                    if (b == 0)
+                        if (a < c)
+                            theta = 0;
+                        else
+                            theta = CV_PI / 2.;
+                    else
+                        theta = CV_PI / 2. + 0.5 * std::atan2(2 * b, (a - c));
+
+                    float size = (float)majAxL;
+
+                    // not sure if we should scale or not scale x,y,axes,size
+                    // (as scale is stored in si)
+                    Elliptic_KeyPoint ekp(
+                        Point2f((float)x, (float)y) * scale, (float)theta,
+                        cv::Size2f((float)majAxL, (float)minAxL) * scale,
+                        size * scale, scale);
+                    ekp.octave = octave;
+                    tbmrs.push_back(ekp);
+                }
+            }
+        }
+        //---------------------------------------------
+    }
+
+    Mat tempsrc;
+
+    // component tree representation (parent,S): see
+    // https://ieeexplore.ieee.org/document/6850018
+    Mat parent;
+    Mat S;
+    // moments: compound type of: (area, x, y, xy, xx, yy)
+    Mat imaAttributes;
+
+    Params params;
+};
+
+void TBMR_Impl::detect(InputArray _image, std::vector<KeyPoint> &keypoints,
+                       InputArray _mask)
+{
+    std::vector<Elliptic_KeyPoint> kp;
+    detect(_image, kp, _mask);
+    keypoints.resize(kp.size());
+    for (size_t i = 0; i < kp.size(); ++i)
+        keypoints[i] = kp[i];
+}
+
+void TBMR_Impl::detect(InputArray _image,
+                       std::vector<Elliptic_KeyPoint> &keypoints,
+                       InputArray _mask)
+{
+    Mat mask = _mask.getMat();
+    Mat src = _image.getMat();
+
+    keypoints.clear();
+
+    if (src.empty())
+        return;
+
+    if (!mask.empty())
+    {
+        CV_Assert(mask.type() == CV_8UC1);
+        CV_Assert(mask.size == src.size);
+    }
+
+    if (!src.isContinuous())
+    {
+        src.copyTo(tempsrc);
+        src = tempsrc;
+    }
+
+    CV_Assert(src.depth() == CV_8U);
+
+    if (src.channels() != 1)
+        cv::cvtColor(src, src, cv::COLOR_BGR2GRAY);
+
+    int m_cur_n_scales =
+        params.n_scale > 0
+            ? params.n_scale
+            : 1 /*todo calculate optimal scale factor from image size*/;
+    float m_scale_factor = params.scale;
+
+    // track and eliminate duplicates introduced with multi scale position ->
+    // (size)
+    Mat dupl(src.rows / 4, src.cols / 4, CV_32F, cv::Scalar::all(0));
+    float *dupl_ptr = dupl.ptr<float>();
+
+    std::vector<Mat> pyr;
+    MSDImagePyramid scaleSpacer(src, m_cur_n_scales, m_scale_factor);
+    pyr = scaleSpacer.getImPyr();
+
+    int oct = 0;
+    for (auto &s : pyr)
+    {
+        float scale = ((float)s.cols) / pyr.begin()->cols;
+        std::vector<Elliptic_KeyPoint> kpts;
+
+        // append max tree tbmrs
+        sortIdx(s.reshape(1, 1), S,
+                SortFlags::SORT_ASCENDING | SortFlags::SORT_EVERY_ROW);
+        calculateTBMRs(s, kpts, mask, scale, oct);
+
+        // reverse instead of sort
+        flip(S, S, -1);
+        calculateTBMRs(s, kpts, mask, scale, oct);
+
+        if (oct == 0)
+        {
+            for (const auto &k : kpts)
+            {
+                dupl_ptr[(int)(k.pt.x / 4) +
+                         (int)(k.pt.y / 4) * (src.cols / 4)] = k.size;
+            }
+            keypoints.insert(keypoints.end(), kpts.begin(), kpts.end());
+        }
+        else
+        {
+            for (const auto &k : kpts)
+            {
+                float &sz = dupl_ptr[(int)(k.pt.x / 4) +
+                                     (int)(k.pt.y / 4) * (src.cols / 4)];
+                // we hereby add only features that are at least 4 pixels away
+                // or have a significantly different size
+                if (std::abs(k.size - sz) / std::max(k.size, sz) >= 0.2f)
+                {
+                    sz = k.size;
+                    keypoints.push_back(k);
+                }
+            }
+        }
+
+        oct++;
+    }
+}
+
+void TBMR_Impl::detectAndCompute(
+    InputArray image, InputArray mask,
+    CV_OUT std::vector<Elliptic_KeyPoint> &keypoints, OutputArray descriptors,
+    bool useProvidedKeypoints)
+{
+    // We can use SIFT to compute descriptors for the extracted keypoints...
+    auto sift = SIFT::create();
+    auto dac = AffineFeature2D::create(this, sift);
+    dac->detectAndCompute(image, mask, keypoints, descriptors,
+                          useProvidedKeypoints);
+}
+
+Ptr<TBMR> TBMR::create(int _min_area, float _max_area_relative, float _scale,
+                       int _n_scale)
+{
+    return cv::makePtr<TBMR_Impl>(
+        TBMR_Impl::Params(_min_area, _max_area_relative, _scale, _n_scale));
+}
+
+} // namespace xfeatures2d
+} // namespace cv
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/teblid.p256.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/teblid.p256.hpp
new file mode 100644
index 00000000..a3c4eb69
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/teblid.p256.hpp
@@ -0,0 +1,104 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Author: Iago Suarez <iagosuarz@gmail.com>
+
+// Implementation of the article:
+//     Iago Suarez, Jose M. Buenaposada, and Luis Baumela.
+//     Revisiting Binary Local Image Description for Resource Limited Devices.
+//     IEEE Robotics and Automation Letters, vol. 6, no. 4, pp. 8317-8324, Oct. 2021.
+
+// ABWLParams: x1, y1, x2, y2, boxRadius, th
+
+// Pre-trained parameters of TEBLID-256 trained in Liberty data set. 10K triplets are sampled per iteration. Each triplet
+// contains an anchor patch, a positive and a negative, selected as the hardest among 256 random negatives.
+static const ABWLParamsFloatTh teblid_wl_params_256_[] = {
+    {25, 14, 13, 15, 6, 21.65f}, {16, 15, 14, 11, 1, 5.65f}, {14, 14, 7, 8, 6, 4.95f},
+    {10, 9, 6, 20, 6, 2.45f}, {13, 26, 13, 19, 5, 2.25f}, {19, 14, 19, 5, 4, 0.85f},
+    {16, 19, 15, 13, 2, 3.35f}, {26, 26, 21, 12, 5, 1.75f}, {18, 23, 15, 20, 2, 4.55f},
+    {12, 15, 10, 20, 1, -1.55f}, {26, 4, 18, 8, 3, 4.55f}, {8, 21, 2, 29, 2, -5.05f},
+    {19, 16, 17, 19, 1, 3.15f}, {10, 3, 5, 13, 3, 4.85f}, {16, 10, 10, 14, 1, 9.95f},
+    {19, 12, 18, 17, 1, 1.35f}, {21, 26, 21, 19, 5, -2.05f}, {6, 7, 5, 5, 5, -0.15f},
+    {22, 12, 20, 14, 2, 1.55f}, {14, 12, 13, 17, 1, 3.35f}, {11, 16, 10, 13, 2, 0.25f},
+    {7, 23, 7, 17, 3, 0.35f}, {27, 13, 25, 8, 4, 2.45f}, {20, 19, 16, 14, 1, 2.75f},
+    {27, 10, 24, 16, 2, -1.65f}, {13, 12, 13, 6, 2, -0.05f}, {14, 18, 13, 23, 1, -0.75f},
+    {14, 8, 11, 1, 1, 0.85f}, {14, 23, 12, 9, 2, 2.95f}, {6, 19, 2, 13, 2, -1.65f},
+    {8, 19, 6, 19, 3, -0.05f}, {18, 28, 17, 25, 3, -0.25f}, {29, 28, 25, 22, 2, -3.85f},
+    {15, 19, 15, 17, 3, -0.05f}, {23, 21, 19, 19, 1, 3.35f}, {20, 20, 20, 16, 3, 0.05f},
+    {29, 4, 25, 8, 2, -3.55f}, {17, 6, 16, 25, 2, 2.65f}, {12, 21, 8, 29, 1, 1.95f},
+    {14, 15, 9, 17, 2, 6.35f}, {18, 5, 17, 3, 3, 0.85f}, {21, 12, 18, 10, 1, 2.65f},
+    {17, 14, 14, 14, 2, 12.45f}, {5, 26, 3, 6, 3, 0.05f}, {16, 13, 15, 14, 1, 3.35f},
+    {28, 21, 24, 22, 3, 1.75f}, {13, 12, 13, 10, 1, -1.05f}, {22, 3, 21, 11, 3, -1.05f},
+    {27, 27, 4, 16, 4, 28.25f}, {12, 13, 7, 10, 1, 0.35f}, {15, 25, 15, 22, 2, -0.15f},
+    {19, 10, 18, 12, 1, 2.05f}, {17, 16, 17, 9, 2, 2.55f}, {21, 17, 21, 14, 2, 0.85f},
+    {13, 19, 12, 16, 1, 1.35f}, {11, 11, 9, 15, 1, 1.15f}, {15, 26, 14, 28, 3, 1.25f},
+    {17, 22, 17, 20, 1, 1.35f}, {10, 26, 2, 27, 2, 1.85f}, {28, 12, 26, 23, 3, 3.95f},
+    {4, 5, 3, 14, 3, 0.75f}, {17, 7, 17, 4, 3, 1.65f}, {19, 15, 17, 15, 1, -3.15f},
+    {7, 8, 2, 5, 2, -6.35f}, {22, 15, 19, 14, 2, 2.05f}, {15, 16, 12, 20, 1, -5.15f},
+    {13, 19, 12, 20, 1, 1.75f}, {17, 10, 17, 8, 2, -0.65f}, {26, 16, 19, 15, 4, -0.65f},
+    {9, 14, 8, 20, 2, 1.05f}, {27, 14, 27, 4, 4, -0.85f}, {17, 14, 15, 9, 1, 0.85f},
+    {5, 4, 5, 3, 3, -0.35f}, {15, 30, 9, 5, 1, 9.05f}, {7, 25, 7, 23, 6, 0.75f},
+    {12, 24, 11, 16, 1, -1.75f}, {20, 29, 20, 20, 2, 0.75f}, {19, 18, 15, 19, 1, 16.05f},
+    {9, 11, 7, 11, 7, 0.35f}, {27, 26, 26, 15, 4, 0.75f}, {10, 28, 10, 27, 3, 0.05f},
+    {8, 12, 8, 6, 3, 0.05f}, {21, 23, 16, 22, 1, 3.75f}, {22, 7, 4, 25, 4, 14.15f},
+    {17, 19, 16, 15, 1, -8.95f}, {28, 21, 11, 15, 3, 67.25f}, {15, 3, 15, 2, 2, -0.45f},
+    {16, 16, 14, 17, 3, 1.65f}, {10, 17, 7, 18, 3, -1.95f}, {12, 18, 12, 15, 1, 1.15f},
+    {18, 16, 16, 13, 1, 1.85f}, {20, 16, 19, 15, 1, 3.95f}, {16, 15, 11, 11, 1, -1.75f},
+    {4, 14, 2, 13, 2, 0.45f}, {29, 18, 27, 17, 2, -1.55f}, {16, 18, 14, 16, 1, 1.05f},
+    {23, 29, 22, 27, 2, -0.25f}, {18, 13, 18, 11, 1, -1.05f}, {26, 23, 21, 27, 4, 3.05f},
+    {18, 22, 17, 18, 1, -1.05f}, {3, 11, 2, 21, 2, 1.95f}, {13, 18, 13, 9, 3, -0.05f},
+    {15, 14, 14, 5, 2, 0.85f}, {1, 14, 1, 1, 1, 3.05f}, {29, 2, 5, 9, 2, 34.85f},
+    {12, 17, 11, 17, 1, -0.15f}, {13, 10, 12, 25, 4, 4.35f}, {5, 13, 1, 25, 1, -10.65f},
+    {13, 16, 13, 12, 1, 2.35f}, {16, 23, 16, 12, 1, -1.35f}, {27, 14, 22, 14, 2, 0.05f},
+    {29, 29, 27, 27, 2, 1.05f}, {23, 6, 22, 4, 4, 1.05f}, {22, 16, 22, 8, 3, -0.15f},
+    {14, 1, 11, 9, 1, 0.45f}, {12, 11, 10, 8, 2, -0.55f}, {24, 19, 7, 16, 7, 10.45f},
+    {5, 29, 2, 20, 2, 1.35f}, {19, 15, 19, 13, 1, -0.95f}, {15, 18, 8, 24, 2, 0.45f},
+    {4, 24, 1, 30, 1, -0.85f}, {17, 30, 17, 26, 1, 1.45f}, {9, 8, 7, 5, 2, -1.85f},
+    {15, 20, 15, 18, 1, 1.65f}, {27, 5, 14, 26, 4, 2.75f}, {18, 19, 18, 15, 1, 1.05f},
+    {24, 14, 9, 12, 1, 81.45f}, {20, 6, 18, 10, 1, 3.35f}, {21, 23, 21, 21, 1, 0.85f},
+    {19, 17, 6, 6, 6, 2.65f}, {10, 13, 6, 12, 3, 9.35f}, {30, 10, 27, 14, 1, 1.15f},
+    {9, 5, 6, 3, 3, 1.35f}, {26, 21, 18, 19, 2, -1.55f}, {23, 5, 23, 4, 4, 0.85f},
+    {14, 11, 11, 12, 1, 20.65f}, {18, 13, 16, 13, 1, 2.05f}, {7, 8, 3, 16, 3, 12.85f},
+    {16, 15, 16, 12, 2, 7.95f}, {25, 20, 24, 25, 3, 2.25f}, {20, 14, 19, 14, 1, 0.05f},
+    {12, 29, 12, 5, 1, 0.85f}, {23, 17, 13, 13, 5, 8.75f}, {27, 27, 23, 22, 4, -8.25f},
+    {11, 4, 11, 3, 3, -0.35f}, {9, 18, 7, 15, 1, 1.65f}, {18, 17, 18, 14, 1, -3.95f},
+    {28, 2, 6, 17, 2, 92.55f}, {5, 20, 3, 22, 3, 0.55f}, {30, 30, 30, 2, 1, 0.35f},
+    {16, 8, 15, 13, 1, -0.75f}, {15, 16, 14, 13, 1, -12.25f}, {28, 5, 27, 5, 3, 0.55f},
+    {13, 13, 12, 12, 1, 1.05f}, {7, 8, 6, 7, 6, 0.95f}, {10, 21, 10, 17, 1, 1.15f},
+    {11, 17, 3, 30, 1, -43.25f}, {16, 17, 9, 14, 7, 3.05f}, {17, 16, 9, 14, 1, 4.35f},
+    {14, 29, 13, 27, 2, 7.15f}, {19, 5, 19, 3, 2, 0.15f}, {18, 16, 14, 14, 1, 57.95f},
+    {10, 23, 8, 25, 2, 4.35f}, {17, 17, 15, 18, 1, 0.75f}, {16, 22, 16, 16, 6, 0.05f},
+    {29, 11, 27, 11, 2, 0.05f}, {13, 9, 7, 11, 1, 5.45f}, {18, 23, 17, 19, 4, 0.55f},
+    {12, 14, 11, 17, 1, 0.95f}, {13, 23, 11, 18, 2, 20.55f}, {27, 8, 23, 20, 4, -4.45f},
+    {18, 18, 18, 11, 4, 0.75f}, {8, 21, 5, 8, 5, 4.55f}, {23, 5, 21, 10, 1, -0.15f},
+    {16, 16, 16, 12, 1, 8.65f}, {18, 17, 14, 19, 1, 42.65f}, {16, 27, 16, 24, 2, -0.45f},
+    {21, 17, 15, 15, 1, -1.25f}, {16, 5, 15, 9, 2, -1.75f}, {24, 16, 1, 30, 1, 11.25f},
+    {15, 14, 14, 19, 1, -8.15f}, {19, 12, 12, 14, 2, 2.85f}, {5, 5, 3, 4, 3, -2.85f},
+    {16, 11, 16, 9, 1, -5.05f}, {16, 9, 6, 18, 6, 44.65f}, {25, 24, 23, 14, 1, 1.45f},
+    {5, 26, 5, 17, 5, -0.75f}, {9, 16, 6, 18, 1, 11.85f}, {29, 25, 9, 24, 2, 2.05f},
+    {25, 22, 24, 30, 1, 1.25f}, {22, 2, 20, 5, 2, 4.45f}, {27, 1, 25, 11, 1, -1.35f},
+    {15, 12, 14, 10, 1, 5.95f}, {17, 6, 16, 8, 1, 1.35f}, {28, 8, 23, 7, 3, -2.55f},
+    {24, 24, 23, 22, 7, 5.05f}, {7, 18, 5, 20, 3, -2.85f}, {22, 15, 20, 20, 1, 7.35f},
+    {30, 21, 28, 20, 1, -1.35f}, {3, 18, 2, 18, 2, -0.45f}, {6, 14, 5, 15, 1, 0.45f},
+    {15, 18, 15, 16, 1, -11.85f}, {7, 11, 5, 2, 1, -39.65f}, {17, 17, 13, 15, 3, 1.65f},
+    {12, 15, 7, 15, 5, -0.05f}, {16, 12, 15, 18, 1, 3.65f}, {14, 26, 14, 25, 5, -0.35f},
+    {11, 17, 8, 18, 1, 0.05f}, {23, 13, 15, 21, 7, 1.85f}, {10, 9, 10, 2, 2, -0.45f},
+    {17, 13, 12, 19, 1, -1.75f}, {20, 25, 19, 22, 1, 3.95f}, {9, 26, 8, 21, 1, 5.25f},
+    {19, 22, 19, 18, 1, -1.05f}, {8, 15, 3, 12, 1, -11.95f}, {26, 13, 16, 19, 5, 37.05f},
+    {24, 12, 21, 13, 1, -1.15f}, {12, 14, 12, 9, 1, 1.25f}, {3, 7, 1, 1, 1, 0.75f},
+    {16, 9, 15, 3, 3, -6.05f}, {23, 20, 23, 8, 7, -1.55f}, {24, 16, 22, 15, 1, -1.65f},
+    {20, 19, 20, 14, 1, 0.85f}, {30, 27, 29, 22, 1, 0.35f}, {27, 17, 4, 16, 4, 101.55f},
+    {8, 13, 5, 13, 5, -5.05f}, {19, 8, 10, 16, 3, 3.65f}, {30, 11, 30, 4, 1, -2.35f},
+    {14, 21, 14, 20, 1, -0.35f}, {14, 11, 13, 13, 1, -1.65f}, {30, 2, 28, 5, 1, 0.65f},
+    {17, 29, 12, 24, 2, 6.35f}, {15, 25, 6, 30, 1, 2.85f}, {4, 1, 1, 1, 1, 5.25f},
+    {12, 16, 5, 20, 5, 24.05f}, {16, 20, 14, 15, 1, 38.15f}, {6, 17, 6, 9, 3, -1.05f},
+    {20, 17, 12, 20, 4, 3.05f}, {15, 15, 12, 4, 4, 0.35f}, {28, 20, 22, 21, 3, -16.05f},
+    {14, 18, 9, 18, 5, -1.25f}, {26, 1, 23, 5, 1, 0.25f}, {21, 24, 11, 10, 7, 1.95f},
+    {15, 19, 14, 12, 1, -0.85f}, {27, 29, 11, 16, 1, 107.65f}, {23, 19, 22, 29, 1, -1.55f},
+    {2, 30, 2, 29, 1, -0.25f}, {14, 16, 6, 5, 3, 26.95f}, {17, 13, 14, 16, 1, 35.95f},
+    {19, 14, 15, 16, 1, -4.85f}, {20, 25, 13, 15, 6, 1.55f}, {19, 18, 11, 12, 5, 10.85f},
+    {30, 30, 30, 13, 1, -7.15f}, {3, 14, 1, 9, 1, -4.25f}, {20, 17, 1, 18, 1, -25.15f},
+    {16, 20, 12, 19, 1, 2.75f}
+};
+static const std::vector<ABWLParamsFloatTh> teblid_wl_params_256(std::begin(teblid_wl_params_256_),
+                                                                 std::end(teblid_wl_params_256_));
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/teblid.p512.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/teblid.p512.hpp
new file mode 100644
index 00000000..b1b1dabb
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/teblid.p512.hpp
@@ -0,0 +1,189 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Author: Iago Suarez <iagosuarz@gmail.com>
+
+// Implementation of the article:
+//     Iago Suarez, Jose M. Buenaposada, and Luis Baumela.
+//     Revisiting Binary Local Image Description for Resource Limited Devices.
+//     IEEE Robotics and Automation Letters, vol. 6, no. 4, pp. 8317-8324, Oct. 2021.
+
+// ABWLParams: x1, y1, x2, y2, boxRadius, th
+
+// Pre-trained parameters of TEBLID-512 trained in Liberty data set. 10K triplets are sampled per iteration. Each triplet
+// contains an anchor patch, a positive and a negative, selected as the hardest among 256 random negatives.
+static const ABWLParamsFloatTh teblid_wl_params_512_[] = {
+    {17, 18, 12, 15, 2, 14.45f}, {13, 14, 5, 7, 5, 4.15f}, {21, 16, 16, 14, 1, 7.75f},
+    {27, 11, 18, 20, 3, 9.65f}, {17, 13, 16, 19, 2, 2.25f}, {18, 24, 18, 16, 5, 0.15f},
+    {12, 11, 10, 25, 6, 0.45f}, {14, 17, 14, 13, 1, -0.95f}, {7, 4, 4, 15, 4, 3.65f},
+    {27, 27, 23, 8, 4, -1.75f}, {19, 13, 19, 6, 6, 1.05f}, {14, 15, 10, 16, 1, 5.45f},
+    {13, 15, 12, 22, 1, -0.05f}, {8, 22, 3, 27, 3, -2.65f}, {13, 19, 8, 13, 1, 3.35f},
+    {18, 16, 17, 12, 1, 1.65f}, {27, 7, 25, 11, 4, -1.55f}, {24, 20, 20, 15, 2, 2.85f},
+    {16, 24, 14, 3, 3, 3.05f}, {23, 18, 7, 18, 7, 22.05f}, {8, 7, 2, 1, 1, -3.65f},
+    {17, 28, 17, 26, 3, -0.15f}, {17, 13, 17, 10, 2, -0.55f}, {10, 18, 10, 11, 1, -0.05f},
+    {11, 28, 7, 22, 2, 3.25f}, {18, 13, 15, 15, 1, -2.85f}, {7, 14, 3, 20, 3, -1.25f},
+    {17, 19, 14, 15, 1, 10.45f}, {14, 12, 14, 8, 2, -1.05f}, {14, 12, 13, 11, 1, 1.25f},
+    {21, 9, 19, 19, 2, 3.15f}, {4, 28, 3, 10, 3, 2.05f}, {27, 27, 26, 26, 4, -0.55f},
+    {19, 22, 19, 19, 2, -1.25f}, {12, 25, 12, 20, 1, 3.45f}, {19, 12, 15, 12, 1, 4.35f},
+    {28, 21, 23, 21, 2, 2.45f}, {10, 15, 7, 18, 2, 2.55f}, {12, 7, 10, 3, 3, 1.35f},
+    {21, 16, 19, 15, 1, 1.25f}, {19, 20, 18, 17, 1, 2.75f}, {26, 2, 19, 7, 2, -0.15f},
+    {18, 2, 15, 22, 2, 8.35f}, {24, 26, 24, 22, 5, 0.35f}, {15, 26, 15, 19, 1, -1.25f},
+    {13, 19, 11, 20, 1, 0.75f}, {5, 14, 4, 10, 4, -0.45f}, {15, 7, 15, 4, 2, -0.05f},
+    {13, 16, 11, 7, 1, 0.85f}, {15, 22, 15, 18, 1, 3.65f}, {24, 8, 23, 4, 4, 1.55f},
+    {13, 11, 11, 14, 1, 1.75f}, {4, 19, 3, 19, 3, -0.35f}, {22, 12, 19, 10, 1, 1.35f},
+    {24, 27, 15, 22, 2, 4.85f}, {12, 13, 10, 10, 1, -2.25f}, {11, 25, 9, 29, 2, 0.25f},
+    {15, 21, 15, 10, 1, -2.15f}, {19, 16, 18, 19, 1, 3.35f}, {29, 13, 24, 8, 2, 1.95f},
+    {17, 16, 16, 20, 1, 6.25f}, {12, 17, 12, 15, 1, 0.35f}, {28, 4, 2, 11, 2, 24.45f},
+    {7, 25, 5, 19, 3, -1.15f}, {22, 13, 20, 16, 1, 0.85f}, {14, 16, 13, 17, 1, -1.95f},
+    {10, 3, 8, 11, 3, 5.15f}, {18, 7, 17, 11, 2, 1.35f}, {27, 11, 25, 22, 2, 0.85f},
+    {5, 26, 3, 28, 3, 0.35f}, {28, 13, 27, 13, 3, -0.45f}, {22, 20, 20, 28, 3, 4.95f},
+    {12, 6, 5, 2, 2, -0.25f}, {14, 18, 13, 16, 1, 2.45f}, {17, 29, 3, 25, 2, 11.75f},
+    {20, 20, 19, 19, 1, 0.85f}, {15, 12, 14, 15, 1, -1.65f}, {12, 14, 12, 13, 1, 0.05f},
+    {17, 14, 10, 26, 3, 4.05f}, {11, 15, 6, 12, 6, -0.35f}, {9, 22, 9, 19, 1, -0.95f},
+    {19, 18, 19, 14, 1, -0.25f}, {23, 15, 12, 18, 2, 49.35f}, {12, 15, 11, 14, 1, 0.85f},
+    {28, 2, 27, 9, 2, 1.95f}, {11, 19, 11, 11, 7, 0.25f}, {13, 29, 13, 23, 2, 1.15f},
+    {27, 19, 22, 17, 3, -2.65f}, {17, 3, 17, 2, 2, -0.25f}, {4, 6, 3, 3, 3, 0.85f},
+    {19, 15, 16, 16, 1, -5.65f}, {22, 5, 20, 9, 2, 1.15f}, {14, 6, 13, 9, 2, 3.05f},
+    {17, 16, 13, 16, 2, 4.05f}, {24, 18, 12, 6, 6, 7.35f}, {20, 14, 18, 15, 2, 9.05f},
+    {20, 9, 18, 13, 1, 0.35f}, {18, 20, 17, 8, 2, 1.65f}, {10, 15, 9, 15, 2, 1.65f},
+    {13, 7, 12, 26, 2, 2.55f}, {13, 12, 11, 19, 2, 6.95f}, {15, 2, 2, 29, 2, 1.75f},
+    {15, 12, 14, 13, 1, 0.85f}, {20, 30, 19, 26, 1, -1.15f}, {28, 26, 28, 4, 3, 1.35f},
+    {16, 13, 15, 12, 1, 5.45f}, {18, 11, 17, 25, 2, 1.35f}, {3, 17, 1, 24, 1, -2.35f},
+    {21, 18, 19, 22, 1, -0.15f}, {9, 13, 9, 8, 2, 0.85f}, {19, 18, 16, 16, 1, -3.05f},
+    {21, 22, 17, 20, 1, 0.05f}, {13, 4, 13, 3, 3, -0.35f}, {24, 15, 21, 9, 1, -0.65f},
+    {24, 25, 19, 17, 6, 11.65f}, {4, 14, 3, 14, 2, -0.85f}, {17, 13, 14, 19, 1, 1.15f},
+    {7, 19, 4, 16, 3, 2.35f}, {4, 20, 1, 5, 1, -9.25f}, {15, 13, 12, 14, 3, 16.05f},
+    {19, 26, 19, 21, 2, -1.45f}, {11, 26, 10, 18, 5, 1.95f}, {17, 16, 17, 13, 1, 0.35f},
+    {19, 16, 19, 11, 1, -0.35f}, {4, 26, 4, 23, 4, 0.15f}, {14, 19, 14, 13, 5, 0.25f},
+    {10, 13, 8, 13, 2, -1.35f}, {14, 12, 14, 10, 1, 0.65f}, {29, 24, 26, 19, 2, -4.05f},
+    {26, 9, 19, 19, 5, -2.25f}, {16, 23, 16, 17, 1, 1.05f}, {4, 13, 3, 4, 3, -0.05f},
+    {13, 16, 7, 21, 2, -1.55f}, {17, 16, 16, 17, 1, 0.25f}, {29, 15, 5, 18, 2, 69.45f},
+    {29, 2, 23, 5, 2, 0.15f}, {9, 17, 9, 14, 2, -1.25f}, {25, 26, 25, 22, 5, -1.85f},
+    {13, 21, 13, 20, 1, -0.65f}, {23, 12, 7, 20, 6, 8.75f}, {6, 8, 6, 3, 3, -0.95f},
+    {13, 19, 13, 17, 1, 1.95f}, {25, 21, 22, 20, 1, 1.05f}, {24, 17, 23, 15, 2, -1.45f},
+    {20, 8, 17, 4, 1, 2.15f}, {11, 19, 10, 17, 1, -1.85f}, {9, 11, 6, 9, 1, -1.75f},
+    {25, 9, 24, 14, 1, -2.95f}, {18, 20, 13, 14, 3, 2.65f}, {26, 23, 25, 23, 5, 0.65f},
+    {14, 20, 11, 4, 4, -1.05f}, {28, 7, 25, 13, 3, 4.35f}, {13, 13, 12, 12, 1, 0.25f},
+    {7, 29, 2, 2, 2, 19.65f}, {16, 17, 16, 8, 5, 0.35f}, {20, 6, 19, 12, 3, 1.65f},
+    {19, 7, 19, 6, 6, 0.65f}, {20, 13, 19, 14, 1, 2.75f}, {19, 24, 16, 29, 2, 2.85f},
+    {8, 15, 4, 13, 1, -10.95f}, {7, 9, 2, 10, 2, 3.65f}, {15, 14, 14, 13, 1, -4.15f},
+    {18, 13, 18, 11, 1, 0.25f}, {8, 19, 5, 23, 2, -0.65f}, {3, 13, 1, 14, 1, -2.25f},
+    {23, 20, 16, 14, 1, 3.75f}, {17, 15, 13, 18, 2, 35.75f}, {16, 16, 9, 14, 5, 3.15f},
+    {15, 28, 15, 27, 3, -0.55f}, {18, 20, 16, 19, 1, 1.95f}, {16, 17, 16, 11, 2, -6.55f},
+    {30, 1, 10, 19, 1, 88.35f}, {12, 19, 9, 23, 2, 7.25f}, {25, 13, 21, 13, 1, 1.75f},
+    {9, 23, 5, 24, 5, -4.15f}, {13, 20, 13, 18, 1, 0.25f}, {13, 13, 12, 13, 3, 0.25f},
+    {29, 18, 25, 2, 2, 0.65f}, {30, 30, 25, 26, 1, 3.75f}, {16, 20, 15, 11, 1, 1.65f},
+    {18, 16, 18, 14, 1, 2.85f}, {15, 18, 5, 7, 4, 42.15f}, {16, 13, 15, 19, 1, 11.75f},
+    {26, 24, 16, 9, 5, -1.25f}, {1, 28, 1, 5, 1, -8.25f}, {20, 17, 20, 16, 1, 0.05f},
+    {15, 19, 10, 17, 4, 2.15f}, {12, 9, 10, 5, 1, 0.65f}, {30, 29, 28, 29, 1, -1.55f},
+    {29, 17, 27, 18, 2, -2.75f}, {17, 29, 15, 27, 2, 1.15f}, {9, 29, 9, 28, 2, -0.15f},
+    {23, 24, 21, 22, 1, -0.75f}, {22, 2, 1, 1, 1, 16.85f}, {20, 4, 20, 1, 1, 1.15f},
+    {5, 30, 4, 25, 1, 1.45f}, {20, 8, 17, 12, 7, 15.35f}, {10, 7, 3, 17, 3, 19.45f},
+    {21, 17, 14, 15, 5, 8.65f}, {14, 10, 13, 8, 1, -1.25f}, {4, 21, 4, 13, 3, 0.25f},
+    {30, 1, 24, 10, 1, 2.15f}, {15, 17, 14, 16, 3, 0.15f}, {21, 23, 20, 15, 3, 2.85f},
+    {17, 20, 17, 18, 3, -2.25f}, {12, 11, 12, 6, 5, 1.75f}, {15, 15, 12, 17, 1, -15.15f},
+    {25, 9, 16, 25, 6, 4.15f}, {22, 28, 22, 27, 3, -0.45f}, {5, 8, 3, 3, 3, -8.25f},
+    {9, 5, 9, 1, 1, 1.25f}, {30, 12, 29, 23, 1, -0.85f}, {20, 21, 5, 9, 5, 3.55f},
+    {15, 21, 15, 20, 1, 0.45f}, {11, 17, 10, 23, 2, -1.25f}, {16, 11, 15, 13, 1, 9.65f},
+    {16, 12, 16, 10, 1, 1.25f}, {15, 6, 14, 3, 3, 3.15f}, {2, 4, 1, 1, 1, -2.05f},
+    {15, 16, 11, 15, 1, -6.85f}, {24, 6, 24, 2, 2, -0.05f}, {8, 15, 6, 12, 1, 3.25f},
+    {21, 27, 1, 30, 1, 7.05f}, {17, 10, 14, 16, 3, 2.35f}, {13, 9, 7, 7, 7, -1.45f},
+    {22, 17, 19, 17, 1, -1.05f}, {16, 14, 14, 13, 2, 20.25f}, {14, 21, 13, 23, 1, 1.15f},
+    {18, 2, 15, 7, 2, 1.35f}, {3, 25, 1, 24, 1, 1.05f}, {24, 20, 7, 14, 7, 5.15f},
+    {26, 25, 24, 19, 2, 2.55f}, {6, 25, 6, 23, 6, 0.55f}, {15, 24, 15, 17, 7, 0.55f},
+    {22, 14, 16, 15, 1, -0.15f}, {17, 25, 17, 23, 1, 0.65f}, {12, 18, 2, 26, 2, -28.35f},
+    {30, 30, 26, 11, 1, 3.85f}, {22, 8, 16, 14, 5, 2.05f}, {9, 16, 8, 20, 1, -1.15f},
+    {4, 14, 2, 13, 2, 3.05f}, {28, 7, 27, 8, 1, -0.95f}, {10, 22, 9, 24, 1, -1.55f},
+    {14, 16, 13, 18, 3, -0.35f}, {28, 26, 3, 15, 2, 101.95f}, {12, 15, 10, 15, 1, 0.35f},
+    {18, 17, 17, 15, 1, -2.05f}, {30, 10, 28, 14, 1, -2.15f}, {30, 14, 28, 30, 1, 4.25f},
+    {30, 18, 7, 13, 1, 105.15f}, {3, 19, 2, 20, 1, 1.15f}, {16, 19, 14, 13, 2, 27.45f},
+    {11, 9, 5, 27, 4, 30.15f}, {16, 19, 15, 15, 2, 18.45f}, {24, 22, 18, 19, 7, -2.45f},
+    {12, 17, 12, 12, 1, 1.85f}, {28, 5, 28, 1, 1, 2.95f}, {4, 29, 2, 30, 1, -3.75f},
+    {27, 11, 27, 8, 1, -0.65f}, {8, 3, 8, 1, 1, 0.05f}, {15, 10, 15, 8, 3, 0.25f},
+    {12, 27, 11, 18, 4, 34.45f}, {25, 6, 22, 8, 6, -2.05f}, {15, 3, 15, 2, 2, 0.25f},
+    {19, 22, 17, 19, 1, 3.25f}, {24, 21, 24, 16, 2, 2.05f}, {9, 7, 6, 6, 6, 2.85f},
+    {13, 26, 11, 27, 2, 3.45f}, {24, 10, 19, 12, 4, 20.95f}, {22, 17, 22, 9, 2, 1.45f},
+    {17, 14, 14, 11, 1, -1.95f}, {13, 4, 13, 3, 1, -0.35f}, {15, 18, 15, 17, 1, -6.85f},
+    {29, 30, 29, 24, 1, 1.15f}, {29, 29, 20, 17, 2, -31.95f}, {6, 12, 2, 27, 2, 11.85f},
+    {18, 17, 14, 13, 2, 2.75f}, {11, 27, 11, 26, 4, 0.15f}, {22, 12, 3, 18, 3, 8.35f},
+    {15, 13, 13, 9, 1, 1.15f}, {12, 20, 7, 18, 1, 2.15f}, {16, 6, 15, 9, 1, -1.15f},
+    {3, 6, 1, 7, 1, -1.05f}, {12, 17, 11, 19, 1, 2.45f}, {15, 8, 8, 18, 7, 1.45f},
+    {11, 19, 11, 5, 3, 0.15f}, {17, 20, 16, 23, 3, -1.65f}, {12, 6, 9, 13, 1, 41.85f},
+    {2, 1, 1, 2, 1, 0.35f}, {14, 26, 13, 21, 3, 0.65f}, {25, 16, 16, 14, 3, -0.35f},
+    {30, 14, 29, 14, 1, 0.25f}, {27, 25, 15, 22, 4, 56.75f}, {13, 10, 8, 7, 2, 23.55f},
+    {18, 19, 13, 14, 1, 88.85f}, {28, 28, 28, 22, 3, -7.25f}, {8, 14, 8, 11, 1, 1.05f},
+    {23, 28, 22, 24, 2, 0.75f}, {8, 2, 3, 18, 2, -1.05f}, {22, 24, 22, 23, 7, -1.65f},
+    {20, 17, 15, 16, 1, -9.75f}, {8, 11, 6, 4, 4, -16.95f}, {25, 13, 23, 13, 2, -0.05f},
+    {18, 18, 16, 15, 1, -10.05f}, {20, 16, 16, 15, 1, 34.15f}, {18, 20, 14, 26, 3, 14.75f},
+    {17, 12, 17, 8, 1, -0.95f}, {1, 5, 1, 3, 1, 1.45f}, {22, 13, 13, 20, 2, 4.85f},
+    {17, 16, 17, 14, 3, -0.05f}, {27, 17, 25, 17, 2, -0.35f}, {8, 23, 6, 29, 2, 0.75f},
+    {15, 4, 14, 18, 1, 64.75f}, {10, 24, 10, 17, 4, 24.25f}, {25, 30, 25, 28, 1, -0.35f},
+    {3, 22, 1, 29, 1, -13.65f}, {24, 8, 23, 17, 1, 2.85f}, {26, 3, 26, 1, 1, 1.75f},
+    {18, 22, 18, 17, 2, -0.35f}, {9, 17, 8, 10, 2, 0.25f}, {29, 22, 29, 2, 2, -12.15f},
+    {19, 4, 5, 10, 3, 108.05f}, {3, 28, 3, 27, 1, -0.35f}, {12, 15, 11, 18, 1, -3.35f},
+    {30, 3, 28, 4, 1, 1.95f}, {7, 9, 7, 8, 1, -0.35f}, {24, 15, 8, 14, 7, 21.25f},
+    {30, 6, 20, 16, 1, -20.05f}, {18, 18, 1, 10, 1, 95.85f}, {30, 20, 28, 21, 1, -1.05f},
+    {15, 15, 13, 14, 1, -17.75f}, {6, 3, 5, 1, 1, -0.55f}, {3, 8, 1, 17, 1, 2.75f},
+    {3, 2, 2, 2, 2, 0.65f}, {19, 28, 18, 20, 1, 0.75f}, {20, 20, 20, 17, 2, -1.85f},
+    {21, 30, 19, 29, 1, 2.65f}, {12, 19, 12, 13, 1, -2.15f}, {29, 10, 29, 4, 2, 1.05f},
+    {20, 16, 20, 14, 1, -0.05f}, {15, 9, 11, 16, 2, 4.25f}, {8, 13, 6, 26, 4, 3.75f},
+    {13, 11, 12, 8, 2, -13.55f}, {17, 27, 17, 26, 4, -0.05f}, {29, 29, 14, 12, 1, 105.95f},
+    {29, 2, 28, 3, 2, 0.45f}, {9, 15, 7, 9, 4, 3.05f}, {27, 28, 12, 30, 1, 9.35f},
+    {14, 30, 2, 28, 1, 79.25f}, {19, 12, 18, 14, 1, 1.75f}, {26, 5, 24, 15, 5, 7.65f},
+    {2, 24, 2, 2, 2, -0.45f}, {6, 21, 5, 21, 1, 0.95f}, {22, 16, 9, 17, 2, 79.15f},
+    {16, 19, 15, 17, 1, 28.05f}, {2, 29, 2, 28, 2, 0.05f}, {25, 11, 24, 1, 1, 0.65f},
+    {16, 30, 16, 29, 1, -0.35f}, {14, 20, 14, 17, 3, 0.95f}, {15, 14, 11, 17, 3, 2.05f},
+    {18, 17, 16, 21, 1, 1.15f}, {17, 8, 17, 4, 2, 2.75f}, {11, 4, 11, 3, 3, -1.65f},
+    {25, 16, 9, 17, 6, 8.65f}, {18, 8, 18, 6, 6, 3.55f}, {17, 22, 17, 19, 1, -0.25f},
+    {8, 20, 3, 11, 3, -28.95f}, {20, 17, 4, 17, 1, -7.35f}, {29, 12, 12, 19, 2, 122.25f},
+    {14, 29, 14, 28, 2, 0.55f}, {12, 18, 10, 18, 1, 4.75f}, {13, 15, 13, 11, 2, 1.75f},
+    {18, 15, 14, 15, 2, 11.15f}, {19, 17, 17, 19, 1, 0.15f}, {22, 17, 12, 16, 6, 2.55f},
+    {30, 22, 29, 18, 1, 0.05f}, {30, 2, 29, 20, 1, -7.95f}, {12, 3, 1, 1, 1, 51.05f},
+    {4, 7, 1, 7, 1, 6.25f}, {27, 10, 21, 13, 4, 0.05f}, {18, 21, 18, 13, 3, -1.15f},
+    {12, 4, 3, 6, 2, 0.75f}, {12, 10, 9, 3, 2, 26.65f}, {3, 28, 2, 29, 2, -1.25f},
+    {22, 2, 20, 5, 2, 1.15f}, {27, 18, 20, 3, 3, -0.55f}, {6, 24, 6, 23, 1, 0.05f},
+    {27, 26, 9, 16, 4, 5.85f}, {5, 18, 5, 11, 5, 1.55f}, {20, 14, 15, 12, 3, 2.25f},
+    {19, 16, 19, 15, 1, -1.65f}, {27, 4, 21, 9, 4, -16.85f}, {3, 19, 2, 29, 1, -62.65f},
+    {20, 24, 18, 22, 1, -1.25f}, {18, 7, 18, 2, 1, -1.05f}, {28, 30, 28, 28, 1, -1.55f},
+    {11, 24, 10, 9, 1, 1.35f}, {21, 18, 21, 14, 3, 0.25f}, {27, 19, 26, 18, 2, -0.65f},
+    {16, 18, 10, 6, 6, 0.85f}, {11, 18, 5, 19, 1, 17.45f}, {24, 16, 22, 16, 1, 0.25f},
+    {17, 15, 17, 9, 5, -9.35f}, {27, 29, 20, 11, 2, 34.35f}, {29, 25, 28, 22, 1, 0.95f},
+    {21, 11, 21, 5, 1, -0.95f}, {12, 15, 8, 16, 2, -10.05f}, {2, 29, 1, 30, 1, 1.45f},
+    {18, 12, 4, 21, 3, -6.05f}, {18, 9, 11, 13, 3, 93.25f}, {18, 3, 10, 21, 3, 3.15f},
+    {17, 11, 16, 16, 1, -10.85f}, {15, 17, 13, 14, 1, -1.65f}, {7, 7, 7, 5, 5, -0.15f},
+    {9, 29, 5, 18, 2, -2.45f}, {10, 11, 10, 6, 6, -0.35f}, {28, 26, 25, 26, 1, 0.15f},
+    {19, 30, 8, 20, 1, 118.15f}, {8, 15, 7, 29, 2, -81.85f}, {21, 18, 19, 17, 1, 4.05f},
+    {2, 22, 1, 22, 1, 1.05f}, {12, 20, 4, 17, 1, -0.85f}, {27, 8, 4, 14, 2, 152.35f},
+    {26, 10, 25, 13, 1, 0.65f}, {19, 13, 19, 8, 3, 1.35f}, {12, 16, 7, 18, 7, -12.35f},
+    {20, 26, 12, 3, 3, 95.35f}, {6, 10, 3, 10, 2, -23.25f}, {25, 25, 25, 21, 2, -0.75f},
+    {12, 3, 7, 16, 2, 75.65f}, {8, 4, 4, 17, 4, 50.85f}, {12, 20, 5, 8, 5, 47.85f},
+    {22, 15, 8, 13, 7, 2.55f}, {12, 13, 12, 8, 2, 0.55f}, {20, 15, 19, 13, 1, 0.15f},
+    {30, 5, 29, 8, 1, 0.25f}, {14, 29, 13, 23, 2, 38.15f}, {18, 19, 9, 10, 7, -2.65f},
+    {2, 11, 1, 10, 1, -1.95f}, {12, 13, 12, 11, 1, -1.05f}, {27, 15, 9, 5, 4, 110.25f},
+    {13, 12, 7, 17, 2, 35.25f}, {8, 17, 1, 26, 1, 2.65f}, {20, 24, 11, 12, 4, 3.65f},
+    {12, 24, 10, 22, 6, 18.75f}, {19, 29, 14, 20, 1, 89.45f}, {20, 27, 20, 25, 2, -0.55f},
+    {9, 25, 8, 27, 1, 0.35f}, {7, 11, 5, 11, 1, 0.25f}, {20, 11, 11, 8, 1, 105.05f},
+    {9, 8, 9, 5, 1, 0.25f}, {27, 9, 25, 10, 1, 1.25f}, {30, 20, 22, 20, 1, -34.65f},
+    {26, 21, 26, 20, 1, -0.55f}, {30, 14, 27, 16, 1, -0.15f}, {12, 16, 11, 19, 3, 0.75f},
+    {7, 28, 6, 29, 1, -0.15f}, {17, 23, 17, 22, 2, -0.15f}, {12, 17, 2, 2, 1, -94.25f},
+    {17, 14, 17, 13, 1, -12.05f}, {18, 12, 16, 16, 1, -15.35f}, {7, 23, 7, 17, 1, -1.75f},
+    {25, 12, 9, 15, 4, 31.35f}, {16, 6, 16, 5, 5, 0.15f}, {8, 16, 7, 16, 7, -2.15f},
+    {6, 7, 5, 7, 5, -0.15f}, {15, 13, 15, 12, 2, -12.05f}, {13, 15, 13, 13, 3, -0.35f},
+    {16, 12, 16, 11, 1, -0.65f}, {18, 15, 15, 14, 3, -0.55f}, {17, 8, 14, 5, 4, 28.95f},
+    {9, 26, 6, 22, 5, 39.05f}, {17, 16, 14, 17, 3, 7.05f}, {25, 1, 24, 2, 1, 0.65f},
+    {14, 16, 14, 15, 1, -1.65f}, {24, 22, 4, 23, 4, 2.85f}, {30, 29, 27, 29, 1, 4.85f},
+    {17, 18, 17, 17, 1, -1.85f}, {19, 30, 19, 28, 1, 1.75f}, {21, 27, 21, 23, 3, -31.65f},
+    {16, 18, 15, 20, 1, 0.05f}, {27, 27, 13, 12, 4, 13.75f}, {30, 25, 27, 26, 1, -0.35f},
+    {4, 21, 3, 7, 1, 0.35f}, {10, 5, 10, 4, 4, -5.75f}, {14, 14, 5, 3, 1, 83.85f},
+    {23, 6, 21, 3, 3, 0.95f}, {9, 20, 2, 15, 2, 27.95f}, {23, 9, 20, 13, 1, -0.25f},
+    {15, 14, 12, 3, 3, -19.05f}, {19, 25, 19, 18, 4, 2.45f}, {27, 25, 24, 22, 4, -13.25f},
+    {15, 15, 15, 11, 1, 44.05f}, {17, 16, 14, 13, 1, 51.85f}, {12, 18, 12, 17, 1, -0.05f},
+    {30, 3, 30, 2, 1, 0.05f}, {21, 20, 18, 28, 3, 79.35f}, {25, 25, 7, 14, 5, 111.25f},
+    {3, 11, 2, 3, 2, -61.65f}, {25, 5, 9, 21, 4, 3.05f}, {6, 15, 4, 28, 3, -69.95f},
+    {9, 9, 3, 3, 3, 35.65f}, {16, 19, 14, 16, 2, 62.05f}, {10, 25, 10, 20, 1, -0.25f},
+    {2, 17, 2, 15, 1, -1.05f}, {17, 15, 15, 16, 1, -2.95f}, {20, 15, 19, 15, 1, 0.95f},
+    {22, 2, 22, 1, 1, -0.15f}, {15, 19, 15, 18, 1, -18.15f}, {15, 16, 10, 12, 1, -18.65f},
+    {28, 2, 23, 14, 2, 74.55f}, {11, 3, 9, 2, 1, 2.65f}
+};
+static const std::vector<ABWLParamsFloatTh> teblid_wl_params_512(std::begin(teblid_wl_params_512_),
+                                                                 std::end(teblid_wl_params_512_));
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/vgg.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/vgg.cpp
new file mode 100644
index 00000000..19184979
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/vgg.cpp
@@ -0,0 +1,583 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2014, 2015
+ *
+ * Karen Simonyan <karen at robots dot ox dot ac dot uk>
+ * Andrea Vedaldi <vedaldi at robots dot ox dot ac dot uk>
+ * Andrew Zisserman <az at robots dot ox dot ac dot uk>
+ *
+ * Visual Geometry Group
+ * Department of Engineering Science, University of Oxford
+ *
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the copyright holders nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+/*
+
+ "Learning Local Feature Descriptors Using Convex Optimisation",
+ Simonyan, K. and Vedaldi, A. and Zisserman, A.,
+ IEEE Transactions on Pattern Analysis and Machine Intelligence, 2014
+
+ "Discriminative Learning of Local Image Descriptors",
+ Matthew A. Brown, Gang Hua, Simon A. J. Winder,
+ IEEE Transactions on Pattern Analysis and Machine Intelligence, 2011
+
+ OpenCV port by: Cristian Balint <cristian dot balint at gmail dot com>
+
+ */
+
+#include "precomp.hpp"
+
+
+
+using namespace cv;
+using namespace std;
+
+
+namespace cv
+{
+namespace xfeatures2d
+{
+
+#ifdef OPENCV_XFEATURES2D_HAS_VGG_DATA
+
+/*
+ !VGG implementation
+ */
+class VGG_Impl CV_FINAL : public VGG
+{
+
+public:
+
+    // constructor
+    explicit VGG_Impl( int desc = VGG::VGG_80, float isigma = 1.4f,
+                       bool img_normalize = true, bool use_scale_orientation = true,
+                       float scale_factor = 6.25f, bool dsc_normalize = false );
+
+    // destructor
+    virtual ~VGG_Impl() CV_OVERRIDE;
+
+    void read( const FileNode& fn ) CV_OVERRIDE;
+    void write( FileStorage& fs ) const CV_OVERRIDE;
+
+    // returns the descriptor length in bytes
+    virtual int descriptorSize() const CV_OVERRIDE { return m_descriptor_size; }
+
+    // returns the descriptor type
+    virtual int descriptorType() const CV_OVERRIDE { return CV_32F; }
+
+    // returns the default norm type
+    virtual int defaultNorm() const CV_OVERRIDE { return NORM_L2; }
+
+    // compute descriptors given keypoints
+    virtual void compute( InputArray image, vector<KeyPoint>& keypoints, OutputArray descriptors ) CV_OVERRIDE;
+
+    // getter / setter
+    virtual void setSigma(const float isigma) CV_OVERRIDE { m_isigma = isigma; }
+    virtual float getSigma() const CV_OVERRIDE { return m_isigma; }
+
+    virtual void setUseNormalizeImage(const bool img_normalize) CV_OVERRIDE { m_img_normalize = img_normalize; }
+    virtual bool getUseNormalizeImage() const CV_OVERRIDE { return m_img_normalize; }
+
+    virtual void setUseScaleOrientation(const bool use_scale_orientation) CV_OVERRIDE { m_use_scale_orientation = use_scale_orientation; }
+    virtual bool getUseScaleOrientation() const CV_OVERRIDE { return m_use_scale_orientation; }
+
+    virtual void setScaleFactor(const float scale_factor) CV_OVERRIDE { m_scale_factor = scale_factor; }
+    virtual float getScaleFactor() const CV_OVERRIDE { return m_scale_factor; }
+
+    virtual void setUseNormalizeDescriptor(const bool dsc_normalize) CV_OVERRIDE { m_dsc_normalize = dsc_normalize; }
+    virtual bool getUseNormalizeDescriptor() const CV_OVERRIDE { return m_dsc_normalize; }
+
+protected:
+
+    /*
+     * VGG parameters
+     */
+
+    int m_descriptor_size;
+
+    // gauss sigma
+    float m_isigma;
+
+    // angle bins
+    int m_anglebins;
+
+    // sample window
+    float m_scale_factor;
+
+    /*
+     * VGG switches
+     */
+
+    // normalize image
+    bool m_img_normalize;
+
+    // switch to enable sample by keypoints orientation
+    bool m_use_scale_orientation;
+
+    // normalize desc
+    bool m_dsc_normalize;
+
+    /*
+     * VGG arrays
+     */
+
+    // image
+    Mat m_image;
+
+    // pool regions & proj
+    Mat m_PRFilters, m_Proj;
+
+private:
+
+    /*
+     * VGG functions
+     */
+
+     // initialize parameters
+     inline void ini_params( const int PRrows, const int PRcols,
+                             const unsigned int PRidx[], const unsigned int PRidxSize, const unsigned int PR[],
+                             const int PJrows, const int PJcols,
+                             const unsigned int PJidx[], const unsigned int PJidxSize, const unsigned int PJ[] );
+
+}; // END VGG_Impl CLASS
+
+// -------------------------------------------------
+/* VGG internal routines */
+
+// sample 64x64 patch from image given keypoint
+static inline void get_patch( const KeyPoint kp, Mat& Patch, const Mat& image,
+                              const bool use_scale_orientation, const float scale_factor )
+{
+  // scale & radians
+  float scale = kp.size / 64.0f * scale_factor;
+  const float angle = (kp.angle == -1)
+        ? 0 : ( (kp.angle)*(float)CV_PI ) / 180.f;
+
+  // transforms
+  const float tsin = sin(angle) * scale;
+  const float tcos = cos(angle) * scale;
+
+  const float half_cols = (float)Patch.cols / 2.0f;
+  const float half_rows = (float)Patch.rows / 2.0f;
+
+  // sample form original image
+  for ( int x = 0; x < Patch.cols; x++ )
+  {
+    for ( int y = 0; y < Patch.rows; y++ )
+    {
+      if ( use_scale_orientation )
+      {
+        const float xoff = x - half_cols;
+        const float yoff = y - half_rows;
+        // the rotation shifts & scale
+        int img_x = int( (kp.pt.x + 0.5f) + xoff*tcos - yoff*tsin );
+        int img_y = int( (kp.pt.y + 0.5f) + xoff*tsin + yoff*tcos );
+        // sample only within image
+        if ( ( img_x < image.cols ) && ( img_x >= 0 )
+          && ( img_y < image.rows ) && ( img_y >= 0 ) )
+          Patch.at<float>( y, x ) = image.at<float>( img_y, img_x );
+        else
+          Patch.at<float>( y, x ) = 0.0f;
+      }
+      else
+      {
+        const float xoff = x - half_cols;
+        const float yoff = y - half_rows;
+        // the samples from image
+        int img_x = int( kp.pt.x + 0.5f + xoff );
+        int img_y = int( kp.pt.y + 0.5f + yoff );
+        // sample only within image
+        if ( ( img_x < image.cols ) && ( img_x >= 0 )
+          && ( img_y < image.rows ) && ( img_y >= 0 ) )
+          Patch.at<float>( y, x ) = image.at<float>( img_y, img_x );
+        else
+          Patch.at<float>( y, x ) = 0.0f;
+      }
+    }
+  }
+}
+
+// get descriptor given 64x64 image patch
+static void get_desc( const Mat Patch, Mat& PatchTrans, int anglebins, bool img_normalize )
+{
+    Mat Ix, Iy;
+    // % compute gradient
+    float kparam[3] = { -1,  0,  1 };
+    Mat Kernel( 1, 3, CV_32F, &kparam );
+    filter2D( Patch, Ix, CV_32F, Kernel,     Point( -1, -1 ), 0, BORDER_REPLICATE );
+    filter2D( Patch, Iy, CV_32F, Kernel.t(), Point( -1, -1 ), 0, BORDER_REPLICATE );
+
+    Mat GMag, GAngle;
+
+    // % gradient magnitude
+    // % GMag = sqrt(Ix .^ 2 + Iy .^ 2);
+    magnitude( Ix, Iy, GMag );
+
+    // % gradient orientation: [0; 2 * pi]
+    // % GAngle = atan2(Iy, Ix) + pi;
+    //phase( Ix, Iy, GAngle, false ); //<- opencv is buggy
+    GAngle = Mat( GMag.rows, GMag.cols, CV_32F );
+    for ( int i = 0; i < (int)GAngle.total(); i++ )
+      GAngle.at<float>(i) = atan2( Iy.at<float>(i), Ix.at<float>(i) ) + (float)CV_PI;
+
+    // % soft-assignment of gradients to the orientation histogram
+    float AngleStep = 2.0f * (float) CV_PI / (float) anglebins;
+    Mat GAngleRatio = GAngle / AngleStep - 0.5f;
+
+    // % Offset1 = mod(GAngleRatio, 1);
+    Mat Offset1( GAngleRatio.rows, GAngleRatio.cols, CV_32F );
+    for ( int i = 0; i < (int)GAngleRatio.total(); i++ )
+      Offset1.at<float>(i) = GAngleRatio.at<float>(i) - floor( GAngleRatio.at<float>(i) );
+
+    Mat w1 = 1.0f - Offset1.t();
+    Mat w2 = Offset1.t();
+
+    Mat Bin1( GAngleRatio.rows, GAngleRatio.cols, CV_8U );
+    Mat Bin2( GAngleRatio.rows, GAngleRatio.cols, CV_8U );
+
+    // % Bin1 = ceil(GAngleRatio);
+    // % Bin1(Bin1 == 0) = Params.nAngleBins;
+    for ( int i = 0; i < (int)GAngleRatio.total(); i++ )
+    {
+      if ( ceil( GAngleRatio.at<float>(i) - 1.0f) == -1.0f )
+        Bin1.at<uchar>(i) = (uchar) anglebins - 1;
+      else
+        Bin1.at<uchar>(i) = (uchar) ceil( GAngleRatio.at<float>(i) - 1.0f );
+    }
+
+    // % Bin2 = Bin1 + 1;
+    // % Bin2(Bin2 > Params.nAngleBins) = 1;
+    for ( int i = 0; i < (int)GAngleRatio.total(); i++ )
+    {
+      if ( ( Bin1.at<uchar>(i) + 1 ) > anglebins - 1 )
+        Bin2.at<uchar>(i) = 0;
+      else
+        Bin2.at<uchar>(i) = Bin1.at<uchar>(i) + 1;
+    }
+
+    // normalize
+    if ( img_normalize )
+    {
+      // % Quantile = 0.8;
+      float q = 0.8f;
+
+      // % T = quantile(GMag(:), Quantile);
+      Mat GMagSorted;
+      sort( GMag.reshape( 0, 1 ), GMagSorted, SORT_ASCENDING );
+
+      int n = GMagSorted.cols;
+      // scipy/stats/mstats_basic.py#L1718 mquantiles()
+      // m = alphap + p*(1.-alphap-betap)
+      // alphap = 0.5 betap = 0.5 => (m = 0.5)
+      // aleph = (n*p + m)
+      float aleph = ( n * q + 0.5f );
+      int k = cvFloor( aleph );
+      if ( k >= n - 1 ) k = n - 1;
+      if ( k <= 1 ) k = 1;
+
+      float gamma = aleph - k;
+      if ( gamma >= 1.0f ) gamma = 1.0f;
+      if ( gamma <= 0.0f ) gamma = 0.0f;
+      // quantile out from distribution
+      float T = ( 1.0f - gamma ) * GMagSorted.at<float>( k - 1 )
+              + gamma * GMagSorted.at<float>( k );
+
+      // avoid NaN
+      if ( T != 0.0f ) GMag /= ( T / anglebins );
+    }
+
+    Mat Bin1T = Bin1.t();
+    Mat Bin2T = Bin2.t();
+    Mat GMagT = GMag.t();
+
+    // % feature channels
+    PatchTrans = Mat( (int)Patch.total(), anglebins, CV_32F, Scalar::all(0) );
+
+    for ( int i = 0; i < anglebins; i++ )
+    {
+      for ( int p = 0; p < (int)Patch.total(); p++ )
+      {
+        if ( Bin1T.at<uchar>(p) == i )
+          PatchTrans.at<float>(p,i) = w1.at<float>(p) * GMagT.at<float>(p);
+        if ( Bin2T.at<uchar>(p) == i )
+          PatchTrans.at<float>(p,i) = w2.at<float>(p) * GMagT.at<float>(p);
+      }
+    }
+}
+
+// -------------------------------------------------
+/* VGG interface implementation */
+
+struct ComputeVGGInvoker : ParallelLoopBody
+{
+    ComputeVGGInvoker( const Mat& _image, Mat* _descriptors,
+                        const vector<KeyPoint>& _keypoints,
+                        const Mat& _PRFilters, const Mat& _Proj,
+                        const int _anglebins, const bool _img_normalize,
+                        const bool _use_scale_orientation, const float _scale_factor )
+    {
+      image = _image;
+      keypoints = _keypoints;
+      descriptors = _descriptors;
+
+      Proj = _Proj;
+      PRFilters = _PRFilters;
+
+      anglebins = _anglebins;
+      scale_factor = _scale_factor;
+      img_normalize = _img_normalize;
+      use_scale_orientation  = _use_scale_orientation;
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      Mat Desc, PatchTrans;
+      Mat Patch( 64, 64, CV_32F );
+      for (int k = range.start; k < range.end; k++)
+      {
+        // sample patch from image
+        get_patch( keypoints[k], Patch, image, use_scale_orientation, scale_factor );
+        // compute transform
+        get_desc( Patch, PatchTrans, anglebins, img_normalize );
+        // pool features
+        Desc = PRFilters * PatchTrans;
+        // crop
+        min( Desc, 1.0f, Desc );
+        // reshape
+        Desc = Desc.reshape( 1, (int)Desc.total() );
+        // project
+        descriptors->row( k ) = Desc.t() * Proj.t();
+      }
+    }
+
+    Mat image;
+    Mat *descriptors;
+    vector<KeyPoint> keypoints;
+
+    Mat Proj;
+    Mat PRFilters;
+
+    int anglebins;
+    float scale_factor;
+    bool img_normalize;
+    bool use_scale_orientation;
+};
+
+// descriptor computation using keypoints
+void VGG_Impl::compute( InputArray _image, vector<KeyPoint>& keypoints, OutputArray _descriptors )
+{
+    // do nothing if no image
+    if( _image.getMat().empty() )
+      return;
+
+    m_image = _image.getMat().clone();
+
+    // Only 8bit images
+    CV_Assert( m_image.depth() == CV_8U );
+
+    // convert to gray inplace
+    if( m_image.channels() > 1 )
+      cvtColor( m_image, m_image, COLOR_BGR2GRAY );
+
+    //convert
+    Mat image;
+    m_image.convertTo( image, CV_32F );
+    m_image = image;
+    image.release();
+
+    // smooth whole image
+    GaussianBlur( m_image, m_image, Size( 0, 0 ), m_isigma, m_isigma, BORDER_REPLICATE );
+
+    // allocate array
+    _descriptors.create( (int) keypoints.size(), m_descriptor_size, CV_32F );
+
+    // prepare descriptors
+    Mat descriptors = _descriptors.getMat();
+    descriptors.setTo( Scalar(0) );
+
+    parallel_for_( Range( 0, (int) keypoints.size() ),
+        ComputeVGGInvoker( m_image, &descriptors, keypoints, m_PRFilters, m_Proj,
+                            m_anglebins, m_img_normalize, m_use_scale_orientation,
+                            m_scale_factor )
+    );
+
+    // normalize desc
+    if ( m_dsc_normalize )
+    {
+      normalize( descriptors, descriptors, 0.0f, 255.0f, NORM_MINMAX, CV_32F );
+      descriptors.convertTo( _descriptors, CV_8U );
+    }
+}
+
+void VGG_Impl::ini_params( const int PRrows, const int PRcols,
+                           const unsigned int PRidx[], const unsigned int PRidxSize,
+                           const unsigned int PR[],
+                           const int PJrows, const int PJcols,
+                           const unsigned int PJidx[], const unsigned int PJidxSize,
+                           const unsigned int PJ[] )
+{
+    int idx;
+
+    // initialize pool-region matrix
+    m_PRFilters = Mat::zeros( PRrows, PRcols, CV_32F );
+    // initialize projection matrix
+    m_Proj = Mat::zeros( PJrows, PJcols, CV_32F );
+
+    idx = 0;
+    // fill sparse pool-region matrix
+    for ( size_t i = 0; i < PRidxSize; i=i+2 )
+    {
+      for ( size_t k = 0; k < PRidx[i+1]; k++ )
+      {
+        // expand floats from hex blobs
+        m_PRFilters.at<float>( PRidx[i] + (int)k ) = *(float *)&PR[idx];
+        idx++;
+      }
+    }
+
+    idx = 0;
+    // fill sparse projection matrix
+    for ( size_t i = 0; i < PJidxSize; i=i+2 )
+    {
+      for ( size_t k = 0; k < PJidx[i+1]; k++ )
+      {
+        // expand floats from hex blobs
+        m_Proj.at<float>( PJidx[i] + (int)k ) = *(float *)&PJ[idx];
+        idx++;
+      }
+    }
+}
+
+// constructor
+VGG_Impl::VGG_Impl( int _desc, float _isigma, bool _img_normalize,
+                    bool _use_scale_orientation, float _scale_factor, bool _dsc_normalize )
+             : m_isigma( _isigma ), m_scale_factor( _scale_factor ),
+               m_img_normalize( _img_normalize ),
+               m_use_scale_orientation( _use_scale_orientation ),
+               m_dsc_normalize( _dsc_normalize )
+{
+    // constant
+    m_anglebins = 8;
+
+    // desc type
+    switch ( _desc )
+    {
+      case VGG::VGG_120:
+        {
+          #include "vgg_generated_120.i"
+          ini_params( PRrows, PRcols, PRidx, sizeof(PRidx)/sizeof(PRidx[0]), PR,
+                      PJrows, PJcols, PJidx, sizeof(PJidx)/sizeof(PJidx[0]), PJ );
+        }
+        break;
+      case VGG::VGG_80:
+        {
+          #include "vgg_generated_80.i"
+          ini_params( PRrows, PRcols, PRidx, sizeof(PRidx)/sizeof(PRidx[0]), PR,
+                      PJrows, PJcols, PJidx, sizeof(PJidx)/sizeof(PJidx[0]), PJ );
+        }
+        break;
+      case VGG::VGG_64:
+        {
+          #include "vgg_generated_64.i"
+          ini_params( PRrows, PRcols, PRidx, sizeof(PRidx)/sizeof(PRidx[0]), PR,
+                      PJrows, PJcols, PJidx, sizeof(PJidx)/sizeof(PJidx[0]), PJ );
+        }
+        break;
+      case VGG::VGG_48:
+        {
+
+          #include "vgg_generated_48.i"
+          ini_params( PRrows, PRcols, PRidx, sizeof(PRidx)/sizeof(PRidx[0]), PR,
+                      PJrows, PJcols, PJidx, sizeof(PJidx)/sizeof(PJidx[0]), PJ );
+        }
+        break;
+      default:
+        CV_Error( Error::StsInternal, "Unknown Descriptor Type." );
+    }
+
+    // set desc size
+    m_descriptor_size = m_Proj.rows;
+}
+
+// destructor
+VGG_Impl::~VGG_Impl()
+{
+}
+
+void VGG_Impl::read (const FileNode& fn)
+{
+    // if node is empty, keep previous value
+    if (!fn["isigma"].empty())
+      fn["isigma"] >> m_isigma;
+    if (!fn["scale_factor"].empty())
+      fn["scale_factor"] >> m_scale_factor;
+    if (!fn["img_normalize"].empty())
+      fn["img_normalize"] >> m_img_normalize;
+    if (!fn["use_scale_orientation"].empty())
+      fn["use_scale_orientation"] >> m_use_scale_orientation;
+    if (!fn["dsc_normalize"].empty())
+      fn["dsc_normalize"] >> m_dsc_normalize;
+}
+
+void VGG_Impl::write (FileStorage& fs) const
+{
+    if ( fs.isOpened() )
+    {
+        fs << "isigma" << m_isigma;
+        fs << "scale_factor" << m_scale_factor;
+        fs << "img_normalize" << m_img_normalize;
+        fs << "use_scale_orientation" << m_use_scale_orientation;
+        fs << "dsc_normalize" << m_dsc_normalize;
+    }
+}
+
+String VGG::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".VGG");
+}
+
+#endif
+
+Ptr<VGG> VGG::create( int desc, float isigma, bool img_normalize, bool use_scale_orientation,
+                      float scale_factor, bool dsc_normalize )
+{
+#ifdef OPENCV_XFEATURES2D_HAS_VGG_DATA
+    return makePtr<VGG_Impl>( desc, isigma, img_normalize, use_scale_orientation, scale_factor, dsc_normalize );
+#else
+    CV_UNUSED(desc); CV_UNUSED(isigma); CV_UNUSED(img_normalize);
+    CV_UNUSED(use_scale_orientation); CV_UNUSED(scale_factor); CV_UNUSED(dsc_normalize);
+    CV_Error(Error::StsNotImplemented, "The OpenCV xfeatures2d binaries is built without downloaded VGG decriptor features: https://github.com/opencv/opencv_contrib/issues/1301");
+#endif
+}
+
+
+} // END NAMESPACE XFEATURES2D
+} // END NAMESPACE CV
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/xfeatures2d_init.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/xfeatures2d_init.cpp
new file mode 100644
index 00000000..317867a5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/src/xfeatures2d_init.cpp
@@ -0,0 +1,43 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_detectors.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_detectors.cpp
new file mode 100644
index 00000000..6f407b1d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_detectors.cpp
@@ -0,0 +1,304 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+class CV_DetectorsTest : public cvtest::BaseTest
+{
+public:
+    CV_DetectorsTest();
+    ~CV_DetectorsTest();
+protected:
+    void run(int);
+    bool testDetector(const Mat& img, Ptr<Feature2D> detector, vector<KeyPoint>& expected);
+
+    void LoadExpected(const string& file, vector<KeyPoint>& out);
+};
+
+CV_DetectorsTest::CV_DetectorsTest()
+{
+}
+CV_DetectorsTest::~CV_DetectorsTest() {}
+
+void getRotation(const Mat& img, Mat& aff, Mat& out)
+{
+    Point center(img.cols/2, img.rows/2);
+    aff = getRotationMatrix2D(center, 30, 1);
+    warpAffine( img, out, aff, img.size());
+}
+
+void getZoom(const Mat& img, Mat& aff, Mat& out)
+{
+    const double mult = 1.2;
+
+    aff.create(2, 3, CV_64F);
+    double *data = aff.ptr<double>();
+    data[0] = mult; data[1] =    0; data[2] = 0;
+    data[3] =    0; data[4] = mult; data[5] = 0;
+
+    warpAffine( img, out, aff, img.size());
+}
+
+void getBlur(const Mat& img, Mat& aff, Mat& out)
+{
+    aff.create(2, 3, CV_64F);
+    double *data = aff.ptr<double>();
+    data[0] = 1; data[1] = 0; data[2] = 0;
+    data[3] = 0; data[4] = 1; data[5] = 0;
+
+    GaussianBlur(img, out, Size(5, 5), 2);
+}
+
+void getBrightness(const Mat& img, Mat& aff, Mat& out)
+{
+    aff.create(2, 3, CV_64F);
+    double *data = aff.ptr<double>();
+    data[0] = 1; data[1] = 0; data[2] = 0;
+    data[3] = 0; data[4] = 1; data[5] = 0;
+
+    cv::add(img, Mat(img.size(), img.type(), Scalar(15)), out);
+}
+
+#if 0
+void showOrig(const Mat& img, const vector<KeyPoint>& orig_pts)
+{
+
+    Mat img_color;
+    cvtColor(img, img_color, COLOR_GRAY2BGR);
+
+    for(size_t i = 0; i < orig_pts.size(); ++i)
+        circle(img_color, orig_pts[i].pt, (int)orig_pts[i].size/2, Scalar(0, 255, 0));
+
+    namedWindow("O"); imshow("O", img_color);
+}
+
+void show(const string& name, const Mat& new_img, const vector<KeyPoint>& new_pts, const vector<KeyPoint>& transf_pts)
+{
+
+    Mat new_img_color;
+    cvtColor(new_img, new_img_color, COLOR_GRAY2BGR);
+
+    for(size_t i = 0; i < transf_pts.size(); ++i)
+        circle(new_img_color, transf_pts[i].pt, (int)transf_pts[i].size/2, Scalar(255, 0, 0));
+
+    for(size_t i = 0; i < new_pts.size(); ++i)
+        circle(new_img_color, new_pts[i].pt, (int)new_pts[i].size/2, Scalar(0, 0, 255));
+
+    namedWindow(name + "_T"); imshow(name + "_T", new_img_color);
+}
+#endif
+
+struct WrapPoint
+{
+    const double* R;
+    WrapPoint(const Mat& rmat) : R(rmat.ptr<double>()) { };
+
+    KeyPoint operator()(const KeyPoint& kp) const
+    {
+        KeyPoint res = kp;
+        res.pt.x = static_cast<float>(kp.pt.x * R[0] + kp.pt.y * R[1] + R[2]);
+        res.pt.y = static_cast<float>(kp.pt.x * R[3] + kp.pt.y * R[4] + R[5]);
+        return res;
+    }
+};
+
+struct sortByR { bool operator()(const KeyPoint& kp1, const KeyPoint& kp2) { return cv::norm(kp1.pt) < cv::norm(kp2.pt); } };
+
+bool CV_DetectorsTest::testDetector(const Mat& img, Ptr<Feature2D> detector, vector<KeyPoint>& exp)
+{
+    vector<KeyPoint> orig_kpts;
+    detector->detect(img, orig_kpts);
+
+    typedef void (*TransfFunc )(const Mat&, Mat&, Mat& FransfFunc);
+    const TransfFunc transfFunc[] = { getRotation, getZoom, getBlur, getBrightness };
+    //const string names[] =  { "Rotation", "Zoom", "Blur", "Brightness" };
+    const size_t case_num = sizeof(transfFunc)/sizeof(transfFunc[0]);
+
+    vector<Mat> affs(case_num);
+    vector<Mat> new_imgs(case_num);
+
+    vector< vector<KeyPoint> > new_kpts(case_num);
+    vector< vector<KeyPoint> > transf_kpts(case_num);
+
+    //showOrig(img, orig_kpts);
+    for(size_t i = 0; i < case_num; ++i)
+    {
+        transfFunc[i](img, affs[i], new_imgs[i]);
+        detector->detect(new_imgs[i], new_kpts[i]);
+        transform(orig_kpts.begin(), orig_kpts.end(), back_inserter(transf_kpts[i]), WrapPoint(affs[i]));
+        //show(names[i], new_imgs[i], new_kpts[i], transf_kpts[i]);
+    }
+
+    const float thres = 3;
+    const float nthres = 3;
+
+    vector<KeyPoint> result;
+    for(size_t i = 0; i < orig_kpts.size(); ++i)
+    {
+        const KeyPoint& okp = orig_kpts[i];
+        int foundCounter = 0;
+        for(size_t j = 0; j < case_num; ++j)
+        {
+            const KeyPoint& tkp = transf_kpts[j][i];
+
+            size_t k = 0;
+
+            for(; k < new_kpts[j].size(); ++k)
+                if (cv::norm(new_kpts[j][k].pt - tkp.pt) < nthres && fabs(new_kpts[j][k].size - tkp.size) < thres)
+                    break;
+
+            if (k != new_kpts[j].size())
+                ++foundCounter;
+
+        }
+        if (foundCounter == (int)case_num)
+            result.push_back(okp);
+    }
+
+    sort(result.begin(), result.end(), sortByR());
+    sort(exp.begin(), exp.end(), sortByR());
+
+    if (result.size() != exp.size())
+    {
+      ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+      return false;
+    }
+
+    int foundCounter1 = 0;
+    for(size_t i = 0; i < exp.size(); ++i)
+    {
+        const KeyPoint& e = exp[i];
+        size_t j = 0;
+        for(; j < result.size(); ++j)
+        {
+            const KeyPoint& r = result[i];
+            if (cv::norm(r.pt-e.pt) < nthres && fabs(r.size - e.size) < thres)
+                break;
+        }
+        if (j != result.size())
+            ++foundCounter1;
+    }
+
+    int foundCounter2 = 0;
+    for(size_t i = 0; i < result.size(); ++i)
+    {
+        const KeyPoint& r = result[i];
+        size_t j = 0;
+        for(; j < exp.size(); ++j)
+        {
+            const KeyPoint& e = exp[i];
+            if (cv::norm(r.pt-e.pt) < nthres && fabs(r.size - e.size) < thres)
+                break;
+        }
+        if (j != exp.size())
+            ++foundCounter2;
+    }
+    //showOrig(img, result); waitKey();
+
+    const float errorRate = 0.9f;
+    if (float(foundCounter1)/exp.size() < errorRate || float(foundCounter2)/result.size() < errorRate)
+    {
+        ts->set_failed_test_info( cvtest::TS::FAIL_MISMATCH);
+        return false;
+    }
+    return true;
+}
+
+void CV_DetectorsTest::LoadExpected(const string& file, vector<KeyPoint>& out)
+{
+    Mat mat_exp;
+    FileStorage fs(file, FileStorage::READ);
+    if (fs.isOpened())
+    {
+        read( fs["ResultVectorData"], mat_exp, Mat() );
+        out.resize(mat_exp.cols / sizeof(KeyPoint));
+        copy(mat_exp.ptr<KeyPoint>(), mat_exp.ptr<KeyPoint>() + out.size(), out.begin());
+    }
+    else
+    {
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA);
+        out.clear();
+    }
+}
+
+void CV_DetectorsTest::run( int /*start_from*/ )
+{
+    Mat img = imread(string(ts->get_data_path()) + "shared/graffiti.png", 0);
+
+    if (img.empty())
+    {
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA );
+        return;
+    }
+
+    Mat to_test(img.size() * 2, img.type(), Scalar(0));
+    Mat roi = to_test(Rect(img.rows/2, img.cols/2, img.cols, img.rows));
+    img.copyTo(roi);
+    GaussianBlur(to_test, to_test, Size(3, 3), 1.5);
+
+    vector<KeyPoint> exp;
+
+#ifdef OPENCV_ENABLE_NONFREE
+    LoadExpected(string(ts->get_data_path()) + "detectors/surf.xml", exp);
+    if (exp.empty())
+        return;
+
+    if (!testDetector(to_test, SURF::create(1536+512+512, 2, 2, true, false), exp))
+        return;
+#endif
+
+    LoadExpected(string(ts->get_data_path()) + "detectors/star.xml", exp);
+    if (exp.empty())
+        return;
+
+    if (!testDetector(to_test, StarDetector::create(45, 30, 10, 8, 5), exp))
+        return;
+
+    ts->set_failed_test_info( cvtest::TS::OK);
+}
+
+
+TEST(Features2d_Detectors, regression) { CV_DetectorsTest test; test.safe_run(); }
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_features2d.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_features2d.cpp
new file mode 100644
index 00000000..193ce5e4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_features2d.cpp
@@ -0,0 +1,470 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+const string FEATURES2D_DIR = "features2d";
+const string DETECTOR_DIR = FEATURES2D_DIR + "/feature_detectors";
+const string DESCRIPTOR_DIR = FEATURES2D_DIR + "/descriptor_extractors";
+const string IMAGE_FILENAME = "tsukuba.png";
+}} // namespace
+
+#include "features2d/test/test_detectors_regression.impl.hpp"
+#include "features2d/test/test_descriptors_regression.impl.hpp"
+
+namespace opencv_test { namespace {
+
+#ifdef OPENCV_ENABLE_NONFREE
+TEST( Features2d_Detector_SURF, regression )
+{
+    CV_FeatureDetectorTest test( "detector-surf", SURF::create() );
+    test.safe_run();
+}
+#endif
+
+TEST( Features2d_Detector_STAR, regression )
+{
+    CV_FeatureDetectorTest test( "detector-star", StarDetector::create() );
+    test.safe_run();
+}
+
+TEST( Features2d_Detector_Harris_Laplace, regression )
+{
+    CV_FeatureDetectorTest test( "detector-harris-laplace", HarrisLaplaceFeatureDetector::create() );
+    test.safe_run();
+}
+
+TEST( Features2d_Detector_Harris_Laplace_Affine_Keypoint_Invariance, regression )
+{
+    CV_FeatureDetectorTest test( "detector-harris-laplace", AffineFeature2D::create(HarrisLaplaceFeatureDetector::create()));
+    test.safe_run();
+}
+
+TEST( Features2d_Detector_Harris_Laplace_Affine, regression )
+{
+    CV_FeatureDetectorTest test( "detector-harris-laplace-affine", AffineFeature2D::create(HarrisLaplaceFeatureDetector::create()));
+    test.safe_run();
+}
+
+TEST(Features2d_Detector_TBMR_Affine, regression)
+{
+    CV_FeatureDetectorTest test("detector-tbmr-affine", TBMR::create());
+    test.safe_run();
+}
+
+/*
+ * Descriptors
+ */
+
+#ifdef OPENCV_ENABLE_NONFREE
+TEST( Features2d_DescriptorExtractor_SURF, regression )
+{
+#ifdef HAVE_OPENCL
+    bool useOCL = cv::ocl::useOpenCL();
+    cv::ocl::setUseOpenCL(false);
+#endif
+
+    CV_DescriptorExtractorTest<L2<float> > test( "descriptor-surf",  0.05f,
+                                                SURF::create() );
+    test.safe_run();
+
+#ifdef HAVE_OPENCL
+    cv::ocl::setUseOpenCL(useOCL);
+#endif
+}
+
+#ifdef HAVE_OPENCL
+TEST( Features2d_DescriptorExtractor_SURF_OCL, regression )
+{
+    bool useOCL = cv::ocl::useOpenCL();
+    cv::ocl::setUseOpenCL(true);
+    if(cv::ocl::useOpenCL())
+    {
+        CV_DescriptorExtractorTest<L2<float> > test( "descriptor-surf_ocl",  0.05f,
+                                                    SURF::create() );
+        test.safe_run();
+    }
+    cv::ocl::setUseOpenCL(useOCL);
+}
+#endif
+#endif // NONFREE
+
+TEST( Features2d_DescriptorExtractor_DAISY, regression )
+{
+    CV_DescriptorExtractorTest<L2<float> > test( "descriptor-daisy",  0.05f,
+                                                DAISY::create() );
+    test.safe_run();
+}
+
+TEST( Features2d_DescriptorExtractor_FREAK, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test("descriptor-freak", (CV_DescriptorExtractorTest<Hamming>::DistanceType)12.f,
+                                             FREAK::create());
+    test.safe_run();
+}
+
+TEST( Features2d_DescriptorExtractor_BRIEF, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test( "descriptor-brief",  1,
+                                             BriefDescriptorExtractor::create() );
+    test.safe_run();
+}
+
+template <int threshold = 0>
+struct LUCIDEqualityDistance
+{
+    typedef unsigned char ValueType;
+    typedef int ResultType;
+
+    ResultType operator()( const unsigned char* a, const unsigned char* b, int size ) const
+    {
+        int res = 0;
+        for (int i = 0; i < size; i++)
+        {
+            if (threshold == 0)
+                res += (a[i] != b[i]) ? 1 : 0;
+            else
+                res += abs(a[i] - b[i]) > threshold ? 1 : 0;
+        }
+        return res;
+    }
+};
+
+TEST( Features2d_DescriptorExtractor_LUCID, regression )
+{
+    CV_DescriptorExtractorTest< LUCIDEqualityDistance<1/*used blur is not bit-exact*/> > test(
+            "descriptor-lucid", 2,
+            LUCID::create(1, 2)
+    );
+    test.safe_run();
+}
+
+TEST( Features2d_DescriptorExtractor_LATCH, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test( "descriptor-latch",  1,
+                                             LATCH::create(32, true, 3, 0) );
+    test.safe_run();
+}
+
+TEST(Features2d_DescriptorExtractor_BEBLID, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test("descriptor-beblid", 1,
+                                             BEBLID::create(6.75));
+    test.safe_run();
+}
+
+TEST(Features2d_DescriptorExtractor_TEBLID, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test("descriptor-teblid", 1,
+                                             TEBLID::create(6.75));
+    test.safe_run();
+}
+
+#ifdef OPENCV_XFEATURES2D_HAS_VGG_DATA
+TEST( Features2d_DescriptorExtractor_VGG, regression )
+{
+    CV_DescriptorExtractorTest<L2<float> > test( "descriptor-vgg",  0.03f,
+                                             VGG::create() );
+    test.safe_run();
+}
+#endif // OPENCV_XFEATURES2D_HAS_VGG_DATA
+
+#ifdef OPENCV_XFEATURES2D_HAS_BOOST_DATA
+TEST( Features2d_DescriptorExtractor_BGM, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test( "descriptor-boostdesc-bgm",
+                                            (CV_DescriptorExtractorTest<Hamming>::DistanceType)12.f,
+                                            BoostDesc::create(BoostDesc::BGM) );
+    test.safe_run();
+}
+
+TEST( Features2d_DescriptorExtractor_BGM_HARD, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test( "descriptor-boostdesc-bgm_hard",
+                                            (CV_DescriptorExtractorTest<Hamming>::DistanceType)12.f,
+                                            BoostDesc::create(BoostDesc::BGM_HARD) );
+    test.safe_run();
+}
+
+TEST( Features2d_DescriptorExtractor_BGM_BILINEAR, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test( "descriptor-boostdesc-bgm_bilinear",
+                                            (CV_DescriptorExtractorTest<Hamming>::DistanceType)15.f,
+                                            BoostDesc::create(BoostDesc::BGM_BILINEAR) );
+    test.safe_run();
+}
+
+TEST( Features2d_DescriptorExtractor_LBGM, regression )
+{
+    CV_DescriptorExtractorTest<L2<float> > test( "descriptor-boostdesc-lbgm",
+                                           1.0f,
+                                           BoostDesc::create(BoostDesc::LBGM) );
+    test.safe_run();
+}
+
+TEST( Features2d_DescriptorExtractor_BINBOOST_64, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test( "descriptor-boostdesc-binboost_64",
+                                            (CV_DescriptorExtractorTest<Hamming>::DistanceType)12.f,
+                                            BoostDesc::create(BoostDesc::BINBOOST_64) );
+    test.safe_run();
+}
+
+TEST( Features2d_DescriptorExtractor_BINBOOST_128, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test( "descriptor-boostdesc-binboost_128",
+                                            (CV_DescriptorExtractorTest<Hamming>::DistanceType)12.f,
+                                            BoostDesc::create(BoostDesc::BINBOOST_128) );
+    test.safe_run();
+}
+
+TEST( Features2d_DescriptorExtractor_BINBOOST_256, regression )
+{
+    CV_DescriptorExtractorTest<Hamming> test( "descriptor-boostdesc-binboost_256",
+                                            (CV_DescriptorExtractorTest<Hamming>::DistanceType)12.f,
+                                            BoostDesc::create(BoostDesc::BINBOOST_256) );
+    test.safe_run();
+}
+#endif  // OPENCV_XFEATURES2D_HAS_BOOST_DATA
+
+#ifdef OPENCV_ENABLE_NONFREE
+TEST(Features2d_BruteForceDescriptorMatcher_knnMatch, regression)
+{
+    const int sz = 100;
+    const int k = 3;
+
+    Ptr<DescriptorExtractor> ext = SURF::create();
+    ASSERT_TRUE(ext);
+
+    Ptr<FeatureDetector> det = SURF::create();
+    //"%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n"
+    ASSERT_TRUE(det);
+
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce");
+    ASSERT_TRUE(matcher);
+
+    Mat imgT(256, 256, CV_8U, Scalar(255));
+    line(imgT, Point(20, sz/2), Point(sz-21, sz/2), Scalar(100), 2);
+    line(imgT, Point(sz/2, 20), Point(sz/2, sz-21), Scalar(100), 2);
+    vector<KeyPoint> kpT;
+    kpT.push_back( KeyPoint(50, 50, 16, 0, 20000, 1, -1) );
+    kpT.push_back( KeyPoint(42, 42, 16, 160, 10000, 1, -1) );
+    Mat descT;
+    ext->compute(imgT, kpT, descT);
+
+    Mat imgQ(256, 256, CV_8U, Scalar(255));
+    line(imgQ, Point(30, sz/2), Point(sz-31, sz/2), Scalar(100), 3);
+    line(imgQ, Point(sz/2, 30), Point(sz/2, sz-31), Scalar(100), 3);
+    vector<KeyPoint> kpQ;
+    det->detect(imgQ, kpQ);
+    Mat descQ;
+    ext->compute(imgQ, kpQ, descQ);
+
+    vector<vector<DMatch> > matches;
+
+    matcher->knnMatch(descQ, descT, matches, k);
+
+    //cout << "\nBest " << k << " matches to " << descT.rows << " train desc-s." << endl;
+    ASSERT_EQ(descQ.rows, static_cast<int>(matches.size()));
+    for(size_t i = 0; i<matches.size(); i++)
+    {
+        //cout << "\nmatches[" << i << "].size()==" << matches[i].size() << endl;
+        ASSERT_GE(min(k, descT.rows), static_cast<int>(matches[i].size()));
+        for(size_t j = 0; j<matches[i].size(); j++)
+        {
+            //cout << "\t" << matches[i][j].queryIdx << " -> " << matches[i][j].trainIdx << endl;
+            ASSERT_EQ(matches[i][j].queryIdx, static_cast<int>(i));
+        }
+    }
+}
+#endif
+
+class CV_DetectPlanarTest : public cvtest::BaseTest
+{
+public:
+    CV_DetectPlanarTest(const string& _fname, int _min_ninliers, const Ptr<Feature2D>& _f2d)
+    : fname(_fname), min_ninliers(_min_ninliers), f2d(_f2d) {}
+
+protected:
+    void run(int)
+    {
+        if(f2d.empty())
+            return;
+        string path = string(ts->get_data_path()) + "detectors_descriptors_evaluation/planar/";
+        string imgname1 = path + "box.png";
+        string imgname2 = path + "box_in_scene.png";
+        Mat img1 = imread(imgname1, 0);
+        Mat img2 = imread(imgname2, 0);
+        if( img1.empty() || img2.empty() )
+        {
+            ts->printf( cvtest::TS::LOG, "missing %s and/or %s\n", imgname1.c_str(), imgname2.c_str());
+            ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA );
+            return;
+        }
+        vector<KeyPoint> kpt1, kpt2;
+        Mat d1, d2;
+#ifdef HAVE_OPENCL
+        if (cv::ocl::useOpenCL())
+        {
+            cv::UMat uimg1;
+            img1.copyTo(uimg1);
+            f2d->detectAndCompute(uimg1, Mat(), kpt1, d1);
+            f2d->detectAndCompute(uimg1, Mat(), kpt2, d2);
+        }
+        else
+#endif
+        {
+            f2d->detectAndCompute(img1, Mat(), kpt1, d1);
+            f2d->detectAndCompute(img1, Mat(), kpt2, d2);
+        }
+        for( size_t i = 0; i < kpt1.size(); i++ )
+            CV_Assert(kpt1[i].response > 0 );
+        for( size_t i = 0; i < kpt2.size(); i++ )
+            CV_Assert(kpt2[i].response > 0 );
+
+        vector<DMatch> matches;
+        BFMatcher(f2d->defaultNorm(), true).match(d1, d2, matches);
+
+        vector<Point2f> pt1, pt2;
+        for( size_t i = 0; i < matches.size(); i++ ) {
+            pt1.push_back(kpt1[matches[i].queryIdx].pt);
+            pt2.push_back(kpt2[matches[i].trainIdx].pt);
+        }
+
+        Mat inliers, H = findHomography(pt1, pt2, RANSAC, 10, inliers);
+        int ninliers = countNonZero(inliers);
+
+        if( ninliers < min_ninliers )
+        {
+            ts->printf( cvtest::TS::LOG, "too little inliers (%d) vs expected %d\n", ninliers, min_ninliers);
+            ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA );
+            return;
+        }
+    }
+
+    string fname;
+    int min_ninliers;
+    Ptr<Feature2D> f2d;
+};
+
+TEST(Features2d_SIFTHomographyTest, regression) { CV_DetectPlanarTest test("SIFT", 80, SIFT::create()); test.safe_run(); }
+
+#ifdef OPENCV_ENABLE_NONFREE
+TEST(Features2d_SURFHomographyTest, regression) { CV_DetectPlanarTest test("SURF", 80, SURF::create()); test.safe_run(); }
+#endif
+
+class FeatureDetectorUsingMaskTest : public cvtest::BaseTest
+{
+public:
+    FeatureDetectorUsingMaskTest(const Ptr<FeatureDetector>& featureDetector) :
+        featureDetector_(featureDetector)
+    {
+        CV_Assert(featureDetector_);
+    }
+
+protected:
+
+    void run(int)
+    {
+        const int nStepX = 2;
+        const int nStepY = 2;
+
+        const string imageFilename = string(ts->get_data_path()) + "/features2d/tsukuba.png";
+
+        Mat image = imread(imageFilename);
+        if(image.empty())
+        {
+            ts->printf(cvtest::TS::LOG, "Image %s can not be read.\n", imageFilename.c_str());
+            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+            return;
+        }
+
+        Mat mask(image.size(), CV_8U);
+
+        const int stepX = image.size().width / nStepX;
+        const int stepY = image.size().height / nStepY;
+
+        vector<KeyPoint> keyPoints;
+        vector<Point2f> points;
+        for(int i=0; i<nStepX; ++i)
+            for(int j=0; j<nStepY; ++j)
+            {
+
+                mask.setTo(0);
+                Rect whiteArea(i * stepX, j * stepY, stepX, stepY);
+                mask(whiteArea).setTo(255);
+
+                featureDetector_->detect(image, keyPoints, mask);
+                KeyPoint::convert(keyPoints, points);
+
+                for(size_t k=0; k<points.size(); ++k)
+                {
+                    if ( !whiteArea.contains(points[k]) )
+                    {
+                        ts->printf(cvtest::TS::LOG, "The feature point is outside of the mask.");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+                        return;
+                    }
+                }
+            }
+
+        ts->set_failed_test_info( cvtest::TS::OK );
+    }
+
+    Ptr<FeatureDetector> featureDetector_;
+};
+
+TEST(Features2d_SIFT_using_mask, regression)
+{
+    FeatureDetectorUsingMaskTest test(SIFT::create());
+    test.safe_run();
+}
+
+#ifdef OPENCV_ENABLE_NONFREE
+TEST(DISABLED_Features2d_SURF_using_mask, regression)
+{
+    FeatureDetectorUsingMaskTest test(SURF::create());
+    test.safe_run();
+}
+#endif // NONFREE
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_gms_matcher.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_gms_matcher.cpp
new file mode 100644
index 00000000..9b65083d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_gms_matcher.cpp
@@ -0,0 +1,116 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+class CV_GMSMatcherTest : public cvtest::BaseTest
+{
+public:
+    CV_GMSMatcherTest();
+    ~CV_GMSMatcherTest();
+
+protected:
+    virtual void run(int);
+
+    bool combinations[4][2];
+    double eps[3][4]; //3 imgs x 4 combinations
+    double correctMatchDistThreshold;
+};
+
+CV_GMSMatcherTest::CV_GMSMatcherTest()
+{
+    combinations[0][0] = false; combinations[0][1] = false;
+    combinations[1][0] = false; combinations[1][1] = true;
+    combinations[2][0] = true; combinations[2][1] = false;
+    combinations[3][0] = true; combinations[3][1] = true;
+
+    eps[0][0] = 0.91;
+    eps[0][1] = 0.91;
+    eps[0][2] = 0.91;
+    eps[0][3] = 0.91;
+
+    eps[1][0] = 0.80;
+    eps[1][1] = 0.78;
+    eps[1][2] = 0.80;
+    eps[1][3] = 0.78;
+
+    eps[2][0] = 0.6;
+    eps[2][1] = 0.6;
+    eps[2][2] = 0.6;
+    eps[2][3] = 0.6;
+
+    correctMatchDistThreshold = 5.0;
+}
+
+CV_GMSMatcherTest::~CV_GMSMatcherTest() {}
+
+void CV_GMSMatcherTest::run( int )
+{
+    ts->set_failed_test_info(cvtest::TS::OK);
+
+    Mat imgRef = imread(string(ts->get_data_path()) + "detectors_descriptors_evaluation/images_datasets/graf/img1.png");
+
+    Ptr<Feature2D> orb = ORB::create(10000);
+    vector<KeyPoint> keypointsRef, keypointsCur;
+    Mat descriptorsRef, descriptorsCur;
+    orb->detectAndCompute(imgRef, noArray(), keypointsRef, descriptorsRef);
+
+    vector<DMatch> matchesAll, matchesGMS;
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-Hamming");
+
+    const int startImg = 2;
+    const int nImgs = 3;
+    for (int num = startImg; num < startImg+nImgs; num++)
+    {
+        string fileName = cv::format("img%d.png", num);
+        string imgPath = string(ts->get_data_path()) + "detectors_descriptors_evaluation/images_datasets/graf/" + fileName;
+        Mat imgCur = imread(imgPath);
+        orb->detectAndCompute(imgCur, noArray(), keypointsCur, descriptorsCur);
+
+        matcher->match(descriptorsCur, descriptorsRef, matchesAll);
+
+        string xml = string(ts->get_data_path()) + format("detectors_descriptors_evaluation/images_datasets/graf/H1to%dp.xml", num);
+        FileStorage fs(xml, FileStorage::READ);
+        if (!fs.isOpened())
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+            return;
+        }
+
+        Mat H1toCur;
+        fs[format("H1%d", num)] >> H1toCur;
+
+        for (int comb = 0; comb < 4; comb++)
+        {
+            matchGMS(imgCur.size(), imgRef.size(), keypointsCur, keypointsRef, matchesAll, matchesGMS, combinations[comb][0], combinations[comb][1]);
+
+            int nbCorrectMatches = 0;
+            for (size_t i = 0; i < matchesGMS.size(); i++)
+            {
+                Point2f ptRef = keypointsRef[matchesGMS[i].trainIdx].pt;
+                Point2f ptCur = keypointsCur[matchesGMS[i].queryIdx].pt;
+                Mat matRef = (Mat_<double>(3,1) << ptRef.x, ptRef.y, 1);
+                Mat matTrans = H1toCur * matRef;
+                Point2f ptTrans( (float) (matTrans.at<double>(0,0)/matTrans.at<double>(2,0)),
+                                 (float) (matTrans.at<double>(1,0)/matTrans.at<double>(2,0)));
+
+                if (cv::norm(ptTrans-ptCur) < correctMatchDistThreshold)
+                    nbCorrectMatches++;
+            }
+
+            double ratio = nbCorrectMatches / (double) matchesGMS.size();
+            EXPECT_GT(ratio, eps[num-startImg][comb]) <<
+                cv::format("Invalid accuracy for image %s and combination withRotation=%d withScale=%d, "
+                           "matches ratio is %g, ratio threshold is %g, distance threshold is %g.",
+                            fileName.c_str(), combinations[comb][0], combinations[comb][1], ratio,
+                            eps[num-startImg][comb], correctMatchDistThreshold);
+        }
+    }
+}
+
+TEST(XFeatures2d_GMSMatcher, gms_matcher_regression) { CV_GMSMatcherTest test; test.safe_run(); }
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_keypoints.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_keypoints.cpp
new file mode 100644
index 00000000..28d125d0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_keypoints.cpp
@@ -0,0 +1,146 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+const string FEATURES2D_DIR = "features2d";
+const string IMAGE_FILENAME = "tsukuba.png";
+
+/****************************************************************************************\
+*                                     Test for KeyPoint                                  *
+\****************************************************************************************/
+
+class CV_FeatureDetectorKeypointsTest : public cvtest::BaseTest
+{
+public:
+    explicit CV_FeatureDetectorKeypointsTest(const Ptr<Feature2D>& _detector) :
+        detector(_detector) {}
+
+protected:
+    virtual void run(int)
+    {
+        CV_Assert(detector);
+        string imgFilename = string(ts->get_data_path()) + FEATURES2D_DIR + "/" + IMAGE_FILENAME;
+
+        // Read the test image.
+        Mat image = imread(imgFilename);
+        if(image.empty())
+        {
+            ts->printf(cvtest::TS::LOG, "Image %s can not be read.\n", imgFilename.c_str());
+            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+            return;
+        }
+
+        vector<KeyPoint> keypoints;
+        detector->detect(image, keypoints);
+
+        if(keypoints.empty())
+        {
+            ts->printf(cvtest::TS::LOG, "Detector can't find keypoints in image.\n");
+            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+            return;
+        }
+
+        Rect r(0, 0, image.cols, image.rows);
+        for(size_t i = 0; i < keypoints.size(); i++)
+        {
+            const KeyPoint& kp = keypoints[i];
+
+            if(!r.contains(kp.pt))
+            {
+                ts->printf(cvtest::TS::LOG, "KeyPoint::pt is out of image (x=%f, y=%f).\n", kp.pt.x, kp.pt.y);
+                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+                return;
+            }
+
+            if(kp.size <= 0.f)
+            {
+                ts->printf(cvtest::TS::LOG, "KeyPoint::size is not positive (%f).\n", kp.size);
+                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+                return;
+            }
+
+            if((kp.angle < 0.f && kp.angle != -1.f) || kp.angle >= 360.f)
+            {
+                ts->printf(cvtest::TS::LOG, "KeyPoint::angle is out of range [0, 360). It's %f.\n", kp.angle);
+                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+                return;
+            }
+        }
+        ts->set_failed_test_info(cvtest::TS::OK);
+    }
+
+    Ptr<Feature2D> detector;
+};
+
+
+// Registration of tests
+#ifdef OPENCV_ENABLE_NONFREE
+TEST(Features2d_Detector_Keypoints_SURF, validation)
+{
+    CV_FeatureDetectorKeypointsTest test(xfeatures2d::SURF::create());
+    test.safe_run();
+}
+#endif // NONFREE
+
+
+TEST(Features2d_Detector_Keypoints_Star, validation)
+{
+    CV_FeatureDetectorKeypointsTest test(xfeatures2d::StarDetector::create());
+    test.safe_run();
+}
+
+
+TEST(Features2d_Detector_Keypoints_MSDDetector, validation)
+{
+    CV_FeatureDetectorKeypointsTest test(xfeatures2d::MSDDetector::create());
+    test.safe_run();
+}
+
+TEST(Features2d_Detector_Keypoints_TBMRDetector, validation)
+{
+    CV_FeatureDetectorKeypointsTest test(xfeatures2d::TBMR::create());
+    test.safe_run();
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_logos_matcher.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_logos_matcher.cpp
new file mode 100644
index 00000000..5a8f7d57
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_logos_matcher.cpp
@@ -0,0 +1,152 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static void loadKeypoints(const std::string& vP_path,
+                          const std::string& oP_path,
+                          const std::string& sP_path,
+                          const std::string& w_path,
+                          std::vector<cv::KeyPoint>& keypoints,
+                          std::vector<int>& nn)
+{
+    {
+        std::ifstream file(vP_path.c_str());
+        if (file.is_open())
+        {
+            float x = 0, y = 0;
+            while (file >> x >> y)
+            {
+                keypoints.push_back(cv::KeyPoint(x, y, 0));
+            }
+        }
+    }
+    {
+        std::ifstream file(oP_path.c_str());
+        if (file.is_open())
+        {
+            float orientation = 0;
+            size_t idx = 0;
+            while (file >> orientation)
+            {
+                keypoints[idx].angle = static_cast<float>(orientation * 180.0 / CV_PI);
+                idx++;
+            }
+        }
+    }
+    {
+        std::ifstream file(sP_path.c_str());
+        if (file.is_open())
+        {
+            float scale = 0;
+            size_t idx = 0;
+            while (file >> scale)
+            {
+                keypoints[idx].size = scale;
+                idx++;
+            }
+        }
+    }
+    {
+        std::ifstream file(w_path.c_str());
+        if (file.is_open())
+        {
+            int neighborIdx = 0;
+            while (file >> neighborIdx)
+            {
+                nn.push_back(neighborIdx);
+            }
+        }
+    }
+
+    ASSERT_TRUE(!keypoints.empty());
+}
+
+static void loadGroundTruth(const std::string& d1_path,
+                            const std::string& b1_path,
+                            std::vector<cv::DMatch>& groundTruth)
+{
+    std::vector<int> d1_vec;
+    {
+        std::ifstream file(d1_path.c_str());
+        if (file.is_open())
+        {
+            int idx = 0;
+            while (file >> idx)
+            {
+                d1_vec.push_back(idx-1);
+            }
+        }
+    }
+
+    std::vector<int> b1_vec;
+    {
+        std::ifstream file(b1_path.c_str());
+        if (file.is_open())
+        {
+            int idx = 0;
+            while (file >> idx)
+            {
+                b1_vec.push_back(idx-1);
+            }
+        }
+    }
+
+    ASSERT_TRUE(!d1_vec.empty());
+    ASSERT_EQ(d1_vec.size(), b1_vec.size());
+
+    for (size_t i = 0; i < d1_vec.size(); i++)
+    {
+        groundTruth.push_back(cv::DMatch(d1_vec[i], b1_vec[i], 0));
+    }
+}
+
+TEST(XFeatures2d_LogosMatcher, logos_matcher_regression)
+{
+    const std::string vP1_path = cvtest::findDataFile("detectors_descriptors_evaluation/matching/LOGOS/vP1.txt");
+    const std::string oP1_path = cvtest::findDataFile("detectors_descriptors_evaluation/matching/LOGOS/oP1.txt");
+    const std::string sP1_path = cvtest::findDataFile("detectors_descriptors_evaluation/matching/LOGOS/sP1.txt");
+    const std::string w1_path = cvtest::findDataFile("detectors_descriptors_evaluation/matching/LOGOS/w1.txt");
+
+    const std::string vP2_path = cvtest::findDataFile("detectors_descriptors_evaluation/matching/LOGOS/vP2.txt");
+    const std::string oP2_path = cvtest::findDataFile("detectors_descriptors_evaluation/matching/LOGOS/oP2.txt");
+    const std::string sP2_path = cvtest::findDataFile("detectors_descriptors_evaluation/matching/LOGOS/sP2.txt");
+    const std::string w2_path = cvtest::findDataFile("detectors_descriptors_evaluation/matching/LOGOS/w2.txt");
+
+    std::vector<cv::KeyPoint> keypoints1, keypoints2;
+    std::vector<int> nn1, nn2;
+    loadKeypoints(vP1_path, oP1_path, sP1_path, w1_path, keypoints1, nn1);
+    loadKeypoints(vP2_path, oP2_path, sP2_path, w2_path, keypoints2, nn2);
+
+    std::vector<cv::DMatch> matchesLogos;
+    matchLOGOS(keypoints1, keypoints2, nn1, nn2, matchesLogos);
+
+    std::vector<cv::DMatch> groundTruth;
+    const std::string d1_path = cvtest::findDataFile("detectors_descriptors_evaluation/matching/LOGOS/d1.txt");
+    const std::string b1_path = cvtest::findDataFile("detectors_descriptors_evaluation/matching/LOGOS/b1.txt");
+    loadGroundTruth(d1_path, b1_path, groundTruth);
+
+    int correctMatches = 0;
+    for (size_t i = 0; i < matchesLogos.size(); i++)
+    {
+        for (size_t j = 0; j < groundTruth.size(); j++)
+        {
+            if (groundTruth[j].queryIdx == matchesLogos[i].queryIdx &&
+                groundTruth[j].trainIdx == matchesLogos[j].trainIdx)
+            {
+                correctMatches++;
+                break;
+            }
+        }
+    }
+
+    ASSERT_EQ(static_cast<int>(groundTruth.size()), correctMatches)
+            << "groundTruth: " << groundTruth.size()
+            << " ; matchesLogos: " << matchesLogos.size()
+            << " ; correctMatches: " << correctMatches;
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_main.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_main.cpp
new file mode 100644
index 00000000..0e51ddfd
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_main.cpp
@@ -0,0 +1,6 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("cv")
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_precomp.hpp
new file mode 100644
index 00000000..0f4ced60
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_precomp.hpp
@@ -0,0 +1,26 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/ts/cuda_test.hpp"
+#include "opencv2/xfeatures2d.hpp"
+#include "opencv2/calib3d.hpp"
+
+#include "cvconfig.h"
+
+#ifdef HAVE_OPENCL
+#  include "opencv2/core/ocl.hpp"
+#endif
+
+#ifdef HAVE_CUDA
+#  include "opencv2/xfeatures2d/cuda.hpp"
+#endif
+
+namespace opencv_test {
+using namespace cv::xfeatures2d;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_rotation_and_scale_invariance.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_rotation_and_scale_invariance.cpp
new file mode 100644
index 00000000..a3dd1a98
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_rotation_and_scale_invariance.cpp
@@ -0,0 +1,289 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "test_precomp.hpp"
+
+#include "features2d/test/test_detectors_invariance.impl.hpp" // main OpenCV repo
+#include "features2d/test/test_descriptors_invariance.impl.hpp" // main OpenCV repo
+
+namespace opencv_test { namespace {
+
+static const char* const IMAGE_TSUKUBA = "features2d/tsukuba.png";
+static const char* const IMAGE_BIKES = "detectors_descriptors_evaluation/images_datasets/bikes/img1.png";
+
+// ========================== ROTATION INVARIANCE =============================
+
+#ifdef OPENCV_ENABLE_NONFREE
+
+INSTANTIATE_TEST_CASE_P(SURF, DetectorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA, SURF::create(), 0.40f, 0.76f)
+));
+
+INSTANTIATE_TEST_CASE_P(SURF, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA, SURF::create(), SURF::create(), 0.83f)
+));
+
+#endif // NONFREE
+
+INSTANTIATE_TEST_CASE_P(LATCH, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA, SIFT::create(), LATCH::create(), 0.98f)
+));
+
+INSTANTIATE_TEST_CASE_P(BEBLID, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA, SIFT::create(), BEBLID::create(6.75), 0.98f)
+));
+
+INSTANTIATE_TEST_CASE_P(TEBLID, DescriptorRotationInvariance, Values(
+        make_tuple(IMAGE_TSUKUBA, SIFT::create(), TEBLID::create(6.75), 0.98f)
+));
+
+INSTANTIATE_TEST_CASE_P(DAISY, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               BRISK::create(),
+               DAISY::create(15, 3, 8, 8, DAISY::NRM_NONE, noArray(), true, true),
+               0.79f)
+));
+#ifdef OPENCV_XFEATURES2D_HAS_VGG_DATA
+INSTANTIATE_TEST_CASE_P(VGG120, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               KAZE::create(),
+               VGG::create(VGG::VGG_120, 1.4f, true, true, 48.0f, false),
+               0.97f)
+));
+INSTANTIATE_TEST_CASE_P(VGG80, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               KAZE::create(),
+               VGG::create(VGG::VGG_80, 1.4f, true, true, 48.0f, false),
+               0.97f)
+));
+INSTANTIATE_TEST_CASE_P(VGG64, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               KAZE::create(),
+               VGG::create(VGG::VGG_64, 1.4f, true, true, 48.0f, false),
+               0.97f)
+));
+INSTANTIATE_TEST_CASE_P(VGG48, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               KAZE::create(),
+               VGG::create(VGG::VGG_48, 1.4f, true, true, 48.0f, false),
+               0.97f)
+));
+#endif  // OPENCV_XFEATURES2D_HAS_VGG_DATA
+
+#ifdef OPENCV_ENABLE_NONFREE
+
+INSTANTIATE_TEST_CASE_P(BRIEF_64, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               BriefDescriptorExtractor::create(64,true),
+               0.98f)
+));
+
+INSTANTIATE_TEST_CASE_P(BRIEF_32, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               BriefDescriptorExtractor::create(32,true),
+               0.97f)
+));
+
+INSTANTIATE_TEST_CASE_P(BRIEF_16, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               BriefDescriptorExtractor::create(16, true),
+               0.98f)
+));
+
+INSTANTIATE_TEST_CASE_P(FREAK, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               FREAK::create(),
+               0.90f)
+));
+
+#ifdef OPENCV_XFEATURES2D_HAS_BOOST_DATA
+INSTANTIATE_TEST_CASE_P(BoostDesc_BGM, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BGM, true, 6.25f),
+               0.999f)
+));
+
+INSTANTIATE_TEST_CASE_P(BoostDesc_BGM_HARD, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BGM_HARD, true, 6.25f),
+               0.98f)
+));
+
+INSTANTIATE_TEST_CASE_P(BoostDesc_BGM_BILINEAR, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BGM_BILINEAR, true, 6.25f),
+               0.98f)
+));
+
+INSTANTIATE_TEST_CASE_P(BoostDesc_BGM_LBGM, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::LBGM, true, 6.25f),
+               0.999f)
+));
+
+INSTANTIATE_TEST_CASE_P(BoostDesc_BINBOOST_64, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BINBOOST_64, true, 6.25f),
+               0.98f)
+));
+
+INSTANTIATE_TEST_CASE_P(BoostDesc_BINBOOST_128, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BINBOOST_128, true, 6.25f),
+               0.98f)
+));
+
+INSTANTIATE_TEST_CASE_P(BoostDesc_BINBOOST_256, DescriptorRotationInvariance, Values(
+    make_tuple(IMAGE_TSUKUBA,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BINBOOST_256, true, 6.25f),
+               0.999f)
+));
+#endif  // OPENCV_XFEATURES2D_HAS_BOOST_DATA
+#endif
+
+
+
+// ============================ SCALE INVARIANCE ==============================
+
+#ifdef OPENCV_ENABLE_NONFREE
+INSTANTIATE_TEST_CASE_P(SURF, DetectorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES, SURF::create(), 0.64f, 0.84f)
+));
+
+INSTANTIATE_TEST_CASE_P(SURF, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES, SURF::create(), SURF::create(), 0.7f)
+));
+#endif // NONFREE
+
+
+#if 0  // DAISY is not scale invariant
+INSTANTIATE_TEST_CASE_P(DISABLED_DAISY, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               BRISK::create(),
+               DAISY::create(15, 3, 8, 8, DAISY::NRM_NONE, noArray(), true, true),
+               0.1f)
+));
+#endif
+
+#ifdef OPENCV_XFEATURES2D_HAS_VGG_DATA
+INSTANTIATE_TEST_CASE_P(VGG120, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               KAZE::create(),
+               VGG::create(VGG::VGG_120, 1.4f, true, true, 48.0f, false),
+               0.98f)
+));
+INSTANTIATE_TEST_CASE_P(VGG80, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               KAZE::create(),
+               VGG::create(VGG::VGG_80, 1.4f, true, true, 48.0f, false),
+               0.98f)
+));
+INSTANTIATE_TEST_CASE_P(VGG64, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               KAZE::create(),
+               VGG::create(VGG::VGG_64, 1.4f, true, true, 48.0f, false),
+               0.97f)
+));
+INSTANTIATE_TEST_CASE_P(VGG48, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               KAZE::create(),
+               VGG::create(VGG::VGG_48, 1.4f, true, true, 48.0f, false),
+               0.93f)
+));
+#endif  // OPENCV_XFEATURES2D_HAS_VGG_DATA
+
+#ifdef OPENCV_ENABLE_NONFREE  // SURF detector is used in tests
+#ifdef OPENCV_XFEATURES2D_HAS_BOOST_DATA
+INSTANTIATE_TEST_CASE_P(BoostDesc_BGM, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BGM, true, 6.25f),
+               0.98f)
+));
+INSTANTIATE_TEST_CASE_P(BoostDesc_BGM_HARD, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BGM_HARD, true, 6.25f),
+               0.75f)
+));
+INSTANTIATE_TEST_CASE_P(BoostDesc_BGM_BILINEAR, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BGM_BILINEAR, true, 6.25f),
+               0.95f)
+));
+INSTANTIATE_TEST_CASE_P(BoostDesc_LBGM, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::LBGM, true, 6.25f),
+               0.95f)
+));
+INSTANTIATE_TEST_CASE_P(BoostDesc_BINBOOST_64, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BINBOOST_64, true, 6.25f),
+               0.75f)
+));
+INSTANTIATE_TEST_CASE_P(BoostDesc_BINBOOST_128, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BINBOOST_128, true, 6.25f),
+               0.95f)
+));
+INSTANTIATE_TEST_CASE_P(BoostDesc_BINBOOST_256, DescriptorScaleInvariance, Values(
+    make_tuple(IMAGE_BIKES,
+               SURF::create(),
+               BoostDesc::create(BoostDesc::BINBOOST_256, true, 6.25f),
+               0.98f)
+));
+#endif  // OPENCV_XFEATURES2D_HAS_BOOST_DATA
+#endif // NONFREE
+
+
+
+// ============================== OTHER TESTS =================================
+
+#ifdef OPENCV_ENABLE_NONFREE
+TEST(Features2d_RotationInvariance2_Detector_SURF, regression)
+{
+    Mat cross(100, 100, CV_8UC1, Scalar(255));
+    line(cross, Point(30, 50), Point(69, 50), Scalar(100), 3);
+    line(cross, Point(50, 30), Point(50, 69), Scalar(100), 3);
+
+    Ptr<SURF> surf = SURF::create(8000., 3, 4, true, false);
+
+    vector<KeyPoint> keypoints;
+    surf->detect(cross, keypoints);
+
+    // Expect 5 keypoints.  One keypoint has coordinates (50.0, 50.0).
+    // The other 4 keypoints should have the same response.
+    // The order of the keypoints is indeterminate.
+    ASSERT_EQ(keypoints.size(), (vector<KeyPoint>::size_type) 5);
+
+    int i1 = -1;
+    for(int i = 0; i < 5; i++)
+    {
+        if(keypoints[i].pt.x == 50.0f)
+            ;
+        else if(i1 == -1)
+            i1 = i;
+        else
+            ASSERT_LT(fabs(keypoints[i1].response - keypoints[i].response) / keypoints[i1].response, 1e-6);
+    }
+}
+
+#endif // NONFREE
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_surf.cuda.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_surf.cuda.cpp
new file mode 100644
index 00000000..48ff0182
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_surf.cuda.cpp
@@ -0,0 +1,198 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#if defined(HAVE_CUDA) && defined(OPENCV_ENABLE_NONFREE)
+
+namespace opencv_test { namespace {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// SURF
+
+#ifdef HAVE_OPENCV_CUDAARITHM
+
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(SURF_HessianThreshold, double)
+    IMPLEMENT_PARAM_CLASS(SURF_Octaves, int)
+    IMPLEMENT_PARAM_CLASS(SURF_OctaveLayers, int)
+    IMPLEMENT_PARAM_CLASS(SURF_Extended, bool)
+    IMPLEMENT_PARAM_CLASS(SURF_Upright, bool)
+}
+
+PARAM_TEST_CASE(CUDA_SURF, SURF_HessianThreshold, SURF_Octaves, SURF_OctaveLayers, SURF_Extended, SURF_Upright)
+{
+    double hessianThreshold;
+    int nOctaves;
+    int nOctaveLayers;
+    bool extended;
+    bool upright;
+
+    virtual void SetUp()
+    {
+        hessianThreshold = GET_PARAM(0);
+        nOctaves = GET_PARAM(1);
+        nOctaveLayers = GET_PARAM(2);
+        extended = GET_PARAM(3);
+        upright = GET_PARAM(4);
+    }
+};
+
+CUDA_TEST_P(CUDA_SURF, Detector)
+{
+    cv::Mat image = readImage("../gpu/features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    cv::cuda::SURF_CUDA surf;
+    surf.hessianThreshold = hessianThreshold;
+    surf.nOctaves = nOctaves;
+    surf.nOctaveLayers = nOctaveLayers;
+    surf.extended = extended;
+    surf.upright = upright;
+    surf.keypointsRatio = 0.05f;
+
+    std::vector<cv::KeyPoint> keypoints;
+    surf(loadMat(image), cv::cuda::GpuMat(), keypoints);
+
+    cv::Ptr<cv::Feature2D> surf_gold = cv::xfeatures2d::SURF::create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
+
+    std::vector<cv::KeyPoint> keypoints_gold;
+    surf_gold->detect(image, keypoints_gold);
+
+    ASSERT_EQ(keypoints_gold.size(), keypoints.size());
+    int matchedCount = getMatchedPointsCount(keypoints_gold, keypoints);
+    double matchedRatio = static_cast<double>(matchedCount) / keypoints_gold.size();
+
+    EXPECT_GT(matchedRatio, 0.95);
+}
+
+CUDA_TEST_P(CUDA_SURF, Detector_Masked)
+{
+    cv::Mat image = readImage("../gpu/features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
+    mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
+
+    cv::cuda::SURF_CUDA surf;
+    surf.hessianThreshold = hessianThreshold;
+    surf.nOctaves = nOctaves;
+    surf.nOctaveLayers = nOctaveLayers;
+    surf.extended = extended;
+    surf.upright = upright;
+    surf.keypointsRatio = 0.05f;
+
+    std::vector<cv::KeyPoint> keypoints;
+    surf(loadMat(image), loadMat(mask), keypoints);
+
+    cv::Ptr<cv::Feature2D> surf_gold = cv::xfeatures2d::SURF::create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
+
+    std::vector<cv::KeyPoint> keypoints_gold;
+    surf_gold->detect(image, keypoints_gold, mask);
+
+    ASSERT_EQ(keypoints_gold.size(), keypoints.size());
+    int matchedCount = getMatchedPointsCount(keypoints_gold, keypoints);
+    double matchedRatio = static_cast<double>(matchedCount) / keypoints_gold.size();
+
+    EXPECT_GT(matchedRatio, 0.95);
+}
+
+CUDA_TEST_P(CUDA_SURF, Descriptor)
+{
+    cv::Mat image = readImage("../gpu/features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    cv::cuda::SURF_CUDA surf;
+    surf.hessianThreshold = hessianThreshold;
+    surf.nOctaves = nOctaves;
+    surf.nOctaveLayers = nOctaveLayers;
+    surf.extended = extended;
+    surf.upright = upright;
+    surf.keypointsRatio = 0.05f;
+
+    cv::Ptr<cv::Feature2D> surf_gold = cv::xfeatures2d::SURF::create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
+
+    std::vector<cv::KeyPoint> keypoints;
+    surf_gold->detect(image, keypoints);
+
+    cv::cuda::GpuMat descriptors;
+    surf(loadMat(image), cv::cuda::GpuMat(), keypoints, descriptors, true);
+
+    cv::Mat descriptors_gold;
+    surf_gold->compute(image, keypoints, descriptors_gold);
+
+    cv::BFMatcher matcher(surf.defaultNorm());
+    std::vector<cv::DMatch> matches;
+    matcher.match(descriptors_gold, cv::Mat(descriptors), matches);
+
+    int matchedCount = getMatchedPointsCount(keypoints, keypoints, matches);
+    double matchedRatio = static_cast<double>(matchedCount) / keypoints.size();
+
+    EXPECT_GT(matchedRatio, 0.6);
+}
+
+#if defined (__x86_64__) || defined (_M_X64)
+testing::internal::ValueArray3<SURF_HessianThreshold, SURF_HessianThreshold, SURF_HessianThreshold> thresholdValues =
+    testing::Values(
+            SURF_HessianThreshold(100.0),
+            SURF_HessianThreshold(500.0),
+            SURF_HessianThreshold(1000.0));
+#else
+// hessian computation is not bit-exact and lower threshold causes different count of detection
+testing::internal::ValueArray2<SURF_HessianThreshold, SURF_HessianThreshold> thresholdValues =
+    testing::Values(
+            SURF_HessianThreshold(830.0),
+            SURF_HessianThreshold(1000.0));
+#endif
+
+INSTANTIATE_TEST_CASE_P(CUDA_Features2D, CUDA_SURF, testing::Combine(
+    thresholdValues,
+    testing::Values(SURF_Octaves(3), SURF_Octaves(4)),
+    testing::Values(SURF_OctaveLayers(2), SURF_OctaveLayers(3)),
+    testing::Values(SURF_Extended(false), SURF_Extended(true)),
+    testing::Values(SURF_Upright(false), SURF_Upright(true))));
+
+#endif // HAVE_OPENCV_CUDAARITHM
+
+}} // namespace
+#endif // HAVE_CUDA && OPENCV_ENABLE_NONFREE
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_surf.ocl.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_surf.ocl.cpp
new file mode 100644
index 00000000..6a4ee6ad
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xfeatures2d/test/test_surf.ocl.cpp
@@ -0,0 +1,203 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#if defined(HAVE_OPENCL) && defined(OPENCV_ENABLE_NONFREE)
+
+namespace opencv_test { namespace {
+
+static bool keyPointsEquals(const cv::KeyPoint& p1, const cv::KeyPoint& p2)
+{
+    const double maxPtDif = 0.1;
+    const double maxSizeDif = 0.1;
+    const double maxAngleDif = 0.1;
+    const double maxResponseDif = 0.01;
+
+    double dist = cv::norm(p1.pt - p2.pt);
+
+    if (dist < maxPtDif &&
+        fabs(p1.size - p2.size) < maxSizeDif &&
+        abs(p1.angle - p2.angle) < maxAngleDif &&
+        abs(p1.response - p2.response) < maxResponseDif &&
+        p1.octave == p2.octave &&
+        p1.class_id == p2.class_id)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+static int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual)
+{
+    std::sort(actual.begin(), actual.end(), perf::comparators::KeypointGreater());
+    std::sort(gold.begin(), gold.end(), perf::comparators::KeypointGreater());
+
+    int validCount = 0;
+
+    for (size_t i = 0; i < gold.size(); ++i)
+    {
+        const cv::KeyPoint& p1 = gold[i];
+        const cv::KeyPoint& p2 = actual[i];
+
+        if (keyPointsEquals(p1, p2))
+            ++validCount;
+    }
+
+    return validCount;
+}
+
+static int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std::vector<cv::KeyPoint>& keypoints2, const std::vector<cv::DMatch>& matches)
+{
+    int validCount = 0;
+
+    for (size_t i = 0; i < matches.size(); ++i)
+    {
+        const cv::DMatch& m = matches[i];
+
+        const cv::KeyPoint& p1 = keypoints1[m.queryIdx];
+        const cv::KeyPoint& p2 = keypoints2[m.trainIdx];
+
+        if (keyPointsEquals(p1, p2))
+            ++validCount;
+    }
+
+    return validCount;
+}
+
+IMPLEMENT_PARAM_CLASS(HessianThreshold, double)
+IMPLEMENT_PARAM_CLASS(Octaves, int)
+IMPLEMENT_PARAM_CLASS(OctaveLayers, int)
+IMPLEMENT_PARAM_CLASS(Extended, bool)
+IMPLEMENT_PARAM_CLASS(Upright, bool)
+
+PARAM_TEST_CASE(SURF, HessianThreshold, Octaves, OctaveLayers, Extended, Upright)
+{
+    bool useOpenCL;
+    double hessianThreshold;
+    int nOctaves;
+    int nOctaveLayers;
+    bool extended;
+    bool upright;
+
+    virtual void SetUp()
+    {
+        useOpenCL = cv::ocl::useOpenCL();
+        hessianThreshold = get<0>(GetParam());
+        nOctaves = get<1>(GetParam());
+        nOctaveLayers = get<2>(GetParam());
+        extended = get<3>(GetParam());
+        upright = get<4>(GetParam());
+    }
+
+    virtual void TearDown()
+    {
+        cv::ocl::setUseOpenCL(useOpenCL);
+    }
+};
+
+TEST_P(SURF, Detector)
+{
+    cv::UMat image;
+    cv::ocl::setUseOpenCL(true);
+    cv::imread(string(cvtest::TS::ptr()->get_data_path()) + "shared/fruits.png", cv::IMREAD_GRAYSCALE).copyTo(image);
+    ASSERT_FALSE(image.empty());
+
+    cv::Ptr<cv::xfeatures2d::SURF> surf = cv::xfeatures2d::SURF::create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
+    std::vector<cv::KeyPoint> keypoints;
+    surf->detect(image, keypoints, cv::noArray());
+
+    cv::ocl::setUseOpenCL(false);
+    std::vector<cv::KeyPoint> keypoints_gold;
+    surf->detect(image, keypoints_gold, cv::noArray());
+
+    ASSERT_EQ(keypoints_gold.size(), keypoints.size());
+    int matchedCount = getMatchedPointsCount(keypoints_gold, keypoints);
+    double matchedRatio = static_cast<double>(matchedCount) / keypoints_gold.size();
+
+    EXPECT_GT(matchedRatio, 0.99);
+}
+
+TEST_P(SURF, Descriptor)
+{
+    cv::UMat image;
+    cv::ocl::setUseOpenCL(true);
+    cv::imread(string(cvtest::TS::ptr()->get_data_path()) + "shared/fruits.png", cv::IMREAD_GRAYSCALE).copyTo(image);
+    ASSERT_FALSE(image.empty());
+
+    cv::Ptr<cv::xfeatures2d::SURF> surf = cv::xfeatures2d::SURF::create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
+
+    std::vector<cv::KeyPoint> keypoints;
+    surf->detect(image, keypoints, cv::noArray());
+
+    cv::UMat descriptors;
+
+    surf->detectAndCompute(image, cv::noArray(), keypoints, descriptors, true);
+
+    cv::ocl::setUseOpenCL(false);
+    cv::Mat descriptors_gold;
+    surf->detectAndCompute(image, cv::noArray(), keypoints, descriptors_gold, true);
+
+    cv::BFMatcher matcher(surf->defaultNorm());
+    std::vector<cv::DMatch> matches;
+    matcher.match(descriptors_gold, descriptors, matches);
+
+    int matchedCount = getMatchedPointsCount(keypoints, keypoints, matches);
+    double matchedRatio = static_cast<double>(matchedCount) / keypoints.size();
+
+    EXPECT_GT(matchedRatio, 0.35);
+}
+
+INSTANTIATE_TEST_CASE_P(OCL_Features2D, SURF, testing::Combine(
+    testing::Values(HessianThreshold(500.0), HessianThreshold(1000.0)),
+    testing::Values(Octaves(3), Octaves(4)),
+    testing::Values(OctaveLayers(2), OctaveLayers(3)),
+    testing::Values(Extended(false), Extended(true)),
+    testing::Values(Upright(false), Upright(true))));
+
+}} // namespace
+
+#endif // HAVE_OPENCL && OPENCV_ENABLE_NONFREE
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/CMakeLists.txt b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/CMakeLists.txt
new file mode 100644
index 00000000..58f9f257
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/CMakeLists.txt
@@ -0,0 +1,2 @@
+set(the_description "Extended image processing module. It includes edge-aware filters and etc.")
+ocv_define_module(ximgproc opencv_core opencv_imgproc opencv_calib3d opencv_imgcodecs opencv_video WRAP python java objc)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/README.md b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/README.md
new file mode 100644
index 00000000..d4ec453d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/README.md
@@ -0,0 +1,19 @@
+Extended Image Processing
+=========================
+
+- Structured Forests
+- Edge Boxes
+- Domain Transform Filter
+- Guided Filter
+- Adaptive Manifold Filter
+- Joint Bilateral Filter
+- Superpixels
+- Graph segmentation
+- Selective search from segmentation
+- Paillou Filter
+- Fast Line Detector
+- Deriche Filter
+- Pei&Lin Normalization
+- Ridge Detection Filter
+- Binary morphology on run-length encoded images
+- Ellipse Detector
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/corridor_fld.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/corridor_fld.jpg
new file mode 100644
index 00000000..baff0411
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/corridor_fld.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_blocks.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_blocks.png
new file mode 100644
index 00000000..9298968a
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_blocks.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_blocks2.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_blocks2.png
new file mode 100644
index 00000000..9107ff43
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_blocks2.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_demo.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_demo.png
new file mode 100644
index 00000000..3f165d59
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_demo.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_lsc.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_lsc.png
new file mode 100644
index 00000000..515fab92
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_lsc.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_slic.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_slic.png
new file mode 100644
index 00000000..5c5f39ed
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/pics/superpixels_slic.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/ximgproc.bib b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/ximgproc.bib
new file mode 100644
index 00000000..f081f54d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/doc/ximgproc.bib
@@ -0,0 +1,402 @@
+@inproceedings{ZitnickECCV14edgeBoxes,
+  author    = {C. Lawrence Zitnick and Piotr Doll{\'a}r},
+  title     = {Edge Boxes: Locating Object Proposals from Edges},
+  booktitle = {ECCV},
+  year      = {2014},
+}
+
+@inproceedings{Dollar2013,
+  title={Structured forests for fast edge detection},
+  author={Doll{\'a}r, Piotr and Zitnick, C Lawrence},
+  booktitle={Computer Vision (ICCV), 2013 IEEE International Conference on},
+  pages={1841--1848},
+  year={2013},
+  organization={IEEE}
+}
+
+@incollection{VBRV14,
+  title={SEEDS: Superpixels extracted via energy-driven sampling},
+  author={Van den Bergh, Michael and Boix, Xavier and Roig, Gemma and de Capitani, Benjamin and Van Gool, Luc},
+  booktitle={Computer Vision--ECCV 2012},
+  pages={13--26},
+  year={2012},
+  publisher={Springer}
+}
+
+@inproceedings{Gastal11,
+  title={Domain transform for edge-aware image and video processing},
+  author={Gastal, Eduardo SL and Oliveira, Manuel M},
+  booktitle={ACM Transactions on Graphics (TOG)},
+  volume={30},
+  number={4},
+  pages={69},
+  year={2011},
+  organization={ACM}
+}
+
+@article{Gastal12,
+  title={Adaptive manifolds for real-time high-dimensional filtering},
+  author={Gastal, Eduardo SL and Oliveira, Manuel M},
+  journal={ACM Transactions on Graphics (TOG)},
+  volume={31},
+  number={4},
+  pages={33},
+  year={2012},
+  publisher={ACM}
+}
+
+@incollection{Kaiming10,
+  title={Guided image filtering},
+  author={He, Kaiming and Sun, Jian and Tang, Xiaoou},
+  booktitle={Computer Vision--ECCV 2010},
+  pages={1--14},
+  year={2010},
+  publisher={Springer}
+}
+
+@inproceedings{Lee14,
+  title={Outdoor place recognition in urban environments using straight lines},
+  author={Lee, Jin Han and Lee, Sehyung and Zhang, Guoxuan and Lim, Jongwoo and Chung, Wan Kyun and Suh, Il Hong},
+  booktitle={2014 IEEE International Conference on Robotics and Automation (ICRA)},
+  pages={5550--5557},
+  year={2014},
+  organization={IEEE}
+}
+
+@inproceedings{Lim2013,
+  title={Sketch tokens: A learned mid-level representation for contour and object detection},
+  author={Lim, Joseph J and Zitnick, C Lawrence and Doll{\'a}r, Piotr},
+  booktitle={Computer Vision and Pattern Recognition (CVPR), 2013 IEEE Conference on},
+  pages={3158--3165},
+  year={2013},
+  organization={IEEE}
+}
+
+@incollection{PFF2004,
+  title={Efficient graph-based image segmentation},
+  author={Felzenszwalb, Pedro F and Huttenlocher, Daniel P},
+  journal={International Journal of Computer Vision},
+  volume={59},
+  number={2},
+  pages={167--181},
+  year={2004},
+  publisher={Springer}
+}
+
+@article{deriche1987,
+  title={Using Canny's criteria to derive a recursively implemented optimal edge detector},
+  author={Deriche Rachid},
+  journal={International journal of computer vision},
+  volume={1},
+  number={2},
+  pages={167--187},
+  year={1987},
+  publisher={Springer}
+}
+
+@article{uijlings2013selective,
+  title={Selective search for object recognition},
+  author={Uijlings, Jasper RR and van de Sande, Koen EA and Gevers, Theo and Smeulders, Arnold WM},
+  journal={International journal of computer vision},
+  volume={104},
+  number={2},
+  pages={154--171},
+  year={2013},
+  publisher={Springer}
+}
+
+@article{Min2014,
+  title={Fast global image smoothing based on weighted least squares},
+  author={Min, Dongbo and Choi, Sunghwan and Lu, Jiangbo and Ham, Bumsub and Sohn, Kwanghoon and Do, Minh N},
+  journal={Image Processing, IEEE Transactions on},
+  volume={23},
+  number={12},
+  pages={5638--5653},
+  year={2014},
+  publisher={IEEE}
+}
+
+@inproceedings{Farbman2008,
+  title={Edge-preserving decompositions for multi-scale tone and detail manipulation},
+  author={Farbman, Zeev and Fattal, Raanan and Lischinski, Dani and Szeliski, Richard},
+  booktitle={ACM Transactions on Graphics (TOG)},
+  volume={27},
+  number={3},
+  pages={67},
+  year={2008},
+  organization={ACM}
+}
+
+
+@inproceedings{xu2011image,
+  title={Image smoothing via L 0 gradient minimization},
+  author={Xu, Li and Lu, Cewu and Xu, Yi and Jia, Jiaya},
+  booktitle={ACM Transactions on Graphics (TOG)},
+  volume={30},
+  number={6},
+  pages={174},
+  year={2011},
+  organization={ACM}
+}
+
+@inproceedings{Revaud2015,
+  title={EpicFlow: Edge-Preserving Interpolation of Correspondences for Optical Flow},
+  author={Revaud, Jerome and Weinzaepfel, Philippe and Harchaoui, Zaid and Schmid, Cordelia},
+  booktitle={Computer Vision and Pattern Recognition (CVPR), IEEE Conference on},
+  pages={1164--1172},
+  year={2015}
+}
+
+@article{Achanta2012,
+  author = {Achanta, Radhakrishna and Shaji, Appu and Smith, Kevin and Lucchi, Aurelien and Fua, Pascal and Susstrunk, Sabine},
+  title = {SLIC Superpixels Compared to State-of-the-Art Superpixel Methods},
+  journal = {IEEE Trans. Pattern Anal. Mach. Intell.},
+  issue_date = {November 2012},
+  volume = {34},
+  number = {11},
+  month = {nov},
+  year = {2012},
+  issn = {0162-8828},
+  pages = {2274--2282},
+  numpages = {9},
+  url = {http://dx.doi.org/10.1109/TPAMI.2012.120},
+  doi = {10.1109/TPAMI.2012.120},
+  acmid = {2377556},
+  publisher = {IEEE Computer Society},
+  address = {Washington, DC, USA},
+  keywords = {Superpixels, segmentation, clustering, k-means}
+}
+
+@InProceedings{Liu_2017_IEEE,
+  author = {Liu, Yong-Jin and Yu, Cheng-Chi and Yu, Min-Jing and He, Ying},
+  title = {Intrinsic Manifold SLIC: A Simple and Efficient Method for Computing Content-Sensitive Superpixels},
+  journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence},
+  issue_date = {March 2017},
+  volume = {PP},
+  month = {mar},
+  year = {2017},
+  issue = {99},
+  url = {https://doi.org/10.1109/TPAMI.2017.2686857},
+  doi = {10.1109/TPAMI.2017.2686857},
+  publisher = {IEEE Computer Society},
+  address = {Washington, DC, USA},
+  keywords = {Superpixels, segmentation, image manifold, centroidal Voronoi tessellation, geodesic distance}
+}
+
+@InProceedings{LiCVPR2015LSC,
+  author = {Li, Zhengqin and Chen, Jiansheng},
+  title = {Superpixel Segmentation Using Linear Spectral Clustering},
+  journal = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
+  month = {June},
+  year = {2015}
+}
+
+@article{Cho2014,
+  title = {Bilateral Texture Filtering},
+  author = {Hojin Cho and Hyunjoon Lee and Henry Kang and Seungyong Lee},
+  journal = {ACM Transactions on Graphics},
+  year = {2014},
+  volume = {33},
+  number = {4},
+  month = {July},
+  pages = {128:1--128:8}
+}
+
+@incollection{zhang2014rolling,
+  title={Rolling guidance filter},
+  author={Zhang, Qi and Shen, Xiaoyong and Xu, Li and Jia, Jiaya},
+  booktitle={Computer Vision--ECCV 2014},
+  pages={815--830},
+  year={2014},
+  publisher={Springer}
+}
+
+@inproceedings{zhang2014100+,
+  title={100+ times faster weighted median filter (WMF)},
+  author={Zhang, Qi and Xu, Li and Jia, Jiaya},
+  booktitle={Computer Vision and Pattern Recognition (CVPR), 2014 IEEE Conference on},
+  pages={2830--2837},
+  year={2014},
+  organization={IEEE}
+}
+
+@article{paillou1997detecting,
+  title={Detecting step edges in noisy SAR images: a new linear operator},
+  author={Paillou, Philippe},
+  journal={IEEE transactions on geoscience and remote sensing},
+  volume={35},
+  number={1},
+  pages={191--196},
+  year={1997}
+}
+
+@book{Niblack1985,
+  title={An introduction to digital image processing},
+  author={Niblack, Wayne},
+  year={1985},
+  publisher={Strandberg Publishing Company}
+}
+
+@inproceedings{Sauvola1997,
+  title={Adaptive document binarization},
+  author={Sauvola, Jaakko and Seppanen, Tapio and Haapakoski, Sami and Pietikainen, Matti},
+  booktitle={Document Analysis and Recognition, 1997., Proceedings of the Fourth International Conference on},
+  volume={1},
+  pages={147--152},
+  year={1997},
+  organization={IEEE}
+}
+
+@article{Wolf2004,
+  title={Extraction and recognition of artificial text in multimedia documents},
+  author={Wolf, Christian and Jolion, J-M},
+  journal={Pattern Analysis \& Applications},
+  volume={6},
+  number={4},
+  pages={309--326},
+  year={2004},
+  publisher={Springer}
+}
+
+@inproceedings{Khurshid2009,
+  title={Comparison of Niblack inspired Binarization methods for ancient documents},
+  author={Khurshid, Khurram and Siddiqi, Imran and Faure, Claudie and Vincent, Nicole},
+  booktitle={IS\&T/SPIE Electronic Imaging},
+  pages={72470U--72470U},
+  year={2009},
+  organization={International Society for Optics and Photonics}
+}
+
+@article{BergerRaghunathan1998,
+  title={Coalescence in 2 dimensions: experiments on thin copolymer films and numerical simulations},
+  author={Berger, L and Raghunathan, V A and Launay, C and  Ausserré, D and Gallot, Y},
+  journal={The European Physical Journal B - Condensed Matter and Complex Systems},
+  volume={2},
+  number={1},
+  pages={93-99},
+  year={1998},
+  publisher={Springer}
+}
+
+@article{PersoonFu1977,
+  title={Shape Discrimination Using Fourier Descriptors},
+  author={E  Persoon and King-Sun  Fu},
+  journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
+  volume={7},
+  number={3},
+  pages={170-179},
+  year={1977},
+  publisher={IEEE Computer Society}
+}
+
+@inproceedings{Breuel2008,
+  title = {Binary Morphology and Related Operations on Run-Length Representations.},
+  author = {Breuel, Thomas},
+  year = {2008},
+  month = {01},
+  pages = {159-166},
+  volume = {1},
+  booktitle = {VISAPP 2008 - 3rd International Conference on Computer Vision Theory and Applications, Proceedings}
+}
+
+@misc{Segleafvein,
+  title = {Best Way of Segmenting Veins in Leaves.},
+  author = {Niki Estner},
+  url = {https://dsp.stackexchange.com/a/1735}
+}
+
+@misc{M_RF,
+  title = {Ridge Filter Mathematica},
+  author = {Wolfram Mathematica},
+  url = {http://reference.wolfram.com/language/ref/RidgeFilter.html}
+}
+
+@inproceedings{BarronPoole2016,
+author = {Jonathan T Barron and Ben Poole},
+title={The Fast Bilateral Solver},
+booktitle={European Conference on Computer Vision (ECCV)},
+year={2016},
+publisher={Springer International Publishing},
+pages={617--632},
+}
+
+@inproceedings{BarronPoole2016,
+author = {Jonathan T Barron and Ben Poole},
+title={The Fast Bilateral Solver},
+booktitle={European Conference on Computer Vision (ECCV)},
+year={2016},
+publisher={Springer International Publishing},
+pages={617--632},
+}
+
+@inproceedings{Hu2017,
+  title={Robust interpolation of correspondences for large displacement optical flow},
+  author={Hu, Yinlin and Li, Yunsong and Song, Rui},
+  booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
+  pages={481--489},
+  year={2017}
+}
+
+@article{topal2012edge,
+  title={Edge drawing: a combined real-time edge and segment detector},
+  author={Topal, Cihan and Akinlar, Cuneyt},
+  journal={Journal of Visual Communication and Image Representation},
+  volume={23},
+  number={6},
+  pages={862--872},
+  year={2012},
+  publisher={Elsevier}
+}
+
+@article{akinlar2011edlines,
+  title={EDLines: A real-time line segment detector with a false detection control},
+  author={Akinlar, Cuneyt and Topal, Cihan},
+  journal={Pattern Recognition Letters},
+  volume={32},
+  number={13},
+  pages={1633--1642},
+  year={2011},
+  publisher={Elsevier}
+}
+
+@article{akinlar2012edpf,
+  title={EDPF: a real-time parameter-free edge segment detector with a false detection control},
+  author={Akinlar, Cuneyt and Topal, Cihan},
+  journal={International Journal of Pattern Recognition and Artificial Intelligence},
+  volume={26},
+  number={01},
+  pages={1255002},
+  year={2012},
+  publisher={World Scientific}
+}
+
+@article{akinlar2013edcircles,
+  title={EDCircles: A real-time circle detector with a false detection control},
+  author={Akinlar, Cuneyt and Topal, Cihan},
+  journal={Pattern Recognition},
+  volume={46},
+  number={3},
+  pages={725--740},
+  year={2013},
+  publisher={Elsevier}
+}
+
+@article{loke2021accelerated,
+  title={Accelerated superpixel image segmentation with a parallelized DBSCAN algorithm},
+  author={Loke, Seng Cheong and MacDonald, Bruce A and Parsons, Matthew and W{\"u}nsche, Burkhard Claus},
+  journal={Journal of Real-Time Image Processing},
+  pages={1--16},
+  year={2021},
+  publisher={Springer}
+}
+
+@article{jia2017fast,
+  title={A fast ellipse detector using projective invariant pruning},
+  author={Jia, Qi and Fan, Xin and Luo, Zhongxuan and Song, Lianbo and Qiu, Tie},
+  journal={IEEE Transactions on Image Processing},
+  volume={26},
+  number={8},
+  pages={3665--3679},
+  year={2017},
+  publisher={IEEE}
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc.hpp
new file mode 100644
index 00000000..dca0443c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc.hpp
@@ -0,0 +1,219 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#ifndef __OPENCV_XIMGPROC_HPP__
+#define __OPENCV_XIMGPROC_HPP__
+
+#include "ximgproc/edge_filter.hpp"
+#include "ximgproc/disparity_filter.hpp"
+#include "ximgproc/sparse_match_interpolator.hpp"
+#include "ximgproc/structured_edge_detection.hpp"
+#include "ximgproc/edgeboxes.hpp"
+#include "ximgproc/edge_drawing.hpp"
+#include "ximgproc/scansegment.hpp"
+#include "ximgproc/seeds.hpp"
+#include "ximgproc/segmentation.hpp"
+#include "ximgproc/fast_hough_transform.hpp"
+#include "ximgproc/estimated_covariance.hpp"
+#include "ximgproc/weighted_median_filter.hpp"
+#include "ximgproc/slic.hpp"
+#include "ximgproc/lsc.hpp"
+#include "ximgproc/paillou_filter.hpp"
+#include "ximgproc/fast_line_detector.hpp"
+#include "ximgproc/deriche_filter.hpp"
+#include "ximgproc/peilin.hpp"
+#include "ximgproc/fourier_descriptors.hpp"
+#include "ximgproc/ridgefilter.hpp"
+#include "ximgproc/brightedges.hpp"
+#include "ximgproc/run_length_morphology.hpp"
+#include "ximgproc/edgepreserving_filter.hpp"
+#include "ximgproc/color_match.hpp"
+#include "ximgproc/radon_transform.hpp"
+#include "ximgproc/find_ellipses.hpp"
+
+
+/** @defgroup ximgproc Extended Image Processing
+  @{
+    @defgroup ximgproc_edge Structured forests for fast edge detection
+
+This module contains implementations of modern structured edge detection algorithms,
+i.e. algorithms which somehow takes into account pixel affinities in natural images.
+
+    @defgroup ximgproc_edgeboxes EdgeBoxes
+
+    @defgroup ximgproc_filters Filters
+
+    @defgroup ximgproc_superpixel Superpixels
+
+    @defgroup ximgproc_segmentation Image segmentation
+
+    @defgroup ximgproc_fast_line_detector Fast line detector
+
+    @defgroup ximgproc_edge_drawing EdgeDrawing
+
+EDGE DRAWING LIBRARY FOR GEOMETRIC FEATURE EXTRACTION AND VALIDATION
+
+Edge Drawing (ED) algorithm is an proactive approach on edge detection problem. In contrast to many other existing edge detection algorithms which follow a subtractive
+approach (i.e. after applying gradient filters onto an image eliminating pixels w.r.t. several rules, e.g. non-maximal suppression and hysteresis in Canny), ED algorithm
+works via an additive strategy, i.e. it picks edge pixels one by one, hence the name Edge Drawing. Then we process those random shaped edge segments to extract higher level
+edge features, i.e. lines, circles, ellipses, etc. The popular method of extraction edge pixels from the thresholded gradient magnitudes is non-maximal supression that tests
+every pixel whether it has the maximum gradient response along its gradient direction and eliminates if it does not. However, this method does not check status of the
+neighboring pixels, and therefore might result low quality (in terms of edge continuity, smoothness, thinness, localization) edge segments. Instead of non-maximal supression,
+ED points a set of edge pixels and join them by maximizing the total gradient response of edge segments. Therefore it can extract high quality edge segments without need for
+an additional hysteresis step.
+
+    @defgroup ximgproc_fourier Fourier descriptors
+
+    @defgroup ximgproc_run_length_morphology Binary morphology on run-length encoded image
+
+    These functions support morphological operations on binary images. In order to be fast and space efficient binary images are encoded with a run-length representation.
+    This representation groups continuous horizontal sequences of "on" pixels together in a "run". A run is charactarized by the column position of the first pixel in the run, the column
+    position of the last pixel in the run and the row position. This representation is very compact for binary images which contain large continuous areas of "on" and "off" pixels. A checkerboard
+    pattern would be a good example. The representation is not so suitable for binary images created from random noise images or other images where little correlation between neighboring pixels
+    exists.
+
+    The morphological operations supported here are very similar to the operations supported in the imgproc module. In general they are fast. However on several occasions they are slower than the functions
+    from imgproc. The structuring elements of cv::MORPH_RECT and cv::MORPH_CROSS have very good support from the imgproc module. Also small structuring elements are very fast in imgproc (presumably
+    due to opencl support). Therefore the functions from this module are recommended for larger structuring elements (cv::MORPH_ELLIPSE or self defined structuring elements). A sample application
+    (run_length_morphology_demo) is supplied which allows to compare the speed of some morphological operations for the functions using run-length encoding and the imgproc functions for a given image.
+
+    Run length encoded images are stored in standard opencv images. Images have a single column of cv::Point3i elements. The number of rows is the number of run + 1. The first row contains
+    the size of the original (not encoded) image.  For the runs the following mapping is used (x: column begin, y: column end (last column), z: row).
+
+    The size of the original image is required for compatibility with the imgproc functions when the boundary handling requires that pixel outside the image boundary are
+    "on".
+
+    @}
+*/
+
+namespace cv
+{
+namespace ximgproc
+{
+
+enum ThinningTypes{
+    THINNING_ZHANGSUEN    = 0, // Thinning technique of Zhang-Suen
+    THINNING_GUOHALL      = 1  // Thinning technique of Guo-Hall
+};
+
+/**
+* @brief Specifies the binarization method to use in cv::ximgproc::niBlackThreshold
+*/
+enum LocalBinarizationMethods{
+	BINARIZATION_NIBLACK = 0, //!< Classic Niblack binarization. See @cite Niblack1985 .
+	BINARIZATION_SAUVOLA = 1, //!< Sauvola's technique. See @cite Sauvola1997 .
+	BINARIZATION_WOLF = 2,    //!< Wolf's technique. See @cite Wolf2004 .
+	BINARIZATION_NICK = 3     //!< NICK technique. See @cite Khurshid2009 .
+};
+
+//! @addtogroup ximgproc
+//! @{
+
+/** @brief Performs thresholding on input images using Niblack's technique or some of the
+popular variations it inspired.
+
+The function transforms a grayscale image to a binary image according to the formulae:
+-   **THRESH_BINARY**
+    \f[dst(x,y) =  \fork{\texttt{maxValue}}{if \(src(x,y) > T(x,y)\)}{0}{otherwise}\f]
+-   **THRESH_BINARY_INV**
+    \f[dst(x,y) =  \fork{0}{if \(src(x,y) > T(x,y)\)}{\texttt{maxValue}}{otherwise}\f]
+where \f$T(x,y)\f$ is a threshold calculated individually for each pixel.
+
+The threshold value \f$T(x, y)\f$ is determined based on the binarization method chosen. For
+classic Niblack, it is the mean minus \f$ k \f$ times standard deviation of
+\f$\texttt{blockSize} \times\texttt{blockSize}\f$ neighborhood of \f$(x, y)\f$.
+
+The function can't process the image in-place.
+
+@param _src Source 8-bit single-channel image.
+@param _dst Destination image of the same size and the same type as src.
+@param maxValue Non-zero value assigned to the pixels for which the condition is satisfied,
+used with the THRESH_BINARY and THRESH_BINARY_INV thresholding types.
+@param type Thresholding type, see cv::ThresholdTypes.
+@param blockSize Size of a pixel neighborhood that is used to calculate a threshold value
+for the pixel: 3, 5, 7, and so on.
+@param k The user-adjustable parameter used by Niblack and inspired techniques. For Niblack, this is
+normally a value between 0 and 1 that is multiplied with the standard deviation and subtracted from
+the mean.
+@param binarizationMethod Binarization method to use. By default, Niblack's technique is used.
+Other techniques can be specified, see cv::ximgproc::LocalBinarizationMethods.
+@param r The user-adjustable parameter used by Sauvola's technique. This is the dynamic range
+of standard deviation.
+@sa  threshold, adaptiveThreshold
+ */
+CV_EXPORTS_W void niBlackThreshold( InputArray _src, OutputArray _dst,
+                                    double maxValue, int type,
+                                    int blockSize, double k, int binarizationMethod = BINARIZATION_NIBLACK,
+                                    double r = 128 );
+
+/** @brief Applies a binary blob thinning operation, to achieve a skeletization of the input image.
+
+The function transforms a binary blob image into a skeletized form using the technique of Zhang-Suen.
+
+@param src Source 8-bit single-channel image, containing binary blobs, with blobs having 255 pixel values.
+@param dst Destination image of the same size and the same type as src. The function can work in-place.
+@param thinningType Value that defines which thinning algorithm should be used. See cv::ximgproc::ThinningTypes
+ */
+CV_EXPORTS_W void thinning( InputArray src, OutputArray dst, int thinningType = THINNING_ZHANGSUEN);
+
+/** @brief Performs anisotropic diffusion on an image.
+
+ The function applies Perona-Malik anisotropic diffusion to an image. This is the solution to the partial differential equation:
+
+ \f[{\frac  {\partial I}{\partial t}}={\mathrm  {div}}\left(c(x,y,t)\nabla I\right)=\nabla c\cdot \nabla I+c(x,y,t)\Delta I\f]
+
+ Suggested functions for c(x,y,t) are:
+
+ \f[c\left(\|\nabla I\|\right)=e^{{-\left(\|\nabla I\|/K\right)^{2}}}\f]
+
+ or
+
+ \f[ c\left(\|\nabla I\|\right)={\frac {1}{1+\left({\frac  {\|\nabla I\|}{K}}\right)^{2}}} \f]
+
+ @param src Source image with 3 channels.
+ @param dst Destination image of the same size and the same number of channels as src .
+ @param alpha The amount of time to step forward by on each iteration (normally, it's between 0 and 1).
+ @param K sensitivity to the edges
+ @param niters The number of iterations
+*/
+CV_EXPORTS_W void anisotropicDiffusion(InputArray src, OutputArray dst, float alpha, float K, int niters );
+
+//! @}
+
+}
+}
+
+#endif // __OPENCV_XIMGPROC_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/brightedges.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/brightedges.hpp
new file mode 100644
index 00000000..fa309119
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/brightedges.hpp
@@ -0,0 +1,50 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2017, IBM Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//      Marc Fiammante marc.fiammante@fr.ibm.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of OpenCV Foundation or contributors may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the OpenCV Foundation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#include "opencv2/core.hpp"
+namespace cv
+{
+    namespace ximgproc {
+        CV_EXPORTS_W void  BrightEdges(Mat &_original, Mat &_edgeview, int contrast = 1, int shortrange = 3, int longrange = 9);
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/color_match.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/color_match.hpp
new file mode 100644
index 00000000..c18390d4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/color_match.hpp
@@ -0,0 +1,66 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_COLOR_MATCH_HPP__
+#define __OPENCV_COLOR_MATCH_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace ximgproc {
+
+//! @addtogroup ximgproc_filters
+//! @{
+
+/**
+* @brief   creates a quaternion image.
+*
+* @param   img         Source 8-bit, 32-bit or 64-bit image, with 3-channel image.
+* @param   qimg        result CV_64FC4 a quaternion image( 4 chanels zero channel and B,G,R).
+*/
+CV_EXPORTS_W void createQuaternionImage(InputArray img, OutputArray qimg);
+
+/**
+* @brief   calculates conjugate of a quaternion image.
+*
+* @param   qimg         quaternion image.
+* @param   qcimg        conjugate of qimg
+*/
+CV_EXPORTS_W void qconj(InputArray qimg, OutputArray qcimg);
+/**
+* @brief   divides each element by its modulus.
+*
+* @param   qimg         quaternion image.
+* @param   qnimg        conjugate of qimg
+*/
+CV_EXPORTS_W void qunitary(InputArray qimg, OutputArray qnimg);
+/**
+* @brief   Calculates the per-element quaternion product of two arrays
+*
+* @param   src1         quaternion image.
+* @param   src2         quaternion image.
+* @param   dst        product dst(I)=src1(I) . src2(I)
+*/
+CV_EXPORTS_W void qmultiply(InputArray  	src1, InputArray  	src2, OutputArray  	dst);
+/**
+* @brief    Performs a forward or inverse Discrete quaternion Fourier transform of a 2D quaternion array.
+*
+* @param   img        quaternion image.
+* @param   qimg       quaternion image in dual space.
+* @param   flags      quaternion image in dual space. only DFT_INVERSE flags is supported
+* @param   sideLeft   true the hypercomplex exponential is to be multiplied on the left (false on the right ).
+*/
+CV_EXPORTS_W void qdft(InputArray img, OutputArray qimg, int  	flags, bool sideLeft);
+/**
+* @brief    Compares a color template against overlapped color image regions.
+*
+* @param   img        Image where the search is running. It must be 3 channels image
+* @param   templ       Searched template. It must be not greater than the source image and have 3 channels
+* @param   result     Map of comparison results. It must be single-channel 64-bit floating-point
+*/
+CV_EXPORTS_W void colorMatchTemplate(InputArray img, InputArray templ, OutputArray result);
+
+}
+}
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/deriche_filter.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/deriche_filter.hpp
new file mode 100644
index 00000000..26d3b675
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/deriche_filter.hpp
@@ -0,0 +1,77 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#ifndef __OPENCV_DERICHEFILTER_HPP__
+#define __OPENCV_DERICHEFILTER_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace ximgproc {
+
+//! @addtogroup ximgproc_filters
+//! @{
+
+/**
+* @brief   Applies Y Deriche filter to an image.
+*
+* For more details about this implementation, please see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.476.5736&rep=rep1&type=pdf
+*
+* @param   op         Source 8-bit or 16bit image, 1-channel or 3-channel image.
+* @param   dst        result CV_32FC image with same number of channel than _op.
+* @param   alpha double see paper
+* @param   omega   double see paper
+*
+*/
+CV_EXPORTS_W void GradientDericheY(InputArray op, OutputArray dst, double alpha,double omega);
+/**
+* @brief   Applies X Deriche filter to an image.
+*
+* For more details about this implementation, please see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.476.5736&rep=rep1&type=pdf
+*
+* @param   op         Source 8-bit or 16bit image, 1-channel or 3-channel image.
+* @param   dst        result CV_32FC image with same number of channel than _op.
+* @param   alpha double see paper
+* @param   omega   double see paper
+*
+*/
+CV_EXPORTS_W void GradientDericheX(InputArray op, OutputArray dst, double alpha,double omega);
+
+}
+}
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/disparity_filter.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/disparity_filter.hpp
new file mode 100644
index 00000000..c6436e60
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/disparity_filter.hpp
@@ -0,0 +1,210 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#ifndef __OPENCV_DISPARITYFILTER_HPP__
+#define __OPENCV_DISPARITYFILTER_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+#include <opencv2/calib3d.hpp>
+
+namespace cv {
+namespace ximgproc {
+
+//! @addtogroup ximgproc_filters
+//! @{
+
+/** @brief Main interface for all disparity map filters.
+ */
+class CV_EXPORTS_W DisparityFilter : public Algorithm
+{
+public:
+
+    /** @brief Apply filtering to the disparity map.
+
+    @param disparity_map_left disparity map of the left view, 1 channel, CV_16S type. Implicitly assumes that disparity
+    values are scaled by 16 (one-pixel disparity corresponds to the value of 16 in the disparity map). Disparity map
+    can have any resolution, it will be automatically resized to fit left_view resolution.
+
+    @param left_view left view of the original stereo-pair to guide the filtering process, 8-bit single-channel
+    or three-channel image.
+
+    @param filtered_disparity_map output disparity map.
+
+    @param disparity_map_right optional argument, some implementations might also use the disparity map
+    of the right view to compute confidence maps, for instance.
+
+    @param ROI region of the disparity map to filter. Optional, usually it should be set automatically.
+
+    @param right_view optional argument, some implementations might also use the right view of the original
+    stereo-pair.
+     */
+    CV_WRAP virtual void filter(InputArray disparity_map_left, InputArray left_view, OutputArray filtered_disparity_map, InputArray disparity_map_right = Mat(), Rect ROI = Rect(), InputArray right_view = Mat()) = 0;
+};
+
+/** @brief Disparity map filter based on Weighted Least Squares filter (in form of Fast Global Smoother that
+is a lot faster than traditional Weighted Least Squares filter implementations) and optional use of
+left-right-consistency-based confidence to refine the results in half-occlusions and uniform areas.
+ */
+class CV_EXPORTS_W DisparityWLSFilter : public DisparityFilter
+{
+public:
+    /** filter parameters */
+
+    /** @brief Lambda is a parameter defining the amount of regularization during filtering. Larger values force
+    filtered disparity map edges to adhere more to source image edges. Typical value is 8000.
+     */
+    CV_WRAP virtual double getLambda() = 0;
+    /** @see getLambda */
+    CV_WRAP virtual void setLambda(double _lambda) = 0;
+    /** @brief SigmaColor is a parameter defining how sensitive the filtering process is to source image edges.
+    Large values can lead to disparity leakage through low-contrast edges. Small values can make the filter too
+    sensitive to noise and textures in the source image. Typical values range from 0.8 to 2.0.
+     */
+    CV_WRAP virtual double getSigmaColor() = 0;
+    /** @see getSigmaColor */
+    CV_WRAP virtual void setSigmaColor(double _sigma_color) = 0;
+
+    /** confidence-related parameters */
+
+    /** @brief LRCthresh is a threshold of disparity difference used in left-right-consistency check during
+    confidence map computation. The default value of 24 (1.5 pixels) is virtually always good enough.
+     */
+    CV_WRAP virtual int getLRCthresh() = 0;
+    /** @see getLRCthresh */
+    CV_WRAP virtual void setLRCthresh(int _LRC_thresh) = 0;
+    /** @brief DepthDiscontinuityRadius is a parameter used in confidence computation. It defines the size of
+    low-confidence regions around depth discontinuities.
+     */
+    CV_WRAP virtual int getDepthDiscontinuityRadius() = 0;
+    /** @see getDepthDiscontinuityRadius */
+    CV_WRAP virtual void setDepthDiscontinuityRadius(int _disc_radius) = 0;
+    /** @brief Get the confidence map that was used in the last filter call. It is a CV_32F one-channel image
+    with values ranging from 0.0 (totally untrusted regions of the raw disparity map) to 255.0 (regions containing
+    correct disparity values with a high degree of confidence).
+     */
+    CV_WRAP virtual Mat getConfidenceMap() = 0;
+    /** @brief Get the ROI used in the last filter call
+     */
+    CV_WRAP virtual Rect getROI() = 0;
+};
+
+/** @brief Convenience factory method that creates an instance of DisparityWLSFilter and sets up all the relevant
+filter parameters automatically based on the matcher instance. Currently supports only StereoBM and StereoSGBM.
+
+@param matcher_left stereo matcher instance that will be used with the filter
+*/
+CV_EXPORTS_W
+Ptr<DisparityWLSFilter> createDisparityWLSFilter(Ptr<StereoMatcher> matcher_left);
+
+/** @brief Convenience method to set up the matcher for computing the right-view disparity map
+that is required in case of filtering with confidence.
+
+@param matcher_left main stereo matcher instance that will be used with the filter
+*/
+CV_EXPORTS_W
+Ptr<StereoMatcher> createRightMatcher(Ptr<StereoMatcher> matcher_left);
+
+/** @brief More generic factory method, create instance of DisparityWLSFilter and execute basic
+initialization routines. When using this method you will need to set-up the ROI, matchers and
+other parameters by yourself.
+
+@param use_confidence filtering with confidence requires two disparity maps (for the left and right views) and is
+approximately two times slower. However, quality is typically significantly better.
+*/
+CV_EXPORTS_W
+Ptr<DisparityWLSFilter> createDisparityWLSFilterGeneric(bool use_confidence);
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+/** @brief Function for reading ground truth disparity maps. Supports basic Middlebury
+and MPI-Sintel formats. Note that the resulting disparity map is scaled by 16.
+
+@param src_path path to the image, containing ground-truth disparity map
+
+@param dst output disparity map, CV_16S depth
+
+@result returns zero if successfully read the ground truth
+ */
+CV_EXPORTS_W
+int readGT(String src_path,OutputArray dst);
+
+/** @brief Function for computing mean square error for disparity maps
+
+@param GT ground truth disparity map
+
+@param src disparity map to evaluate
+
+@param ROI region of interest
+
+@result returns mean square error between GT and src
+ */
+CV_EXPORTS_W
+double computeMSE(InputArray GT, InputArray src, Rect ROI);
+
+/** @brief Function for computing the percent of "bad" pixels in the disparity map
+(pixels where error is higher than a specified threshold)
+
+@param GT ground truth disparity map
+
+@param src disparity map to evaluate
+
+@param ROI region of interest
+
+@param thresh threshold used to determine "bad" pixels
+
+@result returns mean square error between GT and src
+ */
+CV_EXPORTS_W
+double computeBadPixelPercent(InputArray GT, InputArray src, Rect ROI, int thresh=24/*1.5 pixels*/);
+
+/** @brief Function for creating a disparity map visualization (clamped CV_8U image)
+
+@param src input disparity map (CV_16S depth)
+
+@param dst output visualization
+
+@param scale disparity map will be multiplied by this value for visualization
+ */
+CV_EXPORTS_W
+void getDisparityVis(InputArray src,OutputArray dst,double scale=1.0);
+
+//! @}
+}
+}
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edge_drawing.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edge_drawing.hpp
new file mode 100644
index 00000000..6f97dd2a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edge_drawing.hpp
@@ -0,0 +1,132 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_EDGE_DRAWING_HPP__
+#define __OPENCV_EDGE_DRAWING_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+//! @addtogroup ximgproc_edge_drawing
+//! @{
+
+/** @brief Class implementing the ED (EdgeDrawing) @cite topal2012edge, EDLines @cite akinlar2011edlines, EDPF @cite akinlar2012edpf and EDCircles @cite akinlar2013edcircles algorithms
+*/
+
+class CV_EXPORTS_W EdgeDrawing : public Algorithm
+{
+public:
+
+    enum GradientOperator
+    {
+        PREWITT = 0,
+        SOBEL   = 1,
+        SCHARR  = 2,
+        LSD     = 3
+    };
+
+    struct CV_EXPORTS_W_SIMPLE Params
+    {
+        CV_WRAP Params();
+        //! Parameter Free mode will be activated when this value is set as true. Default value is false.
+        CV_PROP_RW bool PFmode;
+        /** @brief indicates the operator used for gradient calculation.
+
+        one of the flags cv::ximgproc::EdgeDrawing::GradientOperator. Default value is PREWITT
+        */
+        CV_PROP_RW int EdgeDetectionOperator;
+        //! threshold value of gradiential difference between pixels. Used to create gradient image. Default value is 20
+        CV_PROP_RW int GradientThresholdValue;
+        //! threshold value used to select anchor points. Default value is 0
+        CV_PROP_RW int AnchorThresholdValue;
+        //! Default value is 1
+        CV_PROP_RW int ScanInterval;
+        /** @brief minimun connected pixels length processed to create an edge segment.
+
+        in gradient image, minimum connected pixels length processed to create an edge segment. pixels having upper value than GradientThresholdValue
+        will be processed. Default value is 10
+        */
+        CV_PROP_RW int MinPathLength;
+        //! sigma value for internal GaussianBlur() function. Default value is 1.0
+        CV_PROP_RW float Sigma;
+        CV_PROP_RW bool SumFlag;
+        //! Default value is true. indicates if NFA (Number of False Alarms) algorithm will be used for line and ellipse validation.
+        CV_PROP_RW bool NFAValidation;
+        //! minimun line length to detect.
+        CV_PROP_RW int MinLineLength;
+        //! Default value is 6.0
+        CV_PROP_RW double MaxDistanceBetweenTwoLines;
+        //! Default value is 1.0
+        CV_PROP_RW double LineFitErrorThreshold;
+        //! Default value is 1.3
+        CV_PROP_RW double MaxErrorThreshold;
+
+        void read(const FileNode& fn);
+        void write(FileStorage& fs) const;
+    };
+
+    /** @brief Detects edges in a grayscale image and prepares them to detect lines and ellipses.
+
+    @param src 8-bit, single-channel, grayscale input image.
+    */
+    CV_WRAP virtual void detectEdges(InputArray src) = 0;
+
+    /** @brief returns Edge Image prepared by detectEdges() function.
+
+    @param dst returns 8-bit, single-channel output image.
+    */
+    CV_WRAP virtual void getEdgeImage(OutputArray dst) = 0;
+
+    /** @brief returns Gradient Image prepared by detectEdges() function.
+
+    @param dst returns 16-bit, single-channel output image.
+    */
+    CV_WRAP virtual void getGradientImage(OutputArray dst) = 0;
+
+    /** @brief Returns std::vector<std::vector<Point>> of detected edge segments, see detectEdges()
+    */
+    CV_WRAP virtual std::vector<std::vector<Point> > getSegments() = 0;
+
+    /** @brief Returns for each line found in detectLines() its edge segment index in getSegments()
+     */
+    CV_WRAP virtual std::vector<int> getSegmentIndicesOfLines() const = 0;
+
+    /** @brief Detects lines.
+
+    @param lines  output Vec<4f> contains the start point and the end point of detected lines.
+    @note you should call detectEdges() before calling this function.
+    */
+    CV_WRAP virtual void detectLines(OutputArray lines) = 0;
+
+    /** @brief Detects circles and ellipses.
+
+    @param ellipses  output Vec<6d> contains center point and perimeter for circles, center point, axes and angle for ellipses.
+    @note you should call detectEdges() before calling this function.
+    */
+    CV_WRAP virtual void detectEllipses(OutputArray ellipses) = 0;
+
+    CV_WRAP Params params;
+
+    /** @brief sets parameters.
+
+    this function is meant to be used for parameter setting in other languages than c++ like python.
+    @param parameters
+    */
+    CV_WRAP void setParams(const EdgeDrawing::Params& parameters);
+    virtual ~EdgeDrawing() { }
+};
+
+/** @brief Creates a smart pointer to a EdgeDrawing object and initializes it
+*/
+CV_EXPORTS_W Ptr<EdgeDrawing> createEdgeDrawing();
+//! @}
+
+}
+}
+
+#endif /* __OPENCV_EDGE_DRAWING_HPP__ */
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edge_filter.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edge_filter.hpp
new file mode 100644
index 00000000..82be7c71
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edge_filter.hpp
@@ -0,0 +1,528 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#ifndef __OPENCV_EDGEFILTER_HPP__
+#define __OPENCV_EDGEFILTER_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+//! @addtogroup ximgproc_filters
+//! @{
+
+enum EdgeAwareFiltersList
+{
+    DTF_NC,
+    DTF_IC,
+    DTF_RF,
+
+    GUIDED_FILTER,
+    AM_FILTER
+};
+
+
+/** @brief Interface for realizations of Domain Transform filter.
+
+For more details about this filter see @cite Gastal11 .
+ */
+class CV_EXPORTS_W DTFilter : public Algorithm
+{
+public:
+
+    /** @brief Produce domain transform filtering operation on source image.
+
+    @param src filtering image with unsigned 8-bit or floating-point 32-bit depth and up to 4 channels.
+
+    @param dst destination image.
+
+    @param dDepth optional depth of the output image. dDepth can be set to -1, which will be equivalent
+    to src.depth().
+     */
+    CV_WRAP virtual void filter(InputArray src, OutputArray dst, int dDepth = -1) = 0;
+};
+
+/** @brief Factory method, create instance of DTFilter and produce initialization routines.
+
+@param guide guided image (used to build transformed distance, which describes edge structure of
+guided image).
+
+@param sigmaSpatial \f${\sigma}_H\f$ parameter in the original article, it's similar to the sigma in the
+coordinate space into bilateralFilter.
+
+@param sigmaColor \f${\sigma}_r\f$ parameter in the original article, it's similar to the sigma in the
+color space into bilateralFilter.
+
+@param mode one form three modes DTF_NC, DTF_RF and DTF_IC which corresponds to three modes for
+filtering 2D signals in the article.
+
+@param numIters optional number of iterations used for filtering, 3 is quite enough.
+
+For more details about Domain Transform filter parameters, see the original article @cite Gastal11 and
+[Domain Transform filter homepage](http://www.inf.ufrgs.br/~eslgastal/DomainTransform/).
+ */
+CV_EXPORTS_W
+Ptr<DTFilter> createDTFilter(InputArray guide, double sigmaSpatial, double sigmaColor, int mode = DTF_NC, int numIters = 3);
+
+/** @brief Simple one-line Domain Transform filter call. If you have multiple images to filter with the same
+guided image then use DTFilter interface to avoid extra computations on initialization stage.
+
+@param guide guided image (also called as joint image) with unsigned 8-bit or floating-point 32-bit
+depth and up to 4 channels.
+@param src filtering image with unsigned 8-bit or floating-point 32-bit depth and up to 4 channels.
+@param dst destination image
+@param sigmaSpatial \f${\sigma}_H\f$ parameter in the original article, it's similar to the sigma in the
+coordinate space into bilateralFilter.
+@param sigmaColor \f${\sigma}_r\f$ parameter in the original article, it's similar to the sigma in the
+color space into bilateralFilter.
+@param mode one form three modes DTF_NC, DTF_RF and DTF_IC which corresponds to three modes for
+filtering 2D signals in the article.
+@param numIters optional number of iterations used for filtering, 3 is quite enough.
+@sa bilateralFilter, guidedFilter, amFilter
+ */
+CV_EXPORTS_W
+void dtFilter(InputArray guide, InputArray src, OutputArray dst, double sigmaSpatial, double sigmaColor, int mode = DTF_NC, int numIters = 3);
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+/** @brief Interface for realizations of Guided Filter.
+
+For more details about this filter see @cite Kaiming10 .
+ */
+class CV_EXPORTS_W GuidedFilter : public Algorithm
+{
+public:
+
+    /** @brief Apply Guided Filter to the filtering image.
+
+    @param src filtering image with any numbers of channels.
+
+    @param dst output image.
+
+    @param dDepth optional depth of the output image. dDepth can be set to -1, which will be equivalent
+    to src.depth().
+     */
+    CV_WRAP virtual void filter(InputArray src, OutputArray dst, int dDepth = -1) = 0;
+};
+
+/** @brief Factory method, create instance of GuidedFilter and produce initialization routines.
+
+@param guide guided image (or array of images) with up to 3 channels, if it have more then 3
+channels then only first 3 channels will be used.
+
+@param radius radius of Guided Filter.
+
+@param eps regularization term of Guided Filter. \f${eps}^2\f$ is similar to the sigma in the color
+space into bilateralFilter.
+
+For more details about Guided Filter parameters, see the original article @cite Kaiming10 .
+ */
+CV_EXPORTS_W Ptr<GuidedFilter> createGuidedFilter(InputArray guide, int radius, double eps);
+
+/** @brief Simple one-line Guided Filter call.
+
+If you have multiple images to filter with the same guided image then use GuidedFilter interface to
+avoid extra computations on initialization stage.
+
+@param guide guided image (or array of images) with up to 3 channels, if it have more then 3
+channels then only first 3 channels will be used.
+
+@param src filtering image with any numbers of channels.
+
+@param dst output image.
+
+@param radius radius of Guided Filter.
+
+@param eps regularization term of Guided Filter. \f${eps}^2\f$ is similar to the sigma in the color
+space into bilateralFilter.
+
+@param dDepth optional depth of the output image.
+
+@sa bilateralFilter, dtFilter, amFilter */
+CV_EXPORTS_W void guidedFilter(InputArray guide, InputArray src, OutputArray dst, int radius, double eps, int dDepth = -1);
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+/** @brief Interface for Adaptive Manifold Filter realizations.
+
+For more details about this filter see @cite Gastal12 and References_.
+
+Below listed optional parameters which may be set up with Algorithm::set function.
+-   member double sigma_s = 16.0
+Spatial standard deviation.
+-   member double sigma_r = 0.2
+Color space standard deviation.
+-   member int tree_height = -1
+Height of the manifold tree (default = -1 : automatically computed).
+-   member int num_pca_iterations = 1
+Number of iterations to computed the eigenvector.
+-   member bool adjust_outliers = false
+Specify adjust outliers using Eq. 9 or not.
+-   member bool use_RNG = true
+Specify use random number generator to compute eigenvector or not.
+ */
+class CV_EXPORTS_W AdaptiveManifoldFilter : public Algorithm
+{
+public:
+    /** @brief Apply high-dimensional filtering using adaptive manifolds.
+
+    @param src filtering image with any numbers of channels.
+
+    @param dst output image.
+
+    @param joint optional joint (also called as guided) image with any numbers of channels.
+     */
+    CV_WRAP virtual void filter(InputArray src, OutputArray dst, InputArray joint = noArray()) = 0;
+
+    CV_WRAP virtual void collectGarbage() = 0;
+
+    CV_WRAP static Ptr<AdaptiveManifoldFilter> create();
+
+    /** @see setSigmaS */
+    virtual double getSigmaS() const = 0;
+    /** @copybrief getSigmaS @see getSigmaS */
+    virtual void setSigmaS(double val) = 0;
+    /** @see setSigmaR */
+    virtual double getSigmaR() const = 0;
+    /** @copybrief getSigmaR @see getSigmaR */
+    virtual void setSigmaR(double val) = 0;
+    /** @see setTreeHeight */
+    virtual int getTreeHeight() const = 0;
+    /** @copybrief getTreeHeight @see getTreeHeight */
+    virtual void setTreeHeight(int val) = 0;
+    /** @see setPCAIterations */
+    virtual int getPCAIterations() const = 0;
+    /** @copybrief getPCAIterations @see getPCAIterations */
+    virtual void setPCAIterations(int val) = 0;
+    /** @see setAdjustOutliers */
+    virtual bool getAdjustOutliers() const = 0;
+    /** @copybrief getAdjustOutliers @see getAdjustOutliers */
+    virtual void setAdjustOutliers(bool val) = 0;
+    /** @see setUseRNG */
+    virtual bool getUseRNG() const = 0;
+    /** @copybrief getUseRNG @see getUseRNG */
+    virtual void setUseRNG(bool val) = 0;
+};
+
+/** @brief Factory method, create instance of AdaptiveManifoldFilter and produce some initialization routines.
+
+@param sigma_s spatial standard deviation.
+
+@param sigma_r color space standard deviation, it is similar to the sigma in the color space into
+bilateralFilter.
+
+@param adjust_outliers optional, specify perform outliers adjust operation or not, (Eq. 9) in the
+original paper.
+
+For more details about Adaptive Manifold Filter parameters, see the original article @cite Gastal12 .
+
+@note Joint images with CV_8U and CV_16U depth converted to images with CV_32F depth and [0; 1]
+color range before processing. Hence color space sigma sigma_r must be in [0; 1] range, unlike same
+sigmas in bilateralFilter and dtFilter functions.
+*/
+CV_EXPORTS_W Ptr<AdaptiveManifoldFilter> createAMFilter(double sigma_s, double sigma_r, bool adjust_outliers = false);
+
+/** @brief Simple one-line Adaptive Manifold Filter call.
+
+@param joint joint (also called as guided) image or array of images with any numbers of channels.
+
+@param src filtering image with any numbers of channels.
+
+@param dst output image.
+
+@param sigma_s spatial standard deviation.
+
+@param sigma_r color space standard deviation, it is similar to the sigma in the color space into
+bilateralFilter.
+
+@param adjust_outliers optional, specify perform outliers adjust operation or not, (Eq. 9) in the
+original paper.
+
+@note Joint images with CV_8U and CV_16U depth converted to images with CV_32F depth and [0; 1]
+color range before processing. Hence color space sigma sigma_r must be in [0; 1] range, unlike same
+sigmas in bilateralFilter and dtFilter functions. @sa bilateralFilter, dtFilter, guidedFilter
+*/
+CV_EXPORTS_W void amFilter(InputArray joint, InputArray src, OutputArray dst, double sigma_s, double sigma_r, bool adjust_outliers = false);
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+/** @brief Applies the joint bilateral filter to an image.
+
+@param joint Joint 8-bit or floating-point, 1-channel or 3-channel image.
+
+@param src Source 8-bit or floating-point, 1-channel or 3-channel image with the same depth as joint
+image.
+
+@param dst Destination image of the same size and type as src .
+
+@param d Diameter of each pixel neighborhood that is used during filtering. If it is non-positive,
+it is computed from sigmaSpace .
+
+@param sigmaColor Filter sigma in the color space. A larger value of the parameter means that
+farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in
+larger areas of semi-equal color.
+
+@param sigmaSpace Filter sigma in the coordinate space. A larger value of the parameter means that
+farther pixels will influence each other as long as their colors are close enough (see sigmaColor ).
+When d\>0 , it specifies the neighborhood size regardless of sigmaSpace . Otherwise, d is
+proportional to sigmaSpace .
+
+@param borderType
+
+@note bilateralFilter and jointBilateralFilter use L1 norm to compute difference between colors.
+
+@sa bilateralFilter, amFilter
+*/
+CV_EXPORTS_W
+void jointBilateralFilter(InputArray joint, InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType = BORDER_DEFAULT);
+
+/** @brief Applies the bilateral texture filter to an image. It performs structure-preserving texture filter.
+For more details about this filter see @cite Cho2014.
+
+@param src Source image whose depth is 8-bit UINT or 32-bit FLOAT
+
+@param dst Destination image of the same size and type as src.
+
+@param fr Radius of kernel to be used for filtering. It should be positive integer
+
+@param numIter Number of iterations of algorithm, It should be positive integer
+
+@param sigmaAlpha Controls the sharpness of the weight transition from edges to smooth/texture regions, where
+a bigger value means sharper transition. When the value is negative, it is automatically calculated.
+
+@param sigmaAvg Range blur parameter for texture blurring. Larger value makes result to be more blurred. When the
+value is negative, it is automatically calculated as described in the paper.
+
+@sa rollingGuidanceFilter, bilateralFilter
+*/
+CV_EXPORTS_W
+void bilateralTextureFilter(InputArray src, OutputArray dst, int fr = 3, int numIter = 1, double sigmaAlpha = -1., double sigmaAvg = -1.);
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+/** @brief Applies the rolling guidance filter to an image.
+
+For more details, please see @cite zhang2014rolling
+
+@param src Source 8-bit or floating-point, 1-channel or 3-channel image.
+
+@param dst Destination image of the same size and type as src.
+
+@param d Diameter of each pixel neighborhood that is used during filtering. If it is non-positive,
+it is computed from sigmaSpace .
+
+@param sigmaColor Filter sigma in the color space. A larger value of the parameter means that
+farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in
+larger areas of semi-equal color.
+
+@param sigmaSpace Filter sigma in the coordinate space. A larger value of the parameter means that
+farther pixels will influence each other as long as their colors are close enough (see sigmaColor ).
+When d\>0 , it specifies the neighborhood size regardless of sigmaSpace . Otherwise, d is
+proportional to sigmaSpace .
+
+@param numOfIter Number of iterations of joint edge-preserving filtering applied on the source image.
+
+@param borderType
+
+@note  rollingGuidanceFilter uses jointBilateralFilter as the edge-preserving filter.
+
+@sa jointBilateralFilter, bilateralFilter, amFilter
+*/
+CV_EXPORTS_W
+void rollingGuidanceFilter(InputArray src, OutputArray dst, int d = -1, double sigmaColor = 25, double sigmaSpace = 3, int numOfIter = 4, int borderType = BORDER_DEFAULT);
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+/** @brief Interface for implementations of Fast Bilateral Solver.
+
+For more details about this solver see @cite BarronPoole2016 .
+*/
+class CV_EXPORTS_W FastBilateralSolverFilter : public Algorithm
+{
+public:
+    /** @brief Apply smoothing operation to the source image.
+
+    @param src source image for filtering with unsigned 8-bit or signed 16-bit or floating-point 32-bit depth and up to 3 channels.
+
+    @param confidence confidence image with unsigned 8-bit or floating-point 32-bit confidence and 1 channel.
+
+    @param dst destination image.
+
+    @note Confidence images with CV_8U depth are expected to in [0, 255] and CV_32F in [0, 1] range.
+    */
+    CV_WRAP virtual void filter(InputArray src, InputArray confidence, OutputArray dst) = 0;
+};
+
+/** @brief Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines.
+
+@param guide image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.
+
+@param sigma_spatial parameter, that is similar to spatial space sigma (bandwidth) in bilateralFilter.
+
+@param sigma_luma parameter, that is similar to luma space sigma (bandwidth) in bilateralFilter.
+
+@param sigma_chroma parameter, that is similar to chroma space sigma (bandwidth) in bilateralFilter.
+
+@param lambda smoothness strength parameter for solver.
+
+@param num_iter number of iterations used for solver, 25 is usually enough.
+
+@param max_tol convergence tolerance used for solver.
+
+For more details about the Fast Bilateral Solver parameters, see the original paper @cite BarronPoole2016.
+
+*/
+CV_EXPORTS_W Ptr<FastBilateralSolverFilter> createFastBilateralSolverFilter(InputArray guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda = 128.0, int num_iter = 25, double max_tol = 1e-5);
+
+
+
+/** @brief Simple one-line Fast Bilateral Solver filter call. If you have multiple images to filter with the same
+guide then use FastBilateralSolverFilter interface to avoid extra computations.
+
+@param guide image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.
+
+@param src source image for filtering with unsigned 8-bit or signed 16-bit or floating-point 32-bit depth and up to 4 channels.
+
+@param confidence confidence image with unsigned 8-bit or floating-point 32-bit confidence and 1 channel.
+
+@param dst destination image.
+
+@param sigma_spatial parameter, that is similar to spatial space sigma (bandwidth) in bilateralFilter.
+
+@param sigma_luma parameter, that is similar to luma space sigma (bandwidth) in bilateralFilter.
+
+@param sigma_chroma parameter, that is similar to chroma space sigma (bandwidth) in bilateralFilter.
+
+@param lambda smoothness strength parameter for solver.
+
+@param num_iter number of iterations used for solver, 25 is usually enough.
+
+@param max_tol convergence tolerance used for solver.
+
+For more details about the Fast Bilateral Solver parameters, see the original paper @cite BarronPoole2016.
+
+@note Confidence images with CV_8U depth are expected to in [0, 255] and CV_32F in [0, 1] range.
+*/
+CV_EXPORTS_W void fastBilateralSolverFilter(InputArray guide, InputArray src, InputArray confidence, OutputArray dst, double sigma_spatial = 8, double sigma_luma = 8, double sigma_chroma = 8, double lambda = 128.0, int num_iter = 25, double max_tol = 1e-5);
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+/** @brief Interface for implementations of Fast Global Smoother filter.
+
+For more details about this filter see @cite Min2014 and @cite Farbman2008 .
+*/
+class CV_EXPORTS_W FastGlobalSmootherFilter : public Algorithm
+{
+public:
+    /** @brief Apply smoothing operation to the source image.
+
+    @param src source image for filtering with unsigned 8-bit or signed 16-bit or floating-point 32-bit depth and up to 4 channels.
+
+    @param dst destination image.
+    */
+    CV_WRAP virtual void filter(InputArray src, OutputArray dst) = 0;
+};
+
+/** @brief Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines.
+
+@param guide image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.
+
+@param lambda parameter defining the amount of regularization
+
+@param sigma_color parameter, that is similar to color space sigma in bilateralFilter.
+
+@param lambda_attenuation internal parameter, defining how much lambda decreases after each iteration. Normally,
+it should be 0.25. Setting it to 1.0 may lead to streaking artifacts.
+
+@param num_iter number of iterations used for filtering, 3 is usually enough.
+
+For more details about Fast Global Smoother parameters, see the original paper @cite Min2014. However, please note that
+there are several differences. Lambda attenuation described in the paper is implemented a bit differently so do not
+expect the results to be identical to those from the paper; sigma_color values from the paper should be multiplied by 255.0 to
+achieve the same effect. Also, in case of image filtering where source and guide image are the same, authors
+propose to dynamically update the guide image after each iteration. To maximize the performance this feature
+was not implemented here.
+*/
+CV_EXPORTS_W Ptr<FastGlobalSmootherFilter> createFastGlobalSmootherFilter(InputArray guide, double lambda, double sigma_color, double lambda_attenuation=0.25, int num_iter=3);
+
+/** @brief Simple one-line Fast Global Smoother filter call. If you have multiple images to filter with the same
+guide then use FastGlobalSmootherFilter interface to avoid extra computations.
+
+@param guide image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.
+
+@param src source image for filtering with unsigned 8-bit or signed 16-bit or floating-point 32-bit depth and up to 4 channels.
+
+@param dst destination image.
+
+@param lambda parameter defining the amount of regularization
+
+@param sigma_color parameter, that is similar to color space sigma in bilateralFilter.
+
+@param lambda_attenuation internal parameter, defining how much lambda decreases after each iteration. Normally,
+it should be 0.25. Setting it to 1.0 may lead to streaking artifacts.
+
+@param num_iter number of iterations used for filtering, 3 is usually enough.
+*/
+CV_EXPORTS_W void fastGlobalSmootherFilter(InputArray guide, InputArray src, OutputArray dst, double lambda, double sigma_color, double lambda_attenuation=0.25, int num_iter=3);
+
+/** @brief Global image smoothing via L0 gradient minimization.
+
+@param src source image for filtering with unsigned 8-bit or signed 16-bit or floating-point depth.
+
+@param dst destination image.
+
+@param lambda parameter defining the smooth term weight.
+
+@param kappa parameter defining the increasing factor of the weight of the gradient data term.
+
+For more details about L0 Smoother, see the original paper @cite xu2011image.
+*/
+CV_EXPORTS_W void l0Smooth(InputArray src, OutputArray dst, double lambda = 0.02, double kappa = 2.0);
+//! @}
+}
+}
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edgeboxes.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edgeboxes.hpp
new file mode 100644
index 00000000..966f9cd0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edgeboxes.hpp
@@ -0,0 +1,201 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_EDGEBOXES_HPP__
+#define __OPENCV_EDGEBOXES_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+//! @addtogroup ximgproc_edgeboxes
+//! @{
+
+// bounding box data structures
+typedef struct
+{
+  int x, y, w, h;
+  float score;
+} Box;
+
+typedef std::vector<Box> Boxes;
+
+/** @brief Class implementing EdgeBoxes algorithm from @cite ZitnickECCV14edgeBoxes :
+ */
+class CV_EXPORTS_W EdgeBoxes : public Algorithm
+{
+
+public:
+
+    /** @brief Returns array containing proposal boxes.
+
+    @param edge_map edge image.
+    @param orientation_map orientation map.
+    @param boxes proposal boxes.
+    @param scores of the proposal boxes, provided a vector of float types.
+    */
+    CV_WRAP virtual void getBoundingBoxes(InputArray edge_map, InputArray orientation_map, CV_OUT std::vector<Rect> &boxes, OutputArray scores = noArray()) = 0;
+
+    /** @brief Returns the step size of sliding window search.
+    */
+    CV_WRAP virtual float getAlpha() const = 0;
+    /** @brief Sets the step size of sliding window search.
+    */
+    CV_WRAP virtual void setAlpha(float value) = 0;
+
+    /** @brief Returns the nms threshold for object proposals.
+    */
+    CV_WRAP virtual float getBeta() const = 0;
+    /** @brief Sets the nms threshold for object proposals.
+    */
+    CV_WRAP virtual void setBeta(float value) = 0;
+
+    /** @brief Returns adaptation rate for nms threshold.
+    */
+    CV_WRAP virtual float getEta() const = 0;
+    /** @brief Sets the adaptation rate for nms threshold.
+    */
+    CV_WRAP virtual void setEta(float value) = 0;
+
+    /** @brief Returns the min score of boxes to detect.
+    */
+    CV_WRAP virtual float getMinScore() const = 0;
+    /** @brief Sets the min score of boxes to detect.
+    */
+    CV_WRAP virtual void setMinScore(float value) = 0;
+
+    /** @brief Returns the max number of boxes to detect.
+    */
+    CV_WRAP virtual int getMaxBoxes() const = 0;
+    /** @brief Sets max number of boxes to detect.
+    */
+    CV_WRAP virtual void setMaxBoxes(int value) = 0;
+
+    /** @brief Returns the edge min magnitude.
+    */
+    CV_WRAP virtual float getEdgeMinMag() const = 0;
+    /** @brief Sets the edge min magnitude.
+    */
+    CV_WRAP virtual void setEdgeMinMag(float value) = 0;
+
+    /** @brief Returns the edge merge threshold.
+    */
+    CV_WRAP virtual float getEdgeMergeThr() const = 0;
+    /** @brief Sets the edge merge threshold.
+    */
+    CV_WRAP virtual void setEdgeMergeThr(float value) = 0;
+
+    /** @brief Returns the cluster min magnitude.
+    */
+    CV_WRAP virtual float getClusterMinMag() const = 0;
+    /** @brief Sets the cluster min magnitude.
+    */
+    CV_WRAP virtual void setClusterMinMag(float value) = 0;
+
+    /** @brief Returns the max aspect ratio of boxes.
+    */
+    CV_WRAP virtual float getMaxAspectRatio() const = 0;
+    /** @brief Sets the max aspect ratio of boxes.
+    */
+    CV_WRAP virtual void setMaxAspectRatio(float value) = 0;
+
+    /** @brief Returns the minimum area of boxes.
+    */
+    CV_WRAP virtual float getMinBoxArea() const = 0;
+    /** @brief Sets the minimum area of boxes.
+    */
+    CV_WRAP virtual void setMinBoxArea(float value) = 0;
+
+    /** @brief Returns the affinity sensitivity.
+    */
+    CV_WRAP virtual float getGamma() const = 0;
+    /** @brief Sets the affinity sensitivity
+    */
+    CV_WRAP virtual void setGamma(float value) = 0;
+
+    /** @brief Returns the scale sensitivity.
+    */
+    CV_WRAP virtual float getKappa() const = 0;
+    /** @brief Sets the scale sensitivity.
+    */
+    CV_WRAP virtual void setKappa(float value) = 0;
+
+};
+
+/** @brief Creates a Edgeboxes
+
+@param alpha step size of sliding window search.
+@param beta nms threshold for object proposals.
+@param eta adaptation rate for nms threshold.
+@param minScore min score of boxes to detect.
+@param maxBoxes max number of boxes to detect.
+@param edgeMinMag edge min magnitude. Increase to trade off accuracy for speed.
+@param edgeMergeThr edge merge threshold. Increase to trade off accuracy for speed.
+@param clusterMinMag cluster min magnitude. Increase to trade off accuracy for speed.
+@param maxAspectRatio max aspect ratio of boxes.
+@param minBoxArea minimum area of boxes.
+@param gamma affinity sensitivity.
+@param kappa scale sensitivity.
+*/
+CV_EXPORTS_W Ptr<EdgeBoxes>
+createEdgeBoxes(float alpha=0.65f,
+                float beta=0.75f,
+                float eta=1,
+                float minScore=0.01f,
+                int   maxBoxes=10000,
+                float edgeMinMag=0.1f,
+                float edgeMergeThr=0.5f,
+                float clusterMinMag=0.5f,
+                float maxAspectRatio=3,
+                float minBoxArea=1000,
+                float gamma=2,
+                float kappa=1.5f);
+
+//! @}
+
+}
+}
+
+#endif /* __OPENCV_EDGEBOXES_HPP__ */
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edgepreserving_filter.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edgepreserving_filter.hpp
new file mode 100644
index 00000000..f5685ce3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/edgepreserving_filter.hpp
@@ -0,0 +1,33 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_EDGEPRESERVINGFILTER_HPP__
+#define __OPENCV_EDGEPRESERVINGFILTER_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv { namespace ximgproc {
+
+//! @addtogroup ximgproc
+//! @{
+
+    /**
+    * @brief Smoothes an image using the Edge-Preserving filter.
+    *
+    * The function smoothes Gaussian noise as well as salt & pepper noise.
+    * For more details about this implementation, please see
+    * [ReiWoe18]  Reich, S. and Wörgötter, F. and Dellen, B. (2018). A Real-Time Edge-Preserving Denoising Filter. Proceedings of the 13th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications (VISIGRAPP): Visapp, 85-94, 4. DOI: 10.5220/0006509000850094.
+    *
+    * @param src Source 8-bit 3-channel image.
+    * @param dst Destination image of the same size and type as src.
+    * @param d Diameter of each pixel neighborhood that is used during filtering. Must be greater or equal 3.
+    * @param threshold Threshold, which distinguishes between noise, outliers, and data.
+    */
+    CV_EXPORTS_W void edgePreservingFilter( InputArray src, OutputArray dst, int d, double threshold );
+
+}} // namespace
+
+//! @}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/estimated_covariance.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/estimated_covariance.hpp
new file mode 100644
index 00000000..e4f5ddfc
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/estimated_covariance.hpp
@@ -0,0 +1,82 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+
+Algorithmic details of this algorithm can be found at:
+ * O. Green, Y. Birk, "A Computationally Efficient Algorithm for the 2D Covariance Method", ACM/IEEE International Conference on High Performance Computing, Networking, Storage and Analysis, Denver, Colorado, 2013
+A previous and less efficient version of the algorithm can be found:
+ * O. Green, L. David, A. Galperin, Y. Birk, "Efficient parallel computation of the estimated covariance matrix", arXiv, 2013
+
+
+*/
+#ifndef __OPENCV_ESTIMATECOVARIANCE_HPP__
+#define __OPENCV_ESTIMATECOVARIANCE_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+/** @brief Computes the estimated covariance matrix of an image using the sliding
+window forumlation.
+
+@param src The source image. Input image must be of a complex type.
+@param dst The destination estimated covariance matrix. Output matrix will be size (windowRows*windowCols, windowRows*windowCols).
+@param windowRows The number of rows in the window.
+@param windowCols The number of cols in the window.
+The window size parameters control the accuracy of the estimation.
+The sliding window moves over the entire image from the top-left corner
+to the bottom right corner. Each location of the window represents a sample.
+If the window is the size of the image, then this gives the exact covariance matrix.
+For all other cases, the sizes of the window will impact the number of samples
+and the number of elements in the estimated covariance matrix.
+*/
+
+CV_EXPORTS_W void covarianceEstimation(InputArray src, OutputArray dst, int windowRows, int windowCols);
+
+}
+}
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/fast_hough_transform.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/fast_hough_transform.hpp
new file mode 100644
index 00000000..adfbf543
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/fast_hough_transform.hpp
@@ -0,0 +1,164 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2015, Smart Engines Ltd, all rights reserved.
+// Copyright (C) 2015, Institute for Information Transmission Problems of the Russian Academy of Sciences (Kharkevich Institute), all rights reserved.
+// Copyright (C) 2015, Dmitry Nikolaev, Simon Karpenko, Michail Aliev, Elena Kuznetsova, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_FAST_HOUGH_TRANSFORM_HPP__
+#define __OPENCV_FAST_HOUGH_TRANSFORM_HPP__
+#ifdef __cplusplus
+
+#include "opencv2/core.hpp"
+
+
+namespace cv { namespace ximgproc {
+
+/**
+* @brief   Specifies the part of Hough space to calculate
+* @details The enum specifies the part of Hough space to calculate. Each
+* member specifies primarily direction of lines (horizontal or vertical)
+* and the direction of angle changes.
+* Direction of angle changes is from multiples of 90 to odd multiples of 45.
+* The image considered to be written top-down and left-to-right.
+* Angles are started from vertical line and go clockwise.
+* Separate quarters and halves are written in orientation they should be in
+* full Hough space.
+*/
+enum AngleRangeOption
+{
+  ARO_0_45    = 0, //< Vertical primarily direction and clockwise angle changes
+  ARO_45_90   = 1, //< Horizontal primarily direction and counterclockwise angle changes
+  ARO_90_135  = 2, //< Horizontal primarily direction and clockwise angle changes
+  ARO_315_0   = 3, //< Vertical primarily direction and counterclockwise angle changes
+  ARO_315_45  = 4, //< Vertical primarily direction
+  ARO_45_135  = 5, //< Horizontal primarily direction
+  ARO_315_135 = 6, //< Full set of directions
+  ARO_CTR_HOR = 7, //< 90 +/- atan(0.5), interval approximately from 64.5 to 116.5 degrees.
+                   //< It is used for calculating Fast Hough Transform for images skewed by atan(0.5).
+  ARO_CTR_VER = 8  //< +/- atan(0.5), interval approximately from 333.5(-26.5) to 26.5 degrees
+                   //< It is used for calculating Fast Hough Transform for images skewed by atan(0.5).
+};
+
+/**
+ * @brief   Specifies binary operations.
+ * @details The enum specifies binary operations, that is such ones which involve
+ *          two operands. Formally, a binary operation @f$ f @f$ on a set @f$ S @f$
+ *          is a binary relation that maps elements of the Cartesian product
+ *          @f$ S \times S @f$ to @f$ S @f$:
+*           @f[ f: S \times S \to S @f]
+ * @ingroup MinUtils_MathOper
+ */
+enum HoughOp
+{
+  FHT_MIN = 0,  //< Binary minimum operation. The constant specifies the binary minimum operation
+                //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = \min(x, y) @f]
+  FHT_MAX = 1,  //< Binary maximum operation. The constant specifies the binary maximum operation
+                //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = \max(x, y) @f]
+  FHT_ADD = 2,  //< Binary addition operation. The constant specifies the binary addition operation
+                //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = x + y @f]
+  FHT_AVE = 3   //< Binary average operation. The constant specifies the binary average operation
+                //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = \frac{x + y}{2} @f]
+};
+
+/**
+* @brief   Specifies to do or not to do skewing of Hough transform image
+* @details The enum specifies to do or not to do skewing of Hough transform image
+* so it would be no cycling in Hough transform image through borders of image.
+*/
+enum HoughDeskewOption
+{
+  HDO_RAW    = 0, //< Use raw cyclic image
+  HDO_DESKEW = 1  //< Prepare deskewed image
+};
+
+/**
+ * @brief   Specifies the degree of rules validation.
+ * @details The enum specifies the degree of rules validation. This can be used,
+ *          for example, to choose a proper way of input arguments validation.
+ */
+typedef enum {
+  RO_STRICT          = 0x00,  ///< Validate each rule in a proper way.
+  RO_IGNORE_BORDERS  = 0x01,  ///< Skip validations of image borders.
+} RulesOption;
+
+/**
+* @brief   Calculates 2D Fast Hough transform of an image.
+* @param   dst         The destination image, result of transformation.
+* @param   src         The source (input) image.
+* @param   dstMatDepth The depth of destination image
+* @param   op          The operation to be applied, see cv::HoughOp
+* @param   angleRange  The part of Hough space to calculate, see cv::AngleRangeOption
+* @param   makeSkew    Specifies to do or not to do image skewing, see cv::HoughDeskewOption
+*
+* The function calculates the fast Hough transform for full, half or quarter
+* range of angles.
+*/
+CV_EXPORTS_W void FastHoughTransform( InputArray  src,
+                                      OutputArray dst,
+                                      int         dstMatDepth,
+                                      int         angleRange = ARO_315_135,
+                                      int         op = FHT_ADD,
+                                      int         makeSkew = HDO_DESKEW );
+
+/**
+* @brief   Calculates coordinates of line segment corresponded by point in Hough space.
+* @param   houghPoint  Point in Hough space.
+* @param   srcImgInfo The source (input) image of Hough transform.
+* @param   angleRange  The part of Hough space where point is situated, see cv::AngleRangeOption
+* @param   makeSkew    Specifies to do or not to do image skewing, see cv::HoughDeskewOption
+* @param   rules       Specifies strictness of line segment calculating, see cv::RulesOption
+* @retval  [Vec4i]     Coordinates of line segment corresponded by point in Hough space.
+* @remarks If rules parameter set to RO_STRICT
+           then returned line cut along the border of source image.
+* @remarks If rules parameter set to RO_WEAK then in case of point, which belongs
+           the incorrect part of Hough image, returned line will not intersect source image.
+*
+* The function calculates coordinates of line segment corresponded by point in Hough space.
+*/
+CV_EXPORTS_W Vec4i HoughPoint2Line(const Point &houghPoint,
+                                   InputArray  srcImgInfo,
+                                   int         angleRange = ARO_315_135,
+                                   int         makeSkew = HDO_DESKEW,
+                                   int         rules = RO_IGNORE_BORDERS );
+
+} }// namespace cv::ximgproc
+
+#endif //__cplusplus
+#endif //__OPENCV_FAST_HOUGH_TRANSFORM_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/fast_line_detector.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/fast_line_detector.hpp
new file mode 100644
index 00000000..234cc8a3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/fast_line_detector.hpp
@@ -0,0 +1,79 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_FAST_LINE_DETECTOR_HPP__
+#define __OPENCV_FAST_LINE_DETECTOR_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+//! @addtogroup ximgproc_fast_line_detector
+//! @{
+
+/** @brief Class implementing the FLD (Fast Line Detector) algorithm described
+in @cite Lee14 .
+*/
+
+//! @include samples/fld_lines.cpp
+
+class CV_EXPORTS_W FastLineDetector : public Algorithm
+{
+public:
+    /** @example fld_lines.cpp
+      An example using the FastLineDetector
+      */
+    /** @brief Finds lines in the input image.
+      This is the output of the default parameters of the algorithm on the above
+      shown image.
+
+      ![image](pics/corridor_fld.jpg)
+
+      @param image A grayscale (CV_8UC1) input image. If only a roi needs to be
+      selected, use: `fld_ptr-\>detect(image(roi), lines, ...);
+      lines += Scalar(roi.x, roi.y, roi.x, roi.y);`
+      @param lines A vector of Vec4f elements specifying the beginning
+      and ending point of a line.  Where Vec4f is (x1, y1, x2, y2), point
+      1 is the start, point 2 - end. Returned lines are directed so that the
+      brighter side is on their left.
+      */
+    CV_WRAP virtual void detect(InputArray image, OutputArray lines) = 0;
+
+    /** @brief Draws the line segments on a given image.
+      @param image The image, where the lines will be drawn. Should be bigger
+      or equal to the image, where the lines were found.
+      @param lines A vector of the lines that needed to be drawn.
+      @param draw_arrow If true, arrow heads will be drawn.
+      @param linecolor Line color.
+      @param linethickness Line thickness.
+      */
+    CV_WRAP virtual void drawSegments(InputOutputArray image, InputArray lines,
+            bool draw_arrow = false, Scalar linecolor = Scalar(0, 0, 255), int linethickness = 1) = 0;
+
+    virtual ~FastLineDetector() { }
+};
+
+/** @brief Creates a smart pointer to a FastLineDetector object and initializes it
+
+@param length_threshold    Segment shorter than this will be discarded
+@param distance_threshold  A point placed from a hypothesis line
+                           segment farther than this will be regarded as an outlier
+@param canny_th1           First threshold for hysteresis procedure in Canny()
+@param canny_th2           Second threshold for hysteresis procedure in Canny()
+@param canny_aperture_size Aperturesize for the sobel operator in Canny().
+                           If zero, Canny() is not applied and the input image is taken as an edge image.
+@param do_merge            If true, incremental merging of segments will be performed
+*/
+CV_EXPORTS_W Ptr<FastLineDetector> createFastLineDetector(
+        int length_threshold = 10, float distance_threshold = 1.414213562f,
+        double canny_th1 = 50.0, double canny_th2 = 50.0, int canny_aperture_size = 3,
+        bool do_merge = false);
+
+//! @} ximgproc_fast_line_detector
+}
+}
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/find_ellipses.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/find_ellipses.hpp
new file mode 100644
index 00000000..cc4d0fd9
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/find_ellipses.hpp
@@ -0,0 +1,38 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_FIND_ELLIPSES_HPP__
+#define __OPENCV_FIND_ELLIPSES_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace ximgproc {
+
+//! @addtogroup ximgproc
+//! @{
+
+/**
+@brief Finds ellipses fastly in an image using projective invariant pruning.
+*
+* The function detects ellipses in images using projective invariant pruning.
+* For more details about this implementation, please see @cite jia2017fast
+* Jia, Qi et al, (2017).
+* A Fast Ellipse Detector using Projective Invariant Pruning. IEEE Transactions on Image Processing.
+*
+@param image input image, could be gray or color.
+@param ellipses output vector of found ellipses. each vector is encoded as five float $x, y, a, b, radius, score$.
+@param scoreThreshold float, the threshold of ellipse score.
+@param reliabilityThreshold float, the threshold of reliability.
+@param centerDistanceThreshold float, the threshold of center distance.
+*/
+CV_EXPORTS_W void findEllipses(
+    InputArray image, OutputArray ellipses,
+    float scoreThreshold = 0.7f, float reliabilityThreshold = 0.5f,
+    float centerDistanceThreshold = 0.05f
+);
+//! @} ximgproc
+}
+}
+#endif
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/fourier_descriptors.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/fourier_descriptors.hpp
new file mode 100644
index 00000000..969a33d7
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/fourier_descriptors.hpp
@@ -0,0 +1,119 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_FOURIERDESCRIPTORS_HPP__
+#define __OPENCV_FOURIERDESCRIPTORS_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace ximgproc {
+
+    //! @addtogroup ximgproc_fourier
+    //! @{
+
+    /** @brief Class for ContourFitting algorithms.
+    ContourFitting match two contours \f$ z_a \f$ and \f$ z_b \f$ minimizing distance
+    \f[ d(z_a,z_b)=\sum (a_n - s  b_n e^{j(n \alpha +\phi )})^2 \f] where \f$ a_n \f$ and \f$ b_n \f$ are Fourier descriptors of \f$ z_a \f$ and \f$ z_b \f$ and s is a scaling factor and  \f$ \phi \f$ is angle rotation and \f$ \alpha \f$ is starting point factor adjustement
+    */
+    class CV_EXPORTS_W ContourFitting : public Algorithm
+    {
+        int ctrSize;
+        int fdSize;
+        std::vector<std::complex<double> > b;
+        std::vector<std::complex<double> > a;
+        std::vector<double> frequence;
+        std::vector<double> rho, psi;
+        void frequencyInit();
+        void fAlpha(double x, double &fn, double &df);
+        double distance(std::complex<double> r, double alpha);
+        double  newtonRaphson(double x1, double x2);
+    public:
+        /** @brief Fit two closed curves using fourier descriptors. More details in @cite PersoonFu1977 and @cite BergerRaghunathan1998
+
+        * @param ctr number of Fourier descriptors equal to number of contour points after resampling.
+        * @param fd Contour defining second shape (Target).
+        */
+        ContourFitting(int ctr=1024,int fd=16):ctrSize(ctr),fdSize(fd){};
+        /** @brief Fit two closed curves using fourier descriptors. More details in @cite PersoonFu1977 and @cite BergerRaghunathan1998
+
+        @param src Contour defining first shape.
+        @param dst Contour defining second shape (Target).
+        @param alphaPhiST : \f$ \alpha \f$=alphaPhiST(0,0), \f$ \phi \f$=alphaPhiST(0,1) (in radian), s=alphaPhiST(0,2), Tx=alphaPhiST(0,3), Ty=alphaPhiST(0,4) rotation center
+        @param dist distance between src and dst after matching.
+        @param fdContour false then src and dst are contours and true src and dst are fourier descriptors.
+        */
+        void estimateTransformation(InputArray src, InputArray dst, OutputArray alphaPhiST, double *dist = 0, bool fdContour = false);
+        /** @brief Fit two closed curves using fourier descriptors. More details in @cite PersoonFu1977 and @cite BergerRaghunathan1998
+
+        @param src Contour defining first shape.
+        @param dst Contour defining second shape (Target).
+        @param alphaPhiST : \f$ \alpha \f$=alphaPhiST(0,0), \f$ \phi \f$=alphaPhiST(0,1) (in radian), s=alphaPhiST(0,2), Tx=alphaPhiST(0,3), Ty=alphaPhiST(0,4) rotation center
+        @param dist distance between src and dst after matching.
+        @param fdContour false then src and dst are contours and true src and dst are fourier descriptors.
+        */
+        CV_WRAP void estimateTransformation(InputArray src, InputArray dst, OutputArray alphaPhiST, CV_OUT double &dist , bool fdContour = false);
+        /** @brief set number of Fourier descriptors used in estimateTransformation
+
+        @param n number of Fourier descriptors equal to number of contour points after resampling.
+        */
+        CV_WRAP void setCtrSize(int n);
+        /** @brief set number of Fourier descriptors when estimateTransformation used vector<Point>
+
+        @param n number of fourier descriptors used for optimal curve matching.
+        */
+        CV_WRAP void setFDSize(int n);
+        /**
+        @returns number of fourier descriptors
+        */
+        CV_WRAP int getCtrSize() { return ctrSize; };
+        /**
+        @returns number of fourier descriptors used for optimal curve matching
+        */
+        CV_WRAP int getFDSize() { return fdSize; };
+    };
+    /**
+    * @brief   Fourier descriptors for planed closed curves
+    *
+    * For more details about this implementation, please see @cite PersoonFu1977
+    *
+    * @param   src   contour type vector<Point> , vector<Point2f>  or vector<Point2d>
+    * @param   dst   Mat of type CV_64FC2 and nbElt rows A VERIFIER
+    * @param   nbElt number of rows in dst or getOptimalDFTSize rows if nbElt=-1
+    * @param   nbFD number of FD return in dst dst = [FD(1...nbFD/2) FD(nbFD/2-nbElt+1...:nbElt)]
+    *
+    */
+    CV_EXPORTS_W void fourierDescriptor(InputArray src, OutputArray dst, int nbElt=-1,int nbFD=-1);
+    /**
+    * @brief   transform a contour
+    *
+    * @param   src   contour or Fourier Descriptors if fd is true
+    * @param   t   transform Mat given by estimateTransformation
+    * @param   dst   Mat of type CV_64FC2 and nbElt rows
+    * @param   fdContour true src are Fourier Descriptors. fdContour false src is a contour
+    *
+    */
+    CV_EXPORTS_W void transformFD(InputArray src, InputArray t,OutputArray dst, bool fdContour=true);
+    /**
+    * @brief   Contour sampling .
+    *
+    * @param   src   contour type vector<Point> , vector<Point2f>  or vector<Point2d>
+    * @param   out   Mat of type CV_64FC2 and nbElt rows
+    * @param   nbElt number of points in out contour
+    *
+    */
+    CV_EXPORTS_W void contourSampling(InputArray src, OutputArray out, int nbElt);
+
+    /**
+    * @brief create ContourFitting algorithm object
+    *
+    * @param ctr number of Fourier descriptors equal to number of contour points after resampling.
+    * @param fd Contour defining second shape (Target).
+    */
+    CV_EXPORTS_W Ptr<ContourFitting> createContourFitting(int ctr = 1024, int fd = 16);
+
+    //! @} ximgproc_fourier
+}
+}
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/lsc.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/lsc.hpp
new file mode 100644
index 00000000..c0e249c3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/lsc.hpp
@@ -0,0 +1,157 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2014, 2015
+ * Zhengqin Li <li-zq12 at mails dot tsinghua dot edu dot cn>
+ * Jiansheng Chen <jschenthu at mail dot tsinghua dot edu dot cn>
+ * Tsinghua University
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the copyright holders nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+/*
+
+ "Superpixel Segmentation using Linear Spectral Clustering"
+ Zhengqin Li, Jiansheng Chen, IEEE Conference on Computer Vision and Pattern
+ Recognition (CVPR), Jun. 2015
+
+ OpenCV port by: Cristian Balint <cristian dot balint at gmail dot com>
+ */
+
+#ifndef __OPENCV_LSC_HPP__
+#define __OPENCV_LSC_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+//! @addtogroup ximgproc_superpixel
+//! @{
+
+/** @brief Class implementing the LSC (Linear Spectral Clustering) superpixels
+algorithm described in @cite LiCVPR2015LSC.
+
+LSC (Linear Spectral Clustering) produces compact and uniform superpixels with low
+computational costs. Basically, a normalized cuts formulation of the superpixel
+segmentation is adopted based on a similarity metric that measures the color
+similarity and space proximity between image pixels. LSC is of linear computational
+complexity and high memory efficiency and is able to preserve global properties of images
+
+ */
+
+class CV_EXPORTS_W SuperpixelLSC : public Algorithm
+{
+public:
+
+    /** @brief Calculates the actual amount of superpixels on a given segmentation computed
+    and stored in SuperpixelLSC object.
+     */
+    CV_WRAP virtual int getNumberOfSuperpixels() const = 0;
+
+    /** @brief Calculates the superpixel segmentation on a given image with the initialized
+    parameters in the SuperpixelLSC object.
+
+    This function can be called again without the need of initializing the algorithm with
+    createSuperpixelLSC(). This save the computational cost of allocating memory for all the
+    structures of the algorithm.
+
+    @param num_iterations Number of iterations. Higher number improves the result.
+
+    The function computes the superpixels segmentation of an image with the parameters initialized
+    with the function createSuperpixelLSC(). The algorithms starts from a grid of superpixels and
+    then refines the boundaries by proposing updates of edges boundaries.
+
+     */
+    CV_WRAP virtual void iterate( int num_iterations = 10 ) = 0;
+
+    /** @brief Returns the segmentation labeling of the image.
+
+    Each label represents a superpixel, and each pixel is assigned to one superpixel label.
+
+    @param labels_out Return: A CV_32SC1 integer array containing the labels of the superpixel
+    segmentation. The labels are in the range [0, getNumberOfSuperpixels()].
+
+    The function returns an image with the labels of the superpixel segmentation. The labels are in
+    the range [0, getNumberOfSuperpixels()].
+     */
+    CV_WRAP virtual void getLabels( OutputArray labels_out ) const = 0;
+
+    /** @brief Returns the mask of the superpixel segmentation stored in SuperpixelLSC object.
+
+    @param image Return: CV_8U1 image mask where -1 indicates that the pixel is a superpixel border,
+    and 0 otherwise.
+
+    @param thick_line If false, the border is only one pixel wide, otherwise all pixels at the border
+    are masked.
+
+    The function return the boundaries of the superpixel segmentation.
+     */
+    CV_WRAP virtual void getLabelContourMask( OutputArray image, bool thick_line = true ) const = 0;
+
+    /** @brief Enforce label connectivity.
+
+    @param min_element_size The minimum element size in percents that should be absorbed into a bigger
+    superpixel. Given resulted average superpixel size valid value should be in 0-100 range, 25 means
+    that less then a quarter sized superpixel should be absorbed, this is default.
+
+    The function merge component that is too small, assigning the previously found adjacent label
+    to this component. Calling this function may change the final number of superpixels.
+     */
+    CV_WRAP virtual void enforceLabelConnectivity( int min_element_size = 25 ) = 0;
+
+
+};
+
+/** @brief Class implementing the LSC (Linear Spectral Clustering) superpixels
+
+@param image Image to segment
+@param region_size Chooses an average superpixel size measured in pixels
+@param ratio Chooses the enforcement of superpixel compactness factor of superpixel
+
+The function initializes a SuperpixelLSC object for the input image. It sets the parameters of
+superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
+computing iterations over the given image. An example of LSC is ilustrated in the following picture.
+For enanched results it is recommended for color images to preprocess image with little gaussian blur
+with a small 3 x 3 kernel and additional conversion into CieLAB color space.
+
+![image](pics/superpixels_lsc.png)
+
+ */
+
+    CV_EXPORTS_W Ptr<SuperpixelLSC> createSuperpixelLSC( InputArray image, int region_size = 10, float ratio = 0.075f );
+
+//! @}
+
+}
+}
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/paillou_filter.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/paillou_filter.hpp
new file mode 100644
index 00000000..03754a11
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/paillou_filter.hpp
@@ -0,0 +1,67 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#ifndef __OPENCV_PAILLOUFILTER_HPP__
+#define __OPENCV_PAILLOUFILTER_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace ximgproc {
+
+//! @addtogroup ximgproc_filters
+//! @{
+
+/**
+* @brief   Applies Paillou filter to an image.
+*
+* For more details about this implementation, please see @cite paillou1997detecting
+*
+* @param   op          Source CV_8U(S) or CV_16U(S), 1-channel or 3-channels image.
+* @param   _dst        result CV_32F image with same number of channel than op.
+* @param   omega double see paper
+* @param   alpha double see paper
+*
+* @sa GradientPaillouX, GradientPaillouY
+*/
+CV_EXPORTS void GradientPaillouY(InputArray op, OutputArray _dst, double alpha, double omega);
+CV_EXPORTS void GradientPaillouX(InputArray op, OutputArray _dst, double alpha, double omega);
+
+}
+}
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/peilin.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/peilin.hpp
new file mode 100644
index 00000000..1b224aaf
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/peilin.hpp
@@ -0,0 +1,32 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_PEILIN_HPP__
+#define __OPENCV_PEILIN_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv { namespace ximgproc {
+
+    //! @addtogroup ximgproc
+    //! @{
+
+    /**
+    * @brief   Calculates an affine transformation that normalize given image using Pei&Lin Normalization.
+    *
+    * Assume given image \f$I=T(\bar{I})\f$ where \f$\bar{I}\f$ is a normalized image and \f$T\f$ is an affine transformation distorting this image by translation, rotation, scaling and skew.
+    * The function returns an affine transformation matrix corresponding to the transformation \f$T^{-1}\f$ described in [PeiLin95].
+    * For more details about this implementation, please see
+    * [PeiLin95] Soo-Chang Pei and Chao-Nan Lin. Image normalization for pattern recognition. Image and Vision Computing, Vol. 13, N.10, pp. 711-723, 1995.
+    *
+    * @param I Given transformed image.
+    * @return Transformation matrix corresponding to inversed image transformation
+    */
+    CV_EXPORTS Matx23d PeiLinNormalization ( InputArray I );
+    /** @overload */
+    CV_EXPORTS_W void PeiLinNormalization ( InputArray I, OutputArray T );
+
+}} // namespace
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/radon_transform.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/radon_transform.hpp
new file mode 100644
index 00000000..059d0c05
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/radon_transform.hpp
@@ -0,0 +1,40 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_RADON_TRANSFORM_HPP__
+#define __OPENCV_RADON_TRANSFORM_HPP__
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+
+namespace cv { namespace ximgproc {
+/**
+* @brief   Calculate Radon Transform of an image.
+* @param   src         The source (input) image.
+* @param   dst         The destination image, result of transformation.
+* @param   theta       Angle resolution of the transform in degrees.
+* @param   start_angle Start angle of the transform in degrees.
+* @param   end_angle   End angle of the transform in degrees.
+* @param   crop        Crop the source image into a circle.
+* @param   norm        Normalize the output Mat to grayscale and convert type to CV_8U
+*
+* This function calculates the Radon Transform of a given image in any range.
+* See https://engineering.purdue.edu/~malcolm/pct/CTI_Ch03.pdf for detail.
+* If the input type is CV_8U, the output will be CV_32S.
+* If the input type is CV_32F or CV_64F, the output will be CV_64F
+* The output size will be num_of_integral x src_diagonal_length.
+* If crop is selected, the input image will be crop into square then circle,
+* and output size will be num_of_integral x min_edge.
+*
+*/
+CV_EXPORTS_W void RadonTransform(InputArray src,
+                                      OutputArray dst,
+                                      double theta = 1,
+                                      double start_angle = 0,
+                                      double end_angle = 180,
+                                      bool crop = false,
+                                      bool norm = false);
+} }
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/ridgefilter.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/ridgefilter.hpp
new file mode 100644
index 00000000..7f21e730
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/ridgefilter.hpp
@@ -0,0 +1,53 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+Ridge Detection Filter.
+OpenCV port by : Kushal Vyas (@kushalvyas), Venkatesh Vijaykumar(@venkateshvijaykumar)
+Adapted from Niki Estner's explanation of RidgeFilter.
+*/
+
+#ifndef __OPENCV_XIMGPROC_RIDGEFILTER_HPP__
+#define __OPENCV_XIMGPROC_RIDGEFILTER_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv { namespace ximgproc {
+
+//! @addtogroup ximgproc_filters
+//! @{
+
+/** @brief  Applies Ridge Detection Filter to an input image.
+Implements Ridge detection similar to the one in [Mathematica](http://reference.wolfram.com/language/ref/RidgeFilter.html)
+using the eigen values from the Hessian Matrix of the input image using Sobel Derivatives.
+Additional refinement can be done using Skeletonization and Binarization. Adapted from @cite segleafvein and @cite M_RF
+
+*/
+class CV_EXPORTS_W RidgeDetectionFilter : public Algorithm
+{
+public:
+    /**
+    @brief Create pointer to the Ridge detection filter.
+    @param ddepth  Specifies output image depth. Defualt is CV_32FC1
+    @param dx Order of derivative x, default is 1
+    @param dy  Order of derivative y, default is 1
+    @param ksize Sobel kernel size , default is 3
+    @param out_dtype Converted format for output, default is CV_8UC1
+    @param scale Optional scale value for derivative values, default is 1
+    @param delta  Optional bias added to output, default is 0
+    @param borderType Pixel extrapolation method, default is BORDER_DEFAULT
+    @see Sobel, threshold, getStructuringElement, morphologyEx.( for additional refinement)
+    */
+    CV_WRAP static Ptr<RidgeDetectionFilter> create(int ddepth = CV_32FC1, int dx=1, int dy=1, int ksize = 3, int out_dtype=CV_8UC1, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT);
+    /**
+    @brief Apply Ridge detection filter on input image.
+    @param _img InputArray as supported by Sobel. img can be 1-Channel or 3-Channels.
+    @param out OutputAray of structure as RidgeDetectionFilter::ddepth. Output image with ridges.
+    */
+    CV_WRAP virtual void getRidgeFilteredImage(InputArray _img, OutputArray out) = 0;
+};
+
+//! @}
+}} // namespace
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/run_length_morphology.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/run_length_morphology.hpp
new file mode 100644
index 00000000..c19e2d85
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/run_length_morphology.hpp
@@ -0,0 +1,119 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_RUN_LENGTH_MORPHOLOGY_HPP__
+#define __OPENCV_RUN_LENGTH_MORPHOLOGY_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace ximgproc {
+namespace rl {
+
+
+//! @addtogroup ximgproc_run_length_morphology
+//! @{
+
+/**
+* @brief   Applies a fixed-level threshold to each array element.
+*
+*
+* @param   src         input array (single-channel).
+* @param   rlDest      resulting run length encoded image.
+* @param   thresh      threshold value.
+* @param   type        thresholding type (only cv::THRESH_BINARY and cv::THRESH_BINARY_INV are supported)
+*
+*/
+CV_EXPORTS void threshold(InputArray src, OutputArray rlDest, double thresh, int type);
+
+
+/**
+* @brief   Dilates an run-length encoded binary image by using a specific structuring element.
+*
+*
+* @param   rlSrc       input image
+* @param   rlDest      result
+* @param   rlKernel    kernel
+* @param   anchor      position of the anchor within the element; default value (0, 0)
+*                      is usually the element center.
+*
+*/
+CV_EXPORTS void dilate(InputArray rlSrc, OutputArray rlDest, InputArray rlKernel, Point anchor = Point(0, 0));
+
+/**
+* @brief   Erodes an run-length encoded binary image by using a specific structuring element.
+*
+*
+* @param   rlSrc       input image
+* @param   rlDest      result
+* @param   rlKernel    kernel
+* @param   bBoundaryOn indicates whether pixel outside the image boundary are assumed to be on
+            (True: works in the same way as the default of cv::erode, False: is a little faster)
+* @param   anchor      position of the anchor within the element; default value (0, 0)
+*                      is usually the element center.
+*
+*/
+CV_EXPORTS void erode(InputArray rlSrc, OutputArray rlDest, InputArray rlKernel,
+    bool bBoundaryOn = true, Point anchor = Point(0, 0));
+
+/**
+* @brief   Returns a run length encoded structuring element of the specified size and shape.
+*
+*
+* @param   shape	Element shape that can be one of cv::MorphShapes
+* @param   ksize	Size of the structuring element.
+*
+*/
+CV_EXPORTS cv::Mat getStructuringElement(int shape, Size ksize);
+
+/**
+* @brief   Paint run length encoded binary image into an image.
+*
+*
+* @param   image       image to paint into (currently only single channel images).
+* @param   rlSrc       run length encoded image
+* @param   value      all foreground pixel of the binary image are set to this value
+*
+*/
+CV_EXPORTS void paint(InputOutputArray image, InputArray rlSrc, const cv::Scalar& value);
+
+/**
+* @brief   Check whether a custom made structuring element can be used with run length morphological operations.
+*          (It must consist of a continuous array of single runs per row)
+*
+* @param   rlStructuringElement   mask to be tested
+*/
+CV_EXPORTS bool isRLMorphologyPossible(InputArray rlStructuringElement);
+
+/**
+* @brief   Creates a run-length encoded image from a vector of runs (column begin, column end, row)
+*
+* @param   runs   vector of runs
+* @param   res    result
+* @param   size   image size (to be used if an "on" boundary should be used in erosion, using the default
+*                  means that the size is computed from the extension of the input)
+*/
+CV_EXPORTS void createRLEImage(const std::vector<cv::Point3i>& runs, OutputArray res, Size size = Size(0, 0));
+
+/**
+* @brief   Applies a morphological operation to a run-length encoded binary image.
+*
+*
+* @param   rlSrc       input image
+* @param   rlDest      result
+* @param   op          all operations supported by cv::morphologyEx (except cv::MORPH_HITMISS)
+* @param   rlKernel    kernel
+* @param   bBoundaryOnForErosion indicates whether pixel outside the image boundary are assumed
+*          to be on for erosion operations (True: works in the same way as the default of cv::erode,
+*          False: is a little faster)
+* @param   anchor      position of the anchor within the element; default value (0, 0) is usually the element center.
+*
+*/
+CV_EXPORTS void morphologyEx(InputArray rlSrc, OutputArray rlDest, int op, InputArray rlKernel,
+    bool bBoundaryOnForErosion = true, Point anchor = Point(0,0));
+
+}
+}
+}
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/scansegment.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/scansegment.hpp
new file mode 100644
index 00000000..5e0a673f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/scansegment.hpp
@@ -0,0 +1,83 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Dr Seng Cheong Loke (lokesengcheong@gmail.com)
+
+#ifndef __OPENCV_XIMGPROC_SCANSEGMENT_HPP__
+#define __OPENCV_XIMGPROC_SCANSEGMENT_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv { namespace ximgproc {
+
+/** @brief Class implementing the F-DBSCAN (Accelerated superpixel image segmentation with a parallelized DBSCAN algorithm) superpixels
+algorithm by Loke SC, et al. @cite loke2021accelerated for original paper.
+
+The algorithm uses a parallelised DBSCAN cluster search that is resistant to noise, competitive in segmentation quality, and faster than
+existing superpixel segmentation methods. When tested on the Berkeley Segmentation Dataset, the average processing speed is 175 frames/s
+with a Boundary Recall of 0.797 and an Achievable Segmentation Accuracy of 0.944. The computational complexity is quadratic O(n2) and
+more suited to smaller images, but can still process a 2MP colour image faster than the SEEDS algorithm in OpenCV. The output is deterministic
+when the number of processing threads is fixed, and requires the source image to be in Lab colour format.
+*/
+class CV_EXPORTS_W ScanSegment : public Algorithm
+{
+public:
+    virtual ~ScanSegment();
+
+    /** @brief Returns the actual superpixel segmentation from the last image processed using iterate.
+
+    Returns zero if no image has been processed.
+    */
+    CV_WRAP virtual int getNumberOfSuperpixels() = 0;
+
+    /** @brief Calculates the superpixel segmentation on a given image with the initialized
+    parameters in the ScanSegment object.
+
+    This function can be called again for other images without the need of initializing the algorithm with createScanSegment().
+    This save the computational cost of allocating memory for all the structures of the algorithm.
+
+    @param img Input image. Supported format: CV_8UC3. Image size must match with the initialized
+    image size with the function createScanSegment(). It MUST be in Lab color space.
+    */
+    CV_WRAP virtual void iterate(InputArray img) = 0;
+
+    /** @brief Returns the segmentation labeling of the image.
+
+    Each label represents a superpixel, and each pixel is assigned to one superpixel label.
+
+    @param labels_out Return: A CV_32UC1 integer array containing the labels of the superpixel
+    segmentation. The labels are in the range [0, getNumberOfSuperpixels()].
+    */
+    CV_WRAP virtual void getLabels(OutputArray labels_out) = 0;
+
+    /** @brief Returns the mask of the superpixel segmentation stored in the ScanSegment object.
+
+    The function return the boundaries of the superpixel segmentation.
+
+    @param image Return: CV_8UC1 image mask where -1 indicates that the pixel is a superpixel border, and 0 otherwise.
+    @param thick_line If false, the border is only one pixel wide, otherwise all pixels at the border are masked.
+    */
+    CV_WRAP virtual void getLabelContourMask(OutputArray image, bool thick_line = false) = 0;
+};
+
+/** @brief Initializes a ScanSegment object.
+
+The function initializes a ScanSegment object for the input image. It stores the parameters of
+the image: image_width and image_height. It also sets the parameters of the F-DBSCAN superpixel
+algorithm, which are: num_superpixels, threads, and merge_small.
+
+@param image_width Image width.
+@param image_height Image height.
+@param num_superpixels Desired number of superpixels. Note that the actual number may be smaller
+due to restrictions (depending on the image size). Use getNumberOfSuperpixels() to
+get the actual number.
+@param slices Number of processing threads for parallelisation. Setting -1 uses the maximum number
+of threads. In practice, four threads is enough for smaller images and eight threads for larger ones.
+@param merge_small merge small segments to give the desired number of superpixels. Processing is
+much faster without merging, but many small segments will be left in the image.
+*/
+CV_EXPORTS_W cv::Ptr<ScanSegment> createScanSegment(int image_width, int image_height, int num_superpixels, int slices = 8, bool merge_small = true);
+
+}}  // namespace
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/seeds.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/seeds.hpp
new file mode 100644
index 00000000..4db8b8f6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/seeds.hpp
@@ -0,0 +1,183 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2014, Beat Kueng (beat-kueng@gmx.net), Lukas Vogel, Morten Lysgaard
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_SEEDS_HPP__
+#define __OPENCV_SEEDS_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+//! @addtogroup ximgproc_superpixel
+//! @{
+
+/** @brief Class implementing the SEEDS (Superpixels Extracted via Energy-Driven Sampling) superpixels
+algorithm described in @cite VBRV14 .
+
+The algorithm uses an efficient hill-climbing algorithm to optimize the superpixels' energy
+function that is based on color histograms and a boundary term, which is optional. The energy
+function encourages superpixels to be of the same color, and if the boundary term is activated, the
+superpixels have smooth boundaries and are of similar shape. In practice it starts from a regular
+grid of superpixels and moves the pixels or blocks of pixels at the boundaries to refine the
+solution. The algorithm runs in real-time using a single CPU.
+ */
+class CV_EXPORTS_W SuperpixelSEEDS : public Algorithm
+{
+public:
+
+    /** @brief Calculates the superpixel segmentation on a given image stored in SuperpixelSEEDS object.
+
+    The function computes the superpixels segmentation of an image with the parameters initialized
+    with the function createSuperpixelSEEDS().
+     */
+    CV_WRAP virtual int getNumberOfSuperpixels() = 0;
+
+    /** @brief Calculates the superpixel segmentation on a given image with the initialized
+    parameters in the SuperpixelSEEDS object.
+
+    This function can be called again for other images without the need of initializing the
+    algorithm with createSuperpixelSEEDS(). This save the computational cost of allocating memory
+    for all the structures of the algorithm.
+
+    @param img Input image. Supported formats: CV_8U, CV_16U, CV_32F. Image size & number of
+    channels must match with the initialized image size & channels with the function
+    createSuperpixelSEEDS(). It should be in HSV or Lab color space. Lab is a bit better, but also
+    slower.
+
+    @param num_iterations Number of pixel level iterations. Higher number improves the result.
+
+    The function computes the superpixels segmentation of an image with the parameters initialized
+    with the function createSuperpixelSEEDS(). The algorithms starts from a grid of superpixels and
+    then refines the boundaries by proposing updates of blocks of pixels that lie at the boundaries
+    from large to smaller size, finalizing with proposing pixel updates. An illustrative example
+    can be seen below.
+
+    ![image](pics/superpixels_blocks2.png)
+     */
+    CV_WRAP virtual void iterate(InputArray img, int num_iterations=4) = 0;
+
+    /** @brief Returns the segmentation labeling of the image.
+
+    Each label represents a superpixel, and each pixel is assigned to one superpixel label.
+
+    @param labels_out Return: A CV_32UC1 integer array containing the labels of the superpixel
+    segmentation. The labels are in the range [0, getNumberOfSuperpixels()].
+
+    The function returns an image with ssthe labels of the superpixel segmentation. The labels are in
+    the range [0, getNumberOfSuperpixels()].
+     */
+    CV_WRAP virtual void getLabels(OutputArray labels_out) = 0;
+
+    /** @brief Returns the mask of the superpixel segmentation stored in SuperpixelSEEDS object.
+
+    @param image Return: CV_8UC1 image mask where -1 indicates that the pixel is a superpixel border,
+    and 0 otherwise.
+
+    @param thick_line If false, the border is only one pixel wide, otherwise all pixels at the border
+    are masked.
+
+    The function return the boundaries of the superpixel segmentation.
+
+    @note
+       -   (Python) A demo on how to generate superpixels in images from the webcam can be found at
+            opencv_source_code/samples/python2/seeds.py
+        -   (cpp) A demo on how to generate superpixels in images from the webcam can be found at
+            opencv_source_code/modules/ximgproc/samples/seeds.cpp. By adding a file image as a command
+            line argument, the static image will be used instead of the webcam.
+        -   It will show a window with the video from the webcam with the superpixel boundaries marked
+            in red (see below). Use Space to switch between different output modes. At the top of the
+            window there are 4 sliders, from which the user can change on-the-fly the number of
+            superpixels, the number of block levels, the strength of the boundary prior term to modify
+            the shape, and the number of iterations at pixel level. This is useful to play with the
+            parameters and set them to the user convenience. In the console the frame-rate of the
+            algorithm is indicated.
+
+    ![image](pics/superpixels_demo.png)
+     */
+    CV_WRAP virtual void getLabelContourMask(OutputArray image, bool thick_line = false) = 0;
+
+    virtual ~SuperpixelSEEDS() {}
+};
+
+/** @brief Initializes a SuperpixelSEEDS object.
+
+@param image_width Image width.
+@param image_height Image height.
+@param image_channels Number of channels of the image.
+@param num_superpixels Desired number of superpixels. Note that the actual number may be smaller
+due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to
+get the actual number.
+@param num_levels Number of block levels. The more levels, the more accurate is the segmentation,
+but needs more memory and CPU time.
+@param prior enable 3x3 shape smoothing term if \>0. A larger value leads to smoother shapes. prior
+must be in the range [0, 5].
+@param histogram_bins Number of histogram bins.
+@param double_step If true, iterate each block level twice for higher accuracy.
+
+The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of
+the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS
+superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and
+double_step.
+
+The number of levels in num_levels defines the amount of block levels that the algorithm use in the
+optimization. The initialization is a grid, in which the superpixels are equally distributed through
+the width and the height of the image. The larger blocks correspond to the superpixel size, and the
+levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels,
+recursively until the smaller block level. An example of initialization of 4 block levels is
+illustrated in the following figure.
+
+![image](pics/superpixels_blocks.png)
+ */
+CV_EXPORTS_W Ptr<SuperpixelSEEDS> createSuperpixelSEEDS(
+    int image_width, int image_height, int image_channels,
+    int num_superpixels, int num_levels, int prior = 2,
+    int histogram_bins=5, bool double_step = false);
+
+//! @}
+
+}
+}
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/segmentation.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/segmentation.hpp
new file mode 100644
index 00000000..02346aa9
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/segmentation.hpp
@@ -0,0 +1,252 @@
+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#ifndef __OPENCV_XIMGPROC_SEGMENTATION_HPP__
+#define __OPENCV_XIMGPROC_SEGMENTATION_HPP__
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+    namespace ximgproc {
+        namespace segmentation {
+            //! @addtogroup ximgproc_segmentation
+            //! @{
+
+                    /** @brief Graph Based Segmentation Algorithm.
+                        The class implements the algorithm described in @cite PFF2004 .
+                     */
+                    class CV_EXPORTS_W GraphSegmentation : public Algorithm {
+                        public:
+                            /** @brief Segment an image and store output in dst
+                                @param src The input image. Any number of channel (1 (Eg: Gray), 3 (Eg: RGB), 4 (Eg: RGB-D)) can be provided
+                                @param dst The output segmentation. It's a CV_32SC1 Mat with the same number of cols and rows as input image, with an unique, sequential, id for each pixel.
+                            */
+                            CV_WRAP virtual void processImage(InputArray src, OutputArray dst) = 0;
+
+                            CV_WRAP virtual void setSigma(double sigma) = 0;
+                            CV_WRAP virtual double getSigma() = 0;
+
+                            CV_WRAP virtual void setK(float k) = 0;
+                            CV_WRAP virtual float getK() = 0;
+
+                            CV_WRAP virtual void setMinSize(int min_size) = 0;
+                            CV_WRAP virtual int getMinSize() = 0;
+                    };
+
+                    /** @brief Creates a graph based segmentor
+                        @param sigma The sigma parameter, used to smooth image
+                        @param k The k parameter of the algorythm
+                        @param min_size The minimum size of segments
+                     */
+                    CV_EXPORTS_W Ptr<GraphSegmentation> createGraphSegmentation(double sigma=0.5, float k=300, int min_size=100);
+
+                    /** @brief Strategie for the selective search segmentation algorithm
+                        The class implements a generic stragery for the algorithm described in @cite uijlings2013selective.
+                     */
+                    class CV_EXPORTS_W SelectiveSearchSegmentationStrategy : public Algorithm {
+                        public:
+                            /** @brief Set a initial image, with a segmentation.
+                                @param img The input image. Any number of channel can be provided
+                                @param regions A segmentation of the image. The parameter must be the same size of img.
+                                @param sizes The sizes of different regions
+                                @param image_id If not set to -1, try to cache pre-computations. If the same set og (img, regions, size) is used, the image_id need to be the same.
+                            */
+                            CV_WRAP virtual void setImage(InputArray img, InputArray regions, InputArray sizes, int image_id = -1) = 0;
+
+                            /** @brief Return the score between two regions (between 0 and 1)
+                                @param r1 The first region
+                                @param r2 The second region
+                            */
+                            CV_WRAP virtual float get(int r1, int r2) = 0;
+
+                            /** @brief Inform the strategy that two regions will be merged
+                                @param r1 The first region
+                                @param r2 The second region
+                            */
+                            CV_WRAP virtual void merge(int r1, int r2) = 0;
+                    };
+
+                    /** @brief Color-based strategy for the selective search segmentation algorithm
+                        The class is implemented from the algorithm described in @cite uijlings2013selective.
+                     */
+                    class CV_EXPORTS_W SelectiveSearchSegmentationStrategyColor : public SelectiveSearchSegmentationStrategy {
+                    };
+
+                    /** @brief Create a new color-based strategy */
+                    CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyColor> createSelectiveSearchSegmentationStrategyColor();
+
+                    /** @brief Size-based strategy for the selective search segmentation algorithm
+                        The class is implemented from the algorithm described in @cite uijlings2013selective.
+                     */
+                    class CV_EXPORTS_W SelectiveSearchSegmentationStrategySize : public SelectiveSearchSegmentationStrategy {
+                    };
+
+                    /** @brief Create a new size-based strategy */
+                    CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategySize> createSelectiveSearchSegmentationStrategySize();
+
+                    /** @brief Texture-based strategy for the selective search segmentation algorithm
+                        The class is implemented from the algorithm described in @cite uijlings2013selective.
+                     */
+                    class CV_EXPORTS_W SelectiveSearchSegmentationStrategyTexture : public SelectiveSearchSegmentationStrategy {
+                    };
+
+                    /** @brief Create a new size-based strategy */
+                    CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyTexture> createSelectiveSearchSegmentationStrategyTexture();
+
+                    /** @brief Fill-based strategy for the selective search segmentation algorithm
+                        The class is implemented from the algorithm described in @cite uijlings2013selective.
+                     */
+                    class CV_EXPORTS_W SelectiveSearchSegmentationStrategyFill : public SelectiveSearchSegmentationStrategy {
+                    };
+
+                    /** @brief Create a new fill-based strategy */
+                    CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyFill> createSelectiveSearchSegmentationStrategyFill();
+
+                    /** @brief Regroup multiple strategies for the selective search segmentation algorithm
+                     */
+                    class CV_EXPORTS_W SelectiveSearchSegmentationStrategyMultiple : public SelectiveSearchSegmentationStrategy {
+                        public:
+
+                            /** @brief Add a new sub-strategy
+                                @param g The strategy
+                                @param weight The weight of the strategy
+                            */
+                            CV_WRAP virtual void addStrategy(Ptr<SelectiveSearchSegmentationStrategy> g, float weight) = 0;
+                            /** @brief Remove all sub-strategies
+                            */
+                            CV_WRAP virtual void clearStrategies() = 0;
+                    };
+
+                    /** @brief Create a new multiple strategy */
+                    CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple();
+
+                    /** @brief Create a new multiple strategy and set one subtrategy
+                        @param s1 The first strategy
+                    */
+                    CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1);
+
+                    /** @brief Create a new multiple strategy and set two subtrategies, with equal weights
+                        @param s1 The first strategy
+                        @param s2 The second strategy
+                    */
+                    CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1, Ptr<SelectiveSearchSegmentationStrategy> s2);
+
+
+                    /** @brief Create a new multiple strategy and set three subtrategies, with equal weights
+                        @param s1 The first strategy
+                        @param s2 The second strategy
+                        @param s3 The third strategy
+                    */
+                    CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1, Ptr<SelectiveSearchSegmentationStrategy> s2, Ptr<SelectiveSearchSegmentationStrategy> s3);
+
+                    /** @brief Create a new multiple strategy and set four subtrategies, with equal weights
+                        @param s1 The first strategy
+                        @param s2 The second strategy
+                        @param s3 The third strategy
+                        @param s4 The forth strategy
+                    */
+                    CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1, Ptr<SelectiveSearchSegmentationStrategy> s2, Ptr<SelectiveSearchSegmentationStrategy> s3, Ptr<SelectiveSearchSegmentationStrategy> s4);
+
+                    /** @brief Selective search segmentation algorithm
+                        The class implements the algorithm described in @cite uijlings2013selective.
+                     */
+                    class CV_EXPORTS_W SelectiveSearchSegmentation : public Algorithm {
+                        public:
+
+                            /** @brief Set a image used by switch* functions to initialize the class
+                                @param img The image
+                            */
+                            CV_WRAP virtual void setBaseImage(InputArray img) = 0;
+
+                            /** @brief Initialize the class with the 'Single stragegy' parameters describled in @cite uijlings2013selective.
+                                @param k The k parameter for the graph segmentation
+                                @param sigma The sigma parameter for the graph segmentation
+                            */
+                            CV_WRAP virtual void switchToSingleStrategy(int k = 200, float sigma = 0.8f) = 0;
+
+                            /** @brief Initialize the class with the 'Selective search fast' parameters describled in @cite uijlings2013selective.
+                                @param base_k The k parameter for the first graph segmentation
+                                @param inc_k The increment of the k parameter for all graph segmentations
+                                @param sigma The sigma parameter for the graph segmentation
+                            */
+                            CV_WRAP virtual void switchToSelectiveSearchFast(int base_k = 150, int inc_k = 150, float sigma = 0.8f) = 0;
+
+                            /** @brief Initialize the class with the 'Selective search fast' parameters describled in @cite uijlings2013selective.
+                                @param base_k The k parameter for the first graph segmentation
+                                @param inc_k The increment of the k parameter for all graph segmentations
+                                @param sigma The sigma parameter for the graph segmentation
+                            */
+                            CV_WRAP virtual void switchToSelectiveSearchQuality(int base_k = 150, int inc_k = 150, float sigma = 0.8f) = 0;
+
+                            /** @brief Add a new image in the list of images to process.
+                                @param img The image
+                            */
+                            CV_WRAP virtual void addImage(InputArray img) = 0;
+
+                            /** @brief Clear the list of images to process
+                            */
+                            CV_WRAP virtual void clearImages() = 0;
+
+                            /** @brief Add a new graph segmentation in the list of graph segementations to process.
+                                @param g The graph segmentation
+                            */
+                            CV_WRAP virtual void addGraphSegmentation(Ptr<GraphSegmentation> g) = 0;
+
+                            /** @brief Clear the list of graph segmentations to process;
+                            */
+                            CV_WRAP virtual void clearGraphSegmentations() = 0;
+
+                            /** @brief Add a new strategy in the list of strategy to process.
+                                @param s The strategy
+                            */
+                            CV_WRAP virtual void addStrategy(Ptr<SelectiveSearchSegmentationStrategy> s) = 0;
+
+                            /** @brief Clear the list of strategy to process;
+                            */
+                            CV_WRAP virtual void clearStrategies() = 0;
+
+                            /** @brief Based on all images, graph segmentations and stragies, computes all possible rects and return them
+                                @param rects The list of rects. The first ones are more relevents than the lasts ones.
+                            */
+                            CV_WRAP virtual void process(CV_OUT std::vector<Rect>& rects) = 0;
+                    };
+
+                    /** @brief Create a new SelectiveSearchSegmentation class.
+                     */
+                    CV_EXPORTS_W Ptr<SelectiveSearchSegmentation> createSelectiveSearchSegmentation();
+
+            //! @}
+
+        }
+    }
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/slic.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/slic.hpp
new file mode 100644
index 00000000..ab8e4bca
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/slic.hpp
@@ -0,0 +1,168 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2013
+ * Radhakrishna Achanta
+ * email : Radhakrishna [dot] Achanta [at] epfl [dot] ch
+ * web : http://ivrl.epfl.ch/people/achanta
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the copyright holders nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+/*
+ "SLIC Superpixels Compared to State-of-the-art Superpixel Methods"
+ Radhakrishna Achanta, Appu Shaji, Kevin Smith, Aurelien Lucchi, Pascal Fua,
+ and Sabine Susstrunk, IEEE TPAMI, Volume 34, Issue 11, Pages 2274-2282,
+ November 2012.
+
+ "SLIC Superpixels" Radhakrishna Achanta, Appu Shaji, Kevin Smith,
+ Aurelien Lucchi, Pascal Fua, and Sabine Süsstrunk, EPFL Technical
+ Report no. 149300, June 2010.
+
+ OpenCV port by: Cristian Balint <cristian dot balint at gmail dot com>
+ */
+
+#ifndef __OPENCV_SLIC_HPP__
+#define __OPENCV_SLIC_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+//! @addtogroup ximgproc_superpixel
+//! @{
+
+    enum SLICType { SLIC = 100, SLICO = 101, MSLIC = 102 };
+
+/** @brief Class implementing the SLIC (Simple Linear Iterative Clustering) superpixels
+algorithm described in @cite Achanta2012.
+
+SLIC (Simple Linear Iterative Clustering) clusters pixels using pixel channels and image plane space
+to efficiently generate compact, nearly uniform superpixels. The simplicity of approach makes it
+extremely easy to use a lone parameter specifies the number of superpixels and the efficiency of
+the algorithm makes it very practical.
+Several optimizations are available for SLIC class:
+SLICO stands for "Zero parameter SLIC" and it is an optimization of baseline SLIC described in @cite Achanta2012.
+MSLIC stands for "Manifold SLIC" and it is an optimization of baseline SLIC described in @cite Liu_2017_IEEE.
+ */
+
+class CV_EXPORTS_W SuperpixelSLIC : public Algorithm
+{
+public:
+
+    /** @brief Calculates the actual amount of superpixels on a given segmentation computed
+    and stored in SuperpixelSLIC object.
+     */
+    CV_WRAP virtual int getNumberOfSuperpixels() const = 0;
+
+    /** @brief Calculates the superpixel segmentation on a given image with the initialized
+    parameters in the SuperpixelSLIC object.
+
+    This function can be called again without the need of initializing the algorithm with
+    createSuperpixelSLIC(). This save the computational cost of allocating memory for all the
+    structures of the algorithm.
+
+    @param num_iterations Number of iterations. Higher number improves the result.
+
+    The function computes the superpixels segmentation of an image with the parameters initialized
+    with the function createSuperpixelSLIC(). The algorithms starts from a grid of superpixels and
+    then refines the boundaries by proposing updates of edges boundaries.
+
+     */
+    CV_WRAP virtual void iterate( int num_iterations = 10 ) = 0;
+
+    /** @brief Returns the segmentation labeling of the image.
+
+    Each label represents a superpixel, and each pixel is assigned to one superpixel label.
+
+    @param labels_out Return: A CV_32SC1 integer array containing the labels of the superpixel
+    segmentation. The labels are in the range [0, getNumberOfSuperpixels()].
+
+    The function returns an image with the labels of the superpixel segmentation. The labels are in
+    the range [0, getNumberOfSuperpixels()].
+     */
+    CV_WRAP virtual void getLabels( OutputArray labels_out ) const = 0;
+
+    /** @brief Returns the mask of the superpixel segmentation stored in SuperpixelSLIC object.
+
+    @param image Return: CV_8U1 image mask where -1 indicates that the pixel is a superpixel border,
+    and 0 otherwise.
+
+    @param thick_line If false, the border is only one pixel wide, otherwise all pixels at the border
+    are masked.
+
+    The function return the boundaries of the superpixel segmentation.
+     */
+    CV_WRAP virtual void getLabelContourMask( OutputArray image, bool thick_line = true ) const = 0;
+
+    /** @brief Enforce label connectivity.
+
+    @param min_element_size The minimum element size in percents that should be absorbed into a bigger
+    superpixel. Given resulted average superpixel size valid value should be in 0-100 range, 25 means
+    that less then a quarter sized superpixel should be absorbed, this is default.
+
+    The function merge component that is too small, assigning the previously found adjacent label
+    to this component. Calling this function may change the final number of superpixels.
+     */
+    CV_WRAP virtual void enforceLabelConnectivity( int min_element_size = 25 ) = 0;
+
+
+};
+
+/** @brief Initialize a SuperpixelSLIC object
+
+@param image Image to segment
+@param algorithm Chooses the algorithm variant to use:
+SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor,
+while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels.
+@param region_size Chooses an average superpixel size measured in pixels
+@param ruler Chooses the enforcement of superpixel smoothness factor of superpixel
+
+The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed
+superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
+computing iterations over the given image. For enanched results it is recommended for color images to
+preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into
+CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture.
+
+![image](pics/superpixels_slic.png)
+
+ */
+
+    CV_EXPORTS_W Ptr<SuperpixelSLIC> createSuperpixelSLIC( InputArray image, int algorithm = SLICO,
+                                                           int region_size = 10, float ruler = 10.0f );
+
+//! @}
+
+}
+}
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/sparse_match_interpolator.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/sparse_match_interpolator.hpp
new file mode 100644
index 00000000..feae7261
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/sparse_match_interpolator.hpp
@@ -0,0 +1,270 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#ifndef __OPENCV_SPARSEMATCHINTERPOLATOR_HPP__
+#define __OPENCV_SPARSEMATCHINTERPOLATOR_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace ximgproc {
+
+//! @addtogroup ximgproc_filters
+//! @{
+
+/** @brief Main interface for all filters, that take sparse matches as an
+input and produce a dense per-pixel matching (optical flow) as an output.
+ */
+class CV_EXPORTS_W SparseMatchInterpolator : public Algorithm
+{
+public:
+    /** @brief Interpolate input sparse matches.
+
+    @param from_image first of the two matched images, 8-bit single-channel or three-channel.
+
+    @param from_points points of the from_image for which there are correspondences in the
+    to_image (Point2f vector or Mat of depth CV_32F)
+
+    @param to_image second of the two matched images, 8-bit single-channel or three-channel.
+
+    @param to_points points in the to_image corresponding to from_points
+    (Point2f vector or Mat of depth CV_32F)
+
+    @param dense_flow output dense matching (two-channel CV_32F image)
+     */
+    CV_WRAP virtual void interpolate(InputArray from_image, InputArray from_points,
+                                     InputArray to_image  , InputArray to_points,
+                                     OutputArray dense_flow) = 0;
+};
+
+/** @brief Sparse match interpolation algorithm based on modified locally-weighted affine
+estimator from @cite Revaud2015 and Fast Global Smoother as post-processing filter.
+ */
+class CV_EXPORTS_W EdgeAwareInterpolator : public SparseMatchInterpolator
+{
+public:
+    /** @brief Interface to provide a more elaborated cost map, i.e. edge map, for the edge-aware term.
+     *  This implementation is based on a rather simple gradient-based edge map estimation.
+     *  To used more complex edge map estimator (e.g. StructuredEdgeDetection that has been
+     *  used in the original publication) that may lead to improved accuracies, the internal
+     *  edge map estimation can be bypassed here.
+     *  @param _costMap a type CV_32FC1 Mat is required.
+     *  @see cv::ximgproc::createSuperpixelSLIC
+    */
+    CV_WRAP virtual void setCostMap(const Mat & _costMap) = 0;
+    /** @brief Parameter to tune the approximate size of the superpixel used for oversegmentation.
+     *  @see cv::ximgproc::createSuperpixelSLIC
+    */
+    /** @brief K is a number of nearest-neighbor matches considered, when fitting a locally affine
+    model. Usually it should be around 128. However, lower values would make the interpolation
+    noticeably faster.
+     */
+    CV_WRAP virtual void setK(int _k) = 0;
+    /** @see setK */
+    CV_WRAP virtual int  getK() = 0;
+
+    /** @brief Sigma is a parameter defining how fast the weights decrease in the locally-weighted affine
+    fitting. Higher values can help preserve fine details, lower values can help to get rid of noise in the
+    output flow.
+     */
+    CV_WRAP virtual void  setSigma(float _sigma) = 0;
+    /** @see setSigma */
+    CV_WRAP virtual float getSigma() = 0;
+
+    /** @brief Lambda is a parameter defining the weight of the edge-aware term in geodesic distance,
+    should be in the range of 0 to 1000.
+     */
+    CV_WRAP virtual void  setLambda(float _lambda) = 0;
+    /** @see setLambda */
+    CV_WRAP virtual float getLambda() = 0;
+
+    /** @brief Sets whether the fastGlobalSmootherFilter() post-processing is employed. It is turned on by
+    default.
+     */
+    CV_WRAP virtual void setUsePostProcessing(bool _use_post_proc) = 0;
+    /** @see setUsePostProcessing */
+    CV_WRAP virtual bool getUsePostProcessing() = 0;
+
+    /** @brief Sets the respective fastGlobalSmootherFilter() parameter.
+     */
+    CV_WRAP virtual void  setFGSLambda(float _lambda) = 0;
+    /** @see setFGSLambda */
+    CV_WRAP virtual float getFGSLambda() = 0;
+
+    /** @see setFGSLambda */
+    CV_WRAP virtual void  setFGSSigma(float _sigma) = 0;
+    /** @see setFGSLambda */
+    CV_WRAP virtual float getFGSSigma() = 0;
+};
+
+/** @brief Factory method that creates an instance of the
+EdgeAwareInterpolator.
+*/
+CV_EXPORTS_W
+Ptr<EdgeAwareInterpolator> createEdgeAwareInterpolator();
+
+/** @brief Sparse match interpolation algorithm based on modified piecewise locally-weighted affine
+ * estimator called Robust Interpolation method of Correspondences or RIC from @cite Hu2017 and Variational
+ * and Fast Global Smoother as post-processing filter. The RICInterpolator is a extension of the EdgeAwareInterpolator.
+ * Main concept of this extension is an piece-wise affine model based on over-segmentation via SLIC superpixel estimation.
+ * The method contains an efficient propagation mechanism to estimate among the pieces-wise models.
+ */
+class CV_EXPORTS_W RICInterpolator : public SparseMatchInterpolator
+{
+public:
+    /** @brief K is a number of nearest-neighbor matches considered, when fitting a locally affine
+     *model for a superpixel segment. However, lower values would make the interpolation
+     *noticeably faster. The original implementation of @cite Hu2017 uses 32.
+    */
+    CV_WRAP virtual void setK(int k = 32) = 0;
+    /** @copybrief setK
+     *  @see setK
+     */
+    CV_WRAP virtual int getK() const = 0;
+    /** @brief Interface to provide a more elaborated cost map, i.e. edge map, for the edge-aware term.
+     *  This implementation is based on a rather simple gradient-based edge map estimation.
+     *  To used more complex edge map estimator (e.g. StructuredEdgeDetection that has been
+     *  used in the original publication) that may lead to improved accuracies, the internal
+     *  edge map estimation can be bypassed here.
+     *  @param costMap a type CV_32FC1 Mat is required.
+     *  @see cv::ximgproc::createSuperpixelSLIC
+    */
+    CV_WRAP virtual void setCostMap(const Mat & costMap) = 0;
+    /** @brief Get the internal cost, i.e. edge map, used for estimating the edge-aware term.
+     *  @see setCostMap
+     */
+    CV_WRAP virtual void setSuperpixelSize(int spSize = 15) = 0;
+    /** @copybrief setSuperpixelSize
+     *  @see setSuperpixelSize
+     */
+    CV_WRAP virtual int getSuperpixelSize() const = 0;
+    /** @brief Parameter defines the number of nearest-neighbor matches for each superpixel considered, when fitting a locally affine
+     *model.
+    */
+    CV_WRAP virtual void setSuperpixelNNCnt(int spNN = 150) = 0;
+    /** @copybrief setSuperpixelNNCnt
+     *  @see setSuperpixelNNCnt
+    */
+    CV_WRAP virtual int getSuperpixelNNCnt() const = 0;
+    /** @brief Parameter to tune enforcement of superpixel smoothness factor used for oversegmentation.
+     *  @see cv::ximgproc::createSuperpixelSLIC
+    */
+    CV_WRAP virtual void setSuperpixelRuler(float ruler = 15.f) = 0;
+    /** @copybrief setSuperpixelRuler
+     *  @see setSuperpixelRuler
+     */
+    CV_WRAP virtual float  getSuperpixelRuler() const = 0;
+    /** @brief Parameter to choose superpixel algorithm variant to use:
+     * - cv::ximgproc::SLICType SLIC segments image using a desired region_size (value: 100)
+     * - cv::ximgproc::SLICType SLICO will optimize using adaptive compactness factor (value: 101)
+     * - cv::ximgproc::SLICType MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels (value: 102).
+     *  @see cv::ximgproc::createSuperpixelSLIC
+    */
+    CV_WRAP virtual void setSuperpixelMode(int mode = 100) = 0;
+    /** @copybrief setSuperpixelMode
+     *  @see setSuperpixelMode
+     */
+    CV_WRAP virtual int getSuperpixelMode() const = 0;
+    /** @brief Alpha is a parameter defining a global weight for transforming geodesic distance into weight.
+     */
+    CV_WRAP virtual void setAlpha(float alpha = 0.7f) = 0;
+    /** @copybrief setAlpha
+     *  @see setAlpha
+     */
+    CV_WRAP virtual float getAlpha() const = 0;
+    /** @brief Parameter defining the number of iterations for piece-wise affine model estimation.
+     */
+    CV_WRAP virtual void setModelIter(int modelIter = 4) = 0;
+    /** @copybrief setModelIter
+     *  @see setModelIter
+     */
+    CV_WRAP virtual int getModelIter() const = 0;
+    /** @brief Parameter to choose wether additional refinement of the piece-wise affine models is employed.
+    */
+    CV_WRAP virtual void setRefineModels(bool refineModles = true) = 0;
+    /** @copybrief setRefineModels
+     *  @see setRefineModels
+     */
+    CV_WRAP virtual bool getRefineModels() const = 0;
+    /** @brief MaxFlow is a threshold to validate the predictions using a certain piece-wise affine model.
+     * If the prediction exceeds the treshold the translational model will be applied instead.
+    */
+    CV_WRAP virtual void setMaxFlow(float maxFlow = 250.f) = 0;
+    /** @copybrief setMaxFlow
+     *  @see setMaxFlow
+     */
+    CV_WRAP virtual float getMaxFlow() const = 0;
+    /** @brief Parameter to choose wether the VariationalRefinement post-processing  is employed.
+    */
+    CV_WRAP virtual void setUseVariationalRefinement(bool use_variational_refinement = false) = 0;
+    /** @copybrief setUseVariationalRefinement
+     *  @see setUseVariationalRefinement
+     */
+    CV_WRAP virtual bool  getUseVariationalRefinement() const = 0;
+    /** @brief Sets whether the fastGlobalSmootherFilter() post-processing is employed.
+    */
+    CV_WRAP virtual void setUseGlobalSmootherFilter(bool use_FGS = true) = 0;
+    /** @copybrief setUseGlobalSmootherFilter
+     *  @see setUseGlobalSmootherFilter
+     */
+    CV_WRAP virtual bool getUseGlobalSmootherFilter() const = 0;
+    /** @brief Sets the respective fastGlobalSmootherFilter() parameter.
+     */
+    CV_WRAP virtual void  setFGSLambda(float lambda = 500.f) = 0;
+    /** @copybrief setFGSLambda
+     *  @see setFGSLambda
+     */
+    CV_WRAP virtual float getFGSLambda() const = 0;
+    /** @brief Sets the respective fastGlobalSmootherFilter() parameter.
+     */
+    CV_WRAP virtual void  setFGSSigma(float sigma = 1.5f) = 0;
+    /** @copybrief setFGSSigma
+     *  @see setFGSSigma
+     */
+    CV_WRAP virtual float getFGSSigma() const = 0;
+};
+
+/** @brief Factory method that creates an instance of the
+RICInterpolator.
+*/
+CV_EXPORTS_W
+Ptr<RICInterpolator> createRICInterpolator();
+//! @}
+}
+}
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/structured_edge_detection.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/structured_edge_detection.hpp
new file mode 100644
index 00000000..1d375d3a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/structured_edge_detection.hpp
@@ -0,0 +1,148 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_STRUCTURED_EDGE_DETECTION_HPP__
+#define __OPENCV_STRUCTURED_EDGE_DETECTION_HPP__
+#ifdef __cplusplus
+
+/** @file
+@date Jun 17, 2014
+@author Yury Gitman
+ */
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+//! @addtogroup ximgproc_edge
+//! @{
+
+/*!
+  Helper class for training part of [P. Dollar and C. L. Zitnick. Structured Forests for Fast Edge Detection, 2013].
+ */
+class CV_EXPORTS_W RFFeatureGetter : public Algorithm
+{
+public:
+
+    /*!
+     * This functions extracts feature channels from src.
+     * Than StructureEdgeDetection uses this feature space
+     * to detect edges.
+     *
+     * \param src : source image to extract features
+     * \param features : output n-channel floating point feature matrix.
+     *
+     * \param gnrmRad : __rf.options.gradientNormalizationRadius
+     * \param gsmthRad : __rf.options.gradientSmoothingRadius
+     * \param shrink : __rf.options.shrinkNumber
+     * \param outNum : __rf.options.numberOfOutputChannels
+     * \param gradNum : __rf.options.numberOfGradientOrientations
+     */
+    CV_WRAP virtual void getFeatures(const Mat &src, Mat &features,
+                                     const int gnrmRad,
+                                     const int gsmthRad,
+                                     const int shrink,
+                                     const int outNum,
+                                     const int gradNum) const = 0;
+};
+
+CV_EXPORTS_W Ptr<RFFeatureGetter> createRFFeatureGetter();
+
+
+
+/** @brief Class implementing edge detection algorithm from @cite Dollar2013 :
+ */
+class CV_EXPORTS_W StructuredEdgeDetection : public Algorithm
+{
+public:
+
+    /** @brief The function detects edges in src and draw them to dst.
+
+    The algorithm underlies this function is much more robust to texture presence, than common
+    approaches, e.g. Sobel
+    @param src source image (RGB, float, in [0;1]) to detect edges
+    @param dst destination image (grayscale, float, in [0;1]) where edges are drawn
+    @sa Sobel, Canny
+     */
+    CV_WRAP virtual void detectEdges(cv::InputArray src, cv::OutputArray dst) const = 0;
+
+    /** @brief The function computes orientation from edge image.
+
+    @param src edge image.
+    @param dst orientation image.
+     */
+    CV_WRAP virtual void computeOrientation(cv::InputArray src, cv::OutputArray dst) const = 0;
+
+
+    /** @brief The function edgenms in edge image and suppress edges where edge is stronger in orthogonal direction.
+
+    @param edge_image edge image from detectEdges function.
+    @param orientation_image orientation image from computeOrientation function.
+    @param dst suppressed image (grayscale, float, in [0;1])
+    @param r radius for NMS suppression.
+    @param s radius for boundary suppression.
+    @param m multiplier for conservative suppression.
+    @param isParallel enables/disables parallel computing.
+     */
+    CV_WRAP virtual void edgesNms(cv::InputArray edge_image, cv::InputArray orientation_image, cv::OutputArray dst, int r = 2, int s = 0, float m = 1, bool isParallel = true) const = 0;
+};
+
+/*!
+* The only constructor
+*
+* \param model : name of the file where the model is stored
+* \param howToGetFeatures : optional object inheriting from RFFeatureGetter.
+*                           You need it only if you would like to train your
+*                           own forest, pass NULL otherwise
+*/
+CV_EXPORTS_W Ptr<StructuredEdgeDetection> createStructuredEdgeDetection(const String &model,
+    Ptr<const RFFeatureGetter> howToGetFeatures = Ptr<RFFeatureGetter>());
+
+//! @}
+
+}
+}
+#endif
+#endif /* __OPENCV_STRUCTURED_EDGE_DETECTION_HPP__ */
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/weighted_median_filter.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/weighted_median_filter.hpp
new file mode 100644
index 00000000..d3da29ef
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/include/opencv2/ximgproc/weighted_median_filter.hpp
@@ -0,0 +1,96 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2015, The Chinese University of Hong Kong, all rights reserved.
+//
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef  __OPENCV_WEIGHTED_MEDIAN_FILTER_HPP__
+#define  __OPENCV_WEIGHTED_MEDIAN_FILTER_HPP__
+#ifdef __cplusplus
+
+/**
+* @file
+* @date Sept 9, 2015
+* @author Zhou Chao
+*/
+
+#include <opencv2/core.hpp>
+#include <string>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+/**
+* @brief Specifies weight types of weighted median filter.
+*/
+enum WMFWeightType
+{
+    WMF_EXP = 1     , //!< \f$exp(-|I1-I2|^2/(2*sigma^2))\f$
+    WMF_IV1 = 1 << 1, //!< \f$(|I1-I2|+sigma)^-1\f$
+    WMF_IV2 = 1 << 2, //!< \f$(|I1-I2|^2+sigma^2)^-1\f$
+    WMF_COS = 1 << 3, //!< \f$dot(I1,I2)/(|I1|*|I2|)\f$
+    WMF_JAC = 1 << 4, //!< \f$(min(r1,r2)+min(g1,g2)+min(b1,b2))/(max(r1,r2)+max(g1,g2)+max(b1,b2))\f$
+    WMF_OFF = 1 << 5  //!< unweighted
+};
+
+/**
+* @brief   Applies weighted median filter to an image.
+*
+* For more details about this implementation, please see @cite zhang2014100+
+*
+* @param   joint       Joint 8-bit, 1-channel or 3-channel image.
+* @param   src         Source 8-bit or floating-point, 1-channel or 3-channel image.
+* @param   dst         Destination image.
+* @param   r           Radius of filtering kernel, should be a positive integer.
+* @param   sigma       Filter range standard deviation for the joint image.
+* @param   weightType  weightType The type of weight definition, see WMFWeightType
+* @param   mask        A 0-1 mask that has the same size with I. This mask is used to ignore the effect of some pixels. If the pixel value on mask is 0,
+*                           the pixel will be ignored when maintaining the joint-histogram. This is useful for applications like optical flow occlusion handling.
+*
+* @sa medianBlur, jointBilateralFilter
+*/
+CV_EXPORTS_W void weightedMedianFilter(InputArray joint, InputArray src, OutputArray dst,
+                                       int r, double sigma = 25.5, int weightType = WMF_EXP, InputArray mask = noArray());
+}
+}
+
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/objc/gen_dict.json b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/objc/gen_dict.json
new file mode 100644
index 00000000..5ae07b20
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/objc/gen_dict.json
@@ -0,0 +1,28 @@
+{
+    "AdditionalImports" : {
+        "*" : [ "\"ximgproc.hpp\"" ]
+    },
+    "missing_consts" : {
+        "Ximgproc" : {
+            "private" : [],
+            "public" : [
+                ["RO_IGNORE_BORDERS", 1], ["RO_STRICT", 0]
+            ]
+        }
+    },
+    "func_arg_fix" : {
+        "Ximgproc" : {
+            "niBlackThreshold" : { "binarizationMethod" : {"ctype" : "LocalBinarizationMethods"} },
+            "HoughPoint2Line" : { "angleRange" : {"ctype" : "AngleRangeOption"},
+                                  "makeSkew" : {"ctype" : "HoughDeskewOption"} },
+            "weightedMedianFilter" : { "weightType" : {"ctype" : "WMFWeightType"} },
+            "createDTFilter" : { "mode" : {"ctype" : "EdgeAwareFiltersList"} },
+            "dtFilter" : { "mode" : {"ctype" : "EdgeAwareFiltersList"} },
+            "thinning" : { "thinningType" : {"ctype" : "ThinningTypes"} },
+            "FastHoughTransform" : { "angleRange" : {"ctype" : "AngleRangeOption"},
+                                     "makeSkew" : {"ctype" : "HoughDeskewOption"},
+                                     "op" : {"ctype" : "HoughOp"} },
+            "createSuperpixelSLIC" : { "algorithm" : {"ctype" : "SLICType"} }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/python/pyopencv_ximgproc.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/python/pyopencv_ximgproc.hpp
new file mode 100644
index 00000000..c7d0a195
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/python/pyopencv_ximgproc.hpp
@@ -0,0 +1,3 @@
+#ifdef HAVE_OPENCV_XIMGPROC
+typedef cv::ximgproc::EdgeDrawing::Params EdgeDrawing_Params;
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/python/test/test_disparity.py b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/python/test/test_disparity.py
new file mode 100644
index 00000000..d797e252
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/python/test/test_disparity.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+import cv2 as cv
+import numpy as np
+
+from tests_common import NewOpenCVTests
+
+class disparity_test(NewOpenCVTests):
+    def test_disp(self):
+        # readGT
+        ret,GT = cv.ximgproc.readGT(self.find_file("cv/disparityfilter/GT.png"))
+        self.assertEqual(ret, 0) # returns 0 on success!
+        self.assertFalse(np.shape(GT) == ())
+
+        # computeMSE
+        left = cv.imread(self.find_file("cv/disparityfilter/disparity_left_raw.png"), cv.IMREAD_UNCHANGED)
+        self.assertFalse(np.shape(left) == ())
+        left = np.asarray(left, dtype=np.int16)
+        mse = cv.ximgproc.computeMSE(GT, left, (0, 0, GT.shape[1], GT.shape[0]))
+
+        # computeBadPixelPercent
+        bad = cv.ximgproc.computeBadPixelPercent(GT, left, (0, 0, GT.shape[1], GT.shape[0]), 24)
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/python/test/test_sparse_match_interpolator.py b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/python/test/test_sparse_match_interpolator.py
new file mode 100644
index 00000000..0b8b977a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/misc/python/test/test_sparse_match_interpolator.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+import numpy as np
+import cv2 as cv
+
+from tests_common import NewOpenCVTests
+
+class Interpolator_test(NewOpenCVTests):
+    def test_edgeaware_interpolator(self):
+        # readGT
+        MAX_DIF = 1.0
+        MAX_MEAN_DIF = 1.0 / 256.0
+
+        src = cv.imread(self.find_file("cv/optflow/RubberWhale1.png"), cv.IMREAD_COLOR)
+        self.assertFalse(src is None)
+
+        ref_flow = cv.readOpticalFlow(self.find_file("cv/sparse_match_interpolator/RubberWhale_reference_result.flo"))
+        self.assertFalse(ref_flow is None)
+
+        matches = np.genfromtxt(self.find_file("cv/sparse_match_interpolator/RubberWhale_sparse_matches.txt")).astype(np.float32)
+        from_points = matches[:,0:2]
+        to_points = matches[:,2:4]
+        interpolator = cv.ximgproc.createEdgeAwareInterpolator()
+        interpolator.setK(128)
+        interpolator.setSigma(0.05)
+        interpolator.setUsePostProcessing(True)
+        interpolator.setFGSLambda(500.0)
+        interpolator.setFGSSigma(1.5)
+
+        dense_flow = interpolator.interpolate(src, from_points, src, to_points)
+
+        self.assertTrue(cv.norm(dense_flow, ref_flow, cv.NORM_INF) <= MAX_DIF)
+        self.assertTrue(cv.norm(dense_flow, ref_flow, cv.NORM_L1) <= (MAX_MEAN_DIF * dense_flow.shape[0] * dense_flow.shape[1]))
+
+    def test_ric_interpolator(self):
+        # readGT
+        MAX_DIF = 6.0
+        MAX_MEAN_DIF = 60.0 / 256.0
+
+        src0 = cv.imread(self.find_file("cv/optflow/RubberWhale1.png"), cv.IMREAD_COLOR)
+        self.assertFalse(src0 is None)
+
+        src1 = cv.imread(self.find_file("cv/optflow/RubberWhale2.png"), cv.IMREAD_COLOR)
+        self.assertFalse(src1 is None)
+
+        ref_flow = cv.readOpticalFlow(self.find_file("cv/sparse_match_interpolator/RubberWhale_reference_result.flo"))
+        self.assertFalse(ref_flow is None)
+
+        matches = np.genfromtxt(self.find_file("cv/sparse_match_interpolator/RubberWhale_sparse_matches.txt")).astype(np.float32)
+        from_points = matches[:,0:2]
+        to_points = matches[:,2:4]
+
+        interpolator = cv.ximgproc.createRICInterpolator()
+        interpolator.setK(32)
+        interpolator.setSuperpixelSize(15)
+        interpolator.setSuperpixelNNCnt(150)
+        interpolator.setSuperpixelRuler(15.0)
+        interpolator.setSuperpixelMode(cv.ximgproc.SLIC)
+        interpolator.setAlpha(0.7)
+        interpolator.setModelIter(4)
+        interpolator.setRefineModels(True)
+        interpolator.setMaxFlow(250)
+        interpolator.setUseVariationalRefinement(True)
+        interpolator.setUseGlobalSmootherFilter(True)
+        interpolator.setFGSLambda(500.0)
+        interpolator.setFGSSigma(1.5)
+        dense_flow = interpolator.interpolate(src0, from_points, src1, to_points)
+        self.assertTrue(cv.norm(dense_flow, ref_flow, cv.NORM_INF) <= MAX_DIF)
+        self.assertTrue(cv.norm(dense_flow, ref_flow, cv.NORM_L1) <= (MAX_MEAN_DIF * dense_flow.shape[0] * dense_flow.shape[1]))
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_adaptive_manifold.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_adaptive_manifold.cpp
new file mode 100644
index 00000000..5d69db8f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_adaptive_manifold.cpp
@@ -0,0 +1,49 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<bool, Size, int, int, MatType> AMPerfTestParam;
+typedef TestBaseWithParam<AMPerfTestParam> AdaptiveManifoldPerfTest;
+
+PERF_TEST_P( AdaptiveManifoldPerfTest, perf,
+    Combine(
+    Values(true, false),            //adjust_outliers flag
+    Values(sz1080p, sz720p),        //size
+    Values(1, 3, 8),                //joint channels num
+    Values(1, 3),                   //source channels num
+    Values(CV_8U, CV_32F)           //source and joint depth
+    )
+)
+{
+    AMPerfTestParam params = GetParam();
+    bool adjustOutliers = get<0>(params);
+    Size sz             = get<1>(params);
+    int jointCnNum      = get<2>(params);
+    int srcCnNum        = get<3>(params);
+    int depth           = get<4>(params);
+
+    Mat joint(sz, CV_MAKE_TYPE(depth, jointCnNum));
+    Mat src(sz, CV_MAKE_TYPE(depth, srcCnNum));
+    Mat dst(sz, CV_MAKE_TYPE(depth, srcCnNum));
+
+    declare.in(joint, src, WARMUP_RNG).out(dst);
+
+    double sigma_s = 16;
+    double sigma_r = 0.5;
+    TEST_CYCLE_N(3)
+    {
+        Mat res;
+        amFilter(joint, src, res, sigma_s, sigma_r, adjustOutliers);
+
+        //at 5th cycle sigma_s will be five times more and tree depth will be 5
+        sigma_s *= 1.38;
+        sigma_r /= 1.38;
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_bilateral_texture_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_bilateral_texture_filter.cpp
new file mode 100644
index 00000000..63be26d4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_bilateral_texture_filter.cpp
@@ -0,0 +1,42 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<int, double, double, Size, MatType, int> BTFTestParam;
+typedef TestBaseWithParam<BTFTestParam> BilateralTextureFilterTest;
+
+PERF_TEST_P(BilateralTextureFilterTest, perf,
+    Combine(
+    Values(2),
+    Values(0.5),
+    Values(0.5),
+    SZ_TYPICAL,
+    Values(CV_8U, CV_32F),
+    Values(1, 3))
+)
+{
+    BTFTestParam params = GetParam();
+    int fr            = get<0>(params);
+    double sigmaAlpha = get<1>(params);
+    double sigmaAvg   = get<2>(params);
+    Size sz           = get<3>(params);
+    int depth         = get<4>(params);
+    int srcCn         = get<5>(params);
+
+    Mat src(sz, CV_MAKE_TYPE(depth,srcCn));
+    Mat dst(sz, src.type());
+
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    TEST_CYCLE_N(1)
+    {
+        bilateralTextureFilter(src, dst, fr, 1, sigmaAlpha, sigmaAvg);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_disparity_wls_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_disparity_wls_filter.cpp
new file mode 100644
index 00000000..f196f810
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_disparity_wls_filter.cpp
@@ -0,0 +1,128 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+#include "opencv2/ximgproc/disparity_filter.hpp"
+
+namespace opencv_test { namespace {
+
+void MakeArtificialExample(RNG rng, Mat& dst_left_view, Mat& dst_left_disparity_map, Mat& dst_right_disparity_map, Rect& dst_ROI);
+
+CV_ENUM(GuideTypes, CV_8UC3);
+CV_ENUM(SrcTypes, CV_16S);
+typedef tuple<GuideTypes, SrcTypes, Size, bool, bool> DisparityWLSParams;
+
+typedef TestBaseWithParam<DisparityWLSParams> DisparityWLSFilterPerfTest;
+
+PERF_TEST_P( DisparityWLSFilterPerfTest, perf, Combine(GuideTypes::all(), SrcTypes::all(), Values(sz720p), Values(true,false), Values(true,false)) )
+{
+    RNG rng(0);
+
+    DisparityWLSParams params = GetParam();
+    int guideType        = get<0>(params);
+    int srcType          = get<1>(params);
+    Size sz              = get<2>(params);
+    bool use_conf        = get<3>(params);
+    bool use_downscale   = get<4>(params);
+
+    Mat guide(sz, guideType);
+    Mat disp_left(sz, srcType);
+    Mat disp_right(sz, srcType);
+    Mat dst(sz, srcType);
+    Rect ROI;
+
+    MakeArtificialExample(rng,guide,disp_left,disp_right,ROI);
+    if(use_downscale)
+    {
+        resize(disp_left,disp_left,Size(),0.5,0.5, INTER_LINEAR_EXACT);
+        disp_left/=2;
+        resize(disp_right,disp_right,Size(),0.5,0.5, INTER_LINEAR_EXACT);
+        disp_right/=2;
+        ROI = Rect(ROI.x/2,ROI.y/2,ROI.width/2,ROI.height/2);
+    }
+
+    TEST_CYCLE_N(10)
+    {
+        Ptr<DisparityWLSFilter> wls_filter = createDisparityWLSFilterGeneric(use_conf);
+        wls_filter->filter(disp_left,guide,dst,disp_right,ROI);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+void MakeArtificialExample(RNG rng, Mat& dst_left_view, Mat& dst_left_disparity_map, Mat& dst_right_disparity_map, Rect& dst_ROI)
+{
+    int w = dst_left_view.cols;
+    int h = dst_left_view.rows;
+
+    //params:
+    unsigned char bg_level = (unsigned char)rng.uniform(0.0,255.0);
+    unsigned char fg_level = (unsigned char)rng.uniform(0.0,255.0);
+    int rect_width  = (int)rng.uniform(w/16,w/2);
+    int rect_height = (int)rng.uniform(h/16,h/2);
+    int rect_disparity = (int)(0.15*w); //typical maximum disparity value
+    double sigma = 6.0;
+
+    int rect_x_offset = (w-rect_width) /2;
+    int rect_y_offset = (h-rect_height)/2;
+
+    if(dst_left_view.channels()==3)
+        dst_left_view = Scalar(Vec3b(bg_level,bg_level,bg_level));
+    else
+        dst_left_view = Scalar(bg_level);
+    dst_left_disparity_map  = Scalar(0);
+    dst_right_disparity_map = Scalar(0);
+    Mat dst_left_view_rect =          Mat(dst_left_view,         Rect(rect_x_offset,rect_y_offset,rect_width,rect_height));
+    Mat dst_left_disparity_map_rect = Mat(dst_left_disparity_map,Rect(rect_x_offset,rect_y_offset,rect_width,rect_height));
+    if(dst_left_view.channels()==3)
+        dst_left_view_rect = Scalar(Vec3b(fg_level,fg_level,fg_level));
+    else
+        dst_left_view_rect = Scalar(fg_level);
+    dst_left_disparity_map_rect = Scalar(16*rect_disparity);
+
+    rect_x_offset-=rect_disparity;
+    Mat dst_right_disparity_map_rect = Mat(dst_right_disparity_map,Rect(rect_x_offset,rect_y_offset,rect_width,rect_height));
+    dst_right_disparity_map_rect = Scalar(-16*rect_disparity);
+
+    //add some gaussian noise:
+    unsigned char *l;
+    short *ldisp, *rdisp;
+    for(int i=0;i<h;i++)
+    {
+        l = dst_left_view.ptr(i);
+        ldisp = (short*)dst_left_disparity_map.ptr(i);
+        rdisp = (short*)dst_right_disparity_map.ptr(i);
+
+        if(dst_left_view.channels()==3)
+        {
+            for(int j=0;j<w;j++)
+            {
+                l[0] = saturate_cast<unsigned char>(l[0] + rng.gaussian(sigma));
+                l[1] = saturate_cast<unsigned char>(l[1] + rng.gaussian(sigma));
+                l[2] = saturate_cast<unsigned char>(l[2] + rng.gaussian(sigma));
+                l+=3;
+                ldisp[0] = saturate_cast<short>(ldisp[0] + rng.gaussian(sigma));
+                ldisp++;
+                rdisp[0] = saturate_cast<short>(rdisp[0] + rng.gaussian(sigma));
+                rdisp++;
+            }
+        }
+        else
+        {
+            for(int j=0;j<w;j++)
+            {
+                l[0] = saturate_cast<unsigned char>(l[0] + rng.gaussian(sigma));
+                l++;
+                ldisp[0] = saturate_cast<short>(ldisp[0] + rng.gaussian(sigma));
+                ldisp++;
+                rdisp[0] = saturate_cast<short>(rdisp[0] + rng.gaussian(sigma));
+                rdisp++;
+            }
+        }
+    }
+
+    dst_ROI = Rect(rect_disparity,0,w-rect_disparity,h);
+}
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_domain_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_domain_transform.cpp
new file mode 100644
index 00000000..6d691e40
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_domain_transform.cpp
@@ -0,0 +1,46 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+CV_ENUM(GuideMatType, CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3) //reduced set
+CV_ENUM(SourceMatType, CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3) //reduced set
+CV_ENUM(DTFMode, DTF_NC, DTF_IC, DTF_RF)
+typedef tuple<GuideMatType, SourceMatType, Size, double, double, DTFMode> DTTestParams;
+
+typedef TestBaseWithParam<DTTestParams> DomainTransformTest;
+
+PERF_TEST_P( DomainTransformTest, perf,
+             Combine(
+                      GuideMatType::all(),
+                      SourceMatType::all(),
+                      Values(szVGA, sz720p),
+                      Values(10.0, 80.0),
+                      Values(30.0, 50.0),
+                      DTFMode::all()
+                    )
+           )
+{
+    int guideType       = get<0>(GetParam());
+    int srcType         = get<1>(GetParam());
+    Size size           = get<2>(GetParam());
+    double sigmaSpatial = get<3>(GetParam());
+    double sigmaColor   = get<4>(GetParam());
+    int dtfType         = get<5>(GetParam());
+
+    Mat guide(size, guideType);
+    Mat src(size, srcType);
+    Mat dst(size, srcType);
+
+    declare.in(guide, src, WARMUP_RNG).out(dst);
+
+    TEST_CYCLE_N(5)
+    {
+        dtFilter(guide, src, dst, sigmaSpatial, sigmaColor, dtfType);
+    }
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_edgepreserving_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_edgepreserving_filter.cpp
new file mode 100644
index 00000000..7d86d165
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_edgepreserving_filter.cpp
@@ -0,0 +1,45 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+//
+//                    Created by Simon Reich
+//
+#include "perf_precomp.hpp"
+
+namespace opencv_test
+{
+namespace
+{
+
+/* 1. Define parameter type and test fixture */
+typedef tuple<int, double> RGFTestParam;
+typedef TestBaseWithParam<RGFTestParam> EdgepreservingFilterTest;
+
+/* 2. Declare the testsuite */
+PERF_TEST_P(EdgepreservingFilterTest, perf,
+            Combine(Values(-20, 0, 10), Values(-100, 0, 20)))
+{
+    /* 3. Get actual test parameters */
+    RGFTestParam params = GetParam();
+    int kernelSize = get<0>(params);
+    double threshold = get<1>(params);
+
+    /* 4. Allocate and initialize arguments for tested function */
+    std::string filename = getDataPath("perf/320x260.png");
+    Mat src = imread(filename, 1);
+    Mat dst(src.size(), src.type());
+
+    /* 5. Manifest your expectations about this test */
+    declare.in(src).out(dst);
+
+    /* 6. Collect the samples! */
+    PERF_SAMPLE_BEGIN();
+        ximgproc::edgePreservingFilter(src, dst, kernelSize, threshold);
+    PERF_SAMPLE_END();
+
+    /* 7. Do not check anything */
+    SANITY_CHECK_NOTHING();
+}
+
+} // namespace
+} // namespace opencv_test
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_fast_hough_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_fast_hough_transform.cpp
new file mode 100644
index 00000000..dee9aadc
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_fast_hough_transform.cpp
@@ -0,0 +1,81 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2015, Smart Engines Ltd, all rights reserved.
+// Copyright (C) 2015, Institute for Information Transmission Problems of the Russian Academy of Sciences (Kharkevich Institute), all rights reserved.
+// Copyright (C) 2015, Dmitry Nikolaev, Simon Karpenko, Michail Aliev, Elena Kuznetsova, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<Size, MatType, MatDepth> srcSize_srcType_dstDepth_t;
+typedef perf::TestBaseWithParam<srcSize_srcType_dstDepth_t>
+        srcSize_srcType_dstDepth;
+
+#define ALL_MAT_DEPHTS CV_8U, CV_8S, CV_16U, CV_32S, CV_32F, CV_64F
+
+PERF_TEST_P(srcSize_srcType_dstDepth, FastHoughTransform,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(TYPICAL_MAT_TYPES),
+                testing::Values(ALL_MAT_DEPHTS)
+                )
+            )
+{
+    Size srcSize  = get<0>(GetParam());
+    int  srcType  = get<1>(GetParam());
+    int  dstDepth = get<2>(GetParam());
+
+    Mat src(srcSize, srcType);
+    Mat fht;
+
+    declare.in(src, WARMUP_RNG);
+
+    TEST_CYCLE_N(3)
+    {
+        FastHoughTransform(src, fht, dstDepth);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+#undef ALL_MAT_DEPHTS
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_fgs_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_fgs_filter.cpp
new file mode 100644
index 00000000..3412ea94
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_fgs_filter.cpp
@@ -0,0 +1,39 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+CV_ENUM(GuideTypes, CV_8UC1, CV_8UC3);
+CV_ENUM(SrcTypes, CV_8UC1, CV_8UC3, CV_16SC1, CV_16SC3, CV_32FC1, CV_32FC3);
+typedef tuple<GuideTypes, SrcTypes, Size> FGSParams;
+
+typedef TestBaseWithParam<FGSParams> FGSFilterPerfTest;
+
+PERF_TEST_P( FGSFilterPerfTest, perf, Combine(GuideTypes::all(), SrcTypes::all(), Values(sz720p)) )
+{
+    RNG rng(0);
+
+    FGSParams params = GetParam();
+    int guideType   = get<0>(params);
+    int srcType     = get<1>(params);
+    Size sz         = get<2>(params);
+
+    Mat guide(sz, guideType);
+    Mat src(sz, srcType);
+    Mat dst(sz, srcType);
+
+    declare.in(guide, src, WARMUP_RNG).out(dst);
+
+    TEST_CYCLE_N(10)
+    {
+        double lambda = rng.uniform(500.0, 10000.0);
+        double sigma  = rng.uniform(1.0, 100.0);
+        fastGlobalSmootherFilter(guide,src,dst,lambda,sigma);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_find_ellipses.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_find_ellipses.cpp
new file mode 100644
index 00000000..0c948fe0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_find_ellipses.cpp
@@ -0,0 +1,27 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace  {
+
+typedef tuple<Size, MatType, int> FindEllipsesTestParam;
+typedef TestBaseWithParam<FindEllipsesTestParam> FindEllipsesTest;
+
+PERF_TEST_P(FindEllipsesTest, perf, Combine(SZ_TYPICAL, Values(CV_8U), Values(1, 3)))
+{
+    FindEllipsesTestParam params = GetParam();
+    Size sz = get<0>(params);
+    int matType = get<1>(params);
+    int srcCn = get<2>(params);
+
+    Mat src(sz, CV_MAKE_TYPE(matType, srcCn));
+    Mat dst(sz, CV_32FC(6));
+
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    TEST_CYCLE() findEllipses(src, dst, 0.7f, 0.5f, 0.05f);
+
+    SANITY_CHECK_NOTHING();
+}
+}} // namespace
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_guided_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_guided_filter.cpp
new file mode 100644
index 00000000..9a0058a5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_guided_filter.cpp
@@ -0,0 +1,39 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+CV_ENUM(GuideTypes, CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3);
+CV_ENUM(SrcTypes, CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3);
+typedef tuple<GuideTypes, SrcTypes, Size> GFParams;
+
+typedef TestBaseWithParam<GFParams> GuidedFilterPerfTest;
+
+PERF_TEST_P( GuidedFilterPerfTest, perf, Combine(GuideTypes::all(), SrcTypes::all(), Values(sz1080p, sz2K)) )
+{
+    RNG rng(0);
+
+    GFParams params = GetParam();
+    int guideType   = get<0>(params);
+    int srcType     = get<1>(params);
+    Size sz         = get<2>(params);
+
+    Mat guide(sz, guideType);
+    Mat src(sz, srcType);
+    Mat dst(sz, srcType);
+
+    declare.in(guide, src, WARMUP_RNG).out(dst);
+
+    TEST_CYCLE_N(3)
+    {
+        int radius = rng.uniform(5, 30);
+        double eps = rng.uniform(0.1, 1e5);
+        guidedFilter(guide, src, dst, radius, eps);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_joint_bilateral_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_joint_bilateral_filter.cpp
new file mode 100644
index 00000000..4894fd91
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_joint_bilateral_filter.cpp
@@ -0,0 +1,45 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<double, Size, MatType, int, int> JBFTestParam;
+typedef TestBaseWithParam<JBFTestParam> JointBilateralFilterTest;
+
+PERF_TEST_P(JointBilateralFilterTest, perf,
+    Combine(
+    Values(4.0, 10.0),
+    SZ_TYPICAL,
+    Values(CV_8U, CV_32F),
+    Values(1, 3),
+    Values(1, 3))
+)
+{
+    JBFTestParam params = GetParam();
+    double sigmaS   = get<0>(params);
+    Size sz         = get<1>(params);
+    int depth       = get<2>(params);
+    int jCn         = get<3>(params);
+    int srcCn       = get<4>(params);
+
+    Mat joint(sz, CV_MAKE_TYPE(depth, jCn));
+    Mat src(sz, CV_MAKE_TYPE(depth, srcCn));
+    Mat dst(sz, src.type());
+
+    declare.in(joint, src, WARMUP_RNG).out(dst);
+
+    RNG rnd(cvRound(10*sigmaS) + sz.height + depth + jCn + srcCn);
+    double sigmaC = rnd.uniform(1.0, 255.0);
+
+    TEST_CYCLE_N(1)
+    {
+        jointBilateralFilter(joint, src, dst, 0, sigmaC, sigmaS);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_l0_smooth.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_l0_smooth.cpp
new file mode 100644
index 00000000..a535b20e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_l0_smooth.cpp
@@ -0,0 +1,41 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<Size, MatType, int> L0SmoothTestParam;
+typedef TestBaseWithParam<L0SmoothTestParam> L0SmoothTest;
+
+PERF_TEST_P(L0SmoothTest, perf,
+    Combine(
+    SZ_TYPICAL,
+    Values(CV_8U, CV_16U, CV_32F, CV_64F),
+    Values(1, 3))
+)
+{
+    L0SmoothTestParam params = GetParam();
+    Size sz         = get<0>(params);
+    int depth       = get<1>(params);
+    int srcCn        = get<2>(params);
+
+    Mat src(sz, CV_MAKE_TYPE(depth, srcCn));
+    Mat dst(sz, src.type());
+
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    RNG rnd(sz.height + depth + srcCn);
+    double lambda = rnd.uniform(0.01, 0.05);
+    double kappa = rnd.uniform(1.0, 3.0);
+
+    TEST_CYCLE_N(1)
+    {
+        l0Smooth(src, dst, lambda, kappa);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_main.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_main.cpp
new file mode 100644
index 00000000..b027d51c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_main.cpp
@@ -0,0 +1,6 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+CV_PERF_TEST_MAIN(edgefilter)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_precomp.hpp
new file mode 100644
index 00000000..622b7107
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_precomp.hpp
@@ -0,0 +1,15 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#ifndef __OPENCV_PERF_PRECOMP_HPP__
+#define __OPENCV_PERF_PRECOMP_HPP__
+
+#include <opencv2/ts.hpp>
+#include <opencv2/ximgproc.hpp>
+
+namespace opencv_test {
+using namespace perf;
+using namespace cv::ximgproc;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_radon_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_radon_transform.cpp
new file mode 100644
index 00000000..f9f88f10
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_radon_transform.cpp
@@ -0,0 +1,35 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<Size, MatType> RadonTransformPerfTestParam;
+typedef perf::TestBaseWithParam<RadonTransformPerfTestParam> RadonTransformPerfTest;
+
+PERF_TEST_P(RadonTransformPerfTest, perf,
+    testing::Combine(
+        testing::Values(TYPICAL_MAT_SIZES),
+        testing::Values(CV_8UC1, CV_32FC1, CV_64FC1)
+    )
+)
+{
+    Size srcSize = get<0>(GetParam());
+    int  srcType = get<1>(GetParam());
+
+    Mat src(srcSize, srcType);
+    Mat radon;
+
+    declare.in(src, WARMUP_RNG);
+
+    TEST_CYCLE()
+    {
+        RadonTransform(src, radon);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+} }
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_ridge_detection_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_ridge_detection_filter.cpp
new file mode 100644
index 00000000..8d6db950
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_ridge_detection_filter.cpp
@@ -0,0 +1,34 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<MatDepth, int, Size> RDFParams;
+typedef TestBaseWithParam<RDFParams> RidgeDetectionFilterPerfTest;
+
+PERF_TEST_P(RidgeDetectionFilterPerfTest, perf, Combine(
+        Values((MatDepth)CV_32F),
+        Values(3),
+        SZ_TYPICAL
+))
+{
+    RDFParams params = GetParam();
+    int ddepth = get<0>(params);
+    int ksize = get<1>(params);
+    Size sz = get<2>(params);
+
+    Mat src(sz, ddepth);
+    Mat out(sz, src.type());
+
+    declare.in(src).out(out);
+
+    Ptr<RidgeDetectionFilter> rdf = RidgeDetectionFilter::create(ddepth,1, 1, ksize);
+
+    TEST_CYCLE() rdf->getRidgeFilteredImage(src, out);
+
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_rolling_guidance_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_rolling_guidance_filter.cpp
new file mode 100644
index 00000000..d6a36116
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_rolling_guidance_filter.cpp
@@ -0,0 +1,43 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<double, Size, MatType, int> RGFTestParam;
+typedef TestBaseWithParam<RGFTestParam> RollingGuidanceFilterTest;
+
+PERF_TEST_P(RollingGuidanceFilterTest, perf,
+    Combine(
+    Values(2.0, 4.0, 6.0, 10.0),
+    SZ_TYPICAL,
+    Values(CV_8U, CV_32F),
+    Values(1, 3))
+)
+{
+    RGFTestParam params = GetParam();
+    double sigmaS   = get<0>(params);
+    Size sz         = get<1>(params);
+    int depth       = get<2>(params);
+    int srcCn       = get<3>(params);
+
+    Mat src(sz, CV_MAKE_TYPE(depth, srcCn));
+    Mat dst(sz, src.type());
+
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    RNG rnd(cvRound(10*sigmaS) + sz.height + depth + srcCn);
+    double sigmaC = rnd.uniform(1.0, 255.0);
+    int iterNum = int(rnd.uniform(1.0, 5.0));
+
+    TEST_CYCLE_N(1)
+    {
+        rollingGuidanceFilter(src, dst, -1, sigmaC, sigmaS, iterNum);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_run_length_morphology.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_run_length_morphology.cpp
new file mode 100644
index 00000000..7ab542d8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_run_length_morphology.cpp
@@ -0,0 +1,37 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test {
+namespace {
+
+typedef tuple<int, Size, int> RLParams;
+
+typedef TestBaseWithParam<RLParams> RLMorphologyPerfTest;
+
+PERF_TEST_P(RLMorphologyPerfTest, perf, Combine(Values(1,7, 21), Values(sz720p, sz2160p),
+    Values(MORPH_ERODE, MORPH_DILATE, MORPH_OPEN, MORPH_CLOSE, MORPH_GRADIENT,MORPH_TOPHAT, MORPH_BLACKHAT)))
+{
+    RLParams params = GetParam();
+    int seSize = get<0>(params);
+    Size sz = get<1>(params);
+    int op = get<2>(params);
+
+    Mat src(sz, CV_8U);
+    Mat thresholded, dstRLE;
+    Mat se = rl::getStructuringElement(MORPH_ELLIPSE, cv::Size(2 * seSize + 1, 2 * seSize + 1));
+
+    declare.in(src, WARMUP_RNG);
+
+    TEST_CYCLE_N(4)
+    {
+        rl::threshold(src, thresholded, 100.0, THRESH_BINARY);
+        rl::morphologyEx(thresholded, dstRLE, op, se);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+}
+} // namespace
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_weighted_median_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_weighted_median_filter.cpp
new file mode 100644
index 00000000..349e5ff4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/perf/perf_weighted_median_filter.cpp
@@ -0,0 +1,48 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<Size, MatType, int, int, int, WMFWeightType> WMFTestParam;
+typedef TestBaseWithParam<WMFTestParam> WeightedMedianFilterTest;
+
+PERF_TEST_P(WeightedMedianFilterTest, perf,
+    Combine(
+    Values(szODD, szQVGA),
+    Values(CV_8U, CV_32F),
+    Values(1, 3),
+    Values(1, 3),
+    Values(3, 5),
+    Values(WMF_EXP, WMF_COS))
+)
+{
+    RNG rnd(1);
+
+    WMFTestParam params = GetParam();
+
+    double sigma   = rnd.uniform(20.0, 30.0);
+    Size sz         = get<0>(params);
+    int srcDepth       = get<1>(params);
+    int jCn         = get<2>(params);
+    int srcCn       = get<3>(params);
+    int r = get<4>(params);
+    WMFWeightType weightType = get<5>(params);
+
+    Mat joint(sz, CV_MAKE_TYPE(CV_8U, jCn));
+    Mat src(sz, CV_MAKE_TYPE(srcDepth, srcCn));
+    Mat dst(sz, src.type());
+
+    declare.in(joint, src, WARMUP_RNG).out(dst);
+
+    TEST_CYCLE_N(1)
+    {
+        weightedMedianFilter(joint, src, dst, r, sigma, weightType);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/CMakeLists.txt b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/CMakeLists.txt
new file mode 100644
index 00000000..aa6d6a6d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/CMakeLists.txt
@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 2.8)
+project(live_demo)
+find_package(OpenCV 3.0 REQUIRED)
+
+set(SOURCES live_demo.cpp)
+
+include_directories(${OpenCV_INCLUDE_DIRS})
+add_executable(live_demo ${SOURCES} ${HEADERS})
+target_link_libraries(live_demo ${OpenCV_LIBS})
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/brightedgesexample.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/brightedgesexample.cpp
new file mode 100644
index 00000000..116b067d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/brightedgesexample.cpp
@@ -0,0 +1,106 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2017, IBM Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//      Marc Fiammante marc.fiammante@fr.ibm.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of OpenCV Foundation or contributors may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the OpenCV Foundation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <stdio.h>
+#include <iostream>
+#include "opencv2/ximgproc.hpp"
+using namespace cv;
+using namespace ximgproc;
+using namespace std;
+
+static void help()
+{
+    printf("\nThis sample demonstrates BrightEdge detection\n"
+        "Call:\n"
+        "    /.edge [image_name -- Default is ../data/ml.png]\n\n");
+}
+const char* keys =
+{
+    "{help h||}{@image |../data/ml.png|input image name}"
+};
+int main(int argc, const char** argv)
+{
+    CommandLineParser parser(argc, argv, keys);
+    if (parser.has("help"))
+    {
+        help();
+        return 0;
+    }
+    string filename = parser.get<string>(0);
+    Mat image = imread(filename, IMREAD_COLOR);
+    if (image.empty())
+    {
+        printf("Cannot read image file: %s\n", filename.c_str());
+        help();
+        return -1;
+    }
+    // Create a window
+    // //  " original ";
+    namedWindow("Original");
+    imshow("Original", image);
+    //  " absdiff ";
+    Mat edge;
+    BrightEdges(image, edge, 0); //  No contrast
+    namedWindow("Absolute Difference");
+    imshow("Absolute Difference", edge);
+    // " default contrast 1 ";
+    BrightEdges(image, edge);
+    namedWindow("Default contrast");
+    imshow("Default contrast", edge);// Default contrast 1
+    // " Contrast 5  \n";
+    BrightEdges(image, edge, 5);
+    namedWindow("Contrast 5");
+    imshow("Contrast 5", edge);
+    // " Contrast 10  \n";
+    BrightEdges(image, edge, 10);
+    namedWindow("Contrast 10");
+    imshow("Contrast 10", edge);
+    //  "wait key ";
+    waitKey(0);
+    //  "end  ";
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/color_match_template.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/color_match_template.cpp
new file mode 100644
index 00000000..e7519102
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/color_match_template.cpp
@@ -0,0 +1,96 @@
+#include <iostream>
+#include <fstream>
+#include <opencv2/core.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/ximgproc.hpp>
+#include <opencv2/ximgproc/color_match.hpp>
+
+using namespace std;
+using namespace cv;
+
+
+
+static void AddSlider(String sliderName, String windowName, int minSlider, int maxSlider, int valDefault, int *valSlider, void(*f)(int, void *), void *r)
+{
+    createTrackbar(sliderName, windowName, valSlider, 1, f, r);
+    setTrackbarMin(sliderName, windowName, minSlider);
+    setTrackbarMax(sliderName, windowName, maxSlider);
+    setTrackbarPos(sliderName, windowName, valDefault);
+}
+
+struct SliderData {
+    Mat img;
+    int thresh;
+};
+
+static void UpdateThreshImage(int , void *r)
+{
+    SliderData *p = (SliderData*)r;
+    Mat dst,labels,stats,centroids;
+
+    threshold(p->img, dst, p->thresh, 255, THRESH_BINARY);
+
+    connectedComponentsWithStats(dst, labels, stats, centroids, 8);
+    if (centroids.rows < 10)
+    {
+        cout << "**********************************************************************************\n";
+        for (int i = 0; i < centroids.rows; i++)
+        {
+            cout << dst.cols - centroids.at<double>(i, 0)  << " ";
+            cout << dst.rows -  centroids.at<double>(i, 1)  << "\n";
+        }
+        cout << "----------------------------------------------------------------------------------\n";
+    }
+    flip(dst, dst, -1);
+
+    imshow("Max Quaternion corr",dst);
+}
+
+int main(int argc, char *argv[])
+{
+    cv::CommandLineParser parser(argc, argv,
+        "{help h | | match color image }{@colortemplate | | input color template image}{@colorimage | | input color image}");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return -1;
+    }
+    string templateName = parser.get<string>("@colortemplate");
+    if (templateName.empty())
+    {
+        parser.printMessage();
+        parser.printErrors();
+        return -2;
+    }
+    string colorImageName = parser.get<string>("@colorimage");
+    if (templateName.empty())
+    {
+        parser.printMessage();
+        parser.printErrors();
+        return -2;
+    }
+    Mat imgLogo = imread(templateName, IMREAD_COLOR);
+    Mat imgColor = imread(colorImageName, IMREAD_COLOR);
+    imshow("Image", imgColor);
+    imshow("template", imgLogo);
+    // OK NOW WHERE IS OPENCV LOGO ?
+    Mat imgcorr;
+    SliderData ps;
+    ximgproc::colorMatchTemplate(imgColor, imgLogo, imgcorr);
+    imshow("quaternion correlation real", imgcorr);
+    normalize(imgcorr, imgcorr,1,0,NORM_MINMAX);
+    imgcorr.convertTo(ps.img, CV_8U, 255);
+    imshow("quaternion correlation", imgcorr);
+    ps.thresh = 0;
+    AddSlider("Level", "quaternion correlation", 0, 255, ps.thresh, &ps.thresh, UpdateThreshImage, &ps);
+    int code = 0;
+    while (code != 27)
+    {
+        code = waitKey(50);
+    }
+
+    waitKey(0);
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/colorize.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/colorize.cpp
new file mode 100644
index 00000000..b44f02da
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/colorize.cpp
@@ -0,0 +1,417 @@
+
+#include "opencv2/core.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/core/utility.hpp"
+
+#include <time.h>
+#include <vector>
+#include <iostream>
+#include <opencv2/ximgproc.hpp>
+
+
+
+using namespace cv;
+
+#ifdef HAVE_EIGEN
+
+#define MARK_RADIUS 5
+#define PALLET_RADIUS 100
+int max_width = 1280;
+int max_height = 720;
+
+static int globalMouseX;
+static int globalMouseY;
+static int selected_r;
+static int selected_g;
+static int selected_b;
+static bool globalMouseClick = false;
+static bool glb_mouse_left = false;
+static bool drawByReference = false;
+static bool mouseDraw = false;
+static bool mouseClick;
+static bool mouseLeft;
+static int mouseX;
+static int mouseY;
+
+cv::Mat mat_draw;
+cv::Mat mat_input_gray;
+cv::Mat mat_input_reference;
+cv::Mat mat_input_confidence;
+cv::Mat mat_pallet(PALLET_RADIUS*2,PALLET_RADIUS*2,CV_8UC3);
+
+
+static void mouseCallback(int event, int x, int y, int flags, void* param);
+void drawTrajectoryByReference(cv::Mat& img);
+double module(Point pt);
+double distance(Point pt1, Point pt2);
+double cross(Point pt1, Point pt2);
+double angle(Point pt1, Point pt2);
+int inCircle(Point p, Point c, int r);
+void createPlate(Mat &im1, int radius);
+
+
+#endif
+
+const String keys =
+    "{help h usage ?     |                | print this message                                                }"
+    "{@image             |                | input image                                                       }"
+    "{sigma_spatial      |8               | parameter of post-filtering                                       }"
+    "{sigma_luma         |8               | parameter of post-filtering                                       }"
+    "{sigma_chroma       |8               | parameter of post-filtering                                       }"
+    "{dst_path           |None            | optional path to save the resulting colorized image               }"
+    "{dst_raw_path       |None            | optional path to save drawed image before filtering               }"
+    "{draw_by_reference  |false           | optional flag to use color image as reference                     }"
+    ;
+
+
+
+int main(int argc, char* argv[])
+{
+
+    CommandLineParser parser(argc,argv,keys);
+    parser.about("fastBilateralSolverFilter Demo");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+#ifdef HAVE_EIGEN
+
+    String img = parser.get<String>(0);
+    double sigma_spatial  = parser.get<double>("sigma_spatial");
+    double sigma_luma  = parser.get<double>("sigma_luma");
+    double sigma_chroma  = parser.get<double>("sigma_chroma");
+    String dst_path = parser.get<String>("dst_path");
+    String dst_raw_path = parser.get<String>("dst_raw_path");
+    drawByReference = parser.get<bool>("draw_by_reference");
+
+    mat_input_reference = cv::imread(img, IMREAD_COLOR);
+    if (mat_input_reference.empty())
+    {
+        std::cerr << "input image '" << img << "' could not be read !" << std::endl << std::endl;
+        parser.printMessage();
+        return 1;
+    }
+
+    cvtColor(mat_input_reference, mat_input_gray, COLOR_BGR2GRAY);
+
+    if(mat_input_gray.cols > max_width)
+    {
+        double scale = float(max_width) / float(mat_input_gray.cols);
+        cv::resize(mat_input_reference, mat_input_reference, cv::Size(), scale, scale);
+        cv::resize(mat_input_gray, mat_input_gray, cv::Size(), scale, scale);
+    }
+
+    if(mat_input_gray.rows > max_height)
+    {
+        double scale = float(max_height) / float(mat_input_gray.rows);
+        cv::resize(mat_input_reference, mat_input_reference, cv::Size(), scale, scale);
+        cv::resize(mat_input_gray, mat_input_gray, cv::Size(), scale, scale);
+    }
+
+
+    float filtering_time;
+    std::cout << "mat_input_reference:" << mat_input_reference.cols<<"x"<< mat_input_reference.rows<< std::endl;
+    std::cout << "please select a color from the palette, by clicking into that," << std::endl;
+    std::cout << "  then select a coarse region in the image to be coloured." << std::endl;
+    std::cout << "  press 'escape' to see the final coloured image." << std::endl;
+
+
+    cv::Mat mat_gray;
+    cv::cvtColor(mat_input_reference, mat_gray, cv::COLOR_BGR2GRAY);
+
+    cv::Mat target = mat_input_reference.clone();
+    cvtColor(mat_gray, mat_input_reference, COLOR_GRAY2BGR);
+
+    cv::namedWindow("draw", cv::WINDOW_AUTOSIZE);
+
+    // construct pallet
+    createPlate(mat_pallet, PALLET_RADIUS);
+    selected_b = 0;
+    selected_g = 0;
+    selected_r = 0;
+
+    cv::Mat mat_show(target.rows,target.cols+PALLET_RADIUS*2,CV_8UC3);
+    cv::Mat color_select(target.rows-mat_pallet.rows,PALLET_RADIUS*2,CV_8UC3,cv::Scalar(selected_b, selected_g, selected_r));
+    target.copyTo(Mat(mat_show,Rect(0,0,target.cols,target.rows)));
+    mat_pallet.copyTo(Mat(mat_show,Rect(target.cols,0,mat_pallet.cols,mat_pallet.rows)));
+    color_select.copyTo(Mat(mat_show,Rect(target.cols,PALLET_RADIUS*2,color_select.cols,color_select.rows)));
+
+    cv::imshow("draw", mat_show);
+    cv::setMouseCallback("draw", mouseCallback, (void *)&mat_show);
+    mat_input_confidence = 0*cv::Mat::ones(mat_gray.size(),mat_gray.type());
+
+    int show_count = 0;
+    while (1)
+    {
+            mouseX = globalMouseX;
+            mouseY = globalMouseY;
+            mouseClick = globalMouseClick;
+            mouseLeft = glb_mouse_left;
+
+
+        if (mouseClick)
+        {
+            drawTrajectoryByReference(target);
+
+            if(show_count%5==0)
+            {
+                cv::Mat target_temp(target.size(),target.type());
+                filtering_time = static_cast<float>(getTickCount());
+                if(mouseDraw)
+                {
+                    cv::cvtColor(target, target_temp, cv::COLOR_BGR2YCrCb);
+                    std::vector<cv::Mat> src_channels;
+                    std::vector<cv::Mat> dst_channels;
+
+                    cv::split(target_temp,src_channels);
+
+                    cv::Mat result1 = cv::Mat(mat_input_gray.size(),mat_input_gray.type());
+                    cv::Mat result2 = cv::Mat(mat_input_gray.size(),mat_input_gray.type());
+
+                    dst_channels.push_back(mat_input_gray);
+                    cv::ximgproc::fastBilateralSolverFilter(mat_input_gray,src_channels[1],mat_input_confidence,result1,sigma_spatial,sigma_luma,sigma_chroma);
+                    dst_channels.push_back(result1);
+                    cv::ximgproc::fastBilateralSolverFilter(mat_input_gray,src_channels[2],mat_input_confidence,result2,sigma_spatial,sigma_luma,sigma_chroma);
+                    dst_channels.push_back(result2);
+
+                    cv::merge(dst_channels,target_temp);
+                    cv::cvtColor(target_temp, target_temp, cv::COLOR_YCrCb2BGR);
+                }
+                else
+                {
+                  target_temp = target.clone();
+                }
+                filtering_time = static_cast<float>(((double)getTickCount() - filtering_time)/getTickFrequency());
+                std::cout << "solver time: " << filtering_time << "s" << std::endl;
+
+                cv::Mat color_selected(target_temp.rows-mat_pallet.rows,PALLET_RADIUS*2,CV_8UC3,cv::Scalar(selected_b, selected_g, selected_r));
+                target_temp.copyTo(Mat(mat_show,Rect(0,0,target_temp.cols,target_temp.rows)));
+                mat_pallet.copyTo(Mat(mat_show,Rect(target_temp.cols,0,mat_pallet.cols,mat_pallet.rows)));
+                color_selected.copyTo(Mat(mat_show,Rect(target_temp.cols,PALLET_RADIUS*2,color_selected.cols,color_selected.rows)));
+                cv::imshow("draw", mat_show);
+            }
+            show_count++;
+        }
+        if (cv::waitKey(2) == 27)
+            break;
+    }
+    mat_draw = target.clone();
+    cv::cvtColor(target, target, cv::COLOR_BGR2YCrCb);
+
+    std::vector<cv::Mat> src_channels;
+    std::vector<cv::Mat> dst_channels;
+
+    cv::split(target,src_channels);
+
+    cv::Mat result1 = cv::Mat(mat_input_gray.size(),mat_input_gray.type());
+    cv::Mat result2 = cv::Mat(mat_input_gray.size(),mat_input_gray.type());
+
+    filtering_time = static_cast<float>(getTickCount());
+
+    // dst_channels.push_back(src_channels[0]);
+    dst_channels.push_back(mat_input_gray);
+    cv::ximgproc::fastBilateralSolverFilter(mat_input_gray,src_channels[1],mat_input_confidence,result1,sigma_spatial,sigma_luma,sigma_chroma);
+    dst_channels.push_back(result1);
+    cv::ximgproc::fastBilateralSolverFilter(mat_input_gray,src_channels[2],mat_input_confidence,result2,sigma_spatial,sigma_luma,sigma_chroma);
+    dst_channels.push_back(result2);
+
+    cv::merge(dst_channels,target);
+    cv::cvtColor(target, target, cv::COLOR_YCrCb2BGR);
+
+    filtering_time = static_cast<float>(((double)getTickCount() - filtering_time)/getTickFrequency());
+    std::cout << "solver time: " << filtering_time << "s" << std::endl;
+
+
+
+    cv::imshow("mat_draw",mat_draw);
+    cv::imshow("output",target);
+
+    if(dst_path!="None")
+    {
+        imwrite(dst_path,target);
+    }
+    if(dst_raw_path!="None")
+    {
+        imwrite(dst_raw_path,mat_draw);
+    }
+
+    cv::waitKey(0);
+
+
+
+#else
+    std::cout << "Can not find eigen, please build with eigen by set WITH_EIGEN=ON" << '\n';
+#endif
+
+    return 0;
+}
+
+
+#ifdef HAVE_EIGEN
+static void mouseCallback(int event, int x, int y, int, void*)
+{
+    switch (event)
+    {
+        case cv::EVENT_MOUSEMOVE:
+            if (globalMouseClick)
+            {
+                globalMouseX = x;
+                globalMouseY = y;
+            }
+            break;
+
+        case cv::EVENT_LBUTTONDOWN:
+            globalMouseClick = true;
+            globalMouseX = x;
+            globalMouseY = y;
+            break;
+
+        case cv::EVENT_LBUTTONUP:
+            glb_mouse_left = true;
+            globalMouseClick = false;
+            break;
+    }
+}
+
+void drawTrajectoryByReference(cv::Mat& img)
+{
+    int i, j;
+    uchar red, green, blue;
+    float gray;
+    int y, x;
+    int r = MARK_RADIUS;
+    int r2 = r * r;
+    uchar* colorPix;
+    uchar* grayPix;
+
+    if(mouseY < PALLET_RADIUS*2 && img.cols <= mouseX && mouseX < img.cols+PALLET_RADIUS*2)
+    {
+        colorPix = mat_pallet.ptr<uchar>(mouseY, mouseX - img.cols);
+        // colorPix = mat_pallet.ptr<uchar>(mouseY, mouseX);
+        selected_b = *colorPix;
+        colorPix++;
+        selected_g = *colorPix;
+        colorPix++;
+        selected_r = *colorPix;
+        colorPix++;
+        std::cout << "x y:("<<mouseX<<"," <<mouseY<< " rgb_select:("<< selected_r<<","<<selected_g<<","<<selected_b<<")" << '\n';
+    }
+    else
+    {
+        mouseDraw = true;
+        y = mouseY - r;
+        for(i=-r; i<r+1 ; i++, y++)
+        {
+            x = mouseX - r;
+            colorPix = mat_input_reference.ptr<uchar>(y, x);
+            grayPix = mat_input_gray.ptr<uchar>(y, x);
+            for(j=-r; j<r+1; j++, x++)
+            {
+                if(i*i + j*j > r2)
+                {
+                    colorPix += mat_input_reference.channels();
+                    grayPix += mat_input_gray.channels();
+                    continue;
+                }
+
+                if(y<0 || y>=mat_input_reference.rows || x<0 || x>=mat_input_reference.cols)
+                {
+                    break;
+                }
+
+                blue = *colorPix;
+                colorPix++;
+                green = *colorPix;
+                colorPix++;
+                red = *colorPix;
+                colorPix++;
+                gray = *grayPix;
+                grayPix++;
+                mat_input_confidence.at<uchar>(y,x) = 255;
+                float draw_y = 0.229f*(float(selected_r)) + 0.587f*(float(selected_g)) + 0.114f*(float(selected_b));
+                int draw_b = int(float(selected_b)*(gray/draw_y));
+                int draw_g = int(float(selected_g)*(gray/draw_y));
+                int draw_r = int(float(selected_r)*(gray/draw_y));
+
+                if(drawByReference)
+                {
+                    cv::circle(img, cv::Point2d(x, y), 1, cv::Scalar(blue, green, red), -1);
+                }
+                else
+                {
+                    cv::circle(img, cv::Point2d(x, y), 1, cv::Scalar(draw_b, draw_g, draw_r), -1);
+                }
+            }
+        }
+    }
+}
+
+double module(Point pt)
+{
+	return sqrt((double)pt.x*pt.x + pt.y*pt.y);
+}
+
+double distance(Point pt1, Point pt2)
+{
+	int dx = pt1.x - pt2.x;
+	int dy = pt1.y - pt2.y;
+	return sqrt((double)dx*dx + dy*dy);
+}
+
+double cross(Point pt1, Point pt2)
+{
+	return pt1.x*pt2.x + pt1.y*pt2.y;
+}
+
+double angle(Point pt1, Point pt2)
+{
+	return acos(cross(pt1, pt2) / (module(pt1)*module(pt2) + DBL_EPSILON));
+}
+
+// p or c is the center
+int inCircle(Point p, Point c, int r)
+{
+	int dx = p.x - c.x;
+	int dy = p.y - c.y;
+	return dx*dx + dy*dy <= r*r ? 1 : 0;
+
+}
+
+//draw the hsv-plate
+void createPlate(Mat &im1, int radius)
+{
+	Mat hsvImag(Size(radius << 1, radius << 1), CV_8UC3, Scalar(0, 0, 255));
+	int w = hsvImag.cols;
+	int h = hsvImag.rows;
+	int cx = w >> 1;
+	int cy = h >> 1;
+	Point pt1(cx, 0);
+
+	for (int j = 0; j < w; j++)
+	{
+		for (int i = 0; i < h; i++)
+		{
+			Point pt2(j - cx, i - cy);
+			if (inCircle(Point(0, 0), pt2, radius))
+			{
+				int theta = static_cast<int>(angle(pt1, pt2) * 180 / CV_PI);
+				if (i > cx)
+				{
+					theta = -theta + 360;
+				}
+				hsvImag.at<Vec3b>(i, j)[0] = saturate_cast<uchar>(theta / 2);
+				hsvImag.at<Vec3b>(i, j)[1] = saturate_cast<uchar>(module(pt2) / cx * 255);
+				hsvImag.at<Vec3b>(i, j)[2] = 255;
+			}
+		}
+	}
+
+
+	cvtColor(hsvImag, im1, COLOR_HSV2BGR);
+}
+
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/dericheSample.py b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/dericheSample.py
new file mode 100644
index 00000000..917db05a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/dericheSample.py
@@ -0,0 +1,59 @@
+import sys
+import numpy as np
+import cv2 as cv
+
+def AddSlider(sliderName,windowName,minSlider,maxSlider,valDefault, update=[]):
+    if update is None:
+        cv.createTrackbar(sliderName, windowName, valDefault,maxSlider-minSlider+1)
+    else:
+        cv.createTrackbar(sliderName, windowName, valDefault,maxSlider-minSlider+1, update)
+    cv.setTrackbarMin(sliderName, windowName, minSlider)
+    cv.setTrackbarMax(sliderName, windowName, maxSlider)
+    cv.setTrackbarPos(sliderName, windowName, valDefault)
+class Filtrage:
+    def __init__(self):
+        self.s =0
+        self.alpha = 100
+        self.omega = 100
+        self.updateFiltre=True
+        self.img=[]
+        self.dximg=[]
+        self.dyimg=[]
+        self.module=[]
+    def DericheFilter(self):
+        self.dximg = cv.ximgproc.GradientDericheX(	self.img, self.alpha/100., self.omega/1000.	)
+        self.dyimg = cv.ximgproc.GradientDericheY(	self.img, self.alpha/100., self.omega/1000.	)
+        dx2=self.dximg*self.dximg
+        dy2=self.dyimg*self.dyimg
+        self.module = np.sqrt(dx2+dy2)
+        cv.normalize(src=self.module,dst=self.module,norm_type=cv.NORM_MINMAX)
+    def SlideBarDeriche(self):
+        cv.namedWindow(self.filename)
+        AddSlider("alpha",self.filename,1,400,self.alpha,self.UpdateAlpha)
+        AddSlider("omega",self.filename,1,1000,self.omega,self.UpdateOmega)
+
+    def UpdateOmega(self,x ):
+        self.updateFiltre=True
+        self.omega=x
+    def UpdateAlpha(self,x ):
+        self.updateFiltre=True
+        self.alpha=x
+    def run(self,argv):
+        # Load the source image
+        self.filename = argv[0] if len(argv) > 0 else "../doc/pics/corridor_fld.jpg"
+        self.img=cv.imread(self.filename,cv.IMREAD_GRAYSCALE)
+        if self.img is None:
+            print ('cannot read file')
+            return
+        self.SlideBarDeriche()
+        while True:
+            cv.imshow(self.filename,self.img)
+            if self.updateFiltre:
+                self.DericheFilter()
+                cv.imshow("module",self.module)
+                self.updateFiltre =False
+            code = cv.waitKey(10)
+            if code==27:
+                break
+if __name__ == '__main__':
+    Filtrage().run(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/deriche_demo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/deriche_demo.cpp
new file mode 100644
index 00000000..403b8553
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/deriche_demo.cpp
@@ -0,0 +1,120 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  *Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+#include <opencv2/core.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/ximgproc.hpp>
+#include "opencv2/ximgproc/deriche_filter.hpp"
+
+using namespace cv;
+using namespace cv::ximgproc;
+
+#include <iostream>
+using namespace std;
+
+int alDerive=100;
+int alMean=100;
+Ptr<Mat> img;
+const string & winName = "Gradient Modulus";
+
+static void DisplayImage(Mat x,string s)
+{
+	vector<Mat> sx;
+	split(x, sx);
+	vector<double> minVal(3), maxVal(3);
+	for (size_t i = 0; i < sx.size(); i++)
+	{
+		minMaxLoc(sx[i], &minVal[i], &maxVal[i]);
+	}
+	maxVal[0] = *max_element(maxVal.begin(), maxVal.end());
+	minVal[0] = *min_element(minVal.begin(), minVal.end());
+	Mat uc;
+	x.convertTo(uc, CV_8U,255/(maxVal[0]-minVal[0]),-255*minVal[0]/(maxVal[0]-minVal[0]));
+	imshow(s, uc);
+}
+
+
+/**
+ * @function DericheFilter
+ * @brief Trackbar callback
+ */
+static void DericheFilter(int, void*)
+{
+    Mat dst;
+    double d=alDerive/100.0,m=alMean/100.0;
+    Mat rx,ry;
+    GradientDericheX(*img.get(),rx,d,m);
+    GradientDericheY(*img.get(),ry,d,m);
+    DisplayImage(rx, "Gx");
+    DisplayImage(ry, "Gy");
+    add(rx.mul(rx),ry.mul(ry),dst);
+    sqrt(dst,dst);
+    DisplayImage(dst, winName );
+}
+
+int main(int argc, char* argv[])
+{
+    Mat *m=new Mat;
+    cv::CommandLineParser parser(argc, argv, "{help h | | show help message}{@input | | input image}");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return -1;
+    }
+    string input_image = parser.get<string>("@input");
+    if (input_image.empty())
+    {
+        parser.printMessage();
+        parser.printErrors();
+        return -2;
+    }
+    if (argc==2)
+        *m = imread(input_image);
+    if (m->empty())
+    {
+        cout << "File not found or empty image\n";
+        return -3;
+    }
+    imshow("Original", *m);
+    img =Ptr<Mat>(m);
+    namedWindow( winName, WINDOW_AUTOSIZE );
+    /// Create a Trackbar for user to enter threshold
+    createTrackbar( "Derive:",winName, &alDerive, 400, DericheFilter );
+    createTrackbar( "Mean:", winName, &alMean, 400, DericheFilter );
+    DericheFilter(0,NULL);
+    waitKey();
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/disparity_filtering.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/disparity_filtering.cpp
new file mode 100644
index 00000000..bd0fb1ee
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/disparity_filtering.cpp
@@ -0,0 +1,477 @@
+#include "opencv2/calib3d.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/ximgproc.hpp"
+#include <iostream>
+#include <string>
+
+using namespace cv;
+using namespace cv::ximgproc;
+using namespace std;
+
+Rect computeROI(Size2i src_sz, Ptr<StereoMatcher> matcher_instance);
+
+const String keys =
+    "{help h usage ? |                  | print this message                                                }"
+    "{@left          |../data/aloeL.jpg | left view of the stereopair                                       }"
+    "{@right         |../data/aloeR.jpg | right view of the stereopair                                      }"
+    "{GT             |../data/aloeGT.png| optional ground-truth disparity (MPI-Sintel or Middlebury format) }"
+    "{dst_path       |None              | optional path to save the resulting filtered disparity map        }"
+    "{dst_raw_path   |None              | optional path to save raw disparity map before filtering          }"
+    "{algorithm      |bm                | stereo matching method (bm or sgbm)                               }"
+    "{filter         |wls_conf          | used post-filtering (wls_conf or wls_no_conf or fbs_conf)         }"
+    "{no-display     |                  | don't display results                                             }"
+    "{no-downscale   |                  | force stereo matching on full-sized views to improve quality      }"
+    "{dst_conf_path  |None              | optional path to save the confidence map used in filtering        }"
+    "{vis_mult       |1.0               | coefficient used to scale disparity map visualizations            }"
+    "{max_disparity  |160               | parameter of stereo matching                                      }"
+    "{window_size    |-1                | parameter of stereo matching                                      }"
+    "{wls_lambda     |8000.0            | parameter of wls post-filtering                                   }"
+    "{wls_sigma      |1.5               | parameter of wls post-filtering                                   }"
+    "{fbs_spatial    |16.0              | parameter of fbs post-filtering                                   }"
+    "{fbs_luma       |8.0               | parameter of fbs post-filtering                                   }"
+    "{fbs_chroma     |8.0               | parameter of fbs post-filtering                                   }"
+    "{fbs_lambda     |128.0             | parameter of fbs post-filtering                                   }"
+    ;
+
+int main(int argc, char** argv)
+{
+    CommandLineParser parser(argc,argv,keys);
+    parser.about("Disparity Filtering Demo");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    String left_im = parser.get<String>(0);
+    String right_im = parser.get<String>(1);
+    String GT_path = parser.get<String>("GT");
+
+    String dst_path = parser.get<String>("dst_path");
+    String dst_raw_path = parser.get<String>("dst_raw_path");
+    String dst_conf_path = parser.get<String>("dst_conf_path");
+    String algo = parser.get<String>("algorithm");
+    String filter = parser.get<String>("filter");
+    bool no_display = parser.has("no-display");
+    bool no_downscale = parser.has("no-downscale");
+    int max_disp = parser.get<int>("max_disparity");
+    double lambda = parser.get<double>("wls_lambda");
+    double sigma  = parser.get<double>("wls_sigma");
+    double fbs_spatial = parser.get<double>("fbs_spatial");
+    double fbs_luma = parser.get<double>("fbs_luma");
+    double fbs_chroma = parser.get<double>("fbs_chroma");
+    double fbs_lambda = parser.get<double>("fbs_lambda");
+    double vis_mult = parser.get<double>("vis_mult");
+
+    int wsize;
+    if(parser.get<int>("window_size")>=0) //user provided window_size value
+        wsize = parser.get<int>("window_size");
+    else
+    {
+        if(algo=="sgbm")
+            wsize = 3; //default window size for SGBM
+        else if(!no_downscale && algo=="bm" && filter=="wls_conf")
+            wsize = 7; //default window size for BM on downscaled views (downscaling is performed only for wls_conf)
+        else
+            wsize = 15; //default window size for BM on full-sized views
+    }
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    //! [load_views]
+    Mat left  = imread(left_im ,IMREAD_COLOR);
+    if ( left.empty() )
+    {
+        cout<<"Cannot read image file: "<<left_im;
+        return -1;
+    }
+
+    Mat right = imread(right_im,IMREAD_COLOR);
+    if ( right.empty() )
+    {
+        cout<<"Cannot read image file: "<<right_im;
+        return -1;
+    }
+    //! [load_views]
+
+    bool noGT;
+    Mat GT_disp;
+    if (GT_path=="../data/aloeGT.png" && left_im!="../data/aloeL.jpg")
+        noGT=true;
+    else
+    {
+        noGT=false;
+        if(readGT(GT_path,GT_disp)!=0)
+        {
+            cout<<"Cannot read ground truth image file: "<<GT_path<<endl;
+            return -1;
+        }
+    }
+
+    Mat left_for_matcher, right_for_matcher;
+    Mat left_disp,right_disp;
+    Mat filtered_disp,solved_disp,solved_filtered_disp;
+    Mat conf_map = Mat(left.rows,left.cols,CV_8U);
+    conf_map = Scalar(255);
+    Rect ROI;
+    Ptr<DisparityWLSFilter> wls_filter;
+    double matching_time, filtering_time;
+    double solving_time = 0;
+    if(max_disp<=0 || max_disp%16!=0)
+    {
+        cout<<"Incorrect max_disparity value: it should be positive and divisible by 16";
+        return -1;
+    }
+    if(wsize<=0 || wsize%2!=1)
+    {
+        cout<<"Incorrect window_size value: it should be positive and odd";
+        return -1;
+    }
+
+    if(filter=="wls_conf") // filtering with confidence (significantly better quality than wls_no_conf)
+    {
+        if(!no_downscale)
+        {
+            // downscale the views to speed-up the matching stage, as we will need to compute both left
+            // and right disparity maps for confidence map computation
+            //! [downscale]
+            max_disp/=2;
+            if(max_disp%16!=0)
+                max_disp += 16-(max_disp%16);
+            resize(left ,left_for_matcher ,Size(),0.5,0.5, INTER_LINEAR_EXACT);
+            resize(right,right_for_matcher,Size(),0.5,0.5, INTER_LINEAR_EXACT);
+            //! [downscale]
+        }
+        else
+        {
+            left_for_matcher  = left.clone();
+            right_for_matcher = right.clone();
+        }
+
+        if(algo=="bm")
+        {
+            //! [matching]
+            Ptr<StereoBM> left_matcher = StereoBM::create(max_disp,wsize);
+            wls_filter = createDisparityWLSFilter(left_matcher);
+            Ptr<StereoMatcher> right_matcher = createRightMatcher(left_matcher);
+
+            cvtColor(left_for_matcher,  left_for_matcher,  COLOR_BGR2GRAY);
+            cvtColor(right_for_matcher, right_for_matcher, COLOR_BGR2GRAY);
+
+            matching_time = (double)getTickCount();
+            left_matcher-> compute(left_for_matcher, right_for_matcher,left_disp);
+            right_matcher->compute(right_for_matcher,left_for_matcher, right_disp);
+            matching_time = ((double)getTickCount() - matching_time)/getTickFrequency();
+            //! [matching]
+        }
+        else if(algo=="sgbm")
+        {
+            Ptr<StereoSGBM> left_matcher  = StereoSGBM::create(0,max_disp,wsize);
+            left_matcher->setP1(24*wsize*wsize);
+            left_matcher->setP2(96*wsize*wsize);
+            left_matcher->setPreFilterCap(63);
+            left_matcher->setMode(StereoSGBM::MODE_SGBM_3WAY);
+            wls_filter = createDisparityWLSFilter(left_matcher);
+            Ptr<StereoMatcher> right_matcher = createRightMatcher(left_matcher);
+
+            matching_time = (double)getTickCount();
+            left_matcher-> compute(left_for_matcher, right_for_matcher,left_disp);
+            right_matcher->compute(right_for_matcher,left_for_matcher, right_disp);
+            matching_time = ((double)getTickCount() - matching_time)/getTickFrequency();
+        }
+        else
+        {
+            cout<<"Unsupported algorithm";
+            return -1;
+        }
+
+        //! [filtering]
+        wls_filter->setLambda(lambda);
+        wls_filter->setSigmaColor(sigma);
+        filtering_time = (double)getTickCount();
+        wls_filter->filter(left_disp,left,filtered_disp,right_disp);
+        filtering_time = ((double)getTickCount() - filtering_time)/getTickFrequency();
+        //! [filtering]
+        conf_map = wls_filter->getConfidenceMap();
+
+        // Get the ROI that was used in the last filter call:
+        ROI = wls_filter->getROI();
+        if(!no_downscale)
+        {
+            // upscale raw disparity and ROI back for a proper comparison:
+            resize(left_disp,left_disp,Size(),2.0,2.0,INTER_LINEAR_EXACT);
+            left_disp = left_disp*2.0;
+            ROI = Rect(ROI.x*2,ROI.y*2,ROI.width*2,ROI.height*2);
+        }
+    }
+    else if(filter=="fbs_conf") // filtering with fbs and confidence using also wls pre-processing
+    {
+        if(!no_downscale)
+        {
+            // downscale the views to speed-up the matching stage, as we will need to compute both left
+            // and right disparity maps for confidence map computation
+            //! [downscale_wls]
+            max_disp/=2;
+            if(max_disp%16!=0)
+                max_disp += 16-(max_disp%16);
+            resize(left ,left_for_matcher ,Size(),0.5,0.5);
+            resize(right,right_for_matcher,Size(),0.5,0.5);
+            //! [downscale_wls]
+        }
+        else
+        {
+            left_for_matcher  = left.clone();
+            right_for_matcher = right.clone();
+        }
+
+        if(algo=="bm")
+        {
+            //! [matching_wls]
+            Ptr<StereoBM> left_matcher = StereoBM::create(max_disp,wsize);
+            wls_filter = createDisparityWLSFilter(left_matcher);
+            Ptr<StereoMatcher> right_matcher = createRightMatcher(left_matcher);
+
+            cvtColor(left_for_matcher,  left_for_matcher,  COLOR_BGR2GRAY);
+            cvtColor(right_for_matcher, right_for_matcher, COLOR_BGR2GRAY);
+
+            matching_time = (double)getTickCount();
+            left_matcher-> compute(left_for_matcher, right_for_matcher,left_disp);
+            right_matcher->compute(right_for_matcher,left_for_matcher, right_disp);
+            matching_time = ((double)getTickCount() - matching_time)/getTickFrequency();
+            //! [matching_wls]
+        }
+        else if(algo=="sgbm")
+        {
+            Ptr<StereoSGBM> left_matcher  = StereoSGBM::create(0,max_disp,wsize);
+            left_matcher->setP1(24*wsize*wsize);
+            left_matcher->setP2(96*wsize*wsize);
+            left_matcher->setPreFilterCap(63);
+            left_matcher->setMode(StereoSGBM::MODE_SGBM_3WAY);
+            wls_filter = createDisparityWLSFilter(left_matcher);
+            Ptr<StereoMatcher> right_matcher = createRightMatcher(left_matcher);
+
+            matching_time = (double)getTickCount();
+            left_matcher-> compute(left_for_matcher, right_for_matcher,left_disp);
+            right_matcher->compute(right_for_matcher,left_for_matcher, right_disp);
+            matching_time = ((double)getTickCount() - matching_time)/getTickFrequency();
+        }
+        else
+        {
+            cout<<"Unsupported algorithm";
+            return -1;
+        }
+
+        //! [filtering_wls]
+        wls_filter->setLambda(lambda);
+        wls_filter->setSigmaColor(sigma);
+        filtering_time = (double)getTickCount();
+        wls_filter->filter(left_disp,left,filtered_disp,right_disp);
+        filtering_time = ((double)getTickCount() - filtering_time)/getTickFrequency();
+        //! [filtering_wls]
+
+        conf_map = wls_filter->getConfidenceMap();
+
+        Mat left_disp_resized;
+        resize(left_disp,left_disp_resized,left.size());
+
+        // Get the ROI that was used in the last filter call:
+        ROI = wls_filter->getROI();
+        if(!no_downscale)
+        {
+            // upscale raw disparity and ROI back for a proper comparison:
+            resize(left_disp,left_disp,Size(),2.0,2.0);
+            left_disp = left_disp*2.0;
+            left_disp_resized = left_disp_resized*2.0;
+            ROI = Rect(ROI.x*2,ROI.y*2,ROI.width*2,ROI.height*2);
+        }
+
+#ifdef HAVE_EIGEN
+        //! [filtering_fbs]
+        solving_time = (double)getTickCount();
+        fastBilateralSolverFilter(left, left_disp_resized, conf_map/255.0f, solved_disp, fbs_spatial, fbs_luma, fbs_chroma, fbs_lambda);
+        solving_time = ((double)getTickCount() - solving_time)/getTickFrequency();
+        //! [filtering_fbs]
+
+        //! [filtering_wls2fbs]
+        fastBilateralSolverFilter(left, filtered_disp, conf_map/255.0f, solved_filtered_disp, fbs_spatial, fbs_luma, fbs_chroma, fbs_lambda);
+        //! [filtering_wls2fbs]
+#else
+        (void)fbs_spatial;
+        (void)fbs_luma;
+        (void)fbs_chroma;
+        (void)fbs_lambda;
+#endif
+    }
+    else if(filter=="wls_no_conf")
+    {
+        /* There is no convenience function for the case of filtering with no confidence, so we
+        will need to set the ROI and matcher parameters manually */
+
+        left_for_matcher  = left.clone();
+        right_for_matcher = right.clone();
+
+        if(algo=="bm")
+        {
+            Ptr<StereoBM> matcher  = StereoBM::create(max_disp,wsize);
+            matcher->setTextureThreshold(0);
+            matcher->setUniquenessRatio(0);
+            cvtColor(left_for_matcher,  left_for_matcher, COLOR_BGR2GRAY);
+            cvtColor(right_for_matcher, right_for_matcher, COLOR_BGR2GRAY);
+            ROI = computeROI(left_for_matcher.size(),matcher);
+            wls_filter = createDisparityWLSFilterGeneric(false);
+            wls_filter->setDepthDiscontinuityRadius((int)ceil(0.33*wsize));
+
+            matching_time = (double)getTickCount();
+            matcher->compute(left_for_matcher,right_for_matcher,left_disp);
+            matching_time = ((double)getTickCount() - matching_time)/getTickFrequency();
+        }
+        else if(algo=="sgbm")
+        {
+            Ptr<StereoSGBM> matcher  = StereoSGBM::create(0,max_disp,wsize);
+            matcher->setUniquenessRatio(0);
+            matcher->setDisp12MaxDiff(1000000);
+            matcher->setSpeckleWindowSize(0);
+            matcher->setP1(24*wsize*wsize);
+            matcher->setP2(96*wsize*wsize);
+            matcher->setMode(StereoSGBM::MODE_SGBM_3WAY);
+            ROI = computeROI(left_for_matcher.size(),matcher);
+            wls_filter = createDisparityWLSFilterGeneric(false);
+            wls_filter->setDepthDiscontinuityRadius((int)ceil(0.5*wsize));
+
+            matching_time = (double)getTickCount();
+            matcher->compute(left_for_matcher,right_for_matcher,left_disp);
+            matching_time = ((double)getTickCount() - matching_time)/getTickFrequency();
+        }
+        else
+        {
+            cout<<"Unsupported algorithm";
+            return -1;
+        }
+
+        wls_filter->setLambda(lambda);
+        wls_filter->setSigmaColor(sigma);
+        filtering_time = (double)getTickCount();
+        wls_filter->filter(left_disp,left,filtered_disp,Mat(),ROI);
+        filtering_time = ((double)getTickCount() - filtering_time)/getTickFrequency();
+    }
+    else
+    {
+        cout<<"Unsupported filter";
+        return -1;
+    }
+
+    //collect and print all the stats:
+    cout.precision(2);
+    cout<<"Matching time:  "<<matching_time<<"s"<<endl;
+    cout<<"Filtering time: "<<filtering_time<<"s"<<endl;
+    cout<<"Solving time: "<<solving_time<<"s"<<endl;
+    cout<<endl;
+
+    double MSE_before,percent_bad_before,MSE_after,percent_bad_after;
+    if(!noGT)
+    {
+        MSE_before = computeMSE(GT_disp,left_disp,ROI);
+        percent_bad_before = computeBadPixelPercent(GT_disp,left_disp,ROI);
+        MSE_after = computeMSE(GT_disp,filtered_disp,ROI);
+        percent_bad_after = computeBadPixelPercent(GT_disp,filtered_disp,ROI);
+
+        cout.precision(5);
+        cout<<"MSE before filtering: "<<MSE_before<<endl;
+        cout<<"MSE after filtering:  "<<MSE_after<<endl;
+        cout<<endl;
+        cout.precision(3);
+        cout<<"Percent of bad pixels before filtering: "<<percent_bad_before<<endl;
+        cout<<"Percent of bad pixels after filtering:  "<<percent_bad_after<<endl;
+    }
+
+    if(dst_path!="None")
+    {
+        Mat filtered_disp_vis;
+        getDisparityVis(filtered_disp,filtered_disp_vis,vis_mult);
+        imwrite(dst_path,filtered_disp_vis);
+    }
+    if(dst_raw_path!="None")
+    {
+        Mat raw_disp_vis;
+        getDisparityVis(left_disp,raw_disp_vis,vis_mult);
+        imwrite(dst_raw_path,raw_disp_vis);
+    }
+    if(dst_conf_path!="None")
+    {
+        imwrite(dst_conf_path,conf_map);
+    }
+
+    if(!no_display)
+    {
+        namedWindow("left", WINDOW_AUTOSIZE);
+        imshow("left", left);
+        namedWindow("right", WINDOW_AUTOSIZE);
+        imshow("right", right);
+
+        if(!noGT)
+        {
+            Mat GT_disp_vis;
+            getDisparityVis(GT_disp,GT_disp_vis,vis_mult);
+            namedWindow("ground-truth disparity", WINDOW_AUTOSIZE);
+            imshow("ground-truth disparity", GT_disp_vis);
+        }
+
+        //! [visualization]
+        Mat raw_disp_vis;
+        getDisparityVis(left_disp,raw_disp_vis,vis_mult);
+        namedWindow("raw disparity", WINDOW_AUTOSIZE);
+        imshow("raw disparity", raw_disp_vis);
+        Mat filtered_disp_vis;
+        getDisparityVis(filtered_disp,filtered_disp_vis,vis_mult);
+        namedWindow("filtered disparity", WINDOW_AUTOSIZE);
+        imshow("filtered disparity", filtered_disp_vis);
+
+        if(!solved_disp.empty())
+        {
+            Mat solved_disp_vis;
+            getDisparityVis(solved_disp,solved_disp_vis,vis_mult);
+            namedWindow("solved disparity", WINDOW_AUTOSIZE);
+            imshow("solved disparity", solved_disp_vis);
+
+            Mat solved_filtered_disp_vis;
+            getDisparityVis(solved_filtered_disp,solved_filtered_disp_vis,vis_mult);
+            namedWindow("solved wls disparity", WINDOW_AUTOSIZE);
+            imshow("solved wls disparity", solved_filtered_disp_vis);
+        }
+
+        while(1)
+        {
+            char key = (char)waitKey();
+            if( key == 27 || key == 'q' || key == 'Q') // 'ESC'
+                break;
+        }
+        //! [visualization]
+    }
+
+    return 0;
+}
+
+Rect computeROI(Size2i src_sz, Ptr<StereoMatcher> matcher_instance)
+{
+    int min_disparity = matcher_instance->getMinDisparity();
+    int num_disparities = matcher_instance->getNumDisparities();
+    int block_size = matcher_instance->getBlockSize();
+
+    int bs2 = block_size/2;
+    int minD = min_disparity, maxD = min_disparity + num_disparities - 1;
+
+    int xmin = maxD + bs2;
+    int xmax = src_sz.width + minD - bs2;
+    int ymin = bs2;
+    int ymax = src_sz.height - bs2;
+
+    Rect r(xmin, ymin, xmax - xmin, ymax - ymin);
+    return r;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edge_drawing.py b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edge_drawing.py
new file mode 100644
index 00000000..8c8d6add
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edge_drawing.py
@@ -0,0 +1,88 @@
+#!/usr/bin/python
+
+'''
+This example illustrates how to use cv.ximgproc.EdgeDrawing class.
+
+Usage:
+    ed.py [<image_name>]
+    image argument defaults to board.jpg
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+import random as rng
+import sys
+
+rng.seed(12345)
+
+def main():
+    try:
+        fn = sys.argv[1]
+    except IndexError:
+        fn = 'board.jpg'
+
+    src = cv.imread(cv.samples.findFile(fn))
+    gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    cv.imshow("source", src)
+
+    ssrc = src.copy()*0
+    lsrc = src.copy()
+    esrc = src.copy()
+
+    ed = cv.ximgproc.createEdgeDrawing()
+
+    # you can change parameters (refer the documentation to see all parameters)
+    EDParams = cv.ximgproc_EdgeDrawing_Params()
+    EDParams.MinPathLength = 50     # try changing this value between 5 to 1000
+    EDParams.PFmode = False         # defaut value try to swich it to True
+    EDParams.MinLineLength = 10     # try changing this value between 5 to 100
+    EDParams.NFAValidation = True   # defaut value try to swich it to False
+
+    ed.setParams(EDParams)
+
+    # Detect edges
+    # you should call this before detectLines() and detectEllipses()
+    ed.detectEdges(gray)
+
+    segments = ed.getSegments()
+    lines = ed.detectLines()
+    ellipses = ed.detectEllipses()
+
+    #Draw detected edge segments
+    for i in range(len(segments)):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        cv.polylines(ssrc, [segments[i]], False, color, 1, cv.LINE_8)
+
+    cv.imshow("detected edge segments", ssrc)
+
+    #Draw detected lines
+    if lines is not None: # Check if the lines have been found and only then iterate over these and add them to the image
+        lines = np.uint16(np.around(lines))
+        for i in range(len(lines)):
+            cv.line(lsrc, (lines[i][0][0], lines[i][0][1]), (lines[i][0][2], lines[i][0][3]), (0, 0, 255), 1, cv.LINE_AA)
+
+    cv.imshow("detected lines", lsrc)
+
+    #Draw detected circles and ellipses
+    if ellipses is not None: # Check if circles and ellipses have been found and only then iterate over these and add them to the image
+        for i in range(len(ellipses)):
+            center = (int(ellipses[i][0][0]), int(ellipses[i][0][1]))
+            axes = (int(ellipses[i][0][2])+int(ellipses[i][0][3]),int(ellipses[i][0][2])+int(ellipses[i][0][4]))
+            angle = ellipses[i][0][5]
+            color = (0, 0, 255)
+            if ellipses[i][0][2] == 0:
+                color = (0, 255, 0)
+            cv.ellipse(esrc, center, axes, angle,0, 360, color, 2, cv.LINE_AA)
+
+    cv.imshow("detected circles and ellipses", esrc)
+    cv.waitKey(0)
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edgeboxes_demo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edgeboxes_demo.cpp
new file mode 100644
index 00000000..6a8a522d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edgeboxes_demo.cpp
@@ -0,0 +1,96 @@
+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#include "opencv2/ximgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+using namespace cv::ximgproc;
+
+static void help()
+{
+    std::cout << std::endl <<
+    "This sample demonstrates structured edge detection and edgeboxes." << std::endl <<
+    "Usage:" << std::endl <<
+    "./edgeboxes_demo [<model>] [<input_image>]" << std::endl;
+}
+
+int main(int argc, char **argv)
+{
+
+  if (argc < 3)
+  {
+    help();
+    return -1;
+  }
+
+  Ptr<StructuredEdgeDetection> pDollar = createStructuredEdgeDetection(argv[1]);
+
+  Mat im;
+  im = imread(argv[2]);
+
+  Mat rgb_im;
+  cvtColor(im, rgb_im, COLOR_BGR2RGB);
+  rgb_im.convertTo(rgb_im, CV_32F, 1.0 / 255.0f);
+
+  Mat edge_im;
+  pDollar->detectEdges(rgb_im, edge_im);
+
+  // computes orientation from edge map
+  Mat O;
+  pDollar->computeOrientation(edge_im, O);
+
+  // apply edge nms
+  Mat edge_nms;
+  pDollar->edgesNms(edge_im, O, edge_nms, 2, 0, 1, true);
+
+  std::vector<Rect> boxes;
+  Ptr<EdgeBoxes> edgeboxes = createEdgeBoxes();
+  edgeboxes->setMaxBoxes(30);
+  edgeboxes->getBoundingBoxes(edge_nms, O, boxes);
+
+  for(int i = 0; i < (int)boxes.size(); i++)
+  {
+      Point p1(boxes[i].x, boxes[i].y), p2(boxes[i].x + boxes[i].width, boxes[i].y + boxes[i].height);
+      Scalar color(0, 255, 0);
+      rectangle(im, p1, p2, color, 1);
+  }
+
+  imshow("Edge", edge_im);
+  imshow("Nms", edge_nms);
+  imshow("Image & boxes", im);
+  waitKey(0);
+
+  return 0;
+ }
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edgeboxes_demo.py b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edgeboxes_demo.py
new file mode 100644
index 00000000..5c31413f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edgeboxes_demo.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+'''
+This sample demonstrates structured edge detection and edgeboxes.
+Usage:
+  edgeboxes_demo.py [<model>] [<input_image>]
+'''
+
+import cv2 as cv
+import numpy as np
+import sys
+
+if __name__ == '__main__':
+    print(__doc__)
+
+    model = sys.argv[1]
+    im = cv.imread(sys.argv[2])
+
+    edge_detection = cv.ximgproc.createStructuredEdgeDetection(model)
+    rgb_im = cv.cvtColor(im, cv.COLOR_BGR2RGB)
+    edges = edge_detection.detectEdges(np.float32(rgb_im) / 255.0)
+
+    orimap = edge_detection.computeOrientation(edges)
+    edges = edge_detection.edgesNms(edges, orimap)
+
+    edge_boxes = cv.ximgproc.createEdgeBoxes()
+    edge_boxes.setMaxBoxes(30)
+    boxes = edge_boxes.getBoundingBoxes(edges, orimap)
+    boxes, scores = edge_boxes.getBoundingBoxes(edges, orimap)
+
+    if len(boxes) > 0:
+        boxes_scores = zip(boxes, scores)
+        for b_s in boxes_scores:
+            box = b_s[0]
+            x, y, w, h = box
+            cv.rectangle(im, (x, y), (x+w, y+h), (0, 255, 0), 1, cv.LINE_AA)
+            score = b_s[1][0]
+            cv.putText(im, "{:.2f}".format(score), (x, y), cv.FONT_HERSHEY_PLAIN, 0.8, (255, 255, 255), 1, cv.LINE_AA)
+            print("Box at (x,y)=({:d},{:d}); score={:f}".format(x, y, score))
+
+    cv.imshow("edges", edges)
+    cv.imshow("edgeboxes", im)
+    cv.waitKey(0)
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edgepreserving_filter_demo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edgepreserving_filter_demo.cpp
new file mode 100644
index 00000000..faa89b43
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/edgepreserving_filter_demo.cpp
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <opencv2/highgui.hpp>
+#include <opencv2/ximgproc.hpp>
+#include <string>
+
+using namespace cv;
+
+int main(int argc, char **argv)
+{
+    cv::CommandLineParser parser(
+        argc, argv,
+        "{help h ? |     | help message}"
+        "{@image   |     | Image filename to process }");
+    if (parser.has("help") || !parser.has("@image"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    // Load image from first parameter
+    std::string filename = parser.get<std::string>("@image");
+    Mat image = imread(filename, 1), res;
+
+    if (!image.data)
+    {
+        std::cerr << "No image data at " << filename << std::endl;
+        throw;
+    }
+
+    // Before filtering
+    imshow("Original image", image);
+    waitKey(0);
+
+    // Initialize filter. Kernel size 5x5, threshold 20
+    ximgproc::edgePreservingFilter(image, res, 9, 20);
+
+    // After filtering
+    imshow("Filtered image", res);
+    waitKey(0);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fast_hough_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fast_hough_transform.cpp
new file mode 100644
index 00000000..c59f30f0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fast_hough_transform.cpp
@@ -0,0 +1,318 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2015, Smart Engines Ltd, all rights reserved.
+// Copyright (C) 2015, Institute for Information Transmission Problems of the Russian Academy of Sciences (Kharkevich Institute), all rights reserved.
+// Copyright (C) 2015, Dmitry Nikolaev, Simon Karpenko, Michail Aliev, Elena Kuznetsova, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/core/utility.hpp>
+
+#include <opencv2/ximgproc.hpp>
+
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <ctime>
+#include <vector>
+
+using namespace cv;
+using namespace cv::ximgproc;
+using namespace std;
+
+static void help()
+{
+    cout << "\nThis program demonstrates line finding with the Fast Hough transform.\n"
+            "Usage:\n"
+            "./fasthoughtransform\n"
+            "<image_name>, default is '../../../samples/data/building.jpg'\n"
+            "<fht_image_depth>, default is " << CV_32S << "\n"
+            "<fht_angle_range>, default is " << 6 << " (@see cv::AngleRangeOption)\n"
+            "<fht_operator>, default is " << 2 << " (@see cv::HoughOp)\n"
+            "<fht_makeskew>, default is " << 1 << "(@see cv::HoughDeskewOption)" << endl;
+}
+
+static bool parseArgs(int argc, const char **argv,
+                      Mat &img,
+                      int &houghDepth,
+                      int &houghAngleRange,
+                      int &houghOperator,
+                      int &houghSkew)
+{
+    if (argc > 6)
+    {
+        cout << "Too many arguments" << endl;
+        return false;
+    }
+
+    const char *filename = argc >= 2 ? argv[1]
+                                     : "../../../samples/data/building.jpg";
+    img = imread(filename, 0);
+    if (img.empty())
+    {
+        cout << "Failed to load image from '" << filename << "'" << endl;
+        return false;
+    }
+
+    houghDepth      = argc >= 3 ? atoi(argv[2]) : CV_32S;
+    houghAngleRange = argc >= 4 ? atoi(argv[3]) : 6;//ARO_315_135
+    houghOperator   = argc >= 5 ? atoi(argv[4]) : 2;//FHT_ADD
+    houghSkew       = argc >= 6 ? atoi(argv[5]) : 1;//HDO_DESKEW
+
+    return true;
+}
+
+static bool getEdges(const Mat &src, Mat &dst)
+{
+    Mat ucharSingleSrc;
+    src.convertTo(ucharSingleSrc, CV_8UC1);
+
+    Canny(ucharSingleSrc, dst, 50, 200, 3);
+    return true;
+}
+
+static bool fht(const Mat &src, Mat &dst,
+         int dstDepth, int angleRange, int op, int skew)
+{
+    clock_t clocks = clock();
+
+    FastHoughTransform(src, dst, dstDepth, angleRange, op, skew);
+
+    clocks = clock() - clocks;
+    double secs = (double)clocks / CLOCKS_PER_SEC;
+    cout << std::setprecision(2) << "FastHoughTransform finished in " << secs
+         << " seconds" << endl;
+
+    return true;
+}
+
+template<typename T>
+bool rel(pair<T, Point> const &a, pair<T, Point> const &b)
+{
+    return a.first > b.first;
+}
+
+template<typename T>
+bool incIfGreater(const T& a, const T& b, int *value)
+{
+    if (!value || a < b)
+        return false;
+    if (a > b)
+        ++(*value);
+    return true;
+}
+
+static const int MAX_LEN = 10000;
+
+template<typename T>
+bool getLocalExtr(vector<Vec4i> &lines,
+                  const Mat &src,
+                  const Mat &fht,
+                  float minWeight,
+                  int maxCount)
+{
+    vector<pair<T, Point> > weightedPoints;
+    for (int y = 0; y < fht.rows; ++y)
+    {
+        if (weightedPoints.size() > MAX_LEN)
+            break;
+
+        T const *pLine = (T *)fht.ptr(max(y - 1, 0));
+        T const *cLine = (T *)fht.ptr(y);
+        T const *nLine = (T *)fht.ptr(min(y + 1, fht.rows - 1));
+
+        for (int x = 0; x < fht.cols; ++x)
+        {
+            if (weightedPoints.size() > MAX_LEN)
+                break;
+
+            T const value = cLine[x];
+            if (value >= minWeight)
+            {
+                int isLocalMax = 0;
+                for (int xx = max(x - 1, 0);
+                     xx <= min(x + 1, fht.cols - 1);
+                     ++xx)
+                {
+                    if (!incIfGreater(value, pLine[xx], &isLocalMax) ||
+                        !incIfGreater(value, cLine[xx], &isLocalMax) ||
+                        !incIfGreater(value, nLine[xx], &isLocalMax))
+                    {
+                        isLocalMax = 0;
+                        break;
+                    }
+                }
+                if (isLocalMax > 0)
+                    weightedPoints.push_back(make_pair(value, Point(x, y)));
+            }
+        }
+    }
+
+    if (weightedPoints.empty())
+        return true;
+
+    sort(weightedPoints.begin(), weightedPoints.end(), &rel<T>);
+    weightedPoints.resize(min(static_cast<int>(weightedPoints.size()),
+                              maxCount));
+
+    for (size_t i = 0; i < weightedPoints.size(); ++i)
+    {
+        lines.push_back(HoughPoint2Line(weightedPoints[i].second, src));
+    }
+    return true;
+}
+
+static bool getLocalExtr(vector<Vec4i> &lines,
+                         const Mat &src,
+                         const Mat &fht,
+                         float minWeight,
+                         int maxCount)
+{
+    int const depth = CV_MAT_DEPTH(fht.type());
+    switch (depth)
+    {
+    case 0:
+        return getLocalExtr<uchar>(lines, src, fht, minWeight, maxCount);
+    case 1:
+        return getLocalExtr<schar>(lines, src, fht, minWeight, maxCount);
+    case 2:
+        return getLocalExtr<ushort>(lines, src, fht, minWeight, maxCount);
+    case 3:
+        return getLocalExtr<short>(lines, src, fht, minWeight, maxCount);
+    case 4:
+        return getLocalExtr<int>(lines, src, fht, minWeight, maxCount);
+   case 5:
+        return getLocalExtr<float>(lines, src, fht, minWeight, maxCount);
+    case 6:
+        return getLocalExtr<double>(lines, src, fht, minWeight, maxCount);
+    default:
+        return false;
+    }
+}
+
+static void rescale(Mat const &src, Mat &dst,
+                    int const maxHeight=500,
+                    int const maxWidth = 1000)
+{
+    double scale = min(min(static_cast<double>(maxWidth) / src.cols,
+                           static_cast<double>(maxHeight) / src.rows), 1.0);
+    resize(src, dst, Size(), scale, scale, INTER_LINEAR_EXACT);
+}
+
+static void showHumanReadableImg(string const &name, Mat const &img)
+{
+    Mat ucharImg;
+    img.convertTo(ucharImg, CV_MAKETYPE(CV_8U, img.channels()));
+    rescale(ucharImg, ucharImg);
+    imshow(name, ucharImg);
+}
+
+static void showFht(Mat const &fht)
+{
+    double minv(0), maxv(0);
+    minMaxLoc(fht, &minv, &maxv);
+    Mat ucharFht;
+    fht.convertTo(ucharFht, CV_MAKETYPE(CV_8U, fht.channels()),
+                  255.0 / (maxv + minv), minv / (maxv + minv));
+    rescale(ucharFht, ucharFht);
+    imshow("fast hough transform", ucharFht);
+}
+
+static void showLines(Mat const &src, vector<Vec4i> const &lines)
+{
+    Mat bgrSrc;
+    cvtColor(src, bgrSrc, COLOR_GRAY2BGR);
+
+    for (size_t i = 0; i < lines.size(); ++i)
+    {
+        Vec4i const &l = lines[i];
+        line(bgrSrc, Point(l[0], l[1]), Point(l[2], l[3]),
+             Scalar(0, 0, 255), 1, LINE_AA);
+    }
+
+    rescale(bgrSrc, bgrSrc);
+    imshow("lines", bgrSrc);
+}
+
+int main(int argc, const char **argv)
+{
+    Mat src;
+    int depth(0);
+    int angleRange(0);
+    int op(0);
+    int skew(0);
+
+    if (!parseArgs(argc, argv, src, depth, angleRange, op, skew))
+    {
+        help();
+        return -1;
+    }
+    showHumanReadableImg("src", src);
+
+    Mat canny;
+    if (!getEdges(src, canny))
+    {
+        cout << "Failed to select canny edges";
+        return -2;
+    }
+    showHumanReadableImg("canny", canny);
+
+    Mat hough;
+    if (!fht(canny, hough, depth, angleRange, op, skew))
+    {
+        cout << "Failed to compute Fast Hough Transform";
+        return -2;
+    }
+    showFht(hough);
+
+    vector<Vec4i> lines;
+    if (!getLocalExtr(lines, canny, hough,
+                      static_cast<float>(255 * 0.3 * min(src.rows, src.cols)),
+                      50))
+    {
+        cout << "Failed to find local maximums on FHT image";
+        return -2;
+    }
+    showLines(canny, lines);
+
+    waitKey();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/filterdemo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/filterdemo.cpp
new file mode 100644
index 00000000..2550ab62
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/filterdemo.cpp
@@ -0,0 +1,105 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/ximgproc.hpp"
+
+#include <stdio.h>
+
+using namespace cv;
+using namespace std;
+
+int main( int argc, const char** argv)
+{
+    float alpha = 1.0f;
+    float sigma = 0.02f;
+    int rows0 = 480;
+    int niters = 10;
+    Mat frame, src, dst;
+
+    const char* window_name = "Anisodiff : Exponential Flux";
+
+    VideoCapture cap;
+    if( argc > 1 )
+        cap.open(argv[1]);
+    else
+        cap.open(0);
+
+    if (!cap.isOpened())
+    {
+        printf("Cannot initialize video capturing\n");
+        return 0;
+    }
+
+    // Create a window
+    namedWindow(window_name, 1);
+
+    // create a toolbar
+    createTrackbar("No. of time steps", window_name, &niters, 30, 0);
+
+    for(;;)
+    {
+        cap >> frame;
+        if( frame.empty() )
+            break;
+
+        if( frame.rows <= rows0 )
+            src = frame;
+        else
+            resize(frame, src, Size(cvRound(480.*frame.cols/frame.rows), 480), 0, 0, INTER_LINEAR_EXACT);
+
+        float t = (float)getTickCount();
+        ximgproc::anisotropicDiffusion(src, dst, alpha, sigma, niters);
+        t = (float)getTickCount() - t;
+        printf("time: %.1fms\n", t*1000./getTickFrequency());
+        imshow(window_name, dst);
+
+        // Wait for a key stroke; the same function arranges events processing
+        char c = (char)waitKey(30);
+        if(c >= 0)
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/find_ellipses.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/find_ellipses.cpp
new file mode 100644
index 00000000..783c9f1a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/find_ellipses.cpp
@@ -0,0 +1,50 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include <iostream>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/ximgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace cv;
+
+int main() {
+
+    // load image
+    Mat img = imread(samples::findFile("stuff.jpg"), IMREAD_COLOR);
+
+    // check if image is loaded
+    if (img.empty()) {
+        std::cout << "fail to open image" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    // create output array
+    std::vector<Vec6f> ells;
+
+    // test ellipse detection
+    cv::ximgproc::findEllipses(img, ells, 0.4f, 0.7f, 0.02f);
+
+    // print output
+    for (unsigned i = 0; i < ells.size(); i++) {
+        Vec6f ell = ells[i];
+        std::cout << ell << std::endl;
+        Scalar color(0, 0, 255);
+        // draw ellipse on image
+        ellipse(
+                img,
+                Point(cvRound(ell[0]), cvRound(ell[1])),
+                Size(cvRound(ell[2]), cvRound(ell[3])),
+                ell[5] * 180 / CV_PI, 0.0, 360.0, color, 3
+        );
+    }
+
+    // show image
+    imshow("result", img);
+    waitKey();
+
+    // end
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/find_ellipses.py b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/find_ellipses.py
new file mode 100644
index 00000000..6caa9477
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/find_ellipses.py
@@ -0,0 +1,46 @@
+#!/usr/bin/python
+
+'''
+This example illustrates how to use cv.ximgproc.findEllipses function.
+
+Usage:
+    find_ellipses.py [<image_name>]
+    image argument defaults to stuff.jpg
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+import sys
+import math
+
+def main():
+    try:
+        fn = sys.argv[1]
+    except IndexError:
+        fn = 'stuff.jpg'
+
+    src = cv.imread(cv.samples.findFile(fn))
+    cv.imshow("source", src)
+
+    ells = cv.ximgproc.findEllipses(src,scoreThreshold = 0.4, reliabilityThreshold = 0.7, centerDistanceThreshold = 0.02)
+
+    if ells is not None:
+        for i in range(len(ells)):
+            center = (int(ells[i][0][0]), int(ells[i][0][1]))
+            axes = (int(ells[i][0][2]),int(ells[i][0][3]))
+            angle = ells[i][0][5] * 180 / math.pi
+            color = (0, 0, 255)
+            cv.ellipse(src, center, axes, angle,0, 360, color, 2, cv.LINE_AA)
+
+    cv.imshow("detected ellipses", src)
+    cv.waitKey(0)
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/findredlinedpolygonfromgooglemaps.py b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/findredlinedpolygonfromgooglemaps.py
new file mode 100644
index 00000000..0d84b037
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/findredlinedpolygonfromgooglemaps.py
@@ -0,0 +1,29 @@
+# USAGE - How to run this code ?
+# python find_shapes.py --image shapes.png
+#python findredlinedpolygonfromgooglemaps.py --image stanford.png 
+
+import numpy as np
+import argparse
+import cv2 as cv
+
+# construct the argument parse and parse the arguments
+ap = argparse.ArgumentParser()
+ap.add_argument("-i", "--image", help = "path to the image file")
+args = vars(ap.parse_args())
+
+# load the image
+image = cv.imread(args["image"])
+lower = np.array([20,0,155])
+upper = np.array([255,120,250])
+shapeMask = cv.inRange(image, lower, upper)
+
+# find the contours in the mask
+(cnts, _) = cv.findContours(shapeMask.copy(), cv.RETR_EXTERNAL,
+    cv.CHAIN_APPROX_SIMPLE)
+cv.imshow("Mask", shapeMask)
+
+# loop over the contours
+for c in cnts:
+    cv.drawContours(image, [c], -1, (0, 255, 0), 2)
+    cv.imshow("Image", image)
+    cv.waitKey(0)
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fld_lines.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fld_lines.cpp
new file mode 100644
index 00000000..87edf624
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fld_lines.cpp
@@ -0,0 +1,134 @@
+#include <iostream>
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/ximgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::ximgproc;
+
+int main(int argc, char** argv)
+{
+    string in;
+    CommandLineParser parser(argc, argv, "{@input|corridor.jpg|input image}{help h||show help message}");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    in = samples::findFile(parser.get<string>("@input"));
+
+    Mat image = imread(in, IMREAD_GRAYSCALE);
+
+    if( image.empty() )
+    {
+        return -1;
+    }
+
+    // Create FLD detector
+    // Param               Default value   Description
+    // length_threshold    10            - Segments shorter than this will be discarded
+    // distance_threshold  1.41421356    - A point placed from a hypothesis line
+    //                                     segment farther than this will be
+    //                                     regarded as an outlier
+    // canny_th1           50            - First threshold for
+    //                                     hysteresis procedure in Canny()
+    // canny_th2           50            - Second threshold for
+    //                                     hysteresis procedure in Canny()
+    // canny_aperture_size 3            - Aperturesize for the sobel operator in Canny().
+    //                                     If zero, Canny() is not applied and the input
+    //                                     image is taken as an edge image.
+    // do_merge            false         - If true, incremental merging of segments
+    //                                     will be performed
+    int length_threshold = 10;
+    float distance_threshold = 1.41421356f;
+    double canny_th1 = 50.0;
+    double canny_th2 = 50.0;
+    int canny_aperture_size = 3;
+    bool do_merge = false;
+    Ptr<FastLineDetector> fld = createFastLineDetector(length_threshold,
+            distance_threshold, canny_th1, canny_th2, canny_aperture_size,
+            do_merge);
+    vector<Vec4f> lines;
+
+    // Because of some CPU's power strategy, it seems that the first running of
+    // an algorithm takes much longer. So here we run the algorithm 10 times
+    // to see the algorithm's processing time with sufficiently warmed-up
+    // CPU performance.
+    for (int run_count = 0; run_count < 5; run_count++) {
+        double freq = getTickFrequency();
+        lines.clear();
+        int64 start = getTickCount();
+        // Detect the lines with FLD
+        fld->detect(image, lines);
+        double duration_ms = double(getTickCount() - start) * 1000 / freq;
+        cout << "Elapsed time for FLD " << duration_ms << " ms." << endl;
+    }
+
+    // Show found lines with FLD
+    Mat line_image_fld(image);
+    fld->drawSegments(line_image_fld, lines);
+    imshow("FLD result", line_image_fld);
+
+    waitKey(1);
+
+    Ptr<EdgeDrawing> ed = createEdgeDrawing();
+    ed->params.EdgeDetectionOperator = EdgeDrawing::SOBEL;
+    ed->params.GradientThresholdValue = 38;
+    ed->params.AnchorThresholdValue = 8;
+
+    vector<Vec6d> ellipses;
+
+    for (int run_count = 0; run_count < 5; run_count++) {
+        double freq = getTickFrequency();
+        lines.clear();
+        int64 start = getTickCount();
+
+        // Detect edges
+        //you should call this before detectLines() and detectEllipses()
+        ed->detectEdges(image);
+
+        // Detect lines
+        ed->detectLines(lines);
+        double duration_ms = double(getTickCount() - start) * 1000 / freq;
+        cout << "Elapsed time for EdgeDrawing detectLines " << duration_ms << " ms." << endl;
+
+        start = getTickCount();
+        // Detect circles and ellipses
+        ed->detectEllipses(ellipses);
+        duration_ms = double(getTickCount() - start) * 1000 / freq;
+        cout << "Elapsed time for EdgeDrawing detectEllipses " << duration_ms << " ms." << endl;
+    }
+
+    Mat edge_image_ed = Mat::zeros(image.size(), CV_8UC3);
+    vector<vector<Point> > segments = ed->getSegments();
+
+    for (size_t i = 0; i < segments.size(); i++)
+    {
+        const Point* pts = &segments[i][0];
+        int n = (int)segments[i].size();
+        polylines(edge_image_ed, &pts, &n, 1, false, Scalar((rand() & 255), (rand() & 255), (rand() & 255)), 1);
+    }
+
+    imshow("EdgeDrawing detected edges", edge_image_ed);
+
+    Mat line_image_ed(image);
+    fld->drawSegments(line_image_ed, lines);
+
+    // Draw circles and ellipses
+    for (size_t i = 0; i < ellipses.size(); i++)
+    {
+        Point center((int)ellipses[i][0], (int)ellipses[i][1]);
+        Size axes((int)ellipses[i][2] + (int)ellipses[i][3], (int)ellipses[i][2] + (int)ellipses[i][4]);
+        double angle(ellipses[i][5]);
+        Scalar color = ellipses[i][2] == 0 ? Scalar(255, 255, 0) : Scalar(0, 255, 0);
+
+        ellipse(line_image_ed, center, axes, angle, 0, 360, color, 2, LINE_AA);
+    }
+
+    imshow("EdgeDrawing result", line_image_ed);
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fourier_descriptors_demo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fourier_descriptors_demo.cpp
new file mode 100644
index 00000000..2afc42d7
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fourier_descriptors_demo.cpp
@@ -0,0 +1,186 @@
+#include <opencv2/core.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/ximgproc.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+struct ThParameters {
+    int levelNoise;
+    int angle;
+    int scale10;
+    int origin;
+    int xg;
+    int yg;
+    bool update;
+} ;
+
+static vector<Point> NoisyPolygon(vector<Point> pRef, double n);
+static void UpdateShape(int , void *r);
+static void AddSlider(String sliderName, String windowName, int minSlider, int maxSlider, int valDefault, int *valSlider, void(*f)(int, void *), void *r);
+
+int main(void)
+{
+    vector<Point> ctrRef;
+    vector<Point> ctrRotate, ctrNoisy, ctrNoisyRotate, ctrNoisyRotateShift;
+    // build a shape with 5 vertex
+    ctrRef.push_back(Point(250,250)); ctrRef.push_back(Point(400, 250));
+    ctrRef.push_back(Point(400, 300)); ctrRef.push_back(Point(250, 300));ctrRef.push_back(Point(180, 270));
+    Point cg(0,0);
+    for (int i=0;i<static_cast<int>(ctrRef.size());i++)
+        cg+=ctrRef[i];
+    cg.x /= static_cast<int>(ctrRef.size());
+    cg.y /= static_cast<int>(ctrRef.size());
+    ThParameters p;
+    p.levelNoise=6;
+    p.angle=45;
+    p.scale10=5;
+    p.origin=10;
+    p.xg=150;
+    p.yg=150;
+    p.update=true;
+    namedWindow("FD Curve matching");
+    // A rotation with center at (150,150) of angle 45 degrees and a scaling of 5/10
+    AddSlider("Noise", "FD Curve matching", 0, 20, p.levelNoise, &p.levelNoise, UpdateShape, &p);
+    AddSlider("Angle", "FD Curve matching", 0, 359, p.angle, &p.angle, UpdateShape, &p);
+    AddSlider("Scale", "FD Curve matching", 5, 100, p.scale10, &p.scale10, UpdateShape, &p);
+    AddSlider("Origin%%", "FD Curve matching", 0, 100, p.origin, &p.origin, UpdateShape, &p);
+    AddSlider("Xg", "FD Curve matching", 150, 450, p.xg, &p.xg, UpdateShape, &p);
+    AddSlider("Yg", "FD Curve matching", 150, 450, p.yg, &p.yg, UpdateShape, &p);
+    int code=0;
+    double dist;
+    vector<vector<Point> > c;
+    Mat img;
+    cout << "******************** PRESS g TO MATCH CURVES *************\n";
+    do
+    {
+        code = waitKey(30);
+        if (p.update)
+        {
+            Mat r = getRotationMatrix2D(Point(p.xg, p.yg), p.angle, 10.0/ p.scale10);
+            ctrNoisy= NoisyPolygon(ctrRef,static_cast<double>(p.levelNoise));
+            cv::transform(ctrNoisy, ctrNoisyRotate, r);
+            ctrNoisyRotateShift.clear();
+            for (int i=0;i<static_cast<int>(ctrNoisy.size());i++)
+                ctrNoisyRotateShift.push_back(ctrNoisyRotate[(i+(p.origin*ctrNoisy.size())/100)% ctrNoisy.size()]);
+            // To draw contour using drawcontours
+            c.clear();
+            c.push_back(ctrRef);
+            c.push_back(ctrNoisyRotateShift);
+            p.update = false;
+            Rect rglobal;
+            for (int i = 0; i < static_cast<int>(c.size()); i++)
+            {
+                rglobal = boundingRect(c[i]) | rglobal;
+            }
+            rglobal.width += 10;
+            rglobal.height += 10;
+            img = Mat::zeros(2 * rglobal.height, 2 * rglobal.width, CV_8UC(3));
+            drawContours(img, c, 0, Scalar(255,0,0));
+            drawContours(img, c, 1, Scalar(0, 255, 0));
+            circle(img, c[0][0], 5, Scalar(255, 0, 0));
+            circle(img, c[1][0], 5, Scalar(0, 255, 0));
+            imshow("FD Curve matching", img);
+        }
+        if (code == 'd')
+        {
+            destroyWindow("FD Curve matching");
+            namedWindow("FD Curve matching");
+            // A rotation with center at (150,150) of angle 45 degrees and a scaling of 5/10
+            AddSlider("Noise", "FD Curve matching", 0, 20, p.levelNoise, &p.levelNoise, UpdateShape, &p);
+            AddSlider("Angle", "FD Curve matching", 0, 359, p.angle, &p.angle, UpdateShape, &p);
+            AddSlider("Scale", "FD Curve matching", 5, 100, p.scale10, &p.scale10, UpdateShape, &p);
+            AddSlider("Origin%%", "FD Curve matching", 0, 100, p.origin, &p.origin, UpdateShape, &p);
+            AddSlider("Xg", "FD Curve matching", 150, 450, p.xg, &p.xg, UpdateShape, &p);
+            AddSlider("Yg", "FD Curve matching", 150, 450, p.yg, &p.yg, UpdateShape, &p);
+
+        }
+        if (code == 'g')
+        {
+            ximgproc::ContourFitting fit;
+            vector<Point2f> ctrRef2d, ctrRot2d;
+            // sampling contour we want 256 points
+            ximgproc::contourSampling(ctrRef, ctrRef2d, 256); // use a mat
+            ximgproc::contourSampling(ctrNoisyRotateShift, ctrRot2d, 256); // use a vector of points
+            fit.setFDSize(16);
+            Mat t;
+            fit.estimateTransformation(ctrRot2d, ctrRef2d, t, &dist, false);
+            cout << "Transform *********\n "<<"Origin = "<< 1-t.at<double>(0,0) <<" expected "<< p.origin/100.0 <<" ("<< ctrNoisy.size()<<")\n";
+            cout << "Angle = " << t.at<double>(0, 1) * 180 / M_PI << " expected " << p.angle  <<"\n";
+            cout << "Scale = " << t.at<double>(0, 2) << " expected " << p.scale10 / 10.0 << "\n";
+            Mat dst;
+            ximgproc::transformFD(ctrRot2d, t, dst, false);
+            c.push_back(dst);
+            drawContours(img, c, 2, Scalar(0,255,255));
+            circle(img, c[2][0], 5, Scalar(0, 255, 255));
+            imshow("FD Curve matching", img);
+        }
+    }
+    while (code!=27);
+
+    return 0;
+}
+
+vector<Point> NoisyPolygon(vector<Point> pRef, double n)
+{
+    RNG rng;
+    vector<Point> c;
+    vector<Point> p = pRef;
+    vector<vector<Point> > contour;
+    for (int i = 0; i<static_cast<int>(p.size()); i++)
+        p[i] += Point(Point2d(n*rng.uniform((double)-1, (double)1), n*rng.uniform((double)-1, (double)1)));
+    if (n==0)
+        return p;
+    c.push_back(p[0]);
+    int minX = p[0].x, maxX = p[0].x, minY = p[0].y, maxY = p[0].y;
+    for (int i = 0; i <static_cast<int>(p.size()); i++)
+    {
+        int next = i + 1;
+        if (next == static_cast<int>(p.size()))
+            next = 0;
+        Point2d u = p[next] - p[i];
+        int d = static_cast<int>(norm(u));
+        double a = atan2(u.y, u.x);
+        int step = 1;
+        if (n != 0)
+            step = static_cast<int>(d / n);
+        for (int j = 1; j<d; j += max(step, 1))
+        {
+            Point pNew;
+            do
+            {
+
+                Point2d pAct = (u*j) / static_cast<double>(d);
+                double r = n*rng.uniform((double)0, (double)1);
+                double theta = a + rng.uniform(0., 2 * CV_PI);
+                pNew = Point(Point2d(r*cos(theta) + pAct.x + p[i].x, r*sin(theta) + pAct.y + p[i].y));
+            } while (pNew.x<0 || pNew.y<0);
+            if (pNew.x<minX)
+                minX = pNew.x;
+            if (pNew.x>maxX)
+                maxX = pNew.x;
+            if (pNew.y<minY)
+                minY = pNew.y;
+            if (pNew.y>maxY)
+                maxY = pNew.y;
+            c.push_back(pNew);
+        }
+    }
+    return c;
+}
+
+void UpdateShape(int , void *r)
+{
+    ((ThParameters *)r)->update = true;
+}
+
+void AddSlider(String sliderName, String windowName, int minSlider, int maxSlider, int valDefault, int *valSlider, void(*f)(int, void *), void *r)
+{
+    createTrackbar(sliderName, windowName, valSlider, 1, f, r);
+    setTrackbarMin(sliderName, windowName, minSlider);
+    setTrackbarMax(sliderName, windowName, maxSlider);
+    setTrackbarPos(sliderName, windowName, valDefault);
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fourier_descriptors_demo.py b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fourier_descriptors_demo.py
new file mode 100644
index 00000000..5583192f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/fourier_descriptors_demo.py
@@ -0,0 +1,169 @@
+import numpy as np
+import cv2 as cv
+import math
+
+class ThParameters:
+    def __init__(self):
+        self.levelNoise=6
+        self.angle=45
+        self.scale10=5
+        self.origin=10
+        self.xg=150
+        self.yg=150
+        self.update=True
+
+def UpdateShape(x ):
+    p.update = True
+
+def union(a,b):
+  x = min(a[0], b[0])
+  y = min(a[1], b[1])
+  w = max(a[0]+a[2], b[0]+b[2]) - x
+  h = max(a[1]+a[3], b[1]+b[3]) - y
+  return (x, y, w, h)
+
+def intersection(a,b):
+  x = max(a[0], b[0])
+  y = max(a[1], b[1])
+  w = min(a[0]+a[2], b[0]+b[2]) - x
+  h = min(a[1]+a[3], b[1]+b[3]) - y
+  if w<0 or h<0: return () # or (0,0,0,0) ?
+  return (x, y, w, h)
+
+def NoisyPolygon(pRef,n):
+#    vector<Point> c
+    p = pRef;
+#    vector<vector<Point> > contour;
+    p = p+n*np.random.random_sample((p.shape[0],p.shape[1]))-n/2.0
+    if (n==0):
+        return p
+    c = np.empty(shape=[0, 2])
+    minX = p[0][0]
+    maxX = p[0][0]
+    minY = p[0][1]
+    maxY = p[0][1]
+    for i in range( 0,p.shape[0]):
+        next = i + 1;
+        if (next == p.shape[0]):
+            next = 0;
+        u = p[next] - p[i]
+        d = int(cv.norm(u))
+        a = np.arctan2(u[1], u[0])
+        step = 1
+        if (n != 0):
+            step = d // n
+        for j in range( 1,int(d),int(max(step, 1))):
+            while  True:
+                pAct = (u*j) / (d)
+                r = n*np.random.random_sample()
+                theta = a + 2*math.pi*np.random.random_sample()
+#                pNew = Point(Point2d(r*cos(theta) + pAct.x + p[i].x, r*sin(theta) + pAct.y + p[i].y));
+                pNew = np.array([(r*np.cos(theta) + pAct[0] + p[i][0], r*np.sin(theta) + pAct[1] + p[i][1])])
+                if (pNew[0][0]>=0 and pNew[0][1]>=0):
+                    break
+            if (pNew[0][0]<minX):
+                minX = pNew[0][0]
+            if (pNew[0][0]>maxX):
+                maxX = pNew[0][0]
+            if (pNew[0][1]<minY):
+                minY = pNew[0][1]
+            if (pNew[0][1]>maxY):
+                maxY = pNew[0][1]
+            c = np.append(c,pNew,axis = 0)
+    return c
+
+#static vector<Point> NoisyPolygon(vector<Point> pRef, double n);
+#static void UpdateShape(int , void *r);
+#static void AddSlider(String sliderName, String windowName, int minSlider, int maxSlider, int valDefault, int *valSlider, void(*f)(int, void *), void *r);
+def AddSlider(sliderName,windowName,minSlider,maxSlider,valDefault, update):
+    cv.createTrackbar(sliderName, windowName, valDefault,maxSlider-minSlider+1, update)
+    cv.setTrackbarMin(sliderName, windowName, minSlider)
+    cv.setTrackbarMax(sliderName, windowName, maxSlider)
+    cv.setTrackbarPos(sliderName, windowName, valDefault)
+
+#    vector<Point> ctrRef;
+#    vector<Point> ctrRotate, ctrNoisy, ctrNoisyRotate, ctrNoisyRotateShift;
+#    // build a shape with 5 vertex
+ctrRef = np.array([(250,250),(400, 250),(400, 300),(250, 300),(180, 270)])
+cg = np.mean(ctrRef,axis=0)
+p=ThParameters()
+cv.namedWindow("FD Curve matching");
+# A rotation with center at (150,150) of angle 45 degrees and a scaling of 5/10
+AddSlider("Noise", "FD Curve matching", 0, 20, p.levelNoise,  UpdateShape)
+AddSlider("Angle", "FD Curve matching", 0, 359, p.angle,  UpdateShape)
+AddSlider("Scale", "FD Curve matching", 5, 100, p.scale10, UpdateShape)
+AddSlider("Origin", "FD Curve matching", 0, 100, p.origin, UpdateShape)
+AddSlider("Xg", "FD Curve matching", 150, 450, p.xg, UpdateShape)
+AddSlider("Yg", "FD Curve matching", 150, 450, p.yg, UpdateShape)
+code = 0
+img = np.zeros((300,512,3), np.uint8)
+print ("******************** PRESS g TO MATCH CURVES *************\n")
+
+while (code!=27):
+    code = cv.waitKey(60)
+    if p.update:
+        p.levelNoise=cv.getTrackbarPos('Noise','FD Curve matching')
+        p.angle=cv.getTrackbarPos('Angle','FD Curve matching')
+        p.scale10=cv.getTrackbarPos('Scale','FD Curve matching')
+        p.origin=cv.getTrackbarPos('Origin','FD Curve matching')
+        p.xg=cv.getTrackbarPos('Xg','FD Curve matching')
+        p.yg=cv.getTrackbarPos('Yg','FD Curve matching')
+
+        r = cv.getRotationMatrix2D((p.xg, p.yg), angle=p.angle, scale=10.0/ p.scale10);
+        ctrNoisy= NoisyPolygon(ctrRef,p.levelNoise)
+        ctrNoisy1 = np.reshape(ctrNoisy,(ctrNoisy.shape[0],1,2))
+        ctrNoisyRotate = cv.transform(ctrNoisy1,r)
+        ctrNoisyRotateShift = np.empty([ctrNoisyRotate.shape[0],1,2],dtype=np.int32)
+        for  i in range(0,ctrNoisy.shape[0]):
+            k=(i+(p.origin*ctrNoisy.shape[0])//100)% ctrNoisyRotate.shape[0]
+            ctrNoisyRotateShift[i] = ctrNoisyRotate[k]
+#       To draw contour using drawcontours
+        cc= np.reshape(ctrNoisyRotateShift,[ctrNoisyRotateShift.shape[0],2])
+        c = [ ctrRef,cc]
+        p.update = False;
+        rglobal =(0,0,0,0)
+        for i in range(0,2):
+            r = cv.boundingRect(c[i])
+            rglobal = union(rglobal,r)
+        r = list(rglobal)
+        r[2] = r[2]+10
+        r[3] = r[3]+10
+        rglobal = tuple(r)
+        img = np.zeros((2 * rglobal[3], 2 * rglobal[2], 3), np.uint8)
+        cv.drawContours(img, c, 0, (255,0,0),1);
+        cv.drawContours(img, c, 1, (0, 255, 0),1);
+        cv.circle(img, tuple(c[0][0]), 5, (255, 0, 0),3);
+        cv.circle(img, tuple(c[1][0]), 5, (0, 255, 0),3);
+        cv.imshow("FD Curve matching", img);
+    if code == ord('d') :
+        cv.destroyWindow("FD Curve matching");
+        cv.namedWindow("FD Curve matching");
+# A rotation with center at (150,150) of angle 45 degrees and a scaling of 5/10
+        AddSlider("Noise", "FD Curve matching", 0, 20, p.levelNoise,  UpdateShape)
+        AddSlider("Angle", "FD Curve matching", 0, 359, p.angle,  UpdateShape)
+        AddSlider("Scale", "FD Curve matching", 5, 100, p.scale10,  UpdateShape)
+        AddSlider("Origin%%", "FD Curve matching", 0, 100, p.origin, UpdateShape)
+        AddSlider("Xg", "FD Curve matching", 150, 450, p.xg,  UpdateShape)
+        AddSlider("Yg", "FD Curve matching", 150, 450, p.yg,  UpdateShape)
+    if  code == ord('g'):
+        fit = cv.ximgproc.createContourFitting(1024,16);
+# sampling contour we want 256 points
+        cn= np.reshape(ctrRef,[ctrRef.shape[0],1,2])
+
+        ctrRef2d = cv.ximgproc.contourSampling(cn,  256)
+        ctrRot2d = cv.ximgproc.contourSampling(ctrNoisyRotateShift,  256)
+        fit.setFDSize(16)
+        c1 = ctrRef2d
+        c2 = ctrRot2d
+        alphaPhiST, dist	 = fit.estimateTransformation(ctrRot2d, ctrRef2d)
+        print( "Transform *********\n Origin = ", 1-alphaPhiST[0,0] ," expected ", p.origin / 100. ,"\n")
+        print( "Angle = ", alphaPhiST[0,1] * 180 / math.pi ," expected " , p.angle,"\n")
+        print( "Scale = " ,alphaPhiST[0,2] ," expected " , p.scale10 / 10.0 , "\n")
+        dst = cv.ximgproc.transformFD(ctrRot2d, alphaPhiST,cn, False);
+        ctmp= np.reshape(dst,[dst.shape[0],2])
+        cdst=ctmp.astype(int)
+
+        c = [ ctrRef,cc,cdst]
+        cv.drawContours(img, c, 2, (0,0,255),1);
+        cv.circle(img, (int(c[2][0][0]),int(c[2][0][1])), 5, (0, 0, 255),5);
+        cv.imshow("FD Curve matching", img);
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/graphsegmentation_demo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/graphsegmentation_demo.cpp
new file mode 100644
index 00000000..5f3b9f92
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/graphsegmentation_demo.cpp
@@ -0,0 +1,151 @@
+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+
+#include "opencv2/ximgproc/segmentation.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace cv::ximgproc::segmentation;
+
+Scalar hsv_to_rgb(Scalar);
+Scalar color_mapping(int);
+
+static void help() {
+    std::cout << std::endl <<
+    "A program demonstrating the use and capabilities of a particular graph based image" << std::endl <<
+    "segmentation algorithm described in P. Felzenszwalb, D. Huttenlocher," << std::endl <<
+    "             \"Efficient Graph-Based Image Segmentation\"" << std::endl <<
+    "International Journal of Computer Vision, Vol. 59, No. 2, September 2004" << std::endl << std::endl <<
+    "Usage:" << std::endl <<
+    "./graphsegmentation_demo input_image output_image [simga=0.5] [k=300] [min_size=100]" << std::endl;
+}
+
+Scalar hsv_to_rgb(Scalar c) {
+    Mat in(1, 1, CV_32FC3);
+    Mat out(1, 1, CV_32FC3);
+
+    float * p = in.ptr<float>(0);
+
+    p[0] = (float)c[0] * 360.0f;
+    p[1] = (float)c[1];
+    p[2] = (float)c[2];
+
+    cvtColor(in, out, COLOR_HSV2RGB);
+
+    Scalar t;
+
+    Vec3f p2 = out.at<Vec3f>(0, 0);
+
+    t[0] = (int)(p2[0] * 255);
+    t[1] = (int)(p2[1] * 255);
+    t[2] = (int)(p2[2] * 255);
+
+    return t;
+
+}
+
+Scalar color_mapping(int segment_id) {
+
+    double base = (double)(segment_id) * 0.618033988749895 + 0.24443434;
+
+    return hsv_to_rgb(Scalar(fmod(base, 1.2), 0.95, 0.80));
+
+}
+
+int main(int argc, char** argv) {
+
+    if (argc < 2 || argc > 6) {
+        help();
+        return -1;
+    }
+
+    Ptr<GraphSegmentation> gs = createGraphSegmentation();
+
+    if (argc > 3)
+        gs->setSigma(atof(argv[3]));
+
+    if (argc > 4)
+        gs->setK((float)atoi(argv[4]));
+
+    if (argc > 5)
+        gs->setMinSize(atoi(argv[5]));
+
+    if (!gs) {
+        std::cerr << "Failed to create GraphSegmentation Algorithm." << std::endl;
+        return -2;
+    }
+
+    Mat input, output, output_image;
+
+    input = imread(argv[1]);
+
+    if (!input.data) {
+        std::cerr << "Failed to load input image" << std::endl;
+        return -3;
+    }
+
+    gs->processImage(input, output);
+
+    double min, max;
+    minMaxLoc(output, &min, &max);
+
+    int nb_segs = (int)max + 1;
+
+    std::cout << nb_segs << " segments" << std::endl;
+
+    output_image = Mat::zeros(output.rows, output.cols, CV_8UC3);
+
+    uint* p;
+    uchar* p2;
+
+    for (int i = 0; i < output.rows; i++) {
+
+        p = output.ptr<uint>(i);
+        p2 = output_image.ptr<uchar>(i);
+
+        for (int j = 0; j < output.cols; j++) {
+            Scalar color = color_mapping(p[j]);
+            p2[j*3] = (uchar)color[0];
+            p2[j*3 + 1] = (uchar)color[1];
+            p2[j*3 + 2] = (uchar)color[2];
+        }
+    }
+
+    imwrite(argv[2], output_image);
+
+    std::cout << "Image written to " << argv[2] << std::endl;
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/live_demo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/live_demo.cpp
new file mode 100644
index 00000000..706ce6eb
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/live_demo.cpp
@@ -0,0 +1,231 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *  
+ *  
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *  
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *  
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *  
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *  
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *  
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/ximgproc.hpp>
+using namespace cv;
+using namespace cv::ximgproc;
+
+#include <iostream>
+using namespace std;
+
+typedef void(*FilteringOperation)(const Mat& src, Mat& dst);
+//current mode (filtering operation example)
+FilteringOperation g_filterOp = NULL;
+
+//list of filtering operations
+void filterDoNothing(const Mat& frame, Mat& dst);
+void filterBlurring(const Mat& frame, Mat& dst);
+void filterStylize(const Mat& frame, Mat& dst);
+void filterDetailEnhancement(const Mat& frame8u, Mat& dst);
+
+//common sliders for every mode
+int g_sigmaColor = 25;
+int g_sigmaSpatial = 10;
+
+//for Stylizing mode
+int g_edgesGamma = 100;
+
+//for Details Enhancement mode
+int g_contrastBase = 100;
+int g_detailsLevel = 100;
+
+int g_numberOfCPUs = cv::getNumberOfCPUs();
+
+//We will use two callbacks to change parameters
+void changeModeCallback(int state, void *filter);
+void changeNumberOfCpuCallback(int count, void*);
+
+void splitScreen(const Mat& rawFrame, Mat& outputFrame, Mat& srcFrame, Mat& processedFrame);
+
+//trivial filter
+void filterDoNothing(const Mat& frame, Mat& dst)
+{
+    frame.copyTo(dst);
+}
+
+//simple edge-aware blurring
+void filterBlurring(const Mat& frame, Mat& dst)
+{
+    dtFilter(frame, frame, dst, g_sigmaSpatial, g_sigmaColor, DTF_RF);
+}
+
+//stylizing filter
+void filterStylize(const Mat& frame, Mat& dst)
+{
+    //blur frame
+    Mat filtered;
+    dtFilter(frame, frame, filtered, g_sigmaSpatial, g_sigmaColor, DTF_NC);
+
+    //compute grayscale blurred frame
+    Mat filteredGray;
+    cvtColor(filtered, filteredGray, COLOR_BGR2GRAY);
+
+    //find gradients of blurred image
+    Mat gradX, gradY;
+    Sobel(filteredGray, gradX, CV_32F, 1, 0, 3, 1.0/255);
+    Sobel(filteredGray, gradY, CV_32F, 0, 1, 3, 1.0/255);
+
+    //compute magnitude of gradient and fit it accordingly the gamma parameter
+    Mat gradMagnitude;
+    magnitude(gradX, gradY, gradMagnitude);
+    cv::pow(gradMagnitude, g_edgesGamma/100.0, gradMagnitude);
+
+    //multiply a blurred frame to the value inversely proportional to the magnitude
+    Mat multiplier = 1.0/(1.0 + gradMagnitude);
+    cvtColor(multiplier, multiplier, COLOR_GRAY2BGR);
+    multiply(filtered, multiplier, dst, 1, dst.type());
+}
+
+void filterDetailEnhancement(const Mat& frame8u, Mat& dst)
+{
+    Mat frame;
+    frame8u.convertTo(frame, CV_32F, 1.0/255);
+
+    //Decompose image to 3 Lab channels
+    Mat frameLab, frameLabCn[3];
+    cvtColor(frame, frameLab, COLOR_BGR2Lab);
+    split(frameLab, frameLabCn);
+
+    //Generate progressively smoother versions of the lightness channel
+    Mat layer0 = frameLabCn[0]; //first channel is original lightness
+    Mat layer1, layer2;
+    dtFilter(layer0, layer0, layer1, g_sigmaSpatial, g_sigmaColor, DTF_IC);
+    dtFilter(layer1, layer1, layer2, 2*g_sigmaSpatial, g_sigmaColor, DTF_IC);
+
+    //Compute detail layers
+    Mat detailLayer1 = layer0 - layer1;
+    Mat detailLayer2 = layer1 - layer2;
+
+    double cBase = g_contrastBase / 100.0;
+    double cDetails1 = g_detailsLevel / 100.0;
+    double cDetails2 = 2.0 - g_detailsLevel / 100.0;
+
+    //Generate lightness
+    double meanLigtness = mean(frameLabCn[0])[0];
+    frameLabCn[0]  = cBase*(layer2 - meanLigtness) + meanLigtness; //fit contrast of base (most blurred) layer
+    frameLabCn[0] += cDetails1*detailLayer1; //add weighted sum of detail layers to new lightness
+    frameLabCn[0] += cDetails2*detailLayer2; //
+
+    //Update new lightness
+    merge(frameLabCn, 3, frameLab);
+    cvtColor(frameLab, frame, COLOR_Lab2BGR);
+    frame.convertTo(dst, CV_8U, 255);
+}
+
+void changeModeCallback(int state, void *filter)
+{
+    if (state == 1)
+        g_filterOp = (FilteringOperation) filter;
+}
+
+void changeNumberOfCpuCallback(int count, void*)
+{
+    count = std::max(1, count);
+    g_numberOfCPUs = count;
+}
+
+//divide screen on two parts: srcFrame and processed Frame
+void splitScreen(const Mat& rawFrame, Mat& outputFrame, Mat& srcFrame, Mat& processedFrame)
+{
+    int h = rawFrame.rows;
+    int w = rawFrame.cols;
+    int cn = rawFrame.channels();
+
+    outputFrame.create(h, 2 * w, CV_MAKE_TYPE(CV_8U, cn));
+    srcFrame = outputFrame(Range::all(), Range(0, w));
+    processedFrame = outputFrame(Range::all(), Range(w, 2 * w));
+    rawFrame.convertTo(srcFrame, srcFrame.type());
+}
+
+int main()
+{
+    VideoCapture cap(0);
+    if (!cap.isOpened())
+    {
+        cerr << "Capture device was not found" << endl;
+        return -1;
+    }
+
+    namedWindow("Demo");
+    displayOverlay("Demo", "Press Ctrl+P to show property window", 5000);
+    
+    //Thread trackbar
+    createTrackbar("Threads", String(), &g_numberOfCPUs, cv::getNumberOfCPUs(), changeNumberOfCpuCallback);
+
+    //Buttons to choose different modes
+    createButton("Mode Details Enhancement", changeModeCallback, (void*)filterDetailEnhancement, QT_RADIOBOX, true);
+    createButton("Mode Stylizing",           changeModeCallback, (void*)filterStylize,           QT_RADIOBOX, false);
+    createButton("Mode Blurring",            changeModeCallback, (void*)filterBlurring,          QT_RADIOBOX, false);
+    createButton("Mode DoNothing",           changeModeCallback, (void*)filterDoNothing,         QT_RADIOBOX, false);
+
+    //sliders for Details Enhancement mode
+    g_filterOp = filterDetailEnhancement; //set Details Enhancement as default filter
+    createTrackbar("Detail contrast", String(), &g_contrastBase, 200);
+    createTrackbar("Detail level" , String(), &g_detailsLevel, 200);
+    
+    //sliders for Stylizing mode
+    createTrackbar("Style gamma", String(), &g_edgesGamma, 300);
+
+    //sliders for every mode
+    createTrackbar("Sigma Spatial", String(), &g_sigmaSpatial, 200);
+    createTrackbar("Sigma Color"  , String(), &g_sigmaColor, 200);
+
+    Mat rawFrame, outputFrame;
+    Mat srcFrame, processedFrame;
+
+    for (;;)
+    {
+        do
+        {
+            cap >> rawFrame;
+        } while (rawFrame.empty());
+
+        cv::setNumThreads(g_numberOfCPUs); //speedup filtering
+
+        splitScreen(rawFrame, outputFrame, srcFrame, processedFrame);
+        g_filterOp(srcFrame, processedFrame);
+
+        imshow("Demo", outputFrame);
+
+        if (waitKey(1) == 27) break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/niblack_thresholding.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/niblack_thresholding.cpp
new file mode 100644
index 00000000..8dafdf96
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/niblack_thresholding.cpp
@@ -0,0 +1,56 @@
+/*
+ * C++ sample to demonstrate Niblack thresholding.
+ */
+
+#include <iostream>
+#include "opencv2/core.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/ximgproc.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::ximgproc;
+
+Mat_<uchar> src;
+int k_ = 8;
+int blockSize_ = 11;
+int type_ = THRESH_BINARY;
+int method_ = BINARIZATION_NIBLACK;
+
+void on_trackbar(int, void*);
+
+int main(int argc, char** argv)
+{
+    // read gray-scale image
+    if(argc != 2)
+    {
+        cout << "Usage: ./niblack_thresholding [IMAGE]\n";
+        return 1;
+    }
+    const char* filename = argv[1];
+    src = imread(filename, IMREAD_GRAYSCALE);
+    imshow("Source", src);
+
+    namedWindow("Niblack", WINDOW_AUTOSIZE);
+    createTrackbar("k", "Niblack", &k_, 20, on_trackbar);
+    createTrackbar("blockSize", "Niblack", &blockSize_, 30, on_trackbar);
+    createTrackbar("method", "Niblack", &method_, 3, on_trackbar);
+    createTrackbar("threshType", "Niblack", &type_, 4, on_trackbar);
+    on_trackbar(0, 0);
+    waitKey(0);
+
+    return 0;
+}
+
+void on_trackbar(int, void*)
+{
+    double k = static_cast<double>(k_-10)/10;                 // [-1.0, 1.0]
+    int blockSize = 2*(blockSize_ >= 1 ? blockSize_ : 1) + 1; // 3,5,7,...,61
+    int type = type_;  // THRESH_BINARY, THRESH_BINARY_INV,
+                       // THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_INV
+    int method = method_; //BINARIZATION_NIBLACK, BINARIZATION_SAUVOLA, BINARIZATION_WOLF, BINARIZATION_NICK
+    Mat dst;
+    niBlackThreshold(src, dst, 255, type, blockSize, k, method);
+    imshow("Niblack", dst);
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/paillou_demo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/paillou_demo.cpp
new file mode 100644
index 00000000..2a8ec2e6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/paillou_demo.cpp
@@ -0,0 +1,112 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/ximgproc.hpp>
+#include "opencv2/ximgproc/paillou_filter.hpp"
+
+using namespace cv;
+using namespace cv::ximgproc;
+
+#include <iostream>
+using namespace std;
+
+int aa = 100, ww = 10;
+
+const char* window_name = "Gradient Modulus";
+
+static void DisplayImage(Mat x,string s)
+{
+    vector<Mat> sx;
+    split(x, sx);
+    vector<double> minVal(3), maxVal(3);
+    for (int i = 0; i < static_cast<int>(sx.size()); i++)
+    {
+        minMaxLoc(sx[i], &minVal[i], &maxVal[i]);
+    }
+    maxVal[0] = *max_element(maxVal.begin(), maxVal.end());
+    minVal[0] = *min_element(minVal.begin(), minVal.end());
+    Mat uc;
+    x.convertTo(uc, CV_8U,255/(maxVal[0]-minVal[0]),-255*minVal[0]/(maxVal[0]-minVal[0]));
+    imshow(s, uc);
+}
+
+
+/**
+ * @function paillouFilter
+ * @brief Trackbar callback
+ */
+static void PaillouFilter(int, void*pm)
+{
+    Mat img = *((Mat*)pm);
+    Mat dst;
+    double a=aa/100.0, w=ww/100.0;
+    Mat rx,ry;
+    GradientPaillouX(img, rx, a, w);
+    GradientPaillouY(img, ry, a, w);
+    DisplayImage(rx, "Gx");
+    DisplayImage(ry, "Gy");
+    add(rx.mul(rx), ry.mul(ry), dst);
+    sqrt(dst, dst);
+    DisplayImage(dst, window_name );
+}
+
+
+int main(int argc, char* argv[])
+{
+    if (argc < 2)
+    {
+        cout << "usage: paillou_demo [image]" << endl;
+        return 1;
+    }
+    Mat img = imread(argv[1]);
+    if (img.empty())
+    {
+        cout << "File not found or empty image\n";
+        return 1;
+    }
+    imshow("Original",img);
+    namedWindow( window_name, WINDOW_AUTOSIZE );
+
+    /// Create a Trackbar for user to enter threshold
+    createTrackbar( "a:",window_name, &aa, 400, PaillouFilter, &img );
+    createTrackbar( "w:", window_name, &ww, 400, PaillouFilter, &img );
+    PaillouFilter(0, &img);
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/peilin.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/peilin.cpp
new file mode 100644
index 00000000..553da77a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/peilin.cpp
@@ -0,0 +1,50 @@
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/ximgproc.hpp>
+
+#include <iostream>
+
+static inline cv::Mat operator& ( const cv::Mat& lhs, const cv::Matx23d& rhs )
+{
+    cv::Mat ret;
+    cv::warpAffine ( lhs, ret, rhs, lhs.size(), cv::INTER_LINEAR );
+    return ret;
+}
+
+static inline cv::Mat operator& ( const cv::Matx23d& lhs, const cv::Mat& rhs )
+{
+    cv::Mat ret;
+    cv::warpAffine ( rhs, ret, lhs, rhs.size(), cv::INTER_LINEAR | cv::WARP_INVERSE_MAP );
+    return ret;
+}
+
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv, "{ @input1 | ../data/peilin_plane.png | }{ @input2 | ../data/peilin_shape.png | }");
+    parser.about("\nThis program demonstrates Pei&Lin Normalization\n");
+    parser.printMessage();
+
+    std::string filename1 = parser.get<std::string>("@input1");
+    std::string filename2 = parser.get<std::string>("@input2");
+
+    cv::Mat I = cv::imread(filename1, 0);
+    if (I.empty())
+    {
+        std::cout << "Couldn't open image " << filename1 << std::endl;
+        return 0;
+    }
+    cv::Mat J = cv::imread(filename2, 0);
+    if (J.empty())
+    {
+        std::cout << "Couldn't open image " << filename2 << std::endl;
+        return 0;
+    }
+    cv::Mat N = I & cv::ximgproc::PeiLinNormalization ( I );
+    cv::Mat D = cv::ximgproc::PeiLinNormalization ( J ) & I;
+    cv::imshow ( "I", I );
+    cv::imshow ( "N", N );
+    cv::imshow ( "J", J );
+    cv::imshow ( "D", D );
+    cv::waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/peilin_plane.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/peilin_plane.png
new file mode 100644
index 00000000..1ef2a28d
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/peilin_plane.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/peilin_shape.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/peilin_shape.png
new file mode 100644
index 00000000..78e9514b
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/peilin_shape.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/polygonstanfordoutput.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/polygonstanfordoutput.png
new file mode 100644
index 00000000..c764bc6f
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/polygonstanfordoutput.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/radon_transform_demo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/radon_transform_demo.cpp
new file mode 100644
index 00000000..f3fa33da
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/radon_transform_demo.cpp
@@ -0,0 +1,18 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include <opencv2/highgui.hpp>
+#include <opencv2/ximgproc/radon_transform.hpp>
+
+using namespace cv;
+
+int main() {
+    Mat src = imread("peilin_plane.png", IMREAD_GRAYSCALE);
+    Mat radon;
+    ximgproc::RadonTransform(src, radon, 1, 0, 180, false, true);
+    imshow("src image", src);
+    imshow("Radon transform", radon);
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/radon_transform_demo.py b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/radon_transform_demo.py
new file mode 100644
index 00000000..0ce7386b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/radon_transform_demo.py
@@ -0,0 +1,13 @@
+# This file is part of OpenCV project.
+# It is subject to the license terms in the LICENSE file found in the top-level directory
+# of this distribution and at http://opencv.org/license.html.
+
+import numpy as np
+import cv2 as cv
+
+if __name__ == "__main__":
+    src = cv.imread("peilin_plane.png", cv.IMREAD_GRAYSCALE)
+    radon = cv.ximgproc.RadonTransform(src).astype(np.float32)
+    cv.imshow("src image", src)
+    cv.imshow("Radon transform", radon)
+    cv.waitKey()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/run_length_morphology_demo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/run_length_morphology_demo.cpp
new file mode 100644
index 00000000..37056c2f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/run_length_morphology_demo.cpp
@@ -0,0 +1,246 @@
+#include <iostream>
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/ximgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::ximgproc;
+
+// Adapted from cv_timer in cv_utilities
+class Timer
+{
+public:
+  Timer() : start_(0), time_(0) {}
+
+  void start()
+  {
+    start_ = cv::getTickCount();
+  }
+
+  void stop()
+  {
+    CV_Assert(start_ != 0);
+    int64 end = cv::getTickCount();
+    time_ += end - start_;
+    start_ = 0;
+  }
+
+  double time()
+  {
+    double ret = time_ / cv::getTickFrequency();
+    time_ = 0;
+    return ret;
+  }
+
+private:
+  int64 start_, time_;
+};
+
+static void help()
+{
+
+printf("\nAllows to estimate the efficiency of the morphology operations implemented\n"
+    "in ximgproc/run_length_morphology.cpp\n"
+    "Call:\n  example_ximgproc_run_length_morphology_demo [image] -u=factor_upscaling image\n"
+    "Similar to the morphology2 sample of the main opencv library it shows the use\n"
+    "of rect, ellipse and cross kernels\n\n"
+    "As rectangular and cross-shaped structuring elements are highly optimized in opencv_imgproc module,\n"
+    "only with elliptical structuring elements a speedup is possible (e.g. for larger circles).\n"
+    "Run-length morphology has advantages for larger images.\n"
+    "You can verify this by upscaling your input with e.g. -u=2\n");
+printf( "Hot keys: \n"
+    "\tESC - quit the program\n"
+    "\tr - use rectangle structuring element\n"
+    "\te - use elliptic structuring element\n"
+    "\tc - use cross-shaped structuring element\n"
+    "\tSPACE - loop through all the options\n" );
+}
+
+static void print_introduction()
+{
+    printf("\nFirst select a threshold for binarization.\n"
+        "Then move the sliders for erosion/dilation or open/close operation\n\n"
+        "The ratio between the time of the execution from opencv_imgproc\n"
+        "and the code using run-length encoding will be displayed in the console\n\n");
+}
+
+Mat src, dst;
+
+int element_shape = MORPH_ELLIPSE;
+
+//the address of variable which receives trackbar position update
+int max_size = 40;
+int open_close_pos = 0;
+int erode_dilate_pos = 0;
+int nThreshold = 100;
+cv::Mat binaryImage;
+cv::Mat binaryRLE, dstRLE;
+cv::Mat rlePainted;
+
+static void PaintRLEToImage(cv::Mat& rleImage, cv::Mat& res, unsigned char uValue)
+{
+    res = cv::Scalar(0);
+    rl::paint(res, rleImage, Scalar((double) uValue));
+}
+
+
+static bool AreImagesIdentical(cv::Mat& image1, cv::Mat& image2)
+{
+    cv::Mat diff;
+    cv::absdiff(image1, image2, diff);
+    int nDiff = cv::countNonZero(diff);
+    return (nDiff == 0);
+}
+
+// callback function for open/close trackbar
+static void OpenClose(int, void*)
+{
+    int n = open_close_pos - max_size;
+    int an = n > 0 ? n : -n;
+    Mat element = getStructuringElement(element_shape, Size(an*2+1, an*2+1), Point(an, an) );
+    Timer timer;
+    timer.start();
+    if( n < 0 )
+        morphologyEx(binaryImage, dst, MORPH_OPEN, element);
+    else
+        morphologyEx(binaryImage, dst, MORPH_CLOSE, element);
+    timer.stop();
+    double imgproc_duration = timer.time();
+
+    element = rl::getStructuringElement(element_shape, Size(an * 2 + 1, an * 2 + 1));
+
+    Timer timer2;
+    timer2.start();
+    if (n < 0)
+        rl::morphologyEx(binaryRLE, dstRLE, MORPH_OPEN, element, true);
+    else
+        rl::morphologyEx(binaryRLE, dstRLE, MORPH_CLOSE, element, true);
+
+    timer2.stop();
+    double rl_duration = timer2.time();
+    cout << "ratio open/close duration: " << rl_duration / imgproc_duration << " (run-length: "
+        << rl_duration << ", pixelwise: " << imgproc_duration << " )" << std::endl;
+
+    PaintRLEToImage(dstRLE, rlePainted, (unsigned char)255);
+    if (!AreImagesIdentical(dst, rlePainted))
+    {
+        cout << "error result image are not identical" << endl;
+    }
+
+    imshow("Open/Close", rlePainted);
+}
+
+// callback function for erode/dilate trackbar
+static void ErodeDilate(int, void*)
+{
+    int n = erode_dilate_pos - max_size;
+    int an = n > 0 ? n : -n;
+    Mat element = getStructuringElement(element_shape, Size(an*2+1, an*2+1), Point(an, an) );
+    Timer timer;
+    timer.start();
+    if( n < 0 )
+        erode(binaryImage, dst, element);
+    else
+        dilate(binaryImage, dst, element);
+    timer.stop();
+    double imgproc_duration = timer.time();
+
+    element = rl::getStructuringElement(element_shape, Size(an*2+1, an*2+1));
+
+    Timer timer2;
+    timer2.start();
+    if( n < 0 )
+        rl::erode(binaryRLE, dstRLE, element, true);
+    else
+        rl::dilate(binaryRLE, dstRLE, element);
+    timer2.stop();
+    double rl_duration = timer2.time();
+
+    PaintRLEToImage(dstRLE, rlePainted, (unsigned char)255);
+    cout << "ratio erode/dilate duration: " << rl_duration / imgproc_duration <<
+        " (run-length: " << rl_duration << ", pixelwise: " << imgproc_duration << " )" << std::endl;
+
+    if (!AreImagesIdentical(dst, rlePainted))
+    {
+        cout << "error result image are not identical" << endl;
+    }
+
+    imshow("Erode/Dilate", rlePainted);
+}
+
+static void OnChangeThreshold(int, void*)
+{
+  threshold(src, binaryImage, (double) nThreshold, 255.0, THRESH_BINARY );
+  rl::threshold(src, binaryRLE, (double) nThreshold, THRESH_BINARY);
+  imshow("Threshold", binaryImage);
+}
+
+
+int main( int argc, char** argv )
+{
+    cv::CommandLineParser parser(argc, argv, "{help h||}{ @image | ../data/aloeL.jpg | }{u| |}");
+    if (parser.has("help"))
+    {
+        help();
+        return 0;
+    }
+    std::string filename = parser.get<std::string>("@image");
+
+    cv::Mat srcIn;
+    if( (srcIn = imread(filename,IMREAD_GRAYSCALE)).empty() )
+    {
+        help();
+        return -1;
+    }
+    int nScale = 1;
+    if (parser.has("u"))
+    {
+        int theScale = parser.get<int>("u");
+        if (theScale > 1)
+            nScale = theScale;
+    }
+
+    if (nScale == 1)
+        src = srcIn;
+    else
+        cv::resize(srcIn, src, cv::Size(srcIn.rows * nScale, srcIn.cols * nScale));
+
+    cout << "scale factor read " << nScale << endl;
+
+    print_introduction();
+
+    //create windows for output images
+    namedWindow("Open/Close",1);
+    namedWindow("Erode/Dilate",1);
+    namedWindow("Threshold",1);
+
+    open_close_pos = erode_dilate_pos = max_size - 10;
+    createTrackbar("size s.e.", "Open/Close",&open_close_pos,max_size*2+1,OpenClose);
+    createTrackbar("size s.e.", "Erode/Dilate",&erode_dilate_pos,max_size*2+1,ErodeDilate);
+    createTrackbar("threshold", "Threshold",&nThreshold,255, OnChangeThreshold);
+    OnChangeThreshold(0, 0);
+    rlePainted.create(cv::Size(src.cols, src.rows), CV_8UC1);
+
+    for(;;)
+    {
+        OpenClose(open_close_pos, 0);
+        ErodeDilate(erode_dilate_pos, 0);
+        char c = (char)waitKey(0);
+
+        if( c == 27 )
+            break;
+        if( c == 'e' )
+            element_shape = MORPH_ELLIPSE;
+        else if( c == 'r' )
+            element_shape = MORPH_RECT;
+        else if( c == 'c' )
+            element_shape = MORPH_CROSS;
+        else if( c == ' ' )
+            element_shape = (element_shape + 1) % 3;
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/seeds.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/seeds.cpp
new file mode 100644
index 00000000..a62d62f1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/seeds.cpp
@@ -0,0 +1,157 @@
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/core/utility.hpp>
+
+#include <opencv2/ximgproc.hpp>
+
+#include <ctype.h>
+#include <stdio.h>
+#include <iostream>
+
+using namespace cv;
+using namespace cv::ximgproc;
+using namespace std;
+
+void trackbarChanged(int pos, void* data);
+
+static void help()
+{
+    cout << "\nThis program demonstrates SEEDS superpixels using OpenCV class SuperpixelSEEDS\n"
+            "Use [space] to toggle output mode\n"
+            "\n"
+            "It captures either from the camera of your choice: 0, 1, ... default 0\n"
+            "Or from an input image\n"
+            "Call:\n"
+            "./seeds [camera #, default 0]\n"
+            "./seeds [input image file]\n" << endl;
+}
+
+static const char* window_name = "SEEDS Superpixels";
+
+static bool init = false;
+
+void trackbarChanged(int, void*)
+{
+    init = false;
+}
+
+
+int main(int argc, char** argv)
+{
+    VideoCapture cap;
+    Mat input_image;
+    bool use_video_capture = false;
+    help();
+
+    if( argc == 1 || (argc == 2 && strlen(argv[1]) == 1 && isdigit(argv[1][0])) )
+    {
+        cap.open(argc == 2 ? argv[1][0] - '0' : 0);
+        use_video_capture = true;
+    }
+    else if( argc >= 2 )
+    {
+        input_image = imread(argv[1]);
+    }
+
+    if( use_video_capture )
+    {
+        if( !cap.isOpened() )
+        {
+            cout << "Could not initialize capturing...\n";
+            return -1;
+        }
+    }
+    else if( input_image.empty() )
+    {
+        cout << "Could not open image...\n";
+        return -1;
+    }
+
+    namedWindow(window_name, 0);
+    int num_iterations = 4;
+    int prior = 2;
+    bool double_step = false;
+    int num_superpixels = 400;
+    int num_levels = 4;
+    int num_histogram_bins = 5;
+    createTrackbar("Number of Superpixels", window_name, &num_superpixels, 1000, trackbarChanged);
+    createTrackbar("Smoothing Prior", window_name, &prior, 5, trackbarChanged);
+    createTrackbar("Number of Levels", window_name, &num_levels, 10, trackbarChanged);
+    createTrackbar("Iterations", window_name, &num_iterations, 12, 0);
+
+    Mat result, mask;
+    Ptr<SuperpixelSEEDS> seeds;
+    int width, height;
+    int display_mode = 0;
+
+    for (;;)
+    {
+        Mat frame;
+        if( use_video_capture )
+            cap >> frame;
+        else
+            input_image.copyTo(frame);
+
+        if( frame.empty() )
+            break;
+
+        if( !init )
+        {
+            width = frame.size().width;
+            height = frame.size().height;
+            seeds = createSuperpixelSEEDS(width, height, frame.channels(), num_superpixels,
+                    num_levels, prior, num_histogram_bins, double_step);
+            init = true;
+        }
+        Mat converted;
+        cvtColor(frame, converted, COLOR_BGR2HSV);
+
+        double t = (double) getTickCount();
+
+        seeds->iterate(converted, num_iterations);
+        result = frame;
+
+        t = ((double) getTickCount() - t) / getTickFrequency();
+        printf("SEEDS segmentation took %i ms with %3i superpixels\n",
+                (int) (t * 1000), seeds->getNumberOfSuperpixels());
+
+        /* retrieve the segmentation result */
+        Mat labels;
+        seeds->getLabels(labels);
+
+        /* get the contours for displaying */
+        seeds->getLabelContourMask(mask, false);
+        result.setTo(Scalar(0, 0, 255), mask);
+
+        /* display output */
+        switch (display_mode)
+        {
+        case 0: //superpixel contours
+            imshow(window_name, result);
+            break;
+        case 1: //mask
+            imshow(window_name, mask);
+            break;
+        case 2: //labels array
+        {
+            // use the last x bit to determine the color. Note that this does not
+            // guarantee that 2 neighboring superpixels have different colors.
+            const int num_label_bits = 2;
+            labels &= (1 << num_label_bits) - 1;
+            labels *= 1 << (16 - num_label_bits);
+            imshow(window_name, labels);
+        }
+            break;
+        }
+
+
+        int c = waitKey(1);
+        if( (c & 255) == 'q' || c == 'Q' || (c & 255) == 27 )
+            break;
+        else if( (c & 255) == ' ' )
+            display_mode = (display_mode + 1) % 3;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/selectivesearchsegmentation_demo.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/selectivesearchsegmentation_demo.cpp
new file mode 100644
index 00000000..e41b6683
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/selectivesearchsegmentation_demo.cpp
@@ -0,0 +1,110 @@
+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+
+#include "opencv2/ximgproc/segmentation.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+#include <ctime>
+
+using namespace cv;
+using namespace cv::ximgproc::segmentation;
+
+static void help() {
+    std::cout << std::endl <<
+    "A program demonstrating the use and capabilities of a particular image segmentation algorithm described" << std::endl <<
+    " in Jasper R. R. Uijlings, Koen E. A. van de Sande, Theo Gevers, Arnold W. M. Smeulders: " << std::endl <<
+    "                       \"Selective Search for Object Recognition\"" << std::endl <<
+    "International Journal of Computer Vision, Volume 104 (2), page 154-171, 2013" << std::endl << std::endl <<
+    "Usage:" << std::endl <<
+    "./selectivesearchsegmentation_demo input_image (single|fast|quality)" << std::endl <<
+    "Use a to display less rects, d to display more rects, q to quit" << std::endl;
+}
+
+
+int main(int argc, char** argv) {
+
+    if (argc < 3) {
+        help();
+        return -1;
+    }
+
+    Mat img = imread(argv[1]);
+
+    Ptr<SelectiveSearchSegmentation> gs = createSelectiveSearchSegmentation();
+    gs->setBaseImage(img);
+
+    if (argv[2][0] == 's') {
+        gs->switchToSingleStrategy();
+    } else if (argv[2][0] == 'f') {
+        gs->switchToSelectiveSearchFast();
+    } else if (argv[2][0] == 'q') {
+        gs->switchToSelectiveSearchQuality();
+    } else {
+        help();
+        return -2;
+    }
+
+    std::vector<Rect> rects;
+    gs->process(rects);
+
+    int nb_rects = 10;
+
+    char c = (char)waitKey();
+
+    while(c != 'q') {
+
+        Mat wimg = img.clone();
+
+        int i = 0;
+
+        for(std::vector<Rect>::iterator it = rects.begin(); it != rects.end(); ++it) {
+            if (i++ < nb_rects) {
+                rectangle(wimg, *it, Scalar(0, 0, 255));
+            }
+        }
+
+        imshow("Output", wimg);
+        c = (char)waitKey();
+
+        if (c == 'd') {
+            nb_rects += 10;
+        }
+
+        if (c == 'a' && nb_rects > 10) {
+            nb_rects -= 10;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/selectivesearchsegmentation_demo.py b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/selectivesearchsegmentation_demo.py
new file mode 100644
index 00000000..9e09c5b5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/selectivesearchsegmentation_demo.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+'''
+A program demonstrating the use and capabilities of a particular image segmentation algorithm described
+in Jasper R. R. Uijlings, Koen E. A. van de Sande, Theo Gevers, Arnold W. M. Smeulders:
+    "Selective Search for Object Recognition"
+International Journal of Computer Vision, Volume 104 (2), page 154-171, 2013
+Usage:
+    ./selectivesearchsegmentation_demo.py input_image (single|fast|quality)
+Use "a" to display less rects, 'd' to display more rects, "q" to quit.
+'''
+
+import cv2 as cv
+import sys
+
+if __name__ == '__main__':
+    img = cv.imread(sys.argv[1])
+
+    cv.setUseOptimized(True)
+    cv.setNumThreads(8)
+
+    gs = cv.ximgproc.segmentation.createSelectiveSearchSegmentation()
+    gs.setBaseImage(img)
+
+    if (sys.argv[2][0] == 's'):
+        gs.switchToSingleStrategy()
+
+    elif (sys.argv[2][0] == 'f'):
+        gs.switchToSelectiveSearchFast()
+
+    elif (sys.argv[2][0] == 'q'):
+        gs.switchToSelectiveSearchQuality()
+    else:
+        print(__doc__)
+        sys.exit(1)
+
+    rects = gs.process()
+    nb_rects = 10
+
+    while True:
+        wimg = img.copy()
+
+        for i in range(len(rects)):
+            if (i < nb_rects):
+                x, y, w, h = rects[i]
+                cv.rectangle(wimg, (x, y), (x+w, y+h), (0, 255, 0), 1, cv.LINE_AA)
+
+        cv.imshow("Output", wimg);
+        c = cv.waitKey()
+
+        if (c == 100):
+            nb_rects += 10
+
+        elif (c == 97 and nb_rects > 10):
+            nb_rects -= 10
+
+        elif (c == 113):
+            break
+
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/slic.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/slic.cpp
new file mode 100644
index 00000000..c49d9ce0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/slic.cpp
@@ -0,0 +1,138 @@
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/core/utility.hpp>
+
+#include <opencv2/ximgproc.hpp>
+
+#include <ctype.h>
+#include <stdio.h>
+#include <iostream>
+
+using namespace cv;
+using namespace cv::ximgproc;
+using namespace std;
+
+static const char* window_name = "SLIC Superpixels";
+
+static const char* keys =
+    "{h help      | | help menu}"
+    "{c camera    |0| camera id}"
+    "{i image     | | image file}"
+    "{a algorithm |1| SLIC(0),SLICO(1),MSLIC(2)}"
+    ;
+
+int main(int argc, char** argv)
+{
+    CommandLineParser cmd(argc,argv,keys);
+    if (cmd.has("help")) {
+        cmd.about("This program demonstrates SLIC superpixels using OpenCV class SuperpixelSLIC.\n"
+            "If no image file is supplied, try to open a webcam.\n"
+            "Use [space] to toggle output mode, ['q' or 'Q' or 'esc'] to exit.\n");
+        cmd.printMessage();
+        return 0;
+    }
+    int capture = cmd.get<int>("camera");
+    String img_file = cmd.get<String>("image");
+    int algorithm = cmd.get<int>("algorithm");
+    int region_size = 50;
+    int ruler = 30;
+    int min_element_size = 50;
+    int num_iterations = 3;
+    bool use_video_capture = img_file.empty();
+
+    VideoCapture cap;
+    Mat input_image;
+
+    if( use_video_capture )
+    {
+        if( !cap.open(capture) )
+        {
+            cout << "Could not initialize capturing..."<<capture<<"\n";
+            return -1;
+        }
+    }
+    else
+    {
+        input_image = imread(img_file);
+        if( input_image.empty() )
+        {
+            cout << "Could not open image..."<<img_file<<"\n";
+            return -1;
+        }
+    }
+
+    namedWindow(window_name, 0);
+    createTrackbar("Algorithm", window_name, &algorithm, 2, 0);
+    createTrackbar("Region size", window_name, &region_size, 200, 0);
+    createTrackbar("Ruler", window_name, &ruler, 100, 0);
+    createTrackbar("Connectivity", window_name, &min_element_size, 100, 0);
+    createTrackbar("Iterations", window_name, &num_iterations, 12, 0);
+
+    Mat result, mask;
+    int display_mode = 0;
+
+    for (;;)
+    {
+        Mat frame;
+        if( use_video_capture )
+            cap >> frame;
+        else
+            input_image.copyTo(frame);
+
+        if( frame.empty() )
+            break;
+
+        result = frame;
+        Mat converted;
+        cvtColor(frame, converted, COLOR_BGR2HSV);
+
+        double t = (double) getTickCount();
+
+        Ptr<SuperpixelSLIC> slic = createSuperpixelSLIC(converted,algorithm+SLIC,region_size,float(ruler));
+        slic->iterate(num_iterations);
+        if (min_element_size>0)
+            slic->enforceLabelConnectivity(min_element_size);
+
+        t = ((double) getTickCount() - t) / getTickFrequency();
+        cout << "SLIC" << (algorithm?'O':' ')
+             << " segmentation took " << (int) (t * 1000)
+             << " ms with " << slic->getNumberOfSuperpixels() << " superpixels" << endl;
+
+        // get the contours for displaying
+        slic->getLabelContourMask(mask, true);
+        result.setTo(Scalar(0, 0, 255), mask);
+
+        // display output
+        switch (display_mode)
+        {
+        case 0: //superpixel contours
+            imshow(window_name, result);
+            break;
+        case 1: //mask
+            imshow(window_name, mask);
+            break;
+        case 2: //labels array
+        {
+            // use the last x bit to determine the color. Note that this does not
+            // guarantee that 2 neighboring superpixels have different colors.
+            // retrieve the segmentation result
+            Mat labels;
+            slic->getLabels(labels);
+            const int num_label_bits = 2;
+            labels &= (1 << num_label_bits) - 1;
+            labels *= 1 << (16 - num_label_bits);
+            imshow(window_name, labels);
+            break;
+        }
+        }
+
+        int c = waitKey(1) & 0xff;
+        if( c == 'q' || c == 'Q' || c == 27 )
+            break;
+        else if( c == ' ' )
+            display_mode = (display_mode + 1) % 3;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/stanford.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/stanford.png
new file mode 100644
index 00000000..9b736a71
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/stanford.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/structured_edge_detection.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/structured_edge_detection.cpp
new file mode 100644
index 00000000..c9190c2a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/structured_edge_detection.cpp
@@ -0,0 +1,96 @@
+/**************************************************************************************
+The structured forests for fast edge detection demo requires you to provide a model.
+This model can be found at the opencv_extra repository on Github on the following link:
+https://github.com/opencv/opencv_extra/blob/master/testdata/cv/ximgproc/model.yml.gz
+***************************************************************************************/
+
+#include <opencv2/ximgproc.hpp>
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace cv::ximgproc;
+
+const char* keys =
+{
+    "{i || input image file name}"
+    "{m || model file name}"
+    "{o || output image file name}"
+};
+
+int main( int argc, const char** argv )
+{
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("This sample demonstrates usage of structured forests for fast edge detection");
+    parser.printMessage();
+
+    if ( !parser.check() )
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    String modelFilename = parser.get<String>("m");
+    String inFilename = parser.get<String>("i");
+    String outFilename = parser.get<String>("o");
+
+    //! [imread]
+    Mat image = imread(inFilename, IMREAD_COLOR);
+    if ( image.empty() )
+        CV_Error(Error::StsError, String("Cannot read image file: ") + inFilename);
+    //! [imread]
+
+    if ( modelFilename.size() == 0)
+        CV_Error(Error::StsError, String("Empty model name"));
+
+    //! [convert]
+    image.convertTo(image, DataType<float>::type, 1/255.0);
+    //! [convert]
+
+    TickMeter tm;
+    tm.start();
+    //! [create]
+    Ptr<StructuredEdgeDetection> pDollar =
+        createStructuredEdgeDetection(modelFilename);
+    //! [create]
+
+    tm.stop();
+    std::cout << "createStructuredEdgeDetection() time : " << tm << std::endl;
+
+    tm.reset();
+    tm.start();
+    //! [detect]
+    Mat edges;
+    pDollar->detectEdges(image, edges);
+    //! [detect]
+    tm.stop();
+    std::cout << "detectEdges() time : " << tm << std::endl;
+
+    tm.reset();
+    tm.start();
+    //! [nms]
+    // computes orientation from edge map
+    Mat orientation_map;
+    pDollar->computeOrientation(edges, orientation_map);
+
+    // suppress edges
+    Mat edge_nms;
+    pDollar->edgesNms(edges, orientation_map, edge_nms, 2, 0, 1, true);
+    //! [nms]
+
+    tm.stop();
+    std::cout << "nms time : " << tm << std::endl;
+
+    //! [imshow]
+    if ( outFilename.size() == 0 )
+    {
+        imshow("edges", edges);
+        imshow("edges nms", edge_nms);
+        waitKey(0);
+    }
+    else
+        imwrite(outFilename, 255*edges);
+    //! [imshow]
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/thinning.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/thinning.cpp
new file mode 100644
index 00000000..39a6960b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/samples/thinning.cpp
@@ -0,0 +1,45 @@
+#include <iostream>
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+#include "opencv2/ximgproc.hpp"
+
+using namespace std;
+using namespace cv;
+
+int main()
+{
+    Mat img = imread("opencv-logo.png", IMREAD_COLOR);
+    resize(img, img, Size(), 0.5, 0.5, INTER_LINEAR_EXACT);
+
+    /// Threshold the input image
+    Mat img_grayscale, img_binary;
+    cvtColor(img, img_grayscale,COLOR_BGR2GRAY);
+    threshold(img_grayscale, img_binary, 0, 255, THRESH_OTSU | THRESH_BINARY_INV);
+
+    /// Apply thinning to get a skeleton
+    Mat img_thinning_ZS, img_thinning_GH;
+    ximgproc::thinning(img_binary, img_thinning_ZS, ximgproc::THINNING_ZHANGSUEN);
+    ximgproc::thinning(img_binary, img_thinning_GH, ximgproc::THINNING_GUOHALL);
+
+    /// Make 3 channel images from thinning result
+    Mat result_ZS(img.rows, img.cols, CV_8UC3), result_GH(img.rows, img.cols, CV_8UC3);
+
+    Mat in[] = { img_thinning_ZS, img_thinning_ZS, img_thinning_ZS };
+    Mat in2[] = { img_thinning_GH, img_thinning_GH, img_thinning_GH };
+    int from_to[] = { 0,0, 1,1, 2,2 };
+    mixChannels( in, 3, &result_ZS, 1, from_to, 3 );
+    mixChannels( in2, 3, &result_GH, 1, from_to, 3 );
+
+    /// Combine everything into a canvas
+    Mat canvas(img.rows, img.cols * 3, CV_8UC3);
+    img.copyTo( canvas( Rect(0, 0, img.cols, img.rows) ) );
+    result_ZS.copyTo( canvas( Rect(img.cols, 0, img.cols, img.rows) ) );
+    result_GH.copyTo( canvas( Rect(img.cols*2, 0, img.cols, img.rows) ) );
+
+    /// Visualize result
+    imshow("Skeleton", canvas); waitKey(0);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/adaptive_manifold_filter_n.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/adaptive_manifold_filter_n.cpp
new file mode 100644
index 00000000..3aa58caf
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/adaptive_manifold_filter_n.cpp
@@ -0,0 +1,876 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include "edgeaware_filters_common.hpp"
+#include <cmath>
+#include <cstring>
+#include <limits>
+
+#ifdef _MSC_VER
+#   pragma warning(disable: 4512)
+#endif
+
+namespace
+{
+
+using std::numeric_limits;
+using std::vector;
+using namespace cv;
+using namespace cv::ximgproc;
+using namespace cv::ximgproc::intrinsics;
+
+#ifndef SQR
+#define SQR(x) ((x)*(x))
+#endif
+
+inline double Log2(double n)
+{
+    return log(n) / log(2.0);
+}
+
+inline double floor_to_power_of_two(double r)
+{
+    return pow(2.0, floor(Log2(r)));
+}
+
+inline int computeManifoldTreeHeight(double sigma_s, double sigma_r)
+{
+    const double Hs = floor(Log2(sigma_s)) - 1.0;
+    const double Lr = 1.0 - sigma_r;
+    return max(2, static_cast<int>(ceil(Hs * Lr)));
+}
+
+static void splitChannels(InputArrayOfArrays src, vector<Mat>& dst)
+{
+    CV_Assert(src.isMat() || src.isUMat() || src.isMatVector() || src.isUMatVector());
+
+    if ( src.isMat() || src.isUMat() )
+    {
+        split(src, dst);
+    }
+    else
+    {
+        Size sz;
+        int depth, totalCnNum;
+
+        checkSameSizeAndDepth(src, sz, depth);
+        totalCnNum = getTotalNumberOfChannels(src);
+
+        dst.resize(totalCnNum);
+        vector<int> fromTo(2 * totalCnNum);
+        for (int i = 0; i < totalCnNum; i++)
+        {
+            fromTo[i * 2 + 0] = i;
+            fromTo[i * 2 + 1] = i;
+
+            dst[i].create(sz, CV_MAKE_TYPE(depth, 1));
+        }
+
+        mixChannels(src, dst, fromTo);
+    }
+}
+
+class AdaptiveManifoldFilterN : public AdaptiveManifoldFilter
+{
+public:
+    AdaptiveManifoldFilterN();
+
+    void filter(InputArray src, OutputArray dst, InputArray joint) CV_OVERRIDE;
+
+    void collectGarbage() CV_OVERRIDE;
+
+    inline double getSigmaS() const CV_OVERRIDE { return sigma_s_; }
+    inline void setSigmaS(double val) CV_OVERRIDE { sigma_s_ = val; }
+    inline double getSigmaR() const CV_OVERRIDE { return sigma_r_; }
+    inline void setSigmaR(double val) CV_OVERRIDE { sigma_r_ = val; }
+    inline int getTreeHeight() const CV_OVERRIDE { return tree_height_; }
+    inline void setTreeHeight(int val) CV_OVERRIDE { tree_height_ = val; }
+    inline int getPCAIterations() const CV_OVERRIDE { return num_pca_iterations_; }
+    inline void setPCAIterations(int val) CV_OVERRIDE { num_pca_iterations_ = val; }
+    inline bool getAdjustOutliers() const CV_OVERRIDE { return adjust_outliers_; }
+    inline void setAdjustOutliers(bool val) CV_OVERRIDE { adjust_outliers_ = val; }
+    inline bool getUseRNG() const CV_OVERRIDE { return useRNG; }
+    inline void setUseRNG(bool val) CV_OVERRIDE { useRNG = val; }
+
+protected:
+
+    bool adjust_outliers_;
+    double sigma_s_;
+    double sigma_r_;
+    int tree_height_;
+    int num_pca_iterations_;
+    bool useRNG;
+
+private:
+
+    Size srcSize;
+    Size smallSize;
+    int jointCnNum;
+    int srcCnNum;
+
+    vector<Mat> jointCn;
+    vector<Mat> srcCn;
+
+    vector<Mat> etaFull;
+
+    vector<Mat> sum_w_ki_Psi_blur_;
+    Mat sum_w_ki_Psi_blur_0_;
+
+    Mat w_k;
+    Mat Psi_splat_0_small;
+    vector<Mat> Psi_splat_small;
+
+    Mat1f minDistToManifoldSquared;
+
+    int curTreeHeight;
+    float sigma_r_over_sqrt_2;
+
+    RNG rnd;
+
+private: /*inline functions*/
+
+    double getNormalizer(int depth)
+    {
+        double normalizer = 1.0;
+
+        if (depth == CV_8U)
+            normalizer = 1.0 / 0xFF;
+        else if (depth == CV_16U)
+            normalizer = 1.0 / 0xFFFF;
+
+        return normalizer;
+    }
+
+    double getResizeRatio()
+    {
+        double df = min(sigma_s_ / 4.0, 256.0 * sigma_r_);
+        df = floor_to_power_of_two(df);
+        df = max(1.0, df);
+        return df;
+    }
+
+    Size getSmallSize()
+    {
+        double df = getResizeRatio();
+        return Size( cvRound(srcSize.width * (1.0/df)), cvRound(srcSize.height*(1.0/df)) ) ;
+    }
+
+    void downsample(const Mat& src, Mat& dst)
+    {
+        double df = getResizeRatio();
+        CV_DbgAssert(src.empty() || src.size() == srcSize);
+        resize(src, dst, Size(), 1.0 / df, 1.0 / df, INTER_LINEAR);
+        CV_DbgAssert(dst.size() == smallSize);
+    }
+
+    void upsample(const Mat& src, Mat& dst)
+    {
+        CV_DbgAssert(src.empty() || src.size() == smallSize);
+        resize(src, dst, srcSize, 0, 0);
+    }
+
+    void downsample(const vector<Mat>& srcv, vector<Mat>& dstv)
+    {
+        mapParallel(&AdaptiveManifoldFilterN::downsample, srcv, dstv);
+    }
+
+    void upsample(const vector<Mat>& srcv, vector<Mat>& dstv)
+    {
+        mapParallel(&AdaptiveManifoldFilterN::upsample, srcv, dstv);
+    }
+
+private:
+
+    void initBuffers(InputArray src_, InputArray joint_);
+
+    void initSrcAndJoint(InputArray src_, InputArray joint_);
+
+    void buildManifoldsAndPerformFiltering(vector<Mat>& eta, Mat1b& cluster, int treeLevel);
+
+    void gatherResult(InputArray src_, OutputArray dst_);
+
+    void compute_w_k(vector<Mat>& etak, Mat& dst, float sigma, int curTreeLevel);
+
+    void computeClusters(Mat1b& cluster, Mat1b& cluster_minus, Mat1b& cluster_plus);
+
+    void computeEta(Mat& teta, Mat1b& cluster, vector<Mat>& etaDst);
+
+
+    static void h_filter(const Mat1f& src, Mat& dst, float sigma);
+
+    static void RFFilterPass(vector<Mat>& joint, vector<Mat>& Psi_splat, Mat& Psi_splat_0, vector<Mat>& Psi_splat_dst, Mat& Psi_splat_0_dst, float ss, float sr);
+
+    static void computeDTHor(vector<Mat>& srcCn, Mat& dst, float ss, float sr);
+
+    static void computeDTVer(vector<Mat>& srcCn, Mat& dst, float ss, float sr);
+
+    static void computeEigenVector(const vector<Mat>& X, const Mat1b& mask, Mat1f& vecDst, int num_pca_iterations, const Mat1f& vecRand);
+
+    static void computeOrientation(const vector<Mat>& X, const Mat1f& vec, Mat1f& dst);
+
+private: /*Parallelization routines*/
+
+    typedef void (AdaptiveManifoldFilterN::*MapFunc)(const Mat& src, Mat& dst);
+
+    void mapParallel(MapFunc func, const vector<Mat>& srcv, vector<Mat>& dstv)
+    {
+        dstv.resize(srcv.size());
+        parallel_for_(Range(0, (int)srcv.size()), MapPrallelLoopBody(this, func, srcv, dstv));
+    }
+
+    struct MapPrallelLoopBody : public cv::ParallelLoopBody
+    {
+        MapPrallelLoopBody(AdaptiveManifoldFilterN *_instancePtr, MapFunc _transform, const vector<Mat>& _srcv, vector<Mat>& _dstv)
+            : instancePtr(_instancePtr), transform(_transform), srcv(_srcv), dstv(_dstv)
+        {}
+
+        AdaptiveManifoldFilterN *instancePtr;
+        MapFunc transform;
+        const vector<Mat>& srcv;
+        vector<Mat>& dstv;
+
+        void operator () (const Range& range) const CV_OVERRIDE
+        {
+            for (int i = range.start; i < range.end; i++)
+                (instancePtr->*transform)(srcv[i], dstv[i]);
+        }
+    };
+
+};
+
+AdaptiveManifoldFilterN::AdaptiveManifoldFilterN()
+{
+    sigma_s_ = 16.0;
+    sigma_r_ = 0.2;
+    tree_height_ = -1;
+    num_pca_iterations_ = 1;
+    adjust_outliers_ = false;
+    useRNG = true;
+}
+
+void AdaptiveManifoldFilterN::initBuffers(InputArray src_, InputArray joint_)
+{
+    initSrcAndJoint(src_, joint_);
+
+    jointCn.resize(jointCnNum);
+    Psi_splat_small.resize(jointCnNum);
+    for (int i = 0; i < jointCnNum; i++)
+    {
+        //jointCn[i].create(srcSize, CV_32FC1);
+        Psi_splat_small[i].create(smallSize, CV_32FC1);
+    }
+
+    srcCn.resize(srcCnNum);
+    sum_w_ki_Psi_blur_.resize(srcCnNum);
+    for (int i = 0; i < srcCnNum; i++)
+    {
+        //srcCn[i].create(srcSize, CV_32FC1);
+        sum_w_ki_Psi_blur_[i] = Mat::zeros(srcSize, CV_32FC1);
+    }
+
+    sum_w_ki_Psi_blur_0_ = Mat::zeros(srcSize, CV_32FC1);
+    w_k.create(srcSize, CV_32FC1);
+    Psi_splat_0_small.create(smallSize, CV_32FC1);
+
+    if (adjust_outliers_)
+        minDistToManifoldSquared.create(srcSize);
+}
+
+void AdaptiveManifoldFilterN::initSrcAndJoint(InputArray src_, InputArray joint_)
+{
+    srcSize = src_.size();
+    smallSize = getSmallSize();
+    srcCnNum = src_.channels();
+
+    split(src_, srcCn);
+    if (src_.depth() != CV_32F)
+    {
+        for (int i = 0; i < srcCnNum; i++)
+            srcCn[i].convertTo(srcCn[i], CV_32F);
+    }
+
+    if (joint_.empty() || joint_.getObj() == src_.getObj())
+    {
+        jointCnNum = srcCnNum;
+
+        if (src_.depth() == CV_32F)
+        {
+            jointCn = srcCn;
+        }
+        else
+        {
+            jointCn.resize(jointCnNum);
+            for (int i = 0; i < jointCnNum; i++)
+                srcCn[i].convertTo(jointCn[i], CV_32F, getNormalizer(src_.depth()));
+        }
+    }
+    else
+    {
+        splitChannels(joint_, jointCn);
+
+        jointCnNum = (int)jointCn.size();
+        int jointDepth = jointCn[0].depth();
+        Size jointSize = jointCn[0].size();
+
+        CV_Assert( jointSize == srcSize && (jointDepth == CV_8U || jointDepth == CV_16U || jointDepth == CV_32F) );
+
+        if (jointDepth != CV_32F)
+        {
+            for (int i = 0; i < jointCnNum; i++)
+                jointCn[i].convertTo(jointCn[i], CV_32F, getNormalizer(jointDepth));
+        }
+    }
+}
+
+void AdaptiveManifoldFilterN::filter(InputArray src, OutputArray dst, InputArray joint)
+{
+    CV_Assert(sigma_s_ >= 1 && (sigma_r_ > 0 && sigma_r_ <= 1));
+    num_pca_iterations_ = std::max(1, num_pca_iterations_);
+
+    initBuffers(src, joint);
+
+    curTreeHeight = tree_height_ <= 0 ? computeManifoldTreeHeight(sigma_s_, sigma_r_) : tree_height_;
+
+    sigma_r_over_sqrt_2 = (float) (sigma_r_ / sqrt(2.0));
+
+    const double seedCoef = jointCn[0].at<float>(srcSize.height/2, srcSize.width/2);
+    const uint64 baseCoef = numeric_limits<uint64>::max() / 0xFFFF;
+    rnd.state = static_cast<int64>(baseCoef*seedCoef);
+
+    Mat1b cluster0(srcSize, 0xFF);
+    vector<Mat> eta0(jointCnNum);
+    for (int i = 0; i < jointCnNum; i++)
+        h_filter(jointCn[i], eta0[i], (float)sigma_s_);
+
+    buildManifoldsAndPerformFiltering(eta0, cluster0, 1);
+
+    gatherResult(src, dst);
+}
+
+void AdaptiveManifoldFilterN::gatherResult(InputArray src_, OutputArray dst_)
+{
+    int dDepth = src_.depth();
+    vector<Mat> dstCn(srcCnNum);
+
+    if (!adjust_outliers_)
+    {
+        for (int i = 0; i < srcCnNum; i++)
+            divide(sum_w_ki_Psi_blur_[i], sum_w_ki_Psi_blur_0_, dstCn[i], 1.0, dDepth);
+
+        merge(dstCn, dst_);
+    }
+    else
+    {
+        Mat1f& alpha = minDistToManifoldSquared;
+        double sigmaMember = -0.5 / (sigma_r_*sigma_r_);
+        multiply(minDistToManifoldSquared, sigmaMember, minDistToManifoldSquared);
+        cv::exp(minDistToManifoldSquared, alpha);
+
+        for (int i = 0; i < srcCnNum; i++)
+        {
+            Mat& f = srcCn[i];
+            Mat& g = dstCn[i];
+
+            divide(sum_w_ki_Psi_blur_[i], sum_w_ki_Psi_blur_0_, g);
+
+            subtract(g, f, g);
+            multiply(alpha, g, g);
+            add(g, f, g);
+
+            g.convertTo(g, dDepth);
+        }
+
+        merge(dstCn, dst_);
+    }
+}
+
+void AdaptiveManifoldFilterN::buildManifoldsAndPerformFiltering(vector<Mat>& eta, Mat1b& cluster, int treeLevel)
+{
+    CV_DbgAssert((int)eta.size() == jointCnNum);
+
+    //splatting
+    Size etaSize = eta[0].size();
+    CV_DbgAssert(etaSize == srcSize || etaSize == smallSize);
+
+    if (etaSize == srcSize)
+    {
+        compute_w_k(eta, w_k, sigma_r_over_sqrt_2, treeLevel);
+        etaFull = eta;
+        downsample(eta, eta);
+    }
+    else
+    {
+        upsample(eta, etaFull);
+        compute_w_k(etaFull, w_k, sigma_r_over_sqrt_2, treeLevel);
+    }
+
+    //blurring
+    Psi_splat_small.resize(srcCnNum);
+    for (int si = 0; si < srcCnNum; si++)
+    {
+        Mat tmp;
+        multiply(srcCn[si], w_k, tmp);
+        downsample(tmp, Psi_splat_small[si]);
+    }
+    downsample(w_k, Psi_splat_0_small);
+
+    vector<Mat>& Psi_splat_small_blur = Psi_splat_small;
+    Mat& Psi_splat_0_small_blur = Psi_splat_0_small;
+
+    float rf_ss = (float)(sigma_s_ / getResizeRatio());
+    float rf_sr = (float)(sigma_r_over_sqrt_2);
+    RFFilterPass(eta, Psi_splat_small, Psi_splat_0_small, Psi_splat_small_blur, Psi_splat_0_small_blur, rf_ss, rf_sr);
+
+    //slicing
+    {
+        Mat tmp;
+        for (int i = 0; i < srcCnNum; i++)
+        {
+            upsample(Psi_splat_small_blur[i], tmp);
+            multiply(tmp, w_k, tmp);
+            add(sum_w_ki_Psi_blur_[i], tmp, sum_w_ki_Psi_blur_[i]);
+        }
+        upsample(Psi_splat_0_small_blur, tmp);
+        multiply(tmp, w_k, tmp);
+        add(sum_w_ki_Psi_blur_0_, tmp, sum_w_ki_Psi_blur_0_);
+    }
+
+    //build new manifolds
+    if (treeLevel < curTreeHeight)
+    {
+        Mat1b cluster_minus, cluster_plus;
+
+        computeClusters(cluster, cluster_minus, cluster_plus);
+
+        vector<Mat> eta_minus(jointCnNum), eta_plus(jointCnNum);
+        {
+            Mat1f teta = 1.0 - w_k;
+            computeEta(teta, cluster_minus, eta_minus);
+            computeEta(teta, cluster_plus, eta_plus);
+        }
+
+        //free memory to continue deep recursion
+        eta.clear();
+        cluster.release();
+
+        buildManifoldsAndPerformFiltering(eta_minus, cluster_minus, treeLevel + 1);
+        buildManifoldsAndPerformFiltering(eta_plus, cluster_plus, treeLevel + 1);
+    }
+}
+
+void AdaptiveManifoldFilterN::collectGarbage()
+{
+    srcCn.clear();
+    jointCn.clear();
+    etaFull.clear();
+    sum_w_ki_Psi_blur_.clear();
+    Psi_splat_small.clear();
+
+    sum_w_ki_Psi_blur_0_.release();
+    w_k.release();
+    Psi_splat_0_small.release();
+    minDistToManifoldSquared.release();
+}
+
+void AdaptiveManifoldFilterN::h_filter(const Mat1f& src, Mat& dst, float sigma)
+{
+    CV_DbgAssert(src.depth() == CV_32F);
+
+    const float a = exp(-sqrt(2.0f) / sigma);
+
+    dst.create(src.size(), CV_32FC1);
+
+    for (int y = 0; y < src.rows; ++y)
+    {
+        const float* src_row = src[y];
+        float* dst_row = dst.ptr<float>(y);
+
+        dst_row[0] = src_row[0];
+        for (int x = 1; x < src.cols; ++x)
+        {
+            dst_row[x] = src_row[x] + a * (dst_row[x - 1] - src_row[x]);
+        }
+        for (int x = src.cols - 2; x >= 0; --x)
+        {
+            dst_row[x] = dst_row[x] + a * (dst_row[x + 1] - dst_row[x]);
+        }
+    }
+
+    for (int y = 1; y < src.rows; ++y)
+    {
+        float* dst_cur_row = dst.ptr<float>(y);
+        float* dst_prev_row = dst.ptr<float>(y-1);
+
+        rf_vert_row_pass(dst_cur_row, dst_prev_row, a, src.cols);
+    }
+    for (int y = src.rows - 2; y >= 0; --y)
+    {
+        float* dst_cur_row = dst.ptr<float>(y);
+        float* dst_prev_row = dst.ptr<float>(y+1);
+
+        rf_vert_row_pass(dst_cur_row, dst_prev_row, a, src.cols);
+    }
+}
+
+void AdaptiveManifoldFilterN::compute_w_k(vector<Mat>& etak, Mat& dst, float sigma, int curTreeLevel)
+{
+    CV_DbgAssert((int)etak.size() == jointCnNum);
+
+    dst.create(srcSize, CV_32FC1);
+    float argConst = -0.5f / (sigma*sigma);
+
+    for (int i = 0; i < srcSize.height; i++)
+    {
+        float *dstRow = dst.ptr<float>(i);
+
+        for (int cn = 0; cn < jointCnNum; cn++)
+        {
+            float *eta_kCnRow = etak[cn].ptr<float>(i);
+            float *jointCnRow = jointCn[cn].ptr<float>(i);
+
+            if (cn == 0)
+            {
+                sqr_dif(dstRow, eta_kCnRow, jointCnRow, srcSize.width);
+            }
+            else
+            {
+                add_sqr_dif(dstRow, eta_kCnRow, jointCnRow, srcSize.width);
+            }
+        }
+
+        if (adjust_outliers_)
+        {
+            float *minDistRow = minDistToManifoldSquared.ptr<float>(i);
+
+            if (curTreeLevel != 1)
+            {
+                min_(minDistRow, minDistRow, dstRow, srcSize.width);
+            }
+            else
+            {
+                std::memcpy(minDistRow, dstRow, srcSize.width*sizeof(float));
+            }
+        }
+
+        mul(dstRow, dstRow, argConst, srcSize.width);
+        //Exp_32f(dstRow, dstRow, srcSize.width);
+    }
+
+    cv::exp(dst, dst);
+}
+
+void AdaptiveManifoldFilterN::computeDTHor(vector<Mat>& srcCn, Mat& dst, float sigma_s, float sigma_r)
+{
+    int cnNum = (int)srcCn.size();
+    int h = srcCn[0].rows;
+    int w = srcCn[0].cols;
+
+    float sigmaRatioSqr = (float) SQR(sigma_s / sigma_r);
+    float lnAlpha       = (float) (-sqrt(2.0) / sigma_s);
+
+    dst.create(h, w-1, CV_32F);
+
+    for (int i = 0; i < h; i++)
+    {
+        float *dstRow = dst.ptr<float>(i);
+
+        for (int cn = 0; cn < cnNum; cn++)
+        {
+            float *curCnRow = srcCn[cn].ptr<float>(i);
+
+            if (cn == 0)
+                sqr_dif(dstRow, curCnRow, curCnRow + 1, w - 1);
+            else
+                add_sqr_dif(dstRow, curCnRow, curCnRow + 1, w - 1);
+        }
+
+        mad(dstRow, dstRow, sigmaRatioSqr, 1.0f, w - 1);
+        sqrt_(dstRow, dstRow, w - 1);
+        mul(dstRow, dstRow, lnAlpha, w - 1);
+        //Exp_32f(dstRow, dstRow, w - 1);
+    }
+
+    cv::exp(dst, dst);
+}
+
+void AdaptiveManifoldFilterN::computeDTVer(vector<Mat>& srcCn, Mat& dst, float sigma_s, float sigma_r)
+{
+    int cnNum = (int)srcCn.size();
+    int h = srcCn[0].rows;
+    int w = srcCn[0].cols;
+
+    dst.create(h-1, w, CV_32F);
+
+    float sigmaRatioSqr = (float) SQR(sigma_s / sigma_r);
+    float lnAlpha       = (float) (-sqrt(2.0) / sigma_s);
+
+    for (int i = 0; i < h-1; i++)
+    {
+        float *dstRow = dst.ptr<float>(i);
+
+        for (int cn = 0; cn < cnNum; cn++)
+        {
+            float *srcRow1 = srcCn[cn].ptr<float>(i);
+            float *srcRow2 = srcCn[cn].ptr<float>(i+1);
+
+            if (cn == 0)
+                sqr_dif(dstRow, srcRow1, srcRow2, w);
+            else
+                add_sqr_dif(dstRow, srcRow1, srcRow2, w);
+        }
+
+        mad(dstRow, dstRow, sigmaRatioSqr, 1.0f, w);
+        sqrt_(dstRow, dstRow, w);
+
+        mul(dstRow, dstRow, lnAlpha, w);
+        //Exp_32f(dstRow, dstRow, w);
+    }
+
+    cv::exp(dst, dst);
+}
+
+void AdaptiveManifoldFilterN::RFFilterPass(vector<Mat>& joint, vector<Mat>& Psi_splat, Mat& Psi_splat_0, vector<Mat>& Psi_splat_dst, Mat& Psi_splat_0_dst, float ss, float sr)
+{
+    int h = joint[0].rows;
+    int w = joint[0].cols;
+    int cnNum = (int)Psi_splat.size();
+
+    Mat adth, adtv;
+    computeDTHor(joint, adth, ss, sr);
+    computeDTVer(joint, adtv, ss, sr);
+
+    Psi_splat_0_dst.create(h, w, CV_32FC1);
+    Psi_splat_dst.resize(cnNum);
+    for (int cn = 0; cn < cnNum; cn++)
+        Psi_splat_dst[cn].create(h, w, CV_32FC1);
+
+    Ptr<DTFilter> dtf = createDTFilterRF(adth, adtv, ss, sr, 1);
+    for (int cn = 0; cn < cnNum; cn++)
+        dtf->filter(Psi_splat[cn], Psi_splat_dst[cn]);
+    dtf->filter(Psi_splat_0, Psi_splat_0_dst);
+}
+
+void AdaptiveManifoldFilterN::computeClusters(Mat1b& cluster, Mat1b& cluster_minus, Mat1b& cluster_plus)
+{
+
+    Mat1f difOreientation;
+    if (jointCnNum > 1)
+    {
+        Mat1f initVec(1, jointCnNum);
+        if (useRNG)
+        {
+            rnd.fill(initVec, RNG::UNIFORM, -0.5, 0.5);
+        }
+        else
+        {
+            for (int i = 0; i < (int)initVec.total(); i++)
+                initVec(0, i) = (i % 2 == 0) ? 0.5f : -0.5f;
+        }
+
+        vector<Mat> difEtaSrc(jointCnNum);
+        for (int i = 0; i < jointCnNum; i++)
+            subtract(jointCn[i], etaFull[i], difEtaSrc[i]);
+
+        Mat1f eigenVec(1, jointCnNum);
+        computeEigenVector(difEtaSrc, cluster, eigenVec, num_pca_iterations_, initVec);
+
+        computeOrientation(difEtaSrc, eigenVec, difOreientation);
+        CV_DbgAssert(difOreientation.size() == srcSize);
+    }
+    else
+    {
+        subtract(jointCn[0], etaFull[0], difOreientation);
+    }
+
+    compare(difOreientation, 0, cluster_minus, CMP_LT);
+    bitwise_and(cluster_minus, cluster, cluster_minus);
+
+    compare(difOreientation, 0, cluster_plus, CMP_GE);
+    bitwise_and(cluster_plus, cluster, cluster_plus);
+}
+
+void AdaptiveManifoldFilterN::computeEta(Mat& teta, Mat1b& cluster, vector<Mat>& etaDst)
+{
+    CV_DbgAssert(teta.size() == srcSize && cluster.size() == srcSize);
+
+    Mat1f tetaMasked = Mat1f::zeros(srcSize);
+    teta.copyTo(tetaMasked, cluster);
+
+    float sigma_s = (float)(sigma_s_ / getResizeRatio());
+
+    Mat1f tetaMaskedBlur;
+    downsample(tetaMasked, tetaMaskedBlur);
+    h_filter(tetaMaskedBlur, tetaMaskedBlur, sigma_s);
+
+    Mat mul;
+    etaDst.resize(jointCnNum);
+    for (int i = 0; i < jointCnNum; i++)
+    {
+        multiply(tetaMasked, jointCn[i], mul);
+        downsample(mul, etaDst[i]);
+        h_filter(etaDst[i], etaDst[i], sigma_s);
+        divide(etaDst[i], tetaMaskedBlur, etaDst[i]);
+    }
+}
+
+void AdaptiveManifoldFilterN::computeEigenVector(const vector<Mat>& X, const Mat1b& mask, Mat1f& vecDst, int num_pca_iterations, const Mat1f& vecRand)
+{
+    int cnNum = (int)X.size();
+    int height = X[0].rows;
+    int width = X[0].cols;
+
+    vecDst.create(1, cnNum);
+    CV_Assert(vecRand.size() == Size(cnNum, 1) && vecDst.size() == Size(cnNum, 1));
+    CV_Assert(mask.rows == height && mask.cols == width);
+
+    const float *pVecRand = vecRand.ptr<float>();
+    Mat1d vecDstd(1, cnNum, 0.0);
+    double *pVecDst = vecDstd.ptr<double>();
+    Mat1f Xw(height, width);
+
+    for (int iter = 0; iter < num_pca_iterations; iter++)
+    {
+        for (int  i = 0; i < height; i++)
+        {
+            const uchar *maskRow = mask.ptr<uchar>(i);
+            float *mulRow = Xw.ptr<float>(i);
+
+            //first multiplication
+            for (int cn = 0; cn < cnNum; cn++)
+            {
+                const float *srcRow = X[cn].ptr<float>(i);
+                const float cnVal = pVecRand[cn];
+
+                if (cn == 0)
+                {
+                    for (int j = 0; j < width; j++)
+                        mulRow[j] = cnVal*srcRow[j];
+                }
+                else
+                {
+                    for (int j = 0; j < width; j++)
+                        mulRow[j] += cnVal*srcRow[j];
+                }
+            }
+
+            for (int j = 0; j < width; j++)
+                if (!maskRow[j]) mulRow[j] = 0.0f;
+
+            //second multiplication
+            for (int cn = 0; cn < cnNum; cn++)
+            {
+                float curCnSum = 0.0f;
+                const float *srcRow = X[cn].ptr<float>(i);
+
+                for (int j = 0; j < width; j++)
+                    curCnSum += mulRow[j]*srcRow[j];
+
+                //TODO: parallel reduce
+                pVecDst[cn] += curCnSum;
+            }
+        }
+    }
+
+    divide(vecDstd, norm(vecDstd), vecDst);
+}
+
+void AdaptiveManifoldFilterN::computeOrientation(const vector<Mat>& X, const Mat1f& vec, Mat1f& dst)
+{
+    int height = X[0].rows;
+    int width = X[0].cols;
+    int cnNum = (int)X.size();
+    dst.create(height, width);
+    CV_DbgAssert(vec.rows == 1 && vec.cols == cnNum);
+
+    const float *pVec = vec.ptr<float>();
+
+    for (int i = 0; i < height; i++)
+    {
+        float *dstRow = dst.ptr<float>(i);
+
+        for (int cn = 0; cn < cnNum; cn++)
+        {
+            const float *srcRow = X[cn].ptr<float>(i);
+            const float cnVal = pVec[cn];
+
+            if (cn == 0)
+            {
+                for (int j = 0; j < width; j++)
+                    dstRow[j] = cnVal*srcRow[j];
+            }
+            else
+            {
+                for (int j = 0; j < width; j++)
+                    dstRow[j] += cnVal*srcRow[j];
+            }
+        }
+    }
+}
+
+
+}
+
+
+namespace cv
+{
+namespace ximgproc
+{
+
+Ptr<AdaptiveManifoldFilter> AdaptiveManifoldFilter::create()
+{
+    return Ptr<AdaptiveManifoldFilter>(new AdaptiveManifoldFilterN());
+}
+
+Ptr<AdaptiveManifoldFilter> createAMFilter(double sigma_s, double sigma_r, bool adjust_outliers)
+{
+    Ptr<AdaptiveManifoldFilter> amf(new AdaptiveManifoldFilterN());
+
+    amf->setSigmaS(sigma_s);
+    amf->setSigmaR(sigma_r);
+    amf->setAdjustOutliers(adjust_outliers);
+
+    return amf;
+}
+
+void amFilter(InputArray joint, InputArray src, OutputArray dst, double sigma_s, double sigma_r, bool adjust_outliers)
+{
+    Ptr<AdaptiveManifoldFilter> amf = createAMFilter(sigma_s, sigma_r, adjust_outliers);
+    amf->filter(src, dst, joint);
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/advanced_types.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/advanced_types.hpp
new file mode 100644
index 00000000..3cc19d6e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/advanced_types.hpp
@@ -0,0 +1,91 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __ADVANCED_TYPES_HPP__
+#define __ADVANCED_TYPES_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+
+/********************* Defines *********************/
+
+#ifndef CV_SQR
+#  define CV_SQR(x)  ((x)*(x))
+#endif
+
+#ifndef CV_CUBE
+#  define CV_CUBE(x)  ((x)*(x)*(x))
+#endif
+
+#ifndef CV_INIT_VECTOR
+#  define CV_INIT_VECTOR(vname, type, ...) \
+    static const type vname##_a[] = __VA_ARGS__; \
+    std::vector <type> vname(vname##_a, \
+    vname##_a + sizeof(vname##_a) / sizeof(*vname##_a))
+#endif
+
+/********************* Types *********************/
+
+/*! fictitious type to highlight that function
+ *  can process n-channels arguments */
+typedef cv::Mat NChannelsMat;
+
+/********************* Functions *********************/
+
+namespace cv
+{
+namespace ximgproc
+{
+
+template <typename _Tp, typename _Tp2> inline
+    cv::Size_<_Tp> operator * (const _Tp2 &x, const cv::Size_<_Tp> &sz)
+{
+    return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(x*sz.width), cv::saturate_cast<_Tp>(x*sz.height));
+}
+
+template <typename _Tp, typename _Tp2> inline
+    cv::Size_<_Tp> operator / (const cv::Size_<_Tp> &sz, const _Tp2 &x)
+{
+    return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(sz.width/x), cv::saturate_cast<_Tp>(sz.height/x));
+}
+
+} // cv
+}
+#endif
+#endif /* __ADVANCED_TYPES_HPP__ */
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/anisodiff.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/anisodiff.cpp
new file mode 100644
index 00000000..996b4ac5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/anisodiff.cpp
@@ -0,0 +1,293 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/* the reference code has been contributed by Chris Sav */
+
+#include "precomp.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+#include "opencl_kernels_ximgproc.hpp"
+
+namespace cv {
+namespace ximgproc {
+
+#if CV_SIMD128
+inline void v_expand_s(const v_uint8x16& a, v_int16x8& b, v_int16x8& c)
+{
+    v_uint16x8 t0, t1;
+    v_expand(a, t0, t1);
+    b = v_reinterpret_as_s16(t0);
+    c = v_reinterpret_as_s16(t1);
+}
+
+inline void v_expand_f32(const v_int16x8& a, v_float32x4& b, v_float32x4& c)
+{
+    v_int32x4 t0, t1;
+    v_expand(a, t0, t1);
+    b = v_cvt_f32(t0);
+    c = v_cvt_f32(t1);
+}
+
+inline v_uint8x16 v_finalize_pix_ch(const v_int16x8& c0, const v_int16x8& c1,
+                                    const v_float32x4& s0, const v_float32x4& s1,
+                                    const v_float32x4& s2, const v_float32x4& s3,
+                                    const v_float32x4& alpha)
+{
+    v_float32x4 f0, f1, f2, f3;
+    v_expand_f32(c0, f0, f1);
+    v_expand_f32(c1, f2, f3);
+
+    v_int16x8 d0 = v_pack(v_round(s0*alpha + f0), v_round(s1*alpha + f1));
+    v_int16x8 d1 = v_pack(v_round(s2*alpha + f2), v_round(s3*alpha + f3));
+
+    return v_pack_u(d0, d1);
+}
+#endif
+
+class ADBody : public ParallelLoopBody
+{
+public:
+    ADBody(const Mat* src_, Mat* dst_, const float* exptab, float alpha)
+    {
+        src = src_;
+        dst = dst_;
+        exptab_ = exptab;
+        alpha_ = alpha;
+    }
+
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        const int cn = 3;
+        int cols = src->cols;
+        int step = (int)src->step;
+        int tab[] = { -cn, cn, -step-cn, -step, -step+cn, step-cn, step, step+cn };
+        float alpha = alpha_;
+        const float* exptab = exptab_;
+
+        for( int i = range.start; i < range.end; i++ )
+        {
+            const uchar* psrc0 = src->ptr<uchar>(i);
+            uchar* pdst = dst->ptr<uchar>(i);
+            int j = 0;
+
+#if CV_SIMD128
+            v_float32x4 v_alpha = v_setall_f32(alpha);
+            for( ; j <= cols - 16; j += 16 )
+            {
+                v_uint8x16 c0, c1, c2;
+                v_load_deinterleave(psrc0 + j*3, c0, c1, c2);
+                v_int16x8 c00, c01, c10, c11, c20, c21;
+
+                v_expand_s(c0, c00, c01);
+                v_expand_s(c1, c10, c11);
+                v_expand_s(c2, c20, c21);
+
+                v_float32x4 s00 = v_setzero_f32(), s01 = s00, s02 = s00, s03 = s00;
+                v_float32x4 s10 = v_setzero_f32(), s11 = s00, s12 = s00, s13 = s00;
+                v_float32x4 s20 = v_setzero_f32(), s21 = s00, s22 = s00, s23 = s00;
+                v_float32x4 fd0, fd1, fd2, fd3;
+
+                for( int k = 0; k < 8; k++ )
+                {
+                    const uchar* psrc1 = psrc0 + j*3 + tab[k];
+                    v_uint8x16 p0, p1, p2;
+                    v_int16x8 p00, p01, p10, p11, p20, p21;
+                    v_load_deinterleave(psrc1, p0, p1, p2);
+
+                    v_expand_s(p0, p00, p01);
+                    v_expand_s(p1, p10, p11);
+                    v_expand_s(p2, p20, p21);
+
+                    v_int16x8 d00 = p00 - c00, d01 = p01 - c01;
+                    v_int16x8 d10 = p10 - c10, d11 = p11 - c11;
+                    v_int16x8 d20 = p20 - c20, d21 = p21 - c21;
+
+                    v_uint16x8 n0 = v_abs(d00) + v_abs(d10) + v_abs(d20);
+                    v_uint16x8 n1 = v_abs(d01) + v_abs(d11) + v_abs(d21);
+
+                    ushort CV_DECL_ALIGNED(16) nbuf[16];
+                    v_store(nbuf, n0);
+                    v_store(nbuf + 8, n1);
+
+                    v_float32x4 w0(exptab[nbuf[0]], exptab[nbuf[1]], exptab[nbuf[2]], exptab[nbuf[3]]);
+                    v_float32x4 w1(exptab[nbuf[4]], exptab[nbuf[5]], exptab[nbuf[6]], exptab[nbuf[7]]);
+                    v_float32x4 w2(exptab[nbuf[8]], exptab[nbuf[9]], exptab[nbuf[10]], exptab[nbuf[11]]);
+                    v_float32x4 w3(exptab[nbuf[12]], exptab[nbuf[13]], exptab[nbuf[14]], exptab[nbuf[15]]);
+
+                    v_expand_f32(d00, fd0, fd1);
+                    v_expand_f32(d01, fd2, fd3);
+                    s00 += fd0*w0; s01 += fd1*w1; s02 += fd2*w2; s03 += fd3*w3;
+                    v_expand_f32(d10, fd0, fd1);
+                    v_expand_f32(d11, fd2, fd3);
+                    s10 += fd0*w0; s11 += fd1*w1; s12 += fd2*w2; s13 += fd3*w3;
+                    v_expand_f32(d20, fd0, fd1);
+                    v_expand_f32(d21, fd2, fd3);
+                    s20 += fd0*w0; s21 += fd1*w1; s22 += fd2*w2; s23 += fd3*w3;
+                }
+
+                c0 = v_finalize_pix_ch(c00, c01, s00, s01, s02, s03, v_alpha);
+                c1 = v_finalize_pix_ch(c10, c11, s10, s11, s12, s13, v_alpha);
+                c2 = v_finalize_pix_ch(c20, c21, s20, s21, s22, s23, v_alpha);
+                v_store_interleave(pdst + j*3, c0, c1, c2);
+            }
+            j *= 3;
+#endif
+
+            for( ; j < cols*cn; j += cn )
+            {
+                int c0  = psrc0[j], c1 = psrc0[j+1], c2 = psrc0[j+2];
+                float s0 = 0.f, s1 = 0.f, s2 = 0.f;
+                for( int k = 0; k < 8; k++ )
+                {
+                    const uchar* psrc1 = psrc0 + j + tab[k];
+                    int delta0 = psrc1[0] - c0;
+                    int delta1 = psrc1[1] - c1;
+                    int delta2 = psrc1[2] - c2;
+                    int nabla = std::abs(delta0) + std::abs(delta1) + std::abs(delta2);
+                    float w = exptab[nabla];
+                    s0 += delta0*w;
+                    s1 += delta1*w;
+                    s2 += delta2*w;
+                }
+                pdst[j] = saturate_cast<uchar>(c0 + alpha*s0);
+                pdst[j+1] = saturate_cast<uchar>(c1 + alpha*s1);
+                pdst[j+2] = saturate_cast<uchar>(c2 + alpha*s2);
+            }
+        }
+    }
+
+    const Mat* src;
+    Mat* dst;
+    const float* exptab_;
+    float alpha_;
+};
+
+#ifdef HAVE_OPENCL
+static bool ocl_anisotropicDiffusion(InputArray src_, OutputArray dst_,
+                                     float alpha, int niters,
+                                     const std::vector<float>& exptab)
+{
+    UMat src0 = src_.getUMat(), dst0 = dst_.getUMat();
+    int type = src0.type();
+    int rows = src0.rows, cols = src0.cols;
+
+    ocl::Kernel k("anisodiff", ocl::ximgproc::anisodiff_oclsrc, "");
+    if (k.empty())
+        return false;
+
+    UMat temp0x(rows + 2, cols + 2, type);
+    UMat temp1x(rows + 2, cols + 2, type);
+    UMat temp0(temp0x, Rect(1, 1, cols, rows));
+    UMat temp1(temp1x, Rect(1, 1, cols, rows));
+
+    int tabsz = (int)exptab.size();
+    UMat uexptab = Mat(1, tabsz, CV_32F, (void*)&exptab[0]).getUMat(ACCESS_READ);
+
+    for (int t = 0; t < niters; t++)
+    {
+        UMat src = temp0, dst = t == niters-1 ? dst0 : temp1;
+        copyMakeBorder(t == 0 ? src0 : src, temp0x, 1, 1, 1, 1, BORDER_REPLICATE);
+
+        k.args(ocl::KernelArg::ReadOnlyNoSize(src), ocl::KernelArg::WriteOnly(dst),
+               ocl::KernelArg::PtrReadOnly(uexptab), alpha);
+
+        size_t globalsize[] = { (size_t)cols, (size_t)rows };
+        if(!k.run(2, globalsize, NULL, true))
+            return false;
+
+        std::swap(temp0, temp1);
+        std::swap(temp0x, temp1x);
+    }
+    return true;
+}
+#endif
+
+void anisotropicDiffusion(InputArray src_, OutputArray dst_, float alpha, float K, int niters )
+{
+    if( niters == 0 )
+    {
+        src_.copyTo(dst_);
+        return;
+    }
+
+    int type = src_.type();
+    CV_Assert(src_.dims() == 2 && type == CV_8UC3);
+    CV_Assert(K != 0);
+    CV_Assert(alpha > 0);
+    CV_Assert(niters >= 0);
+
+    const int cn = 3;
+    float sigma = K * cn * 255.f;
+    float isigma2 = 1 / (sigma * sigma);
+    std::vector<float> exptab_(255*3);
+    float* exptab = &exptab_[0];
+
+    for( int k = 0; k < 255*3; k++ )
+        exptab[k] = std::exp(-k*k*isigma2);
+
+    dst_.create(src_.size(), type);
+
+    CV_OCL_RUN(dst_.isUMat(),
+               ocl_anisotropicDiffusion(src_, dst_, alpha, niters, exptab_));
+
+    Mat src0 = src_.getMat();
+    int rows = src0.rows, cols = src0.cols;
+
+    Mat dst0 = dst_.getMat();
+    Mat temp0x(rows + 2, cols + 2, type);
+    Mat temp1x(rows + 2, cols + 2, type);
+    Mat temp0(temp0x, Rect(1, 1, cols, rows));
+    Mat temp1(temp1x, Rect(1, 1, cols, rows));
+
+    for (int t = 0; t < niters; t++)
+    {
+        Mat src = temp0, dst = t == niters-1 ? dst0 : temp1;
+        copyMakeBorder(t == 0 ? src0 : src, temp0x, 1, 1, 1, 1, BORDER_REPLICATE);
+
+        ADBody body(&src, &dst, exptab, alpha);
+        parallel_for_(Range(0, rows), body, 8);
+
+        std::swap(temp0, temp1);
+        std::swap(temp0x, temp1x);
+    }
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/bilateral_texture_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/bilateral_texture_filter.cpp
new file mode 100644
index 00000000..2a37dc99
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/bilateral_texture_filter.cpp
@@ -0,0 +1,357 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include <opencv2/ximgproc.hpp>
+#include <vector>
+
+namespace cv
+{
+namespace ximgproc
+{
+  void compute_mRTV(const Mat& L, Mat& mRTV, int fr);
+  void compute_G(const Mat& B, const Mat& mRTV, Mat& G, Mat& alpha, int fr);
+  void joint_bilateral_filter(const Mat& img, const Mat& G, Mat& r_img, int fr2, double sigma_avg);
+  void joint_bilateral_filter3(const Mat& img, const Mat& G, Mat& r_img, int fr2, double sigma_avg);
+
+  void bilateralTextureFilter(InputArray src_, OutputArray dst_, int fr,
+                              int numIter, double sigmaAlpha, double sigmaAvg)
+  {
+    CV_Assert(!src_.empty());
+
+    Mat src = src_.getMat();
+    CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+
+    CV_Assert(fr > 0 && numIter > 0);
+
+    if (sigmaAlpha < 0)
+      sigmaAlpha = 5. * fr;
+    if (sigmaAvg < 0)
+      sigmaAvg = 0.05 * sqrt(static_cast<float>(src.channels()));
+
+    Mat I;
+    src.copyTo(I);
+    if (src.type() == CV_8UC1) {
+      I.convertTo(I, CV_32FC1, 1.0 / 255.0);
+    }
+    else if (src.type() == CV_8UC3) {
+      I.convertTo(I, CV_32FC3, 1.0 / 255.0);
+    }
+
+    for (int iter = 0; iter < numIter; iter++)
+    {
+      Mat B;
+      blur(I, B, Size(2 * fr + 1, 2 * fr + 1), Point(-1, -1), BORDER_REFLECT);
+
+      Mat mRTV;
+      compute_mRTV(I, mRTV, fr);
+
+      Mat G, minmRTV;
+      compute_G(B, mRTV, G, minmRTV, fr);
+
+      // alpha blending
+      Mat Gtilde;
+      Mat diff = mRTV - minmRTV;
+      Mat alpha = -diff.mul(sigmaAlpha);
+      exp(alpha, alpha);
+      alpha = alpha + 1.;
+      pow(alpha, -1, alpha);
+      alpha = (alpha - 0.5) * 2;
+      Mat alphainv = -(alpha - 1);
+
+      std::vector<Mat> Gi, Bi;
+      Gi.resize(I.channels());
+      Bi.resize(I.channels());
+      if (I.channels() == 3) {
+        split(G, &Gi[0]);
+        split(B, &Bi[0]);
+      }
+      else {
+        G.copyTo(Gi[0]);
+        B.copyTo(Bi[0]);
+      }
+
+      std::vector<Mat> Gtildei;
+      Gtildei.resize(I.channels());
+      for (int i = 0; i < B.channels(); i++)
+        Gtildei[i] = Gi[i].mul(alpha) + Bi[i].mul(alphainv);
+      merge(&Gtildei[0], B.channels(), Gtilde);
+
+      // joint bilateral filter
+      cv::Mat J;
+      if (I.channels() == 1)
+        joint_bilateral_filter(I, Gtilde, J, fr * 2, sigmaAvg);
+      else if (I.channels() == 3)
+        joint_bilateral_filter3(I, Gtilde, J, fr * 2, sigmaAvg);
+      I = J;
+    }
+    if (src.type() == CV_8UC1) {
+      I.convertTo(I, CV_8UC1, 255.0);
+    }
+    else if (src.type() == CV_8UC3) {
+      I.convertTo(I, CV_8UC3, 255.0);
+    }
+
+    I.copyTo(dst_);
+  }
+
+  void compute_mRTV(const Mat& L, Mat& mRTV, int fr)
+  {
+    mRTV = Mat::zeros(L.size(), CV_32FC1);
+
+    const float eps = 0.00001f;
+
+    // Calculate image derivative(gradient)
+    Mat G;
+    Mat Gx, Gy, kernelx, kernely;
+    kernelx = Mat::zeros(1, 3, CV_32F);
+    kernelx.at<float>(0, 1) = -1.0;
+    kernelx.at<float>(0, 2) = 1.0;
+    filter2D(L, Gx, -1, kernelx, Point(-1, -1), 0, BORDER_REFLECT);
+    kernely = Mat::zeros(3, 1, CV_32F);
+    kernely.at<float>(1, 0) = -1.0;
+    kernely.at<float>(2, 0) = 1.0;
+    filter2D(L, Gy, -1, kernely, Point(-1, -1), 0, BORDER_REFLECT);
+
+    Gx = Gx.mul(Gx);
+    Gy = Gy.mul(Gy);
+    sqrt(Gx + Gy, G);
+
+    // Pad image L and G
+    Mat padL;
+    Mat padG;
+    copyMakeBorder(L, padL, fr, fr, fr, fr, BORDER_REFLECT);
+    copyMakeBorder(G, padG, fr, fr, fr, fr, BORDER_REFLECT);
+
+    // Calculate maxL, minL, maxG, sumG
+    int pu = fr;
+    int pb = pu + L.rows;
+    int pl = fr;
+    int pr = pl + L.cols;
+
+    std::vector<Mat> Li, Gi;
+    Li.resize(L.channels());
+    Gi.resize(L.channels());
+    if (L.channels() == 3) {
+      split(padL, &Li[0]);
+      split(padG, &Gi[0]);
+    }
+    else {
+      padL.copyTo(Li[0]);
+      padG.copyTo(Gi[0]);
+    }
+
+    for (int i = 0; i < L.channels(); i++)
+    {
+      Mat maxL = Mat::zeros(L.size(), CV_32FC1);
+      Mat minL = Mat::ones(L.size(), CV_32FC1);
+      Mat maxG = Mat::zeros(L.size(), CV_32FC1);
+      Mat sumG = Mat::zeros(L.size(), CV_32FC1);
+      for (int y = -fr; y <= fr; y++)
+      {
+        for (int x = -fr; x <= fr; x++)
+        {
+          Mat temp = Li[i](
+            Range(pu + y, pb + y),
+            Range(pl + x, pr + x)
+          );
+          maxL = max(maxL, temp);
+          minL = min(minL, temp);
+
+          temp = Gi[i](
+            Range(pu + y, pb + y),
+            Range(pl + x, pr + x)
+          );
+          maxG = max(maxG, temp);
+          sumG = sumG + temp;
+        }
+      }
+      Mat deltai = maxL - minL;
+      sumG = max(sumG, eps);
+      Mat mRTVi = maxG / sumG * (2 * fr + 1);
+      mRTV = mRTV + mRTVi.mul(deltai);
+    }
+    if (L.channels() == 3)
+      mRTV = mRTV / 3;
+  }
+
+  void compute_G(const Mat& B, const Mat& mRTV, Mat& G, Mat& alpha, int fr)
+  {
+    B.copyTo(G);
+    alpha = Mat::ones(B.size(), CV_32FC1);
+    for (int y = -fr; y <= fr; y++)
+    {
+      for (int x = -fr; x <= fr; x++)
+      {
+        Point pb;
+        Point pt;
+        for (pb.y = 0; pb.y < B.rows; pb.y++)
+        {
+          for (pb.x = 0; pb.x < B.cols; pb.x++)
+          {
+            pt.x = min(max(pb.x + x, 0), B.cols - 1);
+            pt.y = min(max(pb.y + y, 0), B.rows - 1);
+            if (alpha.at<float>(pb) > mRTV.at<float>(pt))
+            {
+              alpha.at<float>(pb) = mRTV.at<float>(pt);
+              if (B.channels() == 3)
+                G.at<Vec3f>(pb) = B.at<Vec3f>(pt);
+              else if (B.channels() == 1)
+                G.at<float>(pb) = B.at<float>(pt);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  void joint_bilateral_filter(const Mat& img, const Mat& G, Mat& r_img, int fr2, double sigma_avg)
+  {
+    Mat p_G;
+    copyMakeBorder(G, p_G, fr2, fr2, fr2, fr2, BORDER_REFLECT);
+
+    Mat p_img;
+    copyMakeBorder(img, p_img, fr2, fr2, fr2, fr2, BORDER_REFLECT);
+
+    Mat SW;
+    if (SW.empty()) {
+      SW = Mat(2*fr2+1, 2*fr2+1, CV_32FC1);
+      int r, c;
+      float y, x;
+      for (r = 0, y = (float)-fr2; r < SW.rows; r++, y += 1.0) {
+        for(c = 0, x = (float)-fr2; c < SW.cols; c++, x += 1.0) {
+          SW.at<float>(r,c) = exp(-(x*x + y*y) / (2*fr2*fr2));
+        }
+      }
+    }
+
+    r_img = Mat::zeros(img.size(), CV_32FC1);
+    {
+      Mat sum_d_W = Mat::zeros(img.size(), CV_32FC1);
+      Mat d_W = Mat::zeros(G.size(), CV_32FC1);
+
+      for (int x = -fr2; x <= fr2; x++) {
+        for (int y = -fr2; y <= fr2; y++) {
+          d_W = p_G(Rect(fr2+x, fr2+y, img.cols, img.rows)) - G;
+          multiply(d_W, d_W, d_W);
+          exp(-0.5 * d_W / (sigma_avg*sigma_avg), d_W);
+
+          d_W = d_W * SW.at<float>(fr2+y, fr2+x); //Gaussian weight
+
+          sum_d_W = sum_d_W + d_W;
+          multiply(d_W, p_img(Rect(fr2+x, fr2+y, img.cols, img.rows)), d_W);
+          r_img = r_img + d_W;
+        }
+      }
+      max(1e-5f, sum_d_W, sum_d_W);
+      divide(r_img, sum_d_W, r_img);
+    }
+  }
+
+  void joint_bilateral_filter3(const Mat& img, const Mat& G, Mat& r_img, int fr2, double sigma_avg)
+  {
+    Mat p_G;
+    copyMakeBorder(G, p_G, fr2, fr2, fr2, fr2, BORDER_REFLECT);
+
+    Mat p_img;
+    copyMakeBorder(img, p_img, fr2, fr2, fr2, fr2, BORDER_REFLECT);
+
+    Mat SW;
+    if (SW.empty()) {
+      SW = Mat(2*fr2+1, 2*fr2+1, CV_32FC1);
+      int r, c;
+      float y, x;
+      for (r = 0, y = (float)-fr2; r < SW.rows; r++, y += 1.0) {
+        for(c = 0, x = (float)-fr2; c < SW.cols; c++, x += 1.0) {
+          SW.at<float>(r,c) = exp(-(x*x + y*y) / (2*fr2*fr2));
+        }
+      }
+    }
+
+    std::vector<Mat> G_channels(3);
+    split(G, G_channels);
+    std::vector<Mat> p_G_channels(3);
+    split(p_G, p_G_channels);
+    std::vector<Mat> p_img_channels(3);
+    split(p_img, p_img_channels);
+
+    Mat sum_d_W = Mat::zeros(img.size(), CV_32FC1);
+    std::vector<Mat> d_W_channels(3);
+    for (int ch = 0; ch < 3; ch++) {
+      d_W_channels[ch] = Mat::zeros(G.size(), CV_32FC1);
+    }
+    Mat d_W = Mat::zeros(G.size(), CV_32FC1);
+
+    std::vector<Mat> r_img_channels(3);
+    for (int ch = 0; ch < 3; ch++) {
+      r_img_channels[ch] = Mat::zeros(G.size(), CV_32FC1);
+    }
+
+    for (int x = -fr2; x <= fr2; x++) {
+      for (int y = -fr2; y <= fr2; y++) {
+        d_W.setTo(0);
+        for (int ch = 0; ch < 3; ch++) {
+          subtract(p_G_channels[ch](Rect(fr2+x, fr2+y, img.cols, img.rows)), G_channels[ch], d_W_channels[ch]);
+          multiply(d_W_channels[ch], d_W_channels[ch], d_W_channels[ch]);
+        }
+        for (int ch = 0; ch < 3; ch++) {
+          add(d_W, d_W_channels[ch], d_W);
+        }
+        exp(-0.5 * d_W / (sigma_avg*sigma_avg), d_W);
+
+        d_W = d_W * SW.at<float>(fr2+y, fr2+x); //Gaussian weight
+
+        add(sum_d_W, d_W, sum_d_W);
+
+        for (int ch = 0; ch < 3; ch++) {
+          Mat n_p_img = p_img_channels[ch](Rect(fr2+x, fr2+y, img.cols, img.rows));
+          accumulateProduct(d_W, n_p_img, r_img_channels[ch]);
+        }
+      }
+    }
+
+    max(1e-5f, sum_d_W, sum_d_W);
+    for (int ch = 0; ch < 3; ch++) {
+      divide(r_img_channels[ch], sum_d_W, r_img_channels[ch]);
+    }
+    merge(r_img_channels, r_img);
+  }
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/brightedges.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/brightedges.cpp
new file mode 100644
index 00000000..5daff1c2
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/brightedges.cpp
@@ -0,0 +1,222 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2017, IBM Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//      Marc Fiammante marc.fiammante@fr.ibm.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of OpenCV Foundation or contributors may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the OpenCV Foundation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#include "opencv2/ximgproc.hpp"
+#include "precomp.hpp"
+#include <iostream>
+#include <signal.h>
+namespace cv
+{
+    namespace ximgproc {
+        static bool isPixelMinimum(Mat &edge, int row, int col, int contrast) {
+            int count = 0;
+            int pixel = edge.ptr(row)[col] + contrast - 1; // minus 1 is needed for chessboard like images with contrast = 1
+                                                           // to get the vertical borders
+            int m2 = edge.ptr(row - 2)[col - 2];
+            int m1 = edge.ptr(row - 1)[col - 1];
+            int p1 = edge.ptr(row + 1)[col + 1];
+            int p2 = edge.ptr(row + 2)[col + 2];
+            if ((pixel <= m1) && (pixel <= p1) && (pixel < (m1 + m2) / 2) && (pixel < (p1 + p2) / 2)) count++; // Local minimum diagonal
+            m2 = edge.ptr(row - 2)[col];
+            m1 = edge.ptr(row - 1)[col];
+            p1 = edge.ptr(row + 1)[col];
+            p2 = edge.ptr(row + 2)[col];
+            if ((pixel <= m1) && (pixel <= p1) && (pixel < (m1 + m2) / 2) && (pixel < (p1 + p2) / 2)) count++; // Local minimum vertical
+            m2 = edge.ptr(row - 2)[col + 2];
+            m1 = edge.ptr(row - 1)[col + 1];
+            p1 = edge.ptr(row + 1)[col - 1];
+            p2 = edge.ptr(row + 2)[col - 2];
+            if ((pixel <= m1) && (pixel <= p1) && (pixel < (m1 + m2) / 2) && (pixel < (p1 + p2) / 2)) count++; // Local minimum other diagonal
+            m2 = edge.ptr(row)[col + 2];
+            m1 = edge.ptr(row)[col + 1];
+            p1 = edge.ptr(row)[col - 1];
+            p2 = edge.ptr(row)[col - 2];
+            if ((pixel <= m1) && (pixel <= p1) && (pixel < (m1 + m2) / 2) && (pixel < (p1 + p2) / 2)) count++; // Local minimum horizontal
+            if (count > 1) return true; // Avoid corners of black zones
+            return false;
+        }
+        static int correctPixel(Mat &iedge, int row, int col) {
+            // now check in there is a line around pixel to fill gaps
+            // Around Diagonal top left to bottom right
+            int weight = 4 * 255;
+            int lines = 0;
+            int line =
+                iedge.ptr(row - 1)[col - 2] +
+                iedge.ptr(row - 1)[col - 1] +
+                iedge.ptr(row)[col + 1] +
+                iedge.ptr(row)[col + 2];
+            if (line == 0) lines += 1;
+			// Around horizontal
+            line =
+                iedge.ptr(row)[col - 2] +
+                iedge.ptr(row)[col - 1] +
+                iedge.ptr(row + 1)[col + 1] +
+                iedge.ptr(row + 1)[col + 2];
+            if (line == 0) lines += 1;
+			// Around Diagonal top right to bottom left
+            line =
+                iedge.ptr(row - 2)[col] +
+                iedge.ptr(row - 1)[col] +
+                iedge.ptr(row + 1)[col + 1] +
+                iedge.ptr(row + 2)[col + 1];
+            if (line == 0) lines += 1;
+			// Around vertical
+            line =
+                iedge.ptr(row - 2)[col - 1] +
+                iedge.ptr(row - 1)[col - 1] +
+                iedge.ptr(row + 1)[col] +
+                iedge.ptr(row + 2)[col];
+            if (line == 0) lines += 1;
+            line =
+                iedge.ptr(row - 2)[col - 2] +
+                iedge.ptr(row - 1)[col - 2] +
+                iedge.ptr(row - 2)[col - 1] +
+                iedge.ptr(row - 1)[col - 1] +
+                iedge.ptr(row + 1)[col + 1] +
+                iedge.ptr(row + 1)[col + 2] +
+                iedge.ptr(row + 2)[col + 1] +
+                iedge.ptr(row + 2)[col + 2];
+            if (line < weight) lines += 1;
+            // Near vertical
+            line =
+                iedge.ptr(row - 2)[col] +
+                iedge.ptr(row - 1)[col] +
+                iedge.ptr(row - 2)[col - 1] +
+                iedge.ptr(row - 2)[col + 1] +
+                iedge.ptr(row + 1)[col] +
+                iedge.ptr(row + 2)[col] +
+                iedge.ptr(row + 2)[col + 1] +
+                iedge.ptr(row + 2)[col - 1];
+            if (line < weight) lines += 1;
+            // Near diagonal top right to bottom left
+            line =
+                iedge.ptr(row - 2)[col + 2] +
+                iedge.ptr(row - 1)[col + 1] +
+                iedge.ptr(row - 2)[col - 1] +
+                iedge.ptr(row - 1)[col + 2] +
+                iedge.ptr(row + 1)[col - 1] +
+                iedge.ptr(row + 2)[col - 2] +
+                iedge.ptr(row + 2)[col - 1] +
+                iedge.ptr(row + 1)[col - 2];
+            if (line < weight) lines += 1;
+            // Near horizontal
+            line =
+                iedge.ptr(row)[(col - 2)] +
+                iedge.ptr(row)[(col - 1)] +
+                iedge.ptr(row - 1)[(col - 2)] +
+                iedge.ptr(row + 1)[(col - 2)] +
+                iedge.ptr(row)[col + 1] +
+                iedge.ptr(row)[col + 2] +
+                iedge.ptr(row + 1)[col + 2] +
+                iedge.ptr(row - 1)[col + 2];
+            if (line < weight) lines += 1;
+            if (line == 1) return 0;
+            // Compute surrounding pixels for dark zone
+            int surround = iedge.ptr(row - 1)[col - 1] +
+                iedge.ptr(row - 1)[col] +
+                iedge.ptr(row - 1)[col + 1] +
+                iedge.ptr(row)[col - 1] +
+                iedge.ptr(row)[col + 1] +
+                iedge.ptr(row + 1)[col - 1] +
+                iedge.ptr(row + 1)[col] +
+                iedge.ptr(row + 1)[col + 1];
+            if (surround == 8 * 255) return 255;
+            if (surround == 0) return 255;
+            return iedge.ptr(row)[col];
+        }
+        static int contrastEdges(Mat &minput, Mat &mouput, int contrast) {
+            Mat mwork(minput.size(), minput.type(), Scalar(255));
+            // Now find if other pixels inside are minimum
+            for (int row = 2; row < minput.rows - 2; row++) {
+                for (int col = 2; col < minput.cols - 2; col++) {
+                    if (isPixelMinimum(minput, row, col, contrast)) {
+                        mwork.ptr(row)[col] = 0;
+                    }
+                    else {
+                        mwork.ptr(row)[col] = 255;
+                    }
+                }
+            }
+            // correct pixels
+            for (int row = 2; row < mwork.rows - 2; row++) {
+                for (int col = 2; col < mwork.cols - 2; col++) {
+                    mouput.ptr(row)[col] = (uchar)correctPixel(mwork, row, col);
+                }
+            }
+            // Set border of output matrix to white
+            for (int col = 0; col < mouput.cols; col++) {
+                for (int row = 0; row < 2; row++) {
+                    mouput.ptr(row)[col] = 255;
+                }
+                for (int row = mouput.rows - 2; row < mouput.rows; row++) {
+                    mouput.ptr(row)[col] = 255;
+                }
+            }
+            for (int row = 0; row < mouput.rows; row++) {
+                for (int col = 0; col < 2; col++) {
+                    mouput.ptr(row)[col] = 255;
+                }
+                for (int col = mouput.cols - 2; col < mouput.cols; col++) {
+                    mouput.ptr(row)[col] = 255;
+                }
+            }
+            return 0;
+        }
+        CV_EXPORTS_W  void BrightEdges(Mat &image, Mat &edge, int contrast, int shortrange, int longrange)
+        {
+            Mat gray, gblur, bblur, diff, cedge;
+            GaussianBlur(image, gblur, Size(shortrange, shortrange), 0);
+            blur(image, bblur, Size(longrange, longrange));
+            absdiff(gblur, bblur, diff);
+            cvtColor(diff, gray, COLOR_BGR2GRAY);
+            equalizeHist(gray, cedge);
+            if (contrast > 0) {
+                edge = Mat(cedge.size(), cedge.type());
+                contrastEdges(cedge, edge, contrast);
+            }
+            else {
+                edge = cedge;
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/deriche_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/deriche_filter.cpp
new file mode 100644
index 00000000..63500497
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/deriche_filter.cpp
@@ -0,0 +1,459 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+#include "precomp.hpp"
+#include <math.h>
+#include <vector>
+#include <iostream>
+
+/*
+If you use this code please cite this @cite deriche1987using
+Using Canny's criteria to derive a recursively implemented optimal edge detector  International journal of computer vision  (Volume:1 ,  Issue: 2 )  1987
+*/
+
+namespace cv {
+namespace ximgproc {
+template<typename T> static void
+VerticalIIRFilter(Mat &img,Mat &dst,const Range &r,double alpha,double omega)
+{
+    float                *f2;
+    int tailleSequence = (img.rows>img.cols) ? img.rows : img.cols;
+    Mat matG1(1, tailleSequence, CV_64FC1), matG2(1, tailleSequence, CV_64FC1);
+    double *g1 = matG1.ptr<double>(0), *g2 = (double*)matG2.ptr<double>(0);
+    double a2, a3;
+    double b1, b2;
+    int rows = img.rows, cols = img.cols;
+    double c = (1 - 2 * exp(-alpha)*cos(omega) + exp(-2 * alpha)) / (exp(-alpha)*sin(omega));
+
+    double a = -c * exp(-alpha)*sin(omega);
+    a2 = 1;// kp*exp(-alpha);
+    a3 = 1;//-kp*exp(-alpha);
+    b1 = -2 * exp(-alpha)*cos(omega);
+    b2 = exp(-2 * alpha);
+
+    for (int j = r.start; j<r.end; j++)
+    {
+        // Causal vertical  IIR filter
+        T *c1 = img.ptr<T>(0);
+        f2 = dst.ptr<float>(0);
+        f2 += j;
+        c1 += j;
+        int i = 0;
+        g1[i] = a2* *c1;
+        i++;
+        c1 += cols;
+        g1[i] =a2 * c1[-cols] - (b1)* g1[i - 1];
+        i++;
+        c1 += cols;
+        for (i = 2; i<rows; i++, c1 += cols)
+            g1[i] = a2 * c1[-cols] - b1*g1[i - 1] - b2 *g1[i - 2];
+        // Anticausal vertical IIR filter
+        c1 = img.ptr<T>(0);
+        c1 += (rows - 1)*cols + j;
+        i = rows - 1;
+        g2[i] = a3 * *c1;
+        i--;
+        c1 -= cols;
+        g2[i] = a3* c1[cols]  + (b1)*g2[i + 1];
+        i--;
+        c1 -= cols;
+        for (i = rows - 3; i >= 0; i--, c1 -= cols)
+            g2[i] = a3*c1[cols] -
+            b1*g2[i + 1] - b2*g2[i + 2];
+        for (i = 0; i<rows; i++, f2 += cols)
+            *f2 = static_cast<float>(a*(g1[i] - g2[i]));
+    }
+}
+
+template<typename T> static void
+HorizontalIIRFilter(Mat &img, Mat &dst, const Range &r, double alpha, double omega)
+{
+    float *f1;
+    int rows = img.rows, cols = img.cols;
+    int tailleSequence = (rows>cols) ? rows : cols;
+    Mat matG1(1, tailleSequence, CV_64FC1), matG2(1, tailleSequence, CV_64FC1);
+    double *g1 = (double*)matG1.ptr(0), *g2 = (double*)matG2.ptr(0);
+    double a,a2, a3;
+    double b1, b2;
+    double c = (1 - 2 * exp(-alpha)*cos(omega) + exp(-2 * alpha)) / (exp(-alpha)*sin(omega));
+
+    a = -c*exp(-alpha)*sin(omega);
+    a2 = 1;// kp*exp(-alpha);
+    a3 = 1;//-kp*exp(-alpha);
+    b1 = -2 * exp(-alpha)*cos(omega);
+    b2 = exp(-2 * alpha);
+
+    for (int i = r.start; i<r.end; i++)
+    {
+        f1 = dst.ptr<float>(i);
+        T *c1 = img.ptr<T>(i);
+        int j = 0;
+        g1[j] = a2* *c1;
+        j++;
+        c1++;
+        g1[j] = a2*c1[j - 1] - (b1)* g1[j - 1];
+        j++;
+        c1++;
+        for (j = 2; j<cols; j++, c1++)
+            g1[j] = a2 * c1[-1] - b1*g1[j - 1] - b2*g1[j - 2];
+        c1 = img.ptr<T>(0);
+        c1 += i*cols + cols - 1;
+        j = cols - 1;
+        g2[j] = a3* *c1;
+        j--;
+        c1--;
+        g2[j] = a3 * c1[1] - b1 * g2[j + 1];
+        j--;
+        c1--;
+        for (j = cols - 3; j >= 0; j--, c1--)
+            g2[j] = a3*c1[1] - b1*g2[j + 1] - b2*g2[j + 2];
+        for (j = 0; j<cols; j++, f1++)
+            *f1 = static_cast<float>(a*(g1[j] - g2[j]));
+    }
+}
+
+class ParallelGradientDericheYCols : public ParallelLoopBody
+{
+private:
+    Mat &img;
+    Mat &dst;
+    double alpha;
+    double omega;
+    bool verbose;
+
+
+public:
+    ParallelGradientDericheYCols(Mat &imgSrc, Mat &d, double ald,double o) :
+        img(imgSrc),
+        dst(d),
+        alpha(ald),
+        omega(o),
+        verbose(false)
+    {
+        int type = img.depth();
+        CV_CheckType(type, type == CV_8UC1 || type == CV_8SC1 || type == CV_16SC1 || type == CV_16UC1 || type == CV_32FC1, "Wrong input type for GradientDericheYCols");
+        type = dst.depth();
+        CV_CheckType(type, type==CV_32FC1, "Wrong output type for GradientDericheYCols");
+    }
+    void Verbose(bool b) { verbose = b; }
+    virtual void operator()(const Range& range) const CV_OVERRIDE
+    {
+        if (verbose)
+            std::cout << getThreadNum() << "# :Start from row " << range.start << " to " << range.end - 1 << " (" << range.end - range.start << " loops)" << std::endl;
+
+        switch (img.depth()) {
+        case CV_8U:
+            VerticalIIRFilter<uchar>(img,dst,range, alpha,omega);
+        break;
+        case CV_8S:
+            VerticalIIRFilter<char>(img, dst, range, alpha, omega);
+        break;
+        case CV_16U:
+            VerticalIIRFilter<ushort>(img, dst, range, alpha, omega);
+            break;
+        case CV_16S:
+            VerticalIIRFilter<short>(img, dst, range, alpha, omega);
+            break;
+        case CV_32F:
+            VerticalIIRFilter<float>(img, dst, range, alpha, omega);
+            break;
+        default:
+            return;
+        }
+    };
+    ParallelGradientDericheYCols& operator=(const ParallelGradientDericheYCols &) {
+        return *this;
+    };
+};
+
+
+class ParallelGradientDericheYRows : public ParallelLoopBody
+{
+private:
+    Mat &img;
+    Mat &dst;
+    double alpha;
+    double omega;
+    bool verbose;
+
+public:
+    ParallelGradientDericheYRows(Mat& imgSrc, Mat &d, double ald,double o) :
+        img(imgSrc),
+        dst(d),
+        alpha(ald),
+        omega(o),
+        verbose(false)
+    {
+        int type = img.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong input type for GradientDericheYRows");
+        type = dst.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong output type for GradientDericheYRows");
+    }
+    void Verbose(bool b) { verbose = b; }
+    virtual void operator()(const Range& range) const CV_OVERRIDE
+    {
+        if (verbose)
+            std::cout << getThreadNum() << "# :Start from row " << range.start << " to " << range.end - 1 << " (" << range.end - range.start << " loops)" << std::endl;
+        float *f1, *f2;
+        int tailleSequence = (img.rows>img.cols) ? img.rows : img.cols;
+        Mat matG1(1,tailleSequence,CV_64FC1), matG2(1,tailleSequence,CV_64FC1);
+        double *g1 = matG1.ptr<double>(0), *g2 = matG2.ptr<double>(0);
+        int cols = img.cols;
+
+
+        double a2po2 = (alpha*alpha + omega * omega);
+        double k = (1 - 2 * exp(-alpha)*cos(omega) + exp(-2 * alpha))*a2po2;
+        k = k / (2 * alpha*exp(-alpha)*sin(omega) + omega - omega * exp(-2 * alpha));
+        double c1 = k * alpha / a2po2;
+        double c2 = k * omega / a2po2;
+        double a0 = c2;
+        double a1 = (-c2 * cos(omega) + c1 * sin(omega))*exp(-alpha);
+        double b1 = -2 * exp(-alpha)*cos(omega);
+        double b2 = exp(-2 * alpha);
+        double a2 = a1 - c2 * b1, a3 = -c2 * b2;
+
+        for (int i = range.start; i<range.end; i++)
+        {
+            f2 = dst.ptr<float>(i);
+            f1 = img.ptr<float>(i);
+            int j = 0;
+            g1[j] = (a0 + a1)* *f1;
+            j++;
+            f1++;
+            g1[j] = a0 * f1[0] + a1*f1[j - 1] - b1* g1[j - 1];
+            j++;
+            f1++;
+            for (j = 2; j<cols; j++, f1++)
+                g1[j] = a0 * f1[0] + a1 * f1[-1] - b1*g1[j - 1] - b2*g1[j - 2];
+            f1 = ((float*)img.ptr(0));
+            f1 += i*cols + cols - 1;
+            j = cols - 1;
+            g2[j] = (a2 + a3)* *f1;
+            j--;
+            f1--;
+            g2[j] = (a2 + a3) * f1[1] - b2* g2[j + 1];
+            j--;
+            f1--;
+            for (j = cols - 3; j >= 0; j--, f1--)
+                g2[j] = a2*f1[1] + a3*f1[2] - b1*g2[j + 1] - b2*g2[j + 2];
+            for (j = 0; j<cols; j++, f2++)
+                *f2 = (float)(g1[j] + g2[j]);
+        }
+
+    };
+    ParallelGradientDericheYRows& operator=(const ParallelGradientDericheYRows &) {
+        return *this;
+    };
+};
+
+
+class ParallelGradientDericheXCols : public ParallelLoopBody
+{
+private:
+    Mat &img;
+    Mat &dst;
+    double alpha;
+    double omega;
+    bool verbose;
+
+public:
+    ParallelGradientDericheXCols(Mat& imgSrc, Mat &d, double alm,double o) :
+        img(imgSrc),
+        dst(d),
+        alpha(alm),
+        omega(o),
+        verbose(false)
+    {
+        int type = img.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong input type for GradientDericheXCols");
+        type = dst.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong output type for GradientDericheXCols");
+    }
+    void Verbose(bool b) { verbose = b; }
+    virtual void operator()(const Range& range) const CV_OVERRIDE
+    {
+        if (verbose)
+            std::cout << getThreadNum() << "# :Start from row " << range.start << " to " << range.end - 1 << " (" << range.end - range.start << " loops)" << std::endl;
+        float                *f1, *f2;
+        int rows = img.rows, cols = img.cols;
+
+        int tailleSequence = (rows>cols) ? rows : cols;
+        Mat matG1(1,tailleSequence,CV_64FC1), matG2(1,tailleSequence,CV_64FC1);
+        double *g1 = (double*)matG1.ptr(0), *g2 = (double*)matG2.ptr(0);
+        double a2po2 = (alpha*alpha + omega * omega);
+        double k = (1 - 2 * exp(-alpha)*cos(omega) + exp(-2 * alpha))*a2po2;
+        k = k / (2 * alpha*exp(-alpha)*sin(omega) + omega - omega * exp(-2 * alpha));
+        double c1 = k * alpha / a2po2;
+        double c2 = k * omega / a2po2;
+        double a0 = c2;
+        double a1 = (-c2 * cos(omega) + c1 * sin(omega))*exp(-alpha);
+        double b1 = -2 * exp(-alpha)*cos(omega);
+        double b2=exp(-2*alpha);
+        double a2=a1-c2*b1, a3=-c2*b2;
+
+
+        for (int j = range.start; j<range.end; j++)
+        {
+            f1 = img.ptr<float>(0);
+            f1 += j;
+            int i = 0;
+            g1[i] = (a0 + a1)* *f1;
+            i++;
+            f1 += cols;
+            g1[i] = a0 * *f1 + a1 * f1[-cols] - (b1)* g1[i - 1];
+            i++;
+            f1 += cols;
+            for (i = 2; i<rows; i++, f1 += cols)
+                g1[i] = a0 * *f1 + a1 * f1[-cols] - b1*g1[i - 1] - b2 *g1[i - 2];
+            f1 = img.ptr<float>(0);
+            f1 += (rows - 1)*cols + j;
+            i = rows - 1;
+            g2[i] = (a2 + a3)* *f1;
+            i--;
+            f1 -= cols;
+            g2[i] = (a2 + a3)* f1[cols] - b2*g2[i + 1];
+            i--;
+            f1 -= cols;
+            for (i = rows - 3; i >= 0; i--, f1 -= cols)
+                g2[i] = a2*f1[cols] + a3* f1[2 * cols] -
+                b1*g2[i + 1] - b2*g2[i + 2];
+            for (i = 0; i<rows; i++, f2 += cols)
+            {
+                f2 = (dst.ptr<float>(i)) + (j*img.channels());
+                *f2 = (float)(g1[i] + g2[i]);
+            }
+        }
+    };
+    ParallelGradientDericheXCols& operator=(const ParallelGradientDericheXCols &) {
+        return *this;
+    };
+};
+
+
+class ParallelGradientDericheXRows : public ParallelLoopBody
+{
+private:
+    Mat &img;
+    Mat &dst;
+    double alpha;
+    double omega;
+    bool verbose;
+
+public:
+    ParallelGradientDericheXRows(Mat& imgSrc, Mat &d, double ald, double o) :
+        img(imgSrc),
+        dst(d),
+        alpha(ald),
+        omega(o),
+        verbose(false)
+    {
+        int type = img.depth();
+        CV_CheckType(type, type == CV_8UC1 || type == CV_8SC1 || type == CV_16SC1 || type == CV_16UC1 || type == CV_32FC1, "Wrong input type for GradientDericheXRows");
+        type = dst.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong output type for GradientDericheXRows");
+    }
+    void Verbose(bool b) { verbose = b; }
+    virtual void operator()(const Range& range) const CV_OVERRIDE
+    {
+        if (verbose)
+            std::cout << getThreadNum() << "# :Start from row " << range.start << " to " << range.end - 1 << " (" << range.end - range.start << " loops)" << std::endl;
+
+        switch (img.depth()) {
+        case CV_8U:
+            HorizontalIIRFilter<uchar>(img,dst,range, alpha,omega);
+            break;
+        case CV_8S:
+            HorizontalIIRFilter<char>(img, dst, range, alpha, omega);
+            break;
+        case CV_16U:
+            HorizontalIIRFilter<ushort>(img, dst, range, alpha, omega);
+            break;
+        case CV_16S:
+            HorizontalIIRFilter<short>(img, dst, range, alpha, omega);
+            break;
+        case CV_32F:
+            HorizontalIIRFilter<float>(img, dst, range, alpha, omega);
+            break;
+        default:
+            return;
+        }
+    };
+    ParallelGradientDericheXRows& operator=(const ParallelGradientDericheXRows &) {
+        return *this;
+    };
+};
+
+void GradientDericheY(InputArray _op, OutputArray _dst,double alphaDerive, double omega)
+{
+    std::vector<Mat> planSrc;
+    split(_op, planSrc);
+
+    std::vector<Mat> planTmp;
+    std::vector<Mat> planDst;
+    for (size_t i = 0; i < planSrc.size(); i++)
+    {
+        planTmp.push_back(Mat(_op.size(), CV_32FC1));
+        planDst.push_back(Mat(_op.size(), CV_32FC1));
+        CV_Assert(planSrc[i].isContinuous() && planTmp[i].isContinuous() && planDst[i].isContinuous());
+        ParallelGradientDericheYCols x(planSrc[i], planTmp[i], alphaDerive,omega);
+        parallel_for_(Range(0, planSrc[i].cols), x, getNumThreads());
+        ParallelGradientDericheYRows xr(planTmp[i], planDst[i], alphaDerive, omega);
+        parallel_for_(Range(0, planTmp[i].rows), xr, getNumThreads());
+    }
+    merge(planDst, _dst);
+}
+
+void GradientDericheX(InputArray _op, OutputArray _dst, double alpha, double omega)
+{
+    std::vector<Mat> planSrc;
+    split(_op, planSrc);
+    std::vector<Mat> planTmp;
+    std::vector<Mat> planDst;
+    for (size_t i = 0; i < planSrc.size(); i++)
+    {
+        planTmp.push_back(Mat(_op.size(), CV_32FC1));
+        planDst.push_back(Mat(_op.size(), CV_32FC1));
+        CV_Assert(planSrc[i].isContinuous() && planTmp[i].isContinuous() && planDst[i].isContinuous());
+
+        ParallelGradientDericheXRows x(planSrc[i], planTmp[i], alpha, omega);
+        parallel_for_(Range(0, planSrc[i].rows), x, getNumThreads());
+        ParallelGradientDericheXCols xr(planTmp[i], planDst[i], alpha, omega);
+        parallel_for_(Range(0, planTmp[i].cols), xr, getNumThreads());
+    }
+    merge(planDst, _dst);
+}
+
+} //end of cv::ximgproc
+} //end of cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/disparity_filters.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/disparity_filters.cpp
new file mode 100644
index 00000000..03a2691d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/disparity_filters.cpp
@@ -0,0 +1,571 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include "opencv2/ximgproc/disparity_filter.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include <math.h>
+#include <vector>
+
+namespace cv {
+namespace ximgproc {
+
+using std::vector;
+#define EPS 1e-43f
+
+class DisparityWLSFilterImpl : public DisparityWLSFilter
+{
+protected:
+    int left_offset, right_offset, top_offset, bottom_offset;
+    Rect valid_disp_ROI;
+    Rect right_view_valid_disp_ROI;
+    int min_disp;
+    bool use_confidence;
+    Mat confidence_map;
+
+    double lambda,sigma_color;
+    int LRC_thresh,depth_discontinuity_radius;
+    float depth_discontinuity_roll_off_factor;
+    float resize_factor;
+    int num_stripes;
+
+    void init(double _lambda, double _sigma_color, bool _use_confidence, int l_offs, int r_offs, int t_offs, int b_offs, int _min_disp);
+    void computeDepthDiscontinuityMaps(Mat& left_disp, Mat& right_disp, Mat& left_dst, Mat& right_dst);
+    void computeConfidenceMap(InputArray left_disp, InputArray right_disp);
+
+protected:
+    struct ComputeDiscontinuityAwareLRC_ParBody : public ParallelLoopBody
+    {
+        DisparityWLSFilterImpl* wls;
+        Mat *left_disp, *right_disp;
+        Mat *left_disc, *right_disc, *dst;
+        Rect left_ROI, right_ROI;
+        int nstripes, stripe_sz;
+
+        ComputeDiscontinuityAwareLRC_ParBody(DisparityWLSFilterImpl& _wls, Mat& _left_disp, Mat& _right_disp, Mat& _left_disc, Mat& _right_disc, Mat& _dst, Rect _left_ROI, Rect _right_ROI, int _nstripes);
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    struct ComputeDepthDisc_ParBody : public ParallelLoopBody
+    {
+        DisparityWLSFilterImpl* wls;
+        Mat *disp,*disp_squares,*dst;
+        int nstripes, stripe_sz;
+
+        ComputeDepthDisc_ParBody(DisparityWLSFilterImpl& _wls, Mat& _disp, Mat& _disp_squares, Mat& _dst, int _nstripes);
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    typedef void (DisparityWLSFilterImpl::*MatOp)(Mat& src, Mat& dst);
+
+    struct ParallelMatOp_ParBody : public ParallelLoopBody
+    {
+        DisparityWLSFilterImpl* wls;
+        vector<MatOp> ops;
+        vector<Mat*> src;
+        vector<Mat*> dst;
+
+        ParallelMatOp_ParBody(DisparityWLSFilterImpl& _wls, vector<MatOp> _ops, vector<Mat*>& _src, vector<Mat*>& _dst);
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    void boxFilterOp(Mat& src,Mat& dst)
+    {
+        int rad = depth_discontinuity_radius;
+        boxFilter(src,dst,CV_32F,Size(2*rad+1,2*rad+1),Point(-1,-1));
+    }
+
+    void sqrBoxFilterOp(Mat& src,Mat& dst)
+    {
+        int rad = depth_discontinuity_radius;
+        sqrBoxFilter(src,dst,CV_32F,Size(2*rad+1,2*rad+1),Point(-1,-1));
+    }
+
+    void copyToOp(Mat& src,Mat& dst)
+    {
+        src.copyTo(dst);
+    }
+
+public:
+    static Ptr<DisparityWLSFilterImpl> create(bool _use_confidence, int l_offs, int r_offs, int t_offs, int b_offs, int min_disp);
+    void filter(InputArray disparity_map_left, InputArray left_view, OutputArray filtered_disparity_map, InputArray disparity_map_right, Rect ROI, InputArray) CV_OVERRIDE;
+    void filter_(InputArray disparity_map_left, InputArray left_view, OutputArray filtered_disparity_map, InputArray disparity_map_right, Rect ROI);
+
+    double getLambda() CV_OVERRIDE { return lambda; }
+    void setLambda(double _lambda) CV_OVERRIDE { lambda = _lambda; }
+
+    double getSigmaColor() CV_OVERRIDE { return sigma_color; }
+    void setSigmaColor(double _sigma_color) CV_OVERRIDE { sigma_color = _sigma_color; }
+
+    int getLRCthresh() CV_OVERRIDE { return LRC_thresh; }
+    void setLRCthresh(int _LRC_thresh) CV_OVERRIDE { LRC_thresh = _LRC_thresh; }
+
+    int getDepthDiscontinuityRadius() CV_OVERRIDE { return depth_discontinuity_radius; }
+    void setDepthDiscontinuityRadius(int _disc_radius) CV_OVERRIDE { depth_discontinuity_radius = _disc_radius; }
+
+    Mat getConfidenceMap() CV_OVERRIDE { return confidence_map; }
+    Rect getROI() CV_OVERRIDE { return valid_disp_ROI; }
+};
+
+void DisparityWLSFilterImpl::init(double _lambda, double _sigma_color, bool _use_confidence,  int l_offs, int r_offs, int t_offs, int b_offs, int _min_disp)
+{
+    left_offset = l_offs; right_offset  = r_offs;
+    top_offset  = t_offs; bottom_offset = b_offs;
+    min_disp = _min_disp;
+    valid_disp_ROI = Rect();
+    right_view_valid_disp_ROI = Rect();
+    min_disp=0;
+    lambda = _lambda;
+    sigma_color = _sigma_color;
+    use_confidence = _use_confidence;
+    confidence_map = Mat();
+    LRC_thresh = 24;
+    depth_discontinuity_radius = 5;
+    depth_discontinuity_roll_off_factor = 0.001f;
+    resize_factor = 1.0;
+    num_stripes = getNumThreads();
+}
+
+void DisparityWLSFilterImpl::computeDepthDiscontinuityMaps(Mat& left_disp, Mat& right_disp, Mat& left_dst, Mat& right_dst)
+{
+    Mat left_disp_ROI (left_disp, valid_disp_ROI);
+    Mat right_disp_ROI(right_disp,right_view_valid_disp_ROI);
+    Mat ldisp,rdisp,ldisp_squared,rdisp_squared;
+
+    {
+        vector<Mat*> _src; _src.push_back(&left_disp_ROI);_src.push_back(&right_disp_ROI);
+                           _src.push_back(&left_disp_ROI);_src.push_back(&right_disp_ROI);
+        vector<Mat*> _dst; _dst.push_back(&ldisp);        _dst.push_back(&rdisp);
+                           _dst.push_back(&ldisp_squared);_dst.push_back(&rdisp_squared);
+        vector<MatOp> _ops; _ops.push_back(&DisparityWLSFilterImpl::copyToOp); _ops.push_back(&DisparityWLSFilterImpl::copyToOp);
+                            _ops.push_back(&DisparityWLSFilterImpl::copyToOp); _ops.push_back(&DisparityWLSFilterImpl::copyToOp);
+        parallel_for_(Range(0,4),ParallelMatOp_ParBody(*this,_ops,_src,_dst));
+    }
+
+    {
+        vector<Mat*> _src; _src.push_back(&ldisp);        _src.push_back(&rdisp);
+                           _src.push_back(&ldisp_squared);_src.push_back(&rdisp_squared);
+        vector<Mat*> _dst; _dst.push_back(&ldisp);        _dst.push_back(&rdisp);
+                           _dst.push_back(&ldisp_squared);_dst.push_back(&rdisp_squared);
+        vector<MatOp> _ops; _ops.push_back(&DisparityWLSFilterImpl::boxFilterOp);   _ops.push_back(&DisparityWLSFilterImpl::boxFilterOp);
+                            _ops.push_back(&DisparityWLSFilterImpl::sqrBoxFilterOp);_ops.push_back(&DisparityWLSFilterImpl::sqrBoxFilterOp);
+        parallel_for_(Range(0,4),ParallelMatOp_ParBody(*this,_ops,_src,_dst));
+    }
+
+    left_dst  = Mat::zeros(left_disp.rows,left_disp.cols,CV_32F);
+    right_dst = Mat::zeros(right_disp.rows,right_disp.cols,CV_32F);
+    Mat left_dst_ROI (left_dst,valid_disp_ROI);
+    Mat right_dst_ROI(right_dst,right_view_valid_disp_ROI);
+
+    parallel_for_(Range(0,num_stripes),ComputeDepthDisc_ParBody(*this,ldisp,ldisp_squared,left_dst_ROI ,num_stripes));
+    parallel_for_(Range(0,num_stripes),ComputeDepthDisc_ParBody(*this,rdisp,rdisp_squared,right_dst_ROI,num_stripes));
+}
+
+
+void DisparityWLSFilterImpl::computeConfidenceMap(InputArray left_disp, InputArray right_disp)
+{
+    Mat ldisp = left_disp.getMat();
+    Mat rdisp = right_disp.getMat();
+    Mat depth_discontinuity_map_left,depth_discontinuity_map_right;
+    right_view_valid_disp_ROI = Rect(ldisp.cols-(valid_disp_ROI.x+valid_disp_ROI.width),valid_disp_ROI.y,
+                                     valid_disp_ROI.width,valid_disp_ROI.height);
+    computeDepthDiscontinuityMaps(ldisp,rdisp,depth_discontinuity_map_left,depth_discontinuity_map_right);
+
+    confidence_map = depth_discontinuity_map_left;
+
+    parallel_for_(Range(0,num_stripes),ComputeDiscontinuityAwareLRC_ParBody(*this,ldisp,rdisp, depth_discontinuity_map_left,depth_discontinuity_map_right,confidence_map,valid_disp_ROI,right_view_valid_disp_ROI,num_stripes));
+    confidence_map = 255.0f*confidence_map;
+}
+
+Ptr<DisparityWLSFilterImpl> DisparityWLSFilterImpl::create(bool _use_confidence, int l_offs=0, int r_offs=0, int t_offs=0, int b_offs=0, int min_disp=0)
+{
+    DisparityWLSFilterImpl *wls = new DisparityWLSFilterImpl();
+    wls->init(8000.0,1.0,_use_confidence,l_offs, r_offs, t_offs, b_offs, min_disp);
+    return Ptr<DisparityWLSFilterImpl>(wls);
+}
+
+void DisparityWLSFilterImpl::filter(InputArray disparity_map_left, InputArray left_view, OutputArray filtered_disparity_map, InputArray disparity_map_right, Rect ROI, InputArray)
+{
+    CV_Assert(!disparity_map_left.empty() && (disparity_map_left.channels() == 1));
+    CV_Assert(!left_view.empty() && (left_view.depth() == CV_8U) && (left_view.channels() == 3 || left_view.channels() == 1));
+    Mat left, right, filt_disp;
+
+    if (disparity_map_left.depth() != CV_32F)
+    {
+        disparity_map_left.getMat().convertTo(left, CV_32F);
+    }
+    else
+    {
+        left = disparity_map_left.getMat();
+        filt_disp = filtered_disparity_map.getMat();
+    }
+
+    if (!disparity_map_right.empty() && use_confidence)
+    {
+        if(disparity_map_right.depth() != CV_32F)
+            disparity_map_right.getMat().convertTo(right, CV_32F);
+        else
+            right = disparity_map_right.getMat();
+    }
+
+    filter_(left, left_view, filt_disp, right, ROI);
+    if (disparity_map_left.depth() != CV_32F){
+        filt_disp.convertTo(filtered_disparity_map, disparity_map_left.depth());
+    } else {
+        filt_disp.copyTo(filtered_disparity_map);
+    }
+}
+
+void DisparityWLSFilterImpl::filter_(InputArray disparity_map_left, InputArray left_view, OutputArray filtered_disparity_map, InputArray disparity_map_right, Rect ROI)
+{
+    CV_Assert( !disparity_map_left.empty()
+               && ( disparity_map_left.depth() == CV_32F)
+               && (disparity_map_left.channels() == 1) );
+    CV_Assert( !left_view.empty()
+               && (left_view.depth() == CV_8U)
+               && (left_view.channels() == 3 || left_view.channels() == 1) );
+
+    Mat disp,src,dst;
+    if(disparity_map_left.size()!=left_view.size())
+        resize_factor = disparity_map_left.cols()/(float)left_view.cols();
+    else
+        resize_factor = 1.0;
+    if(!ROI.empty()) /* user provided a ROI */
+        valid_disp_ROI = ROI;
+    else
+        valid_disp_ROI = Rect(left_offset,top_offset,
+                              disparity_map_left.cols()-left_offset-right_offset,
+                              disparity_map_left.rows()-top_offset-bottom_offset);
+
+    if(!use_confidence)
+    {
+        Mat disp_full_size = disparity_map_left.getMat();
+        Mat src_full_size = left_view.getMat();
+        if(disp_full_size.size!=src_full_size.size)
+        {
+            float x_ratio = src_full_size.cols/(float)disp_full_size.cols;
+            float y_ratio = src_full_size.rows/(float)disp_full_size.rows;
+            resize(disp_full_size,disp_full_size,src_full_size.size());
+            disp_full_size = disp_full_size*x_ratio;
+            ROI = Rect((int)(valid_disp_ROI.x*x_ratio),    (int)(valid_disp_ROI.y*y_ratio),
+                       (int)(valid_disp_ROI.width*x_ratio),(int)(valid_disp_ROI.height*y_ratio));
+        }
+        else
+            ROI = valid_disp_ROI;
+
+        disp = Mat(disp_full_size,ROI);
+        src  = Mat(src_full_size ,ROI);
+        filtered_disparity_map.create(disp_full_size.size(), disp_full_size.type());
+        Mat& dst_full_size = filtered_disparity_map.getMatRef();
+        dst_full_size = Scalar(16*(min_disp-1));
+        dst = Mat(dst_full_size,ROI);
+        Mat filtered_disp;
+        fastGlobalSmootherFilter(src,disp,filtered_disp,lambda,sigma_color);
+        filtered_disp.copyTo(dst);
+    }
+    else
+    {
+        CV_Assert( !disparity_map_right.empty()
+                   && (disparity_map_right.depth() == CV_32F)
+                   && (disparity_map_right.channels() == 1) );
+        CV_Assert( (disparity_map_left.cols() == disparity_map_right.cols()) );
+        CV_Assert( (disparity_map_left.rows() == disparity_map_right.rows()) );
+        computeConfidenceMap(disparity_map_left,disparity_map_right);
+        Mat disp_full_size = disparity_map_left.getMat();
+        Mat src_full_size = left_view.getMat();
+        if(disp_full_size.size!=src_full_size.size){
+            float x_ratio = src_full_size.cols/(float)disp_full_size.cols;
+            float y_ratio = src_full_size.rows/(float)disp_full_size.rows;
+            resize(disp_full_size,disp_full_size,src_full_size.size());
+            disp_full_size = disp_full_size*x_ratio;
+            resize(confidence_map,confidence_map,src_full_size.size());
+            ROI = Rect((int)(valid_disp_ROI.x*x_ratio),    (int)(valid_disp_ROI.y*y_ratio),
+                       (int)(valid_disp_ROI.width*x_ratio),(int)(valid_disp_ROI.height*y_ratio));
+        } else {
+            ROI = valid_disp_ROI;
+        }
+        disp = Mat(disp_full_size,ROI);
+        src  = Mat(src_full_size ,ROI);
+        filtered_disparity_map.create(disp_full_size.size(), disp_full_size.type());
+        Mat& dst_full_size = filtered_disparity_map.getMatRef();
+        dst_full_size = Scalar(16*(min_disp-1));
+        dst = Mat(dst_full_size,ROI);
+        Mat conf(confidence_map,ROI);
+
+        Mat disp_mul_conf;
+        disp_mul_conf = conf.mul(disp);
+        Mat conf_filtered;
+        Ptr<FastGlobalSmootherFilter> wls = createFastGlobalSmootherFilter(src,lambda,sigma_color);
+        wls->filter(disp_mul_conf,disp_mul_conf);
+        wls->filter(conf,conf_filtered);
+        dst = disp_mul_conf.mul(1/(conf_filtered+EPS));
+    }
+}
+
+DisparityWLSFilterImpl::ComputeDiscontinuityAwareLRC_ParBody::ComputeDiscontinuityAwareLRC_ParBody(DisparityWLSFilterImpl& _wls, Mat& _left_disp, Mat& _right_disp, Mat& _left_disc, Mat& _right_disc, Mat& _dst, Rect _left_ROI, Rect _right_ROI, int _nstripes):
+wls(&_wls),left_disp(&_left_disp),right_disp(&_right_disp),left_disc(&_left_disc),right_disc(&_right_disc),dst(&_dst),left_ROI(_left_ROI),right_ROI(_right_ROI),nstripes(_nstripes)
+{
+    stripe_sz = (int)ceil(left_disp->rows/(double)nstripes);
+}
+
+void DisparityWLSFilterImpl::ComputeDiscontinuityAwareLRC_ParBody::operator() (const Range& range) const
+{
+    float* row_left;
+    float* row_left_conf;
+    float* row_right;
+    float* row_right_conf;
+    float* row_dst;
+    int right_idx;
+    int h = left_disp->rows;
+
+    int start = std::min(range.start * stripe_sz, h);
+    int end   = std::min(range.end   * stripe_sz, h);
+    int thresh = (int)(wls->resize_factor*wls->LRC_thresh);
+    for(int i=start;i<end;i++)
+    {
+        row_left  = (float*)left_disp->ptr(i);
+        row_left_conf  = (float*)left_disc->ptr(i);
+        row_right = (float*)right_disp->ptr(i);
+        row_right_conf  = (float*)right_disc->ptr(i);
+        row_dst   = (float*)dst->ptr(i);
+        int j_start = left_ROI.x;
+        int j_end = left_ROI.x+left_ROI.width;
+        int right_end = right_ROI.x+right_ROI.width;
+        for(int j=j_start;j<j_end;j++)
+        {
+            right_idx = j-(((int)row_left[j])>>4);
+            if( right_idx>=right_ROI.x && right_idx<right_end)
+            {
+                if(abs(row_left[j] + row_right[right_idx])< thresh)
+                    row_dst[j] = min(row_left_conf[j],row_right_conf[right_idx]);
+                else
+                    row_dst[j] = 0.0f;
+            }
+        }
+    }
+}
+
+DisparityWLSFilterImpl::ComputeDepthDisc_ParBody::ComputeDepthDisc_ParBody(DisparityWLSFilterImpl& _wls, Mat& _disp, Mat& _disp_squares, Mat& _dst, int _nstripes):
+wls(&_wls),disp(&_disp),disp_squares(&_disp_squares),dst(&_dst),nstripes(_nstripes)
+{
+    stripe_sz = (int)ceil(disp->rows/(double)nstripes);
+}
+
+void DisparityWLSFilterImpl::ComputeDepthDisc_ParBody::operator() (const Range& range) const
+{
+    float* row_disp;
+    float* row_disp_squares;
+    float* row_dst;
+    float variance;
+    int h = disp->rows;
+    int w = disp->cols;
+    int start = std::min(range.start * stripe_sz, h);
+    int end   = std::min(range.end   * stripe_sz, h);
+    float roll_off = wls->depth_discontinuity_roll_off_factor/(wls->resize_factor*wls->resize_factor);
+
+    for(int i=start;i<end;i++)
+    {
+        row_disp = (float*)disp->ptr(i);
+        row_disp_squares = (float*)disp_squares->ptr(i);
+        row_dst = (float*)dst->ptr(i);
+
+        for(int j=0;j<w;j++)
+        {
+            variance = row_disp_squares[j] - (row_disp[j])*(row_disp[j]);
+            row_dst[j] = max(1.0f - roll_off*variance,0.0f);
+        }
+    }
+}
+
+DisparityWLSFilterImpl::ParallelMatOp_ParBody::ParallelMatOp_ParBody(DisparityWLSFilterImpl& _wls, vector<MatOp> _ops, vector<Mat*>& _src, vector<Mat*>& _dst):
+wls(&_wls),ops(_ops),src(_src),dst(_dst)
+{}
+
+void DisparityWLSFilterImpl::ParallelMatOp_ParBody::operator() (const Range& range) const
+{
+    for(int i=range.start;i<range.end;i++)
+        (wls->*ops[i])(*src[i],*dst[i]);
+}
+
+Ptr<DisparityWLSFilter> createDisparityWLSFilter(Ptr<StereoMatcher> matcher_left)
+{
+    Ptr<DisparityWLSFilter> wls;
+    matcher_left->setDisp12MaxDiff(1000000);
+    matcher_left->setSpeckleWindowSize(0);
+
+    int min_disp = matcher_left->getMinDisparity();
+    int num_disp = matcher_left->getNumDisparities();
+    int wsize    = matcher_left->getBlockSize();
+    int wsize2   = wsize/2;
+
+    if(Ptr<StereoBM> bm = matcher_left.dynamicCast<StereoBM>())
+    {
+        bm->setTextureThreshold(0);
+        bm->setUniquenessRatio(0);
+        wls = DisparityWLSFilterImpl::create(true,max(0,min_disp+num_disp)+wsize2,max(0,-min_disp)+wsize2,wsize2,wsize2,min_disp);
+        wls->setDepthDiscontinuityRadius((int)ceil(0.33*wsize));
+    }
+    else if(Ptr<StereoSGBM> sgbm = matcher_left.dynamicCast<StereoSGBM>())
+    {
+        sgbm->setUniquenessRatio(0);
+        wls = DisparityWLSFilterImpl::create(true,max(0,min_disp+num_disp),max(0,-min_disp),0,0,min_disp);
+        wls->setDepthDiscontinuityRadius((int)ceil(0.5*wsize));
+    }
+    else
+        CV_Error(Error::StsBadArg, "DisparityWLSFilter natively supports only StereoBM and StereoSGBM");
+
+    return wls;
+}
+
+Ptr<StereoMatcher> createRightMatcher(Ptr<StereoMatcher> matcher_left)
+{
+    int min_disp = matcher_left->getMinDisparity();
+    int num_disp = matcher_left->getNumDisparities();
+    int wsize    = matcher_left->getBlockSize();
+    if(Ptr<StereoBM> bm = matcher_left.dynamicCast<StereoBM>())
+    {
+        Ptr<StereoBM> right_bm = StereoBM::create(num_disp,wsize);
+        right_bm->setMinDisparity(-(min_disp+num_disp)+1);
+        right_bm->setTextureThreshold(0);
+        right_bm->setUniquenessRatio(0);
+        right_bm->setDisp12MaxDiff(1000000);
+        right_bm->setSpeckleWindowSize(0);
+        return right_bm;
+    }
+    else if(Ptr<StereoSGBM> sgbm = matcher_left.dynamicCast<StereoSGBM>())
+    {
+        Ptr<StereoSGBM> right_sgbm = StereoSGBM::create(-(min_disp+num_disp)+1,num_disp,wsize);
+        right_sgbm->setUniquenessRatio(0);
+        right_sgbm->setP1(sgbm->getP1());
+        right_sgbm->setP2(sgbm->getP2());
+        right_sgbm->setMode(sgbm->getMode());
+        right_sgbm->setPreFilterCap(sgbm->getPreFilterCap());
+        right_sgbm->setDisp12MaxDiff(1000000);
+        right_sgbm->setSpeckleWindowSize(0);
+        return right_sgbm;
+    }
+    else
+    {
+        CV_Error(Error::StsBadArg, "createRightMatcher supports only StereoBM and StereoSGBM");
+    }
+}
+
+Ptr<DisparityWLSFilter> createDisparityWLSFilterGeneric(bool use_confidence)
+{
+    return Ptr<DisparityWLSFilter>(DisparityWLSFilterImpl::create(use_confidence));
+}
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+#define UNKNOWN_DISPARITY 16320
+
+int readGT(String src_path,OutputArray dst)
+{
+    Mat src = imread(src_path,IMREAD_UNCHANGED);
+    dst.create(src.rows,src.cols,CV_16S);
+    Mat& dstMat = dst.getMatRef();
+
+    if(!src.empty() && src.channels()==3 && src.depth()==CV_8U)
+    {
+        //MPI-Sintel format:
+        for(int i=0;i<src.rows;i++)
+            for(int j=0;j<src.cols;j++)
+            {
+                Vec3b bgrPixel = src.at<Vec3b>(i, j);
+                dstMat.at<short>(i,j) = 64*bgrPixel.val[2]+bgrPixel.val[1]/4; //16-multiplied disparity
+            }
+        return 0;
+    }
+    else if(!src.empty() && src.channels()==1 && src.depth()==CV_8U)
+    {
+        //Middlebury format:
+        for(int i=0;i<src.rows;i++)
+            for(int j=0;j<src.cols;j++)
+            {
+                short src_val = src.at<unsigned char>(i, j);
+                if(src_val==0)
+                    dstMat.at<short>(i,j) = UNKNOWN_DISPARITY;
+                else
+                    dstMat.at<short>(i,j) = 16*src_val; //16-multiplied disparity
+            }
+         return 0;
+    }
+    else
+        return 1;
+}
+
+double computeMSE(InputArray GT, InputArray src, Rect ROI)
+{
+    CV_Assert( !GT.empty()  && (GT.depth()  == CV_16S || GT.depth()  == CV_32F) && (GT.channels()  == 1) );
+    CV_Assert( !src.empty() && (src.depth() == CV_16S || src.depth()  == CV_32F) && (src.channels() == 1) );
+    CV_Assert( src.rows() == GT.rows() && src.cols() == GT.cols() );
+    Mat GT_ROI (GT.getMat(), ROI);
+    Mat src_ROI(src.getMat(),ROI);
+
+    Mat tmp, dtmp, gt_mask = (GT_ROI == UNKNOWN_DISPARITY);
+    absdiff(GT_ROI, src_ROI, tmp); tmp.setTo(0, gt_mask); multiply(tmp, tmp, tmp);
+    tmp.convertTo(dtmp, CV_64FC1);
+    return sum(dtmp)[0] / ((gt_mask.total() - countNonZero(gt_mask))*256);
+}
+
+double computeBadPixelPercent(InputArray GT, InputArray src, Rect ROI, int thresh)
+{
+    CV_Assert( !GT.empty()  && (GT.depth()  == CV_16S || GT.depth()  == CV_32F) && (GT.channels()  == 1) );
+    CV_Assert( !src.empty() && (src.depth() == CV_16S || src.depth()  == CV_32F) && (src.channels() == 1) );
+    CV_Assert( src.rows() == GT.rows() && src.cols() == GT.cols() );
+    Mat GT_ROI (GT.getMat(), ROI);
+    Mat src_ROI(src.getMat(),ROI);
+
+    Mat tmp, gt_mask = (GT_ROI == UNKNOWN_DISPARITY);
+    absdiff(GT_ROI, src_ROI, tmp); tmp.setTo(0, gt_mask);
+    cv::threshold(tmp, tmp, thresh - 1, 1, THRESH_BINARY);
+    return (100.0 * countNonZero(tmp)) / (gt_mask.total() - countNonZero(gt_mask));
+}
+
+void getDisparityVis(InputArray src,OutputArray dst,double scale)
+{
+    CV_Assert( !src.empty() && (src.depth() == CV_16S || src.depth()  == CV_32F) && (src.channels() == 1) );
+    Mat srcMat = src.getMat();
+    dst.create(srcMat.rows,srcMat.cols,CV_8UC1);
+    Mat& dstMat = dst.getMatRef();
+
+    srcMat.convertTo(dstMat, CV_8UC1, scale / 16.0);
+    dstMat &= (srcMat != UNKNOWN_DISPARITY);
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/domain_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/domain_transform.cpp
new file mode 100644
index 00000000..9569feca
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/domain_transform.cpp
@@ -0,0 +1,60 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *  
+ *  
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *  
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *  
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *  
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *  
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *  
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include "dtfilter_cpu.hpp"
+
+namespace cv
+{
+namespace ximgproc
+{
+
+CV_EXPORTS_W
+Ptr<DTFilter> createDTFilter(InputArray guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)
+{
+    return Ptr<DTFilter>(DTFilterCPU::create(guide, sigmaSpatial, sigmaColor, mode, numIters));
+}
+
+CV_EXPORTS_W
+void dtFilter(InputArray guide, InputArray src, OutputArray dst, double sigmaSpatial, double sigmaColor, int mode, int numIters)
+{
+    Ptr<DTFilterCPU> dtf = DTFilterCPU::create(guide, sigmaSpatial, sigmaColor, mode, numIters);
+    dtf->setSingleFilterCall(true);
+    dtf->filter(src, dst);
+}
+
+}
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/dtfilter_cpu.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/dtfilter_cpu.cpp
new file mode 100644
index 00000000..79bad427
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/dtfilter_cpu.cpp
@@ -0,0 +1,213 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *  
+ *  
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *  
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *  
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *  
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *  
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *  
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include "dtfilter_cpu.hpp"
+
+namespace cv
+{
+namespace ximgproc
+{
+
+typedef Vec<uchar, 1> Vec1b;
+typedef Vec<float, 1> Vec1f;
+
+Ptr<DTFilterCPU> DTFilterCPU::create(InputArray guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)
+{
+    Ptr<DTFilterCPU> dtf(new DTFilterCPU());
+    dtf->init(guide, sigmaSpatial, sigmaColor, mode, numIters);
+    return dtf;
+}
+
+Ptr<DTFilterCPU> DTFilterCPU::createRF(InputArray adistHor, InputArray adistVert, double sigmaSpatial, double sigmaColor, int numIters /*= 3*/)
+{
+    Mat adh = adistHor.getMat();
+    Mat adv = adistVert.getMat();
+    CV_Assert(adh.type() == CV_32FC1 && adv.type() == CV_32FC1 && adh.rows == adv.rows + 1 && adh.cols == adv.cols - 1);
+
+    Ptr<DTFilterCPU> dtf(new DTFilterCPU());
+    dtf->release();
+    dtf->mode = DTF_RF;
+    dtf->numIters = std::max(1, numIters);
+
+    dtf->h = adh.rows;
+    dtf->w = adh.cols + 1;
+
+    dtf->sigmaSpatial = std::max(1.0f, (float)sigmaSpatial);
+    dtf->sigmaColor = std::max(0.01f, (float)sigmaColor);
+
+    dtf->a0distHor = adh;
+    dtf->a0distVert = adv;
+
+    return dtf;
+}
+
+void DTFilterCPU::init(InputArray guide_, double sigmaSpatial_, double sigmaColor_, int mode_, int numIters_)
+{
+    Mat guide = guide_.getMat();
+
+    int cn = guide.channels();
+    int depth = guide.depth();
+
+    CV_Assert(cn <= 4);
+    CV_Assert((depth == CV_8U || depth == CV_32F) && !guide.empty());
+
+    #define CREATE_DTF(Vect) init_<Vect>(guide, sigmaSpatial_, sigmaColor_, mode_, numIters_);
+
+    if (cn == 1)
+    {
+        if (depth == CV_8U)
+            CREATE_DTF(Vec1b);
+        if (depth == CV_32F)
+            CREATE_DTF(Vec1f);
+    }
+    else if (cn == 2)
+    {
+        if (depth == CV_8U)
+            CREATE_DTF(Vec2b);
+        if (depth == CV_32F)
+            CREATE_DTF(Vec2f);
+    }
+    else if (cn == 3)
+    {
+        if (depth == CV_8U)
+            CREATE_DTF(Vec3b);
+        if (depth == CV_32F)
+            CREATE_DTF(Vec3f);
+    }
+    else if (cn == 4)
+    {
+        if (depth == CV_8U)
+            CREATE_DTF(Vec4b);
+        if (depth == CV_32F)
+            CREATE_DTF(Vec4f);
+    }
+
+    #undef CREATE_DTF
+}
+
+void DTFilterCPU::filter(InputArray src_, OutputArray dst_, int dDepth)
+{
+    Mat src = src_.getMat();
+    dst_.create(src.size(), src.type());
+    Mat& dst = dst_.getMatRef();
+
+    int cn = src.channels();
+    int depth = src.depth();
+
+    CV_Assert(cn <= 4 && (depth == CV_8U || depth == CV_32F));
+
+    if (cn == 1)
+    {
+        if (depth == CV_8U)
+            filter_<Vec1b>(src, dst, dDepth);
+        if (depth == CV_32F)
+            filter_<Vec1f>(src, dst, dDepth);
+    }
+    else if (cn == 2)
+    {
+        if (depth == CV_8U)
+            filter_<Vec2b>(src, dst, dDepth);
+        if (depth == CV_32F)
+            filter_<Vec2f>(src, dst, dDepth);
+    }
+    else if (cn == 3)
+    {
+        if (depth == CV_8U)
+            filter_<Vec3b>(src, dst, dDepth);
+        if (depth == CV_32F)
+            filter_<Vec3f>(src, dst, dDepth);
+    }
+    else if (cn == 4)
+    {
+        if (depth == CV_8U)
+            filter_<Vec4b>(src, dst, dDepth);
+        if (depth == CV_32F)
+            filter_<Vec4f>(src, dst, dDepth);
+    }
+}
+
+void DTFilterCPU::setSingleFilterCall(bool value)
+{
+    singleFilterCall = value;
+}
+
+void DTFilterCPU::release()
+{
+    if (mode == -1) return;
+
+    idistHor.release();
+    idistVert.release();
+
+    distHor.release();
+    distVert.release();
+
+    a0distHor.release();
+    a0distVert.release();
+
+    adistHor.release();
+    adistVert.release();
+}
+
+Mat DTFilterCPU::getWExtendedMat(int h, int w, int type, int brdleft /*= 0*/, int brdRight /*= 0*/, int cacheAlign /*= 0*/)
+{
+    int wrapperCols = w + brdleft + brdRight;
+    if (cacheAlign > 0)
+        wrapperCols += ((wrapperCols + cacheAlign-1) / cacheAlign)*cacheAlign;
+    Mat mat(h, wrapperCols, type);
+    return mat(Range::all(), Range(brdleft, w + brdleft));
+}
+
+
+Range DTFilterCPU::getWorkRangeByThread(const Range& itemsRange, const Range& rangeThread, int declaredNumThreads)
+{
+    if (declaredNumThreads <= 0)
+        declaredNumThreads = cv::getNumThreads();
+
+    int chunk   = itemsRange.size() / declaredNumThreads;
+    int start   = itemsRange.start + chunk * rangeThread.start;
+    int end     = itemsRange.start + ((rangeThread.end >= declaredNumThreads) ? itemsRange.size() : chunk * rangeThread.end);
+
+    return Range(start, end);
+}
+
+Range DTFilterCPU::getWorkRangeByThread(int items, const Range& rangeThread, int declaredNumThreads)
+{
+    return getWorkRangeByThread(Range(0, items), rangeThread, declaredNumThreads);
+}
+
+}
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/dtfilter_cpu.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/dtfilter_cpu.hpp
new file mode 100644
index 00000000..3eaec8b7
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/dtfilter_cpu.hpp
@@ -0,0 +1,294 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#ifndef __OPENCV_DTFILTER_HPP__
+#define __OPENCV_DTFILTER_HPP__
+#include "precomp.hpp"
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4512)
+#pragma warning(disable: 4127)
+#endif
+
+#define CV_GET_NUM_THREAD_WORKS_PROPERLY
+#undef CV_GET_NUM_THREAD_WORKS_PROPERLY
+
+namespace cv
+{
+namespace ximgproc
+{
+
+class DTFilterCPU : public DTFilter
+{
+public: /*Non-template methods*/
+
+    static Ptr<DTFilterCPU> create(InputArray guide, double sigmaSpatial, double sigmaColor, int mode = DTF_NC, int numIters = 3);
+
+    static Ptr<DTFilterCPU> createRF(InputArray adistHor, InputArray adistVert, double sigmaSpatial, double sigmaColor, int numIters = 3);
+
+    void filter(InputArray src, OutputArray dst, int dDepth = -1) CV_OVERRIDE;
+
+    void setSingleFilterCall(bool value);
+
+public: /*Template methods*/
+
+    /*Use this static methods instead of constructor*/
+    template<typename GuideVec>
+    static DTFilterCPU* create_p_(const Mat& guide, double sigmaSpatial, double sigmaColor, int mode = DTF_NC, int numIters = 3);
+
+    template<typename GuideVec>
+    static DTFilterCPU create_(const Mat& guide, double sigmaSpatial, double sigmaColor, int mode = DTF_NC, int numIters = 3);
+
+    template<typename GuideVec>
+    void init_(Mat& guide, double sigmaSpatial, double sigmaColor, int mode = DTF_NC, int numIters = 3);
+
+    template<typename SrcVec>
+    void filter_(const Mat& src, Mat& dst, int dDepth = -1);
+
+protected: /*Typedefs declarations*/
+
+    typedef float                   IDistType;
+    typedef Vec<IDistType, 1>       IDistVec;
+
+    typedef float                   DistType;
+    typedef Vec<DistType, 1>        DistVec;
+
+    typedef float                   WorkType;
+
+public: /*Members declarations*/
+
+    int h, w, mode;
+    float sigmaSpatial, sigmaColor;
+
+    bool singleFilterCall;
+    int numFilterCalls;
+
+    Mat idistHor, idistVert;
+    Mat distHor, distVert;
+
+    Mat a0distHor, a0distVert;
+    Mat adistHor, adistVert;
+    int numIters;
+
+protected: /*Functions declarations*/
+
+    DTFilterCPU() : mode(-1), singleFilterCall(false), numFilterCalls(0) {}
+
+    void init(InputArray guide, double sigmaSpatial, double sigmaColor, int mode = DTF_NC, int numIters = 3);
+
+    void release();
+
+    template<typename GuideVec>
+    inline IDistType getTransformedDistance(const GuideVec &l, const GuideVec &r)
+    {
+        return (IDistType)(1.0f + sigmaSpatial / sigmaColor * norm1<IDistType>(l, r));
+    }
+
+    inline double getIterSigmaH(int iterNum)
+    {
+        return sigmaSpatial * std::pow(2.0, numIters - iterNum) / sqrt(std::pow(4.0, numIters) - 1);
+    }
+
+    inline IDistType getIterRadius(int iterNum)
+    {
+        return (IDistType)(3.0*getIterSigmaH(iterNum));
+    }
+
+    inline float getIterAlpha(int iterNum)
+    {
+        return (float)std::exp(-std::sqrt(2.0 / 3.0) / getIterSigmaH(iterNum));
+    }
+
+protected: /*Wrappers for parallelization*/
+
+    template <typename WorkVec>
+    struct FilterNC_horPass : public ParallelLoopBody
+    {
+        Mat &src, &idist, &dst;
+        float radius;
+
+        FilterNC_horPass(Mat& src_, Mat& idist_, Mat& dst_);
+        void operator() (const Range& range) const CV_OVERRIDE;
+    };
+
+    template <typename WorkVec>
+    struct FilterIC_horPass : public ParallelLoopBody
+    {
+        Mat &src, &idist, &dist, &dst, isrcBuf;
+        float radius;
+
+        FilterIC_horPass(Mat& src_, Mat& idist_, Mat& dist_, Mat& dst_);
+        void operator() (const Range& range) const CV_OVERRIDE;
+    };
+
+    template <typename WorkVec>
+    struct FilterRF_horPass : public ParallelLoopBody
+    {
+        Mat &res, &alphaD;
+        int iteration;
+
+        FilterRF_horPass(Mat& res_, Mat& alphaD_, int iteration_);
+        void operator() (const Range& range) const CV_OVERRIDE;
+        Range getRange() const { return Range(0, res.rows); }
+    };
+
+    template <typename WorkVec>
+    struct FilterRF_vertPass : public ParallelLoopBody
+    {
+        Mat &res, &alphaD;
+        int iteration;
+
+        FilterRF_vertPass(Mat& res_, Mat& alphaD_, int iteration_);
+        void operator() (const Range& range) const CV_OVERRIDE;
+        #ifdef CV_GET_NUM_THREAD_WORKS_PROPERLY
+        Range getRange() const { return Range(0, cv::getNumThreads()); }
+        #else
+        Range getRange() const { return Range(0, res.cols); }
+        #endif
+    };
+
+    template <typename GuideVec>
+    struct ComputeIDTHor_ParBody: public ParallelLoopBody
+    {
+        DTFilterCPU &dtf;
+        Mat &guide, &dst;
+
+        ComputeIDTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_, Mat& dst_);
+        void operator() (const Range& range) const CV_OVERRIDE;
+        Range getRange() { return Range(0, guide.rows); }
+    };
+
+    template <typename GuideVec>
+    struct ComputeDTandIDTHor_ParBody : public ParallelLoopBody
+    {
+        DTFilterCPU &dtf;
+        Mat &guide, &dist, &idist;
+        IDistType maxRadius;
+
+        ComputeDTandIDTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_, Mat& dist_, Mat& idist_);
+        void operator() (const Range& range) const CV_OVERRIDE;
+        Range getRange() { return Range(0, guide.rows); }
+    };
+
+    template <typename GuideVec>
+    struct ComputeA0DTHor_ParBody : public ParallelLoopBody
+    {
+        DTFilterCPU &dtf;
+        Mat &guide;
+        float lna;
+
+        ComputeA0DTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_);
+        void operator() (const Range& range) const CV_OVERRIDE;
+        Range getRange() { return Range(0, guide.rows); }
+        ~ComputeA0DTHor_ParBody();
+    };
+
+    template <typename GuideVec>
+    struct ComputeA0DTVert_ParBody : public ParallelLoopBody
+    {
+        DTFilterCPU &dtf;
+        Mat &guide;
+        float lna;
+
+        ComputeA0DTVert_ParBody(DTFilterCPU& dtf_, Mat& guide_);
+        void operator() (const Range& range) const CV_OVERRIDE;
+        Range getRange() const { return Range(0, guide.rows - 1); }
+        ~ComputeA0DTVert_ParBody();
+    };
+
+protected: /*Auxiliary implementation functions*/
+
+    static Range getWorkRangeByThread(const Range& itemsRange, const Range& rangeThread, int maxThreads = 0);
+    static Range getWorkRangeByThread(int items, const Range& rangeThread, int maxThreads = 0);
+
+    template<typename SrcVec>
+    static void prepareSrcImg_IC(const Mat& src, Mat& inner, Mat& outer);
+
+    static Mat getWExtendedMat(int h, int w, int type, int brdleft = 0, int brdRight = 0, int cacheAlign = 0);
+
+    template<typename SrcVec, typename SrcWorkVec>
+    static void integrateSparseRow(const SrcVec *src, const float *dist, SrcWorkVec *dst, int cols);
+
+    template<typename SrcVec, typename SrcWorkVec>
+    static void integrateRow(const SrcVec *src, SrcWorkVec *dst, int cols);
+
+    inline static int getLeftBound(IDistType *idist, int pos, IDistType searchValue)
+    {
+        while (idist[pos] < searchValue)
+            pos++;
+        return pos;
+    }
+
+    inline static int getRightBound(IDistType *idist, int pos, IDistType searchValue)
+    {
+        while (idist[pos + 1] < searchValue)
+            pos++;
+        return pos;
+    }
+
+    template <typename T, typename T1, typename T2, int n>
+    inline static T norm1(const cv::Vec<T1, n>& v1, const cv::Vec<T2, n>& v2)
+    {
+        T sum = (T) 0;
+        for (int i = 0; i < n; i++)
+            sum += std::abs( (T)v1[i] - (T)v2[i] );
+        return sum;
+    }
+};
+
+/*One-line template wrappers for DT call*/
+
+template<typename GuideVec, typename SrcVec>
+void domainTransformFilter( const Mat_<GuideVec>& guide,
+                            const Mat_<SrcVec>& source,
+                            Mat& dst,
+                            double sigmaSpatial, double sigmaColor,
+                            int mode = DTF_NC, int numPasses = 3
+                          );
+
+template<typename GuideVec, typename SrcVec>
+void domainTransformFilter( const Mat& guide,
+                            const Mat& source,
+                            Mat& dst,
+                            double sigmaSpatial, double sigmaColor,
+                            int mode = DTF_NC, int numPasses = 3
+                          );
+}
+}
+
+#include "dtfilter_cpu.inl.hpp"
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/dtfilter_cpu.inl.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/dtfilter_cpu.inl.hpp
new file mode 100644
index 00000000..cdc28d45
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/dtfilter_cpu.inl.hpp
@@ -0,0 +1,624 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#ifndef __OPENCV_DTFILTER_INL_HPP__
+#define __OPENCV_DTFILTER_INL_HPP__
+#include "precomp.hpp"
+#include "edgeaware_filters_common.hpp"
+#include <limits>
+
+namespace cv
+{
+namespace ximgproc
+{
+
+using namespace cv::ximgproc::intrinsics;
+
+#define NC_USE_INTEGRAL_SRC
+//#undef NC_USE_INTEGRAL_SRC
+
+template<typename GuideVec>
+DTFilterCPU DTFilterCPU::create_(const Mat& guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)
+{
+    DTFilterCPU dtf;
+    dtf.init_<GuideVec>(guide, sigmaSpatial, sigmaColor, mode, numIters);
+    return dtf;
+}
+
+template<typename GuideVec>
+DTFilterCPU* DTFilterCPU::create_p_(const Mat& guide, double sigmaSpatial, double sigmaColor, int mode, int numIters)
+{
+    DTFilterCPU* dtf = new DTFilterCPU();
+    dtf->init_<GuideVec>(guide, sigmaSpatial, sigmaColor, mode, numIters);
+    return dtf;
+}
+
+template<typename GuideVec>
+void DTFilterCPU::init_(Mat& guide, double sigmaSpatial_, double sigmaColor_, int mode_, int numIters_)
+{
+    CV_Assert(guide.type() == traits::Type<GuideVec>::value);
+
+    this->release();
+
+    h = guide.rows;
+    w = guide.cols;
+
+    sigmaSpatial = std::max(1.0f, (float)sigmaSpatial_);
+    sigmaColor   = std::max(0.01f, (float)sigmaColor_);
+
+    mode = mode_;
+    numIters = std::max(1, numIters_);
+
+    if (mode == DTF_NC)
+    {
+        {
+            ComputeIDTHor_ParBody<GuideVec> horBody(*this, guide, idistHor);
+            parallel_for_(horBody.getRange(), horBody);
+        }
+        {
+            Mat guideT = guide.t();
+            ComputeIDTHor_ParBody<GuideVec> horBody(*this, guideT, idistVert);
+            parallel_for_(horBody.getRange(), horBody);
+        }
+    }
+    else if (mode == DTF_IC)
+    {
+        {
+            ComputeDTandIDTHor_ParBody<GuideVec> horBody(*this, guide, distHor, idistHor);
+            parallel_for_(horBody.getRange(), horBody);
+        }
+        {
+            Mat guideT = guide.t();
+            ComputeDTandIDTHor_ParBody<GuideVec> horBody(*this, guideT, distVert, idistVert);
+            parallel_for_(horBody.getRange(), horBody);
+        }
+    }
+    else if (mode == DTF_RF)
+    {
+        ComputeA0DTHor_ParBody<GuideVec> horBody(*this, guide);
+        ComputeA0DTVert_ParBody<GuideVec> vertBody(*this, guide);
+        parallel_for_(horBody.getRange(), horBody);
+        parallel_for_(vertBody.getRange(), vertBody);
+    }
+    else
+    {
+        CV_Error(Error::StsBadFlag, "Incorrect DT filter mode");
+    }
+}
+
+template <typename SrcVec>
+void DTFilterCPU::filter_(const Mat& src, Mat& dst, int dDepth)
+{
+    typedef typename DataType<Vec<WorkType, SrcVec::channels> >::vec_type WorkVec;
+    CV_Assert( src.type() == traits::Type<SrcVec>::value );
+    if ( src.cols != w || src.rows != h )
+    {
+        CV_Error(Error::StsBadSize, "Size of filtering image must be equal to size of guide image");
+    }
+
+    if (singleFilterCall)
+    {
+        CV_Assert(numFilterCalls == 0);
+    }
+    numFilterCalls++;
+
+    Mat res;
+    if (dDepth == -1) dDepth = src.depth();
+
+    //small optimization to avoid extra copying of data
+    bool useDstAsRes = (dDepth == traits::Depth<WorkVec>::value && (mode == DTF_NC || mode == DTF_RF));
+    if (useDstAsRes)
+    {
+        dst.create(h, w, traits::Type<WorkVec>::value);
+        res = dst;
+    }
+
+    if (mode == DTF_NC)
+    {
+        Mat resT(src.cols, src.rows, traits::Type<WorkVec>::value);
+        src.convertTo(res, traits::Type<WorkVec>::value);
+
+        FilterNC_horPass<WorkVec> horParBody(res, idistHor, resT);
+        FilterNC_horPass<WorkVec> vertParBody(resT, idistVert, res);
+
+        for (int iter = 1; iter <= numIters; iter++)
+        {
+            horParBody.radius = vertParBody.radius = getIterRadius(iter);
+
+            parallel_for_(Range(0, res.rows), horParBody);
+            parallel_for_(Range(0, resT.rows), vertParBody);
+        }
+    }
+    else if (mode == DTF_IC)
+    {
+        Mat resT;
+        prepareSrcImg_IC<WorkVec>(src, res, resT);
+
+        FilterIC_horPass<WorkVec> horParBody(res, idistHor, distHor, resT);
+        FilterIC_horPass<WorkVec> vertParBody(resT, idistVert, distVert, res);
+
+        for (int iter = 1; iter <= numIters; iter++)
+        {
+            horParBody.radius = vertParBody.radius = getIterRadius(iter);
+
+            parallel_for_(Range(0, res.rows), horParBody);
+            parallel_for_(Range(0, resT.rows), vertParBody);
+        }
+    }
+    else if (mode == DTF_RF)
+    {
+        src.convertTo(res, traits::Type<WorkVec>::value);
+
+        for (int iter = 1; iter <= numIters; iter++)
+        {
+            if (!singleFilterCall && iter == 2)
+            {
+                a0distHor.copyTo(adistHor);
+                a0distVert.copyTo(adistVert);
+            }
+
+            bool useA0DT = (singleFilterCall || iter == 1);
+            Mat& a0dHor  = (useA0DT) ? a0distHor : adistHor;
+            Mat& a0dVert = (useA0DT) ? a0distVert : adistVert;
+
+            FilterRF_horPass<WorkVec> horParBody(res, a0dHor, iter);
+            FilterRF_vertPass<WorkVec> vertParBody(res, a0dVert, iter);
+            parallel_for_(horParBody.getRange(), horParBody);
+            parallel_for_(vertParBody.getRange(), vertParBody);
+        }
+    }
+
+    if (!useDstAsRes)
+    {
+        res.convertTo(dst, dDepth);
+    }
+}
+
+template<typename SrcVec, typename SrcWorkVec>
+void DTFilterCPU::integrateRow(const SrcVec *src, SrcWorkVec *dst, int cols)
+{
+    SrcWorkVec sum = SrcWorkVec::all(0);
+    dst[0] = sum;
+
+    for (int j = 0; j < cols; j++)
+    {
+        sum += SrcWorkVec(src[j]);
+        dst[j + 1] = sum;
+    }
+}
+
+
+template<typename SrcVec, typename SrcWorkVec>
+void DTFilterCPU::integrateSparseRow(const SrcVec *src, const float *dist, SrcWorkVec *dst, int cols)
+{
+    SrcWorkVec sum = SrcWorkVec::all(0);
+    dst[0] = sum;
+
+    for (int j = 0; j < cols-1; j++)
+    {
+        sum += dist[j] * 0.5f * (SrcWorkVec(src[j]) + SrcWorkVec(src[j+1]));
+        dst[j + 1] = sum;
+    }
+}
+
+template<typename WorkVec>
+void DTFilterCPU::prepareSrcImg_IC(const Mat& src, Mat& dst, Mat& dstT)
+{
+    Mat dstOut(src.rows, src.cols + 2, traits::Type<WorkVec>::value);
+    Mat dstOutT(src.cols, src.rows + 2, traits::Type<WorkVec>::value);
+
+    dst = dstOut(Range::all(), Range(1, src.cols+1));
+    dstT = dstOutT(Range::all(), Range(1, src.rows+1));
+
+    src.convertTo(dst, traits::Type<WorkVec>::value);
+
+    WorkVec *line;
+    int ri = dstOut.cols - 1;
+    for (int i = 0; i < src.rows; i++)
+    {
+        line        = dstOut.ptr<WorkVec>(i);
+        line[0]     = line[1];
+        line[ri]    = line[ri - 1];
+    }
+
+    WorkVec *topLine = dst.ptr<WorkVec>(0);
+    WorkVec *bottomLine = dst.ptr<WorkVec>(dst.rows - 1);
+    ri = dstOutT.cols - 1;
+    for (int i = 0; i < src.cols; i++)
+    {
+        line        = dstOutT.ptr<WorkVec>(i);
+        line[0]     = topLine[i];
+        line[ri]    = bottomLine[i];
+    }
+}
+
+
+template <typename WorkVec>
+DTFilterCPU::FilterNC_horPass<WorkVec>::FilterNC_horPass(Mat& src_, Mat& idist_, Mat& dst_)
+: src(src_), idist(idist_), dst(dst_), radius(1.0f)
+{
+    CV_DbgAssert(src.type() == traits::Type<WorkVec>::value && dst.type() == traits::Type<WorkVec>::value && dst.rows == src.cols && dst.cols == src.rows);
+}
+
+template <typename WorkVec>
+void DTFilterCPU::FilterNC_horPass<WorkVec>::operator()(const Range& range) const
+{
+    #ifdef NC_USE_INTEGRAL_SRC
+    std::vector<WorkVec> isrcBuf(src.cols + 1);
+    WorkVec *isrcLine = &isrcBuf[0];
+    #endif
+
+    for (int i = range.start; i < range.end; i++)
+    {
+        const WorkVec   *srcLine    = src.ptr<WorkVec>(i);
+        IDistType       *idistLine  = idist.ptr<IDistType>(i);
+        int leftBound = 0, rightBound = 0;
+        WorkVec sum;
+
+        #ifdef NC_USE_INTEGRAL_SRC
+        integrateRow(srcLine, isrcLine, src.cols);
+        #else
+        sum = srcLine[0];
+        #endif
+
+        for (int j = 0; j < src.cols; j++)
+        {
+            IDistType curVal = idistLine[j];
+            #ifdef NC_USE_INTEGRAL_SRC
+            leftBound  = getLeftBound(idistLine, leftBound, curVal - radius);
+            rightBound = getRightBound(idistLine, rightBound, curVal + radius);
+            sum = (isrcLine[rightBound + 1] - isrcLine[leftBound]);
+            #else
+            while (idistLine[leftBound] < curVal - radius)
+            {
+                sum -= srcLine[leftBound];
+                leftBound++;
+            }
+
+            while (idistLine[rightBound + 1] < curVal + radius)
+            {
+                rightBound++;
+                sum += srcLine[rightBound];
+            }
+            #endif
+
+            dst.at<WorkVec>(j, i) = sum / (float)(rightBound + 1 - leftBound);
+        }
+    }
+}
+
+template <typename WorkVec>
+DTFilterCPU::FilterIC_horPass<WorkVec>::FilterIC_horPass(Mat& src_, Mat& idist_, Mat& dist_, Mat& dst_)
+: src(src_), idist(idist_), dist(dist_), dst(dst_), radius(1.0f)
+{
+    CV_DbgAssert(src.type() == traits::Type<WorkVec>::value && dst.type() == traits::Type<WorkVec>::value && dst.rows == src.cols && dst.cols == src.rows);
+
+    #ifdef CV_GET_NUM_THREAD_WORKS_PROPERLY
+    isrcBuf.create(cv::getNumThreads(), src.cols + 1, traits::Type<WorkVec>::value);
+    #else
+    isrcBuf.create(src.rows, src.cols + 1, traits::Type<WorkVec>::value);
+    #endif
+}
+
+template <typename WorkVec>
+void DTFilterCPU::FilterIC_horPass<WorkVec>::operator()(const Range& range) const
+{
+    #ifdef CV_GET_NUM_THREAD_WORKS_PROPERLY
+    WorkVec *isrcLine = const_cast<WorkVec*>( isrcBuf.ptr<WorkVec>(cv::getThreadNum()) );
+    #else
+    WorkVec *isrcLine = const_cast<WorkVec*>( isrcBuf.ptr<WorkVec>(range.start) );
+    #endif
+
+    for (int i = range.start; i < range.end; i++)
+    {
+        WorkVec   *srcLine      = src.ptr<WorkVec>(i);
+        DistType  *distLine     = dist.ptr<DistType>(i);
+        IDistType *idistLine    = idist.ptr<IDistType>(i);
+
+        integrateSparseRow(srcLine, distLine, isrcLine, src.cols);
+
+        int leftBound = 0, rightBound = 0;
+        WorkVec sumL, sumR, sumC;
+
+        srcLine[-1] = srcLine[0];
+        srcLine[src.cols] = srcLine[src.cols - 1];
+
+        for (int j = 0; j < src.cols; j++)
+        {
+            IDistType curVal = idistLine[j];
+            IDistType valueLeft = curVal - radius;
+            IDistType valueRight = curVal + radius;
+
+            leftBound = getLeftBound(idistLine, leftBound, valueLeft);
+            rightBound = getRightBound(idistLine, rightBound, valueRight);
+
+            float areaL = idistLine[leftBound] - valueLeft;
+            float areaR = valueRight - idistLine[rightBound];
+            float dl = areaL / distLine[leftBound - 1];
+            float dr = areaR / distLine[rightBound];
+
+            sumL = 0.5f*areaL*(dl*srcLine[leftBound - 1] + (2.0f - dl)*srcLine[leftBound]);
+            sumR = 0.5f*areaR*((2.0f - dr)*srcLine[rightBound] + dr*srcLine[rightBound + 1]);
+            sumC = isrcLine[rightBound] - isrcLine[leftBound];
+
+            dst.at<WorkVec>(j, i) = (sumL + sumC + sumR) / (2.0f * radius);
+        }
+    }
+}
+
+
+template <typename WorkVec>
+DTFilterCPU::FilterRF_horPass<WorkVec>::FilterRF_horPass(Mat& res_, Mat& alphaD_, int iteration_)
+: res(res_), alphaD(alphaD_), iteration(iteration_)
+{
+    CV_DbgAssert(res.type() == traits::Type<WorkVec>::value);
+    CV_DbgAssert(res.type() == traits::Type<WorkVec>::value && res.size() == res.size());
+}
+
+
+template <typename WorkVec>
+void DTFilterCPU::FilterRF_horPass<WorkVec>::operator()(const Range& range) const
+{
+    for (int i = range.start; i < range.end; i++)
+    {
+        WorkVec     *dstLine = res.ptr<WorkVec>(i);
+        DistType    *adLine  = alphaD.ptr<DistType>(i);
+        int j;
+
+        if (iteration > 1)
+        {
+            for (j = res.cols - 2; j >= 0; j--)
+                adLine[j] *= adLine[j];
+        }
+
+        for (j = 1; j < res.cols; j++)
+        {
+            dstLine[j] += adLine[j-1] * (dstLine[j-1] - dstLine[j]);
+        }
+
+        for (j = res.cols - 2; j >= 0; j--)
+        {
+            dstLine[j] += adLine[j] * (dstLine[j+1] - dstLine[j]);
+        }
+    }
+}
+
+
+template <typename WorkVec>
+DTFilterCPU::FilterRF_vertPass<WorkVec>::FilterRF_vertPass(Mat& res_, Mat& alphaD_, int iteration_)
+: res(res_), alphaD(alphaD_), iteration(iteration_)
+{
+    CV_DbgAssert(res.type() == traits::Type<WorkVec>::value);
+    CV_DbgAssert(res.type() == traits::Type<WorkVec>::value && res.size() == res.size());
+}
+
+
+template <typename WorkVec>
+void DTFilterCPU::FilterRF_vertPass<WorkVec>::operator()(const Range& range) const
+{
+    #ifdef CV_GET_NUM_THREAD_WORKS_PROPERLY
+    Range rcols = getWorkRangeByThread(res.cols, range);
+    #else
+    Range rcols = range;
+    #endif
+
+    for (int i = 1; i < res.rows; i++)
+    {
+        WorkVec     *curRow  = res.ptr<WorkVec>(i);
+        WorkVec     *prevRow = res.ptr<WorkVec>(i - 1);
+        DistType    *adRow   = alphaD.ptr<DistType>(i - 1);
+
+        if (iteration > 1)
+        {
+            for (int j = rcols.start; j < rcols.end; j++)
+                adRow[j] *= adRow[j];
+        }
+
+        for (int j = rcols.start; j < rcols.end; j++)
+        {
+            curRow[j] += adRow[j] * (prevRow[j] - curRow[j]);
+        }
+    }
+
+    for (int i = res.rows - 2; i >= 0; i--)
+    {
+        WorkVec     *prevRow = res.ptr<WorkVec>(i + 1);
+        WorkVec     *curRow  = res.ptr<WorkVec>(i);
+        DistType    *adRow   = alphaD.ptr<DistType>(i);
+
+        for (int j = rcols.start; j < rcols.end; j++)
+        {
+            curRow[j] += adRow[j] * (prevRow[j] - curRow[j]);
+        }
+    }
+}
+
+template <typename GuideVec>
+DTFilterCPU::ComputeIDTHor_ParBody<GuideVec>::ComputeIDTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_, Mat& dst_)
+: dtf(dtf_), guide(guide_), dst(dst_)
+{
+    dst.create(guide.rows, guide.cols + 1, traits::Type<IDistVec>::value);
+}
+
+template <typename GuideVec>
+void DTFilterCPU::ComputeIDTHor_ParBody<GuideVec>::operator()(const Range& range) const
+{
+    for (int i = range.start; i < range.end; i++)
+    {
+        const GuideVec *guideLine   = guide.ptr<GuideVec>(i);
+        IDistType *idistLine        = dst.ptr<IDistType>(i);
+
+        IDistType curDist   = (IDistType)0;
+        idistLine[0]        = (IDistType)0;
+
+        for (int j = 1; j < guide.cols; j++)
+        {
+            curDist += dtf.getTransformedDistance(guideLine[j-1], guideLine[j]);
+            idistLine[j] = curDist;
+        }
+        idistLine[guide.cols] = std::numeric_limits<IDistType>::max();
+    }
+}
+
+template <typename GuideVec>
+DTFilterCPU::ComputeDTandIDTHor_ParBody<GuideVec>::ComputeDTandIDTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_, Mat& dist_, Mat& idist_)
+: dtf(dtf_), guide(guide_), dist(dist_), idist(idist_)
+{
+    dist = getWExtendedMat(guide.rows, guide.cols, traits::Type<IDistVec>::value, 1, 1);
+    idist = getWExtendedMat(guide.rows, guide.cols + 1, traits::Type<IDistVec>::value);
+    maxRadius = dtf.getIterRadius(1);
+}
+
+template <typename GuideVec>
+void DTFilterCPU::ComputeDTandIDTHor_ParBody<GuideVec>::operator()(const Range& range) const
+{
+    for (int i = range.start; i < range.end; i++)
+    {
+        const GuideVec  *guideLine  = guide.ptr<GuideVec>(i);
+              DistType  *distLine   = dist.ptr<DistType>(i);
+              IDistType *idistLine  = idist.ptr<IDistType>(i);
+
+        DistType  curDist;
+        IDistType curIDist = (IDistType)0;
+        int j;
+
+        distLine[-1] = maxRadius;
+        //idistLine[-1] = curIDist - maxRadius;
+        idistLine[0] = curIDist;
+        for (j = 0; j < guide.cols-1; j++)
+        {
+            curDist = (DistType) dtf.getTransformedDistance(guideLine[j], guideLine[j + 1]);
+            curIDist += curDist;
+
+            distLine[j] = curDist;
+            idistLine[j + 1] = curIDist;
+        }
+        idistLine[j + 1] = curIDist + maxRadius;
+        distLine[j] = maxRadius;
+    }
+}
+
+template <typename GuideVec>
+DTFilterCPU::ComputeA0DTHor_ParBody<GuideVec>::ComputeA0DTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_)
+: dtf(dtf_), guide(guide_)
+{
+    dtf.a0distHor.create(guide.rows, guide.cols - 1, traits::Type<DistVec>::value);
+    lna = std::log(dtf.getIterAlpha(1));
+}
+
+template <typename GuideVec>
+void DTFilterCPU::ComputeA0DTHor_ParBody<GuideVec>::operator()(const Range& range) const
+{
+    for (int i = range.start; i < range.end; i++)
+    {
+        const GuideVec  *guideLine  = guide.ptr<GuideVec>(i);
+              DistType  *dstLine    = dtf.a0distHor.ptr<DistType>(i);
+
+        for (int j = 0; j < guide.cols - 1; j++)
+        {
+            DistType d = (DistType)dtf.getTransformedDistance(guideLine[j], guideLine[j + 1]);
+            dstLine[j] = lna*d;
+        }
+    }
+}
+
+template <typename GuideVec>
+DTFilterCPU::ComputeA0DTHor_ParBody<GuideVec>::~ComputeA0DTHor_ParBody()
+{
+    cv::exp(dtf.a0distHor, dtf.a0distHor);
+}
+
+template <typename GuideVec>
+DTFilterCPU::ComputeA0DTVert_ParBody<GuideVec>::ComputeA0DTVert_ParBody(DTFilterCPU& dtf_, Mat& guide_)
+: dtf(dtf_), guide(guide_)
+{
+    dtf.a0distVert.create(guide.rows - 1, guide.cols, traits::Type<DistVec>::value);
+    lna = std::log(dtf.getIterAlpha(1));
+}
+
+template <typename GuideVec>
+void DTFilterCPU::ComputeA0DTVert_ParBody<GuideVec>::operator()(const Range& range) const
+{
+    for (int i = range.start; i < range.end; i++)
+    {
+        DistType *dstLine = dtf.a0distVert.ptr<DistType>(i);
+        GuideVec *guideRow1 = guide.ptr<GuideVec>(i);
+        GuideVec *guideRow2 = guide.ptr<GuideVec>(i+1);
+
+        for (int j = 0; j < guide.cols; j++)
+        {
+            DistType d = (DistType)dtf.getTransformedDistance(guideRow1[j], guideRow2[j]);
+            dstLine[j] = lna*d;
+        }
+    }
+}
+
+template <typename GuideVec>
+DTFilterCPU::ComputeA0DTVert_ParBody<GuideVec>::~ComputeA0DTVert_ParBody()
+{
+    cv::exp(dtf.a0distVert, dtf.a0distVert);
+}
+
+
+template<typename GuideVec, typename SrcVec>
+void domainTransformFilter( const Mat_<GuideVec>& guide,
+                            const Mat_<SrcVec>& source,
+                            Mat& dst,
+                            double sigmaSpatial, double sigmaColor,
+                            int mode, int numPasses
+                            )
+{
+    DTFilterCPU *dtf = DTFilterCPU::create_p_<GuideVec>(guide, sigmaSpatial, sigmaColor, mode, numPasses);
+    dtf->filter_<SrcVec>(source, dst);
+    delete dtf;
+}
+
+template<typename GuideVec, typename SrcVec>
+void domainTransformFilter( const Mat& guide,
+                            const Mat& source,
+                            Mat& dst,
+                            double sigmaSpatial, double sigmaColor,
+                            int mode, int numPasses
+                          )
+{
+    DTFilterCPU *dtf = DTFilterCPU::create_p_<GuideVec>(guide, sigmaSpatial, sigmaColor, mode, numPasses);
+    dtf->filter_<SrcVec>(source, dst);
+    delete dtf;
+}
+
+}
+}
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edge_drawing.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edge_drawing.cpp
new file mode 100644
index 00000000..96f77357
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edge_drawing.cpp
@@ -0,0 +1,5755 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include "edge_drawing_common.hpp"
+
+using namespace std;
+
+namespace cv
+{
+namespace ximgproc
+{
+
+struct ComputeGradientBody : ParallelLoopBody
+{
+void operator() (const Range& range) const CV_OVERRIDE;
+
+Mat_<uchar> src;
+mutable Mat_<ushort> gradImage;
+mutable Mat_<uchar> dirImage;
+int gradThresh;
+int op;
+bool SumFlag;
+int* grads;
+bool PFmode;
+};
+
+void ComputeGradientBody::operator() (const Range& range) const
+{
+    const int last_col = src.cols - 1;
+    int gx = 0;
+    int gy = 0;
+    int sum;
+
+    for (int y = range.start; y < range.end; ++y)
+    {
+        const uchar* srcPrevRow = src[y - 1];
+        const uchar* srcCurRow = src[y];
+        const uchar* srcNextRow = src[y + 1];
+
+        ushort* gradRow = gradImage[y];
+        uchar* dirRow = dirImage[y];
+
+        for (int x = 1; x < last_col; ++x)
+        {
+            int com1 = srcNextRow[x + 1] - srcPrevRow[x - 1];
+            int com2 = srcPrevRow[x + 1] - srcNextRow[x - 1];
+
+            switch (op)
+            {
+            case EdgeDrawing::PREWITT:
+                gx = abs(com1 + com2 + srcCurRow[x + 1] - srcCurRow[x - 1]);
+                gy = abs(com1 - com2 + srcNextRow[x] - srcPrevRow[x]);
+                break;
+            case EdgeDrawing::SOBEL:
+                gx = abs(com1 + com2 + 2 * (srcCurRow[x + 1] - srcCurRow[x - 1]));
+                gy = abs(com1 - com2 + 2 * (srcNextRow[x] - srcPrevRow[x]));
+                break;
+            case EdgeDrawing::SCHARR:
+                gx = abs(3 * (com1 + com2) + 10 * (srcCurRow[x + 1] - srcCurRow[x - 1]));
+                gy = abs(3 * (com1 - com2) + 10 * (srcNextRow[x] - srcPrevRow[x]));
+                break;
+            case EdgeDrawing::LSD:
+                // com1 and com2 differs from previous operators, because LSD has 2x2 kernel
+                com1 = srcNextRow[x + 1] - srcCurRow[x];
+                com2 = srcCurRow[x + 1] - srcNextRow[x];
+
+                gx = abs(com1 + com2);
+                gy = abs(com1 - com2);
+                break;
+            }
+
+            if (SumFlag)
+                sum = gx + gy;
+            else
+                sum = (int)sqrt((double)gx * gx + gy * gy);
+
+            gradRow[x] = (ushort)sum;
+
+            if (PFmode)
+                grads[sum]++;
+
+            if (sum >= gradThresh)
+            {
+                if (gx >= gy)
+                    dirRow[x] = EDGE_VERTICAL;
+                else
+                    dirRow[x] = EDGE_HORIZONTAL;
+            }
+        }
+    }
+}
+
+class EdgeDrawingImpl : public EdgeDrawing
+{
+public:
+
+    enum EllipseFittingMethods
+    {
+        BOOKSTEIN = 0,
+        FPF = 1
+    };
+
+    EdgeDrawingImpl();
+    ~EdgeDrawingImpl();
+    void detectEdges(InputArray src) CV_OVERRIDE;
+    void getEdgeImage(OutputArray dst) CV_OVERRIDE;
+    void getGradientImage(OutputArray dst) CV_OVERRIDE;
+
+    vector<vector<Point> > getSegments() CV_OVERRIDE;
+    vector<int> getSegmentIndicesOfLines() const CV_OVERRIDE;
+    void detectLines(OutputArray lines) CV_OVERRIDE;
+    void detectEllipses(OutputArray ellipses) CV_OVERRIDE;
+
+    virtual String getDefaultName() const CV_OVERRIDE;
+    virtual void read(const FileNode& fn) CV_OVERRIDE;
+    virtual void write(FileStorage& fs) const CV_OVERRIDE;
+
+protected:
+    int width;        // width of source image
+    int height;       // height of source image
+    uchar *srcImg;
+    vector<vector<Point> > segmentPoints;
+    vector<int> segmentIndicesOfLines;
+    Mat smoothImage;
+    uchar *edgeImg;   // pointer to edge image data
+    uchar *smoothImg; // pointer to smoothed image data
+    int segmentNos;
+    Mat srcImage;
+
+    double divForTestSegment;
+    double* dH;
+    int* grads;
+    int np;
+
+private:
+    void ComputeGradient();
+    void ComputeAnchorPoints();
+    void JoinAnchorPointsUsingSortedAnchors();
+    int* sortAnchorsByGradValue1();
+
+    static int LongestChain(Chain *chains, int root);
+    static int RetrieveChainNos(Chain *chains, int root, int chainNos[]);
+
+    int anchorNos;
+    vector<Point> anchorPoints;
+    vector<Point> edgePoints;
+
+    Mat edgeImage;
+    Mat gradImage;
+    Mat dirImage;
+    uchar *dirImg;    // pointer to direction image data
+    ushort *gradImg;   // pointer to gradient image data
+
+    int op;           // edge detection operator
+    int gradThresh;   // gradient threshold
+    int anchorThresh; // anchor point threshold
+
+    std::vector<EDLineSegment> lines;
+    int linesNo;
+    int min_line_len;
+    double line_error;
+    double max_distance_between_two_lines;
+    double max_error;
+    double precision;
+    NFALUT* nfa;
+
+    int ComputeMinLineLength();
+    void SplitSegment2Lines(double* x, double* y, int noPixels, int segmentNo);
+    void JoinCollinearLines();
+
+    void ValidateLineSegments();
+    bool ValidateLineSegmentRect(int* x, int* y, EDLineSegment* ls);
+    bool TryToJoinTwoLineSegments(EDLineSegment* ls1, EDLineSegment* ls2, int changeIndex);
+
+    static double ComputeMinDistance(double x1, double y1, double a, double b, int invert);
+    static void ComputeClosestPoint(double x1, double y1, double a, double b, int invert, double& xOut, double& yOut);
+    static void LineFit(double* x, double* y, int count, double& a, double& b, int invert);
+    static void LineFit(double* x, double* y, int count, double& a, double& b, double& e, int& invert);
+    static double ComputeMinDistanceBetweenTwoLines(EDLineSegment* ls1, EDLineSegment* ls2, int* pwhich);
+    static void UpdateLineParameters(EDLineSegment* ls);
+    static void EnumerateRectPoints(double sx, double sy, double ex, double ey, int ptsx[], int ptsy[], int* pNoPoints);
+
+    void TestSegment(int i, int index1, int index2);
+    void ExtractNewSegments();
+    double NFA(double prob, int len);
+
+    int noEllipses;
+    int noCircles;
+    std::vector<mCircle> Circles;
+    std::vector<mEllipse> Ellipses;
+
+    Circle* circles1;
+    Circle* circles2;
+    Circle* circles3;
+    int noCircles1;
+    int noCircles2;
+    int noCircles3;
+
+    EDArcs* edarcs1;
+    EDArcs* edarcs2;
+    EDArcs* edarcs3;
+    EDArcs* edarcs4;
+
+    int* segmentStartLines;
+    BufferManager* bm;
+    Info* info;
+
+    void GenerateCandidateCircles();
+    void DetectArcs();
+    void ValidateCircles(bool validate);
+    void JoinCircles();
+    void JoinArcs1();
+    void JoinArcs2();
+    void JoinArcs3();
+
+    // circle utility functions
+    static void addCircle(Circle* circles, int& noCircles, double xc, double yc, double r, double circleFitError, double* x, double* y, int noPixels);
+    static void addCircle(Circle* circles, int& noCircles, double xc, double yc, double r, double circleFitError, EllipseEquation* pEq, double ellipseFitError, double* x, double* y, int noPixels);
+    static void sortCircles(Circle* circles, int noCircles);
+    static bool CircleFit(double* x, double* y, int N, double* pxc, double* pyc, double* pr, double* pe);
+    static void ComputeCirclePoints(double xc, double yc, double r, double* px, double* py, int* noPoints);
+
+    // ellipse utility functions
+    static bool EllipseFit(double* x, double* y, int noPoints, EllipseEquation* pResult, int mode = FPF);
+    static double** AllocateMatrix(int noRows, int noColumns);
+    static void A_TperB(double** A_, double** B_, double** _res, int _righA, int _colA, int _righB, int _colB);
+    static void choldc(double** a, int n, double** l);
+    static int inverse(double** TB, double** InvB, int N);
+    static void DeallocateMatrix(double** m, int noRows);
+    static void AperB_T(double** A_, double** B_, double** _res, int _righA, int _colA, int _righB, int _colB);
+    static void AperB(double** A_, double** B_, double** _res, int _righA, int _colA, int _righB, int _colB);
+    static void jacobi(double** a, int n, double d[], double** v);
+    static void ROTATE(double** a, int i, int j, int k, int l, double tau, double s);
+    static double computeEllipsePerimeter(EllipseEquation* eq);
+    static double ComputeEllipseError(EllipseEquation* eq, double* px, double* py, int noPoints);
+    static double ComputeEllipseCenterAndAxisLengths(EllipseEquation* eq, double* pxc, double* pyc, double* pmajorAxisLength, double* pminorAxisLength);
+    static void ComputeEllipsePoints(double* pvec, double* px, double* py, int noPoints);
+
+    // arc utility functions
+    static void joinLastTwoArcs(MyArc* arcs, int& noArcs);
+    static void addArc(MyArc* arcs, int& noArchs, double xc, double yc, double r, double circleFitError, // Circular arc
+        double sTheta, double eTheta, int turn, int segmentNo,
+        int sx, int sy, int ex, int ey,
+        double* x, double* y, int noPixels, double overlapRatio = 0.0);
+    static void addArc(MyArc* arcs, int& noArchs, double xc, double yc, double r, double circleFitError, // Elliptic arc
+        double sTheta, double eTheta, int turn, int segmentNo,
+        EllipseEquation* pEq, double ellipseFitError,
+        int sx, int sy, int ex, int ey,
+        double* x, double* y, int noPixels, double overlapRatio = 0.0);
+
+    static void ComputeStartAndEndAngles(double xc, double yc, double r,
+        double* x, double* y, int len,
+        double* psTheta, double* peTheta);
+
+    static void sortArc(MyArc* arcs, int noArcs);
+};
+
+Ptr<EdgeDrawing> createEdgeDrawing()
+{
+    return makePtr<EdgeDrawingImpl>();
+}
+
+EdgeDrawing::Params::Params()
+{
+    PFmode = false;
+    EdgeDetectionOperator = PREWITT;
+    GradientThresholdValue = 20;
+    AnchorThresholdValue = 0;
+    ScanInterval = 1;
+    MinPathLength = 10;
+    Sigma = 1.0;
+    SumFlag = true;
+    NFAValidation = true;
+    MinLineLength = -1;
+    MaxDistanceBetweenTwoLines = 6.0;
+    LineFitErrorThreshold = 1.0;
+    MaxErrorThreshold = 1.3;
+}
+
+void EdgeDrawing::setParams(const EdgeDrawing::Params& parameters)
+{
+    params = parameters;
+}
+
+void EdgeDrawing::Params::read(const cv::FileNode& fn)
+{
+    PFmode = (int)fn["PFmode"] != 0 ? true : false;
+    EdgeDetectionOperator = fn["EdgeDetectionOperator"];
+    GradientThresholdValue = fn["GradientThresholdValue"];
+    AnchorThresholdValue = fn["AnchorThresholdValue"];
+    ScanInterval = fn["ScanInterval"];
+    MinPathLength = fn["MinPathLength"];
+    Sigma = fn["Sigma"];
+    SumFlag = (int)fn["SumFlag"] != 0 ? true : false;
+    NFAValidation = (int)fn["NFAValidation"] != 0 ? true : false;
+    MinLineLength = fn["MinLineLength"];
+    MaxDistanceBetweenTwoLines = fn["MaxDistanceBetweenTwoLines"];
+    LineFitErrorThreshold = fn["LineFitErrorThreshold"];
+    MaxErrorThreshold = fn["MaxErrorThreshold"];
+}
+
+void EdgeDrawing::Params::write(cv::FileStorage& fs) const
+{
+    fs << "PFmode" << PFmode;
+    fs << "EdgeDetectionOperator" << EdgeDetectionOperator;
+    fs << "GradientThresholdValue" << GradientThresholdValue;
+    fs << "AnchorThresholdValue" << AnchorThresholdValue;
+    fs << "ScanInterval" << ScanInterval;
+    fs << "MinPathLength" << MinPathLength;
+    fs << "Sigma" << Sigma;
+    fs << "SumFlag" << SumFlag;
+    fs << "NFAValidation" << NFAValidation;
+    fs << "MinLineLength" << MinLineLength;
+    fs << "MaxDistanceBetweenTwoLines" << MaxDistanceBetweenTwoLines;
+    fs << "LineFitErrorThreshold" << LineFitErrorThreshold;
+    fs << "MaxErrorThreshold" << MaxErrorThreshold;
+}
+
+String EdgeDrawingImpl::getDefaultName() const
+{
+    return String("EdgeDrawing");
+}
+
+void EdgeDrawingImpl::read(const cv::FileNode& fn)
+{
+    params.read(fn);
+}
+
+void EdgeDrawingImpl::write(cv::FileStorage& fs) const
+{
+    writeFormat(fs);
+    params.write(fs);
+}
+
+EdgeDrawingImpl::EdgeDrawingImpl()
+{
+    params = EdgeDrawing::Params();
+    nfa = new NFALUT(1, 1/2, 1, 1);
+    dH = new double[MAX_GRAD_VALUE];
+    grads = new int[MAX_GRAD_VALUE];
+}
+
+EdgeDrawingImpl::~EdgeDrawingImpl()
+{
+    delete nfa;
+    delete[] dH;
+    delete[] grads;
+}
+
+void EdgeDrawingImpl::detectEdges(InputArray src)
+{
+    CV_Assert(!src.empty() && src.type() == CV_8UC1);
+    gradThresh = params.GradientThresholdValue;
+    anchorThresh = params.AnchorThresholdValue;
+    op = params.EdgeDetectionOperator;
+
+    // Check parameters for sanity
+    if (op < 0 || op > 3)
+        op = 0;
+
+    if (gradThresh < 1)
+        gradThresh = 1;
+
+    if (anchorThresh < 0)
+        anchorThresh = 0;
+
+    segmentNos = 0;
+    anchorNos = 0;
+    anchorPoints.clear();
+    lines.clear();
+    segmentPoints.clear();
+    segmentPoints.push_back(vector<Point>()); // create empty vector of points for segments
+    srcImage = src.getMat();
+    srcImg = srcImage.data;
+    height = srcImage.rows;
+    width = srcImage.cols;
+
+    edgeImage = Mat(height, width, CV_8UC1, Scalar(0)); // initialize edge Image
+    gradImage = Mat(height, width, CV_16UC1); // gradImage contains short values
+    dirImage = Mat(height, width, CV_8UC1);
+
+    if (params.Sigma < 1.0)
+        smoothImage = srcImage;
+    else if (params.Sigma == 1.0)
+        GaussianBlur(srcImage, smoothImage, Size(5, 5), params.Sigma);
+    else
+        GaussianBlur(srcImage, smoothImage, Size(), params.Sigma); // calculate kernel from sigma
+
+    // Assign Pointers from Mat's data
+    smoothImg = smoothImage.data;
+    gradImg = (ushort*)gradImage.data;
+    edgeImg = edgeImage.data;
+    dirImg = dirImage.data;
+
+    if (params.PFmode)
+    {
+        memset(dH, 0, sizeof(double) * MAX_GRAD_VALUE);
+        memset(grads, 0, sizeof(int) * MAX_GRAD_VALUE);
+    }
+
+    ComputeGradient();                    // COMPUTE GRADIENT & EDGE DIRECTION MAPS
+    ComputeAnchorPoints();                // COMPUTE ANCHORS
+    JoinAnchorPointsUsingSortedAnchors(); // JOIN ANCHORS
+
+    if (params.PFmode)
+    {
+        // Compute probability function H
+        int size = (width - 2) * (height - 2);
+
+        for (int i = MAX_GRAD_VALUE - 1; i > 0; i--)
+            grads[i - 1] += grads[i];
+
+        for (int i = 0; i < MAX_GRAD_VALUE; i++)
+            dH[i] = (double)grads[i] / ((double)size);
+
+        divForTestSegment = 2.25; // Some magic number :-)
+        memset(edgeImg, 0, width * height); // clear edge image
+        np = 0;
+        for (int i = 0; i < segmentNos; i++)
+        {
+            int len = (int)segmentPoints[i].size();
+            np += (len * (len - 1)) / 2;
+        }
+
+        // Validate segments
+        for (int i = 0; i < segmentNos; i++)
+            TestSegment(i, 0, (int)segmentPoints[i].size() - 1);
+
+        ExtractNewSegments();
+    }
+}
+
+void EdgeDrawingImpl::getEdgeImage(OutputArray _dst)
+{
+    if (!edgeImage.empty())
+        edgeImage.copyTo(_dst);
+}
+
+void EdgeDrawingImpl::getGradientImage(OutputArray _dst)
+{
+    if (!gradImage.empty())
+        gradImage.copyTo(_dst);
+}
+
+std::vector<std::vector<Point> > EdgeDrawingImpl::getSegments()
+{
+    return segmentPoints;
+}
+
+std::vector<int> EdgeDrawingImpl::getSegmentIndicesOfLines() const
+{
+    return segmentIndicesOfLines;
+}
+
+void EdgeDrawingImpl::ComputeGradient()
+{
+    for (int j = 0; j < width; j++)
+    {
+        gradImg[j] = gradImg[(height - 1) * width + j] = (ushort)gradThresh - 1;
+    }
+
+    for (int i = 1; i < height - 1; i++)
+    {
+        gradImg[i * width] = gradImg[(i + 1) * width - 1] = (ushort)gradThresh - 1;
+    }
+
+    ComputeGradientBody body;
+    body.src = smoothImage;
+    body.gradImage = gradImage;
+    body.dirImage = dirImage;
+    body.gradThresh = gradThresh;
+    body.SumFlag = params.SumFlag;
+    body.op = op;
+    body.grads = grads;
+    body.PFmode = params.PFmode;
+
+    parallel_for_(Range(1, smoothImage.rows - 1), body);
+}
+
+void EdgeDrawingImpl::ComputeAnchorPoints()
+{
+    for (int i = 2; i < height - 2; i++)
+    {
+        int start = 2;
+        int inc = 1;
+        if (i % params.ScanInterval != 0)
+        {
+            start = params.ScanInterval;
+            inc = params.ScanInterval;
+        }
+
+        for (int j = start; j < width - 2; j += inc)
+        {
+            if (gradImg[i * width + j] < gradThresh)
+                continue;
+
+            if (dirImg[i * width + j] == EDGE_VERTICAL)
+            {
+                // vertical edge
+                int diff1 = gradImg[i * width + j] - gradImg[i * width + j - 1];
+                int diff2 = gradImg[i * width + j] - gradImg[i * width + j + 1];
+                if (diff1 >= anchorThresh && diff2 >= anchorThresh)
+                {
+                    edgeImg[i * width + j] = ANCHOR_PIXEL;
+                    anchorPoints.push_back(Point(j, i));
+                }
+            }
+            else
+            {
+                // horizontal edge
+                int diff1 = gradImg[i * width + j] - gradImg[(i - 1) * width + j];
+                int diff2 = gradImg[i * width + j] - gradImg[(i + 1) * width + j];
+                if (diff1 >= anchorThresh && diff2 >= anchorThresh)
+                {
+                    edgeImg[i * width + j] = ANCHOR_PIXEL;
+                    anchorPoints.push_back(Point(j, i));
+                }
+            }
+        }
+    }
+
+    anchorNos = (int)anchorPoints.size(); // get the total number of anchor points
+}
+
+void EdgeDrawingImpl::JoinAnchorPointsUsingSortedAnchors()
+{
+    int* chainNos = new int[(width + height) * 8];
+
+    Point* pixels = new Point[width * height];
+    StackNode* stack = new StackNode[width * height];
+    Chain* chains = new Chain[width * height];
+
+    // sort the anchor points by their gradient value in decreasing order
+    int* pAnchors = sortAnchorsByGradValue1();
+
+    // Now join the anchors starting with the anchor having the greatest gradient value
+
+    for (int k0 = anchorNos - 1; k0 >= 0; k0--)
+    {
+        int pixelOffset = pAnchors[k0];
+
+        int i = pixelOffset / width;
+        int j = pixelOffset % width;
+
+        if (edgeImg[i * width + j] != ANCHOR_PIXEL)
+            continue;
+
+        chains[0].len = 0;
+        chains[0].parent = -1;
+        chains[0].dir = 0;
+        chains[0].children[0] = chains[0].children[1] = -1;
+        chains[0].pixels = NULL;
+
+        int noChains = 1;
+        int len = 0;
+        int duplicatePixelCount = 0;
+        int top = -1;  // top of the stack
+
+        if (dirImg[i * width + j] == EDGE_VERTICAL)
+        {
+            stack[++top].r = i;
+            stack[top].c = j;
+            stack[top].dir = DOWN;
+            stack[top].parent = 0;
+
+            stack[++top].r = i;
+            stack[top].c = j;
+            stack[top].dir = UP;
+            stack[top].parent = 0;
+        }
+        else
+        {
+            stack[++top].r = i;
+            stack[top].c = j;
+            stack[top].dir = RIGHT;
+            stack[top].parent = 0;
+
+            stack[++top].r = i;
+            stack[top].c = j;
+            stack[top].dir = LEFT;
+            stack[top].parent = 0;
+        }
+
+        // While the stack is not empty
+StartOfWhile:
+        while (top >= 0)
+        {
+            int r = stack[top].r;
+            int c = stack[top].c;
+            int dir = stack[top].dir;
+            int parent = stack[top].parent;
+            top--;
+
+            if (edgeImg[r * width + c] != EDGE_PIXEL)
+                duplicatePixelCount++;
+
+            chains[noChains].dir = dir;   // traversal direction
+            chains[noChains].parent = parent;
+            chains[noChains].children[0] = chains[noChains].children[1] = -1;
+
+            int chainLen = 0;
+
+            chains[noChains].pixels = &pixels[len];
+
+            pixels[len].y = r;
+            pixels[len].x = c;
+            len++;
+            chainLen++;
+
+            if (dir == LEFT)
+            {
+                while (dirImg[r * width + c] == EDGE_HORIZONTAL)
+                {
+                    edgeImg[r * width + c] = EDGE_PIXEL;
+
+                    // The edge is horizontal. Look LEFT
+                    //
+                    //   A
+                    //   B x
+                    //   C
+                    //
+                    // cleanup up & down pixels
+                    if (edgeImg[(r - 1) * width + c] == ANCHOR_PIXEL)
+                        edgeImg[(r - 1) * width + c] = 0;
+                    if (edgeImg[(r + 1) * width + c] == ANCHOR_PIXEL)
+                        edgeImg[(r + 1) * width + c] = 0;
+
+                    // Look if there is an edge pixel in the neighbors
+                    if (edgeImg[r * width + c - 1] >= ANCHOR_PIXEL)
+                    {
+                        c--;
+                    }
+                    else if (edgeImg[(r - 1) * width + c - 1] >= ANCHOR_PIXEL)
+                    {
+                        r--;
+                        c--;
+                    }
+                    else if (edgeImg[(r + 1) * width + c - 1] >= ANCHOR_PIXEL)
+                    {
+                        r++;
+                        c--;
+                    }
+                    else
+                    {
+                        // else -- follow max. pixel to the LEFT
+                        int A = gradImg[(r - 1) * width + c - 1];
+                        int B = gradImg[r * width + c - 1];
+                        int C = gradImg[(r + 1) * width + c - 1];
+
+                        if (A > B)
+                        {
+                            if (A > C)
+                                r--;
+                            else
+                                r++;
+                        }
+                        else  if (C > B)
+                            r++;
+                        c--;
+                    }
+
+                    if (edgeImg[r * width + c] == EDGE_PIXEL || gradImg[r * width + c] < gradThresh)
+                    {
+                        if (chainLen > 0)
+                        {
+                            chains[noChains].len = chainLen;
+                            chains[parent].children[0] = noChains;
+                            noChains++;
+                        }
+                        goto StartOfWhile;
+                    }
+
+                    pixels[len].y = r;
+                    pixels[len].x = c;
+                    len++;
+                    chainLen++;
+                }
+
+                stack[++top].r = r;
+                stack[top].c = c;
+                stack[top].dir = DOWN;
+                stack[top].parent = noChains;
+
+                stack[++top].r = r;
+                stack[top].c = c;
+                stack[top].dir = UP;
+                stack[top].parent = noChains;
+
+                len--;
+                chainLen--;
+
+                chains[noChains].len = chainLen;
+                chains[parent].children[0] = noChains;
+                noChains++;
+            }
+            else if (dir == RIGHT)
+            {
+                while (dirImg[r * width + c] == EDGE_HORIZONTAL)
+                {
+                    edgeImg[r * width + c] = EDGE_PIXEL;
+
+                    // The edge is horizontal. Look RIGHT
+                    //
+                    //     A
+                    //   x B
+                    //     C
+                    //
+                    // cleanup up&down pixels
+                    if (edgeImg[(r + 1) * width + c] == ANCHOR_PIXEL)
+                        edgeImg[(r + 1) * width + c] = 0;
+                    if (edgeImg[(r - 1) * width + c] == ANCHOR_PIXEL)
+                        edgeImg[(r - 1) * width + c] = 0;
+
+                    // Look if there is an edge pixel in the neighbors
+                    if (edgeImg[r * width + c + 1] >= ANCHOR_PIXEL)
+                    {
+                        c++;
+                    }
+                    else if (edgeImg[(r + 1) * width + c + 1] >= ANCHOR_PIXEL)
+                    {
+                        r++;
+                        c++;
+                    }
+                    else if (edgeImg[(r - 1) * width + c + 1] >= ANCHOR_PIXEL)
+                    {
+                        r--;
+                        c++;
+                    }
+                    else
+                    {
+                        // else -- follow max. pixel to the RIGHT
+                        int A = gradImg[(r - 1) * width + c + 1];
+                        int B = gradImg[r * width + c + 1];
+                        int C = gradImg[(r + 1) * width + c + 1];
+
+                        if (A > B)
+                        {
+                            if (A > C)
+                                r--;       // A
+                            else
+                                r++;       // C
+                        }
+                        else if (C > B)
+                            r++;  // C
+                        c++;
+                    }
+
+                    if (edgeImg[r * width + c] == EDGE_PIXEL || gradImg[r * width + c] < gradThresh)
+                    {
+                        if (chainLen > 0)
+                        {
+                            chains[noChains].len = chainLen;
+                            chains[parent].children[1] = noChains;
+                            noChains++;
+                        }
+                        goto StartOfWhile;
+                    }
+
+                    pixels[len].y = r;
+                    pixels[len].x = c;
+                    len++;
+                    chainLen++;
+                }
+
+                stack[++top].r = r;
+                stack[top].c = c;
+                stack[top].dir = DOWN;  // Go down
+                stack[top].parent = noChains;
+
+                stack[++top].r = r;
+                stack[top].c = c;
+                stack[top].dir = UP;   // Go up
+                stack[top].parent = noChains;
+
+                len--;
+                chainLen--;
+
+                chains[noChains].len = chainLen;
+                chains[parent].children[1] = noChains;
+                noChains++;
+
+            }
+            else if (dir == UP)
+            {
+                while (dirImg[r * width + c] == EDGE_VERTICAL)
+                {
+                    edgeImg[r * width + c] = EDGE_PIXEL;
+
+                    // The edge is vertical. Look UP
+                    //
+                    //   A B C
+                    //     x
+                    //
+                    // Cleanup left & right pixels
+                    if (edgeImg[r * width + c - 1] == ANCHOR_PIXEL)
+                        edgeImg[r * width + c - 1] = 0;
+                    if (edgeImg[r * width + c + 1] == ANCHOR_PIXEL)
+                        edgeImg[r * width + c + 1] = 0;
+
+                    // Look if there is an edge pixel in the neighbors
+                    if (edgeImg[(r - 1) * width + c] >= ANCHOR_PIXEL)
+                    {
+                        r--;
+                    }
+                    else if (edgeImg[(r - 1) * width + c - 1] >= ANCHOR_PIXEL)
+                    {
+                        r--;
+                        c--;
+                    }
+                    else if (edgeImg[(r - 1) * width + c + 1] >= ANCHOR_PIXEL)
+                    {
+                        r--;
+                        c++;
+                    }
+                    else
+                    {
+                        // else -- follow the max. pixel UP
+                        int A = gradImg[(r - 1) * width + c - 1];
+                        int B = gradImg[(r - 1) * width + c];
+                        int C = gradImg[(r - 1) * width + c + 1];
+
+                        if (A > B)
+                        {
+                            if (A > C)
+                                c--;
+                            else
+                                c++;
+                        }
+                        else if (C > B)
+                            c++;
+                        r--;
+                    }
+
+                    if (edgeImg[r * width + c] == EDGE_PIXEL || gradImg[r * width + c] < gradThresh)
+                    {
+                        if (chainLen > 0)
+                        {
+                            chains[noChains].len = chainLen;
+                            chains[parent].children[0] = noChains;
+                            noChains++;
+                        }
+                        goto StartOfWhile;
+                    }
+
+                    pixels[len].y = r;
+                    pixels[len].x = c;
+
+                    len++;
+                    chainLen++;
+                }
+
+                stack[++top].r = r;
+                stack[top].c = c;
+                stack[top].dir = RIGHT;
+                stack[top].parent = noChains;
+
+                stack[++top].r = r;
+                stack[top].c = c;
+                stack[top].dir = LEFT;
+                stack[top].parent = noChains;
+
+                len--;
+                chainLen--;
+
+                chains[noChains].len = chainLen;
+                chains[parent].children[0] = noChains;
+                noChains++;
+            }
+            else   // dir == DOWN
+            {
+                while (dirImg[r * width + c] == EDGE_VERTICAL)
+                {
+                    edgeImg[r * width + c] = EDGE_PIXEL;
+
+                    // The edge is vertical
+                    //
+                    //     x
+                    //   A B C
+                    //
+                    // cleanup side pixels
+                    if (edgeImg[r * width + c + 1] == ANCHOR_PIXEL)
+                        edgeImg[r * width + c + 1] = 0;
+                    if (edgeImg[r * width + c - 1] == ANCHOR_PIXEL)
+                        edgeImg[r * width + c - 1] = 0;
+
+                    // Look if there is an edge pixel in the neighbors
+                    if (edgeImg[(r + 1) * width + c] >= ANCHOR_PIXEL)
+                    {
+                        r++;
+                    }
+                    else if (edgeImg[(r + 1) * width + c + 1] >= ANCHOR_PIXEL)
+                    {
+                        r++;
+                        c++;
+                    }
+                    else if (edgeImg[(r + 1) * width + c - 1] >= ANCHOR_PIXEL)
+                    {
+                        r++;
+                        c--;
+                    }
+                    else
+                    {
+                        // else -- follow the max. pixel DOWN
+                        int A = gradImg[(r + 1) * width + c - 1];
+                        int B = gradImg[(r + 1) * width + c];
+                        int C = gradImg[(r + 1) * width + c + 1];
+
+                        if (A > B)
+                        {
+                            if (A > C)
+                                c--;       // A
+                            else
+                                c++;       // C
+                        }
+                        else if (C > B)
+                            c++;  // C
+                        r++;
+                    }
+
+                    if (edgeImg[r * width + c] == EDGE_PIXEL || gradImg[r * width + c] < gradThresh)
+                    {
+                        if (chainLen > 0)
+                        {
+                            chains[noChains].len = chainLen;
+                            chains[parent].children[1] = noChains;
+                            noChains++;
+                        }
+                        goto StartOfWhile;
+                    }
+
+                    pixels[len].y = r;
+                    pixels[len].x = c;
+
+                    len++;
+                    chainLen++;
+                }
+
+                stack[++top].r = r;
+                stack[top].c = c;
+                stack[top].dir = RIGHT;
+                stack[top].parent = noChains;
+
+                stack[++top].r = r;
+                stack[top].c = c;
+                stack[top].dir = LEFT;
+                stack[top].parent = noChains;
+
+                len--;
+                chainLen--;
+
+                chains[noChains].len = chainLen;
+                chains[parent].children[1] = noChains;
+                noChains++;
+            }
+        }
+
+        if (len - duplicatePixelCount < params.MinPathLength)
+        {
+            for (int k1 = 0; k1 < len; k1++)
+            {
+                edgeImg[pixels[k1].y * width + pixels[k1].x] = 0;
+                edgeImg[pixels[k1].y * width + pixels[k1].x] = 0;
+            }
+        }
+        else
+        {
+            int noSegmentPixels = 0;
+            int totalLen = LongestChain(chains, chains[0].children[1]);
+
+            if (totalLen > 0)
+            {
+                // Retrieve the chainNos
+                int count = RetrieveChainNos(chains, chains[0].children[1], chainNos);
+
+                // Copy these pixels in the reverse order
+                for (int k2 = count - 1; k2 >= 0; k2--)
+                {
+                    int chainNo = chainNos[k2];
+
+                    /* See if we can erase some pixels from the last chain. This is for cleanup */
+
+                    int fr = chains[chainNo].pixels[chains[chainNo].len - 1].y;
+                    int fc = chains[chainNo].pixels[chains[chainNo].len - 1].x;
+
+                    int index = noSegmentPixels - 2;
+                    while (index >= 0)
+                    {
+                        int dr = abs(fr - segmentPoints[segmentNos][index].y);
+                        int dc = abs(fc - segmentPoints[segmentNos][index].x);
+
+                        if (dr <= 1 && dc <= 1)
+                        {
+                            // neighbors. Erase last pixel
+                            segmentPoints[segmentNos].pop_back();
+                            noSegmentPixels--;
+                            index--;
+                        }
+                        else
+                            break;
+                    }
+
+                    if (chains[chainNo].len > 1 && noSegmentPixels > 0)
+                    {
+                        fr = chains[chainNo].pixels[chains[chainNo].len - 2].y;
+                        fc = chains[chainNo].pixels[chains[chainNo].len - 2].x;
+
+                        int dr = abs(fr - segmentPoints[segmentNos][noSegmentPixels - 1].y);
+                        int dc = abs(fc - segmentPoints[segmentNos][noSegmentPixels - 1].x);
+
+                        if (dr <= 1 && dc <= 1)
+                            chains[chainNo].len--;
+                    }
+
+                    for (int l = chains[chainNo].len - 1; l >= 0; l--)
+                    {
+                        segmentPoints[segmentNos].push_back(chains[chainNo].pixels[l]);
+                        noSegmentPixels++;
+                    }
+
+                    chains[chainNo].len = 0;  // Mark as copied
+                }
+            }
+
+            totalLen = LongestChain(chains, chains[0].children[0]);
+            if (totalLen > 1)
+            {
+                // Retrieve the chainNos
+                int count = RetrieveChainNos(chains, chains[0].children[0], chainNos);
+
+                // Copy these chains in the forward direction. Skip the first pixel of the first chain
+                // due to repetition with the last pixel of the previous chain
+                int lastChainNo = chainNos[0];
+                chains[lastChainNo].pixels++;
+                chains[lastChainNo].len--;
+
+                for (int k3 = 0; k3 < count; k3++)
+                {
+                    int chainNo = chainNos[k3];
+
+                    /* See if we can erase some pixels from the last chain. This is for cleanup */
+                    int fr = chains[chainNo].pixels[0].y;
+                    int fc = chains[chainNo].pixels[0].x;
+
+                    int index = noSegmentPixels - 2;
+                    while (index >= 0)
+                    {
+                        int dr = abs(fr - segmentPoints[segmentNos][index].y);
+                        int dc = abs(fc - segmentPoints[segmentNos][index].x);
+
+                        if (dr <= 1 && dc <= 1)
+                        {
+                            // neighbors. Erase last pixel
+                            segmentPoints[segmentNos].pop_back();
+                            noSegmentPixels--;
+                            index--;
+                        }
+                        else
+                            break;
+                    }
+
+                    int startIndex = 0;
+                    int chainLen = chains[chainNo].len;
+                    if (chainLen > 1 && noSegmentPixels > 0)
+                    {
+                        fr = chains[chainNo].pixels[1].y;
+                        fc = chains[chainNo].pixels[1].x;
+
+                        int dr = abs(fr - segmentPoints[segmentNos][noSegmentPixels - 1].y);
+                        int dc = abs(fc - segmentPoints[segmentNos][noSegmentPixels - 1].x);
+
+                        if (dr <= 1 && dc <= 1)
+                        {
+                            startIndex = 1;
+                        }
+                    }
+
+                    /* Start a new chain & copy pixels from the new chain */
+                    for (int l = startIndex; l < chains[chainNo].len; l++)
+                    {
+                        segmentPoints[segmentNos].push_back(chains[chainNo].pixels[l]);
+                        noSegmentPixels++;
+                    }
+
+                    chains[chainNo].len = 0;  // Mark as copied
+                }
+            }
+
+            // See if the first pixel can be cleaned up
+            int fr = segmentPoints[segmentNos][1].y;
+            int fc = segmentPoints[segmentNos][1].x;
+
+            int dr = abs(fr - segmentPoints[segmentNos][noSegmentPixels - 1].y);
+            int dc = abs(fc - segmentPoints[segmentNos][noSegmentPixels - 1].x);
+
+            if (dr <= 1 && dc <= 1)
+            {
+                segmentPoints[segmentNos].erase(segmentPoints[segmentNos].begin());
+                noSegmentPixels--;
+            }
+
+            segmentNos++;
+            segmentPoints.push_back(vector<Point>()); // create empty vector of points for segments
+
+            // Copy the rest of the long chains here
+            for (int k4 = 2; k4 < noChains; k4++)
+            {
+                if (chains[k4].len < 2)
+                    continue;
+
+                totalLen = LongestChain(chains, k4);
+
+                if (totalLen >= 10)
+                {
+                    // Retrieve the chainNos
+                    int count = RetrieveChainNos(chains, k4, chainNos);
+
+                    // Copy the pixels
+                    noSegmentPixels = 0;
+                    for (int k5 = 0; k5 < count; k5++)
+                    {
+                        int chainNo = chainNos[k5];
+
+                        /* See if we can erase some pixels from the last chain. This is for cleanup */
+                        fr = chains[chainNo].pixels[0].y;
+                        fc = chains[chainNo].pixels[0].x;
+
+                        int index = noSegmentPixels - 2;
+                        while (index >= 0)
+                        {
+                            dr = abs(fr - segmentPoints[segmentNos][index].y);
+                            dc = abs(fc - segmentPoints[segmentNos][index].x);
+
+                            if (dr <= 1 && dc <= 1)
+                            {
+                                // neighbors. Erase last pixel
+                                segmentPoints[segmentNos].pop_back();
+                                noSegmentPixels--;
+                                index--;
+                            }
+                            else
+                                break;
+                        }
+
+                        int startIndex = 0;
+                        int chainLen = chains[chainNo].len;
+                        if (chainLen > 1 && noSegmentPixels > 0)
+                        {
+                            fr = chains[chainNo].pixels[1].y;
+                            fc = chains[chainNo].pixels[1].x;
+
+                            dr = abs(fr - segmentPoints[segmentNos][noSegmentPixels - 1].y);
+                            dc = abs(fc - segmentPoints[segmentNos][noSegmentPixels - 1].x);
+
+                            if (dr <= 1 && dc <= 1)
+                            {
+                                startIndex = 1;
+                            }
+                        }
+
+                        /* Start a new chain & copy pixels from the new chain */
+                        for (int l = startIndex; l < chains[chainNo].len; l++)
+                        {
+                            segmentPoints[segmentNos].push_back(chains[chainNo].pixels[l]);
+                            noSegmentPixels++;
+                        }
+
+                        chains[chainNo].len = 0;  // Mark as copied
+                    }
+                    segmentPoints.push_back(vector<Point>()); // create empty vector of points for segments
+                    segmentNos++;
+                }
+            }
+        }
+    }
+
+    // pop back last segment from vector
+    // because of one preallocation in the beginning, it will always empty
+    segmentPoints.pop_back();
+
+    // Clean up
+    delete[] pAnchors;
+    delete[] chains;
+    delete[] stack;
+    delete[] chainNos;
+    delete[] pixels;
+}
+
+int* EdgeDrawingImpl::sortAnchorsByGradValue1()
+{
+    int SIZE = 128 * 256;
+    int* C = new int[SIZE];
+    memset(C, 0, sizeof(int) * SIZE);
+
+    // Count the number of grad values
+    for (int i = 1; i < height - 1; i++)
+    {
+        for (int j = 1; j < width - 1; j++)
+        {
+            if (edgeImg[i * width + j] != ANCHOR_PIXEL)
+                continue;
+
+            int grad = gradImg[i * width + j];
+            C[grad]++;
+        }
+    }
+
+    // Compute indices
+    for (int i = 1; i < SIZE; i++)
+        C[i] += C[i - 1];
+
+    int noAnchors = C[SIZE - 1];
+    int* A = new int[noAnchors];
+
+    for (int i = 1; i < height - 1; i++)
+    {
+        for (int j = 1; j < width - 1; j++)
+        {
+            if (edgeImg[i * width + j] != ANCHOR_PIXEL)
+                continue;
+
+            int grad = gradImg[i * width + j];
+            int index = --C[grad];
+            A[index] = i * width + j;    // anchor's offset
+        }
+    }
+
+    delete[] C;
+    return A;
+}
+
+int EdgeDrawingImpl::LongestChain(Chain* chains, int root)
+{
+    if (root == -1 || chains[root].len == 0)
+        return 0;
+
+    int len0 = 0;
+    if (chains[root].children[0] != -1)
+        len0 = LongestChain(chains, chains[root].children[0]);
+
+    int len1 = 0;
+    if (chains[root].children[1] != -1)
+        len1 = LongestChain(chains, chains[root].children[1]);
+
+    int max = 0;
+
+    if (len0 >= len1)
+    {
+        max = len0;
+        chains[root].children[1] = -1;
+    }
+    else
+    {
+        max = len1;
+        chains[root].children[0] = -1;
+    }
+
+    return chains[root].len + max;
+}
+
+int EdgeDrawingImpl::RetrieveChainNos(Chain* chains, int root, int chainNos[])
+{
+    int count = 0;
+
+    while (root != -1)
+    {
+        chainNos[count] = root;
+        count++;
+
+        if (chains[root].children[0] != -1)
+            root = chains[root].children[0];
+        else
+            root = chains[root].children[1];
+    }
+
+    return count;
+}
+
+void EdgeDrawingImpl::detectLines(OutputArray _lines)
+{
+    std::vector<Vec4f> linePoints;
+    if (segmentPoints.size() < 1)
+    {
+        Mat(linePoints).copyTo(_lines);
+        return;
+    }
+
+    min_line_len = params.MinLineLength;
+    line_error = params.LineFitErrorThreshold;
+    max_distance_between_two_lines = params.MaxDistanceBetweenTwoLines;
+    max_error = params.MaxErrorThreshold;
+
+    if (min_line_len == -1) // If no initial value given, compute it
+        min_line_len = ComputeMinLineLength();
+
+    if (min_line_len < 9) // avoids small line segments in the result. Might be deleted!
+        min_line_len = 9;
+
+    // Temporary buffers used during line fitting
+    double* x = new double[(width + height) * 8];
+    double* y = new double[(width + height) * 8];
+
+    lines.clear();
+    linesNo = 0;
+
+    // Use the whole segment
+    for (size_t segmentNumber = 0; segmentNumber < segmentPoints.size(); segmentNumber++)
+    {
+        std::vector<Point> segment = segmentPoints[segmentNumber];
+        for (int k = 0; k < (int)segment.size(); k++)
+        {
+            x[k] = segment[k].x;
+            y[k] = segment[k].y;
+        }
+        SplitSegment2Lines(x, y, (int)segment.size(), (int)segmentNumber);
+    }
+
+    JoinCollinearLines();
+
+    if (params.NFAValidation)
+        ValidateLineSegments();
+
+    // Delete redundant space from lines
+    // Pop them back
+    int size = (int)lines.size();
+    for (int i = 1; i <= size - linesNo; i++)
+        lines.pop_back();
+
+    segmentIndicesOfLines.clear();
+    for (int i = 0; i < linesNo; i++)
+    {
+        Vec4f line((float)lines[i].sx, (float)lines[i].sy, (float)lines[i].ex, (float)lines[i].ey);
+        linePoints.push_back(line);
+        segmentIndicesOfLines.push_back(lines[i].segmentNo);
+    }
+    Mat(linePoints).copyTo(_lines);
+
+    delete[] x;
+    delete[] y;
+}
+
+// Computes the minimum line length using the NFA formula given width & height values
+int EdgeDrawingImpl::ComputeMinLineLength()
+{
+    // The reason we are dividing the theoretical minimum line length by 2 is because
+    // we now test short line segments by a line support region rectangle having width=2.
+    // This means that within a line support region rectangle for a line segment of length "l"
+    // there are "2*l" many pixels. Thus, a line segment of length "l" has a chance of getting
+    // validated by NFA.
+
+    double logNT = 2.0 * (log10((double)width) + log10((double)height));
+    return (int)round((-logNT / log10(0.125)) * 0.5);
+}
+
+//-----------------------------------------------------------------
+// Given a full segment of pixels, splits the chain to lines
+// This code is used when we use the whole segment of pixels
+//
+void EdgeDrawingImpl::SplitSegment2Lines(double* x, double* y, int noPixels, int segmentNo)
+{
+    // First pixel of the line segment within the segment of points
+    int firstPixelIndex = 0;
+
+    while (noPixels >= min_line_len)
+    {
+        // Start by fitting a line to MIN_LINE_LEN pixels
+        bool valid = false;
+        double lastA(0), lastB(0), error;
+        int lastInvert(0);
+
+        while (noPixels >= min_line_len)
+        {
+            LineFit(x, y, min_line_len, lastA, lastB, error, lastInvert);
+            if (error <= 0.5)
+            {
+                valid = true;
+                break;
+            }
+
+            noPixels -= 1;   // Go slowly
+            x += 1;
+            y += 1;
+            firstPixelIndex += 1;
+        }
+
+        if (valid == false)
+            return;
+
+        // Now try to extend this line
+        int index = min_line_len;
+        int len = min_line_len;
+
+        while (index < noPixels)
+        {
+            int startIndex = index;
+            int lastGoodIndex = index - 1;
+            int goodPixelCount = 0;
+            int badPixelCount = 0;
+
+            while (index < noPixels)
+            {
+                double d = ComputeMinDistance(x[index], y[index], lastA, lastB, lastInvert);
+
+                if (d <= line_error)
+                {
+                    lastGoodIndex = index;
+                    goodPixelCount++;
+                    badPixelCount = 0;
+                }
+                else
+                {
+                    badPixelCount++;
+                    if (badPixelCount >= 5)
+                        break;
+                }
+                index++;
+            }
+
+            if (goodPixelCount >= 2)
+            {
+                len += lastGoodIndex - startIndex + 1;
+                LineFit(x, y, len, lastA, lastB, lastInvert);  // faster LineFit
+                index = lastGoodIndex + 1;
+            }
+
+            if (goodPixelCount < 2 || index >= noPixels)
+            {
+                // End of a line segment. Compute the end points
+                double sx, sy, ex, ey;
+
+                index = 0;
+                while (ComputeMinDistance(x[index], y[index], lastA, lastB, lastInvert) > line_error)
+                    index++;
+                ComputeClosestPoint(x[index], y[index], lastA, lastB, lastInvert, sx, sy);
+                int noSkippedPixels = index;
+
+                index = lastGoodIndex;
+                while (ComputeMinDistance(x[index], y[index], lastA, lastB, lastInvert) > line_error)
+                    index--;
+                ComputeClosestPoint(x[index], y[index], lastA, lastB, lastInvert, ex, ey);
+
+                if ((sx == ex) & (sy == ey))
+                    break;
+
+                // Add the line segment to lines
+                lines.push_back(EDLineSegment(lastA, lastB, lastInvert, sx, sy, ex, ey, segmentNo, firstPixelIndex + noSkippedPixels, index - noSkippedPixels + 1));
+                linesNo++;
+                len = index + 1;
+
+                break;
+            }
+        }
+
+        noPixels -= len;
+        x += len;
+        y += len;
+        firstPixelIndex += len;
+    }
+}
+
+//------------------------------------------------------------------
+// Goes over the original line segments and combines collinear lines that belong to the same segment
+//
+void EdgeDrawingImpl::JoinCollinearLines()
+{
+    int lastLineIndex = -1;   //Index of the last line in the joined lines
+    int i = 0;
+    while (i < linesNo)
+    {
+        int segmentNo = lines[i].segmentNo;
+
+        lastLineIndex++;
+        if (lastLineIndex != i)
+            lines[lastLineIndex] = lines[i];
+
+        int firstLineIndex = lastLineIndex;  // Index of the first line in this segment
+
+        int count = 1;
+        for (int j = i + 1; j < linesNo; j++)
+        {
+            if (lines[j].segmentNo != segmentNo)
+                break;
+
+            // Try to combine this line with the previous line in this segment
+            if (TryToJoinTwoLineSegments(&lines[lastLineIndex], &lines[j],
+                                         lastLineIndex) == false)
+            {
+                lastLineIndex++;
+                if (lastLineIndex != j)
+                    lines[lastLineIndex] = lines[j];
+            }
+            count++;
+        }
+
+        // Try to join the first & last line of this segment
+        if (firstLineIndex != lastLineIndex)
+        {
+            if (TryToJoinTwoLineSegments(&lines[firstLineIndex], &lines[lastLineIndex],
+                                         firstLineIndex))
+            {
+                lastLineIndex--;
+            }
+        }
+        i += count;
+    }
+    linesNo = lastLineIndex + 1;
+}
+
+void EdgeDrawingImpl::ValidateLineSegments()
+{
+#define PRECISION_ANGLE 22.5
+    precision = (PRECISION_ANGLE / 180) * CV_PI;
+#undef PRECISION_ANGLE
+
+    if (nfa->LUTSize == 1)
+    {
+        int lutSize = (width + height) / 8;
+        double prob = 1.0 / 8;  // probability of alignment
+        nfa = new NFALUT(lutSize, prob, width, height);
+    }
+
+    int* x = new int[(width + height) * 4];
+    int* y = new int[(width + height) * 4];
+
+    int noValidLines = 0;
+
+    for (int i = 0; i < linesNo; i++)
+    {
+        EDLineSegment* ls = &lines[i];
+
+        // Compute Line's angle
+        double lineAngle;
+
+        if (ls->invert == 0)
+        {
+            // y = a + bx
+            lineAngle = atan(ls->b);
+        }
+        else
+        {
+            // x = a + by
+            lineAngle = atan(1.0 / ls->b);
+        }
+
+        if (lineAngle < 0)
+            lineAngle += CV_PI;
+
+        Point* pixels = &(segmentPoints[ls->segmentNo][0]);
+        int noPixels = ls->len;
+
+        bool valid = false;
+
+        // Accept very long lines without testing. They are almost never invalidated.
+        if (ls->len >= 80)
+        {
+            valid = true;
+            // Validate short line segments by a line support region rectangle having width=2
+        }
+        else if (ls->len <= 25)
+        {
+            valid = ValidateLineSegmentRect(x, y, ls);
+        }
+        else
+        {
+            // Longer line segments are first validated by a line support region rectangle having width=1 (for speed)
+            // If the line segment is still invalid, then a line support region rectangle having width=2 is tried
+            // If the line segment fails both tests, it is discarded
+            int aligned = 0;
+            int count = 0;
+            for (int j = 0; j < noPixels; j++)
+            {
+                int r = pixels[j].x;
+                int c = pixels[j].y;
+
+                if (r <= 0 || r >= height - 1 || c <= 0 || c >= width - 1)
+                    continue;
+
+                count++;
+
+                // compute gx & gy using the simple [-1 -1 -1]
+                //                                  [ 1  1  1]  filter in both directions
+                // Faster method below
+                // A B C
+                // D x E
+                // F G H
+                // gx = (C-A) + (E-D) + (H-F)
+                // gy = (F-A) + (G-B) + (H-C)
+                //
+                // To make this faster:
+                // com1 = (H-A)
+                // com2 = (C-F)
+                // Then: gx = com1 + com2 + (E-D) = (H-A) + (C-F) + (E-D) = (C-A) + (E-D) + (H-F)
+                //       gy = com2 - com1 + (G-B) = (H-A) - (C-F) + (G-B) = (F-A) + (G-B) + (H-C)
+                //
+                int com1 = srcImg[(r + 1) * width + c + 1] - srcImg[(r - 1) * width + c - 1];
+                int com2 = srcImg[(r - 1) * width + c + 1] - srcImg[(r + 1) * width + c - 1];
+
+                int gx = com1 + com2 + srcImg[r * width + c + 1] - srcImg[r * width + c - 1];
+                int gy = com1 - com2 + srcImg[(r + 1) * width + c] - srcImg[(r - 1) * width + c];
+
+                double pixelAngle = nfa->myAtan2((double)gx, (double)-gy);
+                double diff = fabs(lineAngle - pixelAngle);
+
+                if (diff <= precision || diff >= CV_PI - precision)
+                    aligned++;
+            }
+
+            // Check validation by NFA computation (fast due to LUT)
+            valid = nfa->checkValidationByNFA(count, aligned) || ValidateLineSegmentRect(x, y, ls);
+        }
+
+        if (valid)
+        {
+            if (i != noValidLines)
+                lines[noValidLines] = lines[i];
+            noValidLines++;
+        }
+    }
+
+    linesNo = noValidLines;
+
+    delete[] x;
+    delete[] y;
+}
+
+bool EdgeDrawingImpl::ValidateLineSegmentRect(int* x, int* y, EDLineSegment* ls)
+{
+    // Compute Line's angle
+    double lineAngle;
+
+    if (ls->invert == 0)
+    {
+        // y = a + bx
+        lineAngle = atan(ls->b);
+    }
+    else
+    {
+        // x = a + by
+        lineAngle = atan(1.0 / ls->b);
+    }
+
+    if (lineAngle < 0)
+        lineAngle += CV_PI;
+
+    int noPoints = 0;
+
+    // Enumerate all pixels that fall within the bounding rectangle
+    EnumerateRectPoints(ls->sx, ls->sy, ls->ex, ls->ey, x, y, &noPoints);
+
+    int count = 0;
+    int aligned = 0;
+
+    for (int i = 0; i < noPoints; i++)
+    {
+        int r = y[i];
+        int c = x[i];
+
+        if (r <= 0 || r >= height - 1 || c <= 0 || c >= width - 1)
+            continue;
+
+        count++;
+
+        // compute gx & gy using the simple [-1 -1 -1]
+        //                                  [ 1  1  1]  filter in both directions
+        // Faster method below
+        // A B C
+        // D x E
+        // F G H
+        // gx = (C-A) + (E-D) + (H-F)
+        // gy = (F-A) + (G-B) + (H-C)
+        //
+        // To make this faster:
+        // com1 = (H-A)
+        // com2 = (C-F)
+        // Then: gx = com1 + com2 + (E-D) = (H-A) + (C-F) + (E-D) = (C-A) + (E-D) + (H-F)
+        //       gy = com2 - com1 + (G-B) = (H-A) - (C-F) + (G-B) = (F-A) + (G-B) + (H-C)
+        //
+        int com1 = srcImg[(r + 1) * width + c + 1] - srcImg[(r - 1) * width + c - 1];
+        int com2 = srcImg[(r - 1) * width + c + 1] - srcImg[(r + 1) * width + c - 1];
+
+        int gx = com1 + com2 + srcImg[r * width + c + 1] - srcImg[r * width + c - 1];
+        int gy = com1 - com2 + srcImg[(r + 1) * width + c] - srcImg[(r - 1) * width + c];
+        double pixelAngle = nfa->myAtan2((double)gx, (double)-gy);
+
+        double diff = fabs(lineAngle - pixelAngle);
+
+        if (diff <= precision || diff >= CV_PI - precision)
+            aligned++;
+    }
+    return nfa->checkValidationByNFA(count, aligned);
+}
+
+double EdgeDrawingImpl::ComputeMinDistance(double x1, double y1, double a, double b, int invert)
+{
+    double x2, y2;
+
+    if (invert == 0)
+    {
+        if (b == 0)
+        {
+            x2 = x1;
+            y2 = a;
+        }
+        else
+        {
+            // Let the line passing through (x1, y1) that is perpendicular to a+bx be c+dx
+            double d = -1.0 / (b);
+            double c = y1 - d * x1;
+
+            x2 = (a - c) / (d - b);
+            y2 = a + b * x2;
+        }
+    }
+    else
+    {
+        /// invert = 1
+        if (b == 0)
+        {
+            x2 = a;
+            y2 = y1;
+        }
+        else
+        {
+            // Let the line passing through (x1, y1) that is perpendicular to a+by be c+dy
+            double d = -1.0 / (b);
+            double c = x1 - d * y1;
+
+            y2 = (a - c) / (d - b);
+            x2 = a + b * y2;
+        }
+    }
+
+    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
+}
+
+//---------------------------------------------------------------------------------
+// Given a point (x1, y1) and a line equation y=a+bx (invert=0) OR x=a+by (invert=1)
+// Computes the (x2, y2) on the line that is closest to (x1, y1)
+//
+void EdgeDrawingImpl::ComputeClosestPoint(double x1, double y1, double a, double b, int invert, double& xOut, double& yOut)
+{
+    double x2, y2;
+
+    if (invert == 0)
+    {
+        if (b == 0)
+        {
+            x2 = x1;
+            y2 = a;
+        }
+        else
+        {
+            // Let the line passing through (x1, y1) that is perpendicular to a+bx be c+dx
+            double d = -1.0 / (b);
+            double c = y1 - d * x1;
+
+            x2 = (a - c) / (d - b);
+            y2 = a + b * x2;
+        }
+    }
+    else
+    {
+        /// invert = 1
+        if (b == 0)
+        {
+            x2 = a;
+            y2 = y1;
+        }
+        else
+        {
+            // Let the line passing through (x1, y1) that is perpendicular to a+by be c+dy
+            double d = -1.0 / (b);
+            double c = x1 - d * y1;
+
+            y2 = (a - c) / (d - b);
+            x2 = a + b * y2;
+        }
+    }
+
+    xOut = x2;
+    yOut = y2;
+}
+
+//-----------------------------------------------------------------------------------
+// Fits a line of the form y=a+bx (invert == 0) OR x=a+by (invert == 1)
+// Assumes that the direction of the line is known by a previous computation
+//
+void EdgeDrawingImpl::LineFit(double* x, double* y, int count, double& a, double& b, int invert)
+{
+    if (count < 2)
+        return;
+
+    double S = count, Sx = 0.0, Sy = 0.0, Sxx = 0.0, Sxy = 0.0;
+    for (int i = 0; i < count; i++)
+    {
+        Sx += x[i];
+        Sy += y[i];
+    }
+
+    if (invert)
+    {
+        // Vertical line. Swap x & y, Sx & Sy
+        double* t = x;
+        x = y;
+        y = t;
+
+        double d = Sx;
+        Sx = Sy;
+        Sy = d;
+    }
+
+    // Now compute Sxx & Sxy
+    for (int i = 0; i < count; i++)
+    {
+        Sxx += x[i] * x[i];
+        Sxy += x[i] * y[i];
+    }
+
+    double D = S * Sxx - Sx * Sx;
+    a = (Sxx * Sy - Sx * Sxy) / D;
+    b = (S * Sxy - Sx * Sy) / D;
+}
+
+//-----------------------------------------------------------------------------------
+// Fits a line of the form y=a+bx (invert == 0) OR x=a+by (invert == 1)
+//
+void EdgeDrawingImpl::LineFit(double* x, double* y, int count, double& a, double& b, double& e, int& invert)
+{
+    if (count < 2)
+        return;
+
+    double S = count, Sx = 0.0, Sy = 0.0, Sxx = 0.0, Sxy = 0.0;
+    for (int i = 0; i < count; i++)
+    {
+        Sx += x[i];
+        Sy += y[i];
+    }
+
+    double mx = Sx / count;
+    double my = Sy / count;
+
+    double dx = 0.0;
+    double dy = 0.0;
+
+    for (int i = 0; i < count; i++)
+    {
+        dx += (x[i] - mx) * (x[i] - mx);
+        dy += (y[i] - my) * (y[i] - my);
+    }
+
+    if (dx < dy)
+    {
+        // Vertical line. Swap x & y, Sx & Sy
+        invert = 1;
+        double* t = x;
+        x = y;
+        y = t;
+
+        double d = Sx;
+        Sx = Sy;
+        Sy = d;
+    }
+    else
+    {
+        invert = 0;
+    }
+
+    // Now compute Sxx & Sxy
+    for (int i = 0; i < count; i++)
+    {
+        Sxx += x[i] * x[i];
+        Sxy += x[i] * y[i];
+    }
+
+    double D = S * Sxx - Sx * Sx;
+    a = (Sxx * Sy - Sx * Sxy) / D;
+    b = (S * Sxy - Sx * Sy) / D;
+
+    if (b == 0.0)
+    {
+        // Vertical or horizontal line
+        double error = 0.0;
+        for (int i = 0; i < count; i++)
+        {
+            error += fabs((a)-y[i]);
+        }
+        e = error / count;
+    }
+    else
+    {
+        double error = 0.0;
+        for (int i = 0; i < count; i++)
+        {
+            // Let the line passing through (x[i], y[i]) that is perpendicular to a+bx be c+dx
+            double d = -1.0 / (b);
+            double c = y[i] - d * x[i];
+            double x2 = ((a)-c) / (d - (b));
+            double y2 = (a)+(b)*x2;
+
+            double dist = (x[i] - x2) * (x[i] - x2) + (y[i] - y2) * (y[i] - y2);
+            error += dist;
+        }
+        e = sqrt(error / count);
+    }
+}
+
+//-----------------------------------------------------------------
+// Checks if the given line segments are collinear & joins them if they are
+// In case of a join, ls1 is updated. ls2 is NOT changed
+// Returns true if join is successful, false otherwise
+//
+bool EdgeDrawingImpl::TryToJoinTwoLineSegments(EDLineSegment* ls1, EDLineSegment* ls2, int changeIndex)
+{
+    int which;
+    double dist = ComputeMinDistanceBetweenTwoLines(ls1, ls2, &which);
+    if (dist > max_distance_between_two_lines)
+        return false;
+
+    // Compute line lengths. Use the longer one as the ground truth
+    double dx = ls1->sx - ls1->ex;
+    double dy = ls1->sy - ls1->ey;
+    double prevLen = sqrt(dx * dx + dy * dy);
+
+    dx = ls2->sx - ls2->ex;
+    dy = ls2->sy - ls2->ey;
+    double nextLen = sqrt(dx * dx + dy * dy);
+
+    // Use the longer line as the ground truth
+    EDLineSegment* shorter = ls1;
+    EDLineSegment* longer = ls2;
+
+    if (prevLen > nextLen)
+    {
+        shorter = ls2;
+        longer = ls1;
+    }
+
+    // Just use 3 points to check for collinearity
+    dist = ComputeMinDistance(shorter->sx, shorter->sy, longer->a, longer->b, longer->invert);
+    dist += ComputeMinDistance((shorter->sx + shorter->ex) / 2.0, (shorter->sy + shorter->ey) / 2.0, longer->a, longer->b, longer->invert);
+    dist += ComputeMinDistance(shorter->ex, shorter->ey, longer->a, longer->b, longer->invert);
+
+    dist /= 3.0;
+
+    if (dist > max_error)
+        return false;
+
+    /// 4 cases: 1:(s1, s2), 2:(s1, e2), 3:(e1, s2), 4:(e1, e2)
+
+    /// case 1: (s1, s2)
+    dx = fabs(ls1->sx - ls2->sx);
+    dy = fabs(ls1->sy - ls2->sy);
+    double d = dx + dy;
+    double max = d;
+    which = 1;
+
+    /// case 2: (s1, e2)
+    dx = fabs(ls1->sx - ls2->ex);
+    dy = fabs(ls1->sy - ls2->ey);
+    d = dx + dy;
+    if (d > max)
+    {
+        max = d;
+        which = 2;
+    }
+
+    /// case 3: (e1, s2)
+    dx = fabs(ls1->ex - ls2->sx);
+    dy = fabs(ls1->ey - ls2->sy);
+    d = dx + dy;
+    if (d > max)
+    {
+        max = d;
+        which = 3;
+    }
+
+    /// case 4: (e1, e2)
+    dx = fabs(ls1->ex - ls2->ex);
+    dy = fabs(ls1->ey - ls2->ey);
+    d = dx + dy;
+    if (d > max)
+    {
+        max = d;
+        which = 4;
+    }
+
+    if (which == 1)
+    {
+        // (s1, s2)
+        ls1->ex = ls2->sx;
+        ls1->ey = ls2->sy;
+    }
+    else if (which == 2)
+    {
+        // (s1, e2)
+        ls1->ex = ls2->ex;
+        ls1->ey = ls2->ey;
+    }
+    else if (which == 3)
+    {
+        // (e1, s2)
+        ls1->sx = ls2->sx;
+        ls1->sy = ls2->sy;
+    }
+    else
+    {
+        // (e1, e2)
+        ls1->sx = ls1->ex;
+        ls1->sy = ls1->ey;
+
+        ls1->ex = ls2->ex;
+        ls1->ey = ls2->ey;
+    }
+
+    // Update the first line's parameters
+    if (ls1->firstPixelIndex + ls1->len + 5 >= ls2->firstPixelIndex)
+        ls1->len += ls2->len;
+    else if (ls2->len > ls1->len)
+    {
+        ls1->firstPixelIndex = ls2->firstPixelIndex;
+        ls1->len = ls2->len;
+    }
+
+    UpdateLineParameters(ls1);
+    lines[changeIndex] = *ls1;
+
+    return true;
+}
+
+//-------------------------------------------------------------------------------
+// Computes the minimum distance between the end points of two lines
+//
+double EdgeDrawingImpl::ComputeMinDistanceBetweenTwoLines(EDLineSegment* ls1, EDLineSegment* ls2, int* pwhich)
+{
+    double dx = ls1->sx - ls2->sx;
+    double dy = ls1->sy - ls2->sy;
+    double d = sqrt(dx * dx + dy * dy);
+    double min = d;
+    int which = SOUTH_SOUTH;
+
+    dx = ls1->sx - ls2->ex;
+    dy = ls1->sy - ls2->ey;
+    d = sqrt(dx * dx + dy * dy);
+    if (d < min)
+    {
+        min = d;
+        which = SOUTH_EAST;
+    }
+
+    dx = ls1->ex - ls2->sx;
+    dy = ls1->ey - ls2->sy;
+    d = sqrt(dx * dx + dy * dy);
+    if (d < min)
+    {
+        min = d;
+        which = EAST_SOUTH;
+    }
+
+    dx = ls1->ex - ls2->ex;
+    dy = ls1->ey - ls2->ey;
+    d = sqrt(dx * dx + dy * dy);
+    if (d < min)
+    {
+        min = d;
+        which = EAST_EAST;
+    }
+
+    if (pwhich)
+        *pwhich = which;
+    return min;
+}
+
+//-----------------------------------------------------------------------------------
+// Uses the two end points (sx, sy)----(ex, ey) of the line segment
+// and computes the line that passes through these points (a, b, invert)
+//
+void EdgeDrawingImpl::UpdateLineParameters(EDLineSegment* ls)
+{
+    double dx = ls->ex - ls->sx;
+    double dy = ls->ey - ls->sy;
+
+    if (fabs(dx) >= fabs(dy))
+    {
+        /// Line will be of the form y = a + bx
+        ls->invert = 0;
+        if (fabs(dy) < 1e-3)
+        {
+            ls->b = 0;
+            ls->a = (ls->sy + ls->ey) / 2;
+        }
+        else
+        {
+            ls->b = dy / dx;
+            ls->a = ls->sy - (ls->b) * ls->sx;
+        }
+    }
+    else
+    {
+        /// Line will be of the form x = a + by
+        ls->invert = 1;
+        if (fabs(dx) < 1e-3)
+        {
+            ls->b = 0;
+            ls->a = (ls->sx + ls->ex) / 2;
+        }
+        else
+        {
+            ls->b = dx / dy;
+            ls->a = ls->sx - (ls->b) * ls->sy;
+        }
+    }
+}
+
+void EdgeDrawingImpl::EnumerateRectPoints(double sx, double sy, double ex, double ey, int ptsx[], int ptsy[], int* pNoPoints)
+{
+    double vxTmp[4], vyTmp[4];
+    double vx[4], vy[4];
+    int n, offset;
+
+    double x1 = sx;
+    double y1 = sy;
+    double x2 = ex;
+    double y2 = ey;
+    double width = 2;
+
+    double dx = x2 - x1;
+    double dy = y2 - y1;
+    double vLen = sqrt(dx * dx + dy * dy);
+
+    // make unit vector
+    dx = dx / vLen;
+    dy = dy / vLen;
+
+    /* build list of rectangle corners ordered
+    in a circular way around the rectangle */
+    vxTmp[0] = x1 - dy * width / 2.0;
+    vyTmp[0] = y1 + dx * width / 2.0;
+    vxTmp[1] = x2 - dy * width / 2.0;
+    vyTmp[1] = y2 + dx * width / 2.0;
+    vxTmp[2] = x2 + dy * width / 2.0;
+    vyTmp[2] = y2 - dx * width / 2.0;
+    vxTmp[3] = x1 + dy * width / 2.0;
+    vyTmp[3] = y1 - dx * width / 2.0;
+
+    /* compute rotation of index of corners needed so that the first
+    point has the smaller x.
+
+    if one side is vertical, thus two corners have the same smaller x
+    value, the one with the largest y value is selected as the first.
+    */
+    if (x1 < x2 && y1 <= y2)
+        offset = 0;
+    else if (x1 >= x2 && y1 < y2)
+        offset = 1;
+    else if (x1 > x2&& y1 >= y2)
+        offset = 2;
+    else
+        offset = 3;
+
+    /* apply rotation of index. */
+    for (n = 0; n < 4; n++)
+    {
+        vx[n] = vxTmp[(offset + n) % 4];
+        vy[n] = vyTmp[(offset + n) % 4];
+    }
+
+    /* Set a initial condition.
+
+    The values are set to values that will cause 'ri_inc' (that will
+    be called immediately) to initialize correctly the first 'column'
+    and compute the limits 'ys' and 'ye'.
+
+    'y' is set to the integer value of vy[0], the starting corner.
+
+    'ys' and 'ye' are set to very small values, so 'ri_inc' will
+    notice that it needs to start a new 'column'.
+
+    The smaller integer coordinate inside of the rectangle is
+    'ceil(vx[0])'. The current 'x' value is set to that value minus
+    one, so 'ri_inc' (that will increase x by one) will advance to
+    the first 'column'.
+    */
+    int x = (int)ceil(vx[0]) - 1;
+    int y = (int)ceil(vy[0]);
+    double ys = -DBL_MAX, ye = -DBL_MAX;
+
+    int noPoints = 0;
+    while (1)
+    {
+        /* if not at end of exploration,
+        increase y value for next pixel in the 'column' */
+        y++;
+
+        /* if the end of the current 'column' is reached,
+        and it is not the end of exploration,
+        advance to the next 'column' */
+        while (y > ye&& x <= vx[2])
+        {
+            /* increase x, next 'column' */
+            x++;
+
+            /* if end of exploration, return */
+            if (x > vx[2])
+                break;
+
+            /* update lower y limit (start) for the new 'column'.
+
+            We need to interpolate the y value that corresponds to the
+            lower side of the rectangle. The first thing is to decide if
+            the corresponding side is
+
+            vx[0],vy[0] to vx[3],vy[3] or
+            vx[3],vy[3] to vx[2],vy[2]
+
+            Then, the side is interpolated for the x value of the
+            'column'. But, if the side is vertical (as it could happen if
+            the rectangle is vertical and we are dealing with the first
+            or last 'columns') then we pick the lower value of the side
+            by using 'inter_low'.
+            */
+            if ((double)x < vx[3])
+            {
+                /* interpolation */
+                if (fabs(vx[0] - vx[3]) <= 0.01)
+                {
+                    if (vy[0] < vy[3])
+                        ys = vy[0];
+                    else if (vy[0] > vy[3])
+                        ys = vy[3];
+                    else
+                        ys = vy[0] + (x - vx[0]) * (vy[3] - vy[0]) / (vx[3] - vx[0]);
+                }
+                else
+                    ys = vy[0] + (x - vx[0]) * (vy[3] - vy[0]) / (vx[3] - vx[0]);
+            }
+            else
+            {
+                /* interpolation */
+                if (fabs(vx[3] - vx[2]) <= 0.01)
+                {
+                    if (vy[3] < vy[2])
+                        ys = vy[3];
+                    else if (vy[3] > vy[2])
+                        ys = vy[2];
+                    else
+                        ys = vy[3] + (x - vx[3]) * (y2 - vy[3]) / (vx[2] - vx[3]);
+                }
+                else
+                    ys = vy[3] + (x - vx[3]) * (vy[2] - vy[3]) / (vx[2] - vx[3]);
+            }
+
+            /* update upper y limit (end) for the new 'column'.
+
+            We need to interpolate the y value that corresponds to the
+            upper side of the rectangle. The first thing is to decide if
+            the corresponding side is
+
+            vx[0],vy[0] to vx[1],vy[1] or
+            vx[1],vy[1] to vx[2],vy[2]
+
+            Then, the side is interpolated for the x value of the
+            'column'. But, if the side is vertical (as it could happen if
+            the rectangle is vertical and we are dealing with the first
+            or last 'columns') then we pick the lower value of the side
+            by using 'inter_low'.
+            */
+            if ((double)x < vx[1])
+            {
+                /* interpolation */
+                if (fabs(vx[0] - vx[1]) <= 0.01)
+                {
+                    if (vy[0] < vy[1])
+                        ye = vy[1];
+                    else if (vy[0] > vy[1])
+                        ye = vy[0];
+                    else
+                        ye = vy[0] + (x - vx[0]) * (vy[1] - vy[0]) / (vx[1] - vx[0]);
+                }
+                else
+                    ye = vy[0] + (x - vx[0]) * (vy[1] - vy[0]) / (vx[1] - vx[0]);
+            }
+            else
+            {
+                /* interpolation */
+                if (fabs(vx[1] - vx[2]) <= 0.01)
+                {
+                    if (vy[1] < vy[2])
+                        ye = vy[2];
+                    else if (vy[1] > vy[2])
+                        ye = vy[1];
+                    else
+                        ye = vy[1] + (x - vx[1]) * (vy[2] - vy[1]) / (vx[2] - vx[1]);
+                }
+                else
+                    ye = vy[1] + (x - vx[1]) * (vy[2] - vy[1]) / (vx[2] - vx[1]);
+            }
+            /* new y */
+            y = (int)ceil(ys);
+        }
+
+        // Are we done?
+        if (x > vx[2])
+            break;
+
+        ptsx[noPoints] = x;
+        ptsy[noPoints] = y;
+        noPoints++;
+    }
+    *pNoPoints = noPoints;
+}
+
+/*--------------------------------------EDPF----------------------------------------*/
+
+//----------------------------------------------------------------------------------
+// Resursive validation using half of the pixels as suggested by DMM algorithm
+// We take pixels at Nyquist distance, i.e., 2 (as suggested by DMM)
+//
+void EdgeDrawingImpl::TestSegment(int i, int index1, int index2)
+{
+    int chainLen = index2 - index1 + 1;
+    if (chainLen < params.MinPathLength)
+        return;
+
+    // Test from index1 to index2. If OK, then we are done. Otherwise, split into two and
+    // recursively test the left & right halves
+
+    // First find the min. gradient along the segment
+    int minGrad = 1 << 30;
+    int minGradIndex = 0;
+
+    for (int k = index1; k <= index2; k++) {
+        int r = segmentPoints[i][k].y;
+        int c = segmentPoints[i][k].x;
+        if (gradImg[r * width + c] < minGrad) { minGrad = gradImg[r * width + c]; minGradIndex = k; }
+    }
+
+    double nfa0 = NFA(dH[minGrad], (int)(chainLen / divForTestSegment));
+
+    if (nfa0 <= 1.0) {
+        for (int k = index1; k <= index2; k++) {
+            int r = segmentPoints[i][k].y;
+            int c = segmentPoints[i][k].x;
+
+            edgeImg[r * width + c] = 255;
+        }
+        return;
+    }
+
+    // Split into two halves. We divide at the point where the gradient is the minimum
+    int end = minGradIndex - 1;
+    while (end > index1) {
+        int r = segmentPoints[i][end].y;
+        int c = segmentPoints[i][end].x;
+
+        if (gradImg[r * width + c] <= minGrad) end--;
+        else break;
+    }
+
+    int start = minGradIndex + 1;
+    while (start < index2) {
+        int r = segmentPoints[i][start].y;
+        int c = segmentPoints[i][start].x;
+
+        if (gradImg[r * width + c] <= minGrad) start++;
+        else break;
+    }
+
+    TestSegment(i, index1, end);
+    TestSegment(i, start, index2);
+}
+
+//----------------------------------------------------------------------------------------------
+// After the validation of the edge segments, extracts the valid ones
+// In other words, updates the valid segments' pixel arrays and their lengths
+void EdgeDrawingImpl::ExtractNewSegments()
+{
+    vector< vector<Point> > validSegments;
+    int noSegments = 0;
+
+    for (int i = 0; i < segmentNos; i++) {
+        int start = 0;
+        while (start < (int)segmentPoints[i].size()) {
+
+            while (start < (int)segmentPoints[i].size()) {
+                int r = segmentPoints[i][start].y;
+                int c = segmentPoints[i][start].x;
+
+                if (edgeImg[r * width + c]) break;
+                start++;
+            }
+
+            int end = start + 1;
+            while (end < (int)segmentPoints[i].size()) {
+                int r = segmentPoints[i][end].y;
+                int c = segmentPoints[i][end].x;
+
+                if (edgeImg[r * width + c] == 0) break;
+                end++;
+            }
+
+            int len = end - start;
+            if (len >= 10) {
+                // A new segment. Accepted only only long enough (whatever that means)
+                //segments[noSegments].pixels = &map->segments[i].pixels[start];
+                //segments[noSegments].noPixels = len;
+                validSegments.push_back(vector<Point>());
+                vector<Point> subVec(&segmentPoints[i][start], &segmentPoints[i][end - 1]);
+                validSegments[noSegments] = subVec;
+                noSegments++;
+            }
+            start = end + 1;
+        }
+    }
+
+    segmentPoints = validSegments;
+    segmentNos = noSegments;
+}
+
+double EdgeDrawingImpl::NFA(double prob, int len)
+{
+    double nfa0 = np;
+    for (int i = 0; i<len && nfa0 > 1.0; i++)
+        nfa0 *= prob;
+
+    return nfa0;
+}
+
+/*---------------------------------EDCircle--------------------------------------------*/
+
+void EdgeDrawingImpl::detectEllipses(OutputArray ellipses)
+{
+    vector<Vec6d> _ellipses;
+    if (segmentPoints.size() < 1)
+    {
+        Mat(_ellipses).copyTo(ellipses);
+        return;
+    }
+
+    min_line_len = 6;
+    line_error = params.LineFitErrorThreshold;
+    Circles.clear();
+    Ellipses.clear();
+    lines.clear();
+    // Arcs & circles to be detected
+    // If the end-points of the segment is very close to each other,
+    // then directly fit a circle/ellipse instread of line fitting
+    noCircles1 = 0;
+    circles1 = new Circle[(width + height) * 8];
+
+    int bufferSize = 0;
+    for (int i = 0; i < (int)segmentPoints.size(); i++)
+        bufferSize += (int)segmentPoints[i].size();
+
+    // Compute the starting line number for each segment
+    segmentStartLines = new int[segmentNos + 1];
+
+    bm = new BufferManager(bufferSize * 8);
+
+#define CIRCLE_MIN_LINE_LEN 6
+
+    for (int i = 0; i < segmentNos; i++)
+    {
+        // Make note of the starting line number for this segment
+        segmentStartLines[i] = (int)lines.size();
+
+        int noPixels = (int)segmentPoints[i].size();
+
+        if (noPixels < 2 * CIRCLE_MIN_LINE_LEN)
+            continue;
+
+        double* x = bm->getX();
+        double* y = bm->getY();
+
+        for (int j = 0; j < noPixels; j++)
+        {
+            x[j] = segmentPoints[i][j].x;
+            y[j] = segmentPoints[i][j].y;
+        }
+
+        // If the segment is reasonably long, then see if the segment traverses the boundary of a closed shape
+        if (noPixels >= 4 * CIRCLE_MIN_LINE_LEN)
+        {
+            // If the end-points of the segment is close to each other, then assume a circular/elliptic structure
+            double dx = x[0] - x[noPixels - 1];
+            double dy = y[0] - y[noPixels - 1];
+            double d = sqrt(dx * dx + dy * dy);
+            double r = noPixels / CV_2PI;      // Assume a complete circle
+
+            double maxDistanceBetweenEndPoints = std::max(3.0, r / 4.0);
+
+            // If almost closed loop, then try to fit a circle/ellipse
+            if (d <= maxDistanceBetweenEndPoints)
+            {
+                double xc, yc, circleFitError = 1e10;
+
+                CircleFit(x, y, noPixels, &xc, &yc, &r, &circleFitError);
+
+                EllipseEquation eq;
+                double ellipseFitError = 1e10;
+
+                if (circleFitError > LONG_ARC_ERROR)
+                {
+                    // Try fitting an ellipse
+                    if (EllipseFit(x, y, noPixels, &eq))
+                        ellipseFitError = ComputeEllipseError(&eq, x, y, noPixels);
+                }
+
+                if (circleFitError <= LONG_ARC_ERROR)
+                {
+                    addCircle(circles1, noCircles1, xc, yc, r, circleFitError, x, y, noPixels);
+                    bm->move(noPixels);
+                    continue;
+                }
+                else if (ellipseFitError <= ELLIPSE_ERROR)
+                {
+                    double major, minor;
+                    ComputeEllipseCenterAndAxisLengths(&eq, &xc, &yc, &major, &minor);
+
+                    // Assume major is longer. Otherwise, swap
+                    if (minor > major)
+                    {
+                        double tmp = major;
+                        major = minor;
+                        minor = tmp;
+                    }
+
+                    if (major < 8 * minor)
+                    {
+                        addCircle(circles1, noCircles1, xc, yc, r, circleFitError, &eq, ellipseFitError, x, y, noPixels);
+                        bm->move(noPixels);
+                    }
+                    continue;
+                }
+            }
+        }
+        // Otherwise, split to lines
+        SplitSegment2Lines(x, y, noPixels, i);
+    }
+
+    min_line_len = params.MinLineLength;
+    segmentStartLines[segmentNos] = (int)lines.size();
+
+    // ------------------------------- DETECT ARCS ---------------------------------
+
+    info = new Info[lines.size()];
+
+    // Compute the angle information for each line segment
+    for (int i = 0; i < segmentNos; i++)
+    {
+        for (int j = segmentStartLines[i]; j < segmentStartLines[i + 1]; j++)
+        {
+            EDLineSegment* l1 = &lines[j];
+            EDLineSegment* l2;
+
+            if (j == segmentStartLines[i + 1] - 1)
+                l2 = &lines[segmentStartLines[i]];
+            else
+                l2 = &lines[j + 1];
+
+            // If the end points of the lines are far from each other, then stop at this line
+            double dx = l1->ex - l2->sx;
+            double dy = l1->ey - l2->sy;
+            double d = sqrt(dx * dx + dy * dy);
+            if (d >= 15)
+            {
+                info[j].angle = 10;
+                info[j].sign = 2;
+                info[j].taken = false;
+                continue;
+            }
+
+            // Compute the angle between the lines & their turn direction
+            double v1x = l1->ex - l1->sx;
+            double v1y = l1->ey - l1->sy;
+            double v1Len = sqrt(v1x * v1x + v1y * v1y);
+
+            double v2x = l2->ex - l2->sx;
+            double v2y = l2->ey - l2->sy;
+            double v2Len = sqrt(v2x * v2x + v2y * v2y);
+
+            double dotProduct = (v1x * v2x + v1y * v2y) / (v1Len * v2Len);
+            if (dotProduct > 1.0)
+                dotProduct = 1.0;
+            else if (dotProduct < -1.0)
+                dotProduct = -1.0;
+
+            info[j].angle = acos(dotProduct);
+            info[j].sign = (v1x * v2y - v2x * v1y) >= 0 ? 1 : -1;  // compute cross product
+            info[j].taken = false;
+        }
+    }
+
+    // This is how much space we will allocate for circles buffers
+    int maxNoOfCircles = (int)lines.size() / 3 + noCircles1 * 2;
+
+    edarcs1 = new EDArcs(maxNoOfCircles);
+    DetectArcs();    // Detect all arcs
+
+    // Try to join arcs that are almost perfectly circular.
+    // Use the distance between the arc end-points as a metric in choosing in choosing arcs to join
+    edarcs2 = new EDArcs(maxNoOfCircles);
+    JoinArcs1();
+
+    // Try to join arcs that belong to the same segment
+    edarcs3 = new EDArcs(maxNoOfCircles);
+    JoinArcs2();
+
+    // Try to combine arcs that belong to different segments
+    edarcs4 = new EDArcs(maxNoOfCircles);     // The remaining arcs
+    JoinArcs3();
+
+    // Finally, go over the arcs & circles, and generate candidate circles
+    GenerateCandidateCircles();
+
+    //----------------------------- VALIDATE CIRCLES --------------------------
+    noCircles2 = 0;
+    circles2 = new Circle[maxNoOfCircles];
+    GaussianBlur(srcImage, smoothImage, Size(), 0.50); // calculate kernel from sigma;
+
+    ValidateCircles(params.NFAValidation);
+
+    //----------------------------- JOIN CIRCLES --------------------------
+    noCircles3 = 0;
+    circles3 = new Circle[maxNoOfCircles];
+    JoinCircles();
+
+    noCircles = 0;
+    noEllipses = 0;
+    for (int i = 0; i < noCircles3; i++)
+    {
+        if (circles3[i].isEllipse)
+            noEllipses++;
+        else
+            noCircles++;
+    }
+
+    for (int i = 0; i < noCircles3; i++)
+    {
+        if (circles3[i].isEllipse)
+        {
+            EllipseEquation eq = circles3[i].eq;
+            double xc;
+            double yc;
+            double a;
+            double b;
+            double theta = ComputeEllipseCenterAndAxisLengths(&eq, &xc, &yc, &a, &b);
+            Ellipses.push_back(mEllipse(Point2d(xc, yc), Size2d(a, b), theta));
+            _ellipses.push_back(Vec6d(xc, yc, 0, a, b, theta * 180 / CV_PI));
+        }
+        else
+        {
+            double r = circles3[i].r;
+            double xc = circles3[i].xc;
+            double yc = circles3[i].yc;
+
+            Circles.push_back(mCircle(Point2d(xc, yc), r));
+            _ellipses.push_back(Vec6d(xc, yc, r, 0, 0, 0));
+        }
+    }
+
+    Mat(_ellipses).copyTo(ellipses);
+
+    delete edarcs1;
+    delete edarcs2;
+    delete edarcs3;
+    delete edarcs4;
+
+    delete[] circles1;
+    delete[] circles2;
+    delete[] circles3;
+
+    delete bm;
+    delete[] segmentStartLines;
+    delete[] info;
+}
+
+void EdgeDrawingImpl::GenerateCandidateCircles()
+{
+    // Now, go over the circular arcs & add them to circles1
+    MyArc* arcs = edarcs4->arcs;
+    for (int i = 0; i < edarcs4->noArcs; i++)
+    {
+        if (arcs[i].isEllipse)
+        {
+            // Ellipse
+            if (arcs[i].coverRatio >= CANDIDATE_ELLIPSE_RATIO && arcs[i].ellipseFitError <= ELLIPSE_ERROR)
+            {
+                addCircle(circles1, noCircles1, arcs[i].xc, arcs[i].yc, arcs[i].r, arcs[i].circleFitError, &arcs[i].eq, arcs[i].ellipseFitError,
+                    arcs[i].x, arcs[i].y, arcs[i].noPixels);
+            }
+            else
+            {
+                double coverRatio = MAX(ArcLength(arcs[i].sTheta, arcs[i].eTheta) / CV_2PI, arcs[i].coverRatio);
+                if ((coverRatio >= FULL_CIRCLE_RATIO && arcs[i].circleFitError <= LONG_ARC_ERROR) ||
+                    (coverRatio >= HALF_CIRCLE_RATIO && arcs[i].circleFitError <= HALF_ARC_ERROR) ||
+                    (coverRatio >= CANDIDATE_CIRCLE_RATIO2 && arcs[i].circleFitError <= SHORT_ARC_ERROR))
+                {
+                    addCircle(circles1, noCircles1, arcs[i].xc, arcs[i].yc, arcs[i].r, arcs[i].circleFitError, arcs[i].x, arcs[i].y, arcs[i].noPixels);
+                }
+            }
+        }
+        else
+        {
+            // If a very short arc, ignore
+            if (arcs[i].coverRatio < CANDIDATE_CIRCLE_RATIO1)
+                continue;
+
+            // If the arc is long enough and the circleFitError is small enough, assume a circle
+            if ((arcs[i].coverRatio >= FULL_CIRCLE_RATIO && arcs[i].circleFitError <= LONG_ARC_ERROR) ||
+                (arcs[i].coverRatio >= HALF_CIRCLE_RATIO && arcs[i].circleFitError <= HALF_ARC_ERROR) ||
+                (arcs[i].coverRatio >= CANDIDATE_CIRCLE_RATIO2 && arcs[i].circleFitError <= SHORT_ARC_ERROR))
+            {
+
+                addCircle(circles1, noCircles1, arcs[i].xc, arcs[i].yc, arcs[i].r, arcs[i].circleFitError, arcs[i].x, arcs[i].y, arcs[i].noPixels);
+
+                continue;
+            }
+
+            if (arcs[i].coverRatio < CANDIDATE_CIRCLE_RATIO2)
+                continue;
+
+            // Circle is not possible. Try an ellipse
+            EllipseEquation eq;
+            double ellipseFitError = 1e10;
+            double coverRatio(0);
+
+            int noPixels = arcs[i].noPixels;
+            if (EllipseFit(arcs[i].x, arcs[i].y, noPixels, &eq))
+            {
+                ellipseFitError = ComputeEllipseError(&eq, arcs[i].x, arcs[i].y, noPixels);
+                coverRatio = noPixels / computeEllipsePerimeter(&eq);
+            }
+
+            if (arcs[i].coverRatio > coverRatio)
+                coverRatio = arcs[i].coverRatio;
+
+            if (coverRatio >= CANDIDATE_ELLIPSE_RATIO && ellipseFitError <= ELLIPSE_ERROR)
+            {
+                addCircle(circles1, noCircles1, arcs[i].xc, arcs[i].yc, arcs[i].r, arcs[i].circleFitError, &eq, ellipseFitError, arcs[i].x, arcs[i].y, arcs[i].noPixels);
+            }
+        }
+    }
+}
+
+void EdgeDrawingImpl::DetectArcs()
+{
+    double maxLineLengthThreshold = MAX(width, height) / 5;
+
+    double MIN_ANGLE = CV_PI / 30;  // 6 degrees
+    double MAX_ANGLE = CV_PI / 3;   // 60 degrees
+
+    for (int iter = 1; iter <= 2; iter++)
+    {
+        if (iter == 2)
+            MAX_ANGLE = CV_PI / 1.9;  // 95 degrees
+
+        for (int curSegmentNo = 0; curSegmentNo < segmentNos; curSegmentNo++)
+        {
+            int firstLine = segmentStartLines[curSegmentNo];
+            int stopLine = segmentStartLines[curSegmentNo + 1];
+
+            // We need at least 2 line segments
+            if (stopLine - firstLine <= 1)
+                continue;
+
+            // Process the info for the lines of this segment
+            while (firstLine < stopLine - 1)
+            {
+                // If the line is already taken during the previous step, continue
+                if (info[firstLine].taken)
+                {
+                    firstLine++;
+                    continue;
+                }
+
+                // very long lines cannot be part of an arc
+                if (lines[firstLine].len >= maxLineLengthThreshold)
+                {
+                    firstLine++;
+                    continue;
+                }
+
+                // Skip lines that cannot be part of an arc
+                if (info[firstLine].angle < MIN_ANGLE || info[firstLine].angle > MAX_ANGLE)
+                {
+                    firstLine++;
+                    continue;
+                }
+
+                // Find a group of lines (at least 3) with the same sign & angle < MAX_ANGLE degrees
+                int lastLine = firstLine + 1;
+                while (lastLine < stopLine - 1)
+                {
+                    if (info[lastLine].taken)
+                        break;
+                    if (info[lastLine].sign != info[firstLine].sign)
+                        break;
+
+                    if (lines[lastLine].len >= maxLineLengthThreshold)
+                        break;                                // very long lines cannot be part of an arc
+                    if (info[lastLine].angle < MIN_ANGLE)
+                        break;
+                    if (info[lastLine].angle > MAX_ANGLE)
+                        break;
+
+                    lastLine++;
+                }
+
+                bool specialCase = false;
+                int wrapCase = -1;  // 1: wrap the first two lines with the last line, 2: wrap the last two lines with the first line
+
+                if (lastLine - firstLine == 1)
+                {
+                    // Just 2 lines. If long enough, then try to combine. Angle between 15 & 45 degrees. Min. length = 40
+                    int totalLineLength = lines[firstLine].len + lines[firstLine + 1].len;
+                    int shorterLen = lines[firstLine].len;
+                    int longerLen = lines[firstLine + 1].len;
+
+                    if (lines[firstLine + 1].len < shorterLen)
+                    {
+                        shorterLen = lines[firstLine + 1].len;
+                        longerLen = lines[firstLine].len;
+                    }
+
+                    if (info[firstLine].angle >= CV_PI / 12 && info[firstLine].angle <= CV_PI / 4 && totalLineLength >= 40 && shorterLen * 2 >= longerLen)
+                    {
+                        specialCase = true;
+                    }
+
+                    // If the two lines do not make up for arc generation, then try to wrap the lines to the first OR last line.
+                    // There are two wrapper cases:
+                    if (specialCase == false)
+                    {
+                        // Case 1: Combine the first two lines with the last line of the segment
+                        if (firstLine == segmentStartLines[curSegmentNo] && info[stopLine - 1].angle >= MIN_ANGLE && info[stopLine - 1].angle <= MAX_ANGLE)
+                        {
+                            wrapCase = 1;
+                            specialCase = true;
+                        }
+
+                        // Case 2: Combine the last two lines with the first line of the segment
+                        else if (lastLine == stopLine - 1 && info[lastLine].angle >= MIN_ANGLE && info[lastLine].angle <= MAX_ANGLE)
+                        {
+                            wrapCase = 2;
+                            specialCase = true;
+                        }
+                    }
+
+                    // If still not enough for arc generation, then skip
+                    if (specialCase == false)
+                    {
+                        firstLine = lastLine;
+                        continue;
+                    }
+                }
+
+                // Copy the pixels of this segment to an array
+                int noPixels = 0;
+                double* x = bm->getX();
+                double* y = bm->getY();
+
+                // wrapCase 1: Combine the first two lines with the last line of the segment
+                if (wrapCase == 1)
+                {
+                    int index = lines[stopLine - 1].firstPixelIndex;
+
+                    for (int n = 0; n < lines[stopLine - 1].len; n++)
+                    {
+                        x[noPixels] = segmentPoints[curSegmentNo][index + n].x;
+                        y[noPixels] = segmentPoints[curSegmentNo][index + n].y;
+                        noPixels++;
+                    }
+                }
+
+                for (int m = firstLine; m <= lastLine; m++)
+                {
+                    int index = lines[m].firstPixelIndex;
+
+                    for (int n = 0; n < lines[m].len; n++)
+                    {
+                        x[noPixels] = segmentPoints[curSegmentNo][index + n].x;
+                        y[noPixels] = segmentPoints[curSegmentNo][index + n].y;
+                        noPixels++;
+                    }
+                }
+
+                // wrapCase 2: Combine the last two lines with the first line of the segment
+                if (wrapCase == 2)
+                {
+                    int index = lines[segmentStartLines[curSegmentNo]].firstPixelIndex;
+
+                    for (int n = 0; n < lines[segmentStartLines[curSegmentNo]].len; n++)
+                    {
+                        x[noPixels] = segmentPoints[curSegmentNo][index + n].x;
+                        y[noPixels] = segmentPoints[curSegmentNo][index + n].y;
+                        noPixels++;
+                    }
+                }
+
+                // Move buffer pointers
+                bm->move(noPixels);
+
+                // Try to fit a circle to the entire arc of lines
+                double xc = -1, yc = -1, radius = -1, circleFitError = -1;
+                CircleFit(x, y, noPixels, &xc, &yc, &radius, &circleFitError);
+
+                double coverage = noPixels / (CV_2PI * radius);
+
+                // In the case of the special case, the arc must cover at least 22.5 degrees
+                if (specialCase && coverage < 1.0 / 16)
+                {
+                    info[firstLine].taken = true;
+                    firstLine = lastLine;
+                    continue;
+                }
+
+                // If only 3 lines, use the SHORT_ARC_ERROR
+                double MYERROR = SHORT_ARC_ERROR;
+                if (lastLine - firstLine >= 3)
+                    MYERROR = LONG_ARC_ERROR;
+                if (circleFitError <= MYERROR)
+                {
+                    // Add this to the list of arcs
+                    if (wrapCase == 1)
+                    {
+                        x += lines[stopLine - 1].len;
+                        y += lines[stopLine - 1].len;
+                        noPixels -= lines[stopLine - 1].len;
+                    }
+                    else if (wrapCase == 2)
+                    {
+                        noPixels -= lines[segmentStartLines[curSegmentNo]].len;
+                    }
+
+                    if ((coverage >= FULL_CIRCLE_RATIO && circleFitError <= LONG_ARC_ERROR))
+                    {
+                        addCircle(circles1, noCircles1, xc, yc, radius, circleFitError, x, y, noPixels);
+                    }
+                    else
+                    {
+                        double sTheta, eTheta;
+                        ComputeStartAndEndAngles(xc, yc, radius, x, y, noPixels, &sTheta, &eTheta);
+
+                        addArc(edarcs1->arcs, edarcs1->noArcs, xc, yc, radius, circleFitError, sTheta, eTheta, info[firstLine].sign, curSegmentNo,
+                            (int)x[0], (int)y[0], (int)x[noPixels - 1], (int)y[noPixels - 1], x, y, noPixels);
+                    }
+
+                    for (int m = firstLine; m < lastLine; m++)
+                        info[m].taken = true;
+                    firstLine = lastLine;
+                    continue;
+                }
+
+                // Check if this is an almost closed loop (i.e, if 60% of the circle is present). If so, try to fit an ellipse to the entire arc of lines
+                double dx = x[0] - x[noPixels - 1];
+                double dy = y[0] - y[noPixels - 1];
+                double distanceBetweenEndPoints = sqrt(dx * dx + dy * dy);
+
+                bool isAlmostClosedLoop = (distanceBetweenEndPoints <= 1.72 * radius && coverage >= FULL_CIRCLE_RATIO);
+                if (isAlmostClosedLoop || (iter == 1 && coverage >= 0.25))    // an arc covering at least 90 degrees
+                {
+                    EllipseEquation eq;
+                    double ellipseFitError = 1e10;
+
+                    bool valid = EllipseFit(x, y, noPixels, &eq);
+                    if (valid)
+                        ellipseFitError = ComputeEllipseError(&eq, x, y, noPixels);
+
+                    MYERROR = ELLIPSE_ERROR;
+                    if (isAlmostClosedLoop == false)
+                        MYERROR = 0.75;
+
+                    if (ellipseFitError <= MYERROR)
+                    {
+                        // Add this to the list of arcs
+                        if (wrapCase == 1)
+                        {
+                            x += lines[stopLine - 1].len;
+                            y += lines[stopLine - 1].len;
+                            noPixels -= lines[stopLine - 1].len;
+                        }
+                        else if (wrapCase == 2)
+                        {
+                            noPixels -= lines[segmentStartLines[curSegmentNo]].len;
+                        }
+
+                        if (isAlmostClosedLoop)
+                        {
+                            addCircle(circles1, noCircles1, xc, yc, radius, circleFitError, &eq, ellipseFitError, x, y, noPixels);  // Add an ellipse for validation
+                        }
+                        else
+                        {
+                            double sTheta, eTheta;
+                            ComputeStartAndEndAngles(xc, yc, radius, x, y, noPixels, &sTheta, &eTheta);
+
+                            addArc(edarcs1->arcs, edarcs1->noArcs, xc, yc, radius, circleFitError, sTheta, eTheta, info[firstLine].sign, curSegmentNo, &eq, ellipseFitError,
+                                (int)x[0], (int)y[0], (int)x[noPixels - 1], (int)y[noPixels - 1], x, y, noPixels);
+                        }
+
+                        for (int m = firstLine; m < lastLine; m++)
+                            info[m].taken = true;
+                        firstLine = lastLine;
+                        continue;
+                    }
+                }
+
+                if (specialCase)
+                {
+                    info[firstLine].taken = true;
+                    firstLine = lastLine;
+                    continue;
+                }
+
+                // Continue until we finish all lines that belong to arc of lines
+                while (firstLine <= lastLine - 2)
+                {
+                    // Fit an initial arc and extend it
+                    int curLine = firstLine + 2;
+
+                    // Fit a circle to the pixels of these lines and see if the error is less than a threshold
+                    double XC(0), YC(0), R(0), Error = 1e10;
+                    bool found = false;
+
+                    noPixels = 0;
+                    while (curLine <= lastLine)
+                    {
+                        noPixels = 0;
+                        for (int m = firstLine; m <= curLine; m++)
+                            noPixels += lines[m].len;
+
+                        // Fit circle
+                        CircleFit(x, y, noPixels, &XC, &YC, &R, &Error);
+                        if (Error <= SHORT_ARC_ERROR)
+                        {
+                            found = true;    // found if the error is smaller than the threshold
+                            break;
+                        }
+
+                        // Not found. Move to the next set of lines
+                        x += lines[firstLine].len;
+                        y += lines[firstLine].len;
+
+                        firstLine++;
+                        curLine++;
+                    }
+
+                    // If no initial arc found, then we are done with this arc of lines
+                    if (!found)
+                        break;
+
+                    // If we found an initial arc, then extend it
+                    for (int m = curLine - 2; m <= curLine; m++)
+                        info[m].taken = true;
+                    curLine++;
+
+                    while (curLine <= lastLine)
+                    {
+                        int noPixelsSave = noPixels;
+
+                        noPixels += lines[curLine].len;
+
+                        double r, error;
+                        CircleFit(x, y, noPixels, &xc, &yc, &r, &error);
+                        if (error > LONG_ARC_ERROR)
+                        {
+                            noPixels = noPixelsSave;    // Adding this line made the error big. So, we do not use this line
+                            break;
+                        }
+
+                        // OK. Longer arc
+                        XC = xc;
+                        YC = yc;
+                        R = r;
+                        Error = error;
+
+                        info[curLine].taken = true;
+                        curLine++;
+                    }
+
+                    coverage = noPixels / (CV_2PI * radius);
+                    if ((coverage >= FULL_CIRCLE_RATIO && circleFitError <= LONG_ARC_ERROR))
+                    {
+                        addCircle(circles1, noCircles1, XC, YC, R, Error, x, y, noPixels);
+                    }
+                    else
+                    {
+                        // Add this to the list of arcs
+                        double sTheta, eTheta;
+                        ComputeStartAndEndAngles(XC, YC, R, x, y, noPixels, &sTheta, &eTheta);
+
+                        addArc(edarcs1->arcs, edarcs1->noArcs, XC, YC, R, Error, sTheta, eTheta, info[firstLine].sign, curSegmentNo,
+                            (int)x[0], (int)y[0], (int)x[noPixels - 1], (int)y[noPixels - 1], x, y, noPixels);
+                    }
+
+                    x += noPixels;
+                    y += noPixels;
+
+                    firstLine = curLine;
+                }
+                firstLine = lastLine;
+            }
+        }
+    }
+}
+
+// Go over all circles & ellipses and validate them
+// The idea here is to look at all pixels of a circle/ellipse
+// rather than only the pixels of the lines making up the circle/ellipse
+void EdgeDrawingImpl::ValidateCircles(bool validate)
+{
+    precision = CV_PI / 16;  // Alignment precision
+
+    int points_buffer_size = 8 * (width + height);
+    double *px = new double[points_buffer_size];
+    double *py = new double[points_buffer_size];
+
+    if (nfa->LUTSize == 1 && params.NFAValidation)
+    {
+        int lutSize = (width + height) / 8;
+        double prob = 1.0 / 8;  // probability of alignment
+        nfa = new NFALUT(lutSize, prob, width, height); // create look up table
+    }
+
+    // Validate circles & ellipses
+    bool validateAgain;
+    int count = 0;
+    for (int i = 0; i < noCircles1; )
+    {
+        Circle* circle = &circles1[i];
+        double xc = circle->xc;
+        double yc = circle->yc;
+        double radius = circle->r;
+
+        // Skip potential invalid circles (sometimes these kinds of candidates get generated!)
+        if (radius > MAX(width, height))
+        {
+            i++;
+            continue;
+        }
+
+        validateAgain = false;
+
+        int noPoints = (int)(computeEllipsePerimeter(&circle->eq));
+
+        if (noPoints > points_buffer_size)
+        {
+            i++;
+            continue;
+        }
+
+        if (circle->isEllipse)
+        {
+            ComputeEllipsePoints(circle->eq.coeff, px, py, noPoints);
+        }
+        else
+        {
+            ComputeCirclePoints(xc, yc, radius, px, py, &noPoints);
+        }
+
+        int pr = -1;  // previous row
+        int pc = -1;  // previous column
+
+        int tr = -100;
+        int tc = -100;
+        int tcount = 0;
+
+        int noPeripheryPixels = 0;
+        int noEdgePixels = 0;
+        int aligned = 0;
+        for (int j = 0; j < noPoints; j++)
+        {
+            int r = (int)(py[j] + 0.5);
+            int c = (int)(px[j] + 0.5);
+
+            if (r == pr && c == pc)
+                continue;
+            noPeripheryPixels++;
+
+            if (r <= 0 || r >= height - 1)
+                continue;
+            if (c <= 0 || c >= width - 1)
+                continue;
+
+            pr = r;
+            pc = c;
+
+            int dr = abs(r - tr);
+            int dc = abs(c - tc);
+            if (dr + dc >= 2)
+            {
+                tr = r;
+                tc = c;
+                tcount++;
+            }
+
+            //
+            // See if there is an edge pixel within 1 pixel vicinity
+            //
+            if (edgeImg[r * width + c] != 255)
+            {
+                //   y-cy=-x-cx    y-cy=x-cx
+                //         \       /
+                //          \ IV. /
+                //           \   /
+                //            \ /
+                //     III.    +   I. quadrant
+                //            / \
+                //           /   \
+                //          / II. \
+                //         /       \
+                //
+                // (x, y)-->(x-cx, y-cy)
+                //
+
+                int x = c;
+                int y = r;
+
+                int diff1 = (int)(y - yc - x + xc);
+                int diff2 = (int)(y - yc + x - xc);
+
+                if (diff1 < 0)
+                {
+                    if (diff2 > 0)
+                    {
+                        // I. quadrant
+                        c = x - 1;
+                        if (c >= 1 && edgeImg[r * width + c] == 255)
+                            goto out;
+                        c = x + 1;
+                        if (c < width - 1 && edgeImg[r * width + c] == 255)
+                            goto out;
+
+                        c = x - 2;
+                        if (c >= 2 && edgeImg[r * width + c] == 255)
+                            goto out;
+                        c = x + 2;
+                        if (c < width - 2 && edgeImg[r * width + c] == 255)
+                            goto out;
+                    }
+                    else
+                    {
+                        // IV. quadrant
+                        r = y - 1;
+                        if (r >= 1 && edgeImg[r * width + c] == 255)
+                            goto out;
+                        r = y + 1;
+                        if (r < height - 1 && edgeImg[r * width + c] == 255)
+                            goto out;
+
+                        r = y - 2;
+                        if (r >= 2 && edgeImg[r * width + c] == 255)
+                            goto out;
+                        r = y + 2;
+                        if (r < height - 2 && edgeImg[r * width + c] == 255)
+                            goto out;
+                    }
+                }
+                else
+                {
+                    if (diff2 > 0)
+                    {
+                        // II. quadrant
+                        r = y - 1;
+                        if (r >= 1 && edgeImg[r * width + c] == 255)
+                            goto out;
+                        r = y + 1;
+                        if (r < height - 1 && edgeImg[r * width + c] == 255)
+                            goto out;
+
+                        r = y - 2;
+                        if (r >= 2 && edgeImg[r * width + c] == 255)
+                            goto out;
+                        r = y + 2;
+                        if (r < height - 2 && edgeImg[r * width + c] == 255)
+                            goto out;
+                    }
+                    else
+                    {
+                        // III. quadrant
+                        c = x - 1;
+                        if (c >= 1 && edgeImg[r * width + c] == 255)
+                            goto out;
+                        c = x + 1;
+                        if (c < width - 1 && edgeImg[r * width + c] == 255)
+                            goto out;
+
+                        c = x - 2;
+                        if (c >= 2 && edgeImg[r * width + c] == 255)
+                            goto out;
+                        c = x + 2;
+                        if (c < width - 2 && edgeImg[r * width + c] == 255)
+                            goto out;
+                    }
+                }
+
+                r = pr;
+                c = pc;
+                continue;  // Ignore non-edge pixels.
+                           // This produces less false positives, but occationally misses on some valid circles
+            }
+        out:
+            if (edgeImg[r * width + c] == 255)
+                noEdgePixels++;
+
+            // compute gx & gy
+            int com1 = smoothImg[(r + 1) * width + c + 1] - smoothImg[(r - 1) * width + c - 1];
+            int com2 = smoothImg[(r - 1) * width + c + 1] - smoothImg[(r + 1) * width + c - 1];
+
+            int gx = com1 + com2 + smoothImg[r * width + c + 1] - smoothImg[r * width + c - 1];
+            int gy = com1 - com2 + smoothImg[(r + 1) * width + c] - smoothImg[(r - 1) * width + c];
+            double pixelAngle = nfa->myAtan2((double)gx, (double)-gy);
+
+            double derivX, derivY;
+            if (circle->isEllipse)
+            {
+                // Ellipse
+                derivX = 2 * circle->eq.A() * c + circle->eq.B() * r + circle->eq.D();
+                derivY = circle->eq.B() * c + 2 * circle->eq.C() * r + circle->eq.E();
+            }
+            else
+            {
+                // circle
+                derivX = c - xc;
+                derivY = r - yc;
+            }
+
+            double idealPixelAngle = nfa->myAtan2(derivX, -derivY);
+            double diff = fabs(pixelAngle - idealPixelAngle);
+            if (diff <= precision || diff >= CV_PI - precision)
+                aligned++;
+        }
+
+        bool isValid = !validate || nfa->checkValidationByNFA(noPeripheryPixels, aligned);
+
+        if (isValid)
+        {
+            circles2[count++] = circles1[i];
+        }
+        else if (circle->isEllipse == false && circle->coverRatio >= CANDIDATE_ELLIPSE_RATIO)
+        {
+            // Fit an ellipse to this circle, and try to revalidate
+            double ellipseFitError = 1e10;
+            EllipseEquation eq;
+
+            if (EllipseFit(circle->x, circle->y, circle->noPixels, &eq))
+            {
+                ellipseFitError = ComputeEllipseError(&eq, circle->x, circle->y, circle->noPixels);
+            }
+
+            if (ellipseFitError <= ELLIPSE_ERROR)
+            {
+                circle->isEllipse = true;
+                circle->ellipseFitError = ellipseFitError;
+                circle->eq = eq;
+
+                validateAgain = true;
+            }
+        }
+
+        if (validateAgain == false)
+            i++;
+    }
+
+    noCircles2 = count;
+
+    delete[] px;
+    delete[] py;
+}
+
+void EdgeDrawingImpl::JoinCircles()
+{
+    // Sort the circles wrt their radius
+    sortCircles(circles2, noCircles2);
+
+    noCircles = noCircles2;
+    Circle* circles = circles2;
+
+    vector<bool> taken;
+    vector<int> candidateCircles;
+    int noCandidateCircles;
+
+    for (int i = 0; i < noCircles; i++)
+    {
+        taken.push_back(false);
+        candidateCircles.push_back(0);
+
+        if (circles[i].isEllipse)
+        {
+            ComputeEllipseCenterAndAxisLengths(&circles[i].eq, &circles[i].xc, &circles[i].yc, &circles[i].majorAxisLength, &circles[i].minorAxisLength);
+        }
+    }
+
+    for (int i = 0; i < noCircles; i++)
+    {
+        if (taken[i])
+            continue;
+
+        // Current arc
+        double majorAxisLength, minorAxisLength;
+
+        if (circles[i].isEllipse)
+        {
+            majorAxisLength = circles[i].majorAxisLength;
+            minorAxisLength = circles[i].minorAxisLength;
+        }
+        else
+        {
+            majorAxisLength = circles[i].r;
+            minorAxisLength = circles[i].r;
+        }
+
+        // Find other circles to join with
+        noCandidateCircles = 0;
+
+        for (int j = i + 1; j < noCircles; j++)
+        {
+            if (taken[j])
+                continue;
+
+#define JOINED_SHORT_ARC_ERROR_THRESHOLD  2
+#define AXIS_LENGTH_DIFF_THRESHOLD     6 //(JOINED_SHORT_ARC_ERROR_THRESHOLD*2+1)
+#define CENTER_DISTANCE_THRESHOLD      12 //(AXIS_LENGTH_DIFF_THRESHOLD*2)
+
+            double dx = circles[i].xc - circles[j].xc;
+            double dy = circles[i].yc - circles[j].yc;
+            double centerDistance = sqrt(dx * dx + dy * dy);
+            if (centerDistance > CENTER_DISTANCE_THRESHOLD)
+                continue;
+
+            double diff1, diff2;
+            if (circles[j].isEllipse)
+            {
+                diff1 = fabs(majorAxisLength - circles[j].majorAxisLength);
+                diff2 = fabs(minorAxisLength - circles[j].minorAxisLength);
+            }
+            else
+            {
+                diff1 = fabs(majorAxisLength - circles[j].r);
+                diff2 = fabs(minorAxisLength - circles[j].r);
+            }
+
+            if (diff1 > AXIS_LENGTH_DIFF_THRESHOLD)
+                continue;
+            if (diff2 > AXIS_LENGTH_DIFF_THRESHOLD)
+                continue;
+
+            // Add to candidates
+            candidateCircles[noCandidateCircles] = j;
+            noCandidateCircles++;
+        }
+
+        // Try to join the current arc with the candidate arc (if there is one)
+        double XC = circles[i].xc;
+        double YC = circles[i].yc;
+        double R = circles[i].r;
+
+        double CircleFitError = circles[i].circleFitError;
+        bool CircleFitValid = false;
+
+        EllipseEquation Eq;
+        double EllipseFitError(0);
+        bool EllipseFitValid = false;
+
+        if (noCandidateCircles > 0)
+        {
+            int noPixels = circles[i].noPixels;
+            double* x = bm->getX();
+            double* y = bm->getY();
+            memcpy(x, circles[i].x, noPixels * sizeof(double));
+            memcpy(y, circles[i].y, noPixels * sizeof(double));
+
+            for (int j = 0; j < noCandidateCircles; j++)
+            {
+                int CandidateArcNo = candidateCircles[j];
+
+                int noPixelsSave = noPixels;
+                memcpy(x + noPixels, circles[CandidateArcNo].x, circles[CandidateArcNo].noPixels * sizeof(double));
+                memcpy(y + noPixels, circles[CandidateArcNo].y, circles[CandidateArcNo].noPixels * sizeof(double));
+                noPixels += circles[CandidateArcNo].noPixels;
+
+                bool circleFitOK = false;
+                if (EllipseFitValid == false && circles[i].isEllipse == false && circles[CandidateArcNo].isEllipse == false)
+                {
+                    double xc, yc, r, error = 1e10;
+                    CircleFit(x, y, noPixels, &xc, &yc, &r, &error);
+
+                    if (error <= JOINED_SHORT_ARC_ERROR_THRESHOLD)
+                    {
+                        taken[CandidateArcNo] = true;
+
+                        XC = xc;
+                        YC = yc;
+                        R = r;
+                        CircleFitError = error;
+
+                        circleFitOK = true;
+                        CircleFitValid = true;
+                    }
+                }
+
+                bool ellipseFitOK = false;
+                if (circleFitOK == false)
+                {
+                    // Try to fit an ellipse
+                    double error = 1e10;
+                    EllipseEquation eq;
+                    if (EllipseFit(x, y, noPixels, &eq))
+                    {
+                        error = ComputeEllipseError(&eq, x, y, noPixels);
+                    }
+
+                    if (error <= JOINED_SHORT_ARC_ERROR_THRESHOLD)
+                    {
+                        taken[CandidateArcNo] = true;
+
+                        Eq = eq;
+                        EllipseFitError = error;
+
+                        ellipseFitOK = true;
+                        EllipseFitValid = true;
+                        CircleFitValid = false;
+                    }
+                }
+
+                if (circleFitOK == false && ellipseFitOK == false)
+                {
+                    noPixels = noPixelsSave;
+                }
+            }
+        }
+
+        // Add the new circle/ellipse to circles2
+        if (CircleFitValid)
+        {
+            addCircle(circles3, noCircles3, XC, YC, R, CircleFitError, NULL, NULL, 0);
+        }
+        else if (EllipseFitValid)
+        {
+            addCircle(circles3, noCircles3, XC, YC, R, CircleFitError, &Eq, EllipseFitError, NULL, NULL, 0);
+        }
+        else
+        {
+            circles3[noCircles3] = circles[i];
+            noCircles3++;
+        }
+    }
+}
+
+void EdgeDrawingImpl::JoinArcs1()
+{
+    AngleSet angles;
+
+    // Sort the arcs with respect to their length so that longer arcs are at the beginning
+    sortArc(edarcs1->arcs, edarcs1->noArcs);
+
+    int noArcs = edarcs1->noArcs;
+    MyArc* arcs = edarcs1->arcs;
+
+    bool* taken = new bool[noArcs];
+    for (int i = 0; i < noArcs; i++)
+        taken[i] = false;
+
+    struct CandidateArc
+    {
+        int arcNo;
+        int which;    // 1: (SX, SY)-(sx, sy), 2: (SX, SY)-(ex, ey), 3: (EX, EY)-(sx, sy), 4: (EX, EY)-(ex, ey)
+        double dist;  // min distance between the end points
+    };
+
+    CandidateArc* candidateArcs = new CandidateArc[noArcs];
+    int noCandidateArcs;
+
+    for (int i = 0; i < noArcs; i++)
+    {
+        if (taken[i])
+            continue;
+        if (arcs[i].isEllipse)
+        {
+            edarcs2->arcs[edarcs2->noArcs++] = arcs[i];
+            continue;
+        }
+
+        // Current arc
+        bool CircleEqValid = false;
+        double XC = arcs[i].xc;
+        double YC = arcs[i].yc;
+        double R = arcs[i].r;
+        double CircleFitError = arcs[i].circleFitError;
+        int Turn = arcs[i].turn;
+        int NoPixels = arcs[i].noPixels;
+
+        int SX = arcs[i].sx;
+        int SY = arcs[i].sy;
+        int EX = arcs[i].ex;
+        int EY = arcs[i].ey;
+
+        // Take the pixels making up this arc
+        int noPixels = arcs[i].noPixels;
+
+        double* x = bm->getX();
+        double* y = bm->getY();
+        memcpy(x, arcs[i].x, noPixels * sizeof(double));
+        memcpy(y, arcs[i].y, noPixels * sizeof(double));
+
+        angles.clear();
+        angles.set(arcs[i].sTheta, arcs[i].eTheta);
+
+        while (1)
+        {
+            bool extendedArc = false;
+
+            // Find other arcs to join with
+            noCandidateArcs = 0;
+
+            for (int j = i + 1; j < noArcs; j++)
+            {
+                if (taken[j])
+                    continue;
+                if (arcs[j].isEllipse)
+                    continue;
+
+                double minR = MIN(R, arcs[j].r);
+                double radiusDiffThreshold = minR * 0.25;
+
+                double diff = fabs(R - arcs[j].r);
+                if (diff > radiusDiffThreshold)
+                    continue;
+
+                // If 50% of the current arc overlaps with the existing arc, then ignore this arc
+                if (angles.overlap(arcs[j].sTheta, arcs[j].eTheta) >= 0.50)
+                    continue;
+
+                // Compute the distances
+                // 1: (SX, SY)-(sx, sy)
+                double dx = SX - arcs[j].sx;
+                double dy = SY - arcs[j].sy;
+                double d = sqrt(dx * dx + dy * dy);
+                int which = 1;
+
+                // 2: (SX, SY)-(ex, ey)
+                dx = SX - arcs[j].ex;
+                dy = SY - arcs[j].ey;
+                double d2 = sqrt(dx * dx + dy * dy);
+
+                if (d2 < d)
+                {
+                    d = d2;
+                    which = 2;
+                }
+
+                // 3: (EX, EY)-(sx, sy)
+                dx = EX - arcs[j].sx;
+                dy = EY - arcs[j].sy;
+                d2 = sqrt(dx * dx + dy * dy);
+
+                if (d2 < d)
+                {
+                    d = d2;
+                    which = 3;
+                }
+
+                // 4: (EX, EY)-(ex, ey)
+                dx = EX - arcs[j].ex;
+                dy = EY - arcs[j].ey;
+                d2 = sqrt(dx * dx + dy * dy);
+
+                if (d2 < d)
+                {
+                    d = d2;
+                    which = 4;
+                }
+
+                // Endpoints must be very close
+                double maxDistanceBetweenEndpoints = minR * 1.75; //1.5;
+                if (d > maxDistanceBetweenEndpoints)
+                    continue;
+
+                // This is to give precedence to better matching arc
+                d += diff;
+
+                // They have to turn in the same direction
+                if (which == 2 || which == 3)
+                {
+                    if (Turn != arcs[j].turn)
+                        continue;
+                }
+                else
+                {
+                    if (Turn == arcs[j].turn)
+                        continue;
+                }
+
+                // Add to candidate arcs in sorted order. User insertion sort
+                int index = noCandidateArcs - 1;
+
+                while (index >= 0)
+                {
+                    if (candidateArcs[index].dist < d)
+                        break;
+
+                    candidateArcs[index + 1] = candidateArcs[index];
+                    index--;
+                }
+
+                // Add the new candidate arc to the candidate list
+                index++;
+                candidateArcs[index].arcNo = j;
+                candidateArcs[index].which = which;
+                candidateArcs[index].dist = d;
+                noCandidateArcs++;
+            }
+
+            // Try to join the current arc with the candidate arc (if there is one)
+            if (noCandidateArcs > 0)
+            {
+                for (int j = 0; j < noCandidateArcs; j++)
+                {
+                    int CandidateArcNo = candidateArcs[j].arcNo;
+                    int Which = candidateArcs[j].which;
+
+                    int noPixelsSave = noPixels;
+                    memcpy(x + noPixels, arcs[CandidateArcNo].x, arcs[CandidateArcNo].noPixels * sizeof(double));
+                    memcpy(y + noPixels, arcs[CandidateArcNo].y, arcs[CandidateArcNo].noPixels * sizeof(double));
+                    noPixels += arcs[CandidateArcNo].noPixels;
+
+                    double xc, yc, r, circleFitError;
+                    CircleFit(x, y, noPixels, &xc, &yc, &r, &circleFitError);
+
+                    if (circleFitError > LONG_ARC_ERROR)
+                    {
+                        // No match. Continue with the next candidate
+                        noPixels = noPixelsSave;
+                    }
+                    else
+                    {
+                        // Match. Take it
+                        extendedArc = true;
+                        CircleEqValid = true;
+                        XC = xc;
+                        YC = yc;
+                        R = r;
+                        CircleFitError = circleFitError;
+                        NoPixels = noPixels;
+
+                        taken[CandidateArcNo] = true;
+                        taken[i] = true;
+
+                        angles.set(arcs[CandidateArcNo].sTheta, arcs[CandidateArcNo].eTheta);
+
+                        // Update the end points of the new arc
+                        switch (Which)
+                        {
+                            // (SX, SY)-(sy, sy)
+                        case 1:
+                            SX = EX, SY = EY;
+                            EX = arcs[CandidateArcNo].ex;
+                            EY = arcs[CandidateArcNo].ey;
+                            if (Turn == 1)
+                                Turn = -1;
+                            else
+                                Turn = 1; // reverse the turn direction
+                            break;
+
+                            // (SX, SY)-(ex, ey)
+                        case 2:
+                            SX = EX, SY = EY;
+                            EX = arcs[CandidateArcNo].sx;
+                            EY = arcs[CandidateArcNo].sy;
+                            if (Turn == 1)
+                                Turn = -1;
+                            else
+                                Turn = 1; // reverse the turn direction
+                            break;
+
+                            // (EX, EY)-(sx, sy)
+                        case 3:
+                            EX = arcs[CandidateArcNo].ex;
+                            EY = arcs[CandidateArcNo].ey;
+                            break;
+
+                            // (EX, EY)-(ex, ey)
+                        case 4:
+                            EX = arcs[CandidateArcNo].sx;
+                            EY = arcs[CandidateArcNo].sy;
+                            break;
+                        } //end-switch
+
+                        break; // Do not look at the other candidates
+                    }
+                }
+            }
+
+            if (extendedArc == false)
+                break;
+        }
+
+        if (CircleEqValid == false)
+        {
+            // Add to arcs
+            edarcs2->arcs[edarcs2->noArcs++] = arcs[i];
+        }
+        else
+        {
+            // Add the current OR the extended arc to the new arcs
+            double sTheta, eTheta;
+            angles.computeStartEndTheta(sTheta, eTheta);
+
+            double coverage = ArcLength(sTheta, eTheta) / CV_2PI;
+            if ((coverage >= FULL_CIRCLE_RATIO && CircleFitError <= LONG_ARC_ERROR))
+                addCircle(circles1, noCircles1, XC, YC, R, CircleFitError, x, y, NoPixels);
+            else
+                addArc(edarcs2->arcs, edarcs2->noArcs, XC, YC, R, CircleFitError, sTheta, eTheta, Turn, arcs[i].segmentNo, SX, SY, EX, EY, x, y, NoPixels, angles.overlapRatio());
+
+            bm->move(NoPixels);
+        }
+    }
+
+    delete[] taken;
+    delete[] candidateArcs;
+}
+
+void EdgeDrawingImpl::JoinArcs2()
+{
+    AngleSet angles;
+
+    // Sort the arcs with respect to their length so that longer arcs are at the beginning
+    sortArc(edarcs2->arcs, edarcs2->noArcs);
+
+    int noArcs = edarcs2->noArcs;
+    MyArc* arcs = edarcs2->arcs;
+
+    bool* taken = new bool[noArcs];
+    for (int i = 0; i < noArcs; i++)
+        taken[i] = false;
+
+    struct CandidateArc
+    {
+        int arcNo;
+        int which;    // 1: (SX, SY)-(sx, sy), 2: (SX, SY)-(ex, ey), 3: (EX, EY)-(sx, sy), 4: (EX, EY)-(ex, ey)
+        double dist;  // min distance between the end points
+    };
+
+    CandidateArc* candidateArcs = new CandidateArc[noArcs];
+    int noCandidateArcs;
+
+    for (int i = 0; i < noArcs; i++)
+    {
+        if (taken[i])
+            continue;
+
+        // Current arc
+        bool EllipseEqValid = false;
+        EllipseEquation Eq;
+        double EllipseFitError(0);
+
+        double R = arcs[i].r;
+        int Turn = arcs[i].turn;
+        int NoPixels = arcs[i].noPixels;
+
+        int SX = arcs[i].sx;
+        int SY = arcs[i].sy;
+        int EX = arcs[i].ex;
+        int EY = arcs[i].ey;
+
+        // Take the pixels making up this arc
+        int noPixels = arcs[i].noPixels;
+
+        double* x = bm->getX();
+        double* y = bm->getY();
+        memcpy(x, arcs[i].x, noPixels * sizeof(double));
+        memcpy(y, arcs[i].y, noPixels * sizeof(double));
+
+        angles.clear();
+        angles.set(arcs[i].sTheta, arcs[i].eTheta);
+
+        while (1)
+        {
+            bool extendedArc = false;
+
+            // Find other arcs to join with
+            noCandidateArcs = 0;
+
+            for (int j = i + 1; j < noArcs; j++)
+            {
+                if (taken[j])
+                    continue;
+                if (arcs[j].segmentNo != arcs[i].segmentNo)
+                    continue;
+                if (arcs[j].turn != Turn)
+                    continue;
+
+                double minR = MIN(R, arcs[j].r);
+                double radiusDiffThreshold = minR * 2.5;
+
+                double diff = fabs(R - arcs[j].r);
+                if (diff > radiusDiffThreshold)
+                    continue;
+
+                // If 75% of the current arc overlaps with the existing arc, then ignore this arc
+                if (angles.overlap(arcs[j].sTheta, arcs[j].eTheta) >= 0.75)
+                    continue;
+
+                // Compute the distances
+                // 1: (SX, SY)-(sx, sy)
+                double dx = SX - arcs[j].sx;
+                double dy = SY - arcs[j].sy;
+                double d = sqrt(dx * dx + dy * dy);
+                int which = 1;
+
+                // 2: (SX, SY)-(ex, ey)
+                dx = SX - arcs[j].ex;
+                dy = SY - arcs[j].ey;
+                double d2 = sqrt(dx * dx + dy * dy);
+
+                if (d2 < d)
+                {
+                    d = d2;
+                    which = 2;
+                }
+
+                // 3: (EX, EY)-(sx, sy)
+                dx = EX - arcs[j].sx;
+                dy = EY - arcs[j].sy;
+                d2 = sqrt(dx * dx + dy * dy);
+
+                if (d2 < d)
+                {
+                    d = d2;
+                    which = 3;
+                }
+
+                // 4: (EX, EY)-(ex, ey)
+                dx = EX - arcs[j].ex;
+                dy = EY - arcs[j].ey;
+                d2 = sqrt(dx * dx + dy * dy);
+
+                if (d2 < d)
+                {
+                    d = d2;
+                    which = 4;
+                }
+
+                // Endpoints must be very close
+                double maxDistanceBetweenEndpoints = 5;
+                if (d > maxDistanceBetweenEndpoints)
+                    continue;
+
+                // Add to candidate arcs in sorted order. User insertion sort
+                int index = noCandidateArcs - 1;
+                while (index >= 0)
+                {
+                    if (candidateArcs[index].dist < d)
+                        break;
+
+                    candidateArcs[index + 1] = candidateArcs[index];
+                    index--;
+                }
+
+                // Add the new candidate arc to the candidate list
+                index++;
+                candidateArcs[index].arcNo = j;
+                candidateArcs[index].which = which;
+                candidateArcs[index].dist = d;
+                noCandidateArcs++;
+            }
+
+            // Try to join the current arc with the candidate arc (if there is one)
+            if (noCandidateArcs > 0)
+            {
+                for (int j = 0; j < noCandidateArcs; j++)
+                {
+                    int CandidateArcNo = candidateArcs[j].arcNo;
+                    int Which = candidateArcs[j].which;
+
+                    int noPixelsSave = noPixels;
+                    memcpy(x + noPixels, arcs[CandidateArcNo].x, arcs[CandidateArcNo].noPixels * sizeof(double));
+                    memcpy(y + noPixels, arcs[CandidateArcNo].y, arcs[CandidateArcNo].noPixels * sizeof(double));
+                    noPixels += arcs[CandidateArcNo].noPixels;
+
+                    // Directly fit an ellipse
+                    EllipseEquation eq;
+                    double ellipseFitError = 1e10;
+                    if (EllipseFit(x, y, noPixels, &eq))
+                        ellipseFitError = ComputeEllipseError(&eq, x, y, noPixels);
+
+                    if (ellipseFitError > ELLIPSE_ERROR)
+                    {
+                        // No match. Continue with the next candidate
+                        noPixels = noPixelsSave;
+                    }
+                    else
+                    {
+                        // Match. Take it
+                        extendedArc = true;
+                        EllipseEqValid = true;
+                        Eq = eq;
+                        EllipseFitError = ellipseFitError;
+                        NoPixels = noPixels;
+
+                        taken[CandidateArcNo] = true;
+                        taken[i] = true;
+
+                        R = (R + arcs[CandidateArcNo].r) / 2.0;
+
+                        angles.set(arcs[CandidateArcNo].sTheta, arcs[CandidateArcNo].eTheta);
+
+                        // Update the end points of the new arc
+                        switch (Which)
+                        {
+                            // (SX, SY)-(sy, sy)
+                        case 1:
+                            SX = EX, SY = EY;
+                            EX = arcs[CandidateArcNo].ex;
+                            EY = arcs[CandidateArcNo].ey;
+                            if (Turn == 1)
+                                Turn = -1;
+                            else
+                                Turn = 1; // reverse the turn direction
+                            break;
+
+                            // (SX, SY)-(ex, ey)
+                        case 2:
+                            SX = EX, SY = EY;
+                            EX = arcs[CandidateArcNo].sx;
+                            EY = arcs[CandidateArcNo].sy;
+                            if (Turn == 1)
+                                Turn = -1;
+                            else
+                                Turn = 1; // reverse the turn direction
+                            break;
+
+                            // (EX, EY)-(sx, sy)
+                        case 3:
+                            EX = arcs[CandidateArcNo].ex;
+                            EY = arcs[CandidateArcNo].ey;
+                            break;
+
+                            // (EX, EY)-(ex, ey)
+                        case 4:
+                            EX = arcs[CandidateArcNo].sx;
+                            EY = arcs[CandidateArcNo].sy;
+                            break;
+                        }
+
+                        break; // Do not look at the other candidates
+                    }
+                }
+            }
+
+            if (extendedArc == false)
+                break;
+        }
+
+        if (EllipseEqValid == false)
+        {
+            // Add to arcs
+            edarcs3->arcs[edarcs3->noArcs++] = arcs[i];
+        }
+        else
+        {
+            // Add the current OR the extended arc to the new arcs
+            double sTheta, eTheta;
+            angles.computeStartEndTheta(sTheta, eTheta);
+
+            double XC, YC, CircleFitError;
+            CircleFit(x, y, NoPixels, &XC, &YC, &R, &CircleFitError);
+
+            double coverage = ArcLength(sTheta, eTheta) / CV_2PI;
+            if ((coverage >= FULL_CIRCLE_RATIO && CircleFitError <= LONG_ARC_ERROR))
+                addCircle(circles1, noCircles1, XC, YC, R, CircleFitError, x, y, NoPixels);
+            else
+                addArc(edarcs3->arcs, edarcs3->noArcs, XC, YC, R, CircleFitError, sTheta, eTheta, Turn, arcs[i].segmentNo, &Eq, EllipseFitError, SX, SY, EX, EY, x, y, NoPixels, angles.overlapRatio());
+
+            // Move buffer pointers
+            bm->move(NoPixels);
+        }
+    }
+
+    delete[] taken;
+    delete[] candidateArcs;
+}
+
+void EdgeDrawingImpl::JoinArcs3()
+{
+    AngleSet angles;
+
+    // Sort the arcs with respect to their length so that longer arcs are at the beginning
+    sortArc(edarcs3->arcs, edarcs3->noArcs);
+
+    int noArcs = edarcs3->noArcs;
+    MyArc* arcs = edarcs3->arcs;
+
+    bool* taken = new bool[noArcs];
+    for (int i = 0; i < noArcs; i++)
+        taken[i] = false;
+
+    struct CandidateArc
+    {
+        int arcNo;
+        int which;    // 1: (SX, SY)-(sx, sy), 2: (SX, SY)-(ex, ey), 3: (EX, EY)-(sx, sy), 4: (EX, EY)-(ex, ey)
+        double dist;  // min distance between the end points
+    };
+
+    CandidateArc* candidateArcs = new CandidateArc[noArcs];
+    int noCandidateArcs;
+
+    for (int i = 0; i < noArcs; i++)
+    {
+        if (taken[i])
+            continue;
+
+        // Current arc
+        bool EllipseEqValid = false;
+        EllipseEquation Eq;
+        double EllipseFitError(0);
+
+        double R = arcs[i].r;
+        int Turn = arcs[i].turn;
+        int NoPixels = arcs[i].noPixels;
+
+        int SX = arcs[i].sx;
+        int SY = arcs[i].sy;
+        int EX = arcs[i].ex;
+        int EY = arcs[i].ey;
+
+        // Take the pixels making up this arc
+        int noPixels = arcs[i].noPixels;
+
+        double* x = bm->getX();
+        double* y = bm->getY();
+        memcpy(x, arcs[i].x, noPixels * sizeof(double));
+        memcpy(y, arcs[i].y, noPixels * sizeof(double));
+
+        angles.clear();
+        angles.set(arcs[i].sTheta, arcs[i].eTheta);
+
+        while (1)
+        {
+            bool extendedArc = false;
+
+            // Find other arcs to join with
+            noCandidateArcs = 0;
+
+            for (int j = i + 1; j < noArcs; j++)
+            {
+                if (taken[j])
+                    continue;
+
+                /******************************************************************
+                * It seems that for minimum false detections,
+                * radiusDiffThreshold =  minR*0.5 & maxDistanceBetweenEndpoints = minR*0.75.
+                * But these parameters results in many valid misses too!
+                ******************************************************************/
+
+                double minR = MIN(R, arcs[j].r);
+                double diff = fabs(R - arcs[j].r);
+                if (diff > minR)
+                    continue;
+
+                // If 50% of the current arc overlaps with the existing arc, then ignore this arc
+                if (angles.overlap(arcs[j].sTheta, arcs[j].eTheta) >= 0.50)
+                    continue;
+
+                // Compute the distances
+                // 1: (SX, SY)-(sx, sy)
+                double dx = SX - arcs[j].sx;
+                double dy = SY - arcs[j].sy;
+                double d = sqrt(dx * dx + dy * dy);
+                int which = 1;
+
+                // 2: (SX, SY)-(ex, ey)
+                dx = SX - arcs[j].ex;
+                dy = SY - arcs[j].ey;
+                double d2 = sqrt(dx * dx + dy * dy);
+
+                if (d2 < d)
+                {
+                    d = d2;
+                    which = 2;
+                }
+
+                // 3: (EX, EY)-(sx, sy)
+                dx = EX - arcs[j].sx;
+                dy = EY - arcs[j].sy;
+                d2 = sqrt(dx * dx + dy * dy);
+
+                if (d2 < d)
+                {
+                    d = d2;
+                    which = 3;
+                }
+
+                // 4: (EX, EY)-(ex, ey)
+                dx = EX - arcs[j].ex;
+                dy = EY - arcs[j].ey;
+                d2 = sqrt(dx * dx + dy * dy);
+
+                if (d2 < d)
+                {
+                    d = d2;
+                    which = 4;
+                }
+
+                // Endpoints must be very close
+                if (diff <= 0.50 * minR)
+                {
+                    if (d > minR * 0.75)
+                        continue;
+                }
+                else if (diff <= 0.75 * minR)
+                {
+                    if (d > minR * 0.50)
+                        continue;
+                }
+                else if (diff <= 1.00 * minR)
+                {
+                    if (d > minR * 0.25)
+                        continue;
+                }
+                else
+                    continue;
+
+                // This is to allow more circular arcs a precedence
+                d += diff;
+
+                // They have to turn in the same direction
+                if (which == 2 || which == 3)
+                {
+                    if (Turn != arcs[j].turn)
+                        continue;
+                }
+                else
+                {
+                    if (Turn == arcs[j].turn)
+                        continue;
+                }
+
+                // Add to candidate arcs in sorted order. User insertion sort
+                int index = noCandidateArcs - 1;
+                while (index >= 0)
+                {
+                    if (candidateArcs[index].dist < d)
+                        break;
+
+                    candidateArcs[index + 1] = candidateArcs[index];
+                    index--;
+                }
+
+                // Add the new candidate arc to the candidate list
+                index++;
+                candidateArcs[index].arcNo = j;
+                candidateArcs[index].which = which;
+                candidateArcs[index].dist = d;
+                noCandidateArcs++;
+            }
+
+            // Try to join the current arc with the candidate arc (if there is one)
+            if (noCandidateArcs > 0)
+            {
+                for (int j = 0; j < noCandidateArcs; j++)
+                {
+                    int CandidateArcNo = candidateArcs[j].arcNo;
+                    int Which = candidateArcs[j].which;
+
+                    int noPixelsSave = noPixels;
+                    memcpy(x + noPixels, arcs[CandidateArcNo].x, arcs[CandidateArcNo].noPixels * sizeof(double));
+                    memcpy(y + noPixels, arcs[CandidateArcNo].y, arcs[CandidateArcNo].noPixels * sizeof(double));
+                    noPixels += arcs[CandidateArcNo].noPixels;
+
+                    // Directly fit an ellipse
+                    EllipseEquation eq;
+                    double ellipseFitError = 1e10;
+                    if (EllipseFit(x, y, noPixels, &eq))
+                        ellipseFitError = ComputeEllipseError(&eq, x, y, noPixels);
+
+                    if (ellipseFitError > ELLIPSE_ERROR)
+                    {
+                        // No match. Continue with the next candidate
+                        noPixels = noPixelsSave;
+                    }
+                    else
+                    {
+                        // Match. Take it
+                        extendedArc = true;
+                        EllipseEqValid = true;
+                        Eq = eq;
+                        EllipseFitError = ellipseFitError;
+                        NoPixels = noPixels;
+
+                        taken[CandidateArcNo] = true;
+                        taken[i] = true;
+
+                        R = (R + arcs[CandidateArcNo].r) / 2.0;
+
+                        angles.set(arcs[CandidateArcNo].sTheta, arcs[CandidateArcNo].eTheta);
+
+                        // Update the end points of the new arc
+                        switch (Which)
+                        {
+                            // (SX, SY)-(sy, sy)
+                        case 1:
+                            SX = EX, SY = EY;
+                            EX = arcs[CandidateArcNo].ex;
+                            EY = arcs[CandidateArcNo].ey;
+                            if (Turn == 1)
+                                Turn = -1;
+                            else
+                                Turn = 1; // reverse the turn direction
+                            break;
+
+                            // (SX, SY)-(ex, ey)
+                        case 2:
+                            SX = EX, SY = EY;
+                            EX = arcs[CandidateArcNo].sx;
+                            EY = arcs[CandidateArcNo].sy;
+                            if (Turn == 1)
+                                Turn = -1;
+                            else
+                                Turn = 1; // reverse the turn direction
+                            break;
+
+                            // (EX, EY)-(sx, sy)
+                        case 3:
+                            EX = arcs[CandidateArcNo].ex;
+                            EY = arcs[CandidateArcNo].ey;
+                            break;
+
+                            // (EX, EY)-(ex, ey)
+                        case 4:
+                            EX = arcs[CandidateArcNo].sx;
+                            EY = arcs[CandidateArcNo].sy;
+                            break;
+                        }
+                        break; // Do not look at the other candidates
+                    }
+                }
+            }
+
+            if (extendedArc == false)
+                break;
+        }
+
+        if (EllipseEqValid == false)
+        {
+            // Add to arcs
+            edarcs4->arcs[edarcs4->noArcs++] = arcs[i];
+        }
+        else
+        {
+            // Add the current OR the extended arc to the new arcs
+            double sTheta, eTheta;
+            angles.computeStartEndTheta(sTheta, eTheta);
+
+            double XC, YC, CircleFitError;
+            CircleFit(x, y, NoPixels, &XC, &YC, &R, &CircleFitError);
+
+            double coverage = ArcLength(sTheta, eTheta) / CV_2PI;
+            if ((coverage >= FULL_CIRCLE_RATIO && CircleFitError <= LONG_ARC_ERROR))
+                addCircle(circles1, noCircles1, XC, YC, R, CircleFitError, x, y, NoPixels);
+            else
+                addArc(edarcs4->arcs, edarcs4->noArcs, XC, YC, R, CircleFitError, sTheta, eTheta, Turn, arcs[i].segmentNo, &Eq, EllipseFitError, SX, SY, EX, EY, x, y, NoPixels, angles.overlapRatio());
+
+            bm->move(NoPixels);
+        }
+    }
+
+    delete[] taken;
+    delete[] candidateArcs;
+}
+
+void EdgeDrawingImpl::addCircle(Circle* circles, int& noCircles, double xc, double yc, double r, double circleFitError, double* x, double* y, int noPixels)
+{
+    circles[noCircles].xc = xc;
+    circles[noCircles].yc = yc;
+    circles[noCircles].r = r;
+    circles[noCircles].circleFitError = circleFitError;
+    circles[noCircles].coverRatio = noPixels / CV_2PI * r;
+
+    circles[noCircles].x = x;
+    circles[noCircles].y = y;
+    circles[noCircles].noPixels = noPixels;
+
+    circles[noCircles].isEllipse = false;
+
+    noCircles++;
+}
+
+void EdgeDrawingImpl::addCircle(Circle* circles, int& noCircles, double xc, double yc, double r, double circleFitError, EllipseEquation* pEq, double ellipseFitError, double* x, double* y, int noPixels)
+{
+    circles[noCircles].xc = xc;
+    circles[noCircles].yc = yc;
+    circles[noCircles].r = r;
+    circles[noCircles].circleFitError = circleFitError;
+    circles[noCircles].coverRatio = noPixels / computeEllipsePerimeter(pEq);
+
+    circles[noCircles].x = x;
+    circles[noCircles].y = y;
+    circles[noCircles].noPixels = noPixels;
+
+    circles[noCircles].eq = *pEq;
+    circles[noCircles].ellipseFitError = ellipseFitError;
+    circles[noCircles].isEllipse = true;
+
+    noCircles++;
+}
+
+void EdgeDrawingImpl::sortCircles(Circle* circles, int noCircles)
+{
+    for (int i = 0; i < noCircles - 1; i++)
+    {
+        int max = i;
+        for (int j = i + 1; j < noCircles; j++)
+        {
+            if (circles[j].r > circles[max].r)
+                max = j;
+        }
+
+        if (max != i)
+        {
+            Circle t = circles[i];
+            circles[i] = circles[max];
+            circles[max] = t;
+        }
+    }
+}
+
+
+// ---------------------------------------------------------------------------
+// Given an ellipse equation, computes the length of the perimeter of the ellipse
+// Calculates the ellipse perimeter wrt the Ramajunan II formula
+//
+double EdgeDrawingImpl::computeEllipsePerimeter(EllipseEquation* eq)
+{
+    double mult = 1;
+
+    double A = eq->A() * mult;
+    double B = eq->B() * mult;
+    double C = eq->C() * mult;
+    double D = eq->D() * mult;
+    double E = eq->E() * mult;
+    double F = eq->F() * mult;
+
+    double A2(0), C2(0), D2(0), E2(0), F2(0), theta(0);  //rotated coefficients
+    double D3, E3, F3;                                   //ellipse form coefficients
+    double cX, cY, a, b;                                 //(cX,cY) center, a & b: semimajor & semiminor axes
+    double h;                                            //h = (a-b)^2 / (a+b)^2
+    bool rotation = false;
+
+    //Normalize coefficients
+    B /= A;
+    C /= A;
+    D /= A;
+    E /= A;
+    F /= A;
+    A /= A;
+
+    if (B == 0) //Then not need to rotate the axes
+    {
+        A2 = A;
+        C2 = C;
+        D2 = D;
+        E2 = E;
+        F2 = F;
+    }
+
+    else if (B != 0) //Rotate the axes
+    {
+        rotation = true;
+
+        //Determine the rotation angle (in radians)
+        theta = atan(B / (A - C)) / 2;
+
+        //Compute the coefficients wrt the new coordinate system
+        A2 = 0.5 * (A * (1 + cos(2 * theta) + B * sin(2 * theta) + C * (1 - cos(2 * theta))));
+
+        C2 = 0.5 * (A * (1 - cos(2 * theta) - B * sin(2 * theta) + C * (1 + cos(2 * theta))));
+
+        D2 = D * cos(theta) + E * sin(theta);
+
+        E2 = -D * sin(theta) + E * cos(theta);
+
+        F2 = F;
+    }
+
+    //Transform the conic equation into the ellipse form
+    D3 = D2 / A2; //normalize x term's coef
+
+    E3 = E2 / C2; //normalize y term's coef
+
+    cX = -(D3 / 2);   //center X
+    cY = -(E3 / 2);   //center Y
+
+    F3 = A2 * pow(cX, 2.0) + C2 * pow(cY, 2.0) - F2;
+
+    //semimajor axis
+    a = sqrt(F3 / A2);
+    //semiminor axis
+    b = sqrt(F3 / C2);
+
+    //Center coordinates have to be re-transformed if rotation is applied!
+    if (rotation)
+    {
+        double tmpX = cX, tmpY = cY;
+        cX = tmpX * cos(theta) - tmpY * sin(theta);
+        cY = tmpX * sin(theta) + tmpY * cos(theta);
+    }
+
+    //Perimeter Computation(s)
+    h = pow((a - b), 2.0) / pow((a + b), 2.0);
+
+    //Ramajunan II
+    double P2 = CV_PI * (a + b) * (1 + 3 * h / (10 + sqrt(4 - 3 * h)));
+
+    return P2;
+}
+
+double EdgeDrawingImpl::ComputeEllipseError(EllipseEquation* eq, double* px, double* py, int noPoints)
+{
+    double error = 0;
+
+    double A = eq->A();
+    double B = eq->B();
+    double C = eq->C();
+    double D = eq->D();
+    double E = eq->E();
+    double F = eq->F();
+
+    double xc, yc, major, minor;
+    ComputeEllipseCenterAndAxisLengths(eq, &xc, &yc, &major, &minor);
+
+    for (int i = 0; i < noPoints; i++)
+    {
+        double dx = px[i] - xc;
+        double dy = py[i] - yc;
+
+        double min;
+        double xs;
+
+        if (fabs(dx) > fabs(dy))
+        {
+            // The line equation is of the form: y = mx+n
+            double m = dy / dx;
+            double n = yc - m * xc;
+
+            // a*x^2 + b*x + c
+            double a = A + B * m + C * m * m;
+            double b = B * n + 2 * C * m * n + D + E * m;
+            double c = C * n * n + E * n + F;
+            double det = b * b - 4 * a * c;
+            if (det < 0)
+                det = 0;
+            double x1 = -(b + sqrt(det)) / (2 * a);
+            double x2 = -(b - sqrt(det)) / (2 * a);
+
+            double y1 = m * x1 + n;
+            double y2 = m * x2 + n;
+
+            dx = px[i] - x1;
+            dy = py[i] - y1;
+            double d1 = dx * dx + dy * dy;
+
+            dx = px[i] - x2;
+            dy = py[i] - y2;
+            double d2 = dx * dx + dy * dy;
+
+            if (d1 < d2)
+            {
+                min = d1;
+                xs = x1;
+            }
+            else
+            {
+                min = d2;
+                xs = x2;
+            }
+        }
+        else
+        {
+            // The line equation is of the form: x = my+n
+            double m = dx / dy;
+            double n = xc - m * yc;
+
+            // a*y^2 + b*y + c
+            double a = A * m * m + B * m + C;
+            double b = 2 * A * m * n + B * n + D * m + E;
+            double c = A * n * n + D * n + F;
+            double det = b * b - 4 * a * c;
+            if (det < 0)
+                det = 0;
+            double y1 = -(b + sqrt(det)) / (2 * a);
+            double y2 = -(b - sqrt(det)) / (2 * a);
+
+            double x1 = m * y1 + n;
+            double x2 = m * y2 + n;
+
+            dx = px[i] - x1;
+            dy = py[i] - y1;
+            double d1 = dx * dx + dy * dy;
+
+            dx = px[i] - x2;
+            dy = py[i] - y2;
+            double d2 = dx * dx + dy * dy;
+
+            if (d1 < d2)
+            {
+                min = d1;
+                xs = x1;
+            }
+            else
+            {
+                min = d2;
+                xs = x2;
+            }
+        }
+
+        // Refine the search in the vicinity of (xs, ys)
+        double delta = 0.5;
+        double x = xs;
+        while (1)
+        {
+            x += delta;
+
+            double a = C;
+            double b = B * x + E;
+            double c = A * x * x + D * x + F;
+            double det = b * b - 4 * a * c;
+            if (det < 0)
+                det = 0;
+
+            double y1 = -(b + sqrt(det)) / (2 * a);
+            double y2 = -(b - sqrt(det)) / (2 * a);
+
+            dx = px[i] - x;
+            dy = py[i] - y1;
+            double d1 = dx * dx + dy * dy;
+
+            dy = py[i] - y2;
+            double d2 = dx * dx + dy * dy;
+
+            if (d1 <= min)
+            {
+                min = d1;
+            }
+            else if (d2 <= min)
+            {
+                min = d2;
+            }
+            else
+                break;
+        }
+
+        x = xs;
+        while (1)
+        {
+            x -= delta;
+
+            double a = C;
+            double b = B * x + E;
+            double c = A * x * x + D * x + F;
+            double det = b * b - 4 * a * c;
+            if (det < 0)
+                det = 0;
+
+            double y1 = -(b + sqrt(det)) / (2 * a);
+            double y2 = -(b - sqrt(det)) / (2 * a);
+
+            dx = px[i] - x;
+            dy = py[i] - y1;
+            double d1 = dx * dx + dy * dy;
+
+            dy = py[i] - y2;
+            double d2 = dx * dx + dy * dy;
+
+            if (d1 <= min)
+            {
+                min = d1;
+            }
+            else if (d2 <= min)
+            {
+                min = d2;
+            }
+            else
+                break;
+        }
+        error += min;
+    }
+
+    error = sqrt(error / noPoints);
+
+    return error;
+}
+
+// also returns rotate angle theta
+double EdgeDrawingImpl::ComputeEllipseCenterAndAxisLengths(EllipseEquation* eq, double* pxc, double* pyc, double* pmajorAxisLength, double* pminorAxisLength)
+{
+    double mult = 1;
+
+    double A = eq->A() * mult;
+    double B = eq->B() * mult;
+    double C = eq->C() * mult;
+    double D = eq->D() * mult;
+    double E = eq->E() * mult;
+    double F = eq->F() * mult;
+
+    double A2(0), C2(0), D2(0), E2(0), F2(0), theta(0);  //rotated coefficients
+    double D3, E3, F3;                                   //ellipse form coefficients
+    double cX, cY, a, b;                                 //(cX,cY) center, a & b: semimajor & semiminor axes
+    bool rotation = false;
+
+    //Normalize coefficients
+    B /= A;
+    C /= A;
+    D /= A;
+    E /= A;
+    F /= A;
+    A /= A;
+
+    if (B == 0) //Then not need to rotate the axes
+    {
+        A2 = A;
+        C2 = C;
+        D2 = D;
+        E2 = E;
+        F2 = F;
+    }
+    else if (B != 0) //Rotate the axes
+    {
+        rotation = true;
+
+        //Determine the rotation angle (in radians)
+        theta = atan(B / (A - C)) / 2;
+
+        //Compute the coefficients wrt the new coordinate system
+        A2 = 0.5 * (A * (1 + cos(2 * theta) + B * sin(2 * theta) + C * (1 - cos(2 * theta))));
+
+        C2 = 0.5 * (A * (1 - cos(2 * theta) - B * sin(2 * theta) + C * (1 + cos(2 * theta))));
+
+        D2 = D * cos(theta) + E * sin(theta);
+
+        E2 = -D * sin(theta) + E * cos(theta);
+
+        F2 = F;
+    }
+
+    //Transform the conic equation into the ellipse form
+    D3 = D2 / A2; //normalize x term's coef
+
+    E3 = E2 / C2; //normalize y term's coef
+
+    cX = -(D3 / 2);   //center X
+    cY = -(E3 / 2);   //center Y
+
+    F3 = A2 * pow(cX, 2.0) + C2 * pow(cY, 2.0) - F2;
+
+    //semimajor axis
+    a = sqrt(F3 / A2);
+    //semiminor axis
+    b = sqrt(F3 / C2);
+
+    //Center coordinates have to be re-transformed if rotation is applied!
+    if (rotation)
+    {
+        double tmpX = cX, tmpY = cY;
+        cX = tmpX * cos(theta) - tmpY * sin(theta);
+        cY = tmpX * sin(theta) + tmpY * cos(theta);
+    }
+
+    *pxc = cX;
+    *pyc = cY;
+
+    *pmajorAxisLength = a;
+    *pminorAxisLength = b;
+
+    return theta;
+}
+
+// ---------------------------------------------------------------------------
+// Given an ellipse equation, computes "noPoints" many consecutive points
+// on the ellipse periferi. These points can be used to draw the ellipse
+//
+void EdgeDrawingImpl::ComputeEllipsePoints(double* pvec, double* px, double* py, int noPoints)
+{
+    int npts = noPoints / 2;
+
+    double** u = AllocateMatrix(3, npts + 1);
+    double** Aiu = AllocateMatrix(3, npts + 1);
+    double** L = AllocateMatrix(3, npts + 1);
+    double** B = AllocateMatrix(3, npts + 1);
+    double** Xpos = AllocateMatrix(3, npts + 1);
+    double** Xneg = AllocateMatrix(3, npts + 1);
+    double** ss1 = AllocateMatrix(3, npts + 1);
+    double** ss2 = AllocateMatrix(3, npts + 1);
+    double* lambda = new double[npts + 1];
+    double** uAiu = AllocateMatrix(3, npts + 1);
+    double** A = AllocateMatrix(3, 3);
+    double** Ai = AllocateMatrix(3, 3);
+    double** Aib = AllocateMatrix(3, 2);
+    double** b = AllocateMatrix(3, 2);
+    double** r1 = AllocateMatrix(2, 2);
+    double Ao, Ax, Ay, Axx, Ayy, Axy;
+    double theta;
+    int i;
+    int j;
+    double kk;
+
+    memset(lambda, 0, sizeof(double) * (npts + 1));
+
+    Ao = pvec[6];
+    Ax = pvec[4];
+    Ay = pvec[5];
+    Axx = pvec[1];
+    Ayy = pvec[3];
+    Axy = pvec[2];
+
+    A[1][1] = Axx;
+    A[1][2] = Axy / 2;
+    A[2][1] = Axy / 2;
+    A[2][2] = Ayy;
+    b[1][1] = Ax;
+    b[2][1] = Ay;
+
+    // Generate normals linspace
+    for (i = 1, theta = 0.0; i <= npts; i++, theta += (CV_PI / npts))
+    {
+        u[1][i] = cos(theta);
+        u[2][i] = sin(theta);
+    }
+
+    inverse(A, Ai, 2);
+
+    AperB(Ai, b, Aib, 2, 2, 2, 1);
+    A_TperB(b, Aib, r1, 2, 1, 2, 1);
+    r1[1][1] = r1[1][1] - 4 * Ao;
+
+    AperB(Ai, u, Aiu, 2, 2, 2, npts);
+    for (i = 1; i <= 2; i++)
+        for (j = 1; j <= npts; j++)
+            uAiu[i][j] = u[i][j] * Aiu[i][j];
+
+    for (j = 1; j <= npts; j++)
+    {
+        if ((kk = (r1[1][1] / (uAiu[1][j] + uAiu[2][j]))) >= 0.0)
+            lambda[j] = sqrt(kk);
+        else
+            lambda[j] = -1.0;
+    }
+
+    // Builds up B and L
+    for (j = 1; j <= npts; j++)
+        L[1][j] = L[2][j] = lambda[j];
+    for (j = 1; j <= npts; j++)
+    {
+        B[1][j] = b[1][1];
+        B[2][j] = b[2][1];
+    }
+
+    for (j = 1; j <= npts; j++)
+    {
+        ss1[1][j] = 0.5 * (L[1][j] * u[1][j] - B[1][j]);
+        ss1[2][j] = 0.5 * (L[2][j] * u[2][j] - B[2][j]);
+        ss2[1][j] = 0.5 * (-L[1][j] * u[1][j] - B[1][j]);
+        ss2[2][j] = 0.5 * (-L[2][j] * u[2][j] - B[2][j]);
+    }
+
+    AperB(Ai, ss1, Xpos, 2, 2, 2, npts);
+    AperB(Ai, ss2, Xneg, 2, 2, 2, npts);
+
+    for (j = 1; j <= npts; j++)
+    {
+        if (lambda[j] == -1.0)
+        {
+            px[j - 1] = -1;
+            py[j - 1] = -1;
+            px[j - 1 + npts] = -1;
+            py[j - 1 + npts] = -1;
+        }
+        else
+        {
+            px[j - 1] = Xpos[1][j];
+            py[j - 1] = Xpos[2][j];
+            px[j - 1 + npts] = Xneg[1][j];
+            py[j - 1 + npts] = Xneg[2][j];
+        }
+    }
+
+    DeallocateMatrix(u, 3);
+    DeallocateMatrix(Aiu, 3);
+    DeallocateMatrix(L, 3);
+    DeallocateMatrix(B, 3);
+    DeallocateMatrix(Xpos, 3);
+    DeallocateMatrix(Xneg, 3);
+    DeallocateMatrix(ss1, 3);
+    DeallocateMatrix(ss2, 3);
+    delete[] lambda;
+    DeallocateMatrix(uAiu, 3);
+    DeallocateMatrix(A, 3);
+    DeallocateMatrix(Ai, 3);
+    DeallocateMatrix(Aib, 3);
+    DeallocateMatrix(b, 3);
+    DeallocateMatrix(r1, 2);
+}
+
+
+// Tries to join the last two arcs if their end-points are very close to each other
+// and if they are part of the same segment. This is useful in cases where an arc on a segment
+// is broken due to a noisy patch along the arc, and the long arc is broken into two or more arcs.
+// This function will join such broken arcs
+//
+void EdgeDrawingImpl::joinLastTwoArcs(MyArc* arcs, int& noArcs)
+{
+    if (noArcs < 2)
+        return;
+
+    int prev = noArcs - 2;
+    int last = noArcs - 1;
+
+    if (arcs[prev].segmentNo != arcs[last].segmentNo)
+        return;
+    if (arcs[prev].turn != arcs[last].turn)
+        return;
+    if (arcs[prev].isEllipse || arcs[last].isEllipse)
+        return;
+
+    // The radius difference between the arcs must be very small
+    double minR = MIN(arcs[prev].r, arcs[last].r);
+    double radiusDiffThreshold = minR * 0.25;
+
+    double diff = fabs(arcs[prev].r - arcs[last].r);
+    if (diff > radiusDiffThreshold)
+        return;
+
+    // End-point distance
+    double dx = arcs[prev].ex - arcs[last].sx;
+    double dy = arcs[prev].ey - arcs[last].sy;
+    double d = sqrt(dx * dx + dy * dy);
+
+    double endPointDiffThreshold = 10;
+    if (d > endPointDiffThreshold)
+        return;
+
+    // Try join
+    int noPixels = arcs[prev].noPixels + arcs[last].noPixels;
+
+    double xc, yc, r, circleFitError;
+    CircleFit(arcs[prev].x, arcs[prev].y, noPixels, &xc, &yc, &r, &circleFitError);
+
+    if (circleFitError <= LONG_ARC_ERROR)
+    {
+        arcs[prev].noPixels = noPixels;
+        arcs[prev].circleFitError = circleFitError;
+
+        arcs[prev].xc = xc;
+        arcs[prev].yc = yc;
+        arcs[prev].r = r;
+        arcs[prev].ex = arcs[last].ex;
+        arcs[prev].ey = arcs[last].ey;
+
+        AngleSet angles;
+        angles.set(arcs[prev].sTheta, arcs[prev].eTheta);
+        angles.set(arcs[last].sTheta, arcs[last].eTheta);
+        angles.computeStartEndTheta(arcs[prev].sTheta, arcs[prev].eTheta);
+
+        arcs[prev].coverRatio = ArcLength(arcs[prev].sTheta, arcs[prev].eTheta) / (CV_2PI);
+
+        noArcs--;
+    }
+}
+
+
+//-----------------------------------------------------------------------
+// Add a new arc to arcs
+//
+void EdgeDrawingImpl::addArc(MyArc* arcs, int& noArcs, double xc, double yc, double r, double circleFitError, double sTheta, double eTheta, int turn, int segmentNo, int sx, int sy, int ex, int ey, double* x, double* y, int noPixels, double overlapRatio)
+{
+    CV_UNUSED(overlapRatio);
+    arcs[noArcs].xc = xc;
+    arcs[noArcs].yc = yc;
+    arcs[noArcs].r = r;
+    arcs[noArcs].circleFitError = circleFitError;
+
+    arcs[noArcs].sTheta = sTheta;
+    arcs[noArcs].eTheta = eTheta;
+    arcs[noArcs].coverRatio = ArcLength(sTheta, eTheta) / CV_2PI;
+
+    arcs[noArcs].turn = turn;
+
+    arcs[noArcs].segmentNo = segmentNo;
+
+    arcs[noArcs].isEllipse = false;
+
+    arcs[noArcs].sx = sx;
+    arcs[noArcs].sy = sy;
+    arcs[noArcs].ex = ex;
+    arcs[noArcs].ey = ey;
+
+    arcs[noArcs].x = x;
+    arcs[noArcs].y = y;
+    arcs[noArcs].noPixels = noPixels;
+
+    noArcs++;
+
+    // See if you can join the last two arcs
+    joinLastTwoArcs(arcs, noArcs);
+}
+
+//-------------------------------------------------------------------------
+// Add an elliptic arc to the list of arcs
+//
+void EdgeDrawingImpl::addArc(MyArc* arcs, int& noArcs, double xc, double yc, double r, double circleFitError, double sTheta, double eTheta, int turn, int segmentNo, EllipseEquation* pEq, double ellipseFitError, int sx, int sy, int ex, int ey, double* x, double* y, int noPixels, double overlapRatio)
+{
+    arcs[noArcs].xc = xc;
+    arcs[noArcs].yc = yc;
+    arcs[noArcs].r = r;
+    arcs[noArcs].circleFitError = circleFitError;
+
+    arcs[noArcs].sTheta = sTheta;
+    arcs[noArcs].eTheta = eTheta;
+    arcs[noArcs].coverRatio = (double)((1.0 - overlapRatio) * noPixels) / computeEllipsePerimeter(pEq);
+    arcs[noArcs].turn = turn;
+
+    arcs[noArcs].segmentNo = segmentNo;
+
+    arcs[noArcs].isEllipse = true;
+    arcs[noArcs].eq = *pEq;
+    arcs[noArcs].ellipseFitError = ellipseFitError;
+
+    arcs[noArcs].sx = sx;
+    arcs[noArcs].sy = sy;
+    arcs[noArcs].ex = ex;
+    arcs[noArcs].ey = ey;
+
+    arcs[noArcs].x = x;
+    arcs[noArcs].y = y;
+    arcs[noArcs].noPixels = noPixels;
+
+    noArcs++;
+}
+
+//--------------------------------------------------------------
+// Given a circular arc, computes the start & end angles of the arc in radians
+//
+void EdgeDrawingImpl::ComputeStartAndEndAngles(double xc, double yc, double r, double* x, double* y, int len, double* psTheta, double* peTheta)
+{
+    double sx = x[0];
+    double sy = y[0];
+    double ex = x[len - 1];
+    double ey = y[len - 1];
+    double mx = x[len / 2];
+    double my = y[len / 2];
+
+    double d = (sx - xc) / r;
+    if (d > 1.0)
+        d = 1.0;
+    else if (d < -1.0)
+        d = -1.0;
+    double theta1 = acos(d);
+
+    double sTheta;
+    if (sx >= xc)
+    {
+        if (sy >= yc)
+        {
+            // I. quadrant
+            sTheta = theta1;
+        }
+        else
+        {
+            // IV. quadrant
+            sTheta = CV_2PI - theta1;
+        }
+    }
+    else
+    {
+        if (sy >= yc)
+        {
+            // II. quadrant
+            sTheta = theta1;
+        }
+        else
+        {
+            // III. quadrant
+            sTheta = CV_2PI - theta1;
+        }
+    }
+
+    d = (ex - xc) / r;
+    if (d > 1.0)
+        d = 1.0;
+    else if (d < -1.0)
+        d = -1.0;
+    theta1 = acos(d);
+
+    double eTheta;
+    if (ex >= xc)
+    {
+        if (ey >= yc)
+        {
+            // I. quadrant
+            eTheta = theta1;
+        }
+        else
+        {
+            // IV. quadrant
+            eTheta = CV_2PI - theta1;
+        }
+    }
+    else
+    {
+        if (ey >= yc)
+        {
+            // II. quadrant
+            eTheta = theta1;
+        }
+        else
+        {
+            // III. quadrant
+            eTheta = CV_2PI - theta1;
+        }
+    }
+
+    // Determine whether the arc is clockwise (CW) or counter-clockwise (CCW)
+    double circumference = CV_2PI * r;
+    double ratio = len / circumference;
+
+    if (ratio <= 0.25 || ratio >= 0.75)
+    {
+        double angle1, angle2;
+
+        if (eTheta > sTheta)
+        {
+            angle1 = eTheta - sTheta;
+            angle2 = CV_2PI - eTheta + sTheta;
+        }
+        else
+        {
+            angle1 = sTheta - eTheta;
+            angle2 = CV_2PI - sTheta + eTheta;
+        }
+
+        angle1 = angle1 / CV_2PI;
+        angle2 = angle2 / CV_2PI;
+
+        double diff1 = fabs(ratio - angle1);
+        double diff2 = fabs(ratio - angle2);
+
+        if (diff1 < diff2)
+        {
+            // angle1 is correct
+            if (eTheta > sTheta)
+            {
+                ;
+            }
+            else
+            {
+                double tmp = sTheta;
+                sTheta = eTheta;
+                eTheta = tmp;
+            }
+        }
+        else
+        {
+            // angle2 is correct
+            if (eTheta > sTheta)
+            {
+                double tmp = sTheta;
+                sTheta = eTheta;
+                eTheta = tmp;
+            }
+        }
+    }
+    else
+    {
+        double v1x = mx - sx;
+        double v1y = my - sy;
+        double v2x = ex - mx;
+        double v2y = ey - my;
+
+        // cross product
+        double cross = v1x * v2y - v1y * v2x;
+        if (cross < 0)
+        {
+            // swap sTheta & eTheta
+            double tmp = sTheta;
+            sTheta = eTheta;
+            eTheta = tmp;
+        }
+    }
+
+    double diff = fabs(sTheta - eTheta);
+    if (diff < (CV_2PI / 120))
+    {
+        sTheta = 0;
+        eTheta = 6.26;   // 359 degrees
+    }
+
+    // Round the start & etheta to 0 if very close to 6.28 or 0
+    if (sTheta >= 6.26)
+        sTheta = 0;
+    if (eTheta < 1.0 / CV_2PI)
+        eTheta = 6.28;  // if less than 1 degrees, then round to 6.28
+
+    *psTheta = sTheta;
+    *peTheta = eTheta;
+}
+
+void EdgeDrawingImpl::sortArc(MyArc* arcs, int noArcs)
+{
+    for (int i = 0; i < noArcs - 1; i++)
+    {
+        int max = i;
+        for (int j = i + 1; j < noArcs; j++)
+        {
+            if (arcs[j].coverRatio > arcs[max].coverRatio)
+                max = j;
+        }
+
+        if (max != i)
+        {
+            MyArc t = arcs[i];
+            arcs[i] = arcs[max];
+            arcs[max] = t;
+        }
+    }
+}
+
+
+//---------------------------------------------------------------------
+// Fits a circle to a given set of points. There must be at least 2 points
+// The circle equation is of the form: (x-xc)^2 + (y-yc)^2 = r^2
+// Returns true if there is a fit, false in case no circles can be fit
+//
+bool EdgeDrawingImpl::CircleFit(double* x, double* y, int N, double* pxc, double* pyc, double* pr, double* pe)
+{
+    *pe = 1e20;
+    if (N < 3)
+        return false;
+
+    double xAvg = 0;
+    double yAvg = 0;
+
+    for (int i = 0; i < N; i++)
+    {
+        xAvg += x[i];
+        yAvg += y[i];
+    }
+
+    xAvg /= N;
+    yAvg /= N;
+
+    double Suu = 0;
+    double Suv = 0;
+    double Svv = 0;
+    double Suuu = 0;
+    double Suvv = 0;
+    double Svvv = 0;
+    double Svuu = 0;
+
+    for (int i = 0; i < N; i++)
+    {
+        double u = x[i] - xAvg;
+        double v = y[i] - yAvg;
+
+        Suu += u * u;
+        Suv += u * v;
+        Svv += v * v;
+        Suuu += u * u * u;
+        Suvv += u * v * v;
+        Svvv += v * v * v;
+        Svuu += v * u * u;
+    }
+
+    // Now, we solve for the following linear system of equations
+    // Av = b, where v = (uc, vc) is the center of the circle
+    //
+    // |N    Suv| |uc| = |b1|
+    // |Suv  Svv| |vc| = |b2|
+    //
+    // where b1 = 0.5*(Suuu+Suvv) and b2 = 0.5*(Svvv+Svuu)
+    //
+    double detA = Suu * Svv - Suv * Suv;
+    if (detA == 0)
+        return false;
+
+    double b1 = 0.5 * (Suuu + Suvv);
+    double b2 = 0.5 * (Svvv + Svuu);
+
+    double uc = (Svv * b1 - Suv * b2) / detA;
+    double vc = (Suu * b2 - Suv * b1) / detA;
+
+    double R = sqrt(uc * uc + vc * vc + (Suu + Svv) / N);
+
+    *pxc = uc + xAvg;
+    *pyc = vc + yAvg;
+
+    // Compute mean square error
+    double error = 0;
+    for (int i = 0; i < N; i++)
+    {
+        double dx = x[i] - *pxc;
+        double dy = y[i] - *pyc;
+        double d = sqrt(dx * dx + dy * dy) - R;
+        error += d * d;
+    }
+
+    *pr = R;
+    *pe = sqrt(error / N);
+
+    return true;
+}
+
+
+//------------------------------------------------------------------------------------
+// Computes the points making up a circle
+//
+void EdgeDrawingImpl::ComputeCirclePoints(double xc, double yc, double r, double* px, double* py, int* noPoints)
+{
+    int len = (int)(CV_2PI * r + 0.5);
+    double angleInc = CV_2PI / len;
+    double angle = 0;
+
+    int count = 0;
+
+    while (angle < CV_2PI)
+    {
+        int x = (int)(cos(angle) * r + xc + 0.5);
+        int y = (int)(sin(angle) * r + yc + 0.5);
+
+        angle += angleInc;
+
+        px[count] = x;
+        py[count] = y;
+        count++;
+    }
+
+    *noPoints = count;
+}
+
+bool EdgeDrawingImpl::EllipseFit(double* x, double* y, int noPoints, EllipseEquation* pResult, int mode)
+{
+    double** D = AllocateMatrix(noPoints + 1, 7);
+    double** S = AllocateMatrix(7, 7);
+    double** Const = AllocateMatrix(7, 7);
+    double** temp = AllocateMatrix(7, 7);
+    double** L = AllocateMatrix(7, 7);
+    double** C = AllocateMatrix(7, 7);
+
+    double** invL = AllocateMatrix(7, 7);
+    double* d = new double[7];
+    double** V = AllocateMatrix(7, 7);
+    double** sol = AllocateMatrix(7, 7);
+    double tx, ty;
+
+    memset(d, 0, sizeof(double) * 7);
+
+    switch (mode)
+    {
+    case (FPF):
+        Const[1][3] = -2;
+        Const[2][2] = 1;
+        Const[3][1] = -2;
+        break;
+    case (BOOKSTEIN):
+        Const[1][1] = 2;
+        Const[2][2] = 1;
+        Const[3][3] = 2;
+    }
+
+    if (noPoints < 6)
+        return false;
+
+    // Now first fill design matrix
+    for (int i = 1; i <= noPoints; i++)
+    {
+        tx = x[i - 1];
+        ty = y[i - 1];
+
+        D[i][1] = tx * tx;
+        D[i][2] = tx * ty;
+        D[i][3] = ty * ty;
+        D[i][4] = tx;
+        D[i][5] = ty;
+        D[i][6] = 1.0;
+    }
+
+    // Now compute scatter matrix  S
+    A_TperB(D, D, S, noPoints, 6, noPoints, 6);
+
+    choldc(S, 6, L);
+
+    inverse(L, invL, 6);
+
+    AperB_T(Const, invL, temp, 6, 6, 6, 6);
+    AperB(invL, temp, C, 6, 6, 6, 6);
+
+    jacobi(C, 6, d, V);
+
+    A_TperB(invL, V, sol, 6, 6, 6, 6);
+
+    // Now normalize them
+    for (int j = 1; j <= 6; j++)  /* Scan columns */
+    {
+        double mod = 0.0;
+        for (int i = 1; i <= 6; i++)
+            mod += sol[i][j] * sol[i][j];
+        for (int i = 1; i <= 6; i++)
+            sol[i][j] /= sqrt(mod);
+    }
+
+    double zero = 10e-20;
+    double minev = 10e+20;
+    int solind = 0;
+    int i;
+    switch (mode)
+    {
+    case (BOOKSTEIN):  // smallest eigenvalue
+        for (i = 1; i <= 6; i++)
+            if (d[i] < minev && fabs(d[i]) > zero)
+                solind = i;
+        break;
+    case (FPF):
+        for (i = 1; i <= 6; i++)
+            if (d[i] < 0 && fabs(d[i]) > zero)
+                solind = i;
+    }
+
+    bool valid = true;
+    if (solind == 0)
+        valid = false;
+
+    if (valid)
+    {
+        // Now fetch the right solution
+        for (int j = 1; j <= 6; j++)
+        {
+            pResult->coeff[j] = sol[j][solind];
+        }
+    }
+
+    DeallocateMatrix(D, noPoints + 1);
+    DeallocateMatrix(S, 7);
+    DeallocateMatrix(Const, 7);
+    DeallocateMatrix(temp, 7);
+    DeallocateMatrix(L, 7);
+    DeallocateMatrix(C, 7);
+    DeallocateMatrix(invL, 7);
+    delete[] d;
+    DeallocateMatrix(V, 7);
+    DeallocateMatrix(sol, 7);
+
+    if (valid)
+    {
+        int len = (int)computeEllipsePerimeter(pResult);
+        if (len <= 0 || len > 50000)
+            valid = false;
+    }
+
+    return valid;
+}
+
+double** EdgeDrawingImpl::AllocateMatrix(int noRows, int noColumns)
+{
+    double** m = new double* [noRows];
+
+    for (int i = 0; i < noRows; i++)
+    {
+        m[i] = new double[noColumns];
+        memset(m[i], 0, sizeof(double) * noColumns);
+    }
+
+    return m;
+}
+
+void EdgeDrawingImpl::A_TperB(double** A_, double** B_, double** _res, int _righA, int _colA, int _righB, int _colB)
+{
+    CV_UNUSED(_righB);
+    int p, q, l;
+    for (p = 1; p <= _colA; p++)
+        for (q = 1; q <= _colB; q++)
+        {
+            _res[p][q] = 0.0;
+            for (l = 1; l <= _righA; l++)
+                _res[p][q] = _res[p][q] + A_[l][p] * B_[l][q];
+        }
+}
+
+//-----------------------------------------------------------
+// Perform the Cholesky decomposition
+// Return the lower triangular L  such that L*L'=A
+//
+void EdgeDrawingImpl::choldc(double** a, int n, double** l)
+{
+    int i, j, k;
+    double sum;
+    double* p = new double[n + 1];
+    memset(p, 0, sizeof(double) * (n + 1));
+
+    for (i = 1; i <= n; i++)
+    {
+        for (j = i; j <= n; j++)
+        {
+            for (sum = a[i][j], k = i - 1; k >= 1; k--)
+                sum -= a[i][k] * a[j][k];
+            if (i == j)
+            {
+                if (sum <= 0.0)
+                {
+                }
+                else
+                    p[i] = sqrt(sum);
+            }
+            else
+            {
+                a[j][i] = sum / p[i];
+            }
+        }
+    }
+
+    for (i = 1; i <= n; i++)
+    {
+        for (j = i; j <= n; j++)
+        {
+            if (i == j)
+                l[i][i] = p[i];
+            else
+            {
+                l[j][i] = a[j][i];
+                l[i][j] = 0.0;
+            }
+        }
+    }
+
+    delete[] p;
+}
+
+int EdgeDrawingImpl::inverse(double** TB, double** InvB, int N)
+{
+    int k, i, j, p, q;
+    double mult;
+    double D, temp;
+    double maxpivot;
+    int npivot;
+    double** B = AllocateMatrix(N + 1, N + 2);
+    double** A = AllocateMatrix(N + 1, 2 * N + 2);
+    double** C = AllocateMatrix(N + 1, N + 1);
+    double eps = 10e-20;
+
+    for (k = 1; k <= N; k++)
+        for (j = 1; j <= N; j++)
+            B[k][j] = TB[k][j];
+
+    for (k = 1; k <= N; k++)
+    {
+        for (j = 1; j <= N + 1; j++)
+            A[k][j] = B[k][j];
+        for (j = N + 2; j <= 2 * N + 1; j++)
+            A[k][j] = (double)0;
+        A[k][k - 1 + N + 2] = (double)1;
+    }
+    for (k = 1; k <= N; k++)
+    {
+        maxpivot = fabs((double)A[k][k]);
+        npivot = k;
+        for (i = k; i <= N; i++)
+            if (maxpivot < fabs((double)A[i][k]))
+            {
+                maxpivot = fabs((double)A[i][k]);
+                npivot = i;
+            }
+        if (maxpivot >= eps)
+        {
+            if (npivot != k)
+                for (j = k; j <= 2 * N + 1; j++)
+                {
+                    temp = A[npivot][j];
+                    A[npivot][j] = A[k][j];
+                    A[k][j] = temp;
+                };
+            D = A[k][k];
+            for (j = 2 * N + 1; j >= k; j--)
+                A[k][j] = A[k][j] / D;
+            for (i = 1; i <= N; i++)
+            {
+                if (i != k)
+                {
+                    mult = A[i][k];
+                    for (j = 2 * N + 1; j >= k; j--)
+                        A[i][j] = A[i][j] - mult * A[k][j];
+                }
+            }
+        }
+        else
+        {
+            DeallocateMatrix(B, N + 1);
+            DeallocateMatrix(A, N + 1);
+            DeallocateMatrix(C, N + 1);
+
+            return (-1);
+        }
+    }
+
+    for (k = 1, p = 1; k <= N; k++, p++)
+        for (j = N + 2, q = 1; j <= 2 * N + 1; j++, q++)
+            InvB[p][q] = A[k][j];
+
+    DeallocateMatrix(B, N + 1);
+    DeallocateMatrix(A, N + 1);
+    DeallocateMatrix(C, N + 1);
+
+    return (0);
+}
+
+void EdgeDrawingImpl::DeallocateMatrix(double** m, int noRows)
+{
+    for (int i = 0; i < noRows; i++)
+        delete[] m[i];
+    delete[] m;
+}
+
+void EdgeDrawingImpl::AperB_T(double** A_, double** B_, double** _res, int _righA, int _colA, int _righB, int _colB)
+{
+    CV_UNUSED(_righB);
+    int p, q, l;
+    for (p = 1; p <= _colA; p++)
+        for (q = 1; q <= _colB; q++)
+        {
+            _res[p][q] = 0.0;
+            for (l = 1; l <= _righA; l++)
+                _res[p][q] = _res[p][q] + A_[p][l] * B_[q][l];
+        }
+}
+
+void EdgeDrawingImpl::AperB(double** A_, double** B_, double** _res, int _righA, int _colA, int _righB, int _colB)
+{
+    CV_UNUSED(_righB);
+    int p, q, l;
+    for (p = 1; p <= _righA; p++)
+        for (q = 1; q <= _colB; q++)
+        {
+            _res[p][q] = 0.0;
+            for (l = 1; l <= _colA; l++)
+                _res[p][q] = _res[p][q] + A_[p][l] * B_[l][q];
+        }
+}
+
+void EdgeDrawingImpl::jacobi(double** a, int n, double d[], double** v)
+{
+    int j, iq, ip, i;
+    double tresh, theta, tau, t, sm, s, h, g, c;
+
+    double* b = new double[n + 1];
+    double* z = new double[n + 1];
+    memset(b, 0, sizeof(double) * (n + 1));
+    memset(z, 0, sizeof(double) * (n + 1));
+
+    for (ip = 1; ip <= n; ip++)
+    {
+        for (iq = 1; iq <= n; iq++)
+            v[ip][iq] = 0.0;
+        v[ip][ip] = 1.0;
+    }
+    for (ip = 1; ip <= n; ip++)
+    {
+        b[ip] = d[ip] = a[ip][ip];
+        z[ip] = 0.0;
+    }
+    for (i = 1; i <= 50; i++)
+    {
+        sm = 0.0;
+        for (ip = 1; ip <= n - 1; ip++)
+        {
+            for (iq = ip + 1; iq <= n; iq++)
+                sm += fabs(a[ip][iq]);
+        }
+        if (sm == 0.0)
+        {
+            delete[] b;
+            delete[] z;
+            return;
+        }
+        if (i < 4)
+            tresh = 0.2 * sm / (n * n);
+        else
+            tresh = 0.0;
+        for (ip = 1; ip <= n - 1; ip++)
+        {
+            for (iq = ip + 1; iq <= n; iq++)
+            {
+                g = 100.0 * fabs(a[ip][iq]);
+
+                if (i > 4 && g == 0.0)
+                    a[ip][iq] = 0.0;
+                else if (fabs(a[ip][iq]) > tresh)
+                {
+                    h = d[iq] - d[ip];
+                    if (g == 0.0)
+                        t = (a[ip][iq]) / h;
+                    else
+                    {
+                        theta = 0.5 * h / (a[ip][iq]);
+                        t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
+                        if (theta < 0.0)
+                            t = -t;
+                    }
+                    c = 1.0 / sqrt(1 + t * t);
+                    s = t * c;
+                    tau = s / (1.0 + c);
+                    h = t * a[ip][iq];
+                    z[ip] -= h;
+                    z[iq] += h;
+                    d[ip] -= h;
+                    d[iq] += h;
+                    a[ip][iq] = 0.0;
+                    for (j = 1; j <= ip - 1; j++)
+                    {
+                        ROTATE(a, j, ip, j, iq, tau, s);
+                    }
+                    for (j = ip + 1; j <= iq - 1; j++)
+                    {
+                        ROTATE(a, ip, j, j, iq, tau, s);
+                    }
+                    for (j = iq + 1; j <= n; j++)
+                    {
+                        ROTATE(a, ip, j, iq, j, tau, s);
+                    }
+                    for (j = 1; j <= n; j++)
+                    {
+                        ROTATE(v, j, ip, j, iq, tau, s);
+                    }
+                }
+            }
+        }
+
+        for (ip = 1; ip <= n; ip++)
+        {
+            b[ip] += z[ip];
+            d[ip] = b[ip];
+            z[ip] = 0.0;
+        }
+    }
+    delete[] b;
+    delete[] z;
+}
+
+void EdgeDrawingImpl::ROTATE(double** a, int i, int j, int k, int l, double tau, double s)
+{
+    double g, h;
+    g = a[i][j];
+    h = a[k][l];
+    a[i][j] = g - s * (h + g * tau);
+    a[k][l] = h + s * (g - h * tau);
+}
+
+} // namespace cv
+} // namespace ximgproc
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edge_drawing_common.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edge_drawing_common.hpp
new file mode 100644
index 00000000..135b4566
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edge_drawing_common.hpp
@@ -0,0 +1,570 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_EDGE_DRAWING_COMMON_HPP__
+#define __OPENCV_EDGE_DRAWING_COMMON_HPP__
+
+#include <opencv2/core.hpp>
+
+#define EDGE_VERTICAL   1
+#define EDGE_HORIZONTAL 2
+
+#define ANCHOR_PIXEL  254
+#define EDGE_PIXEL    255
+
+#define LEFT  1
+#define RIGHT 2
+#define UP    3
+#define DOWN  4
+
+#define SOUTH_SOUTH 0
+#define SOUTH_EAST 1
+#define EAST_SOUTH 2
+#define EAST_EAST 3
+
+// Circular arc, circle thresholds
+#define VERY_SHORT_ARC_ERROR     0.40  // Used for very short arcs (>= CANDIDATE_CIRCLE_RATIO1 && < CANDIDATE_CIRCLE_RATIO2)
+#define SHORT_ARC_ERROR          1.00  // Used for short arcs (>= CANDIDATE_CIRCLE_RATIO2 && < HALF_CIRCLE_RATIO)
+#define HALF_ARC_ERROR           1.25  // Used for arcs with length (>=HALF_CIRCLE_RATIO && < FULL_CIRCLE_RATIO)
+#define LONG_ARC_ERROR           1.50  // Used for long arcs (>= FULL_CIRCLE_RATIO)
+
+#define CANDIDATE_CIRCLE_RATIO1  0.25  // 25% -- If only 25% of the circle is detected, it may be a candidate for validation
+#define CANDIDATE_CIRCLE_RATIO2  0.33  // 33% -- If only 33% of the circle is detected, it may be a candidate for validation
+#define HALF_CIRCLE_RATIO        0.50  // 50% -- If 50% of a circle is detected at any point during joins, we immediately make it a candidate
+#define FULL_CIRCLE_RATIO        0.67  // 67% -- If 67% of the circle is detected, we assume that it is fully covered
+
+// Ellipse thresholds
+#define CANDIDATE_ELLIPSE_RATIO  0.50  // 50% -- If 50% of the ellipse is detected, it may be candidate for validation
+#define ELLIPSE_ERROR            1.50  // Used for ellipses. (used to be 1.65 for what reason?)
+#define MAX_GRAD_VALUE 128*256
+
+using namespace std;
+using namespace cv;
+
+class NFALUT
+{
+public:
+
+    NFALUT(int size, double _prob, int _w, int _h);
+    ~NFALUT();
+
+    int* LUT; // look up table
+    int LUTSize;
+
+    double prob;
+    int w, h;
+
+    bool checkValidationByNFA(int n, int k);
+    static double myAtan2(double yy, double xx);
+
+private:
+    double nfa(int n, int k);
+    static double Comb(double n, double k);
+};
+
+NFALUT::NFALUT(int size, double _prob, int _w, int _h)
+{
+    LUTSize = size > 60 ? 60 : size;
+    LUT = new int[LUTSize];
+    w = _w;
+    h = _h;
+    prob = _prob;
+
+    LUT[0] = 1;
+    int j = 1;
+    for (int i = 1; i < LUTSize; i++)
+    {
+        LUT[i] = LUTSize + 1;
+        double ret = nfa(i, j);
+        if (ret >= 1.0)
+        {
+            while (j < i)
+            {
+                j++;
+                ret = nfa(i, j);
+                if (ret <= 1.0)
+                    break;
+            }
+
+            if (ret >= 1.0)
+                continue;
+        }
+        LUT[i] = j;
+    }
+}
+
+
+NFALUT::~NFALUT()
+{
+    delete[] LUT;
+}
+
+bool NFALUT::checkValidationByNFA(int n, int k)
+{
+    if (n >= LUTSize)
+        return nfa(n, k) <= 1.0;
+    else
+        return k >= LUT[n];
+}
+
+double NFALUT::myAtan2(double yy, double xx)
+{
+    double angle = fastAtan2((float)yy, (float)xx);
+
+    if (angle > 180)
+        angle = angle - 180;
+
+    return angle / 180 * CV_PI;
+}
+
+double NFALUT::Comb(double n, double k)   //fast combination computation
+{
+    if (k > n)
+        return 0;
+
+    double r = 1;
+    for (double d = 1; d <= k; ++d)
+    {
+        r *= n--;
+        r /= d;
+    }
+    return r;
+}
+
+double NFALUT::nfa(int n, int k)
+{
+    double sum = 0;
+    double p = 0.125;
+    for (int i = k; i <= n; i++)
+        sum += Comb(n, i) * pow(p, i) * pow(1 - p, n - i);
+
+    return sum * w * w * h * h;
+}
+
+struct StackNode
+{
+    int r, c;         // starting pixel
+    int parent;       // parent chain (-1 if no parent)
+    int dir;          // direction where you are supposed to go
+};
+
+// Used during Edge Linking
+struct Chain
+{
+    int dir;          // Direction of the chain
+    int len;          // # of pixels in the chain
+    int parent;       // Parent of this node (-1 if no parent)
+    int children[2];  // Children of this node (-1 if no children)
+    Point *pixels;    // Pointer to the beginning of the pixels array
+};
+
+// light weight struct for Start & End coordinates of the line segment
+struct LS
+{
+    Point2d start;
+    Point2d end;
+
+    LS(Point2d _start, Point2d _end)
+    {
+        start = _start;
+        end = _end;
+    }
+};
+
+
+struct EDLineSegment
+{
+    double a, b;          // y = a + bx (if invert = 0) || x = a + by (if invert = 1)
+    int invert;
+
+    double sx, sy;        // starting x & y coordinates
+    double ex, ey;        // ending x & y coordinates
+
+    int segmentNo;        // Edge segment that this line belongs to
+    int firstPixelIndex;  // Index of the first pixel within the segment of pixels
+    int len;              // No of pixels making up the line segment
+
+    EDLineSegment(double _a, double _b, int _invert, double _sx, double _sy, double _ex, double _ey, int _segmentNo, int _firstPixelIndex, int _len)
+    {
+        a = _a;
+        b = _b;
+        invert = _invert;
+        sx = _sx;
+        sy = _sy;
+        ex = _ex;
+        ey = _ey;
+        segmentNo = _segmentNo;
+        firstPixelIndex = _firstPixelIndex;
+        len = _len;
+    }
+};
+
+// Circle equation: (x-xc)^2 + (y-yc)^2 = r^2
+struct mCircle {
+	Point2d center;
+	double r;
+	mCircle(Point2d _center, double _r) { center = _center; r = _r; }
+};
+
+// Ellipse equation: Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0
+struct mEllipse {
+	Point2d center;
+	Size axes;
+	double theta;
+	mEllipse(Point2d _center, Size _axes, double _theta) { center = _center; axes = _axes; theta = _theta; }
+};
+
+//----------------------------------------------------------
+// Ellipse Equation is of the form:
+// Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0
+//
+struct EllipseEquation {
+	double coeff[7];  // coeff[1] = A
+
+	EllipseEquation() {
+		for (int i = 0; i<7; i++) coeff[i] = 0;
+	}
+
+	double A() { return coeff[1]; }
+	double B() { return coeff[2]; }
+	double C() { return coeff[3]; }
+	double D() { return coeff[4]; }
+	double E() { return coeff[5]; }
+	double F() { return coeff[6]; }
+};
+
+// ================================ CIRCLES ================================
+struct Circle {
+	double xc, yc, r;        // Center (xc, yc) & radius.
+	double circleFitError;   // circle fit error
+	double coverRatio;       // Percentage of the circle covered by the arcs making up this circle [0-1]
+
+	double *x, *y;           // Pointers to buffers containing the pixels making up this circle
+	int noPixels;            // # of pixels making up this circle
+
+							 // If this circle is better approximated by an ellipse, we set isEllipse to true & eq contains the ellipse's equation
+	EllipseEquation eq;
+	double ellipseFitError;  // ellipse fit error
+	bool isEllipse;
+	double majorAxisLength;     // Length of the major axis
+	double minorAxisLength;     // Length of the minor axis
+};
+
+// ------------------------------------------- ARCS ----------------------------------------------------
+struct MyArc {
+	double xc, yc, r;           // center x, y and radius
+	double circleFitError;      // Error during circle fit
+
+	double sTheta, eTheta;      // Start & end angle in radius
+	double coverRatio;          // Ratio of the pixels covered on the covering circle [0-1] (noPixels/circumference)
+
+	int turn;                   // Turn direction: 1 or -1
+
+	int segmentNo;              // SegmentNo where this arc belongs
+
+	int sx, sy;                 // Start (x, y) coordinate
+	int ex, ey;                 // End (x, y) coordinate of the arc
+
+	double *x, *y;              // Pointer to buffer containing the pixels making up this arc
+	int noPixels;               // # of pixels making up the arc
+
+	bool isEllipse;             // Did we fit an ellipse to this arc?
+	EllipseEquation eq;         // If an ellipse, then the ellipse's equation
+	double ellipseFitError;     // Error during ellipse fit
+};
+
+// =============================== AngleSet ==================================
+
+// add a circular arc to the list of arcs
+inline double ArcLength(double sTheta, double eTheta)
+{
+	if (eTheta > sTheta)
+        return eTheta - sTheta;
+	else
+        return CV_2PI - sTheta + eTheta;
+}
+
+// A fast implementation of the AngleSet class. The slow implementation is really bad. About 10 times slower than this!
+struct AngleSetArc {
+	double sTheta;
+	double eTheta;
+	int next;         // Next AngleSetArc in the linked list
+};
+
+struct AngleSet {
+	AngleSetArc angles[360];
+	int head;
+	int next;   // Next AngleSetArc to be allocated
+	double overlapAmount;   // Total overlap of the arcs in angleSet. Computed during set() function
+
+	AngleSet() { clear(); }
+	void clear() { head = -1; next = 0; overlapAmount = 0; }
+	double overlapRatio() { return overlapAmount / CV_2PI; }
+
+	void _set(double sTheta, double eTheta);
+	void set(double sTheta, double eTheta);
+
+	double _overlap(double sTheta, double eTheta);
+	double overlap(double sTheta, double eTheta);
+
+	void computeStartEndTheta(double& sTheta, double& eTheta);
+	double coverRatio();
+};
+
+void AngleSet::_set(double sTheta, double eTheta)
+{
+    int arc = next++;
+
+    angles[arc].sTheta = sTheta;
+    angles[arc].eTheta = eTheta;
+    angles[arc].next = -1;
+
+    // Add the current arc to the linked list
+    int prev = -1;
+    int current = head;
+    while (1)
+    {
+        // Empty list?
+        if (head < 0)
+        {
+            head = arc;
+            break;
+        }
+
+        // End of the list. Add to the end
+        if (current < 0)
+        {
+            CV_Assert(prev >= 0);
+            angles[prev].next = arc;
+            break;
+        }
+
+        if (angles[arc].eTheta <= angles[current].sTheta)
+        {
+            // Add before current
+            if (prev < 0)
+            {
+                angles[arc].next = current;
+                head = arc;
+            }
+            else
+            {
+                angles[arc].next = current;
+                angles[prev].next = arc;
+            }
+            break;
+        }
+        else if (angles[arc].sTheta >= angles[current].eTheta)
+        {
+            // continue
+            prev = current;
+            current = angles[current].next;
+
+            // End of the list?
+            if (current < 0)
+            {
+                angles[prev].next = arc;
+                break;
+            }
+        }
+        else
+        {
+            // overlaps with current. Join
+            // First delete current from the list
+            if (prev < 0)
+                head = angles[head].next;
+            else
+                angles[prev].next = angles[current].next;
+
+            // Update overlap amount.
+            if (angles[arc].eTheta < angles[current].eTheta)
+            {
+                overlapAmount += angles[arc].eTheta - angles[current].sTheta;
+            }
+            else
+            {
+                overlapAmount += angles[current].eTheta - angles[arc].sTheta;
+            }
+
+            // Now join current with arc
+            if (angles[current].sTheta < angles[arc].sTheta)
+                angles[arc].sTheta = angles[current].sTheta;
+            if (angles[current].eTheta > angles[arc].eTheta)
+                angles[arc].eTheta = angles[current].eTheta;
+            current = angles[current].next;
+        }
+    }
+}
+
+void AngleSet::set(double sTheta, double eTheta)
+{
+    if (eTheta > sTheta)
+    {
+        _set(sTheta, eTheta);
+    }
+    else
+    {
+        _set(sTheta, CV_2PI);
+        _set(0, eTheta);
+    }
+}
+
+double AngleSet::_overlap(double sTheta, double eTheta)
+{
+    double o = 0;
+
+    int current = head;
+    while (current >= 0)
+    {
+        if (sTheta > angles[current].eTheta)
+        {
+            current = angles[current].next;
+            continue;
+        }
+        else if (eTheta < angles[current].sTheta)
+            break;
+
+        // 3 cases.
+        if (sTheta < angles[current].sTheta && eTheta > angles[current].eTheta)
+        {
+            o += angles[current].eTheta - angles[current].sTheta;
+
+        }
+        else if (sTheta < angles[current].sTheta)
+        {
+            o += eTheta - angles[current].sTheta;
+        }
+        else
+        {
+            o += angles[current].eTheta - sTheta;
+        }
+
+        current = angles[current].next;
+    }
+    return o;
+}
+
+double AngleSet::overlap(double sTheta, double eTheta)
+{
+    double o;
+
+    if (eTheta > sTheta)
+    {
+        o = _overlap(sTheta, eTheta);
+    }
+    else
+    {
+        o = _overlap(sTheta, CV_2PI);
+        o += _overlap(0, eTheta);
+    }
+    return o / ArcLength(sTheta, eTheta);
+}
+
+void AngleSet::computeStartEndTheta(double& sTheta, double& eTheta)
+{
+    // Special case: Just one arc
+    if (angles[head].next < 0)
+    {
+        sTheta = angles[head].sTheta;
+        eTheta = angles[head].eTheta;
+
+        return;
+    }
+
+    // OK. More than one arc. Find the biggest gap
+    int current = head;
+    int nextArc = angles[current].next;
+
+    double biggestGapSTheta = angles[current].eTheta;
+    double biggestGapEtheta = angles[nextArc].sTheta;
+    double biggestGapLength = biggestGapEtheta - biggestGapSTheta;
+
+    double start, end, len;
+    while (1)
+    {
+        current = nextArc;
+        nextArc = angles[nextArc].next;
+        if (nextArc < 0)
+            break;
+
+        start = angles[current].eTheta;
+        end = angles[nextArc].sTheta;
+        len = end - start;
+
+        if (len > biggestGapLength)
+        {
+            biggestGapSTheta = start;
+            biggestGapEtheta = end;
+            biggestGapLength = len;
+        }
+    }
+
+    // Compute the gap between the last arc & the first arc
+    start = angles[current].eTheta;
+    end = angles[head].sTheta;
+    len = CV_2PI - start + end;
+    if (len > biggestGapLength)
+    {
+        biggestGapSTheta = start;
+        biggestGapEtheta = end;
+    }
+    sTheta = biggestGapEtheta;
+    eTheta = biggestGapSTheta;
+}
+
+double AngleSet::coverRatio()
+{
+    int current = head;
+
+    double total = 0;
+    while (current >= 0)
+    {
+        total += angles[current].eTheta - angles[current].sTheta;
+        current = angles[current].next;
+    }
+    return total / CV_2PI;
+}
+
+struct EDArcs {
+	MyArc *arcs;
+	int noArcs;
+
+public:
+	EDArcs(int size = 10000) {
+		arcs = new MyArc[size];
+		noArcs = 0;
+	}
+
+	~EDArcs() {
+		delete[] arcs;
+	}
+};
+
+struct BufferManager {
+	double *x, *y;
+	int index;
+
+	BufferManager(int maxSize) {
+		x = new double[maxSize];
+		y = new double[maxSize];
+		index = 0;
+	}
+
+	~BufferManager() {
+		delete[] x;
+		delete[] y;
+	}
+
+	double *getX() { return &x[index]; }
+	double *getY() { return &y[index]; }
+	void move(int size) { index += size; }
+};
+
+struct Info {
+	int sign;     // -1 or 1: sign of the cross product
+	double angle; // angle with the next line (in radians)
+	bool taken;   // Is this line taken during arc detection
+};
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgeaware_filters_common.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgeaware_filters_common.cpp
new file mode 100644
index 00000000..8841bf11
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgeaware_filters_common.cpp
@@ -0,0 +1,556 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include "edgeaware_filters_common.hpp"
+#include "dtfilter_cpu.hpp"
+
+#include <opencv2/core/cvdef.h>
+#include <opencv2/core/utility.hpp>
+#include <cmath>
+using namespace std;
+
+#ifndef SQR
+#define SQR(x) ((x)*(x))
+#endif
+
+#if CV_SSE
+namespace
+{
+
+inline bool CPU_SUPPORT_SSE1()
+{
+    static const bool is_supported = cv::checkHardwareSupport(CV_CPU_SSE);
+    return is_supported;
+}
+
+}  // end
+#endif
+
+namespace cv
+{
+namespace ximgproc
+{
+
+Ptr<DTFilter> createDTFilterRF(InputArray adistHor, InputArray adistVert, double sigmaSpatial, double sigmaColor, int numIters)
+{
+    return Ptr<DTFilter>(DTFilterCPU::createRF(adistHor, adistVert, sigmaSpatial, sigmaColor, numIters));
+}
+
+int getTotalNumberOfChannels(InputArrayOfArrays src)
+{
+    CV_Assert(src.isMat() || src.isUMat() || src.isMatVector() || src.isUMatVector());
+
+    if (src.isMat() || src.isUMat())
+    {
+        return src.channels();
+    }
+    else if (src.isMatVector())
+    {
+        int cnNum = 0;
+        const vector<Mat>& srcv = *static_cast<const vector<Mat>*>(src.getObj());
+        for (unsigned i = 0; i < srcv.size(); i++)
+            cnNum += srcv[i].channels();
+        return cnNum;
+    }
+    else if (src.isUMatVector())
+    {
+        int cnNum = 0;
+        const vector<UMat>& srcv = *static_cast<const vector<UMat>*>(src.getObj());
+        for (unsigned i = 0; i < srcv.size(); i++)
+            cnNum += srcv[i].channels();
+        return cnNum;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+void checkSameSizeAndDepth(InputArrayOfArrays src, Size &sz, int &depth)
+{
+    CV_Assert(src.isMat() || src.isUMat() || src.isMatVector() || src.isUMatVector());
+
+    if (src.isMat() || src.isUMat())
+    {
+        CV_Assert(!src.empty());
+        sz = src.size();
+        depth = src.depth();
+    }
+    else if (src.isMatVector())
+    {
+        const vector<Mat>& srcv = *static_cast<const vector<Mat>*>(src.getObj());
+        CV_Assert(srcv.size() > 0);
+        for (unsigned i = 0; i < srcv.size(); i++)
+        {
+            CV_Assert(srcv[i].depth() == srcv[0].depth());
+            CV_Assert(srcv[i].size() == srcv[0].size());
+        }
+        sz = srcv[0].size();
+        depth = srcv[0].depth();
+    }
+    else if (src.isUMatVector())
+    {
+        const vector<UMat>& srcv = *static_cast<const vector<UMat>*>(src.getObj());
+        CV_Assert(srcv.size() > 0);
+        for (unsigned i = 0; i < srcv.size(); i++)
+        {
+            CV_Assert(srcv[i].depth() == srcv[0].depth());
+            CV_Assert(srcv[i].size() == srcv[0].size());
+        }
+        sz = srcv[0].size();
+        depth = srcv[0].depth();
+    }
+}
+
+namespace intrinsics
+{
+
+inline float getFloatSignBit()
+{
+    union
+    {
+        int signInt;
+        float signFloat;
+    };
+    signInt = 0x80000000;
+
+    return signFloat;
+}
+
+void add_(float *dst, float *src1, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, b;
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_loadu_ps(src1 + j);
+            b = _mm_loadu_ps(dst + j);
+            b = _mm_add_ps(b, a);
+            _mm_storeu_ps(dst + j, b);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] += src1[j];
+}
+
+void mul(float *dst, float *src1, float *src2, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, b;
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_loadu_ps(src1 + j);
+            b = _mm_loadu_ps(src2 + j);
+            b = _mm_mul_ps(a, b);
+            _mm_storeu_ps(dst + j, b);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] = src1[j] * src2[j];
+}
+
+void mul(float *dst, float *src1, float src2, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, b;
+        b = _mm_set_ps1(src2);
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_loadu_ps(src1 + j);
+            a = _mm_mul_ps(a, b);
+            _mm_storeu_ps(dst + j, a);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] = src1[j]*src2;
+}
+
+void mad(float *dst, float *src1, float alpha, float beta, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, b, c;
+        a = _mm_set_ps1(alpha);
+        b = _mm_set_ps1(beta);
+        for (; j < w - 3; j += 4)
+        {
+            c = _mm_loadu_ps(src1 + j);
+            c = _mm_mul_ps(c, a);
+            c = _mm_add_ps(c, b);
+            _mm_storeu_ps(dst + j, c);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] = alpha*src1[j] + beta;
+}
+
+void sqr_(float *dst, float *src1, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a;
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_loadu_ps(src1 + j);
+            a = _mm_mul_ps(a, a);
+            _mm_storeu_ps(dst + j, a);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] = src1[j] * src1[j];
+}
+
+void sqr_dif(float *dst, float *src1, float *src2, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 d;
+        for (; j < w - 3; j += 4)
+        {
+            d = _mm_sub_ps(_mm_loadu_ps(src1 + j), _mm_loadu_ps(src2 + j));
+            d = _mm_mul_ps(d, d);
+            _mm_storeu_ps(dst + j, d);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] = (src1[j] - src2[j])*(src1[j] - src2[j]);
+}
+
+void add_mul(float *dst, float *src1, float *src2, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, b, c;
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_loadu_ps(src1 + j);
+            b = _mm_loadu_ps(src2 + j);
+            b = _mm_mul_ps(b, a);
+            c = _mm_loadu_ps(dst + j);
+            c = _mm_add_ps(c, b);
+            _mm_storeu_ps(dst + j, c);
+        }
+    }
+#endif
+    for (; j < w; j++)
+    {
+        dst[j] += src1[j] * src2[j];
+    }
+}
+
+void add_sqr(float *dst, float *src1, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, c;
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_loadu_ps(src1 + j);
+            a = _mm_mul_ps(a, a);
+            c = _mm_loadu_ps(dst + j);
+            c = _mm_add_ps(c, a);
+            _mm_storeu_ps(dst + j, c);
+        }
+    }
+#endif
+    for (; j < w; j++)
+    {
+        dst[j] += src1[j] * src1[j];
+    }
+}
+
+void add_sqr_dif(float *dst, float *src1, float *src2, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, d;
+        for (; j < w - 3; j += 4)
+        {
+            d = _mm_sub_ps(_mm_loadu_ps(src1 + j), _mm_loadu_ps(src2 + j));
+            d = _mm_mul_ps(d, d);
+            a = _mm_loadu_ps(dst + j);
+            a = _mm_add_ps(a, d);
+            _mm_storeu_ps(dst + j, a);
+        }
+    }
+#endif
+    for (; j < w; j++)
+    {
+        dst[j] += (src1[j] - src2[j])*(src1[j] - src2[j]);
+    }
+}
+
+void sub_mul(float *dst, float *src1, float *src2, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, b, c;
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_loadu_ps(src1 + j);
+            b = _mm_loadu_ps(src2 + j);
+            b = _mm_mul_ps(b, a);
+            c = _mm_loadu_ps(dst + j);
+            c = _mm_sub_ps(c, b);
+            _mm_storeu_ps(dst + j, c);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] -= src1[j] * src2[j];
+}
+
+void sub_mad(float *dst, float *src1, float *src2, float c0, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, b, c;
+        __m128 cnst = _mm_set_ps1(c0);
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_loadu_ps(src1 + j);
+            b = _mm_loadu_ps(src2 + j);
+            b = _mm_mul_ps(b, a);
+            c = _mm_loadu_ps(dst + j);
+            c = _mm_sub_ps(c, cnst);
+            c = _mm_sub_ps(c, b);
+            _mm_storeu_ps(dst + j, c);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] -= src1[j] * src2[j] + c0;
+}
+
+void det_2x2(float *dst, float *a00, float *a01, float *a10, float *a11, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, b;
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_mul_ps(_mm_loadu_ps(a00 + j), _mm_loadu_ps(a11 + j));
+            b = _mm_mul_ps(_mm_loadu_ps(a01 + j), _mm_loadu_ps(a10 + j));
+            a = _mm_sub_ps(a, b);
+            _mm_storeu_ps(dst + j, a);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] = a00[j]*a11[j] - a01[j]*a10[j];
+}
+
+void div_det_2x2(float *a00, float *a01, float *a11, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        const __m128 SIGN_MASK = _mm_set_ps1(getFloatSignBit());
+
+        __m128 a, b, _a00, _a01, _a11;
+        for (; j < w - 3; j += 4)
+        {
+            _a00 = _mm_loadu_ps(a00 + j);
+            _a11 = _mm_loadu_ps(a11 + j);
+            a = _mm_mul_ps(_a00, _a11);
+
+            _a01 = _mm_loadu_ps(a01 + j);
+            _a01 = _mm_xor_ps(_a01, SIGN_MASK);
+            b = _mm_mul_ps(_a01, _a01);
+
+            a = _mm_sub_ps(a, b);
+
+            _a01 = _mm_div_ps(_a01, a);
+            _a00 = _mm_div_ps(_a00, a);
+            _a11 = _mm_div_ps(_a11, a);
+
+            _mm_storeu_ps(a01 + j, _a01);
+            _mm_storeu_ps(a00 + j, _a00);
+            _mm_storeu_ps(a11 + j, _a11);
+        }
+    }
+#endif
+    for (; j < w; j++)
+    {
+        float det = a00[j] * a11[j] - a01[j] * a01[j];
+        a00[j] /= det;
+        a11[j] /= det;
+        a01[j] /= -det;
+    }
+}
+
+void div_1x(float *a1, float *b1, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 _a1, _b1;
+        for (; j < w - 3; j += 4)
+        {
+            _b1 = _mm_loadu_ps(b1 + j);
+            _a1 = _mm_loadu_ps(a1 + j);
+            _mm_storeu_ps(a1 + j, _mm_div_ps(_a1, _b1));
+        }
+    }
+#endif
+    for (; j < w; j++)
+    {
+        a1[j] /= b1[j];
+    }
+}
+
+void inv_self(float *src, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a;
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_rcp_ps(_mm_loadu_ps(src + j));
+            _mm_storeu_ps(src + j, a);
+        }
+    }
+#endif
+    for (; j < w; j++)
+    {
+        src[j] = 1.0f / src[j];
+    }
+}
+
+void sqrt_(float *dst, float *src, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a;
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_sqrt_ps(_mm_loadu_ps(src + j));
+            _mm_storeu_ps(dst + j, a);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] = sqrt(src[j]);
+}
+
+void min_(float *dst, float *src1, float *src2, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 a, b;
+        for (; j < w - 3; j += 4)
+        {
+            a = _mm_loadu_ps(src1 + j);
+            b = _mm_loadu_ps(src2 + j);
+            b = _mm_min_ps(b, a);
+
+            _mm_storeu_ps(dst + j, b);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        dst[j] = std::min(src1[j], src2[j]);
+}
+
+void rf_vert_row_pass(float *curRow, float *prevRow, float alphaVal, int w)
+{
+    int j = 0;
+#if CV_SSE
+    if (CPU_SUPPORT_SSE1())
+    {
+        __m128 cur, prev, res;
+        __m128 alpha = _mm_set_ps1(alphaVal);
+        for (; j < w - 3; j += 4)
+        {
+            cur = _mm_loadu_ps(curRow + j);
+            prev = _mm_loadu_ps(prevRow + j);
+
+            res = _mm_mul_ps(alpha, _mm_sub_ps(prev, cur));
+            res = _mm_add_ps(res, cur);
+            _mm_storeu_ps(curRow + j, res);
+        }
+    }
+#endif
+    for (; j < w; j++)
+        curRow[j] += alphaVal*(prevRow[j] - curRow[j]);
+}
+
+} //end of cv::ximgproc::intrinsics
+
+} //end of cv::ximgproc
+} //end of cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgeaware_filters_common.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgeaware_filters_common.hpp
new file mode 100644
index 00000000..04b935b3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgeaware_filters_common.hpp
@@ -0,0 +1,97 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#ifndef __EDGEAWAREFILTERS_COMMON_HPP__
+#define __EDGEAWAREFILTERS_COMMON_HPP__
+#ifdef __cplusplus
+
+namespace cv
+{
+namespace ximgproc
+{
+
+Ptr<DTFilter> createDTFilterRF(InputArray adistHor, InputArray adistVert, double sigmaSpatial, double sigmaColor, int numIters);
+
+int getTotalNumberOfChannels(InputArrayOfArrays src);
+
+void checkSameSizeAndDepth(InputArrayOfArrays src, Size &sz, int &depth);
+
+namespace intrinsics
+{
+    void add_(float *dst, float *src1, int w);
+
+    void mul(float *dst, float *src1, float *src2, int w);
+
+    void mul(float *dst, float *src1, float src2, int w);
+
+    //dst = alpha*src + beta
+    void mad(float *dst, float *src1, float alpha, float beta, int w);
+
+    void add_mul(float *dst, float *src1, float *src2, int w);
+
+    void sub_mul(float *dst, float *src1, float *src2, int w);
+
+    void sub_mad(float *dst, float *src1, float *src2, float c0, int w);
+
+    void det_2x2(float *dst, float *a00, float *a01, float *a10, float *a11, int w);
+
+    void div_det_2x2(float *a00, float *a01, float *a11, int w);
+
+    void div_1x(float *a1, float *b1, int w);
+
+    void inv_self(float *src, int w);
+
+
+    void sqr_(float *dst, float *src1, int w);
+
+    void sqrt_(float *dst, float *src, int w);
+
+    void sqr_dif(float *dst, float *src1, float *src2, int w);
+
+    void add_sqr_dif(float *dst, float *src1, float *src2, int w);
+
+    void add_sqr(float *dst, float *src1, int w);
+
+    void min_(float *dst, float *src1, float *src2, int w);
+
+    void rf_vert_row_pass(float *curRow, float *prevRow, float alphaVal, int w);
+}
+
+}
+}
+
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgeboxes.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgeboxes.cpp
new file mode 100644
index 00000000..fe454a8a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgeboxes.cpp
@@ -0,0 +1,985 @@
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/*
+Generate Edge Boxes object proposals in given image(s).
+Compute Edge Boxes object proposals as described in:
+  C. Lawrence Zitnick and Piotr Dollár
+  "Edge Boxes: Locating Object Proposals from Edges", ECCV 2014.
+The proposal boxes are fast to compute and give state-of-the-art recall.
+OpenCV port by: Leonardo Lontra <lhe dot lontra at gmail dot com>
+*/
+
+#include "precomp.hpp"
+using namespace cv;
+using namespace std;
+
+inline int clamp(int v, int min, int max)
+{
+  return v < min ? min : v > max ? max : v;
+}
+
+namespace cv
+{
+namespace ximgproc
+{
+
+class EdgeBoxesImpl : public EdgeBoxes
+{
+public:
+
+  EdgeBoxesImpl(float alpha,
+                  float beta,
+                  float eta,
+                  float minScore,
+                  int maxBoxes,
+                  float edgeMinMag,
+                  float edgeMergeThr,
+                  float clusterMinMag,
+                  float maxAspectRatio,
+                  float minBoxArea,
+                  float gamma,
+                  float kappa);
+
+    virtual void getBoundingBoxes(InputArray edge_map, InputArray orientation_map, std::vector<Rect> &boxes, OutputArray scores = noArray()) CV_OVERRIDE;
+
+    float getAlpha() const CV_OVERRIDE { return _alpha; }
+    void setAlpha(float value) CV_OVERRIDE
+    {
+      _alpha = value;
+      _sxStep = sqrt(1 / _alpha);
+      _ayStep = (1 + _alpha) / (2 * _alpha);
+      _xyStepRatio = (1 - _alpha) / (1 + _alpha);
+    }
+
+    float getBeta() const CV_OVERRIDE { return _beta; }
+    void setBeta(float value) CV_OVERRIDE { _beta = value; }
+
+    float getEta() const CV_OVERRIDE { return _eta; }
+    void setEta(float value) CV_OVERRIDE { _eta = value; }
+
+    float getMinScore() const CV_OVERRIDE { return _minScore; }
+    void setMinScore(float value) CV_OVERRIDE { _minScore = value; }
+
+    int getMaxBoxes() const CV_OVERRIDE { return _maxBoxes; }
+    void setMaxBoxes(int value) CV_OVERRIDE { _maxBoxes = value; }
+
+    float getEdgeMinMag() const CV_OVERRIDE { return _edgeMinMag; }
+    void setEdgeMinMag(float value) CV_OVERRIDE { _edgeMinMag = value; }
+
+    float getEdgeMergeThr() const CV_OVERRIDE { return _edgeMergeThr; }
+    void setEdgeMergeThr(float value) CV_OVERRIDE { _edgeMergeThr = value; }
+
+    float getClusterMinMag() const CV_OVERRIDE { return _clusterMinMag; }
+    void setClusterMinMag(float value) CV_OVERRIDE { _clusterMinMag = value; }
+
+    float getMaxAspectRatio() const CV_OVERRIDE { return _maxAspectRatio; }
+    void setMaxAspectRatio(float value) CV_OVERRIDE { _maxAspectRatio = value; }
+
+    float getMinBoxArea() const CV_OVERRIDE { return _minBoxArea; }
+    void setMinBoxArea(float value) CV_OVERRIDE { _minBoxArea = value; }
+
+    float getGamma() const CV_OVERRIDE { return _gamma; }
+    void setGamma(float value) CV_OVERRIDE { _gamma = value; }
+
+    float getKappa() const CV_OVERRIDE { return _kappa; }
+    void setKappa(float value) CV_OVERRIDE
+    {
+      _kappa = value;
+      _scaleNorm.resize(10000);
+      for (int i = 0; i < 10000; i++) _scaleNorm[i] = pow(1.f / i, _kappa);
+    }
+
+    //! the destructor
+    virtual ~EdgeBoxesImpl() {}
+
+private:
+    float _alpha;
+    float _beta;
+    float _eta;
+    float _minScore;
+    int _maxBoxes;
+    float _edgeMinMag;
+    float _edgeMergeThr;
+    float _clusterMinMag;
+    float _maxAspectRatio;
+    float _minBoxArea;
+    float _gamma;
+    float _kappa;
+
+    // edge segment information (see clusterEdges)
+    int h, w;                         // image dimensions
+    int _segCnt;                      // total segment count
+    Mat _segIds;                      // segment ids (-1/0 means no segment)
+    vector<float> _segMag;            // segment edge magnitude sums
+    vector<Point2i> _segP;            // segment lower-right pixel
+    vector<vector<float> > _segAff;   // segment affinities
+    vector<vector<int> > _segAffIdx;  // segment neighbors
+
+    // data structures for efficiency (see prepDataStructs)
+    Mat _segIImg, _magIImg;
+    Mat _hIdxImg, _vIdxImg;
+    vector<vector<int> > _hIdxs, _vIdxs;
+    vector<float> _scaleNorm;
+    float _sxStep, _ayStep, _xyStepRatio;
+
+    // data structures for efficiency (see scoreBox)
+    Mat _sWts;
+    Mat _sDone, _sMap, _sIds;
+    int _sId;
+
+    // helper routines
+    static bool boxesCompare(const Box &a, const Box &b) { return a.score < b.score; }
+    void clusterEdges(Mat &edgeMap, Mat &orientationMap);
+    void prepDataStructs(Mat &edgeMap);
+    void scoreAllBoxes(Boxes &boxes);
+    void scoreBox(Box &box);
+    void refineBox(Box &box);
+    float boxesOverlap(Box &a, Box &b);
+    void boxesNms(Boxes &boxes, float thr, float eta, int maxBoxes);
+};
+
+
+EdgeBoxesImpl::EdgeBoxesImpl(float alpha,
+                             float beta,
+                             float eta,
+                             float minScore,
+                             int maxBoxes,
+                             float edgeMinMag,
+                             float edgeMergeThr,
+                             float clusterMinMag,
+                             float maxAspectRatio,
+                             float minBoxArea,
+                             float gamma,
+                             float kappa)
+    : _alpha(alpha),
+      _beta(beta),
+      _eta(eta),
+      _minScore(minScore),
+      _maxBoxes(maxBoxes),
+      _edgeMinMag(edgeMinMag),
+      _edgeMergeThr(edgeMergeThr),
+      _clusterMinMag(clusterMinMag),
+      _maxAspectRatio(maxAspectRatio),
+      _minBoxArea(minBoxArea),
+      _gamma(gamma),
+      _kappa(kappa)
+
+{
+  // initialize step sizes
+  _sxStep = sqrt(1 / _alpha);
+  _ayStep = (1 + _alpha) / (2 * _alpha);
+  _xyStepRatio = (1 - _alpha) / (1 + _alpha);
+
+  // create _scaleNorm
+  _scaleNorm.resize(10000);
+  for (int i = 0; i < 10000; i++) _scaleNorm[i] = pow(1.f / i, _kappa);
+
+}
+
+
+void EdgeBoxesImpl::clusterEdges(Mat &edgeMap, Mat &orientationMap)
+{
+    int x, y, xd, yd, i, j;
+
+    // greedily merge connected edge pixels into clusters (create _segIds)
+    _segIds = Mat::zeros(w, h, DataType<int>::type);
+    _segCnt = 1;
+    for (x = 0; x < w; x++)
+    {
+        const float *e_ptr = edgeMap.ptr<float>(x);
+        int *s_ptr = _segIds.ptr<int>(x);
+        for (y = 0; y < h; y++)
+        {
+            if (x == 0 || y == 0 || x == w - 1 || y == h - 1 || e_ptr[y] <= _edgeMinMag)
+            {
+                s_ptr[y] = -1;
+            }
+        }
+    }
+
+    for (x = 1; x < w - 1; x++)
+    {
+        int *s_ptr = _segIds.ptr<int>(x);
+        for (y = 1; y < h - 1; y++)
+        {
+            if (s_ptr[y] != 0) continue;
+            float sumv = 0;
+            int x0 = x;
+            int y0 = y;
+            vector<float> vs;
+            vector<int> xs, ys;
+
+            while (sumv < _edgeMergeThr)
+            {
+                _segIds.at<int>(x0, y0) = _segCnt;
+                float o0 = orientationMap.at<float>(x0, y0);
+                float o1, v;
+                bool found;
+                for (xd = -1; xd <= 1; xd++)
+                {
+                    const int *s0_ptr = _segIds.ptr<int>(x0 + xd);
+                    const float *o_ptr = orientationMap.ptr<float>(x0 + xd);
+                    for (yd = -1; yd <= 1; yd++)
+                    {
+                        if (s0_ptr[y0 + yd] != 0) continue;
+                        found = false;
+                        for (i = 0; i < (int)xs.size(); i++)
+                        {
+                            if (xs[i] == x0 + xd && ys[i] == y0 + yd)
+                            {
+                                found = true;
+                                break;
+                            }
+                        }
+                        if (found) continue;
+                        o1 = o_ptr[y0 + yd];
+                        v = fabs(o1 - o0) / (float)CV_PI;
+                        if (v > .5f) v = 1 - v;
+                        vs.push_back(v);
+                        xs.push_back(x0 + xd);
+                        ys.push_back(y0 + yd);
+                    }
+                }
+                float minv = 1000;
+                j = 0;
+                for (i = 0; i < (int)vs.size(); i++)
+                {
+                    if (vs[i] < minv)
+                    {
+                        minv = vs[i];
+                        x0 = xs[i];
+                        y0 = ys[i];
+                        j = i;
+                    }
+                }
+                sumv += minv;
+                if (minv < 1000) vs[j] = 1000;
+            }
+
+            _segCnt++;
+        }
+    }
+
+    // merge or remove small segments
+    _segMag.resize(_segCnt, 0);
+    for (x = 1; x < w - 1; x++)
+    {
+        const float *e_ptr = edgeMap.ptr<float>(x);
+        const int *s_ptr = _segIds.ptr<int>(x);
+        for (y = 1; y < h - 1; y++)
+        {
+          j = s_ptr[y];
+          if (j > 0) _segMag[j] += e_ptr[y];
+        }
+    }
+
+    for (x = 1; x < w - 1; x++)
+    {
+        int *s_ptr = _segIds.ptr<int>(x);
+        for (y = 1; y < h - 1; y++)
+        {
+          j = s_ptr[y];
+          if (j > 0 && _segMag[j] <= _clusterMinMag)
+              s_ptr[y] = 0;
+        }
+    }
+
+    i = 1;
+    while (i > 0)
+    {
+        i = 0;
+        for (x = 1; x < w - 1; x++)
+        {
+            int *s0_ptr = _segIds.ptr<int>(x);
+            const float *o0_ptr = orientationMap.ptr<float>(x);
+            for (y = 1; y < h - 1; y++)
+            {
+                if (s0_ptr[y] != 0) continue;
+                float o0 = o0_ptr[y];
+                float o1, v, minv = 1000;
+                j = 0;
+
+                for (xd = -1; xd <= 1; xd++)
+                {
+                    const int *s1_ptr = _segIds.ptr<int>(x+xd);
+                    const float *o1_ptr = orientationMap.ptr<float>(x+xd);
+                    for (yd = -1; yd <= 1; yd++)
+                    {
+                        if (s1_ptr[y + yd] <= 0) continue;
+                        o1 = o1_ptr[y + yd];
+                        v = fabs(o1 - o0) / (float)CV_PI;
+                        if (v > .5f) v = 1 - v;
+                        if (v < minv)
+                        {
+                            minv = v;
+                            j = s1_ptr[y + yd];
+                        }
+                    }
+                }
+
+                s0_ptr[y] = j;
+                if (j > 0) i++;
+            }
+        }
+    }
+
+    // compactify representation
+    _segMag.assign(_segCnt, 0);
+    vector<int> map(_segCnt, 0);
+    _segCnt = 1;
+    for (x = 1; x < w - 1; x++)
+    {
+        const float *e_ptr = edgeMap.ptr<float>(x);
+        const int *s_ptr = _segIds.ptr<int>(x);
+        for (y = 1; y < h - 1; y++)
+        {
+            j = s_ptr[y];
+            if (j > 0) _segMag[j] += e_ptr[y];
+        }
+    }
+
+    for (i = 0; i < (int)_segMag.size(); i++)
+    {
+      if (_segMag[i] > 0) map[i] = _segCnt++;
+    }
+
+    for (x = 1; x < w - 1; x++)
+    {
+        int *s_ptr = _segIds.ptr<int>(x);
+        for (y = 1; y < h - 1; y++)
+        {
+          j = s_ptr[y];
+          if (j > 0) s_ptr[y] = map[j];
+        }
+    }
+
+    // compute positional means and recompute _segMag
+    _segMag.assign(_segCnt, 0);
+    vector<float> meanX(_segCnt, 0), meanY(_segCnt, 0);
+    vector<float> meanOx(_segCnt, 0), meanOy(_segCnt, 0), meanO(_segCnt, 0);
+    for (x = 1; x < w - 1; x++)
+    {
+        int *s_ptr = _segIds.ptr<int>(x);
+        const float *e_ptr = edgeMap.ptr<float>(x);
+        const float *o_ptr = orientationMap.ptr<float>(x);
+        for (y = 1; y < h - 1; y++)
+        {
+            j = s_ptr[y];
+            if (j <= 0) continue;
+            float m = e_ptr[y];
+            float o = o_ptr[y];
+            _segMag[j] += m;
+            meanOx[j] += m * cos(2 * o);
+            meanOy[j] += m * sin(2 * o);
+            meanX[j] += m * x;
+            meanY[j] += m * y;
+        }
+    }
+
+    for (i = 0; i < _segCnt; i++)
+    {
+        if (_segMag[i] > 0)
+        {
+            float m = _segMag[i];
+            meanX[i] /= m;
+            meanY[i] /= m;
+            meanO[i] = atan2(meanOy[i] / m, meanOx[i] / m) / 2;
+        }
+    }
+
+    // compute segment affinities
+    _segAff.resize(_segCnt);
+    _segAffIdx.resize(_segCnt);
+    for (i = 0; i < _segCnt; i++)
+    {
+      _segAff[i].resize(0);
+      _segAffIdx[i].resize(0);
+    }
+
+    const int rad = 2;
+    for (x = rad; x < w - rad; x++)
+    {
+        const int *s0_ptr = _segIds.ptr<int>(x);
+        for (y = rad; y < h - rad; y++)
+        {
+            int s0 = s0_ptr[y];
+            if (s0 <= 0) continue;
+            for (xd = -rad; xd <= rad; xd++)
+            {
+                const int *s1_ptr = _segIds.ptr<int>(x+xd);
+                for (yd = -rad; yd <= rad; yd++)
+                {
+                    int s1 = s1_ptr[y + yd];
+                    if (s1 <= s0) continue;
+                    bool found = false;
+
+                    for (i = 0; i < (int)_segAffIdx[s0].size(); i++)
+                    {
+                        if (_segAffIdx[s0][i] == s1)
+                        {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (found) continue;
+                    float o = atan2(meanY[s0] - meanY[s1], meanX[s0] - meanX[s1]) + (float)CV_PI / 2.0f;
+                    float a = fabs(cos(meanO[s0] - o) * cos(meanO[s1] - o));
+                    a = pow(a, _gamma);
+                    _segAff[s0].push_back(a);
+                    _segAffIdx[s0].push_back(s1);
+                    _segAff[s1].push_back(a);
+                    _segAffIdx[s1].push_back(s0);
+                }
+            }
+        }
+    }
+
+    // compute _segC and _segR
+    _segP.resize(_segCnt);
+    for (x = 1; x < w - 1; x++)
+    {
+        const int *s_ptr = _segIds.ptr<int>(x);
+        for (y = 1; y < h - 1; y++)
+        {
+            j = s_ptr[y];
+            if (j > 0)
+            {
+                _segP[j] = Point2i(x, y);
+            }
+        }
+    }
+}
+
+
+void EdgeBoxesImpl::prepDataStructs(Mat &edgeMap)
+{
+    int y, x, i;
+
+    // create _segIImg
+    Mat E1 = Mat::zeros(w, h, DataType<float>::type);
+
+    for (i=0; i < _segCnt; i++)
+    {
+      if (_segMag[i] > 0) E1.at<float>(_segP[i].x, _segP[i].y) = _segMag[i];
+    }
+
+    _segIImg = Mat::zeros(w+1, h+1, DataType<float>::type);
+    _magIImg = Mat::zeros(w+1, h+1, DataType<float>::type);
+
+    for (x=1; x < w; x++)
+    {
+      const float *e_ptr = edgeMap.ptr<float>(x);
+      const float *e1_ptr = E1.ptr<float>(x);
+      const float *si0_ptr = _segIImg.ptr<float>(x);
+      float *si1_ptr = _segIImg.ptr<float>(x+1);
+      const float *mi0_ptr = _magIImg.ptr<float>(x);
+      float *mi1_ptr =_magIImg.ptr<float>(x+1);
+      for (y=1; y < h; y++)
+      {
+        // create _segIImg
+        si1_ptr[y+1] = e1_ptr[y] + si0_ptr[y+1] + si1_ptr[y] - si0_ptr[y];
+        float e = e_ptr[y] > _edgeMinMag ? e_ptr[y] : 0;
+        // create _magIImg
+        mi1_ptr[y+1] = e +mi0_ptr[y+1] + mi1_ptr[y] - mi0_ptr[y];
+      }
+    }
+
+    // create remaining data structures
+    int s = 0;
+    int s1;
+
+    _hIdxs.resize(h);
+    _hIdxImg = Mat::zeros(w, h, DataType<int>::type);
+    for (y = 0; y < h; y++)
+    {
+        s = 0;
+        _hIdxs[y].push_back(s);
+        for (x = 0; x < w; x++)
+        {
+            s1 = _segIds.at<int>(x, y);
+            if (s1 != s)
+            {
+                s = s1;
+                _hIdxs[y].push_back(s);
+            }
+            _hIdxImg.at<int>(x, y) = (int)_hIdxs[y].size() - 1;
+        }
+    }
+
+    _vIdxs.resize(w);
+    _vIdxImg = Mat::zeros(w, h, DataType<int>::type);
+    for (x = 0; x < w; x++)
+    {
+        s = 0;
+        _vIdxs[x].push_back(s);
+        for (y = 0; y < h; y++)
+        {
+            s1 = _segIds.at<int>(x, y);
+            if (s1 != s)
+            {
+                s = s1;
+                _vIdxs[x].push_back(s);
+            }
+            _vIdxImg.at<int>(x, y) = (int)_vIdxs[x].size() - 1;
+        }
+    }
+
+    // initialize scoreBox() data structures
+    int n = _segCnt + 1;
+    _sWts = Mat::zeros(n, 1, DataType<float>::type);
+    _sDone = Mat(n, 1, DataType<int>::type,Scalar(-1));
+    _sMap = Mat::zeros(n, 1, DataType<int>::type);
+    _sIds = Mat::zeros(n, 1, DataType<int>::type);
+    _sId = 0;
+}
+
+
+void EdgeBoxesImpl::scoreBox(Box &box)
+{
+    int i, j, k, q, bh, bw, y0, x0, y1, x1, y0m, y1m, x0m, x1m;
+    float *sWts = (float *)_sWts.data;
+    int *sDone = (int *)_sDone.data;
+    int *sMap = (int *)_sMap.data;
+    int *sIds = (int *)_sIds.data;
+    int sId = _sId++;
+
+    // add edge count inside box
+    y1 = clamp(box.y + box.h, 0, h - 1);
+    y0 = box.y = clamp(box.y, 0, h - 1);
+    x1 = clamp(box.x + box.w, 0, w - 1);
+    x0 = box.x = clamp(box.x, 0, w - 1);
+    bh = box.h = y1 - box.y;
+    bh /= 2;
+    bw = box.w = x1 - box.x;
+    bw /= 2;
+    float v = _segIImg.at<float>(x0, y0) + _segIImg.at<float>(x1 + 1, y1 + 1)
+              - _segIImg.at<float>(x1 + 1, y0) - _segIImg.at<float>(x0, y1 + 1);
+
+    // subtract middle quarter of edges
+    y0m = y0 + bh / 2;
+    y1m = y0m + bh;
+    x0m = x0 + bw / 2;
+    x1m = x0m + bw;
+    v -= _magIImg.at<float>(x0m, y0m) + _magIImg.at<float>(x1m + 1, y1m + 1)
+         - _magIImg.at<float>(x1m + 1, y0m) - _magIImg.at<float>(x0m, y1m + 1);
+
+    // short circuit computation if impossible to score highly
+    float norm = _scaleNorm[bw + bh];
+    box.score = v * norm;
+    if (box.score < _minScore)
+    {
+        box.score = 0;
+        return;
+    }
+
+    // find interesecting segments along four boundaries
+    int cs, ce, rs, re, n = 0;
+    cs = _hIdxImg.at<int>(x0, y0);
+    ce = _hIdxImg.at<int>(x1, y0); // top
+    for (i = cs; i <= ce; i++)
+    {
+        j = _hIdxs[y0][i];
+        if (j > 0 && sDone[j] != sId)
+        {
+            sIds[n] = j;
+            sWts[n] = 1;
+            sDone[j] = sId;
+            sMap[j] = n++;
+        }
+    }
+
+    cs = _hIdxImg.at<int>(x0, y1);
+    ce = _hIdxImg.at<int>(x1, y1); // bottom
+    for (i = cs; i <= ce; i++)
+    {
+        j = _hIdxs[y1][i];
+        if (j > 0 && sDone[j] != sId)
+        {
+            sIds[n] = j;
+            sWts[n] = 1;
+            sDone[j] = sId;
+            sMap[j] = n++;
+        }
+    }
+
+    rs = _vIdxImg.at<int>(x0, y0);
+    re = _vIdxImg.at<int>(x0, y1); // left
+    for (i = rs; i <= re; i++)
+    {
+        j = _vIdxs[x0][i];
+        if (j > 0 && sDone[j] != sId)
+        {
+            sIds[n] = j;
+            sWts[n] = 1;
+            sDone[j] = sId;
+            sMap[j] = n++;
+        }
+    }
+
+    rs = _vIdxImg.at<int>(x1, y0);
+    re = _vIdxImg.at<int>(x1, y1); // right
+    for (i = rs; i <= re; i++)
+    {
+        j = _vIdxs[x1][i];
+        if (j > 0 && sDone[j] != sId)
+        {
+            sIds[n] = j;
+            sWts[n] = 1;
+            sDone[j] = sId;
+            sMap[j] = n++;
+        }
+    }
+
+    // follow connected paths and set weights accordingly (ws=1 means remove)
+    for (i = 0; i < n; i++)
+    {
+        float ws = sWts[i];
+        j = sIds[i];
+        for (k = 0; k < (int)_segAffIdx[j].size(); k++)
+        {
+            q = _segAffIdx[j][k];
+            float wq = ws * _segAff[j][k];
+            if (wq < .05f) continue; // short circuit for efficiency
+            if (sDone[q] == sId)
+            {
+                if (wq > sWts[sMap[q]])
+                {
+                    sWts[sMap[q]] = wq;
+                    i = min(i, sMap[q] - 1);
+                }
+            }
+            else if (_segP[q].x >= x0 && _segP[q].x <= x1 && _segP[q].y >= y0 && _segP[q].y <= y1)
+            {
+                sIds[n] = q;
+                sWts[n] = wq;
+                sDone[q] = sId;
+                sMap[q] = n++;
+            }
+        }
+    }
+    // finally remove segments connected to boundaries
+    for (i = 0; i < n; i++)
+    {
+        k = sIds[i];
+        if (_segP[k].x >= x0 && _segP[k].x <= x1 && _segP[k].y >= y0 && _segP[k].y <= y1) v -= sWts[i] * _segMag[k];
+    }
+
+    v *= norm;
+    if (v < _minScore) v = 0;
+    box.score = v;
+}
+
+
+void EdgeBoxesImpl::refineBox(Box &box)
+{
+    int yStep = (int)(box.h * _xyStepRatio);
+    int xStep = (int)(box.w * _xyStepRatio);
+    while (1)
+    {
+        // prepare for iteration
+        yStep /= 2;
+        xStep /= 2;
+        if (yStep <= 2 && xStep <= 2) break;
+        yStep = max(1, yStep);
+        xStep = max(1, xStep);
+        Box B;
+        // search over y start
+        B = box;
+        B.y = box.y - yStep;
+        B.h = B.h + yStep;
+        scoreBox(B);
+
+        if (B.score <= box.score)
+        {
+            B = box;
+            B.y = box.y + yStep;
+            B.h = B.h - yStep;
+            scoreBox(B);
+        }
+        if (B.score > box.score) box = B;
+        // search over y end
+        B = box;
+        B.h = B.h + yStep;
+        scoreBox(B);
+
+        if (B.score <= box.score)
+        {
+            B = box;
+            B.h = B.h - yStep;
+            scoreBox(B);
+        }
+        if (B.score > box.score) box = B;
+        // search over x start
+        B = box;
+        B.x = box.x - xStep;
+        B.w = B.w + xStep;
+        scoreBox(B);
+
+        if (B.score <= box.score)
+        {
+            B = box;
+            B.x = box.x + xStep;
+            B.w = B.w - xStep;
+            scoreBox(B);
+        }
+
+        if (B.score > box.score) box = B;
+        // search over x end
+        B = box;
+        B.w = B.w + xStep;
+        scoreBox(B);
+
+        if (B.score <= box.score)
+        {
+            B = box;
+            B.w = B.w - xStep;
+            scoreBox(B);
+        }
+        if (B.score > box.score) box = B;
+    }
+}
+
+void EdgeBoxesImpl::scoreAllBoxes(Boxes &boxes)
+{
+    // get list of all boxes roughly distributed in grid
+    boxes.resize(0);
+    int ayRad, sxNum;
+    float minSize = sqrt(_minBoxArea);
+    ayRad = (int)(log(_maxAspectRatio) / log(_ayStep * _ayStep));
+    sxNum = (int)(ceil(log(max(w, h) / minSize) / log(_sxStep)));
+
+    for (int s = 0; s < sxNum; s++)
+    {
+        int a, y, x, bh, bw, ky, kx = -1;
+        float ay, sx;
+        for (a = 0; a < 2 * ayRad + 1; a++)
+        {
+            ay = pow(_ayStep, float(a - ayRad));
+            sx = minSize * pow(_sxStep, float(s));
+            bh = (int)(sx / ay);
+            ky = max(2, (int)(bh * _xyStepRatio));
+            bw = (int)(sx * ay);
+            kx = max(2, (int)(bw * _xyStepRatio));
+            for (x = 0; x < w - bw + kx; x += kx)
+            {
+                for (y = 0; y < h - bh + ky; y += ky)
+                {
+                    Box b;
+                    b.y = y;
+                    b.x = x;
+                    b.h = bh;
+                    b.w = bw;
+                    boxes.push_back(b);
+                }
+            }
+        }
+    }
+
+    // score all boxes, refine top candidates
+    int i, k = 0, m = (int)boxes.size();
+    for (i = 0; i < m; i++)
+    {
+        scoreBox(boxes[i]);
+        if (!boxes[i].score) continue;
+        k++;
+        refineBox(boxes[i]);
+    }
+    sort(boxes.rbegin(), boxes.rend(), boxesCompare);
+    boxes.resize(k);
+}
+
+
+float EdgeBoxesImpl::boxesOverlap(Box &a, Box &b)
+{
+    float areai, areaj, areaij;
+    int y0, y1, x0, x1, y1i, x1i, y1j, x1j;
+    y1i = a.y + a.h;
+    x1i = a.x + a.w;
+    if (a.y >= y1i || a.x >= x1i) return 0;
+
+    y1j = b.y + b.h;
+    x1j = b.x + b.w;
+    if (a.y >= y1j || a.x >= x1j) return 0;
+
+    areai = (float) a.w * a.h;
+    y0 = max(a.y, b.y);
+    y1 = min(y1i, y1j);
+    areaj = (float) b.w * b.h;
+    x0 = max(a.x, b.x);
+    x1 = min(x1i, x1j);
+    areaij = (float) max(0, y1 - y0) * max(0, x1 - x0);
+    return areaij / (areai + areaj - areaij);
+}
+
+
+void EdgeBoxesImpl::boxesNms(Boxes &boxes, float thr, float eta, int maxBoxes)
+{
+    sort(boxes.rbegin(), boxes.rend(), boxesCompare);
+    if (thr > .99f) return;
+
+    const int nBin = 10000;
+    const float step = 1 / thr;
+    const float lstep = log(step);
+
+    vector<Boxes> kept;
+    kept.resize(nBin + 1);
+    int n = (int) boxes.size();
+    int i = 0;
+    int j, k, b;
+    int m = 0;
+    int d = 1;
+
+    while (i < n && m < maxBoxes)
+    {
+        b = boxes[i].w * boxes[i].h;
+
+        bool keep = 1;
+        b = clamp((int)(ceil(log(float(b)) / lstep)), d, nBin - d);
+        for (j = b - d; j <= b + d; j++)
+        {
+            for (k = 0; k < (int)kept[j].size(); k++)
+            {
+                if (keep)
+                    keep = boxesOverlap(boxes[i], kept[j][k]) <= thr;
+            }
+        }
+
+        if (keep)
+        {
+            kept[b].push_back(boxes[i]);
+            m++;
+        }
+
+        i++;
+        if (keep && eta < 1.0f && thr > .5f)
+        {
+            thr *= eta;
+            d = (int)ceil(log(1.0f / thr) / lstep);
+        }
+    }
+
+    boxes.resize(m);
+    i = 0;
+    for (j = 0; j < nBin; j++)
+    {
+        for (k = 0; k < (int)kept[j].size(); k++)
+        {
+            boxes[i++] = kept[j][k];
+        }
+    }
+    sort(boxes.rbegin(), boxes.rend(), boxesCompare);
+}
+
+
+void EdgeBoxesImpl::getBoundingBoxes(InputArray edge_map, InputArray orientation_map, std::vector<Rect> &boxes, OutputArray scores)
+{
+    CV_Assert(edge_map.depth() == CV_32F);
+    CV_Assert(orientation_map.depth() == CV_32F);
+
+    Mat E = edge_map.getMat().t();
+    Mat O = orientation_map.getMat().t();
+    std::vector<float> _scores;
+
+    h = E.cols;
+    w = E.rows;
+
+    clusterEdges(E, O);
+    prepDataStructs(E);
+
+    Boxes b;
+    scoreAllBoxes(b);
+    boxesNms(b, _beta, _eta, _maxBoxes);
+
+    // create output boxes
+    int n = (int) b.size();
+    boxes.resize(n);
+
+    if (scores.needed())
+    {
+        _scores.resize(n);
+    }
+
+    for(int i=0; i < n; i++)
+    {
+        boxes[i] = Rect((int)b[i].x + 1, (int)b[i].y + 1, (int)b[i].w, (int)b[i].h);
+        if (scores.needed())
+        {
+            _scores[i] = b[i].score;
+        }
+    }
+
+    // return scores if asked for
+    if (scores.needed())
+    {
+        Mat(_scores).copyTo(scores);
+    }
+}
+
+
+Ptr<EdgeBoxes> createEdgeBoxes(float alpha,
+                              float beta,
+                              float eta,
+                              float minScore,
+                              int   maxBoxes,
+                              float edgeMinMag,
+                              float edgeMergeThr,
+                              float clusterMinMag,
+                              float maxAspectRatio,
+                              float minBoxArea,
+                              float gamma,
+                              float kappa)
+{
+    return makePtr<EdgeBoxesImpl>(alpha,
+                                  beta,
+                                  eta,
+                                  minScore,
+                                  maxBoxes,
+                                  edgeMinMag,
+                                  edgeMergeThr,
+                                  clusterMinMag,
+                                  maxAspectRatio,
+                                  minBoxArea,
+                                  gamma,
+                                  kappa);
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgepreserving_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgepreserving_filter.cpp
new file mode 100644
index 00000000..ea9dfb65
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/edgepreserving_filter.cpp
@@ -0,0 +1,236 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+//
+//                    Created by Simon Reich
+//
+
+#include "precomp.hpp"
+
+namespace cv
+{
+namespace ximgproc
+{
+using namespace std;
+
+void edgePreservingFilter(InputArray _src, OutputArray _dst, int d,
+                          double threshold)
+{
+    CV_Assert(_src.type() == CV_8UC3);
+
+    Mat src = _src.getMat();
+
+    // [re]create the output array so that it has the proper size and type.
+    _dst.create(src.size(), src.type());
+    Mat dst = _dst.getMat();
+    src.copyTo(dst);
+
+    if (d < 3)
+        d = 3;
+    int subwindowX = d, subwindowY = d;
+
+    if (threshold < 0)
+        threshold = 0;
+
+    // number of image channels
+    int nChannel = src.channels();
+
+    vector<double> pixel(nChannel, 0);
+    vector<vector<double>> line1(src.rows, pixel);
+    vector<vector<vector<double>>> weight(src.cols,
+                                          line1); // global weights
+    vector<vector<vector<double>>> imageResult(
+        src.cols, line1); // global normalized image
+
+    // do algorithm
+    cv::Mat subwindow, subwindow1;
+    for (int posX = 0; posX < src.cols - subwindowX; posX++)
+    {
+        for (int posY = 0; posY < src.rows - subwindowY; posY++)
+        {
+            cv::Rect roi =
+                cv::Rect(posX, posY, subwindowX, subwindowY);
+            subwindow1 = src(roi);
+            cv::GaussianBlur(subwindow1, subwindow, cv::Size(5, 5),
+                             0.3, 0.3);
+
+            // compute arithmetic mean of subwindow
+            cv::Scalar ArithmeticMean = cv::mean(subwindow);
+
+            // compute pixelwise distance
+            vector<vector<double>> pixelwiseDist;
+
+            for (int subPosX = 0; subPosX < subwindow.cols;
+                 subPosX++)
+            {
+                vector<double> line;
+                for (int subPosY = 0; subPosY < subwindow.rows;
+                     subPosY++)
+                {
+                    cv::Vec3b intensity =
+                        subwindow.at<cv::Vec3b>(subPosY,
+                                                subPosX);
+                    double distance =
+                        ((double)intensity.val[0] -
+                         ArithmeticMean[0]) *
+                            ((double)intensity.val[0] -
+                             ArithmeticMean[0]) +
+                        ((double)intensity.val[1] -
+                         ArithmeticMean[1]) *
+                            ((double)intensity.val[1] -
+                             ArithmeticMean[1]) +
+                        ((double)intensity.val[2] -
+                         ArithmeticMean[2]) *
+                            ((double)intensity.val[2] -
+                             ArithmeticMean[2]);
+                    distance = sqrt(distance);
+
+                    line.push_back(distance);
+                };
+
+                pixelwiseDist.push_back(line);
+            };
+
+            // compute mean pixelwise distance
+            double meanPixelwiseDist = 0;
+
+            for (int i = 0; i < (int)pixelwiseDist.size(); i++)
+                for (int j = 0;
+                     j < (int)pixelwiseDist[i].size(); j++)
+                    meanPixelwiseDist +=
+                        pixelwiseDist[i][j];
+
+            meanPixelwiseDist /= ((int)pixelwiseDist.size() *
+                                  (int)pixelwiseDist[0].size());
+
+            // detect edge
+            for (int subPosX = 0; subPosX < subwindow.cols;
+                 subPosX++)
+            {
+                for (int subPosY = 0; subPosY < subwindow.rows;
+                     subPosY++)
+                {
+                    if ((meanPixelwiseDist <= threshold &&
+                         pixelwiseDist[subPosX][subPosY] <=
+                             threshold) ||
+                        (meanPixelwiseDist <= threshold &&
+                         pixelwiseDist[subPosX][subPosY] >
+                             threshold))
+                    {
+                        // global Position
+                        int globalPosX = posX + subPosX;
+                        int globalPosY = posY + subPosY;
+
+                        // compute global weight
+                        cv::Vec3b intensity =
+                            subwindow.at<cv::Vec3b>(
+                                subPosY, subPosX);
+                        weight[globalPosX][globalPosY]
+                              [0] +=
+                            intensity.val[0] *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]) *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]);
+                        weight[globalPosX][globalPosY]
+                              [1] +=
+                            intensity.val[1] *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]) *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]);
+                        weight[globalPosX][globalPosY]
+                              [2] +=
+                            intensity.val[2] *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]) *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]);
+
+                        // compute final image
+                        imageResult[globalPosX]
+                                   [globalPosY][0] +=
+                            intensity.val[0] *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]) *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]) *
+                            ArithmeticMean[0];
+                        imageResult[globalPosX]
+                                   [globalPosY][1] +=
+                            intensity.val[1] *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]) *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]) *
+                            ArithmeticMean[1];
+                        imageResult[globalPosX]
+                                   [globalPosY][2] +=
+                            intensity.val[2] *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]) *
+                            (threshold -
+                             pixelwiseDist[subPosX]
+                                          [subPosY]) *
+                            ArithmeticMean[2];
+                    };
+                };
+            };
+        };
+    };
+
+    // compute final image
+    for (int globalPosX = 0; globalPosX < (int)imageResult.size();
+         globalPosX++)
+    {
+        for (int globalPosY = 0;
+             globalPosY < (int)imageResult[globalPosX].size();
+             globalPosY++)
+        {
+            // cout << "globalPosX: " << globalPosX << "/"
+            // << dst.cols << "," << imageResult.size () <<
+            // "\tglobalPosY: " << globalPosY << "/" <<
+            // dst.rows << "," <<imageResult.at
+            // (globalPosX).size () << endl;
+
+            // add image to result
+            cv::Vec3b intensity =
+                src.at<cv::Vec3b>(globalPosY, globalPosX);
+            imageResult[globalPosX][globalPosY][0] +=
+                (double)intensity.val[0];
+            imageResult[globalPosX][globalPosY][1] +=
+                (double)intensity.val[1];
+            imageResult[globalPosX][globalPosY][2] +=
+                (double)intensity.val[2];
+
+            // normalize using weight
+            imageResult[globalPosX][globalPosY][0] /=
+                (weight[globalPosX][globalPosY][0] + 1);
+            imageResult[globalPosX][globalPosY][1] /=
+                (weight[globalPosX][globalPosY][1] + 1);
+            imageResult[globalPosX][globalPosY][2] /=
+                (weight[globalPosX][globalPosY][2] + 1);
+
+            // copy to output image frame
+            dst.at<cv::Vec3b>(globalPosY, globalPosX)[0] =
+                (uchar)imageResult[globalPosX][globalPosY][0];
+            dst.at<cv::Vec3b>(globalPosY, globalPosX)[1] =
+                (uchar)imageResult[globalPosX][globalPosY][1];
+            dst.at<cv::Vec3b>(globalPosY, globalPosX)[2] =
+                (uchar)imageResult[globalPosX][globalPosY][2];
+        };
+    };
+}
+} // namespace ximgproc
+} // namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/estimated_covariance.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/estimated_covariance.cpp
new file mode 100644
index 00000000..9c380c9d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/estimated_covariance.cpp
@@ -0,0 +1,375 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+
+Algorithmic details of this algorithm can be found at:
+ * O. Green, Y. Birk, "A Computationally Efficient Algorithm for the 2D Covariance Method", ACM/IEEE International Conference on High Performance Computing, Networking, Storage and Analysis, Denver, Colorado, 2013
+A previous and less efficient version of the algorithm can be found:
+ * O. Green, L. David, A. Galperin, Y. Birk, "Efficient parallel computation of the estimated covariance matrix", arXiv, 2013
+
+
+*/
+
+#include "precomp.hpp"
+
+using namespace cv;
+using namespace std;
+
+
+namespace cv{
+namespace ximgproc{
+
+class EstimateCovariance{
+
+public:
+    EstimateCovariance(int pr_, int pc_);
+    ~EstimateCovariance();
+
+    void computeEstimateCovariance(Mat inputData,Mat outputData);
+    int combinationCount();
+
+private:
+    typedef struct {
+        int mult1r;
+        int mult1c;
+        int mult2r;
+        int mult2c;
+        int type2; // 0 - for the first P*P. 1 - for the next (P-1)(P-1)
+        int id;
+    } Combination;
+
+    void initInternalDataStructures();
+    void buildCombinationsTable();
+
+    void iterateCombinations(Mat inputData,Mat outputData);
+    void computeOneCombination(int comb_id, Mat inputData , Mat outputData,
+        Mat outputVector,std::vector<int> finalMatPosR, std::vector<int> finalMatPosC);
+
+    inline void complexSubtract(std::complex<float>& src, std::complex<float>& dst){dst-=src;}
+    inline void complexAdd(std::complex<float>& src, std::complex<float>& dst){dst+=src;}
+    inline void complexConjMulAndAdd(std::complex<float>& a, std::complex<float>& b,
+            std::complex<float>& dst){dst += a*b;}
+    inline void complexConjMul(std::complex<float>& a, std::complex<float>& b,
+            std::complex<float>& dst){dst = a*b;}
+
+private:
+    int nr;
+    int nc;
+    int pr;
+    int pc;
+
+    std::vector<Combination> combinationsTable;
+};
+
+
+
+EstimateCovariance::EstimateCovariance(int pr_, int pc_){
+    pr=pr_; pc=pc_;
+}
+
+EstimateCovariance::~EstimateCovariance(){
+
+}
+
+void EstimateCovariance::initInternalDataStructures(){
+    int combCount = combinationCount();
+    combinationsTable.resize(combCount);
+    buildCombinationsTable();
+}
+
+int EstimateCovariance::combinationCount(){
+    return  (pr*pc+(pr-1)*(pc-1));
+}
+
+void EstimateCovariance::buildCombinationsTable()
+{
+    int idx_row,idx_col;
+    int comb_idx = 0;
+    Combination comb;
+
+    // The first element of the product is [0,0] and the second is to down and to the right of it.
+    for (idx_col=0; idx_col<pc; ++idx_col)  {
+        for (idx_row=0; idx_row<pr; ++idx_row)      {
+            comb.mult1r=0;
+            comb.mult1c=0;
+            comb.mult2r=idx_row;
+            comb.mult2c=idx_col;
+            comb.type2 = 0;
+            comb.id = comb_idx;
+            memcpy(&combinationsTable[comb_idx++], &comb, sizeof(Combination));
+        }
+    }
+
+    // The first element is on the top right, and the second element is to the left and down of it.
+    for (idx_row=1; idx_row<pr; ++idx_row)  {
+        for (idx_col=1; idx_col<pc; ++idx_col)      {
+            comb.mult1r=idx_row;
+            comb.mult1c=0;
+            comb.mult2r=0;
+            comb.mult2c=idx_col;
+
+            comb.type2 = 1;
+            comb.id = comb_idx;
+            memcpy(&combinationsTable[comb_idx++], &comb, sizeof(Combination));
+        }
+    }
+}
+
+void EstimateCovariance::computeEstimateCovariance(Mat inputData,Mat outputData){
+    initInternalDataStructures();
+    nr=inputData.rows;
+    nc=inputData.cols;
+
+    iterateCombinations(inputData,outputData);
+}
+
+
+void EstimateCovariance::iterateCombinations(Mat inputData,Mat outputData)
+{
+    Mat outputVector(pr*pc,1,  DataType<std::complex<float> >::type);
+
+    std::vector<int> finalMatPosR(pr*pc,0);
+    std::vector<int> finalMatPosC(pr*pc,0);
+    int combs=combinationCount();
+    for (int idx=0; idx<combs; idx++){
+        outputVector.setTo(Scalar(0,0));
+        for (unsigned x=0; x<finalMatPosR.size(); x++)
+            finalMatPosR[x]=0;
+        for (unsigned x=0; x<finalMatPosC.size(); x++)
+            finalMatPosC[x]=0;
+        computeOneCombination(idx++, inputData, outputData,
+                outputVector,finalMatPosR, finalMatPosC);
+    }
+}
+
+void EstimateCovariance::computeOneCombination(int comb_id,Mat inputData, Mat outputData,
+            Mat outputVector,std::vector<int> finalMatPosR, std::vector<int> finalMatPosC)
+{
+    Combination* comb = &combinationsTable[comb_id];
+    int type2 = comb->type2;
+    int deltaR = (int)abs((int)(comb->mult1r-comb->mult2r));
+    int deltaC = (int)abs((int)(comb->mult1c-comb->mult2c));
+    int numElementsInBlock = pr-abs(deltaR);
+    int numBlocks = pc-deltaC;
+    const int DR= nr-pr;
+    const int DC= nc-pc;
+
+    int elementC=0;
+    std::complex<float> temp_res = std::complex<float>(0,0);
+    int i,j,r,c;
+
+    if (!type2) {
+        // Computing the first index of the combination.
+        // This index is made up
+        for(i=0; i<=( DR); i++) {
+            int iPdr=i+deltaR;
+            for(j=0; j<= (DC); j++) {
+                int jPdc = j+deltaC;
+                complexConjMulAndAdd(inputData.at<std::complex<float> >(i,j), inputData.at<std::complex<float> >(iPdr,jPdc), temp_res);
+            }
+        }
+    }else{
+        // Computing the first index of the combination.
+        for(i=0; i<=( DR); i++) {
+            int iPdr=i+deltaR;
+            for(j=0; j<= (DC); j++) {
+                int jPdc = j+deltaC;
+                complexConjMulAndAdd(inputData.at<std::complex<float> >(iPdr,j), inputData.at<std::complex<float> >(i,jPdc), temp_res);
+            }
+        }
+    }
+    outputVector.at<std::complex<float> >(0,0) = temp_res;
+
+    // Checking if the first element belongs to the first set of combinatons.
+    // The combination that the first element is above the second.
+    if (!type2) {
+        finalMatPosR[0]=0;
+        finalMatPosC[0]=pr*deltaC+deltaR;
+        elementC++;
+    }else{
+        finalMatPosR[0]=deltaR;
+        finalMatPosC[0]=pr*deltaC;
+        elementC++;
+    }
+
+    for(r=1;r<(pr-deltaR);r++){
+        std::complex<float> newRowSum = std::complex<float>(0,0),oldRowSum = std::complex<float>(0,0);
+        std::complex<float> addRows  = std::complex<float>(0,0);
+
+        int rM1 = r-1;
+        int k = DR+1 + rM1;
+        int kPdr = k+deltaR;
+        int rM1Pdr = rM1 + deltaR;
+        int cPdc;
+
+        if (!type2) {
+            for(c=0;c<=(DC); c++){
+                cPdc = c+deltaC;
+                complexConjMulAndAdd(inputData.at<std::complex<float> >(k,c),inputData.at<std::complex<float> >(kPdr,cPdc),newRowSum);
+                complexConjMulAndAdd(inputData.at<std::complex<float> >(rM1,c),inputData.at<std::complex<float> >(rM1Pdr,cPdc),oldRowSum);
+            }
+        }else{
+            for(c=0;c<=(DC); c++){
+                cPdc = c+deltaC;
+                complexConjMulAndAdd(inputData.at<std::complex<float> >(kPdr,c),inputData.at<std::complex<float> >(k,cPdc),newRowSum);
+                complexConjMulAndAdd(inputData.at<std::complex<float> >(rM1Pdr,c),inputData.at<std::complex<float> >(rM1,cPdc),oldRowSum);
+            }
+        }
+        complexAdd(newRowSum,addRows);
+        complexSubtract(oldRowSum,addRows);
+        complexAdd(outputVector.at<std::complex<float> >(rM1,0),outputVector.at<std::complex<float> >(r,0));
+        complexAdd(addRows,outputVector.at<std::complex<float> >(r,0));
+
+        finalMatPosR[elementC]=finalMatPosR[elementC-1]+1;;
+        finalMatPosC[elementC]=finalMatPosC[elementC-1]+1;
+        elementC++;
+    }
+
+    for(c=1; c<numBlocks; c++)  {
+        std::complex<float> newColSum = std::complex<float>(0,0),oldColSum = std::complex<float>(0,0);
+        std::complex<float> addCols  = std::complex<float>(0,0);
+
+        // Index arithmetic
+        int cM1 = c-1;
+        int dcPc = DC+c;
+        int q = DC+1 + cM1;
+        int cM1PdeltaC = cM1 + deltaC;
+        int dcPcPdeltaC = dcPc+deltaC;
+
+        if (!type2) {
+            for(r=0;r<=(DR); r++){
+                int rPdr = r+deltaR;
+                complexConjMulAndAdd(inputData.at<std::complex<float> >(r,q),inputData.at<std::complex<float> >(rPdr,q+deltaC),newColSum);
+                complexConjMulAndAdd(inputData.at<std::complex<float> >(r,cM1),inputData.at<std::complex<float> >(rPdr,cM1+deltaC),oldColSum);
+            }
+        }else{
+            for(r=0;r<=(DR); r++){
+                int rPdr = r+deltaR;
+                complexConjMulAndAdd(inputData.at<std::complex<float> >(rPdr,q),inputData.at<std::complex<float> >(r,q+deltaC),newColSum);
+                complexConjMulAndAdd(inputData.at<std::complex<float> >(rPdr,cM1),inputData.at<std::complex<float> >(r,cM1+deltaC),oldColSum);
+            }
+        }
+        complexAdd(newColSum,addCols);
+        complexSubtract(oldColSum,addCols);
+        complexAdd(outputVector.at<std::complex<float> >((c-1)*numElementsInBlock,0),outputVector.at<std::complex<float> >(c*numElementsInBlock,0));
+        complexAdd(addCols,outputVector.at<std::complex<float> >(c*numElementsInBlock,0));
+
+        finalMatPosR[elementC]=finalMatPosR[elementC-numElementsInBlock]+pr;
+        finalMatPosC[elementC]=finalMatPosC[elementC-numElementsInBlock]+pr;
+        elementC++;
+
+        for(r=1; r<numElementsInBlock; r++) {
+            std::complex<float> w = std::complex<float>(0,0),x = std::complex<float>(0,0),
+                y = std::complex<float>(0,0),z = std::complex<float>(0,0),deltaRowSum = std::complex<float>(0,0);
+            std::complex<float> tempRes = std::complex<float>(0,0);
+            // Index arithmetic
+            int rM1 = r-1;
+            int drPr = DR+r;
+            int rM1PdeltaR = rM1 + deltaR;
+            int drPrPdeltaR = drPr+deltaR;
+
+            if (!type2) {
+                complexConjMul(inputData.at<std::complex<float> >(rM1,cM1),inputData.at<std::complex<float> >(rM1PdeltaR,cM1PdeltaC),w);
+                complexConjMul(inputData.at<std::complex<float> >(rM1,dcPc),inputData.at<std::complex<float> >(rM1PdeltaR,dcPcPdeltaC),x);
+                complexConjMul(inputData.at<std::complex<float> >(drPr,cM1),inputData.at<std::complex<float> >(drPrPdeltaR,cM1PdeltaC),y);
+                complexConjMul(inputData.at<std::complex<float> >(drPr,dcPc),inputData.at<std::complex<float> >(drPrPdeltaR,dcPcPdeltaC),z);
+            }else{
+                complexConjMul(inputData.at<std::complex<float> >(rM1PdeltaR,cM1),inputData.at<std::complex<float> >(rM1,cM1PdeltaC),w);
+                complexConjMul(inputData.at<std::complex<float> >(rM1PdeltaR,dcPc),inputData.at<std::complex<float> >(rM1,dcPcPdeltaC),x);
+                complexConjMul(inputData.at<std::complex<float> >(drPrPdeltaR,cM1),inputData.at<std::complex<float> >(drPr,cM1PdeltaC),y);
+                complexConjMul(inputData.at<std::complex<float> >(drPrPdeltaR,dcPc),inputData.at<std::complex<float> >(drPr,dcPcPdeltaC),z);
+            }
+            complexAdd(w,tempRes);
+            complexSubtract(x,tempRes);
+            complexSubtract(y,tempRes);
+            complexAdd(z,tempRes);
+
+            complexAdd(outputVector.at<std::complex<float> >((c-1)*numElementsInBlock + r,0),deltaRowSum);
+            complexSubtract(outputVector.at<std::complex<float> >((c-1)*numElementsInBlock+ rM1,0),deltaRowSum);
+
+            complexAdd(deltaRowSum,tempRes);
+            complexAdd(outputVector.at<std::complex<float> >(c*numElementsInBlock+rM1,0),tempRes);
+            complexAdd(tempRes,outputVector.at<std::complex<float> >(c*numElementsInBlock+r,0));
+
+            finalMatPosR[elementC]=finalMatPosR[elementC-1]+1;
+            finalMatPosC[elementC]=finalMatPosC[elementC-1]+1;
+            elementC++;
+        }
+    }
+
+    for(i=0; i<numElementsInBlock*numBlocks; i++){
+        outputData.at<std::complex<float> >(finalMatPosR[i],finalMatPosC[i])=outputVector.at<std::complex<float> >(i,0);
+    }
+}
+
+
+
+void covarianceEstimation(InputArray input_, OutputArray output_,int windowRows, int windowCols){
+
+    CV_Assert( input_.channels() <= 2);   // Does not take color images.
+
+    Mat input;
+
+    Mat temp=input_.getMat();
+    if(temp.channels() == 1){
+        temp.convertTo(temp,CV_32FC2);
+        Mat zmat = Mat::zeros(temp.size(), CV_32F);
+        Mat twoChannelsbefore[] = {temp,zmat};
+        cv::merge(twoChannelsbefore,2,input);
+    }else{
+        temp.convertTo(input, CV_32FC2);
+
+    }
+
+    EstimateCovariance estCov(windowRows,windowCols);
+
+    //input_.getMat().convertTo(input, CV_32FC2);
+
+    output_.create(windowRows*windowCols,windowRows*windowCols,  DataType<std::complex<float> >::type);
+
+    Mat output = output_.getMat();
+
+    estCov.computeEstimateCovariance(input,output);
+}
+
+} // namespace ximgproc
+} // namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fast_hough_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fast_hough_transform.cpp
new file mode 100644
index 00000000..391d3fa4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fast_hough_transform.cpp
@@ -0,0 +1,1026 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2015, Smart Engines Ltd, all rights reserved.
+// Copyright (C) 2015, Institute for Information Transmission Problems of the Russian Academy of Sciences (Kharkevich Institute), all rights reserved.
+// Copyright (C) 2015, Dmitry Nikolaev, Simon Karpenko, Michail Aliev, Elena Kuznetsova, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+namespace cv { namespace ximgproc {
+
+#if defined(_WIN32) && !defined(int32_t)
+    typedef __int32 int32_t;
+#endif
+
+template<typename T, int D, HoughOp Op>
+struct HoughOperator { };
+#define SPECIALIZE_HOUGHOP(TOp, body)                                         \
+    template<typename T, int D>                                               \
+    struct HoughOperator<T, D, TOp> {                                         \
+        static void operate(T *pDst, T *pSrc0, T* pSrc1, int len) {           \
+            Mat dst (Size(1, len), D, pDst);                                  \
+            Mat src0(Size(1, len), D, pSrc0);                                 \
+            Mat src1(Size(1, len), D, pSrc1);                                 \
+            body;                                                             \
+        }                                                                     \
+    };
+SPECIALIZE_HOUGHOP(FHT_ADD, add(src0, src1, dst));
+SPECIALIZE_HOUGHOP(FHT_MIN, min(src0, src1, dst));
+SPECIALIZE_HOUGHOP(FHT_MAX, max(src0, src1, dst));
+SPECIALIZE_HOUGHOP(FHT_AVE, addWeighted(src0, 0.5, src1, 0.5, 0.0, dst));
+#undef SPECIALIZE_HOUGHOP
+
+//----------------------fht----------------------------------------------------
+
+template <typename T, int D, HoughOp OP>
+void fhtCore(Mat     &img0,
+             Mat     &img1,
+             int32_t  y0,
+             int32_t  h,
+             bool     isPositiveShift,
+             int      level,
+             double   aspl)
+{
+    if (level <= 0)
+        return;
+
+    CV_Assert(h > 0);
+    if (h == 1)
+    {
+        if ((aspl != 0.0) && (level == 1))
+        {
+            int w = img0.cols;
+            uchar* pLine0 = img0.data + img0.step * y0;
+            uchar* pLine1 = img1.data + img1.step * y0;
+            int dLine = cvRound(y0 * aspl);
+            dLine = dLine % w;
+            dLine = dLine * (int)(img1.elemSize());
+            int wLine = img0.cols * (int)(img0.elemSize());
+            memcpy(pLine0, pLine1 + wLine - dLine, dLine);
+            memcpy(pLine0 + dLine, pLine1, wLine - dLine);
+        }
+        else
+        {
+            memcpy(img0.data + img0.step * y0,
+                   img1.data + img1.step * y0,
+                   img0.cols * (int)(img0.elemSize()));
+        }
+        return;
+    }
+    const int32_t k = h >> 1;
+    fhtCore<T, D, OP>(img1, img0, y0, k,
+                      isPositiveShift, level - 1, aspl);
+    fhtCore<T, D, OP>(img1, img0, y0 + k, h - k,
+                      isPositiveShift, level - 1, aspl);
+
+    int au = 2 * k - 2;
+    int ad = 2 * h - 2 * k - 2;
+    int b = h - 1;
+    int d = 2 * h - 2;
+    int w = img0.cols;
+    int wm = (h / w + 1) * w;
+
+    for (int32_t s = 0; s < h; s++)
+    {
+        int su = (s * au + b) / d;
+        int sd = (s * ad + b) / d;
+        int rd = isPositiveShift ? sd - s : s - sd;
+        rd = (rd + wm) % w;
+        uchar *pLine0 = img0.data + img0.step * (y0 + s);
+        uchar *pLineU = img1.data + img1.step * (y0 + su);
+        uchar *pLineD = img1.data + img1.step * (y0 + k + sd);
+        int w0 = img0.channels() * rd;
+        int w1 = img0.channels() * (w - rd);
+
+        if ((aspl != 0.0) && (level == 1))
+        {
+            int dU = cvRound((y0 + su) * aspl);
+            dU = dU % w;
+            dU *= img0.channels();
+            int dD = cvRound((y0 + k + sd) * aspl);
+            dD = dD % w;
+            dD *= img0.channels();
+            int wB = w * img0.channels();
+
+            int dX = dD - dU;
+            if (w0 >= dX)
+            {
+                if (w0 >= dD)
+                {
+                    HoughOperator<T, D, OP>::operate((T *)pLine0 + dU,
+                                               (T *)pLineU,
+                                               (T *)pLineD + (w0 - dX),
+                                               w1 + dX);
+                    HoughOperator<T, D, OP>::operate((T *)pLine0 + (w1 + dD),
+                                               (T *)pLineU + (w1 + dX),
+                                               (T *)pLineD,
+                                               w0 - dD);
+                    HoughOperator<T, D, OP>::operate((T *)pLine0,
+                                               (T *)pLineU + (wB - dU),
+                                               (T *)pLineD + (w0 - dD),
+                                               dU);
+                }
+                else
+                {
+                    HoughOperator<T, D, OP>::operate((T *)pLine0 + dU,
+                                               (T *)pLineU,
+                                               (T *)pLineD + (w0 - dX),
+                                               wB - dU);
+                    HoughOperator<T, D, OP>::operate((T *)pLine0,
+                                               (T *)pLineU + (wB - dU),
+                                               (T *)pLineD + (w0 + wB - dD),
+                                               dD - w0);
+                    HoughOperator<T, D, OP>::operate((T *)pLine0 + (dD - w0),
+                                               (T *)pLineU + (w1 + dX),
+                                               (T *)pLineD,
+                                               w0 - dX);
+                }
+            }
+            else
+            {
+                HoughOperator<T, D, OP>::operate((T *)pLine0 + dU,
+                                           (T *)pLineU,
+                                           (T *)pLineD + (wB - (dX - w0)),
+                                           dX - w0);
+                HoughOperator<T, D, OP>::operate((T *)pLine0 + (dD - w0),
+                                           (T *)pLineU + (dX - w0),
+                                           (T *)pLineD,
+                                           wB - (dX - w0) - dU);
+                HoughOperator<T, D, OP>::operate((T *)pLine0,
+                                           (T *)pLineU + (wB - dU),
+                                           (T *)pLineD + (wB - (dX - w0) - dU),
+                                           dU);
+            }
+        }
+        else
+        {
+            HoughOperator<T, D, OP>::operate((T *)pLine0,
+                                        (T *)pLineU,
+                                        (T *)pLineD + w0,
+                                        w1);
+            HoughOperator<T, D, OP>::operate((T *)pLine0 + w1,
+                                        (T *)pLineU + w1,
+                                        (T *)pLineD,
+                                        w0);
+        }
+    }
+}
+
+template <typename T, int D, HoughOp Op>
+void fhtVoT(Mat    &img0,
+            Mat    &img1,
+            bool    isPositiveShift,
+            double  aspl)
+{
+    int level = 0;
+    for (int thres = 1; img0.rows > thres; thres <<= 1)
+        level++;
+
+    fhtCore<T, D, Op>(img0, img1, 0, img0.rows, isPositiveShift, level, aspl);
+}
+
+template <typename T, int D>
+void fhtVo(Mat    &img0,
+           Mat    &img1,
+           bool    isPositiveShift,
+           int     operation,
+           double  aspl)
+{
+    switch (operation)
+    {
+    case FHT_ADD:
+        fhtVoT<T, D, FHT_ADD>(img0, img1, isPositiveShift, aspl);
+        break;
+    case FHT_AVE:
+        fhtVoT<T, D, FHT_AVE>(img0, img1, isPositiveShift, aspl);
+        break;
+    case FHT_MAX:
+        fhtVoT<T, D, FHT_MAX>(img0, img1, isPositiveShift, aspl);
+        break;
+    case FHT_MIN:
+        fhtVoT<T, D, FHT_MIN>(img0, img1, isPositiveShift, aspl);
+        break;
+    default:
+        CV_Error_(Error::StsNotImplemented, ("Unknown operation %d", operation));
+        break;
+    }
+}
+
+static void fhtVo(Mat    &img0,
+                  Mat    &img1,
+                  bool    isPositiveShift,
+                  int     operation,
+                  double  aspl)
+{
+    int const depth = img0.depth();
+    switch (depth)
+    {
+    case CV_8U:
+        fhtVo<uchar, CV_8UC1>(img0, img1, isPositiveShift, operation, aspl);
+        break;
+    case CV_8S:
+        fhtVo<schar, CV_8SC1>(img0, img1, isPositiveShift, operation, aspl);
+        break;
+    case CV_16U:
+        fhtVo<ushort, CV_16UC1>(img0, img1, isPositiveShift, operation, aspl);
+        break;
+    case CV_16S:
+        fhtVo<short, CV_16SC1>(img0, img1, isPositiveShift, operation, aspl);
+        break;
+    case CV_32S:
+        fhtVo<int, CV_32SC1>(img0, img1, isPositiveShift, operation, aspl);
+        break;
+    case CV_32F:
+        fhtVo<float, CV_32FC1>(img0, img1, isPositiveShift, operation, aspl);
+        break;
+    case CV_64F:
+        fhtVo<double, CV_64FC1>(img0, img1, isPositiveShift, operation, aspl);
+        break;
+    default:
+        CV_Error_(Error::StsNotImplemented, ("Unknown depth %d", depth));
+        break;
+    }
+}
+
+static void FHT(Mat       &dst,
+                const Mat &src,
+                int        operation,
+                bool       isVertical,
+                bool       isClockwise,
+                double     aspl)
+{
+    CV_Assert(dst.cols > 0 && dst.rows > 0);
+    CV_Assert(src.channels() == dst.channels());
+    if (isVertical)
+        CV_Assert(src.cols == dst.cols && src.rows == dst.rows);
+    else
+        CV_Assert(src.cols == dst.rows && src.rows == dst.cols);
+
+    int level = 0;
+    for (int thres = 1; dst.rows > thres; thres <<= 1)
+        level++;
+
+    Mat tmp;
+    src.convertTo(tmp, dst.type());
+    if (!isVertical)
+        transpose(tmp, tmp);
+    tmp.copyTo(dst);
+
+    fhtVo(dst, tmp,
+          isVertical ? isClockwise : !isClockwise,
+          operation, aspl);
+}
+
+static void calculateFHTQuadrant(Mat       &dst,
+                                 const Mat &src,
+                                 int        operation,
+                                 int        quadrant)
+{
+    bool bVert = true;
+    bool bClock = true;
+    double aspl = 0.0;
+    switch (quadrant)
+    {
+    case ARO_315_0:
+        bVert = true;
+        bClock = false;
+        break;
+    case ARO_0_45:
+        bVert = true;
+        bClock = true;
+        break;
+    case ARO_45_90:
+        bVert = false;
+        bClock = false;
+        break;
+    case ARO_90_135:
+        bVert = false;
+        bClock = true;
+        break;
+    case ARO_CTR_VER:
+        bVert = true;
+        bClock = false;
+        aspl = 0.5;
+        break;
+    case ARO_CTR_HOR:
+        bVert = false;
+        bClock = true;
+        aspl = 0.5;
+        break;
+    default:
+        CV_Error_(Error::StsNotImplemented, ("Unknown quadrant %d", quadrant));
+    }
+
+  FHT(dst, src, operation, bVert, bClock, aspl);
+}
+
+static void createDstFhtMat(OutputArray dst,
+                            InputArray  src,
+                            int         depth,
+                            int         angleRange)
+{
+    int const rows = src.size().height;
+    int const cols = src.size().width;
+    int const channels = src.channels();
+
+    int wd = cols + rows;
+    int ht = 0;
+
+    switch (angleRange)
+    {
+    case ARO_315_0:
+    case ARO_0_45:
+    case ARO_CTR_VER:
+        ht = rows;
+        break;
+    case ARO_45_90:
+    case ARO_90_135:
+    case ARO_CTR_HOR:
+        ht = cols;
+        break;
+    case ARO_315_45:
+        ht = 2 * rows - 1;
+        break;
+    case ARO_45_135:
+        ht = 2 * cols - 1;
+        break;
+    case ARO_315_135:
+        ht = 2 * (cols + rows) - 3;
+        break;
+    default:
+        CV_Error_(Error::StsNotImplemented, ("Unknown angleRange %d", angleRange));
+    }
+
+    dst.create(ht, wd, CV_MAKETYPE(depth, channels));
+}
+
+static void createFHTSrc(Mat       &srcFull,
+                         const Mat &src,
+                         int        angleRange)
+{
+    bool verticalTiling = false;
+    switch (angleRange)
+    {
+    case ARO_315_0:
+    case ARO_0_45:
+    case ARO_CTR_VER:
+    case ARO_315_45:
+        verticalTiling = false;
+        break;
+    case ARO_45_90:
+    case ARO_90_135:
+    case ARO_CTR_HOR:
+    case ARO_45_135:
+        verticalTiling = true;
+        break;
+    default:
+        CV_Error_(Error::StsNotImplemented, ("Unknown angleRange %d", angleRange));
+    }
+
+    int wd = verticalTiling ? src.cols : src.cols + src.rows;
+    int ht = verticalTiling ? src.cols + src.rows : src.rows;
+    srcFull = Mat(ht, wd, src.type());
+
+    Mat imgReg;
+    if (verticalTiling)
+        imgReg = Mat(srcFull, Rect(0, src.rows, src.cols, src.cols));
+    else
+        imgReg = Mat(srcFull, Rect(src.cols, 0, src.rows, src.rows));
+    imgReg = Mat::zeros(imgReg.size(), imgReg.type());
+
+    imgReg = Mat(srcFull, Rect(0, 0, src.cols, src.rows));
+    src.copyTo(imgReg);
+}
+
+static void setFHTDstRegion(Mat       &dstRegion,
+                            const Mat &dst,
+                            const Mat &src,
+                            int        quadrant,
+                            int        angleRange)
+{
+    int base = -1;
+    switch (angleRange)
+    {
+    case ARO_315_0:
+    case ARO_315_45:
+    case ARO_315_135:
+        base = 0;
+        break;
+    case ARO_0_45:
+        base = 1;
+        break;
+    case ARO_45_90:
+    case ARO_45_135:
+        base = 2;
+        break;
+    case ARO_90_135:
+        base = 3;
+        break;
+    default:
+        CV_Error_(Error::StsNotImplemented, ("Unknown angleRange %d", angleRange));
+    }
+
+    int quad = -1;
+    switch (quadrant)
+    {
+    case ARO_315_0:
+        quad = 0;
+        break;
+    case ARO_0_45:
+        quad = 1;
+        break;
+    case ARO_45_90:
+        quad = 2;
+        break;
+    case ARO_90_135:
+        quad = 3;
+        break;
+    default:
+        CV_Error_(Error::StsNotImplemented, ("Unknown quadrant %d", quadrant));
+    }
+
+    if (quad < base)
+        quad += 4;
+
+    int shift = 0;
+    for (int i = base; i < quad; i++)
+        shift += (i & 2) ? src.cols - 1 : src.rows - 1;
+    const int ht = (quad & 2) ? src.cols : src.rows;
+
+    dstRegion = Mat(dst, Rect(0, shift, src.rows + src.cols, ht));
+}
+
+
+
+static void rotateLineRightCyclic(uchar *pLine,
+                                  uchar *pBuf,
+                                  int    len,
+                                  int    shift)
+{
+  shift = shift % len;
+  shift = (shift + len) % len;
+  memcpy(pBuf, pLine, len);
+  memcpy(pLine + shift, pBuf, len - shift);
+  if (shift > 0)
+    memcpy(pLine, pBuf + len - shift, shift);
+}
+
+static void skewQuadrant(Mat         &quad,
+                         const Mat   &src,
+                         uchar       *pBuf,
+                         int          quadrant)
+{
+    CV_Assert(pBuf);
+
+    const int wd = src.cols;
+    const int ht = src.rows;
+
+    double start = 0.;
+    double step = .5;
+    switch (quadrant)
+    {
+    case ARO_315_0:
+    case ARO_CTR_VER:
+        step = -.5;
+        start = ht - 0.5;
+        break;
+    case ARO_0_45:
+        step = -.5;
+        start = ht * .5;
+        break;
+    case ARO_45_90:
+        break;
+    case ARO_90_135:
+    case ARO_CTR_HOR:
+        start = wd * .5 - 0.5;
+        break;
+    default:
+        CV_Error_(Error::StsNotImplemented, ("Unknown quadrant %d", quadrant));
+    }
+
+    const int pixlen = static_cast<int>(quad.elemSize());
+    const int len = quad.cols * pixlen;
+    for (int y = 0; y < quad.rows; y++)
+    {
+        uchar *pLine = quad.ptr(y);
+        int shift = static_cast<int>(start + step * y) * pixlen;
+        rotateLineRightCyclic(pLine, pBuf, len, shift);
+    }
+}
+
+void FastHoughTransform(InputArray  src,
+                        OutputArray dst,
+                        int         dstMatDepth,
+                        int         angleRange,
+                        int         operation,
+                        int         makeSkew)
+{
+    Mat srcMat = src.getMat();
+    if (!srcMat.isContinuous())
+        srcMat = srcMat.clone();
+    CV_Assert(srcMat.cols > 0 && srcMat.rows > 0);
+
+    createDstFhtMat(dst, src, dstMatDepth, angleRange);
+    Mat dstMat = dst.getMat();
+
+    Mat imgRegDst;
+    const int len = dstMat.cols * static_cast<int>(dstMat.elemSize());
+    CV_Assert(len > 0);
+    std::vector<uchar> buf_(len);
+    uchar *buf(&buf_[0]);
+
+    if (angleRange == ARO_315_135)
+    {
+        {
+            Mat imgSrc;
+            createFHTSrc(imgSrc, srcMat, ARO_315_45);
+
+            setFHTDstRegion(imgRegDst, dstMat, srcMat, ARO_315_0, angleRange);
+            calculateFHTQuadrant(imgRegDst, imgSrc, operation, ARO_315_0);
+            flip(imgRegDst, imgRegDst, 0);
+            if (HDO_DESKEW == makeSkew)
+                skewQuadrant(imgRegDst, imgSrc, buf, ARO_315_0);
+
+            setFHTDstRegion(imgRegDst, dstMat, srcMat, ARO_0_45, angleRange);
+            calculateFHTQuadrant(imgRegDst, imgSrc, operation, ARO_0_45);
+            if (HDO_DESKEW == makeSkew)
+                skewQuadrant(imgRegDst, imgSrc, buf, ARO_0_45);
+        }
+        {
+            Mat imgSrc;
+            createFHTSrc(imgSrc, srcMat, ARO_45_135);
+
+            setFHTDstRegion(imgRegDst, dstMat, srcMat, ARO_45_90, angleRange);
+            calculateFHTQuadrant(imgRegDst, imgSrc, operation, ARO_45_90);
+            flip(imgRegDst, imgRegDst, 0);
+            if (HDO_DESKEW == makeSkew)
+                skewQuadrant(imgRegDst, imgSrc, buf, ARO_45_90);
+
+            setFHTDstRegion(imgRegDst, dstMat, srcMat, ARO_90_135, angleRange);
+            calculateFHTQuadrant(imgRegDst, imgSrc, operation, ARO_90_135);
+            if (HDO_DESKEW == makeSkew)
+                skewQuadrant(imgRegDst, imgSrc, buf, ARO_90_135);
+        }
+        return;
+    }
+
+    Mat imgSrc;
+    createFHTSrc(imgSrc, srcMat, angleRange);
+
+    switch (angleRange)
+    {
+    case ARO_315_0:
+        calculateFHTQuadrant(dstMat, imgSrc, operation, angleRange);
+        flip(dstMat, dstMat, 0);
+        if (HDO_DESKEW == makeSkew)
+            skewQuadrant(dstMat, imgSrc, buf, angleRange);
+        return;
+    case ARO_0_45:
+        calculateFHTQuadrant(dstMat, imgSrc, operation, angleRange);
+        if (HDO_DESKEW == makeSkew)
+            skewQuadrant(dstMat, imgSrc, buf, angleRange);
+        return;
+    case ARO_45_90:
+        calculateFHTQuadrant(dstMat, imgSrc, operation, angleRange);
+        flip(dstMat, dstMat, 0);
+        if (HDO_DESKEW == makeSkew)
+            skewQuadrant(dstMat, imgSrc, buf, angleRange);
+        return;
+    case ARO_90_135:
+        calculateFHTQuadrant(dstMat, imgSrc, operation, angleRange);
+        if (HDO_DESKEW == makeSkew)
+            skewQuadrant(dstMat, imgSrc, buf, angleRange);
+        return;
+    case ARO_315_45:
+        setFHTDstRegion(imgRegDst, dstMat, srcMat, ARO_315_0, angleRange);
+        calculateFHTQuadrant(imgRegDst, imgSrc, operation, ARO_315_0);
+        flip(imgRegDst, imgRegDst, 0);
+        if (HDO_DESKEW == makeSkew)
+            skewQuadrant(imgRegDst, imgSrc, buf, ARO_315_0);
+
+        setFHTDstRegion(imgRegDst, dstMat, srcMat, ARO_0_45, angleRange);
+        calculateFHTQuadrant(imgRegDst, imgSrc, operation, ARO_0_45);
+        if (HDO_DESKEW == makeSkew)
+            skewQuadrant(imgRegDst, imgSrc, buf, ARO_0_45);
+        return;
+    case ARO_45_135:
+        setFHTDstRegion(imgRegDst, dstMat, srcMat, ARO_45_90, angleRange);
+        calculateFHTQuadrant(imgRegDst, imgSrc, operation, ARO_45_90);
+        flip(imgRegDst, imgRegDst, 0);
+        if (HDO_DESKEW == makeSkew)
+            skewQuadrant(imgRegDst, imgSrc, buf, ARO_45_90);
+
+        setFHTDstRegion(imgRegDst, dstMat, srcMat, ARO_90_135, angleRange);
+        calculateFHTQuadrant(imgRegDst, imgSrc, operation, ARO_90_135);
+        if (HDO_DESKEW == makeSkew)
+            skewQuadrant(imgRegDst, imgSrc, buf, ARO_90_135);
+        return;
+    case ARO_CTR_VER:
+        calculateFHTQuadrant(dstMat, imgSrc, operation, angleRange);
+        flip(dstMat, dstMat, 0);
+        if (HDO_DESKEW == makeSkew)
+            skewQuadrant(dstMat, imgSrc, buf, angleRange);
+        return;
+    case ARO_CTR_HOR:
+        calculateFHTQuadrant(dstMat, imgSrc, operation, angleRange);
+        if (HDO_DESKEW == makeSkew)
+            skewQuadrant(dstMat, imgSrc, buf, angleRange);
+        return;
+    default:
+        CV_Error_(Error::StsNotImplemented, ("Unknown angleRange %d", angleRange));
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+//----------------------fht point2line-----------------------------------------
+struct LineSegment {
+    Point u, v;
+    LineSegment(const Point _u, const Point _v) : u(_u), v(_v) { }
+};
+
+static void getRawPoint(Point       &rawHoughPoint,
+                        int         &quadRawPoint,
+                        const Point &givenHoughPoint,
+                        const Mat   &srcImgInfo,
+                        int          angleRange,
+                        int          makeSkew)
+{
+    int base = -1;
+    switch (angleRange)
+    {
+    case ARO_315_0:
+    case ARO_315_45:
+    case ARO_CTR_VER:
+    case ARO_315_135:
+        base = 0;
+        break;
+    case ARO_0_45:
+        base = 1;
+        break;
+    case ARO_45_90:
+    case ARO_45_135:
+        base = 2;
+        break;
+    case ARO_90_135:
+    case ARO_CTR_HOR:
+        base = 3;
+        break;
+    default:
+        CV_Error_(Error::StsNotImplemented, ("Unknown angleRange %d", angleRange));
+    }
+
+    int const cols = srcImgInfo.cols;
+    int const rows = srcImgInfo.rows;
+
+    rawHoughPoint.y = givenHoughPoint.y;
+    int quad = 0, qsize = 0;
+    for (quad = base; quad < 4; quad++)
+    {
+        qsize = (quad & 2) ? cols - 1 : rows - 1;
+        if (rawHoughPoint.y <= qsize)
+            break;
+        rawHoughPoint.y -= qsize;
+    }
+    if (quad >= 4)
+        CV_Error(Error::StsInternal, "");
+
+    quadRawPoint = quad;
+
+    double skewShift = 0.0;
+    if (makeSkew == HDO_DESKEW)
+    {
+        switch (quad)
+        {
+        case 0:
+            skewShift = rows - (rawHoughPoint.y + 1) * 0.5;
+            break;
+        case 1:
+            skewShift = (rows - rawHoughPoint.y) * 0.5;
+            break;
+        case 2:
+            skewShift = rawHoughPoint.y * 0.5;
+            break;
+        default:
+            skewShift = 0.5 * (cols + rawHoughPoint.y - 1);
+            break;
+        }
+    }
+
+    rawHoughPoint.x = givenHoughPoint.x - static_cast<int>(skewShift);
+    if (rawHoughPoint.x < 0)
+        rawHoughPoint.x = rows + cols + rawHoughPoint.x;
+}
+
+static bool checkRawPoint(const Point &rawHoughPoint,
+                          int          quadRawPoint,
+                          const Mat   &srcImgInfo)
+{
+    int const cols = srcImgInfo.cols;
+    int const rows = srcImgInfo.rows;
+
+    switch (quadRawPoint)
+    {
+    case 0:
+        //down left triangle on FHT
+        if (rawHoughPoint.x - cols <= rawHoughPoint.y &&
+            rawHoughPoint.x - cols >= 0)
+        return false;
+        break;
+    case 1:
+        //up right triangle on FHT
+        if (rawHoughPoint.x - cols >= rawHoughPoint.y)
+            return false;
+        break;
+    case 2:
+        //up right triangle on up-down FHT image
+        if (rawHoughPoint.x - rows >= cols - 1 - rawHoughPoint.y)
+        return false;
+        break;
+    default:
+        //down left triangle on up-down FHT image
+        if (rawHoughPoint.x - rows <= cols - 1 - rawHoughPoint.y &&
+            rawHoughPoint.x - rows >= 0)
+        return false;
+        break;
+    }
+    return true;
+}
+
+static void shiftLineSegment(LineSegment &segment,
+                             const Point &shift)
+{
+    segment.u.x += shift.x;
+    segment.v.x += shift.x;
+    segment.u.y += shift.y;
+    segment.v.y += shift.y;
+}
+
+static void lineFactors(double      &a,
+                        double      &b,
+                        double      &c,
+                        const Point &point1,
+                        const Point &point2)
+{
+    CV_Assert(point1.x != point2.x || point1.y != point2.y);
+
+    Point vectorSegment(point2.x - point1.x, point2.y - point1.y);
+    a = - vectorSegment.y;
+    b = vectorSegment.x;
+    c = - (a * point1.x + b * point1.y);
+}
+
+static void crossSegments(Point             &point,
+                          const LineSegment &line1,
+                          const LineSegment &line2)
+{
+    double a1 = 0.0, b1 = 0.0, c1 = 0.0;
+    double a2 = 0.0, b2 = 0.0, c2 = 0.0;
+    lineFactors(a1, b1, c1, line1.u, line1.v);
+    lineFactors(a2, b2, c2, line2.u, line2.v);
+
+    double uLine1onLine2 = a2 * line1.u.x + b2 * line1.u.y + c2;
+    double vLine1onLine2 = a2 * line1.v.x + b2 * line1.v.y + c2;
+
+    double ULine2onLine1 = a1 * line2.u.x + b1 * line2.u.y + c1;
+    double VLine2onLine1 = a1 * line2.v.x + b1 * line2.v.y + c1;
+
+    CV_Assert(ULine2onLine1 != 0 || VLine2onLine1 != 0 ||
+              uLine1onLine2 != 0 || vLine1onLine2 != 0);
+    CV_Assert(ULine2onLine1 * VLine2onLine1 <= 0 &&
+              uLine1onLine2 * vLine1onLine2 <= 0);
+
+    static const double double_eps = 1e-10;
+    CV_Assert(std::abs(uLine1onLine2 - vLine1onLine2) >= double_eps);
+
+    double mul = uLine1onLine2 / (uLine1onLine2 - vLine1onLine2);
+    point.x =  cvRound(line1.u.x + mul * (line1.v.x - line1.u.x));
+    point.y =  cvRound(line1.u.y + mul * (line1.v.y - line1.u.y));
+}
+
+Vec4i HoughPoint2Line(const Point &houghPoint,
+                      InputArray  srcImgInfo,
+                      int         angleRange,
+                      int         makeSkew,
+                      int         rules)
+{
+    Mat srcImgInfoMat = srcImgInfo.getMat();
+
+    int const cols = srcImgInfoMat.cols;
+    int const rows = srcImgInfoMat.rows;
+
+    CV_Assert(houghPoint.y >= 0);
+    CV_Assert(houghPoint.x < cols + rows);
+
+    int quad = 0;
+    Point rawPoint(0, 0);
+    getRawPoint(rawPoint, quad, houghPoint, srcImgInfoMat, angleRange, makeSkew);
+    bool ret = checkRawPoint(rawPoint, quad, srcImgInfoMat);
+    if (!(rules & RO_IGNORE_BORDERS))
+    {
+        CV_Assert(ret);
+    }
+
+    LineSegment dstLine(Point(0, 0), Point(0, 0));
+    switch (quad)
+    {
+    case 0:
+        dstLine.v.y = rows - 1;
+        dstLine.u.x = rawPoint.x;
+        dstLine.v.x = dstLine.u.x + rows - rawPoint.y - 1;
+        break;
+    case 1:
+        dstLine.v.y = rows - 1;
+        dstLine.u.x = rawPoint.x;
+        dstLine.v.x = dstLine.u.x - rawPoint.y;
+        break;
+    case 2:
+        dstLine.v.x = cols - 1;
+        dstLine.u.y = rawPoint.x;
+        dstLine.v.y = dstLine.u.y - cols + rawPoint.y + 1;
+        break;
+    default:
+        dstLine.v.x = cols - 1;
+        dstLine.u.y = rawPoint.x;
+        dstLine.v.y = dstLine.u.y + rawPoint.y;
+        break;
+    }
+
+    if (angleRange == ARO_CTR_VER)
+    {
+        int shift = cvRound(0.5 * dstLine.u.y);
+        shift = shift % (cols + rows);
+        dstLine.u.x = dstLine.u.x - shift;
+
+        shift = cvRound(0.5 * dstLine.v.y);
+        shift = shift % (cols + rows);
+        dstLine.v.x = dstLine.v.x - shift;
+    }
+    else if (angleRange == ARO_CTR_HOR)
+    {
+        int shift = cvRound(0.5 * dstLine.u.x);
+        shift = shift % (cols + rows);
+        dstLine.u.y = dstLine.u.y - shift;
+
+        shift = cvRound(0.5 * dstLine.v.x);
+        shift = shift % (cols + rows);
+        dstLine.v.y = dstLine.v.y - shift;
+    }
+
+    if (!ret)
+    {
+        return Vec4i(dstLine.v.x, dstLine.v.y, dstLine.u.x, dstLine.u.y);
+    }
+
+    if (rules & RO_IGNORE_BORDERS)
+    {
+        switch (quad)
+        {
+        case 0:
+            if (dstLine.v.x > cols + rows - 1)
+            {
+                Point shiftVector(-(cols + rows), 0);
+                shiftLineSegment(dstLine, shiftVector);
+            }
+            break;
+        case 3:
+            if (dstLine.v.y > rows + cols - 1)
+            {
+                Point shiftVector(0, -(cols + rows));
+                shiftLineSegment(dstLine, shiftVector);
+            }
+            break;
+        default:
+            break;
+        }
+
+        return Vec4i(dstLine.v.x, dstLine.v.y, dstLine.u.x, dstLine.u.y);
+    }
+
+    Point minIntersectPoint(0, 0);
+
+    Point minLeftUpSrcPoint(0, 0);
+    Point minRightUpSrcPoint(cols - 1, 0);
+    Point minLeftDownSrcPoint(0, rows - 1);
+    Point minRightDownSrcPoint(cols - 1, rows - 1);
+
+    switch (quad)
+    {
+    case 0:
+        if (dstLine.v.x > cols + rows - 1)
+        {
+            LineSegment minRightToDstLine(Point(cols + rows, 0),
+                                          Point(cols + rows, rows - 1) );
+            crossSegments(minIntersectPoint, dstLine, minRightToDstLine);
+            dstLine.u.y = minIntersectPoint.y;
+            dstLine.u.x = 0;
+            dstLine.v.x = dstLine.v.x - (cols + rows);
+        }
+        if (dstLine.v.x > cols  - 1)
+        {
+            LineSegment minRightSrcLine(minRightUpSrcPoint,
+                                        minRightDownSrcPoint);
+            crossSegments(minIntersectPoint, dstLine, minRightSrcLine);
+            dstLine.v.y = minIntersectPoint.y;
+            dstLine.v.x = cols - 1;
+        }
+        break;
+    case 1:
+        if (dstLine.v.x < 0)
+        {
+            LineSegment minLeftSrcLine(minLeftUpSrcPoint, minLeftDownSrcPoint);
+            crossSegments(minIntersectPoint, dstLine, minLeftSrcLine);
+            dstLine.v.y = minIntersectPoint.y;
+            dstLine.v.x = 0;
+        }
+        if (dstLine.u.x > cols - 1)
+        {
+            LineSegment minRightSrcLine(minRightUpSrcPoint,
+                                        minRightDownSrcPoint);
+            crossSegments(minIntersectPoint, dstLine, minRightSrcLine);
+            dstLine.u.y = minIntersectPoint.y;
+            dstLine.u.x = cols - 1;
+        }
+        break;
+    case 2:
+        if (dstLine.v.y < 0)
+        {
+            LineSegment minTopSrcLine(minLeftUpSrcPoint, minRightUpSrcPoint);
+            crossSegments(minIntersectPoint, dstLine, minTopSrcLine);
+            dstLine.v.x = minIntersectPoint.x;
+            dstLine.v.y = 0;
+        }
+        if (dstLine.u.y > rows - 1)
+        {
+            LineSegment minBottomSrcLine(minLeftDownSrcPoint,
+                                         minRightDownSrcPoint);
+            crossSegments(minIntersectPoint, dstLine, minBottomSrcLine );
+            dstLine.u.x = minIntersectPoint.x;
+            dstLine.u.y = rows - 1;
+        }
+        break;
+    default:
+        if (dstLine.v.y > rows + cols - 1)
+        {
+            LineSegment minDownToDstLine(Point(0, rows + cols),
+                                         Point(cols - 1, rows + cols));
+            crossSegments(minIntersectPoint, dstLine, minDownToDstLine);
+            dstLine.u.x = minIntersectPoint.x;
+            dstLine.u.y = 0;
+            dstLine.v.y = dstLine.v.y - (rows + cols);
+        }
+        if (dstLine.v.y > rows - 1)
+        {
+            LineSegment minBottomSrcLine(minLeftDownSrcPoint,
+                                         minRightDownSrcPoint);
+            crossSegments(minIntersectPoint, dstLine, minBottomSrcLine);
+            dstLine.v.x = minIntersectPoint.x;
+            dstLine.v.y = rows - 1;
+        }
+        break;
+    }
+
+    return Vec4i(dstLine.v.x, dstLine.v.y, dstLine.u.x, dstLine.u.y);
+}
+
+//-----------------------------------------------------------------------------
+
+
+} } // namespace cv::ximgproc
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fast_line_detector.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fast_line_detector.cpp
new file mode 100644
index 00000000..95a46a84
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fast_line_detector.cpp
@@ -0,0 +1,681 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include <vector>
+#include <iostream>
+
+struct SEGMENT
+{
+    float x1, y1, x2, y2, angle;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cv{
+namespace ximgproc{
+
+class FastLineDetectorImpl : public FastLineDetector
+{
+    public:
+
+        FastLineDetectorImpl(int _length_threshold = 10, float _distance_threshold = 1.414213562f,
+                double _canny_th1 = 50.0, double _canny_th2 = 50.0, int _canny_aperture_size = 3,
+                bool _do_merge = false);
+
+        void detect(InputArray image, OutputArray lines) CV_OVERRIDE;
+
+        void drawSegments(InputOutputArray image, InputArray lines, bool draw_arrow = false, Scalar linecolor = Scalar(0, 0, 255), int linethickness = 1) CV_OVERRIDE;
+
+    private:
+        int imagewidth, imageheight, threshold_length;
+        float threshold_dist;
+        double canny_th1, canny_th2;
+        int canny_aperture_size;
+        bool do_merge;
+
+        FastLineDetectorImpl& operator= (const FastLineDetectorImpl&); // to quiet MSVC
+        template<class T>
+            void incidentPoint(const Mat& l, T& pt);
+
+        void mergeLines(const SEGMENT& seg1, const SEGMENT& seg2, SEGMENT& seg_merged);
+
+        bool mergeSegments(const SEGMENT& seg1, const SEGMENT& seg2, SEGMENT& seg_merged);
+
+        bool getPointChain(const Mat& img, Point pt, Point& chained_pt, float& direction, int step);
+
+        double distPointLine(const Mat& p, Mat& l);
+
+        void extractSegments(const std::vector<Point2i>& points, std::vector<SEGMENT>& segments);
+
+        void lineDetection(const Mat& src, std::vector<SEGMENT>& segments_all);
+
+        void pointInboardTest(const Size srcSize, Point2i& pt);
+
+        inline void getAngle(SEGMENT& seg);
+
+        void additionalOperationsOnSegment(const Mat& src, SEGMENT& seg);
+
+        void drawSegment(InputOutputArray image, const SEGMENT& seg, Scalar bgr = Scalar(0,255,0), int thickness = 1, bool directed = true);
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+CV_EXPORTS Ptr<FastLineDetector> createFastLineDetector(
+        int length_threshold, float distance_threshold,
+        double canny_th1, double canny_th2, int canny_aperture_size, bool do_merge)
+{
+    return makePtr<FastLineDetectorImpl>(
+            length_threshold, distance_threshold,
+            canny_th1, canny_th2, canny_aperture_size, do_merge);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+FastLineDetectorImpl::FastLineDetectorImpl(int _length_threshold, float _distance_threshold,
+        double _canny_th1, double _canny_th2, int _canny_aperture_size, bool _do_merge)
+    :threshold_length(_length_threshold), threshold_dist(_distance_threshold),
+    canny_th1(_canny_th1), canny_th2(_canny_th2), canny_aperture_size(_canny_aperture_size), do_merge(_do_merge)
+{
+    CV_Assert(_length_threshold > 0 && _distance_threshold > 0 &&
+            _canny_th1 > 0 && _canny_th2 > 0 && _canny_aperture_size >= 0);
+}
+
+void FastLineDetectorImpl::detect(InputArray _image, OutputArray _lines)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat image = _image.getMat();
+    CV_Assert(!image.empty() && image.type() == CV_8UC1);
+
+    std::vector<Vec4f> lines;
+    std::vector<SEGMENT> segments;
+    lineDetection(image, segments);
+    for(size_t i = 0; i < segments.size(); ++i)
+    {
+        const SEGMENT seg = segments[i];
+        Vec4f line(seg.x1, seg.y1, seg.x2, seg.y2);
+        lines.push_back(line);
+    }
+    Mat(lines).copyTo(_lines);
+}
+
+void FastLineDetectorImpl::drawSegments(InputOutputArray image, InputArray lines, bool draw_arrow, Scalar linecolor, int linethickness)
+{
+    CV_INSTRUMENT_REGION();
+
+    int cn = image.channels();
+    CV_Assert(!image.empty() && ( cn == 1 || cn == 3 || cn == 4));
+
+    if (cn == 1)
+    {
+        cvtColor(image, image, COLOR_GRAY2BGR);
+    }
+    else
+    {
+        cvtColor(image, image, COLOR_BGRA2GRAY);
+        cvtColor(image, image, cn == 3 ? COLOR_GRAY2BGR : COLOR_GRAY2BGRA);
+    }
+
+    double gap = 10.0;
+    double arrow_angle = 30.0;
+
+    Mat _lines;
+    _lines = lines.getMat();
+    int N = _lines.checkVector(4);
+    // Draw segments
+    for(int i = 0; i < N; ++i)
+    {
+        const Vec4f& v = _lines.at<Vec4f>(i);
+        Point2f b(v[0], v[1]);
+        Point2f e(v[2], v[3]);
+        line(image, b, e, linecolor, linethickness);
+        if(draw_arrow)
+        {
+            SEGMENT seg;
+            seg.x1 = b.x;
+            seg.y1 = b.y;
+            seg.x2 = e.x;
+            seg.y2 = e.y;
+            getAngle(seg);
+            double ang = (double)seg.angle;
+            Point2i p1;
+            p1.x = cvRound(seg.x2 - gap*cos(arrow_angle * CV_PI / 180.0 + ang));
+            p1.y = cvRound(seg.y2 - gap*sin(arrow_angle * CV_PI / 180.0 + ang));
+            pointInboardTest(image.size(), p1);
+            line(image, Point(cvRound(seg.x2), cvRound(seg.y2)), p1, linecolor, linethickness);
+        }
+    }
+}
+
+void FastLineDetectorImpl::mergeLines(const SEGMENT& seg1, const SEGMENT& seg2, SEGMENT& seg_merged)
+{
+    double xg = 0.0, yg = 0.0;
+    double delta1x = 0.0, delta1y = 0.0, delta2x = 0.0, delta2y = 0.0;
+    float ax = 0, bx = 0, cx = 0, dx = 0;
+    float ay = 0, by = 0, cy = 0, dy = 0;
+    double li = 0.0, lj = 0.0;
+    double thi = 0.0, thj = 0.0, thr = 0.0;
+    double axg = 0.0, bxg = 0.0, cxg = 0.0, dxg = 0.0, delta1xg = 0.0, delta2xg = 0.0;
+
+    ax = seg1.x1;
+    ay = seg1.y1;
+
+    bx = seg1.x2;
+    by = seg1.y2;
+    cx = seg2.x1;
+    cy = seg2.y1;
+
+    dx = seg2.x2;
+    dy = seg2.y2;
+
+    float dlix = (bx - ax);
+    float dliy = (by - ay);
+    float dljx = (dx - cx);
+    float dljy = (dy - cy);
+
+    li = sqrt((double) (dlix * dlix) + (double) (dliy * dliy));
+    lj = sqrt((double) (dljx * dljx) + (double) (dljy * dljy));
+
+    xg = (li * (double) (ax + bx) + lj * (double) (cx + dx))
+        / (double) (2.0 * (li + lj));
+    yg = (li * (double) (ay + by) + lj * (double) (cy + dy))
+        / (double) (2.0 * (li + lj));
+
+    if(dlix == 0.0f) thi = CV_PI / 2.0;
+    else thi = atan(dliy / dlix);
+
+    if(dljx == 0.0f) thj = CV_PI / 2.0;
+    else thj = atan(dljy / dljx);
+
+    if (fabs(thi - thj) <= CV_PI / 2.0)
+    {
+        thr = (li * thi + lj * thj) / (li + lj);
+    }
+    else
+    {
+        double tmp = thj - CV_PI * (thj / fabs(thj));
+        thr = li * thi + lj * tmp;
+        thr /= (li + lj);
+    }
+
+    axg = ((double) ay - yg) * sin(thr) + ((double) ax - xg) * cos(thr);
+    bxg = ((double) by - yg) * sin(thr) + ((double) bx - xg) * cos(thr);
+    cxg = ((double) cy - yg) * sin(thr) + ((double) cx - xg) * cos(thr);
+    dxg = ((double) dy - yg) * sin(thr) + ((double) dx - xg) * cos(thr);
+
+    delta1xg = min(axg,min(bxg,min(cxg,dxg)));
+    delta2xg = max(axg,max(bxg,max(cxg,dxg)));
+
+    delta1x = delta1xg * cos(thr) + xg;
+    delta1y = delta1xg * sin(thr) + yg;
+    delta2x = delta2xg * cos(thr) + xg;
+    delta2y = delta2xg * sin(thr) + yg;
+
+    seg_merged.x1 = (float)delta1x;
+    seg_merged.y1 = (float)delta1y;
+    seg_merged.x2 = (float)delta2x;
+    seg_merged.y2 = (float)delta2y;
+}
+
+double FastLineDetectorImpl::distPointLine(const Mat& p, Mat& l)
+{
+    double x = l.at<double>(0,0);
+    double y = l.at<double>(1,0);
+    double w = sqrt(x*x+y*y);
+
+    l.at<double>(0,0) = x / w;
+    l.at<double>(1,0) = y / w;
+    l.at<double>(2,0) = l.at<double>(2,0) / w;
+
+    return l.dot(p);
+}
+
+bool FastLineDetectorImpl::mergeSegments(const SEGMENT& seg1, const SEGMENT& seg2, SEGMENT& seg_merged)
+{
+    double o[] = { 0.0, 0.0, 1.0 };
+    double a[] = { 0.0, 0.0, 1.0 };
+    double b[] = { 0.0, 0.0, 1.0 };
+    double c[3];
+
+    o[0] = ( seg2.x1 + seg2.x2 ) / 2.0;
+    o[1] = ( seg2.y1 + seg2.y2 ) / 2.0;
+
+    a[0] = seg1.x1;
+    a[1] = seg1.y1;
+    b[0] = seg1.x2;
+    b[1] = seg1.y2;
+
+    Mat ori = Mat(3, 1, CV_64FC1, o).clone();
+    Mat p1 = Mat(3, 1, CV_64FC1, a).clone();
+    Mat p2 = Mat(3, 1, CV_64FC1, b).clone();
+    Mat l1 = Mat(3, 1, CV_64FC1, c).clone();
+
+    l1 = p1.cross(p2);
+
+    Point2f seg1mid, seg2mid;
+    seg1mid.x = (seg1.x1 + seg1.x2) /2.0f;
+    seg1mid.y = (seg1.y1 + seg1.y2) /2.0f;
+    seg2mid.x = (seg2.x1 + seg2.x2) /2.0f;
+    seg2mid.y = (seg2.y1 + seg2.y2) /2.0f;
+
+    float seg1len = sqrt((seg1.x1 - seg1.x2)*(seg1.x1 - seg1.x2)+(seg1.y1 - seg1.y2)*(seg1.y1 - seg1.y2));
+    float seg2len = sqrt((seg2.x1 - seg2.x2)*(seg2.x1 - seg2.x2)+(seg2.y1 - seg2.y2)*(seg2.y1 - seg2.y2));
+    float middist = sqrt((seg1mid.x - seg2mid.x)*(seg1mid.x - seg2mid.x) + (seg1mid.y - seg2mid.y)*(seg1mid.y - seg2mid.y));
+    float angdiff = fabs(seg1.angle - seg2.angle);
+
+    float dist = (float)distPointLine(ori, l1);
+
+    if ( fabs( dist ) <= threshold_dist * 2.0f && middist <= seg1len / 2.0f + seg2len / 2.0f + 20.0f
+            && angdiff <= CV_PI / 180.0f * 5.0f)
+    {
+        mergeLines(seg1, seg2, seg_merged);
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+template<class T>
+    void FastLineDetectorImpl::incidentPoint(const Mat& l, T& pt)
+    {
+        double a[] = { (double)pt.x, (double)pt.y, 1.0 };
+        double b[] = { l.at<double>(0,0), l.at<double>(1,0), 0.0 };
+        double c[3];
+
+        Mat xk = Mat(3, 1, CV_64FC1, a).clone();
+        Mat lh = Mat(3, 1, CV_64FC1, b).clone();
+        Mat lk = Mat(3, 1, CV_64FC1, c).clone();
+
+        lk = xk.cross(lh);
+        xk = lk.cross(l);
+
+        xk.convertTo(xk, -1, 1.0 / xk.at<double>(2,0));
+
+        Point2f pt_tmp;
+        pt_tmp.x = (float)xk.at<double>(0,0) < 0.0f ? 0.0f : (float)xk.at<double>(0,0)
+            >= (imagewidth - 1.0f) ? (imagewidth - 1.0f) : (float)xk.at<double>(0,0);
+        pt_tmp.y = (float)xk.at<double>(1,0) < 0.0f ? 0.0f : (float)xk.at<double>(1,0)
+            >= (imageheight - 1.0f) ? (imageheight - 1.0f) : (float)xk.at<double>(1,0);
+        pt = T(pt_tmp);
+    }
+
+void FastLineDetectorImpl::extractSegments(const std::vector<Point2i>& points, std::vector<SEGMENT>& segments)
+{
+    bool is_line;
+
+    int i, j;
+    SEGMENT seg;
+    Point2i ps, pe, pt;
+
+    std::vector<Point2i> l_points;
+
+    int total = (int)points.size();
+
+    for ( i = 0; i + threshold_length < total; i++ )
+    {
+        ps = points[i];
+        pe = points[i + threshold_length];
+
+        double a[] = { (double)ps.x, (double)ps.y, 1 };
+        double b[] = { (double)pe.x, (double)pe.y, 1 };
+        double c[3], d[3];
+
+        Mat p1 = Mat(3, 1, CV_64FC1, a).clone();
+        Mat p2 = Mat(3, 1, CV_64FC1, b).clone();
+        Mat p = Mat(3, 1, CV_64FC1, c).clone();
+        Mat l = Mat(3, 1, CV_64FC1, d).clone();
+        l = p1.cross(p2);
+
+        is_line = true;
+
+        l_points.clear();
+        l_points.push_back(ps);
+
+        for ( j = 1; j < threshold_length; j++ )
+        {
+            pt.x = points[i+j].x;
+            pt.y = points[i+j].y;
+
+            p.at<double>(0,0) = (double)pt.x;
+            p.at<double>(1,0) = (double)pt.y;
+            p.at<double>(2,0) = 1.0;
+
+            double dist = distPointLine(p, l);
+
+            if ( fabs( dist ) > threshold_dist )
+            {
+                is_line = false;
+                break;
+            }
+            l_points.push_back(pt);
+        }
+
+        // Line check fail, test next point
+        if ( is_line == false )
+            continue;
+
+        l_points.push_back(pe);
+
+        Vec4f line;
+        fitLine( Mat(l_points), line, DIST_L2, 0, 0.01, 0.01);
+        a[0] = line[2];
+        a[1] = line[3];
+        b[0] = line[2] + line[0];
+        b[1] = line[3] + line[1];
+
+        p1 = Mat(3, 1, CV_64FC1, a).clone();
+        p2 = Mat(3, 1, CV_64FC1, b).clone();
+
+        l = p1.cross(p2);
+
+        incidentPoint(l, ps);
+
+        // Extending line
+        for ( j = threshold_length + 1; i + j < total; j++ )
+        {
+            pt.x = points[i+j].x;
+            pt.y = points[i+j].y;
+
+            p.at<double>(0,0) = (double)pt.x;
+            p.at<double>(1,0) = (double)pt.y;
+            p.at<double>(2,0) = 1.0;
+
+            double dist = distPointLine(p, l);
+            if ( fabs( dist ) > threshold_dist )
+            {
+                fitLine( Mat(l_points), line, DIST_L2, 0, 0.01, 0.01);
+                a[0] = line[2];
+                a[1] = line[3];
+                b[0] = line[2] + line[0];
+                b[1] = line[3] + line[1];
+
+                p1 = Mat(3, 1, CV_64FC1, a).clone();
+                p2 = Mat(3, 1, CV_64FC1, b).clone();
+
+                l = p1.cross(p2);
+                dist = distPointLine(p, l);
+                if ( fabs( dist ) > threshold_dist ) {
+                    j--;
+                    break;
+                }
+            }
+            pe = pt;
+            l_points.push_back(pt);
+        }
+        fitLine( Mat(l_points), line, DIST_L2, 0, 0.01, 0.01);
+        a[0] = line[2];
+        a[1] = line[3];
+        b[0] = line[2] + line[0];
+        b[1] = line[3] + line[1];
+
+        p1 = Mat(3, 1, CV_64FC1, a).clone();
+        p2 = Mat(3, 1, CV_64FC1, b).clone();
+
+        l = p1.cross(p2);
+
+        Point2f e1, e2;
+        e1.x = (float)ps.x;
+        e1.y = (float)ps.y;
+        e2.x = (float)pe.x;
+        e2.y = (float)pe.y;
+
+        incidentPoint(l, e1);
+        incidentPoint(l, e2);
+        seg.x1 = e1.x;
+        seg.y1 = e1.y;
+        seg.x2 = e2.x;
+        seg.y2 = e2.y;
+
+        segments.push_back(seg);
+        i = i + j;
+    }
+}
+
+void FastLineDetectorImpl::pointInboardTest(const Size srcSize, Point2i& pt)
+{
+    pt.x = pt.x <= 5 ? 5 : pt.x >= srcSize.width - 5 ? srcSize.width - 5 : pt.x;
+    pt.y = pt.y <= 5 ? 5 : pt.y >= srcSize.height - 5 ? srcSize.height - 5 : pt.y;
+}
+
+bool FastLineDetectorImpl::getPointChain(const Mat& img, Point pt,
+        Point& chained_pt, float& direction, int step)
+{
+    int ri, ci;
+    int indices[8][2] = { {1,1}, {1,0}, {1,-1}, {0,-1},
+        {-1,-1},{-1,0}, {-1,1}, {0,1} };
+
+    float min_dir_diff = 7.0f;
+    Point consistent_pt;
+    int consistent_direction = 0;
+    for ( int i = 0; i < 8; i++ )
+    {
+        ci = pt.x + indices[i][1];
+        ri = pt.y + indices[i][0];
+
+        if ( ri < 0 || ri == img.rows || ci < 0 || ci == img.cols )
+            continue;
+
+        if ( img.at<unsigned char>(ri, ci) == 0 )
+            continue;
+
+        if(step == 0)
+        {
+            chained_pt.x = ci;
+            chained_pt.y = ri;
+            // direction = (float)i;
+            direction = i > 4 ? (float)(i - 8) : (float)i;
+            return true;
+        }
+        else
+        {
+            float curr_dir = i > 4 ? (float)(i - 8) : (float)i;
+            float dir_diff = abs(curr_dir - direction);
+            dir_diff = dir_diff > 4.0f ? 8.0f - dir_diff : dir_diff;
+            if(dir_diff <= min_dir_diff)
+            {
+                min_dir_diff = dir_diff;
+                consistent_pt.x = ci;
+                consistent_pt.y = ri;
+                consistent_direction = i > 4 ? i - 8 : i;
+            }
+        }
+    }
+    if(min_dir_diff < 2.0f)
+    {
+        chained_pt.x = consistent_pt.x;
+        chained_pt.y = consistent_pt.y;
+        direction = (direction * (float)step + (float)consistent_direction)
+            / (float)(step + 1);
+        return true;
+    }
+    return false;
+}
+
+void FastLineDetectorImpl::lineDetection(const Mat& src, std::vector<SEGMENT>& segments_all)
+{
+    int r, c;
+    imageheight=src.rows; imagewidth=src.cols;
+
+    std::vector<Point2i> points;
+    std::vector<SEGMENT> segments, segments_tmp;
+    Mat canny;
+    if (canny_aperture_size == 0)
+    {
+        canny = src;
+    }
+    else
+    {
+        Canny(src, canny, canny_th1, canny_th2, canny_aperture_size);
+    }
+    canny.colRange(0,6).rowRange(0,6).setTo(cv::Scalar::all(0));
+    canny.colRange(src.cols-5,src.cols).rowRange(src.rows-5,src.rows).setTo(cv::Scalar::all(0));
+
+    SEGMENT seg, seg1, seg2;
+
+    for ( r = 0; r < imageheight; r++ )
+    {
+        for ( c = 0; c < imagewidth; c++ )
+        {
+            // Find seeds - skip for non-seeds
+            if ( canny.at<unsigned char>(r,c) == 0 )
+                continue;
+
+            // Found seeds
+            Point2i pt = Point2i(c,r);
+
+            points.push_back(pt);
+            canny.at<unsigned char>(pt.y, pt.x) = 0;
+
+            float direction = 0.0f;
+            int step = 0;
+            while(getPointChain(canny, pt, pt, direction, step))
+            {
+                points.push_back(pt);
+                step++;
+                canny.at<unsigned char>(pt.y, pt.x) = 0;
+            }
+
+            if ( points.size() < (unsigned int)threshold_length + 1 )
+            {
+                points.clear();
+                continue;
+            }
+
+            extractSegments(points, segments);
+
+            if ( segments.size() == 0 )
+            {
+                points.clear();
+                continue;
+            }
+            for ( int i = 0; i < (int)segments.size(); i++ )
+            {
+                seg = segments[i];
+                float length = sqrt((seg.x1 - seg.x2)*(seg.x1 - seg.x2) +
+                        (seg.y1 - seg.y2)*(seg.y1 - seg.y2));
+                if(length < threshold_length)
+                    continue;
+                if( (seg.x1 <= 5.0f && seg.x2 <= 5.0f) ||
+                    (seg.y1 <= 5.0f && seg.y2 <= 5.0f) ||
+                    (seg.x1 >= imagewidth - 5.0f && seg.x2 >= imagewidth - 5.0f) ||
+                    (seg.y1 >= imageheight - 5.0f && seg.y2 >= imageheight - 5.0f) )
+                    continue;
+                additionalOperationsOnSegment(src, seg);
+                if(!do_merge)
+                    segments_all.push_back(seg);
+                segments_tmp.push_back(seg);
+            }
+            points.clear();
+            segments.clear();
+        }
+    }
+    if(!do_merge)
+        return;
+
+    bool is_merged = false;
+    int ith = (int)segments_tmp.size() - 1;
+    int jth = ith - 1;
+    while(ith > 1 || jth > 0)
+    {
+        seg1 = segments_tmp[ith];
+        seg2 = segments_tmp[jth];
+        SEGMENT seg_merged;
+        is_merged = mergeSegments(seg1, seg2, seg_merged);
+        if(is_merged == true)
+        {
+            seg2 = seg_merged;
+            additionalOperationsOnSegment(src, seg2);
+            std::vector<SEGMENT>::iterator it = segments_tmp.begin() + ith;
+            *it = seg2;
+            segments_tmp.erase(segments_tmp.begin()+jth);
+            ith--;
+            jth = ith - 1;
+        }
+        else
+        {
+            jth--;
+        }
+        if(jth < 0) {
+            ith--;
+            jth = ith - 1;
+        }
+    }
+    segments_all = segments_tmp;
+}
+
+inline void FastLineDetectorImpl::getAngle(SEGMENT& seg)
+{
+    seg.angle = (float)(fastAtan2(seg.y2 - seg.y1, seg.x2 - seg.x1) / 180.0f * CV_PI);
+}
+
+void FastLineDetectorImpl::additionalOperationsOnSegment(const Mat& src, SEGMENT& seg)
+{
+    if(seg.x1 == 0.0f && seg.x2 == 0.0f && seg.y1 == 0.0f && seg.y2 == 0.0f)
+        return;
+
+    getAngle(seg);
+    double ang = (double)seg.angle;
+
+    Point2f start = Point2f(seg.x1, seg.y1);
+    Point2f end = Point2f(seg.x2, seg.y2);
+
+    double dx = 0.0, dy = 0.0;
+    dx = (double) end.x - (double) start.x;
+    dy = (double) end.y - (double) start.y;
+
+    int num_points = 10;
+    Point2f *points = new Point2f[num_points];
+
+    points[0] = start;
+    points[num_points - 1] = end;
+    for (int i = 0; i < num_points; i++)
+    {
+        if (i == 0 || i == num_points - 1)
+            continue;
+        points[i].x = points[0].x + ((float)dx / float(num_points - 1) * (float) i);
+        points[i].y = points[0].y + ((float)dy / float(num_points - 1) * (float) i);
+    }
+
+    Point2i *points_right = new Point2i[num_points];
+    Point2i *points_left = new Point2i[num_points];
+    double gap = 1.0;
+
+    for(int i = 0; i < num_points; i++)
+    {
+        points_right[i].x = cvRound(points[i].x + gap*cos(90.0 * CV_PI / 180.0 + ang));
+        points_right[i].y = cvRound(points[i].y + gap*sin(90.0 * CV_PI / 180.0 + ang));
+        points_left[i].x = cvRound(points[i].x - gap*cos(90.0 * CV_PI / 180.0 + ang));
+        points_left[i].y = cvRound(points[i].y - gap*sin(90.0 * CV_PI / 180.0 + ang));
+        pointInboardTest(src.size(), points_right[i]);
+        pointInboardTest(src.size(), points_left[i]);
+    }
+
+    int iR = 0, iL = 0;
+    for(int i = 0; i < num_points; i++)
+    {
+        iR += src.at<unsigned char>(points_right[i].y, points_right[i].x);
+        iL += src.at<unsigned char>(points_left[i].y, points_left[i].x);
+    }
+
+    if(iR > iL)
+    {
+        std::swap(seg.x1, seg.x2);
+        std::swap(seg.y1, seg.y2);
+        getAngle(seg);
+    }
+
+    delete[] points;
+    delete[] points_right;
+    delete[] points_left;
+
+    return;
+}
+
+} // namespace cv
+} // namespace ximgproc
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fbs_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fbs_filter.cpp
new file mode 100644
index 00000000..b490d895
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fbs_filter.cpp
@@ -0,0 +1,645 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+
+#include <cmath>
+#include <vector>
+#include <memory>
+#include <stdlib.h>
+#include <iostream>
+#include <iterator>
+#include <algorithm>
+
+
+#ifdef HAVE_EIGEN
+#  if defined __GNUC__ && defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wshadow"
+#  endif
+#  include <Eigen/Dense>
+#  include <Eigen/SparseCore>
+#  include <Eigen/SparseCholesky>
+#  include <Eigen/IterativeLinearSolvers>
+#  include <Eigen/Sparse>
+
+
+
+
+#if __cplusplus <= 199711L
+    #include <map>
+    typedef std::map<long long /* hash */, int /* vert id */>  mapId;
+#else
+    #include <unordered_map>
+    typedef std::unordered_map<long long /* hash */, int /* vert id */>  mapId;
+#endif
+
+namespace cv
+{
+namespace ximgproc
+{
+
+    class FastBilateralSolverFilterImpl : public FastBilateralSolverFilter
+    {
+    public:
+
+        static Ptr<FastBilateralSolverFilterImpl> create(InputArray guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)
+        {
+            CV_Assert(guide.type() == CV_8UC1 || guide.type() == CV_8UC3);
+            FastBilateralSolverFilterImpl *fbs = new FastBilateralSolverFilterImpl();
+            Mat gui = guide.getMat();
+            fbs->init(gui,sigma_spatial,sigma_luma,sigma_chroma,lambda,num_iter,max_tol);
+            return Ptr<FastBilateralSolverFilterImpl>(fbs);
+        }
+
+        void filter(InputArray src, InputArray confidence, OutputArray dst) CV_OVERRIDE
+        {
+
+            CV_Assert(!src.empty() && (src.depth() == CV_8U || src.depth() == CV_16S || src.depth() == CV_16U || src.depth() == CV_32F) && src.channels()<=4);
+            CV_Assert(!confidence.empty() && (confidence.depth() == CV_8U || confidence.depth() == CV_32F) && confidence.channels()==1);
+            if (src.rows() != rows || src.cols() != cols)
+            {
+                CV_Error(Error::StsBadSize, "Size of the filtered image must be equal to the size of the guide image");
+                return;
+            }
+            if (confidence.rows() != rows || confidence.cols() != cols)
+            {
+                CV_Error(Error::StsBadSize, "Size of the confidence image must be equal to the size of the guide image");
+                return;
+            }
+
+            std::vector<Mat> src_channels;
+            std::vector<Mat> dst_channels;
+            if(src.channels()==1)
+                src_channels.push_back(src.getMat());
+            else
+                split(src,src_channels);
+
+            Mat conf = confidence.getMat();
+
+            for(int i=0;i<src.channels();i++)
+            {
+                Mat cur_res = src_channels[i].clone();
+
+                solve(cur_res,conf,cur_res);
+                cur_res.convertTo(cur_res, src.type());
+                dst_channels.push_back(cur_res);
+            }
+
+            dst.create(src.size(),src_channels[0].type());
+            if(src.channels()==1)
+            {
+                Mat& dstMat = dst.getMatRef();
+                dstMat = dst_channels[0];
+            }
+            else
+            merge(dst_channels,dst);
+            CV_Assert(src.type() == dst.type() && src.size() == dst.size());
+        }
+
+    // protected:
+        void solve(cv::Mat& src, cv::Mat& confidence, cv::Mat& dst);
+        void init(cv::Mat& reference, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol);
+
+        void Splat(Eigen::VectorXf& input, Eigen::VectorXf& dst);
+        void Blur(Eigen::VectorXf& input, Eigen::VectorXf& dst);
+        void Slice(Eigen::VectorXf& input, Eigen::VectorXf& dst);
+
+        void diagonal(Eigen::VectorXf& v,Eigen::SparseMatrix<float>& mat)
+        {
+            mat = Eigen::SparseMatrix<float>(v.size(),v.size());
+            for (int i = 0; i < int(v.size()); i++)
+            {
+                mat.insert(i,i) = v(i);
+            }
+        }
+
+
+
+    private:
+
+        int npixels;
+        int nvertices;
+        int dim;
+        int cols;
+        int rows;
+        std::vector<int> splat_idx;
+        std::vector<std::pair<int, int> > blur_idx;
+        Eigen::VectorXf m;
+        Eigen::VectorXf n;
+        Eigen::SparseMatrix<float, Eigen::ColMajor> blurs;
+        Eigen::SparseMatrix<float, Eigen::ColMajor> S;
+        Eigen::SparseMatrix<float, Eigen::ColMajor> Dn;
+        Eigen::SparseMatrix<float, Eigen::ColMajor> Dm;
+
+        struct grid_params
+        {
+            float spatialSigma;
+            float lumaSigma;
+            float chromaSigma;
+            grid_params()
+            {
+                spatialSigma = 8.0;
+                lumaSigma = 8.0;
+                chromaSigma = 8.0;
+            }
+        };
+
+        struct bs_params
+        {
+            float lam;
+            float A_diag_min;
+            float cg_tol;
+            int cg_maxiter;
+            bs_params()
+            {
+                lam = 128.0;
+                A_diag_min = 1e-5f;
+                cg_tol = 1e-5f;
+                cg_maxiter = 25;
+            }
+        };
+
+        grid_params grid_param;
+        bs_params bs_param;
+
+    };
+
+
+
+    void FastBilateralSolverFilterImpl::init(cv::Mat& reference, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)
+    {
+
+        bs_param.lam = lambda;
+        bs_param.cg_maxiter = num_iter;
+        bs_param.cg_tol = max_tol;
+
+        if(reference.channels()==1)
+        {
+            dim = 3;
+            cols = reference.cols;
+            rows = reference.rows;
+            npixels = cols*rows;
+            long long hash_vec[3];
+            for (int i = 0; i < 3; ++i)
+            hash_vec[i] = static_cast<long long>(std::pow(255, i));
+
+            mapId hashed_coords;
+#if __cplusplus <= 199711L
+#else
+            hashed_coords.reserve(cols*rows);
+#endif
+
+            const unsigned char* pref = (const unsigned char*)reference.data;
+            int vert_idx = 0;
+            int pix_idx = 0;
+
+            // construct Splat(Slice) matrices
+            splat_idx.resize(npixels);
+            for (int y = 0; y < rows; ++y)
+            {
+                for (int x = 0; x < cols; ++x)
+                {
+                    long long coord[3];
+                    coord[0] = int(x / sigma_spatial);
+                    coord[1] = int(y / sigma_spatial);
+                    coord[2] = int(pref[0] / sigma_luma);
+
+                    // convert the coordinate to a hash value
+                    long long hash_coord = 0;
+                    for (int i = 0; i < 3; ++i)
+                        hash_coord += coord[i] * hash_vec[i];
+
+                    // pixels whom are alike will have the same hash value.
+                    // We only want to keep a unique list of hash values, therefore make sure we only insert
+                    // unique hash values.
+                    mapId::iterator it = hashed_coords.find(hash_coord);
+                    if (it == hashed_coords.end())
+                    {
+                        hashed_coords.insert(std::pair<long long, int>(hash_coord, vert_idx));
+                        splat_idx[pix_idx] = vert_idx;
+                        ++vert_idx;
+                    }
+                    else
+                    {
+                        splat_idx[pix_idx] = it->second;
+                    }
+
+                    pref += 1; // skip 1 bytes (y)
+                    ++pix_idx;
+                }
+            }
+            nvertices = static_cast<int>(hashed_coords.size());
+
+            // construct Blur matrices
+            Eigen::VectorXf ones_nvertices = Eigen::VectorXf::Ones(nvertices);
+            diagonal(ones_nvertices,blurs);
+            blurs *= 10;
+            for(int offset = -1; offset <= 1;++offset)
+            {
+                if(offset == 0) continue;
+                for (int i = 0; i < dim; ++i)
+                {
+                    Eigen::SparseMatrix<float, Eigen::ColMajor> blur_temp(hashed_coords.size(), hashed_coords.size());
+                    blur_temp.reserve(Eigen::VectorXi::Constant(nvertices,6));
+                    long long offset_hash_coord = offset * hash_vec[i];
+                    for (mapId::iterator it = hashed_coords.begin(); it != hashed_coords.end(); ++it)
+                    {
+                        long long neighb_coord = it->first + offset_hash_coord;
+                        mapId::iterator it_neighb = hashed_coords.find(neighb_coord);
+                        if (it_neighb != hashed_coords.end())
+                        {
+                            blur_temp.insert(it->second,it_neighb->second) = 1.0f;
+                            blur_idx.push_back(std::pair<int,int>(it->second, it_neighb->second));
+                        }
+                    }
+                    blurs += blur_temp;
+                }
+            }
+            blurs.finalize();
+
+            //bistochastize
+            int maxiter = 10;
+            n = ones_nvertices;
+            m = Eigen::VectorXf::Zero(nvertices);
+            for (int i = 0; i < int(splat_idx.size()); i++)
+            {
+                m(splat_idx[i]) += 1.0f;
+            }
+
+            Eigen::VectorXf bluredn(nvertices);
+
+            for (int i = 0; i < maxiter; i++)
+            {
+                Blur(n,bluredn);
+                n = ((n.array()*m.array()).array()/bluredn.array()).array().sqrt();
+            }
+            Blur(n,bluredn);
+
+            m = n.array() * (bluredn).array();
+            diagonal(m,Dm);
+            diagonal(n,Dn);
+
+        }
+        else
+        {
+            dim = 5;
+            cv::Mat reference_yuv;
+            cv::cvtColor(reference, reference_yuv, COLOR_BGR2YCrCb);
+
+            cols = reference_yuv.cols;
+            rows = reference_yuv.rows;
+            npixels = cols*rows;
+            long long hash_vec[5];
+            for (int i = 0; i < 5; ++i)
+            hash_vec[i] = static_cast<long long>(std::pow(255, i));
+
+            mapId hashed_coords;
+#if __cplusplus <= 199711L
+#else
+            hashed_coords.reserve(cols*rows);
+#endif
+
+            const unsigned char* pref = (const unsigned char*)reference_yuv.data;
+            int vert_idx = 0;
+            int pix_idx = 0;
+
+            // construct Splat(Slice) matrices
+            splat_idx.resize(npixels);
+            for (int y = 0; y < rows; ++y)
+            {
+                for (int x = 0; x < cols; ++x)
+                {
+                    long long coord[5];
+                    coord[0] = int(x / sigma_spatial);
+                    coord[1] = int(y / sigma_spatial);
+                    coord[2] = int(pref[0] / sigma_luma);
+                    coord[3] = int(pref[1] / sigma_chroma);
+                    coord[4] = int(pref[2] / sigma_chroma);
+
+                    // convert the coordinate to a hash value
+                    long long hash_coord = 0;
+                    for (int i = 0; i < 5; ++i)
+                        hash_coord += coord[i] * hash_vec[i];
+
+                    // pixels whom are alike will have the same hash value.
+                    // We only want to keep a unique list of hash values, therefore make sure we only insert
+                    // unique hash values.
+                    mapId::iterator it = hashed_coords.find(hash_coord);
+                    if (it == hashed_coords.end())
+                    {
+                        hashed_coords.insert(std::pair<long long, int>(hash_coord, vert_idx));
+                        splat_idx[pix_idx] = vert_idx;
+                        ++vert_idx;
+                    }
+                    else
+                    {
+                        splat_idx[pix_idx] = it->second;
+                    }
+
+                    pref += 3; // skip 3 bytes (y u v)
+                    ++pix_idx;
+                }
+            }
+            nvertices = static_cast<int>(hashed_coords.size());
+
+            // construct Blur matrices
+            Eigen::VectorXf ones_nvertices = Eigen::VectorXf::Ones(nvertices);
+            diagonal(ones_nvertices,blurs);
+            blurs *= 10;
+            for(int offset = -1; offset <= 1;++offset)
+            {
+                if(offset == 0) continue;
+                for (int i = 0; i < dim; ++i)
+                {
+                    Eigen::SparseMatrix<float, Eigen::ColMajor> blur_temp(hashed_coords.size(), hashed_coords.size());
+                    blur_temp.reserve(Eigen::VectorXi::Constant(nvertices,6));
+                    long long offset_hash_coord = offset * hash_vec[i];
+                    for (mapId::iterator it = hashed_coords.begin(); it != hashed_coords.end(); ++it)
+                    {
+                        long long neighb_coord = it->first + offset_hash_coord;
+                        mapId::iterator it_neighb = hashed_coords.find(neighb_coord);
+                        if (it_neighb != hashed_coords.end())
+                        {
+                            blur_temp.insert(it->second,it_neighb->second) = 1.0f;
+                            blur_idx.push_back(std::pair<int,int>(it->second, it_neighb->second));
+                        }
+                    }
+                    blurs += blur_temp;
+                }
+            }
+            blurs.finalize();
+
+
+            //bistochastize
+            int maxiter = 10;
+            n = ones_nvertices;
+            m = Eigen::VectorXf::Zero(nvertices);
+            for (int i = 0; i < int(splat_idx.size()); i++)
+            {
+                m(splat_idx[i]) += 1.0f;
+            }
+
+            Eigen::VectorXf bluredn(nvertices);
+
+            for (int i = 0; i < maxiter; i++)
+            {
+                Blur(n,bluredn);
+                n = ((n.array()*m.array()).array()/bluredn.array()).array().sqrt();
+            }
+            Blur(n,bluredn);
+
+            m = n.array() * (bluredn).array();
+            diagonal(m,Dm);
+            diagonal(n,Dn);
+        }
+    }
+
+    void FastBilateralSolverFilterImpl::Splat(Eigen::VectorXf& input, Eigen::VectorXf& output)
+    {
+        output.setZero();
+        for (int i = 0; i < int(splat_idx.size()); i++)
+        {
+            output(splat_idx[i]) += input(i);
+        }
+
+    }
+
+    void FastBilateralSolverFilterImpl::Blur(Eigen::VectorXf& input, Eigen::VectorXf& output)
+    {
+        output.setZero();
+        output = input * 10;
+        for (int i = 0; i < int(blur_idx.size()); i++)
+        {
+            output(blur_idx[i].first) += input(blur_idx[i].second);
+        }
+    }
+
+
+    void FastBilateralSolverFilterImpl::Slice(Eigen::VectorXf& input, Eigen::VectorXf& output)
+    {
+        output.setZero();
+        for (int i = 0; i < int(splat_idx.size()); i++)
+        {
+            output(i) = input(splat_idx[i]);
+        }
+    }
+
+
+    void FastBilateralSolverFilterImpl::solve(cv::Mat& target,
+               cv::Mat& confidence,
+               cv::Mat& output)
+    {
+
+        Eigen::SparseMatrix<float, Eigen::ColMajor> M(nvertices,nvertices);
+        Eigen::SparseMatrix<float, Eigen::ColMajor> A_data(nvertices,nvertices);
+        Eigen::SparseMatrix<float, Eigen::ColMajor> A(nvertices,nvertices);
+        Eigen::VectorXf b(nvertices);
+        Eigen::VectorXf y(nvertices);
+        Eigen::VectorXf y0(nvertices);
+        Eigen::VectorXf y1(nvertices);
+        Eigen::VectorXf w_splat(nvertices);
+
+        Eigen::VectorXf x(npixels);
+        Eigen::VectorXf w(npixels);
+
+        if(target.depth() == CV_16S)
+        {
+            const int16_t *pft = reinterpret_cast<const int16_t*>(target.data);
+            for (int i = 0; i < npixels; i++)
+            {
+                x(i) = (cv::saturate_cast<float>(pft[i])+32768.0f)/65535.0f;
+            }
+        }
+        else if(target.depth() == CV_16U)
+        {
+            const uint16_t *pft = reinterpret_cast<const uint16_t*>(target.data);
+            for (int i = 0; i < npixels; i++)
+            {
+                x(i) = cv::saturate_cast<float>(pft[i])/65535.0f;
+            }
+        }
+        else if(target.depth() == CV_8U)
+        {
+            const uchar *pft = reinterpret_cast<const uchar*>(target.data);
+            for (int i = 0; i < npixels; i++)
+            {
+                x(i) = cv::saturate_cast<float>(pft[i])/255.0f;
+            }
+        }
+        else if(target.depth() == CV_32F)
+        {
+            const float *pft = reinterpret_cast<const float*>(target.data);
+            for (int i = 0; i < npixels; i++)
+            {
+                x(i) = pft[i];
+            }
+        }
+
+        if(confidence.depth() == CV_8U)
+        {
+            const uchar *pfc = reinterpret_cast<const uchar*>(confidence.data);
+            for (int i = 0; i < npixels; i++)
+            {
+                w(i) = cv::saturate_cast<float>(pfc[i])/255.0f;
+            }
+        }
+        else if(confidence.depth() == CV_32F)
+        {
+            const float *pfc = reinterpret_cast<const float*>(confidence.data);
+            for (int i = 0; i < npixels; i++)
+            {
+                w(i) = pfc[i];
+            }
+        }
+
+        //construct A
+        Splat(w,w_splat);
+
+        diagonal(w_splat,A_data);
+        A = bs_param.lam * (Dm - Dn * (blurs*Dn)) + A_data ;
+
+        //construct b
+        b.setZero();
+        for (int i = 0; i < int(splat_idx.size()); i++)
+        {
+            b(splat_idx[i]) += x(i) * w(i);
+        }
+
+        //construct guess for y
+        y0.setZero();
+        for (int i = 0; i < int(splat_idx.size()); i++)
+        {
+            y0(splat_idx[i]) += x(i);
+        }
+        y1.setZero();
+        for (int i = 0; i < int(splat_idx.size()); i++)
+        {
+            y1(splat_idx[i]) += 1.0f;
+        }
+        for (int i = 0; i < nvertices; i++)
+        {
+            y0(i) = y0(i)/y1(i);
+        }
+
+
+        // solve Ay = b
+        Eigen::ConjugateGradient<Eigen::SparseMatrix<float>, Eigen::Lower|Eigen::Upper> cg;
+        cg.compute(A);
+        cg.setMaxIterations(bs_param.cg_maxiter);
+        cg.setTolerance(bs_param.cg_tol);
+        // y = cg.solve(b);
+        y = cg.solveWithGuess(b,y0);
+        std::cout << "#iterations:     " << cg.iterations() << std::endl;
+        std::cout << "estimated error: " << cg.error()      << std::endl;
+
+        //slice
+        if(target.depth() == CV_16S)
+        {
+            int16_t *pftar = (int16_t*) output.data;
+            for (int i = 0; i < int(splat_idx.size()); i++)
+            {
+                pftar[i] = cv::saturate_cast<short>(y(splat_idx[i]) * 65535.0f - 32768.0f);
+            }
+        }
+        else if(target.depth() == CV_16U)
+        {
+            uint16_t *pftar = (uint16_t*) output.data;
+            for (int i = 0; i < int(splat_idx.size()); i++)
+            {
+                pftar[i] = cv::saturate_cast<ushort>(y(splat_idx[i]) * 65535.0f);
+            }
+        }
+        else if (target.depth() == CV_8U)
+        {
+            uchar *pftar = (uchar*) output.data;
+            for (int i = 0; i < int(splat_idx.size()); i++)
+            {
+                pftar[i] = cv::saturate_cast<uchar>(y(splat_idx[i]) * 255.0f);
+            }
+        }
+        else
+        {
+            float *pftar = (float*)(output.data);
+            for (int i = 0; i < int(splat_idx.size()); i++)
+            {
+                pftar[i] = y(splat_idx[i]);
+            }
+        }
+
+
+    }
+
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+Ptr<FastBilateralSolverFilter> createFastBilateralSolverFilter(InputArray guide, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)
+{
+    return Ptr<FastBilateralSolverFilter>(FastBilateralSolverFilterImpl::create(guide, sigma_spatial, sigma_luma, sigma_chroma, lambda, num_iter, max_tol));
+}
+
+void fastBilateralSolverFilter(InputArray guide, InputArray src, InputArray confidence, OutputArray dst, double sigma_spatial, double sigma_luma, double sigma_chroma, double lambda, int num_iter, double max_tol)
+{
+    Ptr<FastBilateralSolverFilter> fbs = createFastBilateralSolverFilter(guide, sigma_spatial, sigma_luma, sigma_chroma, lambda, num_iter, max_tol);
+    fbs->filter(src, confidence, dst);
+}
+
+}
+
+}
+
+#else
+
+namespace cv
+{
+namespace ximgproc
+{
+
+Ptr<FastBilateralSolverFilter> createFastBilateralSolverFilter(InputArray, double, double, double, double, int, double)
+{
+    CV_Error(Error::StsNotImplemented, "createFastBilateralSolverFilter : needs to be compiled with EIGEN");
+}
+
+void fastBilateralSolverFilter(InputArray, InputArray, InputArray, OutputArray, double, double, double, double, int, double)
+{
+    CV_Error(Error::StsNotImplemented, "fastBilateralSolverFilter : needs to be compiled with EIGEN");
+}
+
+
+}
+
+}
+
+#endif // HAVE_EIGEN
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fgs_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fgs_filter.cpp
new file mode 100644
index 00000000..5e168da5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fgs_filter.cpp
@@ -0,0 +1,691 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+#include <vector>
+
+namespace cv {
+namespace ximgproc {
+
+using std::vector;
+
+typedef float WorkType;
+typedef Vec<WorkType, 1> WorkVec;
+typedef WorkType (*get_weight_op)(WorkType*, unsigned char*,unsigned char*);
+
+inline WorkType get_weight_1channel(WorkType* LUT, unsigned char* p1,unsigned char* p2)
+{
+    return LUT[ (p1[0]-p2[0])*(p1[0]-p2[0]) ];
+}
+inline WorkType get_weight_3channel(WorkType* LUT, unsigned char* p1,unsigned char* p2)
+{
+    return LUT[ (p1[0]-p2[0])*(p1[0]-p2[0])+
+                (p1[1]-p2[1])*(p1[1]-p2[1])+
+                (p1[2]-p2[2])*(p1[2]-p2[2]) ];
+}
+
+class FastGlobalSmootherFilterImpl : public FastGlobalSmootherFilter
+{
+public:
+    static Ptr<FastGlobalSmootherFilterImpl> create(InputArray guide, double lambda, double sigma_color, int num_iter,double lambda_attenuation);
+    void filter(InputArray src, OutputArray dst) CV_OVERRIDE;
+
+protected:
+    int w,h;
+    int num_stripes;
+    float sigmaColor,lambda;
+    float lambda_attenuation;
+    int num_iter;
+    Mat weights_LUT;
+    Mat Chor, Cvert;
+    Mat interD;
+    void init(InputArray guide,double _lambda,double _sigmaColor,int _num_iter,double _lambda_attenuation);
+    void horizontalPass(Mat& cur);
+    void verticalPass(Mat& cur);
+protected:
+    struct HorizontalPass_ParBody : public ParallelLoopBody
+    {
+        FastGlobalSmootherFilterImpl* fgs;
+        Mat* cur;
+        int nstripes, stripe_sz;
+        int h;
+
+        HorizontalPass_ParBody(FastGlobalSmootherFilterImpl &_fgs, Mat& _cur, int _nstripes, int _h);
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+    inline void process_4row_block(Mat* cur,int i);
+    inline void process_row(Mat* cur,int i);
+
+    struct VerticalPass_ParBody : public ParallelLoopBody
+    {
+        FastGlobalSmootherFilterImpl* fgs;
+        Mat* cur;
+        int nstripes, stripe_sz;
+        int w;
+
+        VerticalPass_ParBody(FastGlobalSmootherFilterImpl &_fgs, Mat& _cur, int _nstripes, int _w);
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    template<get_weight_op get_weight, const int num_ch>
+    struct ComputeHorizontalWeights_ParBody : public ParallelLoopBody
+    {
+        FastGlobalSmootherFilterImpl* fgs;
+        Mat* guide;
+        int nstripes, stripe_sz;
+        int h;
+
+        ComputeHorizontalWeights_ParBody(FastGlobalSmootherFilterImpl &_fgs, Mat& _guide, int _nstripes, int _h);
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    template<get_weight_op get_weight, const int num_ch>
+    struct ComputeVerticalWeights_ParBody : public ParallelLoopBody
+    {
+        FastGlobalSmootherFilterImpl* fgs;
+        Mat* guide;
+        int nstripes, stripe_sz;
+        int w;
+
+        ComputeVerticalWeights_ParBody(FastGlobalSmootherFilterImpl &_fgs, Mat& _guide, int _nstripes, int _w);
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    struct ComputeLUT_ParBody : public ParallelLoopBody
+    {
+        FastGlobalSmootherFilterImpl* fgs;
+        WorkType* LUT;
+        int nstripes, stripe_sz;
+        int sz;
+
+        ComputeLUT_ParBody(FastGlobalSmootherFilterImpl &_fgs, WorkType* _LUT, int _nstripes, int _sz);
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+};
+
+
+void FastGlobalSmootherFilterImpl::init(InputArray guide,double _lambda,double _sigmaColor,int _num_iter,double _lambda_attenuation)
+{
+    CV_Assert( !guide.empty() && _lambda >= 0 && _sigmaColor >= 0 && _num_iter >=1 );
+    CV_Assert( guide.depth() == CV_8U && (guide.channels() == 1 || guide.channels() == 3) );
+    sigmaColor = (float)_sigmaColor;
+    lambda = (float)_lambda;
+    lambda_attenuation = (float)_lambda_attenuation;
+    num_iter = _num_iter;
+    num_stripes = getNumThreads();
+    int num_levels = 3*256*256;
+    weights_LUT.create(1,num_levels,traits::Type<WorkVec>::value);
+
+    WorkType* LUT = (WorkType*)weights_LUT.ptr(0);
+    parallel_for_(Range(0,num_stripes),ComputeLUT_ParBody(*this,LUT,num_stripes,num_levels));
+
+    w = guide.cols();
+    h = guide.rows();
+    Chor.  create(h,w,traits::Type<WorkVec>::value);
+    Cvert. create(h,w,traits::Type<WorkVec>::value);
+    interD.create(h,w,traits::Type<WorkVec>::value);
+    Mat guideMat = guide.getMat();
+
+    if(guide.channels() == 1)
+    {
+        parallel_for_(Range(0,num_stripes),ComputeHorizontalWeights_ParBody<get_weight_1channel,1>(*this,guideMat,num_stripes,h));
+        parallel_for_(Range(0,num_stripes),ComputeVerticalWeights_ParBody  <get_weight_1channel,1>(*this,guideMat,num_stripes,w));
+    }
+    if(guide.channels() == 3)
+    {
+        parallel_for_(Range(0,num_stripes),ComputeHorizontalWeights_ParBody<get_weight_3channel,3>(*this,guideMat,num_stripes,h));
+        parallel_for_(Range(0,num_stripes),ComputeVerticalWeights_ParBody  <get_weight_3channel,3>(*this,guideMat,num_stripes,w));
+    }
+}
+
+Ptr<FastGlobalSmootherFilterImpl> FastGlobalSmootherFilterImpl::create(InputArray guide, double lambda, double sigma_color, int num_iter, double lambda_attenuation)
+{
+    FastGlobalSmootherFilterImpl *fgs = new FastGlobalSmootherFilterImpl();
+    fgs->init(guide,lambda,sigma_color,num_iter,lambda_attenuation);
+    return Ptr<FastGlobalSmootherFilterImpl>(fgs);
+}
+
+void FastGlobalSmootherFilterImpl::filter(InputArray src, OutputArray dst)
+{
+    CV_Assert(!src.empty() && (src.depth() == CV_8U || src.depth() == CV_16S || src.depth() == CV_32F) && src.channels()<=4);
+    if (src.rows() != h || src.cols() != w)
+    {
+        CV_Error(Error::StsBadSize, "Size of the filtered image must be equal to the size of the guide image");
+        return;
+    }
+
+    vector<Mat> src_channels;
+    vector<Mat> dst_channels;
+    if(src.channels()==1)
+        src_channels.push_back(src.getMat());
+    else
+        split(src,src_channels);
+
+    float lambda_ref = lambda;
+
+    for(int i=0;i<src.channels();i++)
+    {
+        lambda = lambda_ref;
+        Mat cur_res = src_channels[i].clone();
+        if(src.depth()!=traits::Type<WorkVec>::value)
+            cur_res.convertTo(cur_res,traits::Type<WorkVec>::value);
+
+        for(int n=0;n<num_iter;n++)
+        {
+            horizontalPass(cur_res);
+            verticalPass(cur_res);
+            lambda*=lambda_attenuation;
+        }
+
+        Mat dstMat;
+        if(src.depth()!=traits::Type<WorkVec>::value)
+            cur_res.convertTo(dstMat,src.depth());
+        else
+            dstMat = cur_res;
+
+        dst_channels.push_back(dstMat);
+    }
+
+    lambda = lambda_ref;
+
+    dst.create(src.size(),src.type());
+    if(src.channels()==1)
+    {
+        Mat& dstMat = dst.getMatRef();
+        dstMat = dst_channels[0];
+    }
+    else
+        merge(dst_channels,dst);
+}
+
+void FastGlobalSmootherFilterImpl::horizontalPass(Mat& cur)
+{
+    parallel_for_(Range(0,num_stripes),HorizontalPass_ParBody(*this,cur,num_stripes,h));
+}
+
+void FastGlobalSmootherFilterImpl::verticalPass(Mat& cur)
+{
+    parallel_for_(Range(0,num_stripes),VerticalPass_ParBody(*this,cur,num_stripes,w));
+}
+
+FastGlobalSmootherFilterImpl::HorizontalPass_ParBody::HorizontalPass_ParBody(FastGlobalSmootherFilterImpl &_fgs, Mat& _cur, int _nstripes, int _h):
+fgs(&_fgs),cur(&_cur), nstripes(_nstripes), h(_h)
+{
+    stripe_sz = (int)ceil(h/(double)nstripes);
+}
+
+void FastGlobalSmootherFilterImpl::process_4row_block(Mat* cur,int i)
+{
+    WorkType denom,denom_next,denom_next2,denom_next3;
+
+    WorkType *Chor_row   = (WorkType*)Chor.ptr  (i);
+    WorkType *interD_row = (WorkType*)interD.ptr(i);
+    WorkType *cur_row    = (WorkType*)cur->ptr  (i);
+
+    WorkType *Chor_row_next   = (WorkType*)Chor.ptr  (i+1);
+    WorkType *interD_row_next = (WorkType*)interD.ptr(i+1);
+    WorkType *cur_row_next    = (WorkType*)cur->ptr  (i+1);
+
+    WorkType *Chor_row_next2   = (WorkType*)Chor.ptr  (i+2);
+    WorkType *interD_row_next2 = (WorkType*)interD.ptr(i+2);
+    WorkType *cur_row_next2    = (WorkType*)cur->ptr  (i+2);
+
+    WorkType *Chor_row_next3   = (WorkType*)Chor.ptr  (i+3);
+    WorkType *interD_row_next3 = (WorkType*)interD.ptr(i+3);
+    WorkType *cur_row_next3    = (WorkType*)cur->ptr  (i+3);
+
+    float coef_cur,          coef_prev;
+    float coef_cur_row_next, coef_prev_row_next;
+    float coef_cur_row_next2,coef_prev_row_next2;
+    float coef_cur_row_next3,coef_prev_row_next3;
+
+    //forward pass:
+    coef_prev           = lambda*Chor_row[0];
+    coef_prev_row_next  = lambda*Chor_row_next[0];
+    coef_prev_row_next2 = lambda*Chor_row_next2[0];
+    coef_prev_row_next3 = lambda*Chor_row_next3[0];
+
+    interD_row[0]       = coef_prev          /(1-coef_prev);
+    interD_row_next[0]  = coef_prev_row_next /(1-coef_prev_row_next);
+    interD_row_next2[0] = coef_prev_row_next2/(1-coef_prev_row_next2);
+    interD_row_next3[0] = coef_prev_row_next3/(1-coef_prev_row_next3);
+
+    cur_row[0]       = cur_row[0]      /(1-coef_prev);
+    cur_row_next[0]  = cur_row_next[0] /(1-coef_prev_row_next);
+    cur_row_next2[0] = cur_row_next2[0]/(1-coef_prev_row_next2);
+    cur_row_next3[0] = cur_row_next3[0]/(1-coef_prev_row_next3);
+    int j=1;
+
+#if CV_SIMD128
+    {
+        v_float32x4 coef_prev_reg(coef_prev,coef_prev_row_next,coef_prev_row_next2,coef_prev_row_next3);
+        v_float32x4 interD_prev_reg(interD_row[0],interD_row_next[0],interD_row_next2[0],interD_row_next3[0]);
+        v_float32x4 cur_prev_reg(cur_row[0],cur_row_next[0],cur_row_next2[0],cur_row_next3[0]);
+        v_float32x4 lambda_reg(lambda,lambda,lambda,lambda);
+        v_float32x4 one_reg(1.0f,1.0f,1.0f,1.0f);
+
+        v_float32x4 a0,a1,a2,a3;
+        v_float32x4 b0,b1,b2,b3;
+        v_float32x4 aux0,aux1,aux2,aux3;
+
+#define PROC4(Chor_in,cur_in,coef_prev_in,interD_prev_in,cur_prev_in,interD_out,cur_out,coef_cur_out)\
+        coef_cur_out = lambda_reg*Chor_in;\
+        aux0 = interD_prev_in*coef_prev_in;\
+        aux1 = coef_cur_out+coef_prev_in;\
+        aux1 = one_reg-aux1;\
+        aux0 = aux1-aux0;\
+        interD_out = coef_cur_out/aux0;\
+        aux1 = cur_prev_in*coef_prev_in;\
+        aux1 = cur_in - aux1;\
+        cur_out = aux1/aux0;
+
+        for(;j<w-3;j+=4)
+        {
+            // processing a 4x4 block:
+
+            aux0 = v_load(Chor_row+j);
+            aux1 = v_load(Chor_row_next+j);
+            aux2 = v_load(Chor_row_next2+j);
+            aux3 = v_load(Chor_row_next3+j);
+            v_transpose4x4(aux0,aux1,aux2,aux3,a0,a1,a2,a3);
+
+            aux0 = v_load(cur_row+j);
+            aux1 = v_load(cur_row_next+j);
+            aux2 = v_load(cur_row_next2+j);
+            aux3 = v_load(cur_row_next3+j);
+            v_transpose4x4(aux0,aux1,aux2,aux3,b0,b1,b2,b3);
+
+            PROC4(a0,b0,coef_prev_reg,interD_prev_reg,cur_prev_reg,a0,b0,aux2);
+            PROC4(a1,b1,aux2,a0,b0,a1,b1,aux3);
+            PROC4(a2,b2,aux3,a1,b1,a2,b2,aux2);
+            PROC4(a3,b3,aux2,a2,b2,a3,b3,aux3);
+
+            interD_prev_reg = a3;
+            cur_prev_reg = b3;
+            coef_prev_reg = aux3;
+
+            v_transpose4x4(a0,a1,a2,a3,aux0,aux1,aux2,aux3);
+            v_store(interD_row+j,aux0);
+            v_store(interD_row_next+j,aux1);
+            v_store(interD_row_next2+j,aux2);
+            v_store(interD_row_next3+j,aux3);
+
+            v_transpose4x4(b0,b1,b2,b3,aux0,aux1,aux2,aux3);
+            v_store(cur_row+j,aux0);
+            v_store(cur_row_next+j,aux1);
+            v_store(cur_row_next2+j,aux2);
+            v_store(cur_row_next3+j,aux3);
+        }
+#undef PROC4
+    }
+#endif
+
+    for(;j<w;j++)
+    {
+        coef_prev           = lambda*Chor_row[j-1];
+        coef_prev_row_next  = lambda*Chor_row_next[j-1];
+        coef_prev_row_next2 = lambda*Chor_row_next2[j-1];
+        coef_prev_row_next3 = lambda*Chor_row_next3[j-1];
+
+        coef_cur           = lambda*Chor_row[j];
+        coef_cur_row_next  = lambda*Chor_row_next[j];
+        coef_cur_row_next2 = lambda*Chor_row_next2[j];
+        coef_cur_row_next3 = lambda*Chor_row_next3[j];
+
+        denom       = (1-coef_prev          -coef_cur)          -interD_row[j-1]      *coef_prev;
+        denom_next  = (1-coef_prev_row_next -coef_cur_row_next) -interD_row_next[j-1] *coef_prev_row_next;
+        denom_next2 = (1-coef_prev_row_next2-coef_cur_row_next2)-interD_row_next2[j-1]*coef_prev_row_next2;
+        denom_next3 = (1-coef_prev_row_next3-coef_cur_row_next3)-interD_row_next3[j-1]*coef_prev_row_next3;
+
+        interD_row[j]       = coef_cur          /denom;
+        interD_row_next[j]  = coef_cur_row_next /denom_next;
+        interD_row_next2[j] = coef_cur_row_next2/denom_next2;
+        interD_row_next3[j] = coef_cur_row_next3/denom_next3;
+
+        cur_row[j]       = (cur_row[j]      -cur_row[j-1]      *coef_prev)          /denom;
+        cur_row_next[j]  = (cur_row_next[j] -cur_row_next[j-1] *coef_prev_row_next) /denom_next;
+        cur_row_next2[j] = (cur_row_next2[j]-cur_row_next2[j-1]*coef_prev_row_next2)/denom_next2;
+        cur_row_next3[j] = (cur_row_next3[j]-cur_row_next3[j-1]*coef_prev_row_next3)/denom_next3;
+    }
+    //backward pass:
+    j = w-2;
+
+#if CV_SIMD128
+    {
+        v_float32x4 cur_next_reg(cur_row[w-1],cur_row_next[w-1],cur_row_next2[w-1],cur_row_next3[w-1]);
+        v_float32x4 a0,a1,a2,a3;
+        v_float32x4 b0,b1,b2,b3;
+        v_float32x4 aux0,aux1,aux2,aux3;
+        for(j-=3;j>=0;j-=4)
+        {
+            //process 4x4 block:
+
+            aux0 = v_load(interD_row+j);
+            aux1 = v_load(interD_row_next+j);
+            aux2 = v_load(interD_row_next2+j);
+            aux3 = v_load(interD_row_next3+j);
+            v_transpose4x4(aux0,aux1,aux2,aux3,a0,a1,a2,a3);
+
+            aux0 = v_load(cur_row+j);
+            aux1 = v_load(cur_row_next+j);
+            aux2 = v_load(cur_row_next2+j);
+            aux3 = v_load(cur_row_next3+j);
+            v_transpose4x4(aux0,aux1,aux2,aux3,b0,b1,b2,b3);
+
+            aux0 = a3*cur_next_reg;
+            b3 = b3-aux0;
+            aux0 = a2*b3;
+            b2 = b2-aux0;
+            aux0 = a1*b2;
+            b1 = b1-aux0;
+            aux0 = a0*b1;
+            b0 = b0-aux0;
+
+            cur_next_reg = b0;
+
+            v_transpose4x4(b0,b1,b2,b3,aux0,aux1,aux2,aux3);
+            v_store(cur_row+j,aux0);
+            v_store(cur_row_next+j,aux1);
+            v_store(cur_row_next2+j,aux2);
+            v_store(cur_row_next3+j,aux3);
+        }
+        j+=3;
+    }
+#endif
+
+    for(;j>=0;j--)
+    {
+        cur_row[j]       = cur_row[j]      -interD_row[j]      *cur_row[j+1];
+        cur_row_next[j]  = cur_row_next[j] -interD_row_next[j] *cur_row_next[j+1];
+        cur_row_next2[j] = cur_row_next2[j]-interD_row_next2[j]*cur_row_next2[j+1];
+        cur_row_next3[j] = cur_row_next3[j]-interD_row_next3[j]*cur_row_next3[j+1];
+    }
+}
+
+void FastGlobalSmootherFilterImpl::process_row(Mat* cur,int i)
+{
+    WorkType denom;
+    WorkType *Chor_row = (WorkType*)Chor.ptr(i);
+    WorkType *interD_row = (WorkType*)interD.ptr(i);
+    WorkType *cur_row = (WorkType*)cur->ptr(i);
+
+    float coef_cur,coef_prev;
+
+    //forward pass:
+    coef_prev = lambda*Chor_row[0];
+    interD_row[0] = coef_prev/(1-coef_prev);
+    cur_row[0] = cur_row[0]/(1-coef_prev);
+    for(int j=1;j<w;j++)
+    {
+        coef_cur = lambda*Chor_row[j];
+        denom = (1-coef_prev-coef_cur)-interD_row[j-1]*coef_prev;
+        interD_row[j] = coef_cur/denom;
+        cur_row[j] = (cur_row[j]-cur_row[j-1]*coef_prev)/denom;
+        coef_prev = coef_cur;
+    }
+
+    //backward pass:
+    for(int j=w-2;j>=0;j--)
+        cur_row[j] = cur_row[j]-interD_row[j]*cur_row[j+1];
+}
+
+void FastGlobalSmootherFilterImpl::HorizontalPass_ParBody::operator()(const Range& range) const
+{
+    int start = std::min(range.start * stripe_sz, h);
+    int end   = std::min(range.end   * stripe_sz, h);
+
+    int i=start;
+    for(;i<end-3;i+=4)
+        fgs->process_4row_block(cur,i);
+    for(;i<end;i++)
+        fgs->process_row(cur,i);
+}
+
+FastGlobalSmootherFilterImpl::VerticalPass_ParBody::VerticalPass_ParBody(FastGlobalSmootherFilterImpl &_fgs, Mat& _cur, int _nstripes, int _w):
+fgs(&_fgs),cur(&_cur), nstripes(_nstripes), w(_w)
+{
+    stripe_sz = (int)ceil(w/(double)nstripes);
+}
+
+void FastGlobalSmootherFilterImpl::VerticalPass_ParBody::operator()(const Range& range) const
+{
+    int start = std::min(range.start * stripe_sz, w);
+    int end   = std::min(range.end   * stripe_sz, w);
+
+    WorkType denom;
+    WorkType *Cvert_row, *Cvert_row_prev;
+    WorkType *interD_row, *interD_row_prev, *cur_row, *cur_row_prev, *cur_row_next;
+
+    float coef_cur,coef_prev;
+
+    Cvert_row = (WorkType*)fgs->Cvert.ptr(0);
+    interD_row = (WorkType*)fgs->interD.ptr(0);
+    cur_row = (WorkType*)cur->ptr(0);
+    //forward pass:
+    for(int j=start;j<end;j++)
+    {
+        coef_cur = fgs->lambda*Cvert_row[j];
+        interD_row[j] = coef_cur/(1-coef_cur);
+        cur_row[j] = cur_row[j]/(1-coef_cur);
+    }
+    for(int i=1;i<fgs->h;i++)
+    {
+        Cvert_row = (WorkType*)fgs->Cvert.ptr(i);
+        Cvert_row_prev = (WorkType*)fgs->Cvert.ptr(i-1);
+        interD_row = (WorkType*)fgs->interD.ptr(i);
+        interD_row_prev = (WorkType*)fgs->interD.ptr(i-1);
+        cur_row = (WorkType*)cur->ptr(i);
+        cur_row_prev = (WorkType*)cur->ptr(i-1);
+        int j = start;
+
+#if CV_SIMD128
+        v_float32x4 a,b,c,d,coef_cur_reg,coef_prev_reg;
+        v_float32x4 one_reg(1.0f,1.0f,1.0f,1.0f);
+        v_float32x4 lambda_reg(fgs->lambda,fgs->lambda,fgs->lambda,fgs->lambda);
+        int sz4 = 4*((end-start)/4);
+        int end4 = start+sz4;
+        for(;j<end4;j+=4)
+        {
+            a = v_load(Cvert_row_prev+j);
+            b = v_load(Cvert_row+j);
+            coef_prev_reg = lambda_reg*a;
+            coef_cur_reg =  lambda_reg*b;
+
+            a = v_load(interD_row_prev+j);
+            a = a*coef_prev_reg;
+
+            b = coef_prev_reg+coef_cur_reg;
+            b = b+a;
+            a = one_reg-b; //computed denom
+
+            b =  coef_cur_reg/a; //computed interD_row
+
+            c = v_load(cur_row_prev+j);
+            c = c*coef_prev_reg;
+
+            d = v_load(cur_row+j);
+            d = d-c;
+            d = d/a; //computed cur_row
+
+            v_store(interD_row+j,b);
+            v_store(cur_row+j,d);
+        }
+#endif
+        for(;j<end;j++)
+        {
+            coef_prev = fgs->lambda*Cvert_row_prev[j];
+            coef_cur  = fgs->lambda*Cvert_row[j];
+            denom = (1-coef_prev-coef_cur)-interD_row_prev[j]*coef_prev;
+            interD_row[j] = coef_cur/denom;
+            cur_row[j] = (cur_row[j]-cur_row_prev[j]*coef_prev)/denom;
+        }
+    }
+
+    //backward pass:
+    for(int i=fgs->h-2;i>=0;i--)
+    {
+        interD_row = (WorkType*)fgs->interD.ptr(i);
+        cur_row = (WorkType*)cur->ptr(i);
+        cur_row_next = (WorkType*)cur->ptr(i+1);
+        int j = start;
+#if CV_SIMD128
+        v_float32x4 a,b;
+        int sz4 = 4*((end-start)/4);
+        int end4 = start+sz4;
+        for(;j<end4;j+=4)
+        {
+            a = v_load(interD_row+j);
+            b = v_load(cur_row_next+j);
+            b = a*b;
+
+            a = v_load(cur_row+j);
+            b = a-b;
+            v_store(cur_row+j,b);
+        }
+#endif
+        for(;j<end;j++)
+            cur_row[j] = cur_row[j]-interD_row[j]*cur_row_next[j];
+    }
+}
+
+template<get_weight_op get_weight, const int num_ch>
+FastGlobalSmootherFilterImpl::ComputeHorizontalWeights_ParBody<get_weight,num_ch>::ComputeHorizontalWeights_ParBody(FastGlobalSmootherFilterImpl &_fgs, Mat& _guide, int _nstripes, int _h):
+fgs(&_fgs),guide(&_guide), nstripes(_nstripes), h(_h)
+{
+    stripe_sz = (int)ceil(h/(double)nstripes);
+}
+
+template<get_weight_op get_weight, const int num_ch>
+void FastGlobalSmootherFilterImpl::ComputeHorizontalWeights_ParBody<get_weight,num_ch>::operator()(const Range& range) const
+{
+    int start = std::min(range.start * stripe_sz, h);
+    int end   = std::min(range.end   * stripe_sz, h);
+
+    WorkType* LUT = (WorkType*)fgs->weights_LUT.ptr(0);
+    unsigned char *row;
+    WorkType *Chor_row;
+
+    for(int i=start;i<end;i++)
+    {
+        row = guide->ptr(i);
+        Chor_row = (WorkType*)fgs->Chor.ptr(i);
+        Chor_row[0] = get_weight(LUT,row,row+num_ch);
+        row+=num_ch;
+        for(int j=1;j<fgs->w-1;j++)
+        {
+            Chor_row[j] = get_weight(LUT,row,row+num_ch);
+            row+=num_ch;
+        }
+        Chor_row[fgs->w-1]=0;
+    }
+}
+
+template<get_weight_op get_weight, const int num_ch>
+FastGlobalSmootherFilterImpl::ComputeVerticalWeights_ParBody<get_weight,num_ch>::ComputeVerticalWeights_ParBody(FastGlobalSmootherFilterImpl &_fgs, Mat& _guide, int _nstripes, int _w):
+fgs(&_fgs),guide(&_guide), nstripes(_nstripes), w(_w)
+{
+    stripe_sz = (int)ceil(w/(double)nstripes);
+}
+
+template<get_weight_op get_weight, const int num_ch>
+void FastGlobalSmootherFilterImpl::ComputeVerticalWeights_ParBody<get_weight,num_ch>::operator()(const Range& range) const
+{
+    int start = std::min(range.start * stripe_sz, w);
+    int end   = std::min(range.end   * stripe_sz, w);
+
+    WorkType* LUT = (WorkType*)fgs->weights_LUT.ptr(0);
+    unsigned char *row,*row_next;
+    WorkType *Cvert_row;
+
+    Cvert_row = (WorkType*)fgs->Cvert.ptr(0);
+    row = guide->ptr(0)+start*num_ch;
+    row_next = guide->ptr(1)+start*num_ch;
+    for(int j=start;j<end;j++)
+    {
+        Cvert_row[j] = get_weight(LUT,row,row_next);
+        row+=num_ch;
+        row_next+=num_ch;
+    }
+
+    for(int i=1;i<fgs->h-1;i++)
+    {
+        row = guide->ptr(i)+start*num_ch;
+        row_next = guide->ptr(i+1)+start*num_ch;
+        Cvert_row = (WorkType*)fgs->Cvert.ptr(i);
+        for(int j=start;j<end;j++)
+        {
+            Cvert_row[j] = get_weight(LUT,row,row_next);
+            row+=num_ch;
+            row_next+=num_ch;
+        }
+    }
+
+    Cvert_row = (WorkType*)fgs->Cvert.ptr(fgs->h-1);
+    for(int j=start;j<end;j++)
+        Cvert_row[j] = 0;
+}
+
+FastGlobalSmootherFilterImpl::ComputeLUT_ParBody::ComputeLUT_ParBody(FastGlobalSmootherFilterImpl &_fgs, WorkType *_LUT, int _nstripes, int _sz):
+fgs(&_fgs), LUT(_LUT), nstripes(_nstripes), sz(_sz)
+{
+    stripe_sz = (int)ceil(sz/(double)nstripes);
+}
+
+void FastGlobalSmootherFilterImpl::ComputeLUT_ParBody::operator()(const Range& range) const
+{
+    int start = std::min(range.start * stripe_sz, sz);
+    int end   = std::min(range.end   * stripe_sz, sz);
+    for(int i=start;i<end;i++)
+        LUT[i] = (WorkType)(-cv::exp(-sqrt((float)i)/fgs->sigmaColor));
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+Ptr<FastGlobalSmootherFilter> createFastGlobalSmootherFilter(InputArray guide, double lambda, double sigma_color, double lambda_attenuation, int num_iter)
+{
+    return Ptr<FastGlobalSmootherFilter>(FastGlobalSmootherFilterImpl::create(guide, lambda, sigma_color, num_iter, lambda_attenuation));
+}
+
+void fastGlobalSmootherFilter(InputArray guide, InputArray src, OutputArray dst, double lambda, double sigma_color, double lambda_attenuation, int num_iter)
+{
+    Ptr<FastGlobalSmootherFilter> fgs = createFastGlobalSmootherFilter(guide, lambda, sigma_color, lambda_attenuation, num_iter);
+    fgs->filter(src, dst);
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/find_ellipses.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/find_ellipses.cpp
new file mode 100644
index 00000000..63727871
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/find_ellipses.cpp
@@ -0,0 +1,1987 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include <opencv2/core.hpp>
+#include <unordered_map>
+#include <numeric>
+
+namespace cv {
+namespace ximgproc {
+
+// typedef
+typedef std::vector<Point> VP;
+typedef std::vector<VP> VVP;
+typedef unsigned int uint;
+
+// ellipse format
+struct Ellipse {
+    Point2f center;
+    float a, b;
+    float radius;
+    float score;
+
+    Ellipse() {
+        center = Point2f(0, 0);
+        a = 0.f, b = 0.f;
+        radius = 0.f, score = 0.f;
+    };
+
+    Ellipse(Point2f _center, float _a, float _b, float _radius,
+            float _score = 0.f) {
+        center = _center;
+        this->a = _a, this->b = _b;
+        this->radius = _radius, this->score = _score;
+    };
+
+    Ellipse(float _center_x, float _center_y, float _a, float _b, float _radius,
+            float _score = 0.f) {
+        center = Point2f(_center_x, _center_y);
+        this->a = _a, this->b = _b;
+        this->radius = _radius, this->score = _score;
+    };
+
+    Ellipse(const Ellipse &other) {
+        center = other.center;
+        a = other.a, b = other.b;
+        radius = other.radius, score = other.score;
+    };
+
+    bool operator<(const Ellipse &other) const {
+        if (score == other.score) {
+            float lhs_e = b / a;
+            float rhs_e = other.b / other.a;
+            if (lhs_e == rhs_e)
+                return false;
+            return lhs_e > rhs_e;
+        }
+        return score > other.score;
+    };
+
+    virtual ~Ellipse() = default;
+};
+
+static int inline signal(float val) {
+    return val > 0.f ? 1 : -1;
+}
+
+static bool sortPoint(const Point &lhs, const Point &rhs) {
+    if (lhs.x == rhs.x) {
+        return lhs.y < rhs.y;
+    }
+    return lhs.x < rhs.x;
+}
+
+static Point2f lineCrossPoint(Point2f l1p1, Point2f l1p2, Point2f l2p1, Point2f l2p2) {
+    Point2f crossPoint;
+    float k1, k2, b1, b2;
+    if (l1p1.x == l1p2.x && l2p1.x == l2p2.x) {
+        crossPoint = Point2f(0, 0);
+        return crossPoint;
+    }
+    if (l1p1.x == l1p2.x) {
+        crossPoint.x = l1p1.x;
+        k2 = (l2p2.y - l2p1.y) / (l2p2.x - l2p1.x);
+        b2 = l2p1.y - k2 * l2p1.x;
+        crossPoint.y = k2 * crossPoint.x + b2;
+        return crossPoint;
+    }
+    if (l2p1.x == l2p2.x) {
+        crossPoint.x = l2p1.x;
+        k2 = (l1p2.y - l1p1.y) / (l1p2.x - l1p1.x);
+        b2 = l1p1.y - k2 * l1p1.x;
+        crossPoint.y = k2 * crossPoint.x + b2;
+        return crossPoint;
+    }
+
+    k1 = (l1p2.y - l1p1.y) / (l1p2.x - l1p1.x);
+    k2 = (l2p2.y - l2p1.y) / (l2p2.x - l2p1.x);
+    b1 = l1p1.y - k1 * l1p1.x;
+    b2 = l2p1.y - k2 * l2p1.x;
+    if (k1 == k2)
+        crossPoint = Point2f(0, 0);
+    else {
+        crossPoint.x = (b2 - b1) / (k1 - k2);
+        crossPoint.y = k1 * crossPoint.x + b1;
+    }
+    return crossPoint;
+}
+
+static void pointToMat(Point2f p1, Point2f p2, Mat& mat) {
+    mat.at<float>(0, 0) = p1.x;
+    mat.at<float>(0, 1) = p1.y;
+    mat.at<float>(1, 0) = p2.x;
+    mat.at<float>(1, 1) = p2.y;
+}
+
+static float valueOfPoints(Point2f p3, Point2f p2, Point2f p1, Point2f p4, Point2f p5, Point2f p6) {
+    float result = 1;
+
+    Point2f v = lineCrossPoint(p1, p2, p3, p4);
+    Point2f w = lineCrossPoint(p5, p6, p3, p4);
+    Point2f u = lineCrossPoint(p5, p6, p1, p2);
+
+    Mat B = Mat(2, 2, CV_32F);
+    Mat C = Mat(2, 2, CV_32F);
+
+    pointToMat(u, v, B);
+    pointToMat(p1, p2, C);
+    Mat A = C * B.inv();
+    result *=
+            A.at<float>(0, 0) * A.at<float>(1, 0) / (A.at<float>(0, 1) * A.at<float>(1, 1));
+
+    pointToMat(p3, p4, C);
+    pointToMat(v, w, B);
+    A = C * B.inv();
+    result *=
+            A.at<float>(0, 0) * A.at<float>(1, 0) / (A.at<float>(0, 1) * A.at<float>(1, 1));
+
+    pointToMat(p5, p6, C);
+    pointToMat(w, u, B);
+    A = C * B.inv();
+    result *=
+            A.at<float>(0, 0) * A.at<float>(1, 0) / (A.at<float>(0, 1) * A.at<float>(1, 1));
+    return result;
+}
+
+static float inline pointDistance2(const Point &A, const Point &B) {
+    return float(((B.x - A.x) * (B.x - A.x) + (B.y - A.y) * (B.y - A.y)));
+}
+
+static float getMinAnglePI(float alpha, float beta) {
+    auto pi = float(CV_PI);
+    auto pi2 = float(2.0 * CV_PI);
+
+    // normalize data in [0, 2*pi]
+    float a = fmod(alpha + pi2, pi2);
+    float b = fmod(beta + pi2, pi2);
+
+    // normalize data in [0, pi]
+    if (a > pi)
+        a -= pi;
+    if (b > pi)
+        b -= pi;
+
+    if (a > b)
+        swap(a, b);
+
+    float diff1 = b - a;
+    float diff2 = pi - diff1;
+
+    return min(diff1, diff2);
+}
+
+// ellipse data
+struct EllipseData {
+    bool isValid;
+    float ta, tb;
+    float ra, rb;
+    Point2f Ma, Mb, Cab;
+    std::vector<float> Sa, Sb;
+};
+
+// implement of ellipse detector
+class EllipseDetectorImpl {
+
+    // preprocessing - Gaussian Smooth.
+    Size _kernelSize; // size of the Gaussian filter
+    double _sigma; // sigma of the Gaussian filter
+
+    // selection strategy - Step 1 - Discard noisy or straight arcs.
+    int _minEdgeLength; // minimum edge size
+    float _minOrientedRectSide; // minimum size of the oriented bounding box containing the arc
+
+    // selection strategy - Step 2 - Remove according to mutual convexity.
+    float _positionThreshold;
+
+    // selection strategy - Step 3 - Number of points considered for slope estimation when estimating the center.
+    unsigned _uNs; // find at most Ns parallel chords
+
+    // selection strategy - Step 3 - Discard pairs of arcs if their estimated center is not close enough
+    float _maxCenterDistance; // maximum distance in pixel between 2 center points
+    float _maxCenterDistance2; // pow(_maxCenterDistance, 2)
+
+    // validation - Points within a threshold are considered to lie on the ellipse contour.
+    float _maxDistanceToEllipseContour;  // maximum distance between a point and the contour
+
+    // validation - Assign a score.
+    float _minScore; // minimum score to confirm a detection
+    float _minReliability; // minimum auxiliary score to confirm a detection
+
+    // auxiliary variables
+    Size _imgSize; // input image size
+
+    int ACC_N_SIZE, ACC_R_SIZE, ACC_A_SIZE; // size of accumulator
+    int *accN, *accR, *accA; // pointer to accumulator
+
+public:
+    float countsOfFindEllipse;
+    float countsOfGetFastCenter;
+
+    EllipseDetectorImpl();
+
+    ~EllipseDetectorImpl() = default;
+
+    // detect the ellipses in the gray image
+    void detect(Mat1b &image, std::vector<Ellipse> &ellipses);
+
+    // set the parameters of the detector
+    void setParameters(float maxCenterDistance, float minScore, float minReliability);
+
+private:
+    // keys for hash table
+    static const ushort PAIR_12 = 0x00;
+    static const ushort PAIR_23 = 0x01;
+    static const ushort PAIR_34 = 0x02;
+    static const ushort PAIR_14 = 0x03;
+
+    static uint inline generateKey(uchar pair, ushort u, ushort v);
+
+    void preProcessing(Mat1b &image, Mat1b &dp, Mat1b &dn);
+
+    void clusterEllipses(std::vector<Ellipse> &ellipses);
+
+    static float
+    getMedianSlope(std::vector<Point2f> &med, Point2f &centers, std::vector<float> &slopes);
+
+    void getFastCenter(std::vector<Point> &e1, std::vector<Point> &e2, EllipseData &data);
+
+    void detectEdges13(Mat1b &DP, VVP &points_1, VVP &points_3);
+
+    void detectEdges24(Mat1b &DN, VVP &points_2, VVP &points_4);
+
+    void
+    findEllipses(Point2f &center, VP &edge_i, VP &edge_j, VP &edge_k, EllipseData &data_ij,
+                 EllipseData &data_ik, std::vector<Ellipse> &ellipses);
+
+    static Point2f getCenterCoordinates(EllipseData &data_ij, EllipseData &data_ik);
+
+    void
+    getTriplets124(VVP &pi, VVP &pj, VVP &pk, std::unordered_map<uint, EllipseData> &data,
+                   std::vector<Ellipse> &ellipses);
+
+    void
+    getTriplets231(VVP &pi, VVP &pj, VVP &pk, std::unordered_map<uint, EllipseData> &data,
+                   std::vector<Ellipse> &ellipses);
+
+    void
+    getTriplets342(VVP &pi, VVP &pj, VVP &pk, std::unordered_map<uint, EllipseData> &data,
+                   std::vector<Ellipse> &ellipses);
+
+    void
+    getTriplets413(VVP &pi, VVP &pj, VVP &pk, std::unordered_map<uint, EllipseData> &data,
+                   std::vector<Ellipse> &ellipses);
+
+    static void labeling(Mat1b &image, VVP &segments, int minLength);
+};
+
+EllipseDetectorImpl::EllipseDetectorImpl() {
+    // Default Parameters Settings
+    _kernelSize = Size(5, 5);
+    _sigma = 1.0;
+    _positionThreshold = 1.0f;
+    _maxCenterDistance = 100.0f * 0.05f;
+    _maxCenterDistance2 = _maxCenterDistance * _maxCenterDistance;
+    _minEdgeLength = 16;
+    _minOrientedRectSide = 3.0f;
+    _maxDistanceToEllipseContour = 0.1f;
+    _minScore = 0.7f;
+    _minReliability = 0.5;
+    _uNs = 16;
+}
+
+void EllipseDetectorImpl::setParameters(float maxCenterDistance, float minScore,
+                                        float minReliability) {
+    _maxCenterDistance = maxCenterDistance;
+    _minScore = minScore;
+    _minReliability = minReliability;
+
+    _maxCenterDistance2 = _maxCenterDistance * _maxCenterDistance;
+}
+
+uint inline EllipseDetectorImpl::generateKey(uchar pair, ushort u, ushort v) {
+    return (pair << 30) + (u << 15) + v;
+}
+
+float EllipseDetectorImpl::getMedianSlope(std::vector<Point2f> &med, Point2f &centers,
+                                          std::vector<float> &slopes) {
+    // med		: vector of points
+    // centers  : centroid of the points in med
+    // slopes	: vector of the slopes
+
+    size_t pointCount = med.size();
+    // CV_Assert(pointCount >= 2);
+
+    size_t halfSize = pointCount >> 1;
+    size_t quarterSize = halfSize >> 1;
+
+    std::vector<float> xx, yy;
+    slopes.reserve(halfSize);
+    xx.reserve(pointCount);
+    yy.reserve(pointCount);
+
+    for (unsigned i = 0; i < halfSize; i++) {
+        Point2f &p1 = med[i];
+        Point2f &p2 = med[halfSize + i];
+
+        xx.push_back(p1.x);
+        xx.push_back(p2.x);
+        yy.push_back(p1.y);
+        yy.push_back(p2.y);
+
+        float den = (p2.x - p1.x);
+        float num = (p2.y - p1.y);
+
+        den = (std::fabs(den) >= 1e-5) ? den : 0.00001f;  // FIXIT: algorithm is not reliable
+
+        slopes.push_back(num / den);
+    }
+
+    nth_element(slopes.begin(), slopes.begin() + quarterSize, slopes.end());
+    nth_element(xx.begin(), xx.begin() + halfSize, xx.end());
+    nth_element(yy.begin(), yy.begin() + halfSize, yy.end());
+    centers.x = xx[halfSize];
+    centers.y = yy[halfSize];
+
+    return slopes[quarterSize];
+}
+
+void EllipseDetectorImpl::getFastCenter(std::vector<Point> &e1, std::vector<Point> &e2,
+                                        EllipseData &data) {
+    countsOfGetFastCenter++;
+    data.isValid = true;
+
+    auto size_1 = unsigned(e1.size());
+    auto size_2 = unsigned(e2.size());
+
+    unsigned hsize_1 = size_1 >> 1;
+    unsigned hsize_2 = size_2 >> 1;
+
+    Point &med1 = e1[hsize_1];
+    Point &med2 = e2[hsize_2];
+
+    Point2f M12, M34;
+    float q2, q4;
+
+    {
+        auto dx_ref = float(e1[0].x - med2.x);
+        auto dy_ref = float(e1[0].y - med2.y);
+
+        if (dx_ref == 0)
+            dx_ref = 0.00001f;
+
+        float m_ref = dy_ref / dx_ref;
+        data.ra = m_ref;
+
+        // find points with same slope as reference
+        std::vector<Point2f> med;
+        med.reserve(hsize_2);
+
+        unsigned minPoints = (_uNs < hsize_2) ? _uNs : hsize_2;
+
+        std::vector<uint> indexes(minPoints);
+        if (_uNs < hsize_2) {
+            unsigned iSzBin = hsize_2 / unsigned(_uNs);
+            unsigned iIdx = hsize_2 + (iSzBin / 2);
+
+            for (unsigned i = 0; i < _uNs; i++) {
+                indexes[i] = iIdx;
+                iIdx += iSzBin;
+            }
+        } else
+            iota(indexes.begin(), indexes.end(), hsize_2);
+
+        for (uint ii = 0; ii < minPoints; ii++) {
+            uint i = indexes[ii];
+
+            auto x1 = float(e2[i].x);
+            auto y1 = float(e2[i].y);
+
+            uint begin = 0;
+            uint end = size_1 - 1;
+
+            auto xb = float(e1[begin].x);
+            auto yb = float(e1[begin].y);
+            float res_begin = ((xb - x1) * dy_ref) - ((yb - y1) * dx_ref);
+            int sign_begin = signal(res_begin);
+            if (sign_begin == 0) {
+                med.emplace_back((xb + x1) * 0.5f, (yb + y1) * 0.5f);
+                continue;
+            }
+
+            auto xe = float(e1[end].x);
+            auto ye = float(e1[end].y);
+            float res_end = ((xe - x1) * dy_ref) - ((ye - y1) * dx_ref);
+            int sign_end = signal(res_end);
+            if (sign_end == 0) {
+                med.emplace_back((xe + x1) * 0.5f, (ye + y1) * 0.5f);
+                continue;
+            }
+
+            if ((sign_begin + sign_end) != 0)
+                continue;
+
+
+            // search parallel arc
+            uint j = (begin + end) >> 1;
+            while (end - begin > 2) {
+                auto x2 = float(e1[j].x);
+                auto y2 = float(e1[j].y);
+                float res = ((x2 - x1) * dy_ref) - ((y2 - y1) * dx_ref);
+                int sign_res = signal(res);
+
+                if (sign_res == 0) {
+                    med.emplace_back((x2 + x1) * 0.5f, (y2 + y1) * 0.5f);
+                    break;
+                }
+
+                if (sign_res + sign_begin == 0) {
+                    sign_end = sign_res;
+                    end = j;
+                } else {
+                    sign_begin = sign_res;
+                    begin = j;
+                }
+                j = (begin + end) >> 1;
+            }
+
+            med.emplace_back((e1[j].x + x1) * 0.5f, (e1[j].y + y1) * 0.5f);
+        }
+
+        if (med.size() < 2) {
+            data.isValid = false;
+            return;
+        }
+
+        q2 = getMedianSlope(med, M12, data.Sa);
+    }
+
+    {
+        auto dx_ref = float(med1.x - e2[0].x);
+        auto dy_ref = float(med1.y - e2[0].y);
+
+        if (dx_ref == 0)
+            dx_ref = 0.00001f;
+
+        float m_ref = dy_ref / dx_ref;
+        data.rb = m_ref;
+
+        // find points with same slope as reference
+        std::vector<Point2f> med;
+        med.reserve(hsize_1);
+
+        uint minPoints = (_uNs < hsize_1) ? _uNs : hsize_1;
+
+        std::vector<uint> indexes(minPoints);
+        if (_uNs < hsize_1) {
+            unsigned iSzBin = hsize_1 / unsigned(_uNs);
+            unsigned iIdx = hsize_1 + (iSzBin / 2);
+
+            for (unsigned i = 0; i < _uNs; i++) {
+                indexes[i] = iIdx;
+                iIdx += iSzBin;
+            }
+        } else
+            iota(indexes.begin(), indexes.end(), hsize_1);
+
+
+        for (uint ii = 0; ii < minPoints; ii++) {
+            uint i = indexes[ii];
+
+            auto x1 = float(e1[i].x);
+            auto y1 = float(e1[i].y);
+
+            uint begin = 0;
+            uint end = size_2 - 1;
+
+            auto xb = float(e2[begin].x);
+            auto yb = float(e2[begin].y);
+            float res_begin = ((xb - x1) * dy_ref) - ((yb - y1) * dx_ref);
+            int sign_begin = signal(res_begin);
+            if (sign_begin == 0) {
+                med.emplace_back((xb + x1) * 0.5f, (yb + y1) * 0.5f);
+                continue;
+            }
+
+            auto xe = float(e2[end].x);
+            auto ye = float(e2[end].y);
+            float res_end = ((xe - x1) * dy_ref) - ((ye - y1) * dx_ref);
+            int sign_end = signal(res_end);
+            if (sign_end == 0) {
+                med.emplace_back((xe + x1) * 0.5f, (ye + y1) * 0.5f);
+                continue;
+            }
+
+            if ((sign_begin + sign_end) != 0)
+                continue;
+
+            uint j = (begin + end) >> 1;
+
+            while (end - begin > 2) {
+                auto x2 = float(e2[j].x);
+                auto y2 = float(e2[j].y);
+                float res = ((x2 - x1) * dy_ref) - ((y2 - y1) * dx_ref);
+                int sign_res = signal(res);
+
+                if (sign_res == 0) {
+                    med.emplace_back((x2 + x1) * 0.5f, (y2 + y1) * 0.5f);
+                    break;
+                }
+
+                if (sign_res + sign_begin == 0) {
+                    sign_end = sign_res;
+                    end = j;
+                } else {
+                    sign_begin = sign_res;
+                    begin = j;
+                }
+                j = (begin + end) >> 1;
+            }
+
+            med.emplace_back((e2[j].x + x1) * 0.5f, (e2[j].y + y1) * 0.5f);
+        }
+
+        if (med.size() < 2) {
+            data.isValid = false;
+            return;
+        }
+        q4 = getMedianSlope(med, M34, data.Sb);
+    }
+
+    if (q2 == q4) {
+        data.isValid = false;
+        return;
+    }
+
+    float invDen = 1 / (q2 - q4);
+    data.Cab.x = (M34.y - q4 * M34.x - M12.y + q2 * M12.x) * invDen;
+    data.Cab.y = (q2 * M34.y - q4 * M12.y + q2 * q4 * (M12.x - M34.x)) * invDen;
+    data.ta = q2;
+    data.tb = q4;
+    data.Ma = M12;
+    data.Mb = M34;
+}
+
+Point2f
+EllipseDetectorImpl::getCenterCoordinates(EllipseData &data_ij, EllipseData &data_ik) {
+    float xx[7];
+    float yy[7];
+
+    xx[0] = data_ij.Cab.x;
+    xx[1] = data_ik.Cab.x;
+    yy[0] = data_ij.Cab.y;
+    yy[1] = data_ik.Cab.y;
+
+    {
+        // 1-1
+        float q2 = data_ij.ta;
+        float q4 = data_ik.ta;
+        Point2f &M12 = data_ij.Ma;
+        Point2f &M34 = data_ik.Ma;
+
+        float invDen = 1 / (q2 - q4);
+        xx[2] = (M34.y - q4 * M34.x - M12.y + q2 * M12.x) * invDen;
+        yy[2] = (q2 * M34.y - q4 * M12.y + q2 * q4 * (M12.x - M34.x)) * invDen;
+    }
+
+    {
+        // 1-2
+        float q2 = data_ij.ta;
+        float q4 = data_ik.tb;
+        Point2f &M12 = data_ij.Ma;
+        Point2f &M34 = data_ik.Mb;
+
+        float invDen = 1 / (q2 - q4);
+        xx[3] = (M34.y - q4 * M34.x - M12.y + q2 * M12.x) * invDen;
+        yy[3] = (q2 * M34.y - q4 * M12.y + q2 * q4 * (M12.x - M34.x)) * invDen;
+    }
+
+    {
+        // 2-2
+        float q2 = data_ij.tb;
+        float q4 = data_ik.tb;
+        Point2f &M12 = data_ij.Mb;
+        Point2f &M34 = data_ik.Mb;
+
+        float invDen = 1 / (q2 - q4);
+        xx[4] = (M34.y - q4 * M34.x - M12.y + q2 * M12.x) * invDen;
+        yy[4] = (q2 * M34.y - q4 * M12.y + q2 * q4 * (M12.x - M34.x)) * invDen;
+    }
+
+    {
+        // 2-1
+        float q2 = data_ij.tb;
+        float q4 = data_ik.ta;
+        Point2f &M12 = data_ij.Mb;
+        Point2f &M34 = data_ik.Ma;
+
+        float invDen = 1 / (q2 - q4);
+        xx[5] = (M34.y - q4 * M34.x - M12.y + q2 * M12.x) * invDen;
+        yy[5] = (q2 * M34.y - q4 * M12.y + q2 * q4 * (M12.x - M34.x)) * invDen;
+    }
+
+    xx[6] = (xx[0] + xx[1]) * 0.5f;
+    yy[6] = (yy[0] + yy[1]) * 0.5f;
+
+
+    // median
+    std::nth_element(xx, xx + 3, xx + 7);
+    std::nth_element(yy, yy + 3, yy + 7);
+    float xc = xx[3];
+    float yc = yy[3];
+
+    return {xc, yc};
+}
+
+
+void EllipseDetectorImpl::labeling(Mat1b &image, VVP &segments, int minLength) {
+    const int RG_STACK_SIZE = 2048;
+    int stackInt[RG_STACK_SIZE];
+    Point stackPoint[RG_STACK_SIZE];
+
+    Mat_<uchar> image_clone = image.clone();
+    Size imgSize = image.size();
+    int h = imgSize.height, w = imgSize.width;
+
+    Point point;
+    for (int y = 0; y < h; ++y) {
+        for (int x = 0; x < w; ++x) {
+            if ((image_clone(y, x)) != 0) {
+                // for each point
+                int curInt = 0;
+                int i = x + y * w;
+                stackInt[curInt] = i;
+                curInt++;
+
+                // clear point list
+                int curPoint = 0;
+                while (curInt > 0) {
+                    curInt--;
+                    i = stackInt[curInt];
+                    int x2 = i % w;
+                    int y2 = i / w;
+
+                    point.x = x2;
+                    point.y = y2;
+
+                    if ((image_clone(y2, x2))) {
+                        stackPoint[curPoint] = point;
+                        curPoint++;
+                        image_clone(y2, x2) = 0;
+                    }
+
+                    // 4 directions
+                    if (x2 > 0 && (image_clone(y2, x2 - 1) != 0)) {
+                        stackInt[curInt] = i - 1;
+                        curInt++;
+                    }
+                    if (y2 > 0 && (image_clone(y2 - 1, x2) != 0)) {
+                        stackInt[curInt] = i - w;
+                        curInt++;
+                    }
+                    if (y2 < h - 1 && (image_clone(y2 + 1, x2) != 0)) {
+                        stackInt[curInt] = i + w;
+                        curInt++;
+                    }
+                    if (x2 < w - 1 && (image_clone(y2, x2 + 1) != 0)) {
+                        stackInt[curInt] = i + 1;
+                        curInt++;
+                    }
+
+                    // 8 directions
+                    if (x2 > 0 && y2 > 0 && (image_clone(y2 - 1, x2 - 1) != 0)) {
+                        stackInt[curInt] = i - w - 1;
+                        curInt++;
+                    }
+                    if (x2 > 0 && y2 < h - 1 && (image_clone(y2 + 1, x2 - 1) != 0)) {
+                        stackInt[curInt] = i + w - 1;
+                        curInt++;
+                    }
+                    if (x2 < w - 1 && y2 > 0 && (image_clone(y2 - 1, x2 + 1) != 0)) {
+                        stackInt[curInt] = i - w + 1;
+                        curInt++;
+                    }
+                    if (x2 < w - 1 && y2 < h - 1 && (image_clone(y2 + 1, x2 + 1) != 0)) {
+                        stackInt[curInt] = i + w + 1;
+                        curInt++;
+                    }
+                }
+
+                if (curPoint >= minLength) {
+                    std::vector<Point> component;
+                    component.reserve(curPoint);
+                    for (int j = 0; j < curPoint; j++)
+                        component.push_back(stackPoint[j]);
+                    segments.push_back(component);
+                }
+            }
+        }
+    }
+}
+
+void EllipseDetectorImpl::detectEdges13(Mat1b &DP, VVP &points_1, VVP &points_3) {
+    // vector of connected edge points
+    VVP contours;
+    int countEdges = 0;
+    // labeling 8-connected edge points, discarding edge too small
+    labeling(DP, contours, _minEdgeLength); // label point on the same arc
+    int contourSize = int(contours.size());
+
+    // for each edge
+    for (int i = 0; i < contourSize; i++) {
+        VP &edgeSegment = contours[i];
+
+        // selection strategy - constraint on axes aspect ratio
+        RotatedRect oriented = minAreaRect(edgeSegment);
+        float orMin = min(oriented.size.width, oriented.size.height);
+
+        if (orMin < _minOrientedRectSide) {
+            countEdges++;
+            continue;
+        }
+
+        // order edge points of the same arc
+        sort(edgeSegment.begin(), edgeSegment.end(), sortPoint);
+        int edgeSegmentSize = unsigned(edgeSegment.size());
+
+        // get extrema of the arc
+        Point &left = edgeSegment[0];
+        Point &right = edgeSegment[edgeSegmentSize - 1];
+
+        // find convexity
+        int countTop = 0;
+        int lx = left.x;
+        for (int k = 1; k < edgeSegmentSize; ++k) {
+            if (edgeSegment[k].x == lx)
+                continue;
+            countTop += (edgeSegment[k].y - left.y);
+            lx = edgeSegment[k].x;
+        }
+
+        int width = abs(right.x - left.x) + 1;
+        int height = abs(right.y - left.y) + 1;
+        int countBottom = (width * height) - edgeSegmentSize - countTop;
+
+        if (countBottom > countTop)
+            points_1.push_back(edgeSegment);
+        else if (countBottom < countTop)
+            points_3.push_back(edgeSegment);
+    }
+}
+
+void EllipseDetectorImpl::detectEdges24(Mat1b &DN, VVP &points_2, VVP &points_4) {
+    // vector of connected edge points
+    VVP contours;
+    int countEdges = 0;
+    // labeling 8-connected edge points, discarding edge too small
+    labeling(DN, contours, _minEdgeLength); // label point on the same arc
+    int contourSize = int(contours.size());
+
+    // for each edge
+    for (int i = 0; i < contourSize; i++) {
+        VP &edgeSegment = contours[i];
+
+        // selection strategy - constraint on axes aspect ratio
+        RotatedRect oriented = minAreaRect(edgeSegment);
+        float orMin = min(oriented.size.width, oriented.size.height);
+
+        if (orMin < _minOrientedRectSide) {
+            countEdges++;
+            continue;
+        }
+
+        // order edge points of the same arc
+        sort(edgeSegment.begin(), edgeSegment.end(), sortPoint);
+        int edgeSegmentSize = unsigned(edgeSegment.size());
+
+        // get extrema of the arc
+        Point &left = edgeSegment[0];
+        Point &right = edgeSegment[edgeSegmentSize - 1];
+
+        // find convexity
+        int countBottom = 0;
+        int lx = left.x;
+        for (int k = 0; k < edgeSegmentSize; ++k) {
+            if (edgeSegment[k].x == lx)
+                continue;
+            countBottom += (left.y - edgeSegment[k].y);
+            lx = edgeSegment[k].x;
+        }
+
+        int width = abs(right.x - left.x) + 1;
+        int height = abs(right.y - left.y) + 1;
+        int countTop = (width * height) - edgeSegmentSize - countBottom;
+
+        if (countBottom > countTop)
+            points_2.push_back(edgeSegment);
+        else if (countBottom < countTop)
+            points_4.push_back(edgeSegment);
+    }
+}
+
+#define T124 pjf,pjm,pjl,pif,pim,pil
+#define T231 pil,pim,pif,pjf,pjm,pjl
+#define T342 pif,pim,pil,pjf,pjm,pjl
+#define T413 pif,pim,pil,pjl,pjm,pjf
+
+void EllipseDetectorImpl::getTriplets124(VVP &pi, VVP &pj, VVP &pk,
+                                         std::unordered_map<uint, EllipseData> &data,
+                                         std::vector<Ellipse> &ellipses) {
+    // get arcs length
+    auto sz_i = ushort(pi.size());
+    auto sz_j = ushort(pj.size());
+    auto sz_k = ushort(pk.size());
+
+    // for each edge i
+    for (ushort i = 0; i < sz_i; i++) {
+        VP &edge_i = pi[i];
+        auto sz_ei = ushort(edge_i.size());
+
+        Point &pif = edge_i[0];
+        Point &pim = edge_i[sz_ei / 2];
+        Point &pil = edge_i[sz_ei - 1];
+
+        // 1 -> reverse 1
+        VP rev_i(edge_i.size());
+        reverse_copy(edge_i.begin(), edge_i.end(), rev_i.begin());
+
+        // for each edge j
+        for (ushort j = 0; j < sz_j; ++j) {
+            VP &edge_j = pj[j];
+            auto sz_ej = ushort(edge_j.size());
+
+            Point &pjf = edge_j[0];
+            Point &pjm = edge_j[sz_ej / 2];
+            Point &pjl = edge_j[sz_ej - 1];
+
+            // constraints on position
+            if (pjl.x > pif.x + _positionThreshold)
+                continue;
+
+            // constraints on CNC
+            const float CNC_THRESHOLD = 0.3f;
+            if (fabs(valueOfPoints(T124) - 1) > CNC_THRESHOLD)
+                continue;
+
+            uint key_ij = generateKey(PAIR_12, i, j);
+
+            // for each edge k
+            for (ushort k = 0; k < sz_k; ++k) {
+                VP &edge_k = pk[k];
+                auto sz_ek = ushort(edge_k.size());
+
+                Point &pkl = edge_k[sz_ek - 1];
+
+                // constraints on position
+                if (pkl.y < pil.y - _positionThreshold)
+                    continue;
+
+                uint key_ik = generateKey(PAIR_14, i, k);
+
+                // find centers
+                EllipseData data_ij, data_ik;
+
+                // if the data for the pair i-j have not been computed yet
+                if (data.count(key_ij) == 0) {
+                    getFastCenter(edge_j, rev_i, data_ij);
+                    // insert computed data in the hash table
+                    data.insert(std::pair<uint, EllipseData>(key_ij, data_ij));
+                } else {
+                    // otherwise, just lookup the data in the hash table
+                    data_ij = data.at(key_ij);
+                }
+
+                // if the data for the pair i-k have not been computed yet
+                if (data.count(key_ik) == 0) {
+                    getFastCenter(edge_i, edge_k, data_ik);
+                    // insert computed data in the hash table
+                    data.insert(std::pair<uint, EllipseData>(key_ik, data_ik));
+                } else {
+                    // otherwise, just lookup the data in the hash table
+                    data_ik = data.at(key_ik);
+                }
+
+                // invalid centers
+                if (!data_ij.isValid || !data_ik.isValid)
+                    continue;
+
+                // selection strategy - Step 3.
+                // the computed centers are not close enough
+                if (pointDistance2(data_ij.Cab, data_ik.Cab) > _maxCenterDistance2)
+                    continue;
+
+                // find ellipse parameters
+                // get the coordinates of the center (xc, yc)
+                Point2f center = getCenterCoordinates(data_ij, data_ik);
+                // find remaining parameters (A, B, rho)
+                findEllipses(center, edge_i, edge_j, edge_k, data_ij, data_ik, ellipses);
+            }
+        }
+    }
+}
+
+void EllipseDetectorImpl::getTriplets231(VVP &pi, VVP &pj, VVP &pk,
+                                         std::unordered_map<uint, EllipseData> &data,
+                                         std::vector<Ellipse> &ellipses) {
+    // get arc length
+    auto sz_i = ushort(pi.size());
+    auto sz_j = ushort(pj.size());
+    auto sz_k = ushort(pk.size());
+
+    // for each edge i
+    for (ushort i = 0; i < sz_i; i++) {
+        VP &edge_i = pi[i];
+        auto sz_ei = ushort(edge_i.size());
+
+        Point &pif = edge_i[0];
+        Point &pim = edge_i[sz_ei / 2];
+        Point &pil = edge_i[sz_ei - 1];
+
+        // 2 -> reverse 2
+        VP rev_i(edge_i.size());
+        reverse_copy(edge_i.begin(), edge_i.end(), rev_i.begin());
+
+        // for each edge j
+        for (ushort j = 0; j < sz_j; ++j) {
+            VP &edge_j = pj[j];
+            auto sz_ej = ushort(edge_j.size());
+
+            Point &pjf = edge_j[0];
+            Point &pjm = edge_j[sz_ej / 2];
+            Point &pjl = edge_j[sz_ej - 1];
+
+            // constraints on position
+            if (pjf.y < pif.y - _positionThreshold)
+                continue;
+
+            // constraints on CNC
+            const float CNC_THRESHOLD = 0.3f;
+            if (fabs(valueOfPoints(T231) - 1) > CNC_THRESHOLD)
+                continue;
+
+            // 3 -> reverse 3
+            VP rev_j(edge_j.size());
+            reverse_copy(edge_j.begin(), edge_j.end(), rev_j.begin());
+
+            uint key_ij = generateKey(PAIR_23, i, j);
+
+            // for each edge k
+            for (ushort k = 0; k < sz_k; ++k) {
+                VP &edge_k = pk[k];
+
+                Point &pkf = edge_k[0];
+
+                // constraints on position
+                if (pkf.x < pil.x - _positionThreshold)
+                    continue;
+
+                uint key_ik = generateKey(PAIR_12, k, i);
+
+                // find centers
+                EllipseData data_ij, data_ik;
+
+                // if the data for the pair i-j have not been computed yet
+                if (data.count(key_ij) == 0) {
+                    getFastCenter(rev_i, rev_j, data_ij);
+                    // insert computed date in the hash table
+                    data.insert(std::pair<uint, EllipseData>(key_ij, data_ij));
+                } else {
+                    // otherwise, just lookup the data in the hash table
+                    data_ij = data.at(key_ij);
+                }
+
+                // if the data for the pair i-k have not been computed yet
+                if (data.count(key_ik) == 0) {
+                    // 1 -> reverse 1
+                    VP rev_k(edge_k.size());
+                    reverse_copy(edge_k.begin(), edge_k.end(), rev_k.begin());
+
+                    getFastCenter(edge_i, rev_k, data_ik);
+                    data.insert(std::pair<uint, EllipseData>(key_ik, data_ik));
+                } else {
+                    // otherwise, just lookup the data in the hash table
+                    data_ik = data.at(key_ik);
+                }
+
+                // invalid centers
+                if (!data_ij.isValid || !data_ik.isValid)
+                    continue;
+
+                // selection strategy - Step 3.
+                // the computed centers are not close enough
+                if (pointDistance2(data_ij.Cab, data_ik.Cab) > _maxCenterDistance2)
+                    continue;
+
+                // find ellipse parameters
+                // get the coordinates of the center (xc, yc)
+                Point2f center = getCenterCoordinates(data_ij, data_ik);
+                // find remaining parameters (A, B, rho)
+                findEllipses(center, edge_i, edge_j, edge_k, data_ij, data_ik, ellipses);
+            }
+        }
+    }
+}
+
+void EllipseDetectorImpl::getTriplets342(VVP &pi, VVP &pj, VVP &pk,
+                                         std::unordered_map<uint, EllipseData> &data,
+                                         std::vector<Ellipse> &ellipses) {
+    // get arcs length
+    auto sz_i = ushort(pi.size());
+    auto sz_j = ushort(pj.size());
+    auto sz_k = ushort(pk.size());
+
+    // for each edge i
+    for (ushort i = 0; i < sz_i; i++) {
+        VP &edge_i = pi[i];
+        auto sz_ei = ushort(edge_i.size());
+
+        Point &pif = edge_i[0];
+        Point &pim = edge_i[sz_ei / 2];
+        Point &pil = edge_i[sz_ei - 1];
+
+        // 3 -> reverse 3
+        VP rev_i(edge_i.size());
+        reverse_copy(edge_i.begin(), edge_i.end(), rev_i.begin());
+
+        // for each edge j
+        for (ushort j = 0; j < sz_j; ++j) {
+            VP &edge_j = pj[j];
+            auto sz_ej = ushort(edge_j.size());
+
+            Point &pjf = edge_j[0];
+            Point &pjm = edge_j[sz_ej / 2];
+            Point &pjl = edge_j[sz_ej - 1];
+
+            // constraints on position
+            if (pjf.x < pil.x - _positionThreshold)
+                continue;
+
+            // constraints on CNC
+            const float CNC_THRESHOLD = 0.3f;
+            if (fabs(valueOfPoints(T342) - 1) > CNC_THRESHOLD)
+                continue;
+
+            // 4 -> reverse 4
+            VP rev_j(edge_j.size());
+            reverse_copy(edge_j.begin(), edge_j.end(), rev_j.begin());
+
+            uint key_ij = generateKey(PAIR_34, i, j);
+
+            // for each edge k
+            for (ushort k = 0; k < sz_k; ++k) {
+                VP &edge_k = pk[k];
+
+                Point &pkf = edge_k[0];
+
+                // constraints on position
+                if (pkf.y > pif.y + _positionThreshold)
+                    continue;
+
+                uint key_ik = generateKey(PAIR_23, k, i);
+
+                // find centers
+                EllipseData data_ij, data_ik;
+
+                // if the data for the pair i-j have not been computed yet
+                if (data.count(key_ij) == 0) {
+                    getFastCenter(edge_i, rev_j, data_ij);
+                    // insert computed data in the hash table
+                    data.insert(std::pair<uint, EllipseData>(key_ij, data_ij));
+                } else {
+                    // otherwise, just lookup the data in the hash table
+                    data_ij = data.at(key_ij);
+                }
+
+                // if the data for the pair i-k have not been computed yet
+                if (data.count(key_ik) == 0) {
+                    // 2 -> reverse 2
+                    VP rev_k(edge_k.size());
+                    reverse_copy(edge_k.begin(), edge_k.end(), rev_k.begin());
+
+                    getFastCenter(rev_i, rev_k, data_ik);
+                    data.insert(std::pair<uint, EllipseData>(key_ik, data_ik));
+                } else {
+                    // otherwise, just lookup the data in the hash table
+                    data_ik = data.at(key_ik);
+                }
+
+                // invalid centers
+                if (!data_ij.isValid || !data_ik.isValid)
+                    continue;
+
+                // selection strategy - Step 3.
+                // the computed centers are not close enough
+                if (pointDistance2(data_ij.Cab, data_ik.Cab) > _maxCenterDistance2)
+                    continue;
+
+                // find ellipse parameters
+                // get the coordinates of the center (xc, yc)
+                Point2f center = getCenterCoordinates(data_ij, data_ik);
+                // find remaining parameters (A, B, rho)
+                findEllipses(center, edge_i, edge_j, edge_k, data_ij, data_ik, ellipses);
+            }
+        }
+
+    }
+}
+
+void EllipseDetectorImpl::getTriplets413(VVP &pi, VVP &pj, VVP &pk,
+                                         std::unordered_map<uint, EllipseData> &data,
+                                         std::vector<Ellipse> &ellipses) {
+    // get arch length
+    auto sz_i = ushort(pi.size());
+    auto sz_j = ushort(pj.size());
+    auto sz_k = ushort(pk.size());
+
+    // for each edge i
+    for (ushort i = 0; i < sz_i; i++) {
+        VP &edge_i = pi[i];
+        auto sz_ei = ushort(edge_i.size());
+
+        Point &pif = edge_i[0];
+        Point &pim = edge_i[sz_ei / 2];
+        Point &pil = edge_i[sz_ei - 1];
+
+        // 4 -> reverse 4
+        VP rev_i(edge_i.size());
+        reverse_copy(edge_i.begin(), edge_i.end(), rev_i.begin());
+
+        // for each edge j
+        for (ushort j = 0; j < sz_j; ++j) {
+            VP &edge_j = pj[j];
+            auto sz_ej = ushort(edge_j.size());
+
+            Point &pjf = edge_j[0];
+            Point &pjm = edge_j[sz_ej / 2];
+            Point &pjl = edge_j[sz_ej - 1];
+
+            // constraints on position
+            if (pjl.y > pil.y + _positionThreshold)
+                continue;
+
+            // constraints on CNC
+            const float CNC_THRESHOLD = 0.3f;
+            if (fabs(valueOfPoints(T413) - 1) > CNC_THRESHOLD)
+                continue;
+
+            uint key_ij = generateKey(PAIR_14, j, i);
+
+            // for each edge k
+            for (ushort k = 0; k < sz_k; ++k) {
+                VP &edge_k = pk[k];
+                auto sz_ek = ushort(edge_k.size());
+
+                Point &pkl = edge_k[sz_ek - 1];
+
+                // constraints on position
+                if (pkl.x > pif.x + _positionThreshold)
+                    continue;
+
+                uint key_ik = generateKey(PAIR_34, k, i);
+
+                // find centers
+                EllipseData data_ij, data_ik;
+
+                // if the data for the pair i-j have not been computed yet
+                if (data.count(key_ij) == 0) {
+                    getFastCenter(edge_i, edge_j, data_ij);
+                    // insert computed date in the hash table
+                    data.insert(std::pair<uint, EllipseData>(key_ij, data_ij));
+                } else {
+                    // otherwise, just lookup the data in the hash table
+                    data_ij = data.at(key_ij);
+                }
+
+                // if the data for the pair i-k have not been computed yet
+                if (data.count(key_ik) == 0) {
+                    getFastCenter(rev_i, edge_k, data_ik);
+                    data.insert(std::pair<uint, EllipseData>(key_ik, data_ik));
+                } else {
+                    // otherwise, just lookup the data in the hash table
+                    data_ik = data.at(key_ik);
+                }
+
+                // invalid centers
+                if (!data_ij.isValid || !data_ik.isValid)
+                    continue;
+
+                // selection strategy - Step 3.
+                // the computed centers are not close enough
+                if (pointDistance2(data_ij.Cab, data_ik.Cab) > _maxCenterDistance2)
+                    continue;
+
+                // find ellipse parameters
+                // get the coordinates of the center (xc, yc)
+                Point2f center = getCenterCoordinates(data_ij, data_ik);
+                // find remaining parameters (A, B, rho)
+                findEllipses(center, edge_i, edge_j, edge_k, data_ij, data_ik, ellipses);
+
+            }
+        }
+    }
+}
+
+void EllipseDetectorImpl::preProcessing(Mat1b &image, Mat1b &dp, Mat1b &dn) {
+    // smooth image
+    GaussianBlur(image, image, _kernelSize, _sigma);
+
+    // temp variables
+    Mat1b edges;// edge mask
+    Mat1s dx, dy; // sobel derivatives
+
+    // detect edges
+    Sobel(image, dx, CV_16S, 1, 0, 3, 1, 0, BORDER_REPLICATE);
+    Sobel(image, dy, CV_16S, 0, 1, 3, 1, 0, BORDER_REPLICATE);
+
+    // calculate magnitude of gradient
+    Size imgSize = image.size();
+    edges.create(imgSize);
+    Mat1f magGrad(imgSize.height, imgSize.width, 0.f);
+    float maxGrad(0);
+    for (int i = 0; i < imgSize.height; i++) {
+        auto *tmpMag = magGrad.ptr<float>(i);
+        for (int j = 0; j < imgSize.width; j++) {
+            auto val = float(abs(dx[i][j]) + abs(dy[i][j]));
+            tmpMag[j] = val;
+            maxGrad = (val > maxGrad) ? val : maxGrad;
+        }
+    }
+
+    // set magic numbers
+    const int NUM_BINS = 64;
+    const double PERCENT_OF_PIXEL_NOT_EDGES = 0.9f, RATIO_THRESHOLD = 0.3f;
+
+    // compute histogram
+    int binSize = cvFloor(maxGrad / float(NUM_BINS) + 0.5f) + 1;
+    binSize = max(1, binSize);
+    int bins[NUM_BINS] = {0};
+    for (int i = 0; i < imgSize.height; i++) {
+        auto *tmpMag = magGrad.ptr<float>(i);
+        for (int j = 0; j < imgSize.width; j++)
+            bins[int(tmpMag[j]) / binSize]++;
+    }
+
+    // select the thresholds
+    float total = 0.f;
+    auto target = float(imgSize.height * imgSize.width * PERCENT_OF_PIXEL_NOT_EDGES);
+    int lowTh, highTh(0);
+
+    while (total < target) {
+        total += bins[highTh];
+        highTh++;
+    }
+    highTh = cvFloor(highTh * binSize);
+    lowTh = cvFloor(RATIO_THRESHOLD * float(highTh));
+
+    // buffer
+    int *magBuffer[3];
+    void *buffer = malloc((imgSize.width + 2) * (imgSize.height + 2) +
+                          (imgSize.width + 2) * 3 * sizeof(int));
+    magBuffer[0] = (int *) buffer;
+    magBuffer[1] = magBuffer[0] + imgSize.width + 2;
+    magBuffer[2] = magBuffer[1] + imgSize.width + 2;
+    uchar *map = (uchar *) (magBuffer[2] + imgSize.width + 2);
+    ptrdiff_t mapStep = imgSize.width + 2;
+
+    int maxSize = MAX(1 << 10, imgSize.width * imgSize.height / 10);
+    std::vector<uchar *> stack;
+    stack.resize(maxSize);
+    uchar **stackTop = 0, **stackBottom = 0;
+    stackTop = stackBottom = &stack[0];
+
+    memset(magBuffer[0], 0, (imgSize.width + 2) * sizeof(int));
+    memset(map, 1, mapStep);
+    memset(map + mapStep * (imgSize.height + 1), 1, mapStep);
+
+    Mat magRow;
+    magRow.create(1, imgSize.width, CV_32F);
+
+    // calculate magnitude and angle of gradient, perform non-maxima suppression.
+    // fill the map with one of the following values:
+    // 0 - the pixel might belong to an edge
+    // 1 - the pixel can not belong to an edge
+    // 2 - the pixel does belong to an edge
+    for (int i = 0; i <= imgSize.height; i++) {
+        int *tmpMag = magBuffer[(i > 0) + 1] + 1;
+        const short *tmpDx = (short *) (dx[i]);
+        const short *tmpDy = (short *) (dy[i]);
+        uchar *tmpMap;
+        int prevFlag = 0;
+
+        if (i < imgSize.height) {
+            tmpMag[-1] = tmpMag[imgSize.width] = 0;
+            for (int j = 0; j < imgSize.width; j++)
+                tmpMag[j] = abs(tmpDx[j]) + abs(tmpDy[j]);
+        } else
+            memset(tmpMag - 1, 0, (imgSize.width + 2) * sizeof(int));
+
+        // at the very beginning we do not have a complete ring
+        // buffer of 3 magnitude rows for non-maxima suppression
+        if (i == 0)
+            continue;
+
+        tmpMap = map + mapStep * i + 1;
+        tmpMap[-1] = tmpMap[imgSize.width] = 1;
+
+        tmpMag = magBuffer[1] + 1; // take the central row
+        tmpDx = (short *) (dx[i - 1]);
+        tmpDy = (short *) (dy[i - 1]);
+
+        ptrdiff_t magStep1, magStep2;
+        magStep1 = magBuffer[2] - magBuffer[1];
+        magStep2 = magBuffer[0] - magBuffer[1];
+
+        if ((stackTop - stackBottom) + imgSize.width > maxSize) {
+            int stackSize = (int) (stackTop - stackBottom);
+            maxSize = MAX(maxSize * 3 / 2, maxSize + 8);
+            stack.resize(maxSize);
+            stackBottom = &stack[0];
+            stackTop = stackBottom + stackSize;
+        }
+
+        const int CANNY_SHIFT = 15;
+        const float TAN22_5 = 0.4142135623730950488016887242097f; // tan(22.5) = sqrt(2) - 1
+        const int TG22 = (int) (TAN22_5 * (1 << CANNY_SHIFT) + 0.5);
+
+        // #define CANNY_PUSH(d)    *(d) = (uchar)2, *stack_top++ = (d)
+        // #define CANNY_POP(d)     ((d) = *--stack_top)
+
+        for (int j = 0; j < imgSize.width; j++) {
+            int x = tmpDx[j], y = tmpDy[j];
+            int s = x ^ y;
+            int m = tmpMag[j];
+            x = abs(x), y = abs(y);
+            if (m > lowTh) {
+                int tg22x = x * TG22;
+                int tg67x = tg22x + ((x + x) << CANNY_SHIFT);
+
+                y <<= CANNY_SHIFT;
+                if (y < tg22x) {
+                    if (m > tmpMag[j - 1] && m >= tmpMag[j + 1]) {
+                        if (m > highTh && !prevFlag && tmpMap[j - mapStep] != 2) {
+                            tmpMap[j] = (uchar) 2;
+                            *stackTop++ = (tmpMap + j);
+                            prevFlag = 1;
+                        } else
+                            tmpMap[j] = (uchar) 0;
+                        continue;
+                    }
+                } else if (y > tg67x) {
+                    if (m > tmpMag[j + magStep2] && m >= tmpMag[j + magStep1]) {
+                        if (m > highTh && !prevFlag && tmpMap[j - mapStep] != 2) {
+                            tmpMap[j] = (uchar) 2;
+                            *stackTop++ = (tmpMap + j);
+                            prevFlag = 1;
+                        } else
+                            tmpMap[j] = (uchar) 0;
+                        continue;
+                    }
+                } else {
+                    s = s < 0 ? -1 : 1;
+                    if (m > tmpMag[j + magStep2 - s] && m > tmpMag[j + magStep1 + s]) {
+                        if (m > highTh && !prevFlag && tmpMap[j - mapStep] != 2) {
+                            tmpMap[j] = (uchar) 2;
+                            *stackTop++ = (tmpMap + j);
+                            prevFlag = 1;
+                        } else
+                            tmpMap[j] = (uchar) 0;
+                        continue;
+                    }
+                }
+            }
+            prevFlag = 0;
+            tmpMap[j] = (uchar) 1;
+        }
+
+        // scroll the ring buffer
+        tmpMag = magBuffer[0];
+        magBuffer[0] = magBuffer[1];
+        magBuffer[1] = magBuffer[2];
+        magBuffer[2] = tmpMag;
+    }
+
+    // track the edges (hysteresis thresholding)
+    while (stackTop > stackBottom) {
+        uchar *m;
+        if ((stackTop - stackBottom) + 8 > maxSize) {
+            int stackSize = (int) (stackTop - stackBottom);
+            maxSize = MAX(maxSize * 3 / 2, maxSize + 8);
+            stack.resize(maxSize);
+            stackBottom = &stack[0];
+            stackTop = stackBottom + stackSize;
+        }
+
+        m = *--stackTop;
+        if (!m[-1]) {
+            *(m - 1) = (uchar) 2;
+            *stackTop++ = m - 1;
+        }
+        if (!m[1]) {
+            *(m + 1) = (uchar) 2;
+            *stackTop++ = m + 1;
+        }
+        if (!m[-mapStep - 1]) {
+            *(m - mapStep - 1) = (uchar) 2;
+            *stackTop++ = m - mapStep - 1;
+        }
+        if (!m[-mapStep]) {
+            *(m - mapStep) = (uchar) 2;
+            *stackTop++ = m - mapStep;
+        }
+        if (!m[-mapStep + 1]) {
+            *(m - mapStep + 1) = (uchar) 2;
+            *stackTop++ = m - mapStep + 1;
+        }
+        if (!m[mapStep - 1]) {
+            *(m + mapStep - 1) = (uchar) 2;
+            *stackTop++ = m + mapStep - 1;
+        }
+        if (!m[mapStep]) {
+            *(m + mapStep) = (uchar) 2;
+            *stackTop++ = m + mapStep;
+        }
+        if (!m[mapStep + 1]) {
+            *(m + mapStep + 1) = (uchar) 2;
+            *stackTop++ = m + mapStep + 1;
+        }
+    }
+
+    // final pass, form the final image
+    for (int i = 0; i < imgSize.height; i++) {
+        const uchar *tmpMap = map + mapStep * (i + 1) + 1;
+        uchar *tmpDst = edges[i];
+        for (int j = 0; j < imgSize.width; j++)
+            tmpDst[j] = (uchar) -(tmpMap[j] >> 1);
+    }
+
+    // for each edge points, compute the edge direction
+    for (int i = 0; i < imgSize.height; i++) {
+        auto *tmpDx = dx.ptr<short>(i);
+        auto *tmpDy = dy.ptr<short>(i);
+        auto *tmpE = edges.ptr<uchar>(i);
+        auto *tmpDp = dp.ptr<uchar>(i);
+        auto *tmpDn = dn.ptr<uchar>(i);
+
+        for (int j = 0; j < imgSize.width; j++) {
+            if (!((tmpE[j] <= 0) || (tmpDx[j] == 0) || (tmpDy[j] == 0))) {
+                // angle of the tangent
+                float phi = -(float(tmpDx[j])) / float(tmpDy[j]);
+                // along positive or negative diagonal
+                if (phi > 0)
+                    tmpDp[j] = (uchar) 255;
+                else if (phi < 0)
+                    tmpDn[j] = (uchar) 255;
+            }
+        }
+    }
+}
+
+void EllipseDetectorImpl::detect(Mat1b &image, std::vector<Ellipse> &ellipses) {
+    countsOfFindEllipse = 0, countsOfGetFastCenter = 0;
+
+    // set the image size
+    _imgSize = image.size();
+
+    // initialize temporary data structures
+    Mat1b dp = Mat1b::zeros(_imgSize); // arcs along positive diagonal
+    Mat1b dn = Mat1b::zeros(_imgSize); // arcs along negative diagonal
+
+    // initialize accumulator dimensions
+    ACC_N_SIZE = 101, ACC_R_SIZE = 180, ACC_A_SIZE = max(_imgSize.height, _imgSize.width);
+
+    // allocate accumulators
+    accN = new int[ACC_N_SIZE], accR = new int[ACC_R_SIZE], accA = new int[ACC_A_SIZE];
+
+    // other temporary
+    VVP points_1, points_2, points_3, points_4; // vector of points, one for each convexity class
+    std::unordered_map<uint, EllipseData> centers; // hash map for reusing already computed EllipseData
+
+    // preprocessing
+    // find edge point with coarse convexity along positive (dp) or negative (dn) diagonal
+    preProcessing(image, dp, dn);
+
+    // detect edge and find convexity
+    detectEdges13(dp, points_1, points_3);
+    detectEdges24(dn, points_2, points_4);
+
+    // find triplets
+    getTriplets124(points_1, points_2, points_4, centers, ellipses);
+    getTriplets231(points_2, points_3, points_1, centers, ellipses);
+    getTriplets342(points_3, points_4, points_2, centers, ellipses);
+    getTriplets413(points_4, points_1, points_3, centers, ellipses);
+
+    // sort by score
+    sort(ellipses.begin(), ellipses.end());
+
+    // free accumulator memory
+    delete[]accN;
+    delete[]accR;
+    delete[]accA;
+
+    // cluster detections
+    clusterEllipses(ellipses);
+}
+
+void EllipseDetectorImpl::findEllipses(Point2f &center, VP &edge_i, VP &edge_j, VP &edge_k,
+                                       EllipseData &data_ij, EllipseData &data_ik,
+                                       std::vector<Ellipse> &ellipses) {
+    countsOfFindEllipse++;
+    // find ellipse parameters
+
+    // 0-initialize accumulators
+    memset(accN, 0, sizeof(int) * ACC_N_SIZE);
+    memset(accR, 0, sizeof(int) * ACC_R_SIZE);
+    memset(accA, 0, sizeof(int) * ACC_A_SIZE);
+
+
+    // get size of the 4 vectors of slopes (2 pairs of arcs)
+    int sz_ij1 = int(data_ij.Sa.size());
+    int sz_ij2 = int(data_ij.Sb.size());
+    int sz_ik1 = int(data_ik.Sa.size());
+    int sz_ik2 = int(data_ik.Sb.size());
+
+    // get the size of the 3 arcs
+    size_t sz_ei = edge_i.size();
+    size_t sz_ej = edge_j.size();
+    size_t sz_ek = edge_k.size();
+
+    // center of the estimated ellipse
+    float a0 = center.x;
+    float b0 = center.y;
+
+    // estimation of remaining parameters
+    // uses 4 combinations of parameters. See Table 1 and Sect [3.2.3] of the paper.
+    // ij1 and ik
+    {
+        float q1 = data_ij.ra;
+        float q3 = data_ik.ra;
+        float q5 = data_ik.rb;
+
+        for (int ij1 = 0; ij1 < sz_ij1; ij1++) {
+            float q2 = data_ij.Sa[ij1];
+
+            float q1xq2 = q1 * q2;
+            // ij1 and ik1
+            for (int ik1 = 0; ik1 < sz_ik1; ik1++) {
+                float q4 = data_ik.Sa[ik1];
+
+                float q3xq4 = q3 * q4;
+
+                // see Eq. [13-18] in the paper
+
+                float a = (q1xq2 - q3xq4); // gama
+                float b = (q3xq4 + 1) * (q1 + q2) - (q1xq2 + 1) * (q3 + q4); // beta
+                float Kp = (-b + sqrt(b * b + 4 * a * a)) / (2 * a); // K+
+                float zplus = ((q1 - Kp) * (q2 - Kp)) / ((1 + q1 * Kp) * (1 + q2 * Kp));
+
+                // available or not
+                if (zplus >= 0.0f) continue;
+
+                float Np = sqrt(-zplus); // N+
+                float rho = atan(Kp); // rho tmp
+                int rhoDeg;
+                if (Np > 1.f) {
+                    // inverse and convert to [0, 180)
+                    Np = 1.f / Np;
+                    rhoDeg = cvRound((rho * 180 / CV_PI) + 180) % 180;
+                } else {
+                    // convert to [0, 180)
+                    rhoDeg = cvRound((rho * 180 / CV_PI) + 90) % 180;
+                }
+
+                int iNp = cvRound(Np * 100);
+
+                if (0 <= iNp && iNp < ACC_N_SIZE && 0 <= rhoDeg && rhoDeg < ACC_R_SIZE) {
+                    ++accN[iNp];    // increment N accumulator
+                    ++accR[rhoDeg];    // increment R accumulator
+                }
+            }
+
+            // ij1 and ik2
+            for (int ik2 = 0; ik2 < sz_ik2; ik2++) {
+                float q4 = data_ik.Sb[ik2];
+
+                float q5xq4 = q5 * q4;
+
+                // See Eq. [13-18] in the paper
+
+                float a = (q1xq2 - q5xq4);
+                float b = (q5xq4 + 1) * (q1 + q2) - (q1xq2 + 1) * (q5 + q4);
+                float Kp = (-b + sqrt(b * b + 4 * a * a)) / (2 * a);
+                float zplus = ((q1 - Kp) * (q2 - Kp)) / ((1 + q1 * Kp) * (1 + q2 * Kp));
+
+                if (zplus >= 0.0f)
+                    continue;
+
+                float Np = sqrt(-zplus);
+                float rho = atan(Kp);
+                int rhoDeg;
+                if (Np > 1.f) {
+                    // inverse and convert to [0, 180)
+                    Np = 1.f / Np;
+                    rhoDeg = cvRound((rho * 180 / CV_PI) + 180) % 180;
+                } else {
+                    // convert to [0, 180)
+                    rhoDeg = cvRound((rho * 180 / CV_PI) + 90) % 180;
+                }
+
+                int iNp = cvRound(Np * 100); // [0, 100]
+
+                if (0 <= iNp && iNp < ACC_N_SIZE && 0 <= rhoDeg && rhoDeg < ACC_R_SIZE) {
+                    ++accN[iNp]; // increment N accumulator
+                    ++accR[rhoDeg]; // increment R accumulator
+                }
+            }
+
+        }
+    }
+
+    //ij2 and ik
+    {
+        float q1 = data_ij.rb;
+        float q3 = data_ik.rb;
+        float q5 = data_ik.ra;
+
+        for (int ij2 = 0; ij2 < sz_ij2; ij2++) {
+            float q2 = data_ij.Sb[ij2];
+
+            float q1xq2 = q1 * q2;
+            //ij2 and ik2
+            for (int ik2 = 0; ik2 < sz_ik2; ik2++) {
+                float q4 = data_ik.Sb[ik2];
+
+                float q3xq4 = q3 * q4;
+
+                // See Eq. [13-18] in the paper
+
+                float a = (q1xq2 - q3xq4);
+                float b = (q3xq4 + 1) * (q1 + q2) - (q1xq2 + 1) * (q3 + q4);
+                float Kp = (-b + sqrt(b * b + 4 * a * a)) / (2 * a);
+                float zplus = ((q1 - Kp) * (q2 - Kp)) / ((1 + q1 * Kp) * (1 + q2 * Kp));
+
+                if (zplus >= 0.0f)
+                    continue;
+
+                float Np = sqrt(-zplus);
+                float rho = atan(Kp);
+                int rhoDeg;
+                if (Np > 1.f) {
+                    // inverse and convert to [0, 180)
+                    Np = 1.f / Np;
+                    rhoDeg = cvRound((rho * 180 / CV_PI) + 180) % 180;
+                } else {
+                    // convert to [0, 180)
+                    rhoDeg = cvRound((rho * 180 / CV_PI) + 90) % 180;
+                }
+
+                int iNp = cvRound(Np * 100); // [0, 100]
+
+                if (0 <= iNp && iNp < ACC_N_SIZE && 0 <= rhoDeg && rhoDeg < ACC_R_SIZE) {
+                    ++accN[iNp]; // increment N accumulator
+                    ++accR[rhoDeg]; // increment R accumulator
+                }
+            }
+
+            // ij2 and ik1
+            for (int ik1 = 0; ik1 < sz_ik1; ik1++) {
+                float q4 = data_ik.Sa[ik1];
+
+                float q5xq4 = q5 * q4;
+
+                // See Eq. [13-18] in the paper
+
+                float a = (q1xq2 - q5xq4);
+                float b = (q5xq4 + 1) * (q1 + q2) - (q1xq2 + 1) * (q5 + q4);
+                float Kp = (-b + sqrt(b * b + 4 * a * a)) / (2 * a);
+                float zplus = ((q1 - Kp) * (q2 - Kp)) / ((1 + q1 * Kp) * (1 + q2 * Kp));
+
+                if (zplus >= 0.0f) {
+                    continue;
+                }
+
+                float Np = sqrt(-zplus);
+                float rho = atan(Kp);
+                int rhoDeg;
+                if (Np > 1.f) {
+                    // inverse and convert to [0, 180)
+                    Np = 1.f / Np;
+                    rhoDeg = cvRound((rho * 180 / CV_PI) + 180) % 180;
+                } else {
+                    // convert to [0, 180)
+                    rhoDeg = cvRound((rho * 180 / CV_PI) + 90) % 180;
+                }
+
+                int iNp = cvRound(Np * 100); // [0, 100]
+
+                if (0 <= iNp && iNp < ACC_N_SIZE && 0 <= rhoDeg && rhoDeg < ACC_R_SIZE) {
+                    ++accN[iNp]; // increment N accumulator
+                    ++accR[rhoDeg]; // increment R accumulator
+                }
+            }
+        }
+    }
+
+    // find peak in N and K accumulator
+    int iN = (int)std::distance(accN, std::max_element(accN, accN + ACC_N_SIZE));
+    int iK = (int)std::distance(accR, std::max_element(accR, accR + ACC_R_SIZE)) + 90;
+
+    // recover real values
+    auto fK = float(iK);
+    float Np = float(iN) * 0.01f;
+    float rho = fK * float(CV_PI) / 180.f; // deg 2 rad
+    float Kp = tan(rho);
+
+    // estimate A. See Eq. [19 - 22] in Sect [3.2.3] of the paper
+    for (ushort l = 0; l < sz_ei; ++l) {
+        Point &pp = edge_i[l];
+        float sk = 1.f / sqrt(Kp * Kp + 1.f); // cos rho
+        float x0 = ((pp.x - a0) * sk) + (((pp.y - b0) * Kp) * sk);
+        float y0 = -(((pp.x - a0) * Kp) * sk) + ((pp.y - b0) * sk);
+        float Ax = sqrt((x0 * x0 * Np * Np + y0 * y0) / ((Np * Np) * (1.f + Kp * Kp)));
+        int A = cvRound(abs(Ax / cos(rho)));
+        if ((0 <= A) && (A < ACC_A_SIZE))
+            ++accA[A];
+    }
+
+    for (ushort l = 0; l < sz_ej; ++l) {
+        Point &pp = edge_j[l];
+        float sk = 1.f / sqrt(Kp * Kp + 1.f);
+        float x0 = ((pp.x - a0) * sk) + (((pp.y - b0) * Kp) * sk);
+        float y0 = -(((pp.x - a0) * Kp) * sk) + ((pp.y - b0) * sk);
+        float Ax = sqrt((x0 * x0 * Np * Np + y0 * y0) / ((Np * Np) * (1.f + Kp * Kp)));
+        int A = cvRound(abs(Ax / cos(rho)));
+        if ((0 <= A) && (A < ACC_A_SIZE))
+            ++accA[A];
+    }
+
+    for (ushort l = 0; l < sz_ek; ++l) {
+        Point &pp = edge_k[l];
+        float sk = 1.f / sqrt(Kp * Kp + 1.f);
+        float x0 = ((pp.x - a0) * sk) + (((pp.y - b0) * Kp) * sk);
+        float y0 = -(((pp.x - a0) * Kp) * sk) + ((pp.y - b0) * sk);
+        float Ax = sqrt((x0 * x0 * Np * Np + y0 * y0) / ((Np * Np) * (1.f + Kp * Kp)));
+        int A = cvRound(abs(Ax / cos(rho)));
+        if ((0 <= A) && (A < ACC_A_SIZE))
+            ++accA[A];
+    }
+
+    // find peak in A accumulator
+    int A = (int)std::distance(accA, std::max_element(accA, accA + ACC_A_SIZE));
+    auto fA = float(A);
+
+    // find B value. See Eq [23] in the paper
+    float fB = abs(fA * Np);
+
+    // got all ellipse parameters
+    Ellipse ell(a0, b0, fA, fB, fmod(rho + float(CV_PI) * 2.f, float(CV_PI)));
+
+    // get the score. See Sect [3.3.1] in the paper
+
+    // find the number of edge pixel lying on the ellipse
+    float _cos = cos(-ell.radius);
+    float _sin = sin(-ell.radius);
+
+    float invA2 = 1.f / (ell.a * ell.a);
+    float invB2 = 1.f / (ell.b * ell.b);
+
+    float invNofPoints = 1.f / float(sz_ei + sz_ej + sz_ek);
+    int counter_on_perimeter = 0;
+
+    for (ushort l = 0; l < sz_ei; ++l) {
+        float tx = float(edge_i[l].x) - ell.center.x;
+        float ty = float(edge_i[l].y) - ell.center.y;
+        float rx = (tx * _cos - ty * _sin);
+        float ry = (tx * _sin + ty * _cos);
+
+        float h = (rx * rx) * invA2 + (ry * ry) * invB2;
+        if (abs(h - 1.f) < _maxDistanceToEllipseContour)
+            ++counter_on_perimeter;
+    }
+
+    for (ushort l = 0; l < sz_ej; ++l) {
+        float tx = float(edge_j[l].x) - ell.center.x;
+        float ty = float(edge_j[l].y) - ell.center.y;
+        float rx = (tx * _cos - ty * _sin);
+        float ry = (tx * _sin + ty * _cos);
+
+        float h = (rx * rx) * invA2 + (ry * ry) * invB2;
+        if (abs(h - 1.f) < _maxDistanceToEllipseContour)
+            ++counter_on_perimeter;
+    }
+
+    for (ushort l = 0; l < sz_ek; ++l) {
+        float tx = float(edge_k[l].x) - ell.center.x;
+        float ty = float(edge_k[l].y) - ell.center.y;
+        float rx = (tx * _cos - ty * _sin);
+        float ry = (tx * _sin + ty * _cos);
+
+        float h = (rx * rx) * invA2 + (ry * ry) * invB2;
+        if (abs(h - 1.f) < _maxDistanceToEllipseContour)
+            ++counter_on_perimeter;
+    }
+
+    // no points found on the ellipse
+    if (counter_on_perimeter <= 0)
+        return;
+
+    // compute score
+    float score = float(counter_on_perimeter) * invNofPoints;
+    if (score < _minScore)
+        return;
+
+    // compute reliability
+    float di, dj, dk;
+    {
+        Point2f p1(float(edge_i[0].x), float(edge_i[0].y));
+        Point2f p2(float(edge_i[sz_ei - 1].x), float(edge_i[sz_ei - 1].y));
+        p1.x -= ell.center.x;
+        p1.y -= ell.center.y;
+        p2.x -= ell.center.x;
+        p2.y -= ell.center.y;
+        Point2f r1((p1.x * _cos - p1.y * _sin), (p1.x * _sin + p1.y * _cos));
+        Point2f r2((p2.x * _cos - p2.y * _sin), (p2.x * _sin + p2.y * _cos));
+        di = abs(r2.x - r1.x) + abs(r2.y - r1.y);
+    }
+    {
+        Point2f p1(float(edge_j[0].x), float(edge_j[0].y));
+        Point2f p2(float(edge_j[sz_ej - 1].x), float(edge_j[sz_ej - 1].y));
+        p1.x -= ell.center.x;
+        p1.y -= ell.center.y;
+        p2.x -= ell.center.x;
+        p2.y -= ell.center.y;
+        Point2f r1((p1.x * _cos - p1.y * _sin), (p1.x * _sin + p1.y * _cos));
+        Point2f r2((p2.x * _cos - p2.y * _sin), (p2.x * _sin + p2.y * _cos));
+        dj = abs(r2.x - r1.x) + abs(r2.y - r1.y);
+    }
+    {
+        Point2f p1(float(edge_k[0].x), float(edge_k[0].y));
+        Point2f p2(float(edge_k[sz_ek - 1].x), float(edge_k[sz_ek - 1].y));
+        p1.x -= ell.center.x;
+        p1.y -= ell.center.y;
+        p2.x -= ell.center.x;
+        p2.y -= ell.center.y;
+        Point2f r1((p1.x * _cos - p1.y * _sin), (p1.x * _sin + p1.y * _cos));
+        Point2f r2((p2.x * _cos - p2.y * _sin), (p2.x * _sin + p2.y * _cos));
+        dk = abs(r2.x - r1.x) + abs(r2.y - r1.y);
+    }
+
+    // this allows to get rid of thick edges
+    float rel = min(1.f, ((di + dj + dk) / (3 * (ell.a + ell.b))));
+
+    if (rel < _minReliability)
+        return;
+
+    // assign the new score
+    ell.score = (score + rel) * 0.5f;
+
+    // the tentative detection has been confirmed
+    ellipses.emplace_back(ell);
+}
+
+void EllipseDetectorImpl::clusterEllipses(std::vector<Ellipse> &ellipses) {
+    const float aDistanceThreshold = 0.1f, bDistanceThreshold = 0.1f;
+    const float rDistanceThreshold = 0.1f;
+    const float DcRatioThreshold = 0.1f, rCircleThreshold = 0.9f;
+
+    int ellipseCount = int(ellipses.size());
+    if (ellipseCount == 0)
+        return;
+
+    // the first ellipse is assigned to a cluster
+    std::vector<Ellipse> clusters;
+    clusters.emplace_back(ellipses[0]);
+
+    bool foundCluster = false;
+    for (int i = 0; i < ellipseCount; i++) {
+        int clusterSize = int(clusters.size());
+
+        Ellipse &e1 = ellipses[i];
+        float ba_e1 = e1.b / e1.a;
+
+        foundCluster = false;
+        for (int j = 0; j < clusterSize; j++) {
+            Ellipse &e2 = clusters[j];
+            float ba_e2 = e2.b / e2.a;
+
+            float cDistanceThreshold = min(e1.b, e2.b) * DcRatioThreshold;
+            cDistanceThreshold = cDistanceThreshold * cDistanceThreshold;
+
+            // filter centers
+            float cDistance = ((e1.center.x - e2.center.x) * (e1.center.x - e2.center.x) +
+                               (e1.center.y - e2.center.y) * (e1.center.y - e2.center.y));
+            if (cDistance > cDistanceThreshold)
+                continue;
+
+            // filter a
+            float aDistance = abs(e1.a - e2.a) / max(e1.a, e2.a);
+            if (aDistance > aDistanceThreshold)
+                continue;
+
+            // filter b
+            float bDistance = abs(e1.b - e2.b) / min(e1.b, e2.b);
+            if (bDistance > bDistanceThreshold)
+                continue;
+
+            // filter angle
+            float rDistance = getMinAnglePI(e1.radius, e2.radius) / float(CV_PI);
+            if ((rDistance > rDistanceThreshold) && (ba_e1 < rCircleThreshold) &&
+                (ba_e2 < rCircleThreshold))
+                continue;
+
+            // same cluster as e2
+            foundCluster = true;
+            break;
+        }
+
+        // create a new cluster
+        if (!foundCluster)
+            clusters.push_back(e1);
+    }
+    clusters.swap(ellipses);
+}
+
+// find ellipses in images
+void findEllipses(
+        InputArray image, OutputArray ellipses,
+        float scoreThreshold, float reliabilityThreshold,
+        float centerDistanceThreshold) {
+
+    // check image empty and type
+    CV_Assert(
+            !image.empty() && (image.isMat() || image.isUMat()));
+
+    // check ellipses type
+    int type = CV_32FC(6);
+    if (ellipses.fixedType()) {
+        type = ellipses.type();
+        CV_CheckType(type, type == CV_32FC(6), "Wrong type of output ellipses");
+    }
+
+    // set class parameters
+    Size imgSize = image.size();
+    float maxCenterDistance =
+            sqrt(float(imgSize.width * imgSize.width + imgSize.height * imgSize.height)) *
+            centerDistanceThreshold;
+    EllipseDetectorImpl edi;
+    edi.setParameters(maxCenterDistance, scoreThreshold, reliabilityThreshold);
+
+    // detect - ellipse format
+    std::vector<Ellipse> ellipseResults;
+    Mat1b grayImage = image.getMat();
+    if (image.channels() != 1)
+        cvtColor(image, grayImage, COLOR_BGR2GRAY);
+    edi.detect(grayImage, ellipseResults);
+
+    // convert - ellipse format to std::vector<Vec6f>
+    std::vector<Vec6f> _ellipses;
+    for (size_t i = 0; i < ellipseResults.size(); i++) {
+        Ellipse tmpEll = ellipseResults[i];
+        Vec6f tmpVec(tmpEll.center.x, tmpEll.center.y, tmpEll.a, tmpEll.b, tmpEll.score,
+                     tmpEll.radius);
+        _ellipses.push_back(tmpVec);
+    }
+    Mat(_ellipses).copyTo(ellipses);
+}
+} // namespace ximgproc
+} // namespace cv
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fourier_descriptors.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fourier_descriptors.cpp
new file mode 100644
index 00000000..a1d8201f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/fourier_descriptors.cpp
@@ -0,0 +1,330 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include <math.h>
+#include <vector>
+
+/*
+If you use this code please cite this @cite BergerRaghunathan1998
+Coalescence in 2 dimensions: experiments on thin copolymer films and numerical simulations  The European Physical Journal B - Condensed Matter and Complex Systems  (Volume:2 ,  Issue: 1 )  1998
+*/
+
+namespace cv {
+namespace ximgproc {
+
+
+void ContourFitting::setCtrSize(int n)
+{
+    CV_Assert(n>0);
+    ctrSize = n;
+}
+
+void ContourFitting::setFDSize(int n)
+{
+    CV_Assert(n>0);
+    fdSize=n;
+}
+
+void ContourFitting::frequencyInit()
+{
+    int nbElt = ctrSize;
+    frequence.resize(ctrSize);
+
+    for (int i = 0; i <= nbElt / 2; i++)
+        frequence[i] = 2 * M_PI*(float)i / nbElt;
+    for (int i = nbElt / 2 + 1; i<nbElt; i++)
+        frequence[i] = 2 * M_PI*(float)(i - nbElt) / nbElt;
+}
+
+void ContourFitting::fAlpha(double x, double &fn, double &df)
+{
+    int 	nbElt = static_cast<int>(rho.size());
+    double	s1 = 0, s2 = 0, s3 = 0, s4 = 0;
+    double	ds1 = 0, ds2 = 0, ds3 = 0, ds4 = 0;
+
+    for (int n = 1; n <= fdSize; n++)
+    {
+        s1 += rho[n] * sin(psi[n] + frequence[n] * x) +
+            rho[nbElt - n] * sin(psi[nbElt - n] + frequence[nbElt - n] * x);
+        s2 += frequence[n] * rho[n] * cos(psi[n] + frequence[n] * x) +
+            frequence[nbElt - n] * rho[nbElt - n] * cos(psi[nbElt - n] + frequence[nbElt - n] * x);
+        s3 += rho[n] * cos(psi[n] + frequence[n] * x) +
+            rho[nbElt - n] * cos(psi[nbElt - n] + frequence[nbElt - n] * x);
+        s4 += frequence[n] * rho[n] * sin(psi[n] + frequence[n] * x) +
+            frequence[nbElt - n] * rho[nbElt - n] * sin(psi[nbElt - n] + frequence[nbElt - n] * x);
+        ds1 += frequence[n] * rho[n] * cos(psi[n] + frequence[n] * x) +
+            frequence[nbElt - n] * rho[nbElt - n] * cos(psi[nbElt - n] + frequence[nbElt - n] * x);
+        ds2 += -frequence[n] * frequence[n] * rho[n] * sin(psi[n] + frequence[n] * x) -
+            frequence[nbElt - n] * frequence[nbElt - n] * rho[nbElt - n] * sin(psi[nbElt - n] + frequence[nbElt - n] * x);
+        ds3 += -frequence[n] * rho[n] * sin(psi[n] + frequence[n] * x) -
+            frequence[nbElt - n] * rho[nbElt - n] * sin(psi[nbElt - n] + frequence[nbElt - n] * x);
+        ds4 += frequence[n] * frequence[n] * rho[n] * cos(psi[n] + frequence[n] * x) +
+            frequence[nbElt - n] * frequence[nbElt - n] * rho[nbElt - n] * cos(psi[nbElt - n] + frequence[nbElt - n] * x);
+    }
+    fn = s1 * s2 - s3 *s4;
+    df = ds1 * s2 + s1 * ds2 - ds3 * s4 - s3 * ds4;
+}
+
+double ContourFitting::distance(std::complex<double> r, double alpha)
+{
+    std::complex<double>		j(0, 1);
+    double 		d = 0;
+
+    for (int i = 1; i <= fdSize; i++)
+        d += abs(a[i] - b[i] * r*exp(j*alpha*frequence[i])) + abs(a[a.size() - i] - b[a.size() - i] * r*exp(j*alpha*frequence[a.size() - i]));
+    return d/fdSize/2;
+};
+
+double  ContourFitting::newtonRaphson(double x1, double x2)
+{
+    double f1,df1;
+    fAlpha(x1,f1,df1);
+    if (f1 < 0)
+    {
+        x1=x2;
+        fAlpha(x1, f1, df1);
+    }
+    CV_Assert(f1>=0);
+    if (f1==0)
+        return x1;
+    for (int i = 0; i < 5; i++)
+    {
+        x1 = x1 -f1/df1;
+        fAlpha(x1, f1, df1);
+        if (f1 == 0)
+            return x1;
+    }
+    return x1;
+}
+
+void ContourFitting::estimateTransformation(InputArray _src, InputArray _ref, OutputArray _alphaPhiST, double &distFin, bool fdContour)
+{
+    estimateTransformation(_src, _ref, _alphaPhiST, &distFin, fdContour);
+}
+void ContourFitting::estimateTransformation(InputArray _src, InputArray _ref, OutputArray _alphaPhiST,double *distFin, bool fdContour)
+{
+    if (!fdContour)
+        CV_Assert( (_src.kind() == _InputArray::STD_VECTOR || _src.kind() == _InputArray::MAT) && (_ref.kind() == _InputArray::STD_VECTOR || _ref.kind() == _InputArray::MAT));
+    else
+        CV_Assert(fdContour && _src.kind() == _InputArray::MAT && _ref.kind() == _InputArray::MAT);
+    CV_Assert(_src.channels() == 2 && _ref.channels() == 2);
+    Mat fdCtr1,fdCtr2;
+    if (!fdContour)
+    {
+        Mat newCtr1,newCtr2;
+        contourSampling(_src, newCtr1, ctrSize);
+        contourSampling(_ref, newCtr2, ctrSize);
+        fourierDescriptor(newCtr1, fdCtr1);
+        fourierDescriptor(newCtr2, fdCtr2);
+    }
+    else
+    {
+        fdCtr1=_src.getMat();
+        fdCtr2= _ref.getMat();
+        CV_Assert(fdCtr1.rows == fdCtr2.rows);
+    }
+    CV_Assert( fdSize<= ctrSize / 2 - 1);
+    if (fdCtr1.type() != CV_64FC2)
+        fdCtr1.convertTo(fdCtr1, CV_64F);
+    if (fdCtr2.type() != CV_64FC2)
+        fdCtr2.convertTo(fdCtr2, CV_64F);
+    rho.resize(ctrSize);
+    psi.resize(ctrSize);
+    b.resize(ctrSize);
+    a.resize(ctrSize);
+    frequencyInit();
+    double  alphaMin, phiMin, sMin;
+    long		    n, nbElt = ctrSize;
+    double 		    s1, s2, sign1, sign2, df, x1 = nbElt, x2 = nbElt, dx;
+    double		    dist, distMin = 10000, alpha, s, phi;
+    std::complex<double> 	j(0, 1), zz;
+
+    for (n = 0; n<nbElt; n++)
+    {
+        b[n] = std::complex<double>(fdCtr1.at<Vec2d>(n,0)[0], fdCtr1.at<Vec2d>(n, 0)[1]);
+        a[n] = std::complex<double>(fdCtr2.at<Vec2d>(n, 0)[0], fdCtr2.at<Vec2d>(n, 0)[1]);
+        zz = conj(a[n])*b[n];
+        rho[n] = abs(zz);
+        psi[n] = arg(zz);
+    }
+
+    x1 = nbElt, x2 = nbElt;
+    sMin = 1;
+    alphaMin = 0;
+    phiMin = arg(a[1] / b[1]);
+    do
+    {
+        x2 = x1;
+        fAlpha(x2, sign2, df);
+        dx = 1;
+        x1 = x2;
+        do
+        {
+            x2 = x1;
+            x1 -= dx;
+            fAlpha(x1, sign1, df);
+        }
+        while ((sign1*sign2>0) && (x1>-nbElt));
+        if (sign1*sign2<0)
+        {
+            alpha=newtonRaphson(x1,x2);
+            s1 = 0;
+            s2 = 0;
+            for (n = 1; n<nbElt; n++)
+            {
+                s1 += rho[n] * sin(psi[n] + frequence[n] * alpha);
+                s2 += rho[n] * cos(psi[n] + frequence[n] * alpha);
+            }
+            phi = -atan2(s1, s2);
+            s1 = 0;
+            s2 = 0;
+            for (n = 1; n < nbElt; n++)
+            {
+                s1 += rho[n] * cos(psi[n] + frequence[n] * alpha + phi);
+                s2 += abs(b[n] * conj(b[n]));
+            }
+            s = s1 / s2;
+            zz = s*exp(j * phi);
+            if (s>0)
+                dist = distance(zz, alpha);
+            else
+                dist = 10000;
+            if (dist<distMin)
+            {
+                distMin = dist;
+                alphaMin = alpha;
+                phiMin = phi;
+                sMin = s;
+            }
+        }
+    }
+    while ((x1>-nbElt));
+    Mat x=(Mat_<double>(1,5)<<alphaMin/ nbElt,phiMin,sMin, fdCtr2.at<Vec2d>(0, 0)[0]- fdCtr1.at<Vec2d>(0, 0)[0], fdCtr2.at<Vec2d>(0, 0)[1]- fdCtr1.at<Vec2d>(0, 0)[1]);
+    if (distFin)
+        *distFin= distMin;
+    x.copyTo(_alphaPhiST);
+}
+
+void fourierDescriptor(InputArray _src, OutputArray _dst, int nbElt, int nbFD)
+{
+    CV_Assert(_src.kind() == _InputArray::MAT || _src.kind() == _InputArray::STD_VECTOR);
+    CV_Assert(_src.empty() || (_src.channels() == 2 && (_src.depth() == CV_32S || _src.depth() == CV_32F || _src.depth() == CV_64F)));
+    Mat  z = _src.getMat();
+    CV_Assert(z.rows == 1 || z.cols == 1);
+    if (nbElt==-1)
+        nbElt = getOptimalDFTSize(max(z.rows, z.cols));
+    CV_Assert((nbFD >= 1 && nbFD <=nbElt/2) || nbFD==-1);
+    Mat  Z;
+    if (z.rows*z.cols!=nbElt)
+        contourSampling(_src, z,nbElt);
+    else if (_src.depth() == CV_32S)
+        z.convertTo(z, CV_32F);
+    dft(z, Z, DFT_SCALE | DFT_REAL_OUTPUT);
+    if (nbFD == -1)
+    {
+        Z.copyTo(_dst);
+    }
+    else
+    {
+        int n1 = nbFD / 2, n2 = nbElt - n1;
+        Mat d(nbFD, 1, Z.type());
+        Z.rowRange(Range(1, n1+1)).copyTo(d.rowRange(Range(0, n1)));
+        if (n2>0)
+            Z.rowRange(Range(n2, Z.rows)).copyTo(d.rowRange(Range(n1, nbFD)));
+        d.copyTo(_dst);
+    }
+}
+
+void contourSampling(InputArray _src, OutputArray _out, int nbElt)
+{
+    CV_Assert(_src.kind() == _InputArray::STD_VECTOR || _src.kind() == _InputArray::MAT);
+    CV_Assert(_src.empty() || (_src.channels() == 2 && (_src.depth() == CV_32S || _src.depth() == CV_32F || _src.depth() == CV_64F)));
+    CV_Assert(nbElt>0);
+    Mat ctr;
+    _src.getMat().convertTo(ctr,CV_32F);
+    if (ctr.rows*ctr.cols == 0)
+    {
+        _out.release();
+        return;
+    }
+    CV_Assert(ctr.rows==1 || ctr.cols==1);
+    double		l1 = 0, l2, p, d, s;
+    Mat r;
+    if (ctr.rows==1)
+        ctr=ctr.t();
+    int j = 0;
+    int 		nb = ctr.rows;
+    p = arcLength(ctr, true);
+    l2 = norm(ctr.row(j) - ctr.row(j + 1)) / p;
+    for (int i = 0; i<nbElt; i++)
+    {
+        s = (float)i / (float)nbElt;
+        while (s >= l2)
+        {
+            j++;
+            l1 = l2;
+            d = norm(ctr.row(j % nb) - ctr.row((j + 1) % nb));
+            l2 = l1 + d / p;
+        }
+        if ((s >= l1) && (s < l2))
+        {
+            Mat d1=ctr.row((j + 1) % nb);
+            Mat d0=ctr.row(j % nb);
+            Mat d10 = d1 - d0;
+            Mat pn = d0 + d10 * (s - l1) / (l2 - l1);
+            r.push_back(pn);
+        }
+    }
+    r.copyTo(_out);
+}
+
+void transformFD(InputArray _src, InputArray _t,OutputArray _dst,  bool fdContour)
+{
+    if (!fdContour)
+        CV_Assert(_src.kind() == _InputArray::STD_VECTOR || _src.kind() == _InputArray::MAT);
+    else
+        CV_Assert( _src.kind() == _InputArray::MAT );
+    CV_Assert(_src.channels() == 2);
+    CV_Assert(_t.kind() == _InputArray::MAT);
+    Mat t=_t.getMat();
+    CV_Assert(t.rows == 1 && t.cols==5 && t.depth()==CV_64F);
+    Mat Z;
+    if (!fdContour)
+    {
+        Mat ctr1 = _src.getMat();
+        if (ctr1.rows==1)
+            ctr1 = ctr1.t();
+        Mat newCtr1;
+        int M = getOptimalDFTSize(ctr1.rows);
+        contourSampling(ctr1, newCtr1, M);
+        fourierDescriptor(newCtr1, Z);
+    }
+    else
+        Z = _src.getMat();
+    if (Z.type()!=CV_64FC2)
+        Z.convertTo(Z,CV_64F);
+    std::complex<double> expitheta = t.at<double>(0,2)  * std::complex<double>(cos(t.at<double>(0, 1)), sin(t.at<double>(0, 1)));
+    for (int j = 1; j<Z.rows; j++)
+    {
+        std::complex<double> zr(Z.at<Vec2d>(j, 0)[0], Z.at<Vec2d>(j,0)[1]);
+        if (j<=Z.rows/2)
+            zr = zr*expitheta*exp(t.at<double>(0, 0) * 2 * (M_PI*j) *  std::complex<double>(0, 1));
+        else
+            zr = zr*expitheta*exp(t.at<double>(0, 0)* 2 * (M_PI*(j - Z.rows))    * std::complex<double>(0, 1));
+        Z.at<Vec2d>(j, 0) = Vec2d(zr.real(),zr.imag());
+    }
+    Z.at<Vec2d>(0, 0) += Vec2d(t.at<double>(0, 3), t.at<double>(0, 4));
+    std::vector<Point2d> z;
+    dft(Z, z, DFT_INVERSE);
+    Mat(z).copyTo(_dst);
+}
+
+cv::Ptr<ContourFitting> createContourFitting(int ctr, int fd)
+{
+    return makePtr<ContourFitting>(ctr, fd);
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/graphsegmentation.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/graphsegmentation.cpp
new file mode 100644
index 00000000..45c8c2a4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/graphsegmentation.cpp
@@ -0,0 +1,394 @@
+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/******************************************************************************\
+*                        Graph based segmentation                             *
+* This code implements the segmentation method described in:                  *
+* P. Felzenszwalb, D. Huttenlocher: "Graph-Based Image Segmentation"          *
+* International Journal of Computer Vision, Vol. 59, No. 2, September 2004    *
+*                                                                             *
+* Author: Maximilien Cuony / LTS2 / EPFL / 2015                               *
+*******************************************************************************/
+
+#include "precomp.hpp"
+#include "opencv2/ximgproc/segmentation.hpp"
+
+#include <iostream>
+
+namespace cv {
+    namespace ximgproc {
+        namespace segmentation {
+
+            // Helpers
+
+            // Represent an edge between two pixels
+            class Edge {
+                public:
+                    int from;
+                    int to;
+                    float weight;
+
+                    bool operator <(const Edge& e) const {
+                        return weight < e.weight;
+                    }
+            };
+
+            // A point in the sets of points
+            class PointSetElement {
+                public:
+                    int p;
+                    int size;
+
+                    PointSetElement() { }
+
+                    PointSetElement(int p_) {
+                        p = p_;
+                        size = 1;
+                    }
+            };
+
+            // An object to manage set of points, who can be fusionned
+            class PointSet {
+                public:
+                    PointSet(int nb_elements_);
+                    ~PointSet();
+
+                    int nb_elements;
+
+                    // Return the main point of the point's set
+                    int getBasePoint(int p);
+
+                    // Join two sets of points, based on their main point
+                    void joinPoints(int p_a, int p_b);
+
+                    // Return the set size of a set (based on the main point)
+                    int size(unsigned int p) { return mapping[p].size; }
+
+                private:
+                    PointSetElement* mapping;
+
+            };
+
+            class GraphSegmentationImpl : public GraphSegmentation {
+                public:
+                    GraphSegmentationImpl() {
+                        sigma = 0.5;
+                        k = 300;
+                        min_size = 100;
+                        name_ = "GraphSegmentation";
+                    }
+
+                    ~GraphSegmentationImpl() CV_OVERRIDE {
+                    };
+
+                    virtual void processImage(InputArray src, OutputArray dst) CV_OVERRIDE;
+
+                    virtual void setSigma(double sigma_) CV_OVERRIDE { if (sigma_ <= 0) { sigma_ = 0.001; } sigma = sigma_; }
+                    virtual double getSigma() CV_OVERRIDE { return sigma; }
+
+                    virtual void setK(float k_) CV_OVERRIDE { k = k_; }
+                    virtual float getK() CV_OVERRIDE { return k; }
+
+                    virtual void setMinSize(int min_size_) CV_OVERRIDE { min_size = min_size_; }
+                    virtual int getMinSize() CV_OVERRIDE { return min_size; }
+
+                    virtual void write(FileStorage& fs) const CV_OVERRIDE {
+                        fs << "name" << name_
+                        << "sigma" << sigma
+                        << "k" << k
+                        << "min_size" << (int)min_size;
+                    }
+
+                    virtual void read(const FileNode& fn) CV_OVERRIDE {
+                        CV_Assert( (String)fn["name"] == name_ );
+
+                        sigma = (double)fn["sigma"];
+                        k = (float)fn["k"];
+                        min_size = (int)(int)fn["min_size"];
+                    }
+
+                private:
+                    double sigma;
+                    float k;
+                    int min_size;
+                    String name_;
+
+                    // Pre-filter the image
+                    void filter(const Mat &img, Mat &img_filtered);
+
+                    // Build the graph between each pixels
+                    void buildGraph(Edge **edges, int &nb_edges, const Mat &img_filtered);
+
+                    // Segment the graph
+                    void segmentGraph(Edge * edges, const int &nb_edges, const Mat & img_filtered, PointSet **es);
+
+                    // Remove areas too small
+                    void filterSmallAreas(Edge *edges, const int &nb_edges, PointSet *es);
+
+                    // Map the segemented graph to a Mat with uniques, sequentials ids
+                    void finalMapping(PointSet *es, Mat &output);
+            };
+
+            void GraphSegmentationImpl::filter(const Mat &img, Mat &img_filtered) {
+
+                Mat img_converted;
+
+                // Switch to float
+                img.convertTo(img_converted, CV_32F);
+
+                // Apply gaussian filter
+                GaussianBlur(img_converted, img_filtered, Size(0, 0), sigma, sigma);
+            }
+
+            void GraphSegmentationImpl::buildGraph(Edge **edges, int &nb_edges, const Mat &img_filtered) {
+
+                *edges = new Edge[img_filtered.rows * img_filtered.cols * 4];
+
+                nb_edges = 0;
+
+                int nb_channels = img_filtered.channels();
+
+                for (int i = 0; i < (int)img_filtered.rows; i++) {
+                    const float* p = img_filtered.ptr<float>(i);
+
+                    for (int j = 0; j < (int)img_filtered.cols; j++) {
+
+                        //Take the right, left, top and down pixel
+                        for (int delta = -1; delta <= 1; delta += 2) {
+                            for (int delta_j = 0, delta_i = 1; delta_j <= 1; delta_j++ || delta_i--) {
+
+                                int i2 = i + delta * delta_i;
+                                int j2 = j + delta * delta_j;
+
+                                if (i2 >= 0 && i2 < img_filtered.rows && j2 >= 0 && j2 < img_filtered.cols) {
+                                    const float* p2 = img_filtered.ptr<float>(i2);
+
+                                    float tmp_total = 0;
+
+                                    for ( int channel = 0; channel < nb_channels; channel++) {
+                                        float tmp_diff = p[j * nb_channels + channel] - p2[j2 * nb_channels + channel];
+                                        tmp_total += tmp_diff * tmp_diff;
+                                    }
+
+                                    float diff = 0;
+                                    diff = sqrt(tmp_total);
+
+                                    (*edges)[nb_edges].weight = diff;
+                                    (*edges)[nb_edges].from = i * img_filtered.cols +  j;
+                                    (*edges)[nb_edges].to = i2 * img_filtered.cols + j2;
+
+                                    nb_edges++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            void GraphSegmentationImpl::segmentGraph(Edge *edges, const int &nb_edges, const Mat &img_filtered, PointSet **es) {
+
+                int total_points = ( int)(img_filtered.rows * img_filtered.cols);
+
+                // Sort edges
+                std::sort(edges, edges + nb_edges);
+
+                // Create a set with all point (by default mapped to themselves)
+                *es = new PointSet(img_filtered.cols * img_filtered.rows);
+
+                // Thresholds
+                float* thresholds = new float[total_points];
+
+                for (int i = 0; i < total_points; i++)
+                    thresholds[i] = k;
+
+                for ( int i = 0; i < nb_edges; i++) {
+
+                    int p_a = (*es)->getBasePoint(edges[i].from);
+                    int p_b = (*es)->getBasePoint(edges[i].to);
+
+                    if (p_a != p_b) {
+                        if (edges[i].weight <= thresholds[p_a] && edges[i].weight <= thresholds[p_b]) {
+                            (*es)->joinPoints(p_a, p_b);
+                            p_a = (*es)->getBasePoint(p_a);
+                            thresholds[p_a] = edges[i].weight + k / (*es)->size(p_a);
+
+                            edges[i].weight = 0;
+                        }
+                    }
+                }
+
+                delete [] thresholds;
+            }
+
+            void GraphSegmentationImpl::filterSmallAreas(Edge *edges, const int &nb_edges, PointSet *es) {
+
+                for ( int i = 0; i < nb_edges; i++) {
+
+                    if (edges[i].weight > 0) {
+
+                        int p_a = es->getBasePoint(edges[i].from);
+                        int p_b = es->getBasePoint(edges[i].to);
+
+                        if (p_a != p_b && (es->size(p_a) < min_size || es->size(p_b) < min_size)) {
+                            es->joinPoints(p_a, p_b);
+
+                        }
+                    }
+                }
+
+            }
+
+            void GraphSegmentationImpl::finalMapping(PointSet *es, Mat &output) {
+
+                int maximum_size = ( int)(output.rows * output.cols);
+
+                int last_id = 0;
+                int * mapped_id = new int[maximum_size];
+
+                for ( int i = 0; i < maximum_size; i++)
+                    mapped_id[i] = -1;
+
+                int rows = output.rows;
+                int cols = output.cols;
+
+                if (output.isContinuous()) {
+                    cols *= rows;
+                    rows = 1;
+                }
+
+                for (int i = 0; i < rows; i++) {
+
+                    int* p = output.ptr<int>(i);
+
+                    for (int j = 0; j < cols; j++) {
+
+                        int point = es->getBasePoint(i * cols + j);
+
+                        if (mapped_id[point] == -1) {
+                            mapped_id[point] = last_id;
+                            last_id++;
+                        }
+
+                        p[j] = mapped_id[point];
+                    }
+                }
+
+                delete [] mapped_id;
+            }
+
+            void GraphSegmentationImpl::processImage(InputArray src, OutputArray dst) {
+
+                Mat img = src.getMat();
+
+                dst.create(img.rows, img.cols, CV_32SC1);
+                Mat output = dst.getMat();
+                output.setTo(0);
+
+                // Filter graph
+                Mat img_filtered;
+                filter(img, img_filtered);
+
+                // Build graph
+                Edge *edges;
+                int nb_edges;
+
+                buildGraph(&edges, nb_edges, img_filtered);
+
+                // Segment graph
+                PointSet *es;
+
+                segmentGraph(edges, nb_edges, img_filtered, &es);
+
+                // Remove small areas
+                filterSmallAreas(edges, nb_edges, es);
+
+                // Map to final output
+                finalMapping(es, output);
+
+                delete [] edges;
+                delete es;
+
+            }
+
+            Ptr<GraphSegmentation> createGraphSegmentation(double sigma, float k, int min_size) {
+
+                Ptr<GraphSegmentation> graphseg = makePtr<GraphSegmentationImpl>();
+
+                graphseg->setSigma(sigma);
+                graphseg->setK(k);
+                graphseg->setMinSize(min_size);
+
+                return graphseg;
+            }
+
+            PointSet::PointSet(int nb_elements_) {
+                nb_elements = nb_elements_;
+
+                mapping = new PointSetElement[nb_elements];
+
+                for ( int i = 0; i < nb_elements; i++) {
+                    mapping[i] = PointSetElement(i);
+                }
+            }
+
+            PointSet::~PointSet() {
+                delete [] mapping;
+            }
+
+            int PointSet::getBasePoint( int p) {
+
+                 int base_p = p;
+
+                while (base_p != mapping[base_p].p) {
+                    base_p = mapping[base_p].p;
+                }
+
+                // Save mapping for faster acces later
+                mapping[p].p = base_p;
+
+                return base_p;
+            }
+
+            void PointSet::joinPoints(int p_a, int p_b) {
+
+                // Always target smaller set, to avoid redirection in getBasePoint
+                if (mapping[p_a].size < mapping[p_b].size)
+                    swap(p_a, p_b);
+
+                mapping[p_b].p = p_a;
+                mapping[p_a].size += mapping[p_b].size;
+
+                nb_elements--;
+            }
+
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/guided_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/guided_filter.cpp
new file mode 100644
index 00000000..11fa0f6f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/guided_filter.cpp
@@ -0,0 +1,798 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include "edgeaware_filters_common.hpp"
+#include <vector>
+
+#ifdef _MSC_VER
+#   pragma warning(disable: 4512)
+#endif
+
+namespace cv
+{
+namespace ximgproc
+{
+
+using std::vector;
+using namespace cv::ximgproc::intrinsics;
+
+template <typename T>
+struct SymArray2D
+{
+    vector<T> vec;
+    int sz;
+
+    SymArray2D()
+    {
+        sz = 0;
+    }
+
+    void create(int sz_)
+    {
+        CV_DbgAssert(sz_ > 0);
+        sz = sz_;
+        vec.resize(total());
+    }
+
+    inline T& operator()(int i, int j)
+    {
+        CV_DbgAssert(i >= 0 && i < sz && j >= 0 && j < sz);
+        if (i < j) std::swap(i, j);
+        return vec[i*(i+1)/2 + j];
+    }
+
+    inline T& operator()(int i)
+    {
+        return vec[i];
+    }
+
+    int total() const
+    {
+        return sz*(sz + 1)/2;
+    }
+
+    void release()
+    {
+        vec.clear();
+        sz = 0;
+    }
+};
+
+
+template <typename XMat>
+static void splitFirstNChannels(InputArrayOfArrays src, vector<XMat>& dst, int maxDstCn)
+{
+    CV_Assert(src.isMat() || src.isUMat() || src.isMatVector() || src.isUMatVector());
+
+    if ( (src.isMat() || src.isUMat()) && src.channels() == maxDstCn )
+    {
+        split(src, dst);
+    }
+    else
+    {
+        Size sz;
+        int depth, totalCnNum;
+
+        checkSameSizeAndDepth(src, sz, depth);
+        totalCnNum = std::min(maxDstCn, getTotalNumberOfChannels(src));
+
+        dst.resize(totalCnNum);
+        vector<int> fromTo(2*totalCnNum);
+        for (int i = 0; i < totalCnNum; i++)
+        {
+            fromTo[i*2 + 0] = i;
+            fromTo[i*2 + 1] = i;
+
+            dst[i].create(sz, CV_MAKE_TYPE(depth, 1));
+        }
+
+        mixChannels(src, dst, fromTo);
+    }
+}
+
+class GuidedFilterImpl : public GuidedFilter
+{
+public:
+
+    static Ptr<GuidedFilterImpl> create(InputArray guide, int radius, double eps);
+
+    void filter(InputArray src, OutputArray dst, int dDepth = -1) CV_OVERRIDE;
+
+protected:
+
+    int radius;
+    double eps;
+    int h, w;
+
+    vector<Mat> guideCn;
+    vector<Mat> guideCnMean;
+
+    SymArray2D<Mat> covarsInv;
+
+    int gCnNum;
+
+protected:
+
+    GuidedFilterImpl() {}
+
+    void init(InputArray guide, int radius, double eps);
+
+    void computeCovGuide(SymArray2D<Mat>& covars);
+
+    void computeCovGuideAndSrc(vector<Mat>& srcCn, vector<Mat>& srcCnMean, vector<vector<Mat> >& cov);
+
+    void getWalkPattern(int eid, int &cn1, int &cn2);
+
+    inline void meanFilter(Mat& src, Mat& dst)
+    {
+        boxFilter(src, dst, CV_32F, Size(2 * radius + 1, 2 * radius + 1), cv::Point(-1, -1), true, BORDER_REFLECT);
+    }
+
+    inline void convertToWorkType(Mat& src, Mat& dst)
+    {
+        src.convertTo(dst, CV_32F);
+    }
+
+private: /*Routines to parallelize boxFilter and convertTo*/
+
+    typedef void (GuidedFilterImpl::*TransformFunc)(Mat& src, Mat& dst);
+
+    struct GFTransform_ParBody : public ParallelLoopBody
+    {
+        GuidedFilterImpl &gf;
+        mutable vector<Mat*> src;
+        mutable vector<Mat*> dst;
+        TransformFunc func;
+
+        GFTransform_ParBody(GuidedFilterImpl& gf_, vector<Mat>& srcv, vector<Mat>& dstv, TransformFunc func_);
+        GFTransform_ParBody(GuidedFilterImpl& gf_, vector<vector<Mat> >& srcvv, vector<vector<Mat> >& dstvv, TransformFunc func_);
+
+        void operator () (const Range& range) const CV_OVERRIDE;
+
+        Range getRange() const
+        {
+            return Range(0, (int)src.size());
+        }
+    };
+
+    template<typename V>
+    void parConvertToWorkType(V &src, V &dst)
+    {
+        GFTransform_ParBody pb(*this, src, dst, &GuidedFilterImpl::convertToWorkType);
+        parallel_for_(pb.getRange(), pb);
+    }
+
+    template<typename V>
+    void parMeanFilter(V &src, V &dst)
+    {
+        GFTransform_ParBody pb(*this, src, dst, &GuidedFilterImpl::meanFilter);
+        parallel_for_(pb.getRange(), pb);
+    }
+
+private: /*Parallel body classes*/
+
+    inline void runParBody(const ParallelLoopBody& pb)
+    {
+        parallel_for_(Range(0, h), pb);
+    }
+
+    struct MulChannelsGuide_ParBody : public ParallelLoopBody
+    {
+        GuidedFilterImpl &gf;
+        SymArray2D<Mat> &covars;
+
+        MulChannelsGuide_ParBody(GuidedFilterImpl& gf_, SymArray2D<Mat>& covars_)
+            : gf(gf_), covars(covars_) {}
+
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    struct ComputeCovGuideFromChannelsMul_ParBody : public ParallelLoopBody
+    {
+        GuidedFilterImpl &gf;
+        SymArray2D<Mat> &covars;
+
+        ComputeCovGuideFromChannelsMul_ParBody(GuidedFilterImpl& gf_, SymArray2D<Mat>& covars_)
+            : gf(gf_), covars(covars_) {}
+
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    struct ComputeCovGuideInv_ParBody : public ParallelLoopBody
+    {
+        GuidedFilterImpl &gf;
+        SymArray2D<Mat> &covars;
+
+        ComputeCovGuideInv_ParBody(GuidedFilterImpl& gf_, SymArray2D<Mat>& covars_);
+
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+
+    struct MulChannelsGuideAndSrc_ParBody : public ParallelLoopBody
+    {
+        GuidedFilterImpl &gf;
+        vector<vector<Mat> > &cov;
+        vector<Mat> &srcCn;
+
+        MulChannelsGuideAndSrc_ParBody(GuidedFilterImpl& gf_, vector<Mat>& srcCn_, vector<vector<Mat> >& cov_)
+            : gf(gf_), cov(cov_), srcCn(srcCn_) {}
+
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    struct ComputeCovFromSrcChannelsMul_ParBody : public ParallelLoopBody
+    {
+        GuidedFilterImpl &gf;
+        vector<vector<Mat> > &cov;
+        vector<Mat> &srcCnMean;
+
+        ComputeCovFromSrcChannelsMul_ParBody(GuidedFilterImpl& gf_, vector<Mat>& srcCnMean_, vector<vector<Mat> >& cov_)
+            : gf(gf_), cov(cov_), srcCnMean(srcCnMean_) {}
+
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    struct ComputeAlpha_ParBody : public ParallelLoopBody
+    {
+        GuidedFilterImpl &gf;
+        vector<vector<Mat> > &alpha;
+        vector<vector<Mat> > &covSrc;
+
+        ComputeAlpha_ParBody(GuidedFilterImpl& gf_, vector<vector<Mat> >& alpha_, vector<vector<Mat> >& covSrc_)
+            : gf(gf_), alpha(alpha_), covSrc(covSrc_) {}
+
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    struct ComputeBeta_ParBody : public ParallelLoopBody
+    {
+        GuidedFilterImpl &gf;
+        vector<vector<Mat> > &alpha;
+        vector<Mat> &srcCnMean;
+        vector<Mat> &beta;
+
+        ComputeBeta_ParBody(GuidedFilterImpl& gf_, vector<vector<Mat> >& alpha_, vector<Mat>& srcCnMean_, vector<Mat>& beta_)
+            : gf(gf_), alpha(alpha_), srcCnMean(srcCnMean_), beta(beta_) {}
+
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    struct ApplyTransform_ParBody : public ParallelLoopBody
+    {
+        GuidedFilterImpl &gf;
+        vector<vector<Mat> > &alpha;
+        vector<Mat> &beta;
+
+        ApplyTransform_ParBody(GuidedFilterImpl& gf_, vector<vector<Mat> >& alpha_, vector<Mat>& beta_)
+            : gf(gf_),  alpha(alpha_), beta(beta_) {}
+
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+};
+
+void GuidedFilterImpl::MulChannelsGuide_ParBody::operator()(const Range& range) const
+{
+    int total = covars.total();
+
+    for (int i = range.start; i < range.end; i++)
+    {
+        int c1, c2;
+        float *cov, *guide1, *guide2;
+
+        for (int k = 0; k < total; k++)
+        {
+            gf.getWalkPattern(k, c1, c2);
+
+            guide1 = gf.guideCn[c1].ptr<float>(i);
+            guide2 = gf.guideCn[c2].ptr<float>(i);
+            cov = covars(c1, c2).ptr<float>(i);
+
+            mul(cov, guide1, guide2, gf.w);
+        }
+    }
+}
+
+void GuidedFilterImpl::ComputeCovGuideFromChannelsMul_ParBody::operator()(const Range& range) const
+{
+    int total = covars.total();
+    float diagSummand = (float)(gf.eps);
+
+    for (int i = range.start; i < range.end; i++)
+    {
+        int c1, c2;
+        float *cov, *guide1, *guide2;
+
+        for (int k = 0; k < total; k++)
+        {
+            gf.getWalkPattern(k, c1, c2);
+
+            guide1 = gf.guideCnMean[c1].ptr<float>(i);
+            guide2 = gf.guideCnMean[c2].ptr<float>(i);
+            cov = covars(c1, c2).ptr<float>(i);
+
+            if (c1 != c2)
+            {
+                sub_mul(cov, guide1, guide2, gf.w);
+            }
+            else
+            {
+                sub_mad(cov, guide1, guide2, -diagSummand, gf.w);
+            }
+        }
+    }
+}
+
+GuidedFilterImpl::ComputeCovGuideInv_ParBody::ComputeCovGuideInv_ParBody(GuidedFilterImpl& gf_, SymArray2D<Mat>& covars_)
+    : gf(gf_), covars(covars_)
+{
+    gf.covarsInv.create(gf.gCnNum);
+
+    if (gf.gCnNum == 3)
+    {
+        for (int k = 0; k < 2; k++)
+            for (int l = 0; l < 3; l++)
+                gf.covarsInv(k, l).create(gf.h, gf.w, CV_32FC1);
+
+        ////trick to avoid memory allocation
+        gf.covarsInv(2, 0).create(gf.h, gf.w, CV_32FC1);
+        gf.covarsInv(2, 1) = covars(2, 1);
+        gf.covarsInv(2, 2) = covars(2, 2);
+
+        return;
+    }
+
+    if (gf.gCnNum == 2)
+    {
+        gf.covarsInv(0, 0) = covars(1, 1);
+        gf.covarsInv(0, 1) = covars(0, 1);
+        gf.covarsInv(1, 1) = covars(0, 0);
+        return;
+    }
+
+    if (gf.gCnNum == 1)
+    {
+        gf.covarsInv(0, 0) = covars(0, 0);
+        return;
+    }
+}
+
+void GuidedFilterImpl::ComputeCovGuideInv_ParBody::operator()(const Range& range) const
+{
+    if (gf.gCnNum == 3)
+    {
+        vector<float> covarsDet(gf.w);
+        float *det = &covarsDet[0];
+
+        for (int i = range.start; i < range.end; i++)
+        {
+            for (int k = 0; k < 3; k++)
+                for (int l = 0; l <= k; l++)
+                {
+                    float *dst = gf.covarsInv(k, l).ptr<float>(i);
+
+                    float *a00 = covars((k + 1) % 3, (l + 1) % 3).ptr<float>(i);
+                    float *a01 = covars((k + 1) % 3, (l + 2) % 3).ptr<float>(i);
+                    float *a10 = covars((k + 2) % 3, (l + 1) % 3).ptr<float>(i);
+                    float *a11 = covars((k + 2) % 3, (l + 2) % 3).ptr<float>(i);
+
+                    det_2x2(dst, a00, a01, a10, a11, gf.w);
+                }
+
+            for (int k = 0; k < 3; k++)
+            {
+                float *a = covars(k, 0).ptr<float>(i);
+                float *ac = gf.covarsInv(k, 0).ptr<float>(i);
+
+                if (k == 0)
+                    mul(det, a, ac, gf.w);
+                else
+                    add_mul(det, a, ac, gf.w);
+            }
+
+            if (gf.eps < 1e-2)
+            {
+                for (int j = 0; j < gf.w; j++)
+                    if (abs(det[j]) < 1e-6f)
+                        det[j] = 1.f;
+            }
+
+            for (int k = 0; k < gf.covarsInv.total(); k += 1)
+            {
+                div_1x(gf.covarsInv(k).ptr<float>(i), det, gf.w);
+            }
+        }
+        return;
+    }
+
+    if (gf.gCnNum == 2)
+    {
+        for (int i = range.start; i < range.end; i++)
+        {
+            float *a00 = gf.covarsInv(0, 0).ptr<float>(i);
+            float *a10 = gf.covarsInv(1, 0).ptr<float>(i);
+            float *a11 = gf.covarsInv(1, 1).ptr<float>(i);
+
+            div_det_2x2(a00, a10, a11, gf.w);
+        }
+        return;
+    }
+
+    if (gf.gCnNum == 1)
+    {
+        //divide(1.0, covars(0, 0)(range, Range::all()), gf.covarsInv(0, 0)(range, Range::all()));
+        //return;
+
+        for (int i = range.start; i < range.end; i++)
+        {
+            float *res = covars(0, 0).ptr<float>(i);
+            inv_self(res, gf.w);
+        }
+        return;
+    }
+}
+
+void GuidedFilterImpl::MulChannelsGuideAndSrc_ParBody::operator()(const Range& range) const
+{
+    int srcCnNum = (int)srcCn.size();
+
+    for (int i = range.start; i < range.end; i++)
+    {
+        for (int si = 0; si < srcCnNum; si++)
+        {
+            int step    = (si % 2) * 2 - 1;
+            int start   = (si % 2) ? 0 : gf.gCnNum - 1;
+            int end     = (si % 2) ? gf.gCnNum : -1;
+
+            float *srcLine = srcCn[si].ptr<float>(i);
+
+            for (int gi = start; gi != end; gi += step)
+            {
+                float *guideLine = gf.guideCn[gi].ptr<float>(i);
+                float *dstLine = cov[si][gi].ptr<float>(i);
+
+                mul(dstLine, srcLine, guideLine, gf.w);
+            }
+        }
+    }
+}
+
+void GuidedFilterImpl::ComputeCovFromSrcChannelsMul_ParBody::operator()(const Range& range) const
+{
+    int srcCnNum = (int)srcCnMean.size();
+
+    for (int i = range.start; i < range.end; i++)
+    {
+        for (int si = 0; si < srcCnNum; si++)
+        {
+            int step    = (si % 2) * 2 - 1;
+            int start   = (si % 2) ? 0 : gf.gCnNum - 1;
+            int end     = (si % 2) ? gf.gCnNum : -1;
+
+            float *srcMeanLine = srcCnMean[si].ptr<float>(i);
+
+            for (int gi = start; gi != end; gi += step)
+            {
+                float *guideMeanLine = gf.guideCnMean[gi].ptr<float>(i);
+                float *covLine = cov[si][gi].ptr<float>(i);
+
+                sub_mul(covLine, srcMeanLine, guideMeanLine, gf.w);
+            }
+        }
+    }
+}
+
+void GuidedFilterImpl::ComputeAlpha_ParBody::operator()(const Range& range) const
+{
+    int srcCnNum = (int)covSrc.size();
+
+    for (int i = range.start; i < range.end; i++)
+    {
+        for (int si = 0; si < srcCnNum; si++)
+        {
+            for (int gi = 0; gi < gf.gCnNum; gi++)
+            {
+                float *y, *A, *dstAlpha;
+
+                dstAlpha = alpha[si][gi].ptr<float>(i);
+                for (int k = 0; k < gf.gCnNum; k++)
+                {
+                    y = covSrc[si][k].ptr<float>(i);
+                    A = gf.covarsInv(gi, k).ptr<float>(i);
+
+                    if (k == 0)
+                    {
+                        mul(dstAlpha, A, y, gf.w);
+                    }
+                    else
+                    {
+                        add_mul(dstAlpha, A, y, gf.w);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void GuidedFilterImpl::ComputeBeta_ParBody::operator()(const Range& range) const
+{
+    int srcCnNum = (int)srcCnMean.size();
+    CV_DbgAssert(&srcCnMean == &beta);
+
+    for (int i = range.start; i < range.end; i++)
+    {
+        float *_g[4];
+        for (int gi = 0; gi < gf.gCnNum; gi++)
+            _g[gi] = gf.guideCnMean[gi].ptr<float>(i);
+
+        float *betaDst, *g, *a;
+        for (int si = 0; si < srcCnNum; si++)
+        {
+            betaDst = beta[si].ptr<float>(i);
+            for (int gi = 0; gi < gf.gCnNum; gi++)
+            {
+                a = alpha[si][gi].ptr<float>(i);
+                g = _g[gi];
+
+                sub_mul(betaDst, a, g, gf.w);
+            }
+        }
+    }
+}
+
+void GuidedFilterImpl::ApplyTransform_ParBody::operator()(const Range& range) const
+{
+    int srcCnNum = (int)alpha.size();
+
+    for (int i = range.start; i < range.end; i++)
+    {
+        float *_g[4];
+        for (int gi = 0; gi < gf.gCnNum; gi++)
+            _g[gi] = gf.guideCn[gi].ptr<float>(i);
+
+        float *betaDst, *g, *a;
+        for (int si = 0; si < srcCnNum; si++)
+        {
+            betaDst = beta[si].ptr<float>(i);
+            for (int gi = 0; gi < gf.gCnNum; gi++)
+            {
+                a = alpha[si][gi].ptr<float>(i);
+                g = _g[gi];
+
+                add_mul(betaDst, a, g, gf.w);
+            }
+        }
+    }
+}
+
+GuidedFilterImpl::GFTransform_ParBody::GFTransform_ParBody(GuidedFilterImpl& gf_, vector<Mat>& srcv, vector<Mat>& dstv, TransformFunc func_)
+    : gf(gf_), func(func_)
+{
+    CV_DbgAssert(srcv.size() == dstv.size());
+    src.resize(srcv.size());
+    dst.resize(srcv.size());
+
+    for (int i = 0; i < (int)srcv.size(); i++)
+    {
+        src[i] = &srcv[i];
+        dst[i] = &dstv[i];
+    }
+}
+
+GuidedFilterImpl::GFTransform_ParBody::GFTransform_ParBody(GuidedFilterImpl& gf_, vector<vector<Mat> >& srcvv, vector<vector<Mat> >& dstvv, TransformFunc func_)
+    : gf(gf_), func(func_)
+{
+    CV_DbgAssert(srcvv.size() == dstvv.size());
+    int n = (int)srcvv.size();
+    int total = 0;
+
+    for (int i = 0; i < n; i++)
+    {
+        CV_DbgAssert(srcvv[i].size() == dstvv[i].size());
+        total += (int)srcvv[i].size();
+    }
+
+    src.resize(total);
+    dst.resize(total);
+
+    int k = 0;
+    for (int i = 0; i < n; i++)
+    {
+        for (int j = 0; j < (int)srcvv[i].size(); j++)
+        {
+            src[k] = &srcvv[i][j];
+            dst[k] = &dstvv[i][j];
+            k++;
+        }
+    }
+}
+
+void GuidedFilterImpl::GFTransform_ParBody::operator()(const Range& range) const
+{
+    for (int i = range.start; i < range.end; i++)
+    {
+        (gf.*func)(*src[i], *dst[i]);
+    }
+}
+
+void GuidedFilterImpl::getWalkPattern(int eid, int &cn1, int &cn2)
+{
+    static int wdata[] = {
+        0, -1, -1, -1, -1, -1,
+        0, -1, -1, -1, -1, -1,
+
+        0,  0,  1, -1, -1, -1,
+        0,  1,  1, -1, -1, -1,
+
+        0,  0,  0,  2,  1,  1,
+        0,  1,  2,  2,  2,  1,
+    };
+
+    cn1 = wdata[6 * 2 * (gCnNum-1) + eid];
+    cn2 = wdata[6 * 2 * (gCnNum-1) + 6 + eid];
+}
+
+Ptr<GuidedFilterImpl> GuidedFilterImpl::create(InputArray guide, int radius, double eps)
+{
+    GuidedFilterImpl *gf = new GuidedFilterImpl();
+    gf->init(guide, radius, eps);
+    return Ptr<GuidedFilterImpl>(gf);
+}
+
+void GuidedFilterImpl::init(InputArray guide, int radius_, double eps_)
+{
+    CV_Assert( !guide.empty() && radius_ >= 0 && eps_ >= 0 );
+    CV_Assert( (guide.depth() == CV_32F || guide.depth() == CV_8U || guide.depth() == CV_16U) && (guide.channels() <= 3) );
+
+    radius = radius_;
+    eps = eps_;
+
+    splitFirstNChannels(guide, guideCn, 3);
+    gCnNum = (int)guideCn.size();
+    h = guideCn[0].rows;
+    w = guideCn[0].cols;
+
+    guideCnMean.resize(gCnNum);
+    parConvertToWorkType(guideCn, guideCn);
+    parMeanFilter(guideCn, guideCnMean);
+
+    SymArray2D<Mat> covars;
+    computeCovGuide(covars);
+    runParBody(ComputeCovGuideInv_ParBody(*this, covars));
+    covars.release();
+}
+
+void GuidedFilterImpl::computeCovGuide(SymArray2D<Mat>& covars)
+{
+    covars.create(gCnNum);
+    for (int i = 0; i < covars.total(); i++)
+        covars(i).create(h, w, CV_32FC1);
+
+    runParBody(MulChannelsGuide_ParBody(*this, covars));
+
+    parMeanFilter(covars.vec, covars.vec);
+
+    runParBody(ComputeCovGuideFromChannelsMul_ParBody(*this, covars));
+}
+
+void GuidedFilterImpl::filter(InputArray src, OutputArray dst, int dDepth /*= -1*/)
+{
+    CV_Assert( !src.empty() && (src.depth() == CV_32F || src.depth() == CV_8U) );
+    if (src.rows() != h || src.cols() != w)
+    {
+        CV_Error(Error::StsBadSize, "Size of filtering image must be equal to size of guide image");
+        return;
+    }
+
+    if (dDepth == -1) dDepth = src.depth();
+    int srcCnNum = src.channels();
+
+    vector<Mat> srcCn(srcCnNum);
+    vector<Mat>& srcCnMean = srcCn;
+    split(src, srcCn);
+
+    if (src.depth() != CV_32F)
+    {
+        parConvertToWorkType(srcCn, srcCn);
+    }
+
+    vector<vector<Mat> > covSrcGuide(srcCnNum);
+    computeCovGuideAndSrc(srcCn, srcCnMean, covSrcGuide);
+
+    vector<vector<Mat> > alpha(srcCnNum);
+    for (int si = 0; si < srcCnNum; si++)
+    {
+        alpha[si].resize(gCnNum);
+        for (int gi = 0; gi < gCnNum; gi++)
+            alpha[si][gi].create(h, w, CV_32FC1);
+    }
+    runParBody(ComputeAlpha_ParBody(*this, alpha, covSrcGuide));
+    covSrcGuide.clear();
+
+    vector<Mat>& beta = srcCnMean;
+    runParBody(ComputeBeta_ParBody(*this, alpha, srcCnMean, beta));
+
+    parMeanFilter(beta, beta);
+    parMeanFilter(alpha, alpha);
+
+    runParBody(ApplyTransform_ParBody(*this, alpha, beta));
+    if (dDepth != CV_32F)
+    {
+        for (int i = 0; i < srcCnNum; i++)
+            beta[i].convertTo(beta[i], dDepth);
+    }
+    merge(beta, dst);
+}
+
+void GuidedFilterImpl::computeCovGuideAndSrc(vector<Mat>& srcCn, vector<Mat>& srcCnMean, vector<vector<Mat> >& cov)
+{
+    int srcCnNum = (int)srcCn.size();
+
+    cov.resize(srcCnNum);
+    for (int i = 0; i < srcCnNum; i++)
+    {
+        cov[i].resize(gCnNum);
+        for (int j = 0; j < gCnNum; j++)
+            cov[i][j].create(h, w, CV_32FC1);
+    }
+
+    runParBody(MulChannelsGuideAndSrc_ParBody(*this, srcCn, cov));
+
+    parMeanFilter(srcCn, srcCnMean);
+    parMeanFilter(cov, cov);
+
+    runParBody(ComputeCovFromSrcChannelsMul_ParBody(*this, srcCnMean, cov));
+}
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+CV_EXPORTS_W
+Ptr<GuidedFilter> createGuidedFilter(InputArray guide, int radius, double eps)
+{
+    return Ptr<GuidedFilter>(GuidedFilterImpl::create(guide, radius, eps));
+}
+
+CV_EXPORTS_W
+void guidedFilter(InputArray guide, InputArray src, OutputArray dst, int radius, double eps, int dDepth)
+{
+    Ptr<GuidedFilter> gf = createGuidedFilter(guide, radius, eps);
+    gf->filter(src, dst, dDepth);
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/joint_bilateral_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/joint_bilateral_filter.cpp
new file mode 100644
index 00000000..f69785e9
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/joint_bilateral_filter.cpp
@@ -0,0 +1,402 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include <climits>
+#include <iostream>
+using namespace std;
+
+#ifdef _MSC_VER
+#   pragma warning(disable: 4512)
+#endif
+
+namespace cv
+{
+namespace ximgproc
+{
+
+typedef Vec<float, 1> Vec1f;
+typedef Vec<uchar, 1> Vec1b;
+
+#ifndef SQR
+#define SQR(a) ((a)*(a))
+#endif
+
+void jointBilateralFilter_32f(Mat& joint, Mat& src, Mat& dst, int radius, double sigmaColor, double sigmaSpace, int borderType);
+
+void jointBilateralFilter_8u(Mat& joint, Mat& src, Mat& dst, int radius, double sigmaColor, double sigmaSpace, int borderType);
+
+template<typename JointVec, typename SrcVec>
+class JointBilateralFilter_32f : public ParallelLoopBody
+{
+    Mat &joint, &src;
+    Mat &dst;
+    int radius, maxk;
+    float scaleIndex;
+    int *spaceOfs;
+    float *spaceWeights, *expLUT;
+
+public:
+
+    JointBilateralFilter_32f(Mat& joint_, Mat& src_, Mat& dst_, int radius_,
+        int maxk_, float scaleIndex_, int *spaceOfs_, float *spaceWeights_, float *expLUT_)
+        :
+        joint(joint_), src(src_), dst(dst_), radius(radius_), maxk(maxk_),
+        scaleIndex(scaleIndex_), spaceOfs(spaceOfs_), spaceWeights(spaceWeights_), expLUT(expLUT_)
+    {
+        CV_DbgAssert(joint.type() == traits::Type<JointVec>::value && src.type() == dst.type() && src.type() == traits::Type<SrcVec>::value);
+        CV_DbgAssert(joint.rows == src.rows && src.rows == dst.rows + 2*radius);
+        CV_DbgAssert(joint.cols == src.cols && src.cols == dst.cols + 2*radius);
+    }
+
+    void operator () (const Range& range) const CV_OVERRIDE
+    {
+        for (int i = radius + range.start; i < radius + range.end; i++)
+        {
+            for (int j = radius; j < src.cols - radius; j++)
+            {
+                JointVec *jointCenterPixPtr = joint.ptr<JointVec>(i) + j;
+                SrcVec *srcCenterPixPtr = src.ptr<SrcVec>(i) + j;
+
+                JointVec jointPix0 = *jointCenterPixPtr;
+                SrcVec srcSum = SrcVec::all(0.0f);
+                float wSum = 0.0f;
+
+                for (int k = 0; k < maxk; k++)
+                {
+                    float *jointPix = reinterpret_cast<float*>(jointCenterPixPtr + spaceOfs[k]);
+                    float alpha = 0.0f;
+
+                    for (int cn = 0; cn < JointVec::channels; cn++)
+                        alpha += std::abs(jointPix0[cn] - jointPix[cn]);
+                    alpha *= scaleIndex;
+                    int idx = (int)(alpha);
+                    alpha -= idx;
+                    float weight = spaceWeights[k] * (expLUT[idx] + alpha*(expLUT[idx + 1] - expLUT[idx]));
+
+                    float *srcPix = reinterpret_cast<float*>(srcCenterPixPtr + spaceOfs[k]);
+                    for (int cn = 0; cn < SrcVec::channels; cn++)
+                        srcSum[cn] += weight*srcPix[cn];
+                    wSum += weight;
+                }
+
+                dst.at<SrcVec>(i - radius, j - radius) = srcSum / wSum;
+            }
+        }
+    }
+};
+
+void jointBilateralFilter_32f(Mat& joint, Mat& src, Mat& dst, int radius, double sigmaColor, double sigmaSpace, int borderType)
+{
+    CV_DbgAssert(joint.depth() == CV_32F && src.depth() == CV_32F);
+
+    int d = 2*radius + 1;
+    int jCn = joint.channels();
+    const int kExpNumBinsPerChannel = 1 << 12;
+    double minValJoint, maxValJoint;
+
+    minMaxLoc(joint, &minValJoint, &maxValJoint);
+    if (abs(maxValJoint - minValJoint) < FLT_EPSILON)
+    {
+        //TODO: make circle pattern instead of square
+        GaussianBlur(src, dst, Size(d, d), sigmaSpace, 0, borderType);
+        return;
+    }
+    float colorRange = (float)(maxValJoint - minValJoint) * jCn;
+    colorRange = std::max(0.01f, colorRange);
+
+    int kExpNumBins = kExpNumBinsPerChannel * jCn;
+    vector<float> expLUTv(kExpNumBins + 2);
+    float *expLUT = &expLUTv[0];
+    float scaleIndex = kExpNumBins/colorRange;
+
+    double gaussColorCoeff = -0.5 / (sigmaColor*sigmaColor);
+    double gaussSpaceCoeff = -0.5 / (sigmaSpace*sigmaSpace);
+
+    for (int i = 0; i < kExpNumBins + 2; i++)
+    {
+        double val = i / scaleIndex;
+        expLUT[i] = (float) std::exp(val * val * gaussColorCoeff);
+    }
+
+    Mat jointTemp, srcTemp;
+    copyMakeBorder(joint, jointTemp, radius, radius, radius, radius, borderType);
+    copyMakeBorder(src, srcTemp, radius, radius, radius, radius, borderType);
+    size_t srcElemStep = srcTemp.step / srcTemp.elemSize();
+    size_t jElemStep = jointTemp.step / jointTemp.elemSize();
+    CV_Assert(srcElemStep == jElemStep);
+
+    vector<float> spaceWeightsv(d*d);
+    vector<int> spaceOfsJointv(d*d);
+    float *spaceWeights = &spaceWeightsv[0];
+    int *spaceOfsJoint = &spaceOfsJointv[0];
+
+    int maxk = 0;
+    for (int i = -radius; i <= radius; i++)
+    {
+        for (int j = -radius; j <= radius; j++)
+        {
+            double r2 = i*i + j*j;
+            if (r2 > SQR(radius))
+                continue;
+
+            spaceWeights[maxk] = (float) std::exp(r2 * gaussSpaceCoeff);
+            spaceOfsJoint[maxk] = (int) (i*jElemStep + j);
+            maxk++;
+        }
+    }
+
+    Range range(0, joint.rows);
+    if (joint.type() == CV_32FC1)
+    {
+        if (src.type() == CV_32FC1)
+        {
+            parallel_for_(range, JointBilateralFilter_32f<Vec1f, Vec1f>(jointTemp, srcTemp, dst, radius, maxk, scaleIndex, spaceOfsJoint, spaceWeights, expLUT));
+        }
+        if (src.type() == CV_32FC3)
+        {
+            parallel_for_(range, JointBilateralFilter_32f<Vec1f, Vec3f>(jointTemp, srcTemp, dst, radius, maxk, scaleIndex, spaceOfsJoint, spaceWeights, expLUT));
+        }
+    }
+
+    if (joint.type() == CV_32FC3)
+    {
+        if (src.type() == CV_32FC1)
+        {
+            parallel_for_(range, JointBilateralFilter_32f<Vec3f, Vec1f>(jointTemp, srcTemp, dst, radius, maxk, scaleIndex, spaceOfsJoint, spaceWeights, expLUT));
+        }
+        if (src.type() == CV_32FC3)
+        {
+            parallel_for_(range, JointBilateralFilter_32f<Vec3f, Vec3f>(jointTemp, srcTemp, dst, radius, maxk, scaleIndex, spaceOfsJoint, spaceWeights, expLUT));
+        }
+    }
+}
+
+template<typename JointVec, typename SrcVec>
+class JointBilateralFilter_8u : public ParallelLoopBody
+{
+    Mat &joint, &src;
+    Mat &dst;
+    int radius, maxk;
+    float scaleIndex;
+    int *spaceOfs;
+    float *spaceWeights, *expLUT;
+
+public:
+
+    JointBilateralFilter_8u(Mat& joint_, Mat& src_, Mat& dst_, int radius_,
+        int maxk_, int *spaceOfs_, float *spaceWeights_, float *expLUT_)
+        :
+        joint(joint_), src(src_), dst(dst_), radius(radius_), maxk(maxk_),
+        spaceOfs(spaceOfs_), spaceWeights(spaceWeights_), expLUT(expLUT_)
+    {
+        CV_DbgAssert(joint.type() == traits::Type<JointVec>::value && src.type() == dst.type() && src.type() == traits::Type<SrcVec>::value);
+        CV_DbgAssert(joint.rows == src.rows && src.rows == dst.rows + 2 * radius);
+        CV_DbgAssert(joint.cols == src.cols && src.cols == dst.cols + 2 * radius);
+    }
+
+    void operator () (const Range& range) const CV_OVERRIDE
+    {
+        typedef Vec<int, JointVec::channels> JointVeci;
+        typedef Vec<float, SrcVec::channels> SrcVecf;
+
+        for (int i = radius + range.start; i < radius + range.end; i++)
+        {
+            for (int j = radius; j < src.cols - radius; j++)
+            {
+                JointVec *jointCenterPixPtr = joint.ptr<JointVec>(i) + j;
+                SrcVec *srcCenterPixPtr = src.ptr<SrcVec>(i) + j;
+
+                JointVeci jointPix0 = JointVeci(*jointCenterPixPtr);
+                SrcVecf srcSum = SrcVecf::all(0.0f);
+                float wSum = 0.0f;
+
+                for (int k = 0; k < maxk; k++)
+                {
+                    uchar *jointPix = reinterpret_cast<uchar*>(jointCenterPixPtr + spaceOfs[k]);
+                    int alpha = 0;
+                    for (int cn = 0; cn < JointVec::channels; cn++)
+                        alpha += std::abs(jointPix0[cn] - (int)jointPix[cn]);
+
+                    float weight = spaceWeights[k] * expLUT[alpha];
+
+                    uchar *srcPix = reinterpret_cast<uchar*>(srcCenterPixPtr + spaceOfs[k]);
+                    for (int cn = 0; cn < SrcVec::channels; cn++)
+                        srcSum[cn] += weight*srcPix[cn];
+                    wSum += weight;
+                }
+
+                dst.at<SrcVec>(i - radius, j - radius) = SrcVec(srcSum / wSum);
+            }
+        }
+    }
+};
+
+void jointBilateralFilter_8u(Mat& joint, Mat& src, Mat& dst, int radius, double sigmaColor, double sigmaSpace, int borderType)
+{
+    CV_DbgAssert(joint.depth() == CV_8U && src.depth() == CV_8U);
+
+    int d = 2 * radius + 1;
+    int jCn = joint.channels();
+
+    double gaussColorCoeff = -0.5 / (sigmaColor*sigmaColor);
+    double gaussSpaceCoeff = -0.5 / (sigmaSpace*sigmaSpace);
+
+    vector<float> expLUTv(jCn*256);
+    float *expLUT = &expLUTv[0];
+
+    for (int i = 0; i < (int)expLUTv.size(); i++)
+    {
+        expLUT[i] = (float)std::exp(i * i * gaussColorCoeff);
+    }
+
+    Mat jointTemp, srcTemp;
+    copyMakeBorder(joint, jointTemp, radius, radius, radius, radius, borderType);
+    copyMakeBorder(src, srcTemp, radius, radius, radius, radius, borderType);
+    size_t srcElemStep = srcTemp.step / srcTemp.elemSize();
+    size_t jElemStep = jointTemp.step / jointTemp.elemSize();
+    CV_Assert(srcElemStep == jElemStep);
+
+    vector<float> spaceWeightsv(d*d);
+    vector<int> spaceOfsJointv(d*d);
+    float *spaceWeights = &spaceWeightsv[0];
+    int *spaceOfsJoint = &spaceOfsJointv[0];
+
+    int maxk = 0;
+    for (int i = -radius; i <= radius; i++)
+    {
+        for (int j = -radius; j <= radius; j++)
+        {
+            double r2 = i*i + j*j;
+            if (r2 > SQR(radius))
+                continue;
+
+            spaceWeights[maxk] = (float)std::exp(r2 * gaussSpaceCoeff);
+            spaceOfsJoint[maxk] = (int)(i*jElemStep + j);
+            maxk++;
+        }
+    }
+
+    Range range(0, src.rows);
+    if (joint.type() == CV_8UC1)
+    {
+        if (src.type() == CV_8UC1)
+        {
+            parallel_for_(range, JointBilateralFilter_8u<Vec1b, Vec1b>(jointTemp, srcTemp, dst, radius, maxk, spaceOfsJoint, spaceWeights, expLUT));
+        }
+        if (src.type() == CV_8UC3)
+        {
+            parallel_for_(range, JointBilateralFilter_8u<Vec1b, Vec3b>(jointTemp, srcTemp, dst, radius, maxk, spaceOfsJoint, spaceWeights, expLUT));
+        }
+    }
+
+    if (joint.type() == CV_8UC3)
+    {
+        if (src.type() == CV_8UC1)
+        {
+            parallel_for_(range, JointBilateralFilter_8u<Vec3b, Vec1b>(jointTemp, srcTemp, dst, radius, maxk, spaceOfsJoint, spaceWeights, expLUT));
+        }
+        if (src.type() == CV_8UC3)
+        {
+            parallel_for_(range, JointBilateralFilter_8u<Vec3b, Vec3b>(jointTemp, srcTemp, dst, radius, maxk, spaceOfsJoint, spaceWeights, expLUT));
+        }
+    }
+}
+
+void jointBilateralFilter(InputArray joint_, InputArray src_, OutputArray dst_, int d, double sigmaColor, double sigmaSpace, int borderType)
+{
+    CV_Assert(!src_.empty());
+
+    if (joint_.empty())
+    {
+        bilateralFilter(src_, dst_, d, sigmaColor, sigmaSpace, borderType);
+        return;
+    }
+
+    Mat src = src_.getMat();
+    Mat joint = joint_.getMat();
+
+    if (src.data == joint.data)
+    {
+        bilateralFilter(src_, dst_, d, sigmaColor, sigmaSpace, borderType);
+        return;
+    }
+
+    CV_Assert(src.size() == joint.size());
+    CV_Assert(src.depth() == joint.depth() && (src.depth() == CV_8U || src.depth() == CV_32F) );
+
+    if (sigmaColor <= 0)
+        sigmaColor = 1;
+    if (sigmaSpace <= 0)
+        sigmaSpace = 1;
+
+    int radius;
+    if (d <= 0)
+        radius = cvRound(sigmaSpace*1.5);
+    else
+        radius = d / 2;
+    radius = std::max(radius, 1);
+
+    dst_.create(src.size(), src.type());
+    Mat dst = dst_.getMat();
+
+    if (dst.data == joint.data)
+        joint = joint.clone();
+    if (dst.data == src.data)
+        src = src.clone();
+
+    int jointCnNum = joint.channels();
+    int srcCnNum = src.channels();
+
+    if ( (srcCnNum == 1 || srcCnNum == 3) && (jointCnNum == 1 || jointCnNum == 3) )
+    {
+        if (joint.depth() == CV_8U)
+        {
+            jointBilateralFilter_8u(joint, src, dst, radius, sigmaColor, sigmaSpace, borderType);
+        }
+        else
+        {
+            jointBilateralFilter_32f(joint, src, dst, radius, sigmaColor, sigmaSpace, borderType);
+        }
+    }
+    else
+    {
+        CV_Error(Error::BadNumChannels, "Unsupported number of channels");
+    }
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/l0_smooth.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/l0_smooth.cpp
new file mode 100644
index 00000000..78db4e78
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/l0_smooth.cpp
@@ -0,0 +1,385 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include <vector>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+
+using namespace cv;
+using namespace std;
+
+namespace
+{
+
+    class ParallelDft : public ParallelLoopBody
+    {
+    private:
+        vector<Mat> src_;
+    public:
+        ParallelDft(vector<Mat> &s)
+        {
+            src_ = s;
+        }
+        void operator() (const Range& range) const CV_OVERRIDE
+        {
+            for (int i = range.start; i != range.end; i++)
+            {
+                dft(src_[i], src_[i]);
+            }
+        }
+    };
+
+    class ParallelIdft : public ParallelLoopBody
+    {
+    private:
+        vector<Mat> src_;
+    public:
+        ParallelIdft(vector<Mat> &s)
+        {
+            src_ = s;
+        }
+        void operator() (const Range& range) const CV_OVERRIDE
+        {
+            for (int i = range.start; i != range.end; i++)
+            {
+                idft(src_[i], src_[i],DFT_SCALE);
+            }
+        }
+    };
+
+    class ParallelDivComplexByReal : public ParallelLoopBody
+    {
+    private:
+        vector<Mat> numer_;
+        vector<Mat> denom_;
+        vector<Mat> dst_;
+
+    public:
+        ParallelDivComplexByReal(vector<Mat> &numer, vector<Mat> &denom, vector<Mat> &dst)
+        {
+            numer_ = numer;
+            denom_ = denom;
+            dst_ = dst;
+        }
+        void operator() (const Range& range) const CV_OVERRIDE
+        {
+            for (int i = range.start; i != range.end; i++)
+            {
+                Mat aPanels[2];
+                Mat bPanels[2];
+                split(numer_[i], aPanels);
+                split(denom_[i], bPanels);
+
+                Mat realPart;
+                Mat imaginaryPart;
+
+                divide(aPanels[0], denom_[i], realPart);
+                divide(aPanels[1], denom_[i], imaginaryPart);
+
+                aPanels[0] = realPart;
+                aPanels[1] = imaginaryPart;
+
+                merge(aPanels, 2, dst_[i]);
+            }
+        }
+    };
+
+
+    void shift(InputArray src, OutputArray dst, int shift_x, int shift_y)
+    {
+        Mat S = src.getMat();
+        Mat D = dst.getMat();
+
+        if(S.data == D.data)
+        {
+            S = S.clone();
+        }
+
+        D.create(S.size(), S.type());
+
+        Mat s0(S, Rect(0, 0, S.cols - shift_x, S.rows - shift_y));
+        Mat s1(S, Rect(S.cols - shift_x, 0, shift_x, S.rows - shift_y));
+        Mat s2(S, Rect(0, S.rows - shift_y, S.cols-shift_x, shift_y));
+        Mat s3(S, Rect(S.cols - shift_x, S.rows- shift_y, shift_x, shift_y));
+
+        Mat d0(D, Rect(shift_x, shift_y, S.cols - shift_x, S.rows - shift_y));
+        Mat d1(D, Rect(0, shift_y, shift_x, S.rows - shift_y));
+        Mat d2(D, Rect(shift_x, 0, S.cols-shift_x, shift_y));
+        Mat d3(D, Rect(0,0,shift_x, shift_y));
+
+        s0.copyTo(d0);
+        s1.copyTo(d1);
+        s2.copyTo(d2);
+        s3.copyTo(d3);
+    }
+
+    // dft after padding imaginary
+    void fft(InputArray src, OutputArray dst)
+    {
+        Mat S = src.getMat();
+        Mat planes[] = {S.clone(), Mat::zeros(S.size(), S.type())};
+        Mat x;
+        merge(planes, 2, dst);
+
+        // compute the result
+        dft(dst, dst);
+    }
+
+    void psf2otf(InputArray src, OutputArray dst, int height, int width)
+    {
+        Mat S = src.getMat();
+        Mat D = dst.getMat();
+
+        Mat padded;
+
+        if(S.data == D.data){
+            S = S.clone();
+        }
+
+        // add padding
+        copyMakeBorder(S, padded, 0, height - S.rows, 0, width - S.cols,
+            BORDER_CONSTANT, Scalar::all(0));
+
+        shift(padded, padded, width - S.cols / 2, height - S.rows / 2);
+
+        // convert to frequency domain
+        fft(padded, dst);
+    }
+
+    void dftMultiChannel(InputArray src, vector<Mat> &dst)
+    {
+        Mat S = src.getMat();
+
+        split(S, dst);
+
+        for(int i = 0; i < S.channels(); i++){
+            Mat planes[] = {dst[i].clone(), Mat::zeros(dst[i].size(), dst[i].type())};
+            merge(planes, 2, dst[i]);
+        }
+
+        parallel_for_(cv::Range(0,S.channels()), ParallelDft(dst));
+
+    }
+
+    void idftMultiChannel(const vector<Mat> &src, OutputArray dst)
+    {
+        vector<Mat> channels(src);
+
+        parallel_for_(Range(0, int(src.size())), ParallelIdft(channels));
+
+        for(int i = 0; unsigned(i) < src.size(); i++){
+            Mat panels[2];
+            split(channels[i], panels);
+            channels[i] = panels[0];
+        }
+
+        Mat D;
+        merge(channels, D);
+        D.copyTo(dst);
+    }
+
+    void divComplexByRealMultiChannel(vector<Mat> &numer,
+        vector<Mat> &denom, vector<Mat> &dst)
+    {
+
+        for(int i = 0; unsigned(i) < numer.size(); i++)
+        {
+            dst[i].create(numer[i].size(), numer[i].type());
+        }
+        parallel_for_(Range(0, int(numer.size())), ParallelDivComplexByReal(numer, denom, dst));
+
+    }
+
+        // power of 2 of the absolute value of the complex
+    Mat pow2absComplex(InputArray src)
+    {
+        Mat S = src.getMat();
+
+        Mat sPanels[2];
+        split(S, sPanels);
+
+        Mat mag;
+        magnitude(sPanels[0], sPanels[1], mag);
+        pow(mag, 2, mag);
+
+        return mag;
+    }
+}
+
+namespace cv
+{
+    namespace ximgproc
+    {
+
+        void l0Smooth(InputArray src, OutputArray dst, double lambda, double kappa)
+        {
+            Mat S = src.getMat();
+
+            CV_Assert(!S.empty());
+            CV_Assert(S.depth() == CV_8U || S.depth() == CV_16U
+            || S.depth() == CV_32F || S.depth() == CV_64F);
+            CV_Assert(lambda > 0.0);
+            CV_Assert(kappa > 1.0);
+
+            dst.create(src.size(), src.type());
+
+            if(S.data == dst.getMat().data)
+            {
+                S = S.clone();
+            }
+
+            if(S.depth() == CV_8U)
+            {
+                S.convertTo(S, CV_32F, 1/255.0f);
+            }
+            else if(S.depth() == CV_16U)
+            {
+                S.convertTo(S, CV_32F, 1/65535.0f);
+            }
+            else if(S.depth() == CV_64F)
+            {
+                S.convertTo(S, CV_32F);
+            }
+
+            const double betaMax = 100000;
+
+            // gradient operators in frequency domain
+            Mat otfFx, otfFy;
+            float kernel[2] = {-1, 1};
+            float kernel_inv[2] = {1,-1};
+            psf2otf(Mat(1,2,CV_32FC1, kernel_inv), otfFx, S.rows, S.cols);
+            psf2otf(Mat(2,1,CV_32FC1, kernel_inv), otfFy, S.rows, S.cols);
+
+            vector<Mat> denomConst;
+            Mat tmp = pow2absComplex(otfFx) + pow2absComplex(otfFy);
+
+            for(int i = 0; i < S.channels(); i++)
+            {
+                denomConst.push_back(tmp);
+            }
+
+            // input image in frequency domain
+            vector<Mat> numerConst;
+            dftMultiChannel(S, numerConst);
+            /*********************************
+            * solver
+            *********************************/
+            double beta = 2 * lambda;
+            while(beta < betaMax){
+                // h, v subproblem
+                Mat h, v;
+
+                filter2D(S, h, -1, Mat(1, 2, CV_32FC1, kernel), Point(0, 0),
+                0, BORDER_REPLICATE);
+                filter2D(S, v, -1, Mat(2, 1, CV_32FC1, kernel), Point(0, 0),
+                0, BORDER_REPLICATE);
+
+                Mat hvMag = h.mul(h) + v.mul(v);
+
+                Mat mask;
+                if(S.channels() == 1)
+                {
+                    threshold(hvMag, mask, lambda/beta, 1, THRESH_BINARY);
+                }
+                else if(S.channels() > 1)
+                {
+                    vector<Mat> channels(S.channels());
+                    split(hvMag, channels);
+                    hvMag = channels[0];
+
+                    for(int i = 1; i < S.channels(); i++)
+                    {
+                        hvMag = hvMag + channels[i];
+                    }
+
+                    threshold(hvMag, mask, lambda/beta, 1, THRESH_BINARY);
+
+                    Mat in[] = {mask, mask, mask};
+                    merge(in, 3, mask);
+                }
+
+                h = h.mul(mask);
+                v = v.mul(mask);
+
+                // S subproblem
+                vector<Mat> denom(S.channels());
+                for(int i = 0; i < S.channels(); i++)
+                {
+                    denom[i] = beta * denomConst[i] + 1;
+                }
+
+                Mat hGrad, vGrad;
+                filter2D(h, hGrad, -1, Mat(1, 2, CV_32FC1, kernel_inv));
+                filter2D(v, vGrad, -1, Mat(2, 1, CV_32FC1, kernel_inv));
+
+                vector<Mat> hvGradFreq;
+                dftMultiChannel(hGrad+vGrad, hvGradFreq);
+
+                vector<Mat> numer(S.channels());
+                for(int i = 0; i < S.channels(); i++)
+                {
+                    numer[i] = numerConst[i] + hvGradFreq[i] * beta;
+                }
+
+                vector<Mat> sFreq(S.channels());
+                divComplexByRealMultiChannel(numer, denom, sFreq);
+
+                idftMultiChannel(sFreq, S);
+
+                beta = beta * kappa;
+            }
+
+            Mat D = dst.getMat();
+            if(D.depth() == CV_8U)
+            {
+                S.convertTo(D, CV_8U, 255);
+            }
+            else if(D.depth() == CV_16U)
+            {
+                S.convertTo(D, CV_16U, 65535);
+            }
+            else if(D.depth() == CV_64F)
+            {
+                S.convertTo(D, CV_64F);
+            }
+            else
+            {
+                S.copyTo(D);
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/lsc.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/lsc.cpp
new file mode 100644
index 00000000..9ef507c8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/lsc.cpp
@@ -0,0 +1,1800 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright (c) 2014, 2015
+ * Zhengqin Li <li-zq12 at mails dot tsinghua dot edu dot cn>
+ * Jiansheng Chen <jschenthu at mail dot tsinghua dot edu dot cn>
+ * Tsinghua University
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the copyright holders nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+/*
+
+ "Superpixel Segmentation using Linear Spectral Clustering"
+ Zhengqin Li, Jiansheng Chen, IEEE Conference on Computer Vision and Pattern
+ Recognition (CVPR), Jun. 2015
+
+ OpenCV port by: Cristian Balint <cristian dot balint at gmail dot com>
+ */
+
+#include <map>
+#include <queue>
+#include "precomp.hpp"
+
+using namespace std;
+
+
+namespace cv {
+namespace ximgproc {
+
+class SuperpixelLSCImpl : public SuperpixelLSC
+{
+public:
+
+    SuperpixelLSCImpl( InputArray image, int region_size, float ratio );
+
+    virtual ~SuperpixelLSCImpl() CV_OVERRIDE;
+
+    // perform amount of iteration
+    virtual void iterate( int num_iterations = 10 ) CV_OVERRIDE;
+
+    // get amount of superpixels
+    virtual int getNumberOfSuperpixels() const CV_OVERRIDE;
+
+    // get image with labels
+    virtual void getLabels( OutputArray labels_out ) const CV_OVERRIDE;
+
+    // get mask image with contour
+    virtual void getLabelContourMask( OutputArray image, bool thick_line = true ) const CV_OVERRIDE;
+
+    // enforce connectivity over labels
+    virtual void enforceLabelConnectivity( int min_element_size ) CV_OVERRIDE;
+
+
+protected:
+
+    // image width
+    int m_width;
+
+    // image width
+    int m_height;
+
+    // seeds stepx
+    int m_stepx;
+
+    // seeds stepy
+    int m_stepy;
+
+    // image channels
+    int m_nr_channels;
+
+    // region size
+    int m_region_size;
+
+    // ratio
+    float m_ratio;
+
+private:
+
+    // labels no
+    int m_numlabels;
+
+    // color coefficient
+    float m_color_coeff;
+
+    // dist coefficient
+    float m_dist_coeff;
+
+    // threshold coeff
+    int m_threshold_coeff;
+
+    // max value from
+    // image channels
+    float m_chvec_max;
+
+    // stacked channels
+    // of original image
+    vector<Mat> m_chvec;
+
+    // seeds on x
+    vector<float> m_kseedsx;
+
+    // seeds on y
+    vector<float> m_kseedsy;
+
+    // W
+    Mat m_W;
+
+    // labels storage
+    Mat m_klabels;
+
+    // initialization
+    inline void initialize();
+
+    // fetch seeds
+    inline void GetChSeeds();
+
+    // precompute vector space
+    inline void GetFeatureSpace();
+
+    // LSC
+    inline void PerformLSC( const int& num_iterations );
+
+    // pre-enforce connectivity over labels
+    inline void PreEnforceLabelConnectivity( int min_element_size );
+
+    // enforce connectivity over labels
+    inline void PostEnforceLabelConnectivity( int threshold );
+
+    // re-count superpixles
+    inline void countSuperpixels();
+
+};
+
+class Superpixel
+{
+public:
+
+    int Label, Size;
+    vector<int> Neighbor, xLoc, yLoc;
+
+    Superpixel( int L = 0, int S = 0 ) : Label(L), Size(S) { }
+
+    friend bool operator == ( Superpixel& S, int L )
+    {
+        return S.Label == L;
+    }
+    friend bool operator == ( int L, Superpixel& S )
+    {
+        return S.Label == L;
+    }
+};
+
+CV_EXPORTS Ptr<SuperpixelLSC> createSuperpixelLSC( InputArray image, int region_size, float ratio )
+{
+    return makePtr<SuperpixelLSCImpl>( image, region_size, ratio );
+}
+
+SuperpixelLSCImpl::SuperpixelLSCImpl( InputArray _image, int _region_size, float _ratio )
+                   : m_region_size(_region_size), m_ratio(_ratio)
+{
+    if ( _image.isMat() )
+    {
+      Mat image = _image.getMat();
+
+      // image should be valid
+      CV_Assert( !image.empty() );
+
+      // initialize sizes
+      m_width = image.size().width;
+      m_height = image.size().height;
+      m_nr_channels = image.channels();
+
+      // intialize channels
+      split( image, m_chvec );
+    }
+    else if ( _image.isMatVector() )
+    {
+      _image.getMatVector( m_chvec );
+
+      // array should be valid
+      CV_Assert( !m_chvec.empty() );
+
+      // initialize sizes
+      m_width = m_chvec[0].size().width;
+      m_height = m_chvec[0].size().height;
+      m_nr_channels = (int) m_chvec.size();
+    }
+    else
+      CV_Error( Error::StsInternal, "Invalid InputArray." );
+
+    // init
+    initialize();
+
+    // feature space
+    GetFeatureSpace();
+}
+
+SuperpixelLSCImpl::~SuperpixelLSCImpl()
+{
+}
+
+int SuperpixelLSCImpl::getNumberOfSuperpixels() const
+{
+    return m_numlabels;
+}
+
+void SuperpixelLSCImpl::initialize()
+{
+    // basic coeffs
+    m_color_coeff = 20.0f;
+    m_threshold_coeff = 4;
+    m_dist_coeff = m_color_coeff * m_ratio;
+
+    // total amount of superpixels given region size
+    m_numlabels = int(float(m_width * m_height)
+                /  float(m_region_size * m_region_size));
+
+    // max intensity
+    m_chvec_max = 0.0f;
+    for( int b = 0; b < m_nr_channels; b++ )
+    {
+      double chmin, chmax;
+      minMaxIdx( m_chvec[b], &chmin, &chmax );
+      if ( m_chvec_max < chmax ) m_chvec_max = (float) chmax;
+    }
+
+    // intitialize label storage
+    m_klabels = Mat( m_height, m_width, CV_32S, Scalar::all(0) );
+
+    // init seeds
+    GetChSeeds();
+}
+
+void SuperpixelLSCImpl::iterate( int num_iterations )
+{
+    PerformLSC( num_iterations );
+}
+
+void SuperpixelLSCImpl::getLabels(OutputArray labels_out) const
+{
+    labels_out.assign( m_klabels );
+}
+
+void SuperpixelLSCImpl::getLabelContourMask(OutputArray _mask, bool _thick_line) const
+{
+    // default width
+    int line_width = 2;
+
+    if ( !_thick_line ) line_width = 1;
+
+    _mask.create( m_height, m_width, CV_8UC1 );
+    Mat mask = _mask.getMat();
+
+    mask.setTo(0);
+
+    const int dx8[8] = { -1, -1,  0,  1, 1, 1, 0, -1 };
+    const int dy8[8] = {  0, -1, -1, -1, 0, 1, 1,  1 };
+
+    int sz = m_width*m_height;
+
+    vector<bool> istaken(sz, false);
+
+    int mainindex = 0;
+    for( int j = 0; j < m_height; j++ )
+    {
+      for( int k = 0; k < m_width; k++ )
+      {
+        int np = 0;
+        for( int i = 0; i < 8; i++ )
+        {
+          int x = k + dx8[i];
+          int y = j + dy8[i];
+
+          if( (x >= 0 && x < m_width) && (y >= 0 && y < m_height) )
+          {
+            int index = y*m_width + x;
+
+            if( false == istaken[index] )
+            {
+              if( m_klabels.at<int>(j,k) != m_klabels.at<int>(y,x) ) np++;
+            }
+          }
+        }
+        if( np > line_width )
+        {
+           mask.at<char>(j,k) = (uchar)255;
+           istaken[mainindex] = true;
+        }
+        mainindex++;
+      }
+    }
+}
+
+/*
+ * enforceLabelConnectivity
+ *
+ *   1. finding an adjacent label for each new component at the start
+ *   2. if a certain component is too small, assigning the previously found
+ *      adjacent label to this component, and not incrementing the label.
+ *
+ */
+void SuperpixelLSCImpl::enforceLabelConnectivity( int min_element_size )
+{
+    int threshold = (m_width * m_height)
+                  / (m_numlabels * m_threshold_coeff);
+
+    PreEnforceLabelConnectivity( min_element_size );
+    PostEnforceLabelConnectivity( threshold );
+    countSuperpixels();
+}
+
+/*
+ * countSuperpixels()
+ *
+ *   1. count unique superpixels
+ *   2. relabel all superpixels
+ *
+ */
+inline void SuperpixelLSCImpl::countSuperpixels()
+{
+    std::map<int,int> labels;
+
+    int labelNum = 0;
+    int prev_label = -1;
+    int mark_label = 0;
+    for( int x = 0; x < m_width; x++ )
+    {
+      for( int y = 0; y < m_height; y++ )
+      {
+        int curr_label = m_klabels.at<int>(y,x);
+
+        // relax, just do relabel
+        if ( curr_label == prev_label )
+        {
+          m_klabels.at<int>(y,x) = mark_label;
+          continue;
+        }
+
+        // on label change do map lookup
+        map<int,int>::iterator it = labels.find( curr_label );
+
+        // if new label seen
+        if ( it == labels.end() )
+        {
+          mark_label = labelNum; labelNum++;
+          labels.insert( pair<int,int>( curr_label, mark_label ) );
+          m_klabels.at<int>(y,x) = mark_label;
+        } else
+        {
+          mark_label = it->second;
+          m_klabels.at<int>(y,x) = mark_label;
+        }
+        prev_label = curr_label;
+      }
+    }
+    m_numlabels = (int) labels.size();
+}
+
+/*
+ * PreEnforceLabelConnectivity
+ *
+ *   1. finding an adjacent label for each new component at the start
+ *   2. if a certain component is too small, assigning the previously found
+ *      adjacent label to this component, and not incrementing the label.
+ *
+ */
+inline void SuperpixelLSCImpl::PreEnforceLabelConnectivity( int min_element_size )
+{
+    const int dx8[8] = { -1, -1,  0,  1,  1,  1,  0, -1 };
+    const int dy8[8] = {  0, -1, -1, -1,  0,  1,  1,  1 };
+
+    int adj = 0;
+    vector<int> xLoc, yLoc;
+    cv::Mat mask( m_height, m_width, CV_8U , Scalar::all(0) );
+
+    for( int i = 0; i < m_width; i++ )
+    {
+      for( int j = 0; j < m_height; j++)
+      {
+        if( mask.at<uchar>(j,i) == 0 )
+        {
+          int L = m_klabels.at<int>(j,i);
+
+          for( int k = 0; k < 8; k++ )
+          {
+            int x = i + dx8[k];
+            int y = j + dy8[k];
+            if ( x >= 0 && x <= m_width -1
+              && y >= 0 && y <= m_height-1)
+            {
+              if ( mask.at<uchar>(y,x) == 1
+                 && m_klabels.at<int>(y,x) != L )
+                adj = m_klabels.at<int>(y,x);
+              break;
+            }
+          }
+
+          mask.at<uchar>(j,i) = 1;
+          xLoc.insert( xLoc.end(), i );
+          yLoc.insert( yLoc.end(), j );
+
+          size_t indexMarker = 0;
+          while( indexMarker < xLoc.size() )
+          {
+            int x = xLoc[indexMarker];
+            int y = yLoc[indexMarker];
+
+            indexMarker++;
+
+            int minX = ( x-1 <= 0 ) ? 0 : x-1;
+            int minY = ( y-1 <= 0 ) ? 0 : y-1;
+            int maxX = ( x+1 >= m_width -1 ) ? m_width -1 : x+1;
+            int maxY = ( y+1 >= m_height-1 ) ? m_height-1 : y+1;
+            for( int m = minX; m <= maxX; m++ )
+            {
+              for( int n = minY; n <= maxY; n++ )
+              {
+                if (   mask.at<uchar>(n,m) == 0
+                 && m_klabels.at<int>(n,m) == L )
+                {
+                  mask.at<uchar>(n,m) = 1;
+                  xLoc.insert( xLoc.end(), m );
+                  yLoc.insert( yLoc.end(), n );
+                }
+              }
+            }
+          }
+          if ( indexMarker < (size_t) min_element_size )
+          {
+            for( size_t k = 0; k < xLoc.size(); k++ )
+            {
+              int x = xLoc[k];
+              int y = yLoc[k];
+              m_klabels.at<int>(y,x) = adj;
+            }
+          }
+          xLoc.clear();
+          yLoc.clear();
+        }
+      }
+    }
+}
+
+/*
+ * PostEnforceLabelConnectivity
+ *
+ */
+inline void SuperpixelLSCImpl::PostEnforceLabelConnectivity( int threshold )
+{
+    float PI2 = float(CV_PI / 2.0f);
+
+    vector<float> centerW;
+    queue <int> xLoc, yLoc;
+    vector<float> centerX1, centerX2;
+    vector<float> centerY1, centerY2;
+    vector<int> strayX, strayY, Size;
+    vector< vector<float> > centerC1( m_nr_channels );
+    vector< vector<float> > centerC2( m_nr_channels );
+
+    cv::Mat mask( m_height, m_width, CV_8U, Scalar::all(0) );
+
+    int L;
+    int sLabel = -1;
+    for( int i = 0; i < m_width; i++ )
+    {
+      for( int j = 0; j < m_height; j++ )
+      {
+        if( mask.at<uchar>(j,i) == 0 )
+        {
+          sLabel++;
+          int count = 1;
+
+          centerW.insert( centerW.end(), 0 );
+          for ( int b = 0; b < m_nr_channels; b++ )
+          {
+            centerC1[b].insert( centerC1[b].end(), 0 );
+            centerC2[b].insert( centerC2[b].end(), 0 );
+          }
+          centerX1.insert( centerX1.end(), 0 );
+          centerX2.insert( centerX2.end(), 0 );
+          centerY1.insert( centerY1.end(), 0 );
+          centerY2.insert( centerY2.end(), 0 );
+
+          strayX.insert( strayX.end(), i );
+          strayY.insert( strayY.end(), j );
+
+          float Weight = m_W.at<float>(j,i);
+
+          // accumulate dists
+          centerW[sLabel] += Weight;
+          for ( int b = 0; b < m_nr_channels; b++ )
+          {
+
+            float thetaC = 0.0f;
+            switch ( m_chvec[b].depth() )
+            {
+              case CV_8U:
+                thetaC = ( (float) m_chvec[b].at<uchar>(j,i)  / m_chvec_max ) * PI2;
+                break;
+              case CV_8S:
+                thetaC = ( (float) m_chvec[b].at<char>(j,i)   / m_chvec_max ) * PI2;
+                break;
+              case CV_16U:
+                thetaC = ( (float) m_chvec[b].at<ushort>(j,i) / m_chvec_max ) * PI2;
+                break;
+              case CV_16S:
+                thetaC = ( (float) m_chvec[b].at<short>(j,i)  / m_chvec_max ) * PI2;
+                break;
+              case CV_32S:
+                thetaC = ( (float) m_chvec[b].at<int>(j,i)    / m_chvec_max ) * PI2;
+                break;
+              case CV_32F:
+                thetaC = ( (float) m_chvec[b].at<float>(j,i)  / m_chvec_max ) * PI2;
+                break;
+              case CV_64F:
+                thetaC = ( (float) m_chvec[b].at<double>(j,i) / m_chvec_max ) * PI2;
+                break;
+              default:
+                CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                break;
+            }
+
+            // we do not store pre-computed C1[b], C2[b]
+            float C1 = m_color_coeff * cos(thetaC) / m_nr_channels;
+            float C2 = m_color_coeff * sin(thetaC) / m_nr_channels;
+
+            centerC1[b][sLabel] += C1; centerC2[b][sLabel] += C2;
+          }
+
+          float thetaX = ( (float) i / (float) m_stepx ) * PI2;
+          // we do not store pre-computed x1, x2
+          float X1 = m_dist_coeff * cos(thetaX);
+          float X2 = m_dist_coeff * sin(thetaX);
+
+          float thetaY = ( (float) j / (float) m_stepy ) * PI2;
+          // we do not store pre-computed y1, y2
+          float Y1 = m_dist_coeff * cos(thetaY);
+          float Y2 = m_dist_coeff * sin(thetaY);
+
+          centerX1[sLabel] += X1; centerX2[sLabel] += X2;
+          centerY1[sLabel] += Y1; centerY2[sLabel] += Y2;
+
+          L = m_klabels.at<int>(j,i);
+          m_klabels.at<int>(j,i) = sLabel;
+
+          mask.at<uchar>(j,i) = 1;
+
+          xLoc.push( i ); yLoc.push( j );
+          while( !xLoc.empty() )
+          {
+            int x = xLoc.front(); xLoc.pop();
+            int y = yLoc.front(); yLoc.pop();
+            int minX = ( x-1 <=0 ) ? 0 : x-1;
+            int minY = ( y-1 <=0 ) ? 0 : y-1;
+            int maxX = ( x+1 >= m_width -1 ) ? m_width -1 : x+1;
+            int maxY = ( y+1 >= m_height-1 ) ? m_height-1 : y+1;
+            for( int m = minX; m <= maxX; m++ )
+            {
+              for( int n = minY; n <= maxY; n++ )
+              {
+                if(   mask.at<uchar>(n,m) == 0
+                && m_klabels.at<int>(n,m) == L )
+                {
+                  count++;
+                  xLoc.push(m); yLoc.push(n);
+
+                  mask.at<uchar>(n,m) = 1;
+                  m_klabels.at<int>(n,m) = sLabel;
+
+                  Weight = m_W.at<float>(n,m);
+                  centerW[sLabel] += Weight;
+                  for ( int b = 0; b < m_nr_channels; b++ )
+                  {
+                    float thetaC = 0.0f;
+                    switch ( m_chvec[b].depth() )
+                    {
+                      case CV_8U:
+                        thetaC = ( (float) m_chvec[b].at<uchar>(j,i)  / m_chvec_max ) * PI2;
+                        break;
+                      case CV_8S:
+                        thetaC = ( (float) m_chvec[b].at<char>(j,i)   / m_chvec_max ) * PI2;
+                        break;
+                      case CV_16U:
+                        thetaC = ( (float) m_chvec[b].at<ushort>(j,i) / m_chvec_max ) * PI2;
+                        break;
+                      case CV_16S:
+                        thetaC = ( (float) m_chvec[b].at<short>(j,i)  / m_chvec_max ) * PI2;
+                        break;
+                      case CV_32S:
+                        thetaC = ( (float) m_chvec[b].at<int>(j,i)    / m_chvec_max ) * PI2;
+                        break;
+                      case CV_32F:
+                        thetaC = ( (float) m_chvec[b].at<float>(j,i)  / m_chvec_max ) * PI2;
+                        break;
+                      case CV_64F:
+                        thetaC = ( (float) m_chvec[b].at<double>(j,i) / m_chvec_max ) * PI2;
+                        break;
+                      default:
+                        CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                        break;
+                    }
+                    // we do not store pre-computed C1[b], C2[b]
+                    float C1 = m_color_coeff * cos(thetaC) / m_nr_channels;
+                    float C2 = m_color_coeff * sin(thetaC) / m_nr_channels;
+
+                    centerC1[b][sLabel] += C1; centerC2[b][sLabel] += C2;
+                  }
+
+                  thetaX = ( (float) m / (float) m_stepx ) * PI2;
+                  // we do not store pre-computed x1, x2
+                  X1 = m_dist_coeff * cos(thetaX);
+                  X2 = m_dist_coeff * sin(thetaX);
+
+                  thetaY = ( (float) n / (float) m_stepy ) * PI2;
+                  // we do not store pre-computed y1, y2
+                  Y1 = m_dist_coeff * cos(thetaY);
+                  Y2 = m_dist_coeff * sin(thetaY);
+
+                  centerX1[sLabel] += X1; centerX2[sLabel] += X2;
+                  centerY1[sLabel] += Y1; centerY2[sLabel] += Y2;
+
+                }
+              }
+            }
+          }
+          Size.insert( Size.end(), count );
+          for ( int b = 0; b < m_nr_channels; b++ )
+          {
+            centerC1[b][sLabel] /= centerW[sLabel];
+            centerC2[b][sLabel] /= centerW[sLabel];
+          }
+          centerX1[sLabel] /= centerW[sLabel];
+          centerX2[sLabel] /= centerW[sLabel];
+          centerY1[sLabel] /= centerW[sLabel];
+          centerY2[sLabel] /= centerW[sLabel];
+        }
+      }
+    }
+    sLabel++;
+
+    vector<Superpixel> Sarray;
+    vector<int>::iterator Pointer;
+    for( int i = 0; i < sLabel; i++)
+    {
+      if( Size[i] < threshold )
+      {
+        int x = strayX[i];
+        int y = strayY[i];
+
+        L = m_klabels.at<int>(y,x);
+        mask.at<uchar>(y,x) = 0;
+
+        size_t indexMark = 0;
+        Superpixel S( L, Size[i] );
+
+        S.xLoc.insert( S.xLoc.end(),x );
+        S.yLoc.insert( S.yLoc.end(),y );
+        while( indexMark < S.xLoc.size() )
+        {
+          x = S.xLoc[indexMark];
+          y = S.yLoc[indexMark];
+
+          indexMark++;
+
+          int minX = ( x-1 <= 0 ) ? 0 : x-1;
+          int minY = ( y-1 <= 0 ) ? 0 : y-1;
+          int maxX = ( x+1 >= m_width -1 ) ? m_width -1 : x+1;
+          int maxY = ( y+1 >= m_height-1 ) ? m_height-1 : y+1;
+          for( int m = minX; m <= maxX; m++ )
+          {
+            for( int n = minY; n <= maxY; n++ )
+            {
+              if(   mask.at<uchar>(n,m) == 1
+              && m_klabels.at<int>(n,m) == L )
+              {
+                mask.at<uchar>(n,m) = 0;
+
+                S.xLoc.insert( S.xLoc.end(), m );
+                S.yLoc.insert( S.yLoc.end(), n );
+              }
+              else if( m_klabels.at<int>(n,m) != L )
+              {
+                int NewLabel = m_klabels.at<int>(n,m);
+                Pointer = find( S.Neighbor.begin(), S.Neighbor.end(), NewLabel );
+                if ( Pointer == S.Neighbor.end() )
+                {
+                  S.Neighbor.insert( S.Neighbor.begin(), NewLabel );
+                }
+              }
+            }
+          }
+        }
+        Sarray.insert(Sarray.end(),S);
+      }
+    }
+
+    vector<int>::iterator I, I2;
+    vector<Superpixel>::iterator S;
+
+    S = Sarray.begin();
+    while( S != Sarray.end() )
+    {
+      int Label1 = (*S).Label;
+      int Label2 = -1;
+
+      double MinDist = DBL_MAX;
+      for ( I = (*S).Neighbor.begin(); I != (*S).Neighbor.end(); I++ )
+      {
+        double D = 0.0f;
+
+        for ( int b = 0; b < m_nr_channels; b++ )
+        {
+          float diffcenterC1 = centerC1[b][Label1]
+                             - centerC1[b][*I];
+          float diffcenterC2 = centerC2[b][Label1]
+                             - centerC2[b][*I];
+
+          D += (diffcenterC1 * diffcenterC1)
+             + (diffcenterC2 * diffcenterC2);
+        }
+
+        float diffcenterX1 = centerX1[Label1] - centerX1[*I];
+        float diffcenterX2 = centerX2[Label1] - centerX2[*I];
+        float diffcenterY1 = centerY1[Label1] - centerY1[*I];
+        float diffcenterY2 = centerY2[Label1] - centerY2[*I];
+
+        D += (diffcenterX1 * diffcenterX1)
+           + (diffcenterX2 * diffcenterX2)
+           + (diffcenterY1 * diffcenterY1)
+           + (diffcenterY2 * diffcenterY2);
+
+        // if within dist
+        if ( D < MinDist )
+        {
+          MinDist = D;
+          Label2 = (*I);
+        }
+      }
+
+      double W1 = centerW[Label1];
+      double W2 = centerW[Label2];
+
+      double W = W1 + W2;
+
+      if ( (Label1 > 0) && (Label2 > 0) )
+      {
+        for ( int b = 0; b < m_nr_channels; b++ )
+        {
+          centerC1[b][Label2] = float((W2*centerC1[b][Label2] + W1*centerC1[b][Label1]) / W);
+          centerC2[b][Label2] = float((W2*centerC2[b][Label2] + W1*centerC2[b][Label1]) / W);
+        }
+        centerX1[Label2] = float((W2*centerX1[Label2] + W1*centerX1[Label1]) / W);
+        centerX2[Label2] = float((W2*centerX2[Label2] + W1*centerX2[Label1]) / W);
+        centerY1[Label2] = float((W2*centerY1[Label2] + W1*centerY1[Label1]) / W);
+        centerY2[Label2] = float((W2*centerY2[Label2] + W1*centerY2[Label1]) / W);
+
+        centerW[Label2] = (float)W;
+        for( size_t i = 0; i < (*S).xLoc.size(); i++ )
+        {
+          int x = (*S).xLoc[i];
+          int y = (*S).yLoc[i];
+          m_klabels.at<int>(y,x) = Label2;
+        }
+      }
+
+      vector<Superpixel>::iterator Stmp;
+      Stmp = find( Sarray.begin(), Sarray.end(), Label2 );
+      if( Stmp != Sarray.end() )
+      {
+        Size[Label2] = Size[Label1] + Size[Label2];
+        if( Size[Label2] >= threshold )
+        {
+          if( S == Stmp )
+          {
+            // erasing only one should be sufficient when the iterators are the same
+            // (maybe the case S == Stmp is not even possible?)
+            Sarray.erase( S );
+          }
+          else if( S < Stmp )
+          {
+            // erase the latter element first, so the other iterator is not invalidated
+            Sarray.erase( Stmp );
+            Sarray.erase( S );
+          }
+          else
+          {
+            Sarray.erase( S );
+            Sarray.erase( Stmp );
+          }
+        }
+        else
+        {
+          (*Stmp).xLoc.insert( (*Stmp).xLoc.end(), (*S).xLoc.begin(), (*S).xLoc.end() );
+          (*Stmp).yLoc.insert( (*Stmp).yLoc.end(), (*S).yLoc.begin(), (*S).yLoc.end() );
+
+          (*Stmp).Neighbor.insert( (*Stmp).Neighbor.end(), (*S).Neighbor.begin(), (*S).Neighbor.end() );
+
+          sort( (*Stmp).Neighbor.begin(), (*Stmp).Neighbor.end() );
+
+          I = unique( (*Stmp).Neighbor.begin(), (*Stmp).Neighbor.end() );
+          (*Stmp).Neighbor.erase( I, (*Stmp).Neighbor.end() );
+
+          I = find  ( (*Stmp).Neighbor.begin(), (*Stmp).Neighbor.end(), Label1 );
+          (*Stmp).Neighbor.erase( I );
+
+          I = find  ( (*Stmp).Neighbor.begin(), (*Stmp).Neighbor.end(), Label2 );
+          (*Stmp).Neighbor.erase( I );
+
+          Sarray.erase( S );
+        }
+      } else Sarray.erase( S );
+
+      for( size_t i = 0; i < Sarray.size(); i++ )
+      {
+        I  = find( Sarray[i].Neighbor.begin(), Sarray[i].Neighbor.end(), Label1 );
+        I2 = find( Sarray[i].Neighbor.begin(), Sarray[i].Neighbor.end(), Label2 );
+
+        if ( I  != Sarray[i].Neighbor.end()
+        &&   I2 != Sarray[i].Neighbor.end() )
+        {
+          Sarray[i].Neighbor.erase( I );
+        }
+        else
+        if ( I  != Sarray[i].Neighbor.end()
+         &&  I2 == Sarray[i].Neighbor.end() )
+        {
+          (*I) = Label2;
+        }
+      }
+
+      S = Sarray.begin();
+
+    }
+}
+
+/*
+ * GetChannelsSeeds_ForGivenStepSize
+ *
+ * The k seed values are
+ * taken as uniform spatial
+ * pixel samples.
+ *
+ */
+inline void SuperpixelLSCImpl::GetChSeeds()
+{
+    int ColNum = (int) sqrt( (double) m_numlabels
+               * ((double)m_width / (double)m_height) );
+    int RowNum = m_numlabels / ColNum;
+
+    m_stepx = m_width / ColNum;
+    m_stepy = m_height / RowNum;
+
+    int Col_remain = m_width  - (m_stepx*ColNum);
+    int Row_remain = m_height - (m_stepy*RowNum);
+
+    int count = 0;
+    int t1 = 1, t2 = 1;
+    int centerx, centery;
+
+    for( int x = 0; x < ColNum; x++ )
+    {
+      t2 = 1;
+      centerx = int((x*m_stepx) + (0.5f*m_stepx) + t1);
+      if ( centerx >= m_width -1 ) centerx = m_width -1;
+
+      for( int y = 0; y < RowNum; y++ )
+      {
+        centery = int((y*m_stepy) + (0.5f*m_stepy) + t2);
+
+        if ( t2 < Row_remain ) t2++;
+        if ( centery >= m_height-1 ) centery = m_height-1;
+
+        m_kseedsx.push_back( (float)centerx );
+        m_kseedsy.push_back( (float)centery );
+
+        count++;
+      }
+      if ( t1 < Col_remain ) t1++;
+    }
+    // update amount
+    m_numlabels = count;
+}
+
+struct FeatureSpaceSigmas
+{
+    FeatureSpaceSigmas( const vector< Mat >& _chvec, const int _nr_channels,
+                        const float _chvec_max, const float _dist_coeff,
+                        const float _color_coeff, const int _stepx, const int _stepy )
+    {
+      chvec = _chvec;
+      stepx = _stepx;
+      stepy = _stepy;
+      chvec_max = _chvec_max;
+      dist_coeff = _dist_coeff;
+      nr_channels = _nr_channels;
+      color_coeff = _color_coeff;
+
+      PI2 = float(CV_PI / 2.0f);
+      sigmaX1 = 0; sigmaX2 = 0;
+      sigmaY1 = 0; sigmaY2 = 0;
+      sigmaC1.resize( nr_channels );
+      sigmaC2.resize( nr_channels );
+      fill( sigmaC1.begin(), sigmaC1.end(), 0 );
+      fill( sigmaC2.begin(), sigmaC2.end(), 0 );
+    }
+
+    FeatureSpaceSigmas( const FeatureSpaceSigmas& counter, Split )
+    {
+      *this = counter;
+      sigmaX1 = 0; sigmaX2 = 0;
+      sigmaY1 = 0; sigmaY2 = 0;
+      sigmaC1.resize( nr_channels );
+      sigmaC2.resize( nr_channels );
+      fill( sigmaC1.begin(), sigmaC1.end(), 0 );
+      fill( sigmaC2.begin(), sigmaC2.end(), 0 );
+    }
+
+    void operator()( const BlockedRange& range )
+    {
+      // previous block state
+      double tmp_sigmaX1 = sigmaX1;
+      double tmp_sigmaX2 = sigmaX2;
+      double tmp_sigmaY1 = sigmaY1;
+      double tmp_sigmaY2 = sigmaY2;
+      vector<double> tmp_sigmaC1( nr_channels );
+      vector<double> tmp_sigmaC2( nr_channels );
+      for( int b = 0; b < nr_channels; b++ )
+      {
+        tmp_sigmaC1[b] = sigmaC1[b];
+        tmp_sigmaC2[b] = sigmaC2[b];
+      }
+
+      for ( int x = range.begin(); x != range.end(); x++ )
+      {
+        float thetaX = ( (float) x / (float) stepx ) * PI2;
+        // we do not store pre-computed x1, x2
+        float x1 = dist_coeff * cos(thetaX);
+        float x2 = dist_coeff * sin(thetaX);
+
+        for( int y = 0; y < chvec[0].rows; y++ )
+        {
+          float thetaY = ( (float) y / (float) stepy ) * PI2;
+          // we do not store pre-computed y1, y2
+          float y1 = dist_coeff * cos(thetaY);
+          float y2 = dist_coeff * sin(thetaY);
+
+          // accumulate distance sigmas
+          tmp_sigmaX1 += x1; tmp_sigmaX2 += x2;
+          tmp_sigmaY1 += y1; tmp_sigmaY2 += y2;
+
+          for( int b = 0; b < nr_channels; b++ )
+          {
+            float thetaC = 0.0f;
+            switch ( chvec[b].depth() )
+            {
+              case CV_8U:
+                thetaC = ( (float) chvec[b].at<uchar>(y,x)  / chvec_max ) * PI2;
+                break;
+              case CV_8S:
+                thetaC = ( (float) chvec[b].at<char>(y,x)   / chvec_max ) * PI2;
+                break;
+              case CV_16U:
+                thetaC = ( (float) chvec[b].at<ushort>(y,x) / chvec_max ) * PI2;
+                break;
+              case CV_16S:
+                thetaC = ( (float) chvec[b].at<short>(y,x)  / chvec_max ) * PI2;
+                break;
+              case CV_32S:
+                thetaC = ( (float) chvec[b].at<int>(y,x)    / chvec_max ) * PI2;
+                break;
+              case CV_32F:
+                thetaC = ( (float) chvec[b].at<float>(y,x)  / chvec_max ) * PI2;
+                break;
+              case CV_64F:
+                thetaC = ( (float) chvec[b].at<double>(y,x) / chvec_max ) * PI2;
+                break;
+              default:
+                CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                break;
+            }
+            // we do not store pre-computed C1[b], C2[b]
+            float C1 = color_coeff * cos(thetaC) / nr_channels;
+            float C2 = color_coeff * sin(thetaC) / nr_channels;
+
+            // accumulate sigmas per channels
+            tmp_sigmaC1[b] += C1; tmp_sigmaC2[b] += C2;
+          }
+        }
+      }
+      sigmaX1 = tmp_sigmaX1; sigmaX2 = tmp_sigmaX2;
+      sigmaY1 = tmp_sigmaY1; sigmaY2 = tmp_sigmaY2;
+      for( int b = 0; b < nr_channels; b++ )
+      {
+        sigmaC1[b] = tmp_sigmaC1[b];
+        sigmaC2[b] = tmp_sigmaC2[b];
+      }
+    }
+
+    void join( FeatureSpaceSigmas& fsc )
+    {
+      sigmaX1 += fsc.sigmaX1; sigmaX2 += fsc.sigmaX2;
+      sigmaY1 += fsc.sigmaY1; sigmaY2 += fsc.sigmaY2;
+      for( int b = 0; b < nr_channels; b++ )
+      {
+        sigmaC1[b] += fsc.sigmaC1[b];
+        sigmaC2[b] += fsc.sigmaC2[b];
+      }
+    }
+
+    float PI2;
+    int nr_channels;
+    int stepx, stepy;
+
+    double sigmaX1, sigmaX2;
+    double sigmaY1, sigmaY2;
+
+    float chvec_max;
+    float dist_coeff;
+    float color_coeff;
+
+    vector<Mat> chvec;
+    vector<double> sigmaC1;
+    vector<double> sigmaC2;
+};
+
+struct FeatureSpaceWeights : ParallelLoopBody
+{
+    FeatureSpaceWeights( const vector< Mat >& _chvec, Mat* _W,
+                         const double _sigmaX1, const double _sigmaX2,
+                         const double _sigmaY1, const double _sigmaY2,
+                         vector<double>& _sigmaC1, vector<double>& _sigmaC2,
+                         const int _nr_channels, const float _chvec_max,
+                         const float _dist_coeff, const float _color_coeff,
+                         const int _stepx, const int _stepy )
+    {
+      W = _W;
+      chvec = _chvec;
+      stepx = _stepx;
+      stepy = _stepy;
+      chvec_max = _chvec_max;
+      dist_coeff = _dist_coeff;
+      nr_channels = _nr_channels;
+      color_coeff = _color_coeff;
+
+      PI2 = float(CV_PI / 2.0f);
+
+      sigmaX1 = _sigmaX1; sigmaX2 = _sigmaX2;
+      sigmaY1 = _sigmaY1; sigmaY2 = _sigmaY2;
+      sigmaC1 = _sigmaC1; sigmaC2 = _sigmaC2;
+    }
+
+    void operator()( const Range& range ) const CV_OVERRIDE
+    {
+      for( int x = range.start; x < range.end; x++ )
+      {
+        float thetaX = ( (float) x / (float) stepx ) * PI2;
+
+        for( int y = 0; y < chvec[0].rows; y++ )
+        {
+          float thetaY = ( (float) y / (float) stepy ) * PI2;
+
+          // accumulate distance channels weighted by sigmas
+          W->at<float>(y,x) += float((dist_coeff * cos(thetaX)) * sigmaX1);
+          W->at<float>(y,x) += float((dist_coeff * sin(thetaX)) * sigmaX2);
+          W->at<float>(y,x) += float((dist_coeff * cos(thetaY)) * sigmaY1);
+          W->at<float>(y,x) += float((dist_coeff * sin(thetaY)) * sigmaY2);
+
+          for( int b = 0; b < nr_channels; b++ )
+          {
+            float thetaC = 0.0f;
+            switch ( chvec[b].depth() )
+            {
+              case CV_8U:
+                thetaC = ( (float) chvec[b].at<uchar>(y,x)  / chvec_max ) * PI2;
+                break;
+              case CV_8S:
+                thetaC = ( (float) chvec[b].at<char>(y,x)   / chvec_max ) * PI2;
+                break;
+              case CV_16U:
+                thetaC = ( (float) chvec[b].at<ushort>(y,x) / chvec_max ) * PI2;
+                break;
+              case CV_16S:
+                thetaC = ( (float) chvec[b].at<short>(y,x)  / chvec_max ) * PI2;
+                break;
+              case CV_32S:
+                thetaC = ( (float) chvec[b].at<int>(y,x)    / chvec_max ) * PI2;
+                break;
+              case CV_32F:
+                thetaC = ( (float) chvec[b].at<float>(y,x)  / chvec_max ) * PI2;
+                break;
+              case CV_64F:
+                thetaC = ( (float) chvec[b].at<double>(y,x) / chvec_max ) * PI2;
+                break;
+              default:
+                CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                break;
+            }
+            // accumulate color channels weighted by sigmas
+            W->at<float>(y,x) += float((color_coeff * cos(thetaC) / nr_channels) * sigmaC1[b]);
+            W->at<float>(y,x) += float((color_coeff * sin(thetaC) / nr_channels) * sigmaC2[b]);
+          }
+        }
+      }
+    }
+
+    Mat* W;
+    float PI2;
+    int nr_channels;
+    int stepx, stepy;
+
+    double sigmaX1, sigmaX2;
+    double sigmaY1, sigmaY2;
+
+    float chvec_max;
+    float dist_coeff;
+    float color_coeff;
+
+    vector<Mat> chvec;
+    vector<double> sigmaC1;
+    vector<double> sigmaC2;
+};
+
+/*
+ * Compute Feature Space
+ *
+ *
+ */
+inline void SuperpixelLSCImpl::GetFeatureSpace()
+{
+    double sigmaX1 = 0.0f, sigmaX2 = 0.0f;
+    double sigmaY1 = 0.0f, sigmaY2 = 0.0f;
+    vector<double> sigmaC1( m_nr_channels , 0.0f );
+    vector<double> sigmaC2( m_nr_channels , 0.0f );
+
+    // compute feature space accumulation sigmas
+    FeatureSpaceSigmas fss( m_chvec, m_nr_channels, m_chvec_max,
+                            m_dist_coeff, m_color_coeff, m_stepx, m_stepy );
+    parallel_reduce( BlockedRange(0, m_width), fss );
+
+    sigmaX1 = fss.sigmaX1; sigmaX2 = fss.sigmaX2;
+    sigmaY1 = fss.sigmaY1; sigmaY2 = fss.sigmaY2;
+    for( int b = 0; b < m_nr_channels; b++ )
+    {
+      sigmaC1[b] = fss.sigmaC1[b];
+      sigmaC2[b] = fss.sigmaC2[b];
+    }
+
+    // normalize sigmas
+    sigmaY1 /= m_width*m_height;
+    sigmaY2 /= m_width*m_height;
+    sigmaX1 /= m_width*m_height;
+    sigmaX2 /= m_width*m_height;
+    for( int b = 0; b < m_nr_channels; b++ )
+    {
+      sigmaC1[b] /= m_width*m_height;
+      sigmaC2[b] /= m_width*m_height;
+    }
+
+    // compute m_W normalization array
+    m_W = Mat( m_height, m_width, CV_32F, 0.0f );
+    parallel_for_( Range(0, m_width), FeatureSpaceWeights( m_chvec, &m_W,
+                   sigmaX1, sigmaX2, sigmaY1, sigmaY2, sigmaC1, sigmaC2,
+                   m_nr_channels, m_chvec_max, m_dist_coeff, m_color_coeff,
+                   m_stepx, m_stepy ) );
+}
+
+struct FeatureSpaceCenters : ParallelLoopBody
+{
+    FeatureSpaceCenters( const vector< Mat >& _chvec, const Mat& _W,
+                         const vector<float>& _kseedsx, const vector<float>& _kseedsy,
+                         vector<float>* _centerX1, vector<float>* _centerX2,
+                         vector<float>* _centerY1, vector<float>* _centerY2,
+                         vector< vector<float> >* _centerC1, vector< vector<float> >* _centerC2,
+                         const int _nr_channels, const float _chvec_max,
+                         const float _dist_coeff, const float _color_coeff,
+                         const int _stepx, const int _stepy )
+    {
+      W = _W;
+      chvec = _chvec;
+      stepx = _stepx;
+      stepy = _stepy;
+      chvec_max = _chvec_max;
+      dist_coeff = _dist_coeff;
+      nr_channels = _nr_channels;
+      color_coeff = _color_coeff;
+
+      PI2 = float(CV_PI / 2.0f);
+
+      kseedsx = _kseedsx;
+      kseedsy = _kseedsy;
+      width  = chvec[0].cols;
+      height = chvec[0].rows;
+
+      centerX1 = _centerX1; centerX2 = _centerX2;
+      centerY1 = _centerY1; centerY2 = _centerY2;
+      centerC1 = _centerC1; centerC2 = _centerC2;
+    }
+
+    void operator()( const Range& range ) const CV_OVERRIDE
+    {
+      for( int i = range.start; i < range.end; i++ )
+      {
+        centerX1->at(i) = 0.0f; centerX2->at(i) = 0.0f;
+        centerY1->at(i) = 0.0f; centerY2->at(i) = 0.0f;
+        for( int b = 0; b < nr_channels; b++ )
+        {
+          centerC1->at(b)[i] = 0.0f; centerC2->at(b)[i] = 0.0f;
+        }
+
+        int X = (int)kseedsx[i]; int Y = (int)kseedsy[i];
+        int minX = (X-stepx/4 <= 0) ? 0 : X-stepx/4;
+        int minY = (Y-stepy/4 <= 0) ? 0 : Y-stepy/4;
+        int maxX = (X+stepx/4 >= width -1) ? width -1 : X+stepx/4;
+        int maxY = (Y+stepy/4 >= height-1) ? height-1 : Y+stepy/4;
+
+        int count = 0;
+        for( int x = minX; x <= maxX; x++ )
+        {
+          float thetaX = ( (float) x / (float) stepx ) * PI2;
+
+          float tx1 = dist_coeff * cos(thetaX);
+          float tx2 = dist_coeff * sin(thetaX);
+
+          for( int y = minY; y <= maxY; y++ )
+          {
+            count++;
+            float thetaY = ( (float) y / (float) stepy ) * PI2;
+
+            // we do not store pre-computed x1, x2
+            float x1 = tx1 / W.at<float>(y,x);
+            float x2 = tx2 / W.at<float>(y,x);
+
+            // we do not store pre-computed y1, y2
+            float y1 = (dist_coeff * cos(thetaY)) / W.at<float>(y,x);
+            float y2 = (dist_coeff * sin(thetaY)) / W.at<float>(y,x);
+
+            centerX1->at(i) += x1; centerX2->at(i) += x2;
+            centerY1->at(i) += y1; centerY2->at(i) += y2;
+
+            for( int b = 0; b < nr_channels; b++ )
+            {
+              float thetaC = 0.0f;
+              switch ( chvec[b].depth() )
+              {
+                case CV_8U:
+                  thetaC = ( (float) chvec[b].at<uchar>(y,x)  / chvec_max ) * PI2;
+                  break;
+                case CV_8S:
+                  thetaC = ( (float) chvec[b].at<char>(y,x)   / chvec_max ) * PI2;
+                  break;
+                case CV_16U:
+                  thetaC = ( (float) chvec[b].at<ushort>(y,x) / chvec_max ) * PI2;
+                  break;
+                case CV_16S:
+                  thetaC = ( (float) chvec[b].at<short>(y,x)  / chvec_max ) * PI2;
+                  break;
+                case CV_32S:
+                  thetaC = ( (float) chvec[b].at<int>(y,x)    / chvec_max ) * PI2;
+                  break;
+                case CV_32F:
+                  thetaC = ( (float) chvec[b].at<float>(y,x)  / chvec_max ) * PI2;
+                  break;
+                case CV_64F:
+                  thetaC = ( (float) chvec[b].at<double>(y,x) / chvec_max ) * PI2;
+                  break;
+                default:
+                  CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                  break;
+              }
+              // we do not store pre-computed C1[b], C2[b]
+              float C1 = (color_coeff * cos(thetaC) / nr_channels) / W.at<float>(y,x);
+              float C2 = (color_coeff * sin(thetaC) / nr_channels) / W.at<float>(y,x);
+
+              centerC1->at(b)[i] += C1; centerC2->at(b)[i] += C2;
+            }
+          }
+        }
+        // normalize
+        centerX1->at(i) /= count; centerX2->at(i) /= count;
+        centerY1->at(i) /= count; centerY2->at(i) /= count;
+        for( int b = 0; b < nr_channels; b++ )
+        {
+          centerC1->at(b)[i] /= count; centerC2->at(b)[i] /= count;
+        }
+      }
+    }
+
+    Mat W;
+    float PI2;
+    int nr_channels;
+    int stepx, stepy;
+    int width, height;
+
+    float chvec_max;
+    float dist_coeff;
+    float color_coeff;
+
+    vector<Mat> chvec;
+    vector<float> kseedsx, kseedsy;
+    vector< vector<float> >* centerC1;
+    vector< vector<float> >* centerC2;
+    vector<float> *centerX1, *centerX2;
+    vector<float> *centerY1, *centerY2;
+};
+
+struct FeatureSpaceKmeans : ParallelLoopBody
+{
+    FeatureSpaceKmeans( Mat* _klabels, Mat* _dist,
+                        const vector< Mat >& _chvec, const Mat& _W,
+                        const vector<float>& _kseedsx, const vector<float>& _kseedsy,
+                        vector<float>& _centerX1, vector<float>& _centerX2,
+                        vector<float>& _centerY1, vector<float>& _centerY2,
+                        vector< vector<float> >& _centerC1, vector< vector<float> >& _centerC2,
+                        const int _nr_channels, const float _chvec_max,
+                        const float _dist_coeff, const float _color_coeff,
+                        const int _stepx, const int _stepy )
+    {
+      W = _W;
+      dist = _dist;
+      chvec = _chvec;
+      stepx = _stepx;
+      stepy = _stepy;
+      klabels = _klabels;
+      chvec_max = _chvec_max;
+      dist_coeff = _dist_coeff;
+      nr_channels = _nr_channels;
+      color_coeff = _color_coeff;
+
+      PI2 = float(CV_PI / 2.0f);
+
+      kseedsx = _kseedsx;
+      kseedsy = _kseedsy;
+      width  = chvec[0].cols;
+      height = chvec[0].rows;
+
+      centerX1 = _centerX1; centerX2 = _centerX2;
+      centerY1 = _centerY1; centerY2 = _centerY2;
+      centerC1 = _centerC1; centerC2 = _centerC2;
+    }
+
+    void operator()( const Range& range ) const CV_OVERRIDE
+    {
+      for( int i = range.start; i < range.end; i++ )
+      {
+        int X = (int)kseedsx[i]; int Y = (int)kseedsy[i];
+        int minX = (X-(stepx) <= 0) ? 0 : X-stepx;
+        int minY = (Y-(stepy) <= 0) ? 0 : Y-stepy;
+        int maxX = (X+(stepx) >= width -1) ? width -1 : X+stepx;
+        int maxY = (Y+(stepy) >= height-1) ? height-1 : Y+stepy;
+
+        for( int x = minX; x <= maxX; x++ )
+        {
+          float thetaX = ( (float) x / (float) stepx ) * PI2;
+
+          float tx1 = dist_coeff * cos(thetaX);
+          float tx2 = dist_coeff * sin(thetaX);
+
+          for( int y = minY; y <= maxY; y++ )
+          {
+            float thetaY = ( (float) y / (float) stepy ) * PI2;
+
+            // we do not store pre-computed x1, x2
+            float x1 = tx1 / W.at<float>(y,x);
+            float x2 = tx2 / W.at<float>(y,x);
+            // we do not store pre-computed y1, y2
+            float y1 = (dist_coeff * cos(thetaY)) / W.at<float>(y,x);
+            float y2 = (dist_coeff * sin(thetaY)) / W.at<float>(y,x);
+
+            float diffx1 = x1 - centerX1[i]; float diffx2 = x2 - centerX2[i];
+            float diffy1 = y1 - centerY1[i]; float diffy2 = y2 - centerY2[i];
+
+            // compute distance given distance terms
+            double D = (diffx1 * diffx1) + (diffx2 * diffx2)
+                     + (diffy1 * diffy1) + (diffy2 * diffy2);
+
+            // compute distance given channels terms
+            for( int b = 0; b < nr_channels; b++ )
+            {
+              float thetaC = 0.0f;
+              switch ( chvec[b].depth() )
+              {
+                case CV_8U:
+                  thetaC = ( (float) chvec[b].at<uchar>(y,x)  / chvec_max ) * PI2;
+                  break;
+                case CV_8S:
+                  thetaC = ( (float) chvec[b].at<char>(y,x)   / chvec_max ) * PI2;
+                  break;
+                case CV_16U:
+                  thetaC = ( (float) chvec[b].at<ushort>(y,x) / chvec_max ) * PI2;
+                  break;
+                case CV_16S:
+                  thetaC = ( (float) chvec[b].at<short>(y,x)  / chvec_max ) * PI2;
+                  break;
+                case CV_32S:
+                  thetaC = ( (float) chvec[b].at<int>(y,x)    / chvec_max ) * PI2;
+                  break;
+                case CV_32F:
+                  thetaC = ( (float) chvec[b].at<float>(y,x)  / chvec_max ) * PI2;
+                  break;
+                case CV_64F:
+                  thetaC = ( (float) chvec[b].at<double>(y,x) / chvec_max ) * PI2;
+                  break;
+                default:
+                  CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                  break;
+              }
+              // we do not store pre-computed C1[b], C2[b]
+              float C1 = (color_coeff * cos(thetaC) / nr_channels) / W.at<float>(y,x);
+              float C2 = (color_coeff * sin(thetaC) / nr_channels) / W.at<float>(y,x);
+
+              float diffC1 = C1 - centerC1[b][i]; float diffC2 = C2 - centerC2[b][i];
+
+              D += (diffC1 * diffC1) + (diffC2 * diffC2);
+            }
+
+            // assign label if within D
+            if ( D < dist->at<float>(y,x) )
+            {
+              dist->at<float>(y,x) = (float)D;
+              klabels->at<int>(y,x) = i;
+            }
+          }
+        }
+
+      }
+    }
+
+    Mat W;
+    float PI2;
+    int nr_channels;
+    int stepx, stepy;
+    int width, height;
+
+    float chvec_max;
+    float dist_coeff;
+    float color_coeff;
+
+    Mat* dist;
+    Mat* klabels;
+    vector<Mat> chvec;
+    vector<float> kseedsx, kseedsy;
+    vector<float> centerX1, centerX2;
+    vector<float> centerY1, centerY2;
+    vector< vector<float> > centerC1;
+    vector< vector<float> > centerC2;
+};
+
+struct FeatureCenterDists
+{
+    FeatureCenterDists( const vector< Mat >& _chvec, const Mat& _W, const Mat& _klabels,
+                        const int _nr_channels, const float _chvec_max, const float _dist_coeff,
+                        const float _color_coeff, const int _stepx, const int _stepy, const int _numlabels )
+    {
+      W = _W;
+      chvec = _chvec;
+      stepx = _stepx;
+      stepy = _stepy;
+      klabels = _klabels;
+      numlabels = _numlabels;
+      chvec_max = _chvec_max;
+      dist_coeff = _dist_coeff;
+      nr_channels = _nr_channels;
+      color_coeff = _color_coeff;
+
+      PI2 = float(CV_PI / 2.0f);
+
+      Wsum.resize(numlabels);
+      kseedsx.resize(numlabels);
+      kseedsy.resize(numlabels);
+      centerX1.resize(numlabels);
+      centerX2.resize(numlabels);
+      centerY1.resize(numlabels);
+      centerY2.resize(numlabels);
+      centerC1.resize(nr_channels);
+      centerC2.resize(nr_channels);
+      clusterSize.resize(numlabels);
+      for( int b = 0; b < nr_channels; b++ )
+      {
+        centerC1[b].resize(numlabels);
+        centerC2[b].resize(numlabels);
+      }
+      // refill with zero all arrays
+      fill(centerX1.begin(), centerX1.end(), 0.0f);
+      fill(centerX2.begin(), centerX2.end(), 0.0f);
+      fill(centerY1.begin(), centerY1.end(), 0.0f);
+      fill(centerY2.begin(), centerY2.end(), 0.0f);
+      for( int b = 0; b < nr_channels; b++ )
+      {
+        fill(centerC1[b].begin(), centerC1[b].end(), 0.0f);
+        fill(centerC2[b].begin(), centerC2[b].end(), 0.0f);
+      }
+      fill(Wsum.begin(), Wsum.end(), 0.0f);
+      fill(kseedsx.begin(), kseedsx.end(), 0.0f);
+      fill(kseedsy.begin(), kseedsy.end(), 0.0f);
+      fill(clusterSize.begin(), clusterSize.end(), 0);
+    }
+
+    FeatureCenterDists( const FeatureCenterDists& counter, Split )
+    {
+      *this = counter;
+      // refill with zero all arrays
+      fill(centerX1.begin(), centerX1.end(), 0.0f);
+      fill(centerX2.begin(), centerX2.end(), 0.0f);
+      fill(centerY1.begin(), centerY1.end(), 0.0f);
+      fill(centerY2.begin(), centerY2.end(), 0.0f);
+      for( int b = 0; b < nr_channels; b++ )
+      {
+        fill(centerC1[b].begin(), centerC1[b].end(), 0.0f);
+        fill(centerC2[b].begin(), centerC2[b].end(), 0.0f);
+      }
+      fill(Wsum.begin(), Wsum.end(), 0.0f);
+      fill(kseedsx.begin(), kseedsx.end(), 0.0f);
+      fill(kseedsy.begin(), kseedsy.end(), 0.0f);
+      fill(clusterSize.begin(), clusterSize.end(), 0);
+
+    }
+
+    void operator()( const BlockedRange& range )
+    {
+      // previous block state
+      vector<float> tmp_Wsum = Wsum;
+      vector<float> tmp_kseedsx = kseedsx;
+      vector<float> tmp_kseedsy = kseedsy;
+      vector<float> tmp_centerX1 = centerX1;
+      vector<float> tmp_centerX2 = centerX2;
+      vector<float> tmp_centerY1 = centerY1;
+      vector<float> tmp_centerY2 = centerY2;
+      vector< vector<float> > tmp_centerC1 = centerC1;
+      vector< vector<float> > tmp_centerC2 = centerC2;
+      vector<int> tmp_clusterSize = clusterSize;
+
+      for ( int x = range.begin(); x != range.end(); x++ )
+      {
+
+        float thetaX = ( (float) x / (float) stepx ) * PI2;
+
+        // we do not store pre-computed x1, x2
+        float x1 = (dist_coeff * cos(thetaX));
+        float x2 = (dist_coeff * sin(thetaX));
+
+        for( int y = 0; y < chvec[0].rows; y++ )
+        {
+          float thetaY = ( (float) y / (float) stepy ) * PI2;
+
+          // we do not store pre-computed y1, y2
+          float y1 = (dist_coeff * cos(thetaY));
+          float y2 = (dist_coeff * sin(thetaY));
+
+          int L = klabels.at<int>(y,x);
+
+          tmp_centerX1[L] += x1; tmp_centerX2[L] += x2;
+          tmp_centerY1[L] += y1; tmp_centerY2[L] += y2;
+
+          // compute distance given channels terms
+          for( int b = 0; b < nr_channels; b++ )
+          {
+            float thetaC = 0.0f;
+            switch ( chvec[b].depth() )
+            {
+              case CV_8U:
+                thetaC = ( (float) chvec[b].at<uchar>(y,x)  / chvec_max ) * PI2;
+                break;
+              case CV_8S:
+                thetaC = ( (float) chvec[b].at<char>(y,x)   / chvec_max ) * PI2;
+                break;
+              case CV_16U:
+                thetaC = ( (float) chvec[b].at<ushort>(y,x) / chvec_max ) * PI2;
+                break;
+              case CV_16S:
+                thetaC = ( (float) chvec[b].at<short>(y,x)  / chvec_max ) * PI2;
+                break;
+              case CV_32S:
+                thetaC = ( (float) chvec[b].at<int>(y,x)    / chvec_max ) * PI2;
+                break;
+              case CV_32F:
+                thetaC = ( (float) chvec[b].at<float>(y,x)  / chvec_max ) * PI2;
+                break;
+              case CV_64F:
+                thetaC = ( (float) chvec[b].at<double>(y,x) / chvec_max ) * PI2;
+                break;
+              default:
+                CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                break;
+            }
+
+            // we do not store pre-computed C1[b], C2[b]
+            float C1 = (color_coeff * cos(thetaC) / nr_channels);
+            float C2 = (color_coeff * sin(thetaC) / nr_channels);
+
+            tmp_centerC1[b][L] += C1; tmp_centerC2[b][L] += C2;
+
+          }
+          tmp_clusterSize[L]++;
+          tmp_Wsum[L] += W.at<float>(y,x);
+          tmp_kseedsx[L] += x; tmp_kseedsy[L] += y;
+        }
+      }
+
+      Wsum = tmp_Wsum;
+      kseedsx = tmp_kseedsx;
+      kseedsy = tmp_kseedsy;
+      clusterSize = tmp_clusterSize;
+      centerX1 = tmp_centerX1; centerX2 = tmp_centerX2;
+      centerY1 = tmp_centerY1; centerY2 = tmp_centerY2;
+      centerC1 = tmp_centerC1; centerC2 = tmp_centerC2;
+    }
+
+    void join( FeatureCenterDists& fcd )
+    {
+      for (int l = 0; l < numlabels; l++)
+      {
+        Wsum[l] += fcd.Wsum[l];
+        kseedsx[l] += fcd.kseedsx[l];
+        kseedsy[l] += fcd.kseedsy[l];
+        centerX1[l] += fcd.centerX1[l];
+        centerX2[l] += fcd.centerX2[l];
+        centerY1[l] += fcd.centerY1[l];
+        centerY2[l] += fcd.centerY2[l];
+        clusterSize[l] += fcd.clusterSize[l];
+        for( int b = 0; b < nr_channels; b++ )
+        {
+            centerC1[b][l] += fcd.centerC1[b][l];
+            centerC2[b][l] += fcd.centerC2[b][l];
+        }
+      }
+    }
+
+    Mat W;
+    float PI2;
+    int numlabels;
+    int nr_channels;
+    int stepx, stepy;
+
+    float chvec_max;
+    float dist_coeff;
+    float color_coeff;
+
+    Mat klabels;
+    vector<Mat> chvec;
+
+    vector<float> Wsum;
+    vector<int> clusterSize;
+    vector<float> kseedsx, kseedsy;
+    vector<float> centerX1, centerX2;
+    vector<float> centerY1, centerY2;
+    vector< vector<float> > centerC1, centerC2;
+
+};
+
+struct FeatureNormals : ParallelLoopBody
+{
+    FeatureNormals( const vector<float>& _Wsum, const vector<int>& _clusterSize,
+                    vector<float>* _kseedsx, vector<float>* _kseedsy,
+                    vector<float>* _centerX1, vector<float>* _centerX2,
+                    vector<float>* _centerY1, vector<float>* _centerY2,
+                    vector< vector<float> >* _centerC1, vector< vector<float> >* _centerC2,
+                    const int _numlabels, const int _nr_channels )
+    {
+      Wsum = _Wsum;
+      numlabels = _numlabels;
+      clusterSize = _clusterSize;
+      nr_channels = _nr_channels;
+
+      kseedsx = _kseedsx; kseedsy = _kseedsy;
+      centerX1 = _centerX1; centerX2 = _centerX2;
+      centerY1 = _centerY1; centerY2 = _centerY2;
+      centerC1 = _centerC1; centerC2 = _centerC2;
+    }
+
+    void operator()( const Range& range ) const CV_OVERRIDE
+    {
+      for( int i = range.start; i < range.end; i++ )
+      {
+        if ( Wsum[i] != 0 )
+        {
+          centerX1->at(i) /= Wsum[i]; centerX2->at(i) /= Wsum[i];
+          centerY1->at(i) /= Wsum[i]; centerY2->at(i) /= Wsum[i];
+          for( int b = 0; b < nr_channels; b++ )
+          {
+            centerC1->at(b)[i] /= Wsum[i]; centerC2->at(b)[i] /= Wsum[i];
+          }
+        }
+        if ( clusterSize[i] != 0 )
+        {
+          kseedsx->at(i) /= clusterSize[i];
+          kseedsy->at(i) /= clusterSize[i];
+        }
+      }
+    }
+
+    int numlabels;
+    vector<float> Wsum;
+    vector<int> clusterSize;
+    int nr_channels;
+
+    vector<float> *kseedsx, *kseedsy;
+    vector<float> *centerX1, *centerX2;
+    vector<float> *centerY1, *centerY2;
+    vector< vector<float> > *centerC1;
+    vector< vector<float> > *centerC2;
+};
+
+
+/*
+ *    PerformSuperpixelLSC
+ *
+ *    Performs weighted kmeans segmentation
+ *    in (4 + 2*m_nr_channels) dimensional space
+ *
+ */
+inline void SuperpixelLSCImpl::PerformLSC( const int&  itrnum )
+{
+    // allocate initial workspaces
+    cv::Mat dist( m_height, m_width, CV_32F );
+
+    vector<float> centerX1( m_numlabels );
+    vector<float> centerX2( m_numlabels );
+    vector<float> centerY1( m_numlabels );
+    vector<float> centerY2( m_numlabels );
+    vector< vector<float> > centerC1( m_nr_channels );
+    vector< vector<float> > centerC2( m_nr_channels );
+    for( int b = 0; b < m_nr_channels; b++ )
+    {
+      centerC1[b].resize( m_numlabels );
+      centerC2[b].resize( m_numlabels );
+    }
+    vector<float> Wsum( m_numlabels );
+    vector<int> clusterSize( m_numlabels );
+
+    // compute weighted distance centers
+    parallel_for_( Range(0, m_numlabels), FeatureSpaceCenters(
+                   m_chvec, m_W, m_kseedsx, m_kseedsy,
+                   &centerX1, &centerX2, &centerY1, &centerY2,
+                   &centerC1, &centerC2, m_nr_channels, m_chvec_max,
+                   m_dist_coeff, m_color_coeff, m_stepx, m_stepy ) );
+
+    // K-Means
+    for( int itr = 0; itr < itrnum; itr++ )
+    {
+
+      dist.setTo( FLT_MAX );
+
+      // k-mean
+      parallel_for_( Range(0, m_numlabels), FeatureSpaceKmeans(
+                     &m_klabels, &dist, m_chvec, m_W, m_kseedsx, m_kseedsy,
+                     centerX1, centerX2, centerY1, centerY2, centerC1, centerC2,
+                     m_nr_channels, m_chvec_max, m_dist_coeff, m_color_coeff,
+                     m_stepx, m_stepy ) );
+
+      // parallel reduce structure
+      FeatureCenterDists fcd( m_chvec, m_W, m_klabels, m_nr_channels, m_chvec_max,
+                              m_dist_coeff, m_color_coeff, m_stepx, m_stepy, m_numlabels );
+
+      // accumulate center distances
+      parallel_reduce( BlockedRange(0, m_width), fcd );
+
+      // featch out the results
+      Wsum = fcd.Wsum; clusterSize = fcd.clusterSize;
+      m_kseedsx = fcd.kseedsx; m_kseedsy = fcd.kseedsy;
+      centerX1 = fcd.centerX1; centerX2 = fcd.centerX2;
+      centerY1 = fcd.centerY1; centerY2 = fcd.centerY2;
+      centerC1 = fcd.centerC1; centerC2 = fcd.centerC2;
+
+
+      // normalize accumulated distances
+      parallel_for_( Range(0, m_numlabels), FeatureNormals(
+                     Wsum, clusterSize, &m_kseedsx, &m_kseedsy,
+                     &centerX1, &centerX2, &centerY1, &centerY2,
+                     &centerC1, &centerC2, m_numlabels, m_nr_channels ) );
+    }
+}
+
+} // namespace ximgproc
+} // namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/niblack_thresholding.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/niblack_thresholding.cpp
new file mode 100644
index 00000000..3599f770
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/niblack_thresholding.cpp
@@ -0,0 +1,133 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2014, Beat Kueng (beat-kueng@gmx.net), Lukas Vogel, Morten Lysgaard
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#include "precomp.hpp"
+#include <cmath>
+
+namespace cv {
+namespace ximgproc {
+
+void niBlackThreshold( InputArray _src, OutputArray _dst, double maxValue,
+        int type, int blockSize, double k, int binarizationMethod, double r)
+{
+    // Input grayscale image
+    Mat src = _src.getMat();
+    CV_Assert(src.channels() == 1);
+    CV_Assert(blockSize % 2 == 1 && blockSize > 1);
+    if (binarizationMethod == BINARIZATION_SAUVOLA) {
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(r != 0);
+    }
+    type &= THRESH_MASK;
+
+    // Compute local threshold (T = mean + k * stddev)
+    // using mean and standard deviation in the neighborhood of each pixel
+    // (intermediate calculations are done with floating-point precision)
+    Mat thresh;
+    {
+        // note that: Var[X] = E[X^2] - E[X]^2
+        Mat mean, sqmean, variance, stddev, sqrtVarianceMeanSum;
+        double srcMin, stddevMax;
+        boxFilter(src, mean, CV_32F, Size(blockSize, blockSize),
+                Point(-1,-1), true, BORDER_REPLICATE);
+        sqrBoxFilter(src, sqmean, CV_32F, Size(blockSize, blockSize),
+                Point(-1,-1), true, BORDER_REPLICATE);
+        variance = sqmean - mean.mul(mean);
+        sqrt(variance, stddev);
+        switch (binarizationMethod)
+        {
+        case BINARIZATION_NIBLACK:
+            thresh = mean + stddev * static_cast<float>(k);
+            break;
+        case BINARIZATION_SAUVOLA:
+            thresh = mean.mul(1. + static_cast<float>(k) * (stddev / r - 1.));
+            break;
+        case BINARIZATION_WOLF:
+            minMaxIdx(src, &srcMin);
+            minMaxIdx(stddev, NULL, &stddevMax);
+            thresh = mean - static_cast<float>(k) * (mean - srcMin - stddev.mul(mean - srcMin) / stddevMax);
+            break;
+        case BINARIZATION_NICK:
+            sqrt(variance + sqmean, sqrtVarianceMeanSum);
+            thresh = mean + static_cast<float>(k) * sqrtVarianceMeanSum;
+            break;
+        default:
+            CV_Error( Error::StsBadArg, "Unknown binarization method" );
+            break;
+        }
+        thresh.convertTo(thresh, src.depth());
+    }
+
+    // Prepare output image
+    _dst.create(src.size(), src.type());
+    Mat dst = _dst.getMat();
+    CV_Assert(src.data != dst.data);  // no inplace processing
+
+    // Apply thresholding: ( pixel > threshold ) ? foreground : background
+    Mat mask;
+    switch (type)
+    {
+    case THRESH_BINARY:      // dst = (src > thresh) ? maxval : 0
+    case THRESH_BINARY_INV:  // dst = (src > thresh) ? 0 : maxval
+        compare(src, thresh, mask, (type == THRESH_BINARY ? CMP_GT : CMP_LE));
+        dst.setTo(0);
+        dst.setTo(maxValue, mask);
+        break;
+    case THRESH_TRUNC:       // dst = (src > thresh) ? thresh : src
+        compare(src, thresh, mask, CMP_GT);
+        src.copyTo(dst);
+        thresh.copyTo(dst, mask);
+        break;
+    case THRESH_TOZERO:      // dst = (src > thresh) ? src : 0
+    case THRESH_TOZERO_INV:  // dst = (src > thresh) ? 0 : src
+        compare(src, thresh, mask, (type == THRESH_TOZERO ? CMP_GT : CMP_LE));
+        dst.setTo(0);
+        src.copyTo(dst, mask);
+        break;
+    default:
+        CV_Error( Error::StsBadArg, "Unknown threshold type" );
+        break;
+    }
+}
+
+} // namespace ximgproc
+} // namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/opencl/anisodiff.cl b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/opencl/anisodiff.cl
new file mode 100644
index 00000000..be72ed7a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/opencl/anisodiff.cl
@@ -0,0 +1,39 @@
+__kernel void anisodiff(__global const uchar * srcptr, int srcstep, int srcoffset,
+                        __global uchar * dstptr, int dststep, int dstoffset,
+                        int rows, int cols, __constant float* exptab, float alpha)
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if( x < cols && y < rows )
+    {
+        int yofs = y*dststep + x*3;
+        int xofs = y*srcstep + x*3;
+        float4 s = 0.f;
+
+        float4 c = (float4)(srcptr[xofs], srcptr[xofs+1], srcptr[xofs+2], 0.f);
+        float4 delta, adelta;
+        float w;
+
+        #define UPDATE_SUM(xofs1) \
+            delta = (float4)(srcptr[xofs + xofs1], srcptr[xofs + xofs1 + 1], srcptr[xofs + xofs1 + 2], 0.f) - c; \
+            adelta = fabs(delta); \
+            w = exptab[convert_int(adelta.x + adelta.y + adelta.z)]; \
+            s += delta*w
+
+        UPDATE_SUM(3);
+        UPDATE_SUM(-3);
+        UPDATE_SUM(-srcstep-3);
+        UPDATE_SUM(-srcstep);
+        UPDATE_SUM(-srcstep+3);
+        UPDATE_SUM(srcstep-3);
+        UPDATE_SUM(srcstep);
+        UPDATE_SUM(srcstep+3);
+
+        s = s*alpha + c;
+        uchar4 d = convert_uchar4_sat(convert_int4_rte(s));
+        dstptr[yofs] = d.x;
+        dstptr[yofs+1] = d.y;
+        dstptr[yofs+2] = d.z;
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/paillou_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/paillou_filter.cpp
new file mode 100644
index 00000000..136c801e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/paillou_filter.cpp
@@ -0,0 +1,424 @@
+/*
+*  By downloading, copying, installing or using the software you agree to this license.
+*  If you do not agree to this license, do not download, install,
+*  copy or use the software.
+*
+*
+*  License Agreement
+*  For Open Source Computer Vision Library
+*  (3 - clause BSD License)
+*
+*  Redistribution and use in source and binary forms, with or without modification,
+*  are permitted provided that the following conditions are met :
+*
+*  * Redistributions of source code must retain the above copyright notice,
+*  this list of conditions and the following disclaimer.
+*
+*  * Redistributions in binary form must reproduce the above copyright notice,
+*  this list of conditions and the following disclaimer in the documentation
+*  and / or other materials provided with the distribution.
+*
+*  * Neither the names of the copyright holders nor the names of the contributors
+*  may be used to endorse or promote products derived from this software
+*  without specific prior written permission.
+*
+*  This software is provided by the copyright holders and contributors "as is" and
+*  any express or implied warranties, including, but not limited to, the implied
+*  warranties of merchantability and fitness for a particular purpose are disclaimed.
+*  In no event shall copyright holders or contributors be liable for any direct,
+*  indirect, incidental, special, exemplary, or consequential damages
+*  (including, but not limited to, procurement of substitute goods or services;
+*  loss of use, data, or profits; or business interruption) however caused
+*  and on any theory of liability, whether in contract, strict liability,
+*  or tort(including negligence or otherwise) arising in any way out of
+*  the use of this software, even if advised of the possibility of such damage.
+*/
+#include "precomp.hpp"
+#include <math.h>
+#include <vector>
+#include <iostream>
+
+/*
+If you use this code please cite this @cite paillou1997detecting
+Detecting step edges in noisy SAR images: a new linear operator  IEEE Transactions on Geoscience and Remote Sensing  (Volume:35 ,  Issue: 1 )  1997
+Equation xx pyyy mean equation xx at page yyy in previous paper
+*/
+
+namespace cv {
+namespace ximgproc {
+
+template<typename T> static void
+VerticalIIRFilter(Mat &img, Mat &dst, const Range &range, double a,double w)
+{
+    float *f2;
+    int tailleSequence = (img.rows>img.cols) ? img.rows : img.cols;
+    Mat matYp(1, tailleSequence, CV_64FC1), matYm(1, tailleSequence, CV_64FC1);
+    double *yp = matYp.ptr<double>(0), *ym = matYm.ptr<double>(0);
+    int rows = img.rows, cols = img.cols;
+
+    // Equation 12 p193
+    double                b1 = -2 * exp(-a)*cosh(w);
+    double                a1 = 2 * exp(-a)*cosh(w) - exp(-2 * a) - 1;
+    double                b2 = exp(-2 * a);
+    for (int j = range.start; j < range.end; j++)
+    {
+        // Equation 26 p194
+        T *c1 = (T *)img.ptr(0) + j;
+        f2 = dst.ptr<float>(0) + j;
+        double border = *c1;
+        yp[0] = *c1;
+        c1 += cols;
+        yp[1] = *c1 - b1*yp[0] - b2*border;
+        c1 += cols;
+        for (int i = 2; i < rows; i++, c1 += cols)
+            yp[i] = *c1 - b1*yp[i - 1] - b2*yp[i - 2];
+        // Equation 27 p194
+        c1 = (T *)img.ptr(rows - 1) + j;
+        border = *c1;
+        ym[rows - 1] = *c1;
+        c1 -= cols;
+        ym[rows - 2] = *c1 - b1*ym[rows - 1];
+        c1 -= cols;
+        for (int i = rows - 3; i >= 0; i--, c1 -= cols)
+            ym[i] = *c1 - b1*ym[i + 1] - b2*ym[i + 2];
+        // Equation 25 p193
+        for (int i = 0; i < rows; i++, f2 += cols)
+            *f2 = (float)(a1*(ym[i] - yp[i]));
+    }
+}
+
+template<typename T> static void
+HorizontalIIRFilter(Mat &img, Mat &dst, const Range &range, double a, double w)
+{
+    int tailleSequence = (img.rows>img.cols) ? img.rows : img.cols;
+    Mat matYp(1, tailleSequence, CV_64FC1), matYm(1, tailleSequence, CV_64FC1);
+    double *yp = matYp.ptr<double>(0), *ym = matYm.ptr<double>(0);
+    int cols = img.cols;
+    float *f2;
+
+    // Equation 12 p193
+    double                b1 = -2 * exp(-a)*cosh(w);
+    double                a1 = 2 * exp(-a)*cosh(w) - exp(-2 * a) - 1;
+    double                b2 = exp(-2 * a);
+
+    for (int i = range.start; i<range.end; i++)
+    {
+        // Equation 26 p194
+        T *c1 = img.ptr<T>(i);
+        double border = *c1;
+        yp[0] = *c1;
+        c1++;
+        yp[1] = *c1 - b1*yp[0] - b2*border;
+        c1++;
+        for (int j = 2; j<cols; j++, c1++)
+            yp[j] = *c1 - b1*yp[j - 1] - b2*yp[j - 2];
+        // Equation 27 p194
+        c1 = img.ptr<T>(i) + cols - 1;
+        border = *c1;
+        ym[cols - 1] = *c1;
+        c1--;
+        ym[cols - 2] = *c1 - b1*ym[cols - 1];
+        c1--;
+        for (int j = cols - 3; j >= 0; j--, c1--)
+            ym[j] = *c1 - b1*ym[j + 1] - b2*ym[j + 2];
+        // Equation 25 p193
+        f2 = dst.ptr<float>(i);
+        for (int j = 0; j<cols; j++, f2++)
+            *f2 = (float)(a1*(ym[j] - yp[j]));
+    }
+}
+
+class ParallelGradientPaillouYCols: public ParallelLoopBody
+{
+private:
+    Mat &img;
+    Mat &dst;
+    double a;
+    double w;
+    bool verbose;
+public:
+    ParallelGradientPaillouYCols(Mat& imgSrc, Mat &d,double aa,double ww):
+        img(imgSrc),
+        dst(d),
+        a(aa),
+        w(ww),
+        verbose(false)
+    {
+        int type = img.depth();
+        CV_CheckType(type, type == CV_8UC1 || type == CV_8SC1 || type == CV_16SC1 || type == CV_16UC1 || type == CV_32FC1, "Wrong input type for GradientPaillouY");
+        type = dst.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong output type for GradientPaillouYCols");
+    }
+    void Verbose(bool b){verbose=b;}
+    virtual void operator()(const Range& range) const CV_OVERRIDE
+    {
+        if (verbose)
+            std::cout << getThreadNum()<<"# :Start from row " << range.start << " to "  << range.end-1<<" ("<<range.end-range.start<<" loops)" << std::endl;
+
+        switch(img.depth()){
+        case CV_8U:
+            VerticalIIRFilter<uchar>(img, dst, range, a, w);
+            break;
+        case CV_8S:
+            VerticalIIRFilter<char>(img, dst, range, a, w);
+            break;
+        case CV_16S :
+            VerticalIIRFilter<short>(img, dst, range, a, w);
+            break;
+        case CV_16U:
+            VerticalIIRFilter<short>(img, dst, range, a, w);
+            break;
+        case CV_32F:
+            VerticalIIRFilter<float>(img, dst, range, a, w);
+            break;
+        default :
+            return ;
+            }
+    };
+    ParallelGradientPaillouYCols& operator=(const ParallelGradientPaillouYCols &) {
+         return *this;
+    };
+};
+
+
+class ParallelGradientPaillouYRows: public ParallelLoopBody
+{
+private:
+    Mat &img;
+    Mat &dst;
+    double a;
+    double w;
+    bool verbose;
+
+public:
+    ParallelGradientPaillouYRows(Mat& imgSrc, Mat &d,double aa,double ww):
+        img(imgSrc),
+        dst(d),
+        a(aa),
+        w(ww),
+        verbose(false)
+    {
+        int type = img.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong input type for GradientPaillouYRows");
+        type = dst.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong output type for GradientPaillouYRows");
+    }
+    void Verbose(bool b){verbose=b;}
+    virtual void operator()(const Range& range) const CV_OVERRIDE
+    {
+        if (verbose)
+            std::cout << getThreadNum()<<"# :Start from row " << range.start << " to "  << range.end-1<<" ("<<range.end-range.start<<" loops)" << std::endl;
+        float *iy,*iy0;
+        int tailleSequence=(img.rows>img.cols)?img.rows:img.cols;
+        Mat matIym(1,tailleSequence,CV_64FC1),  matIyp(1,tailleSequence,CV_64FC1);
+        double *iym=matIym.ptr<double>(0), *iyp=matIyp.ptr<double>(0);
+        int cols=img.cols;
+
+        // Equation 13 p193
+        double                d=(1-2*exp(-a)*cosh(w)+exp(-2*a))/(2*a*exp(-a)*sinh(w)+w*(1-exp(-2*a)));
+        double                c1=a*d;
+        double                c2=w*d;
+        // Equation 12 p193
+        double                b1=-2*exp(-a)*cosh(w);
+        double                b2=exp(-2*a);
+        // Equation 14 p193
+        double                a0p=c2;
+        double                a1p=(c1*sinh(w)-c2*cosh(w))*exp(-a);
+        double                a1m=a1p-c2*b1;
+        double                a2m=-c2*b2;
+
+        for (int i=range.start;i<range.end;i++)
+            {
+            iy0 = img.ptr<float>(i);
+            int j=0;
+            iyp[0] = a0p*iy0[0] ;
+            iyp[1] = a0p*iy0[1] + a1p*iy0[0] - b1*iyp[0];
+            iy0 += 2;
+            for (j=2;j<cols;j++,iy0++)
+                iyp[j] = a0p*iy0[0] + a1p*iy0[-1] - b1*iyp[j-1] - b2*iyp[j-2];
+            iy0 = img.ptr<float>(i)+cols-1;
+            iym[cols-1] = 0;
+            iy0--;
+            iym[cols-2] = a1m*iy0[1]  - b1*iym[cols-1];
+            iy0--;
+            for (j=cols-3;j>=0;j--,iy0--)
+                iym[j] = a1m*iy0[1] + a2m*iy0[2] - b1*iym[j+1] - b2*iym[j+2];
+            iy = dst.ptr<float>(i);
+            for (j=0;j<cols;j++,iy++)
+                *iy = (float)(iym[j]+iyp[j]);
+            }
+
+    };
+    ParallelGradientPaillouYRows& operator=(const ParallelGradientPaillouYRows &) {
+         return *this;
+    };
+};
+
+
+class ParallelGradientPaillouXCols: public ParallelLoopBody
+{
+private:
+    Mat &img;
+    Mat &dst;
+    double a;
+    double w;
+    bool verbose;
+
+public:
+    ParallelGradientPaillouXCols(Mat& imgSrc, Mat &d,double aa,double ww):
+        img(imgSrc),
+        dst(d),
+        a(aa),
+        w(ww),
+        verbose(false)
+    {
+        int type = img.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong input type for GradientPaillouXCols");
+        type = dst.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong output type for GradientPaillouXCols");
+    }
+    void Verbose(bool b){verbose=b;}
+    virtual void operator()(const Range& range) const CV_OVERRIDE
+    {
+        if (verbose)
+            std::cout << getThreadNum() << "# :Start from row " << range.start << " to " << range.end - 1 << " (" << range.end - range.start << " loops)" << std::endl;
+        float *iy, *iy0;
+        int tailleSequence = (img.rows>img.cols) ? img.rows : img.cols;
+        Mat matIym(1,tailleSequence,CV_64FC1),  matIyp(1,tailleSequence,CV_64FC1);
+        double *iym=matIym.ptr<double>(0), *iyp=matIyp.ptr<double>(0);
+        int rows = img.rows,cols=img.cols;
+
+        // Equation 13 p193
+        double                d = (1 - 2 * exp(-a)*cosh(w) + exp(-2 * a)) / (2 * a*exp(-a)*sinh(w) + w*(1 - exp(-2 * a)));
+        double                c1 = a*d;
+        double                c2 = w*d;
+        // Equation 12 p193
+        double                b1 = -2 * exp(-a)*cosh(w);
+        double                b2 = exp(-2 * a);
+        // Equation 14 p193
+        double                a0p = c2;
+        double                a1p = (c1*sinh(w) - c2*cosh(w))*exp(-a);
+        double                a1m = a1p - c2*b1;
+        double                a2m = -c2*b2;
+
+        for (int j = range.start; j<range.end; j++)
+        {
+            iy0 = img.ptr<float>(0)+j;
+            iyp[0] = a0p*iy0[0];
+            iy0 +=cols;
+            iyp[1] = a0p*iy0[0] + a1p*iy0[-cols] - b1*iyp[0];
+            iy0 +=cols;
+            for (int i = 2; i<rows; i++, iy0+=cols)
+                iyp[i] = a0p*iy0[0] + a1p*iy0[-cols] - b1*iyp[i - 1] - b2*iyp[i - 2];
+            iy0 = img.ptr<float>(rows-1) + j;
+            iym[rows - 1] = 0;
+            iy0 -=cols;
+            iym[rows - 2] = a1m*iy0[cols] - b1*iym[rows-1];
+            iy0-=cols;
+            for (int i = rows - 3; i >= 0; i--, iy0-=cols)
+                iym[i] = a1m*iy0[cols] + a2m*iy0[2*cols] - b1*iym[i + 1] - b2*iym[i + 2];
+            iy = dst.ptr<float>(0)+j;
+            for (int i = 0; i<rows; i++, iy+=cols)
+                *iy = (float)(iym[i] + iyp[i]);
+        }
+
+    };
+    ParallelGradientPaillouXCols& operator=(const ParallelGradientPaillouXCols &) {
+         return *this;
+    };
+};
+
+
+class ParallelGradientPaillouXRows: public ParallelLoopBody
+{
+private:
+    Mat &img;
+    Mat &im1;
+    double a;
+    double w;
+    bool verbose;
+
+public:
+    ParallelGradientPaillouXRows(Mat& imgSrc, Mat &d,double aa,double ww):
+        img(imgSrc),
+        im1(d),
+        a(aa),
+        w(ww),
+        verbose(false)
+    {
+        int type = img.depth();
+        CV_CheckType(type, type == CV_8UC1 || type == CV_8SC1 || type == CV_16SC1 || type == CV_16UC1 || type == CV_32FC1, "Wrong input type for GradientPaillouXRows");
+        type = im1.depth();
+        CV_CheckType(type, type == CV_32FC1, "Wrong output type for GradientPaillouXRows");
+    }
+    void Verbose(bool b){verbose=b;}
+    virtual void operator()(const Range& range) const CV_OVERRIDE
+    {
+        if (verbose)
+            std::cout << getThreadNum()<<"# :Start from row " << range.start << " to "  << range.end-1<<" ("<<range.end-range.start<<" loops)" << std::endl;
+
+        // Equation 12 p193
+        switch(img.depth()){
+        case CV_8U :
+            HorizontalIIRFilter<uchar>(img,im1,range,a,w);
+            break;
+        case CV_8S :
+            HorizontalIIRFilter<char>(img, im1, range, a, w);
+            break;
+        case CV_16S :
+            HorizontalIIRFilter<short>(img, im1, range, a, w);
+            break;
+        case CV_16U:
+            HorizontalIIRFilter<ushort>(img, im1, range, a, w);
+            break;
+        case CV_32F:
+            HorizontalIIRFilter<float>(img, im1, range, a, w);
+            break;
+        default :
+            return ;
+            }
+    };
+    ParallelGradientPaillouXRows& operator=(const ParallelGradientPaillouXRows &) {
+         return *this;
+    };
+};
+
+void GradientPaillouY(InputArray _op, OutputArray _dst, double alpha, double omega)
+{
+    std::vector<Mat> planSrc;
+    split(_op,planSrc);
+    std::vector<Mat> planTmp;
+    std::vector<Mat> planDst;
+    for (int i = 0; i <static_cast<int>(planSrc.size()); i++)
+    {
+		planTmp.push_back(Mat(_op.size(), CV_32FC1));
+		planDst.push_back(Mat(_op.size(), CV_32FC1));
+        CV_Assert(planSrc[i].isContinuous() && planTmp[i].isContinuous() && planDst[i].isContinuous());
+        ParallelGradientPaillouYCols x(planSrc[i],planTmp[i],alpha,omega);
+        parallel_for_(Range(0, planSrc[i].cols), x,getNumThreads());
+        ParallelGradientPaillouYRows xr(planTmp[i],planDst[i],alpha,omega);
+        parallel_for_(Range(0, planTmp[i].rows), xr,getNumThreads());
+    }
+    merge(planDst,_dst);
+}
+
+void GradientPaillouX(InputArray _op, OutputArray _dst, double alpha, double omega)
+{
+    std::vector<Mat> planSrc;
+    split(_op,planSrc);
+    std::vector<Mat> planTmp;
+    std::vector<Mat> planDst;
+    for (int i = 0; i <static_cast<int>(planSrc.size()); i++)
+    {
+		planTmp.push_back(Mat(_op.size(), CV_32FC1));
+		planDst.push_back(Mat(_op.size(), CV_32FC1));
+        CV_Assert(planSrc[i].isContinuous() && planTmp[i].isContinuous() && planDst[i].isContinuous());
+        ParallelGradientPaillouXRows x(planSrc[i],planTmp[i],alpha,omega);
+        parallel_for_(Range(0, planSrc[i].rows), x,getNumThreads());
+        ParallelGradientPaillouXCols xr(planTmp[i],planDst[i],alpha,omega);
+        parallel_for_(Range(0, planTmp[i].cols), xr,getNumThreads());
+    }
+    merge(planDst,_dst);
+}
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/peilin.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/peilin.cpp
new file mode 100644
index 00000000..882987ed
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/peilin.cpp
@@ -0,0 +1,56 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+
+namespace cv { namespace ximgproc {
+
+    static inline Moments operator& ( const Moments & lhs, const Matx22d & rhs )
+    {
+        return Moments (
+            lhs.m00,
+            rhs ( 0, 0 ) * lhs.m10 + rhs ( 0, 1 ) * lhs.m01,
+            rhs ( 1, 0 ) * lhs.m10 + rhs ( 1, 1 ) * lhs.m01,
+            rhs ( 0, 0 ) * rhs ( 0, 0 ) * lhs.m20 + rhs ( 0, 1 ) * rhs ( 0, 1 ) * lhs.m02 + 2 * rhs ( 0, 0 ) * rhs ( 0, 1 ) * lhs.m11,
+            rhs ( 0, 0 ) * rhs ( 1, 0 ) * lhs.m20 + rhs ( 0, 1 ) * rhs ( 1, 1 ) * lhs.m02 + ( rhs ( 0, 0 ) * rhs ( 1, 1 ) + rhs ( 0, 1 ) * rhs ( 1, 0 ) ) * lhs.m11,
+            rhs ( 1, 0 ) * rhs ( 1, 0 ) * lhs.m20 + rhs ( 1, 1 ) * rhs ( 1, 1 ) * lhs.m02 + 2 * rhs ( 1, 0 ) * rhs ( 1, 1 ) * lhs.m11,
+            rhs ( 0, 0 ) * rhs ( 0, 0 ) * rhs ( 0, 0 ) * lhs.m30 + 3 * rhs ( 0, 0 ) * rhs ( 0, 0 ) * rhs ( 0, 1 ) * lhs.m21 + 3 * rhs ( 0, 0 ) * rhs ( 0, 1 ) * rhs ( 0, 1 ) * lhs.m12 + rhs ( 0, 1 ) * rhs ( 0, 1 ) * rhs ( 0, 1 ) * lhs.m03,
+            rhs ( 0, 0 ) * rhs ( 0, 0 ) * rhs ( 1, 0 ) * lhs.m30 + ( rhs ( 0, 0 ) * rhs ( 0, 0 ) * rhs ( 1, 1 ) + 2 * rhs ( 0, 0 ) * rhs ( 0, 1 ) * rhs ( 1, 0 ) ) * lhs.m21 + ( 2 * rhs ( 0, 0 ) * rhs ( 0, 1 ) * rhs ( 1, 1 ) + rhs ( 0, 1 ) * rhs ( 0, 1 ) * rhs ( 1, 0 ) ) * lhs.m12 + rhs ( 0, 1 ) * rhs ( 0, 1 ) * rhs ( 1, 1 ) * lhs.m03,
+            rhs ( 0, 0 ) * rhs ( 1, 0 ) * rhs ( 1, 0 ) * lhs.m30 + ( rhs ( 1, 0 ) * rhs ( 1, 0 ) * rhs ( 0, 1 ) + 2 * rhs ( 0, 0 ) * rhs ( 1, 0 ) * rhs ( 1, 1 ) ) * lhs.m21 + ( 2 * rhs ( 0, 1 ) * rhs ( 1, 0 ) * rhs ( 1, 1 ) + rhs ( 1, 1 ) * rhs ( 1, 1 ) * rhs ( 0, 0 ) ) * lhs.m12 + rhs ( 0, 1 ) * rhs ( 1, 1 ) * rhs ( 1, 1 ) * lhs.m03,
+            rhs ( 1, 0 ) * rhs ( 1, 0 ) * rhs ( 1, 0 ) * lhs.m30 + 3 * rhs ( 1, 0 ) * rhs ( 1, 0 ) * rhs ( 1, 1 ) * lhs.m21 + 3 * rhs ( 1, 0 ) * rhs ( 1, 1 ) * rhs ( 1, 1 ) * lhs.m12 + rhs ( 1, 1 ) * rhs ( 1, 1 ) * rhs ( 1, 1 ) * lhs.m03
+        );
+    }
+
+    static inline Matx23d operator| ( const Matx22d & lhs, const Matx21d & rhs )
+    {
+        return Matx23d ( lhs ( 0, 0 ), lhs ( 0, 1 ), rhs ( 0 ), lhs ( 1, 0 ), lhs ( 1, 1 ), rhs ( 1 ) );
+    }
+
+    Matx23d PeiLinNormalization ( InputArray I )
+    {
+        const Moments  M = moments ( I );
+        const double  l1 = ( M.mu20 / M.m00 + M.mu02 / M.m00 + sqrt ( ( M.mu20 / M.m00 - M.mu02 / M.m00 ) * ( M.mu20 / M.m00 - M.mu02 / M.m00 ) + 4 * M.mu11 / M.m00 * M.mu11 / M.m00 ) ) / 2;
+        const double  l2 = ( M.mu20 / M.m00 + M.mu02 / M.m00 - sqrt ( ( M.mu20 / M.m00 - M.mu02 / M.m00 ) * ( M.mu20 / M.m00 - M.mu02 / M.m00 ) + 4 * M.mu11 / M.m00 * M.mu11 / M.m00 ) ) / 2;
+        const double  ex = ( M.mu11 / M.m00 ) / sqrt ( ( l1 - M.mu20 / M.m00 ) * ( l1 - M.mu20 / M.m00 ) + M.mu11 / M.m00 * M.mu11 / M.m00 );
+        const double  ey = ( l1 - M.mu20 / M.m00 ) / sqrt ( ( l1 - M.mu20 / M.m00 ) * ( l1 - M.mu20 / M.m00 ) + M.mu11 / M.m00 * M.mu11 / M.m00 );
+        const Matx22d  E = Matx22d ( ex, ey, -ey, ex );
+        const double   p = min ( I.size().height, I.size().width ) / 8;
+        const Matx22d  W = Matx22d ( p / sqrt ( l1 ), 0, 0, p / sqrt ( l2 ) );
+        const Matx21d  c = Matx21d ( M.m10 / M.m00, M.m01 / M.m00 );
+        const Matx21d  i = Matx21d ( I.size().width / 2, I.size().height / 2 );
+        const Moments  N = M & W * E;
+        const double  t1 = N.mu12 + N.mu30;
+        const double  t2 = N.mu03 + N.mu21;
+        const double phi = atan2 ( -t1, t2 );
+        const double psi = ( -t1 * sin ( phi ) + t2 * cos ( phi ) >= 0 ) ? phi : ( phi + CV_PI  );
+        const Matx22d  A = Matx22d ( cos ( psi ), sin ( psi ), -sin ( psi ), cos ( psi ) );
+        return ( A * W * E ) | ( i - A * W * E * c );
+    }
+
+    void PeiLinNormalization ( InputArray I, OutputArray T )
+    {
+        T.assign ( Mat ( PeiLinNormalization ( I ) ) );
+    }
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/precomp.hpp
new file mode 100644
index 00000000..29e77d0a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/precomp.hpp
@@ -0,0 +1,52 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#ifndef _OPENCV_XIMGPROC_PRECOMP_HPP_
+#define _OPENCV_XIMGPROC_PRECOMP_HPP_
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/ocl.hpp>
+#include <opencv2/core/base.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/core/private.hpp>
+#include <opencv2/imgproc.hpp>
+
+#include <opencv2/ximgproc.hpp>
+
+#include <algorithm>
+#include <map>
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/quaternion.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/quaternion.cpp
new file mode 100644
index 00000000..3b1ea163
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/quaternion.cpp
@@ -0,0 +1,200 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.#include "precomp.hpp"
+#include "precomp.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/ximgproc/color_match.hpp"
+
+using namespace std;
+
+namespace cv { namespace ximgproc {
+
+void createQuaternionImage(InputArray _img, OutputArray _qimg)
+{
+    int type = _img.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_CheckType(depth, depth == CV_8U || depth == CV_32F || depth == CV_64F, "Depth must be CV_8U, CV_32F or CV_64F");
+    CV_Assert(_img.dims() == 2 && cn == 3);
+    vector<Mat> qplane(4);
+    vector<Mat> plane;
+    split(_img, plane);
+    qplane[0] = Mat::zeros(_img.size(), CV_64FC1);
+    for (int i = 0; i < cn; i++)
+        plane[i].convertTo(qplane[3-i], CV_64F);
+    merge(qplane, _qimg);
+}
+
+void qconj(InputArray _img, OutputArray _qimg)
+{
+    int type = _img.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_CheckType(depth, depth == CV_32F || depth == CV_64F, "Depth must be CV_32F or CV_64F");
+    CV_Assert(_img.dims() == 2 && cn == 4);
+    vector<Mat> qplane(4), plane;
+    split(_img, plane);
+    qplane[0] = plane[0];
+    qplane[1] = -plane[1];
+    qplane[2] = -plane[2];
+    qplane[3] = -plane[3];
+    merge(qplane, _qimg);
+}
+
+void qunitary(InputArray _img, OutputArray _qimg)
+{
+    int type = _img.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_Assert((depth == CV_64F) && _img.dims() == 2 && cn == 4);
+    _img.copyTo(_qimg);
+    Mat qimg = _qimg.getMat();
+    qimg.forEach<Vec4d>([](Vec4d &p, const int * /*position*/) -> void {
+        double d = p[0] * p[0] + p[1] * p[1] + p[2] * p[2] + p[3] * p[3];
+        d = 1 / sqrt(d);
+        p *= d;
+    });
+}
+
+void qdft(InputArray _img, OutputArray _qimg, int  	flags, bool sideLeft)
+{
+    CV_INSTRUMENT_REGION();
+
+    int type = _img.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_Assert(depth == CV_64F && _img.dims() == 2 && cn == 4);
+    float c;
+    if (sideLeft)
+        c = 1;  // Left qdft
+    else
+        c = -1; // right qdft
+
+    vector<Mat> q;
+    Mat img;
+    img = _img.getMat();
+
+    CV_Assert(getOptimalDFTSize(img.rows) == img.rows && getOptimalDFTSize(img.cols) == img.cols);
+
+    split(img, q);
+    Mat c1r;
+    Mat c1i; // Imaginary part of c1 =x'
+    Mat c2r; // Real part of c2 =y'
+    Mat c2i; // Imaginary part of c2=z'
+    c1r = q[0].clone();
+    c1i = (q[1] + q[2] + q[3]) / sqrt(3);
+    c2r = (q[2] - q[3]) / sqrt(2);
+    c2i = c * (q[3] + q[2] - 2 * q[1]) / sqrt(6);
+    vector<Mat> vc1 = { c1r,c1i }, vc2 = { c2r,c2i };
+    Mat c1, c2, C1, C2;
+    merge(vc1, c1);
+    merge(vc2, c2);
+    if (flags& DFT_INVERSE)
+    {
+        dft(c1, C1, DFT_COMPLEX_OUTPUT | DFT_INVERSE|DFT_SCALE);
+        dft(c2, C2, DFT_COMPLEX_OUTPUT | DFT_INVERSE | DFT_SCALE);
+    }
+    else
+    {
+        dft(c1, C1, DFT_COMPLEX_OUTPUT);
+        dft(c2, C2, DFT_COMPLEX_OUTPUT);
+    }
+    split(C1, vc1);
+    split(C2, vc2);
+    vector<Mat> qdft(4);
+    qdft[0] = vc1[0].clone();
+    qdft[1] = vc1[1] / sqrt(3) - c * 2 * vc2[1] / sqrt(6);
+    qdft[2] = vc1[1] / sqrt(3) + vc2[0] / sqrt(2) + c * vc2[1] / sqrt(6);
+    qdft[3] = vc1[1] / sqrt(3) - vc2[0] / sqrt(2) + c * vc2[1] / sqrt(6);
+    Mat dst0;
+    merge(qdft, dst0);
+    dst0.copyTo(_qimg);
+}
+
+
+void qmultiply(InputArray  	src1, InputArray  	src2, OutputArray  	dst)
+{
+    int type = src1.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_Assert(depth == CV_64F && src1.dims() == 2 && cn == 4);
+    type = src2.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_Assert(depth == CV_64F && src2.dims() == 2 && cn == 4);
+    vector<Mat> q3(4);
+    if (src1.rows() == src2.rows() && src1.cols() == src2.cols())
+    {
+        vector<Mat> q1, q2;
+        split(src1, q1);
+        split(src2, q2);
+        q3[0] = q1[0].mul(q2[0]) - q1[1].mul(q2[1]) - q1[2].mul(q2[2]) - q1[3].mul(q2[3]);
+        q3[1] = q1[0].mul(q2[1]) + q1[1].mul(q2[0]) + q1[2].mul(q2[3]) - q1[3].mul(q2[2]);
+        q3[2] = q1[0].mul(q2[2]) - q1[1].mul(q2[3]) + q1[2].mul(q2[0]) + q1[3].mul(q2[1]);
+        q3[3] = q1[0].mul(q2[3]) + q1[1].mul(q2[2]) - q1[2].mul(q2[1]) + q1[3].mul(q2[0]);
+    }
+    else if (src1.rows() == 1 && src1.cols() == 1)
+    {
+        vector<Mat> q2;
+        Vec4d q1 = src1.getMat().at<Vec4d>(0, 0);
+        split(src2, q2);
+        q3[0] = q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2] - q1[3] * q2[3];
+        q3[1] = q1[0] * q2[1] + q1[1] * q2[0] + q1[2] * q2[3] - q1[3] * q2[2];
+        q3[2] = q1[0] * q2[2] - q1[1] * q2[3] + q1[2] * q2[0] + q1[3] * q2[1];
+        q3[3] = q1[0] * q2[3] + q1[1] * q2[2] - q1[2] * q2[1] + q1[3] * q2[0];
+    }
+    else if (src2.rows() == 1 && src2.cols() == 1)
+    {
+        vector<Mat> q1;
+        split(src1, q1);
+        Vec4d q2 = src2.getMat().at<Vec4d>(0, 0);
+        q3[0] = q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2] - q1[3] * q2[3];
+        q3[1] = q1[0] * q2[1] + q1[1] * q2[0] + q1[2] * q2[3] - q1[3] * q2[2];
+        q3[2] = q1[0] * q2[2] - q1[1] * q2[3] + q1[2] * q2[0] + q1[3] * q2[1];
+        q3[3] = q1[0] * q2[3] + q1[1] * q2[2] - q1[2] * q2[1] + q1[3] * q2[0];
+    }
+    else
+        CV_Assert(src1.rows() == src2.rows() && src1.cols() == src2.cols());
+    merge(q3, dst);
+
+}
+
+void colorMatchTemplate(InputArray _image, InputArray _templ, OutputArray _result)
+{
+    CV_INSTRUMENT_REGION();
+    Mat image = _image.getMat(), imageF;
+    CV_Assert(image.channels() == 3);
+    Mat colorTemplate = _templ.getMat(), colorTemplateF;
+    CV_Assert(colorTemplate.channels() == 3);
+    int rr = max(getOptimalDFTSize(image.rows), getOptimalDFTSize(colorTemplate.rows));
+    int cc = max(getOptimalDFTSize(image.cols), getOptimalDFTSize(colorTemplate.cols));
+    Mat logo(rr, cc, CV_64FC3, Scalar::all(0));
+    Mat img = Mat(rr, cc, CV_64FC3, Scalar::all(0));
+    colorTemplate.convertTo(colorTemplateF, CV_64F, 1 / 256.),
+    colorTemplateF.copyTo(logo(Rect(0, 0, colorTemplate.cols, colorTemplate.rows)));
+    image.convertTo(imageF, CV_64F, 1 / 256.);
+    imageF.copyTo(img(Rect(0, 0, image.cols, image.rows)));
+    Mat qimg, qlogo;
+    Mat qimgFFT, qimgIFFT, qlogoFFT;
+    // Create quaternion image
+    createQuaternionImage(img, qimg);
+    createQuaternionImage(logo, qlogo);
+    // quaternion fourier transform
+    qdft(qimg, qimgFFT, 0, true);
+    qdft(qimg, qimgIFFT, DFT_INVERSE, true);
+    qdft(qlogo, qlogoFFT, 0, false);
+    double sqrtnn = sqrt(static_cast<int>(qimgFFT.rows*qimgFFT.cols));
+    qimgFFT /= sqrtnn;
+    qimgIFFT *= sqrtnn;
+    qlogoFFT /= sqrtnn;
+    Mat mu(1, 1, CV_64FC4, Scalar(0, 1, 1, 1) / sqrt(3.));
+    Mat qtmp, qlogopara, qlogoortho;
+    qmultiply(mu, qlogoFFT, qtmp);
+    qmultiply(qtmp, mu, qtmp);
+    subtract(qlogoFFT, qtmp, qlogopara);
+    qlogopara = qlogopara / 2;
+    subtract(qlogoFFT, qlogopara, qlogoortho);
+    Mat qcross1, qcross2, cqf, cqfi;
+    qconj(qimgFFT, cqf);
+    qconj(qimgIFFT, cqfi);
+    qmultiply(cqf, qlogopara, qcross1);
+    qmultiply(cqfi, qlogoortho, qcross2);
+    Mat pwsp = qcross1 + qcross2;
+    Mat crossCorr, pwspUnitary;
+    qunitary(pwsp, pwspUnitary);
+    qdft(pwspUnitary, crossCorr, DFT_INVERSE, false);
+    vector<Mat> p;
+    split(crossCorr, p);
+    Mat imgcorr = (p[0].mul(p[0]) + p[1].mul(p[1]) + p[2].mul(p[2]) + p[3].mul(p[3]));
+    sqrt(imgcorr, _result);
+}
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/radon_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/radon_transform.cpp
new file mode 100644
index 00000000..5e23edda
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/radon_transform.cpp
@@ -0,0 +1,81 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+
+namespace cv {namespace ximgproc {
+    void RadonTransform(InputArray src,
+                             OutputArray dst,
+                             double theta,
+                             double start_angle,
+                             double end_angle,
+                             bool crop,
+                             bool norm)
+    {
+        CV_Assert(src.dims() == 2);
+        CV_Assert(src.channels() == 1);
+        CV_Assert((end_angle - start_angle) * theta > 0);
+
+        Mat _srcMat = src.getMat();
+
+        int _row_num, _col_num, _out_mat_type;
+        _col_num = cvRound((end_angle - start_angle) / theta);
+        transpose(_srcMat, _srcMat);
+        Mat _masked_src;
+        cv::Point _center;
+
+        if (_srcMat.type() == CV_32FC1 || _srcMat.type() == CV_64FC1) {
+            _out_mat_type = CV_64FC1;
+        }
+        else {
+            _out_mat_type = CV_32SC1;
+        }
+
+        if (crop) {
+            // crop the source into square
+            _row_num = min(_srcMat.rows, _srcMat.cols);
+            cv::Rect _crop_ROI(
+                _srcMat.cols / 2 - _row_num / 2,
+                _srcMat.rows / 2 - _row_num / 2,
+                _row_num, _row_num);
+            _srcMat = _srcMat(_crop_ROI);
+            // crop the source into circle
+            Mat _mask(_srcMat.size(), CV_8UC1, Scalar(0));
+            _center = Point(_srcMat.cols / 2, _srcMat.rows / 2);
+            circle(_mask, _center, _srcMat.cols / 2, Scalar(255), FILLED);
+            _srcMat.copyTo(_masked_src, _mask);
+        }
+        else {
+            // avoid cropping corner when rotating
+            _row_num = cvCeil(sqrt(_srcMat.rows * _srcMat.rows + _srcMat.cols * _srcMat.cols));
+            _masked_src = Mat(Size(_row_num, _row_num), _srcMat.type(), Scalar(0));
+            _center = Point(_masked_src.cols / 2, _masked_src.rows / 2);
+            _srcMat.copyTo(_masked_src(Rect(
+                (_row_num - _srcMat.cols) / 2,
+                (_row_num - _srcMat.rows) / 2,
+                _srcMat.cols, _srcMat.rows)));
+        }
+
+        double _t;
+        Mat _rotated_src;
+        Mat _radon(_row_num, _col_num, _out_mat_type);
+
+        for (int _col = 0; _col < _col_num; _col++) {
+            // rotate the source by _t
+            _t = (start_angle + _col * theta);
+            cv::Mat _r_matrix = cv::getRotationMatrix2D(_center, _t, 1);
+            cv::warpAffine(_masked_src, _rotated_src, _r_matrix, _masked_src.size());
+            Mat _col_mat = _radon.col(_col);
+            // make projection
+            cv::reduce(_rotated_src, _col_mat, 1, REDUCE_SUM, _out_mat_type);
+        }
+
+        if (norm) {
+            normalize(_radon, _radon, 0, 255, NORM_MINMAX, CV_8UC1);
+        }
+
+        _radon.copyTo(dst);
+        return;
+    }
+} }
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/ridgedetectionfilter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/ridgedetectionfilter.cpp
new file mode 100644
index 00000000..a98062d6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/ridgedetectionfilter.cpp
@@ -0,0 +1,73 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/ximgproc/ridgefilter.hpp"
+
+namespace cv { namespace ximgproc {
+
+class RidgeDetectionFilterImpl : public RidgeDetectionFilter
+{
+public:
+    int _ddepth, _dx, _dy, _ksize;
+    double _scale, _delta;
+    int _borderType;
+    int _out_dtype;
+    RidgeDetectionFilterImpl(int ddepth=CV_32FC1, int dx=1, int dy=1, int ksize = 3, int out_dtype=CV_8UC1, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT)
+    {
+        CV_Assert((ksize == 1 || ksize == 3 || ksize == 5 || ksize == 7));
+        CV_Assert((ddepth == CV_32FC1 || ddepth == CV_64FC1));
+        _ddepth = ddepth;
+        _dx = dx;
+        _dy = dy;
+        _ksize = ksize;
+        _scale = scale;
+        _delta = delta;
+        _borderType = borderType;
+        _out_dtype = out_dtype;
+    }
+    virtual void getRidgeFilteredImage(InputArray _img, OutputArray out) CV_OVERRIDE;
+};
+
+void RidgeDetectionFilterImpl::getRidgeFilteredImage(InputArray _img, OutputArray out)
+{
+    Mat img = _img.getMat();
+    CV_Assert(img.channels() == 1 || img.channels() == 3);
+
+    if(img.channels() == 3)
+        cvtColor(img, img, COLOR_BGR2GRAY);
+
+    Mat sbx, sby;
+    Sobel(img, sbx, _ddepth, _dx, 0, _ksize, _scale, _delta, _borderType);
+    Sobel(img, sby, _ddepth, 0, _dy, _ksize, _scale, _delta, _borderType);
+
+    Mat sbxx, sbyy, sbxy;
+    Sobel(sbx, sbxx, _ddepth, _dx, 0, _ksize, _scale, _delta, _borderType);
+    Sobel(sby, sbyy, _ddepth, 0, _dy, _ksize, _scale, _delta, _borderType);
+    Sobel(sbx, sbxy, _ddepth, 0, _dy, _ksize, _scale, _delta, _borderType);
+
+    Mat sb2xx, sb2yy, sb2xy;
+    multiply(sbxx, sbxx, sb2xx);
+    multiply(sbyy, sbyy, sb2yy);
+    multiply(sbxy, sbxy, sb2xy);
+
+    Mat sbxxyy;
+    multiply(sbxx, sbyy, sbxxyy);
+
+    Mat rootex;
+    rootex = (sb2xx +  (sb2xy + sb2xy + sb2xy + sb2xy)  - (sbxxyy + sbxxyy) + sb2yy );
+    Mat root;
+    sqrt(rootex, root);
+    Mat ridgexp;
+    ridgexp = ( (sbxx + sbyy) + root );
+    ridgexp.convertTo(out, _out_dtype, 0.5);
+}
+
+Ptr<RidgeDetectionFilter> RidgeDetectionFilter::create(int ddepth, int dx, int dy, int ksize, int out_dtype, double scale, double delta, int borderType)
+{
+    return makePtr<RidgeDetectionFilterImpl>(ddepth, dx, dy, ksize, out_dtype, scale, delta, borderType);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/rolling_guidance_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/rolling_guidance_filter.cpp
new file mode 100644
index 00000000..7e6d2674
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/rolling_guidance_filter.cpp
@@ -0,0 +1,83 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include <opencv2/ximgproc.hpp>
+
+namespace cv
+{
+namespace ximgproc
+{
+    void rollingGuidanceFilter(InputArray src_, OutputArray dst_, int d,
+                               double sigmaColor, double sigmaSpace,  int numOfIter, int borderType)
+    {
+        CV_Assert(!src_.empty());
+
+        Mat guidance = src_.getMat();
+        Mat src = src_.getMat();
+
+        CV_Assert(src.size() == guidance.size());
+        CV_Assert(src.depth() == guidance.depth() && (src.depth() == CV_8U || src.depth() == CV_32F) );
+
+        if (sigmaColor <= 0)
+            sigmaColor = 1;
+        if (sigmaSpace <= 0)
+            sigmaSpace = 1;
+
+        dst_.create(src.size(), src.type());
+        Mat dst = dst_.getMat();
+
+        if (src.data == guidance.data)
+            guidance = guidance.clone();
+        if (dst.data == src.data)
+            src = src.clone();
+
+        int srcCnNum = src.channels();
+
+        if (srcCnNum == 1 || srcCnNum == 3)
+        {
+            while(numOfIter--){
+                jointBilateralFilter(guidance, src, guidance, d, sigmaColor, sigmaSpace, borderType);
+            }
+            guidance.copyTo(dst_);
+        }
+        else
+        {
+            CV_Error(Error::BadNumChannels, "Unsupported number of channels");
+        }
+    }
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/run_length_morphology.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/run_length_morphology.cpp
new file mode 100644
index 00000000..3cf88048
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/run_length_morphology.cpp
@@ -0,0 +1,812 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+#include "precomp.hpp"
+#include <math.h>
+#include <vector>
+#include <iostream>
+
+
+namespace cv {
+namespace ximgproc {
+namespace rl {
+
+struct rlType
+{
+  int cb, ce, r;
+  rlType(int cbIn, int ceIn, int rIn): cb(cbIn), ce(ceIn), r(rIn) {}
+  rlType(): cb(0), ce(0), r(0) {}
+  bool operator < (const rlType& other) const { if (r < other.r || (r == other.r && cb < other.cb)
+      || (r == other.r && cb == other.cb && ce < other.ce)) return true; else return false; }
+};
+
+typedef std::vector<rlType> rlVec;
+
+template <class T>
+void _thresholdLine(T* pData, int nWidth, int nRow, T threshold, int type, rlVec& res)
+{
+  bool bOn = false;
+  int nStartSegment = 0;
+  for (int j = 0; j < nWidth; j++)
+  {
+    bool bAboveThreshold = (pData[j] > threshold);
+    bool bCurOn = (bAboveThreshold == (THRESH_BINARY == type));
+    if (!bOn && bCurOn)
+    {
+      nStartSegment = j;
+      bOn = true;
+    }
+    else if (bOn && !bCurOn)
+    {
+      rlType chord(nStartSegment, j - 1, nRow);
+      res.push_back(chord);
+      bOn = false;
+    }
+
+  }
+  if (bOn)
+  {
+    rlType chord(nStartSegment, nWidth - 1, nRow);
+    res.push_back(chord);
+  }
+}
+
+static void _threshold(cv::Mat& img, rlVec& res, double threshold, int type)
+{
+  res.clear();
+  switch (img.depth())
+  {
+  case CV_8U:
+    for (int i = 0; i < img.rows; ++i)
+      _thresholdLine<uchar>(img.ptr(i), img.cols, i, (uchar) threshold, type, res);
+    break;
+  case CV_8S:
+    for (int i = 0; i < img.rows; ++i)
+      _thresholdLine<schar>((schar*) img.ptr(i), img.cols, i, (schar) threshold, type, res);
+    break;
+  case CV_16U:
+      for (int i = 0; i < img.rows; ++i)
+      {
+          _thresholdLine<unsigned short>((unsigned short*)img.ptr(i), img.cols, i,
+              (unsigned short)threshold, type, res);
+      }
+    break;
+  case CV_16S:
+    for (int i = 0; i < img.rows; ++i)
+      _thresholdLine<short>((short*) img.ptr(i), img.cols, i, (short) threshold, type, res);
+    break;
+  case CV_32S:
+    for (int i = 0; i < img.rows; ++i)
+      _thresholdLine<int>((int*) img.ptr(i), img.cols, i, (int) threshold, type, res);
+    break;
+  case CV_32F:
+    for (int i = 0; i < img.rows; ++i)
+      _thresholdLine<float>((float*) img.ptr(i), img.cols, i, (float) threshold, type, res);
+    break;
+  case CV_64F:
+    for (int i = 0; i < img.rows; ++i)
+      _thresholdLine<double>((double*) img.ptr(i), img.cols, i, threshold, type, res);
+    break;
+  default:
+    CV_Error( Error::StsUnsupportedFormat, "unsupported image type" );
+  }
+}
+
+
+static void convertToOutputArray(rlVec& runs, Size size, OutputArray& res)
+{
+    size_t nRuns = runs.size();
+    std::vector<cv::Point3i> segments(nRuns + 1);
+    segments[0] = cv::Point3i(size.width, size.height, 0);
+    for (size_t i = 0; i < nRuns; ++i)
+    {
+        rlType& curRun = runs[i];
+        segments[i + 1] = Point3i(curRun.cb, curRun.ce, curRun.r);
+    }
+    Mat(segments).copyTo(res);
+}
+
+
+CV_EXPORTS void threshold(InputArray src, OutputArray rlDest, double thresh, int type)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat image = src.getMat();
+    CV_Assert(!image.empty() && image.channels() == 1);
+    CV_Assert(type == THRESH_BINARY || type == THRESH_BINARY_INV);
+    rlVec runs;
+    _threshold(image, runs, thresh, type);
+    Size size(image.cols, image.rows);
+
+    convertToOutputArray(runs, size, rlDest);
+}
+
+
+template <class T>
+void paint_impl(cv::Mat& img, rlType* pRuns, int nSize, T value)
+{
+    int i;
+    rlType* pCurRun;
+    for (pCurRun = pRuns, i = 0; i< nSize; ++pCurRun, ++i)
+    {
+        rlType& curRun = *pCurRun;
+        if (curRun.r < 0 || curRun.r >= img.rows || curRun.cb >= img.cols || curRun.ce < 0)
+            continue;
+
+        T* rowPtr = (T*)img.ptr(curRun.r);
+        std::fill(rowPtr + std::max(curRun.cb, 0), rowPtr + std::min(curRun.ce + 1, img.cols), value);
+    }
+}
+
+  CV_EXPORTS void paint(InputOutputArray image, InputArray rlSrc, const Scalar& value)
+  {
+    Mat _runs;
+    _runs = rlSrc.getMat();
+    int N = _runs.checkVector(3);
+    if (N <= 1)
+        return;
+
+    double dValue = value[0];
+
+    cv::Mat _image = image.getMat();
+
+    rlType* pRuns = (rlType*) &(_runs.at<Point3i>(1));
+    switch (_image.type())
+    {
+    case CV_8UC1:
+        paint_impl<uchar>(_image, pRuns, N - 1, (uchar)dValue);
+        break;
+    case CV_8SC1:
+        paint_impl<schar>(_image, pRuns, N - 1, (schar)dValue);
+        break;
+    case CV_16UC1:
+        paint_impl<unsigned short>(_image, pRuns, N - 1, (unsigned short)dValue);
+        break;
+    case CV_16SC1:
+        paint_impl<short>(_image, pRuns, N - 1, (short)dValue);
+        break;
+    case CV_32SC1:
+        paint_impl<int>(_image, pRuns, N - 1, (int)dValue);
+        break;
+    case CV_32FC1:
+        paint_impl<float>(_image, pRuns, N - 1, (float)dValue);
+        break;
+    case CV_64FC1:
+        paint_impl<double>(_image, pRuns, N - 1, dValue);
+        break;
+    default:
+        CV_Error(Error::StsUnsupportedFormat, "unsupported image type");
+        break;
+    }
+  }
+
+static void translateRegion(rlVec& reg, Point ptTrans)
+{
+    for (rlVec::iterator it=reg.begin();it!=reg.end();++it)
+    {
+        it->r += ptTrans.y;
+        it->cb += ptTrans.x;
+        it->ce += ptTrans.x;
+    }
+}
+
+CV_EXPORTS Mat getStructuringElement(int shape, Size ksize)
+{
+  Mat mask = cv::getStructuringElement(shape, ksize);
+
+  rlVec reg;
+  _threshold(mask, reg, 0.0, THRESH_BINARY);
+
+  Point ptTrans = - Point(mask.cols / 2, mask.rows / 2);
+  translateRegion(reg, ptTrans);
+  Mat rlDest;
+  convertToOutputArray(reg, Size(mask.cols, mask.rows), rlDest);
+
+  return rlDest;
+}
+
+static void erode_rle (rlVec& regIn, rlVec& regOut, rlVec& se)
+{
+  using namespace std;
+
+    regOut.clear();
+
+    if (regIn.size() == 0)
+        return;
+
+    int nMinRow = regIn[0].r;
+    int nMaxRow = regIn.back().r;
+
+    int nRows = nMaxRow - nMinRow + 1;
+
+
+    const int EMPTY = -1;
+
+    // setup a table which holds the index of the first chord for each row
+    vector<int> pIdxChord1(nRows);
+    vector<int> pIdxNextRow(nRows);
+
+    int i,j;
+
+    for (i=1;i<nRows;i++)
+    {
+        pIdxChord1[i] = EMPTY;
+        pIdxNextRow[i] = EMPTY;
+    }
+
+    pIdxChord1[0] = 0;
+    pIdxNextRow[nRows-1] = (int) regIn.size();
+
+    for (i=1; i < (int) regIn.size();i++)
+        if (regIn[i].r != regIn[i-1].r)
+        {
+            pIdxChord1[regIn[i].r - nMinRow] = i;
+            pIdxNextRow[regIn[i-1].r - nMinRow] = i;
+        }
+
+    int nMinRowSE = se[0].r;
+    int nMaxRowSE = se.back().r;
+
+    int nRowsSE = nMaxRowSE - nMinRowSE + 1;
+
+    assert(nRowsSE == (int) se.size());
+
+    vector<int> pCurIdxRow(nRowsSE);
+
+    // loop through all possible rows
+    for (i=nMinRow - nMinRowSE; i<= nMaxRow - nMaxRowSE; i++)
+    {
+        // check whether all relevant rows are available
+        bool bNextRow = false;
+
+        for (j=0; j < nRowsSE; j++)
+        {
+            // get idx of first chord in regIn for this row of the se
+            pCurIdxRow[j] = pIdxChord1[ j + nMinRowSE + i - nMinRow];
+            if (pCurIdxRow[j] == -1)
+            {
+                bNextRow = true;
+                break;
+            }
+        }
+
+        if (bNextRow)
+            continue;
+
+        while (!bNextRow)
+        {
+          int nPossibleStart = std::numeric_limits<int>::min();
+
+          // search for row with max( cb - se.cb) (the leftmost possible position of a result chord
+          for (j=0;j<nRowsSE;j++)
+              nPossibleStart = max(nPossibleStart, regIn[pCurIdxRow[j]].cb - se[j].cb);
+
+          // for all rows skip chords whose end is left from the point
+          // where it can contribute to a result
+          bool bHaveResult = true;
+          int nLimitingRow = 0;
+          int nChordEnd = std::numeric_limits<int>::max(); //INT_MAX;
+
+          for (j=0;j<nRowsSE;j++)
+          {
+              while (regIn[pCurIdxRow[j]].ce < nPossibleStart + se[j].ce &&
+                  pCurIdxRow[j] != pIdxNextRow[j + nMinRowSE + i - nMinRow])
+              {
+                  pCurIdxRow[j]++;
+              }
+
+              // if all chords in this row skipped -> next row
+              if (pCurIdxRow[j] == pIdxNextRow[ j + nMinRowSE + i - nMinRow])
+              {
+                  bNextRow = true;
+                  bHaveResult = false;
+                  break;
+              }
+              else if ( bHaveResult )
+              {
+              // can the found chord contribute to a result ?
+              if (regIn[ pCurIdxRow[j] ].cb - se[j].cb <= nPossibleStart)
+              {
+                  int nCurPossibleEnd = regIn[ pCurIdxRow[j] ].ce - se[j].ce;
+                  if (nCurPossibleEnd < nChordEnd)
+                  {
+                      nChordEnd = nCurPossibleEnd;
+                      nLimitingRow = j;
+                  }
+              }
+              else
+                  bHaveResult = false;
+              }
+          }
+
+        if (bHaveResult)
+        {
+            regOut.push_back(rlType(nPossibleStart, nChordEnd, i));
+            pCurIdxRow[nLimitingRow]++;
+
+            if (pCurIdxRow[nLimitingRow] == pIdxNextRow[ nLimitingRow + nMinRowSE + i - nMinRow])
+                  bNextRow = true;
+        }
+        } // end while (!bNextRow
+    } // end for
+
+}
+
+static void convertInputArrayToRuns(InputArray& theArray, rlVec& runs, Size& theSize)
+{
+  Mat _runs;
+  _runs = theArray.getMat();
+  int N = _runs.checkVector(3);
+  if (N == 0)
+  {
+      runs.clear();
+      return;
+  }
+  runs.resize(N - 1);
+  Point3i pt = _runs.at<Point3i>(0);
+  theSize.width = pt.x;
+  theSize.height = pt.y;
+
+  for (int i = 1; i < N; ++i)
+  {
+    pt = _runs.at<Point3i>(i);
+    runs[i-1] = rlType(pt.x, pt.y, pt.z);
+  }
+}
+
+static void sortChords(rlVec& lChords)
+{
+    sort(lChords.begin(), lChords.end());
+}
+
+static void mergeNeighbouringChords(rlVec& rlIn, rlVec& rlOut)
+{
+    rlOut.clear();
+    if (rlIn.size() == 0)
+        return;
+
+    rlOut.push_back(rlIn[0]);
+
+    for (int i = 1; i< (int)rlIn.size(); i++)
+    {
+        rlType& curIn = rlIn[i];
+        rlType& lastAddedOut = rlOut.back();
+        if (curIn.r == lastAddedOut.r && curIn.cb <= lastAddedOut.ce + 1)
+            lastAddedOut.ce = max(curIn.ce, lastAddedOut.ce);
+        else
+            rlOut.push_back(curIn);
+    }
+}
+
+static void union_regions(rlVec& reg1, rlVec& reg2, rlVec& regUnion)
+{
+    rlVec lAllChords(reg1);
+
+    lAllChords.insert(lAllChords.end(), reg2.begin(), reg2.end());
+
+    sortChords(lAllChords);
+    mergeNeighbouringChords(lAllChords, regUnion);
+}
+
+static void intersect(rlVec& reg1, rlVec& reg2, rlVec& regRes)
+{
+    rlVec::iterator end1 = reg1.end();
+    rlVec::iterator end2 = reg2.end();
+
+    rlVec::iterator cur1 = reg1.begin();
+    rlVec::iterator cur2 = reg2.begin();
+    regRes.clear();
+
+    while (cur1 != end1 && cur2 != end2)
+    {
+        if (cur1->r < cur2->r || (cur1->r == cur2->r && cur1->ce < cur2->cb))
+            ++cur1;
+        else if (cur2->r < cur1->r || (cur1->r == cur2->r && cur2->ce < cur1->cb))
+            ++cur2;
+        else
+        {
+            assert(cur1->r == cur2->r);
+            int nStart = max(cur1->cb, cur2->cb);
+            int nEnd = min(cur1->ce, cur2->ce);
+            if (nStart > nEnd)
+            {
+                assert(nStart <= nEnd);
+            }
+            regRes.push_back(rlType(nStart, nEnd, cur1->r));
+            if (cur1->ce < cur2->ce)
+                ++cur1;
+            else
+                ++cur2;
+        }
+
+    }
+}
+
+static void addBoundary(rlVec& runsIn, int nWidth, int nHeight, int nBoundaryLeft, int nBoundaryTop,
+    int nBoundaryRight, int nBoundaryBottom, rlVec& res)
+{
+    rlVec boundary;
+    for (int i = -nBoundaryTop; i < 0; ++i)
+        boundary.push_back(rlType(-nBoundaryLeft, nWidth - 1 + nBoundaryRight, i));
+    for (int i = 0; i < nHeight; ++i)
+    {
+        boundary.push_back(rlType(-nBoundaryLeft, -1, i));
+        boundary.push_back(rlType(nWidth, nWidth - 1 + nBoundaryRight, i));
+    }
+
+    for (int i = nHeight; i < nHeight + nBoundaryBottom; ++i)
+        boundary.push_back(rlType(-nBoundaryLeft, nWidth - 1 + nBoundaryRight, i));
+
+    union_regions(runsIn, boundary, res);
+}
+
+static cv::Rect getBoundingRectangle(rlVec& reg)
+{
+    using namespace std;
+    cv::Rect rect;
+    if (reg.empty())
+    {
+        rect.x = rect.y = rect.width = rect.height = 0;
+        return rect;
+    }
+
+    int minX = std::numeric_limits<int>::max();
+    int minY = std::numeric_limits<int>::max();
+    int maxX = std::numeric_limits<int>::min();
+    int maxY = std::numeric_limits<int>::min();
+
+    int i;
+    for (i = 0; i<(int)reg.size(); i++)
+    {
+        minX = min(minX, reg[i].cb);
+        maxX = max(maxX, reg[i].ce);
+        minY = min(minY, reg[i].r);
+        maxY = max(maxY, reg[i].r);
+    }
+
+    rect.x = minX;
+    rect.y = minY;
+    rect.width = maxX - minX + 1;
+    rect.height = maxY - minY + 1;
+    return rect;
+}
+
+static void createUprightRectangle(cv::Rect rect, rlVec &rl)
+{
+    rl.clear();
+    rlType curRL;
+    int j;
+    int cb = rect.x;
+    int ce = rect.x + rect.width - 1;
+    for (j = 0; j < rect.height; j++)
+    {
+        curRL.cb = cb;
+        curRL.ce = ce;
+        curRL.r = j + rect.y;
+        rl.push_back(curRL);
+    }
+}
+
+static void erode_with_boundary_rle(rlVec& runsSource, int nWidth, int nHeight, rlVec& runsDestination,
+    rlVec& runsKernel)
+{
+    cv::Rect rect = getBoundingRectangle(runsKernel);
+    rlVec regExtended, regFrame, regResultRaw;
+    addBoundary(runsSource, nWidth, nHeight, max(0, -rect.x), max(0, -rect.y),
+        max(0, rect.x + rect.width), max(0, rect.y + rect.height), regExtended);
+
+    erode_rle(regExtended, regResultRaw, runsKernel);
+    createUprightRectangle(cv::Rect(0, 0, nWidth, nHeight), regFrame);
+    intersect(regResultRaw, regFrame, runsDestination);
+}
+
+
+CV_EXPORTS void erode(InputArray rlSrc, OutputArray rlDest, InputArray rlKernel, bool bBoundaryOn,
+    Point anchor)
+{
+  rlVec runsSource, runsDestination, runsKernel;
+  Size sizeSource, sizeKernel;
+  convertInputArrayToRuns(rlSrc, runsSource, sizeSource);
+  convertInputArrayToRuns(rlKernel, runsKernel, sizeKernel);
+
+  if (anchor != Point(0,0))
+    translateRegion(runsKernel, -anchor);
+
+  if (bBoundaryOn)
+      erode_with_boundary_rle(runsSource, sizeSource.width, sizeSource.height, runsDestination, runsKernel);
+  else
+      erode_rle(runsSource, runsDestination, runsKernel);
+  convertToOutputArray(runsDestination, sizeSource, rlDest);
+}
+
+
+static void subtract_rle( rlVec& regFrom,
+                        rlVec& regSubtract,
+                        rlVec& regRes)
+{
+    rlVec::iterator end1 = regFrom.end();
+    rlVec::iterator end2 = regSubtract.end();
+
+    rlVec::iterator cur1 = regFrom.begin();
+    rlVec::iterator cur2 = regSubtract.begin();
+    regRes.clear();
+
+    while( cur1 != end1)
+    {
+        if (cur2 == end2)
+        {
+            regRes.insert( regRes.end(), cur1, end1);
+            return;
+        }
+        else if ( cur1->r < cur2->r || (cur1->r == cur2->r && cur1->ce < cur2->cb))
+        {
+            regRes.push_back(*cur1);
+            ++cur1;
+        }
+        else if ( cur2->r < cur1->r || (cur1->r == cur2->r && cur2->ce < cur1->cb))
+            ++cur2;
+        else
+        {
+            int curR = cur1->r;
+            assert(curR == cur2->r);
+            rlVec::iterator lastIncluded;
+
+            bool bIncremented = false;
+            for (lastIncluded = cur2;
+                lastIncluded != end2 && lastIncluded->r == curR && lastIncluded->cb <= cur1->ce;
+                ++lastIncluded)
+            {
+                bIncremented = true;
+            }
+
+            if (bIncremented)
+                --lastIncluded;
+
+            // now all chords from cur2 to lastIncluded have an intersection with cur1
+            if (cur1->cb < cur2->cb)
+                regRes.push_back(rlType(cur1->cb, cur2->cb - 1, curR));
+
+            // we add the gaps between the chords of reg2 to the result
+            while (cur2 < lastIncluded)
+            {
+                regRes.push_back(rlType(cur2->ce + 1, (cur2 + 1)->cb - 1, curR));
+                if (regRes.back().cb > regRes.back().ce)
+                {
+                    assert(false);
+                }
+                ++cur2;
+            }
+
+            if (cur1->ce > lastIncluded->ce)
+            {
+                regRes.push_back(rlType(lastIncluded->ce + 1, cur1->ce, curR));
+                assert(regRes.back().cb <= regRes.back().ce);
+            }
+            ++cur1;
+        }
+
+    }
+}
+
+
+
+
+static void invertRegion(rlVec& runsIn, rlVec& runsOut)
+{
+    // if there is only one chord in row -> do not insert anything for this row
+    // otherwise insert chords for the spaces between chords
+    runsOut.clear();
+    int nCurRow = std::numeric_limits<int>::min();
+    int nLastRight = nCurRow;
+    for (rlVec::iterator it = runsIn.begin(); it != runsIn.end(); ++it)
+    {
+        rlType run = *it;
+        if (run.r != nCurRow)
+        {
+            nCurRow = run.r;
+            nLastRight = run.ce;
+        }
+        else
+        {
+            assert(run.cb > nLastRight + 1);
+            runsOut.push_back(rlType(nLastRight + 1, run.cb - 1, nCurRow));
+            nLastRight = run.ce;
+        }
+    }
+}
+
+
+static void dilate_rle(rlVec& runsSource,
+    rlVec& runsDestination,
+    rlVec& runsKernel)
+{
+    cv::Rect rectSource = getBoundingRectangle(runsSource);
+    cv::Rect rectKernel = getBoundingRectangle(runsKernel);
+
+    cv::Rect background;
+    background.x = rectSource.x - 2 * rectKernel.width;
+    background.y = rectSource.y - 2 * rectKernel.height;
+    background.width = rectSource.width + 4 * rectKernel.width;
+    background.height = rectSource.height + 4 * rectKernel.height;
+
+    rlVec rlBackground, rlSourceInverse, rlResultInverse;
+    createUprightRectangle(background, rlBackground);
+    subtract_rle(rlBackground, runsSource, rlSourceInverse);
+
+    erode_rle(rlSourceInverse, rlResultInverse, runsKernel);
+
+    invertRegion(rlResultInverse, runsDestination);
+}
+
+
+
+CV_EXPORTS void dilate(InputArray rlSrc, OutputArray rlDest, InputArray rlKernel, Point anchor)
+{
+  rlVec runsSource, runsDestination, runsKernel;
+  Size sizeSource, sizeKernel;
+  convertInputArrayToRuns(rlSrc, runsSource, sizeSource);
+  convertInputArrayToRuns(rlKernel, runsKernel, sizeKernel);
+
+  if (anchor != Point(0, 0))
+      translateRegion(runsKernel, -anchor);
+
+  dilate_rle(runsSource, runsDestination, runsKernel);
+
+  convertToOutputArray(runsDestination, sizeSource, rlDest);
+}
+
+CV_EXPORTS bool isRLMorphologyPossible(InputArray rlStructuringElement)
+{
+  rlVec runsKernel;
+  Size sizeKernel;
+  convertInputArrayToRuns(rlStructuringElement, runsKernel, sizeKernel);
+
+  for (int i = 1; i < (int) runsKernel.size(); ++i)
+    if (runsKernel[i].r != runsKernel[i-1].r + 1)
+      return false;
+
+  return true;
+}
+
+CV_EXPORTS void createRLEImage(const std::vector<cv::Point3i>& runs, OutputArray res, Size size)
+{
+    size_t nRuns = runs.size();
+    rlVec runsConverted(nRuns);
+    for (size_t i = 0u; i < nRuns; ++i)
+    {
+        const Point3i &curIn = runs[i];
+        runsConverted[i] = rlType(curIn.x, curIn.y, curIn.z);
+    }
+    sortChords(runsConverted);
+
+    if (size.width == 0 || size.height == 0)
+    {
+        Rect boundingRect = getBoundingRectangle(runsConverted);
+        size.width = std::max(0, boundingRect.x + boundingRect.width);
+        size.height = std::max(0, boundingRect.y + boundingRect.height);
+    }
+    convertToOutputArray(runsConverted, size, res);
+}
+
+
+CV_EXPORTS void morphologyEx(InputArray rlSrc, OutputArray rlDest, int op, InputArray rlKernel,
+    bool bBoundaryOnForErosion, Point anchor)
+{
+    if (op == MORPH_ERODE)
+        rl::erode(rlSrc, rlDest, rlKernel, bBoundaryOnForErosion, anchor);
+    else if (op == MORPH_DILATE)
+        rl::dilate(rlSrc, rlDest, rlKernel, anchor);
+    else
+    {
+        rlVec runsSource, runsKernel, runsDestination;
+        Size sizeSource, sizeKernel;
+        convertInputArrayToRuns(rlKernel, runsKernel, sizeKernel);
+        convertInputArrayToRuns(rlSrc, runsSource, sizeSource);
+
+        if (anchor != Point(0, 0))
+            translateRegion(runsKernel, -anchor);
+
+        switch (op)
+        {
+        case MORPH_OPEN:
+        {
+            rlVec runsEroded;
+
+            if (bBoundaryOnForErosion)
+                erode_with_boundary_rle(runsSource, sizeSource.width, sizeSource.height, runsEroded, runsKernel);
+            else
+                erode_rle(runsSource, runsEroded, runsKernel);
+            dilate_rle(runsEroded, runsDestination, runsKernel);
+        }
+        break;
+        case MORPH_CLOSE:
+        {
+            rlVec runsDilated;
+
+            dilate_rle(runsSource, runsDilated, runsKernel);
+            if (bBoundaryOnForErosion)
+                erode_with_boundary_rle(runsDilated, sizeSource.width, sizeSource.height, runsDestination, runsKernel);
+            else
+                erode_rle(runsDilated, runsDestination, runsKernel);
+        }
+        break;
+        case MORPH_GRADIENT:
+        {
+            rlVec runsEroded, runsDilated;
+            if (bBoundaryOnForErosion)
+                erode_with_boundary_rle(runsSource, sizeSource.width, sizeSource.height, runsEroded, runsKernel);
+            else
+                erode_rle(runsSource, runsEroded, runsKernel);
+            dilate_rle(runsSource, runsDilated, runsKernel);
+            subtract_rle(runsDilated, runsEroded, runsDestination);
+         }
+        break;
+        case MORPH_TOPHAT:
+        {
+            rlVec runsEroded, runsOpened;
+
+            if (bBoundaryOnForErosion)
+                erode_with_boundary_rle(runsSource, sizeSource.width, sizeSource.height, runsEroded, runsKernel);
+            else
+                erode_rle(runsSource, runsEroded, runsKernel);
+            dilate_rle(runsEroded, runsOpened, runsKernel);
+            subtract_rle(runsSource, runsOpened, runsDestination);
+        }
+        break;
+
+        case MORPH_BLACKHAT:
+        {
+            rlVec runsClosed, runsDilated;
+
+            dilate_rle(runsSource, runsDilated, runsKernel);
+            if (bBoundaryOnForErosion)
+                erode_with_boundary_rle(runsDilated, sizeSource.width, sizeSource.height, runsClosed, runsKernel);
+            else
+                erode_rle(runsDilated, runsClosed, runsKernel);
+
+            subtract_rle(runsClosed, runsSource, runsDestination);
+        }
+        break;
+        default:
+        case MORPH_HITMISS:
+            CV_Error(Error::StsBadArg, "unknown or unsupported morphological operation");
+        }
+        convertToOutputArray(runsDestination, sizeSource, rlDest);
+    }
+}
+
+}
+} //end of cv::ximgproc
+} //end of cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/scansegment.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/scansegment.cpp
new file mode 100644
index 00000000..037ea69e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/scansegment.cpp
@@ -0,0 +1,770 @@
+////////////////////////////////////////////////////////////////////////////////////////
+//
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Dr Seng Cheong Loke (lokesengcheong@gmail.com)
+//
+//
+
+#include "precomp.hpp"
+
+#include <numeric>
+#include <atomic>
+
+namespace cv {
+namespace ximgproc {
+
+ScanSegment::~ScanSegment()
+{
+    // nothing
+}
+
+class ScanSegmentImpl CV_FINAL : public ScanSegment
+{
+#define UNKNOWN 0
+#define BORDER -1
+#define UNCLASSIFIED -2
+#define NONE -3
+
+public:
+
+    ScanSegmentImpl(int image_width, int image_height, int num_superpixels, int slices, bool merge_small);
+
+    virtual ~ScanSegmentImpl();
+
+    virtual int getNumberOfSuperpixels() CV_OVERRIDE { return clusterCount; }
+
+    virtual void iterate(InputArray img) CV_OVERRIDE;
+
+    virtual void getLabels(OutputArray labels_out) CV_OVERRIDE;
+
+    virtual void getLabelContourMask(OutputArray image, bool thick_line = false) CV_OVERRIDE;
+
+private:
+    static const int neighbourCount = 8;    // number of pixel neighbours
+    static const int smallClustersDiv = 10000;  // divide total pixels by this to give smallClusters
+    const float tolerance100 = 10.0f;       // colour tolerance for image size of 100x100px
+
+    int processthreads;                     // concurrent threads for parallel processing
+    int width, height;                      // image size
+    int superpixels;                        // number of superpixels
+    bool merge;                             // merge small superpixels
+    int indexSize;                          // size of label mat vector
+    int clusterSize;                        // max size of clusters
+    int clusterCount;                       // number of superpixels from the most recent iterate
+    float adjTolerance;                     // adjusted colour tolerance
+
+    int horzDiv, vertDiv;                   // number of horizontal and vertical segments
+    float horzLength, vertLength;           // length of each segment
+    int effectivethreads;                   // effective number of concurrent threads
+    int smallClusters;                      // clusters below this pixel count are considered small for merging
+
+    cv::AutoBuffer<cv::Rect> seedRects;     // autobuffer of seed rectangles
+    cv::AutoBuffer<cv::Rect> seedRectsExt;  // autobuffer of extended seed rectangles
+    cv::AutoBuffer<cv::Rect> offsetRects;   // autobuffer of offset rectangles
+    cv::Point neighbourLoc[8] = { cv::Point(-1, -1), cv::Point(0, -1), cv::Point(1, -1), cv::Point(-1, 0), cv::Point(1, 0), cv::Point(-1, 1), cv::Point(0, 1), cv::Point(1, 1) };                // neighbour locations
+
+    std::vector<int> indexNeighbourVec;     // indices for parallel processing
+    std::vector<std::pair<int, int>> indexProcessVec;
+
+    cv::AutoBuffer<int> labelsBuffer;       // label autobuffer
+    cv::AutoBuffer<int> clusterBuffer;      // cluster autobuffer
+    cv::AutoBuffer<uchar> pixelBuffer;      // pixel autobuffer
+    std::vector<cv::AutoBuffer<int>> offsetVec; // vector of offset autobuffers
+    cv::Vec3b* labBuffer;                   // lab buffer
+    int neighbourLocBuffer[neighbourCount]; // neighbour locations
+
+    std::atomic<int> clusterIndex, clusterID;  // atomic indices
+
+    cv::Mat src, labelsMat;                 // mats
+
+    struct WSNode
+    {
+        int next;
+        int mask_ofs;
+        int img_ofs;
+    };
+
+    // Queue for WSNodes
+    struct WSQueue
+    {
+        WSQueue() { first = last = 0; }
+        int first, last;
+    };
+
+    void OP1(int v);
+    void OP2(std::pair<int, int> const& p);
+    void OP3(int v);
+    void OP4(std::pair<int, int> const& p);
+    void expandCluster(int* offsetBuffer, const cv::Point& point);
+    void calculateCluster(int* offsetBuffer, int* offsetEnd, int pointIndex, int currentClusterID);
+    static int allocWSNodes(std::vector<WSNode>& storage);
+    static void watershedEx(const cv::Mat& src, cv::Mat& dst);
+};
+
+CV_EXPORTS Ptr<ScanSegment> createScanSegment(int image_width, int image_height, int num_superpixels, int slices, bool merge_small)
+{
+    return makePtr<ScanSegmentImpl>(image_width, image_height, num_superpixels, slices, merge_small);
+}
+
+ScanSegmentImpl::ScanSegmentImpl(int image_width, int image_height, int num_superpixels, int slices, bool merge_small)
+{
+    // set the number of process threads
+    processthreads = (slices > 0) ? slices : cv::getNumThreads();
+
+    width = image_width;
+    height = image_height;
+    superpixels = num_superpixels;
+    merge = merge_small;
+    indexSize = height * width;
+    clusterSize = cvRound(1.1f * (float)(width * height) / (float)superpixels);
+    clusterCount = 0;
+    labelsMat = cv::Mat(height, width, CV_32SC1);
+
+    // divide bounds area into uniformly distributed rectangular segments
+    int shortCount = cvFloor(sqrtf((float)processthreads));
+    int longCount = processthreads / shortCount;
+    horzDiv = width > height ? longCount : shortCount;
+    vertDiv = width > height ? shortCount : longCount;
+    horzLength = (float)width / (float)horzDiv;
+    vertLength = (float)height / (float)vertDiv;
+    effectivethreads = horzDiv * vertDiv;
+    smallClusters = 0;
+
+    // get array of seed rects
+    seedRects = cv::AutoBuffer<cv::Rect>(horzDiv * vertDiv);
+    seedRectsExt = cv::AutoBuffer<cv::Rect>(horzDiv * vertDiv);
+    offsetRects = cv::AutoBuffer<cv::Rect>(horzDiv * vertDiv);
+    for (int y = 0; y < vertDiv; y++) {
+        for (int x = 0; x < horzDiv; x++) {
+            int xStart = cvFloor((float)x * horzLength);
+            int yStart = cvFloor((float)y * vertLength);
+            cv::Rect seedRect = cv::Rect(xStart, yStart, (int)(x == horzDiv - 1 ? width - xStart : horzLength), (int)(y == vertDiv - 1 ? height - yStart : vertLength));
+
+            int bnd_l = seedRect.x;
+            int bnd_t = seedRect.y;
+            int bnd_r = seedRect.x + seedRect.width - 1;
+            int bnd_b = seedRect.y + seedRect.height - 1;
+            if (bnd_l > 0) {
+                bnd_l -= 1;
+            }
+            if (bnd_t > 0) {
+                bnd_t -= 1;
+            }
+            if (bnd_r < width - 1) {
+                bnd_r += 1;
+            }
+            if (bnd_b < height - 1) {
+                bnd_b += 1;
+            }
+
+            seedRects.data()[(y * horzDiv) + x] = seedRect;
+            seedRectsExt.data()[(y * horzDiv) + x] = cv::Rect(bnd_l, bnd_t, bnd_r - bnd_l + 1, bnd_b - bnd_t + 1);
+            offsetRects.data()[(y * horzDiv) + x] = cv::Rect(seedRect.x - bnd_l, seedRect.y - bnd_t, seedRect.width, seedRect.height);
+        }
+    }
+
+    // get adjusted tolerance = (100 / average length (horz/vert)) x sqrt(3) [ie. euclidean lab colour distance sqrt(l2 + a2 + b2)] x tolerance100
+    adjTolerance = (200.0f / (width + height)) * sqrtf(3) * tolerance100;
+    adjTolerance = adjTolerance * adjTolerance;
+
+    // create neighbour vector
+    indexNeighbourVec = std::vector<int>(effectivethreads);
+    std::iota(indexNeighbourVec.begin(), indexNeighbourVec.end(), 0);
+
+    // create process vector
+    indexProcessVec = std::vector<std::pair<int, int>>(processthreads);
+    int processDiv = indexSize / processthreads;
+    int processCurrent = 0;
+    for (int i = 0; i < processthreads - 1; i++) {
+        indexProcessVec[i] = std::make_pair(processCurrent, processCurrent + processDiv);
+        processCurrent += processDiv;
+    }
+    indexProcessVec[processthreads - 1] = std::make_pair(processCurrent, indexSize);
+
+    // create buffers and initialise
+    labelsBuffer = cv::AutoBuffer<int>(indexSize);
+    clusterBuffer = cv::AutoBuffer<int>(indexSize);
+    pixelBuffer = cv::AutoBuffer<uchar>(indexSize);
+    offsetVec = std::vector<cv::AutoBuffer<int>>(effectivethreads);
+    int offsetSize = (clusterSize + 1) * sizeof(int);
+    for (int i = 0; i < effectivethreads; i++) {
+        offsetVec[i] = cv::AutoBuffer<int>(offsetSize);
+    }
+    for (int i = 0; i < neighbourCount; i++) {
+        neighbourLocBuffer[i] = (neighbourLoc[i].y * width) + neighbourLoc[i].x;
+    }
+}
+
+ScanSegmentImpl::~ScanSegmentImpl()
+{
+    // clean up
+    if (!src.empty()) {
+        src.release();
+    }
+    if (!labelsMat.empty()) {
+        labelsMat.release();
+    }
+}
+
+void ScanSegmentImpl::iterate(InputArray img)
+{
+    if (img.isMat())
+    {
+        // get Mat
+        src = img.getMat();
+
+        // image should be valid
+        CV_Assert(!src.empty());
+    }
+    else if (img.isMatVector())
+    {
+        std::vector<cv::Mat> vec;
+
+        // get vector Mat
+        img.getMatVector(vec);
+
+        // array should be valid
+        CV_Assert(!vec.empty());
+
+        // merge into Mat
+        cv::merge(vec, src);
+    }
+    else
+        CV_Error(Error::StsInternal, "Invalid InputArray.");
+
+    int depth = src.depth();
+
+    CV_Assert(src.size().width == width && src.size().height == height);
+    CV_Assert(depth == CV_8U);
+    CV_Assert(src.channels() == 3);
+
+    clusterCount = 0;
+    clusterIndex.store(0);
+    clusterID.store(1);
+
+    smallClusters = indexSize / smallClustersDiv;
+
+    // set labels to NONE
+    labelsMat.setTo(NONE);
+
+    // set labels buffer to UNCLASSIFIED
+    std::fill(labelsBuffer.data(), labelsBuffer.data() + indexSize, UNCLASSIFIED);
+
+    // apply light blur
+    cv::medianBlur(src, src, 3);
+
+    // start at the center of the rect, then run through the remainder
+    labBuffer = reinterpret_cast<cv::Vec3b*>(src.data);
+    cv::parallel_for_(Range(0, (int)indexNeighbourVec.size()), [&](const Range& range) {
+        for (int i = range.start; i < range.end; i++) {
+            OP1(i);
+        }
+    });
+
+    if (merge) {
+        // get cutoff size for clusters
+        std::vector<std::pair<int, int>> countVec;
+        int clusterIndexSize = clusterIndex.load();
+        countVec.reserve(clusterIndexSize / 2);
+        for (int i = 1; i < clusterIndexSize; i += 2) {
+            int count = clusterBuffer.data()[i];
+            if (count >= smallClusters) {
+                int currentID = clusterBuffer.data()[i - 1];
+                countVec.push_back(std::make_pair(currentID, count));
+            }
+        }
+
+        // sort descending
+        std::sort(countVec.begin(), countVec.end(), [](const std::pair<int, int>& left, const std::pair<int, int>& right) {
+            return left.second > right.second;
+        });
+
+        int countSize = (int)countVec.size();
+        int cutoff = MAX(smallClusters, countVec[MIN(countSize - 1, superpixels - 1)].second);
+        clusterCount = (int)std::count_if(countVec.begin(), countVec.end(), [&cutoff](std::pair<int, int> p) {return p.second > cutoff; });
+
+        // change labels to 1 -> clusterCount, 0 = UNKNOWN, reuse clusterbuffer
+        std::fill_n(clusterBuffer.data(), indexSize, UNKNOWN);
+        int countLimit = cutoff == -1 ? (int)countVec.size() : clusterCount;
+        for (int i = 0; i < countLimit; i++) {
+            clusterBuffer.data()[countVec[i].first] = i + 1;
+        }
+
+        parallel_for_(Range(0, (int)indexProcessVec.size()), [&](const Range& range) {
+            for (int i = range.start; i < range.end; i++) {
+                OP2(indexProcessVec[i]);
+            }
+        });
+
+        // make copy of labels buffer
+        memcpy(labelsMat.data, labelsBuffer.data(), indexSize * sizeof(int));
+
+        // run watershed
+        cv::parallel_for_(Range(0, (int)indexNeighbourVec.size()), [&](const Range& range) {
+            for (int i = range.start; i < range.end; i++) {
+                OP3(i);
+            }
+        });
+
+        // copy back to labels mat
+        parallel_for_(Range(0, (int)indexProcessVec.size()), [&](const Range& range) {
+            for (int i = range.start; i < range.end; i++) {
+                OP4(indexProcessVec[i]);
+            }
+        });
+    }
+    else
+    {
+        memcpy(labelsMat.data, labelsBuffer.data(), indexSize * sizeof(int));
+    }
+
+    src.release();
+}
+
+void ScanSegmentImpl::OP1(int v)
+{
+    cv::Rect seedRect = seedRects.data()[v];
+    for (int y = seedRect.y; y < seedRect.y + seedRect.height; y++) {
+        for (int x = seedRect.x; x < seedRect.x + seedRect.width; x++) {
+            expandCluster(offsetVec[v].data(), cv::Point(x, y));
+        }
+    }
+}
+
+void ScanSegmentImpl::OP2(std::pair<int, int> const& p)
+{
+    for (int i = p.first; i < p.second; i++) {
+        labelsBuffer.data()[i] = clusterBuffer.data()[labelsBuffer.data()[i]];
+        if (labelsBuffer.data()[i] == UNKNOWN) {
+            pixelBuffer.data()[i] = 255;
+        }
+        else {
+            pixelBuffer.data()[i] = 0;
+        }
+    }
+}
+
+void ScanSegmentImpl::OP3(int v)
+{
+    cv::Rect seedRectExt = seedRectsExt.data()[v];
+    cv::Mat seedLabels = labelsMat(seedRectExt).clone();
+    watershedEx(src(seedRectExt), seedLabels);
+    seedLabels(offsetRects.data()[v]).copyTo(labelsMat(seedRects.data()[v]));
+    seedLabels.release();
+}
+
+void ScanSegmentImpl::OP4(std::pair<int, int> const& p)
+{
+    for (int i = p.first; i < p.second; i++) {
+        if (pixelBuffer.data()[i] == 0) {
+            ((int*)labelsMat.data)[i] = labelsBuffer.data()[i] - 1;
+        }
+        else {
+            ((int*)labelsMat.data)[i] -= 1;
+        }
+    }
+}
+
+// expand clusters from a point
+void ScanSegmentImpl::expandCluster(int* offsetBuffer, const cv::Point& point)
+{
+    int pointIndex = (point.y * width) + point.x;
+    if (labelsBuffer.data()[pointIndex] == UNCLASSIFIED) {
+        int offsetStart = 0;
+        int offsetEnd = 0;
+        int currentClusterID = clusterID.fetch_add(1);
+
+        calculateCluster(offsetBuffer, &offsetEnd, pointIndex, currentClusterID);
+
+        if (offsetStart == offsetEnd) {
+            labelsBuffer.data()[pointIndex] = UNKNOWN;
+        }
+        else {
+            // set cluster id and get core point index
+            labelsBuffer.data()[pointIndex] = currentClusterID;
+
+            while (offsetStart < offsetEnd) {
+                int intoffset2 = *(offsetBuffer + offsetStart);
+                offsetStart++;
+                calculateCluster(offsetBuffer, &offsetEnd, intoffset2, currentClusterID);
+            }
+
+            // add origin point
+            offsetBuffer[offsetEnd] = pointIndex;
+            offsetEnd++;
+
+            // store to buffer
+            int currentClusterIndex = clusterIndex.fetch_add(2);
+            clusterBuffer.data()[currentClusterIndex] = currentClusterID;
+            clusterBuffer.data()[currentClusterIndex + 1] = offsetEnd;
+        }
+    }
+}
+
+void ScanSegmentImpl::calculateCluster(int* offsetBuffer, int* offsetEnd, int pointIndex, int currentClusterID)
+{
+    for (int i = 0; i < neighbourCount; i++) {
+        if (*offsetEnd < clusterSize) {
+            int intoffset2 = pointIndex + neighbourLocBuffer[i];
+            if (intoffset2 >= 0 && intoffset2 < indexSize && labelsBuffer.data()[intoffset2] == UNCLASSIFIED) {
+                int diff1 = (int)labBuffer[pointIndex][0] - (int)labBuffer[intoffset2][0];
+                int diff2 = (int)labBuffer[pointIndex][1] - (int)labBuffer[intoffset2][1];
+                int diff3 = (int)labBuffer[pointIndex][2] - (int)labBuffer[intoffset2][2];
+
+                if ((diff1 * diff1) + (diff2 * diff2) + (diff3 * diff3) <= (int)adjTolerance) {
+                    labelsBuffer.data()[intoffset2] = currentClusterID;
+                    offsetBuffer[*offsetEnd] = intoffset2;
+                    (*offsetEnd)++;
+                }
+            }
+        }
+        else { break; }
+    }
+}
+
+int ScanSegmentImpl::allocWSNodes(std::vector<ScanSegmentImpl::WSNode>& storage)
+{
+    int sz = (int)storage.size();
+    int newsz = MAX(128, sz * 3 / 2);
+
+    storage.resize(newsz);
+    if (sz == 0)
+    {
+        storage[0].next = 0;
+        sz = 1;
+    }
+    for (int i = sz; i < newsz - 1; i++)
+        storage[i].next = i + 1;
+    storage[newsz - 1].next = 0;
+    return sz;
+}
+
+//the modified version of watershed algorithm from OpenCV
+void ScanSegmentImpl::watershedEx(const cv::Mat& src, cv::Mat& dst)
+{
+    // https://github.com/Seaball/watershed_with_mask
+
+    // Labels for pixels
+    const int IN_QUEUE = -2; // Pixel visited
+    // possible bit values = 2^8
+    const int NQ = 256;
+
+    cv::Size size = src.size();
+    int channel = 3;
+    // Vector of every created node
+    std::vector<WSNode> storage;
+    int free_node = 0, node;
+    // Priority queue of queues of nodes
+    // from high priority (0) to low priority (255)
+    WSQueue q[NQ];
+    // Non-empty queue with highest priority
+    int active_queue;
+    int i, j;
+    // Color differences
+    int db, dg, dr;
+    int subs_tab[513];
+
+    // MAX(a,b) = b + MAX(a-b,0)
+#define ws_max(a,b) ((b) + subs_tab[(a)-(b)+NQ])
+// MIN(a,b) = a - MAX(a-b,0)
+#define ws_min(a,b) ((a) - subs_tab[(a)-(b)+NQ])
+
+    // Create a new node with offsets mofs and iofs in queue idx
+#define ws_push(idx,mofs,iofs)          \
+{                                       \
+    if (!free_node)                     \
+        free_node = allocWSNodes(storage); \
+    node = free_node;                   \
+    free_node = storage[free_node].next; \
+    storage[node].next = 0;             \
+    storage[node].mask_ofs = mofs;      \
+    storage[node].img_ofs = iofs;       \
+    if (q[idx].last)                   \
+        storage[q[idx].last].next = node; \
+    else                                \
+        q[idx].first = node;            \
+    q[idx].last = node;                 \
+}
+
+    // Get next node from queue idx
+#define ws_pop(idx,mofs,iofs)           \
+{                                       \
+    node = q[idx].first;                \
+    q[idx].first = storage[node].next;  \
+    if (!storage[node].next)           \
+        q[idx].last = 0;                \
+    storage[node].next = free_node;     \
+    free_node = node;                   \
+    mofs = storage[node].mask_ofs;      \
+    iofs = storage[node].img_ofs;       \
+}
+
+// Get highest absolute channel difference in diff
+#define c_diff(ptr1,ptr2,diff)           \
+{                                        \
+    db = std::abs((ptr1)[0] - (ptr2)[0]); \
+    dg = std::abs((ptr1)[1] - (ptr2)[1]); \
+    dr = std::abs((ptr1)[2] - (ptr2)[2]); \
+    diff = ws_max(db, dg);                \
+    diff = ws_max(diff, dr);              \
+    CV_Assert(0 <= diff && diff <= 255);  \
+}
+
+    CV_Assert(src.type() == CV_8UC3 && dst.type() == CV_32SC1);
+    CV_Assert(src.size() == dst.size());
+
+    // Current pixel in input image
+    const uchar* img = src.ptr();
+    // Step size to next row in input image
+    int istep = int(src.step / sizeof(img[0]));
+
+    // Current pixel in mask image
+    int* mask = dst.ptr<int>();
+    // Step size to next row in mask image
+    int mstep = int(dst.step / sizeof(mask[0]));
+
+    for (i = 0; i < 256; i++)
+        subs_tab[i] = 0;
+    for (i = 256; i <= 512; i++)
+        subs_tab[i] = i - 256;
+
+    //for (j = 0; j < size.width; j++)
+    //mask[j] = mask[j + mstep*(size.height - 1)] = 0;
+
+    // initial phase: put all the neighbor pixels of each marker to the ordered queue -
+    // determine the initial boundaries of the basins
+    for (i = 1; i < size.height - 1; i++) {
+        img += istep; mask += mstep;
+        mask[0] = mask[size.width - 1] = 0; // boundary pixels
+
+        for (j = 1; j < size.width - 1; j++) {
+            int* m = mask + j;
+            if (m[0] < 0)
+                m[0] = 0;
+            if (m[0] == 0 && (m[-1] > 0 || m[1] > 0 || m[-mstep] > 0 || m[mstep] > 0))
+            {
+                // Find smallest difference to adjacent markers
+                const uchar* ptr = img + j * channel;
+                int idx = 256, t;
+                if (m[-1] > 0) {
+                    c_diff(ptr, ptr - channel, idx);
+                }
+                if (m[1] > 0) {
+                    c_diff(ptr, ptr + channel, t);
+                    idx = ws_min(idx, t);
+                }
+                if (m[-mstep] > 0) {
+                    c_diff(ptr, ptr - istep, t);
+                    idx = ws_min(idx, t);
+                }
+                if (m[mstep] > 0) {
+                    c_diff(ptr, ptr + istep, t);
+                    idx = ws_min(idx, t);
+                }
+
+                // Add to according queue
+                CV_Assert(0 <= idx && idx <= 255);
+                ws_push(idx, i * mstep + j, i * istep + j * channel);
+                m[0] = IN_QUEUE;//initial unvisited
+            }
+        }
+    }
+    // find the first non-empty queue
+    for (i = 0; i < NQ; i++)
+        if (q[i].first)
+            break;
+
+    // if there is no markers, exit immediately
+    if (i == NQ)
+        return;
+
+    active_queue = i;//first non-empty priority queue
+    img = src.ptr();
+    mask = dst.ptr<int>();
+
+    // recursively fill the basins
+    int diff = 0, temp = 0;
+    for (;;)
+    {
+        int mofs, iofs;
+        int lab = 0, t;
+        int* m;
+        const uchar* ptr;
+
+        // Get non-empty queue with highest priority
+        // Exit condition: empty priority queue
+        if (q[active_queue].first == 0)
+        {
+            for (i = active_queue + 1; i < NQ; i++)
+                if (q[i].first)
+                    break;
+            if (i == NQ)
+            {
+                std::vector<WSNode>().swap(storage);
+                break;
+            }
+            active_queue = i;
+        }
+
+        // Get next node
+        ws_pop(active_queue, mofs, iofs);
+        int top = 1, bottom = 1, left = 1, right = 1;
+        if (0 <= mofs && mofs < mstep)//pixel on the top
+            top = 0;
+        if ((mofs % mstep) == 0)//pixel in the left column
+            left = 0;
+        if ((mofs + 1) % mstep == 0)//pixel in the right column
+            right = 0;
+        if (mstep * (size.height - 1) <= mofs && mofs < mstep * size.height)//pixel on the bottom
+            bottom = 0;
+
+        // Calculate pointer to current pixel in input and marker image
+        m = mask + mofs;
+        ptr = img + iofs;
+        // Check surrounding pixels for labels to determine label for current pixel
+        if (left) {//the left point can be visited
+            t = m[-1];
+            if (t > 0) {
+                lab = t;
+                c_diff(ptr, ptr - channel, diff);
+            }
+        }
+        if (right) {// Right point can be visited
+            t = m[1];
+            if (t > 0) {
+                if (lab == 0) {//and this point didn't be labeled before
+                    lab = t;
+                    c_diff(ptr, ptr + channel, diff);
+                }
+                else if (t != lab) {
+                    c_diff(ptr, ptr + channel, temp);
+                    diff = ws_min(diff, temp);
+                    if (diff == temp)
+                        lab = t;
+                }
+            }
+        }
+        if (top) {
+            t = m[-mstep]; // Top
+            if (t > 0) {
+                if (lab == 0) {//and this point didn't be labeled before
+                    lab = t;
+                    c_diff(ptr, ptr - istep, diff);
+                }
+                else if (t != lab) {
+                    c_diff(ptr, ptr - istep, temp);
+                    diff = ws_min(diff, temp);
+                    if (diff == temp)
+                        lab = t;
+                }
+            }
+        }
+        if (bottom) {
+            t = m[mstep]; // Bottom
+            if (t > 0) {
+                if (lab == 0) {
+                    lab = t;
+                }
+                else if (t != lab) {
+                    c_diff(ptr, ptr + istep, temp);
+                    diff = ws_min(diff, temp);
+                    if (diff == temp)
+                        lab = t;
+                }
+            }
+        }
+        // Set label to current pixel in marker image
+        CV_Assert(lab != 0);//lab must be labeled with a nonzero number
+        m[0] = lab;
+
+        // Add adjacent, unlabeled pixels to corresponding queue
+        if (left) {
+            if (m[-1] == 0)//left pixel with marker 0
+            {
+                c_diff(ptr, ptr - channel, t);
+                ws_push(t, mofs - 1, iofs - channel);
+                active_queue = ws_min(active_queue, t);
+                m[-1] = IN_QUEUE;
+            }
+        }
+
+        if (right)
+        {
+            if (m[1] == 0)//right pixel with marker 0
+            {
+                c_diff(ptr, ptr + channel, t);
+                ws_push(t, mofs + 1, iofs + channel);
+                active_queue = ws_min(active_queue, t);
+                m[1] = IN_QUEUE;
+            }
+        }
+
+        if (top)
+        {
+            if (m[-mstep] == 0)//top pixel with marker 0
+            {
+                c_diff(ptr, ptr - istep, t);
+                ws_push(t, mofs - mstep, iofs - istep);
+                active_queue = ws_min(active_queue, t);
+                m[-mstep] = IN_QUEUE;
+            }
+        }
+
+        if (bottom) {
+            if (m[mstep] == 0)//down pixel with marker 0
+            {
+                c_diff(ptr, ptr + istep, t);
+                ws_push(t, mofs + mstep, iofs + istep);
+                active_queue = ws_min(active_queue, t);
+                m[mstep] = IN_QUEUE;
+            }
+        }
+    }
+}
+
+void ScanSegmentImpl::getLabels(OutputArray labels_out)
+{
+    labels_out.assign(labelsMat);
+}
+
+void ScanSegmentImpl::getLabelContourMask(OutputArray image, bool thick_line)
+{
+    image.create(height, width, CV_8UC1);
+    cv::Mat dst = image.getMat();
+    dst.setTo(cv::Scalar(0));
+
+    const int dx8[8] = { -1, -1, 0, 1, 1, 1, 0, -1 };
+    const int dy8[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
+
+    for (int j = 0; j < height; j++)
+    {
+        for (int k = 0; k < width; k++)
+        {
+            int neighbors = 0;
+            for (int i = 0; i < 8; i++)
+            {
+                int x = k + dx8[i];
+                int y = j + dy8[i];
+
+                if ((x >= 0 && x < width) && (y >= 0 && y < height))
+                {
+                    int index = y * width + x;
+                    int mainindex = j * width + k;
+                    if (((int*)labelsMat.data)[mainindex] != ((int*)labelsMat.data)[index])
+                    {
+                        if (thick_line || !*dst.ptr<uchar>(y, x))
+                            neighbors++;
+                    }
+                }
+            }
+            if (neighbors > 1)
+                *dst.ptr<uchar>(j, k) = (uchar)255;
+        }
+    }
+}
+
+} // namespace ximgproc
+} // namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/seeds.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/seeds.cpp
new file mode 100644
index 00000000..54fac992
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/seeds.cpp
@@ -0,0 +1,1247 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2014, Beat Kueng (beat-kueng@gmx.net), Lukas Vogel, Morten Lysgaard
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+/******************************************************************************\
+*                            SEEDS Superpixels                                *
+*  This code implements the superpixel method described in:                   *
+*  M. Van den Bergh, X. Boix, G. Roig, B. de Capitani and L. Van Gool,        *
+*  "SEEDS: Superpixels Extracted via Energy-Driven Sampling", ECCV 2012       *
+\******************************************************************************/
+
+#include <cmath>
+#include <algorithm>
+#include <vector>
+#include <cstdlib>
+using namespace std;
+
+
+
+//required confidence when double_step is used
+#define REQ_CONF 0.1f
+
+#define MINIMUM_NR_SUBLABELS 1
+
+
+// the type of the histogram and the T array
+typedef float HISTN;
+
+
+namespace cv {
+namespace ximgproc {
+
+class SuperpixelSEEDSImpl : public SuperpixelSEEDS
+{
+public:
+
+    SuperpixelSEEDSImpl(int image_width, int image_height, int image_channels,
+            int num_superpixels, int num_levels,  int prior = 2,
+           int histogram_bins = 5,  bool double_step = false);
+
+    virtual ~SuperpixelSEEDSImpl();
+
+    virtual int getNumberOfSuperpixels() CV_OVERRIDE { return nrLabels(seeds_top_level); }
+
+    virtual void iterate(InputArray img, int num_iterations = 4) CV_OVERRIDE;
+
+
+    virtual void getLabels(OutputArray labels_out) CV_OVERRIDE;
+    virtual void getLabelContourMask(OutputArray image, bool thick_line = false) CV_OVERRIDE;
+
+private:
+    /* initialization */
+    void initialize(int num_superpixels, int num_levels);
+    void initImage(InputArray img);
+    void assignLabels();
+    void computeHistograms(int until_level = -1);
+    template<typename _Tp>
+    inline void initImageBins(const Mat& img, int max_value);
+
+
+    /* pixel operations */
+    inline void update(int label_new, int image_idx, int label_old);
+    //image_idx = y*width+x
+    inline void addPixel(int level, int label, int image_idx);
+    inline void deletePixel(int level, int label, int image_idx);
+    inline bool probability(int image_idx, int label1, int label2, int prior1, int prior2);
+    inline int threebyfour(int x, int y, int label);
+    inline int fourbythree(int x, int y, int label);
+
+    inline void updateLabels();
+    // main loop for pixel updating
+    void updatePixels();
+
+
+    /* block operations */
+    void addBlock(int level, int label, int sublevel, int sublabel);
+    inline void addBlockToplevel(int label, int sublevel, int sublabel);
+    void deleteBlockToplevel(int label, int sublevel, int sublabel);
+
+    // intersection on label1A and intersection_delete on label1B
+    // returns intA - intB
+    float intersectConf(int level1, int label1A, int label1B, int level2, int label2);
+
+    //main loop for block updates
+    void updateBlocks(int level, float req_confidence = 0.0f);
+
+    /* go to next block level */
+    int goDownOneLevel();
+
+    //make sure a superpixel stays connected (h=horizontal,v=vertical, f=forward,b=backward)
+    inline bool checkSplit_hf(int a11, int a12, int a21, int a22, int a31, int a32);
+    inline bool checkSplit_hb(int a12, int a13, int a22, int a23, int a32, int a33);
+    inline bool checkSplit_vf(int a11, int a12, int a13, int a21, int a22, int a23);
+    inline bool checkSplit_vb(int a21, int a22, int a23, int a31, int a32, int a33);
+
+
+    //compute initial label for sublevels: level <= seeds_top_level
+    //this is an equally sized grid with size nr_h[level]*nr_w[level]
+    int computeLabel(int level, int x, int y) {
+        return std::min(y * nr_wh[2 * level + 1] / height, nr_wh[2 * level + 1] - 1) * nr_wh[2 * level]
+            + std::min(x * nr_wh[2 * level] / width, nr_wh[2 * level] - 1);
+    }
+    inline int nrLabels(int level) const {
+        return nr_wh[2 * level + 1] * nr_wh[2 * level];
+    }
+
+    int width, height; //image size
+    int nr_bins; //number of histogram bins per channel
+    int nr_channels; //number of image channels
+    bool forwardbackward;
+
+    int seeds_nr_levels;
+    int seeds_top_level; // == seeds_nr_levels-1 (const)
+    int seeds_current_level; //start with level seeds_top_level-1, then go down
+    bool seeds_double_step;
+    int seeds_prior;
+
+    // keep one labeling for each level
+    vector<int> nr_wh; // [2*level]/[2*level+1] number of labels in x-direction/y-direction
+
+    /* pre-initialized arrays. they are not modified afterwards */
+    int* labels_bottom; //labels of level==0
+    vector<int*> parent_pre_init;
+
+    unsigned int* image_bins; //[y*width + x] bin index (histogram) of each image pixel
+
+    vector<int*> parent; //[level][label] = corresponding label of block with level+1
+    int* labels; //output labels: labels of level==seeds_top_level
+    unsigned int* nr_partitions; //[label] how many partitions label has on toplevel
+
+    int histogram_size; //== pow(nr_bins, nr_channels)
+    int histogram_size_aligned;
+    vector<HISTN*> histogram; //[level][label * histogram_size_aligned + j]
+    vector<HISTN*> T; //[level][label] how many pixels with this label
+
+    /* OpenCV containers for our memory arrays. This makes sure memory is
+     * allocated & released properly */
+    Mat labels_mat;
+    Mat labels_bottom_mat;
+    Mat nr_partitions_mat;
+    Mat image_bins_mat;
+    vector<Mat> histogram_mat;
+    vector<Mat> T_mat;
+    vector<Mat> parent_mat;
+    vector<Mat> parent_pre_init_mat;
+};
+
+CV_EXPORTS Ptr<SuperpixelSEEDS> createSuperpixelSEEDS(int image_width, int image_height,
+        int image_channels, int num_superpixels, int num_levels, int prior, int histogram_bins,
+        bool double_step)
+{
+    return makePtr<SuperpixelSEEDSImpl>(image_width, image_height, image_channels,
+            num_superpixels, num_levels, prior, histogram_bins, double_step);
+}
+
+SuperpixelSEEDSImpl::SuperpixelSEEDSImpl(int image_width, int image_height, int image_channels,
+            int num_superpixels, int num_levels, int prior, int histogram_bins, bool double_step)
+{
+    width = image_width;
+    height = image_height;
+    nr_bins = histogram_bins;
+    nr_channels = image_channels;
+    seeds_double_step = double_step;
+    seeds_prior = std::min(prior, 5);
+
+    histogram_size = nr_bins;
+    for (int i = 1; i < nr_channels; ++i)
+        histogram_size *= nr_bins;
+    histogram_size_aligned = (histogram_size
+        + ((CV_MALLOC_ALIGN / sizeof(HISTN)) - 1)) & -static_cast<int>(CV_MALLOC_ALIGN / sizeof(HISTN));
+
+    initialize(num_superpixels, num_levels);
+}
+
+SuperpixelSEEDSImpl::~SuperpixelSEEDSImpl()
+{
+}
+
+
+void SuperpixelSEEDSImpl::iterate(InputArray img, int num_iterations)
+{
+    initImage(img);
+
+    // block updates
+    while (seeds_current_level >= 0)
+    {
+        if( seeds_double_step )
+            updateBlocks(seeds_current_level, REQ_CONF);
+
+        updateBlocks(seeds_current_level);
+        seeds_current_level = goDownOneLevel();
+    }
+    updateLabels();
+
+    for (int i = 0; i < num_iterations; ++i)
+        updatePixels();
+}
+void SuperpixelSEEDSImpl::getLabels(OutputArray labels_out)
+{
+    labels_out.assign(labels_mat);
+}
+
+void SuperpixelSEEDSImpl::initialize(int num_superpixels, int num_levels)
+{
+    /* enforce parameter restrictions */
+    if( num_superpixels < 10 )
+        num_superpixels = 10;
+    if( num_levels < 2 )
+        num_levels = 2;
+    int num_superpixels_h = (int)sqrtf((float)num_superpixels * height / width);
+    int num_superpixels_w = num_superpixels_h * width / height;
+    seeds_nr_levels = num_levels + 1;
+    float seeds_wf, seeds_hf;
+    do
+    {
+        --seeds_nr_levels;
+        seeds_wf = (float)width / num_superpixels_w / (1<<(seeds_nr_levels-1));
+        seeds_hf = (float)height / num_superpixels_h / (1<<(seeds_nr_levels-1));
+    } while( seeds_wf < 1.f || seeds_hf < 1.f );
+    int seeds_w = (int)ceil(seeds_wf);
+    int seeds_h = (int)ceil(seeds_hf);
+    CV_Assert(seeds_nr_levels > 0);
+
+    seeds_top_level = seeds_nr_levels - 1;
+    image_bins_mat = Mat(height, width, CV_32SC1);
+    image_bins = (unsigned int*)image_bins_mat.data;
+
+    // init labels
+    labels_mat = Mat(height, width, CV_32SC1);
+    labels = (int*)labels_mat.data;
+    labels_bottom_mat = Mat(height, width, CV_32SC1);
+    labels_bottom = (int*)labels_bottom_mat.data;
+    parent.resize(seeds_nr_levels);
+    parent_pre_init.resize(seeds_nr_levels);
+    nr_wh.resize(2 * seeds_nr_levels);
+    int level = 0;
+    int nr_seeds_w = (width / seeds_w);
+    int nr_seeds_h = (height / seeds_h);
+    nr_wh[2 * level] = nr_seeds_w;
+    nr_wh[2 * level + 1] = nr_seeds_h;
+    parent_mat.push_back(Mat(nr_seeds_h, nr_seeds_w, CV_32SC1));
+    parent[level] = (int*)parent_mat.back().data;
+    parent_pre_init_mat.push_back(Mat(nr_seeds_h, nr_seeds_w, CV_32SC1));
+    parent_pre_init[level] = (int*)parent_pre_init_mat.back().data;
+    for (level = 1; level < seeds_nr_levels; level++)
+    {
+        nr_seeds_w /= 2; // always partitioned in 2x2 sub-blocks
+        nr_seeds_h /= 2;
+        parent_mat.push_back(Mat(nr_seeds_h, nr_seeds_w, CV_32SC1));
+        parent[level] = (int*)parent_mat.back().data;
+        parent_pre_init_mat.push_back(Mat(nr_seeds_h, nr_seeds_w, CV_32SC1));
+        parent_pre_init[level] = (int*)parent_pre_init_mat.back().data;
+        nr_wh[2 * level] = nr_seeds_w;
+        nr_wh[2 * level + 1] = nr_seeds_h;
+
+        for (int y = 0; y < height; y++)
+        {
+            for (int x = 0; x < width; x++)
+            {
+                parent_pre_init[level - 1][computeLabel(level - 1, x, y)] =
+                        computeLabel(level, x, y); // set parent
+            }
+        }
+    }
+    nr_partitions_mat = Mat(nr_wh[2 * seeds_top_level + 1],
+            nr_wh[2 * seeds_top_level], CV_32SC1);
+    nr_partitions = (unsigned int*)nr_partitions_mat.data;
+
+    //preinit the labels (these are not changed anymore later)
+    int i = 0;
+    for (int y = 0; y < height; ++y)
+    {
+        for (int x = 0; x < width; ++x)
+        {
+            labels_bottom[i] = computeLabel(0, x, y);
+            ++i;
+        }
+    }
+
+    // create histogram buffers
+    histogram.resize(seeds_nr_levels);
+    T.resize(seeds_nr_levels);
+    histogram_mat.resize(seeds_nr_levels);
+    T_mat.resize(seeds_nr_levels);
+    for (level = 0; level < seeds_nr_levels; level++)
+    {
+        histogram_mat[level] = Mat(nr_wh[2 * level + 1],
+                nr_wh[2 * level]*histogram_size_aligned, CV_32FC1);
+        histogram[level] = (HISTN*)histogram_mat[level].data;
+        T_mat[level] = Mat(nr_wh[2 * level + 1], nr_wh[2 * level], CV_32FC1);
+        T[level] = (HISTN*)T_mat[level].data;
+    }
+}
+
+
+template<typename _Tp>
+void SuperpixelSEEDSImpl::initImageBins(const Mat& img, int max_value)
+{
+    int img_width = img.size().width;
+    int img_height = img.size().height;
+    int channels = img.channels();
+
+    for (int y = 0; y < img_height; ++y)
+    {
+        for (int x = 0; x < img_width; ++x)
+        {
+            const _Tp* ptr = img.ptr<_Tp>(y, x);
+            int bin = 0;
+            for (int i = 0; i < channels; ++i)
+                bin = bin * nr_bins + (int) ptr[i] * nr_bins / max_value;
+            image_bins[y * img_width + x] = bin;
+        }
+    }
+}
+
+/* specialization for float: max_value is assumed to be 1.0f */
+template<>
+void SuperpixelSEEDSImpl::initImageBins<float>(const Mat& img, int)
+{
+    int img_width = img.size().width;
+    int img_height = img.size().height;
+    int channels = img.channels();
+
+    for (int y = 0; y < img_height; ++y)
+    {
+        for (int x = 0; x < img_width; ++x)
+        {
+            const float* ptr = img.ptr<float>(y, x);
+            int bin = 0;
+            for(int i=0; i<channels; ++i)
+                bin = bin * nr_bins + std::min((int)(ptr[i] * (float)nr_bins), nr_bins-1);
+            image_bins[y*img_width + x] = bin;
+        }
+    }
+}
+
+void SuperpixelSEEDSImpl::initImage(InputArray img)
+{
+    Mat src;
+
+    if ( img.isMat() )
+    {
+      // get Mat
+      src = img.getMat();
+
+      // image should be valid
+      CV_Assert( !src.empty() );
+    }
+    else if ( img.isMatVector() )
+    {
+      vector<Mat> vec;
+      // get vector Mat
+      img.getMatVector( vec );
+
+      // array should be valid
+      CV_Assert( !vec.empty() );
+
+      // merge into Mat
+      merge( vec, src );
+    }
+    else
+      CV_Error( Error::StsInternal, "Invalid InputArray." );
+
+    int depth = src.depth();
+    seeds_current_level = seeds_nr_levels - 2;
+    forwardbackward = true;
+
+    assignLabels();
+
+    CV_Assert(src.size().width == width && src.size().height == height);
+    CV_Assert(depth == CV_8U || depth == CV_16U || depth == CV_32F);
+    CV_Assert(src.channels() == nr_channels);
+
+    // initialize the histogram bins from the image
+    switch (depth)
+    {
+    case CV_8U:
+        initImageBins<uchar>(src, 1 << 8);
+        break;
+    case CV_16U:
+        initImageBins<ushort>(src, 1 << 16);
+        break;
+    case CV_32F:
+        initImageBins<float>(src, 1);
+        break;
+    }
+
+    computeHistograms();
+}
+
+// adds labeling to all the blocks at all levels and sets the correct parents
+void SuperpixelSEEDSImpl::assignLabels()
+{
+    /* each top level label is partitioned into 4 elements */
+    int nr_labels_toplevel = nrLabels(seeds_top_level);
+    for (int i = 0; i < nr_labels_toplevel; ++i)
+        nr_partitions[i] = 4;
+
+    for (int level = 1; level < seeds_nr_levels; level++)
+    {
+        memcpy(parent[level - 1], parent_pre_init[level - 1],
+                sizeof(int) * nrLabels(level - 1));
+    }
+}
+
+void SuperpixelSEEDSImpl::computeHistograms(int until_level)
+{
+    if( until_level == -1 )
+        until_level = seeds_nr_levels - 1;
+    until_level++;
+
+    // clear histograms
+    for (int level = 0; level < seeds_nr_levels; level++)
+    {
+        int nr_labels = nrLabels(level);
+        memset(histogram[level], 0,
+                sizeof(HISTN) * histogram_size_aligned * nr_labels);
+        memset(T[level], 0, sizeof(HISTN) * nr_labels);
+    }
+
+    // build histograms on the first level by adding the pixels to the blocks
+    for (int i = 0; i < width * height; ++i)
+        addPixel(0, labels_bottom[i], i);
+
+    // build histograms on the upper levels by adding the histogram from the level below
+    for (int level = 1; level < until_level; level++)
+    {
+        for (int label = 0; label < nrLabels(level - 1); label++)
+        {
+            addBlock(level, parent[level - 1][label], level - 1, label);
+        }
+    }
+}
+
+void SuperpixelSEEDSImpl::updateBlocks(int level, float req_confidence)
+{
+    int labelA;
+    int labelB;
+    int sublabel;
+    bool done;
+    int step = nr_wh[2 * level];
+
+    // horizontal bidirectional block updating
+    for (int y = 1; y < nr_wh[2 * level + 1] - 1; y++)
+    {
+        for (int x = 1; x < nr_wh[2 * level] - 2; x++)
+        {
+            // choose a label at the current level
+            sublabel = y * step + x;
+            // get the label at the top level (= superpixel label)
+            labelA = parent[level][y * step + x];
+            // get the neighboring label at the top level (= superpixel label)
+            labelB = parent[level][y * step + x + 1];
+
+            if( labelA == labelB )
+                continue;
+
+            // get the surrounding labels at the top level, to check for splitting
+            int a11 = parent[level][(y - 1) * step + (x - 1)];
+            int a12 = parent[level][(y - 1) * step + (x)];
+            int a21 = parent[level][(y) * step + (x - 1)];
+            int a22 = parent[level][(y) * step + (x)];
+            int a31 = parent[level][(y + 1) * step + (x - 1)];
+            int a32 = parent[level][(y + 1) * step + (x)];
+            done = false;
+
+            if( nr_partitions[labelA] == 2 || (nr_partitions[labelA] > 2 // 3 or more partitions
+                    && checkSplit_hf(a11, a12, a21, a22, a31, a32)) )
+            {
+                // run algorithm as usual
+                float conf = intersectConf(seeds_top_level, labelB, labelA, level, sublabel);
+                if( conf > req_confidence )
+                {
+                    deleteBlockToplevel(labelA, level, sublabel);
+                    addBlockToplevel(labelB, level, sublabel);
+                    done = true;
+                }
+            }
+
+            if( !done && (nr_partitions[labelB] > MINIMUM_NR_SUBLABELS) )
+            {
+                // try opposite direction
+                sublabel = y * step + x + 1;
+                int a13 = parent[level][(y - 1) * step + (x + 1)];
+                int a14 = parent[level][(y - 1) * step + (x + 2)];
+                int a23 = parent[level][(y) * step + (x + 1)];
+                int a24 = parent[level][(y) * step + (x + 2)];
+                int a33 = parent[level][(y + 1) * step + (x + 1)];
+                int a34 = parent[level][(y + 1) * step + (x + 2)];
+                if( nr_partitions[labelB] <= 2 // == 2
+                        || (nr_partitions[labelB] > 2 && checkSplit_hb(a13, a14, a23, a24, a33, a34)) )
+                {
+                    // run algorithm as usual
+                    float conf = intersectConf(seeds_top_level, labelA, labelB, level, sublabel);
+                    if( conf > req_confidence )
+                    {
+                        deleteBlockToplevel(labelB, level, sublabel);
+                        addBlockToplevel(labelA, level, sublabel);
+                        x++;
+                    }
+                }
+            }
+        }
+    }
+
+    // vertical bidirectional
+    for (int x = 1; x < nr_wh[2 * level] - 1; x++)
+    {
+        for (int y = 1; y < nr_wh[2 * level + 1] - 2; y++)
+        {
+            // choose a label at the current level
+            sublabel = y * step + x;
+            // get the label at the top level (= superpixel label)
+            labelA = parent[level][y * step + x];
+            // get the neighboring label at the top level (= superpixel label)
+            labelB = parent[level][(y + 1) * step + x];
+
+            if( labelA == labelB )
+                continue;
+
+            int a11 = parent[level][(y - 1) * step + (x - 1)];
+            int a12 = parent[level][(y - 1) * step + (x)];
+            int a13 = parent[level][(y - 1) * step + (x + 1)];
+            int a21 = parent[level][(y) * step + (x - 1)];
+            int a22 = parent[level][(y) * step + (x)];
+            int a23 = parent[level][(y) * step + (x + 1)];
+
+            done = false;
+            if( nr_partitions[labelA] == 2 || (nr_partitions[labelA] > 2 // 3 or more partitions
+                    && checkSplit_vf(a11, a12, a13, a21, a22, a23)) )
+            {
+                // run algorithm as usual
+                float conf = intersectConf(seeds_top_level, labelB, labelA, level, sublabel);
+                if( conf > req_confidence )
+                {
+                    deleteBlockToplevel(labelA, level, sublabel);
+                    addBlockToplevel(labelB, level, sublabel);
+                    done = true;
+                }
+            }
+
+            if( !done && (nr_partitions[labelB] > MINIMUM_NR_SUBLABELS) )
+            {
+                // try opposite direction
+                sublabel = (y + 1) * step + x;
+                int a31 = parent[level][(y + 1) * step + (x - 1)];
+                int a32 = parent[level][(y + 1) * step + (x)];
+                int a33 = parent[level][(y + 1) * step + (x + 1)];
+                int a41 = parent[level][(y + 2) * step + (x - 1)];
+                int a42 = parent[level][(y + 2) * step + (x)];
+                int a43 = parent[level][(y + 2) * step + (x + 1)];
+                if( nr_partitions[labelB] <= 2 // == 2
+                        || (nr_partitions[labelB] > 2 && checkSplit_vb(a31, a32, a33, a41, a42, a43)) )
+                {
+                    // run algorithm as usual
+                    float conf = intersectConf(seeds_top_level, labelA, labelB, level, sublabel);
+                    if( conf > req_confidence )
+                    {
+                        deleteBlockToplevel(labelB, level, sublabel);
+                        addBlockToplevel(labelA, level, sublabel);
+                        y++;
+                    }
+                }
+            }
+        }
+    }
+}
+
+int SuperpixelSEEDSImpl::goDownOneLevel()
+{
+    int old_level = seeds_current_level;
+    int new_level = seeds_current_level - 1;
+
+    if( new_level < 0 )
+        return -1;
+
+    // reset nr_partitions
+    memset(nr_partitions, 0, sizeof(int) * nrLabels(seeds_top_level));
+
+    // go through labels of new_level
+    int labels_new_level = nrLabels(new_level);
+    //the lowest level (0) has 1 partition, all higher levels are
+    //initially partitioned into 4
+    int partitions = new_level ? 4 : 1;
+
+    for (int label = 0; label < labels_new_level; ++label)
+    {
+        // assign parent = parent of old_label
+        int& cur_parent = parent[new_level][label];
+        int p = parent[old_level][cur_parent];
+        cur_parent = p;
+
+        nr_partitions[p] += partitions;
+    }
+
+    return new_level;
+}
+
+void SuperpixelSEEDSImpl::updatePixels()
+{
+    int labelA;
+    int labelB;
+    int priorA = 0;
+    int priorB = 0;
+
+    for (int y = 1; y < height - 1; y++)
+    {
+        for (int x = 1; x < width - 2; x++)
+        {
+
+            labelA = labels[(y) * width + (x)];
+            labelB = labels[(y) * width + (x + 1)];
+
+            if( labelA != labelB )
+            {
+                int a22 = labelA;
+                int a23 = labelB;
+                if( forwardbackward )
+                {
+                    // horizontal bidirectional
+                    int a11 = labels[(y - 1) * width + (x - 1)];
+                    int a12 = labels[(y - 1) * width + (x)];
+                    int a21 = labels[(y) * width + (x - 1)];
+                    int a31 = labels[(y + 1) * width + (x - 1)];
+                    int a32 = labels[(y + 1) * width + (x)];
+                    if( checkSplit_hf(a11, a12, a21, a22, a31, a32) )
+                    {
+                        if( seeds_prior )
+                        {
+                            priorA = threebyfour(x, y, labelA);
+                            priorB = threebyfour(x, y, labelB);
+                        }
+
+                        if( probability(y * width + x, labelA, labelB, priorA, priorB) )
+                        {
+                            update(labelB, y * width + x, labelA);
+                        }
+                        else
+                        {
+                            int a13 = labels[(y - 1) * width + (x + 1)];
+                            int a14 = labels[(y - 1) * width + (x + 2)];
+                            int a24 = labels[(y) * width + (x + 2)];
+                            int a33 = labels[(y + 1) * width + (x + 1)];
+                            int a34 = labels[(y + 1) * width + (x + 2)];
+                            if( checkSplit_hb(a13, a14, a23, a24, a33, a34) )
+                            {
+                                if( probability(y * width + x + 1, labelB, labelA, priorB, priorA) )
+                                {
+                                    update(labelA, y * width + x + 1, labelB);
+                                    x++;
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                { // forward backward
+                    // horizontal bidirectional
+                    int a13 = labels[(y - 1) * width + (x + 1)];
+                    int a14 = labels[(y - 1) * width + (x + 2)];
+                    int a24 = labels[(y) * width + (x + 2)];
+                    int a33 = labels[(y + 1) * width + (x + 1)];
+                    int a34 = labels[(y + 1) * width + (x + 2)];
+                    if( checkSplit_hb(a13, a14, a23, a24, a33, a34) )
+                    {
+                        if( seeds_prior )
+                        {
+                            priorA = threebyfour(x, y, labelA);
+                            priorB = threebyfour(x, y, labelB);
+                        }
+
+                        if( probability(y * width + x + 1, labelB, labelA, priorB, priorA) )
+                        {
+                            update(labelA, y * width + x + 1, labelB);
+                            x++;
+                        }
+                        else
+                        {
+                            int a11 = labels[(y - 1) * width + (x - 1)];
+                            int a12 = labels[(y - 1) * width + (x)];
+                            int a21 = labels[(y) * width + (x - 1)];
+                            int a31 = labels[(y + 1) * width + (x - 1)];
+                            int a32 = labels[(y + 1) * width + (x)];
+                            if( checkSplit_hf(a11, a12, a21, a22, a31, a32) )
+                            {
+                                if( probability(y * width + x, labelA, labelB, priorA, priorB) )
+                                {
+                                    update(labelB, y * width + x, labelA);
+                                }
+                            }
+                        }
+                    }
+                }
+            } // labelA != labelB
+        } // for x
+    } // for y
+
+    for (int x = 1; x < width - 1; x++)
+    {
+        for (int y = 1; y < height - 2; y++)
+        {
+
+            labelA = labels[(y) * width + (x)];
+            labelB = labels[(y + 1) * width + (x)];
+            if( labelA != labelB )
+            {
+                int a22 = labelA;
+                int a32 = labelB;
+
+                if( forwardbackward )
+                {
+                    // vertical bidirectional
+                    int a11 = labels[(y - 1) * width + (x - 1)];
+                    int a12 = labels[(y - 1) * width + (x)];
+                    int a13 = labels[(y - 1) * width + (x + 1)];
+                    int a21 = labels[(y) * width + (x - 1)];
+                    int a23 = labels[(y) * width + (x + 1)];
+                    if( checkSplit_vf(a11, a12, a13, a21, a22, a23) )
+                    {
+                        if( seeds_prior )
+                        {
+                            priorA = fourbythree(x, y, labelA);
+                            priorB = fourbythree(x, y, labelB);
+                        }
+
+                        if( probability(y * width + x, labelA, labelB, priorA, priorB) )
+                        {
+                            update(labelB, y * width + x, labelA);
+                        }
+                        else
+                        {
+                            int a31 = labels[(y + 1) * width + (x - 1)];
+                            int a33 = labels[(y + 1) * width + (x + 1)];
+                            int a41 = labels[(y + 2) * width + (x - 1)];
+                            int a42 = labels[(y + 2) * width + (x)];
+                            int a43 = labels[(y + 2) * width + (x + 1)];
+                            if( checkSplit_vb(a31, a32, a33, a41, a42, a43) )
+                            {
+                                if( probability((y + 1) * width + x, labelB, labelA, priorB, priorA) )
+                                {
+                                    update(labelA, (y + 1) * width + x, labelB);
+                                    y++;
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                { // forwardbackward
+                    // vertical bidirectional
+                    int a31 = labels[(y + 1) * width + (x - 1)];
+                    int a33 = labels[(y + 1) * width + (x + 1)];
+                    int a41 = labels[(y + 2) * width + (x - 1)];
+                    int a42 = labels[(y + 2) * width + (x)];
+                    int a43 = labels[(y + 2) * width + (x + 1)];
+                    if( checkSplit_vb(a31, a32, a33, a41, a42, a43) )
+                    {
+                        if( seeds_prior )
+                        {
+                            priorA = fourbythree(x, y, labelA);
+                            priorB = fourbythree(x, y, labelB);
+                        }
+
+                        if( probability((y + 1) * width + x, labelB, labelA, priorB, priorA) )
+                        {
+                            update(labelA, (y + 1) * width + x, labelB);
+                            y++;
+                        }
+                        else
+                        {
+                            int a11 = labels[(y - 1) * width + (x - 1)];
+                            int a12 = labels[(y - 1) * width + (x)];
+                            int a13 = labels[(y - 1) * width + (x + 1)];
+                            int a21 = labels[(y) * width + (x - 1)];
+                            int a23 = labels[(y) * width + (x + 1)];
+                            if( checkSplit_vf(a11, a12, a13, a21, a22, a23) )
+                            {
+                                if( probability(y * width + x, labelA, labelB, priorA, priorB) )
+                                {
+                                    update(labelB, y * width + x, labelA);
+                                }
+                            }
+                        }
+                    }
+                }
+            } // labelA != labelB
+        } // for y
+    } // for x
+    forwardbackward = !forwardbackward;
+
+    // update border pixels
+    for (int x = 0; x < width; x++)
+    {
+        labelA = labels[x];
+        labelB = labels[width + x];
+        if( labelA != labelB )
+            update(labelB, x, labelA);
+        labelA = labels[(height - 1) * width + x];
+        labelB = labels[(height - 2) * width + x];
+        if( labelA != labelB )
+            update(labelB, (height - 1) * width + x, labelA);
+    }
+    for (int y = 0; y < height; y++)
+    {
+        labelA = labels[y * width];
+        labelB = labels[y * width + 1];
+        if( labelA != labelB )
+            update(labelB, y * width, labelA);
+        labelA = labels[y * width + width - 1];
+        labelB = labels[y * width + width - 2];
+        if( labelA != labelB )
+            update(labelB, y * width + width - 1, labelA);
+    }
+}
+
+void SuperpixelSEEDSImpl::update(int label_new, int image_idx, int label_old)
+{
+    //change the label of a single pixel
+    deletePixel(seeds_top_level, label_old, image_idx);
+    addPixel(seeds_top_level, label_new, image_idx);
+    labels[image_idx] = label_new;
+}
+
+void SuperpixelSEEDSImpl::addPixel(int level, int label, int image_idx)
+{
+    histogram[level][label * histogram_size_aligned + image_bins[image_idx]]++;
+    T[level][label]++;
+}
+
+void SuperpixelSEEDSImpl::deletePixel(int level, int label, int image_idx)
+{
+    histogram[level][label * histogram_size_aligned + image_bins[image_idx]]--;
+    T[level][label]--;
+}
+
+void SuperpixelSEEDSImpl::addBlock(int level, int label, int sublevel,
+        int sublabel)
+{
+    parent[sublevel][sublabel] = label;
+
+    HISTN* h_label = &histogram[level][label * histogram_size_aligned];
+    HISTN* h_sublabel = &histogram[sublevel][sublabel * histogram_size_aligned];
+
+    //add the (sublevel, sublabel) block to the block (level, label)
+    int n = 0;
+#if CV_SSSE3
+    const int loop_end = histogram_size - 3;
+    for (; n < loop_end; n += 4)
+    {
+        //this does exactly the same as the loop peeling below, but 4 elements at a time
+        __m128 h_labelp = _mm_load_ps(h_label + n);
+        __m128 h_sublabelp = _mm_load_ps(h_sublabel + n);
+        h_labelp = _mm_add_ps(h_labelp, h_sublabelp);
+        _mm_store_ps(h_label + n, h_labelp);
+    }
+#endif
+
+    //loop peeling
+    for (; n < histogram_size; n++)
+        h_label[n] += h_sublabel[n];
+
+    T[level][label] += T[sublevel][sublabel];
+}
+
+void SuperpixelSEEDSImpl::addBlockToplevel(int label, int sublevel, int sublabel)
+{
+    addBlock(seeds_top_level, label, sublevel, sublabel);
+    nr_partitions[label]++;
+}
+
+void SuperpixelSEEDSImpl::deleteBlockToplevel(int label, int sublevel, int sublabel)
+{
+    HISTN* h_label = &histogram[seeds_top_level][label * histogram_size_aligned];
+    HISTN* h_sublabel = &histogram[sublevel][sublabel * histogram_size_aligned];
+
+    //do the reverse operation of add_block_toplevel
+    int n = 0;
+#if CV_SSSE3
+    const int loop_end = histogram_size - 3;
+    for (; n < loop_end; n += 4)
+    {
+        //this does exactly the same as the loop peeling below, but 4 elements at a time
+        __m128 h_labelp = _mm_load_ps(h_label + n);
+        __m128 h_sublabelp = _mm_load_ps(h_sublabel + n);
+        h_labelp = _mm_sub_ps(h_labelp, h_sublabelp);
+        _mm_store_ps(h_label + n, h_labelp);
+    }
+#endif
+
+    //loop peeling
+    for (; n < histogram_size; ++n)
+        h_label[n] -= h_sublabel[n];
+
+    T[seeds_top_level][label] -= T[sublevel][sublabel];
+
+    nr_partitions[label]--;
+}
+
+void SuperpixelSEEDSImpl::updateLabels()
+{
+    for (int i = 0; i < width * height; ++i)
+        labels[i] = parent[0][labels_bottom[i]];
+}
+
+bool SuperpixelSEEDSImpl::probability(int image_idx, int label1, int label2,
+        int prior1, int prior2)
+{
+    unsigned int color = image_bins[image_idx];
+    float P_label1 = histogram[seeds_top_level][label1 * histogram_size_aligned + color]
+                                                * T[seeds_top_level][label2];
+    float P_label2 = histogram[seeds_top_level][label2 * histogram_size_aligned + color]
+                                                * T[seeds_top_level][label1];
+
+    if( seeds_prior )
+    {
+        float p;
+        if( prior2 != 0 )
+            p = (float) prior1 / prior2;
+        else //pathological case
+            p = 1.f;
+        switch( seeds_prior )
+        {
+        case 5: p *= p;
+            /* fallthrough */
+        case 4: p *= p;
+            /* fallthrough */
+        case 3: p *= p;
+            /* fallthrough */
+        case 2:
+            p *= p;
+            P_label1 *= T[seeds_top_level][label2];
+            P_label2 *= T[seeds_top_level][label1];
+            /* fallthrough */
+        case 1:
+            P_label1 *= p;
+            break;
+        }
+    }
+
+    return (P_label2 > P_label1);
+}
+
+int SuperpixelSEEDSImpl::threebyfour(int x, int y, int label)
+{
+    /* count how many pixels in a neighborhood of (x,y) have the label 'label'.
+     * neighborhood (x=counted, o,O=ignored, O=(x,y)):
+     * x x x x
+     * x O o x
+     * x x x x
+     */
+
+#if CV_SSSE3
+    __m128i addp = _mm_set1_epi32(1);
+    __m128i addp_middle = _mm_set_epi32(1, 0, 0, 1);
+    __m128i labelp = _mm_set1_epi32(label);
+    /* 1. row */
+    __m128i data1 = _mm_loadu_si128((__m128i*) (labels + (y-1)*width + x -1));
+    __m128i mask1 = _mm_cmpeq_epi32(data1, labelp);
+    __m128i countp = _mm_and_si128(mask1, addp);
+    /* 2. row */
+    __m128i data2 = _mm_loadu_si128((__m128i*) (labels + y*width + x -1));
+    __m128i mask2 = _mm_cmpeq_epi32(data2, labelp);
+    __m128i count1 = _mm_and_si128(mask2, addp_middle);
+    countp = _mm_add_epi32(countp, count1);
+    /* 3. row */
+    __m128i data3 = _mm_loadu_si128((__m128i*) (labels + (y+1)*width + x -1));
+    __m128i mask3 = _mm_cmpeq_epi32(data3, labelp);
+    __m128i count3 = _mm_and_si128(mask3, addp);
+    countp = _mm_add_epi32(count3, countp);
+
+    countp = _mm_hadd_epi32(countp, countp);
+    countp = _mm_hadd_epi32(countp, countp);
+    return _mm_cvtsi128_si32(countp);
+#else
+    int count = 0;
+    count += (labels[(y - 1) * width + x - 1] == label);
+    count += (labels[(y - 1) * width + x] == label);
+    count += (labels[(y - 1) * width + x + 1] == label);
+    count += (labels[(y - 1) * width + x + 2] == label);
+
+    count += (labels[y * width + x - 1] == label);
+    count += (labels[y * width + x + 2] == label);
+
+    count += (labels[(y + 1) * width + x - 1] == label);
+    count += (labels[(y + 1) * width + x] == label);
+    count += (labels[(y + 1) * width + x + 1] == label);
+    count += (labels[(y + 1) * width + x + 2] == label);
+
+    return count;
+#endif
+}
+
+int SuperpixelSEEDSImpl::fourbythree(int x, int y, int label)
+{
+    /* count how many pixels in a neighborhood of (x,y) have the label 'label'.
+     * neighborhood (x=counted, o,O=ignored, O=(x,y)):
+     * x x x o
+     * x O o x
+     * x o o x
+     * x x x o
+     */
+
+#if CV_SSSE3
+    __m128i addp_border = _mm_set_epi32(0, 1, 1, 1);
+    __m128i addp_middle = _mm_set_epi32(1, 0, 0, 1);
+    __m128i labelp = _mm_set1_epi32(label);
+    /* 1. row */
+    __m128i data1 = _mm_loadu_si128((__m128i*) (labels + (y-1)*width + x -1));
+    __m128i mask1 = _mm_cmpeq_epi32(data1, labelp);
+    __m128i countp = _mm_and_si128(mask1, addp_border);
+    /* 2. row */
+    __m128i data2 = _mm_loadu_si128((__m128i*) (labels + y*width + x -1));
+    __m128i mask2 = _mm_cmpeq_epi32(data2, labelp);
+    __m128i count1 = _mm_and_si128(mask2, addp_middle);
+    countp = _mm_add_epi32(countp, count1);
+    /* 3. row */
+    __m128i data3 = _mm_loadu_si128((__m128i*) (labels + (y+1)*width + x -1));
+    __m128i mask3 = _mm_cmpeq_epi32(data3, labelp);
+    __m128i count3 = _mm_and_si128(mask3, addp_middle);
+    countp = _mm_add_epi32(count3, countp);
+    /* 4. row */
+    __m128i data4 = _mm_loadu_si128((__m128i*) (labels + (y+2)*width + x -1));
+    __m128i mask4 = _mm_cmpeq_epi32(data4, labelp);
+    __m128i count4 = _mm_and_si128(mask4, addp_border);
+    countp = _mm_add_epi32(countp, count4);
+
+    countp = _mm_hadd_epi32(countp, countp);
+    countp = _mm_hadd_epi32(countp, countp);
+    return _mm_cvtsi128_si32(countp);
+#else
+    int count = 0;
+    count += (labels[(y - 1) * width + x - 1] == label);
+    count += (labels[(y - 1) * width + x] == label);
+    count += (labels[(y - 1) * width + x + 1] == label);
+
+    count += (labels[y * width + x - 1] == label);
+    count += (labels[y * width + x + 2] == label);
+
+    count += (labels[(y + 1) * width + x - 1] == label);
+    count += (labels[(y + 1) * width + x + 2] == label);
+
+    count += (labels[(y + 2) * width + x - 1] == label);
+    count += (labels[(y + 2) * width + x] == label);
+    count += (labels[(y + 2) * width + x + 1] == label);
+
+    return count;
+#endif
+}
+
+float SuperpixelSEEDSImpl::intersectConf(int level1, int label1A, int label1B,
+        int level2, int label2)
+{
+    float sumA = 0, sumB = 0;
+    float* h1A = &histogram[level1][label1A * histogram_size_aligned];
+    float* h1B = &histogram[level1][label1B * histogram_size_aligned];
+    float* h2 = &histogram[level2][label2 * histogram_size_aligned];
+    const float count1A = T[level1][label1A];
+    const float count2 = T[level2][label2];
+    const float count1B = T[level1][label1B] - count2;
+
+    /* this calculates several things:
+     * - normalized intersection of a histogram. which is equal to:
+     *   sum i over bins ( min(histogram1_i / T1_i, histogram2_i / T2_i) )
+     * - intersection A = intersection of (level1, label1A) and (level2, label2)
+     * - intersection B =
+     *     intersection of (level1, label1B) - (level2, label2) and (level2, label2)
+     *   where (level1, label1B) - (level2, label2)
+     *     is the subtraction of 2 histograms (-> delete_block method)
+     * - returns the difference between the 2 intersections: intA - intB
+     */
+
+    int n = 0;
+#if CV_SSSE3
+    __m128 count1Ap = _mm_set1_ps(count1A);
+    __m128 count2p = _mm_set1_ps(count2);
+    __m128 count1Bp = _mm_set1_ps(count1B);
+    __m128 sumAp = _mm_set1_ps(0.0f);
+    __m128 sumBp = _mm_set1_ps(0.0f);
+
+    const int loop_end = histogram_size - 3;
+    for(; n < loop_end; n += 4)
+    {
+        //this does exactly the same as the loop peeling below, but 4 elements at a time
+
+        // normal
+        __m128 h1Ap = _mm_load_ps(h1A + n);
+        __m128 h1Bp = _mm_load_ps(h1B + n);
+        __m128 h2p = _mm_load_ps(h2 + n);
+
+        __m128 h1ApC2 = _mm_mul_ps(h1Ap, count2p);
+        __m128 h2pC1A = _mm_mul_ps(h2p, count1Ap);
+        __m128 maskA = _mm_cmple_ps(h1ApC2, h2pC1A);
+        __m128 sum1AddA = _mm_and_ps(maskA, h1ApC2);
+        __m128 sum2AddA = _mm_andnot_ps(maskA, h2pC1A);
+        sumAp = _mm_add_ps(sumAp, sum1AddA);
+        sumAp = _mm_add_ps(sumAp, sum2AddA);
+
+        // del
+        __m128 diffp = _mm_sub_ps(h1Bp, h2p);
+        __m128 h1BpC2 = _mm_mul_ps(diffp, count2p);
+        __m128 h2pC1B = _mm_mul_ps(h2p, count1Bp);
+        __m128 maskB = _mm_cmple_ps(h1BpC2, h2pC1B);
+        __m128 sum1AddB = _mm_and_ps(maskB, h1BpC2);
+        __m128 sum2AddB = _mm_andnot_ps(maskB, h2pC1B);
+        sumBp = _mm_add_ps(sumBp, sum1AddB);
+        sumBp = _mm_add_ps(sumBp, sum2AddB);
+    }
+    // merge results (quite expensive)
+    float sum1Asse;
+    sumAp = _mm_hadd_ps(sumAp, sumAp);
+    sumAp = _mm_hadd_ps(sumAp, sumAp);
+    _mm_store_ss(&sum1Asse, sumAp);
+
+    float sum1Bsse;
+    sumBp = _mm_hadd_ps(sumBp, sumBp);
+    sumBp = _mm_hadd_ps(sumBp, sumBp);
+    _mm_store_ss(&sum1Bsse, sumBp);
+
+    sumA += sum1Asse;
+    sumB += sum1Bsse;
+#endif
+
+    //loop peeling
+    for (; n < histogram_size; ++n)
+    {
+        // normal intersect
+        if( h1A[n] * count2 < h2[n] * count1A ) sumA += h1A[n] * count2;
+        else sumA += h2[n] * count1A;
+
+        // intersect_del
+        float diff = h1B[n] - h2[n];
+        if( diff * count2 < h2[n] * count1B ) sumB += diff * count2;
+        else sumB += h2[n] * count1B;
+    }
+
+    float intA = sumA / (count1A * count2);
+    float intB = sumB / (count1B * count2);
+    return intA - intB;
+}
+
+bool SuperpixelSEEDSImpl::checkSplit_hf(int a11, int a12, int a21, int a22, int a31, int a32)
+{
+    if( (a22 != a21) && (a22 == a12) && (a22 == a32) ) return false;
+    if( (a22 != a11) && (a22 == a12) && (a22 == a21) ) return false;
+    if( (a22 != a31) && (a22 == a32) && (a22 == a21) ) return false;
+    return true;
+}
+bool SuperpixelSEEDSImpl::checkSplit_hb(int a12, int a13, int a22, int a23, int a32, int a33)
+{
+    if( (a22 != a23) && (a22 == a12) && (a22 == a32) ) return false;
+    if( (a22 != a13) && (a22 == a12) && (a22 == a23) ) return false;
+    if( (a22 != a33) && (a22 == a32) && (a22 == a23) ) return false;
+    return true;
+
+}
+bool SuperpixelSEEDSImpl::checkSplit_vf(int a11, int a12, int a13, int a21, int a22, int a23)
+{
+    if( (a22 != a12) && (a22 == a21) && (a22 == a23) ) return false;
+    if( (a22 != a11) && (a22 == a21) && (a22 == a12) ) return false;
+    if( (a22 != a13) && (a22 == a23) && (a22 == a12) ) return false;
+    return true;
+}
+bool SuperpixelSEEDSImpl::checkSplit_vb(int a21, int a22, int a23, int a31, int a32, int a33)
+{
+    if( (a22 != a32) && (a22 == a21) && (a22 == a23) ) return false;
+    if( (a22 != a31) && (a22 == a21) && (a22 == a32) ) return false;
+    if( (a22 != a33) && (a22 == a23) && (a22 == a32) ) return false;
+    return true;
+}
+
+void SuperpixelSEEDSImpl::getLabelContourMask(OutputArray image, bool thick_line)
+{
+    image.create(height, width, CV_8UC1);
+    Mat dst = image.getMat();
+    dst.setTo(Scalar(0));
+
+    const int dx8[8] = { -1, -1, 0, 1, 1, 1, 0, -1 };
+    const int dy8[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
+
+    for (int j = 0; j < height; j++)
+    {
+        for (int k = 0; k < width; k++)
+        {
+            int neighbors = 0;
+            for (int i = 0; i < 8; i++)
+            {
+                int x = k + dx8[i];
+                int y = j + dy8[i];
+
+                if( (x >= 0 && x < width) && (y >= 0 && y < height) )
+                {
+                    int index = y * width + x;
+                    int mainindex = j * width + k;
+                    if( labels[mainindex] != labels[index] )
+                    {
+                        if( thick_line || !*dst.ptr<uchar>(y, x) )
+                            neighbors++;
+                    }
+                }
+            }
+            if( neighbors > 1 )
+                *dst.ptr<uchar>(j, k) = (uchar)255;
+        }
+    }
+}
+
+} // namespace ximgproc
+} // namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/selectivesearchsegmentation.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/selectivesearchsegmentation.cpp
new file mode 100644
index 00000000..198c153a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/selectivesearchsegmentation.cpp
@@ -0,0 +1,1107 @@
+/*
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+/*******************************************************************************\
+*                   Selective search segmentation                              *
+* This code implements the segmentation method described in:                   *
+* Jasper R. R. Uijlings, Koen E. A. van de Sande, Theo Gevers,                 *
+* Arnold W. M. Smeulders: "Selective Search for Object Recognition "           *
+* International Journal of Computer Vision, Volume 104 (2), page 154-171, 2013 *
+* Author: Maximilien Cuony / LTS2 / EPFL / 2016                                *
+********************************************************************************/
+
+#include "precomp.hpp"
+#include "opencv2/ximgproc/segmentation.hpp"
+
+#include <iostream>
+
+namespace cv {
+    namespace ximgproc {
+        namespace segmentation {
+
+            // Helpers
+
+            // Represent a regsion
+            class Region {
+                public:
+                    int id;
+                    int level;
+                    int merged_to;
+                    double rank;
+                    Rect bounding_box;
+
+                    Region() : id(0), level(0), merged_to(0), rank(0) {}
+
+                    friend std::ostream& operator<<(std::ostream& os, const Region& n);
+
+                    bool operator <(const Region& n) const {
+                        return rank < n.rank;
+                    }
+            };
+
+            // Comparator to sort cv::rect (used for a std::map).
+            struct rectComparator {
+                bool operator()(const cv::Rect_<int>& a, const cv::Rect_<int>& b) const {
+                    if (a.x < b.x) {
+                        return true;
+                    }
+                    if (a.x > b.x) {
+                        return false;
+                    }
+                    if (a.y < b.y) {
+                        return true;
+                    }
+                    if (a.y > b.y) {
+                        return false;
+                    }
+                    if (a.width < b.width) {
+                        return true;
+                    }
+                    if (a.width > b.width) {
+                        return false;
+                    }
+                    if (a.height < b.height) {
+                        return true;
+                    }
+                    if (a.height > b.height) {
+                        return false;
+                    }
+                    return false;
+                }
+            };
+
+            // Represent a neighboor
+            class Neighbour {
+                public:
+                    int from;
+                    int to;
+                    float similarity;
+                    friend std::ostream& operator<<(std::ostream& os, const Neighbour& n);
+
+                    bool operator <(const Neighbour& n) const {
+                        return similarity < n.similarity;
+                    }
+            };
+
+            /****************************************
+             * Stragegy / Color
+             ***************************************/
+
+            class SelectiveSearchSegmentationStrategyColorImpl CV_FINAL : public SelectiveSearchSegmentationStrategyColor {
+                public:
+                    SelectiveSearchSegmentationStrategyColorImpl() {
+                        name_ = "SelectiveSearchSegmentationStrategyColor";
+                        last_image_id = -1;
+                    }
+
+                    virtual void setImage(InputArray img, InputArray regions, InputArray sizes, int image_id = -1) CV_OVERRIDE;
+                    virtual float get(int r1, int r2) CV_OVERRIDE;
+                    virtual void merge(int r1, int r2) CV_OVERRIDE;
+
+                private:
+                    String name_;
+
+                    Mat histograms; // [Region X Histogram]
+                    Mat sizes;
+                    int histogram_size;
+
+                    int last_image_id; // If the image_id is not equal to -1 and the same as the previous call for setImage, computations are used again
+                    Mat last_histograms;
+            };
+
+
+            void SelectiveSearchSegmentationStrategyColorImpl::setImage(InputArray img_, InputArray regions_, InputArray sizes_, int image_id) {
+
+                Mat img = img_.getMat();
+                Mat regions = regions_.getMat();
+                sizes = sizes_.getMat();
+
+                if (image_id == -1 || last_image_id != image_id) {
+
+                    std::vector<Mat> img_planes;
+                    split(img, img_planes);
+
+                    int histogram_bins_size = 25;
+
+                    float range[] = {0, 256};
+                    const float* histogram_ranges = {range};
+
+                    double min, max;
+                    minMaxLoc(regions, &min, &max);
+                    int nb_segs = (int)max + 1;
+
+                    histogram_size = histogram_bins_size * img.channels();
+
+                    histograms = Mat_<float>(nb_segs, histogram_size);
+
+                    for (int r = 0; r < nb_segs; r++) {
+
+                        // Generate mask
+                        Mat mask = regions == r;
+
+                        // Compute histogram for each channels
+                        float tt = 0;
+
+                        Mat tmp_hists = Mat(histogram_size, 1, CV_32F);
+                        float *tmp_histogram = tmp_hists.ptr<float>(0);
+                        int h_pos = 0;
+                        Mat tmp_hist;
+
+                        for (int p = 0; p < img.channels(); p++) {
+
+                            calcHist(&img_planes[p], 1, 0, mask, tmp_hist, 1, &histogram_bins_size, &histogram_ranges);
+
+                            float *tmp_hist_ = tmp_hist.ptr<float>(0);
+
+                            // Copy local histogram to global histogram
+                            for (int pos = 0; pos < histogram_bins_size; pos++) {
+                                tmp_histogram[pos + h_pos] = tmp_hist_[pos];
+                                tt += tmp_histogram[pos + h_pos];
+                            }
+                            h_pos += histogram_bins_size;
+                        }
+
+                        // Normalize historgrams
+                        float* histogram = histograms.ptr<float>(r);
+
+                        for (int h_pos2 = 0; h_pos2 < histogram_size; h_pos2++) {
+                            histogram[h_pos2] = tmp_histogram[h_pos2] / tt;
+                        }
+                    }
+
+                    // Save cache if we have an image id
+                    if (image_id != -1) {
+                        last_histograms = histograms.clone();
+                        last_image_id = image_id;
+                    }
+                } else { // last_image_id == image_id
+                    // Use cache
+                    histograms = last_histograms.clone();
+                }
+            }
+
+            float SelectiveSearchSegmentationStrategyColorImpl::get(int r1, int r2) {
+
+                float r = 0;
+                float* h1 = histograms.ptr<float>(r1);
+                float* h2 = histograms.ptr<float>(r2);
+
+                for (int i = 0; i < histogram_size; i++) {
+                    r += min(h1[i], h2[i]);
+                }
+
+                return r;
+            }
+
+            void SelectiveSearchSegmentationStrategyColorImpl::merge(int r1, int r2) {
+                int size_r1 = sizes.at<int>(r1);
+                int size_r2 = sizes.at<int>(r2);
+
+                float* h1 = histograms.ptr<float>(r1);
+                float* h2 = histograms.ptr<float>(r2);
+
+                for (int i = 0; i < histogram_size; i++) {
+                    h1[i] = (h1[i] * size_r1 + h2[i] * size_r2) / (size_r1 + size_r2);
+                    h2[i] = h1[i];
+                }
+            }
+
+
+            Ptr<SelectiveSearchSegmentationStrategyColor> createSelectiveSearchSegmentationStrategyColor() {
+                Ptr<SelectiveSearchSegmentationStrategyColor> s = makePtr<SelectiveSearchSegmentationStrategyColorImpl>();
+                return s;
+            }
+
+            /****************************************
+             * Stragegy / Multiple
+             ***************************************/
+
+            class SelectiveSearchSegmentationStrategyMultipleImpl CV_FINAL : public SelectiveSearchSegmentationStrategyMultiple {
+                public:
+                    SelectiveSearchSegmentationStrategyMultipleImpl() {
+                        name_ = "SelectiveSearchSegmentationStrategyMultiple";
+                        weights_total = 0;
+                    }
+
+                    virtual void setImage(InputArray img, InputArray regions, InputArray sizes, int image_id = -1) CV_OVERRIDE;
+                    virtual float get(int r1, int r2) CV_OVERRIDE;
+                    virtual void merge(int r1, int r2) CV_OVERRIDE;
+
+                    virtual void addStrategy(Ptr<SelectiveSearchSegmentationStrategy> g, float weight) CV_OVERRIDE;
+                    virtual void clearStrategies() CV_OVERRIDE;
+
+                private:
+                    String name_;
+                    std::vector<Ptr<SelectiveSearchSegmentationStrategy> > strategies;
+                    std::vector<float> weights;
+                    float weights_total;
+            };
+
+            void SelectiveSearchSegmentationStrategyMultipleImpl::addStrategy(Ptr<SelectiveSearchSegmentationStrategy> g, float weight) {
+                strategies.push_back(g);
+                weights.push_back(weight);
+                weights_total += weight;
+            }
+
+            void SelectiveSearchSegmentationStrategyMultipleImpl::clearStrategies() {
+                strategies.clear();
+                weights.clear();
+                weights_total = 0;
+            }
+
+            void SelectiveSearchSegmentationStrategyMultipleImpl::setImage(InputArray img_, InputArray regions_, InputArray sizes_, int image_id) {
+                for (unsigned int i = 0; i < strategies.size(); i++) {
+                    strategies[i]->setImage(img_, regions_, sizes_, image_id);
+                }
+            }
+
+            float SelectiveSearchSegmentationStrategyMultipleImpl::get(int r1, int r2) {
+                float tt = 0;
+
+                for (unsigned int i = 0; i < strategies.size(); i++) {
+                    tt += weights[i] * strategies[i]->get(r1, r2);
+                }
+
+                return tt / weights_total;
+            }
+
+            void SelectiveSearchSegmentationStrategyMultipleImpl::merge(int r1, int r2) {
+                for (unsigned int i = 0; i < strategies.size(); i++) {
+                    strategies[i]->merge(r1, r2);
+                }
+            }
+
+            Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple() {
+                Ptr<SelectiveSearchSegmentationStrategyMultiple> s = makePtr<SelectiveSearchSegmentationStrategyMultipleImpl>();
+                return s;
+            }
+
+            // Helpers to quickly create a multiple stragegy with 1 to 4 equal strageries
+            Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1) {
+                Ptr<SelectiveSearchSegmentationStrategyMultiple> s = makePtr<SelectiveSearchSegmentationStrategyMultipleImpl>();
+
+                s->addStrategy(s1, 1.0f);
+
+                return s;
+            }
+
+            Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1, Ptr<SelectiveSearchSegmentationStrategy> s2) {
+                Ptr<SelectiveSearchSegmentationStrategyMultiple> s = makePtr<SelectiveSearchSegmentationStrategyMultipleImpl>();
+
+                s->addStrategy(s1, 0.5f);
+                s->addStrategy(s2, 0.5f);
+
+                return s;
+            }
+
+            Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1, Ptr<SelectiveSearchSegmentationStrategy> s2, Ptr<SelectiveSearchSegmentationStrategy> s3) {
+                Ptr<SelectiveSearchSegmentationStrategyMultiple> s = makePtr<SelectiveSearchSegmentationStrategyMultipleImpl>();
+
+                s->addStrategy(s1, 0.3333f);
+                s->addStrategy(s2, 0.3333f);
+                s->addStrategy(s3, 0.3333f);
+
+                return s;
+            }
+
+            Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1, Ptr<SelectiveSearchSegmentationStrategy> s2, Ptr<SelectiveSearchSegmentationStrategy> s3, Ptr<SelectiveSearchSegmentationStrategy> s4) {
+                Ptr<SelectiveSearchSegmentationStrategyMultiple> s = makePtr<SelectiveSearchSegmentationStrategyMultipleImpl>();
+
+                s->addStrategy(s1, 0.25f);
+                s->addStrategy(s2, 0.25f);
+                s->addStrategy(s3, 0.25f);
+                s->addStrategy(s4, 0.25f);
+
+                return s;
+            }
+
+
+            /****************************************
+             * Stragegy / Size
+             ***************************************/
+
+            class SelectiveSearchSegmentationStrategySizeImpl CV_FINAL : public SelectiveSearchSegmentationStrategySize {
+                public:
+                    SelectiveSearchSegmentationStrategySizeImpl() {
+                        name_ = "SelectiveSearchSegmentationStrategySize";
+                    }
+
+                    virtual void setImage(InputArray img, InputArray regions, InputArray sizes, int image_id = -1) CV_OVERRIDE;
+                    virtual float get(int r1, int r2) CV_OVERRIDE;
+                    virtual void merge(int r1, int r2) CV_OVERRIDE;
+
+                private:
+                    String name_;
+
+                    Mat sizes;
+                    int size_image;
+            };
+
+
+            void SelectiveSearchSegmentationStrategySizeImpl::setImage(InputArray img_, InputArray, InputArray sizes_, int /* image_id */) {
+                Mat img = img_.getMat();
+                size_image = img.rows * img.cols;
+                sizes = sizes_.getMat();
+            }
+
+            float SelectiveSearchSegmentationStrategySizeImpl::get(int r1, int r2) {
+
+                int size_r1 = sizes.at<int>(r1);
+                int size_r2 = sizes.at<int>(r2);
+
+                return max(min(1.0f - (float)(size_r1 + size_r2) / (float)(size_image), 1.0f), 0.0f);
+            }
+
+            void SelectiveSearchSegmentationStrategySizeImpl::merge(int /* r1 */, int /* r2 */) {
+                // Nothing to do (sizes are merged at parent level)
+            }
+
+
+            Ptr<SelectiveSearchSegmentationStrategySize> createSelectiveSearchSegmentationStrategySize() {
+                Ptr<SelectiveSearchSegmentationStrategySize> s = makePtr<SelectiveSearchSegmentationStrategySizeImpl>();
+                return s;
+            }
+
+
+            /****************************************
+             * Stragegy / Fill
+             ***************************************/
+
+            class SelectiveSearchSegmentationStrategyFillImpl CV_FINAL : public SelectiveSearchSegmentationStrategyFill {
+                public:
+                    SelectiveSearchSegmentationStrategyFillImpl() {
+                        name_ = "SelectiveSearchSegmentationStrategyFill";
+                    }
+
+                    virtual void setImage(InputArray img, InputArray regions, InputArray sizes, int image_id = -1) CV_OVERRIDE;
+                    virtual float get(int r1, int r2) CV_OVERRIDE;
+                    virtual void merge(int r1, int r2) CV_OVERRIDE;
+
+                private:
+                    String name_;
+
+                    Mat sizes;
+                    int size_image;
+                    std::vector<Rect> bounding_rects;
+            };
+
+
+            void SelectiveSearchSegmentationStrategyFillImpl::setImage(InputArray img_, InputArray regions_, InputArray sizes_, int /* image_id */) {
+                Mat img = img_.getMat();
+                sizes = sizes_.getMat();
+                Mat regions = regions_.getMat();
+
+                size_image = img.rows * img.cols;
+
+                // Build initial bouding rects
+                double min, max;
+                minMaxLoc(regions, &min, &max);
+
+                int nb_segs = (int)max + 1;
+
+                // Build a list of points for each regions
+                std::vector<std::vector<cv::Point> > points;
+
+                points.resize(nb_segs);
+
+                for (int i = 0; i < (int)regions.rows; i++) {
+                    const int* p = regions.ptr<int>(i);
+
+                    for (int j = 0; j < (int)regions.cols; j++) {
+                        points[p[j]].push_back(cv::Point(j, i));
+                    }
+                }
+
+                // Compute bounding rects for each regions
+                bounding_rects.resize(nb_segs);
+
+                for(int seg = 0; seg < nb_segs; seg++) {
+                    bounding_rects[seg] = cv::boundingRect(points[seg]);
+                }
+            }
+
+            float SelectiveSearchSegmentationStrategyFillImpl::get(int r1, int r2) {
+
+                int size_r1 = sizes.at<int>(r1);
+                int size_r2 = sizes.at<int>(r2);
+                int bounding_rect_size = (bounding_rects[r1] | bounding_rects[r2]).area();
+
+                return max(min(1.0f - (float)(bounding_rect_size - size_r1 - size_r2) / (float)(size_image), 1.0f), 0.0f);
+            }
+
+            void SelectiveSearchSegmentationStrategyFillImpl::merge(int r1, int r2) {
+                bounding_rects[r1] = bounding_rects[r1] | bounding_rects[r2];
+                bounding_rects[r2] = bounding_rects[r1];
+            }
+
+
+            Ptr<SelectiveSearchSegmentationStrategyFill> createSelectiveSearchSegmentationStrategyFill() {
+                Ptr<SelectiveSearchSegmentationStrategyFill> s = makePtr<SelectiveSearchSegmentationStrategyFillImpl>();
+                return s;
+            }
+
+
+            /****************************************
+             * Stragegy / Texture
+             ***************************************/
+
+            class SelectiveSearchSegmentationStrategyTextureImpl CV_FINAL : public SelectiveSearchSegmentationStrategyTexture {
+                public:
+                    SelectiveSearchSegmentationStrategyTextureImpl() {
+                        name_ = "SelectiveSearchSegmentationStrategyTexture";
+                        last_image_id = -1;
+                    }
+
+                    virtual void setImage(InputArray img, InputArray regions, InputArray sizes, int image_id = -1) CV_OVERRIDE;
+                    virtual float get(int r1, int r2) CV_OVERRIDE;
+                    virtual void merge(int r1, int r2) CV_OVERRIDE;
+
+                private:
+                    String name_;
+
+                    Mat histograms; //[Region X Histogram]
+                    Mat sizes;
+                    int histogram_size;
+
+                    int last_image_id; // If the image_id is not equal to -1 and the same as the previous call for setImage, computations are used again
+                    Mat last_histograms;
+            };
+
+
+            void SelectiveSearchSegmentationStrategyTextureImpl::setImage(InputArray img_, InputArray regions_, InputArray sizes_, int image_id) {
+
+                Mat img = img_.getMat();
+                Mat regions = regions_.getMat();
+                sizes = sizes_.getMat();
+
+                if (image_id == -1 || last_image_id != image_id) {
+
+                    std::vector<Mat> img_planes;
+                    split(img, img_planes);
+
+                    int histogram_bins_size = 10;
+
+                    float range[] = {0.0, 256.0};
+
+                    double min, max;
+                    minMaxLoc(regions, &min, &max);
+                    int nb_segs = (int)max + 1;
+
+                    histogram_size = histogram_bins_size * img.channels() * 8;
+
+                    histograms = Mat_<float>(nb_segs, histogram_size);
+
+                    // Compute, for each channels, the 8 gaussians
+                    std::vector<Mat> img_gaussians;
+
+                    for (int p = 0; p < img.channels(); p++) {
+
+                        Mat tmp_gradiant;
+                        Mat tmp_gradiant_pos, tmp_gradiant_neg;
+                        Mat img_plane_rotated;
+                        Mat tmp_rot;
+
+                        // X, no rot
+                        Scharr(img_planes[p], tmp_gradiant, CV_32F, 1, 0);
+                        threshold(tmp_gradiant, tmp_gradiant_pos, 0, 0, THRESH_TOZERO);
+                        threshold(tmp_gradiant, tmp_gradiant_neg, 0, 0, THRESH_TOZERO_INV);
+
+                        img_gaussians.push_back(tmp_gradiant_pos.clone());
+                        img_gaussians.push_back(tmp_gradiant_neg.clone());
+
+                        // Y, no rot
+                        Scharr(img_planes[p], tmp_gradiant, CV_32F, 0, 1);
+                        threshold(tmp_gradiant, tmp_gradiant_pos, 0, 0, THRESH_TOZERO);
+                        threshold(tmp_gradiant, tmp_gradiant_neg, 0, 0, THRESH_TOZERO_INV);
+
+                        img_gaussians.push_back(tmp_gradiant_pos.clone());
+                        img_gaussians.push_back(tmp_gradiant_neg.clone());
+
+                        Point2f center(img.cols / 2.0f, img.rows / 2.0f);
+                        Mat rot = cv::getRotationMatrix2D(center, 45.0, 1.0);
+                        Rect bbox = cv::RotatedRect(center, img.size(), 45.0).boundingRect();
+                        rot.at<double>(0,2) += bbox.width/2.0 - center.x;
+                        rot.at<double>(1,2) += bbox.height/2.0 - center.y;
+
+                        warpAffine(img_planes[p], img_plane_rotated, rot, bbox.size());
+
+                        // X, rot
+                        Scharr(img_plane_rotated, tmp_gradiant, CV_32F, 1, 0);
+
+                        center = Point((int)(img_plane_rotated.cols / 2.0), (int)(img_plane_rotated.rows / 2.0));
+                        rot = cv::getRotationMatrix2D(center, -45.0, 1.0);
+                        // Using this bigger box avoids clipping the ends of narrow images
+                        Rect bbox2 = cv::RotatedRect(center, img_plane_rotated.size(), -45.0).boundingRect();\
+                        warpAffine(tmp_gradiant, tmp_rot, rot, bbox2.size());
+
+                        // for narrow images, bbox might be less tall or wide than img
+                        int start_x = std::max(0, (bbox.width - img.cols) / 2);
+                        int start_y = std::max(0, (bbox.height - img.rows) / 2);
+                        tmp_gradiant = tmp_rot(Rect(start_x, start_y, img.cols, img.rows));
+
+                        threshold(tmp_gradiant, tmp_gradiant_pos, 0, 0, THRESH_TOZERO);
+                        threshold(tmp_gradiant, tmp_gradiant_neg, 0, 0, THRESH_TOZERO_INV);
+
+                        img_gaussians.push_back(tmp_gradiant_pos.clone());
+                        img_gaussians.push_back(tmp_gradiant_neg.clone());
+
+                        // Y, rot
+                        Scharr(img_plane_rotated, tmp_gradiant, CV_32F, 0, 1);
+
+                        center = Point((int)(img_plane_rotated.cols / 2.0), (int)(img_plane_rotated.rows / 2.0));
+                        rot = cv::getRotationMatrix2D(center, -45.0, 1.0);
+                        bbox2 = cv::RotatedRect(center, img_plane_rotated.size(), -45.0).boundingRect();\
+                        warpAffine(tmp_gradiant, tmp_rot, rot, bbox2.size());
+
+                        start_x = std::max(0, (bbox.width - img.cols) / 2);
+                        start_y = std::max(0, (bbox.height - img.rows) / 2);
+                        tmp_gradiant = tmp_rot(Rect(start_x, start_y, img.cols, img.rows));
+
+                        threshold(tmp_gradiant, tmp_gradiant_pos, 0, 0, THRESH_TOZERO);
+                        threshold(tmp_gradiant, tmp_gradiant_neg, 0, 0, THRESH_TOZERO_INV);
+
+                        img_gaussians.push_back(tmp_gradiant_pos.clone());
+                        img_gaussians.push_back(tmp_gradiant_neg.clone());
+
+                    }
+
+                    // Normalisze gaussiaans in 0-255 range (for faster computation of histograms)
+                    for (int i = 0; i < img.channels() * 8; i++) {
+
+                        double hmin, hmax;
+                        minMaxLoc(img_gaussians[i], &hmin, &hmax);
+
+                        Mat tmp;
+                        img_gaussians[i].convertTo(tmp, CV_8U, (range[1] - 1) / (hmax - hmin), -(range[1] - 1) * hmin / (hmax - hmin));
+                        img_gaussians[i] = tmp;
+
+                    }
+
+                    // We compute histograms manualy, directly addings bins based on the region instead of computing multiple histograms
+                    // This speedup significantly computations
+
+                    std::vector<int> totals;
+                    totals.resize(nb_segs);
+
+                    // Bins for histograms
+                    Mat_<int> tmp_histograms = Mat_<int>::zeros(nb_segs, histogram_size);
+
+                    int* regions_data = (int*)regions.data;
+
+                    for (unsigned int x = 0; x < regions.total(); x++) {
+                        int region = regions_data[x];
+
+                        int* histogram = tmp_histograms.ptr<int>(region);
+
+                        for (int p = 0; p < img.channels(); p++) {
+                            for (unsigned int i = 0; i < 8; i++) {
+
+                                int val = (int)((unsigned char*)img_gaussians[p * 8 + i].data)[x];
+
+                                int bin = (int)((float)val / (range[1] / histogram_bins_size));
+
+                                histogram[(p * 8 + i) * histogram_bins_size + bin]++;
+                                totals[region]++;
+                            }
+                        }
+                    }
+
+                    // Normalisation per segments
+                    for (int r = 0; r < nb_segs; r++) {
+
+                        float* histogram = histograms.ptr<float>(r);
+                        int* tmp_histogram = tmp_histograms.ptr<int>(r);
+
+                        for (int h_pos2 = 0; h_pos2 < histogram_size; h_pos2++) {
+                            histogram[h_pos2] = (float)tmp_histogram[h_pos2] / (float)totals[r];
+                        }
+                    }
+
+                    if (image_id != -1) { // Save cache if it's apply
+                        last_histograms = histograms.clone();
+                        last_image_id = image_id;
+                    }
+                } else { // image_id == last_image_id
+                    histograms = last_histograms.clone(); // Use cache
+                }
+            }
+
+            float SelectiveSearchSegmentationStrategyTextureImpl::get(int r1, int r2) {
+
+                float r = 0;
+                float* h1 = histograms.ptr<float>(r1);
+                float* h2 = histograms.ptr<float>(r2);
+
+                for (int i = 0; i < histogram_size; i++) {
+                    r += min(h1[i], h2[i]);
+                }
+
+                return r;
+            }
+
+            void SelectiveSearchSegmentationStrategyTextureImpl::merge(int r1, int r2) {
+                int size_r1 = sizes.at<int>(r1);
+                int size_r2 = sizes.at<int>(r2);
+
+                float* h1 = histograms.ptr<float>(r1);
+                float* h2 = histograms.ptr<float>(r2);
+
+                for (int i = 0; i < histogram_size; i++) {
+                    h1[i] = (h1[i] * size_r1 + h2[i] * size_r2) / (size_r1 + size_r2);
+                    h2[i] = h1[i];
+                }
+            }
+
+
+            Ptr<SelectiveSearchSegmentationStrategyTexture> createSelectiveSearchSegmentationStrategyTexture() {
+                Ptr<SelectiveSearchSegmentationStrategyTexture> s = makePtr<SelectiveSearchSegmentationStrategyTextureImpl>();
+                return s;
+            }
+
+            // Core
+
+            class SelectiveSearchSegmentationImpl CV_FINAL : public SelectiveSearchSegmentation {
+                public:
+                    SelectiveSearchSegmentationImpl() {
+                        name_ = "SelectiveSearchSegmentation";
+                    }
+
+                    ~SelectiveSearchSegmentationImpl() CV_OVERRIDE {
+                    };
+
+                    virtual void write(FileStorage& fs) const CV_OVERRIDE {
+                        fs << "name" << name_;
+                    }
+
+                    virtual void read(const FileNode& fn) CV_OVERRIDE {
+                        CV_Assert( (String)fn["name"] == name_);
+                    }
+
+                    virtual void setBaseImage(InputArray img) CV_OVERRIDE;
+
+                    virtual void switchToSingleStrategy(int k = 200, float sigma = 0.8) CV_OVERRIDE;
+                    virtual void switchToSelectiveSearchFast(int base_k = 150, int inc_k = 150, float sigma = 0.8) CV_OVERRIDE;
+                    virtual void switchToSelectiveSearchQuality(int base_k = 150, int inc_k = 150, float sigma = 0.8) CV_OVERRIDE;
+
+                    virtual void addImage(InputArray img) CV_OVERRIDE;
+                    virtual void clearImages() CV_OVERRIDE;
+
+                    virtual void addGraphSegmentation(Ptr<GraphSegmentation> g) CV_OVERRIDE;
+                    virtual void clearGraphSegmentations() CV_OVERRIDE;
+
+                    virtual void addStrategy(Ptr<SelectiveSearchSegmentationStrategy> s) CV_OVERRIDE;
+                    virtual void clearStrategies() CV_OVERRIDE;
+
+                    virtual void process(std::vector<Rect>& rects) CV_OVERRIDE;
+
+
+                private:
+                    String name_;
+
+                    Mat base_image;
+                    std::vector<Mat> images;
+                    std::vector<Ptr<GraphSegmentation> > segmentations;
+                    std::vector<Ptr<SelectiveSearchSegmentationStrategy> > strategies;
+
+                    void hierarchicalGrouping(const Mat& img, Ptr<SelectiveSearchSegmentationStrategy>& s, const Mat& img_regions, const Mat_<char>& is_neighbour, const Mat_<int>& sizes, int& nb_segs, const std::vector<Rect>& bounding_rects, std::vector<Region>& regions, int region_id);
+            };
+
+            void SelectiveSearchSegmentationImpl::setBaseImage(InputArray img) {
+                base_image = img.getMat();
+            }
+
+            void SelectiveSearchSegmentationImpl::addImage(InputArray img) {
+                images.push_back(img.getMat());
+            }
+
+            void SelectiveSearchSegmentationImpl::clearImages() {
+                images.clear();
+            }
+
+            void SelectiveSearchSegmentationImpl::addGraphSegmentation(Ptr<GraphSegmentation> g) {
+                segmentations.push_back(g);
+            }
+
+            void SelectiveSearchSegmentationImpl::clearGraphSegmentations() {
+                segmentations.clear();
+            }
+
+            void SelectiveSearchSegmentationImpl::addStrategy(Ptr<SelectiveSearchSegmentationStrategy> s) {
+                strategies.push_back(s);
+            }
+
+            void SelectiveSearchSegmentationImpl::clearStrategies() {
+                strategies.clear();
+            }
+
+            void SelectiveSearchSegmentationImpl::switchToSingleStrategy(int k, float sigma) {
+                clearImages();
+                clearGraphSegmentations();
+                clearStrategies();
+
+                Mat hsv;
+                cvtColor(base_image, hsv, COLOR_BGR2HSV);
+                addImage(hsv);
+
+                Ptr<GraphSegmentation> gs = createGraphSegmentation();
+                gs->setK((float)k);
+                gs->setSigma(sigma);
+                addGraphSegmentation(gs);
+
+                Ptr<SelectiveSearchSegmentationStrategyColor> color = createSelectiveSearchSegmentationStrategyColor();
+                Ptr<SelectiveSearchSegmentationStrategyFill> fill = createSelectiveSearchSegmentationStrategyFill();
+                Ptr<SelectiveSearchSegmentationStrategyTexture> texture = createSelectiveSearchSegmentationStrategyTexture();
+                Ptr<SelectiveSearchSegmentationStrategySize> size = createSelectiveSearchSegmentationStrategySize();
+
+                Ptr<SelectiveSearchSegmentationStrategyMultiple> m = createSelectiveSearchSegmentationStrategyMultiple(color, fill, texture, size);
+
+                addStrategy(m);
+
+            }
+
+            void SelectiveSearchSegmentationImpl::switchToSelectiveSearchFast(int base_k, int inc_k, float sigma) {
+                clearImages();
+                clearGraphSegmentations();
+                clearStrategies();
+
+                Mat hsv;
+                cvtColor(base_image, hsv, COLOR_BGR2HSV);
+                addImage(hsv);
+                Mat lab;
+                cvtColor(base_image, lab, COLOR_BGR2Lab);
+                addImage(lab);
+
+                for (int k = base_k; k <= base_k + inc_k * 2; k+= inc_k) {
+                    Ptr<GraphSegmentation> gs = createGraphSegmentation();
+                    gs->setK((float)k);
+                    gs->setSigma(sigma);
+                    addGraphSegmentation(gs);
+                }
+
+                Ptr<SelectiveSearchSegmentationStrategyColor> color = createSelectiveSearchSegmentationStrategyColor();
+                Ptr<SelectiveSearchSegmentationStrategyFill> fill = createSelectiveSearchSegmentationStrategyFill();
+                Ptr<SelectiveSearchSegmentationStrategyTexture> texture = createSelectiveSearchSegmentationStrategyTexture();
+                Ptr<SelectiveSearchSegmentationStrategySize> size = createSelectiveSearchSegmentationStrategySize();
+
+                Ptr<SelectiveSearchSegmentationStrategyMultiple> m = createSelectiveSearchSegmentationStrategyMultiple(color, fill, texture, size);
+
+                addStrategy(m);
+
+                Ptr<SelectiveSearchSegmentationStrategyFill> fill2 = createSelectiveSearchSegmentationStrategyFill();
+                Ptr<SelectiveSearchSegmentationStrategyTexture> texture2 = createSelectiveSearchSegmentationStrategyTexture();
+                Ptr<SelectiveSearchSegmentationStrategySize> size2 = createSelectiveSearchSegmentationStrategySize();
+
+                Ptr<SelectiveSearchSegmentationStrategyMultiple> m2 = createSelectiveSearchSegmentationStrategyMultiple(fill2, texture2, size2);
+
+                addStrategy(m2);
+
+            }
+
+            void SelectiveSearchSegmentationImpl::switchToSelectiveSearchQuality(int base_k, int inc_k, float sigma) {
+                clearImages();
+                clearGraphSegmentations();
+                clearStrategies();
+
+
+                Mat hsv;
+                cvtColor(base_image, hsv, COLOR_BGR2HSV);
+                addImage(hsv);
+                Mat lab;
+                cvtColor(base_image, lab, COLOR_BGR2Lab);
+                addImage(lab);
+
+                Mat I;
+                cvtColor(base_image, I, COLOR_BGR2GRAY);
+                addImage(I);
+
+                Mat channel[3];
+                split(hsv, channel);
+                addImage(channel[0]);
+
+                split(base_image, channel);
+                std::vector<Mat> channel2 = {channel[2], channel[1], I};
+
+                Mat rgI;
+                merge(channel2, rgI);
+                addImage(rgI);
+
+                for (int k = base_k; k <= base_k + inc_k * 4; k+= inc_k) {
+                    Ptr<GraphSegmentation> gs = createGraphSegmentation();
+                    gs->setK((float)k);
+                    gs->setSigma(sigma);
+                    addGraphSegmentation(gs);
+                }
+
+                Ptr<SelectiveSearchSegmentationStrategyColor> color = createSelectiveSearchSegmentationStrategyColor();
+                Ptr<SelectiveSearchSegmentationStrategyFill> fill = createSelectiveSearchSegmentationStrategyFill();
+                Ptr<SelectiveSearchSegmentationStrategyTexture> texture = createSelectiveSearchSegmentationStrategyTexture();
+                Ptr<SelectiveSearchSegmentationStrategySize> size = createSelectiveSearchSegmentationStrategySize();
+
+                Ptr<SelectiveSearchSegmentationStrategyMultiple> m = createSelectiveSearchSegmentationStrategyMultiple(color, fill, texture, size);
+
+                addStrategy(m);
+
+                Ptr<SelectiveSearchSegmentationStrategyFill> fill2 = createSelectiveSearchSegmentationStrategyFill();
+                Ptr<SelectiveSearchSegmentationStrategyTexture> texture2 = createSelectiveSearchSegmentationStrategyTexture();
+                Ptr<SelectiveSearchSegmentationStrategySize> size2 = createSelectiveSearchSegmentationStrategySize();
+
+                Ptr<SelectiveSearchSegmentationStrategyMultiple> m2 = createSelectiveSearchSegmentationStrategyMultiple(fill2, texture2, size2);
+
+                addStrategy(m2);
+
+                Ptr<SelectiveSearchSegmentationStrategyFill> fill3 = createSelectiveSearchSegmentationStrategyFill();
+                addStrategy(fill3);
+
+                Ptr<SelectiveSearchSegmentationStrategySize> size3 = createSelectiveSearchSegmentationStrategySize();
+                addStrategy(size3);
+            }
+
+            void SelectiveSearchSegmentationImpl::process(std::vector<Rect>& rects) {
+
+                std::vector<Region> all_regions;
+
+                int image_id = 0;
+
+                for(std::vector<Mat>::iterator image = images.begin(); image != images.end(); ++image) {
+                    for(std::vector<Ptr<GraphSegmentation> >::iterator gs = segmentations.begin(); gs != segmentations.end(); ++gs) {
+
+                        Mat img_regions;
+                        Mat_<char> is_neighbour;
+                        Mat_<int> sizes;
+
+                        // Compute initial segmentation
+                        (*gs)->processImage(*image, img_regions);
+
+                        // Get number of regions
+                        double min, max;
+                        minMaxLoc(img_regions, &min, &max);
+                        int nb_segs = (int)max + 1;
+
+                        // Compute bouding rects and neighbours
+                        std::vector<Rect> bounding_rects;
+                        bounding_rects.resize(nb_segs);
+
+                        std::vector<std::vector<cv::Point> > points;
+
+                        points.resize(nb_segs);
+
+                        is_neighbour = Mat::zeros(nb_segs, nb_segs, CV_8UC1);
+                        sizes = Mat::zeros(nb_segs, 1, CV_32SC1);
+
+                        const int* previous_p = NULL;
+
+                        for (int i = 0; i < (int)img_regions.rows; i++) {
+                            const int* p = img_regions.ptr<int>(i);
+
+                            for (int j = 0; j < (int)img_regions.cols; j++) {
+
+                                points[p[j]].push_back(cv::Point(j, i));
+                                sizes.at<int>(p[j], 0) = sizes.at<int>(p[j], 0) + 1;
+
+                                if (i > 0 && j > 0) {
+
+                                    is_neighbour.at<char>(p[j], p[j - 1]) = 1;
+                                    is_neighbour.at<char>(p[j], previous_p[j]) = 1;
+                                    is_neighbour.at<char>(p[j], previous_p[j - 1]) = 1;
+
+                                    is_neighbour.at<char>(p[j - 1], p[j]) = 1;
+                                    is_neighbour.at<char>(previous_p[j], p[j]) = 1;
+                                    is_neighbour.at<char>(previous_p[j - 1], p[j]) = 1;
+                                }
+                            }
+                            previous_p = p;
+                        }
+
+                        for(int seg = 0; seg < nb_segs; seg++) {
+                            bounding_rects[seg] = cv::boundingRect(points[seg]);
+                        }
+
+                        for(std::vector<Ptr<SelectiveSearchSegmentationStrategy> >::iterator strategy = strategies.begin(); strategy != strategies.end(); ++strategy) {
+                            std::vector<Region> regions;
+                            hierarchicalGrouping(*image, *strategy, img_regions, is_neighbour, sizes, nb_segs, bounding_rects, regions, image_id);
+
+                            for(std::vector<Region>::iterator region = regions.begin(); region != regions.end(); ++region) {
+                                all_regions.push_back(*region);
+                            }
+                        }
+
+                        image_id++;
+                    }
+                }
+
+                std::sort(all_regions.begin(), all_regions.end());
+
+                std::map<Rect, char, rectComparator> processed_rect;
+
+                rects.clear();
+
+                // Remove duplicate in rect list
+                for(std::vector<Region>::iterator region = all_regions.begin(); region != all_regions.end(); ++region) {
+                    if (processed_rect.find((*region).bounding_box) == processed_rect.end()) {
+                        processed_rect[(*region).bounding_box] = true;
+                        rects.push_back((*region).bounding_box);
+                    }
+                }
+
+            }
+
+            void SelectiveSearchSegmentationImpl::hierarchicalGrouping(const Mat& img, Ptr<SelectiveSearchSegmentationStrategy>& s, const Mat& img_regions, const Mat_<char>& is_neighbour, const Mat_<int>& sizes_, int& nb_segs, const std::vector<Rect>& bounding_rects, std::vector<Region>& regions, int image_id) {
+
+                Mat sizes = sizes_.clone();
+
+                std::vector<Neighbour> similarities;
+                regions.clear();
+
+                /////////////////////////////////////////
+
+                s->setImage(img, img_regions, sizes, image_id);
+
+                // Compute initial similarities
+                for (int i = 0; i < nb_segs; i++) {
+                    Region r;
+
+                    r.id = i;
+                    r.level = 1;
+                    r.merged_to = -1;
+                    r.bounding_box = bounding_rects[i];
+
+                    regions.push_back(r);
+
+                    for (int j = i + 1; j < nb_segs; j++) {
+                        if (is_neighbour.at<char>(i, j)) {
+                            Neighbour n;
+                            n.from = i;
+                            n.to = j;
+                            n.similarity = s->get(i, j);
+
+                            similarities.push_back(n);
+                        }
+                    }
+                }
+
+                while(similarities.size() > 0) {
+
+                    std::sort(similarities.begin(), similarities.end());
+
+                    // for(std::vector<Neighbour>::iterator similarity = similarities.begin(); similarity != similarities.end(); ++similarity) {
+                    //     std::cout << *similarity << std::endl;
+                    // }
+
+                    Neighbour p = similarities.back();
+                    similarities.pop_back();
+
+                    Region region_from = regions[p.from];
+                    Region region_to = regions[p.to];
+
+                    Region new_r;
+                    new_r.id = std::min(region_from.id, region_to.id); // Should be the smalest, working ID
+                    new_r.level = std::max(region_from.level, region_to.level) + 1;
+                    new_r.merged_to = -1;
+                    new_r.bounding_box = region_from.bounding_box | region_to.bounding_box;
+
+                    regions.push_back(new_r);
+
+                    regions[p.from].merged_to = (int)regions.size() - 1;
+                    regions[p.to].merged_to = (int)regions.size() - 1;
+
+                    // Merge
+                    s->merge(region_from.id, region_to.id);
+
+                    // Update size
+                    sizes.at<int>(region_from.id, 0) += sizes.at<int>(region_to.id, 0);
+                    sizes.at<int>(region_to.id, 0) = sizes.at<int>(region_from.id, 0);
+
+                    std::vector<int> local_neighbours;
+
+                    for(std::vector<Neighbour>::iterator similarity = similarities.begin(); similarity != similarities.end();) {
+                        if ((*similarity).from == p.from || (*similarity).to == p.from || (*similarity).from == p.to || (*similarity).to == p.to) {
+                            int from = 0;
+
+                            if ((*similarity).from == p.from || (*similarity).from == p.to) {
+                                from = (*similarity).to;
+                            } else {
+                                from = (*similarity).from;
+                            }
+
+                            bool already_neighboor = false;
+
+                            for(std::vector<int>::iterator local_neighbour = local_neighbours.begin(); local_neighbour != local_neighbours.end(); local_neighbour++) {
+                                if (*local_neighbour == from) {
+                                    already_neighboor = true;
+                                }
+                            }
+
+                            if (!already_neighboor) {
+                                local_neighbours.push_back(from);
+                            }
+
+                            similarity = similarities.erase(similarity);
+                        } else {
+                            similarity++;
+                        }
+                    }
+
+                    for(std::vector<int>::iterator local_neighbour = local_neighbours.begin(); local_neighbour != local_neighbours.end(); local_neighbour++) {
+
+                        Neighbour n;
+                        n.from = (int)regions.size() - 1;
+                        n.to = *local_neighbour;
+                        n.similarity = s->get(regions[n.from].id, regions[n.to].id);
+
+                        similarities.push_back(n);
+                    }
+                }
+
+                // Compute regions' rank
+                for(std::vector<Region>::iterator region = regions.begin(); region != regions.end(); ++region) {
+                    // Note: this is inverted from the paper, but we keep the lover region first so it's works
+                    (*region).rank = ((double) rand() / (RAND_MAX)) * ((*region).level);
+                }
+
+            }
+
+            Ptr<SelectiveSearchSegmentation> createSelectiveSearchSegmentation() {
+                Ptr<SelectiveSearchSegmentation> s = makePtr<SelectiveSearchSegmentationImpl>();
+                return s;
+            }
+
+            std::ostream& operator<<(std::ostream& os, const Neighbour& n) {
+                os << "Neighbour[" << n.from << "->" << n.to << "," << n.similarity << "]";
+                return os;
+            }
+
+            std::ostream& operator<<(std::ostream& os, const Region& r) {
+                os << "Region[WID" << r.id << ", L" << r.level << ", merged to " << r.merged_to << ", R:" << r.rank << ", " << r.bounding_box << "]";
+                return os;
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/slic.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/slic.cpp
new file mode 100644
index 00000000..7528f0ff
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/slic.cpp
@@ -0,0 +1,1790 @@
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * SLIC, SLICO Copyright (c) 2013
+ * Radhakrishna Achanta
+ * email : Radhakrishna [dot] Achanta [at] epfl [dot] ch
+ * web : http://ivrl.epfl.ch/people/achanta
+ *
+ * MSLIC Copyright (c) 2016, 2017
+ * Yong-Jin Liu
+ * email : liuyongjin [at] tsinghua [dot] edu [dot] cn
+ * web : http://47.89.51.189/liuyj
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the copyright holders nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+/*
+ "SLIC Superpixels Compared to State-of-the-art Superpixel Methods"
+ Radhakrishna Achanta, Appu Shaji, Kevin Smith, Aurelien Lucchi, Pascal Fua,
+ and Sabine Susstrunk, IEEE TPAMI, Volume 34, Issue 11, Pages 2274-2282,
+ November 2012.
+
+ "SLIC Superpixels" Radhakrishna Achanta, Appu Shaji, Kevin Smith,
+ Aurelien Lucchi, Pascal Fua, and Sabine Süsstrunk, EPFL Technical
+ Report no. 149300, June 2010.
+
+ "Intrinsic Manifold SLIC: A Simple and Efficient Method for Computing
+ Content-Sensitive Superpixels"
+ Yong-Jin Liu, Cheng-Chi Yu, Min-Jing Yu, Ying He,
+ IEEE Transactions on Pattern Analysis and Machine Intelligence,
+ March 2017, Issue 99.
+
+ OpenCV port by: Cristian Balint <cristian dot balint at gmail dot com>
+ */
+
+#include "precomp.hpp"
+
+using namespace std;
+
+
+namespace cv {
+namespace ximgproc {
+
+class SuperpixelSLICImpl : public SuperpixelSLIC
+{
+public:
+
+    SuperpixelSLICImpl( InputArray image, int algorithm, int region_size, float ruler );
+
+    virtual ~SuperpixelSLICImpl() CV_OVERRIDE;
+
+    // perform amount of iteration
+    virtual void iterate( int num_iterations = 10 ) CV_OVERRIDE;
+
+    // get amount of superpixels
+    virtual int getNumberOfSuperpixels() const CV_OVERRIDE;
+
+    // get image with labels
+    virtual void getLabels( OutputArray labels_out ) const CV_OVERRIDE;
+
+    // get mask image with contour
+    virtual void getLabelContourMask( OutputArray image, bool thick_line = true ) const CV_OVERRIDE;
+
+    // enforce connectivity over labels
+    virtual void enforceLabelConnectivity( int min_element_size = 25 ) CV_OVERRIDE;
+
+
+protected:
+
+    // image width
+    int m_width;
+
+    // image width
+    int m_height;
+
+    // image channels
+    int m_nr_channels;
+
+    // algorithm
+    int m_algorithm;
+
+    // region size
+    int m_region_size;
+
+    // compactness
+    float m_ruler;
+
+    // ratio (MSLIC)
+    float m_ratio;
+
+    // split (MSLIC)
+    float m_split;
+
+    // current iter
+    int m_cur_iter;
+
+    // current iter
+    int m_iterations;
+
+
+private:
+
+    // labels no
+    int m_numlabels;
+
+    // stacked channels
+    // of original image
+    vector<Mat> m_chvec;
+
+    // seeds on x
+    vector<float> m_kseedsx;
+
+    // seeds on y
+    vector<float> m_kseedsy;
+
+    // labels storage
+    Mat m_klabels;
+
+    // seeds storage
+    vector< vector<float> > m_kseeds;
+
+    // adaptive k (MSLIC)
+    vector<float> m_adaptk;
+
+    // merge threshold (MSLIC)
+    float m_merge;
+
+    // initialization
+    inline void initialize();
+
+    // detect edges over all channels
+    inline void DetectChEdges( Mat& edgemag );
+
+    // random perturb seeds
+    inline void PerturbSeeds( const Mat& edgemag );
+
+    // fetch seeds
+    inline void GetChSeedsS();
+
+    // fetch seeds
+    inline void GetChSeedsK();
+
+    // SLIC
+    inline void PerformSLIC( const int& num_iterations );
+
+    // SLICO
+    inline void PerformSLICO( const int& num_iterations );
+
+    // MSLIC
+    inline void PerformMSLIC( const int& num_iterations );
+
+    // MSLIC
+    inline void SuperpixelSplit();
+
+};
+
+CV_EXPORTS Ptr<SuperpixelSLIC> createSuperpixelSLIC( InputArray image, int algorithm, int region_size, float ruler )
+{
+    return makePtr<SuperpixelSLICImpl>( image, algorithm, region_size, ruler );
+}
+
+SuperpixelSLICImpl::SuperpixelSLICImpl( InputArray _image, int _algorithm, int _region_size, float _ruler )
+                   : m_algorithm(_algorithm), m_region_size(_region_size), m_ruler(_ruler)
+{
+    if ( _image.isMat() )
+    {
+      Mat image = _image.getMat();
+
+      // image should be valid
+      CV_Assert( !image.empty() );
+
+      // initialize sizes
+      m_width = image.size().width;
+      m_height = image.size().height;
+      m_nr_channels = image.channels();
+
+      // intialize channels
+      split( image, m_chvec );
+    }
+    else if ( _image.isMatVector() )
+    {
+      _image.getMatVector( m_chvec );
+
+      // array should be valid
+      CV_Assert( !m_chvec.empty() );
+
+      // initialize sizes
+      m_width = m_chvec[0].size().width;
+      m_height = m_chvec[0].size().height;
+      m_nr_channels = (int) m_chvec.size();
+    }
+    else
+      CV_Error( Error::StsInternal, "Invalid InputArray." );
+
+    // init
+    initialize();
+}
+
+SuperpixelSLICImpl::~SuperpixelSLICImpl()
+{
+    m_chvec.clear();
+    m_kseeds.clear();
+    m_kseedsx.clear();
+    m_kseedsy.clear();
+    m_klabels.release();
+}
+
+int SuperpixelSLICImpl::getNumberOfSuperpixels() const
+{
+    return m_numlabels;
+}
+
+void SuperpixelSLICImpl::initialize()
+{
+    // total amount of superpixels given its size as input
+    m_numlabels = int(float(m_width * m_height)
+                /  float(m_region_size * m_region_size));
+
+    // initialize seed storage
+    m_kseeds.resize( m_nr_channels );
+
+    // intitialize label storage
+    m_klabels = Mat( m_height, m_width, CV_32S, Scalar::all(0) );
+
+    // perturb seeds is not absolutely necessary,
+    // one can set this flag to false
+    bool perturbseeds = true;
+
+    // storage for edge magnitudes
+    Mat edgemag;
+    if (perturbseeds)
+      DetectChEdges(edgemag);
+
+    if( m_algorithm == SLICO )
+      GetChSeedsK();
+    else if( ( m_algorithm == SLIC ) ||
+             ( m_algorithm == MSLIC ) )
+      GetChSeedsS();
+    else
+      CV_Error( Error::StsInternal, "No such algorithm" );
+
+    // update amount of labels now
+    m_numlabels = (int)m_kseeds[0].size();
+
+    // perturb seeds given edges
+    if (perturbseeds)
+      PerturbSeeds(edgemag);
+
+    if( m_algorithm == MSLIC )
+    {
+      m_merge = 4.0f;
+      m_adaptk.resize( m_numlabels, 1.0f );
+    }
+}
+
+void SuperpixelSLICImpl::iterate( int num_iterations )
+{
+    // store total iterations
+    m_iterations = num_iterations;
+
+    if( m_algorithm == SLICO )
+      PerformSLICO( num_iterations );
+    else if( m_algorithm == SLIC )
+      PerformSLIC( num_iterations );
+    else if( m_algorithm == MSLIC )
+      PerformMSLIC( num_iterations );
+    else
+      CV_Error( Error::StsInternal, "No such algorithm" );
+
+    // re-update amount of labels
+    m_numlabels = (int)m_kseeds[0].size();
+}
+
+void SuperpixelSLICImpl::getLabels(OutputArray labels_out) const
+{
+    labels_out.assign( m_klabels );
+}
+
+void SuperpixelSLICImpl::getLabelContourMask(OutputArray _mask, bool _thick_line) const
+{
+    // default width
+    int line_width = 2;
+
+    if ( !_thick_line ) line_width = 1;
+
+    _mask.create( m_height, m_width, CV_8UC1 );
+    Mat mask = _mask.getMat();
+
+    mask.setTo(0);
+
+    const int dx8[8] = { -1, -1,  0,  1, 1, 1, 0, -1 };
+    const int dy8[8] = {  0, -1, -1, -1, 0, 1, 1,  1 };
+
+    int sz = m_width*m_height;
+
+    vector<bool> istaken(sz, false);
+
+    int mainindex = 0;
+    for( int j = 0; j < m_height; j++ )
+    {
+      for( int k = 0; k < m_width; k++ )
+      {
+        int np = 0;
+        for( int i = 0; i < 8; i++ )
+        {
+          int x = k + dx8[i];
+          int y = j + dy8[i];
+
+          if( (x >= 0 && x < m_width) && (y >= 0 && y < m_height) )
+          {
+            int index = y*m_width + x;
+
+            if( false == istaken[index] )
+            {
+              if( m_klabels.at<int>(j,k) != m_klabels.at<int>(y,x) ) np++;
+            }
+          }
+        }
+        if( np > line_width )
+        {
+           mask.at<char>(j,k) = (uchar)255;
+           istaken[mainindex] = true;
+        }
+        mainindex++;
+      }
+    }
+}
+
+/*
+ * EnforceLabelConnectivity
+ *
+ *   1. finding an adjacent label for each new component at the start
+ *   2. if a certain component is too small, assigning the previously found
+ *      adjacent label to this component, and not incrementing the label.
+ *
+ */
+void SuperpixelSLICImpl::enforceLabelConnectivity( int min_element_size )
+{
+
+    if ( min_element_size == 0 ) return;
+    CV_Assert( min_element_size >= 0 && min_element_size <= 100 );
+
+    vector<float> adaptk( m_numlabels, 1.0f );
+
+    if( m_algorithm == MSLIC )
+    {
+      adaptk.clear();
+    }
+
+    const int dx4[4] = { -1,  0,  1,  0 };
+    const int dy4[4] = {  0, -1,  0,  1 };
+
+    const int sz = m_width * m_height;
+    const int supsz = sz / m_numlabels;
+
+    int div = int(100.0f/(float)min_element_size + 0.5f);
+    int min_sp_sz = max(3, supsz / div);
+
+    Mat nlabels( m_height, m_width, CV_32S, Scalar(INT_MAX) );
+
+    int label = 0;
+    vector<int> xvec(sz);
+    vector<int> yvec(sz);
+
+    // MSLIC
+    int currentlabel;
+    float diffch = 0.0f;
+    vector<float> adjch;
+    vector<float> curch;
+    map<int,int> hashtable;
+
+    if( m_algorithm == MSLIC )
+    {
+      hashtable[-1] = 0;
+      adjch.resize( m_nr_channels, 0 );
+      curch.resize( m_nr_channels, 0 );
+    }
+
+    //adjacent label
+    int adjlabel = 0;
+
+    for( int j = 0; j < m_height; j++ )
+    {
+        for( int k = 0; k < m_width; k++ )
+        {
+            if( nlabels.at<int>(j,k) == INT_MAX )
+            {
+                nlabels.at<int>(j,k) = label;
+                //--------------------
+                // Start a new segment
+                //--------------------
+                xvec[0] = k;
+                yvec[0] = j;
+                currentlabel = m_klabels.at<int>(j,k);
+                //-------------------------------------------------------
+                // Quickly find an adjacent label for use later if needed
+                //-------------------------------------------------------
+                for( int n = 0; n < 4; n++ )
+                {
+                    int x = xvec[0] + dx4[n];
+                    int y = yvec[0] + dy4[n];
+                    if( (x >= 0 && x < m_width) && (y >= 0 && y < m_height) )
+                    {
+                        if( nlabels.at<int>(y,x) != INT_MAX )
+                        {
+                            adjlabel = nlabels.at<int>(y,x);
+                            if( m_algorithm == MSLIC )
+                            {
+                                for( int b = 0; b < m_nr_channels; b++ )
+                                {
+                                  adjch[b] = m_kseeds[b][m_klabels.at<int>(y,x)];
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if( m_algorithm == MSLIC )
+                {
+                    float ssumch = 0.0f;
+                    for( int b = 0; b < m_nr_channels; b++ )
+                    {
+                        curch[b] = m_kseeds[b][m_klabels.at<int>(j,k)];
+                        // squared distance
+                        float diff = curch[b] - adjch[b];
+                        ssumch += diff * diff;
+                    }
+                    // L2 distance with adj
+                    diffch = sqrt( ssumch );
+                    adaptk.push_back( m_adaptk[currentlabel] );
+                }
+
+                int count(1);
+                for( int c = 0; c < count; c++ )
+                {
+                    for( int n = 0; n < 4; n++ )
+                    {
+                        int x = xvec[c] + dx4[n];
+                        int y = yvec[c] + dy4[n];
+
+                        if( (x >= 0 && x < m_width) && (y >= 0 && y < m_height) )
+                        {
+                            if( INT_MAX == nlabels.at<int>(y,x) &&
+                                m_klabels.at<int>(j,k) == m_klabels.at<int>(y,x) )
+                            {
+                                xvec[count] = x;
+                                yvec[count] = y;
+                                nlabels.at<int>(y,x) = label;
+                                count++;
+                            }
+                        }
+                    }
+                }
+                // MSLIC only
+                if( m_algorithm == MSLIC )
+                {
+                  if ( m_cur_iter < m_iterations - 1 )
+                  {
+                      hashtable[label] = count;
+                      //-------------------------------------------------------
+                      // If segment size is less then a limit, or is very similar
+                      // to it's neighbour assign adjacent label found before,
+                      // and decrement label count.
+                      //-------------------------------------------------------
+                      if( ( count <= min_sp_sz ) ||
+                          (
+                            ( diffch < m_merge ) &&
+                            ( hashtable[adjlabel] + hashtable[(int)adaptk.size()-1]
+                           <= 3 * m_region_size * m_region_size )
+                          )
+                        )
+                      {
+                          if( ( diffch < m_merge) &&
+                              ( hashtable[adjlabel] + hashtable[(int)adaptk.size()-1]
+                             <= 3 * m_region_size * m_region_size )
+                            )
+                          {
+                              adaptk[adjlabel] = min( 2.0f, float(adaptk[adjlabel] + adaptk[(int)adaptk.size()-1]) );
+                              hashtable[adjlabel] += hashtable[(int)adaptk.size()-1];
+                          }
+
+                          for( int c = 0; c < count; c++ )
+                          {
+                              nlabels.at<int>(yvec[c],xvec[c]) = adjlabel;
+                          }
+
+                          label--;
+                          adaptk.pop_back();
+                      }
+                  } else
+                  {
+                      //-------------------------------------------------------
+                      // If segment size is less then a limit, assign an
+                      // adjacent label found before, and decrement label count.
+                      //-------------------------------------------------------
+                      if( count <= min_sp_sz )
+                      {
+                          for( int c = 0; c < count; c++ )
+                          {
+                              nlabels.at<int>(yvec[c],xvec[c]) = adjlabel;
+                          }
+                          label--;
+                      }
+                  }
+                // SLIC or SLICO
+                } else
+                {
+                  //-------------------------------------------------------
+                  // If segment size is less then a limit, assign an
+                  // adjacent label found before, and decrement label count.
+                  //-------------------------------------------------------
+                  if( count <= min_sp_sz )
+                  {
+                      for( int c = 0; c < count; c++ )
+                      {
+                          nlabels.at<int>(yvec[c],xvec[c]) = adjlabel;
+                      }
+                      label--;
+                  }
+                }
+                label++;
+            }
+        }
+    }
+    // replace old
+    m_klabels = nlabels;
+    m_numlabels = label;
+
+    m_adaptk.clear();
+    m_adaptk = adaptk;
+}
+
+/*
+ * DetectChEdges
+ */
+inline void SuperpixelSLICImpl::DetectChEdges( Mat &edgemag )
+{
+    Mat dx, dy;
+    Mat S_dx, S_dy;
+
+    for (int c = 0; c < m_nr_channels; c++)
+    {
+        // derivate
+        Sobel( m_chvec[c], dx, CV_32F, 1, 0, 1, 1.0f, 0.0f, BORDER_DEFAULT );
+        Sobel( m_chvec[c], dy, CV_32F, 0, 1, 1, 1.0f, 0.0f, BORDER_DEFAULT );
+
+        // acumulate ^2 derivate
+        MatExpr dx2 = dx.mul(dx);
+        MatExpr dy2 = dy.mul(dy);
+        if (S_dx.empty())
+        {
+            S_dx = dx2;
+            S_dy = dy2;
+        }
+        else
+        {
+            S_dx += dx2;
+            S_dy += dy2;
+        }
+    }
+    // total magnitude
+    edgemag = S_dx + S_dy;
+}
+
+/*
+ * PerturbSeeds
+ */
+inline void SuperpixelSLICImpl::PerturbSeeds( const Mat& edgemag )
+{
+    const int dx8[8] = { -1, -1,  0,  1,  1,  1,  0, -1 };
+    const int dy8[8] = {  0, -1, -1, -1,  0,  1,  1,  1 };
+
+    for( int n = 0; n < m_numlabels; n++ )
+    {
+        int ox = (int)m_kseedsx[n]; //original x
+        int oy = (int)m_kseedsy[n]; //original y
+
+        int storex = ox;
+        int storey = oy;
+        for( int i = 0; i < 8; i++ )
+        {
+            int nx = ox + dx8[i]; //new x
+            int ny = oy + dy8[i]; //new y
+
+            if( nx >= 0 && nx < m_width && ny >= 0 && ny < m_height)
+            {
+                if( edgemag.at<float>(ny,nx) < edgemag.at<float>(storey,storex) )
+                {
+                    storex = nx;
+                    storey = ny;
+                }
+            }
+        }
+        if( storex != ox && storey != oy )
+        {
+            m_kseedsx[n] = (float)storex;
+            m_kseedsy[n] = (float)storey;
+
+            switch ( m_chvec[0].depth() )
+            {
+              case CV_8U:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = m_chvec[b].at<uchar>( storey, storex );
+                break;
+
+              case CV_8S:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = m_chvec[b].at<char>( storey, storex );
+                break;
+
+              case CV_16U:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = m_chvec[b].at<ushort>( storey, storex );
+                break;
+
+              case CV_16S:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = m_chvec[b].at<short>( storey, storex );
+                break;
+
+              case CV_32S:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = (float) m_chvec[b].at<int>( storey, storex );
+                break;
+
+              case CV_32F:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = m_chvec[b].at<float>( storey, storex );
+                break;
+
+              case CV_64F:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = (float) m_chvec[b].at<double>( storey, storex );
+                break;
+
+              default:
+                CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                break;
+            }
+        }
+    }
+}
+
+/*
+ * GetChannelsSeeds_ForGivenStepSize
+ *
+ * The k seed values are
+ * taken as uniform spatial
+ * pixel samples.
+ *
+ */
+inline void SuperpixelSLICImpl::GetChSeedsS()
+{
+    int n = 0;
+    int numseeds = 0;
+
+    int xstrips = int(0.5f + float(m_width) / float(m_region_size) );
+    int ystrips = int(0.5f + float(m_height) / float(m_region_size) );
+
+    int xerr = m_width  - m_region_size*xstrips;
+    int yerr = m_height - m_region_size*ystrips;
+
+    float xerrperstrip = float(xerr) / float(xstrips);
+    float yerrperstrip = float(yerr) / float(ystrips);
+
+    int xoff = m_region_size / 2;
+    int yoff = m_region_size / 2;
+
+    numseeds = xstrips*ystrips;
+
+    for ( int b = 0; b < m_nr_channels; b++ )
+      m_kseeds[b].resize(numseeds);
+
+    m_kseedsx.resize(numseeds);
+    m_kseedsy.resize(numseeds);
+
+    for( int y = 0; y < ystrips; y++ )
+    {
+        int ye = y * (int)yerrperstrip;
+        int Y = y*m_region_size + yoff+ye;
+        if( Y > m_height-1 ) continue;
+        for( int x = 0; x < xstrips; x++ )
+        {
+            int xe = x * (int)xerrperstrip;
+            int X = x*m_region_size + xoff+xe;
+            if( X > m_width-1 ) continue;
+
+            switch ( m_chvec[0].depth() )
+            {
+              case CV_8U:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = m_chvec[b].at<uchar>(Y,X);
+                break;
+
+              case CV_8S:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = m_chvec[b].at<char>(Y,X);
+                break;
+
+              case CV_16U:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = m_chvec[b].at<ushort>(Y,X);
+                break;
+
+              case CV_16S:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = m_chvec[b].at<short>(Y,X);
+                break;
+
+              case CV_32S:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = (float) m_chvec[b].at<int>(Y,X);
+                break;
+
+              case CV_32F:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = m_chvec[b].at<float>(Y,X);
+                break;
+
+              case CV_64F:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b][n] = (float) m_chvec[b].at<double>(Y,X);
+                break;
+
+              default:
+                CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                break;
+            }
+
+            m_kseedsx[n] = (float)X;
+            m_kseedsy[n] = (float)Y;
+
+            n++;
+        }
+    }
+}
+
+/*
+ * GetChannlesSeeds_ForGivenK
+ *
+ * The k seed values are
+ * taken as uniform spatial
+ * pixel samples.
+ *
+ */
+inline void SuperpixelSLICImpl::GetChSeedsK()
+{
+    int xoff = m_region_size / 2;
+    int yoff = m_region_size / 2;
+    int n = 0; int r = 0;
+    for( int y = 0; y < m_height; y++ )
+    {
+        int Y = y*m_region_size + yoff;
+        if( Y > m_height-1 ) continue;
+        for( int x = 0; x < m_width; x++ )
+        {
+            // hex grid
+            int X = x*m_region_size + ( xoff<<( r & 0x1) );
+            if( X > m_width-1 ) continue;
+
+            switch ( m_chvec[0].depth() )
+            {
+              case CV_8U:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b].push_back( m_chvec[b].at<uchar>(Y,X) );
+                break;
+
+              case CV_8S:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b].push_back( m_chvec[b].at<char>(Y,X) );
+                break;
+
+              case CV_16U:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b].push_back( m_chvec[b].at<ushort>(Y,X) );
+                break;
+
+              case CV_16S:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b].push_back( m_chvec[b].at<short>(Y,X) );
+                break;
+
+              case CV_32S:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b].push_back( (float) m_chvec[b].at<int>(Y,X) );
+                break;
+
+              case CV_32F:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b].push_back( m_chvec[b].at<float>(Y,X) );
+                break;
+
+              case CV_64F:
+                for( int b = 0; b < m_nr_channels; b++ )
+                  m_kseeds[b].push_back( (float) m_chvec[b].at<double>(Y,X) );
+                break;
+
+              default:
+                CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                break;
+            }
+
+            m_kseedsx.push_back((float)X);
+            m_kseedsy.push_back((float)Y);
+
+            n++;
+        }
+        r++;
+    }
+}
+
+struct SeedNormInvoker : ParallelLoopBody
+{
+    SeedNormInvoker( vector< vector<float> >* _kseeds, vector< vector<float> >* _sigma,
+                     vector<int>* _clustersize, vector<float>* _sigmax, vector<float>* _sigmay,
+                     vector<float>* _kseedsx, vector<float>* _kseedsy, int _nr_channels )
+    {
+      sigma = _sigma;
+      kseeds = _kseeds;
+      sigmax = _sigmax;
+      sigmay = _sigmay;
+      kseedsx = _kseedsx;
+      kseedsy = _kseedsy;
+      nr_channels = _nr_channels;
+      clustersize = _clustersize;
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      for (int k = range.start; k < range.end; ++k)
+      {
+            if( clustersize->at(k) <= 0 ) clustersize->at(k) = 1;
+
+            for ( int b = 0; b < nr_channels; b++ )
+              kseeds->at(b)[k] = sigma->at(b)[k] / float(clustersize->at(k));
+
+            kseedsx->at(k) = sigmax->at(k) / float(clustersize->at(k));
+            kseedsy->at(k) = sigmay->at(k) / float(clustersize->at(k));
+      } // end for k
+    }
+    vector<float>* sigmax;
+    vector<float>* sigmay;
+    vector<float>* kseedsx;
+    vector<float>* kseedsy;
+    vector<int>* clustersize;
+    vector< vector<float> >* sigma;
+    vector< vector<float> >* kseeds;
+    int nr_channels;
+};
+
+struct SeedsCenters
+{
+    SeedsCenters( const vector<Mat>& _chvec, const Mat& _klabels,
+                  const int _numlabels, const int _nr_channels )
+    {
+      chvec = _chvec;
+      klabels = _klabels;
+      numlabels = _numlabels;
+      nr_channels = _nr_channels;
+
+      // allocate and init arrays
+      sigma.resize(nr_channels);
+      for( int b =0 ; b < nr_channels ; b++ )
+        sigma[b].assign(numlabels, 0);
+
+      sigmax.assign(numlabels, 0);
+      sigmay.assign(numlabels, 0);
+      clustersize.assign(numlabels, 0);
+    }
+
+    SeedsCenters( const SeedsCenters& counter, Split )
+    {
+      *this = counter;
+      // refill with zero all arrays
+      for( int b = 0; b < nr_channels; b++ )
+        fill(sigma[b].begin(), sigma[b].end(), 0.0f);
+
+      fill(sigmax.begin(), sigmax.end(), 0.0f);
+      fill(sigmay.begin(), sigmay.end(), 0.0f);
+      fill(clustersize.begin(), clustersize.end(), 0);
+    }
+
+    void operator()( const BlockedRange& range )
+    {
+      // previous block state
+      vector<float> tmp_sigmax = sigmax;
+      vector<float> tmp_sigmay = sigmay;
+      vector<vector <float> > tmp_sigma = sigma;
+      vector<int> tmp_clustersize = clustersize;
+
+      for ( int x = range.begin(); x != range.end(); x++ )
+      {
+        for( int y = 0; y < chvec[0].rows; y++ )
+        {
+            int idx = klabels.at<int>(y,x);
+
+            switch ( chvec[0].depth() )
+            {
+              case CV_8U:
+                for( int b = 0; b < nr_channels; b++ )
+                  tmp_sigma[b][idx] += chvec[b].at<uchar>(y,x);
+                break;
+
+              case CV_8S:
+                for( int b = 0; b < nr_channels; b++ )
+                  tmp_sigma[b][idx] += chvec[b].at<char>(y,x);
+                break;
+
+              case CV_16U:
+                for( int b = 0; b < nr_channels; b++ )
+                  tmp_sigma[b][idx] += chvec[b].at<ushort>(y,x);
+                break;
+
+              case CV_16S:
+                for( int b = 0; b < nr_channels; b++ )
+                  tmp_sigma[b][idx] += chvec[b].at<short>(y,x);
+                break;
+
+              case CV_32S:
+                for( int b = 0; b < nr_channels; b++ )
+                  tmp_sigma[b][idx] += chvec[b].at<int>(y,x);
+                break;
+
+              case CV_32F:
+                for( int b = 0; b < nr_channels; b++ )
+                  tmp_sigma[b][idx] += chvec[b].at<float>(y,x);
+                break;
+
+              case CV_64F:
+                for( int b = 0; b < nr_channels; b++ )
+                  tmp_sigma[b][idx] += (float) chvec[b].at<double>(y,x);
+                break;
+
+              default:
+                CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                break;
+            }
+
+            tmp_sigmax[idx] += x;
+            tmp_sigmay[idx] += y;
+
+            tmp_clustersize[idx]++;
+
+        }
+      }
+      sigma = tmp_sigma;
+      sigmax = tmp_sigmax;
+      sigmay = tmp_sigmay;
+      clustersize = tmp_clustersize;
+    }
+
+    void join( SeedsCenters& sc )
+    {
+      for (int l = 0; l < numlabels; l++)
+      {
+        sigmax[l] += sc.sigmax[l];
+        sigmay[l] += sc.sigmay[l];
+        for( int b = 0; b < nr_channels; b++ )
+            sigma[b][l] += sc.sigma[b][l];
+        clustersize[l] += sc.clustersize[l];
+      }
+    }
+
+    Mat klabels;
+    int numlabels;
+    int nr_channels;
+    vector<Mat> chvec;
+    vector<float> sigmax;
+    vector<float> sigmay;
+    vector<int> clustersize;
+    vector< vector<float> > sigma;
+};
+
+struct SLICOGrowInvoker : ParallelLoopBody
+{
+    SLICOGrowInvoker( vector<Mat>* _chvec, Mat* _distchans, Mat* _distxy, Mat* _distvec,
+                      Mat* _klabels, float _kseedsxn, float _kseedsyn, float _xywt,
+                      float _maxchansn, vector< vector<float> > *_kseeds,
+                      int _x1, int _x2, int _nr_channels, int _n )
+    {
+      chvec = _chvec;
+      distchans = _distchans;
+      distxy = _distxy;
+      distvec = _distvec;
+      kseedsxn = _kseedsxn;
+      kseedsyn = _kseedsyn;
+      klabels = _klabels;
+      maxchansn = _maxchansn;
+      kseeds = _kseeds;
+      x1 = _x1;
+      x2 = _x2;
+      n = _n;
+      xywt = _xywt;
+      nr_channels = _nr_channels;
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      int cols = klabels->cols;
+      int rows = klabels->rows;
+      for (int y = range.start; y < range.end; ++y)
+      {
+        for( int x = x1; x < x2; x++ )
+        {
+          CV_Assert( y < rows && x < cols && y >= 0 && x >= 0 );
+          distchans->at<float>(y,x) = 0;
+
+            switch ( chvec->at(0).depth() )
+            {
+              case CV_8U:
+                for( int b = 0; b < nr_channels; b++ )
+                {
+                  float diff = chvec->at(b).at<uchar>(y,x)
+                             - kseeds->at(b)[n];
+                  distchans->at<float>(y,x) += diff * diff;
+                }
+                break;
+
+              case CV_8S:
+                for( int b = 0; b < nr_channels; b++ )
+                {
+                  float diff = chvec->at(b).at<char>(y,x)
+                             - kseeds->at(b)[n];
+                  distchans->at<float>(y,x) += diff * diff;
+                }
+                break;
+
+              case CV_16U:
+                for( int b = 0; b < nr_channels; b++ )
+                {
+                  float diff = chvec->at(b).at<ushort>(y,x)
+                             - kseeds->at(b)[n];
+                  distchans->at<float>(y,x) += diff * diff;
+                }
+                break;
+
+              case CV_16S:
+                for( int b = 0; b < nr_channels; b++ )
+                {
+                  float diff = chvec->at(b).at<short>(y,x)
+                             - kseeds->at(b)[n];
+                  distchans->at<float>(y,x) += diff * diff;
+                }
+                break;
+
+              case CV_32S:
+                for( int b = 0; b < nr_channels; b++ )
+                {
+                  float diff = chvec->at(b).at<int>(y,x)
+                             - kseeds->at(b)[n];
+                  distchans->at<float>(y,x) += diff * diff;
+                }
+                break;
+
+              case CV_32F:
+                for( int b = 0; b < nr_channels; b++ )
+                {
+                  float diff = chvec->at(b).at<float>(y,x)
+                             - kseeds->at(b)[n];
+                  distchans->at<float>(y,x) += diff * diff;
+                }
+                break;
+
+              case CV_64F:
+                for( int b = 0; b < nr_channels; b++ )
+                {
+                  float diff = float(chvec->at(b).at<double>(y,x)
+                             - kseeds->at(b)[n]);
+                  distchans->at<float>(y,x) += diff * diff;
+                }
+                break;
+
+              default:
+                CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                break;
+            }
+
+
+          float difx = x - kseedsxn;
+          float dify = y - kseedsyn;
+          distxy->at<float>(y,x) = difx*difx + dify*dify;
+
+          // only varying m, prettier superpixels
+          float dist = distchans->at<float>(y,x)
+                     / maxchansn + distxy->at<float>(y,x)/xywt;
+
+          if( dist < distvec->at<float>(y,x) )
+          {
+            distvec->at<float>(y,x) = dist;
+            klabels->at<int>(y,x) = n;
+          }
+        } // end for x
+      } // end for y
+    }
+
+    Mat* klabels;
+    vector< vector<float> > *kseeds;
+    float maxchansn, xywt;
+    vector<Mat>* chvec;
+    Mat *distchans, *distxy, *distvec;
+    float kseedsxn, kseedsyn;
+    int x1, x2, nr_channels, n;
+};
+
+/*
+ *
+ *    Magic SLIC - no parameters
+ *
+ *    Performs k mean segmentation. It is fast because it looks locally, not
+ * over the entire image.
+ * This function picks the maximum value of color distance as compact factor
+ * M and maximum pixel distance as grid step size S from each cluster (13 April 2011).
+ * So no need to input a constant value of M and S. There are two clear
+ * advantages:
+ *
+ * [1] The algorithm now better handles both textured and non-textured regions
+ * [2] There is not need to set any parameters!!!
+ *
+ * SLICO (or SLIC Zero) dynamically varies only the compactness factor S,
+ * not the step size S.
+ *
+ */
+inline void SuperpixelSLICImpl::PerformSLICO( const int&  itrnum )
+{
+    Mat distxy( m_height, m_width, CV_32F, Scalar::all(FLT_MAX) );
+    Mat distvec( m_height, m_width, CV_32F, Scalar::all(FLT_MAX) );
+    Mat distchans( m_height, m_width, CV_32F, Scalar::all(FLT_MAX) );
+
+    // this is the variable value of M, just start with 10
+    vector<float> maxchans( m_numlabels, FLT_MIN );
+    // this is the variable value of M, just start with 10
+    vector<float> maxxy( m_numlabels, FLT_MIN );
+    // note: this is different from how usual SLIC/LKM works
+    const float xywt = float(m_region_size*m_region_size);
+
+    for( int itr = 0; itr < itrnum; itr++ )
+    {
+        distvec.setTo(FLT_MAX);
+        for( int n = 0; n < m_numlabels; n++ )
+        {
+            int y1 = max(0, (int) m_kseedsy[n] - m_region_size);
+            int y2 = min(m_height, (int) m_kseedsy[n] + m_region_size);
+            int x1 = max(0, (int) m_kseedsx[n] - m_region_size);
+            int x2 = min((int) m_width,(int) m_kseedsx[n] + m_region_size);
+
+            parallel_for_( Range(y1, y2), SLICOGrowInvoker( &m_chvec, &distchans, &distxy, &distvec,
+                           &m_klabels, m_kseedsx[n], m_kseedsy[n], xywt, maxchans[n], &m_kseeds,
+                           x1, x2, m_nr_channels, n ) );
+        }
+        //-----------------------------------------------------------------
+        // Assign the max color distance for a cluster
+        //-----------------------------------------------------------------
+        if( itr == 0 )
+        {
+            maxchans.assign(m_numlabels,FLT_MIN);
+            maxxy.assign(m_numlabels,FLT_MIN);
+        }
+
+        for( int x = 0; x < m_width; x++ )
+        {
+          for( int y = 0; y < m_height; y++ )
+          {
+              int idx = m_klabels.at<int>(y,x);
+
+              if( maxchans[idx] < distchans.at<float>(y,x) )
+                  maxchans[idx] = distchans.at<float>(y,x);
+
+              if( maxxy[idx] < distxy.at<float>(y,x) )
+                  maxxy[idx] = distxy.at<float>(y,x);
+          }
+        }
+        //-----------------------------------------------------------------
+        // Recalculate the centroid and store in the seed values
+        //-----------------------------------------------------------------
+
+        // parallel reduce structure
+        SeedsCenters sc( m_chvec, m_klabels, m_numlabels, m_nr_channels );
+
+        // accumulate center distances
+        parallel_reduce( BlockedRange(0, m_width), sc );
+
+        // normalize centers
+        parallel_for_( Range(0, m_numlabels), SeedNormInvoker( &m_kseeds, &sc.sigma,
+                       &sc.clustersize, &sc.sigmax, &sc.sigmay, &m_kseedsx, &m_kseedsy, m_nr_channels  ) );
+
+    }
+}
+
+struct SLICGrowInvoker : ParallelLoopBody
+{
+    SLICGrowInvoker( vector<Mat>* _chvec, Mat* _distvec, Mat* _klabels,
+                     float _kseedsxn, float _kseedsyn, float _xywt,
+                     vector< vector<float> > *_kseeds, int _x1, int _x2,
+                     int _nr_channels, int _n )
+    {
+      chvec = _chvec;
+      distvec = _distvec;
+      kseedsxn = _kseedsxn;
+      kseedsyn = _kseedsyn;
+      klabels = _klabels;
+      kseeds = _kseeds;
+      x1 = _x1;
+      x2 = _x2;
+      n = _n;
+      xywt = _xywt;
+      nr_channels = _nr_channels;
+    }
+
+    void operator ()(const cv::Range& range) const CV_OVERRIDE
+    {
+      for (int y = range.start; y < range.end; ++y)
+      {
+        for( int x = x1; x < x2; x++ )
+        {
+          float dist = 0;
+
+          switch ( chvec->at(0).depth() )
+          {
+            case CV_8U:
+              for( int b = 0; b < nr_channels; b++ )
+              {
+                float diff = chvec->at(b).at<uchar>(y,x) - kseeds->at(b)[n];
+                dist += diff * diff;
+              }
+              break;
+
+            case CV_8S:
+              for( int b = 0; b < nr_channels; b++ )
+              {
+                float diff = chvec->at(b).at<char>(y,x) - kseeds->at(b)[n];
+                dist += diff * diff;
+              }
+              break;
+
+            case CV_16U:
+              for( int b = 0; b < nr_channels; b++ )
+              {
+                float diff = chvec->at(b).at<ushort>(y,x) - kseeds->at(b)[n];
+                dist += diff * diff;
+              }
+              break;
+
+            case CV_16S:
+              for( int b = 0; b < nr_channels; b++ )
+              {
+                float diff = chvec->at(b).at<short>(y,x) - kseeds->at(b)[n];
+                dist += diff * diff;
+              }
+              break;
+
+            case CV_32S:
+              for( int b = 0; b < nr_channels; b++ )
+              {
+                float diff = chvec->at(b).at<int>(y,x) - kseeds->at(b)[n];
+                dist += diff * diff;
+              }
+              break;
+
+            case CV_32F:
+              for( int b = 0; b < nr_channels; b++ )
+              {
+                float diff = chvec->at(b).at<float>(y,x) - kseeds->at(b)[n];
+                dist += diff * diff;
+              }
+              break;
+
+            case CV_64F:
+              for( int b = 0; b < nr_channels; b++ )
+              {
+                float diff = float(chvec->at(b).at<double>(y,x) - kseeds->at(b)[n]);
+                dist += diff * diff;
+              }
+              break;
+
+            default:
+              CV_Error( Error::StsInternal, "Invalid matrix depth" );
+              break;
+          }
+
+          float difx = x - kseedsxn;
+          float dify = y - kseedsyn;
+          float distxy = difx*difx + dify*dify;
+
+          dist += distxy / xywt;
+
+          //this would be more exact but expensive
+          //dist = sqrt(dist) + sqrt(distxy/xywt);
+
+          if( dist < distvec->at<float>(y,x) )
+          {
+            distvec->at<float>(y,x) = dist;
+            klabels->at<int>(y,x) = n;
+          }
+        } //end for x
+      } // end for y
+    }
+
+    Mat* klabels;
+    vector< vector<float> > *kseeds;
+    float xywt;
+    vector<Mat>* chvec;
+    Mat *distvec;
+    float kseedsxn, kseedsyn;
+    int x1, x2, nr_channels, n;
+};
+
+/*
+ *    PerformSuperpixelSLIC
+ *
+ *    Performs k mean segmentation. It is fast because it looks locally, not
+ * over the entire image.
+ *
+ */
+inline void SuperpixelSLICImpl::PerformSLIC( const int&  itrnum )
+{
+    Mat distvec( m_height, m_width, CV_32F );
+
+    const float xywt = (m_region_size/m_ruler)*(m_region_size/m_ruler);
+
+    for( int itr = 0; itr < itrnum; itr++ )
+    {
+        distvec.setTo(FLT_MAX);
+        for( int n = 0; n < m_numlabels; n++ )
+        {
+            int y1 = max(0, (int) m_kseedsy[n] - m_region_size);
+            int y2 = min(m_height, (int) m_kseedsy[n] + m_region_size);
+            int x1 = max(0, (int) m_kseedsx[n] - m_region_size);
+            int x2 = min((int) m_width,(int) m_kseedsx[n] + m_region_size);
+
+            parallel_for_( Range(y1, y2), SLICGrowInvoker( &m_chvec, &distvec,
+                           &m_klabels, m_kseedsx[n], m_kseedsy[n], xywt, &m_kseeds,
+                           x1, x2, m_nr_channels, n ) );
+        }
+
+        //-----------------------------------------------------------------
+        // Recalculate the centroid and store in the seed values
+        //-----------------------------------------------------------------
+        // instead of reassigning memory on each iteration, just reset.
+
+        // parallel reduce structure
+        SeedsCenters sc( m_chvec, m_klabels, m_numlabels, m_nr_channels );
+
+        // accumulate center distances
+        parallel_reduce( BlockedRange(0, m_width), sc );
+
+        // normalize centers
+        parallel_for_( Range(0, m_numlabels), SeedNormInvoker( &m_kseeds, &sc.sigma,
+                       &sc.clustersize, &sc.sigmax, &sc.sigmay, &m_kseedsx, &m_kseedsy, m_nr_channels  ) );
+
+    }
+}
+
+/*
+ *    PerformSuperpixelMSLIC
+ *
+ *
+ */
+inline void SuperpixelSLICImpl::PerformMSLIC( const int&  itrnum )
+{
+    vector< vector<float> > sigma(m_nr_channels);
+    for( int b = 0; b < m_nr_channels; b++ )
+      sigma[b].resize(m_numlabels, 0);
+
+    Mat distvec( m_height, m_width, CV_32F );
+
+    const float xywt = (m_region_size/m_ruler)*(m_region_size/m_ruler);
+
+    int offset = m_region_size;
+
+    // from paper
+    m_split = 4.0f;
+    m_ratio = 5.0f;
+
+    for( int itr = 0; itr < itrnum; itr++ )
+    {
+        m_cur_iter = itr;
+
+        distvec.setTo(FLT_MAX);
+        for( int n = 0; n < m_numlabels; n++ )
+        {
+            if ( m_adaptk[n] < 1.0f )
+                offset = int(m_region_size * m_adaptk[n]);
+            else
+                offset = int(m_region_size * m_adaptk[n]);
+
+            int y1 = max(0,        (int) m_kseedsy[n] - offset);
+            int y2 = min(m_height, (int) m_kseedsy[n] + offset);
+            int x1 = max(0,        (int) m_kseedsx[n] - offset);
+            int x2 = min(m_width,  (int) m_kseedsx[n] + offset);
+
+            parallel_for_( Range(y1, y2), SLICGrowInvoker( &m_chvec, &distvec,
+                           &m_klabels, m_kseedsx[n], m_kseedsy[n], xywt, &m_kseeds,
+                           x1, x2, m_nr_channels, n ) );
+        }
+
+        //-----------------------------------------------------------------
+        // Recalculate the centroid and store in the seed values
+        //-----------------------------------------------------------------
+        // instead of reassigning memory on each iteration, just reset.
+
+        // parallel reduce structure
+        SeedsCenters sc( m_chvec, m_klabels, m_numlabels, m_nr_channels );
+
+        // accumulate center distances
+        parallel_reduce( BlockedRange(0, m_width), sc );
+
+        // normalize centers
+        parallel_for_( Range(0, m_numlabels), SeedNormInvoker( &m_kseeds, &sc.sigma,
+                       &sc.clustersize, &sc.sigmax, &sc.sigmay, &m_kseedsx, &m_kseedsy, m_nr_channels ) );
+
+        // 13% as in original paper
+        enforceLabelConnectivity( 13 );
+        SuperpixelSplit();
+    }
+}
+
+inline void SuperpixelSLICImpl::SuperpixelSplit()
+{
+    Mat klabels = m_klabels.clone();
+
+    // parallel reduce structure
+    SeedsCenters msc( m_chvec, m_klabels, m_numlabels, m_nr_channels );
+
+    // accumulate center distances
+    parallel_reduce( BlockedRange(0, m_width), msc );
+
+    const float invwt = 1.0f / ( (m_region_size/m_ruler)*(m_region_size/m_ruler) );
+    const float sqrt_invwt = sqrt(invwt);
+
+    if ( m_cur_iter < m_iterations - 2 )
+    {
+        vector<float> avglabs( m_numlabels, 0 );
+        for( int y = 0; y < m_height - 1; y++ )
+        {
+            for( int x = 0; x < m_width - 1; x++ )
+            {
+                if ( klabels.at<int>( y, x ) == klabels.at<int>( y+1, x ) &&
+                     klabels.at<int>( y, x ) == klabels.at<int>( y, x+1 ) )
+                {
+                    float x1 = 1, y1 = 0;
+                    float x2 = 0, y2 = 1;
+
+                    vector<float> ch1(m_nr_channels);
+                    vector<float> ch2(m_nr_channels);
+
+                    switch ( m_chvec.at(0).depth() )
+                    {
+                      case CV_8U:
+                        for( int c = 0; c < m_nr_channels; c++ )
+                        {
+                            ch1[c] = float( m_chvec[c].at<uchar>( y+1, x   )
+                                          - m_chvec[c].at<uchar>( y,   x   ) );
+                            ch2[c] = float( m_chvec[c].at<uchar>( y,   x+1 )
+                                          - m_chvec[c].at<uchar>( y,   x   ) );
+
+                            ch1[c] /= sqrt_invwt;
+                            ch2[c] /= sqrt_invwt;
+                        }
+                        break;
+
+                      case CV_8S:
+                        for( int c = 0; c < m_nr_channels; c++ )
+                        {
+                            ch1[c] = float( m_chvec[c].at<char>( y+1, x   )
+                                          - m_chvec[c].at<char>( y,   x   ) );
+                            ch2[c] = float( m_chvec[c].at<char>( y,   x+1 )
+                                          - m_chvec[c].at<char>( y,   x   ) );
+
+                            ch1[c] /= sqrt_invwt;
+                            ch2[c] /= sqrt_invwt;
+                        }
+                        break;
+
+                      case CV_16U:
+                        for( int c = 0; c < m_nr_channels; c++ )
+                        {
+                            ch1[c] = float( m_chvec[c].at<ushort>( y+1, x   )
+                                          - m_chvec[c].at<ushort>( y,   x   ) );
+                            ch2[c] = float( m_chvec[c].at<ushort>( y,   x+1 )
+                                          - m_chvec[c].at<ushort>( y,   x   ) );
+
+                            ch1[c] /= sqrt_invwt;
+                            ch2[c] /= sqrt_invwt;
+                        }
+                        break;
+
+                      case CV_16S:
+                        for( int c = 0; c < m_nr_channels; c++ )
+                        {
+                            ch1[c] = float( m_chvec[c].at<short>( y+1, x   )
+                                          - m_chvec[c].at<short>( y,   x   ) );
+                            ch2[c] = float( m_chvec[c].at<short>( y,   x+1 )
+                                          - m_chvec[c].at<short>( y,   x   ) );
+
+                            ch1[c] /= sqrt_invwt;
+                            ch2[c] /= sqrt_invwt;
+                        }
+                        break;
+
+                      case CV_32S:
+                        for( int c = 0; c < m_nr_channels; c++ )
+                        {
+                            ch1[c] = float( m_chvec[c].at<int>( y+1, x   )
+                                          - m_chvec[c].at<int>( y,   x   ) );
+                            ch2[c] = float( m_chvec[c].at<int>( y,   x+1 )
+                                          - m_chvec[c].at<int>( y,   x   ) );
+
+                            ch1[c] /= sqrt_invwt;
+                            ch2[c] /= sqrt_invwt;
+                        }
+                        break;
+
+                      case CV_32F:
+                        for( int c = 0; c < m_nr_channels; c++ )
+                        {
+                            ch1[c] = m_chvec[c].at<float>( y+1, x   )
+                                   - m_chvec[c].at<float>( y,   x   );
+                            ch2[c] = m_chvec[c].at<float>( y,   x+1 )
+                                   - m_chvec[c].at<float>( y,   x   );
+
+                            ch1[c] /= sqrt_invwt;
+                            ch2[c] /= sqrt_invwt;
+                        }
+                        break;
+
+                      case CV_64F:
+                        for( int c = 0; c < m_nr_channels; c++ )
+                        {
+                            ch1[c] = float( m_chvec[c].at<double>( y+1, x   )
+                                          - m_chvec[c].at<double>( y,   x   ) );
+                            ch2[c] = float( m_chvec[c].at<double>( y,   x+1 )
+                                          - m_chvec[c].at<double>( y,   x   ) );
+
+                            ch1[c] /= sqrt_invwt;
+                            ch2[c] /= sqrt_invwt;
+                        }
+                        break;
+
+                      default:
+                        CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                        break;
+                    }
+                    float ch11sqsum = 0.0f;
+                    float ch12sqsum = 0.0f;
+                    float ch22sqsum = 0.0f;
+                    for( int c = 0; c < m_nr_channels; c++ )
+                    {
+                       ch11sqsum += ch1[c]*ch1[c];
+                       ch12sqsum += ch1[c]*ch2[c];
+                       ch22sqsum += ch2[c]*ch2[c];
+                    }
+
+                    // adjacent metric for N channels
+                    avglabs[ klabels.at<int>(y,x) ]
+                              += sqrt(   (x1*x1 + y1*y1 + ch11sqsum) * (x2*x2 + y2*y2 + ch22sqsum)
+                                       - (x1*x2 + y1*y2 + ch12sqsum) * (x1*x2 + y1*y2 + ch12sqsum) );
+                }
+             }
+        }
+        for ( int i = 0; i < m_numlabels; i++ )
+        {
+            avglabs[i] /= m_region_size * m_region_size;
+        }
+
+        m_kseedsx.clear();
+        m_kseedsy.clear();
+        m_kseedsx.resize( m_numlabels, 0 );
+        m_kseedsy.resize( m_numlabels, 0 );
+        for( int c = 0; c < m_nr_channels; c++ )
+        {
+          m_kseeds[c].clear();
+          m_kseeds[c].resize( m_numlabels, 0 );
+        }
+
+        for( int k = 0; k < m_numlabels; k++ )
+        {
+            m_kseedsx[k] = msc.sigmax[k] / msc.clustersize[k];
+            m_kseedsy[k] = msc.sigmay[k] / msc.clustersize[k];
+            for( int c = 0; c < m_nr_channels; c++ )
+                m_kseeds[c][k] = msc.sigma[c][k] / msc.clustersize[k];
+        }
+
+        for( int k = 0; k < m_numlabels; k++ )
+        {
+            int xindex = 0, yindex = 0;
+            if ( ( m_adaptk[k] <= 0.5f ) ||
+                 ( avglabs[k] < (m_split * m_ratio) ) )
+            {
+                m_kseedsx[k] = msc.sigmax[k] / msc.clustersize[k];
+                m_kseedsy[k] = msc.sigmay[k] / msc.clustersize[k];
+                for( int c = 0; c < m_nr_channels; c++ )
+                  m_kseeds[c][k] = msc.sigma[c][k] / msc.clustersize[k];
+
+                m_adaptk[k] = sqrt( m_ratio / avglabs[k] );
+                m_adaptk[k] = max( 0.5f, m_adaptk[k] );
+                m_adaptk[k] = min( 2.0f, m_adaptk[k] );
+            }
+            // if segment size is too large
+            // split it and calculate four new seeds
+            else
+            {
+                xindex = (int)( msc.sigmax[k] / msc.clustersize[k] );
+                yindex = (int)( msc.sigmay[k] / msc.clustersize[k] );
+                m_adaptk[k] = max( 0.5f, m_adaptk[k] / 2 );
+
+                const float minadaptk = min( 1.0f, m_adaptk[k] ) * m_region_size / 2;
+
+                int x1 = (int)( xindex - minadaptk );
+                int x2 = (int)( xindex + minadaptk );
+                int x3 = (int)( xindex - minadaptk );
+                int x4 = (int)( xindex + minadaptk );
+
+                int y1 = (int)( yindex + minadaptk );
+                int y2 = (int)( yindex + minadaptk );
+                int y3 = (int)( yindex - minadaptk );
+                int y4 = (int)( yindex - minadaptk );
+
+                if ( x1 < 0         ) x1 = 0;
+                if ( x2 >= m_width  ) x2 = m_width  - 1;
+                if ( x3 < 0         ) x3 = 0;
+                if ( x4 >= m_width  ) x4 = m_width  - 1;
+                if ( y1 >= m_height ) y1 = m_height - 1;
+                if ( y2 >= m_height ) y2 = m_height - 1;
+                if ( y3 < 0         ) y3 = 0;
+                if ( y4 < 0         ) y4 = 0;
+
+                m_kseedsx[k] = (float)x1;
+                m_kseedsy[k] = (float)y1;
+                for( int c = 0; c < m_nr_channels; c++ )
+                {
+                    switch ( m_chvec[c].depth() )
+                    {
+                      case CV_8U:
+                        m_kseeds[c][k] = m_chvec[c].at<uchar>(y1,x1);
+                        break;
+
+                      case CV_8S:
+                        m_kseeds[c][k] = m_chvec[c].at<char>(y1,x1);
+                        break;
+
+                      case CV_16U:
+                        m_kseeds[c][k] = m_chvec[c].at<ushort>(y1,x1);
+                        break;
+
+                      case CV_16S:
+                        m_kseeds[c][k] = m_chvec[c].at<short>(y1,x1);
+                        break;
+
+                      case CV_32S:
+                        m_kseeds[c][k] = float(m_chvec[c].at<int>(y1,x1));
+                        break;
+
+                      case CV_32F:
+                        m_kseeds[c][k] = m_chvec[c].at<float>(y1,x1);
+                        break;
+
+                      case CV_64F:
+                        m_kseeds[c][k] = float(m_chvec[c].at<double>(y1,x1));
+                        break;
+
+                      default:
+                        CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                        break;
+                    }
+                }
+
+                m_kseedsx.push_back( (float)x2 );
+                m_kseedsx.push_back( (float)x3 );
+                m_kseedsx.push_back( (float)x4 );
+                m_kseedsy.push_back( (float)y2 );
+                m_kseedsy.push_back( (float)y3 );
+                m_kseedsy.push_back( (float)y4 );
+
+                for( int c = 0; c < m_nr_channels; c++ )
+                {
+                    switch ( m_chvec[c].depth() )
+                    {
+                      case CV_8U:
+                        m_kseeds[c].push_back( m_chvec[c].at<uchar>(y2,x2) );
+                        m_kseeds[c].push_back( m_chvec[c].at<uchar>(y3,x3) );
+                        m_kseeds[c].push_back( m_chvec[c].at<uchar>(y4,x4) );
+                        break;
+
+                      case CV_8S:
+                        m_kseeds[c].push_back( m_chvec[c].at<char>(y2,x2) );
+                        m_kseeds[c].push_back( m_chvec[c].at<char>(y3,x3) );
+                        m_kseeds[c].push_back( m_chvec[c].at<char>(y4,x4) );
+                        break;
+
+                      case CV_16U:
+                        m_kseeds[c].push_back( m_chvec[c].at<ushort>(y2,x2) );
+                        m_kseeds[c].push_back( m_chvec[c].at<ushort>(y3,x3) );
+                        m_kseeds[c].push_back( m_chvec[c].at<ushort>(y4,x4) );
+                        break;
+
+                      case CV_16S:
+                        m_kseeds[c].push_back( m_chvec[c].at<short>(y2,x2) );
+                        m_kseeds[c].push_back( m_chvec[c].at<short>(y3,x3) );
+                        m_kseeds[c].push_back( m_chvec[c].at<short>(y4,x4) );
+                        break;
+
+                      case CV_32S:
+                        m_kseeds[c].push_back( float(m_chvec[c].at<int>(y2,x2)) );
+                        m_kseeds[c].push_back( float(m_chvec[c].at<int>(y3,x3)) );
+                        m_kseeds[c].push_back( float(m_chvec[c].at<int>(y4,x4)) );
+                        break;
+
+                      case CV_32F:
+                        m_kseeds[c].push_back( m_chvec[c].at<float>(y2,x2) );
+                        m_kseeds[c].push_back( m_chvec[c].at<float>(y3,x3) );
+                        m_kseeds[c].push_back( m_chvec[c].at<float>(y4,x4) );
+                        break;
+
+                      case CV_64F:
+                        m_kseeds[c].push_back( float(m_chvec[c].at<double>(y2,x2)) );
+                        m_kseeds[c].push_back( float(m_chvec[c].at<double>(y3,x3)) );
+                        m_kseeds[c].push_back( float(m_chvec[c].at<double>(y4,x4)) );
+                        break;
+
+                      default:
+                        CV_Error( Error::StsInternal, "Invalid matrix depth" );
+                        break;
+                    }
+                }
+                m_adaptk.push_back( m_adaptk[k] );
+                m_adaptk.push_back( m_adaptk[k] );
+                m_adaptk.push_back( m_adaptk[k] );
+                msc.clustersize.push_back( 1 );
+                msc.clustersize.push_back( 1 );
+                msc.clustersize.push_back( 1 );
+            }
+        }
+    }
+    else
+    {
+        m_kseedsx.clear();
+        m_kseedsy.clear();
+        m_kseedsx.resize( m_numlabels, 0 );
+        m_kseedsy.resize( m_numlabels, 0 );
+        for( int c = 0; c < m_nr_channels; c++ )
+        {
+          m_kseeds[c].clear();
+          m_kseeds[c].resize( m_numlabels, 0 );
+        }
+
+        for( int k = 0; k < m_numlabels; k++ )
+        {
+            m_kseedsx[k] = msc.sigmax[k] / msc.clustersize[k];
+            m_kseedsy[k] = msc.sigmay[k] / msc.clustersize[k];
+            for( int c = 0; c < m_nr_channels; c++ )
+                m_kseeds[c][k] = msc.sigma[c][k] / msc.clustersize[k];
+        }
+    }
+
+  m_klabels.release();
+  m_klabels = klabels.clone();
+
+  // re-update amount of labels
+  m_numlabels = (int)m_kseeds[0].size();
+
+}
+
+
+} // namespace ximgproc
+} // namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/sparse_match_interpolators.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/sparse_match_interpolators.cpp
new file mode 100644
index 00000000..b12d7767
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/sparse_match_interpolators.cpp
@@ -0,0 +1,1918 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include "opencv2/ximgproc/sparse_match_interpolator.hpp"
+#include "opencv2/video.hpp"
+#include <algorithm>
+#include <vector>
+#include "opencv2/core/hal/hal.hpp"
+
+using namespace std;
+
+#define INF 1E+20F
+
+namespace cv {
+namespace ximgproc {
+
+struct SparseMatch
+{
+    Point2f reference_image_pos;
+    Point2f target_image_pos;
+    SparseMatch(){}
+    SparseMatch(Point2f ref_point, Point2f target_point): reference_image_pos(ref_point), target_image_pos(target_point) {}
+};
+
+bool operator<(const SparseMatch& lhs,const SparseMatch& rhs);
+
+static void computeGradientMagnitude(Mat& src, Mat& dst);
+static void weightedLeastSquaresAffineFit(int* labels, float* weights, int count, float lambda, const SparseMatch* matches, Mat& dst);
+static void generateHypothesis(int* labels, int count, RNG& rng, unsigned char* is_used, SparseMatch* matches, Mat& dst);
+static void verifyHypothesis(int* labels, float* weights, int count, SparseMatch* matches, float eps, float lambda, Mat& hypothesis_transform, Mat& old_transform, float& old_weighted_num_inliers);
+
+struct node
+{
+    float dist;
+    int label;
+    node() {}
+    node(int l,float d): dist(d), label(l) {}
+};
+
+
+
+class EdgeAwareInterpolatorImpl CV_FINAL : public EdgeAwareInterpolator
+{
+public:
+    static Ptr<EdgeAwareInterpolatorImpl> create();
+    void interpolate(InputArray from_image, InputArray from_points, InputArray to_image, InputArray to_points, OutputArray dense_flow) CV_OVERRIDE;
+
+protected:
+    int match_num;
+    int w, h;
+    //internal buffers:
+    vector<node>* g;
+    Mat NNlabels;
+    Mat NNdistances;
+    Mat labels;
+    Mat costMap;
+    //tunable parameters:
+    float lambda;
+    int k;
+    float sigma;
+    bool use_post_proc;
+    float fgs_lambda;
+    float fgs_sigma;
+
+    // static parameters:
+    static const int ransac_interpolation_num_iter = 1;
+    static const int distance_transform_num_iter = 1;
+    float regularization_coef;
+    static const int ransac_num_stripes = 4;
+    RNG rngs[ransac_num_stripes];
+
+    void init();
+    void preprocessData(Mat& src, vector<SparseMatch>& matches);
+    void geodesicDistanceTransform(Mat& distances, Mat& cost_map);
+    void buildGraph(Mat& distances, Mat& cost_map);
+    void ransacInterpolation(vector<SparseMatch>& matches, Mat& dst_dense_flow);
+
+protected:
+    struct GetKNNMatches_ParBody : public ParallelLoopBody
+    {
+        EdgeAwareInterpolatorImpl* inst;
+        int num_stripes;
+        int stripe_sz;
+
+        GetKNNMatches_ParBody(EdgeAwareInterpolatorImpl& _inst, int _num_stripes);
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+    struct RansacInterpolation_ParBody : public ParallelLoopBody
+    {
+        EdgeAwareInterpolatorImpl* inst;
+        Mat* transforms;
+        float* weighted_inlier_nums;
+        float* eps;
+        SparseMatch* matches;
+        int num_stripes;
+        int stripe_sz;
+        int inc;
+
+        RansacInterpolation_ParBody(EdgeAwareInterpolatorImpl& _inst, Mat* _transforms, float* _weighted_inlier_nums, float* _eps, SparseMatch* _matches, int _num_stripes, int _inc);
+        void operator () (const Range& range) const CV_OVERRIDE;
+    };
+
+public:
+    void setCostMap(const Mat & _costMap) CV_OVERRIDE { _costMap.copyTo(costMap); }
+    void  setK(int _k) CV_OVERRIDE {k=_k;}
+    int   getK() CV_OVERRIDE {return k;}
+    void  setSigma(float _sigma) CV_OVERRIDE {sigma=_sigma;}
+    float getSigma() CV_OVERRIDE {return sigma;}
+    void  setLambda(float _lambda) CV_OVERRIDE {lambda=_lambda;}
+    float getLambda() CV_OVERRIDE {return lambda;}
+    void  setUsePostProcessing(bool _use_post_proc) CV_OVERRIDE {use_post_proc=_use_post_proc;}
+    bool  getUsePostProcessing() CV_OVERRIDE {return use_post_proc;}
+    void  setFGSLambda(float _lambda) CV_OVERRIDE {fgs_lambda=_lambda;}
+    float getFGSLambda() CV_OVERRIDE {return fgs_lambda;}
+    void  setFGSSigma(float _sigma) CV_OVERRIDE {fgs_sigma = _sigma;}
+    float getFGSSigma() CV_OVERRIDE {return fgs_sigma;}
+};
+
+void EdgeAwareInterpolatorImpl::init()
+{
+    lambda        = 999.0f;
+    k             = 128;
+    sigma         = 0.05f;
+    use_post_proc = true;
+    fgs_lambda    = 500.0f;
+    fgs_sigma     = 1.5f;
+    regularization_coef = 0.01f;
+    costMap = Mat();
+}
+
+Ptr<EdgeAwareInterpolatorImpl> EdgeAwareInterpolatorImpl::create()
+{
+    EdgeAwareInterpolatorImpl *eai = new EdgeAwareInterpolatorImpl();
+    eai->init();
+    return Ptr<EdgeAwareInterpolatorImpl>(eai);
+}
+
+void EdgeAwareInterpolatorImpl::interpolate(InputArray from_image, InputArray from_points, InputArray, InputArray to_points, OutputArray dense_flow)
+{
+    CV_Assert( !from_image.empty() && (from_image.depth() == CV_8U) && (from_image.channels() == 3 || from_image.channels() == 1) );
+    CV_Assert( !from_points.empty() && !to_points.empty() && from_points.sameSize(to_points) );
+    CV_Assert((from_points.isVector() || from_points.isMat()) && from_points.depth() == CV_32F);
+    CV_Assert((to_points.isVector() || to_points.isMat()) && to_points.depth() == CV_32F);
+    CV_Assert(from_points.sameSize(to_points));
+
+    w = from_image.cols();
+    h = from_image.rows();
+
+    Mat from_mat = from_points.getMat();
+    Mat to_mat = to_points.getMat();
+    int npoints = from_mat.checkVector(2, CV_32F, false);
+    if (from_mat.channels() != 2)
+        from_mat = from_mat.reshape(2, npoints);
+
+    if (to_mat.channels() != 2){
+        to_mat = to_mat.reshape(2, npoints);
+        npoints = from_mat.checkVector(2, CV_32F, false);
+    }
+
+
+    vector<SparseMatch> matches_vector(npoints);
+    for(unsigned int i=0;i<matches_vector.size();i++)
+        matches_vector[i] = SparseMatch(from_mat.at<Point2f>(i), to_mat.at<Point2f>(i));
+
+
+    sort(matches_vector.begin(),matches_vector.end());
+
+    match_num = (int)matches_vector.size();
+    CV_Assert(match_num<SHRT_MAX);
+
+    Mat src = from_image.getMat();
+    labels = Mat(h,w,CV_32S);
+    labels = Scalar(-1);
+    NNlabels = Mat(match_num,k,CV_32S);
+    NNlabels = Scalar(-1);
+    NNdistances = Mat(match_num,k,CV_32F);
+    NNdistances = Scalar(0.0f);
+    g = new vector<node>[match_num];
+
+    preprocessData(src,matches_vector);
+
+    dense_flow.create(from_image.size(),CV_32FC2);
+    Mat dst = dense_flow.getMat();
+    ransacInterpolation(matches_vector,dst);
+    if(use_post_proc)
+        fastGlobalSmootherFilter(src,dst,dst,fgs_lambda,fgs_sigma);
+
+    costMap.release();
+    delete[] g;
+}
+
+void EdgeAwareInterpolatorImpl::preprocessData(Mat& src, vector<SparseMatch>& matches)
+{
+    Mat distances(h,w,CV_32F);
+    distances = Scalar(INF);
+
+    int x,y;
+    for(unsigned int i=0;i<matches.size();i++)
+    {
+        x = min((int)(matches[i].reference_image_pos.x+0.5f),w-1);
+        y = min((int)(matches[i].reference_image_pos.y+0.5f),h-1);
+
+        distances.at<float>(y,x) = 0.0f;
+        labels.at<int>(y,x) = (int)i;
+    }
+
+    if (costMap.empty())
+    {
+        costMap.create(h, w, CV_32FC1);
+        computeGradientMagnitude(src, costMap);
+    }
+    else
+        CV_Assert(costMap.cols == w && costMap.rows == h);
+    costMap = (1000.0f-lambda) + lambda* costMap;
+    geodesicDistanceTransform(distances, costMap);
+    buildGraph(distances, costMap);
+    parallel_for_(Range(0,getNumThreads()),GetKNNMatches_ParBody(*this,getNumThreads()));
+}
+
+void EdgeAwareInterpolatorImpl::geodesicDistanceTransform(Mat& distances, Mat& cost_map)
+{
+    float c1 = 1.0f / 2.0f;
+    float c2 = sqrt(2.0f) / 2.0f;
+    float d = 0.0f;
+    int i, j;
+    float *dist_row, *cost_row;
+    float *dist_row_prev, *cost_row_prev;
+    int *label_row;
+    int *label_row_prev;
+
+#define CHECK(cur_dist,cur_label,cur_cost,prev_dist,prev_label,prev_cost,coef)\
+{\
+    d = prev_dist + coef*(cur_cost+prev_cost);\
+    if(cur_dist>d){\
+        cur_dist=d;\
+        cur_label = prev_label;}\
+}
+
+    for (int it = 0; it < distance_transform_num_iter; it++)
+    {
+        //first pass (left-to-right, top-to-bottom):
+        dist_row = distances.ptr<float>(0);
+        label_row = labels.ptr<int>(0);
+        cost_row = cost_map.ptr<float>(0);
+        for (j = 1; j < w; j++)
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row[j - 1], label_row[j - 1], cost_row[j - 1], c1);
+
+        for (i = 1; i < h; i++)
+        {
+            dist_row = distances.ptr<float>(i);
+            dist_row_prev = distances.ptr<float>(i - 1);
+
+            label_row = labels.ptr<int>(i);
+            label_row_prev = labels.ptr<int>(i - 1);
+
+            cost_row = cost_map.ptr<float>(i);
+            cost_row_prev = cost_map.ptr<float>(i - 1);
+
+            j = 0;
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j + 1], label_row_prev[j + 1], cost_row_prev[j + 1], c2);
+            j++;
+            for (; j < w - 1; j++)
+            {
+                CHECK(dist_row[j], label_row[j], cost_row[j], dist_row[j - 1], label_row[j - 1], cost_row[j - 1], c1);
+                CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j - 1], label_row_prev[j - 1], cost_row_prev[j - 1], c2);
+                CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+                CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j + 1], label_row_prev[j + 1], cost_row_prev[j + 1], c2);
+            }
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row[j - 1], label_row[j - 1], cost_row[j - 1], c1);
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j - 1], label_row_prev[j - 1], cost_row_prev[j - 1], c2);
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+        }
+
+        //second pass (right-to-left, bottom-to-top):
+        dist_row = distances.ptr<float>(h - 1);
+        label_row = labels.ptr<int>(h - 1);
+        cost_row = cost_map.ptr<float>(h - 1);
+        for (j = w - 2; j >= 0; j--)
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row[j + 1], label_row[j + 1], cost_row[j + 1], c1);
+
+        for (i = h - 2; i >= 0; i--)
+        {
+            dist_row = distances.ptr<float>(i);
+            dist_row_prev = distances.ptr<float>(i + 1);
+
+            label_row = labels.ptr<int>(i);
+            label_row_prev = labels.ptr<int>(i + 1);
+
+            cost_row = cost_map.ptr<float>(i);
+            cost_row_prev = cost_map.ptr<float>(i + 1);
+
+            j = w - 1;
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j - 1], label_row_prev[j - 1], cost_row_prev[j - 1], c2);
+            j--;
+            for (; j > 0; j--)
+            {
+                CHECK(dist_row[j], label_row[j], cost_row[j], dist_row[j + 1], label_row[j + 1], cost_row[j + 1], c1);
+                CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j + 1], label_row_prev[j + 1], cost_row_prev[j + 1], c2);
+                CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+                CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j - 1], label_row_prev[j - 1], cost_row_prev[j - 1], c2);
+            }
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row[j + 1], label_row[j + 1], cost_row[j + 1], c1);
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j + 1], label_row_prev[j + 1], cost_row_prev[j + 1], c2);
+            CHECK(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+        }
+    }
+#undef CHECK
+}
+
+void EdgeAwareInterpolatorImpl::buildGraph(Mat& distances, Mat& cost_map)
+{
+    float *dist_row,      *cost_row;
+    float *dist_row_prev, *cost_row_prev;
+    int *label_row;
+    int *label_row_prev;
+    int i,j;
+    const float c1 = 1.0f/2.0f;
+    const float c2 = sqrt(2.0f)/2.0f;
+    float d;
+    bool found;
+
+#define CHECK(cur_dist,cur_label,cur_cost,prev_dist,prev_label,prev_cost,coef)\
+    if(cur_label!=prev_label)\
+    {\
+        d = prev_dist + cur_dist + coef*(cur_cost+prev_cost);\
+        found = false;\
+        for(unsigned int n=0;n<g[prev_label].size();n++)\
+        {\
+            if(g[prev_label][n].label==cur_label)\
+            {\
+                g[prev_label][n].dist = min(g[prev_label][n].dist,d);\
+                found=true;\
+                break;\
+            }\
+        }\
+        if(!found)\
+            g[prev_label].push_back(node(cur_label ,d));\
+    }
+
+    dist_row  = distances.ptr<float>(0);
+    label_row = labels.ptr<int>(0);
+    cost_row  = cost_map.ptr<float>(0);
+    for(j=1;j<w;j++)
+        CHECK(dist_row[j],label_row[j],cost_row[j],dist_row[j-1],label_row[j-1],cost_row[j-1],c1);
+
+    for(i=1;i<h;i++)
+    {
+        dist_row       = distances.ptr<float>(i);
+        dist_row_prev  = distances.ptr<float>(i-1);
+
+        label_row      = labels.ptr<int>(i);
+        label_row_prev = labels.ptr<int>(i-1);
+
+        cost_row      = cost_map.ptr<float>(i);
+        cost_row_prev = cost_map.ptr<float>(i-1);
+
+        j=0;
+        CHECK(dist_row[j],label_row[j],cost_row[j],dist_row_prev[j]  ,label_row_prev[j]  ,cost_row_prev[j]  ,c1);
+        CHECK(dist_row[j],label_row[j],cost_row[j],dist_row_prev[j+1],label_row_prev[j+1],cost_row_prev[j+1],c2);
+        j++;
+        for(;j<w-1;j++)
+        {
+            CHECK(dist_row[j],label_row[j],cost_row[j],dist_row[j-1]     ,label_row[j-1]     ,cost_row[j-1]     ,c1);
+            CHECK(dist_row[j],label_row[j],cost_row[j],dist_row_prev[j-1],label_row_prev[j-1],cost_row_prev[j-1],c2);
+            CHECK(dist_row[j],label_row[j],cost_row[j],dist_row_prev[j]  ,label_row_prev[j]  ,cost_row_prev[j]  ,c1);
+            CHECK(dist_row[j],label_row[j],cost_row[j],dist_row_prev[j+1],label_row_prev[j+1],cost_row_prev[j+1],c2);
+        }
+        CHECK(dist_row[j],label_row[j],cost_row[j],dist_row[j-1]     ,label_row[j-1]     ,cost_row[j-1]     ,c1);
+        CHECK(dist_row[j],label_row[j],cost_row[j],dist_row_prev[j-1],label_row_prev[j-1],cost_row_prev[j-1],c2);
+        CHECK(dist_row[j],label_row[j],cost_row[j],dist_row_prev[j]  ,label_row_prev[j]  ,cost_row_prev[j]  ,c1);
+    }
+#undef CHECK
+
+    // force equal distances in both directions:
+    node* neighbors;
+    for(i=0;i<match_num;i++)
+    {
+        if(g[i].empty())
+            continue;
+        neighbors = &g[i].front();
+        for(j=0;j<(int)g[i].size();j++)
+        {
+            found = false;
+
+            for(unsigned int n=0;n<g[neighbors[j].label].size();n++)
+            {
+                if(g[neighbors[j].label][n].label==i)
+                {
+                    neighbors[j].dist = g[neighbors[j].label][n].dist = min(neighbors[j].dist,g[neighbors[j].label][n].dist);
+                    found = true;
+                    break;
+                }
+            }
+
+            if(!found)
+                g[neighbors[j].label].push_back(node((int)i,neighbors[j].dist));
+        }
+    }
+}
+
+struct nodeHeap
+{
+    // start indexing from 1 (root)
+    // children: 2*i, 2*i+1
+    // parent: i>>1
+    node* heap;
+    int* heap_pos;
+    node tmp_node;
+    int size;
+    int num_labels;
+
+    nodeHeap(int _num_labels)
+    {
+        num_labels = _num_labels;
+        heap = new node[num_labels+1];
+        heap[0] = node(-1,-1.0f);
+        heap_pos = new int[num_labels];
+        memset(heap_pos,0,sizeof(int)*num_labels);
+        size=0;
+    }
+
+    ~nodeHeap()
+    {
+        delete[] heap;
+        delete[] heap_pos;
+    }
+
+    void clear()
+    {
+        size=0;
+        memset(heap_pos,0,sizeof(int)*num_labels);
+    }
+
+    inline bool empty()
+    {
+        return (size==0);
+    }
+
+    inline void nodeSwap(int idx1, int idx2)
+    {
+        heap_pos[heap[idx1].label] = idx2;
+        heap_pos[heap[idx2].label] = idx1;
+
+        tmp_node   = heap[idx1];
+        heap[idx1] = heap[idx2];
+        heap[idx2] = tmp_node;
+    }
+
+    void add(node n)
+    {
+        size++;
+        heap[size] = n;
+        heap_pos[n.label] = size;
+        int i = size;
+        int parent_i = i>>1;
+        while(heap[i].dist<heap[parent_i].dist)
+        {
+            nodeSwap(i,parent_i);
+            i=parent_i;
+            parent_i = i>>1;
+        }
+    }
+
+    node getMin()
+    {
+        node res = heap[1];
+        heap_pos[res.label] = 0;
+
+        int i=1;
+        int left,right;
+        while( (left=i<<1) < size )
+        {
+            right = left+1;
+            if(heap[left].dist<heap[right].dist)
+            {
+                heap[i] = heap[left];
+                heap_pos[heap[i].label] = i;
+                i = left;
+            }
+            else
+            {
+                heap[i] = heap[right];
+                heap_pos[heap[i].label] = i;
+                i = right;
+            }
+        }
+
+        if(i==size)
+        {
+            size--;
+            return res;
+        }
+
+        heap[i] = heap[size];
+        heap_pos[heap[i].label] = i;
+
+        int parent_i = i>>1;
+        while(heap[i].dist<heap[parent_i].dist)
+        {
+            nodeSwap(i,parent_i);
+            i=parent_i;
+            parent_i = i>>1;
+        }
+
+        size--;
+        return res;
+    }
+
+    //checks if node is already in the heap
+    //if not - add it
+    //if it is - update it with the min dist of the two
+    void updateNode(node n)
+    {
+        if(heap_pos[n.label])
+        {
+            int i = heap_pos[n.label];
+            heap[i].dist = min(heap[i].dist,n.dist);
+            int parent_i = i>>1;
+            while(heap[i].dist<heap[parent_i].dist)
+            {
+                nodeSwap(i,parent_i);
+                i=parent_i;
+                parent_i = i>>1;
+            }
+        }
+        else
+            add(n);
+    }
+};
+
+EdgeAwareInterpolatorImpl::GetKNNMatches_ParBody::GetKNNMatches_ParBody(EdgeAwareInterpolatorImpl& _inst, int _num_stripes):
+inst(&_inst),num_stripes(_num_stripes)
+{
+    stripe_sz = (int)ceil(inst->match_num/(double)num_stripes);
+}
+
+void EdgeAwareInterpolatorImpl::GetKNNMatches_ParBody::operator() (const Range& range) const
+{
+    int start = std::min(range.start * stripe_sz, inst->match_num);
+    int end   = std::min(range.end   * stripe_sz, inst->match_num);
+    nodeHeap q((int)inst->match_num);
+    int num_expanded_vertices;
+    unsigned char* expanded_flag = new unsigned char[inst->match_num];
+    node* neighbors;
+
+    for(int i=start;i<end;i++)
+    {
+        if(inst->g[i].empty())
+            continue;
+
+        num_expanded_vertices = 0;
+        memset(expanded_flag,0,inst->match_num);
+        q.clear();
+        q.add(node((int)i,0.0f));
+        int* NNlabels_row    = inst->NNlabels.ptr<int>(i);
+        float* NNdistances_row = inst->NNdistances.ptr<float>(i);
+        while(num_expanded_vertices<inst->k && !q.empty())
+        {
+            node vert_for_expansion = q.getMin();
+            expanded_flag[vert_for_expansion.label] = 1;
+
+            //write the expanded vertex to the dst:
+            NNlabels_row[num_expanded_vertices] = vert_for_expansion.label;
+            NNdistances_row[num_expanded_vertices] = vert_for_expansion.dist;
+            num_expanded_vertices++;
+
+            //update the heap:
+            neighbors = &inst->g[vert_for_expansion.label].front();
+            for(int j=0;j<(int)inst->g[vert_for_expansion.label].size();j++)
+            {
+                if(!expanded_flag[neighbors[j].label])
+                    q.updateNode(node(neighbors[j].label,vert_for_expansion.dist+neighbors[j].dist));
+            }
+        }
+    }
+    delete[] expanded_flag;
+}
+
+static void weightedLeastSquaresAffineFit(int* labels, float* weights, int count, float lambda, const SparseMatch* matches, Mat& dst)
+{
+    double sa[6][6]={{0.}}, sb[6]={0.};
+    Mat A (6, 6, CV_64F, &sa[0][0]),
+        B (6, 1, CV_64F, sb),
+        MM(1, 6, CV_64F);
+    Point2f a,b;
+    float w;
+
+    for( int i = 0; i < count; i++ )
+    {
+        a = matches[labels[i]].reference_image_pos;
+        b = matches[labels[i]].target_image_pos;
+        w = weights[i];
+
+        sa[0][0] += w*a.x*a.x;
+        sa[0][1] += w*a.y*a.x;
+        sa[0][2] += w*a.x;
+        sa[1][1] += w*a.y*a.y;
+        sa[1][2] += w*a.y;
+        sa[2][2] += w;
+
+        sb[0] += w*a.x*b.x;
+        sb[1] += w*a.y*b.x;
+        sb[2] += w*b.x;
+        sb[3] += w*a.x*b.y;
+        sb[4] += w*a.y*b.y;
+        sb[5] += w*b.y;
+    }
+    sa[0][0] += lambda;
+    sa[1][1] += lambda;
+
+    sa[3][4] = sa[4][3] = sa[1][0] = sa[0][1];
+    sa[3][5] = sa[5][3] = sa[2][0] = sa[0][2];
+    sa[4][5] = sa[5][4] = sa[2][1] = sa[1][2];
+
+    sa[3][3] = sa[0][0];
+    sa[4][4] = sa[1][1];
+    sa[5][5] = sa[2][2];
+
+    sb[0] += lambda;
+    sb[4] += lambda;
+
+    solve(A, B, MM, DECOMP_EIG);
+    MM.reshape(2,3).convertTo(dst,CV_32F);
+}
+
+static void generateHypothesis(int* labels, int count, RNG& rng, unsigned char* is_used, SparseMatch* matches, Mat& dst)
+{
+    int idx;
+    Point2f src_points[3];
+    Point2f dst_points[3];
+    memset(is_used,0,count);
+
+    // randomly get 3 distinct matches
+    idx = rng.uniform(0,count-2);
+    is_used[idx] = true;
+    src_points[0] = matches[labels[idx]].reference_image_pos;
+    dst_points[0] = matches[labels[idx]].target_image_pos;
+
+    idx = rng.uniform(0,count-1);
+    if (is_used[idx])
+        idx = count-2;
+    is_used[idx] = true;
+    src_points[1] = matches[labels[idx]].reference_image_pos;
+    dst_points[1] = matches[labels[idx]].target_image_pos;
+
+    idx = rng.uniform(0,count);
+    if (is_used[idx])
+        idx = count-1;
+    is_used[idx] = true;
+    src_points[2] = matches[labels[idx]].reference_image_pos;
+    dst_points[2] = matches[labels[idx]].target_image_pos;
+
+    // compute an affine transform:
+    getAffineTransform(src_points,dst_points).convertTo(dst,CV_32F);
+}
+
+static void verifyHypothesis(int* labels, float* weights, int count, SparseMatch* matches, float eps, float lambda, Mat& hypothesis_transform, Mat& old_transform, float& old_weighted_num_inliers)
+{
+    float* tr = hypothesis_transform.ptr<float>(0);
+    Point2f a,b;
+    float weighted_num_inliers = -lambda*((tr[0]-1)*(tr[0]-1)+tr[1]*tr[1]+tr[3]*tr[3]+(tr[4]-1)*(tr[4]-1));
+
+    for(int i=0;i<count;i++)
+    {
+        a = matches[labels[i]].reference_image_pos;
+        b = matches[labels[i]].target_image_pos;
+        if(abs(tr[0]*a.x + tr[1]*a.y + tr[2] - b.x) +
+           abs(tr[3]*a.x + tr[4]*a.y + tr[5] - b.y) < eps)
+            weighted_num_inliers += weights[i];
+    }
+
+    if(weighted_num_inliers>=old_weighted_num_inliers)
+    {
+        old_weighted_num_inliers = weighted_num_inliers;
+        hypothesis_transform.copyTo(old_transform);
+    }
+}
+
+static void computeGradientMagnitude(Mat& src, Mat& dst)
+{
+    Mat dx, dy;
+    Sobel(src, dx, CV_16S, 1, 0);
+    Sobel(src, dy, CV_16S, 0, 1);
+    float norm_coef = src.channels() * 4 * 255.0f;
+
+    if (src.channels() == 1)
+    {
+        for (int i = 0; i < src.rows; i++)
+        {
+            short* dx_row = dx.ptr<short>(i);
+            short* dy_row = dy.ptr<short>(i);
+            float* dst_row = dst.ptr<float>(i);
+
+            for (int j = 0; j < src.cols; j++)
+                dst_row[j] = ((float)abs(dx_row[j]) + abs(dy_row[j])) / norm_coef;
+        }
+    }
+    else
+    {
+        for (int i = 0; i < src.rows; i++)
+        {
+            Vec3s* dx_row = dx.ptr<Vec3s>(i);
+            Vec3s* dy_row = dy.ptr<Vec3s>(i);
+            float* dst_row = dst.ptr<float>(i);
+
+            for (int j = 0; j < src.cols; j++)
+                dst_row[j] = (float)(abs(dx_row[j][0]) + abs(dy_row[j][0]) +
+                    abs(dx_row[j][1]) + abs(dy_row[j][1]) +
+                    abs(dx_row[j][2]) + abs(dy_row[j][2])) / norm_coef;
+        }
+    }
+}
+
+EdgeAwareInterpolatorImpl::RansacInterpolation_ParBody::RansacInterpolation_ParBody(EdgeAwareInterpolatorImpl& _inst, Mat* _transforms, float* _weighted_inlier_nums, float* _eps, SparseMatch* _matches, int _num_stripes, int _inc):
+inst(&_inst), transforms(_transforms), weighted_inlier_nums(_weighted_inlier_nums), eps(_eps), matches(_matches), num_stripes(_num_stripes), inc(_inc)
+{
+    stripe_sz = (int)ceil(inst->match_num/(double)num_stripes);
+}
+
+void EdgeAwareInterpolatorImpl::RansacInterpolation_ParBody::operator() (const Range& range) const
+{
+    if(range.end>range.start+1)
+    {
+        for(int n=range.start;n<range.end;n++)
+            (*this)(Range(n,n+1));
+        return;
+    }
+
+    int start = std::min(range.start * stripe_sz, inst->match_num);
+    int end   = std::min(range.end   * stripe_sz, inst->match_num);
+    if(inc<0)
+    {
+        int tmp = end;
+        end = start-1;
+        start = tmp-1;
+    }
+
+    int* KNNlabels;
+    float* KNNdistances;
+    unsigned char* is_used = new unsigned char[inst->k];
+    Mat hypothesis_transform;
+
+    int* inlier_labels    = new int[inst->k];
+    float* inlier_distances = new float[inst->k];
+    float* tr;
+    int num_inliers;
+    Point2f a,b;
+
+    for(int i=start;i!=end;i+=inc)
+    {
+        if(inst->g[i].empty())
+            continue;
+
+        KNNlabels    = inst->NNlabels.ptr<int>(i);
+        KNNdistances = inst->NNdistances.ptr<float>(i);
+        if(inc>0) //forward pass
+        {
+            cv::hal::exp32f(KNNdistances,KNNdistances,inst->k);
+
+            Point2f average = Point2f(0.0f,0.0f);
+            for(int j=0;j<inst->k;j++)
+                average += matches[KNNlabels[j]].target_image_pos - matches[KNNlabels[j]].reference_image_pos;
+            average/=inst->k;
+            float average_dist = 0.0;
+            Point2f vec;
+            for(int j=0;j<inst->k;j++)
+            {
+                vec = (matches[KNNlabels[j]].target_image_pos - matches[KNNlabels[j]].reference_image_pos);
+                average_dist += abs(vec.x-average.x) + abs(vec.y-average.y);
+            }
+            eps[i] = min(0.5f*(average_dist/inst->k),2.0f);
+        }
+
+        for(int it=0;it<inst->ransac_interpolation_num_iter;it++)
+        {
+            generateHypothesis(KNNlabels,inst->k,inst->rngs[range.start],is_used,matches,hypothesis_transform);
+            verifyHypothesis(KNNlabels,KNNdistances,inst->k,matches,eps[i],inst->regularization_coef,hypothesis_transform,transforms[i],weighted_inlier_nums[i]);
+        }
+
+        //propagate hypotheses from neighbors:
+        node* neighbors = &inst->g[i].front();
+        for(int j=0;j<(int)inst->g[i].size();j++)
+        {
+            if((inc*neighbors[j].label)<(inc*i) && (inc*neighbors[j].label)>=(inc*start)) //already processed this neighbor
+                verifyHypothesis(KNNlabels,KNNdistances,inst->k,matches,eps[i],inst->regularization_coef,transforms[neighbors[j].label],transforms[i],weighted_inlier_nums[i]);
+        }
+
+        if(inc<0) //backward pass
+        {
+            // determine inliers and compute a least squares fit:
+            tr = transforms[i].ptr<float>(0);
+            num_inliers = 0;
+
+            for(int j=0;j<inst->k;j++)
+            {
+                a = matches[KNNlabels[j]].reference_image_pos;
+                b = matches[KNNlabels[j]].target_image_pos;
+                if(abs(tr[0]*a.x + tr[1]*a.y + tr[2] - b.x) +
+                   abs(tr[3]*a.x + tr[4]*a.y + tr[5] - b.y) < eps[i])
+                {
+                    inlier_labels[num_inliers]    = KNNlabels[j];
+                    inlier_distances[num_inliers] = KNNdistances[j];
+                    num_inliers++;
+                }
+            }
+
+            weightedLeastSquaresAffineFit(inlier_labels,inlier_distances,num_inliers,inst->regularization_coef,matches,transforms[i]);
+        }
+    }
+
+    delete[] inlier_labels;
+    delete[] inlier_distances;
+    delete[] is_used;
+}
+
+void EdgeAwareInterpolatorImpl::ransacInterpolation(vector<SparseMatch>& matches, Mat& dst_dense_flow)
+{
+    NNdistances *= (-sigma*sigma);
+
+    Mat* transforms = new Mat[match_num];
+    float* weighted_inlier_nums = new float[match_num];
+    float* eps = new float[match_num];
+    for(int i=0;i<match_num;i++)
+        weighted_inlier_nums[i] = -std::numeric_limits<float>::max();
+
+    for(int i=0;i<ransac_num_stripes;i++)
+        rngs[i] = RNG(0);
+
+    //forward pass:
+    parallel_for_(Range(0,ransac_num_stripes),RansacInterpolation_ParBody(*this,transforms,weighted_inlier_nums,eps,&matches.front(),ransac_num_stripes,1));
+    //backward pass:
+    parallel_for_(Range(0,ransac_num_stripes),RansacInterpolation_ParBody(*this,transforms,weighted_inlier_nums,eps,&matches.front(),ransac_num_stripes,-1));
+
+    //construct the final piecewise-affine interpolation:
+    int* label_row;
+    float* tr;
+    for(int i=0;i<h;i++)
+    {
+        label_row = labels.ptr<int>(i);
+        Point2f* dst_row = dst_dense_flow.ptr<Point2f>(i);
+        for(int j=0;j<w;j++)
+        {
+            tr = transforms[label_row[j]].ptr<float>(0);
+            dst_row[j] = Point2f(tr[0]*j+tr[1]*i+tr[2],tr[3]*j+tr[4]*i+tr[5]) - Point2f((float)j,(float)i);
+        }
+    }
+
+    delete[] transforms;
+    delete[] weighted_inlier_nums;
+    delete[] eps;
+}
+
+CV_EXPORTS_W
+Ptr<EdgeAwareInterpolator> createEdgeAwareInterpolator()
+{
+    return Ptr<EdgeAwareInterpolator>(EdgeAwareInterpolatorImpl::create());
+}
+
+bool operator<(const SparseMatch& lhs,const SparseMatch& rhs)
+{
+    if((int)(lhs.reference_image_pos.y+0.5f)!=(int)(rhs.reference_image_pos.y+0.5f))
+        return (lhs.reference_image_pos.y<rhs.reference_image_pos.y);
+    else
+        return (lhs.reference_image_pos.x<rhs.reference_image_pos.x);
+}
+
+class RICInterpolatorImpl CV_FINAL : public RICInterpolator
+{
+public:
+    static Ptr<RICInterpolatorImpl> create();
+    void interpolate(InputArray from_image, InputArray from_points, InputArray to_image, InputArray to_points, OutputArray dense_flow) CV_OVERRIDE;
+
+protected:
+    // internal buffers
+    int match_num;
+    vector<vector<node>> g;
+    Mat NNlabels;
+    Mat NNdistances;
+    Mat labels;
+    Mat costMap;
+    static const int distance_transform_num_iter = 1;
+    float lambda;
+
+    //tunable parameters:
+    int max_neighbors;
+    float alpha;
+    int sp_size;
+    int sp_nncnt;
+    float sp_ruler;
+    int model_iter;
+    bool refine_models;
+    bool use_variational_refinement;
+    float cost_suffix;
+    float max_flow;
+    bool use_global_smoother_filter;
+    float fgs_lambda;
+    float fgs_sigma;
+    SLICType slic_type;
+
+    void init();
+    void buildGraph(Mat& distances, Mat& cost_map);
+    void geodesicDistanceTransform(Mat& distances, Mat& cost_map);
+    int  overSegmentaion(const Mat & img, Mat & outLabels, const int spSize);
+    void superpixelNeighborConstruction(const Mat & labels, int labelCnt, Mat& outNeighbor);
+    void superpixelLayoutAnalysis(const Mat & labels, int labelCnt, Mat & outCenterPositions, Mat & outNodeItemLists);
+    void findSupportMatches(vector<int> & srcIds, int srcCnt, int supportCnt, Mat & matNN,
+        Mat & matNNDis, vector<int> & outSupportIds, vector<float> &  outSupportDis);
+    float GetWeightFromDistance(float dis);
+    int PropagateModels(int spCnt, Mat & spNN, vector<int> & supportMatchIds, vector<float> & supportMatchDis, int supportCnt,
+        const vector<SparseMatch> &inputMatches, Mat & outModels);
+    float HypothesisEvaluation(const Mat & inModel, const int * matNodes, const float * matDis, int matCnt, const vector<SparseMatch> & inputMatches, Mat & outInLier);
+    int HypothesisGeneration(int* matNodes, int matCnt, const vector<SparseMatch> & inputMatches, Mat & outModel);
+
+public:
+    void setCostMap(const Mat & _costMap) CV_OVERRIDE { _costMap.copyTo(costMap); }
+    void setK(int val) CV_OVERRIDE { max_neighbors  = val; }
+    int  getK() const CV_OVERRIDE { return max_neighbors; }
+    void setSuperpixelSize(int val) CV_OVERRIDE { sp_size = val; }
+    int  getSuperpixelSize() const CV_OVERRIDE { return sp_size; }
+    void setSuperpixelNNCnt(int val) CV_OVERRIDE { sp_nncnt = val; }
+    int  getSuperpixelNNCnt() const CV_OVERRIDE { return sp_nncnt; }
+    void setSuperpixelRuler(float val) CV_OVERRIDE { sp_ruler = val; }
+    float getSuperpixelRuler() const CV_OVERRIDE { return sp_ruler; }
+    void setSuperpixelMode(int val) CV_OVERRIDE
+    {
+        slic_type = static_cast<SLICType>(val);
+        CV_Assert(slic_type == SLICO || slic_type == SLIC || slic_type == MSLIC);
+    }
+    int  getSuperpixelMode() const CV_OVERRIDE { return slic_type; }
+    void setAlpha(float val) CV_OVERRIDE { alpha = val; }
+    float getAlpha() const CV_OVERRIDE { return alpha; }
+    void setModelIter(int val) CV_OVERRIDE { model_iter = val; }
+    int  getModelIter() const CV_OVERRIDE { return model_iter; }
+    void setRefineModels(bool val) CV_OVERRIDE { refine_models = static_cast<int>(val); }
+    bool getRefineModels() const CV_OVERRIDE { return refine_models; }
+    void setMaxFlow(float val) CV_OVERRIDE { max_flow = val; }
+    float getMaxFlow() const CV_OVERRIDE { return max_flow; }
+    void setUseVariationalRefinement(bool val) CV_OVERRIDE { use_variational_refinement = val; }
+    bool getUseVariationalRefinement() const CV_OVERRIDE { return use_variational_refinement; }
+    void  setUseGlobalSmootherFilter(bool val) CV_OVERRIDE { use_global_smoother_filter = val; }
+    bool  getUseGlobalSmootherFilter() const CV_OVERRIDE { return use_global_smoother_filter; }
+    void  setFGSLambda(float _lambda) CV_OVERRIDE { fgs_lambda = _lambda; }
+    float getFGSLambda() const CV_OVERRIDE { return fgs_lambda; }
+    void  setFGSSigma(float _sigma) CV_OVERRIDE { fgs_sigma = _sigma; }
+    float getFGSSigma() const CV_OVERRIDE { return fgs_sigma; }
+};
+
+Ptr<RICInterpolatorImpl> RICInterpolatorImpl::create()
+{
+    auto eai = makePtr<RICInterpolatorImpl>();
+    eai->init();
+    return eai;
+}
+
+void RICInterpolatorImpl::init()
+{
+    max_neighbors = 32;
+    alpha = 0.7f;
+    lambda = 999.0f;
+    sp_size = 15;
+    sp_nncnt = 150;
+    sp_ruler = 15.f;
+    model_iter = 4;
+    refine_models = true;
+    use_variational_refinement = false;
+    cost_suffix = 0.001f;
+    max_flow = 250.f;
+    use_global_smoother_filter = true;
+    fgs_lambda = 500.0f;
+    fgs_sigma = 1.5f;
+    slic_type = SLIC;
+    costMap = Mat();
+}
+
+struct MinHeap
+{
+public:
+    MinHeap(int size)
+    {
+        //memset(this, 0, sizeof(*this));
+        Init(size);
+    }
+
+    int Init(int size)
+    {
+        m_index.resize(size);
+        m_weight.resize(size);
+        m_size = size;
+        m_validSize = 0;
+
+        return 0;
+    }
+    int Push(float index, float weight)
+    {
+        if (m_validSize >= m_size)
+        {
+            CV_Error(Error::StsOutOfRange, " m_validSize >= m_size this problem can be resolved my decreasig k parameter");
+        }
+        m_index[m_validSize] = index;
+        m_weight[m_validSize] = weight;
+        m_validSize++;
+
+        int i = m_validSize - 1;
+        while (prior(m_weight[i], m_weight[(i - 1) / 2])) {
+            swap(m_weight[i], m_weight[(i - 1) / 2]);
+            swap(m_index[i], m_index[(i - 1) / 2]);
+            i = (i - 1) / 2; // jump up to the parent
+        }
+
+        return i;
+    }
+
+    float Pop(float* weight = NULL)
+    {
+        if (m_validSize == 0) {
+            return -1;
+        }
+
+        if (weight) {
+            *weight = m_weight[0];
+        }
+        float outIdx = m_index[0];
+
+        // use the last item to overwrite the first
+        m_index[0] = m_index[m_validSize - 1];
+        m_weight[0] = m_weight[m_validSize - 1];
+        m_validSize--;
+
+        // adjust the heap from top to bottom
+        float rawIdx = m_index[0];
+        float rawWt = m_weight[0];
+        int candiPos = 0; // the root
+        int i = 1; // left child of the root
+        while (i < m_validSize) {
+            // test right child
+            if (i + 1 < m_validSize && prior(m_weight[i + 1], m_weight[i])) {
+                i++;
+            }
+            if (prior(rawWt, m_weight[i])) {
+                break;
+            }
+            m_index[candiPos] = m_index[i];
+            m_weight[candiPos] = m_weight[i];
+            candiPos = i;
+
+            i = (i + 1) * 2 - 1; // left child
+        }
+        m_index[candiPos] = rawIdx;
+        m_weight[candiPos] = rawWt;
+
+        return outIdx;
+    }
+    void Clear()
+    {
+        m_validSize = 0;
+    }
+    int Size()
+    {
+        return m_validSize;
+    }
+
+private:
+    inline bool prior(float w1, float w2)
+    {
+            return w1 < w2;
+    }
+
+    vector<float> m_index;
+    vector<float> m_weight;
+    int m_size;
+    int m_validSize;
+};
+
+void RICInterpolatorImpl::interpolate(InputArray from_image, InputArray from_points, InputArray to_image, InputArray to_points, OutputArray dense_flow)
+{
+    CV_Assert(!from_image.empty());
+    CV_Assert(from_image.depth() == CV_8U);
+    CV_Assert((from_image.channels() == 3 || from_image.channels() == 1));
+    CV_Assert(use_variational_refinement == false || !to_image.empty());
+    CV_Assert(use_variational_refinement == false || to_image.depth() == CV_8U);
+    CV_Assert(use_variational_refinement == false || to_image.channels() == 3 || to_image.channels() == 1);
+    CV_Assert(!from_points.empty());
+    CV_Assert(!to_points.empty());
+    CV_Assert((from_points.isVector() || from_points.isMat()) && from_points.depth() == CV_32F);
+    CV_Assert((to_points.isVector() || to_points.isMat()) && to_points.depth() == CV_32F);
+    CV_Assert(from_points.sameSize(to_points));
+
+    Mat from_mat = from_points.getMat();
+    Mat to_mat = to_points.getMat();
+    int npoints = from_mat.checkVector(2, CV_32F, false);
+
+    if (from_mat.channels() != 2)
+        from_mat = from_mat.reshape(2, npoints);
+
+    if (to_mat.channels() != 2 ){
+        to_mat = to_mat.reshape(2, npoints);
+        npoints = from_mat.checkVector(2, CV_32F, false);
+    }
+
+    vector<SparseMatch> matches_vector(npoints);
+    for(unsigned int i=0;i<matches_vector.size();i++)
+        matches_vector[i] = SparseMatch(from_mat.at<Point2f>(i),to_mat.at<Point2f>(i));
+
+    match_num = static_cast<int>(matches_vector.size());
+
+    Mat src = from_image.getMat();
+    Size src_size = src.size();
+
+    labels = Mat(src_size, CV_32SC1);
+    labels.setTo(-1);
+    NNlabels = Mat(match_num, max_neighbors, CV_32S);
+    NNlabels = Scalar(-1);
+    NNdistances = Mat(match_num, max_neighbors, CV_32F);
+    NNdistances = Scalar(0.0f);
+
+    Mat matDistanceMap(src_size, CV_32FC1);
+    matDistanceMap.setTo(1e10);
+
+    if (costMap.empty())
+    {
+        costMap.create(src_size, CV_32FC1);
+        computeGradientMagnitude(src, costMap);
+    }
+    else
+        CV_Assert(costMap.rows == src.rows && costMap.cols == src.cols );
+
+    costMap = (1000.0f - lambda) + lambda * costMap;
+
+    for (unsigned int i = 0; i < matches_vector.size(); i++)
+    {
+        const SparseMatch & p = matches_vector[i];
+        Point pos(static_cast<int>(p.reference_image_pos.x), static_cast<int>(p.reference_image_pos.y));
+        labels.at<int>(pos) = i;
+        matDistanceMap.at<float>(pos) = costMap.at<float>(pos);
+    }
+
+    geodesicDistanceTransform(matDistanceMap, costMap);
+
+    g.resize(match_num);
+    buildGraph(matDistanceMap, costMap);
+    parallel_for_(Range(0, getNumThreads()), [&](const Range & range)
+    {
+        int stripe_sz = (int)ceil(match_num / (double)getNumThreads());
+        int start = std::min(range.start * stripe_sz, match_num);
+        int end = std::min(range.end   * stripe_sz, match_num);
+        nodeHeap q((int)match_num);
+        int num_expanded_vertices;
+        vector<unsigned int> expanded_flag(match_num);
+        node* neighbors;
+        for (int i = start; i < end; i++)
+        {
+            if (g[i].empty())
+                continue;
+            num_expanded_vertices = 0;
+            fill(expanded_flag.begin(), expanded_flag.end(), 0);
+            q.clear();
+            q.add(node((int)i, 0.0f));
+            int* NNlabels_row = NNlabels.ptr<int>(i);
+            float* NNdistances_row = NNdistances.ptr<float>(i);
+            while (num_expanded_vertices < max_neighbors && !q.empty())
+            {
+                node vert_for_expansion = q.getMin();
+                expanded_flag[vert_for_expansion.label] = 1;
+
+                //write the expanded vertex to the dst:
+                NNlabels_row[num_expanded_vertices] = vert_for_expansion.label;
+                NNdistances_row[num_expanded_vertices] = vert_for_expansion.dist;
+                num_expanded_vertices++;
+
+                //update the heap:
+                neighbors = &g[vert_for_expansion.label].front();
+                for (int j = 0; j < (int)g[vert_for_expansion.label].size(); j++)
+                {
+                    if (!expanded_flag[neighbors[j].label])
+                        q.updateNode(node(neighbors[j].label, vert_for_expansion.dist + neighbors[j].dist));
+                }
+            }
+        }
+    });
+
+    Mat spLabels;
+    Mat spNN;
+    Mat spPos;
+    Mat spItems;
+
+    int spCnt = overSegmentaion(src, spLabels, sp_size);
+    superpixelNeighborConstruction(spLabels, spCnt, spNN);
+    superpixelLayoutAnalysis(spLabels, spCnt, spPos, spItems);
+
+    vector<int> srcMatchIds(spCnt);
+    for (int i = 0; i < spCnt; i++)
+    {
+        Point pos = static_cast<Point>(spPos.at<Point2f>(i) + Point2f(0.5f,0.5f));
+        pos.x = MIN(labels.cols - 1, pos.x);
+        pos.y = MIN(labels.rows - 1, pos.y);
+        srcMatchIds[i] = labels.at<int>(pos);
+    }
+
+    int supportCnt = sp_nncnt;
+    vector<int> supportMatchIds(spCnt*supportCnt);  // support matches for each superpixel
+    vector<float> supportMatchDis(spCnt*supportCnt);
+
+    findSupportMatches(srcMatchIds, spCnt, supportCnt, NNlabels, NNdistances, supportMatchIds, supportMatchDis);
+
+    Mat transModels(spCnt,6, CV_32FC1);
+    Mat fitModels(spCnt, 6, CV_32FC1);
+    Mat rawModel(1, 6, CV_32FC1);
+    rawModel.setTo(0);
+    rawModel.at<float>(0) = 1;
+    rawModel.at<float>(4) = 1;
+
+    for (int i = 0; i < spCnt; i++) {
+        int matId = supportMatchIds[i*supportCnt + 0];
+
+        const SparseMatch & p = matches_vector[matId];
+        float u = p.target_image_pos.x - p.reference_image_pos.x;
+        float v = p.target_image_pos.y - p.reference_image_pos.y;
+
+        rawModel.copyTo(transModels.row(i));
+        transModels.at<float>(i,2) = u;
+        transModels.at<float>(i,5) = v;
+        transModels.row(i).copyTo(fitModels.row(i));
+    }
+
+    PropagateModels(spCnt, spNN, supportMatchIds, supportMatchDis, supportCnt, matches_vector, fitModels);
+
+    dense_flow.create(from_image.size(), CV_32FC2);
+
+    Mat U = Mat(src.rows, src.cols, CV_32FC1);
+    Mat V = Mat(src.rows, src.cols, CV_32FC1);
+    for (int i = 0; i < spCnt; i++) {
+        for (int k = 0; k < spItems.cols; k++) {
+            int x = spItems.at<Point>(i,k).x;
+            int y = spItems.at<Point>(i,k).y;
+            if (x < 0 || y < 0) {
+                break;
+            }
+            float fx = fitModels.at<float>(i, 0) * x + fitModels.at<float>(i, 1) * y + fitModels.at<float>(i, 2);
+            float fy = fitModels.at<float>(i, 3) * x + fitModels.at<float>(i, 4) * y + fitModels.at<float>(i, 5);
+            //cout << fitModels << endl;
+            U.at<float>(y, x) = fx - x;
+            V.at<float>(y, x) = fy - y;
+            if (abs(fx - x) > max_flow || abs(fy - y) > max_flow)
+            {
+                // use the translational model directly
+                fx = transModels.at<float>(i, 0) * x + transModels.at<float>(i, 1) * y + transModels.at<float>(i, 2);
+                fy = transModels.at<float>(i, 3) * x + transModels.at<float>(i, 4) * y + transModels.at<float>(i, 5);
+                U.at<float>(y, x) = fx - x;
+                V.at<float>(y, x) = fy - y;
+            }
+        }
+    }
+
+    Mat dst;
+    Mat prevGrey, currGrey;
+
+    if (use_variational_refinement)
+    {
+        Mat src2 = to_image.getMat();
+        cv::medianBlur(U, U, 3);
+        cv::medianBlur(V, V, 3);
+        Ptr<VariationalRefinement> variationalrefine = VariationalRefinement::create();
+        cvtColor(src, prevGrey, COLOR_BGR2GRAY);
+        cvtColor(src2, currGrey, COLOR_BGR2GRAY);
+        variationalrefine->setOmega(1.9f);
+        variationalrefine->calcUV(prevGrey, currGrey, U,V);
+    }
+    Mat UV[2] = { U,V };
+    merge(UV, 2, dst);
+
+    if (use_global_smoother_filter)
+    {
+        if (prevGrey.empty())
+            cvtColor(src, prevGrey, COLOR_BGR2GRAY);
+        fastGlobalSmootherFilter(prevGrey, dst, dst, fgs_lambda, fgs_sigma);
+    }
+    dst.copyTo(dense_flow.getMat());
+    costMap.release();
+}
+
+void RICInterpolatorImpl::geodesicDistanceTransform(Mat& distances, Mat& cost_map)
+{
+    float c1 = 1.0f / 2.0f;
+    float c2 = sqrt(2.0f) / 2.0f;
+    float d = 0.0f;
+    int i, j;
+    float *dist_row, *cost_row;
+    float *dist_row_prev, *cost_row_prev;
+    int *label_row;
+    int *label_row_prev;
+
+#define CHK_GD(cur_dist,cur_label,cur_cost,prev_dist,prev_label,prev_cost,coef)\
+{\
+    d = prev_dist + coef*(cur_cost+prev_cost);\
+    if(cur_dist>d){\
+        cur_dist=d;\
+        cur_label = prev_label;}\
+}
+
+    for (int it = 0; it < distance_transform_num_iter; it++)
+    {
+        //first pass (left-to-right, top-to-bottom):
+        dist_row = distances.ptr<float>(0);
+        label_row = labels.ptr<int>(0);
+        cost_row = cost_map.ptr<float>(0);
+        for (j = 1; j < distances.cols; j++)
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row[j - 1], label_row[j - 1], cost_row[j - 1], c1);
+
+        for (i = 1; i < distances.rows; i++)
+        {
+            dist_row = distances.ptr<float>(i);
+            dist_row_prev = distances.ptr<float>(i - 1);
+
+            label_row = labels.ptr<int>(i);
+            label_row_prev = labels.ptr<int>(i - 1);
+
+            cost_row = cost_map.ptr<float>(i);
+            cost_row_prev = cost_map.ptr<float>(i - 1);
+
+            j = 0;
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j + 1], label_row_prev[j + 1], cost_row_prev[j + 1], c2);
+            j++;
+            for (; j < distances.cols - 1; j++)
+            {
+                CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row[j - 1], label_row[j - 1], cost_row[j - 1], c1);
+                CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j - 1], label_row_prev[j - 1], cost_row_prev[j - 1], c2);
+                CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+                CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j + 1], label_row_prev[j + 1], cost_row_prev[j + 1], c2);
+            }
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row[j - 1], label_row[j - 1], cost_row[j - 1], c1);
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j - 1], label_row_prev[j - 1], cost_row_prev[j - 1], c2);
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+        }
+
+        //second pass (right-to-left, bottom-to-top):
+        dist_row = distances.ptr<float>(distances.rows - 1);
+        label_row = labels.ptr<int>(distances.rows - 1);
+        cost_row = cost_map.ptr<float>(distances.rows - 1);
+        for (j = distances.cols - 2; j >= 0; j--)
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row[j + 1], label_row[j + 1], cost_row[j + 1], c1);
+
+        for (i = distances.rows - 2; i >= 0; i--)
+        {
+            dist_row = distances.ptr<float>(i);
+            dist_row_prev = distances.ptr<float>(i + 1);
+
+            label_row = labels.ptr<int>(i);
+            label_row_prev = labels.ptr<int>(i + 1);
+
+            cost_row = cost_map.ptr<float>(i);
+            cost_row_prev = cost_map.ptr<float>(i + 1);
+
+            j = distances.cols - 1;
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j - 1], label_row_prev[j - 1], cost_row_prev[j - 1], c2);
+            j--;
+            for (; j > 0; j--)
+            {
+                CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row[j + 1], label_row[j + 1], cost_row[j + 1], c1);
+                CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j + 1], label_row_prev[j + 1], cost_row_prev[j + 1], c2);
+                CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+                CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j - 1], label_row_prev[j - 1], cost_row_prev[j - 1], c2);
+            }
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row[j + 1], label_row[j + 1], cost_row[j + 1], c1);
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j + 1], label_row_prev[j + 1], cost_row_prev[j + 1], c2);
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+        }
+    }
+#undef CHK_GD
+}
+
+void RICInterpolatorImpl::buildGraph(Mat& distances, Mat& cost_map)
+{
+    float *dist_row, *cost_row;
+    float *dist_row_prev, *cost_row_prev;
+    const int *label_row;
+    const int *label_row_prev;
+    int i, j;
+    const float c1 = 1.0f / 2.0f;
+    const float c2 = sqrt(2.0f) / 2.0f;
+    float d;
+    bool found;
+    int h = labels.rows;
+    int w = labels.cols;
+#define CHK_GD(cur_dist,cur_label,cur_cost,prev_dist,prev_label,prev_cost,coef)\
+    if(cur_label!=prev_label)\
+    {\
+        d = prev_dist + cur_dist + coef*(cur_cost+prev_cost);\
+        found = false;\
+        for(unsigned int n=0;n<g[prev_label].size();n++)\
+        {\
+            if(g[prev_label][n].label==cur_label)\
+            {\
+                g[prev_label][n].dist = min(g[prev_label][n].dist,d);\
+                found=true;\
+                break;\
+            }\
+        }\
+        if(!found)\
+            g[prev_label].push_back(node(cur_label ,d));\
+    }
+
+    dist_row = distances.ptr<float>(0);
+    label_row = labels.ptr<int>(0);
+    cost_row = cost_map.ptr<float>(0);
+    for (j = 1; j < w; j++)
+        CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row[j - 1], label_row[j - 1], cost_row[j - 1], c1);
+
+    for (i = 1; i < h; i++)
+    {
+        dist_row = distances.ptr<float>(i);
+        dist_row_prev = distances.ptr<float>(i - 1);
+
+        label_row = labels.ptr<int>(i);
+        label_row_prev = labels.ptr<int>(i - 1);
+
+        cost_row = cost_map.ptr<float>(i);
+        cost_row_prev = cost_map.ptr<float>(i - 1);
+
+        j = 0;
+        CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+        CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j + 1], label_row_prev[j + 1], cost_row_prev[j + 1], c2);
+        j++;
+        for (; j < w - 1; j++)
+        {
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row[j - 1], label_row[j - 1], cost_row[j - 1], c1);
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j - 1], label_row_prev[j - 1], cost_row_prev[j - 1], c2);
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+            CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j + 1], label_row_prev[j + 1], cost_row_prev[j + 1], c2);
+        }
+        CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row[j - 1], label_row[j - 1], cost_row[j - 1], c1);
+        CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j - 1], label_row_prev[j - 1], cost_row_prev[j - 1], c2);
+        CHK_GD(dist_row[j], label_row[j], cost_row[j], dist_row_prev[j], label_row_prev[j], cost_row_prev[j], c1);
+    }
+#undef CHK_GD
+
+    // force equal distances in both directions:
+    node* neighbors;
+    for (i = 0; i < match_num; i++)
+    {
+        if (g[i].empty())
+            continue;
+        neighbors = &g[i].front();
+        for (j = 0; j < (int)g[i].size(); j++)
+        {
+            found = false;
+
+            for (unsigned int n = 0; n < g[neighbors[j].label].size(); n++)
+            {
+                if (g[neighbors[j].label][n].label == i)
+                {
+                    neighbors[j].dist = g[neighbors[j].label][n].dist = min(neighbors[j].dist, g[neighbors[j].label][n].dist);
+                    found = true;
+                    break;
+                }
+            }
+
+            if (!found)
+                g[neighbors[j].label].push_back(node((int)i, neighbors[j].dist));
+        }
+    }
+}
+
+int RICInterpolatorImpl::overSegmentaion(const Mat & img, Mat & outLabels, const int spSize)
+{
+    Mat labImg;
+    cvtColor(img, labImg, COLOR_BGR2Lab);
+    Ptr< SuperpixelSLIC> slic = createSuperpixelSLIC(labImg, slic_type, spSize, sp_ruler);
+    slic->iterate(5);
+    slic->getLabels(outLabels);
+    return slic->getNumberOfSuperpixels();
+}
+
+void RICInterpolatorImpl::superpixelNeighborConstruction(const Mat & _labels, int labelCnt, Mat& outNeighbor)
+{
+    // init
+    outNeighbor = Mat(labelCnt, max_neighbors, CV_32SC1); // only support 32 neighbors
+    outNeighbor.setTo(-1);
+
+    vector<int> diffPairs(labels.cols*_labels.rows * 4, 0);
+    int diffPairCnt = 0;
+    for (int i = 1; i < _labels.rows; i++) {
+        for (int j = 1; j < _labels.cols; j++) {
+
+            int l0 = _labels.at<int>(i,j);
+            int l1 = _labels.at<int>(i,j- 1);
+            int l2 = _labels.at<int>(i-1,j);
+
+            if (l0 != l1) {
+                diffPairs[2 * diffPairCnt] = l0;
+                diffPairs[2 * diffPairCnt + 1] = l1;
+                diffPairCnt++;
+            }
+
+            if (l0 != l2) {
+                diffPairs[2 * diffPairCnt] = l0;
+                diffPairs[2 * diffPairCnt + 1] = l2;
+                diffPairCnt++;
+            }
+        }
+    }
+
+    for (int i = 0; i < diffPairCnt; i++) {
+        int a = diffPairs[2 * i];
+        int b = diffPairs[2 * i + 1];
+        int k = 0;
+
+        // add to neighbor list of a
+        for (k = 0; k < max_neighbors; k++) {
+            if (outNeighbor.at<int>(a, k) < 0) {
+                break;
+            }
+            if (outNeighbor.at<int>(a,k) == b) {
+                k = -1;
+                break;
+            }
+        }
+        if (k >= 0 && k < max_neighbors) {
+            outNeighbor.at<int>(a, k) = b;
+        }
+
+        // add to neighbor list of b
+        for (k = 0; k < max_neighbors; k++) {
+            if (outNeighbor.at<int>(b, k) < 0) {
+                break;
+            }
+            if (outNeighbor.at<int>(b, k) == a) {
+                k = -1;
+                break;
+            }
+        }
+        if (k >= 0 && k < max_neighbors) {
+            outNeighbor.at<int>(b, k) = a;
+        }
+    }
+
+}
+
+void RICInterpolatorImpl::superpixelLayoutAnalysis(const Mat & _labels, int labelCnt, Mat & outCenterPositions, Mat & outNodeItemLists)
+{
+    outCenterPositions = Mat(labelCnt,1,CV_32FC2); // x and y
+    outCenterPositions.setTo(0);
+
+    vector<int> itemCnt(labelCnt, 0);
+
+    for (int i = 0; i < _labels.rows; i++) {
+        for (int j = 0; j < _labels.cols; j++) {
+            int id = _labels.at<int>(i,j);
+            outCenterPositions.at<Point2f>(id) += Point2f(static_cast<float>(j),static_cast<float>(i));
+            itemCnt[id]++;
+        }
+    }
+    int maxItemCnt = 0;
+    for (int i = 0; i < labelCnt; i++) {
+        if (itemCnt[i] > maxItemCnt) {
+            maxItemCnt = itemCnt[i];
+        }
+        if (itemCnt[i] > 0) {
+            outCenterPositions.at<Point2f>(i).x /= itemCnt[i];
+            outCenterPositions.at<Point2f>(i).y /= itemCnt[i];
+        }
+        else {
+            outCenterPositions.at<Point2f>(i) = Point2f(-1,-1);
+        }
+    }
+
+    // get node item lists
+    outNodeItemLists = Mat(labelCnt, maxItemCnt, CV_32SC2);
+    outNodeItemLists.setTo(-1);
+    fill(itemCnt.begin(), itemCnt.end(), 0);
+    for (int i = 0; i < _labels.rows; i++) {
+        for (int j = 0; j < _labels.cols; j++) {
+            int id = _labels.at<int>(i,j);
+            int cnt = itemCnt[id];
+            outNodeItemLists.at<Point>(id, cnt) = Point(j,i);
+            itemCnt[id]++;
+        }
+    }
+
+}
+
+void RICInterpolatorImpl::findSupportMatches(vector<int> & srcIds, int srcCnt, int supportCnt, Mat & matNN,
+                                            Mat & matNNDis, vector<int> & outSupportIds, vector<float> &  outSupportDis)
+{
+    fill(outSupportIds.begin(), outSupportIds.end(), -1); // -1
+    fill(outSupportDis.begin(), outSupportDis.end(), -1.f); // -1
+
+    int allNodeCnt = matNN.rows;
+    MinHeap H(allNodeCnt); // min-heap
+    vector<float> currDis(allNodeCnt);
+
+    for (int i = 0; i < srcCnt; i++)
+    {
+        int id = srcIds[i];
+        int* pSupportIds   = &outSupportIds[i * supportCnt];
+        float* pSupportDis = &outSupportDis[i * supportCnt];
+
+        H.Clear();
+        fill(currDis.begin(), currDis.end(), numeric_limits<float>::max());
+
+        int validSupportCnt = 0;
+
+        H.Push(static_cast<float>(id), 0); // min distance
+        currDis[id] = 0;
+
+        while (H.Size()) {
+            float dis;
+            int idx = static_cast<int>(H.Pop(&dis));
+
+            if (dis > currDis[idx]) {
+                continue;
+            }
+
+            pSupportIds[validSupportCnt] = idx;
+            pSupportDis[validSupportCnt] = dis;
+            validSupportCnt++;
+            if (validSupportCnt >= supportCnt) {
+                break;
+            }
+
+            for (int k = 0; k < matNN.cols; k++) {
+                int nb = matNN.at<int>(idx, k);
+                if (nb < 0) {
+                    break;
+                }
+                float newDis = dis + matNNDis.at<float>(idx,k);
+                if (newDis < currDis[nb]) {
+                    H.Push(static_cast<float>(nb), newDis);
+                    currDis[nb] = newDis;
+                }
+            }
+        }
+    }
+}
+
+int RICInterpolatorImpl::PropagateModels(int spCnt, Mat & spNN, vector<int> & supportMatchIds, vector<float> & supportMatchDis, int supportCnt,
+    const vector<SparseMatch> &inputMatches, Mat & outModels)
+{
+    int iterCnt = model_iter;
+
+    srand(0);
+
+    Mat inLierFlag(spCnt, supportCnt, CV_32SC1);
+    Mat tmpInlierFlag(1, supportCnt, CV_32SC1);
+    Mat tmpModel(1, 6, CV_32FC1);
+
+    // prepare data
+    vector<float> bestCost(spCnt);
+    parallel_for_(Range(0, spCnt), [&](const Range& range)
+    {
+        for (int i = range.start; i < range.end; i++)
+        {
+            Mat outModelRow = outModels.row(i);
+            Mat inlierFlagRow = inLierFlag.row(i);
+            bestCost[i] =
+                HypothesisEvaluation(
+                outModelRow,
+                &supportMatchIds[i * supportCnt],
+                &supportMatchDis[i * supportCnt],
+                supportCnt,
+                inputMatches,
+                inlierFlagRow);
+        }
+    }
+    );
+    parallel_for_(Range(0, iterCnt), [&](const Range& range)
+    {
+        vector<int> vFlags(spCnt);
+        for (int iter = range.start; iter < range.end; iter++)
+        {
+            fill(vFlags.begin(), vFlags.end(), 0);
+
+            int startPos = 0, endPos = spCnt, step = 1;
+            if (iter % 2 == 1) {
+                startPos = spCnt - 1; endPos = -1; step = -1;
+            }
+
+            for (int idx = startPos; idx != endPos; idx += step)
+            {
+                for (int i = 0; i < spNN.cols; i++) {
+                    int nb = spNN.at<int>(idx, i);
+                    if (nb < 0) break;
+                    if (!vFlags[nb]) continue;
+                    Mat NNModel = outModels.row(nb);
+                    float cost = HypothesisEvaluation(
+                        outModels.row(nb),
+                        &supportMatchIds[idx * supportCnt],
+                        &supportMatchDis[idx * supportCnt],
+                        supportCnt,
+                        inputMatches,
+                        tmpInlierFlag);
+                    if (cost < bestCost[idx])
+                    {
+                        outModels.row(nb).copyTo(outModels.row(idx));
+                        tmpInlierFlag.copyTo(inLierFlag.row(idx));
+                        bestCost[idx] = cost;
+                    }
+                }
+
+                // random test
+                int testCnt = 1;
+                for (int i = 0; i < testCnt; i++) {
+                    if (HypothesisGeneration(&supportMatchIds[idx * supportCnt], supportCnt, inputMatches, tmpModel) == 0)
+                    {
+                        float cost = HypothesisEvaluation(
+                            tmpModel,
+                            &supportMatchIds[idx * supportCnt],
+                            &supportMatchDis[idx * supportCnt],
+                            supportCnt,
+                            inputMatches,
+                            tmpInlierFlag);
+                        if (cost < bestCost[idx])
+                        {
+                            tmpModel.copyTo(outModels.row(idx));
+                            tmpInlierFlag.copyTo(inLierFlag.row(idx));
+                            bestCost[idx] = cost;
+                        }
+                    }
+                }
+                vFlags[idx] = 1;
+            }
+        }
+    }
+    );
+    // refinement
+    if (refine_models)
+    {
+        parallel_for_(Range(0, spCnt), [&](const Range& range)
+        {
+            int averInlier = 0;
+            int minPtCnt = 30;
+            for (int i = range.start; i < range.end; i++)
+            {
+
+                Mat pt1(supportCnt, 1, CV_32FC2);
+                Mat pt2(supportCnt, 1, CV_32FC2);
+                vector<int>   inlier_labels(supportCnt);
+                vector<float> inlier_distances(supportCnt);
+                Mat fitModel;
+
+                int* matNodes = &supportMatchIds[i * supportCnt];
+                float* matDis = &supportMatchDis[i * supportCnt];
+
+                int inlierCnt = 0;
+                for (int k = 0; k < supportCnt; k++) {
+                    if (inLierFlag.at<int>(i, k))
+                    {
+                        int matId = matNodes[k];
+                        inlier_labels[inlierCnt] = matId;
+                        inlier_distances[inlierCnt] = GetWeightFromDistance(matDis[k]);
+                        inlierCnt++;
+                    }
+                }
+                if (inlierCnt >= minPtCnt)
+                {
+                    weightedLeastSquaresAffineFit(&inlier_labels[0], &inlier_distances[0], inlierCnt, 0.01f, &inputMatches[0], fitModel);
+                    fitModel.reshape(1, 1).copyTo(outModels.row(i));
+
+                }
+                averInlier += inlierCnt;
+            }
+        }
+        );
+    }
+
+    return 0;
+}
+
+float RICInterpolatorImpl::GetWeightFromDistance(float dis)
+{
+    return exp(-dis / (alpha * 1000));
+}
+
+float RICInterpolatorImpl::HypothesisEvaluation(const Mat & inModel, const int * matNodes, const float * matDis, int matCnt, const vector<SparseMatch> & inputMatches, Mat & outInLier)
+{
+    float errTh = 5.;
+
+    // find inliers
+    int inLierCnt = 0;
+    float cost = 0;
+    for (int k = 0; k < matCnt; k++) {
+        int matId = matNodes[k];
+        const SparseMatch & p = inputMatches[matId];
+        float x1 = p.reference_image_pos.x;
+        float y1 = p.reference_image_pos.y;
+        float xp = inModel.at<float>(0) * x1 + inModel.at<float>(1) * y1 + inModel.at<float>(2);
+        float yp = inModel.at<float>(3) * x1 + inModel.at<float>(4) * y1 + inModel.at<float>(5);
+        float pu = xp - x1, pv = yp - y1;
+
+        float tu = p.target_image_pos.x - p.reference_image_pos.x;
+        float tv = p.target_image_pos.y - p.reference_image_pos.y;
+        float wt = GetWeightFromDistance(matDis[k]);
+
+        if (std::isnan(pu) || std::isnan(pv)) {
+            outInLier.at<int>(k) = 0;
+            cost += wt * errTh;
+            continue;
+        }
+
+        float dis = sqrt((tu - pu)*(tu - pu) + (tv - pv)*(tv - pv));
+        if (dis < errTh) {
+            outInLier.at<int>(k) = 1;
+            inLierCnt++;
+            cost += wt * dis;
+        }
+        else {
+            outInLier.at<int>(k) = 0;
+            cost += wt * errTh;
+        }
+    }
+    return cost;
+}
+
+int RICInterpolatorImpl::HypothesisGeneration(int* matNodes, int matCnt, const vector<SparseMatch> & inputMatches, Mat & outModel)
+{
+    if (matCnt < 3)
+    {
+        return -1;
+    }
+
+    int pickTimes = 0;
+    int maxPickTimes = 10;
+    float p1[6], p2[6]; // 3 pairs
+    bool pick_data = true;
+    float deter = 0;
+    while (pick_data)
+    {
+        pick_data = false;
+        // pick 3 group of points randomly
+        for (int k = 0; k < 3; k++) {
+            int matId = matNodes[rand() % matCnt];
+            const SparseMatch & p = inputMatches[matId];
+            p1[2 * k] = p.reference_image_pos.x;
+            p1[2 * k + 1] = p.reference_image_pos.y;
+            p2[2 * k] = p.target_image_pos.x;
+            p2[2 * k + 1] = p.target_image_pos.y;
+        }
+        // are the 3 points on the same line ?
+        deter = 0; // determinant
+        deter = p1[0] * p1[3] + p1[2] * p1[5] + p1[4] * p1[1]
+              - p1[4] * p1[3] - p1[0] * p1[5] - p1[2] * p1[1];
+        if (abs(deter) <= FLT_EPSILON)
+        {
+            pickTimes++;
+            if (pickTimes > maxPickTimes) {
+                return -1;
+            }
+            pick_data = true;
+        }
+    }
+    // estimate the model
+    float inv[9];
+    inv[0] = (p1[3] - p1[5]) / deter;
+    inv[1] = (p1[5] - p1[1]) / deter;
+    inv[2] = (p1[1] - p1[3]) / deter;
+    inv[3] = (p1[4] - p1[2]) / deter;
+    inv[4] = (p1[0] - p1[4]) / deter;
+    inv[5] = (p1[2] - p1[0]) / deter;
+    inv[6] = (p1[2] * p1[5] - p1[3] * p1[4]) / deter;
+    inv[7] = (p1[1] * p1[4] - p1[0] * p1[5]) / deter;
+    inv[8] = (p1[0] * p1[3] - p1[1] * p1[2]) / deter;
+
+    outModel.at<float>(0) = inv[0] * p2[0] + inv[1] * p2[2] + inv[2] * p2[4];
+    outModel.at<float>(1) = inv[3] * p2[0] + inv[4] * p2[2] + inv[5] * p2[4];
+    outModel.at<float>(2) = inv[6] * p2[0] + inv[7] * p2[2] + inv[8] * p2[4];
+    outModel.at<float>(3) = inv[0] * p2[1] + inv[1] * p2[3] + inv[2] * p2[5];
+    outModel.at<float>(4) = inv[3] * p2[1] + inv[4] * p2[3] + inv[5] * p2[5];
+    outModel.at<float>(5) = inv[6] * p2[1] + inv[7] * p2[3] + inv[8] * p2[5];
+
+    return 0;
+}
+CV_EXPORTS_W
+
+Ptr<RICInterpolator> createRICInterpolator()
+{
+    return Ptr<RICInterpolator>(RICInterpolatorImpl::create());
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/structured_edge_detection.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/structured_edge_detection.cpp
new file mode 100644
index 00000000..ffd80660
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/structured_edge_detection.cpp
@@ -0,0 +1,902 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+#include <vector>
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+#include <cmath>
+
+#include "advanced_types.hpp"
+
+#ifdef CV_CXX11
+#define CV_USE_PARALLEL_PREDICT_EDGES_1 1
+#define CV_USE_PARALLEL_PREDICT_EDGES_2 0  //1, see https://github.com/opencv/opencv_contrib/issues/2346
+#else
+#define CV_USE_PARALLEL_PREDICT_EDGES_1 0
+#define CV_USE_PARALLEL_PREDICT_EDGES_2 0
+#endif
+
+/********************* Helper functions *********************/
+
+/*!
+ * Lightweight wrapper over cv::resize
+ *
+ * \param src : source image to resize
+ * \param dst : destination image size
+ * \return resized image
+ */
+static cv::Mat imresize(const cv::Mat &src, const cv::Size &nSize)
+{
+    cv::Mat dst;
+    if (nSize.width < src.size().width
+    &&  nSize.height < src.size().height)
+        cv::resize(src, dst, nSize, 0.0, 0.0, cv::INTER_AREA);
+    else
+        cv::resize(src, dst, nSize, 0.0, 0.0, cv::INTER_LINEAR);
+
+    return dst;
+}
+
+/*!
+ * The function filters src with triangle filter with radius equal rad
+ *
+ * \param src : source image to filter
+ * \param rad : radius of filtering kernel
+ * \return filtering result
+ */
+static cv::Mat imsmooth(const cv::Mat &src, const int rad)
+{
+    if (rad == 0)
+        return src;
+    else
+    {
+        const float p = 12.0f/rad/(rad + 2) - 2;
+        cv::Mat dst;
+
+        if (rad <= 1)
+        {
+            CV_INIT_VECTOR(kernelXY, float, {1/(p + 2), p/(p + 2), 1/(p + 2)});
+            cv::sepFilter2D(src, dst, -1, kernelXY, kernelXY);
+        }
+        else
+        {
+            float nrml = CV_SQR(rad + 1.0f);
+
+            std::vector <float> kernelXY(2*rad + 1);
+            for (int i = 0; i <= rad; ++i)
+            {
+                kernelXY[2*rad - i] = (i + 1) / nrml;
+                kernelXY[i] = (i + 1) / nrml;
+            }
+            sepFilter2D(src, dst, -1, kernelXY, kernelXY);
+        }
+
+        return dst;
+    }
+}
+
+/*!
+ *  The function implements rgb to luv conversion in a way similar
+ *  to UCSD computer vision toolbox
+ *
+ * \param src : source image (RGB, float, in [0;1]) to convert
+ * \return converted image in luv colorspace
+ */
+static cv::Mat rgb2luv(const cv::Mat &src)
+{
+    cv::Mat dst(src.size(), src.type());
+
+    const float a  = CV_CUBE(29.0f)/27;
+    const float y0 = 8.0f/a;
+
+    const float mX[] = {0.430574f, 0.341550f, 0.178325f};
+    const float mY[] = {0.222015f, 0.706655f, 0.071330f};
+    const float mZ[] = {0.020183f, 0.129553f, 0.939180f};
+
+    const float maxi= 1.0f/270;
+    const float minu=  -88*maxi;
+    const float minv= -134*maxi;
+
+    const float un = 0.197833f;
+    const float vn = 0.468331f;
+
+    // build (padded) lookup table for y->l conversion assuming y in [0,1]
+    std::vector <float> lTable(1024);
+    for (int i = 0; i < 1024; ++i)
+    {
+        float y = i/1024.0f;
+        float l = y > y0 ? 116*powf(y, 1.0f/3.0f) - 16 : y*a;
+
+        lTable[i] = l*maxi;
+    }
+    for (int i = 0; i < 40; ++i)
+        lTable.push_back(*--lTable.end());
+
+    const int nchannels = 3;
+
+    for (int i = 0; i < src.rows; ++i)
+    {
+        const float *pSrc = src.ptr<float>(i);
+        float *pDst = dst.ptr<float>(i);
+
+        for (int j = 0; j < src.cols*nchannels; j += nchannels)
+        {
+            const float rgb[] = {pSrc[j + 0], pSrc[j + 1], pSrc[j + 2]};
+
+            const float xyz[] = {mX[0]*rgb[0] + mX[1]*rgb[1] + mX[2]*rgb[2],
+                                 mY[0]*rgb[0] + mY[1]*rgb[1] + mY[2]*rgb[2],
+                                 mZ[0]*rgb[0] + mZ[1]*rgb[1] + mZ[2]*rgb[2]};
+            const float nz = 1.0f / float(xyz[0] + 15*xyz[1] + 3*xyz[2] + 1e-35);
+
+            const float l = pDst[j] = lTable[cvFloor(1024*xyz[1])];
+
+            pDst[j + 1] = l * (13*4*xyz[0]*nz - 13*un) - minu;;
+            pDst[j + 2] = l * (13*9*xyz[1]*nz - 13*vn) - minv;
+        }
+    }
+
+    return dst;
+}
+
+/*!
+ * The function computes gradient magnitude and weighted (with magnitude)
+ * orientation histogram. Magnitude is additionally normalized
+ * by dividing on imsmooth(M, gnrmRad) + 0.01;
+ *
+ * \param src : source image
+ * \param magnitude : gradient magnitude
+ * \param histogram : gradient orientation nBins-channels histogram
+ * \param nBins : number of gradient orientations
+ * \param pSize : factor to downscale histogram
+ * \param gnrmRad : radius for magnitude normalization
+ */
+static void gradientHist(const cv::Mat &src, cv::Mat &magnitude, cv::Mat &histogram,
+                         const int nBins, const int pSize, const int gnrmRad)
+{
+    cv::Mat phase, Dx, Dy;
+
+    magnitude.create( src.size(), cv::DataType<float>::type );
+    phase.create( src.size(), cv::DataType<float>::type );
+    histogram.create( cv::Size( cvCeil(src.size().width/float(pSize)),
+                                cvCeil(src.size().height/float(pSize)) ),
+        CV_MAKETYPE(cv::DataType<float>::type, nBins) );
+
+    histogram.setTo(0);
+
+    cv::Sobel( src, Dx, cv::DataType<float>::type,
+        1, 0, 1, 1.0, 0.0, cv::BORDER_REFLECT );
+    cv::Sobel( src, Dy, cv::DataType<float>::type,
+        0, 1, 1, 1.0, 0.0, cv::BORDER_REFLECT );
+
+    int nchannels = src.channels();
+
+    for (int i = 0; i < src.rows; ++i)
+    {
+        const float *pDx = Dx.ptr<float>(i);
+        const float *pDy = Dy.ptr<float>(i);
+
+        float *pMagnitude = magnitude.ptr<float>(i);
+        float *pPhase = phase.ptr<float>(i);
+
+        for (int j = 0; j < src.cols*nchannels; j += nchannels)
+        {
+            float fMagn = float(-1e-5), fdx = 0, fdy = 0;
+            for (int k = 0; k < nchannels; ++k)
+            {
+                float cMagn = CV_SQR( pDx[j + k] ) + CV_SQR( pDy[j + k] );
+                if (cMagn > fMagn)
+                {
+                    fMagn = cMagn;
+                    fdx = pDx[j + k];
+                    fdy = pDy[j + k];
+                }
+            }
+
+            pMagnitude[j/nchannels] = sqrtf(fMagn);
+
+            float angle = cv::fastAtan2(fdy, fdx) / 180.0f - 1.0f * (fdy < 0);
+            if (std::fabs(fdx) + std::fabs(fdy) < 1e-5)
+                angle = 0.5f;
+            pPhase[j/nchannels] = angle;
+        }
+    }
+
+    magnitude /= imsmooth( magnitude, gnrmRad )
+        + 0.01*cv::Mat::ones( magnitude.size(), magnitude.type() );
+
+    for (int i = 0; i < phase.rows; ++i)
+    {
+        const float *pPhase = phase.ptr<float>(i);
+        const float *pMagn  = magnitude.ptr<float>(i);
+
+        float *pHist = histogram.ptr<float>(i/pSize);
+
+        for (int j = 0; j < phase.cols; ++j)
+        {
+            int angle = cvRound(pPhase[j]*nBins);
+            if(angle >= nBins)
+            {
+              angle = 0;
+            }
+            const int index = (j/pSize)*nBins + angle;
+            pHist[index] += pMagn[j] / CV_SQR(pSize);
+        }
+    }
+}
+
+/*!
+ * The class parallelizing the edgenms algorithm.
+ *
+ * \param E : edge image
+ * \param O : orientation image
+ * \param dst : destination image
+ * \param r : radius for NMS suppression
+ * \param s : radius for boundary suppression
+ * \param m : multiplier for conservative suppression
+ */
+class NmsInvoker : public cv::ParallelLoopBody
+{
+
+private:
+  const cv::Mat &E;
+  const cv::Mat &O;
+  cv::Mat &dst;
+  const int r;
+  const float m;
+
+public:
+  NmsInvoker(const cv::Mat &_E, const cv::Mat &_O, cv::Mat &_dst, const int _r, const float _m)
+              : E(_E), O(_O), dst(_dst), r(_r), m(_m)
+              {
+              }
+
+  void operator()(const cv::Range &range) const CV_OVERRIDE
+  {
+     for (int x = range.start; x < range.end; x++)
+     {
+       const float *e_ptr = E.ptr<float>(x);
+       const float *o_ptr = O.ptr<float>(x);
+       float *dst_ptr = dst.ptr<float>(x);
+       for (int y=0; y < E.cols; y++)
+       {
+         float e = e_ptr[y];
+         dst_ptr[y] = e;
+         if (!e) continue;
+         e *= m;
+         float coso = cos(o_ptr[y]);
+         float sino = sin(o_ptr[y]);
+         for (int d=-r; d<=r; d++)
+         {
+           if (d)
+           {
+             float xdcos = x+d*coso;
+             float ydsin = y+d*sino;
+             xdcos = xdcos < 0 ? 0 : (xdcos > E.rows - 1.001f ? E.rows - 1.001f : xdcos);
+             ydsin = ydsin < 0 ? 0 : (ydsin > E.cols - 1.001f ? E.cols - 1.001f : ydsin);
+             int x0 = (int)xdcos;
+             int y0 = (int)ydsin;
+             int x1 = x0 + 1;
+             int y1 = y0 + 1;
+             float dx0 = xdcos - x0;
+             float dy0 = ydsin - y0;
+             float dx1 = 1 - dx0;
+             float dy1 = 1 - dy0;
+             float e0 = E.at<float>(x0, y0) * dx1 * dy1 +
+                         E.at<float>(x1, y0) * dx0 * dy1 +
+                         E.at<float>(x0, y1) * dx1 * dy0 +
+                         E.at<float>(x1, y1) * dx0 * dy0;
+
+             if(e < e0)
+             {
+               dst_ptr[y] = 0;
+               break;
+             }
+           }
+         }
+
+       }
+     }
+  }
+};
+
+/********************* RFFeatureGetter class *********************/
+
+namespace cv
+{
+namespace ximgproc
+{
+
+class RFFeatureGetterImpl : public RFFeatureGetter
+{
+public:
+    /*!
+     * Default constructor
+     */
+    RFFeatureGetterImpl() : name("RFFeatureGetter"){}
+
+    /*!
+     * The method extracts features from img and store them to features.
+     * Extracted features are appropriate for StructuredEdgeDetection::predictEdges.
+     *
+     * \param src : source image (RGB, float, in [0;1]) to extract features
+     * \param features : destination feature image
+     *
+     * \param gnrmRad : __rf.options.gradientNormalizationRadius
+     * \param gsmthRad : __rf.options.gradientSmoothingRadius
+     * \param shrink : __rf.options.shrinkNumber
+     * \param outNum : __rf.options.numberOfOutputChannels
+     * \param gradNum : __rf.options.numberOfGradientOrientations
+     */
+    virtual void getFeatures(const Mat &src, Mat &features, const int gnrmRad, const int gsmthRad,
+                             const int shrink, const int outNum, const int gradNum) const CV_OVERRIDE
+    {
+        cv::Mat luvImg = rgb2luv(src);
+
+        std::vector <cv::Mat> featureArray;
+
+        cv::Size nSize = src.size() / float(shrink);
+        split( imresize(luvImg, nSize), featureArray );
+
+        CV_INIT_VECTOR(scales, float, {1.0f, 0.5f});
+
+        for (size_t i = 0; i < scales.size(); ++i)
+        {
+            int pSize = std::max( 1, int(shrink*scales[i]) );
+
+            cv::Mat magnitude, histogram;
+            gradientHist(/**/ imsmooth(imresize(luvImg, scales[i]*src.size()), gsmthRad),
+                magnitude, histogram, gradNum, pSize, gnrmRad /**/);
+
+            featureArray.push_back(/**/ imresize( magnitude, nSize ).clone() /**/);
+            featureArray.push_back(/**/ imresize( histogram, nSize ).clone() /**/);
+        }
+
+        // Mixing
+        int resType = CV_MAKETYPE(cv::DataType<float>::type, outNum);
+        features.create(nSize, resType);
+
+        std::vector <int> fromTo;
+        for (int i = 0; i < 2*outNum; ++i)
+            fromTo.push_back(i/2);
+
+        mixChannels(featureArray, features, fromTo);
+    }
+
+protected:
+    /*! algorithm name */
+    String name;
+};
+
+Ptr<RFFeatureGetter> createRFFeatureGetter()
+{
+        return makePtr<RFFeatureGetterImpl>();
+}
+
+}
+}
+
+/********************* StructuredEdgeDetection class *********************/
+
+namespace cv
+{
+namespace ximgproc
+{
+
+class StructuredEdgeDetectionImpl : public StructuredEdgeDetection
+{
+public:
+    /*!
+     * This constructor loads __rf model from filename
+     *
+     * \param filename : name of the file where the model is stored
+     */
+    StructuredEdgeDetectionImpl(const cv::String &filename,
+        Ptr<const RFFeatureGetter> _howToGetFeatures)
+        : name("StructuredEdgeDetection"),
+          howToGetFeatures( (!_howToGetFeatures.empty())
+                          ? _howToGetFeatures
+                          : createRFFeatureGetter().staticCast<const RFFeatureGetter>() )
+    {
+        cv::FileStorage modelFile(filename, FileStorage::READ);
+        CV_Assert( modelFile.isOpened() );
+
+        __rf.options.stride
+            = modelFile["options"]["stride"];
+        __rf.options.shrinkNumber
+            = modelFile["options"]["shrinkNumber"];
+        __rf.options.patchSize
+            = modelFile["options"]["patchSize"];
+        __rf.options.patchInnerSize
+            = modelFile["options"]["patchInnerSize"];
+
+        __rf.options.numberOfGradientOrientations
+            = modelFile["options"]["numberOfGradientOrientations"];
+        __rf.options.gradientSmoothingRadius
+            = modelFile["options"]["gradientSmoothingRadius"];
+        __rf.options.regFeatureSmoothingRadius
+            = modelFile["options"]["regFeatureSmoothingRadius"];
+        __rf.options.ssFeatureSmoothingRadius
+            = modelFile["options"]["ssFeatureSmoothingRadius"];
+        __rf.options.gradientNormalizationRadius
+            = modelFile["options"]["gradientNormalizationRadius"];
+
+        __rf.options.selfsimilarityGridSize
+            = modelFile["options"]["selfsimilarityGridSize"];
+
+        __rf.options.numberOfTrees
+            = modelFile["options"]["numberOfTrees"];
+        __rf.options.numberOfTreesToEvaluate
+            = modelFile["options"]["numberOfTreesToEvaluate"];
+
+        __rf.options.numberOfOutputChannels =
+            2*(__rf.options.numberOfGradientOrientations + 1) + 3;
+        //--------------------------------------------
+
+        cv::FileNode childs = modelFile["childs"];
+        cv::FileNode featureIds = modelFile["featureIds"];
+
+        std::vector <int> currentTree;
+
+        for(cv::FileNodeIterator it = childs.begin();
+            it != childs.end(); ++it)
+        {
+            (*it) >> currentTree;
+            std::copy(currentTree.begin(), currentTree.end(),
+                std::back_inserter(__rf.childs));
+        }
+
+        for(cv::FileNodeIterator it = featureIds.begin();
+            it != featureIds.end(); ++it)
+        {
+            (*it) >> currentTree;
+            std::copy(currentTree.begin(), currentTree.end(),
+                std::back_inserter(__rf.featureIds));
+        }
+
+        cv::FileNode thresholds = modelFile["thresholds"];
+        std::vector <float> fcurrentTree;
+
+        for(cv::FileNodeIterator it = thresholds.begin();
+            it != thresholds.end(); ++it)
+        {
+            (*it) >> fcurrentTree;
+            std::copy(fcurrentTree.begin(), fcurrentTree.end(),
+                std::back_inserter(__rf.thresholds));
+        }
+
+        cv::FileNode edgeBoundaries = modelFile["edgeBoundaries"];
+        cv::FileNode edgeBins = modelFile["edgeBins"];
+
+        for(cv::FileNodeIterator it = edgeBoundaries.begin();
+            it != edgeBoundaries.end(); ++it)
+        {
+            (*it) >> currentTree;
+            std::copy(currentTree.begin(), currentTree.end(),
+                std::back_inserter(__rf.edgeBoundaries));
+        }
+
+        for(cv::FileNodeIterator it = edgeBins.begin();
+            it != edgeBins.end(); ++it)
+        {
+            (*it) >> currentTree;
+            std::copy(currentTree.begin(), currentTree.end(),
+                std::back_inserter(__rf.edgeBins));
+        }
+
+        __rf.numberOfTreeNodes = int( __rf.childs.size() ) / __rf.options.numberOfTrees;
+    }
+
+    /*!
+     * The function detects edges in src and draw them to dst
+     *
+     * \param _src : source image (RGB, float, in [0;1]) to detect edges
+     * \param _dst : destination image (grayscale, float, in [0;1])
+     *              where edges are drawn
+     */
+    void detectEdges(cv::InputArray _src, cv::OutputArray _dst) const CV_OVERRIDE
+    {
+        CV_Assert( _src.type() == CV_32FC3 );
+
+        _dst.createSameSize( _src, cv::DataType<float>::type );
+        _dst.setTo(0);
+        Mat dst = _dst.getMat();
+
+        int padding = ( __rf.options.patchSize
+            - __rf.options.patchInnerSize )/2;
+
+        cv::Mat nSrc;
+        copyMakeBorder( _src, nSrc, padding, padding,
+            padding, padding, BORDER_REFLECT );
+
+        NChannelsMat features;
+        createRFFeatureGetter()->getFeatures( nSrc, features,
+            __rf.options.gradientNormalizationRadius,
+            __rf.options.gradientSmoothingRadius,
+            __rf.options.shrinkNumber,
+            __rf.options.numberOfOutputChannels,
+            __rf.options.numberOfGradientOrientations );
+        predictEdges( features, dst );
+    }
+
+    /*!
+     * The function computes orientation from edge image.
+     *
+     * \param src : edge image.
+     * \param dst : orientation image.
+     * \param r : filter radius.
+     */
+    void computeOrientation(cv::InputArray _src, cv::OutputArray _dst) const CV_OVERRIDE
+    {
+      CV_Assert( _src.type() == CV_32FC1 );
+
+      cv::Mat Oxx, Oxy, Oyy;
+
+      _dst.createSameSize( _src, _src.type() );
+      _dst.setTo(0);
+
+      Mat src = _src.getMat();
+      cv::Mat E_conv = imsmooth(src, __rf.options.gradientNormalizationRadius);
+
+      Sobel(E_conv, Oxx, -1, 2, 0);
+      Sobel(E_conv, Oxy, -1, 1, 1);
+      Sobel(E_conv, Oyy, -1, 0, 2);
+
+      Mat dst = _dst.getMat();
+      float *o = dst.ptr<float>();
+      float *oxx = Oxx.ptr<float>();
+      float *oxy = Oxy.ptr<float>();
+      float *oyy = Oyy.ptr<float>();
+      for (int i = 0; i < dst.rows * dst.cols; i++)
+      {
+          int xysign = -((oxy[i] > 0) - (oxy[i] < 0));
+          o[i] = (atan((oyy[i] * xysign / (oxx[i] + 1e-5))) > 0) ? (float) fmod(
+                  atan((oyy[i] * xysign / (oxx[i] + 1e-5))), CV_PI) : (float) fmod(
+                  atan((oyy[i] * xysign / (oxx[i] + 1e-5))) + CV_PI, CV_PI);
+      }
+    }
+
+     /*!
+     * The function suppress edges where edge is stronger in orthogonal direction
+     * \param edge_image : edge image from detectEdges function.
+     * \param orientation_image : orientation image from computeOrientation function.
+     * \param _dst : suppressed image (grayscale, float, in [0;1])
+     * \param r : radius for NMS suppression.
+     * \param s : radius for boundary suppression.
+     * \param m : multiplier for conservative suppression.
+     * \param isParallel: enables/disables parallel computing.
+     */
+    void edgesNms(cv::InputArray edge_image, cv::InputArray orientation_image, cv::OutputArray _dst, int r, int s, float m, bool isParallel) const CV_OVERRIDE
+    {
+        CV_Assert(edge_image.type() == CV_32FC1);
+        CV_Assert(orientation_image.type() == CV_32FC1);
+
+        cv::Mat E = edge_image.getMat();
+        cv::Mat O = orientation_image.getMat();
+        cv::Mat E_t = E.t();
+        cv::Mat O_t = O.t();
+
+        cv::Mat dst = _dst.getMat();
+        dst.create(E.cols, E.rows, E.type());
+        dst.setTo(0);
+
+        cv::Range sizeRange = cv::Range(0, E_t.rows);
+        NmsInvoker body = NmsInvoker(E_t, O_t, dst, r, m);
+        if (isParallel)
+        {
+          cv::parallel_for_(sizeRange, body);
+        } else
+        {
+          body(sizeRange);
+        }
+
+        s = s > E_t.rows / 2 ? E_t.rows / 2 : s;
+        s = s > E_t.cols / 2 ? E_t.cols / 2 : s;
+        for (int x=0; x<s; x++)
+        {
+          for (int y=0; y<E_t.cols; y++)
+          {
+            dst.at<float>(x, y) *= x / (float)s;
+            dst.at<float>(E_t.rows-1-x, y) *= x / (float)s;
+          }
+        }
+
+        for (int x=0; x < E_t.rows; x++)
+        {
+          for (int y=0; y < s; y++)
+          {
+            dst.at<float>(x, y) *= y / (float)s;
+            dst.at<float>(x, E_t.cols-1-y) *= y / (float)s;
+          }
+        }
+      transpose(dst, dst);
+      dst.copyTo(_dst);
+    }
+
+
+protected:
+    /*!
+     * Private method used by process method. The function
+     * predict edges in n-channel feature image and store them to dst.
+     *
+     * \param features : source image (n-channels, float) to detect edges
+     * \param dst : destination image (grayscale, float, in [0;1]) where edges are drawn
+     */
+    void predictEdges(const NChannelsMat &features, cv::Mat &dst) const
+    {
+        int shrink = __rf.options.shrinkNumber;
+        int rfs = __rf.options.regFeatureSmoothingRadius;
+        int sfs = __rf.options.ssFeatureSmoothingRadius;
+
+        int nTreesEval = __rf.options.numberOfTreesToEvaluate;
+        int nTrees = __rf.options.numberOfTrees;
+        int nTreesNodes = __rf.numberOfTreeNodes;
+
+        const int nchannels = features.channels();
+        int pSize  = __rf.options.patchSize;
+
+        int nFeatures = CV_SQR(pSize/shrink)*nchannels;
+        int outNum = __rf.options.numberOfOutputChannels;
+
+        int stride = __rf.options.stride;
+        int ipSize = __rf.options.patchInnerSize;
+        int gridSize = __rf.options.selfsimilarityGridSize;
+
+        const int height = cvCeil( double(features.rows*shrink - pSize) / stride );
+        const int width  = cvCeil( double(features.cols*shrink - pSize) / stride );
+        // image size in patches with overlapping
+
+        //-------------------------------------------------------------------------
+
+        NChannelsMat regFeatures = imsmooth(features, cvRound(rfs / float(shrink)));
+        NChannelsMat  ssFeatures = imsmooth(features, cvRound(sfs / float(shrink)));
+
+        NChannelsMat indexes(height, width, CV_MAKETYPE(DataType<int>::type, nTreesEval));
+
+        std::vector <int> offsetI(/**/ CV_SQR(pSize/shrink)*nchannels, 0);
+        for (int i = 0; i < CV_SQR(pSize/shrink)*nchannels; ++i)
+        {
+            int z = i / CV_SQR(pSize/shrink);
+            int y = ( i % CV_SQR(pSize/shrink) )/(pSize/shrink);
+            int x = ( i % CV_SQR(pSize/shrink) )%(pSize/shrink);
+
+            offsetI[i] = x*features.cols*nchannels + y*nchannels + z;
+        }
+        // lookup table for mapping linear index to offsets
+
+        std::vector <int> offsetE(/**/ CV_SQR(ipSize)*outNum, 0);
+        for (int i = 0; i < CV_SQR(ipSize)*outNum; ++i)
+        {
+            int z = i / CV_SQR(ipSize);
+            int y = ( i % CV_SQR(ipSize) )/ipSize;
+            int x = ( i % CV_SQR(ipSize) )%ipSize;
+
+            offsetE[i] = x*dst.cols*outNum + y*outNum + z;
+        }
+        // lookup table for mapping linear index to offsets
+
+        std::vector <int> offsetX( CV_SQR(gridSize)*(CV_SQR(gridSize) - 1)/2 * nchannels, 0);
+        std::vector <int> offsetY( CV_SQR(gridSize)*(CV_SQR(gridSize) - 1)/2 * nchannels, 0);
+
+        int hc = cvRound( (pSize/shrink) / (2.0*gridSize) );
+        // half of cell
+        std::vector <int> gridPositions;
+        for(int i = 0; i < gridSize; i++)
+            gridPositions.push_back( int( (i+1)*(pSize/shrink + 2*hc - 1)/(gridSize + 1.0) - hc + 0.5f ) );
+
+        for (int i = 0, n = 0; i < CV_SQR(gridSize)*nchannels; ++i)
+            for (int j = (i%CV_SQR(gridSize)) + 1; j < CV_SQR(gridSize); ++j, ++n)
+            {
+                int z = i / CV_SQR(gridSize);
+
+                int x1 = gridPositions[i%CV_SQR(gridSize)%gridSize];
+                int y1 = gridPositions[i%CV_SQR(gridSize)/gridSize];
+
+                int x2 = gridPositions[j%gridSize];
+                int y2 = gridPositions[j/gridSize];
+
+                offsetX[n] = x1*features.cols*nchannels + y1*nchannels + z;
+                offsetY[n] = x2*features.cols*nchannels + y2*nchannels + z;
+            }
+            // lookup tables for mapping linear index to offset pairs
+
+        #if CV_USE_PARALLEL_PREDICT_EDGES_1
+        parallel_for_(cv::Range(0, height), [&](const cv::Range& range)
+        #else
+        const cv::Range range(0, height);
+        #endif
+        {
+            for(int i = range.start; i < range.end; ++i) {
+                float *regFeaturesPtr = regFeatures.ptr<float>(i*stride/shrink);
+                float  *ssFeaturesPtr = ssFeatures.ptr<float>(i*stride/shrink);
+
+                int *indexPtr = indexes.ptr<int>(i);
+
+                for (int j = 0, k = 0; j < width; ++k, j += !(k %= nTreesEval))
+                    // for j,k in [0;width)x[0;nTreesEval)
+                {
+                    int baseNode = ( ((i + j)%(2*nTreesEval) + k)%nTrees )*nTreesNodes;
+                    int currentNode = baseNode;
+                    // select root node of the tree to evaluate
+
+                    int offset = (j*stride/shrink)*nchannels;
+                    while ( __rf.childs[currentNode] != 0 )
+                    {
+                        int currentId = __rf.featureIds[currentNode];
+                        float currentFeature;
+
+                        if (currentId >= nFeatures)
+                        {
+                            int xIndex = offsetX[currentId - nFeatures];
+                            float A = ssFeaturesPtr[offset + xIndex];
+
+                            int yIndex = offsetY[currentId - nFeatures];
+                            float B = ssFeaturesPtr[offset + yIndex];
+
+                            currentFeature = A - B;
+                        }
+                        else
+                            currentFeature = regFeaturesPtr[offset + offsetI[currentId]];
+
+                        // compare feature to threshold and move left or right accordingly
+                        if (currentFeature < __rf.thresholds[currentNode])
+                            currentNode = baseNode + __rf.childs[currentNode] - 1;
+                        else
+                            currentNode = baseNode + __rf.childs[currentNode];
+                    }
+
+                    indexPtr[j*nTreesEval + k] = currentNode;
+                }
+            }
+        }
+        #if CV_USE_PARALLEL_PREDICT_EDGES_1
+        );
+        #endif
+
+        NChannelsMat dstM(dst.size(),
+            CV_MAKETYPE(DataType<float>::type, outNum));
+        dstM.setTo(0);
+
+        float step = 2.0f * CV_SQR(stride) / CV_SQR(ipSize) / nTreesEval;
+        #if CV_USE_PARALLEL_PREDICT_EDGES_2
+        parallel_for_(cv::Range(0, height), [&](const cv::Range& range)
+        #elif CV_USE_PARALLEL_PREDICT_EDGES_1
+        const cv::Range range(0, height);
+        #endif
+        {
+            for(int i = range.start; i < range.end; ++i)
+            {
+                int *pIndex = indexes.ptr<int>(i);
+                float *pDst = dstM.ptr<float>(i*stride);
+
+                for (int j = 0, k = 0; j < width; ++k, j += !(k %= nTreesEval))
+                {// for j,k in [0;width)x[0;nTreesEval)
+
+                    int currentNode = pIndex[j*nTreesEval + k];
+                    size_t sizeBoundaries = __rf.edgeBoundaries.size();
+                    int convertedBoundaries = static_cast<int>(sizeBoundaries);
+                    int nBnds = (convertedBoundaries - 1) / (nTreesNodes * nTrees);
+                    int start = __rf.edgeBoundaries[currentNode * nBnds];
+                    int finish = __rf.edgeBoundaries[currentNode * nBnds + 1];
+
+                    if (start == finish)
+                        continue;
+
+                    int offset = j*stride*outNum;
+                    for (int p = start; p < finish; ++p)
+                        pDst[offset + offsetE[__rf.edgeBins[p]]] += step;
+                }
+            }
+        }
+        #if CV_USE_PARALLEL_PREDICT_EDGES_2
+        );
+        #endif
+
+        cv::reduce( dstM.reshape(1, int( dstM.total() ) ), dstM, 2, REDUCE_SUM);
+        imsmooth( dstM.reshape(1, dst.rows), 1 ).copyTo(dst);
+    }
+
+/********************* Members *********************/
+protected:
+    /*! algorithm name */
+    String name;
+
+    /*! optional feature getter (getFeatures method) */
+    Ptr<const RFFeatureGetter> howToGetFeatures;
+
+    /*! random forest used to detect edges */
+    struct RandomForest
+    {
+        /*! random forest options, e.g. number of trees */
+        struct RandomForestOptions
+        {
+            // model params
+
+            int numberOfOutputChannels; /*!< number of edge orientation bins for output */
+
+            int patchSize;              /*!< width of image patches */
+            int patchInnerSize;         /*!< width of predicted part inside patch*/
+
+            // feature params
+
+            int regFeatureSmoothingRadius;    /*!< radius for smoothing of regular features
+                                               *   (using convolution with triangle filter) */
+
+            int ssFeatureSmoothingRadius;     /*!< radius for smoothing of additional features
+                                               *   (using convolution with triangle filter) */
+
+            int shrinkNumber;                 /*!< amount to shrink channels */
+
+            int numberOfGradientOrientations; /*!< number of orientations per gradient scale */
+
+            int gradientSmoothingRadius;      /*!< radius for smoothing of gradients
+                                               *   (using convolution with triangle filter) */
+
+            int gradientNormalizationRadius;  /*!< gradient normalization radius */
+            int selfsimilarityGridSize;       /*!< number of self similarity cells */
+
+            // detection params
+            int numberOfTrees;            /*!< number of trees in forest to train */
+            int numberOfTreesToEvaluate;  /*!< number of trees to evaluate per location */
+
+            int stride;                   /*!< stride at which to compute edges */
+
+        } options;
+
+        int numberOfTreeNodes;
+
+        std::vector <int> featureIds;     /*!< feature coordinate thresholded at k-th node */
+        std::vector <float> thresholds;   /*!< threshold applied to featureIds[k] at k-th node */
+        std::vector <int> childs;         /*!< k --> child[k] - 1, child[k] */
+
+        std::vector <int> edgeBoundaries; /*!< ... */
+        std::vector <int> edgeBins;       /*!< ... */
+    } __rf;
+};
+
+Ptr<StructuredEdgeDetection> createStructuredEdgeDetection(const String &model,
+    Ptr<const RFFeatureGetter> howToGetFeatures)
+{
+        return makePtr<StructuredEdgeDetectionImpl>(model, howToGetFeatures);
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/thinning.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/thinning.cpp
new file mode 100644
index 00000000..b28784d2
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/thinning.cpp
@@ -0,0 +1,93 @@
+#include "precomp.hpp"
+
+using namespace std;
+
+namespace cv {
+namespace ximgproc {
+
+// Applies a thinning iteration to a binary image
+static void thinningIteration(Mat img, int iter, int thinningType){
+    Mat marker = Mat::zeros(img.size(), CV_8UC1);
+
+    if(thinningType == THINNING_ZHANGSUEN){
+        for (int i = 1; i < img.rows-1; i++)
+        {
+            for (int j = 1; j < img.cols-1; j++)
+            {
+                uchar p2 = img.at<uchar>(i-1, j);
+                uchar p3 = img.at<uchar>(i-1, j+1);
+                uchar p4 = img.at<uchar>(i, j+1);
+                uchar p5 = img.at<uchar>(i+1, j+1);
+                uchar p6 = img.at<uchar>(i+1, j);
+                uchar p7 = img.at<uchar>(i+1, j-1);
+                uchar p8 = img.at<uchar>(i, j-1);
+                uchar p9 = img.at<uchar>(i-1, j-1);
+
+                int A  = (p2 == 0 && p3 == 1) + (p3 == 0 && p4 == 1) +
+                         (p4 == 0 && p5 == 1) + (p5 == 0 && p6 == 1) +
+                         (p6 == 0 && p7 == 1) + (p7 == 0 && p8 == 1) +
+                         (p8 == 0 && p9 == 1) + (p9 == 0 && p2 == 1);
+                int B  = p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9;
+                int m1 = iter == 0 ? (p2 * p4 * p6) : (p2 * p4 * p8);
+                int m2 = iter == 0 ? (p4 * p6 * p8) : (p2 * p6 * p8);
+
+                if (A == 1 && (B >= 2 && B <= 6) && m1 == 0 && m2 == 0)
+                    marker.at<uchar>(i,j) = 1;
+            }
+        }
+    }
+    if(thinningType == THINNING_GUOHALL){
+        for (int i = 1; i < img.rows-1; i++)
+        {
+            for (int j = 1; j < img.cols-1; j++)
+            {
+                uchar p2 = img.at<uchar>(i-1, j);
+                uchar p3 = img.at<uchar>(i-1, j+1);
+                uchar p4 = img.at<uchar>(i, j+1);
+                uchar p5 = img.at<uchar>(i+1, j+1);
+                uchar p6 = img.at<uchar>(i+1, j);
+                uchar p7 = img.at<uchar>(i+1, j-1);
+                uchar p8 = img.at<uchar>(i, j-1);
+                uchar p9 = img.at<uchar>(i-1, j-1);
+
+                int C  = ((!p2) & (p3 | p4)) + ((!p4) & (p5 | p6)) +
+                         ((!p6) & (p7 | p8)) + ((!p8) & (p9 | p2));
+                int N1 = (p9 | p2) + (p3 | p4) + (p5 | p6) + (p7 | p8);
+                int N2 = (p2 | p3) + (p4 | p5) + (p6 | p7) + (p8 | p9);
+                int N  = N1 < N2 ? N1 : N2;
+                int m  = iter == 0 ? ((p6 | p7 | (!p9)) & p8) : ((p2 | p3 | (!p5)) & p4);
+
+                if ((C == 1) && ((N >= 2) && ((N <= 3)) & (m == 0)))
+                    marker.at<uchar>(i,j) = 1;
+            }
+        }
+    }
+
+    img &= ~marker;
+}
+
+// Apply the thinning procedure to a given image
+void thinning(InputArray input, OutputArray output, int thinningType){
+    Mat processed = input.getMat().clone();
+    CV_CheckTypeEQ(processed.type(), CV_8UC1, "");
+    // Enforce the range of the input image to be in between 0 - 255
+    processed /= 255;
+
+    Mat prev = Mat::zeros(processed.size(), CV_8UC1);
+    Mat diff;
+
+    do {
+        thinningIteration(processed, 0, thinningType);
+        thinningIteration(processed, 1, thinningType);
+        absdiff(processed, prev, diff);
+        processed.copyTo(prev);
+    }
+    while (countNonZero(diff) > 0);
+
+    processed *= 255;
+
+    output.assign(processed);
+}
+
+} //namespace ximgproc
+} //namespace cv
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/weighted_median_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/weighted_median_filter.cpp
new file mode 100644
index 00000000..c29b77b1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/src/weighted_median_filter.cpp
@@ -0,0 +1,743 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "precomp.hpp"
+#include <opencv2/imgproc.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace{
+
+using namespace cv::ximgproc;
+
+/***************************************************************/
+/* Function: from32FTo32S
+ * Description: adaptive quantization for changing a floating-point 1D image to integer image.
+ *                The adaptive quantization strategy is based on binary search, which searches an
+ *                upper bound of quantization error.
+ *                The function also return a mapping between quantized value (32F) and quantized index (32S).
+ *                The mapping is used to convert integer image back to floating-point image after filtering.
+ ***************************************************************/
+void from32FTo32S(Mat &img, Mat &outImg, int nI, float *mapping)
+{
+    int rows = img.rows, cols = img.cols;
+    size_t alls = (size_t)rows * cols;
+    CV_Assert(alls < INT_MAX);
+
+    CV_Assert(img.isContinuous());
+    float *imgPtr = img.ptr<float>();
+    typedef pair<float,int> pairFI;
+    std::vector<pairFI> data(alls);
+
+    // Sort all pixels of the image by ascending order of pixel value
+    for (size_t i = 0; i < alls; i++)
+    {
+        pairFI& d = data[i];
+        d.second = (int)i;
+        d.first = imgPtr[i];
+    }
+
+    struct PixelValueOrder {
+        static bool compare(const pairFI &a, const pairFI &b) {
+            return a.first < b.first;
+        }
+    };
+    sort(data.begin(), data.end(), PixelValueOrder::compare);
+
+    // Find lower bound and upper bound of the pixel values
+    double maxVal = data[alls - 1].first, minVal = data[0].first;
+
+    const float maxRange = (float)(maxVal - minVal);
+
+    float l = 0, r = maxRange*2.0f/nI;
+    // Perform binary search on error bound
+    while (r > l)
+    {
+        float m = (r + l) * 0.5f;
+        if (m == r || m == l)
+            break;  // bailout on numeric accuracy limit
+        bool suc = true;
+        float base = (float)minVal;
+        int cnt = 0;
+        for (size_t i = 0; i < alls; i++)
+        {
+            if (data[i].first > base + m)
+            {
+                cnt++;
+                base = data[i].first;
+                if (cnt == nI)
+                {
+                    suc = false;
+                    break;
+                }
+            }
+        }
+        if (suc)
+            r = m;
+        else
+            l = m;
+    }
+
+    Mat retImg(img.size(),CV_32SC1);
+    CV_Assert(retImg.isContinuous());
+    int *retImgPtr = retImg.ptr<int>();
+
+    // In the sorted list, divide pixel values into clusters according to the minimum error bound
+    // Quantize each value to the median of its cluster
+    // Also record the mapping of quantized value and quantized index.
+    float base = (float)minVal;
+    int baseI = 0;
+    int cnt = 0;
+    for (size_t i = 0; i < alls; i++)
+    {
+        if (data[i].first > base + r)
+        {
+            mapping[cnt] = data[(baseI+i-1)>>1].first; //median
+            cnt++;
+            base = data[i].first;
+            baseI = (int)i;
+        }
+        retImgPtr[data[i].second] = cnt;
+    }
+    // tail: i == alls
+    mapping[cnt] = data[(baseI+alls-1)>>1].first; // median
+
+    //end of the function
+    swap(outImg, retImg);
+}
+
+/***************************************************************/
+/* Function: from32STo32F
+ * Description: convert the quantization index image back to the floating-point image accroding to the mapping
+***************************************************************/
+void from32STo32F(Mat &img, Mat &outImg, float *mapping)
+{
+    Mat retImg(img.size(),CV_32F);
+    CV_Assert(img.isContinuous());
+    CV_Assert(retImg.isContinuous());
+    int rows = img.rows, cols = img.cols, alls = rows*cols;
+    float *retImgPtr = retImg.ptr<float>();
+    int *imgPtr = img.ptr<int>();
+
+    // convert 32S index to 32F real value
+    for(int i=0;i<alls;i++)
+    {
+        retImgPtr[i] = mapping[imgPtr[i]];
+    }
+
+    // end of the function
+    outImg = retImg;
+}
+
+
+/***************************************************************
+ * Function: float2D
+ * Description: allocate a 2D float array with dimension "dim1 x dim2"
+ ***************************************************************/
+float** float2D(int dim1, int dim2)
+{
+    float **ret = new float*[dim1];
+    ret[0] = new float[dim1*dim2];
+    for(int i=1;i<dim1;i++)ret[i] = ret[i-1]+dim2;
+
+    return ret;
+}
+
+/***************************************************************
+ * Function: float2D_release
+ * Description: deallocate the 2D array created by float2D()
+ ***************************************************************/
+void float2D_release(float **p)
+{
+    delete []p[0];
+    delete []p;
+}
+
+/***************************************************************
+ * Function: int2D
+ * Description: allocate a 2D integer array with dimension "dim1 x dim2"
+ ***************************************************************/
+int** int2D(int dim1, int dim2)
+{
+    int **ret = new int*[dim1];
+    ret[0] = new int[dim1*dim2];
+    for(int i=1;i<dim1;i++)ret[i] = ret[i-1]+dim2;
+
+    return ret;
+}
+
+/***************************************************************
+ * Function: int2D_release
+ * Description: deallocate the 2D array created by int2D()
+ ***************************************************************/
+void int2D_release(int **p)
+{
+    delete []p[0];
+    delete []p;
+}
+
+/***************************************************************
+ * Function: updateBCB
+ * Description: maintain the necklace table of BCB
+ ***************************************************************/
+inline void updateBCB(int &num,int *f,int *b,int i,int v)
+{
+    static int p1,p2;
+
+    if(i)
+    {
+        if(!num)
+        { // cell is becoming non-empty
+            p2=f[0];
+            f[0]=i;
+            f[i]=p2;
+            b[p2]=i;
+            b[i]=0;
+        }
+        else if(!(num+v))
+        {// cell is becoming empty
+            p1=b[i],p2=f[i];
+            f[p1]=p2;
+            b[p2]=p1;
+        }
+    }
+
+    // update the cell count
+    num += v;
+}
+
+/***************************************************************
+ * Function: featureIndexing
+ * Description: convert uchar feature image "F" to CV_32SC1 type.
+ *                If F is 3-channel, perform k-means clustering
+ *                If F is 1-channel, only perform type-casting
+ ***************************************************************/
+void featureIndexing(Mat &F, float **&wMap, int &nF, float sigmaI, int weightType){
+    // Configuration and Declaration
+    Mat FNew;
+    int cols = F.cols, rows = F.rows;
+    int alls = cols * rows;
+    int KmeansAttempts=1;
+
+    /* For 1 channel feature image (uchar)*/
+    if(F.channels() == 1)
+    {
+        nF = 256;
+
+        // Type-casting
+        F.convertTo(FNew, CV_32S);
+
+        // Compute weight map (weight between each pair of feature index)
+        wMap = float2D(nF,nF);
+        float nSigmaI = sigmaI;
+        float divider = (1.0f/(2*nSigmaI*nSigmaI));
+
+        for(int i=0;i<nF;i++)
+        {
+            for(int j=i;j<nF;j++)
+            {
+                float diff = fabs((float)(i-j));
+                float val;
+
+                switch(weightType)
+                {
+                    case WMF_EXP: val = exp(-(diff*diff)*divider); break;
+                    case WMF_IV1: val = 1.0f/(diff+nSigmaI); break;
+                    case WMF_IV2: val = 1.0f / (diff*diff+nSigmaI*nSigmaI); break;
+                    case WMF_COS: val = 1.0f; break;
+                    case WMF_JAC: val = (float)(min(i,j)*1.0/max(i,j)); break;
+                    case WMF_OFF: val = 1.0f; break;
+                    default: val = exp(-(diff*diff)*divider);
+                }
+
+                wMap[i][j] = wMap[j][i] = val;
+            }
+        }
+    }
+
+    /* For 3 channel feature image (uchar)*/
+    else if(F.channels() == 3)
+    {
+        const int shift = 2; // 256(8-bit)->64(6-bit)
+        const int LOW_NUM = 256>>shift;
+        static int hash[LOW_NUM][LOW_NUM][LOW_NUM]={{{0}}};
+
+        memset(hash,0,sizeof(hash));
+
+        // throw pixels into a 2D histogram
+        int candCnt = 0;
+        {
+            int lowR,lowG,lowB;
+            uchar *FPtr = F.ptr<uchar>();
+            for(int i=0,i3=0;i<alls;i++,i3+=3)
+            {
+                lowB = FPtr[i3]>>shift;
+                lowG = FPtr[i3+1]>>shift;
+                lowR = FPtr[i3+2]>>shift;
+
+                if(hash[lowB][lowG][lowR]==0)
+                {
+                    candCnt++;
+                    hash[lowB][lowG][lowR]=1;
+                }
+            }
+        }
+
+        nF = min(nF, candCnt);
+        Mat samples(candCnt,3,CV_32F);
+
+        //prepare for K-means
+        int top=0;
+        for(int i=0;i<LOW_NUM;i++)for(int j=0;j<LOW_NUM;j++)for(int k=0;k<LOW_NUM;k++){
+            if(hash[i][j][k]){
+                samples.ptr<float>(top)[0] = (float)i;
+                samples.ptr<float>(top)[1] = (float)j;
+                samples.ptr<float>(top)[2] = (float)k;
+                top++;
+            }
+        }
+
+        //do K-means
+        Mat labels;
+        Mat centers;
+        kmeans(samples, nF, labels, TermCriteria(TermCriteria::MAX_ITER| TermCriteria::EPS, 0, 10000), KmeansAttempts, KMEANS_PP_CENTERS, centers );
+
+        //make connection (i,j,k) <-> index
+        top = 0;
+        for(int i=0;i<LOW_NUM;i++)for(int j=0;j<LOW_NUM;j++)for(int k=0;k<LOW_NUM;k++)
+        {
+            if(hash[i][j][k])
+            {
+                hash[i][j][k] = labels.ptr<int>(top)[0];
+                top++;
+            }
+        }
+
+        // generate index map
+        FNew = Mat(F.size(),CV_32SC1);
+
+        int lowR,lowG,lowB;
+        uchar *FPtr = F.ptr<uchar>();
+        for(int i=0,i3=0;i<alls;i++,i3+=3)
+        {
+            lowB = FPtr[i3]>>shift;
+            lowG = FPtr[i3+1]>>shift;
+            lowR = FPtr[i3+2]>>shift;
+
+            FNew.ptr<int>()[i] = hash[lowB][lowG][lowR];
+        }
+
+        // Compute weight map (weight between each pair of feature index)
+        wMap = float2D(nF,nF);
+        float nSigmaI = sigmaI/256.0f*LOW_NUM;
+        float divider = (1.0f/(2*nSigmaI*nSigmaI));
+
+        float *length = new float[nF];
+        for(int i=0;i<nF;i++)
+        {
+            float a0 = centers.ptr<float>(i)[0];
+            float a1 = centers.ptr<float>(i)[1];
+            float a2 = centers.ptr<float>(i)[2];
+            length[i] = sqrt(a0*a0+a1*a1+a2*a2);
+        }
+
+        for(int i=0;i<nF;i++)
+        {
+            for(int j=i;j<nF;j++)
+            {
+                float a0 = centers.ptr<float>(i)[0], b0 = centers.ptr<float>(j)[0];
+                float a1 = centers.ptr<float>(i)[1], b1 = centers.ptr<float>(j)[1];
+                float a2 = centers.ptr<float>(i)[2], b2 = centers.ptr<float>(j)[2];
+                float diff0 = a0-b0;
+                float diff1 = a1-b1;
+                float diff2 = a2-b2;
+
+                float val;
+
+                switch(weightType)
+                {
+                    case WMF_EXP: val = exp(-(diff0*diff0+diff1*diff1+diff2*diff2)*divider); break;
+                    case WMF_IV1: val = 1.0f/(fabs(diff0)+fabs(diff1)+fabs(diff2)+nSigmaI); break;
+                    case WMF_IV2: val = 1.0f / (diff0*diff0+diff1*diff1+diff2*diff2+nSigmaI*nSigmaI); break;
+                    case WMF_COS: val = (a0*b0+a1*b1+a2*b2)/(length[i]*length[j]); break;
+                    case WMF_JAC: val = (min(a0,b0)+min(a1,b1)+min(a2,b2))/(max(a0,b0)+max(a1,b1)+max(a2,b2)); break;
+                    case WMF_OFF: val = 1.0f; break;
+                    default: val = exp(-(diff0*diff0+diff1*diff1+diff2*diff2)*divider);
+                }
+
+                wMap[i][j] = wMap[j][i] = val;
+            }
+        }
+
+        delete []length;
+    }
+    //end of the function
+    F = FNew;
+}
+
+Mat filterCore(Mat &I, Mat &F, float **wMap, int r=20, int nF=256, int nI=256, Mat mask=Mat())
+{
+    // Check validation
+    assert(I.depth() == CV_32S && I.channels()==1);//input image: 32SC1
+    assert(F.depth() == CV_32S && F.channels()==1);//feature image: 32SC1
+
+    // Configuration and declaration
+    int rows = I.rows, cols = I.cols;
+    Mat outImg = I.clone();
+
+    // Handle Mask
+    if(mask.empty())
+    {
+        mask = Mat(I.size(),CV_8U);
+        mask = Scalar(1);
+    }
+
+    // Allocate memory for joint-histogram and BCB
+    int **H = int2D(nI,nF);
+    int *BCB = new int[nF];
+
+    // Allocate links for necklace table
+    int **Hf = int2D(nI,nF);//forward link
+    int **Hb = int2D(nI,nF);//backward link
+    int *BCBf = new int[nF];//forward link
+    int *BCBb = new int[nF];//backward link
+
+    // Column Scanning
+    for(int x=0;x<cols;x++)
+    {
+        // Reset histogram and BCB for each column
+        memset(BCB, 0, sizeof(int)*nF);
+        memset(H[0], 0, sizeof(int)*nF*nI);
+        for(int i=0;i<nI;i++)Hf[i][0]=Hb[i][0]=0;
+        BCBf[0]=BCBb[0]=0;
+
+        // Reset cut-point
+        int medianVal = -1;
+
+        // Precompute "x" range and checks boundary
+        int downX = max(0,x-r);
+        int upX = min(cols-1,x+r);
+
+        // Initialize joint-histogram and BCB for the first window
+        int upY = min(rows-1,r);
+        for(int i=0;i<=upY;i++)
+        {
+            int *IPtr = I.ptr<int>(i);
+            int *FPtr = F.ptr<int>(i);
+            uchar *maskPtr = mask.ptr<uchar>(i);
+
+            for(int j=downX;j<=upX;j++)
+            {
+                if(!maskPtr[j])continue;
+
+                int fval = IPtr[j];
+                int *curHist = H[fval];
+                int gval = FPtr[j];
+
+                // Maintain necklace table of joint-histogram
+                if(!curHist[gval] && gval)
+                {
+                    int *curHf = Hf[fval];
+                    int *curHb = Hb[fval];
+
+                    int p1=0,p2=curHf[0];
+                    curHf[p1]=gval;
+                    curHf[gval]=p2;
+                    curHb[p2]=gval;
+                    curHb[gval]=p1;
+                }
+
+                curHist[gval]++;
+                // Maintain necklace table of BCB
+                updateBCB(BCB[gval],BCBf,BCBb,gval,-1);
+            }
+        }
+
+        for(int y=0;y<rows;y++)
+        {
+            // Find weighted median with help of BCB and joint-histogram
+            float balanceWeight = 0;
+            int curIndex = F.ptr<int>(y,x)[0];
+            float *fPtr = wMap[curIndex];
+            int &curMedianVal = medianVal;
+
+            // Compute current balance
+            {
+                int i=0;
+                do
+                {
+                    balanceWeight += BCB[i]*fPtr[i];
+                    i=BCBf[i];
+                }while(i);
+            }
+
+            // Move cut-point to the left
+            if(balanceWeight >= 0)
+            {
+                for(;balanceWeight >= 0 && curMedianVal > 0; curMedianVal--)
+                {
+                    float curWeight = 0;
+                    int *nextHist = H[curMedianVal];
+                    int *nextHf = Hf[curMedianVal];
+
+                    // Compute weight change by shift cut-point
+                    int i=0;
+                    do
+                    {
+                        curWeight += (nextHist[i]<<1)*fPtr[i];
+
+                        // Update BCB and maintain the necklace table of BCB
+                        updateBCB(BCB[i],BCBf,BCBb,i,-(nextHist[i]<<1));
+
+                        i=nextHf[i];
+                    }while(i);
+
+                    balanceWeight -= curWeight;
+                }
+            }
+            // Move cut-point to the right
+            else if(balanceWeight < 0)
+            {
+                for(;balanceWeight < 0 && curMedianVal != nI-1; curMedianVal++)
+                {
+                    float curWeight = 0;
+                    int *nextHist = H[curMedianVal+1];
+                    int *nextHf = Hf[curMedianVal+1];
+
+                    // Compute weight change by shift cut-point
+                    int i=0;
+                    do
+                    {
+                        curWeight += (nextHist[i]<<1)*fPtr[i];
+
+                        // Update BCB and maintain the necklace table of BCB
+                        updateBCB(BCB[i],BCBf,BCBb,i,nextHist[i]<<1);
+
+                        i=nextHf[i];
+                    }while(i);
+                    balanceWeight += curWeight;
+                }
+            }
+
+            // Weighted median is found and written to the output image
+            if(curMedianVal != -1)
+            {
+                if(balanceWeight < 0)
+                    outImg.ptr<int>(y,x)[0] = curMedianVal+1;
+                else
+                    outImg.ptr<int>(y,x)[0] = curMedianVal;
+            }
+
+            // Update joint-histogram and BCB when local window is shifted.
+            int fval,gval,*curHist;
+
+            // Add entering pixels into joint-histogram and BCB
+            int rownum = y + r + 1;
+            if(rownum < rows)
+            {
+                    int *inputImgPtr = I.ptr<int>(rownum);
+                    int *guideImgPtr = F.ptr<int>(rownum);
+                    uchar *maskPtr = mask.ptr<uchar>(rownum);
+
+                    for(int j=downX;j<=upX;j++)
+                    {
+                        if(!maskPtr[j])continue;
+
+                        fval = inputImgPtr[j];
+                        curHist = H[fval];
+                        gval = guideImgPtr[j];
+
+                        // Maintain necklace table of joint-histogram
+                        if(!curHist[gval] && gval)
+                        {
+                            int *curHf = Hf[fval];
+                            int *curHb = Hb[fval];
+
+                            int p1=0,p2=curHf[0];
+                            curHf[gval]=p2;
+                            curHb[gval]=p1;
+                            curHf[p1]=curHb[p2]=gval;
+                        }
+
+                        curHist[gval]++;
+
+                        // Maintain necklace table of BCB
+                        updateBCB(BCB[gval],BCBf,BCBb,gval,((fval <= medianVal)<<1)-1);
+                    }
+                }
+
+
+                // Delete leaving pixels into joint-histogram and BCB
+                rownum = y - r;
+                if(rownum >= 0)
+                {
+                    int *inputImgPtr = I.ptr<int>(rownum);
+                    int *guideImgPtr = F.ptr<int>(rownum);
+                    uchar *maskPtr = mask.ptr<uchar>(rownum);
+
+                    for(int j=downX;j<=upX;j++)
+                    {
+                        if(!maskPtr[j])continue;
+
+                        fval = inputImgPtr[j];
+                        curHist = H[fval];
+                        gval = guideImgPtr[j];
+
+                        curHist[gval]--;
+
+                        // Maintain necklace table of joint-histogram
+                        if(!curHist[gval] && gval)
+                        {
+                            int *curHf = Hf[fval];
+                            int *curHb = Hb[fval];
+
+                            int p1=curHb[gval],p2=curHf[gval];
+                            curHf[p1]=p2;
+                            curHb[p2]=p1;
+                        }
+
+                        // Maintain necklace table of BCB
+                        updateBCB(BCB[gval],BCBf,BCBb,gval,-((fval <= medianVal)<<1)+1);
+                    }
+                }
+        }
+    }
+
+    // Deallocate the memory
+    {
+        delete []BCB;
+        delete []BCBf;
+        delete []BCBb;
+        int2D_release(H);
+        int2D_release(Hf);
+        int2D_release(Hb);
+    }
+
+    // end of the function
+    return outImg;
+}
+}
+
+namespace cv
+{
+namespace ximgproc
+{
+void weightedMedianFilter(InputArray joint, InputArray src, OutputArray dst, int r, double sigma, int weightType, InputArray mask)
+{
+    CV_Assert(!src.empty());
+    CV_Assert(r > 0 && sigma > 0);
+
+    int nI = 256;
+    int nF = 256;
+
+    Mat I = src.getMat();
+    Mat F = joint.getMat();
+    if(joint.empty())
+    {
+        medianBlur(src, dst, r);
+        return;
+    }
+
+    CV_Assert(I.depth() == CV_32F || I.depth() == CV_8U);
+    CV_Assert(F.depth() == CV_8U && (F.channels() == 1 || F.channels() == 3));
+
+    dst.create(src.size(), src.type());
+    Mat D = dst.getMat();
+
+    if(D.data == F.data)
+        F = F.clone();
+    if(D.data == I.data)
+        I = I.clone();
+
+    //Preprocess I
+    //OUTPUT OF THIS STEP: Is, iMap
+    //If I is floating point image, "adaptive quantization" is done in from32FTo32S.
+    //The mapping of floating value to integer value is stored in iMap (for each channel).
+    //"Is" stores each channel of "I". The channels are converted to CV_32S type after this step.
+    vector<float *> iMap(I.channels());
+    vector<Mat> Is;
+    split(I,Is);
+    for(int i=0;i<(int)Is.size();i++)
+    {
+        if(I.depth() == CV_32F)
+        {
+            iMap[i] = new float[nI];
+            from32FTo32S(Is[i],Is[i],nI,iMap[i]);
+        }
+        else if(I.depth() == CV_8U)
+        {
+            Is[i].convertTo(Is[i],CV_32S);
+        }
+    }
+
+    //Preprocess F
+    //OUTPUT OF THIS STEP: F(new), wMap
+    //If "F" is 3-channel image, "clustering feature image" is done in featureIndexing.
+    //If "F" is 1-channel image, featureIndexing only does a type-casting on "F".
+    //The output "F" is CV_32S type, containing indexes of feature values.
+    //"wMap" is a 2D array that defines the distance between each pair of feature indexes.
+    // wMap[i][j] is the weight between feature index "i" and "j".
+    float **wMap = NULL;
+    featureIndexing(F, wMap, nF, float(sigma), weightType);
+
+    //Filtering - Joint-Histogram Framework
+    for(int i=0; i<(int)Is.size(); i++)
+    {
+        Is[i] = filterCore(Is[i], F, wMap, r, nF, nI, mask.getMat());
+    }
+    float2D_release(wMap);
+
+    //Postprocess F
+    //Convert input image back to the original type.
+    for(int i = 0; i < (int)Is.size(); i++)
+    {
+        if(I.depth()==CV_32F)
+        {
+            from32STo32F(Is[i],Is[i],iMap[i]);
+            delete []iMap[i];
+        }
+        else if(I.depth()==CV_8U)
+        {
+            Is[i].convertTo(Is[i],CV_8U);
+        }
+    }
+
+    //merge the channels
+    merge(Is, D);
+}
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_adaptive_manifold.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_adaptive_manifold.cpp
new file mode 100644
index 00000000..273161ac
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_adaptive_manifold.cpp
@@ -0,0 +1,179 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test {
+Ptr<AdaptiveManifoldFilter> createAMFilterRefImpl(double sigma_s, double sigma_r, bool adjust_outliers = false);
+namespace {
+
+#ifndef SQR
+#define SQR(x) ((x)*(x))
+#endif
+
+static string getOpenCVExtraDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+static void checkSimilarity(InputArray res, InputArray ref, double maxNormInf = 1, double maxNormL2 = 1.0 / 64)
+{
+    double normInf = cvtest::norm(res, ref, NORM_INF);
+    double normL2 = cvtest::norm(res, ref, NORM_L2) / res.total();
+
+    if (maxNormInf >= 0) { EXPECT_LE(normInf, maxNormInf); }
+    if (maxNormL2 >= 0) { EXPECT_LE(normL2, maxNormL2); }
+}
+
+TEST(AdaptiveManifoldTest, SplatSurfaceAccuracy)
+{
+    RNG rnd(0);
+
+    for (int i = 0; i < 5; i++)
+    {
+        Size sz(rnd.uniform(512, 1024), rnd.uniform(512, 1024));
+
+        int guideCn = rnd.uniform(1, 8);
+        Mat guide(sz, CV_MAKE_TYPE(CV_32F, guideCn));
+        randu(guide, 0, 1);
+
+        Scalar surfaceValue;
+        int srcCn = rnd.uniform(1, 4);
+        rnd.fill(surfaceValue, RNG::UNIFORM, 0, 255);
+        Mat src(sz, CV_MAKE_TYPE(CV_8U, srcCn), surfaceValue);
+
+        double sigma_s = rnd.uniform(1.0, 50.0);
+        double sigma_r = rnd.uniform(0.1, 0.9);
+
+        Mat res;
+        amFilter(guide, src, res, sigma_s, sigma_r, false);
+
+        double normInf = cvtest::norm(src, res, NORM_INF);
+        EXPECT_EQ(normInf, 0);
+    }
+}
+
+TEST(AdaptiveManifoldTest, AuthorsReferenceAccuracy)
+{
+    String srcImgPath = "cv/edgefilter/kodim23.png";
+
+    String refPaths[] =
+    {
+        "cv/edgefilter/amf/kodim23_amf_ss5_sr0.3_ref.png",
+        "cv/edgefilter/amf/kodim23_amf_ss30_sr0.1_ref.png",
+        "cv/edgefilter/amf/kodim23_amf_ss50_sr0.3_ref.png"
+    };
+
+    pair<double, double> refParams[] =
+    {
+        make_pair(5.0, 0.3),
+        make_pair(30.0, 0.1),
+        make_pair(50.0, 0.3)
+    };
+
+    String refOutliersPaths[] =
+    {
+        "cv/edgefilter/amf/kodim23_amf_ss5_sr0.1_outliers_ref.png",
+        "cv/edgefilter/amf/kodim23_amf_ss15_sr0.3_outliers_ref.png",
+        "cv/edgefilter/amf/kodim23_amf_ss50_sr0.5_outliers_ref.png"
+    };
+
+    pair<double, double> refOutliersParams[] =
+    {
+        make_pair(5.0, 0.1),
+        make_pair(15.0, 0.3),
+        make_pair(50.0, 0.5),
+    };
+
+    Mat srcImg = imread(getOpenCVExtraDir() + srcImgPath);
+    ASSERT_TRUE(!srcImg.empty());
+
+    for (int i = 0; i < 3; i++)
+    {
+        Mat refRes = imread(getOpenCVExtraDir() + refPaths[i]);
+        double sigma_s = refParams[i].first;
+        double sigma_r = refParams[i].second;
+        ASSERT_TRUE(!refRes.empty());
+
+        Mat res;
+        Ptr<AdaptiveManifoldFilter> amf = createAMFilter(sigma_s, sigma_r, false);
+        amf->setUseRNG(false);
+        amf->filter(srcImg, res, srcImg);
+        amf->collectGarbage();
+
+        checkSimilarity(res, refRes);
+    }
+
+    for (int i = 0; i < 3; i++)
+    {
+        Mat refRes = imread(getOpenCVExtraDir() + refOutliersPaths[i]);
+        double sigma_s = refOutliersParams[i].first;
+        double sigma_r = refOutliersParams[i].second;
+        ASSERT_TRUE(!refRes.empty());
+
+        Mat res;
+        Ptr<AdaptiveManifoldFilter> amf = createAMFilter(sigma_s, sigma_r, true);
+        amf->setUseRNG(false);
+        amf->filter(srcImg, res, srcImg);
+        amf->collectGarbage();
+
+        checkSimilarity(res, refRes);
+    }
+}
+
+typedef tuple<string, string> AMRefTestParams;
+typedef TestWithParam<AMRefTestParams> AdaptiveManifoldRefImplTest;
+
+TEST_P(AdaptiveManifoldRefImplTest, RefImplAccuracy)
+{
+    AMRefTestParams params = GetParam();
+
+    string guideFileName = get<0>(params);
+    string srcFileName = get<1>(params);
+
+    Mat guide = imread(getOpenCVExtraDir() + guideFileName);
+    Mat src = imread(getOpenCVExtraDir() + srcFileName);
+    ASSERT_TRUE(!guide.empty() && !src.empty());
+
+    int seed = 10 * (int)guideFileName.length() + (int)srcFileName.length();
+    RNG rnd(seed);
+
+    //inconsistent downsample/upsample operations in reference implementation
+    Size dstSize((guide.cols + 15) & ~15, (guide.rows + 15) & ~15);
+
+    resize(guide, guide, dstSize, 0, 0, INTER_LINEAR_EXACT);
+    resize(src, src, dstSize, 0, 0, INTER_LINEAR_EXACT);
+
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
+    for (int iter = 0; iter < 4; iter++)
+    {
+        double sigma_s = rnd.uniform(1.0, 50.0);
+        double sigma_r = rnd.uniform(0.1, 0.9);
+        bool adjust_outliers = (iter % 2 == 0);
+
+        cv::setNumThreads(nThreads);
+        Mat res;
+        amFilter(guide, src, res, sigma_s, sigma_r, adjust_outliers);
+
+        cv::setNumThreads(1);
+        Mat resRef;
+        Ptr<AdaptiveManifoldFilter> amf = createAMFilterRefImpl(sigma_s, sigma_r, adjust_outliers);
+        amf->filter(src, resRef, guide);
+
+        //results of reference implementation may differ on small sigma_s into small isolated region
+        //due to low single-precision floating point numbers accuracy
+        //therefore the threshold of inf norm was increased
+        checkSimilarity(res, resRef, 25);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(TypicalSet, AdaptiveManifoldRefImplTest,
+    Combine(
+    Values("cv/edgefilter/kodim23.png", "cv/npr/test4.png"),
+    Values("cv/edgefilter/kodim23.png", "cv/npr/test4.png")
+));
+
+
+}} // namespace
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_adaptive_manifold_ref_impl.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_adaptive_manifold_ref_impl.cpp
new file mode 100644
index 00000000..f1e9d1be
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_adaptive_manifold_ref_impl.cpp
@@ -0,0 +1,947 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * The MIT License(MIT)
+ *
+ * Copyright(c) 2013 Vladislav Vinogradov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files(the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions :
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "test_precomp.hpp"
+#include <opencv2/core/private.hpp>
+
+namespace opencv_test { namespace {
+
+using namespace cv::ximgproc;
+
+    struct Buf
+    {
+        Mat_<Point3f> eta_1;
+        Mat_<uchar> cluster_1;
+
+        Mat_<Point3f> tilde_dst;
+        Mat_<float> alpha;
+        Mat_<Point3f> diff;
+        Mat_<Point3f> dst;
+
+        Mat_<float> V;
+
+        Mat_<Point3f> dIcdx;
+        Mat_<Point3f> dIcdy;
+        Mat_<float> dIdx;
+        Mat_<float> dIdy;
+        Mat_<float> dHdx;
+        Mat_<float> dVdy;
+
+        Mat_<float> t;
+
+        Mat_<float> theta_masked;
+        Mat_<Point3f> mul;
+        Mat_<Point3f> numerator;
+        Mat_<float> denominator;
+        Mat_<Point3f> numerator_filtered;
+        Mat_<float> denominator_filtered;
+
+        Mat_<Point3f> X;
+        Mat_<Point3f> eta_k_small;
+        Mat_<Point3f> eta_k_big;
+        Mat_<Point3f> X_squared;
+        Mat_<float> pixel_dist_to_manifold_squared;
+        Mat_<float> gaussian_distance_weights;
+        Mat_<Point3f> Psi_splat;
+        Mat_<Vec4f> Psi_splat_joined;
+        Mat_<Vec4f> Psi_splat_joined_resized;
+        Mat_<Vec4f> blurred_projected_values;
+        Mat_<Point3f> w_ki_Psi_blur;
+        Mat_<float> w_ki_Psi_blur_0;
+        Mat_<Point3f> w_ki_Psi_blur_resized;
+        Mat_<float> w_ki_Psi_blur_0_resized;
+        Mat_<float> rand_vec;
+        Mat_<float> v1;
+        Mat_<float> Nx_v1_mult;
+        Mat_<float> theta;
+
+        std::vector<Mat_<Point3f> > eta_minus;
+        std::vector<Mat_<uchar> > cluster_minus;
+        std::vector<Mat_<Point3f> > eta_plus;
+        std::vector<Mat_<uchar> > cluster_plus;
+
+        void release();
+    };
+
+    void Buf::release()
+    {
+        eta_1.release();
+        cluster_1.release();
+
+        tilde_dst.release();
+        alpha.release();
+        diff.release();
+        dst.release();
+
+        V.release();
+
+        dIcdx.release();
+        dIcdy.release();
+        dIdx.release();
+        dIdy.release();
+        dHdx.release();
+        dVdy.release();
+
+        t.release();
+
+        theta_masked.release();
+        mul.release();
+        numerator.release();
+        denominator.release();
+        numerator_filtered.release();
+        denominator_filtered.release();
+
+        X.release();
+        eta_k_small.release();
+        eta_k_big.release();
+        X_squared.release();
+        pixel_dist_to_manifold_squared.release();
+        gaussian_distance_weights.release();
+         Psi_splat.release();
+        Psi_splat_joined.release();
+        Psi_splat_joined_resized.release();
+        blurred_projected_values.release();
+        w_ki_Psi_blur.release();
+        w_ki_Psi_blur_0.release();
+        w_ki_Psi_blur_resized.release();
+        w_ki_Psi_blur_0_resized.release();
+        rand_vec.release();
+        v1.release();
+        Nx_v1_mult.release();
+        theta.release();
+
+        eta_minus.clear();
+        cluster_minus.clear();
+        eta_plus.clear();
+        cluster_plus.clear();
+    }
+
+    class AdaptiveManifoldFilterRefImpl : public AdaptiveManifoldFilter
+    {
+    public:
+        AdaptiveManifoldFilterRefImpl();
+
+        void filter(InputArray src, OutputArray dst, InputArray joint);
+
+        void collectGarbage();
+
+        inline double getSigmaS() const CV_OVERRIDE { return sigma_s_; }
+        inline void setSigmaS(double val) CV_OVERRIDE { sigma_s_ = val; }
+        inline double getSigmaR() const CV_OVERRIDE { return sigma_r_; }
+        inline void setSigmaR(double val) CV_OVERRIDE { sigma_r_ = val; }
+        inline int getTreeHeight() const CV_OVERRIDE { return tree_height_; }
+        inline void setTreeHeight(int val) CV_OVERRIDE { tree_height_ = val; }
+        inline int getPCAIterations() const CV_OVERRIDE { return num_pca_iterations_; }
+        inline void setPCAIterations(int val) CV_OVERRIDE { num_pca_iterations_ = val; }
+        inline bool getAdjustOutliers() const CV_OVERRIDE { return adjust_outliers_; }
+        inline void setAdjustOutliers(bool val) CV_OVERRIDE { adjust_outliers_ = val; }
+        inline bool getUseRNG() const CV_OVERRIDE { return useRNG; }
+        inline void setUseRNG(bool val) CV_OVERRIDE { useRNG = val; }
+
+    protected:
+        bool adjust_outliers_;
+        double sigma_s_;
+        double sigma_r_;
+        int tree_height_;
+        int num_pca_iterations_;
+        bool useRNG;
+
+    private:
+        void buildManifoldsAndPerformFiltering(const Mat_<Point3f>& eta_k, const Mat_<uchar>& cluster_k, int current_tree_level);
+
+        Buf buf_;
+
+        Mat_<Point3f> src_f_;
+        Mat_<Point3f> src_joint_f_;
+
+        Mat_<Point3f> sum_w_ki_Psi_blur_;
+        Mat_<float> sum_w_ki_Psi_blur_0_;
+
+        Mat_<float> min_pixel_dist_to_manifold_squared_;
+
+        RNG rng_;
+
+        int cur_tree_height_;
+        float sigma_r_over_sqrt_2_;
+    };
+
+    AdaptiveManifoldFilterRefImpl::AdaptiveManifoldFilterRefImpl()
+    {
+        sigma_s_ = 16.0;
+        sigma_r_ = 0.2;
+        tree_height_ = -1;
+        num_pca_iterations_ = 1;
+        adjust_outliers_ = false;
+        useRNG = true;
+    }
+
+    void AdaptiveManifoldFilterRefImpl::collectGarbage()
+    {
+        buf_.release();
+
+        src_f_.release();
+        src_joint_f_.release();
+
+        sum_w_ki_Psi_blur_.release();
+        sum_w_ki_Psi_blur_0_.release();
+
+        min_pixel_dist_to_manifold_squared_.release();
+    }
+
+    inline double Log2(double n)
+    {
+        return log(n) / log(2.0);
+    }
+
+    inline int computeManifoldTreeHeight(double sigma_s, double sigma_r)
+    {
+        const double Hs = floor(Log2(sigma_s)) - 1.0;
+        const double Lr = 1.0 - sigma_r;
+        return max(2, static_cast<int>(ceil(Hs * Lr)));
+    }
+/*
+    void ensureSizeIsEnough(int rows, int cols, int type, Mat& m)
+    {
+        if (m.empty() || m.type() != type || m.data != m.datastart)
+            m.create(rows, cols, type);
+        else
+        {
+            const size_t esz = m.elemSize();
+            const ptrdiff_t delta2 = m.dataend - m.datastart;
+
+            const size_t minstep = m.cols * esz;
+
+            Size wholeSize;
+            wholeSize.height = std::max(static_cast<int>((delta2 - minstep) / m.step + 1), m.rows);
+            wholeSize.width = std::max(static_cast<int>((delta2 - m.step * (wholeSize.height - 1)) / esz), m.cols);
+
+            if (wholeSize.height < rows || wholeSize.width < cols)
+                m.create(rows, cols, type);
+            else
+            {
+                m.cols = cols;
+                m.rows = rows;
+            }
+        }
+    }
+
+    inline void ensureSizeIsEnough(Size size, int type, Mat& m)
+    {
+        ensureSizeIsEnough(size.height, size.width, type, m);
+    }
+*/
+    template <typename T>
+    inline void ensureSizeIsEnough(int rows, int cols, Mat_<T>& m)
+    {
+        if (m.empty() || m.data != m.datastart)
+            m.create(rows, cols);
+        else
+        {
+            const size_t esz = m.elemSize();
+            const ptrdiff_t delta2 = m.dataend - m.datastart;
+
+            const size_t minstep = m.cols * esz;
+
+            Size wholeSize;
+            wholeSize.height = std::max(static_cast<int>((delta2 - minstep) / m.step + 1), m.rows);
+            wholeSize.width = std::max(static_cast<int>((delta2 - m.step * (wholeSize.height - 1)) / esz), m.cols);
+
+            if (wholeSize.height < rows || wholeSize.width < cols)
+                m.create(rows, cols);
+            else
+            {
+                m.cols = cols;
+                m.rows = rows;
+            }
+        }
+    }
+
+    template <typename T>
+    inline void ensureSizeIsEnough(Size size, Mat_<T>& m)
+    {
+        ensureSizeIsEnough(size.height, size.width, m);
+    }
+
+    template <typename T>
+    void h_filter(const Mat_<T>& src, Mat_<T>& dst, float sigma)
+    {
+        CV_DbgAssert( src.depth() == CV_32F );
+
+        const float a = exp(-sqrt(2.0f) / sigma);
+
+        ensureSizeIsEnough(src.size(), dst);
+
+        for (int y = 0; y < src.rows; ++y)
+        {
+            const T* src_row = src[y];
+            T* dst_row = dst[y];
+
+            dst_row[0] = src_row[0];
+            for (int x = 1; x < src.cols; ++x)
+            {
+                //dst_row[x] = src_row[x] + a * (src_row[x - 1] - src_row[x]);
+                dst_row[x] = src_row[x] + a * (dst_row[x - 1] - src_row[x]); //!!!
+            }
+            for (int x = src.cols - 2; x >= 0; --x)
+            {
+                dst_row[x] = dst_row[x] + a * (dst_row[x + 1] - dst_row[x]);
+            }
+        }
+
+        for (int y = 1; y < src.rows; ++y)
+        {
+            T* dst_cur_row = dst[y];
+            T* dst_prev_row = dst[y - 1];
+
+            for (int x = 0; x < src.cols; ++x)
+            {
+                dst_cur_row[x] = dst_cur_row[x] + a * (dst_prev_row[x] - dst_cur_row[x]);
+            }
+        }
+        for (int y = src.rows - 2; y >= 0; --y)
+        {
+            T* dst_cur_row = dst[y];
+            T* dst_prev_row = dst[y + 1];
+
+            for (int x = 0; x < src.cols; ++x)
+            {
+                dst_cur_row[x] = dst_cur_row[x] + a * (dst_prev_row[x] - dst_cur_row[x]);
+            }
+        }
+    }
+
+    template <typename T>
+    void rdivide(const Mat_<T>& a, const Mat_<float>& b, Mat_<T>& dst)
+    {
+        CV_DbgAssert( a.depth() == CV_32F );
+        CV_DbgAssert( a.size() == b.size() );
+
+        ensureSizeIsEnough(a.size(), dst);
+        dst.setTo(0);
+
+        for (int y = 0; y < a.rows; ++y)
+        {
+            const T* a_row = a[y];
+            const float* b_row = b[y];
+            T* dst_row = dst[y];
+
+            for (int x = 0; x < a.cols; ++x)
+            {
+                //if (b_row[x] > numeric_limits<float>::epsilon())
+                    dst_row[x] = a_row[x] * (1.0f / b_row[x]);
+            }
+        }
+    }
+
+    template <typename T>
+    void times(const Mat_<T>& a, const Mat_<float>& b, Mat_<T>& dst)
+    {
+        CV_DbgAssert( a.depth() == CV_32F );
+        CV_DbgAssert( a.size() == b.size() );
+
+        ensureSizeIsEnough(a.size(), dst);
+
+        for (int y = 0; y < a.rows; ++y)
+        {
+            const T* a_row = a[y];
+            const float* b_row = b[y];
+            T* dst_row = dst[y];
+
+            for (int x = 0; x < a.cols; ++x)
+            {
+                dst_row[x] = a_row[x] * b_row[x];
+            }
+        }
+    }
+
+    void AdaptiveManifoldFilterRefImpl::filter(InputArray _src, OutputArray _dst, InputArray _joint)
+    {
+        const Mat src = _src.getMat();
+        const Mat src_joint = _joint.getMat();
+
+        const Size srcSize = src.size();
+
+        CV_Assert( src.type() == CV_8UC3 );
+        CV_Assert( src_joint.empty() || (src_joint.type() == src.type() && src_joint.size() == srcSize) );
+
+        ensureSizeIsEnough(srcSize, src_f_);
+        src.convertTo(src_f_, src_f_.type(), 1.0 / 255.0);
+
+        ensureSizeIsEnough(srcSize, sum_w_ki_Psi_blur_);
+        sum_w_ki_Psi_blur_.setTo(Scalar::all(0));
+
+        ensureSizeIsEnough(srcSize, sum_w_ki_Psi_blur_0_);
+        sum_w_ki_Psi_blur_0_.setTo(Scalar::all(0));
+
+        ensureSizeIsEnough(srcSize, min_pixel_dist_to_manifold_squared_);
+        min_pixel_dist_to_manifold_squared_.setTo(Scalar::all(numeric_limits<float>::max()));
+
+        // If the tree_height was not specified, compute it using Eq. (10) of our paper.
+        cur_tree_height_ = tree_height_ > 0 ? tree_height_ : computeManifoldTreeHeight(sigma_s_, sigma_r_);
+
+        // If no joint signal was specified, use the original signal
+        ensureSizeIsEnough(srcSize, src_joint_f_);
+        if (src_joint.empty())
+            src_f_.copyTo(src_joint_f_);
+        else
+            src_joint.convertTo(src_joint_f_, src_joint_f_.type(), 1.0 / 255.0);
+
+        // Use the center pixel as seed to random number generation.
+        const double seedCoef = src_joint_f_(src_joint_f_.rows / 2, src_joint_f_.cols / 2).x;
+        const uint64 baseCoef = numeric_limits<uint64>::max() / 0xFFFF;
+        rng_.state = static_cast<uint64>(baseCoef*seedCoef);
+
+        // Dividing the covariance matrix by 2 is equivalent to dividing the standard deviations by sqrt(2).
+        sigma_r_over_sqrt_2_ = static_cast<float>(sigma_r_ / sqrt(2.0));
+
+        // Algorithm 1, Step 1: compute the first manifold by low-pass filtering.
+        h_filter(src_joint_f_, buf_.eta_1, static_cast<float>(sigma_s_));
+
+        ensureSizeIsEnough(srcSize, buf_.cluster_1);
+        buf_.cluster_1.setTo(Scalar::all(1));
+
+        buf_.eta_minus.resize(cur_tree_height_);
+        buf_.cluster_minus.resize(cur_tree_height_);
+        buf_.eta_plus.resize(cur_tree_height_);
+        buf_.cluster_plus.resize(cur_tree_height_);
+        buildManifoldsAndPerformFiltering(buf_.eta_1, buf_.cluster_1, 1);
+
+        // Compute the filter response by normalized convolution -- Eq. (4)
+        rdivide(sum_w_ki_Psi_blur_, sum_w_ki_Psi_blur_0_, buf_.tilde_dst);
+
+        if (!adjust_outliers_)
+        {
+            buf_.tilde_dst.convertTo(_dst, CV_8U, 255.0);
+        }
+        else
+        {
+            // Adjust the filter response for outlier pixels -- Eq. (10)
+            ensureSizeIsEnough(srcSize, buf_.alpha);
+            exp(min_pixel_dist_to_manifold_squared_ * (-0.5 / sigma_r_ / sigma_r_), buf_.alpha);
+
+            ensureSizeIsEnough(srcSize, buf_.diff);
+            subtract(buf_.tilde_dst, src_f_, buf_.diff);
+            times(buf_.diff, buf_.alpha, buf_.diff);
+
+            ensureSizeIsEnough(srcSize, buf_.dst);
+            cv::add(src_f_, buf_.diff, buf_.dst);  // TODO cvtest
+
+            buf_.dst.convertTo(_dst, CV_8U, 255.0);
+        }
+    }
+
+    inline double floor_to_power_of_two(double r)
+    {
+        return pow(2.0, floor(Log2(r)));
+    }
+
+    void channelsSum(const Mat_<Point3f>& src, Mat_<float>& dst)
+    {
+        ensureSizeIsEnough(src.size(), dst);
+
+        for (int y = 0; y < src.rows; ++y)
+        {
+            const Point3f* src_row = src[y];
+            float* dst_row = dst[y];
+
+            for (int x = 0; x < src.cols; ++x)
+            {
+                const Point3f src_val = src_row[x];
+                dst_row[x] = src_val.x + src_val.y + src_val.z;
+            }
+        }
+    }
+
+    void phi(const Mat_<float>& src, Mat_<float>& dst, float sigma)
+    {
+        ensureSizeIsEnough(src.size(), dst);
+
+        for (int y = 0; y < dst.rows; ++y)
+        {
+            const float* src_row = src[y];
+            float* dst_row = dst[y];
+
+            for (int x = 0; x < dst.cols; ++x)
+            {
+                dst_row[x] = exp(-0.5f * src_row[x] / sigma / sigma);
+            }
+        }
+    }
+
+    void catCn(const Mat_<Point3f>& a, const Mat_<float>& b, Mat_<Vec4f>& dst)
+    {
+        ensureSizeIsEnough(a.size(), dst);
+
+        for (int y = 0; y < a.rows; ++y)
+        {
+            const Point3f* a_row = a[y];
+            const float* b_row = b[y];
+            Vec4f* dst_row = dst[y];
+
+            for (int x = 0; x < a.cols; ++x)
+            {
+                const Point3f a_val = a_row[x];
+                const float b_val = b_row[x];
+                dst_row[x] = Vec4f(a_val.x, a_val.y, a_val.z, b_val);
+            }
+        }
+    }
+
+    void diffY(const Mat_<Point3f>& src, Mat_<Point3f>& dst)
+    {
+        ensureSizeIsEnough(src.rows - 1, src.cols, dst);
+
+        for (int y = 0; y < src.rows - 1; ++y)
+        {
+            const Point3f* src_cur_row = src[y];
+            const Point3f* src_next_row = src[y + 1];
+            Point3f* dst_row = dst[y];
+
+            for (int x = 0; x < src.cols; ++x)
+            {
+                dst_row[x] = src_next_row[x] - src_cur_row[x];
+            }
+        }
+    }
+
+    void diffX(const Mat_<Point3f>& src, Mat_<Point3f>& dst)
+    {
+        ensureSizeIsEnough(src.rows, src.cols - 1, dst);
+
+        for (int y = 0; y < src.rows; ++y)
+        {
+            const Point3f* src_row = src[y];
+            Point3f* dst_row = dst[y];
+
+            for (int x = 0; x < src.cols - 1; ++x)
+            {
+                dst_row[x] = src_row[x + 1] - src_row[x];
+            }
+        }
+    }
+
+    void TransformedDomainRecursiveFilter(const Mat_<Vec4f>& I, const Mat_<float>& DH, const Mat_<float>& DV, Mat_<Vec4f>& dst, float sigma, Buf& buf)
+    {
+        CV_DbgAssert( I.size() == DH.size() );
+
+        const float a = exp(-sqrt(2.0f) / sigma);
+
+        ensureSizeIsEnough(I.size(), dst);
+        I.copyTo(dst);
+
+        ensureSizeIsEnough(DH.size(), buf.V);
+
+        for (int y = 0; y < DH.rows; ++y)
+        {
+            const float* D_row = DH[y];
+            float* V_row = buf.V[y];
+
+            for (int x = 0; x < DH.cols; ++x)
+            {
+                V_row[x] = pow(a, D_row[x]);
+            }
+        }
+        for (int y = 0; y < I.rows; ++y)
+        {
+            const float* V_row = buf.V[y];
+            Vec4f* dst_row = dst[y];
+
+            for (int x = 1; x < I.cols; ++x)
+            {
+                Vec4f dst_cur_val = dst_row[x];
+                const Vec4f dst_prev_val = dst_row[x - 1];
+                const float V_val = V_row[x];
+
+                dst_cur_val[0] += V_val * (dst_prev_val[0] - dst_cur_val[0]);
+                dst_cur_val[1] += V_val * (dst_prev_val[1] - dst_cur_val[1]);
+                dst_cur_val[2] += V_val * (dst_prev_val[2] - dst_cur_val[2]);
+                dst_cur_val[3] += V_val * (dst_prev_val[3] - dst_cur_val[3]);
+
+                dst_row[x] = dst_cur_val;
+            }
+            for (int x = I.cols - 2; x >= 0; --x)
+            {
+                Vec4f dst_cur_val = dst_row[x];
+                const Vec4f dst_prev_val = dst_row[x + 1];
+                //const float V_val = V_row[x];
+                const float V_val = V_row[x+1];
+
+                dst_cur_val[0] += V_val * (dst_prev_val[0] - dst_cur_val[0]);
+                dst_cur_val[1] += V_val * (dst_prev_val[1] - dst_cur_val[1]);
+                dst_cur_val[2] += V_val * (dst_prev_val[2] - dst_cur_val[2]);
+                dst_cur_val[3] += V_val * (dst_prev_val[3] - dst_cur_val[3]);
+
+                dst_row[x] = dst_cur_val;
+            }
+        }
+
+        for (int y = 0; y < DV.rows; ++y)
+        {
+            const float* D_row = DV[y];
+            float* V_row = buf.V[y];
+
+            for (int x = 0; x < DV.cols; ++x)
+            {
+                V_row[x] = pow(a, D_row[x]);
+            }
+        }
+        for (int y = 1; y < I.rows; ++y)
+        {
+            const float* V_row = buf.V[y];
+            Vec4f* dst_cur_row = dst[y];
+            Vec4f* dst_prev_row = dst[y - 1];
+
+            for (int x = 0; x < I.cols; ++x)
+            {
+                Vec4f dst_cur_val = dst_cur_row[x];
+                const Vec4f dst_prev_val = dst_prev_row[x];
+                const float V_val = V_row[x];
+
+                dst_cur_val[0] += V_val * (dst_prev_val[0] - dst_cur_val[0]);
+                dst_cur_val[1] += V_val * (dst_prev_val[1] - dst_cur_val[1]);
+                dst_cur_val[2] += V_val * (dst_prev_val[2] - dst_cur_val[2]);
+                dst_cur_val[3] += V_val * (dst_prev_val[3] - dst_cur_val[3]);
+
+                dst_cur_row[x] = dst_cur_val;
+            }
+        }
+        for (int y = I.rows - 2; y >= 0; --y)
+        {
+            //const float* V_row = buf.V[y];
+            const float* V_row = buf.V[y + 1];
+            Vec4f* dst_cur_row = dst[y];
+            Vec4f* dst_prev_row = dst[y + 1];
+
+            for (int x = 0; x < I.cols; ++x)
+            {
+                Vec4f dst_cur_val = dst_cur_row[x];
+                const Vec4f dst_prev_val = dst_prev_row[x];
+                const float V_val = V_row[x];
+
+                dst_cur_val[0] += V_val * (dst_prev_val[0] - dst_cur_val[0]);
+                dst_cur_val[1] += V_val * (dst_prev_val[1] - dst_cur_val[1]);
+                dst_cur_val[2] += V_val * (dst_prev_val[2] - dst_cur_val[2]);
+                dst_cur_val[3] += V_val * (dst_prev_val[3] - dst_cur_val[3]);
+
+                dst_cur_row[x] = dst_cur_val;
+            }
+        }
+    }
+
+    void RF_filter(const Mat_<Vec4f>& src, const Mat_<Point3f>& src_joint, Mat_<Vec4f>& dst, float sigma_s, float sigma_r, Buf& buf)
+    {
+        CV_DbgAssert( src_joint.size() == src.size() );
+
+        diffX(src_joint, buf.dIcdx);
+        diffY(src_joint, buf.dIcdy);
+
+        ensureSizeIsEnough(src.size(), buf.dIdx);
+        buf.dIdx.setTo(Scalar::all(0));
+        for (int y = 0; y < src.rows; ++y)
+        {
+            const Point3f* dIcdx_row = buf.dIcdx[y];
+            float* dIdx_row = buf.dIdx[y];
+
+            for (int x = 1; x < src.cols; ++x)
+            {
+                const Point3f val = dIcdx_row[x - 1];
+                dIdx_row[x] = val.dot(val);
+            }
+        }
+
+        ensureSizeIsEnough(src.size(), buf.dIdy);
+        buf.dIdy.setTo(Scalar::all(0));
+        for (int y = 1; y < src.rows; ++y)
+        {
+            const Point3f* dIcdy_row = buf.dIcdy[y - 1];
+            float* dIdy_row = buf.dIdy[y];
+
+            for (int x = 0; x < src.cols; ++x)
+            {
+                const Point3f val = dIcdy_row[x];
+                dIdy_row[x] = val.dot(val);
+            }
+        }
+
+        ensureSizeIsEnough(buf.dIdx.size(), buf.dHdx);
+        buf.dIdx.convertTo(buf.dHdx, buf.dHdx.type(), (sigma_s / sigma_r) * (sigma_s / sigma_r), (sigma_s / sigma_s) * (sigma_s / sigma_s));
+        sqrt(buf.dHdx, buf.dHdx);
+
+        ensureSizeIsEnough(buf.dIdy.size(), buf.dVdy);
+        buf.dIdy.convertTo(buf.dVdy, buf.dVdy.type(), (sigma_s / sigma_r) * (sigma_s / sigma_r), (sigma_s / sigma_s) * (sigma_s / sigma_s));
+        sqrt(buf.dVdy, buf.dVdy);
+
+        ensureSizeIsEnough(src.size(), dst);
+        src.copyTo(dst);
+        TransformedDomainRecursiveFilter(src, buf.dHdx, buf.dVdy, dst, sigma_s, buf);
+    }
+
+    void split_3_1(const Mat_<Vec4f>& src, Mat_<Point3f>& dst1, Mat_<float>& dst2)
+    {
+        ensureSizeIsEnough(src.size(), dst1);
+        ensureSizeIsEnough(src.size(), dst2);
+
+        for (int y = 0; y < src.rows; ++y)
+        {
+            const Vec4f* src_row = src[y];
+            Point3f* dst1_row = dst1[y];
+            float* dst2_row = dst2[y];
+
+            for (int x = 0; x < src.cols; ++x)
+            {
+                Vec4f val = src_row[x];
+                dst1_row[x] = Point3f(val[0], val[1], val[2]);
+                dst2_row[x] = val[3];
+            }
+        }
+    }
+
+    void computeEigenVector(const Mat_<float>& X, const Mat_<uchar>& mask, Mat_<float>& dst, int num_pca_iterations, const Mat_<float>& rand_vec, Buf& buf)
+    {
+        CV_DbgAssert( X.cols == rand_vec.cols );
+        CV_DbgAssert( X.rows == mask.size().area() );
+        CV_DbgAssert( rand_vec.rows == 1 );
+
+        ensureSizeIsEnough(rand_vec.size(), dst);
+        rand_vec.copyTo(dst);
+
+        ensureSizeIsEnough(X.size(), buf.t);
+
+        float* dst_row = dst[0];
+
+        for (int i = 0; i < num_pca_iterations; ++i)
+        {
+            buf.t.setTo(Scalar::all(0));
+
+            for (int y = 0, ind = 0; y < mask.rows; ++y)
+            {
+                const uchar* mask_row = mask[y];
+
+                for (int x = 0; x < mask.cols; ++x, ++ind)
+                {
+                    if (mask_row[x])
+                    {
+                        const float* X_row = X[ind];
+                        float* t_row = buf.t[ind];
+
+                        float dots = 0.0;
+                        for (int c = 0; c < X.cols; ++c)
+                            dots += dst_row[c] * X_row[c];
+
+                        for (int c = 0; c < X.cols; ++c)
+                            t_row[c] = dots * X_row[c];
+                    }
+                }
+            }
+
+            dst.setTo(0.0);
+            for (int k = 0; k < X.rows; ++k)
+            {
+                const float* t_row = buf.t[k];
+
+                for (int c = 0; c < X.cols; ++c)
+                {
+                    dst_row[c] += t_row[c];
+                }
+            }
+        }
+
+        double n = cvtest::norm(dst, NORM_L2);
+        cv::divide(dst, n, dst);  // TODO cvtest
+    }
+
+    void calcEta(const Mat_<Point3f>& src_joint_f, const Mat_<float>& theta, const Mat_<uchar>& cluster, Mat_<Point3f>& dst, float sigma_s, float df, Buf& buf)
+    {
+        ensureSizeIsEnough(theta.size(), buf.theta_masked);
+        buf.theta_masked.setTo(Scalar::all(0));
+        theta.copyTo(buf.theta_masked, cluster);
+
+        times(src_joint_f, buf.theta_masked, buf.mul);
+
+        const Size nsz = Size(saturate_cast<int>(buf.mul.cols * (1.0 / df)), saturate_cast<int>(buf.mul.rows * (1.0 / df)));
+
+        ensureSizeIsEnough(nsz, buf.numerator);
+        resize(buf.mul, buf.numerator, Size(), 1.0 / df, 1.0 / df);
+
+        ensureSizeIsEnough(nsz, buf.denominator);
+        resize(buf.theta_masked, buf.denominator, Size(), 1.0 / df, 1.0 / df);
+        h_filter(buf.numerator, buf.numerator_filtered, sigma_s / df);
+        h_filter(buf.denominator, buf.denominator_filtered, sigma_s / df);
+
+
+        rdivide(buf.numerator_filtered, buf.denominator_filtered, dst);
+    }
+
+    void AdaptiveManifoldFilterRefImpl::buildManifoldsAndPerformFiltering(const Mat_<Point3f>& eta_k, const Mat_<uchar>& cluster_k, int current_tree_level)
+    {
+        // Compute downsampling factor
+
+        double df = min(sigma_s_ / 4.0, 256.0 * sigma_r_);
+        df = floor_to_power_of_two(df);
+        df = max(1.0, df);
+
+        // Splatting: project the pixel values onto the current manifold eta_k
+
+        if (eta_k.rows == src_joint_f_.rows)
+        {
+            ensureSizeIsEnough(src_joint_f_.size(), buf_.X);
+            subtract(src_joint_f_, eta_k, buf_.X);
+
+            const Size nsz = Size(saturate_cast<int>(eta_k.cols * (1.0 / df)), saturate_cast<int>(eta_k.rows * (1.0 / df)));
+            ensureSizeIsEnough(nsz, buf_.eta_k_small);
+            resize(eta_k, buf_.eta_k_small, Size(), 1.0 / df, 1.0 / df);
+        }
+        else
+        {
+            ensureSizeIsEnough(eta_k.size(), buf_.eta_k_small);
+            eta_k.copyTo(buf_.eta_k_small);
+
+            ensureSizeIsEnough(src_joint_f_.size(), buf_.eta_k_big);
+            resize(eta_k, buf_.eta_k_big, src_joint_f_.size());
+
+            ensureSizeIsEnough(src_joint_f_.size(), buf_.X);
+            subtract(src_joint_f_, buf_.eta_k_big, buf_.X);
+        }
+
+        // Project pixel colors onto the manifold -- Eq. (3), Eq. (5)
+
+        ensureSizeIsEnough(buf_.X.size(), buf_.X_squared);
+        cv::multiply(buf_.X, buf_.X, buf_.X_squared);  // TODO cvtest
+
+        channelsSum(buf_.X_squared, buf_.pixel_dist_to_manifold_squared);
+
+        phi(buf_.pixel_dist_to_manifold_squared, buf_.gaussian_distance_weights, sigma_r_over_sqrt_2_);
+
+        times(src_f_, buf_.gaussian_distance_weights, buf_.Psi_splat);
+
+        const Mat_<float>& Psi_splat_0 = buf_.gaussian_distance_weights;
+
+        // Save min distance to later perform adjustment of outliers -- Eq. (10)
+
+        if (adjust_outliers_)
+        {
+            cv::min(_InputArray(min_pixel_dist_to_manifold_squared_), _InputArray(buf_.pixel_dist_to_manifold_squared), _OutputArray(min_pixel_dist_to_manifold_squared_));
+        }
+
+        // Blurring: perform filtering over the current manifold eta_k
+
+        catCn(buf_.Psi_splat, Psi_splat_0, buf_.Psi_splat_joined);
+
+        ensureSizeIsEnough(buf_.eta_k_small.size(), buf_.Psi_splat_joined_resized);
+        resize(buf_.Psi_splat_joined, buf_.Psi_splat_joined_resized, buf_.eta_k_small.size());
+
+        RF_filter(buf_.Psi_splat_joined_resized, buf_.eta_k_small, buf_.blurred_projected_values, static_cast<float>(sigma_s_ / df), sigma_r_over_sqrt_2_, buf_);
+
+        split_3_1(buf_.blurred_projected_values, buf_.w_ki_Psi_blur, buf_.w_ki_Psi_blur_0);
+
+        // Slicing: gather blurred values from the manifold
+
+        // Since we perform splatting and slicing at the same points over the manifolds,
+        // the interpolation weights are equal to the gaussian weights used for splatting.
+        const Mat_<float>& w_ki = buf_.gaussian_distance_weights;
+
+        ensureSizeIsEnough(src_f_.size(), buf_.w_ki_Psi_blur_resized);
+        resize(buf_.w_ki_Psi_blur, buf_.w_ki_Psi_blur_resized, src_f_.size());
+        times(buf_.w_ki_Psi_blur_resized, w_ki, buf_.w_ki_Psi_blur_resized);
+        cv::add(sum_w_ki_Psi_blur_, buf_.w_ki_Psi_blur_resized, sum_w_ki_Psi_blur_);  // TODO cvtest
+
+        ensureSizeIsEnough(src_f_.size(), buf_.w_ki_Psi_blur_0_resized);
+        resize(buf_.w_ki_Psi_blur_0, buf_.w_ki_Psi_blur_0_resized, src_f_.size());
+        times(buf_.w_ki_Psi_blur_0_resized, w_ki, buf_.w_ki_Psi_blur_0_resized);
+        cv::add(sum_w_ki_Psi_blur_0_, buf_.w_ki_Psi_blur_0_resized, sum_w_ki_Psi_blur_0_);  // TODO cvtest
+
+        // Compute two new manifolds eta_minus and eta_plus
+
+        if (current_tree_level < cur_tree_height_)
+        {
+            // Algorithm 1, Step 2: compute the eigenvector v1
+            const Mat_<float> nX(src_joint_f_.size().area(), 3, (float*) buf_.X.data);
+
+            ensureSizeIsEnough(1, nX.cols, buf_.rand_vec);
+            if (useRNG)
+            {
+                rng_.fill(buf_.rand_vec, RNG::UNIFORM, -0.5, 0.5);
+            }
+            else
+            {
+                for (int i = 0; i < (int)buf_.rand_vec.total(); i++)
+                    buf_.rand_vec(0, i) = (i % 2 == 0) ? 0.5f : -0.5f;
+            }
+
+            computeEigenVector(nX, cluster_k, buf_.v1, num_pca_iterations_, buf_.rand_vec, buf_);
+
+            // Algorithm 1, Step 3: Segment pixels into two clusters -- Eq. (6)
+
+            ensureSizeIsEnough(nX.rows, buf_.v1.rows, buf_.Nx_v1_mult);
+            gemm(nX, buf_.v1, 1.0, noArray(), 0.0, buf_.Nx_v1_mult, GEMM_2_T);
+
+            const Mat_<float> dot(src_joint_f_.rows, src_joint_f_.cols, (float*) buf_.Nx_v1_mult.data);
+
+            Mat_<uchar>& cluster_minus = buf_.cluster_minus[current_tree_level];
+            ensureSizeIsEnough(dot.size(), cluster_minus);
+            cvtest::compare(dot, 0, cluster_minus, CMP_LT);
+            bitwise_and(cluster_minus, cluster_k, cluster_minus);
+
+            Mat_<uchar>& cluster_plus = buf_.cluster_plus[current_tree_level];
+            ensureSizeIsEnough(dot.size(), cluster_plus);
+            //compare(dot, 0, cluster_plus, CMP_GT);
+            cvtest::compare(dot, 0, cluster_plus, CMP_GE);
+            bitwise_and(cluster_plus, cluster_k, cluster_plus);
+
+            // Algorithm 1, Step 4: Compute new manifolds by weighted low-pass filtering -- Eq. (7-8)
+
+            ensureSizeIsEnough(w_ki.size(), buf_.theta);
+            buf_.theta.setTo(Scalar::all(1.0));
+            subtract(buf_.theta, w_ki, buf_.theta);
+
+            Mat_<Point3f>& eta_minus = buf_.eta_minus[current_tree_level];
+            calcEta(src_joint_f_, buf_.theta, cluster_minus, eta_minus, (float)sigma_s_, (float)df, buf_);
+
+            Mat_<Point3f>& eta_plus = buf_.eta_plus[current_tree_level];
+            calcEta(src_joint_f_, buf_.theta, cluster_plus, eta_plus, (float)sigma_s_, (float)df, buf_);
+
+            // Algorithm 1, Step 5: recursively build more manifolds.
+
+            buildManifoldsAndPerformFiltering(eta_minus, cluster_minus, current_tree_level + 1);
+            buildManifoldsAndPerformFiltering(eta_plus, cluster_plus, current_tree_level + 1);
+        }
+    }
+
+} // namespace
+
+Ptr<AdaptiveManifoldFilter> createAMFilterRefImpl(double sigma_s, double sigma_r, bool adjust_outliers)
+{
+    Ptr<AdaptiveManifoldFilter> amf(new AdaptiveManifoldFilterRefImpl());
+
+    amf->setSigmaS(sigma_s);
+    amf->setSigmaR(sigma_r);
+    amf->setAdjustOutliers(adjust_outliers);
+
+    return amf;
+}
+
+} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_anisodiff.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_anisodiff.cpp
new file mode 100644
index 00000000..83555b79
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_anisodiff.cpp
@@ -0,0 +1,29 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ximgproc_AnisotropicDiffusion, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "cv/shared/";
+    string original_path = folder + "fruits.png";
+
+    Mat original = imread(original_path, IMREAD_COLOR);
+
+    ASSERT_FALSE(original.empty()) << "Could not load input image " << original_path;
+    ASSERT_EQ(3, original.channels()) << "Load color input image " << original_path;
+
+    Mat result;
+    float alpha = 1.0f;
+    float K = 0.02f;
+    int niters = 10;
+    ximgproc::anisotropicDiffusion(original, result, alpha, K, niters);
+
+    double adiff_psnr = cvtest::PSNR(original, result);
+    //printf("psnr=%.2f\n", adiff_psnr);
+    ASSERT_GT(adiff_psnr, 25.0);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_bilateral_texture_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_bilateral_texture_filter.cpp
new file mode 100644
index 00000000..4d82ed69
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_bilateral_texture_filter.cpp
@@ -0,0 +1,102 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<int, double, double, MatType, int> BTFParams;
+typedef TestWithParam<BTFParams> BilateralTextureFilterTest;
+
+TEST_P(BilateralTextureFilterTest, SplatSurfaceAccuracy)
+{
+  BTFParams params = GetParam();
+  int fr            = get<0>(params);
+  double sigmaAlpha = get<1>(params);
+  double sigmaAvg   = get<2>(params);
+  int depth         = get<3>(params);
+  int srcCn         = get<4>(params);
+
+  RNG rnd(0);
+
+  Size sz(rnd.uniform(256,512), rnd.uniform(256,512));
+
+  for (int i = 0; i < 5; i++)
+  {
+    Scalar surfaceValue;
+    if(depth == CV_8U)
+        rnd.fill(surfaceValue, RNG::UNIFORM, 0, 255);
+    else
+        rnd.fill(surfaceValue, RNG::UNIFORM, 0.0f, 1.0f);
+
+    Mat src(sz, CV_MAKE_TYPE(depth, srcCn), surfaceValue);
+
+    Mat res;
+    bilateralTextureFilter(src, res, fr, 1, sigmaAlpha, sigmaAvg);
+
+    double normL1 = cvtest::norm(src, res, NORM_L1)/src.total()/src.channels();
+    EXPECT_LE(normL1, 1.0/64.0);
+  }
+}
+
+TEST_P(BilateralTextureFilterTest, MultiThreadReproducibility)
+{
+    if (cv::getNumberOfCPUs() == 1)
+      return;
+
+    BTFParams params = GetParam();
+    int fr            = get<0>(params);
+    double sigmaAlpha = get<1>(params);
+    double sigmaAvg   = get<2>(params);
+    int depth         = get<3>(params);
+    int srcCn         = get<4>(params);
+
+    double MAX_DIF = 1.0;
+    double MAX_MEAN_DIF = 1.0 / 64.0;
+    int loopsCount = 2;
+    RNG rnd(1);
+
+    Size sz(rnd.uniform(256,512), rnd.uniform(256,512));
+
+    Mat src(sz,CV_MAKE_TYPE(depth, srcCn));
+    if(src.depth()==CV_8U)
+        randu(src, 0, 255);
+    else if(src.depth()==CV_16S)
+        randu(src, -32767, 32767);
+    else
+        randu(src, 0.0f, 1.0f);
+
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
+    for (int iter = 0; iter <= loopsCount; iter++)
+    {
+        cv::setNumThreads(nThreads);
+        Mat resMultiThread;
+        bilateralTextureFilter(src, resMultiThread, fr, 1, sigmaAlpha, sigmaAvg);
+
+        cv::setNumThreads(1);
+        Mat resSingleThread;
+        bilateralTextureFilter(src, resSingleThread, fr, 1, sigmaAlpha, sigmaAvg);
+
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_INF), MAX_DIF);
+        EXPECT_LE(
+          cv::norm(resSingleThread, resMultiThread, NORM_L1),
+          MAX_MEAN_DIF * src.total() * src.channels());
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(
+  TypicalSet1,
+  BilateralTextureFilterTest,
+  Combine(
+    Values(2),
+    Values(0.5),
+    Values(0.5),
+    Values(CV_8U, CV_32F),
+    Values(1, 3)
+    )
+);
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_deriche_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_deriche_filter.cpp
new file mode 100644
index 00000000..65aabae8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_deriche_filter.cpp
@@ -0,0 +1,41 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ximgproc_DericheFilter, regression)
+{
+    Mat img = Mat::zeros(64, 64, CV_8UC3);
+    Mat res = Mat::zeros(64, 64, CV_32FC3);
+    img.at<Vec3b>(31, 31) = Vec3b(1, 2, 4);
+    double a = 0.5;
+    double w = 0.0005;
+    Mat dst;
+
+    ximgproc::GradientDericheX(img, dst, a, w);
+    double c = pow(1 - exp(-a), 2.0) * exp(a);
+    double k = pow(a*(1 - exp(-a)), 2.0) / (1 + 2 * a*exp(-a) - exp(-2 * a));
+    for (int i = 0; i < img.rows; i++)
+    {
+        double n = -31 + i;
+        for (int j = 0; j < img.cols; j++)
+        {
+	        double m = -31 + j;
+	        double x = -c * exp(-a * fabs(m))*sin(w*m);
+	        x = x * (k*(a*sin(w*fabs(n)) + w * cos(w*fabs(n)))*exp(-a * fabs(n))) / (a*a + w * w);
+	        x = x / (w*w);
+	        float xx=static_cast<float>(x);
+	        res.at<Vec3f>(i, j) = Vec3f(xx, 2 * xx, 4 * xx);
+        }
+    }
+    EXPECT_LE(cv::norm(res, dst, NORM_INF), 1e-5);
+
+    Mat dst2;
+    ximgproc::GradientDericheY(img, dst2, a, w);
+    cv::transpose(dst2, dst2);
+    EXPECT_LE(cv::norm(dst2, dst, NORM_INF), 1e-5);
+}
+}
+} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_disparity_wls_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_disparity_wls_filter.cpp
new file mode 100644
index 00000000..b589d3f3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_disparity_wls_filter.cpp
@@ -0,0 +1,117 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+#include "opencv2/ximgproc/disparity_filter.hpp"
+
+namespace opencv_test { namespace {
+
+static string getDataDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+CV_ENUM(SrcTypes, CV_16S);
+CV_ENUM(GuideTypes, CV_8UC1, CV_8UC3)
+typedef tuple<Size, SrcTypes, GuideTypes, bool, bool> DisparityWLSParams;
+typedef TestWithParam<DisparityWLSParams> DisparityWLSFilterTest;
+
+TEST(DisparityWLSFilterTest, ReferenceAccuracy)
+{
+    string dir = getDataDir() + "cv/disparityfilter";
+
+    Mat left = imread(dir + "/left_view.png",IMREAD_COLOR);
+    ASSERT_FALSE(left.empty());
+    Mat left_disp  = imread(dir + "/disparity_left_raw.png",IMREAD_GRAYSCALE);
+    ASSERT_FALSE(left_disp.empty());
+    left_disp.convertTo(left_disp,CV_16S,16);
+    Mat right_disp = imread(dir + "/disparity_right_raw.png",IMREAD_GRAYSCALE);
+    ASSERT_FALSE(right_disp.empty());
+    right_disp.convertTo(right_disp,CV_16S,-16);
+
+    Mat GT;
+    ASSERT_FALSE(readGT(dir + "/GT.png",GT));
+
+    FileStorage ROI_storage( dir + "/ROI.xml", FileStorage::READ );
+    Rect ROI((int)ROI_storage["x"],(int)ROI_storage["y"],(int)ROI_storage["width"],(int)ROI_storage["height"]);
+
+    FileStorage reference_res( dir + "/reference_accuracy.xml", FileStorage::READ );
+    double ref_MSE = (double)reference_res["MSE_after"];
+    double ref_BadPercent = (double)reference_res["BadPercent_after"];
+
+    Mat res;
+
+    Ptr<DisparityWLSFilter> wls_filter = createDisparityWLSFilterGeneric(true);
+    wls_filter->setLambda(8000.0);
+    wls_filter->setSigmaColor(0.5);
+    wls_filter->filter(left_disp,left,res,right_disp,ROI);
+
+    double MSE = computeMSE(GT,res,ROI);
+    double BadPercent = computeBadPixelPercent(GT,res,ROI);
+    double eps = 0.01;
+
+    EXPECT_LE(MSE,ref_MSE+eps*ref_MSE);
+    EXPECT_LE(BadPercent,ref_BadPercent+eps*ref_BadPercent);
+}
+
+TEST_P(DisparityWLSFilterTest, MultiThreadReproducibility)
+{
+    if (cv::getNumberOfCPUs() == 1)
+        return;
+
+    double MAX_DIF = 1.0;
+    double MAX_MEAN_DIF = 1.0 / 256.0;
+    int loopsCount = 2;
+    RNG rng(0);
+
+    DisparityWLSParams params = GetParam();
+    Size size          = get<0>(params);
+    int srcType        = get<1>(params);
+    int guideType      = get<2>(params);
+    bool use_conf      = get<3>(params);
+    bool use_downscale = get<4>(params);
+
+    Mat left(size, guideType);
+    randu(left, 0, 255);
+    Mat left_disp(size,srcType);
+    int max_disp = (int)(size.width*0.1);
+    randu(left_disp, 0, max_disp-1);
+    Mat right_disp(size,srcType);
+    randu(left_disp, -max_disp+1, 0);
+    Rect ROI(max_disp,0,size.width-max_disp,size.height);
+
+    if(use_downscale)
+    {
+        resize(left_disp,left_disp,Size(),0.5,0.5, INTER_LINEAR_EXACT);
+        resize(right_disp,right_disp,Size(),0.5,0.5, INTER_LINEAR_EXACT);
+        ROI = Rect(ROI.x/2,ROI.y/2,ROI.width/2,ROI.height/2);
+    }
+
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
+    for (int iter = 0; iter <= loopsCount; iter++)
+    {
+        double lambda = rng.uniform(100.0, 10000.0);
+        double sigma  = rng.uniform(1.0, 100.0);
+
+        Ptr<DisparityWLSFilter> wls_filter = createDisparityWLSFilterGeneric(use_conf);
+        wls_filter->setLambda(lambda);
+        wls_filter->setSigmaColor(sigma);
+
+        cv::setNumThreads(nThreads);
+        Mat resMultiThread;
+        wls_filter->filter(left_disp,left,resMultiThread,right_disp,ROI);
+
+        cv::setNumThreads(1);
+        Mat resSingleThread;
+        wls_filter->filter(left_disp,left,resSingleThread,right_disp,ROI);
+
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_INF), MAX_DIF);
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_L1), MAX_MEAN_DIF*left.total());
+    }
+}
+INSTANTIATE_TEST_CASE_P(FullSet,DisparityWLSFilterTest,Combine(Values(szODD, szQVGA), SrcTypes::all(), GuideTypes::all(),Values(true,false),Values(true,false)));
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_domain_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_domain_transform.cpp
new file mode 100644
index 00000000..ab3dc155
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_domain_transform.cpp
@@ -0,0 +1,217 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static string getOpenCVExtraDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+CV_ENUM(SupportedTypes, CV_8UC1, CV_8UC3, CV_32FC1); // reduced set
+CV_ENUM(ModeType, DTF_NC, DTF_IC, DTF_RF)
+typedef tuple<Size, ModeType, SupportedTypes, SupportedTypes> DTParams;
+
+Mat convertTypeAndSize(Mat src, int dstType, Size dstSize)
+{
+    Mat dst;
+    CV_Assert(src.channels() == 3);
+
+    int dstChannels = CV_MAT_CN(dstType);
+
+    if (dstChannels == 1)
+    {
+        cvtColor(src, dst, COLOR_BGR2GRAY);
+    }
+    else if (dstChannels == 2)
+    {
+        Mat srcCn[3];
+        split(src, srcCn);
+        merge(srcCn, 2, dst);
+    }
+    else if (dstChannels == 3)
+    {
+        dst = src.clone();
+    }
+    else if (dstChannels == 4)
+    {
+        Mat srcCn[4];
+        split(src, srcCn);
+        srcCn[3] = srcCn[0].clone();
+        merge(srcCn, 4, dst);
+    }
+
+    dst.convertTo(dst, dstType);
+    resize(dst, dst, dstSize, 0, 0, dstType == CV_32FC1 ? INTER_LINEAR : INTER_LINEAR_EXACT);
+
+    return dst;
+}
+
+TEST(DomainTransformTest, SplatSurfaceAccuracy)
+{
+    static int dtModes[] = {DTF_NC, DTF_RF, DTF_IC};
+    RNG rnd(0);
+
+    for (int i = 0; i < 15; i++)
+    {
+        Size sz(rnd.uniform(512, 1024), rnd.uniform(512, 1024));
+
+        int guideCn = rnd.uniform(1, 4);
+        Mat guide(sz, CV_MAKE_TYPE(CV_32F, guideCn));
+        randu(guide, 0, 255);
+
+        Scalar surfaceValue;
+        int srcCn = rnd.uniform(1, 4);
+        rnd.fill(surfaceValue, RNG::UNIFORM, 0, 255);
+        Mat src(sz, CV_MAKE_TYPE(CV_8U, srcCn), surfaceValue);
+
+        double sigma_s = rnd.uniform(1.0, 100.0);
+        double sigma_r = rnd.uniform(1.0, 100.0);
+        int mode = dtModes[i%3];
+
+        Mat res;
+        dtFilter(guide, src, res, sigma_s, sigma_r, mode, 1);
+
+        double normL1 = cvtest::norm(src, res, NORM_L1)/src.total()/src.channels();
+        EXPECT_LE(normL1, 1.0/64);
+    }
+}
+
+typedef TestWithParam<DTParams> DomainTransformTest;
+TEST_P(DomainTransformTest, MultiThreadReproducibility)
+{
+    if (cv::getNumberOfCPUs() == 1)
+        return;
+
+    double MAX_DIF = 1.0;
+    double MAX_MEAN_DIF = 1.0 / 256.0;
+    int loopsCount = 2;
+    RNG rng(0);
+
+    DTParams params = GetParam();
+    Size size = get<0>(params);
+    int mode = get<1>(params);
+    int guideType = get<2>(params);
+    int srcType = get<3>(params);
+
+    Mat original = imread(getOpenCVExtraDir() + "cv/edgefilter/statue.png");
+    Mat guide = convertTypeAndSize(original, guideType, size);
+    Mat src = convertTypeAndSize(original, srcType, size);
+
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
+    for (int iter = 0; iter <= loopsCount; iter++)
+    {
+        double ss = rng.uniform(0.0, 100.0);
+        double sc = rng.uniform(0.0, 100.0);
+
+        cv::setNumThreads(nThreads);
+        Mat resMultithread;
+        dtFilter(guide, src, resMultithread, ss, sc, mode);
+
+        cv::setNumThreads(1);
+        Mat resSingleThread;
+        dtFilter(guide, src, resSingleThread, ss, sc, mode);
+
+        EXPECT_LE(cv::norm(resSingleThread, resMultithread, NORM_INF), MAX_DIF);
+        EXPECT_LE(cv::norm(resSingleThread, resMultithread, NORM_L1), MAX_MEAN_DIF*src.total());
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(FullSet, DomainTransformTest,
+    Combine(Values(szODD, szQVGA), ModeType::all(), SupportedTypes::all(), SupportedTypes::all())
+);
+
+template<typename SrcVec>
+Mat getChessMat1px(Size sz, double whiteIntensity = 255)
+{
+    typedef typename DataType<SrcVec>::channel_type SrcType;
+
+    Mat dst(sz, traits::Type<SrcVec>::value);
+
+    SrcVec black = SrcVec::all(0);
+    SrcVec white = SrcVec::all((SrcType)whiteIntensity);
+
+    for (int i = 0; i < dst.rows; i++)
+        for (int j = 0; j < dst.cols; j++)
+            dst.at<SrcVec>(i, j) = ((i + j) % 2) ? white : black;
+
+    return dst;
+}
+
+TEST(DomainTransformTest, ChessBoard_NC_accuracy)
+{
+    RNG rng(0);
+    double MAX_DIF = 1;
+    Size sz = szVGA;
+    double ss = 80;
+    double sc = 60;
+
+    Mat srcb = randomMat(rng, sz, CV_8UC4, 0, 255, true);
+    Mat srcf = randomMat(rng, sz, CV_32FC4, 0, 255, true);
+    Mat chessb = getChessMat1px<Vec3b>(sz);
+
+    Mat dstb, dstf;
+    dtFilter(chessb, srcb.clone(), dstb, ss, sc, DTF_NC);
+    dtFilter(chessb, srcf.clone(), dstf, ss, sc, DTF_NC);
+
+    EXPECT_LE(cv::norm(srcb, dstb, NORM_INF), MAX_DIF);
+    EXPECT_LE(cv::norm(srcf, dstf, NORM_INF), MAX_DIF);
+}
+
+TEST(DomainTransformTest, BoxFilter_NC_accuracy)
+{
+    double MAX_DIF = 1;
+    int radius = 5;
+    double sc = 1.0;
+    double ss = 1.01*radius / sqrt(3.0);
+
+    Mat src = imread(getOpenCVExtraDir() + "cv/edgefilter/statue.png");
+    ASSERT_TRUE(!src.empty());
+
+    Mat1b guide(src.size(), 200);
+    Mat res_dt, res_box;
+
+    blur(src, res_box, Size(2 * radius + 1, 2 * radius + 1));
+    dtFilter(guide, src, res_dt, ss, sc, DTF_NC, 1);
+
+    EXPECT_LE(cv::norm(res_dt, res_box, NORM_L2), MAX_DIF*src.total());
+}
+
+TEST(DomainTransformTest, AuthorReferenceAccuracy)
+{
+    string dir = getOpenCVExtraDir() + "cv/edgefilter";
+    double ss = 30;
+    double sc = 0.2 * 255;
+
+    Mat src = imread(dir + "/statue.png");
+    Mat ref_NC = imread(dir + "/dt/authors_statue_NC_ss30_sc0.2.png");
+    Mat ref_IC = imread(dir + "/dt/authors_statue_IC_ss30_sc0.2.png");
+    Mat ref_RF = imread(dir + "/dt/authors_statue_RF_ss30_sc0.2.png");
+
+    ASSERT_FALSE(src.empty());
+    ASSERT_FALSE(ref_NC.empty());
+    ASSERT_FALSE(ref_IC.empty());
+    ASSERT_FALSE(ref_RF.empty());
+
+    Mat res_NC, res_IC, res_RF;
+    dtFilter(src, src, res_NC, ss, sc, DTF_NC);
+    dtFilter(src, src, res_IC, ss, sc, DTF_IC);
+    dtFilter(src, src, res_RF, ss, sc, DTF_RF);
+
+    double totalMaxError = 1.0/64.0*src.total();
+
+    EXPECT_LE(cvtest::norm(res_NC, ref_NC, NORM_L2), totalMaxError);
+    EXPECT_LE(cvtest::norm(res_NC, ref_NC, NORM_INF), 1);
+
+    EXPECT_LE(cvtest::norm(res_IC, ref_IC, NORM_L2), totalMaxError);
+    EXPECT_LE(cvtest::norm(res_IC, ref_IC, NORM_INF), 1);
+
+    EXPECT_LE(cvtest::norm(res_RF, ref_RF, NORM_L2), totalMaxError);
+    EXPECT_LE(cvtest::norm(res_IC, ref_IC, NORM_INF), 1);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_edgeboxes.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_edgeboxes.cpp
new file mode 100644
index 00000000..03e95637
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_edgeboxes.cpp
@@ -0,0 +1,48 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ximgproc_Edgeboxes, regression)
+{
+    //Testing Edgeboxes implementation by asking for one proposal
+    //on a simple test image from the PASCAL VOC 2012 dataset.
+    std::vector<Rect> boxes;
+    std::vector<float> scores;
+    float expectedScore = 0.48742563f;
+    Rect expectedProposal(158, 69, 125, 154);
+
+    //Using sample model file, compute orientations map for use with edge detection.
+    cv::String testImagePath = cvtest::TS::ptr()->get_data_path() + "cv/ximgproc/" + "pascal_voc_bird.png";
+    Mat testImg = imread(testImagePath);
+    ASSERT_FALSE(testImg.empty()) << "Could not load input image " << testImagePath;
+    cvtColor(testImg, testImg, COLOR_BGR2RGB);
+    testImg.convertTo(testImg, CV_32F, 1.0 / 255.0f);
+
+    //Use the model for structured edge detection that is already provided in opencv_extra.
+    cv::String model_path = cvtest::TS::ptr()->get_data_path() + "cv/ximgproc/" + "model.yml.gz";
+    Ptr<StructuredEdgeDetection> sed = createStructuredEdgeDetection(model_path);
+    Mat edgeImage, edgeOrientations;
+    sed->detectEdges(testImg, edgeImage);
+    sed->computeOrientation(edgeImage, edgeOrientations);
+
+    //Obtain one proposal and its score from Edgeboxes.
+    Ptr<EdgeBoxes> edgeboxes = createEdgeBoxes();
+    edgeboxes->setMaxBoxes(1);
+    edgeboxes->getBoundingBoxes(edgeImage, edgeOrientations, boxes, scores);
+
+    //We asked for one proposal and thus one score, we better get one back only.
+    ASSERT_TRUE(boxes.size() == 1);
+    ASSERT_TRUE(scores.size() == 1);
+
+    //Check the proposal and its score.
+    EXPECT_NEAR(scores[0], expectedScore, 1e-8);
+    EXPECT_EQ(expectedProposal.x, boxes[0].x);
+    EXPECT_EQ(expectedProposal.y, boxes[0].y);
+    EXPECT_EQ(expectedProposal.height, boxes[0].height);
+    EXPECT_EQ(expectedProposal.width, boxes[0].width);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_edgepreserving_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_edgepreserving_filter.cpp
new file mode 100644
index 00000000..8f6059b7
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_edgepreserving_filter.cpp
@@ -0,0 +1,35 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+//                    Created by Simon Reich
+//
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ximgproc_EdgepreservingFilter, regression)
+{
+    // Load original image
+    std::string filename = string(cvtest::TS::ptr()->get_data_path()) + "perf/320x260.png";
+    cv::Mat src, dst, noise, original = imread(filename, 1);
+
+    ASSERT_FALSE(original.empty()) << "Could not load input image " << filename;
+    ASSERT_EQ(3, original.channels()) << "Load color input image " << filename;
+
+    // add noise
+    noise = Mat(original.size(), original.type());
+    cv::randn(noise, 0, 5);
+    src = original + noise;
+
+    // Filter
+    int kernel = 9;
+    double threshold = 20;
+    ximgproc::edgePreservingFilter(src, dst, kernel, threshold);
+
+    double psnr = cvtest::PSNR(original, dst);
+    //printf("psnr=%.2f\n", psnr);
+    ASSERT_LT(psnr, 25.0);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fast_hough_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fast_hough_transform.cpp
new file mode 100644
index 00000000..aa41132e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fast_hough_transform.cpp
@@ -0,0 +1,462 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2015, Smart Engines Ltd, all rights reserved.
+// Copyright (C) 2015, Institute for Information Transmission Problems of the Russian Academy of Sciences (Kharkevich Institute), all rights reserved.
+// Copyright (C) 2015, Dmitry Nikolaev, Simon Karpenko, Michail Aliev, Elena Kuznetsova, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+//----------------------utils---------------------------------------------------
+
+template <typename T> struct Eps
+{
+    static T get() { return 1; }
+};
+template <> struct Eps<float> { static float get() { return float(1e-3); } };
+template <> struct Eps<double> { static double get() { return 1e-6; } };
+
+template <typename T> struct MinPos
+{
+    static T get() { return Eps<T>::get(); }
+};
+
+template <typename T> struct Max { static T get()
+{
+    return saturate_cast<T>(numeric_limits<T>::max()); }
+};
+
+template <typename T> struct Rand
+{
+    static T get(T _min = MinPos<T>::get(), T _max = Max<T>::get())
+    {
+        RNG& rng = TS::ptr()->get_rng();
+        return saturate_cast<T>(rng.uniform(int(std::max(MinPos<T>::get(),
+                                                         _min)),
+                                            int(std::min(Max<T>::get(),
+                                                         _max))));
+    }
+};
+template <> struct Rand <float>
+{
+    static float get(float _min = MinPos<float>::get(),
+                     float _max = Max<float>::get())
+    {
+        RNG& rng = TS::ptr()->get_rng();
+        return rng.uniform(std::max(MinPos<float>::get(), _min),
+                           std::min(Max<float>::get(),    _max));
+    }
+};
+template <> struct Rand <double>
+{
+    static double get(double _min = MinPos<double>::get(),
+                     double _max = Max<double>::get())
+    {
+        RNG& rng = TS::ptr()->get_rng();
+        return rng.uniform(std::max(MinPos<double>::get(), _min),
+                           std::min(Max<double>::get(),    _max));
+    }
+};
+
+template <typename T> struct Eq
+{
+    static bool get(T a, T b)
+    {
+        return a < b ? b - a < Eps<T>::get() : a - b < Eps<T>::get();
+    }
+};
+
+//----------------------TestFHT-------------------------------------------------
+class TestFHT
+{
+public:
+    TestFHT() : ts(TS::ptr()) {}
+
+    void run_n_tests(int depth,
+                     int channels,
+                     int pts_count,
+                     int n_per_test);
+
+private:
+    template <typename T>
+    int run_n_tests_t(int depth,
+                      int channels,
+                      int pts_count,
+                      int n_per_test);
+
+    template <typename T>
+    int run_test(int depth,
+                 int channels,
+                 int pts_count);
+
+    template <typename T>
+    int put_random_points(Mat &img,
+                          int count,
+                          vector<Point> &pts);
+
+    int run_func(Mat const&src,
+                 Mat& fht);
+
+    template <typename T>
+    int validate_test_results(Mat const &fht,
+                              Mat const &src,
+                              vector<Point> const& pts);
+
+    template <typename T> int validate_sum(Mat const& src, Mat const& fht);
+    int validate_point(Mat const& fht, vector<Point> const &pts);
+    int validate_line(Mat const& fht, Mat const& src, vector<Point> const& pts);
+
+private:
+    TS *ts;
+};
+
+template <typename T>
+int TestFHT::put_random_points(Mat &img, int count, vector<Point> &pts)
+{
+    int code = TS::OK;
+
+    pts.resize(count, Point(-1, -1));
+
+    for (int i = 0; i < count; ++i)
+    {
+        RNG rng = ts->get_rng();
+        Point const pt(rng.uniform(0, img.cols),
+                       rng.uniform(0, img.rows));
+        pts[i] = pt;
+
+        for (int c = 0; c < img.channels(); ++c)
+        {
+            T color = Rand<T>::get(MinPos<T>::get(),
+                                   T(Max<T>::get() / count));
+
+            T *img_line = (T*)(img.data + img.step * pt.y);
+            img_line[pt.x * img.channels() + c] = color;
+        }
+    }
+
+    return code;
+}
+
+template <typename T>
+int TestFHT::validate_sum(Mat const& src, Mat const& fht)
+{
+    int const channels = src.channels();
+    if (fht.channels() != channels)
+        return TS::FAIL_BAD_ARG_CHECK;
+
+
+    vector<Mat> src_channels(channels);
+    split(src, src_channels);
+    vector<Mat> fht_channels(channels);
+    split(fht, fht_channels);
+
+    for (int c = 0; c < channels; ++c)
+    {
+        T const src_sum = saturate_cast<T>(sum(src_channels[c]).val[0]);
+        for (int y = 0; y < fht.rows; ++y)
+        {
+            T const fht_sum = saturate_cast<T>(sum(fht_channels[c].row(y)).val[0]);
+            if (!Eq<T>::get(src_sum, fht_sum))
+            {
+                ts->printf(TS::LOG,
+                           "The sum of column #%d of channel #%d of the fast "
+                           "hough transform result and the sum of source image"
+                           " mismatch (=%g, should be =%g)\n",
+                           y, c, (float)fht_sum, (float)src_sum);
+                return TS::FAIL_BAD_ACCURACY;
+            }
+        }
+    }
+    return TS::OK;
+}
+
+int TestFHT::validate_point(Mat const& fht,
+                            vector<Point> const &pts)
+{
+    if (pts.empty())
+        return TS::OK;
+
+    for (size_t i = 1; i < pts.size(); ++i)
+    {
+        if (pts[0] != pts[i])
+            return TS::OK;
+    }
+
+    int const channels = fht.channels();
+    vector<Mat> fht_channels(channels);
+    split(fht, fht_channels);
+
+    for (int c = 0; c < channels; ++c)
+    {
+        for (int y = 0; y < fht.rows; ++y)
+        {
+            int cnt = countNonZero(fht_channels[c].row(y));
+            if (cnt != 1)
+            {
+                ts->printf(TS::LOG,
+                           "The incorrect count of non-zero values in column "
+                           "#%d, channel #%d of FastHoughTransform result "
+                           "image (=%d, should be %d)\n",
+                           y, c, cnt, 1);
+                return TS::FAIL_BAD_ACCURACY;
+            }
+        }
+    }
+    return TS::OK;
+}
+
+static const double MAX_LDIST = 2.0;
+int TestFHT::validate_line(Mat const& fht,
+                           Mat const& src,
+                           vector<Point> const& pts)
+{
+    size_t const size = (int)pts.size();
+    if (size < 2)
+        return TS::OK;
+    size_t first_pt_i = 0, second_pt_i = 1;
+    for (size_t i = first_pt_i + 1; i < size; ++i)
+    {
+        if (pts[i] != pts[first_pt_i])
+        {
+            second_pt_i = first_pt_i;
+            break;
+        }
+    }
+    if (pts[second_pt_i] == pts[first_pt_i])
+        return TS::OK;
+    for (size_t i = second_pt_i + 1; i < size; ++i)
+    {
+        if (pts[i] != pts[second_pt_i])
+            return TS::OK;
+    }
+    const Point &f = pts[first_pt_i];
+    const Point &s = pts[second_pt_i];
+
+    int const channels = fht.channels();
+    vector<Mat> fht_channels(channels);
+    split(fht, fht_channels);
+
+    for (int ch = 0; ch < channels; ++ch)
+    {
+        Point fht_max(-1, -1);
+        minMaxLoc(fht_channels[ch], 0, 0, 0, &fht_max);
+        Vec4i src_line =  HoughPoint2Line(fht_max, src,
+                                          ARO_315_135, HDO_DESKEW, RO_STRICT);
+
+        double const a = src_line[1] - src_line[3];
+        double const b = src_line[2] - src_line[0];
+        double const c = - (a * src_line[0] + b * src_line[1]);
+
+        double const fd = abs(f.x * a + f.y * b + c) / sqrt(a * a + b * b);
+        double const sd = abs(s.x * a + s.y * b + c) / sqrt(a * a + b * b);
+        double const dist = std::max(fd, sd);
+
+        if (dist > MAX_LDIST)
+        {
+            ts->printf(TS::LOG,
+                       "Failed to detect max line in channels %d (distance "
+                        "between point and line correspoinding of maximum in "
+                        "FastHoughTransform space is #%g)\n", ch, dist);
+            return TS::FAIL_BAD_ACCURACY;
+        }
+    }
+
+    return TS::OK;
+}
+
+template <typename T>
+int TestFHT::validate_test_results(Mat const &fht,
+                                   Mat const &src,
+                                   vector<Point> const& pts)
+{
+    int code = validate_sum<T>(src, fht);
+    if (code == TS::OK)
+        code = validate_point(fht, pts);
+    if (code == TS::OK)
+        code = validate_line(fht, src, pts);
+    return code;
+}
+
+int TestFHT::run_func(Mat const&src,
+                      Mat& fht)
+{
+    int code = TS::OK;
+    FastHoughTransform(src, fht, src.depth());
+    return code;
+}
+
+static Size random_size(int const max_size_log,
+                        int const elem_size)
+{
+    RNG& rng = TS::ptr()->get_rng();
+    return randomSize(rng, std::max(1,
+        max_size_log - cvRound(log(double(elem_size)))));
+}
+
+static const int FHT_MAX_SIZE_LOG = 9;
+
+template <typename T>
+int TestFHT::run_test(int depth,
+                      int channels,
+                      int pts_count)
+{
+    int code = TS::OK;
+
+    Size size = random_size(FHT_MAX_SIZE_LOG,
+                            CV_ELEM_SIZE(CV_MAKE_TYPE(depth, channels)));
+    Mat src = Mat::zeros(size, CV_MAKETYPE(depth, channels));
+
+    vector<Point> pts;
+    code = put_random_points<T>(src, pts_count, pts);
+    if (code != TS::OK)
+        return code;
+
+    Mat fht;
+    code = run_func(src, fht);
+    if (code != TS::OK)
+        return code;
+
+    code = validate_test_results<T>(fht, src, pts);
+    return code;
+}
+
+void TestFHT::run_n_tests(int depth,
+                          int channels,
+                          int pts_count,
+                          int  n)
+{
+    try
+    {
+        int code = TS::OK;
+
+        switch (depth)
+        {
+        case CV_8U:
+            code = run_n_tests_t<uchar>(depth, channels, pts_count, n);
+            break;
+        case CV_8S:
+            code = run_n_tests_t<schar>(depth, channels, pts_count, n);
+            break;
+        case CV_16U:
+            code = run_n_tests_t<ushort>(depth, channels, pts_count, n);
+            break;
+        case CV_16S:
+            code = run_n_tests_t<short>(depth, channels, pts_count, n);
+            break;
+        case CV_32S:
+            code = run_n_tests_t<int>(depth, channels, pts_count, n);
+            break;
+        case CV_32F:
+            code = run_n_tests_t<float>(depth, channels, pts_count, n);
+            break;
+        case CV_64F:
+            code = run_n_tests_t<double>(depth, channels, pts_count, n);
+            break;
+        default:
+            code = TS::FAIL_BAD_ARG_CHECK;
+            ts->printf(TS::LOG, "Unknown depth %d\n", depth);
+            break;
+        }
+        if (code != TS::OK)
+            throw TS::FailureCode(code);
+    }
+    catch (const TS::FailureCode& fc)
+    {
+        std::string errorStr = TS::str_from_code(fc);
+        ts->printf(TS::LOG,
+                   "General failure:\n\t%s (%d)\n", errorStr.c_str(), fc);
+
+        ts->set_failed_test_info(fc);
+    }
+    catch(...)
+    {
+        ts->printf(TS::LOG, "Unknown failure\n");
+        ts->set_failed_test_info(TS::FAIL_EXCEPTION);
+    }
+}
+
+template <typename T>
+int TestFHT::run_n_tests_t(int depth,
+                           int channels,
+                           int pts_count,
+                           int n)
+{
+    int code = TS::OK;
+    for (int iTest = 0; iTest < n; ++iTest)
+    {
+        code = run_test<T>(depth, channels, pts_count);
+        if (code != TS::OK)
+        {
+            ts->printf(TS::LOG, "Test %d failed with code %d\n", iTest, code);
+            break;
+        }
+    }
+    return code;
+}
+
+//----------------------TEST_P--------------------------------------------------
+typedef tuple<int, int, int, int> Depth_Channels_PtsC_nPerTest;
+typedef TestWithParam<Depth_Channels_PtsC_nPerTest> FastHoughTransformTest;
+
+TEST_P(FastHoughTransformTest, accuracy)
+{
+    int  const depth      = get<0>(GetParam());
+    int  const channels   = get<1>(GetParam());
+    int  const pts_count  = get<2>(GetParam());
+    int  const n_per_test = get<3>(GetParam());
+
+    TestFHT testFht;
+    testFht.run_n_tests(depth, channels, pts_count, n_per_test);
+}
+
+#define FHT_ALL_DEPTHS CV_8U, CV_16U, CV_32S, CV_32F, CV_64F
+#define FHT_ALL_CHANNELS 1, 3, 4
+
+INSTANTIATE_TEST_CASE_P(FullSet, FastHoughTransformTest,
+                        Combine(Values(FHT_ALL_DEPTHS),
+                                Values(FHT_ALL_CHANNELS),
+                                Values(1, 2),
+                                Values(5)));
+
+#undef FHT_ALL_DEPTHS
+#undef FHT_ALL_CHANNELS
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fbs_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fbs_filter.cpp
new file mode 100644
index 00000000..f966d5b6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fbs_filter.cpp
@@ -0,0 +1,131 @@
+/*
+ *  By downloading, copying, installing or using the software you agree to this license.
+ *  If you do not agree to this license, do not download, install,
+ *  copy or use the software.
+ *
+ *
+ *  License Agreement
+ *  For Open Source Computer Vision Library
+ *  (3 - clause BSD License)
+ *
+ *  Redistribution and use in source and binary forms, with or without modification,
+ *  are permitted provided that the following conditions are met :
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *  this list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation
+ *  and / or other materials provided with the distribution.
+ *
+ *  * Neither the names of the copyright holders nor the names of the contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  This software is provided by the copyright holders and contributors "as is" and
+ *  any express or implied warranties, including, but not limited to, the implied
+ *  warranties of merchantability and fitness for a particular purpose are disclaimed.
+ *  In no event shall copyright holders or contributors be liable for any direct,
+ *  indirect, incidental, special, exemplary, or consequential damages
+ *  (including, but not limited to, procurement of substitute goods or services;
+ *  loss of use, data, or profits; or business interruption) however caused
+ *  and on any theory of liability, whether in contract, strict liability,
+ *  or tort(including negligence or otherwise) arising in any way out of
+ *  the use of this software, even if advised of the possibility of such damage.
+ */
+
+#include "test_precomp.hpp"
+
+#ifdef HAVE_EIGEN
+
+namespace opencv_test { namespace {
+
+using namespace std;
+using namespace cv;
+using namespace cv::ximgproc;
+
+static string getDataDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+CV_ENUM(SrcTypes, CV_8UC1, CV_8UC3, CV_8UC4, CV_16SC1, CV_16SC3, CV_32FC1);
+CV_ENUM(GuideTypes, CV_8UC1, CV_8UC3)
+typedef tuple<Size, SrcTypes, GuideTypes> FBSParams;
+typedef TestWithParam<FBSParams> FastBilateralSolverTest;
+
+TEST(FastBilateralSolverTest, SplatSurfaceAccuracy)
+{
+    RNG rnd(0);
+    int chanLut[] = {1,3,4};
+
+    for (int i = 0; i < 5; i++)
+    {
+        Size sz(rnd.uniform(512, 1024), rnd.uniform(512, 1024));
+
+        int guideCn = rnd.uniform(0, 2); // 1 or 3 channels
+        Mat guide(sz, CV_MAKE_TYPE(CV_8U, chanLut[guideCn]));
+        randu(guide, 0, 255);
+
+        Scalar surfaceValue;
+        int srcCn = rnd.uniform(0, 3); // 1, 3 or 4 channels
+        rnd.fill(surfaceValue, RNG::UNIFORM, 0, 255);
+        Mat src(sz, CV_MAKE_TYPE(CV_16S, chanLut[srcCn]), surfaceValue);
+        Mat confidence(sz, CV_MAKE_TYPE(CV_8U, 1), 255);
+
+        double sigma_spatial = rnd.uniform(4.0, 40.0);
+        double sigma_luma = rnd.uniform(4.0, 40.0);
+        double sigma_chroma  = rnd.uniform(4.0, 40.0);
+
+        Mat res;
+        fastBilateralSolverFilter(guide, src, confidence, res, sigma_spatial, sigma_luma, sigma_chroma);
+
+        // When filtering a constant image we should get the same image:
+        double normL1 = cvtest::norm(src, res, NORM_L1)/src.total()/src.channels();
+        EXPECT_LE(normL1, 1.0/64);
+    }
+}
+
+#define COUNT_EXCEED(MAT1, MAT2, THRESHOLD, PIXEL_COUNT) \
+{                                                        \
+    Mat diff, count;                                     \
+    absdiff(MAT1.reshape(1), MAT2.reshape(1), diff);     \
+    cvtest::compare(diff, THRESHOLD, count, CMP_GT);     \
+    PIXEL_COUNT = countNonZero(count.reshape(1));        \
+    PIXEL_COUNT /= MAT1.channels();                      \
+}
+
+TEST(FastBilateralSolverTest, ReferenceAccuracy)
+{
+    string dir = getDataDir() + "cv/edgefilter";
+
+    Mat src = imread(dir + "/kodim23.png");
+    Mat ref = imread(dir + "/fbs/kodim23_spatial=16_luma=16_chroma=16.png");
+
+    Mat confidence(src.size(), CV_MAKE_TYPE(CV_8U, 1), 255);
+
+    ASSERT_FALSE(src.empty());
+    ASSERT_FALSE(ref.empty());
+
+    Mat res;
+    fastBilateralSolverFilter(src,src,confidence,res, 16.0, 16.0, 16.0);
+
+    double totalMaxError = 1.0/64.0*src.total()*src.channels();
+
+    EXPECT_LE(cvtest::norm(res, ref, NORM_L2), totalMaxError);
+#if defined (__x86_64__) || defined (_M_X64)
+    EXPECT_LE(cvtest::norm(res, ref, NORM_INF), 1);
+#else
+    // fastBilateralSolverFilter is not bit-exact
+    int pixelCount = 0;
+    COUNT_EXCEED(res, ref, 2, pixelCount);
+    EXPECT_LE(pixelCount, (int)(res.cols*res.rows*1/100));
+#endif
+}
+
+INSTANTIATE_TEST_CASE_P(FullSet, FastBilateralSolverTest,Combine(Values(szODD, szQVGA), SrcTypes::all(), GuideTypes::all()));
+
+}
+}
+
+#endif //HAVE_EIGEN
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fgs_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fgs_filter.cpp
new file mode 100644
index 00000000..27ee0b88
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fgs_filter.cpp
@@ -0,0 +1,115 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static string getDataDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+CV_ENUM(SrcTypes, CV_8UC1, CV_8UC3, CV_8UC4, CV_16SC1, CV_16SC3, CV_32FC1);
+CV_ENUM(GuideTypes, CV_8UC1, CV_8UC3)
+typedef tuple<Size, SrcTypes, GuideTypes> FGSParams;
+typedef TestWithParam<FGSParams> FastGlobalSmootherTest;
+
+TEST(FastGlobalSmootherTest, SplatSurfaceAccuracy)
+{
+    RNG rnd(0);
+
+    for (int i = 0; i < 5; i++)
+    {
+        Size sz(rnd.uniform(512, 1024), rnd.uniform(512, 1024));
+
+        int guideCn = rnd.uniform(1, 2);
+        if(guideCn==2) guideCn++; //1 or 3 channels
+        Mat guide(sz, CV_MAKE_TYPE(CV_8U, guideCn));
+        randu(guide, 0, 255);
+
+        Scalar surfaceValue;
+        int srcCn = rnd.uniform(1, 4);
+        rnd.fill(surfaceValue, RNG::UNIFORM, 0, 255);
+        Mat src(sz, CV_MAKE_TYPE(CV_16S, srcCn), surfaceValue);
+
+        double lambda = rnd.uniform(100, 10000);
+        double sigma  = rnd.uniform(1.0, 100.0);
+
+        Mat res;
+        fastGlobalSmootherFilter(guide, src, res, lambda, sigma);
+
+        // When filtering a constant image we should get the same image:
+        double normL1 = cvtest::norm(src, res, NORM_L1)/src.total()/src.channels();
+        EXPECT_LE(normL1, 1.0/64);
+    }
+}
+
+TEST(FastGlobalSmootherTest, ReferenceAccuracy)
+{
+    string dir = getDataDir() + "cv/edgefilter";
+
+    Mat src = imread(dir + "/kodim23.png");
+    Mat ref = imread(dir + "/fgs/kodim23_lambda=1000_sigma=10.png");
+
+    ASSERT_FALSE(src.empty());
+    ASSERT_FALSE(ref.empty());
+
+    Mat res;
+    fastGlobalSmootherFilter(src,src,res,1000.0,10.0);
+
+    double totalMaxError = 1.0/64.0*src.total()*src.channels();
+
+    EXPECT_LE(cvtest::norm(res, ref, NORM_L2), totalMaxError);
+    EXPECT_LE(cvtest::norm(res, ref, NORM_INF), 1);
+}
+
+TEST_P(FastGlobalSmootherTest, MultiThreadReproducibility)
+{
+    if (cv::getNumberOfCPUs() == 1)
+        return;
+
+    double MAX_DIF = 1.0;
+    double MAX_MEAN_DIF = 1.0 / 64.0;
+    int loopsCount = 2;
+    RNG rng(0);
+
+    FGSParams params = GetParam();
+    Size size     = get<0>(params);
+    int srcType   = get<1>(params);
+    int guideType = get<2>(params);
+
+    Mat guide(size, guideType);
+    randu(guide, 0, 255);
+    Mat src(size,srcType);
+    if(src.depth()==CV_8U)
+        randu(src, 0, 255);
+    else if(src.depth()==CV_16S)
+        randu(src, -32767, 32767);
+    else
+        randu(src, -100000.0f, 100000.0f);
+
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
+    for (int iter = 0; iter <= loopsCount; iter++)
+    {
+        double lambda = rng.uniform(100.0, 10000.0);
+        double sigma  = rng.uniform(1.0, 100.0);
+
+        cv::setNumThreads(nThreads);
+        Mat resMultiThread;
+        fastGlobalSmootherFilter(guide, src, resMultiThread, lambda, sigma);
+
+        cv::setNumThreads(1);
+        Mat resSingleThread;
+        fastGlobalSmootherFilter(guide, src, resSingleThread, lambda, sigma);
+
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_INF), MAX_DIF);
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_L1), MAX_MEAN_DIF*src.total()*src.channels());
+    }
+}
+INSTANTIATE_TEST_CASE_P(FullSet, FastGlobalSmootherTest,Combine(Values(szODD, szQVGA), SrcTypes::all(), GuideTypes::all()));
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_find_ellipses.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_find_ellipses.cpp
new file mode 100644
index 00000000..b1fd27bb
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_find_ellipses.cpp
@@ -0,0 +1,43 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+using namespace cv;
+
+namespace opencv_test { namespace {
+
+
+TEST(FindEllipsesTest, EllipsesOnly)
+{
+    std::string picture_name = "cv/imgproc/stuff.jpg";
+    std::string filename = cvtest::TS::ptr()->get_data_path() + picture_name;
+    Mat src = imread(filename, IMREAD_GRAYSCALE);
+    EXPECT_FALSE(src.empty()) << "Invalid test image: " << filename;
+
+    std::vector<Vec6f> ells;
+    ximgproc::findEllipses(src, ells, 0.7f, 0.75f, 0.02f);
+
+    // number check
+    EXPECT_EQ(ells.size(), size_t(3)) << "Should find 3 ellipses";
+
+    // position check
+    // target centers
+    Point2f center_1(226.9f, 57.2f);
+    Point2f center_2(393.1f, 187.0f);
+    Point2f center_3(208.5f, 307.5f);
+    // matching
+    for (auto ell: ells) {
+        bool has_match = false;
+        for (auto c: {center_1, center_2, center_3}) {
+            Point2f diff = c - Point2f(ell[0], ell[1]);
+            float distance = sqrt(diff.x * diff.x + diff.y * diff.y);
+            if (distance < 5.0) {
+                has_match = true;
+                break;
+            }
+        }
+        EXPECT_TRUE(has_match) << "Wrong ellipse center:" << Point2f(ell[0], ell[1]);
+    }
+}
+}}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fld.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fld.cpp
new file mode 100644
index 00000000..24022a38
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fld.cpp
@@ -0,0 +1,299 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+const Size img_size(320, 240);
+const int FLD_TEST_SEED = 0x134679;
+const int EPOCHS = 10;
+
+class FLDBase : public testing::Test
+{
+    public:
+        FLDBase() { }
+
+    protected:
+        Mat test_image;
+        vector<Vec4f> lines;
+        RNG rng;
+        int passedtests;
+
+        void GenerateWhiteNoise(Mat& image);
+        void GenerateConstColor(Mat& image);
+        void GenerateLines(Mat& image, const unsigned int numLines);
+        void GenerateEdgeLines(Mat& image, const unsigned int numLines);
+        void GenerateBrokenLines(Mat& image, const unsigned int numLines);
+        void GenerateRotatedRect(Mat& image);
+        virtual void SetUp();
+};
+
+class ximgproc_FLD: public FLDBase
+{
+    public:
+        ximgproc_FLD() { }
+    protected:
+
+};
+
+class ximgproc_ED: public FLDBase
+{
+    public:
+        ximgproc_ED()
+        {
+            detector = createEdgeDrawing();
+        }
+    protected:
+        Ptr<EdgeDrawing> detector;
+
+};
+
+void FLDBase::GenerateWhiteNoise(Mat& image)
+{
+    image = Mat(img_size, CV_8UC1);
+    rng.fill(image, RNG::UNIFORM, 0, 256);
+}
+
+void FLDBase::GenerateConstColor(Mat& image)
+{
+    image = Mat(img_size, CV_8UC1, Scalar::all(rng.uniform(0, 256)));
+}
+
+
+void FLDBase::GenerateLines(Mat& image, const unsigned int numLines)
+{
+    image = Mat(img_size, CV_8UC1, Scalar::all(rng.uniform(0, 128)));
+
+    for(unsigned int i = 0; i < numLines; ++i)
+    {
+        int y = rng.uniform(10, img_size.width - 10);
+        Point p1(y, 10);
+        Point p2(y, img_size.height - 10);
+        line(image, p1, p2, Scalar(255), 2);
+    }
+}
+
+void FLDBase::GenerateEdgeLines(Mat& image, const unsigned int numLines)
+{
+    image = Mat(img_size, CV_8UC1, Scalar::all(0));
+
+    for(unsigned int i = 0; i < numLines; ++i)
+    {
+        int y = rng.uniform(10, img_size.width - 10);
+        Point p1(y, 10);
+        Point p2(y, img_size.height - 10);
+        line(image, p1, p2, Scalar(255), 1);
+    }
+}
+
+void FLDBase::GenerateBrokenLines(Mat& image, const unsigned int numLines)
+{
+    image = Mat(img_size, CV_8UC1, Scalar::all(rng.uniform(0, 128)));
+
+    for(unsigned int i = 0; i < numLines; ++i)
+    {
+        int y = rng.uniform(10, img_size.width - 10);
+        Point p1(y, 10);
+        Point p2(y, img_size.height/2);
+        line(image, p1, p2, Scalar(255), 2);
+        p1 = Point2i(y, img_size.height/2 + 3);
+        p2 = Point2i(y, img_size.height - 10);
+        line(image, p1, p2, Scalar(255), 2);
+    }
+}
+
+void FLDBase::GenerateRotatedRect(Mat& image)
+{
+    image = Mat::zeros(img_size, CV_8UC1);
+
+    Point center(rng.uniform(img_size.width/4, img_size.width*3/4),
+            rng.uniform(img_size.height/4, img_size.height*3/4));
+    Size rect_size(rng.uniform(img_size.width/8, img_size.width/6),
+            rng.uniform(img_size.height/8, img_size.height/6));
+    float angle = rng.uniform(0.f, 360.f);
+
+    Point2f vertices[4];
+
+    RotatedRect rRect = RotatedRect(center, rect_size, angle);
+
+    rRect.points(vertices);
+    for (int i = 0; i < 4; i++)
+    {
+        line(image, vertices[i], vertices[(i + 1) % 4], Scalar(255), 3);
+    }
+}
+
+void FLDBase::SetUp()
+{
+    lines.clear();
+    test_image = Mat();
+    rng = RNG(FLD_TEST_SEED);
+    passedtests = 0;
+}
+
+
+TEST_F(ximgproc_FLD, whiteNoise)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        GenerateWhiteNoise(test_image);
+        Ptr<FastLineDetector> detector = createFastLineDetector(20);
+        detector->detect(test_image, lines);
+
+        if(40u >= lines.size()) ++passedtests;
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+TEST_F(ximgproc_FLD, constColor)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        GenerateConstColor(test_image);
+        Ptr<FastLineDetector> detector = createFastLineDetector();
+        detector->detect(test_image, lines);
+
+        if(0u == lines.size()) ++passedtests;
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+TEST_F(ximgproc_FLD, lines)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        const unsigned int numOfLines = 1;
+        GenerateLines(test_image, numOfLines);
+        Ptr<FastLineDetector> detector = createFastLineDetector();
+        detector->detect(test_image, lines);
+        if(numOfLines * 2 == lines.size()) ++passedtests;  // * 2 because of Gibbs effect
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+TEST_F(ximgproc_FLD, edgeLines)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        const unsigned int numOfLines = 1;
+        GenerateEdgeLines(test_image, numOfLines);
+        Ptr<FastLineDetector> detector = createFastLineDetector(10, 1.414213562f, 50, 50, 0);
+        detector->detect(test_image, lines);
+        if(numOfLines == lines.size()) ++passedtests;
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+TEST_F(ximgproc_FLD, mergeLines)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        const unsigned int numOfLines = 1;
+        GenerateBrokenLines(test_image, numOfLines);
+        Ptr<FastLineDetector> detector = createFastLineDetector(10, 1.414213562f, true);
+        detector->detect(test_image, lines);
+        if(numOfLines * 2 == lines.size()) ++passedtests;  // * 2 because of Gibbs effect
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+TEST_F(ximgproc_FLD, rotatedRect)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        GenerateRotatedRect(test_image);
+        Ptr<FastLineDetector> detector = createFastLineDetector();
+        detector->detect(test_image, lines);
+
+        if(2u <= lines.size())  ++passedtests;
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+//************** EDGE DRAWING *******************
+
+TEST_F(ximgproc_ED, whiteNoise)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        GenerateWhiteNoise(test_image);
+        detector->detectEdges(test_image);
+        detector->detectLines(lines);
+        if(2u >= lines.size()) ++passedtests;
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+TEST_F(ximgproc_ED, constColor)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        GenerateConstColor(test_image);
+        detector->detectEdges(test_image);
+        if(0u == detector->getSegments().size()) ++passedtests;
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+TEST_F(ximgproc_ED, lines)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        const unsigned int numOfLines = 1;
+        GenerateLines(test_image, numOfLines);
+        detector->detectEdges(test_image);
+        detector->detectLines(lines);
+        if(numOfLines * 2 == lines.size()) ++passedtests;  // * 2 because of Gibbs effect
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+TEST_F(ximgproc_ED, mergeLines)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        const unsigned int numOfLines = 1;
+        GenerateBrokenLines(test_image, numOfLines);
+        detector->detectEdges(test_image);
+        detector->detectLines(lines);
+        if(numOfLines * 2 == lines.size()) ++passedtests;  // * 2 because of Gibbs effect
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+TEST_F(ximgproc_ED, rotatedRect)
+{
+    for (int i = 0; i < EPOCHS; ++i)
+    {
+        GenerateRotatedRect(test_image);
+        detector->detectEdges(test_image);
+        detector->detectLines(lines);
+
+        if(6u <= lines.size())  ++passedtests;
+    }
+    ASSERT_EQ(EPOCHS, passedtests);
+}
+
+TEST_F(ximgproc_ED, ManySmallCircles)
+{
+    string picture_name = "cv/imgproc/beads.jpg";
+
+    string filename = cvtest::TS::ptr()->get_data_path() + picture_name;
+    test_image = imread(filename, IMREAD_GRAYSCALE);
+    EXPECT_FALSE(test_image.empty()) << "Invalid test image: " << filename;
+
+    vector<Vec6d> ellipses;
+    detector->detectEdges(test_image);
+    detector->detectEllipses(ellipses);
+    detector->detectLines(lines);
+
+    size_t segments_size = 6458;
+    size_t lines_size = 6264;
+    size_t ellipses_size = 2449;
+    EXPECT_EQ(detector->getSegments().size(), segments_size);
+    EXPECT_GE(lines.size(), lines_size);
+    EXPECT_LE(lines.size(), lines_size + 2);
+    EXPECT_EQ(ellipses.size(), ellipses_size);
+}
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fourier_descriptors.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fourier_descriptors.cpp
new file mode 100644
index 00000000..d13a8969
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_fourier_descriptors.cpp
@@ -0,0 +1,90 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+
+TEST(ximgproc_fourierdescriptors,test_FD_AND_FIT)
+{
+    Mat fd;
+    vector<Point2f> ctr(16);
+    float Rx = 100, Ry = 100;
+    Point2f g(0, 0);
+    float angleOri = 0;
+    for (int i = 0; i < static_cast<int>(ctr.size()); i++)
+    {
+        float theta = static_cast<float>(2 * CV_PI / static_cast<int>(ctr.size()) * i + angleOri);
+        ctr[i] = Point2f(Rx * cos(theta) + g.x, Ry * sin(theta) + g.y);
+
+    }
+    ximgproc::fourierDescriptor(ctr, fd);
+    CV_Assert(cv::norm(fd.at<Vec2f>(0, 0)) < ctr.size() * FLT_EPSILON && cv::norm(fd.at<Vec2f>(0, 1) - Vec2f(Rx, 0)) < ctr.size() * FLT_EPSILON);
+    Rx = 100, Ry = 50;
+    g = Point2f(50, 20);
+    for (int i = 0; i < static_cast<int>(ctr.size()); i++)
+    {
+        float theta = static_cast<float>(2 * CV_PI / static_cast<int>(ctr.size()) * i + angleOri);
+        ctr[i] = Point2f(Rx * cos(theta) + g.x, Ry * sin(theta) + g.y);
+    }
+    ximgproc::fourierDescriptor(ctr, fd);
+    CV_Assert(cv::norm(fd.at<Vec2f>(0, 0) - Vec2f(g)) < 1 &&
+        fabs(fd.at<Vec2f>(0, 1)[0] + fd.at<Vec2f>(0, static_cast<int>(ctr.size()) - 1)[0] - Rx) < 1 &&
+        fabs(fd.at<Vec2f>(0, 1)[0] - fd.at<Vec2f>(0, static_cast<int>(ctr.size()) - 1)[0] - Ry) < 1);
+    Rx = 70, Ry = 100;
+    g = Point2f(30, 100);
+    angleOri = static_cast<float>(CV_PI / 4);
+    for (int i = 0; i < static_cast<int>(ctr.size()); i++)
+    {
+        float theta = static_cast<float>(2 * CV_PI / static_cast<int>(ctr.size()) * i + CV_PI / 4);
+        ctr[i] = Point2f(Rx * cos(theta) + g.x, Ry * sin(theta) + g.y);
+    }
+    ximgproc::fourierDescriptor(ctr, fd);
+    CV_Assert(cv::norm(fd.at<Vec2f>(0, 0) - Vec2f(g)) < 1);
+    CV_Assert(cv::norm(Vec2f((Rx + Ry)*cos(angleOri) / 2, (Rx + Ry)*sin(angleOri) / 2) - fd.at<Vec2f>(0, 1)) < 1);
+    CV_Assert(cv::norm(Vec2f((Rx - Ry)*cos(angleOri) / 2, -(Rx - Ry)*sin(angleOri) / 2) - fd.at<Vec2f>(0, static_cast<int>(ctr.size()) - 1)) < 1);
+
+    RNG rAlea;
+    g.x = 0; g.y = 0;
+    ctr.resize(256);
+    for (int i = 0; i < static_cast<int>(ctr.size()); i++)
+    {
+        ctr[i] = Point2f(rAlea.uniform(0.0F, 1.0F), rAlea.uniform(0.0F, 1.0F));
+        g += ctr[i];
+    }
+    g.x = g.x / ctr.size();
+    g.y = g.y / ctr.size();
+    double rotAngle = 35;
+    double s = 0.1515;
+    Mat r = getRotationMatrix2D(g, rotAngle, 0.1515);
+    vector<Point2f> unknownCtr;
+    vector<Point2f> ctrShift;
+    int valShift = 170;
+    for (int i = 0; i < static_cast<int>(ctr.size()); i++)
+        ctrShift.push_back(ctr[(i + valShift) % ctr.size()]);
+    cv::transform(ctrShift, unknownCtr, r);
+    ximgproc::ContourFitting fit;
+    fit.setFDSize(16);
+    Mat t;
+    double dist;
+    fit.estimateTransformation(unknownCtr, ctr, t, &dist, false);
+    CV_Assert(fabs(t.at<double>(0, 0)*ctr.size() + valShift) < 10 || fabs((1 - t.at<double>(0, 0))*ctr.size() - valShift) < 10);
+    CV_Assert(fabs(t.at<double>(0, 1) - rotAngle / 180.*CV_PI) < 0.1);
+    CV_Assert(fabs(t.at<double>(0, 2) - 1 / s) < 0.1);
+    ctr.resize(4);
+    ctr[0] = Point2f(0, 0);
+    ctr[1] = Point2f(16, 0);
+    ctr[2] = Point2f(16, 16);
+    ctr[3] = Point2f(0, 16);
+    double squareArea = contourArea(ctr), lengthSquare = arcLength(ctr, true);
+    Mat ctrs;
+    ximgproc::contourSampling(ctr, ctrs, 64);
+    CV_Assert(fabs(squareArea - contourArea(ctrs)) < FLT_EPSILON);
+    CV_Assert(fabs(lengthSquare - arcLength(ctrs, true)) < FLT_EPSILON);
+}
+
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_guided_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_guided_filter.cpp
new file mode 100644
index 00000000..b8293da6
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_guided_filter.cpp
@@ -0,0 +1,402 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+#ifndef SQR
+#define SQR(x) ((x)*(x))
+#endif
+
+static string getOpenCVExtraDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+static Mat convertTypeAndSize(Mat src, int dstType, Size dstSize)
+{
+    Mat dst;
+    int srcCnNum = src.channels();
+    int dstCnNum = CV_MAT_CN(dstType);
+    CV_Assert(srcCnNum == 3);
+
+    if (srcCnNum == dstCnNum)
+    {
+        src.copyTo(dst);
+    }
+    else if (dstCnNum == 1 && srcCnNum == 3)
+    {
+        cvtColor(src, dst, COLOR_BGR2GRAY);
+    }
+    else if (dstCnNum == 1 && srcCnNum == 4)
+    {
+        cvtColor(src, dst, COLOR_BGRA2GRAY);
+    }
+    else
+    {
+        vector<Mat> srcCn;
+        split(src, srcCn);
+        srcCn.resize(dstCnNum);
+
+        uint64 seed = 10000 * src.rows + 1000 * src.cols + 100 * dstSize.height + 10 * dstSize.width + dstType;
+        RNG rnd(seed);
+
+        for (int i = srcCnNum; i < dstCnNum; i++)
+        {
+            Mat& donor = srcCn[i % srcCnNum];
+
+            double minVal, maxVal;
+            minMaxLoc(donor, &minVal, &maxVal);
+
+            Mat randItem(src.size(), CV_MAKE_TYPE(src.depth(), 1));
+            randn(randItem, 0, (maxVal - minVal) / 100);
+
+            cv::add(donor, randItem, srcCn[i]);  // TODO cvtest
+        }
+
+        merge(srcCn, dst);
+    }
+
+    dst.convertTo(dst, dstType);
+    resize(dst, dst, dstSize, 0, 0, INTER_LINEAR_EXACT);
+
+    return dst;
+}
+
+class GuidedFilterRefImpl : public GuidedFilter
+{
+    int height, width, rad, chNum;
+    Mat det;
+    Mat *channels, *exps, **vars, **A;
+    double eps;
+
+    void meanFilter(const Mat &src, Mat & dst);
+
+    void computeCovGuide();
+
+    void computeCovGuideInv();
+
+    void applyTransform(int cNum, Mat *Ichannels, Mat *beta, Mat **alpha, int dDepth);
+
+    void computeCovGuideAndSrc(int cNum, Mat **vars_I, Mat *Ichannels, Mat *exp_I);
+
+    void computeBeta(int cNum, Mat *beta, Mat *exp_I, Mat **alpha);
+
+    void computeAlpha(int cNum, Mat **alpha, Mat **vars_I);
+
+public:
+
+    GuidedFilterRefImpl(InputArray guide_, int rad, double eps);
+
+    void filter(InputArray src, OutputArray dst, int dDepth = -1);
+
+    ~GuidedFilterRefImpl();
+};
+
+void GuidedFilterRefImpl::meanFilter(const Mat &src, Mat & dst)
+{
+    boxFilter(src, dst, CV_32F, Size(2 * rad + 1, 2 * rad + 1), Point(-1, -1), true, BORDER_REFLECT);
+}
+
+GuidedFilterRefImpl::GuidedFilterRefImpl(InputArray _guide, int _rad, double _eps) :
+  height(_guide.rows()), width(_guide.cols()), rad(_rad), chNum(_guide.channels()), eps(_eps)
+{
+    Mat guide = _guide.getMat();
+    CV_Assert(chNum > 0 && chNum <= 3);
+
+    channels = new Mat[chNum];
+    exps     = new Mat[chNum];
+
+    A    = new Mat *[chNum];
+    vars = new Mat *[chNum];
+    for (int i = 0; i < chNum; ++i)
+    {
+        A[i]    = new Mat[chNum];
+        vars[i] = new Mat[chNum];
+    }
+
+    split(guide, channels);
+    for (int i = 0; i < chNum; ++i)
+    {
+        channels[i].convertTo(channels[i], CV_32F);
+        meanFilter(channels[i], exps[i]);
+    }
+
+    computeCovGuide();
+
+    computeCovGuideInv();
+}
+
+void GuidedFilterRefImpl::computeCovGuide()
+{
+    static const int pY[] = { 0, 0, 1, 0, 1, 2 };
+    static const int pX[] = { 0, 1, 1, 2, 2, 2 };
+
+    int numOfIterations = (SQR(chNum) - chNum) / 2 + chNum;
+    for (int k = 0; k < numOfIterations; ++k)
+    {
+        int i = pY[k], j = pX[k];
+
+        vars[i][j] = channels[i].mul(channels[j]);
+        meanFilter(vars[i][j], vars[i][j]);
+        vars[i][j] -= exps[i].mul(exps[j]);
+
+        if (i == j)
+            vars[i][j] += eps * Mat::ones(height, width, CV_32F);
+        else
+            vars[j][i] = vars[i][j];
+    }
+}
+
+void GuidedFilterRefImpl::computeCovGuideInv()
+{
+    static const int pY[] = { 0, 0, 1, 0, 1, 2 };
+    static const int pX[] = { 0, 1, 1, 2, 2, 2 };
+
+    int numOfIterations = (SQR(chNum) - chNum) / 2 + chNum;
+    if (chNum == 3)
+    {
+        for (int k = 0; k < numOfIterations; ++k){
+            int i = pY[k], i1 = (pY[k] + 1) % 3, i2 = (pY[k] + 2) % 3;
+            int j = pX[k], j1 = (pX[k] + 1) % 3, j2 = (pX[k] + 2) % 3;
+
+            A[i][j] = vars[i1][j1].mul(vars[i2][j2])
+                - vars[i1][j2].mul(vars[i2][j1]);
+        }
+    }
+    else if (chNum == 2)
+    {
+        A[0][0] = vars[1][1];
+        A[1][1] = vars[0][0];
+        A[0][1] = -vars[0][1];
+    }
+    else if (chNum == 1)
+        A[0][0] = Mat::ones(height, width, CV_32F);
+
+    for (int i = 0; i < chNum; ++i)
+        for (int j = 0; j < i; ++j)
+            A[i][j] = A[j][i];
+
+    det = vars[0][0].mul(A[0][0]);
+    for (int k = 0; k < chNum - 1; ++k)
+        det += vars[0][k + 1].mul(A[0][k + 1]);
+}
+
+GuidedFilterRefImpl::~GuidedFilterRefImpl(){
+    delete [] channels;
+    delete [] exps;
+
+    for (int i = 0; i < chNum; ++i)
+    {
+        delete [] A[i];
+        delete [] vars[i];
+    }
+
+    delete [] A;
+    delete [] vars;
+}
+
+void GuidedFilterRefImpl::filter(InputArray src_, OutputArray dst_, int dDepth)
+{
+    if (dDepth == -1) dDepth = src_.depth();
+    dst_.create(height, width, src_.type());
+    Mat src = src_.getMat();
+    Mat dst = dst_.getMat();
+    int cNum = src.channels();
+
+    CV_Assert(height == src.rows && width == src.cols);
+
+    Mat *Ichannels, *exp_I, **vars_I, **alpha, *beta;
+    Ichannels = new Mat[cNum];
+    exp_I     = new Mat[cNum];
+    beta      = new Mat[cNum];
+
+    vars_I = new Mat *[chNum];
+    alpha  = new Mat *[chNum];
+    for (int i = 0; i < chNum; ++i){
+        vars_I[i] = new Mat[cNum];
+        alpha[i]  = new Mat[cNum];
+    }
+
+    split(src, Ichannels);
+    for (int i = 0; i < cNum; ++i)
+    {
+        Ichannels[i].convertTo(Ichannels[i], CV_32F);
+        meanFilter(Ichannels[i], exp_I[i]);
+    }
+
+    computeCovGuideAndSrc(cNum, vars_I, Ichannels, exp_I);
+
+    computeAlpha(cNum, alpha, vars_I);
+
+    computeBeta(cNum, beta, exp_I, alpha);
+
+    for (int i = 0; i < chNum + 1; ++i)
+        for (int j = 0; j < cNum; ++j)
+            if (i < chNum)
+                meanFilter(alpha[i][j], alpha[i][j]);
+            else
+                meanFilter(beta[j], beta[j]);
+
+    applyTransform(cNum, Ichannels, beta, alpha, dDepth);
+    merge(Ichannels, cNum, dst);
+
+    delete [] Ichannels;
+    delete [] exp_I;
+    delete [] beta;
+
+    for (int i = 0; i < chNum; ++i)
+    {
+        delete [] vars_I[i];
+        delete [] alpha[i];
+    }
+    delete [] vars_I;
+    delete [] alpha;
+}
+
+void GuidedFilterRefImpl::computeAlpha(int cNum, Mat **alpha, Mat **vars_I)
+{
+    for (int i = 0; i < chNum; ++i)
+        for (int j = 0; j < cNum; ++j)
+        {
+            alpha[i][j] = vars_I[0][j].mul(A[i][0]);
+            for (int k = 1; k < chNum; ++k)
+                alpha[i][j] += vars_I[k][j].mul(A[i][k]);
+            alpha[i][j] /= det;
+        }
+}
+
+void GuidedFilterRefImpl::computeBeta(int cNum, Mat *beta, Mat *exp_I, Mat **alpha)
+{
+    for (int i = 0; i < cNum; ++i)
+    {
+        beta[i] = exp_I[i];
+        for (int j = 0; j < chNum; ++j)
+            beta[i] -= alpha[j][i].mul(exps[j]);
+    }
+}
+
+void GuidedFilterRefImpl::computeCovGuideAndSrc(int cNum, Mat **vars_I, Mat *Ichannels, Mat *exp_I)
+{
+    for (int i = 0; i < chNum; ++i)
+        for (int j = 0; j < cNum; ++j)
+        {
+            vars_I[i][j] = channels[i].mul(Ichannels[j]);
+            meanFilter(vars_I[i][j], vars_I[i][j]);
+            vars_I[i][j] -= exp_I[j].mul(exps[i]);
+        }
+}
+
+void GuidedFilterRefImpl::applyTransform(int cNum, Mat *Ichannels, Mat *beta, Mat **alpha, int dDepth)
+{
+    for (int i = 0; i < cNum; ++i)
+    {
+        Ichannels[i] = beta[i];
+        for (int j = 0; j < chNum; ++j)
+            Ichannels[i] += alpha[j][i].mul(channels[j]);
+        Ichannels[i].convertTo(Ichannels[i], dDepth);
+    }
+}
+
+typedef tuple<int, string, string> GFParams;
+typedef TestWithParam<GFParams> GuidedFilterTest;
+
+TEST_P(GuidedFilterTest, accuracy)
+{
+    GFParams params = GetParam();
+
+    int guideCnNum = 3;
+    int srcCnNum = get<0>(params);
+
+    string guideFileName = get<1>(params);
+    string srcFileName = get<2>(params);
+
+    int seed = 100 * guideCnNum + 50 * srcCnNum + 5*(int)guideFileName.length() + (int)srcFileName.length();
+    RNG rng(seed);
+
+    Mat guide = imread(getOpenCVExtraDir() + guideFileName);
+    Mat src = imread(getOpenCVExtraDir() + srcFileName);
+    ASSERT_TRUE(!guide.empty() && !src.empty());
+
+    Size dstSize(guide.cols + 1 + rng.uniform(0, 3), guide.rows);
+
+    guide = convertTypeAndSize(guide, CV_MAKE_TYPE(guide.depth(), guideCnNum), dstSize);
+    src = convertTypeAndSize(src, CV_MAKE_TYPE(src.depth(), srcCnNum), dstSize);
+
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
+    for (int iter = 0; iter < 2; iter++)
+    {
+        int radius = rng.uniform(0, 50);
+        double eps = rng.uniform(0.0, SQR(255.0));
+
+        cv::setNumThreads(nThreads);
+        Mat res;
+        Ptr<GuidedFilter> gf = createGuidedFilter(guide, radius, eps);
+        gf->filter(src, res);
+
+        cv::setNumThreads(1);
+        Mat resRef;
+        Ptr<GuidedFilter> gfRef(new GuidedFilterRefImpl(guide, radius, eps));
+        gfRef->filter(src, resRef);
+
+        double normInf = cv::norm(res, resRef, NORM_INF);
+        double normL2 = cv::norm(res, resRef, NORM_L2) / guide.total();
+
+        EXPECT_LE(normInf, 1.0);
+        EXPECT_LE(normL2, 1.0/64.0);
+    }
+}
+
+TEST_P(GuidedFilterTest, smallParamsIssue)
+{
+    GFParams params = GetParam();
+    string guideFileName = get<1>(params);
+    string srcFileName = get<2>(params);
+    int guideCnNum = 3;
+    int srcCnNum = get<0>(params);
+
+    Mat guide = imread(getOpenCVExtraDir() + guideFileName);
+    Mat src = imread(getOpenCVExtraDir() + srcFileName);
+    ASSERT_TRUE(!guide.empty() && !src.empty());
+
+    Size dstSize(guide.cols, guide.rows);
+    guide = convertTypeAndSize(guide, CV_MAKE_TYPE(guide.depth(), guideCnNum), dstSize);
+    src = convertTypeAndSize(src, CV_MAKE_TYPE(src.depth(), srcCnNum), dstSize);
+    Mat output;
+
+    ximgproc::guidedFilter(guide, src, output, 3, 1e-6);
+
+    size_t whitePixels = 0;
+    for(int i = 0; i < output.cols; i++)
+    {
+        for(int j = 0; j < output.rows; j++)
+        {
+            if(output.channels() == 1)
+            {
+                if(output.ptr<uchar>(i)[j] == 255)
+                    whitePixels++;
+            }
+            else if(output.channels() == 3)
+            {
+                Vec3b currentPixel = output.ptr<Vec3b>(i)[j];
+                if(currentPixel == Vec3b(255, 255, 255))
+                    whitePixels++;
+            }
+        }
+    }
+    double whiteRate = whitePixels / (double) output.total();
+    EXPECT_LE(whiteRate, 0.1);
+}
+
+INSTANTIATE_TEST_CASE_P(TypicalSet, GuidedFilterTest,
+    Combine(
+    Values(1, 3),
+    Values("cv/shared/lena.png", "cv/shared/baboon.png"),
+    Values("cv/shared/lena.png", "cv/shared/baboon.png")
+));
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_joint_bilateral_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_joint_bilateral_filter.cpp
new file mode 100644
index 00000000..773bed78
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_joint_bilateral_filter.cpp
@@ -0,0 +1,244 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static std::string getOpenCVExtraDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+static void checkSimilarity(InputArray src, InputArray ref)
+{
+    double normInf = cvtest::norm(src, ref, NORM_INF);
+    double normL2 = cvtest::norm(src, ref, NORM_L2) / (src.total()*src.channels());
+
+    EXPECT_LE(normInf, 1.0);
+    EXPECT_LE(normL2, 1.0 / 16);
+}
+
+static Mat convertTypeAndSize(Mat src, int dstType, Size dstSize)
+{
+    Mat dst;
+    int srcCnNum = src.channels();
+    int dstCnNum = CV_MAT_CN(dstType);
+
+    if (srcCnNum == dstCnNum)
+    {
+        src.copyTo(dst);
+    }
+    else if (srcCnNum == 3 && dstCnNum == 1)
+    {
+        cvtColor(src, dst, COLOR_BGR2GRAY);
+    }
+    else if (srcCnNum == 1 && dstCnNum == 3)
+    {
+        cvtColor(src, dst, COLOR_GRAY2BGR);
+    }
+    else
+    {
+        CV_Error(Error::BadNumChannels, "Bad num channels in src");
+    }
+
+    dst.convertTo(dst, dstType);
+    resize(dst, dst, dstSize, 0, 0, INTER_LINEAR_EXACT);
+
+    return dst;
+}
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+void jointBilateralFilterNaive(InputArray joint, InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType = BORDER_DEFAULT);
+
+typedef Vec<float, 1> Vec1f;
+typedef Vec<uchar, 1> Vec1b;
+
+#ifndef SQR
+#define SQR(a) ((a)*(a))
+#endif
+
+template<typename T, int cn>
+float normL1Sqr(const Vec<T, cn>& a, const Vec<T, cn>& b)
+{
+    float res = 0.0f;
+    for (int i = 0; i < cn; i++)
+        res += std::abs((float)a[i] - (float)b[i]);
+    return res*res;
+}
+
+template<typename JointVec, typename SrcVec>
+void jointBilateralFilterNaive_(InputArray joint_, InputArray src_, OutputArray dst_, int d, double sigmaColor, double sigmaSpace, int borderType)
+{
+    CV_Assert(joint_.size() == src_.size());
+    CV_Assert(joint_.type() == traits::Type<JointVec>::value && src_.type() == traits::Type<SrcVec>::value);
+    typedef Vec<float, SrcVec::channels> SrcVecf;
+
+    if (sigmaColor <= 0)
+        sigmaColor = 1;
+    if (sigmaSpace <= 0)
+        sigmaSpace = 1;
+
+    int radius;
+    if (d <= 0)
+        radius = cvRound(sigmaSpace*1.5);
+    else
+        radius = d / 2;
+    radius = std::max(radius, 1);
+    d = 2 * radius + 1;
+
+    dst_.create(src_.size(), src_.type());
+    Mat_<SrcVec> dst = dst_.getMat();
+    Mat_<JointVec> jointExt;
+    Mat_<SrcVec> srcExt;
+    cv::copyMakeBorder(src_, srcExt, radius, radius, radius, radius, borderType);  // TODO cvtest
+    cv::copyMakeBorder(joint_, jointExt, radius, radius, radius, radius, borderType);  // TODO cvtest
+
+    float colorGaussCoef = (float)(-0.5 / (sigmaColor*sigmaColor));
+    float spaceGaussCoef = (float)(-0.5 / (sigmaSpace*sigmaSpace));
+
+    for (int i = radius; i < srcExt.rows - radius; i++)
+    {
+        for (int j = radius; j < srcExt.cols - radius; j++)
+        {
+            JointVec joint0 = jointExt(i, j);
+            SrcVecf sum = SrcVecf::all(0.0f);
+            float sumWeights = 0.0f;
+
+            for (int k = -radius; k <= radius; k++)
+            {
+                for (int l = -radius; l <= radius; l++)
+                {
+                    float spatDistSqr = (float)(k*k + l*l);
+                    if (spatDistSqr > SQR(radius)) continue;
+
+                    float colorDistSqr = normL1Sqr(joint0, jointExt(i + k, j + l));
+
+                    float weight = std::exp(spatDistSqr*spaceGaussCoef + colorDistSqr*colorGaussCoef);
+
+                    sum += weight*SrcVecf(srcExt(i + k, j + l));
+                    sumWeights += weight;
+                }
+            }
+
+            dst(i - radius, j - radius) = sum / sumWeights;
+        }
+    }
+}
+
+void jointBilateralFilterNaive(InputArray joint, InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType)
+{
+    CV_Assert(src.size() == joint.size() && src.depth() == joint.depth());
+    CV_Assert(src.type() == CV_32FC1 || src.type() == CV_32FC3 || src.type() == CV_8UC1 || src.type() == CV_8UC3);
+    CV_Assert(joint.type() == CV_32FC1 || joint.type() == CV_32FC3 || joint.type() == CV_8UC1 || joint.type() == CV_8UC3);
+
+    int jointType = joint.type();
+    int srcType = src.type();
+
+    #define JBF_naive(VecJoint, VecSrc) jointBilateralFilterNaive_<VecJoint, VecSrc>(joint, src, dst, d, sigmaColor, sigmaSpace, borderType);
+    if (jointType == CV_8UC1)
+    {
+        if (srcType == CV_8UC1)  JBF_naive(Vec1b, Vec1b);
+        if (srcType == CV_8UC3)  JBF_naive(Vec1b, Vec3b);
+    }
+    if (jointType == CV_8UC3)
+    {
+        if (srcType == CV_8UC1)  JBF_naive(Vec3b, Vec1b);
+        if (srcType == CV_8UC3)  JBF_naive(Vec3b, Vec3b);
+    }
+    if (jointType == CV_32FC1)
+    {
+        if (srcType == CV_32FC1) JBF_naive(Vec1f, Vec1f);
+        if (srcType == CV_32FC3) JBF_naive(Vec1f, Vec3f);
+    }
+    if (jointType == CV_32FC3)
+    {
+        if (srcType == CV_32FC1) JBF_naive(Vec3f, Vec1f);
+        if (srcType == CV_32FC3) JBF_naive(Vec3f, Vec3f);
+    }
+    #undef JBF_naive
+}
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+typedef tuple<string, string> JBFTestParam;
+typedef TestWithParam<JBFTestParam> JointBilateralFilterTest_NaiveRef;
+
+TEST_P(JointBilateralFilterTest_NaiveRef, Accuracy)
+{
+    JBFTestParam param = GetParam();
+    double sigmaS       = 8.0;
+    string jointPath    = get<0>(param);
+    string srcPath      = get<1>(param);
+    int depth           = CV_8U;
+    int jCn             = 3;
+    int srcCn           = 1;
+    int jointType       = CV_MAKE_TYPE(depth, jCn);
+    int srcType         = CV_MAKE_TYPE(depth, srcCn);
+
+    Mat joint = imread(getOpenCVExtraDir() + jointPath);
+    Mat src = imread(getOpenCVExtraDir() + srcPath);
+    ASSERT_TRUE(!joint.empty() && !src.empty());
+
+    joint = convertTypeAndSize(joint, jointType, joint.size());
+    src = convertTypeAndSize(src, srcType, joint.size());
+
+    RNG rnd(cvRound(10*sigmaS) + jointType + srcType + jointPath.length() + srcPath.length() + joint.rows + joint.cols);
+    double sigmaC = rnd.uniform(0, 255);
+
+    Mat resNaive;
+    jointBilateralFilterNaive(joint, src, resNaive, 0, sigmaC, sigmaS);
+
+    Mat res;
+    jointBilateralFilter(joint, src, res, 0, sigmaC, sigmaS);
+
+    checkSimilarity(res, resNaive);
+}
+
+INSTANTIATE_TEST_CASE_P(Set2, JointBilateralFilterTest_NaiveRef,
+    Combine(
+    Values("/cv/shared/airplane.png", "/cv/shared/fruits.png"),
+    Values("/cv/shared/airplane.png", "/cv/shared/fruits.png"))
+);
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+typedef tuple<string, int> BFTestParam;
+typedef TestWithParam<BFTestParam> JointBilateralFilterTest_BilateralRef;
+
+TEST_P(JointBilateralFilterTest_BilateralRef, Accuracy)
+{
+    BFTestParam param   = GetParam();
+    double sigmaS       = 4.0;
+    string srcPath      = get<0>(param);
+    int srcType         = get<1>(param);
+
+    Mat src = imread(getOpenCVExtraDir() + srcPath);
+    ASSERT_TRUE(!src.empty());
+    src = convertTypeAndSize(src, srcType, src.size());
+
+    RNG rnd(cvRound(10*sigmaS) + srcPath.length() + srcType + src.rows);
+    double sigmaC = rnd.uniform(0.0, 255.0);
+
+    Mat resRef;
+    bilateralFilter(src, resRef, 0, sigmaC, sigmaS);
+
+    Mat res, joint = src.clone();
+    jointBilateralFilter(joint, src, res, 0, sigmaC, sigmaS);
+
+    checkSimilarity(res, resRef);
+}
+
+INSTANTIATE_TEST_CASE_P(Set1, JointBilateralFilterTest_BilateralRef,
+    Combine(
+    Values("/cv/shared/lena.png", "cv/shared/box_in_scene.png"),
+    Values(CV_8UC3, CV_32FC1)
+    )
+);
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_l0_smooth.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_l0_smooth.cpp
new file mode 100644
index 00000000..fd9ffd26
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_l0_smooth.cpp
@@ -0,0 +1,83 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+CV_ENUM(SrcTypes, CV_8UC1, CV_8UC3, CV_16UC1, CV_16UC3);
+typedef tuple<Size, SrcTypes> L0SmoothParams;
+typedef TestWithParam<L0SmoothParams> L0SmoothTest;
+
+TEST(L0SmoothTest, SplatSurfaceAccuracy)
+{
+    RNG rnd(0);
+
+    for (int i = 0; i < 3; i++)
+    {
+        Size sz(rnd.uniform(512, 1024), rnd.uniform(512, 1024));
+
+        Scalar surfaceValue;
+        int srcCn = 3;
+        rnd.fill(surfaceValue, RNG::UNIFORM, 0, 255);
+        Mat src(sz, CV_MAKE_TYPE(CV_8U, srcCn), surfaceValue);
+
+        double lambda = rnd.uniform(0.01, 0.05);
+        double kappa  = rnd.uniform(1.5, 5.0);
+
+        Mat res;
+        l0Smooth(src, res, lambda, kappa);
+
+        // When filtering a constant image we should get the same image:
+        double normL1 = cvtest::norm(src, res, NORM_L1)/src.total()/src.channels();
+        EXPECT_LE(normL1, 1.0/64);
+    }
+}
+
+TEST_P(L0SmoothTest, MultiThreadReproducibility)
+{
+    if (cv::getNumberOfCPUs() == 1)
+        return;
+
+    double MAX_DIF = 10.0;
+    double MAX_MEAN_DIF = 1.0 / 8.0;
+    int loopsCount = 2;
+    RNG rng(0);
+
+    L0SmoothParams params = GetParam();
+    Size size     = get<0>(params);
+    int srcType   = get<1>(params);
+
+    Mat src(size,srcType);
+    if(src.depth()==CV_8U)
+        randu(src, 0, 255);
+    else if(src.depth()==CV_16U)
+        randu(src, 0, 65535);
+    else
+        randu(src, -100000.0f, 100000.0f);
+
+
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
+    for (int iter = 0; iter <= loopsCount; iter++)
+    {
+        double lambda = rng.uniform(0.01, 0.05);
+        double kappa  = rng.uniform(1.5, 5.0);
+
+        cv::setNumThreads(nThreads);
+        Mat resMultiThread;
+        l0Smooth(src, resMultiThread, lambda, kappa);
+
+        cv::setNumThreads(1);
+        Mat resSingleThread;
+        l0Smooth(src, resSingleThread, lambda, kappa);
+
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_INF), MAX_DIF);
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_L1), MAX_MEAN_DIF*src.total()*src.channels());
+    }
+}
+INSTANTIATE_TEST_CASE_P(FullSet, L0SmoothTest,Combine(Values(szODD, szQVGA), SrcTypes::all()));
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_main.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_main.cpp
new file mode 100644
index 00000000..a6fc332d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_main.cpp
@@ -0,0 +1,6 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("")
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_matchcolortemplate.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_matchcolortemplate.cpp
new file mode 100644
index 00000000..c4aeaf80
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_matchcolortemplate.cpp
@@ -0,0 +1,81 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+
+TEST(ximgproc_matchcolortemplate,test_QFFT)
+{
+    String openCVExtraDir = cvtest::TS::ptr()->get_data_path();
+    String dataPath = openCVExtraDir;
+#ifdef GENERATE_TESTDATA
+    FileStorage fs;
+    dataPath += "cv/ximgproc/sources/07.png";
+    Mat imgTest = imread(dataPath, IMREAD_COLOR);
+    resize(imgTest, imgTest, Size(), 0.0625, 0.0625);
+    Mat qimgTest, qdftimgTest;
+    ximgproc::createQuaternionImage(imgTest, qimgTest);
+    ximgproc::qdft(qimgTest, qdftimgTest, 0, true);
+    fs.open(openCVExtraDir + "cv/ximgproc/qdftData.yml.gz", FileStorage::WRITE);
+    fs << "image" << imgTest;
+    fs << "qdftleft" << qdftimgTest;
+    ximgproc::qdft(qimgTest, qdftimgTest, 0, false);
+    fs << "qdftright" << qdftimgTest;
+    ximgproc::qdft(qimgTest, qdftimgTest, DFT_INVERSE, true);
+    fs << "qidftleft" << qdftimgTest;
+    ximgproc::qdft(qimgTest, qdftimgTest, DFT_INVERSE, false);
+    fs << "qidftright" << qdftimgTest;
+    fs.release();
+#endif
+    dataPath = openCVExtraDir + "cv/ximgproc/qdftData.yml.gz";
+    FileStorage f;
+    f.open(dataPath, FileStorage::READ);
+    Mat img;
+    f["image"] >> img;
+    Mat qTest;
+    vector<String> nodeName = { "qdftleft","qdftright","qidftleft","qidftright" };
+    vector<int> flag = { 0,0,DFT_INVERSE,DFT_INVERSE };
+    vector<bool> leftSize = {true,false,true,false};
+    ximgproc::createQuaternionImage(img, img);
+    for (int i=0;i<static_cast<int>(nodeName.size());i++)
+    {
+        Mat test, dd;
+        f[nodeName[i]] >> qTest;
+        ximgproc::qdft(img, test, flag[i], leftSize[i]);
+        absdiff(test, qTest, dd);
+        vector<Mat> plane;
+        split(dd, plane);
+        for (auto p : plane)
+        {
+            double maxVal;
+            Point pIdx;
+            minMaxLoc(p, NULL, &maxVal, NULL, &pIdx);
+            ASSERT_LE(p.at<double>(pIdx), 1e-5);
+        }
+    }
+}
+
+TEST(ximgproc_matchcolortemplate, test_COLORMATCHTEMPLATE)
+{
+    String openCVExtraDir = cvtest::TS::ptr()->get_data_path();
+    String dataPath = openCVExtraDir + "cv/ximgproc/corr.yml.gz";
+    Mat img, logo;
+    Mat corrRef,corr;
+    img = imread(openCVExtraDir + "cv/ximgproc/image.png", IMREAD_COLOR);
+    logo = imread(openCVExtraDir + "cv/ximgproc/opencv_logo.png", IMREAD_COLOR);
+    ximgproc::colorMatchTemplate(img, logo, corr);
+#ifdef GENERATE_TESTDATA
+    FileStorage fs;
+    fs.open(dataPath, FileStorage::WRITE);
+    fs << "corr" << imgcorr;
+    fs.release();
+#endif
+    FileStorage f;
+    f.open(dataPath, FileStorage::READ);
+    f["corr"] >> corrRef;
+    EXPECT_LE(cv::norm(corr, corrRef, NORM_INF), 1e-5);
+}
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_niblack_threshold.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_niblack_threshold.cpp
new file mode 100644
index 00000000..7b463ea3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_niblack_threshold.cpp
@@ -0,0 +1,29 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ximgproc_niBlackThreshold, sauvola)
+{
+    Mat src = (Mat_<uchar>(3, 3) << 1, 1, 1, 2, 2, 2, 3, 3, 3);
+    Mat dst;
+    cv::ximgproc::niBlackThreshold(src, dst, 255, THRESH_BINARY, 3, 1, BINARIZATION_SAUVOLA, 1);
+
+    EXPECT_EQ(CV_8U, dst.type());
+    EXPECT_EQ(3, dst.rows);
+    EXPECT_EQ(3, dst.cols);
+
+    EXPECT_EQ(0, dst.at<uchar>(0, 0));
+    EXPECT_EQ(0, dst.at<uchar>(0, 1));
+    EXPECT_EQ(0, dst.at<uchar>(0, 2));
+    EXPECT_EQ(0, dst.at<uchar>(1, 0));
+    EXPECT_EQ(0, dst.at<uchar>(1, 1));
+    EXPECT_EQ(0, dst.at<uchar>(1, 2));
+    EXPECT_EQ(255, dst.at<uchar>(2, 0));
+    EXPECT_EQ(255, dst.at<uchar>(2, 1));
+    EXPECT_EQ(255, dst.at<uchar>(2, 2));
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_precomp.hpp
new file mode 100644
index 00000000..1b24cca3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_precomp.hpp
@@ -0,0 +1,19 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ximgproc.hpp"
+#include "opencv2/ts.hpp"
+#include <opencv2/ts/ts_perf.hpp>
+#include <opencv2/core/utility.hpp>
+
+namespace opencv_test {
+using namespace cv::ximgproc;
+using namespace perf; // szODD
+
+Ptr<AdaptiveManifoldFilter> createAMFilterRefImpl(double sigma_s, double sigma_r, bool adjust_outliers);
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_radon_transform.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_radon_transform.cpp
new file mode 100644
index 00000000..f84af99d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_radon_transform.cpp
@@ -0,0 +1,81 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test {namespace {
+
+TEST(RadonTransformTest, output_size)
+{
+    Mat src(Size(256, 256), CV_8U, Scalar(0));
+    circle(src, Point(128, 128), 64, Scalar(255), FILLED);
+    Mat radon;
+    cv::ximgproc::RadonTransform(src, radon);
+
+    EXPECT_EQ(363, radon.rows);
+    EXPECT_EQ(180, radon.cols);
+
+    cv::ximgproc::RadonTransform(src, radon, 1, 0, 180, true);
+
+    EXPECT_EQ(256, radon.rows);
+    EXPECT_EQ(180, radon.cols);
+}
+
+TEST(RadonTransformTest, output_type)
+{
+    Mat src_int(Size(256, 256), CV_8U, Scalar(0));
+    circle(src_int, Point(128, 128), 64, Scalar(255), FILLED);
+    Mat radon, radon_norm;
+    cv::ximgproc::RadonTransform(src_int, radon);
+    cv::ximgproc::RadonTransform(src_int, radon_norm, 1, 0, 180, false, true);
+
+    EXPECT_EQ(CV_32SC1, radon.type());
+    EXPECT_EQ(CV_8U, radon_norm.type());
+
+    Mat src_float(Size(256, 256), CV_32FC1, Scalar(0));
+    Mat src_double(Size(256, 256), CV_32FC1, Scalar(0));
+    cv::ximgproc::RadonTransform(src_float, radon);
+    cv::ximgproc::RadonTransform(src_float, radon_norm, 1, 0, 180, false, true);
+    EXPECT_EQ(CV_64FC1, radon.type());
+    EXPECT_EQ(CV_8U, radon_norm.type());
+    cv::ximgproc::RadonTransform(src_double, radon);
+    EXPECT_EQ(CV_64FC1, radon.type());
+    EXPECT_EQ(CV_8U, radon_norm.type());
+}
+
+TEST(RadonTransformTest, accuracy_by_pixel)
+{
+    Mat src(Size(256, 256), CV_8U, Scalar(0));
+    circle(src, Point(128, 128), 64, Scalar(255), FILLED);
+    Mat radon;
+    cv::ximgproc::RadonTransform(src, radon);
+
+    ASSERT_EQ(CV_32SC1, radon.type());
+
+    EXPECT_EQ(0, radon.at<int>(0, 0));
+
+    EXPECT_LT(18000, radon.at<int>(128, 128));
+    EXPECT_GT(19000, radon.at<int>(128, 128));
+}
+
+TEST(RadonTransformTest, accuracy_uchar)
+{
+    Mat src(Size(10, 10), CV_8UC1, Scalar(1));
+    cv::Mat radon;
+    ximgproc::RadonTransform(src, radon, 45, 0, 180, false, false);
+
+    EXPECT_EQ(100, sum(radon.col(0))[0]);
+}
+
+TEST(RadonTransformTest, accuracy_float)
+{
+    Mat src(Size(10, 10), CV_32FC1, Scalar(1.1));
+    cv::Mat radon;
+    ximgproc::RadonTransform(src, radon, 45, 0, 180, false, false);
+
+    EXPECT_LT(109, sum(radon.col(0))[0]);
+    EXPECT_GT(111, sum(radon.col(0))[0]);
+}
+
+} }
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_ridge_detection_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_ridge_detection_filter.cpp
new file mode 100644
index 00000000..732f424a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_ridge_detection_filter.cpp
@@ -0,0 +1,27 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ximgproc_ridgedetectionfilter, ReferenceAccuracy)
+{
+    String openCVExtraDir = cvtest::TS::ptr()->get_data_path();
+    String srcImgPath = "cv/ximgproc/sources/04.png";
+    String refPath = "cv/ximgproc/results/ridge_filter_test_ref/04.png";
+    Mat src = imread(openCVExtraDir + srcImgPath);
+    Mat ref = imread(openCVExtraDir + refPath, 0);
+    Mat n_ref;
+    ref.convertTo(n_ref, CV_8UC1);
+    Ptr<RidgeDetectionFilter> rdf = RidgeDetectionFilter::create();
+    Mat out;
+    rdf->getRidgeFilteredImage(src, out);
+    Mat out_cmp;
+    out.convertTo(out_cmp, CV_8UC1);
+    EXPECT_LE(cvtest::norm(out, ref, NORM_INF), 0.0f);
+    EXPECT_LE(cvtest::norm(out, ref, NORM_L2 | NORM_RELATIVE), .0f);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_rolling_guidance_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_rolling_guidance_filter.cpp
new file mode 100644
index 00000000..8f329aa1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_rolling_guidance_filter.cpp
@@ -0,0 +1,174 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static std::string getOpenCVExtraDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+static void checkSimilarity(InputArray src, InputArray ref)
+{
+    // Doesn't work with bilateral filter: EXPECT_LE(cvtest::norm(src, ref, NORM_INF), 1.0);
+    EXPECT_LE(cvtest::norm(src, ref, NORM_L2 | NORM_RELATIVE), 1e-3);
+}
+
+static Mat convertTypeAndSize(Mat src, int dstType, Size dstSize)
+{
+    Mat dst;
+    int srcCnNum = src.channels();
+    int dstCnNum = CV_MAT_CN(dstType);
+
+    if (srcCnNum == dstCnNum)
+    {
+        src.copyTo(dst);
+    }
+    else if (srcCnNum == 3 && dstCnNum == 1)
+    {
+        cvtColor(src, dst, COLOR_BGR2GRAY);
+    }
+    else if (srcCnNum == 1 && dstCnNum == 3)
+    {
+        cvtColor(src, dst, COLOR_GRAY2BGR);
+    }
+    else
+    {
+        CV_Error(Error::BadNumChannels, "Bad num channels in src");
+    }
+
+    dst.convertTo(dst, dstType);
+    resize(dst, dst, dstSize, 0, 0, INTER_LINEAR_EXACT);
+
+    return dst;
+}
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+typedef tuple<double, MatType, int> RGFParams;
+typedef TestWithParam<RGFParams> RollingGuidanceFilterTest;
+
+TEST_P(RollingGuidanceFilterTest, SplatSurfaceAccuracy)
+{
+    RGFParams params = GetParam();
+    double sigmaS   = get<0>(params);
+    int depth       = get<1>(params);
+    int srcCn       = get<2>(params);
+
+    RNG rnd(0);
+
+    Size sz(rnd.uniform(512,1024), rnd.uniform(512,1024));
+
+    for (int i = 0; i < 5; i++)
+    {
+        Scalar surfaceValue;
+        rnd.fill(surfaceValue, RNG::UNIFORM, 0, 255);
+        Mat src(sz, CV_MAKE_TYPE(depth, srcCn), surfaceValue);
+
+        double sigmaC = rnd.uniform(1.0, 255.0);
+	int iterNum = int(rnd.uniform(1.0, 5.0));
+
+        Mat res;
+        rollingGuidanceFilter(src, res, -1, sigmaC, sigmaS, iterNum);
+
+        double normL1 = cvtest::norm(src, res, NORM_L1)/src.total()/src.channels();
+        EXPECT_LE(normL1, 1.0/64);
+    }
+}
+
+TEST_P(RollingGuidanceFilterTest, MultiThreadReproducibility)
+{
+    if (cv::getNumberOfCPUs() == 1)
+        return;
+
+    RGFParams params = GetParam();
+    double sigmaS   = get<0>(params);
+    int depth       = get<1>(params);
+    int srcCn       = get<2>(params);
+
+    double MAX_DIF = 1.0;
+    double MAX_MEAN_DIF = 1.0 / 64.0;
+    int loopsCount = 2;
+    RNG rnd(1);
+
+    Size sz(rnd.uniform(512,1024), rnd.uniform(512,1024));
+
+    Mat src(sz,CV_MAKE_TYPE(depth, srcCn));
+    if(src.depth()==CV_8U)
+        randu(src, 0, 255);
+    else if(src.depth()==CV_16S)
+        randu(src, -32767, 32767);
+    else
+        randu(src, -100000.0f, 100000.0f);
+
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
+    for (int iter = 0; iter <= loopsCount; iter++)
+    {
+        int iterNum = int(rnd.uniform(1.0, 5.0));
+        double sigmaC = rnd.uniform(1.0, 255.0);
+
+        cv::setNumThreads(nThreads);
+        Mat resMultiThread;
+        rollingGuidanceFilter(src, resMultiThread, -1, sigmaC, sigmaS, iterNum);
+
+        cv::setNumThreads(1);
+        Mat resSingleThread;
+        rollingGuidanceFilter(src, resSingleThread, -1, sigmaC, sigmaS, iterNum);
+
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_INF), MAX_DIF);
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_L1), MAX_MEAN_DIF*src.total()*src.channels());
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(TypicalSet1, RollingGuidanceFilterTest,
+    Combine(
+    Values(2.0, 5.0),
+    Values(CV_8U, CV_32F),
+    Values(1, 3)
+    )
+);
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+typedef tuple<double, string, int> RGFBFParam;
+typedef TestWithParam<RGFBFParam> RollingGuidanceFilterTest_BilateralRef;
+
+TEST_P(RollingGuidanceFilterTest_BilateralRef, Accuracy)
+{
+    RGFBFParam params = GetParam();
+    double sigmaS       = get<0>(params);
+    string srcPath      = get<1>(params);
+    int srcType         = get<2>(params);
+
+    Mat src = imread(getOpenCVExtraDir() + srcPath);
+    ASSERT_TRUE(!src.empty());
+    src = convertTypeAndSize(src, srcType, src.size());
+
+    RNG rnd(0);
+    double sigmaC = rnd.uniform(0.0, 255.0);
+
+    Mat resRef;
+    bilateralFilter(src, resRef, 0, sigmaC, sigmaS);
+
+    Mat res, joint = src.clone();
+    rollingGuidanceFilter(src, res, 0, sigmaC, sigmaS, 1);
+
+    checkSimilarity(res, resRef);
+}
+
+INSTANTIATE_TEST_CASE_P(TypicalSet2, RollingGuidanceFilterTest_BilateralRef,
+    Combine(
+    Values(4.0, 6.0, 8.0),
+    Values("/cv/shared/pic2.png", "/cv/shared/lena.png", "cv/shared/box_in_scene.png"),
+    Values(CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3)
+    )
+);
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_run_length_morphology.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_run_length_morphology.cpp
new file mode 100644
index 00000000..f4e39f48
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_run_length_morphology.cpp
@@ -0,0 +1,249 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+#include "opencv2/ximgproc/run_length_morphology.hpp"
+#include "opencv2/imgproc.hpp"
+
+namespace opencv_test {
+namespace {
+
+const Size img_size(640, 480);
+const int tile_size(20);
+typedef tuple<cv::MorphTypes, int, int> RLMParams;
+typedef tuple<cv::MorphTypes, int, int, int> RLMSParams;
+
+class RLTestBase
+{
+public:
+    RLTestBase() { }
+
+protected:
+    std::vector<Mat> test_image;
+    std::vector<Mat> test_image_rle;
+
+    void generateCheckerBoard(Mat& image);
+    void generateRandomImage(Mat& image);
+
+    bool areImagesIdentical(Mat& pixelImage, Mat& rleImage);
+    bool arePixelImagesIdentical(Mat& image1, Mat& image2);
+
+    void setUp_impl();
+};
+
+void RLTestBase::generateCheckerBoard(Mat& image)
+{
+    image.create(img_size, CV_8UC1);
+    for (int iy = 0; iy < img_size.height; iy += tile_size)
+    {
+        Range rowRange(iy, std::min(iy + tile_size, img_size.height));
+        for (int ix = 0; ix < img_size.width; ix += tile_size)
+        {
+            Range colRange(ix, std::min(ix + tile_size, img_size.width));
+            Mat tile(image, rowRange, colRange);
+            bool bBright = ((iy + ix) % (2 * tile_size) == 0);
+            tile = (bBright ? Scalar(255) : Scalar(0));
+        }
+    }
+}
+
+void RLTestBase::generateRandomImage(Mat& image)
+{
+    image.create(img_size, CV_8UC1);
+    randu(image, Scalar::all(0), Scalar::all(255));
+}
+
+
+void RLTestBase::setUp_impl()
+{
+    test_image.resize(2);
+    test_image_rle.resize(2);
+    generateCheckerBoard(test_image[0]);
+    rl::threshold(test_image[0], test_image_rle[0], 100.0, THRESH_BINARY);
+
+    cv::Mat theRandom;
+    generateRandomImage(theRandom);
+    double dThreshold = 254.0;
+    cv::threshold(theRandom, test_image[1], dThreshold, 255.0, THRESH_BINARY);
+
+    rl::threshold(theRandom, test_image_rle[1], dThreshold, THRESH_BINARY);
+
+}
+
+bool RLTestBase::areImagesIdentical(Mat& pixelImage, Mat& rleImage)
+{
+    cv::Mat rleConverted;
+    rleConverted = cv::Mat::zeros(pixelImage.rows, pixelImage.cols, CV_8UC1);
+    rl::paint(rleConverted, rleImage, Scalar(255.0));
+    return arePixelImagesIdentical(pixelImage, rleConverted);
+}
+
+bool RLTestBase::arePixelImagesIdentical(Mat& image1, Mat& image2)
+{
+    cv::Mat diff;
+    cv::absdiff(image1, image2, diff);
+    int nDiff = cv::countNonZero(diff);
+    return (nDiff == 0);
+}
+
+
+
+class RL_Identical_Result_Simple : public RLTestBase, public ::testing::TestWithParam<RLMSParams>
+{
+public:
+    RL_Identical_Result_Simple() { }
+protected:
+    virtual void SetUp() { setUp_impl(); }
+};
+
+TEST_P(RL_Identical_Result_Simple, simple)
+{
+    Mat resPix, resRLE;
+    RLMSParams param = GetParam();
+    cv::MorphTypes elementType = get<0>(param);
+    int nSize = get<1>(param);
+    int image = get<2>(param);
+    int op = get<3>(param);
+    Mat element = getStructuringElement(elementType, Size(nSize * 2 + 1, nSize * 2 + 1),
+        Point(nSize, nSize));
+
+
+    morphologyEx(test_image[image], resPix, op, element);
+
+    Mat elementRLE = rl::getStructuringElement(elementType, Size(nSize * 2 + 1, nSize * 2 + 1));
+    rl::morphologyEx(test_image_rle[image], resRLE, op, elementRLE);
+
+    ASSERT_TRUE(areImagesIdentical(resPix, resRLE));
+}
+
+INSTANTIATE_TEST_CASE_P(TypicalSET, RL_Identical_Result_Simple, Combine(Values(MORPH_RECT, MORPH_CROSS, MORPH_ELLIPSE),
+    Values(1, 5, 11), Values(0, 1), Values(MORPH_ERODE, MORPH_DILATE, MORPH_OPEN, MORPH_CLOSE, MORPH_GRADIENT, MORPH_TOPHAT, MORPH_BLACKHAT)));
+
+
+class RL_Identical_Result : public RLTestBase, public ::testing::TestWithParam<RLMParams>
+{
+public:
+    RL_Identical_Result() { }
+protected:
+    virtual void SetUp() { setUp_impl(); }
+};
+
+
+TEST_P(RL_Identical_Result, erosion_no_boundary)
+{
+    Mat resPix, resRLE;
+    RLMParams param = GetParam();
+    cv::MorphTypes elementType = get<0>(param);
+    int nSize = get<1>(param);
+    int image = get<2>(param);
+    Mat element = getStructuringElement(elementType, Size(nSize * 2 + 1, nSize * 2 + 1),
+        Point(nSize, nSize));
+
+    erode(test_image[image], resPix, element, cv::Point(-1,-1), 1, BORDER_CONSTANT, cv::Scalar(0));
+
+    Mat elementRLE = rl::getStructuringElement(elementType, Size(nSize * 2 + 1, nSize * 2 + 1));
+    rl::erode(test_image_rle[image], resRLE, elementRLE, false);
+
+    ASSERT_TRUE(areImagesIdentical(resPix, resRLE));
+}
+
+TEST_P(RL_Identical_Result, erosion_with_offset)
+{
+    Mat resPix, resRLE;
+    RLMParams param = GetParam();
+    cv::MorphTypes elementType = get<0>(param);
+    int nSize = get<1>(param);
+    int image = get<2>(param);
+    int nOffset = nSize - 1;
+    Mat element = getStructuringElement(elementType, Size(nSize * 2 + 1, nSize * 2 + 1),
+        Point(nSize, nSize));
+
+    erode(test_image[image], resPix, element, cv::Point(nSize + nOffset, nSize + nOffset));
+
+    Mat elementRLE = rl::getStructuringElement(elementType, Size(nSize * 2 + 1, nSize * 2 + 1));
+    rl::erode(test_image_rle[image], resRLE, elementRLE, true, Point(nOffset, nOffset));
+
+    ASSERT_TRUE(areImagesIdentical(resPix, resRLE));
+}
+
+TEST_P(RL_Identical_Result, dilation_with_offset)
+{
+    Mat resPix, resRLE;
+    RLMParams param = GetParam();
+    cv::MorphTypes elementType = get<0>(param);
+    int nSize = get<1>(param);
+    int image = get<2>(param);
+    int nOffset = nSize - 1;
+    Mat element = getStructuringElement(elementType, Size(nSize * 2 + 1, nSize * 2 + 1),
+        Point(nSize, nSize));
+
+    dilate(test_image[image], resPix, element, cv::Point(nSize + nOffset, nSize + nOffset));
+
+    Mat elementRLE = rl::getStructuringElement(elementType, Size(nSize * 2 + 1, nSize * 2 + 1));
+    rl::dilate(test_image_rle[image], resRLE, elementRLE, Point(nOffset, nOffset));
+
+    ASSERT_TRUE(areImagesIdentical(resPix, resRLE));
+}
+
+INSTANTIATE_TEST_CASE_P(TypicalSET, RL_Identical_Result, Combine(Values(MORPH_RECT, MORPH_CROSS, MORPH_ELLIPSE), Values(1,5,11), Values(0,1)));
+
+class RL_CreateCustomKernel : public RLTestBase, public testing::Test
+{
+public:
+    RL_CreateCustomKernel() { }
+protected:
+    virtual void SetUp() { setUp_impl(); }
+};
+
+
+TEST_F(RL_CreateCustomKernel, check_valid)
+{
+    // create a diamond
+    int nSize = 21;
+    std::vector<Point3i> runs;
+    for (int i = 0; i < nSize; ++i)
+    {
+        runs.emplace_back(Point3i(-i, i, -nSize + i));
+        runs.emplace_back(Point3i(-i, i, nSize - i));
+    }
+    runs.emplace_back(Point3i(-nSize, nSize, 0));
+    Mat kernel, dest;
+    rl::createRLEImage(runs, kernel);
+    ASSERT_TRUE(rl::isRLMorphologyPossible(kernel));
+
+    rl::erode(test_image_rle[0], dest, kernel);
+    //only one row means: no runs, all pixels off
+    ASSERT_TRUE(dest.rows == 1);
+}
+
+typedef tuple<int> RLPParams;
+
+class RL_Paint : public RLTestBase, public ::testing::TestWithParam<RLPParams>
+{
+public:
+RL_Paint() { }
+protected:
+    virtual void SetUp() { setUp_impl(); }
+};
+
+TEST_P(RL_Paint, same_result)
+{
+    Mat converted, pixBinary, painted;
+    RLPParams param = GetParam();
+    int rType = get<0>(param);
+
+    double dThreshold = 100.0;
+    double dMaxValue = 105.0;
+    test_image[1].convertTo(converted, rType);
+    cv::threshold(converted, pixBinary, dThreshold, dMaxValue, THRESH_BINARY);
+
+    painted.create(test_image[1].rows, test_image[1].cols, rType);
+    painted = cv::Scalar(0.0);
+    rl::paint(painted, test_image_rle[1], Scalar(dMaxValue));
+    ASSERT_TRUE(arePixelImagesIdentical(pixBinary, painted));
+}
+
+INSTANTIATE_TEST_CASE_P(TypicalSET, RL_Paint, Values(CV_8U, CV_16U, CV_16S, CV_32F, CV_64F));
+
+}
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_scansegment.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_scansegment.cpp
new file mode 100644
index 00000000..fecda0fd
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_scansegment.cpp
@@ -0,0 +1,35 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static void runScanSegment(int slices)
+
+{
+    Mat img = imread(cvtest::findDataFile("cv/shared/lena.png"), IMREAD_COLOR);
+    Mat labImg;
+    cvtColor(img, labImg, COLOR_BGR2Lab);
+    Ptr<ScanSegment> ss = createScanSegment(labImg.cols, labImg.rows, 500, slices, true);
+    ss->iterate(labImg);
+    int numSuperpixels = ss->getNumberOfSuperpixels();
+    EXPECT_GT(numSuperpixels, 100);
+    EXPECT_LE(numSuperpixels, 500);
+    Mat res;
+    ss->getLabelContourMask(res, false);
+    EXPECT_GE(cvtest::norm(res, NORM_L1), 1000000);
+
+    if (cvtest::debugLevel >= 10)
+    {
+        imshow("ScanSegment", res);
+        waitKey();
+    }
+}
+
+TEST(ximgproc_ScanSegment, smoke) { runScanSegment(1); }
+TEST(ximgproc_ScanSegment, smoke4) { runScanSegment(4); }
+TEST(ximgproc_ScanSegment, smoke8) { runScanSegment(8); }
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_slic.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_slic.cpp
new file mode 100644
index 00000000..ab1f01bc
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_slic.cpp
@@ -0,0 +1,22 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ximgproc_SuperpixelSLIC, smoke)
+{
+    Mat img = imread(cvtest::findDataFile("cv/shared/lena.png"), IMREAD_COLOR);
+    Mat labImg;
+    cvtColor(img, labImg, COLOR_BGR2Lab);
+    Ptr< SuperpixelSLIC> slic = createSuperpixelSLIC(labImg);
+    slic->iterate(5);
+    Mat outLabels;
+    slic->getLabels(outLabels);
+    EXPECT_FALSE(outLabels.empty());
+    int numSuperpixels = slic->getNumberOfSuperpixels();
+    EXPECT_GT(numSuperpixels, 0);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_sparse_match_interpolator.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_sparse_match_interpolator.cpp
new file mode 100644
index 00000000..261d6109
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_sparse_match_interpolator.cpp
@@ -0,0 +1,220 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+#include "opencv2/ximgproc/sparse_match_interpolator.hpp"
+
+namespace opencv_test { namespace {
+
+static string getDataDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+const float FLOW_TAG_FLOAT = 202021.25f;
+Mat readOpticalFlow( const String& path )
+{
+//    CV_Assert(sizeof(float) == 4);
+    //FIXME: ensure right sizes of int and float - here and in writeOpticalFlow()
+
+    Mat_<Point2f> flow;
+    std::ifstream file(path.c_str(), std::ios_base::binary);
+    if ( !file.good() )
+        return std::move(flow); // no file - return empty matrix
+
+    float tag;
+    file.read((char*) &tag, sizeof(float));
+    if ( tag != FLOW_TAG_FLOAT )
+        return std::move(flow);
+
+    int width, height;
+
+    file.read((char*) &width, 4);
+    file.read((char*) &height, 4);
+
+    flow.create(height, width);
+
+    for ( int i = 0; i < flow.rows; ++i )
+    {
+        for ( int j = 0; j < flow.cols; ++j )
+        {
+            Point2f u;
+            file.read((char*) &u.x, sizeof(float));
+            file.read((char*) &u.y, sizeof(float));
+            if ( !file.good() )
+            {
+                flow.release();
+                return std::move(flow);
+            }
+
+            flow(i, j) = u;
+        }
+    }
+    file.close();
+    return std::move(flow);
+}
+
+CV_ENUM(GuideTypes, CV_8UC1, CV_8UC3)
+typedef tuple<Size, GuideTypes> InterpolatorParams;
+typedef TestWithParam<InterpolatorParams> InterpolatorTest;
+
+TEST(InterpolatorTest, ReferenceAccuracy)
+{
+    double MAX_DIF = 1.0;
+    double MAX_MEAN_DIF = 1.0 / 256.0;
+    string dir = getDataDir() + "cv/sparse_match_interpolator";
+
+    Mat src = imread(getDataDir() + "cv/optflow/RubberWhale1.png",IMREAD_COLOR);
+    ASSERT_FALSE(src.empty());
+
+    Mat ref_flow = readOpticalFlow(dir + "/RubberWhale_reference_result.flo");
+    ASSERT_FALSE(ref_flow.empty());
+
+    std::ifstream file((dir + "/RubberWhale_sparse_matches.txt").c_str());
+    float from_x,from_y,to_x,to_y;
+    vector<Point2f> from_points;
+    vector<Point2f> to_points;
+
+    while(file >> from_x >> from_y >> to_x >> to_y)
+    {
+        from_points.push_back(Point2f(from_x,from_y));
+        to_points.push_back(Point2f(to_x,to_y));
+    }
+
+    Mat res_flow;
+
+    Ptr<EdgeAwareInterpolator> interpolator = createEdgeAwareInterpolator();
+    interpolator->setK(128);
+    interpolator->setSigma(0.05f);
+    interpolator->setUsePostProcessing(true);
+    interpolator->setFGSLambda(500.0f);
+    interpolator->setFGSSigma(1.5f);
+    interpolator->interpolate(src,from_points,Mat(),to_points,res_flow);
+
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_INF), MAX_DIF);
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_L1) , MAX_MEAN_DIF*res_flow.total());
+
+    Mat from_point_mat(from_points);
+    Mat to_points_mat(to_points);
+    interpolator->interpolate(src,from_point_mat,Mat(),to_points_mat,res_flow);
+
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_INF), MAX_DIF);
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_L1) , MAX_MEAN_DIF*res_flow.total());
+
+}
+
+TEST(InterpolatorTest, RICReferenceAccuracy)
+{
+    double MAX_DIF = 6.0;
+    double MAX_MEAN_DIF = 60.0 / 256.0;
+    string dir = getDataDir() + "cv/sparse_match_interpolator";
+
+    Mat src = imread(getDataDir() + "cv/optflow/RubberWhale1.png", IMREAD_COLOR);
+    ASSERT_FALSE(src.empty());
+
+    Mat ref_flow = readOpticalFlow(dir + "/RubberWhale_reference_result.flo");
+    ASSERT_FALSE(ref_flow.empty());
+
+    Mat src1 = imread(getDataDir() + "cv/optflow/RubberWhale2.png", IMREAD_COLOR);
+    ASSERT_FALSE(src.empty());
+
+    std::ifstream file((dir + "/RubberWhale_sparse_matches.txt").c_str());
+    float from_x, from_y, to_x, to_y;
+    vector<Point2f> from_points;
+    vector<Point2f> to_points;
+
+    while (file >> from_x >> from_y >> to_x >> to_y)
+    {
+        from_points.push_back(Point2f(from_x, from_y));
+        to_points.push_back(Point2f(to_x, to_y));
+    }
+
+    Mat res_flow;
+
+    Ptr<RICInterpolator> interpolator = createRICInterpolator();
+    interpolator->setK(32);
+    interpolator->setSuperpixelSize(15);
+    interpolator->setSuperpixelNNCnt(150);
+    interpolator->setSuperpixelRuler(15.f);
+    interpolator->setSuperpixelMode(ximgproc::SLIC);
+    interpolator->setAlpha(0.7f);
+    interpolator->setModelIter(4);
+    interpolator->setRefineModels(true);
+    interpolator->setMaxFlow(250.f);
+    interpolator->setUseVariationalRefinement(true);
+    interpolator->setUseGlobalSmootherFilter(true);
+    interpolator->setFGSLambda(500.f);
+    interpolator->setFGSSigma(1.5f);
+    interpolator->interpolate(src, from_points, src1, to_points, res_flow);
+
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_INF), MAX_DIF);
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_L1), MAX_MEAN_DIF*res_flow.total());
+
+    Mat from_point_mat(from_points);
+    Mat to_points_mat(to_points);
+    interpolator->interpolate(src, from_point_mat, src1, to_points_mat, res_flow);
+
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_INF), MAX_DIF);
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_L1) , MAX_MEAN_DIF*res_flow.total());
+}
+
+TEST_P(InterpolatorTest, MultiThreadReproducibility)
+{
+    if (cv::getNumberOfCPUs() == 1)
+        return;
+
+    double MAX_DIF = 1.0;
+    double MAX_MEAN_DIF = 1.0 / 256.0;
+    int loopsCount = 2;
+    RNG rng(0);
+
+    InterpolatorParams params = GetParam();
+    Size size       = get<0>(params);
+    int guideType   = get<1>(params);
+
+    Mat from(size, guideType);
+    randu(from, 0, 255);
+
+    int num_matches = rng.uniform(5,SHRT_MAX-1);
+    vector<Point2f> from_points;
+    vector<Point2f> to_points;
+
+    for(int i=0;i<num_matches;i++)
+    {
+        from_points.push_back(Point2f(rng.uniform(0.01f,(float)size.width-1.01f),rng.uniform(0.01f,(float)size.height-1.01f)));
+        to_points.push_back(Point2f(rng.uniform(0.01f,(float)size.width-1.01f),rng.uniform(0.01f,(float)size.height-1.01f)));
+    }
+
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
+    for (int iter = 0; iter <= loopsCount; iter++)
+    {
+        int K = rng.uniform(4,512);
+        float sigma = rng.uniform(0.01f,0.5f);
+        float FGSlambda = rng.uniform(100.0f, 10000.0f);
+        float FGSsigma  = rng.uniform(0.5f, 100.0f);
+
+        Ptr<EdgeAwareInterpolator> interpolator = createEdgeAwareInterpolator();
+        interpolator->setK(K);
+        interpolator->setSigma(sigma);
+        interpolator->setUsePostProcessing(true);
+        interpolator->setFGSLambda(FGSlambda);
+        interpolator->setFGSSigma(FGSsigma);
+
+        cv::setNumThreads(nThreads);
+        Mat resMultiThread;
+        interpolator->interpolate(from,from_points,Mat(),to_points,resMultiThread);
+
+        cv::setNumThreads(1);
+        Mat resSingleThread;
+        interpolator->interpolate(from,from_points,Mat(),to_points,resSingleThread);
+
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_INF), MAX_DIF);
+        EXPECT_LE(cv::norm(resSingleThread, resMultiThread, NORM_L1) , MAX_MEAN_DIF*resMultiThread.total());
+    }
+}
+INSTANTIATE_TEST_CASE_P(FullSet,InterpolatorTest, Combine(Values(szODD,szVGA), GuideTypes::all()));
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_structured_edge_detection.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_structured_edge_detection.cpp
new file mode 100644
index 00000000..3ff44a66
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_structured_edge_detection.cpp
@@ -0,0 +1,42 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(ximgproc_StructuredEdgeDetection, regression)
+{
+    cv::String subfolder = "cv/ximgproc/";
+    cv::String dir = cvtest::TS::ptr()->get_data_path() + subfolder;
+    int nTests = 12;
+    float threshold = 0.01f;
+    
+    cv::String modelName = dir + "model.yml.gz";
+    cv::Ptr<cv::ximgproc::StructuredEdgeDetection> pDollar =
+        cv::ximgproc::createStructuredEdgeDetection(modelName);
+
+    for (int i = 0; i < nTests; ++i)
+    {
+        cv::String srcName = dir + cv::format( "sources/%02d.png", i + 1);
+        cv::Mat src = cv::imread( srcName, 1 );
+        ASSERT_TRUE(!src.empty());
+
+        cv::String previousResultName = dir + cv::format( "results/%02d.png", i + 1 );
+        cv::Mat previousResult = cv::imread( previousResultName, 0 );
+        previousResult.convertTo( previousResult, CV_32F, 1/255.0 );
+
+        src.convertTo( src, CV_32F, 1/255.0 );
+
+        cv::Mat currentResult( src.size(), src.type() );
+        pDollar->detectEdges( src, currentResult );
+
+        cv::Mat sqrError = ( currentResult - previousResult )
+            .mul( currentResult - previousResult );
+        cv::Scalar mse = cv::sum(sqrError) / cv::Scalar::all( double( sqrError.total() ) );
+
+        EXPECT_LE( mse[0], threshold );
+    }
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_thinning.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_thinning.cpp
new file mode 100644
index 00000000..733fe85d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_thinning.cpp
@@ -0,0 +1,52 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static int createTestImage(Mat& src)
+{
+    src = Mat::zeros(Size(256, 256), CV_8UC1);
+    for (int x = 50; x < src.cols - 50; x += 50)
+    {
+        cv::circle(src, Point(x, x/2), 30 + x/2, Scalar(255), 5);
+    }
+    int src_pixels = countNonZero(src);
+    EXPECT_GT(src_pixels, 0);
+    return src_pixels;
+}
+
+TEST(ximgproc_Thinning, simple_ZHANGSUEN)
+{
+    Mat src;
+    int src_pixels = createTestImage(src);
+
+    Mat dst;
+    thinning(src, dst, THINNING_ZHANGSUEN);
+    int dst_pixels = countNonZero(dst);
+    EXPECT_LE(dst_pixels, src_pixels);
+
+#if 0
+    imshow("src", src); imshow("dst", dst); waitKey();
+#endif
+}
+
+TEST(ximgproc_Thinning, simple_GUOHALL)
+{
+    Mat src;
+    int src_pixels = createTestImage(src);
+
+    Mat dst;
+    thinning(src, dst, THINNING_GUOHALL);
+    int dst_pixels = countNonZero(dst);
+    EXPECT_LE(dst_pixels, src_pixels);
+
+#if 0
+    imshow("src", src); imshow("dst", dst); waitKey();
+#endif
+}
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_weighted_median_filter.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_weighted_median_filter.cpp
new file mode 100644
index 00000000..1e70c986
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/test/test_weighted_median_filter.cpp
@@ -0,0 +1,76 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+static string getDataDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+typedef tuple<Size, WMFWeightType> WMFParams;
+typedef TestWithParam<WMFParams> WeightedMedianFilterTest;
+
+TEST_P(WeightedMedianFilterTest, SplatSurfaceAccuracy)
+{
+
+    WMFParams params = GetParam();
+    Size size = get<0>(params);
+    WMFWeightType weightType = get<1>(params);
+
+    RNG rnd(0);
+
+    int guideCn = rnd.uniform(1, 2);
+    if(guideCn==2) guideCn++; //1 or 3 channels
+    Mat guide(size, CV_MAKE_TYPE(CV_8U, guideCn));
+    randu(guide, 0, 255);
+
+    Scalar surfaceValue;
+    int srcCn = rnd.uniform(1, 4);
+    rnd.fill(surfaceValue, RNG::UNIFORM, 0, 255);
+    Mat src(size, CV_MAKE_TYPE(CV_8U, srcCn), surfaceValue);
+
+    int r = int(rnd.uniform(3, 11));
+    double sigma  = rnd.uniform(9.0, 100.0);
+
+    Mat res;
+    weightedMedianFilter(guide, src, res, r, sigma, weightType);
+
+    double normL1 = cvtest::norm(src, res, NORM_L1)/src.total()/src.channels();
+    EXPECT_LE(normL1, 1.0/64);
+}
+
+TEST(WeightedMedianFilterTest, ReferenceAccuracy)
+{
+    string dir = getDataDir() + "cv/edgefilter";
+
+    Mat src = imread(dir + "/kodim23.png");
+    Mat ref = imread(dir + "/fgs/kodim23_lambda=1000_sigma=10.png");
+
+    ASSERT_FALSE(src.empty());
+    ASSERT_FALSE(ref.empty());
+
+    Mat res;
+    weightedMedianFilter(src, src, res, 7);
+
+    double totalMaxError = 1.0/32.0*src.total()*src.channels();
+
+    EXPECT_LE(cvtest::norm(res, ref, NORM_L2), totalMaxError);
+}
+
+TEST(WeightedMedianFilterTest, mask_zeros_no_crash)
+{
+    Mat img = imread(getDataDir() + "cv/ximgproc/sources/01.png");
+    Mat mask = Mat::zeros(img.size(), CV_8U);
+    Mat filtered;
+    weightedMedianFilter(img, img, filtered, 3, 20, WMF_EXP, mask);
+
+    EXPECT_EQ(cv::norm(img, filtered, NORM_INF), 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(TypicalSET, WeightedMedianFilterTest, Combine(Values(szODD, szQVGA),  Values(WMF_EXP, WMF_IV2, WMF_OFF)));
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/disparity_filtering.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/disparity_filtering.markdown
new file mode 100644
index 00000000..0248c6db
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/disparity_filtering.markdown
@@ -0,0 +1,76 @@
+Disparity map post-filtering {#tutorial_ximgproc_disparity_filtering}
+============================
+
+Introduction
+------------
+
+Stereo matching algorithms, especially highly-optimized ones that are intended for real-time processing
+on CPU, tend to make quite a few errors on challenging sequences. These errors are usually concentrated
+in uniform texture-less areas, half-occlusions and regions near depth discontinuities. One way of dealing
+with stereo-matching errors is to use various techniques of detecting potentially inaccurate disparity
+values and invalidate them, therefore making the disparity map semi-sparse. Several such techniques are
+already implemented in the StereoBM and StereoSGBM algorithms. Another way would be to use some kind of
+filtering procedure to align the disparity map edges with those of the source image and to propagate
+the disparity values from high- to low-confidence regions like half-occlusions. Recent advances in
+edge-aware filtering have enabled performing such post-filtering under the constraints of real-time
+processing on CPU.
+
+In this tutorial you will learn how to use the disparity map post-filtering to improve the results
+of StereoBM and StereoSGBM algorithms.
+
+Source Stereoscopic Image
+-------------------------
+
+![Left view](images/ambush_5_left.jpg)
+![Right view](images/ambush_5_right.jpg)
+
+Source Code
+-----------
+
+We will be using snippets from the example application, that can be downloaded [here ](https://github.com/opencv/opencv_contrib/blob/master/modules/ximgproc/samples/disparity_filtering.cpp).
+
+Explanation
+-----------
+
+The provided example has several options that yield different trade-offs between the speed and
+the quality of the resulting disparity map. Both the speed and the quality are measured if the user
+has provided the ground-truth disparity map. In this tutorial we will take a detailed look at the
+default pipeline, that was designed to provide the best possible quality under the constraints of
+real-time processing on CPU.
+
+-#  **Load left and right views**
+    @snippet ximgproc/samples/disparity_filtering.cpp load_views
+    We start by loading the source stereopair. For this tutorial we will take a somewhat challenging
+    example from the MPI-Sintel dataset with a lot of texture-less regions.
+
+-#  **Prepare the views for matching**
+    @snippet ximgproc/samples/disparity_filtering.cpp downscale
+    We perform downscaling of the views to speed-up the matching stage at the cost of minor
+    quality degradation. To get the best possible quality downscaling should be avoided.
+
+-#  **Perform matching and create the filter instance**
+    @snippet ximgproc/samples/disparity_filtering.cpp matching
+    We are using StereoBM for faster processing. If speed is not critical, though,
+    StereoSGBM would provide better quality. The filter instance is created by providing
+    the StereoMatcher instance that we intend to use. Another matcher instance is
+    returned by the createRightMatcher function. These two matcher instances are then
+    used to compute disparity maps both for the left and right views, that are required
+    by the filter.
+
+-#  **Perform filtering**
+    @snippet ximgproc/samples/disparity_filtering.cpp filtering
+    Disparity maps computed by the respective matcher instances, as well as the source left view
+    are passed to the filter. Note that we are using the original non-downscaled view to guide the
+    filtering process. The disparity map is automatically upscaled in an edge-aware fashion to match
+    the original view resolution. The result is stored in filtered_disp.
+
+-#  **Visualize the disparity maps**
+    @snippet ximgproc/samples/disparity_filtering.cpp visualization
+    We use a convenience function getDisparityVis to visualize the disparity maps. The second parameter
+    defines the contrast (all disparity values are scaled by this value in the visualization).
+
+Results
+-------
+
+![Result of the StereoBM](images/ambush_5_bm.png)
+![Result of the demonstrated pipeline (StereoBM on downscaled views with post-filtering)](images/ambush_5_bm_with_filter.png)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/01.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/01.jpg
new file mode 100644
index 00000000..fddb8e21
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/01.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/02.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/02.jpg
new file mode 100644
index 00000000..4583cf02
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/02.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/03.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/03.jpg
new file mode 100644
index 00000000..16b3adf1
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/03.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/04.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/04.jpg
new file mode 100644
index 00000000..cd157346
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/04.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/05.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/05.jpg
new file mode 100644
index 00000000..6ab0ee15
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/05.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/06.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/06.jpg
new file mode 100644
index 00000000..f42b7122
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/06.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/07.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/07.jpg
new file mode 100644
index 00000000..0bdd457c
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/07.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/08.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/08.jpg
new file mode 100644
index 00000000..2c96d990
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/08.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/09.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/09.jpg
new file mode 100644
index 00000000..8e654faa
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/09.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/10.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/10.jpg
new file mode 100644
index 00000000..311596c6
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/10.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/11.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/11.jpg
new file mode 100644
index 00000000..68ecdfaa
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/11.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/12.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/12.jpg
new file mode 100644
index 00000000..891de11f
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/12.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_bm.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_bm.png
new file mode 100644
index 00000000..0f339181
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_bm.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_bm_with_filter.png b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_bm_with_filter.png
new file mode 100644
index 00000000..3a585238
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_bm_with_filter.png differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_left.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_left.jpg
new file mode 100644
index 00000000..0fb11f5e
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_left.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_right.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_right.jpg
new file mode 100644
index 00000000..2f9f4f1e
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/images/ambush_5_right.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/prediction.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/prediction.markdown
new file mode 100644
index 00000000..7f1fd854
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/prediction.markdown
@@ -0,0 +1,69 @@
+Structured forests for fast edge detection {#tutorial_ximgproc_prediction}
+==========================================
+
+Introduction
+------------
+
+In this tutorial you will learn how to use structured forests for the purpose of edge detection in
+an image.
+
+Examples
+--------
+
+![image](images/01.jpg)
+
+![image](images/02.jpg)
+
+![image](images/03.jpg)
+
+![image](images/04.jpg)
+
+![image](images/05.jpg)
+
+![image](images/06.jpg)
+
+![image](images/07.jpg)
+
+![image](images/08.jpg)
+
+![image](images/09.jpg)
+
+![image](images/10.jpg)
+
+![image](images/11.jpg)
+
+![image](images/12.jpg)
+
+@note binarization techniques like Canny edge detector are applicable to edges produced by both
+algorithms (Sobel and StructuredEdgeDetection::detectEdges).
+
+Source Code
+-----------
+
+@includelineno ximgproc/samples/structured_edge_detection.cpp
+
+Explanation
+-----------
+
+-#  **Load source color image**
+
+    @snippet ximgproc/samples/structured_edge_detection.cpp imread
+
+-#  **Convert source image to float [0;1] range**
+
+    @snippet ximgproc/samples/structured_edge_detection.cpp convert
+
+-#  **Run main algorithm**
+
+    @snippet ximgproc/samples/structured_edge_detection.cpp create
+    @snippet ximgproc/samples/structured_edge_detection.cpp detect
+    @snippet ximgproc/samples/structured_edge_detection.cpp nms
+
+-#  **Show results**
+
+    @snippet ximgproc/samples/structured_edge_detection.cpp imshow
+
+Literature
+----------
+
+For more information, refer to the following papers : @cite Dollar2013 @cite Lim2013
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/scripts/modelConvert.m b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/scripts/modelConvert.m
new file mode 100644
index 00000000..11790bbb
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/scripts/modelConvert.m
@@ -0,0 +1,73 @@
+function modelConvert(model, outname)
+%% script for converting Piotr's matlab model into YAML format
+
+outfile = fopen(outname, 'w');
+
+fprintf(outfile, '%%YAML:1.0\n\n');
+
+fprintf(outfile, ['options:\n'...
+                  '    numberOfTrees: 8\n'...
+                  '    numberOfTreesToEvaluate: 4\n'...
+                  '    selfsimilarityGridSize: 5\n'...
+                  '    stride: 2\n'...
+                  '    shrinkNumber: 2\n'...
+                  '    patchSize: 32\n'...
+                  '    patchInnerSize: 16\n'...
+                  '    numberOfGradientOrientations: 4\n'...
+                  '    gradientSmoothingRadius: 0\n'...
+                  '    regFeatureSmoothingRadius: 2\n'...
+                  '    ssFeatureSmoothingRadius: 8\n'...
+                  '    gradientNormalizationRadius: 4\n\n']);
+
+fprintf(outfile, 'childs:\n');
+printToYML(outfile, model.child', 0);
+
+fprintf(outfile, 'featureIds:\n');
+printToYML(outfile, model.fids', 0);
+
+fprintf(outfile, 'thresholds:\n');
+printToYML(outfile, model.thrs', 0);
+
+N = 1000;
+fprintf(outfile, 'edgeBoundaries:\n');
+printToYML(outfile, model.eBnds, N);
+
+fprintf(outfile, 'edgeBins:\n');
+printToYML(outfile, model.eBins, N);
+
+fclose(outfile);
+gzip(outname);
+
+end
+
+function printToYML(outfile, A, N)
+%% append matrix A to outfile as
+%%    - [a11, a12, a13, a14, ..., a1n]
+%%    - [a21, a22, a23, a24, ..., a2n]
+%%    ...
+%%
+%% if size(A, 2) == 1, A is printed by N elemnent per row
+
+    if (length(size(A)) ~= 2)
+        error('printToYML: second-argument matrix should have two dimensions');
+    end
+
+    if (size(A,2) ~= 1)
+        for i=1:size(A,1)
+            fprintf(outfile, '    - [');
+            fprintf(outfile, '%d,', A(i, 1:end-1));
+            fprintf(outfile, '%d]\n', A(i, end));
+        end
+    else
+        len = length(A);
+        for i=1:ceil(len/N)
+            first = (i-1)*N + 1;
+             last = min(i*N, len) - 1;
+
+            fprintf(outfile, '    - [');
+            fprintf(outfile, '%d,', A(first:last));
+            fprintf(outfile, '%d]\n', A(last + 1));
+        end
+    end
+    fprintf(outfile, '\n');
+end
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/training.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/training.markdown
new file mode 100644
index 00000000..382aafbc
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/ximgproc/tutorials/training.markdown
@@ -0,0 +1,115 @@
+Structured forest training {#tutorial_ximgproc_training}
+==========================
+
+Introduction
+------------
+
+In this tutorial we show how to train your own structured forest using author's initial Matlab
+implementation.
+
+Training pipeline
+-----------------
+
+-#  Download "Piotr's Toolbox" from [link](http://vision.ucsd.edu/~pdollar/toolbox/doc/index.html)
+    and put it into separate directory, e.g. PToolbox
+
+-#  Download BSDS500 dataset from
+    link \<http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/BSR/\> and put it into
+    separate directory named exactly BSR
+-#  Add both directory and their subdirectories to Matlab path.
+
+-#  Download detector code from
+    link \<http://research.microsoft.com/en-us/downloads/389109f6-b4e8-404c-84bf-239f7cbf4e3d/\> and
+    put it into root directory. Now you should have :
+    @code
+        .
+            BSR
+            PToolbox
+            models
+            private
+            Contents.m
+            edgesChns.m
+            edgesDemo.m
+            edgesDemoRgbd.m
+            edgesDetect.m
+            edgesEval.m
+            edgesEvalDir.m
+            edgesEvalImg.m
+            edgesEvalPlot.m
+            edgesSweeps.m
+            edgesTrain.m
+            license.txt
+            readme.txt
+    @endcode
+
+-#  Rename models/forest/modelFinal.mat to models/forest/modelFinal.mat.backup
+
+-#  Open edgesChns.m and comment lines 26--41. Add after commented lines the following:
+    @code{.cpp}
+            shrink=opts.shrink;
+            chns = single(getFeatures( im2double(I) ));
+    @endcode
+
+-#  Now it is time to compile promised getFeatures. I do with the following code:
+    @code{.cpp}
+    #include <cv.h>
+    #include <highgui.h>
+
+    #include <mat.h>
+    #include <mex.h>
+
+    #include "MxArray.hpp" // https://github.com/kyamagu/mexopencv
+
+    class NewRFFeatureGetter : public cv::RFFeatureGetter
+    {
+    public:
+        NewRFFeatureGetter() : name("NewRFFeatureGetter"){}
+
+        virtual void getFeatures(const cv::Mat &src, NChannelsMat &features,
+                                 const int gnrmRad, const int gsmthRad,
+                                 const int shrink, const int outNum, const int gradNum) const
+        {
+            // here your feature extraction code, the default one is:
+            // resulting features Mat should be n-channels, floating point matrix
+        }
+
+    protected:
+        cv::String name;
+    };
+
+    MEXFUNCTION_LINKAGE void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
+    {
+        if (nlhs != 1) mexErrMsgTxt("nlhs != 1");
+        if (nrhs != 1) mexErrMsgTxt("nrhs != 1");
+
+        cv::Mat src = MxArray(prhs[0]).toMat();
+        src.convertTo(src, cv::DataType<float>::type);
+
+        std::string modelFile = MxArray(prhs[1]).toString();
+        NewRFFeatureGetter *pDollar = createNewRFFeatureGetter();
+
+        cv::Mat edges;
+        pDollar->getFeatures(src, edges, 4, 0, 2, 13, 4);
+        // you can use other numbers here
+
+        edges.convertTo(edges, cv::DataType<double>::type);
+
+        plhs[0] = MxArray(edges);
+    }
+    @endcode
+
+-#  Place compiled mex file into root dir and run edgesDemo. You will need to wait a couple of hours
+    after that the new model will appear inside models/forest/.
+
+-#  The final step is converting trained model from Matlab binary format to YAML which you can use
+    with our ocv::StructuredEdgeDetection. For this purpose run
+    opencv_contrib/ximgproc/tutorials/scripts/modelConvert(model, "model.yml")
+
+How to use your model
+---------------------
+
+Just use expanded constructor with above defined class NewRFFeatureGetter
+@code{.cpp}
+cv::StructuredEdgeDetection pDollar
+    = cv::createStructuredEdgeDetection( modelName, makePtr<NewRFFeatureGetter>() );
+@endcode
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/CMakeLists.txt b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/CMakeLists.txt
new file mode 100644
index 00000000..1727a42b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/CMakeLists.txt
@@ -0,0 +1,5 @@
+set(the_description "Object detection algorithms")
+ocv_define_module(xobjdetect opencv_core opencv_imgproc opencv_objdetect opencv_imgcodecs WRAP python)
+if (BUILD_opencv_apps AND NOT APPLE_FRAMEWORK)
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tools ${CMAKE_CURRENT_BINARY_DIR}/tools)
+endif()
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/README.md b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/README.md
new file mode 100644
index 00000000..1b428e75
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/README.md
@@ -0,0 +1,4 @@
+Object Detection using Boosted Features
+=======================================
+
+Uses a Waldboost cascade and local binary patterns computed as integral features for 2D object detection.
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/doc/xobjdetect.bib b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/doc/xobjdetect.bib
new file mode 100644
index 00000000..563a800d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/doc/xobjdetect.bib
@@ -0,0 +1,19 @@
+@inproceedings{Dollar09,
+  title={Integral Channel Features.},
+  author={Doll{\'a}r, Piotr and Tu, Zhuowen and Perona, Pietro and Belongie, Serge},
+  booktitle={BMVC},
+  volume={2},
+  number={3},
+  pages={5},
+  year={2009}
+}
+
+@inproceedings{Sochman05,
+  title={Waldboost-learning for time constrained sequential detection},
+  author={Sochman, Jan and Matas, Jiri},
+  booktitle={Computer Vision and Pattern Recognition, 2005. CVPR 2005. IEEE Computer Society Conference on},
+  volume={2},
+  pages={150--156},
+  year={2005},
+  organization={IEEE}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/include/opencv2/xobjdetect.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/include/opencv2/xobjdetect.hpp
new file mode 100644
index 00000000..13dde112
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/include/opencv2/xobjdetect.hpp
@@ -0,0 +1,104 @@
+/*
+
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+
+*/
+
+#ifndef __OPENCV_XOBJDETECT_XOBJDETECT_HPP__
+#define __OPENCV_XOBJDETECT_XOBJDETECT_HPP__
+
+#include <opencv2/core.hpp>
+#include <vector>
+#include <string>
+
+/** @defgroup xobjdetect Extended object detection
+*/
+namespace cv
+{
+namespace xobjdetect
+{
+//! @addtogroup xobjdetect
+//! @{
+
+
+/** @brief WaldBoost detector
+*/
+class CV_EXPORTS WBDetector {
+public:
+    /** @brief Read detector from FileNode.
+    @param node FileNode for input
+    */
+    virtual void read(const FileNode &node) = 0;
+
+    /** @brief Write detector to FileStorage.
+    @param fs FileStorage for output
+    */
+    virtual void write(FileStorage &fs) const = 0;
+
+    /** @brief Train WaldBoost detector
+    @param pos_samples Path to directory with cropped positive samples
+    @param neg_imgs Path to directory with negative (background) images
+    */
+    virtual void train(
+        const std::string& pos_samples,
+        const std::string& neg_imgs) = 0;
+
+    /** @brief Detect objects on image using WaldBoost detector
+    @param img Input image for detection
+    @param bboxes Bounding boxes coordinates output vector
+    @param confidences Confidence values for bounding boxes output vector
+    */
+    virtual void detect(
+        const Mat& img,
+        std::vector<Rect> &bboxes,
+        std::vector<double> &confidences) = 0;
+
+    /** @brief Create instance of WBDetector
+    */
+    static Ptr<WBDetector> create();
+
+    virtual ~WBDetector(){}
+};
+
+
+//! @}
+
+} /* namespace xobjdetect */
+} /* namespace cv */
+
+#endif /* __OPENCV_XOBJDETECT_XOBJDETECT_HPP__ */
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/cascadeclassifier.h b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/cascadeclassifier.h
new file mode 100644
index 00000000..b948480d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/cascadeclassifier.h
@@ -0,0 +1,95 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#ifndef _OPENCV_CASCADECLASSIFIER_H_
+#define _OPENCV_CASCADECLASSIFIER_H_
+
+#include "precomp.hpp"
+
+#define CC_CASCADE_FILENAME "cascade.xml"
+#define CC_PARAMS_FILENAME "params.xml"
+
+#define CC_CASCADE_PARAMS "cascadeParams"
+#define CC_STAGE_TYPE "stageType"
+#define CC_FEATURE_TYPE "featureType"
+#define CC_HEIGHT "height"
+#define CC_WIDTH  "width"
+
+#define CC_STAGE_NUM    "stageNum"
+#define CC_STAGES       "stages"
+#define CC_STAGE_PARAMS "stageParams"
+
+#define CC_BOOST            "BOOST"
+#define CC_BOOST_TYPE       "boostType"
+#define CC_DISCRETE_BOOST   "DAB"
+#define CC_REAL_BOOST       "RAB"
+#define CC_LOGIT_BOOST      "LB"
+#define CC_GENTLE_BOOST     "GAB"
+#define CC_MINHITRATE       "minHitRate"
+#define CC_MAXFALSEALARM    "maxFalseAlarm"
+#define CC_TRIM_RATE        "weightTrimRate"
+#define CC_MAX_DEPTH        "maxDepth"
+#define CC_WEAK_COUNT       "maxWeakCount"
+#define CC_STAGE_THRESHOLD  "stageThreshold"
+#define CC_WEAK_CLASSIFIERS "weakClassifiers"
+#define CC_INTERNAL_NODES   "internalNodes"
+#define CC_LEAF_VALUES      "leafValues"
+
+#define CC_FEATURES       FEATURES
+#define CC_FEATURE_PARAMS "featureParams"
+#define CC_MAX_CAT_COUNT  "maxCatCount"
+#define CC_FEATURE_SIZE   "featSize"
+
+#define CC_HAAR        "HAAR"
+#define CC_MODE        "mode"
+#define CC_MODE_BASIC  "BASIC"
+#define CC_MODE_CORE   "CORE"
+#define CC_MODE_ALL    "ALL"
+#define CC_RECTS       "rects"
+#define CC_TILTED      "tilted"
+
+#define CC_LBP  "LBP"
+#define CC_RECT "rect"
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/feature_evaluator.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/feature_evaluator.cpp
new file mode 100644
index 00000000..41dfbf5e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/feature_evaluator.cpp
@@ -0,0 +1,131 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#include "precomp.hpp"
+
+namespace cv {
+namespace xobjdetect {
+
+float calcNormFactor( const Mat& sum, const Mat& sqSum )
+{
+    CV_DbgAssert( sum.cols > 3 && sqSum.rows > 3 );
+    Rect normrect( 1, 1, sum.cols - 3, sum.rows - 3 );
+    size_t p0, p1, p2, p3;
+    CV_SUM_OFFSETS( p0, p1, p2, p3, normrect, sum.step1() )
+    double area = normrect.width * normrect.height;
+    const int *sp = sum.ptr<int>();
+    int valSum = sp[p0] - sp[p1] - sp[p2] + sp[p3];
+    const double *sqp = sqSum.ptr<double>();
+    double valSqSum = sqp[p0] - sqp[p1] - sqp[p2] + sqp[p3];
+    return (float) sqrt( (double) (area * valSqSum - (double)valSum * valSum) );
+}
+
+CvParams::CvParams() : name( "params" ) {}
+void CvParams::printDefaults() const
+{ std::cout << "--" << name << "--" << std::endl; }
+void CvParams::printAttrs() const {}
+bool CvParams::scanAttr( const std::string, const std::string ) { return false; }
+
+
+//---------------------------- FeatureParams --------------------------------------
+
+CvFeatureParams::CvFeatureParams() : maxCatCount( 0 ), featSize( 1 )
+{
+    name = CC_FEATURE_PARAMS;
+}
+
+void CvFeatureParams::init( const CvFeatureParams& fp )
+{
+    maxCatCount = fp.maxCatCount;
+    featSize = fp.featSize;
+}
+
+void CvFeatureParams::write( FileStorage &fs ) const
+{
+    fs << CC_MAX_CAT_COUNT << maxCatCount;
+    fs << CC_FEATURE_SIZE << featSize;
+}
+
+bool CvFeatureParams::read( const FileNode &node )
+{
+    if ( node.empty() )
+        return false;
+    maxCatCount = node[CC_MAX_CAT_COUNT];
+    featSize = node[CC_FEATURE_SIZE];
+    return ( maxCatCount >= 0 && featSize >= 1 );
+}
+
+Ptr<CvFeatureParams> CvFeatureParams::create()
+{
+    return Ptr<CvFeatureParams>(new CvLBPFeatureParams);
+}
+
+//------------------------------------- FeatureEvaluator ---------------------------------------
+
+void CvFeatureEvaluator::init(const CvFeatureParams *_featureParams,
+                              int _maxSampleCount, Size _winSize )
+{
+    CV_Assert(_maxSampleCount > 0);
+    featureParams = (CvFeatureParams *)_featureParams;
+    winSize = _winSize;
+    numFeatures = 0;
+    cls.create( (int)_maxSampleCount, 1, CV_32FC1 );
+    generateFeatures();
+}
+
+void CvFeatureEvaluator::setImage(const Mat &, uchar clsLabel, int idx, const std::vector<int>&)
+{
+    //CV_Assert(img.cols == winSize.width);
+    //CV_Assert(img.rows == winSize.height);
+    CV_Assert(idx < cls.rows);
+    cls.ptr<float>(idx)[0] = clsLabel;
+}
+
+Ptr<CvFeatureEvaluator> CvFeatureEvaluator::create()
+{
+    return Ptr<CvFeatureEvaluator>(new CvLBPEvaluator);
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/feature_evaluator.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/feature_evaluator.hpp
new file mode 100644
index 00000000..879e75f0
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/feature_evaluator.hpp
@@ -0,0 +1,151 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#ifndef _OPENCV_FEATURES_H_
+#define _OPENCV_FEATURES_H_
+
+#include <stdio.h>
+
+#define FEATURES "features"
+
+#define CV_SUM_OFFSETS( p0, p1, p2, p3, rect, step )                      \
+    /* (x, y) */                                                          \
+    (p0) = (rect).x + (step) * (rect).y;                                  \
+    /* (x + w, y) */                                                      \
+    (p1) = (rect).x + (rect).width + (step) * (rect).y;                   \
+    /* (x + w, y) */                                                      \
+    (p2) = (rect).x + (step) * ((rect).y + (rect).height);                \
+    /* (x + w, y + h) */                                                  \
+    (p3) = (rect).x + (rect).width + (step) * ((rect).y + (rect).height);
+
+#define CV_TILTED_OFFSETS( p0, p1, p2, p3, rect, step )                   \
+    /* (x, y) */                                                          \
+    (p0) = (rect).x + (step) * (rect).y;                                  \
+    /* (x - h, y + h) */                                                  \
+    (p1) = (rect).x - (rect).height + (step) * ((rect).y + (rect).height);\
+    /* (x + w, y + w) */                                                  \
+    (p2) = (rect).x + (rect).width + (step) * ((rect).y + (rect).width);  \
+    /* (x + w - h, y + w + h) */                                          \
+    (p3) = (rect).x + (rect).width - (rect).height                        \
+           + (step) * ((rect).y + (rect).width + (rect).height);
+
+namespace cv {
+namespace xobjdetect {
+
+float calcNormFactor( const cv::Mat& sum, const cv::Mat& sqSum );
+
+template<class Feature>
+void _writeFeatures( const std::vector<Feature> features, cv::FileStorage &fs, const cv::Mat& featureMap )
+{
+    fs << FEATURES << "[";
+    const cv::Mat_<int>& featureMap_ = (const cv::Mat_<int>&)featureMap;
+    for ( int fi = 0; fi < featureMap.cols; fi++ )
+        if ( featureMap_(0, fi) >= 0 )
+        {
+            fs << "{";
+            features[fi].write( fs );
+            fs << "}";
+        }
+    fs << "]";
+}
+
+class CvParams
+{
+public:
+    CvParams();
+    virtual ~CvParams() {}
+    // from|to file
+    virtual void write( cv::FileStorage &fs ) const = 0;
+    virtual bool read( const cv::FileNode &node ) = 0;
+    // from|to screen
+    virtual void printDefaults() const;
+    virtual void printAttrs() const;
+    virtual bool scanAttr( const std::string prmName, const std::string val );
+    std::string name;
+};
+
+class CvFeatureParams : public CvParams
+{
+public:
+    enum { HAAR = 0, LBP = 1, HOG = 2 };
+    CvFeatureParams();
+    virtual void init( const CvFeatureParams& fp );
+    virtual void write( cv::FileStorage &fs ) const CV_OVERRIDE;
+    virtual bool read( const cv::FileNode &node ) CV_OVERRIDE;
+    static cv::Ptr<CvFeatureParams> create();
+    int maxCatCount; // 0 in case of numerical features
+    int featSize; // 1 in case of simple features (HAAR, LBP) and N_BINS(9)*N_CELLS(4) in case of Dalal's HOG features
+};
+
+class CvFeatureEvaluator
+{
+public:
+    virtual ~CvFeatureEvaluator() {}
+    virtual void init(const CvFeatureParams *_featureParams,
+                      int _maxSampleCount, cv::Size _winSize );
+    virtual void setImage(const cv::Mat& img, uchar clsLabel, int idx, const std::vector<int> &feature_ind);
+    virtual void setWindow(const cv::Point& p) = 0;
+    virtual void writeFeatures( cv::FileStorage &fs, const cv::Mat& featureMap ) const = 0;
+    virtual float operator()(int featureIdx) = 0;
+    static cv::Ptr<CvFeatureEvaluator> create();
+
+    int getNumFeatures() const { return numFeatures; }
+    int getMaxCatCount() const { return featureParams->maxCatCount; }
+    int getFeatureSize() const { return featureParams->featSize; }
+    const cv::Mat& getCls() const { return cls; }
+    float getCls(int si) const { return cls.at<float>(si, 0); }
+protected:
+    virtual void generateFeatures() = 0;
+
+    int npos, nneg;
+    int numFeatures;
+    cv::Size winSize;
+    CvFeatureParams *featureParams;
+    cv::Mat cls;
+};
+
+}
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/lbpfeatures.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/lbpfeatures.cpp
new file mode 100644
index 00000000..4e1c8d29
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/lbpfeatures.cpp
@@ -0,0 +1,128 @@
+
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#include "precomp.hpp"
+
+namespace cv {
+namespace xobjdetect {
+
+CvLBPFeatureParams::CvLBPFeatureParams()
+{
+    maxCatCount = 256;
+    name = LBPF_NAME;
+}
+
+void CvLBPEvaluator::init(const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize)
+{
+    CV_Assert( _maxSampleCount > 0);
+    sum.create((int)_maxSampleCount, (_winSize.width + 1) * (_winSize.height + 1), CV_32SC1);
+    CvFeatureEvaluator::init( _featureParams, _maxSampleCount, _winSize );
+}
+
+void CvLBPEvaluator::setImage(const Mat &img, uchar clsLabel, int idx,
+    const std::vector<int> &feature_ind)
+{
+    CV_DbgAssert( !sum.empty() );
+    CvFeatureEvaluator::setImage( img, clsLabel, idx, feature_ind );
+    integral( img, sum );
+    cur_sum = sum;
+    offset_ = int(sum.ptr<int>(1) - sum.ptr<int>());
+    for (size_t i = 0; i < feature_ind.size(); ++i) {
+        features[feature_ind[i]].calcPoints(offset_);
+    }
+}
+
+void CvLBPEvaluator::writeFeatures( FileStorage &fs, const Mat& featureMap ) const
+{
+    _writeFeatures( features, fs, featureMap );
+}
+
+void CvLBPEvaluator::generateFeatures()
+{
+    int offset = winSize.width + 1;
+    for( int x = 0; x < winSize.width; x++ )
+        for( int y = 0; y < winSize.height; y++ )
+            for( int w = 1; w <= winSize.width / 3; w++ )
+                for( int h = 1; h <= winSize.height / 3; h++ )
+                    if ( (x+3*w <= winSize.width) && (y+3*h <= winSize.height) )
+                        features.push_back( Feature(offset, x, y, w, h ) );
+    numFeatures = (int)features.size();
+}
+
+CvLBPEvaluator::Feature::Feature()
+{
+    rect = Rect(0, 0, 0, 0);
+}
+
+CvLBPEvaluator::Feature::Feature( int offset, int x, int y, int _blockWidth, int _blockHeight )
+{
+    x_ = x;
+    y_ = y;
+    block_w_ = _blockWidth;
+    block_h_ = _blockHeight;
+    offset_ = offset;
+    calcPoints(offset);
+}
+
+void CvLBPEvaluator::Feature::calcPoints(int offset)
+{
+    Rect tr = rect = Rect(x_, y_, block_w_, block_h_);
+    CV_SUM_OFFSETS( p[0], p[1], p[4], p[5], tr, offset )
+    tr.x += 2*rect.width;
+    CV_SUM_OFFSETS( p[2], p[3], p[6], p[7], tr, offset )
+    tr.y +=2*rect.height;
+    CV_SUM_OFFSETS( p[10], p[11], p[14], p[15], tr, offset )
+    tr.x -= 2*rect.width;
+    CV_SUM_OFFSETS( p[8], p[9], p[12], p[13], tr, offset )
+    offset_ = offset;
+}
+
+void CvLBPEvaluator::Feature::write(FileStorage &fs) const
+{
+    fs << CC_RECT << "[:" << rect.x << rect.y << rect.width << rect.height << "]";
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/lbpfeatures.h b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/lbpfeatures.h
new file mode 100644
index 00000000..8f28a838
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/lbpfeatures.h
@@ -0,0 +1,116 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#ifndef _OPENCV_LBPFEATURES_H_
+#define _OPENCV_LBPFEATURES_H_
+
+#include "precomp.hpp"
+
+
+#define LBPF_NAME "lbpFeatureParams"
+
+namespace cv {
+namespace xobjdetect {
+
+struct CvLBPFeatureParams : CvFeatureParams
+{
+    CvLBPFeatureParams();
+
+};
+
+class CvLBPEvaluator : public CvFeatureEvaluator
+{
+public:
+    virtual ~CvLBPEvaluator() {}
+    virtual void init(const CvFeatureParams *_featureParams,
+        int _maxSampleCount, cv::Size _winSize ) CV_OVERRIDE;
+    virtual void setImage(const cv::Mat& img, uchar clsLabel, int idx, const std::vector<int> &feature_ind) CV_OVERRIDE;
+    virtual void setWindow(const cv::Point& p) CV_OVERRIDE
+    { cur_sum = sum.rowRange(p.y, p.y + winSize.height).colRange(p.x, p.x + winSize.width); }
+    virtual float operator()(int featureIdx) CV_OVERRIDE
+    { return (float)features[featureIdx].calc( cur_sum ); }
+    virtual void writeFeatures( cv::FileStorage &fs, const cv::Mat& featureMap ) const CV_OVERRIDE;
+protected:
+    virtual void generateFeatures() CV_OVERRIDE;
+
+    class Feature
+    {
+    public:
+        Feature();
+        Feature( int offset, int x, int y, int _block_w, int _block_h  );
+        uchar calc( const cv::Mat& _sum );
+        void write( cv::FileStorage &fs ) const;
+
+        cv::Rect rect;
+        int p[16];
+
+        int x_, y_, block_w_, block_h_, offset_;
+        void calcPoints(int offset);
+    };
+    std::vector<Feature> features;
+
+    cv::Mat sum, cur_sum;
+    int offset_;
+};
+
+inline uchar CvLBPEvaluator::Feature::calc(const cv::Mat &_sum)
+{
+    const int* psum = _sum.ptr<int>();
+
+    int cval = psum[p[5]] - psum[p[6]] - psum[p[9]] + psum[p[10]];
+
+    return (uchar)((psum[p[0]] - psum[p[1]] - psum[p[4]] + psum[p[5]] >= cval ? 128 : 0) |   // 0
+        (psum[p[1]] - psum[p[2]] - psum[p[5]] + psum[p[6]] >= cval ? 64 : 0) |    // 1
+        (psum[p[2]] - psum[p[3]] - psum[p[6]] + psum[p[7]] >= cval ? 32 : 0) |    // 2
+        (psum[p[6]] - psum[p[7]] - psum[p[10]] + psum[p[11]] >= cval ? 16 : 0) |  // 5
+        (psum[p[10]] - psum[p[11]] - psum[p[14]] + psum[p[15]] >= cval ? 8 : 0) | // 8
+        (psum[p[9]] - psum[p[10]] - psum[p[13]] + psum[p[14]] >= cval ? 4 : 0) |  // 7
+        (psum[p[8]] - psum[p[9]] - psum[p[12]] + psum[p[13]] >= cval ? 2 : 0) |   // 6
+        (psum[p[4]] - psum[p[5]] - psum[p[8]] + psum[p[9]] >= cval ? 1 : 0));     // 3
+}
+
+}
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/precomp.hpp
new file mode 100644
index 00000000..cd454645
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/precomp.hpp
@@ -0,0 +1,72 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#ifndef __OPENCV_XOBJDETECT_PRECOMP_HPP__
+#define __OPENCV_XOBJDETECT_PRECOMP_HPP__
+
+#include <opencv2/xobjdetect.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/objdetect.hpp>
+
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <cmath>
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <cassert>
+#include <cstdio>
+
+#include "cascadeclassifier.h"
+#include "feature_evaluator.hpp"
+#include "lbpfeatures.h"
+#include "waldboost.hpp"
+#include "wbdetector.hpp"
+
+#endif /* __OPENCV_XOBJDETECT_PRECOMP_HPP__ */
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/waldboost.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/waldboost.cpp
new file mode 100644
index 00000000..9601755a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/waldboost.cpp
@@ -0,0 +1,454 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#include "precomp.hpp"
+
+namespace cv {
+namespace xobjdetect {
+
+static void compute_cdf(const Mat1b& data,
+                        const Mat1f& weights,
+                        Mat1f& cdf)
+{
+    for (int i = 0; i < cdf.cols; ++i)
+        cdf(0, i) = 0;
+
+    for (int i = 0; i < weights.cols; ++i) {
+        cdf(0, data(0, i)) += weights(0, i);
+    }
+
+    for (int i = 1; i < cdf.cols; ++i) {
+        cdf(0, i) += cdf(0, i - 1);
+    }
+}
+
+static void compute_min_step(const Mat &data_pos, const Mat &data_neg, size_t n_bins,
+                      Mat &data_min, Mat &data_step)
+{
+    // Check that quantized data will fit in unsigned char
+    assert(n_bins <= 256);
+
+    assert(data_pos.rows == data_neg.rows);
+
+    Mat reduced_pos, reduced_neg;
+
+    reduce(data_pos, reduced_pos, 1, REDUCE_MIN);
+    reduce(data_neg, reduced_neg, 1, REDUCE_MIN);
+    min(reduced_pos, reduced_neg, data_min);
+    data_min -= 0.01;
+
+    Mat data_max;
+    reduce(data_pos, reduced_pos, 1, REDUCE_MAX);
+    reduce(data_neg, reduced_neg, 1, REDUCE_MAX);
+    max(reduced_pos, reduced_neg, data_max);
+    data_max += 0.01;
+
+    data_step = (data_max - data_min) / (double)(n_bins - 1);
+}
+
+static void quantize_data(Mat &data, Mat1f &data_min, Mat1f &data_step)
+{
+//#pragma omp parallel for
+    for (int col = 0; col < data.cols; ++col) {
+        data.col(col) -= data_min;
+        data.col(col) /= data_step;
+    }
+    data.convertTo(data, CV_8U);
+}
+
+WaldBoost::WaldBoost(int weak_count):
+    weak_count_(weak_count),
+    thresholds_(),
+    alphas_(),
+    feature_indices_(),
+    polarities_(),
+    cascade_thresholds_() {}
+
+WaldBoost::WaldBoost():
+    weak_count_(),
+    thresholds_(),
+    alphas_(),
+    feature_indices_(),
+    polarities_(),
+    cascade_thresholds_() {}
+
+std::vector<int> WaldBoost::get_feature_indices()
+{
+    return feature_indices_;
+}
+
+void WaldBoost::detect(Ptr<CvFeatureEvaluator> eval,
+            const Mat& img, const std::vector<float>& scales,
+            std::vector<Rect>& bboxes, Mat1f& confidences)
+{
+    bboxes.clear();
+    confidences.release();
+
+    Mat resized_img;
+    int step = 4;
+    float h;
+    for (size_t i = 0; i < scales.size(); ++i) {
+        float scale = scales[i];
+        resize(img, resized_img, Size(), scale, scale, INTER_LINEAR_EXACT);
+        eval->setImage(resized_img, 0, 0, feature_indices_);
+        int n_rows = (int)(24 / scale);
+        int n_cols = (int)(24 / scale);
+        for (int r = 0; r + 24 < resized_img.rows; r += step) {
+            for (int c = 0; c + 24 < resized_img.cols; c += step) {
+                //eval->setImage(resized_img(Rect(c, r, 24, 24)), 0, 0);
+                eval->setWindow(Point(c, r));
+                if (predict(eval, &h) == +1) {
+                    int row = (int)(r / scale);
+                    int col = (int)(c / scale);
+                    bboxes.push_back(Rect(col, row, n_cols, n_rows));
+                    confidences.push_back(h);
+                }
+            }
+        }
+    }
+    groupRectangles(bboxes, 3, 0.7);
+}
+
+void WaldBoost::detect(Ptr<CvFeatureEvaluator> eval,
+            const Mat& img, const std::vector<float>& scales,
+            std::vector<Rect>& bboxes, std::vector<double>& confidences)
+{
+    bboxes.clear();
+    confidences.clear();
+
+    Mat resized_img;
+    int step = 4;
+    float h;
+    for (size_t i = 0; i < scales.size(); ++i) {
+        float scale = scales[i];
+        resize(img, resized_img, Size(), scale, scale, INTER_LINEAR_EXACT);
+        eval->setImage(resized_img, 0, 0, feature_indices_);
+        int n_rows = (int)(24 / scale);
+        int n_cols = (int)(24 / scale);
+        for (int r = 0; r + 24 < resized_img.rows; r += step) {
+            for (int c = 0; c + 24 < resized_img.cols; c += step) {
+                eval->setWindow(Point(c, r));
+                if (predict(eval, &h) == +1) {
+                    int row = (int)(r / scale);
+                    int col = (int)(c / scale);
+                    bboxes.push_back(Rect(col, row, n_cols, n_rows));
+                    confidences.push_back(h);
+                }
+            }
+        }
+    }
+    std::vector<int> levels(bboxes.size(), 0);
+    groupRectangles(bboxes, levels, confidences, 3, 0.7);
+}
+
+void WaldBoost::fit(Mat& data_pos, Mat& data_neg)
+{
+    // data_pos: F x N_pos
+    // data_neg: F x N_neg
+    // every feature corresponds to row
+    // every sample corresponds to column
+    assert(data_pos.rows >= weak_count_);
+    assert(data_pos.rows == data_neg.rows);
+
+    std::vector<bool> feature_ignore;
+    for (int i = 0; i < data_pos.rows; ++i) {
+        feature_ignore.push_back(false);
+    }
+
+    Mat1f pos_weights(1, data_pos.cols, 1.0f / (2 * data_pos.cols));
+    Mat1f neg_weights(1, data_neg.cols, 1.0f / (2 * data_neg.cols));
+    Mat1f pos_trace(1, data_pos.cols, 0.0f);
+    Mat1f neg_trace(1, data_neg.cols, 0.0f);
+
+    bool quantize = false;
+    if (data_pos.type() != CV_8U) {
+        std::cerr << "quantize" << std::endl;
+        quantize = true;
+    }
+
+    Mat1f data_min, data_step;
+    int n_bins = 256;
+    if (quantize) {
+        compute_min_step(data_pos, data_neg, n_bins, data_min, data_step);
+        quantize_data(data_pos, data_min, data_step);
+        quantize_data(data_neg, data_min, data_step);
+    }
+
+    std::cerr << "pos=" << data_pos.cols << " neg=" << data_neg.cols << std::endl;
+    for (int i = 0; i < weak_count_; ++i) {
+        // Train weak learner with lowest error using weights
+        double min_err = DBL_MAX;
+        int min_feature_ind = -1;
+        int min_polarity = 0;
+        int threshold_q = 0;
+        float min_threshold = 0;
+//#pragma omp parallel for
+        for (int feat_i = 0; feat_i < data_pos.rows; ++feat_i) {
+            if (feature_ignore[feat_i])
+                continue;
+
+            // Construct cdf
+            Mat1f pos_cdf(1, n_bins), neg_cdf(1, n_bins);
+            compute_cdf(data_pos.row(feat_i), pos_weights, pos_cdf);
+            compute_cdf(data_neg.row(feat_i), neg_weights, neg_cdf);
+
+            float neg_total = (float)sum(neg_weights)[0];
+            Mat1f err_direct = pos_cdf + neg_total - neg_cdf;
+            Mat1f err_backward = 1.0f - err_direct;
+
+            int idx1[2], idx2[2];
+            double err1, err2;
+            minMaxIdx(err_direct, &err1, NULL, idx1);
+            minMaxIdx(err_backward, &err2, NULL, idx2);
+//#pragma omp critical
+            {
+            if (min(err1, err2) < min_err) {
+                if (err1 < err2) {
+                    min_err = err1;
+                    min_polarity = +1;
+                    threshold_q = idx1[1];
+                } else {
+                    min_err = err2;
+                    min_polarity = -1;
+                    threshold_q = idx2[1];
+                }
+                min_feature_ind = feat_i;
+                if (quantize) {
+                    min_threshold = data_min(feat_i, 0) + data_step(feat_i, 0) *
+                        (threshold_q + .5f);
+                } else {
+                    min_threshold = threshold_q + .5f;
+                }
+            }
+            }
+        }
+
+
+        float alpha = .5f * (float)log((1 - min_err) / min_err);
+        alphas_.push_back(alpha);
+        feature_indices_.push_back(min_feature_ind);
+        thresholds_.push_back(min_threshold);
+        polarities_.push_back(min_polarity);
+        feature_ignore[min_feature_ind] = true;
+
+        double loss = 0;
+        // Update positive weights
+        for (int j = 0; j < data_pos.cols; ++j) {
+            int val = data_pos.at<unsigned char>(min_feature_ind, j);
+            int label = min_polarity * (val - threshold_q) >= 0 ? +1 : -1;
+            pos_weights(0, j) *= exp(-alpha * label);
+            pos_trace(0, j) += alpha * label;
+            loss += exp(-pos_trace(0, j)) / (2.0f * data_pos.cols);
+        }
+
+        // Update negative weights
+        for (int j = 0; j < data_neg.cols; ++j) {
+            int val = data_neg.at<unsigned char>(min_feature_ind, j);
+            int label = min_polarity * (val - threshold_q) >= 0 ? +1 : -1;
+            neg_weights(0, j) *= exp(alpha * label);
+            neg_trace(0, j) += alpha * label;
+            loss += exp(+neg_trace(0, j)) / (2.0f * data_neg.cols);
+        }
+        double cascade_threshold = -1;
+        minMaxIdx(pos_trace, &cascade_threshold);
+        cascade_thresholds_.push_back((float)cascade_threshold);
+
+        std::cerr << "i=" << std::setw(4) << i;
+        std::cerr << " feat=" << std::setw(5) << min_feature_ind;
+        std::cerr << " thr=" << std::setw(3) << threshold_q;
+        std::cerr << " casthr=" << std::fixed << std::setprecision(3)
+             << cascade_threshold;
+        std::cerr <<  " alpha=" << std::fixed << std::setprecision(3)
+             << alpha << " err=" << std::fixed << std::setprecision(3) << min_err
+             << " loss=" << std::scientific << loss << std::endl;
+
+        //int pos = 0;
+        //for (int j = 0; j < data_pos.cols; ++j) {
+        //    if (pos_trace(0, j) > cascade_threshold - 0.5) {
+        //        pos_trace(0, pos) = pos_trace(0, j);
+        //        data_pos.col(j).copyTo(data_pos.col(pos));
+        //        pos_weights(0, pos) = pos_weights(0, j);
+        //        pos += 1;
+        //    }
+        //}
+        //std::cerr << "pos " << data_pos.cols << "/" << pos << std::endl;
+        //pos_trace = pos_trace.colRange(0, pos);
+        //data_pos = data_pos.colRange(0, pos);
+        //pos_weights = pos_weights.colRange(0, pos);
+
+        int pos = 0;
+        for (int j = 0; j < data_neg.cols; ++j) {
+            if (neg_trace(0, j) > cascade_threshold - 0.5) {
+                neg_trace(0, pos) = neg_trace(0, j);
+                data_neg.col(j).copyTo(data_neg.col(pos));
+                neg_weights(0, pos) = neg_weights(0, j);
+                pos += 1;
+            }
+        }
+        std::cerr << "neg " << data_neg.cols << "/" << pos << std::endl;
+        neg_trace = neg_trace.colRange(0, pos);
+        data_neg = data_neg.colRange(0, pos);
+        neg_weights = neg_weights.colRange(0, pos);
+
+
+        if (loss < 1e-50 || min_err > 0.5) {
+            std::cerr << "Stopping early. loss=" << loss << " min_err=" << min_err << std::endl;
+            weak_count_ = i + 1;
+            break;
+        }
+
+        // Avoid crashing on next Mat creation
+        if (pos <= 1) {
+            std::cerr << "Stopping early. pos=" << pos << std::endl;
+            weak_count_ = i + 1;
+            break;
+        }
+
+        // Normalize weights
+        double z = (sum(pos_weights) + sum(neg_weights))[0];
+        pos_weights /= z;
+        neg_weights /= z;
+    }
+}
+
+int WaldBoost::predict(Ptr<CvFeatureEvaluator> eval, float *h) const
+{
+    assert(feature_indices_.size() == size_t(weak_count_));
+    assert(cascade_thresholds_.size() == size_t(weak_count_));
+    float res = 0;
+    int count = weak_count_;
+    for (int i = 0; i < count; ++i) {
+        float val = (*eval)(feature_indices_[i]);
+        int label = polarities_[i] * (val - thresholds_[i]) > 0 ? +1: -1;
+        res += alphas_[i] * label;
+        if (res < cascade_thresholds_[i]) {
+            return -1;
+        }
+    }
+    *h = res;
+    return res > cascade_thresholds_[count - 1] ? +1 : -1;
+}
+
+void WaldBoost::write(FileStorage &fs) const
+{
+    fs << "{";
+    fs << "waldboost_params"
+       << "{" << "weak_count" << weak_count_ << "}";
+
+    fs << "thresholds" << "[";
+    for (size_t i = 0; i < thresholds_.size(); ++i)
+        fs << thresholds_[i];
+    fs << "]";
+
+    fs << "alphas" << "[";
+    for (size_t i = 0; i < alphas_.size(); ++i)
+        fs << alphas_[i];
+    fs << "]";
+
+    fs << "polarities" << "[";
+    for (size_t i = 0; i < polarities_.size(); ++i)
+        fs << polarities_[i];
+    fs << "]";
+
+    fs << "cascade_thresholds" << "[";
+    for (size_t i = 0; i < cascade_thresholds_.size(); ++i)
+        fs << cascade_thresholds_[i];
+    fs << "]";
+
+    fs << "feature_indices" << "[";
+    for (size_t i = 0; i < feature_indices_.size(); ++i)
+        fs << feature_indices_[i];
+    fs << "]";
+
+    fs << "}";
+}
+
+void WaldBoost::read(const FileNode &node)
+{
+    weak_count_ = (int)(node["waldboost_params"]["weak_count"]);
+    thresholds_.resize(weak_count_);
+    alphas_.resize(weak_count_);
+    polarities_.resize(weak_count_);
+    cascade_thresholds_.resize(weak_count_);
+    feature_indices_.resize(weak_count_);
+
+    FileNodeIterator n;
+
+    n = node["thresholds"].begin();
+    for (int i = 0; i < weak_count_; ++i, ++n)
+        *n >> thresholds_[i];
+
+    n = node["alphas"].begin();
+    for (int i = 0; i < weak_count_; ++i, ++n)
+        *n >> alphas_[i];
+
+    n = node["polarities"].begin();
+    for (int i = 0; i < weak_count_; ++i, ++n)
+        *n >> polarities_[i];
+
+    n = node["cascade_thresholds"].begin();
+    for (int i = 0; i < weak_count_; ++i, ++n)
+        *n >> cascade_thresholds_[i];
+
+    n = node["feature_indices"].begin();
+    for (int i = 0; i < weak_count_; ++i, ++n)
+        *n >> feature_indices_[i];
+}
+
+void WaldBoost::reset(int weak_count)
+{
+    weak_count_ = weak_count;
+    thresholds_.clear();
+    alphas_.clear();
+    feature_indices_.clear();
+    polarities_.clear();
+    cascade_thresholds_.clear();
+}
+
+WaldBoost::~WaldBoost()
+{
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/waldboost.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/waldboost.hpp
new file mode 100644
index 00000000..9247619e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/waldboost.hpp
@@ -0,0 +1,94 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#ifndef __OPENCV_XOBJDETECT_WALDBOOST_HPP__
+#define __OPENCV_XOBJDETECT_WALDBOOST_HPP__
+
+#include "precomp.hpp"
+
+namespace cv {
+namespace xobjdetect {
+
+class WaldBoost {
+public:
+    WaldBoost(int weak_count);
+    WaldBoost();
+    std::vector<int> get_feature_indices();
+
+    void detect(Ptr<CvFeatureEvaluator> eval,
+                const Mat& img,
+                const std::vector<float>& scales,
+                std::vector<Rect>& bboxes,
+                Mat1f& confidences);
+
+    void detect(Ptr<CvFeatureEvaluator> eval,
+                const Mat& img,
+                const std::vector<float>& scales,
+                std::vector<Rect>& bboxes,
+                std::vector<double>& confidences);
+
+    void fit(Mat& data_pos, Mat& data_neg);
+    int predict(Ptr<CvFeatureEvaluator> eval, float *h) const;
+    void save(const std::string& filename);
+    void load(const std::string& filename);
+
+    void read(const FileNode &node);
+    void write(FileStorage &fs) const;
+
+    void reset(int weak_count);
+    ~WaldBoost();
+
+private:
+    int weak_count_;
+    std::vector<float> thresholds_;
+    std::vector<float> alphas_;
+    std::vector<int> feature_indices_;
+    std::vector<int> polarities_;
+    std::vector<float> cascade_thresholds_;
+};
+
+}
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/wbdetector.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/wbdetector.cpp
new file mode 100644
index 00000000..0add44ba
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/wbdetector.cpp
@@ -0,0 +1,222 @@
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+Copyright (C) 2015, Itseez Inc., all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+#include "precomp.hpp"
+
+using std::cerr;
+using std::endl;
+using std::vector;
+using std::string;
+
+namespace cv {
+namespace xobjdetect {
+
+static vector<Mat> sample_patches(
+        const string& path,
+        int n_rows,
+        int n_cols,
+        size_t n_patches)
+{
+    vector<String> filenames;
+    glob(path, filenames);
+    vector<Mat> patches;
+    size_t patch_count = 0;
+    for (size_t i = 0; i < filenames.size(); ++i) {
+        Mat img = imread(filenames[i], IMREAD_GRAYSCALE);
+        for (int row = 0; row + n_rows < img.rows; row += n_rows) {
+            for (int col = 0; col + n_cols < img.cols; col += n_cols) {
+                patches.push_back(img(Rect(col, row, n_cols, n_rows)).clone());
+                patch_count += 1;
+                if (patch_count == n_patches) {
+                    goto sampling_finished;
+                }
+            }
+        }
+    }
+sampling_finished:
+    return patches;
+}
+
+static vector<Mat> read_imgs(const string& path)
+{
+    vector<String> filenames;
+    glob(path, filenames);
+    vector<Mat> imgs;
+    for (size_t i = 0; i < filenames.size(); ++i) {
+        imgs.push_back(imread(filenames[i], IMREAD_GRAYSCALE));
+    }
+    return imgs;
+}
+
+void WBDetectorImpl::read(const FileNode& node)
+{
+    boost_.read(node);
+}
+
+
+void WBDetectorImpl::write(FileStorage &fs) const
+{
+    boost_.write(fs);
+}
+
+void WBDetectorImpl::train(
+    const string& pos_samples_path,
+    const string& neg_imgs_path)
+{
+
+    vector<Mat> pos_imgs = read_imgs(pos_samples_path);
+    vector<Mat> neg_imgs = sample_patches(neg_imgs_path, 24, 24, pos_imgs.size() * 10);
+
+    CV_Assert(pos_imgs.size());
+    CV_Assert(neg_imgs.size());
+
+    int n_features;
+    Mat pos_data, neg_data;
+
+    Ptr<CvFeatureEvaluator> eval = CvFeatureEvaluator::create();
+    eval->init(CvFeatureParams::create(), 1, Size(24, 24));
+    n_features = eval->getNumFeatures();
+
+    const int stages[] = {64, 128, 256, 512, 1024};
+    const int stage_count = sizeof(stages) / sizeof(*stages);
+    const int stage_neg = (int)(pos_imgs.size() * 5);
+    const int max_per_image = 100;
+
+    const float scales_arr[] = {.3f, .4f, .5f, .6f, .7f, .8f, .9f, 1.0f};
+    const vector<float> scales(scales_arr,
+            scales_arr + sizeof(scales_arr) / sizeof(*scales_arr));
+
+    vector<String> neg_filenames;
+    glob(neg_imgs_path, neg_filenames);
+
+
+    for (int i = 0; i < stage_count; ++i) {
+
+        cerr << "compute features" << endl;
+
+        pos_data = Mat1b(n_features, (int)pos_imgs.size());
+        neg_data = Mat1b(n_features, (int)neg_imgs.size());
+
+        for (size_t k = 0; k < pos_imgs.size(); ++k) {
+            eval->setImage(pos_imgs[k], +1, 0, boost_.get_feature_indices());
+            for (int j = 0; j < n_features; ++j) {
+                pos_data.at<uchar>(j, (int)k) = (uchar)(*eval)(j);
+            }
+        }
+
+        for (size_t k = 0; k < neg_imgs.size(); ++k) {
+            eval->setImage(neg_imgs[k], 0, 0, boost_.get_feature_indices());
+            for (int j = 0; j < n_features; ++j) {
+                neg_data.at<uchar>(j, (int)k) = (uchar)(*eval)(j);
+            }
+        }
+
+
+        boost_.reset(stages[i]);
+        boost_.fit(pos_data, neg_data);
+
+        if (i + 1 == stage_count) {
+            break;
+        }
+
+        int bootstrap_count = 0;
+        size_t img_i = 0;
+        for (; img_i < neg_filenames.size(); ++img_i) {
+            cerr << "win " << bootstrap_count << "/" << stage_neg
+                 << " img " << (img_i + 1) << "/" << neg_filenames.size() << "\r";
+            Mat img = imread(neg_filenames[img_i], IMREAD_GRAYSCALE);
+            vector<Rect> bboxes;
+            Mat1f confidences;
+            boost_.detect(eval, img, scales, bboxes, confidences);
+
+            if (confidences.rows > 0) {
+                Mat1i indices;
+                sortIdx(confidences, indices,
+                        SORT_EVERY_COLUMN + SORT_DESCENDING);
+
+                int win_count = min(max_per_image, confidences.rows);
+                win_count = min(win_count, stage_neg - bootstrap_count);
+                Mat window;
+                for (int k = 0; k < win_count; ++k) {
+                    resize(img(bboxes[indices(k, 0)]), window, Size(24, 24), 0, 0, INTER_LINEAR_EXACT);
+                    neg_imgs.push_back(window.clone());
+                    bootstrap_count += 1;
+                }
+                if (bootstrap_count >= stage_neg) {
+                    break;
+                }
+            }
+        }
+        cerr << "bootstrapped " << bootstrap_count << " windows from "
+             << (img_i + 1) << " images" << endl;
+    }
+}
+
+void WBDetectorImpl::detect(
+    const Mat& img,
+    vector<Rect> &bboxes,
+    vector<double> &confidences)
+{
+    Mat test_img = img.clone();
+    bboxes.clear();
+    confidences.clear();
+    vector<float> scales;
+    for (float scale = 0.2f; scale < 1.2f; scale *= 1.1f) {
+        scales.push_back(scale);
+    }
+    Ptr<CvFeatureParams> params = CvFeatureParams::create();
+    Ptr<CvFeatureEvaluator> eval = CvFeatureEvaluator::create();
+    eval->init(params, 1, Size(24, 24));
+    boost_.detect(eval, img, scales, bboxes, confidences);
+    CV_Assert(confidences.size() == bboxes.size());
+}
+
+Ptr<WBDetector>
+WBDetector::create()
+{
+    return Ptr<WBDetector>(new WBDetectorImpl());
+}
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/wbdetector.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/wbdetector.hpp
new file mode 100644
index 00000000..71972aae
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/src/wbdetector.hpp
@@ -0,0 +1,76 @@
+/*
+
+By downloading, copying, installing or using the software you agree to this
+license. If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+Third party copyrights are property of their respective owners.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall copyright holders or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+
+*/
+
+#ifndef __OPENCV_XOBJDETECT_DETECTOR_HPP__
+#define __OPENCV_XOBJDETECT_DETECTOR_HPP__
+
+#include <opencv2/core.hpp>
+#include <vector>
+#include <string>
+#include "precomp.hpp"
+
+namespace cv
+{
+namespace xobjdetect
+{
+
+class WBDetectorImpl CV_FINAL : public WBDetector {
+public:
+    virtual void read(const FileNode &node) CV_OVERRIDE;
+    virtual void write(FileStorage &fs) const CV_OVERRIDE;
+
+    virtual void train(
+        const std::string& pos_samples,
+        const std::string& neg_imgs) CV_OVERRIDE;
+
+    virtual void detect(
+        const Mat& img,
+        std::vector<Rect> &bboxes,
+        std::vector<double> &confidences) CV_OVERRIDE;
+
+private:
+    WaldBoost boost_;
+};
+
+} /* namespace xobjdetect */
+} /* namespace cv */
+
+#endif /* __OPENCV_XOBJDETECT_DETECTOR_HPP__ */
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/tools/CMakeLists.txt b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/tools/CMakeLists.txt
new file mode 100644
index 00000000..5c40af12
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/tools/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(waldboost_detector)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/tools/waldboost_detector/CMakeLists.txt b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/tools/waldboost_detector/CMakeLists.txt
new file mode 100644
index 00000000..8ed7eb6d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/tools/waldboost_detector/CMakeLists.txt
@@ -0,0 +1,34 @@
+set(name waldboost_detector)
+set(the_target opencv_${name})
+
+set(OPENCV_${the_target}_DEPS opencv_core opencv_imgproc opencv_imgcodecs opencv_videoio
+    opencv_highgui opencv_xobjdetect)
+
+ocv_check_dependencies(${OPENCV_${the_target}_DEPS})
+
+if(NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+project(${the_target})
+
+ocv_include_directories("${OpenCV_SOURCE_DIR}/include/opencv")
+ocv_include_modules_recurse(${OPENCV_${the_target}_DEPS})
+
+file(GLOB ${the_target}_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
+
+add_executable(${the_target} ${${the_target}_SOURCES})
+
+ocv_target_link_libraries(${the_target} ${OPENCV_${the_target}_DEPS})
+
+set_target_properties(${the_target} PROPERTIES
+                      DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+                      ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+                      RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+                      OUTPUT_NAME ${the_target})
+
+if(ENABLE_SOLUTION_FOLDERS)
+  set_target_properties(${the_target} PROPERTIES FOLDER "applications")
+endif()
+
+install(TARGETS ${the_target} OPTIONAL RUNTIME DESTINATION bin COMPONENT main)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/tools/waldboost_detector/waldboost_detector.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/tools/waldboost_detector/waldboost_detector.cpp
new file mode 100644
index 00000000..a10aa3c5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xobjdetect/tools/waldboost_detector/waldboost_detector.cpp
@@ -0,0 +1,46 @@
+#include "opencv2/xobjdetect.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+#include <cstdio>
+using namespace std;
+using namespace cv;
+using namespace cv::xobjdetect;
+
+int main(int argc, char **argv)
+{
+    if (argc < 5) {
+        cerr << "Usage: " << argv[0] << " train <model_filename> <pos_path> <neg_path>" << endl;
+        cerr << "       " << argv[0] << " detect <model_filename> <img_filename> <out_filename> <labelling_filename>" << endl;
+        return 0;
+    }
+
+    string mode = argv[1];
+    Ptr<WBDetector> detector = WBDetector::create();
+    if (mode == "train") {
+        assert(argc == 5);
+        detector->train(argv[3], argv[4]);
+        FileStorage fs(argv[2], FileStorage::WRITE);
+        fs << "waldboost";
+        detector->write(fs);
+    } else if (mode == "detect") {
+        assert(argc == 6);
+        vector<Rect> bboxes;
+        vector<double> confidences;
+        Mat img = imread(argv[3], IMREAD_GRAYSCALE);
+        FileStorage fs(argv[2], FileStorage::READ);
+        detector->read(fs.getFirstTopLevelNode());
+        detector->detect(img, bboxes, confidences);
+
+        FILE *fhandle = fopen(argv[5], "a");
+        for (size_t i = 0; i < bboxes.size(); ++i) {
+            Rect o = bboxes[i];
+            fprintf(fhandle, "%s;%u;%u;%u;%u;%lf\n",
+                argv[3], o.x, o.y, o.width, o.height, confidences[i]);
+        }
+        for (size_t i = 0; i < bboxes.size(); ++i) {
+            rectangle(img, bboxes[i], Scalar(255, 0, 0));
+        }
+        imwrite(argv[4], img);
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/CMakeLists.txt b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/CMakeLists.txt
new file mode 100644
index 00000000..b456ce38
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/CMakeLists.txt
@@ -0,0 +1,2 @@
+set(the_description "Addon to basic photo module")
+ocv_define_module(xphoto opencv_core opencv_imgproc opencv_photo WRAP python java objc)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/README.md b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/README.md
new file mode 100644
index 00000000..fc4aa885
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/README.md
@@ -0,0 +1,7 @@
+Additional photo processing algorithms
+======================================
+
+1. Color balance
+2. Denoising
+3. Inpainting
+
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/doc/xphoto.bib b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/doc/xphoto.bib
new file mode 100644
index 00000000..c888e374
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/doc/xphoto.bib
@@ -0,0 +1,77 @@
+@incollection{He2012,
+  title={Statistics of patch offsets for image completion},
+  author={He, Kaiming and Sun, Jian},
+  booktitle={Computer Vision--ECCV 2012},
+  pages={16--29},
+  year={2012},
+  publisher={Springer}
+}
+@inproceedings{Cheng2015,
+  title={Effective learning-based illuminant estimation using simple features},
+  author={Cheng, Dongliang and Price, Brian and Cohen, Scott and Brown, Michael S},
+  booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition},
+  pages={1000--1008},
+  year={2015}
+}
+@book{Holzmann1988,
+  title={Beyond Photography: The Digital Darkroom},
+  author={GerPublished by ard J. Holzmann},
+  publisher={Prentice Hall in 1988}
+}
+@inproceedings{DD02,
+  author = {Durand, Fr{\'e}do and Dorsey, Julie},
+  title = {Fast bilateral filtering for the display of high-dynamic-range images},
+  booktitle = {ACM Transactions on Graphics (TOG)},
+  year = {2002},
+  pages = {257--266},
+  volume = {21},
+  number = {3},
+  publisher = {ACM},
+  url = {https://www.researchgate.net/profile/Julie_Dorsey/publication/220184746_Fast_Bilateral_Filtering_for_the_Display_of_High_-_dynamic_-_range_Images/links/54566b000cf26d5090a95f96/Fast-Bilateral-Filtering-for-the-Display-of-High-dynamic-range-Images.pdf}
+}
+
+@INPROCEEDINGS{GenserPCS2018,
+   author={N. {Genser} and J. {Seiler} and F. {Schilling} and A. {Kaup}},
+   booktitle={Proc. Picture Coding Symposium (PCS)},
+   title={Signal and Loss Geometry Aware Frequency Selective Extrapolation for Error Concealment},
+   year={2018},
+   pages={159-163},
+   keywords={extrapolation;image reconstruction;video coding;loss geometry aware frequency selective extrapolation;error concealment;complex models;moderate computational complexity;Full HD image;error pattern;adjacent samples;undistorted samples;reconstruction parameters;processing order;High Efficiency Video Coding;content based partitioning;signal characteristics;block based frequency selective extrapolation;Image reconstruction;Extrapolation;Geometry;Partitioning algorithms;Task analysis;Computational modeling;Standards},
+   doi={10.1109/PCS.2018.8456259},
+   month={June},
+}
+
+@ARTICLE{SeilerTIP2015,
+   author={J. {Seiler} and M. {Jonscher} and M. {Schöberl} and A. {Kaup}},
+   journal={IEEE Transactions on Image Processing},
+   title={Resampling Images to a Regular Grid From a Non-Regular Subset of Pixel Positions Using Frequency Selective Reconstruction},
+   year={2015},
+   volume={24},
+   number={11},
+   pages={4540-4555},
+   keywords={Fourier transforms;image reconstruction;resampling images;regular grid;nonregular subset;pixel positions;frequency selective reconstruction;displaying image signals;image signal reconstruction algorithm;Fourier domain;optical transfer function;visual quality;peak signal-to-noise ratio;Image reconstruction;Signal processing algorithms;Reconstruction algorithms;Signal processing;Spatial resolution;;Image reconstruction;non-regular sampling;interpolation},
+   doi={10.1109/TIP.2015.2463084},
+   month={Nov},
+}
+
+@INPROCEEDINGS{GroscheICIP2018,
+   author={S. {Grosche} and J. {Seiler} and A. {Kaup}},
+   booktitle={Proc. 25th IEEE International Conference on Image Processing (ICIP)},
+   title={Iterative Optimization of Quarter Sampling Masks for Non-Regular Sampling Sensors},
+   year={2018},
+   pages={26-30},
+   keywords={extrapolation;image enhancement;image reconstruction;image resolution;image sampling;image sensors;interpolation;iterative methods;optimisation;regression analysis;iterative optimization;nonregular sampling sensors;iterative algorithm;arbitrary quarter sampling mask;reconstruction algorithms;random quarter sampling mask;optimized mask;frequency selective extrapolation;steering kernel regression;nearest neighbor interpolation;linear interpolation;regular imaging sensor;reconstruction quality;noise figure 0.31 dB to 0.68 dB;Image resolution;Image reconstruction;Sensors;Optimization;Energy resolution;Reconstruction algorithms;Image sensors;Non-Regular Sampling;Image reconstruction},
+   doi={10.1109/ICIP.2018.8451658},
+   month={Oct},
+}
+
+@INPROCEEDINGS{GroscheIST2018,
+   author={S. {Grosche} and J. {Seiler} and A. {Kaup}},
+   booktitle={Proc. IEEE International Conference on Imaging Systems and Techniques (IST)},
+   title={Design Techniques for Incremental Non-Regular Image Sampling Patterns},
+   year={2018},
+   pages={1-6},
+   keywords={image reconstruction;image resolution;image sampling;design techniques;incremental nonregular image sampling patterns;image signals;regular two dimensional grid;nonregular sampling patterns;sampling positions;random patterns;regular patterns;arbitrary sampling densities;incremental sampling patterns;sampling density;Image reconstruction;Scanning electron microscopy;Probability distribution;Atomic force microscopy;Reconstruction algorithms;Measurement by laser beam;Image Reconstruction;non-Regular Sampling},
+   doi={10.1109/IST.2018.8577090},
+   month={Oct},
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto.hpp
new file mode 100644
index 00000000..031fbb98
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto.hpp
@@ -0,0 +1,56 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_XPHOTO_HPP__
+#define __OPENCV_XPHOTO_HPP__
+
+/** @defgroup xphoto Additional photo processing algorithms
+*/
+
+#include "xphoto/inpainting.hpp"
+#include "xphoto/white_balance.hpp"
+#include "xphoto/dct_image_denoising.hpp"
+#include "xphoto/bm3d_image_denoising.hpp"
+#include "xphoto/oilpainting.hpp"
+#include "xphoto/tonemap.hpp"
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/bm3d_image_denoising.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/bm3d_image_denoising.hpp
new file mode 100644
index 00000000..5873f4c9
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/bm3d_image_denoising.hpp
@@ -0,0 +1,186 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BM3D_IMAGE_DENOISING_HPP__
+#define __OPENCV_BM3D_IMAGE_DENOISING_HPP__
+
+/** @file
+@date Jul 19, 2016
+@author Bartek Pawlik
+*/
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+    namespace xphoto
+    {
+        //! @addtogroup xphoto
+        //! @{
+
+        //! BM3D transform types
+        enum TransformTypes
+        {
+            /** Un-normalized Haar transform */
+            HAAR = 0
+        };
+
+        //! BM3D algorithm steps
+        enum Bm3dSteps
+        {
+            /** Execute all steps of the algorithm */
+            BM3D_STEPALL = 0,
+            /** Execute only first step of the algorithm */
+            BM3D_STEP1 = 1,
+            /** Execute only second step of the algorithm */
+            BM3D_STEP2 = 2
+        };
+
+        /** @brief Performs image denoising using the Block-Matching and 3D-filtering algorithm
+        <http://www.cs.tut.fi/~foi/GCF-BM3D/BM3D_TIP_2007.pdf> with several computational
+        optimizations. Noise expected to be a gaussian white noise.
+
+        @param src Input 8-bit or 16-bit 1-channel image.
+        @param dstStep1 Output image of the first step of BM3D with the same size and type as src.
+        @param dstStep2 Output image of the second step of BM3D with the same size and type as src.
+        @param h Parameter regulating filter strength. Big h value perfectly removes noise but also
+        removes image details, smaller h value preserves details but also preserves some noise.
+        @param templateWindowSize Size in pixels of the template patch that is used for block-matching.
+        Should be power of 2.
+        @param searchWindowSize Size in pixels of the window that is used to perform block-matching.
+        Affect performance linearly: greater searchWindowsSize - greater denoising time.
+        Must be larger than templateWindowSize.
+        @param blockMatchingStep1 Block matching threshold for the first step of BM3D (hard thresholding),
+        i.e. maximum distance for which two blocks are considered similar.
+        Value expressed in euclidean distance.
+        @param blockMatchingStep2 Block matching threshold for the second step of BM3D (Wiener filtering),
+        i.e. maximum distance for which two blocks are considered similar.
+        Value expressed in euclidean distance.
+        @param groupSize Maximum size of the 3D group for collaborative filtering.
+        @param slidingStep Sliding step to process every next reference block.
+        @param beta Kaiser window parameter that affects the sidelobe attenuation of the transform of the
+        window. Kaiser window is used in order to reduce border effects. To prevent usage of the window,
+        set beta to zero.
+        @param normType Norm used to calculate distance between blocks. L2 is slower than L1
+        but yields more accurate results.
+        @param step Step of BM3D to be executed. Possible variants are: step 1, step 2, both steps.
+        @param transformType Type of the orthogonal transform used in collaborative filtering step.
+        Currently only Haar transform is supported.
+
+        This function expected to be applied to grayscale images. Advanced usage of this function
+        can be manual denoising of colored image in different colorspaces.
+
+        @sa
+        fastNlMeansDenoising
+        */
+        CV_EXPORTS_W void bm3dDenoising(
+            InputArray src,
+            InputOutputArray dstStep1,
+            OutputArray dstStep2,
+            float h = 1,
+            int templateWindowSize = 4,
+            int searchWindowSize = 16,
+            int blockMatchingStep1 = 2500,
+            int blockMatchingStep2 = 400,
+            int groupSize = 8,
+            int slidingStep = 1,
+            float beta = 2.0f,
+            int normType = cv::NORM_L2,
+            int step = cv::xphoto::BM3D_STEPALL,
+            int transformType = cv::xphoto::HAAR);
+
+        /** @brief Performs image denoising using the Block-Matching and 3D-filtering algorithm
+        <http://www.cs.tut.fi/~foi/GCF-BM3D/BM3D_TIP_2007.pdf> with several computational
+        optimizations. Noise expected to be a gaussian white noise.
+
+        @param src Input 8-bit or 16-bit 1-channel image.
+        @param dst Output image with the same size and type as src.
+        @param h Parameter regulating filter strength. Big h value perfectly removes noise but also
+        removes image details, smaller h value preserves details but also preserves some noise.
+        @param templateWindowSize Size in pixels of the template patch that is used for block-matching.
+        Should be power of 2.
+        @param searchWindowSize Size in pixels of the window that is used to perform block-matching.
+        Affect performance linearly: greater searchWindowsSize - greater denoising time.
+        Must be larger than templateWindowSize.
+        @param blockMatchingStep1 Block matching threshold for the first step of BM3D (hard thresholding),
+        i.e. maximum distance for which two blocks are considered similar.
+        Value expressed in euclidean distance.
+        @param blockMatchingStep2 Block matching threshold for the second step of BM3D (Wiener filtering),
+        i.e. maximum distance for which two blocks are considered similar.
+        Value expressed in euclidean distance.
+        @param groupSize Maximum size of the 3D group for collaborative filtering.
+        @param slidingStep Sliding step to process every next reference block.
+        @param beta Kaiser window parameter that affects the sidelobe attenuation of the transform of the
+        window. Kaiser window is used in order to reduce border effects. To prevent usage of the window,
+        set beta to zero.
+        @param normType Norm used to calculate distance between blocks. L2 is slower than L1
+        but yields more accurate results.
+        @param step Step of BM3D to be executed. Allowed are only BM3D_STEP1 and BM3D_STEPALL.
+        BM3D_STEP2 is not allowed as it requires basic estimate to be present.
+        @param transformType Type of the orthogonal transform used in collaborative filtering step.
+        Currently only Haar transform is supported.
+
+        This function expected to be applied to grayscale images. Advanced usage of this function
+        can be manual denoising of colored image in different colorspaces.
+
+        @sa
+        fastNlMeansDenoising
+        */
+        CV_EXPORTS_W void bm3dDenoising(
+            InputArray src,
+            OutputArray dst,
+            float h = 1,
+            int templateWindowSize = 4,
+            int searchWindowSize = 16,
+            int blockMatchingStep1 = 2500,
+            int blockMatchingStep2 = 400,
+            int groupSize = 8,
+            int slidingStep = 1,
+            float beta = 2.0f,
+            int normType = cv::NORM_L2,
+            int step = cv::xphoto::BM3D_STEPALL,
+            int transformType = cv::xphoto::HAAR);
+        //! @}
+    }
+}
+
+#endif // __OPENCV_BM3D_IMAGE_DENOISING_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/dct_image_denoising.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/dct_image_denoising.hpp
new file mode 100644
index 00000000..bfb77fec
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/dct_image_denoising.hpp
@@ -0,0 +1,79 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_DCT_IMAGE_DENOISING_HPP__
+#define __OPENCV_DCT_IMAGE_DENOISING_HPP__
+
+/** @file
+@date Jun 26, 2014
+@author Yury Gitman
+*/
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace xphoto
+{
+
+//! @addtogroup xphoto
+//! @{
+
+    /** @brief The function implements simple dct-based denoising
+
+    <http://www.ipol.im/pub/art/2011/ys-dct/>.
+    @param src source image
+    @param dst destination image
+    @param sigma expected noise standard deviation
+    @param psize size of block side where dct is computed
+
+    @sa
+       fastNlMeansDenoising
+     */
+    CV_EXPORTS_W void dctDenoising(const Mat &src, Mat &dst, const double sigma, const int psize = 16);
+
+//! @}
+
+}
+}
+
+#endif // __OPENCV_DCT_IMAGE_DENOISING_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/inpainting.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/inpainting.hpp
new file mode 100644
index 00000000..cd71a9d8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/inpainting.hpp
@@ -0,0 +1,120 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//                       (3-clause BSD License)
+//
+// Copyright (C) 2000-2019, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+// Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * Neither the names of the copyright holders nor the names of the contributors
+//    may be used to endorse or promote products derived from this software
+//    without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_INPAINTING_HPP__
+#define __OPENCV_INPAINTING_HPP__
+
+/** @file
+@date Jul 22, 2014
+@author Yury Gitman
+*/
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace xphoto
+{
+
+//! @addtogroup xphoto
+//! @{
+
+    //! @brief Various inpainting algorithms
+    //! @sa inpaint
+    enum InpaintTypes
+    {
+        /** This algorithm searches for dominant correspondences (transformations) of
+        image patches and tries to seamlessly fill-in the area to be inpainted using this
+        transformations */
+        INPAINT_SHIFTMAP = 0,
+        /** Performs Frequency Selective Reconstruction (FSR).
+        One of the two quality profiles BEST and FAST can be chosen, depending on the time available for reconstruction.
+        See @cite GenserPCS2018 and @cite SeilerTIP2015 for details.
+
+        The algorithm may be utilized for the following areas of application:
+        1. %Error Concealment (Inpainting).
+           The sampling mask indicates the missing pixels of the distorted input
+           image to be reconstructed.
+        2. Non-Regular Sampling.
+           For more information on how to choose a good sampling mask, please review
+           @cite GroscheICIP2018 and @cite GroscheIST2018.
+
+        1-channel grayscale or 3-channel BGR image are accepted.
+
+        Conventional accepted ranges:
+        - 0-255 for CV_8U
+        - 0-65535 for CV_16U
+        - 0-1 for CV_32F/CV_64F.
+        */
+        INPAINT_FSR_BEST = 1,
+        INPAINT_FSR_FAST = 2                     //!< See #INPAINT_FSR_BEST
+    };
+
+    /** @brief The function implements different single-image inpainting algorithms.
+
+    See the original papers @cite He2012 (Shiftmap) or @cite GenserPCS2018 and @cite SeilerTIP2015 (FSR) for details.
+
+    @param src source image
+    - #INPAINT_SHIFTMAP: it could be of any type and any number of channels from 1 to 4. In case of
+    3- and 4-channels images the function expect them in CIELab colorspace or similar one, where first
+    color component shows intensity, while second and third shows colors. Nonetheless you can try any
+    colorspaces.
+    - #INPAINT_FSR_BEST or #INPAINT_FSR_FAST: 1-channel grayscale or 3-channel BGR image.
+    @param mask mask (#CV_8UC1), where non-zero pixels indicate valid image area, while zero pixels
+    indicate area to be inpainted
+    @param dst destination image
+    @param algorithmType see xphoto::InpaintTypes
+    */
+    CV_EXPORTS_W void inpaint(const Mat &src, const Mat &mask, Mat &dst, const int algorithmType);
+
+//! @}
+
+}
+}
+
+#endif // __OPENCV_INPAINTING_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/oilpainting.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/oilpainting.hpp
new file mode 100644
index 00000000..6d5c6cf1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/oilpainting.hpp
@@ -0,0 +1,41 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+
+#ifndef __OPENCV_OIL_PAINTING_HPP__
+#define __OPENCV_OIL_PAINTING_HPP__
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+
+namespace cv
+{
+namespace xphoto
+{
+
+//! @addtogroup xphoto
+//! @{
+
+/** @brief oilPainting
+See the book @cite Holzmann1988 for details.
+@param src Input three-channel or one channel image (either CV_8UC3 or CV_8UC1)
+@param dst Output image of the same size and type as src.
+@param size neighbouring size is 2-size+1
+@param dynRatio image is divided by dynRatio before histogram processing
+@param code	color space conversion code(see ColorConversionCodes). Histogram will used only first plane
+*/
+CV_EXPORTS_W void oilPainting(InputArray src, OutputArray dst, int size, int dynRatio, int code);
+/** @brief oilPainting
+See the book @cite Holzmann1988 for details.
+@param src Input three-channel or one channel image (either CV_8UC3 or CV_8UC1)
+@param dst Output image of the same size and type as src.
+@param size neighbouring size is 2-size+1
+@param dynRatio image is divided by dynRatio before histogram processing
+*/
+CV_EXPORTS_W void oilPainting(InputArray src, OutputArray dst, int size, int dynRatio);
+//! @}
+}
+}
+
+#endif // __OPENCV_OIL_PAINTING_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/tonemap.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/tonemap.hpp
new file mode 100644
index 00000000..9a69d390
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/tonemap.hpp
@@ -0,0 +1,56 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_XPHOTO_TONEMAP_HPP
+#define OPENCV_XPHOTO_TONEMAP_HPP
+
+#include "opencv2/photo.hpp"
+
+namespace cv { namespace xphoto {
+
+//! @addtogroup xphoto
+//! @{
+
+/** @brief This algorithm decomposes image into two layers: base layer and detail layer using bilateral filter
+and compresses contrast of the base layer thus preserving all the details.
+
+This implementation uses regular bilateral filter from OpenCV.
+
+Saturation enhancement is possible as in cv::TonemapDrago.
+
+For more information see @cite DD02 .
+ */
+class CV_EXPORTS_W TonemapDurand : public Tonemap
+{
+public:
+
+    CV_WRAP virtual float getSaturation() const = 0;
+    CV_WRAP virtual void setSaturation(float saturation) = 0;
+
+    CV_WRAP virtual float getContrast() const = 0;
+    CV_WRAP virtual void setContrast(float contrast) = 0;
+
+    CV_WRAP virtual float getSigmaSpace() const = 0;
+    CV_WRAP virtual void setSigmaSpace(float sigma_space) = 0;
+
+    CV_WRAP virtual float getSigmaColor() const = 0;
+    CV_WRAP virtual void setSigmaColor(float sigma_color) = 0;
+};
+
+/** @brief Creates TonemapDurand object
+
+You need to set the OPENCV_ENABLE_NONFREE option in cmake to use those. Use them at your own risk.
+
+@param gamma gamma value for gamma correction. See createTonemap
+@param contrast resulting contrast on logarithmic scale, i. e. log(max / min), where max and min
+are maximum and minimum luminance values of the resulting image.
+@param saturation saturation enhancement value. See createTonemapDrago
+@param sigma_color bilateral filter sigma in color space
+@param sigma_space bilateral filter sigma in coordinate space
+ */
+CV_EXPORTS_W Ptr<TonemapDurand>
+createTonemapDurand(float gamma = 1.0f, float contrast = 4.0f, float saturation = 1.0f, float sigma_color = 2.0f, float sigma_space = 2.0f);
+
+}} // namespace
+#endif  // OPENCV_XPHOTO_TONEMAP_HPP
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/white_balance.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/white_balance.hpp
new file mode 100644
index 00000000..1767f1f4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/include/opencv2/xphoto/white_balance.hpp
@@ -0,0 +1,230 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_SIMPLE_COLOR_BALANCE_HPP__
+#define __OPENCV_SIMPLE_COLOR_BALANCE_HPP__
+
+/** @file
+@date Jun 26, 2014
+@author Yury Gitman
+*/
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+namespace xphoto
+{
+
+//! @addtogroup xphoto
+//! @{
+
+/** @brief The base class for auto white balance algorithms.
+ */
+class CV_EXPORTS_W WhiteBalancer : public Algorithm
+{
+  public:
+    /** @brief Applies white balancing to the input image
+
+    @param src Input image
+    @param dst White balancing result
+    @sa cvtColor, equalizeHist
+    */
+    CV_WRAP virtual void balanceWhite(InputArray src, OutputArray dst) = 0;
+};
+
+/** @brief A simple white balance algorithm that works by independently stretching
+    each of the input image channels to the specified range. For increased robustness
+    it ignores the top and bottom \f$p\%\f$ of pixel values.
+ */
+class CV_EXPORTS_W SimpleWB : public WhiteBalancer
+{
+  public:
+    /** @brief Input image range minimum value
+    @see setInputMin */
+    CV_WRAP virtual float getInputMin() const = 0;
+    /** @copybrief getInputMin @see getInputMin */
+    CV_WRAP virtual void setInputMin(float val) = 0;
+
+    /** @brief Input image range maximum value
+    @see setInputMax */
+    CV_WRAP virtual float getInputMax() const = 0;
+    /** @copybrief getInputMax @see getInputMax */
+    CV_WRAP virtual void setInputMax(float val) = 0;
+
+    /** @brief Output image range minimum value
+    @see setOutputMin */
+    CV_WRAP virtual float getOutputMin() const = 0;
+    /** @copybrief getOutputMin @see getOutputMin */
+    CV_WRAP virtual void setOutputMin(float val) = 0;
+
+    /** @brief Output image range maximum value
+    @see setOutputMax */
+    CV_WRAP virtual float getOutputMax() const = 0;
+    /** @copybrief getOutputMax @see getOutputMax */
+    CV_WRAP virtual void setOutputMax(float val) = 0;
+
+    /** @brief Percent of top/bottom values to ignore
+    @see setP */
+    CV_WRAP virtual float getP() const = 0;
+    /** @copybrief getP @see getP */
+    CV_WRAP virtual void setP(float val) = 0;
+};
+
+/** @brief Creates an instance of SimpleWB
+ */
+CV_EXPORTS_W Ptr<SimpleWB> createSimpleWB();
+
+/** @brief Gray-world white balance algorithm
+
+This algorithm scales the values of pixels based on a
+gray-world assumption which states that the average of all channels
+should result in a gray image.
+
+It adds a modification which thresholds pixels based on their
+saturation value and only uses pixels below the provided threshold in
+finding average pixel values.
+
+Saturation is calculated using the following for a 3-channel RGB image per
+pixel I and is in the range [0, 1]:
+
+\f[ \texttt{Saturation} [I] = \frac{\textrm{max}(R,G,B) - \textrm{min}(R,G,B)
+}{\textrm{max}(R,G,B)} \f]
+
+A threshold of 1 means that all pixels are used to white-balance, while a
+threshold of 0 means no pixels are used. Lower thresholds are useful in
+white-balancing saturated images.
+
+Currently supports images of type @ref CV_8UC3 and @ref CV_16UC3.
+ */
+class CV_EXPORTS_W GrayworldWB : public WhiteBalancer
+{
+  public:
+    /** @brief Maximum saturation for a pixel to be included in the
+        gray-world assumption
+    @see setSaturationThreshold */
+    CV_WRAP virtual float getSaturationThreshold() const = 0;
+    /** @copybrief getSaturationThreshold @see getSaturationThreshold */
+    CV_WRAP virtual void setSaturationThreshold(float val) = 0;
+};
+
+/** @brief Creates an instance of GrayworldWB
+ */
+CV_EXPORTS_W Ptr<GrayworldWB> createGrayworldWB();
+
+/** @brief More sophisticated learning-based automatic white balance algorithm.
+
+As @ref GrayworldWB, this algorithm works by applying different gains to the input
+image channels, but their computation is a bit more involved compared to the
+simple gray-world assumption. More details about the algorithm can be found in
+@cite Cheng2015 .
+
+To mask out saturated pixels this function uses only pixels that satisfy the
+following condition:
+
+\f[ \frac{\textrm{max}(R,G,B)}{\texttt{range_max_val}} < \texttt{saturation_thresh} \f]
+
+Currently supports images of type @ref CV_8UC3 and @ref CV_16UC3.
+ */
+class CV_EXPORTS_W LearningBasedWB : public WhiteBalancer
+{
+  public:
+    /** @brief Implements the feature extraction part of the algorithm.
+
+    In accordance with @cite Cheng2015 , computes the following features for the input image:
+    1. Chromaticity of an average (R,G,B) tuple
+    2. Chromaticity of the brightest (R,G,B) tuple (while ignoring saturated pixels)
+    3. Chromaticity of the dominant (R,G,B) tuple (the one that has the highest value in the RGB histogram)
+    4. Mode of the chromaticity palette, that is constructed by taking 300 most common colors according to
+       the RGB histogram and projecting them on the chromaticity plane. Mode is the most high-density point
+       of the palette, which is computed by a straightforward fixed-bandwidth kernel density estimator with
+       a Epanechnikov kernel function.
+
+    @param src Input three-channel image (BGR color space is assumed).
+    @param dst An array of four (r,g) chromaticity tuples corresponding to the features listed above.
+    */
+    CV_WRAP virtual void extractSimpleFeatures(InputArray src, OutputArray dst) = 0;
+
+    /** @brief Maximum possible value of the input image (e.g. 255 for 8 bit images,
+               4095 for 12 bit images)
+    @see setRangeMaxVal */
+    CV_WRAP virtual int getRangeMaxVal() const = 0;
+    /** @copybrief getRangeMaxVal @see getRangeMaxVal */
+    CV_WRAP virtual void setRangeMaxVal(int val) = 0;
+
+    /** @brief Threshold that is used to determine saturated pixels, i.e. pixels where at least one of the
+        channels exceeds \f$\texttt{saturation_threshold}\times\texttt{range_max_val}\f$ are ignored.
+    @see setSaturationThreshold */
+    CV_WRAP virtual float getSaturationThreshold() const = 0;
+    /** @copybrief getSaturationThreshold @see getSaturationThreshold */
+    CV_WRAP virtual void setSaturationThreshold(float val) = 0;
+
+    /** @brief Defines the size of one dimension of a three-dimensional RGB histogram that is used internally
+        by the algorithm. It often makes sense to increase the number of bins for images with higher bit depth
+        (e.g. 256 bins for a 12 bit image).
+    @see setHistBinNum */
+    CV_WRAP virtual int getHistBinNum() const = 0;
+    /** @copybrief getHistBinNum @see getHistBinNum */
+    CV_WRAP virtual void setHistBinNum(int val) = 0;
+};
+
+/** @brief Creates an instance of LearningBasedWB
+
+@param path_to_model Path to a .yml file with the model. If not specified, the default model is used
+ */
+CV_EXPORTS_W Ptr<LearningBasedWB> createLearningBasedWB(const String& path_to_model = String());
+
+/** @brief Implements an efficient fixed-point approximation for applying channel gains, which is
+    the last step of multiple white balance algorithms.
+
+@param src Input three-channel image in the BGR color space (either CV_8UC3 or CV_16UC3)
+@param dst Output image of the same size and type as src.
+@param gainB gain for the B channel
+@param gainG gain for the G channel
+@param gainR gain for the R channel
+*/
+CV_EXPORTS_W void applyChannelGains(InputArray src, OutputArray dst, float gainB, float gainG, float gainR);
+//! @}
+}
+}
+
+#endif // __OPENCV_SIMPLE_COLOR_BALANCE_HPP__
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/misc/objc/gen_dict.json b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/misc/objc/gen_dict.json
new file mode 100644
index 00000000..1b9e54a4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/misc/objc/gen_dict.json
@@ -0,0 +1,5 @@
+{
+    "AdditionalImports" : {
+        "*" : [ "\"xphoto.hpp\"" ]
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_grayworld.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_grayworld.cpp
new file mode 100644
index 00000000..d5440823
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_grayworld.cpp
@@ -0,0 +1,34 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<Size, float> Size_WBThresh_t;
+typedef perf::TestBaseWithParam<Size_WBThresh_t> Size_WBThresh;
+
+PERF_TEST_P( Size_WBThresh, autowbGrayworld,
+    testing::Combine(
+        SZ_ALL_HD,
+        testing::Values( 0.1, 0.5, 1.0 )
+    )
+)
+{
+    Size size = get<0>(GetParam());
+    float wb_thresh = get<1>(GetParam());
+
+    Mat src(size, CV_8UC3);
+    Mat dst(size, CV_8UC3);
+
+    declare.in(src, WARMUP_RNG).out(dst);
+    Ptr<xphoto::GrayworldWB> wb = xphoto::createGrayworldWB();
+    wb->setSaturationThreshold(wb_thresh);
+
+    TEST_CYCLE() wb->balanceWhite(src, dst);
+
+    SANITY_CHECK(dst);
+}
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_learning_based_color_balance.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_learning_based_color_balance.cpp
new file mode 100644
index 00000000..794fdd10
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_learning_based_color_balance.cpp
@@ -0,0 +1,40 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<Size, MatType> learningBasedWBParams;
+typedef perf::TestBaseWithParam<learningBasedWBParams> learningBasedWBPerfTest;
+
+PERF_TEST_P(learningBasedWBPerfTest, perf, Combine(SZ_ALL_HD, Values(CV_8UC3, CV_16UC3)))
+{
+    Size size = get<0>(GetParam());
+    MatType t = get<1>(GetParam());
+    Mat src(size, t);
+    Mat dst(size, t);
+
+    int range_max_val = 255, hist_bin_num = 64;
+    if (t == CV_16UC3)
+    {
+        range_max_val = 65535;
+        hist_bin_num = 256;
+    }
+
+    Mat src_dscl(Size(size.width / 16, size.height / 16), t);
+    RNG rng(1234);
+    rng.fill(src_dscl, RNG::UNIFORM, 0, range_max_val);
+    resize(src_dscl, src, src.size(), 0, 0, INTER_LINEAR_EXACT);
+    Ptr<xphoto::LearningBasedWB> wb = xphoto::createLearningBasedWB();
+    wb->setRangeMaxVal(range_max_val);
+    wb->setSaturationThreshold(0.98f);
+    wb->setHistBinNum(hist_bin_num);
+
+    TEST_CYCLE() wb->balanceWhite(src, dst);
+
+    SANITY_CHECK_NOTHING();
+}
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_main.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_main.cpp
new file mode 100644
index 00000000..db11778a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_main.cpp
@@ -0,0 +1,6 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "perf_precomp.hpp"
+
+CV_PERF_TEST_MAIN(xphoto)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_precomp.hpp
new file mode 100644
index 00000000..cc4fd140
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/perf/perf_precomp.hpp
@@ -0,0 +1,10 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#ifndef __OPENCV_PERF_PRECOMP_HPP__
+#define __OPENCV_PERF_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/xphoto.hpp"
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/bm3d_image_denoising.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/bm3d_image_denoising.cpp
new file mode 100644
index 00000000..cc872d65
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/bm3d_image_denoising.cpp
@@ -0,0 +1,73 @@
+#include "opencv2/xphoto.hpp"
+#include "opencv2/highgui.hpp"
+
+const char* keys =
+{
+    "{i || input image name}"
+    "{o || output image name}"
+    "{sigma || expected noise standard deviation}"
+    "{tw |4| template window size}"
+    "{sw |16| search window size}"
+};
+
+int main(int argc, const char** argv)
+{
+    bool printHelp = (argc == 1);
+    printHelp = printHelp || (argc == 2 && std::string(argv[1]) == "--help");
+    printHelp = printHelp || (argc == 2 && std::string(argv[1]) == "-h");
+
+    if (printHelp)
+    {
+        printf("\nThis sample demonstrates BM3D image denoising\n"
+            "Call:\n"
+            "    bm3d_image_denoising -i=<string> -sigma=<double> -tw=<int> -sw=<int> [-o=<string>]\n\n");
+        return 0;
+    }
+
+    cv::CommandLineParser parser(argc, argv, keys);
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    std::string inFilename = parser.get<std::string>("i");
+    std::string outFilename = parser.get<std::string>("o");
+
+    cv::Mat src = cv::imread(inFilename, cv::IMREAD_GRAYSCALE);
+    if (src.empty())
+    {
+        printf("Cannot read image file: %s\n", inFilename.c_str());
+        return -1;
+    }
+
+    float sigma = parser.get<float>("sigma");
+    if (sigma == 0.0)
+        sigma = 15.0;
+
+    int templateWindowSize = parser.get<int>("tw");
+    if (templateWindowSize == 0)
+        templateWindowSize = 4;
+
+    int searchWindowSize = parser.get<int>("sw");
+    if (searchWindowSize == 0)
+        searchWindowSize = 16;
+
+    cv::Mat res(src.size(), src.type());
+    cv::xphoto::bm3dDenoising(src, res, sigma, templateWindowSize, searchWindowSize);
+
+    if (outFilename.empty())
+    {
+        cv::namedWindow("input image", cv::WINDOW_NORMAL);
+        cv::imshow("input image", src);
+        cv::namedWindow("denoising result", cv::WINDOW_NORMAL);
+        cv::imshow("denoising result", res);
+        cv::waitKey(0);
+    }
+    else
+    {
+        cv::imwrite(outFilename, res);
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/color_balance.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/color_balance.cpp
new file mode 100644
index 00000000..b33fe9d7
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/color_balance.cpp
@@ -0,0 +1,68 @@
+#include "opencv2/xphoto.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+using namespace std;
+
+const char *keys = { "{help h usage ? |         | print this message}"
+                     "{i              |         | input image name  }"
+                     "{o              |         | output image name }"
+                     "{a              |grayworld| color balance algorithm (simple, grayworld or learning_based)}"
+                     "{m              |         | path to the model for the learning-based algorithm (optional) }" };
+
+int main(int argc, const char **argv)
+{
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("OpenCV color balance demonstration sample");
+    if (parser.has("help") || argc < 2)
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    string inFilename = parser.get<string>("i");
+    string outFilename = parser.get<string>("o");
+    string algorithm = parser.get<string>("a");
+    string modelFilename = parser.get<string>("m");
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    Mat src = imread(inFilename, 1);
+    if (src.empty())
+    {
+        printf("Cannot read image file: %s\n", inFilename.c_str());
+        return -1;
+    }
+
+    Mat res;
+    Ptr<xphoto::WhiteBalancer> wb;
+    if (algorithm == "simple")
+        wb = xphoto::createSimpleWB();
+    else if (algorithm == "grayworld")
+        wb = xphoto::createGrayworldWB();
+    else if (algorithm == "learning_based")
+        wb = xphoto::createLearningBasedWB(modelFilename);
+    else
+    {
+        printf("Unsupported algorithm: %s\n", algorithm.c_str());
+        return -1;
+    }
+
+    wb->balanceWhite(src, res);
+
+    if (outFilename == "")
+    {
+        namedWindow("after white balance", 1);
+        imshow("after white balance", res);
+
+        waitKey(0);
+    }
+    else
+        imwrite(outFilename, res);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/color_balance_benchmark.py b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/color_balance_benchmark.py
new file mode 100644
index 00000000..cfc70239
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/color_balance_benchmark.py
@@ -0,0 +1,268 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import os, sys, argparse, json
+import numpy as np
+import scipy.io
+import cv2 as cv
+import timeit
+from learn_color_balance import load_ground_truth
+
+
+def load_json(path):
+    f = open(path, "r")
+    data = json.load(f)
+    return data
+
+
+def save_json(obj, path):
+    tmp_file = path + ".bak"
+    f = open(tmp_file, "w")
+    json.dump(obj, f, indent=2)
+    f.flush()
+    os.fsync(f.fileno())
+    f.close()
+    try:
+        os.rename(tmp_file, path)
+    except:
+        os.remove(path)
+        os.rename(tmp_file, path)
+
+
+def parse_sequence(input_str):
+    if len(input_str) == 0:
+        return []
+    else:
+        return [o.strip() for o in input_str.split(",") if o]
+
+
+def stretch_to_8bit(arr, clip_percentile = 2.5):
+    arr = np.clip(arr * (255.0 / np.percentile(arr, 100 - clip_percentile)), 0, 255)
+    return arr.astype(np.uint8)
+
+
+def evaluate(im, algo, gt_illuminant, i, range_thresh, bin_num, dst_folder, model_folder):
+    new_im = None
+    start_time = timeit.default_timer()
+    if algo=="grayworld":
+        inst = cv.xphoto.createGrayworldWB()
+        inst.setSaturationThreshold(0.95)
+        new_im = inst.balanceWhite(im)
+    elif algo=="nothing":
+        new_im = im
+    elif algo.split(":")[0]=="learning_based":
+        model_path = ""
+        if len(algo.split(":"))>1:
+            model_path = os.path.join(model_folder, algo.split(":")[1])
+        inst = cv.xphoto.createLearningBasedWB(model_path)
+        inst.setRangeMaxVal(range_thresh)
+        inst.setSaturationThreshold(0.98)
+        inst.setHistBinNum(bin_num)
+        new_im = inst.balanceWhite(im)
+    elif algo=="GT":
+        gains = gt_illuminant / min(gt_illuminant)
+        g1 = float(1.0 / gains[2])
+        g2 = float(1.0 / gains[1])
+        g3 = float(1.0 / gains[0])
+        new_im = cv.xphoto.applyChannelGains(im, g1, g2, g3)
+    time = 1000*(timeit.default_timer() - start_time) #time in ms
+
+    if len(dst_folder)>0:
+        if not os.path.exists(dst_folder):
+            os.makedirs(dst_folder)
+        im_name = ("%04d_" % i) + algo.replace(":","_") + ".jpg"
+        cv.imwrite(os.path.join(dst_folder, im_name), stretch_to_8bit(new_im))
+
+    #recover the illuminant from the color balancing result, assuming the standard model:
+    estimated_illuminant = [0, 0, 0]
+    eps = 0.01
+    estimated_illuminant[2] = np.percentile((im[:,:,0] + eps) / (new_im[:,:,0] + eps), 50)
+    estimated_illuminant[1] = np.percentile((im[:,:,1] + eps) / (new_im[:,:,1] + eps), 50)
+    estimated_illuminant[0] = np.percentile((im[:,:,2] + eps) / (new_im[:,:,2] + eps), 50)
+
+    res = np.arccos(np.dot(gt_illuminant,estimated_illuminant)/
+                   (np.linalg.norm(gt_illuminant) * np.linalg.norm(estimated_illuminant)))
+    return (time, (res / np.pi) * 180)
+
+
+def build_html_table(out, state, stat_list, img_range):
+    stat_dict = {'mean': ('Mean error', lambda arr: np.mean(arr)),
+                 'median': ('Median error',lambda arr: np.percentile(arr, 50)),
+                 'p05': ('5<sup>th</sup> percentile',lambda arr: np.percentile(arr, 5)),
+                 'p20': ('20<sup>th</sup> percentile',lambda arr: np.percentile(arr, 20)),
+                 'p80': ('80<sup>th</sup> percentile',lambda arr: np.percentile(arr, 80)),
+                 'p95': ('95<sup>th</sup> percentile',lambda arr: np.percentile(arr, 95))
+                }
+    html_out = ['<style type="text/css">\n',
+                '  html, body {font-family: Lucida Console, Courier New, Courier;font-size: 16px;color:#3e4758;}\n',
+                '  .tbl{background:none repeat scroll 0 0 #FFFFFF;border-collapse:collapse;font-family:"Lucida Sans Unicode","Lucida Grande",Sans-Serif;font-size:14px;margin:20px;text-align:left;width:480px;margin-left: auto;margin-right: auto;white-space:nowrap;}\n',
+                '  .tbl span{display:block;white-space:nowrap;}\n',
+                '  .tbl thead tr:last-child th {padding-bottom:5px;}\n',
+                '  .tbl tbody tr:first-child td {border-top:3px solid #6678B1;}\n',
+                '  .tbl th{border:none;color:#003399;font-size:16px;font-weight:normal;white-space:nowrap;padding:3px 10px;}\n',
+                '  .tbl td{border:none;border-bottom:1px solid #CCCCCC;color:#666699;padding:6px 8px;white-space:nowrap;}\n',
+                '  .tbl tbody tr:hover td{color:#000099;}\n',
+                '  .tbl caption{font:italic 16px "Trebuchet MS",Verdana,Arial,Helvetica,sans-serif;padding:0 0 5px;text-align:right;white-space:normal;}\n',
+                '  .firstingroup {border-top:2px solid #6678B1;}\n',
+                '</style>\n\n']
+
+    html_out += ['<table class="tbl">\n',
+                 '  <thead>\n',
+                 '    <tr>\n',
+                 '      <th align="center" valign="top"> Algorithm Name </th>\n',
+                 '      <th align="center" valign="top"> Average Time </th>\n']
+    for stat in stat_list:
+        if stat not in stat_dict.keys():
+            print("Error: unsupported statistic " + stat)
+            sys.exit(1)
+        html_out += ['      <th align="center" valign="top"> ' +
+                             stat_dict[stat][0] +
+                          ' </th>\n']
+    html_out += ['    </tr>\n',
+                 '  </thead>\n',
+                 '  <tbody>\n']
+
+    for algorithm in state.keys():
+        arr = [state[algorithm][file]["angular_error"] for file in state[algorithm].keys() if file>=img_range[0] and file<=img_range[1]]
+        average_time = "%.2f ms" % np.mean([state[algorithm][file]["time"] for file in state[algorithm].keys()
+                                                                           if file>=img_range[0] and file<=img_range[1]])
+        html_out += ['    <tr>\n',
+                     '      <td>' + algorithm + '</td>\n',
+                     '      <td>' + average_time + '</td>\n']
+        for stat in stat_list:
+            html_out += ['      <td> ' +
+                                 "%.2f&deg" % stat_dict[stat][1](arr) +
+                             ' </td>\n']
+        html_out += ['    </tr>\n']
+    html_out += ['  </tbody>\n',
+                 '</table>\n']
+    f = open(out, 'w')
+    f.writelines(html_out)
+    f.close()
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description=("A benchmarking script for color balance algorithms"),
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument(
+        "-a",
+        "--algorithms",
+        metavar="ALGORITHMS",
+        default="",
+        help=("Comma-separated list of color balance algorithms to evaluate. "
+              "Currently available: GT,learning_based,grayworld,nothing. "
+              "Use a colon to set a specific model for the learning-based "
+              "algorithm, e.g. learning_based:model1.yml,learning_based:model2.yml"))
+    parser.add_argument(
+        "-i",
+        "--input_folder",
+        metavar="INPUT_FOLDER",
+        default="",
+        help=("Folder containing input images to evaluate on. Assumes minimally "
+              "processed png images like in the Gehler-Shi (http://www.cs.sfu.ca/~colour/data/shi_gehler/) "
+              "or NUS 8-camera (http://www.comp.nus.edu.sg/~whitebal/illuminant/illuminant.html) datasets"))
+    parser.add_argument(
+        "-g",
+        "--ground_truth",
+        metavar="GROUND_TRUTH",
+        default="real_illum_568..mat",
+        help=("Path to the mat file containing ground truth illuminations. Currently "
+              "supports formats supplied by the Gehler-Shi and NUS 8-camera datasets."))
+    parser.add_argument(
+        "-o",
+        "--out",
+        metavar="OUT",
+        default="./white_balance_eval_result.html",
+        help="Path to the output html table")
+    parser.add_argument(
+        "-s",
+        "--state",
+        metavar="STATE_JSON",
+        default="./WB_evaluation_state.json",
+        help=("Path to a json file that stores the current evaluation state"))
+    parser.add_argument(
+        "-t",
+        "--stats",
+        metavar="STATS",
+        default="mean,median,p05,p20,p80,p95",
+        help=("Comma-separated list of error statistics to compute and list "
+              "in the output table. All the available ones are used by default"))
+    parser.add_argument(
+        "-b",
+        "--input_bit_depth",
+        metavar="INPUT_BIT_DEPTH",
+        default="",
+        help=("Assumed bit depth for input images. Should be specified in order to "
+              "use full bit depth for evaluation (for instance, -b 12 for 12 bit images). "
+              "Otherwise, input images are converted to 8 bit prior to the evaluation."))
+    parser.add_argument(
+        "-d",
+        "--dst_folder",
+        metavar="DST_FOLDER",
+        default="",
+        help=("If specified, this folder will be used to store the color correction results"))
+    parser.add_argument(
+        "-r",
+        "--range",
+        metavar="RANGE",
+        default="0,0",
+        help=("Comma-separated range of images from the dataset to evaluate on (for instance: 0,568). "
+              "All available images are used by default."))
+    parser.add_argument(
+        "-m",
+        "--model_folder",
+        metavar="MODEL_FOLDER",
+        default="",
+        help=("Path to the folder containing models for the learning-based color balance algorithm (optional)"))
+    args, other_args = parser.parse_known_args()
+
+    if not os.path.exists(args.input_folder):
+        print("Error: " + args.input_folder + (" does not exist. Please, correctly "
+                                                 "specify the -i parameter"))
+        sys.exit(1)
+
+    if not os.path.exists(args.ground_truth):
+        print("Error: " + args.ground_truth + (" does not exist. Please, correctly "
+                                                 "specify the -g parameter"))
+        sys.exit(1)
+
+    state = {}
+    if os.path.isfile(args.state):
+        state = load_json(args.state)
+
+    algorithm_list = parse_sequence(args.algorithms)
+    img_range = list(map(int, parse_sequence(args.range)))
+    if len(img_range)!=2:
+        print("Error: Please specify the -r parameter in form <first_image_index>,<last_image_index>")
+        sys.exit(1)
+
+    img_files = sorted(os.listdir(args.input_folder))
+    (gt_illuminants,black_levels) = load_ground_truth(args.ground_truth)
+
+    for algorithm in algorithm_list:
+        i = 0
+        if algorithm not in state.keys():
+            state[algorithm] = {}
+        sz = len(img_files)
+        for file in img_files:
+            if file not in state[algorithm].keys() and\
+             ((i>=img_range[0] and i<img_range[1]) or img_range[0]==img_range[1]==0):
+                cur_path = os.path.join(args.input_folder, file)
+                im = cv.imread(cur_path, -1).astype(np.float32)
+                im -= black_levels[i]
+                range_thresh = 255
+                if len(args.input_bit_depth)>0:
+                    range_thresh = 2**int(args.input_bit_depth) - 1
+                    im = np.clip(im, 0, range_thresh).astype(np.uint16)
+                else:
+                    im = stretch_to_8bit(im)
+
+                (time,angular_err) = evaluate(im, algorithm, gt_illuminants[i], i, range_thresh,
+                                              256 if range_thresh > 255 else 64, args.dst_folder, args.model_folder)
+                state[algorithm][file] = {"angular_error": angular_err, "time": time}
+                sys.stdout.write("Algorithm: %-20s Done: [%3d/%3d]\r" % (algorithm, i, sz)),
+                sys.stdout.flush()
+                save_json(state, args.state)
+            i+=1
+    save_json(state, args.state)
+    build_html_table(args.out, state, parse_sequence(args.stats), [img_files[img_range[0]], img_files[img_range[1]-1]])
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/dct_image_denoising.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/dct_image_denoising.cpp
new file mode 100644
index 00000000..e305a23e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/dct_image_denoising.cpp
@@ -0,0 +1,70 @@
+#include "opencv2/xphoto.hpp"
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc/types_c.h"
+
+const char* keys =
+{
+    "{i || input image name}"
+    "{o || output image name}"
+    "{sigma || expected noise standard deviation}"
+    "{psize |16| expected noise standard deviation}"
+};
+
+int main( int argc, const char** argv )
+{
+    bool printHelp = ( argc == 1 );
+    printHelp = printHelp || ( argc == 2 && std::string(argv[1]) == "--help" );
+    printHelp = printHelp || ( argc == 2 && std::string(argv[1]) == "-h" );
+
+    if ( printHelp )
+    {
+        printf("\nThis sample demonstrates dct-based image denoising\n"
+            "Call:\n"
+            "    dct_image_denoising -i=<string> -sigma=<double> -psize=<int> [-o=<string>]\n\n");
+        return 0;
+    }
+
+    cv::CommandLineParser parser(argc, argv, keys);
+    if ( !parser.check() )
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    std::string inFilename = parser.get<std::string>("i");
+    std::string outFilename = parser.get<std::string>("o");
+
+    cv::Mat src = cv::imread(inFilename, 1);
+    if ( src.empty() )
+    {
+        printf("Cannot read image file: %s\n", inFilename.c_str());
+        return -1;
+    }
+
+	double sigma = parser.get<double>("sigma");
+	if (sigma == 0.0)
+		sigma = 15.0;
+
+    int psize = parser.get<int>("psize");
+    if (psize == 0)
+        psize = 16;
+
+    cv::Mat res(src.size(), src.type());
+    cv::xphoto::dctDenoising(src, res, sigma, psize);
+
+    if ( outFilename == "" )
+    {
+        cv::namedWindow("denoising result", 1);
+        cv::imshow("denoising result", res);
+
+        cv::waitKey(0);
+    }
+    else
+        cv::imwrite(outFilename, res);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/inpainting.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/inpainting.cpp
new file mode 100644
index 00000000..5c07fe0b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/inpainting.cpp
@@ -0,0 +1,78 @@
+#include "opencv2/xphoto.hpp"
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <ctime>
+#include <iostream>
+
+const char* keys =
+{
+    "{i || input image name}"
+    "{m || mask image name}"
+    "{o || output image name}"
+};
+
+int main( int argc, const char** argv )
+{
+    bool printHelp = ( argc == 1 );
+    printHelp = printHelp || ( argc == 2 && std::string(argv[1]) == "--help" );
+    printHelp = printHelp || ( argc == 2 && std::string(argv[1]) == "-h" );
+
+    if ( printHelp )
+    {
+        printf("\nThis sample demonstrates shift-map image inpainting\n"
+            "Call:\n"
+            "    inpainting -i=<string> -m=<string> [-o=<string>]\n\n");
+        return 0;
+    }
+
+    cv::CommandLineParser parser(argc, argv, keys);
+    if ( !parser.check() )
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    std::string inFilename = parser.get<std::string>("i");
+    std::string maskFilename = parser.get<std::string>("m");
+    std::string outFilename = parser.get<std::string>("o");
+
+    cv::Mat src = cv::imread(inFilename, cv::IMREAD_UNCHANGED);
+    if ( src.empty() )
+    {
+        printf( "Cannot read image file: %s\n", inFilename.c_str() );
+        return -1;
+    }
+
+    cv::cvtColor(src, src, cv::COLOR_BGR2Lab);
+
+    cv::Mat mask = cv::imread(maskFilename, cv::IMREAD_GRAYSCALE);
+    if ( mask.empty() )
+    {
+        printf( "Cannot read image file: %s\n", maskFilename.c_str() );
+        return -1;
+    }
+    cv::threshold(mask, mask, 128, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
+
+    cv::Mat res(src.size(), src.type());
+
+    int time = clock();
+    cv::xphoto::inpaint( src, mask, res, cv::xphoto::INPAINT_SHIFTMAP );
+    std::cout << "time = " << (clock() - time)
+        / double(CLOCKS_PER_SEC) << std::endl;
+
+    cv::cvtColor(res, res, cv::COLOR_Lab2BGR);
+
+    if ( outFilename == "" )
+    {
+        cv::namedWindow("inpainting result", 1);
+        cv::imshow("inpainting result", res);
+
+        cv::waitKey(0);
+    }
+    else
+        cv::imwrite(outFilename, res);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/learn_color_balance.py b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/learn_color_balance.py
new file mode 100644
index 00000000..bd67611e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/learn_color_balance.py
@@ -0,0 +1,290 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import os, sys, argparse
+import numpy as np
+import scipy.io
+from sklearn.tree import DecisionTreeRegressor
+import cv2 as cv
+import random
+
+
+def parse_sequence(input_str):
+    if len(input_str) == 0:
+        return []
+    else:
+        return [o.strip() for o in input_str.split(",") if o]
+
+
+def convert_to_8bit(arr, clip_percentile = 2.5):
+    arr = np.clip(arr * (255.0 / np.percentile(arr, 100 - clip_percentile)), 0, 255)
+    return arr.astype(np.uint8)
+
+
+def learn_regression_tree_ensemble(img_features, gt_illuminants, num_trees, max_tree_depth):
+    eps = 0.001
+    inst = [[img_features[i], gt_illuminants[i][0] / (sum(gt_illuminants[i]) + eps),
+                              gt_illuminants[i][1] / (sum(gt_illuminants[i]) + eps)] for i in range(len(img_features))]
+
+    inst.sort(key = lambda obj: obj[1]) #sort by r chromaticity
+    stride = int(np.ceil(len(inst) / float(num_trees+1)))
+    sz = 2*stride
+    dst_model = []
+    for tree_idx in range(num_trees):
+        #local group in the training data is additionally weighted by num_trees
+        local_group_range = range(tree_idx*stride, min(tree_idx*stride+sz, len(inst)))
+        X = num_trees * [inst[i][0] for i in local_group_range]
+        y_r = num_trees * [inst[i][1] for i in local_group_range]
+        y_g = num_trees * [inst[i][2] for i in local_group_range]
+
+        #add the rest of the training data:
+        X = X + [inst[i][0] for i in range(len(inst)) if i not in local_group_range]
+        y_r = y_r + [inst[i][1] for i in range(len(inst)) if i not in local_group_range]
+        y_g = y_g + [inst[i][2] for i in range(len(inst)) if i not in local_group_range]
+
+        local_model = []
+        for feature_idx in range(len(X[0])):
+            tree_r = DecisionTreeRegressor(max_depth = max_tree_depth, random_state = 1234)
+            tree_r.fit([el[feature_idx][0] for el in X], y_r)
+            tree_g = DecisionTreeRegressor(max_depth = max_tree_depth, random_state = 1234)
+            tree_g.fit([el[feature_idx][0] for el in X], y_g)
+            local_model.append([tree_r, tree_g])
+        dst_model.append(local_model)
+    return dst_model
+
+
+def get_tree_node_lists(tree, tree_depth):
+    dst_feature_idx = (2**tree_depth-1) * [0]
+    dst_thresh_vals = (2**tree_depth-1) * [.5]
+    dst_leaf_vals   = (2**tree_depth) * [-1]
+    leaf_idx_offset = (2**tree_depth-1)
+    left      = tree.tree_.children_left
+    right     = tree.tree_.children_right
+    threshold = tree.tree_.threshold
+    value = tree.tree_.value
+    feature = tree.tree_.feature
+
+    def recurse(left, right, threshold, feature, node, dst_idx, cur_depth):
+        if (threshold[node] != -2):
+            dst_feature_idx[dst_idx] = feature[node]
+            dst_thresh_vals[dst_idx] = threshold[node]
+            if left[node] != -1:
+                recurse (left, right, threshold, feature, left[node], 2*dst_idx+1, cur_depth + 1)
+            if right[node] != -1:
+                recurse (left, right, threshold, feature, right[node], 2*dst_idx+2, cur_depth + 1)
+        else:
+            range_start = 2**(tree_depth - cur_depth) * dst_idx + (2**(tree_depth - cur_depth) - 1) - leaf_idx_offset
+            range_end = 2**(tree_depth - cur_depth) * dst_idx + (2**(tree_depth - cur_depth+1) - 2) - leaf_idx_offset + 1
+            dst_leaf_vals[range_start:range_end] = (range_end - range_start) * [value[node][0][0]]
+
+    recurse(left, right, threshold, feature, 0, 0, 0)
+    return (dst_feature_idx, dst_thresh_vals, dst_leaf_vals)
+
+
+def generate_code(model, input_params, use_YML, out_file):
+    feature_idx = []
+    thresh_vals = []
+    leaf_vals = []
+    depth = int(input_params["--max_tree_depth"])
+    for local_model in model:
+        for feature in local_model:
+            (local_feature_idx, local_thresh_vals, local_leaf_vals) = get_tree_node_lists(feature[0], depth)
+            feature_idx += local_feature_idx
+            thresh_vals += local_thresh_vals
+            leaf_vals += local_leaf_vals
+            (local_feature_idx, local_thresh_vals, local_leaf_vals) = get_tree_node_lists(feature[1], depth)
+            feature_idx += local_feature_idx
+            thresh_vals += local_thresh_vals
+            leaf_vals += local_leaf_vals
+    if use_YML:
+        fs = cv.FileStorage(out_file, 1)
+        fs.write("num_trees", len(model))
+        fs.write("num_tree_nodes", 2**depth)
+        fs.write("feature_idx", np.array(feature_idx).astype(np.uint8))
+        fs.write("thresh_vals", np.array(thresh_vals).astype(np.float32))
+        fs.write("leaf_vals", np.array(leaf_vals).astype(np.float32))
+        fs.release()
+    else:
+        res = "/* This file was automatically generated by learn_color_balance.py script\n" +\
+              " * using the following parameters:\n"
+        for key in input_params:
+            res += " " + key + " " + input_params[key]
+        res += "\n */\n"
+        res += "const int num_features = 4;\n"
+        res += "const int _num_trees = " + str(len(model)) + ";\n"
+        res += "const int _num_tree_nodes = " + str(2**depth) + ";\n"
+
+        res += "unsigned char _feature_idx[_num_trees*num_features*2*(_num_tree_nodes-1)] = {" + str(feature_idx[0])
+        for i in range(1,len(feature_idx)):
+            res += "," + str(feature_idx[i])
+        res += "};\n"
+
+        res += "float _thresh_vals[_num_trees*num_features*2*(_num_tree_nodes-1)] = {" + ("%.3ff" % thresh_vals[0])[1:]
+        for i in range(1,len(thresh_vals)):
+            res += "," + ("%.3ff" % thresh_vals[i])[1:]
+        res += "};\n"
+
+        res += "float _leaf_vals[_num_trees*num_features*2*_num_tree_nodes] = {" + ("%.3ff" % leaf_vals[0])[1:]
+        for i in range(1,len(leaf_vals)):
+            res += "," + ("%.3ff" % leaf_vals[i])[1:]
+        res += "};\n"
+        f = open(out_file,"w")
+        f.write(res)
+        f.close()
+
+
+def load_ground_truth(gt_path):
+    gt = scipy.io.loadmat(gt_path)
+    base_gt_illuminants = []
+    black_levels = []
+    if "groundtruth_illuminants" in gt.keys() and "darkness_level" in gt.keys():
+        #NUS 8-camera dataset format
+        base_gt_illuminants = gt["groundtruth_illuminants"]
+        black_levels = len(base_gt_illuminants) * [gt["darkness_level"][0][0]]
+    elif "real_rgb" in gt.keys():
+        #Gehler-Shi dataset format
+        base_gt_illuminants = gt["real_rgb"]
+        black_levels = 87 * [0] + (len(base_gt_illuminants) - 87) * [129]
+    else:
+        print("Error: unknown ground-truth format, only formats of Gehler-Shi and NUS 8-camera datasets are supported")
+        sys.exit(1)
+
+    return (base_gt_illuminants, black_levels)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description=("A tool for training the learning-based "
+                     "color balance algorithm. Currently supports "
+                     "training only on the Gehler-Shi and NUS 8-camera datasets."),
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument(
+        "-i",
+        "--input_folder",
+        metavar="INPUT_FOLDER",
+        default="",
+        help=("Folder containing the training dataset. Assumes minimally "
+              "processed png images like in the Gehler-Shi (http://www.cs.sfu.ca/~colour/data/shi_gehler/) "
+              "or NUS 8-camera (http://www.comp.nus.edu.sg/~whitebal/illuminant/illuminant.html) datasets"))
+    parser.add_argument(
+        "-g",
+        "--ground_truth",
+        metavar="GROUND_TRUTH",
+        default="real_illum_568..mat",
+        help=("Path to the mat file containing ground truth illuminations. Currently "
+              "supports formats supplied by the Gehler-Shi and NUS 8-camera datasets."))
+    parser.add_argument(
+        "-r",
+        "--range",
+        metavar="RANGE",
+        default="0,0",
+        help="Range of images from the input dataset to use for training")
+    parser.add_argument(
+        "-o",
+        "--out",
+        metavar="OUT",
+        default="color_balance_model.yml",
+        help="Path to the output learnt model. Either a .yml (for loading during runtime) "
+             "or .hpp (for compiling with the main code) file ")
+    parser.add_argument(
+        "--hist_bin_num",
+        metavar="HIST_BIN_NUM",
+        default="64",
+        help=("Size of one dimension of a three-dimensional RGB histogram employed in the "
+              "feature extraction step."))
+    parser.add_argument(
+        "--num_trees",
+        metavar="NUM_TREES",
+        default="20",
+        help=("Parameter to control the size of the regression tree ensemble"))
+    parser.add_argument(
+        "--max_tree_depth",
+        metavar="MAX_TREE_DEPTH",
+        default="4",
+        help=("Maxmimum depth of regression trees constructed during training."))
+    parser.add_argument(
+        "-a",
+        "--num_augmented",
+        metavar="NUM_AUGMENTED",
+        default="2",
+        help=("Number of augmented samples per one training image. Training set "
+              "augmentation tends to improve the learnt model robustness."))
+
+    args, other_args = parser.parse_known_args()
+
+    if not os.path.exists(args.input_folder):
+        print("Error: " + args.input_folder + (" does not exist. Please, correctly "
+                                                 "specify the -i parameter"))
+        sys.exit(1)
+
+    if not os.path.exists(args.ground_truth):
+        print("Error: " + args.ground_truth + (" does not exist. Please, correctly "
+                                                 "specify the -g parameter"))
+        sys.exit(1)
+
+    img_range = list(map(int,parse_sequence(args.range)))
+    if len(img_range)!=2:
+        print("Error: Please specify the -r parameter in form <first_image_index>,<last_image_index>")
+        sys.exit(1)
+
+    use_YML = None
+    if args.out.endswith(".yml"):
+        use_YML = True
+    elif args.out.endswith(".hpp"):
+        use_YML = False
+    else:
+        print("Error: Only .hpp and .yml are supported as output formats")
+        sys.exit(1)
+
+    hist_bin_num = int(args.hist_bin_num)
+    num_trees = int(args.num_trees)
+    max_tree_depth = int(args.max_tree_depth)
+    img_files = sorted(os.listdir(args.input_folder))
+    (base_gt_illuminants,black_levels) = load_ground_truth(args.ground_truth)
+
+    features = []
+    gt_illuminants = []
+    i=0
+    sz = len(img_files)
+    random.seed(1234)
+    inst = cv.xphoto.createLearningBasedWB()
+    inst.setRangeMaxVal(255)
+    inst.setSaturationThreshold(0.98)
+    inst.setHistBinNum(hist_bin_num)
+    for file in img_files:
+        if (i>=img_range[0] and i<img_range[1]) or (img_range[0]==img_range[1]==0):
+            cur_path = os.path.join(args.input_folder,file)
+            im = cv.imread(cur_path, -1).astype(np.float32)
+            im -= black_levels[i]
+            im_8bit = convert_to_8bit(im)
+            cur_img_features = inst.extractSimpleFeatures(im_8bit, None)
+            features.append(cur_img_features.tolist())
+            gt_illuminants.append(base_gt_illuminants[i].tolist())
+
+            for iter in range(int(args.num_augmented)):
+                R_coef = random.uniform(0.2, 5.0)
+                G_coef = random.uniform(0.2, 5.0)
+                B_coef = random.uniform(0.2, 5.0)
+                im_8bit = im
+                im_8bit[:,:,0] *= B_coef
+                im_8bit[:,:,1] *= G_coef
+                im_8bit[:,:,2] *= R_coef
+                im_8bit = convert_to_8bit(im)
+                cur_img_features = inst.extractSimpleFeatures(im_8bit, None)
+                features.append(cur_img_features.tolist())
+                illum = base_gt_illuminants[i]
+                illum[0] *= R_coef
+                illum[1] *= G_coef
+                illum[2] *= B_coef
+                gt_illuminants.append(illum.tolist())
+
+            sys.stdout.write("Computing features: [%3d/%3d]\r" % (i, sz)),
+            sys.stdout.flush()
+        i+=1
+
+    print("\nLearning the model...")
+    model = learn_regression_tree_ensemble(features, gt_illuminants, num_trees, max_tree_depth)
+    print("Writing the model...")
+    generate_code(model,{"-r":args.range, "--hist_bin_num": args.hist_bin_num, "--num_trees": args.num_trees,
+                         "--max_tree_depth": args.max_tree_depth, "--num_augmented": args.num_augmented},
+                  use_YML, args.out)
+    print("Done")
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/oil.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/oil.cpp
new file mode 100644
index 00000000..f06756ef
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/samples/oil.cpp
@@ -0,0 +1,103 @@
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/xphoto.hpp>
+#include "opencv2/xphoto/oilpainting.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void TrackSlider(int , void *);
+static void addSlider(String sliderName, String windowName, int minSlider, int maxSlider, int valDefault, int *valSlider, void(*f)(int, void *), void *r);
+vector<int> colorSpace = { COLOR_BGR2GRAY,COLOR_BGR2HSV,COLOR_BGR2YUV,COLOR_BGR2XYZ };
+
+struct OilImage {
+    String winName = "Oil painting";
+    int size;
+    int dynRatio;
+    int colorSpace;
+    Mat img;
+};
+
+const String keys =
+"{Help h usage ? help  |     | Print this message   }"
+"{v                    | 0   | video index }"
+"{a                    | 700   | API index }"
+"{s                    | 10   | neighbouring size }"
+"{d                    | 1   | dynamic ratio }"
+"{c                    | 0   | color space }"
+"{@arg1                |     | file path}"
+;
+
+
+int main(int argc, char* argv[])
+{
+    CommandLineParser parser(argc, argv, keys);
+
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    String filename = parser.get<String>(0);
+    OilImage p;
+    p.dynRatio = parser.get<int>("d");
+    p.size = parser.get<int>("s");
+    p.colorSpace = parser.get<int>("c");
+    if (p.colorSpace < 0 || p.colorSpace >= static_cast<int>(colorSpace.size()))
+    {
+        std::cout << "Color space must be >= 0 and <"<< colorSpace.size()<<"\n";
+        return EXIT_FAILURE;
+    }
+    if (!filename.empty())
+    {
+        p.img = imread(filename);
+        if (p.img.empty())
+        {
+            std::cout << "Check file path!\n";
+            return EXIT_FAILURE;
+        }
+        Mat dst;
+        xphoto::oilPainting(p.img, dst, p.size, p.dynRatio, colorSpace[p.colorSpace]);
+        imshow("oil painting effect", dst);
+        waitKey();
+        return 0;
+    }
+    VideoCapture v(parser.get<int>("v")+ parser.get<int>("a"));
+    v>> p.img;
+    p.winName="Oil Painting";
+    namedWindow(p.winName);
+    addSlider("DynRatio", p.winName, 1,127,p.dynRatio,&p.dynRatio, TrackSlider, &p);
+    addSlider("Size", p.winName, 1, 100, p.size, &p.size, TrackSlider, &p);
+    addSlider("ColorSpace", p.winName, 0, static_cast<int>(colorSpace.size()-1), p.colorSpace, &p.colorSpace, TrackSlider, &p);
+    while (waitKey(20) != 27)
+    {
+        v>>p.img;
+        imshow("Original", p.img);
+        TrackSlider(0, &p);
+        waitKey(10);
+    }
+    return 0;
+}
+
+void addSlider(String sliderName, String windowName, int minSlider, int maxSlider, int valDefault, int *valSlider, void(*f)(int, void *), void *r)
+{
+    createTrackbar(sliderName, windowName, valSlider, 1, f, r);
+    setTrackbarMin(sliderName, windowName, minSlider);
+    setTrackbarMax(sliderName, windowName, maxSlider);
+    setTrackbarPos(sliderName, windowName, valDefault);
+}
+
+void TrackSlider(int , void *r)
+{
+    OilImage *p = (OilImage *)r;
+    Mat dst;
+    p->img = p->img / p->dynRatio;
+    p->img = p->img*p->dynRatio;
+    xphoto::oilPainting(p->img, dst, p->size, p->dynRatio,colorSpace[p->colorSpace]);
+    if (!dst.empty())
+    {
+        imshow(p->winName, dst);
+    }
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/advanced_types.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/advanced_types.hpp
new file mode 100644
index 00000000..eabafa89
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/advanced_types.hpp
@@ -0,0 +1,66 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __ADVANCED_TYPES_HPP__
+#define __ADVANCED_TYPES_HPP__
+#ifdef __cplusplus
+
+#include <opencv2/core.hpp>
+
+/********************* Functions *********************/
+
+namespace cv
+{
+
+template <typename _Tp, typename _Tp2> static inline
+    cv::Size_<_Tp> operator * (const _Tp2 x, const cv::Size_<_Tp> &sz)
+{
+    return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(x*sz.width), cv::saturate_cast<_Tp>(x*sz.height));
+}
+
+template <typename _Tp, typename _Tp2> static inline
+    cv::Size_<_Tp> operator / (const cv::Size_<_Tp> &sz, const _Tp2 x)
+{
+    return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(sz.width/x), cv::saturate_cast<_Tp>(sz.height/x));
+}
+
+} // cv
+
+#endif
+#endif /* __ADVANCED_TYPES_HPP__ */
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/annf.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/annf.hpp
new file mode 100644
index 00000000..111469fe
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/annf.hpp
@@ -0,0 +1,297 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __ANNF_HPP__
+#define __ANNF_HPP__
+
+#include <vector>
+#include <stack>
+#include <limits>
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+#include <fstream>
+#include <time.h>
+#include <functional>
+
+#include "norm2.hpp"
+#include "whs.hpp"
+
+/************************* KDTree class *************************/
+
+template <typename ForwardIterator> void
+generate_seq(ForwardIterator it, int first, int last)
+{
+    for (int i = first; i < last; ++i, ++it)
+        *it = i;
+}
+
+/////////////////////////////////////////////////////
+/////////////////////////////////////////////////////
+
+template <typename Tp, int cn> class KDTree
+{
+private:
+    class KDTreeComparator
+    {
+        const KDTree <Tp, cn> *main; // main class
+        int dimIdx; // dimension to compare
+
+    public:
+        bool operator () (const int &x, const int &y) const
+        {
+            cv::Vec <Tp, cn> u = main->data[main->idx[x]];
+            cv::Vec <Tp, cn> v = main->data[main->idx[y]];
+
+            return  u[dimIdx] < v[dimIdx];
+        }
+
+        KDTreeComparator(const KDTree <Tp, cn> *_main, int _dimIdx)
+            : main(_main), dimIdx(_dimIdx) {}
+    };
+
+    const int height, width;
+    const int leafNumber; // maximum number of point per leaf
+    const int zeroThresh; // radius of prohibited shifts
+
+    std::vector <cv::Vec <Tp, cn> > data;
+    std::vector <int> idx;
+    std::vector <cv::Point2i> nodes;
+
+    int getMaxSpreadN(const int left, const int right) const;
+    void operator =(const KDTree <Tp, cn> &) const {};
+
+public:
+    void updateDist(const int leaf, const int &idx0, int &bestIdx, double &dist);
+
+    KDTree(const cv::Mat &data, const int leafNumber = 8, const int zeroThresh = 16);
+    ~KDTree(){};
+};
+
+template <typename Tp, int cn> int KDTree <Tp, cn>::
+getMaxSpreadN(const int left, const int right) const
+{
+    cv::Vec<Tp, cn> maxValue = data[ idx[left] ],
+                    minValue = data[ idx[left] ];
+
+    for (int i = left + 1; i < right; ++i)
+        for (int j = 0; j < cn; ++j)
+        {
+            minValue[j] = std::min( minValue[j], data[idx[i]][j] );
+            maxValue[j] = std::max( maxValue[j], data[idx[i]][j] );
+        }
+    cv::Vec<Tp, cn> spread = maxValue - minValue;
+
+    Tp *begIt = &spread[0];
+    return int(std::max_element(begIt, begIt + cn) - begIt);
+}
+
+template <typename Tp, int cn> KDTree <Tp, cn>::
+KDTree(const cv::Mat &img, const int _leafNumber, const int _zeroThresh)
+    : height(img.rows), width(img.cols),
+      leafNumber(_leafNumber), zeroThresh(_zeroThresh)
+///////////////////////////////////////////////////
+{
+    int imgch = img.channels();
+    CV_Assert( img.isContinuous() && imgch <= cn);
+
+    for(size_t i = 0; i < img.total(); i++)
+    {
+        cv::Vec<Tp, cn> v = cv::Vec<Tp, cn>::all((Tp)0);
+        for (int c = 0; c < imgch; c++)
+        {
+            v[c] = *((Tp*)(img.data) + i*imgch + c);
+        }
+        data.push_back(v);
+    }
+
+    generate_seq( std::back_inserter(idx), 0, int(data.size()) );
+    std::fill_n( std::back_inserter(nodes),
+        int(data.size()), cv::Point2i(0, 0) );
+
+    std::stack <int> left, right;
+    left.push( 0 );
+    right.push( int(idx.size()) );
+
+    while ( !left.empty() )
+    {
+        int  _left = left.top();   left.pop();
+        int _right = right.top(); right.pop();
+
+        if ( _right - _left <= leafNumber)
+        {
+            for (int i = _left; i < _right; ++i)
+                nodes[idx[i]] = cv::Point2i(_left, _right);
+            continue;
+        }
+
+        int nth = _left + (_right - _left)/2;
+
+        int dimIdx = getMaxSpreadN(_left, _right);
+        KDTreeComparator comp( this, dimIdx );
+
+        std::vector<int> _idx(idx.begin(), idx.end());
+        std::nth_element(/**/
+            _idx.begin() +  _left,
+            _idx.begin() +    nth,
+            _idx.begin() + _right, comp
+                         /**/);
+        idx = _idx;
+
+          left.push(_left); right.push(nth + 1);
+        left.push(nth + 1);  right.push(_right);
+    }
+}
+
+template <typename Tp, int cn> void KDTree <Tp, cn>::
+updateDist(const int leaf, const int &idx0, int &bestIdx, double &dist)
+{
+    for (int k = nodes[leaf].x; k < nodes[leaf].y; ++k)
+    {
+        int y = idx0/width, ny = idx[k]/width;
+        int x = idx0%width, nx = idx[k]%width;
+
+        if (abs(ny - y) < zeroThresh &&
+            abs(nx - x) < zeroThresh)
+            continue;
+        if (nx >= width  - 1 || nx < 1 ||
+            ny >= height - 1 || ny < 1 )
+            continue;
+
+        double ndist = norm2(data[idx0], data[idx[k]]);
+
+        if (ndist < dist)
+        {
+            dist = ndist;
+            bestIdx = idx[k];
+        }
+    }
+}
+
+/************************** ANNF search **************************/
+
+static void dominantTransforms(const cv::Mat &img, std::vector <cv::Point2i> &transforms,
+                               const int nTransform, const int psize)
+{
+    const int zeroThresh = 2*psize;
+    const int leafNum = 64;
+
+    /** Walsh-Hadamard Transformation **/
+
+    std::vector <cv::Mat> channels;
+    cv::split(img, channels);
+
+    int cncase = std::max(img.channels() - 2, 0);
+    const int np[] = {cncase == 0 ? 12 : (cncase == 1 ? 16 : 10),
+                      cncase == 0 ? 12 : (cncase == 1 ? 04 : 02),
+                      cncase == 0 ? 00 : (cncase == 1 ? 04 : 02),
+                      cncase == 0 ? 00 : (cncase == 1 ? 00 : 10)};
+
+    for (int i = 0; i < img.channels(); ++i)
+        rgb2whs(channels[i], channels[i], np[i], psize);
+
+    cv::Mat whs; // Walsh-Hadamard series
+    cv::merge(channels, whs);
+
+    KDTree <float, 24> kdTree(whs, leafNum, zeroThresh);
+    std::vector <int> annf( whs.total(), 0 );
+
+    /** Propagation-assisted kd-tree search **/
+
+    for (int i = 0; i < whs.rows; ++i)
+        for (int j = 0; j < whs.cols; ++j)
+        {
+            double dist = std::numeric_limits <double>::max();
+            int current = i*whs.cols + j;
+
+            int dy[] = {0, 1, 0}, dx[] = {0, 0, 1};
+            for (int k = 0; k < int( sizeof(dy)/sizeof(int) ); ++k)
+                if ( i - dy[k] >= 0 && j - dx[k] >= 0 )
+                {
+                    int neighbor = (i - dy[k])*whs.cols + (j - dx[k]);
+                    int leafIdx = (dx[k] == 0 && dy[k] == 0)
+                        ? neighbor : annf[neighbor] + dy[k]*whs.cols + dx[k];
+                    kdTree.updateDist(leafIdx, current,
+                                annf[i*whs.cols + j], dist);
+                }
+        }
+
+    /** Local maxima extraction **/
+
+    cv::Mat_<double> annfHist(2*whs.rows - 1, 2*whs.cols - 1, 0.0),
+                    _annfHist(2*whs.rows - 1, 2*whs.cols - 1, 0.0);
+    for (size_t i = 0; i < annf.size(); ++i)
+        ++annfHist( annf[i]/whs.cols - int(i)/whs.cols + whs.rows - 1,
+                    annf[i]%whs.cols - int(i)%whs.cols + whs.cols - 1 );
+
+    cv::GaussianBlur( annfHist, annfHist,
+        cv::Size(0, 0), std::sqrt(2.0), 0.0, cv::BORDER_CONSTANT);
+    cv::dilate( annfHist, _annfHist,
+        cv::Matx<uchar, 9, 9>::ones() );
+
+    std::vector < std::pair<double, int> > amount;
+    std::vector <cv::Point2i> shiftM;
+
+    for (int i = 0, t = 0; i < annfHist.rows; ++i)
+    {
+        double  *pAnnfHist =  annfHist.ptr<double>(i);
+        double *_pAnnfHist = _annfHist.ptr<double>(i);
+
+        for (int j = 0; j < annfHist.cols; ++j)
+            if ( pAnnfHist[j] != 0 && pAnnfHist[j] == _pAnnfHist[j] )
+            {
+                amount.push_back( std::make_pair(pAnnfHist[j], t++) );
+                shiftM.push_back( cv::Point2i(j - whs.cols + 1,
+                                              i - whs.rows + 1) );
+            }
+    }
+
+    int num = std::min((int)amount.size(), (int)nTransform);
+    std::partial_sort( amount.begin(), amount.begin() + num,
+        amount.end(), std::greater< std::pair<double, int> >() );
+
+    transforms.resize(num);
+    for (int i = 0; i < num; ++i)
+    {
+        int idx = amount[i].second;
+        transforms[i] = cv::Point2i( shiftM[idx].x, shiftM[idx].y );
+    }
+}
+
+#endif /* __ANNF_HPP__ */
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/blending.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/blending.hpp
new file mode 100644
index 00000000..436dec52
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/blending.hpp
@@ -0,0 +1,45 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __BLENDING_HPP__
+#define __BLENDING_HPP__
+
+
+
+#endif /* __BLENDING_HPP__ */
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_commons.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_commons.hpp
new file mode 100644
index 00000000..b4f51b14
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_commons.hpp
@@ -0,0 +1,165 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BM3D_DENOISING_INVOKER_COMMONS_HPP__
+#define __OPENCV_BM3D_DENOISING_INVOKER_COMMONS_HPP__
+
+#include "bm3d_denoising_invoker_structs.hpp"
+
+// std::isnan is a part of C++11 and it is not supported in MSVS2010/2012
+#if defined _MSC_VER && _MSC_VER < 1800 /* MSVC 2013 */
+#include <float.h>
+namespace std {
+    template <typename T> bool isnan(T value) { return _isnan(value) != 0; }
+}
+#endif
+
+namespace cv
+{
+namespace xphoto
+{
+
+// Returns largest power of 2 smaller than the input value
+inline int getLargestPowerOf2SmallerThan(unsigned x)
+{
+    x = x | (x >> 1);
+    x = x | (x >> 2);
+    x = x | (x >> 4);
+    x = x | (x >> 8);
+    x = x | (x >> 16);
+    return x - (x >> 1);
+}
+
+// Returns true if x is a power of 2. Otherwise false.
+inline bool isPowerOf2(int x)
+{
+    return (x > 0) && !(x & (x - 1));
+}
+
+
+template <typename T>
+inline static void shrink(T &val, T &nonZeroCount, const T &threshold)
+{
+    if (std::abs(val) < threshold)
+        val = 0;
+    else
+        ++nonZeroCount;
+}
+
+template <typename T>
+inline static void hardThreshold2D(T *dst, T *thrMap, const int &templateWindowSizeSq)
+{
+    for (int i = 1; i < templateWindowSizeSq; ++i)
+    {
+        if (std::abs(dst[i]) < thrMap[i])
+            dst[i] = 0;
+    }
+}
+
+template <int N, typename T, typename DT, typename CT>
+inline static T HardThreshold(BlockMatch<T, DT, CT> *z, const int &n, T *&thrMap)
+{
+    T nonZeroCount = 0;
+
+    for (int i = 0; i < N; ++i)
+        shrink(z[i][n], nonZeroCount, *thrMap++);
+
+    return nonZeroCount;
+}
+
+template <typename T, typename DT, typename CT>
+inline static T HardThreshold(BlockMatch<T, DT, CT> *z, const int &n, T *&thrMap, const int &N)
+{
+    T nonZeroCount = 0;
+
+    for (int i = 0; i < N; ++i)
+        shrink(z[i][n], nonZeroCount, *thrMap++);
+
+    return nonZeroCount;
+}
+
+template <int N, typename T, typename DT, typename CT>
+inline static int WienerFiltering(BlockMatch<T, DT, CT> *zSrc, BlockMatch<T, DT, CT> *zBasic, const int &n, T *&thrMap)
+{
+    int wienerCoeffs = 0;
+
+    for (int i = 0; i < N; ++i)
+    {
+        // Possible optimization point here to get rid of floats and casts
+        int basicSq = zBasic[i][n] * zBasic[i][n];
+        int sigmaSq = *thrMap * *thrMap;
+        int denom = basicSq + sigmaSq;
+        float wie = (denom == 0) ? 1.0f : ((float)basicSq / (float)denom);
+
+        zBasic[i][n] = (T)(zSrc[i][n] * wie);
+        wienerCoeffs += (int)wie;
+        ++thrMap;
+    }
+
+    return wienerCoeffs;
+}
+
+template <typename T, typename DT, typename CT>
+inline static int WienerFiltering(BlockMatch<T, DT, CT> *zSrc, BlockMatch<T, DT, CT> *zBasic, const int &n, T *&thrMap, const unsigned &N)
+{
+    int wienerCoeffs = 0;
+
+    for (unsigned i = 0; i < N; ++i)
+    {
+        // Possible optimization point here to get rid of floats and casts
+        int basicSq = zBasic[i][n] * zBasic[i][n];
+        int sigmaSq = *thrMap * *thrMap;
+        int denom = basicSq + sigmaSq;
+        float wie = (denom == 0) ? 1.0f : ((float)basicSq / (float)denom);
+
+        zBasic[i][n] = (T)(zSrc[i][n] * wie);
+        wienerCoeffs += (int)wie;
+        ++thrMap;
+    }
+
+    return wienerCoeffs;
+}
+
+
+}  // namespace xphoto
+}  // namespace cv
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_step1.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_step1.hpp
new file mode 100644
index 00000000..ec5303c1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_step1.hpp
@@ -0,0 +1,517 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BM3D_DENOISING_INVOKER_STEP1_HPP__
+#define __OPENCV_BM3D_DENOISING_INVOKER_STEP1_HPP__
+
+#include "bm3d_denoising_invoker_commons.hpp"
+#include "bm3d_denoising_transforms.hpp"
+#include "kaiser_window.hpp"
+
+namespace cv
+{
+namespace xphoto
+{
+
+template <typename T, typename D, typename WT, typename TT, typename TC>
+struct Bm3dDenoisingInvokerStep1 : public ParallelLoopBody
+{
+public:
+    Bm3dDenoisingInvokerStep1(
+        const Mat& src,
+        Mat& dst,
+        const int &templateWindowSize,
+        const int &searchWindowSize,
+        const float &h,
+        const int &hBM,
+        const int &groupSize,
+        const int &slidingStep,
+        const float &beta);
+
+    virtual ~Bm3dDenoisingInvokerStep1();
+    void operator() (const Range& range) const CV_OVERRIDE;
+
+private:
+    // Unimplemented operator in order to satisfy compiler warning.
+    void operator= (const Bm3dDenoisingInvokerStep1&);
+
+    void calcDistSumsForFirstElementInRow(
+        int i,
+        Array2d<int>& distSums,
+        Array3d<int>& colDistSums,
+        Array3d<int>& lastColDistSums,
+        BlockMatch<TT, int, TT> *bm,
+        int &elementSize) const;
+
+    void calcDistSumsForAllElementsInFirstRow(
+        int i,
+        int j,
+        int firstColNum,
+        Array2d<int>& distSums,
+        Array3d<int>& colDistSums,
+        Array3d<int>& lastColDistSums,
+        BlockMatch<TT, int, TT> *bm,
+        int &elementSize) const;
+
+    // Image containers
+    const Mat& src_;
+    Mat& dst_;
+    Mat srcExtended_;
+
+    // Border size of the extended src and basic images
+    int borderSize_;
+
+    // Template and window size
+    int templateWindowSize_;
+    int searchWindowSize_;
+
+    // Half template and window size
+    int halfTemplateWindowSize_;
+    int halfSearchWindowSize_;
+
+    // Squared template and window size
+    int templateWindowSizeSq_;
+    int searchWindowSizeSq_;
+
+    // Block matching threshold
+    int hBM_;
+
+    // Maximum size of 3D group
+    int groupSize_;
+
+    // Sliding step
+    const int slidingStep_;
+
+    // Threshold map
+    TT *thrMap_;
+
+    // Kaiser window
+    float *kaiser_;
+};
+
+template <typename T, typename D, typename WT, typename TT, typename TC>
+Bm3dDenoisingInvokerStep1<T, D, WT, TT, TC>::Bm3dDenoisingInvokerStep1(
+    const Mat& src,
+    Mat& dst,
+    const int &templateWindowSize,
+    const int &searchWindowSize,
+    const float &h,
+    const int &hBM,
+    const int &groupSize,
+    const int &slidingStep,
+    const float &beta) :
+    src_(src), dst_(dst), groupSize_(groupSize), slidingStep_(slidingStep), thrMap_(NULL), kaiser_(NULL)
+{
+    groupSize_ = getLargestPowerOf2SmallerThan(groupSize);
+    CV_Assert(groupSize > 0);
+
+    halfTemplateWindowSize_ = templateWindowSize >> 1;
+    halfSearchWindowSize_ = searchWindowSize >> 1;
+    templateWindowSize_ = templateWindowSize;
+    searchWindowSize_ = searchWindowSize;
+    templateWindowSizeSq_ = templateWindowSize_ * templateWindowSize_;
+    searchWindowSizeSq_ = searchWindowSize_ * searchWindowSize_;
+
+    // Extend image to avoid border problem
+    borderSize_ = halfSearchWindowSize_ + halfTemplateWindowSize_;
+    copyMakeBorder(src_, srcExtended_, borderSize_, borderSize_, borderSize_, borderSize_, BORDER_DEFAULT);
+
+    // Calculate block matching threshold
+    hBM_ = D::template calcBlockMatchingThreshold<int>(hBM, templateWindowSizeSq_);
+
+    // Select transforms depending on the template size
+    TC::RegisterTransforms2D(templateWindowSize_);
+
+    // Precompute threshold map
+    TC::calcThresholdMap3D(thrMap_, h, templateWindowSize_, groupSize_);
+
+    // Generate kaiser window
+    calcKaiserWindow2D(kaiser_, templateWindowSize_, beta);
+}
+
+template<typename T, typename D, typename WT, typename TT, typename TC>
+inline Bm3dDenoisingInvokerStep1<T, D, WT, TT, TC>::~Bm3dDenoisingInvokerStep1()
+{
+    delete[] thrMap_;
+    delete[] kaiser_;
+}
+
+template <typename T, typename D, typename WT, typename TT, typename TC>
+void Bm3dDenoisingInvokerStep1<T, D, WT, TT, TC>::operator() (const Range& range) const
+{
+    const int size = (range.size() + 2 * borderSize_) * srcExtended_.cols;
+    std::vector<WT> weightedSum(size, 0.0);
+    std::vector<WT> weights(size, 0.0);
+    int row_from = range.start;
+    int row_to = range.end - 1;
+
+    // Local vars for faster processing
+    const int blockSize = templateWindowSize_;
+    const int blockSizeSq = templateWindowSizeSq_;
+    const int halfBlockSize = halfTemplateWindowSize_;
+    const int searchWindowSize = searchWindowSize_;
+    const int searchWindowSizeSq = searchWindowSizeSq_;
+    const TT halfSearchWindowSize = (TT)halfSearchWindowSize_;
+    const int hBM = hBM_;
+    const int groupSize = groupSize_;
+
+    const int step = srcExtended_.cols;
+    const int dstStep = srcExtended_.cols;
+    const int weiStep = srcExtended_.cols;
+    const int dstcstep = dstStep - blockSize;
+    const int weicstep = weiStep - blockSize;
+
+    // Buffer to store 3D group
+    BlockMatch<TT, int, TT> *bm = new BlockMatch<TT, int, TT>[searchWindowSizeSq];
+    for (int i = 0; i < searchWindowSizeSq; ++i)
+        bm[i].init(blockSizeSq);
+
+    // First element in a group is always the reference patch. Hence distance is 0.
+    bm[0](0, halfSearchWindowSize, halfSearchWindowSize);
+
+    // Sums of columns and rows for current pixel
+    Array2d<int> distSums(searchWindowSize, searchWindowSize);
+
+    // Sums of columns for current pixel (for lazy calc optimization)
+    Array3d<int> colDistSums(blockSize, searchWindowSize, searchWindowSize);
+
+    // Last elements of column sum (for each element in a row)
+    Array3d<int> lastColDistSums(src_.cols, searchWindowSize, searchWindowSize);
+
+    int firstColNum = -1;
+    for (int j = row_from, jj = 0; j <= row_to; j += slidingStep_, jj += slidingStep_)
+    {
+        for (int i = 0; i < src_.cols; i += slidingStep_)
+        {
+            const T *currentPixel = srcExtended_.ptr<T>(0) + step*j + i;
+            int elementSize = 1;
+
+            // Calculate distSums using moving average filter approach.
+            if (i == 0)
+            {
+                // Calculate distSums for the first element in a row
+                calcDistSumsForFirstElementInRow(j, distSums, colDistSums, lastColDistSums, bm, elementSize);
+                firstColNum = 0;
+            }
+            else
+            {
+                if (j == row_from)
+                {
+                    // Calculate distSums for all elements in the first row
+                    calcDistSumsForAllElementsInFirstRow(
+                        j, i, firstColNum, distSums, colDistSums, lastColDistSums, bm, elementSize);
+                }
+                else
+                {
+                    const int start_bx = blockSize + i - 1;
+                    const int start_by = j - 1;
+                    const int ax = halfSearchWindowSize + start_bx;
+                    const int ay = halfSearchWindowSize + start_by;
+
+                    const T a_up = srcExtended_.at<T>(ay, ax);
+                    const T a_down = srcExtended_.at<T>(ay + blockSize, ax);
+
+                    for (TT y = 0; y < searchWindowSize; y++)
+                    {
+                        int *distSumsRow = distSums.row_ptr(y);
+                        int *colDistSumsRow = colDistSums.row_ptr(firstColNum, y);
+                        int *lastColDistSumsRow = lastColDistSums.row_ptr(i, y);
+
+                        const T *b_up_ptr = srcExtended_.ptr<T>(start_by + y);
+                        const T *b_down_ptr = srcExtended_.ptr<T>(start_by + y + blockSize);
+
+                        for (TT x = 0; x < searchWindowSize; x++)
+                        {
+                            // Remove from current pixel sum column sum with index "firstColNum"
+                            distSumsRow[x] -= colDistSumsRow[x];
+
+                            const int bx = start_bx + x;
+                            colDistSumsRow[x] = lastColDistSumsRow[x] +
+                                D::template calcUpDownDist<T>(a_up, a_down, b_up_ptr[bx], b_down_ptr[bx]);
+
+                            distSumsRow[x] += colDistSumsRow[x];
+                            lastColDistSumsRow[x] = colDistSumsRow[x];
+
+                            if (x == halfSearchWindowSize && y == halfSearchWindowSize)
+                                continue;
+
+                            // Save the distance, coordinate and increase the counter
+                            if (distSumsRow[x] < hBM)
+                                bm[elementSize++](distSumsRow[x], x, y);
+                        }
+                    }
+                }
+
+                firstColNum = (firstColNum + 1) % blockSize;
+            }
+
+            // Sort bm by distance (first element is already sorted)
+            std::sort(bm + 1, bm + elementSize);
+
+            // Find the nearest power of 2 and cap the group size from the top
+            elementSize = getLargestPowerOf2SmallerThan(elementSize);
+            if (elementSize > groupSize)
+                elementSize = groupSize;
+
+            // Transform 2D patches
+            for (int n = 0; n < elementSize; ++n)
+            {
+                const T *candidatePatch = currentPixel + step * bm[n].coord_y + bm[n].coord_x;
+                TC::forwardTransform2D(candidatePatch, bm[n].data(), step, blockSize);
+            }
+
+            // Transform and shrink 1D columns
+            TT sumNonZero = 0;
+            TT *thrMapPtr1D = thrMap_ + (elementSize - 1) * blockSizeSq;
+            switch (elementSize)
+            {
+            case 16:
+                for (int n = 0; n < blockSizeSq; n++)
+                {
+                    TC::forwardTransform16(bm, n);
+                    sumNonZero += HardThreshold<16>(bm, n, thrMapPtr1D);
+                    TC::inverseTransform16(bm, n);
+                }
+                break;
+            case 8:
+                for (int n = 0; n < blockSizeSq; n++)
+                {
+                    TC::forwardTransform8(bm, n);
+                    sumNonZero += HardThreshold<8>(bm, n, thrMapPtr1D);
+                    TC::inverseTransform8(bm, n);
+                }
+                break;
+            case 4:
+                for (int n = 0; n < blockSizeSq; n++)
+                {
+                    TC::forwardTransform4(bm, n);
+                    sumNonZero += HardThreshold<4>(bm, n, thrMapPtr1D);
+                    TC::inverseTransform4(bm, n);
+                }
+                break;
+            case 2:
+                for (int n = 0; n < blockSizeSq; n++)
+                {
+                    TC::forwardTransform2(bm, n);
+                    TC::forwardTransform2(bm, n);
+                    sumNonZero += HardThreshold<2>(bm, n, thrMapPtr1D);
+                    TC::inverseTransform2(bm, n);
+                }
+                break;
+            case 1:
+                {
+                    TT *block = bm[0].data();
+                    for (int n = 0; n < blockSizeSq; n++)
+                        shrink(block[n], sumNonZero, *thrMapPtr1D++);
+                }
+                break;
+            default:
+                for (int n = 0; n < blockSizeSq; n++)
+                {
+                    TC::forwardTransformN(bm, n, elementSize);
+                    sumNonZero += HardThreshold(bm, n, thrMapPtr1D, elementSize);
+                    TC::inverseTransformN(bm, n, elementSize);
+                }
+            }
+
+            // Inverse 2D transform
+            for (int n = 0; n < elementSize; ++n)
+                TC::inverseTransform2D(bm[n].data(), blockSize);
+
+            // Aggregate the results (increase sumNonZero to avoid division by zero)
+            float weight = 1.0f / (float)(++sumNonZero);
+
+            // Scale weight by element size
+            weight *= elementSize;
+            weight /= groupSize;
+
+            // Put patches back to their original positions
+            WT *dstPtr = weightedSum.data() + jj * dstStep + i;
+            WT *weiPtr = weights.data() + jj * dstStep + i;
+            const float *kaiser = kaiser_;
+
+            for (int l = 0; l < elementSize; ++l)
+            {
+                const TT *block = bm[l].data();
+                int offset = bm[l].coord_y * dstStep + bm[l].coord_x;
+                WT *d = dstPtr + offset;
+                WT *dw = weiPtr + offset;
+
+                for (int n = 0; n < blockSize; ++n)
+                {
+                    for (int m = 0; m < blockSize; ++m)
+                    {
+                        unsigned idx = n * blockSize + m;
+                        *d += kaiser[idx] * block[idx] * weight;
+                        *dw += kaiser[idx] * weight;
+                        ++d, ++dw;
+                    }
+                    d += dstcstep;
+                    dw += weicstep;
+                }
+            }
+        } // i
+    } // j
+
+    // Cleanup
+    for (int i = 0; i < searchWindowSizeSq; ++i)
+        bm[i].release();
+    delete[] bm;
+
+    // Divide accumulation buffer by the corresponding weights
+    for (int i = row_from, ii = 0; i <= row_to; ++i, ++ii)
+    {
+        T *d = dst_.ptr<T>(i);
+        float *dE = weightedSum.data() + (ii + halfSearchWindowSize + halfBlockSize) * dstStep + halfSearchWindowSize;
+        float *dw = weights.data() + (ii + halfSearchWindowSize + halfBlockSize) * dstStep + halfSearchWindowSize;
+        for (int j = 0; j < dst_.cols; ++j)
+            d[j] = cv::saturate_cast<T>(dE[j + halfBlockSize] / dw[j + halfBlockSize]);
+    }
+}
+
+template <typename T, typename D, typename WT, typename TT, typename TC>
+inline void Bm3dDenoisingInvokerStep1<T, D, WT, TT, TC>::calcDistSumsForFirstElementInRow(
+    int i,
+    Array2d<int>& distSums,
+    Array3d<int>& colDistSums,
+    Array3d<int>& lastColDistSums,
+    BlockMatch<TT, int, TT> *bm,
+    int &elementSize) const
+{
+    int j = 0;
+    const int hBM = hBM_;
+    const int blockSize = templateWindowSize_;
+    const int searchWindowSize = searchWindowSize_;
+    const TT halfSearchWindowSize = (TT)halfSearchWindowSize_;
+    const int ay = halfSearchWindowSize + i;
+    const int ax = halfSearchWindowSize + j;
+
+    for (TT y = 0; y < searchWindowSize; ++y)
+    {
+        for (TT x = 0; x < searchWindowSize; ++x)
+        {
+            // Zeroize arrays
+            distSums[y][x] = 0;
+            for (int tx = 0; tx < blockSize; tx++)
+                colDistSums[tx][y][x] = 0;
+
+            int start_y = i + y;
+            int start_x = j + x;
+
+            for (int ty = 0; ty < blockSize; ty++)
+                for (int tx = 0; tx < blockSize; tx++)
+                {
+                    int dist = D::template calcDist<T>(
+                        srcExtended_,
+                        ay + ty,
+                        ax + tx,
+                        start_y + ty,
+                        start_x + tx);
+
+                    distSums[y][x] += dist;
+                    colDistSums[tx][y][x] += dist;
+                }
+
+            lastColDistSums[j][y][x] = colDistSums[blockSize - 1][y][x];
+
+            if (x == halfSearchWindowSize && y == halfSearchWindowSize)
+                continue;
+
+            if (distSums[y][x] < hBM)
+                bm[elementSize++](distSums[y][x], x, y);
+        }
+    }
+}
+
+template <typename T, typename D, typename WT, typename TT, typename TC>
+inline void Bm3dDenoisingInvokerStep1<T, D, WT, TT, TC>::calcDistSumsForAllElementsInFirstRow(
+    int i,
+    int j,
+    int firstColNum,
+    Array2d<int>& distSums,
+    Array3d<int>& colDistSums,
+    Array3d<int>& lastColDistSums,
+    BlockMatch<TT, int, TT> *bm,
+    int &elementSize) const
+{
+    const int hBM = hBM_;
+    const int blockSize = templateWindowSize_;
+    const int searchWindowSize = searchWindowSize_;
+    const TT halfSearchWindowSize = (TT)halfSearchWindowSize_;
+
+    const int bx_start = blockSize - 1 + j;
+    const int ax = halfSearchWindowSize + bx_start;
+    const int ay = halfSearchWindowSize + i;
+
+    for (TT y = 0; y < searchWindowSize; ++y)
+    {
+        for (TT x = 0; x < searchWindowSize; ++x)
+        {
+            distSums[y][x] -= colDistSums[firstColNum][y][x];
+
+            colDistSums[firstColNum][y][x] = 0;
+            int by = i + y;
+            int bx = bx_start + x;
+
+            for (int ty = 0; ty < blockSize; ty++)
+                colDistSums[firstColNum][y][x] += D::template calcDist<T>(
+                    srcExtended_,
+                    ay + ty,
+                    ax,
+                    by + ty,
+                    bx);
+
+            distSums[y][x] += colDistSums[firstColNum][y][x];
+            lastColDistSums[j][y][x] = colDistSums[firstColNum][y][x];
+
+            if (x == halfSearchWindowSize && y == halfSearchWindowSize)
+                continue;
+
+            if (distSums[y][x] < hBM)
+                bm[elementSize++](distSums[y][x], x, y);
+        }
+    }
+}
+
+}  // namespace xphoto
+}  // namespace cv
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_step2.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_step2.hpp
new file mode 100644
index 00000000..0662b722
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_step2.hpp
@@ -0,0 +1,540 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BM3D_DENOISING_INVOKER_STEP2_HPP__
+#define __OPENCV_BM3D_DENOISING_INVOKER_STEP2_HPP__
+
+#include "bm3d_denoising_invoker_commons.hpp"
+#include "bm3d_denoising_transforms.hpp"
+#include "kaiser_window.hpp"
+
+namespace cv
+{
+namespace xphoto
+{
+
+template <typename T, typename D, typename WT, typename TT, typename TC>
+struct Bm3dDenoisingInvokerStep2 : public ParallelLoopBody
+{
+public:
+    Bm3dDenoisingInvokerStep2(
+        const Mat& src,
+        const Mat& basic,
+        Mat& dst,
+        const int &templateWindowSize,
+        const int &searchWindowSize,
+        const float &h,
+        const int &hBM,
+        const int &groupSize,
+        const int &slidingStep,
+        const float &beta);
+
+    virtual ~Bm3dDenoisingInvokerStep2();
+    void operator() (const Range& range) const CV_OVERRIDE;
+
+private:
+    // Unimplemented operator in order to satisfy compiler warning.
+    void operator= (const Bm3dDenoisingInvokerStep2&);
+
+    void calcDistSumsForFirstElementInRow(
+        int i,
+        Array2d<int>& distSums,
+        Array3d<int>& colDistSums,
+        Array3d<int>& lastColDistSums,
+        BlockMatch<TT, int, TT> *bm,
+        int &elementSize) const;
+
+    void calcDistSumsForAllElementsInFirstRow(
+        int i,
+        int j,
+        int firstColNum,
+        Array2d<int>& distSums,
+        Array3d<int>& colDistSums,
+        Array3d<int>& lastColDistSums,
+        BlockMatch<TT, int, TT> *bm,
+        int &elementSize) const;
+
+    // Image containers
+    const Mat& src_;
+    const Mat& basic_;
+    Mat& dst_;
+    Mat srcExtended_;
+    Mat basicExtended_;
+
+    // Border size of the extended src and basic images
+    int borderSize_;
+
+    // Template and window size
+    int templateWindowSize_;
+    int searchWindowSize_;
+
+    // Half template and window size
+    int halfTemplateWindowSize_;
+    int halfSearchWindowSize_;
+
+    // Squared template and window size
+    int templateWindowSizeSq_;
+    int searchWindowSizeSq_;
+
+    // Block matching threshold
+    int hBM_;
+
+    // Maximum size of 3D group
+    int groupSize_;
+
+    // Sliding step
+    const int slidingStep_;
+
+    // Threshold map
+    TT *thrMap_;
+
+    // Kaiser window
+    float *kaiser_;
+};
+
+template <typename T, typename D, typename WT, typename TT, typename TC>
+Bm3dDenoisingInvokerStep2<T, D, WT, TT, TC>::Bm3dDenoisingInvokerStep2(
+    const Mat& src,
+    const Mat& basic,
+    Mat& dst,
+    const int &templateWindowSize,
+    const int &searchWindowSize,
+    const float &h,
+    const int &hBM,
+    const int &groupSize,
+    const int &slidingStep,
+    const float &beta) :
+    src_(src), basic_(basic), dst_(dst), groupSize_(groupSize), slidingStep_(slidingStep), thrMap_(NULL), kaiser_(NULL)
+{
+    groupSize_ = getLargestPowerOf2SmallerThan(groupSize);
+    CV_Assert(groupSize > 0);
+
+    halfTemplateWindowSize_ = templateWindowSize >> 1;
+    halfSearchWindowSize_ = searchWindowSize >> 1;
+    templateWindowSize_ = templateWindowSize;
+    searchWindowSize_ = searchWindowSize;
+    templateWindowSizeSq_ = templateWindowSize_ * templateWindowSize_;
+    searchWindowSizeSq_ = searchWindowSize_ * searchWindowSize_;
+
+    // Extend image to avoid border problem
+    borderSize_ = halfSearchWindowSize_ + halfTemplateWindowSize_;
+    copyMakeBorder(src_, srcExtended_, borderSize_, borderSize_, borderSize_, borderSize_, BORDER_DEFAULT);
+    copyMakeBorder(basic_, basicExtended_, borderSize_, borderSize_, borderSize_, borderSize_, BORDER_DEFAULT);
+
+    // Calculate block matching threshold
+    hBM_ = D::template calcBlockMatchingThreshold<int>(hBM, templateWindowSizeSq_);
+
+    // Select transforms depending on the template size
+    TC::RegisterTransforms2D(templateWindowSize_);
+
+    // Precompute threshold map
+    TC::calcThresholdMap3D(thrMap_, h, templateWindowSize_, groupSize_);
+
+    // Generate kaiser window
+    calcKaiserWindow2D(kaiser_, templateWindowSize_, beta);
+}
+
+template<typename T, typename D, typename WT, typename TT, typename TC>
+inline Bm3dDenoisingInvokerStep2<T, D, WT, TT, TC>::~Bm3dDenoisingInvokerStep2()
+{
+    delete[] thrMap_;
+    delete[] kaiser_;
+}
+
+template <typename T, typename D, typename WT, typename TT, typename TC>
+void Bm3dDenoisingInvokerStep2<T, D, WT, TT, TC>::operator() (const Range& range) const
+{
+    const int size = (range.size() + 2 * borderSize_) * srcExtended_.cols;
+    std::vector<WT> weightedSum(size, 0.0);
+    std::vector<WT> weights(size, 0.0);
+    int row_from = range.start;
+    int row_to = range.end - 1;
+
+    // Local vars for faster processing
+    const int blockSize = templateWindowSize_;
+    const int blockSizeSq = templateWindowSizeSq_;
+    const int halfBlockSize = halfTemplateWindowSize_;
+    const int searchWindowSize = searchWindowSize_;
+    const int searchWindowSizeSq = searchWindowSizeSq_;
+    const TT halfSearchWindowSize = (TT)halfSearchWindowSize_;
+    const int hBM = hBM_;
+    const int groupSize = groupSize_;
+
+    const int step = srcExtended_.cols;
+    const int dstStep = srcExtended_.cols;
+    const int weiStep = srcExtended_.cols;
+    const int dstcstep = dstStep - blockSize;
+    const int weicstep = weiStep - blockSize;
+
+    // Buffer to store 3D group
+    BlockMatch<TT, int, TT> *bmBasic = new BlockMatch<TT, int, TT>[searchWindowSizeSq];
+    BlockMatch<TT, int, TT> *bmSrc = new BlockMatch<TT, int, TT>[searchWindowSizeSq];
+    for (int i = 0; i < searchWindowSizeSq; ++i)
+    {
+        bmBasic[i].init(blockSizeSq);
+        bmSrc[i].init(blockSizeSq);
+    }
+
+    // First element in a group is always the reference patch. Hence distance is 0.
+    bmBasic[0](0, halfSearchWindowSize, halfSearchWindowSize);
+    bmSrc[0](0, halfSearchWindowSize, halfSearchWindowSize);
+
+    // Sums of columns and rows for current pixel
+    Array2d<int> distSums(searchWindowSize, searchWindowSize);
+
+    // Sums of columns for current pixel (for lazy calc optimization)
+    Array3d<int> colDistSums(blockSize, searchWindowSize, searchWindowSize);
+
+    // Last elements of column sum (for each element in a row)
+    Array3d<int> lastColDistSums(src_.cols, searchWindowSize, searchWindowSize);
+
+    int firstColNum = -1;
+    for (int j = row_from, jj = 0; j <= row_to; j += slidingStep_, jj += slidingStep_)
+    {
+        for (int i = 0; i < src_.cols; i += slidingStep_)
+        {
+            const T *currentPixelSrc = srcExtended_.ptr<T>(0) + step*j + i;
+            const T *currentPixelBasic = basicExtended_.ptr<T>(0) + step*j + i;
+
+            int elementSize = 1;
+
+            // Calculate distSums using moving average filter approach.
+            if (i == 0)
+            {
+                // Calculate distSums for the first element in a row
+                calcDistSumsForFirstElementInRow(j, distSums, colDistSums, lastColDistSums, bmBasic, elementSize);
+                firstColNum = 0;
+            }
+            else
+            {
+                if (j == row_from)
+                {
+                    // Calculate distSums for all elements in the first row
+                    calcDistSumsForAllElementsInFirstRow(
+                        j, i, firstColNum, distSums, colDistSums, lastColDistSums, bmBasic, elementSize);
+                }
+                else
+                {
+                    const int start_bx = blockSize + i - 1;
+                    const int start_by = j - 1;
+                    const int ax = halfSearchWindowSize + start_bx;
+                    const int ay = halfSearchWindowSize + start_by;
+
+                    const T a_up = basicExtended_.at<T>(ay, ax);
+                    const T a_down = basicExtended_.at<T>(ay + blockSize, ax);
+
+                    for (TT y = 0; y < searchWindowSize; y++)
+                    {
+                        int *distSumsRow = distSums.row_ptr(y);
+                        int *colDistSumsRow = colDistSums.row_ptr(firstColNum, y);
+                        int *lastColDistSumsRow = lastColDistSums.row_ptr(i, y);
+
+                        const T *b_up_ptr = basicExtended_.ptr<T>(start_by + y);
+                        const T *b_down_ptr = basicExtended_.ptr<T>(start_by + y + blockSize);
+
+                        for (TT x = 0; x < searchWindowSize; x++)
+                        {
+                            // Remove from current pixel sum column sum with index "firstColNum"
+                            distSumsRow[x] -= colDistSumsRow[x];
+
+                            const int bx = start_bx + x;
+                            colDistSumsRow[x] = lastColDistSumsRow[x] +
+                                D::template calcUpDownDist<T>(a_up, a_down, b_up_ptr[bx], b_down_ptr[bx]);
+
+                            distSumsRow[x] += colDistSumsRow[x];
+                            lastColDistSumsRow[x] = colDistSumsRow[x];
+
+                            if (x == halfSearchWindowSize && y == halfSearchWindowSize)
+                                continue;
+
+                            // Save the distance, coordinate and increase the counter
+                            if (distSumsRow[x] < hBM)
+                                bmBasic[elementSize++](distSumsRow[x], x, y);
+                        }
+                    }
+                }
+
+                firstColNum = (firstColNum + 1) % blockSize;
+            }
+
+            // Sort bmBasic by distance (first element is already sorted)
+            std::sort(bmBasic + 1, bmBasic + elementSize);
+
+            // Find the nearest power of 2 and cap the group size from the top
+            elementSize = getLargestPowerOf2SmallerThan(elementSize);
+            if (elementSize > groupSize)
+                elementSize = groupSize;
+
+            // Transform 2D patches
+            for (int n = 0; n < elementSize; ++n)
+            {
+                const T *candidatePatchSrc = currentPixelSrc + step * bmBasic[n].coord_y + bmBasic[n].coord_x;
+                const T *candidatePatchBasic = currentPixelBasic + step * bmBasic[n].coord_y + bmBasic[n].coord_x;
+                TC::forwardTransform2D(candidatePatchSrc, bmSrc[n].data(), step, blockSize);
+                TC::forwardTransform2D(candidatePatchBasic, bmBasic[n].data(), step, blockSize);
+            }
+
+            // Transform and shrink 1D columns
+            int wienerCoefficients = 0;
+            TT *thrMapPtr1D = thrMap_ + (elementSize - 1) * blockSizeSq;
+            switch (elementSize)
+            {
+            case 16:
+                for (int n = 0; n < blockSizeSq; n++)
+                {
+                    TC::forwardTransform16(bmSrc, n);
+                    TC::forwardTransform16(bmBasic, n);
+                    wienerCoefficients += WienerFiltering<16>(bmSrc, bmBasic, n, thrMapPtr1D);
+                    TC::inverseTransform16(bmBasic, n);
+                }
+                break;
+            case 8:
+                for (int n = 0; n < blockSizeSq; n++)
+                {
+                    TC::forwardTransform8(bmSrc, n);
+                    TC::forwardTransform8(bmBasic, n);
+                    wienerCoefficients += WienerFiltering<8>(bmSrc, bmBasic, n, thrMapPtr1D);
+                    TC::inverseTransform8(bmBasic, n);
+                }
+                break;
+            case 4:
+                for (int n = 0; n < blockSizeSq; n++)
+                {
+                    TC::forwardTransform4(bmSrc, n);
+                    TC::forwardTransform4(bmBasic, n);
+                    wienerCoefficients += WienerFiltering<4>(bmSrc, bmBasic, n, thrMapPtr1D);
+                    TC::inverseTransform4(bmBasic, n);
+                }
+                break;
+            case 2:
+                for (int n = 0; n < blockSizeSq; n++)
+                {
+                    TC::forwardTransform2(bmSrc, n);
+                    TC::forwardTransform2(bmBasic, n);
+                    wienerCoefficients += WienerFiltering<2>(bmSrc, bmBasic, n, thrMapPtr1D);
+                    TC::inverseTransform2(bmBasic, n);
+                }
+                break;
+            case 1:
+            {
+                for (int n = 0; n < blockSizeSq; n++)
+                    wienerCoefficients += WienerFiltering<1>(bmSrc, bmBasic, n, thrMapPtr1D);
+            }
+            break;
+            default:
+                for (int n = 0; n < blockSizeSq; n++)
+                {
+                    TC::forwardTransformN(bmSrc, n, elementSize);
+                    TC::forwardTransformN(bmBasic, n, elementSize);
+                    wienerCoefficients += WienerFiltering(bmSrc, bmBasic, n, thrMapPtr1D, elementSize);
+                    TC::inverseTransformN(bmBasic, n, elementSize);
+                }
+            }
+
+            // Inverse 2D transform
+            for (int n = 0; n < elementSize; ++n)
+                TC::inverseTransform2D(bmBasic[n].data(), blockSize);
+
+            // Aggregate the results (increase sumNonZero to avoid division by zero)
+            float weight = 1.0f / (float)(++wienerCoefficients);
+
+            // Scale weight by element size
+            weight *= elementSize;
+            weight /= groupSize;
+
+            // Put patches back to their original positions
+            WT *dstPtr = weightedSum.data() + jj * dstStep + i;
+            WT *weiPtr = weights.data() + jj * dstStep + i;
+            const float *kaiser = kaiser_;
+
+            for (int l = 0; l < elementSize; ++l)
+            {
+                const TT *block = bmBasic[l].data();
+                int offset = bmBasic[l].coord_y * dstStep + bmBasic[l].coord_x;
+                WT *d = dstPtr + offset;
+                WT *dw = weiPtr + offset;
+
+                for (int n = 0; n < blockSize; ++n)
+                {
+                    for (int m = 0; m < blockSize; ++m)
+                    {
+                        unsigned idx = n * blockSize + m;
+                        *d += kaiser[idx] * block[idx] * weight;
+                        *dw += kaiser[idx] * weight;
+                        ++d, ++dw;
+                    }
+                    d += dstcstep;
+                    dw += weicstep;
+                }
+            }
+        } // i
+    } // j
+
+    // Cleanup
+    for (int i = 0; i < searchWindowSizeSq; ++i)
+    {
+        bmBasic[i].release();
+        bmSrc[i].release();
+    }
+
+    delete[] bmSrc;
+    delete[] bmBasic;
+
+    // Divide accumulation buffer by the corresponding weights
+    for (int i = row_from, ii = 0; i <= row_to; ++i, ++ii)
+    {
+        T *d = dst_.ptr<T>(i);
+        float *dE = weightedSum.data() + (ii + halfSearchWindowSize + halfBlockSize) * dstStep + halfSearchWindowSize;
+        float *dw = weights.data() + (ii + halfSearchWindowSize + halfBlockSize) * dstStep + halfSearchWindowSize;
+        for (int j = 0; j < dst_.cols; ++j)
+            d[j] = cv::saturate_cast<T>(dE[j + halfBlockSize] / dw[j + halfBlockSize]);
+    }
+}
+
+
+template <typename T, typename D, typename WT, typename TT, typename TC>
+inline void Bm3dDenoisingInvokerStep2<T, D, WT, TT, TC>::calcDistSumsForFirstElementInRow(
+    int i,
+    Array2d<int>& distSums,
+    Array3d<int>& colDistSums,
+    Array3d<int>& lastColDistSums,
+    BlockMatch<TT, int, TT> *bm,
+    int &elementSize) const
+{
+    int j = 0;
+    const int hBM = hBM_;
+    const int blockSize = templateWindowSize_;
+    const int searchWindowSize = searchWindowSize_;
+    const TT halfSearchWindowSize = (TT)halfSearchWindowSize_;
+    const int ay = halfSearchWindowSize + i;
+    const int ax = halfSearchWindowSize + j;
+
+    for (TT y = 0; y < searchWindowSize; ++y)
+    {
+        for (TT x = 0; x < searchWindowSize; ++x)
+        {
+            // Zeroize arrays
+            distSums[y][x] = 0;
+            for (int tx = 0; tx < blockSize; tx++)
+                colDistSums[tx][y][x] = 0;
+
+            int start_y = i + y;
+            int start_x = j + x;
+
+            for (int ty = 0; ty < blockSize; ty++)
+                for (int tx = 0; tx < blockSize; tx++)
+                {
+                    int dist = D::template calcDist<T>(
+                        basicExtended_,
+                        ay + ty,
+                        ax + tx,
+                        start_y + ty,
+                        start_x + tx);
+
+                    distSums[y][x] += dist;
+                    colDistSums[tx][y][x] += dist;
+                }
+
+            lastColDistSums[j][y][x] = colDistSums[blockSize - 1][y][x];
+
+            if (x == halfSearchWindowSize && y == halfSearchWindowSize)
+                continue;
+
+            if (distSums[y][x] < hBM)
+                bm[elementSize++](distSums[y][x], x, y);
+        }
+    }
+}
+
+template <typename T, typename D, typename WT, typename TT, typename TC>
+inline void Bm3dDenoisingInvokerStep2<T, D, WT, TT, TC>::calcDistSumsForAllElementsInFirstRow(
+    int i,
+    int j,
+    int firstColNum,
+    Array2d<int>& distSums,
+    Array3d<int>& colDistSums,
+    Array3d<int>& lastColDistSums,
+    BlockMatch<TT, int, TT> *bm,
+    int &elementSize) const
+{
+    const int hBM = hBM_;
+    const int blockSize = templateWindowSize_;
+    const int searchWindowSize = searchWindowSize_;
+    const TT halfSearchWindowSize = (TT)halfSearchWindowSize_;
+
+    const int bx_start = blockSize - 1 + j;
+    const int ax = halfSearchWindowSize + bx_start;
+    const int ay = halfSearchWindowSize + i;
+
+    for (TT y = 0; y < searchWindowSize; ++y)
+    {
+        for (TT x = 0; x < searchWindowSize; ++x)
+        {
+            distSums[y][x] -= colDistSums[firstColNum][y][x];
+
+            colDistSums[firstColNum][y][x] = 0;
+            int by = i + y;
+            int bx = bx_start + x;
+
+            for (int ty = 0; ty < blockSize; ty++)
+                colDistSums[firstColNum][y][x] += D::template calcDist<T>(
+                    basicExtended_,
+                    ay + ty,
+                    ax,
+                    by + ty,
+                    bx);
+
+            distSums[y][x] += colDistSums[firstColNum][y][x];
+            lastColDistSums[j][y][x] = colDistSums[firstColNum][y][x];
+
+            if (x == halfSearchWindowSize && y == halfSearchWindowSize)
+                continue;
+
+            if (distSums[y][x] < hBM)
+                bm[elementSize++](distSums[y][x], x, y);
+        }
+    }
+}
+
+}  // namespace xphoto
+}  // namespace cv
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_structs.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_structs.hpp
new file mode 100644
index 00000000..1db0dc77
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_invoker_structs.hpp
@@ -0,0 +1,366 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BM3D_DENOISING_INVOKER_STRUCTS_HPP__
+#define __OPENCV_BM3D_DENOISING_INVOKER_STRUCTS_HPP__
+
+namespace cv
+{
+namespace xphoto
+{
+
+template <typename T, typename DT, typename CT>
+class BlockMatch
+{
+public:
+    // Data accessor
+    T* data()
+    {
+        return data_;
+    }
+
+    // Const version of data accessor
+    const T* data() const
+    {
+        return data_;
+    }
+
+    // Allocate memory for data
+    void init(const int &blockSizeSq)
+    {
+        data_ = new T[blockSizeSq];
+    }
+
+    // Release data memory
+    void release()
+    {
+        delete[] data_;
+    }
+
+    // Overloaded operator for convenient assignment
+    void operator()(const DT &_dist, const CT &_coord_x, const CT &_coord_y)
+    {
+        dist = _dist;
+        coord_x = _coord_x;
+        coord_y = _coord_y;
+    }
+
+    // Overloaded array subscript operator
+    T& operator[](const std::size_t &idx)
+    {
+        return data_[idx];
+    };
+
+    // Overloaded const array subscript operator
+    const T& operator[](const std::size_t &idx) const
+    {
+        return data_[idx];
+    };
+
+    // Overloaded comparison operator for sorting
+    bool operator<(const BlockMatch& right) const
+    {
+        return dist < right.dist;
+    }
+
+    // Block matching distance
+    DT dist;
+
+    // Relative coordinates to the current search window
+    CT coord_x;
+    CT coord_y;
+
+private:
+    // Pointer to the pixel values of the block
+    T *data_;
+};
+
+class DistAbs
+{
+    template <typename T>
+    struct calcDist_
+    {
+        static inline int f(const T &a, const T &b)
+        {
+            return std::abs(a - b);
+        }
+    };
+
+    template <typename ET>
+    struct calcDist_<Vec<ET, 2> >
+    {
+        static inline int f(const Vec<ET, 2> a, const Vec<ET, 2> b)
+        {
+            return std::abs((int)(a[0] - b[0])) + std::abs((int)(a[1] - b[1]));
+        }
+    };
+
+    template <typename ET>
+    struct calcDist_<Vec<ET, 3> >
+    {
+        static inline int f(const Vec<ET, 3> a, const Vec<ET, 3> b)
+        {
+            return
+                std::abs((int)(a[0] - b[0])) +
+                std::abs((int)(a[1] - b[1])) +
+                std::abs((int)(a[2] - b[2]));
+        }
+    };
+
+    template <typename ET>
+    struct calcDist_<Vec<ET, 4> >
+    {
+        static inline int f(const Vec<ET, 4> a, const Vec<ET, 4> b)
+        {
+            return
+                std::abs((int)(a[0] - b[0])) +
+                std::abs((int)(a[1] - b[1])) +
+                std::abs((int)(a[2] - b[2])) +
+                std::abs((int)(a[3] - b[3]));
+        }
+    };
+
+public:
+    template <typename T>
+    static inline int calcDist(const T &a, const T &b)
+    {
+        return calcDist_<T>::f(a, b);
+    }
+
+    template <typename T>
+    static inline int calcDist(const Mat& m, int i1, int j1, int i2, int j2)
+    {
+        const T a = m.at<T>(i1, j1);
+        const T b = m.at<T>(i2, j2);
+        return calcDist<T>(a, b);
+    }
+
+    template <typename T>
+    static inline int calcUpDownDist(T a_up, T a_down, T b_up, T b_down)
+    {
+        return calcDist<T>(a_down, b_down) - calcDist<T>(a_up, b_up);
+    };
+
+    template <typename T>
+    static inline T calcBlockMatchingThreshold(const T &blockMatchThrL2, const T &blockSizeSq)
+    {
+        return (T)(std::sqrt((double)blockMatchThrL2) * blockSizeSq);
+    }
+};
+
+class DistSquared
+{
+    template <typename T>
+    struct calcDist_
+    {
+        static inline int f(const T &a, const T &b)
+        {
+            return (a - b) * (a - b);
+        }
+    };
+
+    template <typename ET>
+    struct calcDist_<Vec<ET, 2> >
+    {
+        static inline int f(const Vec<ET, 2> a, const Vec<ET, 2> b)
+        {
+            return (int)(a[0] - b[0])*(int)(a[0] - b[0]) + (int)(a[1] - b[1])*(int)(a[1] - b[1]);
+        }
+    };
+
+    template <typename ET>
+    struct calcDist_<Vec<ET, 3> >
+    {
+        static inline int f(const Vec<ET, 3> a, const Vec<ET, 3> b)
+        {
+            return
+                (int)(a[0] - b[0])*(int)(a[0] - b[0]) +
+                (int)(a[1] - b[1])*(int)(a[1] - b[1]) +
+                (int)(a[2] - b[2])*(int)(a[2] - b[2]);
+        }
+    };
+
+    template <typename ET>
+    struct calcDist_<Vec<ET, 4> >
+    {
+        static inline int f(const Vec<ET, 4> a, const Vec<ET, 4> b)
+        {
+            return
+                (int)(a[0] - b[0])*(int)(a[0] - b[0]) +
+                (int)(a[1] - b[1])*(int)(a[1] - b[1]) +
+                (int)(a[2] - b[2])*(int)(a[2] - b[2]) +
+                (int)(a[3] - b[3])*(int)(a[3] - b[3]);
+        }
+    };
+
+    template <typename T> struct calcUpDownDist_
+    {
+        static inline int f(T a_up, T a_down, T b_up, T b_down)
+        {
+            int A = a_down - b_down;
+            int B = a_up - b_up;
+            return (A - B)*(A + B);
+        }
+    };
+
+    template <typename ET, int n> struct calcUpDownDist_<Vec<ET, n> >
+    {
+    private:
+        typedef Vec<ET, n> T;
+    public:
+        static inline int f(T a_up, T a_down, T b_up, T b_down)
+        {
+            return calcDist<T>(a_down, b_down) - calcDist<T>(a_up, b_up);
+        }
+    };
+
+public:
+    template <typename T>
+    static inline int calcDist(const T &a, const T &b)
+    {
+        return calcDist_<T>::f(a, b);
+    }
+
+    template <typename T>
+    static inline int calcDist(const Mat& m, int i1, int j1, int i2, int j2)
+    {
+        const T a = m.at<T>(i1, j1);
+        const T b = m.at<T>(i2, j2);
+        return calcDist<T>(a, b);
+    }
+
+    template <typename T>
+    static inline int calcUpDownDist(T a_up, T a_down, T b_up, T b_down)
+    {
+        return calcUpDownDist_<T>::f(a_up, a_down, b_up, b_down);
+    };
+
+    template <typename T>
+    static inline T calcBlockMatchingThreshold(const T &blockMatchThrL2, const T &blockSizeSq)
+    {
+        return blockMatchThrL2 * blockSizeSq;
+    }
+};
+
+template <class T>
+struct Array2d
+{
+    T* a;
+    int n1, n2;
+    bool needToDeallocArray;
+
+    Array2d(const Array2d& array2d) :
+        a(array2d.a), n1(array2d.n1), n2(array2d.n2), needToDeallocArray(false)
+    {
+        if (array2d.needToDeallocArray)
+        {
+            CV_Error(Error::BadDataPtr, "Copy constructor for self allocating arrays not supported");
+        }
+    }
+
+    Array2d(T* _a, int _n1, int _n2) :
+        a(_a), n1(_n1), n2(_n2), needToDeallocArray(false)
+    {
+    }
+
+    Array2d(int _n1, int _n2) :
+        n1(_n1), n2(_n2), needToDeallocArray(true)
+    {
+        a = new T[n1*n2];
+    }
+
+    ~Array2d()
+    {
+        if (needToDeallocArray)
+            delete[] a;
+    }
+
+    T* operator [] (int i)
+    {
+        return a + i*n2;
+    }
+
+    inline T* row_ptr(int i)
+    {
+        return (*this)[i];
+    }
+};
+
+template <class T>
+struct Array3d
+{
+    T* a;
+    int n1, n2, n3;
+    bool needToDeallocArray;
+
+    Array3d(T* _a, int _n1, int _n2, int _n3) :
+        a(_a), n1(_n1), n2(_n2), n3(_n3), needToDeallocArray(false)
+    {
+    }
+
+    Array3d(int _n1, int _n2, int _n3) :
+        n1(_n1), n2(_n2), n3(_n3), needToDeallocArray(true)
+    {
+        a = new T[n1*n2*n3];
+    }
+
+    ~Array3d()
+    {
+        if (needToDeallocArray)
+            delete[] a;
+    }
+
+    Array2d<T> operator [] (int i)
+    {
+        Array2d<T> array2d(a + i*n2*n3, n2, n3);
+        return array2d;
+    }
+
+    inline T* row_ptr(int i1, int i2)
+    {
+        return a + i1*n2*n3 + i2*n3;
+    }
+};
+
+}  // namespace xphoto
+}  // namespace cv
+
+#endif
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms.hpp
new file mode 100644
index 00000000..ded5c53b
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms.hpp
@@ -0,0 +1,73 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BM3D_DENOISING_TRANSFORMS_HPP__
+#define __OPENCV_BM3D_DENOISING_TRANSFORMS_HPP__
+
+#include "bm3d_denoising_transforms_haar.hpp"
+
+namespace cv
+{
+namespace xphoto
+{
+
+// Following class contains interface of the transform domain functions.
+template <typename T, typename TT>
+class Transform
+{
+  public:
+    // 2D transforms
+    typedef void(*Forward2D)(const T *ptr, TT *dst, const int &step, const int blockSize);
+    typedef void(*Inverse2D)(TT *src, const int blockSize);
+
+    // 1D transforms
+    typedef void(*Forward1D)(BlockMatch<TT, int, TT> *z, const int &n, const unsigned &N);
+    typedef void(*Inverse1D)(BlockMatch<TT, int, TT> *z, const int &n, const unsigned &N);
+
+    // Specialized 1D transforms
+    typedef void(*Forward1Ds)(BlockMatch<TT, int, TT> *z, const int &n);
+    typedef void(*Inverse1Ds)(BlockMatch<TT, int, TT> *z, const int &n);
+};
+
+}  // namespace xphoto
+}  // namespace cv
+
+#endif
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms_1D.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms_1D.hpp
new file mode 100644
index 00000000..595e1a9e
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms_1D.hpp
@@ -0,0 +1,376 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BM3D_DENOISING_TRANSFORMS_1D_HPP__
+#define __OPENCV_BM3D_DENOISING_TRANSFORMS_1D_HPP__
+
+namespace cv
+{
+namespace xphoto
+{
+
+class HaarTransform1D
+{
+    static void CalculateIndicesN(unsigned *diffIndices, const unsigned &size, const unsigned &N)
+    {
+        unsigned diffIdx = 1;
+        unsigned diffAllIdx = 0;
+        for (unsigned i = 1; i <= N; i <<= 1)
+        {
+            diffAllIdx += (i >> 1);
+            for (unsigned j = 0; j < (i >> 1); ++j)
+                diffIndices[diffIdx++] = size - (--diffAllIdx);
+            diffAllIdx += i;
+        }
+    }
+
+public:
+    /// 1D forward transformations of array of arbitrary size
+    template <typename T, typename DT, typename CT>
+    inline static void ForwardTransformN(BlockMatch<T, DT, CT> *src, const int &n, const unsigned &N)
+    {
+        const unsigned size = N + (N << 1) - 2;
+        T *dstX = new T[size];
+
+        // Fill dstX with source values
+        for (unsigned i = 0; i < N; ++i)
+            dstX[i] = src[i][n];
+
+        unsigned idx = 0, dstIdx = N;
+        for (unsigned i = N; i > 1; i >>= 1)
+        {
+            // Get sums
+            for (unsigned j = 0; j < (i >> 1); ++j)
+                dstX[dstIdx++] = (dstX[idx + 2 * j] + dstX[idx + j * 2 + 1] + 1) >> 1;
+
+            // Get diffs
+            for (unsigned j = 0; j < (i >> 1); ++j)
+                dstX[dstIdx++] = dstX[idx + 2 * j] - dstX[idx + j * 2 + 1];
+
+            idx = dstIdx - i;
+        }
+
+        // Calculate indices in the destination matrix.
+        unsigned *diffIndices = new unsigned[N];
+        CalculateIndicesN(diffIndices, size, N);
+
+        // Fill in destination matrix
+        src[0][n] = dstX[size - 2];
+        for (unsigned i = 1; i < N; ++i)
+            src[i][n] = dstX[diffIndices[i]];
+
+        delete[] dstX;
+        delete[] diffIndices;
+    }
+
+    /// 1D inverse transformation of array of arbitrary size
+    template <typename T, typename DT, typename CT>
+    inline static void InverseTransformN(BlockMatch<T, DT, CT> *src, const int &n, const unsigned &N)
+    {
+        const unsigned dstSize = (N << 1) - 2;
+        T *dstX = new T[dstSize];
+        T *srcX = new T[N];
+
+        // Fill srcX with source values
+        srcX[0] = src[0][n] * 2;
+        for (unsigned i = 1; i < N; ++i)
+            srcX[i] = src[i][n];
+
+        // Take care of first two elements
+        dstX[0] = srcX[0] + srcX[1];
+        dstX[1] = srcX[0] - srcX[1];
+
+        unsigned idx = 0, dstIdx = 2;
+        for (unsigned i = 4; i < N; i <<= 1)
+        {
+            for (unsigned j = 0; j < (i >> 1); ++j)
+            {
+                dstX[dstIdx++] = dstX[idx + j] + srcX[idx + 2 + j];
+                dstX[dstIdx++] = dstX[idx + j] - srcX[idx + 2 + j];
+            }
+            idx += (i >> 1);
+        }
+
+        // Handle the last X elements
+        dstIdx = 0;
+        for (unsigned j = 0; j < (N >> 1); ++j)
+        {
+            src[dstIdx++][n] = (dstX[idx + j] + srcX[idx + 2 + j]) >> 1;
+            src[dstIdx++][n] = (dstX[idx + j] - srcX[idx + 2 + j]) >> 1;
+        }
+
+        delete[] srcX;
+        delete[] dstX;
+    }
+
+    /// 1D forward transformations of fixed array size: 2, 4, 8 and 16
+
+    template <typename T, typename DT, typename CT>
+    inline static void ForwardTransform2(BlockMatch<T, DT, CT> *z, const int &n)
+    {
+        T sum = (z[0][n] + z[1][n] + 1) >> 1;
+        T dif = z[0][n] - z[1][n];
+
+        z[0][n] = sum;
+        z[1][n] = dif;
+    }
+
+    template <typename T, typename DT, typename CT>
+    inline static void ForwardTransform4(BlockMatch<T, DT, CT> *z, const int &n)
+    {
+        T sum0 = (z[0][n] + z[1][n] + 1) >> 1;
+        T sum1 = (z[2][n] + z[3][n] + 1) >> 1;
+        T dif0 = z[0][n] - z[1][n];
+        T dif1 = z[2][n] - z[3][n];
+
+        T sum00 = (sum0 + sum1 + 1) >> 1;
+        T dif00 = sum0 - sum1;
+
+        z[0][n] = sum00;
+        z[1][n] = dif00;
+        z[2][n] = dif0;
+        z[3][n] = dif1;
+    }
+
+    template <typename T, typename DT, typename CT>
+    inline static void ForwardTransform8(BlockMatch<T, DT, CT> *z, const int &n)
+    {
+        T sum0 = (z[0][n] + z[1][n] + 1) >> 1;
+        T sum1 = (z[2][n] + z[3][n] + 1) >> 1;
+        T sum2 = (z[4][n] + z[5][n] + 1) >> 1;
+        T sum3 = (z[6][n] + z[7][n] + 1) >> 1;
+        T dif0 = z[0][n] - z[1][n];
+        T dif1 = z[2][n] - z[3][n];
+        T dif2 = z[4][n] - z[5][n];
+        T dif3 = z[6][n] - z[7][n];
+
+        T sum00 = (sum0 + sum1 + 1) >> 1;
+        T sum11 = (sum2 + sum3 + 1) >> 1;
+        T dif00 = sum0 - sum1;
+        T dif11 = sum2 - sum3;
+
+        T sum000 = (sum00 + sum11 + 1) >> 1;
+        T dif000 = sum00 - sum11;
+
+        z[0][n] = sum000;
+        z[1][n] = dif000;
+        z[2][n] = dif00;
+        z[3][n] = dif11;
+        z[4][n] = dif0;
+        z[5][n] = dif1;
+        z[6][n] = dif2;
+        z[7][n] = dif3;
+    }
+
+    template <typename T, typename DT, typename CT>
+    inline static void ForwardTransform16(BlockMatch<T, DT, CT> *z, const int &n)
+    {
+        T sum0 = (z[0][n] + z[1][n] + 1) >> 1;
+        T sum1 = (z[2][n] + z[3][n] + 1) >> 1;
+        T sum2 = (z[4][n] + z[5][n] + 1) >> 1;
+        T sum3 = (z[6][n] + z[7][n] + 1) >> 1;
+        T sum4 = (z[8][n] + z[9][n] + 1) >> 1;
+        T sum5 = (z[10][n] + z[11][n] + 1) >> 1;
+        T sum6 = (z[12][n] + z[13][n] + 1) >> 1;
+        T sum7 = (z[14][n] + z[15][n] + 1) >> 1;
+        T dif0 = z[0][n] - z[1][n];
+        T dif1 = z[2][n] - z[3][n];
+        T dif2 = z[4][n] - z[5][n];
+        T dif3 = z[6][n] - z[7][n];
+        T dif4 = z[8][n] - z[9][n];
+        T dif5 = z[10][n] - z[11][n];
+        T dif6 = z[12][n] - z[13][n];
+        T dif7 = z[14][n] - z[15][n];
+
+        T sum00 = (sum0 + sum1 + 1) >> 1;
+        T sum11 = (sum2 + sum3 + 1) >> 1;
+        T sum22 = (sum4 + sum5 + 1) >> 1;
+        T sum33 = (sum6 + sum7 + 1) >> 1;
+        T dif00 = sum0 - sum1;
+        T dif11 = sum2 - sum3;
+        T dif22 = sum4 - sum5;
+        T dif33 = sum6 - sum7;
+
+        T sum000 = (sum00 + sum11 + 1) >> 1;
+        T sum111 = (sum22 + sum33 + 1) >> 1;
+        T dif000 = sum00 - sum11;
+        T dif111 = sum22 - sum33;
+
+        T sum0000 = (sum000 + sum111 + 1) >> 1;
+        T dif0000 = dif000 - dif111;
+
+        z[0][n] = sum0000;
+        z[1][n] = dif0000;
+        z[2][n] = dif000;
+        z[3][n] = dif111;
+        z[4][n] = dif00;
+        z[5][n] = dif11;
+        z[6][n] = dif22;
+        z[7][n] = dif33;
+        z[8][n] = dif0;
+        z[9][n] = dif1;
+        z[10][n] = dif2;
+        z[11][n] = dif3;
+        z[12][n] = dif4;
+        z[13][n] = dif5;
+        z[14][n] = dif6;
+        z[15][n] = dif7;
+    }
+
+    /// 1D inverse transformations of fixed array size: 2, 4, 8 and 16
+
+    template <typename T, typename DT, typename CT>
+    inline static void InverseTransform2(BlockMatch<T, DT, CT> *src, const int &n)
+    {
+        T src0 = src[0][n] * 2;
+        T src1 = src[1][n];
+
+        src[0][n] = (src0 + src1) >> 1;
+        src[1][n] = (src0 - src1) >> 1;
+    }
+
+    template <typename T, typename DT, typename CT>
+    inline static void InverseTransform4(BlockMatch<T, DT, CT> *src, const int &n)
+    {
+        T src0 = src[0][n] * 2;
+        T src1 = src[1][n];
+        T src2 = src[2][n];
+        T src3 = src[3][n];
+
+        T sum0 = src0 + src1;
+        T dif0 = src0 - src1;
+
+        src[0][n] = (sum0 + src2) >> 1;
+        src[1][n] = (sum0 - src2) >> 1;
+        src[2][n] = (dif0 + src3) >> 1;
+        src[3][n] = (dif0 - src3) >> 1;
+    }
+
+    template <typename T, typename DT, typename CT>
+    inline static void InverseTransform8(BlockMatch<T, DT, CT> *src, const int &n)
+    {
+        T src0 = src[0][n] * 2;
+        T src1 = src[1][n];
+        T src2 = src[2][n];
+        T src3 = src[3][n];
+        T src4 = src[4][n];
+        T src5 = src[5][n];
+        T src6 = src[6][n];
+        T src7 = src[7][n];
+
+        T sum0 = src0 + src1;
+        T dif0 = src0 - src1;
+
+        T sum00 = sum0 + src2;
+        T dif00 = sum0 - src2;
+        T sum11 = dif0 + src3;
+        T dif11 = dif0 - src3;
+
+        src[0][n] = (sum00 + src4) >> 1;
+        src[1][n] = (sum00 - src4) >> 1;
+        src[2][n] = (dif00 + src5) >> 1;
+        src[3][n] = (dif00 - src5) >> 1;
+        src[4][n] = (sum11 + src6) >> 1;
+        src[5][n] = (sum11 - src6) >> 1;
+        src[6][n] = (dif11 + src7) >> 1;
+        src[7][n] = (dif11 - src7) >> 1;
+    }
+
+    template <typename T, typename DT, typename CT>
+    inline static void InverseTransform16(BlockMatch<T, DT, CT> *src, const int &n)
+    {
+        T src0 = src[0][n] * 2;
+        T src1 = src[1][n];
+        T src2 = src[2][n];
+        T src3 = src[3][n];
+        T src4 = src[4][n];
+        T src5 = src[5][n];
+        T src6 = src[6][n];
+        T src7 = src[7][n];
+        T src8 = src[8][n];
+        T src9 = src[9][n];
+        T src10 = src[10][n];
+        T src11 = src[11][n];
+        T src12 = src[12][n];
+        T src13 = src[13][n];
+        T src14 = src[14][n];
+        T src15 = src[15][n];
+
+        T sum0 = src0 + src1;
+        T dif0 = src0 - src1;
+
+        T sum00 = sum0 + src2;
+        T dif00 = sum0 - src2;
+        T sum11 = dif0 + src3;
+        T dif11 = dif0 - src3;
+
+        T sum000 = sum00 + src4;
+        T dif000 = sum00 - src4;
+        T sum111 = dif00 + src5;
+        T dif111 = dif00 - src5;
+        T sum222 = sum11 + src6;
+        T dif222 = sum11 - src6;
+        T sum333 = dif11 + src7;
+        T dif333 = dif11 - src7;
+
+        src[0][n] = (sum000 + src8) >> 1;
+        src[1][n] = (sum000 - src8) >> 1;
+        src[2][n] = (dif000 + src9) >> 1;
+        src[3][n] = (dif000 - src9) >> 1;
+        src[4][n] = (sum111 + src10) >> 1;
+        src[5][n] = (sum111 - src10) >> 1;
+        src[6][n] = (dif111 + src11) >> 1;
+        src[7][n] = (dif111 - src11) >> 1;
+        src[8][n] = (sum222 + src12) >> 1;
+        src[9][n] = (sum222 - src12) >> 1;
+        src[10][n] = (dif222 + src13) >> 1;
+        src[11][n] = (dif222 - src13) >> 1;
+        src[12][n] = (sum333 + src14) >> 1;
+        src[13][n] = (sum333 - src14) >> 1;
+        src[14][n] = (dif333 + src15) >> 1;
+        src[15][n] = (dif333 - src15) >> 1;
+    }
+};
+
+}  // namespace xphoto
+}  // namespace cv
+
+#endif
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms_2D.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms_2D.hpp
new file mode 100644
index 00000000..f5ef915d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms_2D.hpp
@@ -0,0 +1,511 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BM3D_DENOISING_TRANSFORMS_2D_HPP__
+#define __OPENCV_BM3D_DENOISING_TRANSFORMS_2D_HPP__
+
+namespace cv
+{
+namespace xphoto
+{
+
+class HaarTransform2D
+{
+    template <int X>
+    static void CalculateIndices(unsigned *diffIndices, const unsigned &size)
+    {
+        unsigned diffIdx = 1;
+        unsigned diffAllIdx = 0;
+        for (unsigned i = 1; i <= X; i <<= 1)
+        {
+            diffAllIdx += (i >> 1);
+            for (unsigned j = 0; j < (i >> 1); ++j)
+                diffIndices[diffIdx++] = size - (--diffAllIdx);
+            diffAllIdx += i;
+        }
+    }
+
+public:
+    /// Transforms for 2D block of arbitrary size
+    template <typename T, typename TT, int X, int N>
+    inline static void ForwardTransformX(const T *src, TT *dst, const int &step)
+    {
+        const unsigned size = X + (X << 1) - 2;
+        TT dstX[size];
+
+        // Fill dstX with source values
+        for (unsigned i = 0; i < X; ++i)
+            dstX[i] = *(src + i * step);
+
+        unsigned idx = 0, dstIdx = X;
+        for (unsigned i = X; i > 1; i >>= 1)
+        {
+            // Get sums
+            for (unsigned j = 0; j < (i >> 1); ++j)
+                dstX[dstIdx++] = (dstX[idx + 2 * j] + dstX[idx + j * 2 + 1] + 1) >> 1;
+
+            // Get diffs
+            for (unsigned j = 0; j < (i >> 1); ++j)
+                dstX[dstIdx++] = dstX[idx + 2 * j] - dstX[idx + j * 2 + 1];
+
+            idx = dstIdx - i;
+        }
+
+        // Calculate indices in the destination matrix.
+        unsigned diffIndices[X];
+        CalculateIndices<X>(diffIndices, size);
+
+        // Fill in destination matrix
+        dst[0] = dstX[size - 2];
+        for (int i = 1; i < X; ++i)
+            dst[i * N] = dstX[diffIndices[i]];
+    }
+
+    template <typename T, typename TT, int X>
+    inline static void ForwardTransformXxX(const T *ptr, TT *dst, const int &step, const int /*blockSize*/)
+    {
+        TT temp[X * X];
+
+        // Transform columns first
+        for (unsigned i = 0; i < X; ++i)
+            ForwardTransformX<T, TT, X, X>(ptr + i, temp + i, step);
+
+        // Then transform rows
+        for (unsigned i = 0; i < X; ++i)
+            ForwardTransformX<TT, TT, X, 1>(temp + i * X, dst + i * X, 1);
+    }
+
+    template <typename T, int X, int N>
+    inline static void InverseTransformX(T *src, T *dst)
+    {
+        const unsigned dstSize = (X << 1) - 2;
+        T dstX[dstSize];
+        T srcX[X];
+
+        // Fill srcX with source values
+        srcX[0] = src[0] * 2;
+        for (int i = 1; i < X; ++i)
+            srcX[i] = src[i * N];
+
+        // Take care of first two elements
+        dstX[0] = srcX[0] + srcX[1];
+        dstX[1] = srcX[0] - srcX[1];
+
+        unsigned idx = 0, dstIdx = 2;
+        for (int i = 4; i < X; i <<= 1)
+        {
+            for (int j = 0; j < (i >> 1); ++j)
+            {
+                dstX[dstIdx++] = dstX[idx + j] + srcX[idx + 2 + j];
+                dstX[dstIdx++] = dstX[idx + j] - srcX[idx + 2 + j];
+            }
+            idx += (i >> 1);
+        }
+
+        // Handle the last X elements
+        dstIdx = 0;
+        for (int j = 0; j < (X >> 1); ++j)
+        {
+            dst[dstIdx++ * N] = (dstX[idx + j] + srcX[idx + 2 + j]) >> 1;
+            dst[dstIdx++ * N] = (dstX[idx + j] - srcX[idx + 2 + j]) >> 1;
+        }
+    }
+
+    template <typename T, int X>
+    inline static void InverseTransformXxX(T *src, const int /*blockSize*/)
+    {
+        T temp[X * X];
+
+        // Invert columns first
+        for (int i = 0; i < X; ++i)
+            InverseTransformX<T, X, X>(src + i, temp + i);
+
+        // Then invert rows
+        for (int i = 0; i < X; ++i)
+            InverseTransformX<T, X, 1>(temp + i * X, src + i * X);
+    }
+
+    // Same as above but X and N are arguments, not template parameters.
+
+    static void CalculateIndices(int *diffIndices, const int &size, const int &X)
+    {
+        int diffIdx = 1;
+        int diffAllIdx = 0;
+        for (int i = 1; i <= X; i <<= 1)
+        {
+            diffAllIdx += (i >> 1);
+            for (int j = 0; j < (i >> 1); ++j)
+                diffIndices[diffIdx++] = size - (--diffAllIdx);
+            diffAllIdx += i;
+        }
+    }
+
+    template <typename T, typename TT>
+    inline static void ForwardTransformX(const T *src, TT *dst, const int &step, const int &X, const int &N)
+    {
+        const int size = X + (X << 1) - 2;
+        TT *dstX = new TT[size];
+
+        // Fill dstX with source values
+        for (int i = 0; i < X; ++i)
+            dstX[i] = *(src + i * step);
+
+        int idx = 0, dstIdx = X;
+        for (int i = X; i > 1; i >>= 1)
+        {
+            // Get sums
+            for (int j = 0; j < (i >> 1); ++j)
+                dstX[dstIdx++] = (dstX[idx + 2 * j] + dstX[idx + j * 2 + 1] + 1) >> 1;
+
+            // Get diffs
+            for (int j = 0; j < (i >> 1); ++j)
+                dstX[dstIdx++] = dstX[idx + 2 * j] - dstX[idx + j * 2 + 1];
+
+            idx = dstIdx - i;
+        }
+
+        // Calculate indices in the destination matrix.
+        int *diffIndices = new int[X];
+        CalculateIndices(diffIndices, size, X);
+
+        // Fill in destination matrix
+        dst[0] = dstX[size - 2];
+        for (int i = 1; i < X; ++i)
+            dst[i * N] = dstX[diffIndices[i]];
+
+        delete[] diffIndices;
+        delete[] dstX;
+    }
+
+    template <typename T, typename TT>
+    inline static void ForwardTransformXxX(const T *ptr, TT *dst, const int &step, const int X)
+    {
+        TT *temp = new TT[X * X];
+
+        // Transform columns first
+        for (int i = 0; i < X; ++i)
+            ForwardTransformX<T, TT>(ptr + i, temp + i, step, X, X);
+
+        // Then transform rows
+        for (int i = 0; i < X; ++i)
+            ForwardTransformX<TT, TT>(temp + i * X, dst + i * X, 1, X, 1);
+
+        delete[] temp;
+    }
+
+    template <typename T>
+    inline static void InverseTransformX(T *src, T *dst, const int &X, const int &N)
+    {
+        const unsigned dstSize = (X << 1) - 2;
+        T *dstX = new T[dstSize];
+        T *srcX = new T[X];
+
+        // Fill srcX with source values
+        srcX[0] = src[0] * 2;
+        for (int i = 1; i < X; ++i)
+            srcX[i] = src[i * N];
+
+        // Take care of first two elements
+        dstX[0] = srcX[0] + srcX[1];
+        dstX[1] = srcX[0] - srcX[1];
+
+        unsigned idx = 0, dstIdx = 2;
+        for (int i = 4; i < X; i <<= 1)
+        {
+            for (int j = 0; j < (i >> 1); ++j)
+            {
+                dstX[dstIdx++] = dstX[idx + j] + srcX[idx + 2 + j];
+                dstX[dstIdx++] = dstX[idx + j] - srcX[idx + 2 + j];
+            }
+            idx += (i >> 1);
+        }
+
+        // Handle the last X elements
+        dstIdx = 0;
+        for (int j = 0; j < (X >> 1); ++j)
+        {
+            dst[dstIdx++ * N] = (dstX[idx + j] + srcX[idx + 2 + j]) >> 1;
+            dst[dstIdx++ * N] = (dstX[idx + j] - srcX[idx + 2 + j]) >> 1;
+        }
+
+        delete[] dstX;
+        delete[] srcX;
+    }
+
+    template <typename T>
+    inline static void InverseTransformXxX(T *src, const int X)
+    {
+        T *temp = new T[X * X];
+
+        // Invert columns first
+        for (int i = 0; i < X; ++i)
+            InverseTransformX<T>(src + i, temp + i, X, X);
+
+        // Then invert rows
+        for (int i = 0; i < X; ++i)
+            InverseTransformX<T>(temp + i * X, src + i * X, X, 1);
+
+        delete[] temp;
+    }
+
+    /// Transforms for 2x2 2D block
+
+    template <typename T, typename TT, int N>
+    inline static void ForwardTransform2(const T *src, TT *dst, const int &step)
+    {
+        const T *src0 = src;
+        const T *src1 = src + 1 * step;
+
+        dst[0 * N] = (*src0 + *src1 + 1) >> 1;
+        dst[1 * N] = *src0 - *src1;
+    }
+
+    template <typename T, typename TT>
+    inline static void ForwardTransform2x2(const T *ptr, TT *dst, const int &step, const int /*blockSize*/)
+    {
+        TT temp[4];
+
+        // Transform columns first
+        for (int i = 0; i < 2; ++i)
+            ForwardTransform2<T, TT, 2>(ptr + i, temp + i, step);
+
+        // Then transform rows
+        for (int i = 0; i < 2; ++i)
+            ForwardTransform2<TT, TT, 1>(temp + i * 2, dst + i * 2, 1);
+    }
+
+    template <typename TT, int N>
+    inline static void InverseTransform2(TT *src, TT *dst)
+    {
+        TT src0 = src[0 * N] * 2;
+        TT src1 = src[1 * N];
+
+        dst[0 * N] = (src0 + src1) >> 1;
+        dst[1 * N] = (src0 - src1) >> 1;
+    }
+
+    template <typename T>
+    inline static void InverseTransform2x2(T *src, const int /*blockSize*/)
+    {
+        T temp[4];
+
+        // Invert columns first
+        for (int i = 0; i < 2; ++i)
+            InverseTransform2<T, 2>(src + i, temp + i);
+
+        // Then invert rows
+        for (int i = 0; i < 2; ++i)
+            InverseTransform2<T, 1>(temp + i * 2, src + i * 2);
+    }
+
+    /// Transforms for 4x4 2D block
+
+    template <typename T, typename TT, int N>
+    inline static void ForwardTransform4(const T *src, TT *dst, const int &step)
+    {
+        const T *src0 = src;
+        const T *src1 = src + 1 * step;
+        const T *src2 = src + 2 * step;
+        const T *src3 = src + 3 * step;
+
+        TT sum0 = (*src0 + *src1 + 1) >> 1;
+        TT sum1 = (*src2 + *src3 + 1) >> 1;
+        TT dif0 = *src0 - *src1;
+        TT dif1 = *src2 - *src3;
+
+        TT sum00 = (sum0 + sum1 + 1) >> 1;
+        TT dif00 = sum0 - sum1;
+
+        dst[0 * N] = sum00;
+        dst[1 * N] = dif00;
+        dst[2 * N] = dif0;
+        dst[3 * N] = dif1;
+    }
+
+    template <typename T, typename TT>
+    inline static void ForwardTransform4x4(const T *ptr, TT *dst, const int &step, const int /*blockSize*/)
+    {
+        TT temp[16];
+
+        // Transform columns first
+        for (int i = 0; i < 4; ++i)
+            ForwardTransform4<T, TT, 4>(ptr + i, temp + i, step);
+
+        // Then transform rows
+        for (int i = 0; i < 4; ++i)
+            ForwardTransform4<TT, TT, 1>(temp + i * 4, dst + i * 4, 1);
+    }
+
+    template <typename TT, int N>
+    inline static void InverseTransform4(TT *src, TT *dst)
+    {
+        TT src0 = src[0 * N] * 2;
+        TT src1 = src[1 * N];
+        TT src2 = src[2 * N];
+        TT src3 = src[3 * N];
+
+        TT sum0 = src0 + src1;
+        TT dif0 = src0 - src1;
+
+        dst[0 * N] = (sum0 + src2) >> 1;
+        dst[1 * N] = (sum0 - src2) >> 1;
+        dst[2 * N] = (dif0 + src3) >> 1;
+        dst[3 * N] = (dif0 - src3) >> 1;
+    }
+
+    template <typename T>
+    inline static void InverseTransform4x4(T *src, const int /*blockSize*/)
+    {
+        T temp[16];
+
+        // Invert columns first
+        for (int i = 0; i < 4; ++i)
+            InverseTransform4<T, 4>(src + i, temp + i);
+
+        // Then invert rows
+        for (int i = 0; i < 4; ++i)
+            InverseTransform4<T, 1>(temp + i * 4, src + i * 4);
+    }
+
+    /// Transforms for 8x8 2D block
+
+    template <typename T, typename TT, int N>
+    inline static void ForwardTransform8(const T *src, TT *dst, const int &step)
+    {
+        const T *src0 = src;
+        const T *src1 = src + 1 * step;
+        const T *src2 = src + 2 * step;
+        const T *src3 = src + 3 * step;
+        const T *src4 = src + 4 * step;
+        const T *src5 = src + 5 * step;
+        const T *src6 = src + 6 * step;
+        const T *src7 = src + 7 * step;
+
+        TT sum0 = (*src0 + *src1 + 1) >> 1;
+        TT sum1 = (*src2 + *src3 + 1) >> 1;
+        TT sum2 = (*src4 + *src5 + 1) >> 1;
+        TT sum3 = (*src6 + *src7 + 1) >> 1;
+        TT dif0 = *src0 - *src1;
+        TT dif1 = *src2 - *src3;
+        TT dif2 = *src4 - *src5;
+        TT dif3 = *src6 - *src7;
+
+        TT sum00 = (sum0 + sum1 + 1) >> 1;
+        TT sum11 = (sum2 + sum3 + 1) >> 1;
+        TT dif00 = sum0 - sum1;
+        TT dif11 = sum2 - sum3;
+
+        TT sum000 = (sum00 + sum11 + 1) >> 1;
+        TT dif000 = sum00 - sum11;
+
+        dst[0 * N] = sum000;
+        dst[1 * N] = dif000;
+        dst[2 * N] = dif00;
+        dst[3 * N] = dif11;
+        dst[4 * N] = dif0;
+        dst[5 * N] = dif1;
+        dst[6 * N] = dif2;
+        dst[7 * N] = dif3;
+    }
+
+    template <typename T, typename TT>
+    inline static void ForwardTransform8x8(const T *ptr, TT *dst, const int &step, const int /*blockSize*/)
+    {
+        TT temp[64];
+
+        // Transform columns first
+        for (int i = 0; i < 8; ++i)
+            ForwardTransform8<T, TT, 8>(ptr + i, temp + i, step);
+
+        // Then transform rows
+        for (int i = 0; i < 8; ++i)
+            ForwardTransform8<TT, TT, 1>(temp + i * 8, dst + i * 8, 1);
+    }
+
+    template <typename T, int N>
+    inline static void InverseTransform8(T *src, T *dst)
+    {
+        T src0 = src[0] * 2;
+        T src1 = src[1 * N];
+        T src2 = src[2 * N];
+        T src3 = src[3 * N];
+        T src4 = src[4 * N];
+        T src5 = src[5 * N];
+        T src6 = src[6 * N];
+        T src7 = src[7 * N];
+
+        T sum0 = src0 + src1;
+        T dif0 = src0 - src1;
+
+        T sum00 = sum0 + src2;
+        T dif00 = sum0 - src2;
+        T sum11 = dif0 + src3;
+        T dif11 = dif0 - src3;
+
+        dst[0 * N] = (sum00 + src4) >> 1;
+        dst[1 * N] = (sum00 - src4) >> 1;
+        dst[2 * N] = (dif00 + src5) >> 1;
+        dst[3 * N] = (dif00 - src5) >> 1;
+        dst[4 * N] = (sum11 + src6) >> 1;
+        dst[5 * N] = (sum11 - src6) >> 1;
+        dst[6 * N] = (dif11 + src7) >> 1;
+        dst[7 * N] = (dif11 - src7) >> 1;
+    }
+
+    template <typename T>
+    inline static void InverseTransform8x8(T *src, const int /*blockSize*/)
+    {
+        T temp[64];
+
+        // Invert columns first
+        for (int i = 0; i < 8; ++i)
+            InverseTransform8<T, 8>(src + i, temp + i);
+
+        // Then invert rows
+        for (int i = 0; i < 8; ++i)
+            InverseTransform8<T, 1>(temp + i * 8, src + i * 8);
+    }
+};
+
+}  // namespace xphoto
+}  // namespace cv
+
+#endif
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms_haar.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms_haar.hpp
new file mode 100644
index 00000000..489b2ae4
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_denoising_transforms_haar.hpp
@@ -0,0 +1,290 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BM3D_DENOISING_TRANSFORMS_HAAR_HPP__
+#define __OPENCV_BM3D_DENOISING_TRANSFORMS_HAAR_HPP__
+
+#include "bm3d_denoising_transforms_1D.hpp"
+#include "bm3d_denoising_transforms_2D.hpp"
+
+namespace cv
+{
+namespace xphoto
+{
+
+// Forward declaration
+template <typename T, typename TT>
+class Transform;
+
+template <typename T, typename TT>
+class HaarTransform
+{
+    static void calcCoefficients1D(cv::Mat &coeff1D, const int &numberOfElements)
+    {
+        // Generate base array and initialize with zeros
+        cv::Mat baseArr = cv::Mat::zeros(numberOfElements, numberOfElements, CV_32FC1);
+
+        // Calculate base array coefficients.
+        int currentRow = 0;
+        for (int i = numberOfElements; i > 0; i /= 2)
+        {
+            for (int k = 0, sign = -1; k < numberOfElements; ++k)
+            {
+                // Alternate sign every i-th element
+                if (k % i == 0)
+                    sign *= -1;
+
+                // Move to the next row every 2*i-th element
+                if (k != 0 && (k % (2 * i) == 0))
+                    ++currentRow;
+
+                baseArr.at<float>(currentRow, k) = sign * 1.0f / i;
+            }
+            ++currentRow;
+        }
+
+        // Square each elements of the base array
+        float *ptr = baseArr.ptr<float>(0);
+        for (unsigned i = 0; i < baseArr.total(); ++i)
+            ptr[i] = ptr[i] * ptr[i];
+
+        // Multiply baseArray with 1D vector of ones
+        cv::Mat unitaryArr = cv::Mat::ones(numberOfElements, 1, CV_32FC1);
+        coeff1D = baseArr * unitaryArr;
+    }
+
+    // Method to generate threshold coefficients for 1D transform depending on the number of elements.
+    static void fillHaarCoefficients1D(float *thrCoeff1D, int &idx, const int &numberOfElements)
+    {
+        cv::Mat coeff1D;
+        calcCoefficients1D(coeff1D, numberOfElements);
+
+        // Square root the array to get standard deviation
+        float *ptr = coeff1D.ptr<float>(0);
+        for (unsigned i = 0; i < coeff1D.total(); ++i)
+        {
+            ptr[i] = std::sqrt(ptr[i]);
+            thrCoeff1D[idx++] = ptr[i];
+        }
+    }
+
+    // Method to generate threshold coefficients for 2D transform depending on the number of elements.
+    static void fillHaarCoefficients2D(float *thrCoeff2D, const int &templateWindowSize)
+    {
+        cv::Mat coeff1D;
+        calcCoefficients1D(coeff1D, templateWindowSize);
+
+        // Calculate 2D array
+        cv::Mat coeff1Dt;
+        cv::transpose(coeff1D, coeff1Dt);
+        cv::Mat coeff2D = coeff1D * coeff1Dt;
+
+        // Square root the array to get standard deviation
+        float *ptr = coeff2D.ptr<float>(0);
+        for (unsigned i = 0; i < coeff2D.total(); ++i)
+            thrCoeff2D[i] = std::sqrt(ptr[i]);
+    }
+
+public:
+    // Method to calculate 1D threshold map based on the maximum number of elements
+    // Allocates memory for the output array.
+    static void calcThresholdMap1D(float *&thrMap1D, const int &numberOfElements)
+    {
+        CV_Assert(numberOfElements > 0);
+
+        // Allocate memory for the array
+        const int arrSize = (numberOfElements << 1) - 1;
+        if (thrMap1D == NULL)
+            thrMap1D = new float[arrSize];
+
+        for (int i = 1, idx = 0; i <= numberOfElements; i *= 2)
+            fillHaarCoefficients1D(thrMap1D, idx, i);
+    }
+
+    // Method to calculate 2D threshold map based on the maximum number of elements
+    // Allocates memory for the output array.
+    static void calcThresholdMap2D(float *&thrMap2D, const int &templateWindowSize)
+    {
+        // Allocate memory for the array
+        if (thrMap2D == NULL)
+            thrMap2D = new float[templateWindowSize * templateWindowSize];
+
+        fillHaarCoefficients2D(thrMap2D, templateWindowSize);
+    }
+
+    // Method to calculate 3D threshold map based on the maximum number of elements.
+    // Allocates memory for the output array.
+    static void calcThresholdMap3D(
+        TT *&outThrMap1D,
+        const float &hardThr1D,
+        const int &templateWindowSize,
+        const int &groupSize)
+    {
+        const int templateWindowSizeSq = templateWindowSize * templateWindowSize;
+
+        // Allocate memory for the output array
+        if (outThrMap1D == NULL)
+            outThrMap1D = new TT[templateWindowSizeSq * ((groupSize << 1) - 1)];
+
+        // Generate 1D coefficients map
+        float *thrMap1D = NULL;
+        calcThresholdMap1D(thrMap1D, groupSize);
+
+        // Generate 2D coefficients map
+        float *thrMap2D = NULL;
+        calcThresholdMap2D(thrMap2D, templateWindowSize);
+
+        // Generate 3D threshold map
+        TT *thrMapPtr1D = outThrMap1D;
+        for (int i = 1, ii = 0; i <= groupSize; ++ii, i *= 2)
+        {
+            float coeff = (i == 1) ? 1.0f : std::sqrt(2.0f * std::log((float)i));
+            for (int jj = 0; jj < templateWindowSizeSq; ++jj)
+            {
+                for (int ii1 = 0; ii1 < (1 << ii); ++ii1)
+                {
+                    int indexIn1D = (1 << ii) - 1 + ii1;
+                    int indexIn2D = jj;
+                    int thr = static_cast<int>(thrMap1D[indexIn1D] * thrMap2D[indexIn2D] * hardThr1D * coeff);
+
+                    // Set DC component to zero
+                    if (jj == 0 && ii1 == 0)
+                        thr = 0;
+
+                    *thrMapPtr1D++ = cv::saturate_cast<TT>(thr);
+                }
+            }
+        }
+
+        delete[] thrMap1D;
+        delete[] thrMap2D;
+    }
+
+    // Method that registers 2D transform calls
+    static void RegisterTransforms2D(const int &templateWindowSize)
+    {
+        // Check if template window size is a power of two
+        if (!isPowerOf2(templateWindowSize))
+            CV_Error(Error::StsBadArg, "Unsupported template size! Template size must be power of two!");
+
+        switch (templateWindowSize)
+        {
+        case 2:
+            forwardTransform2D = HaarTransform2D::ForwardTransform2x2<T, TT>;
+            inverseTransform2D = HaarTransform2D::InverseTransform2x2<TT>;
+            break;
+        case 4:
+            forwardTransform2D = HaarTransform2D::ForwardTransform4x4<T, TT>;
+            inverseTransform2D = HaarTransform2D::InverseTransform4x4<TT>;
+            break;
+        case 8:
+            forwardTransform2D = HaarTransform2D::ForwardTransform8x8<T, TT>;
+            inverseTransform2D = HaarTransform2D::InverseTransform8x8<TT>;
+            break;
+        case 16:
+            forwardTransform2D = HaarTransform2D::ForwardTransformXxX<T, TT, 16>;
+            inverseTransform2D = HaarTransform2D::InverseTransformXxX<TT, 16>;
+            break;
+        case 32:
+            forwardTransform2D = HaarTransform2D::ForwardTransformXxX<T, TT, 32>;
+            inverseTransform2D = HaarTransform2D::InverseTransformXxX<TT, 32>;
+            break;
+        case 64:
+            forwardTransform2D = HaarTransform2D::ForwardTransformXxX<T, TT, 64>;
+            inverseTransform2D = HaarTransform2D::InverseTransformXxX<TT, 64>;
+            break;
+        default:
+            forwardTransform2D = HaarTransform2D::ForwardTransformXxX<T, TT>;
+            inverseTransform2D = HaarTransform2D::InverseTransformXxX<TT>;
+        }
+    }
+
+    // 2D transform pointers
+    static typename Transform<T, TT>::Forward2D forwardTransform2D;
+    static typename Transform<T, TT>::Inverse2D inverseTransform2D;
+
+    // 1D transform pointers
+    static typename Transform<T, TT>::Forward1D forwardTransformN;
+    static typename Transform<T, TT>::Inverse1D inverseTransformN;
+
+    // Specialized 1D forward transform pointers
+    static typename Transform<T, TT>::Forward1Ds forwardTransform2;
+    static typename Transform<T, TT>::Forward1Ds forwardTransform4;
+    static typename Transform<T, TT>::Forward1Ds forwardTransform8;
+    static typename Transform<T, TT>::Forward1Ds forwardTransform16;
+
+    // Specialized 1D inverse transform pointers
+    static typename Transform<T, TT>::Inverse1Ds inverseTransform2;
+    static typename Transform<T, TT>::Inverse1Ds inverseTransform4;
+    static typename Transform<T, TT>::Inverse1Ds inverseTransform8;
+    static typename Transform<T, TT>::Inverse1Ds inverseTransform16;
+};
+
+/// Explicit static members initialization
+
+#define INITIALIZE_HAAR_TRANSFORM(type, member, value)              \
+template <typename T, typename TT>                                  \
+typename Transform<T, TT>::type HaarTransform<T, TT>::member = value;
+
+// 2D transforms
+INITIALIZE_HAAR_TRANSFORM(Forward2D, forwardTransform2D, NULL)
+INITIALIZE_HAAR_TRANSFORM(Inverse2D, inverseTransform2D, NULL)
+
+// 1D transforms
+INITIALIZE_HAAR_TRANSFORM(Forward1D, forwardTransformN, HaarTransform1D::ForwardTransformN)
+INITIALIZE_HAAR_TRANSFORM(Inverse1D, inverseTransformN, HaarTransform1D::InverseTransformN)
+
+// Specialized 1D forward transforms
+INITIALIZE_HAAR_TRANSFORM(Forward1Ds, forwardTransform2, HaarTransform1D::ForwardTransform2)
+INITIALIZE_HAAR_TRANSFORM(Forward1Ds, forwardTransform4, HaarTransform1D::ForwardTransform4)
+INITIALIZE_HAAR_TRANSFORM(Forward1Ds, forwardTransform8, HaarTransform1D::ForwardTransform8)
+INITIALIZE_HAAR_TRANSFORM(Forward1Ds, forwardTransform16, HaarTransform1D::ForwardTransform16)
+
+// Specialized 1D inverse transforms
+INITIALIZE_HAAR_TRANSFORM(Inverse1Ds, inverseTransform2, HaarTransform1D::InverseTransform2)
+INITIALIZE_HAAR_TRANSFORM(Inverse1Ds, inverseTransform4, HaarTransform1D::InverseTransform4)
+INITIALIZE_HAAR_TRANSFORM(Inverse1Ds, inverseTransform8, HaarTransform1D::InverseTransform8)
+INITIALIZE_HAAR_TRANSFORM(Inverse1Ds, inverseTransform16, HaarTransform1D::InverseTransform16)
+
+}  // namespace xphoto
+}  // namespace cv
+
+#endif
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_image_denoising.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_image_denoising.cpp
new file mode 100644
index 00000000..6deb443f
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/bm3d_image_denoising.cpp
@@ -0,0 +1,349 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "opencv2/xphoto.hpp"
+#include "opencv2/core.hpp"
+
+#ifdef OPENCV_ENABLE_NONFREE
+
+#include "bm3d_denoising_invoker_step1.hpp"
+#include "bm3d_denoising_invoker_step2.hpp"
+#include "bm3d_denoising_transforms.hpp"
+
+#endif
+
+namespace cv
+{
+namespace xphoto
+{
+
+#ifdef OPENCV_ENABLE_NONFREE
+
+template<typename ST, typename D, typename TT>
+static void bm3dDenoising_(
+    const Mat& src,
+    Mat& basic,
+    Mat& dst,
+    const float& h,
+    const int &templateWindowSize,
+    const int &searchWindowSize,
+    const int &hBMStep1,
+    const int &hBMStep2,
+    const int &groupSize,
+    const int &slidingStep,
+    const float &beta,
+    const int &step)
+{
+    double granularity = (double)std::max(1., (double)src.total() / (1 << 16));
+
+    switch (CV_MAT_CN(src.type())) {
+    case 1:
+        if (step == BM3D_STEP1 || step == BM3D_STEPALL)
+        {
+            parallel_for_(cv::Range(0, src.rows),
+                Bm3dDenoisingInvokerStep1<ST, D, float, TT, HaarTransform<ST, TT> >(
+                    src,
+                    basic,
+                    templateWindowSize,
+                    searchWindowSize,
+                    h,
+                    hBMStep1,
+                    groupSize,
+                    slidingStep,
+                    beta),
+                granularity);
+        }
+        if (step == BM3D_STEP2 || step == BM3D_STEPALL)
+        {
+            parallel_for_(cv::Range(0, src.rows),
+                Bm3dDenoisingInvokerStep2<ST, D, float, TT, HaarTransform<ST, TT> >(
+                    src,
+                    basic,
+                    dst,
+                    templateWindowSize,
+                    searchWindowSize,
+                    h,
+                    hBMStep2,
+                    groupSize,
+                    slidingStep,
+                    beta),
+                granularity);
+        }
+        break;
+    default:
+        CV_Error(Error::StsBadArg,
+            "Unsupported number of channels! Only 1 channel is supported at the moment.");
+    }
+}
+
+void bm3dDenoising(
+    InputArray _src,
+    InputOutputArray _basic,
+    OutputArray _dst,
+    float h,
+    int templateWindowSize,
+    int searchWindowSize,
+    int blockMatchingStep1,
+    int blockMatchingStep2,
+    int groupSize,
+    int slidingStep,
+    float beta,
+    int normType,
+    int step,
+    int transformType)
+{
+    int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_Assert(1 == cn);
+    CV_Assert(HAAR == transformType);
+    CV_Assert(searchWindowSize > templateWindowSize);
+    CV_Assert(slidingStep > 0 && slidingStep < templateWindowSize);
+
+    Size srcSize = _src.size();
+
+    switch (step)
+    {
+    case BM3D_STEP1:
+        _basic.create(srcSize, type);
+        break;
+    case BM3D_STEP2:
+        CV_Assert(type == _basic.type());
+        _dst.create(srcSize, type);
+        break;
+    case BM3D_STEPALL:
+        if (_basic.needed())
+            _basic.create(srcSize, type);
+        _dst.create(srcSize, type);
+        break;
+    default:
+        CV_Error(Error::StsBadArg, "Unsupported BM3D step!");
+    }
+
+    Mat src = _src.getMat();
+    Mat basic = _basic.getMat().empty() ? Mat(srcSize, type) : _basic.getMat();
+    Mat dst = _dst.getMat();
+
+    switch (normType) {
+    case cv::NORM_L2:
+        switch (depth) {
+        case CV_8U:
+            bm3dDenoising_<uchar, DistSquared, short>(
+                src,
+                basic,
+                dst,
+                h,
+                templateWindowSize,
+                searchWindowSize,
+                blockMatchingStep1,
+                blockMatchingStep2,
+                groupSize,
+                slidingStep,
+                beta,
+                step);
+            break;
+        default:
+            CV_Error(Error::StsBadArg,
+                "Unsupported depth! Only CV_8U is supported for NORM_L2");
+        }
+        break;
+    case cv::NORM_L1:
+        switch (depth) {
+        case CV_8U:
+            bm3dDenoising_<uchar, DistAbs, short>(
+                src,
+                basic,
+                dst,
+                h,
+                templateWindowSize,
+                searchWindowSize,
+                blockMatchingStep1,
+                blockMatchingStep2,
+                groupSize,
+                slidingStep,
+                beta,
+                step);
+            break;
+        case CV_16U:
+            bm3dDenoising_<ushort, DistAbs, int>(
+                src,
+                basic,
+                dst,
+                h,
+                templateWindowSize,
+                searchWindowSize,
+                blockMatchingStep1,
+                blockMatchingStep2,
+                groupSize,
+                slidingStep,
+                beta,
+                step);
+            break;
+        default:
+            CV_Error(Error::StsBadArg,
+                "Unsupported depth! Only CV_8U and CV_16U are supported for NORM_L1");
+        }
+        break;
+    default:
+        CV_Error(Error::StsBadArg,
+            "Unsupported norm type! Only NORM_L2 and NORM_L1 are supported");
+    }
+}
+
+void bm3dDenoising(
+    InputArray _src,
+    OutputArray _dst,
+    float h,
+    int templateWindowSize,
+    int searchWindowSize,
+    int blockMatchingStep1,
+    int blockMatchingStep2,
+    int groupSize,
+    int slidingStep,
+    float beta,
+    int normType,
+    int step,
+    int transformType)
+{
+    if (step == BM3D_STEP2)
+        CV_Error(Error::StsBadArg,
+            "Unsupported step type! To use BM3D_STEP2 one need to provide basic image.");
+
+    Mat basic;
+
+    bm3dDenoising(
+        _src,
+        basic,
+        _dst,
+        h,
+        templateWindowSize,
+        searchWindowSize,
+        blockMatchingStep1,
+        blockMatchingStep2,
+        groupSize,
+        slidingStep,
+        beta,
+        normType,
+        step,
+        transformType);
+
+    if (step == BM3D_STEP1)
+        _dst.assign(basic);
+}
+
+#else
+
+void bm3dDenoising(
+    InputArray _src,
+    InputOutputArray _basic,
+    OutputArray _dst,
+    float h,
+    int templateWindowSize,
+    int searchWindowSize,
+    int blockMatchingStep1,
+    int blockMatchingStep2,
+    int groupSize,
+    int slidingStep,
+    float beta,
+    int normType,
+    int step,
+    int transformType)
+{
+    // Empty implementation
+
+    CV_UNUSED(_src);
+    CV_UNUSED(_basic);
+    CV_UNUSED(_dst);
+    CV_UNUSED(h);
+    CV_UNUSED(templateWindowSize);
+    CV_UNUSED(searchWindowSize);
+    CV_UNUSED(blockMatchingStep1);
+    CV_UNUSED(blockMatchingStep2);
+    CV_UNUSED(groupSize);
+    CV_UNUSED(slidingStep);
+    CV_UNUSED(beta);
+    CV_UNUSED(normType);
+    CV_UNUSED(step);
+    CV_UNUSED(transformType);
+
+    CV_Error(Error::StsNotImplemented,
+        "This algorithm is patented and is excluded in this configuration;"
+        "Set OPENCV_ENABLE_NONFREE CMake option and rebuild the library");
+}
+
+void bm3dDenoising(
+    InputArray _src,
+    OutputArray _dst,
+    float h,
+    int templateWindowSize,
+    int searchWindowSize,
+    int blockMatchingStep1,
+    int blockMatchingStep2,
+    int groupSize,
+    int slidingStep,
+    float beta,
+    int normType,
+    int step,
+    int transformType)
+{
+    // Empty implementation
+
+    CV_UNUSED(_src);
+    CV_UNUSED(_dst);
+    CV_UNUSED(h);
+    CV_UNUSED(templateWindowSize);
+    CV_UNUSED(searchWindowSize);
+    CV_UNUSED(blockMatchingStep1);
+    CV_UNUSED(blockMatchingStep2);
+    CV_UNUSED(groupSize);
+    CV_UNUSED(slidingStep);
+    CV_UNUSED(beta);
+    CV_UNUSED(normType);
+    CV_UNUSED(step);
+    CV_UNUSED(transformType);
+
+    CV_Error(Error::StsNotImplemented,
+        "This algorithm is patented and is excluded in this configuration;"
+        "Set OPENCV_ENABLE_NONFREE CMake option and rebuild the library");
+}
+
+#endif
+
+}  // namespace xphoto
+}  // namespace cv
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/dct_image_denoising.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/dct_image_denoising.cpp
new file mode 100644
index 00000000..c43bbb43
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/dct_image_denoising.cpp
@@ -0,0 +1,185 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <vector>
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+
+#include "opencv2/xphoto.hpp"
+
+#include "opencv2/imgproc.hpp"
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/core_c.h"
+
+#include "opencv2/core/types.hpp"
+#include "opencv2/core/types_c.h"
+
+namespace cv
+{
+namespace xphoto
+{
+
+    void grayDctDenoising(const Mat &, Mat &, const double, const int);
+    void rgbDctDenoising(const Mat &, Mat &, const double, const int);
+    void dctDenoising(const Mat &, Mat &, const double, const int);
+
+
+    struct grayDctDenoisingInvoker : public ParallelLoopBody
+    {
+    public:
+        grayDctDenoisingInvoker(const Mat &src, std::vector <Mat> &patches, const double sigma, const int psize);
+        ~grayDctDenoisingInvoker(){};
+
+        void operator() (const Range &range) const CV_OVERRIDE;
+
+    protected:
+        const Mat &src;
+        std::vector <Mat> &patches; // image decomposition into sliding patches
+
+        const int psize; // size of block to compute dct
+        const double sigma; // expected noise standard deviation
+        const double thresh; // thresholding estimate
+
+        void operator =(const grayDctDenoisingInvoker&) const {};
+    };
+
+    grayDctDenoisingInvoker::grayDctDenoisingInvoker(const Mat &_src, std::vector <Mat> &_patches,
+                                                     const double _sigma, const int _psize)
+        : src(_src), patches(_patches), psize(_psize), sigma(_sigma), thresh(3*_sigma) {}
+
+    void grayDctDenoisingInvoker::operator() (const Range &range) const
+    {
+        for (int i = range.start; i <= range.end - 1; ++i)
+        {
+            int y = i / (src.cols - psize);
+            int x = i % (src.cols - psize);
+
+            Rect patchNum( x, y, psize, psize );
+
+            Mat patch(psize, psize, CV_32FC1);
+            src(patchNum).copyTo( patch );
+
+            dct(patch, patch);
+            float *data = (float *) patch.data;
+            for (int k = 0; k < psize*psize; ++k)
+                data[k] *= fabs(data[k]) > thresh;
+            idct(patch, patches[i]);
+        }
+    }
+
+    void grayDctDenoising(const Mat &src, Mat &dst, const double sigma, const int psize)
+    {
+        CV_Assert( src.type() == CV_MAKE_TYPE(CV_32F, 1) );
+
+        int npixels = (src.rows - psize)*(src.cols - psize);
+
+        std::vector <Mat> patches;
+        for (int i = 0; i < npixels; ++i)
+            patches.push_back( Mat(psize, psize, CV_32FC1) );
+        parallel_for_( cv::Range(0, npixels),
+            grayDctDenoisingInvoker(src, patches, sigma, psize) );
+
+        Mat res( src.size(), CV_32FC1, 0.0f ),
+            num( src.size(), CV_32FC1, 0.0f );
+
+        for (int k = 0; k < npixels; ++k)
+        {
+            int i = k / (src.cols - psize);
+            int j = k % (src.cols - psize);
+
+            res( Rect(j, i, psize, psize) ) += patches[k];
+            num( Rect(j, i, psize, psize) ) += Mat::ones(psize, psize, CV_32FC1);
+        }
+        res /= num;
+
+        res.convertTo( dst, src.type() );
+    }
+
+    void rgbDctDenoising(const Mat &src, Mat &dst, const double sigma, const int psize)
+    {
+        CV_Assert( src.type() == CV_MAKE_TYPE(CV_32F, 3) );
+
+        cv::Matx33f mt(cvInvSqrt(3.0f),  cvInvSqrt(3.0f),       cvInvSqrt(3.0f),
+                       cvInvSqrt(2.0f),  0.0f,                 -cvInvSqrt(2.0f),
+                       cvInvSqrt(6.0f), -2.0f*cvInvSqrt(6.0f),  cvInvSqrt(6.0f));
+
+        cv::transform(src, dst, mt);
+
+        std::vector <Mat> mv;
+        split(dst, mv);
+
+        for (size_t i = 0; i < mv.size(); ++i)
+            grayDctDenoising(mv[i], mv[i], sigma, psize);
+
+        merge(mv, dst);
+
+        cv::transform( dst, dst, mt.inv() );
+    }
+
+    /*! This function implements simple dct-based image denoising,
+	 *	link: http://www.ipol.im/pub/art/2011/ys-dct/
+     *
+	 *  \param src : source image (rgb, or gray)
+     *  \param dst : destination image
+     *  \param sigma : expected noise standard deviation
+     *  \param psize : size of block side where dct is computed
+     */
+    void dctDenoising(const Mat &src, Mat &dst, const double sigma, const int psize)
+    {
+        CV_Assert( src.channels() == 3 || src.channels() == 1 );
+
+        int xtype = CV_MAKE_TYPE( CV_32F, src.channels() );
+        Mat img( src.size(), xtype );
+        src.convertTo(img, xtype);
+
+        if ( img.type() == CV_32FC3 )
+            rgbDctDenoising( img, img, sigma, psize );
+        else if ( img.type() == CV_32FC1 )
+            grayDctDenoising( img, img, sigma, psize );
+        else
+            CV_Error_( CV_StsNotImplemented,
+            ("Unsupported source image format (=%d)", img.type()) );
+
+        img.convertTo( dst, src.type() );
+    }
+
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/gcgraph.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/gcgraph.hpp
new file mode 100644
index 00000000..513e9c2d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/gcgraph.hpp
@@ -0,0 +1,386 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef _CV_GCGRAPH_H_
+#define _CV_GCGRAPH_H_
+
+
+template <class TWeight> class GCGraph
+{
+public:
+    GCGraph();
+    GCGraph( unsigned int vtxCount, unsigned int edgeCount );
+    ~GCGraph();
+    void create( unsigned int vtxCount, unsigned int edgeCount );
+    int addVtx();
+    void addEdges( int i, int j, TWeight w, TWeight revw );
+    void addTermWeights( int i, TWeight sourceW, TWeight sinkW );
+    TWeight maxFlow();
+    bool inSourceSegment( int i );
+private:
+    class Vtx
+    {
+    public:
+        Vtx *next; // initialized and used in maxFlow() only
+        int parent;
+        int first;
+        int ts;
+        int dist;
+        TWeight weight;
+        unsigned char t;
+    };
+    class Edge
+    {
+    public:
+        int dst;
+        int next;
+        TWeight weight;
+    };
+
+    ::std::vector<Vtx> vtcs;
+    ::std::vector<Edge> edges;
+    TWeight flow;
+};
+
+template <class TWeight>
+GCGraph<TWeight>::GCGraph()
+{
+    flow = 0;
+}
+template <class TWeight>
+GCGraph<TWeight>::GCGraph( unsigned int vtxCount, unsigned int edgeCount )
+{
+    create( vtxCount, edgeCount );
+}
+template <class TWeight>
+GCGraph<TWeight>::~GCGraph()
+{
+}
+template <class TWeight>
+void GCGraph<TWeight>::create( unsigned int vtxCount, unsigned int edgeCount )
+{
+    vtcs.reserve( vtxCount );
+    edges.reserve( edgeCount + 2 );
+    flow = 0;
+}
+
+template <class TWeight>
+int GCGraph<TWeight>::addVtx()
+{
+    Vtx v;
+    memset( &v, 0, sizeof(Vtx));
+    vtcs.push_back(v);
+    return (int)vtcs.size() - 1;
+}
+
+template <class TWeight>
+void GCGraph<TWeight>::addEdges( int i, int j, TWeight w, TWeight revw )
+{
+    CV_Assert( i>=0 && i<(int)vtcs.size() );
+    CV_Assert( j>=0 && j<(int)vtcs.size() );
+    CV_Assert( w>=0 && revw>=0 );
+    CV_Assert( i != j );
+
+    if( !edges.size() )
+        edges.resize( 2 );
+
+    Edge fromI, toI;
+    fromI.dst = j;
+    fromI.next = vtcs[i].first;
+    fromI.weight = w;
+    vtcs[i].first = (int)edges.size();
+    edges.push_back( fromI );
+
+    toI.dst = i;
+    toI.next = vtcs[j].first;
+    toI.weight = revw;
+    vtcs[j].first = (int)edges.size();
+    edges.push_back( toI );
+}
+
+template <class TWeight>
+void GCGraph<TWeight>::addTermWeights( int i, TWeight sourceW, TWeight sinkW )
+{
+    CV_Assert( i>=0 && i<(int)vtcs.size() );
+
+    TWeight dw = vtcs[i].weight;
+    if( dw > 0 )
+        sourceW += dw;
+    else
+        sinkW -= dw;
+    flow += (sourceW < sinkW) ? sourceW : sinkW;
+    vtcs[i].weight = sourceW - sinkW;
+}
+
+template <class TWeight>
+TWeight GCGraph<TWeight>::maxFlow()
+{
+    const int TERMINAL = -1, ORPHAN = -2;
+    Vtx stub, *nilNode = &stub, *first = nilNode, *last = nilNode;
+    int curr_ts = 0;
+    stub.next = nilNode;
+    Vtx *vtxPtr = &vtcs[0];
+    Edge *edgePtr = &edges[0];
+
+    ::std::vector<Vtx*> orphans;
+
+    // initialize the active queue and the graph vertices
+    for( int i = 0; i < (int)vtcs.size(); i++ )
+    {
+        Vtx* v = vtxPtr + i;
+        v->ts = 0;
+        if( v->weight != 0 )
+        {
+            last = last->next = v;
+            v->dist = 1;
+            v->parent = TERMINAL;
+            v->t = v->weight < 0;
+        }
+        else
+            v->parent = 0;
+    }
+    first = first->next;
+    last->next = nilNode;
+    nilNode->next = 0;
+
+    // run the search-path -> augment-graph -> restore-trees loop
+    for(;;)
+    {
+        Vtx* v, *u;
+        int e0 = -1, ei = 0, ej = 0;
+        TWeight minWeight, weight;
+        uchar vt;
+
+        // grow S & T search trees, find an edge connecting them
+        while( first != nilNode )
+        {
+            v = first;
+            if( v->parent )
+            {
+                vt = v->t;
+                for( ei = v->first; ei != 0; ei = edgePtr[ei].next )
+                {
+                    if( edgePtr[ei^vt].weight == 0 )
+                        continue;
+                    u = vtxPtr+edgePtr[ei].dst;
+                    if( !u->parent )
+                    {
+                        u->t = vt;
+                        u->parent = ei ^ 1;
+                        u->ts = v->ts;
+                        u->dist = v->dist + 1;
+                        if( !u->next )
+                        {
+                            u->next = nilNode;
+                            last = last->next = u;
+                        }
+                        continue;
+                    }
+
+                    if( u->t != vt )
+                    {
+                        e0 = ei ^ vt;
+                        break;
+                    }
+
+                    if( u->dist > v->dist+1 && u->ts <= v->ts )
+                    {
+                        // reassign the parent
+                        u->parent = ei ^ 1;
+                        u->ts = v->ts;
+                        u->dist = v->dist + 1;
+                    }
+                }
+                if( e0 > 0 )
+                    break;
+            }
+            // exclude the vertex from the active list
+            first = first->next;
+            v->next = 0;
+        }
+
+        if( e0 <= 0 )
+            break;
+
+        // find the minimum edge weight along the path
+        minWeight = edgePtr[e0].weight;
+        CV_Assert( minWeight > 0 );
+        // k = 1: source tree, k = 0: destination tree
+        for( int k = 1; k >= 0; k-- )
+        {
+            for( v = vtxPtr+edgePtr[e0^k].dst;; v = vtxPtr+edgePtr[ei].dst )
+            {
+                if( (ei = v->parent) < 0 )
+                    break;
+                weight = edgePtr[ei^k].weight;
+                minWeight = MIN(minWeight, weight);
+                CV_Assert( minWeight > 0 );
+            }
+            weight = std::abs( TWeight(v->weight) );
+            minWeight = MIN(minWeight, weight);
+            CV_Assert( minWeight > 0 );
+        }
+
+        // modify weights of the edges along the path and collect orphans
+        edgePtr[e0].weight -= minWeight;
+        edgePtr[e0^1].weight += minWeight;
+        flow += minWeight;
+
+        // k = 1: source tree, k = 0: destination tree
+        for( int k = 1; k >= 0; k-- )
+        {
+            for( v = vtxPtr+edgePtr[e0^k].dst;; v = vtxPtr+edgePtr[ei].dst )
+            {
+                if( (ei = v->parent) < 0 )
+                    break;
+                edgePtr[ei^(k^1)].weight += minWeight;
+                if( (edgePtr[ei^k].weight -= minWeight) == 0 )
+                {
+                    orphans.push_back(v);
+                    v->parent = ORPHAN;
+                }
+            }
+
+            v->weight = v->weight + minWeight*(1-k*2);
+            if( v->weight == 0 )
+            {
+               orphans.push_back(v);
+               v->parent = ORPHAN;
+            }
+        }
+
+        // restore the search trees by finding new parents for the orphans
+        curr_ts++;
+        while( !orphans.empty() )
+        {
+            Vtx* v2 = orphans.back();
+            orphans.pop_back();
+
+            int d, minDist = INT_MAX;
+            e0 = 0;
+            vt = v2->t;
+
+            for( ei = v2->first; ei != 0; ei = edgePtr[ei].next )
+            {
+                if( edgePtr[ei^(vt^1)].weight == 0 )
+                    continue;
+                u = vtxPtr+edgePtr[ei].dst;
+                if( u->t != vt || u->parent == 0 )
+                    continue;
+                // compute the distance to the tree root
+                for( d = 0;; )
+                {
+                    if( u->ts == curr_ts )
+                    {
+                        d += u->dist;
+                        break;
+                    }
+                    ej = u->parent;
+                    d++;
+                    if( ej < 0 )
+                    {
+                        if( ej == ORPHAN )
+                            d = INT_MAX-1;
+                        else
+                        {
+                            u->ts = curr_ts;
+                            u->dist = 1;
+                        }
+                        break;
+                    }
+                    u = vtxPtr+edgePtr[ej].dst;
+                }
+
+                // update the distance
+                if( ++d < INT_MAX )
+                {
+                    if( d < minDist )
+                    {
+                        minDist = d;
+                        e0 = ei;
+                    }
+                    for( u = vtxPtr+edgePtr[ei].dst; u->ts != curr_ts; u = vtxPtr+edgePtr[u->parent].dst )
+                    {
+                        u->ts = curr_ts;
+                        u->dist = --d;
+                    }
+                }
+            }
+
+            if( (v2->parent = e0) > 0 )
+            {
+                v2->ts = curr_ts;
+                v2->dist = minDist;
+                continue;
+            }
+
+            /* no parent is found */
+            v2->ts = 0;
+            for( ei = v2->first; ei != 0; ei = edgePtr[ei].next )
+            {
+                u = vtxPtr+edgePtr[ei].dst;
+                ej = u->parent;
+                if( u->t != vt || !ej )
+                    continue;
+                if( edgePtr[ei^(vt^1)].weight && !u->next )
+                {
+                    u->next = nilNode;
+                    last = last->next = u;
+                }
+                if( ej > 0 && vtxPtr+edgePtr[ej].dst == v2 )
+                {
+                    orphans.push_back(u);
+                    u->parent = ORPHAN;
+                }
+            }
+        }
+    }
+    return flow;
+}
+
+template <class TWeight>
+bool GCGraph<TWeight>::inSourceSegment( int i )
+{
+    CV_Assert( i>=0 && i<(int)vtcs.size() );
+    return vtcs[i].t == 0;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/grayworld_white_balance.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/grayworld_white_balance.cpp
new file mode 100644
index 00000000..8d5953d3
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/grayworld_white_balance.cpp
@@ -0,0 +1,350 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+#include "opencv2/xphoto.hpp"
+
+namespace cv
+{
+namespace xphoto
+{
+
+void calculateChannelSums(uint &sumB, uint &sumG, uint &sumR, uchar *src_data, int src_len, float thresh);
+void calculateChannelSums(uint64 &sumB, uint64 &sumG, uint64 &sumR, ushort *src_data, int src_len, float thresh);
+
+class GrayworldWBImpl CV_FINAL : public GrayworldWB
+{
+  private:
+    float thresh;
+
+  public:
+    GrayworldWBImpl() { thresh = 0.9f; }
+    float getSaturationThreshold() const CV_OVERRIDE { return thresh; }
+    void setSaturationThreshold(float val) CV_OVERRIDE { thresh = val; }
+    void balanceWhite(InputArray _src, OutputArray _dst) CV_OVERRIDE
+    {
+        CV_Assert(!_src.empty());
+        CV_Assert(_src.isContinuous());
+        CV_Assert(_src.type() == CV_8UC3 || _src.type() == CV_16UC3);
+        Mat src = _src.getMat();
+
+        int N = src.cols * src.rows, N3 = N * 3;
+
+        double dsumB = 0.0, dsumG = 0.0, dsumR = 0.0;
+        if (src.type() == CV_8UC3)
+        {
+            uint sumB = 0, sumG = 0, sumR = 0;
+            calculateChannelSums(sumB, sumG, sumR, src.ptr<uchar>(), N3, thresh);
+            dsumB = (double)sumB;
+            dsumG = (double)sumG;
+            dsumR = (double)sumR;
+        }
+        else if (src.type() == CV_16UC3)
+        {
+            uint64 sumB = 0, sumG = 0, sumR = 0;
+            calculateChannelSums(sumB, sumG, sumR, src.ptr<ushort>(), N3, thresh);
+            dsumB = (double)sumB;
+            dsumG = (double)sumG;
+            dsumR = (double)sumR;
+        }
+
+        // Find inverse of averages
+        double max_sum = max(dsumB, max(dsumR, dsumG));
+        const double eps = 0.1;
+        float dinvB = dsumB < eps ? 0.f : (float)(max_sum / dsumB),
+              dinvG = dsumG < eps ? 0.f : (float)(max_sum / dsumG),
+              dinvR = dsumR < eps ? 0.f : (float)(max_sum / dsumR);
+
+        // Use the inverse of averages as channel gains:
+        applyChannelGains(src, _dst, dinvB, dinvG, dinvR);
+    }
+};
+
+/* Computes sums for each channel, while ignoring saturated pixels which are determined by thresh
+ * (version for CV_8UC3)
+ */
+void calculateChannelSums(uint &sumB, uint &sumG, uint &sumR, uchar *src_data, int src_len, float thresh)
+{
+    sumB = sumG = sumR = 0;
+    ushort thresh255 = (ushort)cvRound(thresh * 255);
+    int i = 0;
+#if CV_SIMD128
+    v_uint8x16 v_inB, v_inG, v_inR, v_min_val, v_max_val;
+    v_uint16x8 v_iB1, v_iB2, v_iG1, v_iG2, v_iR1, v_iR2;
+    v_uint16x8 v_min1, v_min2, v_max1, v_max2, v_m1, v_m2;
+    v_uint16x8 v_255 = v_setall_u16(255), v_thresh = v_setall_u16(thresh255);
+    v_uint32x4 v_uint1, v_uint2;
+    v_uint32x4 v_SB = v_setzero_u32(), v_SG = v_setzero_u32(), v_SR = v_setzero_u32();
+
+    for (; i < src_len - 47; i += 48)
+    {
+        // Load 3x uint8x16 and deinterleave into vectors of each channel
+        v_load_deinterleave(&src_data[i], v_inB, v_inG, v_inR);
+
+        // Get min and max
+        v_min_val = v_min(v_inB, v_min(v_inG, v_inR));
+        v_max_val = v_max(v_inB, v_max(v_inG, v_inR));
+
+        // Split into two ushort vectors per channel
+        v_expand(v_inB, v_iB1, v_iB2);
+        v_expand(v_inG, v_iG1, v_iG2);
+        v_expand(v_inR, v_iR1, v_iR2);
+        v_expand(v_min_val, v_min1, v_min2);
+        v_expand(v_max_val, v_max1, v_max2);
+
+        // Calculate masks
+        v_m1 = ~(v_mul_wrap(v_max1 - v_min1, v_255) > v_mul_wrap(v_thresh, v_max1));
+        v_m2 = ~(v_mul_wrap(v_max2 - v_min2, v_255) > v_mul_wrap(v_thresh, v_max2));
+
+        // Apply masks
+        v_iB1 = (v_iB1 & v_m1) + (v_iB2 & v_m2);
+        v_iG1 = (v_iG1 & v_m1) + (v_iG2 & v_m2);
+        v_iR1 = (v_iR1 & v_m1) + (v_iR2 & v_m2);
+
+        // Split and add to the sums:
+        v_expand(v_iB1, v_uint1, v_uint2);
+        v_SB += v_uint1 + v_uint2;
+        v_expand(v_iG1, v_uint1, v_uint2);
+        v_SG += v_uint1 + v_uint2;
+        v_expand(v_iR1, v_uint1, v_uint2);
+        v_SR += v_uint1 + v_uint2;
+    }
+
+    sumB = v_reduce_sum(v_SB);
+    sumG = v_reduce_sum(v_SG);
+    sumR = v_reduce_sum(v_SR);
+#endif
+    unsigned int minRGB, maxRGB;
+    for (; i < src_len; i += 3)
+    {
+        minRGB = min(src_data[i], min(src_data[i + 1], src_data[i + 2]));
+        maxRGB = max(src_data[i], max(src_data[i + 1], src_data[i + 2]));
+        if ((maxRGB - minRGB) * 255 > thresh255 * maxRGB)
+            continue;
+        sumB += src_data[i];
+        sumG += src_data[i + 1];
+        sumR += src_data[i + 2];
+    }
+}
+
+/* Computes sums for each channel, while ignoring saturated pixels which are determined by thresh
+ * (version for CV_16UC3)
+ */
+void calculateChannelSums(uint64 &sumB, uint64 &sumG, uint64 &sumR, ushort *src_data, int src_len, float thresh)
+{
+    sumB = sumG = sumR = 0;
+    uint thresh65535 = cvRound(thresh * 65535);
+    int i = 0;
+#if CV_SIMD128
+    v_uint16x8 v_inB, v_inG, v_inR, v_min_val, v_max_val;
+    v_uint32x4 v_iB1, v_iB2, v_iG1, v_iG2, v_iR1, v_iR2;
+    v_uint32x4 v_min1, v_min2, v_max1, v_max2, v_m1, v_m2;
+    v_uint32x4 v_65535 = v_setall_u32(65535), v_thresh = v_setall_u32(thresh65535);
+    v_uint64x2 v_u64_1, v_u64_2;
+    v_uint64x2 v_SB = v_setzero_u64(), v_SG = v_setzero_u64(), v_SR = v_setzero_u64();
+
+    for (; i < src_len - 23; i += 24)
+    {
+        // Load 3x uint16x8 and deinterleave into vectors of each channel
+        v_load_deinterleave(&src_data[i], v_inB, v_inG, v_inR);
+
+        // Get min and max
+        v_min_val = v_min(v_inB, v_min(v_inG, v_inR));
+        v_max_val = v_max(v_inB, v_max(v_inG, v_inR));
+
+        // Split into two uint vectors per channel
+        v_expand(v_inB, v_iB1, v_iB2);
+        v_expand(v_inG, v_iG1, v_iG2);
+        v_expand(v_inR, v_iR1, v_iR2);
+        v_expand(v_min_val, v_min1, v_min2);
+        v_expand(v_max_val, v_max1, v_max2);
+
+        // Calculate masks
+        v_m1 = ~((v_max1 - v_min1) * v_65535 > v_thresh * v_max1);
+        v_m2 = ~((v_max2 - v_min2) * v_65535 > v_thresh * v_max2);
+
+        // Apply masks
+        v_iB1 = (v_iB1 & v_m1) + (v_iB2 & v_m2);
+        v_iG1 = (v_iG1 & v_m1) + (v_iG2 & v_m2);
+        v_iR1 = (v_iR1 & v_m1) + (v_iR2 & v_m2);
+
+        // Split and add to the sums:
+        v_expand(v_iB1, v_u64_1, v_u64_2);
+        v_SB += v_u64_1 + v_u64_2;
+        v_expand(v_iG1, v_u64_1, v_u64_2);
+        v_SG += v_u64_1 + v_u64_2;
+        v_expand(v_iR1, v_u64_1, v_u64_2);
+        v_SR += v_u64_1 + v_u64_2;
+    }
+
+    // Perform final reduction
+    uint64 sum_arr[2];
+    v_store(sum_arr, v_SB);
+    sumB = sum_arr[0] + sum_arr[1];
+    v_store(sum_arr, v_SG);
+    sumG = sum_arr[0] + sum_arr[1];
+    v_store(sum_arr, v_SR);
+    sumR = sum_arr[0] + sum_arr[1];
+#endif
+    unsigned int minRGB, maxRGB;
+    for (; i < src_len; i += 3)
+    {
+        minRGB = min(src_data[i], min(src_data[i + 1], src_data[i + 2]));
+        maxRGB = max(src_data[i], max(src_data[i + 1], src_data[i + 2]));
+        if ((maxRGB - minRGB) * 65535 > thresh65535 * maxRGB)
+            continue;
+        sumB += src_data[i];
+        sumG += src_data[i + 1];
+        sumR += src_data[i + 2];
+    }
+}
+
+void applyChannelGains(InputArray _src, OutputArray _dst, float gainB, float gainG, float gainR)
+{
+    Mat src = _src.getMat();
+    CV_Assert(!src.empty());
+    CV_Assert(src.isContinuous());
+    CV_Assert(src.type() == CV_8UC3 || src.type() == CV_16UC3);
+
+    _dst.create(src.size(), src.type());
+    Mat dst = _dst.getMat();
+    int N3 = 3 * src.cols * src.rows;
+    int i = 0;
+
+    // Scale gains by their maximum (fixed point approximation works only when all gains are <=1)
+    float gain_max = max(gainB, max(gainG, gainR));
+    if (gain_max > 0)
+    {
+        gainB /= gain_max;
+        gainG /= gain_max;
+        gainR /= gain_max;
+    }
+
+    if (src.type() == CV_8UC3)
+    {
+        // Fixed point arithmetic, mul by 2^8 then shift back 8 bits
+        int i_gainB = cvRound(gainB * (1 << 8)), i_gainG = cvRound(gainG * (1 << 8)),
+            i_gainR = cvRound(gainR * (1 << 8));
+        const uchar *src_data = src.ptr<uchar>();
+        uchar *dst_data = dst.ptr<uchar>();
+#if CV_SIMD128
+        v_uint8x16 v_inB, v_inG, v_inR;
+        v_uint8x16 v_outB, v_outG, v_outR;
+        v_uint16x8 v_sB1, v_sB2, v_sG1, v_sG2, v_sR1, v_sR2;
+        v_uint16x8 v_gainB = v_setall_u16((ushort)i_gainB), v_gainG = v_setall_u16((ushort)i_gainG),
+                   v_gainR = v_setall_u16((ushort)i_gainR);
+
+        for (; i < N3 - 47; i += 48)
+        {
+            // Load 3x uint8x16 and deinterleave into vectors of each channel
+            v_load_deinterleave(&src_data[i], v_inB, v_inG, v_inR);
+
+            // Split into two ushort vectors per channel
+            v_expand(v_inB, v_sB1, v_sB2);
+            v_expand(v_inG, v_sG1, v_sG2);
+            v_expand(v_inR, v_sR1, v_sR2);
+
+            // Multiply by gains
+            v_sB1 = v_mul_wrap(v_sB1, v_gainB) >> 8;
+            v_sB2 = v_mul_wrap(v_sB2, v_gainB) >> 8;
+            v_sG1 = v_mul_wrap(v_sG1, v_gainG) >> 8;
+            v_sG2 = v_mul_wrap(v_sG2, v_gainG) >> 8;
+            v_sR1 = v_mul_wrap(v_sR1, v_gainR) >> 8;
+            v_sR2 = v_mul_wrap(v_sR2, v_gainR) >> 8;
+
+            // Pack into vectors of v_uint8x16
+            v_store_interleave(&dst_data[i], v_pack(v_sB1, v_sB2), v_pack(v_sG1, v_sG2), v_pack(v_sR1, v_sR2));
+        }
+#endif
+        for (; i < N3; i += 3)
+        {
+            dst_data[i] = (uchar)((src_data[i] * i_gainB) >> 8);
+            dst_data[i + 1] = (uchar)((src_data[i + 1] * i_gainG) >> 8);
+            dst_data[i + 2] = (uchar)((src_data[i + 2] * i_gainR) >> 8);
+        }
+    }
+    else if (src.type() == CV_16UC3)
+    {
+        // Fixed point arithmetic, mul by 2^16 then shift back 16 bits
+        int i_gainB = cvRound(gainB * (1 << 16)), i_gainG = cvRound(gainG * (1 << 16)),
+            i_gainR = cvRound(gainR * (1 << 16));
+        const ushort *src_data = src.ptr<ushort>();
+        ushort *dst_data = dst.ptr<ushort>();
+#if CV_SIMD128
+        v_uint16x8 v_inB, v_inG, v_inR;
+        v_uint16x8 v_outB, v_outG, v_outR;
+        v_uint32x4 v_sB1, v_sB2, v_sG1, v_sG2, v_sR1, v_sR2;
+        v_uint32x4 v_gainB = v_setall_u32((uint)i_gainB), v_gainG = v_setall_u32((uint)i_gainG),
+                   v_gainR = v_setall_u32((uint)i_gainR);
+
+        for (; i < N3 - 23; i += 24)
+        {
+            // Load 3x uint16x8 and deinterleave into vectors of each channel
+            v_load_deinterleave(&src_data[i], v_inB, v_inG, v_inR);
+
+            // Split into two uint vectors per channel
+            v_expand(v_inB, v_sB1, v_sB2);
+            v_expand(v_inG, v_sG1, v_sG2);
+            v_expand(v_inR, v_sR1, v_sR2);
+
+            // Multiply by scaling factors
+            v_sB1 = (v_sB1 * v_gainB) >> 16;
+            v_sB2 = (v_sB2 * v_gainB) >> 16;
+            v_sG1 = (v_sG1 * v_gainG) >> 16;
+            v_sG2 = (v_sG2 * v_gainG) >> 16;
+            v_sR1 = (v_sR1 * v_gainR) >> 16;
+            v_sR2 = (v_sR2 * v_gainR) >> 16;
+
+            // Pack into vectors of v_uint16x8
+            v_store_interleave(&dst_data[i], v_pack(v_sB1, v_sB2), v_pack(v_sG1, v_sG2), v_pack(v_sR1, v_sR2));
+        }
+#endif
+        for (; i < N3; i += 3)
+        {
+            dst_data[i] = (ushort)((src_data[i] * i_gainB) >> 16);
+            dst_data[i + 1] = (ushort)((src_data[i + 1] * i_gainG) >> 16);
+            dst_data[i + 2] = (ushort)((src_data[i + 2] * i_gainR) >> 16);
+        }
+    }
+}
+
+Ptr<GrayworldWB> createGrayworldWB() { return makePtr<GrayworldWBImpl>(); }
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/inpainting.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/inpainting.cpp
new file mode 100644
index 00000000..d6a406ca
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/inpainting.cpp
@@ -0,0 +1,424 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//                       (3-clause BSD License)
+//
+// Copyright (C) 2000-2019, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+// Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * Neither the names of the copyright holders nor the names of the contributors
+//    may be used to endorse or promote products derived from this software
+//    without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <vector>
+#include <stack>
+#include <limits>
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+#include <fstream>
+#include <time.h>
+#include <functional>
+#include <string>
+#include <tuple>
+
+#include "opencv2/xphoto.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/core/types.hpp"
+#include "photomontage.hpp"
+#include "annf.hpp"
+#include "advanced_types.hpp"
+
+#include "inpainting_fsr.impl.hpp"
+
+namespace cv
+{
+namespace xphoto
+{
+    template <typename Tp, unsigned int cn>
+    static void shiftMapInpaint( const Mat &_src, const Mat &_mask, Mat &dst,
+        const int nTransform = 60, const int psize = 8, const cv::Point2i dsize = cv::Point2i(800, 600) )
+    {
+        /** Preparing input **/
+        cv::Mat src, mask, img, dmask, ddmask;
+
+        const float ls = std::max(/**/ std::min( /*...*/
+            std::max(_src.rows, _src.cols)/float(dsize.x),
+            std::min(_src.rows, _src.cols)/float(dsize.y)
+                                               ), 1.0f /**/);
+
+
+        cv::resize(_mask, mask, _mask.size()/ls, 0, 0, cv::INTER_NEAREST);
+        cv::resize(_src,  src,  _src.size()/ls,  0, 0,    cv::INTER_AREA);
+
+        src.convertTo( img, CV_32F );
+        img.setTo(0, ~(mask > 0));
+
+        cv::erode( mask,  dmask, cv::Mat(), cv::Point(-1,-1), 2);
+        cv::erode(dmask, ddmask, cv::Mat(), cv::Point(-1,-1), 2);
+
+        std::vector <Point2i> pPath;
+        cv::Mat_<int> backref( ddmask.size(), int(-1) );
+
+        for (int i = 0; i < ddmask.rows; ++i)
+        {
+            uchar *dmask_data = (uchar *) ddmask.template ptr<uchar>(i);
+            int *backref_data = (int *) backref.template ptr< int >(i);
+
+            for (int j = 0; j < ddmask.cols; ++j)
+                if (dmask_data[j] == 0)
+                {
+                    backref_data[j] = int(pPath.size());
+                     pPath.push_back( cv::Point(j, i) );
+                }
+        }
+
+        /** ANNF computation **/
+        std::vector <cv::Point2i> transforms( nTransform );
+        dominantTransforms(img, transforms, nTransform, psize);
+        transforms.push_back( cv::Point2i(0, 0) );
+
+        /** Warping **/
+        std::vector <std::vector <cv::Vec <float, cn> > > pointSeq( pPath.size() ); // source image transformed with transforms
+        std::vector <int> labelSeq( pPath.size() );                                 // resulting label sequence
+        std::vector <std::vector <int> >  linkIdx( pPath.size() );                  // neighbor links for pointSeq elements
+        std::vector <std::vector <unsigned char > > maskSeq( pPath.size() );        // corresponding mask
+
+        for (size_t i = 0; i < pPath.size(); ++i)
+        {
+            uchar xmask = dmask.template at<uchar>(pPath[i]);
+
+            for (int j = 0; j < nTransform + 1; ++j)
+            {
+                cv::Point2i u = pPath[i] + transforms[j];
+
+                unsigned char vmask = 0;
+                cv::Vec <float, cn> vimg = 0;
+
+                if ( u.y < src.rows && u.y >= 0
+                &&   u.x < src.cols && u.x >= 0 )
+                {
+                    if ( xmask == 0 || j == nTransform )
+                        vmask = mask.template at<uchar>(u);
+                    vimg = img.template at<cv::Vec<float, cn> >(u);
+                }
+
+                maskSeq[i].push_back(vmask);
+                pointSeq[i].push_back(vimg);
+
+                if (vmask != 0)
+                    labelSeq[i] = j;
+            }
+
+            cv::Point2i  p[] = {
+                                 pPath[i] + cv::Point2i(0, +1),
+                                 pPath[i] + cv::Point2i(+1, 0)
+                               };
+
+            for (uint j = 0; j < sizeof(p)/sizeof(cv::Point2i); ++j)
+                if ( p[j].y < src.rows && p[j].y >= 0 &&
+                     p[j].x < src.cols && p[j].x >= 0 )
+                    linkIdx[i].push_back( backref(p[j]) );
+                else
+                    linkIdx[i].push_back( -1 );
+        }
+
+        /** Stitching **/
+        photomontage( pointSeq, maskSeq, linkIdx, labelSeq );
+
+        /** Upscaling **/
+        if (ls != 1)
+        {
+            _src.convertTo( img, CV_32F );
+
+            std::vector <Point2i> __pPath = pPath; pPath.clear();
+
+            cv::Mat_<int> __backref( img.size(), -1 );
+
+            std::vector <std::vector <cv::Vec <float, cn> > > __pointSeq = pointSeq; pointSeq.clear();
+            std::vector <int> __labelSeq = labelSeq; labelSeq.clear();
+            std::vector <std::vector <int> > __linkIdx = linkIdx; linkIdx.clear();
+            std::vector <std::vector <unsigned char > > __maskSeq = maskSeq; maskSeq.clear();
+
+            for (size_t i = 0; i < __pPath.size(); ++i)
+            {
+                cv::Point2i p[] = {
+                    __pPath[i] + cv::Point2i(0, -1),
+                    __pPath[i] + cv::Point2i(-1, 0)
+                };
+
+                for (uint j = 0; j < sizeof(p)/sizeof(cv::Point2i); ++j)
+                    if ( p[j].y < src.rows && p[j].y >= 0 &&
+                        p[j].x < src.cols && p[j].x >= 0 )
+                        __linkIdx[i].push_back( backref(p[j]) );
+                    else
+                        __linkIdx[i].push_back( -1 );
+            }
+
+            for (size_t k = 0; k < __pPath.size(); ++k)
+            {
+                int clabel = __labelSeq[k];
+                int nearSeam = 0;
+
+                for (size_t i = 0; i < __linkIdx[k].size(); ++i)
+                    nearSeam |= ( __linkIdx[k][i] == -1
+                        || clabel != __labelSeq[__linkIdx[k][i]] );
+
+                if (nearSeam != 0)
+                    for (int i = 0; i < ls; ++i)
+                        for (int j = 0; j < ls; ++j)
+                        {
+                            cv::Point2i u = ls*(__pPath[k] + transforms[__labelSeq[k]]) + cv::Point2i(j, i);
+
+                            pPath.push_back( ls*__pPath[k] + cv::Point2i(j, i) );
+                            labelSeq.push_back( 0 );
+
+                            __backref(i, j) = int( pPath.size() );
+
+                            cv::Point2i dv[] = {
+                                                 cv::Point2i(0,  0),
+                                                 cv::Point2i(-1, 0),
+                                                 cv::Point2i(+1, 0),
+                                                 cv::Point2i(0, -1),
+                                                 cv::Point2i(0, +1)
+                                               };
+
+                            std::vector <cv::Vec <float, cn> > pointVec;
+                                            std::vector <uchar> maskVec;
+
+                            for (uint q = 0; q < sizeof(dv)/sizeof(cv::Point2i); ++q)
+                                if (u.x + dv[q].x >= 0 && u.x + dv[q].x < img.cols
+                                &&  u.y + dv[q].y >= 0 && u.y + dv[q].y < img.rows)
+                                {
+                                    pointVec.push_back(img.template at<cv::Vec <float, cn> >(u + dv[q]));
+                                    maskVec.push_back(_mask.template at<uchar>(u + dv[q]));
+                                }
+                                else
+                                {
+                                    pointVec.push_back( cv::Vec <float, cn>::all(0) );
+                                    maskVec.push_back( 0 );
+                                }
+
+                            pointSeq.push_back(pointVec);
+                              maskSeq.push_back(maskVec);
+                        }
+                else
+                {
+                    cv::Point2i fromIdx = ls*(__pPath[k] + transforms[__labelSeq[k]]),
+                                  toIdx = ls*__pPath[k];
+
+                    for (int i = 0; i < ls; ++i)
+                    {
+                        cv::Vec <float, cn> *from = img.template ptr<cv::Vec <float, cn> >(fromIdx.y + i) + fromIdx.x;
+                        cv::Vec <float, cn>   *to = img.template ptr<cv::Vec <float, cn> >(toIdx.y + i) + toIdx.x;
+
+                        for (int j = 0; j < ls; ++j)
+                            to[j] = from[j];
+                    }
+                }
+            }
+
+
+            for (size_t i = 0; i < pPath.size(); ++i)
+            {
+                cv::Point2i  p[] = {
+                    pPath[i] + cv::Point2i(0, +1),
+                    pPath[i] + cv::Point2i(+1, 0)
+                };
+
+                std::vector <int> linkVec;
+
+                for (uint j = 0; j < sizeof(p)/sizeof(cv::Point2i); ++j)
+                    if ( p[j].y < src.rows && p[j].y >= 0 &&
+                        p[j].x < src.cols && p[j].x >= 0 )
+                        linkVec.push_back( __backref(p[j]) );
+                    else
+                        linkVec.push_back( -1 );
+
+                linkIdx.push_back(linkVec);
+            }
+
+            photomontage( pointSeq, maskSeq, linkIdx, labelSeq );
+        }
+
+        /** Writing result **/
+        for (size_t i = 0; i < labelSeq.size(); ++i)
+        {
+            if (pPath[i].x >= img.cols || pPath[i].y >= img.rows)
+                continue;
+
+            cv::Vec <float, cn> val = pointSeq[i][labelSeq[i]];
+            img.template at<cv::Vec <float, cn> >(pPath[i]) = val;
+        }
+        img.convertTo( dst, dst.type() );
+    }
+
+    template <typename Tp, unsigned int cn>
+    void inpaint(const Mat &src, const Mat &mask, Mat &dst, const int algorithmType)
+    {
+        dst.create( src.size(), src.type() );
+
+        switch ( algorithmType )
+        {
+            case xphoto::INPAINT_SHIFTMAP:
+                shiftMapInpaint <Tp, cn>(src, mask, dst);
+                break;
+            default:
+                CV_Error_( Error::StsNotImplemented,
+                    ("Unsupported algorithm type (=%d)", algorithmType) );
+                break;
+        }
+    }
+
+    static
+    void inpaint_shiftmap(const Mat &src, const Mat &mask, Mat &dst, const int algorithmType)
+    {
+        switch ( src.type() )
+        {
+            case CV_8SC1:
+                inpaint <char,   1>( src, mask, dst, algorithmType );
+                break;
+            case CV_8SC2:
+                inpaint <char,   2>( src, mask, dst, algorithmType );
+                break;
+            case CV_8SC3:
+                inpaint <char,   3>( src, mask, dst, algorithmType );
+                break;
+            case CV_8SC4:
+                inpaint <char,   4>( src, mask, dst, algorithmType );
+                break;
+            case CV_8UC1:
+                inpaint <uchar,  1>( src, mask, dst, algorithmType );
+                break;
+            case CV_8UC2:
+                inpaint <uchar,  2>( src, mask, dst, algorithmType );
+                break;
+            case CV_8UC3:
+                inpaint <uchar,  3>( src, mask, dst, algorithmType );
+                break;
+            case CV_8UC4:
+                inpaint <uchar,  4>( src, mask, dst, algorithmType );
+                break;
+            case CV_16SC1:
+                inpaint <short,  1>( src, mask, dst, algorithmType );
+                break;
+            case CV_16SC2:
+                inpaint <short,  2>( src, mask, dst, algorithmType );
+                break;
+            case CV_16SC3:
+                inpaint <short,  3>( src, mask, dst, algorithmType );
+                break;
+            case CV_16SC4:
+                inpaint <short,  4>( src, mask, dst, algorithmType );
+                break;
+            case CV_16UC1:
+                inpaint <ushort, 1>( src, mask, dst, algorithmType );
+                break;
+            case CV_16UC2:
+                inpaint <ushort, 2>( src, mask, dst, algorithmType );
+                break;
+            case CV_16UC3:
+                inpaint <ushort, 3>( src, mask, dst, algorithmType );
+                break;
+            case CV_16UC4:
+                inpaint <ushort, 4>( src, mask, dst, algorithmType );
+                break;
+            case CV_32SC1:
+                inpaint <int,    1>( src, mask, dst, algorithmType );
+                break;
+            case CV_32SC2:
+                inpaint <int,    2>( src, mask, dst, algorithmType );
+                break;
+            case CV_32SC3:
+                inpaint <int,    3>( src, mask, dst, algorithmType );
+                break;
+            case CV_32SC4:
+                inpaint <int,    4>( src, mask, dst, algorithmType );
+                break;
+            case CV_32FC1:
+                inpaint <float,  1>( src, mask, dst, algorithmType );
+                break;
+            case CV_32FC2:
+                inpaint <float,  2>( src, mask, dst, algorithmType );
+                break;
+            case CV_32FC3:
+                inpaint <float,  3>( src, mask, dst, algorithmType );
+                break;
+            case CV_32FC4:
+                inpaint <float,  4>( src, mask, dst, algorithmType );
+                break;
+            case CV_64FC1:
+                inpaint <double, 1>( src, mask, dst, algorithmType );
+                break;
+            case CV_64FC2:
+                inpaint <double, 2>( src, mask, dst, algorithmType );
+                break;
+            case CV_64FC3:
+                inpaint <double, 3>( src, mask, dst, algorithmType );
+                break;
+            case CV_64FC4:
+                inpaint <double, 4>( src, mask, dst, algorithmType );
+                break;
+            default:
+                CV_Error_( Error::StsNotImplemented,
+                    ("Unsupported source image format (=%d)",
+                    src.type()) );
+        }
+    }
+
+void inpaint(const Mat &src, const Mat &mask, Mat &dst, const int algorithmType)
+{
+    CV_Assert(!src.empty());
+    CV_Assert(!mask.empty());
+    CV_CheckTypeEQ(mask.type(), CV_8UC1, "");
+    CV_Assert(src.rows == mask.rows && src.cols == mask.cols);
+
+    switch (algorithmType)
+    {
+        case xphoto::INPAINT_SHIFTMAP:
+            return inpaint_shiftmap(src, mask, dst, algorithmType);
+        case xphoto::INPAINT_FSR_BEST:
+        case xphoto::INPAINT_FSR_FAST:
+            return inpaint_fsr(src, mask, dst, algorithmType);
+    }
+    CV_Error_(Error::StsNotImplemented, ("Unsupported inpainting algorithm type (=%d)", algorithmType));
+}
+
+}}  // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/inpainting_fsr.impl.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/inpainting_fsr.impl.hpp
new file mode 100644
index 00000000..b9ebb348
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/inpainting_fsr.impl.hpp
@@ -0,0 +1,826 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// This is not a standalone header, see inpainting.cpp
+
+namespace cv
+{
+namespace xphoto
+{
+
+struct fsr_parameters
+{
+    // default variables
+    int block_size = 16;
+    double conc_weighting = 0.5;
+    double rhos[4] = { 0.80, 0.70, 0.66, 0.64 };
+    double threshold_stddev_Y[3] = { 0.014, 0.030, 0.090 };
+    double threshold_stddev_Cx[3] = { 0.006, 0.010, 0.028 };
+    // quality profile dependent variables
+    int block_size_min, fft_size, max_iter, min_iter, iter_const;
+    double orthogonality_correction;
+    fsr_parameters(const int quality)
+    {
+        if (quality == xphoto::INPAINT_FSR_BEST)
+        {
+            block_size_min = 2;
+            fft_size = 64;
+            max_iter = 400;
+            min_iter = 50;
+            iter_const = 2000;
+            orthogonality_correction = 0.2;
+        }
+        else if (quality == xphoto::INPAINT_FSR_FAST)
+        {
+            block_size_min = 4;
+            fft_size = 32;
+            max_iter = 100;
+            min_iter = 20;
+            iter_const = 1000;
+            orthogonality_correction = 0.5;
+        }
+        else
+        {
+            CV_Error(Error::StsBadArg, "Unknown quality level set, supported: FAST, BEST");
+
+        }
+    }
+};
+
+
+static void
+icvSgnMat(const Mat& src, Mat& dst) {
+    dst = Mat::zeros(src.size(), CV_64F);
+    for (int y = 0; y < src.rows; ++y)
+    {
+        for (int x = 0; x < src.cols; ++x)
+        {
+            double curr_val = src.at<double>(y,x);
+            if (curr_val > 0)
+            {
+                dst.at<double>(y,x) = 1;
+            }
+            else if (curr_val)
+            {
+                dst.at<double>(y,x) = -1;
+            }
+        }
+    }
+}
+
+
+static double
+icvStandardDeviation(const Mat& distorted_block_2d, const Mat& error_mask_2d) {
+    if (countNonZero(error_mask_2d) < 1)
+    {
+        return NAN; // block with no undistorted pixels shouldn't be chosen for processing (only if block_size_min is reached)
+    }
+    Scalar tmp_stddev, tmp_mean;
+    Mat mask8u;
+    error_mask_2d.convertTo(mask8u, CV_8U, 2.0);
+    meanStdDev(distorted_block_2d, tmp_mean, tmp_stddev, mask8u);
+    double sigma_n = tmp_stddev[0] / 255;
+    if (sigma_n < 0)
+    {
+        sigma_n = 0;
+    }
+    else if (sigma_n > 1)
+    {
+        sigma_n = 1;
+    }
+    return sigma_n;
+}
+
+static void
+icvExtrapolateBlock(Mat& distorted_block, Mat& error_mask, fsr_parameters& fsr_params, double rho, double normedStdDev, Mat& extrapolated_block)
+{
+    double fft_size = fsr_params.fft_size;
+    double orthogonality_correction = fsr_params.orthogonality_correction;
+    int M = distorted_block.rows;
+    int N = distorted_block.cols;
+    int fft_x_offset = cvFloor((fft_size - N) / 2);
+    int fft_y_offset = cvFloor((fft_size - M) / 2);
+
+    // weighting function
+    Mat w = Mat::zeros(fsr_params.fft_size, fsr_params.fft_size, CV_64F);
+    error_mask.copyTo(w(Range(fft_y_offset, fft_y_offset + M), Range(fft_x_offset, fft_x_offset + N)));
+    for (int u = 0; u < fft_size; ++u)
+    {
+        for (int v = 0; v < fft_size; ++v)
+        {
+            w.at<double>(u, v) *= std::pow(rho, std::sqrt(std::pow(u + 0.5 - (fft_y_offset + M / 2), 2) + std::pow(v + 0.5 - (fft_x_offset + N / 2), 2)));
+        }
+    }
+    Mat W;
+    dft(w, W, DFT_COMPLEX_OUTPUT);
+    Mat W_padded;
+    hconcat(W, W, W_padded);
+    vconcat(W_padded, W_padded, W_padded);
+
+    // frequency weighting
+    Mat frequency_weighting = Mat::ones(fsr_params.fft_size, fsr_params.fft_size / 2 + 1, CV_64F);
+    for (int y = 0; y < fft_size; ++y)
+    {
+        for (int x = 0; x < (fft_size / 2 + 1); ++x)
+        {
+            double y2 = fft_size / 2 - std::abs(y - fft_size / 2);
+            double x2 = fft_size / 2 - std::abs(x - fft_size / 2);
+            frequency_weighting.at<double>(y, x) = 1 - std::sqrt(x2*x2 + y2 * y2)*std::sqrt(2) / fft_size;
+        }
+    }
+    // pad image to fft window size
+    Mat f(Size(fsr_params.fft_size, fsr_params.fft_size), CV_64F, Scalar::all(0));
+    distorted_block.copyTo(f(Range(fft_y_offset, fft_y_offset + M), Range(fft_x_offset, fft_x_offset + N)));
+
+    // create initial model
+    Mat G = Mat::zeros(fsr_params.fft_size, fsr_params.fft_size, CV_64FC2); // complex
+
+    // calculate initial residual
+    Mat Rw_tmp, Rw;
+    dft(f.mul(w), Rw_tmp, DFT_COMPLEX_OUTPUT);
+    Rw = Rw_tmp(Range(0, fsr_params.fft_size), Range(0, fsr_params.fft_size / 2 + 1));
+
+    // estimate ideal number of iterations (GenserIWSSIP2017)
+    // calculate stddev if not available (e.g., for smallest block size)
+    if (normedStdDev == 0) {
+        normedStdDev = icvStandardDeviation(distorted_block, error_mask);
+    }
+    int num_iters = cvRound(fsr_params.iter_const * normedStdDev);
+    if (num_iters < fsr_params.min_iter) {
+        num_iters = fsr_params.min_iter;
+    }
+    else if (num_iters > fsr_params.max_iter) {
+        num_iters = fsr_params.max_iter;
+    }
+
+    int iter_counter = 0;
+    while (iter_counter < num_iters)
+    { // Spectral Constrained FSE (GenserIWSSIP2018)
+        Mat projection_distances(Rw.size(), CV_64F);
+        Mat Rw_mag = Mat(Rw.size(), CV_64F);
+        std::vector<Mat> channels(2);
+        split(Rw, channels);
+        magnitude(channels[0], channels[1], Rw_mag);
+        projection_distances = Rw_mag.mul(frequency_weighting);
+
+        double minVal, maxVal;
+        int maxLocx = -1;
+        int maxLocy = -1;
+        minMaxLoc(projection_distances, &minVal, &maxVal);
+
+        for (int y = 0; y < projection_distances.rows; ++y)
+        { // assure that first appearance of max Value is selected
+            for (int x = 0; x < projection_distances.cols; ++x)
+            {
+                if (std::abs(projection_distances.at<double>(y, x) - maxVal) < 0.001)
+                {
+                    maxLocy = y;
+                    maxLocx = x;
+                    break;
+                }
+            }
+            if (maxLocy != -1)
+            {
+                break;
+            }
+        }
+        int bf2select = maxLocy + maxLocx * projection_distances.rows;
+        int v = static_cast<int>(std::max(0.0, std::floor(bf2select / fft_size)));
+        int u = static_cast<int>(std::max(0, bf2select % fsr_params.fft_size));
+
+
+        // exclude second half of first and middle col
+        if ((v == 0 && u > fft_size / 2) || (v == fft_size / 2 && u > fft_size / 2))
+        {
+            int u_prev = u;
+            u = fsr_params.fft_size - u;
+            Rw.at<std::complex<double> >(u, v) = std::conj(Rw.at<std::complex<double> >(u_prev, v));
+        }
+
+        // calculate complex conjugate solution
+        int u_cj = -1;
+        int v_cj = -1;
+        // fill first lower col (copy from first upper col)
+        if (u >= 1 && u < fft_size / 2 && v == 0)
+        {
+            u_cj = fsr_params.fft_size - u;
+            v_cj = v;
+        }
+        // fill middle lower col (copy from first middle col)
+        if (u >= 1 && u < fft_size / 2 && v == fft_size / 2)
+        {
+            u_cj = fsr_params.fft_size - u;
+            v_cj = v;
+        }
+        // fill first row right (copy from first row left)
+        if (u == 0 && v >= 1 && v < fft_size / 2)
+        {
+            u_cj = u;
+            v_cj = fsr_params.fft_size - v;
+        }
+        // fill middle row right (copy from middle row left)
+        if (u == fft_size / 2 && v >= 1 && v < fft_size / 2)
+        {
+            u_cj = u;
+            v_cj = fsr_params.fft_size - v;
+        }
+        // fill cell upper right (copy from lower cell left)
+        if (u >= fft_size / 2 + 1 && v >= 1 && v < fft_size / 2)
+        {
+            u_cj = fsr_params.fft_size - u;
+            v_cj = fsr_params.fft_size - v;
+        }
+        // fill cell lower right (copy from upper cell left)
+        if (u >= 1 && u < fft_size / 2 && v >= 1 && v < fft_size / 2)
+        {
+            u_cj = fsr_params.fft_size - u;
+            v_cj = fsr_params.fft_size - v;
+        }
+
+        /// add coef to model and update residual
+        if (u_cj != -1 && v_cj != -1)
+        {
+            std::complex< double> expansion_coefficient = orthogonality_correction * Rw.at< std::complex<double> >(u, v) / W.at<std::complex<double> >(0, 0);
+            G.at< std::complex<double> >(u, v) += fft_size * fft_size * expansion_coefficient;
+            G.at< std::complex<double> >(u_cj, v_cj) = std::conj(G.at< std::complex<double> >(u, v));
+
+            Mat expansion_mat(Rw.size(), CV_64FC2, Scalar(expansion_coefficient.real(), expansion_coefficient.imag()));
+            Mat W_tmp1 = W_padded(Range(fsr_params.fft_size - u, fsr_params.fft_size - u + Rw.rows), Range(fsr_params.fft_size - v, fsr_params.fft_size - v + Rw.cols));
+            Mat W_tmp2 = W_padded(Range(fsr_params.fft_size - u_cj, fsr_params.fft_size - u_cj + Rw.rows), Range(fsr_params.fft_size - v_cj, fsr_params.fft_size - v_cj + Rw.cols));
+            Mat res_1(W_tmp1.size(), W_tmp1.type());
+            mulSpectrums(expansion_mat, W_tmp1, res_1, 0);
+            expansion_mat.setTo(Scalar(expansion_coefficient.real(), -expansion_coefficient.imag()));
+            Mat res_2(W_tmp1.size(), W_tmp1.type());
+            mulSpectrums(expansion_mat, W_tmp2, res_2, 0);
+            Rw -= res_1 + res_2;
+
+            ++iter_counter; // ... as two basis functions were added
+        }
+        else
+        {
+            std::complex<double> expansion_coefficient = orthogonality_correction * Rw.at< std::complex<double> >(u, v) / W.at< std::complex<double> >(0, 0);
+            G.at< std::complex<double> >(u, v) += fft_size * fft_size * expansion_coefficient;
+            Mat expansion_mat(Rw.size(), CV_64FC2, Scalar(expansion_coefficient.real(), expansion_coefficient.imag()));
+            Mat W_tmp = W_padded(Range(fsr_params.fft_size - u, fsr_params.fft_size - u + Rw.rows), Range(fsr_params.fft_size - v, fsr_params.fft_size - v + Rw.cols));
+            Mat res_tmp(W_tmp.size(), W_tmp.type());
+            mulSpectrums(expansion_mat, W_tmp, res_tmp, 0);
+            Rw -= res_tmp;
+
+        }
+        ++iter_counter;
+    }
+
+    // get pixels from model
+    Mat g;
+    idft(G, g, DFT_SCALE);
+
+    // extract reconstructed pixels
+    Mat g_real(M, N, CV_64F);
+    for (int x = 0; x < M; ++x)
+    {
+        for (int y = 0; y < N; ++y)
+        {
+            g_real.at<double>(x, y) = g.at< std::complex<double> >(fft_y_offset + x, fft_x_offset + y).real();
+        }
+    }
+    g_real.copyTo(extrapolated_block);
+    Mat orig_samples;
+    error_mask.convertTo(orig_samples, CV_8U);
+    distorted_block.copyTo(extrapolated_block, orig_samples); // copy where orig_samples is nonzero
+}
+
+
+static void
+icvGetTodoBlocks(Mat& sampled_img, Mat& sampling_mask, std::vector< std::tuple< int, int > >& set_todo, int block_size, int block_size_min, int border_width, double homo_threshold, Mat& set_process_this_block_size, std::vector< std::tuple< int, int > >& set_later, Mat& sigma_n_array)
+{
+    std::vector< std::tuple< int, int > > set_now;
+    set_later.clear();
+    size_t list_length = set_todo.size();
+    int img_height = sampled_img.rows;
+    int img_width = sampled_img.cols;
+    Mat reconstructed_img;
+    sampled_img.copyTo(reconstructed_img);
+
+    // calculate block lists
+    for (size_t entry = 0; entry < list_length; ++entry)
+    {
+        int xblock_counter = std::get<0>(set_todo[entry]);
+        int yblock_counter = std::get<1>(set_todo[entry]);
+
+        int left_border = std::min(xblock_counter*block_size, border_width);
+        int top_border = std::min(yblock_counter*block_size, border_width);
+        int right_border = std::max(0, std::min(img_width - (xblock_counter + 1)*block_size, border_width));
+        int bottom_border = std::max(0, std::min(img_height - (yblock_counter + 1)*block_size, border_width));
+
+        // extract blocks from images
+        Mat distorted_block_2d = reconstructed_img(Range(yblock_counter*block_size - top_border, std::min(img_height, (yblock_counter*block_size + block_size + bottom_border))), Range(xblock_counter*block_size - left_border, std::min(img_width, (xblock_counter*block_size + block_size + right_border))));
+        Mat error_mask_2d = sampling_mask(Range(yblock_counter*block_size - top_border, std::min(img_height, (yblock_counter*block_size + block_size + bottom_border))), Range(xblock_counter*block_size - left_border, std::min(img_width, (xblock_counter*block_size + block_size + right_border))));
+
+        // determine normalized and weighted standard deviation
+        if (block_size > block_size_min && xblock_counter < sigma_n_array.cols && yblock_counter < sigma_n_array.rows)
+        {
+            double sigma_n = icvStandardDeviation(distorted_block_2d, error_mask_2d);
+            sigma_n_array.at<double>( yblock_counter, xblock_counter) = sigma_n;
+
+            // homogeneous case
+            if (sigma_n < homo_threshold)
+            {
+                set_now.emplace_back(xblock_counter, yblock_counter);
+                set_process_this_block_size.at<double>(yblock_counter, xblock_counter) = 255;
+
+            }
+            else
+            {
+                int yblock_counter_quadernary = yblock_counter * 2;
+                int xblock_counter_quadernary = xblock_counter * 2;
+                int yblock_offset = 0;
+                int xblock_offset = 0;
+
+                for (int quader_counter = 0; quader_counter < 4; ++quader_counter)
+                {
+                    if (quader_counter == 0)
+                    {
+                        yblock_offset = 0;
+                        xblock_offset = 0;
+                    }
+                    else if (quader_counter == 1)
+                    {
+                        yblock_offset = 0;
+                        xblock_offset = 1;
+                    }
+                    else if (quader_counter == 2)
+                    {
+                        yblock_offset = 1;
+                        xblock_offset = 0;
+                    }
+                    else if (quader_counter == 3)
+                    {
+                        yblock_offset = 1;
+                        xblock_offset = 1;
+                    }
+
+                    set_later.emplace_back(xblock_counter_quadernary + xblock_offset, yblock_counter_quadernary + yblock_offset);
+                }
+
+            }
+        }
+
+    }
+}
+
+
+static void
+icvDetermineProcessingOrder(
+    const Mat& _sampled_img, const Mat& _sampling_mask,
+    const int quality, const std::string& channel, Mat& reconstructed_img
+)
+{
+    fsr_parameters fsr_params(quality);
+    int block_size = fsr_params.block_size;
+    int block_size_max = fsr_params.block_size;
+    int block_size_min = fsr_params.block_size_min;
+    double conc_weighting = fsr_params.conc_weighting;
+    int fft_size = fsr_params.fft_size;
+    double rho = fsr_params.rhos[0];
+    Mat sampled_img, sampling_mask;
+    _sampled_img.convertTo(sampled_img, CV_64F);
+    reconstructed_img = sampled_img.clone();
+
+    _sampling_mask.convertTo(sampling_mask, CV_64F);
+
+    double threshold_stddev_LUT[3];
+    if (channel == "Y")
+    {
+        std::copy(fsr_params.threshold_stddev_Y, fsr_params.threshold_stddev_Y + 3, threshold_stddev_LUT);
+    }
+    else if (channel == "Cx")
+    {
+        std::copy(fsr_params.threshold_stddev_Cx, fsr_params.threshold_stddev_Cx + 3, threshold_stddev_LUT);
+    }
+    else
+    {
+        CV_Error(Error::StsBadArg, "channel type unsupported!");
+    }
+
+
+    double threshold_stddev = threshold_stddev_LUT[0];
+
+    std::vector< std::tuple< int, int > > set_later;
+    int img_height = sampled_img.rows;
+    int img_width = sampled_img.cols;
+
+    // initial scan of distorted blocks
+    std::vector< std::tuple< int, int > > set_todo;
+    int blocks_column = divUp(img_height, block_size);
+    int blocks_line = divUp(img_width, block_size);
+    for (int y = 0; y < blocks_column; ++y)
+    {
+        for (int x = 0; x < blocks_line; ++x)
+        {
+            Mat curr_block = sampling_mask(Range(y*block_size, std::min(img_height, (y + 1)*block_size)), Range(x*block_size, std::min(img_width, (x + 1)*block_size)));
+            double min_block, max_block;
+            minMaxLoc(curr_block, &min_block, &max_block);
+            if (min_block == 0)
+            {
+                set_todo.emplace_back(x, y);
+            }
+        }
+    }
+
+    // loop over all distorted blocks and extrapolate them depending on
+    // their block size
+    int border_width = 0;
+    while (block_size >= block_size_min)
+    {
+        int blocks_per_column = cvCeil(img_height / block_size);
+        int blocks_per_line = cvCeil(img_width / block_size);
+        Mat nen_array = Mat::zeros(blocks_per_column, blocks_per_line, CV_64F);
+        Mat proc_array = Mat::zeros(blocks_per_column, blocks_per_line, CV_64F);
+        Mat sigma_n_array = Mat::zeros(blocks_per_column, blocks_per_line, CV_64F);
+        Mat set_process_this_block_size = Mat::zeros(blocks_per_column, blocks_per_line, CV_64F);
+        if (block_size > block_size_min)
+        {
+            if (block_size < block_size_max)
+            {
+                set_todo = set_later;
+            }
+            border_width = cvFloor(fft_size - block_size) / 2;
+            icvGetTodoBlocks(sampled_img, sampling_mask, set_todo, block_size, block_size_min, border_width, threshold_stddev, set_process_this_block_size, set_later, sigma_n_array);
+        }
+        else
+        {
+            set_process_this_block_size.setTo(Scalar(255));
+        }
+
+        // if block to be extrapolated, increase nen of neighboring pixels
+        for (int yblock_counter = 0; yblock_counter < blocks_per_column; ++yblock_counter)
+        {
+            for (int xblock_counter = 0; xblock_counter < blocks_per_line; ++xblock_counter)
+            {
+                Mat curr_block = sampling_mask(Range(yblock_counter*block_size, std::min(img_height, (yblock_counter + 1)*block_size)), Range(xblock_counter*block_size, std::min(img_width, (xblock_counter + 1)*block_size)));
+                double min_block, max_block;
+                minMaxLoc(curr_block, &min_block, &max_block);
+                if (min_block == 0)
+                {
+                    if (yblock_counter > 0 && xblock_counter > 0)
+                    {
+                        nen_array.at<double>(yblock_counter - 1, xblock_counter - 1)++;
+                    }
+                    if (yblock_counter > 0)
+                    {
+                        nen_array.at<double>(yblock_counter - 1, xblock_counter)++;
+                    }
+                    if (yblock_counter > 0 && xblock_counter < (blocks_per_line - 1))
+                    {
+                        nen_array.at<double>(yblock_counter - 1, xblock_counter + 1)++;
+                    }
+                    if (xblock_counter > 0)
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter - 1)++;
+                    }
+                    if (xblock_counter < (blocks_per_line - 1))
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter + 1)++;
+                    }
+                    if (yblock_counter < (blocks_per_column - 1) && xblock_counter>0)
+                    {
+                        nen_array.at<double>(yblock_counter + 1, xblock_counter - 1)++;
+                    }
+                    if (yblock_counter < (blocks_per_column - 1))
+                    {
+                        nen_array.at<double>(yblock_counter + 1, xblock_counter)++;
+                    }
+                    if (yblock_counter < (blocks_per_column - 1) && xblock_counter < (blocks_per_line - 1))
+                    {
+                        nen_array.at<double>(yblock_counter + 1, xblock_counter + 1)++;
+                    }
+                }
+            }
+        }
+
+        // determine if block itself has to be extrapolated
+        for (int yblock_counter = 0; yblock_counter < blocks_per_column; ++yblock_counter)
+        {
+            for (int xblock_counter = 0; xblock_counter < blocks_per_line; ++xblock_counter)
+            {
+                Mat curr_block = sampling_mask(Range(yblock_counter*block_size, std::min(img_height, (yblock_counter + 1)*block_size)), Range(xblock_counter*block_size, std::min(img_width, (xblock_counter + 1)*block_size)));
+                double min_block, max_block;
+                minMaxLoc(curr_block, &min_block, &max_block);
+                if (min_block != 0)
+                {
+                    nen_array.at<double>(yblock_counter, xblock_counter) = -1;
+                }
+                else
+                {
+                // if border block, increase nen respectively
+                    if (yblock_counter == 0 && xblock_counter == 0)
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter) = nen_array.at<double>(yblock_counter, xblock_counter) + 5;
+                    }
+                    if (yblock_counter == 0 && xblock_counter == (blocks_per_line - 1))
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter) = nen_array.at<double>(yblock_counter, xblock_counter) + 5;
+                    }
+                    if (yblock_counter == (blocks_per_column - 1) && xblock_counter == 0)
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter) = nen_array.at<double>(yblock_counter, xblock_counter) + 5;
+                    }
+                    if (yblock_counter == (blocks_per_column - 1) && xblock_counter == (blocks_per_line - 1))
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter) = nen_array.at<double>(yblock_counter, xblock_counter) + 5;
+                    }
+                    if (yblock_counter == 0 && xblock_counter != 0 && xblock_counter != (blocks_per_line - 1))
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter) = nen_array.at<double>(yblock_counter, xblock_counter) + 3;
+                    }
+                    if (yblock_counter == (blocks_per_column - 1) && xblock_counter != 0 && xblock_counter != (blocks_per_line - 1))
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter) = nen_array.at<double>(yblock_counter, xblock_counter) + 3;
+                    }
+                    if (yblock_counter != 0 && yblock_counter != (blocks_per_column - 1) && xblock_counter == 0)
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter) = nen_array.at<double>(yblock_counter, xblock_counter) + 3;
+                    }
+                    if (yblock_counter != 0 && yblock_counter != (blocks_per_column - 1) && xblock_counter == (blocks_per_line - 1))
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter) = nen_array.at<double>(yblock_counter, xblock_counter) + 3;
+                    }
+                }
+            }
+        }
+
+        // if all blocks have 8 not extrapolated neighbors, penalize nen of blocks without any known samples by one
+        double min_nen_tmp, max_nen_tmp;
+        minMaxLoc(nen_array, &min_nen_tmp, &max_nen_tmp);
+        if (min_nen_tmp == 8) {
+            for (int yblock_counter = 0; yblock_counter < blocks_per_column; ++yblock_counter)
+            {
+                for (int xblock_counter = 0; xblock_counter < blocks_per_line; ++xblock_counter)
+                {
+                    Mat curr_block = sampling_mask(Range(yblock_counter*block_size, std::min(img_height, (yblock_counter + 1)*block_size)), Range(xblock_counter*block_size, std::min(img_width, (xblock_counter + 1)*block_size)));
+                    double min_block, max_block;
+                    minMaxLoc(curr_block, &min_block, &max_block);
+                    if (max_block == 0)
+                    {
+                        nen_array.at<double>(yblock_counter, xblock_counter)++;
+                    }
+                }
+            }
+        }
+
+        // do actual processing per block
+        int all_blocks_finished = 0;
+        while (all_blocks_finished == 0) {
+            // clear proc_array
+            proc_array.setTo(Scalar(1));
+
+            // determine blocks to extrapolate
+            double min_nen = 99;
+            int bl_counter = 0;
+            // add all homogeneous blocks that shall be processed to list
+            // using same priority
+            // begins with highest prioroty or lowest nen array value
+            std::vector< std::tuple< int, int > > block_list;
+            for (int yblock_counter = 0; yblock_counter < blocks_per_column; ++yblock_counter)
+            {
+                for (int xblock_counter = 0; xblock_counter < blocks_per_line; ++xblock_counter)
+                {
+            // decision if block contains errors
+                    double tmp_val = nen_array.at<double>(yblock_counter, xblock_counter);
+                    if (tmp_val >= 0 && tmp_val < min_nen && set_process_this_block_size.at<double>(yblock_counter, xblock_counter) == 255) {
+                        bl_counter = 0;
+                        block_list.clear();
+                        min_nen = tmp_val;
+                        proc_array.setTo(Scalar(1));
+                    }
+                    if (tmp_val == min_nen && proc_array.at<double>(yblock_counter, xblock_counter) != 0 && set_process_this_block_size.at<double>(yblock_counter, xblock_counter) == 0) {
+                        nen_array.at<double>(yblock_counter, xblock_counter) = -1;
+                    }
+                    if (tmp_val == min_nen && proc_array.at<double>(yblock_counter, xblock_counter) != 0 && set_process_this_block_size.at<double>(yblock_counter, xblock_counter) != 0) {
+                        block_list.emplace_back(yblock_counter, xblock_counter);
+                        bl_counter++;
+                        // block neighboring blocks from processing
+                        if (yblock_counter > 0 && xblock_counter > 0)
+                        {
+                            proc_array.at<double>(yblock_counter - 1, xblock_counter - 1) = 0;
+                        }
+                        if (yblock_counter > 0)
+                        {
+                            proc_array.at<double>(yblock_counter - 1, xblock_counter) = 0;
+                        }
+                         if (yblock_counter > 0 && xblock_counter > 0)
+                        {
+                            proc_array.at<double>(yblock_counter - 1, xblock_counter - 1) = 0;
+                        }
+                        if (yblock_counter > 0)
+                        {
+                            proc_array.at<double>(yblock_counter - 1, xblock_counter) = 0;
+                        }
+                        if (yblock_counter > 0 && xblock_counter < (blocks_per_line - 1))
+                        {
+                            proc_array.at<double>(yblock_counter - 1, xblock_counter + 1) = 0;
+                        }
+                        if (xblock_counter > 0)
+                        {
+                            proc_array.at<double>(yblock_counter, xblock_counter - 1) = 0;
+                        }
+                        if (xblock_counter < (blocks_per_line - 1))
+                        {
+                            proc_array.at<double>(yblock_counter, xblock_counter + 1) = 0;
+                        }
+                        if (yblock_counter < (blocks_per_column - 1) && xblock_counter > 0)
+                        {
+                            proc_array.at<double>(yblock_counter + 1, xblock_counter - 1) = 0;
+                        }
+                        if (yblock_counter < (blocks_per_column - 1))
+                        {
+                            proc_array.at<double>(yblock_counter + 1, xblock_counter) = 0;
+                        }
+                        if (yblock_counter < (blocks_per_column - 1) && xblock_counter < (blocks_per_line - 1))
+                        {
+                            proc_array.at<double>(yblock_counter + 1, xblock_counter + 1) = 0;
+                        }
+                    }
+                }
+            }
+            int max_bl_counter = bl_counter;
+            block_list.emplace_back(-1, -1);
+            if (bl_counter == 0)
+            {
+                all_blocks_finished = 1;
+            }
+            // blockwise extrapolation of all blocks that can be processed in parallel
+            for (bl_counter = 0; bl_counter < max_bl_counter; ++bl_counter)
+            {
+                int yblock_counter = std::get<0>(block_list[bl_counter]);
+                int xblock_counter = std::get<1>(block_list[bl_counter]);
+
+                // calculation of the extrapolation area's borders
+                int left_border = std::min(xblock_counter*block_size, border_width);
+                int top_border = std::min(yblock_counter*block_size, border_width);
+                int right_border = std::max(0, std::min(img_width - (xblock_counter + 1)*block_size, border_width));
+                int bottom_border = std::max(0, std::min(img_height - (yblock_counter + 1)*block_size, border_width));
+
+                // extract blocks from images
+                Mat distorted_block_2d = reconstructed_img(Range(yblock_counter*block_size - top_border, std::min(img_height, (yblock_counter*block_size + block_size + bottom_border))), Range(xblock_counter*block_size - left_border, std::min(img_width, (xblock_counter*block_size + block_size + right_border))));
+                Mat error_mask_2d = sampling_mask(Range(yblock_counter*block_size - top_border, std::min(img_height, (yblock_counter*block_size + block_size + bottom_border))), Range(xblock_counter*block_size - left_border, std::min(img_width, xblock_counter*block_size + block_size + right_border)));
+                // get actual stddev value as it is needed to estimate the
+                // best number of iterations
+                double sigma_n_a = sigma_n_array.at<double>(yblock_counter, xblock_counter);
+
+                // actual extrapolation
+                Mat extrapolated_block_2d;
+                icvExtrapolateBlock(distorted_block_2d, error_mask_2d, fsr_params, rho, sigma_n_a, extrapolated_block_2d);
+
+                // update image and mask
+                extrapolated_block_2d(Range(top_border, extrapolated_block_2d.rows - bottom_border), Range(left_border, extrapolated_block_2d.cols - right_border)).copyTo(reconstructed_img(Range(yblock_counter*block_size, std::min(img_height, (yblock_counter + 1)*block_size)), Range(xblock_counter*block_size, std::min(img_width, (xblock_counter + 1)*block_size))));
+
+                Mat signs;
+                icvSgnMat(error_mask_2d(Range(top_border, error_mask_2d.rows - bottom_border), Range(left_border, error_mask_2d.cols - right_border)), signs);
+                Mat tmp_mask = error_mask_2d(Range(top_border, error_mask_2d.rows - bottom_border), Range(left_border, error_mask_2d.cols - right_border)) + (1 - signs) *conc_weighting;
+                tmp_mask.copyTo(sampling_mask(Range(yblock_counter*block_size, std::min(img_height, (yblock_counter + 1)*block_size)), Range(xblock_counter*block_size, std::min(img_width, (xblock_counter + 1)*block_size))));
+
+                // update nen-array
+                nen_array.at<double>(yblock_counter, xblock_counter) = -1;
+                if (yblock_counter > 0 && xblock_counter > 0)
+                {
+                    nen_array.at<double>(yblock_counter - 1, xblock_counter - 1)--;
+                }
+                if (yblock_counter > 0)
+                {
+                    nen_array.at<double>(yblock_counter - 1, xblock_counter)--;
+                }
+                if (yblock_counter > 0 && xblock_counter < blocks_per_line - 1)
+                {
+                    nen_array.at<double>(yblock_counter - 1, xblock_counter + 1)--;
+                }
+                if (xblock_counter > 0)
+                {
+                    nen_array.at<double>(yblock_counter, xblock_counter - 1)--;
+                }
+                if (xblock_counter < blocks_per_line - 1)
+                {
+                    nen_array.at<double>(yblock_counter, xblock_counter + 1)--;
+                }
+                if (yblock_counter < blocks_per_column - 1 && xblock_counter>0)
+                {
+                    nen_array.at<double>(yblock_counter + 1, xblock_counter - 1)--;
+                }
+                if (yblock_counter < blocks_per_column - 1)
+                {
+                    nen_array.at<double>(yblock_counter + 1, xblock_counter)--;
+                }
+                if (yblock_counter < blocks_per_column - 1 && xblock_counter < blocks_per_line - 1)
+                {
+                    nen_array.at<double>(yblock_counter + 1, xblock_counter + 1)--;
+                }
+
+            }
+
+        }
+
+        // set parameters for next extrapolation tasks (higher texture)
+        block_size = block_size / 2;
+        border_width = (fft_size - block_size) / 2;
+        if (block_size == 8)
+        {
+            threshold_stddev = threshold_stddev_LUT[1];
+            rho = fsr_params.rhos[1];
+        }
+        if (block_size == 4)
+        {
+            threshold_stddev = threshold_stddev_LUT[2];
+            rho = fsr_params.rhos[2];
+        }
+        if (block_size == 2)
+        {
+            rho = fsr_params.rhos[3];
+        }
+
+        // terminate function - no heterogeneous blocks left
+        if (set_later.empty())
+        {
+            break;
+        }
+    }
+}
+
+
+static
+void inpaint_fsr(Mat src, const Mat &mask, Mat &dst, const int algorithmType)
+{
+    CV_Assert(algorithmType == xphoto::INPAINT_FSR_BEST || algorithmType == xphoto::INPAINT_FSR_FAST);
+    CV_Check(src.channels(), src.channels() == 1 || src.channels() == 3, "");
+    switch (src.type())
+    {
+        case CV_8UC1:
+        case CV_8UC3:
+            break;
+        case CV_16UC1:
+        case CV_16UC3:
+        {
+            double minRange, maxRange;
+            minMaxLoc(src, &minRange, &maxRange);
+            if (minRange < 0 || maxRange > 65535)
+            {
+                CV_Error(Error::StsUnsupportedFormat, "Unsupported source image format!");
+                break;
+            }
+            src.convertTo(src, CV_8U, 1/256.0);
+            break;
+        }
+        case CV_32FC1:
+        case CV_64FC1:
+        case CV_32FC3:
+        case CV_64FC3:
+        {
+            double minRange, maxRange;
+            minMaxLoc(src, &minRange, &maxRange);
+            if (minRange < -FLT_EPSILON || maxRange > (1.0 + FLT_EPSILON))
+            {
+                CV_Error(Error::StsUnsupportedFormat, "Unsupported source image format!");
+                break;
+            }
+            src.convertTo(src, CV_8U, 255.0);
+            break;
+        }
+        default:
+            CV_Error(Error::StsUnsupportedFormat, "Unsupported source image format!");
+            break;
+    }
+    dst.create(src.size(), src.type());
+    Mat mask_01;
+    threshold(mask, mask_01, 0.0, 1.0, THRESH_BINARY);
+    if (src.channels() == 1)
+    { // grayscale image
+        Mat y_reconstructed;
+        icvDetermineProcessingOrder(src, mask_01, algorithmType, "Y", y_reconstructed);
+        y_reconstructed.convertTo(dst, CV_8U);
+    }
+    else if (src.channels() == 3)
+    { // RGB image
+        Mat ycrcb;
+        cvtColor(src, ycrcb, COLOR_BGR2YCrCb);
+        std::vector<Mat> channels(3);
+        split(ycrcb, channels);
+        Mat y = channels[0];
+        Mat cb = channels[2];
+        Mat cr = channels[1];
+        Mat y_reconstructed, cb_reconstructed, cr_reconstructed;
+        y = y.mul(mask_01);
+        cb = cb.mul(mask_01);
+        cr = cr.mul(mask_01);
+        icvDetermineProcessingOrder(y, mask_01, algorithmType, "Y", y_reconstructed);
+        icvDetermineProcessingOrder(cb, mask_01, algorithmType, "Cx", cb_reconstructed);
+        icvDetermineProcessingOrder(cr, mask_01, algorithmType, "Cx", cr_reconstructed);
+        Mat ycrcb_reconstructed;
+        y_reconstructed.convertTo(channels[0], CV_8U);
+        cr_reconstructed.convertTo(channels[1], CV_8U);
+        cb_reconstructed.convertTo(channels[2], CV_8U);
+        merge(channels, ycrcb_reconstructed);
+        cvtColor(ycrcb_reconstructed, dst, COLOR_YCrCb2BGR);
+    }
+}
+
+}}  // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/kaiser_window.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/kaiser_window.hpp
new file mode 100644
index 00000000..f5aa1ff8
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/kaiser_window.hpp
@@ -0,0 +1,129 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_BM3D_DENOISING_KAISER_WINDOW_HPP__
+#define __OPENCV_BM3D_DENOISING_KAISER_WINDOW_HPP__
+
+#include "opencv2/core.hpp"
+#include <cmath>
+
+namespace cv
+{
+namespace xphoto
+{
+
+static int factorial(int n)
+{
+    if (n == 0)
+        return 1;
+
+    int val = 1;
+    for (int idx = 1; idx <= n; ++idx)
+        val *= idx;
+
+    return val;
+}
+
+template <int MAX_ITER>
+static float bessel0(const float &x)
+{
+    float sum = 0.0f;
+
+    for (int m = 0; m < MAX_ITER; ++m)
+    {
+        float factM = (float)factorial(m);
+        float inc = std::pow(1.0f / factM * std::pow(x * 0.5f, (float)m), 2.0f);
+        sum += inc;
+
+        if ((inc / sum) < 0.001F)
+            break;
+    }
+
+    return sum;
+}
+
+#define MAX_ITER_BESSEL 100
+
+static void calcKaiserWindow1D(cv::Mat &dst, const int N, const float beta)
+{
+    if (dst.empty())
+        dst.create(cv::Size(1, N), CV_32FC1);
+
+    CV_Assert(dst.total() == (size_t)N);
+    CV_Assert(dst.type() == CV_32FC1);
+    CV_Assert(N > 0);
+
+    float *p = dst.ptr<float>(0);
+    for (int i = 0; i < N; ++i)
+    {
+        float b = beta * std::sqrt(1.0f - std::pow(2.0f * i / (N - 1.0f) - 1.0f, 2.0f));
+        p[i] = bessel0<MAX_ITER_BESSEL>(b) / bessel0<MAX_ITER_BESSEL>(beta);
+    }
+}
+
+static void calcKaiserWindow2D(float *&kaiser, const int N, const float beta)
+{
+    if (kaiser == NULL)
+        kaiser = new float[N * N];
+
+    if (beta == 0.0f)
+    {
+        for (int i = 0; i < N * N; ++i)
+            kaiser[i] = 1.0f;
+        return;
+    }
+
+    cv::Mat kaiser1D;
+    calcKaiserWindow1D(kaiser1D, N, beta);
+
+    cv::Mat kaiser1Dt;
+    cv::transpose(kaiser1D, kaiser1Dt);
+
+    cv::Mat kaiser2D = kaiser1D * kaiser1Dt;
+    float *p = kaiser2D.ptr<float>(0);
+    for (unsigned i = 0; i < kaiser2D.total(); ++i)
+        kaiser[i] = p[i];
+}
+
+}  // namespace xphoto
+}  // namespace cv
+
+#endif
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/learning_based_color_balance.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/learning_based_color_balance.cpp
new file mode 100644
index 00000000..bd408e6c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/learning_based_color_balance.cpp
@@ -0,0 +1,622 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "learning_based_color_balance_model.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/xphoto.hpp"
+
+using namespace std;
+#define EPS 0.00001f
+
+namespace cv
+{
+namespace xphoto
+{
+
+inline void getChromaticity(Vec2f &dst, float R, float G, float B)
+{
+    dst[0] = R / (R + G + B + EPS);
+    dst[1] = G / (R + G + B + EPS);
+}
+
+struct hist_elem
+{
+    float hist_val;
+    float r, g;
+    hist_elem(float _hist_val, Vec2f chromaticity) : hist_val(_hist_val), r(chromaticity[0]), g(chromaticity[1]) {}
+};
+bool operator<(const hist_elem &a, const hist_elem &b);
+bool operator<(const hist_elem &a, const hist_elem &b) { return a.hist_val > b.hist_val; }
+
+class LearningBasedWBImpl : public LearningBasedWB
+{
+  private:
+    int range_max_val, hist_bin_num, palette_size;
+    float saturation_thresh, palette_bandwidth, prediction_thresh;
+    int num_trees, num_tree_nodes, tree_depth;
+    uchar *feature_idx;
+    float *thresh_vals, *leaf_vals;
+    Mat feature_idx_Mat, thresh_vals_Mat, leaf_vals_Mat;
+    Mat mask;
+    int src_max_val;
+
+    void preprocessing(Mat &src);
+    void getAverageAndBrightestColorChromaticity(Vec2f &average_chromaticity, Vec2f &brightest_chromaticity, Mat &src);
+    void getColorPaletteMode(Vec2f &dst, hist_elem *palette);
+    void getHistogramBasedFeatures(Vec2f &dominant_chromaticity, Vec2f &chromaticity_palette_mode, Mat &src);
+
+    float regressionTreePredict(Vec2f src, uchar *tree_feature_idx, float *tree_thresh_vals, float *tree_leaf_vals);
+    Vec2f predictIlluminant(vector<Vec2f> features);
+
+  public:
+    LearningBasedWBImpl(String path_to_model)
+    {
+        range_max_val = 255;
+        saturation_thresh = 0.98f;
+        hist_bin_num = 64;
+        palette_size = 300;
+        palette_bandwidth = 0.1f;
+        prediction_thresh = 0.025f;
+        /* try to load model from file */
+        FileStorage fs;
+        if (!path_to_model.empty() && fs.open(path_to_model, FileStorage::READ))
+        {
+            if (fs["num_trees"].isReal()) { //workaround for #10506
+                double nt = fs["num_trees"];
+                num_trees = int(nt);
+                double ntn = fs["num_tree_nodes"];
+                num_tree_nodes = int(ntn);
+            } else {
+                num_trees = fs["num_trees"];
+                num_tree_nodes = fs["num_tree_nodes"];
+            }
+            fs["feature_idx"] >> feature_idx_Mat;
+            fs["thresh_vals"] >> thresh_vals_Mat;
+            fs["leaf_vals"] >> leaf_vals_Mat;
+            feature_idx = feature_idx_Mat.ptr<uchar>();
+            thresh_vals = thresh_vals_Mat.ptr<float>();
+            leaf_vals = leaf_vals_Mat.ptr<float>();
+        }
+        else
+        {
+            /* use the default model */
+            num_trees = _num_trees;
+            num_tree_nodes = _num_tree_nodes;
+            feature_idx = _feature_idx;
+            thresh_vals = _thresh_vals;
+            leaf_vals = _leaf_vals;
+        }
+    }
+
+    int getRangeMaxVal() const CV_OVERRIDE { return range_max_val; }
+    void setRangeMaxVal(int val) CV_OVERRIDE { range_max_val = val; }
+
+    float getSaturationThreshold() const CV_OVERRIDE { return saturation_thresh; }
+    void setSaturationThreshold(float val) CV_OVERRIDE { saturation_thresh = val; }
+
+    int getHistBinNum() const CV_OVERRIDE { return hist_bin_num; }
+    void setHistBinNum(int val) CV_OVERRIDE { hist_bin_num = val; }
+
+    void extractSimpleFeatures(InputArray _src, OutputArray _dst) CV_OVERRIDE
+    {
+        CV_Assert(!_src.empty());
+        CV_Assert(_src.isContinuous());
+        CV_Assert(_src.type() == CV_8UC3 || _src.type() == CV_16UC3);
+        Mat src = _src.getMat();
+        vector<Vec2f> dst(num_features);
+
+        preprocessing(src);
+        getAverageAndBrightestColorChromaticity(dst[0], dst[1], src);
+        getHistogramBasedFeatures(dst[2], dst[3], src);
+        Mat(dst).convertTo(_dst, CV_32F);
+    }
+
+    void balanceWhite(InputArray _src, OutputArray _dst) CV_OVERRIDE
+    {
+        CV_Assert(!_src.empty());
+        CV_Assert(_src.isContinuous());
+        CV_Assert(_src.type() == CV_8UC3 || _src.type() == CV_16UC3);
+        Mat src = _src.getMat();
+
+        vector<Vec2f> features;
+        extractSimpleFeatures(src, features);
+        Vec2f illuminant = predictIlluminant(features);
+
+        float denom = 1 - illuminant[0] - illuminant[1];
+        float gainB = 1.0f;
+        float gainG = denom / illuminant[1];
+        float gainR = denom / illuminant[0];
+        applyChannelGains(src, _dst, gainB, gainG, gainR);
+    }
+};
+
+/* Computes a mask for non-saturated pixels and maximum pixel value
+ * which are then used for feature computation
+ */
+void LearningBasedWBImpl::preprocessing(Mat &src)
+{
+    mask.create(src.size(), CV_8U);
+    uchar *mask_ptr = mask.ptr<uchar>();
+    int src_len = src.rows * src.cols;
+    int thresh = (int)(saturation_thresh * range_max_val);
+    int i = 0;
+    int local_max;
+    src_max_val = -1;
+
+    if (src.type() == CV_8UC3)
+    {
+        uchar *src_ptr = src.ptr<uchar>();
+#if CV_SIMD128
+        v_uint8x16 v_inB, v_inG, v_inR, v_local_max;
+        v_uint8x16 v_global_max = v_setall_u8(0), v_mask, v_thresh = v_setall_u8((uchar)thresh);
+        for (; i < src_len - 15; i += 16)
+        {
+            v_load_deinterleave(src_ptr + 3 * i, v_inB, v_inG, v_inR);
+            v_local_max = v_max(v_inB, v_max(v_inG, v_inR));
+            v_global_max = v_max(v_local_max, v_global_max);
+            v_mask = (v_local_max < v_thresh);
+            v_store(mask_ptr + i, v_mask);
+        }
+        uchar global_max[16];
+        v_store(global_max, v_global_max);
+        for (int j = 0; j < 16; j++)
+        {
+            if (global_max[j] > src_max_val)
+                src_max_val = global_max[j];
+        }
+#endif
+        for (; i < src_len; i++)
+        {
+            local_max = max(src_ptr[3 * i], max(src_ptr[3 * i + 1], src_ptr[3 * i + 2]));
+            if (local_max > src_max_val)
+                src_max_val = local_max;
+            if (local_max < thresh)
+                mask_ptr[i] = 255;
+            else
+                mask_ptr[i] = 0;
+        }
+    }
+    else if (src.type() == CV_16UC3)
+    {
+        ushort *src_ptr = src.ptr<ushort>();
+#if CV_SIMD128
+        v_uint16x8 v_inB, v_inG, v_inR, v_local_max;
+        v_uint16x8 v_global_max = v_setall_u16(0), v_mask, v_thresh = v_setall_u16((ushort)thresh);
+        for (; i < src_len - 7; i += 8)
+        {
+            v_load_deinterleave(src_ptr + 3 * i, v_inB, v_inG, v_inR);
+            v_local_max = v_max(v_inB, v_max(v_inG, v_inR));
+            v_global_max = v_max(v_local_max, v_global_max);
+            v_mask = (v_local_max < v_thresh);
+            v_pack_store(mask_ptr + i, v_mask);
+        }
+        ushort global_max[8];
+        v_store(global_max, v_global_max);
+        for (int j = 0; j < 8; j++)
+        {
+            if (global_max[j] > src_max_val)
+                src_max_val = global_max[j];
+        }
+#endif
+        for (; i < src_len; i++)
+        {
+            local_max = max(src_ptr[3 * i], max(src_ptr[3 * i + 1], src_ptr[3 * i + 2]));
+            if (local_max > src_max_val)
+                src_max_val = local_max;
+            if (local_max < thresh)
+                mask_ptr[i] = 255;
+            else
+                mask_ptr[i] = 0;
+        }
+    }
+}
+
+void LearningBasedWBImpl::getAverageAndBrightestColorChromaticity(Vec2f &average_chromaticity,
+                                                                  Vec2f &brightest_chromaticity, Mat &src)
+{
+    int i = 0;
+    int src_len = src.rows * src.cols;
+    uchar *mask_ptr = mask.ptr<uchar>();
+    uint brightestB = 0, brightestG = 0, brightestR = 0;
+    uint max_sum = 0;
+    if (src.type() == CV_8UC3)
+    {
+        uint sumB = 0, sumG = 0, sumR = 0;
+        uchar *src_ptr = src.ptr<uchar>();
+#if CV_SIMD128
+        v_uint16x8 v_max_sum = v_setall_u16(0), v_brightestR = v_setall_u16(0), v_brightestG = v_setall_u16(0), v_brightestB = v_setall_u16(0);
+        v_uint32x4 v_SB = v_setzero_u32(), v_SG = v_setzero_u32(), v_SR = v_setzero_u32();
+        for (; i < src_len - 15; i += 16)
+        {
+            v_uint8x16 v_inB, v_inG, v_inR;
+            v_load_deinterleave(src_ptr + 3 * i, v_inB, v_inG, v_inR);
+            v_uint8x16 v_mask = v_load(mask_ptr + i);
+
+            v_inB &= v_mask;
+            v_inG &= v_mask;
+            v_inR &= v_mask;
+
+            v_uint16x8 v_sR1, v_sR2, v_sG1, v_sG2, v_sB1, v_sB2;
+            v_expand(v_inB, v_sB1, v_sB2);
+            v_expand(v_inG, v_sG1, v_sG2);
+            v_expand(v_inR, v_sR1, v_sR2);
+
+            // update the brightest (R,G,B) tuple (process left half):
+            v_uint16x8 v_sum = v_sB1 + v_sG1 + v_sR1;
+            v_uint16x8 v_max_mask = (v_sum > v_max_sum);
+            v_max_sum = v_max(v_sum, v_max_sum);
+            v_brightestB = (v_sB1 & v_max_mask) + (v_brightestB & (~v_max_mask));
+            v_brightestG = (v_sG1 & v_max_mask) + (v_brightestG & (~v_max_mask));
+            v_brightestR = (v_sR1 & v_max_mask) + (v_brightestR & (~v_max_mask));
+
+            // update the brightest (R,G,B) tuple (process right half):
+            v_sum = v_sB2 + v_sG2 + v_sR2;
+            v_max_mask = (v_sum > v_max_sum);
+            v_max_sum = v_max(v_sum, v_max_sum);
+            v_brightestB = (v_sB2 & v_max_mask) + (v_brightestB & (~v_max_mask));
+            v_brightestG = (v_sG2 & v_max_mask) + (v_brightestG & (~v_max_mask));
+            v_brightestR = (v_sR2 & v_max_mask) + (v_brightestR & (~v_max_mask));
+
+            // update sums:
+            v_sB1 = v_sB1 + v_sB2;
+            v_sG1 = v_sG1 + v_sG2;
+            v_sR1 = v_sR1 + v_sR2;
+
+            v_uint32x4 v_uint1, v_uint2;
+            v_expand(v_sB1, v_uint1, v_uint2);
+            v_SB += v_uint1 + v_uint2;
+            v_expand(v_sG1, v_uint1, v_uint2);
+            v_SG += v_uint1 + v_uint2;
+            v_expand(v_sR1, v_uint1, v_uint2);
+            v_SR += v_uint1 + v_uint2;
+        }
+        sumB = v_reduce_sum(v_SB);
+        sumG = v_reduce_sum(v_SG);
+        sumR = v_reduce_sum(v_SR);
+        ushort brightestB_arr[8], brightestG_arr[8], brightestR_arr[8], max_sum_arr[8];
+        v_store(brightestB_arr, v_brightestB);
+        v_store(brightestG_arr, v_brightestG);
+        v_store(brightestR_arr, v_brightestR);
+        v_store(max_sum_arr, v_max_sum);
+        for (int j = 0; j < 8; j++)
+        {
+            if (max_sum_arr[j] > max_sum)
+            {
+                max_sum = max_sum_arr[j];
+                brightestB = brightestB_arr[j];
+                brightestG = brightestG_arr[j];
+                brightestR = brightestR_arr[j];
+            }
+        }
+#endif
+        for (; i < src_len; i++)
+        {
+            uint sum_val = src_ptr[3 * i] + src_ptr[3 * i + 1] + src_ptr[3 * i + 2];
+            if (mask_ptr[i])
+            {
+                sumB += src_ptr[3 * i];
+                sumG += src_ptr[3 * i + 1];
+                sumR += src_ptr[3 * i + 2];
+                if (sum_val > max_sum)
+                {
+                    max_sum = sum_val;
+                    brightestB = src_ptr[3 * i];
+                    brightestG = src_ptr[3 * i + 1];
+                    brightestR = src_ptr[3 * i + 2];
+                }
+            }
+        }
+        double maxRGB = (double)max(sumR, max(sumG, sumB));
+        getChromaticity(average_chromaticity, (float)(sumR / maxRGB), (float)(sumG / maxRGB), (float)(sumB / maxRGB));
+        getChromaticity(brightest_chromaticity, (float)brightestR, (float)brightestG, (float)brightestB);
+    }
+    else if (src.type() == CV_16UC3)
+    {
+        uint64 sumB = 0, sumG = 0, sumR = 0;
+        ushort *src_ptr = src.ptr<ushort>();
+#if CV_SIMD128
+        const v_uint16x8 v_mask_lower = v_setall_u16(255);
+        v_uint32x4 v_max_sum = v_setall_u32(0), v_brightestR = v_setall_u32(0), v_brightestG = v_setall_u32(0), v_brightestB = v_setall_u32(0);
+        v_uint64x2 v_SB = v_setzero_u64(), v_SG = v_setzero_u64(), v_SR = v_setzero_u64();
+        for (; i < src_len - 7; i += 8)
+        {
+            v_uint16x8 v_inB, v_inG, v_inR;
+            v_load_deinterleave(src_ptr + 3 * i, v_inB, v_inG, v_inR);
+            v_uint16x8 v_mask = v_load_expand(mask_ptr + i);
+            v_mask = v_mask | ((v_mask & v_mask_lower) << 8);
+
+            v_inB &= v_mask;
+            v_inG &= v_mask;
+            v_inR &= v_mask;
+
+            v_uint32x4 v_iR1, v_iR2, v_iG1, v_iG2, v_iB1, v_iB2;
+            v_expand(v_inB, v_iB1, v_iB2);
+            v_expand(v_inG, v_iG1, v_iG2);
+            v_expand(v_inR, v_iR1, v_iR2);
+
+            // update the brightest (R,G,B) tuple (process left half):
+            v_uint32x4 v_sum = v_iB1 + v_iG1 + v_iR1;
+            v_uint32x4 v_max_mask = (v_sum > v_max_sum);
+            v_max_sum = v_max(v_sum, v_max_sum);
+            v_brightestB = (v_iB1 & v_max_mask) + (v_brightestB & (~v_max_mask));
+            v_brightestG = (v_iG1 & v_max_mask) + (v_brightestG & (~v_max_mask));
+            v_brightestR = (v_iR1 & v_max_mask) + (v_brightestR & (~v_max_mask));
+
+            // update the brightest (R,G,B) tuple (process right half):
+            v_sum = v_iB2 + v_iG2 + v_iR2;
+            v_max_mask = (v_sum > v_max_sum);
+            v_max_sum = v_max(v_sum, v_max_sum);
+            v_brightestB = (v_iB2 & v_max_mask) + (v_brightestB & (~v_max_mask));
+            v_brightestG = (v_iG2 & v_max_mask) + (v_brightestG & (~v_max_mask));
+            v_brightestR = (v_iR2 & v_max_mask) + (v_brightestR & (~v_max_mask));
+
+            // update sums:
+            v_iB1 = v_iB1 + v_iB2;
+            v_iG1 = v_iG1 + v_iG2;
+            v_iR1 = v_iR1 + v_iR2;
+            v_uint64x2 v_uint64_1, v_uint64_2;
+            v_expand(v_iB1, v_uint64_1, v_uint64_2);
+            v_SB += v_uint64_1 + v_uint64_2;
+            v_expand(v_iG1, v_uint64_1, v_uint64_2);
+            v_SG += v_uint64_1 + v_uint64_2;
+            v_expand(v_iR1, v_uint64_1, v_uint64_2);
+            v_SR += v_uint64_1 + v_uint64_2;
+        }
+        uint64 sum_arr[2];
+        v_store(sum_arr, v_SB);
+        sumB = sum_arr[0] + sum_arr[1];
+        v_store(sum_arr, v_SG);
+        sumG = sum_arr[0] + sum_arr[1];
+        v_store(sum_arr, v_SR);
+        sumR = sum_arr[0] + sum_arr[1];
+        uint brightestB_arr[4], brightestG_arr[4], brightestR_arr[4], max_sum_arr[4];
+        v_store(brightestB_arr, v_brightestB);
+        v_store(brightestG_arr, v_brightestG);
+        v_store(brightestR_arr, v_brightestR);
+        v_store(max_sum_arr, v_max_sum);
+        for (int j = 0; j < 4; j++)
+        {
+            if (max_sum_arr[j] > max_sum)
+            {
+                max_sum = max_sum_arr[j];
+                brightestB = brightestB_arr[j];
+                brightestG = brightestG_arr[j];
+                brightestR = brightestR_arr[j];
+            }
+        }
+#endif
+        for (; i < src_len; i++)
+        {
+            uint sum_val = src_ptr[3 * i] + src_ptr[3 * i + 1] + src_ptr[3 * i + 2];
+            if (mask_ptr[i])
+            {
+                sumB += src_ptr[3 * i];
+                sumG += src_ptr[3 * i + 1];
+                sumR += src_ptr[3 * i + 2];
+                if (sum_val > max_sum)
+                {
+                    max_sum = sum_val;
+                    brightestB = src_ptr[3 * i];
+                    brightestG = src_ptr[3 * i + 1];
+                    brightestR = src_ptr[3 * i + 2];
+                }
+            }
+        }
+        double maxRGB = (double)max(sumR, max(sumG, sumB));
+        getChromaticity(average_chromaticity, (float)(sumR / maxRGB), (float)(sumG / maxRGB), (float)(sumB / maxRGB));
+        getChromaticity(brightest_chromaticity, (float)brightestR, (float)brightestG, (float)brightestB);
+    }
+}
+
+/* Returns the most high-density point (i.e. mode) of the color palette.
+ * Uses a simplistic kernel density estimator with a Epanechnikov kernel and
+ * fixed bandwidth.
+ */
+void LearningBasedWBImpl::getColorPaletteMode(Vec2f &dst, hist_elem *palette)
+{
+    float max_density = -1.0f;
+    float denom = palette_bandwidth * palette_bandwidth;
+    for (int i = 0; i < palette_size; i++)
+    {
+        float cur_density = 0.0f;
+        float cur_dist_sq;
+
+        for (int j = 0; j < palette_size; j++)
+        {
+            cur_dist_sq = (palette[i].r - palette[j].r) * (palette[i].r - palette[j].r) +
+                          (palette[i].g - palette[j].g) * (palette[i].g - palette[j].g);
+            cur_density += max((1.0f - (cur_dist_sq / denom)), 0.0f);
+        }
+
+        if (cur_density > max_density)
+        {
+            max_density = cur_density;
+            dst[0] = palette[i].r;
+            dst[1] = palette[i].g;
+        }
+    }
+}
+
+void LearningBasedWBImpl::getHistogramBasedFeatures(Vec2f &dominant_chromaticity, Vec2f &chromaticity_palette_mode,
+                                                    Mat &src)
+{
+    MatND hist;
+    int channels[] = {0, 1, 2};
+    int histSize[] = {hist_bin_num, hist_bin_num, hist_bin_num};
+    float range[] = {0, (float)max(hist_bin_num, src_max_val)};
+    const float *ranges[] = {range, range, range};
+    calcHist(&src, 1, channels, mask, hist, 3, histSize, ranges);
+
+    int dominant_B = 0, dominant_G = 0, dominant_R = 0;
+    double max_hist_val = 0;
+    float *hist_ptr = hist.ptr<float>();
+    for (int i = 0; i < hist_bin_num; i++)
+        for (int j = 0; j < hist_bin_num; j++)
+            for (int k = 0; k < hist_bin_num; k++)
+            {
+                if (*hist_ptr > max_hist_val)
+                {
+                    max_hist_val = *hist_ptr;
+                    dominant_B = i;
+                    dominant_G = j;
+                    dominant_R = k;
+                }
+                hist_ptr++;
+            }
+    getChromaticity(dominant_chromaticity, (float)dominant_R, (float)dominant_G, (float)dominant_B);
+
+    vector<hist_elem> palette;
+    palette.reserve(palette_size);
+    hist_ptr = hist.ptr<float>();
+    // extract top palette_size most common colors and add them to the palette:
+    for (int i = 0; i < hist_bin_num; i++)
+        for (int j = 0; j < hist_bin_num; j++)
+            for (int k = 0; k < hist_bin_num; k++)
+            {
+                float bin_count = *hist_ptr;
+                if (bin_count < EPS)
+                {
+                    hist_ptr++;
+                    continue;
+                }
+                Vec2f chromaticity;
+                getChromaticity(chromaticity, (float)k, (float)j, (float)i);
+                hist_elem el(bin_count, chromaticity);
+
+                if (palette.size() < (uint)palette_size)
+                {
+                    palette.push_back(el);
+                    if (palette.size() == (uint)palette_size)
+                        make_heap(palette.begin(), palette.end());
+                }
+                else if (bin_count > palette.front().hist_val)
+                {
+                    pop_heap(palette.begin(), palette.end());
+                    palette.back() = el;
+                    push_heap(palette.begin(), palette.end());
+                }
+                hist_ptr++;
+            }
+    getColorPaletteMode(chromaticity_palette_mode, (hist_elem *)(&palette[0]));
+}
+
+float LearningBasedWBImpl::regressionTreePredict(Vec2f src, uchar *tree_feature_idx, float *tree_thresh_vals,
+                                                 float *tree_leaf_vals)
+{
+    int node_idx = 0;
+    for (int i = 0; i < tree_depth; i++)
+    {
+        if (src[tree_feature_idx[node_idx]] <= tree_thresh_vals[node_idx])
+            node_idx = 2 * node_idx + 1;
+        else
+            node_idx = 2 * node_idx + 2;
+    }
+    return tree_leaf_vals[node_idx - num_tree_nodes + 1];
+}
+
+Vec2f LearningBasedWBImpl::predictIlluminant(vector<Vec2f> features)
+{
+    int feature_model_size = 2 * (num_tree_nodes - 1);
+    int local_model_size = num_features * feature_model_size;
+    int feature_model_size_leaf = 2 * num_tree_nodes;
+    int local_model_size_leaf = num_features * feature_model_size_leaf;
+    tree_depth = cvRound( (log(static_cast<float>(num_tree_nodes)) / log(2.0f)) );
+
+    vector<float> consensus_r, consensus_g;
+    vector<float> all_r, all_g;
+    for (int i = 0; i < num_trees; i++)
+    {
+        Vec2f local_predictions[num_features];
+        for (int j = 0; j < num_features; j++)
+        {
+            float r = regressionTreePredict(features[j], feature_idx + local_model_size * i + feature_model_size * j,
+                                            thresh_vals + local_model_size * i + feature_model_size * j,
+                                            leaf_vals + local_model_size_leaf * i + feature_model_size_leaf * j);
+            float g = regressionTreePredict(
+              features[j], feature_idx + local_model_size * i + feature_model_size * j + feature_model_size / 2,
+              thresh_vals + local_model_size * i + feature_model_size * j + feature_model_size / 2,
+              leaf_vals + local_model_size_leaf * i + feature_model_size_leaf * j + feature_model_size_leaf / 2);
+            local_predictions[j] = Vec2f(r, g);
+            all_r.push_back(r);
+            all_g.push_back(g);
+        }
+        int agreement_degree = 0;
+        for (int j = 0; j < num_features - 1; j++)
+            for (int k = j + 1; k < num_features; k++)
+            {
+                if (norm(local_predictions[j] - local_predictions[k]) < prediction_thresh)
+                    agreement_degree++;
+            }
+        if (agreement_degree >= 3)
+        {
+            for (int j = 0; j < num_features; j++)
+            {
+                consensus_r.push_back(local_predictions[j][0]);
+                consensus_g.push_back(local_predictions[j][1]);
+            }
+        }
+    }
+
+    float illuminant_r, illuminant_g;
+    if (consensus_r.size() == 0)
+    {
+        nth_element(all_r.begin(), all_r.begin() + all_r.size() / 2, all_r.end());
+        illuminant_r = all_r[all_r.size() / 2];
+        nth_element(all_g.begin(), all_g.begin() + all_g.size() / 2, all_g.end());
+        illuminant_g = all_g[all_g.size() / 2];
+    }
+    else
+    {
+        nth_element(consensus_r.begin(), consensus_r.begin() + consensus_r.size() / 2, consensus_r.end());
+        illuminant_r = consensus_r[consensus_r.size() / 2];
+        nth_element(consensus_g.begin(), consensus_g.begin() + consensus_g.size() / 2, consensus_g.end());
+        illuminant_g = consensus_g[consensus_g.size() / 2];
+    }
+    return Vec2f(illuminant_r, illuminant_g);
+}
+
+Ptr<LearningBasedWB> createLearningBasedWB(const String& path_to_model)
+{
+    Ptr<LearningBasedWB> inst = makePtr<LearningBasedWBImpl>(path_to_model);
+    return inst;
+}
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/learning_based_color_balance_model.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/learning_based_color_balance_model.hpp
new file mode 100644
index 00000000..e46d8f6d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/learning_based_color_balance_model.hpp
@@ -0,0 +1,365 @@
+/* This file was automatically generated by learn_color_balance.py script
+ * using the following parameters:
+ --num_trees 20 --hist_bin_num 64 --max_tree_depth 4 --num_augmented 2 -r 0,0
+ */
+const int num_features = 4;
+const int _num_trees = 20;
+const int _num_tree_nodes = 16;
+unsigned char _feature_idx[_num_trees * num_features * 2 * (_num_tree_nodes - 1)] = {
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1,
+  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1,
+  0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0,
+  0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+  0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+  1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0,
+  1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0,
+  1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+  0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1,
+  0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,
+  0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+  1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
+  0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1,
+  0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,
+  0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+  1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1,
+  1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1,
+  0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1,
+  0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,
+  1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+  0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1,
+  1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+  0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0,
+  1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0,
+  0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,
+  1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0,
+  0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+  0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1,
+  1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+float _thresh_vals[_num_trees * num_features * 2 * (_num_tree_nodes - 1)] = {
+  .193f, .098f, .455f, .040f, .145f, .316f, .571f, .016f, .058f, .137f, .174f, .276f, .356f, .515f, .730f, .606f, .324f,
+  .794f, .230f, .440f, .683f, .878f, .134f, .282f, .406f, .532f, .036f, .747f, .830f, .931f, .196f, .145f, .363f, .047f,
+  .351f, .279f, .519f, .013f, .887f, .191f, .193f, .361f, .316f, .576f, .445f, .524f, .368f, .752f, .271f, .477f, .636f,
+  .798f, .146f, .249f, .423f, .521f, .446f, .023f, .795f, .908f, .259f, .026f, .557f, .125f, .121f, .432f, .774f, .500f,
+  .500f, .984f, .202f, .307f, .509f, .038f, .042f, .667f, .500f, .000f, .014f, .560f, .984f, .000f, .125f, .333f, .553f,
+  .333f, .860f, .000f, .500f, .000f, .193f, .114f, .432f, .032f, .157f, .310f, .567f, .013f, .048f, .127f, .428f, .271f,
+  .370f, .511f, .762f, .615f, .325f, .833f, .193f, .440f, .728f, .887f, .086f, .230f, .411f, .546f, .671f, .009f, .863f,
+  .944f, .283f, .174f, .515f, .087f, .209f, .356f, .693f, .059f, .145f, .344f, .254f, .316f, .455f, .571f, .811f, .537f,
+  .343f, .751f, .243f, .435f, .630f, .813f, .134f, .310f, .391f, .487f, .597f, .683f, .755f, .878f, .307f, .145f, .446f,
+  .063f, .349f, .457f, .576f, .021f, .792f, .268f, .250f, .421f, .463f, .574f, .610f, .478f, .354f, .636f, .271f, .423f,
+  .529f, .795f, .146f, .257f, .124f, .458f, .043f, .022f, .752f, .836f, .307f, .026f, .557f, .125f, .135f, .435f, .774f,
+  .500f, .500f, .984f, .238f, .500f, .509f, .038f, .042f, .600f, .400f, .000f, .014f, .500f, .667f, .000f, .125f, .250f,
+  .455f, .097f, .333f, .984f, .000f, .000f, .271f, .155f, .511f, .078f, .198f, .372f, .696f, .059f, .123f, .183f, .237f,
+  .310f, .432f, .564f, .875f, .546f, .324f, .728f, .195f, .423f, .616f, .823f, .131f, .281f, .355f, .490f, .581f, .677f,
+  .775f, .885f, .300f, .192f, .515f, .109f, .248f, .374f, .693f, .065f, .157f, .580f, .276f, .341f, .455f, .571f, .811f,
+  .532f, .324f, .679f, .196f, .421f, .630f, .804f, .111f, .252f, .348f, .447f, .565f, .247f, .755f, .866f, .335f, .188f,
+  .503f, .104f, .270f, .521f, .607f, .021f, .134f, .364f, .332f, .421f, .571f, .576f, .836f, .458f, .294f, .523f, .171f,
+  .413f, .501f, .651f, .065f, .273f, .354f, .062f, .052f, .489f, .523f, .784f, .307f, .026f, .557f, .125f, .156f, .432f,
+  .774f, .500f, .500f, .984f, .200f, .399f, .509f, .038f, .042f, .560f, .429f, .000f, .014f, .138f, .667f, .000f, .125f,
+  .222f, .500f, .522f, .286f, .984f, .500f, .000f, .295f, .186f, .564f, .104f, .293f, .432f, .762f, .059f, .127f, .271f,
+  .593f, .353f, .511f, .630f, .875f, .538f, .324f, .685f, .195f, .423f, .616f, .791f, .099f, .281f, .389f, .452f, .581f,
+  .293f, .728f, .842f, .320f, .211f, .521f, .098f, .251f, .403f, .693f, .058f, .158f, .580f, .469f, .188f, .455f, .571f,
+  .811f, .532f, .324f, .717f, .193f, .415f, .587f, .791f, .122f, .265f, .391f, .457f, .559f, .665f, .753f, .835f, .405f,
+  .305f, .503f, .135f, .457f, .483f, .607f, .044f, .182f, .394f, .569f, .156f, .484f, .576f, .836f, .455f, .294f, .576f,
+  .248f, .376f, .482f, .651f, .089f, .273f, .181f, .430f, .472f, .500f, .265f, .784f, .414f, .228f, .557f, .026f, .620f,
+  .476f, .774f, .500f, .156f, .595f, .304f, .322f, .509f, .038f, .042f, .533f, .391f, .683f, .106f, .175f, .286f, .010f,
+  .026f, .226f, .500f, .429f, .197f, .655f, .000f, .800f, .386f, .218f, .564f, .082f, .295f, .479f, .762f, .043f, .155f,
+  .293f, .440f, .432f, .511f, .630f, .875f, .544f, .306f, .705f, .185f, .412f, .606f, .791f, .109f, .263f, .372f, .502f,
+  .315f, .685f, .741f, .855f, .365f, .221f, .544f, .110f, .307f, .455f, .730f, .059f, .179f, .276f, .468f, .403f, .515f,
+  .678f, .860f, .520f, .340f, .683f, .196f, .440f, .591f, .754f, .122f, .274f, .394f, .464f, .556f, .622f, .723f, .835f,
+  .375f, .147f, .503f, .055f, .319f, .436f, .607f, .018f, .773f, .624f, .298f, .467f, .450f, .576f, .836f, .454f, .287f,
+  .571f, .163f, .376f, .308f, .648f, .086f, .236f, .373f, .427f, .477f, .496f, .333f, .795f, .500f, .307f, .774f, .026f,
+  .462f, .557f, .042f, .125f, .191f, .406f, .500f, .509f, .038f, .000f, .138f, .600f, .400f, .000f, .073f, .500f, .010f,
+  .000f, .026f, .275f, .226f, .588f, .984f, .688f, .000f, .000f, .386f, .245f, .564f, .097f, .343f, .479f, .762f, .048f,
+  .180f, .424f, .466f, .432f, .511f, .630f, .875f, .541f, .335f, .702f, .193f, .413f, .602f, .791f, .116f, .296f, .376f,
+  .481f, .210f, .641f, .741f, .863f, .341f, .145f, .531f, .087f, .283f, .455f, .729f, .047f, .109f, .189f, .469f, .375f,
+  .515f, .571f, .811f, .553f, .324f, .683f, .196f, .425f, .607f, .761f, .122f, .252f, .368f, .499f, .248f, .648f, .723f,
+  .848f, .365f, .135f, .503f, .082f, .279f, .503f, .607f, .044f, .086f, .182f, .319f, .395f, .448f, .576f, .836f, .454f,
+  .287f, .571f, .163f, .389f, .308f, .752f, .086f, .250f, .373f, .436f, .498f, .496f, .636f, .834f, .500f, .307f, .774f,
+  .026f, .474f, .557f, .042f, .125f, .000f, .414f, .561f, .509f, .038f, .000f, .138f, .560f, .626f, .000f, .400f, .174f,
+  .984f, .000f, .073f, .500f, .852f, .226f, .667f, .500f, .000f, .000f, .353f, .141f, .564f, .073f, .265f, .432f, .762f,
+  .032f, .106f, .193f, .478f, .470f, .511f, .630f, .875f, .605f, .325f, .728f, .193f, .437f, .652f, .855f, .116f, .264f,
+  .412f, .502f, .202f, .685f, .776f, .912f, .341f, .161f, .531f, .087f, .298f, .455f, .729f, .047f, .109f, .185f, .467f,
+  .375f, .515f, .571f, .811f, .580f, .324f, .685f, .196f, .425f, .607f, .824f, .122f, .252f, .368f, .512f, .231f, .648f,
+  .749f, .885f, .365f, .135f, .503f, .082f, .319f, .499f, .607f, .044f, .086f, .702f, .384f, .439f, .465f, .576f, .836f,
+  .478f, .287f, .594f, .163f, .454f, .502f, .784f, .086f, .250f, .364f, .345f, .500f, .370f, .651f, .836f, .476f, .295f,
+  .557f, .026f, .474f, .509f, .774f, .125f, .000f, .333f, .364f, .495f, .405f, .038f, .042f, .560f, .626f, .000f, .400f,
+  .174f, .010f, .000f, .059f, .500f, .852f, .226f, .667f, .667f, .000f, .000f, .419f, .157f, .564f, .078f, .295f, .479f,
+  .762f, .043f, .124f, .256f, .353f, .432f, .511f, .630f, .875f, .605f, .325f, .713f, .193f, .423f, .677f, .842f, .116f,
+  .264f, .385f, .502f, .621f, .177f, .756f, .912f, .388f, .174f, .564f, .095f, .310f, .456f, .730f, .047f, .143f, .276f,
+  .468f, .431f, .515f, .682f, .860f, .352f, .215f, .591f, .124f, .290f, .536f, .723f, .064f, .172f, .244f, .318f, .428f,
+  .548f, .666f, .825f, .394f, .146f, .503f, .055f, .349f, .499f, .607f, .018f, .773f, .271f, .327f, .439f, .465f, .576f,
+  .836f, .464f, .287f, .588f, .163f, .377f, .502f, .752f, .086f, .250f, .237f, .454f, .464f, .370f, .636f, .834f, .476f,
+  .000f, .557f, .282f, .000f, .509f, .774f, .026f, .481f, .000f, .000f, .495f, .405f, .038f, .042f, .556f, .626f, .000f,
+  .343f, .174f, .010f, .000f, .023f, .559f, .852f, .226f, .667f, .667f, .000f, .000f, .468f, .157f, .567f, .078f, .305f,
+  .511f, .762f, .043f, .124f, .271f, .464f, .511f, .193f, .630f, .875f, .351f, .208f, .602f, .116f, .302f, .489f, .720f,
+  .059f, .164f, .281f, .325f, .414f, .282f, .654f, .842f, .388f, .174f, .564f, .095f, .313f, .456f, .730f, .047f, .143f,
+  .279f, .468f, .431f, .515f, .682f, .860f, .356f, .215f, .591f, .124f, .290f, .539f, .753f, .064f, .174f, .274f, .318f,
+  .435f, .556f, .647f, .848f, .411f, .146f, .411f, .055f, .349f, .490f, .499f, .018f, .773f, .271f, .327f, .181f, .610f,
+  .467f, .448f, .287f, .163f, .454f, .086f, .262f, .359f, .636f, .041f, .476f, .200f, .633f, .257f, .428f, .522f, .795f,
+  .435f, .000f, .557f, .049f, .000f, .509f, .774f, .330f, .282f, .500f, .000f, .462f, .405f, .038f, .042f, .393f, .029f,
+  .000f, .026f, .226f, .602f, .000f, .500f, .183f, .163f, .337f, .500f, .984f, .500f, .000f, .468f, .157f, .567f, .078f,
+  .314f, .511f, .762f, .043f, .124f, .271f, .456f, .511f, .193f, .630f, .875f, .355f, .208f, .602f, .116f, .296f, .414f,
+  .761f, .059f, .179f, .263f, .324f, .381f, .502f, .681f, .855f, .356f, .174f, .537f, .095f, .289f, .455f, .729f, .047f,
+  .143f, .186f, .471f, .403f, .515f, .588f, .811f, .352f, .215f, .568f, .147f, .282f, .435f, .723f, .077f, .191f, .265f,
+  .318f, .395f, .543f, .630f, .824f, .439f, .141f, .443f, .051f, .363f, .490f, .479f, .018f, .773f, .279f, .446f, .223f,
+  .607f, .504f, .491f, .298f, .179f, .454f, .086f, .264f, .350f, .571f, .041f, .122f, .390f, .287f, .324f, .431f, .502f,
+  .752f, .500f, .307f, .774f, .026f, .500f, .557f, .042f, .125f, .000f, .434f, .524f, .509f, .038f, .000f, .138f, .447f,
+  .225f, .000f, .026f, .226f, .600f, .000f, .500f, .337f, .667f, .333f, .269f, .984f, .500f, .000f, .425f, .157f, .564f,
+  .078f, .314f, .511f, .762f, .043f, .124f, .269f, .467f, .479f, .561f, .630f, .875f, .372f, .208f, .602f, .148f, .296f,
+  .441f, .775f, .072f, .179f, .230f, .324f, .408f, .516f, .652f, .863f, .403f, .179f, .571f, .095f, .337f, .456f, .730f,
+  .047f, .145f, .267f, .458f, .056f, .521f, .682f, .860f, .352f, .193f, .568f, .095f, .282f, .435f, .696f, .056f, .147f,
+  .230f, .318f, .395f, .534f, .630f, .808f, .484f, .141f, .454f, .051f, .372f, .605f, .487f, .018f, .773f, .316f, .483f,
+  .490f, .610f, .486f, .490f, .298f, .200f, .472f, .122f, .275f, .397f, .571f, .061f, .174f, .370f, .364f, .349f, .435f,
+  .499f, .752f, .500f, .307f, .667f, .026f, .500f, .661f, .774f, .125f, .000f, .398f, .524f, .557f, .167f, .760f, .042f,
+  .500f, .667f, .000f, .429f, .138f, .984f, .000f, .029f, .364f, .906f, .226f, .667f, .500f, .000f, .000f, .488f, .157f,
+  .567f, .078f, .366f, .511f, .762f, .043f, .124f, .309f, .487f, .511f, .193f, .630f, .875f, .376f, .208f, .575f, .148f,
+  .302f, .452f, .687f, .072f, .182f, .230f, .325f, .413f, .516f, .621f, .833f, .452f, .179f, .571f, .095f, .349f, .515f,
+  .730f, .047f, .145f, .244f, .444f, .456f, .206f, .682f, .860f, .368f, .215f, .568f, .124f, .290f, .444f, .689f, .063f,
+  .188f, .252f, .343f, .406f, .516f, .630f, .804f, .162f, .085f, .490f, .044f, .086f, .372f, .454f, .015f, .424f, .463f,
+  .134f, .262f, .478f, .607f, .490f, .462f, .297f, .583f, .163f, .349f, .522f, .702f, .065f, .237f, .315f, .428f, .499f,
+  .397f, .636f, .795f, .500f, .310f, .667f, .026f, .432f, .661f, .000f, .125f, .146f, .500f, .332f, .557f, .167f, .774f,
+  .000f, .537f, .667f, .000f, .400f, .138f, .984f, .000f, .029f, .500f, .906f, .226f, .667f, .500f, .000f, .000f, .511f,
+  .157f, .696f, .078f, .361f, .564f, .875f, .043f, .124f, .223f, .404f, .561f, .630f, .762f, .896f, .376f, .209f, .578f,
+  .116f, .296f, .452f, .687f, .058f, .179f, .264f, .332f, .413f, .516f, .621f, .833f, .455f, .189f, .571f, .098f, .274f,
+  .515f, .730f, .056f, .148f, .244f, .354f, .233f, .206f, .682f, .860f, .381f, .230f, .565f, .124f, .315f, .496f, .673f,
+  .064f, .177f, .282f, .351f, .441f, .528f, .622f, .804f, .146f, .082f, .503f, .044f, .086f, .349f, .607f, .015f, .424f,
+  .085f, .134f, .262f, .298f, .576f, .836f, .349f, .271f, .466f, .146f, .297f, .413f, .608f, .065f, .200f, .364f, .318f,
+  .441f, .291f, .531f, .752f, .535f, .000f, .226f, .286f, .000f, .000f, .348f, .026f, .432f, .000f, .000f, .667f, .000f,
+  .333f, .423f, .500f, .391f, .000f, .073f, .500f, .600f, .000f, .026f, .226f, .455f, .551f, .379f, .984f, .000f, .000f,
+  .564f, .184f, .762f, .089f, .404f, .630f, .875f, .044f, .141f, .271f, .332f, .614f, .752f, .864f, .896f, .385f, .230f,
+  .590f, .116f, .332f, .505f, .687f, .059f, .185f, .283f, .506f, .452f, .546f, .626f, .833f, .254f, .161f, .456f, .087f,
+  .189f, .300f, .571f, .047f, .109f, .179f, .209f, .275f, .375f, .521f, .730f, .395f, .230f, .565f, .112f, .348f, .505f,
+  .751f, .064f, .177f, .290f, .387f, .441f, .282f, .623f, .848f, .146f, .055f, .503f, .018f, .773f, .316f, .607f, .011f,
+  .428f, .134f, .887f, .236f, .358f, .576f, .836f, .349f, .271f, .472f, .146f, .364f, .413f, .636f, .065f, .200f, .288f,
+  .366f, .441f, .398f, .516f, .795f, .592f, .000f, .774f, .282f, .000f, .735f, .042f, .026f, .476f, .000f, .000f, .038f,
+  .127f, .000f, .138f, .500f, .391f, .000f, .029f, .500f, .522f, .000f, .026f, .226f, .455f, .535f, .260f, .984f, .000f,
+  .000f, .250f, .155f, .564f, .078f, .198f, .404f, .762f, .043f, .124f, .183f, .223f, .295f, .432f, .630f, .875f, .385f,
+  .230f, .574f, .116f, .330f, .505f, .728f, .065f, .173f, .283f, .554f, .453f, .546f, .626f, .842f, .285f, .161f, .515f,
+  .087f, .209f, .441f, .693f, .047f, .109f, .184f, .264f, .334f, .456f, .571f, .811f, .352f, .198f, .555f, .124f, .274f,
+  .449f, .723f, .076f, .172f, .236f, .318f, .402f, .519f, .622f, .824f, .236f, .146f, .503f, .055f, .147f, .366f, .607f,
+  .018f, .773f, .146f, .188f, .280f, .499f, .576f, .836f, .329f, .262f, .449f, .163f, .364f, .350f, .588f, .086f, .200f,
+  .296f, .366f, .331f, .412f, .482f, .784f, .571f, .000f, .774f, .307f, .000f, .234f, .042f, .026f, .406f, .000f, .000f,
+  .647f, .620f, .000f, .138f, .500f, .400f, .000f, .109f, .068f, .537f, .000f, .026f, .226f, .500f, .447f, .522f, .984f,
+  .000f, .000f, .268f, .157f, .511f, .078f, .198f, .346f, .696f, .043f, .124f, .183f, .237f, .313f, .458f, .564f, .875f,
+  .351f, .208f, .571f, .116f, .265f, .460f, .728f, .065f, .164f, .230f, .308f, .412f, .516f, .632f, .842f, .300f, .161f,
+  .521f, .087f, .209f, .360f, .693f, .047f, .109f, .184f, .276f, .313f, .452f, .571f, .811f, .351f, .196f, .558f, .122f,
+  .274f, .449f, .723f, .072f, .166f, .236f, .318f, .421f, .520f, .617f, .824f, .190f, .134f, .503f, .051f, .402f, .280f,
+  .607f, .018f, .773f, .156f, .616f, .389f, .345f, .576f, .836f, .326f, .237f, .466f, .179f, .294f, .350f, .636f, .086f,
+  .407f, .277f, .338f, .295f, .415f, .562f, .795f, .307f, .026f, .774f, .125f, .000f, .543f, .042f, .500f, .500f, .205f,
+  .000f, .420f, .321f, .000f, .138f, .447f, .371f, .560f, .026f, .226f, .500f, .000f, .125f, .297f, .187f, .304f, .500f,
+  .522f, .984f, .000f, .256f, .155f, .564f, .078f, .193f, .314f, .762f, .043f, .124f, .428f, .223f, .258f, .470f, .630f,
+  .875f, .338f, .193f, .582f, .116f, .264f, .465f, .728f, .065f, .164f, .230f, .296f, .414f, .531f, .652f, .842f, .316f,
+  .174f, .571f, .095f, .276f, .433f, .730f, .047f, .143f, .209f, .300f, .343f, .521f, .682f, .860f, .343f, .193f, .587f,
+  .105f, .274f, .438f, .751f, .066f, .166f, .230f, .318f, .381f, .519f, .648f, .848f, .271f, .146f, .503f, .055f, .403f,
+  .366f, .607f, .018f, .773f, .365f, .445f, .444f, .517f, .576f, .836f, .324f, .237f, .478f, .115f, .287f, .350f, .636f,
+  .074f, .405f, .387f, .337f, .295f, .431f, .522f, .795f, .307f, .026f, .667f, .125f, .984f, .426f, .000f, .500f, .500f,
+  .156f, .000f, .500f, .557f, .972f, .000f, .429f, .434f, .000f, .023f, .226f, .560f, .000f, .125f, .222f, .760f, .500f,
+  .500f, .667f, .000f, .000f, .310f, .157f, .564f, .078f, .256f, .425f, .762f, .043f, .124f, .193f, .258f, .350f, .511f,
+  .630f, .875f, .337f, .182f, .597f, .101f, .264f, .443f, .728f, .063f, .161f, .216f, .296f, .395f, .522f, .652f, .842f,
+  .341f, .174f, .516f, .095f, .276f, .431f, .678f, .047f, .143f, .209f, .300f, .391f, .460f, .571f, .811f, .324f, .193f,
+  .543f, .122f, .254f, .434f, .689f, .066f, .145f, .230f, .431f, .391f, .508f, .597f, .808f, .271f, .146f, .366f, .055f,
+  .365f, .357f, .503f, .018f, .773f, .249f, .417f, .316f, .444f, .517f, .607f, .308f, .200f, .472f, .115f, .264f, .357f,
+  .571f, .058f, .138f, .260f, .364f, .338f, .431f, .499f, .752f, .414f, .049f, .557f, .125f, .307f, .438f, .000f, .500f,
+  .330f, .984f, .333f, .446f, .122f, .014f, .000f, .391f, .333f, .518f, .026f, .174f, .500f, .000f, .125f, .279f, .760f,
+  .299f, .500f, .408f, .667f, .000f, .310f, .157f, .479f, .078f, .255f, .370f, .564f, .043f, .124f, .193f, .271f, .483f,
+  .418f, .512f, .762f, .335f, .182f, .597f, .086f, .265f, .423f, .728f, .041f, .129f, .230f, .302f, .375f, .522f, .652f,
+  .842f, .374f, .184f, .544f, .095f, .300f, .455f, .811f, .047f, .145f, .254f, .341f, .404f, .516f, .569f, .860f, .326f,
+  .196f, .584f, .118f, .252f, .434f, .751f, .064f, .141f, .236f, .290f, .391f, .508f, .648f, .848f, .316f, .146f, .421f,
+  .055f, .279f, .454f, .503f, .018f, .773f, .183f, .280f, .347f, .571f, .499f, .605f, .294f, .161f, .499f, .086f, .225f,
+  .364f, .636f, .058f, .476f, .200f, .264f, .347f, .454f, .571f, .795f, .500f, .520f, .307f, .462f, .571f, .000f, .450f,
+  .051f, .220f, .557f, .833f, .984f, .000f, .655f, .532f, .355f, .073f, .556f, .026f, .138f, .500f, .000f, .500f, .183f,
+  .906f, .299f, .410f, .333f, .984f, .000f, .370f, .157f, .559f, .078f, .271f, .483f, .762f, .043f, .124f, .198f, .310f,
+  .418f, .512f, .752f, .022f, .308f, .161f, .582f, .086f, .230f, .414f, .728f, .042f, .116f, .193f, .281f, .346f, .489f,
+  .632f, .842f, .455f, .184f, .729f, .095f, .316f, .579f, .811f, .047f, .145f, .276f, .356f, .544f, .666f, .806f, .860f,
+  .326f, .174f, .584f, .088f, .247f, .435f, .751f, .042f, .141f, .215f, .290f, .368f, .528f, .648f, .848f, .347f, .306f,
+  .553f, .146f, .364f, .433f, .610f, .055f, .198f, .338f, .451f, .445f, .432f, .096f, .836f, .294f, .161f, .499f, .108f,
+  .204f, .381f, .636f, .041f, .474f, .198f, .262f, .324f, .362f, .571f, .795f, .500f, .569f, .307f, .101f, .774f, .000f,
+  .423f, .043f, .465f, .121f, .000f, .984f, .000f, .500f, .524f, .333f, .675f, .560f, .292f, .138f, .429f, .000f, .073f,
+  .550f, .000f, .195f, .377f, .500f, .984f, .000f, .479f, .183f, .704f, .082f, .310f, .567f, .875f, .043f, .141f, .271f,
+  .372f, .511f, .630f, .762f, .896f, .325f, .164f, .602f, .086f, .230f, .414f, .761f, .040f, .131f, .197f, .283f, .352f,
+  .516f, .685f, .855f};
+float _leaf_vals[_num_trees * num_features * 2 * _num_tree_nodes] = {
+  .011f, .029f, .047f, .064f, .075f, .102f, .141f, .172f, .212f, .259f, .308f, .364f, .443f, .497f, .592f, .767f, .069f,
+  .165f, .241f, .278f, .357f, .412f, .463f, .540f, .562f, .623f, .676f, .734f, .797f, .838f, .894f, .944f, .014f, .040f,
+  .061f, .033f, .040f, .160f, .181f, .101f, .123f, .047f, .195f, .282f, .374f, .775f, .248f, .068f, .064f, .155f, .177f,
+  .351f, .409f, .479f, .576f, .451f, .677f, .784f, .817f, .764f, .823f, .860f, .898f, .941f, .154f, .154f, .248f, .248f,
+  .050f, .081f, .177f, .227f, .252f, .309f, .385f, .428f, .441f, .525f, .616f, .689f, .435f, .137f, .208f, .406f, .457f,
+  .483f, .518f, .576f, .669f, .844f, .593f, .706f, .853f, .853f, .895f, .925f, .012f, .029f, .047f, .067f, .111f, .134f,
+  .148f, .178f, .214f, .261f, .311f, .357f, .420f, .476f, .592f, .773f, .057f, .143f, .194f, .262f, .358f, .415f, .465f,
+  .541f, .602f, .649f, .655f, .739f, .808f, .849f, .894f, .944f, .050f, .068f, .089f, .118f, .146f, .187f, .211f, .230f,
+  .263f, .308f, .364f, .443f, .497f, .581f, .690f, .832f, .079f, .171f, .263f, .306f, .356f, .401f, .452f, .486f, .538f,
+  .577f, .629f, .687f, .722f, .766f, .834f, .900f, .046f, .066f, .083f, .064f, .090f, .113f, .143f, .235f, .289f, .416f,
+  .094f, .204f, .454f, .074f, .697f, .836f, .067f, .156f, .200f, .332f, .266f, .411f, .473f, .514f, .627f, .575f, .758f,
+  .676f, .775f, .826f, .864f, .900f, .162f, .162f, .248f, .248f, .079f, .102f, .165f, .241f, .281f, .337f, .385f, .428f,
+  .441f, .525f, .616f, .689f, .397f, .137f, .166f, .307f, .421f, .443f, .525f, .486f, .527f, .585f, .687f, .611f, .767f,
+  .821f, .942f, .916f, .055f, .073f, .090f, .110f, .165f, .188f, .207f, .225f, .261f, .312f, .358f, .420f, .475f, .579f,
+  .693f, .875f, .079f, .164f, .238f, .277f, .325f, .378f, .448f, .487f, .527f, .557f, .610f, .648f, .716f, .769f, .830f,
+  .896f, .038f, .090f, .112f, .131f, .206f, .160f, .224f, .249f, .286f, .334f, .370f, .443f, .497f, .581f, .690f, .832f,
+  .056f, .153f, .221f, .278f, .311f, .365f, .420f, .463f, .524f, .562f, .625f, .699f, .696f, .762f, .829f, .889f, .024f,
+  .093f, .104f, .119f, .104f, .154f, .153f, .216f, .273f, .376f, .202f, .138f, .609f, .690f, .814f, .930f, .027f, .098f,
+  .158f, .252f, .304f, .393f, .706f, .462f, .630f, .554f, .845f, .643f, .852f, .694f, .781f, .858f, .169f, .169f, .248f,
+  .248f, .105f, .124f, .110f, .197f, .308f, .242f, .385f, .428f, .441f, .525f, .616f, .689f, .375f, .137f, .146f, .314f,
+  .412f, .437f, .454f, .520f, .510f, .615f, .692f, .576f, .701f, .701f, .780f, .846f, .039f, .091f, .109f, .125f, .209f,
+  .256f, .251f, .126f, .295f, .350f, .420f, .475f, .568f, .625f, .738f, .875f, .055f, .153f, .236f, .281f, .338f, .390f,
+  .425f, .462f, .522f, .563f, .609f, .687f, .674f, .721f, .776f, .846f, .034f, .078f, .123f, .148f, .201f, .153f, .215f,
+  .253f, .239f, .335f, .382f, .446f, .502f, .581f, .690f, .832f, .063f, .145f, .220f, .284f, .340f, .386f, .424f, .467f,
+  .520f, .550f, .611f, .671f, .718f, .758f, .792f, .854f, .065f, .117f, .138f, .163f, .225f, .371f, .188f, .145f, .457f,
+  .345f, .102f, .276f, .609f, .690f, .814f, .930f, .032f, .133f, .188f, .247f, .268f, .350f, .427f, .495f, .538f, .578f,
+  .641f, .835f, .700f, .759f, .780f, .868f, .187f, .187f, .135f, .170f, .218f, .144f, .261f, .340f, .416f, .335f, .388f,
+  .428f, .441f, .525f, .616f, .689f, .367f, .273f, .143f, .308f, .382f, .439f, .410f, .470f, .524f, .461f, .626f, .528f,
+  .583f, .702f, .673f, .773f, .031f, .068f, .124f, .154f, .217f, .154f, .255f, .302f, .358f, .405f, .435f, .475f, .568f,
+  .625f, .738f, .875f, .061f, .144f, .221f, .261f, .325f, .366f, .448f, .495f, .538f, .590f, .618f, .659f, .686f, .739f,
+  .791f, .858f, .034f, .079f, .149f, .175f, .198f, .231f, .249f, .327f, .353f, .382f, .443f, .489f, .570f, .649f, .740f,
+  .882f, .076f, .148f, .218f, .296f, .357f, .400f, .444f, .472f, .516f, .554f, .597f, .630f, .678f, .722f, .781f, .864f,
+  .021f, .055f, .135f, .053f, .180f, .150f, .370f, .214f, .331f, .530f, .219f, .326f, .609f, .690f, .814f, .930f, .049f,
+  .095f, .149f, .216f, .370f, .294f, .443f, .489f, .526f, .594f, .621f, .747f, .656f, .762f, .780f, .884f, .216f, .248f,
+  .160f, .190f, .197f, .356f, .296f, .341f, .391f, .428f, .441f, .525f, .593f, .668f, .760f, .637f, .388f, .250f, .155f,
+  .334f, .419f, .456f, .497f, .448f, .591f, .542f, .552f, .719f, .656f, .709f, .849f, .897f, .034f, .078f, .151f, .184f,
+  .211f, .253f, .262f, .351f, .358f, .405f, .435f, .475f, .568f, .625f, .738f, .875f, .076f, .148f, .229f, .303f, .341f,
+  .376f, .444f, .480f, .548f, .510f, .594f, .638f, .685f, .742f, .800f, .882f, .028f, .062f, .089f, .114f, .174f, .196f,
+  .241f, .294f, .335f, .371f, .443f, .482f, .511f, .590f, .714f, .832f, .075f, .157f, .223f, .281f, .342f, .386f, .450f,
+  .489f, .542f, .590f, .611f, .653f, .682f, .728f, .783f, .893f, .041f, .076f, .186f, .109f, .175f, .195f, .209f, .227f,
+  .274f, .355f, .196f, .314f, .609f, .690f, .814f, .930f, .049f, .097f, .161f, .221f, .415f, .304f, .454f, .492f, .527f,
+  .581f, .629f, .747f, .685f, .758f, .836f, .914f, .225f, .248f, .187f, .074f, .228f, .365f, .295f, .337f, .391f, .428f,
+  .441f, .525f, .593f, .668f, .760f, .637f, .413f, .277f, .431f, .456f, .115f, .162f, .254f, .334f, .503f, .661f, .515f,
+  .515f, .696f, .751f, .836f, .897f, .023f, .057f, .090f, .116f, .180f, .197f, .239f, .283f, .338f, .365f, .420f, .475f,
+  .568f, .625f, .738f, .875f, .074f, .157f, .227f, .282f, .365f, .410f, .451f, .504f, .577f, .610f, .646f, .679f, .728f,
+  .782f, .855f, .923f, .028f, .062f, .089f, .120f, .165f, .204f, .243f, .304f, .335f, .371f, .443f, .482f, .511f, .590f,
+  .714f, .832f, .073f, .157f, .220f, .287f, .343f, .393f, .451f, .489f, .567f, .596f, .616f, .650f, .711f, .760f, .840f,
+  .917f, .041f, .076f, .186f, .092f, .203f, .116f, .222f, .261f, .330f, .438f, .214f, .316f, .609f, .690f, .814f, .930f,
+  .049f, .104f, .163f, .221f, .414f, .448f, .513f, .561f, .566f, .744f, .614f, .683f, .721f, .761f, .854f, .915f, .228f,
+  .248f, .196f, .096f, .300f, .225f, .295f, .344f, .466f, .385f, .403f, .468f, .441f, .525f, .616f, .689f, .414f, .307f,
+  .445f, .460f, .115f, .162f, .254f, .334f, .459f, .495f, .501f, .705f, .680f, .751f, .836f, .897f, .031f, .065f, .100f,
+  .132f, .201f, .221f, .280f, .333f, .374f, .405f, .435f, .475f, .568f, .625f, .738f, .875f, .073f, .157f, .226f, .288f,
+  .349f, .401f, .450f, .489f, .589f, .621f, .649f, .680f, .718f, .759f, .843f, .923f, .029f, .067f, .107f, .140f, .207f,
+  .227f, .279f, .339f, .369f, .393f, .444f, .494f, .575f, .651f, .740f, .882f, .042f, .093f, .147f, .184f, .220f, .256f,
+  .290f, .323f, .402f, .455f, .495f, .540f, .619f, .687f, .748f, .876f, .021f, .055f, .098f, .053f, .206f, .221f, .389f,
+  .239f, .343f, .438f, .228f, .316f, .609f, .690f, .814f, .930f, .049f, .104f, .160f, .221f, .235f, .426f, .455f, .529f,
+  .623f, .551f, .600f, .677f, .697f, .760f, .836f, .914f, .232f, .201f, .231f, .309f, .117f, .096f, .070f, .044f, .466f,
+  .385f, .403f, .468f, .441f, .525f, .616f, .689f, .418f, .251f, .450f, .394f, .115f, .162f, .254f, .334f, .460f, .488f,
+  .494f, .703f, .680f, .751f, .836f, .897f, .031f, .065f, .100f, .132f, .207f, .229f, .289f, .342f, .435f, .346f, .461f,
+  .482f, .568f, .625f, .738f, .875f, .043f, .093f, .146f, .180f, .241f, .278f, .307f, .330f, .391f, .451f, .472f, .524f,
+  .610f, .651f, .741f, .874f, .029f, .067f, .107f, .140f, .212f, .233f, .269f, .343f, .369f, .393f, .444f, .494f, .575f,
+  .651f, .740f, .882f, .042f, .093f, .151f, .188f, .238f, .271f, .293f, .321f, .408f, .459f, .513f, .553f, .609f, .672f,
+  .777f, .893f, .021f, .055f, .098f, .053f, .210f, .226f, .355f, .247f, .439f, .514f, .637f, .836f, .333f, .420f, .227f,
+  .313f, .019f, .060f, .098f, .133f, .147f, .179f, .237f, .125f, .196f, .407f, .451f, .477f, .572f, .654f, .774f, .903f,
+  .239f, .375f, .204f, .250f, .150f, .150f, .096f, .057f, .426f, .383f, .403f, .468f, .441f, .525f, .616f, .689f, .407f,
+  .407f, .126f, .244f, .134f, .203f, .294f, .406f, .449f, .469f, .573f, .482f, .751f, .751f, .836f, .897f, .031f, .065f,
+  .100f, .132f, .212f, .232f, .281f, .348f, .435f, .346f, .461f, .482f, .568f, .625f, .738f, .875f, .043f, .093f, .152f,
+  .190f, .235f, .262f, .295f, .330f, .354f, .417f, .455f, .492f, .620f, .685f, .768f, .888f, .029f, .067f, .107f, .140f,
+  .167f, .219f, .238f, .298f, .352f, .382f, .443f, .485f, .532f, .596f, .714f, .832f, .056f, .105f, .161f, .195f, .230f,
+  .267f, .289f, .322f, .367f, .414f, .462f, .529f, .579f, .667f, .742f, .875f, .021f, .053f, .094f, .052f, .214f, .235f,
+  .288f, .235f, .451f, .530f, .632f, .826f, .316f, .233f, .466f, .356f, .019f, .060f, .084f, .110f, .192f, .162f, .235f,
+  .287f, .418f, .363f, .447f, .482f, .573f, .631f, .724f, .880f, .243f, .248f, .210f, .074f, .237f, .308f, .378f, .334f,
+  .391f, .428f, .441f, .525f, .593f, .668f, .760f, .637f, .398f, .398f, .235f, .418f, .105f, .166f, .287f, .405f, .458f,
+  .482f, .589f, .488f, .630f, .630f, .751f, .866f, .031f, .065f, .100f, .132f, .218f, .235f, .269f, .344f, .400f, .435f,
+  .478f, .396f, .568f, .625f, .738f, .875f, .056f, .106f, .160f, .190f, .215f, .248f, .292f, .331f, .383f, .415f, .459f,
+  .503f, .594f, .678f, .783f, .898f, .029f, .067f, .108f, .144f, .226f, .241f, .293f, .353f, .275f, .384f, .446f, .502f,
+  .579f, .651f, .740f, .882f, .038f, .077f, .112f, .161f, .202f, .241f, .289f, .323f, .362f, .410f, .462f, .515f, .582f,
+  .658f, .727f, .868f, .021f, .053f, .094f, .052f, .227f, .249f, .316f, .237f, .483f, .630f, .726f, .836f, .583f, .493f,
+  .274f, .426f, .034f, .080f, .109f, .146f, .210f, .181f, .285f, .223f, .385f, .436f, .469f, .544f, .576f, .619f, .714f,
+  .880f, .250f, .248f, .218f, .074f, .241f, .293f, .378f, .334f, .408f, .522f, .409f, .317f, .547f, .397f, .616f, .689f,
+  .410f, .308f, .440f, .469f, .111f, .160f, .250f, .328f, .516f, .674f, .506f, .506f, .685f, .751f, .836f, .897f, .031f,
+  .065f, .100f, .132f, .229f, .267f, .359f, .244f, .442f, .346f, .461f, .482f, .568f, .625f, .738f, .875f, .056f, .106f,
+  .160f, .190f, .219f, .255f, .302f, .340f, .392f, .421f, .463f, .496f, .578f, .642f, .717f, .869f, .029f, .067f, .108f,
+  .144f, .223f, .250f, .318f, .362f, .400f, .444f, .476f, .508f, .579f, .651f, .740f, .882f, .032f, .096f, .155f, .192f,
+  .227f, .255f, .306f, .349f, .381f, .418f, .464f, .519f, .589f, .653f, .721f, .867f, .018f, .049f, .037f, .080f, .201f,
+  .248f, .091f, .152f, .229f, .253f, .323f, .259f, .632f, .826f, .274f, .428f, .028f, .096f, .165f, .230f, .434f, .361f,
+  .449f, .500f, .554f, .596f, .610f, .679f, .678f, .743f, .801f, .903f, .260f, .248f, .208f, .243f, .259f, .302f, .414f,
+  .315f, .408f, .522f, .409f, .317f, .535f, .620f, .357f, .692f, .405f, .266f, .432f, .463f, .111f, .170f, .250f, .328f,
+  .535f, .656f, .525f, .525f, .693f, .751f, .836f, .897f, .031f, .065f, .100f, .132f, .211f, .249f, .320f, .372f, .478f,
+  .396f, .568f, .608f, .647f, .738f, .849f, .902f, .032f, .095f, .153f, .190f, .237f, .269f, .305f, .344f, .390f, .423f,
+  .465f, .514f, .581f, .637f, .718f, .869f, .033f, .072f, .110f, .152f, .214f, .250f, .273f, .316f, .419f, .449f, .476f,
+  .508f, .579f, .651f, .740f, .882f, .039f, .095f, .144f, .185f, .250f, .296f, .323f, .362f, .416f, .467f, .502f, .531f,
+  .589f, .643f, .714f, .867f, .018f, .049f, .036f, .079f, .095f, .246f, .091f, .131f, .233f, .268f, .342f, .294f, .609f,
+  .690f, .814f, .930f, .037f, .093f, .146f, .175f, .270f, .226f, .408f, .339f, .448f, .303f, .472f, .506f, .580f, .640f,
+  .726f, .880f, .273f, .235f, .283f, .319f, .117f, .096f, .070f, .044f, .475f, .609f, .357f, .692f, .414f, .278f, .536f,
+  .462f, .374f, .229f, .139f, .344f, .414f, .441f, .505f, .402f, .496f, .572f, .606f, .526f, .680f, .751f, .836f, .897f,
+  .031f, .072f, .110f, .157f, .239f, .277f, .437f, .352f, .565f, .578f, .631f, .514f, .748f, .578f, .849f, .902f, .039f,
+  .095f, .152f, .202f, .252f, .305f, .345f, .432f, .423f, .467f, .509f, .544f, .592f, .640f, .713f, .869f, .028f, .062f,
+  .089f, .120f, .152f, .173f, .191f, .211f, .252f, .277f, .302f, .324f, .446f, .502f, .592f, .767f, .043f, .090f, .136f,
+  .191f, .256f, .311f, .359f, .390f, .424f, .470f, .492f, .534f, .593f, .655f, .776f, .893f, .012f, .032f, .021f, .058f,
+  .093f, .135f, .059f, .026f, .228f, .270f, .292f, .324f, .609f, .690f, .814f, .930f, .042f, .097f, .141f, .176f, .218f,
+  .342f, .143f, .270f, .446f, .303f, .480f, .516f, .580f, .627f, .774f, .903f, .292f, .238f, .299f, .331f, .117f, .096f,
+  .070f, .044f, .430f, .536f, .612f, .347f, .593f, .668f, .760f, .637f, .386f, .214f, .133f, .342f, .405f, .444f, .507f,
+  .442f, .464f, .479f, .565f, .517f, .680f, .751f, .836f, .897f, .031f, .065f, .100f, .131f, .165f, .188f, .204f, .222f,
+  .275f, .303f, .336f, .383f, .568f, .625f, .738f, .875f, .046f, .101f, .141f, .193f, .256f, .302f, .345f, .451f, .425f,
+  .468f, .509f, .535f, .586f, .649f, .744f, .874f, .028f, .062f, .089f, .120f, .155f, .189f, .214f, .247f, .310f, .338f,
+  .392f, .444f, .497f, .581f, .690f, .832f, .049f, .101f, .142f, .181f, .211f, .247f, .287f, .325f, .377f, .426f, .473f,
+  .530f, .587f, .645f, .745f, .875f, .021f, .055f, .098f, .053f, .280f, .306f, .168f, .226f, .257f, .314f, .351f, .309f,
+  .609f, .690f, .814f, .930f, .048f, .102f, .140f, .185f, .274f, .321f, .143f, .250f, .443f, .359f, .443f, .483f, .542f,
+  .609f, .746f, .894f, .317f, .252f, .324f, .348f, .117f, .096f, .070f, .044f, .594f, .404f, .499f, .531f, .593f, .668f,
+  .760f, .637f, .402f, .260f, .124f, .345f, .382f, .444f, .423f, .448f, .473f, .511f, .563f, .516f, .680f, .751f, .836f,
+  .897f, .031f, .065f, .100f, .132f, .166f, .188f, .207f, .225f, .301f, .322f, .341f, .404f, .475f, .579f, .693f, .875f,
+  .048f, .100f, .142f, .187f, .216f, .244f, .283f, .318f, .378f, .430f, .473f, .525f, .586f, .642f, .744f, .874f, .028f,
+  .062f, .089f, .120f, .155f, .189f, .215f, .249f, .274f, .345f, .363f, .409f, .502f, .581f, .690f, .832f, .053f, .095f,
+  .132f, .175f, .211f, .243f, .288f, .326f, .399f, .434f, .474f, .527f, .579f, .637f, .745f, .875f, .021f, .053f, .092f,
+  .052f, .054f, .108f, .180f, .116f, .204f, .271f, .321f, .362f, .609f, .690f, .814f, .930f, .054f, .105f, .177f, .148f,
+  .216f, .260f, .394f, .301f, .226f, .381f, .443f, .484f, .588f, .680f, .774f, .903f, .339f, .339f, .248f, .248f, .222f,
+  .288f, .111f, .057f, .352f, .366f, .422f, .505f, .593f, .668f, .760f, .637f, .387f, .016f, .160f, .380f, .113f, .221f,
+  .346f, .410f, .442f, .482f, .474f, .496f, .563f, .508f, .700f, .866f, .031f, .065f, .100f, .131f, .148f, .177f, .202f,
+  .218f, .338f, .280f, .357f, .420f, .568f, .625f, .738f, .875f, .053f, .098f, .135f, .175f, .212f, .242f, .277f, .307f,
+  .384f, .434f, .476f, .536f, .594f, .644f, .744f, .874f, .029f, .067f, .107f, .140f, .184f, .215f, .249f, .274f, .335f,
+  .376f, .406f, .479f, .579f, .651f, .740f, .882f, .056f, .085f, .129f, .177f, .209f, .238f, .289f, .323f, .361f, .413f,
+  .471f, .539f, .601f, .677f, .776f, .893f, .021f, .055f, .098f, .053f, .138f, .211f, .281f, .183f, .345f, .232f, .387f,
+  .290f, .609f, .690f, .814f, .930f, .057f, .083f, .167f, .124f, .232f, .182f, .401f, .293f, .226f, .358f, .445f, .497f,
+  .581f, .654f, .774f, .903f, .353f, .353f, .248f, .248f, .112f, .240f, .290f, .096f, .354f, .374f, .393f, .433f, .595f,
+  .468f, .648f, .692f, .378f, .016f, .106f, .339f, .119f, .191f, .327f, .397f, .446f, .477f, .512f, .549f, .680f, .751f,
+  .836f, .897f, .031f, .065f, .100f, .132f, .172f, .211f, .338f, .261f, .349f, .375f, .402f, .437f, .568f, .625f, .738f,
+  .875f, .057f, .086f, .129f, .173f, .199f, .232f, .280f, .306f, .366f, .419f, .471f, .531f, .592f, .652f, .744f, .874f,
+  .029f, .067f, .107f, .140f, .184f, .215f, .249f, .286f, .371f, .396f, .420f, .443f, .477f, .533f, .682f, .832f, .047f,
+  .094f, .134f, .165f, .205f, .237f, .277f, .306f, .366f, .411f, .466f, .519f, .558f, .619f, .727f, .868f, .021f, .055f,
+  .098f, .053f, .115f, .175f, .238f, .195f, .305f, .390f, .332f, .232f, .424f, .243f, .626f, .826f, .030f, .071f, .108f,
+  .138f, .195f, .114f, .295f, .240f, .320f, .362f, .424f, .489f, .542f, .613f, .730f, .880f, .385f, .385f, .248f, .375f,
+  .172f, .262f, .393f, .347f, .364f, .416f, .412f, .433f, .448f, .486f, .648f, .533f, .354f, .016f, .183f, .308f, .111f,
+  .177f, .269f, .346f, .414f, .440f, .454f, .520f, .507f, .544f, .700f, .866f, .031f, .065f, .100f, .132f, .172f, .210f,
+  .232f, .261f, .323f, .361f, .390f, .418f, .444f, .468f, .548f, .773f, .030f, .072f, .110f, .153f, .205f, .246f, .283f,
+  .312f, .355f, .399f, .461f, .532f, .594f, .652f, .744f, .874f, .029f, .067f, .108f, .147f, .206f, .237f, .286f, .334f,
+  .358f, .424f, .461f, .494f, .522f, .565f, .791f, .882f, .039f, .091f, .132f, .168f, .214f, .244f, .278f, .311f, .373f,
+  .413f, .465f, .521f, .596f, .677f, .776f, .893f, .021f, .055f, .098f, .053f, .166f, .219f, .411f, .273f, .379f, .461f,
+  .256f, .206f, .501f, .264f, .587f, .816f, .031f, .066f, .104f, .139f, .154f, .187f, .203f, .241f, .318f, .360f, .414f,
+  .493f, .621f, .692f, .775f, .903f, .429f, .223f, .430f, .462f, .480f, .504f, .532f, .555f, .170f, .266f, .111f, .057f,
+  .327f, .407f, .441f, .475f, .307f, .307f, .126f, .257f, .091f, .171f, .253f, .332f, .390f, .420f, .457f, .488f, .573f,
+  .503f, .700f, .866f, .031f, .065f, .100f, .132f, .176f, .215f, .261f, .311f, .386f, .439f, .466f, .489f, .562f, .514f,
+  .612f, .773f, .033f, .073f, .102f, .146f, .177f, .216f, .255f, .295f, .323f, .388f, .450f, .502f, .580f, .644f, .744f,
+  .874f, .029f, .067f, .108f, .147f, .210f, .259f, .308f, .364f, .503f, .543f, .584f, .646f, .723f, .578f, .791f, .882f,
+  .028f, .068f, .122f, .163f, .194f, .231f, .273f, .310f, .357f, .403f, .464f, .533f, .596f, .677f, .776f, .893f, .048f,
+  .094f, .177f, .218f, .307f, .432f, .273f, .229f, .500f, .253f, .603f, .513f, .754f, .673f, .825f, .930f, .018f, .062f,
+  .102f, .129f, .142f, .173f, .188f, .226f, .391f, .313f, .471f, .402f, .621f, .692f, .775f, .903f, .489f, .443f, .207f,
+  .494f, .541f, .577f, .648f, .720f, .175f, .237f, .111f, .057f, .287f, .335f, .409f, .374f, .264f, .187f, .285f, .318f,
+  .156f, .106f, .341f, .251f, .380f, .391f, .432f, .475f, .584f, .513f, .700f, .866f, .031f, .068f, .108f, .157f, .212f,
+  .261f, .312f, .371f, .483f, .517f, .571f, .611f, .665f, .738f, .849f, .902f, .028f, .068f, .120f, .154f, .188f, .219f,
+  .259f, .305f, .338f, .387f, .454f, .520f, .609f, .691f, .768f, .888f};
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/norm2.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/norm2.hpp
new file mode 100644
index 00000000..027e522d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/norm2.hpp
@@ -0,0 +1,73 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __NORM2_HPP__
+#define __NORM2_HPP__
+
+template<bool B, class T = void> struct iftype {};
+template<class T> struct iftype<true, T> { typedef T type; }; // enable_if
+
+template<class T, T v> struct int_const { // integral_constant
+    static const T value = v;
+    typedef T value_type;
+    typedef int_const type;
+    operator value_type() const { return value; }
+    value_type operator()() const { return value; }
+};
+
+typedef int_const<bool,true> ttype; // true_type
+typedef int_const<bool,false> ftype; // false_type
+
+template <class T, class U> struct same_as : ftype {};
+template <class T> struct same_as<T, T> : ttype {};   // is_same
+
+
+template <typename _Tp> struct is_norm2_type :
+    int_const<bool, !same_as<_Tp,   char>::value
+                 && !same_as<_Tp,  uchar>::value
+                 && !same_as<_Tp, ushort>::value
+                 && !same_as<_Tp,   uint>::value>{};
+
+template <typename _Tp, int cn> static inline typename iftype< is_norm2_type<_Tp>::value, _Tp >::
+    type norm2(cv::Vec<_Tp, cn> a, cv::Vec<_Tp, cn> b) { return (a - b).dot(a - b); }
+
+template <typename _Tp> static inline typename iftype< is_norm2_type<_Tp>::value, _Tp >::
+    type norm2(const _Tp &a, const _Tp &b) { return (a - b)*(a - b); }
+
+#endif /* __NORM2_HPP__ */
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/oilpainting.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/oilpainting.cpp
new file mode 100644
index 00000000..21e62414
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/oilpainting.cpp
@@ -0,0 +1,172 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "opencv2/xphoto.hpp"
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+
+template<class T>
+class Vec3fTo {
+public :
+    cv::Vec3f a;
+    Vec3fTo(cv::Vec3f x) {
+        a = x;
+    };
+    T extract();
+    cv::Vec3f make(int);
+};
+
+template<>
+uchar Vec3fTo<uchar>::extract()
+{
+    return static_cast<uchar>(a[0]);
+}
+
+template<>
+cv::Vec3b Vec3fTo<cv::Vec3b>::extract()
+{
+    return a;
+}
+
+template<>
+cv::Vec3f Vec3fTo<uchar>::make(int x)
+{
+    return cv::Vec3f((a*x)/x);
+}
+
+template<>
+cv::Vec3f Vec3fTo<cv::Vec3b>::make(int x)
+{
+    return cv::Vec3f(static_cast<float>(static_cast<int>(a[0]*x)/x),
+        static_cast<float>(static_cast<int>(a[1] * x) / x),
+        static_cast<float>(static_cast<int>(a[2] * x) / x));
+}
+
+namespace cv
+{
+namespace xphoto
+{
+template<typename Type>
+class ParallelOilPainting : public ParallelLoopBody
+{
+private:
+    Mat & imgSrc;
+    Mat &dst;
+    Mat &imgLuminance;
+    int halfsize;
+    int dynRatio;
+
+public:
+    ParallelOilPainting<Type>(Mat& img, Mat &d, Mat &iLuminance, int r,int k) :
+        imgSrc(img),
+        dst(d),
+        imgLuminance(iLuminance),
+        halfsize(r),
+        dynRatio(k)
+    {}
+    virtual void operator()(const Range& range) const CV_OVERRIDE
+    {
+        std::vector<int> histogram(256);
+        std::vector<Vec3f> meanBGR(256);
+
+        for (int y = range.start; y < range.end; y++)
+        {
+            Type *vDst = dst.ptr<Type>(y);
+            for (int x = 0; x < imgSrc.cols; x++, vDst++)
+            {
+                if (x == 0)
+                {
+                    histogram.assign(256, 0);
+                    meanBGR.assign(256, Vec3f(0,0,0));
+                    for (int yy = -halfsize; yy <= halfsize; yy++)
+                    {
+                        if (y + yy >= 0 && y + yy < imgSrc.rows)
+                        {
+                            Type *vPtr = imgSrc.ptr<Type>(y + yy) + x - 0;
+                            uchar *uc = imgLuminance.ptr(y + yy) + x - 0;
+                            for (int xx = 0; xx <= halfsize; xx++, vPtr++, uc++)
+                            {
+                                if (x + xx >= 0 && x + xx < imgSrc.cols)
+                                {
+                                    histogram[*uc]++;
+                                    meanBGR[*uc] += Vec3fTo<Type>(*vPtr).make(dynRatio);
+                                }
+                            }
+                        }
+                    }
+
+                }
+                else
+                {
+                    for (int yy = -halfsize; yy <= halfsize; yy++)
+                    {
+                        if (y + yy >= 0 && y + yy < imgSrc.rows)
+                        {
+                            Type *vPtr = imgSrc.ptr<Type>(y + yy) + x - halfsize - 1;
+                            uchar *uc = imgLuminance.ptr(y + yy) + x - halfsize - 1;
+                            int xx = -halfsize - 1;
+                            if (x + xx >= 0 && x + xx < imgSrc.cols)
+                            {
+                                histogram[*uc]--;
+                                meanBGR[*uc] -= Vec3fTo<Type>(*vPtr).make(dynRatio);
+                            }
+                            vPtr = imgSrc.ptr<Type>(y + yy) + x + halfsize;
+                            uc = imgLuminance.ptr(y + yy) + x + halfsize;
+                            xx = halfsize;
+                            if (x + xx >= 0 && x + xx < imgSrc.cols)
+                            {
+                                histogram[*uc]++;
+                                meanBGR[*uc] += Vec3fTo<Type>(*vPtr).make(dynRatio);
+                            }
+                        }
+                    }
+                }
+                auto pos = distance(histogram.begin(), std::max_element(histogram.begin(), histogram.end()));
+                *vDst = Vec3fTo<Type>(meanBGR[pos] / histogram[pos]).extract();
+            }
+        }
+    }
+};
+
+void oilPainting(InputArray src, OutputArray dst, int size, int dynValue)
+{
+    oilPainting(src, dst, size, dynValue, COLOR_BGR2GRAY);
+}
+
+void oilPainting(InputArray _src, OutputArray _dst, int size, int dynValue,int code)
+{
+    CV_CheckType(_src.type(), _src.type() == CV_8UC1 || _src.type() == CV_8UC3, "only 1 or 3 channels (CV_8UC)");
+    CV_Assert(_src.kind() == _InputArray::MAT);
+    CV_Assert(size >= 1);
+    CV_CheckGT(dynValue , 0,"dynValue must be  0");
+    CV_CheckLT(dynValue, 128, "dynValue must less than 128 ");
+    Mat src = _src.getMat();
+    Mat lum,dst(_src.size(),_src.type());
+    if (src.type() == CV_8UC3)
+    {
+        cvtColor(_src, lum, code);
+        if (lum.channels() > 1)
+        {
+            extractChannel(lum, lum, 0);
+        }
+    }
+    else
+        lum = src.clone();
+    double dratio = 1 / double(dynValue);
+    lum.forEach<uchar>([=](uchar &pixel, const int * /*position*/) { pixel = saturate_cast<uchar>(cvRound(pixel * dratio)); });
+    if (_src.type() == CV_8UC1)
+    {
+        ParallelOilPainting<uchar> oilAlgo(src, dst, lum, size, dynValue);
+        parallel_for_(Range(0, src.rows), oilAlgo);
+    }
+    else
+    {
+        ParallelOilPainting<Vec3b> oilAlgo(src, dst, lum, size, dynValue);
+        parallel_for_(Range(0, src.rows), oilAlgo);
+    }
+    dst.copyTo(_dst);
+    dst = (dst  / dynValue) * dynValue;
+}
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/photomontage.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/photomontage.hpp
new file mode 100644
index 00000000..bdafb360
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/photomontage.hpp
@@ -0,0 +1,246 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __PHOTOMONTAGE_HPP__
+#define __PHOTOMONTAGE_HPP__
+
+#include <vector>
+#include <stack>
+#include <limits>
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+#include <fstream>
+#include <time.h>
+#include <functional>
+
+#include "norm2.hpp"
+#include "blending.hpp"
+
+namespace gcoptimization
+{
+
+#include "gcgraph.hpp"
+
+
+typedef float TWeight;
+typedef  int  labelTp;
+
+
+#define GCInfinity 10*1000*1000
+#define eps 0.02
+
+
+template <typename Tp> static int min_idx(std::vector <Tp> vec)
+{
+    return int( std::min_element(vec.begin(), vec.end()) - vec.begin() );
+}
+
+////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
+
+template <typename Tp> class Photomontage
+{
+private:
+    const std::vector <std::vector <Tp> > &pointSeq;   // points for stitching
+    const std::vector <std::vector <uchar> > &maskSeq; // corresponding masks
+
+    const std::vector <std::vector <int> > &linkIdx;   // vector of neighbors for pointSeq
+
+    std::vector <std::vector <labelTp> > labelings;    // vector of labelings
+    std::vector <TWeight>  distances;                  // vector of max-flow costs for different labeling
+
+    std::vector <labelTp> &labelSeq;                   // current best labeling
+
+    TWeight singleExpansion(const int alpha);          // single neighbor computing
+
+    class ParallelExpansion : public cv::ParallelLoopBody
+    {
+    public:
+        Photomontage <Tp> *main;
+
+        ParallelExpansion(Photomontage <Tp> *_main) : main(_main){}
+        ~ParallelExpansion(){};
+
+        void operator () (const cv::Range &range) const CV_OVERRIDE
+        {
+            for (int i = range.start; i <= range.end - 1; ++i)
+                main->distances[i] = main->singleExpansion(i);
+        }
+    } parallelExpansion;
+
+    void operator =(const Photomontage <Tp>&) const {};
+
+protected:
+    virtual TWeight dist(const Tp &l1p1, const Tp &l1p2, const Tp &l2p1, const Tp &l2p2);
+    virtual void setWeights(GCGraph <TWeight> &graph,
+        const int idx1, const int idx2, const int l1, const int l2, const int lx);
+
+public:
+    void gradientDescent(); // gradient descent in alpha-expansion topology
+
+    Photomontage(const std::vector <std::vector <Tp> > &pointSeq,
+                 const std::vector <std::vector <uchar> > &maskSeq,
+                 const std::vector <std::vector <int> > &linkIdx,
+                       std::vector <labelTp> &labelSeq);
+    virtual ~Photomontage(){};
+};
+
+template <typename Tp> inline TWeight Photomontage <Tp>::
+dist(const Tp &l1p1, const Tp &l1p2, const Tp &l2p1, const Tp &l2p2)
+{
+    return norm2(l1p1, l2p1) + norm2(l1p2, l2p2);
+}
+
+template <typename Tp> void Photomontage <Tp>::
+setWeights(GCGraph <TWeight> &graph, const int idx1, const int idx2,
+    const int l1, const int l2, const int lx)
+{
+    if ((size_t)idx1 >= pointSeq.size() || (size_t)idx2 >= pointSeq.size()
+        || (size_t)l1 >= pointSeq[idx1].size() || (size_t)l1 >= pointSeq[idx2].size()
+        || (size_t)l2 >= pointSeq[idx1].size() || (size_t)l2 >= pointSeq[idx2].size()
+        || (size_t)lx >= pointSeq[idx1].size() || (size_t)lx >= pointSeq[idx2].size())
+        return;
+
+    if (l1 == l2)
+    {
+        /** Link from A to B **/
+        TWeight weightAB = dist( pointSeq[idx1][l1], pointSeq[idx2][l1],
+                                 pointSeq[idx1][lx], pointSeq[idx2][lx] );
+        graph.addEdges( idx1, idx2, weightAB, weightAB );
+    }
+    else
+    {
+        int X = graph.addVtx();
+
+        /** Link from X to sink **/
+        TWeight weightXS = dist( pointSeq[idx1][l1], pointSeq[idx2][l1],
+                                 pointSeq[idx1][l2], pointSeq[idx2][l2] );
+        graph.addTermWeights( X, 0, weightXS );
+
+        /** Link from A to X **/
+        TWeight weightAX = dist( pointSeq[idx1][l1], pointSeq[idx2][l1],
+                                 pointSeq[idx1][lx], pointSeq[idx2][lx] );
+        graph.addEdges( idx1, X, weightAX, weightAX );
+
+        /** Link from X to B **/
+        TWeight weightXB = dist( pointSeq[idx1][lx], pointSeq[idx1][lx],
+                                 pointSeq[idx1][l2], pointSeq[idx1][l2] );
+        graph.addEdges( X, idx2, weightXB, weightXB );
+    }
+}
+
+template <typename Tp> TWeight Photomontage <Tp>::
+singleExpansion(const int alpha)
+{
+    GCGraph <TWeight> graph( 3*int(pointSeq.size()), 4*int(pointSeq.size()) );
+
+    /** Terminal links **/
+    for (size_t i = 0; i < maskSeq.size(); ++i)
+        graph.addTermWeights( graph.addVtx(),
+            maskSeq[i][alpha] ? TWeight(0) : TWeight(GCInfinity), 0 );
+
+    /** Neighbor links **/
+    for (size_t i = 0; i < pointSeq.size(); ++i)
+        for (size_t j = 0; j < linkIdx[i].size(); ++j)
+            if ( linkIdx[i][j] != -1)
+                setWeights( graph, int(i), linkIdx[i][j],
+                    labelSeq[i], labelSeq[linkIdx[i][j]], alpha );
+
+    /** Max-flow computation **/
+    TWeight result = graph.maxFlow();
+
+    /** Writing results **/
+    for (size_t i = 0; i < pointSeq.size(); ++i)
+        labelings[i][alpha] = graph.inSourceSegment(int(i)) ? labelSeq[i] : alpha;
+
+    return result;
+}
+
+template <typename Tp> void Photomontage <Tp>::
+gradientDescent()
+{
+    TWeight optValue = std::numeric_limits<TWeight>::max();
+
+    for (int num = -1; /**/; num = -1)
+    {
+        int range = int( pointSeq[0].size() );
+        parallel_for_( cv::Range(0, range), parallelExpansion );
+
+        int minIndex = min_idx(distances);
+        TWeight minValue = distances[minIndex];
+
+        if (minValue < (1.00 - eps)*optValue)
+            optValue = distances[num = minIndex];
+
+        if (num == -1)
+            break;
+
+        for (size_t i = 0; i < labelSeq.size(); ++i)
+            labelSeq[i] = labelings[i][num];
+    }
+}
+
+template <typename Tp> Photomontage <Tp>::
+Photomontage( const std::vector <std::vector <Tp> > &_pointSeq,
+            const std::vector <std::vector <uchar> > &_maskSeq,
+              const std::vector <std::vector <int> > &_linkIdx,
+                              std::vector <labelTp> &_labelSeq )
+  :
+    pointSeq(_pointSeq), maskSeq(_maskSeq), linkIdx(_linkIdx),
+    distances(pointSeq[0].size()), labelSeq(_labelSeq), parallelExpansion(this)
+{
+    size_t lsize = pointSeq[0].size();
+    labelings.assign( pointSeq.size(),
+      std::vector <labelTp>( lsize ) );
+}
+
+}
+
+template <typename Tp> static inline
+void photomontage( const std::vector <std::vector <Tp> > &pointSeq,
+                 const std::vector <std::vector <uchar> > &maskSeq,
+                   const std::vector <std::vector <int> > &linkIdx,
+                   std::vector <gcoptimization::labelTp> &labelSeq )
+{
+    gcoptimization::Photomontage <Tp>(pointSeq, maskSeq,
+        linkIdx, labelSeq).gradientDescent();
+}
+
+#endif /* __PHOTOMONTAGE_HPP__ */
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/simple_color_balance.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/simple_color_balance.cpp
new file mode 100644
index 00000000..59ba71f7
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/simple_color_balance.cpp
@@ -0,0 +1,193 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/xphoto.hpp"
+
+namespace cv
+{
+namespace xphoto
+{
+
+template <typename T>
+void balanceWhiteSimple(std::vector<Mat_<T> > &src, Mat &dst, const float inputMin, const float inputMax,
+                        const float outputMin, const float outputMax, const float p)
+{
+    /********************* Simple white balance *********************/
+    const float s1 = p; // low quantile
+    const float s2 = p; // high quantile
+
+    int nElements = src[0].depth() == CV_8U ? 256 : 4096;
+
+    float minValue0 = inputMin;
+    float maxValue0 = inputMax;
+
+    // deal with cv::calcHist (exclusive upper bound)
+    if (src[0].depth() == CV_32F || src[0].depth() == CV_64F) // floating
+    {
+        maxValue0 += MIN((inputMax - inputMin) / (nElements - 1), 1);
+        if (inputMax == inputMin) // single value
+            maxValue0 += 1;
+    }
+    else // integer
+    {
+        maxValue0 += 1;
+    }
+
+    float interval = (maxValue0 - minValue0) / float(nElements);
+
+    for (size_t i = 0; i < src.size(); ++i)
+    {
+        float minValue = minValue0;
+        float maxValue = maxValue0;
+
+        Mat img = src[i].reshape(1);
+        Mat hist;
+        int channels[] = {0};
+        int histSize[] = {nElements};
+        float inputRange[] = {minValue, maxValue};
+        const float *ranges[] = {inputRange};
+
+        calcHist(&img, 1, channels, Mat(), hist, 1, histSize, ranges, true, false);
+
+        int total = int(src[i].total());
+
+        int p1 = 0, p2 = nElements - 1;
+        int n1 = 0, n2 = total;
+
+        // searching for s1 and s2
+        while (n1 + hist.at<float>(p1) < s1 * total / 100.0f)
+        {
+            n1 += saturate_cast<int>(hist.at<float>(p1++));
+            minValue += interval;
+        }
+
+        while (n2 - hist.at<float>(p2) > (100.0f - s2) * total / 100.0f)
+        {
+            n2 -= saturate_cast<int>(hist.at<float>(p2--));
+            maxValue -= interval;
+        }
+
+        src[i] = (outputMax - outputMin) * (src[i] - minValue) / (maxValue - minValue) + outputMin;
+    }
+    /****************************************************************/
+
+    dst.create(/**/ src[0].size(), CV_MAKETYPE(src[0].depth(), int(src.size())) /**/);
+    cv::merge(src, dst);
+}
+
+class SimpleWBImpl CV_FINAL : public SimpleWB
+{
+  private:
+    float inputMin, inputMax, outputMin, outputMax, p;
+
+  public:
+    SimpleWBImpl()
+    {
+        inputMin = 0.0f;
+        inputMax = 255.0f;
+        outputMin = 0.0f;
+        outputMax = 255.0f;
+        p = 2.0f;
+    }
+
+    float getInputMin() const CV_OVERRIDE { return inputMin; }
+    void setInputMin(float val) CV_OVERRIDE { inputMin = val; }
+
+    float getInputMax() const CV_OVERRIDE { return inputMax; }
+    void setInputMax(float val) CV_OVERRIDE { inputMax = val; }
+
+    float getOutputMin() const CV_OVERRIDE { return outputMin; }
+    void setOutputMin(float val) CV_OVERRIDE { outputMin = val; }
+
+    float getOutputMax() const CV_OVERRIDE { return outputMax; }
+    void setOutputMax(float val) CV_OVERRIDE { outputMax = val; }
+
+    float getP() const CV_OVERRIDE { return p; }
+    void setP(float val) CV_OVERRIDE { p = val; }
+
+    void balanceWhite(InputArray _src, OutputArray _dst) CV_OVERRIDE
+    {
+        CV_Assert(!_src.empty());
+        CV_Assert(_src.depth() == CV_8U || _src.depth() == CV_16S || _src.depth() == CV_32S || _src.depth() == CV_32F);
+        Mat src = _src.getMat();
+        Mat &dst = _dst.getMatRef();
+
+        switch (src.depth())
+        {
+        case CV_8U:
+        {
+            std::vector<Mat_<uchar> > mv;
+            split(src, mv);
+            balanceWhiteSimple(mv, dst, inputMin, inputMax, outputMin, outputMax, p);
+            break;
+        }
+        case CV_16S:
+        {
+            std::vector<Mat_<short> > mv;
+            split(src, mv);
+            balanceWhiteSimple(mv, dst, inputMin, inputMax, outputMin, outputMax, p);
+            break;
+        }
+        case CV_32S:
+        {
+            std::vector<Mat_<int> > mv;
+            split(src, mv);
+            balanceWhiteSimple(mv, dst, inputMin, inputMax, outputMin, outputMax, p);
+            break;
+        }
+        case CV_32F:
+        {
+            std::vector<Mat_<float> > mv;
+            split(src, mv);
+            balanceWhiteSimple(mv, dst, inputMin, inputMax, outputMin, outputMax, p);
+            break;
+        }
+        }
+    }
+};
+
+Ptr<SimpleWB> createSimpleWB() { return makePtr<SimpleWBImpl>(); }
+}
+}
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/tonemap.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/tonemap.cpp
new file mode 100644
index 00000000..038017ea
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/tonemap.cpp
@@ -0,0 +1,129 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/utils/trace.hpp>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/xphoto.hpp"
+
+namespace cv { namespace xphoto {
+
+#ifdef OPENCV_ENABLE_NONFREE
+static inline
+void mapLuminance(Mat src, Mat dst, Mat lum, Mat new_lum, float saturation)
+{
+    std::vector<Mat> channels(3);
+    split(src, channels);
+    for(int i = 0; i < 3; i++) {
+        channels[i] = channels[i].mul(1.0f / lum);
+        pow(channels[i], saturation, channels[i]);
+        channels[i] = channels[i].mul(new_lum);
+    }
+    merge(channels, dst);
+}
+
+static inline
+void log_(const Mat& src, Mat& dst)
+{
+    max(src, Scalar::all(1e-4), dst);
+    log(dst, dst);
+}
+
+class TonemapDurandImpl CV_FINAL : public TonemapDurand
+{
+public:
+    TonemapDurandImpl(float _gamma, float _contrast, float _saturation, float _sigma_color, float _sigma_space) :
+        name("TonemapDurand"),
+        gamma(_gamma),
+        contrast(_contrast),
+        saturation(_saturation),
+        sigma_color(_sigma_color),
+        sigma_space(_sigma_space)
+    {
+    }
+
+    void process(InputArray _src, OutputArray _dst) CV_OVERRIDE
+    {
+        CV_TRACE_FUNCTION();
+
+        Mat src = _src.getMat();
+        CV_Assert(!src.empty());
+        _dst.create(src.size(), CV_32FC3);
+        Mat img = _dst.getMat();
+        Ptr<Tonemap> linear = createTonemap(1.0f);
+        linear->process(src, img);
+
+        Mat gray_img;
+        cvtColor(img, gray_img, COLOR_RGB2GRAY);
+        Mat log_img;
+        log_(gray_img, log_img);
+        Mat map_img;
+        bilateralFilter(log_img, map_img, -1, sigma_color, sigma_space);
+
+        double min, max;
+        minMaxLoc(map_img, &min, &max);
+        float scale = contrast / static_cast<float>(max - min);
+        exp(map_img * (scale - 1.0f) + log_img, map_img);
+        log_img.release();
+
+        mapLuminance(img, img, gray_img, map_img, saturation);
+        pow(img, 1.0f / gamma, img);
+    }
+
+    float getGamma() const CV_OVERRIDE { return gamma; }
+    void setGamma(float val) CV_OVERRIDE { gamma = val; }
+
+    float getSaturation() const CV_OVERRIDE { return saturation; }
+    void setSaturation(float val) CV_OVERRIDE { saturation = val; }
+
+    float getContrast() const CV_OVERRIDE { return contrast; }
+    void setContrast(float val) CV_OVERRIDE { contrast = val; }
+
+    float getSigmaColor() const CV_OVERRIDE { return sigma_color; }
+    void setSigmaColor(float val) CV_OVERRIDE { sigma_color = val; }
+
+    float getSigmaSpace() const CV_OVERRIDE { return sigma_space; }
+    void setSigmaSpace(float val) CV_OVERRIDE { sigma_space = val; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name
+           << "gamma" << gamma
+           << "contrast" << contrast
+           << "sigma_color" << sigma_color
+           << "sigma_space" << sigma_space
+           << "saturation" << saturation;
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert(n.isString() && String(n) == name);
+        gamma = fn["gamma"];
+        contrast = fn["contrast"];
+        sigma_color = fn["sigma_color"];
+        sigma_space = fn["sigma_space"];
+        saturation = fn["saturation"];
+    }
+
+protected:
+    String name;
+    float gamma, contrast, saturation, sigma_color, sigma_space;
+};
+
+Ptr<TonemapDurand> createTonemapDurand(float gamma, float contrast, float saturation, float sigma_color, float sigma_space)
+{
+    return makePtr<TonemapDurandImpl>(gamma, contrast, saturation, sigma_color, sigma_space);
+}
+#else
+Ptr<TonemapDurand> createTonemapDurand(float /*gamma*/, float /*contrast*/, float /*saturation*/, float /*sigma_color*/, float /*sigma_space*/)
+{
+    CV_Error(Error::StsNotImplemented,
+        "This algorithm is patented and is excluded in this configuration; "
+        "Set OPENCV_ENABLE_NONFREE CMake option and rebuild the library");
+}
+#endif  // OPENCV_ENABLE_NONFREE
+
+}}  // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/whs.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/whs.hpp
new file mode 100644
index 00000000..b7ef46ae
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/src/whs.hpp
@@ -0,0 +1,148 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __WHS_HPP__
+#define __WHS_HPP__
+
+static inline int hl(int x)
+{
+    int res = 0;
+    while (x)
+    {
+        res += x&1;
+        x >>= 1;
+    }
+    return res;
+}
+
+static inline int rp2(int x)
+{
+    int res = 1;
+    while (res < x)
+        res <<= 1;
+    return res;
+}
+
+template <typename ForwardIterator>
+static void generate_snake(ForwardIterator snake, const int n)
+{
+    cv::Point previous;
+    if (n > 0)
+    {
+        previous = cv::Point(0, 0);
+        *snake = previous;
+    }
+
+    for (int k = 1, num = 1; num <= n; ++k)
+    {
+        const cv::Point2i dv[] = { cv::Point2i( !(k&1),   (k&1) ),
+                                   cv::Point2i( -(k&1), -!(k&1) ) };
+
+        *snake = previous = previous - dv[1];
+        ++num;
+
+        for (int i = 0; i < 2; ++i)
+            for (int j = 0; j < k && num < n; ++j)
+            {
+                *snake = previous = previous + dv[i];
+                ++num;
+            }
+    }
+}
+
+static void nextProjection(std::vector <cv::Mat> &projections, const cv::Point &A,
+                           const cv::Point &B, const int psize)
+{
+    int xsign = (A.x != B.x)*(hl(A.x&B.x) + (B.x > A.x))&1;
+    int ysign = (A.y != B.y)*(hl(A.y&B.y) + (B.y > A.y))&1;
+    bool plusToMinusUpdate = xsign || ysign;
+
+    int dx = (A.x != B.x) << ( hl(psize - 1) - hl(A.x ^ B.x) );
+    int dy = (A.y != B.y) << ( hl(psize - 1) - hl(A.y ^ B.y) );
+
+    cv::Mat proj = projections[projections.size() - 1],
+           nproj = -proj.clone();
+
+    for (int i = dy; i < nproj.rows; ++i)
+    {
+        float *vxNext = nproj.ptr<float>(i - dy);
+        float  *vNext = nproj.ptr<float>(i);
+
+        float *vxCurrent = proj.ptr<float>(i - dy);
+
+        if (plusToMinusUpdate)
+            for (int j = dx; j < nproj.cols; ++j)
+                vNext[j] += vxCurrent[j - dx] - vxNext[j - dx];
+        else
+            for (int j = dx; j < nproj.cols; ++j)
+                vNext[j] -= vxCurrent[j - dx] - vxNext[j - dx];
+    }
+    projections.push_back(nproj);
+}
+
+static void rgb2whs(const cv::Mat &src, cv::Mat &dst, const int nProjections, const int psize)
+{
+    CV_Assert(nProjections <= psize*psize && src.type() == CV_32FC1);
+
+    const int npsize = rp2(psize);
+    std::vector <cv::Mat> projections;
+
+    cv::Mat img, proj;
+    cv::copyMakeBorder(src, img, npsize, npsize, npsize, npsize,
+        cv::BORDER_CONSTANT, 0);
+    cv::boxFilter(img, proj, CV_32F, cv::Size(npsize, npsize),
+        cv::Point(-1, -1), true, cv::BORDER_REFLECT);
+    projections.push_back(proj);
+
+    std::vector <cv::Point2i> snake_idx;
+    generate_snake(std::back_inserter(snake_idx), nProjections);
+
+    for (int i = 1; i < nProjections; ++i)
+        nextProjection(projections, snake_idx[i - 1],
+            snake_idx[i], npsize);
+
+    int pad = 0;
+
+    cv::merge(projections, img);
+    img(cv::Rect(npsize + pad, npsize + pad, src.cols - pad,
+        src.rows - pad)).copyTo(dst);
+}
+
+
+#endif /* __WHS_HPP__ */
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/dct_image_denoising.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/dct_image_denoising.cpp
new file mode 100644
index 00000000..bc2f7782
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/dct_image_denoising.cpp
@@ -0,0 +1,42 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+    TEST(xphoto_dctimagedenoising, regression)
+    {
+        cv::String subfolder = "cv/xphoto/";
+        cv::String dir = cvtest::TS::ptr()->get_data_path() + subfolder + "dct_image_denoising/";
+        int nTests = 1;
+
+        double thresholds[] = {0.2};
+
+        int psize[] = {8};
+        double sigma[] = {9.0};
+
+        for (int i = 0; i < nTests; ++i)
+        {
+            cv::String srcName = dir + cv::format( "sources/%02d.png", i + 1);
+            cv::Mat src = cv::imread( srcName, 1 );
+            ASSERT_TRUE(!src.empty());
+
+            cv::String previousResultName = dir + cv::format( "results/%02d.png", i + 1 );
+            cv::Mat previousResult = cv::imread( previousResultName, 1 );
+            ASSERT_TRUE(!src.empty());
+
+            cv::Mat currentResult;
+
+            cv::xphoto::dctDenoising(src, currentResult, sigma[i], psize[i]);
+
+            cv::Mat sqrError = ( currentResult - previousResult )
+                .mul( currentResult - previousResult );
+            cv::Scalar mse = cv::sum(sqrError) / cv::Scalar::all( double(sqrError.total()*sqrError.channels()) );
+
+            EXPECT_LE( mse[0] + mse[1] + mse[2] + mse[3], thresholds[i] );
+        }
+    }
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/simple_color_balance.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/simple_color_balance.cpp
new file mode 100644
index 00000000..b8a52494
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/simple_color_balance.cpp
@@ -0,0 +1,273 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+    TEST(xphoto_simplecolorbalance, uchar_max_value)
+    {
+        const uchar oldMax = 120, newMax = 255;
+
+        Mat test = Mat::zeros(3,3,CV_8UC1);
+        test.at<uchar>(0, 0) = oldMax;
+        test.at<uchar>(0, 1) = oldMax / 2;
+        test.at<uchar>(0, 2) = oldMax / 4;
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(0);
+        wb->setInputMax(oldMax);
+        wb->setOutputMin(0);
+        wb->setOutputMax(newMax);
+
+        wb->balanceWhite(test, test);
+
+        double minDst, maxDst;
+        cv::minMaxIdx(test, &minDst, &maxDst);
+
+        ASSERT_NEAR(maxDst, newMax, 1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, uchar_min_value)
+    {
+        const uchar oldMin = 120, newMin = 0;
+
+        Mat test = Mat::zeros(1,3,CV_8UC1);
+        test.at<uchar>(0, 0) = oldMin;
+        test.at<uchar>(0, 1) = (256 + oldMin) / 2;
+        test.at<uchar>(0, 2) = 255;
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(oldMin);
+        wb->setInputMax(255);
+        wb->setOutputMin(newMin);
+        wb->setOutputMax(255);
+
+        wb->balanceWhite(test, test);
+
+        double minDst, maxDst;
+        cv::minMaxIdx(test, &minDst, &maxDst);
+
+        ASSERT_NEAR(minDst, newMin, 1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, uchar_equal_range)
+    {
+        const int N = 4;
+        uchar data[N] = {0, 1, 16, 255};
+        Mat test = Mat(1, N, CV_8UC1, data);
+        Mat result = Mat(1, N, CV_8UC1, data);
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(0);
+        wb->setInputMax(255);
+        wb->setOutputMin(0);
+        wb->setOutputMax(255);
+
+        wb->balanceWhite(test, test);
+
+        double err;
+        cv::minMaxIdx(cv::abs(test - result), NULL, &err);
+        ASSERT_LE(err, 1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, uchar_single_value)
+    {
+        const int N = 4;
+        uchar data0[N] = {51, 51, 51, 51};
+        uchar data1[N] = {33, 33, 33, 33};
+        Mat test = Mat(1, N, CV_8UC1, data0);
+        Mat result = Mat(1, N, CV_8UC1, data1);
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(51);
+        wb->setInputMax(51);
+        wb->setOutputMin(33);
+        wb->setOutputMax(200);
+
+        wb->balanceWhite(test, test);
+
+        double err;
+        cv::minMaxIdx(cv::abs(test - result), NULL, &err);
+        ASSERT_LE(err, 1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, uchar_p)
+    {
+        const int N = 5;
+        uchar data0[N] = {10, 55, 102, 188, 233};
+        uchar data1[N] = {0, 1, 90, 254, 255};
+        Mat test = Mat(1, N, CV_8UC1, data0);
+        Mat result = Mat(1, N, CV_8UC1, data1);
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(10);
+        wb->setInputMax(233);
+        wb->setOutputMin(0);
+        wb->setOutputMax(255);
+        wb->setP(21);
+
+        wb->balanceWhite(test, test);
+
+        double err;
+        cv::minMaxIdx(cv::abs(test - result), NULL, &err);
+        ASSERT_LE(err, 1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, uchar_c3)
+    {
+        const int N = 15;
+        uchar data0[N] = {10, 55, 102, 55, 102, 188, 102, 188, 233, 188, 233, 10, 233, 10, 55};
+        uchar data1[N] = {0, 1, 90, 1, 90, 254, 90, 254, 255, 254, 255, 0, 255, 0, 1};
+        Mat test = Mat(1, N / 3, CV_8UC3, data0);
+        Mat result = Mat(1, N / 3, CV_8UC3, data1);
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(10);
+        wb->setInputMax(233);
+        wb->setOutputMin(0);
+        wb->setOutputMax(255);
+        wb->setP(21);
+
+        wb->balanceWhite(test, test);
+
+        double err;
+        cv::minMaxIdx(cv::abs(test - result), NULL, &err);
+        ASSERT_LE(err, 1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, float_max_value)
+    {
+        const float oldMax = 24000.f, newMax = 65536.f;
+
+        Mat test = Mat::zeros(3,3,CV_32FC1);
+        test.at<float>(0, 0) = oldMax;
+        test.at<float>(0, 1) = oldMax / 2;
+        test.at<float>(0, 2) = oldMax / 4;
+
+        double minSrc, maxSrc;
+        cv::minMaxIdx(test, &minSrc, &maxSrc);
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin((float)minSrc);
+        wb->setInputMax((float)maxSrc);
+        wb->setOutputMin(0);
+        wb->setOutputMax(newMax);
+
+        wb->balanceWhite(test, test);
+
+        double minDst, maxDst;
+        cv::minMaxIdx(test, &minDst, &maxDst);
+
+        ASSERT_NEAR(maxDst, newMax, newMax*1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, float_min_value)
+    {
+        const float oldMin = 24000.f, newMin = 0.f;
+
+        Mat test = Mat::zeros(1,3,CV_32FC1);
+        test.at<float>(0, 0) = oldMin;
+        test.at<float>(0, 1) = (65536.f + oldMin) / 2;
+        test.at<float>(0, 2) = 65536.f;
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(oldMin);
+        wb->setInputMax(65536.f);
+        wb->setOutputMin(newMin);
+        wb->setOutputMax(65536.f);
+
+        wb->balanceWhite(test, test);
+
+        double minDst, maxDst;
+        cv::minMaxIdx(test, &minDst, &maxDst);
+
+        ASSERT_NEAR(minDst, newMin, 65536*1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, float_equal_range)
+    {
+        const int N = 5;
+        float data[N] = {0.f, 1.f, 16.2f, 256.3f, 4096.f};
+        Mat test = Mat(1, N, CV_32FC1, data);
+        Mat result = Mat(1, N, CV_32FC1, data);
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(0);
+        wb->setInputMax(4096);
+        wb->setOutputMin(0);
+        wb->setOutputMax(4096);
+
+        wb->balanceWhite(test, test);
+
+        double err;
+        cv::minMaxIdx(cv::abs(test - result), NULL, &err);
+        ASSERT_LE(err, 1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, float_single_value)
+    {
+        const int N = 4;
+        float data0[N] = {24000.5f, 24000.5f, 24000.5f, 24000.5f};
+        float data1[N] = {52000.25f, 52000.25f, 52000.25f, 52000.25f};
+        Mat test = Mat(1, N, CV_32FC1, data0);
+        Mat result = Mat(1, N, CV_32FC1, data1);
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(24000.5f);
+        wb->setInputMax(24000.5f);
+        wb->setOutputMin(52000.25f);
+        wb->setOutputMax(65536.f);
+
+        wb->balanceWhite(test, test);
+
+        double err;
+        cv::minMaxIdx(cv::abs(test - result), NULL, &err);
+        ASSERT_LE(err, 65536*1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, float_p)
+    {
+        const int N = 5;
+        float data0[N] = {16000.f, 20000.5f, 24000.f, 36000.5f, 48000.f};
+        float data1[N] = {-16381.952f, 0.f, 16381.952f, 65536.f, 114685.952f};
+        Mat test = Mat(1, N, CV_32FC1, data0);
+        Mat result = Mat(1, N, CV_32FC1, data1);
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(16000.f);
+        wb->setInputMax(48000.f);
+        wb->setOutputMin(0.f);
+        wb->setOutputMax(65536.f);
+        wb->setP(21);
+
+        wb->balanceWhite(test, test);
+
+        double err;
+        cv::minMaxIdx(cv::abs(test - result), NULL, &err);
+        ASSERT_LE(err, 65536*1e-4);
+    }
+
+    TEST(xphoto_simplecolorbalance, float_c3)
+    {
+        const int N = 15;
+        float data0[N] = {16000.f, 20000.5f, 24000.f, 20000.5f, 24000.f, 36000.5f, 24000.f, 36000.5f, 48000.f, 36000.5f, 48000.f, 16000.f, 48000.f, 16000.f, 20000.5f};
+        float data1[N] = {-16381.952f, 0.f, 16381.952f, 0.f, 16381.952f, 65536.f, 16381.952f, 65536.f, 114685.952f, 65536.f, 114685.952f, -16381.952f, 114685.952f, -16381.952f, 0.f};
+        Mat test = Mat(1, N / 3, CV_32FC3, data0);
+        Mat result = Mat(1, N / 3, CV_32FC3, data1);
+
+        cv::Ptr<cv::xphoto::SimpleWB> wb = cv::xphoto::createSimpleWB();
+        wb->setInputMin(16000.f);
+        wb->setInputMax(48000.f);
+        wb->setOutputMin(0.f);
+        wb->setOutputMax(65536.f);
+        wb->setP(21);
+
+        wb->balanceWhite(test, test);
+
+        double err;
+        cv::minMaxIdx(cv::abs(test - result), NULL, &err);
+        ASSERT_LE(err, 65536*1e-4);
+    }
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_denoise_bm3d.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_denoise_bm3d.cpp
new file mode 100644
index 00000000..fc2ae3c5
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_denoise_bm3d.cpp
@@ -0,0 +1,464 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+//#define DUMP_RESULTS
+//#define TEST_TRANSFORMS
+
+#ifdef TEST_TRANSFORMS
+#include "..\..\xphoto\src\bm3d_denoising_invoker_commons.hpp"
+#include "..\..\xphoto\src\bm3d_denoising_transforms.hpp"
+#include "..\..\xphoto\src\kaiser_window.hpp"
+using namespace cv::xphoto;
+#endif
+
+#ifdef DUMP_RESULTS
+#  define DUMP(image, path) imwrite(path, image)
+#else
+#  define DUMP(image, path)
+#endif
+
+#ifdef OPENCV_ENABLE_NONFREE
+
+namespace opencv_test { namespace {
+
+    TEST(xphoto_DenoisingBm3dGrayscale, regression_L2)
+    {
+        std::string folder = std::string(cvtest::TS::ptr()->get_data_path()) + "cv/xphoto/bm3d_image_denoising/";
+        std::string original_path = folder + "lena_noised_gaussian_sigma=10.png";
+        std::string expected_path = folder + "lena_noised_denoised_bm3d_wiener_grayscale_l2_tw=4_sw=16_h=10_bm=400.png";
+
+        cv::Mat original = cv::imread(original_path, cv::IMREAD_GRAYSCALE);
+        cv::Mat expected = cv::imread(expected_path, cv::IMREAD_GRAYSCALE);
+
+        ASSERT_FALSE(original.empty()) << "Could not load input image " << original_path;
+        ASSERT_FALSE(expected.empty()) << "Could not load reference image " << expected_path;
+
+        // BM3D: two different calls doing exactly the same thing
+        cv::Mat result, resultSec;
+        cv::xphoto::bm3dDenoising(original, noArray(), resultSec, 10, 4, 16, 2500, 400, 8, 1, 0.0f, cv::NORM_L2, cv::xphoto::BM3D_STEPALL);
+        cv::xphoto::bm3dDenoising(original, result, 10, 4, 16, 2500, 400, 8, 1, 0.0f, cv::NORM_L2, cv::xphoto::BM3D_STEPALL);
+
+        DUMP(result, expected_path + ".res.png");
+
+        ASSERT_EQ(cvtest::norm(result, resultSec, cv::NORM_L2), 0);
+        ASSERT_LT(cvtest::norm(result, expected, cv::NORM_L2), 200);
+    }
+
+    TEST(xphoto_DenoisingBm3dGrayscale, regression_L2_separate)
+    {
+        std::string folder = std::string(cvtest::TS::ptr()->get_data_path()) + "cv/xphoto/bm3d_image_denoising/";
+        std::string original_path = folder + "lena_noised_gaussian_sigma=10.png";
+        std::string expected_basic_path = folder + "lena_noised_denoised_bm3d_grayscale_l2_tw=4_sw=16_h=10_bm=2500.png";
+        std::string expected_path = folder + "lena_noised_denoised_bm3d_wiener_grayscale_l2_tw=4_sw=16_h=10_bm=400.png";
+
+        cv::Mat original = cv::imread(original_path, cv::IMREAD_GRAYSCALE);
+        cv::Mat expected_basic = cv::imread(expected_basic_path, cv::IMREAD_GRAYSCALE);
+        cv::Mat expected = cv::imread(expected_path, cv::IMREAD_GRAYSCALE);
+
+        ASSERT_FALSE(original.empty()) << "Could not load input image " << original_path;
+        ASSERT_FALSE(expected_basic.empty()) << "Could not load reference image " << expected_basic_path;
+        ASSERT_FALSE(expected.empty()) << "Could not load input image " << expected_path;
+
+        cv::Mat basic, result;
+
+        // BM3D step 1
+        cv::xphoto::bm3dDenoising(original, basic, 10, 4, 16, 2500, -1, 8, 1, 0.0f, cv::NORM_L2, cv::xphoto::BM3D_STEP1);
+        ASSERT_LT(cvtest::norm(basic, expected_basic, cv::NORM_L2), 200);
+        DUMP(basic, expected_basic_path + ".res.basic.png");
+
+        // BM3D step 2
+        cv::xphoto::bm3dDenoising(original, basic, result, 10, 4, 16, 2500, 400, 8, 1, 0.0f, cv::NORM_L2, cv::xphoto::BM3D_STEP2);
+        ASSERT_LT(cvtest::norm(basic, expected_basic, cv::NORM_L2), 200);
+        DUMP(basic, expected_basic_path + ".res.basic2.png");
+
+        DUMP(result, expected_path + ".res.png");
+
+        ASSERT_LT(cvtest::norm(result, expected, cv::NORM_L2), 200);
+    }
+
+    TEST(xphoto_DenoisingBm3dGrayscale, regression_L1)
+    {
+        std::string folder = std::string(cvtest::TS::ptr()->get_data_path()) + "cv/xphoto/bm3d_image_denoising/";
+        std::string original_path = folder + "lena_noised_gaussian_sigma=10.png";
+        std::string expected_path = folder + "lena_noised_denoised_bm3d_grayscale_l1_tw=4_sw=16_h=10_bm=2500.png";
+
+        cv::Mat original = cv::imread(original_path, cv::IMREAD_GRAYSCALE);
+        cv::Mat expected = cv::imread(expected_path, cv::IMREAD_GRAYSCALE);
+
+        ASSERT_FALSE(original.empty()) << "Could not load input image " << original_path;
+        ASSERT_FALSE(expected.empty()) << "Could not load reference image " << expected_path;
+
+        cv::Mat result;
+        cv::xphoto::bm3dDenoising(original, result, 10, 4, 16, 2500, -1, 8, 1, 0.0f, cv::NORM_L1, cv::xphoto::BM3D_STEP1);
+
+        DUMP(result, expected_path + ".res.png");
+
+        ASSERT_LT(cvtest::norm(result, expected, cv::NORM_L2), 200);
+    }
+
+    TEST(xphoto_DenoisingBm3dGrayscale, regression_L2_8x8)
+    {
+        std::string folder = std::string(cvtest::TS::ptr()->get_data_path()) + "cv/xphoto/bm3d_image_denoising/";
+        std::string original_path = folder + "lena_noised_gaussian_sigma=10.png";
+        std::string expected_path = folder + "lena_noised_denoised_bm3d_grayscale_l2_tw=8_sw=16_h=10_bm=2500.png";
+
+        cv::Mat original = cv::imread(original_path, cv::IMREAD_GRAYSCALE);
+        cv::Mat expected = cv::imread(expected_path, cv::IMREAD_GRAYSCALE);
+
+        ASSERT_FALSE(original.empty()) << "Could not load input image " << original_path;
+        ASSERT_FALSE(expected.empty()) << "Could not load reference image " << expected_path;
+
+        cv::Mat result;
+        cv::xphoto::bm3dDenoising(original, result, 10, 8, 16, 2500, -1, 8, 1, 0.0f, cv::NORM_L2, cv::xphoto::BM3D_STEP1);
+
+        DUMP(result, expected_path + ".res.png");
+
+        ASSERT_LT(cvtest::norm(result, expected, cv::NORM_L2), 200);
+    }
+
+#ifdef TEST_TRANSFORMS
+
+    TEST(xphoto_DenoisingBm3dKaiserWindow, regression_4)
+    {
+        float beta = 2.0f;
+        int N = 4;
+
+        cv::Mat kaiserWindow;
+        calcKaiserWindow1D(kaiserWindow, N, beta);
+
+        float kaiser4[] = {
+            0.43869004f,
+            0.92432547f,
+            0.92432547f,
+            0.43869004f
+        };
+
+        for (int i = 0; i < N; ++i)
+            ASSERT_FLOAT_EQ(kaiser4[i], kaiserWindow.at<float>(i));
+    }
+
+    TEST(xphoto_DenoisingBm3dKaiserWindow, regression_8)
+    {
+        float beta = 2.0f;
+        int N = 8;
+
+        cv::Mat kaiserWindow;
+        calcKaiserWindow1D(kaiserWindow, N, beta);
+
+        float kaiser8[] = {
+            0.43869004f,
+            0.68134475f,
+            0.87685609f,
+            0.98582518f,
+            0.98582518f,
+            0.87685609f,
+            0.68134463f,
+            0.43869004f
+        };
+
+        for (int i = 0; i < N; ++i)
+            ASSERT_FLOAT_EQ(kaiser8[i], kaiserWindow.at<float>(i));
+    }
+
+    TEST(xphoto_DenoisingBm3dTransforms, regression_2D_generic)
+    {
+        const int templateWindowSize = 8;
+        const int templateWindowSizeSq = templateWindowSize * templateWindowSize;
+
+        uchar src[templateWindowSizeSq];
+        short dst[templateWindowSizeSq];
+        short dstSec[templateWindowSizeSq];
+
+        // Initialize array
+        for (uchar i = 0; i < templateWindowSizeSq; ++i)
+            src[i] = (i % 10) * 10;
+
+        // Use tailored transforms
+        HaarTransform<uchar, short>::RegisterTransforms2D(templateWindowSize);
+        HaarTransform<uchar, short>::forwardTransform2D(src, dst, templateWindowSize, templateWindowSize);
+        HaarTransform<uchar, short>::inverseTransform2D(dst, templateWindowSize);
+
+        // Use generic transforms
+        HaarTransform2D::ForwardTransformXxX<uchar, short, templateWindowSize>(src, dstSec, templateWindowSize, templateWindowSize);
+        HaarTransform2D::InverseTransformXxX<short, templateWindowSize>(dstSec, templateWindowSize);
+
+        for (unsigned i = 0; i < templateWindowSizeSq; ++i)
+            ASSERT_EQ(dst[i], dstSec[i]);
+    }
+
+    TEST(xphoto_DenoisingBm3dTransforms, regression_2D_4x4)
+    {
+        const int templateWindowSize = 4;
+        const int templateWindowSizeSq = templateWindowSize * templateWindowSize;
+
+        uchar src[templateWindowSizeSq];
+        short dst[templateWindowSizeSq];
+
+        // Initialize array
+        for (uchar i = 0; i < templateWindowSizeSq; ++i)
+        {
+            src[i] = i;
+        }
+
+        HaarTransform2D::ForwardTransform4x4(src, dst, templateWindowSize, templateWindowSize);
+        HaarTransform2D::InverseTransform4x4(dst, templateWindowSize);
+
+        for (uchar i = 0; i < templateWindowSizeSq; ++i)
+            ASSERT_EQ(static_cast<short>(src[i]), dst[i]);
+    }
+
+    TEST(xphoto_DenoisingBm3dTransforms, regression_2D_8x8)
+    {
+        const int templateWindowSize = 8;
+        const int templateWindowSizeSq = templateWindowSize * templateWindowSize;
+
+        uchar src[templateWindowSizeSq];
+        short dst[templateWindowSizeSq];
+
+        // Initialize array
+        for (uchar i = 0; i < templateWindowSizeSq; ++i)
+        {
+            src[i] = i;
+        }
+
+        HaarTransform2D::ForwardTransform8x8(src, dst, templateWindowSize, templateWindowSize);
+        HaarTransform2D::InverseTransform8x8(dst, templateWindowSize);
+
+        for (uchar i = 0; i < templateWindowSizeSq; ++i)
+            ASSERT_EQ(static_cast<short>(src[i]), dst[i]);
+    }
+
+    template <typename T, typename DT, typename CT>
+    static void Test1dTransform(
+        T *thrMap,
+        int groupSize,
+        int templateWindowSizeSq,
+        BlockMatch<T, DT, CT> *bm,
+        BlockMatch<T, DT, CT> *bmOrig,
+        int expectedNonZeroCount = -1)
+    {
+        if (expectedNonZeroCount < 0)
+            expectedNonZeroCount = groupSize * templateWindowSizeSq;
+
+        // Test group size
+        short sumNonZero = 0;
+        T *thrMapPtr1D = thrMap + (groupSize - 1) * templateWindowSizeSq;
+        for (int n = 0; n < templateWindowSizeSq; n++)
+        {
+            switch (groupSize)
+            {
+            case 16:
+                HaarTransform1D::ForwardTransform16(bm, n);
+                sumNonZero += HardThreshold<16>(bm, n, thrMapPtr1D);
+                HaarTransform1D::InverseTransform16(bm, n);
+                break;
+            case 8:
+                HaarTransform1D::ForwardTransform8(bm, n);
+                sumNonZero += HardThreshold<8>(bm, n, thrMapPtr1D);
+                HaarTransform1D::InverseTransform8(bm, n);
+                break;
+            case 4:
+                HaarTransform1D::ForwardTransform4(bm, n);
+                sumNonZero += HardThreshold<4>(bm, n, thrMapPtr1D);
+                HaarTransform1D::InverseTransform4(bm, n);
+                break;
+            case 2:
+                HaarTransform1D::ForwardTransform2(bm, n);
+                sumNonZero += HardThreshold<2>(bm, n, thrMapPtr1D);
+                HaarTransform1D::InverseTransform2(bm, n);
+                break;
+            default:
+                HaarTransform1D::ForwardTransformN(bm, n, groupSize);
+                sumNonZero += HardThreshold(bm, n, thrMapPtr1D, groupSize);
+                HaarTransform1D::InverseTransformN(bm, n, groupSize);
+            }
+        }
+
+        // Assert transform
+        if (expectedNonZeroCount == groupSize * templateWindowSizeSq)
+        {
+            for (int i = 0; i < groupSize; ++i)
+                for (int j = 0; j < templateWindowSizeSq; ++j)
+                    ASSERT_EQ(bm[i][j], bmOrig[i][j]);
+        }
+
+        // Assert shrinkage
+        ASSERT_EQ(sumNonZero, expectedNonZeroCount);
+    }
+
+    TEST(xphoto_DenoisingBm3dTransforms, regression_1D_transform)
+    {
+        const int templateWindowSize = 4;
+        const int templateWindowSizeSq = templateWindowSize * templateWindowSize;
+        const int searchWindowSize = 16;
+        const int searchWindowSizeSq = searchWindowSize * searchWindowSize;
+        const float h = 10;
+        int maxGroupSize = 64;
+
+        // Precompute separate maps for transform and shrinkage verification
+        short *thrMapTransform = NULL;
+        short *thrMapShrinkage = NULL;
+        HaarTransform<short, short>::calcThresholdMap3D(thrMapTransform, 0, templateWindowSize, maxGroupSize);
+        HaarTransform<short, short>::calcThresholdMap3D(thrMapShrinkage, h, templateWindowSize, maxGroupSize);
+
+        // Generate some data
+        BlockMatch<short, int, short> *bm = new BlockMatch<short, int, short>[maxGroupSize];
+        BlockMatch<short, int, short> *bmOrig = new BlockMatch<short, int, short>[maxGroupSize];
+        for (int i = 0; i < maxGroupSize; ++i)
+        {
+            bm[i].init(templateWindowSizeSq);
+            bmOrig[i].init(templateWindowSizeSq);
+        }
+
+        for (short i = 0; i < maxGroupSize; ++i)
+        {
+            for (short j = 0; j < templateWindowSizeSq; ++j)
+            {
+                bm[i][j] = (j + 1);
+                bmOrig[i][j] = bm[i][j];
+            }
+        }
+
+        // Verify transforms
+        Test1dTransform<short, int, short>(thrMapTransform, 2, templateWindowSizeSq, bm, bmOrig);
+        Test1dTransform<short, int, short>(thrMapTransform, 4, templateWindowSizeSq, bm, bmOrig);
+        Test1dTransform<short, int, short>(thrMapTransform, 8, templateWindowSizeSq, bm, bmOrig);
+        Test1dTransform<short, int, short>(thrMapTransform, 16, templateWindowSizeSq, bm, bmOrig);
+        Test1dTransform<short, int, short>(thrMapTransform, 32, templateWindowSizeSq, bm, bmOrig);
+        Test1dTransform<short, int, short>(thrMapTransform, 64, templateWindowSizeSq, bm, bmOrig);
+
+        // Verify shrinkage
+        Test1dTransform<short, int, short>(thrMapShrinkage, 2, templateWindowSizeSq, bm, bmOrig, 6);
+        Test1dTransform<short, int, short>(thrMapShrinkage, 4, templateWindowSizeSq, bm, bmOrig, 6);
+        Test1dTransform<short, int, short>(thrMapShrinkage, 8, templateWindowSizeSq, bm, bmOrig, 6);
+        Test1dTransform<short, int, short>(thrMapShrinkage, 16, templateWindowSizeSq, bm, bmOrig, 6);
+        Test1dTransform<short, int, short>(thrMapShrinkage, 32, templateWindowSizeSq, bm, bmOrig, 6);
+        Test1dTransform<short, int, short>(thrMapShrinkage, 64, templateWindowSizeSq, bm, bmOrig, 14);
+    }
+
+    const float sqrt2 = std::sqrt(2.0f);
+
+    TEST(xphoto_DenoisingBm3dTransforms, regression_1D_generate)
+    {
+        const int numberOfElements = 8;
+        const int arrSize = (numberOfElements << 1) - 1;
+        float *thrMap1D = NULL;
+        HaarTransform<short, short>::calcThresholdMap1D(thrMap1D, numberOfElements);
+
+        // Expected array
+        const float kThrMap1D[arrSize] = {
+            1.0f,  // 1 element
+            sqrt2 / 2.0f,    sqrt2, // 2 elements
+            0.5f,            1.0f,            sqrt2,       sqrt2,  // 4 elements
+            sqrt2 / 4.0f,    sqrt2 / 2.0f,    1.0f,        1.0f,  sqrt2, sqrt2, sqrt2, sqrt2  // 8 elements
+        };
+
+        for (int j = 0; j < arrSize; ++j)
+            ASSERT_EQ(thrMap1D[j], kThrMap1D[j]);
+
+        delete[] thrMap1D;
+    }
+
+    TEST(xphoto_DenoisingBm3dTransforms, regression_2D_generate_4x4)
+    {
+        const int templateWindowSize = 4;
+        float *thrMap2D = NULL;
+        HaarTransform<short, short>::calcThresholdMap2D(thrMap2D, templateWindowSize);
+
+        // Expected array
+        const float kThrMap4x4[templateWindowSize * templateWindowSize] = {
+            0.25f,           0.5f,       sqrt2 / 2.0f,    sqrt2 / 2.0f,
+            0.5f,            1.0f,       sqrt2,           sqrt2,
+            sqrt2 / 2.0f,    sqrt2,      2.0f,            2.0f,
+            sqrt2 / 2.0f,    sqrt2,      2.0f,            2.0f
+        };
+
+        for (int j = 0; j < templateWindowSize * templateWindowSize; ++j)
+            ASSERT_EQ(thrMap2D[j], kThrMap4x4[j]);
+
+        delete[] thrMap2D;
+    }
+
+    TEST(xphoto_DenoisingBm3dTransforms, regression_2D_generate_8x8)
+    {
+        const int templateWindowSize = 8;
+        float *thrMap2D = NULL;
+        HaarTransform<short, short>::calcThresholdMap2D(thrMap2D, templateWindowSize);
+
+        // Expected array
+        const float kThrMap8x8[templateWindowSize * templateWindowSize] = {
+            0.125f,       0.25f,        sqrt2 / 4.0f, sqrt2 / 4.0f, 0.5f,  0.5f,  0.5f,  0.5f,
+            0.25f,        0.5f,         sqrt2 / 2.0f, sqrt2 / 2.0f, 1.0f,  1.0f,  1.0f,  1.0f,
+            sqrt2 / 4.0f, sqrt2 / 2.0f, 1.0f,         1.0f,         sqrt2, sqrt2, sqrt2, sqrt2,
+            sqrt2 / 4.0f, sqrt2 / 2.0f, 1.0f,         1.0f,         sqrt2, sqrt2, sqrt2, sqrt2,
+            0.5f,         1.0f,         sqrt2,        sqrt2,        2.0f,  2.0f,  2.0f,  2.0f,
+            0.5f,         1.0f,         sqrt2,        sqrt2,        2.0f,  2.0f,  2.0f,  2.0f,
+            0.5f,         1.0f,         sqrt2,        sqrt2,        2.0f,  2.0f,  2.0f,  2.0f,
+            0.5f,         1.0f,         sqrt2,        sqrt2,        2.0f,  2.0f,  2.0f,  2.0f
+        };
+
+        for (int j = 0; j < templateWindowSize * templateWindowSize; ++j)
+            ASSERT_EQ(thrMap2D[j], kThrMap8x8[j]);
+
+        delete[] thrMap2D;
+    }
+
+    TEST(xphoto_Bm3dDenoising, powerOf2)
+    {
+        ASSERT_EQ(8, getLargestPowerOf2SmallerThan(9));
+        ASSERT_EQ(16, getLargestPowerOf2SmallerThan(21));
+        ASSERT_EQ(4, getLargestPowerOf2SmallerThan(7));
+        ASSERT_EQ(8, getLargestPowerOf2SmallerThan(8));
+        ASSERT_EQ(4, getLargestPowerOf2SmallerThan(5));
+        ASSERT_EQ(4, getLargestPowerOf2SmallerThan(4));
+        ASSERT_EQ(2, getLargestPowerOf2SmallerThan(3));
+        ASSERT_EQ(1, getLargestPowerOf2SmallerThan(1));
+        ASSERT_EQ(0, getLargestPowerOf2SmallerThan(0));
+    }
+
+#endif  // TEST_TRANSFORMS
+
+}} // namespace
+
+#endif  // OPENCV_ENABLE_NONFREE
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_grayworld.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_grayworld.cpp
new file mode 100644
index 00000000..69b03bb1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_grayworld.cpp
@@ -0,0 +1,99 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+    void ref_autowbGrayworld(InputArray _src, OutputArray _dst, float thresh)
+    {
+        Mat src = _src.getMat();
+
+        _dst.create(src.size(), src.type());
+        Mat dst = _dst.getMat();
+
+        int width  = src.cols,
+            height = src.rows,
+            N      = width*height,
+            N3     = N*3;
+
+        // Calculate sum of pixel values of each channel
+        const uchar* src_data = src.ptr<uchar>(0);
+        unsigned long sum1 = 0, sum2 = 0, sum3 = 0;
+        int i = 0;
+        unsigned int minRGB, maxRGB, thresh255 = cvRound(thresh * 255);
+        for ( ; i < N3; i += 3 )
+        {
+            minRGB = std::min(src_data[i], std::min(src_data[i + 1], src_data[i + 2]));
+            maxRGB = std::max(src_data[i], std::max(src_data[i + 1], src_data[i + 2]));
+            if ( (maxRGB - minRGB) * 255 > thresh255 * maxRGB ) continue;
+            sum1 += src_data[i];
+            sum2 += src_data[i + 1];
+            sum3 += src_data[i + 2];
+        }
+
+        // Find inverse of averages
+        double inv1 = sum1 == 0 ? 0.f : (double)N / (double)sum1,
+               inv2 = sum2 == 0 ? 0.f : (double)N / (double)sum2,
+               inv3 = sum3 == 0 ? 0.f : (double)N / (double)sum3;
+
+        // Find maximum
+        double inv_max = std::max(std::max(inv1, inv2), inv3);
+
+        // Scale by maximum
+        if ( inv_max > 0 )
+        {
+            inv1 = (double) inv1 / inv_max;
+            inv2 = (double) inv2 / inv_max;
+            inv3 = (double) inv3 / inv_max;
+        }
+
+        // Fixed point arithmetic, mul by 2^8 then shift back 8 bits
+        int i_inv1 = cvRound(inv1 * (1 << 8)),
+            i_inv2 = cvRound(inv2 * (1 << 8)),
+            i_inv3 = cvRound(inv3 * (1 << 8));
+
+        // Scale input pixel values
+        uchar* dst_data = dst.ptr<uchar>(0);
+        i = 0;
+        for ( ; i < N3; i += 3 )
+        {
+            dst_data[i]     = (uchar)((src_data[i]     * i_inv1) >> 8);
+            dst_data[i + 1] = (uchar)((src_data[i + 1] * i_inv2) >> 8);
+            dst_data[i + 2] = (uchar)((src_data[i + 2] * i_inv3) >> 8);
+        }
+    }
+
+    TEST(xphoto_grayworld_white_balance, regression)
+    {
+        String dir = cvtest::TS::ptr()->get_data_path() + "cv/xphoto/simple_white_balance/";
+        const int nTests = 8;
+        const float wb_thresh = 0.5f;
+        const float acc_thresh = 2.f;
+        Ptr<xphoto::GrayworldWB> wb = xphoto::createGrayworldWB();
+        wb->setSaturationThreshold(wb_thresh);
+
+        for ( int i = 0; i < nTests; ++i )
+        {
+            String srcName = dir + format("sources/%02d.png", i + 1);
+            Mat src = imread(srcName, IMREAD_COLOR);
+            ASSERT_TRUE(!src.empty());
+
+            Mat referenceResult;
+            ref_autowbGrayworld(src, referenceResult, wb_thresh);
+
+            Mat currentResult;
+            wb->balanceWhite(src, currentResult);
+            ASSERT_LE(cv::norm(currentResult, referenceResult, NORM_INF), acc_thresh);
+
+            // test the 16-bit depth:
+            Mat currentResult_16U, src_16U;
+            src.convertTo(src_16U, CV_16UC3, 256.0);
+            wb->balanceWhite(src_16U, currentResult_16U);
+            currentResult_16U.convertTo(currentResult, CV_8UC3, 1/256.0);
+            ASSERT_LE(cv::norm(currentResult, referenceResult, NORM_INF), acc_thresh);
+        }
+    }
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_hdr.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_hdr.cpp
new file mode 100644
index 00000000..86eeb311
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_hdr.cpp
@@ -0,0 +1,71 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+using namespace cv::xphoto;
+
+#ifdef OPENCV_ENABLE_NONFREE
+
+void loadImage(string path, Mat &img)
+{
+    img = imread(path, -1);
+    ASSERT_FALSE(img.empty()) << "Could not load input image " << path;
+}
+
+void checkEqual(Mat img0, Mat img1, double threshold, const string& name)
+{
+    double max = 1.0;
+    minMaxLoc(abs(img0 - img1), NULL, &max);
+    ASSERT_FALSE(max > threshold) << "max=" << max << " threshold=" << threshold << " method=" << name;
+}
+
+TEST(Photo_Tonemap, Durand_regression)
+{
+    string test_path = string(cvtest::TS::ptr()->get_data_path()) + "cv/hdr/tonemap/";
+
+    Mat img, expected, result;
+    loadImage(test_path + "image.hdr", img);
+    float gamma = 2.2f;
+
+    Ptr<TonemapDurand> durand = createTonemapDurand(gamma);
+    durand->process(img, result);
+    loadImage(test_path + "durand.png", expected);
+    result.convertTo(result, CV_8UC3, 255);
+    checkEqual(result, expected, 3, "Durand");
+}
+
+TEST(Photo_Tonemap, Durand_property_regression)
+{
+    const float gamma = 1.0f;
+    const float contrast = 2.0f;
+    const float saturation = 3.0f;
+    const float sigma_color = 4.0f;
+    const float sigma_space = 5.0f;
+
+    const Ptr<TonemapDurand> durand1 = createTonemapDurand(gamma, contrast, saturation, sigma_color, sigma_space);
+    ASSERT_EQ(gamma, durand1->getGamma());
+    ASSERT_EQ(contrast, durand1->getContrast());
+    ASSERT_EQ(saturation, durand1->getSaturation());
+    ASSERT_EQ(sigma_space, durand1->getSigmaSpace());
+    ASSERT_EQ(sigma_color, durand1->getSigmaColor());
+
+    const Ptr<TonemapDurand> durand2 = createTonemapDurand();
+    durand2->setGamma(gamma);
+    durand2->setContrast(contrast);
+    durand2->setSaturation(saturation);
+    durand2->setSigmaColor(sigma_color);
+    durand2->setSigmaSpace(sigma_space);
+    ASSERT_EQ(gamma, durand2->getGamma());
+    ASSERT_EQ(contrast, durand2->getContrast());
+    ASSERT_EQ(saturation, durand2->getSaturation());
+    ASSERT_EQ(sigma_color, durand2->getSigmaColor());
+    ASSERT_EQ(sigma_space, durand2->getSigmaSpace());
+}
+
+#endif // OPENCV_ENABLE_NONFREE
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_inpainting.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_inpainting.cpp
new file mode 100644
index 00000000..c7391ceb
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_inpainting.cpp
@@ -0,0 +1,75 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+using namespace xphoto;
+
+
+static void test_inpainting(const Size inputSize, InpaintTypes mode, double expected_psnr, ImreadModes inputMode = IMREAD_COLOR)
+{
+    string original_path = cvtest::findDataFile("cv/shared/lena.png");
+    string mask_path = cvtest::findDataFile("cv/inpaint/mask.png");
+
+    Mat original_ = imread(original_path, inputMode);
+    ASSERT_FALSE(original_.empty()) << "Could not load input image " << original_path;
+
+    Mat mask_ = imread(mask_path, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(mask_.empty()) << "Could not load error mask " << mask_path;
+
+    Mat original, mask;
+    resize(original_, original, inputSize, 0.0, 0.0, INTER_AREA);
+    resize(mask_, mask, inputSize, 0.0, 0.0, INTER_NEAREST);
+
+    Mat mask_valid = (mask == 0);
+    Mat im_distorted(inputSize, original.type(), Scalar::all(0));
+    original.copyTo(im_distorted, mask_valid);
+
+    Mat reconstructed;
+    xphoto::inpaint(im_distorted, mask_valid, reconstructed, mode);
+
+    double adiff_psnr = cvtest::PSNR(original, reconstructed);
+    EXPECT_LE(expected_psnr, adiff_psnr);
+
+#if 0
+    imshow("original", original);
+    imshow("im_distorted", im_distorted);
+    imshow("reconstructed", reconstructed);
+    std::cout << "adiff_psnr=" << adiff_psnr << std::endl;
+    waitKey();
+#endif
+}
+
+TEST(xphoto_inpaint, smoke_FSR_FAST)  // fast smoke test, input doesn't fit well for tested algorithm
+{
+    test_inpainting(Size(128, 128), INPAINT_FSR_FAST, 30);
+}
+TEST(xphoto_inpaint, smoke_FSR_BEST)  // fast smoke test, input doesn't fit well for tested algorithm
+{
+    applyTestTag(CV_TEST_TAG_LONG);
+    test_inpainting(Size(128, 128), INPAINT_FSR_BEST, 30);
+}
+
+TEST(xphoto_inpaint, smoke_grayscale_FSR_FAST)  // fast smoke test, input doesn't fit well for tested algorithm
+{
+    test_inpainting(Size(128, 128), INPAINT_FSR_FAST, 30, IMREAD_GRAYSCALE);
+}
+TEST(xphoto_inpaint, smoke_grayscale_FSR_BEST)  // fast smoke test, input doesn't fit well for tested algorithm
+{
+    test_inpainting(Size(128, 128), INPAINT_FSR_BEST, 30, IMREAD_GRAYSCALE);
+}
+
+
+TEST(xphoto_inpaint, regression_FSR_FAST)
+{
+    test_inpainting(Size(512, 512), INPAINT_FSR_FAST, 39.5);
+}
+TEST(xphoto_inpaint, regression_FSR_BEST)
+{
+    applyTestTag(CV_TEST_TAG_VERYLONG);  // add --test_tag_enable=verylong to run this test
+    test_inpainting(Size(512, 512), INPAINT_FSR_BEST, 39.6);
+}
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_learning_based_color_balance.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_learning_based_color_balance.cpp
new file mode 100644
index 00000000..a083ff7a
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_learning_based_color_balance.cpp
@@ -0,0 +1,47 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+TEST(xphoto_simplefeatures, regression)
+{
+    float acc_thresh = 0.01f;
+
+    // Generate a test image:
+    Mat test_im(1000, 1000, CV_8UC3);
+    RNG rng(1234);
+    rng.fill(test_im, RNG::NORMAL, Scalar(64, 100, 128), Scalar(10, 10, 10));
+    cvtest::threshold(test_im, test_im, 200.0, 255.0, THRESH_TRUNC);
+    test_im.at<Vec3b>(0, 0) = Vec3b(240, 220, 200);
+
+    // Which should have the following features:
+    Vec2f ref1(128.0f / (64 + 100 + 128), 100.0f / (64 + 100 + 128));
+    Vec2f ref2(200.0f / (240 + 220 + 200), 220.0f / (240 + 220 + 200));
+
+    vector<Vec2f> dst_features;
+    Ptr<xphoto::LearningBasedWB> wb = xphoto::createLearningBasedWB();
+    wb->setRangeMaxVal(255);
+    wb->setSaturationThreshold(0.98f);
+    wb->setHistBinNum(64);
+    wb->extractSimpleFeatures(test_im, dst_features);
+    ASSERT_LE(cv::norm(dst_features[0], ref1, NORM_INF), acc_thresh);
+    ASSERT_LE(cv::norm(dst_features[1], ref2, NORM_INF), acc_thresh);
+    ASSERT_LE(cv::norm(dst_features[2], ref1, NORM_INF), acc_thresh);
+    ASSERT_LE(cv::norm(dst_features[3], ref1, NORM_INF), acc_thresh);
+
+    // check 16 bit depth:
+    test_im.convertTo(test_im, CV_16U, 256.0);
+    wb->setRangeMaxVal(65535);
+    wb->setSaturationThreshold(0.98f);
+    wb->setHistBinNum(128);
+    wb->extractSimpleFeatures(test_im, dst_features);
+    ASSERT_LE(cv::norm(dst_features[0], ref1, NORM_INF), acc_thresh);
+    ASSERT_LE(cv::norm(dst_features[1], ref2, NORM_INF), acc_thresh);
+    ASSERT_LE(cv::norm(dst_features[2], ref1, NORM_INF), acc_thresh);
+    ASSERT_LE(cv::norm(dst_features[3], ref1, NORM_INF), acc_thresh);
+}
+
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_main.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_main.cpp
new file mode 100644
index 00000000..a6fc332d
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_main.cpp
@@ -0,0 +1,6 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("")
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_oil_painting.cpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_oil_painting.cpp
new file mode 100644
index 00000000..e7ef2fc1
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_oil_painting.cpp
@@ -0,0 +1,108 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+Mat testOilPainting(Mat imgSrc, int halfSize, int dynRatio, int colorSpace)
+{
+    vector<int> histogramme;
+    vector<Vec3f> moyenneRGB;
+    Mat dst(imgSrc.size(), imgSrc.type());
+    Mat lum;
+    if (imgSrc.channels() != 1)
+    {
+        cvtColor(imgSrc, lum, colorSpace);
+        if (lum.channels() > 1)
+        {
+            extractChannel(lum, lum, 0);
+        }
+    }
+    else
+        lum = imgSrc.clone();
+    lum = lum / dynRatio;
+    if (dst.channels() == 3)
+        for (int y = 0; y < imgSrc.rows; y++)
+        {
+            Vec3b *vDst = dst.ptr<Vec3b>(y);
+            for (int x = 0; x < imgSrc.cols; x++, vDst++) //for each pixel
+            {
+                Mat mask(lum.size(), CV_8UC1, Scalar::all(0));
+                Rect r(Point(x - halfSize, y - halfSize), Size(2 * halfSize + 1, 2 * halfSize + 1));
+                r = r & Rect(Point(0, 0), lum.size());
+                mask(r).setTo(255);
+                int histSize[] = { 256 };
+                float hranges[] = { 0, 256 };
+                const float* ranges[] = { hranges };
+                Mat hist;
+                int channels[] = { 0 };
+                calcHist(&lum, 1, channels, mask, hist, 1, histSize, ranges, true, false);
+                double maxVal = 0;
+                Point pMin, pMax;
+                minMaxLoc(hist, 0, &maxVal, &pMin, &pMax);
+                mask.setTo(0, lum != static_cast<int>(pMax.y));
+                Scalar v = mean(imgSrc, mask);
+                *vDst = Vec3b(static_cast<uchar>(v[0]), static_cast<uchar>(v[1]), static_cast<uchar>(v[2]));
+            }
+        }
+    else
+        for (int y = 0; y < imgSrc.rows; y++)
+        {
+            uchar *vDst = dst.ptr<uchar>(y);
+            for (int x = 0; x < imgSrc.cols; x++, vDst++) //for each pixel
+            {
+                Mat mask(lum.size(), CV_8UC1, Scalar::all(0));
+                Rect r(Point(x - halfSize, y - halfSize), Size(2 * halfSize + 1, 2 * halfSize + 1));
+                r = r & Rect(Point(0, 0), lum.size());
+                mask(r).setTo(255);
+                int histSize[] = { 256 };
+                float hranges[] = { 0, 256 };
+                const float* ranges[] = { hranges };
+                Mat hist;
+                int channels[] = { 0 };
+                calcHist(&lum, 1, channels, mask, hist, 1, histSize, ranges, true, false);
+                double maxVal = 0;
+                Point pMin, pMax;
+                minMaxLoc(hist, 0, &maxVal, &pMin, &pMax);
+                mask.setTo(0, lum != static_cast<int>(pMax.y));
+                Scalar v = mean(imgSrc, mask);
+                *vDst = static_cast<uchar>(v[0]);
+            }
+        }
+    return dst;
+}
+
+TEST(xphoto_oil_painting, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "cv/inpaint/";
+    Mat orig = imread(folder+"exp1.png", IMREAD_COLOR);
+    ASSERT_TRUE(!orig.empty());
+    resize(orig, orig, Size(100, 100));
+    Mat dst1, dst2, dd;
+    xphoto::oilPainting(orig, dst1, 3, 5, COLOR_BGR2GRAY);
+    dst2 = testOilPainting(orig, 3, 5, COLOR_BGR2GRAY);
+    absdiff(dst1, dst2, dd);
+    vector<Mat> plane;
+    split(dd, plane);
+    for (auto p : plane)
+    {
+        double maxVal;
+        Point pIdx;
+        minMaxLoc(p, NULL, &maxVal, NULL, &pIdx);
+        ASSERT_LE(p.at<uchar>(pIdx), 2);
+    }
+    Mat orig2 = imread(folder + "exp1.png",IMREAD_GRAYSCALE);
+    ASSERT_TRUE(!orig2.empty());
+    resize(orig2, orig2, Size(100, 100));
+    Mat dst3, dst4, ddd;
+    xphoto::oilPainting(orig2, dst3, 3, 5, COLOR_BGR2GRAY);
+    dst4 = testOilPainting(orig2, 3, 5, COLOR_BGR2GRAY);
+    absdiff(dst3, dst4, ddd);
+    double maxVal;
+    Point pIdx;
+    minMaxLoc(ddd, NULL, &maxVal, NULL, &pIdx);
+    ASSERT_LE(ddd.at<uchar>(pIdx), 2);
+}
+
+}} // namespace
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_precomp.hpp b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_precomp.hpp
new file mode 100644
index 00000000..18249e23
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/test/test_precomp.hpp
@@ -0,0 +1,10 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/xphoto.hpp"
+#include "opencv2/ts.hpp"
+
+#endif
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/fsr_for_inpainting.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/fsr_for_inpainting.markdown
new file mode 100644
index 00000000..739dda70
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/fsr_for_inpainting.markdown
@@ -0,0 +1,77 @@
+Image Inpainting {#tutorial_xphoto_inpainting}
+================
+
+Introduction
+------------
+In this tutorial we will show how to use the algorithm Rapid Frequency Selective Reconstructiom (FSR) for image inpainting.
+
+Basics
+------
+Image Inpainting is the process of reconstructing damaged or missing parts of an image.
+This is achieved by replacing distorted pixels by pixels similar to the neighboring ones. There are several algorithms for inpainting, using different approaches for such replacement.
+
+One of those algorithms is called **Rapid Frequency Selectice Reconstruction (FSR)**.
+FSR reconstructs image signals by exploiting the property that small areas of images can be represented sparsely in the Fourier domain. See @cite GenserPCS2018 and @cite SeilerTIP2015 for details.
+
+FSR can be utilized for the following areas of application:
+
+-# **Error Concealment (Inpainting)**:
+    The sampling mask indicates the missing pixels of the distorted input image to be reconstructed.
+
+-# **Non-Regular Sampling**:
+    For more information on how to choose a good sampling mask, please review @cite GroscheICIP2018 and @cite GroscheIST2018.
+
+Example
+-------
+The following sample code shows how to use FSR for inpainting.
+The non-zero pixels of the error mask indicate valid image area, while zero pixels indicate area to be reconstructed.
+You can create an arbitrary mask manually using tools like Paint or GIMP. Start with a plain white image and draw some distortions in black.
+
+  @code{.cpp}
+
+  #include <opencv2/opencv.hpp>
+  #include <opencv2/xphoto/inpainting.hpp>
+  #include <iostream>
+
+  using namespace cv;
+
+  int main(int argc, char** argv)
+  {
+      // read image and error pattern
+      Mat original_, mask_;
+      original_ = imread("images/kodim22.png");
+      mask_ = imread("images/pattern_random.png", IMREAD_GRAYSCALE);
+
+      // make sure that mask and source image have the same size
+      Mat mask;
+      resize(mask_, mask, original_.size(), 0.0, 0.0, cv::INTER_NEAREST);
+
+      // distort image
+      Mat im_distorted(original_.size(), original_.type(), Scalar::all(0));
+      original_.copyTo(im_distorted, mask); // copy valid pixels only (i.e. non-zero pixels in mask)
+
+      // reconstruct the distorted image
+      // choose quality profile fast (xphoto::INPAINT_FSR_FAST) or best (xphoto::INPAINT_FSR_BEST)
+      Mat reconstructed;
+      xphoto::inpaint(im_distorted, mask, reconstructed, xphoto::INPAINT_FSR_FAST);
+
+      imshow("orignal image", original_);
+      imshow("distorted image", im_distorted);
+      imshow("reconstructed image", reconstructed);
+      waitKey();
+
+      return 0;
+  }
+  @endcode
+
+Original and distorted image:
+![image](images/originalVSdistorted.jpg)
+
+Reconstruction:
+![image](images/reconstructed_fastVSbest.jpg)
+
+Left image: fast quality profile (run time 8 seconds). Right image: best quality profile (1 minute 51 seconds).
+
+Additional Resources
+--------------------
+[Comparison of FSR to existing inpainting methods in OpenCV](https://github.com/opencv/opencv_contrib/files/3730212/inpainting_comparison.pdf)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/baboon.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/baboon.jpg
new file mode 100644
index 00000000..2f98d835
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/baboon.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/baboon_oil_painting_effect.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/baboon_oil_painting_effect.jpg
new file mode 100644
index 00000000..4fb033e4
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/baboon_oil_painting_effect.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/originalVSdistorted.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/originalVSdistorted.jpg
new file mode 100644
index 00000000..2320694a
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/originalVSdistorted.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/reconstructed_fastVSbest.jpg b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/reconstructed_fastVSbest.jpg
new file mode 100644
index 00000000..c16ea035
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/images/reconstructed_fastVSbest.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/oil_painting_effect.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/oil_painting_effect.markdown
new file mode 100644
index 00000000..f7c4f95c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/oil_painting_effect.markdown
@@ -0,0 +1,23 @@
+Oil painting effect {#tutorial_xphoto_oil_painting_effect}
+===================================================
+
+Introduction
+------------
+Image is converted in a color space default color space COLOR_BGR2GRAY.
+For every pixel in the image a program calculated a histogram (first plane of color space) of the neighbouring of size 2*size+1.
+and assigned the value of the most frequently occurring value. The result looks almost like an oil painting. Parameter 4 of oilPainting is used to decrease image dynamic and hence increase oil painting effect.
+
+Example
+--------------------
+
+
+    @code{.cpp}
+    Mat img;
+    Mat dst;
+    img = imread("opencv/samples/data/baboon.jpg");
+    xphoto::oilPainting(img, dst, 10, 1, COLOR_BGR2Lab);
+    imshow("oil painting effect", dst);
+    @endcode
+
+    Original ![](images/baboon.jpg)
+    Oil painting effect ![](images/baboon_oil_painting_effect.jpg)
diff --git a/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/training_white_balance.markdown b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/training_white_balance.markdown
new file mode 100644
index 00000000..eac4c849
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/modules/xphoto/tutorials/training_white_balance.markdown
@@ -0,0 +1,42 @@
+Training the learning-based white balance algorithm {#tutorial_xphoto_training_white_balance}
+===================================================
+
+Introduction
+------------
+
+Many traditional white balance algorithms are statistics-based, i.e. they rely on the fact that certain assumptions should hold in properly white-balanced images
+like the well-known grey-world assumption. However, better results can often be achieved by leveraging large datasets of images with ground-truth
+illuminants in a learning-based framework. This tutorial demonstrates how to train a learning-based white balance algorithm and evaluate the quality of the results.
+
+
+How to train a model
+--------------------
+
+-#  Download a dataset for training. In this tutorial we will use the [Gehler-Shi dataset ](http://www.cs.sfu.ca/~colour/data/shi_gehler/). Extract all 568 training images
+    in one folder. A file containing ground-truth illuminant values (real_illum_568..mat) is downloaded separately.
+
+-#  We will be using a [Python script ](https://github.com/opencv/opencv_contrib/tree/master/modules/xphoto/samples/learn_color_balance.py) for training.
+    Call it with the following parameters:
+    @code
+        python learn_color_balance.py -i <path to the folder with training images> -g <path to real_illum_568..mat> -r 0,378 --num_trees 30 --max_tree_depth 6 --num_augmented 0
+    @endcode
+    This should start training a model on the first 378 images (2/3 of the whole dataset). We set the size of the model to be 30 regression tree pairs per feature and limit
+    the tree depth to be no more then 6. By default the resulting model will be saved to color_balance_model.yml
+
+-#  Use the trained model by passing its path when constructing an instance of LearningBasedWB:
+    @code{.cpp}
+    Ptr<xphoto::LearningBasedWB> wb = xphoto::createLearningBasedWB(modelFilename);
+    @endcode
+
+
+How to evaluate a model
+----------------------
+
+-#  We will use a [benchmarking script ](https://github.com/opencv/opencv_contrib/tree/master/modules/xphoto/samples/color_balance_benchmark.py) to compare
+    the model that we've trained with the classic grey-world algorithm on the remaining 1/3 of the dataset. Call the script with the following parameters:
+    @code
+        python color_balance_benchmark.py -a grayworld,learning_based:color_balance_model.yml -m <full path to folder containing the model> -i <path to the folder with training images> -g <path to real_illum_568..mat> -r 379,567 -d "img"
+    @endcode
+
+-# The objective evaluation results are stored in white_balance_eval_result.html and the resulting white-balanced images are stored in the img folder for a qualitative
+   comparison of algorithms. Different algorithms are compared in terms of angular error between the estimated and ground-truth illuminants.
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/opencv_contrib/samples/data/corridor.jpg b/C++/opencv-4.7.0/opencv_contrib/samples/data/corridor.jpg
new file mode 100644
index 00000000..6ebef4ed
Binary files /dev/null and b/C++/opencv-4.7.0/opencv_contrib/samples/data/corridor.jpg differ
diff --git a/C++/opencv-4.7.0/opencv_contrib/samples/python2/common.py b/C++/opencv-4.7.0/opencv_contrib/samples/python2/common.py
new file mode 100644
index 00000000..56ff6865
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/samples/python2/common.py
@@ -0,0 +1,220 @@
+#!/usr/bin/env python
+
+'''
+This module contains some common routines used by other samples.
+'''
+
+import numpy as np
+import cv2 as cv
+
+# built-in modules
+import os
+import itertools as it
+from contextlib import contextmanager
+
+image_extensions = ['.bmp', '.jpg', '.jpeg', '.png', '.tif', '.tiff', '.pbm', '.pgm', '.ppm']
+
+class Bunch(object):
+    def __init__(self, **kw):
+        self.__dict__.update(kw)
+    def __str__(self):
+        return str(self.__dict__)
+
+def splitfn(fn):
+    path, fn = os.path.split(fn)
+    name, ext = os.path.splitext(fn)
+    return path, name, ext
+
+def anorm2(a):
+    return (a*a).sum(-1)
+def anorm(a):
+    return np.sqrt( anorm2(a) )
+
+def homotrans(H, x, y):
+    xs = H[0, 0]*x + H[0, 1]*y + H[0, 2]
+    ys = H[1, 0]*x + H[1, 1]*y + H[1, 2]
+    s  = H[2, 0]*x + H[2, 1]*y + H[2, 2]
+    return xs/s, ys/s
+
+def to_rect(a):
+    a = np.ravel(a)
+    if len(a) == 2:
+        a = (0, 0, a[0], a[1])
+    return np.array(a, np.float64).reshape(2, 2)
+
+def rect2rect_mtx(src, dst):
+    src, dst = to_rect(src), to_rect(dst)
+    cx, cy = (dst[1] - dst[0]) / (src[1] - src[0])
+    tx, ty = dst[0] - src[0] * (cx, cy)
+    M = np.float64([[ cx,  0, tx],
+                    [  0, cy, ty],
+                    [  0,  0,  1]])
+    return M
+
+
+def lookat(eye, target, up = (0, 0, 1)):
+    fwd = np.asarray(target, np.float64) - eye
+    fwd /= anorm(fwd)
+    right = np.cross(fwd, up)
+    right /= anorm(right)
+    down = np.cross(fwd, right)
+    R = np.float64([right, down, fwd])
+    tvec = -np.dot(R, eye)
+    return R, tvec
+
+def mtx2rvec(R):
+    w, u, vt = cv.SVDecomp(R - np.eye(3))
+    p = vt[0] + u[:,0]*w[0]    # same as np.dot(R, vt[0])
+    c = np.dot(vt[0], p)
+    s = np.dot(vt[1], p)
+    axis = np.cross(vt[0], vt[1])
+    return axis * np.arctan2(s, c)
+
+def draw_str(dst, (x, y), s):
+    cv.putText(dst, s, (x+1, y+1), cv.FONT_HERSHEY_PLAIN, 1.0, (0, 0, 0), thickness = 2, lineType=cv.LINE_AA)
+    cv.putText(dst, s, (x, y), cv.FONT_HERSHEY_PLAIN, 1.0, (255, 255, 255), lineType=cv.LINE_AA)
+
+class Sketcher:
+    def __init__(self, windowname, dests, colors_func):
+        self.prev_pt = None
+        self.windowname = windowname
+        self.dests = dests
+        self.colors_func = colors_func
+        self.dirty = False
+        self.show()
+        cv.setMouseCallback(self.windowname, self.on_mouse)
+
+    def show(self):
+        cv.imshow(self.windowname, self.dests[0])
+
+    def on_mouse(self, event, x, y, flags, param):
+        pt = (x, y)
+        if event == cv.EVENT_LBUTTONDOWN:
+            self.prev_pt = pt
+        elif event == cv.EVENT_LBUTTONUP:
+            self.prev_pt = None
+
+        if self.prev_pt and flags & cv.EVENT_FLAG_LBUTTON:
+            for dst, color in zip(self.dests, self.colors_func()):
+                cv.line(dst, self.prev_pt, pt, color, 5)
+            self.dirty = True
+            self.prev_pt = pt
+            self.show()
+
+
+# palette data from matplotlib/_cm.py
+_jet_data =   {'red':   ((0., 0, 0), (0.35, 0, 0), (0.66, 1, 1), (0.89,1, 1),
+                         (1, 0.5, 0.5)),
+               'green': ((0., 0, 0), (0.125,0, 0), (0.375,1, 1), (0.64,1, 1),
+                         (0.91,0,0), (1, 0, 0)),
+               'blue':  ((0., 0.5, 0.5), (0.11, 1, 1), (0.34, 1, 1), (0.65,0, 0),
+                         (1, 0, 0))}
+
+cmap_data = { 'jet' : _jet_data }
+
+def make_cmap(name, n=256):
+    data = cmap_data[name]
+    xs = np.linspace(0.0, 1.0, n)
+    channels = []
+    eps = 1e-6
+    for ch_name in ['blue', 'green', 'red']:
+        ch_data = data[ch_name]
+        xp, yp = [], []
+        for x, y1, y2 in ch_data:
+            xp += [x, x+eps]
+            yp += [y1, y2]
+        ch = np.interp(xs, xp, yp)
+        channels.append(ch)
+    return np.uint8(np.array(channels).T*255)
+
+def nothing(*arg, **kw):
+    pass
+
+def clock():
+    return cv.getTickCount() / cv.getTickFrequency()
+
+@contextmanager
+def Timer(msg):
+    print msg, '...',
+    start = clock()
+    try:
+        yield
+    finally:
+        print "%.2f ms" % ((clock()-start)*1000)
+
+class StatValue:
+    def __init__(self, smooth_coef = 0.5):
+        self.value = None
+        self.smooth_coef = smooth_coef
+    def update(self, v):
+        if self.value is None:
+            self.value = v
+        else:
+            c = self.smooth_coef
+            self.value = c * self.value + (1.0-c) * v
+
+class RectSelector:
+    def __init__(self, win, callback):
+        self.win = win
+        self.callback = callback
+        cv.setMouseCallback(win, self.onmouse)
+        self.drag_start = None
+        self.drag_rect = None
+    def onmouse(self, event, x, y, flags, param):
+        x, y = np.int16([x, y]) # BUG
+        if event == cv.EVENT_LBUTTONDOWN:
+            self.drag_start = (x, y)
+        if self.drag_start:
+            if flags & cv.EVENT_FLAG_LBUTTON:
+                xo, yo = self.drag_start
+                x0, y0 = np.minimum([xo, yo], [x, y])
+                x1, y1 = np.maximum([xo, yo], [x, y])
+                self.drag_rect = None
+                if x1-x0 > 0 and y1-y0 > 0:
+                    self.drag_rect = (x0, y0, x1, y1)
+            else:
+                rect = self.drag_rect
+                self.drag_start = None
+                self.drag_rect = None
+                if rect:
+                    self.callback(rect)
+    def draw(self, vis):
+        if not self.drag_rect:
+            return False
+        x0, y0, x1, y1 = self.drag_rect
+        cv.rectangle(vis, (x0, y0), (x1, y1), (0, 255, 0), 2)
+        return True
+    @property
+    def dragging(self):
+        return self.drag_rect is not None
+
+
+def grouper(n, iterable, fillvalue=None):
+    '''grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx'''
+    args = [iter(iterable)] * n
+    return it.izip_longest(fillvalue=fillvalue, *args)
+
+def mosaic(w, imgs):
+    '''Make a grid from images.
+
+    w    -- number of grid columns
+    imgs -- images (must have same size and format)
+    '''
+    imgs = iter(imgs)
+    img0 = imgs.next()
+    pad = np.zeros_like(img0)
+    imgs = it.chain([img0], imgs)
+    rows = grouper(w, imgs, pad)
+    return np.vstack(map(np.hstack, rows))
+
+def getsize(img):
+    h, w = img.shape[:2]
+    return w, h
+
+def mdot(*args):
+    return reduce(np.dot, args)
+
+def draw_keypoints(vis, keypoints, color = (0, 255, 255)):
+    for kp in keypoints:
+            x, y = kp.pt
+            cv.circle(vis, (int(x), int(y)), 2, color)
diff --git a/C++/opencv-4.7.0/opencv_contrib/samples/python2/lsd_lines_extraction.py b/C++/opencv-4.7.0/opencv_contrib/samples/python2/lsd_lines_extraction.py
new file mode 100644
index 00000000..46291b51
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/samples/python2/lsd_lines_extraction.py
@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+
+'''
+This example shows the functionalities of lines extraction finished by LSDDetector class.
+
+USAGE: lsd_lines_extraction.py [<path_to_input_image>]
+'''
+
+import sys
+import cv2 as cv
+
+if __name__ == '__main__':
+    print(__doc__)
+
+    if len(sys.argv) > 1:
+        fname = sys.argv[1]
+    else :
+        fname = '../data/corridor.jpg'
+
+    img = cv.imread(fname)
+
+    if img is None:
+        print('Failed to load image file:', fname)
+        sys.exit(1)
+
+    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+
+    lsd = cv.line_descriptor_LSDDetector.createLSDDetector()
+
+    lines = lsd.detect(gray, 2, 1)
+    for kl in lines:
+        if kl.octave == 0:
+            # cv.line only accepts integer coordinate
+            pt1 = (int(kl.startPointX), int(kl.startPointY))
+            pt2 = (int(kl.endPointX), int(kl.endPointY))
+            cv.line(img, pt1, pt2, [255, 0, 0], 2)
+
+    cv.imshow('output', img)
+    cv.waitKey(0)
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/opencv_contrib/samples/python2/seeds.py b/C++/opencv-4.7.0/opencv_contrib/samples/python2/seeds.py
new file mode 100644
index 00000000..002f61cd
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/samples/python2/seeds.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+
+'''
+This sample demonstrates SEEDS Superpixels segmentation
+Use [space] to toggle output mode
+
+Usage:
+  seeds.py [<video source>]
+
+'''
+
+import numpy as np
+import cv2 as cv
+
+# built-in module
+import sys
+
+
+if __name__ == '__main__':
+    print(__doc__)
+
+    try:
+        fn = sys.argv[1]
+    except:
+        fn = 0
+
+    def nothing(*arg):
+        pass
+
+    cv.namedWindow('SEEDS')
+    cv.createTrackbar('Number of Superpixels', 'SEEDS', 400, 1000, nothing)
+    cv.createTrackbar('Iterations', 'SEEDS', 4, 12, nothing)
+
+    seeds = None
+    display_mode = 0
+    num_superpixels = 400
+    prior = 2
+    num_levels = 4
+    num_histogram_bins = 5
+
+    cap = cv.VideoCapture(fn)
+    while True:
+        flag, img = cap.read()
+        converted_img = cv.cvtColor(img, cv.COLOR_BGR2HSV)
+        height,width,channels = converted_img.shape
+        num_superpixels_new = cv.getTrackbarPos('Number of Superpixels', 'SEEDS')
+        num_iterations = cv.getTrackbarPos('Iterations', 'SEEDS')
+
+        if not seeds or num_superpixels_new != num_superpixels:
+            num_superpixels = num_superpixels_new
+            seeds = cv.ximgproc.createSuperpixelSEEDS(width, height, channels,
+                    num_superpixels, num_levels, prior, num_histogram_bins)
+            color_img = np.zeros((height,width,3), np.uint8)
+            color_img[:] = (0, 0, 255)
+
+        seeds.iterate(converted_img, num_iterations)
+
+        # retrieve the segmentation result
+        labels = seeds.getLabels()
+
+
+        # labels output: use the last x bits to determine the color
+        num_label_bits = 2
+        labels &= (1<<num_label_bits)-1
+        labels *= 1<<(16-num_label_bits)
+
+
+        mask = seeds.getLabelContourMask(False)
+
+        # stitch foreground & background together
+        mask_inv = cv.bitwise_not(mask)
+        result_bg = cv.bitwise_and(img, img, mask=mask_inv)
+        result_fg = cv.bitwise_and(color_img, color_img, mask=mask)
+        result = cv.add(result_bg, result_fg)
+
+        if display_mode == 0:
+            cv.imshow('SEEDS', result)
+        elif display_mode == 1:
+            cv.imshow('SEEDS', mask)
+        else:
+            cv.imshow('SEEDS', labels)
+
+        ch = cv.waitKey(1)
+        if ch == 27:
+            break
+        elif ch & 0xff == ord(' '):
+            display_mode = (display_mode + 1) % 3
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/opencv_contrib/samples/python2/video.py b/C++/opencv-4.7.0/opencv_contrib/samples/python2/video.py
new file mode 100644
index 00000000..3115097c
--- /dev/null
+++ b/C++/opencv-4.7.0/opencv_contrib/samples/python2/video.py
@@ -0,0 +1,199 @@
+#!/usr/bin/env python
+
+'''
+Video capture sample.
+
+Sample shows how VideoCapture class can be used to acquire video
+frames from a camera of a movie file. Also the sample provides
+an example of procedural video generation by an object, mimicking
+the VideoCapture interface (see Chess class).
+
+'create_capture' is a convinience function for capture creation,
+falling back to procedural video in case of error.
+
+Usage:
+    video.py [--shotdir <shot path>] [source0] [source1] ...'
+
+    sourceN is an
+     - integer number for camera capture
+     - name of video file
+     - synth:<params> for procedural video
+
+Synth examples:
+    synth:bg=../cpp/lena.jpg:noise=0.1
+    synth:class=chess:bg=../cpp/lena.jpg:noise=0.1:size=640x480
+
+Keys:
+    ESC    - exit
+    SPACE  - save current frame to <shot path> directory
+
+'''
+
+import numpy as np
+from numpy import pi, sin, cos
+
+import cv2 as cv
+
+# built-in modules
+from time import clock
+
+# local modules
+import common
+
+class VideoSynthBase(object):
+    def __init__(self, size=None, noise=0.0, bg = None, **params):
+        self.bg = None
+        self.frame_size = (640, 480)
+        if bg is not None:
+            self.bg = cv.imread(bg, 1)
+            h, w = self.bg.shape[:2]
+            self.frame_size = (w, h)
+
+        if size is not None:
+            w, h = map(int, size.split('x'))
+            self.frame_size = (w, h)
+            self.bg = cv.resize(self.bg, self.frame_size)
+
+        self.noise = float(noise)
+
+    def render(self, dst):
+        pass
+
+    def read(self, dst=None):
+        w, h = self.frame_size
+
+        if self.bg is None:
+            buf = np.zeros((h, w, 3), np.uint8)
+        else:
+            buf = self.bg.copy()
+
+        self.render(buf)
+
+        if self.noise > 0.0:
+            noise = np.zeros((h, w, 3), np.int8)
+            cv.randn(noise, np.zeros(3), np.ones(3)*255*self.noise)
+            buf = cv.add(buf, noise, dtype=cv.CV_8UC3)
+        return True, buf
+
+    def isOpened(self):
+        return True
+
+class Chess(VideoSynthBase):
+    def __init__(self, **kw):
+        super(Chess, self).__init__(**kw)
+
+        w, h = self.frame_size
+
+        self.grid_size = sx, sy = 10, 7
+        white_quads = []
+        black_quads = []
+        for i, j in np.ndindex(sy, sx):
+            q = [[j, i, 0], [j+1, i, 0], [j+1, i+1, 0], [j, i+1, 0]]
+            [white_quads, black_quads][(i + j) % 2].append(q)
+        self.white_quads = np.float32(white_quads)
+        self.black_quads = np.float32(black_quads)
+
+        fx = 0.9
+        self.K = np.float64([[fx*w, 0, 0.5*(w-1)],
+                        [0, fx*w, 0.5*(h-1)],
+                        [0.0,0.0,      1.0]])
+
+        self.dist_coef = np.float64([-0.2, 0.1, 0, 0])
+        self.t = 0
+
+    def draw_quads(self, img, quads, color = (0, 255, 0)):
+        img_quads = cv.projectPoints(quads.reshape(-1, 3), self.rvec, self.tvec, self.K, self.dist_coef) [0]
+        img_quads.shape = quads.shape[:2] + (2,)
+        for q in img_quads:
+            cv.fillConvexPoly(img, np.int32(q*4), color, cv.LINE_AA, shift=2)
+
+    def render(self, dst):
+        t = self.t
+        self.t += 1.0/30.0
+
+        sx, sy = self.grid_size
+        center = np.array([0.5*sx, 0.5*sy, 0.0])
+        phi = pi/3 + sin(t*3)*pi/8
+        c, s = cos(phi), sin(phi)
+        ofs = np.array([sin(1.2*t), cos(1.8*t), 0]) * sx * 0.2
+        eye_pos = center + np.array([cos(t)*c, sin(t)*c, s]) * 15.0 + ofs
+        target_pos = center + ofs
+
+        R, self.tvec = common.lookat(eye_pos, target_pos)
+        self.rvec = common.mtx2rvec(R)
+
+        self.draw_quads(dst, self.white_quads, (245, 245, 245))
+        self.draw_quads(dst, self.black_quads, (10, 10, 10))
+
+
+classes = dict(chess=Chess)
+
+presets = dict(
+    empty = 'synth:',
+    lena = 'synth:bg=../cpp/lena.jpg:noise=0.1',
+    chess = 'synth:class=chess:bg=../cpp/lena.jpg:noise=0.1:size=640x480'
+)
+
+
+def create_capture(source = 0, fallback = presets['chess']):
+    '''source: <int> or '<int>|<filename>|synth [:<param_name>=<value> [:...]]'
+    '''
+    source = str(source).strip()
+    chunks = source.split(':')
+    # handle drive letter ('c:', ...)
+    if len(chunks) > 1 and len(chunks[0]) == 1 and chunks[0].isalpha():
+        chunks[1] = chunks[0] + ':' + chunks[1]
+        del chunks[0]
+
+    source = chunks[0]
+    try: source = int(source)
+    except ValueError: pass
+    params = dict( s.split('=') for s in chunks[1:] )
+
+    cap = None
+    if source == 'synth':
+        Class = classes.get(params.get('class', None), VideoSynthBase)
+        try: cap = Class(**params)
+        except: pass
+    else:
+        cap = cv.VideoCapture(source)
+        if 'size' in params:
+            w, h = map(int, params['size'].split('x'))
+            cap.set(cv.CAP_PROP_FRAME_WIDTH, w)
+            cap.set(cv.CAP_PROP_FRAME_HEIGHT, h)
+    if cap is None or not cap.isOpened():
+        print 'Warning: unable to open video source: ', source
+        if fallback is not None:
+            return create_capture(fallback, None)
+    return cap
+
+if __name__ == '__main__':
+    import sys
+    import getopt
+
+    print __doc__
+
+    args, sources = getopt.getopt(sys.argv[1:], '', 'shotdir=')
+    args = dict(args)
+    shotdir = args.get('--shotdir', '.')
+    if len(sources) == 0:
+        sources = [ 0 ]
+
+    caps = map(create_capture, sources)
+    shot_idx = 0
+    while True:
+        imgs = []
+        for i, cap in enumerate(caps):
+            ret, img = cap.read()
+            imgs.append(img)
+            cv.imshow('capture %d' % i, img)
+        ch = 0xFF & cv.waitKey(1)
+        if ch == 27:
+            break
+        if ch == ord(' '):
+            for i, img in enumerate(imgs):
+                fn = '%s/shot_%d_%03d.bmp' % (shotdir, i, shot_idx)
+                cv.imwrite(fn, img)
+                print fn, 'saved'
+            shot_idx += 1
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/platforms/android/README.android b/C++/opencv-4.7.0/platforms/android/README.android
new file mode 100644
index 00000000..c5725772
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/README.android
@@ -0,0 +1 @@
+See http://opencv.org/platforms/android
diff --git a/C++/opencv-4.7.0/platforms/android/android.toolchain.cmake b/C++/opencv-4.7.0/platforms/android/android.toolchain.cmake
new file mode 100644
index 00000000..69c5598a
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/android.toolchain.cmake
@@ -0,0 +1,1795 @@
+# Copyright (c) 2010-2011, Ethan Rublee
+# Copyright (c) 2011-2014, Andrey Kamaev
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1.  Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#
+# 2.  Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#
+# 3.  Neither the name of the copyright holder nor the names of its
+#     contributors may be used to endorse or promote products derived from this
+#     software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+# ------------------------------------------------------------------------------
+#  Android CMake toolchain file, for use with the Android NDK r5-r10d
+#  Requires cmake 2.6.3 or newer (2.8.9 or newer is recommended).
+#  See home page: https://github.com/taka-no-me/android-cmake
+#
+#  Usage Linux:
+#   $ export ANDROID_NDK=/absolute/path/to/the/android-ndk
+#   $ mkdir build && cd build
+#   $ cmake -DCMAKE_TOOLCHAIN_FILE=path/to/the/android.toolchain.cmake ..
+#   $ make -j8
+#
+#  Usage Windows:
+#     You need native port of make to build your project.
+#     Android NDK r7 (and newer) already has make.exe on board.
+#     For older NDK you have to install it separately.
+#     For example, this one: http://gnuwin32.sourceforge.net/packages/make.htm
+#
+#   $ SET ANDROID_NDK=C:\absolute\path\to\the\android-ndk
+#   $ mkdir build && cd build
+#   $ cmake.exe -G"MinGW Makefiles"
+#       -DCMAKE_TOOLCHAIN_FILE=path\to\the\android.toolchain.cmake
+#       -DCMAKE_MAKE_PROGRAM="%ANDROID_NDK%\prebuilt\windows\bin\make.exe" ..
+#   $ cmake.exe --build .
+#
+#
+#  Options (can be set as cmake parameters: -D<option_name>=<value>):
+#    ANDROID_NDK=/opt/android-ndk - path to the NDK root.
+#      Can be set as environment variable. Can be set only at first cmake run.
+#
+#    ANDROID_ABI=armeabi-v7a - specifies the target Application Binary
+#      Interface (ABI). This option nearly matches to the APP_ABI variable
+#      used by ndk-build tool from Android NDK.
+#
+#      Possible targets are:
+#        "armeabi" - ARMv5TE based CPU with software floating point operations
+#        "armeabi-v7a" - ARMv7 based devices with hardware FPU instructions
+#            this ABI target is used by default
+#        "armeabi-v7a-hard with NEON" - ARMv7 based devices with hardware FPU instructions and hardfp
+#        "armeabi-v7a with NEON" - same as armeabi-v7a, but
+#            sets NEON as floating-point unit
+#        "armeabi-v7a with VFPV3" - same as armeabi-v7a, but
+#            sets VFPV3 as floating-point unit (has 32 registers instead of 16)
+#        "armeabi-v6 with VFP" - tuned for ARMv6 processors having VFP
+#        "x86" - IA-32 instruction set
+#        "mips" - MIPS32 instruction set
+#
+#      64-bit ABIs for NDK r10 and newer:
+#        "arm64-v8a" - ARMv8 AArch64 instruction set
+#        "x86_64" - Intel64 instruction set (r1)
+#        "mips64" - MIPS64 instruction set (r6)
+#
+#    ANDROID_NATIVE_API_LEVEL=android-8 - level of Android API compile for.
+#      Option is read-only when standalone toolchain is used.
+#      Note: building for "android-L" requires explicit configuration.
+#
+#    ANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.9 - the name of compiler
+#      toolchain to be used. The list of possible values depends on the NDK
+#      version. For NDK r10c the possible values are:
+#
+#        * aarch64-linux-android-4.9
+#        * aarch64-linux-android-clang3.4
+#        * aarch64-linux-android-clang3.5
+#        * arm-linux-androideabi-4.6
+#        * arm-linux-androideabi-4.8
+#        * arm-linux-androideabi-4.9 (default)
+#        * arm-linux-androideabi-clang3.4
+#        * arm-linux-androideabi-clang3.5
+#        * mips64el-linux-android-4.9
+#        * mips64el-linux-android-clang3.4
+#        * mips64el-linux-android-clang3.5
+#        * mipsel-linux-android-4.6
+#        * mipsel-linux-android-4.8
+#        * mipsel-linux-android-4.9
+#        * mipsel-linux-android-clang3.4
+#        * mipsel-linux-android-clang3.5
+#        * x86-4.6
+#        * x86-4.8
+#        * x86-4.9
+#        * x86-clang3.4
+#        * x86-clang3.5
+#        * x86_64-4.9
+#        * x86_64-clang3.4
+#        * x86_64-clang3.5
+#
+#    ANDROID_FORCE_ARM_BUILD=OFF - set ON to generate 32-bit ARM instructions
+#      instead of Thumb. Is not available for "armeabi-v6 with VFP"
+#      (is forced to be ON) ABI.
+#
+#    ANDROID_NO_UNDEFINED=ON - set ON to show all undefined symbols as linker
+#      errors even if they are not used.
+#
+#    ANDROID_SO_UNDEFINED=OFF - set ON to allow undefined symbols in shared
+#      libraries. Automatically turned for NDK r5x and r6x due to GLESv2
+#      problems.
+#
+#    ANDROID_STL=gnustl_static - specify the runtime to use.
+#
+#      Possible values are:
+#        none           -> Do not configure the runtime.
+#        system         -> Use the default minimal system C++ runtime library.
+#                          Implies -fno-rtti -fno-exceptions.
+#                          Is not available for standalone toolchain.
+#        system_re      -> Use the default minimal system C++ runtime library.
+#                          Implies -frtti -fexceptions.
+#                          Is not available for standalone toolchain.
+#        gabi++_static  -> Use the GAbi++ runtime as a static library.
+#                          Implies -frtti -fno-exceptions.
+#                          Available for NDK r7 and newer.
+#                          Is not available for standalone toolchain.
+#        gabi++_shared  -> Use the GAbi++ runtime as a shared library.
+#                          Implies -frtti -fno-exceptions.
+#                          Available for NDK r7 and newer.
+#                          Is not available for standalone toolchain.
+#        stlport_static -> Use the STLport runtime as a static library.
+#                          Implies -fno-rtti -fno-exceptions for NDK before r7.
+#                          Implies -frtti -fno-exceptions for NDK r7 and newer.
+#                          Is not available for standalone toolchain.
+#        stlport_shared -> Use the STLport runtime as a shared library.
+#                          Implies -fno-rtti -fno-exceptions for NDK before r7.
+#                          Implies -frtti -fno-exceptions for NDK r7 and newer.
+#                          Is not available for standalone toolchain.
+#        gnustl_static  -> Use the GNU STL as a static library.
+#                          Implies -frtti -fexceptions.
+#        gnustl_shared  -> Use the GNU STL as a shared library.
+#                          Implies -frtti -fno-exceptions.
+#                          Available for NDK r7b and newer.
+#                          Silently degrades to gnustl_static if not available.
+#        c++_static     -> Use the LLVM libc++ runtime as a static library.
+#                          Implies -frtti -fexceptions.
+#        c++_shared     -> Use the LLVM libc++ runtime as a shared library.
+#                          Implies -frtti -fno-exceptions.
+#
+#    ANDROID_STL_FORCE_FEATURES=ON - turn rtti and exceptions support based on
+#      chosen runtime. If disabled, then the user is responsible for settings
+#      these options.
+#
+#  What?:
+#    android-cmake toolchain searches for NDK/toolchain in the following order:
+#      ANDROID_NDK - cmake parameter
+#      ANDROID_NDK - environment variable
+#      ANDROID_STANDALONE_TOOLCHAIN - cmake parameter
+#      ANDROID_STANDALONE_TOOLCHAIN - environment variable
+#      ANDROID_NDK - default locations
+#      ANDROID_STANDALONE_TOOLCHAIN - default locations
+#
+#    Make sure to do the following in your scripts:
+#      SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${my_cxx_flags}" )
+#      SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${my_cxx_flags}" )
+#    The flags will be prepopulated with critical flags, so don't loose them.
+#    Also be aware that toolchain also sets configuration-specific compiler
+#    flags and linker flags.
+#
+#    ANDROID and BUILD_ANDROID will be set to true, you may test any of these
+#    variables to make necessary Android-specific configuration changes.
+#
+#    Also ARMEABI or ARMEABI_V7A or ARMEABI_V7A_HARD or X86 or MIPS or ARM64_V8A or X86_64 or MIPS64
+#    will be set true, mutually exclusive. NEON option will be set true
+#    if VFP is set to NEON.
+#
+# ------------------------------------------------------------------------------
+
+cmake_minimum_required( VERSION 2.8.12.2 )
+
+if( DEFINED CMAKE_CROSSCOMPILING )
+ # subsequent toolchain loading is not really needed
+ return()
+endif()
+
+if( CMAKE_TOOLCHAIN_FILE )
+ # touch toolchain variable to suppress "unused variable" warning
+endif()
+
+# inherit settings in recursive loads
+get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
+if( _CMAKE_IN_TRY_COMPILE )
+ include( "${CMAKE_CURRENT_SOURCE_DIR}/../android.toolchain.config.cmake" OPTIONAL )
+endif()
+
+# this one is important
+if( CMAKE_VERSION VERSION_GREATER "3.0.99" )
+ set( CMAKE_SYSTEM_NAME Android )
+else()
+ set( CMAKE_SYSTEM_NAME Linux )
+endif()
+
+# this one not so much
+set( CMAKE_SYSTEM_VERSION 1 )
+
+# rpath makes low sense for Android
+set( CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "" )
+set( CMAKE_SKIP_RPATH TRUE CACHE BOOL "If set, runtime paths are not added when using shared libraries." )
+
+# NDK search paths
+set( ANDROID_SUPPORTED_NDK_VERSIONS ${ANDROID_EXTRA_NDK_VERSIONS} -r10d -r10c -r10b -r10 -r9d -r9c -r9b -r9 -r8e -r8d -r8c -r8b -r8 -r7c -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" )
+if( NOT DEFINED ANDROID_NDK_SEARCH_PATHS )
+ if( CMAKE_HOST_WIN32 )
+  file( TO_CMAKE_PATH "$ENV{PROGRAMFILES}" ANDROID_NDK_SEARCH_PATHS )
+  set( ANDROID_NDK_SEARCH_PATHS "${ANDROID_NDK_SEARCH_PATHS}" "$ENV{SystemDrive}/NVPACK" )
+ else()
+  file( TO_CMAKE_PATH "$ENV{HOME}" ANDROID_NDK_SEARCH_PATHS )
+  set( ANDROID_NDK_SEARCH_PATHS /opt "${ANDROID_NDK_SEARCH_PATHS}/NVPACK" )
+ endif()
+endif()
+if( NOT DEFINED ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH )
+ set( ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH /opt/android-toolchain )
+endif()
+
+# known ABIs
+set( ANDROID_SUPPORTED_ABIS_arm "armeabi-v7a;armeabi;armeabi-v7a with NEON;armeabi-v7a-hard with NEON;armeabi-v7a with VFPV3;armeabi-v6 with VFP" )
+set( ANDROID_SUPPORTED_ABIS_arm64 "arm64-v8a" )
+set( ANDROID_SUPPORTED_ABIS_x86 "x86" )
+set( ANDROID_SUPPORTED_ABIS_x86_64 "x86_64" )
+set( ANDROID_SUPPORTED_ABIS_mips "mips" )
+set( ANDROID_SUPPORTED_ABIS_mips64 "mips64" )
+
+# API level defaults
+set( ANDROID_DEFAULT_NDK_API_LEVEL 9 )
+set( ANDROID_DEFAULT_NDK_API_LEVEL_arm64 21 )
+set( ANDROID_DEFAULT_NDK_API_LEVEL_x86 9 )
+set( ANDROID_DEFAULT_NDK_API_LEVEL_x86_64 21 )
+set( ANDROID_DEFAULT_NDK_API_LEVEL_mips 9 )
+set( ANDROID_DEFAULT_NDK_API_LEVEL_mips64 21 )
+
+
+macro( __LIST_FILTER listvar regex )
+  if( ${listvar} )
+    foreach( __val ${${listvar}} )
+      if( __val MATCHES "${regex}" )
+        list( REMOVE_ITEM ${listvar} "${__val}" )
+      endif()
+    endforeach()
+  endif()
+endmacro()
+
+macro( __INIT_VARIABLE var_name )
+  set( __test_path 0 )
+  foreach( __var ${ARGN} )
+    if( __var STREQUAL "PATH" )
+      set( __test_path 1 )
+      break()
+    endif()
+  endforeach()
+
+  if( __test_path AND NOT EXISTS "${${var_name}}" )
+    unset( ${var_name} CACHE )
+  endif()
+
+  if( " ${${var_name}}" STREQUAL " " )
+    set( __values 0 )
+    foreach( __var ${ARGN} )
+      if( __var STREQUAL "VALUES" )
+        set( __values 1 )
+      elseif( NOT __var STREQUAL "PATH" )
+        if( __var MATCHES "^ENV_.*$" )
+          string( REPLACE "ENV_" "" __var "${__var}" )
+          set( __value "$ENV{${__var}}" )
+        elseif( DEFINED ${__var} )
+          set( __value "${${__var}}" )
+        elseif( __values )
+          set( __value "${__var}" )
+        else()
+          set( __value "" )
+        endif()
+
+        if( NOT " ${__value}" STREQUAL " " AND (NOT __test_path OR EXISTS "${__value}") )
+          set( ${var_name} "${__value}" )
+          break()
+        endif()
+      endif()
+    endforeach()
+    unset( __value )
+    unset( __values )
+  endif()
+
+  if( __test_path )
+    file( TO_CMAKE_PATH "${${var_name}}" ${var_name} )
+  endif()
+  unset( __test_path )
+endmacro()
+
+macro( __DETECT_NATIVE_API_LEVEL _var _path )
+  set( __ndkApiLevelRegex "^[\t ]*#define[\t ]+__ANDROID_API__[\t ]+([0-9]+)[\t ]*.*$" )
+  file( STRINGS ${_path} __apiFileContent REGEX "${__ndkApiLevelRegex}" )
+  if( NOT __apiFileContent )
+    set( __ndkApiLevelRegex "^[\t ]*#define[\t ]+__ANDROID_API__[\t ]+__ANDROID_API_FUTURE__[\t ]*$" )
+    file( STRINGS ${_path} __apiFileContent REGEX "${__ndkApiLevelRegex}" )
+    if( __apiFileContent )
+      set(${_var} 10000)
+    else()
+      message( SEND_ERROR "Could not get Android native API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." )
+    endif()
+  else()
+    string( REGEX REPLACE "${__ndkApiLevelRegex}" "\\1" ${_var} "${__apiFileContent}" )
+  endif()
+  unset( __apiFileContent )
+  unset( __ndkApiLevelRegex )
+endmacro()
+
+macro( __DETECT_TOOLCHAIN_MACHINE_NAME _var _root )
+ if( EXISTS "${_root}" )
+    file( GLOB __gccExePath RELATIVE "${_root}/bin/" "${_root}/bin/*-gcc${TOOL_OS_SUFFIX}" )
+    __LIST_FILTER( __gccExePath "^[.].*" )
+    list( LENGTH __gccExePath __gccExePathsCount )
+    if( NOT __gccExePathsCount EQUAL 1  AND NOT _CMAKE_IN_TRY_COMPILE )
+      message( WARNING "Could not determine machine name for compiler from ${_root}" )
+      set( ${_var} "" )
+    else()
+      get_filename_component( __gccExeName "${__gccExePath}" NAME_WE )
+      string( REPLACE "-gcc" "" ${_var} "${__gccExeName}" )
+    endif()
+    unset( __gccExePath )
+    unset( __gccExePathsCount )
+    unset( __gccExeName )
+  else()
+    set( ${_var} "" )
+  endif()
+endmacro()
+
+
+# fight against cygwin
+set( ANDROID_FORBID_SYGWIN TRUE CACHE BOOL "Prevent cmake from working under cygwin and using cygwin tools")
+mark_as_advanced( ANDROID_FORBID_SYGWIN )
+if( ANDROID_FORBID_SYGWIN )
+ if( CYGWIN )
+  message( FATAL_ERROR "Android NDK and android-cmake toolchain are not welcome Cygwin. It is unlikely that this cmake toolchain will work under cygwin. But if you want to try then you can set cmake variable ANDROID_FORBID_SYGWIN to FALSE and rerun cmake." )
+ endif()
+
+ if( CMAKE_HOST_WIN32 )
+  # remove cygwin from PATH
+  set( __new_path "$ENV{PATH}")
+  __LIST_FILTER( __new_path "cygwin" )
+  set(ENV{PATH} "${__new_path}")
+  unset(__new_path)
+ endif()
+endif()
+
+
+# detect current host platform
+if( NOT DEFINED ANDROID_NDK_HOST_X64 AND (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|AMD64" OR CMAKE_HOST_APPLE) )
+ set( ANDROID_NDK_HOST_X64 1 CACHE BOOL "Try to use 64-bit compiler toolchain" )
+ mark_as_advanced( ANDROID_NDK_HOST_X64 )
+endif()
+
+set( TOOL_OS_SUFFIX "" )
+if( CMAKE_HOST_APPLE )
+ set( ANDROID_NDK_HOST_SYSTEM_NAME "darwin-x86_64" )
+ set( ANDROID_NDK_HOST_SYSTEM_NAME2 "darwin-x86" )
+elseif( CMAKE_HOST_WIN32 )
+ set( ANDROID_NDK_HOST_SYSTEM_NAME "windows-x86_64" )
+ set( ANDROID_NDK_HOST_SYSTEM_NAME2 "windows" )
+ set( TOOL_OS_SUFFIX ".exe" )
+elseif( CMAKE_HOST_UNIX )
+ set( ANDROID_NDK_HOST_SYSTEM_NAME "linux-x86_64" )
+ set( ANDROID_NDK_HOST_SYSTEM_NAME2 "linux-x86" )
+else()
+ message( FATAL_ERROR "Cross-compilation on your platform is not supported by this cmake toolchain" )
+endif()
+
+if( NOT ANDROID_NDK_HOST_X64 )
+ set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} )
+endif()
+
+# see if we have path to Android NDK
+if( NOT ANDROID_NDK AND NOT ANDROID_STANDALONE_TOOLCHAIN )
+  __INIT_VARIABLE( ANDROID_NDK PATH ENV_ANDROID_NDK )
+endif()
+if( NOT ANDROID_NDK )
+ # see if we have path to Android standalone toolchain
+ __INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ENV_ANDROID_STANDALONE_TOOLCHAIN )
+
+ if( NOT ANDROID_STANDALONE_TOOLCHAIN )
+  #try to find Android NDK in one of the default locations
+  set( __ndkSearchPaths )
+  foreach( __ndkSearchPath ${ANDROID_NDK_SEARCH_PATHS} )
+   foreach( suffix ${ANDROID_SUPPORTED_NDK_VERSIONS} )
+    list( APPEND __ndkSearchPaths "${__ndkSearchPath}/android-ndk${suffix}" )
+   endforeach()
+  endforeach()
+  __INIT_VARIABLE( ANDROID_NDK PATH VALUES ${__ndkSearchPaths} )
+  unset( __ndkSearchPaths )
+
+  if( ANDROID_NDK )
+   message( STATUS "Using default path for Android NDK: ${ANDROID_NDK}" )
+   message( STATUS "  If you prefer to use a different location, please define a cmake or environment variable: ANDROID_NDK" )
+  else()
+   #try to find Android standalone toolchain in one of the default locations
+   __INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH )
+
+   if( ANDROID_STANDALONE_TOOLCHAIN )
+    message( STATUS "Using default path for standalone toolchain ${ANDROID_STANDALONE_TOOLCHAIN}" )
+    message( STATUS "  If you prefer to use a different location, please define the variable: ANDROID_STANDALONE_TOOLCHAIN" )
+   endif( ANDROID_STANDALONE_TOOLCHAIN )
+  endif( ANDROID_NDK )
+ endif( NOT ANDROID_STANDALONE_TOOLCHAIN )
+endif( NOT ANDROID_NDK )
+
+# remember found paths
+if( ANDROID_NDK )
+ get_filename_component( ANDROID_NDK "${ANDROID_NDK}" ABSOLUTE )
+ set( ANDROID_NDK "${ANDROID_NDK}" CACHE INTERNAL "Path of the Android NDK" FORCE )
+ set( BUILD_WITH_ANDROID_NDK True )
+ if( EXISTS "${ANDROID_NDK}/RELEASE.TXT" )
+  file( STRINGS "${ANDROID_NDK}/RELEASE.TXT" ANDROID_NDK_RELEASE_FULL LIMIT_COUNT 1 REGEX "r[0-9]+[a-z]?" )
+  string( REGEX MATCH "r([0-9]+)([a-z]?)" ANDROID_NDK_RELEASE "${ANDROID_NDK_RELEASE_FULL}" )
+ else()
+  set( ANDROID_NDK_RELEASE "r1x" )
+  set( ANDROID_NDK_RELEASE_FULL "unreleased" )
+ endif()
+ string( REGEX REPLACE "r([0-9]+)([a-z]?)" "\\1*1000" ANDROID_NDK_RELEASE_NUM "${ANDROID_NDK_RELEASE}" )
+ string( FIND " abcdefghijklmnopqastuvwxyz" "${CMAKE_MATCH_2}" __ndkReleaseLetterNum )
+ math( EXPR ANDROID_NDK_RELEASE_NUM "${ANDROID_NDK_RELEASE_NUM}+${__ndkReleaseLetterNum}" )
+elseif( ANDROID_STANDALONE_TOOLCHAIN )
+ get_filename_component( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" ABSOLUTE )
+ # try to detect change
+ if( CMAKE_AR )
+  string( LENGTH "${ANDROID_STANDALONE_TOOLCHAIN}" __length )
+  string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidStandaloneToolchainPreviousPath )
+  if( NOT __androidStandaloneToolchainPreviousPath STREQUAL ANDROID_STANDALONE_TOOLCHAIN )
+   message( FATAL_ERROR "It is not possible to change path to the Android standalone toolchain on subsequent run." )
+  endif()
+  unset( __androidStandaloneToolchainPreviousPath )
+  unset( __length )
+ endif()
+ set( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" CACHE INTERNAL "Path of the Android standalone toolchain" FORCE )
+ set( BUILD_WITH_STANDALONE_TOOLCHAIN True )
+else()
+ list(GET ANDROID_NDK_SEARCH_PATHS 0 ANDROID_NDK_SEARCH_PATH)
+ message( FATAL_ERROR "Could not find neither Android NDK nor Android standalone toolchain.
+    You should either set an environment variable:
+      export ANDROID_NDK=~/my-android-ndk
+    or
+      export ANDROID_STANDALONE_TOOLCHAIN=~/my-android-toolchain
+    or put the toolchain or NDK in the default path:
+      sudo ln -s ~/my-android-ndk ${ANDROID_NDK_SEARCH_PATH}/android-ndk
+      sudo ln -s ~/my-android-toolchain ${ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH}" )
+endif()
+
+# android NDK layout
+if( BUILD_WITH_ANDROID_NDK )
+ if( NOT DEFINED ANDROID_NDK_LAYOUT )
+  # try to automatically detect the layout
+  if( EXISTS "${ANDROID_NDK}/RELEASE.TXT")
+   set( ANDROID_NDK_LAYOUT "RELEASE" )
+  elseif( EXISTS "${ANDROID_NDK}/../../linux-x86/toolchain/" )
+   set( ANDROID_NDK_LAYOUT "LINARO" )
+  elseif( EXISTS "${ANDROID_NDK}/../../gcc/" )
+   set( ANDROID_NDK_LAYOUT "ANDROID" )
+  endif()
+ endif()
+ set( ANDROID_NDK_LAYOUT "${ANDROID_NDK_LAYOUT}" CACHE STRING "The inner layout of NDK" )
+ mark_as_advanced( ANDROID_NDK_LAYOUT )
+ if( ANDROID_NDK_LAYOUT STREQUAL "LINARO" )
+  set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} ) # only 32-bit at the moment
+  set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/../../${ANDROID_NDK_HOST_SYSTEM_NAME}/toolchain" )
+  set( ANDROID_NDK_TOOLCHAINS_SUBPATH  "" )
+  set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "" )
+ elseif( ANDROID_NDK_LAYOUT STREQUAL "ANDROID" )
+  set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} ) # only 32-bit at the moment
+  set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/../../gcc/${ANDROID_NDK_HOST_SYSTEM_NAME}/arm" )
+  set( ANDROID_NDK_TOOLCHAINS_SUBPATH  "" )
+  set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "" )
+ else() # ANDROID_NDK_LAYOUT STREQUAL "RELEASE"
+  set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/toolchains" )
+  set( ANDROID_NDK_TOOLCHAINS_SUBPATH  "/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
+  set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME2}" )
+ endif()
+ get_filename_component( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK_TOOLCHAINS_PATH}" ABSOLUTE )
+
+ # try to detect change of NDK
+ if( CMAKE_AR )
+  string( LENGTH "${ANDROID_NDK_TOOLCHAINS_PATH}" __length )
+  string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidNdkPreviousPath )
+  if( NOT __androidNdkPreviousPath STREQUAL ANDROID_NDK_TOOLCHAINS_PATH )
+   message( FATAL_ERROR "It is not possible to change the path to the NDK on subsequent CMake run. You must remove all generated files from your build folder first.
+   " )
+  endif()
+  unset( __androidNdkPreviousPath )
+  unset( __length )
+ endif()
+endif()
+
+
+# get all the details about standalone toolchain
+if( BUILD_WITH_STANDALONE_TOOLCHAIN )
+ __DETECT_NATIVE_API_LEVEL( ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include/android/api-level.h" )
+ set( ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )
+ set( __availableToolchains "standalone" )
+ __DETECT_TOOLCHAIN_MACHINE_NAME( __availableToolchainMachines "${ANDROID_STANDALONE_TOOLCHAIN}" )
+ if( NOT __availableToolchainMachines )
+  message( FATAL_ERROR "Could not determine machine name of your toolchain. Probably your Android standalone toolchain is broken." )
+ endif()
+ if( __availableToolchainMachines MATCHES x86_64 )
+  set( __availableToolchainArchs "x86_64" )
+ elseif( __availableToolchainMachines MATCHES i686 )
+  set( __availableToolchainArchs "x86" )
+ elseif( __availableToolchainMachines MATCHES aarch64 )
+  set( __availableToolchainArchs "arm64" )
+ elseif( __availableToolchainMachines MATCHES arm )
+  set( __availableToolchainArchs "arm" )
+ elseif( __availableToolchainMachines MATCHES mips64el )
+  set( __availableToolchainArchs "mips64" )
+ elseif( __availableToolchainMachines MATCHES mipsel )
+  set( __availableToolchainArchs "mips" )
+ endif()
+ execute_process( COMMAND "${ANDROID_STANDALONE_TOOLCHAIN}/bin/${__availableToolchainMachines}-gcc${TOOL_OS_SUFFIX}" -dumpversion
+                  OUTPUT_VARIABLE __availableToolchainCompilerVersions OUTPUT_STRIP_TRAILING_WHITESPACE )
+ string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?" __availableToolchainCompilerVersions "${__availableToolchainCompilerVersions}" )
+ if( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/bin/clang${TOOL_OS_SUFFIX}" )
+  list( APPEND __availableToolchains "standalone-clang" )
+  list( APPEND __availableToolchainMachines ${__availableToolchainMachines} )
+  list( APPEND __availableToolchainArchs ${__availableToolchainArchs} )
+  list( APPEND __availableToolchainCompilerVersions ${__availableToolchainCompilerVersions} )
+ endif()
+endif()
+
+macro( __GLOB_NDK_TOOLCHAINS __availableToolchainsVar __availableToolchainsLst __toolchain_subpath )
+ foreach( __toolchain ${${__availableToolchainsLst}} )
+  if( "${__toolchain}" MATCHES "-clang3[.][0-9]$" AND NOT EXISTS "${ANDROID_NDK_TOOLCHAINS_PATH}/${__toolchain}${__toolchain_subpath}" )
+   SET( __toolchainVersionRegex "^TOOLCHAIN_VERSION[\t ]+:=[\t ]+(.*)$" )
+   FILE( STRINGS "${ANDROID_NDK_TOOLCHAINS_PATH}/${__toolchain}/setup.mk" __toolchainVersionStr REGEX "${__toolchainVersionRegex}" )
+   if( __toolchainVersionStr )
+    string( REGEX REPLACE "${__toolchainVersionRegex}" "\\1" __toolchainVersionStr "${__toolchainVersionStr}" )
+    string( REGEX REPLACE "-clang3[.][0-9]$" "-${__toolchainVersionStr}" __gcc_toolchain "${__toolchain}" )
+   else()
+    string( REGEX REPLACE "-clang3[.][0-9]$" "-4.6" __gcc_toolchain "${__toolchain}" )
+   endif()
+   unset( __toolchainVersionStr )
+   unset( __toolchainVersionRegex )
+  else()
+   set( __gcc_toolchain "${__toolchain}" )
+  endif()
+  __DETECT_TOOLCHAIN_MACHINE_NAME( __machine "${ANDROID_NDK_TOOLCHAINS_PATH}/${__gcc_toolchain}${__toolchain_subpath}" )
+  if( __machine )
+   string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9x]+)?$" __version "${__gcc_toolchain}" )
+   if( __machine MATCHES x86_64 )
+    set( __arch "x86_64" )
+   elseif( __machine MATCHES i686 )
+    set( __arch "x86" )
+   elseif( __machine MATCHES aarch64 )
+    set( __arch "arm64" )
+   elseif( __machine MATCHES arm )
+    set( __arch "arm" )
+   elseif( __machine MATCHES mips64el )
+    set( __arch "mips64" )
+   elseif( __machine MATCHES mipsel )
+    set( __arch "mips" )
+   else()
+    set( __arch "" )
+   endif()
+   #message("machine: !${__machine}!\narch: !${__arch}!\nversion: !${__version}!\ntoolchain: !${__toolchain}!\n")
+   if (__arch)
+    list( APPEND __availableToolchainMachines "${__machine}" )
+    list( APPEND __availableToolchainArchs "${__arch}" )
+    list( APPEND __availableToolchainCompilerVersions "${__version}" )
+    list( APPEND ${__availableToolchainsVar} "${__toolchain}" )
+   endif()
+  endif()
+  unset( __gcc_toolchain )
+ endforeach()
+endmacro()
+
+# get all the details about NDK
+if( BUILD_WITH_ANDROID_NDK )
+ file( GLOB ANDROID_SUPPORTED_NATIVE_API_LEVELS RELATIVE "${ANDROID_NDK}/platforms" "${ANDROID_NDK}/platforms/android-*" )
+ string( REPLACE "android-" "" ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_SUPPORTED_NATIVE_API_LEVELS}" )
+ set( __availableToolchains "" )
+ set( __availableToolchainMachines "" )
+ set( __availableToolchainArchs "" )
+ set( __availableToolchainCompilerVersions "" )
+ if( ANDROID_TOOLCHAIN_NAME AND EXISTS "${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_TOOLCHAIN_NAME}/" )
+  # do not go through all toolchains if we know the name
+  set( __availableToolchainsLst "${ANDROID_TOOLCHAIN_NAME}" )
+  __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH}" )
+  if( NOT __availableToolchains AND NOT ANDROID_NDK_TOOLCHAINS_SUBPATH STREQUAL ANDROID_NDK_TOOLCHAINS_SUBPATH2 )
+   __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH2}" )
+   if( __availableToolchains )
+    set( ANDROID_NDK_TOOLCHAINS_SUBPATH ${ANDROID_NDK_TOOLCHAINS_SUBPATH2} )
+   endif()
+  endif()
+ endif()
+ if( NOT __availableToolchains )
+  file( GLOB __availableToolchainsLst RELATIVE "${ANDROID_NDK_TOOLCHAINS_PATH}" "${ANDROID_NDK_TOOLCHAINS_PATH}/*" )
+  if( __availableToolchainsLst )
+   list(SORT __availableToolchainsLst) # we need clang to go after gcc
+  endif()
+  __LIST_FILTER( __availableToolchainsLst "^[.]" )
+  __LIST_FILTER( __availableToolchainsLst "llvm" )
+  __LIST_FILTER( __availableToolchainsLst "renderscript" )
+  __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH}" )
+  if( NOT __availableToolchains AND NOT ANDROID_NDK_TOOLCHAINS_SUBPATH STREQUAL ANDROID_NDK_TOOLCHAINS_SUBPATH2 )
+   __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH2}" )
+   if( __availableToolchains )
+    set( ANDROID_NDK_TOOLCHAINS_SUBPATH ${ANDROID_NDK_TOOLCHAINS_SUBPATH2} )
+   endif()
+  endif()
+ endif()
+ if( NOT __availableToolchains )
+  message( FATAL_ERROR "Could not find any working toolchain in the NDK. Probably your Android NDK is broken." )
+ endif()
+endif()
+
+# build list of available ABIs
+set( ANDROID_SUPPORTED_ABIS "" )
+set( __uniqToolchainArchNames ${__availableToolchainArchs} )
+list( REMOVE_DUPLICATES __uniqToolchainArchNames )
+list( SORT __uniqToolchainArchNames )
+foreach( __arch ${__uniqToolchainArchNames} )
+ list( APPEND ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${__arch}} )
+endforeach()
+unset( __uniqToolchainArchNames )
+if( NOT ANDROID_SUPPORTED_ABIS )
+ message( FATAL_ERROR "No one of known Android ABIs is supported by this cmake toolchain." )
+endif()
+
+# choose target ABI
+__INIT_VARIABLE( ANDROID_ABI VALUES ${ANDROID_SUPPORTED_ABIS} )
+# verify that target ABI is supported
+list( FIND ANDROID_SUPPORTED_ABIS "${ANDROID_ABI}" __androidAbiIdx )
+if( __androidAbiIdx EQUAL -1 )
+ string( REPLACE ";" "\", \"" PRINTABLE_ANDROID_SUPPORTED_ABIS  "${ANDROID_SUPPORTED_ABIS}" )
+ message( FATAL_ERROR "Specified ANDROID_ABI = \"${ANDROID_ABI}\" is not supported by this cmake toolchain or your NDK/toolchain.
+   Supported values are: \"${PRINTABLE_ANDROID_SUPPORTED_ABIS}\"
+   " )
+endif()
+unset( __androidAbiIdx )
+
+# set target ABI options
+if( ANDROID_ABI STREQUAL "x86" )
+ set( X86 true )
+ set( ANDROID_NDK_ABI_NAME "x86" )
+ set( ANDROID_ARCH_NAME "x86" )
+ set( ANDROID_LLVM_TRIPLE "i686-none-linux-android" )
+ set( CMAKE_SYSTEM_PROCESSOR "i686" )
+elseif( ANDROID_ABI STREQUAL "x86_64" )
+ set( X86 true )
+ set( X86_64 true )
+ set( ANDROID_NDK_ABI_NAME "x86_64" )
+ set( ANDROID_ARCH_NAME "x86_64" )
+ set( CMAKE_SYSTEM_PROCESSOR "x86_64" )
+ set( ANDROID_LLVM_TRIPLE "x86_64-none-linux-android" )
+elseif( ANDROID_ABI STREQUAL "mips64" )
+ set( MIPS64 true )
+ set( ANDROID_NDK_ABI_NAME "mips64" )
+ set( ANDROID_ARCH_NAME "mips64" )
+ set( ANDROID_LLVM_TRIPLE "mips64el-none-linux-android" )
+ set( CMAKE_SYSTEM_PROCESSOR "mips64" )
+elseif( ANDROID_ABI STREQUAL "mips" )
+ set( MIPS true )
+ set( ANDROID_NDK_ABI_NAME "mips" )
+ set( ANDROID_ARCH_NAME "mips" )
+ set( ANDROID_LLVM_TRIPLE "mipsel-none-linux-android" )
+ set( CMAKE_SYSTEM_PROCESSOR "mips" )
+elseif( ANDROID_ABI STREQUAL "arm64-v8a" )
+ set( ARM64_V8A true )
+ set( ANDROID_NDK_ABI_NAME "arm64-v8a" )
+ set( ANDROID_ARCH_NAME "arm64" )
+ set( ANDROID_LLVM_TRIPLE "aarch64-none-linux-android" )
+ set( CMAKE_SYSTEM_PROCESSOR "aarch64" )
+ set( VFPV3 true )
+ set( NEON true )
+elseif( ANDROID_ABI STREQUAL "armeabi" )
+ set( ARMEABI true )
+ set( ANDROID_NDK_ABI_NAME "armeabi" )
+ set( ANDROID_ARCH_NAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" )
+ set( CMAKE_SYSTEM_PROCESSOR "armv5te" )
+elseif( ANDROID_ABI STREQUAL "armeabi-v6 with VFP" )
+ set( ARMEABI_V6 true )
+ set( ANDROID_NDK_ABI_NAME "armeabi" )
+ set( ANDROID_ARCH_NAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" )
+ set( CMAKE_SYSTEM_PROCESSOR "armv6" )
+ # need always fallback to older platform
+ set( ARMEABI true )
+elseif( ANDROID_ABI STREQUAL "armeabi-v7a")
+ set( ARMEABI_V7A true )
+ set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
+ set( ANDROID_ARCH_NAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )
+ set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
+elseif( ANDROID_ABI STREQUAL "armeabi-v7a with VFPV3" )
+ set( ARMEABI_V7A true )
+ set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
+ set( ANDROID_ARCH_NAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )
+ set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
+ set( VFPV3 true )
+elseif( ANDROID_ABI STREQUAL "armeabi-v7a with NEON" )
+ set( ARMEABI_V7A true )
+ set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
+ set( ANDROID_ARCH_NAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )
+ set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
+ set( VFPV3 true )
+ set( NEON true )
+elseif( ANDROID_ABI STREQUAL "armeabi-v7a-hard with NEON" )
+ set( ARMEABI_V7A_HARD true )
+ set( ANDROID_NDK_ABI_NAME "armeabi-v7a-hard" )
+ set( ANDROID_ARCH_NAME "arm" )
+ set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )
+ set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
+ set( VFPV3 true )
+ set( NEON true )
+else()
+ message( SEND_ERROR "Unknown ANDROID_ABI=\"${ANDROID_ABI}\" is specified." )
+endif()
+
+if( CMAKE_BINARY_DIR AND EXISTS "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" )
+ # really dirty hack
+ # it is not possible to change CMAKE_SYSTEM_PROCESSOR after the first run...
+ file( APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" "SET(CMAKE_SYSTEM_PROCESSOR \"${CMAKE_SYSTEM_PROCESSOR}\")\n" )
+endif()
+
+if( ANDROID_ARCH_NAME STREQUAL "arm" AND NOT ARMEABI_V6 )
+ __INIT_VARIABLE( ANDROID_FORCE_ARM_BUILD VALUES OFF )
+ set( ANDROID_FORCE_ARM_BUILD ${ANDROID_FORCE_ARM_BUILD} CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" FORCE )
+ mark_as_advanced( ANDROID_FORCE_ARM_BUILD )
+else()
+ unset( ANDROID_FORCE_ARM_BUILD CACHE )
+endif()
+
+# choose toolchain
+if( ANDROID_TOOLCHAIN_NAME )
+ list( FIND __availableToolchains "${ANDROID_TOOLCHAIN_NAME}" __toolchainIdx )
+ if( __toolchainIdx EQUAL -1 )
+  list( SORT __availableToolchains )
+  string( REPLACE ";" "\n  * " toolchains_list "${__availableToolchains}" )
+  set( toolchains_list "  * ${toolchains_list}")
+  message( FATAL_ERROR "Specified toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is missing in your NDK or broken. Please verify that your NDK is working or select another compiler toolchain.
+To configure the toolchain set CMake variable ANDROID_TOOLCHAIN_NAME to one of the following values:\n${toolchains_list}\n" )
+ endif()
+ list( GET __availableToolchainArchs ${__toolchainIdx} __toolchainArch )
+ if( NOT __toolchainArch STREQUAL ANDROID_ARCH_NAME )
+  message( SEND_ERROR "Selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is not able to compile binaries for the \"${ANDROID_ARCH_NAME}\" platform." )
+ endif()
+else()
+ set( __toolchainIdx -1 )
+ set( __applicableToolchains "" )
+ set( __toolchainMaxVersion "0.0.0" )
+ list( LENGTH __availableToolchains __availableToolchainsCount )
+ math( EXPR __availableToolchainsCount "${__availableToolchainsCount}-1" )
+ foreach( __idx RANGE ${__availableToolchainsCount} )
+  list( GET __availableToolchainArchs ${__idx} __toolchainArch )
+  if( __toolchainArch STREQUAL ANDROID_ARCH_NAME )
+   list( GET __availableToolchainCompilerVersions ${__idx} __toolchainVersion )
+   string( REPLACE "x" "99" __toolchainVersion "${__toolchainVersion}")
+   if( __toolchainVersion VERSION_GREATER __toolchainMaxVersion )
+    set( __toolchainMaxVersion "${__toolchainVersion}" )
+    set( __toolchainIdx ${__idx} )
+   endif()
+  endif()
+ endforeach()
+ unset( __availableToolchainsCount )
+ unset( __toolchainMaxVersion )
+ unset( __toolchainVersion )
+endif()
+unset( __toolchainArch )
+if( __toolchainIdx EQUAL -1 )
+ message( FATAL_ERROR "No one of available compiler toolchains is able to compile for ${ANDROID_ARCH_NAME} platform." )
+endif()
+list( GET __availableToolchains ${__toolchainIdx} ANDROID_TOOLCHAIN_NAME )
+list( GET __availableToolchainMachines ${__toolchainIdx} ANDROID_TOOLCHAIN_MACHINE_NAME )
+list( GET __availableToolchainCompilerVersions ${__toolchainIdx} ANDROID_COMPILER_VERSION )
+
+unset( __toolchainIdx )
+unset( __availableToolchains )
+unset( __availableToolchainMachines )
+unset( __availableToolchainArchs )
+unset( __availableToolchainCompilerVersions )
+
+# choose native API level
+__INIT_VARIABLE( ANDROID_NATIVE_API_LEVEL ENV_ANDROID_NATIVE_API_LEVEL ANDROID_API_LEVEL ENV_ANDROID_API_LEVEL ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME} ANDROID_DEFAULT_NDK_API_LEVEL )
+string( REPLACE "android-" "" ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" )
+string( STRIP "${ANDROID_NATIVE_API_LEVEL}" ANDROID_NATIVE_API_LEVEL )
+# adjust API level
+set( __real_api_level ${ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME}} )
+foreach( __level ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )
+ if( (__level LESS ANDROID_NATIVE_API_LEVEL OR __level STREQUAL ANDROID_NATIVE_API_LEVEL) AND NOT __level LESS __real_api_level )
+  set( __real_api_level ${__level} )
+ endif()
+endforeach()
+if( __real_api_level AND NOT ANDROID_NATIVE_API_LEVEL STREQUAL __real_api_level )
+ message( STATUS "Adjusting Android API level 'android-${ANDROID_NATIVE_API_LEVEL}' to 'android-${__real_api_level}'")
+ set( ANDROID_NATIVE_API_LEVEL ${__real_api_level} )
+endif()
+unset(__real_api_level)
+# validate
+list( FIND ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_NATIVE_API_LEVEL}" __levelIdx )
+if( __levelIdx EQUAL -1 )
+ message( SEND_ERROR "Specified Android native API level 'android-${ANDROID_NATIVE_API_LEVEL}' is not supported by your NDK/toolchain.\nSupported values of ANDROID_NATIVE_API_LEVEL: ${ANDROID_SUPPORTED_NATIVE_API_LEVELS}" )
+else()
+ if( BUILD_WITH_ANDROID_NDK )
+  if(EXISTS "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h")
+    __DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h" )
+  else()
+    __DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/sysroot/usr/include/android/api-level.h")
+  endif()
+
+  if( NOT __realApiLevel EQUAL ANDROID_NATIVE_API_LEVEL AND NOT __realApiLevel GREATER 9000 )
+   message( SEND_ERROR "Specified Android API level (${ANDROID_NATIVE_API_LEVEL}) does not match to the level found (${__realApiLevel}). Probably your copy of NDK is broken." )
+  endif()
+  unset( __realApiLevel )
+ endif()
+ set( ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" CACHE STRING "Android API level for native code" FORCE )
+ set( CMAKE_ANDROID_API ${ANDROID_NATIVE_API_LEVEL} )
+ if( CMAKE_VERSION VERSION_GREATER "2.8" )
+  list( SORT ANDROID_SUPPORTED_NATIVE_API_LEVELS )
+  set_property( CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )
+ endif()
+endif()
+unset( __levelIdx )
+
+
+# remember target ABI
+set( ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "The target ABI for Android. If arm, then armeabi-v7a is recommended for hardware floating point." FORCE )
+if( CMAKE_VERSION VERSION_GREATER "2.8" )
+ list( SORT ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_NAME} )
+ set_property( CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_NAME}} )
+endif()
+
+
+# runtime choice (STL, rtti, exceptions)
+if( NOT ANDROID_STL )
+  set( ANDROID_STL gnustl_static )
+endif()
+set( ANDROID_STL "${ANDROID_STL}" CACHE STRING "C++ runtime" )
+set( ANDROID_STL_FORCE_FEATURES ON CACHE BOOL "automatically configure rtti and exceptions support based on C++ runtime" )
+mark_as_advanced( ANDROID_STL ANDROID_STL_FORCE_FEATURES )
+
+if( BUILD_WITH_ANDROID_NDK )
+ if( NOT "${ANDROID_STL}" MATCHES "^(none|system|system_re|gabi\\+\\+_static|gabi\\+\\+_shared|stlport_static|stlport_shared|gnustl_static|gnustl_shared|c\\+\\+_static|c\\+\\+_shared)$")
+  message( FATAL_ERROR "ANDROID_STL is set to invalid value \"${ANDROID_STL}\".
+The possible values are:
+  none           -> Do not configure the runtime.
+  system         -> Use the default minimal system C++ runtime library.
+  system_re      -> Same as system but with rtti and exceptions.
+  gabi++_static  -> Use the GAbi++ runtime as a static library.
+  gabi++_shared  -> Use the GAbi++ runtime as a shared library.
+  stlport_static -> Use the STLport runtime as a static library.
+  stlport_shared -> Use the STLport runtime as a shared library.
+  gnustl_static  -> (default) Use the GNU STL as a static library.
+  gnustl_shared  -> Use the GNU STL as a shared library.
+  c++_shared     -> Use the LLVM libc++ runtime as a shared library.
+  c++_static     -> Use the LLVM libc++ runtime as a static library.
+" )
+ endif()
+elseif( BUILD_WITH_STANDALONE_TOOLCHAIN )
+ if( NOT "${ANDROID_STL}" MATCHES "^(none|gnustl_static|gnustl_shared|c\\+\\+_static|c\\+\\+_shared)$")
+  message( FATAL_ERROR "ANDROID_STL is set to invalid value \"${ANDROID_STL}\".
+The possible values are:
+  none           -> Do not configure the runtime.
+  gnustl_static  -> (default) Use the GNU STL as a static library.
+  gnustl_shared  -> Use the GNU STL as a shared library.
+  c++_shared     -> Use the LLVM libc++ runtime as a shared library.
+  c++_static     -> Use the LLVM libc++ runtime as a static library.
+" )
+ endif()
+endif()
+
+unset( ANDROID_RTTI )
+unset( ANDROID_EXCEPTIONS )
+unset( ANDROID_STL_INCLUDE_DIRS )
+unset( __libstl )
+unset( __libsupcxx )
+
+if( NOT _CMAKE_IN_TRY_COMPILE AND ANDROID_NDK_RELEASE STREQUAL "r7b" AND ARMEABI_V7A AND NOT VFPV3 AND ANDROID_STL MATCHES "gnustl" )
+ message( WARNING  "The GNU STL armeabi-v7a binaries from NDK r7b can crash non-NEON devices. The files provided with NDK r7b were not configured properly, resulting in crashes on Tegra2-based devices and others when trying to use certain floating-point functions (e.g., cosf, sinf, expf).
+You are strongly recommended to switch to another NDK release.
+" )
+endif()
+
+if( NOT _CMAKE_IN_TRY_COMPILE AND X86 AND ANDROID_STL MATCHES "gnustl" AND ANDROID_NDK_RELEASE STREQUAL "r6" )
+  message( WARNING  "The x86 system header file from NDK r6 has incorrect definition for ptrdiff_t. You are recommended to upgrade to a newer NDK release or manually patch the header:
+See https://android.googlesource.com/platform/development.git f907f4f9d4e56ccc8093df6fee54454b8bcab6c2
+  diff --git a/ndk/platforms/android-9/arch-x86/include/machine/_types.h b/ndk/platforms/android-9/arch-x86/include/machine/_types.h
+  index 5e28c64..65892a1 100644
+  --- a/ndk/platforms/android-9/arch-x86/include/machine/_types.h
+  +++ b/ndk/platforms/android-9/arch-x86/include/machine/_types.h
+  @@ -51,7 +51,11 @@ typedef long int       ssize_t;
+   #endif
+   #ifndef _PTRDIFF_T
+   #define _PTRDIFF_T
+  -typedef long           ptrdiff_t;
+  +#  ifdef __ANDROID__
+  +     typedef int            ptrdiff_t;
+  +#  else
+  +     typedef long           ptrdiff_t;
+  +#  endif
+   #endif
+" )
+endif()
+
+
+# setup paths and STL for standalone toolchain
+if( BUILD_WITH_STANDALONE_TOOLCHAIN )
+ set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" )
+ set( ANDROID_CLANG_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" )
+ set( ANDROID_SYSROOT "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot" )
+ set( ANDROID_SYSROOT_INCLUDE "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include" )
+
+ if( NOT ANDROID_STL STREQUAL "none" )
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_STANDALONE_TOOLCHAIN}/include/c++/${ANDROID_COMPILER_VERSION}" )
+  if( NOT EXISTS "${ANDROID_STL_INCLUDE_DIRS}" )
+   # old location ( pre r8c )
+   set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}" )
+  endif()
+  if( (ARMEABI_V7A OR ARMEABI_V7A_HARD) AND EXISTS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/bits" )
+   list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}" )
+  elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb/bits" )
+   list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb" )
+  else()
+   list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" )
+  endif()
+  # always search static GNU STL to get the location of libsupc++.a
+  if( (ARMEABI_V7A OR ARMEABI_V7A_HARD) AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libstdc++.a" )
+   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb" )
+  elseif( (ARMEABI_V7A OR ARMEABI_V7A_HARD) AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libstdc++.a" )
+   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}" )
+  elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libstdc++.a" )
+   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb" )
+  elseif( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libstdc++.a" )
+   set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib" )
+  endif()
+  if( __libstl )
+   set( __libsupcxx "${__libstl}/libsupc++.a" )
+   set( __libstl    "${__libstl}/libstdc++.a" )
+  endif()
+  if( NOT EXISTS "${__libsupcxx}" )
+   message( FATAL_ERROR "The required libstdsupc++.a is missing in your standalone toolchain.
+ Usually it happens because of bug in make-standalone-toolchain.sh script from NDK r7, r7b and r7c.
+ You need to either upgrade to newer NDK or manually copy
+     $ANDROID_NDK/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a
+ to
+     ${__libsupcxx}
+   " )
+  endif()
+  if( ANDROID_STL STREQUAL "gnustl_shared" )
+   if( (ARMEABI_V7A OR ARMEABI_V7A_HARD) AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libgnustl_shared.so" )
+    set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libgnustl_shared.so" )
+   elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libgnustl_shared.so" )
+    set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libgnustl_shared.so" )
+   elseif( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libgnustl_shared.so" )
+    set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libgnustl_shared.so" )
+   endif()
+  endif()
+ endif()
+endif()
+
+# clang
+if( "${ANDROID_TOOLCHAIN_NAME}" STREQUAL "standalone-clang" )
+ set( ANDROID_COMPILER_IS_CLANG 1 )
+ execute_process( COMMAND "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/clang${TOOL_OS_SUFFIX}" --version OUTPUT_VARIABLE ANDROID_CLANG_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE )
+ string( REGEX MATCH "[0-9]+[.][0-9]+" ANDROID_CLANG_VERSION "${ANDROID_CLANG_VERSION}")
+elseif( "${ANDROID_TOOLCHAIN_NAME}" MATCHES "-clang3[.][0-9]?$" )
+ string( REGEX MATCH "3[.][0-9]$" ANDROID_CLANG_VERSION "${ANDROID_TOOLCHAIN_NAME}")
+ string( REGEX REPLACE "-clang${ANDROID_CLANG_VERSION}$" "-${ANDROID_COMPILER_VERSION}" ANDROID_GCC_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" )
+ if( NOT EXISTS "${ANDROID_NDK_TOOLCHAINS_PATH}/llvm-${ANDROID_CLANG_VERSION}${ANDROID_NDK_TOOLCHAINS_SUBPATH}/bin/clang${TOOL_OS_SUFFIX}" )
+  message( FATAL_ERROR "Could not find the Clang compiler driver" )
+ endif()
+ set( ANDROID_COMPILER_IS_CLANG 1 )
+ set( ANDROID_CLANG_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAINS_PATH}/llvm-${ANDROID_CLANG_VERSION}${ANDROID_NDK_TOOLCHAINS_SUBPATH}" )
+else()
+ set( ANDROID_GCC_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" )
+ unset( ANDROID_COMPILER_IS_CLANG CACHE )
+endif()
+
+string( REPLACE "." "" _clang_name "clang${ANDROID_CLANG_VERSION}" )
+if( NOT EXISTS "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}" )
+ set( _clang_name "clang" )
+endif()
+
+
+# setup paths and STL for NDK
+if( BUILD_WITH_ANDROID_NDK )
+ set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_GCC_TOOLCHAIN_NAME}${ANDROID_NDK_TOOLCHAINS_SUBPATH}" )
+ set( ANDROID_SYSROOT "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}" )
+ if( EXISTS "${ANDROID_SYSROOT}/usr/include" )
+   set( ANDROID_SYSROOT_INCLUDE "${ANDROID_SYSROOT}/usr/include" )
+ else()
+   set( ANDROID_SYSROOT_INCLUDE "${ANDROID_NDK}/sysroot/usr/include" "${ANDROID_NDK}/sysroot/usr/include/${ANDROID_TOOLCHAIN_MACHINE_NAME}" )
+ endif()
+
+ if( ANDROID_STL STREQUAL "none" )
+  # do nothing
+ elseif( ANDROID_STL STREQUAL "system" )
+  set( ANDROID_RTTI             OFF )
+  set( ANDROID_EXCEPTIONS       OFF )
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/system/include" )
+ elseif( ANDROID_STL STREQUAL "system_re" )
+  set( ANDROID_RTTI             ON )
+  set( ANDROID_EXCEPTIONS       ON )
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/system/include" )
+ elseif( ANDROID_STL MATCHES "gabi" )
+  if( ANDROID_NDK_RELEASE_NUM LESS 7000 ) # before r7
+   message( FATAL_ERROR "gabi++ is not available in your NDK. You have to upgrade to NDK r7 or newer to use gabi++.")
+  endif()
+  set( ANDROID_RTTI             ON )
+  set( ANDROID_EXCEPTIONS       OFF )
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/gabi++/include" )
+  set( __libstl                 "${ANDROID_NDK}/sources/cxx-stl/gabi++/libs/${ANDROID_NDK_ABI_NAME}/libgabi++_static.a" )
+ elseif( ANDROID_STL MATCHES "stlport" )
+  if( NOT ANDROID_NDK_RELEASE_NUM LESS 8004 ) # before r8d
+   set( ANDROID_EXCEPTIONS       ON )
+  else()
+   set( ANDROID_EXCEPTIONS       OFF )
+  endif()
+  if( ANDROID_NDK_RELEASE_NUM LESS 7000 ) # before r7
+   set( ANDROID_RTTI            OFF )
+  else()
+   set( ANDROID_RTTI            ON )
+  endif()
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/cxx-stl/stlport/stlport" )
+  set( __libstl                 "${ANDROID_NDK}/sources/cxx-stl/stlport/libs/${ANDROID_NDK_ABI_NAME}/libstlport_static.a" )
+ elseif( ANDROID_STL MATCHES "gnustl" )
+  set( ANDROID_EXCEPTIONS       ON )
+  set( ANDROID_RTTI             ON )
+  if( EXISTS "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}" )
+   if( ARMEABI_V7A AND ANDROID_COMPILER_VERSION VERSION_EQUAL "4.7" AND ANDROID_NDK_RELEASE STREQUAL "r8d" )
+    # gnustl binary for 4.7 compiler is buggy :(
+    # TODO: look for right fix
+    set( __libstl                "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/4.6" )
+   else()
+    set( __libstl                "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}" )
+   endif()
+  else()
+   set( __libstl                "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++" )
+  endif()
+  set( ANDROID_STL_INCLUDE_DIRS "${__libstl}/include" "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/include" "${__libstl}/include/backward" )
+  if( EXISTS "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libgnustl_static.a" )
+   set( __libstl                "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libgnustl_static.a" )
+  else()
+   set( __libstl                "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libstdc++.a" )
+  endif()
+ elseif( ANDROID_STL MATCHES "c\\+\\+" )
+  set( ANDROID_EXCEPTIONS       ON )
+  set( ANDROID_RTTI             ON )
+  set( __libstl                "${ANDROID_NDK}/sources/cxx-stl/llvm-libc++" )
+  set( __libstl                "${__libstl}/libs/${ANDROID_NDK_ABI_NAME}/libc++_static.a" )
+  set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_NDK}/sources/android/support/include" "${ANDROID_NDK}/sources/cxx-stl/llvm-libc++/libcxx/include" "${ANDROID_NDK}/sources/cxx-stl/llvm-libc++abi/libcxxabi/include" )
+ else()
+  message( FATAL_ERROR "Unknown runtime: ${ANDROID_STL}" )
+ endif()
+
+ # find libsupc++.a - rtti & exceptions
+ if( ANDROID_STL STREQUAL "system_re" OR ANDROID_STL MATCHES "gnustl" )
+  set( __libsupcxx "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" ) # r8b or newer
+  if( NOT EXISTS "${__libsupcxx}" )
+   set( __libsupcxx "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" ) # r7-r8
+  endif()
+  if( NOT EXISTS "${__libsupcxx}" ) # before r7
+   if( ARMEABI_V7A )
+    if( ANDROID_FORCE_ARM_BUILD )
+     set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libsupc++.a" )
+    else()
+     set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libsupc++.a" )
+    endif()
+   elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD )
+    set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libsupc++.a" )
+   else()
+    set( __libsupcxx "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libsupc++.a" )
+   endif()
+  endif()
+  if( NOT EXISTS "${__libsupcxx}")
+   message( ERROR "Could not find libsupc++.a for a chosen platform. Either your NDK is not supported or is broken.")
+  endif()
+ endif()
+endif()
+
+
+# case of shared STL linkage
+if( ANDROID_STL MATCHES "shared" AND DEFINED __libstl )
+ string( REPLACE "_static.a" "_shared.so" __libstl "${__libstl}" )
+ if( NOT EXISTS "${__libstl}" )
+   message( FATAL_ERROR "Unable to find shared library ${__libstl}" )
+ endif()
+endif()
+
+
+# ccache support
+__INIT_VARIABLE( _ndk_ccache NDK_CCACHE ENV_NDK_CCACHE )
+if( _ndk_ccache )
+ if( DEFINED NDK_CCACHE AND NOT EXISTS NDK_CCACHE )
+  unset( NDK_CCACHE CACHE )
+ endif()
+ find_program( NDK_CCACHE "${_ndk_ccache}" DOC "The path to ccache binary")
+else()
+ unset( NDK_CCACHE CACHE )
+endif()
+unset( _ndk_ccache )
+
+
+# setup the cross-compiler
+if( NOT CMAKE_C_COMPILER )
+ if( NDK_CCACHE AND NOT ANDROID_SYSROOT MATCHES "[ ;\"]" )
+  set( CMAKE_C_COMPILER   "${NDK_CCACHE}" CACHE PATH "ccache as C compiler" )
+  set( CMAKE_CXX_COMPILER "${NDK_CCACHE}" CACHE PATH "ccache as C++ compiler" )
+  if( ANDROID_COMPILER_IS_CLANG )
+   set( CMAKE_C_COMPILER_ARG1   "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}"   CACHE PATH "C compiler")
+   set( CMAKE_CXX_COMPILER_ARG1 "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler")
+  else()
+   set( CMAKE_C_COMPILER_ARG1   "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}" CACHE PATH "C compiler")
+   set( CMAKE_CXX_COMPILER_ARG1 "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler")
+  endif()
+ else()
+  if( ANDROID_COMPILER_IS_CLANG )
+   set( CMAKE_C_COMPILER   "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}${TOOL_OS_SUFFIX}"   CACHE PATH "C compiler")
+   set( CMAKE_CXX_COMPILER "${ANDROID_CLANG_TOOLCHAIN_ROOT}/bin/${_clang_name}++${TOOL_OS_SUFFIX}" CACHE PATH "C++ compiler")
+  else()
+   set( CMAKE_C_COMPILER   "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"    CACHE PATH "C compiler" )
+   set( CMAKE_CXX_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}"    CACHE PATH "C++ compiler" )
+  endif()
+ endif()
+ set( CMAKE_ASM_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"     CACHE PATH "assembler" )
+ set( CMAKE_STRIP        "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-strip${TOOL_OS_SUFFIX}"   CACHE PATH "strip" )
+ if( EXISTS "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc-ar${TOOL_OS_SUFFIX}" )
+  # Use gcc-ar if we have it for better LTO support.
+  set( CMAKE_AR           "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc-ar${TOOL_OS_SUFFIX}"      CACHE PATH "archive" )
+ else()
+  set( CMAKE_AR           "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ar${TOOL_OS_SUFFIX}"      CACHE PATH "archive" )
+ endif()
+ set( CMAKE_LINKER       "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ld${TOOL_OS_SUFFIX}"      CACHE PATH "linker" )
+ set( CMAKE_NM           "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-nm${TOOL_OS_SUFFIX}"      CACHE PATH "nm" )
+ set( CMAKE_OBJCOPY      "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-objcopy${TOOL_OS_SUFFIX}" CACHE PATH "objcopy" )
+ set( CMAKE_OBJDUMP      "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-objdump${TOOL_OS_SUFFIX}" CACHE PATH "objdump" )
+ set( CMAKE_RANLIB       "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ranlib${TOOL_OS_SUFFIX}"  CACHE PATH "ranlib" )
+endif()
+
+set( _CMAKE_TOOLCHAIN_PREFIX "${ANDROID_TOOLCHAIN_MACHINE_NAME}-" )
+if( CMAKE_VERSION VERSION_LESS 2.8.5 )
+ set( CMAKE_ASM_COMPILER_ARG1 "-c" )
+endif()
+if( APPLE )
+ find_program( CMAKE_INSTALL_NAME_TOOL NAMES install_name_tool )
+ if( NOT CMAKE_INSTALL_NAME_TOOL )
+  message( FATAL_ERROR "Could not find install_name_tool, please check your installation." )
+ endif()
+ mark_as_advanced( CMAKE_INSTALL_NAME_TOOL )
+endif()
+
+# Force set compilers because standard identification works badly for us
+if( CMAKE_VERSION VERSION_LESS 3.5.0 )
+  include( CMakeForceCompiler )
+  CMAKE_FORCE_C_COMPILER( "${CMAKE_C_COMPILER}" GNU )
+endif()
+if( ANDROID_COMPILER_IS_CLANG )
+ set( CMAKE_C_COMPILER_ID Clang )
+endif()
+set( CMAKE_C_PLATFORM_ID Linux )
+if( X86_64 OR MIPS64 OR ARM64_V8A )
+ set( CMAKE_C_SIZEOF_DATA_PTR 8 )
+else()
+ set( CMAKE_C_SIZEOF_DATA_PTR 4 )
+endif()
+set( CMAKE_C_HAS_ISYSROOT 1 )
+set( CMAKE_C_COMPILER_ABI ELF )
+if( CMAKE_VERSION VERSION_LESS 3.5.0 )
+  CMAKE_FORCE_CXX_COMPILER( "${CMAKE_CXX_COMPILER}" GNU )
+endif()
+if( ANDROID_COMPILER_IS_CLANG )
+ set( CMAKE_CXX_COMPILER_ID Clang)
+endif()
+set( CMAKE_CXX_PLATFORM_ID Linux )
+set( CMAKE_CXX_SIZEOF_DATA_PTR ${CMAKE_C_SIZEOF_DATA_PTR} )
+set( CMAKE_CXX_HAS_ISYSROOT 1 )
+set( CMAKE_CXX_COMPILER_ABI ELF )
+set( CMAKE_CXX_SOURCE_FILE_EXTENSIONS cc cp cxx cpp CPP c++ C )
+# force ASM compiler (required for CMake < 2.8.5)
+set( CMAKE_ASM_COMPILER_ID_RUN TRUE )
+set( CMAKE_ASM_COMPILER_ID GNU )
+set( CMAKE_ASM_COMPILER_WORKS TRUE )
+set( CMAKE_ASM_COMPILER_FORCED TRUE )
+set( CMAKE_COMPILER_IS_GNUASM 1)
+set( CMAKE_ASM_SOURCE_FILE_EXTENSIONS s S asm )
+
+foreach( lang C CXX ASM )
+ if( ANDROID_COMPILER_IS_CLANG )
+  set( CMAKE_${lang}_COMPILER_VERSION ${ANDROID_CLANG_VERSION} )
+ else()
+  set( CMAKE_${lang}_COMPILER_VERSION ${ANDROID_COMPILER_VERSION} )
+ endif()
+endforeach()
+
+# flags and definitions
+remove_definitions( -DANDROID )
+add_definitions( -DANDROID )
+
+if( ANDROID_SYSROOT MATCHES "[ ;\"]" )
+ if( CMAKE_HOST_WIN32 )
+  # try to convert path to 8.3 form
+  file( WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/cvt83.cmd" "@echo %~s1" )
+  execute_process( COMMAND "$ENV{ComSpec}" /c "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/cvt83.cmd" "${ANDROID_SYSROOT}"
+                   OUTPUT_VARIABLE __path OUTPUT_STRIP_TRAILING_WHITESPACE
+                   RESULT_VARIABLE __result ERROR_QUIET )
+  if( __result EQUAL 0 )
+   file( TO_CMAKE_PATH "${__path}" ANDROID_SYSROOT )
+   set( ANDROID_CXX_FLAGS "--sysroot=${ANDROID_SYSROOT}" )
+  else()
+   set( ANDROID_CXX_FLAGS "--sysroot=\"${ANDROID_SYSROOT}\"" )
+  endif()
+ else()
+  set( ANDROID_CXX_FLAGS "'--sysroot=${ANDROID_SYSROOT}'" )
+ endif()
+ if( NOT _CMAKE_IN_TRY_COMPILE )
+  # quotes can break try_compile and compiler identification
+  message(WARNING "Path to your Android NDK (or toolchain) has non-alphanumeric symbols.\nThe build might be broken.\n")
+ endif()
+else()
+ set( ANDROID_CXX_FLAGS "--sysroot=${ANDROID_SYSROOT}" )
+endif()
+
+# NDK flags
+if (ARM64_V8A )
+ set( ANDROID_CXX_FLAGS         "${ANDROID_CXX_FLAGS} -funwind-tables" )
+ set( ANDROID_CXX_FLAGS_RELEASE "-fomit-frame-pointer -fstrict-aliasing" )
+ set( ANDROID_CXX_FLAGS_DEBUG   "-fno-omit-frame-pointer -fno-strict-aliasing" )
+ if( NOT ANDROID_COMPILER_IS_CLANG )
+  set( ANDROID_CXX_FLAGS_RELEASE "${ANDROID_CXX_FLAGS_RELEASE} -funswitch-loops -finline-limit=300" )
+ endif()
+elseif( ARMEABI OR ARMEABI_V7A OR ARMEABI_V7A_HARD)
+ set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -funwind-tables" )
+ if( NOT ANDROID_FORCE_ARM_BUILD AND NOT ARMEABI_V6 )
+  set( ANDROID_CXX_FLAGS_RELEASE "-mthumb -fomit-frame-pointer -fno-strict-aliasing" )
+  set( ANDROID_CXX_FLAGS_DEBUG   "-marm -fno-omit-frame-pointer -fno-strict-aliasing" )
+  if( NOT ANDROID_COMPILER_IS_CLANG )
+   set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -finline-limit=64" )
+  endif()
+ else()
+  # always compile ARMEABI_V6 in arm mode; otherwise there is no difference from ARMEABI
+  set( ANDROID_CXX_FLAGS_RELEASE "-marm -fomit-frame-pointer -fstrict-aliasing" )
+  set( ANDROID_CXX_FLAGS_DEBUG   "-marm -fno-omit-frame-pointer -fno-strict-aliasing" )
+  if( NOT ANDROID_COMPILER_IS_CLANG )
+   set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -funswitch-loops -finline-limit=300" )
+  endif()
+ endif()
+elseif( X86 OR X86_64 )
+ set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -funwind-tables" )
+ if( NOT ANDROID_COMPILER_IS_CLANG )
+  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -funswitch-loops -finline-limit=300" )
+ endif()
+ set( ANDROID_CXX_FLAGS_RELEASE "-fomit-frame-pointer -fstrict-aliasing" )
+ set( ANDROID_CXX_FLAGS_DEBUG   "-fno-omit-frame-pointer -fno-strict-aliasing" )
+elseif( MIPS OR MIPS64 )
+ set( ANDROID_CXX_FLAGS         "${ANDROID_CXX_FLAGS} -fno-strict-aliasing -finline-functions -funwind-tables -fmessage-length=0" )
+ set( ANDROID_CXX_FLAGS_RELEASE "-fomit-frame-pointer" )
+ set( ANDROID_CXX_FLAGS_DEBUG   "-fno-omit-frame-pointer" )
+ if( NOT ANDROID_COMPILER_IS_CLANG )
+  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -fno-inline-functions-called-once -fgcse-after-reload -frerun-cse-after-loop -frename-registers" )
+  set( ANDROID_CXX_FLAGS_RELEASE "${ANDROID_CXX_FLAGS_RELEASE} -funswitch-loops -finline-limit=300" )
+ endif()
+elseif()
+ set( ANDROID_CXX_FLAGS_RELEASE "" )
+ set( ANDROID_CXX_FLAGS_DEBUG   "" )
+endif()
+
+set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -fsigned-char" ) # good/necessary when porting desktop libraries
+
+if( NOT X86 AND NOT ANDROID_COMPILER_IS_CLANG )
+ set( ANDROID_CXX_FLAGS "-Wno-psabi ${ANDROID_CXX_FLAGS}" )
+endif()
+
+if( NOT ANDROID_COMPILER_VERSION VERSION_LESS "4.6" )
+ set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -no-canonical-prefixes" ) # see https://android-review.googlesource.com/#/c/47564/
+endif()
+
+# ABI-specific flags
+if( ARMEABI_V7A_HARD )
+ set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv7-a -mfloat-abi=hard -mhard-float -D_NDK_MATH_NO_SOFTFP=1" )
+ if( NEON )
+  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=neon" )
+ elseif( VFPV3 )
+  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3" )
+ else()
+  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3-d16" )
+ endif()
+elseif( ARMEABI_V7A )
+ set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv7-a -mfloat-abi=softfp" )
+ if( NEON )
+  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=neon" )
+ elseif( VFPV3 )
+  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3" )
+ else()
+  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3-d16" )
+ endif()
+
+elseif( ARMEABI_V6 )
+ set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv6 -mfloat-abi=softfp -mfpu=vfp" ) # vfp == vfpv2
+elseif( ARMEABI )
+ set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv5te -mtune=xscale -msoft-float" )
+endif()
+
+if( ANDROID_STL MATCHES "gnustl" AND (EXISTS "${__libstl}" OR EXISTS "${__libsupcxx}") )
+ set( CMAKE_CXX_CREATE_SHARED_LIBRARY "<CMAKE_C_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>" )
+ set( CMAKE_CXX_CREATE_SHARED_MODULE  "<CMAKE_C_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>" )
+ set( CMAKE_CXX_LINK_EXECUTABLE       "<CMAKE_C_COMPILER> <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>" )
+else()
+ set( CMAKE_CXX_CREATE_SHARED_LIBRARY "<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>" )
+ set( CMAKE_CXX_CREATE_SHARED_MODULE  "<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>" )
+ set( CMAKE_CXX_LINK_EXECUTABLE       "<CMAKE_CXX_COMPILER> <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>" )
+endif()
+
+# STL
+if( EXISTS "${__libstl}" OR EXISTS "${__libsupcxx}" )
+ if( EXISTS "${__libstl}" )
+  set( CMAKE_CXX_CREATE_SHARED_LIBRARY "${CMAKE_CXX_CREATE_SHARED_LIBRARY} \"${__libstl}\"" )
+  set( CMAKE_CXX_CREATE_SHARED_MODULE  "${CMAKE_CXX_CREATE_SHARED_MODULE} \"${__libstl}\"" )
+  set( CMAKE_CXX_LINK_EXECUTABLE       "${CMAKE_CXX_LINK_EXECUTABLE} \"${__libstl}\"" )
+ endif()
+ if( EXISTS "${__libsupcxx}" )
+  set( CMAKE_CXX_CREATE_SHARED_LIBRARY "${CMAKE_CXX_CREATE_SHARED_LIBRARY} \"${__libsupcxx}\"" )
+  set( CMAKE_CXX_CREATE_SHARED_MODULE  "${CMAKE_CXX_CREATE_SHARED_MODULE} \"${__libsupcxx}\"" )
+  set( CMAKE_CXX_LINK_EXECUTABLE       "${CMAKE_CXX_LINK_EXECUTABLE} \"${__libsupcxx}\"" )
+  # C objects:
+  set( CMAKE_C_CREATE_SHARED_LIBRARY "<CMAKE_C_COMPILER> <CMAKE_SHARED_LIBRARY_C_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_C_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>" )
+  set( CMAKE_C_CREATE_SHARED_MODULE  "<CMAKE_C_COMPILER> <CMAKE_SHARED_LIBRARY_C_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_C_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>" )
+  set( CMAKE_C_LINK_EXECUTABLE       "<CMAKE_C_COMPILER> <FLAGS> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>" )
+  set( CMAKE_C_CREATE_SHARED_LIBRARY "${CMAKE_C_CREATE_SHARED_LIBRARY} \"${__libsupcxx}\"" )
+  set( CMAKE_C_CREATE_SHARED_MODULE  "${CMAKE_C_CREATE_SHARED_MODULE} \"${__libsupcxx}\"" )
+  set( CMAKE_C_LINK_EXECUTABLE       "${CMAKE_C_LINK_EXECUTABLE} \"${__libsupcxx}\"" )
+ endif()
+ if( ANDROID_STL MATCHES "gnustl" )
+  if( NOT EXISTS "${ANDROID_LIBM_PATH}" )
+   set( ANDROID_LIBM_PATH -lm )
+  endif()
+  set( CMAKE_CXX_CREATE_SHARED_LIBRARY "${CMAKE_CXX_CREATE_SHARED_LIBRARY} ${ANDROID_LIBM_PATH}" )
+  set( CMAKE_CXX_CREATE_SHARED_MODULE  "${CMAKE_CXX_CREATE_SHARED_MODULE} ${ANDROID_LIBM_PATH}" )
+  set( CMAKE_CXX_LINK_EXECUTABLE       "${CMAKE_CXX_LINK_EXECUTABLE} ${ANDROID_LIBM_PATH}" )
+ endif()
+endif()
+
+# variables controlling optional build flags
+if( ANDROID_NDK_RELEASE_NUM LESS 7000 ) # before r7
+ # libGLESv2.so in NDK's prior to r7 refers to missing external symbols.
+ # So this flag option is required for all projects using OpenGL from native.
+ __INIT_VARIABLE( ANDROID_SO_UNDEFINED                      VALUES ON )
+else()
+ __INIT_VARIABLE( ANDROID_SO_UNDEFINED                      VALUES OFF )
+endif()
+__INIT_VARIABLE( ANDROID_NO_UNDEFINED                       VALUES ON )
+__INIT_VARIABLE( ANDROID_FUNCTION_LEVEL_LINKING             VALUES ON )
+__INIT_VARIABLE( ANDROID_GOLD_LINKER                        VALUES ON )
+__INIT_VARIABLE( ANDROID_NOEXECSTACK                        VALUES ON )
+__INIT_VARIABLE( ANDROID_RELRO                              VALUES ON )
+
+set( ANDROID_NO_UNDEFINED           ${ANDROID_NO_UNDEFINED}           CACHE BOOL "Show all undefined symbols as linker errors" )
+set( ANDROID_SO_UNDEFINED           ${ANDROID_SO_UNDEFINED}           CACHE BOOL "Allows or disallows undefined symbols in shared libraries" )
+set( ANDROID_FUNCTION_LEVEL_LINKING ${ANDROID_FUNCTION_LEVEL_LINKING} CACHE BOOL "Put each function in separate section and enable garbage collection of unused input sections at link time" )
+set( ANDROID_GOLD_LINKER            ${ANDROID_GOLD_LINKER}            CACHE BOOL "Enables gold linker" )
+set( ANDROID_NOEXECSTACK            ${ANDROID_NOEXECSTACK}            CACHE BOOL "Allows or disallows undefined symbols in shared libraries" )
+set( ANDROID_RELRO                  ${ANDROID_RELRO}                  CACHE BOOL "Enables RELRO - a memory corruption mitigation technique" )
+mark_as_advanced( ANDROID_NO_UNDEFINED ANDROID_SO_UNDEFINED ANDROID_FUNCTION_LEVEL_LINKING ANDROID_GOLD_LINKER ANDROID_NOEXECSTACK ANDROID_RELRO )
+
+# linker flags
+set( ANDROID_LINKER_FLAGS "" )
+
+if( ARMEABI_V7A )
+ # this is *required* to use the following linker flags that routes around
+ # a CPU bug in some Cortex-A8 implementations:
+ set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--fix-cortex-a8" )
+endif()
+
+if( ARMEABI_V7A_HARD )
+ set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--no-warn-mismatch -lm_hard" )
+endif()
+
+if( ANDROID_NO_UNDEFINED )
+ if( MIPS )
+  # there is some sysroot-related problem in mips linker...
+  if( NOT ANDROID_SYSROOT MATCHES "[ ;\"]" )
+   set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--no-undefined -Wl,-rpath-link,${ANDROID_SYSROOT}/usr/lib" )
+  endif()
+ else()
+  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--no-undefined" )
+ endif()
+endif()
+
+if( ANDROID_SO_UNDEFINED )
+ set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-allow-shlib-undefined" )
+endif()
+
+if( ANDROID_FUNCTION_LEVEL_LINKING )
+ set( ANDROID_CXX_FLAGS    "${ANDROID_CXX_FLAGS} -fdata-sections -ffunction-sections" )
+ set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--gc-sections" )
+endif()
+
+if( ANDROID_COMPILER_VERSION VERSION_EQUAL "4.6" )
+ if( ANDROID_GOLD_LINKER AND (CMAKE_HOST_UNIX OR ANDROID_NDK_RELEASE_NUM GREATER 8002) AND (ARMEABI OR ARMEABI_V7A OR ARMEABI_V7A_HARD OR X86) )
+  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -fuse-ld=gold" )
+ elseif( ANDROID_NDK_RELEASE_NUM GREATER 8002 ) # after r8b
+  set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -fuse-ld=bfd" )
+ elseif( ANDROID_NDK_RELEASE STREQUAL "r8b" AND ARMEABI AND NOT _CMAKE_IN_TRY_COMPILE )
+  message( WARNING "The default bfd linker from arm GCC 4.6 toolchain can fail with 'unresolvable R_ARM_THM_CALL relocation' error message. See https://code.google.com/p/android/issues/detail?id=35342
+  On Linux and OS X host platform you can workaround this problem using gold linker (default).
+  Rerun cmake with -DANDROID_GOLD_LINKER=ON option in case of problems.
+" )
+ endif()
+endif() # version 4.6
+
+if( ANDROID_NOEXECSTACK )
+ if( ANDROID_COMPILER_IS_CLANG )
+  set( ANDROID_CXX_FLAGS    "${ANDROID_CXX_FLAGS} -Xclang -mnoexecstack" )
+ else()
+  set( ANDROID_CXX_FLAGS    "${ANDROID_CXX_FLAGS} -Wa,--noexecstack" )
+ endif()
+ set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-z,noexecstack" )
+endif()
+
+if( ANDROID_RELRO )
+ set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-z,relro -Wl,-z,now" )
+endif()
+
+if( ANDROID_COMPILER_IS_CLANG )
+ set( ANDROID_CXX_FLAGS "-target ${ANDROID_LLVM_TRIPLE} -Qunused-arguments ${ANDROID_CXX_FLAGS}" )
+ if( BUILD_WITH_ANDROID_NDK )
+  set( ANDROID_CXX_FLAGS "-gcc-toolchain ${ANDROID_TOOLCHAIN_ROOT} ${ANDROID_CXX_FLAGS}" )
+ endif()
+endif()
+
+# cache flags
+set( CMAKE_CXX_FLAGS           ""                        CACHE STRING "c++ flags" )
+set( CMAKE_C_FLAGS             ""                        CACHE STRING "c flags" )
+set( CMAKE_CXX_FLAGS_RELEASE   "-O3 -DNDEBUG"            CACHE STRING "c++ Release flags" )
+set( CMAKE_C_FLAGS_RELEASE     "-O3 -DNDEBUG"            CACHE STRING "c Release flags" )
+set( CMAKE_CXX_FLAGS_DEBUG     "-O0 -g -DDEBUG -D_DEBUG" CACHE STRING "c++ Debug flags" )
+set( CMAKE_C_FLAGS_DEBUG       "-O0 -g -DDEBUG -D_DEBUG" CACHE STRING "c Debug flags" )
+set( CMAKE_SHARED_LINKER_FLAGS ""                        CACHE STRING "shared linker flags" )
+set( CMAKE_MODULE_LINKER_FLAGS ""                        CACHE STRING "module linker flags" )
+set( CMAKE_EXE_LINKER_FLAGS    "-Wl,-z,nocopyreloc"      CACHE STRING "executable linker flags" )
+
+# put flags to cache (for debug purpose only)
+set( ANDROID_CXX_FLAGS         "${ANDROID_CXX_FLAGS}"         CACHE INTERNAL "Android specific c/c++ flags" )
+set( ANDROID_CXX_FLAGS_RELEASE "${ANDROID_CXX_FLAGS_RELEASE}" CACHE INTERNAL "Android specific c/c++ Release flags" )
+set( ANDROID_CXX_FLAGS_DEBUG   "${ANDROID_CXX_FLAGS_DEBUG}"   CACHE INTERNAL "Android specific c/c++ Debug flags" )
+set( ANDROID_LINKER_FLAGS      "${ANDROID_LINKER_FLAGS}"      CACHE INTERNAL "Android specific c/c++ linker flags" )
+
+# finish flags
+set( CMAKE_CXX_FLAGS           "${ANDROID_CXX_FLAGS} ${CMAKE_CXX_FLAGS}" )
+set( CMAKE_C_FLAGS             "${ANDROID_CXX_FLAGS} ${CMAKE_C_FLAGS}" )
+set( CMAKE_CXX_FLAGS_RELEASE   "${ANDROID_CXX_FLAGS_RELEASE} ${CMAKE_CXX_FLAGS_RELEASE}" )
+set( CMAKE_C_FLAGS_RELEASE     "${ANDROID_CXX_FLAGS_RELEASE} ${CMAKE_C_FLAGS_RELEASE}" )
+set( CMAKE_CXX_FLAGS_DEBUG     "${ANDROID_CXX_FLAGS_DEBUG} ${CMAKE_CXX_FLAGS_DEBUG}" )
+set( CMAKE_C_FLAGS_DEBUG       "${ANDROID_CXX_FLAGS_DEBUG} ${CMAKE_C_FLAGS_DEBUG}" )
+set( CMAKE_SHARED_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}" )
+set( CMAKE_MODULE_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}" )
+set( CMAKE_EXE_LINKER_FLAGS    "${ANDROID_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}" )
+
+if( MIPS AND BUILD_WITH_ANDROID_NDK AND ANDROID_NDK_RELEASE STREQUAL "r8" )
+ set( CMAKE_SHARED_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_SHARED_LINKER_FLAGS}" )
+ set( CMAKE_MODULE_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.xsc ${CMAKE_MODULE_LINKER_FLAGS}" )
+ set( CMAKE_EXE_LINKER_FLAGS    "-Wl,-T,${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_GCC_TOOLCHAIN_NAME}/mipself.x ${CMAKE_EXE_LINKER_FLAGS}" )
+endif()
+
+# pie/pic
+if( NOT (ANDROID_NATIVE_API_LEVEL LESS 16) AND (NOT DEFINED ANDROID_APP_PIE OR ANDROID_APP_PIE) AND (CMAKE_VERSION VERSION_GREATER 2.8.8) )
+ set( CMAKE_POSITION_INDEPENDENT_CODE TRUE )
+ set( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fPIE -pie")
+else()
+ set( CMAKE_POSITION_INDEPENDENT_CODE FALSE )
+ set( CMAKE_CXX_FLAGS "-fpic ${CMAKE_CXX_FLAGS}" )
+ set( CMAKE_C_FLAGS   "-fpic ${CMAKE_C_FLAGS}" )
+endif()
+
+# configure rtti
+if( DEFINED ANDROID_RTTI AND ANDROID_STL_FORCE_FEATURES )
+ if( ANDROID_RTTI )
+  set( CMAKE_CXX_FLAGS "-frtti ${CMAKE_CXX_FLAGS}" )
+ else()
+  set( CMAKE_CXX_FLAGS "-fno-rtti ${CMAKE_CXX_FLAGS}" )
+ endif()
+endif()
+
+# configure exceptions
+if( DEFINED ANDROID_EXCEPTIONS AND ANDROID_STL_FORCE_FEATURES )
+ if( ANDROID_EXCEPTIONS )
+  set( CMAKE_CXX_FLAGS "-fexceptions ${CMAKE_CXX_FLAGS}" )
+  set( CMAKE_C_FLAGS "-fexceptions ${CMAKE_C_FLAGS}" )
+ else()
+  set( CMAKE_CXX_FLAGS "-fno-exceptions ${CMAKE_CXX_FLAGS}" )
+  set( CMAKE_C_FLAGS "-fno-exceptions ${CMAKE_C_FLAGS}" )
+ endif()
+endif()
+
+# global includes and link directories
+include_directories( SYSTEM "${ANDROID_SYSROOT_INCLUDE}" ${ANDROID_STL_INCLUDE_DIRS} )
+get_filename_component(__android_install_path "${CMAKE_INSTALL_PREFIX}/libs/${ANDROID_NDK_ABI_NAME}" ABSOLUTE) # avoid CMP0015 policy warning
+link_directories( "${__android_install_path}" )
+set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DANDROID -D__ANDROID_API__=${ANDROID_NATIVE_API_LEVEL}" )
+set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DANDROID -D__ANDROID_API__=${ANDROID_NATIVE_API_LEVEL}" )
+
+# detect if need link crtbegin_so.o explicitly
+if( NOT DEFINED ANDROID_EXPLICIT_CRT_LINK )
+ set( __cmd "${CMAKE_CXX_CREATE_SHARED_LIBRARY}" )
+ string( REPLACE "<CMAKE_CXX_COMPILER>" "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}" __cmd "${__cmd}" )
+ string( REPLACE "<CMAKE_C_COMPILER>"   "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}"   __cmd "${__cmd}" )
+ string( REPLACE "<CMAKE_SHARED_LIBRARY_CXX_FLAGS>" "${CMAKE_CXX_FLAGS}" __cmd "${__cmd}" )
+ string( REPLACE "<LANGUAGE_COMPILE_FLAGS>" "" __cmd "${__cmd}" )
+ string( REPLACE "<LINK_FLAGS>" "${CMAKE_SHARED_LINKER_FLAGS}" __cmd "${__cmd}" )
+ string( REPLACE "<CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS>" "-shared" __cmd "${__cmd}" )
+ string( REPLACE "<CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG>" "" __cmd "${__cmd}" )
+ string( REPLACE "<TARGET_SONAME>" "" __cmd "${__cmd}" )
+ string( REPLACE "<TARGET>" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/toolchain_crtlink_test.so" __cmd "${__cmd}" )
+ string( REPLACE "<OBJECTS>" "\"${ANDROID_SYSROOT}/usr/lib/crtbegin_so.o\"" __cmd "${__cmd}" )
+ string( REPLACE "<LINK_LIBRARIES>" "" __cmd "${__cmd}" )
+ separate_arguments( __cmd )
+ foreach( __var ANDROID_NDK ANDROID_NDK_TOOLCHAINS_PATH ANDROID_STANDALONE_TOOLCHAIN )
+  if( ${__var} )
+   set( __tmp "${${__var}}" )
+   separate_arguments( __tmp )
+   string( REPLACE "${__tmp}" "${${__var}}" __cmd "${__cmd}")
+  endif()
+ endforeach()
+ string( REPLACE "'" "" __cmd "${__cmd}" )
+ string( REPLACE "\"" "" __cmd "${__cmd}" )
+ execute_process( COMMAND ${__cmd} RESULT_VARIABLE __cmd_result OUTPUT_QUIET ERROR_QUIET )
+ if( __cmd_result EQUAL 0 )
+  set( ANDROID_EXPLICIT_CRT_LINK ON )
+ else()
+  set( ANDROID_EXPLICIT_CRT_LINK OFF )
+ endif()
+endif()
+
+if( ANDROID_EXPLICIT_CRT_LINK )
+ set( CMAKE_CXX_CREATE_SHARED_LIBRARY "${CMAKE_CXX_CREATE_SHARED_LIBRARY} \"${ANDROID_SYSROOT}/usr/lib/crtbegin_so.o\"" )
+ set( CMAKE_CXX_CREATE_SHARED_MODULE  "${CMAKE_CXX_CREATE_SHARED_MODULE} \"${ANDROID_SYSROOT}/usr/lib/crtbegin_so.o\"" )
+endif()
+
+# setup output directories
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT 1)
+endif()
+set( CMAKE_INSTALL_PREFIX "${ANDROID_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" )
+
+if( DEFINED LIBRARY_OUTPUT_PATH_ROOT
+      OR EXISTS "${CMAKE_SOURCE_DIR}/AndroidManifest.xml"
+      OR (EXISTS "${CMAKE_SOURCE_DIR}/../AndroidManifest.xml" AND EXISTS "${CMAKE_SOURCE_DIR}/../jni/") )
+  set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "Root for binaries output, set this to change where Android libs are installed to" )
+  if( NOT _CMAKE_IN_TRY_COMPILE )
+    if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
+      set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for applications" )
+    else()
+      set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications" )
+    endif()
+    set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for Android libs" )
+  endif()
+endif()
+
+# copy shaed stl library to build directory
+if( NOT _CMAKE_IN_TRY_COMPILE AND __libstl MATCHES "[.]so$" AND DEFINED LIBRARY_OUTPUT_PATH )
+  get_filename_component( __libstlname "${__libstl}" NAME )
+  execute_process( COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${__libstl}" "${LIBRARY_OUTPUT_PATH}/${__libstlname}" RESULT_VARIABLE __fileCopyProcess )
+  if( NOT __fileCopyProcess EQUAL 0 OR NOT EXISTS "${LIBRARY_OUTPUT_PATH}/${__libstlname}")
+    message( SEND_ERROR "Failed copying of ${__libstl} to the ${LIBRARY_OUTPUT_PATH}/${__libstlname}" )
+  endif()
+  unset( __fileCopyProcess )
+  unset( __libstlname )
+endif()
+
+
+# set these global flags for cmake client scripts to change behavior
+set( ANDROID True )
+set( BUILD_ANDROID True )
+
+# where is the target environment
+set( CMAKE_FIND_ROOT_PATH
+    "${ANDROID_TOOLCHAIN_ROOT}/bin"
+    "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}"
+    "${ANDROID_SYSROOT}"
+    "${ANDROID_NDK}/sysroot"  # NDK16+
+    "${CMAKE_INSTALL_PREFIX}"
+    "${CMAKE_INSTALL_PREFIX}/share" )
+
+# only search for libraries and includes in the ndk toolchain
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_LIBRARY)
+  set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_INCLUDE)
+  set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_PACKAGE)
+  set( CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY )
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_PROGRAM)
+  set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER )
+endif()
+
+macro(__cmake_find_root_save_and_reset)
+  foreach(v
+      CMAKE_FIND_ROOT_PATH_MODE_LIBRARY
+      CMAKE_FIND_ROOT_PATH_MODE_INCLUDE
+      CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+      CMAKE_FIND_ROOT_PATH_MODE_PROGRAM
+  )
+    set(__save_${v} ${${v}})
+    set(${v} NEVER)
+  endforeach()
+endmacro()
+
+macro(__cmake_find_root_restore)
+  foreach(v
+      CMAKE_FIND_ROOT_PATH_MODE_LIBRARY
+      CMAKE_FIND_ROOT_PATH_MODE_INCLUDE
+      CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+      CMAKE_FIND_ROOT_PATH_MODE_PROGRAM
+  )
+    set(${v} ${__save_${v}})
+    unset(__save_${v})
+  endforeach()
+endmacro()
+
+# macro to find packages on the host OS
+macro( find_host_package )
+ __cmake_find_root_save_and_reset()
+ if( CMAKE_HOST_WIN32 )
+  SET( WIN32 1 )
+  SET( UNIX )
+ elseif( CMAKE_HOST_APPLE )
+  SET( APPLE 1 )
+  SET( UNIX )
+ endif()
+ find_package( ${ARGN} )
+ SET( WIN32 )
+ SET( APPLE )
+ SET( UNIX 1 )
+ __cmake_find_root_restore()
+endmacro()
+
+
+# macro to find programs on the host OS
+macro( find_host_program )
+ __cmake_find_root_save_and_reset()
+ if( CMAKE_HOST_WIN32 )
+  SET( WIN32 1 )
+  SET( UNIX )
+ elseif( CMAKE_HOST_APPLE )
+  SET( APPLE 1 )
+  SET( UNIX )
+ endif()
+ find_program( ${ARGN} )
+ SET( WIN32 )
+ SET( APPLE )
+ SET( UNIX 1 )
+ __cmake_find_root_restore()
+endmacro()
+
+
+# export toolchain settings for the try_compile() command
+if( NOT _CMAKE_IN_TRY_COMPILE )
+ set( __toolchain_config "")
+ foreach( __var NDK_CCACHE  LIBRARY_OUTPUT_PATH_ROOT  ANDROID_FORBID_SYGWIN
+                ANDROID_NDK_HOST_X64
+                ANDROID_NDK
+                ANDROID_NDK_LAYOUT
+                ANDROID_STANDALONE_TOOLCHAIN
+                ANDROID_TOOLCHAIN_NAME
+                ANDROID_ABI
+                ANDROID_NATIVE_API_LEVEL
+                ANDROID_STL
+                ANDROID_STL_FORCE_FEATURES
+                ANDROID_FORCE_ARM_BUILD
+                ANDROID_NO_UNDEFINED
+                ANDROID_SO_UNDEFINED
+                ANDROID_FUNCTION_LEVEL_LINKING
+                ANDROID_GOLD_LINKER
+                ANDROID_NOEXECSTACK
+                ANDROID_RELRO
+                ANDROID_LIBM_PATH
+                ANDROID_EXPLICIT_CRT_LINK
+                ANDROID_APP_PIE
+                )
+  if( DEFINED ${__var} )
+   if( ${__var} MATCHES " ")
+    set( __toolchain_config "${__toolchain_config}set( ${__var} \"${${__var}}\" CACHE INTERNAL \"\" )\n" )
+   else()
+    set( __toolchain_config "${__toolchain_config}set( ${__var} ${${__var}} CACHE INTERNAL \"\" )\n" )
+   endif()
+  endif()
+ endforeach()
+ file( WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/android.toolchain.config.cmake" "${__toolchain_config}" )
+ unset( __toolchain_config )
+endif()
+
+
+# force cmake to produce / instead of \ in build commands for Ninja generator
+if( CMAKE_GENERATOR MATCHES "Ninja" AND CMAKE_HOST_WIN32 )
+ # it is a bad hack after all
+ # CMake generates Ninja makefiles with UNIX paths only if it thinks that we are going to build with MinGW
+ set( CMAKE_COMPILER_IS_MINGW TRUE ) # tell CMake that we are MinGW
+ set( CMAKE_CROSSCOMPILING TRUE )    # stop recursion
+ enable_language( C )
+ enable_language( CXX )
+ # unset( CMAKE_COMPILER_IS_MINGW ) # can't unset because CMake does not convert back-slashes in response files without it
+ unset( MINGW )
+endif()
+
+
+# Variables controlling behavior or set by cmake toolchain:
+#   ANDROID_ABI : "armeabi-v7a" (default), "armeabi", "armeabi-v7a with NEON", "armeabi-v7a-hard with NEON", "armeabi-v7a with VFPV3", "armeabi-v6 with VFP", "x86", "mips", "arm64-v8a", "x86_64", "mips64"
+#   ANDROID_NATIVE_API_LEVEL : 3,4,5,8,9,14,15,16,17,18,19,21 (depends on NDK version)
+#   ANDROID_STL : gnustl_static/gnustl_shared/stlport_static/stlport_shared/gabi++_static/gabi++_shared/system_re/system/none
+#   ANDROID_FORBID_SYGWIN : ON/OFF
+#   ANDROID_NO_UNDEFINED : ON/OFF
+#   ANDROID_SO_UNDEFINED : OFF/ON  (default depends on NDK version)
+#   ANDROID_FUNCTION_LEVEL_LINKING : ON/OFF
+#   ANDROID_GOLD_LINKER : ON/OFF
+#   ANDROID_NOEXECSTACK : ON/OFF
+#   ANDROID_RELRO : ON/OFF
+#   ANDROID_FORCE_ARM_BUILD : ON/OFF
+#   ANDROID_STL_FORCE_FEATURES : ON/OFF
+#   ANDROID_LIBM_PATH : path to libm.so (set to something like $(TOP)/out/target/product/<product_name>/obj/lib/libm.so) to workaround unresolved `sincos`
+# Can be set only at the first run:
+#   ANDROID_NDK : path to your NDK install
+#   NDK_CCACHE : path to your ccache executable
+#   ANDROID_TOOLCHAIN_NAME : the NDK name of compiler toolchain
+#   ANDROID_NDK_HOST_X64 : try to use x86_64 toolchain (default for x64 host systems)
+#   ANDROID_NDK_LAYOUT : the inner NDK structure (RELEASE, LINARO, ANDROID)
+#   LIBRARY_OUTPUT_PATH_ROOT : <any valid path>
+#   ANDROID_STANDALONE_TOOLCHAIN
+#
+# Primary read-only variables:
+#   ANDROID : always TRUE
+#   ARMEABI : TRUE for arm v6 and older devices
+#   ARMEABI_V6 : TRUE for arm v6
+#   ARMEABI_V7A : TRUE for arm v7a
+#   ARMEABI_V7A_HARD : TRUE for arm v7a with hardfp
+#   ARM64_V8A : TRUE for arm64-v8a
+#   NEON : TRUE if NEON unit is enabled
+#   VFPV3 : TRUE if VFP version 3 is enabled
+#   X86 : TRUE if configured for x86
+#   X86_64 : TRUE if configured for x86_64
+#   MIPS : TRUE if configured for mips
+#   MIPS64 : TRUE if configured for mips64
+#   BUILD_WITH_ANDROID_NDK : TRUE if NDK is used
+#   BUILD_WITH_STANDALONE_TOOLCHAIN : TRUE if standalone toolchain is used
+#   ANDROID_NDK_HOST_SYSTEM_NAME : "windows", "linux-x86" or "darwin-x86" depending on host platform
+#   ANDROID_NDK_ABI_NAME : "armeabi", "armeabi-v7a", "armeabi-v7a-hard", "x86", "mips", "arm64-v8a", "x86_64", "mips64" depending on ANDROID_ABI
+#   ANDROID_NDK_RELEASE : from r5 to r10d; set only for NDK
+#   ANDROID_NDK_RELEASE_NUM : numeric ANDROID_NDK_RELEASE version (1000*major+minor)
+#   ANDROID_ARCH_NAME : "arm", "x86", "mips", "arm64", "x86_64", "mips64" depending on ANDROID_ABI
+#   ANDROID_SYSROOT : path to the compiler sysroot
+#   ANDROID_SYSROOT_INCLUDE : paths to system include paths
+#   TOOL_OS_SUFFIX : "" or ".exe" depending on host platform
+#   ANDROID_COMPILER_IS_CLANG : TRUE if clang compiler is used
+#
+# Secondary (less stable) read-only variables:
+#   ANDROID_COMPILER_VERSION : GCC version used (not Clang version)
+#   ANDROID_CLANG_VERSION : version of clang compiler if clang is used
+#   ANDROID_CXX_FLAGS : C/C++ compiler flags required by Android platform
+#   ANDROID_SUPPORTED_ABIS : list of currently allowed values for ANDROID_ABI
+#   ANDROID_TOOLCHAIN_MACHINE_NAME : "arm-linux-androideabi", "arm-eabi" or "i686-android-linux"
+#   ANDROID_TOOLCHAIN_ROOT : path to the top level of toolchain (standalone or placed inside NDK)
+#   ANDROID_CLANG_TOOLCHAIN_ROOT : path to clang tools
+#   ANDROID_SUPPORTED_NATIVE_API_LEVELS : list of native API levels found inside NDK
+#   ANDROID_STL_INCLUDE_DIRS : stl include paths
+#   ANDROID_RTTI : if rtti is enabled by the runtime
+#   ANDROID_EXCEPTIONS : if exceptions are enabled by the runtime
+#   ANDROID_GCC_TOOLCHAIN_NAME : read-only, differs from ANDROID_TOOLCHAIN_NAME only if clang is used
+#
+# Defaults:
+#   ANDROID_DEFAULT_NDK_API_LEVEL
+#   ANDROID_DEFAULT_NDK_API_LEVEL_${ARCH}
+#   ANDROID_NDK_SEARCH_PATHS
+#   ANDROID_SUPPORTED_ABIS_${ARCH}
+#   ANDROID_SUPPORTED_NDK_VERSIONS
diff --git a/C++/opencv-4.7.0/platforms/android/build-tests/test_cmake_build.py b/C++/opencv-4.7.0/platforms/android/build-tests/test_cmake_build.py
new file mode 100644
index 00000000..25d185b8
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/build-tests/test_cmake_build.py
@@ -0,0 +1,154 @@
+#!/usr/bin/env python
+
+import unittest
+import os, sys, subprocess, argparse, shutil, re
+import logging as log
+
+log.basicConfig(format='%(message)s', level=log.DEBUG)
+
+CMAKE_TEMPLATE='''\
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+
+# Enable C++11
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+
+SET(PROJECT_NAME hello-android)
+PROJECT(${PROJECT_NAME})
+
+FIND_PACKAGE(OpenCV REQUIRED %(libset)s)
+FILE(GLOB srcs "*.cpp")
+
+ADD_EXECUTABLE(${PROJECT_NAME} ${srcs})
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${OpenCV_LIBS} dl z)
+'''
+
+CPP_TEMPLATE = '''\
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+using namespace cv;
+const char* message = "Hello Android!";
+int main(int argc, char* argv[])
+{
+  (void)argc; (void)argv;
+  printf("%s\\n", message);
+  Size textsize = getTextSize(message, FONT_HERSHEY_COMPLEX, 3, 5, 0);
+  Mat img(textsize.height + 20, textsize.width + 20, CV_32FC1, Scalar(230,230,230));
+  putText(img, message, Point(10, img.rows - 10), FONT_HERSHEY_COMPLEX, 3, Scalar(0, 0, 0), 5);
+  imwrite("/mnt/sdcard/HelloAndroid.png", img);
+  return 0;
+}
+'''
+
+#===================================================================================================
+
+class TestCmakeBuild(unittest.TestCase):
+    def __init__(self, libset, abi, cmake_vars, opencv_cmake_path, workdir, *args, **kwargs):
+        unittest.TestCase.__init__(self, *args, **kwargs)
+        self.libset = libset
+        self.abi = abi
+        self.cmake_vars = cmake_vars
+        self.opencv_cmake_path = opencv_cmake_path
+        self.workdir = workdir
+        self.srcdir = os.path.join(self.workdir, "src")
+        self.bindir = os.path.join(self.workdir, "build")
+
+    def shortDescription(self):
+        return "ABI: %s, LIBSET: %s" % (self.abi, self.libset)
+
+    def getCMakeToolchain(self):
+        if True:
+            toolchain = os.path.join(os.environ['ANDROID_NDK'], 'build', 'cmake', 'android.toolchain.cmake')
+            if os.path.exists(toolchain):
+                return toolchain
+        toolchain = os.path.join(self.opencv_cmake_path, "android.toolchain.cmake")
+        if os.path.exists(toolchain):
+            return toolchain
+        else:
+            raise Exception("Can't find toolchain")
+
+    def gen_cmakelists(self):
+        return CMAKE_TEMPLATE % {"libset": self.libset}
+
+    def gen_code(self):
+        return CPP_TEMPLATE
+
+    def write_src_file(self, fname, content):
+        with open(os.path.join(self.srcdir, fname), "w") as f:
+            f.write(content)
+
+    def setUp(self):
+        if os.path.exists(self.workdir):
+            shutil.rmtree(self.workdir)
+        os.mkdir(self.workdir)
+        os.mkdir(self.srcdir)
+        os.mkdir(self.bindir)
+        self.write_src_file("CMakeLists.txt", self.gen_cmakelists())
+        self.write_src_file("main.cpp", self.gen_code())
+        os.chdir(self.bindir)
+
+    def tearDown(self):
+        pass
+        #if os.path.exists(self.workdir):
+        #    shutil.rmtree(self.workdir)
+
+    def runTest(self):
+        cmd = [
+            "cmake",
+            "-GNinja",
+            "-DOpenCV_DIR=%s" % self.opencv_cmake_path,
+            "-DCMAKE_TOOLCHAIN_FILE=%s" % self.getCMakeToolchain(),
+            self.srcdir
+        ] + [ "-D{}={}".format(key, value) for key, value in self.cmake_vars.items() ]
+        log.info("Executing: %s" % cmd)
+        retcode = subprocess.call(cmd)
+        self.assertEqual(retcode, 0, "cmake failed")
+
+        cmd = ["ninja", "-v"]
+        log.info("Executing: %s" % cmd)
+        retcode = subprocess.call(cmd)
+        self.assertEqual(retcode, 0, "make failed")
+
+def suite(workdir, opencv_cmake_path):
+    abis = {
+        "armeabi-v7a": { "ANDROID_ABI": "armeabi-v7a", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_shared", 'ANDROID_NATIVE_API_LEVEL': "21" },
+        "arm64-v8a": { "ANDROID_ABI": "arm64-v8a", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_shared", 'ANDROID_NATIVE_API_LEVEL': "21" },
+        "x86": { "ANDROID_ABI": "x86", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_shared", 'ANDROID_NATIVE_API_LEVEL': "21" },
+        "x86_64": { "ANDROID_ABI": "x86_64", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_shared", 'ANDROID_NATIVE_API_LEVEL': "21" },
+    }
+
+    suite = unittest.TestSuite()
+    for libset in ["", "opencv_java"]:
+        for abi, cmake_vars in abis.items():
+            suite.addTest(TestCmakeBuild(libset, abi, cmake_vars, opencv_cmake_path,
+                    os.path.join(workdir, "{}-{}".format(abi, "static" if libset == "" else "shared"))))
+    return suite
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Test OpenCV for Android SDK with cmake')
+    parser.add_argument('--sdk_path', help="Path to Android SDK to use for build")
+    parser.add_argument('--ndk_path', help="Path to Android NDK to use for build")
+    parser.add_argument("--workdir", default="testspace", help="Working directory (and output)")
+    parser.add_argument("opencv_cmake_path", help="Path to folder with OpenCVConfig.cmake and android.toolchain.cmake (usually <SDK>/sdk/native/jni/")
+
+    args = parser.parse_args()
+
+    if args.sdk_path is not None:
+        os.environ["ANDROID_SDK"] = os.path.abspath(args.sdk_path)
+    if args.ndk_path is not None:
+        os.environ["ANDROID_NDK"] = os.path.abspath(args.ndk_path)
+
+    if not 'ANDROID_HOME' in os.environ and 'ANDROID_SDK' in os.environ:
+        os.environ['ANDROID_HOME'] = os.environ["ANDROID_SDK"]
+
+    print("Using SDK: %s" % os.environ["ANDROID_SDK"])
+    print("Using NDK: %s" % os.environ["ANDROID_NDK"])
+
+    workdir = os.path.abspath(args.workdir)
+    if not os.path.exists(workdir):
+        os.mkdir(workdir)
+    res = unittest.TextTestRunner(verbosity=3).run(suite(workdir, os.path.abspath(args.opencv_cmake_path)))
+    if not res.wasSuccessful():
+        sys.exit(res)
diff --git a/C++/opencv-4.7.0/platforms/android/build-tests/test_gradle.sh b/C++/opencv-4.7.0/platforms/android/build-tests/test_gradle.sh
new file mode 100644
index 00000000..9f1b233f
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/build-tests/test_gradle.sh
@@ -0,0 +1,37 @@
+#!/bin/bash -e
+SDK_DIR=$1
+echo "OpenCV Android SDK path: ${SDK_DIR}"
+
+ANDROID_HOME=${ANDROID_HOME:-${ANDROID_SDK_ROOT:-${ANDROID_SDK?Required ANDROID_HOME/ANDROID_SDK/ANDROID_SDK_ROOT}}}
+ANDROID_NDK=${ANDROID_NDK_HOME-${ANDROID_NDK:-${NDKROOT?Required ANDROID_NDK_HOME/ANDROID_NDK/NDKROOT}}}
+
+echo "Android SDK: ${ANDROID_HOME}"
+echo "Android NDK: ${ANDROID_NDK}"
+
+if [ ! -d "${ANDROID_HOME}" ]; then
+  echo "FATAL: Missing Android SDK directory"
+  exit 1
+fi
+if [ ! -d "${ANDROID_NDK}" ]; then
+  echo "FATAL: Missing Android NDK directory"
+  exit 1
+fi
+
+export ANDROID_HOME=${ANDROID_HOME}
+export ANDROID_SDK=${ANDROID_HOME}
+export ANDROID_SDK_ROOT=${ANDROID_HOME}
+
+export ANDROID_NDK=${ANDROID_NDK}
+export ANDROID_NDK_HOME=${ANDROID_NDK}
+
+echo "Cloning OpenCV Android SDK ..."
+rm -rf "test-gradle"
+cp -rp "${SDK_DIR}" "test-gradle"
+echo "Cloning OpenCV Android SDK ... Done!"
+
+echo "Run gradle ..."
+(cd "test-gradle/samples"; ./gradlew -i assemble)
+
+echo "#"
+echo "# Done!"
+echo "#"
diff --git a/C++/opencv-4.7.0/platforms/android/build_sdk.py b/C++/opencv-4.7.0/platforms/android/build_sdk.py
new file mode 100644
index 00000000..f445be10
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/build_sdk.py
@@ -0,0 +1,464 @@
+#!/usr/bin/env python
+
+import os, sys
+import argparse
+import glob
+import re
+import shutil
+import subprocess
+import time
+
+import logging as log
+import xml.etree.ElementTree as ET
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+class Fail(Exception):
+    def __init__(self, text=None):
+        self.t = text
+    def __str__(self):
+        return "ERROR" if self.t is None else self.t
+
+def execute(cmd, shell=False):
+    try:
+        log.debug("Executing: %s" % cmd)
+        log.info('Executing: ' + ' '.join(cmd))
+        retcode = subprocess.call(cmd, shell=shell)
+        if retcode < 0:
+            raise Fail("Child was terminated by signal: %s" % -retcode)
+        elif retcode > 0:
+            raise Fail("Child returned: %s" % retcode)
+    except OSError as e:
+        raise Fail("Execution failed: %d / %s" % (e.errno, e.strerror))
+
+def rm_one(d):
+    d = os.path.abspath(d)
+    if os.path.exists(d):
+        if os.path.isdir(d):
+            log.info("Removing dir: %s", d)
+            shutil.rmtree(d)
+        elif os.path.isfile(d):
+            log.info("Removing file: %s", d)
+            os.remove(d)
+
+def check_dir(d, create=False, clean=False):
+    d = os.path.abspath(d)
+    log.info("Check dir %s (create: %s, clean: %s)", d, create, clean)
+    if os.path.exists(d):
+        if not os.path.isdir(d):
+            raise Fail("Not a directory: %s" % d)
+        if clean:
+            for x in glob.glob(os.path.join(d, "*")):
+                rm_one(x)
+    else:
+        if create:
+            os.makedirs(d)
+    return d
+
+def check_executable(cmd):
+    try:
+        log.debug("Executing: %s" % cmd)
+        result = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        if not isinstance(result, str):
+            result = result.decode("utf-8")
+        log.debug("Result: %s" % (result+'\n').split('\n')[0])
+        return True
+    except Exception as e:
+        log.debug('Failed: %s' % e)
+        return False
+
+def determine_opencv_version(version_hpp_path):
+    # version in 2.4 - CV_VERSION_EPOCH.CV_VERSION_MAJOR.CV_VERSION_MINOR.CV_VERSION_REVISION
+    # version in master - CV_VERSION_MAJOR.CV_VERSION_MINOR.CV_VERSION_REVISION-CV_VERSION_STATUS
+    with open(version_hpp_path, "rt") as f:
+        data = f.read()
+        major = re.search(r'^#define\W+CV_VERSION_MAJOR\W+(\d+)$', data, re.MULTILINE).group(1)
+        minor = re.search(r'^#define\W+CV_VERSION_MINOR\W+(\d+)$', data, re.MULTILINE).group(1)
+        revision = re.search(r'^#define\W+CV_VERSION_REVISION\W+(\d+)$', data, re.MULTILINE).group(1)
+        version_status = re.search(r'^#define\W+CV_VERSION_STATUS\W+"([^"]*)"$', data, re.MULTILINE).group(1)
+        return "%(major)s.%(minor)s.%(revision)s%(version_status)s" % locals()
+
+# shutil.move fails if dst exists
+def move_smart(src, dst):
+    def move_recurse(subdir):
+        s = os.path.join(src, subdir)
+        d = os.path.join(dst, subdir)
+        if os.path.exists(d):
+            if os.path.isdir(d):
+                for item in os.listdir(s):
+                    move_recurse(os.path.join(subdir, item))
+            elif os.path.isfile(s):
+                shutil.move(s, d)
+        else:
+            shutil.move(s, d)
+    move_recurse('')
+
+# shutil.copytree fails if dst exists
+def copytree_smart(src, dst):
+    def copy_recurse(subdir):
+        s = os.path.join(src, subdir)
+        d = os.path.join(dst, subdir)
+        if os.path.exists(d):
+            if os.path.isdir(d):
+                for item in os.listdir(s):
+                    copy_recurse(os.path.join(subdir, item))
+            elif os.path.isfile(s):
+                shutil.copy2(s, d)
+        else:
+            if os.path.isdir(s):
+                shutil.copytree(s, d)
+            elif os.path.isfile(s):
+                shutil.copy2(s, d)
+    copy_recurse('')
+
+def get_highest_version(subdirs):
+    return max(subdirs, key=lambda dir: [int(comp) for comp in os.path.split(dir)[-1].split('.')])
+
+
+#===================================================================================================
+
+class ABI:
+    def __init__(self, platform_id, name, toolchain, ndk_api_level = None, cmake_vars = dict()):
+        self.platform_id = platform_id # platform code to add to apk version (for cmake)
+        self.name = name # general name (official Android ABI identifier)
+        self.toolchain = toolchain # toolchain identifier (for cmake)
+        self.cmake_vars = dict(
+            ANDROID_STL="gnustl_static",
+            ANDROID_ABI=self.name,
+            ANDROID_PLATFORM_ID=platform_id,
+        )
+        if toolchain is not None:
+            self.cmake_vars['ANDROID_TOOLCHAIN_NAME'] = toolchain
+        else:
+            self.cmake_vars['ANDROID_TOOLCHAIN'] = 'clang'
+            self.cmake_vars['ANDROID_STL'] = 'c++_shared'
+        if ndk_api_level:
+            self.cmake_vars['ANDROID_NATIVE_API_LEVEL'] = ndk_api_level
+        self.cmake_vars.update(cmake_vars)
+    def __str__(self):
+        return "%s (%s)" % (self.name, self.toolchain)
+    def haveIPP(self):
+        return self.name == "x86" or self.name == "x86_64"
+
+#===================================================================================================
+
+class Builder:
+    def __init__(self, workdir, opencvdir, config):
+        self.workdir = check_dir(workdir, create=True)
+        self.opencvdir = check_dir(opencvdir)
+        self.config = config
+        self.libdest = check_dir(os.path.join(self.workdir, "o4a"), create=True, clean=True)
+        self.resultdest = check_dir(os.path.join(self.workdir, 'OpenCV-android-sdk'), create=True, clean=True)
+        self.docdest = check_dir(os.path.join(self.workdir, 'OpenCV-android-sdk', 'sdk', 'java', 'javadoc'), create=True, clean=True)
+        self.extra_packs = []
+        self.opencv_version = determine_opencv_version(os.path.join(self.opencvdir, "modules", "core", "include", "opencv2", "core", "version.hpp"))
+        self.use_ccache = False if config.no_ccache else True
+        self.cmake_path = self.get_cmake()
+        self.ninja_path = self.get_ninja()
+        self.debug = True if config.debug else False
+        self.debug_info = True if config.debug_info else False
+        self.no_samples_build = True if config.no_samples_build else False
+        self.opencl = True if config.opencl else False
+        self.no_kotlin = True if config.no_kotlin else False
+        self.shared = True if config.shared else False
+
+    def get_cmake(self):
+        if not self.config.use_android_buildtools and check_executable(['cmake', '--version']):
+            log.info("Using cmake from PATH")
+            return 'cmake'
+        # look to see if Android SDK's cmake is installed
+        android_cmake = os.path.join(os.environ['ANDROID_SDK'], 'cmake')
+        if os.path.exists(android_cmake):
+            cmake_subdirs = [f for f in os.listdir(android_cmake) if check_executable([os.path.join(android_cmake, f, 'bin', 'cmake'), '--version'])]
+            if len(cmake_subdirs) > 0:
+                # there could be more than one - get the most recent
+                cmake_from_sdk = os.path.join(android_cmake, get_highest_version(cmake_subdirs), 'bin', 'cmake')
+                log.info("Using cmake from Android SDK: %s", cmake_from_sdk)
+                return cmake_from_sdk
+        raise Fail("Can't find cmake")
+
+    def get_ninja(self):
+        if not self.config.use_android_buildtools and check_executable(['ninja', '--version']):
+            log.info("Using ninja from PATH")
+            return 'ninja'
+        # Android SDK's cmake includes a copy of ninja - look to see if its there
+        android_cmake = os.path.join(os.environ['ANDROID_SDK'], 'cmake')
+        if os.path.exists(android_cmake):
+            cmake_subdirs = [f for f in os.listdir(android_cmake) if check_executable([os.path.join(android_cmake, f, 'bin', 'ninja'), '--version'])]
+            if len(cmake_subdirs) > 0:
+                # there could be more than one - just take the first one
+                ninja_from_sdk = os.path.join(android_cmake, cmake_subdirs[0], 'bin', 'ninja')
+                log.info("Using ninja from Android SDK: %s", ninja_from_sdk)
+                return ninja_from_sdk
+        raise Fail("Can't find ninja")
+
+    def get_toolchain_file(self):
+        if not self.config.force_opencv_toolchain:
+            toolchain = os.path.join(os.environ['ANDROID_NDK'], 'build', 'cmake', 'android.toolchain.cmake')
+            if os.path.exists(toolchain):
+                return toolchain
+        toolchain = os.path.join(SCRIPT_DIR, "android.toolchain.cmake")
+        if os.path.exists(toolchain):
+            return toolchain
+        else:
+            raise Fail("Can't find toolchain")
+
+    def get_engine_apk_dest(self, engdest):
+        return os.path.join(engdest, "platforms", "android", "service", "engine", ".build")
+
+    def add_extra_pack(self, ver, path):
+        if path is None:
+            return
+        self.extra_packs.append((ver, check_dir(path)))
+
+    def clean_library_build_dir(self):
+        for d in ["CMakeCache.txt", "CMakeFiles/", "bin/", "libs/", "lib/", "package/", "install/samples/"]:
+            rm_one(d)
+
+    def build_library(self, abi, do_install):
+        cmd = [self.cmake_path, "-GNinja"]
+        cmake_vars = dict(
+            CMAKE_TOOLCHAIN_FILE=self.get_toolchain_file(),
+            INSTALL_CREATE_DISTRIB="ON",
+            WITH_OPENCL="OFF",
+            BUILD_KOTLIN_EXTENSIONS="ON",
+            WITH_IPP=("ON" if abi.haveIPP() else "OFF"),
+            WITH_TBB="ON",
+            BUILD_EXAMPLES="OFF",
+            BUILD_TESTS="OFF",
+            BUILD_PERF_TESTS="OFF",
+            BUILD_DOCS="OFF",
+            BUILD_ANDROID_EXAMPLES=("OFF" if self.no_samples_build else "ON"),
+            INSTALL_ANDROID_EXAMPLES=("OFF" if self.no_samples_build else "ON"),
+        )
+        if self.ninja_path != 'ninja':
+            cmake_vars['CMAKE_MAKE_PROGRAM'] = self.ninja_path
+
+        if self.debug:
+            cmake_vars['CMAKE_BUILD_TYPE'] = "Debug"
+
+        if self.debug_info:  # Release with debug info
+            cmake_vars['BUILD_WITH_DEBUG_INFO'] = "ON"
+
+        if self.opencl:
+            cmake_vars['WITH_OPENCL'] = "ON"
+
+        if self.no_kotlin:
+            cmake_vars['BUILD_KOTLIN_EXTENSIONS'] = "OFF"
+
+        if self.shared:
+            cmake_vars['BUILD_SHARED_LIBS'] = "ON"
+
+        if self.config.modules_list is not None:
+            cmd.append("-DBUILD_LIST='%s'" % self.config.modules_list)
+
+        if self.config.extra_modules_path is not None:
+            cmd.append("-DOPENCV_EXTRA_MODULES_PATH='%s'" % self.config.extra_modules_path)
+
+        if self.use_ccache == True:
+            cmd.append("-DNDK_CCACHE=ccache")
+        if do_install:
+            cmd.extend(["-DBUILD_TESTS=ON", "-DINSTALL_TESTS=ON"])
+
+        cmake_vars.update(abi.cmake_vars)
+        cmd += [ "-D%s='%s'" % (k, v) for (k, v) in cmake_vars.items() if v is not None]
+        cmd.append(self.opencvdir)
+        execute(cmd)
+        # full parallelism for C++ compilation tasks
+        execute([self.ninja_path, "opencv_modules"])
+        # limit parallelism for building samples (avoid huge memory consumption)
+        if self.no_samples_build:
+            execute([self.ninja_path, "install" if (self.debug_info or self.debug) else "install/strip"])
+        else:
+            execute([self.ninja_path, "-j1" if (self.debug_info or self.debug) else "-j3", "install" if (self.debug_info or self.debug) else "install/strip"])
+
+    def build_javadoc(self):
+        classpaths = []
+        for dir, _, files in os.walk(os.environ["ANDROID_SDK"]):
+            for f in files:
+                if f == "android.jar" or f == "annotations.jar":
+                    classpaths.append(os.path.join(dir, f))
+        srcdir = os.path.join(self.resultdest, 'sdk', 'java', 'src')
+        dstdir = self.docdest
+        # synchronize with modules/java/jar/build.xml.in
+        shutil.copy2(os.path.join(SCRIPT_DIR, '../../doc/mymath.js'), dstdir)
+        cmd = [
+            "javadoc",
+            '-windowtitle', 'OpenCV %s Java documentation' % self.opencv_version,
+            '-doctitle', 'OpenCV Java documentation (%s)' % self.opencv_version,
+            "-nodeprecated",
+            "-public",
+            '-sourcepath', srcdir,
+            '-encoding', 'UTF-8',
+            '-charset', 'UTF-8',
+            '-docencoding', 'UTF-8',
+            '--allow-script-in-comments',
+            '-header',
+'''
+            <script>
+              var url = window.location.href;
+              var pos = url.lastIndexOf('/javadoc/');
+              url = pos >= 0 ? (url.substring(0, pos) + '/javadoc/mymath.js') : (window.location.origin + '/mymath.js');
+              var script = document.createElement('script');
+              script.src = '%s/MathJax.js?config=TeX-AMS-MML_HTMLorMML,' + url;
+              document.getElementsByTagName('head')[0].appendChild(script);
+            </script>
+''' % 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0',
+            '-bottom', 'Generated on %s / OpenCV %s' % (time.strftime("%Y-%m-%d %H:%M:%S"), self.opencv_version),
+            "-d", dstdir,
+            "-classpath", ":".join(classpaths),
+            '-subpackages', 'org.opencv',
+        ]
+        execute(cmd)
+
+    def gather_results(self):
+        # Copy all files
+        root = os.path.join(self.libdest, "install")
+        for item in os.listdir(root):
+            src = os.path.join(root, item)
+            dst = os.path.join(self.resultdest, item)
+            if os.path.isdir(src):
+                log.info("Copy dir: %s", item)
+                if self.config.force_copy:
+                    copytree_smart(src, dst)
+                else:
+                    move_smart(src, dst)
+            elif os.path.isfile(src):
+                log.info("Copy file: %s", item)
+                if self.config.force_copy:
+                    shutil.copy2(src, dst)
+                else:
+                    shutil.move(src, dst)
+
+def get_ndk_dir():
+    # look to see if Android NDK is installed
+    android_sdk_ndk = os.path.join(os.environ["ANDROID_SDK"], 'ndk')
+    android_sdk_ndk_bundle = os.path.join(os.environ["ANDROID_SDK"], 'ndk-bundle')
+    if os.path.exists(android_sdk_ndk):
+        ndk_subdirs = [f for f in os.listdir(android_sdk_ndk) if os.path.exists(os.path.join(android_sdk_ndk, f, 'package.xml'))]
+        if len(ndk_subdirs) > 0:
+            # there could be more than one - get the most recent
+            ndk_from_sdk = os.path.join(android_sdk_ndk, get_highest_version(ndk_subdirs))
+            log.info("Using NDK (side-by-side) from Android SDK: %s", ndk_from_sdk)
+            return ndk_from_sdk
+    if os.path.exists(os.path.join(android_sdk_ndk_bundle, 'package.xml')):
+        log.info("Using NDK bundle from Android SDK: %s", android_sdk_ndk_bundle)
+        return android_sdk_ndk_bundle
+    return None
+
+
+#===================================================================================================
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Build OpenCV for Android SDK')
+    parser.add_argument("work_dir", nargs='?', default='.', help="Working directory (and output)")
+    parser.add_argument("opencv_dir", nargs='?', default=os.path.join(SCRIPT_DIR, '../..'), help="Path to OpenCV source dir")
+    parser.add_argument('--config', default='ndk-18-api-level-21.config.py', type=str, help="Package build configuration", )
+    parser.add_argument('--ndk_path', help="Path to Android NDK to use for build")
+    parser.add_argument('--sdk_path', help="Path to Android SDK to use for build")
+    parser.add_argument('--use_android_buildtools', action="store_true", help='Use cmake/ninja build tools from Android SDK')
+    parser.add_argument("--modules_list", help="List of  modules to include for build")
+    parser.add_argument("--extra_modules_path", help="Path to extra modules to use for build")
+    parser.add_argument('--sign_with', help="Certificate to sign the Manager apk")
+    parser.add_argument('--build_doc', action="store_true", help="Build javadoc")
+    parser.add_argument('--no_ccache', action="store_true", help="Do not use ccache during library build")
+    parser.add_argument('--force_copy', action="store_true", help="Do not use file move during library build (useful for debug)")
+    parser.add_argument('--force_opencv_toolchain', action="store_true", help="Do not use toolchain from Android NDK")
+    parser.add_argument('--debug', action="store_true", help="Build 'Debug' binaries (CMAKE_BUILD_TYPE=Debug)")
+    parser.add_argument('--debug_info', action="store_true", help="Build with debug information (useful for Release mode: BUILD_WITH_DEBUG_INFO=ON)")
+    parser.add_argument('--no_samples_build', action="store_true", help="Do not build samples (speeds up build)")
+    parser.add_argument('--opencl', action="store_true", help="Enable OpenCL support")
+    parser.add_argument('--no_kotlin', action="store_true", help="Disable Kotlin extensions")
+    parser.add_argument('--shared', action="store_true", help="Build shared libraries")
+    args = parser.parse_args()
+
+    log.basicConfig(format='%(message)s', level=log.DEBUG)
+    log.debug("Args: %s", args)
+
+    if args.ndk_path is not None:
+        os.environ["ANDROID_NDK"] = args.ndk_path
+    if args.sdk_path is not None:
+        os.environ["ANDROID_SDK"] = args.sdk_path
+
+    if not 'ANDROID_HOME' in os.environ and 'ANDROID_SDK' in os.environ:
+        os.environ['ANDROID_HOME'] = os.environ["ANDROID_SDK"]
+
+    if not 'ANDROID_SDK' in os.environ:
+        raise Fail("SDK location not set. Either pass --sdk_path or set ANDROID_SDK environment variable")
+
+    # look for an NDK installed with the Android SDK
+    if not 'ANDROID_NDK' in os.environ and 'ANDROID_SDK' in os.environ:
+        sdk_ndk_dir = get_ndk_dir()
+        if sdk_ndk_dir:
+            os.environ['ANDROID_NDK'] = sdk_ndk_dir
+
+    if not 'ANDROID_NDK' in os.environ:
+        raise Fail("NDK location not set. Either pass --ndk_path or set ANDROID_NDK environment variable")
+
+    show_samples_build_warning = False
+    #also set ANDROID_NDK_HOME (needed by the gradle build)
+    if not 'ANDROID_NDK_HOME' in os.environ and 'ANDROID_NDK' in os.environ:
+        os.environ['ANDROID_NDK_HOME'] = os.environ["ANDROID_NDK"]
+        show_samples_build_warning = True
+
+    if not check_executable(['ccache', '--version']):
+        log.info("ccache not found - disabling ccache support")
+        args.no_ccache = True
+
+    if os.path.realpath(args.work_dir) == os.path.realpath(SCRIPT_DIR):
+        raise Fail("Specify workdir (building from script directory is not supported)")
+    if os.path.realpath(args.work_dir) == os.path.realpath(args.opencv_dir):
+        raise Fail("Specify workdir (building from OpenCV source directory is not supported)")
+
+    # Relative paths become invalid in sub-directories
+    if args.opencv_dir is not None and not os.path.isabs(args.opencv_dir):
+        args.opencv_dir = os.path.abspath(args.opencv_dir)
+    if args.extra_modules_path is not None and not os.path.isabs(args.extra_modules_path):
+        args.extra_modules_path = os.path.abspath(args.extra_modules_path)
+
+    cpath = args.config
+    if not os.path.exists(cpath):
+        cpath = os.path.join(SCRIPT_DIR, cpath)
+        if not os.path.exists(cpath):
+            raise Fail('Config "%s" is missing' % args.config)
+    with open(cpath, 'r') as f:
+        cfg = f.read()
+    print("Package configuration:")
+    print('=' * 80)
+    print(cfg.strip())
+    print('=' * 80)
+
+    ABIs = None  # make flake8 happy
+    exec(compile(cfg, cpath, 'exec'))
+
+    log.info("Android NDK path: %s", os.environ["ANDROID_NDK"])
+    log.info("Android SDK path: %s", os.environ["ANDROID_SDK"])
+
+    builder = Builder(args.work_dir, args.opencv_dir, args)
+
+    log.info("Detected OpenCV version: %s", builder.opencv_version)
+
+    for i, abi in enumerate(ABIs):
+        do_install = (i == 0)
+
+        log.info("=====")
+        log.info("===== Building library for %s", abi)
+        log.info("=====")
+
+        os.chdir(builder.libdest)
+        builder.clean_library_build_dir()
+        builder.build_library(abi, do_install)
+
+    builder.gather_results()
+
+    if args.build_doc:
+        builder.build_javadoc()
+
+    log.info("=====")
+    log.info("===== Build finished")
+    log.info("=====")
+    if show_samples_build_warning:
+        #give a hint how to solve "Gradle sync failed: NDK not configured."
+        log.info("ANDROID_NDK_HOME environment variable required by the samples project is not set")
+    log.info("SDK location: %s", builder.resultdest)
+    log.info("Documentation location: %s", builder.docdest)
diff --git a/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradle.properties b/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradle.properties
new file mode 100644
index 00000000..115cd29e
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradle.properties
@@ -0,0 +1,17 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx2g
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
diff --git a/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradle/wrapper/gradle-wrapper.jar b/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 00000000..8252d7e2
Binary files /dev/null and b/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradle/wrapper/gradle-wrapper.properties.in b/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradle/wrapper/gradle-wrapper.properties.in
new file mode 100644
index 00000000..9084063b
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradle/wrapper/gradle-wrapper.properties.in
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-@GRADLE_VERSION@-all.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradlew b/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradlew
new file mode 100644
index 00000000..061dbc98
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradlew
@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='-Dfile.encoding=UTF-8 "-Xmx64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradlew.bat b/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradlew.bat
new file mode 100644
index 00000000..9f29d12c
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/gradle-wrapper/gradlew.bat
@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=-Dfile.encoding=UTF-8 "-Xmx64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/C++/opencv-4.7.0/platforms/android/ndk-10.config.py b/C++/opencv-4.7.0/platforms/android/ndk-10.config.py
new file mode 100644
index 00000000..c958df74
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/ndk-10.config.py
@@ -0,0 +1,9 @@
+ABIs = [
+    ABI("2", "armeabi-v7a", "arm-linux-androideabi-4.8", cmake_vars=dict(ANDROID_ABI='armeabi-v7a with NEON')),
+    ABI("1", "armeabi",     "arm-linux-androideabi-4.8"),
+    ABI("3", "arm64-v8a",   "aarch64-linux-android-4.9"),
+    ABI("5", "x86_64",      "x86_64-4.9"),
+    ABI("4", "x86",         "x86-4.8"),
+    ABI("7", "mips64",      "mips64el-linux-android-4.9"),
+    ABI("6", "mips",        "mipsel-linux-android-4.8")
+]
diff --git a/C++/opencv-4.7.0/platforms/android/ndk-16.config.py b/C++/opencv-4.7.0/platforms/android/ndk-16.config.py
new file mode 100644
index 00000000..a25079e3
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/ndk-16.config.py
@@ -0,0 +1,7 @@
+ABIs = [
+    ABI("2", "armeabi-v7a", "arm-linux-androideabi-4.9", cmake_vars=dict(ANDROID_ABI='armeabi-v7a with NEON')),
+    ABI("1", "armeabi",     "arm-linux-androideabi-4.9", cmake_vars=dict(WITH_TBB='OFF')),
+    ABI("3", "arm64-v8a",   "aarch64-linux-android-4.9"),
+    ABI("5", "x86_64",      "x86_64-4.9"),
+    ABI("4", "x86",         "x86-4.9"),
+]
diff --git a/C++/opencv-4.7.0/platforms/android/ndk-17.config.py b/C++/opencv-4.7.0/platforms/android/ndk-17.config.py
new file mode 100644
index 00000000..9a9b5cc3
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/ndk-17.config.py
@@ -0,0 +1,6 @@
+ABIs = [
+    ABI("2", "armeabi-v7a", None, cmake_vars=dict(ANDROID_ABI='armeabi-v7a with NEON')),
+    ABI("3", "arm64-v8a",   None),
+    ABI("5", "x86_64",      None),
+    ABI("4", "x86",         None),
+]
diff --git a/C++/opencv-4.7.0/platforms/android/ndk-18-api-level-21.config.py b/C++/opencv-4.7.0/platforms/android/ndk-18-api-level-21.config.py
new file mode 100644
index 00000000..2019c913
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/ndk-18-api-level-21.config.py
@@ -0,0 +1,6 @@
+ABIs = [
+    ABI("2", "armeabi-v7a", None, 21, cmake_vars=dict(ANDROID_ABI='armeabi-v7a with NEON')),
+    ABI("3", "arm64-v8a",   None, 21),
+    ABI("5", "x86_64",      None, 21),
+    ABI("4", "x86",         None, 21),
+]
diff --git a/C++/opencv-4.7.0/platforms/android/ndk-18-api-level-24.config.py b/C++/opencv-4.7.0/platforms/android/ndk-18-api-level-24.config.py
new file mode 100644
index 00000000..c995885c
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/ndk-18-api-level-24.config.py
@@ -0,0 +1,6 @@
+ABIs = [
+    ABI("2", "armeabi-v7a", None, 24, cmake_vars=dict(ANDROID_ABI='armeabi-v7a with NEON')),
+    ABI("3", "arm64-v8a",   None, 24),
+    ABI("5", "x86_64",      None, 24),
+    ABI("4", "x86",         None, 24),
+]
diff --git a/C++/opencv-4.7.0/platforms/android/ndk-18.config.py b/C++/opencv-4.7.0/platforms/android/ndk-18.config.py
new file mode 100644
index 00000000..9a9b5cc3
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/ndk-18.config.py
@@ -0,0 +1,6 @@
+ABIs = [
+    ABI("2", "armeabi-v7a", None, cmake_vars=dict(ANDROID_ABI='armeabi-v7a with NEON')),
+    ABI("3", "arm64-v8a",   None),
+    ABI("5", "x86_64",      None),
+    ABI("4", "x86",         None),
+]
diff --git a/C++/opencv-4.7.0/platforms/android/ndk-22.config.py b/C++/opencv-4.7.0/platforms/android/ndk-22.config.py
new file mode 100644
index 00000000..95ab8b17
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/ndk-22.config.py
@@ -0,0 +1,6 @@
+ABIs = [
+    ABI("2", "armeabi-v7a", None, cmake_vars=dict(ANDROID_ABI='armeabi-v7a with NEON', ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5', KOTLIN_PLUGIN_VERSION='1.5.10')),
+    ABI("3", "arm64-v8a",   None, cmake_vars=dict(ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5', KOTLIN_PLUGIN_VERSION='1.5.10')),
+    ABI("5", "x86_64",      None, cmake_vars=dict(ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5', KOTLIN_PLUGIN_VERSION='1.5.10')),
+    ABI("4", "x86",         None, cmake_vars=dict(ANDROID_GRADLE_PLUGIN_VERSION='4.1.2', GRADLE_VERSION='6.5', KOTLIN_PLUGIN_VERSION='1.5.10')),
+]
diff --git a/C++/opencv-4.7.0/platforms/android/ndk-25.config.py b/C++/opencv-4.7.0/platforms/android/ndk-25.config.py
new file mode 100644
index 00000000..b6b12126
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/ndk-25.config.py
@@ -0,0 +1,19 @@
+# Docs: https://developer.android.com/ndk/guides/cmake#android_native_api_level
+ANDROID_NATIVE_API_LEVEL = int(os.environ.get('ANDROID_NATIVE_API_LEVEL', 32))
+cmake_common_vars = {
+    # Docs: https://source.android.com/docs/setup/about/build-numbers
+    # Docs: https://developer.android.com/studio/publish/versioning
+    'ANDROID_COMPILE_SDK_VERSION': os.environ.get('ANDROID_COMPILE_SDK_VERSION', 32),
+    'ANDROID_TARGET_SDK_VERSION': os.environ.get('ANDROID_TARGET_SDK_VERSION', 32),
+    'ANDROID_MIN_SDK_VERSION': os.environ.get('ANDROID_MIN_SDK_VERSION', ANDROID_NATIVE_API_LEVEL),
+    # Docs: https://developer.android.com/studio/releases/gradle-plugin
+    'ANDROID_GRADLE_PLUGIN_VERSION': '7.3.1',
+    'GRADLE_VERSION': '7.5.1',
+    'KOTLIN_PLUGIN_VERSION': '1.5.20',
+}
+ABIs = [
+    ABI("2", "armeabi-v7a", None, ndk_api_level=ANDROID_NATIVE_API_LEVEL, cmake_vars=cmake_common_vars),
+    ABI("3", "arm64-v8a",   None, ndk_api_level=ANDROID_NATIVE_API_LEVEL, cmake_vars=cmake_common_vars),
+    ABI("5", "x86_64",      None, ndk_api_level=ANDROID_NATIVE_API_LEVEL, cmake_vars=cmake_common_vars),
+    ABI("4", "x86",         None, ndk_api_level=ANDROID_NATIVE_API_LEVEL, cmake_vars=cmake_common_vars),
+]
diff --git a/C++/opencv-4.7.0/platforms/android/service/CMakeLists.txt b/C++/opencv-4.7.0/platforms/android/service/CMakeLists.txt
new file mode 100644
index 00000000..66e0c468
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/CMakeLists.txt
@@ -0,0 +1,10 @@
+if(NOT ANDROID_PROJECTS_BUILD_TYPE STREQUAL "ANT")
+  message(STATUS "Android OpenCV Manager is ignored")
+  return()
+endif()
+
+if(BUILD_ANDROID_SERVICE)
+  add_subdirectory(engine)
+endif()
+
+install(FILES "readme.txt" DESTINATION "apk/" COMPONENT libs)
diff --git a/C++/opencv-4.7.0/platforms/android/service/engine/AndroidManifest.xml b/C++/opencv-4.7.0/platforms/android/service/engine/AndroidManifest.xml
new file mode 100644
index 00000000..660152ed
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/engine/AndroidManifest.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.opencv.engine"
+    android:versionCode="345@ANDROID_PLATFORM_ID@"
+    android:versionName="3.45">
+
+    <uses-sdk android:minSdkVersion="@ANDROID_NATIVE_API_LEVEL@" android:targetSdkVersion="22"/>
+    <uses-feature android:name="android.hardware.touchscreen" android:required="false"/>
+
+    <application
+        android:icon="@drawable/icon"
+        android:label="@string/app_name" android:allowBackup="true">
+
+    <service android:exported="true" android:name="OpenCVEngineService" android:process=":OpenCVEngineProcess">
+        <intent-filter>
+            <action android:name="org.opencv.engine.BIND"></action>
+        </intent-filter>
+    </service>
+
+    <activity
+        android:name="org.opencv.engine.manager.ManagerActivity"
+        android:label="@string/app_name"
+        android:screenOrientation="portrait">
+        <intent-filter>
+            <action android:name="android.intent.action.MAIN" />
+            <category android:name="android.intent.category.LAUNCHER" />
+        </intent-filter>
+    </activity>
+    </application>
+</manifest>
diff --git a/C++/opencv-4.7.0/platforms/android/service/engine/CMakeLists.txt b/C++/opencv-4.7.0/platforms/android/service/engine/CMakeLists.txt
new file mode 100644
index 00000000..a31790a9
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/engine/CMakeLists.txt
@@ -0,0 +1,3 @@
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${ANDROID_MANIFEST_FILE}" "${OpenCV_BINARY_DIR}/platforms/android/service/engine/.build/${ANDROID_MANIFEST_FILE}"  @ONLY)
+unset(__android_project_chain CACHE)
+add_android_project(opencv_engine "${CMAKE_CURRENT_SOURCE_DIR}" SDK_TARGET 9 ${ANDROID_SDK_TARGET} IGNORE_JAVA ON IGNORE_MANIFEST ON COPY_LIBS ON)
diff --git a/C++/opencv-4.7.0/platforms/android/service/engine/res/drawable/icon.png b/C++/opencv-4.7.0/platforms/android/service/engine/res/drawable/icon.png
new file mode 100644
index 00000000..63045492
Binary files /dev/null and b/C++/opencv-4.7.0/platforms/android/service/engine/res/drawable/icon.png differ
diff --git a/C++/opencv-4.7.0/platforms/android/service/engine/res/layout/main.xml b/C++/opencv-4.7.0/platforms/android/service/engine/res/layout/main.xml
new file mode 100644
index 00000000..a4717c8b
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/engine/res/layout/main.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/ScrollBox"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent" >
+
+    <LinearLayout
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:gravity="center_vertical|center_horizontal"
+        android:orientation="vertical"
+        android:scrollbarStyle="insideInset" >
+
+        <TextView
+            android:id="@+id/textView4"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/about"
+            android:textAppearance="?android:attr/textAppearanceLarge" />
+
+        <TextView
+            android:id="@+id/textViewIntro"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:autoLink="web"
+            android:text="@string/intro"
+            android:textAppearance="?android:attr/textAppearanceSmall" />
+
+        <TextView
+            android:id="@+id/textView5"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textAppearance="?android:attr/textAppearanceSmall" />
+
+        <TextView
+            android:id="@+id/textView6"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textAppearance="?android:attr/textAppearanceSmall" />
+
+        <Button
+            android:id="@+id/CheckEngineUpdate"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="center_vertical|center_horizontal"
+            android:text="@string/checkUpdate" />
+    </LinearLayout>
+
+</ScrollView>
diff --git a/C++/opencv-4.7.0/platforms/android/service/engine/res/values/strings.xml b/C++/opencv-4.7.0/platforms/android/service/engine/res/values/strings.xml
new file mode 100644
index 00000000..2cd62ed2
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/engine/res/values/strings.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OpenCV Manager</string>
+    <string name="about">About</string>
+    <string name="checkUpdate">Check for update</string>
+    <string name="intro">OpenCV library is used by other applications for image enhancement, panorama stitching, object detection, recognition and tracking and so on. OpenCV Manager provides the best version of the OpenCV for your hardware. See opencv.org for details.</string>
+</resources>
diff --git a/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/HardwareDetector.java b/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/HardwareDetector.java
new file mode 100644
index 00000000..60a7cec2
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/HardwareDetector.java
@@ -0,0 +1,118 @@
+package org.opencv.engine;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
+import android.os.Build;
+import android.text.TextUtils;
+import android.util.Log;
+
+public class HardwareDetector {
+    private static String TAG = "OpenCVEngine/HardwareDetector";
+
+    public static final int ARCH_UNKNOWN = -1;
+
+    public static final int ARCH_X86 = 0x01000000;
+    public static final int ARCH_X86_64 = 0x02000000;
+    public static final int ARCH_ARM = 0x04000000;
+    public static final int ARCH_ARMv7 = 0x10000000;
+    public static final int ARCH_ARMv8 = 0x20000000;
+    public static final int ARCH_MIPS = 0x40000000;
+    public static final int ARCH_MIPS_64 = 0x80000000;
+
+    // Return CPU flags list
+    public static List<String> getFlags() {
+        Map<String, String> raw = getRawCpuInfo();
+        String f = raw.get("flags");
+        if (f == null)
+            f = raw.get("Features");
+        if (f == null)
+            return Arrays.asList();
+        return Arrays.asList(TextUtils.split(f, " "));
+    }
+
+    // Return CPU arch
+    public static int getAbi() {
+        List<String> abis = Arrays.asList(Build.CPU_ABI, Build.CPU_ABI2);
+        Log.i(TAG, "ABIs: " + abis.toString());
+        if (abis.contains("x86_64")) {
+            return ARCH_X86_64;
+        } else if (abis.contains("x86")) {
+            return ARCH_X86;
+        } else if (abis.contains("arm64-v8a")) {
+            return ARCH_ARMv8;
+        } else if (abis.contains("armeabi-v7a")
+                || abis.contains("armeabi-v7a-hard")) {
+            return ARCH_ARMv7;
+        } else if (abis.contains("armeabi")) {
+            return ARCH_ARM;
+        } else if (abis.contains("mips64")) {
+            return ARCH_MIPS_64;
+        } else if (abis.contains("mips")) {
+            return ARCH_MIPS;
+        }
+        return ARCH_UNKNOWN;
+    }
+
+    // Return hardware platform name
+    public static String getHardware() {
+        Map<String, String> raw = getRawCpuInfo();
+        return raw.get("Hardware");
+    }
+
+    // Return processor count
+    public static int getProcessorCount() {
+        int result = 0;
+        try {
+            Pattern pattern = Pattern.compile("(\\d)+(-(\\d+))?");
+            Scanner s = new Scanner(
+                    new File("/sys/devices/system/cpu/possible"));
+            if (s.hasNextLine()) {
+                String line = s.nextLine();
+                Log.d(TAG, "Got CPUs: " + line);
+                Matcher m = pattern.matcher(line);
+                while (m.find()) {
+                    int start = Integer.parseInt(m.group(1));
+                    int finish = start;
+                    if (m.group(3) != null) {
+                        finish = Integer.parseInt(m.group(3));
+                    }
+                    result += finish - start + 1;
+                    Log.d(TAG, "Got CPU range " + start + " ~ " + finish);
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to read cpu count");
+            e.printStackTrace();
+        }
+        return result;
+
+    }
+
+    // Return parsed cpuinfo contents
+    public static Map<String, String> getRawCpuInfo() {
+        Map<String, String> map = new HashMap<String, String>();
+        try {
+            Scanner s = new Scanner(new File("/proc/cpuinfo"));
+            while (s.hasNextLine()) {
+                String line = s.nextLine();
+                String[] vals = line.split(": ");
+                if (vals.length > 1) {
+                    map.put(vals[0].trim(), vals[1].trim());
+                } else {
+                    Log.d(TAG, "Failed to parse cpuinfo: " + line);
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to read cpuinfo");
+            e.printStackTrace();
+        }
+        return map;
+    }
+
+}
diff --git a/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/MarketConnector.java b/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/MarketConnector.java
new file mode 100644
index 00000000..e4c936dc
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/MarketConnector.java
@@ -0,0 +1,31 @@
+package org.opencv.engine;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.util.Log;
+
+public class MarketConnector {
+    protected static final String OpenCVPackageNamePreffix = "org.opencv.lib";
+    private static final String TAG = "OpenCVEngine/MarketConnector";
+    protected Context mContext;
+
+    public MarketConnector(Context context) {
+        mContext = context;
+    }
+
+    public boolean InstallAppFromMarket(String AppID) {
+        Log.d(TAG, "Installing app: " + AppID);
+        boolean result = true;
+        try {
+            Uri uri = Uri.parse("market://details?id=" + AppID);
+            Intent intent = new Intent(Intent.ACTION_VIEW, uri);
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            mContext.startActivity(intent);
+        } catch (Exception e) {
+            Log.e(TAG, "Installation failed");
+            result = false;
+        }
+        return result;
+    }
+}
diff --git a/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/OpenCVEngineInterface.aidl b/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/OpenCVEngineInterface.aidl
new file mode 100644
index 00000000..1f16aac2
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/OpenCVEngineInterface.aidl
@@ -0,0 +1,33 @@
+package org.opencv.engine;
+
+/**
+* Class provides Java interface to OpenCV Engine Service. Is synchronous with native OpenCVEngine class.
+*/
+interface OpenCVEngineInterface
+{
+    /**
+    * @return Return service version
+    */
+    int getEngineVersion();
+
+    /**
+    * Find installed OpenCV library
+    * @param OpenCV version
+    * @return Returns path to OpenCV native libs or empty string if OpenCV was not found
+    */
+    String getLibPathByVersion(String version);
+
+    /**
+    * Try to install defined version of OpenCV from Google Play (Android Market).
+    * @param OpenCV version
+    * @return Returns true if installation was successful or OpenCV package has been already installed
+    */
+    boolean installVersion(String version);
+
+    /**
+    * Return list of libraries in loading order separated by ";" symbol
+    * @param OpenCV version
+    * @return Returns OpenCV libraries names separated by symbol ";" in loading order
+    */
+    String getLibraryList(String version);
+}
diff --git a/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/OpenCVEngineService.java b/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/OpenCVEngineService.java
new file mode 100644
index 00000000..850bad53
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/OpenCVEngineService.java
@@ -0,0 +1,165 @@
+package org.opencv.engine;
+
+import android.app.Service;
+import android.content.Intent;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.res.XmlResourceParser;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.util.Log;
+import android.text.TextUtils;
+import java.io.File;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.xmlpull.v1.XmlPullParser;
+
+public class OpenCVEngineService extends Service {
+    private static final String TAG = "OpenCVEngine/Service";
+    private IBinder mEngineInterface = null;
+    private List<LibVariant> variants = new ArrayList<LibVariant>();
+
+    private class LibVariant {
+        public String version;
+        public List<String> files;
+
+        public void parseFile(XmlResourceParser p) {
+            try {
+                int eventType = p.getEventType();
+                while (eventType != XmlPullParser.END_DOCUMENT) {
+                    if (eventType == XmlPullParser.START_TAG) {
+                        if (p.getName().equals("library")) {
+                            parseLibraryTag(p);
+                        } else if (p.getName().equals("file")) {
+                            parseFileTag(p);
+                        }
+                    }
+                    eventType = p.next();
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Failed to parse xml library descriptor");
+            }
+        }
+
+        private void parseLibraryTag(XmlResourceParser p) {
+            version = p.getAttributeValue(null, "version");
+            files = new ArrayList<String>();
+        }
+
+        private void parseFileTag(XmlResourceParser p) {
+            files.add(p.getAttributeValue(null, "name"));
+        }
+
+        public boolean hasAllFiles(String path) {
+            boolean result = true;
+            List<String> actualFiles = Arrays.asList((new File(path)).list());
+            for (String f : files)
+                result &= actualFiles.contains(f);
+            return result;
+        }
+
+        public boolean isCompatible(String v) {
+            String[] expected = v.split("\\.");
+            String[] actual = version.split("\\.");
+            int i = 0;
+            for (; i < Math.min(expected.length, actual.length); ++i) {
+                int diff = Integer.valueOf(expected[i])
+                        - Integer.valueOf(actual[i]);
+                if (diff > 0 || (diff != 0 && i == 0)) {
+                    // requested version is greater than actual OR major version differs
+                    return false;
+                } else if (diff < 0) {
+                    // version is compatible
+                    return true;
+                }
+            }
+            if (expected.length > i) {
+                // requested version is longer than actual - 2.4.11.2 and 2.4.11
+                return false;
+            }
+            return true;
+        }
+
+        public String getFileList() {
+            return TextUtils.join(";", files);
+        }
+    }
+
+    public void onCreate() {
+        Log.d(TAG, "Service starting");
+        for (Field field : R.xml.class.getDeclaredFields()) {  // Build error here means that all config.xml files are missing (configuration problem)
+            Log.d(TAG, "Found config: " + field.getName());
+            final LibVariant lib = new LibVariant();
+            try {
+                final int id = field.getInt(R.xml.class);
+                final XmlResourceParser p = getResources().getXml(id);
+                lib.parseFile(p);
+            } catch (IllegalArgumentException e) {
+                e.printStackTrace();
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            }
+            if (lib.version != null
+                    && lib.files.size() != 0
+                    && lib.hasAllFiles(getApplication().getApplicationInfo().nativeLibraryDir)) {
+                variants.add(lib);
+            Log.d(TAG, "Added config: " + lib.version);
+            }
+        }
+        super.onCreate();
+        mEngineInterface = new OpenCVEngineInterface.Stub() {
+
+            @Override
+            public boolean installVersion(String version)
+                    throws RemoteException {
+                // DO NOTHING
+                return false;
+            }
+
+            @Override
+            public String getLibraryList(String version) throws RemoteException {
+                Log.i(TAG, "getLibraryList(" + version + ")");
+                for (LibVariant lib : variants) {
+                    Log.i(TAG, "checking " + lib.version + " ...");
+                    if (lib.isCompatible(version))
+                        return lib.getFileList();
+                }
+                return null;
+            }
+
+            @Override
+            public String getLibPathByVersion(String version)
+                    throws RemoteException {
+                // TODO: support API 8
+                return getApplication().getApplicationInfo().nativeLibraryDir;
+            }
+
+            @Override
+            public int getEngineVersion() throws RemoteException {
+                int version = 3450;
+                try {
+                    version = getPackageManager().getPackageInfo(getPackageName(), 0).versionCode;
+                } catch (NameNotFoundException e) {
+                    e.printStackTrace();
+                }
+                return version / 1000;
+            }
+        };
+    }
+
+    public IBinder onBind(Intent intent) {
+        Log.i(TAG, "Service onBind called for intent " + intent.toString());
+        return mEngineInterface;
+    }
+
+    public boolean onUnbind(Intent intent) {
+        Log.i(TAG, "Service onUnbind called for intent " + intent.toString());
+        return true;
+    }
+
+    public void OnDestroy() {
+        Log.i(TAG, "OpenCV Engine service destruction");
+    }
+
+}
diff --git a/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/manager/ManagerActivity.java b/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/manager/ManagerActivity.java
new file mode 100644
index 00000000..0f97a836
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/engine/src/org/opencv/engine/manager/ManagerActivity.java
@@ -0,0 +1,113 @@
+package org.opencv.engine.manager;
+
+import org.opencv.engine.MarketConnector;
+import org.opencv.engine.HardwareDetector;
+import org.opencv.engine.OpenCVEngineInterface;
+import org.opencv.engine.OpenCVEngineService;
+import org.opencv.engine.R;
+import android.app.Activity;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.TextView;
+import android.widget.Toast;
+
+public class ManagerActivity extends Activity {
+    protected static final String TAG = "OpenCVEngine/Activity";
+    protected MarketConnector mMarket;
+    protected TextView mVersionText;
+    protected boolean mExtraInfo = false;
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.main);
+
+        final Class<OpenCVEngineService> c = OpenCVEngineService.class;
+        final String packageName = c.getPackage().getName();
+
+        mMarket = new MarketConnector(this);
+
+        Button updateButton = (Button) findViewById(R.id.CheckEngineUpdate);
+        updateButton.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                if (!mMarket.InstallAppFromMarket(packageName)) {
+                    Toast toast = Toast.makeText(getApplicationContext(),
+                            "Google Play is not available", Toast.LENGTH_SHORT);
+                    toast.show();
+                }
+            }
+        });
+
+        TextView aboutText = (TextView) findViewById(R.id.textView4);
+        aboutText.setText("About (" + packageName + ")");
+
+        if (mExtraInfo) {
+            TextView extraText = (TextView) findViewById(R.id.textView6);
+            extraText.setText(
+                    "CPU count: "
+                    + HardwareDetector.getProcessorCount()
+                    + "\nABI: 0x"
+                    + Integer.toHexString(HardwareDetector.getAbi())
+                    + "\nFlags: "
+                    + TextUtils.join(";", HardwareDetector.getFlags())
+                    + "\nHardware: "
+                    + HardwareDetector.getHardware());
+        }
+
+        mVersionText = (TextView) findViewById(R.id.textView5);
+        if (!bindService(new Intent(this, c),
+                new OpenCVEngineServiceConnection(), Context.BIND_AUTO_CREATE)) {
+            Log.e(TAG, "Failed to bind to service:" + c.getName());
+            mVersionText.setText("not available");
+        } else {
+            Log.d(TAG, "Successfully bound to service:" + c.getName());
+            mVersionText.setText("available");
+        }
+
+    }
+
+    protected class OpenCVEngineServiceConnection implements ServiceConnection {
+        public void onServiceDisconnected(ComponentName name) {
+            Log.d(TAG, "Handle: service disconnected");
+        }
+
+        public void onServiceConnected(ComponentName name, IBinder service) {
+            Log.d(TAG, "Handle: service connected");
+            OpenCVEngineInterface engine = OpenCVEngineInterface.Stub
+                    .asInterface(service);
+            if (engine == null) {
+                Log.e(TAG, "Cannot connect to OpenCV Manager Service!");
+                unbindService(this);
+                return;
+            }
+            Log.d(TAG, "Successful connection");
+            try {
+                String[] vars = { "2.4", "3.0" };
+                String res = new String();
+                for (String piece : vars) {
+                    res += "\n\t" + piece + " -> "
+                            + engine.getLibraryList(piece);
+                }
+                mVersionText.setText("Path: "
+                        + engine.getLibPathByVersion(null) + res);
+            } catch (RemoteException e) {
+                e.printStackTrace();
+                Log.e(TAG, "Call failed");
+            }
+            unbindService(this);
+        }
+    };
+
+}
diff --git a/C++/opencv-4.7.0/platforms/android/service/readme.txt b/C++/opencv-4.7.0/platforms/android/service/readme.txt
new file mode 100644
index 00000000..b77adbca
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/android/service/readme.txt
@@ -0,0 +1,25 @@
+How to select the proper version of OpenCV Manager
+--------------------------------------------------
+
+Since version 1.7 several packages of OpenCV Manager are built. Every package is targeted for some
+specific hardware platform and includes corresponding OpenCV binaries. So, in all cases OpenCV
+Manager uses built-in version of OpenCV. The new package selection logic in most cases simplifies
+OpenCV installation on end user devices. In most cases OpenCV Manager may be installed automatically
+from Google Play.
+
+If Google Play is not available (i.e. on emulator, developer board, etc), you can install it
+manually using adb tool:
+
+    adb install <path-to-OpenCV-sdk>/apk/OpenCV_<version>_Manager_<app_version>_<platform>.apk
+
+Example: OpenCV_3.4.5-dev_Manager_3.45_armeabi-v7a.apk
+
+Use the list of platforms below to determine proper OpenCV Manager package for your device:
+
+- armeabi (ARMv5, ARMv6)
+- armeabi-v7a (ARMv7-A + NEON)
+- arm64-v8a
+- mips
+- mips64
+- x86
+- x86_64
diff --git a/C++/opencv-4.7.0/platforms/apple/__init__.py b/C++/opencv-4.7.0/platforms/apple/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/C++/opencv-4.7.0/platforms/apple/build_xcframework.py b/C++/opencv-4.7.0/platforms/apple/build_xcframework.py
new file mode 100644
index 00000000..49878435
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/apple/build_xcframework.py
@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+This script builds OpenCV into an xcframework compatible with the platforms
+of your choice. Just run it and grab a snack; you'll be waiting a while.
+"""
+
+import sys, os, argparse, pathlib, traceback, contextlib, shutil
+from cv_build_utils import execute, print_error, print_header, get_xcode_version, get_cmake_version
+
+if __name__ == "__main__":
+
+    # Check for dependencies
+    assert sys.version_info >= (3, 6), "Python 3.6 or later is required! Current version is {}".format(sys.version_info)
+    # Need CMake 3.18.5/3.19 or later for a Silicon-related fix to building for the iOS Simulator.
+    # See https://gitlab.kitware.com/cmake/cmake/-/issues/21425 for context.
+    assert get_cmake_version() >= (3, 18, 5), "CMake 3.18.5 or later is required. Current version is {}".format(get_cmake_version())
+    # Need Xcode 12.2 for Apple Silicon support
+    assert get_xcode_version() >= (12, 2), \
+        "Xcode 12.2 command line tools or later are required! Current version is {}. ".format(get_xcode_version()) + \
+        "Run xcode-select to switch if you have multiple Xcode installs."
+
+    # Parse arguments
+    description = """
+        This script builds OpenCV into an xcframework supporting the Apple platforms of your choice.
+        """
+    epilog = """
+        Any arguments that are not recognized by this script are passed through to the ios/osx build_framework.py scripts.
+        """
+    parser = argparse.ArgumentParser(description=description, epilog=epilog)
+    parser.add_argument('-o', '--out', metavar='OUTDIR', help='<Required> The directory where the xcframework will be created', required=True)
+    parser.add_argument('--framework_name', default='opencv2', help='Name of OpenCV xcframework (default: opencv2, will change to OpenCV in future version)')
+    parser.add_argument('--iphoneos_archs', default=None, help='select iPhoneOS target ARCHS. Default is "armv7,arm64"')
+    parser.add_argument('--iphonesimulator_archs', default=None, help='select iPhoneSimulator target ARCHS. Default is "x86_64,arm64"')
+    parser.add_argument('--macos_archs', default=None, help='Select MacOS ARCHS. Default is "x86_64,arm64"')
+    parser.add_argument('--catalyst_archs', default=None, help='Select Catalyst ARCHS. Default is "x86_64,arm64"')
+    parser.add_argument('--build_only_specified_archs', default=False, action='store_true', help='if enabled, only directly specified archs are built and defaults are ignored')
+
+    args, unknown_args = parser.parse_known_args()
+    if unknown_args:
+        print("The following args are not recognized by this script and will be passed through to the ios/osx build_framework.py scripts: {}".format(unknown_args))
+
+    # Parse architectures from args
+    iphoneos_archs = args.iphoneos_archs
+    if not iphoneos_archs and not args.build_only_specified_archs:
+        # Supply defaults
+        iphoneos_archs = "armv7,arm64"
+    print('Using iPhoneOS ARCHS={}'.format(iphoneos_archs))
+
+    iphonesimulator_archs = args.iphonesimulator_archs
+    if not iphonesimulator_archs and not args.build_only_specified_archs:
+        # Supply defaults
+        iphonesimulator_archs = "x86_64,arm64"
+    print('Using iPhoneSimulator ARCHS={}'.format(iphonesimulator_archs))
+
+    macos_archs = args.macos_archs
+    if not macos_archs and not args.build_only_specified_archs:
+        # Supply defaults
+        macos_archs = "x86_64,arm64"
+    print('Using MacOS ARCHS={}'.format(macos_archs))
+
+    catalyst_archs = args.catalyst_archs
+    if not catalyst_archs and not args.build_only_specified_archs:
+        # Supply defaults
+        catalyst_archs = "x86_64,arm64"
+    print('Using Catalyst ARCHS={}'.format(catalyst_archs))
+
+    # Build phase
+
+    try:
+        # Phase 1: build .frameworks for each platform
+        osx_script_path = os.path.abspath(os.path.abspath(os.path.dirname(__file__))+'/../osx/build_framework.py')
+        ios_script_path = os.path.abspath(os.path.abspath(os.path.dirname(__file__))+'/../ios/build_framework.py')
+
+        build_folders = []
+
+        def get_or_create_build_folder(base_dir, platform):
+            build_folder = "{}/{}".format(base_dir, platform).replace(" ", "\\ ")  # Escape spaces in output path
+            pathlib.Path(build_folder).mkdir(parents=True, exist_ok=True)
+            return build_folder
+
+        if iphoneos_archs:
+            build_folder = get_or_create_build_folder(args.out, "iphoneos")
+            build_folders.append(build_folder)
+            command = ["python3", ios_script_path, build_folder, "--iphoneos_archs", iphoneos_archs, "--framework_name", args.framework_name, "--build_only_specified_archs"] + unknown_args
+            print_header("Building iPhoneOS frameworks")
+            print(command)
+            execute(command, cwd=os.getcwd())
+        if iphonesimulator_archs:
+            build_folder = get_or_create_build_folder(args.out, "iphonesimulator")
+            build_folders.append(build_folder)
+            command = ["python3", ios_script_path, build_folder, "--iphonesimulator_archs", iphonesimulator_archs, "--framework_name", args.framework_name, "--build_only_specified_archs"] + unknown_args
+            print_header("Building iPhoneSimulator frameworks")
+            execute(command, cwd=os.getcwd())
+        if macos_archs:
+            build_folder = get_or_create_build_folder(args.out, "macos")
+            build_folders.append(build_folder)
+            command = ["python3", osx_script_path, build_folder, "--macos_archs", macos_archs, "--framework_name", args.framework_name, "--build_only_specified_archs"] + unknown_args
+            print_header("Building MacOS frameworks")
+            execute(command, cwd=os.getcwd())
+        if catalyst_archs:
+            build_folder = get_or_create_build_folder(args.out, "catalyst")
+            build_folders.append(build_folder)
+            command = ["python3", osx_script_path, build_folder, "--catalyst_archs", catalyst_archs, "--framework_name", args.framework_name, "--build_only_specified_archs"] + unknown_args
+            print_header("Building Catalyst frameworks")
+            execute(command, cwd=os.getcwd())
+
+        # Phase 2: put all the built .frameworks together into a .xcframework
+
+        xcframework_path = "{}/{}.xcframework".format(args.out, args.framework_name)
+        print_header("Building {}".format(xcframework_path))
+
+        # Remove the xcframework if it exists, otherwise the existing
+        # file will cause the xcodebuild command to fail.
+        with contextlib.suppress(FileNotFoundError):
+            shutil.rmtree(xcframework_path)
+            print("Removed existing xcframework at {}".format(xcframework_path))
+
+        xcframework_build_command = [
+            "xcodebuild",
+            "-create-xcframework",
+            "-output",
+            xcframework_path,
+        ]
+        for folder in build_folders:
+            xcframework_build_command += ["-framework", "{}/{}.framework".format(folder, args.framework_name)]
+        execute(xcframework_build_command, cwd=os.getcwd())
+
+        print("")
+        print_header("Finished building {}".format(xcframework_path))
+    except Exception as e:
+        print_error(e)
+        traceback.print_exc(file=sys.stderr)
+        sys.exit(1)
diff --git a/C++/opencv-4.7.0/platforms/apple/cv_build_utils.py b/C++/opencv-4.7.0/platforms/apple/cv_build_utils.py
new file mode 100644
index 00000000..d764b70f
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/apple/cv_build_utils.py
@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+"""
+Common utilities. These should be compatible with Python 2 and 3.
+"""
+
+from __future__ import print_function
+import sys, re
+from subprocess import check_call, check_output, CalledProcessError
+
+def execute(cmd, cwd = None):
+    print("Executing: %s in %s" % (cmd, cwd), file=sys.stderr)
+    print('Executing: ' + ' '.join(cmd))
+    retcode = check_call(cmd, cwd = cwd)
+    if retcode != 0:
+        raise Exception("Child returned:", retcode)
+
+def print_header(text):
+    print("="*60)
+    print(text)
+    print("="*60)
+
+def print_error(text):
+    print("="*60, file=sys.stderr)
+    print("ERROR: %s" % text, file=sys.stderr)
+    print("="*60, file=sys.stderr)
+
+def get_xcode_major():
+    ret = check_output(["xcodebuild", "-version"]).decode('utf-8')
+    m = re.match(r'Xcode\s+(\d+)\..*', ret, flags=re.IGNORECASE)
+    if m:
+        return int(m.group(1))
+    else:
+        raise Exception("Failed to parse Xcode version")
+
+def get_xcode_version():
+    """
+    Returns the major and minor version of the current Xcode
+    command line tools as a tuple of (major, minor)
+    """
+    ret = check_output(["xcodebuild", "-version"]).decode('utf-8')
+    m = re.match(r'Xcode\s+(\d+)\.(\d+)', ret, flags=re.IGNORECASE)
+    if m:
+        return (int(m.group(1)), int(m.group(2)))
+    else:
+        raise Exception("Failed to parse Xcode version")
+
+def get_xcode_setting(var, projectdir):
+    ret = check_output(["xcodebuild", "-showBuildSettings"], cwd = projectdir).decode('utf-8')
+    m = re.search("\s" + var + " = (.*)", ret)
+    if m:
+        return m.group(1)
+    else:
+        raise Exception("Failed to parse Xcode settings")
+
+def get_cmake_version():
+    """
+    Returns the major and minor version of the current CMake
+    command line tools as a tuple of (major, minor, revision)
+    """
+    ret = check_output(["cmake", "--version"]).decode('utf-8')
+    m = re.match(r'cmake\sversion\s+(\d+)\.(\d+).(\d+)', ret, flags=re.IGNORECASE)
+    if m:
+        return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
+    else:
+        raise Exception("Failed to parse CMake version")
diff --git a/C++/opencv-4.7.0/platforms/apple/readme.md b/C++/opencv-4.7.0/platforms/apple/readme.md
new file mode 100644
index 00000000..222af109
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/apple/readme.md
@@ -0,0 +1,56 @@
+# Building for Apple Platforms
+
+build_xcframework.py creates an xcframework supporting a variety of Apple platforms.
+
+You'll need the following to run these steps:
+- MacOS 10.15 or later
+- Python 3.6 or later
+- CMake 3.18.5/3.19.0 or later (make sure the `cmake` command is available on your PATH)
+- Xcode 12.2 or later (and its command line tools)
+
+You can then run build_xcframework.py, as below:
+```
+cd ~/<my_working_directory>
+python opencv/platforms/apple/build_xcframework.py --out ./build_xcframework
+```
+
+Grab a coffee, because you'll be here for a while. By default this builds OpenCV for 8 architectures across 4 platforms:
+
+- iOS (`--iphoneos_archs`): arm64, armv7
+- iOS Simulator (`--iphonesimulator_archs`): x86_64, arm64
+- macOS (`--macos_archs`): x86_64, arm64
+- Mac Catalyst (`--catalyst_archs`): x86_64, arm64
+
+If everything's fine, you will eventually get `opencv2.xcframework` in the output directory.
+
+The script has some configuration options to exclude platforms and architectures you don't want to build for. Use the `--help` flag for more information.
+
+## How it Works
+
+This script generates a fat `.framework` for each platform you specify, and stitches them together into a `.xcframework`. This file can be used to support the same architecture on different platforms, which fat `.framework`s don't allow. To build the intermediate `.framework`s, `build_xcframework.py` leverages the `build_framework.py` scripts in the ios and osx platform folders.
+
+### Passthrough Arguments
+
+Any arguments that aren't recognized by `build_xcframework.py` will be passed to the platform-specific `build_framework.py` scripts. The `--without` flag mentioned in the examples is an example of this in action. For more info, see the `--help` info for those scripts.
+
+## Examples
+
+You may override the defaults by specifying a value for any of the `*_archs` flags. For example, if you want to build for arm64 on every platform, you can do this:
+
+```
+python build_xcframework.py --out somedir --iphoneos_archs arm64 --iphonesimulator_archs arm64 --macos_archs arm64 --catalyst_archs arm64
+```
+
+
+If you want to build only for certain platforms, you can supply the `--build_only_specified_archs` flag, which makes the script build only the archs you directly ask for. For example, to build only for Catalyst, you can do this:
+
+```
+python build_xcframework.py --out somedir --catalyst_archs x86_64,arm64 --build_only_specified_archs
+```
+
+You can also build without OpenCV functionality you don't need. You can do this by using the `--without` flag, which you use once per item you want to go without. For example, if you wanted to compile without `video` or `objc`, you'd can do this:
+
+```
+python build_xcframework.py --out somedir --without video --without objc
+```
+(if you have issues with this, try using `=`, e.g. `--without=video --without=objc`, and file an issue on GitHub.)
diff --git a/C++/opencv-4.7.0/platforms/ios/Info.Dynamic.plist.in b/C++/opencv-4.7.0/platforms/ios/Info.Dynamic.plist.in
new file mode 100644
index 00000000..e48fffdb
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/Info.Dynamic.plist.in
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>en</string>
+    <key>CFBundleExecutable</key>
+    <string>${FRAMEWORK_NAME}</string>
+    <key>CFBundleName</key>
+    <string>${OPENCV_APPLE_BUNDLE_NAME}</string>
+    <key>CFBundleIdentifier</key>
+    <string>${OPENCV_APPLE_BUNDLE_ID}</string>
+    <key>CFBundleVersion</key>
+    <string>${OPENCV_LIBVERSION}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${OPENCV_LIBVERSION}</string>
+    <key>CFBundleSignature</key>
+    <string>????</string>
+    <key>CFBundlePackageType</key>
+    <string>FMWK</string>
+    <key>CFBundleSupportedPlatforms</key>
+    <array>
+        <string>iPhoneOS</string>
+    </array>
+    <key>MinimumOSVersion</key>
+    <string>8.0</string>
+    <key>UIDeviceFamily</key>
+    <array>
+        <integer>1</integer>
+        <integer>2</integer>
+    </array>
+</dict>
+</plist>
diff --git a/C++/opencv-4.7.0/platforms/ios/Info.plist.in b/C++/opencv-4.7.0/platforms/ios/Info.plist.in
new file mode 100644
index 00000000..a166934b
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/Info.plist.in
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleName</key>
+    <string>${OPENCV_APPLE_BUNDLE_NAME}</string>
+    <key>CFBundleIdentifier</key>
+    <string>${OPENCV_APPLE_BUNDLE_ID}</string>
+    <key>CFBundleVersion</key>
+    <string>${OPENCV_LIBVERSION}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${OPENCV_LIBVERSION}</string>
+    <key>CFBundleSignature</key>
+    <string>????</string>
+    <key>CFBundlePackageType</key>
+    <string>FMWK</string>
+</dict>
+</plist>
diff --git a/C++/opencv-4.7.0/platforms/ios/__init__.py b/C++/opencv-4.7.0/platforms/ios/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/C++/opencv-4.7.0/platforms/ios/build_docs.py b/C++/opencv-4.7.0/platforms/ios/build_docs.py
new file mode 100644
index 00000000..e5dc9b2e
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/build_docs.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+"""
+This script builds OpenCV docs for iOS.
+"""
+
+from __future__ import print_function
+import os, sys, multiprocessing, argparse, traceback
+from subprocess import check_call, check_output, CalledProcessError, Popen
+
+def execute(cmd, cwd = None, output = None):
+    if not output:
+        print("Executing: %s in %s" % (cmd, cwd), file=sys.stderr)
+        print('Executing: ' + ' '.join(cmd))
+        retcode = check_call(cmd, cwd = cwd)
+        if retcode != 0:
+            raise Exception("Child returned:", retcode)
+    else:
+        with open(output, "a") as f:
+            f.flush()
+            p = Popen(cmd, cwd = cwd, stdout = f)
+            os.waitpid(p.pid, 0)
+
+class DocBuilder:
+    def __init__(self, script_dir, framework_dir, output_dir, framework_header, framework_name, arch, target):
+        self.script_dir = script_dir
+        self.framework_dir = framework_dir
+        self.output_dir = output_dir
+        self.framework_header = framework_header
+        self.framework_name = framework_name
+        self.arch = arch
+        self.target = target
+
+    def _build(self):
+        if not os.path.isdir(self.output_dir):
+            os.makedirs(self.output_dir)
+
+        self.buildDocs()
+
+    def build(self):
+        try:
+            self._build()
+        except Exception as e:
+            print("="*60, file=sys.stderr)
+            print("ERROR: %s" % e, file=sys.stderr)
+            print("="*60, file=sys.stderr)
+            traceback.print_exc(file=sys.stderr)
+            sys.exit(1)
+
+    def getToolchain(self):
+        return None
+
+    def getSourceKitten(self):
+        ret = check_output(["gem", "which", "jazzy"])
+        if ret.find('ERROR:') == 0:
+            raise Exception("Failed to find jazzy")
+        else:
+            return os.path.join(ret[0:ret.rfind('/')], '../bin/sourcekitten')
+
+    def buildDocs(self):
+        sourceKitten = self.getSourceKitten()
+        sourceKittenSwiftDoc = [sourceKitten, "doc", "--module-name", self.framework_name, "--", "-project", self.framework_name + ".xcodeproj", "ARCHS=" + self.arch, "-sdk", self.target, "-configuration", "Release", "-parallelizeTargets", "-jobs", str(multiprocessing.cpu_count()), "-target", "opencv_objc_framework"]
+        execute(sourceKittenSwiftDoc, cwd = self.framework_dir, output = os.path.join(self.output_dir, "swiftDoc.json"))
+        sdk_dir = check_output(["xcrun", "--show-sdk-path", "--sdk", self.target]).rstrip()
+        sourceKittenObjcDoc = [sourceKitten, "doc", "--objc", self.framework_header, "--", "-x", "objective-c", "-isysroot", sdk_dir, "-fmodules"]
+        print(sourceKittenObjcDoc)
+        execute(sourceKittenObjcDoc, cwd = self.framework_dir, output = os.path.join(self.output_dir, "objcDoc.json"))
+        execute(["jazzy", "--author", "OpenCV", "--author_url", "http://opencv.org", "--github_url", "https://github.com/opencv/opencv", "--module", self.framework_name, "--undocumented-text", "\"\"", "--sourcekitten-sourcefile", "swiftDoc.json,objcDoc.json"], cwd = self.output_dir)
+
+class iOSDocBuilder(DocBuilder):
+
+    def getToolchain(self):
+        return None
+
+if __name__ == "__main__":
+    script_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
+    parser = argparse.ArgumentParser(description='The script builds OpenCV docs for iOS.')
+    parser.add_argument('framework_dir', metavar='FRAMEWORK_DIR', help='folder where framework build files are located')
+    parser.add_argument('--output_dir', default=None, help='folder where docs will be built (default is "../doc_build" relative to framework_dir)')
+    parser.add_argument('--framework_header', default=None, help='umbrella header for OpenCV framework (default is "../../../lib/Release/{framework_name}.framework/Headers/{framework_name}.h")')
+    parser.add_argument('--framework_name', default='opencv2', help='Name of OpenCV framework (default: opencv2, will change to OpenCV in future version)')
+    args = parser.parse_args()
+
+    arch = "x86_64"
+    target = "iphonesimulator"
+
+    b = iOSDocBuilder(script_dir, args.framework_dir, args.output_dir if args.output_dir else os.path.join(args.framework_dir, "../doc_build"), args.framework_header if args.framework_header else os.path.join(args.framework_dir, "../../../lib/Release/" + args.framework_name + ".framework/Headers/" + args.framework_name + ".h"), args.framework_name, arch, target)
+    b.build()
diff --git a/C++/opencv-4.7.0/platforms/ios/build_framework.py b/C++/opencv-4.7.0/platforms/ios/build_framework.py
new file mode 100644
index 00000000..12e7fddd
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/build_framework.py
@@ -0,0 +1,597 @@
+#!/usr/bin/env python
+"""
+The script builds OpenCV.framework for iOS.
+The built framework is universal, it can be used to build app and run it on either iOS simulator or real device.
+
+Usage:
+    ./build_framework.py <outputdir>
+
+By cmake conventions (and especially if you work with OpenCV repository),
+the output dir should not be a subdirectory of OpenCV source tree.
+
+Script will create <outputdir>, if it's missing, and a few its subdirectories:
+
+    <outputdir>
+        build/
+            iPhoneOS-*/
+               [cmake-generated build tree for an iOS device target]
+            iPhoneSimulator-*/
+               [cmake-generated build tree for iOS simulator]
+        {framework_name}.framework/
+            [the framework content]
+        samples/
+            [sample projects]
+        docs/
+            [documentation]
+
+The script should handle minor OpenCV updates efficiently
+- it does not recompile the library from scratch each time.
+However, {framework_name}.framework directory is erased and recreated on each run.
+
+Adding --dynamic parameter will build {framework_name}.framework as App Store dynamic framework. Only iOS 8+ versions are supported.
+"""
+
+from __future__ import print_function, unicode_literals
+import glob, os, os.path, shutil, string, sys, argparse, traceback, multiprocessing, codecs, io
+from subprocess import check_call, check_output, CalledProcessError
+
+if sys.version_info >= (3, 8): # Python 3.8+
+    def copy_tree(src, dst):
+        shutil.copytree(src, dst, dirs_exist_ok=True)
+else:
+    from distutils.dir_util import copy_tree
+
+sys.path.insert(0, os.path.abspath(os.path.abspath(os.path.dirname(__file__))+'/../apple'))
+from cv_build_utils import execute, print_error, get_xcode_major, get_xcode_setting, get_xcode_version, get_cmake_version
+
+IPHONEOS_DEPLOYMENT_TARGET='9.0'  # default, can be changed via command line options or environment variable
+
+class Builder:
+    def __init__(self, opencv, contrib, dynamic, bitcodedisabled, exclude, disable, enablenonfree, targets, debug, debug_info, framework_name, run_tests, build_docs, swiftdisabled):
+        self.opencv = os.path.abspath(opencv)
+        self.contrib = None
+        if contrib:
+            modpath = os.path.join(contrib, "modules")
+            if os.path.isdir(modpath):
+                self.contrib = os.path.abspath(modpath)
+            else:
+                print("Note: contrib repository is bad - modules subfolder not found", file=sys.stderr)
+        self.dynamic = dynamic
+        self.bitcodedisabled = bitcodedisabled
+        self.exclude = exclude
+        self.build_objc_wrapper = not "objc" in self.exclude
+        self.disable = disable
+        self.enablenonfree = enablenonfree
+        self.targets = targets
+        self.debug = debug
+        self.debug_info = debug_info
+        self.framework_name = framework_name
+        self.run_tests = run_tests
+        self.build_docs = build_docs
+        self.swiftdisabled = swiftdisabled
+
+    def checkCMakeVersion(self):
+        if get_xcode_version() >= (12, 2):
+            assert get_cmake_version() >= (3, 19), "CMake 3.19 or later is required when building with Xcode 12.2 or greater. Current version is {}".format(get_cmake_version())
+        else:
+            assert get_cmake_version() >= (3, 17), "CMake 3.17 or later is required. Current version is {}".format(get_cmake_version())
+
+    def getBuildDir(self, parent, target):
+
+        res = os.path.join(parent, 'build-%s-%s' % (target[0].lower(), target[1].lower()))
+
+        if not os.path.isdir(res):
+            os.makedirs(res)
+        return os.path.abspath(res)
+
+    def _build(self, outdir):
+        self.checkCMakeVersion()
+        outdir = os.path.abspath(outdir)
+        if not os.path.isdir(outdir):
+            os.makedirs(outdir)
+        main_working_dir = os.path.join(outdir, "build")
+        dirs = []
+
+        xcode_ver = get_xcode_major()
+
+        # build each architecture separately
+        alltargets = []
+
+        for target_group in self.targets:
+            for arch in target_group[0]:
+                current = ( arch, target_group[1] )
+                alltargets.append(current)
+
+        for target in alltargets:
+            main_build_dir = self.getBuildDir(main_working_dir, target)
+            dirs.append(main_build_dir)
+
+            cmake_flags = []
+            if self.contrib:
+                cmake_flags.append("-DOPENCV_EXTRA_MODULES_PATH=%s" % self.contrib)
+            if xcode_ver >= 7 and target[1] == 'iPhoneOS' and self.bitcodedisabled == False:
+                cmake_flags.append("-DCMAKE_C_FLAGS=-fembed-bitcode")
+                cmake_flags.append("-DCMAKE_CXX_FLAGS=-fembed-bitcode")
+            if xcode_ver >= 7 and target[1] == 'Catalyst':
+                sdk_path = check_output(["xcodebuild", "-version", "-sdk", "macosx", "Path"]).decode('utf-8').rstrip()
+                c_flags = [
+                    "-target %s-apple-ios13.0-macabi" % target[0],  # e.g. x86_64-apple-ios13.2-macabi # -mmacosx-version-min=10.15
+                    "-isysroot %s" % sdk_path,
+                    "-iframework %s/System/iOSSupport/System/Library/Frameworks" % sdk_path,
+                    "-isystem %s/System/iOSSupport/usr/include" % sdk_path,
+                ]
+                if self.bitcodedisabled == False:
+                    c_flags.append("-fembed-bitcode")
+                cmake_flags.append("-DCMAKE_C_FLAGS=" + " ".join(c_flags))
+                cmake_flags.append("-DCMAKE_CXX_FLAGS=" + " ".join(c_flags))
+                cmake_flags.append("-DCMAKE_EXE_LINKER_FLAGS=" + " ".join(c_flags))
+
+                # CMake cannot compile Swift for Catalyst https://gitlab.kitware.com/cmake/cmake/-/issues/21436
+                # cmake_flags.append("-DCMAKE_Swift_FLAGS=" + " " + target_flag)
+                cmake_flags.append("-DSWIFT_DISABLED=1")
+
+                cmake_flags.append("-DIOS=1")  # Build the iOS codebase
+                cmake_flags.append("-DMAC_CATALYST=1")  # Set a flag for Mac Catalyst, just in case we need it
+                cmake_flags.append("-DWITH_OPENCL=OFF")  # Disable OpenCL; it isn't compatible with iOS
+                cmake_flags.append("-DCMAKE_OSX_SYSROOT=%s" % sdk_path)
+                cmake_flags.append("-DCMAKE_CXX_COMPILER_WORKS=TRUE")
+                cmake_flags.append("-DCMAKE_C_COMPILER_WORKS=TRUE")
+            self.buildOne(target[0], target[1], main_build_dir, cmake_flags)
+
+            if not self.dynamic:
+                self.mergeLibs(main_build_dir)
+            else:
+                self.makeDynamicLib(main_build_dir)
+        self.makeFramework(outdir, dirs)
+        if self.build_objc_wrapper:
+            if self.run_tests:
+                check_call([sys.argv[0].replace("build_framework", "run_tests"), "--framework_dir=" + outdir, "--framework_name=" + self.framework_name, dirs[0] +  "/modules/objc_bindings_generator/{}/test".format(self.getObjcTarget(target[1]))])
+            else:
+                print("To run tests call:")
+                print(sys.argv[0].replace("build_framework", "run_tests") + " --framework_dir=" + outdir + " --framework_name=" + self.framework_name + " " + dirs[0] +  "/modules/objc_bindings_generator/{}/test".format(self.getObjcTarget(target[1])))
+            if self.build_docs:
+                check_call([sys.argv[0].replace("build_framework", "build_docs"), dirs[0] + "/modules/objc/framework_build"])
+                doc_path = os.path.join(dirs[0], "modules", "objc", "doc_build", "docs")
+                if os.path.exists(doc_path):
+                    shutil.copytree(doc_path, os.path.join(outdir, "docs"))
+                    shutil.copyfile(os.path.join(self.opencv, "doc", "opencv.ico"), os.path.join(outdir, "docs", "favicon.ico"))
+            else:
+                print("To build docs call:")
+                print(sys.argv[0].replace("build_framework", "build_docs") + " " + dirs[0] + "/modules/objc/framework_build")
+            self.copy_samples(outdir)
+            if self.swiftdisabled:
+                swift_sources_dir = os.path.join(outdir, "SwiftSources")
+                if not os.path.exists(swift_sources_dir):
+                    os.makedirs(swift_sources_dir)
+                for root, dirs, files in os.walk(dirs[0]):
+                    for file in files:
+                        if file.endswith(".swift") and file.find("Test") == -1:
+                            with io.open(os.path.join(root, file), encoding="utf-8", errors="ignore") as file_in:
+                                body = file_in.read()
+                            if body.find("import Foundation") != -1:
+                                insert_pos = body.find("import Foundation") + len("import Foundation") + 1
+                                body = body[:insert_pos] + "import " + self.framework_name + "\n" + body[insert_pos:]
+                            else:
+                                body = "import " + self.framework_name + "\n\n" + body
+                            with codecs.open(os.path.join(swift_sources_dir, file), "w", "utf-8") as file_out:
+                                file_out.write(body)
+
+    def build(self, outdir):
+        try:
+            self._build(outdir)
+        except Exception as e:
+            print_error(e)
+            traceback.print_exc(file=sys.stderr)
+            sys.exit(1)
+
+    def getToolchain(self, arch, target):
+        return None
+
+    def getConfiguration(self):
+        return "Debug" if self.debug else "Release"
+
+    def getCMakeArgs(self, arch, target):
+
+        args = [
+            "cmake",
+            "-GXcode",
+            "-DAPPLE_FRAMEWORK=ON",
+            "-DCMAKE_INSTALL_PREFIX=install",
+            "-DCMAKE_BUILD_TYPE=%s" % self.getConfiguration(),
+            "-DOPENCV_INCLUDE_INSTALL_PATH=include",
+            "-DOPENCV_3P_LIB_INSTALL_PATH=lib/3rdparty",
+            "-DFRAMEWORK_NAME=%s" % self.framework_name,
+        ]
+        if self.dynamic:
+            args += [
+                "-DDYNAMIC_PLIST=ON"
+            ]
+        if self.enablenonfree:
+            args += [
+                "-DOPENCV_ENABLE_NONFREE=ON"
+            ]
+        if self.debug_info:
+            args += [
+                "-DBUILD_WITH_DEBUG_INFO=ON"
+            ]
+
+        if len(self.exclude) > 0:
+            args += ["-DBUILD_opencv_%s=OFF" % m for m in self.exclude]
+
+        if len(self.disable) > 0:
+            args += ["-DWITH_%s=OFF" % f for f in self.disable]
+
+        return args
+
+    def getBuildCommand(self, arch, target):
+
+        buildcmd = [
+            "xcodebuild",
+        ]
+
+        if (self.dynamic or self.build_objc_wrapper) and not self.bitcodedisabled and target == "iPhoneOS":
+            buildcmd.append("BITCODE_GENERATION_MODE=bitcode")
+
+        buildcmd += [
+            "IPHONEOS_DEPLOYMENT_TARGET=" + os.environ['IPHONEOS_DEPLOYMENT_TARGET'],
+            "ARCHS=%s" % arch,
+            "-sdk", target.lower(),
+            "-configuration", self.getConfiguration(),
+            "-parallelizeTargets",
+            "-jobs", str(multiprocessing.cpu_count()),
+        ]
+
+        return buildcmd
+
+    def getInfoPlist(self, builddirs):
+        return os.path.join(builddirs[0], "ios", "Info.plist")
+
+    def getObjcTarget(self, target):
+        # Obj-C generation target
+        return 'ios'
+
+    def makeCMakeCmd(self, arch, target, dir, cmakeargs = []):
+        toolchain = self.getToolchain(arch, target)
+        cmakecmd = self.getCMakeArgs(arch, target) + \
+            (["-DCMAKE_TOOLCHAIN_FILE=%s" % toolchain] if toolchain is not None else [])
+        if target.lower().startswith("iphoneos"):
+            cmakecmd.append("-DCPU_BASELINE=DETECT")
+        if target.lower().startswith("iphonesimulator"):
+            build_arch = check_output(["uname", "-m"]).decode('utf-8').rstrip()
+            if build_arch != arch:
+                print("build_arch (%s) != arch (%s)" % (build_arch, arch))
+                cmakecmd.append("-DCMAKE_SYSTEM_PROCESSOR=" + arch)
+                cmakecmd.append("-DCMAKE_OSX_ARCHITECTURES=" + arch)
+                cmakecmd.append("-DCPU_BASELINE=DETECT")
+                cmakecmd.append("-DCMAKE_CROSSCOMPILING=ON")
+                cmakecmd.append("-DOPENCV_WORKAROUND_CMAKE_20989=ON")
+        if target.lower() == "catalyst":
+            build_arch = check_output(["uname", "-m"]).decode('utf-8').rstrip()
+            if build_arch != arch:
+                print("build_arch (%s) != arch (%s)" % (build_arch, arch))
+                cmakecmd.append("-DCMAKE_SYSTEM_PROCESSOR=" + arch)
+                cmakecmd.append("-DCMAKE_OSX_ARCHITECTURES=" + arch)
+                cmakecmd.append("-DCPU_BASELINE=DETECT")
+                cmakecmd.append("-DCMAKE_CROSSCOMPILING=ON")
+                cmakecmd.append("-DOPENCV_WORKAROUND_CMAKE_20989=ON")
+        if target.lower() == "macosx":
+            build_arch = check_output(["uname", "-m"]).decode('utf-8').rstrip()
+            if build_arch != arch:
+                print("build_arch (%s) != arch (%s)" % (build_arch, arch))
+                cmakecmd.append("-DCMAKE_SYSTEM_PROCESSOR=" + arch)
+                cmakecmd.append("-DCMAKE_OSX_ARCHITECTURES=" + arch)
+                cmakecmd.append("-DCPU_BASELINE=DETECT")
+                cmakecmd.append("-DCMAKE_CROSSCOMPILING=ON")
+                cmakecmd.append("-DOPENCV_WORKAROUND_CMAKE_20989=ON")
+
+        cmakecmd.append(dir)
+        cmakecmd.extend(cmakeargs)
+        return cmakecmd
+
+    def buildOne(self, arch, target, builddir, cmakeargs = []):
+        # Run cmake
+        #toolchain = self.getToolchain(arch, target)
+        #cmakecmd = self.getCMakeArgs(arch, target) + \
+        #    (["-DCMAKE_TOOLCHAIN_FILE=%s" % toolchain] if toolchain is not None else [])
+        #if target.lower().startswith("iphoneos"):
+        #    cmakecmd.append("-DCPU_BASELINE=DETECT")
+        #cmakecmd.append(self.opencv)
+        #cmakecmd.extend(cmakeargs)
+        cmakecmd = self.makeCMakeCmd(arch, target, self.opencv, cmakeargs)
+        print("")
+        print("=================================")
+        print("CMake")
+        print("=================================")
+        print("")
+        execute(cmakecmd, cwd = builddir)
+        print("")
+        print("=================================")
+        print("Xcodebuild")
+        print("=================================")
+        print("")
+
+        # Clean and build
+        clean_dir = os.path.join(builddir, "install")
+        if os.path.isdir(clean_dir):
+            shutil.rmtree(clean_dir)
+        buildcmd = self.getBuildCommand(arch, target)
+        execute(buildcmd + ["-target", "ALL_BUILD", "build"], cwd = builddir)
+        execute(["cmake", "-DBUILD_TYPE=%s" % self.getConfiguration(), "-P", "cmake_install.cmake"], cwd = builddir)
+        if self.build_objc_wrapper:
+            cmakecmd = self.makeCMakeCmd(arch, target, builddir + "/modules/objc_bindings_generator/{}/gen".format(self.getObjcTarget(target)), cmakeargs)
+            if self.swiftdisabled:
+                cmakecmd.append("-DSWIFT_DISABLED=1")
+            cmakecmd.append("-DBUILD_ROOT=%s" % builddir)
+            cmakecmd.append("-DCMAKE_INSTALL_NAME_TOOL=install_name_tool")
+            cmakecmd.append("--no-warn-unused-cli")
+            execute(cmakecmd, cwd = builddir + "/modules/objc/framework_build")
+
+            execute(buildcmd + ["-target", "ALL_BUILD", "build"], cwd = builddir + "/modules/objc/framework_build")
+            execute(["cmake", "-DBUILD_TYPE=%s" % self.getConfiguration(), "-DCMAKE_INSTALL_PREFIX=%s" % (builddir + "/install"), "-P", "cmake_install.cmake"], cwd = builddir + "/modules/objc/framework_build")
+
+    def mergeLibs(self, builddir):
+        res = os.path.join(builddir, "lib", self.getConfiguration(), "libopencv_merged.a")
+        libs = glob.glob(os.path.join(builddir, "install", "lib", "*.a"))
+        module = [os.path.join(builddir, "install", "lib", self.framework_name + ".framework", self.framework_name)] if self.build_objc_wrapper else []
+
+        libs3 = glob.glob(os.path.join(builddir, "install", "lib", "3rdparty", "*.a"))
+        print("Merging libraries:\n\t%s" % "\n\t".join(libs + libs3 + module), file=sys.stderr)
+        execute(["libtool", "-static", "-o", res] + libs + libs3 + module)
+
+    def makeDynamicLib(self, builddir):
+        target = builddir[(builddir.rfind("build-") + 6):]
+        target_platform = target[(target.rfind("-") + 1):]
+        is_device = target_platform == "iphoneos" or target_platform == "catalyst"
+        framework_dir = os.path.join(builddir, "install", "lib", self.framework_name + ".framework")
+        if not os.path.exists(framework_dir):
+            os.makedirs(framework_dir)
+        res = os.path.join(framework_dir, self.framework_name)
+        libs = glob.glob(os.path.join(builddir, "install", "lib", "*.a"))
+        if self.build_objc_wrapper:
+            module = [os.path.join(builddir, "lib", self.getConfiguration(), self.framework_name + ".framework", self.framework_name)]
+        else:
+            module = []
+
+        libs3 = glob.glob(os.path.join(builddir, "install", "lib", "3rdparty", "*.a"))
+
+        if os.environ.get('IPHONEOS_DEPLOYMENT_TARGET'):
+            link_target = target[:target.find("-")] + "-apple-ios" + os.environ['IPHONEOS_DEPLOYMENT_TARGET'] + ("-simulator" if target.endswith("simulator") else "")
+        else:
+            if target_platform == "catalyst":
+                link_target = "%s-apple-ios13.0-macabi" % target[:target.find("-")]
+            else:
+                link_target = "%s-apple-darwin" % target[:target.find("-")]
+        bitcode_flags = ["-fembed-bitcode", "-Xlinker", "-bitcode_verify"] if is_device and not self.bitcodedisabled else []
+        toolchain_dir = get_xcode_setting("TOOLCHAIN_DIR", builddir)
+        sdk_dir = get_xcode_setting("SDK_DIR", builddir)
+        framework_options = []
+        swift_link_dirs = ["-L" + toolchain_dir + "/usr/lib/swift/" + target_platform, "-L/usr/lib/swift"]
+        if target_platform == "catalyst":
+            swift_link_dirs = ["-L" + toolchain_dir + "/usr/lib/swift/" + "maccatalyst", "-L/usr/lib/swift"]
+            framework_options = [
+                "-iframework", "%s/System/iOSSupport/System/Library/Frameworks" % sdk_dir,
+                "-framework", "AVFoundation", "-framework", "UIKit", "-framework", "CoreGraphics",
+                "-framework", "CoreImage", "-framework", "CoreMedia", "-framework", "QuartzCore",
+            ]
+        elif target_platform == "macosx":
+            framework_options = [
+                "-framework", "AVFoundation", "-framework", "AppKit", "-framework", "CoreGraphics",
+                "-framework", "CoreImage", "-framework", "CoreMedia", "-framework", "QuartzCore",
+                "-framework", "Accelerate", "-framework", "OpenCL",
+            ]
+        elif target_platform == "iphoneos" or target_platform == "iphonesimulator":
+            framework_options = [
+                "-iframework", "%s/System/iOSSupport/System/Library/Frameworks" % sdk_dir,
+                "-framework", "AVFoundation", "-framework", "CoreGraphics",
+                "-framework", "CoreImage", "-framework", "CoreMedia", "-framework", "QuartzCore",
+                "-framework", "Accelerate", "-framework", "UIKit", "-framework", "CoreVideo",
+            ]
+        execute([
+            "clang++",
+            "-Xlinker", "-rpath",
+            "-Xlinker", "/usr/lib/swift",
+            "-target", link_target,
+            "-isysroot", sdk_dir,] +
+            framework_options + [
+            "-install_name", "@rpath/" + self.framework_name + ".framework/" + self.framework_name,
+            "-dynamiclib", "-dead_strip", "-fobjc-link-runtime", "-all_load",
+            "-o", res
+        ] + swift_link_dirs + bitcode_flags + module + libs + libs3)
+
+    def makeFramework(self, outdir, builddirs):
+        name = self.framework_name
+
+        # set the current dir to the dst root
+        framework_dir = os.path.join(outdir, "%s.framework" % name)
+        if os.path.isdir(framework_dir):
+            shutil.rmtree(framework_dir)
+        os.makedirs(framework_dir)
+
+        if self.dynamic:
+            dstdir = framework_dir
+        else:
+            dstdir = os.path.join(framework_dir, "Versions", "A")
+
+        # copy headers from one of build folders
+        shutil.copytree(os.path.join(builddirs[0], "install", "include", "opencv2"), os.path.join(dstdir, "Headers"))
+        if name != "opencv2":
+            for dirname, dirs, files in os.walk(os.path.join(dstdir, "Headers")):
+                for filename in files:
+                    filepath = os.path.join(dirname, filename)
+                    with codecs.open(filepath, "r", "utf-8") as file:
+                        body = file.read()
+                    body = body.replace("include \"opencv2/", "include \"" + name + "/")
+                    body = body.replace("include <opencv2/", "include <" + name + "/")
+                    with codecs.open(filepath, "w", "utf-8") as file:
+                        file.write(body)
+        if self.build_objc_wrapper:
+            copy_tree(os.path.join(builddirs[0], "install", "lib", name + ".framework", "Headers"), os.path.join(dstdir, "Headers"))
+            platform_name_map = {
+                    "arm": "armv7-apple-ios",
+                    "arm64": "arm64-apple-ios",
+                    "i386": "i386-apple-ios-simulator",
+                    "x86_64": "x86_64-apple-ios-simulator",
+                } if builddirs[0].find("iphone") != -1 else {
+                    "x86_64": "x86_64-apple-macos",
+                    "arm64": "arm64-apple-macos",
+                }
+            for d in builddirs:
+                copy_tree(os.path.join(d, "install", "lib", name + ".framework", "Modules"), os.path.join(dstdir, "Modules"))
+            for dirname, dirs, files in os.walk(os.path.join(dstdir, "Modules")):
+                for filename in files:
+                    filestem = os.path.splitext(filename)[0]
+                    fileext = os.path.splitext(filename)[1]
+                    if filestem in platform_name_map:
+                        os.rename(os.path.join(dirname, filename), os.path.join(dirname, platform_name_map[filestem] + fileext))
+
+        # make universal static lib
+        if self.dynamic:
+            libs = [os.path.join(d, "install", "lib", name + ".framework", name) for d in builddirs]
+        else:
+            libs = [os.path.join(d, "lib", self.getConfiguration(), "libopencv_merged.a") for d in builddirs]
+        lipocmd = ["lipo", "-create"]
+        lipocmd.extend(libs)
+        lipocmd.extend(["-o", os.path.join(dstdir, name)])
+        print("Creating universal library from:\n\t%s" % "\n\t".join(libs), file=sys.stderr)
+        execute(lipocmd)
+
+        # dynamic framework has different structure, just copy the Plist directly
+        if self.dynamic:
+            resdir = dstdir
+            shutil.copyfile(self.getInfoPlist(builddirs), os.path.join(resdir, "Info.plist"))
+        else:
+            # copy Info.plist
+            resdir = os.path.join(dstdir, "Resources")
+            os.makedirs(resdir)
+            shutil.copyfile(self.getInfoPlist(builddirs), os.path.join(resdir, "Info.plist"))
+
+            # make symbolic links
+            links = [
+                (["A"], ["Versions", "Current"]),
+                (["Versions", "Current", "Headers"], ["Headers"]),
+                (["Versions", "Current", "Resources"], ["Resources"]),
+                (["Versions", "Current", "Modules"], ["Modules"]),
+                (["Versions", "Current", name], [name])
+            ]
+            for l in links:
+                s = os.path.join(*l[0])
+                d = os.path.join(framework_dir, *l[1])
+                os.symlink(s, d)
+
+    def copy_samples(self, outdir):
+        return
+
+class iOSBuilder(Builder):
+
+    def getToolchain(self, arch, target):
+        toolchain = os.path.join(self.opencv, "platforms", "ios", "cmake", "Toolchains", "Toolchain-%s_Xcode.cmake" % target)
+        return toolchain
+
+    def getCMakeArgs(self, arch, target):
+        args = Builder.getCMakeArgs(self, arch, target)
+        args = args + [
+            '-DIOS_ARCH=%s' % arch
+        ]
+        return args
+
+    def copy_samples(self, outdir):
+        print('Copying samples to: ' + outdir)
+        samples_dir = os.path.join(outdir, "samples")
+        if os.path.exists(samples_dir):
+            shutil.rmtree(samples_dir)
+        shutil.copytree(os.path.join(self.opencv, "samples", "swift", "ios"), samples_dir)
+        if self.framework_name != "OpenCV":
+            for dirname, dirs, files in os.walk(samples_dir):
+                for filename in files:
+                    if not filename.endswith((".h", ".swift", ".pbxproj")):
+                        continue
+                    filepath = os.path.join(dirname, filename)
+                    with open(filepath) as file:
+                        body = file.read()
+                    body = body.replace("import OpenCV", "import " + self.framework_name)
+                    body = body.replace("#import <OpenCV/OpenCV.h>", "#import <" + self.framework_name + "/" + self.framework_name + ".h>")
+                    body = body.replace("OpenCV.framework", self.framework_name + ".framework")
+                    body = body.replace("../../OpenCV/**", "../../" + self.framework_name + "/**")
+                    with open(filepath, "w") as file:
+                        file.write(body)
+
+
+if __name__ == "__main__":
+    folder = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), "../.."))
+    parser = argparse.ArgumentParser(description='The script builds OpenCV.framework for iOS.')
+    # TODO: When we can make breaking changes, we should make the out argument explicit and required like in build_xcframework.py.
+    parser.add_argument('out', metavar='OUTDIR', help='folder to put built framework')
+    parser.add_argument('--opencv', metavar='DIR', default=folder, help='folder with opencv repository (default is "../.." relative to script location)')
+    parser.add_argument('--contrib', metavar='DIR', default=None, help='folder with opencv_contrib repository (default is "None" - build only main framework)')
+    parser.add_argument('--without', metavar='MODULE', default=[], action='append', help='OpenCV modules to exclude from the framework. To exclude multiple, specify this flag again, e.g. "--without video --without objc"')
+    parser.add_argument('--disable', metavar='FEATURE', default=[], action='append', help='OpenCV features to disable (add WITH_*=OFF). To disable multiple, specify this flag again, e.g. "--disable tbb --disable openmp"')
+    parser.add_argument('--dynamic', default=False, action='store_true', help='build dynamic framework (default is "False" - builds static framework)')
+    parser.add_argument('--disable-bitcode', default=False, dest='bitcodedisabled', action='store_true', help='disable bitcode (enabled by default)')
+    parser.add_argument('--iphoneos_deployment_target', default=os.environ.get('IPHONEOS_DEPLOYMENT_TARGET', IPHONEOS_DEPLOYMENT_TARGET), help='specify IPHONEOS_DEPLOYMENT_TARGET')
+    parser.add_argument('--build_only_specified_archs', default=False, action='store_true', help='if enabled, only directly specified archs are built and defaults are ignored')
+    parser.add_argument('--iphoneos_archs', default=None, help='select iPhoneOS target ARCHS. Default is "armv7,armv7s,arm64"')
+    parser.add_argument('--iphonesimulator_archs', default=None, help='select iPhoneSimulator target ARCHS. Default is "i386,x86_64"')
+    parser.add_argument('--enable_nonfree', default=False, dest='enablenonfree', action='store_true', help='enable non-free modules (disabled by default)')
+    parser.add_argument('--debug', default=False, dest='debug', action='store_true', help='Build "Debug" binaries (disabled by default)')
+    parser.add_argument('--debug_info', default=False, dest='debug_info', action='store_true', help='Build with debug information (useful for Release mode: BUILD_WITH_DEBUG_INFO=ON)')
+    parser.add_argument('--framework_name', default='opencv2', dest='framework_name', help='Name of OpenCV framework (default: opencv2, will change to OpenCV in future version)')
+    parser.add_argument('--legacy_build', default=False, dest='legacy_build', action='store_true', help='Build legacy opencv2 framework (default: False, equivalent to "--framework_name=opencv2 --without=objc")')
+    parser.add_argument('--run_tests', default=False, dest='run_tests', action='store_true', help='Run tests')
+    parser.add_argument('--build_docs', default=False, dest='build_docs', action='store_true', help='Build docs')
+    parser.add_argument('--disable-swift', default=False, dest='swiftdisabled', action='store_true', help='Disable building of Swift extensions')
+
+    args, unknown_args = parser.parse_known_args()
+    if unknown_args:
+        print("The following args are not recognized and will not be used: %s" % unknown_args)
+
+    os.environ['IPHONEOS_DEPLOYMENT_TARGET'] = args.iphoneos_deployment_target
+    print('Using IPHONEOS_DEPLOYMENT_TARGET=' + os.environ['IPHONEOS_DEPLOYMENT_TARGET'])
+
+    iphoneos_archs = None
+    if args.iphoneos_archs:
+        iphoneos_archs = args.iphoneos_archs.split(',')
+    elif not args.build_only_specified_archs:
+        # Supply defaults
+        iphoneos_archs = ["armv7", "armv7s", "arm64"]
+    print('Using iPhoneOS ARCHS=' + str(iphoneos_archs))
+
+    iphonesimulator_archs = None
+    if args.iphonesimulator_archs:
+        iphonesimulator_archs = args.iphonesimulator_archs.split(',')
+    elif not args.build_only_specified_archs:
+        # Supply defaults
+        iphonesimulator_archs = ["i386", "x86_64"]
+    print('Using iPhoneSimulator ARCHS=' + str(iphonesimulator_archs))
+
+    # Prevent the build from happening if the same architecture is specified for multiple platforms.
+    # When `lipo` is run to stitch the frameworks together into a fat framework, it'll fail, so it's
+    # better to stop here while we're ahead.
+    if iphoneos_archs and iphonesimulator_archs:
+        duplicate_archs = set(iphoneos_archs).intersection(iphonesimulator_archs)
+        if duplicate_archs:
+            print_error("Cannot have the same architecture for multiple platforms in a fat framework! Consider using build_xcframework.py in the apple platform folder instead. Duplicate archs are %s" % duplicate_archs)
+            exit(1)
+
+    if args.legacy_build:
+        args.framework_name = "opencv2"
+        if not "objc" in args.without:
+            args.without.append("objc")
+
+    targets = []
+    if os.environ.get('BUILD_PRECOMMIT', None):
+        if not iphoneos_archs:
+            print_error("--iphoneos_archs must have at least one value")
+            sys.exit(1)
+        targets.append((iphoneos_archs, "iPhoneOS"))
+    else:
+        if not iphoneos_archs and not iphonesimulator_archs:
+            print_error("--iphoneos_archs and --iphonesimulator_archs are undefined; nothing will be built.")
+            sys.exit(1)
+        if iphoneos_archs:
+            targets.append((iphoneos_archs, "iPhoneOS"))
+        if iphonesimulator_archs:
+            targets.append((iphonesimulator_archs, "iPhoneSimulator"))
+
+    b = iOSBuilder(args.opencv, args.contrib, args.dynamic, args.bitcodedisabled, args.without, args.disable, args.enablenonfree, targets, args.debug, args.debug_info, args.framework_name, args.run_tests, args.build_docs, args.swiftdisabled)
+
+    b.build(args.out)
diff --git a/C++/opencv-4.7.0/platforms/ios/cmake/Modules/Platform/iOS.cmake b/C++/opencv-4.7.0/platforms/ios/cmake/Modules/Platform/iOS.cmake
new file mode 100644
index 00000000..207f41f4
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/cmake/Modules/Platform/iOS.cmake
@@ -0,0 +1,174 @@
+# This file is based off of the Platform/Darwin.cmake and Platform/UnixPaths.cmake
+# files which are included with CMake 2.8.4
+# It has been altered for iOS development
+set (UNIX 1)
+set (APPLE 1)
+set (IOS 1)
+
+# Darwin versions:
+#   6.x == Mac OSX 10.2
+#   7.x == Mac OSX 10.3
+#   8.x == Mac OSX 10.4
+#   9.x == Mac OSX 10.5
+#  10.x == Mac OSX 10.6 (Snow Leopard)
+string (REGEX REPLACE "^([0-9]+)\\.([0-9]+).*$" "\\1" DARWIN_MAJOR_VERSION "${CMAKE_SYSTEM_VERSION}")
+string (REGEX REPLACE "^([0-9]+)\\.([0-9]+).*$" "\\2" DARWIN_MINOR_VERSION "${CMAKE_SYSTEM_VERSION}")
+
+# Do not use the "-Wl,-search_paths_first" flag with the OSX 10.2 compiler.
+# Done this way because it is too early to do a TRY_COMPILE.
+if (NOT DEFINED HAVE_FLAG_SEARCH_PATHS_FIRST)
+    set (HAVE_FLAG_SEARCH_PATHS_FIRST 0)
+    if ("${DARWIN_MAJOR_VERSION}" GREATER 6)
+        set (HAVE_FLAG_SEARCH_PATHS_FIRST 1)
+    endif ("${DARWIN_MAJOR_VERSION}" GREATER 6)
+endif (NOT DEFINED HAVE_FLAG_SEARCH_PATHS_FIRST)
+# More desirable, but does not work:
+#INCLUDE(CheckCXXCompilerFlag)
+#CHECK_CXX_COMPILER_FLAG("-Wl,-search_paths_first" HAVE_FLAG_SEARCH_PATHS_FIRST)
+
+set (CMAKE_SHARED_LIBRARY_PREFIX "lib")
+set (CMAKE_SHARED_LIBRARY_SUFFIX ".dylib")
+set (CMAKE_SHARED_MODULE_PREFIX "lib")
+set (CMAKE_SHARED_MODULE_SUFFIX ".so")
+set (CMAKE_MODULE_EXISTS 1)
+set (CMAKE_DL_LIBS "")
+
+set (CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ")
+set (CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ")
+set (CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}")
+set (CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}")
+
+# Additional flags for dynamic framework
+if (APPLE_FRAMEWORK AND BUILD_SHARED_LIBS)
+  set (CMAKE_MODULE_LINKER_FLAGS "-rpath @executable_path/Frameworks -rpath @loader_path/Frameworks")
+  set (CMAKE_SHARED_LINKER_FLAGS "-rpath @executable_path/Frameworks -rpath @loader_path/Frameworks")
+  set (CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG 1)
+  set (CMAKE_INSTALL_NAME_DIR "@rpath")
+endif()
+
+# Hidden visibility is required for cxx on iOS
+set (no_warn "-Wno-unused-function -Wno-overloaded-virtual")
+set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${no_warn}")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -fvisibility=hidden -fvisibility-inlines-hidden ${no_warn}")
+
+set(CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG -O3 -ffast-math")
+if(NOT IOS_ARCH STREQUAL "armv7" AND NOT IOS_ARCH STREQUAL "armv7s")
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
+endif()
+
+if (HAVE_FLAG_SEARCH_PATHS_FIRST)
+    set (CMAKE_C_LINK_FLAGS "-Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}")
+    set (CMAKE_CXX_LINK_FLAGS "-Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}")
+endif (HAVE_FLAG_SEARCH_PATHS_FIRST)
+
+set (CMAKE_PLATFORM_HAS_INSTALLNAME 1)
+set (CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib -headerpad_max_install_names")
+set (CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle -headerpad_max_install_names")
+set (CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,")
+set (CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,")
+set (CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".so" ".a")
+
+# hack: if a new cmake (which uses CMAKE_INSTALL_NAME_TOOL) runs on an old build tree
+# (where install_name_tool was hardcoded) and where CMAKE_INSTALL_NAME_TOOL isn't in the cache
+# and still cmake didn't fail in CMakeFindBinUtils.cmake (because it isn't rerun)
+# hardcode CMAKE_INSTALL_NAME_TOOL here to install_name_tool, so it behaves as it did before, Alex
+if (NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
+    find_program(CMAKE_INSTALL_NAME_TOOL install_name_tool)
+endif (NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
+
+# Setup iOS developer location
+if (IPHONEOS)
+    set (_CMAKE_IOS_DEVELOPER_ROOT "/Developer/Platforms/iPhoneOS.platform/Developer")
+else ()
+    if (IPHONESIMULATOR)
+        set (_CMAKE_IOS_DEVELOPER_ROOT "/Developer/Platforms/iPhoneSimulator.platform/Developer")
+    endif ()
+endif ()
+# Find installed iOS SDKs
+file (GLOB _CMAKE_IOS_SDKS "${_CMAKE_IOS_DEVELOPER_ROOT}/SDKs/*")
+
+# Find and use the most recent iOS sdk
+if (_CMAKE_IOS_SDKS)
+    list (SORT _CMAKE_IOS_SDKS)
+    list (REVERSE _CMAKE_IOS_SDKS)
+    list (GET _CMAKE_IOS_SDKS 0 _CMAKE_IOS_SDK_ROOT)
+
+    # Set the sysroot default to the most recent SDK
+    set (CMAKE_OSX_SYSROOT ${_CMAKE_IOS_SDK_ROOT} CACHE PATH "Sysroot used for iOS support")
+
+    # set the architecture for iOS - this env var sets armv6,armv7 and appears to be XCode's standard. The other found is ARCHS_UNIVERSAL_IPHONE_OS but that is armv7 only
+    set (CMAKE_OSX_ARCHITECTURES "$(ARCHS_STANDARD_32_BIT)" CACHE string  "Build architecture for iOS")
+
+    # Set the default based on this file and not the environment variable
+    set (CMAKE_FIND_ROOT_PATH ${_CMAKE_IOS_DEVELOPER_ROOT} ${_CMAKE_IOS_SDK_ROOT} CACHE string  "iOS library search path root")
+
+    # default to searching for frameworks first
+    set (CMAKE_FIND_FRAMEWORK FIRST)
+
+    # set up the default search directories for frameworks
+    set (CMAKE_SYSTEM_FRAMEWORK_PATH
+        ${_CMAKE_IOS_SDK_ROOT}/System/Library/Frameworks
+        ${_CMAKE_IOS_SDK_ROOT}/System/Library/PrivateFrameworks
+        ${_CMAKE_IOS_SDK_ROOT}/Developer/Library/Frameworks
+    )
+endif (_CMAKE_IOS_SDKS)
+
+if ("${CMAKE_BACKWARDS_COMPATIBILITY}" MATCHES "^1\\.[0-6]$")
+    set (CMAKE_SHARED_MODULE_CREATE_C_FLAGS "${CMAKE_SHARED_MODULE_CREATE_C_FLAGS} -flat_namespace -undefined suppress")
+endif ("${CMAKE_BACKWARDS_COMPATIBILITY}" MATCHES "^1\\.[0-6]$")
+
+if (NOT XCODE)
+      # Enable shared library versioning.  This flag is not actually referenced
+      # but the fact that the setting exists will cause the generators to support
+      # soname computation.
+      set (CMAKE_SHARED_LIBRARY_SONAME_C_FLAG "-install_name")
+endif (NOT XCODE)
+
+# Xcode does not support -isystem yet.
+if (XCODE)
+    set (CMAKE_INCLUDE_SYSTEM_FLAG_C)
+    set (CMAKE_INCLUDE_SYSTEM_FLAG_CXX)
+endif (XCODE)
+
+# Need to list dependent shared libraries on link line.  When building
+# with -isysroot (for universal binaries), the linker always looks for
+# dependent libraries under the sysroot.  Listing them on the link
+# line works around the problem.
+set (CMAKE_LINK_DEPENDENT_LIBRARY_FILES 1)
+
+set (CMAKE_C_CREATE_SHARED_LIBRARY_FORBIDDEN_FLAGS -w)
+set (CMAKE_CXX_CREATE_SHARED_LIBRARY_FORBIDDEN_FLAGS -w)
+
+set (CMAKE_C_CREATE_SHARED_LIBRARY
+    "<CMAKE_C_COMPILER> <LANGUAGE_COMPILE_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> <LINK_FLAGS> -o <TARGET> -install_name <TARGET_INSTALLNAME_DIR><TARGET_SONAME> <OBJECTS> <LINK_LIBRARIES>")
+set (CMAKE_CXX_CREATE_SHARED_LIBRARY
+    "<CMAKE_CXX_COMPILER> <LANGUAGE_COMPILE_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <LINK_FLAGS> -o <TARGET> -install_name <TARGET_INSTALLNAME_DIR><TARGET_SONAME> <OBJECTS> <LINK_LIBRARIES>")
+
+set (CMAKE_CXX_CREATE_SHARED_MODULE
+    "<CMAKE_CXX_COMPILER> <LANGUAGE_COMPILE_FLAGS> <CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS> <LINK_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
+
+set (CMAKE_C_CREATE_SHARED_MODULE
+    "<CMAKE_C_COMPILER>  <LANGUAGE_COMPILE_FLAGS> <CMAKE_SHARED_MODULE_CREATE_C_FLAGS> <LINK_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
+
+set (CMAKE_C_CREATE_MACOSX_FRAMEWORK
+    "<CMAKE_C_COMPILER> <LANGUAGE_COMPILE_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> <LINK_FLAGS> -o <TARGET> -install_name <TARGET_INSTALLNAME_DIR><TARGET_SONAME> <OBJECTS> <LINK_LIBRARIES>")
+set (CMAKE_CXX_CREATE_MACOSX_FRAMEWORK
+    "<CMAKE_CXX_COMPILER> <LANGUAGE_COMPILE_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <LINK_FLAGS> -o <TARGET> -install_name <TARGET_INSTALLNAME_DIR><TARGET_SONAME> <OBJECTS> <LINK_LIBRARIES>")
+
+# Add the install directory of the running cmake to the search directories
+# CMAKE_ROOT is CMAKE_INSTALL_PREFIX/share/cmake, so we need to go two levels up
+get_filename_component (_CMAKE_INSTALL_DIR "${CMAKE_ROOT}" PATH)
+get_filename_component (_CMAKE_INSTALL_DIR "${_CMAKE_INSTALL_DIR}" PATH)
+
+# List common installation prefixes.  These will be used for all search types
+list (APPEND CMAKE_SYSTEM_PREFIX_PATH
+    # Standard
+    ${_CMAKE_IOS_DEVELOPER_ROOT}/usr
+    ${_CMAKE_IOS_SDK_ROOT}/usr
+
+    # CMake install location
+    "${_CMAKE_INSTALL_DIR}"
+
+    # Project install destination.
+    "${CMAKE_INSTALL_PREFIX}"
+)
diff --git a/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/Toolchain-Catalyst_Xcode.cmake b/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/Toolchain-Catalyst_Xcode.cmake
new file mode 100644
index 00000000..a22c10a7
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/Toolchain-Catalyst_Xcode.cmake
@@ -0,0 +1,4 @@
+set(MAC_CATALYST TRUE)
+message(STATUS "Setting up Catalyst toolchain for IOS_ARCH='${IOS_ARCH}'")
+include(${CMAKE_CURRENT_LIST_DIR}/common-ios-toolchain.cmake)
+message(STATUS "Catalyst toolchain loaded")
diff --git a/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/Toolchain-iPhoneOS_Xcode.cmake b/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/Toolchain-iPhoneOS_Xcode.cmake
new file mode 100644
index 00000000..ec8d4fad
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/Toolchain-iPhoneOS_Xcode.cmake
@@ -0,0 +1,4 @@
+message(STATUS "Setting up iPhoneOS toolchain for IOS_ARCH='${IOS_ARCH}'")
+set(IPHONEOS TRUE)
+include(${CMAKE_CURRENT_LIST_DIR}/common-ios-toolchain.cmake)
+message(STATUS "iPhoneOS toolchain loaded")
diff --git a/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/Toolchain-iPhoneSimulator_Xcode.cmake b/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/Toolchain-iPhoneSimulator_Xcode.cmake
new file mode 100644
index 00000000..4eb212d3
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/Toolchain-iPhoneSimulator_Xcode.cmake
@@ -0,0 +1,4 @@
+message(STATUS "Setting up iPhoneSimulator toolchain for IOS_ARCH='${IOS_ARCH}'")
+set(IPHONESIMULATOR TRUE)
+include(${CMAKE_CURRENT_LIST_DIR}/common-ios-toolchain.cmake)
+message(STATUS "iPhoneSimulator toolchain loaded")
diff --git a/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/common-ios-toolchain.cmake b/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/common-ios-toolchain.cmake
new file mode 100644
index 00000000..a5ec05a8
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/common-ios-toolchain.cmake
@@ -0,0 +1,182 @@
+# load settings in case of "try compile"
+set(TOOLCHAIN_CONFIG_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/toolchain.config.cmake")
+get_property(__IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE)
+if(__IN_TRY_COMPILE)
+  set(TOOLCHAIN_CONFIG_FILE "${CMAKE_CURRENT_SOURCE_DIR}/../toolchain.config.cmake")
+  if(NOT EXISTS "${TOOLCHAIN_CONFIG_FILE}")
+    # Hack for "try_compile" commands with other binary directory
+    set(TOOLCHAIN_CONFIG_FILE "${CMAKE_PLATFORM_INFO_DIR}/../toolchain.config.cmake")
+    if(NOT EXISTS "${TOOLCHAIN_CONFIG_FILE}")
+      message(FATAL_ERROR "Current CMake version (${CMAKE_VERSION}) is not supported")
+    endif()
+  endif()
+  include("${TOOLCHAIN_CONFIG_FILE}")
+  macro(toolchain_save_config)
+    # nothing
+  endmacro()
+else()
+  macro(toolchain_save_config)
+    set(__config "#message(\"Load TOOLCHAIN config...\")\n")
+    get_cmake_property(__variableNames VARIABLES)
+    set(__vars_list ${ARGN})
+    list(APPEND __vars_list
+        ${TOOLCHAIN_CONFIG_VARS}
+        CMAKE_SYSTEM_NAME
+        CMAKE_SYSTEM_VERSION
+        CMAKE_SYSTEM_PROCESSOR
+        CMAKE_C_COMPILER
+        CMAKE_CXX_COMPILER
+        CMAKE_C_FLAGS
+        CMAKE_CXX_FLAGS
+        CMAKE_SHARED_LINKER_FLAGS
+        CMAKE_MODULE_LINKER_FLAGS
+        CMAKE_EXE_LINKER_FLAGS
+        CMAKE_SKIP_RPATH
+        CMAKE_FIND_ROOT_PATH
+    )
+    foreach(__var ${__variableNames})
+      foreach(_v ${__vars_list})
+        if("x${__var}" STREQUAL "x${_v}")
+          if(${__var} MATCHES " ")
+            set(__config "${__config}set(${__var} \"${${__var}}\")\n")
+          else()
+            set(__config "${__config}set(${__var} ${${__var}})\n")
+          endif()
+        endif()
+      endforeach()
+    endforeach()
+    if(EXISTS "${TOOLCHAIN_CONFIG_FILE}")
+      file(READ "${TOOLCHAIN_CONFIG_FILE}" __config_old)
+    endif()
+    if("${__config_old}" STREQUAL "${__config}")
+      # nothing
+    else()
+      #message("Update TOOLCHAIN config: ${__config}")
+      file(WRITE "${TOOLCHAIN_CONFIG_FILE}" "${__config}")
+    endif()
+    unset(__config)
+    unset(__config_old)
+    unset(__vars_list)
+    unset(__variableNames)
+  endmacro()
+endif() # IN_TRY_COMPILE
+
+if(NOT DEFINED IOS_ARCH)
+  message(FATAL_ERROR "iOS toolchain requires ARCH option for proper configuration of compiler flags")
+endif()
+if(IOS_ARCH MATCHES "^arm64")
+  set(AARCH64 1)
+elseif(IOS_ARCH MATCHES "^armv")
+  set(ARM 1)
+elseif(IOS_ARCH MATCHES "^x86_64")
+  set(X86_64 1)
+elseif(IOS_ARCH MATCHES "^i386")
+  set(X86 1)
+else()
+  message(FATAL_ERROR "iOS toolchain doesn't recognize ARCH='${IOS_ARCH}' value")
+endif()
+
+if(NOT DEFINED CMAKE_OSX_SYSROOT)
+  if(IPHONEOS)
+    set(CMAKE_OSX_SYSROOT "iphoneos")
+  elseif(IPHONESIMULATOR)
+    set(CMAKE_OSX_SYSROOT "iphonesimulator")
+  elseif(MAC_CATALYST)
+    # Use MacOS SDK for Catalyst builds
+    set(CMAKE_OSX_SYSROOT "macosx")
+  endif()
+endif()
+set(CMAKE_MACOSX_BUNDLE YES)
+set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO")
+
+if(APPLE_FRAMEWORK AND NOT BUILD_SHARED_LIBS)
+  set(CMAKE_OSX_ARCHITECTURES "${IOS_ARCH}" CACHE INTERNAL "Build architecture for iOS" FORCE)
+endif()
+
+if(NOT DEFINED IPHONEOS_DEPLOYMENT_TARGET AND NOT MAC_CATALYST)
+  if(NOT DEFINED ENV{IPHONEOS_DEPLOYMENT_TARGET})
+    message(FATAL_ERROR "IPHONEOS_DEPLOYMENT_TARGET is not specified")
+  endif()
+  set(IPHONEOS_DEPLOYMENT_TARGET "$ENV{IPHONEOS_DEPLOYMENT_TARGET}")
+endif()
+
+if(NOT __IN_TRY_COMPILE)
+  set(_xcodebuild_wrapper "${CMAKE_BINARY_DIR}/xcodebuild_wrapper")
+  if(NOT EXISTS "${_xcodebuild_wrapper}")
+    set(_xcodebuild_wrapper_tmp "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/xcodebuild_wrapper")
+    if(NOT DEFINED CMAKE_MAKE_PROGRAM)  # empty since CMake 3.10
+      find_program(XCODEBUILD_PATH "xcodebuild")
+      if(NOT XCODEBUILD_PATH)
+        message(FATAL_ERROR "Specify CMAKE_MAKE_PROGRAM variable ('xcodebuild' absolute path)")
+      endif()
+      set(CMAKE_MAKE_PROGRAM "${XCODEBUILD_PATH}")
+    endif()
+    if(CMAKE_MAKE_PROGRAM STREQUAL _xcodebuild_wrapper)
+      message(FATAL_ERROR "Can't prepare xcodebuild_wrapper")
+    endif()
+    if(APPLE_FRAMEWORK AND BUILD_SHARED_LIBS)
+      set(XCODEBUILD_EXTRA_ARGS "${XCODEBUILD_EXTRA_ARGS} IPHONEOS_DEPLOYMENT_TARGET=${IPHONEOS_DEPLOYMENT_TARGET} CODE_SIGN_IDENTITY='' CODE_SIGNING_REQUIRED=NO -sdk ${CMAKE_OSX_SYSROOT}")
+    else()
+      set(XCODEBUILD_EXTRA_ARGS "${XCODEBUILD_EXTRA_ARGS} IPHONEOS_DEPLOYMENT_TARGET=${IPHONEOS_DEPLOYMENT_TARGET} CODE_SIGN_IDENTITY='' CODE_SIGNING_REQUIRED=NO ARCHS=${IOS_ARCH} -sdk ${CMAKE_OSX_SYSROOT}")
+    endif()
+    configure_file("${CMAKE_CURRENT_LIST_DIR}/xcodebuild_wrapper.in" "${_xcodebuild_wrapper_tmp}" @ONLY)
+    file(COPY "${_xcodebuild_wrapper_tmp}" DESTINATION ${CMAKE_BINARY_DIR} FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+  endif()
+  set(CMAKE_MAKE_PROGRAM "${_xcodebuild_wrapper}" CACHE INTERNAL "" FORCE)
+endif()
+
+# Standard settings
+set(CMAKE_SYSTEM_NAME iOS)
+
+# Apple Framework settings
+if(APPLE_FRAMEWORK AND BUILD_SHARED_LIBS)
+  set(CMAKE_SYSTEM_VERSION "${IPHONEOS_DEPLOYMENT_TARGET}")
+  set(CMAKE_C_SIZEOF_DATA_PTR 4)
+  set(CMAKE_CXX_SIZEOF_DATA_PTR 4)
+else()
+  set(CMAKE_SYSTEM_VERSION "${IPHONEOS_DEPLOYMENT_TARGET}")
+  set(CMAKE_SYSTEM_PROCESSOR "${IOS_ARCH}")
+
+  if(AARCH64 OR X86_64)
+    set(CMAKE_C_SIZEOF_DATA_PTR 8)
+    set(CMAKE_CXX_SIZEOF_DATA_PTR 8)
+  else()
+    set(CMAKE_C_SIZEOF_DATA_PTR 4)
+    set(CMAKE_CXX_SIZEOF_DATA_PTR 4)
+  endif()
+endif()
+
+# Include extra modules for the iOS platform files
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/platforms/ios/cmake/Modules")
+
+# Force the compilers to clang for iOS
+include(CMakeForceCompiler)
+#CMAKE_FORCE_C_COMPILER (clang GNU)
+#CMAKE_FORCE_CXX_COMPILER (clang++ GNU)
+
+set(CMAKE_C_HAS_ISYSROOT 1)
+set(CMAKE_CXX_HAS_ISYSROOT 1)
+set(CMAKE_C_COMPILER_ABI ELF)
+set(CMAKE_CXX_COMPILER_ABI ELF)
+
+# Skip the platform compiler checks for cross compiling
+set(CMAKE_CXX_COMPILER_WORKS TRUE)
+set(CMAKE_C_COMPILER_WORKS TRUE)
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_LIBRARY)
+  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_INCLUDE)
+  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_PACKAGE)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_PROGRAM)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+endif()
+
+toolchain_save_config(IOS_ARCH IPHONEOS_DEPLOYMENT_TARGET)
diff --git a/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/xcodebuild_wrapper.in b/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/xcodebuild_wrapper.in
new file mode 100644
index 00000000..43deddfe
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/cmake/Toolchains/xcodebuild_wrapper.in
@@ -0,0 +1,19 @@
+#!/bin/sh
+
+# Force 'Debug' configuration
+# Details: https://github.com/opencv/opencv/issues/13856
+if [[ "$@" =~ "-project CMAKE_TRY_COMPILE.xcodeproj" && -z "${OPENCV_SKIP_XCODEBUILD_FORCE_TRYCOMPILE_DEBUG}" ]]; then
+  ARGS=()
+  for ((i=1; i<=$#; i++))
+  do
+    arg=${!i}
+    ARGS+=("$arg")
+    if [[ "$arg" == "-configuration" ]]; then
+      ARGS+=("Debug")
+      i=$(($i+1))
+    fi
+  done
+  set -- "${ARGS[@]}"
+fi
+
+@CMAKE_MAKE_PROGRAM@ @XCODEBUILD_EXTRA_ARGS@ $*
diff --git a/C++/opencv-4.7.0/platforms/ios/readme.txt b/C++/opencv-4.7.0/platforms/ios/readme.txt
new file mode 100644
index 00000000..0c39e721
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/readme.txt
@@ -0,0 +1,7 @@
+Building OpenCV from Source, using CMake and Command Line
+=========================================================
+
+cd ~/<my_working_directory>
+python opencv/platforms/ios/build_framework.py ios
+
+If everything's fine, a few minutes later you will get ~/<my_working_directory>/ios/opencv2.framework. You can add this framework to your Xcode projects.
diff --git a/C++/opencv-4.7.0/platforms/ios/run_tests.py b/C++/opencv-4.7.0/platforms/ios/run_tests.py
new file mode 100644
index 00000000..12603b22
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/ios/run_tests.py
@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+"""
+This script runs OpenCV.framework tests for iOS.
+"""
+
+from __future__ import print_function
+import glob, re, os, os.path, shutil, string, sys, argparse, traceback, multiprocessing
+from subprocess import check_call, check_output, CalledProcessError
+
+IPHONEOS_DEPLOYMENT_TARGET='9.0'  # default, can be changed via command line options or environment variable
+
+def execute(cmd, cwd = None):
+    print("Executing: %s in %s" % (cmd, cwd), file=sys.stderr)
+    print('Executing: ' + ' '.join(cmd))
+    retcode = check_call(cmd, cwd = cwd)
+    if retcode != 0:
+        raise Exception("Child returned:", retcode)
+
+class TestRunner:
+    def __init__(self, script_dir, tests_dir, build_dir, framework_dir, framework_name, arch, target, platform):
+        self.script_dir = script_dir
+        self.tests_dir = tests_dir
+        self.build_dir = build_dir
+        self.framework_dir = framework_dir
+        self.framework_name = framework_name
+        self.arch = arch
+        self.target = target
+        self.platform = platform
+
+    def _run(self):
+        if not os.path.isdir(self.build_dir):
+            os.makedirs(self.build_dir)
+
+        self.runTest()
+
+    def run(self):
+        try:
+            self._run()
+        except Exception as e:
+            print("="*60, file=sys.stderr)
+            print("ERROR: %s" % e, file=sys.stderr)
+            print("="*60, file=sys.stderr)
+            traceback.print_exc(file=sys.stderr)
+            sys.exit(1)
+
+    def getToolchain(self):
+        return None
+
+    def getCMakeArgs(self):
+        args = [
+            "cmake",
+            "-GXcode",
+            "-DFRAMEWORK_DIR=%s" % self.framework_dir,
+            "-DFRAMEWORK_NAME=%s" % self.framework_name,
+        ]
+        return args
+
+    def makeCMakeCmd(self):
+        toolchain = self.getToolchain()
+        cmakecmd = self.getCMakeArgs() + \
+            (["-DCMAKE_TOOLCHAIN_FILE=%s" % toolchain] if toolchain is not None else []) + \
+            ["-DCMAKE_INSTALL_NAME_TOOL=install_name_tool"]
+        cmakecmd.append(self.tests_dir)
+        return cmakecmd
+
+    def runTest(self):
+        cmakecmd = self.makeCMakeCmd()
+        execute(cmakecmd, cwd = self.build_dir)
+        buildcmd = self.getTestCommand()
+        execute(buildcmd, cwd = self.build_dir)
+
+    def getTestCommand(self):
+        testcmd = [
+            "xcodebuild",
+            "test",
+            "-project", "OpenCVTest.xcodeproj",
+            "-scheme", "OpenCVTestTests",
+            "-destination", "platform=%s" % self.platform
+        ]
+        return testcmd
+
+class iOSTestRunner(TestRunner):
+
+    def getToolchain(self):
+        toolchain = os.path.join(self.script_dir, "cmake", "Toolchains", "Toolchain-%s_Xcode.cmake" % self.target)
+        return toolchain
+
+    def getCMakeArgs(self):
+        args = TestRunner.getCMakeArgs(self)
+        args = args + [
+            "-DIOS_ARCH=%s" % self.arch,
+            "-DIPHONEOS_DEPLOYMENT_TARGET=%s" % os.environ['IPHONEOS_DEPLOYMENT_TARGET'],
+        ]
+        return args
+
+if __name__ == "__main__":
+    script_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
+    parser = argparse.ArgumentParser(description='The script builds OpenCV.framework for iOS.')
+    parser.add_argument('tests_dir', metavar='TEST_DIR', help='folder where test files are located')
+    parser.add_argument('--build_dir', default=None, help='folder where test will be built (default is "../test_build" relative to tests_dir)')
+    parser.add_argument('--framework_dir', default=None, help='folder where OpenCV framework is located')
+    parser.add_argument('--framework_name', default='opencv2', help='Name of OpenCV framework (default: opencv2, will change to OpenCV in future version)')
+    parser.add_argument('--iphoneos_deployment_target', default=os.environ.get('IPHONEOS_DEPLOYMENT_TARGET', IPHONEOS_DEPLOYMENT_TARGET), help='specify IPHONEOS_DEPLOYMENT_TARGET')
+    parser.add_argument('--platform', default='iOS Simulator,name=iPhone 11', help='xcodebuild platform parameter (default is iOS 11 simulator)')
+    args = parser.parse_args()
+
+    os.environ['IPHONEOS_DEPLOYMENT_TARGET'] = args.iphoneos_deployment_target
+    print('Using IPHONEOS_DEPLOYMENT_TARGET=' + os.environ['IPHONEOS_DEPLOYMENT_TARGET'])
+    arch = "x86_64"
+    target = "iPhoneSimulator"
+    print('Using iPhoneSimulator ARCH=' + arch)
+
+    r = iOSTestRunner(script_dir, args.tests_dir, args.build_dir if args.build_dir else os.path.join(args.tests_dir, "../test_build"), args.framework_dir, args.framework_name, arch, target, args.platform)
+    r.run()
diff --git a/C++/opencv-4.7.0/platforms/js/README.md b/C++/opencv-4.7.0/platforms/js/README.md
new file mode 100644
index 00000000..17c17ee1
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/js/README.md
@@ -0,0 +1,15 @@
+Building OpenCV.js by Emscripten
+====================
+
+[Download and install Emscripten](https://emscripten.org/docs/getting_started/downloads.html).
+
+Execute `build_js.py` script:
+```
+emcmake python <opencv_src_dir>/platforms/js/build_js.py <build_dir>
+```
+
+If everything is fine, a few minutes later you will get `<build_dir>/bin/opencv.js`. You can add this into your web pages.
+
+Find out more build options by `-h` switch.
+
+For detailed build tutorial, check out `<opencv_src_dir>/doc/js_tutorials/js_setup/js_setup/js_setup.markdown`.
diff --git a/C++/opencv-4.7.0/platforms/js/build_js.py b/C++/opencv-4.7.0/platforms/js/build_js.py
new file mode 100644
index 00000000..64dc1a6c
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/js/build_js.py
@@ -0,0 +1,349 @@
+#!/usr/bin/env python
+
+import os, sys, subprocess, argparse, shutil, glob, re, multiprocessing
+import logging as log
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+class Fail(Exception):
+    def __init__(self, text=None):
+        self.t = text
+    def __str__(self):
+        return "ERROR" if self.t is None else self.t
+
+def execute(cmd, shell=False):
+    try:
+        log.info("Executing: %s" % cmd)
+        env = os.environ.copy()
+        env['VERBOSE'] = '1'
+        retcode = subprocess.call(cmd, shell=shell, env=env)
+        if retcode < 0:
+            raise Fail("Child was terminated by signal: %s" % -retcode)
+        elif retcode > 0:
+            raise Fail("Child returned: %s" % retcode)
+    except OSError as e:
+        raise Fail("Execution failed: %d / %s" % (e.errno, e.strerror))
+
+def rm_one(d):
+    d = os.path.abspath(d)
+    if os.path.exists(d):
+        if os.path.isdir(d):
+            log.info("Removing dir: %s", d)
+            shutil.rmtree(d)
+        elif os.path.isfile(d):
+            log.info("Removing file: %s", d)
+            os.remove(d)
+
+def check_dir(d, create=False, clean=False):
+    d = os.path.abspath(d)
+    log.info("Check dir %s (create: %s, clean: %s)", d, create, clean)
+    if os.path.exists(d):
+        if not os.path.isdir(d):
+            raise Fail("Not a directory: %s" % d)
+        if clean:
+            for x in glob.glob(os.path.join(d, "*")):
+                rm_one(x)
+    else:
+        if create:
+            os.makedirs(d)
+    return d
+
+def check_file(d):
+    d = os.path.abspath(d)
+    if os.path.exists(d):
+        if os.path.isfile(d):
+            return True
+        else:
+            return False
+    return False
+
+def find_file(name, path):
+    for root, dirs, files in os.walk(path):
+        if name in files:
+            return os.path.join(root, name)
+
+class Builder:
+    def __init__(self, options):
+        self.options = options
+        self.build_dir = check_dir(options.build_dir, create=True)
+        self.opencv_dir = check_dir(options.opencv_dir)
+        print('-----------------------------------------------------------')
+        print('options.opencv_dir:', options.opencv_dir)
+        self.emscripten_dir = check_dir(options.emscripten_dir)
+
+    def get_toolchain_file(self):
+        return os.path.join(self.emscripten_dir, "cmake", "Modules", "Platform", "Emscripten.cmake")
+
+    def clean_build_dir(self):
+        for d in ["CMakeCache.txt", "CMakeFiles/", "bin/", "libs/", "lib/", "modules"]:
+            rm_one(d)
+
+    def get_cmake_cmd(self):
+        cmd = [
+            "cmake",
+            "-DPYTHON_DEFAULT_EXECUTABLE=%s" % sys.executable,
+               "-DENABLE_PIC=FALSE", # To workaround emscripten upstream backend issue https://github.com/emscripten-core/emscripten/issues/8761
+               "-DCMAKE_BUILD_TYPE=Release",
+               "-DCMAKE_TOOLCHAIN_FILE='%s'" % self.get_toolchain_file(),
+               "-DCPU_BASELINE=''",
+               "-DCMAKE_INSTALL_PREFIX=/usr/local",
+               "-DCPU_DISPATCH=''",
+               "-DCV_TRACE=OFF",
+               "-DBUILD_SHARED_LIBS=OFF",
+               "-DWITH_1394=OFF",
+               "-DWITH_ADE=OFF",
+               "-DWITH_VTK=OFF",
+               "-DWITH_EIGEN=OFF",
+               "-DWITH_FFMPEG=OFF",
+               "-DWITH_GSTREAMER=OFF",
+               "-DWITH_GTK=OFF",
+               "-DWITH_GTK_2_X=OFF",
+               "-DWITH_IPP=OFF",
+               "-DWITH_JASPER=OFF",
+               "-DWITH_JPEG=OFF",
+               "-DWITH_WEBP=OFF",
+               "-DWITH_OPENEXR=OFF",
+               "-DWITH_OPENGL=OFF",
+               "-DWITH_OPENVX=OFF",
+               "-DWITH_OPENNI=OFF",
+               "-DWITH_OPENNI2=OFF",
+               "-DWITH_PNG=OFF",
+               "-DWITH_TBB=OFF",
+               "-DWITH_TIFF=OFF",
+               "-DWITH_V4L=OFF",
+               "-DWITH_OPENCL=OFF",
+               "-DWITH_OPENCL_SVM=OFF",
+               "-DWITH_OPENCLAMDFFT=OFF",
+               "-DWITH_OPENCLAMDBLAS=OFF",
+               "-DWITH_GPHOTO2=OFF",
+               "-DWITH_LAPACK=OFF",
+               "-DWITH_ITT=OFF",
+               "-DWITH_QUIRC=ON",
+               "-DBUILD_ZLIB=ON",
+               "-DBUILD_opencv_apps=OFF",
+               "-DBUILD_opencv_calib3d=ON",
+               "-DBUILD_opencv_dnn=ON",
+               "-DBUILD_opencv_features2d=ON",
+               "-DBUILD_opencv_flann=ON",  # No bindings provided. This module is used as a dependency for other modules.
+               "-DBUILD_opencv_gapi=OFF",
+               "-DBUILD_opencv_ml=OFF",
+               "-DBUILD_opencv_photo=ON",
+               "-DBUILD_opencv_imgcodecs=OFF",
+               "-DBUILD_opencv_shape=OFF",
+               "-DBUILD_opencv_videoio=OFF",
+               "-DBUILD_opencv_videostab=OFF",
+               "-DBUILD_opencv_highgui=OFF",
+               "-DBUILD_opencv_superres=OFF",
+               "-DBUILD_opencv_stitching=OFF",
+               "-DBUILD_opencv_java=OFF",
+               "-DBUILD_opencv_js=ON",
+               "-DBUILD_opencv_python2=OFF",
+               "-DBUILD_opencv_python3=OFF",
+               "-DBUILD_EXAMPLES=ON",
+               "-DBUILD_PACKAGE=OFF",
+               "-DBUILD_TESTS=ON",
+               "-DBUILD_PERF_TESTS=ON"]
+        if self.options.cmake_option:
+            cmd += self.options.cmake_option
+        if self.options.build_doc:
+            cmd.append("-DBUILD_DOCS=ON")
+        else:
+            cmd.append("-DBUILD_DOCS=OFF")
+
+        if self.options.threads:
+            cmd.append("-DWITH_PTHREADS_PF=ON")
+        else:
+            cmd.append("-DWITH_PTHREADS_PF=OFF")
+
+        if self.options.simd:
+            cmd.append("-DCV_ENABLE_INTRINSICS=ON")
+        else:
+            cmd.append("-DCV_ENABLE_INTRINSICS=OFF")
+
+        if self.options.build_wasm_intrin_test:
+            cmd.append("-DBUILD_WASM_INTRIN_TESTS=ON")
+        else:
+            cmd.append("-DBUILD_WASM_INTRIN_TESTS=OFF")
+
+        if self.options.webnn:
+            cmd.append("-DWITH_WEBNN=ON")
+
+        flags = self.get_build_flags()
+        if flags:
+            cmd += ["-DCMAKE_C_FLAGS='%s'" % flags,
+                    "-DCMAKE_CXX_FLAGS='%s'" % flags]
+        return cmd
+
+    def get_build_flags(self):
+        flags = ""
+        if self.options.build_wasm:
+            flags += "-s WASM=1 "
+        elif self.options.disable_wasm:
+            flags += "-s WASM=0 "
+        if self.options.threads:
+            flags += "-s USE_PTHREADS=1 -s PTHREAD_POOL_SIZE=4 "
+        else:
+            flags += "-s USE_PTHREADS=0 "
+        if self.options.enable_exception:
+            flags += "-s DISABLE_EXCEPTION_CATCHING=0 "
+        if self.options.simd:
+            flags += "-msimd128 "
+        if self.options.build_flags:
+            flags += self.options.build_flags
+        if self.options.webnn:
+            flags += "-s USE_WEBNN=1 "
+        return flags
+
+    def config(self):
+        cmd = self.get_cmake_cmd()
+        cmd.append(self.opencv_dir)
+        execute(cmd)
+
+    def build_opencvjs(self):
+        execute(["make", "-j", str(multiprocessing.cpu_count()), "opencv.js"])
+
+    def build_test(self):
+        execute(["make", "-j", str(multiprocessing.cpu_count()), "opencv_js_test"])
+
+    def build_perf(self):
+        execute(["make", "-j", str(multiprocessing.cpu_count()), "opencv_js_perf"])
+
+    def build_doc(self):
+        execute(["make", "-j", str(multiprocessing.cpu_count()), "doxygen"])
+
+    def build_loader(self):
+        execute(["make", "-j", str(multiprocessing.cpu_count()), "opencv_js_loader"])
+
+
+#===================================================================================================
+
+if __name__ == "__main__":
+    log.basicConfig(format='%(message)s', level=log.DEBUG)
+
+    opencv_dir = os.path.abspath(os.path.join(SCRIPT_DIR, '../..'))
+    emscripten_dir = None
+    if "EMSCRIPTEN" in os.environ:
+        emscripten_dir = os.environ["EMSCRIPTEN"]
+    else:
+        log.warning("EMSCRIPTEN environment variable is not available. Please properly activate Emscripten SDK and consider using 'emcmake' launcher")
+
+    parser = argparse.ArgumentParser(description='Build OpenCV.js by Emscripten')
+    parser.add_argument("build_dir", help="Building directory (and output)")
+    parser.add_argument('--opencv_dir', default=opencv_dir, help='Opencv source directory (default is "../.." relative to script location)')
+    parser.add_argument('--emscripten_dir', default=emscripten_dir, help="Path to Emscripten to use for build (deprecated in favor of 'emcmake' launcher)")
+    parser.add_argument('--build_wasm', action="store_true", help="Build OpenCV.js in WebAssembly format")
+    parser.add_argument('--disable_wasm', action="store_true", help="Build OpenCV.js in Asm.js format")
+    parser.add_argument('--threads', action="store_true", help="Build OpenCV.js with threads optimization")
+    parser.add_argument('--simd', action="store_true", help="Build OpenCV.js with SIMD optimization")
+    parser.add_argument('--build_test', action="store_true", help="Build tests")
+    parser.add_argument('--build_perf', action="store_true", help="Build performance tests")
+    parser.add_argument('--build_doc', action="store_true", help="Build tutorials")
+    parser.add_argument('--build_loader', action="store_true", help="Build OpenCV.js loader")
+    parser.add_argument('--clean_build_dir', action="store_true", help="Clean build dir")
+    parser.add_argument('--skip_config', action="store_true", help="Skip cmake config")
+    parser.add_argument('--config_only', action="store_true", help="Only do cmake config")
+    parser.add_argument('--enable_exception', action="store_true", help="Enable exception handling")
+    # Use flag --cmake option="-D...=ON" only for one argument, if you would add more changes write new cmake_option flags
+    parser.add_argument('--cmake_option', action='append', help="Append CMake options")
+    # Use flag --build_flags="-s USE_PTHREADS=0 -Os" for one and more arguments as in the example
+    parser.add_argument('--build_flags', help="Append Emscripten build options")
+    parser.add_argument('--build_wasm_intrin_test', default=False, action="store_true", help="Build WASM intrin tests")
+    # Write a path to modify file like argument of this flag
+    parser.add_argument('--config', default=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'opencv_js.config.py'),
+                        help="Specify configuration file with own list of exported into JS functions")
+    parser.add_argument('--webnn', action="store_true", help="Enable WebNN Backend")
+
+    args = parser.parse_args()
+
+    log.debug("Args: %s", args)
+
+    os.environ["OPENCV_JS_WHITELIST"] = os.path.abspath(args.config)
+
+    if 'EMMAKEN_JUST_CONFIGURE' in os.environ:
+        del os.environ['EMMAKEN_JUST_CONFIGURE']  # avoid linker errors with NODERAWFS message then using 'emcmake' launcher
+
+    if args.emscripten_dir is None:
+        log.error("Cannot get Emscripten path, please use 'emcmake' launcher or specify it either by EMSCRIPTEN environment variable or --emscripten_dir option.")
+        sys.exit(-1)
+
+    builder = Builder(args)
+
+    os.chdir(builder.build_dir)
+
+    if args.clean_build_dir:
+        log.info("=====")
+        log.info("===== Clean build dir %s", builder.build_dir)
+        log.info("=====")
+        builder.clean_build_dir()
+
+    if not args.skip_config:
+        target = "default target"
+        if args.build_wasm:
+            target = "wasm"
+        elif args.disable_wasm:
+            target = "asm.js"
+        log.info("=====")
+        log.info("===== Config OpenCV.js build for %s" % target)
+        log.info("=====")
+        builder.config()
+
+    if args.config_only:
+        sys.exit(0)
+
+    log.info("=====")
+    log.info("===== Building OpenCV.js")
+    log.info("=====")
+    builder.build_opencvjs()
+
+    if args.build_test:
+        log.info("=====")
+        log.info("===== Building OpenCV.js tests")
+        log.info("=====")
+        builder.build_test()
+
+    if args.build_perf:
+        log.info("=====")
+        log.info("===== Building OpenCV.js performance tests")
+        log.info("=====")
+        builder.build_perf()
+
+    if args.build_doc:
+        log.info("=====")
+        log.info("===== Building OpenCV.js tutorials")
+        log.info("=====")
+        builder.build_doc()
+
+    if args.build_loader:
+        log.info("=====")
+        log.info("===== Building OpenCV.js loader")
+        log.info("=====")
+        builder.build_loader()
+
+    log.info("=====")
+    log.info("===== Build finished")
+    log.info("=====")
+
+    opencvjs_path = os.path.join(builder.build_dir, "bin", "opencv.js")
+    if check_file(opencvjs_path):
+        log.info("OpenCV.js location: %s", opencvjs_path)
+
+    if args.build_test:
+        opencvjs_test_path = os.path.join(builder.build_dir, "bin", "tests.html")
+        if check_file(opencvjs_test_path):
+            log.info("OpenCV.js tests location: %s", opencvjs_test_path)
+
+    if args.build_perf:
+        opencvjs_perf_path = os.path.join(builder.build_dir, "bin", "perf")
+        opencvjs_perf_base_path = os.path.join(builder.build_dir, "bin", "perf", "base.js")
+        if check_file(opencvjs_perf_base_path):
+            log.info("OpenCV.js performance tests location: %s", opencvjs_perf_path)
+
+    if args.build_doc:
+        opencvjs_tutorial_path = find_file("tutorial_js_root.html", os.path.join(builder.build_dir, "doc", "doxygen", "html"))
+        if check_file(opencvjs_tutorial_path):
+            log.info("OpenCV.js tutorials location: %s", opencvjs_tutorial_path)
+
+    if args.build_loader:
+        opencvjs_loader_path = os.path.join(builder.build_dir, "bin", "loader.js")
+        if check_file(opencvjs_loader_path):
+            log.info("OpenCV.js loader location: %s", opencvjs_loader_path)
diff --git a/C++/opencv-4.7.0/platforms/js/opencv_js.config.py b/C++/opencv-4.7.0/platforms/js/opencv_js.config.py
new file mode 100644
index 00000000..23f26a50
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/js/opencv_js.config.py
@@ -0,0 +1,199 @@
+# Classes and methods whitelist
+
+core = {
+    '': [
+        'absdiff', 'add', 'addWeighted', 'bitwise_and', 'bitwise_not', 'bitwise_or', 'bitwise_xor', 'cartToPolar',
+        'compare', 'convertScaleAbs', 'copyMakeBorder', 'countNonZero', 'determinant', 'dft', 'divide', 'eigen',
+        'exp', 'flip', 'getOptimalDFTSize','gemm', 'hconcat', 'inRange', 'invert', 'kmeans', 'log', 'magnitude',
+        'max', 'mean', 'meanStdDev', 'merge', 'min', 'minMaxLoc', 'mixChannels', 'multiply', 'norm', 'normalize',
+        'perspectiveTransform', 'polarToCart', 'pow', 'randn', 'randu', 'reduce', 'repeat', 'rotate', 'setIdentity', 'setRNGSeed',
+        'solve', 'solvePoly', 'split', 'sqrt', 'subtract', 'trace', 'transform', 'transpose', 'vconcat',
+        'setLogLevel', 'getLogLevel',
+    ],
+    'Algorithm': [],
+}
+
+imgproc = {
+    '': [
+        'Canny',
+        'GaussianBlur',
+        'Laplacian',
+        'HoughLines',
+        'HoughLinesP',
+        'HoughCircles',
+        'Scharr',
+        'Sobel',
+        'adaptiveThreshold',
+        'approxPolyDP',
+        'arcLength',
+        'bilateralFilter',
+        'blur',
+        'boundingRect',
+        'boxFilter',
+        'calcBackProject',
+        'calcHist',
+        'circle',
+        'compareHist',
+        'connectedComponents',
+        'connectedComponentsWithStats',
+        'contourArea',
+        'convexHull',
+        'convexityDefects',
+        'cornerHarris',
+        'cornerMinEigenVal',
+        'createCLAHE',
+        'createLineSegmentDetector',
+        'cvtColor',
+        'demosaicing',
+        'dilate',
+        'distanceTransform',
+        'distanceTransformWithLabels',
+        'drawContours',
+        'ellipse',
+        'ellipse2Poly',
+        'equalizeHist',
+        'erode',
+        'filter2D',
+        'findContours',
+        'fitEllipse',
+        'fitLine',
+        'floodFill',
+        'getAffineTransform',
+        'getPerspectiveTransform',
+        'getRotationMatrix2D',
+        'getStructuringElement',
+        'goodFeaturesToTrack',
+        'grabCut',
+        #'initUndistortRectifyMap',  # 4.x: moved to calib3d
+        'integral',
+        'integral2',
+        'isContourConvex',
+        'line',
+        'matchShapes',
+        'matchTemplate',
+        'medianBlur',
+        'minAreaRect',
+        'minEnclosingCircle',
+        'moments',
+        'morphologyEx',
+        'pointPolygonTest',
+        'putText',
+        'pyrDown',
+        'pyrUp',
+        'rectangle',
+        'remap',
+        'resize',
+        'sepFilter2D',
+        'threshold',
+        #'undistort',  # 4.x: moved to calib3d
+        'warpAffine',
+        'warpPerspective',
+        'warpPolar',
+        'watershed',
+        'fillPoly',
+        'fillConvexPoly',
+        'polylines',
+    ],
+    'CLAHE': ['apply', 'collectGarbage', 'getClipLimit', 'getTilesGridSize', 'setClipLimit', 'setTilesGridSize'],
+    'segmentation_IntelligentScissorsMB': [
+        'IntelligentScissorsMB',
+        'setWeights',
+        'setGradientMagnitudeMaxLimit',
+        'setEdgeFeatureZeroCrossingParameters',
+        'setEdgeFeatureCannyParameters',
+        'applyImage',
+        'applyImageFeatures',
+        'buildMap',
+        'getContour'
+    ],
+}
+
+objdetect = {'': ['groupRectangles'],
+             'HOGDescriptor': ['load', 'HOGDescriptor', 'getDefaultPeopleDetector', 'getDaimlerPeopleDetector', 'setSVMDetector', 'detectMultiScale'],
+             'CascadeClassifier': ['load', 'detectMultiScale2', 'CascadeClassifier', 'detectMultiScale3', 'empty', 'detectMultiScale'],
+             'QRCodeDetector': ['QRCodeDetector', 'decode', 'decodeCurved', 'detect', 'detectAndDecode', 'detectMulti', 'setEpsX', 'setEpsY'],
+             'ArucoDetector': ['getPredefinedDictionary', 'detectMarkers', 'refineDetectedMarkers', 'getDictionary', 'stetDictionary', 'getDetectorParameters', 'setDetectorParameters', 'getRefineParameters', 'setRefineParameters'],
+             'GridBoard': ['create','generateImage', 'getGridSize', 'getMarkerLength', 'getMarkerSeparation'],
+             'CharucoBoard': ['create', 'generateImage', 'getChessboardCorners', 'getNearestMarkerCorners', 'checkCharucoCornersCollinear']
+}
+
+video = {
+    '': [
+        'CamShift',
+        'calcOpticalFlowFarneback',
+        'calcOpticalFlowPyrLK',
+        'createBackgroundSubtractorMOG2',
+        'findTransformECC',
+        'meanShift',
+    ],
+    'BackgroundSubtractorMOG2': ['BackgroundSubtractorMOG2', 'apply'],
+    'BackgroundSubtractor': ['apply', 'getBackgroundImage'],
+    # issue #21070: 'Tracker': ['init', 'update'],
+    'TrackerMIL': ['create'],
+    'TrackerMIL_Params': [],
+}
+
+dnn = {'dnn_Net': ['setInput', 'forward', 'setPreferableBackend'],
+       '': ['readNetFromCaffe', 'readNetFromTensorflow', 'readNetFromTorch', 'readNetFromDarknet',
+            'readNetFromONNX', 'readNet', 'blobFromImage']}
+
+features2d = {'Feature2D': ['detect', 'compute', 'detectAndCompute', 'descriptorSize', 'descriptorType', 'defaultNorm', 'empty', 'getDefaultName'],
+              'BRISK': ['create', 'getDefaultName'],
+              'ORB': ['create', 'setMaxFeatures', 'setScaleFactor', 'setNLevels', 'setEdgeThreshold', 'setFastThreshold', 'setFirstLevel', 'setWTA_K', 'setScoreType', 'setPatchSize', 'getFastThreshold', 'getDefaultName'],
+              'MSER': ['create', 'detectRegions', 'setDelta', 'getDelta', 'setMinArea', 'getMinArea', 'setMaxArea', 'getMaxArea', 'setPass2Only', 'getPass2Only', 'getDefaultName'],
+              'FastFeatureDetector': ['create', 'setThreshold', 'getThreshold', 'setNonmaxSuppression', 'getNonmaxSuppression', 'setType', 'getType', 'getDefaultName'],
+              'AgastFeatureDetector': ['create', 'setThreshold', 'getThreshold', 'setNonmaxSuppression', 'getNonmaxSuppression', 'setType', 'getType', 'getDefaultName'],
+              'GFTTDetector': ['create', 'setMaxFeatures', 'getMaxFeatures', 'setQualityLevel', 'getQualityLevel', 'setMinDistance', 'getMinDistance', 'setBlockSize', 'getBlockSize', 'setHarrisDetector', 'getHarrisDetector', 'setK', 'getK', 'getDefaultName'],
+              # 'SimpleBlobDetector': ['create'],
+              'KAZE': ['create', 'setExtended', 'getExtended', 'setUpright', 'getUpright', 'setThreshold', 'getThreshold', 'setNOctaves', 'getNOctaves', 'setNOctaveLayers', 'getNOctaveLayers', 'setDiffusivity', 'getDiffusivity', 'getDefaultName'],
+              'AKAZE': ['create', 'setDescriptorType', 'getDescriptorType', 'setDescriptorSize', 'getDescriptorSize', 'setDescriptorChannels', 'getDescriptorChannels', 'setThreshold', 'getThreshold', 'setNOctaves', 'getNOctaves', 'setNOctaveLayers', 'getNOctaveLayers', 'setDiffusivity', 'getDiffusivity', 'getDefaultName'],
+              'DescriptorMatcher': ['add', 'clear', 'empty', 'isMaskSupported', 'train', 'match', 'knnMatch', 'radiusMatch', 'clone', 'create'],
+              'BFMatcher': ['isMaskSupported', 'create'],
+              '': ['drawKeypoints', 'drawMatches', 'drawMatchesKnn']}
+
+photo = {'': ['createAlignMTB', 'createCalibrateDebevec', 'createCalibrateRobertson', \
+              'createMergeDebevec', 'createMergeMertens', 'createMergeRobertson', \
+              'createTonemapDrago', 'createTonemapMantiuk', 'createTonemapReinhard', 'inpaint'],
+        'CalibrateCRF': ['process'],
+        'AlignMTB' : ['calculateShift', 'shiftMat', 'computeBitmaps', 'getMaxBits', 'setMaxBits', \
+                      'getExcludeRange', 'setExcludeRange', 'getCut', 'setCut'],
+        'CalibrateDebevec' : ['getLambda', 'setLambda', 'getSamples', 'setSamples', 'getRandom', 'setRandom'],
+        'CalibrateRobertson' : ['getMaxIter', 'setMaxIter', 'getThreshold', 'setThreshold', 'getRadiance'],
+        'MergeExposures' : ['process'],
+        'MergeDebevec' : ['process'],
+        'MergeMertens' : ['process', 'getContrastWeight', 'setContrastWeight', 'getSaturationWeight', \
+                          'setSaturationWeight', 'getExposureWeight', 'setExposureWeight'],
+        'MergeRobertson' : ['process'],
+        'Tonemap' : ['process' , 'getGamma', 'setGamma'],
+        'TonemapDrago' : ['getSaturation', 'setSaturation', 'getBias', 'setBias', \
+                          'getSigmaColor', 'setSigmaColor', 'getSigmaSpace','setSigmaSpace'],
+        'TonemapMantiuk' : ['getScale', 'setScale', 'getSaturation', 'setSaturation'],
+        'TonemapReinhard' : ['getIntensity', 'setIntensity', 'getLightAdaptation', 'setLightAdaptation', \
+                             'getColorAdaptation', 'setColorAdaptation']
+        }
+
+calib3d = {
+    '': [
+        'findHomography',
+        'calibrateCameraExtended',
+        'drawFrameAxes',
+        'estimateAffine2D',
+        'getDefaultNewCameraMatrix',
+        'initUndistortRectifyMap',
+        'Rodrigues',
+        'solvePnP',
+        'solvePnPRansac',
+        'solvePnPRefineLM',
+        'projectPoints',
+        'undistort',
+
+        # cv::fisheye namespace
+        'fisheye_initUndistortRectifyMap',
+        'fisheye_projectPoints',
+    ],
+}
+
+white_list = makeWhiteList([core, imgproc, objdetect, video, dnn, features2d, photo, calib3d])
+
+# namespace_prefix_override['dnn'] = ''  # compatibility stuff (enabled by default)
+# namespace_prefix_override['aruco'] = ''  # compatibility stuff (enabled by default)
diff --git a/C++/opencv-4.7.0/platforms/linux/aarch64-gnu.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/aarch64-gnu.toolchain.cmake
new file mode 100644
index 00000000..ae16337c
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/aarch64-gnu.toolchain.cmake
@@ -0,0 +1,4 @@
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version")
+set(GNU_MACHINE "aarch64-linux-gnu" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/arm.toolchain.cmake")
diff --git a/C++/opencv-4.7.0/platforms/linux/arm-gnueabi.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/arm-gnueabi.toolchain.cmake
new file mode 100644
index 00000000..21d951d6
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/arm-gnueabi.toolchain.cmake
@@ -0,0 +1,3 @@
+set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version")
+set(GNU_MACHINE "/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/arm.toolchain.cmake")
diff --git a/C++/opencv-4.7.0/platforms/linux/arm.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/arm.toolchain.cmake
new file mode 100644
index 00000000..184997fb
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/arm.toolchain.cmake
@@ -0,0 +1,97 @@
+if(COMMAND toolchain_save_config)
+  return() # prevent recursive call
+endif()
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
+  set(CMAKE_SYSTEM_PROCESSOR arm)
+else()
+  #message("CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}")
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake")
+
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm AND NOT ARM_IGNORE_FP)
+  set(FLOAT_ABI_SUFFIX "")
+  if(NOT SOFTFP)
+    set(FLOAT_ABI_SUFFIX "hf")
+  endif()
+endif()
+
+if(NOT "x${GCC_COMPILER_VERSION}" STREQUAL "x")
+  set(__GCC_VER_SUFFIX "-${GCC_COMPILER_VERSION}")
+endif()
+
+if(NOT DEFINED CMAKE_C_COMPILER)
+  find_program(CMAKE_C_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-gcc${__GCC_VER_SUFFIX})
+else()
+  #message(WARNING "CMAKE_C_COMPILER=${CMAKE_C_COMPILER} is defined")
+endif()
+if(NOT DEFINED CMAKE_CXX_COMPILER)
+  find_program(CMAKE_CXX_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-g++${__GCC_VER_SUFFIX})
+else()
+  #message(WARNING "CMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} is defined")
+endif()
+if(NOT DEFINED CMAKE_LINKER)
+  find_program(CMAKE_LINKER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld)
+else()
+  #message(WARNING "CMAKE_LINKER=${CMAKE_LINKER} is defined")
+endif()
+if(NOT DEFINED CMAKE_AR)
+  find_program(CMAKE_AR NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar)
+else()
+  #message(WARNING "CMAKE_AR=${CMAKE_AR} is defined")
+endif()
+
+if(NOT DEFINED ARM_LINUX_SYSROOT AND DEFINED GNU_MACHINE)
+  set(ARM_LINUX_SYSROOT /usr/${GNU_MACHINE}${FLOAT_ABI_SUFFIX})
+endif()
+
+if(NOT DEFINED CMAKE_CXX_FLAGS)
+  set(CMAKE_CXX_FLAGS           "" CACHE INTERNAL "")
+  set(CMAKE_C_FLAGS             "" CACHE INTERNAL "")
+  set(CMAKE_SHARED_LINKER_FLAGS "" CACHE INTERNAL "")
+  set(CMAKE_MODULE_LINKER_FLAGS "" CACHE INTERNAL "")
+  set(CMAKE_EXE_LINKER_FLAGS    "" CACHE INTERNAL "")
+
+  set(CMAKE_CXX_FLAGS           "${CMAKE_CXX_FLAGS} -fdata-sections -Wa,--noexecstack -fsigned-char -Wno-psabi")
+  set(CMAKE_C_FLAGS             "${CMAKE_C_FLAGS} -fdata-sections -Wa,--noexecstack -fsigned-char -Wno-psabi")
+  if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm)
+    set(CMAKE_CXX_FLAGS           "-mthumb ${CMAKE_CXX_FLAGS}")
+    set(CMAKE_C_FLAGS             "-mthumb ${CMAKE_C_FLAGS}")
+    set(CMAKE_EXE_LINKER_FLAGS    "${CMAKE_EXE_LINKER_FLAGS} -Wl,-z,nocopyreloc")
+  endif()
+  if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm)
+    set(ARM_LINKER_FLAGS "-Wl,--fix-cortex-a8 -Wl,--no-undefined -Wl,--gc-sections -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now")
+  elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
+    set(ARM_LINKER_FLAGS "-Wl,--no-undefined -Wl,--gc-sections -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now")
+  endif()
+  set(CMAKE_SHARED_LINKER_FLAGS "${ARM_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}")
+  set(CMAKE_MODULE_LINKER_FLAGS "${ARM_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS    "${ARM_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}")
+else()
+  #message(WARNING "CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}' is defined")
+endif()
+
+if(USE_NEON)
+  message(WARNING "You use obsolete variable USE_NEON to enable NEON instruction set. Use -DENABLE_NEON=ON instead." )
+  set(ENABLE_NEON TRUE)
+elseif(USE_VFPV3)
+  message(WARNING "You use obsolete variable USE_VFPV3 to enable VFPV3 instruction set. Use -DENABLE_VFPV3=ON instead." )
+  set(ENABLE_VFPV3 TRUE)
+endif()
+
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${ARM_LINUX_SYSROOT})
+
+if(EXISTS ${CUDA_TOOLKIT_ROOT_DIR})
+  set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${CUDA_TOOLKIT_ROOT_DIR})
+endif()
+
+set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS}
+    ARM_LINUX_SYSROOT
+    ENABLE_NEON
+    ENABLE_VFPV3
+    CUDA_TOOLKIT_ROOT_DIR
+)
+toolchain_save_config()
diff --git a/C++/opencv-4.7.0/platforms/linux/gnu.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/gnu.toolchain.cmake
new file mode 100644
index 00000000..64258e65
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/gnu.toolchain.cmake
@@ -0,0 +1,134 @@
+cmake_minimum_required(VERSION 3.5)
+
+# load settings in case of "try compile"
+set(TOOLCHAIN_CONFIG_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/toolchain.config.cmake")
+get_property(__IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE)
+if(__IN_TRY_COMPILE)
+  include("${CMAKE_CURRENT_SOURCE_DIR}/../toolchain.config.cmake" OPTIONAL) # CMAKE_BINARY_DIR is different
+  macro(toolchain_save_config)
+    # nothing
+  endmacro()
+else()
+  macro(toolchain_save_config)
+    set(__config "#message(\"Load TOOLCHAIN config...\")\n")
+    get_cmake_property(__variableNames VARIABLES)
+    set(__vars_list ${ARGN})
+    list(APPEND __vars_list
+        ${TOOLCHAIN_CONFIG_VARS}
+        CMAKE_SYSTEM_NAME
+        CMAKE_SYSTEM_VERSION
+        CMAKE_SYSTEM_PROCESSOR
+        CMAKE_C_COMPILER
+        CMAKE_CXX_COMPILER
+        CMAKE_C_FLAGS
+        CMAKE_CXX_FLAGS
+        CMAKE_SHARED_LINKER_FLAGS
+        CMAKE_MODULE_LINKER_FLAGS
+        CMAKE_EXE_LINKER_FLAGS
+        CMAKE_SKIP_RPATH
+        CMAKE_FIND_ROOT_PATH
+        GCC_COMPILER_VERSION
+    )
+    foreach(__var ${__variableNames})
+      foreach(_v ${__vars_list})
+        if("x${__var}" STREQUAL "x${_v}")
+          if(${__var} MATCHES " ")
+            set(__config "${__config}set(${__var} \"${${__var}}\")\n")
+          else()
+            set(__config "${__config}set(${__var} ${${__var}})\n")
+          endif()
+        endif()
+      endforeach()
+    endforeach()
+    if(EXISTS "${TOOLCHAIN_CONFIG_FILE}")
+      file(READ "${TOOLCHAIN_CONFIG_FILE}" __config_old)
+    endif()
+    if("${__config_old}" STREQUAL "${__config}")
+      # nothing
+    else()
+      #message("Update TOOLCHAIN config: ${__config}")
+      file(WRITE "${TOOLCHAIN_CONFIG_FILE}" "${__config}")
+    endif()
+    unset(__config)
+    unset(__config_old)
+    unset(__vars_list)
+    unset(__variableNames)
+  endmacro()
+endif() # IN_TRY_COMPILE
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_LIBRARY)
+  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_INCLUDE)
+  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_PACKAGE)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_PROGRAM)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+endif()
+
+macro(__cmake_find_root_save_and_reset)
+  foreach(v
+      CMAKE_FIND_ROOT_PATH_MODE_LIBRARY
+      CMAKE_FIND_ROOT_PATH_MODE_INCLUDE
+      CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+      CMAKE_FIND_ROOT_PATH_MODE_PROGRAM
+  )
+    set(__save_${v} ${${v}})
+    set(${v} NEVER)
+  endforeach()
+endmacro()
+
+macro(__cmake_find_root_restore)
+  foreach(v
+      CMAKE_FIND_ROOT_PATH_MODE_LIBRARY
+      CMAKE_FIND_ROOT_PATH_MODE_INCLUDE
+      CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+      CMAKE_FIND_ROOT_PATH_MODE_PROGRAM
+  )
+    set(${v} ${__save_${v}})
+    unset(__save_${v})
+  endforeach()
+endmacro()
+
+
+# macro to find programs on the host OS
+macro(find_host_program)
+ __cmake_find_root_save_and_reset()
+ if(CMAKE_HOST_WIN32)
+  SET(WIN32 1)
+  SET(UNIX)
+ elseif(CMAKE_HOST_APPLE)
+  SET(APPLE 1)
+  SET(UNIX)
+ endif()
+ find_program(${ARGN})
+ SET(WIN32)
+ SET(APPLE)
+ SET(UNIX 1)
+ __cmake_find_root_restore()
+endmacro()
+
+# macro to find packages on the host OS
+macro(find_host_package)
+ __cmake_find_root_save_and_reset()
+ if(CMAKE_HOST_WIN32)
+  SET(WIN32 1)
+  SET(UNIX)
+ elseif(CMAKE_HOST_APPLE)
+  SET(APPLE 1)
+  SET(UNIX)
+ endif()
+ find_package(${ARGN})
+ SET(WIN32)
+ SET(APPLE)
+ SET(UNIX 1)
+ __cmake_find_root_restore()
+endmacro()
+
+set(CMAKE_SKIP_RPATH TRUE CACHE BOOL "If set, runtime paths are not added when using shared libraries.")
diff --git a/C++/opencv-4.7.0/platforms/linux/mips.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/mips.toolchain.cmake
new file mode 100644
index 00000000..b6b46090
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/mips.toolchain.cmake
@@ -0,0 +1,80 @@
+# ----------------------------------------------------------------------------------------------
+#  MIPS ToolChanin can be downloaded from https://www.mips.com/develop/tools/codescape-mips-sdk/ .
+#  Toolchains with 'mti' in the name (and install directory) are for MIPS R2-R5 instruction sets.
+#  Toolchains with 'img' in the name are for MIPS R6 instruction sets.
+#  It is recommended to use cmake-gui application for build scripts configuration and generation:
+#  1. Run cmake-gui
+#  2. Specify toolchain file for cross-compiling, mips32r5el-gnu.toolchian.cmake or mips64r6el-gnu.toolchain.cmake
+#     can be selected.
+#  3. Configure and Generate makefiles.
+#  4. make -j4 & make install
+# ----------------------------------------------------------------------------------------------
+
+if(COMMAND toolchain_save_config)
+  return() # prevent recursive call
+endif()
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
+  set(CMAKE_SYSTEM_PROCESSOR mips)
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake")
+
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL mips AND NOT MIPS_IGNORE_FP)
+  set(FLOAT_ABI_SUFFIX "")
+endif()
+
+if(NOT "x${GCC_COMPILER_VERSION}" STREQUAL "x")
+  set(__GCC_VER_SUFFIX "-${GCC_COMPILER_VERSION}")
+endif()
+
+if(NOT DEFINED CMAKE_C_COMPILER)
+  find_program(CMAKE_C_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-gcc${__GCC_VER_SUFFIX})
+endif()
+if(NOT DEFINED CMAKE_CXX_COMPILER)
+  find_program(CMAKE_CXX_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-g++${__GCC_VER_SUFFIX})
+endif()
+if(NOT DEFINED CMAKE_LINKER)
+  find_program(CMAKE_LINKER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld)
+endif()
+if(NOT DEFINED CMAKE_AR)
+  find_program(CMAKE_AR NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar)
+endif()
+
+if(NOT DEFINED MIPS_LINUX_SYSROOT AND DEFINED GNU_MACHINE)
+  set(MIPS_LINUX_SYSROOT /usr/bin)
+endif()
+
+if(NOT DEFINED CMAKE_CXX_FLAGS)
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES "mips32r5el")
+    set(CMAKE_C_FLAGS             "-march=mips32r5 -EL -mmsa -mhard-float -mfp64 -mnan=2008 -mabs=2008 -O3 -ffp-contract=off -mtune=p5600" CACHE INTERNAL "")
+    set(CMAKE_SHARED_LINKER_FLAGS "" CACHE INTERNAL "")
+    set(CMAKE_CXX_FLAGS           "-march=mips32r5 -EL -mmsa -mhard-float -mfp64 -mnan=2008 -mabs=2008 -O3 -ffp-contract=off -mtune=p5600" CACHE INTERNAL "")
+    set(CMAKE_MODULE_LINKER_FLAGS "" CACHE INTERNAL "")
+    set(CMAKE_EXE_LINKER_FLAGS    "-lpthread -lrt -ldl -latomic" CACHE INTERNAL "Added for mips cross build error")
+
+    set(CMAKE_CXX_FLAGS           "${CMAKE_CXX_FLAGS} -fdata-sections  -Wa,--noexecstack -fsigned-char -Wno-psabi")
+    set(CMAKE_C_FLAGS             "${CMAKE_C_FLAGS} -fdata-sections  -Wa,--noexecstack -fsigned-char -Wno-psabi")
+  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "mips64r6el")
+    set(CMAKE_C_FLAGS             "-O3 -march=i6500 -EL -mmsa -mabi=64 -mhard-float -mfp64 -mnan=2008" CACHE INTERNAL "")
+    set(CMAKE_SHARED_LINKER_FLAGS "" CACHE INTERNAL "")
+    set(CMAKE_CXX_FLAGS           "-O3 -march=i6500 -EL -mmsa -mabi=64 -mhard-float -mfp64 -mnan=2008" CACHE INTERNAL "")
+    set(CMAKE_MODULE_LINKER_FLAGS "" CACHE INTERNAL "")
+    set(CMAKE_EXE_LINKER_FLAGS    "-lpthread -lrt -ldl" CACHE INTERNAL "Added for mips cross build error")
+
+    set(CMAKE_CXX_FLAGS           "${CMAKE_CXX_FLAGS} -fdata-sections -Wa,--noexecstack -fsigned-char -Wno-psabi")
+    set(CMAKE_C_FLAGS             "${CMAKE_C_FLAGS} -fdata-sections -Wa,--noexecstack -fsigned-char -Wno-psabi")
+  endif()
+  set(CMAKE_SHARED_LINKER_FLAGS "${MIPS_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}")
+  set(CMAKE_MODULE_LINKER_FLAGS "${MIPS_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS    "${MIPS_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}")
+endif()
+
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${MIPS_LINUX_SYSROOT})
+
+set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS}
+    MIPS_LINUX_SYSROOT
+)
+toolchain_save_config()
diff --git a/C++/opencv-4.7.0/platforms/linux/mips32r5el-gnu.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/mips32r5el-gnu.toolchain.cmake
new file mode 100644
index 00000000..d93d4f2c
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/mips32r5el-gnu.toolchain.cmake
@@ -0,0 +1,14 @@
+# ----------------------------------------------------------------------------------------------
+#  MIPS ToolChanin can be downloaded from https://www.mips.com/develop/tools/codescape-mips-sdk/ .
+#  Toolchains with 'mti' in the name (and install directory) are for MIPS R2-R5 instruction sets.
+#  Toolchains with 'img' in the name are for MIPS R6 instruction sets.
+#  It is recommended to use cmake-gui for build scripts configuration and generation:
+#  1. Run cmake-gui
+#  2. Specify toolchain file mips32r5el-gnu.toolchian.cmake for cross-compiling.
+#  3. Configure and Generate makefiles.
+#  4. make -j4 & make install
+# ----------------------------------------------------------------------------------------------
+set(CMAKE_SYSTEM_PROCESSOR mips32r5el)
+set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version")
+set(GNU_MACHINE "mips-mti-linux-gnu" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/mips.toolchain.cmake")
diff --git a/C++/opencv-4.7.0/platforms/linux/mips64r6el-gnu.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/mips64r6el-gnu.toolchain.cmake
new file mode 100644
index 00000000..ce636686
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/mips64r6el-gnu.toolchain.cmake
@@ -0,0 +1,14 @@
+# ----------------------------------------------------------------------------------------------
+#  MIPS ToolChanin can be downloaded from https://www.mips.com/develop/tools/codescape-mips-sdk/ .
+#  Toolchains with 'mti' in the name (and install directory) are for MIPS R2-R5 instruction sets.
+#  Toolchains with 'img' in the name are for MIPS R6 instruction sets.
+#  It is recommended to use cmake-gui for build scripts configuration and generation:
+#  1. Run cmake-gui
+#  2. Specify toolchain file mips64r6el-gnu.toolchain.cmake for cross-compiling.
+#  3. Configure and Generate makefiles.
+#  4. make -j4 & make install
+# ----------------------------------------------------------------------------------------------
+set(CMAKE_SYSTEM_PROCESSOR mips64r6el)
+set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version")
+set(GNU_MACHINE "mips-img-linux-gnu" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/mips.toolchain.cmake")
diff --git a/C++/opencv-4.7.0/platforms/linux/ppc64-gnu.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/ppc64-gnu.toolchain.cmake
new file mode 100644
index 00000000..f6177c4f
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/ppc64-gnu.toolchain.cmake
@@ -0,0 +1,3 @@
+set(CMAKE_SYSTEM_PROCESSOR ppc64)
+set(GNU_MACHINE "powerpc64-linux-gnu" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/ppcat.toolchain.cmake")
diff --git a/C++/opencv-4.7.0/platforms/linux/ppc64le-gnu.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/ppc64le-gnu.toolchain.cmake
new file mode 100644
index 00000000..2266c345
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/ppc64le-gnu.toolchain.cmake
@@ -0,0 +1,3 @@
+set(CMAKE_SYSTEM_PROCESSOR ppc64le)
+set(GNU_MACHINE "powerpc64le-linux-gnu" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/ppcat.toolchain.cmake")
diff --git a/C++/opencv-4.7.0/platforms/linux/ppcat.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/ppcat.toolchain.cmake
new file mode 100644
index 00000000..86ece6b6
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/ppcat.toolchain.cmake
@@ -0,0 +1,129 @@
+if(COMMAND toolchain_save_config)
+  return() # prevent recursive call
+endif()
+
+option(AT_PATH        "Advance Toolchain directory" "")
+option(AT_RPATH       "Add new directories to runtime search path" "")
+option(AT_HOST_LINK   "Enable/disable Link against host advance toolchain runtime" OFF)
+option(AT_NO_AUTOVEC  "Disable/enable Auto Vectorizer optimization" OFF)
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake")
+
+if(NOT DEFINED CMAKE_C_COMPILER)
+  string(REGEX REPLACE "/+$" "" AT_PATH "${AT_PATH}")
+
+  if(NOT AT_PATH)
+    message(FATAL_ERROR "'AT_PATH' option is required. Please set it to Advance Toolchain path to get toolchain works")
+  endif()
+
+  if(NOT EXISTS ${AT_PATH})
+    message(FATAL_ERROR "'${AT_PATH}' Advance Toolchain path isn't exist")
+  endif()
+
+  set(CMAKE_C_COMPILER "${AT_PATH}/bin/${GNU_MACHINE}-gcc")
+
+  if(NOT EXISTS ${CMAKE_C_COMPILER})
+    message(FATAL_ERROR "GNU C compiler isn't exist on path '${CMAKE_C_COMPILER}'. Please install Advance Toolchain with ${CMAKE_SYSTEM_PROCESSOR} supports")
+  endif()
+endif()
+
+if(NOT DEFINED CMAKE_CXX_COMPILER)
+  set(CMAKE_CXX_COMPILER "${AT_PATH}/bin/${GNU_MACHINE}-g++")
+
+  if(NOT EXISTS ${CMAKE_CXX_COMPILER})
+    message(FATAL_ERROR "GNU C++ compiler isn't exist. Invalid install of Advance Toolchain")
+  endif()
+endif()
+
+if(NOT DEFINED AT_GCCROOT_PATH)
+  set(AT_GCCROOT_PATH "${AT_PATH}/${GNU_MACHINE}")
+
+  if(NOT EXISTS ${AT_GCCROOT_PATH})
+    message(FATAL_ERROR "GCC root path '${AT_GCCROOT_PATH}' isn't exist. Invalid install of Advance Toolchain")
+  endif()
+endif()
+
+if(NOT DEFINED AT_SYSROOT_PATH)
+  if(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "ppc64")
+    set(AT_SYSROOT_PATH "${AT_PATH}/ppc")
+  else()
+    set(AT_SYSROOT_PATH "${AT_PATH}/${CMAKE_SYSTEM_PROCESSOR}")
+  endif()
+
+  if(NOT EXISTS ${AT_SYSROOT_PATH})
+    message(FATAL_ERROR "System root path '${AT_SYSROOT_PATH}' isn't exist. Invalid install of Advance Toolchain")
+  endif()
+endif()
+
+if(NOT DEFINED CMAKE_EXE_LINKER_FLAGS)
+  set(CMAKE_CXX_FLAGS           "" CACHE INTERNAL "")
+  set(CMAKE_C_FLAGS             "" CACHE INTERNAL "")
+  set(CMAKE_EXE_LINKER_FLAGS    "" CACHE INTERNAL "")
+  set(CMAKE_SHARED_LINKER_FLAGS "" CACHE INTERNAL "")
+  set(CMAKE_MODULE_LINKER_FLAGS "" CACHE INTERNAL "")
+
+  if(AT_RPATH)
+    string(REPLACE "," ";" RPATH_LIST ${AT_RPATH})
+  endif()
+
+  if(AT_HOST_LINK)
+    #get 64-bit dynamic linker path
+    file(STRINGS "${AT_SYSROOT_PATH}/usr/bin/ldd" RTLDLIST LIMIT_COUNT 1 REGEX "^RTLDLIST=[\"*\"]")
+    string(REGEX REPLACE "RTLDLIST=|\"" "" RTLDLIST "${RTLDLIST}")
+    string(REPLACE " " ";" RTLDLIST "${RTLDLIST}")
+
+    #RTLDLIST must contains 32 and 64 bit paths
+    list(LENGTH RTLDLIST RTLDLIST_LEN)
+    if(NOT RTLDLIST_LEN GREATER 1)
+      message(FATAL_ERROR "Could not fetch dynamic linker path. Invalid install of Advance Toolchain")
+    endif()
+
+    list (GET RTLDLIST 1 LINKER_PATH)
+    set(CMAKE_EXE_LINKER_FLAGS "-Wl,--dynamic-linker=${AT_SYSROOT_PATH}${LINKER_PATH}")
+
+    list(APPEND RPATH_LIST "${AT_GCCROOT_PATH}/lib64/")
+    list(APPEND RPATH_LIST "${AT_SYSROOT_PATH}/lib64/")
+    list(APPEND RPATH_LIST "${AT_SYSROOT_PATH}/usr/lib64/")
+    list(APPEND RPATH_LIST "${PROJECT_BINARY_DIR}/lib/")
+  endif()
+
+  list(LENGTH RPATH_LIST RPATH_LEN)
+  if(RPATH_LEN GREATER 0)
+    set(AT_LINKER_FLAGS "${AT_LINKER_FLAGS} -Wl")
+    foreach(RPATH ${RPATH_LIST})
+      set(AT_LINKER_FLAGS "${AT_LINKER_FLAGS},-rpath,${RPATH}")
+    endforeach()
+  endif()
+
+  set(CMAKE_SHARED_LINKER_FLAGS "${AT_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}")
+  set(CMAKE_MODULE_LINKER_FLAGS "${AT_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS    "${AT_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}")
+
+  if(AT_NO_AUTOVEC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-tree-vectorize -fno-tree-slp-vectorize")
+    set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -fno-tree-vectorize -fno-tree-slp-vectorize")
+  endif()
+
+endif()
+
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${AT_SYSROOT_PATH} ${AT_GCCROOT_PATH})
+set(CMAKE_SYSROOT ${AT_SYSROOT_PATH})
+
+# what about ld.gold?
+if(NOT DEFINED CMAKE_LINKER)
+  find_program(CMAKE_LINKER NAMES ld)
+endif()
+
+if(NOT DEFINED CMAKE_AR)
+  find_program(CMAKE_AR NAMES ar)
+endif()
+
+set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS}
+    CMAKE_SYSROOT
+    AT_SYSROOT_PATH
+    AT_GCCROOT_PATH
+)
+toolchain_save_config()
diff --git a/C++/opencv-4.7.0/platforms/linux/riscv-gnu.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/riscv-gnu.toolchain.cmake
new file mode 100644
index 00000000..662fb6bd
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/riscv-gnu.toolchain.cmake
@@ -0,0 +1,60 @@
+if(COMMAND toolchain_save_config)
+  return() # prevent recursive call
+endif()
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
+  set(CMAKE_SYSTEM_PROCESSOR riscv64)
+else()
+  #message("CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}")
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake")
+
+if(NOT "x${GCC_COMPILER_VERSION}" STREQUAL "x")
+  set(__GCC_VER_SUFFIX "-${GCC_COMPILER_VERSION}")
+endif()
+
+if(NOT DEFINED GNU_MACHINE)
+  set(GNU_MACHINE riscv64-unknown-linux-gnu CACHE STRING "GNU compiler triple")
+endif()
+
+if(NOT DEFINED TOOLCHAIN_COMPILER_LOCATION_HINT)
+  set(TOOLCHAIN_COMPILER_LOCATION_HINT PATHS /opt/riscv/bin ENV PATH)
+endif()
+
+if(NOT DEFINED CMAKE_C_COMPILER)
+  find_program(CMAKE_C_COMPILER NAMES ${GNU_MACHINE}-gcc${__GCC_VER_SUFFIX} ${TOOLCHAIN_COMPILER_LOCATION_HINT})
+else()
+  #message(WARNING "CMAKE_C_COMPILER=${CMAKE_C_COMPILER} is defined")
+endif()
+if(NOT DEFINED CMAKE_CXX_COMPILER)
+  find_program(CMAKE_CXX_COMPILER NAMES ${GNU_MACHINE}-g++${__GCC_VER_SUFFIX} ${TOOLCHAIN_COMPILER_LOCATION_HINT})
+else()
+  #message(WARNING "CMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} is defined")
+endif()
+if(NOT DEFINED CMAKE_LINKER)
+  find_program(CMAKE_LINKER NAMES ${GNU_MACHINE}-ld${__GCC_VER_SUFFIX} ${GNU_MACHINE}-ld ${TOOLCHAIN_COMPILER_LOCATION_HINT})
+else()
+  #message(WARNING "CMAKE_LINKER=${CMAKE_LINKER} is defined")
+endif()
+if(NOT DEFINED CMAKE_AR)
+  find_program(CMAKE_AR NAMES ${GNU_MACHINE}-ar${__GCC_VER_SUFFIX} ${GNU_MACHINE}-ar ${TOOLCHAIN_COMPILER_LOCATION_HINT})
+else()
+  #message(WARNING "CMAKE_AR=${CMAKE_AR} is defined")
+endif()
+
+if(NOT DEFINED RISCV_SYSROOT)
+  get_filename_component(_base_dir ${CMAKE_C_COMPILER} DIRECTORY)
+  get_filename_component(_base_dir ${_base_dir} DIRECTORY)
+  set(RISCV_SYSROOT ${_base_dir}/sysroot CACHE PATH "RISC-V sysroot")
+endif()
+
+set(CMAKE_SYSROOT "${RISCV_SYSROOT}")
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${RISCV_SYSROOT})
+
+set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS}
+    RISCV_SYSROOT
+)
+toolchain_save_config()
diff --git a/C++/opencv-4.7.0/platforms/linux/riscv64-071-gcc.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/riscv64-071-gcc.toolchain.cmake
new file mode 100644
index 00000000..be2c7dcd
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/riscv64-071-gcc.toolchain.cmake
@@ -0,0 +1,9 @@
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_C_COMPILER  riscv64-unknown-linux-gnu-gcc)
+set(CMAKE_CXX_COMPILER riscv64-unknown-linux-gnu-g++)
+
+set(CMAKE_CXX_FLAGS ""    CACHE STRING "")
+set(CMAKE_C_FLAGS ""    CACHE STRING "")
+
+set(CMAKE_CXX_FLAGS "-static -march=rv64gcvxthead -mabi=lp64v -pthread -D__riscv_vector_071")
+set(CMAKE_C_FLAGS "-static -march=rv64gcvxthead -mabi=lp64v -pthread -D__riscv_vector_071")
diff --git a/C++/opencv-4.7.0/platforms/linux/riscv64-clang.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/riscv64-clang.toolchain.cmake
new file mode 100644
index 00000000..cec5f7d7
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/riscv64-clang.toolchain.cmake
@@ -0,0 +1,27 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR riscv64)
+
+set(RISCV_CLANG_BUILD_ROOT /opt/rvv-llvm CACHE PATH "Path to CLANG for RISC-V cross compiler build directory")
+set(RISCV_GCC_INSTALL_ROOT /opt/riscv CACHE PATH "Path to GCC for RISC-V cross compiler installation directory")
+set(CMAKE_SYSROOT ${RISCV_GCC_INSTALL_ROOT}/sysroot CACHE PATH "RISC-V sysroot")
+
+set(CLANG_TARGET_TRIPLE riscv64-unknown-linux-gnu)
+
+set(CMAKE_C_COMPILER ${RISCV_CLANG_BUILD_ROOT}/bin/clang)
+set(CMAKE_C_COMPILER_TARGET ${CLANG_TARGET_TRIPLE})
+set(CMAKE_CXX_COMPILER ${RISCV_CLANG_BUILD_ROOT}/bin/clang++)
+set(CMAKE_CXX_COMPILER_TARGET ${CLANG_TARGET_TRIPLE})
+set(CMAKE_ASM_COMPILER ${RISCV_CLANG_BUILD_ROOT}/bin/clang)
+set(CMAKE_ASM_COMPILER_TARGET ${CLANG_TARGET_TRIPLE})
+
+# Don't run the linker on compiler check
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+set(CMAKE_C_FLAGS "-march=rv64gc --gcc-toolchain=${RISCV_GCC_INSTALL_ROOT} -w ${CMAKE_C_FLAGS}")
+set(CMAKE_CXX_FLAGS "-march=rv64gc --gcc-toolchain=${RISCV_GCC_INSTALL_ROOT} -w ${CXX_FLAGS}")
+
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
diff --git a/C++/opencv-4.7.0/platforms/linux/riscv64-gcc.toolchain.cmake b/C++/opencv-4.7.0/platforms/linux/riscv64-gcc.toolchain.cmake
new file mode 100644
index 00000000..c3a0e161
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/linux/riscv64-gcc.toolchain.cmake
@@ -0,0 +1,10 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+set(GNU_MACHINE riscv64-unknown-linux-gnu CACHE STRING "GNU compiler triple")
+
+if(NOT DEFINED CMAKE_CXX_FLAGS)  # guards toolchain multiple calls
+  set(CMAKE_C_FLAGS "-march=rv64gc")
+  set(CMAKE_CXX_FLAGS "-march=rv64gc")
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/riscv-gnu.toolchain.cmake")
diff --git a/C++/opencv-4.7.0/platforms/maven/README.md b/C++/opencv-4.7.0/platforms/maven/README.md
new file mode 100644
index 00000000..55c11ac8
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/maven/README.md
@@ -0,0 +1,95 @@
+# Using Maven to build OpenCV
+
+This page describes the how to build OpenCV using [Apache Maven](http://maven.apache.org/index.html). The Maven build is simply a wrapper around the existing CMake process but has the additional aims of creating Java OSGi-compatible bundles with included native support and also allow the build to be carried out on RaspberryPi (ARM) architecture. There is nothing preventing using the POM on x86 Linux however.
+
+The following assumes building on Debian-based Linux platform.
+
+## 1 - Overview
+The Maven build process aims to:
+  1. Provide a simpler route to build OpenCV and Java bundles.
+  2. Automatically check the required native dependencies.
+  3. Make the Java libraries OSGi compatible.
+  4. Include the native OpenCV native library inside the Java bundle.
+  5. Integration testing of the bundle within an OSGi environment.
+  6. Allow the build to function on x86, x86_64 or amd architectures, Debian-based Linux platform.
+
+### 2 - Preparing The Build environment
+To build using the Maven build process both `Maven` and and up-to-date `JDK` (Java Development Kit) need to be installed. If you know you already have these installed then continue to `Environment Variable` otherwise the easiest solution is to install them using the aptitude package manager:
+
+`sudo aptitude install maven default-jdk`
+
+Note that installing via `aptitude` you are unlikely to get the latest version of Maven or JDK although if you are not developing Java code this shouldn't matter for this build process.
+
+### 3 - Starting the build
+#### 3.1 - Environment variables
+**Applicability:** All processors.
+
+   The following environment variables must be set otherwise the build will fail and halt:
+
+   * `$JAVA_HOME` (the absolute path to the JDK root directory)
+   * `$ANT_HOME` (the absolute path to the Ant root directory)
+
+It is recommended that advantage is taken of multiple processor cores to reduce build time. This can be done by setting a MAKEFLAGS environment variable specifying the number of parallel builds e.g.:
+
+   * `$MAKEFLAGS="-j8"`
+
+However if this flag is not set the build will NOT fail. On a RaspberryPi 2 typical build times are 5 hours with `-j1` (which is the default if `$MAKEFLAGS` is not specified) and a little over 2 hours with `-j4`.
+
+All of the above environment variables can be set on an ad-hoc basis using 'export'.
+#### 3.2 - Build Directory
+**Applicability:** All processors
+
+By default the following build directories are created.
+
+`<OpenCV_root_dir>/build`
+
+`<OpenCV_root_dir>/build/maven/opencv/target`
+
+`<OpenCV_root_dir>/build/maven/opencv-it/target`
+
+Under `build` are the standard OpenCV artifacts. Under `build/maven/opencv/target` can be found the OSGi compatible Java bundle. When deploying the bundle into an OSGi framework e.g. [Apache Karaf](http://karaf.apache.org/), loading of the native library is automatically taken care of. An integration testing module is created under the `opencv-it` directory and is only of use during the build but is disabled by fault. The standard Java library as created by the CMake process is also available as specified in the existing OpenCV documentation.
+
+The Maven build is initiated from the directory contain the `pom.xml` file.
+#### 3.3 - x86 or x86_64 Architecture:
+Generally all that is required is the standard Maven command:
+
+`mvn clean install`
+
+One of the first things the build will do is check the required native dependencies. The Maven build indicates the status of the required dependencies and will fail at this point if any are missing. Install using the package manager e.g. aptitude or apt-get, and restart the build with the above command.
+
+Once the build successfully completes the OSGi compatible artifacts are available as described above in 'Build Directory'.
+
+#### 3.4 - ARM 32-bit Architecture - Raspbian Distribution
+Similar to the x86 architecture the native dependencies are first checked so install any that are missing, however at the time of writing there are no official `libtbb2` and `libtbb-dev` packages in Raspbian. Version 4.4.3 of Intel's Thread Building Blocks library are available [here](http://www.javatechnics.com/thread-building-blocks-tbb-4-4-3-for-raspbian) as a Raspbian-compatible Debian packages.
+
+**PLEASE NOTE THESE ARE NOT OFFICIAL RASPBIAN PACKAGES. INSTALL AT YOUR OWN RISK.**
+
+The build can be started with the following command:
+
+`mvn clean install`
+
+Upon a successful build the libraries will be available as described above in 'Build Directory'.
+
+#### 3.5 CMake
+**Applicability:** x86 processors
+
+The CMake Maven plugin is configured to use the native CMake package (recommended) i.e. it will NOT download the latest CMake binary. Should you require CMake download then include the following Maven commandline switch when building:
+
+ `-Ddownload.cmake=true`
+
+ #### 3.6 Integration Tests
+ **Applicability:** All processors
+
+ OSGi integration tests can be run as part of the build by including the following commandline switch to Maven:
+
+ `-Pintegration`
+
+### 4.0 Maintainer Notes
+This section is relevant to those maintaining the Maven platform build. If you just want to build the library then you do not need to refer to this section.
+
+#### 4.1 Updating POM Version to Match Core Version
+Maven requires the version to be hard-coded in the POM or in otherwords it cannot be changed at runtime. When the core C/C++ code version changes it is easy to forget to update the Maven version. The POM utilises the enforcer plugin to ensure the POM and Core versions match causing the build to fail if they do not.
+
+Should the POM version require updating then this can be done utilising the Maven 'versions' plugin and this will apply the correct version to all POMs within the project. Execute the following Maven command from the root directory of the Maven project:
+
+`mvn versions:set -DnewVersion=$(. ./opencv/scripts/functions && cd ./opencv/scripts && extract_version && echo $REPLY)`
diff --git a/C++/opencv-4.7.0/platforms/maven/opencv-it/pom.xml b/C++/opencv-4.7.0/platforms/maven/opencv-it/pom.xml
new file mode 100644
index 00000000..f4699df1
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/maven/opencv-it/pom.xml
@@ -0,0 +1,111 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.opencv</groupId>
+        <artifactId>opencv-parent</artifactId>
+        <version>4.7.0</version>
+    </parent>
+    <groupId>org.opencv</groupId>
+    <artifactId>opencv-it</artifactId>
+    <name>OpenCV Integration Test</name>
+    <dependencies>
+        <dependency>
+            <groupId>org.ops4j.pax.exam</groupId>
+            <artifactId>pax-exam-container-karaf</artifactId>
+            <version>${pax.exam.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.ops4j.pax.exam</groupId>
+            <artifactId>pax-exam-junit4</artifactId>
+            <version>${pax.exam.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.geronimo.specs</groupId>
+            <artifactId>geronimo-atinject_1.0_spec</artifactId>
+            <version>1.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.ops4j.pax.url</groupId>
+            <artifactId>pax-url-aether</artifactId>
+            <version>1.6.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.osgi</groupId>
+            <artifactId>org.osgi.core</artifactId>
+            <version>4.3.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.osgi</groupId>
+            <artifactId>org.osgi.compendium</artifactId>
+            <version>4.3.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>1.7.24</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>1.7.24</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <artifactId>org.apache.karaf.log.core</artifactId>
+            <groupId>org.apache.karaf.log</groupId>
+            <version>4.0.6</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.ops4j.pax.logging</groupId>
+            <artifactId>pax-logging-api</artifactId>
+            <version>1.8.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.8.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>opencv</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <build>
+        <directory>../../../build/maven/opencv-it/target</directory>
+        <testSourceDirectory>src/test/java</testSourceDirectory>
+        <testOutputDirectory>../../../build/maven/opencv-it/target</testOutputDirectory>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.servicemix.tooling</groupId>
+                <artifactId>depends-maven-plugin</artifactId>
+                <version>1.4.0</version>
+                <executions>
+                    <execution>
+                        <id>generate-depends-file</id>
+                        <goals>
+                            <goal>generate-depends-file</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.15</version>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/C++/opencv-4.7.0/platforms/maven/opencv-it/src/test/java/org/opencv/osgi/DeployOpenCVTest.java b/C++/opencv-4.7.0/platforms/maven/opencv-it/src/test/java/org/opencv/osgi/DeployOpenCVTest.java
new file mode 100644
index 00000000..25d85929
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/maven/opencv-it/src/test/java/org/opencv/osgi/DeployOpenCVTest.java
@@ -0,0 +1,97 @@
+package org.opencv.osgi;
+
+import java.io.File;
+import javax.inject.Inject;
+import junit.framework.TestCase;
+import org.apache.karaf.log.core.LogService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.ops4j.pax.exam.Configuration;
+import static org.ops4j.pax.exam.CoreOptions.maven;
+import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
+import org.ops4j.pax.exam.Option;
+import org.ops4j.pax.exam.junit.PaxExam;
+import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.karafDistributionConfiguration;
+import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.keepRuntimeFolder;
+import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.logLevel;
+import org.ops4j.pax.exam.karaf.options.LogLevelOption;
+import org.ops4j.pax.exam.options.MavenArtifactUrlReference;
+import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
+import org.ops4j.pax.exam.spi.reactors.PerClass;
+import org.ops4j.pax.logging.spi.PaxLoggingEvent;
+import org.osgi.framework.BundleContext;
+
+/**
+ *
+ * @author Kerry Billingham <contact@AvionicEngineers.com>
+ */
+@ExamReactorStrategy(PerClass.class)
+@RunWith(PaxExam.class)
+public class DeployOpenCVTest {
+
+    /*
+    The expected string in Karaf logs when the bundle has deployed and native library loaded.
+    */
+    private static final String OPENCV_SUCCESSFUL_LOAD_STRING = "Successfully loaded OpenCV native library.";
+
+    private static final String KARAF_VERSION = "4.0.6";
+
+    @Inject
+    protected BundleContext bundleContext;
+
+    @Inject
+    private LogService logService;
+
+    /*
+    This service is required to ensure that the native library has been loaded
+    before any test is carried out.
+    */
+    @Inject
+    private OpenCVInterface openCVInterface;
+
+    @Configuration
+    public static Option[] configuration() throws Exception {
+        MavenArtifactUrlReference karafUrl = maven()
+                .groupId("org.apache.karaf")
+                .artifactId("apache-karaf")
+                .version(KARAF_VERSION)
+                .type("tar.gz");
+        return new Option[]{
+            karafDistributionConfiguration()
+            .frameworkUrl(karafUrl)
+            .unpackDirectory(new File("../../../build/target/exam"))
+            .useDeployFolder(false),
+            keepRuntimeFolder(),
+            mavenBundle()
+            .groupId("org.opencv")
+            .artifactId("opencv")
+            .versionAsInProject(),
+            logLevel(LogLevelOption.LogLevel.INFO)
+        };
+    }
+
+    /**
+     * Tests that the OpenCV bundle has been successfully deployed and that the
+     * native library has been loaded.
+     */
+    @Test
+    public void testOpenCVNativeLibraryLoadSuccess() {
+
+        Iterable<PaxLoggingEvent> loggingEvents = logService.getEvents();
+        boolean loadSuccessful = logsContainsMessage(loggingEvents, OPENCV_SUCCESSFUL_LOAD_STRING);
+
+        TestCase.assertTrue("Could not determine if OpenCV library successfully loaded from the logs.", loadSuccessful);
+
+    }
+
+    private boolean logsContainsMessage(Iterable<PaxLoggingEvent> logEnumeration, final String logMessageString) {
+        boolean contains = false;
+        for (PaxLoggingEvent logEntry : logEnumeration) {
+            if (logEntry.getMessage().contains(logMessageString)) {
+                contains = true;
+                break;
+            }
+        }
+        return contains;
+    }
+}
diff --git a/C++/opencv-4.7.0/platforms/maven/opencv/pom.xml b/C++/opencv-4.7.0/platforms/maven/opencv/pom.xml
new file mode 100644
index 00000000..bfbf2eef
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/maven/opencv/pom.xml
@@ -0,0 +1,272 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.opencv</groupId>
+        <artifactId>opencv-parent</artifactId>
+        <version>4.7.0</version>
+    </parent>
+    <groupId>org.opencv</groupId>
+    <artifactId>opencv</artifactId>
+    <packaging>bundle</packaging>
+    <name>OpenCV</name>
+
+    <properties>
+        <source.path>../../..</source.path>
+        <build.directory>${source.path}/build</build.directory>
+        <nativelibrary.name>libopencv_java${lib.version.string}.so</nativelibrary.name>
+        <resources.directory>${build.directory}/src</resources.directory>
+    </properties>
+    <build>
+        <directory>../../../build/maven/opencv/target</directory>
+        <outputDirectory>../../../build/src</outputDirectory>
+        <sourceDirectory>../../../build/src</sourceDirectory>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-clean-plugin</artifactId>
+                <version>3.0.0</version>
+                <configuration>
+                    <filesets>
+                        <fileset>
+                            <directory>${build.directory}</directory>
+                        </fileset>
+                    </filesets>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>exec-maven-plugin</artifactId>
+                <version>1.4.0</version>
+                <executions>
+                    <execution>
+                        <id>get-opencv-version</id>
+                        <phase>generate-resources</phase>
+                        <goals>
+                            <goal>exec</goal>
+                        </goals>
+                        <configuration>
+                            <executable>bash</executable>
+                            <workingDirectory>${project.basedir}/scripts</workingDirectory>
+                            <arguments>
+                                <argument>properties</argument>
+                                <argument>${build.directory}</argument>
+                                <argument>build.properties</argument>
+                            </arguments>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>setup-environment</id>
+                        <phase>validate</phase>
+                        <goals>
+                            <goal>exec</goal>
+                        </goals>
+                        <configuration>
+                            <executable>bash</executable>
+                            <workingDirectory>${project.basedir}/scripts</workingDirectory>
+                            <arguments>
+                              <!-- Optional packages should be placed BEFORE required ones
+                              in the following argument list. -->
+                                <argument>deb_package_check</argument>
+                                <argument>-olibpng-dev|libpng12-dev</argument>
+                                <argument>-olibopenjp2-7-dev|libjasper-dev</argument>
+                                <argument>-opython-dev</argument>
+                                <argument>-opython-numpy</argument>
+                                <argument>build-essential</argument>
+                                <argument>cmake</argument>
+                                <argument>git</argument>
+                                <argument>libgtk2.0-dev</argument>
+                                <argument>pkg-config</argument>
+                                <argument>libavcodec-dev</argument>
+                                <argument>libavformat-dev</argument>
+                                <argument>libswscale-dev</argument>
+                                <argument>libtbb2</argument>
+                                <argument>libtbb-dev</argument>
+                                <argument>libjpeg-dev</argument>
+                                <argument>libtiff5-dev</argument>
+                                <argument>libdc1394-22-dev</argument>
+                                <argument>execstack</argument>
+                                <argument>ant</argument>
+                            </arguments>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>check-execstack</id>
+                        <phase>process-classes</phase>
+                        <goals>
+                            <goal>exec</goal>
+                        </goals>
+                        <configuration>
+                            <workingDirectory>${project.basedir}/scripts</workingDirectory>
+                            <executable>bash</executable>
+                            <arguments>
+                                <argument>execstack_check</argument>
+                                <argument>${build.directory}/lib/libopencv_java${lib.version.string}.so</argument>
+                            </arguments>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-resources-plugin</artifactId>
+                <version>3.0.2</version>
+                <executions>
+                    <execution>
+                        <id>copy-resources</id>
+                        <phase>generate-resources</phase>
+                        <goals>
+                            <goal>copy-resources</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>${resources.directory}</outputDirectory>
+                            <resources>
+                                <resource>
+                                    <directory>resources</directory>
+                                </resource>
+                            </resources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>properties-maven-plugin</artifactId>
+                <version>1.0.0</version>
+                <executions>
+                    <execution>
+                        <id>set-arch-properties</id>
+                        <phase>process-resources</phase>
+                        <goals>
+                            <goal>read-project-properties</goal>
+                        </goals>
+                        <configuration>
+                            <files>
+                                <file>${build.directory}/build.properties</file>
+                            </files>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-enforcer-plugin</artifactId>
+                <version>1.4.1</version>
+                <executions>
+                    <execution>
+                        <phase>validate</phase>
+                        <id>enforce-os</id>
+                        <goals>
+                            <goal>enforce</goal>
+                        </goals>
+                        <configuration>
+                            <rules>
+                                <requireOS>
+                                    <family>unix</family>
+                                    <message>This POM is written to function on UNIX family of OS.
+                                        More specifically it should be a Debian flavour of Linux.</message>
+                                </requireOS>
+                            </rules>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>enforce-environment</id>
+                        <goals>
+                            <goal>enforce</goal>
+                        </goals>
+                        <configuration>
+                            <rules>
+                                <requireEnvironmentVariable>
+                                    <level>ERROR</level>
+                                    <variableName>ANT_HOME</variableName>
+                                    <message>$ANT_HOME is not set. Build may fail.</message>
+                                </requireEnvironmentVariable>
+                                <requireEnvironmentVariable>
+                                    <level>ERROR</level>
+                                    <variableName>JAVA_HOME</variableName>
+                                    <message>$JAVA_HOME is not set. Build will fail.</message>
+                                </requireEnvironmentVariable>
+                                <requireEnvironmentVariable>
+                                    <level>WARN</level>
+                                    <variableName>MAKEFLAGS</variableName>
+                                    <message>No MAKEFLAGS environment variable. Build may be slow.
+To speed up the build you can try exporting MAKEFLAGS=-jX where X equals the number of parallel builds.</message>
+                                </requireEnvironmentVariable>
+                            </rules>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <phase>process-resources</phase>
+                        <id>check-versions-match</id>
+                        <goals>
+                            <goal>enforce</goal>
+                        </goals>
+                        <configuration>
+                            <rules>
+                                <requireProperty>
+                                    <property>project.version</property>
+                                    <regex>${opencv.version}</regex>
+                                    <regexMessage>The Maven POM version ${project.version} does not match the extracted OpenCV version ${opencv.version}.
+To correct this please execute the following Maven command from the Maven root directory:
+    mvn versions:set -DnewVersion=$(. ./opencv/scripts/functions &amp;&amp; cd ./opencv/scripts &amp;&amp; extract_version &amp;&amp; echo $REPLY)</regexMessage>
+                                </requireProperty>
+                            </rules>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-bundle-plugin</artifactId>
+                <version>2.3.7</version>
+                <extensions>true</extensions>
+                <configuration>
+                    <instructions>
+                        <Export-Package>*</Export-Package>
+                        <Bundle-NativeCode>${nativelibrary.name};osname=linux;processor=${osgi.processor}</Bundle-NativeCode>
+                        <Include-Resource>${build.directory}/lib/${nativelibrary.name}</Include-Resource>
+                    </instructions>
+                    <manifestLocation>${build.directory}/manifest</manifestLocation>
+                    <niceManifest>true</niceManifest>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>com.googlecode.cmake-maven-project</groupId>
+                <artifactId>cmake-maven-plugin</artifactId>
+                <version>3.4.1-b2</version>
+                <executions>
+                    <execution>
+                        <phase>generate-sources</phase>
+                        <id>cmake-generate</id>
+                        <goals>
+                            <goal>generate</goal>
+                        </goals>
+                        <configuration>
+                            <sourcePath>../../..</sourcePath>
+                            <targetPath>../../../build</targetPath>
+                            <generator>Unix Makefiles</generator>
+                            <options>
+                                <option>-DBUILD_SHARED_LIBS:BOOL=OFF</option>
+                            </options>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <phase>generate-sources</phase>
+                        <id>cmake-compile</id>
+                        <goals>
+                            <goal>compile</goal>
+                        </goals>
+                        <configuration>
+                            <target>opencv_java</target>
+                            <projectDirectory>../../../build</projectDirectory>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.15</version>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/C++/opencv-4.7.0/platforms/maven/opencv/resources/OSGI-INF/blueprint/blueprint.xml b/C++/opencv-4.7.0/platforms/maven/opencv/resources/OSGI-INF/blueprint/blueprint.xml
new file mode 100644
index 00000000..cdd99787
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/maven/opencv/resources/OSGI-INF/blueprint/blueprint.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<blueprint
+    xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
+    xmlns='http://www.osgi.org/xmlns/blueprint/v1.0.0'
+    xsi:schemaLocation='http://www.osgi.org/xmlns/blueprint/v1.0.0 https://osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd'>
+
+    <bean id="opencvnativeloader" class="org.opencv.osgi.OpenCVNativeLoader" scope="singleton" init-method="init" />
+
+    <service id="opencvtestservice" ref="opencvnativeloader" interface="org.opencv.osgi.OpenCVInterface" />
+
+</blueprint>
diff --git a/C++/opencv-4.7.0/platforms/maven/opencv/scripts/deb_package_check b/C++/opencv-4.7.0/platforms/maven/opencv/scripts/deb_package_check
new file mode 100644
index 00000000..ced31acc
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/maven/opencv/scripts/deb_package_check
@@ -0,0 +1,102 @@
+#!/bin/bash
+##################################################################################################
+#
+# 		This script checks for the required Debian packages are installed
+# 		to build OpenCV.
+# Commandline parameters:
+# $@                These are the names of the packages to check with 'dpkg'. Multiple values may
+#         be specified per package by using pipe as a delimiter, e.g. libpng-dev|libpng12-dev.
+#         Multiple values are evaluated left-to-right and the first found prevents checking of
+#         the remaining package options.
+#
+# -o <package_name> Specifying this switch with a package name marks it as optional
+#                   i.e. it is not required to be installed.
+#
+# Returns:
+#   0 - All packages installed (success)
+#   1 - One or more packages missing (failure)
+#
+#   Kerry Billingham <contact (at) avionicengineers (d0t) com>
+#   20 April 2016
+#
+##################################################################################################
+red=$'\e[1;31m'
+green=$'\e[1;32m'
+yellow=$'\e[1;33m'
+end=$'\e[0m'
+check_message="Checking for "
+declare -i packageMissing=0
+declare -i installed=1
+
+#########################
+# Function declarations.
+#########################
+function check_package() {
+     check_message="Checking for package "
+     dpkg -s $1 &>/dev/null
+     is_installed=$?
+     if [ ${is_installed} -ne 0 ]; then
+          printf "%-80s%s\n" "$2${check_message}${red}$1" " MISSING.${end}"
+          packageMissing=1
+     else
+          printf "%-80s%s\n" "$2${check_message}${green}$1" " INSTALLED.${end}"
+          packageMissing=0
+     fi
+     return $is_installed
+}
+
+# Main part of script.
+ORIGINAL_IFS=$IFS
+
+dpkg -? &>/dev/null
+if [ $? -ne 0 ]; then
+    printf "%-80s%s\n" "${check_message} ${red}'dpkg'" " MISSING.${end}"
+    exit 1
+else
+    printf "%-80s%s\n" "${check_message} ${green}'dpkg'" " INSTALLED.${end}"
+fi
+
+while getopts o: option; do
+    case $option in
+        o)
+            IFS="|"
+            packageChoices=( ${OPTARG} )
+            if [ ${#packageChoices[@]} -gt 1 ]; then
+                echo "Optional package. One of ${yellow}${packageChoices[@]}${end} can be installed."
+                for choice in ${packageChoices[@]}; do
+                    check_package ${choice} "    "
+                    if [ $? -eq 0 ]; then
+                        break
+                    fi
+                done
+            else
+                echo "Optional package ${yellow}${packageChoices}${end}"
+                check_package ${OPTARG} "    "
+            fi
+            IFS=$ORIGINAL_IFS
+            ;;
+        \?)
+            echo "No option found"
+            ;;
+    esac
+done
+
+shift $((OPTIND-1))
+packageArray=( $@ )
+for package in ${packageArray[@]}; do
+    IFS="|"
+    packageChoices=( ${package} )
+    if [ ${#packageChoices[@]} -gt 1 ]; then
+        echo "Multiple options. One of ${yellow}${packageChoices[@]}${end} must be installed."
+        for choice in ${packageChoices[@]}; do
+            check_package ${choice} "    "
+            if [ $? -eq 0 ]; then
+                break
+            fi
+        done
+    else
+        check_package ${package} ""
+    fi
+done
+
+exit $packageMissing
diff --git a/C++/opencv-4.7.0/platforms/maven/opencv/scripts/execstack_check b/C++/opencv-4.7.0/platforms/maven/opencv/scripts/execstack_check
new file mode 100644
index 00000000..04faeff4
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/maven/opencv/scripts/execstack_check
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+##################################################################
+#
+#	This script will clear the executable flag on
+#	the specified library and then check it has
+#	been cleared as a separate operation.
+#
+#	$1 - The absolute path to the OpenCV native library.
+#
+#	Returns:
+#	0 - The executable flag has been cleared
+#	1 - The executable flag could NOT be cleared (failure).
+#
+#   Kerry Billingham <contact (at) avionicengineers (d0t) com>
+#   11 March 2017
+#
+##################################################################
+red=$'\e[1;31m'
+green=$'\e[1;32m'
+end=$'\e[0m'
+echo "${green}[INFO] Checking that the native library executable stack flag is NOT set.${end}"
+BINARY=execstack
+$BINARY --help > /dev/null || BINARY=/usr/sbin/execstack
+$BINARY -c $1
+$BINARY -q $1 | grep -o ^-
+if [ $? -ne 0 ]; then
+    echo
+    echo "${red}[ERROR] The Executable Flag could not be cleared on the library $1.${end}"
+    exit 1
+fi
+exit 0
diff --git a/C++/opencv-4.7.0/platforms/maven/opencv/scripts/functions b/C++/opencv-4.7.0/platforms/maven/opencv/scripts/functions
new file mode 100644
index 00000000..7d2f7648
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/maven/opencv/scripts/functions
@@ -0,0 +1,21 @@
+#!/bin/bash
+###############################################################
+#
+# Defines some common functions.
+#
+# Kerry Billingham <contact [At] AvionicEngineers.{com]>
+#
+##############################################################
+majorHashDefine="#define CV_VERSION_MAJOR"
+minorHashDefine="#define CV_VERSION_MINOR"
+revisionHashDefine="#define CV_VERSION_REVISION"
+statusHashDefine="#define CV_VERSION_STATUS"
+versionHeader="../../../../modules/core/include/opencv2/core/version.hpp"
+
+function extract_version() {
+    minorVersion=$(grep "${minorHashDefine}" $versionHeader | grep -o ".$")
+    majorVersion=$(grep "${majorHashDefine}" $versionHeader | grep -o ".$")
+    revision=$(grep "${revisionHashDefine}" $versionHeader | grep -o ".$")
+
+    REPLY="${majorVersion}.${minorVersion}.${revision}"
+}
diff --git a/C++/opencv-4.7.0/platforms/maven/opencv/scripts/properties b/C++/opencv-4.7.0/platforms/maven/opencv/scripts/properties
new file mode 100644
index 00000000..cd7f665b
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/maven/opencv/scripts/properties
@@ -0,0 +1,86 @@
+#!/bin/bash
+#####################################################################
+# This script extracts several properties and then writes them to a
+# to a file, 'build.properties'. These properties include:
+#
+#	1. OpenCV version.
+#	2. OpenVC version as a string for use by Maven.
+#	3. The CPU binary word size.
+#	4. Architecture string.
+#	4. OSGi compatible CPU architecture string.
+#
+# There is no need to execute this script directly as it will be
+# called during the Maven build process.
+#
+# Command-line parameters:
+#   $1 - The build directory and where the output file will be written
+#   $2 - The name of the output file to write to.
+#
+# Returns:
+#   0 - Successfully written the properties file.
+#   1 - Error occurred such as build directory does not exist
+#	or OpenCV version could not be determined or an
+#	unexpected error.
+#
+#   Kerry Billingham <contact (at) avionicengineers (d0t) com>
+#   20 April 2016
+#
+#####################################################################
+
+# Include some external functions and variables
+. ./functions
+
+#Test build directory exists
+if [  ! -n "$1" ] || [ ! -d $1 ];then
+    echo "Build directory not specified or does not exist!"
+    exit 1
+fi
+
+if [ -n "${versionHeader}" ] && [ -e ${versionHeader} ];then
+
+    extract_version
+
+    bits=$(getconf LONG_BIT)
+    architecture=$(arch)
+    osgiProcessor="Not Set"
+
+    case ${architecture} in
+        x86*)
+            echo "This is x86 (32 | 64) bit"
+            case ${bits} in
+                32)
+                    osgiProcessor="x86"
+                    ;;
+                64)
+                    osgiProcessor="x86_64"
+                    ;;
+                *)
+                    osgiProcessor="Unknown"
+            esac
+            ;;
+        arm*)
+            echo "This is ARM"
+            byteOrder=$(lscpu | grep -i "byte order")
+            shopt -s nocasematch
+            if [[ "${byteOrder}" == *little* ]]; then
+                osgiProcessor="arm_le"
+            elif [[ "${byteOrder}}" == *big* ]]; then
+                osgiProcessor="arm_be"
+            fi
+            shopt -u nocasematch
+            ;;
+        *)
+            echo "This is unknown architecture"
+        esac
+
+    echo "The version number will be ${majorVersion}.${minorVersion}.${revision}"
+    echo "opencv.version=${majorVersion}.${minorVersion}.${revision}" > ${1}/${2}
+    echo "lib.version.string=${majorVersion}${minorVersion}${revision}" >> ${1}/${2}
+    echo "bits=${bits}" >> ${1}/${2}
+    echo "architecture=$(arch)" >> ${1}/${2}
+    echo "osgi.processor=${osgiProcessor}" >> ${1}/${2}
+    exit 0
+else
+    echo "Could not locate file ${versionHeader} to determine versioning."
+    exit 1
+fi
diff --git a/C++/opencv-4.7.0/platforms/maven/pom.xml b/C++/opencv-4.7.0/platforms/maven/pom.xml
new file mode 100644
index 00000000..73d5302c
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/maven/pom.xml
@@ -0,0 +1,57 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>org.opencv</groupId>
+    <artifactId>opencv-parent</artifactId>
+    <version>4.7.0</version>
+    <packaging>pom</packaging>
+    <name>OpenCV Parent POM</name>
+    <licenses>
+        <license>
+            <name>License Agreement For Open Source Computer Vision Library (Apache 2.0 License)</name>
+            <url>http://opencv.org/license.html</url>
+        </license>
+    </licenses>
+    <url>http://opencv.org/</url>
+    <scm>
+        <connection>scm:git:https://github.com/opencv/opencv.git</connection>
+        <url>https://github.com/opencv/opencv</url>
+    </scm>
+    <contributors>
+        <contributor>
+            <name>Kerry Billingham</name>
+            <email>contact (at) AvionicEngineers (d0t) c(0)m</email>
+            <organization>Java Technics</organization>
+            <url>www.javatechnics.com</url>
+        </contributor>
+    </contributors>
+
+    <properties>
+        <nativelibrary.name>libopencv_java${lib.version.string}.so</nativelibrary.name>
+        <pax.exam.version>4.8.0</pax.exam.version>
+        <maven.compiler.source>1.7</maven.compiler.source>
+        <maven.compiler.target>1.7</maven.compiler.target>
+        <download.cmake>false</download.cmake>
+    </properties>
+    <distributionManagement>
+        <snapshotRepository>
+            <id>${repo.name}</id>
+            <url>${repo.url}</url>
+        </snapshotRepository>
+    </distributionManagement>
+
+    <modules>
+        <module>opencv</module>
+    </modules>
+    <profiles>
+        <profile>
+            <id>integration</id>
+            <activation>
+                <activeByDefault>false</activeByDefault>
+            </activation>
+            <modules>
+                <module>opencv-it</module>
+            </modules>
+        </profile>
+    </profiles>
+</project>
diff --git a/C++/opencv-4.7.0/platforms/osx/Info.plist.in b/C++/opencv-4.7.0/platforms/osx/Info.plist.in
new file mode 100644
index 00000000..a166934b
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/osx/Info.plist.in
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleName</key>
+    <string>${OPENCV_APPLE_BUNDLE_NAME}</string>
+    <key>CFBundleIdentifier</key>
+    <string>${OPENCV_APPLE_BUNDLE_ID}</string>
+    <key>CFBundleVersion</key>
+    <string>${OPENCV_LIBVERSION}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${OPENCV_LIBVERSION}</string>
+    <key>CFBundleSignature</key>
+    <string>????</string>
+    <key>CFBundlePackageType</key>
+    <string>FMWK</string>
+</dict>
+</plist>
diff --git a/C++/opencv-4.7.0/platforms/osx/__init__.py b/C++/opencv-4.7.0/platforms/osx/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/C++/opencv-4.7.0/platforms/osx/build_docs.py b/C++/opencv-4.7.0/platforms/osx/build_docs.py
new file mode 100644
index 00000000..9021eba0
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/osx/build_docs.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+"""
+This script builds OpenCV docs for macOS.
+"""
+
+from __future__ import print_function
+import os, sys, multiprocessing, argparse, traceback
+from subprocess import check_call, check_output, CalledProcessError, Popen
+
+# import common code
+sys.path.insert(0, os.path.abspath(os.path.abspath(os.path.dirname(__file__))+'/../ios'))
+from build_docs import DocBuilder
+
+class OSXDocBuilder(DocBuilder):
+
+    def getToolchain(self):
+        return None
+
+if __name__ == "__main__":
+    script_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
+    parser = argparse.ArgumentParser(description='The script builds OpenCV docs for macOS.')
+    parser.add_argument('framework_dir', metavar='FRAMEWORK_DIR', help='folder where framework build files are located')
+    parser.add_argument('--output_dir', default=None, help='folder where docs will be built (default is "../doc_build" relative to framework_dir)')
+    parser.add_argument('--framework_header', default=None, help='umbrella header for OpenCV framework (default is "../../../lib/Release/{framework_name}.framework/Headers/{framework_name}.h")')
+    parser.add_argument('--framework_name', default='opencv2', help='Name of OpenCV framework (default: opencv2, will change to OpenCV in future version)')
+
+    args = parser.parse_args()
+    arch = "x86_64"
+    target = "macosx"
+
+    b = OSXDocBuilder(script_dir, args.framework_dir, args.output_dir if args.output_dir else os.path.join(args.framework_dir, "../doc_build"), args.framework_header if args.framework_header else os.path.join(args.framework_dir, "../../../lib/Release/" + args.framework_name + ".framework/Headers/" + args.framework_name + ".h"), args.framework_name, arch, target)
+    b.build()
diff --git a/C++/opencv-4.7.0/platforms/osx/build_framework.py b/C++/opencv-4.7.0/platforms/osx/build_framework.py
new file mode 100644
index 00000000..2dd5015e
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/osx/build_framework.py
@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+"""
+The script builds OpenCV.framework for OSX.
+"""
+
+from __future__ import print_function
+import os, os.path, sys, argparse, traceback, multiprocessing
+
+# import common code
+sys.path.insert(0, os.path.abspath(os.path.abspath(os.path.dirname(__file__))+'/../ios'))
+from build_framework import Builder
+sys.path.insert(0, os.path.abspath(os.path.abspath(os.path.dirname(__file__))+'/../apple'))
+from cv_build_utils import print_error, get_cmake_version
+
+MACOSX_DEPLOYMENT_TARGET='10.12'  # default, can be changed via command line options or environment variable
+
+class OSXBuilder(Builder):
+
+    def checkCMakeVersion(self):
+        assert get_cmake_version() >= (3, 17), "CMake 3.17 or later is required. Current version is {}".format(get_cmake_version())
+
+    def getObjcTarget(self, target):
+        # Obj-C generation target
+        if target == "Catalyst":
+            return 'ios'
+        else:
+            return 'osx'
+
+    def getToolchain(self, arch, target):
+        return None
+
+    def getBuildCommand(self, arch, target):
+        buildcmd = [
+            "xcodebuild",
+            "MACOSX_DEPLOYMENT_TARGET=" + os.environ['MACOSX_DEPLOYMENT_TARGET'],
+            "ARCHS=%s" % arch,
+            "-sdk", "macosx" if target == "Catalyst" else target.lower(),
+            "-configuration", "Debug" if self.debug else "Release",
+            "-parallelizeTargets",
+            "-jobs", str(multiprocessing.cpu_count())
+        ]
+
+        if target == "Catalyst":
+            buildcmd.append("-destination 'platform=macOS,arch=%s,variant=Mac Catalyst'" % arch)
+            buildcmd.append("-UseModernBuildSystem=YES")
+            buildcmd.append("SKIP_INSTALL=NO")
+            buildcmd.append("BUILD_LIBRARY_FOR_DISTRIBUTION=YES")
+            buildcmd.append("TARGETED_DEVICE_FAMILY=\"1,2\"")
+            buildcmd.append("SDKROOT=iphoneos")
+            buildcmd.append("SUPPORTS_MAC_CATALYST=YES")
+
+        return buildcmd
+
+    def getInfoPlist(self, builddirs):
+        return os.path.join(builddirs[0], "osx", "Info.plist")
+
+
+if __name__ == "__main__":
+    folder = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), "../.."))
+    parser = argparse.ArgumentParser(description='The script builds OpenCV.framework for OSX.')
+    # TODO: When we can make breaking changes, we should make the out argument explicit and required like in build_xcframework.py.
+    parser.add_argument('out', metavar='OUTDIR', help='folder to put built framework')
+    parser.add_argument('--opencv', metavar='DIR', default=folder, help='folder with opencv repository (default is "../.." relative to script location)')
+    parser.add_argument('--contrib', metavar='DIR', default=None, help='folder with opencv_contrib repository (default is "None" - build only main framework)')
+    parser.add_argument('--without', metavar='MODULE', default=[], action='append', help='OpenCV modules to exclude from the framework. To exclude multiple, specify this flag again, e.g. "--without video --without objc"')
+    parser.add_argument('--disable', metavar='FEATURE', default=[], action='append', help='OpenCV features to disable (add WITH_*=OFF). To disable multiple, specify this flag again, e.g. "--disable tbb --disable openmp"')
+    parser.add_argument('--dynamic', default=False, action='store_true', help='build dynamic framework (default is "False" - builds static framework)')
+    parser.add_argument('--enable_nonfree', default=False, dest='enablenonfree', action='store_true', help='enable non-free modules (disabled by default)')
+    parser.add_argument('--macosx_deployment_target', default=os.environ.get('MACOSX_DEPLOYMENT_TARGET', MACOSX_DEPLOYMENT_TARGET), help='specify MACOSX_DEPLOYMENT_TARGET')
+    parser.add_argument('--build_only_specified_archs', default=False, action='store_true', help='if enabled, only directly specified archs are built and defaults are ignored')
+    parser.add_argument('--archs', default=None, help='(Deprecated! Prefer --macos_archs instead.) Select target ARCHS (set to "x86_64,arm64" to build Universal Binary for Big Sur and later). Default is "x86_64".')
+    parser.add_argument('--macos_archs', default=None, help='Select target ARCHS (set to "x86_64,arm64" to build Universal Binary for Big Sur and later). Default is "x86_64"')
+    parser.add_argument('--catalyst_archs', default=None, help='Select target ARCHS (set to "x86_64,arm64" to build Universal Binary for Big Sur and later). Default is None')
+    parser.add_argument('--debug', action='store_true', help='Build "Debug" binaries (CMAKE_BUILD_TYPE=Debug)')
+    parser.add_argument('--debug_info', action='store_true', help='Build with debug information (useful for Release mode: BUILD_WITH_DEBUG_INFO=ON)')
+    parser.add_argument('--framework_name', default='opencv2', dest='framework_name', help='Name of OpenCV framework (default: opencv2, will change to OpenCV in future version)')
+    parser.add_argument('--legacy_build', default=False, dest='legacy_build', action='store_true', help='Build legacy framework (default: False, equivalent to "--framework_name=opencv2 --without=objc")')
+    parser.add_argument('--run_tests', default=False, dest='run_tests', action='store_true', help='Run tests')
+    parser.add_argument('--build_docs', default=False, dest='build_docs', action='store_true', help='Build docs')
+    parser.add_argument('--disable-swift', default=False, dest='swiftdisabled', action='store_true', help='Disable building of Swift extensions')
+
+    args, unknown_args = parser.parse_known_args()
+    if unknown_args:
+        print("The following args are not recognized and will not be used: %s" % unknown_args)
+
+    os.environ['MACOSX_DEPLOYMENT_TARGET'] = args.macosx_deployment_target
+    print('Using MACOSX_DEPLOYMENT_TARGET=' + os.environ['MACOSX_DEPLOYMENT_TARGET'])
+
+    macos_archs = None
+    if args.archs:
+        # The archs flag is replaced by macos_archs. If the user specifies archs,
+        # treat it as if the user specified the macos_archs flag instead.
+        args.macos_archs = args.archs
+        print("--archs is deprecated! Prefer --macos_archs instead.")
+    if args.macos_archs:
+        macos_archs = args.macos_archs.split(',')
+    elif not args.build_only_specified_archs:
+        # Supply defaults
+        macos_archs = ["x86_64"]
+    print('Using MacOS ARCHS=' + str(macos_archs))
+
+    catalyst_archs = None
+    if args.catalyst_archs:
+        catalyst_archs = args.catalyst_archs.split(',')
+    # TODO: To avoid breaking existing CI, catalyst_archs has no defaults. When we can make a breaking change, this should specify a default arch.
+    print('Using Catalyst ARCHS=' + str(catalyst_archs))
+
+    # Prevent the build from happening if the same architecture is specified for multiple platforms.
+    # When `lipo` is run to stitch the frameworks together into a fat framework, it'll fail, so it's
+    # better to stop here while we're ahead.
+    if macos_archs and catalyst_archs:
+        duplicate_archs = set(macos_archs).intersection(catalyst_archs)
+        if duplicate_archs:
+            print_error("Cannot have the same architecture for multiple platforms in a fat framework! Consider using build_xcframework.py in the apple platform folder instead. Duplicate archs are %s" % duplicate_archs)
+            exit(1)
+
+    if args.legacy_build:
+        args.framework_name = "opencv2"
+        if not "objc" in args.without:
+            args.without.append("objc")
+
+    targets = []
+    if not macos_archs and not catalyst_archs:
+        print_error("--macos_archs and --catalyst_archs are undefined; nothing will be built.")
+        sys.exit(1)
+    if macos_archs:
+        targets.append((macos_archs, "MacOSX"))
+    if catalyst_archs:
+        targets.append((catalyst_archs, "Catalyst")),
+
+    b = OSXBuilder(args.opencv, args.contrib, args.dynamic, True, args.without, args.disable, args.enablenonfree, targets, args.debug, args.debug_info, args.framework_name, args.run_tests, args.build_docs, args.swiftdisabled)
+    b.build(args.out)
diff --git a/C++/opencv-4.7.0/platforms/osx/run_tests.py b/C++/opencv-4.7.0/platforms/osx/run_tests.py
new file mode 100644
index 00000000..afdcf842
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/osx/run_tests.py
@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+"""
+This script runs OpenCV.framework tests for OSX.
+"""
+
+from __future__ import print_function
+import os, os.path, sys, argparse, traceback, multiprocessing
+
+# import common code
+sys.path.insert(0, os.path.abspath(os.path.abspath(os.path.dirname(__file__))+'/../ios'))
+from run_tests import TestRunner
+
+MACOSX_DEPLOYMENT_TARGET='10.12'  # default, can be changed via command line options or environment variable
+
+class OSXTestRunner(TestRunner):
+
+    def getToolchain(self):
+        return None
+
+    def getCMakeArgs(self):
+        args = TestRunner.getCMakeArgs(self)
+        args = args + [
+            '-DMACOSX_DEPLOYMENT_TARGET=%s' % os.environ['MACOSX_DEPLOYMENT_TARGET']
+        ]
+        return args
+
+
+if __name__ == "__main__":
+    script_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
+    parser = argparse.ArgumentParser(description='The script builds OpenCV.framework for OSX.')
+    parser.add_argument('tests_dir', metavar='TEST_DIR', help='folder where test files are located')
+    parser.add_argument('--build_dir', default=None, help='folder where test will be built (default is "../test_build" relative to tests_dir)')
+    parser.add_argument('--framework_dir', default=None, help='folder where OpenCV framework is located')
+    parser.add_argument('--framework_name', default='opencv2', help='Name of OpenCV framework (default: opencv2, will change to OpenCV in future version)')
+    parser.add_argument('--macosx_deployment_target', default=os.environ.get('MACOSX_DEPLOYMENT_TARGET', MACOSX_DEPLOYMENT_TARGET), help='specify MACOSX_DEPLOYMENT_TARGET')
+    parser.add_argument('--platform', default='macOS,arch=x86_64', help='xcodebuild platform parameter (default is macOS)')
+
+    args = parser.parse_args()
+    os.environ['MACOSX_DEPLOYMENT_TARGET'] = args.macosx_deployment_target
+    arch = "x86_64"
+    target = "macOS"
+
+    r = OSXTestRunner(script_dir, args.tests_dir, args.build_dir if args.build_dir else os.path.join(args.tests_dir, "../test_build"), args.framework_dir, args.framework_name, arch, target, args.platform)
+    r.run()
diff --git a/C++/opencv-4.7.0/platforms/readme.txt b/C++/opencv-4.7.0/platforms/readme.txt
new file mode 100644
index 00000000..310148a9
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/readme.txt
@@ -0,0 +1,3 @@
+This folder contains toolchains and additional files that are needed for cross compilation.
+For more information see introduction tutorials for target platform in documentation:
+https://docs.opencv.org/4.x/df/d65/tutorial_table_of_content_introduction.html
diff --git a/C++/opencv-4.7.0/platforms/scripts/pylintrc b/C++/opencv-4.7.0/platforms/scripts/pylintrc
new file mode 100644
index 00000000..35c4a34a
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/scripts/pylintrc
@@ -0,0 +1,16 @@
+[MESSAGES CONTROL]
+
+# Disable all to choose the Tests one by one
+disable=all
+
+# Tests
+enable=bad-indentation,       # Used when an unexpected number of indentation’s tabulations or spaces has been found.
+       mixed-indentation,     # Used when there are some mixed tabs and spaces in a module.
+       unnecessary-semicolon, # Used when a statement is ended by a semi-colon (”;”), which isn’t necessary.
+       unused-variable        # Used when a variable is defined but not used. (Use _var to ignore var).
+
+
+[REPORTS]
+
+# Activate the evaluation score.
+score=no
diff --git a/C++/opencv-4.7.0/platforms/scripts/valgrind.supp b/C++/opencv-4.7.0/platforms/scripts/valgrind.supp
new file mode 100644
index 00000000..c71cdf96
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/scripts/valgrind.supp
@@ -0,0 +1,289 @@
+{
+   OpenCV-IPP static init
+   Memcheck:Cond
+   fun:ippicvGetCpuFeatures
+   fun:ippicvStaticInit
+}
+
+{
+   OpenCV-getInitializationMutex
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv22getInitializationMutexEv
+}
+
+{
+   OpenCV-SingletonBuffer
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv20allocSingletonBufferEm
+}
+
+{
+   OpenCV-SingletonNewBuffer
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv23allocSingletonNewBufferEm
+}
+
+{
+   OpenCV-getStdAllocator
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv3Mat15getStdAllocatorEv
+}
+
+{
+   OpenCV-getOpenCLAllocator
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv3ocl18getOpenCLAllocatorEv
+}
+
+{
+   OpenCV-getCoreTlsData
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv14getCoreTlsDataEv
+}
+
+{
+   OpenCV-TLS-getTlsStorage
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv*L13getTlsStorageEv
+}
+
+{
+   OpenCV-TLS-getData()
+   Memcheck:Leak
+   ...
+   fun:*setData*
+   fun:_ZNK2cv16TLSDataContainer7getDataEv
+}
+
+{
+   OpenCV-parallel_for-reconfigure
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv10ThreadPool12reconfigure_Ej
+}
+
+{
+   OpenCV-parallel_for-instance
+   Memcheck:Leak
+   fun:_Znwm
+   fun:*instance*
+   ...
+   fun:_ZN2cv13parallel_for_ERKNS_5RangeERKNS_16ParallelLoopBodyEd
+}
+
+{
+   OpenCV-parallel_for-setNumThreads()
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv13setNumThreadsEi
+}
+
+{
+   OpenCV-parallel_for-getNumThreads()
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv13getNumThreadsEv
+}
+
+{
+   OpenCV-getIPPSingelton
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv3ippL15getIPPSingeltonEv
+}
+
+{
+   OpenCV-getGlobalMatOpInitializer
+   Memcheck:Leak
+   fun:_Znwm
+   fun:_ZN2cvL25getGlobalMatOpInitializerEv
+}
+
+{
+   OpenCV-CoreTLSData
+   Memcheck:Leak
+   ...
+   fun:_ZNK2cv7TLSDataINS_11CoreTLSDataEE3getEv
+}
+
+{
+   OpenCV-getThreadID()
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv5utils11getThreadIDEv
+}
+
+{
+   OpenCV-ThreadID
+   Memcheck:Leak
+   fun:_Znwm
+   fun:_ZNK2cv7TLSDataINS_12_GLOBAL__N_18ThreadIDEE18createDataInstanceEv
+}
+
+{
+   OpenCV-ThreadID-TLS
+   Memcheck:Leak
+   fun:_Znwm
+   fun:getThreadIDTLS
+}
+
+{
+   OpenCV-CoreTLS
+   Memcheck:Leak
+   fun:_Znwm
+   fun:_ZNK2cv7TLSDataINS_11CoreTLSDataEE18createDataInstanceEv
+}
+
+{
+   OpenCV-UMatDataAutoLockerTLS
+   Memcheck:Leak
+   ...
+   fun:_ZN2cvL21getUMatDataAutoLockerEv
+}
+
+{
+   OpenCV-haveOpenCL
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv3ocl10haveOpenCLEv
+}
+
+{
+   OpenCV-DNN-getLayerFactoryMutex
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv3dnn*20getLayerFactoryMutexEv
+}
+
+{
+   OpenCV-ocl::Context
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv3ocl7Context10getDefaultEb
+}
+
+{
+   OpenCV-ocl::Device
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv3ocl6Device10getDefaultEv
+}
+
+{
+   OpenCV-ocl::Queue
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv3ocl5Queue6createERKNS0_7ContextERKNS0_6DeviceE
+}
+
+{
+   OpenCV-ocl::Program
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv3ocl6Kernel6createEPKcRKNS0_7ProgramE
+}
+
+{
+   OpenCV-ocl::ProgramEntry
+   Memcheck:Leak
+   ...
+   fun:_ZNK2cv3ocl8internal12ProgramEntrycvRNS0_13ProgramSourceEEv
+}
+
+{
+   OpenCV-ocl::Context::getProg
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv3ocl7Context7getProgERKNS0_13ProgramSourceERKNS_6StringERS5_
+}
+
+{
+   OpenCV-getTraceManager()
+   Memcheck:Leak
+   ...
+   fun:getTraceManagerCallOnce
+}
+
+{
+   OpenCV-ITT
+   Memcheck:Leak
+   ...
+   fun:__itt_*create*
+}
+
+{
+   OpenCV-SingletonLogger
+   Memcheck:Leak
+   ...
+   fun:_ZN2cv5utils7logging8internalL26getGlobalLoggingInitStructEv
+}
+
+{
+   OpenCV-gtk_init
+   Memcheck:Leak
+   ...
+   fun:gtk_init
+   fun:cvInitSystem
+}
+
+{
+   OpenCV-FFmpeg-swsscale
+   Memcheck:Addr16
+   ...
+   fun:sws_scale
+   fun:_ZN20CvVideoWriter_FFMPEG10writeFrameEPKhiiiii
+   fun:cvWriteFrame_FFMPEG
+}
+
+{
+   OpenCV-GStreamer-gst_init
+   Memcheck:Leak
+   ...
+   fun:gst_init
+}
+
+{
+   OpenCV-GStreamer-gst_deinit
+   Memcheck:Leak
+   ...
+   fun:gst_deinit
+}
+
+{
+   OpenCV-GStreamer-gst_init_check
+   Memcheck:Leak
+   ...
+   fun:gst_init_check
+}
+
+{
+   OpenCV-GStreamer-gst_parse_launch_full-reachable
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   ...
+   fun:gst_parse_launch_full
+}
+
+{
+   OpenCV-OpenEXR-ThreadPool
+   Memcheck:Leak
+   fun:_Znwm
+   fun:_ZN16IlmThread_opencv10ThreadPoolC1Ej
+   fun:_ZN16IlmThread_opencv10ThreadPool16globalThreadPoolEv
+}
+
+{
+   OpenCV-test-gapi-thread-tls
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:calloc
+   fun:allocate_dtv
+   fun:_dl_allocate_tls
+}
diff --git a/C++/opencv-4.7.0/platforms/scripts/valgrind_3rdparty.supp b/C++/opencv-4.7.0/platforms/scripts/valgrind_3rdparty.supp
new file mode 100644
index 00000000..9e9e8e58
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/scripts/valgrind_3rdparty.supp
@@ -0,0 +1,230 @@
+{
+   IPP static init
+   Memcheck:Cond
+   fun:ippicvGetCpuFeatures
+   fun:ippicvStaticInit
+}
+
+{
+   TBB - allocate_via_handler_v3 issue
+   Memcheck:Leak
+   fun:malloc
+   fun:_ZN3tbb8internal23allocate_via_handler_v3Em
+}
+
+{
+   GTest
+   Memcheck:Cond
+   fun:_ZN7testing8internal11CmpHelperLEIddEENS_15AssertionResultEPKcS4_RKT_RKT0_
+}
+
+{
+   GTest-RegisterTests
+   Memcheck:Leak
+   ...
+   fun:RegisterTests
+   ...
+   fun:_ZN7testing14InitGoogleTestEPiPPc
+}
+
+{
+   OpenCL
+   Memcheck:Cond
+   ...
+   obj:**/libOpenCL.so*
+}
+
+{
+   OpenCL-Intel
+   Memcheck:Cond
+   ...
+   obj:**/libigdrcl.so
+}
+
+{
+   OpenCL-Intel
+   Memcheck:Leak
+   ...
+   obj:*/libigdrcl.so*
+}
+
+{
+   OpenCL
+   Memcheck:Param
+   ioctl(generic)
+   ...
+   fun:clGetPlatformIDs
+}
+
+{
+   OpenCL-Init
+   Memcheck:Leak
+   ...
+   fun:clGetPlatformIDs
+}
+
+{
+   GTK-css
+   Memcheck:Leak
+   ...
+   fun:gtk_css_provider*
+}
+
+{
+   gcrypt
+   Memcheck:Leak
+   ...
+   obj:*/libgcrypt*
+}
+
+{
+   p11-kit
+   Memcheck:Leak
+   fun:*alloc
+   obj:*/libp11-kit*
+}
+
+{
+   gobject
+   Memcheck:Leak
+   fun:*alloc
+   ...
+   obj:*/libgobject*
+}
+
+{
+   tasn
+   Memcheck:Leak
+   fun:*alloc
+   obj:*/libtasn*.so*
+}
+
+{
+   dl_init
+   Memcheck:Leak
+   ...
+   fun:_dl_init
+}
+
+{
+   dl_open
+   Memcheck:Leak
+   ...
+   fun:_dl_open
+}
+
+{
+   GDAL
+   Memcheck:Leak
+   fun:*alloc
+   ...
+   obj:/usr/lib/libgdal.so.1.17.1
+}
+
+{
+   FFMPEG-sws_scale
+   Memcheck:Addr16
+   ...
+   fun:sws_scale
+   ...
+   fun:cvWriteFrame_FFMPEG
+}
+
+{
+   GStreamer-orc_program_compile_full
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   ...
+   fun:orc_program_compile_full
+   ...
+   fun:clone
+}
+
+{
+   GStreamer-orc_program_new_from_static_bytecode
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   ...
+   fun:orc_program_new_from_static_bytecode
+   ...
+   fun:clone
+}
+
+{
+   GStreamer-matroska-other
+   Memcheck:Leak
+   ...
+   fun:gst*
+   obj:*gstmatroska*
+   ...
+   obj:*glib*
+   fun:start_thread
+   fun:clone
+}
+
+{
+   GStreamer-matroska-gst_riff_create_video_caps
+   Memcheck:Leak
+   ...
+   fun:gst_riff_create_video_caps
+   obj:*gstmatroska*
+   ...
+   fun:clone
+}
+
+
+{
+   GStreamer-tls
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:calloc
+   fun:allocate_dtv
+   fun:_dl_allocate_tls
+}
+
+{
+   GStreamer-registry
+   Memcheck:Leak
+   ...
+   fun:gst_update_registry
+}
+
+{
+   GStreamer-plugin_load
+   Memcheck:Leak
+   ...
+   fun:gst_plugin_load_by_name
+}
+
+{
+   GStreamer-separate-threads
+   Memcheck:Leak
+   ...
+   obj:*/libglib*
+   fun:start_thread
+   fun:clone
+}
+
+{
+   clone-unknown-leak
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:_Znwm
+   obj:*
+   obj:*
+   fun:start_thread
+   fun:clone
+}
+
+{
+   avcodec57-ffv1-16bit-ubuntu18
+   Memcheck:Cond
+   ...
+   obj:/usr/lib/x86_64-linux-gnu/libavcodec.so.57.107.100
+   fun:avcodec_default_execute
+   obj:/usr/lib/x86_64-linux-gnu/libavcodec.so.57.107.100
+   fun:avcodec_encode_video2
+   obj:/usr/lib/x86_64-linux-gnu/libavcodec.so.57.107.100
+   fun:avcodec_send_frame
+   ...
+}
diff --git a/C++/opencv-4.7.0/platforms/semihosting/aarch64-semihosting.toolchain.cmake b/C++/opencv-4.7.0/platforms/semihosting/aarch64-semihosting.toolchain.cmake
new file mode 100644
index 00000000..95bbda3b
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/semihosting/aarch64-semihosting.toolchain.cmake
@@ -0,0 +1,40 @@
+# This file is part of OpenCV project.
+# It is subject to the license terms in the LICENSE file found in the top-level directory
+# of this distribution and at http://opencv.org/license.html
+
+set(CMAKE_SYSTEM_NAME               Generic)
+set(CMAKE_SYSTEM_PROCESSOR          AArch64)
+
+set(CMAKE_TRY_COMPILE_TARGET_TYPE   STATIC_LIBRARY)
+
+set(PORT_FILE ${CMAKE_SOURCE_DIR}/platforms/semihosting/include/aarch64_semihosting_port.hpp)
+
+set(COMMON_FLAGS "--specs=rdimon.specs -DOPENCV_INCLUDE_PORT_FILE=\\\"${PORT_FILE}\\\"")
+
+set(CMAKE_AR                        ${SEMIHOSTING_TOOLCHAIN_PATH}aarch64-none-elf-ar${CMAKE_EXECUTABLE_SUFFIX})
+set(CMAKE_ASM_COMPILER              ${SEMIHOSTING_TOOLCHAIN_PATH}aarch64-none-elf-gcc${CMAKE_EXECUTABLE_SUFFIX})
+set(CMAKE_C_COMPILER                ${SEMIHOSTING_TOOLCHAIN_PATH}aarch64-none-elf-gcc${CMAKE_EXECUTABLE_SUFFIX})
+set(CMAKE_CXX_COMPILER              ${SEMIHOSTING_TOOLCHAIN_PATH}aarch64-none-elf-g++${CMAKE_EXECUTABLE_SUFFIX})
+set(CMAKE_LINKER                    ${SEMIHOSTING_TOOLCHAIN_PATH}aarch64-none-elf-ld${CMAKE_EXECUTABLE_SUFFIX})
+set(CMAKE_OBJCOPY                   ${SEMIHOSTING_TOOLCHAIN_PATH}aarch64-none-elf-objcopy${CMAKE_EXECUTABLE_SUFFIX} CACHE INTERNAL "")
+set(CMAKE_RANLIB                    ${SEMIHOSTING_TOOLCHAIN_PATH}aarch64-none-elf-ranlib${CMAKE_EXECUTABLE_SUFFIX} CACHE INTERNAL "")
+set(CMAKE_SIZE                      ${SEMIHOSTING_TOOLCHAIN_PATH}aarch64-none-elf-size${CMAKE_EXECUTABLE_SUFFIX} CACHE INTERNAL "")
+set(CMAKE_STRIP                     ${SEMIHOSTING_TOOLCHAIN_PATH}aarch64-none-elf-strip${CMAKE_EXECUTABLE_SUFFIX} CACHE INTERNAL "")
+set(CMAKE_C_FLAGS                   ${COMMON_FLAGS} CACHE INTERNAL "")
+set(CMAKE_CXX_FLAGS                 ${COMMON_FLAGS} CACHE INTERNAL "")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+set(OPENCV_SEMIHOSTING ON)
+set(OPENCV_DISABLE_THREAD_SUPPORT ON)
+set(OPENCV_DISABLE_FILESYSTEM_SUPPORT ON)
+set(BUILD_SHARED_LIBS OFF)
+set(OPENCV_FORCE_3RDPARTY_BUILD OFF)
+
+
+# Enable newlib.
+add_definitions(-D_GNU_SOURCE)
+
+add_definitions(-D_POSIX_PATH_MAX=0)
diff --git a/C++/opencv-4.7.0/platforms/semihosting/include/aarch64_semihosting_port.hpp b/C++/opencv-4.7.0/platforms/semihosting/include/aarch64_semihosting_port.hpp
new file mode 100644
index 00000000..d3151c24
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/semihosting/include/aarch64_semihosting_port.hpp
@@ -0,0 +1,42 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef AARCH64_BAREMETAL_PORT_HPP
+#define AARCH64_BAREMETAL_PORT_HPP
+
+#include <malloc.h> // Needed for `memalign`.
+#include <sys/errno.h> // Needed for `ENOMEM`.
+
+// -std=c++11 is missing the following definitions when targeting
+// semihosting on aarch64.
+#if __cplusplus == 201103L
+#include <cmath>
+#define M_PI 3.14159265358979323846
+#define M_SQRT2 1.41421356237309504880
+
+namespace std {
+inline double cbrt(double x) {
+    return ::cbrt(x);
+}
+inline double copysign(double mag, double sgn) {
+    return ::copysign(mag, sgn);
+}
+} //namespace std
+#endif // __cplusplus == 201103L
+
+extern "C" {
+// Redirect the implementation of `posix_memalign` to `memalign`
+// as the former is
+// missing at link time. https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_memalign.html
+__attribute__((weak)) int posix_memalign(void **memptr, size_t alignment, size_t size) {
+    void * ptr =  memalign(alignment, size);
+    if (ptr != NULL) {
+        *memptr = ptr;
+        return 0;
+    }
+    return ENOMEM;
+}
+} // extern "C"
+
+#endif
diff --git a/C++/opencv-4.7.0/platforms/wince/arm-wince-headless-overrides.cmake b/C++/opencv-4.7.0/platforms/wince/arm-wince-headless-overrides.cmake
new file mode 100644
index 00000000..e31530c5
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/wince/arm-wince-headless-overrides.cmake
@@ -0,0 +1,12 @@
+if(WINCE)
+  # CommCtrl.lib does not exist in headless WINCE Adding this will make CMake
+  # Try_Compile succeed and therefore also C/C++ ABI Detetection work
+  # https://gitlab.kitware.com/cmake/cmake/blob/master/Modules/Platform/Windows-
+  # MSVC.cmake
+  set(CMAKE_C_STANDARD_LIBRARIES_INIT "coredll.lib oldnames.lib")
+  set(CMAKE_CXX_STANDARD_LIBRARIES_INIT ${CMAKE_C_STANDARD_LIBRARIES_INIT})
+  foreach(ID EXE SHARED MODULE)
+    string(APPEND CMAKE_${ID}_LINKER_FLAGS_INIT
+           " /NODEFAULTLIB:libc.lib")
+  endforeach()
+endif()
diff --git a/C++/opencv-4.7.0/platforms/wince/arm-wince.toolchain.cmake b/C++/opencv-4.7.0/platforms/wince/arm-wince.toolchain.cmake
new file mode 100644
index 00000000..fc96d12e
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/wince/arm-wince.toolchain.cmake
@@ -0,0 +1,35 @@
+set(CMAKE_SYSTEM_NAME WindowsCE)
+
+if(NOT CMAKE_SYSTEM_VERSION)
+  set(CMAKE_SYSTEM_VERSION 8.0)
+endif()
+
+if(NOT CMAKE_SYSTEM_PROCESSOR)
+  set(CMAKE_SYSTEM_PROCESSOR armv7-a)
+endif()
+
+if(NOT CMAKE_GENERATOR_TOOLSET)
+  set(CMAKE_GENERATOR_TOOLSET CE800)
+endif()
+
+# Needed to make try_compile to succeed
+if(BUILD_HEADLESS)
+  set(CMAKE_USER_MAKE_RULES_OVERRIDE
+      ${CMAKE_CURRENT_LIST_DIR}/arm-wince-headless-overrides.cmake)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_PROGRAM)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_LIBRARY)
+  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_INCLUDE)
+  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_PACKAGE)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+endif()
diff --git a/C++/opencv-4.7.0/platforms/wince/readme.md b/C++/opencv-4.7.0/platforms/wince/readme.md
new file mode 100644
index 00000000..65208736
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/wince/readme.md
@@ -0,0 +1,70 @@
+# Building OpenCV from Source for Windows Embedded Compact (WINCE/WEC)
+
+## Requirements
+CMake 3.1.0 or higher
+Windows Embedded Compact SDK
+
+## Configuring
+To configure CMake for Windows Embedded, specify Visual Studio 2013 as generator and the name of your installed SDK:
+
+`cmake -G "Visual Studio 12 2013" -A "MySDK WEC2013" -DCMAKE_TOOLCHAIN_FILE:FILEPATH=../platforms/wince/arm-wince.toolchain.cmake`
+
+If you are building for a headless WINCE, specify `-DBUILD_HEADLESS=ON` when configuring. This will remove the `commctrl.lib` dependency.
+
+If you are building for anything else than WINCE800, you need to specify that in the configuration step. Example:
+
+```
+-DCMAKE_SYSTEM_VERSION=7.0 -DCMAKE_GENERATOR_TOOLSET=CE700 -DCMAKE_SYSTEM_PROCESSOR=arm-v4
+```
+
+For headless WEC2013, this configuration may not be limited to but is known to work:
+
+```
+-DBUILD_EXAMPLES=OFF `
+-DBUILD_opencv_apps=OFF `
+-DBUILD_opencv_calib3d=OFF `
+-DBUILD_opencv_highgui=OFF `
+-DBUILD_opencv_features2d=OFF `
+-DBUILD_opencv_flann=OFF `
+-DBUILD_opencv_ml=OFF `
+-DBUILD_opencv_objdetect=OFF `
+-DBUILD_opencv_photo=OFF `
+-DBUILD_opencv_shape=OFF `
+-DBUILD_opencv_stitching=OFF `
+-DBUILD_opencv_superres=OFF `
+-DBUILD_opencv_ts=OFF `
+-DBUILD_opencv_video=OFF `
+-DBUILD_opencv_videoio=OFF `
+-DBUILD_opencv_videostab=OFF `
+-DBUILD_opencv_dnn=OFF `
+-DBUILD_opencv_java=OFF `
+-DBUILD_opencv_python2=OFF `
+-DBUILD_opencv_python3=OFF `
+-DBUILD_opencv_java_bindings_generator=OFF `
+-DBUILD_opencv_python_bindings_generator=OFF `
+-DBUILD_TIFF=OFF `
+-DCV_TRACE=OFF `
+-DWITH_OPENCL=OFF `
+-DHAVE_OPENCL=OFF `
+-DWITH_QT=OFF `
+-DWITH_GTK=OFF `
+-DWITH_QUIRC=OFF `
+-DWITH_JASPER=OFF `
+-DWITH_WEBP=OFF `
+-DWITH_PROTOBUF=OFF `
+-DBUILD_SHARED_LIBS=OFF `
+-DWITH_OPENEXR=OFF `
+-DWITH_TIFF=OFF `
+```
+
+## Configuring to build as shared
+Building OpenCV as shared libraries is as easy as appending
+```
+-DBUILD_SHARED_LIBS=ON `
+-DBUILD_ZLIB=ON
+```
+to the build configuration.
+
+## Building
+You are required to build using Unicode:
+`cmake --build . -- /p:CharacterSet=Unicode`
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200313-dldt-disable-unused-targets.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200313-dldt-disable-unused-targets.patch
new file mode 100644
index 00000000..2dcfd4e9
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200313-dldt-disable-unused-targets.patch
@@ -0,0 +1,158 @@
+diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
+index d5feedb..1b7aa7e 100644
+--- a/inference-engine/CMakeLists.txt
++++ b/inference-engine/CMakeLists.txt
+@@ -59,11 +59,11 @@ if(ENABLE_TESTS)
+     add_subdirectory(tests)
+ endif()
+ 
+-add_subdirectory(tools)
++#add_subdirectory(tools)
+ 
+ # gflags and format_reader targets are kept inside of samples directory and
+ # they must be built even if samples build is disabled (required for tests and tools).
+-add_subdirectory(samples)
++#add_subdirectory(samples)
+ 
+ file(GLOB_RECURSE SAMPLES_SOURCES samples/*.cpp samples/*.hpp samples/*.h)
+ add_cpplint_target(sample_cpplint
+@@ -134,7 +134,7 @@ install(DIRECTORY ${ie_python_api_SOURCE_DIR}/sample/
+ add_custom_target(ie_dev_targets ALL DEPENDS inference_engine HeteroPlugin)
+ 
+ # Developer package
+-ie_developer_export_targets(format_reader)
++#ie_developer_export_targets(format_reader)
+ 
+ if (ENABLE_NGRAPH)
+     ie_developer_export_targets(${NGRAPH_LIBRARIES})
+diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
+index 54e264c..c0b7495 100644
+--- a/inference-engine/src/inference_engine/CMakeLists.txt
++++ b/inference-engine/src/inference_engine/CMakeLists.txt
+@@ -228,7 +228,7 @@ target_include_directories(${TARGET_NAME}_nn_builder PRIVATE "${CMAKE_CURRENT_SO
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
+             ${NN_BUILDER_LIBRARY_SRC})
+ 
+diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+index cd727fd..2f09b44 100644
+--- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
++++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+@@ -184,9 +184,9 @@ endif()
+ add_library(mkldnn_plugin_layers_no_opt OBJECT ${CROSS_COMPILED_SOURCES})
+ set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt)
+ 
+-add_library(mkldnn_plugin_layers_no_opt_s OBJECT ${CROSS_COMPILED_SOURCES})
+-set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt_s)
+-target_compile_definitions(mkldnn_plugin_layers_no_opt_s PRIVATE USE_STATIC_IE)
++#add_library(mkldnn_plugin_layers_no_opt_s OBJECT ${CROSS_COMPILED_SOURCES})
++#set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt_s)
++#target_compile_definitions(mkldnn_plugin_layers_no_opt_s PRIVATE USE_STATIC_IE)
+ 
+ set(object_libraries mkldnn_plugin_layers_no_opt)
+ set(mkldnn_plugin_object_libraries mkldnn_plugin_layers_no_opt_s)
+@@ -220,7 +220,7 @@ if (ENABLE_SSE42)
+     endfunction()
+ 
+     mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42)
+-    mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42_s)
++    #mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42_s)
+ 
+     list(APPEND object_libraries mkldnn_plugin_layers_sse42)
+     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_sse42_s)
+@@ -259,7 +259,7 @@ if (ENABLE_AVX2)
+     endfunction()
+ 
+     mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2)
+-    mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2_s)
++    #mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2_s)
+ 
+     list(APPEND object_libraries mkldnn_plugin_layers_avx2)
+     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_avx2_s)
+@@ -297,7 +297,7 @@ if (ENABLE_AVX512F)
+     endfunction()
+ 
+     mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512)
+-    mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512_s)
++    #mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512_s)
+ 
+     list(APPEND object_libraries mkldnn_plugin_layers_avx512)
+     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_avx512_s)
+@@ -317,7 +317,7 @@ target_link_libraries(${TARGET_NAME} PRIVATE inference_engine ${INTEL_ITT_LIBS}
+ 
+ #  add test object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
+ 
+ target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>)
+ 
+diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
+index 41f14a9..0e1b4f6 100644
+--- a/inference-engine/src/preprocessing/CMakeLists.txt
++++ b/inference-engine/src/preprocessing/CMakeLists.txt
+@@ -81,7 +81,7 @@ endif()
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
+ 
+ set_ie_threading_interface_for(${TARGET_NAME}_s)
+diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
+index 8995390..8413faf 100644
+--- a/inference-engine/src/vpu/common/CMakeLists.txt
++++ b/inference-engine/src/vpu/common/CMakeLists.txt
+@@ -49,7 +49,7 @@ add_common_target("vpu_common_lib" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_common_target("vpu_common_lib_test_static" TRUE)
++    #add_common_target("vpu_common_lib_test_static" TRUE)
+ else()
+     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
+ endif()
+diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+index e77296e..333f560 100644
+--- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
++++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+@@ -60,7 +60,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
++    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
+ else()
+     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
+ endif()
+diff --git a/inference-engine/thirdparty/CMakeLists.txt b/inference-engine/thirdparty/CMakeLists.txt
+index ec22761..8bb3325 100644
+--- a/inference-engine/thirdparty/CMakeLists.txt
++++ b/inference-engine/thirdparty/CMakeLists.txt
+@@ -36,7 +36,7 @@ function(build_with_lto)
+     endif()
+ 
+     add_subdirectory(pugixml)
+-    add_subdirectory(stb_lib)
++    #add_subdirectory(stb_lib)
+     add_subdirectory(ade)
+     add_subdirectory(fluid/modules/gapi)
+ 
+diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+index 8bcb280..5a17fa3 100644
+--- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
++++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
+ else()
+ 	add_library(pugixml STATIC ${SOURCES})
+ 	if (MSVC)
+-		add_library(pugixml_mt STATIC ${SOURCES})
++                #add_library(pugixml_mt STATIC ${SOURCES})
+ 		#if (WIN32)
+ 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200313-dldt-fix-binaries-location.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200313-dldt-fix-binaries-location.patch
new file mode 100644
index 00000000..82da0d8c
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200313-dldt-fix-binaries-location.patch
@@ -0,0 +1,13 @@
+diff --git a/cmake/developer_package.cmake b/cmake/developer_package.cmake
+index e59edb2..e42ac19 100644
+--- a/cmake/developer_package.cmake
++++ b/cmake/developer_package.cmake
+@@ -99,7 +99,7 @@ if(UNIX)
+     SET(LIB_DL ${CMAKE_DL_LIBS})
+ endif()
+ 
+-set(OUTPUT_ROOT ${OpenVINO_MAIN_SOURCE_DIR})
++set(OUTPUT_ROOT ${CMAKE_BINARY_DIR})
+ 
+ # Enable postfixes for Debug/Release builds
+ set(IE_DEBUG_POSTFIX_WIN "d")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200313-ngraph-disable-tests-examples.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200313-ngraph-disable-tests-examples.patch
new file mode 100644
index 00000000..bfdd78ff
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200313-ngraph-disable-tests-examples.patch
@@ -0,0 +1,25 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 631465f..723153b 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -567,7 +567,7 @@ if (NGRAPH_ONNX_IMPORT_ENABLE)
+     endif()
+ endif()
+ 
+-include(cmake/external_gtest.cmake)
++#include(cmake/external_gtest.cmake)
+ if(NGRAPH_JSON_ENABLE)
+     include(cmake/external_json.cmake)
+ endif()
+@@ -623,8 +623,8 @@ endif()
+ 
+ add_subdirectory(src)
+ 
+-add_subdirectory(test)
+-add_subdirectory(doc/examples)
++#add_subdirectory(test)
++#add_subdirectory(doc/examples)
+ 
+ if (NGRAPH_DOC_BUILD_ENABLE)
+     add_subdirectory(doc)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200318-dldt-pdb.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200318-dldt-pdb.patch
new file mode 100644
index 00000000..d94a84ab
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200318-dldt-pdb.patch
@@ -0,0 +1,14 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index e48cee5..5823e92 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -12,6 +12,9 @@ endif()
+ 
+ project(OpenVINO)
+ 
++set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
++set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++
+ set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ set(CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200319-dldt-fix-msvs2019-v16.5.0.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200319-dldt-fix-msvs2019-v16.5.0.patch
new file mode 100644
index 00000000..7f864fbd
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/20200319-dldt-fix-msvs2019-v16.5.0.patch
@@ -0,0 +1,13 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 7900b382..b5c53d09 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -24,6 +24,8 @@ include(features)
+ # include developer package
+ include(developer_package)
+ 
++disable_deprecated_warnings()
++
+ # These options are shared with 3rdparty plugins
+ # by means of developer package
+ include(check_features)
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/patch.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/patch.config.py
new file mode 100644
index 00000000..ded4f3f3
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/patch.config.py
@@ -0,0 +1,5 @@
+applyPatch('20200313-ngraph-disable-tests-examples.patch', 'ngraph')
+applyPatch('20200313-dldt-disable-unused-targets.patch')
+applyPatch('20200313-dldt-fix-binaries-location.patch')
+applyPatch('20200318-dldt-pdb.patch')
+applyPatch('20200319-dldt-fix-msvs2019-v16.5.0.patch')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/sysroot.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/sysroot.config.py
new file mode 100644
index 00000000..f99c3425
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.1/sysroot.config.py
@@ -0,0 +1,51 @@
+sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
+copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
+#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
+
+build_config = 'Release' if not self.config.build_debug else 'Debug'
+build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
+
+def copy_bin(name):
+    global build_bin_dir, sysroot_bin_dir
+    copytree(build_bin_dir / name, sysroot_bin_dir / name)
+
+dll_suffix = 'd' if self.config.build_debug else ''
+def copy_dll(name):
+    global copy_bin, dll_suffix
+    copy_bin(name + dll_suffix + '.dll')
+    copy_bin(name + dll_suffix + '.pdb')
+
+copy_bin('cldnn_global_custom_kernels')
+copy_bin('cache.json')
+copy_dll('clDNNPlugin')
+copy_dll('HeteroPlugin')
+copy_dll('inference_engine')
+copy_dll('inference_engine_nn_builder')
+copy_dll('MKLDNNPlugin')
+copy_dll('myriadPlugin')
+copy_dll('ngraph')
+copy_bin('plugins.xml')
+copytree(self.build_dir / 'bin' / 'intel64' / 'pcie-ma248x.elf', sysroot_bin_dir / 'pcie-ma248x.elf')
+copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2x8x.mvcmd', sysroot_bin_dir / 'usb-ma2x8x.mvcmd')
+copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2450.mvcmd', sysroot_bin_dir / 'usb-ma2450.mvcmd')
+
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
+
+sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
+sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
+
+copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
+if not self.config.build_debug:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
+    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
+    copytree(build_bin_dir / 'inference_engine_nn_builder.lib', sysroot_ie_lib_dir / 'inference_engine_nn_builder.lib')
+else:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
+    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
+    copytree(build_bin_dir / 'inference_engine_nn_builderd.lib', sysroot_ie_lib_dir / 'inference_engine_nn_builderd.lib')
+
+sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
+copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
+copytree(self.srcdir / 'ngraph/LICENSE', sysroot_license_dir / 'ngraph-LICENSE')
+copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200413-dldt-disable-unused-targets.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200413-dldt-disable-unused-targets.patch
new file mode 100644
index 00000000..c42c7605
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200413-dldt-disable-unused-targets.patch
@@ -0,0 +1,202 @@
+diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
+index e7ea6547..7333d19c 100644
+--- a/inference-engine/CMakeLists.txt
++++ b/inference-engine/CMakeLists.txt
+@@ -72,11 +72,11 @@ if(ENABLE_TESTS)
+     add_subdirectory(tests)
+ endif()
+ 
+-add_subdirectory(tools)
++#add_subdirectory(tools)
+ 
+ # gflags and format_reader targets are kept inside of samples directory and
+ # they must be built even if samples build is disabled (required for tests and tools).
+-add_subdirectory(samples)
++#add_subdirectory(samples)
+ 
+ file(GLOB_RECURSE SAMPLES_SOURCES samples/*.cpp samples/*.hpp samples/*.h)
+ add_cpplint_target(sample_cpplint
+@@ -154,10 +154,10 @@ endif()
+ # Developer package
+ #
+ 
+-ie_developer_export_targets(format_reader)
++#ie_developer_export_targets(format_reader)
+ ie_developer_export_targets(${NGRAPH_LIBRARIES})
+ 
+-ie_developer_export()
++#ie_developer_export()
+ 
+ configure_file(
+     "${IE_MAIN_SOURCE_DIR}/cmake/developer_package_config.cmake.in"
+diff --git a/inference-engine/src/legacy_api/CMakeLists.txt b/inference-engine/src/legacy_api/CMakeLists.txt
+index a03a5f23..63d4f687 100644
+--- a/inference-engine/src/legacy_api/CMakeLists.txt
++++ b/inference-engine/src/legacy_api/CMakeLists.txt
+@@ -22,7 +22,7 @@ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${NN_BUILDER_LIBRARY_SRC}
+             ${PUBLIC_HEADERS})
+diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
+index 2071c126..015d8ff8 100644
+--- a/inference-engine/src/inference_engine/CMakeLists.txt
++++ b/inference-engine/src/inference_engine/CMakeLists.txt
+@@ -98,7 +98,7 @@ add_clang_format_target(${TARGET_NAME}_plugin_api_clang_format FOR_SOURCES ${plu
+ 
+ # Create common base object library
+ 
+-add_library(${TARGET_NAME}_common_obj OBJECT
++add_library(${TARGET_NAME}_common_obj OBJECT EXCLUDE_FROM_ALL
+             ${IE_BASE_SOURCE_FILES})
+ 
+ target_compile_definitions(${TARGET_NAME}_common_obj PRIVATE IMPLEMENT_INFERENCE_ENGINE_API)
+@@ -110,7 +110,7 @@ target_include_directories(${TARGET_NAME}_common_obj SYSTEM PRIVATE
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS}
+             ${PUBLIC_HEADERS})
+@@ -200,7 +200,7 @@ add_clang_format_target(${TARGET_NAME}_nn_builder_clang_format FOR_TARGETS ${TAR
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_common_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_legacy_obj>
+diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+index 52183e86..4fd6d7d4 100644
+--- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
++++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+@@ -163,9 +163,9 @@ add_library(mkldnn_plugin_layers_no_opt OBJECT ${CROSS_COMPILED_SOURCES})
+ set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt)
+ target_compile_definitions(mkldnn_plugin_layers_no_opt PRIVATE "IMPLEMENT_INFERENCE_ENGINE_PLUGIN")
+ 
+-add_library(mkldnn_plugin_layers_no_opt_s OBJECT ${CROSS_COMPILED_SOURCES})
+-set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt_s)
+-target_compile_definitions(mkldnn_plugin_layers_no_opt_s PRIVATE "USE_STATIC_IE;IMPLEMENT_INFERENCE_ENGINE_PLUGIN")
++#add_library(mkldnn_plugin_layers_no_opt_s OBJECT ${CROSS_COMPILED_SOURCES})
++#set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt_s)
++#target_compile_definitions(mkldnn_plugin_layers_no_opt_s PRIVATE "USE_STATIC_IE;IMPLEMENT_INFERENCE_ENGINE_PLUGIN")
+ 
+ set(object_libraries mkldnn_plugin_layers_no_opt)
+ set(mkldnn_plugin_object_libraries mkldnn_plugin_layers_no_opt_s)
+@@ -190,7 +190,7 @@ if (ENABLE_SSE42)
+     endfunction()
+ 
+     mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42)
+-    mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42_s)
++    #mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42_s)
+ 
+     list(APPEND object_libraries mkldnn_plugin_layers_sse42)
+     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_sse42_s)
+@@ -216,7 +216,7 @@ if (ENABLE_AVX2)
+     endfunction()
+ 
+     mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2)
+-    mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2_s)
++    #mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2_s)
+ 
+     list(APPEND object_libraries mkldnn_plugin_layers_avx2)
+     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_avx2_s)
+@@ -242,7 +242,7 @@ if (ENABLE_AVX512F)
+     endfunction()
+ 
+     mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512)
+-    mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512_s)
++    #mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512_s)
+ 
+     list(APPEND object_libraries mkldnn_plugin_layers_avx512)
+     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_avx512_s)
+@@ -264,7 +264,7 @@ target_link_libraries(${TARGET_NAME} PRIVATE inference_engine inference_engine_l
+ 
+ #  add test object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
+ 
+ target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>
+                                                       $<TARGET_PROPERTY:inference_engine_lp_transformations,INTERFACE_INCLUDE_DIRECTORIES>
+diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
+index c3ad1e58..b5913840 100644
+--- a/inference-engine/src/preprocessing/CMakeLists.txt
++++ b/inference-engine/src/preprocessing/CMakeLists.txt
+@@ -124,7 +124,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS})
+ 
+@@ -167,7 +167,7 @@ endif()
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
+ 
+ set_ie_threading_interface_for(${TARGET_NAME}_s)
+diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
+index 65215299..03ba4a4c 100644
+--- a/inference-engine/src/vpu/common/CMakeLists.txt
++++ b/inference-engine/src/vpu/common/CMakeLists.txt
+@@ -53,7 +53,7 @@ add_common_target("vpu_common_lib" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_common_target("vpu_common_lib_test_static" TRUE)
++    #add_common_target("vpu_common_lib_test_static" TRUE)
+ else()
+     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
+ endif()
+diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+index 982d3c7f..15fcf3e8 100644
+--- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
++++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+@@ -64,7 +64,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
++    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
+ else()
+     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
+ endif()
+diff --git a/inference-engine/thirdparty/CMakeLists.txt b/inference-engine/thirdparty/CMakeLists.txt
+index ebf32c71..ad8cb435 100644
+--- a/inference-engine/thirdparty/CMakeLists.txt
++++ b/inference-engine/thirdparty/CMakeLists.txt
+@@ -36,7 +36,7 @@ function(build_with_lto)
+     endif()
+ 
+     add_subdirectory(pugixml)
+-    add_subdirectory(stb_lib)
++    #add_subdirectory(stb_lib)
+     add_subdirectory(ade)
+     add_subdirectory(fluid/modules/gapi)
+ 
+diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+index 8bcb2801..f7e031c0 100644
+--- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
++++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
+ else()
+ 	add_library(pugixml STATIC ${SOURCES})
+ 	if (MSVC)
+-		add_library(pugixml_mt STATIC ${SOURCES})
++               #add_library(pugixml_mt STATIC ${SOURCES})
+ 		#if (WIN32)
+ 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200413-dldt-fix-binaries-location.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200413-dldt-fix-binaries-location.patch
new file mode 100644
index 00000000..153e342a
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200413-dldt-fix-binaries-location.patch
@@ -0,0 +1,13 @@
+diff --git a/cmake/developer_package.cmake b/cmake/developer_package.cmake
+index bed73503..5124795a 100644
+--- a/cmake/developer_package.cmake
++++ b/cmake/developer_package.cmake
+@@ -137,7 +137,7 @@ if("${CMAKE_BUILD_TYPE}" STREQUAL "")
+     set(CMAKE_BUILD_TYPE "Release")
+ endif()
+ 
+-set(OUTPUT_ROOT ${OpenVINO_MAIN_SOURCE_DIR})
++set(OUTPUT_ROOT "${CMAKE_BINARY_DIR}")
+ 
+ # Enable postfixes for Debug/Release builds
+ set(IE_DEBUG_POSTFIX_WIN "d")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200413-dldt-pdb.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200413-dldt-pdb.patch
new file mode 100644
index 00000000..5cf51e2e
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200413-dldt-pdb.patch
@@ -0,0 +1,14 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index edf8233f..cf197376 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -18,6 +18,9 @@ endif()
+ 
+ project(OpenVINO)
+ 
++set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi /FS")
++set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++
+ set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ set(IE_MAIN_SOURCE_DIR ${OpenVINO_MAIN_SOURCE_DIR}/inference-engine)
+ set(CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200415-ngraph-disable-unused-options.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200415-ngraph-disable-unused-options.patch
new file mode 100644
index 00000000..8151755d
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/20200415-ngraph-disable-unused-options.patch
@@ -0,0 +1,14 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index edf8233f..addac6cd 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -78,8 +78,7 @@ function(build_ngraph)
+     if (NOT ANDROID)
+         ngraph_set(NGRAPH_UNIT_TEST_ENABLE TRUE)
+         ngraph_set(NGRAPH_UNIT_TEST_OPENVINO_ENABLE TRUE)
+-        # ngraph_set(NGRAPH_ONNX_IMPORT_ENABLE TRUE)
+-        set(NGRAPH_ONNX_IMPORT_ENABLE TRUE CACHE BOOL "" FORCE)
++        ngraph_set(NGRAPH_ONNX_IMPORT_ENABLE TRUE)
+     else()
+         ngraph_set(NGRAPH_UNIT_TEST_ENABLE FALSE)
+         ngraph_set(NGRAPH_TEST_UTIL_ENABLE FALSE)
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/patch.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/patch.config.py
new file mode 100644
index 00000000..b40970cb
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/patch.config.py
@@ -0,0 +1,4 @@
+applyPatch('20200413-dldt-disable-unused-targets.patch')
+applyPatch('20200413-dldt-fix-binaries-location.patch')
+applyPatch('20200413-dldt-pdb.patch')
+applyPatch('20200415-ngraph-disable-unused-options.patch')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/sysroot.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/sysroot.config.py
new file mode 100644
index 00000000..f51ac812
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.2/sysroot.config.py
@@ -0,0 +1,56 @@
+sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
+copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
+#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
+
+build_config = 'Release' if not self.config.build_debug else 'Debug'
+build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
+
+def copy_bin(name):
+    global build_bin_dir, sysroot_bin_dir
+    copytree(build_bin_dir / name, sysroot_bin_dir / name)
+
+dll_suffix = 'd' if self.config.build_debug else ''
+def copy_dll(name):
+    global copy_bin, dll_suffix
+    copy_bin(name + dll_suffix + '.dll')
+    copy_bin(name + dll_suffix + '.pdb')
+
+copy_bin('cldnn_global_custom_kernels')
+copy_bin('cache.json')
+copy_dll('clDNNPlugin')
+copy_dll('HeteroPlugin')
+copy_dll('inference_engine')
+copy_dll('inference_engine_legacy')
+copy_dll('inference_engine_nn_builder')
+copy_dll('inference_engine_transformations')  # runtime
+copy_dll('inference_engine_lp_transformations')  # runtime
+copy_dll('MKLDNNPlugin')  # runtime
+copy_dll('myriadPlugin')  # runtime
+copy_dll('ngraph')
+copy_bin('plugins.xml')
+copytree(self.build_dir / 'bin' / 'intel64' / 'pcie-ma248x.elf', sysroot_bin_dir / 'pcie-ma248x.elf')
+copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2x8x.mvcmd', sysroot_bin_dir / 'usb-ma2x8x.mvcmd')
+copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2450.mvcmd', sysroot_bin_dir / 'usb-ma2450.mvcmd')
+
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
+
+sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
+sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
+
+copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
+if not self.config.build_debug:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
+    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
+    copytree(build_bin_dir / 'inference_engine_nn_builder.lib', sysroot_ie_lib_dir / 'inference_engine_nn_builder.lib')
+    copytree(build_bin_dir / 'inference_engine_legacy.lib', sysroot_ie_lib_dir / 'inference_engine_legacy.lib')
+else:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
+    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
+    copytree(build_bin_dir / 'inference_engine_nn_builderd.lib', sysroot_ie_lib_dir / 'inference_engine_nn_builderd.lib')
+    copytree(build_bin_dir / 'inference_engine_legacyd.lib', sysroot_ie_lib_dir / 'inference_engine_legacyd.lib')
+
+sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
+copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
+copytree(self.srcdir / 'ngraph/LICENSE', sysroot_license_dir / 'ngraph-LICENSE')
+copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200413-dldt-disable-unused-targets.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200413-dldt-disable-unused-targets.patch
new file mode 100644
index 00000000..c42c7605
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200413-dldt-disable-unused-targets.patch
@@ -0,0 +1,202 @@
+diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
+index e7ea6547..7333d19c 100644
+--- a/inference-engine/CMakeLists.txt
++++ b/inference-engine/CMakeLists.txt
+@@ -72,11 +72,11 @@ if(ENABLE_TESTS)
+     add_subdirectory(tests)
+ endif()
+ 
+-add_subdirectory(tools)
++#add_subdirectory(tools)
+ 
+ # gflags and format_reader targets are kept inside of samples directory and
+ # they must be built even if samples build is disabled (required for tests and tools).
+-add_subdirectory(samples)
++#add_subdirectory(samples)
+ 
+ file(GLOB_RECURSE SAMPLES_SOURCES samples/*.cpp samples/*.hpp samples/*.h)
+ add_cpplint_target(sample_cpplint
+@@ -154,10 +154,10 @@ endif()
+ # Developer package
+ #
+ 
+-ie_developer_export_targets(format_reader)
++#ie_developer_export_targets(format_reader)
+ ie_developer_export_targets(${NGRAPH_LIBRARIES})
+ 
+-ie_developer_export()
++#ie_developer_export()
+ 
+ configure_file(
+     "${IE_MAIN_SOURCE_DIR}/cmake/developer_package_config.cmake.in"
+diff --git a/inference-engine/src/legacy_api/CMakeLists.txt b/inference-engine/src/legacy_api/CMakeLists.txt
+index a03a5f23..63d4f687 100644
+--- a/inference-engine/src/legacy_api/CMakeLists.txt
++++ b/inference-engine/src/legacy_api/CMakeLists.txt
+@@ -22,7 +22,7 @@ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${NN_BUILDER_LIBRARY_SRC}
+             ${PUBLIC_HEADERS})
+diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
+index 2071c126..015d8ff8 100644
+--- a/inference-engine/src/inference_engine/CMakeLists.txt
++++ b/inference-engine/src/inference_engine/CMakeLists.txt
+@@ -98,7 +98,7 @@ add_clang_format_target(${TARGET_NAME}_plugin_api_clang_format FOR_SOURCES ${plu
+ 
+ # Create common base object library
+ 
+-add_library(${TARGET_NAME}_common_obj OBJECT
++add_library(${TARGET_NAME}_common_obj OBJECT EXCLUDE_FROM_ALL
+             ${IE_BASE_SOURCE_FILES})
+ 
+ target_compile_definitions(${TARGET_NAME}_common_obj PRIVATE IMPLEMENT_INFERENCE_ENGINE_API)
+@@ -110,7 +110,7 @@ target_include_directories(${TARGET_NAME}_common_obj SYSTEM PRIVATE
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS}
+             ${PUBLIC_HEADERS})
+@@ -200,7 +200,7 @@ add_clang_format_target(${TARGET_NAME}_nn_builder_clang_format FOR_TARGETS ${TAR
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_common_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_legacy_obj>
+diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+index 52183e86..4fd6d7d4 100644
+--- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
++++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+@@ -163,9 +163,9 @@ add_library(mkldnn_plugin_layers_no_opt OBJECT ${CROSS_COMPILED_SOURCES})
+ set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt)
+ target_compile_definitions(mkldnn_plugin_layers_no_opt PRIVATE "IMPLEMENT_INFERENCE_ENGINE_PLUGIN")
+ 
+-add_library(mkldnn_plugin_layers_no_opt_s OBJECT ${CROSS_COMPILED_SOURCES})
+-set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt_s)
+-target_compile_definitions(mkldnn_plugin_layers_no_opt_s PRIVATE "USE_STATIC_IE;IMPLEMENT_INFERENCE_ENGINE_PLUGIN")
++#add_library(mkldnn_plugin_layers_no_opt_s OBJECT ${CROSS_COMPILED_SOURCES})
++#set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt_s)
++#target_compile_definitions(mkldnn_plugin_layers_no_opt_s PRIVATE "USE_STATIC_IE;IMPLEMENT_INFERENCE_ENGINE_PLUGIN")
+ 
+ set(object_libraries mkldnn_plugin_layers_no_opt)
+ set(mkldnn_plugin_object_libraries mkldnn_plugin_layers_no_opt_s)
+@@ -190,7 +190,7 @@ if (ENABLE_SSE42)
+     endfunction()
+ 
+     mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42)
+-    mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42_s)
++    #mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42_s)
+ 
+     list(APPEND object_libraries mkldnn_plugin_layers_sse42)
+     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_sse42_s)
+@@ -216,7 +216,7 @@ if (ENABLE_AVX2)
+     endfunction()
+ 
+     mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2)
+-    mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2_s)
++    #mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2_s)
+ 
+     list(APPEND object_libraries mkldnn_plugin_layers_avx2)
+     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_avx2_s)
+@@ -242,7 +242,7 @@ if (ENABLE_AVX512F)
+     endfunction()
+ 
+     mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512)
+-    mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512_s)
++    #mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512_s)
+ 
+     list(APPEND object_libraries mkldnn_plugin_layers_avx512)
+     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_avx512_s)
+@@ -264,7 +264,7 @@ target_link_libraries(${TARGET_NAME} PRIVATE inference_engine inference_engine_l
+ 
+ #  add test object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
+ 
+ target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>
+                                                       $<TARGET_PROPERTY:inference_engine_lp_transformations,INTERFACE_INCLUDE_DIRECTORIES>
+diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
+index c3ad1e58..b5913840 100644
+--- a/inference-engine/src/preprocessing/CMakeLists.txt
++++ b/inference-engine/src/preprocessing/CMakeLists.txt
+@@ -124,7 +124,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS})
+ 
+@@ -167,7 +167,7 @@ endif()
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
+ 
+ set_ie_threading_interface_for(${TARGET_NAME}_s)
+diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
+index 65215299..03ba4a4c 100644
+--- a/inference-engine/src/vpu/common/CMakeLists.txt
++++ b/inference-engine/src/vpu/common/CMakeLists.txt
+@@ -53,7 +53,7 @@ add_common_target("vpu_common_lib" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_common_target("vpu_common_lib_test_static" TRUE)
++    #add_common_target("vpu_common_lib_test_static" TRUE)
+ else()
+     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
+ endif()
+diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+index 982d3c7f..15fcf3e8 100644
+--- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
++++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+@@ -64,7 +64,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
++    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
+ else()
+     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
+ endif()
+diff --git a/inference-engine/thirdparty/CMakeLists.txt b/inference-engine/thirdparty/CMakeLists.txt
+index ebf32c71..ad8cb435 100644
+--- a/inference-engine/thirdparty/CMakeLists.txt
++++ b/inference-engine/thirdparty/CMakeLists.txt
+@@ -36,7 +36,7 @@ function(build_with_lto)
+     endif()
+ 
+     add_subdirectory(pugixml)
+-    add_subdirectory(stb_lib)
++    #add_subdirectory(stb_lib)
+     add_subdirectory(ade)
+     add_subdirectory(fluid/modules/gapi)
+ 
+diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+index 8bcb2801..f7e031c0 100644
+--- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
++++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
+ else()
+ 	add_library(pugixml STATIC ${SOURCES})
+ 	if (MSVC)
+-		add_library(pugixml_mt STATIC ${SOURCES})
++               #add_library(pugixml_mt STATIC ${SOURCES})
+ 		#if (WIN32)
+ 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200413-dldt-fix-binaries-location.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200413-dldt-fix-binaries-location.patch
new file mode 100644
index 00000000..153e342a
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200413-dldt-fix-binaries-location.patch
@@ -0,0 +1,13 @@
+diff --git a/cmake/developer_package.cmake b/cmake/developer_package.cmake
+index bed73503..5124795a 100644
+--- a/cmake/developer_package.cmake
++++ b/cmake/developer_package.cmake
+@@ -137,7 +137,7 @@ if("${CMAKE_BUILD_TYPE}" STREQUAL "")
+     set(CMAKE_BUILD_TYPE "Release")
+ endif()
+ 
+-set(OUTPUT_ROOT ${OpenVINO_MAIN_SOURCE_DIR})
++set(OUTPUT_ROOT "${CMAKE_BINARY_DIR}")
+ 
+ # Enable postfixes for Debug/Release builds
+ set(IE_DEBUG_POSTFIX_WIN "d")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200413-dldt-pdb.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200413-dldt-pdb.patch
new file mode 100644
index 00000000..5cf51e2e
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200413-dldt-pdb.patch
@@ -0,0 +1,14 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index edf8233f..cf197376 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -18,6 +18,9 @@ endif()
+ 
+ project(OpenVINO)
+ 
++set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi /FS")
++set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++
+ set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ set(IE_MAIN_SOURCE_DIR ${OpenVINO_MAIN_SOURCE_DIR}/inference-engine)
+ set(CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200604-dldt-disable-multidevice.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200604-dldt-disable-multidevice.patch
new file mode 100644
index 00000000..cee6172e
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/20200604-dldt-disable-multidevice.patch
@@ -0,0 +1,13 @@
+diff --git a/inference-engine/src/CMakeLists.txt b/inference-engine/src/CMakeLists.txt
+index 7e9f590..a460c17 100644
+--- a/inference-engine/src/CMakeLists.txt
++++ b/inference-engine/src/CMakeLists.txt
+@@ -24,7 +24,7 @@ endif()
+ 
+ add_subdirectory(hetero_plugin)
+ 
+-add_subdirectory(multi_device)
++#add_subdirectory(multi_device)
+ 
+ add_subdirectory(transformations)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/patch.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/patch.config.py
new file mode 100644
index 00000000..0492c8b1
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/patch.config.py
@@ -0,0 +1,4 @@
+applyPatch('20200413-dldt-disable-unused-targets.patch')
+applyPatch('20200413-dldt-fix-binaries-location.patch')
+applyPatch('20200413-dldt-pdb.patch')
+applyPatch('20200604-dldt-disable-multidevice.patch')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/sysroot.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/sysroot.config.py
new file mode 100644
index 00000000..49c0e378
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.3.0/sysroot.config.py
@@ -0,0 +1,57 @@
+sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
+copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
+#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
+
+build_config = 'Release' if not self.config.build_debug else 'Debug'
+build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
+
+def copy_bin(name):
+    global build_bin_dir, sysroot_bin_dir
+    copytree(build_bin_dir / name, sysroot_bin_dir / name)
+
+dll_suffix = 'd' if self.config.build_debug else ''
+def copy_dll(name):
+    global copy_bin, dll_suffix
+    copy_bin(name + dll_suffix + '.dll')
+    copy_bin(name + dll_suffix + '.pdb')
+
+copy_bin('cldnn_global_custom_kernels')
+copy_bin('cache.json')
+copy_dll('clDNNPlugin')
+copy_dll('HeteroPlugin')
+copy_dll('inference_engine')
+copy_dll('inference_engine_legacy')
+copy_dll('inference_engine_nn_builder')
+copy_dll('inference_engine_transformations')  # runtime
+copy_dll('inference_engine_lp_transformations')  # runtime
+copy_dll('MKLDNNPlugin')  # runtime
+copy_dll('myriadPlugin')  # runtime
+#copy_dll('MultiDevicePlugin')  # runtime, not used
+copy_dll('ngraph')
+copy_bin('plugins.xml')
+copytree(self.build_dir / 'bin' / 'intel64' / 'pcie-ma248x.elf', sysroot_bin_dir / 'pcie-ma248x.elf')
+copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2x8x.mvcmd', sysroot_bin_dir / 'usb-ma2x8x.mvcmd')
+copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2450.mvcmd', sysroot_bin_dir / 'usb-ma2450.mvcmd')
+
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
+
+sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
+sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
+
+copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
+if not self.config.build_debug:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
+    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
+    copytree(build_bin_dir / 'inference_engine_nn_builder.lib', sysroot_ie_lib_dir / 'inference_engine_nn_builder.lib')
+    copytree(build_bin_dir / 'inference_engine_legacy.lib', sysroot_ie_lib_dir / 'inference_engine_legacy.lib')
+else:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
+    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
+    copytree(build_bin_dir / 'inference_engine_nn_builderd.lib', sysroot_ie_lib_dir / 'inference_engine_nn_builderd.lib')
+    copytree(build_bin_dir / 'inference_engine_legacyd.lib', sysroot_ie_lib_dir / 'inference_engine_legacyd.lib')
+
+sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
+copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
+copytree(self.srcdir / 'ngraph/LICENSE', sysroot_license_dir / 'ngraph-LICENSE')
+copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20200413-dldt-pdb.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20200413-dldt-pdb.patch
new file mode 100644
index 00000000..081c3c04
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20200413-dldt-pdb.patch
@@ -0,0 +1,14 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 1f981ed2..90eb500a 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -22,6 +22,9 @@ endif()
+ 
+ project(OpenVINO)
+ 
++set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi /FS")
++set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++
+ set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ set(IE_MAIN_SOURCE_DIR ${OpenVINO_MAIN_SOURCE_DIR}/inference-engine)
+ list(APPEND CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20200604-dldt-disable-multidevice.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20200604-dldt-disable-multidevice.patch
new file mode 100644
index 00000000..b4d1ef9b
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20200604-dldt-disable-multidevice.patch
@@ -0,0 +1,13 @@
+diff --git a/inference-engine/src/CMakeLists.txt b/inference-engine/src/CMakeLists.txt
+index 0ba0dd78..7d34e7cb 100644
+--- a/inference-engine/src/CMakeLists.txt
++++ b/inference-engine/src/CMakeLists.txt
+@@ -26,7 +26,7 @@ endif()
+ 
+ add_subdirectory(hetero_plugin)
+ 
+-add_subdirectory(multi_device)
++#add_subdirectory(multi_device)
+ 
+ add_subdirectory(transformations)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20200701-dldt-disable-unused-targets.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20200701-dldt-disable-unused-targets.patch
new file mode 100644
index 00000000..bce5ccbd
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20200701-dldt-disable-unused-targets.patch
@@ -0,0 +1,173 @@
+diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
+index 39ff413b..df4e89c7 100644
+--- a/inference-engine/CMakeLists.txt
++++ b/inference-engine/CMakeLists.txt
+@@ -66,7 +66,7 @@ if(ENABLE_TESTS)
+     add_subdirectory(tests)
+ endif()
+ 
+-add_subdirectory(tools)
++#add_subdirectory(tools)
+ 
+ function(ie_build_samples)
+     # samples should be build with the same flags as from OpenVINO package,
+@@ -85,7 +85,7 @@ endfunction()
+ 
+ # gflags and format_reader targets are kept inside of samples directory and
+ # they must be built even if samples build is disabled (required for tests and tools).
+-ie_build_samples()
++#ie_build_samples()
+ 
+ file(GLOB_RECURSE SAMPLES_SOURCES samples/*.cpp samples/*.hpp samples/*.h)
+ add_cpplint_target(sample_cpplint
+@@ -174,10 +174,10 @@ endif()
+ # Developer package
+ #
+ 
+-ie_developer_export_targets(format_reader)
++#ie_developer_export_targets(format_reader)
+ ie_developer_export_targets(${NGRAPH_LIBRARIES})
+ 
+-ie_developer_export()
++#ie_developer_export()
+ 
+ configure_file(
+     "${IE_MAIN_SOURCE_DIR}/cmake/developer_package_config.cmake.in"
+diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
+index 4ae0d560..e37acbe0 100644
+--- a/inference-engine/src/inference_engine/CMakeLists.txt
++++ b/inference-engine/src/inference_engine/CMakeLists.txt
+@@ -99,7 +99,7 @@ add_cpplint_target(${TARGET_NAME}_plugin_api_cpplint FOR_SOURCES ${plugin_api_sr
+ 
+ # Create common base object library
+ 
+-add_library(${TARGET_NAME}_common_obj OBJECT
++add_library(${TARGET_NAME}_common_obj OBJECT EXCLUDE_FROM_ALL
+             ${IE_BASE_SOURCE_FILES})
+ 
+ target_compile_definitions(${TARGET_NAME}_common_obj PRIVATE IMPLEMENT_INFERENCE_ENGINE_API)
+@@ -112,7 +112,7 @@ target_include_directories(${TARGET_NAME}_common_obj SYSTEM PRIVATE
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS}
+             ${PUBLIC_HEADERS})
+@@ -177,7 +177,7 @@ ie_register_plugins(MAIN_TARGET ${TARGET_NAME}
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_common_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_legacy_obj>
+diff --git a/inference-engine/src/legacy_api/CMakeLists.txt b/inference-engine/src/legacy_api/CMakeLists.txt
+index 85524310..ed27e058 100644
+--- a/inference-engine/src/legacy_api/CMakeLists.txt
++++ b/inference-engine/src/legacy_api/CMakeLists.txt
+@@ -21,7 +21,7 @@ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${PUBLIC_HEADERS})
+ 
+diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+index 297783da..06da35c3 100644
+--- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
++++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+@@ -192,7 +192,7 @@ cross_compiled_file(${TARGET_NAME}
+ 
+ #  add test object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
+ 
+ target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>
+                                                       $<TARGET_PROPERTY:inference_engine_lp_transformations,INTERFACE_INCLUDE_DIRECTORIES>
+diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
+index adc52f06..6b7d0ffe 100644
+--- a/inference-engine/src/preprocessing/CMakeLists.txt
++++ b/inference-engine/src/preprocessing/CMakeLists.txt
+@@ -124,7 +124,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS})
+ 
+@@ -183,7 +183,7 @@ add_cpplint_target(${TARGET_NAME}_cpplint FOR_TARGETS ${TARGET_NAME}
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
+ 
+ set_ie_threading_interface_for(${TARGET_NAME}_s)
+diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
+index 43e9308f..2e40dd31 100644
+--- a/inference-engine/src/vpu/common/CMakeLists.txt
++++ b/inference-engine/src/vpu/common/CMakeLists.txt
+@@ -55,7 +55,7 @@ add_common_target("vpu_common_lib" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_common_target("vpu_common_lib_test_static" TRUE)
++    #add_common_target("vpu_common_lib_test_static" TRUE)
+ else()
+     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
+ endif()
+diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+index 982d3c7f..15fcf3e8 100644
+--- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
++++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+@@ -64,7 +64,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
++    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
+ else()
+     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
+ endif()
+diff --git a/inference-engine/thirdparty/CMakeLists.txt b/inference-engine/thirdparty/CMakeLists.txt
+index f94453e0..c80e75c5 100644
+--- a/inference-engine/thirdparty/CMakeLists.txt
++++ b/inference-engine/thirdparty/CMakeLists.txt
+@@ -43,13 +43,13 @@ function(build_with_lto)
+     endfunction()
+ 
+     ie_build_pugixml()
+-    add_subdirectory(stb_lib)
++    #add_subdirectory(stb_lib)
+     add_subdirectory(ade)
+     add_subdirectory(fluid/modules/gapi)
+ 
+     target_include_directories(pugixml INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/pugixml/src>")
+ 
+-    set_target_properties(pugixml ade fluid stb_image
++    set_target_properties(pugixml ade fluid
+                           PROPERTIES FOLDER thirdparty)
+ 
+     # developer package
+diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+index 8bcb2801..380fb468 100644
+--- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
++++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
+ else()
+ 	add_library(pugixml STATIC ${SOURCES})
+ 	if (MSVC)
+-		add_library(pugixml_mt STATIC ${SOURCES})
++               #add_library(pugixml_mt STATIC ${SOURCES})
+ 		#if (WIN32)
+ 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20201005-dldt-fix-cldnn-compilation.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20201005-dldt-fix-cldnn-compilation.patch
new file mode 100644
index 00000000..152af26c
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/20201005-dldt-fix-cldnn-compilation.patch
@@ -0,0 +1,12 @@
+diff --git a/inference-engine/thirdparty/clDNN/kernel_selector/common/tensor_type.h b/inference-engine/thirdparty/clDNN/kernel_selector/common/tensor_type.h
+index 3dbdfd0b..6b04b910 100644
+--- a/inference-engine/thirdparty/clDNN/kernel_selector/common/tensor_type.h
++++ b/inference-engine/thirdparty/clDNN/kernel_selector/common/tensor_type.h
+@@ -15,6 +15,7 @@
+ 
+ #pragma once
+ 
++#include <stdexcept>
+ #include "common_types.h"
+ #include "common_tools.h"
+ #include <vector>
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/patch.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/patch.config.py
new file mode 100644
index 00000000..6fe3e6e1
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/patch.config.py
@@ -0,0 +1,4 @@
+applyPatch('20200701-dldt-disable-unused-targets.patch')
+applyPatch('20200413-dldt-pdb.patch')
+applyPatch('20200604-dldt-disable-multidevice.patch')
+applyPatch('20201005-dldt-fix-cldnn-compilation.patch')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/sysroot.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/sysroot.config.py
new file mode 100644
index 00000000..fc8dffd3
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2020.4/sysroot.config.py
@@ -0,0 +1,56 @@
+sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
+copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
+#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
+
+build_config = 'Release' if not self.config.build_debug else 'Debug'
+build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
+
+def copy_bin(name):
+    global build_bin_dir, sysroot_bin_dir
+    copytree(build_bin_dir / name, sysroot_bin_dir / name)
+
+dll_suffix = 'd' if self.config.build_debug else ''
+def copy_dll(name):
+    global copy_bin, dll_suffix
+    copy_bin(name + dll_suffix + '.dll')
+    copy_bin(name + dll_suffix + '.pdb')
+
+copy_bin('cache.json')
+copy_dll('clDNNPlugin')
+copy_dll('HeteroPlugin')
+copy_dll('inference_engine')
+copy_dll('inference_engine_ir_reader')
+copy_dll('inference_engine_legacy')
+copy_dll('inference_engine_transformations')  # runtime
+copy_dll('inference_engine_lp_transformations')  # runtime
+copy_dll('MKLDNNPlugin')  # runtime
+copy_dll('myriadPlugin')  # runtime
+#copy_dll('MultiDevicePlugin')  # runtime, not used
+copy_dll('ngraph')
+copy_bin('plugins.xml')
+copytree(self.build_dir / 'bin' / 'intel64' / 'pcie-ma248x.elf', sysroot_bin_dir / 'pcie-ma248x.elf')
+copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2x8x.mvcmd', sysroot_bin_dir / 'usb-ma2x8x.mvcmd')
+copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2450.mvcmd', sysroot_bin_dir / 'usb-ma2450.mvcmd')
+
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
+
+sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
+sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
+
+copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
+if not self.config.build_debug:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
+    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_reader.lib', sysroot_ie_lib_dir / 'inference_engine_ir_reader.lib')
+    copytree(build_bin_dir / 'inference_engine_legacy.lib', sysroot_ie_lib_dir / 'inference_engine_legacy.lib')
+else:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
+    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_readerd.lib', sysroot_ie_lib_dir / 'inference_engine_ir_readerd.lib')
+    copytree(build_bin_dir / 'inference_engine_legacyd.lib', sysroot_ie_lib_dir / 'inference_engine_legacyd.lib')
+
+sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
+copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
+copytree(self.srcdir / 'ngraph/LICENSE', sysroot_license_dir / 'ngraph-LICENSE')
+copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/20200413-dldt-pdb.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/20200413-dldt-pdb.patch
new file mode 100644
index 00000000..081c3c04
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/20200413-dldt-pdb.patch
@@ -0,0 +1,14 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 1f981ed2..90eb500a 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -22,6 +22,9 @@ endif()
+ 
+ project(OpenVINO)
+ 
++set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi /FS")
++set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++
+ set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ set(IE_MAIN_SOURCE_DIR ${OpenVINO_MAIN_SOURCE_DIR}/inference-engine)
+ list(APPEND CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/20200604-dldt-disable-multidevice.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/20200604-dldt-disable-multidevice.patch
new file mode 100644
index 00000000..b4d1ef9b
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/20200604-dldt-disable-multidevice.patch
@@ -0,0 +1,13 @@
+diff --git a/inference-engine/src/CMakeLists.txt b/inference-engine/src/CMakeLists.txt
+index 0ba0dd78..7d34e7cb 100644
+--- a/inference-engine/src/CMakeLists.txt
++++ b/inference-engine/src/CMakeLists.txt
+@@ -26,7 +26,7 @@ endif()
+ 
+ add_subdirectory(hetero_plugin)
+ 
+-add_subdirectory(multi_device)
++#add_subdirectory(multi_device)
+ 
+ add_subdirectory(transformations)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/20201005-dldt-disable-unused-targets.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/20201005-dldt-disable-unused-targets.patch
new file mode 100644
index 00000000..0f56717e
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/20201005-dldt-disable-unused-targets.patch
@@ -0,0 +1,178 @@
+diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
+index 7f45ab02..a7bac7e9 100644
+--- a/inference-engine/CMakeLists.txt
++++ b/inference-engine/CMakeLists.txt
+@@ -70,7 +70,7 @@ if(ENABLE_TESTS)
+     add_subdirectory(tests)
+ endif()
+ 
+-add_subdirectory(tools)
++#add_subdirectory(tools)
+ 
+ function(ie_build_samples)
+     # samples should be build with the same flags as from OpenVINO package,
+@@ -89,7 +89,7 @@ endfunction()
+ 
+ # gflags and format_reader targets are kept inside of samples directory and
+ # they must be built even if samples build is disabled (required for tests and tools).
+-ie_build_samples()
++#ie_build_samples()
+ 
+ file(GLOB_RECURSE SAMPLES_SOURCES samples/*.cpp samples/*.hpp samples/*.h)
+ add_cpplint_target(sample_cpplint
+@@ -180,7 +180,7 @@ endif()
+ # Developer package
+ #
+ 
+-ie_developer_export_targets(format_reader)
++#ie_developer_export_targets(format_reader)
+ ie_developer_export_targets(${NGRAPH_LIBRARIES})
+ 
+ # for Template plugin
+@@ -188,7 +188,7 @@ if(NGRAPH_INTERPRETER_ENABLE)
+     ie_developer_export_targets(ngraph_backend interpreter_backend)
+ endif()
+ 
+-ie_developer_export()
++#ie_developer_export()
+ 
+ configure_file(
+     "${IE_MAIN_SOURCE_DIR}/cmake/developer_package_config.cmake.in"
+diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
+index 9ab88898..8badb591 100644
+--- a/inference-engine/src/inference_engine/CMakeLists.txt
++++ b/inference-engine/src/inference_engine/CMakeLists.txt
+@@ -118,7 +118,7 @@ add_cpplint_target(${TARGET_NAME}_plugin_api_cpplint FOR_SOURCES ${plugin_api_sr
+ 
+ # Create common base object library
+ 
+-add_library(${TARGET_NAME}_common_obj OBJECT
++add_library(${TARGET_NAME}_common_obj OBJECT EXCLUDE_FROM_ALL
+             ${IE_BASE_SOURCE_FILES})
+ 
+ target_compile_definitions(${TARGET_NAME}_common_obj PRIVATE IMPLEMENT_INFERENCE_ENGINE_API)
+@@ -132,7 +132,7 @@ target_include_directories(${TARGET_NAME}_common_obj SYSTEM PRIVATE
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS}
+             ${PUBLIC_HEADERS})
+@@ -183,7 +183,7 @@ ie_register_plugins(MAIN_TARGET ${TARGET_NAME}
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_common_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_legacy_obj>
+diff --git a/inference-engine/src/legacy_api/CMakeLists.txt b/inference-engine/src/legacy_api/CMakeLists.txt
+index ed87a073..b30e6671 100644
+--- a/inference-engine/src/legacy_api/CMakeLists.txt
++++ b/inference-engine/src/legacy_api/CMakeLists.txt
+@@ -26,7 +26,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${PUBLIC_HEADERS})
+ 
+diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+index 166818cd..6c1e8e36 100644
+--- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
++++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+@@ -193,7 +193,7 @@ cross_compiled_file(${TARGET_NAME}
+ 
+ #  add test object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
+ 
+ target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>
+                                                       $<TARGET_PROPERTY:inference_engine_lp_transformations,INTERFACE_INCLUDE_DIRECTORIES>
+diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
+index f4fed72a..9cedd6b5 100644
+--- a/inference-engine/src/preprocessing/CMakeLists.txt
++++ b/inference-engine/src/preprocessing/CMakeLists.txt
+@@ -124,7 +124,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS})
+ 
+@@ -175,7 +175,7 @@ add_cpplint_target(${TARGET_NAME}_cpplint FOR_TARGETS ${TARGET_NAME}
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
+ 
+ set_ie_threading_interface_for(${TARGET_NAME}_s)
+diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
+index b291d5b4..74ab8287 100644
+--- a/inference-engine/src/vpu/common/CMakeLists.txt
++++ b/inference-engine/src/vpu/common/CMakeLists.txt
+@@ -57,7 +57,7 @@ add_common_target("vpu_common_lib" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_common_target("vpu_common_lib_test_static" TRUE)
++    #add_common_target("vpu_common_lib_test_static" TRUE)
+ else()
+     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
+ endif()
+diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+index a4543745..807b8e36 100644
+--- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
++++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+@@ -65,7 +65,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
++    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
+ else()
+     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
+ endif()
+diff --git a/inference-engine/thirdparty/CMakeLists.txt b/inference-engine/thirdparty/CMakeLists.txt
+index a2550bfa..10ce316f 100644
+--- a/inference-engine/thirdparty/CMakeLists.txt
++++ b/inference-engine/thirdparty/CMakeLists.txt
+@@ -56,13 +56,13 @@ function(build_with_lto)
+     endfunction()
+ 
+     ie_build_pugixml()
+-    add_subdirectory(stb_lib)
++    #add_subdirectory(stb_lib)
+     add_subdirectory(ade)
+     add_subdirectory(fluid/modules/gapi)
+ 
+     target_include_directories(pugixml INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/pugixml/src>")
+ 
+-    set_target_properties(pugixml ade fluid stb_image
++    set_target_properties(pugixml ade fluid
+                           PROPERTIES FOLDER thirdparty)
+ 
+     # developer package
+diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+index 8bcb2801..380fb468 100644
+--- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
++++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
+ else()
+ 	add_library(pugixml STATIC ${SOURCES})
+ 	if (MSVC)
+-		add_library(pugixml_mt STATIC ${SOURCES})
++               #add_library(pugixml_mt STATIC ${SOURCES})
+ 		#if (WIN32)
+ 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/patch.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/patch.config.py
new file mode 100644
index 00000000..8c890159
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/patch.config.py
@@ -0,0 +1,3 @@
+applyPatch('20201005-dldt-disable-unused-targets.patch')
+applyPatch('20200413-dldt-pdb.patch')
+applyPatch('20200604-dldt-disable-multidevice.patch')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/sysroot.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/sysroot.config.py
new file mode 100644
index 00000000..fc8dffd3
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.1/sysroot.config.py
@@ -0,0 +1,56 @@
+sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
+copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
+#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
+
+build_config = 'Release' if not self.config.build_debug else 'Debug'
+build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
+
+def copy_bin(name):
+    global build_bin_dir, sysroot_bin_dir
+    copytree(build_bin_dir / name, sysroot_bin_dir / name)
+
+dll_suffix = 'd' if self.config.build_debug else ''
+def copy_dll(name):
+    global copy_bin, dll_suffix
+    copy_bin(name + dll_suffix + '.dll')
+    copy_bin(name + dll_suffix + '.pdb')
+
+copy_bin('cache.json')
+copy_dll('clDNNPlugin')
+copy_dll('HeteroPlugin')
+copy_dll('inference_engine')
+copy_dll('inference_engine_ir_reader')
+copy_dll('inference_engine_legacy')
+copy_dll('inference_engine_transformations')  # runtime
+copy_dll('inference_engine_lp_transformations')  # runtime
+copy_dll('MKLDNNPlugin')  # runtime
+copy_dll('myriadPlugin')  # runtime
+#copy_dll('MultiDevicePlugin')  # runtime, not used
+copy_dll('ngraph')
+copy_bin('plugins.xml')
+copytree(self.build_dir / 'bin' / 'intel64' / 'pcie-ma248x.elf', sysroot_bin_dir / 'pcie-ma248x.elf')
+copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2x8x.mvcmd', sysroot_bin_dir / 'usb-ma2x8x.mvcmd')
+copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2450.mvcmd', sysroot_bin_dir / 'usb-ma2450.mvcmd')
+
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
+
+sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
+sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
+
+copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
+if not self.config.build_debug:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
+    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_reader.lib', sysroot_ie_lib_dir / 'inference_engine_ir_reader.lib')
+    copytree(build_bin_dir / 'inference_engine_legacy.lib', sysroot_ie_lib_dir / 'inference_engine_legacy.lib')
+else:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
+    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_readerd.lib', sysroot_ie_lib_dir / 'inference_engine_ir_readerd.lib')
+    copytree(build_bin_dir / 'inference_engine_legacyd.lib', sysroot_ie_lib_dir / 'inference_engine_legacyd.lib')
+
+sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
+copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
+copytree(self.srcdir / 'ngraph/LICENSE', sysroot_license_dir / 'ngraph-LICENSE')
+copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20200413-dldt-pdb.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20200413-dldt-pdb.patch
new file mode 100644
index 00000000..081c3c04
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20200413-dldt-pdb.patch
@@ -0,0 +1,14 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 1f981ed2..90eb500a 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -22,6 +22,9 @@ endif()
+ 
+ project(OpenVINO)
+ 
++set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi /FS")
++set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++
+ set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ set(IE_MAIN_SOURCE_DIR ${OpenVINO_MAIN_SOURCE_DIR}/inference-engine)
+ list(APPEND CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20200604-dldt-disable-multidevice.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20200604-dldt-disable-multidevice.patch
new file mode 100644
index 00000000..b4d1ef9b
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20200604-dldt-disable-multidevice.patch
@@ -0,0 +1,13 @@
+diff --git a/inference-engine/src/CMakeLists.txt b/inference-engine/src/CMakeLists.txt
+index 0ba0dd78..7d34e7cb 100644
+--- a/inference-engine/src/CMakeLists.txt
++++ b/inference-engine/src/CMakeLists.txt
+@@ -26,7 +26,7 @@ endif()
+ 
+ add_subdirectory(hetero_plugin)
+ 
+-add_subdirectory(multi_device)
++#add_subdirectory(multi_device)
+ 
+ add_subdirectory(transformations)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20201217-dldt-disable-unused-targets.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20201217-dldt-disable-unused-targets.patch
new file mode 100644
index 00000000..7e0c57eb
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20201217-dldt-disable-unused-targets.patch
@@ -0,0 +1,250 @@
+diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
+index a3e4f74c..190305a6 100644
+--- a/inference-engine/CMakeLists.txt
++++ b/inference-engine/CMakeLists.txt
+@@ -69,7 +69,7 @@ if(ENABLE_TESTS)
+     add_subdirectory(tests)
+ endif()
+ 
+-add_subdirectory(tools)
++#add_subdirectory(tools)
+ 
+ function(ie_build_samples)
+     # samples should be build with the same flags as from OpenVINO package,
+@@ -88,7 +88,7 @@ endfunction()
+ 
+ # gflags and format_reader targets are kept inside of samples directory and
+ # they must be built even if samples build is disabled (required for tests and tools).
+-ie_build_samples()
++#ie_build_samples()
+ 
+ file(GLOB_RECURSE SAMPLES_SOURCES samples/*.cpp samples/*.hpp samples/*.h)
+ add_cpplint_target(sample_cpplint
+@@ -179,7 +179,7 @@ endif()
+ # Developer package
+ #
+ 
+-ie_developer_export_targets(format_reader)
++#ie_developer_export_targets(format_reader)
+ ie_developer_export_targets(${NGRAPH_LIBRARIES})
+ 
+ # for Template plugin
+@@ -187,7 +187,7 @@ if(NGRAPH_INTERPRETER_ENABLE)
+     ie_developer_export_targets(ngraph_backend interpreter_backend)
+ endif()
+ 
+-ie_developer_export()
++#ie_developer_export()
+ 
+ configure_file(
+     "${IE_MAIN_SOURCE_DIR}/cmake/developer_package_config.cmake.in"
+diff --git a/inference-engine/cmake/add_ie_target.cmake b/inference-engine/cmake/add_ie_target.cmake
+index 35b96542..48dacfb3 100644
+--- a/inference-engine/cmake/add_ie_target.cmake
++++ b/inference-engine/cmake/add_ie_target.cmake
+@@ -91,7 +91,7 @@ function(addIeTarget)
+     if (ARG_TYPE STREQUAL EXECUTABLE)
+         add_executable(${ARG_NAME} ${all_sources})
+     elseif(ARG_TYPE STREQUAL STATIC OR ARG_TYPE STREQUAL SHARED)
+-        add_library(${ARG_NAME} ${ARG_TYPE} ${all_sources})
++        add_library(${ARG_NAME} ${ARG_TYPE} EXCLUDE_FROM_ALL ${all_sources})
+     else()
+         message(SEND_ERROR "Invalid target type ${ARG_TYPE} specified for target name ${ARG_NAME}")
+     endif()
+diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
+index f012a038..5204fb6a 100644
+--- a/inference-engine/src/inference_engine/CMakeLists.txt
++++ b/inference-engine/src/inference_engine/CMakeLists.txt
+@@ -99,7 +99,7 @@ add_cpplint_target(${TARGET_NAME}_plugin_api_cpplint FOR_SOURCES ${plugin_api_sr
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS}
+             ${PUBLIC_HEADERS})
+@@ -162,7 +162,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_legacy_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
+             ${IE_STATIC_DEPENDENT_FILES})
+diff --git a/inference-engine/src/legacy_api/CMakeLists.txt b/inference-engine/src/legacy_api/CMakeLists.txt
+index fab2f68d..864953a1 100644
+--- a/inference-engine/src/legacy_api/CMakeLists.txt
++++ b/inference-engine/src/legacy_api/CMakeLists.txt
+@@ -22,7 +22,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${PUBLIC_HEADERS})
+ 
+diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+index f52926d6..dd039e29 100644
+--- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
++++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+@@ -194,7 +194,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ #  add test object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
+ 
+ target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>
+                                                       $<TARGET_PROPERTY:inference_engine_legacy,INTERFACE_INCLUDE_DIRECTORIES>
+diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
+index d47dfb35..a9046654 100644
+--- a/inference-engine/src/preprocessing/CMakeLists.txt
++++ b/inference-engine/src/preprocessing/CMakeLists.txt
+@@ -101,7 +101,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS})
+ 
+@@ -153,7 +153,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
+ 
+ set_ie_threading_interface_for(${TARGET_NAME}_s)
+diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
+index bd97c2c6..d89cdaa5 100644
+--- a/inference-engine/src/vpu/common/CMakeLists.txt
++++ b/inference-engine/src/vpu/common/CMakeLists.txt
+@@ -5,7 +5,7 @@
+ file(GLOB_RECURSE SOURCES *.cpp *.hpp *.h)
+ 
+ function(add_common_target TARGET_NAME STATIC_IE)
+-    add_library(${TARGET_NAME} STATIC ${SOURCES})
++    add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+     ie_faster_build(${TARGET_NAME}
+         UNITY
+@@ -62,7 +62,7 @@ add_common_target("vpu_common_lib" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_common_target("vpu_common_lib_test_static" TRUE)
++    #add_common_target("vpu_common_lib_test_static" TRUE)
+ else()
+     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
+ endif()
+diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+index 797ef975..0cc5a65a 100644
+--- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
++++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+@@ -5,7 +5,7 @@
+ file(GLOB_RECURSE SOURCES *.cpp *.hpp *.h *.inc)
+ 
+ function(add_graph_transformer_target TARGET_NAME STATIC_IE)
+-    add_library(${TARGET_NAME} STATIC ${SOURCES})
++    add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+     set_ie_threading_interface_for(${TARGET_NAME})
+ 
+@@ -63,7 +63,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
++    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
+ else()
+     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
+ endif()
+diff --git a/inference-engine/thirdparty/CMakeLists.txt b/inference-engine/thirdparty/CMakeLists.txt
+index fa2a4d02..c2ca41cd 100644
+--- a/inference-engine/thirdparty/CMakeLists.txt
++++ b/inference-engine/thirdparty/CMakeLists.txt
+@@ -61,11 +61,11 @@ else()
+     target_include_directories(pugixml INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/pugixml/src>")
+ endif()
+ 
+-add_subdirectory(stb_lib)
++#add_subdirectory(stb_lib)
+ add_subdirectory(ade)
+ add_subdirectory(fluid/modules/gapi)
+ 
+-set_target_properties(ade fluid stb_image PROPERTIES FOLDER thirdparty)
++set_target_properties(ade fluid PROPERTIES FOLDER thirdparty)
+ 
+ # developer package
+ 
+diff --git a/inference-engine/thirdparty/mkldnn.cmake b/inference-engine/thirdparty/mkldnn.cmake
+index 0c2e936e..f36e7beb 100644
+--- a/inference-engine/thirdparty/mkldnn.cmake
++++ b/inference-engine/thirdparty/mkldnn.cmake
+@@ -117,7 +117,7 @@ if(WIN32)
+     endif()
+ endif()
+ 
+-add_library(${TARGET} STATIC ${HDR} ${SRC})
++add_library(${TARGET} STATIC EXCLUDE_FROM_ALL ${HDR} ${SRC})
+ set_ie_threading_interface_for(${TARGET})
+ 
+ if(GEMM STREQUAL "OPENBLAS")
+diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+index 8bcb2801..380fb468 100644
+--- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
++++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
+ else()
+ 	add_library(pugixml STATIC ${SOURCES})
+ 	if (MSVC)
+-		add_library(pugixml_mt STATIC ${SOURCES})
++                #add_library(pugixml_mt STATIC ${SOURCES})
+ 		#if (WIN32)
+ 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+diff --git a/ngraph/core/builder/CMakeLists.txt b/ngraph/core/builder/CMakeLists.txt
+index 4c5a4766..6f5f2535 100644
+--- a/ngraph/core/builder/CMakeLists.txt
++++ b/ngraph/core/builder/CMakeLists.txt
+@@ -28,7 +28,7 @@ source_group("src" FILES ${LIBRARY_SRC})
+ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create shared library
+-add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${LIBRARY_SRC} ${PUBLIC_HEADERS})
+ 
+ if(COMMAND ie_faster_build)
+     ie_faster_build(${TARGET_NAME}
+diff --git a/ngraph/core/reference/CMakeLists.txt b/ngraph/core/reference/CMakeLists.txt
+index 2fa49195..ce68fdc8 100644
+--- a/ngraph/core/reference/CMakeLists.txt
++++ b/ngraph/core/reference/CMakeLists.txt
+@@ -28,7 +28,7 @@ source_group("src" FILES ${LIBRARY_SRC})
+ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create shared library
+-add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${LIBRARY_SRC} ${PUBLIC_HEADERS})
+ 
+ if(COMMAND ie_faster_build)
+     ie_faster_build(${TARGET_NAME}
+diff --git a/openvino/itt/CMakeLists.txt b/openvino/itt/CMakeLists.txt
+index 766521a1..04240a89 100644
+--- a/openvino/itt/CMakeLists.txt
++++ b/openvino/itt/CMakeLists.txt
+@@ -56,7 +56,7 @@ if(ENABLE_PROFILING_ITT)
+     endif()
+ endif()
+ 
+-add_library(${TARGET_NAME} STATIC ${SOURCES})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+ add_library(openvino::itt ALIAS ${TARGET_NAME})
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20201218-dldt-vs-version.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20201218-dldt-vs-version.patch
new file mode 100644
index 00000000..4d60de77
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/20201218-dldt-vs-version.patch
@@ -0,0 +1,16 @@
+diff --git a/cmake/vs_version/vs_version.cmake b/cmake/vs_version/vs_version.cmake
+index d857e2e4..453903fd 100644
+--- a/cmake/vs_version/vs_version.cmake
++++ b/cmake/vs_version/vs_version.cmake
+@@ -22,9 +22,9 @@ if(IE_VS_VER_HAS_VERSION)
+ endif()
+ 
+ set(IE_VS_VER_PRODUCTVERSION_STR "${CI_BUILD_NUMBER}")
+-set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit")
++set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit (for OpenCV Windows package)")
+ set(IE_VS_VER_COPYRIGHT_STR "Copyright (C) 2018-2020, Intel Corporation")
+-set(IE_VS_VER_COMMENTS_STR "https://docs.openvinotoolkit.org/")
++set(IE_VS_VER_COMMENTS_STR "https://github.com/opencv/opencv/wiki/Intel%27s-Deep-Learning-Inference-Engine-backend")
+ 
+ #
+ # ie_add_vs_version_file(NAME <name>
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/build.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/build.config.py
new file mode 100644
index 00000000..ebb0cb1a
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/build.config.py
@@ -0,0 +1,3 @@
+os.environ['CI_BUILD_NUMBER'] = '2021.2.0-opencv_winpack_dldt'
+
+cmake_vars['ENABLE_V10_SERIALIZE'] = 'ON'
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/patch.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/patch.config.py
new file mode 100644
index 00000000..76b16544
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/patch.config.py
@@ -0,0 +1,4 @@
+applyPatch('20201217-dldt-disable-unused-targets.patch')
+applyPatch('20200413-dldt-pdb.patch')
+applyPatch('20200604-dldt-disable-multidevice.patch')
+applyPatch('20201218-dldt-vs-version.patch')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/sysroot.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/sysroot.config.py
new file mode 100644
index 00000000..0862e1e0
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.2/sysroot.config.py
@@ -0,0 +1,54 @@
+sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
+copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
+#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
+
+build_config = 'Release' if not self.config.build_debug else 'Debug'
+build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
+
+def copy_bin(name):
+    global build_bin_dir, sysroot_bin_dir
+    copytree(build_bin_dir / name, sysroot_bin_dir / name)
+
+dll_suffix = 'd' if self.config.build_debug else ''
+def copy_dll(name):
+    global copy_bin, dll_suffix
+    copy_bin(name + dll_suffix + '.dll')
+    copy_bin(name + dll_suffix + '.pdb')
+
+copy_bin('cache.json')
+copy_dll('clDNNPlugin')
+copy_dll('HeteroPlugin')
+copy_dll('inference_engine')
+copy_dll('inference_engine_ir_reader')
+copy_dll('inference_engine_legacy')
+copy_dll('inference_engine_transformations')  # runtime
+copy_dll('inference_engine_lp_transformations')  # runtime
+copy_dll('MKLDNNPlugin')  # runtime
+copy_dll('myriadPlugin')  # runtime
+#copy_dll('MultiDevicePlugin')  # runtime, not used
+copy_dll('ngraph')
+copy_bin('plugins.xml')
+copy_bin('pcie-ma2x8x.elf')
+copy_bin('usb-ma2x8x.mvcmd')
+
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
+
+sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
+sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
+
+copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
+if not self.config.build_debug:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
+    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_reader.lib', sysroot_ie_lib_dir / 'inference_engine_ir_reader.lib')
+    copytree(build_bin_dir / 'inference_engine_legacy.lib', sysroot_ie_lib_dir / 'inference_engine_legacy.lib')
+else:
+    copytree(self.build_dir / 'install' / 'lib' / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
+    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_readerd.lib', sysroot_ie_lib_dir / 'inference_engine_ir_readerd.lib')
+    copytree(build_bin_dir / 'inference_engine_legacyd.lib', sysroot_ie_lib_dir / 'inference_engine_legacyd.lib')
+
+sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
+copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
+copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20200604-dldt-disable-multidevice.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20200604-dldt-disable-multidevice.patch
new file mode 100644
index 00000000..b4d1ef9b
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20200604-dldt-disable-multidevice.patch
@@ -0,0 +1,13 @@
+diff --git a/inference-engine/src/CMakeLists.txt b/inference-engine/src/CMakeLists.txt
+index 0ba0dd78..7d34e7cb 100644
+--- a/inference-engine/src/CMakeLists.txt
++++ b/inference-engine/src/CMakeLists.txt
+@@ -26,7 +26,7 @@ endif()
+ 
+ add_subdirectory(hetero_plugin)
+ 
+-add_subdirectory(multi_device)
++#add_subdirectory(multi_device)
+ 
+ add_subdirectory(transformations)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20210324-dldt-disable-unused-targets.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20210324-dldt-disable-unused-targets.patch
new file mode 100644
index 00000000..2b70be76
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20210324-dldt-disable-unused-targets.patch
@@ -0,0 +1,219 @@
+diff --git a/cmake/developer_package/add_ie_target.cmake b/cmake/developer_package/add_ie_target.cmake
+index b081a6945..5468f09f0 100644
+--- a/cmake/developer_package/add_ie_target.cmake
++++ b/cmake/developer_package/add_ie_target.cmake
+@@ -91,7 +91,7 @@ function(addIeTarget)
+     if (ARG_TYPE STREQUAL EXECUTABLE)
+         add_executable(${ARG_NAME} ${all_sources})
+     elseif(ARG_TYPE STREQUAL STATIC OR ARG_TYPE STREQUAL SHARED)
+-        add_library(${ARG_NAME} ${ARG_TYPE} ${all_sources})
++        add_library(${ARG_NAME} ${ARG_TYPE} EXCLUDE_FROM_ALL ${all_sources})
+     else()
+         message(SEND_ERROR "Invalid target type ${ARG_TYPE} specified for target name ${ARG_NAME}")
+     endif()
+diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
+index 95c657222..3ab53f854 100644
+--- a/inference-engine/CMakeLists.txt
++++ b/inference-engine/CMakeLists.txt
+@@ -39,7 +39,7 @@ if(ENABLE_TESTS)
+     add_subdirectory(tests)
+ endif()
+ 
+-add_subdirectory(tools)
++#add_subdirectory(tools)
+ 
+ function(ie_build_samples)
+     # samples should be build with the same flags as from OpenVINO package,
+@@ -58,7 +58,7 @@ endfunction()
+ 
+ # gflags and format_reader targets are kept inside of samples directory and
+ # they must be built even if samples build is disabled (required for tests and tools).
+-ie_build_samples()
++#ie_build_samples()
+ 
+ if (ENABLE_PYTHON)
+     add_subdirectory(ie_bridges/python)
+@@ -138,7 +138,7 @@ endif()
+ # Developer package
+ #
+ 
+-openvino_developer_export_targets(COMPONENT openvino_common TARGETS format_reader)
++#openvino_developer_export_targets(COMPONENT openvino_common TARGETS format_reader)
+ openvino_developer_export_targets(COMPONENT ngraph TARGETS ${NGRAPH_LIBRARIES})
+ 
+ # for Template plugin
+@@ -146,7 +146,7 @@ if(NGRAPH_INTERPRETER_ENABLE)
+     openvino_developer_export_targets(COMPONENT ngraph TARGETS ngraph_backend interpreter_backend)
+ endif()
+ 
+-ie_developer_export()
++#ie_developer_export()
+ 
+ configure_file(
+     "${IE_MAIN_SOURCE_DIR}/cmake/templates/InferenceEngineDeveloperPackageConfig.cmake.in"
+diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
+index 1ea322763..b5c25837d 100644
+--- a/inference-engine/src/inference_engine/CMakeLists.txt
++++ b/inference-engine/src/inference_engine/CMakeLists.txt
+@@ -95,7 +95,7 @@ add_cpplint_target(${TARGET_NAME}_plugin_api_cpplint FOR_SOURCES ${plugin_api_sr
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS}
+             ${PUBLIC_HEADERS})
+@@ -156,7 +156,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_legacy_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
+             ${IE_STATIC_DEPENDENT_FILES})
+diff --git a/inference-engine/src/legacy_api/CMakeLists.txt b/inference-engine/src/legacy_api/CMakeLists.txt
+index 66498fdbd..4a6c7f619 100644
+--- a/inference-engine/src/legacy_api/CMakeLists.txt
++++ b/inference-engine/src/legacy_api/CMakeLists.txt
+@@ -26,7 +26,7 @@ endif()
+ 
+ file(TOUCH ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp)
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${PUBLIC_HEADERS})
+ 
+diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+index 73c7ba9f9..e8cf8d9f9 100644
+--- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
++++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+@@ -78,7 +78,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ #  add test object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
+ target_link_libraries(${TARGET_NAME}_obj PUBLIC mkldnn)
+ 
+ target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>
+diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
+index 973fafcbf..d886d6aa4 100644
+--- a/inference-engine/src/preprocessing/CMakeLists.txt
++++ b/inference-engine/src/preprocessing/CMakeLists.txt
+@@ -101,7 +101,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS})
+ 
+@@ -153,7 +153,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
+ 
+ set_ie_threading_interface_for(${TARGET_NAME}_s)
+diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
+index 5c31c9a7a..adb170a5f 100644
+--- a/inference-engine/src/vpu/common/CMakeLists.txt
++++ b/inference-engine/src/vpu/common/CMakeLists.txt
+@@ -5,7 +5,7 @@
+ file(GLOB_RECURSE SOURCES *.cpp *.hpp *.h)
+ 
+ function(add_common_target TARGET_NAME STATIC_IE)
+-    add_library(${TARGET_NAME} STATIC ${SOURCES})
++    add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+     ie_faster_build(${TARGET_NAME}
+         UNITY
+@@ -62,7 +62,7 @@ add_common_target("vpu_common_lib" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_common_target("vpu_common_lib_test_static" TRUE)
++    #add_common_target("vpu_common_lib_test_static" TRUE)
+ else()
+     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
+ endif()
+diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+index 97bd4caa9..0f49ed144 100644
+--- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
++++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+@@ -5,7 +5,7 @@
+ file(GLOB_RECURSE SOURCES *.cpp *.hpp *.h *.inc)
+ 
+ function(add_graph_transformer_target TARGET_NAME STATIC_IE)
+-    add_library(${TARGET_NAME} STATIC ${SOURCES})
++    add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+     set_ie_threading_interface_for(${TARGET_NAME})
+ 
+@@ -63,7 +63,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
++    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
+ else()
+     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
+ endif()
+diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+index 8bcb2801a..5a17fa3f7 100644
+--- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
++++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
+ else()
+ 	add_library(pugixml STATIC ${SOURCES})
+ 	if (MSVC)
+-		add_library(pugixml_mt STATIC ${SOURCES})
++                #add_library(pugixml_mt STATIC ${SOURCES})
+ 		#if (WIN32)
+ 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+diff --git a/ngraph/core/builder/CMakeLists.txt b/ngraph/core/builder/CMakeLists.txt
+index 13b31ee17..be613b65f 100644
+--- a/ngraph/core/builder/CMakeLists.txt
++++ b/ngraph/core/builder/CMakeLists.txt
+@@ -28,7 +28,7 @@ source_group("src" FILES ${LIBRARY_SRC})
+ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create shared library
+-add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${LIBRARY_SRC} ${PUBLIC_HEADERS})
+ 
+ if(COMMAND ie_faster_build)
+     ie_faster_build(${TARGET_NAME}
+diff --git a/ngraph/core/reference/CMakeLists.txt b/ngraph/core/reference/CMakeLists.txt
+index 62749a650..dc857f853 100644
+--- a/ngraph/core/reference/CMakeLists.txt
++++ b/ngraph/core/reference/CMakeLists.txt
+@@ -28,7 +28,7 @@ source_group("src" FILES ${LIBRARY_SRC})
+ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create shared library
+-add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${LIBRARY_SRC} ${PUBLIC_HEADERS})
+ 
+ if(COMMAND ie_faster_build)
+     ie_faster_build(${TARGET_NAME}
+diff --git a/openvino/itt/CMakeLists.txt b/openvino/itt/CMakeLists.txt
+index 648ac0a05..4291740d7 100644
+--- a/openvino/itt/CMakeLists.txt
++++ b/openvino/itt/CMakeLists.txt
+@@ -18,7 +18,7 @@ set(TARGET_NAME itt)
+ 
+ file(GLOB_RECURSE SOURCES "src/*.cpp" "src/*.hpp")
+ 
+-add_library(${TARGET_NAME} STATIC ${SOURCES})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+ add_library(openvino::itt ALIAS ${TARGET_NAME})
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20210324-dldt-pdb.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20210324-dldt-pdb.patch
new file mode 100644
index 00000000..87de5ae6
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20210324-dldt-pdb.patch
@@ -0,0 +1,15 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 1f981ed2..90eb500a 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -22,6 +22,10 @@ endif()
+ 
+ project(OpenVINO)
+ 
++set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi /FS")
++set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++
+ set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ set(IE_MAIN_SOURCE_DIR ${OpenVINO_MAIN_SOURCE_DIR}/inference-engine)
+ list(APPEND CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20210324-dldt-vs-version.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20210324-dldt-vs-version.patch
new file mode 100644
index 00000000..989e2d0a
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/20210324-dldt-vs-version.patch
@@ -0,0 +1,16 @@
+diff --git a/cmake/developer_package/vs_version/vs_version.cmake b/cmake/developer_package/vs_version/vs_version.cmake
+index d857e2e4..453903fd 100644
+--- a/cmake/developer_package/vs_version/vs_version.cmake
++++ b/cmake/developer_package/vs_version/vs_version.cmake
+@@ -22,9 +22,9 @@ if(IE_VS_VER_HAS_VERSION)
+ endif()
+ 
+ set(IE_VS_VER_PRODUCTVERSION_STR "${CI_BUILD_NUMBER}")
+-set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit")
++set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit (for OpenCV Windows package)")
+ set(IE_VS_VER_COPYRIGHT_STR "Copyright (C) 2018-2020, Intel Corporation")
+-set(IE_VS_VER_COMMENTS_STR "https://docs.openvinotoolkit.org/")
++set(IE_VS_VER_COMMENTS_STR "https://github.com/opencv/opencv/wiki/Intel%27s-Deep-Learning-Inference-Engine-backend")
+ 
+ #
+ # ie_add_vs_version_file(NAME <name>
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/build.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/build.config.py
new file mode 100644
index 00000000..bfaaea8d
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/build.config.py
@@ -0,0 +1,3 @@
+os.environ['CI_BUILD_NUMBER'] = '2021.3.0-opencv_winpack_dldt'
+
+cmake_vars['ENABLE_V10_SERIALIZE'] = 'ON'
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/patch.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/patch.config.py
new file mode 100644
index 00000000..341f7a83
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/patch.config.py
@@ -0,0 +1,4 @@
+applyPatch('20210324-dldt-disable-unused-targets.patch')
+applyPatch('20210324-dldt-pdb.patch')
+applyPatch('20200604-dldt-disable-multidevice.patch')
+applyPatch('20210324-dldt-vs-version.patch')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/sysroot.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/sysroot.config.py
new file mode 100644
index 00000000..0e1ec8ec
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.3/sysroot.config.py
@@ -0,0 +1,55 @@
+sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
+copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
+#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
+
+build_config = 'Release' if not self.config.build_debug else 'Debug'
+build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
+
+def copy_bin(name):
+    global build_bin_dir, sysroot_bin_dir
+    copytree(build_bin_dir / name, sysroot_bin_dir / name)
+
+dll_suffix = 'd' if self.config.build_debug else ''
+def copy_dll(name):
+    global copy_bin, dll_suffix
+    copy_bin(name + dll_suffix + '.dll')
+    copy_bin(name + dll_suffix + '.pdb')
+
+copy_bin('cache.json')
+copy_dll('clDNNPlugin')
+copy_dll('HeteroPlugin')
+copy_dll('inference_engine')
+copy_dll('inference_engine_ir_reader')
+copy_dll('inference_engine_ir_v7_reader')
+copy_dll('inference_engine_legacy')
+copy_dll('inference_engine_transformations')  # runtime
+copy_dll('inference_engine_lp_transformations')  # runtime
+copy_dll('MKLDNNPlugin')  # runtime
+copy_dll('myriadPlugin')  # runtime
+#copy_dll('MultiDevicePlugin')  # runtime, not used
+copy_dll('ngraph')
+copy_bin('plugins.xml')
+copy_bin('pcie-ma2x8x.elf')
+copy_bin('usb-ma2x8x.mvcmd')
+
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
+
+sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
+sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
+
+copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
+if not self.config.build_debug:
+    copytree(build_bin_dir / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
+    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_reader.lib', sysroot_ie_lib_dir / 'inference_engine_ir_reader.lib')
+    copytree(build_bin_dir / 'inference_engine_legacy.lib', sysroot_ie_lib_dir / 'inference_engine_legacy.lib')
+else:
+    copytree(build_bin_dir / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
+    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_readerd.lib', sysroot_ie_lib_dir / 'inference_engine_ir_readerd.lib')
+    copytree(build_bin_dir / 'inference_engine_legacyd.lib', sysroot_ie_lib_dir / 'inference_engine_legacyd.lib')
+
+sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
+copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
+copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-disable-multidevice-autoplugin.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-disable-multidevice-autoplugin.patch
new file mode 100644
index 00000000..f1e74874
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-disable-multidevice-autoplugin.patch
@@ -0,0 +1,16 @@
+diff --git a/inference-engine/src/CMakeLists.txt b/inference-engine/src/CMakeLists.txt
+index 0ba0dd78..7d34e7cb 100644
+--- a/inference-engine/src/CMakeLists.txt
++++ b/inference-engine/src/CMakeLists.txt
+@@ -26,9 +26,9 @@ endif()
+ 
+ add_subdirectory(hetero_plugin)
+ 
+-add_subdirectory(auto_plugin)
++#add_subdirectory(auto_plugin)
+ 
+-add_subdirectory(multi_device)
++#add_subdirectory(multi_device)
+ 
+ add_subdirectory(transformations)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-disable-unused-targets.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-disable-unused-targets.patch
new file mode 100644
index 00000000..9d44cdad
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-disable-unused-targets.patch
@@ -0,0 +1,219 @@
+diff --git a/cmake/developer_package/add_ie_target.cmake b/cmake/developer_package/add_ie_target.cmake
+index d49f16a4d..2726ca787 100644
+--- a/cmake/developer_package/add_ie_target.cmake
++++ b/cmake/developer_package/add_ie_target.cmake
+@@ -92,7 +92,7 @@ function(addIeTarget)
+     if (ARG_TYPE STREQUAL EXECUTABLE)
+         add_executable(${ARG_NAME} ${all_sources})
+     elseif(ARG_TYPE STREQUAL STATIC OR ARG_TYPE STREQUAL SHARED)
+-        add_library(${ARG_NAME} ${ARG_TYPE} ${all_sources})
++        add_library(${ARG_NAME} ${ARG_TYPE} EXCLUDE_FROM_ALL ${all_sources})
+     else()
+         message(SEND_ERROR "Invalid target type ${ARG_TYPE} specified for target name ${ARG_NAME}")
+     endif()
+diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
+index 1ac7fd8bf..df7091e51 100644
+--- a/inference-engine/CMakeLists.txt
++++ b/inference-engine/CMakeLists.txt
+@@ -39,7 +39,7 @@ if(ENABLE_TESTS)
+     add_subdirectory(tests)
+ endif()
+ 
+-add_subdirectory(tools)
++#add_subdirectory(tools)
+ 
+ function(ie_build_samples)
+     # samples should be build with the same flags as from OpenVINO package,
+@@ -58,7 +58,7 @@ endfunction()
+ 
+ # gflags and format_reader targets are kept inside of samples directory and
+ # they must be built even if samples build is disabled (required for tests and tools).
+-ie_build_samples()
++#ie_build_samples()
+ 
+ if(ENABLE_PYTHON)
+     add_subdirectory(ie_bridges/python)
+@@ -142,7 +142,7 @@ endif()
+ # Developer package
+ #
+ 
+-openvino_developer_export_targets(COMPONENT openvino_common TARGETS format_reader gflags ie_samples_utils)
++#openvino_developer_export_targets(COMPONENT openvino_common TARGETS format_reader gflags ie_samples_utils)
+ 
+ # for Template plugin
+ if(NGRAPH_INTERPRETER_ENABLE)
+@@ -166,7 +166,7 @@ function(ie_generate_dev_package_config)
+                 @ONLY)
+ endfunction()
+ 
+-ie_generate_dev_package_config()
++#ie_generate_dev_package_config()
+ 
+ #
+ # Coverage
+diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
+index e8ed1a5c4..1fc9fc3ff 100644
+--- a/inference-engine/src/inference_engine/CMakeLists.txt
++++ b/inference-engine/src/inference_engine/CMakeLists.txt
+@@ -110,7 +110,7 @@ add_cpplint_target(${TARGET_NAME}_plugin_api_cpplint FOR_SOURCES ${plugin_api_sr
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS}
+             ${PUBLIC_HEADERS})
+@@ -181,7 +181,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_legacy_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
+             ${IE_STATIC_DEPENDENT_FILES})
+diff --git a/inference-engine/src/legacy_api/CMakeLists.txt b/inference-engine/src/legacy_api/CMakeLists.txt
+index 8eae82bd2..e0e6745b1 100644
+--- a/inference-engine/src/legacy_api/CMakeLists.txt
++++ b/inference-engine/src/legacy_api/CMakeLists.txt
+@@ -26,7 +26,7 @@ endif()
+ 
+ file(TOUCH ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp)
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${PUBLIC_HEADERS})
+ 
+diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+index fe57b29dd..07831e2fb 100644
+--- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
++++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+@@ -67,7 +67,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ #  add test object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
+ target_link_libraries(${TARGET_NAME}_obj PUBLIC mkldnn)
+ 
+ target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>
+diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
+index f9548339d..ef962145a 100644
+--- a/inference-engine/src/preprocessing/CMakeLists.txt
++++ b/inference-engine/src/preprocessing/CMakeLists.txt
+@@ -101,7 +101,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS})
+ 
+@@ -153,7 +153,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
+ 
+ set_ie_threading_interface_for(${TARGET_NAME}_s)
+diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
+index 249e47c28..4ddf63049 100644
+--- a/inference-engine/src/vpu/common/CMakeLists.txt
++++ b/inference-engine/src/vpu/common/CMakeLists.txt
+@@ -5,7 +5,7 @@
+ file(GLOB_RECURSE SOURCES *.cpp *.hpp *.h)
+ 
+ function(add_common_target TARGET_NAME STATIC_IE)
+-    add_library(${TARGET_NAME} STATIC ${SOURCES})
++    add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+     ie_faster_build(${TARGET_NAME}
+         UNITY
+@@ -60,7 +60,7 @@ add_common_target("vpu_common_lib" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_common_target("vpu_common_lib_test_static" TRUE)
++    #add_common_target("vpu_common_lib_test_static" TRUE)
+ else()
+     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
+ endif()
+diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+index bc73ab5b1..b4c1547fc 100644
+--- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
++++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+@@ -5,7 +5,7 @@
+ file(GLOB_RECURSE SOURCES *.cpp *.hpp *.h *.inc)
+ 
+ function(add_graph_transformer_target TARGET_NAME STATIC_IE)
+-    add_library(${TARGET_NAME} STATIC ${SOURCES})
++    add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+     set_ie_threading_interface_for(${TARGET_NAME})
+ 
+@@ -70,7 +70,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
++    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
+ else()
+     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
+ endif()
+diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+index 8bcb2801a..f7e031c01 100644
+--- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
++++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
+ else()
+ 	add_library(pugixml STATIC ${SOURCES})
+ 	if (MSVC)
+-		add_library(pugixml_mt STATIC ${SOURCES})
++                #add_library(pugixml_mt STATIC ${SOURCES})
+ 		#if (WIN32)
+ 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+diff --git a/ngraph/core/builder/CMakeLists.txt b/ngraph/core/builder/CMakeLists.txt
+index ff5c381e7..2797ec9ab 100644
+--- a/ngraph/core/builder/CMakeLists.txt
++++ b/ngraph/core/builder/CMakeLists.txt
+@@ -16,7 +16,7 @@ source_group("src" FILES ${LIBRARY_SRC})
+ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create shared library
+-add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${LIBRARY_SRC} ${PUBLIC_HEADERS})
+ 
+ if(COMMAND ie_faster_build)
+     ie_faster_build(${TARGET_NAME}
+diff --git a/ngraph/core/reference/CMakeLists.txt b/ngraph/core/reference/CMakeLists.txt
+index ef4a764ab..f6d3172e2 100644
+--- a/ngraph/core/reference/CMakeLists.txt
++++ b/ngraph/core/reference/CMakeLists.txt
+@@ -16,7 +16,7 @@ source_group("src" FILES ${LIBRARY_SRC})
+ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create shared library
+-add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${LIBRARY_SRC} ${PUBLIC_HEADERS})
+ 
+ if(COMMAND ie_faster_build)
+     ie_faster_build(${TARGET_NAME}
+diff --git a/openvino/itt/CMakeLists.txt b/openvino/itt/CMakeLists.txt
+index e9f880b8c..c63f4df63 100644
+--- a/openvino/itt/CMakeLists.txt
++++ b/openvino/itt/CMakeLists.txt
+@@ -6,7 +6,7 @@ set(TARGET_NAME itt)
+ 
+ file(GLOB_RECURSE SOURCES "src/*.cpp" "src/*.hpp")
+ 
+-add_library(${TARGET_NAME} STATIC ${SOURCES})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+ add_library(openvino::itt ALIAS ${TARGET_NAME})
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-pdb.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-pdb.patch
new file mode 100644
index 00000000..65e6f84d
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-pdb.patch
@@ -0,0 +1,15 @@
+iff --git a/CMakeLists.txt b/CMakeLists.txt
+index e0706a72e..9a053b1e4 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -6,6 +6,10 @@ cmake_minimum_required(VERSION 3.13)
+ 
+ project(OpenVINO)
+ 
++set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi /FS")
++set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++
+ set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ set(IE_MAIN_SOURCE_DIR ${OpenVINO_MAIN_SOURCE_DIR}/inference-engine)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-vs-version.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-vs-version.patch
new file mode 100644
index 00000000..36b00687
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/20210630-dldt-vs-version.patch
@@ -0,0 +1,16 @@
+diff --git a/cmake/developer_package/vs_version/vs_version.cmake b/cmake/developer_package/vs_version/vs_version.cmake
+index 14d4c0e1e..6a44f73b9 100644
+--- a/cmake/developer_package/vs_version/vs_version.cmake
++++ b/cmake/developer_package/vs_version/vs_version.cmake
+@@ -8,9 +8,9 @@ set(IE_VS_VER_FILEVERSION_STR "${IE_VERSION_MAJOR}.${IE_VERSION_MINOR}.${IE_VERS
+ 
+ set(IE_VS_VER_COMPANY_NAME_STR "Intel Corporation")
+ set(IE_VS_VER_PRODUCTVERSION_STR "${CI_BUILD_NUMBER}")
+-set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit")
++set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit (for OpenCV Windows package)")
+ set(IE_VS_VER_COPYRIGHT_STR "Copyright (C) 2018-2021, Intel Corporation")
+-set(IE_VS_VER_COMMENTS_STR "https://docs.openvinotoolkit.org/")
++set(IE_VS_VER_COMMENTS_STR "https://github.com/opencv/opencv/wiki/Intel%27s-Deep-Learning-Inference-Engine-backend")
+ 
+ #
+ # ie_add_vs_version_file(NAME <name>
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/build.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/build.config.py
new file mode 100644
index 00000000..a643c179
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/build.config.py
@@ -0,0 +1 @@
+os.environ['CI_BUILD_NUMBER'] = '2021.4.1-opencv_winpack_dldt'
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/patch.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/patch.config.py
new file mode 100644
index 00000000..7f8715aa
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/patch.config.py
@@ -0,0 +1,4 @@
+applyPatch('20210630-dldt-disable-unused-targets.patch')
+applyPatch('20210630-dldt-pdb.patch')
+applyPatch('20210630-dldt-disable-multidevice-autoplugin.patch')
+applyPatch('20210630-dldt-vs-version.patch')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/sysroot.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/sysroot.config.py
new file mode 100644
index 00000000..fa428110
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.1/sysroot.config.py
@@ -0,0 +1,56 @@
+sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
+copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
+#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
+
+build_config = 'Release' if not self.config.build_debug else 'Debug'
+build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
+
+def copy_bin(name):
+    global build_bin_dir, sysroot_bin_dir
+    copytree(build_bin_dir / name, sysroot_bin_dir / name)
+
+dll_suffix = 'd' if self.config.build_debug else ''
+def copy_dll(name):
+    global copy_bin, dll_suffix
+    copy_bin(name + dll_suffix + '.dll')
+    copy_bin(name + dll_suffix + '.pdb')
+
+copy_bin('cache.json')
+copy_dll('clDNNPlugin')
+copy_dll('HeteroPlugin')
+copy_dll('inference_engine')
+copy_dll('inference_engine_ir_reader')
+#copy_dll('inference_engine_ir_v7_reader')
+copy_dll('inference_engine_legacy')
+copy_dll('inference_engine_transformations')  # runtime
+copy_dll('inference_engine_lp_transformations')  # runtime
+#copy_dll('inference_engine_preproc')  # runtime
+copy_dll('MKLDNNPlugin')  # runtime
+copy_dll('myriadPlugin')  # runtime
+#copy_dll('MultiDevicePlugin')  # runtime, not used
+copy_dll('ngraph')
+copy_bin('plugins.xml')
+copy_bin('pcie-ma2x8x.elf')
+copy_bin('usb-ma2x8x.mvcmd')
+
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
+
+sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
+sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
+
+copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
+if not self.config.build_debug:
+    copytree(build_bin_dir / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
+    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_reader.lib', sysroot_ie_lib_dir / 'inference_engine_ir_reader.lib')
+    copytree(build_bin_dir / 'inference_engine_legacy.lib', sysroot_ie_lib_dir / 'inference_engine_legacy.lib')
+else:
+    copytree(build_bin_dir / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
+    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_readerd.lib', sysroot_ie_lib_dir / 'inference_engine_ir_readerd.lib')
+    copytree(build_bin_dir / 'inference_engine_legacyd.lib', sysroot_ie_lib_dir / 'inference_engine_legacyd.lib')
+
+sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
+copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
+copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-disable-multidevice-autoplugin.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-disable-multidevice-autoplugin.patch
new file mode 100644
index 00000000..f1e74874
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-disable-multidevice-autoplugin.patch
@@ -0,0 +1,16 @@
+diff --git a/inference-engine/src/CMakeLists.txt b/inference-engine/src/CMakeLists.txt
+index 0ba0dd78..7d34e7cb 100644
+--- a/inference-engine/src/CMakeLists.txt
++++ b/inference-engine/src/CMakeLists.txt
+@@ -26,9 +26,9 @@ endif()
+ 
+ add_subdirectory(hetero_plugin)
+ 
+-add_subdirectory(auto_plugin)
++#add_subdirectory(auto_plugin)
+ 
+-add_subdirectory(multi_device)
++#add_subdirectory(multi_device)
+ 
+ add_subdirectory(transformations)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-disable-unused-targets.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-disable-unused-targets.patch
new file mode 100644
index 00000000..9d44cdad
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-disable-unused-targets.patch
@@ -0,0 +1,219 @@
+diff --git a/cmake/developer_package/add_ie_target.cmake b/cmake/developer_package/add_ie_target.cmake
+index d49f16a4d..2726ca787 100644
+--- a/cmake/developer_package/add_ie_target.cmake
++++ b/cmake/developer_package/add_ie_target.cmake
+@@ -92,7 +92,7 @@ function(addIeTarget)
+     if (ARG_TYPE STREQUAL EXECUTABLE)
+         add_executable(${ARG_NAME} ${all_sources})
+     elseif(ARG_TYPE STREQUAL STATIC OR ARG_TYPE STREQUAL SHARED)
+-        add_library(${ARG_NAME} ${ARG_TYPE} ${all_sources})
++        add_library(${ARG_NAME} ${ARG_TYPE} EXCLUDE_FROM_ALL ${all_sources})
+     else()
+         message(SEND_ERROR "Invalid target type ${ARG_TYPE} specified for target name ${ARG_NAME}")
+     endif()
+diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
+index 1ac7fd8bf..df7091e51 100644
+--- a/inference-engine/CMakeLists.txt
++++ b/inference-engine/CMakeLists.txt
+@@ -39,7 +39,7 @@ if(ENABLE_TESTS)
+     add_subdirectory(tests)
+ endif()
+ 
+-add_subdirectory(tools)
++#add_subdirectory(tools)
+ 
+ function(ie_build_samples)
+     # samples should be build with the same flags as from OpenVINO package,
+@@ -58,7 +58,7 @@ endfunction()
+ 
+ # gflags and format_reader targets are kept inside of samples directory and
+ # they must be built even if samples build is disabled (required for tests and tools).
+-ie_build_samples()
++#ie_build_samples()
+ 
+ if(ENABLE_PYTHON)
+     add_subdirectory(ie_bridges/python)
+@@ -142,7 +142,7 @@ endif()
+ # Developer package
+ #
+ 
+-openvino_developer_export_targets(COMPONENT openvino_common TARGETS format_reader gflags ie_samples_utils)
++#openvino_developer_export_targets(COMPONENT openvino_common TARGETS format_reader gflags ie_samples_utils)
+ 
+ # for Template plugin
+ if(NGRAPH_INTERPRETER_ENABLE)
+@@ -166,7 +166,7 @@ function(ie_generate_dev_package_config)
+                 @ONLY)
+ endfunction()
+ 
+-ie_generate_dev_package_config()
++#ie_generate_dev_package_config()
+ 
+ #
+ # Coverage
+diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
+index e8ed1a5c4..1fc9fc3ff 100644
+--- a/inference-engine/src/inference_engine/CMakeLists.txt
++++ b/inference-engine/src/inference_engine/CMakeLists.txt
+@@ -110,7 +110,7 @@ add_cpplint_target(${TARGET_NAME}_plugin_api_cpplint FOR_SOURCES ${plugin_api_sr
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS}
+             ${PUBLIC_HEADERS})
+@@ -181,7 +181,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_legacy_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
+             ${IE_STATIC_DEPENDENT_FILES})
+diff --git a/inference-engine/src/legacy_api/CMakeLists.txt b/inference-engine/src/legacy_api/CMakeLists.txt
+index 8eae82bd2..e0e6745b1 100644
+--- a/inference-engine/src/legacy_api/CMakeLists.txt
++++ b/inference-engine/src/legacy_api/CMakeLists.txt
+@@ -26,7 +26,7 @@ endif()
+ 
+ file(TOUCH ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp)
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${PUBLIC_HEADERS})
+ 
+diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+index fe57b29dd..07831e2fb 100644
+--- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
++++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+@@ -67,7 +67,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ #  add test object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
+ target_link_libraries(${TARGET_NAME}_obj PUBLIC mkldnn)
+ 
+ target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>
+diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
+index f9548339d..ef962145a 100644
+--- a/inference-engine/src/preprocessing/CMakeLists.txt
++++ b/inference-engine/src/preprocessing/CMakeLists.txt
+@@ -101,7 +101,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS})
+ 
+@@ -153,7 +153,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
+ 
+ set_ie_threading_interface_for(${TARGET_NAME}_s)
+diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
+index 249e47c28..4ddf63049 100644
+--- a/inference-engine/src/vpu/common/CMakeLists.txt
++++ b/inference-engine/src/vpu/common/CMakeLists.txt
+@@ -5,7 +5,7 @@
+ file(GLOB_RECURSE SOURCES *.cpp *.hpp *.h)
+ 
+ function(add_common_target TARGET_NAME STATIC_IE)
+-    add_library(${TARGET_NAME} STATIC ${SOURCES})
++    add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+     ie_faster_build(${TARGET_NAME}
+         UNITY
+@@ -60,7 +60,7 @@ add_common_target("vpu_common_lib" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_common_target("vpu_common_lib_test_static" TRUE)
++    #add_common_target("vpu_common_lib_test_static" TRUE)
+ else()
+     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
+ endif()
+diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+index bc73ab5b1..b4c1547fc 100644
+--- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
++++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+@@ -5,7 +5,7 @@
+ file(GLOB_RECURSE SOURCES *.cpp *.hpp *.h *.inc)
+ 
+ function(add_graph_transformer_target TARGET_NAME STATIC_IE)
+-    add_library(${TARGET_NAME} STATIC ${SOURCES})
++    add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+     set_ie_threading_interface_for(${TARGET_NAME})
+ 
+@@ -70,7 +70,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
++    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
+ else()
+     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
+ endif()
+diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+index 8bcb2801a..f7e031c01 100644
+--- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
++++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
+ else()
+ 	add_library(pugixml STATIC ${SOURCES})
+ 	if (MSVC)
+-		add_library(pugixml_mt STATIC ${SOURCES})
++                #add_library(pugixml_mt STATIC ${SOURCES})
+ 		#if (WIN32)
+ 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+diff --git a/ngraph/core/builder/CMakeLists.txt b/ngraph/core/builder/CMakeLists.txt
+index ff5c381e7..2797ec9ab 100644
+--- a/ngraph/core/builder/CMakeLists.txt
++++ b/ngraph/core/builder/CMakeLists.txt
+@@ -16,7 +16,7 @@ source_group("src" FILES ${LIBRARY_SRC})
+ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create shared library
+-add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${LIBRARY_SRC} ${PUBLIC_HEADERS})
+ 
+ if(COMMAND ie_faster_build)
+     ie_faster_build(${TARGET_NAME}
+diff --git a/ngraph/core/reference/CMakeLists.txt b/ngraph/core/reference/CMakeLists.txt
+index ef4a764ab..f6d3172e2 100644
+--- a/ngraph/core/reference/CMakeLists.txt
++++ b/ngraph/core/reference/CMakeLists.txt
+@@ -16,7 +16,7 @@ source_group("src" FILES ${LIBRARY_SRC})
+ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create shared library
+-add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${LIBRARY_SRC} ${PUBLIC_HEADERS})
+ 
+ if(COMMAND ie_faster_build)
+     ie_faster_build(${TARGET_NAME}
+diff --git a/openvino/itt/CMakeLists.txt b/openvino/itt/CMakeLists.txt
+index e9f880b8c..c63f4df63 100644
+--- a/openvino/itt/CMakeLists.txt
++++ b/openvino/itt/CMakeLists.txt
+@@ -6,7 +6,7 @@ set(TARGET_NAME itt)
+ 
+ file(GLOB_RECURSE SOURCES "src/*.cpp" "src/*.hpp")
+ 
+-add_library(${TARGET_NAME} STATIC ${SOURCES})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+ add_library(openvino::itt ALIAS ${TARGET_NAME})
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-pdb.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-pdb.patch
new file mode 100644
index 00000000..65e6f84d
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-pdb.patch
@@ -0,0 +1,15 @@
+iff --git a/CMakeLists.txt b/CMakeLists.txt
+index e0706a72e..9a053b1e4 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -6,6 +6,10 @@ cmake_minimum_required(VERSION 3.13)
+ 
+ project(OpenVINO)
+ 
++set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi /FS")
++set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++
+ set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ set(IE_MAIN_SOURCE_DIR ${OpenVINO_MAIN_SOURCE_DIR}/inference-engine)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-vs-version.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-vs-version.patch
new file mode 100644
index 00000000..36b00687
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20210630-dldt-vs-version.patch
@@ -0,0 +1,16 @@
+diff --git a/cmake/developer_package/vs_version/vs_version.cmake b/cmake/developer_package/vs_version/vs_version.cmake
+index 14d4c0e1e..6a44f73b9 100644
+--- a/cmake/developer_package/vs_version/vs_version.cmake
++++ b/cmake/developer_package/vs_version/vs_version.cmake
+@@ -8,9 +8,9 @@ set(IE_VS_VER_FILEVERSION_STR "${IE_VERSION_MAJOR}.${IE_VERSION_MINOR}.${IE_VERS
+ 
+ set(IE_VS_VER_COMPANY_NAME_STR "Intel Corporation")
+ set(IE_VS_VER_PRODUCTVERSION_STR "${CI_BUILD_NUMBER}")
+-set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit")
++set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit (for OpenCV Windows package)")
+ set(IE_VS_VER_COPYRIGHT_STR "Copyright (C) 2018-2021, Intel Corporation")
+-set(IE_VS_VER_COMMENTS_STR "https://docs.openvinotoolkit.org/")
++set(IE_VS_VER_COMMENTS_STR "https://github.com/opencv/opencv/wiki/Intel%27s-Deep-Learning-Inference-Engine-backend")
+ 
+ #
+ # ie_add_vs_version_file(NAME <name>
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20220118-dldt-fix-msvs-compilation-21469.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20220118-dldt-fix-msvs-compilation-21469.patch
new file mode 100644
index 00000000..411d5cbd
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/20220118-dldt-fix-msvs-compilation-21469.patch
@@ -0,0 +1,12 @@
+diff --git a/inference-engine/src/plugin_api/caseless.hpp b/inference-engine/src/plugin_api/caseless.hpp
+index d8ce739..0dd8886 100644
+--- a/inference-engine/src/plugin_api/caseless.hpp
++++ b/inference-engine/src/plugin_api/caseless.hpp
+@@ -12,6 +12,7 @@
+ #include <algorithm>
+ #include <cctype>
+ #include <functional>
++#include <iterator>
+ #include <map>
+ #include <set>
+ #include <unordered_map>
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/build.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/build.config.py
new file mode 100644
index 00000000..708dcddd
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/build.config.py
@@ -0,0 +1 @@
+os.environ['CI_BUILD_NUMBER'] = '2021.4.2-opencv_winpack_dldt'
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/cmake/InferenceEngineConfig-version.cmake b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/cmake/InferenceEngineConfig-version.cmake
new file mode 100644
index 00000000..bc449d05
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/cmake/InferenceEngineConfig-version.cmake
@@ -0,0 +1,29 @@
+# Copyright (C) 2018-2021 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+set(PACKAGE_VERSION_MAJOR 2021)
+set(PACKAGE_VERSION_MINOR 4)
+set(PACKAGE_VERSION_PATCH 2)
+set(PACKAGE_VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE_VERSION_PATCH}")
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+# Compatibility with old versioning for 2.x
+if(PACKAGE_FIND_VERSION_MAJOR VERSION_EQUAL 2)
+    set(PACKAGE_VERSION_COMPATIBLE True)
+    if(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED)
+        message(WARNING "Inference Engine versioning has changed. Use ${PACKAGE_VERSION} instead of ${PACKAGE_FIND_VERSION}")
+    endif()
+endif()
+
+if(PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+    set(PACKAGE_VERSION_EXACT True)
+    set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if(PACKAGE_FIND_VERSION_MAJOR EQUAL PACKAGE_VERSION_MAJOR AND
+   PACKAGE_FIND_VERSION VERSION_LESS PACKAGE_VERSION)
+    set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/cmake/InferenceEngineConfig.cmake b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/cmake/InferenceEngineConfig.cmake
new file mode 100644
index 00000000..d9c9a12d
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/cmake/InferenceEngineConfig.cmake
@@ -0,0 +1,31 @@
+# Inference Engine CMake config for OpenCV windows package
+
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+
+set(InferenceEngine_LIBRARIES IE::inference_engine)
+add_library(IE::inference_engine SHARED IMPORTED)
+
+set_target_properties(IE::inference_engine PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/deployment_tools/inference_engine/include"
+)
+
+# Import target "IE::inference_engine" for configuration "Debug"
+set_property(TARGET IE::inference_engine APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+set_target_properties(IE::inference_engine PROPERTIES
+  IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/deployment_tools/inference_engine/lib/intel64/inference_engined.lib"
+  IMPORTED_LINK_DEPENDENT_LIBRARIES_DEBUG ""
+  IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/inference_engined.dll"
+  )
+
+# Import target "IE::inference_engine" for configuration "Release"
+set_property(TARGET IE::inference_engine APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(IE::inference_engine PROPERTIES
+  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/deployment_tools/inference_engine/lib/intel64/inference_engine.lib"
+  IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE ""
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/inference_engine.dll"
+  )
+
+set(InferenceEngine_FOUND ON)
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/patch.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/patch.config.py
new file mode 100644
index 00000000..bd31af23
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/patch.config.py
@@ -0,0 +1,5 @@
+applyPatch('20210630-dldt-disable-unused-targets.patch')
+applyPatch('20210630-dldt-pdb.patch')
+applyPatch('20210630-dldt-disable-multidevice-autoplugin.patch')
+applyPatch('20210630-dldt-vs-version.patch')
+applyPatch('20220118-dldt-fix-msvs-compilation-21469.patch')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/sysroot.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/sysroot.config.py
new file mode 100644
index 00000000..f11e99f8
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4.2/sysroot.config.py
@@ -0,0 +1,58 @@
+copytree(self.cpath / 'cmake', self.sysrootdir / 'deployment_tools' / 'inference_engine' / 'cmake')
+
+sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
+copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
+#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
+
+build_config = 'Release' if not self.config.build_debug else 'Debug'
+build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
+
+def copy_bin(name):
+    global build_bin_dir, sysroot_bin_dir
+    copytree(build_bin_dir / name, sysroot_bin_dir / name)
+
+dll_suffix = 'd' if self.config.build_debug else ''
+def copy_dll(name):
+    global copy_bin, dll_suffix
+    copy_bin(name + dll_suffix + '.dll')
+    copy_bin(name + dll_suffix + '.pdb')
+
+copy_bin('cache.json')
+copy_dll('clDNNPlugin')
+copy_dll('HeteroPlugin')
+copy_dll('inference_engine')
+copy_dll('inference_engine_ir_reader')
+#copy_dll('inference_engine_ir_v7_reader')
+copy_dll('inference_engine_legacy')
+copy_dll('inference_engine_transformations')  # runtime
+copy_dll('inference_engine_lp_transformations')  # runtime
+#copy_dll('inference_engine_preproc')  # runtime
+copy_dll('MKLDNNPlugin')  # runtime
+copy_dll('myriadPlugin')  # runtime
+#copy_dll('MultiDevicePlugin')  # runtime, not used
+copy_dll('ngraph')
+copy_bin('plugins.xml')
+copy_bin('pcie-ma2x8x.elf')
+copy_bin('usb-ma2x8x.mvcmd')
+
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
+
+sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
+sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
+
+copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
+if not self.config.build_debug:
+    copytree(build_bin_dir / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
+    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_reader.lib', sysroot_ie_lib_dir / 'inference_engine_ir_reader.lib')
+    copytree(build_bin_dir / 'inference_engine_legacy.lib', sysroot_ie_lib_dir / 'inference_engine_legacy.lib')
+else:
+    copytree(build_bin_dir / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
+    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_readerd.lib', sysroot_ie_lib_dir / 'inference_engine_ir_readerd.lib')
+    copytree(build_bin_dir / 'inference_engine_legacyd.lib', sysroot_ie_lib_dir / 'inference_engine_legacyd.lib')
+
+sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
+copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
+copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-disable-multidevice-autoplugin.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-disable-multidevice-autoplugin.patch
new file mode 100644
index 00000000..f1e74874
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-disable-multidevice-autoplugin.patch
@@ -0,0 +1,16 @@
+diff --git a/inference-engine/src/CMakeLists.txt b/inference-engine/src/CMakeLists.txt
+index 0ba0dd78..7d34e7cb 100644
+--- a/inference-engine/src/CMakeLists.txt
++++ b/inference-engine/src/CMakeLists.txt
+@@ -26,9 +26,9 @@ endif()
+ 
+ add_subdirectory(hetero_plugin)
+ 
+-add_subdirectory(auto_plugin)
++#add_subdirectory(auto_plugin)
+ 
+-add_subdirectory(multi_device)
++#add_subdirectory(multi_device)
+ 
+ add_subdirectory(transformations)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-disable-unused-targets.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-disable-unused-targets.patch
new file mode 100644
index 00000000..9d44cdad
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-disable-unused-targets.patch
@@ -0,0 +1,219 @@
+diff --git a/cmake/developer_package/add_ie_target.cmake b/cmake/developer_package/add_ie_target.cmake
+index d49f16a4d..2726ca787 100644
+--- a/cmake/developer_package/add_ie_target.cmake
++++ b/cmake/developer_package/add_ie_target.cmake
+@@ -92,7 +92,7 @@ function(addIeTarget)
+     if (ARG_TYPE STREQUAL EXECUTABLE)
+         add_executable(${ARG_NAME} ${all_sources})
+     elseif(ARG_TYPE STREQUAL STATIC OR ARG_TYPE STREQUAL SHARED)
+-        add_library(${ARG_NAME} ${ARG_TYPE} ${all_sources})
++        add_library(${ARG_NAME} ${ARG_TYPE} EXCLUDE_FROM_ALL ${all_sources})
+     else()
+         message(SEND_ERROR "Invalid target type ${ARG_TYPE} specified for target name ${ARG_NAME}")
+     endif()
+diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
+index 1ac7fd8bf..df7091e51 100644
+--- a/inference-engine/CMakeLists.txt
++++ b/inference-engine/CMakeLists.txt
+@@ -39,7 +39,7 @@ if(ENABLE_TESTS)
+     add_subdirectory(tests)
+ endif()
+ 
+-add_subdirectory(tools)
++#add_subdirectory(tools)
+ 
+ function(ie_build_samples)
+     # samples should be build with the same flags as from OpenVINO package,
+@@ -58,7 +58,7 @@ endfunction()
+ 
+ # gflags and format_reader targets are kept inside of samples directory and
+ # they must be built even if samples build is disabled (required for tests and tools).
+-ie_build_samples()
++#ie_build_samples()
+ 
+ if(ENABLE_PYTHON)
+     add_subdirectory(ie_bridges/python)
+@@ -142,7 +142,7 @@ endif()
+ # Developer package
+ #
+ 
+-openvino_developer_export_targets(COMPONENT openvino_common TARGETS format_reader gflags ie_samples_utils)
++#openvino_developer_export_targets(COMPONENT openvino_common TARGETS format_reader gflags ie_samples_utils)
+ 
+ # for Template plugin
+ if(NGRAPH_INTERPRETER_ENABLE)
+@@ -166,7 +166,7 @@ function(ie_generate_dev_package_config)
+                 @ONLY)
+ endfunction()
+ 
+-ie_generate_dev_package_config()
++#ie_generate_dev_package_config()
+ 
+ #
+ # Coverage
+diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
+index e8ed1a5c4..1fc9fc3ff 100644
+--- a/inference-engine/src/inference_engine/CMakeLists.txt
++++ b/inference-engine/src/inference_engine/CMakeLists.txt
+@@ -110,7 +110,7 @@ add_cpplint_target(${TARGET_NAME}_plugin_api_cpplint FOR_SOURCES ${plugin_api_sr
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS}
+             ${PUBLIC_HEADERS})
+@@ -181,7 +181,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_legacy_obj>
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
+             ${IE_STATIC_DEPENDENT_FILES})
+diff --git a/inference-engine/src/legacy_api/CMakeLists.txt b/inference-engine/src/legacy_api/CMakeLists.txt
+index 8eae82bd2..e0e6745b1 100644
+--- a/inference-engine/src/legacy_api/CMakeLists.txt
++++ b/inference-engine/src/legacy_api/CMakeLists.txt
+@@ -26,7 +26,7 @@ endif()
+ 
+ file(TOUCH ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp)
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${PUBLIC_HEADERS})
+ 
+diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+index fe57b29dd..07831e2fb 100644
+--- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
++++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
+@@ -67,7 +67,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ #  add test object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
+ target_link_libraries(${TARGET_NAME}_obj PUBLIC mkldnn)
+ 
+ target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>
+diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
+index f9548339d..ef962145a 100644
+--- a/inference-engine/src/preprocessing/CMakeLists.txt
++++ b/inference-engine/src/preprocessing/CMakeLists.txt
+@@ -101,7 +101,7 @@ endif()
+ 
+ # Create object library
+ 
+-add_library(${TARGET_NAME}_obj OBJECT
++add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL
+             ${LIBRARY_SRC}
+             ${LIBRARY_HEADERS})
+ 
+@@ -153,7 +153,7 @@ ie_add_api_validator_post_build_step(TARGET ${TARGET_NAME})
+ 
+ # Static library used for unit tests which are always built
+ 
+-add_library(${TARGET_NAME}_s STATIC
++add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
+             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
+ 
+ set_ie_threading_interface_for(${TARGET_NAME}_s)
+diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
+index 249e47c28..4ddf63049 100644
+--- a/inference-engine/src/vpu/common/CMakeLists.txt
++++ b/inference-engine/src/vpu/common/CMakeLists.txt
+@@ -5,7 +5,7 @@
+ file(GLOB_RECURSE SOURCES *.cpp *.hpp *.h)
+ 
+ function(add_common_target TARGET_NAME STATIC_IE)
+-    add_library(${TARGET_NAME} STATIC ${SOURCES})
++    add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+     ie_faster_build(${TARGET_NAME}
+         UNITY
+@@ -60,7 +60,7 @@ add_common_target("vpu_common_lib" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_common_target("vpu_common_lib_test_static" TRUE)
++    #add_common_target("vpu_common_lib_test_static" TRUE)
+ else()
+     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
+ endif()
+diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+index bc73ab5b1..b4c1547fc 100644
+--- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
++++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
+@@ -5,7 +5,7 @@
+ file(GLOB_RECURSE SOURCES *.cpp *.hpp *.h *.inc)
+ 
+ function(add_graph_transformer_target TARGET_NAME STATIC_IE)
+-    add_library(${TARGET_NAME} STATIC ${SOURCES})
++    add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+     set_ie_threading_interface_for(${TARGET_NAME})
+ 
+@@ -70,7 +70,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
+ 
+ # Unit tests support for graph transformer
+ if(WIN32)
+-    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
++    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
+ else()
+     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
+ endif()
+diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+index 8bcb2801a..f7e031c01 100644
+--- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
++++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
+@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
+ else()
+ 	add_library(pugixml STATIC ${SOURCES})
+ 	if (MSVC)
+-		add_library(pugixml_mt STATIC ${SOURCES})
++                #add_library(pugixml_mt STATIC ${SOURCES})
+ 		#if (WIN32)
+ 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+ 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+diff --git a/ngraph/core/builder/CMakeLists.txt b/ngraph/core/builder/CMakeLists.txt
+index ff5c381e7..2797ec9ab 100644
+--- a/ngraph/core/builder/CMakeLists.txt
++++ b/ngraph/core/builder/CMakeLists.txt
+@@ -16,7 +16,7 @@ source_group("src" FILES ${LIBRARY_SRC})
+ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create shared library
+-add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${LIBRARY_SRC} ${PUBLIC_HEADERS})
+ 
+ if(COMMAND ie_faster_build)
+     ie_faster_build(${TARGET_NAME}
+diff --git a/ngraph/core/reference/CMakeLists.txt b/ngraph/core/reference/CMakeLists.txt
+index ef4a764ab..f6d3172e2 100644
+--- a/ngraph/core/reference/CMakeLists.txt
++++ b/ngraph/core/reference/CMakeLists.txt
+@@ -16,7 +16,7 @@ source_group("src" FILES ${LIBRARY_SRC})
+ source_group("include" FILES ${PUBLIC_HEADERS})
+ 
+ # Create shared library
+-add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${LIBRARY_SRC} ${PUBLIC_HEADERS})
+ 
+ if(COMMAND ie_faster_build)
+     ie_faster_build(${TARGET_NAME}
+diff --git a/openvino/itt/CMakeLists.txt b/openvino/itt/CMakeLists.txt
+index e9f880b8c..c63f4df63 100644
+--- a/openvino/itt/CMakeLists.txt
++++ b/openvino/itt/CMakeLists.txt
+@@ -6,7 +6,7 @@ set(TARGET_NAME itt)
+ 
+ file(GLOB_RECURSE SOURCES "src/*.cpp" "src/*.hpp")
+ 
+-add_library(${TARGET_NAME} STATIC ${SOURCES})
++add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
+ 
+ add_library(openvino::itt ALIAS ${TARGET_NAME})
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-pdb.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-pdb.patch
new file mode 100644
index 00000000..65e6f84d
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-pdb.patch
@@ -0,0 +1,15 @@
+iff --git a/CMakeLists.txt b/CMakeLists.txt
+index e0706a72e..9a053b1e4 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -6,6 +6,10 @@ cmake_minimum_required(VERSION 3.13)
+ 
+ project(OpenVINO)
+ 
++set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi /FS")
++set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
++
+ set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ set(IE_MAIN_SOURCE_DIR ${OpenVINO_MAIN_SOURCE_DIR}/inference-engine)
+ 
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-vs-version.patch b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-vs-version.patch
new file mode 100644
index 00000000..36b00687
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/20210630-dldt-vs-version.patch
@@ -0,0 +1,16 @@
+diff --git a/cmake/developer_package/vs_version/vs_version.cmake b/cmake/developer_package/vs_version/vs_version.cmake
+index 14d4c0e1e..6a44f73b9 100644
+--- a/cmake/developer_package/vs_version/vs_version.cmake
++++ b/cmake/developer_package/vs_version/vs_version.cmake
+@@ -8,9 +8,9 @@ set(IE_VS_VER_FILEVERSION_STR "${IE_VERSION_MAJOR}.${IE_VERSION_MINOR}.${IE_VERS
+ 
+ set(IE_VS_VER_COMPANY_NAME_STR "Intel Corporation")
+ set(IE_VS_VER_PRODUCTVERSION_STR "${CI_BUILD_NUMBER}")
+-set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit")
++set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit (for OpenCV Windows package)")
+ set(IE_VS_VER_COPYRIGHT_STR "Copyright (C) 2018-2021, Intel Corporation")
+-set(IE_VS_VER_COMMENTS_STR "https://docs.openvinotoolkit.org/")
++set(IE_VS_VER_COMMENTS_STR "https://github.com/opencv/opencv/wiki/Intel%27s-Deep-Learning-Inference-Engine-backend")
+ 
+ #
+ # ie_add_vs_version_file(NAME <name>
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/build.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/build.config.py
new file mode 100644
index 00000000..33ef1050
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/build.config.py
@@ -0,0 +1 @@
+os.environ['CI_BUILD_NUMBER'] = '2021.4.0-opencv_winpack_dldt'
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/patch.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/patch.config.py
new file mode 100644
index 00000000..7f8715aa
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/patch.config.py
@@ -0,0 +1,4 @@
+applyPatch('20210630-dldt-disable-unused-targets.patch')
+applyPatch('20210630-dldt-pdb.patch')
+applyPatch('20210630-dldt-disable-multidevice-autoplugin.patch')
+applyPatch('20210630-dldt-vs-version.patch')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/sysroot.config.py b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/sysroot.config.py
new file mode 100644
index 00000000..fa428110
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/2021.4/sysroot.config.py
@@ -0,0 +1,56 @@
+sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
+copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
+#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
+
+build_config = 'Release' if not self.config.build_debug else 'Debug'
+build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
+
+def copy_bin(name):
+    global build_bin_dir, sysroot_bin_dir
+    copytree(build_bin_dir / name, sysroot_bin_dir / name)
+
+dll_suffix = 'd' if self.config.build_debug else ''
+def copy_dll(name):
+    global copy_bin, dll_suffix
+    copy_bin(name + dll_suffix + '.dll')
+    copy_bin(name + dll_suffix + '.pdb')
+
+copy_bin('cache.json')
+copy_dll('clDNNPlugin')
+copy_dll('HeteroPlugin')
+copy_dll('inference_engine')
+copy_dll('inference_engine_ir_reader')
+#copy_dll('inference_engine_ir_v7_reader')
+copy_dll('inference_engine_legacy')
+copy_dll('inference_engine_transformations')  # runtime
+copy_dll('inference_engine_lp_transformations')  # runtime
+#copy_dll('inference_engine_preproc')  # runtime
+copy_dll('MKLDNNPlugin')  # runtime
+copy_dll('myriadPlugin')  # runtime
+#copy_dll('MultiDevicePlugin')  # runtime, not used
+copy_dll('ngraph')
+copy_bin('plugins.xml')
+copy_bin('pcie-ma2x8x.elf')
+copy_bin('usb-ma2x8x.mvcmd')
+
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
+copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
+
+sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
+sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
+
+copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
+if not self.config.build_debug:
+    copytree(build_bin_dir / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
+    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_reader.lib', sysroot_ie_lib_dir / 'inference_engine_ir_reader.lib')
+    copytree(build_bin_dir / 'inference_engine_legacy.lib', sysroot_ie_lib_dir / 'inference_engine_legacy.lib')
+else:
+    copytree(build_bin_dir / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
+    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
+    copytree(build_bin_dir / 'inference_engine_ir_readerd.lib', sysroot_ie_lib_dir / 'inference_engine_ir_readerd.lib')
+    copytree(build_bin_dir / 'inference_engine_legacyd.lib', sysroot_ie_lib_dir / 'inference_engine_legacyd.lib')
+
+sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
+copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
+copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/build_package.py b/C++/opencv-4.7.0/platforms/winpack_dldt/build_package.py
new file mode 100644
index 00000000..277a13c2
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/build_package.py
@@ -0,0 +1,578 @@
+#!/usr/bin/env python
+
+import os, sys
+import argparse
+import glob
+import re
+import shutil
+import subprocess
+import time
+
+import logging as log
+
+if sys.version_info[0] == 2:
+    sys.exit("FATAL: Python 2.x is not supported")
+
+from pathlib import Path
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+class Fail(Exception):
+    def __init__(self, text=None):
+        self.t = text
+    def __str__(self):
+        return "ERROR" if self.t is None else self.t
+
+def execute(cmd, cwd=None, shell=False):
+    try:
+        log.debug("Executing: %s" % cmd)
+        log.info('Executing: ' + ' '.join(cmd))
+        if cwd:
+            log.info("    in: %s" % cwd)
+        retcode = subprocess.call(cmd, shell=shell, cwd=str(cwd) if cwd else None)
+        if retcode < 0:
+            raise Fail("Child was terminated by signal: %s" % -retcode)
+        elif retcode > 0:
+            raise Fail("Child returned: %s" % retcode)
+    except OSError as e:
+        raise Fail("Execution failed: %d / %s" % (e.errno, e.strerror))
+
+def check_executable(cmd):
+    try:
+        log.debug("Executing: %s" % cmd)
+        result = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        if not isinstance(result, str):
+            result = result.decode("utf-8")
+        log.debug("Result: %s" % (result + '\n').split('\n')[0])
+        return True
+    except OSError as e:
+        log.debug('Failed: %s' % e)
+        return False
+
+
+def rm_one(d):
+    d = str(d)  # Python 3.5 may not handle Path
+    d = os.path.abspath(d)
+    if os.path.exists(d):
+        if os.path.isdir(d):
+            log.info("Removing dir: %s", d)
+            shutil.rmtree(d)
+        elif os.path.isfile(d):
+            log.info("Removing file: %s", d)
+            os.remove(d)
+
+
+def prepare_dir(d, clean=False):
+    d = str(d)  # Python 3.5 may not handle Path
+    d = os.path.abspath(d)
+    log.info("Preparing directory: '%s' (clean: %r)", d, clean)
+    if os.path.exists(d):
+        if not os.path.isdir(d):
+            raise Fail("Not a directory: %s" % d)
+        if clean:
+            for item in os.listdir(d):
+                rm_one(os.path.join(d, item))
+    else:
+        os.makedirs(d)
+    return Path(d)
+
+
+def check_dir(d):
+    d = str(d)  # Python 3.5 may not handle Path
+    d = os.path.abspath(d)
+    log.info("Check directory: '%s'", d)
+    if os.path.exists(d):
+        if not os.path.isdir(d):
+            raise Fail("Not a directory: %s" % d)
+    else:
+        raise Fail("The directory is missing: %s" % d)
+    return Path(d)
+
+
+# shutil.copytree fails if dst exists
+def copytree(src, dst, exclude=None):
+    log.debug('copytree(%s, %s)', src, dst)
+    src = str(src)  # Python 3.5 may not handle Path
+    dst = str(dst)  # Python 3.5 may not handle Path
+    if os.path.isfile(src):
+        shutil.copy2(src, dst)
+        return
+    def copy_recurse(subdir):
+        if exclude and subdir in exclude:
+            log.debug('  skip: %s', subdir)
+            return
+        s = os.path.join(src, subdir)
+        d = os.path.join(dst, subdir)
+        if os.path.exists(d) or exclude:
+            if os.path.isfile(s):
+                shutil.copy2(s, d)
+            elif os.path.isdir(s):
+                if not os.path.isdir(d):
+                    os.makedirs(d)
+                for item in os.listdir(s):
+                    copy_recurse(os.path.join(subdir, item))
+            else:
+                assert False, s + " => " + d
+        else:
+            if os.path.isfile(s):
+                shutil.copy2(s, d)
+            elif os.path.isdir(s):
+                shutil.copytree(s, d)
+            else:
+                assert False, s + " => " + d
+    copy_recurse('')
+
+
+def git_checkout(dst, url, branch, revision, clone_extra_args, noFetch=False):
+    assert isinstance(dst, Path)
+    log.info("Git checkout: '%s' (%s @ %s)", dst, url, revision)
+    if noFetch:
+        pass
+    elif not os.path.exists(str(dst / '.git')):
+        execute(cmd=['git', 'clone'] +
+                (['-b', branch] if branch else []) +
+                clone_extra_args + [url, '.'], cwd=dst)
+    else:
+        execute(cmd=['git', 'fetch', 'origin'] + ([branch + ':' + branch] if branch else []), cwd=dst)
+    execute(cmd=['git', 'reset', '--hard'], cwd=dst)
+    execute(cmd=['git', 'clean', '-f', '-d'], cwd=dst)
+    execute(cmd=['git', 'checkout', '--force', '-B', 'winpack_dldt', revision], cwd=dst)
+    execute(cmd=['git', 'clean', '-f', '-d'], cwd=dst)
+    execute(cmd=['git', 'submodule', 'init'], cwd=dst)
+    execute(cmd=['git', 'submodule', 'update', '--force', '--depth=1000'], cwd=dst)
+    log.info("Git checkout: DONE")
+    execute(cmd=['git', 'status'], cwd=dst)
+    execute(cmd=['git', 'log', '--max-count=1', 'HEAD'], cwd=dst)
+
+
+def git_apply_patch(src_dir, patch_file):
+    src_dir = str(src_dir)  # Python 3.5 may not handle Path
+    patch_file = str(patch_file)  # Python 3.5 may not handle Path
+    assert os.path.exists(patch_file), patch_file
+    execute(cmd=['git', 'apply', '--3way', '-v', '--ignore-space-change', str(patch_file)], cwd=src_dir)
+    execute(cmd=['git', '--no-pager', 'diff', 'HEAD'], cwd=src_dir)
+    os.environ['GIT_AUTHOR_NAME'] = os.environ['GIT_COMMITTER_NAME']='build'
+    os.environ['GIT_AUTHOR_EMAIL'] = os.environ['GIT_COMMITTER_EMAIL']='build@opencv.org'
+    execute(cmd=['git', 'commit', '-am', 'apply opencv patch'], cwd=src_dir)
+
+
+#===================================================================================================
+
+class BuilderDLDT:
+    def __init__(self, config):
+        self.config = config
+
+        cpath = self.config.dldt_config
+        log.info('DLDT build configuration: %s', cpath)
+        if not os.path.exists(cpath):
+            cpath = os.path.join(SCRIPT_DIR, cpath)
+            if not os.path.exists(cpath):
+                raise Fail('Config "%s" is missing' % cpath)
+        self.cpath = Path(cpath)
+
+        clean_src_dir = self.config.clean_dldt
+        if self.config.dldt_src_dir:
+            assert os.path.exists(self.config.dldt_src_dir), self.config.dldt_src_dir
+            dldt_dir_name = 'dldt-custom'
+            self.srcdir = self.config.dldt_src_dir
+            clean_src_dir = False
+        else:
+            assert not self.config.dldt_src_dir
+            self.init_patchset()
+            dldt_dir_name = 'dldt-' + self.config.dldt_src_commit + \
+                    ('/patch-' + self.patch_hashsum if self.patch_hashsum else '')
+            if self.config.build_debug:
+                dldt_dir_name += '-debug'
+            self.srcdir = None  # updated below
+        log.info('DLDT directory: %s', dldt_dir_name)
+        self.outdir = prepare_dir(os.path.join(self.config.build_cache_dir, dldt_dir_name))
+        if self.srcdir is None:
+            self.srcdir = prepare_dir(self.outdir / 'sources', clean=clean_src_dir)
+        self.build_dir = prepare_dir(self.outdir / 'build', clean=self.config.clean_dldt)
+        self.sysrootdir = prepare_dir(self.outdir / 'sysroot', clean=self.config.clean_dldt or self.config.clean_dldt_sysroot)
+        if not (self.config.clean_dldt or self.config.clean_dldt_sysroot):
+            _ = prepare_dir(self.sysrootdir / 'bin', clean=True)  # always clean sysroot/bin (package files)
+            _ = prepare_dir(self.sysrootdir / 'etc', clean=True)  # always clean sysroot/etc (package files)
+
+        if self.config.build_subst_drive:
+            if os.path.exists(self.config.build_subst_drive + ':\\'):
+                execute(['subst', self.config.build_subst_drive + ':', '/D'])
+            execute(['subst', self.config.build_subst_drive + ':', str(self.outdir)])
+            def fix_path(p):
+                return str(p).replace(str(self.outdir), self.config.build_subst_drive + ':')
+            self.srcdir = Path(fix_path(self.srcdir))
+            self.build_dir = Path(fix_path(self.build_dir))
+            self.sysrootdir = Path(fix_path(self.sysrootdir))
+
+
+    def init_patchset(self):
+        cpath = self.cpath
+        self.patch_file = str(cpath / 'patch.config.py')  # Python 3.5 may not handle Path
+        with open(self.patch_file, 'r') as f:
+            self.patch_file_contents = f.read()
+
+        patch_hashsum = None
+        try:
+            import hashlib
+            patch_hashsum = hashlib.md5(self.patch_file_contents.encode('utf-8')).hexdigest()
+        except:
+            log.warn("Can't compute hashsum of patches: %s", self.patch_file)
+        self.patch_hashsum = self.config.override_patch_hashsum if self.config.override_patch_hashsum else patch_hashsum
+
+
+    def prepare_sources(self):
+        if self.config.dldt_src_dir:
+            log.info('Using DLDT custom repository: %s', self.srcdir)
+            return
+
+        def do_clone(srcdir, noFetch):
+            git_checkout(srcdir, self.config.dldt_src_url, self.config.dldt_src_branch, self.config.dldt_src_commit,
+                    ['-n', '--depth=100', '--no-single-branch', '--recurse-submodules'] +
+                    (self.config.dldt_src_git_clone_extra or []),
+                    noFetch=noFetch
+            )
+
+        if not os.path.exists(str(self.srcdir / '.git')):
+            log.info('DLDT git checkout through "reference" copy.')
+            reference_dir = self.config.dldt_reference_dir
+            if reference_dir is None:
+                reference_dir = prepare_dir(os.path.join(self.config.build_cache_dir, 'dldt-git-reference-repository'))
+                do_clone(reference_dir, False)
+                log.info('DLDT reference git checkout completed. Copying...')
+            else:
+                log.info('Using DLDT reference repository. Copying...')
+            copytree(reference_dir, self.srcdir)
+            do_clone(self.srcdir, True)
+        else:
+            do_clone(self.srcdir, False)
+
+        log.info('DLDT git checkout completed. Patching...')
+
+        def applyPatch(patch_file, subdir = None):
+            if subdir:
+                log.info('Patching "%s": %s' % (subdir, patch_file))
+            else:
+                log.info('Patching: %s' % (patch_file))
+            git_apply_patch(self.srcdir / subdir if subdir else self.srcdir, self.cpath / patch_file)
+
+        exec(compile(self.patch_file_contents, self.patch_file, 'exec'))
+
+        log.info('DLDT patches applied')
+
+
+    def build(self):
+        self.cmake_path = 'cmake'
+        build_config = 'Release' if not self.config.build_debug else 'Debug'
+
+        cmd = [self.cmake_path, '-G', 'Visual Studio 16 2019', '-A', 'x64']
+
+        cmake_vars = dict(
+            CMAKE_BUILD_TYPE=build_config,
+            TREAT_WARNING_AS_ERROR='OFF',
+            ENABLE_SAMPLES='OFF',
+            ENABLE_TESTS='OFF',
+            BUILD_TESTS='OFF',
+            ENABLE_OPENCV='OFF',
+            ENABLE_GNA='OFF',
+            ENABLE_SPEECH_DEMO='OFF',  # 2020.4+
+            NGRAPH_DOC_BUILD_ENABLE='OFF',
+            NGRAPH_UNIT_TEST_ENABLE='OFF',
+            NGRAPH_UNIT_TEST_OPENVINO_ENABLE='OFF',
+            NGRAPH_TEST_UTIL_ENABLE='OFF',
+            NGRAPH_ONNX_IMPORT_ENABLE='OFF',
+            CMAKE_INSTALL_PREFIX=str(self.build_dir / 'install'),
+            OUTPUT_ROOT=str(self.build_dir),  # 2020.4+
+        )
+
+        self.build_config_file = str(self.cpath / 'build.config.py')  # Python 3.5 may not handle Path
+        if os.path.exists(str(self.build_config_file)):
+            with open(self.build_config_file, 'r') as f:
+                cfg = f.read()
+            exec(compile(cfg, str(self.build_config_file), 'exec'))
+            log.info('DLDT processed build configuration script')
+
+        cmd += [ '-D%s=%s' % (k, v) for (k, v) in cmake_vars.items() if v is not None]
+        if self.config.cmake_option_dldt:
+            cmd += self.config.cmake_option_dldt
+
+        cmd.append(str(self.srcdir))
+
+        build_dir = self.build_dir
+        try:
+            execute(cmd, cwd=build_dir)
+
+            # build
+            cmd = [self.cmake_path, '--build', '.', '--config', build_config, # '--target', 'install',
+                    '--',
+                    # '/m:2' is removed, not properly supported by 2021.3
+                    '/v:n', '/consoleloggerparameters:NoSummary',
+            ]
+            execute(cmd, cwd=build_dir)
+
+            # install ngraph only
+            cmd = [self.cmake_path, '-DBUILD_TYPE=' + build_config, '-P', 'cmake_install.cmake']
+            execute(cmd, cwd=build_dir / 'ngraph')
+        except:
+            raise
+
+        log.info('DLDT build completed')
+
+
+    def make_sysroot(self):
+        cfg_file = str(self.cpath / 'sysroot.config.py')  # Python 3.5 may not handle Path
+        with open(cfg_file, 'r') as f:
+            cfg = f.read()
+        exec(compile(cfg, cfg_file, 'exec'))
+
+        log.info('DLDT sysroot preparation completed')
+
+
+    def cleanup(self):
+        if self.config.build_subst_drive:
+            execute(['subst', self.config.build_subst_drive + ':', '/D'])
+
+
+#===================================================================================================
+
+class Builder:
+    def __init__(self, config):
+        self.config = config
+        build_dir_name = 'opencv_build' if not self.config.build_debug else 'opencv_build_debug'
+        self.build_dir = prepare_dir(Path(self.config.output_dir) / build_dir_name, clean=self.config.clean_opencv)
+        self.package_dir = prepare_dir(Path(self.config.output_dir) / 'package/opencv', clean=True)
+        self.install_dir = prepare_dir(self.package_dir / 'build')
+        self.src_dir = check_dir(self.config.opencv_dir)
+
+
+    def build(self, builderDLDT):
+        self.cmake_path = 'cmake'
+        build_config = 'Release' if not self.config.build_debug else 'Debug'
+
+        cmd = [self.cmake_path, '-G', 'Visual Studio 16 2019', '-A', 'x64']
+
+        cmake_vars = dict(
+            CMAKE_BUILD_TYPE=build_config,
+            INSTALL_CREATE_DISTRIB='ON',
+            BUILD_opencv_world='OFF',
+            BUILD_TESTS='OFF',
+            BUILD_PERF_TESTS='OFF',
+            ENABLE_CXX11='ON',
+            WITH_INF_ENGINE='ON',
+            WITH_TBB='ON',
+            CPU_BASELINE='AVX2',
+            CMAKE_INSTALL_PREFIX=str(self.install_dir),
+            INSTALL_PDB='ON',
+            INSTALL_PDB_COMPONENT_EXCLUDE_FROM_ALL='OFF',
+
+            VIDEOIO_PLUGIN_LIST='all',
+
+            OPENCV_SKIP_CMAKE_ROOT_CONFIG='ON',
+            OPENCV_BIN_INSTALL_PATH='bin',
+            OPENCV_INCLUDE_INSTALL_PATH='include',
+            OPENCV_LIB_INSTALL_PATH='lib',
+            OPENCV_CONFIG_INSTALL_PATH='cmake',
+            OPENCV_3P_LIB_INSTALL_PATH='3rdparty',
+            OPENCV_SAMPLES_SRC_INSTALL_PATH='samples',
+            OPENCV_DOC_INSTALL_PATH='doc',
+            OPENCV_OTHER_INSTALL_PATH='etc',
+            OPENCV_LICENSES_INSTALL_PATH='etc/licenses',
+
+            OPENCV_INSTALL_DATA_DIR_RELATIVE='../../src/opencv',
+
+            BUILD_opencv_python2='OFF',
+            BUILD_opencv_python3='ON',
+            PYTHON3_LIMITED_API='ON',
+            OPENCV_PYTHON_INSTALL_PATH='python',
+        )
+
+        if self.config.dldt_release:
+            cmake_vars['INF_ENGINE_RELEASE'] = str(self.config.dldt_release)
+
+        InferenceEngine_DIR = str(builderDLDT.sysrootdir / 'deployment_tools' / 'inference_engine' / 'cmake')
+        assert os.path.exists(InferenceEngine_DIR), InferenceEngine_DIR
+        cmake_vars['InferenceEngine_DIR:PATH'] = InferenceEngine_DIR
+
+        ngraph_DIR = str(builderDLDT.sysrootdir / 'ngraph/cmake')
+        if not os.path.exists(ngraph_DIR):
+            ngraph_DIR = str(builderDLDT.sysrootdir / 'ngraph/deployment_tools/ngraph/cmake')
+        assert os.path.exists(ngraph_DIR), ngraph_DIR
+        cmake_vars['ngraph_DIR:PATH'] = ngraph_DIR
+
+        cmake_vars['TBB_DIR:PATH'] = str(builderDLDT.sysrootdir / 'tbb/cmake')
+        assert os.path.exists(cmake_vars['TBB_DIR:PATH']), cmake_vars['TBB_DIR:PATH']
+
+        if self.config.build_debug:
+            cmake_vars['CMAKE_BUILD_TYPE'] = 'Debug'
+            cmake_vars['BUILD_opencv_python3'] ='OFF'  # python3x_d.lib is missing
+            cmake_vars['OPENCV_INSTALL_APPS_LIST'] = 'all'
+
+        if self.config.build_tests:
+            cmake_vars['BUILD_TESTS'] = 'ON'
+            cmake_vars['BUILD_PERF_TESTS'] = 'ON'
+            cmake_vars['BUILD_opencv_ts'] = 'ON'
+            cmake_vars['INSTALL_TESTS']='ON'
+
+        if self.config.build_tests_dnn:
+            cmake_vars['BUILD_TESTS'] = 'ON'
+            cmake_vars['BUILD_PERF_TESTS'] = 'ON'
+            cmake_vars['BUILD_opencv_ts'] = 'ON'
+            cmake_vars['OPENCV_BUILD_TEST_MODULES_LIST'] = 'dnn'
+            cmake_vars['OPENCV_BUILD_PERF_TEST_MODULES_LIST'] = 'dnn'
+            cmake_vars['INSTALL_TESTS']='ON'
+
+        cmd += [ "-D%s=%s" % (k, v) for (k, v) in cmake_vars.items() if v is not None]
+        if self.config.cmake_option:
+            cmd += self.config.cmake_option
+
+        cmd.append(str(self.src_dir))
+
+        log.info('Configuring OpenCV...')
+
+        execute(cmd, cwd=self.build_dir)
+
+        log.info('Building OpenCV...')
+
+        # build
+        cmd = [self.cmake_path, '--build', '.', '--config', build_config, '--target', 'install',
+                '--', '/v:n', '/m:2', '/consoleloggerparameters:NoSummary'
+        ]
+        execute(cmd, cwd=self.build_dir)
+
+        log.info('OpenCV build/install completed')
+
+
+    def copy_sysroot(self, builderDLDT):
+        log.info('Copy sysroot files')
+
+        copytree(builderDLDT.sysrootdir / 'bin', self.install_dir / 'bin')
+        copytree(builderDLDT.sysrootdir / 'etc', self.install_dir / 'etc')
+
+        log.info('Copy sysroot files - DONE')
+
+
+    def package_sources(self):
+        package_opencv = prepare_dir(self.package_dir / 'src/opencv', clean=True)
+        package_opencv = str(package_opencv)  # Python 3.5 may not handle Path
+        execute(cmd=['git', 'clone', '-s', str(self.src_dir), '.'], cwd=str(package_opencv))
+        for item in os.listdir(package_opencv):
+            if str(item).startswith('.git'):
+                rm_one(os.path.join(package_opencv, item))
+
+        with open(str(self.package_dir / 'README.md'), 'w') as f:
+            f.write('See licensing/copying statements in "build/etc/licenses"\n')
+            f.write('Wiki page: https://github.com/opencv/opencv/wiki/Intel%27s-Deep-Learning-Inference-Engine-backend\n')
+
+        log.info('Package OpenCV sources - DONE')
+
+
+#===================================================================================================
+
+def main():
+
+    dldt_src_url = 'https://github.com/openvinotoolkit/openvino'
+    dldt_src_commit = '2021.4.2'
+    dldt_config = None
+    dldt_release = None
+
+    build_cache_dir_default = os.environ.get('BUILD_CACHE_DIR', '.build_cache')
+    build_subst_drive = os.environ.get('BUILD_SUBST_DRIVE', None)
+
+    parser = argparse.ArgumentParser(
+            description='Build OpenCV Windows package with Inference Engine (DLDT)',
+    )
+    parser.add_argument('output_dir', nargs='?', default='.', help='Output directory')
+    parser.add_argument('opencv_dir', nargs='?', default=os.path.join(SCRIPT_DIR, '../..'), help='Path to OpenCV source dir')
+    parser.add_argument('--build_cache_dir', default=build_cache_dir_default, help='Build cache directory (sources and binaries cache of build dependencies, default = "%s")' % build_cache_dir_default)
+    parser.add_argument('--build_subst_drive', default=build_subst_drive, help='Drive letter to workaround Windows limit for 260 symbols in path (error MSB3491)')
+
+    parser.add_argument('--cmake_option', action='append', help='Append OpenCV CMake option')
+    parser.add_argument('--cmake_option_dldt', action='append', help='Append CMake option for DLDT project')
+
+    parser.add_argument('--clean_dldt', action='store_true', help='Clean DLDT build and sysroot directories')
+    parser.add_argument('--clean_dldt_sysroot', action='store_true', help='Clean DLDT sysroot directories')
+    parser.add_argument('--clean_opencv', action='store_true', help='Clean OpenCV build directory')
+
+    parser.add_argument('--build_debug', action='store_true', help='Build debug binaries')
+    parser.add_argument('--build_tests', action='store_true', help='Build OpenCV tests')
+    parser.add_argument('--build_tests_dnn', action='store_true', help='Build OpenCV DNN accuracy and performance tests only')
+
+    parser.add_argument('--dldt_src_url', default=dldt_src_url, help='DLDT source URL (tag / commit, default: %s)' % dldt_src_url)
+    parser.add_argument('--dldt_src_branch', help='DLDT checkout branch')
+    parser.add_argument('--dldt_src_commit', default=dldt_src_commit, help='DLDT source commit / tag (default: %s)' % dldt_src_commit)
+    parser.add_argument('--dldt_src_git_clone_extra', action='append', help='DLDT git clone extra args')
+    parser.add_argument('--dldt_release', default=dldt_release, help='DLDT release code for INF_ENGINE_RELEASE, e.g 2021030000 (default: %s)' % dldt_release)
+
+    parser.add_argument('--dldt_reference_dir', help='DLDT reference git repository (optional)')
+    parser.add_argument('--dldt_src_dir', help='DLDT custom source repository (skip git checkout and patching, use for TESTING only)')
+
+    parser.add_argument('--dldt_config', default=dldt_config, help='Specify DLDT build configuration (defaults to evaluate from DLDT commit/branch)')
+
+    parser.add_argument('--override_patch_hashsum', default='', help='(script debug mode)')
+
+    args = parser.parse_args()
+
+    log.basicConfig(
+            format='%(asctime)s %(levelname)-8s %(message)s',
+            level=os.environ.get('LOGLEVEL', 'INFO'),
+            datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    log.debug('Args: %s', args)
+
+    if not check_executable(['git', '--version']):
+        sys.exit("FATAL: 'git' is not available")
+    if not check_executable(['cmake', '--version']):
+        sys.exit("FATAL: 'cmake' is not available")
+
+    if os.path.realpath(args.output_dir) == os.path.realpath(SCRIPT_DIR):
+        raise Fail("Specify output_dir (building from script directory is not supported)")
+    if os.path.realpath(args.output_dir) == os.path.realpath(args.opencv_dir):
+        raise Fail("Specify output_dir (building from OpenCV source directory is not supported)")
+
+    # Relative paths become invalid in sub-directories
+    if args.opencv_dir is not None and not os.path.isabs(args.opencv_dir):
+        args.opencv_dir = os.path.abspath(args.opencv_dir)
+
+    if not args.dldt_config:
+        if str(args.dldt_src_commit).startswith('releases/20'):  # releases/2020/4
+            args.dldt_config = str(args.dldt_src_commit)[len('releases/'):].replace('/', '.')
+            if not args.dldt_src_branch:
+                args.dldt_src_branch = args.dldt_src_commit
+        elif str(args.dldt_src_branch).startswith('releases/20'):  # releases/2020/4
+            args.dldt_config = str(args.dldt_src_branch)[len('releases/'):].replace('/', '.')
+        else:
+            args.dldt_config = args.dldt_src_commit
+
+    _opencv_dir = check_dir(args.opencv_dir)
+    _outdir = prepare_dir(args.output_dir)
+    _cachedir = prepare_dir(args.build_cache_dir)
+
+    ocv_hooks_dir = os.environ.get('OPENCV_CMAKE_HOOKS_DIR', None)
+    hooks_dir = os.path.join(SCRIPT_DIR, 'cmake-opencv-checks')
+    os.environ['OPENCV_CMAKE_HOOKS_DIR'] = hooks_dir if ocv_hooks_dir is None else (hooks_dir + ';' + ocv_hooks_dir)
+
+    builder_dldt = BuilderDLDT(args)
+
+    try:
+        builder_dldt.prepare_sources()
+        builder_dldt.build()
+        builder_dldt.make_sysroot()
+
+        builder_opencv = Builder(args)
+        builder_opencv.build(builder_dldt)
+        builder_opencv.copy_sysroot(builder_dldt)
+        builder_opencv.package_sources()
+    except:
+        builder_dldt.cleanup()
+        raise
+
+    log.info("=====")
+    log.info("===== Build finished")
+    log.info("=====")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except:
+        log.info('FATAL: Error occurred. To investigate problem try to change logging level using LOGLEVEL=DEBUG environment variable.')
+        raise
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/cmake-opencv-checks/POST_FINALIZE.cmake b/C++/opencv-4.7.0/platforms/winpack_dldt/cmake-opencv-checks/POST_FINALIZE.cmake
new file mode 100644
index 00000000..0952262a
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/cmake-opencv-checks/POST_FINALIZE.cmake
@@ -0,0 +1,17 @@
+message(STATUS "Winpack-DLDT: Validating OpenCV build configuration...")
+
+if(NOT INF_ENGINE_TARGET)
+  message(SEND_ERROR "Inference engine must be detected")
+  set(HAS_ERROR 1)
+endif()
+if(NOT HAVE_NGRAPH)
+  message(SEND_ERROR "Inference engine nGraph must be detected")
+  set(HAS_ERROR 1)
+endif()
+
+if(HAS_ERROR)
+  ocv_cmake_dump_vars("^IE_|INF_|INFERENCE|ngraph")
+  message(FATAL_ERROR "Winpack-DLDT: Validating OpenCV build configuration... FAILED")
+endif()
+
+message(STATUS "Winpack-DLDT: Validating OpenCV build configuration... DONE")
diff --git a/C++/opencv-4.7.0/platforms/winpack_dldt/package-tests/test_dnn_backends.py b/C++/opencv-4.7.0/platforms/winpack_dldt/package-tests/test_dnn_backends.py
new file mode 100644
index 00000000..e3b6e16f
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winpack_dldt/package-tests/test_dnn_backends.py
@@ -0,0 +1,13 @@
+import sys
+print(sys.version_info)
+try:
+    import cv2 as cv
+    print(cv.__version__)
+    print(cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE))
+except:
+    print(sys.path)
+    import os
+    print(os.environ.get('PATH', ''))
+    raise
+
+print('OK')
diff --git a/C++/opencv-4.7.0/platforms/winrt/readme.txt b/C++/opencv-4.7.0/platforms/winrt/readme.txt
new file mode 100644
index 00000000..2d1b4e6c
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winrt/readme.txt
@@ -0,0 +1,159 @@
+Building OpenCV from Source, using CMake and Command Line
+=========================================================
+
+Requirements
+============
+CMake 3.1.0 or higher
+Windows Phone/Store 8.1 Visual Studio 2013
+Windows Phone/Store 8.0 Visual Studio 2012
+
+For example, to be able to build all Windows Phone and Windows Store projects install the following:
+
+Install Visual Studio 2013 Community Edition
+    http://go.microsoft.com/?linkid=9863608
+
+Install Visual Studio Express 2012 for Windows Desktop
+    https://devblogs.microsoft.com/visualstudio/visual-studio-express-2012-for-windows-desktop-is-here/
+
+
+
+To create and build all Windows Phone (8.0, 8.1) and Windows Store (8.0, 8.1) Visual Studio projects
+==========================================================================================
+cd opencv/platforms/winrt
+setup_winrt.bat "WP,WS" "8.0,8.1" "x86,ARM" -b
+
+If everything's fine, a few minutes later you will get the following output in the opencv/bin directory:
+
+bin
+    install
+        WP
+            8.0
+                ARM
+                x86
+            8.1
+                ARM
+                x86
+        WS
+            8.0
+                ARM
+                x86
+            8.1
+                ARM
+                x86
+    WP
+        8.0
+            ARM
+            x86
+        8.1
+            ARM
+            x86
+    WS
+        8.0
+            ARM
+            x86
+        8.1
+            ARM
+            x86
+
+"-b" flag in the command above builds each generated solutions in both "Debug" and "Release" configurations. It also builds the predefined "INSTALL" project within generated solutions. Building it creates a separate install location that accumulates binaries and includes for specified platforms. Default location is "<ocv-src>\bin\install\".
+
+WinRT samples reference 'install' binaries and include files via "OPENCV_WINRT_INSTALL_DIR" environment variable. Please declare it and point to "<ocv-src>\bin\install\" directory to resolve references within sample applications.
+
+If you don't want to build all configurations automatically, you can omit "-b" flag and build OpenCV.sln for the particular platform you are targeting manually. Due to the current limitations of CMake, separate x86/x64/ARM projects must be generated for each platform.
+
+You can also target a single specific configuration
+    setup_winrt.bat "WP" "8.1" "x86"
+
+Or a subset of configurations
+    setup_winrt.bat "WP,WS" "8.1" "x86"
+
+To display the command line options for setup_winrt.bat
+    setup_winrt.bat -h
+
+Note that x64 CMake generation support is as follows:
+------------------------------
+Platform\Version | 8.0 | 8.1 |
+-----------------|-----|-----|
+Windows Phone    | No  | No  |
+Windows Store    | Yes | Yes |
+
+Note: setup_winrt.bat calls the unsigned PowerShell script with the -ExecutionPolicy Unrestricted option.
+
+
+CMake command line options for Windows Phone and Store
+======================================================
+
+cmake [options] <path-to-source>
+
+Windows Phone 8.1 x86
+cmake -G "Visual Studio 12 2013" -DCMAKE_SYSTEM_NAME=WindowsPhone -DCMAKE_SYSTEM_VERSION=8.1 <path-to-source>
+
+Windows Phone 8.1 ARM
+cmake -G "Visual Studio 12 2013 ARM" -DCMAKE_SYSTEM_NAME=WindowsPhone -DCMAKE_SYSTEM_VERSION=8.1 <path-to-source>
+
+Windows Store 8.1 x86
+cmake -G "Visual Studio 12 2013" -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=8.1 <path-to-source>
+
+Windows Store 8.1 ARM
+cmake -G "Visual Studio 12 2013 ARM" -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=8.1 <path-to-source>
+
+Note: For Windows 8.0 Phone and Store you can specify either Visual Studio 11 2012 or Visual Studio 12 2013 as the generator
+
+Windows Phone 8.0 x86
+cmake -G "Visual Studio 12 2013" -DCMAKE_SYSTEM_NAME=WindowsPhone -DCMAKE_SYSTEM_VERSION=8.0 <path-to-source>
+
+Windows Phone 8.0 ARM
+cmake -G "Visual Studio 12 2013 ARM" -DCMAKE_SYSTEM_NAME=WindowsPhone -DCMAKE_SYSTEM_VERSION=8.0 <path-to-source>
+
+Windows Store 8.0 x86
+cmake -G "Visual Studio 12 2013" -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=8.0 <path-to-source>
+
+Windows Store 8.0 ARM
+cmake -G "Visual Studio 12 2013 ARM" -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=8.0 <path-to-source>
+
+Example
+======================================================
+
+To generate Windows Phone 8.1 x86 project files in the opencv/bin dir
+
+mkdir bin
+cd bin
+cmake -G "Visual Studio 12 2013" -DCMAKE_SYSTEM_NAME=WindowsPhone -DCMAKE_SYSTEM_VERSION=8.1 ../
+
+Running tests for Windows Store
+===============================
+1. You might need to install this if you haven't already: http://www.microsoft.com/en-US/download/details.aspx?id=40784
+
+2. Set OPENCV_TEST_DATA_PATH environment variable to location of opencv_extra/testdata (cloning of https://github.com/opencv/opencv_extra repo required) to get tests work correctly. Also, set OPENCV_PERF_VALIDATION_DIR environment variable in case you are planning to have place where to store performance test results and compare them with the future test runs.
+
+3. In case you'd like to adjust some flags that are defaulted by setup_winrt script, go to "Manual build" section. Otherwise go to platforms/winrt and execute
+
+setup_winrt.bat "WS" "8.1" "x64"
+
+This will generate all files needed to build open_cv projects for selected platform in opencv\bin\<Depends on generated configuration>. Open the opencv\bin\<path to required configuration> directory and open the OpenCV.sln.
+
+4. Set OCV solution to Release mode and build it. They should build without errors and generate executables in "bin\WS\8.1\x64\bin\Release\" (or similar path depending on the configuration)
+
+5. Running tests:
+ - **Accuracy:** Run opencv_test_{module}.exe via console or as usual by double clicking it. You should see output in the console window
+ - **Performance:** Run opencv_perf_{module}.exe via console or as usual by double clicking it. You should see output in the console window. In case you'd like to write test results to file use --perf_write_validation_results=<filename> parameter; To compare current results to previous use --perf_read_validation_results=<filename>. This should read/write files from/to OPENCV_PERF_VALIDATION_DIR
+
+Manual build
+============
+
+ CMake interface:
+-----------------
+  1. Set CMAKE_SYSTEM_NAME to WindowsStore or WindowsPhone and CMAKE_SYSTEM_VERSION to 8.0 or 8.1
+  2. Set CMAKE_INSTALL_PREFIX using format "<install dir>\WS\8.1\x64" (this structure is required by samples)
+  3. Click "Configure" and choose required generator
+  4. Click "Generate"
+
+ Command line:
+--------------
+  1. md bin
+  2. cd bin
+  3. Add any required parameters to this command and execute it:
+
+  cmake -G "Visual Studio 12 2013 Win64" -DCMAKE_SYSTEM_NAME:String=WindowsStore -DCMAKE_SYSTEM_VERSION:String=8.1 -DCMAKE_VS_EFFECTIVE_PLATFORMS:String=x64 -DCMAKE_INSTALL_PREFIX:PATH=.\install\WS\8.1\x64\ ..
+
+Return to "Running tests for Windows Store", list item 4.
diff --git a/C++/opencv-4.7.0/platforms/winrt/setup_winrt.bat b/C++/opencv-4.7.0/platforms/winrt/setup_winrt.bat
new file mode 100644
index 00000000..3268bcf6
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winrt/setup_winrt.bat
@@ -0,0 +1,2 @@
+@echo off
+Powershell.exe -ExecutionPolicy Unrestricted -File setup_winrt.ps1 %*
diff --git a/C++/opencv-4.7.0/platforms/winrt/setup_winrt.ps1 b/C++/opencv-4.7.0/platforms/winrt/setup_winrt.ps1
new file mode 100644
index 00000000..518c73c3
--- /dev/null
+++ b/C++/opencv-4.7.0/platforms/winrt/setup_winrt.ps1
@@ -0,0 +1,383 @@
+<#
+Copyright (c) Microsoft Open Technologies, Inc.
+All rights reserved.
+
+(3-clause BSD License)
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that
+the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
+following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or
+promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+#>
+
+[CmdletBinding()]
+Param(
+    [parameter(Mandatory=$False)]
+    [switch]
+    $HELP,
+
+    [parameter(Mandatory=$False)]
+    [switch]
+    $BUILD,
+
+    [parameter(Mandatory=$False)]
+    [Array]
+    [ValidateNotNull()]
+    $PLATFORMS_IN = "WP",
+
+    [parameter(Mandatory=$False)]
+    [Array]
+    [ValidateNotNull()]
+    $VERSIONS_IN = "8.1",
+
+    [parameter(Mandatory=$False)]
+    [Array]
+    [ValidateNotNull()]
+    $ARCHITECTURES_IN = "x86",
+
+    [parameter(Mandatory=$False)]
+    [String]
+    $TESTS = "None",
+
+    [parameter(Mandatory=$False)]
+    [String]
+    [ValidateNotNull()]
+    [ValidateSet("Visual Studio 15 2017","Visual Studio 14 2015","Visual Studio 12 2013","Visual Studio 11 2012")]
+    $GENERATOR = "Visual Studio 15 2017",
+
+    [parameter(Mandatory=$False)]
+    [String]
+    $INSTALL
+)
+
+
+Function L() {
+    Param(
+        [parameter(Mandatory=$true)]
+        [String]
+        [ValidateNotNull()]
+        $str
+    )
+
+    Write-Host "INFO> $str"
+}
+
+Function D() {
+    Param(
+        [parameter(Mandatory=$true)]
+        [String]
+        [ValidateNotNull()]
+        $str
+    )
+
+    # Use this trigger to toggle debug output
+    [bool]$debug = $true
+
+    if ($debug) {
+        Write-Host "DEBUG> $str"
+    }
+}
+
+function Get-Batchfile ($file) {
+    $cmd = "`"$file`" & set"
+    cmd /c $cmd | Foreach-Object {
+        $p, $v = $_.split('=')
+        Set-Item -path env:$p -value $v
+    }
+}
+
+# Enables access to Visual Studio variables via "vsvars32.bat"
+function Set-VS12()
+{
+    Try {
+        $vs12comntools = (Get-ChildItem env:VS120COMNTOOLS).Value
+        $batchFile = [System.IO.Path]::Combine($vs12comntools, "vsvars32.bat")
+        Get-Batchfile $BatchFile
+        [System.Console]::Title = "Visual Studio 2010 Windows PowerShell"
+     } Catch {
+        $ErrorMessage = $_.Exception.Message
+        L "Error: $ErrorMessage"
+        return $false
+     }
+     return $true
+}
+
+# Executes msbuild to build or install projects
+# Throws Exception on error
+function Call-MSBuild($path, $config)
+{
+    $command = "msbuild $path /p:Configuration='$config' /m"
+    L "Executing: $($command)"
+    msbuild $path /p:Configuration="$config" /m
+
+    if(-Not $?) {
+        Throw "Failure executing command: $($command)"
+    }
+
+    return $true
+}
+
+function RunAccuracyTests($path) {
+    md "$path\bin\Release\accuracy"
+    python "$PSScriptRoot\..\..\modules\ts\misc\run.py" -w "$path\bin\Release\accuracy" -a "$path\bin\Release"
+}
+
+function RunPerfTests($path) {
+    md "$path\bin\Release\perf"
+    python "$PSScriptRoot\..\..\modules\ts\misc\run.py" -w "$path\bin\Release\perf" "$path\bin\Release"
+}
+
+Function Execute() {
+    If ($HELP.IsPresent) {
+        ShowHelp
+    }
+
+    # Validating arguments.
+    # This type of validation (rather than using ValidateSet()) is required to make .bat wrapper work
+
+    D "Input Platforms: $PLATFORMS_IN"
+    $platforms = New-Object System.Collections.ArrayList
+    $PLATFORMS_IN.Split("," ,[System.StringSplitOptions]::RemoveEmptyEntries) | ForEach {
+        $_ = $_.Trim()
+        if ("WP","WS" -Contains $_) {
+            [void]$platforms.Add($_)
+            D "$_ is valid"
+        } else {
+            Throw "$($_) is not valid! Please use WP, WS"
+        }
+    }
+    D "Processed Platforms: $platforms"
+
+    D "Input Versions: $VERSIONS_IN"
+    $versions = New-Object System.Collections.ArrayList
+    $VERSIONS_IN.Split("," ,[System.StringSplitOptions]::RemoveEmptyEntries) | ForEach {
+        $_ = $_.Trim()
+        if ("8.0","8.1","10.0" -Contains $_) {
+            [void]$versions.Add($_)
+            D "$_ is valid"
+        } else {
+            Throw "$($_) is not valid! Please use 8.0, 8.1, 10.0"
+        }
+    }
+    D "Processed Versions: $versions"
+
+    D "Input Architectures: $ARCHITECTURES_IN"
+    $architectures = New-Object System.Collections.ArrayList
+    $ARCHITECTURES_IN.Split("," ,[System.StringSplitOptions]::RemoveEmptyEntries) | ForEach {
+        $_ = $_.Trim()
+        if ("x86","x64","ARM" -Contains $_) {
+            $architectures.Add($_) > $null
+            D "$_ is valid"
+        } else {
+            Throw "$($_) is not valid! Please use x86, x64, ARM"
+        }
+    }
+
+    D "Processed Architectures: $architectures"
+
+    # Assuming we are in '<ocv-sources>/platforms/winrt' we should move up to sources root directory
+    Push-Location ../../
+
+    $SRC = Get-Location
+
+    $def_architectures = @{
+        "x86" = "";
+        "x64" = " Win64"
+        "arm" = " ARM"
+    }
+
+    # Setting up Visual Studio variables to enable build
+    $shouldBuid = $false
+    If ($BUILD.IsPresent) {
+        $shouldBuild = Set-VS12
+    }
+
+    foreach($plat in $platforms) {
+        # Set proper platform name.
+        $platName = ""
+        Switch ($plat) {
+            "WP" { $platName = "WindowsPhone" }
+            "WS" { $platName = "WindowsStore" }
+        }
+
+        foreach($vers in $versions) {
+
+            foreach($arch in $architectures) {
+
+                # Set proper architecture. For MSVS this is done by selecting proper generator
+                $genName = $GENERATOR
+                Switch ($arch) {
+                    "ARM" { $genName = $GENERATOR + $def_architectures['arm'] }
+                    "x64" { $genName = $GENERATOR + $def_architectures['x64'] }
+                }
+
+                # Constructing path to the install binaries
+                # Creating these binaries will be done by building CMake-generated INSTALL project from Visual Studio
+                $installPath = "$SRC\bin\install\$plat\$vers\$arch"
+                if ($INSTALL) {
+                    # Do not add architrecture to the path since it will be added by OCV CMake logic
+                    $installPath = "$SRC\$INSTALL\$plat\$vers"
+                }
+
+                $path = "$SRC\bin\$plat\$vers\$arch"
+
+                L "-----------------------------------------------"
+                L "Target:"
+                L "    Directory: $path"
+                L "    Platform: $platName"
+                L "    Version: $vers"
+                L "    Architecture: $arch"
+                L "    Generator: $genName"
+                L "    Install Directory: $installPath"
+
+                # Delete target directory if exists to ensure that CMake cache is cleared out.
+                If (Test-Path $path) {
+                    Remove-Item -Recurse -Force $path
+                }
+
+                # Validate if required directory exists, create if it doesn't
+                New-Item -ItemType Directory -Force -Path $path
+
+                # Change location to the respective subdirectory
+                Push-Location -Path $path
+
+                L "Generating project:"
+                L "cmake -G $genName -DCMAKE_SYSTEM_NAME:String=$platName -DCMAKE_SYSTEM_VERSION:String=$vers -DCMAKE_VS_EFFECTIVE_PLATFORMS:String=$arch -DCMAKE_INSTALL_PREFIX:PATH=$installPath $SRC"
+                cmake -G $genName -DCMAKE_SYSTEM_NAME:String=$platName -DCMAKE_SYSTEM_VERSION:String=$vers -DCMAKE_VS_EFFECTIVE_PLATFORMS:String=$arch -DCMAKE_INSTALL_PREFIX:PATH=$installPath $SRC
+                L "-----------------------------------------------"
+
+                # REFERENCE:
+                # Executed from '$SRC/bin' folder.
+                # Targeting x86 WindowsPhone 8.1.
+                # cmake -G "Visual Studio 12 2013" -DCMAKE_SYSTEM_NAME:String=WindowsPhone -DCMAKE_SYSTEM_VERSION:String=8.1 ..
+
+
+                # Building and installing project
+                Try {
+                    If ($shouldBuild) {
+                        L "Building and installing project:"
+
+                        Call-MSBuild "OpenCV.sln" "Debug"
+                        Call-MSBuild "INSTALL.vcxproj" "Debug"
+
+                        Call-MSBuild "OpenCV.sln" "Release"
+                        Call-MSBuild "INSTALL.vcxproj" "Release"
+
+                        Try {
+                            # Running tests for release versions:
+                            If ($TESTS -eq "ALL") {
+                                RunAccuracyTests "$path"
+                                RunPerfTests "$path"
+                            } else {
+                                If($TESTS -eq "ACC") {
+                                    RunAccuracyTests "$path"
+                                }
+                                If($TESTS -eq "PERF") {
+                                    RunPerfTests "$path"
+                                }
+                            }
+                        } Catch {
+                            $ErrorMessage = $_.Exception.Message
+                            L "Error: $ErrorMessage"
+                            exit
+                        }
+                    }
+                } Catch {
+                    $ErrorMessage = $_.Exception.Message
+                    L "Error: $ErrorMessage"
+
+                    # Exiting at this point will leave command line pointing at the erroneous configuration directory
+                    exit
+                }
+
+                # Return back to Sources folder
+                Pop-Location
+            }
+        }
+    }
+
+    # Return back to Script folder
+    Pop-Location
+}
+
+Function ShowHelp() {
+    Write-Host "Configures OpenCV and generates projects for specified version of Visual Studio/platforms/architectures."
+    Write-Host "Must be executed from the sources folder containing main CMakeLists configuration."
+    Write-Host "Parameter keys can be shortened down to a single symbol (e.g. '-a') and are not case sensitive."
+    Write-Host "Proper parameter sequencing is required when omitting keys."
+    Write-Host "Generates the following folder structure, depending on the supplied parameters: "
+    Write-Host "     bin/ "
+    Write-Host "      | "
+    Write-Host "      |-WP "
+    Write-Host "      |  ... "
+    Write-Host "      |-WinRT "
+    Write-Host "      |  |-8.0 "
+    Write-Host "      |  |-8.1 "
+    Write-Host "      |  |  |-x86 "
+    Write-Host "      |  |  |-x64 "
+    Write-Host "      |  |  |-ARM "
+    Write-Host " "
+    Write-Host " USAGE: "
+    Write-Host "   Calling:"
+    Write-Host "     PS> setup_winrt.ps1 [params]"
+    Write-Host "     cmd> setup_winrt.bat [params]"
+    Write-Host "     cmd> PowerShell.exe -ExecutionPolicy Unrestricted -File setup_winrt.ps1 [params]"
+    Write-Host "   Parameters:"
+    Write-Host "     setup_winrt [options] [platform] [version] [architecture] [tests] [generator] [install-path]"
+    Write-Host "     setup_winrt -b 'WP' 'x86,ARM' "
+    Write-Host "     setup_winrt -b 'WP' 'x86,ARM' ALL"
+    Write-Host "     setup_winrt -b 'WP' 'x86,ARM' -test PERF "
+    Write-Host "     setup_winrt -architecture x86 -platform WP "
+    Write-Host "     setup_winrt -arc x86 -plat 'WP,WS' "
+    Write-Host "     setup_winrt -a x86 -g 'Visual Studio 15 2017' -pl WP "
+    Write-Host " WHERE: "
+    Write-Host "     options -  Options to call "
+    Write-Host "                 -h: displays command line help "
+    Write-Host "                 -b: builds BUILD_ALL and INSTALL projects for each generated configuration in both Debug and Release modes."
+    Write-Host "     platform -  Array of target platforms. "
+    Write-Host "                 Default: WP "
+    Write-Host "                 Example: 'WS,WP' "
+    Write-Host "                 Options: WP, WS ('WindowsPhone', 'WindowsStore'). "
+    Write-Host "                 Note that you'll need to use quotes to specify more than one platform. "
+    Write-Host "     version - Array of platform versions. "
+    Write-Host "                 Default: 8.1 "
+    Write-Host "                 Example: '8.0,8.1' "
+    Write-Host "                 Options: 8.0, 8.1, 10.0. Available options may be limited depending on your local setup (e.g. SDK availability). "
+    Write-Host "                 Note that you'll need to use quotes to specify more than one version. "
+    Write-Host "     architecture - Array of target architectures to build for. "
+    Write-Host "                 Default: x86 "
+    Write-Host "                 Example: 'ARM,x64' "
+    Write-Host "                 Options: x86, ARM, x64. Available options may be limited depending on your local setup. "
+    Write-Host "                 Note that you'll need to use quotes to specify more than one architecture. "
+    Write-Host "     tests - Test sets to run. Requires -b option otherwise ignored. "
+    Write-Host "                 Default: None. "
+    Write-Host "                 Example: 'ALL' "
+    Write-Host "                 Options: ACC, PERF, ALL. "
+    Write-Host "     generator - Visual Studio instance used to generate the projects. "
+    Write-Host "                 Default: Visual Studio 12 2013 "
+    Write-Host "                 Example: 'Visual Studio 11 2012' "
+    Write-Host "                 Use 'cmake --help' to find all available option on your machine. "
+    Write-Host "     install-path - Path to install binaries (relative to the sources directory). "
+    Write-Host "                 Default: <src-dir>\bin\install\<platform>\<version>\<architecture> "
+    Write-Host "                 Example: '../install' "
+
+    Exit
+}
+
+Execute
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/CMakeLists.example.in b/C++/opencv-4.7.0/samples/CMakeLists.example.in
new file mode 100644
index 00000000..7cf20d5e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/CMakeLists.example.in
@@ -0,0 +1,37 @@
+# cmake needs this line
+cmake_minimum_required(VERSION 3.1)
+
+if(NOT DEFINED EXAMPLE_NAME)
+  message(FATAL_ERROR "Invalid build script: missing EXAMPLE_NAME")
+endif()
+if(NOT DEFINED EXAMPLE_FILE)
+  message(FATAL_ERROR "Invalid build script: missing EXAMPLE_FILE")
+endif()
+
+file(TO_CMAKE_PATH "${EXAMPLE_FILE}" EXAMPLE_FILE)
+message(STATUS "Project: ${EXAMPLE_NAME}")
+message(STATUS "File   : ${EXAMPLE_FILE}")
+
+# Define project name
+project(${EXAMPLE_NAME})
+
+# Find OpenCV, you may need to set OpenCV_DIR variable
+# to the absolute path to the directory containing OpenCVConfig.cmake file
+# via the command line or GUI
+find_package(OpenCV REQUIRED)
+
+# If the package has been found, several variables will
+# be set, you can find the full list with descriptions
+# in the OpenCVConfig.cmake file.
+# Print some message showing some of them
+message(STATUS "OpenCV library status:")
+message(STATUS "    config: ${OpenCV_DIR}")
+message(STATUS "    version: ${OpenCV_VERSION}")
+message(STATUS "    libraries: ${OpenCV_LIBS}")
+message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")
+
+# Declare the executable target built from your sources
+add_executable(${EXAMPLE_NAME} "${EXAMPLE_FILE}")
+
+# Link your application with OpenCV libraries
+target_link_libraries(${EXAMPLE_NAME} PRIVATE ${OpenCV_LIBS})
diff --git a/C++/opencv-4.7.0/samples/CMakeLists.txt b/C++/opencv-4.7.0/samples/CMakeLists.txt
new file mode 100644
index 00000000..6a18b61a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/CMakeLists.txt
@@ -0,0 +1,138 @@
+if(NOT CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_LIST_DIR)
+#===================================================================================================
+#
+# Build as part of OpenCV
+#
+#===================================================================================================
+
+include("${CMAKE_CURRENT_LIST_DIR}/samples_utils.cmake")
+
+function(ocv_install_example_src relpath)
+  if(INSTALL_C_EXAMPLES)
+    file(GLOB files ${ARGN})
+    install(FILES ${files}
+            DESTINATION "${OPENCV_SAMPLES_SRC_INSTALL_PATH}/${relpath}"
+            COMPONENT samples)
+  endif()
+endfunction()
+
+if((TARGET Threads::Threads OR HAVE_PTHREAD OR MSVC OR APPLE) AND NOT OPENCV_EXAMPLES_DISABLE_THREADS)
+  add_definitions(-DHAVE_THREADS=1)
+endif()
+
+add_subdirectory(cpp)
+add_subdirectory(java/tutorial_code)
+add_subdirectory(dnn)
+add_subdirectory(gpu)
+add_subdirectory(tapi)
+add_subdirectory(opencl)
+add_subdirectory(sycl)
+if(WIN32 AND HAVE_DIRECTX)
+  add_subdirectory(directx)
+endif()
+if((NOT ANDROID) AND HAVE_OPENGL)
+  add_subdirectory(opengl)
+endif()
+if(HAVE_OPENVX)
+  add_subdirectory(openvx)
+endif()
+if(UNIX AND NOT ANDROID AND HAVE_VA)
+  add_subdirectory(va_intel)
+endif()
+if(ANDROID AND (BUILD_ANDROID_EXAMPLES OR INSTALL_ANDROID_EXAMPLES))
+  add_subdirectory(android)
+endif()
+if(INSTALL_PYTHON_EXAMPLES)
+  add_subdirectory(python)
+endif()
+# The examples in this folder will work with a semihosting version of
+# OpenCV. For more information about semihosting, see
+# https://developer.arm.com/documentation/100863/latest
+if(OPENCV_SEMIHOSTING)
+  add_subdirectory(semihosting)
+endif()
+ocv_install_example_src("." CMakeLists.txt samples_utils.cmake)
+if(INSTALL_C_EXAMPLES)
+  install(DIRECTORY data DESTINATION "${OPENCV_SAMPLES_SRC_INSTALL_PATH}" COMPONENT samples_data)
+endif()
+
+else()
+#===================================================================================================
+#
+#  Standalone mode
+#
+#===================================================================================================
+cmake_minimum_required(VERSION 3.1)
+
+project(samples C CXX)
+option(BUILD_EXAMPLES "Build samples" ON)
+
+# Assuming following installation folder structure (default for UNIX):
+# <install_root>/share/
+# └── OpenCV/  <-- OPENCV_CONFIG_INSTALL_PATH
+#     ├── OpenCVConfig.cmake  <-- file to be found by find_package
+#     ├── ...
+#     ├── samples/  <-- OPENCV_SAMPLES_SRC_INSTALL_PATH
+#     │   ├── CMakeLists.txt  <-- this file
+#     │   ├── cpp/
+find_package(OpenCV REQUIRED PATHS "..")
+
+include("${CMAKE_CURRENT_LIST_DIR}/samples_utils.cmake")
+
+function(ocv_install_example_src)
+  # not used in this branch
+endfunction()
+
+if(MSVC)
+  if(NOT ENABLE_BUILD_HARDENING)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+  endif()
+
+  if(NOT OpenCV_SHARED)
+    foreach(flag_var
+            CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+            CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
+            CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+            CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+      if(${flag_var} MATCHES "/MD")
+        string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+      endif()
+      if(${flag_var} MATCHES "/MDd")
+        string(REGEX REPLACE "/MDd" "/MTd" ${flag_var} "${${flag_var}}")
+      endif()
+    endforeach(flag_var)
+
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:msvcrt.lib /NODEFAULTLIB:msvcrtd.lib")
+    if(NOT BUILD_WITH_STATIC_CRT)
+      set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /NODEFAULTLIB:libcmt.lib")
+      set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /NODEFAULTLIB:libcmtd.lib")
+    endif()
+  endif()
+endif()
+
+if(OPENCV_EXAMPLES_DISABLE_THREADS)
+  # nothing
+elseif(MSVC OR APPLE)
+  set(HAVE_THREADS 1)
+else()
+  find_package(Threads)
+endif()
+if((TARGET Threads::Threads OR HAVE_THREADS) AND NOT OPENCV_EXAMPLES_DISABLE_THREADS)
+  set(HAVE_THREADS 1)
+  add_definitions(-DHAVE_THREADS=1)
+endif()
+
+add_subdirectory(cpp)
+if(WIN32)
+  add_subdirectory(directx)
+endif()
+add_subdirectory(dnn)
+# add_subdirectory(gpu)
+add_subdirectory(opencl)
+add_subdirectory(sycl)
+# add_subdirectory(opengl)
+# add_subdirectory(openvx)
+add_subdirectory(tapi)
+# add_subdirectory(va_intel)
+
+endif()
diff --git a/C++/opencv-4.7.0/samples/_winpack_build_sample.cmd b/C++/opencv-4.7.0/samples/_winpack_build_sample.cmd
new file mode 100644
index 00000000..06081a83
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/_winpack_build_sample.cmd
@@ -0,0 +1,239 @@
+:: Usage:
+:: - Drag & drop .cpp file on this file from Windows explorer
+:: - Run from cmd/powershell:
+::   - > _winpack_build_sample.cmd cpp\opencv_version.cpp
+:: Requires:
+:: - CMake
+:: - MSVS 2015/2017/2019
+:: (tools are searched on default paths or environment should be pre-configured)
+@echo off
+setlocal
+
+SET SCRIPT_DIR=%~dp0
+SET "OPENCV_SETUPVARS_SCRIPT=setup_vars_opencv4.cmd"
+SET "PACKAGE_BUILD_DIR=%SCRIPT_DIR%\..\..\build"
+IF NOT EXIST "%PACKAGE_BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%" (
+  :: Winpack DLDT
+  SET "PACKAGE_BUILD_DIR=%SCRIPT_DIR%\..\..\..\build"
+)
+IF NOT EXIST "%PACKAGE_BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%" (
+  set "MSG=OpenCV Winpack installation is required"
+  goto die
+)
+:: normalize path
+for %%i in ("%PACKAGE_BUILD_DIR%") do SET "PACKAGE_BUILD_DIR=%%~fi"
+
+if [%1]==[] (
+  set "MSG=Sample path is required"
+  goto die
+)
+if exist %1\* (
+  set "MSG=Only .cpp samples are allowed (not a directory): %1"
+  goto die
+)
+if NOT "%~x1" == ".cpp" (
+  set "MSG=Only .cpp samples are allowed: %~x1"
+  goto die
+)
+set SRC_FILENAME=%~dpnx1
+echo SRC_FILENAME=%SRC_FILENAME%
+call :dirname "%SRC_FILENAME%" SRC_DIR
+echo SRC_DIR=%SRC_DIR%
+set "SRC_NAME=%~n1"
+echo SRC_NAME=%SRC_NAME%
+echo ================================================================================
+
+:: Path to root 'bin' dir
+set "PATH=%PACKAGE_BUILD_DIR%\bin;%PATH%"
+
+:: Detect compiler
+cl /? >NUL 2>NUL <NUL
+if %ERRORLEVEL% == 0 (
+  goto detect_cmake
+)
+PUSHD %CD%
+
+CALL :try_call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat"
+IF ERRORLEVEL 1 (
+  CALL :try_call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+)
+IF ERRORLEVEL 1 (
+  CALL :try_call "C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Auxiliary\Build\vcvars64.bat"
+)
+
+IF ERRORLEVEL 1 (
+  CALL :try_call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\VC\Auxiliary\Build\vcvars64.bat"
+)
+IF ERRORLEVEL 1 (
+  CALL :try_call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+)
+IF ERRORLEVEL 1 (
+  CALL :try_call "C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliary\Build\vcvars64.bat"
+)
+
+IF ERRORLEVEL 1 (
+  CALL :try_call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
+)
+
+POPD
+cl /? >NUL 2>NUL <NUL
+if %ERRORLEVEL% NEQ 0 (
+  set "MSG=Can't detect Microsoft Visual Studio C++ compiler (cl.exe). MSVS 2015/2017/2019 are supported only from standard locations"
+  goto die
+)
+
+:: Detect CMake
+:detect_cmake
+cmake --version >NUL 2>NUL
+if %ERRORLEVEL% EQU 0 GOTO :CMAKE_FOUND
+
+if NOT exist "C:\Program Files\CMake\bin" GOTO CMAKE_NOT_FOUND
+set "PATH=%PATH%;C:\Program Files\CMake\bin"
+cmake --version >NUL 2>NUL
+if %ERRORLEVEL% EQU 0 GOTO :CMAKE_FOUND
+
+:CMAKE_NOT_FOUND
+set "MSG=CMake is required to build OpenCV samples. Download it from here: https://cmake.org/download/ and install into 'C:\Program Files\CMake'"
+goto die
+
+:CMAKE_FOUND
+set CMAKE_FOUND=1
+call :execute cmake --version
+echo CMake is detected
+where cmake
+
+:: Detect available MSVS version
+if NOT DEFINED VisualStudioVersion (
+  set "MSG=Can't determine MSVS version. 'VisualStudioVersion' is not defined"
+  goto die
+)
+if "%VisualStudioVersion%" == "14.0" (
+  set "CMAKE_GENERATOR=-G^"Visual Studio 14 Win64^""
+  set "BUILD_DIR_SUFFIX=.vc14"
+  if EXIST "%PACKAGE_BUILD_DIR%\x64\vc14\bin" (
+    set "PATH=%PACKAGE_BUILD_DIR%\x64\vc14\bin;%PATH%"
+  )
+) else (
+  if "%VisualStudioVersion%" == "15.0" (
+    set "CMAKE_GENERATOR=-G^"Visual Studio 15 Win64^""
+    set "BUILD_DIR_SUFFIX=.vc15"
+    set "PATH=%PATH%;%SCRIPTDIR%\..\..\build\x64\vc15\bin\"
+    if EXIST "%PACKAGE_BUILD_DIR%\x64\vc15\bin" (
+      set "PATH=%PACKAGE_BUILD_DIR%\x64\vc15\bin;%PATH%"
+    ) else (
+      if EXIST "%PACKAGE_BUILD_DIR%\x64\vc14\bin" (
+        set "PATH=%PACKAGE_BUILD_DIR%\x64\vc14\bin;%PATH%"
+      )
+    )
+  ) else (
+    if "%VisualStudioVersion%" == "16.0" (
+      echo.==========================================
+      echo.*  Note: MSVS 2019 requires CMake 3.14+  *
+      echo.==========================================
+      set "CMAKE_GENERATOR=-G^"Visual Studio 16 2019^" -A x64"
+      set "BUILD_DIR_SUFFIX=.vc16"
+      if EXIST "%PACKAGE_BUILD_DIR%\x64\vc16\bin" (
+        set "PATH=%PACKAGE_BUILD_DIR%\x64\vc16\bin;%PATH%"
+      ) else (
+        if EXIST "%PACKAGE_BUILD_DIR%\x64\vc15\bin" (
+          set "PATH=%PACKAGE_BUILD_DIR%\x64\vc15\bin;%PATH%"
+        ) else (
+          if EXIST "%PACKAGE_BUILD_DIR%\x64\vc14\bin" (
+            set "PATH=%PACKAGE_BUILD_DIR%\x64\vc14\bin;%PATH%"
+          )
+        )
+      )
+    ) else (
+      set "MSG=Unsupported MSVS version. VisualStudioVersion=%VisualStudioVersion%"
+      goto die
+    )
+  )
+)
+
+set "BUILD_DIR=%SRC_DIR%\build_%SRC_NAME%%BUILD_DIR_SUFFIX%"
+call :set_title Create build directory
+if NOT exist "%BUILD_DIR%" ( call :execute md "%BUILD_DIR%" )
+PUSHD "%BUILD_DIR%"
+if NOT exist "%BUILD_DIR%/sample" ( call :execute md "%BUILD_DIR%/sample" )
+call :execute copy /Y "%SCRIPT_DIR%/CMakeLists.example.in" "%BUILD_DIR%/sample/CMakeLists.txt"
+
+call :set_title Configuring via CMake
+call :execute cmake %CMAKE_GENERATOR% "%BUILD_DIR%\sample" -DEXAMPLE_NAME=%SRC_NAME% "-DEXAMPLE_FILE=%SRC_FILENAME%"
+if %ERRORLEVEL% NEQ 0 (
+  set "MSG=CMake configuration step failed: %BUILD_DIR%"
+  goto die
+)
+
+call :set_title Build sample project via CMake
+call :execute cmake --build . --config Release
+if %ERRORLEVEL% NEQ 0 (
+  set "MSG=Build step failed: %BUILD_DIR%"
+  goto die
+)
+
+call :set_title Launch %SRC_NAME%
+if NOT exist "%BUILD_DIR%\Release\%SRC_NAME%.exe" (
+  echo. "ERROR: Can't find executable file (build seems broken): %SRC_NAME%.exe"
+) else (
+  cd "%BUILD_DIR%\Release"
+  call :execute "%SRC_NAME%.exe" --help
+  echo ================================================================================
+  echo **  Type '%SRC_NAME%.exe' to run sample application
+  echo **  Type '%SRC_NAME%.exe --help' to get list of available options (if available)
+  echo **  Type 'start ..\%SRC_NAME%.sln' to launch MSVS IDE
+  echo **  Type 'cmake --build .. --config Release' to rebuild sample
+  echo **  Type 'exit' to exit from interactive shell and open the build directory
+  echo ================================================================================
+)
+
+call :set_title Hands-on: %SRC_NAME%
+cmd /k echo Current directory: %CD%
+
+call :set_title Done: %SRC_NAME%
+echo Opening build directory with project files...
+explorer "%BUILD_DIR%"
+
+POPD
+echo Done%
+
+pause
+exit /B 0
+
+
+::
+:: Helper routines
+::
+
+:set_title
+  title OpenCV sample: %*
+  EXIT /B 0
+
+:execute
+  echo =================================================================================
+  setlocal
+  echo %*
+  call %*
+  endlocal
+  EXIT /B %ERRORLEVEL%
+
+:dirname file resultVar
+  setlocal
+  set _dir=%~dp1
+  set _dir=%_dir:~0,-1%
+  endlocal & set %2=%_dir%
+  EXIT /B 0
+
+:try_call
+IF EXIST %1 (
+  CALL %*
+  EXIT /B
+) ELSE (
+  EXIT /B 1
+)
+
+:: 'goto die' instead of 'call'
+:die
+  TITLE OpenCV sample: ERROR: %MSG%
+  echo ERROR: %MSG%
+  pause
+  EXIT /B 1
diff --git a/C++/opencv-4.7.0/samples/_winpack_run_python_sample.cmd b/C++/opencv-4.7.0/samples/_winpack_run_python_sample.cmd
new file mode 100644
index 00000000..1ee8bb9a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/_winpack_run_python_sample.cmd
@@ -0,0 +1,150 @@
+@ECHO OFF
+SETLOCAL
+
+SET SCRIPT_DIR=%~dp0
+SET "OPENCV_SETUPVARS_SCRIPT=setup_vars_opencv4.cmd"
+SET "BUILD_DIR=%SCRIPT_DIR%\..\..\build"
+IF NOT EXIST "%BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%" (
+  :: Winpack DLDT
+  SET "BUILD_DIR=%SCRIPT_DIR%\..\..\..\build"
+)
+IF NOT EXIST "%BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%" (
+  ECHO ERROR: OpenCV Winpack installation is required
+  pause
+  exit
+)
+:: normalize path
+for %%i in ("%PACKAGE_BUILD_DIR%") do SET "PACKAGE_BUILD_DIR=%%~fi"
+
+:: Detect Python binary
+python -V 2>nul
+IF %ERRORLEVEL% EQU 0 (
+  SET PYTHON=python
+  GOTO :PYTHON_FOUND
+)
+
+CALL :QUERY_PYTHON 3.11
+IF %ERRORLEVEL% EQU 0 GOTO :PYTHON_FOUND
+CALL :QUERY_PYTHON 3.10
+IF %ERRORLEVEL% EQU 0 GOTO :PYTHON_FOUND
+CALL :QUERY_PYTHON 3.9
+IF %ERRORLEVEL% EQU 0 GOTO :PYTHON_FOUND
+CALL :QUERY_PYTHON 3.8
+IF %ERRORLEVEL% EQU 0 GOTO :PYTHON_FOUND
+CALL :QUERY_PYTHON 3.7
+IF %ERRORLEVEL% EQU 0 GOTO :PYTHON_FOUND
+CALL :QUERY_PYTHON 3.6
+IF %ERRORLEVEL% EQU 0 GOTO :PYTHON_FOUND
+CALL :QUERY_PYTHON 3.5
+IF %ERRORLEVEL% EQU 0 GOTO :PYTHON_FOUND
+CALL :QUERY_PYTHON 3.4
+IF %ERRORLEVEL% EQU 0 GOTO :PYTHON_FOUND
+CALL :QUERY_PYTHON 2.7
+IF %ERRORLEVEL% EQU 0 GOTO :PYTHON_FOUND
+GOTO :PYTHON_NOT_FOUND
+
+:QUERY_PYTHON
+SETLOCAL
+SET PY_VERSION=%1
+SET PYTHON_DIR=
+CALL :regquery "HKCU\SOFTWARE\Python\PythonCore\%PY_VERSION%\InstallPath" PYTHON_DIR
+IF EXIST "%PYTHON_DIR%\python.exe" (
+  SET "PYTHON=%PYTHON_DIR%\python.exe"
+  GOTO :QUERY_PYTHON_FOUND
+)
+CALL :regquery "HKLM\SOFTWARE\Python\PythonCore\%PY_VERSION%\InstallPath" PYTHON_DIR
+IF EXIST "%PYTHON_DIR%\python.exe" (
+  SET "PYTHON=%PYTHON_DIR%\python.exe"
+  GOTO :QUERY_PYTHON_FOUND
+)
+
+::echo Python %PY_VERSION% is not detected
+ENDLOCAL
+EXIT /B 1
+
+:QUERY_PYTHON_FOUND
+ECHO Found Python %PY_VERSION% from Windows Registry: %PYTHON%
+ENDLOCAL & SET PYTHON=%PYTHON%
+EXIT /B 0
+
+IF exist C:\Python27-x64\python.exe (
+  SET PYTHON=C:\Python27-x64\python.exe
+  GOTO :PYTHON_FOUND
+)
+IF exist C:\Python27\python.exe (
+  SET PYTHON=C:\Python27\python.exe
+  GOTO :PYTHON_FOUND
+)
+
+:PYTHON_NOT_FOUND
+ECHO ERROR: Python not found
+IF NOT DEFINED OPENCV_BATCH_MODE ( pause )
+EXIT /B
+
+:PYTHON_FOUND
+ECHO Using Python: %PYTHON%
+
+:: Don't generate unnecessary .pyc cache files
+SET PYTHONDONTWRITEBYTECODE=1
+
+IF [%1]==[] goto rundemo
+
+set SRC_FILENAME=%~dpnx1
+echo SRC_FILENAME=%SRC_FILENAME%
+call :dirname "%SRC_FILENAME%" SRC_DIR
+call :dirname "%PYTHON%" PYTHON_DIR
+PUSHD %SRC_DIR%
+
+CALL "%BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%"
+:: repair SCRIPT_DIR
+SET "SCRIPT_DIR=%~dp0"
+
+ECHO Run: %*
+%PYTHON% %*
+SET result=%errorlevel%
+IF %result% NEQ 0 (
+  IF NOT DEFINED OPENCV_BATCH_MODE (
+    SET "PATH=%PYTHON_DIR%;%PATH%"
+    echo ================================================================================
+    echo **  Type 'python sample_name.py' to run sample
+    echo **  Type 'exit' to exit from interactive shell and open the build directory
+    echo ================================================================================
+    cmd /k echo Current directory: %CD%
+  )
+)
+
+POPD
+EXIT /B %result%
+
+:rundemo
+PUSHD "%SCRIPT_DIR%\python"
+
+CALL "%BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%"
+:: repair SCRIPT_DIR
+SET "SCRIPT_DIR=%~dp0"
+
+%PYTHON% demo.py
+SET result=%errorlevel%
+IF %result% NEQ 0 (
+  IF NOT DEFINED OPENCV_BATCH_MODE ( pause )
+)
+
+POPD
+EXIT /B %result%
+
+
+:dirname file resultVar
+  setlocal
+  set _dir=%~dp1
+  set _dir=%_dir:~0,-1%
+  endlocal & set %2=%_dir%
+  EXIT /B 0
+
+:regquery name resultVar
+  SETLOCAL
+  FOR /F "tokens=*" %%A IN ('REG QUERY "%1" /reg:64 /ve 2^>NUL ^| FIND "REG_SZ"') DO SET _val=%%A
+  IF "x%_val%x"=="xx" EXIT /B 1
+  SET _val=%_val:*REG_SZ=%
+  FOR /F "tokens=*" %%A IN ("%_val%") DO SET _val=%%A
+  ENDLOCAL & SET %2=%_val%
+  EXIT /B 0
diff --git a/C++/opencv-4.7.0/samples/android/15-puzzle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/15-puzzle/AndroidManifest.xml
new file mode 100644
index 00000000..86bda2cf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/15-puzzle/AndroidManifest.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.opencv.samples.puzzle15"
+    android:versionCode="301"
+    android:versionName="3.01" >
+
+    <uses-sdk android:minSdkVersion="8"/>
+
+    <application
+        android:icon="@drawable/icon"
+        android:label="@string/app_name" >
+
+        <activity
+            android:name=".Puzzle15Activity"
+            android:label="@string/app_name"
+            android:screenOrientation="landscape"
+            android:configChanges="keyboardHidden|orientation" >
+
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/15-puzzle/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/15-puzzle/CMakeLists.txt
new file mode 100644
index 00000000..90a997f5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/15-puzzle/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(sample example-15-puzzle)
+
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
+if(TARGET ${sample})
+  add_dependencies(opencv_android_examples ${sample})
+endif()
diff --git a/C++/opencv-4.7.0/samples/android/15-puzzle/build.gradle.in b/C++/opencv-4.7.0/samples/android/15-puzzle/build.gradle.in
new file mode 100644
index 00000000..ad5c9f93
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/15-puzzle/build.gradle.in
@@ -0,0 +1,31 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
+    defaultConfig {
+        applicationId "org.opencv.samples.puzzle15"
+        minSdkVersion @ANDROID_MIN_SDK_VERSION@
+        targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
+        versionCode 301
+        versionName "3.01"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main {
+            java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            res.srcDirs = @ANDROID_SAMPLE_RES_PATH@
+            manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@'
+        }
+    }
+}
+
+dependencies {
+    //implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':opencv')
+}
diff --git a/C++/opencv-4.7.0/samples/android/15-puzzle/gradle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/15-puzzle/gradle/AndroidManifest.xml
new file mode 100644
index 00000000..14956492
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/15-puzzle/gradle/AndroidManifest.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.opencv.samples.puzzle15"
+>
+
+    <application
+        android:icon="@drawable/icon"
+        android:label="@string/app_name">
+
+        <activity
+            android:exported="true"
+            android:name=".Puzzle15Activity"
+            android:label="@string/app_name"
+            android:screenOrientation="landscape"
+            android:configChanges="keyboardHidden|orientation" >
+
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/15-puzzle/res/drawable/icon.png b/C++/opencv-4.7.0/samples/android/15-puzzle/res/drawable/icon.png
new file mode 100644
index 00000000..63045492
Binary files /dev/null and b/C++/opencv-4.7.0/samples/android/15-puzzle/res/drawable/icon.png differ
diff --git a/C++/opencv-4.7.0/samples/android/15-puzzle/res/values/strings.xml b/C++/opencv-4.7.0/samples/android/15-puzzle/res/values/strings.xml
new file mode 100644
index 00000000..1421a450
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/15-puzzle/res/values/strings.xml
@@ -0,0 +1,6 @@
+<resources>
+    <string name="app_name">OCV 15 Puzzle</string>
+    <string name="menu_toggle_tile_numbers">Show/hide tile numbers</string>
+    <string name="menu_start_new_game">Start new game</string>
+
+</resources>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/Puzzle15Activity.java b/C++/opencv-4.7.0/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/Puzzle15Activity.java
new file mode 100644
index 00000000..db888b9c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/Puzzle15Activity.java
@@ -0,0 +1,153 @@
+package org.opencv.samples.puzzle15;
+
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.CameraActivity;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Mat;
+import org.opencv.android.CameraBridgeViewBase;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener;
+import org.opencv.android.JavaCameraView;
+
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.WindowManager;
+
+import java.util.Collections;
+import java.util.List;
+
+public class Puzzle15Activity extends CameraActivity implements CvCameraViewListener, View.OnTouchListener {
+
+    private static final String  TAG = "Puzzle15::Activity";
+
+    private CameraBridgeViewBase mOpenCvCameraView;
+    private Puzzle15Processor    mPuzzle15;
+    private MenuItem             mItemHideNumbers;
+    private MenuItem             mItemStartNewGame;
+
+
+    private int                  mGameWidth;
+    private int                  mGameHeight;
+
+    private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
+
+        @Override
+        public void onManagerConnected(int status) {
+            switch (status) {
+                case LoaderCallbackInterface.SUCCESS:
+                {
+                    Log.i(TAG, "OpenCV loaded successfully");
+
+                    /* Now enable camera view to start receiving frames */
+                    mOpenCvCameraView.setOnTouchListener(Puzzle15Activity.this);
+                    mOpenCvCameraView.enableView();
+                } break;
+                default:
+                {
+                    super.onManagerConnected(status);
+                } break;
+            }
+        }
+    };
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        Log.d(TAG, "Creating and setting view");
+        mOpenCvCameraView = (CameraBridgeViewBase) new JavaCameraView(this, -1);
+        setContentView(mOpenCvCameraView);
+        mOpenCvCameraView.setVisibility(CameraBridgeViewBase.VISIBLE);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+        mPuzzle15 = new Puzzle15Processor();
+        mPuzzle15.prepareNewGame();
+    }
+
+    @Override
+    public void onPause()
+    {
+        super.onPause();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public void onResume()
+    {
+        super.onResume();
+        if (!OpenCVLoader.initDebug()) {
+            Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
+            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
+        } else {
+            Log.d(TAG, "OpenCV library found inside package. Using it!");
+            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
+        }
+    }
+
+    @Override
+    protected List<? extends CameraBridgeViewBase> getCameraViewList() {
+        return Collections.singletonList(mOpenCvCameraView);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "called onCreateOptionsMenu");
+        mItemHideNumbers = menu.add("Show/hide tile numbers");
+        mItemStartNewGame = menu.add("Start new game");
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "Menu Item selected " + item);
+        if (item == mItemStartNewGame) {
+            /* We need to start new game */
+            mPuzzle15.prepareNewGame();
+        } else if (item == mItemHideNumbers) {
+            /* We need to enable or disable drawing of the tile numbers */
+            mPuzzle15.toggleTileNumbers();
+        }
+        return true;
+    }
+
+    public void onCameraViewStarted(int width, int height) {
+        mGameWidth = width;
+        mGameHeight = height;
+        mPuzzle15.prepareGameSize(width, height);
+    }
+
+    public void onCameraViewStopped() {
+    }
+
+    public boolean onTouch(View view, MotionEvent event) {
+        int xpos, ypos;
+
+        xpos = (view.getWidth() - mGameWidth) / 2;
+        xpos = (int)event.getX() - xpos;
+
+        ypos = (view.getHeight() - mGameHeight) / 2;
+        ypos = (int)event.getY() - ypos;
+
+        if (xpos >=0 && xpos <= mGameWidth && ypos >=0  && ypos <= mGameHeight) {
+            /* click is inside the picture. Deliver this event to processor */
+            mPuzzle15.deliverTouchEvent(xpos, ypos);
+        }
+
+        return false;
+    }
+
+    public Mat onCameraFrame(Mat inputFrame) {
+        return mPuzzle15.puzzleFrame(inputFrame);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/Puzzle15Processor.java b/C++/opencv-4.7.0/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/Puzzle15Processor.java
new file mode 100644
index 00000000..83c62f46
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/Puzzle15Processor.java
@@ -0,0 +1,195 @@
+package org.opencv.samples.puzzle15;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.core.Point;
+import org.opencv.imgproc.Imgproc;
+
+import android.util.Log;
+
+
+/**
+ * This class is a controller for puzzle game.
+ * It converts the image from Camera into the shuffled image
+ */
+public class Puzzle15Processor {
+
+    private static final int GRID_SIZE = 4;
+    private static final int GRID_AREA = GRID_SIZE * GRID_SIZE;
+    private static final int GRID_EMPTY_INDEX = GRID_AREA - 1;
+    private static final String TAG = "Puzzle15Processor";
+    private static final Scalar GRID_EMPTY_COLOR = new Scalar(0x33, 0x33, 0x33, 0xFF);
+
+    private int[]   mIndexes;
+    private int[]   mTextWidths;
+    private int[]   mTextHeights;
+
+    private Mat mRgba15;
+    private Mat[] mCells15;
+    private boolean mShowTileNumbers = true;
+
+    public Puzzle15Processor() {
+        mTextWidths = new int[GRID_AREA];
+        mTextHeights = new int[GRID_AREA];
+
+        mIndexes = new int [GRID_AREA];
+
+        for (int i = 0; i < GRID_AREA; i++)
+            mIndexes[i] = i;
+    }
+
+    /* this method is intended to make processor prepared for a new game */
+    public synchronized void prepareNewGame() {
+        do {
+            shuffle(mIndexes);
+        } while (!isPuzzleSolvable());
+    }
+
+    /* This method is to make the processor know the size of the frames that
+     * will be delivered via puzzleFrame.
+     * If the frames will be different size - then the result is unpredictable
+     */
+    public synchronized void prepareGameSize(int width, int height) {
+        mRgba15 = new Mat(height, width, CvType.CV_8UC4);
+        mCells15 = new Mat[GRID_AREA];
+
+        for (int i = 0; i < GRID_SIZE; i++) {
+            for (int j = 0; j < GRID_SIZE; j++) {
+                int k = i * GRID_SIZE + j;
+                mCells15[k] = mRgba15.submat(i * height / GRID_SIZE, (i + 1) * height / GRID_SIZE, j * width / GRID_SIZE, (j + 1) * width / GRID_SIZE);
+            }
+        }
+
+        for (int i = 0; i < GRID_AREA; i++) {
+            Size s = Imgproc.getTextSize(Integer.toString(i + 1), 3/* CV_FONT_HERSHEY_COMPLEX */, 1, 2, null);
+            mTextHeights[i] = (int) s.height;
+            mTextWidths[i] = (int) s.width;
+        }
+    }
+
+    /* this method to be called from the outside. it processes the frame and shuffles
+     * the tiles as specified by mIndexes array
+     */
+    public synchronized Mat puzzleFrame(Mat inputPicture) {
+        Mat[] cells = new Mat[GRID_AREA];
+        int rows = inputPicture.rows();
+        int cols = inputPicture.cols();
+
+        rows = rows - rows%4;
+        cols = cols - cols%4;
+
+        for (int i = 0; i < GRID_SIZE; i++) {
+            for (int j = 0; j < GRID_SIZE; j++) {
+                int k = i * GRID_SIZE + j;
+                cells[k] = inputPicture.submat(i * inputPicture.rows() / GRID_SIZE, (i + 1) * inputPicture.rows() / GRID_SIZE, j * inputPicture.cols()/ GRID_SIZE, (j + 1) * inputPicture.cols() / GRID_SIZE);
+            }
+        }
+
+        rows = rows - rows%4;
+        cols = cols - cols%4;
+
+        // copy shuffled tiles
+        for (int i = 0; i < GRID_AREA; i++) {
+            int idx = mIndexes[i];
+            if (idx == GRID_EMPTY_INDEX)
+                mCells15[i].setTo(GRID_EMPTY_COLOR);
+            else {
+                cells[idx].copyTo(mCells15[i]);
+                if (mShowTileNumbers) {
+                    Imgproc.putText(mCells15[i], Integer.toString(1 + idx), new Point((cols / GRID_SIZE - mTextWidths[idx]) / 2,
+                            (rows / GRID_SIZE + mTextHeights[idx]) / 2), 3/* CV_FONT_HERSHEY_COMPLEX */, 1, new Scalar(255, 0, 0, 255), 2);
+                }
+            }
+        }
+
+        for (int i = 0; i < GRID_AREA; i++)
+            cells[i].release();
+
+        drawGrid(cols, rows, mRgba15);
+
+        return mRgba15;
+    }
+
+    public void toggleTileNumbers() {
+        mShowTileNumbers = !mShowTileNumbers;
+    }
+
+    public void deliverTouchEvent(int x, int y) {
+        int rows = mRgba15.rows();
+        int cols = mRgba15.cols();
+
+        int row = (int) Math.floor(y * GRID_SIZE / rows);
+        int col = (int) Math.floor(x * GRID_SIZE / cols);
+
+        if (row < 0 || row >= GRID_SIZE || col < 0 || col >= GRID_SIZE) {
+            Log.e(TAG, "It is not expected to get touch event outside of picture");
+            return ;
+        }
+
+        int idx = row * GRID_SIZE + col;
+        int idxtoswap = -1;
+
+        // left
+        if (idxtoswap < 0 && col > 0)
+            if (mIndexes[idx - 1] == GRID_EMPTY_INDEX)
+                idxtoswap = idx - 1;
+        // right
+        if (idxtoswap < 0 && col < GRID_SIZE - 1)
+            if (mIndexes[idx + 1] == GRID_EMPTY_INDEX)
+                idxtoswap = idx + 1;
+        // top
+        if (idxtoswap < 0 && row > 0)
+            if (mIndexes[idx - GRID_SIZE] == GRID_EMPTY_INDEX)
+                idxtoswap = idx - GRID_SIZE;
+        // bottom
+        if (idxtoswap < 0 && row < GRID_SIZE - 1)
+            if (mIndexes[idx + GRID_SIZE] == GRID_EMPTY_INDEX)
+                idxtoswap = idx + GRID_SIZE;
+
+        // swap
+        if (idxtoswap >= 0) {
+            synchronized (this) {
+                int touched = mIndexes[idx];
+                mIndexes[idx] = mIndexes[idxtoswap];
+                mIndexes[idxtoswap] = touched;
+            }
+        }
+    }
+
+    private void drawGrid(int cols, int rows, Mat drawMat) {
+        for (int i = 1; i < GRID_SIZE; i++) {
+            Imgproc.line(drawMat, new Point(0, i * rows / GRID_SIZE), new Point(cols, i * rows / GRID_SIZE), new Scalar(0, 255, 0, 255), 3);
+            Imgproc.line(drawMat, new Point(i * cols / GRID_SIZE, 0), new Point(i * cols / GRID_SIZE, rows), new Scalar(0, 255, 0, 255), 3);
+        }
+    }
+
+    private static void shuffle(int[] array) {
+        for (int i = array.length; i > 1; i--) {
+            int temp = array[i - 1];
+            int randIx = (int) (Math.random() * i);
+            array[i - 1] = array[randIx];
+            array[randIx] = temp;
+        }
+    }
+
+    private boolean isPuzzleSolvable() {
+
+        int sum = 0;
+        for (int i = 0; i < GRID_AREA; i++) {
+            if (mIndexes[i] == GRID_EMPTY_INDEX)
+                sum += (i / GRID_SIZE) + 1;
+            else {
+                int smaller = 0;
+                for (int j = i + 1; j < GRID_AREA; j++) {
+                    if (mIndexes[j] < mIndexes[i])
+                        smaller++;
+                }
+                sum += smaller;
+            }
+        }
+        return sum % 2 == 0;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/CMakeLists.txt
new file mode 100644
index 00000000..360f1aa2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/CMakeLists.txt
@@ -0,0 +1,17 @@
+# ----------------------------------------------------------------------------
+#  CMake file for Android samples. See root CMakeLists.txt
+#
+# ----------------------------------------------------------------------------
+add_custom_target(opencv_android_examples)
+
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations)
+
+add_subdirectory(15-puzzle)
+add_subdirectory(face-detection)
+add_subdirectory(image-manipulations)
+add_subdirectory(camera-calibration)
+add_subdirectory(color-blob-detection)
+add_subdirectory(tutorial-1-camerapreview)
+add_subdirectory(tutorial-2-mixedprocessing)
+add_subdirectory(tutorial-3-cameracontrol)
+add_subdirectory(tutorial-4-opencl)
diff --git a/C++/opencv-4.7.0/samples/android/build.gradle.in b/C++/opencv-4.7.0/samples/android/build.gradle.in
new file mode 100644
index 00000000..f36fe216
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/build.gradle.in
@@ -0,0 +1,104 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+
+    repositories {
+        google()
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:@ANDROID_GRADLE_PLUGIN_VERSION@'
+        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:@KOTLIN_PLUGIN_VERSION@'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        jcenter()
+    }
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}
+
+//allprojects {
+//    gradle.projectsEvaluated {
+//        tasks.withType(JavaCompile) {
+//            options.compilerArgs << "-Xlint:unchecked"
+//            options.compilerArgs << "-Xlint:deprecation"
+//        }
+//    }
+//}
+
+def opencv_strict_build_configuration = @ANDROID_STRICT_BUILD_CONFIGURATION@;
+
+gradle.afterProject { project ->
+    if (project.pluginManager.hasPlugin('com.android.application')
+            || project.pluginManager.hasPlugin('com.android.library')
+            || project.pluginManager.hasPlugin('com.android.test')
+            || project.pluginManager.hasPlugin('com.android.feature') ) {
+        if (true) {
+            gradle.println("Override build ABIs for the project ${project.name}")
+            project.android {
+                splits {
+                    abi {
+                        enable true
+                        universalApk false
+                        @ANDROID_ABI_FILTER@
+                    }
+                }
+            }
+        }
+
+        if (true) {
+            gradle.println("Override lintOptions for the project ${project.name}")
+            project.android {
+                lintOptions {
+                    // checkReleaseBuilds false
+                    abortOnError false
+                }
+            }
+        }
+
+        // (you still need to re-build OpenCV with debug information to debug it)
+        if (true) {
+            gradle.println("Override doNotStrip-debug for the project ${project.name}")
+            project.android {
+                buildTypes {
+                    debug {
+                        packagingOptions {
+                            doNotStrip '**/*.so'  // controlled by OpenCV CMake scripts
+                        }
+                    }
+                }
+            }
+        }
+        if (false || project.hasProperty("doNotStrip")) {
+            gradle.println("Override doNotStrip-release for the project ${project.name}")
+            project.android {
+                buildTypes {
+                    release {
+                        packagingOptions {
+                            doNotStrip '**/*.so'  // controlled by OpenCV CMake scripts
+                        }
+                    }
+                }
+            }
+        }
+
+        // Android Gradle Plugin (AGP) 3.5+ is required
+        // https://github.com/android/ndk-samples/wiki/Configure-NDK-Path
+        def isNdkVersionSupported = project.android.metaClass.getProperties().find { it.name == 'ndkVersion' } != null
+        if ((false || opencv_strict_build_configuration) && isNdkVersionSupported) {
+            gradle.println("Override ndkVersion for the project ${project.name}")
+            project.android {
+                ndkVersion '@ANDROID_NDK_REVISION@'
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/camera-calibration/CMakeLists.txt
new file mode 100644
index 00000000..81483c6c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/camera-calibration/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(sample example-camera-calibration)
+
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
+if(TARGET ${sample})
+  add_dependencies(opencv_android_examples ${sample})
+endif()
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/build.gradle.in b/C++/opencv-4.7.0/samples/android/camera-calibration/build.gradle.in
new file mode 100644
index 00000000..d62b1518
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/camera-calibration/build.gradle.in
@@ -0,0 +1,31 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
+    defaultConfig {
+        applicationId "org.opencv.samples.cameracalibration"
+        minSdkVersion @ANDROID_MIN_SDK_VERSION@
+        targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
+        versionCode 301
+        versionName "3.01"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main {
+            java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            res.srcDirs = @ANDROID_SAMPLE_RES_PATH@
+            manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@'
+        }
+    }
+}
+
+dependencies {
+    //implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':opencv')
+}
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/gradle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/camera-calibration/gradle/AndroidManifest.xml
new file mode 100644
index 00000000..d1640199
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/camera-calibration/gradle/AndroidManifest.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="org.opencv.samples.cameracalibration"
+>
+
+    <application
+        android:label="@string/app_name"
+        android:icon="@drawable/icon">
+
+        <activity
+                  android:exported="true"
+                  android:name="CameraCalibrationActivity"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true"
+                      android:normalScreens="true"
+                      android:largeScreens="true"
+                      android:anyDensity="true" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/res/drawable/icon.png b/C++/opencv-4.7.0/samples/android/camera-calibration/res/drawable/icon.png
new file mode 100644
index 00000000..79ad9484
Binary files /dev/null and b/C++/opencv-4.7.0/samples/android/camera-calibration/res/drawable/icon.png differ
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/res/layout/camera_calibration_surface_view.xml b/C++/opencv-4.7.0/samples/android/camera-calibration/res/layout/camera_calibration_surface_view.xml
new file mode 100644
index 00000000..79346654
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/camera-calibration/res/layout/camera_calibration_surface_view.xml
@@ -0,0 +1,12 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    xmlns:opencv="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/camera_calibration_java_surface_view" />
+
+</LinearLayout>
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/res/menu/calibration.xml b/C++/opencv-4.7.0/samples/android/camera-calibration/res/menu/calibration.xml
new file mode 100644
index 00000000..f766aece
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/camera-calibration/res/menu/calibration.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android" >
+    <group android:checkableBehavior="single">
+        <item android:id="@+id/calibrate"
+              android:title="@string/action_calibrate"
+              android:showAsAction="ifRoom|withText" />
+        <item android:id="@+id/preview_mode"
+              android:title="@string/preview_mode">
+              <menu>
+                  <group android:checkableBehavior="single">
+                      <item android:id="@+id/calibration"
+                            android:title="@string/calibration"
+                            android:checked="true" />
+                      <item android:id="@+id/undistortion"
+                            android:title="@string/undistortion" />
+                      <item android:id="@+id/comparison"
+                            android:title="@string/comparison" />
+                  </group>
+              </menu>
+        </item>
+    </group>
+</menu>
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/res/values/strings.xml b/C++/opencv-4.7.0/samples/android/camera-calibration/res/values/strings.xml
new file mode 100644
index 00000000..401c2449
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/camera-calibration/res/values/strings.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <string name="app_name">OCV Camera Calibration</string>
+    <string name="action_calibrate">Calibrate</string>
+    <string name="calibration">Calibration</string>
+    <string name="undistortion">Undistortion</string>
+    <string name="comparison">Comparison</string>
+    <string name="preview_mode">Preview mode</string>
+    <string name="calibration_successful">Successfully calibrated!\nAvg. re-projection error:</string>
+    <string name="calibration_unsuccessful">Unsuccessful calibration.\nTry again</string>
+    <string name="more_samples">Please, capture more samples</string>
+    <string name="calibrating">Calibrating...</string>
+    <string name="please_wait">Please, wait</string>
+    <string name="original">Original</string>
+    <string name="undistorted">Undistorted</string>
+
+</resources>
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/CalibrationResult.java b/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/CalibrationResult.java
new file mode 100644
index 00000000..a4c77e4c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/CalibrationResult.java
@@ -0,0 +1,69 @@
+package org.opencv.samples.cameracalibration;
+
+import org.opencv.core.Mat;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+public abstract class CalibrationResult {
+    private static final String TAG = "OCV::CalibrationResult";
+
+    private static final int CAMERA_MATRIX_ROWS = 3;
+    private static final int CAMERA_MATRIX_COLS = 3;
+    private static final int DISTORTION_COEFFICIENTS_SIZE = 5;
+
+    public static void save(Activity activity, Mat cameraMatrix, Mat distortionCoefficients) {
+        SharedPreferences sharedPref = activity.getPreferences(Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = sharedPref.edit();
+
+        double[] cameraMatrixArray = new double[CAMERA_MATRIX_ROWS * CAMERA_MATRIX_COLS];
+        cameraMatrix.get(0,  0, cameraMatrixArray);
+        for (int i = 0; i < CAMERA_MATRIX_ROWS; i++) {
+            for (int j = 0; j < CAMERA_MATRIX_COLS; j++) {
+                int id = i * CAMERA_MATRIX_ROWS + j;
+                editor.putFloat(Integer.toString(id), (float)cameraMatrixArray[id]);
+            }
+        }
+
+        double[] distortionCoefficientsArray = new double[DISTORTION_COEFFICIENTS_SIZE];
+        distortionCoefficients.get(0, 0, distortionCoefficientsArray);
+        int shift = CAMERA_MATRIX_ROWS * CAMERA_MATRIX_COLS;
+        for (int i = shift; i < DISTORTION_COEFFICIENTS_SIZE + shift; i++) {
+            editor.putFloat(Integer.toString(i), (float)distortionCoefficientsArray[i-shift]);
+        }
+
+        editor.apply();
+        Log.i(TAG, "Saved camera matrix: " + cameraMatrix.dump());
+        Log.i(TAG, "Saved distortion coefficients: " + distortionCoefficients.dump());
+    }
+
+    public static boolean tryLoad(Activity activity, Mat cameraMatrix, Mat distortionCoefficients) {
+        SharedPreferences sharedPref = activity.getPreferences(Context.MODE_PRIVATE);
+        if (sharedPref.getFloat("0", -1) == -1) {
+            Log.i(TAG, "No previous calibration results found");
+            return false;
+        }
+
+        double[] cameraMatrixArray = new double[CAMERA_MATRIX_ROWS * CAMERA_MATRIX_COLS];
+        for (int i = 0; i < CAMERA_MATRIX_ROWS; i++) {
+            for (int j = 0; j < CAMERA_MATRIX_COLS; j++) {
+                int id = i * CAMERA_MATRIX_ROWS + j;
+                cameraMatrixArray[id] = sharedPref.getFloat(Integer.toString(id), -1);
+            }
+        }
+        cameraMatrix.put(0, 0, cameraMatrixArray);
+        Log.i(TAG, "Loaded camera matrix: " + cameraMatrix.dump());
+
+        double[] distortionCoefficientsArray = new double[DISTORTION_COEFFICIENTS_SIZE];
+        int shift = CAMERA_MATRIX_ROWS * CAMERA_MATRIX_COLS;
+        for (int i = shift; i < DISTORTION_COEFFICIENTS_SIZE + shift; i++) {
+            distortionCoefficientsArray[i - shift] = sharedPref.getFloat(Integer.toString(i), -1);
+        }
+        distortionCoefficients.put(0, 0, distortionCoefficientsArray);
+        Log.i(TAG, "Loaded distortion coefficients: " + distortionCoefficients.dump());
+
+        return true;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/CameraCalibrationActivity.java b/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/CameraCalibrationActivity.java
new file mode 100644
index 00000000..30a6ad9c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/CameraCalibrationActivity.java
@@ -0,0 +1,235 @@
+// This sample is based on "Camera calibration With OpenCV" tutorial:
+// https://docs.opencv.org/4.x/d4/d94/tutorial_camera_calibration.html
+//
+// It uses standard OpenCV asymmetric circles grid pattern 11x4:
+// https://github.com/opencv/opencv/blob/4.x/doc/acircles_pattern.png
+// The results are the camera matrix and 5 distortion coefficients.
+//
+// Tap on highlighted pattern to capture pattern corners for calibration.
+// Move pattern along the whole screen and capture data.
+//
+// When you've captured necessary amount of pattern corners (usually ~20 are enough),
+// press "Calibrate" button for performing camera calibration.
+
+package org.opencv.samples.cameracalibration;
+
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.CameraActivity;
+import org.opencv.android.CameraBridgeViewBase;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Mat;
+
+import android.app.ProgressDialog;
+import android.content.res.Resources;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.View.OnTouchListener;
+import android.view.WindowManager;
+import android.widget.Toast;
+
+import java.util.Collections;
+import java.util.List;
+
+public class CameraCalibrationActivity extends CameraActivity implements CvCameraViewListener2, OnTouchListener {
+    private static final String TAG = "OCVSample::Activity";
+
+    private CameraBridgeViewBase mOpenCvCameraView;
+    private CameraCalibrator mCalibrator;
+    private OnCameraFrameRender mOnCameraFrameRender;
+    private Menu mMenu;
+    private int mWidth;
+    private int mHeight;
+
+    private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
+        @Override
+        public void onManagerConnected(int status) {
+            switch (status) {
+            case LoaderCallbackInterface.SUCCESS:
+            {
+                Log.i(TAG, "OpenCV loaded successfully");
+                mOpenCvCameraView.enableView();
+                mOpenCvCameraView.setOnTouchListener(CameraCalibrationActivity.this);
+            } break;
+            default:
+            {
+                super.onManagerConnected(status);
+            } break;
+            }
+        }
+    };
+
+    public CameraCalibrationActivity() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "called onCreate");
+        super.onCreate(savedInstanceState);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.camera_calibration_surface_view);
+
+        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.camera_calibration_java_surface_view);
+        mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
+    @Override
+    public void onPause()
+    {
+        super.onPause();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public void onResume()
+    {
+        super.onResume();
+        if (!OpenCVLoader.initDebug()) {
+            Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
+            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
+        } else {
+            Log.d(TAG, "OpenCV library found inside package. Using it!");
+            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
+        }
+    }
+
+    @Override
+    protected List<? extends CameraBridgeViewBase> getCameraViewList() {
+        return Collections.singletonList(mOpenCvCameraView);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        super.onCreateOptionsMenu(menu);
+        getMenuInflater().inflate(R.menu.calibration, menu);
+        mMenu = menu;
+        return true;
+    }
+
+    @Override
+    public boolean onPrepareOptionsMenu (Menu menu) {
+        super.onPrepareOptionsMenu(menu);
+        menu.findItem(R.id.preview_mode).setEnabled(true);
+        if (mCalibrator != null && !mCalibrator.isCalibrated()) {
+            menu.findItem(R.id.preview_mode).setEnabled(false);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+        case R.id.calibration:
+            mOnCameraFrameRender =
+                new OnCameraFrameRender(new CalibrationFrameRender(mCalibrator));
+            item.setChecked(true);
+            return true;
+        case R.id.undistortion:
+            mOnCameraFrameRender =
+                new OnCameraFrameRender(new UndistortionFrameRender(mCalibrator));
+            item.setChecked(true);
+            return true;
+        case R.id.comparison:
+            mOnCameraFrameRender =
+                new OnCameraFrameRender(new ComparisonFrameRender(mCalibrator, mWidth, mHeight, getResources()));
+            item.setChecked(true);
+            return true;
+        case R.id.calibrate:
+            final Resources res = getResources();
+            if (mCalibrator.getCornersBufferSize() < 2) {
+                (Toast.makeText(this, res.getString(R.string.more_samples), Toast.LENGTH_SHORT)).show();
+                return true;
+            }
+
+            mOnCameraFrameRender = new OnCameraFrameRender(new PreviewFrameRender());
+            new AsyncTask<Void, Void, Void>() {
+                private ProgressDialog calibrationProgress;
+
+                @Override
+                protected void onPreExecute() {
+                    calibrationProgress = new ProgressDialog(CameraCalibrationActivity.this);
+                    calibrationProgress.setTitle(res.getString(R.string.calibrating));
+                    calibrationProgress.setMessage(res.getString(R.string.please_wait));
+                    calibrationProgress.setCancelable(false);
+                    calibrationProgress.setIndeterminate(true);
+                    calibrationProgress.show();
+                }
+
+                @Override
+                protected Void doInBackground(Void... arg0) {
+                    mCalibrator.calibrate();
+                    return null;
+                }
+
+                @Override
+                protected void onPostExecute(Void result) {
+                    calibrationProgress.dismiss();
+                    mCalibrator.clearCorners();
+                    mOnCameraFrameRender = new OnCameraFrameRender(new CalibrationFrameRender(mCalibrator));
+                    String resultMessage = (mCalibrator.isCalibrated()) ?
+                            res.getString(R.string.calibration_successful)  + " " + mCalibrator.getAvgReprojectionError() :
+                            res.getString(R.string.calibration_unsuccessful);
+                    (Toast.makeText(CameraCalibrationActivity.this, resultMessage, Toast.LENGTH_SHORT)).show();
+
+                    if (mCalibrator.isCalibrated()) {
+                        CalibrationResult.save(CameraCalibrationActivity.this,
+                                mCalibrator.getCameraMatrix(), mCalibrator.getDistortionCoefficients());
+                    }
+                }
+            }.execute();
+            return true;
+        default:
+            return super.onOptionsItemSelected(item);
+        }
+    }
+
+    public void onCameraViewStarted(int width, int height) {
+        if (mWidth != width || mHeight != height) {
+            mWidth = width;
+            mHeight = height;
+            mCalibrator = new CameraCalibrator(mWidth, mHeight);
+            if (CalibrationResult.tryLoad(this, mCalibrator.getCameraMatrix(), mCalibrator.getDistortionCoefficients())) {
+                mCalibrator.setCalibrated();
+            } else {
+                if (mMenu != null && !mCalibrator.isCalibrated()) {
+                    mMenu.findItem(R.id.preview_mode).setEnabled(false);
+                }
+            }
+
+            mOnCameraFrameRender = new OnCameraFrameRender(new CalibrationFrameRender(mCalibrator));
+        }
+    }
+
+    public void onCameraViewStopped() {
+    }
+
+    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
+        return mOnCameraFrameRender.render(inputFrame);
+    }
+
+    @Override
+    public boolean onTouch(View v, MotionEvent event) {
+        Log.d(TAG, "onTouch invoked");
+
+        mCalibrator.addCorners();
+        return false;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/CameraCalibrator.java b/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/CameraCalibrator.java
new file mode 100644
index 00000000..aa2c1b5e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/CameraCalibrator.java
@@ -0,0 +1,170 @@
+package org.opencv.samples.cameracalibration;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.calib3d.Calib3d;
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfDouble;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.MatOfPoint3f;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.imgproc.Imgproc;
+
+import android.util.Log;
+
+public class CameraCalibrator {
+    private static final String TAG = "OCV::CameraCalibrator";
+
+    private final Size mPatternSize = new Size(4, 11);
+    private final int mCornersSize = (int)(mPatternSize.width * mPatternSize.height);
+    private boolean mPatternWasFound = false;
+    private MatOfPoint2f mCorners = new MatOfPoint2f();
+    private List<Mat> mCornersBuffer = new ArrayList<>();
+    private boolean mIsCalibrated = false;
+
+    private Mat mCameraMatrix = new Mat();
+    private Mat mDistortionCoefficients = new Mat();
+    private int mFlags;
+    private double mRms;
+    private double mSquareSize = 0.0181;
+    private Size mImageSize;
+
+    public CameraCalibrator(int width, int height) {
+        mImageSize = new Size(width, height);
+        mFlags = Calib3d.CALIB_FIX_PRINCIPAL_POINT +
+                 Calib3d.CALIB_ZERO_TANGENT_DIST +
+                 Calib3d.CALIB_FIX_ASPECT_RATIO +
+                 Calib3d.CALIB_FIX_K4 +
+                 Calib3d.CALIB_FIX_K5;
+        Mat.eye(3, 3, CvType.CV_64FC1).copyTo(mCameraMatrix);
+        mCameraMatrix.put(0, 0, 1.0);
+        Mat.zeros(5, 1, CvType.CV_64FC1).copyTo(mDistortionCoefficients);
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    public void processFrame(Mat grayFrame, Mat rgbaFrame) {
+        findPattern(grayFrame);
+        renderFrame(rgbaFrame);
+    }
+
+    public void calibrate() {
+        ArrayList<Mat> rvecs = new ArrayList<>();
+        ArrayList<Mat> tvecs = new ArrayList<>();
+        Mat reprojectionErrors = new Mat();
+        ArrayList<Mat> objectPoints = new ArrayList<>();
+        objectPoints.add(Mat.zeros(mCornersSize, 1, CvType.CV_32FC3));
+        calcBoardCornerPositions(objectPoints.get(0));
+        for (int i = 1; i < mCornersBuffer.size(); i++) {
+            objectPoints.add(objectPoints.get(0));
+        }
+
+        Calib3d.calibrateCamera(objectPoints, mCornersBuffer, mImageSize,
+                mCameraMatrix, mDistortionCoefficients, rvecs, tvecs, mFlags);
+
+        mIsCalibrated = Core.checkRange(mCameraMatrix)
+                && Core.checkRange(mDistortionCoefficients);
+
+        mRms = computeReprojectionErrors(objectPoints, rvecs, tvecs, reprojectionErrors);
+        Log.i(TAG, String.format("Average re-projection error: %f", mRms));
+        Log.i(TAG, "Camera matrix: " + mCameraMatrix.dump());
+        Log.i(TAG, "Distortion coefficients: " + mDistortionCoefficients.dump());
+    }
+
+    public void clearCorners() {
+        mCornersBuffer.clear();
+    }
+
+    private void calcBoardCornerPositions(Mat corners) {
+        final int cn = 3;
+        float[] positions = new float[mCornersSize * cn];
+
+        for (int i = 0; i < mPatternSize.height; i++) {
+            for (int j = 0; j < mPatternSize.width * cn; j += cn) {
+                positions[(int) (i * mPatternSize.width * cn + j + 0)] =
+                        (2 * (j / cn) + i % 2) * (float) mSquareSize;
+                positions[(int) (i * mPatternSize.width * cn + j + 1)] =
+                        i * (float) mSquareSize;
+                positions[(int) (i * mPatternSize.width * cn + j + 2)] = 0;
+            }
+        }
+        corners.create(mCornersSize, 1, CvType.CV_32FC3);
+        corners.put(0, 0, positions);
+    }
+
+    private double computeReprojectionErrors(List<Mat> objectPoints,
+            List<Mat> rvecs, List<Mat> tvecs, Mat perViewErrors) {
+        MatOfPoint2f cornersProjected = new MatOfPoint2f();
+        double totalError = 0;
+        double error;
+        float[] viewErrors = new float[objectPoints.size()];
+
+        MatOfDouble distortionCoefficients = new MatOfDouble(mDistortionCoefficients);
+        int totalPoints = 0;
+        for (int i = 0; i < objectPoints.size(); i++) {
+            MatOfPoint3f points = new MatOfPoint3f(objectPoints.get(i));
+            Calib3d.projectPoints(points, rvecs.get(i), tvecs.get(i),
+                    mCameraMatrix, distortionCoefficients, cornersProjected);
+            error = Core.norm(mCornersBuffer.get(i), cornersProjected, Core.NORM_L2);
+
+            int n = objectPoints.get(i).rows();
+            viewErrors[i] = (float) Math.sqrt(error * error / n);
+            totalError  += error * error;
+            totalPoints += n;
+        }
+        perViewErrors.create(objectPoints.size(), 1, CvType.CV_32FC1);
+        perViewErrors.put(0, 0, viewErrors);
+
+        return Math.sqrt(totalError / totalPoints);
+    }
+
+    private void findPattern(Mat grayFrame) {
+        mPatternWasFound = Calib3d.findCirclesGrid(grayFrame, mPatternSize,
+                mCorners, Calib3d.CALIB_CB_ASYMMETRIC_GRID);
+    }
+
+    public void addCorners() {
+        if (mPatternWasFound) {
+            mCornersBuffer.add(mCorners.clone());
+        }
+    }
+
+    private void drawPoints(Mat rgbaFrame) {
+        Calib3d.drawChessboardCorners(rgbaFrame, mPatternSize, mCorners, mPatternWasFound);
+    }
+
+    private void renderFrame(Mat rgbaFrame) {
+        drawPoints(rgbaFrame);
+
+        Imgproc.putText(rgbaFrame, "Captured: " + mCornersBuffer.size(), new Point(rgbaFrame.cols() / 3 * 2, rgbaFrame.rows() * 0.1),
+                Imgproc.FONT_HERSHEY_SIMPLEX, 1.0, new Scalar(255, 255, 0));
+    }
+
+    public Mat getCameraMatrix() {
+        return mCameraMatrix;
+    }
+
+    public Mat getDistortionCoefficients() {
+        return mDistortionCoefficients;
+    }
+
+    public int getCornersBufferSize() {
+        return mCornersBuffer.size();
+    }
+
+    public double getAvgReprojectionError() {
+        return mRms;
+    }
+
+    public boolean isCalibrated() {
+        return mIsCalibrated;
+    }
+
+    public void setCalibrated() {
+        mIsCalibrated = true;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/OnCameraFrameRender.java b/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/OnCameraFrameRender.java
new file mode 100644
index 00000000..a89cdf6a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/OnCameraFrameRender.java
@@ -0,0 +1,103 @@
+package org.opencv.samples.cameracalibration;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
+import org.opencv.calib3d.Calib3d;
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Range;
+import org.opencv.core.Scalar;
+import org.opencv.imgproc.Imgproc;
+
+import android.content.res.Resources;
+
+abstract class FrameRender {
+    protected CameraCalibrator mCalibrator;
+
+    public abstract Mat render(CvCameraViewFrame inputFrame);
+}
+
+class PreviewFrameRender extends FrameRender {
+    @Override
+    public Mat render(CvCameraViewFrame inputFrame) {
+        return inputFrame.rgba();
+    }
+}
+
+class CalibrationFrameRender extends FrameRender {
+    public CalibrationFrameRender(CameraCalibrator calibrator) {
+        mCalibrator = calibrator;
+    }
+
+    @Override
+    public Mat render(CvCameraViewFrame inputFrame) {
+        Mat rgbaFrame = inputFrame.rgba();
+        Mat grayFrame = inputFrame.gray();
+        mCalibrator.processFrame(grayFrame, rgbaFrame);
+
+        return rgbaFrame;
+    }
+}
+
+class UndistortionFrameRender extends FrameRender {
+    public UndistortionFrameRender(CameraCalibrator calibrator) {
+        mCalibrator = calibrator;
+    }
+
+    @Override
+    public Mat render(CvCameraViewFrame inputFrame) {
+        Mat renderedFrame = new Mat(inputFrame.rgba().size(), inputFrame.rgba().type());
+        Calib3d.undistort(inputFrame.rgba(), renderedFrame,
+                mCalibrator.getCameraMatrix(), mCalibrator.getDistortionCoefficients());
+
+        return renderedFrame;
+    }
+}
+
+class ComparisonFrameRender extends FrameRender {
+    private int mWidth;
+    private int mHeight;
+    private Resources mResources;
+    public ComparisonFrameRender(CameraCalibrator calibrator, int width, int height, Resources resources) {
+        mCalibrator = calibrator;
+        mWidth = width;
+        mHeight = height;
+        mResources = resources;
+    }
+
+    @Override
+    public Mat render(CvCameraViewFrame inputFrame) {
+        Mat undistortedFrame = new Mat(inputFrame.rgba().size(), inputFrame.rgba().type());
+        Calib3d.undistort(inputFrame.rgba(), undistortedFrame,
+                mCalibrator.getCameraMatrix(), mCalibrator.getDistortionCoefficients());
+
+        Mat comparisonFrame = inputFrame.rgba();
+        undistortedFrame.colRange(new Range(0, mWidth / 2)).copyTo(comparisonFrame.colRange(new Range(mWidth / 2, mWidth)));
+        List<MatOfPoint> border = new ArrayList<MatOfPoint>();
+        final int shift = (int)(mWidth * 0.005);
+        border.add(new MatOfPoint(new Point(mWidth / 2 - shift, 0), new Point(mWidth / 2 + shift, 0),
+                new Point(mWidth / 2 + shift, mHeight), new Point(mWidth / 2 - shift, mHeight)));
+        Imgproc.fillPoly(comparisonFrame, border, new Scalar(255, 255, 255));
+
+        Imgproc.putText(comparisonFrame, mResources.getString(R.string.original), new Point(mWidth * 0.1, mHeight * 0.1),
+                Imgproc.FONT_HERSHEY_SIMPLEX, 1.0, new Scalar(255, 255, 0));
+        Imgproc.putText(comparisonFrame, mResources.getString(R.string.undistorted), new Point(mWidth * 0.6, mHeight * 0.1),
+                Imgproc.FONT_HERSHEY_SIMPLEX, 1.0, new Scalar(255, 255, 0));
+
+        return comparisonFrame;
+    }
+}
+
+class OnCameraFrameRender {
+    private FrameRender mFrameRender;
+    public OnCameraFrameRender(FrameRender frameRender) {
+        mFrameRender = frameRender;
+    }
+    public Mat render(CvCameraViewFrame inputFrame) {
+        return mFrameRender.render(inputFrame);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/color-blob-detection/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/color-blob-detection/CMakeLists.txt
new file mode 100644
index 00000000..3f590431
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/color-blob-detection/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(sample example-color-blob-detection)
+
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
+if(TARGET ${sample})
+  add_dependencies(opencv_android_examples ${sample})
+endif()
diff --git a/C++/opencv-4.7.0/samples/android/color-blob-detection/build.gradle.in b/C++/opencv-4.7.0/samples/android/color-blob-detection/build.gradle.in
new file mode 100644
index 00000000..8900e25c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/color-blob-detection/build.gradle.in
@@ -0,0 +1,31 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
+    defaultConfig {
+        applicationId "org.opencv.samples.colorblobdetect"
+        minSdkVersion @ANDROID_MIN_SDK_VERSION@
+        targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
+        versionCode 301
+        versionName "3.01"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main {
+            java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            res.srcDirs = @ANDROID_SAMPLE_RES_PATH@
+            manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@'
+        }
+    }
+}
+
+dependencies {
+    //implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':opencv')
+}
diff --git a/C++/opencv-4.7.0/samples/android/color-blob-detection/gradle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/color-blob-detection/gradle/AndroidManifest.xml
new file mode 100644
index 00000000..4fb8b582
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/color-blob-detection/gradle/AndroidManifest.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="org.opencv.samples.colorblobdetect"
+>
+
+    <application
+        android:label="@string/app_name"
+        android:icon="@drawable/icon"
+        android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
+
+        <activity
+                  android:exported="true"
+                  android:name="ColorBlobDetectionActivity"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true"
+                      android:normalScreens="true"
+                      android:largeScreens="true"
+                      android:anyDensity="true" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/color-blob-detection/res/drawable/icon.png b/C++/opencv-4.7.0/samples/android/color-blob-detection/res/drawable/icon.png
new file mode 100644
index 00000000..63045492
Binary files /dev/null and b/C++/opencv-4.7.0/samples/android/color-blob-detection/res/drawable/icon.png differ
diff --git a/C++/opencv-4.7.0/samples/android/color-blob-detection/res/layout/color_blob_detection_surface_view.xml b/C++/opencv-4.7.0/samples/android/color-blob-detection/res/layout/color_blob_detection_surface_view.xml
new file mode 100644
index 00000000..94531a60
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/color-blob-detection/res/layout/color_blob_detection_surface_view.xml
@@ -0,0 +1,11 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/color_blob_detection_activity_surface_view" />
+
+</LinearLayout>
diff --git a/C++/opencv-4.7.0/samples/android/color-blob-detection/res/values/strings.xml b/C++/opencv-4.7.0/samples/android/color-blob-detection/res/values/strings.xml
new file mode 100644
index 00000000..5b6f2c16
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/color-blob-detection/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OCV Color Blob Detection</string>
+</resources>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/android/color-blob-detection/src/org/opencv/samples/colorblobdetect/ColorBlobDetectionActivity.java b/C++/opencv-4.7.0/samples/android/color-blob-detection/src/org/opencv/samples/colorblobdetect/ColorBlobDetectionActivity.java
new file mode 100644
index 00000000..a656dc50
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/color-blob-detection/src/org/opencv/samples/colorblobdetect/ColorBlobDetectionActivity.java
@@ -0,0 +1,205 @@
+package org.opencv.samples.colorblobdetect;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.CameraActivity;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.Rect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.android.CameraBridgeViewBase;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
+import org.opencv.imgproc.Imgproc;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.View.OnTouchListener;
+import android.view.SurfaceView;
+
+public class ColorBlobDetectionActivity extends CameraActivity implements OnTouchListener, CvCameraViewListener2 {
+    private static final String  TAG              = "OCVSample::Activity";
+
+    private boolean              mIsColorSelected = false;
+    private Mat                  mRgba;
+    private Scalar               mBlobColorRgba;
+    private Scalar               mBlobColorHsv;
+    private ColorBlobDetector    mDetector;
+    private Mat                  mSpectrum;
+    private Size                 SPECTRUM_SIZE;
+    private Scalar               CONTOUR_COLOR;
+
+    private CameraBridgeViewBase mOpenCvCameraView;
+
+    private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
+        @Override
+        public void onManagerConnected(int status) {
+            switch (status) {
+                case LoaderCallbackInterface.SUCCESS:
+                {
+                    Log.i(TAG, "OpenCV loaded successfully");
+                    mOpenCvCameraView.enableView();
+                    mOpenCvCameraView.setOnTouchListener(ColorBlobDetectionActivity.this);
+                } break;
+                default:
+                {
+                    super.onManagerConnected(status);
+                } break;
+            }
+        }
+    };
+
+    public ColorBlobDetectionActivity() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "called onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.color_blob_detection_surface_view);
+
+        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.color_blob_detection_activity_surface_view);
+        mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
+    @Override
+    public void onPause()
+    {
+        super.onPause();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public void onResume()
+    {
+        super.onResume();
+        if (!OpenCVLoader.initDebug()) {
+            Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
+            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
+        } else {
+            Log.d(TAG, "OpenCV library found inside package. Using it!");
+            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
+        }
+    }
+
+    @Override
+    protected List<? extends CameraBridgeViewBase> getCameraViewList() {
+        return Collections.singletonList(mOpenCvCameraView);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    public void onCameraViewStarted(int width, int height) {
+        mRgba = new Mat(height, width, CvType.CV_8UC4);
+        mDetector = new ColorBlobDetector();
+        mSpectrum = new Mat();
+        mBlobColorRgba = new Scalar(255);
+        mBlobColorHsv = new Scalar(255);
+        SPECTRUM_SIZE = new Size(200, 64);
+        CONTOUR_COLOR = new Scalar(255,0,0,255);
+    }
+
+    public void onCameraViewStopped() {
+        mRgba.release();
+    }
+
+    public boolean onTouch(View v, MotionEvent event) {
+        int cols = mRgba.cols();
+        int rows = mRgba.rows();
+
+        int xOffset = (mOpenCvCameraView.getWidth() - cols) / 2;
+        int yOffset = (mOpenCvCameraView.getHeight() - rows) / 2;
+
+        int x = (int)event.getX() - xOffset;
+        int y = (int)event.getY() - yOffset;
+
+        Log.i(TAG, "Touch image coordinates: (" + x + ", " + y + ")");
+
+        if ((x < 0) || (y < 0) || (x > cols) || (y > rows)) return false;
+
+        Rect touchedRect = new Rect();
+
+        touchedRect.x = (x>4) ? x-4 : 0;
+        touchedRect.y = (y>4) ? y-4 : 0;
+
+        touchedRect.width = (x+4 < cols) ? x + 4 - touchedRect.x : cols - touchedRect.x;
+        touchedRect.height = (y+4 < rows) ? y + 4 - touchedRect.y : rows - touchedRect.y;
+
+        Mat touchedRegionRgba = mRgba.submat(touchedRect);
+
+        Mat touchedRegionHsv = new Mat();
+        Imgproc.cvtColor(touchedRegionRgba, touchedRegionHsv, Imgproc.COLOR_RGB2HSV_FULL);
+
+        // Calculate average color of touched region
+        mBlobColorHsv = Core.sumElems(touchedRegionHsv);
+        int pointCount = touchedRect.width*touchedRect.height;
+        for (int i = 0; i < mBlobColorHsv.val.length; i++)
+            mBlobColorHsv.val[i] /= pointCount;
+
+        mBlobColorRgba = convertScalarHsv2Rgba(mBlobColorHsv);
+
+        Log.i(TAG, "Touched rgba color: (" + mBlobColorRgba.val[0] + ", " + mBlobColorRgba.val[1] +
+                ", " + mBlobColorRgba.val[2] + ", " + mBlobColorRgba.val[3] + ")");
+
+        mDetector.setHsvColor(mBlobColorHsv);
+
+        Imgproc.resize(mDetector.getSpectrum(), mSpectrum, SPECTRUM_SIZE, 0, 0, Imgproc.INTER_LINEAR_EXACT);
+
+        mIsColorSelected = true;
+
+        touchedRegionRgba.release();
+        touchedRegionHsv.release();
+
+        return false; // don't need subsequent touch events
+    }
+
+    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
+        mRgba = inputFrame.rgba();
+
+        if (mIsColorSelected) {
+            mDetector.process(mRgba);
+            List<MatOfPoint> contours = mDetector.getContours();
+            Log.i(TAG, "Contours count: " + contours.size());
+            Imgproc.drawContours(mRgba, contours, -1, CONTOUR_COLOR);
+
+            Mat colorLabel = mRgba.submat(4, 68, 4, 68);
+            colorLabel.setTo(mBlobColorRgba);
+
+            Mat spectrumLabel = mRgba.submat(4, 4 + mSpectrum.rows(), 70, 70 + mSpectrum.cols());
+            mSpectrum.copyTo(spectrumLabel);
+        }
+
+        return mRgba;
+    }
+
+    private Scalar convertScalarHsv2Rgba(Scalar hsvColor) {
+        Mat pointMatRgba = new Mat();
+        Mat pointMatHsv = new Mat(1, 1, CvType.CV_8UC3, hsvColor);
+        Imgproc.cvtColor(pointMatHsv, pointMatRgba, Imgproc.COLOR_HSV2RGB_FULL, 4);
+
+        return new Scalar(pointMatRgba.get(0, 0));
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/color-blob-detection/src/org/opencv/samples/colorblobdetect/ColorBlobDetector.java b/C++/opencv-4.7.0/samples/android/color-blob-detection/src/org/opencv/samples/colorblobdetect/ColorBlobDetector.java
new file mode 100644
index 00000000..21988a81
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/color-blob-detection/src/org/opencv/samples/colorblobdetect/ColorBlobDetector.java
@@ -0,0 +1,108 @@
+package org.opencv.samples.colorblobdetect;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.Scalar;
+import org.opencv.imgproc.Imgproc;
+
+public class ColorBlobDetector {
+    // Lower and Upper bounds for range checking in HSV color space
+    private Scalar mLowerBound = new Scalar(0);
+    private Scalar mUpperBound = new Scalar(0);
+    // Minimum contour area in percent for contours filtering
+    private static double mMinContourArea = 0.1;
+    // Color radius for range checking in HSV color space
+    private Scalar mColorRadius = new Scalar(25,50,50,0);
+    private Mat mSpectrum = new Mat();
+    private List<MatOfPoint> mContours = new ArrayList<MatOfPoint>();
+
+    // Cache
+    Mat mPyrDownMat = new Mat();
+    Mat mHsvMat = new Mat();
+    Mat mMask = new Mat();
+    Mat mDilatedMask = new Mat();
+    Mat mHierarchy = new Mat();
+
+    public void setColorRadius(Scalar radius) {
+        mColorRadius = radius;
+    }
+
+    public void setHsvColor(Scalar hsvColor) {
+        double minH = (hsvColor.val[0] >= mColorRadius.val[0]) ? hsvColor.val[0]-mColorRadius.val[0] : 0;
+        double maxH = (hsvColor.val[0]+mColorRadius.val[0] <= 255) ? hsvColor.val[0]+mColorRadius.val[0] : 255;
+
+        mLowerBound.val[0] = minH;
+        mUpperBound.val[0] = maxH;
+
+        mLowerBound.val[1] = hsvColor.val[1] - mColorRadius.val[1];
+        mUpperBound.val[1] = hsvColor.val[1] + mColorRadius.val[1];
+
+        mLowerBound.val[2] = hsvColor.val[2] - mColorRadius.val[2];
+        mUpperBound.val[2] = hsvColor.val[2] + mColorRadius.val[2];
+
+        mLowerBound.val[3] = 0;
+        mUpperBound.val[3] = 255;
+
+        Mat spectrumHsv = new Mat(1, (int)(maxH-minH), CvType.CV_8UC3);
+
+        for (int j = 0; j < maxH-minH; j++) {
+            byte[] tmp = {(byte)(minH+j), (byte)255, (byte)255};
+            spectrumHsv.put(0, j, tmp);
+        }
+
+        Imgproc.cvtColor(spectrumHsv, mSpectrum, Imgproc.COLOR_HSV2RGB_FULL, 4);
+    }
+
+    public Mat getSpectrum() {
+        return mSpectrum;
+    }
+
+    public void setMinContourArea(double area) {
+        mMinContourArea = area;
+    }
+
+    public void process(Mat rgbaImage) {
+        Imgproc.pyrDown(rgbaImage, mPyrDownMat);
+        Imgproc.pyrDown(mPyrDownMat, mPyrDownMat);
+
+        Imgproc.cvtColor(mPyrDownMat, mHsvMat, Imgproc.COLOR_RGB2HSV_FULL);
+
+        Core.inRange(mHsvMat, mLowerBound, mUpperBound, mMask);
+        Imgproc.dilate(mMask, mDilatedMask, new Mat());
+
+        List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
+
+        Imgproc.findContours(mDilatedMask, contours, mHierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
+
+        // Find max contour area
+        double maxArea = 0;
+        Iterator<MatOfPoint> each = contours.iterator();
+        while (each.hasNext()) {
+            MatOfPoint wrapper = each.next();
+            double area = Imgproc.contourArea(wrapper);
+            if (area > maxArea)
+                maxArea = area;
+        }
+
+        // Filter contours by area and resize to fit the original image size
+        mContours.clear();
+        each = contours.iterator();
+        while (each.hasNext()) {
+            MatOfPoint contour = each.next();
+            if (Imgproc.contourArea(contour) > mMinContourArea*maxArea) {
+                Core.multiply(contour, new Scalar(4,4), contour);
+                mContours.add(contour);
+            }
+        }
+    }
+
+    public List<MatOfPoint> getContours() {
+        return mContours;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/face-detection/CMakeLists.txt
new file mode 100644
index 00000000..bbcfa32f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/CMakeLists.txt
@@ -0,0 +1,12 @@
+set(sample example-face-detection)
+
+if(BUILD_FAT_JAVA_LIB)
+  set(native_deps opencv_java)
+else()
+  set(native_deps opencv_objdetect)
+endif()
+
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}" NATIVE_DEPS ${native_deps})
+if(TARGET ${sample})
+  add_dependencies(opencv_android_examples ${sample})
+endif()
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/build.gradle.in b/C++/opencv-4.7.0/samples/android/face-detection/build.gradle.in
new file mode 100644
index 00000000..9e3b187a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/build.gradle.in
@@ -0,0 +1,43 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
+    defaultConfig {
+        applicationId "org.opencv.samples.facedetect"
+        minSdkVersion @ANDROID_MIN_SDK_VERSION@
+        targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
+        versionCode 301
+        versionName "3.01"
+
+        externalNativeBuild {
+            cmake {
+                arguments "-DOpenCV_DIR=" + project(':opencv').projectDir + "/@ANDROID_PROJECT_JNI_PATH@"@OPENCV_ANDROID_CMAKE_EXTRA_ARGS@
+                targets "detection_based_tracker"
+            }
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main {
+            java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            res.srcDirs = @ANDROID_SAMPLE_RES_PATH@
+            manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@'
+        }
+    }
+    externalNativeBuild {
+        cmake {
+             path '@ANDROID_SAMPLE_JNI_PATH@/CMakeLists.txt'
+        }
+    }
+}
+
+dependencies {
+    //implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':opencv')
+}
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/gradle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/face-detection/gradle/AndroidManifest.xml
new file mode 100644
index 00000000..157b318d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/gradle/AndroidManifest.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="org.opencv.samples.facedetect"
+>
+
+    <application
+        android:label="@string/app_name"
+        android:icon="@drawable/icon">
+
+        <activity
+                  android:exported="true"
+                  android:name="FdActivity"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true"
+                      android:normalScreens="true"
+                      android:largeScreens="true"
+                      android:anyDensity="true" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/jni/Android.mk b/C++/opencv-4.7.0/samples/android/face-detection/jni/Android.mk
new file mode 100644
index 00000000..e882cac0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/jni/Android.mk
@@ -0,0 +1,23 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+#OPENCV_INSTALL_MODULES:=off
+#OPENCV_LIB_TYPE:=SHARED
+ifdef OPENCV_ANDROID_SDK
+  ifneq ("","$(wildcard $(OPENCV_ANDROID_SDK)/OpenCV.mk)")
+    include ${OPENCV_ANDROID_SDK}/OpenCV.mk
+  else
+    include ${OPENCV_ANDROID_SDK}/sdk/native/jni/OpenCV.mk
+  endif
+else
+  include ../../sdk/native/jni/OpenCV.mk
+endif
+
+LOCAL_SRC_FILES  := DetectionBasedTracker_jni.cpp
+LOCAL_C_INCLUDES += $(LOCAL_PATH)
+LOCAL_LDLIBS     += -llog -ldl
+
+LOCAL_MODULE     := detection_based_tracker
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/jni/Application.mk b/C++/opencv-4.7.0/samples/android/face-detection/jni/Application.mk
new file mode 100644
index 00000000..4fffcb28
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/jni/Application.mk
@@ -0,0 +1,4 @@
+APP_STL := gnustl_static
+APP_CPPFLAGS := -frtti -fexceptions
+APP_ABI := armeabi-v7a
+APP_PLATFORM := android-8
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/jni/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/face-detection/jni/CMakeLists.txt
new file mode 100644
index 00000000..15f8f4db
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/jni/CMakeLists.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.6)
+
+set(target detection_based_tracker)
+project(${target} CXX)
+
+set(ANDROID_OPENCV_COMPONENTS "opencv_java" CACHE STRING "")
+message(STATUS "ANDROID_ABI=${ANDROID_ABI}")
+find_package(OpenCV REQUIRED COMPONENTS ${ANDROID_OPENCV_COMPONENTS})
+
+file(GLOB srcs *.cpp *.c)
+file(GLOB hdrs *.hpp *.h)
+
+include_directories("${CMAKE_CURRENT_LIST_DIR}")
+add_library(${target} SHARED ${srcs} ${hdrs})
+target_link_libraries(${target} ${ANDROID_OPENCV_COMPONENTS})
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp b/C++/opencv-4.7.0/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp
new file mode 100644
index 00000000..6ce36bc5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp
@@ -0,0 +1,251 @@
+#include <DetectionBasedTracker_jni.h>
+#include <opencv2/core.hpp>
+#include <opencv2/objdetect.hpp>
+
+#include <string>
+#include <vector>
+
+#include <android/log.h>
+
+#define LOG_TAG "FaceDetection/DetectionBasedTracker"
+#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
+
+using namespace std;
+using namespace cv;
+
+inline void vector_Rect_to_Mat(vector<Rect>& v_rect, Mat& mat)
+{
+    mat = Mat(v_rect, true);
+}
+
+class CascadeDetectorAdapter: public DetectionBasedTracker::IDetector
+{
+public:
+    CascadeDetectorAdapter(cv::Ptr<cv::CascadeClassifier> detector):
+            IDetector(),
+            Detector(detector)
+    {
+        LOGD("CascadeDetectorAdapter::Detect::Detect");
+        CV_Assert(detector);
+    }
+
+    void detect(const cv::Mat &Image, std::vector<cv::Rect> &objects)
+    {
+        LOGD("CascadeDetectorAdapter::Detect: begin");
+        LOGD("CascadeDetectorAdapter::Detect: scaleFactor=%.2f, minNeighbours=%d, minObjSize=(%dx%d), maxObjSize=(%dx%d)", scaleFactor, minNeighbours, minObjSize.width, minObjSize.height, maxObjSize.width, maxObjSize.height);
+        Detector->detectMultiScale(Image, objects, scaleFactor, minNeighbours, 0, minObjSize, maxObjSize);
+        LOGD("CascadeDetectorAdapter::Detect: end");
+    }
+
+    virtual ~CascadeDetectorAdapter()
+    {
+        LOGD("CascadeDetectorAdapter::Detect::~Detect");
+    }
+
+private:
+    CascadeDetectorAdapter();
+    cv::Ptr<cv::CascadeClassifier> Detector;
+};
+
+struct DetectorAgregator
+{
+    cv::Ptr<CascadeDetectorAdapter> mainDetector;
+    cv::Ptr<CascadeDetectorAdapter> trackingDetector;
+
+    cv::Ptr<DetectionBasedTracker> tracker;
+    DetectorAgregator(cv::Ptr<CascadeDetectorAdapter>& _mainDetector, cv::Ptr<CascadeDetectorAdapter>& _trackingDetector):
+            mainDetector(_mainDetector),
+            trackingDetector(_trackingDetector)
+    {
+        CV_Assert(_mainDetector);
+        CV_Assert(_trackingDetector);
+
+        DetectionBasedTracker::Parameters DetectorParams;
+        tracker = makePtr<DetectionBasedTracker>(mainDetector, trackingDetector, DetectorParams);
+    }
+};
+
+JNIEXPORT jlong JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeCreateObject
+(JNIEnv * jenv, jclass, jstring jFileName, jint faceSize)
+{
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeCreateObject enter");
+    const char* jnamestr = jenv->GetStringUTFChars(jFileName, NULL);
+    string stdFileName(jnamestr);
+    jlong result = 0;
+
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeCreateObject");
+
+    try
+    {
+        cv::Ptr<CascadeDetectorAdapter> mainDetector = makePtr<CascadeDetectorAdapter>(
+            makePtr<CascadeClassifier>(stdFileName));
+        cv::Ptr<CascadeDetectorAdapter> trackingDetector = makePtr<CascadeDetectorAdapter>(
+            makePtr<CascadeClassifier>(stdFileName));
+        result = (jlong)new DetectorAgregator(mainDetector, trackingDetector);
+        if (faceSize > 0)
+        {
+            mainDetector->setMinObjectSize(Size(faceSize, faceSize));
+            //trackingDetector->setMinObjectSize(Size(faceSize, faceSize));
+        }
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeCreateObject caught cv::Exception: %s", e.what());
+        jclass je = jenv->FindClass("org/opencv/core/CvException");
+        if(!je)
+            je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, e.what());
+    }
+    catch (...)
+    {
+        LOGD("nativeCreateObject caught unknown exception");
+        jclass je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, "Unknown exception in JNI code of DetectionBasedTracker.nativeCreateObject()");
+        return 0;
+    }
+
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeCreateObject exit");
+    return result;
+}
+
+JNIEXPORT void JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDestroyObject
+(JNIEnv * jenv, jclass, jlong thiz)
+{
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDestroyObject");
+
+    try
+    {
+        if(thiz != 0)
+        {
+            ((DetectorAgregator*)thiz)->tracker->stop();
+            delete (DetectorAgregator*)thiz;
+        }
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeestroyObject caught cv::Exception: %s", e.what());
+        jclass je = jenv->FindClass("org/opencv/core/CvException");
+        if(!je)
+            je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, e.what());
+    }
+    catch (...)
+    {
+        LOGD("nativeDestroyObject caught unknown exception");
+        jclass je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, "Unknown exception in JNI code of DetectionBasedTracker.nativeDestroyObject()");
+    }
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDestroyObject exit");
+}
+
+JNIEXPORT void JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStart
+(JNIEnv * jenv, jclass, jlong thiz)
+{
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStart");
+
+    try
+    {
+        ((DetectorAgregator*)thiz)->tracker->run();
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeStart caught cv::Exception: %s", e.what());
+        jclass je = jenv->FindClass("org/opencv/core/CvException");
+        if(!je)
+            je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, e.what());
+    }
+    catch (...)
+    {
+        LOGD("nativeStart caught unknown exception");
+        jclass je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, "Unknown exception in JNI code of DetectionBasedTracker.nativeStart()");
+    }
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStart exit");
+}
+
+JNIEXPORT void JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStop
+(JNIEnv * jenv, jclass, jlong thiz)
+{
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStop");
+
+    try
+    {
+        ((DetectorAgregator*)thiz)->tracker->stop();
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeStop caught cv::Exception: %s", e.what());
+        jclass je = jenv->FindClass("org/opencv/core/CvException");
+        if(!je)
+            je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, e.what());
+    }
+    catch (...)
+    {
+        LOGD("nativeStop caught unknown exception");
+        jclass je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, "Unknown exception in JNI code of DetectionBasedTracker.nativeStop()");
+    }
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStop exit");
+}
+
+JNIEXPORT void JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeSetFaceSize
+(JNIEnv * jenv, jclass, jlong thiz, jint faceSize)
+{
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeSetFaceSize -- BEGIN");
+
+    try
+    {
+        if (faceSize > 0)
+        {
+            ((DetectorAgregator*)thiz)->mainDetector->setMinObjectSize(Size(faceSize, faceSize));
+            //((DetectorAgregator*)thiz)->trackingDetector->setMinObjectSize(Size(faceSize, faceSize));
+        }
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeStop caught cv::Exception: %s", e.what());
+        jclass je = jenv->FindClass("org/opencv/core/CvException");
+        if(!je)
+            je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, e.what());
+    }
+    catch (...)
+    {
+        LOGD("nativeSetFaceSize caught unknown exception");
+        jclass je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, "Unknown exception in JNI code of DetectionBasedTracker.nativeSetFaceSize()");
+    }
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeSetFaceSize -- END");
+}
+
+
+JNIEXPORT void JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDetect
+(JNIEnv * jenv, jclass, jlong thiz, jlong imageGray, jlong faces)
+{
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDetect");
+
+    try
+    {
+        vector<Rect> RectFaces;
+        ((DetectorAgregator*)thiz)->tracker->process(*((Mat*)imageGray));
+        ((DetectorAgregator*)thiz)->tracker->getObjects(RectFaces);
+        *((Mat*)faces) = Mat(RectFaces, true);
+    }
+    catch(const cv::Exception& e)
+    {
+        LOGD("nativeCreateObject caught cv::Exception: %s", e.what());
+        jclass je = jenv->FindClass("org/opencv/core/CvException");
+        if(!je)
+            je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, e.what());
+    }
+    catch (...)
+    {
+        LOGD("nativeDetect caught unknown exception");
+        jclass je = jenv->FindClass("java/lang/Exception");
+        jenv->ThrowNew(je, "Unknown exception in JNI code DetectionBasedTracker.nativeDetect()");
+    }
+    LOGD("Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDetect END");
+}
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/jni/DetectionBasedTracker_jni.h b/C++/opencv-4.7.0/samples/android/face-detection/jni/DetectionBasedTracker_jni.h
new file mode 100644
index 00000000..7e0541d8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/jni/DetectionBasedTracker_jni.h
@@ -0,0 +1,61 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_opencv_samples_fd_DetectionBasedTracker */
+
+#ifndef _Included_org_opencv_samples_fd_DetectionBasedTracker
+#define _Included_org_opencv_samples_fd_DetectionBasedTracker
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_opencv_samples_fd_DetectionBasedTracker
+ * Method:    nativeCreateObject
+ * Signature: (Ljava/lang/String;F)J
+ */
+JNIEXPORT jlong JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeCreateObject
+  (JNIEnv *, jclass, jstring, jint);
+
+/*
+ * Class:     org_opencv_samples_fd_DetectionBasedTracker
+ * Method:    nativeDestroyObject
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDestroyObject
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_opencv_samples_fd_DetectionBasedTracker
+ * Method:    nativeStart
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStart
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     org_opencv_samples_fd_DetectionBasedTracker
+ * Method:    nativeStop
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeStop
+  (JNIEnv *, jclass, jlong);
+
+  /*
+   * Class:     org_opencv_samples_fd_DetectionBasedTracker
+   * Method:    nativeSetFaceSize
+   * Signature: (JI)V
+   */
+  JNIEXPORT void JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeSetFaceSize
+  (JNIEnv *, jclass, jlong, jint);
+
+/*
+ * Class:     org_opencv_samples_fd_DetectionBasedTracker
+ * Method:    nativeDetect
+ * Signature: (JJJ)V
+ */
+JNIEXPORT void JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker_nativeDetect
+  (JNIEnv *, jclass, jlong, jlong, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/res/drawable/icon.png b/C++/opencv-4.7.0/samples/android/face-detection/res/drawable/icon.png
new file mode 100644
index 00000000..63045492
Binary files /dev/null and b/C++/opencv-4.7.0/samples/android/face-detection/res/drawable/icon.png differ
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/res/layout/face_detect_surface_view.xml b/C++/opencv-4.7.0/samples/android/face-detection/res/layout/face_detect_surface_view.xml
new file mode 100644
index 00000000..68d8fb4e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/res/layout/face_detect_surface_view.xml
@@ -0,0 +1,11 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/fd_activity_surface_view" />
+
+</LinearLayout>
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/res/raw/lbpcascade_frontalface.xml b/C++/opencv-4.7.0/samples/android/face-detection/res/raw/lbpcascade_frontalface.xml
new file mode 100644
index 00000000..fc7648ef
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/res/raw/lbpcascade_frontalface.xml
@@ -0,0 +1,1505 @@
+<?xml version="1.0"?>
+<!--
+number of positive samples 3000
+number of negative samples 1500
+-->
+<opencv_storage>
+<cascade type_id="opencv-cascade-classifier">
+  <stageType>BOOST</stageType>
+  <featureType>LBP</featureType>
+  <height>24</height>
+  <width>24</width>
+  <stageParams>
+    <boostType>GAB</boostType>
+    <minHitRate>0.9950000047683716</minHitRate>
+    <maxFalseAlarm>0.5000000000000000</maxFalseAlarm>
+    <weightTrimRate>0.9500000000000000</weightTrimRate>
+    <maxDepth>1</maxDepth>
+    <maxWeakCount>100</maxWeakCount></stageParams>
+  <featureParams>
+    <maxCatCount>256</maxCatCount></featureParams>
+  <stageNum>20</stageNum>
+  <stages>
+    <!-- stage 0 -->
+    <_>
+      <maxWeakCount>3</maxWeakCount>
+      <stageThreshold>-0.7520892024040222</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 46 -67130709 -21569 -1426120013 -1275125205 -21585
+            -16385 587145899 -24005</internalNodes>
+          <leafValues>
+            -0.6543210148811340 0.8888888955116272</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 13 -163512766 -769593758 -10027009 -262145 -514457854
+            -193593353 -524289 -1</internalNodes>
+          <leafValues>
+            -0.7739216089248657 0.7278633713722229</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 2 -363936790 -893203669 -1337948010 -136907894
+            1088782736 -134217726 -741544961 -1590337</internalNodes>
+          <leafValues>
+            -0.7068563103675842 0.6761534214019775</leafValues></_></weakClassifiers></_>
+    <!-- stage 1 -->
+    <_>
+      <maxWeakCount>4</maxWeakCount>
+      <stageThreshold>-0.4872078299522400</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 84 2147483647 1946124287 -536870913 2147450879
+            738132490 1061101567 243204619 2147446655</internalNodes>
+          <leafValues>
+            -0.8083735704421997 0.7685696482658386</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 21 2147483647 263176079 1879048191 254749487 1879048191
+            -134252545 -268435457 801111999</internalNodes>
+          <leafValues>
+            -0.7698410153388977 0.6592915654182434</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 106 -98110272 1610939566 -285484400 -850010381
+            -189334372 -1671954433 -571026695 -262145</internalNodes>
+          <leafValues>
+            -0.7506558895111084 0.5444605946540833</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 48 -798690576 -131075 1095771153 -237144073 -65569 -1
+            -216727745 -69206049</internalNodes>
+          <leafValues>
+            -0.7775990366935730 0.5465461611747742</leafValues></_></weakClassifiers></_>
+    <!-- stage 2 -->
+    <_>
+      <maxWeakCount>4</maxWeakCount>
+      <stageThreshold>-1.1592328548431396</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 47 -21585 -20549 -100818262 -738254174 -20561 -36865
+            -151016790 -134238549</internalNodes>
+          <leafValues>
+            -0.5601882934570313 0.7743113040924072</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 12 -286003217 183435247 -268994614 -421330945
+            -402686081 1090387966 -286785545 -402653185</internalNodes>
+          <leafValues>
+            -0.6124526262283325 0.6978127956390381</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 26 -50347012 970882927 -50463492 -1253377 -134218251
+            -50364513 -33619992 -172490753</internalNodes>
+          <leafValues>
+            -0.6114496588706970 0.6537628173828125</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 8 -273 -135266321 1877977738 -2088243418 -134217987
+            2146926575 -18910642 1095231247</internalNodes>
+          <leafValues>
+            -0.6854077577590942 0.5403239130973816</leafValues></_></weakClassifiers></_>
+    <!-- stage 3 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.7562355995178223</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 96 -1273 1870659519 -20971602 -67633153 -134250731
+            2004875127 -250 -150995969</internalNodes>
+          <leafValues>
+            -0.4051094949245453 0.7584033608436585</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 33 -868162224 -76810262 -4262145 -257 1465211989
+            -268959873 -2656269 -524289</internalNodes>
+          <leafValues>
+            -0.7388162612915039 0.5340843200683594</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 57 -12817 -49 -541103378 -152950 -38993 -20481 -1153876
+            -72478976</internalNodes>
+          <leafValues>
+            -0.6582943797111511 0.5339496731758118</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 125 -269484161 -452984961 -319816180 -1594032130 -2111
+            -990117891 -488975296 -520947741</internalNodes>
+          <leafValues>
+            -0.5981323719024658 0.5323504805564880</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 53 557787431 670265215 -1342193665 -1075892225
+            1998528318 1056964607 -33570977 -1</internalNodes>
+          <leafValues>
+            -0.6498787999153137 0.4913350641727448</leafValues></_></weakClassifiers></_>
+    <!-- stage 4 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.8085358142852783</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 60 -536873708 880195381 -16842788 -20971521 -176687276
+            -168427659 -16777260 -33554626</internalNodes>
+          <leafValues>
+            -0.5278195738792419 0.6946372389793396</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 7 -1 -62981529 -1090591130 805330978 -8388827 -41945787
+            -39577 -531118985</internalNodes>
+          <leafValues>
+            -0.5206505060195923 0.6329920291900635</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 98 -725287348 1347747543 -852489 -16809993 1489881036
+            -167903241 -1 -1</internalNodes>
+          <leafValues>
+            -0.7516061067581177 0.4232024252414703</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 44 -32777 1006582562 -65 935312171 -8388609 -1078198273
+            -1 733886267</internalNodes>
+          <leafValues>
+            -0.7639313936233521 0.4123568832874298</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 24 -85474705 2138828511 -1036436754 817625855
+            1123369029 -58796809 -1013468481 -194513409</internalNodes>
+          <leafValues>
+            -0.5123769044876099 0.5791834592819214</leafValues></_></weakClassifiers></_>
+    <!-- stage 5 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.5549971461296082</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 42 -17409 -20481 -268457797 -134239493 -17473 -1 -21829
+            -21846</internalNodes>
+          <leafValues>
+            -0.3763174116611481 0.7298233509063721</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 6 -805310737 -2098262358 -269504725 682502698
+            2147483519 1740574719 -1090519233 -268472385</internalNodes>
+          <leafValues>
+            -0.5352765917778015 0.5659480094909668</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 61 -67109678 -6145 -8 -87884584 -20481 -1073762305
+            -50856216 -16849696</internalNodes>
+          <leafValues>
+            -0.5678374171257019 0.4961479902267456</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 123 -138428633 1002418167 -1359008245 -1908670465
+            -1346685918 910098423 -1359010520 -1346371657</internalNodes>
+          <leafValues>
+            -0.5706262588500977 0.4572288393974304</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 9 -89138513 -4196353 1256531674 -1330665426 1216308261
+            -36190633 33498198 -151796633</internalNodes>
+          <leafValues>
+            -0.5344601869583130 0.4672054052352905</leafValues></_></weakClassifiers></_>
+    <!-- stage 6 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.8776460289955139</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 105 1073769576 206601725 -34013449 -33554433 -789514004
+            -101384321 -690225153 -264193</internalNodes>
+          <leafValues>
+            -0.7700348496437073 0.5943940877914429</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 30 -1432340997 -823623681 -49153 -34291724 -269484035
+            -1342767105 -1078198273 -1277955</internalNodes>
+          <leafValues>
+            -0.5043668746948242 0.6151274442672730</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 35 -1067385040 -195758209 -436748425 -134217731
+            -50855988 -129 -1 -1</internalNodes>
+          <leafValues>
+            -0.6808040738105774 0.4667325913906097</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 119 832534325 -34111555 -26050561 -423659521 -268468364
+            2105014143 -2114244 -17367185</internalNodes>
+          <leafValues>
+            -0.4927591383457184 0.5401885509490967</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 82 -1089439888 -1080524865 2143059967 -1114121
+            -1140949004 -3 -2361356 -739516</internalNodes>
+          <leafValues>
+            -0.6445107460021973 0.4227822124958038</leafValues></_></weakClassifiers></_>
+    <!-- stage 7 -->
+    <_>
+      <maxWeakCount>6</maxWeakCount>
+      <stageThreshold>-1.1139287948608398</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 52 -1074071553 -1074003969 -1 -1280135430 -5324817 -1
+            -335548482 582134442</internalNodes>
+          <leafValues>
+            -0.5307556986808777 0.6258179545402527</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 99 -706937396 -705364068 -540016724 -570495027
+            -570630659 -587857963 -33628164 -35848193</internalNodes>
+          <leafValues>
+            -0.5227634310722351 0.5049746036529541</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 18 -2035630093 42119158 -268503053 -1671444 261017599
+            1325432815 1954394111 -805306449</internalNodes>
+          <leafValues>
+            -0.4983572661876679 0.5106441378593445</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 111 -282529488 -1558073088 1426018736 -170526448
+            -546832487 -5113037 -34243375 -570427929</internalNodes>
+          <leafValues>
+            -0.4990860521793366 0.5060507059097290</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 92 1016332500 -606301707 915094269 -1080086049
+            -1837027144 -1361600280 2147318747 1067975613</internalNodes>
+          <leafValues>
+            -0.5695009231567383 0.4460467398166657</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 51 -656420166 -15413034 -141599534 -603435836
+            1505950458 -787556946 -79823438 -1326199134</internalNodes>
+          <leafValues>
+            -0.6590405106544495 0.3616424500942230</leafValues></_></weakClassifiers></_>
+    <!-- stage 8 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.8243625760078430</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 28 -901591776 -201916417 -262 -67371009 -143312112
+            -524289 -41943178 -1</internalNodes>
+          <leafValues>
+            -0.4972776770591736 0.6027074456214905</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 112 -4507851 -411340929 -268437513 -67502145 -17350859
+            -32901 -71344315 -29377</internalNodes>
+          <leafValues>
+            -0.4383158981800079 0.5966237187385559</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 69 -75894785 -117379438 -239063587 -12538500 1485072126
+            2076233213 2123118847 801906927</internalNodes>
+          <leafValues>
+            -0.6386105418205261 0.3977999985218048</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 19 -823480413 786628589 -16876049 -1364262914 242165211
+            1315930109 -696268833 -455082829</internalNodes>
+          <leafValues>
+            -0.5512794256210327 0.4282079637050629</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 73 -521411968 6746762 -1396236286 -2038436114
+            -185612509 57669627 -143132877 -1041235973</internalNodes>
+          <leafValues>
+            -0.6418755054473877 0.3549866080284119</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 126 -478153869 1076028979 -1645895615 1365298272
+            -557859073 -339771473 1442574528 -1058802061</internalNodes>
+          <leafValues>
+            -0.4841901361942291 0.4668019413948059</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 45 -246350404 -1650402048 -1610612745 -788400696
+            1467604861 -2787397 1476263935 -4481349</internalNodes>
+          <leafValues>
+            -0.5855734348297119 0.3879135847091675</leafValues></_></weakClassifiers></_>
+    <!-- stage 9 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-1.2237116098403931</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 114 -24819 1572863935 -16809993 -67108865 2146778388
+            1433927541 -268608444 -34865205</internalNodes>
+          <leafValues>
+            -0.2518476545810700 0.7088654041290283</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 97 -1841359 -134271049 -32769 -5767369 -1116675 -2185
+            -8231 -33603327</internalNodes>
+          <leafValues>
+            -0.4303432404994965 0.5283288359642029</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 25 -1359507589 -1360593090 -1073778729 -269553812
+            -809512977 1744707583 -41959433 -134758978</internalNodes>
+          <leafValues>
+            -0.4259553551673889 0.5440809130668640</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 34 729753407 -134270989 -1140907329 -235200777
+            658456383 2147467263 -1140900929 -16385</internalNodes>
+          <leafValues>
+            -0.5605589151382446 0.4220733344554901</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 134 -310380553 -420675595 -193005472 -353568129
+            1205338070 -990380036 887604324 -420544526</internalNodes>
+          <leafValues>
+            -0.5192656517028809 0.4399855434894562</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 16 -1427119361 1978920959 -287119734 -487068946
+            114759245 -540578051 -707510259 -671660453</internalNodes>
+          <leafValues>
+            -0.5013077259063721 0.4570254683494568</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 74 -738463762 -889949281 -328301948 -121832450
+            -1142658284 -1863576559 2146417353 -263185</internalNodes>
+          <leafValues>
+            -0.4631414115428925 0.4790246188640595</leafValues></_></weakClassifiers></_>
+    <!-- stage 10 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.5544230937957764</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 113 -76228780 -65538 -1 -67174401 -148007 -33 -221796
+            -272842924</internalNodes>
+          <leafValues>
+            -0.3949716091156006 0.6082032322883606</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 110 369147696 -1625232112 2138570036 -1189900 790708019
+            -1212613127 799948719 -4456483</internalNodes>
+          <leafValues>
+            -0.4855885505676270 0.4785369932651520</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 37 784215839 -290015241 536832799 -402984963
+            -1342414991 -838864897 -176769 -268456129</internalNodes>
+          <leafValues>
+            -0.4620285332202911 0.4989669024944305</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 41 -486418688 -171915327 -340294900 -21938 -519766032
+            -772751172 -73096060 -585322623</internalNodes>
+          <leafValues>
+            -0.6420643329620361 0.3624351918697357</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 117 -33554953 -475332625 -1423463824 -2077230421
+            -4849669 -2080505925 -219032928 -1071915349</internalNodes>
+          <leafValues>
+            -0.4820112884044647 0.4632140696048737</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 65 -834130468 -134217476 -1349314083 -1073803559
+            -619913764 -1449131844 -1386890321 -1979118423</internalNodes>
+          <leafValues>
+            -0.4465552568435669 0.5061788558959961</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 56 -285249779 1912569855 -16530 -1731022870 -1161904146
+            -1342177297 -268439634 -1464078708</internalNodes>
+          <leafValues>
+            -0.5190586447715759 0.4441480338573456</leafValues></_></weakClassifiers></_>
+    <!-- stage 11 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.7161560654640198</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 20 1246232575 1078001186 -10027057 60102 -277348353
+            -43646987 -1210581153 1195769615</internalNodes>
+          <leafValues>
+            -0.4323809444904327 0.5663768053054810</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 15 -778583572 -612921106 -578775890 -4036478
+            -1946580497 -1164766570 -1986687009 -12103599</internalNodes>
+          <leafValues>
+            -0.4588732719421387 0.4547033011913300</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 129 -1073759445 2013231743 -1363169553 -1082459201
+            -1414286549 868185983 -1356133589 -1077936257</internalNodes>
+          <leafValues>
+            -0.5218553543090820 0.4111092388629913</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 102 -84148365 -2093417722 -1204850272 564290299
+            -67121221 -1342177350 -1309195902 -776734797</internalNodes>
+          <leafValues>
+            -0.4920000731945038 0.4326725304126740</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 88 -25694458 67104495 -290216278 -168563037 2083877442
+            1702788383 -144191964 -234882162</internalNodes>
+          <leafValues>
+            -0.4494568109512329 0.4448510706424713</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 59 -857980836 904682741 -1612267521 232279415
+            1550862252 -574825221 -357380888 -4579409</internalNodes>
+          <leafValues>
+            -0.5180826783180237 0.3888972699642181</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 27 -98549440 -137838400 494928389 -246013630 939541351
+            -1196072350 -620603549 2137216273</internalNodes>
+          <leafValues>
+            -0.6081240773200989 0.3333222270011902</leafValues></_></weakClassifiers></_>
+    <!-- stage 12 -->
+    <_>
+      <maxWeakCount>8</maxWeakCount>
+      <stageThreshold>-0.6743940711021423</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 29 -150995201 2071191945 -1302151626 536934335
+            -1059008937 914128709 1147328110 -268369925</internalNodes>
+          <leafValues>
+            -0.1790193915367127 0.6605972051620483</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 128 -134509479 1610575703 -1342177289 1861484541
+            -1107833788 1577058173 -333558568 -136319041</internalNodes>
+          <leafValues>
+            -0.3681024610996246 0.5139749646186829</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 70 -1 1060154476 -1090984524 -630918524 -539492875
+            779616255 -839568424 -321</internalNodes>
+          <leafValues>
+            -0.3217232525348663 0.6171553134918213</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 4 -269562385 -285029906 -791084350 -17923776 235286671
+            1275504943 1344390399 -966276889</internalNodes>
+          <leafValues>
+            -0.4373284578323364 0.4358185231685638</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 76 17825984 -747628419 595427229 1474759671 575672208
+            -1684005538 872217086 -1155858277</internalNodes>
+          <leafValues>
+            -0.4404836893081665 0.4601220190525055</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 124 -336593039 1873735591 -822231622 -355795238
+            -470820869 -1997537409 -1057132384 -1015285005</internalNodes>
+          <leafValues>
+            -0.4294152259826660 0.4452161788940430</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 54 -834212130 -593694721 -322142257 -364892500
+            -951029539 -302125121 -1615106053 -79249765</internalNodes>
+          <leafValues>
+            -0.3973052501678467 0.4854526817798615</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 95 1342144479 2147431935 -33554561 -47873 -855685912 -1
+            1988052447 536827383</internalNodes>
+          <leafValues>
+            -0.7054683566093445 0.2697997391223908</leafValues></_></weakClassifiers></_>
+    <!-- stage 13 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-1.2042298316955566</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 39 1431368960 -183437936 -537002499 -137497097
+            1560590321 -84611081 -2097193 -513</internalNodes>
+          <leafValues>
+            -0.5905947685241699 0.5101932883262634</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 120 -1645259691 2105491231 2130706431 1458995007
+            -8567536 -42483883 -33780003 -21004417</internalNodes>
+          <leafValues>
+            -0.4449204802513123 0.4490709304809570</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 89 -612381022 -505806938 -362027516 -452985106
+            275854917 1920431639 -12600561 -134221825</internalNodes>
+          <leafValues>
+            -0.4693818688392639 0.4061094820499420</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 14 -805573153 -161 -554172679 -530519488 -16779441
+            2000682871 -33604275 -150997129</internalNodes>
+          <leafValues>
+            -0.3600351214408875 0.5056326985359192</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 67 6192 435166195 1467449341 2046691505 -1608493775
+            -4755729 -1083162625 -71365637</internalNodes>
+          <leafValues>
+            -0.4459891915321350 0.4132415652275085</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 86 -41689215 -3281034 1853357967 -420712635 -415924289
+            -270209208 -1088293113 -825311232</internalNodes>
+          <leafValues>
+            -0.4466069042682648 0.4135067760944367</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 80 -117391116 -42203396 2080374461 -188709 -542008165
+            -356831940 -1091125345 -1073796897</internalNodes>
+          <leafValues>
+            -0.3394956290721893 0.5658645033836365</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 75 -276830049 1378714472 -1342181951 757272098
+            1073740607 -282199241 -415761549 170896931</internalNodes>
+          <leafValues>
+            -0.5346512198448181 0.3584479391574860</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 55 -796075825 -123166849 2113667055 -217530421
+            -1107432194 -16385 -806359809 -391188771</internalNodes>
+          <leafValues>
+            -0.4379335641860962 0.4123645126819611</leafValues></_></weakClassifiers></_>
+    <!-- stage 14 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.8402050137519836</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 71 -890246622 15525883 -487690486 47116238 -1212319899
+            -1291847681 -68159890 -469829921</internalNodes>
+          <leafValues>
+            -0.2670986354351044 0.6014143228530884</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 31 -1361180685 -1898008841 -1090588811 -285410071
+            -1074016265 -840443905 2147221487 -262145</internalNodes>
+          <leafValues>
+            -0.4149844348430634 0.4670888185501099</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 40 1426190596 1899364271 2142731795 -142607505
+            -508232452 -21563393 -41960001 -65</internalNodes>
+          <leafValues>
+            -0.4985891580581665 0.3719584941864014</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 109 -201337965 10543906 -236498096 -746195597
+            1974565825 -15204415 921907633 -190058309</internalNodes>
+          <leafValues>
+            -0.4568729996681213 0.3965812027454376</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 130 -595026732 -656401928 -268649235 -571490699
+            -440600392 -133131 -358810952 -2004088646</internalNodes>
+          <leafValues>
+            -0.4770836830139160 0.3862601518630981</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 66 941674740 -1107882114 1332789109 -67691015
+            -1360463693 -1556612430 -609108546 733546933</internalNodes>
+          <leafValues>
+            -0.4877715110778809 0.3778986334800720</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 49 -17114945 -240061474 1552871558 -82775604 -932393844
+            -1308544889 -532635478 -99042357</internalNodes>
+          <leafValues>
+            -0.3721654713153839 0.4994400143623352</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 133 -655906006 1405502603 -939205164 1884929228
+            -498859222 559417357 -1928559445 -286264385</internalNodes>
+          <leafValues>
+            -0.3934195041656494 0.4769641458988190</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 0 -335837777 1860677295 -90 -1946186226 931096183
+            251612987 2013265917 -671232197</internalNodes>
+          <leafValues>
+            -0.4323300719261169 0.4342164099216461</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 103 37769424 -137772680 374692301 2002666345 -536176194
+            -1644484728 807009019 1069089930</internalNodes>
+          <leafValues>
+            -0.4993278682231903 0.3665378093719482</leafValues></_></weakClassifiers></_>
+    <!-- stage 15 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-1.1974394321441650</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 43 -5505 2147462911 2143265466 -4511070 -16450 -257
+            -201348440 -71333206</internalNodes>
+          <leafValues>
+            -0.3310225307941437 0.5624626278877258</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 90 -136842268 -499330741 2015250980 -87107126
+            -641665744 -788524639 -1147864792 -134892563</internalNodes>
+          <leafValues>
+            -0.5266560912132263 0.3704403042793274</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 104 -146800880 -1780368555 2111170033 -140904684
+            -16777551 -1946681885 -1646463595 -839131947</internalNodes>
+          <leafValues>
+            -0.4171888828277588 0.4540435671806335</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 85 -832054034 -981663763 -301990281 -578814081
+            -932319000 -1997406723 -33555201 -69206017</internalNodes>
+          <leafValues>
+            -0.4556705355644226 0.3704262077808380</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 24 -118492417 -1209026825 1119023838 -1334313353
+            1112948738 -297319313 1378887291 -139469193</internalNodes>
+          <leafValues>
+            -0.4182529747486115 0.4267231225967407</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 78 -1714382628 -2353704 -112094959 -549613092
+            -1567058760 -1718550464 -342315012 -1074972227</internalNodes>
+          <leafValues>
+            -0.3625369668006897 0.4684656262397766</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 5 -85219702 316836394 -33279 1904970288 2117267315
+            -260901769 -621461759 -88607770</internalNodes>
+          <leafValues>
+            -0.4742925167083740 0.3689507246017456</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 11 -294654041 -353603585 -1641159686 -50331921
+            -2080899877 1145569279 -143132713 -152044037</internalNodes>
+          <leafValues>
+            -0.3666271567344666 0.4580127298831940</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 32 1887453658 -638545712 -1877976819 -34320972
+            -1071067983 -661345416 -583338277 1060190561</internalNodes>
+          <leafValues>
+            -0.4567637443542481 0.3894708156585693</leafValues></_></weakClassifiers></_>
+    <!-- stage 16 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-0.5733128190040588</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 122 -994063296 1088745462 -318837116 -319881377
+            1102566613 1165490103 -121679694 -134744129</internalNodes>
+          <leafValues>
+            -0.4055117964744568 0.5487945079803467</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 68 -285233233 -538992907 1811935199 -369234005 -529
+            -20593 -20505 -1561401854</internalNodes>
+          <leafValues>
+            -0.3787897229194641 0.4532003402709961</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 58 -1335245632 1968917183 1940861695 536816369
+            -1226071367 -570908176 457026619 1000020667</internalNodes>
+          <leafValues>
+            -0.4258328974246979 0.4202791750431061</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 94 -1360318719 -1979797897 -50435249 -18646473
+            -608879292 -805306691 -269304244 -17840167</internalNodes>
+          <leafValues>
+            -0.4561023116111755 0.4002747833728790</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 87 2062765935 -16449 -1275080721 -16406 45764335
+            -1090552065 -772846337 -570464322</internalNodes>
+          <leafValues>
+            -0.4314672648906708 0.4086346626281738</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 127 -536896021 1080817663 -738234288 -965478709
+            -2082767969 1290855887 1993822934 -990381609</internalNodes>
+          <leafValues>
+            -0.4174543321132660 0.4249868988990784</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 3 -818943025 168730891 -293610428 -79249354 669224671
+            621166734 1086506807 1473768907</internalNodes>
+          <leafValues>
+            -0.4321364760398865 0.4090838730335236</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 79 -68895696 -67107736 -1414315879 -841676168
+            -619843344 -1180610531 -1081990469 1043203389</internalNodes>
+          <leafValues>
+            -0.5018386244773865 0.3702533841133118</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 116 -54002134 -543485719 -2124882422 -1437445858
+            -115617074 -1195787391 -1096024366 -2140472445</internalNodes>
+          <leafValues>
+            -0.5037505626678467 0.3564981222152710</leafValues></_></weakClassifiers></_>
+    <!-- stage 17 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-0.4892596900463104</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 132 -67113211 2003808111 1862135111 846461923 -2752
+            2002237273 -273154752 1937223539</internalNodes>
+          <leafValues>
+            -0.2448196411132813 0.5689709186553955</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 62 1179423888 -78064940 -611839555 -539167899
+            -1289358360 -1650810108 -892540499 -1432827684</internalNodes>
+          <leafValues>
+            -0.4633283913135529 0.3587929606437683</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 23 -285212705 -78450761 -656212031 -264050110 -27787425
+            -1334349961 -547662981 -135796924</internalNodes>
+          <leafValues>
+            -0.3731099069118500 0.4290455579757690</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 77 341863476 403702016 -550588417 1600194541
+            -1080690735 951127993 -1388580949 -1153717473</internalNodes>
+          <leafValues>
+            -0.3658909499645233 0.4556473195552826</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 22 -586880702 -204831512 -100644596 -39319550
+            -1191150794 705692513 457203315 -75806957</internalNodes>
+          <leafValues>
+            -0.5214384198188782 0.3221037387847900</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 72 -416546870 545911370 -673716192 -775559454
+            -264113598 139424 -183369982 -204474641</internalNodes>
+          <leafValues>
+            -0.4289036989212036 0.4004956185817719</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 50 -1026505020 -589692154 -1740499937 -1563770497
+            1348491006 -60710713 -1109853489 -633909413</internalNodes>
+          <leafValues>
+            -0.4621542394161224 0.3832748532295227</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 108 -1448872304 -477895040 -1778390608 -772418127
+            -1789923416 -1612057181 -805306693 -1415842113</internalNodes>
+          <leafValues>
+            -0.3711548447608948 0.4612701535224915</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 92 407905424 -582449988 52654751 -1294472 -285103725
+            -74633006 1871559083 1057955850</internalNodes>
+          <leafValues>
+            -0.5180652141571045 0.3205870389938355</leafValues></_></weakClassifiers></_>
+    <!-- stage 18 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.5911940932273865</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 81 4112 -1259563825 -846671428 -100902460 1838164148
+            -74153752 -90653988 -1074263896</internalNodes>
+          <leafValues>
+            -0.2592592537403107 0.5873016119003296</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 1 -285216785 -823206977 -1085589 -1081346 1207959293
+            1157103471 2097133565 -2097169</internalNodes>
+          <leafValues>
+            -0.3801195919513702 0.4718827307224274</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 121 -12465 -536875169 2147478367 2130706303 -37765492
+            -866124467 -318782328 -1392509185</internalNodes>
+          <leafValues>
+            -0.3509117066860199 0.5094807147979736</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 38 2147449663 -20741 -16794757 1945873146 -16710 -1
+            -8406341 -67663041</internalNodes>
+          <leafValues>
+            -0.4068757295608521 0.4130136370658875</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 17 -155191713 866117231 1651407483 548272812 -479201468
+            -447742449 1354229504 -261884429</internalNodes>
+          <leafValues>
+            -0.4557141065597534 0.3539792001247406</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 100 -225319378 -251682065 -492783986 -792341777
+            -1287261695 1393643841 -11274182 -213909521</internalNodes>
+          <leafValues>
+            -0.4117803275585175 0.4118592441082001</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 63 -382220122 -2002072729 -51404800 -371201558
+            -923011069 -2135301457 -2066104743 -1042557441</internalNodes>
+          <leafValues>
+            -0.4008397758007050 0.4034757018089294</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 101 -627353764 -48295149 1581203952 -436258614
+            -105268268 -1435893445 -638126888 -1061107126</internalNodes>
+          <leafValues>
+            -0.5694189667701721 0.2964762747287750</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 118 -8399181 1058107691 -621022752 -251003468 -12582915
+            -574619739 -994397789 -1648362021</internalNodes>
+          <leafValues>
+            -0.3195341229438782 0.5294018983840942</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 92 -348343812 -1078389516 1717960437 364735981
+            -1783841602 -4883137 -457572354 -1076950384</internalNodes>
+          <leafValues>
+            -0.3365339040756226 0.5067458748817444</leafValues></_></weakClassifiers></_>
+    <!-- stage 19 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.7612916231155396</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 10 -1976661318 -287957604 -1659497122 -782068 43591089
+            -453637880 1435470000 -1077438561</internalNodes>
+          <leafValues>
+            -0.4204545319080353 0.5165745615959168</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 131 -67110925 14874979 -142633168 -1338923040
+            2046713291 -2067933195 1473503712 -789579837</internalNodes>
+          <leafValues>
+            -0.3762553930282593 0.4075302779674530</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 83 -272814301 -1577073 -1118685 -305156120 -1052289
+            -1073813756 -538971154 -355523038</internalNodes>
+          <leafValues>
+            -0.4253497421741486 0.3728055357933044</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 135 -2233 -214486242 -538514758 573747007 -159390971
+            1994225489 -973738098 -203424005</internalNodes>
+          <leafValues>
+            -0.3601998090744019 0.4563256204128265</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 115 -261031688 -1330369299 -641860609 1029570301
+            -1306461192 -1196149518 -1529767778 683139823</internalNodes>
+          <leafValues>
+            -0.4034293889999390 0.4160816967487335</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 64 -572993608 -34042628 -417865 -111109 -1433365268
+            -19869715 -1920939864 -1279457063</internalNodes>
+          <leafValues>
+            -0.3620899617671967 0.4594142735004425</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 36 -626275097 -615256993 1651946018 805366393
+            2016559730 -430780849 -799868165 -16580645</internalNodes>
+          <leafValues>
+            -0.3903816640377045 0.4381459355354309</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 93 1354797300 -1090957603 1976418270 -1342502178
+            -1851873892 -1194637077 -1153521668 -1108399474</internalNodes>
+          <leafValues>
+            -0.3591445386409760 0.4624078869819641</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 91 68157712 1211368313 -304759523 1063017136 798797750
+            -275513546 648167355 -1145357350</internalNodes>
+          <leafValues>
+            -0.4297670423984528 0.4023293554782867</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 107 -546318240 -1628569602 -163577944 -537002306
+            -545456389 -1325465645 -380446736 -1058473386</internalNodes>
+          <leafValues>
+            -0.5727006793022156 0.2995934784412384</leafValues></_></weakClassifiers></_></stages>
+  <features>
+    <_>
+      <rect>
+        0 0 3 5</rect></_>
+    <_>
+      <rect>
+        0 0 4 2</rect></_>
+    <_>
+      <rect>
+        0 0 6 3</rect></_>
+    <_>
+      <rect>
+        0 1 2 3</rect></_>
+    <_>
+      <rect>
+        0 1 3 3</rect></_>
+    <_>
+      <rect>
+        0 1 3 7</rect></_>
+    <_>
+      <rect>
+        0 4 3 3</rect></_>
+    <_>
+      <rect>
+        0 11 3 4</rect></_>
+    <_>
+      <rect>
+        0 12 8 4</rect></_>
+    <_>
+      <rect>
+        0 14 4 3</rect></_>
+    <_>
+      <rect>
+        1 0 5 3</rect></_>
+    <_>
+      <rect>
+        1 1 2 2</rect></_>
+    <_>
+      <rect>
+        1 3 3 1</rect></_>
+    <_>
+      <rect>
+        1 7 4 4</rect></_>
+    <_>
+      <rect>
+        1 12 2 2</rect></_>
+    <_>
+      <rect>
+        1 13 4 1</rect></_>
+    <_>
+      <rect>
+        1 14 4 3</rect></_>
+    <_>
+      <rect>
+        1 17 3 2</rect></_>
+    <_>
+      <rect>
+        2 0 2 3</rect></_>
+    <_>
+      <rect>
+        2 1 2 2</rect></_>
+    <_>
+      <rect>
+        2 2 4 6</rect></_>
+    <_>
+      <rect>
+        2 3 4 4</rect></_>
+    <_>
+      <rect>
+        2 7 2 1</rect></_>
+    <_>
+      <rect>
+        2 11 2 3</rect></_>
+    <_>
+      <rect>
+        2 17 3 2</rect></_>
+    <_>
+      <rect>
+        3 0 2 2</rect></_>
+    <_>
+      <rect>
+        3 1 7 3</rect></_>
+    <_>
+      <rect>
+        3 7 2 1</rect></_>
+    <_>
+      <rect>
+        3 7 2 4</rect></_>
+    <_>
+      <rect>
+        3 18 2 2</rect></_>
+    <_>
+      <rect>
+        4 0 2 3</rect></_>
+    <_>
+      <rect>
+        4 3 2 1</rect></_>
+    <_>
+      <rect>
+        4 6 2 1</rect></_>
+    <_>
+      <rect>
+        4 6 2 5</rect></_>
+    <_>
+      <rect>
+        4 7 5 2</rect></_>
+    <_>
+      <rect>
+        4 8 4 3</rect></_>
+    <_>
+      <rect>
+        4 18 2 2</rect></_>
+    <_>
+      <rect>
+        5 0 2 2</rect></_>
+    <_>
+      <rect>
+        5 3 4 4</rect></_>
+    <_>
+      <rect>
+        5 6 2 5</rect></_>
+    <_>
+      <rect>
+        5 9 2 2</rect></_>
+    <_>
+      <rect>
+        5 10 2 2</rect></_>
+    <_>
+      <rect>
+        6 3 4 4</rect></_>
+    <_>
+      <rect>
+        6 4 4 3</rect></_>
+    <_>
+      <rect>
+        6 5 2 3</rect></_>
+    <_>
+      <rect>
+        6 5 2 5</rect></_>
+    <_>
+      <rect>
+        6 5 4 3</rect></_>
+    <_>
+      <rect>
+        6 6 4 2</rect></_>
+    <_>
+      <rect>
+        6 6 4 4</rect></_>
+    <_>
+      <rect>
+        6 18 1 2</rect></_>
+    <_>
+      <rect>
+        6 21 2 1</rect></_>
+    <_>
+      <rect>
+        7 0 3 7</rect></_>
+    <_>
+      <rect>
+        7 4 2 3</rect></_>
+    <_>
+      <rect>
+        7 9 5 1</rect></_>
+    <_>
+      <rect>
+        7 21 2 1</rect></_>
+    <_>
+      <rect>
+        8 0 1 4</rect></_>
+    <_>
+      <rect>
+        8 5 2 2</rect></_>
+    <_>
+      <rect>
+        8 5 3 2</rect></_>
+    <_>
+      <rect>
+        8 17 3 1</rect></_>
+    <_>
+      <rect>
+        8 18 1 2</rect></_>
+    <_>
+      <rect>
+        9 0 5 3</rect></_>
+    <_>
+      <rect>
+        9 2 2 6</rect></_>
+    <_>
+      <rect>
+        9 5 1 1</rect></_>
+    <_>
+      <rect>
+        9 11 1 1</rect></_>
+    <_>
+      <rect>
+        9 16 1 1</rect></_>
+    <_>
+      <rect>
+        9 16 2 1</rect></_>
+    <_>
+      <rect>
+        9 17 1 1</rect></_>
+    <_>
+      <rect>
+        9 18 1 1</rect></_>
+    <_>
+      <rect>
+        10 5 1 2</rect></_>
+    <_>
+      <rect>
+        10 5 3 3</rect></_>
+    <_>
+      <rect>
+        10 7 1 5</rect></_>
+    <_>
+      <rect>
+        10 8 1 1</rect></_>
+    <_>
+      <rect>
+        10 9 1 1</rect></_>
+    <_>
+      <rect>
+        10 10 1 1</rect></_>
+    <_>
+      <rect>
+        10 10 1 2</rect></_>
+    <_>
+      <rect>
+        10 14 3 3</rect></_>
+    <_>
+      <rect>
+        10 15 1 1</rect></_>
+    <_>
+      <rect>
+        10 15 2 1</rect></_>
+    <_>
+      <rect>
+        10 16 1 1</rect></_>
+    <_>
+      <rect>
+        10 16 2 1</rect></_>
+    <_>
+      <rect>
+        10 17 1 1</rect></_>
+    <_>
+      <rect>
+        10 21 1 1</rect></_>
+    <_>
+      <rect>
+        11 3 2 2</rect></_>
+    <_>
+      <rect>
+        11 5 1 2</rect></_>
+    <_>
+      <rect>
+        11 5 3 3</rect></_>
+    <_>
+      <rect>
+        11 5 4 6</rect></_>
+    <_>
+      <rect>
+        11 6 1 1</rect></_>
+    <_>
+      <rect>
+        11 7 2 2</rect></_>
+    <_>
+      <rect>
+        11 8 1 2</rect></_>
+    <_>
+      <rect>
+        11 10 1 1</rect></_>
+    <_>
+      <rect>
+        11 10 1 2</rect></_>
+    <_>
+      <rect>
+        11 15 1 1</rect></_>
+    <_>
+      <rect>
+        11 17 1 1</rect></_>
+    <_>
+      <rect>
+        11 18 1 1</rect></_>
+    <_>
+      <rect>
+        12 0 2 2</rect></_>
+    <_>
+      <rect>
+        12 1 2 5</rect></_>
+    <_>
+      <rect>
+        12 2 4 1</rect></_>
+    <_>
+      <rect>
+        12 3 1 3</rect></_>
+    <_>
+      <rect>
+        12 7 3 4</rect></_>
+    <_>
+      <rect>
+        12 10 3 2</rect></_>
+    <_>
+      <rect>
+        12 11 1 1</rect></_>
+    <_>
+      <rect>
+        12 12 3 2</rect></_>
+    <_>
+      <rect>
+        12 14 4 3</rect></_>
+    <_>
+      <rect>
+        12 17 1 1</rect></_>
+    <_>
+      <rect>
+        12 21 2 1</rect></_>
+    <_>
+      <rect>
+        13 6 2 5</rect></_>
+    <_>
+      <rect>
+        13 7 3 5</rect></_>
+    <_>
+      <rect>
+        13 11 3 2</rect></_>
+    <_>
+      <rect>
+        13 17 2 2</rect></_>
+    <_>
+      <rect>
+        13 17 3 2</rect></_>
+    <_>
+      <rect>
+        13 18 1 2</rect></_>
+    <_>
+      <rect>
+        13 18 2 2</rect></_>
+    <_>
+      <rect>
+        14 0 2 2</rect></_>
+    <_>
+      <rect>
+        14 1 1 3</rect></_>
+    <_>
+      <rect>
+        14 2 3 2</rect></_>
+    <_>
+      <rect>
+        14 7 2 1</rect></_>
+    <_>
+      <rect>
+        14 13 2 1</rect></_>
+    <_>
+      <rect>
+        14 13 3 3</rect></_>
+    <_>
+      <rect>
+        14 17 2 2</rect></_>
+    <_>
+      <rect>
+        15 0 2 2</rect></_>
+    <_>
+      <rect>
+        15 0 2 3</rect></_>
+    <_>
+      <rect>
+        15 4 3 2</rect></_>
+    <_>
+      <rect>
+        15 4 3 6</rect></_>
+    <_>
+      <rect>
+        15 6 3 2</rect></_>
+    <_>
+      <rect>
+        15 11 3 4</rect></_>
+    <_>
+      <rect>
+        15 13 3 2</rect></_>
+    <_>
+      <rect>
+        15 17 2 2</rect></_>
+    <_>
+      <rect>
+        15 17 3 2</rect></_>
+    <_>
+      <rect>
+        16 1 2 3</rect></_>
+    <_>
+      <rect>
+        16 3 2 4</rect></_>
+    <_>
+      <rect>
+        16 6 1 1</rect></_>
+    <_>
+      <rect>
+        16 16 2 2</rect></_>
+    <_>
+      <rect>
+        17 1 2 2</rect></_>
+    <_>
+      <rect>
+        17 1 2 5</rect></_>
+    <_>
+      <rect>
+        17 12 2 2</rect></_>
+    <_>
+      <rect>
+        18 0 2 2</rect></_></features></cascade>
+</opencv_storage>
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/res/values/strings.xml b/C++/opencv-4.7.0/samples/android/face-detection/res/values/strings.xml
new file mode 100644
index 00000000..476a9e03
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OCV Face Detection</string>
+</resources>
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/src/org/opencv/samples/facedetect/DetectionBasedTracker.java b/C++/opencv-4.7.0/samples/android/face-detection/src/org/opencv/samples/facedetect/DetectionBasedTracker.java
new file mode 100644
index 00000000..6179f1bd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/src/org/opencv/samples/facedetect/DetectionBasedTracker.java
@@ -0,0 +1,41 @@
+package org.opencv.samples.facedetect;
+
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfRect;
+
+public class DetectionBasedTracker
+{
+    public DetectionBasedTracker(String cascadeName, int minFaceSize) {
+        mNativeObj = nativeCreateObject(cascadeName, minFaceSize);
+    }
+
+    public void start() {
+        nativeStart(mNativeObj);
+    }
+
+    public void stop() {
+        nativeStop(mNativeObj);
+    }
+
+    public void setMinFaceSize(int size) {
+        nativeSetFaceSize(mNativeObj, size);
+    }
+
+    public void detect(Mat imageGray, MatOfRect faces) {
+        nativeDetect(mNativeObj, imageGray.getNativeObjAddr(), faces.getNativeObjAddr());
+    }
+
+    public void release() {
+        nativeDestroyObject(mNativeObj);
+        mNativeObj = 0;
+    }
+
+    private long mNativeObj = 0;
+
+    private static native long nativeCreateObject(String cascadeName, int minFaceSize);
+    private static native void nativeDestroyObject(long thiz);
+    private static native void nativeStart(long thiz);
+    private static native void nativeStop(long thiz);
+    private static native void nativeSetFaceSize(long thiz, int size);
+    private static native void nativeDetect(long thiz, long inputImage, long faces);
+}
diff --git a/C++/opencv-4.7.0/samples/android/face-detection/src/org/opencv/samples/facedetect/FdActivity.java b/C++/opencv-4.7.0/samples/android/face-detection/src/org/opencv/samples/facedetect/FdActivity.java
new file mode 100644
index 00000000..979c3da7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/face-detection/src/org/opencv/samples/facedetect/FdActivity.java
@@ -0,0 +1,259 @@
+package org.opencv.samples.facedetect;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.List;
+
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.CameraActivity;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfRect;
+import org.opencv.core.Rect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.android.CameraBridgeViewBase;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
+import org.opencv.objdetect.CascadeClassifier;
+import org.opencv.imgproc.Imgproc;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.WindowManager;
+
+public class FdActivity extends CameraActivity implements CvCameraViewListener2 {
+
+    private static final String    TAG                 = "OCVSample::Activity";
+    private static final Scalar    FACE_RECT_COLOR     = new Scalar(0, 255, 0, 255);
+    public static final int        JAVA_DETECTOR       = 0;
+    public static final int        NATIVE_DETECTOR     = 1;
+
+    private MenuItem               mItemFace50;
+    private MenuItem               mItemFace40;
+    private MenuItem               mItemFace30;
+    private MenuItem               mItemFace20;
+    private MenuItem               mItemType;
+
+    private Mat                    mRgba;
+    private Mat                    mGray;
+    private File                   mCascadeFile;
+    private CascadeClassifier      mJavaDetector;
+    private DetectionBasedTracker  mNativeDetector;
+
+    private int                    mDetectorType       = JAVA_DETECTOR;
+    private String[]               mDetectorName;
+
+    private float                  mRelativeFaceSize   = 0.2f;
+    private int                    mAbsoluteFaceSize   = 0;
+
+    private CameraBridgeViewBase   mOpenCvCameraView;
+
+    private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
+        @Override
+        public void onManagerConnected(int status) {
+            switch (status) {
+                case LoaderCallbackInterface.SUCCESS:
+                {
+                    Log.i(TAG, "OpenCV loaded successfully");
+
+                    // Load native library after(!) OpenCV initialization
+                    System.loadLibrary("detection_based_tracker");
+
+                    try {
+                        // load cascade file from application resources
+                        InputStream is = getResources().openRawResource(R.raw.lbpcascade_frontalface);
+                        File cascadeDir = getDir("cascade", Context.MODE_PRIVATE);
+                        mCascadeFile = new File(cascadeDir, "lbpcascade_frontalface.xml");
+                        FileOutputStream os = new FileOutputStream(mCascadeFile);
+
+                        byte[] buffer = new byte[4096];
+                        int bytesRead;
+                        while ((bytesRead = is.read(buffer)) != -1) {
+                            os.write(buffer, 0, bytesRead);
+                        }
+                        is.close();
+                        os.close();
+
+                        mJavaDetector = new CascadeClassifier(mCascadeFile.getAbsolutePath());
+                        if (mJavaDetector.empty()) {
+                            Log.e(TAG, "Failed to load cascade classifier");
+                            mJavaDetector = null;
+                        } else
+                            Log.i(TAG, "Loaded cascade classifier from " + mCascadeFile.getAbsolutePath());
+
+                        mNativeDetector = new DetectionBasedTracker(mCascadeFile.getAbsolutePath(), 0);
+
+                        cascadeDir.delete();
+
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                        Log.e(TAG, "Failed to load cascade. Exception thrown: " + e);
+                    }
+
+                    mOpenCvCameraView.enableView();
+                } break;
+                default:
+                {
+                    super.onManagerConnected(status);
+                } break;
+            }
+        }
+    };
+
+    public FdActivity() {
+        mDetectorName = new String[2];
+        mDetectorName[JAVA_DETECTOR] = "Java";
+        mDetectorName[NATIVE_DETECTOR] = "Native (tracking)";
+
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "called onCreate");
+        super.onCreate(savedInstanceState);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.face_detect_surface_view);
+
+        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.fd_activity_surface_view);
+        mOpenCvCameraView.setVisibility(CameraBridgeViewBase.VISIBLE);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
+    @Override
+    public void onPause()
+    {
+        super.onPause();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public void onResume()
+    {
+        super.onResume();
+        if (!OpenCVLoader.initDebug()) {
+            Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
+            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
+        } else {
+            Log.d(TAG, "OpenCV library found inside package. Using it!");
+            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
+        }
+    }
+
+    @Override
+    protected List<? extends CameraBridgeViewBase> getCameraViewList() {
+        return Collections.singletonList(mOpenCvCameraView);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        mOpenCvCameraView.disableView();
+    }
+
+    public void onCameraViewStarted(int width, int height) {
+        mGray = new Mat();
+        mRgba = new Mat();
+    }
+
+    public void onCameraViewStopped() {
+        mGray.release();
+        mRgba.release();
+    }
+
+    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
+
+        mRgba = inputFrame.rgba();
+        mGray = inputFrame.gray();
+
+        if (mAbsoluteFaceSize == 0) {
+            int height = mGray.rows();
+            if (Math.round(height * mRelativeFaceSize) > 0) {
+                mAbsoluteFaceSize = Math.round(height * mRelativeFaceSize);
+            }
+            mNativeDetector.setMinFaceSize(mAbsoluteFaceSize);
+        }
+
+        MatOfRect faces = new MatOfRect();
+
+        if (mDetectorType == JAVA_DETECTOR) {
+            if (mJavaDetector != null)
+                mJavaDetector.detectMultiScale(mGray, faces, 1.1, 2, 2, // TODO: objdetect.CV_HAAR_SCALE_IMAGE
+                        new Size(mAbsoluteFaceSize, mAbsoluteFaceSize), new Size());
+        }
+        else if (mDetectorType == NATIVE_DETECTOR) {
+            if (mNativeDetector != null)
+                mNativeDetector.detect(mGray, faces);
+        }
+        else {
+            Log.e(TAG, "Detection method is not selected!");
+        }
+
+        Rect[] facesArray = faces.toArray();
+        for (int i = 0; i < facesArray.length; i++)
+            Imgproc.rectangle(mRgba, facesArray[i].tl(), facesArray[i].br(), FACE_RECT_COLOR, 3);
+
+        return mRgba;
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "called onCreateOptionsMenu");
+        mItemFace50 = menu.add("Face size 50%");
+        mItemFace40 = menu.add("Face size 40%");
+        mItemFace30 = menu.add("Face size 30%");
+        mItemFace20 = menu.add("Face size 20%");
+        mItemType   = menu.add(mDetectorName[mDetectorType]);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
+        if (item == mItemFace50)
+            setMinFaceSize(0.5f);
+        else if (item == mItemFace40)
+            setMinFaceSize(0.4f);
+        else if (item == mItemFace30)
+            setMinFaceSize(0.3f);
+        else if (item == mItemFace20)
+            setMinFaceSize(0.2f);
+        else if (item == mItemType) {
+            int tmpDetectorType = (mDetectorType + 1) % mDetectorName.length;
+            item.setTitle(mDetectorName[tmpDetectorType]);
+            setDetectorType(tmpDetectorType);
+        }
+        return true;
+    }
+
+    private void setMinFaceSize(float faceSize) {
+        mRelativeFaceSize = faceSize;
+        mAbsoluteFaceSize = 0;
+    }
+
+    private void setDetectorType(int type) {
+        if (mDetectorType != type) {
+            mDetectorType = type;
+
+            if (type == NATIVE_DETECTOR) {
+                Log.i(TAG, "Detection Based Tracker enabled");
+                mNativeDetector.start();
+            } else {
+                Log.i(TAG, "Cascade detector enabled");
+                mNativeDetector.stop();
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/image-manipulations/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/image-manipulations/CMakeLists.txt
new file mode 100644
index 00000000..bbb4cbc8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/image-manipulations/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(sample example-image-manipulations)
+
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
+if(TARGET ${sample})
+  add_dependencies(opencv_android_examples ${sample})
+endif()
diff --git a/C++/opencv-4.7.0/samples/android/image-manipulations/build.gradle.in b/C++/opencv-4.7.0/samples/android/image-manipulations/build.gradle.in
new file mode 100644
index 00000000..0d685ed4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/image-manipulations/build.gradle.in
@@ -0,0 +1,31 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
+    defaultConfig {
+        applicationId "org.opencv.samples.imagemanipulations"
+        minSdkVersion @ANDROID_MIN_SDK_VERSION@
+        targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
+        versionCode 301
+        versionName "3.01"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main {
+            java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            res.srcDirs = @ANDROID_SAMPLE_RES_PATH@
+            manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@'
+        }
+    }
+}
+
+dependencies {
+    //implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':opencv')
+}
diff --git a/C++/opencv-4.7.0/samples/android/image-manipulations/gradle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/image-manipulations/gradle/AndroidManifest.xml
new file mode 100644
index 00000000..2aa9c09a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/image-manipulations/gradle/AndroidManifest.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="org.opencv.samples.imagemanipulations"
+>
+
+    <application
+        android:label="@string/app_name"
+        android:icon="@drawable/icon">
+
+        <activity
+                  android:exported="true"
+                  android:name="ImageManipulationsActivity"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true"
+                      android:normalScreens="true"
+                      android:largeScreens="true"
+                      android:anyDensity="true" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/image-manipulations/res/drawable/icon.png b/C++/opencv-4.7.0/samples/android/image-manipulations/res/drawable/icon.png
new file mode 100644
index 00000000..63045492
Binary files /dev/null and b/C++/opencv-4.7.0/samples/android/image-manipulations/res/drawable/icon.png differ
diff --git a/C++/opencv-4.7.0/samples/android/image-manipulations/res/layout/image_manipulations_surface_view.xml b/C++/opencv-4.7.0/samples/android/image-manipulations/res/layout/image_manipulations_surface_view.xml
new file mode 100644
index 00000000..06e2e5e9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/image-manipulations/res/layout/image_manipulations_surface_view.xml
@@ -0,0 +1,11 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/image_manipulations_activity_surface_view" />
+
+</LinearLayout>
diff --git a/C++/opencv-4.7.0/samples/android/image-manipulations/res/values/strings.xml b/C++/opencv-4.7.0/samples/android/image-manipulations/res/values/strings.xml
new file mode 100644
index 00000000..564fd795
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/image-manipulations/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OCV Image Manipulations</string>
+</resources>
diff --git a/C++/opencv-4.7.0/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsActivity.java b/C++/opencv-4.7.0/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsActivity.java
new file mode 100644
index 00000000..5ab5e5f0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsActivity.java
@@ -0,0 +1,327 @@
+package org.opencv.samples.imagemanipulations;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.CameraActivity;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfFloat;
+import org.opencv.core.MatOfInt;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.android.CameraBridgeViewBase;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
+import org.opencv.imgproc.Imgproc;
+
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.WindowManager;
+
+public class ImageManipulationsActivity extends CameraActivity implements CvCameraViewListener2 {
+    private static final String  TAG                 = "OCVSample::Activity";
+
+    public static final int      VIEW_MODE_RGBA      = 0;
+    public static final int      VIEW_MODE_HIST      = 1;
+    public static final int      VIEW_MODE_CANNY     = 2;
+    public static final int      VIEW_MODE_SEPIA     = 3;
+    public static final int      VIEW_MODE_SOBEL     = 4;
+    public static final int      VIEW_MODE_ZOOM      = 5;
+    public static final int      VIEW_MODE_PIXELIZE  = 6;
+    public static final int      VIEW_MODE_POSTERIZE = 7;
+
+    private MenuItem             mItemPreviewRGBA;
+    private MenuItem             mItemPreviewHist;
+    private MenuItem             mItemPreviewCanny;
+    private MenuItem             mItemPreviewSepia;
+    private MenuItem             mItemPreviewSobel;
+    private MenuItem             mItemPreviewZoom;
+    private MenuItem             mItemPreviewPixelize;
+    private MenuItem             mItemPreviewPosterize;
+    private CameraBridgeViewBase mOpenCvCameraView;
+
+    private Size                 mSize0;
+
+    private Mat                  mIntermediateMat;
+    private Mat                  mMat0;
+    private MatOfInt             mChannels[];
+    private MatOfInt             mHistSize;
+    private int                  mHistSizeNum = 25;
+    private MatOfFloat           mRanges;
+    private Scalar               mColorsRGB[];
+    private Scalar               mColorsHue[];
+    private Scalar               mWhilte;
+    private Point                mP1;
+    private Point                mP2;
+    private float                mBuff[];
+    private Mat                  mSepiaKernel;
+
+    public static int           viewMode = VIEW_MODE_RGBA;
+
+    private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
+        @Override
+        public void onManagerConnected(int status) {
+            switch (status) {
+                case LoaderCallbackInterface.SUCCESS:
+                {
+                    Log.i(TAG, "OpenCV loaded successfully");
+                    mOpenCvCameraView.enableView();
+                } break;
+                default:
+                {
+                    super.onManagerConnected(status);
+                } break;
+            }
+        }
+    };
+
+    public ImageManipulationsActivity() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "called onCreate");
+        super.onCreate(savedInstanceState);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.image_manipulations_surface_view);
+
+        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.image_manipulations_activity_surface_view);
+        mOpenCvCameraView.setVisibility(CameraBridgeViewBase.VISIBLE);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
+    @Override
+    public void onPause()
+    {
+        super.onPause();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public void onResume()
+    {
+        super.onResume();
+        if (!OpenCVLoader.initDebug()) {
+            Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
+            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
+        } else {
+            Log.d(TAG, "OpenCV library found inside package. Using it!");
+            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
+        }
+    }
+
+    @Override
+    protected List<? extends CameraBridgeViewBase> getCameraViewList() {
+        return Collections.singletonList(mOpenCvCameraView);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "called onCreateOptionsMenu");
+        mItemPreviewRGBA  = menu.add("Preview RGBA");
+        mItemPreviewHist  = menu.add("Histograms");
+        mItemPreviewCanny = menu.add("Canny");
+        mItemPreviewSepia = menu.add("Sepia");
+        mItemPreviewSobel = menu.add("Sobel");
+        mItemPreviewZoom  = menu.add("Zoom");
+        mItemPreviewPixelize  = menu.add("Pixelize");
+        mItemPreviewPosterize = menu.add("Posterize");
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
+        if (item == mItemPreviewRGBA)
+            viewMode = VIEW_MODE_RGBA;
+        if (item == mItemPreviewHist)
+            viewMode = VIEW_MODE_HIST;
+        else if (item == mItemPreviewCanny)
+            viewMode = VIEW_MODE_CANNY;
+        else if (item == mItemPreviewSepia)
+            viewMode = VIEW_MODE_SEPIA;
+        else if (item == mItemPreviewSobel)
+            viewMode = VIEW_MODE_SOBEL;
+        else if (item == mItemPreviewZoom)
+            viewMode = VIEW_MODE_ZOOM;
+        else if (item == mItemPreviewPixelize)
+            viewMode = VIEW_MODE_PIXELIZE;
+        else if (item == mItemPreviewPosterize)
+            viewMode = VIEW_MODE_POSTERIZE;
+        return true;
+    }
+
+    public void onCameraViewStarted(int width, int height) {
+        mIntermediateMat = new Mat();
+        mSize0 = new Size();
+        mChannels = new MatOfInt[] { new MatOfInt(0), new MatOfInt(1), new MatOfInt(2) };
+        mBuff = new float[mHistSizeNum];
+        mHistSize = new MatOfInt(mHistSizeNum);
+        mRanges = new MatOfFloat(0f, 256f);
+        mMat0  = new Mat();
+        mColorsRGB = new Scalar[] { new Scalar(200, 0, 0, 255), new Scalar(0, 200, 0, 255), new Scalar(0, 0, 200, 255) };
+        mColorsHue = new Scalar[] {
+                new Scalar(255, 0, 0, 255),   new Scalar(255, 60, 0, 255),  new Scalar(255, 120, 0, 255), new Scalar(255, 180, 0, 255), new Scalar(255, 240, 0, 255),
+                new Scalar(215, 213, 0, 255), new Scalar(150, 255, 0, 255), new Scalar(85, 255, 0, 255),  new Scalar(20, 255, 0, 255),  new Scalar(0, 255, 30, 255),
+                new Scalar(0, 255, 85, 255),  new Scalar(0, 255, 150, 255), new Scalar(0, 255, 215, 255), new Scalar(0, 234, 255, 255), new Scalar(0, 170, 255, 255),
+                new Scalar(0, 120, 255, 255), new Scalar(0, 60, 255, 255),  new Scalar(0, 0, 255, 255),   new Scalar(64, 0, 255, 255),  new Scalar(120, 0, 255, 255),
+                new Scalar(180, 0, 255, 255), new Scalar(255, 0, 255, 255), new Scalar(255, 0, 215, 255), new Scalar(255, 0, 85, 255),  new Scalar(255, 0, 0, 255)
+        };
+        mWhilte = Scalar.all(255);
+        mP1 = new Point();
+        mP2 = new Point();
+
+        // Fill sepia kernel
+        mSepiaKernel = new Mat(4, 4, CvType.CV_32F);
+        mSepiaKernel.put(0, 0, /* R */0.189f, 0.769f, 0.393f, 0f);
+        mSepiaKernel.put(1, 0, /* G */0.168f, 0.686f, 0.349f, 0f);
+        mSepiaKernel.put(2, 0, /* B */0.131f, 0.534f, 0.272f, 0f);
+        mSepiaKernel.put(3, 0, /* A */0.000f, 0.000f, 0.000f, 1f);
+    }
+
+    public void onCameraViewStopped() {
+        // Explicitly deallocate Mats
+        if (mIntermediateMat != null)
+            mIntermediateMat.release();
+
+        mIntermediateMat = null;
+    }
+
+    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
+        Mat rgba = inputFrame.rgba();
+        Size sizeRgba = rgba.size();
+
+        Mat rgbaInnerWindow;
+
+        int rows = (int) sizeRgba.height;
+        int cols = (int) sizeRgba.width;
+
+        int left = cols / 8;
+        int top = rows / 8;
+
+        int width = cols * 3 / 4;
+        int height = rows * 3 / 4;
+
+        switch (ImageManipulationsActivity.viewMode) {
+        case ImageManipulationsActivity.VIEW_MODE_RGBA:
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_HIST:
+            Mat hist = new Mat();
+            int thikness = (int) (sizeRgba.width / (mHistSizeNum + 10) / 5);
+            if(thikness > 5) thikness = 5;
+            int offset = (int) ((sizeRgba.width - (5*mHistSizeNum + 4*10)*thikness)/2);
+            // RGB
+            for(int c=0; c<3; c++) {
+                Imgproc.calcHist(Arrays.asList(rgba), mChannels[c], mMat0, hist, mHistSize, mRanges);
+                Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);
+                hist.get(0, 0, mBuff);
+                for(int h=0; h<mHistSizeNum; h++) {
+                    mP1.x = mP2.x = offset + (c * (mHistSizeNum + 10) + h) * thikness;
+                    mP1.y = sizeRgba.height-1;
+                    mP2.y = mP1.y - 2 - (int)mBuff[h];
+                    Imgproc.line(rgba, mP1, mP2, mColorsRGB[c], thikness);
+                }
+            }
+            // Value and Hue
+            Imgproc.cvtColor(rgba, mIntermediateMat, Imgproc.COLOR_RGB2HSV_FULL);
+            // Value
+            Imgproc.calcHist(Arrays.asList(mIntermediateMat), mChannels[2], mMat0, hist, mHistSize, mRanges);
+            Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);
+            hist.get(0, 0, mBuff);
+            for(int h=0; h<mHistSizeNum; h++) {
+                mP1.x = mP2.x = offset + (3 * (mHistSizeNum + 10) + h) * thikness;
+                mP1.y = sizeRgba.height-1;
+                mP2.y = mP1.y - 2 - (int)mBuff[h];
+                Imgproc.line(rgba, mP1, mP2, mWhilte, thikness);
+            }
+            // Hue
+            Imgproc.calcHist(Arrays.asList(mIntermediateMat), mChannels[0], mMat0, hist, mHistSize, mRanges);
+            Core.normalize(hist, hist, sizeRgba.height/2, 0, Core.NORM_INF);
+            hist.get(0, 0, mBuff);
+            for(int h=0; h<mHistSizeNum; h++) {
+                mP1.x = mP2.x = offset + (4 * (mHistSizeNum + 10) + h) * thikness;
+                mP1.y = sizeRgba.height-1;
+                mP2.y = mP1.y - 2 - (int)mBuff[h];
+                Imgproc.line(rgba, mP1, mP2, mColorsHue[h], thikness);
+            }
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_CANNY:
+            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
+            Imgproc.Canny(rgbaInnerWindow, mIntermediateMat, 80, 90);
+            Imgproc.cvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4);
+            rgbaInnerWindow.release();
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_SOBEL:
+            Mat gray = inputFrame.gray();
+            Mat grayInnerWindow = gray.submat(top, top + height, left, left + width);
+            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
+            Imgproc.Sobel(grayInnerWindow, mIntermediateMat, CvType.CV_8U, 1, 1);
+            Core.convertScaleAbs(mIntermediateMat, mIntermediateMat, 10, 0);
+            Imgproc.cvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4);
+            grayInnerWindow.release();
+            rgbaInnerWindow.release();
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_SEPIA:
+            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
+            Core.transform(rgbaInnerWindow, rgbaInnerWindow, mSepiaKernel);
+            rgbaInnerWindow.release();
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_ZOOM:
+            Mat zoomCorner = rgba.submat(0, rows / 2 - rows / 10, 0, cols / 2 - cols / 10);
+            Mat mZoomWindow = rgba.submat(rows / 2 - 9 * rows / 100, rows / 2 + 9 * rows / 100, cols / 2 - 9 * cols / 100, cols / 2 + 9 * cols / 100);
+            Imgproc.resize(mZoomWindow, zoomCorner, zoomCorner.size(), 0, 0, Imgproc.INTER_LINEAR_EXACT);
+            Size wsize = mZoomWindow.size();
+            Imgproc.rectangle(mZoomWindow, new Point(1, 1), new Point(wsize.width - 2, wsize.height - 2), new Scalar(255, 0, 0, 255), 2);
+            zoomCorner.release();
+            mZoomWindow.release();
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_PIXELIZE:
+            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
+            Imgproc.resize(rgbaInnerWindow, mIntermediateMat, mSize0, 0.1, 0.1, Imgproc.INTER_NEAREST);
+            Imgproc.resize(mIntermediateMat, rgbaInnerWindow, rgbaInnerWindow.size(), 0., 0., Imgproc.INTER_NEAREST);
+            rgbaInnerWindow.release();
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_POSTERIZE:
+            /*
+            Imgproc.cvtColor(rgbaInnerWindow, mIntermediateMat, Imgproc.COLOR_RGBA2RGB);
+            Imgproc.pyrMeanShiftFiltering(mIntermediateMat, mIntermediateMat, 5, 50);
+            Imgproc.cvtColor(mIntermediateMat, rgbaInnerWindow, Imgproc.COLOR_RGB2RGBA);
+            */
+            rgbaInnerWindow = rgba.submat(top, top + height, left, left + width);
+            Imgproc.Canny(rgbaInnerWindow, mIntermediateMat, 80, 90);
+            rgbaInnerWindow.setTo(new Scalar(0, 0, 0, 255), mIntermediateMat);
+            Core.convertScaleAbs(rgbaInnerWindow, mIntermediateMat, 1./16, 0);
+            Core.convertScaleAbs(mIntermediateMat, rgbaInnerWindow, 16, 0);
+            rgbaInnerWindow.release();
+            break;
+        }
+
+        return rgba;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/CMakeLists.txt
new file mode 100644
index 00000000..4e41ebfb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(sample example-mobilenet-objdetect)
+
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
+if(TARGET ${sample})
+  add_dependencies(opencv_android_examples ${sample})
+endif()
diff --git a/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/build.gradle.in b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/build.gradle.in
new file mode 100644
index 00000000..e8238f73
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/build.gradle.in
@@ -0,0 +1,31 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
+    defaultConfig {
+        applicationId "org.opencv.samples.opencv_mobilenet"
+        minSdkVersion @ANDROID_MIN_SDK_VERSION@
+        targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
+        versionCode 341
+        versionName "3.41"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main {
+            java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            res.srcDirs = @ANDROID_SAMPLE_RES_PATH@
+            manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@'
+        }
+    }
+}
+
+dependencies {
+    //implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':opencv')
+}
diff --git a/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/gradle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/gradle/AndroidManifest.xml
new file mode 100644
index 00000000..473a5db3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/gradle/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="org.opencv.samples.opencv_mobilenet"
+>
+
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.AppCompat.NoActionBar">  <!--Full screen mode-->
+        <activity
+                  android:exported="true"
+                  android:name=".MainActivity"
+                  android:screenOrientation="landscape">  <!--Screen orientation-->
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <!--Allow to use a camera-->
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/res/layout/activity_main.xml b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/res/layout/activity_main.xml
new file mode 100644
index 00000000..516dcb99
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/res/layout/activity_main.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="org.opencv.samples.opencv_mobilenet.MainActivity">
+
+    <org.opencv.android.JavaCameraView
+        android:id="@+id/CameraView"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:visibility="visible" />
+</FrameLayout>
diff --git a/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/res/values/strings.xml b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/res/values/strings.xml
new file mode 100644
index 00000000..a7adc522
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/res/values/strings.xml
@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">opencv_mobilenet</string>
+</resources>
diff --git a/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/src/org/opencv/samples/opencv_mobilenet/MainActivity.java b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/src/org/opencv/samples/opencv_mobilenet/MainActivity.java
new file mode 100644
index 00000000..44b4ba3d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/mobilenet-objdetect/src/org/opencv/samples/opencv_mobilenet/MainActivity.java
@@ -0,0 +1,164 @@
+package org.opencv.samples.opencv_mobilenet;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
+import android.util.Log;
+
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.CameraBridgeViewBase;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.dnn.Net;
+import org.opencv.dnn.Dnn;
+import org.opencv.imgproc.Imgproc;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+public class MainActivity extends AppCompatActivity implements CvCameraViewListener2 {
+
+    // Initialize OpenCV manager.
+    private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
+        @Override
+        public void onManagerConnected(int status) {
+            switch (status) {
+                case LoaderCallbackInterface.SUCCESS: {
+                    Log.i(TAG, "OpenCV loaded successfully");
+                    mOpenCvCameraView.enableView();
+                    break;
+                }
+                default: {
+                    super.onManagerConnected(status);
+                    break;
+                }
+            }
+        }
+    };
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION, this, mLoaderCallback);
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+
+        // Set up camera listener.
+        mOpenCvCameraView = (CameraBridgeViewBase)findViewById(R.id.CameraView);
+        mOpenCvCameraView.setVisibility(CameraBridgeViewBase.VISIBLE);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
+    // Load a network.
+    public void onCameraViewStarted(int width, int height) {
+        String proto = getPath("MobileNetSSD_deploy.prototxt", this);
+        String weights = getPath("MobileNetSSD_deploy.caffemodel", this);
+        net = Dnn.readNetFromCaffe(proto, weights);
+        Log.i(TAG, "Network loaded successfully");
+    }
+
+    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
+        final int IN_WIDTH = 300;
+        final int IN_HEIGHT = 300;
+        final float WH_RATIO = (float)IN_WIDTH / IN_HEIGHT;
+        final double IN_SCALE_FACTOR = 0.007843;
+        final double MEAN_VAL = 127.5;
+        final double THRESHOLD = 0.2;
+
+        // Get a new frame
+        Mat frame = inputFrame.rgba();
+        Imgproc.cvtColor(frame, frame, Imgproc.COLOR_RGBA2RGB);
+
+        // Forward image through network.
+        Mat blob = Dnn.blobFromImage(frame, IN_SCALE_FACTOR,
+                new Size(IN_WIDTH, IN_HEIGHT),
+                new Scalar(MEAN_VAL, MEAN_VAL, MEAN_VAL), /*swapRB*/false, /*crop*/false);
+        net.setInput(blob);
+        Mat detections = net.forward();
+
+        int cols = frame.cols();
+        int rows = frame.rows();
+
+        detections = detections.reshape(1, (int)detections.total() / 7);
+
+        for (int i = 0; i < detections.rows(); ++i) {
+            double confidence = detections.get(i, 2)[0];
+            if (confidence > THRESHOLD) {
+                int classId = (int)detections.get(i, 1)[0];
+
+                int left   = (int)(detections.get(i, 3)[0] * cols);
+                int top    = (int)(detections.get(i, 4)[0] * rows);
+                int right  = (int)(detections.get(i, 5)[0] * cols);
+                int bottom = (int)(detections.get(i, 6)[0] * rows);
+
+                // Draw rectangle around detected object.
+                Imgproc.rectangle(frame, new Point(left, top), new Point(right, bottom),
+                                  new Scalar(0, 255, 0));
+                String label = classNames[classId] + ": " + confidence;
+                int[] baseLine = new int[1];
+                Size labelSize = Imgproc.getTextSize(label, Imgproc.FONT_HERSHEY_SIMPLEX, 0.5, 1, baseLine);
+
+                // Draw background for label.
+                Imgproc.rectangle(frame, new Point(left, top - labelSize.height),
+                                  new Point(left + labelSize.width, top + baseLine[0]),
+                                  new Scalar(255, 255, 255), Imgproc.FILLED);
+                // Write class name and confidence.
+                Imgproc.putText(frame, label, new Point(left, top),
+                        Imgproc.FONT_HERSHEY_SIMPLEX, 0.5, new Scalar(0, 0, 0));
+            }
+        }
+        return frame;
+    }
+
+    public void onCameraViewStopped() {}
+
+    // Upload file to storage and return a path.
+    private static String getPath(String file, Context context) {
+        AssetManager assetManager = context.getAssets();
+
+        BufferedInputStream inputStream = null;
+        try {
+            // Read data from assets.
+            inputStream = new BufferedInputStream(assetManager.open(file));
+            byte[] data = new byte[inputStream.available()];
+            inputStream.read(data);
+            inputStream.close();
+
+            // Create copy file in storage.
+            File outFile = new File(context.getFilesDir(), file);
+            FileOutputStream os = new FileOutputStream(outFile);
+            os.write(data);
+            os.close();
+            // Return a path to file which may be read in common way.
+            return outFile.getAbsolutePath();
+        } catch (IOException ex) {
+            Log.i(TAG, "Failed to upload a file");
+        }
+        return "";
+    }
+
+    private static final String TAG = "OpenCV/Sample/MobileNet";
+    private static final String[] classNames = {"background",
+            "aeroplane", "bicycle", "bird", "boat",
+            "bottle", "bus", "car", "cat", "chair",
+            "cow", "diningtable", "dog", "horse",
+            "motorbike", "person", "pottedplant",
+            "sheep", "sofa", "train", "tvmonitor"};
+
+    private Net net;
+    private CameraBridgeViewBase mOpenCvCameraView;
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/CMakeLists.txt
new file mode 100644
index 00000000..8f8c25ae
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(sample example-tutorial-1-camerapreview)
+
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
+if(TARGET ${sample})
+  add_dependencies(opencv_android_examples ${sample})
+endif()
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/build.gradle.in b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/build.gradle.in
new file mode 100644
index 00000000..5a649175
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/build.gradle.in
@@ -0,0 +1,31 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
+    defaultConfig {
+        applicationId "org.opencv.samples.tutorial1"
+        minSdkVersion @ANDROID_MIN_SDK_VERSION@
+        targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
+        versionCode 301
+        versionName "3.01"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main {
+            java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            res.srcDirs = @ANDROID_SAMPLE_RES_PATH@
+            manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@'
+        }
+    }
+}
+
+dependencies {
+    //implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':opencv')
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/gradle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/gradle/AndroidManifest.xml
new file mode 100644
index 00000000..79aaf3f5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/gradle/AndroidManifest.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="org.opencv.samples.tutorial1"
+>
+
+    <application
+        android:label="@string/app_name"
+        android:icon="@drawable/icon"
+        android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
+
+        <activity
+                  android:exported="true"
+                  android:name="Tutorial1Activity"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true"
+                      android:normalScreens="true"
+                      android:largeScreens="true"
+                      android:anyDensity="true" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/res/drawable/icon.png b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/res/drawable/icon.png
new file mode 100644
index 00000000..63045492
Binary files /dev/null and b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/res/drawable/icon.png differ
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/res/layout/tutorial1_surface_view.xml b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/res/layout/tutorial1_surface_view.xml
new file mode 100644
index 00000000..77f1c5fb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/res/layout/tutorial1_surface_view.xml
@@ -0,0 +1,15 @@
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    xmlns:opencv="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:visibility="gone"
+        android:id="@+id/tutorial1_activity_java_surface_view"
+        opencv:show_fps="true"
+        opencv:camera_id="any" />
+
+</FrameLayout>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/res/values/strings.xml b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/res/values/strings.xml
new file mode 100644
index 00000000..b7bea7d5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OCV T1 Preview</string>
+</resources>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/src/org/opencv/samples/tutorial1/Tutorial1Activity.java b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/src/org/opencv/samples/tutorial1/Tutorial1Activity.java
new file mode 100644
index 00000000..4c9a39b3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-1-camerapreview/src/org/opencv/samples/tutorial1/Tutorial1Activity.java
@@ -0,0 +1,106 @@
+package org.opencv.samples.tutorial1;
+
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.CameraActivity;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Mat;
+import org.opencv.android.CameraBridgeViewBase;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
+
+import android.os.Bundle;
+import android.util.Log;
+import android.view.MenuItem;
+import android.view.SurfaceView;
+import android.view.WindowManager;
+
+import java.util.Collections;
+import java.util.List;
+
+public class Tutorial1Activity extends CameraActivity implements CvCameraViewListener2 {
+    private static final String TAG = "OCVSample::Activity";
+
+    private CameraBridgeViewBase mOpenCvCameraView;
+    private boolean              mIsJavaCamera = true;
+    private MenuItem             mItemSwitchCamera = null;
+
+    private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
+        @Override
+        public void onManagerConnected(int status) {
+            switch (status) {
+                case LoaderCallbackInterface.SUCCESS:
+                {
+                    Log.i(TAG, "OpenCV loaded successfully");
+                    mOpenCvCameraView.enableView();
+                } break;
+                default:
+                {
+                    super.onManagerConnected(status);
+                } break;
+            }
+        }
+    };
+
+    public Tutorial1Activity() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "called onCreate");
+        super.onCreate(savedInstanceState);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.tutorial1_surface_view);
+
+        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.tutorial1_activity_java_surface_view);
+
+        mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
+
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
+    @Override
+    public void onPause()
+    {
+        super.onPause();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public void onResume()
+    {
+        super.onResume();
+        if (!OpenCVLoader.initDebug()) {
+            Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
+            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
+        } else {
+            Log.d(TAG, "OpenCV library found inside package. Using it!");
+            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
+        }
+    }
+
+    @Override
+    protected List<? extends CameraBridgeViewBase> getCameraViewList() {
+        return Collections.singletonList(mOpenCvCameraView);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    public void onCameraViewStarted(int width, int height) {
+    }
+
+    public void onCameraViewStopped() {
+    }
+
+    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
+        return inputFrame.rgba();
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/CMakeLists.txt
new file mode 100644
index 00000000..c254dd8f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/CMakeLists.txt
@@ -0,0 +1,12 @@
+set(sample example-tutorial-2-mixedprocessing)
+
+if(BUILD_FAT_JAVA_LIB)
+  set(native_deps opencv_java)
+else()
+  set(native_deps opencv_features2d)
+endif()
+
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}" NATIVE_DEPS ${native_deps})
+if(TARGET ${sample})
+  add_dependencies(opencv_android_examples ${sample})
+endif()
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/build.gradle.in b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/build.gradle.in
new file mode 100644
index 00000000..7eca49b1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/build.gradle.in
@@ -0,0 +1,43 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
+    defaultConfig {
+        applicationId "org.opencv.samples.tutorial2"
+        minSdkVersion @ANDROID_MIN_SDK_VERSION@
+        targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
+        versionCode 301
+        versionName "3.01"
+
+        externalNativeBuild {
+            cmake {
+                arguments "-DOpenCV_DIR=" + project(':opencv').projectDir + "/@ANDROID_PROJECT_JNI_PATH@"@OPENCV_ANDROID_CMAKE_EXTRA_ARGS@
+                targets "mixed_sample"
+            }
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main {
+            java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            res.srcDirs = @ANDROID_SAMPLE_RES_PATH@
+            manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@'
+        }
+    }
+    externalNativeBuild {
+        cmake {
+             path '@ANDROID_SAMPLE_JNI_PATH@/CMakeLists.txt'
+        }
+    }
+}
+
+dependencies {
+    //implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':opencv')
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/gradle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/gradle/AndroidManifest.xml
new file mode 100644
index 00000000..90d4bbf8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/gradle/AndroidManifest.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="org.opencv.samples.tutorial2"
+>
+
+    <application
+        android:label="@string/app_name"
+        android:icon="@drawable/icon">
+
+        <activity
+                  android:exported="true"
+                  android:name="Tutorial2Activity"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true"
+                      android:normalScreens="true"
+                      android:largeScreens="true"
+                      android:anyDensity="true" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/Android.mk b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/Android.mk
new file mode 100644
index 00000000..6cd88bd7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/Android.mk
@@ -0,0 +1,19 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+ifdef OPENCV_ANDROID_SDK
+  ifneq ("","$(wildcard $(OPENCV_ANDROID_SDK)/OpenCV.mk)")
+    include ${OPENCV_ANDROID_SDK}/OpenCV.mk
+  else
+    include ${OPENCV_ANDROID_SDK}/sdk/native/jni/OpenCV.mk
+  endif
+else
+  include ../../sdk/native/jni/OpenCV.mk
+endif
+
+LOCAL_MODULE    := mixed_sample
+LOCAL_SRC_FILES := jni_part.cpp
+LOCAL_LDLIBS +=  -llog -ldl
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/Application.mk b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/Application.mk
new file mode 100644
index 00000000..4fffcb28
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/Application.mk
@@ -0,0 +1,4 @@
+APP_STL := gnustl_static
+APP_CPPFLAGS := -frtti -fexceptions
+APP_ABI := armeabi-v7a
+APP_PLATFORM := android-8
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/CMakeLists.txt
new file mode 100644
index 00000000..5b34f8b9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/CMakeLists.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.6)
+
+set(target mixed_sample)
+project(${target} CXX)
+
+set(ANDROID_OPENCV_COMPONENTS "opencv_java" CACHE STRING "")
+message(STATUS "ANDROID_ABI=${ANDROID_ABI}")
+find_package(OpenCV REQUIRED COMPONENTS ${ANDROID_OPENCV_COMPONENTS})
+
+file(GLOB srcs *.cpp *.c)
+file(GLOB hdrs *.hpp *.h)
+
+include_directories("${CMAKE_CURRENT_LIST_DIR}")
+add_library(${target} SHARED ${srcs} ${hdrs})
+target_link_libraries(${target} ${ANDROID_OPENCV_COMPONENTS})
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/jni_part.cpp b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/jni_part.cpp
new file mode 100644
index 00000000..72fa0b24
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/jni/jni_part.cpp
@@ -0,0 +1,27 @@
+#include <jni.h>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/features2d.hpp>
+#include <vector>
+
+using namespace std;
+using namespace cv;
+
+extern "C" {
+JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial2_Tutorial2Activity_FindFeatures(JNIEnv*, jobject, jlong addrGray, jlong addrRgba);
+
+JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial2_Tutorial2Activity_FindFeatures(JNIEnv*, jobject, jlong addrGray, jlong addrRgba)
+{
+    Mat& mGr  = *(Mat*)addrGray;
+    Mat& mRgb = *(Mat*)addrRgba;
+    vector<KeyPoint> v;
+
+    Ptr<FeatureDetector> detector = FastFeatureDetector::create(50);
+    detector->detect(mGr, v);
+    for( unsigned int i = 0; i < v.size(); i++ )
+    {
+        const KeyPoint& kp = v[i];
+        circle(mRgb, Point(kp.pt.x, kp.pt.y), 10, Scalar(255,0,0,255));
+    }
+}
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/res/drawable/icon.png b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/res/drawable/icon.png
new file mode 100644
index 00000000..63045492
Binary files /dev/null and b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/res/drawable/icon.png differ
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/res/layout/tutorial2_surface_view.xml b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/res/layout/tutorial2_surface_view.xml
new file mode 100644
index 00000000..a176669a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/res/layout/tutorial2_surface_view.xml
@@ -0,0 +1,11 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.android.JavaCameraView
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:id="@+id/tutorial2_activity_surface_view" />
+
+</LinearLayout>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/res/values/strings.xml b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/res/values/strings.xml
new file mode 100644
index 00000000..0ecc4bb6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OCV T2 Mixed Processing</string>
+</resources>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/src/org/opencv/samples/tutorial2/Tutorial2Activity.java b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/src/org/opencv/samples/tutorial2/Tutorial2Activity.java
new file mode 100644
index 00000000..617247af
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-2-mixedprocessing/src/org/opencv/samples/tutorial2/Tutorial2Activity.java
@@ -0,0 +1,181 @@
+package org.opencv.samples.tutorial2;
+
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.CameraActivity;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.android.CameraBridgeViewBase;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
+import org.opencv.imgproc.Imgproc;
+
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.WindowManager;
+
+import java.util.Collections;
+import java.util.List;
+
+public class Tutorial2Activity extends CameraActivity implements CvCameraViewListener2 {
+    private static final String    TAG = "OCVSample::Activity";
+
+    private static final int       VIEW_MODE_RGBA     = 0;
+    private static final int       VIEW_MODE_GRAY     = 1;
+    private static final int       VIEW_MODE_CANNY    = 2;
+    private static final int       VIEW_MODE_FEATURES = 5;
+
+    private int                    mViewMode;
+    private Mat                    mRgba;
+    private Mat                    mIntermediateMat;
+    private Mat                    mGray;
+
+    private MenuItem               mItemPreviewRGBA;
+    private MenuItem               mItemPreviewGray;
+    private MenuItem               mItemPreviewCanny;
+    private MenuItem               mItemPreviewFeatures;
+
+    private CameraBridgeViewBase   mOpenCvCameraView;
+
+    private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
+        @Override
+        public void onManagerConnected(int status) {
+            switch (status) {
+                case LoaderCallbackInterface.SUCCESS:
+                {
+                    Log.i(TAG, "OpenCV loaded successfully");
+
+                    // Load native library after(!) OpenCV initialization
+                    System.loadLibrary("mixed_sample");
+
+                    mOpenCvCameraView.enableView();
+                } break;
+                default:
+                {
+                    super.onManagerConnected(status);
+                } break;
+            }
+        }
+    };
+
+    public Tutorial2Activity() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "called onCreate");
+        super.onCreate(savedInstanceState);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.tutorial2_surface_view);
+
+        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.tutorial2_activity_surface_view);
+        mOpenCvCameraView.setVisibility(CameraBridgeViewBase.VISIBLE);
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "called onCreateOptionsMenu");
+        mItemPreviewRGBA = menu.add("Preview RGBA");
+        mItemPreviewGray = menu.add("Preview GRAY");
+        mItemPreviewCanny = menu.add("Canny");
+        mItemPreviewFeatures = menu.add("Find features");
+        return true;
+    }
+
+    @Override
+    public void onPause()
+    {
+        super.onPause();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public void onResume()
+    {
+        super.onResume();
+        if (!OpenCVLoader.initDebug()) {
+            Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
+            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
+        } else {
+            Log.d(TAG, "OpenCV library found inside package. Using it!");
+            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
+        }
+    }
+
+    @Override
+    protected List<? extends CameraBridgeViewBase> getCameraViewList() {
+        return Collections.singletonList(mOpenCvCameraView);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    public void onCameraViewStarted(int width, int height) {
+        mRgba = new Mat(height, width, CvType.CV_8UC4);
+        mIntermediateMat = new Mat(height, width, CvType.CV_8UC4);
+        mGray = new Mat(height, width, CvType.CV_8UC1);
+    }
+
+    public void onCameraViewStopped() {
+        mRgba.release();
+        mGray.release();
+        mIntermediateMat.release();
+    }
+
+    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
+        final int viewMode = mViewMode;
+        switch (viewMode) {
+        case VIEW_MODE_GRAY:
+            // input frame has gray scale format
+            Imgproc.cvtColor(inputFrame.gray(), mRgba, Imgproc.COLOR_GRAY2RGBA, 4);
+            break;
+        case VIEW_MODE_RGBA:
+            // input frame has RBGA format
+            mRgba = inputFrame.rgba();
+            break;
+        case VIEW_MODE_CANNY:
+            // input frame has gray scale format
+            mRgba = inputFrame.rgba();
+            Imgproc.Canny(inputFrame.gray(), mIntermediateMat, 80, 100);
+            Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_GRAY2RGBA, 4);
+            break;
+        case VIEW_MODE_FEATURES:
+            // input frame has RGBA format
+            mRgba = inputFrame.rgba();
+            mGray = inputFrame.gray();
+            FindFeatures(mGray.getNativeObjAddr(), mRgba.getNativeObjAddr());
+            break;
+        }
+
+        return mRgba;
+    }
+
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
+
+        if (item == mItemPreviewRGBA) {
+            mViewMode = VIEW_MODE_RGBA;
+        } else if (item == mItemPreviewGray) {
+            mViewMode = VIEW_MODE_GRAY;
+        } else if (item == mItemPreviewCanny) {
+            mViewMode = VIEW_MODE_CANNY;
+        } else if (item == mItemPreviewFeatures) {
+            mViewMode = VIEW_MODE_FEATURES;
+        }
+
+        return true;
+    }
+
+    public native void FindFeatures(long matAddrGr, long matAddrRgba);
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/CMakeLists.txt
new file mode 100644
index 00000000..69100a61
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(sample example-tutorial-3-cameracontrol)
+
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}" LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}" SDK_TARGET 11 "${ANDROID_SDK_TARGET}")
+if(TARGET ${sample})
+  add_dependencies(opencv_android_examples ${sample})
+endif()
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/build.gradle.in b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/build.gradle.in
new file mode 100644
index 00000000..0ba304f5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/build.gradle.in
@@ -0,0 +1,31 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
+    defaultConfig {
+        applicationId "org.opencv.samples.tutorial3"
+        minSdkVersion @ANDROID_MIN_SDK_VERSION@
+        targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
+        versionCode 301
+        versionName "3.01"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main {
+            java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            res.srcDirs = @ANDROID_SAMPLE_RES_PATH@
+            manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@'
+        }
+    }
+}
+
+dependencies {
+    //implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':opencv')
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/gradle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/gradle/AndroidManifest.xml
new file mode 100644
index 00000000..87cbc760
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/gradle/AndroidManifest.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="org.opencv.samples.tutorial3"
+>
+
+    <application
+        android:label="@string/app_name"
+        android:icon="@drawable/icon">
+
+        <activity
+                  android:exported="true"
+                  android:name="Tutorial3Activity"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true"
+                      android:normalScreens="true"
+                      android:largeScreens="true"
+                      android:anyDensity="true" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <uses-feature android:name="android.hardware.camera" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
+    <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/res/drawable/icon.png b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/res/drawable/icon.png
new file mode 100644
index 00000000..63045492
Binary files /dev/null and b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/res/drawable/icon.png differ
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/res/layout/tutorial3_surface_view.xml b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/res/layout/tutorial3_surface_view.xml
new file mode 100644
index 00000000..a5749057
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/res/layout/tutorial3_surface_view.xml
@@ -0,0 +1,12 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.samples.tutorial3.Tutorial3View
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:visibility="gone"
+        android:id="@+id/tutorial3_activity_java_surface_view" />
+
+</LinearLayout>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/res/values/strings.xml b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/res/values/strings.xml
new file mode 100644
index 00000000..d3fb56d9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OCV T3 Camera Control</string>
+</resources>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/src/org/opencv/samples/tutorial3/Tutorial3Activity.java b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/src/org/opencv/samples/tutorial3/Tutorial3Activity.java
new file mode 100644
index 00000000..c487f11e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/src/org/opencv/samples/tutorial3/Tutorial3Activity.java
@@ -0,0 +1,202 @@
+package org.opencv.samples.tutorial3;
+
+import java.text.SimpleDateFormat;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.ListIterator;
+
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.CameraActivity;
+import org.opencv.android.CameraBridgeViewBase;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+import org.opencv.core.Mat;
+import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
+
+import android.annotation.SuppressLint;
+import android.hardware.Camera.Size;
+import android.os.Bundle;
+import android.os.Environment;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.SubMenu;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.View.OnTouchListener;
+import android.view.WindowManager;
+import android.widget.Toast;
+
+public class Tutorial3Activity extends CameraActivity implements CvCameraViewListener2, OnTouchListener {
+    private static final String TAG = "OCVSample::Activity";
+
+    private Tutorial3View mOpenCvCameraView;
+    private List<Size> mResolutionList;
+    private Menu mMenu;
+    private boolean mCameraStarted = false;
+    private boolean mMenuItemsCreated = false;
+    private MenuItem[] mEffectMenuItems;
+    private SubMenu mColorEffectsMenu;
+    private MenuItem[] mResolutionMenuItems;
+    private SubMenu mResolutionMenu;
+
+    private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
+        @Override
+        public void onManagerConnected(int status) {
+            switch (status) {
+                case LoaderCallbackInterface.SUCCESS:
+                {
+                    Log.i(TAG, "OpenCV loaded successfully");
+                    mOpenCvCameraView.enableView();
+                    mOpenCvCameraView.setOnTouchListener(Tutorial3Activity.this);
+                } break;
+                default:
+                {
+                    super.onManagerConnected(status);
+                } break;
+            }
+        }
+    };
+
+    public Tutorial3Activity() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "called onCreate");
+        super.onCreate(savedInstanceState);
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        setContentView(R.layout.tutorial3_surface_view);
+
+        mOpenCvCameraView = (Tutorial3View) findViewById(R.id.tutorial3_activity_java_surface_view);
+
+        mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
+
+        mOpenCvCameraView.setCvCameraViewListener(this);
+    }
+
+    @Override
+    public void onPause()
+    {
+        super.onPause();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public void onResume()
+    {
+        super.onResume();
+        if (!OpenCVLoader.initDebug()) {
+            Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
+            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, mLoaderCallback);
+        } else {
+            Log.d(TAG, "OpenCV library found inside package. Using it!");
+            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
+        }
+    }
+
+    @Override
+    protected List<? extends CameraBridgeViewBase> getCameraViewList() {
+        return Collections.singletonList(mOpenCvCameraView);
+    }
+
+    public void onDestroy() {
+        super.onDestroy();
+        if (mOpenCvCameraView != null)
+            mOpenCvCameraView.disableView();
+    }
+
+    @Override
+    public void onCameraViewStarted(int width, int height) {
+        mCameraStarted = true;
+        setupMenuItems();
+    }
+
+    public void onCameraViewStopped() {
+    }
+
+    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
+        return inputFrame.rgba();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        mMenu = menu;
+        setupMenuItems();
+        return true;
+    }
+
+    private void setupMenuItems() {
+        if (mMenu == null || !mCameraStarted || mMenuItemsCreated) {
+            return;
+        }
+        List<String> effects = mOpenCvCameraView.getEffectList();
+
+        if (effects == null) {
+            Log.e(TAG, "Color effects are not supported by device!");
+            return;
+        }
+
+        mColorEffectsMenu = mMenu.addSubMenu("Color Effect");
+        mEffectMenuItems = new MenuItem[effects.size()];
+
+        int idx = 0;
+        ListIterator<String> effectItr = effects.listIterator();
+        for (String effect: effects) {
+            mEffectMenuItems[idx] = mColorEffectsMenu.add(1, idx, Menu.NONE, effect);
+            idx++;
+        }
+
+        mResolutionMenu = mMenu.addSubMenu("Resolution");
+        mResolutionList = mOpenCvCameraView.getResolutionList();
+        mResolutionMenuItems = new MenuItem[mResolutionList.size()];
+
+        idx = 0;
+        for (Size resolution: mResolutionList) {
+            mResolutionMenuItems[idx] = mResolutionMenu.add(2, idx, Menu.NONE,
+                    Integer.valueOf(resolution.width).toString() + "x" + Integer.valueOf(resolution.height).toString());
+            idx++;
+        }
+        mMenuItemsCreated = true;
+    }
+
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
+        if (item.getGroupId() == 1)
+        {
+            mOpenCvCameraView.setEffect((String) item.getTitle());
+            Toast.makeText(this, mOpenCvCameraView.getEffect(), Toast.LENGTH_SHORT).show();
+        }
+        else if (item.getGroupId() == 2)
+        {
+            int id = item.getItemId();
+            Size resolution = mResolutionList.get(id);
+            mOpenCvCameraView.setResolution(resolution);
+            resolution = mOpenCvCameraView.getResolution();
+            String caption = Integer.valueOf(resolution.width).toString() + "x" + Integer.valueOf(resolution.height).toString();
+            Toast.makeText(this, caption, Toast.LENGTH_SHORT).show();
+        }
+
+        return true;
+    }
+
+    @SuppressLint("SimpleDateFormat")
+    @Override
+    public boolean onTouch(View v, MotionEvent event) {
+        Log.i(TAG,"onTouch event");
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss");
+        String currentDateandTime = sdf.format(new Date());
+        String fileName = Environment.getExternalStorageDirectory().getPath() +
+                               "/sample_picture_" + currentDateandTime + ".jpg";
+        mOpenCvCameraView.takePicture(fileName);
+        Toast.makeText(this, fileName + " saved", Toast.LENGTH_SHORT).show();
+        return false;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/src/org/opencv/samples/tutorial3/Tutorial3View.java b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/src/org/opencv/samples/tutorial3/Tutorial3View.java
new file mode 100644
index 00000000..d102cbcd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-3-cameracontrol/src/org/opencv/samples/tutorial3/Tutorial3View.java
@@ -0,0 +1,87 @@
+package org.opencv.samples.tutorial3;
+
+import java.io.FileOutputStream;
+import java.util.List;
+
+import org.opencv.android.JavaCameraView;
+
+import android.content.Context;
+import android.hardware.Camera;
+import android.hardware.Camera.PictureCallback;
+import android.hardware.Camera.Size;
+import android.util.AttributeSet;
+import android.util.Log;
+
+public class Tutorial3View extends JavaCameraView implements PictureCallback {
+
+    private static final String TAG = "Sample::Tutorial3View";
+    private String mPictureFileName;
+
+    public Tutorial3View(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public List<String> getEffectList() {
+        return mCamera.getParameters().getSupportedColorEffects();
+    }
+
+    public boolean isEffectSupported() {
+        return (mCamera.getParameters().getColorEffect() != null);
+    }
+
+    public String getEffect() {
+        return mCamera.getParameters().getColorEffect();
+    }
+
+    public void setEffect(String effect) {
+        Camera.Parameters params = mCamera.getParameters();
+        params.setColorEffect(effect);
+        mCamera.setParameters(params);
+    }
+
+    public List<Size> getResolutionList() {
+        return mCamera.getParameters().getSupportedPreviewSizes();
+    }
+
+    public void setResolution(Size resolution) {
+        disconnectCamera();
+        mMaxHeight = resolution.height;
+        mMaxWidth = resolution.width;
+        connectCamera(getWidth(), getHeight());
+    }
+
+    public Size getResolution() {
+        return mCamera.getParameters().getPreviewSize();
+    }
+
+    public void takePicture(final String fileName) {
+        Log.i(TAG, "Taking picture");
+        this.mPictureFileName = fileName;
+        // Postview and jpeg are sent in the same buffers if the queue is not empty when performing a capture.
+        // Clear up buffers to avoid mCamera.takePicture to be stuck because of a memory issue
+        mCamera.setPreviewCallback(null);
+
+        // PictureCallback is implemented by the current class
+        mCamera.takePicture(null, null, this);
+    }
+
+    @Override
+    public void onPictureTaken(byte[] data, Camera camera) {
+        Log.i(TAG, "Saving a bitmap to file");
+        // The camera preview was automatically stopped. Start it again.
+        mCamera.startPreview();
+        mCamera.setPreviewCallback(this);
+
+        // Write the image in a file (in jpeg format)
+        try {
+            FileOutputStream fos = new FileOutputStream(mPictureFileName);
+
+            fos.write(data);
+            fos.close();
+
+        } catch (java.io.IOException e) {
+            Log.e("PictureDemo", "Exception in photoCallback", e);
+        }
+
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/CMakeLists.txt
new file mode 100644
index 00000000..94e955fe
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/CMakeLists.txt
@@ -0,0 +1,27 @@
+set(sample example-tutorial-4-opencl)
+if(NOT DEFINED ANDROID_OPENCL_SDK)
+  message(STATUS "Sample ${sample} is disabled, because ANDROID_OPENCL_SDK is not specified")
+  return()
+endif()
+if(ANDROID_NATIVE_API_LEVEL LESS 14)
+  message(STATUS "Sample ${sample} is disabled, because ANDROID_NATIVE_API_LEVEL < 14")
+  return()
+endif()
+
+if(BUILD_FAT_JAVA_LIB)
+  set(native_deps opencv_java)
+else()
+  set(native_deps opencv_imgproc)
+endif()
+
+include_directories(${ANDROID_OPENCL_SDK}/include)
+link_directories(${ANDROID_OPENCL_SDK}/lib/${ANDROID_NDK_ABI_NAME})
+add_android_project(${sample} "${CMAKE_CURRENT_SOURCE_DIR}"
+    LIBRARY_DEPS "${OPENCV_ANDROID_LIB_DIR}"
+    SDK_TARGET 21 "${ANDROID_SDK_TARGET}"
+    NATIVE_DEPS ${native_deps} -lGLESv2 -lEGL -lOpenCL
+    COPY_LIBS YES
+)
+if(TARGET ${sample})
+  add_dependencies(opencv_android_examples ${sample})
+endif()
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/build.gradle.in b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/build.gradle.in
new file mode 100644
index 00000000..2cb9a7bc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/build.gradle.in
@@ -0,0 +1,43 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
+    defaultConfig {
+        applicationId "org.opencv.samples.tutorial4"
+        minSdkVersion @ANDROID_MIN_SDK_VERSION@
+        targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
+        versionCode 301
+        versionName "3.01"
+
+        externalNativeBuild {
+            cmake {
+                arguments "-DOpenCV_DIR=" + project(':opencv').projectDir + "/@ANDROID_PROJECT_JNI_PATH@"@OPENCV_ANDROID_CMAKE_EXTRA_ARGS@
+                targets "JNIpart"
+            }
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main {
+            java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@
+            res.srcDirs = @ANDROID_SAMPLE_RES_PATH@
+            manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@'
+        }
+    }
+    externalNativeBuild {
+        cmake {
+             path '@ANDROID_SAMPLE_JNI_PATH@/CMakeLists.txt'
+        }
+    }
+}
+
+dependencies {
+    //implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':opencv')
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/gradle/AndroidManifest.xml b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/gradle/AndroidManifest.xml
new file mode 100644
index 00000000..7cef5cc6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/gradle/AndroidManifest.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.opencv.samples.tutorial4"
+    android:versionCode="1"
+    android:versionName="1.0" >
+
+    <uses-sdk
+        android:minSdkVersion="14"
+        android:targetSdkVersion="21" />
+
+    <uses-feature android:glEsVersion="0x00020000" android:required="true"/>
+    <uses-feature android:name="android.hardware.camera"/>
+    <uses-feature android:name="android.hardware.camera2" android:required="false"/>
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <application
+        android:allowBackup="true"
+        android:icon="@drawable/icon">
+        <activity
+            android:exported="true"
+            android:name=".Tutorial4Activity"
+            android:label="@string/app_name"
+            android:screenOrientation="landscape"
+            android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/Android.mk b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/Android.mk
new file mode 100644
index 00000000..dacd0f66
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/Android.mk
@@ -0,0 +1,27 @@
+LOCAL_PATH := $(call my-dir)
+
+# add OpenCV
+include $(CLEAR_VARS)
+OPENCV_INSTALL_MODULES:=on
+ifdef OPENCV_ANDROID_SDK
+  ifneq ("","$(wildcard $(OPENCV_ANDROID_SDK)/OpenCV.mk)")
+    include ${OPENCV_ANDROID_SDK}/OpenCV.mk
+  else
+    include ${OPENCV_ANDROID_SDK}/sdk/native/jni/OpenCV.mk
+  endif
+else
+  include ../../sdk/native/jni/OpenCV.mk
+endif
+
+ifndef OPENCL_SDK
+  $(error Specify OPENCL_SDK to Android OpenCL SDK location)
+endif
+
+# add OpenCL
+LOCAL_C_INCLUDES += $(OPENCL_SDK)/include
+LOCAL_LDLIBS += -L$(OPENCL_SDK)/lib/$(TARGET_ARCH_ABI) -lOpenCL
+
+LOCAL_MODULE    := JNIpart
+LOCAL_SRC_FILES := jni.c CLprocessor.cpp
+LOCAL_LDLIBS    += -llog -lGLESv2 -lEGL
+include $(BUILD_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/Application.mk b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/Application.mk
new file mode 100644
index 00000000..06db6576
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/Application.mk
@@ -0,0 +1,4 @@
+APP_STL := gnustl_static
+APP_GNUSTL_FORCE_CPP_FEATURES := exceptions rtti
+APP_ABI := armeabi-v7a
+APP_PLATFORM := android-14
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/CLprocessor.cpp b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/CLprocessor.cpp
new file mode 100644
index 00000000..27b878b3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/CLprocessor.cpp
@@ -0,0 +1,283 @@
+#define __CL_ENABLE_EXCEPTIONS
+#define CL_USE_DEPRECATED_OPENCL_1_1_APIS /*let's give a chance for OpenCL 1.1 devices*/
+#include <CL/cl.hpp>
+
+#include <GLES2/gl2.h>
+#include <EGL/egl.h>
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/core/ocl.hpp>
+
+#include "common.hpp"
+
+const char oclProgB2B[] = "// clBuffer to clBuffer";
+const char oclProgI2B[] = "// clImage to clBuffer";
+const char oclProgI2I[] = \
+  "__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST; \n" \
+    "\n" \
+    "__kernel void Laplacian( \n" \
+    "        __read_only image2d_t imgIn, \n" \
+    "        __write_only image2d_t imgOut \n" \
+    "    ) { \n" \
+    "  \n" \
+    "    const int2 pos = {get_global_id(0), get_global_id(1)}; \n" \
+    "  \n" \
+    "    float4 sum = (float4) 0.0f; \n" \
+    "    sum += read_imagef(imgIn, sampler, pos + (int2)(-1,0)); \n" \
+    "    sum += read_imagef(imgIn, sampler, pos + (int2)(+1,0)); \n" \
+    "    sum += read_imagef(imgIn, sampler, pos + (int2)(0,-1)); \n" \
+    "    sum += read_imagef(imgIn, sampler, pos + (int2)(0,+1)); \n" \
+    "    sum -= read_imagef(imgIn, sampler, pos) * 4; \n" \
+    "  \n" \
+    "    write_imagef(imgOut, pos, sum*10); \n" \
+    "} \n";
+
+void dumpCLinfo()
+{
+    LOGD("*** OpenCL info ***");
+    try
+    {
+        std::vector<cl::Platform> platforms;
+        cl::Platform::get(&platforms);
+        LOGD("OpenCL info: Found %d OpenCL platforms", platforms.size());
+        for (int i = 0; i < platforms.size(); ++i)
+        {
+            std::string name = platforms[i].getInfo<CL_PLATFORM_NAME>();
+            std::string version = platforms[i].getInfo<CL_PLATFORM_VERSION>();
+            std::string profile = platforms[i].getInfo<CL_PLATFORM_PROFILE>();
+            std::string extensions = platforms[i].getInfo<CL_PLATFORM_EXTENSIONS>();
+            LOGD( "OpenCL info: Platform[%d] = %s, ver = %s, prof = %s, ext = %s",
+                  i, name.c_str(), version.c_str(), profile.c_str(), extensions.c_str() );
+        }
+
+        std::vector<cl::Device> devices;
+        platforms[0].getDevices(CL_DEVICE_TYPE_ALL, &devices);
+
+        for (int i = 0; i < devices.size(); ++i)
+        {
+            std::string name = devices[i].getInfo<CL_DEVICE_NAME>();
+            std::string extensions = devices[i].getInfo<CL_DEVICE_EXTENSIONS>();
+            cl_ulong type = devices[i].getInfo<CL_DEVICE_TYPE>();
+            LOGD( "OpenCL info: Device[%d] = %s (%s), ext = %s",
+                  i, name.c_str(), (type==CL_DEVICE_TYPE_GPU ? "GPU" : "CPU"), extensions.c_str() );
+        }
+    }
+    catch(const cl::Error& e)
+    {
+        LOGE( "OpenCL info: error while gathering OpenCL info: %s (%d)", e.what(), e.err() );
+    }
+    catch(const std::exception& e)
+    {
+        LOGE( "OpenCL info: error while gathering OpenCL info: %s", e.what() );
+    }
+    catch(...)
+    {
+        LOGE( "OpenCL info: unknown error while gathering OpenCL info" );
+    }
+    LOGD("*******************");
+}
+
+cl::Context theContext;
+cl::CommandQueue theQueue;
+cl::Program theProgB2B, theProgI2B, theProgI2I;
+bool haveOpenCL = false;
+
+extern "C" void initCL()
+{
+    dumpCLinfo();
+
+    EGLDisplay mEglDisplay = eglGetCurrentDisplay();
+    if (mEglDisplay == EGL_NO_DISPLAY)
+        LOGE("initCL: eglGetCurrentDisplay() returned 'EGL_NO_DISPLAY', error = %x", eglGetError());
+
+    EGLContext mEglContext = eglGetCurrentContext();
+    if (mEglContext == EGL_NO_CONTEXT)
+        LOGE("initCL: eglGetCurrentContext() returned 'EGL_NO_CONTEXT', error = %x", eglGetError());
+
+    cl_context_properties props[] =
+    {   CL_GL_CONTEXT_KHR,   (cl_context_properties) mEglContext,
+        CL_EGL_DISPLAY_KHR,  (cl_context_properties) mEglDisplay,
+        CL_CONTEXT_PLATFORM, 0,
+        0 };
+
+    try
+    {
+        haveOpenCL = false;
+        cl::Platform p = cl::Platform::getDefault();
+        std::string ext = p.getInfo<CL_PLATFORM_EXTENSIONS>();
+        if(ext.find("cl_khr_gl_sharing") == std::string::npos)
+            LOGE("Warning: CL-GL sharing isn't supported by PLATFORM");
+        props[5] = (cl_context_properties) p();
+
+        theContext = cl::Context(CL_DEVICE_TYPE_GPU, props);
+        std::vector<cl::Device> devs = theContext.getInfo<CL_CONTEXT_DEVICES>();
+        LOGD("Context returned %d devices, taking the 1st one", devs.size());
+        ext = devs[0].getInfo<CL_DEVICE_EXTENSIONS>();
+        if(ext.find("cl_khr_gl_sharing") == std::string::npos)
+            LOGE("Warning: CL-GL sharing isn't supported by DEVICE");
+
+        theQueue = cl::CommandQueue(theContext, devs[0]);
+
+        cl::Program::Sources src(1, std::make_pair(oclProgI2I, sizeof(oclProgI2I)));
+        theProgI2I = cl::Program(theContext, src);
+        theProgI2I.build(devs);
+
+        cv::ocl::attachContext(p.getInfo<CL_PLATFORM_NAME>(), p(), theContext(), devs[0]());
+        if( cv::ocl::useOpenCL() )
+            LOGD("OpenCV+OpenCL works OK!");
+        else
+            LOGE("Can't init OpenCV with OpenCL TAPI");
+        haveOpenCL = true;
+    }
+    catch(const cl::Error& e)
+    {
+        LOGE("cl::Error: %s (%d)", e.what(), e.err());
+    }
+    catch(const std::exception& e)
+    {
+        LOGE("std::exception: %s", e.what());
+    }
+    catch(...)
+    {
+        LOGE( "OpenCL info: unknown error while initializing OpenCL stuff" );
+    }
+    LOGD("initCL completed");
+}
+
+extern "C" void closeCL()
+{
+}
+
+#define GL_TEXTURE_2D 0x0DE1
+void procOCL_I2I(int texIn, int texOut, int w, int h)
+{
+    LOGD("Processing OpenCL Direct (image2d)");
+    if(!haveOpenCL)
+    {
+        LOGE("OpenCL isn't initialized");
+        return;
+    }
+
+    LOGD("procOCL_I2I(%d, %d, %d, %d)", texIn, texOut, w, h);
+    cl::ImageGL imgIn (theContext, CL_MEM_READ_ONLY,  GL_TEXTURE_2D, 0, texIn);
+    cl::ImageGL imgOut(theContext, CL_MEM_WRITE_ONLY, GL_TEXTURE_2D, 0, texOut);
+    std::vector < cl::Memory > images;
+    images.push_back(imgIn);
+    images.push_back(imgOut);
+
+    int64_t t = getTimeMs();
+    theQueue.enqueueAcquireGLObjects(&images);
+    theQueue.finish();
+    LOGD("enqueueAcquireGLObjects() costs %d ms", getTimeInterval(t));
+
+    t = getTimeMs();
+    cl::Kernel Laplacian(theProgI2I, "Laplacian"); //TODO: may be done once
+    Laplacian.setArg(0, imgIn);
+    Laplacian.setArg(1, imgOut);
+    theQueue.finish();
+    LOGD("Kernel() costs %d ms", getTimeInterval(t));
+
+    t = getTimeMs();
+    theQueue.enqueueNDRangeKernel(Laplacian, cl::NullRange, cl::NDRange(w, h), cl::NullRange);
+    theQueue.finish();
+    LOGD("enqueueNDRangeKernel() costs %d ms", getTimeInterval(t));
+
+    t = getTimeMs();
+    theQueue.enqueueReleaseGLObjects(&images);
+    theQueue.finish();
+    LOGD("enqueueReleaseGLObjects() costs %d ms", getTimeInterval(t));
+}
+
+void procOCL_OCV(int texIn, int texOut, int w, int h)
+{
+    LOGD("Processing OpenCL via OpenCV");
+    if(!haveOpenCL)
+    {
+        LOGE("OpenCL isn't initialized");
+        return;
+    }
+
+    int64_t t = getTimeMs();
+    cl::ImageGL imgIn (theContext, CL_MEM_READ_ONLY,  GL_TEXTURE_2D, 0, texIn);
+    std::vector < cl::Memory > images(1, imgIn);
+    theQueue.enqueueAcquireGLObjects(&images);
+    theQueue.finish();
+    cv::UMat uIn, uOut, uTmp;
+    cv::ocl::convertFromImage(imgIn(), uIn);
+    LOGD("loading texture data to OpenCV UMat costs %d ms", getTimeInterval(t));
+    theQueue.enqueueReleaseGLObjects(&images);
+
+    t = getTimeMs();
+    //cv::blur(uIn, uOut, cv::Size(5, 5));
+    cv::Laplacian(uIn, uTmp, CV_8U);
+    cv:multiply(uTmp, 10, uOut);
+    cv::ocl::finish();
+    LOGD("OpenCV processing costs %d ms", getTimeInterval(t));
+
+    t = getTimeMs();
+    cl::ImageGL imgOut(theContext, CL_MEM_WRITE_ONLY, GL_TEXTURE_2D, 0, texOut);
+    images.clear();
+    images.push_back(imgOut);
+    theQueue.enqueueAcquireGLObjects(&images);
+    cl_mem clBuffer = (cl_mem)uOut.handle(cv::ACCESS_READ);
+    cl_command_queue q = (cl_command_queue)cv::ocl::Queue::getDefault().ptr();
+    size_t offset = 0;
+    size_t origin[3] = { 0, 0, 0 };
+    size_t region[3] = { w, h, 1 };
+    CV_Assert(clEnqueueCopyBufferToImage (q, clBuffer, imgOut(), offset, origin, region, 0, NULL, NULL) == CL_SUCCESS);
+    theQueue.enqueueReleaseGLObjects(&images);
+    cv::ocl::finish();
+    LOGD("uploading results to texture costs %d ms", getTimeInterval(t));
+}
+
+void drawFrameProcCPU(int w, int h, int texOut)
+{
+    LOGD("Processing on CPU");
+    int64_t t;
+
+    // let's modify pixels in FBO texture in C++ code (on CPU)
+    static cv::Mat m;
+    m.create(h, w, CV_8UC4);
+
+    // read
+    t = getTimeMs();
+    // expecting FBO to be bound
+    glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, m.data);
+    LOGD("glReadPixels() costs %d ms", getTimeInterval(t));
+
+   // modify
+    t = getTimeMs();
+    cv::Laplacian(m, m, CV_8U);
+    m *= 10;
+    LOGD("Laplacian() costs %d ms", getTimeInterval(t));
+
+    // write back
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, texOut);
+    t = getTimeMs();
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, m.data);
+    LOGD("glTexSubImage2D() costs %d ms", getTimeInterval(t));
+}
+
+
+enum ProcMode {PROC_MODE_NO_PROC=0, PROC_MODE_CPU=1, PROC_MODE_OCL_DIRECT=2, PROC_MODE_OCL_OCV=3};
+
+extern "C" void processFrame(int tex1, int tex2, int w, int h, int mode)
+{
+    switch(mode)
+    {
+        //case PROC_MODE_NO_PROC:
+    case PROC_MODE_CPU:
+        drawFrameProcCPU(w, h, tex2);
+        break;
+    case PROC_MODE_OCL_DIRECT:
+        procOCL_I2I(tex1, tex2, w, h);
+        break;
+    case PROC_MODE_OCL_OCV:
+        procOCL_OCV(tex1, tex2, w, h);
+        break;
+    default:
+        LOGE("Unexpected processing mode: %d", mode);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/CMakeLists.txt b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/CMakeLists.txt
new file mode 100644
index 00000000..4fdea135
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/CMakeLists.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.6)
+
+set(target mixed_sample)
+project(${target} CXX)
+
+set(ANDROID_OPENCV_COMPONENTS "opencv_java" CACHE STRING "")
+message(STATUS "ANDROID_ABI=${ANDROID_ABI}")
+find_package(OpenCV REQUIRED COMPONENTS ${ANDROID_OPENCV_COMPONENTS})
+
+file(GLOB srcs *.cpp *.c)
+file(GLOB hdrs *.hpp *.h)
+
+include_directories("${CMAKE_CURRENT_LIST_DIR}")
+add_library(${target} SHARED ${srcs} ${hdrs})
+target_link_libraries(${target} ${ANDROID_OPENCV_COMPONENTS} -lGLESv2 -lEGL -lOpenCL)
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/common.hpp b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/common.hpp
new file mode 100644
index 00000000..2923803f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/common.hpp
@@ -0,0 +1,19 @@
+#include <android/log.h>
+#define LOG_TAG "JNIpart"
+//#define LOGD(...)
+#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
+#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__))
+
+#include <time.h> // clock_gettime
+
+static inline int64_t getTimeMs()
+{
+    struct timespec now;
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    return (int64_t) now.tv_sec*1000 + now.tv_nsec/1000000;
+}
+
+static inline int getTimeInterval(int64_t startTime)
+{
+    return int(getTimeMs() - startTime);
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/jni.c b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/jni.c
new file mode 100644
index 00000000..0c48ab60
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/jni/jni.c
@@ -0,0 +1,20 @@
+#include <jni.h>
+
+int initCL();
+void closeCL();
+void processFrame(int tex1, int tex2, int w, int h, int mode);
+
+JNIEXPORT jint JNICALL Java_org_opencv_samples_tutorial4_NativePart_initCL(JNIEnv * env, jclass cls)
+{
+    return initCL();
+}
+
+JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial4_NativePart_closeCL(JNIEnv * env, jclass cls)
+{
+    closeCL();
+}
+
+JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial4_NativePart_processFrame(JNIEnv * env, jclass cls, jint tex1, jint tex2, jint w, jint h, jint mode)
+{
+    processFrame(tex1, tex2, w, h, mode);
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/lint.xml b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/lint.xml
new file mode 100644
index 00000000..ee0eead5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/lint.xml
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<lint>
+</lint>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/drawable/icon.png b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/drawable/icon.png
new file mode 100644
index 00000000..63045492
Binary files /dev/null and b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/drawable/icon.png differ
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/layout/activity.xml b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/layout/activity.xml
new file mode 100644
index 00000000..86f87b25
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/layout/activity.xml
@@ -0,0 +1,26 @@
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <org.opencv.samples.tutorial4.MyGLSurfaceView
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:id="@+id/my_gl_surface_view" />
+
+    <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:orientation = "vertical" >
+	    <TextView
+	        android:layout_width="wrap_content"
+	        android:layout_height="wrap_content"
+	        android:id="@+id/fps_text_view"
+	        android:text="FPS:" />
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:id="@+id/proc_mode_text_view"
+            android:text="Processing mode:" />
+	    </LinearLayout>
+
+</FrameLayout>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/menu/menu.xml b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/menu/menu.xml
new file mode 100644
index 00000000..dc27333e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/menu/menu.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android" >
+    <group android:checkableBehavior="single">
+        <item android:id="@+id/no_proc" android:title="No processing" />
+        <item android:id="@+id/cpu" android:title="Use CPU code" />
+        <item android:id="@+id/ocl_direct" android:title="Use OpenCL direct" />
+        <item android:id="@+id/ocl_ocv" android:title="Use OpenCL via OpenCV" />
+    </group>
+</menu>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/values/strings.xml b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/values/strings.xml
new file mode 100644
index 00000000..c2f87e29
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/res/values/strings.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <string name="app_name">OpenCV Tutorial 4 - Use OpenCL</string>
+
+</resources>
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/src/org/opencv/samples/tutorial4/MyGLSurfaceView.java b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/src/org/opencv/samples/tutorial4/MyGLSurfaceView.java
new file mode 100644
index 00000000..edaf3463
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/src/org/opencv/samples/tutorial4/MyGLSurfaceView.java
@@ -0,0 +1,112 @@
+package org.opencv.samples.tutorial4;
+
+import org.opencv.android.CameraGLSurfaceView;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.SurfaceHolder;
+import android.widget.TextView;
+import android.widget.Toast;
+
+public class MyGLSurfaceView extends CameraGLSurfaceView implements CameraGLSurfaceView.CameraTextureListener {
+
+    static final String LOGTAG = "MyGLSurfaceView";
+    protected int procMode = NativePart.PROCESSING_MODE_NO_PROCESSING;
+    static final String[] procModeName = new String[] {"No Processing", "CPU", "OpenCL Direct", "OpenCL via OpenCV"};
+    protected int  frameCounter;
+    protected long lastNanoTime;
+    TextView mFpsText = null;
+
+    public MyGLSurfaceView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent e) {
+        if(e.getAction() == MotionEvent.ACTION_DOWN)
+            ((Activity)getContext()).openOptionsMenu();
+        return true;
+    }
+
+    @Override
+    public void surfaceCreated(SurfaceHolder holder) {
+        super.surfaceCreated(holder);
+        //NativePart.initCL();
+    }
+
+    @Override
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        //NativePart.closeCL();
+        super.surfaceDestroyed(holder);
+    }
+
+    public void setProcessingMode(int newMode) {
+        if(newMode>=0 && newMode<procModeName.length)
+            procMode = newMode;
+        else
+            Log.e(LOGTAG, "Ignoring invalid processing mode: " + newMode);
+
+        ((Activity) getContext()).runOnUiThread(new Runnable() {
+            public void run() {
+                Toast.makeText(getContext(), "Selected mode: " + procModeName[procMode], Toast.LENGTH_LONG).show();
+            }
+        });
+    }
+
+    @Override
+    public void onCameraViewStarted(int width, int height) {
+        ((Activity) getContext()).runOnUiThread(new Runnable() {
+            public void run() {
+                Toast.makeText(getContext(), "onCameraViewStarted", Toast.LENGTH_SHORT).show();
+            }
+        });
+        NativePart.initCL();
+        frameCounter = 0;
+        lastNanoTime = System.nanoTime();
+    }
+
+    @Override
+    public void onCameraViewStopped() {
+        ((Activity) getContext()).runOnUiThread(new Runnable() {
+            public void run() {
+                Toast.makeText(getContext(), "onCameraViewStopped", Toast.LENGTH_SHORT).show();
+            }
+        });
+    }
+
+    @Override
+    public boolean onCameraTexture(int texIn, int texOut, int width, int height) {
+        // FPS
+        frameCounter++;
+        if(frameCounter >= 30)
+        {
+            final int fps = (int) (frameCounter * 1e9 / (System.nanoTime() - lastNanoTime));
+            Log.i(LOGTAG, "drawFrame() FPS: "+fps);
+            if(mFpsText != null) {
+                Runnable fpsUpdater = new Runnable() {
+                    public void run() {
+                        mFpsText.setText("FPS: " + fps);
+                    }
+                };
+                new Handler(Looper.getMainLooper()).post(fpsUpdater);
+            } else {
+                Log.d(LOGTAG, "mFpsText == null");
+                mFpsText = (TextView)((Activity) getContext()).findViewById(R.id.fps_text_view);
+            }
+            frameCounter = 0;
+            lastNanoTime = System.nanoTime();
+        }
+
+
+        if(procMode == NativePart.PROCESSING_MODE_NO_PROCESSING)
+            return false;
+
+        NativePart.processFrame(texIn, texOut, width, height, procMode);
+        return true;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/src/org/opencv/samples/tutorial4/NativePart.java b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/src/org/opencv/samples/tutorial4/NativePart.java
new file mode 100644
index 00000000..e3d11709
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/src/org/opencv/samples/tutorial4/NativePart.java
@@ -0,0 +1,18 @@
+package org.opencv.samples.tutorial4;
+
+public class NativePart {
+    static
+    {
+        System.loadLibrary("opencv_java4");
+        System.loadLibrary("JNIpart");
+    }
+
+    public static final int PROCESSING_MODE_NO_PROCESSING = 0;
+    public static final int PROCESSING_MODE_CPU = 1;
+    public static final int PROCESSING_MODE_OCL_DIRECT = 2;
+    public static final int PROCESSING_MODE_OCL_OCV = 3;
+
+    public static native int initCL();
+    public static native void closeCL();
+    public static native void processFrame(int tex1, int tex2, int w, int h, int mode);
+}
diff --git a/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/src/org/opencv/samples/tutorial4/Tutorial4Activity.java b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/src/org/opencv/samples/tutorial4/Tutorial4Activity.java
new file mode 100644
index 00000000..0be55df6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/android/tutorial-4-opencl/src/org/opencv/samples/tutorial4/Tutorial4Activity.java
@@ -0,0 +1,102 @@
+package org.opencv.samples.tutorial4;
+
+import android.app.Activity;
+import android.content.pm.ActivityInfo;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.TextView;
+
+public class Tutorial4Activity extends Activity {
+
+    private MyGLSurfaceView mView;
+    private TextView mProcMode;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
+                WindowManager.LayoutParams.FLAG_FULLSCREEN);
+        getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
+                WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+
+        //mView = new MyGLSurfaceView(this, null);
+        //setContentView(mView);
+        setContentView(R.layout.activity);
+        mView = (MyGLSurfaceView) findViewById(R.id.my_gl_surface_view);
+        mView.setCameraTextureListener(mView);
+        TextView tv = (TextView)findViewById(R.id.fps_text_view);
+        mProcMode = (TextView)findViewById(R.id.proc_mode_text_view);
+        runOnUiThread(new Runnable() {
+            public void run() {
+                mProcMode.setText("Processing mode: No processing");
+            }
+        });
+
+        mView.setProcessingMode(NativePart.PROCESSING_MODE_NO_PROCESSING);
+    }
+
+    @Override
+    protected void onPause() {
+        mView.onPause();
+        super.onPause();
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        mView.onResume();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.menu, menu);
+        return super.onCreateOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+        case R.id.no_proc:
+            runOnUiThread(new Runnable() {
+                public void run() {
+                    mProcMode.setText("Processing mode: No Processing");
+                }
+            });
+            mView.setProcessingMode(NativePart.PROCESSING_MODE_NO_PROCESSING);
+            return true;
+        case R.id.cpu:
+            runOnUiThread(new Runnable() {
+                public void run() {
+                    mProcMode.setText("Processing mode: CPU");
+                }
+            });
+            mView.setProcessingMode(NativePart.PROCESSING_MODE_CPU);
+            return true;
+        case R.id.ocl_direct:
+            runOnUiThread(new Runnable() {
+                public void run() {
+                    mProcMode.setText("Processing mode: OpenCL direct");
+                }
+            });
+            mView.setProcessingMode(NativePart.PROCESSING_MODE_OCL_DIRECT);
+            return true;
+        case R.id.ocl_ocv:
+            runOnUiThread(new Runnable() {
+                public void run() {
+                    mProcMode.setText("Processing mode: OpenCL via OpenCV (TAPI)");
+                }
+            });
+            mView.setProcessingMode(NativePart.PROCESSING_MODE_OCL_OCV);
+            return true;
+        default:
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/cpp/3calibration.cpp b/C++/opencv-4.7.0/samples/cpp/3calibration.cpp
new file mode 100644
index 00000000..2495dbd0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/3calibration.cpp
@@ -0,0 +1,360 @@
+/*
+ * 3calibration.cpp -- Calibrate 3 cameras in a horizontal line together.
+ */
+
+#include "opencv2/calib3d.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core/utility.hpp"
+
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+using namespace cv;
+using namespace std;
+
+enum { DETECTION = 0, CAPTURING = 1, CALIBRATED = 2 };
+
+static void help(char** argv)
+{
+        printf( "\nThis is a camera calibration sample that calibrates 3 horizontally placed cameras together.\n"
+               "Usage: %s\n"
+               "     -w=<board_width>         # the number of inner corners per one of board dimension\n"
+               "     -h=<board_height>        # the number of inner corners per another board dimension\n"
+               "     [-s=<squareSize>]       # square size in some user-defined units (1 by default)\n"
+               "     [-o=<out_camera_params>] # the output filename for intrinsic [and extrinsic] parameters\n"
+               "     [-zt]                    # assume zero tangential distortion\n"
+               "     [-a=<aspectRatio>]      # fix aspect ratio (fx/fy)\n"
+               "     [-p]                     # fix the principal point at the center\n"
+               "     [input_data]             # input data - text file with a list of the images of the board\n"
+               "\n", argv[0] );
+
+}
+
+static void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners)
+{
+    corners.resize(0);
+
+    for( int i = 0; i < boardSize.height; i++ )
+        for( int j = 0; j < boardSize.width; j++ )
+            corners.push_back(Point3f(float(j*squareSize),
+                                      float(i*squareSize), 0));
+}
+
+static bool run3Calibration(vector<vector<Point2f> > imagePoints1,
+                            vector<vector<Point2f> > imagePoints2,
+                            vector<vector<Point2f> > imagePoints3,
+                            Size imageSize, Size boardSize,
+                            float squareSize, float aspectRatio,
+                            int flags,
+                            Mat& cameraMatrix1, Mat& distCoeffs1,
+                            Mat& cameraMatrix2, Mat& distCoeffs2,
+                            Mat& cameraMatrix3, Mat& distCoeffs3,
+                            Mat& R12, Mat& T12, Mat& R13, Mat& T13)
+{
+    int c, i;
+
+    // step 1: calibrate each camera individually
+    vector<vector<Point3f> > objpt(1);
+    vector<vector<Point2f> > imgpt;
+    calcChessboardCorners(boardSize, squareSize, objpt[0]);
+    vector<Mat> rvecs, tvecs;
+
+    for( c = 1; c <= 3; c++ )
+    {
+        const vector<vector<Point2f> >& imgpt0 = c == 1 ? imagePoints1 : c == 2 ? imagePoints2 : imagePoints3;
+        imgpt.clear();
+        int N = 0;
+        for( i = 0; i < (int)imgpt0.size(); i++ )
+            if( !imgpt0[i].empty() )
+            {
+                imgpt.push_back(imgpt0[i]);
+                N += (int)imgpt0[i].size();
+            }
+
+        if( imgpt.size() < 3 )
+        {
+            printf("Error: not enough views for camera %d\n", c);
+            return false;
+        }
+
+        objpt.resize(imgpt.size(),objpt[0]);
+
+        Mat cameraMatrix = Mat::eye(3, 3, CV_64F);
+        if( flags & CALIB_FIX_ASPECT_RATIO )
+            cameraMatrix.at<double>(0,0) = aspectRatio;
+
+        Mat distCoeffs = Mat::zeros(5, 1, CV_64F);
+
+        double err = calibrateCamera(objpt, imgpt, imageSize, cameraMatrix,
+                        distCoeffs, rvecs, tvecs,
+                        flags|CALIB_FIX_K3/*|CALIB_FIX_K4|CALIB_FIX_K5|CALIB_FIX_K6*/);
+        bool ok = checkRange(cameraMatrix) && checkRange(distCoeffs);
+        if(!ok)
+        {
+            printf("Error: camera %d was not calibrated\n", c);
+            return false;
+        }
+        printf("Camera %d calibration reprojection error = %g\n", c, sqrt(err/N));
+
+        if( c == 1 )
+            cameraMatrix1 = cameraMatrix, distCoeffs1 = distCoeffs;
+        else if( c == 2 )
+            cameraMatrix2 = cameraMatrix, distCoeffs2 = distCoeffs;
+        else
+            cameraMatrix3 = cameraMatrix, distCoeffs3 = distCoeffs;
+    }
+
+    vector<vector<Point2f> > imgpt_right;
+
+    // step 2: calibrate (1,2) and (3,2) pairs
+    for( c = 2; c <= 3; c++ )
+    {
+        const vector<vector<Point2f> >& imgpt0 = c == 2 ? imagePoints2 : imagePoints3;
+
+        imgpt.clear();
+        imgpt_right.clear();
+        int N = 0;
+
+        for( i = 0; i < (int)std::min(imagePoints1.size(), imgpt0.size()); i++ )
+            if( !imagePoints1.empty() && !imgpt0[i].empty() )
+            {
+                imgpt.push_back(imagePoints1[i]);
+                imgpt_right.push_back(imgpt0[i]);
+                N += (int)imgpt0[i].size();
+            }
+
+        if( imgpt.size() < 3 )
+        {
+            printf("Error: not enough shared views for cameras 1 and %d\n", c);
+            return false;
+        }
+
+        objpt.resize(imgpt.size(),objpt[0]);
+        Mat cameraMatrix = c == 2 ? cameraMatrix2 : cameraMatrix3;
+        Mat distCoeffs = c == 2 ? distCoeffs2 : distCoeffs3;
+        Mat R, T, E, F;
+        double err = stereoCalibrate(objpt, imgpt, imgpt_right, cameraMatrix1, distCoeffs1,
+                                     cameraMatrix, distCoeffs,
+                                     imageSize, R, T, E, F,
+                                     CALIB_FIX_INTRINSIC,
+                                     TermCriteria(TermCriteria::COUNT, 30, 0));
+        printf("Pair (1,%d) calibration reprojection error = %g\n", c, sqrt(err/(N*2)));
+        if( c == 2 )
+        {
+            cameraMatrix2 = cameraMatrix;
+            distCoeffs2 = distCoeffs;
+            R12 = R; T12 = T;
+        }
+        else
+        {
+            R13 = R; T13 = T;
+        }
+    }
+
+    return true;
+}
+
+static bool readStringList( const string& filename, vector<string>& l )
+{
+    l.resize(0);
+    FileStorage fs(filename, FileStorage::READ);
+    if( !fs.isOpened() )
+        return false;
+    FileNode n = fs.getFirstTopLevelNode();
+    if( n.type() != FileNode::SEQ )
+        return false;
+    FileNodeIterator it = n.begin(), it_end = n.end();
+    for( ; it != it_end; ++it )
+        l.push_back((string)*it);
+    return true;
+}
+
+
+int main( int argc, char** argv )
+{
+    int i, k;
+    int flags = 0;
+    Size boardSize, imageSize;
+    float squareSize, aspectRatio;
+    string outputFilename;
+    string inputFilename = "";
+
+    vector<vector<Point2f> > imgpt[3];
+    vector<string> imageList;
+
+    cv::CommandLineParser parser(argc, argv,
+        "{help ||}{w||}{h||}{s|1|}{o|out_camera_data.yml|}"
+        "{zt||}{a|1|}{p||}{@input||}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    boardSize.width = parser.get<int>("w");
+    boardSize.height = parser.get<int>("h");
+    squareSize = parser.get<float>("s");
+    aspectRatio = parser.get<float>("a");
+    if (parser.has("a"))
+        flags |= CALIB_FIX_ASPECT_RATIO;
+    if (parser.has("zt"))
+        flags |= CALIB_ZERO_TANGENT_DIST;
+    if (parser.has("p"))
+        flags |= CALIB_FIX_PRINCIPAL_POINT;
+    outputFilename = parser.get<string>("o");
+    inputFilename = parser.get<string>("@input");
+    if (!parser.check())
+    {
+        help(argv);
+        parser.printErrors();
+        return -1;
+    }
+    if (boardSize.width <= 0)
+        return fprintf( stderr, "Invalid board width\n" ), -1;
+    if (boardSize.height <= 0)
+        return fprintf( stderr, "Invalid board height\n" ), -1;
+    if (squareSize <= 0)
+        return fprintf( stderr, "Invalid board square width\n" ), -1;
+    if (aspectRatio <= 0)
+        return printf("Invalid aspect ratio\n" ), -1;
+    if( inputFilename.empty() ||
+       !readStringList(inputFilename, imageList) ||
+       imageList.size() == 0 || imageList.size() % 3 != 0 )
+    {
+        printf("Error: the input image list is not specified, or can not be read, or the number of files is not divisible by 3\n");
+        return -1;
+    }
+
+    Mat view, viewGray;
+    Mat cameraMatrix[3], distCoeffs[3], R[3], P[3], R12, T12;
+    for( k = 0; k < 3; k++ )
+    {
+        cameraMatrix[k] = Mat_<double>::eye(3,3);
+        cameraMatrix[k].at<double>(0,0) = aspectRatio;
+        cameraMatrix[k].at<double>(1,1) = 1;
+        distCoeffs[k] = Mat_<double>::zeros(5,1);
+    }
+    Mat R13=Mat_<double>::eye(3,3), T13=Mat_<double>::zeros(3,1);
+
+    FileStorage fs;
+    namedWindow( "Image View", 0 );
+
+    for( k = 0; k < 3; k++ )
+        imgpt[k].resize(imageList.size()/3);
+
+    for( i = 0; i < (int)(imageList.size()/3); i++ )
+    {
+        for( k = 0; k < 3; k++ )
+        {
+            int k1 = k == 0 ? 2 : k == 1 ? 0 : 1;
+            printf("%s\n", imageList[i*3+k].c_str());
+            view = imread(imageList[i*3+k], 1);
+
+            if(!view.empty())
+            {
+                vector<Point2f> ptvec;
+                imageSize = view.size();
+                cvtColor(view, viewGray, COLOR_BGR2GRAY);
+                bool found = findChessboardCorners( view, boardSize, ptvec, CALIB_CB_ADAPTIVE_THRESH );
+
+                drawChessboardCorners( view, boardSize, Mat(ptvec), found );
+                if( found )
+                {
+                    imgpt[k1][i].resize(ptvec.size());
+                    std::copy(ptvec.begin(), ptvec.end(), imgpt[k1][i].begin());
+                }
+                //imshow("view", view);
+                //int c = waitKey(0) & 255;
+                //if( c == 27 || c == 'q' || c == 'Q' )
+                //    return -1;
+            }
+        }
+    }
+
+    printf("Running calibration ...\n");
+
+    run3Calibration(imgpt[0], imgpt[1], imgpt[2], imageSize,
+                    boardSize, squareSize, aspectRatio, flags|CALIB_FIX_K4|CALIB_FIX_K5,
+                    cameraMatrix[0], distCoeffs[0],
+                    cameraMatrix[1], distCoeffs[1],
+                    cameraMatrix[2], distCoeffs[2],
+                    R12, T12, R13, T13);
+
+    fs.open(outputFilename, FileStorage::WRITE);
+
+    fs << "cameraMatrix1" << cameraMatrix[0];
+    fs << "cameraMatrix2" << cameraMatrix[1];
+    fs << "cameraMatrix3" << cameraMatrix[2];
+
+    fs << "distCoeffs1" << distCoeffs[0];
+    fs << "distCoeffs2" << distCoeffs[1];
+    fs << "distCoeffs3" << distCoeffs[2];
+
+    fs << "R12" << R12;
+    fs << "T12" << T12;
+    fs << "R13" << R13;
+    fs << "T13" << T13;
+
+    fs << "imageWidth" << imageSize.width;
+    fs << "imageHeight" << imageSize.height;
+
+    Mat Q;
+
+    // step 3: find rectification transforms
+    double ratio = rectify3Collinear(cameraMatrix[0], distCoeffs[0], cameraMatrix[1],
+             distCoeffs[1], cameraMatrix[2], distCoeffs[2],
+             imgpt[0], imgpt[2],
+             imageSize, R12, T12, R13, T13,
+             R[0], R[1], R[2], P[0], P[1], P[2], Q, -1.,
+             imageSize, 0, 0, CALIB_ZERO_DISPARITY);
+    Mat map1[3], map2[3];
+
+    fs << "R1" << R[0];
+    fs << "R2" << R[1];
+    fs << "R3" << R[2];
+
+    fs << "P1" << P[0];
+    fs << "P2" << P[1];
+    fs << "P3" << P[2];
+
+    fs << "disparityRatio" << ratio;
+    fs.release();
+
+    printf("Disparity ratio = %g\n", ratio);
+
+    for( k = 0; k < 3; k++ )
+        initUndistortRectifyMap(cameraMatrix[k], distCoeffs[k], R[k], P[k], imageSize, CV_16SC2, map1[k], map2[k]);
+
+    Mat canvas(imageSize.height, imageSize.width*3, CV_8UC3), small_canvas;
+    destroyWindow("view");
+    canvas = Scalar::all(0);
+
+    for( i = 0; i < (int)(imageList.size()/3); i++ )
+    {
+        canvas = Scalar::all(0);
+        for( k = 0; k < 3; k++ )
+        {
+            int k1 = k == 0 ? 2 : k == 1 ? 0 : 1;
+            int k2 = k == 0 ? 1 : k == 1 ? 0 : 2;
+            view = imread(imageList[i*3+k], 1);
+
+            if(view.empty())
+                continue;
+
+            Mat rview = canvas.colRange(k2*imageSize.width, (k2+1)*imageSize.width);
+            remap(view, rview, map1[k1], map2[k1], INTER_LINEAR);
+        }
+        printf("%s %s %s\n", imageList[i*3].c_str(), imageList[i*3+1].c_str(), imageList[i*3+2].c_str());
+        resize( canvas, small_canvas, Size(1500, 1500/3), 0, 0, INTER_LINEAR_EXACT );
+        for( k = 0; k < small_canvas.rows; k += 16 )
+            line(small_canvas, Point(0, k), Point(small_canvas.cols, k), Scalar(0,255,0), 1);
+        imshow("rectified", small_canvas);
+        char c = (char)waitKey(0);
+        if( c == 27 || c == 'q' || c == 'Q' )
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/CMakeLists.txt b/C++/opencv-4.7.0/samples/cpp/CMakeLists.txt
new file mode 100644
index 00000000..c9c4440f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/CMakeLists.txt
@@ -0,0 +1,80 @@
+ocv_install_example_src(cpp *.cpp *.hpp CMakeLists.txt)
+
+set(OPENCV_CPP_SAMPLES_REQUIRED_DEPS
+  opencv_core
+  opencv_imgproc
+  opencv_flann
+  opencv_imgcodecs
+  opencv_videoio
+  opencv_highgui
+  opencv_ml
+  opencv_video
+  opencv_objdetect
+  opencv_photo
+  opencv_features2d
+  opencv_calib3d
+  opencv_stitching
+  opencv_dnn
+  ${OPENCV_MODULES_PUBLIC}
+  ${OpenCV_LIB_COMPONENTS})
+ocv_check_dependencies(${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
+
+if(NOT BUILD_EXAMPLES OR NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+set(DEPS_example_snippet_imgproc_segmentation opencv_core opencv_imgproc)
+set(DEPS_example_cpp_intelligent_scissors opencv_core opencv_imgproc opencv_imgcodecs opencv_highgui)
+
+project(cpp_samples)
+ocv_include_modules_recurse(${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
+file(GLOB_RECURSE cpp_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+if(NOT HAVE_opencv_cudaarithm OR NOT HAVE_opencv_cudafilters)
+  ocv_list_filterout(cpp_samples "/gpu/")
+endif()
+ocv_list_filterout(cpp_samples "real_time_pose_estimation/")
+ocv_list_filterout(cpp_samples "parallel_backend/")
+foreach(sample_filename ${cpp_samples})
+  set(package "cpp")
+  if(sample_filename MATCHES "tutorial_code/snippet")
+    set(package "snippet")
+  elseif(sample_filename MATCHES "tutorial_code")
+    set(package "tutorial")
+  endif()
+  ocv_define_sample(tgt ${sample_filename} ${package})
+  set(deps ${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
+  if(DEFINED DEPS_${tgt})
+    set(deps ${DEPS_${tgt}})
+  endif()
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${deps})
+  if(sample_filename MATCHES "/gpu/" AND HAVE_opencv_cudaarithm AND HAVE_opencv_cuda_filters)
+    ocv_target_link_libraries(${tgt} PRIVATE opencv_cudaarithm opencv_cudafilters)
+  endif()
+  if(sample_filename MATCHES "/viz/")
+    ocv_target_link_libraries(${tgt} PRIVATE ${VTK_LIBRARIES})
+    target_compile_definitions(${tgt} PRIVATE -DUSE_VTK)
+  endif()
+  if(HAVE_OPENGL AND sample_filename MATCHES "detect_mser")
+    target_compile_definitions(${tgt} PRIVATE HAVE_OPENGL)
+    ocv_target_link_libraries(${tgt} PRIVATE "${OPENGL_LIBRARIES}")
+  endif()
+  if(sample_filename MATCHES "simd_")
+    # disabled intentionally - demonstration purposes only
+    #target_include_directories(${tgt} PRIVATE "${CMAKE_CURRENT_LIST_DIR}")
+    #target_compile_definitions(${tgt} PRIVATE OPENCV_SIMD_CONFIG_HEADER=opencv_simd_config_custom.hpp)
+    #target_compile_definitions(${tgt} PRIVATE OPENCV_SIMD_CONFIG_INCLUDE_DIR=1)
+    #target_compile_options(${tgt} PRIVATE -mavx2)
+  endif()
+endforeach()
+
+include("tutorial_code/calib3d/real_time_pose_estimation/CMakeLists.txt" OPTIONAL)
+
+# Standalone samples only
+if(OpenCV_FOUND AND NOT CMAKE_VERSION VERSION_LESS "3.1")
+  add_subdirectory("example_cmake")
+endif()
+if(OpenCV_FOUND AND NOT CMAKE_VERSION VERSION_LESS "3.9"
+    AND NOT OPENCV_EXAMPLES_SKIP_PARALLEL_BACKEND
+)
+  add_subdirectory("tutorial_code/core/parallel_backend")
+endif()
diff --git a/C++/opencv-4.7.0/samples/cpp/application_trace.cpp b/C++/opencv-4.7.0/samples/cpp/application_trace.cpp
new file mode 100644
index 00000000..3ad06a4c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/application_trace.cpp
@@ -0,0 +1,95 @@
+/* OpenCV Application Tracing support demo. */
+#include <iostream>
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/core/utils/trace.hpp>
+
+using namespace cv;
+using namespace std;
+
+static void process_frame(const cv::UMat& frame)
+{
+    CV_TRACE_FUNCTION(); // OpenCV Trace macro for function
+
+    imshow("Live", frame);
+
+    UMat gray, processed;
+    cv::cvtColor(frame, gray, COLOR_BGR2GRAY);
+    Canny(gray, processed, 32, 64, 3);
+    imshow("Processed", processed);
+}
+
+int main(int argc, char** argv)
+{
+    CV_TRACE_FUNCTION();
+
+    cv::CommandLineParser parser(argc, argv,
+        "{help h ? |     | help message}"
+        "{n        | 100 | number of frames to process }"
+        "{@video   | 0   | video filename or cameraID }"
+    );
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    VideoCapture capture;
+    std::string video = parser.get<string>("@video");
+    if (video.size() == 1 && isdigit(video[0]))
+        capture.open(parser.get<int>("@video"));
+    else
+        capture.open(samples::findFileOrKeep(video));  // keep GStreamer pipelines
+    int nframes = 0;
+    if (capture.isOpened())
+    {
+        nframes = (int)capture.get(CAP_PROP_FRAME_COUNT);
+        cout << "Video " << video <<
+            ": width=" << capture.get(CAP_PROP_FRAME_WIDTH) <<
+            ", height=" << capture.get(CAP_PROP_FRAME_HEIGHT) <<
+            ", nframes=" << nframes << endl;
+    }
+    else
+    {
+        cout << "Could not initialize video capturing...\n";
+        return -1;
+    }
+
+    int N = parser.get<int>("n");
+    if (nframes > 0 && N > nframes)
+        N = nframes;
+
+    cout << "Start processing..." << endl
+        << "Press ESC key to terminate" << endl;
+
+    UMat frame;
+    for (int i = 0; N > 0 ? (i < N) : true; i++)
+    {
+        CV_TRACE_REGION("FRAME"); // OpenCV Trace macro for named "scope" region
+        {
+            CV_TRACE_REGION("read");
+            capture.read(frame);
+
+            if (frame.empty())
+            {
+                cerr << "Can't capture frame: " << i << std::endl;
+                break;
+            }
+
+            // OpenCV Trace macro for NEXT named region in the same C++ scope
+            // Previous "read" region will be marked complete on this line.
+            // Use this to eliminate unnecessary curly braces.
+            CV_TRACE_REGION_NEXT("process");
+            process_frame(frame);
+
+            CV_TRACE_REGION_NEXT("delay");
+            if (waitKey(1) == 27/*ESC*/)
+                break;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/asift.cpp b/C++/opencv-4.7.0/samples/cpp/asift.cpp
new file mode 100644
index 00000000..56895405
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/asift.cpp
@@ -0,0 +1,199 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/features2d.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/calib3d.hpp>
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+using namespace cv;
+
+static void help(char** argv)
+{
+    cout
+    << "This is a sample usage of AffineFeature detector/extractor.\n"
+    << "And this is a C++ version of samples/python/asift.py\n"
+    << "Usage: " << argv[0] << "\n"
+    << "     [ --feature=<sift|orb|brisk> ]         # Feature to use.\n"
+    << "     [ --flann ]                            # use Flann-based matcher instead of bruteforce.\n"
+    << "     [ --maxlines=<number(50 as default)> ] # The maximum number of lines in visualizing the matching result.\n"
+    << "     [ --image1=<image1(aero1.jpg as default)> ]\n"
+    << "     [ --image2=<image2(aero3.jpg as default)> ] # Path to images to compare."
+    << endl;
+}
+
+static double timer()
+{
+    return getTickCount() / getTickFrequency();
+}
+
+int main(int argc, char** argv)
+{
+    vector<String> fileName;
+    cv::CommandLineParser parser(argc, argv,
+        "{help h ||}"
+        "{feature|brisk|}"
+        "{flann||}"
+        "{maxlines|50|}"
+        "{image1|aero1.jpg|}{image2|aero3.jpg|}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    string feature = parser.get<string>("feature");
+    bool useFlann = parser.has("flann");
+    int maxlines = parser.get<int>("maxlines");
+    fileName.push_back(samples::findFile(parser.get<string>("image1")));
+    fileName.push_back(samples::findFile(parser.get<string>("image2")));
+    if (!parser.check())
+    {
+        parser.printErrors();
+        cout << "See --help (or missing '=' between argument name and value?)" << endl;
+        return 1;
+    }
+
+    Mat img1 = imread(fileName[0], IMREAD_GRAYSCALE);
+    Mat img2 = imread(fileName[1], IMREAD_GRAYSCALE);
+    if (img1.empty())
+    {
+        cerr << "Image " << fileName[0] << " is empty or cannot be found" << endl;
+        return 1;
+    }
+    if (img2.empty())
+    {
+        cerr << "Image " << fileName[1] << " is empty or cannot be found" << endl;
+        return 1;
+    }
+
+    Ptr<Feature2D> backend;
+    Ptr<DescriptorMatcher> matcher;
+
+    if (feature == "sift")
+    {
+        backend = SIFT::create();
+        if (useFlann)
+            matcher = DescriptorMatcher::create("FlannBased");
+        else
+            matcher = DescriptorMatcher::create("BruteForce");
+    }
+    else if (feature == "orb")
+    {
+        backend = ORB::create();
+        if (useFlann)
+            matcher = makePtr<FlannBasedMatcher>(makePtr<flann::LshIndexParams>(6, 12, 1));
+        else
+            matcher = DescriptorMatcher::create("BruteForce-Hamming");
+    }
+    else if (feature == "brisk")
+    {
+        backend = BRISK::create();
+        if (useFlann)
+            matcher = makePtr<FlannBasedMatcher>(makePtr<flann::LshIndexParams>(6, 12, 1));
+        else
+            matcher = DescriptorMatcher::create("BruteForce-Hamming");
+    }
+    else
+    {
+        cerr << feature << " is not supported. See --help" << endl;
+        return 1;
+    }
+
+    cout << "extracting with " << feature << "..." << endl;
+    Ptr<AffineFeature> ext = AffineFeature::create(backend);
+    vector<KeyPoint> kp1, kp2;
+    Mat desc1, desc2;
+
+    ext->detectAndCompute(img1, Mat(), kp1, desc1);
+    ext->detectAndCompute(img2, Mat(), kp2, desc2);
+    cout << "img1 - " << kp1.size() << " features, "
+         << "img2 - " << kp2.size() << " features"
+         << endl;
+
+    cout << "matching with " << (useFlann ? "flann" : "bruteforce") << "..." << endl;
+    double start = timer();
+    // match and draw
+    vector< vector<DMatch> > rawMatches;
+    vector<Point2f> p1, p2;
+    vector<float> distances;
+    matcher->knnMatch(desc1, desc2, rawMatches, 2);
+    // filter_matches
+    for (size_t i = 0; i < rawMatches.size(); i++)
+    {
+        const vector<DMatch>& m = rawMatches[i];
+        if (m.size() == 2 && m[0].distance < m[1].distance * 0.75)
+        {
+            p1.push_back(kp1[m[0].queryIdx].pt);
+            p2.push_back(kp2[m[0].trainIdx].pt);
+            distances.push_back(m[0].distance);
+        }
+    }
+    vector<uchar> status;
+    vector< pair<Point2f, Point2f> > pointPairs;
+    Mat H = findHomography(p1, p2, status, RANSAC);
+    int inliers = 0;
+    for (size_t i = 0; i < status.size(); i++)
+    {
+        if (status[i])
+        {
+            pointPairs.push_back(make_pair(p1[i], p2[i]));
+            distances[inliers] = distances[i];
+            // CV_Assert(inliers <= (int)i);
+            inliers++;
+        }
+    }
+    distances.resize(inliers);
+
+    cout << "execution time: " << fixed << setprecision(2) << (timer()-start)*1000 << " ms" << endl;
+    cout << inliers << " / " << status.size() << " inliers/matched" << endl;
+
+    cout << "visualizing..." << endl;
+    vector<int> indices(inliers);
+    cv::sortIdx(distances, indices, SORT_EVERY_ROW+SORT_ASCENDING);
+
+    // explore_match
+    int h1 = img1.size().height;
+    int w1 = img1.size().width;
+    int h2 = img2.size().height;
+    int w2 = img2.size().width;
+    Mat vis = Mat::zeros(max(h1, h2), w1+w2, CV_8U);
+    img1.copyTo(Mat(vis, Rect(0, 0, w1, h1)));
+    img2.copyTo(Mat(vis, Rect(w1, 0, w2, h2)));
+    cvtColor(vis, vis, COLOR_GRAY2BGR);
+
+    vector<Point2f> corners(4);
+    corners[0] = Point2f(0, 0);
+    corners[1] = Point2f((float)w1, 0);
+    corners[2] = Point2f((float)w1, (float)h1);
+    corners[3] = Point2f(0, (float)h1);
+    vector<Point2i> icorners;
+    perspectiveTransform(corners, corners, H);
+    transform(corners, corners, Matx23f(1,0,(float)w1,0,1,0));
+    Mat(corners).convertTo(icorners, CV_32S);
+    polylines(vis, icorners, true, Scalar(255,255,255));
+
+    for (int i = 0; i < min(inliers, maxlines); i++)
+    {
+        int idx = indices[i];
+        const Point2f& pi1 = pointPairs[idx].first;
+        const Point2f& pi2 = pointPairs[idx].second;
+        circle(vis, pi1, 2, Scalar(0,255,0), -1);
+        circle(vis, pi2 + Point2f((float)w1,0), 2, Scalar(0,255,0), -1);
+        line(vis, pi1, pi2 + Point2f((float)w1,0), Scalar(0,255,0));
+    }
+    if (inliers > maxlines)
+        cout << "only " << maxlines << " inliers are visualized" << endl;
+    imshow("affine find_obj", vis);
+
+    // Mat vis2 = Mat::zeros(max(h1, h2), w1+w2, CV_8U);
+    // Mat warp1;
+    // warpPerspective(img1, warp1, H, Size(w1, h1));
+    // warp1.copyTo(Mat(vis2, Rect(0, 0, w1, h1)));
+    // img2.copyTo(Mat(vis2, Rect(w1, 0, w2, h2)));
+    // imshow("warped", vis2);
+
+    waitKey();
+    cout << "done" << endl;
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/audio_spectrogram.cpp b/C++/opencv-4.7.0/samples/cpp/audio_spectrogram.cpp
new file mode 100644
index 00000000..80bfc1fb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/audio_spectrogram.cpp
@@ -0,0 +1,1071 @@
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cmath>
+using namespace cv;
+using namespace std;
+
+
+class AudioDrawing
+{
+
+public:
+
+    AudioDrawing(const CommandLineParser& parser) {
+        if (!initAndCheckArgs(parser))
+        {
+            cerr << "Error: Wrong input arguments" << endl;
+            exit(0);
+        }
+        Draw();
+    }
+
+    void Draw() {
+        if (draw == "static")
+        {
+            vector<int>inputAudio = {};
+            int samplingRate = 0;
+            if (inputType == "file")
+            {
+                samplingRate = readAudioFile(audio, inputAudio);
+            }
+            else if (inputType == "microphone")
+            {
+                samplingRate = readAudioMicrophone(inputAudio);
+            }
+            if ((inputAudio.size() == 0) || samplingRate <= 0)
+            {
+                cerr << "Error: problems with audio reading, check input arguments" << endl;
+                return;
+            }
+
+            int duration = static_cast<int>(inputAudio.size()) / samplingRate;
+
+            // since the dimensional grid is counted in integer seconds,
+            // if the input audio has an incomplete last second,
+            // then it is filled with zeros to complete
+            int remainder = static_cast<int>(inputAudio.size()) % samplingRate;
+            if (remainder)
+            {
+                int sizeToFullSec = samplingRate - remainder;
+                for (int j = 0; j < sizeToFullSec; ++j)
+                {
+                    inputAudio.push_back(0);
+                }
+                duration += 1;
+                cout << "Update duration of audio to full last second with " <<
+                        sizeToFullSec << " zero samples" << endl;
+                cout << "New number of samples " << inputAudio.size() << endl;
+            }
+            cout << "Duration of audio = " << duration << " seconds" << endl;
+
+            // since the dimensional grid is counted in integer seconds,
+            // if duration of file is less than xmarkup, to avoid an incorrect display,
+            // xmarkup will be taken equal to duration
+            if (duration <= xmarkup)
+            {
+                xmarkup = duration + 1;
+            }
+
+            if (graph == "ampl")
+            {
+                Mat imgAmplitude = drawAmplitude(inputAudio);
+                imgAmplitude = drawAmplitudeScale(imgAmplitude, inputAudio, samplingRate);
+                imshow("Display amplitude graph", imgAmplitude);
+                waitKey(0);
+            }
+            else if (graph == "spec")
+            {
+                vector<vector<double>>stft = STFT(inputAudio);
+                Mat imgSpec = drawSpectrogram(stft);
+                imgSpec = drawSpectrogramColorbar(imgSpec, inputAudio, samplingRate, stft);
+                imshow("Display spectrogram", imgSpec);
+                waitKey(0);
+            }
+            else if (graph == "ampl_and_spec")
+            {
+                Mat imgAmplitude = drawAmplitude(inputAudio);
+                imgAmplitude = drawAmplitudeScale(imgAmplitude, inputAudio, samplingRate);
+                vector<vector<double>>stft = STFT(inputAudio);
+                Mat imgSpec = drawSpectrogram(stft);
+                imgSpec = drawSpectrogramColorbar(imgSpec, inputAudio, samplingRate, stft);
+                Mat imgTotal = concatenateImages(imgAmplitude, imgSpec);
+                imshow("Display amplitude graph and spectrogram", imgTotal);
+                waitKey(0);
+            }
+        }
+        else if (draw == "dynamic")
+        {
+            if (inputType == "file")
+            {
+                dynamicFile(audio);
+            }
+            else if (inputType == "microphone")
+            {
+                dynamicMicrophone();
+            }
+        }
+    }
+
+    ~AudioDrawing() {
+    }
+
+    int readAudioFile(string file, vector<int>& inputAudio)
+    {
+        VideoCapture cap;
+        vector<int> params {    CAP_PROP_AUDIO_STREAM, audioStream,
+                                CAP_PROP_VIDEO_STREAM, -1,
+                                CAP_PROP_AUDIO_DATA_DEPTH, CV_16S   };
+
+        cap.open(file, CAP_ANY, params);
+        if (!cap.isOpened())
+        {
+            cerr << "Error : Can't read audio file: '" << audio << "' with audioStream = " << audioStream << endl;
+            return -1;
+        }
+        const int audioBaseIndex = (int)cap.get(CAP_PROP_AUDIO_BASE_INDEX);
+        const int numberOfChannels = (int)cap.get(CAP_PROP_AUDIO_TOTAL_CHANNELS);
+        cout << "CAP_PROP_AUDIO_DATA_DEPTH: " << depthToString((int)cap.get(CAP_PROP_AUDIO_DATA_DEPTH)) << endl;
+        int samplingRate =  static_cast<int>(cap.get(CAP_PROP_AUDIO_SAMPLES_PER_SECOND));
+        cout << "CAP_PROP_AUDIO_SAMPLES_PER_SECOND: " << cap.get(CAP_PROP_AUDIO_SAMPLES_PER_SECOND) << endl;
+        cout << "CAP_PROP_AUDIO_TOTAL_CHANNELS: " << numberOfChannels << endl;
+        cout << "CAP_PROP_AUDIO_TOTAL_STREAMS: " << cap.get(CAP_PROP_AUDIO_TOTAL_STREAMS) << endl;
+
+        vector<int> frameVec;
+        Mat frame;
+        for (;;)
+        {
+            if (cap.grab())
+            {
+                cap.retrieve(frame, audioBaseIndex);
+                frameVec = frame;
+                inputAudio.insert(inputAudio.end(), frameVec.begin(), frameVec.end());
+            }
+            else
+            {
+                cout << "Number of samples: " << inputAudio.size() << endl;
+                break;
+            }
+        }
+        return samplingRate;
+    }
+
+    int readAudioMicrophone(vector<int>& inputAudio)
+    {
+        VideoCapture cap;
+        vector<int> params {    CAP_PROP_AUDIO_STREAM, 0,
+                                CAP_PROP_VIDEO_STREAM, -1   };
+
+        cap.open(0, CAP_ANY, params);
+        if (!cap.isOpened())
+        {
+            cerr << "Error: Can't open microphone" << endl;
+            return -1;
+        }
+
+        const int audioBaseIndex =  static_cast<int>(cap.get(CAP_PROP_AUDIO_BASE_INDEX));
+        const int numberOfChannels =  static_cast<int>(cap.get(CAP_PROP_AUDIO_TOTAL_CHANNELS));
+        cout << "CAP_PROP_AUDIO_DATA_DEPTH: " << depthToString( static_cast<int>(cap.get(CAP_PROP_AUDIO_DATA_DEPTH))) << endl;
+        int samplingRate = static_cast<int>(cap.get(CAP_PROP_AUDIO_SAMPLES_PER_SECOND));
+        cout << "CAP_PROP_AUDIO_SAMPLES_PER_SECOND: " << samplingRate << endl;
+        cout << "CAP_PROP_AUDIO_TOTAL_CHANNELS: " << numberOfChannels << endl;
+        cout << "CAP_PROP_AUDIO_TOTAL_STREAMS: " << cap.get(CAP_PROP_AUDIO_TOTAL_STREAMS) << endl;
+
+        const double cvTickFreq = getTickFrequency();
+        int64 sysTimeCurr = getTickCount();
+        int64 sysTimePrev = sysTimeCurr;
+
+        vector<int> frameVec;
+        Mat frame;
+        while ((sysTimeCurr - sysTimePrev) / cvTickFreq < microTime)
+        {
+            if (cap.grab())
+            {
+                cap.retrieve(frame, audioBaseIndex);
+                frameVec = frame;
+                inputAudio.insert(inputAudio.end(), frameVec.begin(), frameVec.end());
+                sysTimeCurr = getTickCount();
+            }
+            else
+            {
+                cerr << "Error: Grab error" << endl;
+                break;
+            }
+        }
+        cout << "Number of samples: " << inputAudio.size() << endl;
+        return samplingRate;
+    }
+
+
+    Mat drawAmplitude(vector<int>& inputAudio)
+    {
+        Scalar color = Scalar(247,111,87);
+        int thickness = 5;
+        int frameVectorRows = 500;
+        int middle = frameVectorRows / 2;
+        // usually the input data is too big, so it is necessary
+        // to reduce size using interpolation of data
+        int frameVectorCols = 40000;
+        if (static_cast<int>(inputAudio.size()) < frameVectorCols)
+        {
+            frameVectorCols = static_cast<int>(inputAudio.size());
+        }
+
+        Mat img(frameVectorRows, frameVectorCols, CV_8UC3 , Scalar(255,255,255)); // white background
+
+        vector<double>reshapeAudio(inputAudio.size());
+        for (size_t i = 0; i < inputAudio.size(); ++i)
+        {
+            reshapeAudio[i]=static_cast<double>(inputAudio[i]);
+        }
+
+        Mat img_frameVector( 1, static_cast<int>(reshapeAudio.size()), CV_64F , reshapeAudio.data());
+        Mat img_frameVector_resize;
+        resize(img_frameVector, img_frameVector_resize, Size(frameVectorCols, 1), INTER_LINEAR);
+        reshapeAudio = img_frameVector_resize;
+
+        // normalization data by maximum element
+        normalize(reshapeAudio, reshapeAudio, 1.0, 0.0, NORM_INF);
+
+        for (size_t i = 0; i < reshapeAudio.size(); ++i)
+        {
+            reshapeAudio[i] = middle - reshapeAudio[i] * middle;
+        }
+
+        for (int i = 1; i < static_cast<int>(reshapeAudio.size()); ++i)
+        {
+            line(img, Point(i-1, static_cast<int>(reshapeAudio[i-1])), Point(i, static_cast<int>(reshapeAudio[i])), color, thickness);
+        }
+        Mat resImage;
+        resize(img, resImage, Size(900, 400), INTER_AREA );
+        return resImage;
+    }
+
+    Mat drawAmplitudeScale(Mat& inputImg, const vector<int>& inputAudio, int samplingRate,
+                           int xmin = 0, int xmax = 0)
+    {
+        // function of layout drawing for graph of volume amplitudes
+        // x axis for time
+        // y axis for amplitudes
+
+        // parameters for the new image size
+        int preCol = 100;
+        int aftCol = 100;
+        int preLine = 40;
+        int aftLine = 50;
+
+        int frameVectorRows = inputImg.rows;
+        int frameVectorCols = inputImg.cols;
+
+        int totalRows = preLine + frameVectorRows + aftLine;
+        int totalCols = preCol + frameVectorCols + aftCol;
+
+        Mat imgTotal = Mat(totalRows, totalCols, CV_8UC3, Scalar(255, 255, 255));
+        inputImg.copyTo(imgTotal(Rect(preCol, preLine, inputImg.cols, inputImg.rows)));
+
+
+        // calculating values on x axis
+        if (xmax == 0)
+        {
+            xmax = static_cast<int>(inputAudio.size()) / samplingRate;
+        }
+        std::vector<double> xList(xmarkup);
+        if (xmax >= xmarkup)
+        {
+            double deltax = (xmax - xmin) / (xmarkup - 1);
+            for (int i = 0; i < xmarkup; ++i)
+            {
+                xList[i] = (xmin + deltax * i);
+            }
+        }
+        else
+        {
+            // this case is used to display a dynamic update
+            vector<double> tmpXList;
+            for (int i = xmin; i < xmax; ++i)
+            {
+                tmpXList.push_back(i + 1);
+            }
+            int k = 0;
+            for (int i = xmarkup - static_cast<int>(tmpXList.size()); i < xmarkup; ++i)
+            {
+                xList[i] = tmpXList[k];
+                k += 1;
+            }
+        }
+
+        // calculating values on y axis
+        double minCv; double maxCv; Point minLoc; Point maxLoc;
+        minMaxLoc(inputAudio, &minCv, &maxCv, &minLoc, &maxLoc);
+        int ymin = static_cast<int>(minCv);
+        int ymax = static_cast<int>(maxCv);
+
+        std::vector<double> yList(ymarkup);
+        double deltay = (ymax - ymin) / (ymarkup - 1);
+        for (int i = 0; i < ymarkup; ++i)
+        {
+            yList[i] = ymin + deltay * i;
+        }
+
+        // parameters for layout drawing
+        int textThickness = 1;
+        int gridThickness = 1;
+        Scalar gridColor(0, 0, 0);
+        Scalar textColor(0, 0, 0);
+        float fontScale = 0.5;
+
+        // horizontal axis
+        line(imgTotal, Point(preCol, totalRows - aftLine), Point(preCol + frameVectorCols, totalRows - aftLine),
+            gridColor, gridThickness);
+        // vertical axis
+        line(imgTotal, Point(preCol, preLine), Point(preCol, preLine + frameVectorRows),
+            gridColor, gridThickness);
+
+        // parameters for layout calculation
+        int serifSize = 10;
+        int indentDownX = serifSize * 2;
+        int indentDownY = serifSize / 2;
+        int indentLeftX = serifSize;
+        int indentLeftY = 2 * preCol / 3;
+
+
+        // drawing layout for x axis
+        int numX = frameVectorCols / (xmarkup - 1);
+        for (size_t i = 0; i < xList.size(); ++i)
+        {
+            int a1 = static_cast<int>(preCol + i * numX);
+            int a2 = frameVectorRows + preLine;
+
+            int b1 = a1;
+            int b2 = a2 + serifSize;
+
+            if (enableGrid)
+            {
+                int d1 = a1;
+                int d2 = preLine;
+                line(imgTotal, Point(a1, a2), Point(d1, d2), gridColor, gridThickness);
+            }
+            line(imgTotal, Point(a1, a2), Point(b1, b2), gridColor, gridThickness);
+            putText(imgTotal, to_string(int(xList[i])), Point(b1 - indentLeftX, b2 + indentDownX),
+                    FONT_HERSHEY_SIMPLEX, fontScale, textColor, textThickness);
+        }
+
+        // drawing layout for y axis
+        int numY = frameVectorRows / (ymarkup - 1);
+        for (size_t i = 0; i < yList.size(); ++i) {
+            int a1 = preCol;
+            int a2 = static_cast<int>(totalRows - aftLine - i * numY);
+            int b1 = preCol - serifSize;
+            int b2 = a2;
+            if (enableGrid)
+            {
+                int d1 = preCol + frameVectorCols;
+                int d2 = a2;
+                line(imgTotal, Point(a1, a2), Point(d1, d2), gridColor, gridThickness);
+            }
+            line(imgTotal, Point(a1, a2), Point(b1, b2), gridColor, gridThickness);
+            putText(imgTotal, to_string(int(yList[i])), Point(b1 - indentLeftY, b2 + indentDownY),
+                    FONT_HERSHEY_SIMPLEX, fontScale, textColor, textThickness);
+        }
+        Mat resImage;
+        resize(imgTotal, resImage, Size(cols, rows), INTER_AREA );
+        return resImage;
+    }
+
+    vector<vector<double>> STFT(const vector<int>& inputAudio)
+    {
+        // The Short-time Fourier transform (STFT), is a Fourier-related transform used to
+        // determine the sinusoidal frequency and phase content of local sections of a signal
+        // as it changes over time.
+        // In practice, the procedure for computing STFTs is to divide a longer time signal
+        // into shorter segments of equal length and then compute the Fourier transform separately
+        // on each shorter segment. This reveals the Fourier spectrum on each shorter segment.
+        // One then usually plots the changing spectra as a function of time, known as a spectrogram
+        // or waterfall plot.
+        // https://en.wikipedia.org/wiki/Short-time_Fourier_transform
+
+        int timeStep = windLen - overlap;
+        Mat dstMat;
+        vector<double> stftRow;
+        vector<double> WindType;
+        if (windowType == "Hann")
+        {
+            // https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows
+            for (int j = 1 - windLen; j < windLen; j+=2)
+            {
+                WindType.push_back(j * (0.5 * (1 - cos(CV_PI * j / (windLen - 1)))));
+            }
+        }
+        else if (windowType == "Hamming")
+        {
+            // https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows
+            for (int j = 1 - windLen; j < windLen; j+=2)
+            {
+                WindType.push_back(j * (0.53836 - 0.46164 * (cos(CV_PI * j / (windLen - 1)))));
+            }
+        }
+        for (size_t i = 0; i < inputAudio.size(); i += timeStep)
+        {
+            vector<double>section(windLen, 0);
+            for (int j = 0; j < windLen; ++j)
+            {
+                section[j] = inputAudio[j + i];
+            }
+            if (windowType == "Hann" || windowType == "Hamming")
+            {
+                for (size_t j = 0; j < section.size(); ++j)
+                {
+                    section[j] *= WindType[j];
+                }
+            }
+
+            dft(section, dstMat, DFT_COMPLEX_OUTPUT);
+
+            for (int j = 0; j < dstMat.cols / 4; ++j)
+            {
+                double complModule = sqrt(dstMat.at<double>(2*j) * dstMat.at<double>(2*j) +
+                                        dstMat.at<double>(2*j+1) * dstMat.at<double>(2*j+1));
+                stftRow.push_back(complModule);
+            }
+        }
+
+        size_t xSize = inputAudio.size() / timeStep + 1;
+        // we need only the first part of the spectrum, the second part is symmetrical
+        size_t ySize = dstMat.cols / 4;
+
+        vector<vector<double>> stft(ySize, vector<double>(xSize, 0.));
+        for (size_t i = 0; i < xSize; ++i)
+        {
+            for (size_t j = 0; j < ySize; ++j)
+            {
+                // write elements with transposition and convert it to the decibel scale
+                double stftElem = stftRow[ i * ySize + j];
+                if (stftElem != 0.)
+                {
+                    stft[j][i] = 10 * log10(stftElem);
+                }
+            }
+        }
+        return stft;
+    }
+
+    Mat drawSpectrogram(const vector<vector<double>>& stft)
+    {
+        int frameVectorRows = static_cast<int>(stft.size());
+        int frameVectorCols = static_cast<int>(stft[0].size());
+
+        // Normalization of image values from 0 to 255 to get more contrast image
+        // and this normalization will be taken into account in the scale drawing
+        int colormapImageRows = 255;
+
+        double minCv; double maxCv; Point minLoc; Point maxLoc;
+        minMaxLoc(stft[0], &minCv, &maxCv, &minLoc, &maxLoc);
+        double maxStft = max(abs(maxCv), abs(minCv));
+
+        for (int i = 1; i < frameVectorRows; ++i)
+        {
+            minMaxLoc( stft[i], &minCv, &maxCv, &minLoc, &maxLoc);
+            maxStft = max(maxStft, max(abs(maxCv), abs(minCv)));
+        }
+        // if maxStft is zero (silence)
+        if (maxStft == 0.)
+        {
+            maxStft = 1;
+        }
+        Mat imgSpec(frameVectorRows, frameVectorCols, CV_8UC1, Scalar(255, 255, 255));
+
+        for (int i = 0; i < frameVectorRows; ++i)
+        {
+            for (int j = 0; j < frameVectorCols; ++j)
+            {
+                imgSpec.at<uchar>(frameVectorRows - i - 1, j) = static_cast<uchar>(stft[i][j] * colormapImageRows / maxStft);
+            }
+        }
+        applyColorMap(imgSpec, imgSpec, COLORMAP_INFERNO);
+        Mat resImage;
+        resize(imgSpec, resImage, Size(900, 400), INTER_AREA);
+        return resImage;
+    }
+
+    Mat drawSpectrogramColorbar(Mat& inputImg, const vector<int>& inputAudio,
+                                int samplingRate, const vector<vector<double>>& stft,
+                                int xmin = 0, int xmax = 0)
+    {
+        // function of layout drawing for the three-dimensional graph of the spectrogram
+        // x axis for time
+        // y axis for frequencies
+        // z axis for magnitudes of frequencies shown by color scale
+
+        // parameters for the new image size
+        int preCol = 100;
+        int aftCol = 100;
+        int preLine = 40;
+        int aftLine = 50;
+        int colColor = 20;
+        int indCol = 20;
+
+        int frameVectorRows = inputImg.rows;
+        int frameVectorCols = inputImg.cols;
+
+        int totalRows = preLine + frameVectorRows + aftLine;
+        int totalCols = preCol + frameVectorCols + aftCol;
+
+        Mat imgTotal = Mat(totalRows, totalCols, CV_8UC3 , Scalar(255, 255, 255));
+        inputImg.copyTo(imgTotal(Rect(preCol, preLine, frameVectorCols, frameVectorRows)));
+
+        // colorbar image due to drawSpectrogram(..) picture has been normalised from 255 to 0,
+        // so here colorbar has values from 255 to 0
+        int colorArrSize = 256;
+        Mat imgColorBar = Mat (colorArrSize, colColor, CV_8UC1 , Scalar(255,255,255));
+        for (int i = 0; i < colorArrSize; ++i)
+        {
+            for( int j = 0; j < colColor; ++j)
+            {
+                imgColorBar.at<uchar>(i, j) = static_cast<uchar>(colorArrSize - 1 - i); // from 255 to 0
+            }
+        }
+
+        applyColorMap(imgColorBar, imgColorBar, COLORMAP_INFERNO);
+        resize(imgColorBar, imgColorBar, Size(colColor, frameVectorRows), INTER_AREA);
+        imgColorBar.copyTo(imgTotal(Rect(preCol + frameVectorCols + indCol, preLine, colColor, frameVectorRows)));
+
+
+        // calculating values on x axis
+        if (xmax == 0)
+        {
+            xmax = static_cast<int>(inputAudio.size()) / samplingRate + 1;
+        }
+        vector<double> xList(xmarkup, 0);
+        if (xmax >= xmarkup)
+        {
+            double deltax = (xmax - xmin) / (xmarkup - 1);
+            for(int i = 0; i < xmarkup; ++i)
+            {
+                xList[i] = xmin + deltax * i;
+            }
+        }
+        else
+        {
+            // this case is used to display a dynamic update
+            vector<double> tmpXList;
+            for(int i = xmin; i < xmax; ++i)
+            {
+                tmpXList.push_back(i + 1);
+            }
+            int k = 0;
+            for (int i = xmarkup - static_cast<int>(tmpXList.size()); i < xmarkup; ++i)
+            {
+                xList[i] = tmpXList[k];
+                k += 1;
+            }
+        }
+
+        // calculating values on y axis
+        // according to the Nyquist sampling theorem,
+        // signal should posses frequencies equal to half of sampling rate
+        int ymin = 0;
+        int ymax = static_cast<int>(samplingRate / 2);
+
+        vector<double> yList;
+        double deltay = (ymax - ymin) / (ymarkup - 1);
+        for(int i = 0; i < ymarkup; ++i)
+        {
+            yList.push_back(ymin + deltay * i);
+        }
+
+        // calculating values on z axis
+        double minCv; double maxCv; Point minLoc; Point maxLoc;
+        minMaxLoc( stft[0], &minCv, &maxCv, &minLoc, &maxLoc);
+        double zmin = minCv, zmax = maxCv;
+
+        std::vector<double> zList;
+        for (size_t i = 1; i < stft.size(); ++i)
+        {
+            minMaxLoc( stft[i], &minCv, &maxCv, &minLoc, &maxLoc);
+            zmax = max(zmax, maxCv);
+            zmin = min(zmin, minCv);
+        }
+        double deltaz = (zmax - zmin) / (zmarkup - 1);
+        for(int i = 0; i < zmarkup; ++i)
+        {
+            zList.push_back(zmin + deltaz * i);
+        }
+
+        // parameters for layout drawing
+        int textThickness = 1;
+        int gridThickness = 1;
+        Scalar gridColor(0,0,0);
+        Scalar textColor(0,0,0);
+        float fontScale = 0.5;
+
+        int serifSize = 10;
+        int indentDownX = serifSize * 2;
+        int indentDownY = serifSize / 2;
+        int indentLeftX = serifSize;
+        int indentLeftY = 2 * preCol / 3;
+
+        // horizontal axis
+        line(imgTotal, Point(preCol, totalRows - aftLine), Point(preCol + frameVectorCols, totalRows - aftLine),
+                            gridColor, gridThickness);
+        // vertical axis
+        line(imgTotal, Point(preCol, preLine), Point(preCol, preLine + frameVectorRows),
+                            gridColor, gridThickness);
+
+        // drawing layout for x axis
+        int numX = frameVectorCols / (xmarkup - 1);
+        for (size_t i = 0; i < xList.size(); ++i)
+        {
+            int a1 = static_cast<int>(preCol + i * numX);
+            int a2 = frameVectorRows + preLine;
+
+            int b1 = a1;
+            int b2 = a2 + serifSize;
+
+            line(imgTotal, Point(a1, a2), Point(b1, b2), gridColor, gridThickness);
+            putText(imgTotal, to_string(static_cast<int>(xList[i])), Point(b1 - indentLeftX, b2 + indentDownX),
+                    FONT_HERSHEY_SIMPLEX, fontScale, textColor, textThickness);
+        }
+
+        // drawing layout for y axis
+        int numY = frameVectorRows / (ymarkup - 1);
+        for (size_t i = 0; i < yList.size(); ++i)
+        {
+            int a1 = preCol;
+            int a2 = static_cast<int>(totalRows - aftLine - i * numY);
+
+            int b1 = preCol - serifSize;
+            int b2 = a2;
+
+            line(imgTotal, Point(a1, a2), Point(b1, b2), gridColor, gridThickness);
+            putText(imgTotal, to_string(static_cast<int>(yList[i])), Point(b1 - indentLeftY, b2 + indentDownY),
+                    FONT_HERSHEY_SIMPLEX, fontScale, textColor, textThickness);
+        }
+
+        // drawing layout for z axis
+        int numZ = frameVectorRows / (zmarkup - 1);
+        for (size_t i = 0; i < zList.size(); ++i)
+        {
+            int a1 = preCol + frameVectorCols + indCol + colColor;
+            int a2 = static_cast<int>(totalRows - aftLine - i * numZ);
+
+            int b1 = a1 + serifSize;
+            int b2 = a2;
+
+            line(imgTotal, Point(a1, a2), Point(b1, b2), gridColor, gridThickness);
+            putText(imgTotal, to_string(static_cast<int>(zList[i])), Point(b1 + 10, b2 + indentDownY),
+                    FONT_HERSHEY_SIMPLEX, fontScale, textColor, textThickness);
+        }
+        Mat resImage;
+        resize(imgTotal, resImage, Size(cols, rows), INTER_AREA );
+        return resImage;
+    }
+
+    Mat concatenateImages(Mat& img1, Mat& img2)
+    {
+        // first image will be under the second image
+        int totalRows = img1.rows + img2.rows;
+        int totalCols = max(img1.cols , img2.cols);
+        // if images columns do not match, the difference is filled in white
+        Mat imgTotal = Mat (totalRows, totalCols, CV_8UC3 , Scalar(255, 255, 255));
+
+        img1.copyTo(imgTotal(Rect(0, 0, img1.cols, img1.rows)));
+        img2.copyTo(imgTotal(Rect(0, img1.rows, img2.cols, img2.rows)));
+        return imgTotal;
+    }
+
+    void dynamicFile(const string file)
+    {
+        VideoCapture cap;
+        vector<int> params {    CAP_PROP_AUDIO_STREAM, audioStream,
+                                CAP_PROP_VIDEO_STREAM, -1,
+                                CAP_PROP_AUDIO_DATA_DEPTH, CV_16S   };
+
+        cap.open(file, CAP_ANY, params);
+        if (!cap.isOpened())
+        {
+            cerr << "Error : Can't read audio file: '" << audio << "' with audioStream = " << audioStream << endl;
+            return;
+        }
+
+        const int audioBaseIndex = static_cast<int>(cap.get(CAP_PROP_AUDIO_BASE_INDEX));
+        const int numberOfChannels = static_cast<int>(cap.get(CAP_PROP_AUDIO_TOTAL_CHANNELS));
+        int samplingRate = static_cast<int>(cap.get(CAP_PROP_AUDIO_SAMPLES_PER_SECOND));
+
+        cout << "CAP_PROP_AUDIO_DATA_DEPTH: " << depthToString(static_cast<int>(cap.get(CAP_PROP_AUDIO_DATA_DEPTH))) << endl;
+        cout << "CAP_PROP_AUDIO_SAMPLES_PER_SECOND: " << cap.get(CAP_PROP_AUDIO_SAMPLES_PER_SECOND) << endl;
+        cout << "CAP_PROP_AUDIO_TOTAL_CHANNELS: " << numberOfChannels << endl;
+        cout << "CAP_PROP_AUDIO_TOTAL_STREAMS: " << cap.get(CAP_PROP_AUDIO_TOTAL_STREAMS) << endl;
+
+        int step = static_cast<int>(updateTime * samplingRate);
+        int frameSize = static_cast<int>(frameSizeTime * samplingRate);
+
+        // since the dimensional grid is counted in integer seconds,
+        // if duration of audio frame is less than xmarkup, to avoid an incorrect display,
+        // xmarkup will be taken equal to duration
+        if (frameSizeTime <= xmarkup)
+        {
+            xmarkup = frameSizeTime;
+        }
+
+        vector<int> buffer;
+        vector<int> frameVector;
+        vector<int> section(frameSize, 0);
+        vector<vector<double>>stft;
+        Mat frame, imgAmplitude, imgSpec, imgTotal;
+        int currentSamples = 0;
+        int xmin = 0;
+        int xmax = 0;
+
+        for (;;)
+        {
+            if (cap.grab())
+            {
+                cap.retrieve(frame, audioBaseIndex);
+                frameVector = frame;
+                buffer.insert(buffer.end(), frameVector.begin(), frameVector.end());
+                int bufferSize = static_cast<int>(buffer.size());
+                if (bufferSize >= step)
+                {
+                    currentSamples += bufferSize;
+                    section.erase(section.begin(), section.begin() + step);
+                    section.insert(section.end(), buffer.begin(), buffer.end());
+                    buffer.erase(buffer.begin(), buffer.begin() + step);
+                    if (currentSamples < frameSize)
+                    {
+                        xmin = 0;
+                        xmax = (currentSamples) / samplingRate;
+                    }
+                    else
+                    {
+                        xmin = (currentSamples - frameSize) / samplingRate + 1;
+                        xmax = (currentSamples) / samplingRate;
+                    }
+
+                    if (graph == "ampl")
+                    {
+                        imgAmplitude = drawAmplitude(section);
+                        imgAmplitude = drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax);
+                        imshow("Display amplitude graph", imgAmplitude);
+                        waitKey(waitTime);
+                    }
+                    else if (graph == "spec")
+                    {
+                        stft = STFT(section);
+                        imgSpec = drawSpectrogram(stft);
+                        imgSpec = drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax);
+                        imshow("Display spectrogram", imgSpec);
+                        waitKey(waitTime);
+                    }
+                    else if (graph == "ampl_and_spec")
+                    {
+                        imgAmplitude = drawAmplitude(section);
+                        imgAmplitude = drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax);
+                        stft = STFT(section);
+                        imgSpec = drawSpectrogram(stft);
+                        imgSpec = drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax);
+                        imgTotal = concatenateImages(imgAmplitude, imgSpec);
+                        imshow("Display amplitude graph and spectrogram", imgTotal);
+                        waitKey(waitTime);
+                    }
+                }
+            }
+            else
+            {
+                break;
+            }
+        }
+
+    }
+
+    void dynamicMicrophone()
+    {
+        VideoCapture cap;
+        vector<int> params {    CAP_PROP_AUDIO_STREAM, 0,
+                                CAP_PROP_VIDEO_STREAM, -1   };
+
+        cap.open(0, CAP_MSMF, params);
+        if (!cap.isOpened())
+        {
+            cerr << "Error: Can't open microphone" << endl;
+            return;
+        }
+
+        const int audioBaseIndex = static_cast<int>(cap.get(CAP_PROP_AUDIO_BASE_INDEX));
+        const int numberOfChannels = static_cast<int>(cap.get(CAP_PROP_AUDIO_TOTAL_CHANNELS));
+        int samplingRate = static_cast<int>(cap.get(CAP_PROP_AUDIO_SAMPLES_PER_SECOND));
+        cout << "CAP_PROP_AUDIO_DATA_DEPTH: " << depthToString(static_cast<int>(cap.get(CAP_PROP_AUDIO_DATA_DEPTH))) << endl;
+        cout << "CAP_PROP_AUDIO_SAMPLES_PER_SECOND: " << cap.get(CAP_PROP_AUDIO_SAMPLES_PER_SECOND) << endl;
+        cout << "CAP_PROP_AUDIO_TOTAL_CHANNELS: " << numberOfChannels << endl;
+        cout << "CAP_PROP_AUDIO_TOTAL_STREAMS: " << cap.get(CAP_PROP_AUDIO_TOTAL_STREAMS) << endl;
+
+        const double cvTickFreq = getTickFrequency();
+        int64 sysTimeCurr = getTickCount();
+        int64 sysTimePrev = sysTimeCurr;
+
+        int step = (updateTime * samplingRate);
+        int frameSize = (frameSizeTime * samplingRate);
+        // since the dimensional grid is counted in integer seconds,
+        // if duration of audio frame is less than xmarkup, to avoid an incorrect display,
+        // xmarkup will be taken equal to duration
+        if (frameSizeTime <= xmarkup)
+        {
+            xmarkup = frameSizeTime;
+        }
+
+        vector<int> frameVector;
+        vector<int> buffer;
+        vector<int> section(frameSize, 0);
+        Mat frame, imgAmplitude, imgSpec, imgTotal;
+
+        int currentSamples = 0;
+        vector<vector<double>> stft;
+        int xmin = 0;
+        int xmax = 0;
+        waitTime = updateTime * 1000;
+        while ((sysTimeCurr - sysTimePrev) / cvTickFreq < microTime)
+        {
+            if (cap.grab())
+            {
+                cap.retrieve(frame, audioBaseIndex);
+                frameVector = frame;
+                buffer.insert(buffer.end(), frameVector.begin(), frameVector.end());
+                sysTimeCurr = getTickCount();
+
+                int bufferSize = static_cast<int>(buffer.size());
+                if (bufferSize >= step)
+                {
+                    currentSamples += step;
+                    section.erase(section.begin(), section.begin() + step);
+                    section.insert(section.end(), buffer.begin(), buffer.end());
+                    buffer.erase(buffer.begin(), buffer.begin() + step);
+
+                    if (currentSamples < frameSize)
+                    {
+                        xmin = 0;
+                        xmax = (currentSamples) / samplingRate;
+                    }
+                    else
+                    {
+                        xmin = (currentSamples - frameSize) / samplingRate + 1;
+                        xmax = (currentSamples) / samplingRate;
+                    }
+
+                    if (graph == "ampl")
+                    {
+                        imgAmplitude = drawAmplitude(section);
+                        imgAmplitude = drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax);
+                        imshow("Display amplitude graph", imgAmplitude);
+                        waitKey(waitTime);
+                    }
+                    else if (graph == "spec")
+                    {
+                        stft = STFT(section);
+                        imgSpec = drawSpectrogram(stft);
+                        imgSpec = drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax);
+                        imshow("Display spectrogram", imgSpec);
+                        waitKey(waitTime);
+                    }
+                    else if (graph == "ampl_and_spec")
+                    {
+                        imgAmplitude = drawAmplitude(section);
+                        imgAmplitude = drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax);
+                        stft = STFT(section);
+                        imgSpec = drawSpectrogram(stft);
+                        imgSpec = drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax);
+                        imgTotal = concatenateImages(imgAmplitude, imgSpec);
+                        imshow("Display amplitude graph and spectrogram", imgTotal);
+                        waitKey(waitTime);
+                    }
+                }
+            }
+            else
+            {
+                cerr << "Error: Grab error" << endl;
+                break;
+            }
+        }
+
+    }
+
+    bool initAndCheckArgs(const CommandLineParser& parser)
+    {
+        inputType = parser.get<string>("inputType");
+        if ((inputType != "file") && (inputType != "microphone"))
+        {
+            cout << "Error: " << inputType << " input method doesnt exist" << endl;
+            return false;
+        }
+
+        draw = parser.get<string>("draw");
+        if ((draw != "static") && (draw != "dynamic"))
+        {
+            cout << "Error: " << draw << " draw type doesnt exist" << endl;
+            return false;
+        }
+
+        graph = parser.get<string>("graph");
+        if ((graph != "ampl") && (graph != "spec") && (graph != "ampl_and_spec"))
+        {
+            cout << "Error: " << graph << " type of graph doesnt exist" << endl;
+            return false;
+        }
+
+        audio = samples::findFile(parser.get<std::string>("audio"));
+
+        audioStream = parser.get<int>("audioStream");
+        if (audioStream < 0)
+        {
+            cout << "Error: audioStream = " << audioStream << " - incorrect value. Must be >= 0" << endl;
+            return false;
+        }
+        windowType = parser.get<string>("windowType");
+        if ((windowType != "Rect") && (windowType != "Hann") && (windowType != "Hamming"))
+        {
+            cout << "Error: " << windowType << " type of window doesnt exist" << endl;
+            return false;
+        }
+
+        windLen = parser.get<int>("windLen");
+        if (windLen <= 0)
+        {
+            cout << "Error: windLen = " << windLen << " - incorrect value. Must be > 0" << endl;
+            return false;
+        }
+
+        overlap = parser.get<int>("overlap");
+        if (overlap <= 0)
+        {
+            cout << "Error: overlap = " << overlap << " - incorrect value. Must be > 0" << endl;
+            return false;
+        }
+
+        enableGrid = parser.get<bool>("enableGrid");
+
+        rows = parser.get<int>("rows");
+        if (rows <= 0)
+        {
+            cout << "Error: rows = " << rows << " - incorrect value. Must be > 0" << endl;
+            return false;
+        }
+        cols = parser.get<int>("cols");
+
+        if (cols <= 0)
+        {
+            cout << "Error: cols = " << cols << " - incorrect value. Must be > 0" << endl;
+            return false;
+        }
+        xmarkup = parser.get<int>("xmarkup");
+        if (xmarkup < 2)
+        {
+            cout << "Error: xmarkup = " << xmarkup << " - incorrect value. Must be >= 2" << endl;
+            return false;
+        }
+        ymarkup = parser.get<int>("ymarkup");
+        if (ymarkup < 2)
+        {
+            cout << "Error: ymarkup = " << ymarkup << " - incorrect value. Must be >= 2" << endl;
+            return false;
+        }
+        zmarkup = parser.get<int>("zmarkup");
+        if (zmarkup < 2)
+        {
+            cout << "Error: zmarkup = " << zmarkup << " - incorrect value. Must be >= 2" << endl;
+            return false;
+        }
+        microTime = parser.get<int>("microTime");
+        if (microTime <= 0)
+        {
+            cout << "Error: microTime = " << microTime << " - incorrect value. Must be > 0" << endl;
+            return false;
+        }
+        frameSizeTime = parser.get<int>("frameSizeTime");
+        if (frameSizeTime <= 0)
+        {
+            cout << "Error: frameSizeTime = " << frameSizeTime << " - incorrect value. Must be > 0" << endl;
+            return false;
+        }
+        updateTime = parser.get<int>("updateTime");
+        if (updateTime <= 0)
+        {
+            cout << "Error: updateTime = " << updateTime << " - incorrect value. Must be > 0" << endl;
+            return false;
+        }
+        waitTime = parser.get<int>("waitTime");
+        if (waitTime < 0)
+        {
+            cout << "Error: waitTime = " << waitTime << " - incorrect value. Must be >= 0" << endl;
+            return false;
+        }
+        return true;
+    }
+
+private :
+    string inputType;
+    string draw;
+    string graph;
+    string audio;
+    int audioStream;
+
+    string windowType;
+    int windLen;
+    int overlap;
+
+    bool enableGrid;
+
+    int rows;
+    int cols;
+
+    int xmarkup;
+    int ymarkup;
+    int zmarkup;
+
+    int microTime;
+    int frameSizeTime;
+    int updateTime;
+    int waitTime;
+
+};
+
+int main(int argc, char** argv)
+{
+    const String keys =
+        "{help h usage ? |               | this sample draws a volume graph and/or spectrogram of audio/video files and microphone \n\t\tDefault usage: ./Spectrogram.exe}"
+        "{inputType i    | file          | file or microphone                       }"
+        "{draw d         | static        | type of drawing: \n\t\t\tstatic - for plotting graph(s) across the entire input audio \n\t\t\tdynamic - for plotting graph(s) in a time-updating window}"
+        "{graph g        | ampl_and_spec | type of graph: amplitude graph or/and spectrogram. Please use tags below : \n\t\t\tampl - draw the amplitude graph \n\t\t\tspec - draw the spectrogram\n\t\t\tampl_and_spec - draw the amplitude graph and spectrogram on one image under each other}"
+        "{audio a        | Megamind.avi  | name and path to file                    }"
+        "{audioStream s  | 1             | CAP_PROP_AUDIO_STREAM value. Select audio stream number }"
+        "{windowType t   | Rect          | type of window for STFT. Please use tags below : \n\t\t\tRect/Hann/Hamming }"
+        "{windLen l      | 256           | size of window for STFT                  }"
+        "{overlap o      | 128           | overlap of windows for STFT              }"
+
+        "{enableGrid     | false         | grid on the amplitude graph              }"
+
+        "{rows r         | 400           | rows of output image                     }"
+        "{cols c         | 900           | cols of output image                     }"
+
+        "{xmarkup x      | 5             | number of x axis divisions (time asix)   }"
+        "{ymarkup y      | 5             | number of y axis divisions (frequency or/and amplitude axis) }"
+        "{zmarkup z      | 5             | number of z axis divisions (colorbar)    }"
+
+        "{microTime m    | 20            | time of recording audio with microphone in seconds }"
+        "{frameSizeTime f| 5             | size of sliding window in seconds        }"
+        "{updateTime u   | 1             | update time of sliding window in seconds }"
+        "{waitTime w     | 10            | parameter to cv.waitKey() for dynamic update of file input, takes values in milliseconds }"
+        ;
+
+    CommandLineParser parser(argc, argv, keys);
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    AudioDrawing draw(parser);
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/cpp/bgfg_segm.cpp b/C++/opencv-4.7.0/samples/cpp/bgfg_segm.cpp
new file mode 100644
index 00000000..05377757
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/bgfg_segm.cpp
@@ -0,0 +1,124 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/video.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main(int argc, const char** argv)
+{
+    const String keys = "{c camera     | 0 | use video stream from camera (device index starting from 0) }"
+                        "{fn file_name |   | use video file as input }"
+                        "{m method | mog2 | method: background subtraction algorithm ('knn', 'mog2')}"
+                        "{h help | | show help message}";
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("This sample demonstrates background segmentation.");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    int camera = parser.get<int>("camera");
+    String file = parser.get<String>("file_name");
+    String method = parser.get<String>("method");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+
+    VideoCapture cap;
+    if (file.empty())
+        cap.open(camera);
+    else
+    {
+        file = samples::findFileOrKeep(file);  // ignore gstreamer pipelines
+        cap.open(file.c_str());
+    }
+    if (!cap.isOpened())
+    {
+        cout << "Can not open video stream: '" << (file.empty() ? "<camera>" : file) << "'" << endl;
+        return 2;
+    }
+
+    Ptr<BackgroundSubtractor> model;
+    if (method == "knn")
+        model = createBackgroundSubtractorKNN();
+    else if (method == "mog2")
+        model = createBackgroundSubtractorMOG2();
+    if (!model)
+    {
+        cout << "Can not create background model using provided method: '" << method << "'" << endl;
+        return 3;
+    }
+
+    cout << "Press <space> to toggle background model update" << endl;
+    cout << "Press 's' to toggle foreground mask smoothing" << endl;
+    cout << "Press ESC or 'q' to exit" << endl;
+    bool doUpdateModel = true;
+    bool doSmoothMask = false;
+
+    Mat inputFrame, frame, foregroundMask, foreground, background;
+    for (;;)
+    {
+        // prepare input frame
+        cap >> inputFrame;
+        if (inputFrame.empty())
+        {
+            cout << "Finished reading: empty frame" << endl;
+            break;
+        }
+        const Size scaledSize(640, 640 * inputFrame.rows / inputFrame.cols);
+        resize(inputFrame, frame, scaledSize, 0, 0, INTER_LINEAR);
+
+        // pass the frame to background model
+        model->apply(frame, foregroundMask, doUpdateModel ? -1 : 0);
+
+        // show processed frame
+        imshow("image", frame);
+
+        // show foreground image and mask (with optional smoothing)
+        if (doSmoothMask)
+        {
+            GaussianBlur(foregroundMask, foregroundMask, Size(11, 11), 3.5, 3.5);
+            threshold(foregroundMask, foregroundMask, 10, 255, THRESH_BINARY);
+        }
+        if (foreground.empty())
+            foreground.create(scaledSize, frame.type());
+        foreground = Scalar::all(0);
+        frame.copyTo(foreground, foregroundMask);
+        imshow("foreground mask", foregroundMask);
+        imshow("foreground image", foreground);
+
+        // show background image
+        model->getBackgroundImage(background);
+        if (!background.empty())
+            imshow("mean background image", background );
+
+        // interact with user
+        const char key = (char)waitKey(30);
+        if (key == 27 || key == 'q') // ESC
+        {
+            cout << "Exit requested" << endl;
+            break;
+        }
+        else if (key == ' ')
+        {
+            doUpdateModel = !doUpdateModel;
+            cout << "Toggle background update: " << (doUpdateModel ? "ON" : "OFF") << endl;
+        }
+        else if (key == 's')
+        {
+            doSmoothMask = !doSmoothMask;
+            cout << "Toggle foreground mask smoothing: " << (doSmoothMask ? "ON" : "OFF") << endl;
+        }
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/calibration.cpp b/C++/opencv-4.7.0/samples/cpp/calibration.cpp
new file mode 100644
index 00000000..1e8e1499
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/calibration.cpp
@@ -0,0 +1,645 @@
+#include "opencv2/core.hpp"
+#include <opencv2/core/utility.hpp>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/calib3d.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <cctype>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+const char * usage =
+" \nexample command line for calibration from a live feed.\n"
+"   calibration  -w=4 -h=5 -s=0.025 -o=camera.yml -op -oe\n"
+" \n"
+" example command line for calibration from a list of stored images:\n"
+"   imagelist_creator image_list.xml *.png\n"
+"   calibration -w=4 -h=5 -s=0.025 -o=camera.yml -op -oe image_list.xml\n"
+" where image_list.xml is the standard OpenCV XML/YAML\n"
+" use imagelist_creator to create the xml or yaml list\n"
+" file consisting of the list of strings, e.g.:\n"
+" \n"
+"<?xml version=\"1.0\"?>\n"
+"<opencv_storage>\n"
+"<images>\n"
+"view000.png\n"
+"view001.png\n"
+"<!-- view002.png -->\n"
+"view003.png\n"
+"view010.png\n"
+"one_extra_view.jpg\n"
+"</images>\n"
+"</opencv_storage>\n";
+
+const char* liveCaptureHelp =
+    "When the live video from camera is used as input, the following hot-keys may be used:\n"
+        "  <ESC>, 'q' - quit the program\n"
+        "  'g' - start capturing images\n"
+        "  'u' - switch undistortion on/off\n";
+
+static void help(char** argv)
+{
+    printf( "This is a camera calibration sample.\n"
+        "Usage: %s\n"
+        "     -w=<board_width>         # the number of inner corners per one of board dimension\n"
+        "     -h=<board_height>        # the number of inner corners per another board dimension\n"
+        "     [-pt=<pattern>]          # the type of pattern: chessboard or circles' grid\n"
+        "     [-n=<number_of_frames>]  # the number of frames to use for calibration\n"
+        "                              # (if not specified, it will be set to the number\n"
+        "                              #  of board views actually available)\n"
+        "     [-d=<delay>]             # a minimum delay in ms between subsequent attempts to capture a next view\n"
+        "                              # (used only for video capturing)\n"
+        "     [-s=<squareSize>]        # square size in some user-defined units (1 by default)\n"
+        "     [-o=<out_camera_params>] # the output filename for intrinsic [and extrinsic] parameters\n"
+        "     [-op]                    # write detected feature points\n"
+        "     [-oe]                    # write extrinsic parameters\n"
+        "     [-oo]                    # write refined 3D object points\n"
+        "     [-zt]                    # assume zero tangential distortion\n"
+        "     [-a=<aspectRatio>]       # fix aspect ratio (fx/fy)\n"
+        "     [-p]                     # fix the principal point at the center\n"
+        "     [-v]                     # flip the captured images around the horizontal axis\n"
+        "     [-V]                     # use a video file, and not an image list, uses\n"
+        "                              # [input_data] string for the video file name\n"
+        "     [-su]                    # show undistorted images after calibration\n"
+        "     [-ws=<number_of_pixel>]  # half of search window for cornerSubPix (11 by default)\n"
+        "     [-fx=<X focal length>]   # focal length in X-dir as an initial intrinsic guess (if this flag is used, fx, fy, cx, cy must be set)\n"
+        "     [-fy=<Y focal length>]   # focal length in Y-dir as an initial intrinsic guess (if this flag is used, fx, fy, cx, cy must be set)\n"
+        "     [-cx=<X center point>]   # camera center point in X-dir as an initial intrinsic guess (if this flag is used, fx, fy, cx, cy must be set)\n"
+        "     [-cy=<Y center point>]   # camera center point in Y-dir as an initial intrinsic guess (if this flag is used, fx, fy, cx, cy must be set)\n"
+        "     [-imshow-scale           # image resize scaling factor when displaying the results (must be >= 1)\n"
+        "     [-enable-k3=<0/1>        # to enable (1) or disable (0) K3 coefficient for the distortion model\n"
+        "     [-dt=<distance>]         # actual distance between top-left and top-right corners of\n"
+        "                              # the calibration grid. If this parameter is specified, a more\n"
+        "                              # accurate calibration method will be used which may be better\n"
+        "                              # with inaccurate, roughly planar target.\n"
+        "     [input_data]             # input data, one of the following:\n"
+        "                              #  - text file with a list of the images of the board\n"
+        "                              #    the text file can be generated with imagelist_creator\n"
+        "                              #  - name of video file with a video of the board\n"
+        "                              # if input_data not specified, a live view from the camera is used\n"
+        "\n", argv[0] );
+    printf("\n%s",usage);
+    printf( "\n%s", liveCaptureHelp );
+}
+
+enum { DETECTION = 0, CAPTURING = 1, CALIBRATED = 2 };
+enum Pattern { CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
+
+static double computeReprojectionErrors(
+        const vector<vector<Point3f> >& objectPoints,
+        const vector<vector<Point2f> >& imagePoints,
+        const vector<Mat>& rvecs, const vector<Mat>& tvecs,
+        const Mat& cameraMatrix, const Mat& distCoeffs,
+        vector<float>& perViewErrors )
+{
+    vector<Point2f> imagePoints2;
+    int i, totalPoints = 0;
+    double totalErr = 0, err;
+    perViewErrors.resize(objectPoints.size());
+
+    for( i = 0; i < (int)objectPoints.size(); i++ )
+    {
+        projectPoints(Mat(objectPoints[i]), rvecs[i], tvecs[i],
+                      cameraMatrix, distCoeffs, imagePoints2);
+        err = norm(Mat(imagePoints[i]), Mat(imagePoints2), NORM_L2);
+        int n = (int)objectPoints[i].size();
+        perViewErrors[i] = (float)std::sqrt(err*err/n);
+        totalErr += err*err;
+        totalPoints += n;
+    }
+
+    return std::sqrt(totalErr/totalPoints);
+}
+
+static void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners, Pattern patternType = CHESSBOARD)
+{
+    corners.resize(0);
+
+    switch(patternType)
+    {
+      case CHESSBOARD:
+      case CIRCLES_GRID:
+        for( int i = 0; i < boardSize.height; i++ )
+            for( int j = 0; j < boardSize.width; j++ )
+                corners.push_back(Point3f(float(j*squareSize),
+                                          float(i*squareSize), 0));
+        break;
+
+      case ASYMMETRIC_CIRCLES_GRID:
+        for( int i = 0; i < boardSize.height; i++ )
+            for( int j = 0; j < boardSize.width; j++ )
+                corners.push_back(Point3f(float((2*j + i % 2)*squareSize),
+                                          float(i*squareSize), 0));
+        break;
+
+      default:
+        CV_Error(Error::StsBadArg, "Unknown pattern type\n");
+    }
+}
+
+static bool runCalibration( vector<vector<Point2f> > imagePoints,
+                    Size imageSize, Size boardSize, Pattern patternType,
+                    float squareSize, float aspectRatio,
+                    float grid_width, bool release_object,
+                    int flags, Mat& cameraMatrix, Mat& distCoeffs,
+                    vector<Mat>& rvecs, vector<Mat>& tvecs,
+                    vector<float>& reprojErrs,
+                    vector<Point3f>& newObjPoints,
+                    double& totalAvgErr)
+{
+    if( flags & CALIB_FIX_ASPECT_RATIO )
+        cameraMatrix.at<double>(0,0) = aspectRatio;
+
+    distCoeffs = Mat::zeros(8, 1, CV_64F);
+
+    vector<vector<Point3f> > objectPoints(1);
+    calcChessboardCorners(boardSize, squareSize, objectPoints[0], patternType);
+    objectPoints[0][boardSize.width - 1].x = objectPoints[0][0].x + grid_width;
+    newObjPoints = objectPoints[0];
+
+    objectPoints.resize(imagePoints.size(),objectPoints[0]);
+
+    double rms;
+    int iFixedPoint = -1;
+    if (release_object)
+        iFixedPoint = boardSize.width - 1;
+    rms = calibrateCameraRO(objectPoints, imagePoints, imageSize, iFixedPoint,
+                            cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints,
+                            flags | CALIB_USE_LU);
+    printf("RMS error reported by calibrateCamera: %g\n", rms);
+
+    bool ok = checkRange(cameraMatrix) && checkRange(distCoeffs);
+
+    if (release_object) {
+        cout << "New board corners: " << endl;
+        cout << newObjPoints[0] << endl;
+        cout << newObjPoints[boardSize.width - 1] << endl;
+        cout << newObjPoints[boardSize.width * (boardSize.height - 1)] << endl;
+        cout << newObjPoints.back() << endl;
+    }
+
+    objectPoints.clear();
+    objectPoints.resize(imagePoints.size(), newObjPoints);
+    totalAvgErr = computeReprojectionErrors(objectPoints, imagePoints,
+                rvecs, tvecs, cameraMatrix, distCoeffs, reprojErrs);
+
+    return ok;
+}
+
+static void saveCameraParams( const string& filename,
+                       Size imageSize, Size boardSize,
+                       float squareSize, float aspectRatio, int flags,
+                       const Mat& cameraMatrix, const Mat& distCoeffs,
+                       const vector<Mat>& rvecs, const vector<Mat>& tvecs,
+                       const vector<float>& reprojErrs,
+                       const vector<vector<Point2f> >& imagePoints,
+                       const vector<Point3f>& newObjPoints,
+                       double totalAvgErr )
+{
+    FileStorage fs( filename, FileStorage::WRITE );
+
+    time_t tt;
+    time( &tt );
+    struct tm *t2 = localtime( &tt );
+    char buf[1024];
+    strftime( buf, sizeof(buf)-1, "%c", t2 );
+
+    fs << "calibration_time" << buf;
+
+    if( !rvecs.empty() || !reprojErrs.empty() )
+        fs << "nframes" << (int)std::max(rvecs.size(), reprojErrs.size());
+    fs << "image_width" << imageSize.width;
+    fs << "image_height" << imageSize.height;
+    fs << "board_width" << boardSize.width;
+    fs << "board_height" << boardSize.height;
+    fs << "square_size" << squareSize;
+
+    if( flags & CALIB_FIX_ASPECT_RATIO )
+        fs << "aspectRatio" << aspectRatio;
+
+    if( flags != 0 )
+    {
+        snprintf( buf, sizeof(buf), "flags: %s%s%s%s",
+            flags & CALIB_USE_INTRINSIC_GUESS ? "+use_intrinsic_guess" : "",
+            flags & CALIB_FIX_ASPECT_RATIO ? "+fix_aspectRatio" : "",
+            flags & CALIB_FIX_PRINCIPAL_POINT ? "+fix_principal_point" : "",
+            flags & CALIB_ZERO_TANGENT_DIST ? "+zero_tangent_dist" : "" );
+        //cvWriteComment( *fs, buf, 0 );
+    }
+
+    fs << "flags" << flags;
+
+    fs << "camera_matrix" << cameraMatrix;
+    fs << "distortion_coefficients" << distCoeffs;
+
+    fs << "avg_reprojection_error" << totalAvgErr;
+    if( !reprojErrs.empty() )
+        fs << "per_view_reprojection_errors" << Mat(reprojErrs);
+
+    if( !rvecs.empty() && !tvecs.empty() )
+    {
+        CV_Assert(rvecs[0].type() == tvecs[0].type());
+        Mat bigmat((int)rvecs.size(), 6, rvecs[0].type());
+        for( int i = 0; i < (int)rvecs.size(); i++ )
+        {
+            Mat r = bigmat(Range(i, i+1), Range(0,3));
+            Mat t = bigmat(Range(i, i+1), Range(3,6));
+
+            CV_Assert(rvecs[i].rows == 3 && rvecs[i].cols == 1);
+            CV_Assert(tvecs[i].rows == 3 && tvecs[i].cols == 1);
+            //*.t() is MatExpr (not Mat) so we can use assignment operator
+            r = rvecs[i].t();
+            t = tvecs[i].t();
+        }
+        //cvWriteComment( *fs, "a set of 6-tuples (rotation vector + translation vector) for each view", 0 );
+        fs << "extrinsic_parameters" << bigmat;
+    }
+
+    if( !imagePoints.empty() )
+    {
+        Mat imagePtMat((int)imagePoints.size(), (int)imagePoints[0].size(), CV_32FC2);
+        for( int i = 0; i < (int)imagePoints.size(); i++ )
+        {
+            Mat r = imagePtMat.row(i).reshape(2, imagePtMat.cols);
+            Mat imgpti(imagePoints[i]);
+            imgpti.copyTo(r);
+        }
+        fs << "image_points" << imagePtMat;
+    }
+
+    if( !newObjPoints.empty() )
+    {
+        fs << "grid_points" << newObjPoints;
+    }
+}
+
+static bool readStringList( const string& filename, vector<string>& l )
+{
+    l.resize(0);
+    FileStorage fs(filename, FileStorage::READ);
+    if( !fs.isOpened() )
+        return false;
+    size_t dir_pos = filename.rfind('/');
+    if (dir_pos == string::npos)
+        dir_pos = filename.rfind('\\');
+    FileNode n = fs.getFirstTopLevelNode();
+    if( n.type() != FileNode::SEQ )
+        return false;
+    FileNodeIterator it = n.begin(), it_end = n.end();
+    for( ; it != it_end; ++it )
+    {
+        string fname = (string)*it;
+        if (dir_pos != string::npos)
+        {
+            string fpath = samples::findFile(filename.substr(0, dir_pos + 1) + fname, false);
+            if (fpath.empty())
+            {
+                fpath = samples::findFile(fname);
+            }
+            fname = fpath;
+        }
+        else
+        {
+            fname = samples::findFile(fname);
+        }
+        l.push_back(fname);
+    }
+    return true;
+}
+
+
+static bool runAndSave(const string& outputFilename,
+                const vector<vector<Point2f> >& imagePoints,
+                Size imageSize, Size boardSize, Pattern patternType, float squareSize,
+                float grid_width, bool release_object,
+                float aspectRatio, int flags, Mat& cameraMatrix,
+                Mat& distCoeffs, bool writeExtrinsics, bool writePoints, bool writeGrid )
+{
+    vector<Mat> rvecs, tvecs;
+    vector<float> reprojErrs;
+    double totalAvgErr = 0;
+    vector<Point3f> newObjPoints;
+
+    bool ok = runCalibration(imagePoints, imageSize, boardSize, patternType, squareSize,
+                   aspectRatio, grid_width, release_object, flags, cameraMatrix, distCoeffs,
+                   rvecs, tvecs, reprojErrs, newObjPoints, totalAvgErr);
+    printf("%s. avg reprojection error = %.7f\n",
+           ok ? "Calibration succeeded" : "Calibration failed",
+           totalAvgErr);
+
+    if( ok )
+        saveCameraParams( outputFilename, imageSize,
+                         boardSize, squareSize, aspectRatio,
+                         flags, cameraMatrix, distCoeffs,
+                         writeExtrinsics ? rvecs : vector<Mat>(),
+                         writeExtrinsics ? tvecs : vector<Mat>(),
+                         writeExtrinsics ? reprojErrs : vector<float>(),
+                         writePoints ? imagePoints : vector<vector<Point2f> >(),
+                         writeGrid ? newObjPoints : vector<Point3f>(),
+                         totalAvgErr );
+    return ok;
+}
+
+int main( int argc, char** argv )
+{
+    Size boardSize, imageSize;
+    float squareSize, aspectRatio = 1;
+    Mat cameraMatrix, distCoeffs;
+    string outputFilename;
+    string inputFilename = "";
+
+    int i, nframes;
+    bool writeExtrinsics, writePoints;
+    bool undistortImage = false;
+    int flags = 0;
+    VideoCapture capture;
+    bool flipVertical;
+    bool showUndistorted;
+    bool videofile;
+    int delay;
+    clock_t prevTimestamp = 0;
+    int mode = DETECTION;
+    int cameraId = 0;
+    vector<vector<Point2f> > imagePoints;
+    vector<string> imageList;
+    Pattern pattern = CHESSBOARD;
+
+    cv::CommandLineParser parser(argc, argv,
+        "{help ||}{w||}{h||}{pt|chessboard|}{n|10|}{d|1000|}{s|1|}{o|out_camera_data.yml|}"
+        "{op||}{oe||}{zt||}{a||}{p||}{v||}{V||}{su||}"
+        "{oo||}{ws|11|}{dt||}"
+        "{fx||}{fy||}{cx||}{cy||}"
+        "{imshow-scale|1|}{enable-k3|0|}"
+        "{@input_data|0|}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    boardSize.width = parser.get<int>( "w" );
+    boardSize.height = parser.get<int>( "h" );
+    if ( parser.has("pt") )
+    {
+        string val = parser.get<string>("pt");
+        if( val == "circles" )
+            pattern = CIRCLES_GRID;
+        else if( val == "acircles" )
+            pattern = ASYMMETRIC_CIRCLES_GRID;
+        else if( val == "chessboard" )
+            pattern = CHESSBOARD;
+        else
+            return fprintf( stderr, "Invalid pattern type: must be chessboard or circles\n" ), -1;
+    }
+    squareSize = parser.get<float>("s");
+    nframes = parser.get<int>("n");
+    delay = parser.get<int>("d");
+    writePoints = parser.has("op");
+    writeExtrinsics = parser.has("oe");
+    bool writeGrid = parser.has("oo");
+    if (parser.has("a")) {
+        flags |= CALIB_FIX_ASPECT_RATIO;
+        aspectRatio = parser.get<float>("a");
+    }
+    if ( parser.has("zt") )
+        flags |= CALIB_ZERO_TANGENT_DIST;
+    if ( parser.has("p") )
+        flags |= CALIB_FIX_PRINCIPAL_POINT;
+    flipVertical = parser.has("v");
+    videofile = parser.has("V");
+    if ( parser.has("o") )
+        outputFilename = parser.get<string>("o");
+    showUndistorted = parser.has("su");
+    if ( isdigit(parser.get<string>("@input_data")[0]) )
+        cameraId = parser.get<int>("@input_data");
+    else
+        inputFilename = parser.get<string>("@input_data");
+    int winSize = parser.get<int>("ws");
+    cameraMatrix = Mat::eye(3, 3, CV_64F);
+    if (parser.has("fx") && parser.has("fy") && parser.has("cx") && parser.has("cy"))
+    {
+        cameraMatrix.at<double>(0,0) = parser.get<double>("fx");
+        cameraMatrix.at<double>(0,2) = parser.get<double>("cx");
+        cameraMatrix.at<double>(1,1) = parser.get<double>("fy");
+        cameraMatrix.at<double>(1,2) = parser.get<double>("cy");
+        flags |= CALIB_USE_INTRINSIC_GUESS;
+        std::cout << "Use the following camera matrix as an initial guess:\n" << cameraMatrix << std::endl;
+    }
+    int viewScaleFactor = parser.get<int>("imshow-scale");
+    bool useK3 = parser.get<bool>("enable-k3");
+    std::cout << "Use K3 distortion coefficient? " << useK3 << std::endl;
+    if (!useK3)
+    {
+        flags |= CALIB_FIX_K3;
+    }
+    float grid_width = squareSize * (boardSize.width - 1);
+    bool release_object = false;
+    if (parser.has("dt")) {
+        grid_width = parser.get<float>("dt");
+        release_object = true;
+    }
+    if (!parser.check())
+    {
+        help(argv);
+        parser.printErrors();
+        return -1;
+    }
+    if ( squareSize <= 0 )
+        return fprintf( stderr, "Invalid board square width\n" ), -1;
+    if ( nframes <= 3 )
+        return printf("Invalid number of images\n" ), -1;
+    if ( aspectRatio <= 0 )
+        return printf( "Invalid aspect ratio\n" ), -1;
+    if ( delay <= 0 )
+        return printf( "Invalid delay\n" ), -1;
+    if ( boardSize.width <= 0 )
+        return fprintf( stderr, "Invalid board width\n" ), -1;
+    if ( boardSize.height <= 0 )
+        return fprintf( stderr, "Invalid board height\n" ), -1;
+
+    if( !inputFilename.empty() )
+    {
+        if( !videofile && readStringList(samples::findFile(inputFilename), imageList) )
+            mode = CAPTURING;
+        else
+            capture.open(samples::findFileOrKeep(inputFilename));
+    }
+    else
+        capture.open(cameraId);
+
+    if( !capture.isOpened() && imageList.empty() )
+        return fprintf( stderr, "Could not initialize video (%d) capture\n",cameraId ), -2;
+
+    if( !imageList.empty() )
+        nframes = (int)imageList.size();
+
+    if( capture.isOpened() )
+        printf( "%s", liveCaptureHelp );
+
+    namedWindow( "Image View", 1 );
+
+    for(i = 0;;i++)
+    {
+        Mat view, viewGray;
+        bool blink = false;
+
+        if( capture.isOpened() )
+        {
+            Mat view0;
+            capture >> view0;
+            view0.copyTo(view);
+        }
+        else if( i < (int)imageList.size() )
+            view = imread(imageList[i], 1);
+
+        if(view.empty())
+        {
+            if( imagePoints.size() > 0 )
+                runAndSave(outputFilename, imagePoints, imageSize,
+                           boardSize, pattern, squareSize, grid_width, release_object, aspectRatio,
+                           flags, cameraMatrix, distCoeffs,
+                           writeExtrinsics, writePoints, writeGrid);
+            break;
+        }
+
+        imageSize = view.size();
+
+        if( flipVertical )
+            flip( view, view, 0 );
+
+        vector<Point2f> pointbuf;
+        cvtColor(view, viewGray, COLOR_BGR2GRAY);
+
+        bool found;
+        switch( pattern )
+        {
+            case CHESSBOARD:
+                found = findChessboardCorners( view, boardSize, pointbuf,
+                    CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_FAST_CHECK | CALIB_CB_NORMALIZE_IMAGE);
+                break;
+            case CIRCLES_GRID:
+                found = findCirclesGrid( view, boardSize, pointbuf );
+                break;
+            case ASYMMETRIC_CIRCLES_GRID:
+                found = findCirclesGrid( view, boardSize, pointbuf, CALIB_CB_ASYMMETRIC_GRID );
+                break;
+            default:
+                return fprintf( stderr, "Unknown pattern type\n" ), -1;
+        }
+
+       // improve the found corners' coordinate accuracy
+        if( pattern == CHESSBOARD && found) cornerSubPix( viewGray, pointbuf, Size(winSize,winSize),
+            Size(-1,-1), TermCriteria( TermCriteria::EPS+TermCriteria::COUNT, 30, 0.0001 ));
+
+        if( mode == CAPTURING && found &&
+           (!capture.isOpened() || clock() - prevTimestamp > delay*1e-3*CLOCKS_PER_SEC) )
+        {
+            imagePoints.push_back(pointbuf);
+            prevTimestamp = clock();
+            blink = capture.isOpened();
+        }
+
+        if(found)
+            drawChessboardCorners( view, boardSize, Mat(pointbuf), found );
+
+        string msg = mode == CAPTURING ? "100/100" :
+            mode == CALIBRATED ? "Calibrated" : "Press 'g' to start";
+        int baseLine = 0;
+        Size textSize = getTextSize(msg, 1, 1, 1, &baseLine);
+        Point textOrigin(view.cols - 2*textSize.width - 10, view.rows - 2*baseLine - 10);
+
+        if( mode == CAPTURING )
+        {
+            if(undistortImage)
+                msg = cv::format( "%d/%d Undist", (int)imagePoints.size(), nframes );
+            else
+                msg = cv::format( "%d/%d", (int)imagePoints.size(), nframes );
+        }
+
+        putText( view, msg, textOrigin, 1, 1,
+                 mode != CALIBRATED ? Scalar(0,0,255) : Scalar(0,255,0));
+
+        if( blink )
+            bitwise_not(view, view);
+
+        if( mode == CALIBRATED && undistortImage )
+        {
+            Mat temp = view.clone();
+            undistort(temp, view, cameraMatrix, distCoeffs);
+        }
+        if (viewScaleFactor > 1)
+        {
+            Mat viewScale;
+            resize(view, viewScale, Size(), 1.0/viewScaleFactor, 1.0/viewScaleFactor, INTER_AREA);
+            imshow("Image View", viewScale);
+        }
+        else
+        {
+            imshow("Image View", view);
+        }
+
+        char key = (char)waitKey(capture.isOpened() ? 50 : 500);
+
+        if( key == 27 )
+            break;
+
+        if( key == 'u' && mode == CALIBRATED )
+            undistortImage = !undistortImage;
+
+        if( capture.isOpened() && key == 'g' )
+        {
+            mode = CAPTURING;
+            imagePoints.clear();
+        }
+
+        if( mode == CAPTURING && imagePoints.size() >= (unsigned)nframes )
+        {
+            if( runAndSave(outputFilename, imagePoints, imageSize,
+                       boardSize, pattern, squareSize, grid_width, release_object, aspectRatio,
+                       flags, cameraMatrix, distCoeffs,
+                       writeExtrinsics, writePoints, writeGrid))
+                mode = CALIBRATED;
+            else
+                mode = DETECTION;
+            if( !capture.isOpened() )
+                break;
+        }
+    }
+
+    if( !capture.isOpened() && showUndistorted )
+    {
+        Mat view, rview, map1, map2;
+        initUndistortRectifyMap(cameraMatrix, distCoeffs, Mat(),
+                                getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, 1, imageSize, 0),
+                                imageSize, CV_16SC2, map1, map2);
+
+        for( i = 0; i < (int)imageList.size(); i++ )
+        {
+            view = imread(imageList[i], 1);
+            if(view.empty())
+                continue;
+            remap(view, rview, map1, map2, INTER_LINEAR);
+            if (viewScaleFactor > 1)
+            {
+                Mat rviewScale;
+                resize(rview, rviewScale, Size(), 1.0/viewScaleFactor, 1.0/viewScaleFactor, INTER_AREA);
+                imshow("Image View", rviewScale);
+            }
+            else
+            {
+                imshow("Image View", rview);
+            }
+            char c = (char)waitKey();
+            if( c == 27 || c == 'q' || c == 'Q' )
+                break;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/camshiftdemo.cpp b/C++/opencv-4.7.0/samples/cpp/camshiftdemo.cpp
new file mode 100644
index 00000000..e0840f75
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/camshiftdemo.cpp
@@ -0,0 +1,219 @@
+#include "opencv2/core/utility.hpp"
+#include "opencv2/video/tracking.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+#include <ctype.h>
+
+using namespace cv;
+using namespace std;
+
+Mat image;
+
+bool backprojMode = false;
+bool selectObject = false;
+int trackObject = 0;
+bool showHist = true;
+Point origin;
+Rect selection;
+int vmin = 10, vmax = 256, smin = 30;
+
+// User draws box around object to track. This triggers CAMShift to start tracking
+static void onMouse( int event, int x, int y, int, void* )
+{
+    if( selectObject )
+    {
+        selection.x = MIN(x, origin.x);
+        selection.y = MIN(y, origin.y);
+        selection.width = std::abs(x - origin.x);
+        selection.height = std::abs(y - origin.y);
+
+        selection &= Rect(0, 0, image.cols, image.rows);
+    }
+
+    switch( event )
+    {
+    case EVENT_LBUTTONDOWN:
+        origin = Point(x,y);
+        selection = Rect(x,y,0,0);
+        selectObject = true;
+        break;
+    case EVENT_LBUTTONUP:
+        selectObject = false;
+        if( selection.width > 0 && selection.height > 0 )
+            trackObject = -1;   // Set up CAMShift properties in main() loop
+        break;
+    }
+}
+
+string hot_keys =
+    "\n\nHot keys: \n"
+    "\tESC - quit the program\n"
+    "\tc - stop the tracking\n"
+    "\tb - switch to/from backprojection view\n"
+    "\th - show/hide object histogram\n"
+    "\tp - pause video\n"
+    "To initialize tracking, select the object with mouse\n";
+
+static void help(const char** argv)
+{
+    cout << "\nThis is a demo that shows mean-shift based tracking\n"
+            "You select a color objects such as your face and it tracks it.\n"
+            "This reads from video camera (0 by default, or the camera number the user enters\n"
+            "Usage: \n\t";
+    cout << argv[0] << " [camera number]\n";
+    cout << hot_keys;
+}
+
+const char* keys =
+{
+    "{help h | | show help message}{@camera_number| 0 | camera number}"
+};
+
+int main( int argc, const char** argv )
+{
+    VideoCapture cap;
+    Rect trackWindow;
+    int hsize = 16;
+    float hranges[] = {0,180};
+    const float* phranges = hranges;
+    CommandLineParser parser(argc, argv, keys);
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    int camNum = parser.get<int>(0);
+    cap.open(camNum);
+
+    if( !cap.isOpened() )
+    {
+        help(argv);
+        cout << "***Could not initialize capturing...***\n";
+        cout << "Current parameter's value: \n";
+        parser.printMessage();
+        return -1;
+    }
+    cout << hot_keys;
+    namedWindow( "Histogram", 0 );
+    namedWindow( "CamShift Demo", 0 );
+    setMouseCallback( "CamShift Demo", onMouse, 0 );
+    createTrackbar( "Vmin", "CamShift Demo", &vmin, 256, 0 );
+    createTrackbar( "Vmax", "CamShift Demo", &vmax, 256, 0 );
+    createTrackbar( "Smin", "CamShift Demo", &smin, 256, 0 );
+
+    Mat frame, hsv, hue, mask, hist, histimg = Mat::zeros(200, 320, CV_8UC3), backproj;
+    bool paused = false;
+
+    for(;;)
+    {
+        if( !paused )
+        {
+            cap >> frame;
+            if( frame.empty() )
+                break;
+        }
+
+        frame.copyTo(image);
+
+        if( !paused )
+        {
+            cvtColor(image, hsv, COLOR_BGR2HSV);
+
+            if( trackObject )
+            {
+                int _vmin = vmin, _vmax = vmax;
+
+                inRange(hsv, Scalar(0, smin, MIN(_vmin,_vmax)),
+                        Scalar(180, 256, MAX(_vmin, _vmax)), mask);
+                int ch[] = {0, 0};
+                hue.create(hsv.size(), hsv.depth());
+                mixChannels(&hsv, 1, &hue, 1, ch, 1);
+
+                if( trackObject < 0 )
+                {
+                    // Object has been selected by user, set up CAMShift search properties once
+                    Mat roi(hue, selection), maskroi(mask, selection);
+                    calcHist(&roi, 1, 0, maskroi, hist, 1, &hsize, &phranges);
+                    normalize(hist, hist, 0, 255, NORM_MINMAX);
+
+                    trackWindow = selection;
+                    trackObject = 1; // Don't set up again, unless user selects new ROI
+
+                    histimg = Scalar::all(0);
+                    int binW = histimg.cols / hsize;
+                    Mat buf(1, hsize, CV_8UC3);
+                    for( int i = 0; i < hsize; i++ )
+                        buf.at<Vec3b>(i) = Vec3b(saturate_cast<uchar>(i*180./hsize), 255, 255);
+                    cvtColor(buf, buf, COLOR_HSV2BGR);
+
+                    for( int i = 0; i < hsize; i++ )
+                    {
+                        int val = saturate_cast<int>(hist.at<float>(i)*histimg.rows/255);
+                        rectangle( histimg, Point(i*binW,histimg.rows),
+                                   Point((i+1)*binW,histimg.rows - val),
+                                   Scalar(buf.at<Vec3b>(i)), -1, 8 );
+                    }
+                }
+
+                // Perform CAMShift
+                calcBackProject(&hue, 1, 0, hist, backproj, &phranges);
+                backproj &= mask;
+                RotatedRect trackBox = CamShift(backproj, trackWindow,
+                                    TermCriteria( TermCriteria::EPS | TermCriteria::COUNT, 10, 1 ));
+                if( trackWindow.area() <= 1 )
+                {
+                    int cols = backproj.cols, rows = backproj.rows, r = (MIN(cols, rows) + 5)/6;
+                    trackWindow = Rect(trackWindow.x - r, trackWindow.y - r,
+                                       trackWindow.x + r, trackWindow.y + r) &
+                                  Rect(0, 0, cols, rows);
+                }
+
+                if( backprojMode )
+                    cvtColor( backproj, image, COLOR_GRAY2BGR );
+                ellipse( image, trackBox, Scalar(0,0,255), 3, LINE_AA );
+            }
+        }
+        else if( trackObject < 0 )
+            paused = false;
+
+        if( selectObject && selection.width > 0 && selection.height > 0 )
+        {
+            Mat roi(image, selection);
+            bitwise_not(roi, roi);
+        }
+
+        imshow( "CamShift Demo", image );
+        imshow( "Histogram", histimg );
+
+        char c = (char)waitKey(10);
+        if( c == 27 )
+            break;
+        switch(c)
+        {
+        case 'b':
+            backprojMode = !backprojMode;
+            break;
+        case 'c':
+            trackObject = 0;
+            histimg = Scalar::all(0);
+            break;
+        case 'h':
+            showHist = !showHist;
+            if( !showHist )
+                destroyWindow( "Histogram" );
+            else
+                namedWindow( "Histogram", 1 );
+            break;
+        case 'p':
+            paused = !paused;
+            break;
+        default:
+            ;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/cloning_demo.cpp b/C++/opencv-4.7.0/samples/cpp/cloning_demo.cpp
new file mode 100644
index 00000000..43f6e202
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/cloning_demo.cpp
@@ -0,0 +1,251 @@
+/*
+* cloning_demo.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to use OpenCV seamless cloning
+* module without GUI.
+*
+* 1- Normal Cloning
+* 2- Mixed Cloning
+* 3- Monochrome Transfer
+* 4- Color Change
+* 5- Illumination change
+* 6- Texture Flattening
+
+* The program takes as input a source and a destination image (for 1-3 methods)
+* and outputs the cloned image.
+*
+* Download test images from opencv_extra repository.
+*/
+
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main()
+{
+    cout << endl;
+    cout << "Note: specify OPENCV_SAMPLES_DATA_PATH_HINT=<opencv_extra>/testdata/cv" << endl << endl;
+    cout << "Cloning Module" << endl;
+    cout << "---------------" << endl;
+    cout << "Options: " << endl;
+    cout << endl;
+    cout << "1) Normal Cloning " << endl;
+    cout << "2) Mixed Cloning " << endl;
+    cout << "3) Monochrome Transfer " << endl;
+    cout << "4) Local Color Change " << endl;
+    cout << "5) Local Illumination Change " << endl;
+    cout << "6) Texture Flattening " << endl;
+    cout << endl;
+    cout << "Press number 1-6 to choose from above techniques: ";
+    int num = 1;
+    cin >> num;
+    cout << endl;
+
+    if(num == 1)
+    {
+        string folder =  "cloning/Normal_Cloning/";
+        string original_path1 = samples::findFile(folder + "source1.png");
+        string original_path2 = samples::findFile(folder + "destination1.png");
+        string original_path3 = samples::findFile(folder + "mask.png");
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat destination = imread(original_path2, IMREAD_COLOR);
+        Mat mask = imread(original_path3, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(destination.empty())
+        {
+            cout << "Could not load destination image " << original_path2 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path3 << endl;
+            exit(0);
+        }
+
+        Mat result;
+        Point p;
+        p.x = 400;
+        p.y = 100;
+
+        seamlessClone(source, destination, mask, p, result, 1);
+
+        imshow("Output",result);
+        imwrite("cloned.png", result);
+    }
+    else if(num == 2)
+    {
+        string folder = "cloning/Mixed_Cloning/";
+        string original_path1 = samples::findFile(folder + "source1.png");
+        string original_path2 = samples::findFile(folder + "destination1.png");
+        string original_path3 = samples::findFile(folder + "mask.png");
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat destination = imread(original_path2, IMREAD_COLOR);
+        Mat mask = imread(original_path3, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(destination.empty())
+        {
+            cout << "Could not load destination image " << original_path2 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path3 << endl;
+            exit(0);
+        }
+
+        Mat result;
+        Point p;
+        p.x = destination.size().width/2;
+        p.y = destination.size().height/2;
+
+        seamlessClone(source, destination, mask, p, result, 2);
+
+        imshow("Output",result);
+        imwrite("cloned.png", result);
+    }
+    else if(num == 3)
+    {
+        string folder = "cloning/Monochrome_Transfer/";
+        string original_path1 = samples::findFile(folder + "source1.png");
+        string original_path2 = samples::findFile(folder + "destination1.png");
+        string original_path3 = samples::findFile(folder + "mask.png");
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat destination = imread(original_path2, IMREAD_COLOR);
+        Mat mask = imread(original_path3, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(destination.empty())
+        {
+            cout << "Could not load destination image " << original_path2 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path3 << endl;
+            exit(0);
+        }
+
+        Mat result;
+        Point p;
+        p.x = destination.size().width/2;
+        p.y = destination.size().height/2;
+
+        seamlessClone(source, destination, mask, p, result, 3);
+
+        imshow("Output",result);
+        imwrite("cloned.png", result);
+    }
+    else if(num == 4)
+    {
+        string folder = "cloning/color_change/";
+        string original_path1 = samples::findFile(folder + "source1.png");
+        string original_path2 = samples::findFile(folder + "mask.png");
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat mask = imread(original_path2, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path2 << endl;
+            exit(0);
+        }
+
+        Mat result;
+
+        colorChange(source, mask, result, 1.5, .5, .5);
+
+        imshow("Output",result);
+        imwrite("cloned.png", result);
+    }
+    else if(num == 5)
+    {
+        string folder = "cloning/Illumination_Change/";
+        string original_path1 = samples::findFile(folder + "source1.png");
+        string original_path2 = samples::findFile(folder + "mask.png");
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat mask = imread(original_path2, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path2 << endl;
+            exit(0);
+        }
+
+        Mat result;
+
+        illuminationChange(source, mask, result, 0.2f, 0.4f);
+
+        imshow("Output",result);
+        imwrite("cloned.png", result);
+    }
+    else if(num == 6)
+    {
+        string folder = "cloning/Texture_Flattening/";
+        string original_path1 = samples::findFile(folder + "source1.png");
+        string original_path2 = samples::findFile(folder + "mask.png");
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat mask = imread(original_path2, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path2 << endl;
+            exit(0);
+        }
+
+        Mat result;
+
+        textureFlattening(source, mask, result, 30, 45, 3);
+
+        imshow("Output",result);
+        imwrite("cloned.png", result);
+    }
+    else
+    {
+        cerr << "Invalid selection: " << num << endl;
+        exit(1);
+    }
+    waitKey(0);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/cloning_gui.cpp b/C++/opencv-4.7.0/samples/cpp/cloning_gui.cpp
new file mode 100644
index 00000000..c4e4de73
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/cloning_gui.cpp
@@ -0,0 +1,550 @@
+/*
+* cloning.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to use OpenCV seamless cloning
+* module.
+*
+* 1- Normal Cloning
+* 2- Mixed Cloning
+* 3- Monochrome Transfer
+* 4- Color Change
+* 5- Illumination change
+* 6- Texture Flattening
+
+* The program takes as input a source and a destination image (for 1-3 methods)
+* and outputs the cloned image.
+
+* Step 1:
+* -> In the source image, select the region of interest by left click mouse button. A Polygon ROI will be created by left clicking mouse button.
+* -> To set the Polygon ROI, click the right mouse button or 'd' key.
+* -> To reset the region selected, click the middle mouse button or 'r' key.
+
+* Step 2:
+* -> In the destination image, select the point where you want to place the ROI in the image by left clicking mouse button.
+* -> To get the cloned result, click the right mouse button or 'c' key.
+* -> To quit the program, use 'q' key.
+*
+* Result: The cloned image will be displayed.
+*/
+
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include <iostream>
+
+// we're NOT "using namespace std;" here, to avoid collisions between the beta variable and std::beta in c++17
+using std::cin;
+using std::cout;
+using std::endl;
+using std::string;
+
+using namespace cv;
+
+Mat img0, img1, img2, res, res1, final, final1, blend;
+
+Point point;
+int drag = 0;
+int destx, desty;
+
+int numpts = 100;
+Point* pts = new Point[100];
+Point* pts2 = new Point[100];
+Point* pts_diff = new Point[100];
+
+int var = 0;
+int flag = 0, flag1 = 0, flag4 = 0;
+
+int minx, miny, maxx, maxy, lenx, leny;
+int minxd, minyd, maxxd, maxyd, lenxd, lenyd;
+
+int channel, num, kernel_size;
+
+float alpha,beta;
+
+float red, green, blue;
+
+float low_t, high_t;
+
+void source(int, int, int, int, void*);
+void destination(int, int, int, int, void*);
+void checkfile(char*);
+
+void source(int event, int x, int y, int, void*)
+{
+
+    if (event == EVENT_LBUTTONDOWN && !drag)
+    {
+        if(flag1 == 0)
+        {
+            if(var==0)
+                img1 = img0.clone();
+            point = Point(x, y);
+            circle(img1,point,2,Scalar(0, 0, 255),-1, 8, 0);
+            pts[var] = point;
+            var++;
+            drag  = 1;
+            if(var>1)
+                line(img1,pts[var-2], point, Scalar(0, 0, 255), 2, 8, 0);
+
+            imshow("Source", img1);
+        }
+    }
+
+    if (event == EVENT_LBUTTONUP && drag)
+    {
+        imshow("Source", img1);
+
+        drag = 0;
+    }
+    if (event == EVENT_RBUTTONDOWN)
+    {
+        flag1 = 1;
+        img1 = img0.clone();
+        for(int i = var; i < numpts ; i++)
+            pts[i] = point;
+
+        if(var!=0)
+        {
+            const Point* pts3[1] = {&pts[0]};
+            polylines( img1, pts3, &numpts,1, 1, Scalar(0,0,0), 2, 8, 0);
+        }
+
+        for(int i=0;i<var;i++)
+        {
+            minx = min(minx,pts[i].x);
+            maxx = max(maxx,pts[i].x);
+            miny = min(miny,pts[i].y);
+            maxy = max(maxy,pts[i].y);
+        }
+        lenx = maxx - minx;
+        leny = maxy - miny;
+
+        int mid_pointx = minx + lenx/2;
+        int mid_pointy = miny + leny/2;
+
+        for(int i=0;i<var;i++)
+        {
+            pts_diff[i].x = pts[i].x - mid_pointx;
+            pts_diff[i].y = pts[i].y - mid_pointy;
+        }
+
+        imshow("Source", img1);
+    }
+
+    if (event == EVENT_RBUTTONUP)
+    {
+        flag = var;
+
+        final = Mat::zeros(img0.size(),CV_8UC3);
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        const Point* pts4[1] = {&pts[0]};
+
+        fillPoly(res1, pts4,&numpts, 1, Scalar(255, 255, 255), 8, 0);
+        bitwise_and(img0, img0, final,res1);
+
+        imshow("Source", img1);
+
+        if(num == 4)
+        {
+            colorChange(img0,res1,blend,red,green,blue);
+            imshow("Color Change Image", blend);
+            waitKey(0);
+
+        }
+        else if(num == 5)
+        {
+            illuminationChange(img0,res1,blend,alpha,beta);
+            imshow("Illum Change Image", blend);
+            waitKey(0);
+        }
+        else if(num == 6)
+        {
+            textureFlattening(img0,res1,blend,low_t,high_t,kernel_size);
+            imshow("Texture Flattened", blend);
+            waitKey(0);
+        }
+
+    }
+    if (event == EVENT_MBUTTONDOWN)
+    {
+        for(int i = 0; i < numpts ; i++)
+        {
+            pts[i].x=0;
+            pts[i].y=0;
+        }
+        var = 0;
+        flag1 = 0;
+        minx = INT_MAX; miny = INT_MAX; maxx = INT_MIN; maxy = INT_MIN;
+        imshow("Source", img0);
+        if(num == 1 || num == 2 || num == 3)
+            imshow("Destination",img2);
+        drag = 0;
+    }
+}
+
+void destination(int event, int x, int y, int, void*)
+{
+
+    Mat im1;
+    minxd = INT_MAX; minyd = INT_MAX; maxxd = INT_MIN; maxyd = INT_MIN;
+    im1 = img2.clone();
+    if (event == EVENT_LBUTTONDOWN)
+    {
+        flag4 = 1;
+        if(flag1 == 1)
+        {
+            point = Point(x, y);
+
+            for(int i=0;i<var;i++)
+            {
+                pts2[i].x = point.x + pts_diff[i].x;
+                pts2[i].y = point.y + pts_diff[i].y;
+            }
+
+            for(int i=var;i<numpts;i++)
+            {
+                pts2[i].x = point.x + pts_diff[0].x;
+                pts2[i].y = point.y + pts_diff[0].y;
+            }
+
+            const Point* pts5[1] = {&pts2[0]};
+            polylines( im1, pts5, &numpts,1, 1, Scalar(0,0,255), 2, 8, 0);
+
+            destx = x;
+            desty = y;
+
+            imshow("Destination", im1);
+        }
+    }
+    if (event == EVENT_RBUTTONUP)
+    {
+        for(int i=0;i<flag;i++)
+        {
+            minxd = min(minxd,pts2[i].x);
+            maxxd = max(maxxd,pts2[i].x);
+            minyd = min(minyd,pts2[i].y);
+            maxyd = max(maxyd,pts2[i].y);
+        }
+
+        if(maxxd > im1.size().width || maxyd > im1.size().height || minxd < 0 || minyd < 0)
+        {
+            cout << "Index out of range" << endl;
+            exit(1);
+        }
+
+        final1 = Mat::zeros(img2.size(),CV_8UC3);
+        res = Mat::zeros(img2.size(),CV_8UC1);
+        for(int i=miny, k=minyd;i<(miny+leny);i++,k++)
+            for(int j=minx,l=minxd ;j<(minx+lenx);j++,l++)
+            {
+                for(int c=0;c<channel;c++)
+                {
+                    final1.at<uchar>(k,l*channel+c) = final.at<uchar>(i,j*channel+c);
+
+                }
+            }
+
+        const Point* pts6[1] = {&pts2[0]};
+        fillPoly(res, pts6, &numpts, 1, Scalar(255, 255, 255), 8, 0);
+
+        if(num == 1 || num == 2 || num == 3)
+        {
+            seamlessClone(img0,img2,res1,point,blend,num);
+            imshow("Cloned Image", blend);
+            imwrite("cloned.png",blend);
+            waitKey(0);
+        }
+
+        for(int i = 0; i < flag ; i++)
+        {
+            pts2[i].x=0;
+            pts2[i].y=0;
+        }
+
+        minxd = INT_MAX; minyd = INT_MAX; maxxd = INT_MIN; maxyd = INT_MIN;
+    }
+
+    im1.release();
+}
+
+int main()
+{
+    cout << endl;
+    cout << "Cloning Module" << endl;
+    cout << "---------------" << endl;
+    cout << "Step 1:" << endl;
+    cout << " -> In the source image, select the region of interest by left click mouse button. A Polygon ROI will be created by left clicking mouse button." << endl;
+    cout << " -> To set the Polygon ROI, click the right mouse button or use 'd' key" << endl;
+    cout << " -> To reset the region selected, click the middle mouse button or use 'r' key." << endl;
+
+    cout << "Step 2:" << endl;
+    cout << " -> In the destination image, select the point where you want to place the ROI in the image by left clicking mouse button." << endl;
+    cout << " -> To get the cloned result, click the right mouse button or use 'c' key." << endl;
+    cout << " -> To quit the program, use 'q' key." << endl;
+    cout << endl;
+    cout << "Options: " << endl;
+    cout << endl;
+    cout << "1) Normal Cloning " << endl;
+    cout << "2) Mixed Cloning " << endl;
+    cout << "3) Monochrome Transfer " << endl;
+    cout << "4) Local Color Change " << endl;
+    cout << "5) Local Illumination Change " << endl;
+    cout << "6) Texture Flattening " << endl;
+
+    cout << endl;
+
+    cout << "Press number 1-6 to choose from above techniques: ";
+    cin >> num;
+    cout << endl;
+
+    minx = INT_MAX; miny = INT_MAX; maxx = INT_MIN; maxy = INT_MIN;
+
+    minxd = INT_MAX; minyd = INT_MAX; maxxd = INT_MIN; maxyd = INT_MIN;
+
+    int flag3 = 0;
+
+    if(num == 1 || num == 2 || num == 3)
+    {
+
+        string src,dest;
+        cout << "Enter Source Image: ";
+        cin >> src;
+
+        cout << "Enter Destination Image: ";
+        cin >> dest;
+
+        img0 = imread(samples::findFile(src));
+
+        img2 = imread(samples::findFile(dest));
+
+        if(img0.empty())
+        {
+            cout << "Source Image does not exist" << endl;
+            exit(2);
+        }
+        if(img2.empty())
+        {
+            cout << "Destination Image does not exist" << endl;
+            exit(2);
+        }
+
+        channel = img0.channels();
+
+        res = Mat::zeros(img2.size(),CV_8UC1);
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        final = Mat::zeros(img0.size(),CV_8UC3);
+        final1 = Mat::zeros(img2.size(),CV_8UC3);
+        //////////// source image ///////////////////
+
+        namedWindow("Source", 1);
+        setMouseCallback("Source", source, NULL);
+        imshow("Source", img0);
+
+        /////////// destination image ///////////////
+
+        namedWindow("Destination", 1);
+        setMouseCallback("Destination", destination, NULL);
+        imshow("Destination",img2);
+
+    }
+    else if(num == 4)
+    {
+        string src;
+        cout << "Enter Source Image: ";
+        cin >> src;
+
+        cout << "Enter RGB values: " << endl;
+        cout << "Red: ";
+        cin >> red;
+
+        cout << "Green: ";
+        cin >> green;
+
+        cout << "Blue: ";
+        cin >> blue;
+
+        img0 = imread(samples::findFile(src));
+
+        if(img0.empty())
+        {
+            cout << "Source Image does not exist" << endl;
+            exit(2);
+        }
+
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        final = Mat::zeros(img0.size(),CV_8UC3);
+
+        //////////// source image ///////////////////
+
+        namedWindow("Source", 1);
+        setMouseCallback("Source", source, NULL);
+        imshow("Source", img0);
+
+    }
+    else if(num == 5)
+    {
+        string src;
+        cout << "Enter Source Image: ";
+        cin >> src;
+
+        cout << "alpha: ";
+        cin >> alpha;
+
+        cout << "beta: ";
+        cin >> beta;
+
+        img0 = imread(samples::findFile(src));
+
+        if(img0.empty())
+        {
+            cout << "Source Image does not exist" << endl;
+            exit(2);
+        }
+
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        final = Mat::zeros(img0.size(),CV_8UC3);
+
+        //////////// source image ///////////////////
+
+        namedWindow("Source", 1);
+        setMouseCallback("Source", source, NULL);
+        imshow("Source", img0);
+
+    }
+    else if(num == 6)
+    {
+        string src;
+        cout << "Enter Source Image: ";
+        cin >> src;
+
+        cout << "low_threshold: ";
+        cin >> low_t;
+
+        cout << "high_threshold: ";
+        cin >> high_t;
+
+        cout << "kernel_size: ";
+        cin >> kernel_size;
+
+        img0 = imread(samples::findFile(src));
+
+        if(img0.empty())
+        {
+            cout << "Source Image does not exist" << endl;
+            exit(2);
+        }
+
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        final = Mat::zeros(img0.size(),CV_8UC3);
+
+        //////////// source image ///////////////////
+
+        namedWindow("Source", 1);
+        setMouseCallback("Source", source, NULL);
+        imshow("Source", img0);
+    }
+    else
+    {
+        cout << "Wrong Option Chosen" << endl;
+        exit(1);
+    }
+
+    for(;;)
+    {
+        char key = (char)waitKey(0);
+
+        if(key == 'd' && flag3 == 0)
+        {
+            flag1 = 1;
+            flag3 = 1;
+            img1 = img0.clone();
+            for(int i = var; i < numpts ; i++)
+                pts[i] = point;
+
+            if(var!=0)
+            {
+                const Point* pts3[1] = {&pts[0]};
+                polylines( img1, pts3, &numpts,1, 1, Scalar(0,0,0), 2, 8, 0);
+            }
+
+            for(int i=0;i<var;i++)
+            {
+                minx = min(minx,pts[i].x);
+                maxx = max(maxx,pts[i].x);
+                miny = min(miny,pts[i].y);
+                maxy = max(maxy,pts[i].y);
+            }
+            lenx = maxx - minx;
+            leny = maxy - miny;
+
+            int mid_pointx = minx + lenx/2;
+            int mid_pointy = miny + leny/2;
+
+            for(int i=0;i<var;i++)
+            {
+                pts_diff[i].x = pts[i].x - mid_pointx;
+                pts_diff[i].y = pts[i].y - mid_pointy;
+            }
+
+            flag = var;
+
+            final = Mat::zeros(img0.size(),CV_8UC3);
+            res1 = Mat::zeros(img0.size(),CV_8UC1);
+            const Point* pts4[1] = {&pts[0]};
+
+            fillPoly(res1, pts4,&numpts, 1, Scalar(255, 255, 255), 8, 0);
+            bitwise_and(img0, img0, final,res1);
+
+            imshow("Source", img1);
+        }
+        else if(key == 'r')
+        {
+            for(int i = 0; i < numpts ; i++)
+            {
+                pts[i].x=0;
+                pts[i].y=0;
+            }
+            var = 0;
+            flag1 = 0;
+            flag3 = 0;
+            flag4 = 0;
+            minx = INT_MAX; miny = INT_MAX; maxx = INT_MIN; maxy = INT_MIN;
+            imshow("Source", img0);
+            if(num == 1 || num == 2 || num == 3)
+                imshow("Destination",img2);
+            drag = 0;
+        }
+        else if ((num == 1 || num == 2 || num == 3) && key == 'c' && flag1 == 1 && flag4 == 1)
+        {
+            seamlessClone(img0,img2,res1,point,blend,num);
+            imshow("Cloned Image", blend);
+            imwrite("cloned.png",blend);
+        }
+        else if (num == 4 && key == 'c' && flag1 == 1)
+        {
+            colorChange(img0,res1,blend,red,green,blue);
+            imshow("Color Change Image", blend);
+            imwrite("cloned.png",blend);
+        }
+        else if (num == 5 && key == 'c' && flag1 == 1)
+        {
+            illuminationChange(img0,res1,blend,alpha,beta);
+            imshow("Illum Change Image", blend);
+            imwrite("cloned.png",blend);
+        }
+        else if (num == 6 && key == 'c' && flag1 == 1)
+        {
+            textureFlattening(img0,res1,blend,low_t,high_t,kernel_size);
+            imshow("Texture Flattened", blend);
+            imwrite("cloned.png",blend);
+        }
+        else if(key == 'q')
+            break;
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/connected_components.cpp b/C++/opencv-4.7.0/samples/cpp/connected_components.cpp
new file mode 100644
index 00000000..74afb29d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/connected_components.cpp
@@ -0,0 +1,61 @@
+
+#include <opencv2/core/utility.hpp>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+Mat img;
+int threshval = 100;
+
+static void on_trackbar(int, void*)
+{
+    Mat bw = threshval < 128 ? (img < threshval) : (img > threshval);
+    Mat labelImage(img.size(), CV_32S);
+    int nLabels = connectedComponents(bw, labelImage, 8);
+    std::vector<Vec3b> colors(nLabels);
+    colors[0] = Vec3b(0, 0, 0);//background
+    for(int label = 1; label < nLabels; ++label){
+        colors[label] = Vec3b( (rand()&255), (rand()&255), (rand()&255) );
+    }
+    Mat dst(img.size(), CV_8UC3);
+    for(int r = 0; r < dst.rows; ++r){
+        for(int c = 0; c < dst.cols; ++c){
+            int label = labelImage.at<int>(r, c);
+            Vec3b &pixel = dst.at<Vec3b>(r, c);
+            pixel = colors[label];
+         }
+     }
+
+    imshow( "Connected Components", dst );
+}
+
+int main( int argc, const char** argv )
+{
+    CommandLineParser parser(argc, argv, "{@image|stuff.jpg|image for converting to a grayscale}");
+    parser.about("\nThis program demonstrates connected components and use of the trackbar\n");
+    parser.printMessage();
+    cout << "\nThe image is converted to grayscale and displayed, another image has a trackbar\n"
+            "that controls thresholding and thereby the extracted contours which are drawn in color\n";
+
+    String inputImage = parser.get<string>(0);
+    img = imread(samples::findFile(inputImage), IMREAD_GRAYSCALE);
+
+    if(img.empty())
+    {
+        cout << "Could not read input image file: " << inputImage << endl;
+        return EXIT_FAILURE;
+    }
+
+    imshow( "Image", img );
+
+    namedWindow( "Connected Components", WINDOW_AUTOSIZE);
+    createTrackbar( "Threshold", "Connected Components", &threshval, 255, on_trackbar );
+    on_trackbar(threshval, 0);
+
+    waitKey(0);
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/contours2.cpp b/C++/opencv-4.7.0/samples/cpp/contours2.cpp
new file mode 100644
index 00000000..c3653fb5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/contours2.cpp
@@ -0,0 +1,96 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <math.h>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help(char** argv)
+{
+    cout
+        << "\nThis program illustrates the use of findContours and drawContours\n"
+        << "The original image is put up along with the image of drawn contours\n"
+        << "Usage:\n";
+    cout
+        << argv[0]
+        << "\nA trackbar is put up which controls the contour level from -3 to 3\n"
+        << endl;
+}
+
+const int w = 500;
+int levels = 3;
+
+vector<vector<Point> > contours;
+vector<Vec4i> hierarchy;
+
+static void on_trackbar(int, void*)
+{
+    Mat cnt_img = Mat::zeros(w, w, CV_8UC3);
+    int _levels = levels - 3;
+    drawContours( cnt_img, contours, _levels <= 0 ? 3 : -1, Scalar(128,255,255),
+                  3, LINE_AA, hierarchy, std::abs(_levels) );
+
+    imshow("contours", cnt_img);
+}
+
+int main( int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv, "{help h||}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    Mat img = Mat::zeros(w, w, CV_8UC1);
+    //Draw 6 faces
+    for( int i = 0; i < 6; i++ )
+    {
+        int dx = (i%2)*250 - 30;
+        int dy = (i/2)*150;
+        const Scalar white = Scalar(255);
+        const Scalar black = Scalar(0);
+
+        if( i == 0 )
+        {
+            for( int j = 0; j <= 10; j++ )
+            {
+                double angle = (j+5)*CV_PI/21;
+                line(img, Point(cvRound(dx+100+j*10-80*cos(angle)),
+                    cvRound(dy+100-90*sin(angle))),
+                    Point(cvRound(dx+100+j*10-30*cos(angle)),
+                    cvRound(dy+100-30*sin(angle))), white, 1, 8, 0);
+            }
+        }
+
+        ellipse( img, Point(dx+150, dy+100), Size(100,70), 0, 0, 360, white, -1, 8, 0 );
+        ellipse( img, Point(dx+115, dy+70), Size(30,20), 0, 0, 360, black, -1, 8, 0 );
+        ellipse( img, Point(dx+185, dy+70), Size(30,20), 0, 0, 360, black, -1, 8, 0 );
+        ellipse( img, Point(dx+115, dy+70), Size(15,15), 0, 0, 360, white, -1, 8, 0 );
+        ellipse( img, Point(dx+185, dy+70), Size(15,15), 0, 0, 360, white, -1, 8, 0 );
+        ellipse( img, Point(dx+115, dy+70), Size(5,5), 0, 0, 360, black, -1, 8, 0 );
+        ellipse( img, Point(dx+185, dy+70), Size(5,5), 0, 0, 360, black, -1, 8, 0 );
+        ellipse( img, Point(dx+150, dy+100), Size(10,5), 0, 0, 360, black, -1, 8, 0 );
+        ellipse( img, Point(dx+150, dy+150), Size(40,10), 0, 0, 360, black, -1, 8, 0 );
+        ellipse( img, Point(dx+27, dy+100), Size(20,35), 0, 0, 360, white, -1, 8, 0 );
+        ellipse( img, Point(dx+273, dy+100), Size(20,35), 0, 0, 360, white, -1, 8, 0 );
+    }
+    //show the faces
+    namedWindow( "image", 1 );
+    imshow( "image", img );
+    //Extract the contours so that
+    vector<vector<Point> > contours0;
+    findContours( img, contours0, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE);
+
+    contours.resize(contours0.size());
+    for( size_t k = 0; k < contours0.size(); k++ )
+        approxPolyDP(Mat(contours0[k]), contours[k], 3, true);
+
+    namedWindow( "contours", 1 );
+    createTrackbar( "levels+3", "contours", &levels, 7, on_trackbar );
+
+    on_trackbar(0,0);
+    waitKey();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/convexhull.cpp b/C++/opencv-4.7.0/samples/cpp/convexhull.cpp
new file mode 100644
index 00000000..d839b806
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/convexhull.cpp
@@ -0,0 +1,57 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help(char** argv)
+{
+    cout << "\nThis sample program demonstrates the use of the convexHull() function\n"
+         << "Call:\n"
+         << argv[0] << endl;
+}
+
+int main( int argc, char** argv )
+{
+    CommandLineParser parser(argc, argv, "{help h||}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    Mat img(500, 500, CV_8UC3);
+    RNG& rng = theRNG();
+
+    for(;;)
+    {
+        int i, count = (unsigned)rng%100 + 1;
+
+        vector<Point> points;
+
+        for( i = 0; i < count; i++ )
+        {
+            Point pt;
+            pt.x = rng.uniform(img.cols/4, img.cols*3/4);
+            pt.y = rng.uniform(img.rows/4, img.rows*3/4);
+
+            points.push_back(pt);
+        }
+
+        vector<Point> hull;
+        convexHull(points, hull, true);
+
+        img = Scalar::all(0);
+        for( i = 0; i < count; i++ )
+            circle(img, points[i], 3, Scalar(0, 0, 255), FILLED, LINE_AA);
+
+        polylines(img, hull, true, Scalar(0, 255, 0), 1, LINE_AA);
+        imshow("hull", img);
+
+        char key = (char)waitKey();
+        if( key == 27 || key == 'q' || key == 'Q' ) // 'ESC'
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/cout_mat.cpp b/C++/opencv-4.7.0/samples/cpp/cout_mat.cpp
new file mode 100644
index 00000000..0d282415
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/cout_mat.cpp
@@ -0,0 +1,69 @@
+/*
+ *
+ * cvout_sample just demonstrates the serial out capabilities of cv::Mat
+ *  That is, cv::Mat M(...); cout << M;  Now works.
+ *
+ */
+
+#include "opencv2/core.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static void help(char** argv)
+{
+    cout
+    << "\n------------------------------------------------------------------\n"
+    << " This program shows the serial out capabilities of cv::Mat\n"
+    << "That is, cv::Mat M(...); cout << M;  Now works.\n"
+    << "Output can be formatted to OpenCV, matlab, python, numpy, csv and \n"
+    << "C styles Usage:\n"
+    << argv[0]
+    << "\n------------------------------------------------------------------\n\n"
+    << endl;
+}
+
+
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv, "{help h||}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    Mat I = Mat::eye(4, 4, CV_64F);
+    I.at<double>(1,1) = CV_PI;
+    cout << "I = \n" << I << ";" << endl << endl;
+
+    Mat r = Mat(10, 3, CV_8UC3);
+    randu(r, Scalar::all(0), Scalar::all(255));
+
+    cout << "r (default) = \n" << r << ";" << endl << endl;
+    cout << "r (matlab) = \n" << format(r, Formatter::FMT_MATLAB) << ";" << endl << endl;
+    cout << "r (python) = \n" << format(r, Formatter::FMT_PYTHON) << ";" << endl << endl;
+    cout << "r (numpy) = \n" << format(r, Formatter::FMT_NUMPY) << ";" << endl << endl;
+    cout << "r (csv) = \n" << format(r, Formatter::FMT_CSV) << ";" << endl << endl;
+    cout << "r (c) = \n" << format(r, Formatter::FMT_C) << ";" << endl << endl;
+
+    Point2f p(5, 1);
+    cout << "p = " << p << ";" << endl;
+
+    Point3f p3f(2, 6, 7);
+    cout << "p3f = " << p3f << ";" << endl;
+
+    vector<float> v;
+    v.push_back(1);
+    v.push_back(2);
+    v.push_back(3);
+
+    cout << "shortvec = " << Mat(v) << endl;
+
+    vector<Point2f> points(20);
+    for (size_t i = 0; i < points.size(); ++i)
+        points[i] = Point2f((float)(i * 5), (float)(i % 7));
+
+    cout << "points = " << points << ";" << endl;
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/create_mask.cpp b/C++/opencv-4.7.0/samples/cpp/create_mask.cpp
new file mode 100644
index 00000000..67b0ec9b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/create_mask.cpp
@@ -0,0 +1,118 @@
+/*
+* create_mask.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to make mask image (black and white).
+* The program takes as input a source image and outputs its corresponding
+* mask image.
+*/
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+Mat src, img1, mask, final;
+
+Point point;
+vector<Point> pts;
+int drag = 0;
+int var = 0;
+int flag = 0;
+
+void mouseHandler(int, int, int, int, void*);
+
+void mouseHandler(int event, int x, int y, int, void*)
+{
+
+    if (event == EVENT_LBUTTONDOWN && !drag)
+    {
+        if (flag == 0)
+        {
+            if (var == 0)
+                img1 = src.clone();
+            point = Point(x, y);
+            circle(img1, point, 2, Scalar(0, 0, 255), -1, 8, 0);
+            pts.push_back(point);
+            var++;
+            drag  = 1;
+
+            if (var > 1)
+                line(img1,pts[var-2], point, Scalar(0, 0, 255), 2, 8, 0);
+
+            imshow("Source", img1);
+        }
+    }
+
+    if (event == EVENT_LBUTTONUP && drag)
+    {
+        imshow("Source", img1);
+        drag = 0;
+    }
+
+    if (event == EVENT_RBUTTONDOWN)
+    {
+        flag = 1;
+        img1 = src.clone();
+
+        if (var != 0)
+        {
+            polylines( img1, pts, 1, Scalar(0,0,0), 2, 8, 0);
+        }
+
+        imshow("Source", img1);
+    }
+
+    if (event == EVENT_RBUTTONUP)
+    {
+        flag = var;
+        final = Mat::zeros(src.size(), CV_8UC3);
+        mask = Mat::zeros(src.size(), CV_8UC1);
+
+        fillPoly(mask, pts, Scalar(255, 255, 255), 8, 0);
+        bitwise_and(src, src, final, mask);
+        imshow("Mask", mask);
+        imshow("Result", final);
+        imshow("Source", img1);
+    }
+
+    if (event == EVENT_MBUTTONDOWN)
+    {
+        pts.clear();
+        var = 0;
+        drag = 0;
+        flag = 0;
+        imshow("Source", src);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    CommandLineParser parser(argc, argv, "{@input | lena.jpg | input image}");
+    parser.about("This program demonstrates using mouse events\n");
+    parser.printMessage();
+    cout << "\n\tleft mouse button - set a point to create mask shape\n"
+        "\tright mouse button - create mask from points\n"
+        "\tmiddle mouse button - reset\n";
+    String input_image = parser.get<String>("@input");
+
+    src = imread(samples::findFile(input_image));
+
+    if (src.empty())
+    {
+        printf("Error opening image: %s\n", input_image.c_str());
+        return 0;
+    }
+
+    namedWindow("Source", WINDOW_AUTOSIZE);
+    setMouseCallback("Source", mouseHandler, NULL);
+    imshow("Source", src);
+    waitKey(0);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/dbt_face_detection.cpp b/C++/opencv-4.7.0/samples/cpp/dbt_face_detection.cpp
new file mode 100644
index 00000000..d5707d4b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/dbt_face_detection.cpp
@@ -0,0 +1,111 @@
+#if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(ANDROID) || (defined(_MSC_VER) && _MSC_VER>=1800)
+
+#include <opencv2/imgproc.hpp>  // Gaussian Blur
+#include <opencv2/core.hpp>        // Basic OpenCV structures (cv::Mat, Scalar)
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>  // OpenCV window I/O
+#include <opencv2/features2d.hpp>
+#include <opencv2/objdetect.hpp>
+
+#include <stdio.h>
+
+using namespace std;
+using namespace cv;
+
+const string WindowName = "Face Detection example";
+
+class CascadeDetectorAdapter: public DetectionBasedTracker::IDetector
+{
+    public:
+        CascadeDetectorAdapter(cv::Ptr<cv::CascadeClassifier> detector):
+            IDetector(),
+            Detector(detector)
+        {
+            CV_Assert(detector);
+        }
+
+        void detect(const cv::Mat &Image, std::vector<cv::Rect> &objects) CV_OVERRIDE
+        {
+            Detector->detectMultiScale(Image, objects, scaleFactor, minNeighbours, 0, minObjSize, maxObjSize);
+        }
+
+        virtual ~CascadeDetectorAdapter() CV_OVERRIDE
+        {}
+
+    private:
+        CascadeDetectorAdapter();
+        cv::Ptr<cv::CascadeClassifier> Detector;
+ };
+
+int main(int , char** )
+{
+    namedWindow(WindowName);
+
+    VideoCapture VideoStream(0);
+
+    if (!VideoStream.isOpened())
+    {
+        printf("Error: Cannot open video stream from camera\n");
+        return 1;
+    }
+
+    std::string cascadeFrontalfilename = samples::findFile("data/lbpcascades/lbpcascade_frontalface.xml");
+    cv::Ptr<cv::CascadeClassifier> cascade = makePtr<cv::CascadeClassifier>(cascadeFrontalfilename);
+    cv::Ptr<DetectionBasedTracker::IDetector> MainDetector = makePtr<CascadeDetectorAdapter>(cascade);
+    if ( cascade->empty() )
+    {
+      printf("Error: Cannot load %s\n", cascadeFrontalfilename.c_str());
+      return 2;
+    }
+
+    cascade = makePtr<cv::CascadeClassifier>(cascadeFrontalfilename);
+    cv::Ptr<DetectionBasedTracker::IDetector> TrackingDetector = makePtr<CascadeDetectorAdapter>(cascade);
+    if ( cascade->empty() )
+    {
+      printf("Error: Cannot load %s\n", cascadeFrontalfilename.c_str());
+      return 2;
+    }
+
+    DetectionBasedTracker::Parameters params;
+    DetectionBasedTracker Detector(MainDetector, TrackingDetector, params);
+
+    if (!Detector.run())
+    {
+        printf("Error: Detector initialization failed\n");
+        return 2;
+    }
+
+    Mat ReferenceFrame;
+    Mat GrayFrame;
+    vector<Rect> Faces;
+
+    do
+    {
+        VideoStream >> ReferenceFrame;
+        cvtColor(ReferenceFrame, GrayFrame, COLOR_BGR2GRAY);
+        Detector.process(GrayFrame);
+        Detector.getObjects(Faces);
+
+        for (size_t i = 0; i < Faces.size(); i++)
+        {
+            rectangle(ReferenceFrame, Faces[i], Scalar(0,255,0));
+        }
+
+        imshow(WindowName, ReferenceFrame);
+    } while (waitKey(30) < 0);
+
+    Detector.stop();
+
+    return 0;
+}
+
+#else
+
+#include <stdio.h>
+int main()
+{
+    printf("This sample works for UNIX or ANDROID or Visual Studio 2013+ only\n");
+    return 0;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/cpp/delaunay2.cpp b/C++/opencv-4.7.0/samples/cpp/delaunay2.cpp
new file mode 100644
index 00000000..428804e3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/delaunay2.cpp
@@ -0,0 +1,153 @@
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help(char** argv)
+{
+    cout << "\nThis program demonstrates iterative construction of\n"
+            "delaunay triangulation and voronoi tessellation.\n"
+            "It draws a random set of points in an image and then delaunay triangulates them.\n"
+            "Usage: \n";
+    cout << argv[0];
+    cout << "\n\nThis program builds the triangulation interactively, you may stop this process by\n"
+            "hitting any key.\n";
+}
+
+static void draw_subdiv_point( Mat& img, Point2f fp, Scalar color )
+{
+    circle( img, fp, 3, color, FILLED, LINE_8, 0 );
+}
+
+static void draw_subdiv( Mat& img, Subdiv2D& subdiv, Scalar delaunay_color )
+{
+#if 1
+    vector<Vec6f> triangleList;
+    subdiv.getTriangleList(triangleList);
+    vector<Point> pt(3);
+
+    for( size_t i = 0; i < triangleList.size(); i++ )
+    {
+        Vec6f t = triangleList[i];
+        pt[0] = Point(cvRound(t[0]), cvRound(t[1]));
+        pt[1] = Point(cvRound(t[2]), cvRound(t[3]));
+        pt[2] = Point(cvRound(t[4]), cvRound(t[5]));
+        line(img, pt[0], pt[1], delaunay_color, 1, LINE_AA, 0);
+        line(img, pt[1], pt[2], delaunay_color, 1, LINE_AA, 0);
+        line(img, pt[2], pt[0], delaunay_color, 1, LINE_AA, 0);
+    }
+#else
+    vector<Vec4f> edgeList;
+    subdiv.getEdgeList(edgeList);
+    for( size_t i = 0; i < edgeList.size(); i++ )
+    {
+        Vec4f e = edgeList[i];
+        Point pt0 = Point(cvRound(e[0]), cvRound(e[1]));
+        Point pt1 = Point(cvRound(e[2]), cvRound(e[3]));
+        line(img, pt0, pt1, delaunay_color, 1, LINE_AA, 0);
+    }
+#endif
+}
+
+static void locate_point( Mat& img, Subdiv2D& subdiv, Point2f fp, Scalar active_color )
+{
+    int e0=0, vertex=0;
+
+    subdiv.locate(fp, e0, vertex);
+
+    if( e0 > 0 )
+    {
+        int e = e0;
+        do
+        {
+            Point2f org, dst;
+            if( subdiv.edgeOrg(e, &org) > 0 && subdiv.edgeDst(e, &dst) > 0 )
+                line( img, org, dst, active_color, 3, LINE_AA, 0 );
+
+            e = subdiv.getEdge(e, Subdiv2D::NEXT_AROUND_LEFT);
+        }
+        while( e != e0 );
+    }
+
+    draw_subdiv_point( img, fp, active_color );
+}
+
+
+static void paint_voronoi( Mat& img, Subdiv2D& subdiv )
+{
+    vector<vector<Point2f> > facets;
+    vector<Point2f> centers;
+    subdiv.getVoronoiFacetList(vector<int>(), facets, centers);
+
+    vector<Point> ifacet;
+    vector<vector<Point> > ifacets(1);
+
+    for( size_t i = 0; i < facets.size(); i++ )
+    {
+        ifacet.resize(facets[i].size());
+        for( size_t j = 0; j < facets[i].size(); j++ )
+            ifacet[j] = facets[i][j];
+
+        Scalar color;
+        color[0] = rand() & 255;
+        color[1] = rand() & 255;
+        color[2] = rand() & 255;
+        fillConvexPoly(img, ifacet, color, 8, 0);
+
+        ifacets[0] = ifacet;
+        polylines(img, ifacets, true, Scalar(), 1, LINE_AA, 0);
+        circle(img, centers[i], 3, Scalar(), FILLED, LINE_AA, 0);
+    }
+}
+
+
+int main( int argc, char** argv )
+{
+    cv::CommandLineParser parser(argc, argv, "{help h||}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+
+    Scalar active_facet_color(0, 0, 255), delaunay_color(255,255,255);
+    Rect rect(0, 0, 600, 600);
+
+    Subdiv2D subdiv(rect);
+    Mat img(rect.size(), CV_8UC3);
+
+    img = Scalar::all(0);
+    string win = "Delaunay Demo";
+    imshow(win, img);
+
+    for( int i = 0; i < 200; i++ )
+    {
+        Point2f fp( (float)(rand()%(rect.width-10)+5),
+                    (float)(rand()%(rect.height-10)+5));
+
+        locate_point( img, subdiv, fp, active_facet_color );
+        imshow( win, img );
+
+        if( waitKey( 100 ) >= 0 )
+            break;
+
+        subdiv.insert(fp);
+
+        img = Scalar::all(0);
+        draw_subdiv( img, subdiv, delaunay_color );
+        imshow( win, img );
+
+        if( waitKey( 100 ) >= 0 )
+            break;
+    }
+
+    img = Scalar::all(0);
+    paint_voronoi( img, subdiv );
+    imshow( win, img );
+
+    waitKey(0);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/demhist.cpp b/C++/opencv-4.7.0/samples/cpp/demhist.cpp
new file mode 100644
index 00000000..4a564af4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/demhist.cpp
@@ -0,0 +1,94 @@
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+int _brightness = 100;
+int _contrast = 100;
+
+Mat image;
+
+/* brightness/contrast callback function */
+static void updateBrightnessContrast( int /*arg*/, void* )
+{
+    int histSize = 64;
+    int brightness = _brightness - 100;
+    int contrast = _contrast - 100;
+
+    /*
+     * The algorithm is by Werner D. Streidt
+     * (http://visca.com/ffactory/archives/5-99/msg00021.html)
+     */
+    double a, b;
+    if( contrast > 0 )
+    {
+        double delta = 127.*contrast/100;
+        a = 255./(255. - delta*2);
+        b = a*(brightness - delta);
+    }
+    else
+    {
+        double delta = -128.*contrast/100;
+        a = (256.-delta*2)/255.;
+        b = a*brightness + delta;
+    }
+
+    Mat dst, hist;
+    image.convertTo(dst, CV_8U, a, b);
+    imshow("image", dst);
+
+    calcHist(&dst, 1, 0, Mat(), hist, 1, &histSize, 0);
+    Mat histImage = Mat::ones(200, 320, CV_8U)*255;
+
+    normalize(hist, hist, 0, histImage.rows, NORM_MINMAX, CV_32F);
+
+    histImage = Scalar::all(255);
+    int binW = cvRound((double)histImage.cols/histSize);
+
+    for( int i = 0; i < histSize; i++ )
+        rectangle( histImage, Point(i*binW, histImage.rows),
+                   Point((i+1)*binW, histImage.rows - cvRound(hist.at<float>(i))),
+                   Scalar::all(0), -1, 8, 0 );
+    imshow("histogram", histImage);
+}
+
+const char* keys =
+{
+    "{help h||}{@image|baboon.jpg|input image file}"
+};
+
+int main( int argc, const char** argv )
+{
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("\nThis program demonstrates the use of calcHist() -- histogram creation.\n");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    string inputImage = parser.get<string>(0);
+
+    // Load the source image. HighGUI use.
+    image = imread(samples::findFile(inputImage), IMREAD_GRAYSCALE);
+    if(image.empty())
+    {
+        std::cerr << "Cannot read image file: " << inputImage << std::endl;
+        return -1;
+    }
+
+    namedWindow("image", 0);
+    namedWindow("histogram", 0);
+
+    createTrackbar("brightness", "image", &_brightness, 200, updateBrightnessContrast);
+    createTrackbar("contrast", "image", &_contrast, 200, updateBrightnessContrast);
+
+    updateBrightnessContrast(0, 0);
+    waitKey();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/detect_blob.cpp b/C++/opencv-4.7.0/samples/cpp/detect_blob.cpp
new file mode 100644
index 00000000..2c871db4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/detect_blob.cpp
@@ -0,0 +1,205 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/features2d.hpp>
+#include <vector>
+#include <map>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+
+static void help(char** argv)
+{
+    cout << "\n This program demonstrates how to use BLOB to detect and filter region \n"
+         << "Usage: \n"
+         << argv[0]
+         << " <image1(detect_blob.png as default)>\n"
+         << "Press a key when image window is active to change descriptor";
+}
+
+
+static String Legende(SimpleBlobDetector::Params &pAct)
+{
+    String s = "";
+    if (pAct.filterByArea)
+    {
+        String inf = static_cast<const ostringstream&>(ostringstream() << pAct.minArea).str();
+        String sup = static_cast<const ostringstream&>(ostringstream() << pAct.maxArea).str();
+        s = " Area range [" + inf + " to  " + sup + "]";
+    }
+    if (pAct.filterByCircularity)
+    {
+        String inf = static_cast<const ostringstream&>(ostringstream() << pAct.minCircularity).str();
+        String sup = static_cast<const ostringstream&>(ostringstream() << pAct.maxCircularity).str();
+        if (s.length() == 0)
+            s = " Circularity range [" + inf + " to  " + sup + "]";
+        else
+            s += " AND Circularity range [" + inf + " to  " + sup + "]";
+    }
+    if (pAct.filterByColor)
+    {
+        String inf = static_cast<const ostringstream&>(ostringstream() << (int)pAct.blobColor).str();
+        if (s.length() == 0)
+            s = " Blob color " + inf;
+        else
+            s += " AND Blob color " + inf;
+    }
+    if (pAct.filterByConvexity)
+    {
+        String inf = static_cast<const ostringstream&>(ostringstream() << pAct.minConvexity).str();
+        String sup = static_cast<const ostringstream&>(ostringstream() << pAct.maxConvexity).str();
+        if (s.length() == 0)
+            s = " Convexity range[" + inf + " to  " + sup + "]";
+        else
+            s += " AND  Convexity range[" + inf + " to  " + sup + "]";
+    }
+    if (pAct.filterByInertia)
+    {
+        String inf = static_cast<const ostringstream&>(ostringstream() << pAct.minInertiaRatio).str();
+        String sup = static_cast<const ostringstream&>(ostringstream() << pAct.maxInertiaRatio).str();
+        if (s.length() == 0)
+            s = " Inertia ratio range [" + inf + " to  " + sup + "]";
+        else
+            s += " AND  Inertia ratio range [" + inf + " to  " + sup + "]";
+    }
+    return s;
+}
+
+
+
+int main(int argc, char *argv[])
+{
+    String fileName;
+    cv::CommandLineParser parser(argc, argv, "{@input |detect_blob.png| }{h help | | }");
+    if (parser.has("h"))
+    {
+        help(argv);
+        return 0;
+    }
+    fileName = parser.get<string>("@input");
+    Mat img = imread(samples::findFile(fileName), IMREAD_COLOR);
+    if (img.empty())
+    {
+        cout << "Image " << fileName << " is empty or cannot be found\n";
+        return 1;
+    }
+
+    SimpleBlobDetector::Params pDefaultBLOB;
+    // This is default parameters for SimpleBlobDetector
+    pDefaultBLOB.thresholdStep = 10;
+    pDefaultBLOB.minThreshold = 10;
+    pDefaultBLOB.maxThreshold = 220;
+    pDefaultBLOB.minRepeatability = 2;
+    pDefaultBLOB.minDistBetweenBlobs = 10;
+    pDefaultBLOB.filterByColor = false;
+    pDefaultBLOB.blobColor = 0;
+    pDefaultBLOB.filterByArea = false;
+    pDefaultBLOB.minArea = 25;
+    pDefaultBLOB.maxArea = 5000;
+    pDefaultBLOB.filterByCircularity = false;
+    pDefaultBLOB.minCircularity = 0.9f;
+    pDefaultBLOB.maxCircularity = (float)1e37;
+    pDefaultBLOB.filterByInertia = false;
+    pDefaultBLOB.minInertiaRatio = 0.1f;
+    pDefaultBLOB.maxInertiaRatio = (float)1e37;
+    pDefaultBLOB.filterByConvexity = false;
+    pDefaultBLOB.minConvexity = 0.95f;
+    pDefaultBLOB.maxConvexity = (float)1e37;
+    // Descriptor array for BLOB
+    vector<String> typeDesc;
+    // Param array for BLOB
+    vector<SimpleBlobDetector::Params> pBLOB;
+    vector<SimpleBlobDetector::Params>::iterator itBLOB;
+    // Color palette
+    vector< Vec3b >  palette;
+    for (int i = 0; i<65536; i++)
+    {
+        uchar c1 = (uchar)rand();
+        uchar c2 = (uchar)rand();
+        uchar c3 = (uchar)rand();
+        palette.push_back(Vec3b(c1, c2, c3));
+    }
+    help(argv);
+
+
+    // These descriptors are going to be detecting and computing BLOBS with 6 different params
+    // Param for first BLOB detector we want all
+    typeDesc.push_back("BLOB");    // see http://docs.opencv.org/4.x/d0/d7a/classcv_1_1SimpleBlobDetector.html
+    pBLOB.push_back(pDefaultBLOB);
+    pBLOB.back().filterByArea = true;
+    pBLOB.back().minArea = 1;
+    pBLOB.back().maxArea = float(img.rows*img.cols);
+    // Param for second BLOB detector we want area between 500 and 2900 pixels
+    typeDesc.push_back("BLOB");
+    pBLOB.push_back(pDefaultBLOB);
+    pBLOB.back().filterByArea = true;
+    pBLOB.back().minArea = 500;
+    pBLOB.back().maxArea = 2900;
+    // Param for third BLOB detector we want only circular object
+    typeDesc.push_back("BLOB");
+    pBLOB.push_back(pDefaultBLOB);
+    pBLOB.back().filterByCircularity = true;
+    // Param for Fourth BLOB detector we want ratio inertia
+    typeDesc.push_back("BLOB");
+    pBLOB.push_back(pDefaultBLOB);
+    pBLOB.back().filterByInertia = true;
+    pBLOB.back().minInertiaRatio = 0;
+    pBLOB.back().maxInertiaRatio = (float)0.2;
+    // Param for fifth BLOB detector we want ratio inertia
+    typeDesc.push_back("BLOB");
+    pBLOB.push_back(pDefaultBLOB);
+    pBLOB.back().filterByConvexity = true;
+    pBLOB.back().minConvexity = 0.;
+    pBLOB.back().maxConvexity = (float)0.9;
+    // Param for six BLOB detector we want blob with gravity center color equal to 0
+    typeDesc.push_back("BLOB");
+    pBLOB.push_back(pDefaultBLOB);
+    pBLOB.back().filterByColor = true;
+    pBLOB.back().blobColor = 0;
+
+    itBLOB = pBLOB.begin();
+    vector<double> desMethCmp;
+    Ptr<Feature2D> b;
+    String label;
+    // Descriptor loop
+    vector<String>::iterator itDesc;
+    for (itDesc = typeDesc.begin(); itDesc != typeDesc.end(); ++itDesc)
+    {
+        vector<KeyPoint> keyImg1;
+        if (*itDesc == "BLOB")
+        {
+            b = SimpleBlobDetector::create(*itBLOB);
+            label = Legende(*itBLOB);
+            ++itBLOB;
+        }
+        try
+        {
+            // We can detect keypoint with detect method
+            vector<KeyPoint>  keyImg;
+            vector<Rect>  zone;
+            vector<vector <Point> >  region;
+            Mat     desc, result(img.rows, img.cols, CV_8UC3);
+            if (b.dynamicCast<SimpleBlobDetector>().get())
+            {
+                Ptr<SimpleBlobDetector> sbd = b.dynamicCast<SimpleBlobDetector>();
+                sbd->detect(img, keyImg, Mat());
+                drawKeypoints(img, keyImg, result);
+                int i = 0;
+                for (vector<KeyPoint>::iterator k = keyImg.begin(); k != keyImg.end(); ++k, ++i)
+                    circle(result, k->pt, (int)k->size, palette[i % 65536]);
+            }
+            namedWindow(*itDesc + label, WINDOW_AUTOSIZE);
+            imshow(*itDesc + label, result);
+            imshow("Original", img);
+            waitKey();
+        }
+        catch (const Exception& e)
+        {
+            cout << "Feature : " << *itDesc << "\n";
+            cout << e.msg << endl;
+        }
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/detect_mser.cpp b/C++/opencv-4.7.0/samples/cpp/detect_mser.cpp
new file mode 100644
index 00000000..d289e229
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/detect_mser.cpp
@@ -0,0 +1,537 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/features2d.hpp>
+#include "opencv2/core/opengl.hpp"
+
+#include <vector>
+#include <map>
+#include <iostream>
+#include <iomanip>
+#include <limits>
+#include <stdint.h>
+#ifdef HAVE_OPENGL
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN 1
+#define NOMINMAX 1
+#include <windows.h>
+#endif
+#if defined(_WIN64)
+#include <windows.h>
+#endif
+
+#if defined(__APPLE__)
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#else
+#include <GL/gl.h>
+#include <GL/glu.h>
+#endif
+#endif
+
+
+using namespace std;
+using namespace cv;
+
+
+static void help(char** argv)
+{
+    cout << "\nThis program demonstrates how to use MSER to detect extremal regions\n"
+            "Usage:\n"
+         << argv[0] << " <image1(without parameter a synthetic image is used as default)>\n"
+            "Press esc key when image window is active to change descriptor parameter\n"
+            "Press 2, 8, 4, 6, +, -, or 5 keys in openGL windows to change view or use mouse\n";
+}
+
+struct MSERParams
+{
+    MSERParams(int _delta = 5, int _min_area = 60, int _max_area = 14400,
+               double _max_variation = 0.25, double _min_diversity = .2,
+               int _max_evolution = 200, double _area_threshold = 1.01,
+               double _min_margin = 0.003, int _edge_blur_size = 5)
+    {
+        delta = _delta;
+        minArea = _min_area;
+        maxArea = _max_area;
+        maxVariation = _max_variation;
+        minDiversity = _min_diversity;
+        maxEvolution = _max_evolution;
+        areaThreshold = _area_threshold;
+        minMargin = _min_margin;
+        edgeBlurSize = _edge_blur_size;
+        pass2Only = false;
+    }
+
+    int delta;
+    int minArea;
+    int maxArea;
+    double maxVariation;
+    double minDiversity;
+    bool pass2Only;
+
+    int maxEvolution;
+    double areaThreshold;
+    double minMargin;
+    int edgeBlurSize;
+};
+
+static String Legende(const MSERParams &pAct)
+{
+    ostringstream ss;
+    ss << "Area[" << pAct.minArea << "," << pAct.maxArea << "] ";
+    ss << "del. [" << pAct.delta << "] ";
+    ss << "var. [" << pAct.maxVariation << "] ";
+    ss << "div. [" << (int)pAct.minDiversity << "] ";
+    ss << "pas. [" << (int)pAct.pass2Only << "] ";
+    ss << "RGb->evo. [" << pAct.maxEvolution << "] ";
+    ss << "are. [" << (int)pAct.areaThreshold << "] ";
+    ss << "mar. [" << (int)pAct.minMargin << "] ";
+    ss << "siz. [" << pAct.edgeBlurSize << "]";
+
+    return ss.str();
+}
+
+
+#ifdef HAVE_OPENGL
+const int win_width = 800;
+const int win_height = 640;
+#endif
+bool    rotateEnable=true;
+bool    keyPressed=false;
+
+Vec4f   rotAxis(1,0,1,0);
+Vec3f  zoom(1,0,0);
+
+float obsX = 0.f;
+float obsY = 0.f;
+float obsZ = -10.f;
+float tx = 0.f;
+float ty = 0.f;
+
+float thetaObs = -1.570f;
+float phiObs = 1.570f;
+float rObs = 10.f;
+
+int prevX = -1;
+int prevY = -1;
+int prevTheta = -1000;
+int prevPhi = -1000;
+
+#ifdef HAVE_OPENGL
+struct DrawData
+{
+    ogl::Arrays arr;
+    ogl::Texture2D tex;
+    ogl::Buffer indices;
+};
+
+
+static void draw(void* userdata)
+{
+    DrawData* data = static_cast<DrawData*>(userdata);
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    gluLookAt(obsX, obsY, obsZ, 0, 0, .0, .0, 10.0, 0.0);
+    glTranslatef(tx,ty,0);
+    keyPressed = false;
+    ogl::render(data->arr, data->indices, ogl::TRIANGLES);
+}
+
+static void onMouse(int event, int x, int y, int flags, void*)
+{
+    if (event == EVENT_RBUTTONDOWN)
+    {
+        prevX = x;
+        prevY = y;
+    }
+    if (event == EVENT_RBUTTONUP)
+    {
+        prevX = -1;
+        prevY = -1;
+    }
+    if (prevX != -1)
+    {
+        tx += float((x - prevX) / 100.0);
+        ty -= float((y - prevY) / 100.0);
+        prevX = x;
+        prevY = y;
+    }
+    if (event == EVENT_LBUTTONDOWN)
+    {
+        prevTheta = x;
+        prevPhi = y;
+    }
+    if (event == EVENT_LBUTTONUP)
+    {
+        prevTheta = -1000;
+        prevPhi = -1000;
+    }
+    if (prevTheta != -1000)
+    {
+        if (x - prevTheta<0)
+        {
+            thetaObs += 0.02f;
+        }
+        else if (x - prevTheta>0)
+        {
+            thetaObs -= 0.02f;
+        }
+        if (y - prevPhi<0)
+        {
+            phiObs -= 0.02f;
+        }
+        else if (y - prevPhi>0)
+        {
+            phiObs += 0.02f;
+        }
+        prevTheta = x;
+        prevPhi = y;
+    }
+    if (event==EVENT_MOUSEWHEEL)
+    {
+        if (getMouseWheelDelta(flags)>0)
+            rObs += 0.1f;
+        else
+            rObs -= 0.1f;
+    }
+    float pi = static_cast<float>(CV_PI);
+    if (thetaObs>pi)
+    {
+        thetaObs = -2 * pi + thetaObs;
+    }
+    if (thetaObs<-pi)
+    {
+        thetaObs = 2 * pi + thetaObs;
+    }
+    if (phiObs>pi / 2)
+    {
+        phiObs = pi / 2 - 0.0001f;
+    }
+    if (phiObs<-pi / 2)
+    {
+        phiObs = -pi / 2 + 0.00001f;
+    }
+    if (rObs<0)
+    {
+        rObs = 0;
+    }
+
+}
+#endif
+
+#ifdef HAVE_OPENGL
+static void DrawOpenGLMSER(Mat img, Mat result)
+{
+    Mat imgGray;
+    if (img.type() != CV_8UC1)
+        cvtColor(img, imgGray, COLOR_BGR2GRAY);
+    else
+        imgGray = img;
+
+    namedWindow("OpenGL", WINDOW_OPENGL);
+    setMouseCallback("OpenGL", onMouse, NULL);
+
+    Mat_<Vec3f> vertex(1, img.cols*img.rows);
+    Mat_<Vec2f> texCoords(1, img.cols*img.rows);
+    for (int i = 0, nbPix = 0; i<img.rows; i++)
+    {
+        for (int j = 0; j<img.cols; j++, nbPix++)
+        {
+            float x = (j) / (float)img.cols;
+            float y = (i) / (float)img.rows;
+            vertex.at< Vec3f >(0, nbPix) = Vec3f(float(2 * (x - 0.5)), float(2 * (0.5 - y)), float(imgGray.at<uchar>(i, j) / 512.0));
+            texCoords.at< Vec2f>(0, nbPix) = Vec2f(x, y);
+        }
+    }
+
+    Mat_<int> indices(1, (img.rows - 1)*(6 * img.cols));
+    for (int i = 1, nbPix = 0; i<img.rows; i++)
+    {
+        for (int j = 1; j<img.cols; j++)
+        {
+            int c = i*img.cols + j;
+            indices.at<int>(0, nbPix++) = c;
+            indices.at<int>(0, nbPix++) = c - 1;
+            indices.at<int>(0, nbPix++) = c - img.cols - 1;
+            indices.at<int>(0, nbPix++) = c - img.cols - 1;
+            indices.at<int>(0, nbPix++) = c - img.cols;
+            indices.at<int>(0, nbPix++) = c;
+        }
+    }
+
+    DrawData *data = new DrawData;
+
+    data->arr.setVertexArray(vertex);
+    data->arr.setTexCoordArray(texCoords);
+    data->indices.copyFrom(indices);
+    data->tex.copyFrom(result);
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluPerspective(45.0, (double)win_width / win_height, 0.0, 1000.0);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    glEnable(GL_TEXTURE_2D);
+    data->tex.bind();
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+    glDisable(GL_CULL_FACE);
+    setOpenGlDrawCallback("OpenGL", draw, data);
+
+    for (;;)
+    {
+        updateWindow("OpenGL");
+        char key = (char)waitKey(40);
+        if (key == 27)
+            break;
+        if (key == 0x20)
+            rotateEnable = !rotateEnable;
+        float pi = static_cast<float>(CV_PI);
+
+        switch (key) {
+            case '5':
+                obsX = 0, obsY = 0, obsZ = -10;
+                thetaObs = -pi/2, phiObs = pi/2, rObs = 10;
+                tx=0; ty=0;
+                break;
+            case '4':
+                thetaObs += 0.1f;
+                break;
+            case '6':
+                thetaObs -= 0.1f;
+                break;
+            case '2':
+                phiObs -= 0.1f;
+                break;
+            case '8':
+                phiObs += 0.1f;
+                break;
+            case '+':
+                rObs -= 0.1f;
+                break;
+            case '-':
+                rObs += 0.1f;
+                break;
+        }
+
+        if (thetaObs>pi)
+        {
+            thetaObs = -2 * pi + thetaObs;
+        }
+        if (thetaObs<-pi)
+            thetaObs = 2 * pi + thetaObs;
+        if (phiObs>pi / 2)
+            phiObs = pi / 2 - 0.0001f;
+        if (phiObs<-pi / 2)
+            phiObs = -pi / 2 + 0.00001f;
+        if (rObs<0)
+            rObs = 0;
+        obsX = rObs*cos(thetaObs)*cos(phiObs);
+        obsY = rObs*sin(thetaObs)*cos(phiObs);
+        obsZ = rObs*sin(phiObs);
+    }
+    setOpenGlDrawCallback("OpenGL", 0, 0);
+    destroyAllWindows();
+}
+#endif
+
+// Add nested rectangles of different widths and colors to an image
+static void addNestedRectangles(Mat &img, Point p0, int* width, int *color, int n) {
+    for (int i = 0; i<n; i++)
+    {
+        rectangle(img, Rect(p0, Size(width[i], width[i])), Scalar(color[i]), 1);
+        p0 += Point((width[i] - width[i + 1]) / 2, (width[i] - width[i + 1]) / 2);
+        floodFill(img, p0, Scalar(color[i]));
+    }
+}
+
+// Add nested circles of different widths and colors to an image
+static void addNestedCircles(Mat &img, Point p0, int *width, int *color, int n) {
+    for (int i = 0; i<n; i++)
+    {
+        circle(img, p0, width[i] / 2, Scalar(color[i]), 1);
+        floodFill(img, p0, Scalar(color[i]));
+    }
+}
+
+static Mat MakeSyntheticImage()
+{
+    const int fond = 0;
+
+    Mat img(800, 800, CV_8UC1);
+    img = Scalar(fond);
+
+    int width[] = { 390, 380, 300, 290, 280, 270, 260, 250, 210, 190, 150, 100, 80, 70 };
+
+    int color1[] = { 80, 180, 160, 140, 120, 100, 90, 110, 170, 150, 140, 100, 220 };
+    int color2[] = { 81, 181, 161, 141, 121, 101, 91, 111, 171, 151, 141, 101, 221 };
+    int color3[] = { 175, 75, 95, 115, 135, 155, 165, 145, 85, 105, 115, 155, 35 };
+    int color4[] = { 173, 73, 93, 113, 133, 153, 163, 143, 83, 103, 113, 153, 33 };
+
+    addNestedRectangles(img, Point(10, 10), width, color1, 13);
+    addNestedCircles(img, Point(200, 600), width, color2, 13);
+
+    addNestedRectangles(img, Point(410, 10), width, color3, 13);
+    addNestedCircles(img, Point(600, 600), width, color4, 13);
+
+    int histSize = 256;
+    float range[] = { 0, 256 };
+    const float* histRange[] = { range };
+    Mat hist;
+
+    // we compute the histogram
+    calcHist(&img, 1, 0, Mat(), hist, 1, &histSize, histRange, true, false);
+
+    cout << "****************Maximal region************************\n";
+    for (int i = 0; i < hist.rows; i++)
+    {
+        if (hist.at<float>(i, 0)!=0)
+        {
+            cout << "h" << setw(3) << left << i << "\t=\t" << hist.at<float>(i, 0) << "\n";
+        }
+    }
+
+    return img;
+}
+
+int main(int argc, char *argv[])
+{
+    Mat imgOrig, img;
+    Size blurSize(5, 5);
+    cv::CommandLineParser parser(argc, argv, "{ help h | | }{ @input | | }");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+
+    string input = parser.get<string>("@input");
+    if (!input.empty())
+    {
+        imgOrig = imread(samples::findFile(input), IMREAD_GRAYSCALE);
+        blur(imgOrig, img, blurSize);
+    }
+    else
+    {
+        imgOrig = MakeSyntheticImage();
+        img = imgOrig;
+    }
+
+    // Descriptor array MSER
+    vector<String> typeDesc;
+    // Param array for MSER
+    vector<MSERParams> pMSER;
+
+    // Color palette
+    vector<Vec3b> palette;
+    for (int i = 0; i<=numeric_limits<uint16_t>::max(); i++)
+        palette.push_back(Vec3b((uchar)rand(), (uchar)rand(), (uchar)rand()));
+
+    help(argv);
+
+    MSERParams params;
+
+    params.delta = 10;
+    params.minArea = 100;
+    params.maxArea = 5000;
+    params.maxVariation = 2;
+    params.minDiversity = 0;
+    params.pass2Only = true;
+
+    typeDesc.push_back("MSER");
+    pMSER.push_back(params);
+
+    params.pass2Only = false;
+    typeDesc.push_back("MSER");
+    pMSER.push_back(params);
+
+    params.delta = 100;
+    typeDesc.push_back("MSER");
+    pMSER.push_back(params);
+
+    vector<MSERParams>::iterator itMSER = pMSER.begin();
+    Ptr<Feature2D> b;
+    String label;
+    // Descriptor loop
+    vector<String>::iterator itDesc;
+    Mat result(img.rows, img.cols, CV_8UC3);
+    for (itDesc = typeDesc.begin(); itDesc != typeDesc.end(); ++itDesc)
+    {
+        vector<KeyPoint> keyImg1;
+        if (*itDesc == "MSER")
+        {
+            if (img.type() == CV_8UC3)
+            {
+                b = MSER::create(itMSER->delta, itMSER->minArea, itMSER->maxArea, itMSER->maxVariation, itMSER->minDiversity, itMSER->maxEvolution,
+                                 itMSER->areaThreshold, itMSER->minMargin, itMSER->edgeBlurSize);
+                label = Legende(*itMSER);
+                ++itMSER;
+            }
+            else
+            {
+                b = MSER::create(itMSER->delta, itMSER->minArea, itMSER->maxArea, itMSER->maxVariation, itMSER->minDiversity);
+                b.dynamicCast<MSER>()->setPass2Only(itMSER->pass2Only);
+                label = Legende(*itMSER);
+                ++itMSER;
+            }
+        }
+
+        if (img.type()==CV_8UC3)
+        {
+            img.copyTo(result);
+        }
+        else
+        {
+            vector<Mat> plan;
+            plan.push_back(img);
+            plan.push_back(img);
+            plan.push_back(img);
+            merge(plan,result);
+        }
+        try
+        {
+            // We can detect regions using detectRegions method
+            vector<KeyPoint> keyImg;
+            vector<Rect> zone;
+            vector<vector <Point> > region;
+            Mat desc;
+
+            if (b.dynamicCast<MSER>().get())
+            {
+                Ptr<MSER> sbd = b.dynamicCast<MSER>();
+                sbd->detectRegions(img, region, zone);
+                //result = Scalar(0, 0, 0);
+                int nbPixelInMSER=0;
+                for (vector<vector <Point> >::iterator itr = region.begin(); itr != region.end(); ++itr)
+                {
+                    for (vector <Point>::iterator itp = itr->begin(); itp != itr->end(); ++itp)
+                    {
+                        // all pixels belonging to region become blue
+                        result.at<Vec3b>(itp->y, itp->x) = Vec3b(128, 0, 0);
+                        nbPixelInMSER++;
+                    }
+                }
+                cout << "Number of MSER region: " << region.size() << "; Number of pixels in all MSER region: " << nbPixelInMSER << "\n";
+            }
+
+            const string winName = *itDesc + label;
+            namedWindow(winName, WINDOW_AUTOSIZE);
+            imshow(winName, result);
+            imshow("Original", img);
+        }
+        catch (const Exception& e)
+        {
+            cout << "Feature: " << *itDesc << "\n";
+            cout << e.msg << endl;
+        }
+#ifdef HAVE_OPENGL
+        DrawOpenGLMSER(img, result);
+#endif
+        waitKey();
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/dft.cpp b/C++/opencv-4.7.0/samples/cpp/dft.cpp
new file mode 100644
index 00000000..f57ae3f8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/dft.cpp
@@ -0,0 +1,86 @@
+#include "opencv2/core.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <stdio.h>
+
+using namespace cv;
+using namespace std;
+
+static void help(const char ** argv)
+{
+    printf("\nThis program demonstrated the use of the discrete Fourier transform (dft)\n"
+           "The dft of an image is taken and it's power spectrum is displayed.\n"
+           "Usage:\n %s [image_name -- default lena.jpg]\n",argv[0]);
+}
+
+const char* keys =
+{
+    "{help h||}{@image|lena.jpg|input image file}"
+};
+
+int main(int argc, const char ** argv)
+{
+    help(argv);
+    CommandLineParser parser(argc, argv, keys);
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    string filename = parser.get<string>(0);
+    Mat img = imread(samples::findFile(filename), IMREAD_GRAYSCALE);
+    if( img.empty() )
+    {
+        help(argv);
+        printf("Cannot read image file: %s\n", filename.c_str());
+        return -1;
+    }
+    int M = getOptimalDFTSize( img.rows );
+    int N = getOptimalDFTSize( img.cols );
+    Mat padded;
+    copyMakeBorder(img, padded, 0, M - img.rows, 0, N - img.cols, BORDER_CONSTANT, Scalar::all(0));
+
+    Mat planes[] = {Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F)};
+    Mat complexImg;
+    merge(planes, 2, complexImg);
+
+    dft(complexImg, complexImg);
+
+    // compute log(1 + sqrt(Re(DFT(img))**2 + Im(DFT(img))**2))
+    split(complexImg, planes);
+    magnitude(planes[0], planes[1], planes[0]);
+    Mat mag = planes[0];
+    mag += Scalar::all(1);
+    log(mag, mag);
+
+    // crop the spectrum, if it has an odd number of rows or columns
+    mag = mag(Rect(0, 0, mag.cols & -2, mag.rows & -2));
+
+    int cx = mag.cols/2;
+    int cy = mag.rows/2;
+
+    // rearrange the quadrants of Fourier image
+    // so that the origin is at the image center
+    Mat tmp;
+    Mat q0(mag, Rect(0, 0, cx, cy));
+    Mat q1(mag, Rect(cx, 0, cx, cy));
+    Mat q2(mag, Rect(0, cy, cx, cy));
+    Mat q3(mag, Rect(cx, cy, cx, cy));
+
+    q0.copyTo(tmp);
+    q3.copyTo(q0);
+    tmp.copyTo(q3);
+
+    q1.copyTo(tmp);
+    q2.copyTo(q1);
+    tmp.copyTo(q2);
+
+    normalize(mag, mag, 0, 1, NORM_MINMAX);
+
+    imshow("spectrum magnitude", mag);
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/digits_lenet.cpp b/C++/opencv-4.7.0/samples/cpp/digits_lenet.cpp
new file mode 100644
index 00000000..df8935de
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/digits_lenet.cpp
@@ -0,0 +1,182 @@
+//  This example provides a digital recognition based on LeNet-5 and connected component analysis.
+//  It makes it possible for OpenCV beginner to run dnn models in real time using only CPU.
+//  It can read pictures from the camera in real time to make predictions, and display the recognized digits as overlays on top of the original digits.
+//
+//  In order to achieve a better display effect, please write the number on white paper and occupy the entire camera.
+//
+//  You can follow the following guide to train LeNet-5 by yourself using the MNIST dataset.
+//  https://github.com/intel/caffe/blob/a3d5b022fe026e9092fc7abc7654b1162ab9940d/examples/mnist/readme.md
+//
+//  You can also download already trained model directly.
+//  https://github.com/zihaomu/opencv_digit_text_recognition_demo/tree/master/src
+
+
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/dnn.hpp>
+
+#include <iostream>
+#include <vector>
+
+using namespace cv;
+using namespace cv::dnn;
+
+const char *keys =
+    "{ help     h  | | Print help message. }"
+    "{ input    i  | | Path to input image or video file. Skip this argument to capture frames from a camera.}"
+    "{ device      |  0  | camera device number. }"
+    "{ modelBin    |     | Path to a binary .caffemodel file contains trained network.}"
+    "{ modelTxt    |     | Path to a .prototxt file contains the model definition of trained network.}"
+    "{ width       | 640 | Set the width of the camera }"
+    "{ height      | 480 | Set the height of the camera }"
+    "{ thr         | 0.7 | Confidence threshold. }";
+
+// Find best class for the blob (i.e. class with maximal probability)
+static void getMaxClass(const Mat &probBlob, int &classId, double &classProb);
+
+void predictor(Net net, const Mat &roi, int &class_id, double &probability);
+
+int main(int argc, char **argv)
+{
+    // Parse command line arguments.
+    CommandLineParser parser(argc, argv, keys);
+
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    int vWidth = parser.get<int>("width");
+    int vHeight = parser.get<int>("height");
+    float confThreshold = parser.get<float>("thr");
+    std::string modelTxt = parser.get<String>("modelTxt");
+    std::string modelBin = parser.get<String>("modelBin");
+
+    Net net;
+    try
+    {
+        net = readNet(modelTxt, modelBin);
+    }
+    catch (cv::Exception &ee)
+    {
+        std::cerr << "Exception: " << ee.what() << std::endl;
+        std::cout << "Can't load the network by using the flowing files:" << std::endl;
+        std::cout << "modelTxt: " << modelTxt << std::endl;
+        std::cout << "modelBin: " << modelBin << std::endl;
+        return 1;
+    }
+
+    const std::string resultWinName = "Please write the number on white paper and occupy the entire camera.";
+    const std::string preWinName = "Preprocessing";
+
+    namedWindow(preWinName, WINDOW_AUTOSIZE);
+    namedWindow(resultWinName, WINDOW_AUTOSIZE);
+
+    Mat labels, stats, centroids;
+    Point position;
+
+    Rect getRectangle;
+    bool ifDrawingBox = false;
+
+    int classId = 0;
+    double probability = 0;
+
+    Rect basicRect = Rect(0, 0, vWidth, vHeight);
+    Mat rawImage;
+
+    double fps = 0;
+
+    // Open a video file or an image file or a camera stream.
+    VideoCapture cap;
+    if (parser.has("input"))
+        cap.open(parser.get<String>("input"));
+    else
+        cap.open(parser.get<int>("device"));
+
+    TickMeter tm;
+
+    while (waitKey(1) < 0)
+    {
+        cap >> rawImage;
+        if (rawImage.empty())
+        {
+            waitKey();
+            break;
+        }
+
+        tm.reset();
+        tm.start();
+
+        Mat image = rawImage.clone();
+        // Image preprocessing
+        cvtColor(image, image, COLOR_BGR2GRAY);
+        GaussianBlur(image, image, Size(3, 3), 2, 2);
+        adaptiveThreshold(image, image, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 25, 10);
+        bitwise_not(image, image);
+
+        Mat element = getStructuringElement(MORPH_RECT, Size(3, 3), Point(-1,-1));
+        dilate(image, image, element, Point(-1,-1), 1);
+        // Find connected component
+        int nccomps = cv::connectedComponentsWithStats(image, labels, stats, centroids);
+
+        for (int i = 1; i < nccomps; i++)
+        {
+            ifDrawingBox = false;
+
+            // Extend the bounding box of connected component for easier recognition
+            if (stats.at<int>(i - 1, CC_STAT_AREA) > 80 && stats.at<int>(i - 1, CC_STAT_AREA) < 3000)
+            {
+                ifDrawingBox = true;
+                int left = stats.at<int>(i - 1, CC_STAT_HEIGHT) / 4;
+                getRectangle = Rect(stats.at<int>(i - 1, CC_STAT_LEFT) - left, stats.at<int>(i - 1, CC_STAT_TOP) - left, stats.at<int>(i - 1, CC_STAT_WIDTH) + 2 * left, stats.at<int>(i - 1, CC_STAT_HEIGHT) + 2 * left);
+                getRectangle &= basicRect;
+            }
+
+            if (ifDrawingBox && !getRectangle.empty())
+            {
+                Mat roi = image(getRectangle);
+                predictor(net, roi, classId, probability);
+
+                if (probability < confThreshold)
+                    continue;
+
+                rectangle(rawImage, getRectangle, Scalar(128, 255, 128), 2);
+
+                position = Point(getRectangle.br().x - 7, getRectangle.br().y + 25);
+                putText(rawImage, std::to_string(classId), position, 3, 1.0, Scalar(128, 128, 255), 2);
+            }
+        }
+
+        tm.stop();
+        fps = 1 / tm.getTimeSec();
+        std::string fpsString = format("Inference FPS: %.2f.", fps);
+        putText(rawImage, fpsString, Point(5, 20), FONT_HERSHEY_SIMPLEX, 0.6, Scalar(128, 255, 128));
+
+        imshow(resultWinName, rawImage);
+        imshow(preWinName, image);
+
+    }
+
+    return 0;
+}
+
+static void getMaxClass(const Mat &probBlob, int &classId, double &classProb)
+{
+    Mat probMat = probBlob.reshape(1, 1);
+    Point classNumber;
+    minMaxLoc(probMat, NULL, &classProb, NULL, &classNumber);
+    classId = classNumber.x;
+}
+
+void predictor(Net net, const Mat &roi, int &classId, double &probability)
+{
+    Mat pred;
+    // Convert Mat to batch of images
+    Mat inputBlob = dnn::blobFromImage(roi, 1.0, Size(28, 28));
+    // Set the network input
+    net.setInput(inputBlob);
+    // Compute output
+    pred = net.forward();
+    getMaxClass(pred, classId, probability);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/digits_svm.cpp b/C++/opencv-4.7.0/samples/cpp/digits_svm.cpp
new file mode 100644
index 00000000..c55b320d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/digits_svm.cpp
@@ -0,0 +1,375 @@
+#include "opencv2/core.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/ml.hpp"
+
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+using namespace cv;
+using namespace std;
+
+const int SZ = 20;  // size of each digit is SZ x SZ
+const int CLASS_N = 10;
+const char* DIGITS_FN = "digits.png";
+
+static void help(char** argv)
+{
+    cout <<
+    "\n"
+    "SVM and KNearest digit recognition.\n"
+    "\n"
+    "Sample loads a dataset of handwritten digits from 'digits.png'.\n"
+    "Then it trains a SVM and KNearest classifiers on it and evaluates\n"
+    "their accuracy.\n"
+    "\n"
+    "Following preprocessing is applied to the dataset:\n"
+    " - Moment-based image deskew (see deskew())\n"
+    " - Digit images are split into 4 10x10 cells and 16-bin\n"
+    "   histogram of oriented gradients is computed for each\n"
+    "   cell\n"
+    " - Transform histograms to space with Hellinger metric (see [1] (RootSIFT))\n"
+    "\n"
+    "\n"
+    "[1] R. Arandjelovic, A. Zisserman\n"
+    "    \"Three things everyone should know to improve object retrieval\"\n"
+    "    http://www.robots.ox.ac.uk/~vgg/publications/2012/Arandjelovic12/arandjelovic12.pdf\n"
+    "\n"
+    "Usage:\n"
+    << argv[0] << endl;
+}
+
+static void split2d(const Mat& image, const Size cell_size, vector<Mat>& cells)
+{
+    int height = image.rows;
+    int width = image.cols;
+
+    int sx = cell_size.width;
+    int sy = cell_size.height;
+
+    cells.clear();
+
+    for (int i = 0; i < height; i += sy)
+    {
+        for (int j = 0; j < width; j += sx)
+        {
+            cells.push_back(image(Rect(j, i, sx, sy)));
+        }
+    }
+}
+
+static void load_digits(const char* fn, vector<Mat>& digits, vector<int>& labels)
+{
+    digits.clear();
+    labels.clear();
+
+    String filename = samples::findFile(fn);
+
+    cout << "Loading " << filename << " ..." << endl;
+
+    Mat digits_img = imread(filename, IMREAD_GRAYSCALE);
+    split2d(digits_img, Size(SZ, SZ), digits);
+
+    for (int i = 0; i < CLASS_N; i++)
+    {
+        for (size_t j = 0; j < digits.size() / CLASS_N; j++)
+        {
+            labels.push_back(i);
+        }
+    }
+}
+
+static void deskew(const Mat& img, Mat& deskewed_img)
+{
+    Moments m = moments(img);
+
+    if (abs(m.mu02) < 0.01)
+    {
+        deskewed_img = img.clone();
+        return;
+    }
+
+    float skew = (float)(m.mu11 / m.mu02);
+    float M_vals[2][3] = {{1, skew, -0.5f * SZ * skew}, {0, 1, 0}};
+    Mat M(Size(3, 2), CV_32F);
+
+    for (int i = 0; i < M.rows; i++)
+    {
+        for (int j = 0; j < M.cols; j++)
+        {
+            M.at<float>(i, j) = M_vals[i][j];
+        }
+    }
+
+    warpAffine(img, deskewed_img, M, Size(SZ, SZ), WARP_INVERSE_MAP | INTER_LINEAR);
+}
+
+static void mosaic(const int width, const vector<Mat>& images, Mat& grid)
+{
+    int mat_width = SZ * width;
+    int mat_height = SZ * (int)ceil((double)images.size() / width);
+
+    if (!images.empty())
+    {
+        grid = Mat(Size(mat_width, mat_height), images[0].type());
+
+        for (size_t i = 0; i < images.size(); i++)
+        {
+            Mat location_on_grid = grid(Rect(SZ * ((int)i % width), SZ * ((int)i / width), SZ, SZ));
+            images[i].copyTo(location_on_grid);
+        }
+    }
+}
+
+static void evaluate_model(const vector<float>& predictions, const vector<Mat>& digits, const vector<int>& labels, Mat& mos)
+{
+    double err = 0;
+
+    for (size_t i = 0; i < predictions.size(); i++)
+    {
+        if ((int)predictions[i] != labels[i])
+        {
+            err++;
+        }
+    }
+
+    err /= predictions.size();
+
+    cout << cv::format("error: %.2f %%", err * 100) << endl;
+
+    int confusion[10][10] = {};
+
+    for (size_t i = 0; i < labels.size(); i++)
+    {
+        confusion[labels[i]][(int)predictions[i]]++;
+    }
+
+    cout << "confusion matrix:" << endl;
+    for (int i = 0; i < 10; i++)
+    {
+        for (int j = 0; j < 10; j++)
+        {
+            cout << cv::format("%2d ", confusion[i][j]);
+        }
+        cout << endl;
+    }
+
+    cout << endl;
+
+    vector<Mat> vis;
+
+    for (size_t i = 0; i < digits.size(); i++)
+    {
+        Mat img;
+        cvtColor(digits[i], img, COLOR_GRAY2BGR);
+
+        if ((int)predictions[i] != labels[i])
+        {
+            for (int j = 0; j < img.rows; j++)
+            {
+                for (int k = 0; k < img.cols; k++)
+                {
+                    img.at<Vec3b>(j, k)[0] = 0;
+                    img.at<Vec3b>(j, k)[1] = 0;
+                }
+            }
+        }
+
+        vis.push_back(img);
+    }
+
+    mosaic(25, vis, mos);
+}
+
+static void bincount(const Mat& x, const Mat& weights, const int min_length, vector<double>& bins)
+{
+    double max_x_val = 0;
+    minMaxLoc(x, NULL, &max_x_val);
+
+    bins = vector<double>(max((int)max_x_val, min_length));
+
+    for (int i = 0; i < x.rows; i++)
+    {
+        for (int j = 0; j < x.cols; j++)
+        {
+            bins[x.at<int>(i, j)] += weights.at<float>(i, j);
+        }
+    }
+}
+
+static void preprocess_hog(const vector<Mat>& digits, Mat& hog)
+{
+    int bin_n = 16;
+    int half_cell = SZ / 2;
+    double eps = 1e-7;
+
+    hog = Mat(Size(4 * bin_n, (int)digits.size()), CV_32F);
+
+    for (size_t img_index = 0; img_index < digits.size(); img_index++)
+    {
+        Mat gx;
+        Sobel(digits[img_index], gx, CV_32F, 1, 0);
+
+        Mat gy;
+        Sobel(digits[img_index], gy, CV_32F, 0, 1);
+
+        Mat mag;
+        Mat ang;
+        cartToPolar(gx, gy, mag, ang);
+
+        Mat bin(ang.size(), CV_32S);
+
+        for (int i = 0; i < ang.rows; i++)
+        {
+            for (int j = 0; j < ang.cols; j++)
+            {
+                bin.at<int>(i, j) = (int)(bin_n * ang.at<float>(i, j) / (2 * CV_PI));
+            }
+        }
+
+        Mat bin_cells[] = {
+            bin(Rect(0, 0, half_cell, half_cell)),
+            bin(Rect(half_cell, 0, half_cell, half_cell)),
+            bin(Rect(0, half_cell, half_cell, half_cell)),
+            bin(Rect(half_cell, half_cell, half_cell, half_cell))
+        };
+        Mat mag_cells[] = {
+            mag(Rect(0, 0, half_cell, half_cell)),
+            mag(Rect(half_cell, 0, half_cell, half_cell)),
+            mag(Rect(0, half_cell, half_cell, half_cell)),
+            mag(Rect(half_cell, half_cell, half_cell, half_cell))
+        };
+
+        vector<double> hist;
+        hist.reserve(4 * bin_n);
+
+        for (int i = 0; i < 4; i++)
+        {
+            vector<double> partial_hist;
+            bincount(bin_cells[i], mag_cells[i], bin_n, partial_hist);
+            hist.insert(hist.end(), partial_hist.begin(), partial_hist.end());
+        }
+
+        // transform to Hellinger kernel
+        double sum = 0;
+
+        for (size_t i = 0; i < hist.size(); i++)
+        {
+            sum += hist[i];
+        }
+
+        for (size_t i = 0; i < hist.size(); i++)
+        {
+            hist[i] /= sum + eps;
+            hist[i] = sqrt(hist[i]);
+        }
+
+        double hist_norm = norm(hist);
+
+        for (size_t i = 0; i < hist.size(); i++)
+        {
+            hog.at<float>((int)img_index, (int)i) = (float)(hist[i] / (hist_norm + eps));
+        }
+    }
+}
+
+static void shuffle(vector<Mat>& digits, vector<int>& labels)
+{
+    vector<int> shuffled_indexes(digits.size());
+
+    for (size_t i = 0; i < digits.size(); i++)
+    {
+        shuffled_indexes[i] = (int)i;
+    }
+
+    randShuffle(shuffled_indexes);
+
+    vector<Mat> shuffled_digits(digits.size());
+    vector<int> shuffled_labels(labels.size());
+
+    for (size_t i = 0; i < shuffled_indexes.size(); i++)
+    {
+        shuffled_digits[shuffled_indexes[i]] = digits[i];
+        shuffled_labels[shuffled_indexes[i]] = labels[i];
+    }
+
+    digits = shuffled_digits;
+    labels = shuffled_labels;
+}
+
+int main(int /* argc */, char* argv[])
+{
+    help(argv);
+
+    vector<Mat> digits;
+    vector<int> labels;
+
+    load_digits(DIGITS_FN, digits, labels);
+
+    cout << "preprocessing..." << endl;
+
+    // shuffle digits
+    shuffle(digits, labels);
+
+    vector<Mat> digits2;
+
+    for (size_t i = 0; i < digits.size(); i++)
+    {
+        Mat deskewed_digit;
+        deskew(digits[i], deskewed_digit);
+        digits2.push_back(deskewed_digit);
+    }
+
+    Mat samples;
+
+    preprocess_hog(digits2, samples);
+
+    int train_n = (int)(0.9 * samples.rows);
+    Mat test_set;
+
+    vector<Mat> digits_test(digits2.begin() + train_n, digits2.end());
+    mosaic(25, digits_test, test_set);
+    imshow("test set", test_set);
+
+    Mat samples_train = samples(Rect(0, 0, samples.cols, train_n));
+    Mat samples_test = samples(Rect(0, train_n, samples.cols, samples.rows - train_n));
+    vector<int> labels_train(labels.begin(), labels.begin() + train_n);
+    vector<int> labels_test(labels.begin() + train_n, labels.end());
+
+    Ptr<ml::KNearest> k_nearest;
+    Ptr<ml::SVM> svm;
+    vector<float> predictions;
+    Mat vis;
+
+    cout << "training KNearest..." << endl;
+    k_nearest = ml::KNearest::create();
+    k_nearest->train(samples_train, ml::ROW_SAMPLE, labels_train);
+
+    // predict digits with KNearest
+    k_nearest->findNearest(samples_test, 4, predictions);
+    evaluate_model(predictions, digits_test, labels_test, vis);
+    imshow("KNearest test", vis);
+    k_nearest.release();
+
+    cout << "training SVM..." << endl;
+    svm = ml::SVM::create();
+    svm->setGamma(5.383);
+    svm->setC(2.67);
+    svm->setKernel(ml::SVM::RBF);
+    svm->setType(ml::SVM::C_SVC);
+    svm->train(samples_train, ml::ROW_SAMPLE, labels_train);
+
+    // predict digits with SVM
+    svm->predict(samples_test, predictions);
+    evaluate_model(predictions, digits_test, labels_test, vis);
+    imshow("SVM test", vis);
+    cout << "Saving SVM as \"digits_svm.yml\"..." << endl;
+    svm->save("digits_svm.yml");
+    svm.release();
+
+    waitKey();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/dis_opticalflow.cpp b/C++/opencv-4.7.0/samples/cpp/dis_opticalflow.cpp
new file mode 100644
index 00000000..3c1c22cf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/dis_opticalflow.cpp
@@ -0,0 +1,64 @@
+
+#include "opencv2/core/utility.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/video.hpp"
+
+using namespace std;
+using namespace cv;
+
+int main(int argc, char **argv)
+{
+    CommandLineParser parser(argc, argv, "{ @video  | vtest.avi  | use video as input }");
+    string filename = samples::findFileOrKeep(parser.get<string>("@video"));
+
+    VideoCapture cap;
+    cap.open(filename);
+
+    if(!cap.isOpened())
+    {
+        printf("ERROR: Cannot open file %s\n", filename.c_str());
+        parser.printMessage();
+        return -1;
+    }
+
+    Mat prevgray, gray, rgb, frame;
+    Mat flow, flow_uv[2];
+    Mat mag, ang;
+    Mat hsv_split[3], hsv;
+    char ret;
+
+    Ptr<DenseOpticalFlow> algorithm = DISOpticalFlow::create(DISOpticalFlow::PRESET_MEDIUM);
+
+    while(true)
+    {
+        cap >> frame;
+        if (frame.empty())
+            break;
+
+        cvtColor(frame, gray, COLOR_BGR2GRAY);
+
+        if (!prevgray.empty())
+        {
+            algorithm->calc(prevgray, gray, flow);
+            split(flow, flow_uv);
+            multiply(flow_uv[1], -1, flow_uv[1]);
+            cartToPolar(flow_uv[0], flow_uv[1], mag, ang, true);
+            normalize(mag, mag, 0, 1, NORM_MINMAX);
+            hsv_split[0] = ang;
+            hsv_split[1] = mag;
+            hsv_split[2] = Mat::ones(ang.size(), ang.type());
+            merge(hsv_split, 3, hsv);
+            cvtColor(hsv, rgb, COLOR_HSV2BGR);
+            imshow("flow", rgb);
+            imshow("orig", frame);
+        }
+
+        if ((ret = (char)waitKey(20)) > 0)
+            break;
+        std::swap(prevgray, gray);
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/distrans.cpp b/C++/opencv-4.7.0/samples/cpp/distrans.cpp
new file mode 100644
index 00000000..9304ec6d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/distrans.cpp
@@ -0,0 +1,185 @@
+#include <opencv2/core/utility.hpp>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <stdio.h>
+
+using namespace std;
+using namespace cv;
+
+int maskSize0 = DIST_MASK_5;
+int voronoiType = -1;
+int edgeThresh = 100;
+int distType0 = DIST_L1;
+
+// The output and temporary images
+Mat gray;
+
+// threshold trackbar callback
+static void onTrackbar( int, void* )
+{
+    static const Scalar colors[] =
+    {
+        Scalar(0,0,0),
+        Scalar(255,0,0),
+        Scalar(255,128,0),
+        Scalar(255,255,0),
+        Scalar(0,255,0),
+        Scalar(0,128,255),
+        Scalar(0,255,255),
+        Scalar(0,0,255),
+        Scalar(255,0,255)
+    };
+
+    int maskSize = voronoiType >= 0 ? DIST_MASK_5 : maskSize0;
+    int distType = voronoiType >= 0 ? DIST_L2 : distType0;
+
+    Mat edge = gray >= edgeThresh, dist, labels, dist8u;
+
+    if( voronoiType < 0 )
+        distanceTransform( edge, dist, distType, maskSize );
+    else
+        distanceTransform( edge, dist, labels, distType, maskSize, voronoiType );
+
+    if( voronoiType < 0 )
+    {
+        // begin "painting" the distance transform result
+        dist *= 5000;
+        pow(dist, 0.5, dist);
+
+        Mat dist32s, dist8u1, dist8u2;
+
+        dist.convertTo(dist32s, CV_32S, 1, 0.5);
+        dist32s &= Scalar::all(255);
+
+        dist32s.convertTo(dist8u1, CV_8U, 1, 0);
+        dist32s *= -1;
+
+        dist32s += Scalar::all(255);
+        dist32s.convertTo(dist8u2, CV_8U);
+
+        Mat planes[] = {dist8u1, dist8u2, dist8u2};
+        merge(planes, 3, dist8u);
+    }
+    else
+    {
+        dist8u.create(labels.size(), CV_8UC3);
+        for( int i = 0; i < labels.rows; i++ )
+        {
+            const int* ll = (const int*)labels.ptr(i);
+            const float* dd = (const float*)dist.ptr(i);
+            uchar* d = (uchar*)dist8u.ptr(i);
+            for( int j = 0; j < labels.cols; j++ )
+            {
+                int idx = ll[j] == 0 || dd[j] == 0 ? 0 : (ll[j]-1)%8 + 1;
+                float scale = 1.f/(1 + dd[j]*dd[j]*0.0004f);
+                int b = cvRound(colors[idx][0]*scale);
+                int g = cvRound(colors[idx][1]*scale);
+                int r = cvRound(colors[idx][2]*scale);
+                d[j*3] = (uchar)b;
+                d[j*3+1] = (uchar)g;
+                d[j*3+2] = (uchar)r;
+            }
+        }
+    }
+
+    imshow("Distance Map", dist8u );
+}
+
+static void help(const char** argv)
+{
+    printf("\nProgram to demonstrate the use of the distance transform function between edge images.\n"
+            "Usage:\n"
+            "%s [image_name -- default image is stuff.jpg]\n"
+            "\nHot keys: \n"
+            "\tESC - quit the program\n"
+            "\tC - use C/Inf metric\n"
+            "\tL1 - use L1 metric\n"
+            "\tL2 - use L2 metric\n"
+            "\t3 - use 3x3 mask\n"
+            "\t5 - use 5x5 mask\n"
+            "\t0 - use precise distance transform\n"
+            "\tv - switch to Voronoi diagram mode\n"
+            "\tp - switch to pixel-based Voronoi diagram mode\n"
+            "\tSPACE - loop through all the modes\n\n", argv[0]);
+}
+
+const char* keys =
+{
+    "{help h||}{@image |stuff.jpg|input image file}"
+};
+
+int main( int argc, const char** argv )
+{
+    CommandLineParser parser(argc, argv, keys);
+    help(argv);
+    if (parser.has("help"))
+        return 0;
+    string filename = parser.get<string>(0);
+    gray = imread(samples::findFile(filename), 0);
+    if(gray.empty())
+    {
+        printf("Cannot read image file: %s\n", filename.c_str());
+        help(argv);
+        return -1;
+    }
+
+    namedWindow("Distance Map", 1);
+    createTrackbar("Brightness Threshold", "Distance Map", &edgeThresh, 255, onTrackbar, 0);
+
+    for(;;)
+    {
+        // Call to update the view
+        onTrackbar(0, 0);
+
+        char c = (char)waitKey(0);
+
+        if( c == 27 )
+            break;
+
+        if( c == 'c' || c == 'C' || c == '1' || c == '2' ||
+            c == '3' || c == '5' || c == '0' )
+            voronoiType = -1;
+
+        if( c == 'c' || c == 'C' )
+            distType0 = DIST_C;
+        else if( c == '1' )
+            distType0 = DIST_L1;
+        else if( c == '2' )
+            distType0 = DIST_L2;
+        else if( c == '3' )
+            maskSize0 = DIST_MASK_3;
+        else if( c == '5' )
+            maskSize0 = DIST_MASK_5;
+        else if( c == '0' )
+            maskSize0 = DIST_MASK_PRECISE;
+        else if( c == 'v' )
+            voronoiType = 0;
+        else if( c == 'p' )
+            voronoiType = 1;
+        else if( c == ' ' )
+        {
+            if( voronoiType == 0 )
+                voronoiType = 1;
+            else if( voronoiType == 1 )
+            {
+                voronoiType = -1;
+                maskSize0 = DIST_MASK_3;
+                distType0 = DIST_C;
+            }
+            else if( distType0 == DIST_C )
+                distType0 = DIST_L1;
+            else if( distType0 == DIST_L1 )
+                distType0 = DIST_L2;
+            else if( maskSize0 == DIST_MASK_3 )
+                maskSize0 = DIST_MASK_5;
+            else if( maskSize0 == DIST_MASK_5 )
+                maskSize0 = DIST_MASK_PRECISE;
+            else if( maskSize0 == DIST_MASK_PRECISE )
+                voronoiType = 0;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/drawing.cpp b/C++/opencv-4.7.0/samples/cpp/drawing.cpp
new file mode 100644
index 00000000..eba297ee
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/drawing.cpp
@@ -0,0 +1,189 @@
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <stdio.h>
+
+using namespace cv;
+
+static void help(char** argv)
+{
+    printf("\nThis program demonstrates OpenCV drawing and text output functions.\n"
+    "Usage:\n"
+    "   %s\n", argv[0]);
+}
+static Scalar randomColor(RNG& rng)
+{
+    int icolor = (unsigned)rng;
+    return Scalar(icolor&255, (icolor>>8)&255, (icolor>>16)&255);
+}
+
+int main(int /* argc */, char** argv)
+{
+    help(argv);
+    char wndname[] = "Drawing Demo";
+    const int NUMBER = 100;
+    const int DELAY = 5;
+    int lineType = LINE_AA; // change it to LINE_8 to see non-antialiased graphics
+    int i, width = 1000, height = 700;
+    int x1 = -width/2, x2 = width*3/2, y1 = -height/2, y2 = height*3/2;
+    RNG rng(0xFFFFFFFF);
+
+    Mat image = Mat::zeros(height, width, CV_8UC3);
+    imshow(wndname, image);
+    waitKey(DELAY);
+
+    for (i = 0; i < NUMBER * 2; i++)
+    {
+        Point pt1, pt2;
+        pt1.x = rng.uniform(x1, x2);
+        pt1.y = rng.uniform(y1, y2);
+        pt2.x = rng.uniform(x1, x2);
+        pt2.y = rng.uniform(y1, y2);
+
+        int arrowed = rng.uniform(0, 6);
+
+        if( arrowed < 3 )
+            line( image, pt1, pt2, randomColor(rng), rng.uniform(1,10), lineType );
+        else
+            arrowedLine(image, pt1, pt2, randomColor(rng), rng.uniform(1, 10), lineType);
+
+        imshow(wndname, image);
+        if(waitKey(DELAY) >= 0)
+            return 0;
+    }
+
+    for (i = 0; i < NUMBER * 2; i++)
+    {
+        Point pt1, pt2;
+        pt1.x = rng.uniform(x1, x2);
+        pt1.y = rng.uniform(y1, y2);
+        pt2.x = rng.uniform(x1, x2);
+        pt2.y = rng.uniform(y1, y2);
+        int thickness = rng.uniform(-3, 10);
+        int marker = rng.uniform(0, 10);
+        int marker_size = rng.uniform(30, 80);
+
+        if (marker > 5)
+            rectangle(image, pt1, pt2, randomColor(rng), MAX(thickness, -1), lineType);
+        else
+            drawMarker(image, pt1, randomColor(rng), marker, marker_size );
+
+        imshow(wndname, image);
+        if(waitKey(DELAY) >= 0)
+            return 0;
+    }
+
+    for (i = 0; i < NUMBER; i++)
+    {
+        Point center;
+        center.x = rng.uniform(x1, x2);
+        center.y = rng.uniform(y1, y2);
+        Size axes;
+        axes.width = rng.uniform(0, 200);
+        axes.height = rng.uniform(0, 200);
+        double angle = rng.uniform(0, 180);
+
+        ellipse( image, center, axes, angle, angle - 100, angle + 200,
+                 randomColor(rng), rng.uniform(-1,9), lineType );
+
+        imshow(wndname, image);
+        if(waitKey(DELAY) >= 0)
+            return 0;
+    }
+
+    for (i = 0; i< NUMBER; i++)
+    {
+        Point pt[2][3];
+        pt[0][0].x = rng.uniform(x1, x2);
+        pt[0][0].y = rng.uniform(y1, y2);
+        pt[0][1].x = rng.uniform(x1, x2);
+        pt[0][1].y = rng.uniform(y1, y2);
+        pt[0][2].x = rng.uniform(x1, x2);
+        pt[0][2].y = rng.uniform(y1, y2);
+        pt[1][0].x = rng.uniform(x1, x2);
+        pt[1][0].y = rng.uniform(y1, y2);
+        pt[1][1].x = rng.uniform(x1, x2);
+        pt[1][1].y = rng.uniform(y1, y2);
+        pt[1][2].x = rng.uniform(x1, x2);
+        pt[1][2].y = rng.uniform(y1, y2);
+        const Point* ppt[2] = {pt[0], pt[1]};
+        int npt[] = {3, 3};
+
+        polylines(image, ppt, npt, 2, true, randomColor(rng), rng.uniform(1,10), lineType);
+
+        imshow(wndname, image);
+        if(waitKey(DELAY) >= 0)
+            return 0;
+    }
+
+    for (i = 0; i< NUMBER; i++)
+    {
+        Point pt[2][3];
+        pt[0][0].x = rng.uniform(x1, x2);
+        pt[0][0].y = rng.uniform(y1, y2);
+        pt[0][1].x = rng.uniform(x1, x2);
+        pt[0][1].y = rng.uniform(y1, y2);
+        pt[0][2].x = rng.uniform(x1, x2);
+        pt[0][2].y = rng.uniform(y1, y2);
+        pt[1][0].x = rng.uniform(x1, x2);
+        pt[1][0].y = rng.uniform(y1, y2);
+        pt[1][1].x = rng.uniform(x1, x2);
+        pt[1][1].y = rng.uniform(y1, y2);
+        pt[1][2].x = rng.uniform(x1, x2);
+        pt[1][2].y = rng.uniform(y1, y2);
+        const Point* ppt[2] = {pt[0], pt[1]};
+        int npt[] = {3, 3};
+
+        fillPoly(image, ppt, npt, 2, randomColor(rng), lineType);
+
+        imshow(wndname, image);
+        if(waitKey(DELAY) >= 0)
+            return 0;
+    }
+
+    for (i = 0; i < NUMBER; i++)
+    {
+        Point center;
+        center.x = rng.uniform(x1, x2);
+        center.y = rng.uniform(y1, y2);
+
+        circle(image, center, rng.uniform(0, 300), randomColor(rng),
+               rng.uniform(-1, 9), lineType);
+
+        imshow(wndname, image);
+        if(waitKey(DELAY) >= 0)
+            return 0;
+    }
+
+    for (i = 1; i < NUMBER; i++)
+    {
+        Point org;
+        org.x = rng.uniform(x1, x2);
+        org.y = rng.uniform(y1, y2);
+
+        putText(image, "Testing text rendering", org, rng.uniform(0,8),
+                rng.uniform(0,100)*0.05+0.1, randomColor(rng), rng.uniform(1, 10), lineType);
+
+        imshow(wndname, image);
+        if(waitKey(DELAY) >= 0)
+            return 0;
+    }
+
+    Size textsize = getTextSize("OpenCV forever!", FONT_HERSHEY_COMPLEX, 3, 5, 0);
+    Point org((width - textsize.width)/2, (height - textsize.height)/2);
+
+    Mat image2;
+    for( i = 0; i < 255; i += 2 )
+    {
+        image2 = image - Scalar::all(i);
+        putText(image2, "OpenCV forever!", org, FONT_HERSHEY_COMPLEX, 3,
+                Scalar(i, i, 255), 5, lineType);
+
+        imshow(wndname, image2);
+        if(waitKey(DELAY) >= 0)
+            return 0;
+    }
+
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/edge.cpp b/C++/opencv-4.7.0/samples/cpp/edge.cpp
new file mode 100644
index 00000000..339baf2a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/edge.cpp
@@ -0,0 +1,85 @@
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <stdio.h>
+
+using namespace cv;
+using namespace std;
+
+int edgeThresh = 1;
+int edgeThreshScharr=1;
+
+Mat image, gray, blurImage, edge1, edge2, cedge;
+
+const char* window_name1 = "Edge map : Canny default (Sobel gradient)";
+const char* window_name2 = "Edge map : Canny with custom gradient (Scharr)";
+
+// define a trackbar callback
+static void onTrackbar(int, void*)
+{
+    blur(gray, blurImage, Size(3,3));
+
+    // Run the edge detector on grayscale
+    Canny(blurImage, edge1, edgeThresh, edgeThresh*3, 3);
+    cedge = Scalar::all(0);
+
+    image.copyTo(cedge, edge1);
+    imshow(window_name1, cedge);
+
+    /// Canny detector with scharr
+    Mat dx,dy;
+    Scharr(blurImage,dx,CV_16S,1,0);
+    Scharr(blurImage,dy,CV_16S,0,1);
+    Canny( dx,dy, edge2, edgeThreshScharr, edgeThreshScharr*3 );
+    /// Using Canny's output as a mask, we display our result
+    cedge = Scalar::all(0);
+    image.copyTo(cedge, edge2);
+    imshow(window_name2, cedge);
+}
+
+static void help(const char** argv)
+{
+    printf("\nThis sample demonstrates Canny edge detection\n"
+           "Call:\n"
+           "    %s [image_name -- Default is fruits.jpg]\n\n", argv[0]);
+}
+
+const char* keys =
+{
+    "{help h||}{@image |fruits.jpg|input image name}"
+};
+
+int main( int argc, const char** argv )
+{
+    help(argv);
+    CommandLineParser parser(argc, argv, keys);
+    string filename = parser.get<string>(0);
+
+    image = imread(samples::findFile(filename), IMREAD_COLOR);
+    if(image.empty())
+    {
+        printf("Cannot read image file: %s\n", filename.c_str());
+        help(argv);
+        return -1;
+    }
+    cedge.create(image.size(), image.type());
+    cvtColor(image, gray, COLOR_BGR2GRAY);
+
+    // Create a window
+    namedWindow(window_name1, 1);
+    namedWindow(window_name2, 1);
+
+    // create a toolbar
+    createTrackbar("Canny threshold default", window_name1, &edgeThresh, 100, onTrackbar);
+    createTrackbar("Canny threshold Scharr", window_name2, &edgeThreshScharr, 400, onTrackbar);
+
+    // Show the image
+    onTrackbar(0, 0);
+
+    // Wait for a key stroke; the same function arranges events processing
+    waitKey(0);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/ela.cpp b/C++/opencv-4.7.0/samples/cpp/ela.cpp
new file mode 100644
index 00000000..ad76ba1b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/ela.cpp
@@ -0,0 +1,67 @@
+/**
+  @file ela.cpp
+  @author Alessandro de Oliveira Faria (A.K.A. CABELO)
+  @brief Error Level Analysis (ELA) permits identifying areas within an image that are at different compression levels. With JPEG images, the entire picture should be at roughly the same level. If a section of the image is at a significantly different error level, then it likely indicates a digital modification. This example allows to see visually the changes made in a JPG image based in it's compression error analysis. Questions and suggestions email to: Alessandro de Oliveira Faria cabelo[at]opensuse[dot]org or OpenCV Team.
+  @date Jun 24, 2018
+*/
+
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace cv;
+
+int scale_value = 7;
+int quality = 95;
+Mat image;
+Mat compressed_img;
+const char* decodedwin = "the recompressed image";
+const char* diffwin = "scaled difference between the original and recompressed images";
+
+static void processImage(int , void*)
+{
+    Mat Ela;
+
+    // Compression jpeg
+    std::vector<int> compressing_factor;
+    std::vector<uchar> buf;
+
+    compressing_factor.push_back(IMWRITE_JPEG_QUALITY);
+    compressing_factor.push_back(quality);
+
+    imencode(".jpg", image, buf, compressing_factor);
+
+    compressed_img = imdecode(buf, 1);
+
+    Mat output;
+    absdiff(image,compressed_img,output);
+    output.convertTo(Ela, CV_8UC3, scale_value);
+
+    // Shows processed image
+    imshow(decodedwin, compressed_img);
+    imshow(diffwin, Ela);
+}
+
+int main (int argc, char* argv[])
+{
+    CommandLineParser parser(argc, argv, "{ input i | ela_modified.jpg | Input image to calculate ELA algorithm. }");
+    parser.about("\nJpeg Recompression Example:\n");
+    parser.printMessage();
+
+    // Read the new image
+    image = imread(samples::findFile(parser.get<String>("input")));
+
+    // Check image
+    if (!image.empty())
+    {
+        processImage(0, 0);
+        createTrackbar("Scale", diffwin, &scale_value, 100, processImage);
+        createTrackbar("Quality", diffwin, &quality, 100, processImage);
+        waitKey(0);
+    }
+    else
+    {
+        std::cout << "> Error in load image\n";
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/em.cpp b/C++/opencv-4.7.0/samples/cpp/em.cpp
new file mode 100644
index 00000000..f5310740
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/em.cpp
@@ -0,0 +1,70 @@
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/ml.hpp"
+
+using namespace cv;
+using namespace cv::ml;
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    const int N = 4;
+    const int N1 = (int)sqrt((double)N);
+    const Scalar colors[] =
+    {
+        Scalar(0,0,255), Scalar(0,255,0),
+        Scalar(0,255,255),Scalar(255,255,0)
+    };
+
+    int i, j;
+    int nsamples = 100;
+    Mat samples( nsamples, 2, CV_32FC1 );
+    Mat labels;
+    Mat img = Mat::zeros( Size( 500, 500 ), CV_8UC3 );
+    Mat sample( 1, 2, CV_32FC1 );
+
+    samples = samples.reshape(2, 0);
+    for( i = 0; i < N; i++ )
+    {
+        // form the training samples
+        Mat samples_part = samples.rowRange(i*nsamples/N, (i+1)*nsamples/N );
+
+        Scalar mean(((i%N1)+1)*img.rows/(N1+1),
+                    ((i/N1)+1)*img.rows/(N1+1));
+        Scalar sigma(30,30);
+        randn( samples_part, mean, sigma );
+    }
+    samples = samples.reshape(1, 0);
+
+    // cluster the data
+    Ptr<EM> em_model = EM::create();
+    em_model->setClustersNumber(N);
+    em_model->setCovarianceMatrixType(EM::COV_MAT_SPHERICAL);
+    em_model->setTermCriteria(TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 300, 0.1));
+    em_model->trainEM( samples, noArray(), labels, noArray() );
+
+    // classify every image pixel
+    for( i = 0; i < img.rows; i++ )
+    {
+        for( j = 0; j < img.cols; j++ )
+        {
+            sample.at<float>(0) = (float)j;
+            sample.at<float>(1) = (float)i;
+            int response = cvRound(em_model->predict2( sample, noArray() )[1]);
+            Scalar c = colors[response];
+
+            circle( img, Point(j, i), 1, c*0.75, FILLED );
+        }
+    }
+
+    //draw the clustered samples
+    for( i = 0; i < nsamples; i++ )
+    {
+        Point pt(cvRound(samples.at<float>(i, 0)), cvRound(samples.at<float>(i, 1)));
+        circle( img, pt, 1, colors[labels.at<int>(i)], FILLED );
+    }
+
+    imshow( "EM-clustering result", img );
+    waitKey(0);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/epipolar_lines.cpp b/C++/opencv-4.7.0/samples/cpp/epipolar_lines.cpp
new file mode 100644
index 00000000..ed514c91
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/epipolar_lines.cpp
@@ -0,0 +1,106 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "opencv2/calib3d.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include <vector>
+#include <iostream>
+
+using namespace cv;
+
+int main(int args, char** argv) {
+    std::string img_name1, img_name2;
+    if (args < 3) {
+       CV_Error(Error::StsBadArg,
+                "Path to two images \nFor example: "
+                "./epipolar_lines img1.jpg img2.jpg");
+    } else {
+       img_name1 = argv[1];
+       img_name2 = argv[2];
+    }
+
+    Mat image1 = imread(img_name1);
+    Mat image2 = imread(img_name2);
+    Mat descriptors1, descriptors2;
+    std::vector<KeyPoint> keypoints1, keypoints2;
+
+    Ptr<SIFT> detector = SIFT::create();
+    detector->detect(image1, keypoints1);
+    detector->detect(image2, keypoints2);
+    detector->compute(image1, keypoints1, descriptors1);
+    detector->compute(image2, keypoints2, descriptors2);
+
+    FlannBasedMatcher matcher(makePtr<flann::KDTreeIndexParams>(5), makePtr<flann::SearchParams>(32));
+
+    // get k=2 best match that we can apply ratio test explained by D.Lowe
+    std::vector<std::vector<DMatch>> matches_vector;
+    matcher.knnMatch(descriptors1, descriptors2, matches_vector, 2);
+
+    std::vector<Point2d> pts1, pts2;
+    pts1.reserve(matches_vector.size()); pts2.reserve(matches_vector.size());
+    for (const auto &m : matches_vector) {
+        // compare best and second match using Lowe ratio test
+        if (m[0].distance / m[1].distance < 0.75) {
+            pts1.emplace_back(keypoints1[m[0].queryIdx].pt);
+            pts2.emplace_back(keypoints2[m[0].trainIdx].pt);
+        }
+    }
+
+    std::cout << "Number of points " << pts1.size() << '\n';
+
+    Mat inliers;
+    const auto begin_time = std::chrono::steady_clock::now();
+    const Mat F = findFundamentalMat(pts1, pts2, RANSAC, 1., 0.99, 2000, inliers);
+    std::cout << "RANSAC fundamental matrix time " << static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>
+            (std::chrono::steady_clock::now() - begin_time).count()) << "\n";
+
+    Mat points1 = Mat((int)pts1.size(), 2, CV_64F, pts1.data());
+    Mat points2 = Mat((int)pts2.size(), 2, CV_64F, pts2.data());
+    vconcat(points1.t(), Mat::ones(1, points1.rows, points1.type()), points1);
+    vconcat(points2.t(), Mat::ones(1, points2.rows, points2.type()), points2);
+
+    RNG rng;
+    const int circle_sz = 3, line_sz = 1, max_lines = 300;
+    std::vector<int> pts_shuffle (points1.cols);
+    for (int i = 0; i < points1.cols; i++)
+        pts_shuffle[i] = i;
+    randShuffle(pts_shuffle);
+    int plot_lines = 0, num_inliers = 0;
+    double mean_err = 0;
+    for (int pt : pts_shuffle) {
+        if (inliers.at<uchar>(pt)) {
+            const Scalar col (rng.uniform(0,256), rng.uniform(0,256), rng.uniform(0,256));
+            const Mat l2 = F     * points1.col(pt);
+            const Mat l1 = F.t() * points2.col(pt);
+            double a1 = l1.at<double>(0), b1 = l1.at<double>(1), c1 = l1.at<double>(2);
+            double a2 = l2.at<double>(0), b2 = l2.at<double>(1), c2 = l2.at<double>(2);
+            const double mag1 = sqrt(a1*a1 + b1*b1), mag2 = (a2*a2 + b2*b2);
+            a1 /= mag1; b1 /= mag1; c1 /= mag1; a2 /= mag2; b2 /= mag2; c2 /= mag2;
+            if (plot_lines++ < max_lines) {
+                line(image1, Point2d(0, -c1/b1),
+                     Point2d((double)image1.cols, -(a1*image1.cols+c1)/b1), col, line_sz);
+                line(image2, Point2d(0, -c2/b2),
+                     Point2d((double)image2.cols, -(a2*image2.cols+c2)/b2), col, line_sz);
+            }
+            circle (image1, pts1[pt], circle_sz, col, -1);
+            circle (image2, pts2[pt], circle_sz, col, -1);
+            mean_err += (fabs(points1.col(pt).dot(l2)) / mag2 + fabs(points2.col(pt).dot(l1) / mag1)) / 2;
+            num_inliers++;
+        }
+    }
+    std::cout << "Mean distance from tentative inliers to epipolar lines " << mean_err/num_inliers
+              << " number of inliers " << num_inliers << "\n";
+    // concatenate two images
+    hconcat(image1, image2, image1);
+    const int new_img_size = 1200 * 800; // for example
+    // resize with the same aspect ratio
+    resize(image1, image1, Size((int) sqrt ((double) image1.cols * new_img_size / image1.rows),
+                                (int)sqrt ((double) image1.rows * new_img_size / image1.cols)));
+
+    imshow("epipolar lines, image 1, 2", image1);
+    imwrite("epipolar_lines.png", image1);
+    waitKey(0);
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/cpp/essential_mat_reconstr.cpp b/C++/opencv-4.7.0/samples/cpp/essential_mat_reconstr.cpp
new file mode 100644
index 00000000..5a7b8373
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/essential_mat_reconstr.cpp
@@ -0,0 +1,342 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "opencv2/calib3d.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include <vector>
+#include <iostream>
+#include <fstream>
+
+using namespace cv;
+static double getError2EpipLines (const Mat &F, const Mat &pts1, const Mat &pts2, const Mat &mask) {
+    Mat points1, points2;
+    vconcat(pts1, Mat::ones(1, pts1.cols, pts1.type()), points1);
+    vconcat(pts2, Mat::ones(1, pts2.cols, pts2.type()), points2);
+
+    double mean_error = 0;
+    for (int pt = 0; pt < (int) mask.total(); pt++)
+        if (mask.at<uchar>(pt)) {
+            const Mat l2 = F     * points1.col(pt);
+            const Mat l1 = F.t() * points2.col(pt);
+            mean_error += (fabs(points1.col(pt).dot(l1)) / sqrt(pow(l1.at<double>(0), 2) + pow(l1.at<double>(1), 2)) +
+                           fabs(points2.col(pt).dot(l2) / sqrt(pow(l2.at<double>(0), 2) + pow(l2.at<double>(1), 2)))) / 2;
+        }
+    return mean_error / mask.total();
+}
+static int sgn(double val) { return (0 < val) - (val < 0); }
+
+/*
+ * @points3d - vector of Point3 or Mat of size Nx3
+ * @planes - vector of found planes
+ * @labels - vector of size point3d. Every point which has non-zero label is classified to this plane.
+ */
+static void getPlanes (InputArray points3d_, std::vector<int> &labels, std::vector<Vec4d> &planes, int desired_num_planes, double thr_, double conf_, int max_iters_) {
+    Mat points3d = points3d_.getMat();
+    points3d.convertTo(points3d, CV_64F); // convert points to have double precision
+    if (points3d_.isVector())
+        points3d = Mat((int)points3d.total(), 3, CV_64F, points3d.data);
+    else {
+        if (points3d.type() != CV_64F)
+            points3d = points3d.reshape(1, (int)points3d.total()); // convert point to have 1 channel
+        if (points3d.rows < points3d.cols)
+            transpose(points3d, points3d); // transpose so points will be in rows
+        CV_CheckEQ(points3d.cols, 3, "Invalid dimension of point");
+    }
+
+    /*
+     * 3D plane fitting with RANSAC
+     * @best_model contains coefficients [a b c d] s.t. ax + by + cz = d
+     *
+     */
+    auto plane_ransac = [] (const Mat &pts, double thr, double conf, int max_iters, Vec4d &best_model, std::vector<bool> &inliers) {
+        const int pts_size = pts.rows, max_lo_inliers = 15, max_lo_iters = 10;
+        int best_inls = 0;
+        if (pts_size < 3) return false;
+        RNG rng;
+        const auto * const points = (double *) pts.data;
+        std::vector<int> min_sample(3);
+        inliers = std::vector<bool>(pts_size);
+        const double log_conf = log(1-conf);
+        Vec4d model, lo_model;
+        std::vector<int> random_pool (pts_size);
+        for (int p = 0; p < pts_size; p++)
+            random_pool[p] = p;
+
+        // estimate plane coefficients using covariance matrix
+        auto estimate = [&] (const std::vector<int> &sample, Vec4d &model_) {
+            // https://www.ilikebigbits.com/2017_09_25_plane_from_points_2.html
+            const int n = static_cast<int>(sample.size());
+            if (n < 3) return false;
+            double sum_x = 0, sum_y = 0, sum_z = 0;
+            for (int s : sample) {
+                sum_x += points[3*s  ];
+                sum_y += points[3*s+1];
+                sum_z += points[3*s+2];
+            }
+            const double c_x = sum_x / n, c_y = sum_y / n, c_z = sum_z / n;
+            double xx = 0, yy = 0, zz = 0, xy = 0, xz = 0, yz = 0;
+            for (int s : sample) {
+                const double x_ = points[3*s] - c_x, y_ = points[3*s+1] - c_y, z_ = points[3*s+2] - c_z;
+                xx += x_*x_; yy += y_*y_; zz += z_*z_; xy += x_*y_; yz += y_*z_; xz += x_*z_;
+            }
+            xx /= n; yy /= n; zz /= n; xy /= n; yz /= n; xz /= n;
+            Vec3d weighted_normal(0,0,0);
+            const double det_x = yy*zz - yz*yz, det_y = xx*zz - xz*xz, det_z = xx*yy - xy*xy;
+            Vec3d axis_x (det_x, xz*xz-xy*zz, xy*yz-xz*yy);
+            Vec3d axis_y (xz*yz-xy*zz, det_y, xy*xz-yz*xx);
+            Vec3d axis_z (xy*yz-xz*yy, xy*xz-yz*xx, det_z);
+            weighted_normal += axis_x * det_x * det_x;
+            weighted_normal += sgn(weighted_normal.dot(axis_y)) * axis_y * det_y * det_y;
+            weighted_normal += sgn(weighted_normal.dot(axis_z)) * axis_z * det_z * det_z;
+            weighted_normal /= norm(weighted_normal);
+            if (std::isinf(weighted_normal(0)) ||
+                std::isinf(weighted_normal(1)) ||
+                std::isinf(weighted_normal(2))) return false;
+            // find plane model from normal and centroid
+            model_ = Vec4d(weighted_normal(0), weighted_normal(1), weighted_normal(2),
+                           weighted_normal.dot(Vec3d(c_x, c_y, c_z)));
+            return true;
+        };
+
+        // calculate number of inliers
+        auto getInliers = [&] (const Vec4d &model_) {
+            const double a = model_(0), b = model_(1), c = model_(2), d = model_(3);
+            int num_inliers = 0;
+            std::fill(inliers.begin(), inliers.end(), false);
+            for (int p = 0; p < pts_size; p++) {
+                inliers[p] = fabs(a * points[3*p] + b * points[3*p+1] + c * points[3*p+2] - d) < thr;
+                if (inliers[p]) num_inliers++;
+                if (num_inliers + pts_size - p < best_inls) break;
+            }
+            return num_inliers;
+        };
+        // main RANSAC loop
+        for (int iters = 0; iters < max_iters; iters++) {
+            // find minimal sample: 3 points
+            min_sample[0] = rng.uniform(0, pts_size);
+            min_sample[1] = rng.uniform(0, pts_size);
+            min_sample[2] = rng.uniform(0, pts_size);
+            if (! estimate(min_sample, model))
+                continue;
+            int num_inliers = getInliers(model);
+            if (num_inliers > best_inls) {
+                // store so-far-the-best
+                std::vector<bool> best_inliers = inliers;
+                // do Local Optimization
+                for (int lo_iter = 0; lo_iter < max_lo_iters; lo_iter++) {
+                    std::vector<int> inliers_idx; inliers_idx.reserve(max_lo_inliers);
+                    randShuffle(random_pool);
+                    for (int p : random_pool) {
+                        if (best_inliers[p]) {
+                            inliers_idx.emplace_back(p);
+                            if ((int)inliers_idx.size() >= max_lo_inliers)
+                                break;
+                        }
+                    }
+                    if (! estimate(inliers_idx, lo_model))
+                        continue;
+                    int lo_inls = getInliers(lo_model);
+                    if (best_inls < lo_inls) {
+                        best_model = lo_model;
+                        best_inls = lo_inls;
+                        best_inliers = inliers;
+                    }
+                }
+                if (best_inls < num_inliers) {
+                    best_model = model;
+                    best_inls = num_inliers;
+                }
+                // update max iters
+                // because points are quite noisy we need more iterations
+                const double max_hyp = 3 * log_conf / log(1 - pow(double(best_inls) / pts_size, 3));
+                if (! std::isinf(max_hyp) && max_hyp < max_iters)
+                    max_iters = static_cast<int>(max_hyp);
+            }
+        }
+        getInliers(best_model);
+        return best_inls != 0;
+    };
+
+    labels = std::vector<int>(points3d.rows, 0);
+    Mat pts3d_plane_fit = points3d.clone();
+    // keep array of indices of points corresponding to original points3d
+    std::vector<int> to_orig_pts_arr(pts3d_plane_fit.rows);
+    for (int i = 0; i < (int) to_orig_pts_arr.size(); i++)
+        to_orig_pts_arr[i] = i;
+    for (int num_planes = 1; num_planes <= desired_num_planes; num_planes++) {
+        Vec4d model;
+        std::vector<bool> inl;
+        if (!plane_ransac(pts3d_plane_fit, thr_, conf_, max_iters_, model, inl))
+            break;
+        planes.emplace_back(model);
+
+        const int pts3d_size = pts3d_plane_fit.rows;
+        pts3d_plane_fit = Mat();
+        pts3d_plane_fit.reserve(points3d.rows);
+
+        int cnt = 0;
+        for (int p = 0; p < pts3d_size; p++) {
+            if (! inl[p]) {
+                // if point is not inlier to found plane - add it to next run
+                to_orig_pts_arr[cnt] = to_orig_pts_arr[p];
+                pts3d_plane_fit.push_back(points3d.row(to_orig_pts_arr[cnt]));
+                cnt++;
+            } else labels[to_orig_pts_arr[p]] = num_planes; // otherwise label this point
+        }
+    }
+}
+
+int main(int args, char** argv) {
+    std::string data_file, image_dir;
+    if (args < 3) {
+       CV_Error(Error::StsBadArg,
+                "Path to data file and directory to image files are missing!\nData file must have"
+                " format:\n--------------\n image_name_1\nimage_name_2\nk11 k12 k13\n0   k22 k23\n"
+                "0   0   1\n--------------\nIf image_name_{1,2} are not in the same directory as "
+                "the data file then add argument with directory to image files.\nFor example: "
+                "./essential_mat_reconstr essential_mat_data.txt ./");
+    } else {
+       data_file = argv[1];
+       image_dir = argv[2];
+    }
+    std::ifstream file(data_file, std::ios_base::in);
+    CV_CheckEQ((int)file.is_open(), 1, "Data file is not found!");
+    std::string filename1, filename2;
+    std::getline(file, filename1);
+    std::getline(file, filename2);
+    Mat image1 = imread(image_dir+filename1);
+    Mat image2 = imread(image_dir+filename2);
+    CV_CheckEQ((int)image1.empty(), 0, "Image 1 is not found!");
+    CV_CheckEQ((int)image2.empty(), 0, "Image 2 is not found!");
+
+    // read calibration
+    Matx33d K;
+    for (int i = 0; i < 3; i++)
+        for (int j = 0; j < 3; j++)
+            file >> K(i,j);
+    file.close();
+
+    Mat descriptors1, descriptors2;
+    std::vector<KeyPoint> keypoints1, keypoints2;
+
+    // detect points with SIFT
+    Ptr<SIFT> detector = SIFT::create();
+    detector->detect(image1, keypoints1);
+    detector->detect(image2, keypoints2);
+    detector->compute(image1, keypoints1, descriptors1);
+    detector->compute(image2, keypoints2, descriptors2);
+
+    FlannBasedMatcher matcher(makePtr<flann::KDTreeIndexParams>(5), makePtr<flann::SearchParams>(32));
+
+    // get k=2 best match that we can apply ratio test explained by D.Lowe
+    std::vector<std::vector<DMatch>> matches_vector;
+    matcher.knnMatch(descriptors1, descriptors2, matches_vector, 2);
+
+    // filter keypoints with Lowe ratio test
+    std::vector<Point2d> pts1, pts2;
+    pts1.reserve(matches_vector.size()); pts2.reserve(matches_vector.size());
+    for (const auto &m : matches_vector) {
+        // compare best and second match using Lowe ratio test
+        if (m[0].distance / m[1].distance < 0.75) {
+            pts1.emplace_back(keypoints1[m[0].queryIdx].pt);
+            pts2.emplace_back(keypoints2[m[0].trainIdx].pt);
+        }
+    }
+
+    Mat inliers;
+    const int pts_size = (int) pts1.size();
+    const auto begin_time = std::chrono::steady_clock::now();
+    // fine essential matrix
+    const Mat E = findEssentialMat(pts1, pts2, Mat(K), RANSAC, 0.99, 1.0, inliers);
+    std::cout << "RANSAC essential matrix time " << std::chrono::duration_cast<std::chrono::microseconds>
+            (std::chrono::steady_clock::now() - begin_time).count() <<
+            "mcs.\nNumber of inliers " << countNonZero(inliers) << "\n";
+
+    Mat points1 = Mat((int)pts1.size(), 2, CV_64F, pts1.data());
+    Mat points2 = Mat((int)pts2.size(), 2, CV_64F, pts2.data());
+    points1 = points1.t(); points2 = points2.t();
+
+    std::cout << "Mean error to epipolar lines " <<
+        getError2EpipLines(K.inv().t() * E * K.inv(), points1, points2, inliers) << "\n";
+
+    // decompose essential into rotation and translation
+    Mat R1, R2, t;
+    decomposeEssentialMat(E, R1, R2, t);
+
+    // Create two relative pose
+    // P1 = K [  I    |   0  ]
+    // P2 = K [R{1,2} | {+-}t]
+    Mat P1;
+    hconcat(K, Vec3d::zeros(), P1);
+    std::vector<Mat> P2s(4);
+    hconcat(K * R1,  K * t, P2s[0]);
+    hconcat(K * R1, -K * t, P2s[1]);
+    hconcat(K * R2,  K * t, P2s[2]);
+    hconcat(K * R2, -K * t, P2s[3]);
+
+    // find objects point by enumerating over 4 different projection matrices of second camera
+    // vector to keep object points
+    std::vector<std::vector<Vec3d>> obj_pts_per_cam(4);
+    // vector to keep indices of image points corresponding to object points
+    std::vector<std::vector<int>> img_idxs_per_cam(4);
+    int cam_idx = 0, best_cam_idx = 0, max_obj_pts = 0;
+    for (const auto &P2 : P2s) {
+        obj_pts_per_cam[cam_idx].reserve(pts_size);
+        img_idxs_per_cam[cam_idx].reserve(pts_size);
+        for (int i = 0; i < pts_size; i++) {
+            // process only inliers
+            if (! inliers.at<uchar>(i))
+                continue;
+
+            Vec4d obj_pt;
+            // find object point using triangulation
+            triangulatePoints(P1, P2, points1.col(i), points2.col(i), obj_pt);
+            obj_pt /= obj_pt(3); // normalize 4d point
+            if (obj_pt(2) > 0) { // check if projected point has positive depth
+                obj_pts_per_cam[cam_idx].emplace_back(Vec3d(obj_pt(0), obj_pt(1), obj_pt(2)));
+                img_idxs_per_cam[cam_idx].emplace_back(i);
+            }
+        }
+        if (max_obj_pts < (int) obj_pts_per_cam[cam_idx].size()) {
+            max_obj_pts = (int) obj_pts_per_cam[cam_idx].size();
+            best_cam_idx = cam_idx;
+        }
+        cam_idx++;
+    }
+
+    std::cout << "Number of object points " << max_obj_pts << "\n";
+
+    const int circle_sz = 7;
+    // draw image points that are inliers on two images
+    std::vector<int> labels;
+    std::vector<Vec4d> planes;
+    getPlanes (obj_pts_per_cam[best_cam_idx], labels, planes, 4, 0.002, 0.99, 10000);
+    const int num_found_planes = (int) planes.size();
+    RNG rng;
+    std::vector<Scalar> plane_colors (num_found_planes);
+    for (int pl = 0; pl < num_found_planes; pl++)
+        plane_colors[pl] = Scalar (rng.uniform(0,256), rng.uniform(0,256), rng.uniform(0,256));
+    for (int obj_pt = 0; obj_pt < max_obj_pts; obj_pt++) {
+        const int pt = img_idxs_per_cam[best_cam_idx][obj_pt];
+        if (labels[obj_pt] > 0) { // plot plane points
+            circle (image1, pts1[pt], circle_sz, plane_colors[labels[obj_pt]-1], -1);
+            circle (image2, pts2[pt], circle_sz, plane_colors[labels[obj_pt]-1], -1);
+        } else { // plot inliers
+            circle (image1, pts1[pt], circle_sz, Scalar(0,0,0), -1);
+            circle (image2, pts2[pt], circle_sz, Scalar(0,0,0), -1);
+        }
+    }
+
+    // concatenate two images
+    hconcat(image1, image2, image1);
+    const int new_img_size = 1200 * 800; // for example
+    // resize with the same aspect ratio
+    resize(image1, image1, Size((int)sqrt ((double) image1.cols * new_img_size / image1.rows),
+                                (int)sqrt ((double) image1.rows * new_img_size / image1.cols)));
+    imshow("image 1-2", image1);
+    imwrite("planes.png", image1);
+    waitKey(0);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/example_cmake/CMakeLists.txt b/C++/opencv-4.7.0/samples/cpp/example_cmake/CMakeLists.txt
new file mode 100644
index 00000000..8d5cd98a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/example_cmake/CMakeLists.txt
@@ -0,0 +1,26 @@
+# cmake needs this line
+cmake_minimum_required(VERSION 3.1)
+
+# Define project name
+project(opencv_example_project)
+
+# Find OpenCV, you may need to set OpenCV_DIR variable
+# to the absolute path to the directory containing OpenCVConfig.cmake file
+# via the command line or GUI
+find_package(OpenCV REQUIRED)
+
+# If the package has been found, several variables will
+# be set, you can find the full list with descriptions
+# in the OpenCVConfig.cmake file.
+# Print some message showing some of them
+message(STATUS "OpenCV library status:")
+message(STATUS "    config: ${OpenCV_DIR}")
+message(STATUS "    version: ${OpenCV_VERSION}")
+message(STATUS "    libraries: ${OpenCV_LIBS}")
+message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")
+
+# Declare the executable target built from your sources
+add_executable(opencv_example example.cpp)
+
+# Link your application with OpenCV libraries
+target_link_libraries(opencv_example PRIVATE ${OpenCV_LIBS})
diff --git a/C++/opencv-4.7.0/samples/cpp/example_cmake/Makefile b/C++/opencv-4.7.0/samples/cpp/example_cmake/Makefile
new file mode 100644
index 00000000..f7291157
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/example_cmake/Makefile
@@ -0,0 +1,12 @@
+CXX ?= g++
+
+CXXFLAGS += -c -Wall $(shell pkg-config --cflags opencv)
+LDFLAGS += $(shell pkg-config --libs --static opencv)
+
+all: opencv_example
+
+opencv_example: example.o; $(CXX) $< -o $@ $(LDFLAGS)
+
+%.o: %.cpp; $(CXX) $< -o $@ $(CXXFLAGS)
+
+clean: ; rm -f example.o opencv_example
diff --git a/C++/opencv-4.7.0/samples/cpp/example_cmake/example.cpp b/C++/opencv-4.7.0/samples/cpp/example_cmake/example.cpp
new file mode 100644
index 00000000..cac5050b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/example_cmake/example.cpp
@@ -0,0 +1,50 @@
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/videoio.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+void drawText(Mat & image);
+
+int main()
+{
+    cout << "Built with OpenCV " << CV_VERSION << endl;
+    Mat image;
+    VideoCapture capture;
+    capture.open(0);
+    if(capture.isOpened())
+    {
+        cout << "Capture is opened" << endl;
+        for(;;)
+        {
+            capture >> image;
+            if(image.empty())
+                break;
+            drawText(image);
+            imshow("Sample", image);
+            if(waitKey(10) >= 0)
+                break;
+        }
+    }
+    else
+    {
+        cout << "No capture" << endl;
+        image = Mat::zeros(480, 640, CV_8UC1);
+        drawText(image);
+        imshow("Sample", image);
+        waitKey(0);
+    }
+    return 0;
+}
+
+void drawText(Mat & image)
+{
+    putText(image, "Hello OpenCV",
+            Point(20, 50),
+            FONT_HERSHEY_COMPLEX, 1, // font face and scale
+            Scalar(255, 255, 255), // white
+            1, LINE_AA); // line thickness and type
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/facedetect.cpp b/C++/opencv-4.7.0/samples/cpp/facedetect.cpp
new file mode 100644
index 00000000..9c846faf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/facedetect.cpp
@@ -0,0 +1,257 @@
+#include "opencv2/objdetect.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static void help(const char** argv)
+{
+    cout << "\nThis program demonstrates the use of cv::CascadeClassifier class to detect objects (Face + eyes). You can use Haar or LBP features.\n"
+            "This classifier can recognize many kinds of rigid objects, once the appropriate classifier is trained.\n"
+            "It's most known use is for faces.\n"
+            "Usage:\n"
+        <<  argv[0]
+        <<  "   [--cascade=<cascade_path> this is the primary trained classifier such as frontal face]\n"
+            "   [--nested-cascade[=nested_cascade_path this an optional secondary classifier such as eyes]]\n"
+            "   [--scale=<image scale greater or equal to 1, try 1.3 for example>]\n"
+            "   [--try-flip]\n"
+            "   [filename|camera_index]\n\n"
+            "example:\n"
+        <<  argv[0]
+        <<  " --cascade=\"data/haarcascades/haarcascade_frontalface_alt.xml\" --nested-cascade=\"data/haarcascades/haarcascade_eye_tree_eyeglasses.xml\" --scale=1.3\n\n"
+            "During execution:\n\tHit any key to quit.\n"
+            "\tUsing OpenCV version " << CV_VERSION << "\n" << endl;
+}
+
+void detectAndDraw( Mat& img, CascadeClassifier& cascade,
+                    CascadeClassifier& nestedCascade,
+                    double scale, bool tryflip );
+
+string cascadeName;
+string nestedCascadeName;
+
+int main( int argc, const char** argv )
+{
+    VideoCapture capture;
+    Mat frame, image;
+    string inputName;
+    bool tryflip;
+    CascadeClassifier cascade, nestedCascade;
+    double scale;
+
+    cv::CommandLineParser parser(argc, argv,
+        "{help h||}"
+        "{cascade|data/haarcascades/haarcascade_frontalface_alt.xml|}"
+        "{nested-cascade|data/haarcascades/haarcascade_eye_tree_eyeglasses.xml|}"
+        "{scale|1|}{try-flip||}{@filename||}"
+    );
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    cascadeName = parser.get<string>("cascade");
+    nestedCascadeName = parser.get<string>("nested-cascade");
+    scale = parser.get<double>("scale");
+    if (scale < 1)
+        scale = 1;
+    tryflip = parser.has("try-flip");
+    inputName = parser.get<string>("@filename");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 0;
+    }
+    if (!nestedCascade.load(samples::findFileOrKeep(nestedCascadeName)))
+        cerr << "WARNING: Could not load classifier cascade for nested objects" << endl;
+    if (!cascade.load(samples::findFile(cascadeName)))
+    {
+        cerr << "ERROR: Could not load classifier cascade" << endl;
+        help(argv);
+        return -1;
+    }
+    if( inputName.empty() || (isdigit(inputName[0]) && inputName.size() == 1) )
+    {
+        int camera = inputName.empty() ? 0 : inputName[0] - '0';
+        if(!capture.open(camera))
+        {
+            cout << "Capture from camera #" <<  camera << " didn't work" << endl;
+            return 1;
+        }
+    }
+    else if (!inputName.empty())
+    {
+        image = imread(samples::findFileOrKeep(inputName), IMREAD_COLOR);
+        if (image.empty())
+        {
+            if (!capture.open(samples::findFileOrKeep(inputName)))
+            {
+                cout << "Could not read " << inputName << endl;
+                return 1;
+            }
+        }
+    }
+    else
+    {
+        image = imread(samples::findFile("lena.jpg"), IMREAD_COLOR);
+        if (image.empty())
+        {
+            cout << "Couldn't read lena.jpg" << endl;
+            return 1;
+        }
+    }
+
+    if( capture.isOpened() )
+    {
+        cout << "Video capturing has been started ..." << endl;
+
+        for(;;)
+        {
+            capture >> frame;
+            if( frame.empty() )
+                break;
+
+            Mat frame1 = frame.clone();
+            detectAndDraw( frame1, cascade, nestedCascade, scale, tryflip );
+
+            char c = (char)waitKey(10);
+            if( c == 27 || c == 'q' || c == 'Q' )
+                break;
+        }
+    }
+    else
+    {
+        cout << "Detecting face(s) in " << inputName << endl;
+        if( !image.empty() )
+        {
+            detectAndDraw( image, cascade, nestedCascade, scale, tryflip );
+            waitKey(0);
+        }
+        else if( !inputName.empty() )
+        {
+            /* assume it is a text file containing the
+            list of the image filenames to be processed - one per line */
+            FILE* f = fopen( inputName.c_str(), "rt" );
+            if( f )
+            {
+                char buf[1000+1];
+                while( fgets( buf, 1000, f ) )
+                {
+                    int len = (int)strlen(buf);
+                    while( len > 0 && isspace(buf[len-1]) )
+                        len--;
+                    buf[len] = '\0';
+                    cout << "file " << buf << endl;
+                    image = imread( buf, 1 );
+                    if( !image.empty() )
+                    {
+                        detectAndDraw( image, cascade, nestedCascade, scale, tryflip );
+                        char c = (char)waitKey(0);
+                        if( c == 27 || c == 'q' || c == 'Q' )
+                            break;
+                    }
+                    else
+                    {
+                        cerr << "Aw snap, couldn't read image " << buf << endl;
+                    }
+                }
+                fclose(f);
+            }
+        }
+    }
+
+    return 0;
+}
+
+void detectAndDraw( Mat& img, CascadeClassifier& cascade,
+                    CascadeClassifier& nestedCascade,
+                    double scale, bool tryflip )
+{
+    double t = 0;
+    vector<Rect> faces, faces2;
+    const static Scalar colors[] =
+    {
+        Scalar(255,0,0),
+        Scalar(255,128,0),
+        Scalar(255,255,0),
+        Scalar(0,255,0),
+        Scalar(0,128,255),
+        Scalar(0,255,255),
+        Scalar(0,0,255),
+        Scalar(255,0,255)
+    };
+    Mat gray, smallImg;
+
+    cvtColor( img, gray, COLOR_BGR2GRAY );
+    double fx = 1 / scale;
+    resize( gray, smallImg, Size(), fx, fx, INTER_LINEAR_EXACT );
+    equalizeHist( smallImg, smallImg );
+
+    t = (double)getTickCount();
+    cascade.detectMultiScale( smallImg, faces,
+        1.1, 2, 0
+        //|CASCADE_FIND_BIGGEST_OBJECT
+        //|CASCADE_DO_ROUGH_SEARCH
+        |CASCADE_SCALE_IMAGE,
+        Size(30, 30) );
+    if( tryflip )
+    {
+        flip(smallImg, smallImg, 1);
+        cascade.detectMultiScale( smallImg, faces2,
+                                 1.1, 2, 0
+                                 //|CASCADE_FIND_BIGGEST_OBJECT
+                                 //|CASCADE_DO_ROUGH_SEARCH
+                                 |CASCADE_SCALE_IMAGE,
+                                 Size(30, 30) );
+        for( vector<Rect>::const_iterator r = faces2.begin(); r != faces2.end(); ++r )
+        {
+            faces.push_back(Rect(smallImg.cols - r->x - r->width, r->y, r->width, r->height));
+        }
+    }
+    t = (double)getTickCount() - t;
+    printf( "detection time = %g ms\n", t*1000/getTickFrequency());
+    for ( size_t i = 0; i < faces.size(); i++ )
+    {
+        Rect r = faces[i];
+        Mat smallImgROI;
+        vector<Rect> nestedObjects;
+        Point center;
+        Scalar color = colors[i%8];
+        int radius;
+
+        double aspect_ratio = (double)r.width/r.height;
+        if( 0.75 < aspect_ratio && aspect_ratio < 1.3 )
+        {
+            center.x = cvRound((r.x + r.width*0.5)*scale);
+            center.y = cvRound((r.y + r.height*0.5)*scale);
+            radius = cvRound((r.width + r.height)*0.25*scale);
+            circle( img, center, radius, color, 3, 8, 0 );
+        }
+        else
+            rectangle( img, Point(cvRound(r.x*scale), cvRound(r.y*scale)),
+                       Point(cvRound((r.x + r.width-1)*scale), cvRound((r.y + r.height-1)*scale)),
+                       color, 3, 8, 0);
+        if( nestedCascade.empty() )
+            continue;
+        smallImgROI = smallImg( r );
+        nestedCascade.detectMultiScale( smallImgROI, nestedObjects,
+            1.1, 2, 0
+            //|CASCADE_FIND_BIGGEST_OBJECT
+            //|CASCADE_DO_ROUGH_SEARCH
+            //|CASCADE_DO_CANNY_PRUNING
+            |CASCADE_SCALE_IMAGE,
+            Size(30, 30) );
+        for ( size_t j = 0; j < nestedObjects.size(); j++ )
+        {
+            Rect nr = nestedObjects[j];
+            center.x = cvRound((r.x + nr.x + nr.width*0.5)*scale);
+            center.y = cvRound((r.y + nr.y + nr.height*0.5)*scale);
+            radius = cvRound((nr.width + nr.height)*0.25*scale);
+            circle( img, center, radius, color, 3, 8, 0 );
+        }
+    }
+    imshow( "result", img );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/facial_features.cpp b/C++/opencv-4.7.0/samples/cpp/facial_features.cpp
new file mode 100644
index 00000000..1bb236c3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/facial_features.cpp
@@ -0,0 +1,215 @@
+/*
+ * Author: Samyak Datta (datta[dot]samyak[at]gmail.com)
+ *
+ * A program to detect facial feature points using
+ * Haarcascade classifiers for face, eyes, nose and mouth
+ *
+ */
+
+#include "opencv2/objdetect.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include <iostream>
+#include <cstdio>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+using namespace cv;
+
+// Functions for facial feature detection
+static void help(char** argv);
+static void detectFaces(Mat&, vector<Rect_<int> >&, string);
+static void detectEyes(Mat&, vector<Rect_<int> >&, string);
+static void detectNose(Mat&, vector<Rect_<int> >&, string);
+static void detectMouth(Mat&, vector<Rect_<int> >&, string);
+static void detectFacialFeaures(Mat&, const vector<Rect_<int> >, string, string, string);
+
+string input_image_path;
+string face_cascade_path, eye_cascade_path, nose_cascade_path, mouth_cascade_path;
+
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv,
+            "{eyes||}{nose||}{mouth||}{help h||}{@image||}{@facexml||}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    input_image_path = parser.get<string>("@image");
+    face_cascade_path = parser.get<string>("@facexml");
+    eye_cascade_path = parser.has("eyes") ? parser.get<string>("eyes") : "";
+    nose_cascade_path = parser.has("nose") ? parser.get<string>("nose") : "";
+    mouth_cascade_path = parser.has("mouth") ? parser.get<string>("mouth") : "";
+    if (input_image_path.empty() || face_cascade_path.empty())
+    {
+        cout << "IMAGE or FACE_CASCADE are not specified";
+        return 1;
+    }
+    // Load image and cascade classifier files
+    Mat image;
+    image = imread(samples::findFile(input_image_path));
+
+    // Detect faces and facial features
+    vector<Rect_<int> > faces;
+    detectFaces(image, faces, face_cascade_path);
+    detectFacialFeaures(image, faces, eye_cascade_path, nose_cascade_path, mouth_cascade_path);
+
+    imshow("Result", image);
+
+    waitKey(0);
+    return 0;
+}
+
+static void help(char** argv)
+{
+    cout << "\nThis file demonstrates facial feature points detection using Haarcascade classifiers.\n"
+        "The program detects a face and eyes, nose and mouth inside the face."
+        "The code has been tested on the Japanese Female Facial Expression (JAFFE) database and found"
+        "to give reasonably accurate results. \n";
+
+    cout << "\nUSAGE: " << argv[0] << " [IMAGE] [FACE_CASCADE] [OPTIONS]\n"
+        "IMAGE\n\tPath to the image of a face taken as input.\n"
+        "FACE_CASCSDE\n\t Path to a haarcascade classifier for face detection.\n"
+        "OPTIONS: \nThere are 3 options available which are described in detail. There must be a "
+        "space between the option and it's argument (All three options accept arguments).\n"
+        "\t-eyes=<eyes_cascade> : Specify the haarcascade classifier for eye detection.\n"
+        "\t-nose=<nose_cascade> : Specify the haarcascade classifier for nose detection.\n"
+        "\t-mouth=<mouth-cascade> : Specify the haarcascade classifier for mouth detection.\n";
+
+
+    cout << "EXAMPLE:\n"
+        "(1) " << argv[0] << " image.jpg face.xml -eyes=eyes.xml -mouth=mouth.xml\n"
+        "\tThis will detect the face, eyes and mouth in image.jpg.\n"
+        "(2) " << argv[0] << " image.jpg face.xml -nose=nose.xml\n"
+        "\tThis will detect the face and nose in image.jpg.\n"
+        "(3) " << argv[0] << " image.jpg face.xml\n"
+        "\tThis will detect only the face in image.jpg.\n";
+
+    cout << " \n\nThe classifiers for face and eyes can be downloaded from : "
+        " \nhttps://github.com/opencv/opencv/tree/4.x/data/haarcascades";
+
+    cout << "\n\nThe classifiers for nose and mouth can be downloaded from : "
+        " \nhttps://github.com/opencv/opencv_contrib/tree/4.x/modules/face/data/cascades\n";
+}
+
+static void detectFaces(Mat& img, vector<Rect_<int> >& faces, string cascade_path)
+{
+    CascadeClassifier face_cascade;
+    face_cascade.load(samples::findFile(cascade_path));
+
+    if (!face_cascade.empty())
+        face_cascade.detectMultiScale(img, faces, 1.15, 3, 0|CASCADE_SCALE_IMAGE, Size(30, 30));
+    return;
+}
+
+static void detectFacialFeaures(Mat& img, const vector<Rect_<int> > faces, string eye_cascade,
+        string nose_cascade, string mouth_cascade)
+{
+    for(unsigned int i = 0; i < faces.size(); ++i)
+    {
+        // Mark the bounding box enclosing the face
+        Rect face = faces[i];
+        rectangle(img, Point(face.x, face.y), Point(face.x+face.width, face.y+face.height),
+                Scalar(255, 0, 0), 1, 4);
+
+        // Eyes, nose and mouth will be detected inside the face (region of interest)
+        Mat ROI = img(Rect(face.x, face.y, face.width, face.height));
+
+        // Check if all features (eyes, nose and mouth) are being detected
+        bool is_full_detection = false;
+        if( (!eye_cascade.empty()) && (!nose_cascade.empty()) && (!mouth_cascade.empty()) )
+            is_full_detection = true;
+
+        // Detect eyes if classifier provided by the user
+        if(!eye_cascade.empty())
+        {
+            vector<Rect_<int> > eyes;
+            detectEyes(ROI, eyes, eye_cascade);
+
+            // Mark points corresponding to the centre of the eyes
+            for(unsigned int j = 0; j < eyes.size(); ++j)
+            {
+                Rect e = eyes[j];
+                circle(ROI, Point(e.x+e.width/2, e.y+e.height/2), 3, Scalar(0, 255, 0), -1, 8);
+                /* rectangle(ROI, Point(e.x, e.y), Point(e.x+e.width, e.y+e.height),
+                    Scalar(0, 255, 0), 1, 4); */
+            }
+        }
+
+        // Detect nose if classifier provided by the user
+        double nose_center_height = 0.0;
+        if(!nose_cascade.empty())
+        {
+            vector<Rect_<int> > nose;
+            detectNose(ROI, nose, nose_cascade);
+
+            // Mark points corresponding to the centre (tip) of the nose
+            for(unsigned int j = 0; j < nose.size(); ++j)
+            {
+                Rect n = nose[j];
+                circle(ROI, Point(n.x+n.width/2, n.y+n.height/2), 3, Scalar(0, 255, 0), -1, 8);
+                nose_center_height = (n.y + n.height/2);
+            }
+        }
+
+        // Detect mouth if classifier provided by the user
+        double mouth_center_height = 0.0;
+        if(!mouth_cascade.empty())
+        {
+            vector<Rect_<int> > mouth;
+            detectMouth(ROI, mouth, mouth_cascade);
+
+            for(unsigned int j = 0; j < mouth.size(); ++j)
+            {
+                Rect m = mouth[j];
+                mouth_center_height = (m.y + m.height/2);
+
+                // The mouth should lie below the nose
+                if( (is_full_detection) && (mouth_center_height > nose_center_height) )
+                {
+                    rectangle(ROI, Point(m.x, m.y), Point(m.x+m.width, m.y+m.height), Scalar(0, 255, 0), 1, 4);
+                }
+                else if( (is_full_detection) && (mouth_center_height <= nose_center_height) )
+                    continue;
+                else
+                    rectangle(ROI, Point(m.x, m.y), Point(m.x+m.width, m.y+m.height), Scalar(0, 255, 0), 1, 4);
+            }
+        }
+
+    }
+
+    return;
+}
+
+static void detectEyes(Mat& img, vector<Rect_<int> >& eyes, string cascade_path)
+{
+    CascadeClassifier eyes_cascade;
+    eyes_cascade.load(samples::findFile(cascade_path, !cascade_path.empty()));
+
+    if (!eyes_cascade.empty())
+        eyes_cascade.detectMultiScale(img, eyes, 1.20, 5, 0|CASCADE_SCALE_IMAGE, Size(30, 30));
+    return;
+}
+
+static void detectNose(Mat& img, vector<Rect_<int> >& nose, string cascade_path)
+{
+    CascadeClassifier nose_cascade;
+    nose_cascade.load(samples::findFile(cascade_path, !cascade_path.empty()));
+
+    if (!nose_cascade.empty())
+        nose_cascade.detectMultiScale(img, nose, 1.20, 5, 0|CASCADE_SCALE_IMAGE, Size(30, 30));
+    return;
+}
+
+static void detectMouth(Mat& img, vector<Rect_<int> >& mouth, string cascade_path)
+{
+    CascadeClassifier mouth_cascade;
+    mouth_cascade.load(samples::findFile(cascade_path, !cascade_path.empty()));
+
+    if (!mouth_cascade.empty())
+        mouth_cascade.detectMultiScale(img, mouth, 1.20, 5, 0|CASCADE_SCALE_IMAGE, Size(30, 30));
+    return;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/falsecolor.cpp b/C++/opencv-4.7.0/samples/cpp/falsecolor.cpp
new file mode 100644
index 00000000..bfe43a72
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/falsecolor.cpp
@@ -0,0 +1,110 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+enum MyShape{MyCIRCLE=0,MyRECTANGLE,MyELLIPSE};
+
+struct ParamColorMap {
+    int iColormap;
+    Mat img;
+};
+
+String winName="False color";
+static const String ColorMaps[] = { "Autumn", "Bone", "Jet", "Winter", "Rainbow", "Ocean", "Summer", "Spring",
+                                    "Cool", "HSV", "Pink", "Hot", "Parula", "Magma", "Inferno", "Plasma", "Viridis",
+                                    "Cividis", "Twilight", "Twilight Shifted", "Turbo", "Deep Green", "User defined (random)" };
+
+static void TrackColorMap(int x, void *r)
+{
+    ParamColorMap *p = (ParamColorMap*)r;
+    Mat dst;
+    p->iColormap= x;
+    if (x == COLORMAP_DEEPGREEN + 1)
+    {
+        Mat lutRND(256, 1, CV_8UC3);
+        randu(lutRND, Scalar(0, 0, 0), Scalar(255, 255, 255));
+        applyColorMap(p->img, dst, lutRND);
+    }
+    else
+        applyColorMap(p->img,dst,p->iColormap);
+
+    putText(dst, "Colormap : "+ColorMaps[p->iColormap], Point(10, 20), FONT_HERSHEY_SIMPLEX, 0.8, Scalar(255, 255, 255),2);
+    imshow(winName, dst);
+}
+
+
+static Mat DrawMyImage(int thickness,int nbShape)
+{
+    Mat img=Mat::zeros(500,256*thickness+100,CV_8UC1);
+    int offsetx = 50, offsety = 25;
+    int lineLength = 50;
+
+    for (int i=0;i<256;i++)
+        line(img,Point(thickness*i+ offsetx, offsety),Point(thickness*i+ offsetx, offsety+ lineLength),Scalar(i), thickness);
+    RNG r;
+    Point center;
+    int radius;
+    int width,height;
+    int angle;
+    Rect rc;
+
+    for (int i=1;i<=nbShape;i++)
+    {
+        int typeShape = r.uniform(MyCIRCLE, MyELLIPSE+1);
+        switch (typeShape) {
+        case MyCIRCLE:
+            center = Point(r.uniform(offsetx,img.cols- offsetx), r.uniform(offsety + lineLength, img.rows - offsety));
+            radius = r.uniform(1, min(offsetx, offsety));
+            circle(img,center,radius,Scalar(i),-1);
+            break;
+        case MyRECTANGLE:
+            center = Point(r.uniform(offsetx, img.cols - offsetx), r.uniform(offsety + lineLength, img.rows - offsety));
+            width = r.uniform(1, min(offsetx, offsety));
+            height = r.uniform(1, min(offsetx, offsety));
+            rc = Rect(center-Point(width ,height )/2, center + Point(width , height )/2);
+            rectangle(img,rc, Scalar(i), -1);
+            break;
+        case MyELLIPSE:
+            center = Point(r.uniform(offsetx, img.cols - offsetx), r.uniform(offsety + lineLength, img.rows - offsety));
+            width = r.uniform(1, min(offsetx, offsety));
+            height = r.uniform(1, min(offsetx, offsety));
+            angle = r.uniform(0, 180);
+            ellipse(img, center,Size(width/2,height/2),angle,0,360, Scalar(i), -1);
+            break;
+        }
+    }
+    return img;
+}
+
+int main(int argc, char** argv)
+{
+    cout << "This program demonstrates the use of applyColorMap function.\n\n";
+
+    ParamColorMap  p;
+    Mat img;
+
+    if (argc > 1)
+        img = imread(samples::findFile(argv[1]), IMREAD_GRAYSCALE);
+    else
+        img = DrawMyImage(2,256);
+
+    p.img=img;
+    p.iColormap=0;
+
+    imshow("Gray image",img);
+    namedWindow(winName);
+    createTrackbar("colormap", winName, NULL, COLORMAP_DEEPGREEN + 1, TrackColorMap, (void*)&p);
+    setTrackbarMin("colormap", winName, COLORMAP_AUTUMN);
+    setTrackbarMax("colormap", winName, COLORMAP_DEEPGREEN + 1);
+    setTrackbarPos("colormap", winName, COLORMAP_AUTUMN);
+
+    TrackColorMap(0, (void*)&p);
+
+    cout << "Press a key to exit" << endl;
+    waitKey(0);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/fback.cpp b/C++/opencv-4.7.0/samples/cpp/fback.cpp
new file mode 100644
index 00000000..74e55a5e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/fback.cpp
@@ -0,0 +1,68 @@
+#include "opencv2/video/tracking.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help(char** argv)
+{
+    cout <<
+            "\nThis program demonstrates dense optical flow algorithm by Gunnar Farneback\n"
+            "Mainly the function: calcOpticalFlowFarneback()\n"
+            "Call:\n"
+        <<  argv[0]
+        <<  "This reads from video camera 0\n" << endl;
+}
+static void drawOptFlowMap(const Mat& flow, Mat& cflowmap, int step,
+                    double, const Scalar& color)
+{
+    for(int y = 0; y < cflowmap.rows; y += step)
+        for(int x = 0; x < cflowmap.cols; x += step)
+        {
+            const Point2f& fxy = flow.at<Point2f>(y, x);
+            line(cflowmap, Point(x,y), Point(cvRound(x+fxy.x), cvRound(y+fxy.y)),
+                 color);
+            circle(cflowmap, Point(x,y), 2, color, -1);
+        }
+}
+
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv, "{help h||}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    VideoCapture cap(0);
+    help(argv);
+    if( !cap.isOpened() )
+        return -1;
+
+    Mat flow, cflow, frame;
+    UMat gray, prevgray, uflow;
+    namedWindow("flow", 1);
+
+    for(;;)
+    {
+        cap >> frame;
+        cvtColor(frame, gray, COLOR_BGR2GRAY);
+
+        if( !prevgray.empty() )
+        {
+            calcOpticalFlowFarneback(prevgray, gray, uflow, 0.5, 3, 15, 3, 5, 1.2, 0);
+            cvtColor(prevgray, cflow, COLOR_GRAY2BGR);
+            uflow.copyTo(flow);
+            drawOptFlowMap(flow, cflow, 16, 1.5, Scalar(0, 255, 0));
+            imshow("flow", cflow);
+        }
+        if(waitKey(30)>=0)
+            break;
+        std::swap(prevgray, gray);
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/ffilldemo.cpp b/C++/opencv-4.7.0/samples/cpp/ffilldemo.cpp
new file mode 100644
index 00000000..1f0f7371
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/ffilldemo.cpp
@@ -0,0 +1,177 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help(char** argv)
+{
+    cout << "\nThis program demonstrated the floodFill() function\n"
+            "Call:\n"
+        <<  argv[0]
+        <<  " [image_name -- Default: fruits.jpg]\n" << endl;
+
+    cout << "Hot keys: \n"
+            "\tESC - quit the program\n"
+            "\tc - switch color/grayscale mode\n"
+            "\tm - switch mask mode\n"
+            "\tr - restore the original image\n"
+            "\ts - use null-range floodfill\n"
+            "\tf - use gradient floodfill with fixed(absolute) range\n"
+            "\tg - use gradient floodfill with floating(relative) range\n"
+            "\t4 - use 4-connectivity mode\n"
+            "\t8 - use 8-connectivity mode\n" << endl;
+}
+
+Mat image0, image, gray, mask;
+int ffillMode = 1;
+int loDiff = 20, upDiff = 20;
+int connectivity = 4;
+int isColor = true;
+bool useMask = false;
+int newMaskVal = 255;
+
+static void onMouse( int event, int x, int y, int, void* )
+{
+    if( event != EVENT_LBUTTONDOWN )
+        return;
+
+    Point seed = Point(x,y);
+    int lo = ffillMode == 0 ? 0 : loDiff;
+    int up = ffillMode == 0 ? 0 : upDiff;
+    int flags = connectivity + (newMaskVal << 8) +
+                (ffillMode == 1 ? FLOODFILL_FIXED_RANGE : 0);
+    int b = (unsigned)theRNG() & 255;
+    int g = (unsigned)theRNG() & 255;
+    int r = (unsigned)theRNG() & 255;
+    Rect ccomp;
+
+    Scalar newVal = isColor ? Scalar(b, g, r) : Scalar(r*0.299 + g*0.587 + b*0.114);
+    Mat dst = isColor ? image : gray;
+    int area;
+
+    if( useMask )
+    {
+        threshold(mask, mask, 1, 128, THRESH_BINARY);
+        area = floodFill(dst, mask, seed, newVal, &ccomp, Scalar(lo, lo, lo),
+                  Scalar(up, up, up), flags);
+        imshow( "mask", mask );
+    }
+    else
+    {
+        area = floodFill(dst, seed, newVal, &ccomp, Scalar(lo, lo, lo),
+                  Scalar(up, up, up), flags);
+    }
+
+    imshow("image", dst);
+    cout << area << " pixels were repainted\n";
+}
+
+
+int main( int argc, char** argv )
+{
+    cv::CommandLineParser parser (argc, argv,
+        "{help h | | show help message}{@image|fruits.jpg| input image}"
+    );
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    string filename = parser.get<string>("@image");
+    image0 = imread(samples::findFile(filename), 1);
+
+    if( image0.empty() )
+    {
+        cout << "Image empty\n";
+        parser.printMessage();
+        return 0;
+    }
+    help(argv);
+    image0.copyTo(image);
+    cvtColor(image0, gray, COLOR_BGR2GRAY);
+    mask.create(image0.rows+2, image0.cols+2, CV_8UC1);
+
+    namedWindow( "image", 0 );
+    createTrackbar( "lo_diff", "image", &loDiff, 255, 0 );
+    createTrackbar( "up_diff", "image", &upDiff, 255, 0 );
+
+    setMouseCallback( "image", onMouse, 0 );
+
+    for(;;)
+    {
+        imshow("image", isColor ? image : gray);
+
+        char c = (char)waitKey(0);
+        if( c == 27 )
+        {
+            cout << "Exiting ...\n";
+            break;
+        }
+        switch( c )
+        {
+        case 'c':
+            if( isColor )
+            {
+                cout << "Grayscale mode is set\n";
+                cvtColor(image0, gray, COLOR_BGR2GRAY);
+                mask = Scalar::all(0);
+                isColor = false;
+            }
+            else
+            {
+                cout << "Color mode is set\n";
+                image0.copyTo(image);
+                mask = Scalar::all(0);
+                isColor = true;
+            }
+            break;
+        case 'm':
+            if( useMask )
+            {
+                destroyWindow( "mask" );
+                useMask = false;
+            }
+            else
+            {
+                namedWindow( "mask", 0 );
+                mask = Scalar::all(0);
+                imshow("mask", mask);
+                useMask = true;
+            }
+            break;
+        case 'r':
+            cout << "Original image is restored\n";
+            image0.copyTo(image);
+            cvtColor(image, gray, COLOR_BGR2GRAY);
+            mask = Scalar::all(0);
+            break;
+        case 's':
+            cout << "Simple floodfill mode is set\n";
+            ffillMode = 0;
+            break;
+        case 'f':
+            cout << "Fixed Range floodfill mode is set\n";
+            ffillMode = 1;
+            break;
+        case 'g':
+            cout << "Gradient (floating range) floodfill mode is set\n";
+            ffillMode = 2;
+            break;
+        case '4':
+            cout << "4-connectivity mode is set\n";
+            connectivity = 4;
+            break;
+        case '8':
+            cout << "8-connectivity mode is set\n";
+            connectivity = 8;
+            break;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/filestorage.cpp b/C++/opencv-4.7.0/samples/cpp/filestorage.cpp
new file mode 100644
index 00000000..e0b462bb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/filestorage.cpp
@@ -0,0 +1,193 @@
+/*
+ * filestorage_sample demonstrate the usage of the opencv serialization functionality
+ */
+
+#include "opencv2/core.hpp"
+#include <iostream>
+#include <string>
+
+using std::string;
+using std::cout;
+using std::endl;
+using std::cerr;
+using std::ostream;
+using namespace cv;
+
+static void help(char** av)
+{
+  cout << "\nfilestorage_sample demonstrate the usage of the opencv serialization functionality.\n"
+      << "usage:\n"
+      <<  av[0] << " outputfile.yml.gz\n"
+      << "\n   outputfile above can have many different extensions, see below."
+      << "\nThis program demonstrates the use of FileStorage for serialization, that is in use << and >>  in OpenCV\n"
+      << "For example, how to create a class and have it serialize, but also how to use it to read and write matrices.\n"
+      << "FileStorage allows you to serialize to various formats specified by the file end type."
+          << "\nYou should try using different file extensions.(e.g. yaml yml xml xml.gz yaml.gz etc...)\n" << endl;
+}
+
+struct MyData
+{
+  MyData() :
+    A(0), X(0), id()
+  {
+  }
+  explicit MyData(int) :
+    A(97), X(CV_PI), id("mydata1234")
+  {
+  }
+  int A;
+  double X;
+  string id;
+  void write(FileStorage& fs) const //Write serialization for this class
+  {
+    fs << "{" << "A" << A << "X" << X << "id" << id << "}";
+  }
+  void read(const FileNode& node)  //Read serialization for this class
+  {
+
+    A = (int)node["A"];
+    X = (double)node["X"];
+    id = (string)node["id"];
+  }
+};
+
+//These write and read functions must exist as per the inline functions in operations.hpp
+static void write(FileStorage& fs, const std::string&, const MyData& x){
+  x.write(fs);
+}
+static void read(const FileNode& node, MyData& x, const MyData& default_value = MyData()){
+  if(node.empty())
+    x = default_value;
+  else
+    x.read(node);
+}
+
+static ostream& operator<<(ostream& out, const MyData& m){
+  out << "{ id = " << m.id << ", ";
+  out << "X = " << m.X << ", ";
+  out << "A = " << m.A << "}";
+  return out;
+}
+int main(int ac, char** av)
+{
+  cv::CommandLineParser parser(ac, av,
+    "{@input||}{help h ||}"
+  );
+  if (parser.has("help"))
+  {
+    help(av);
+    return 0;
+  }
+  string filename = parser.get<string>("@input");
+  if (filename.empty())
+  {
+    help(av);
+    return 1;
+  }
+
+  //write
+  {
+    FileStorage fs(filename, FileStorage::WRITE);
+
+    cout << "writing images\n";
+    fs << "images" << "[";
+
+    fs << "image1.jpg" << "myfi.png" << "baboon.jpg";
+    cout << "image1.jpg" << " myfi.png" << " baboon.jpg" << endl;
+
+    fs << "]";
+
+    cout << "writing mats\n";
+    Mat R =Mat_<double>::eye(3, 3),T = Mat_<double>::zeros(3, 1);
+    cout << "R = " << R << "\n";
+    cout << "T = " << T << "\n";
+    fs << "R" << R;
+    fs << "T" << T;
+
+    cout << "writing MyData struct\n";
+    MyData m(1);
+    fs << "mdata" << m;
+    cout << m << endl;
+  }
+
+  //read
+  {
+    FileStorage fs(filename, FileStorage::READ);
+
+    if (!fs.isOpened())
+    {
+      cerr << "failed to open " << filename << endl;
+      help(av);
+      return 1;
+    }
+
+    FileNode n = fs["images"];
+    if (n.type() != FileNode::SEQ)
+    {
+      cerr << "images is not a sequence! FAIL" << endl;
+      return 1;
+    }
+
+    cout << "reading images\n";
+    FileNodeIterator it = n.begin(), it_end = n.end();
+    for (; it != it_end; ++it)
+    {
+      cout << (string)*it << "\n";
+    }
+
+    Mat R, T;
+    cout << "reading R and T" << endl;
+
+    fs["R"] >> R;
+    fs["T"] >> T;
+
+    cout << "R = " << R << "\n";
+    cout << "T = " << T << endl;
+
+    MyData m;
+    fs["mdata"] >> m;
+
+    cout << "read mdata\n";
+    cout << m << endl;
+
+    cout << "attempting to read mdata_b\n";   //Show default behavior for empty matrix
+    fs["mdata_b"] >> m;
+    cout << "read mdata_b\n";
+    cout << m << endl;
+
+  }
+
+  cout << "Try opening " << filename << " to see the serialized data." << endl << endl;
+
+  //read from string
+  {
+    cout << "Read data from string\n";
+    string dataString =
+        "%YAML:1.0\n"
+        "mdata:\n"
+        "   A: 97\n"
+        "   X: 3.1415926535897931e+00\n"
+        "   id: mydata1234\n";
+    MyData m;
+    FileStorage fs(dataString, FileStorage::READ | FileStorage::MEMORY);
+    cout << "attempting to read mdata_b from string\n";   //Show default behavior for empty matrix
+    fs["mdata"] >> m;
+    cout << "read mdata\n";
+    cout << m << endl;
+  }
+
+  //write to string
+  {
+    cout << "Write data to string\n";
+    FileStorage fs(filename, FileStorage::WRITE | FileStorage::MEMORY | FileStorage::FORMAT_YAML);
+
+    cout << "writing MyData struct\n";
+    MyData m(1);
+    fs << "mdata" << m;
+    cout << m << endl;
+    string createdString = fs.releaseAndGetString();
+    cout << "Created string:\n" << createdString << "\n";
+  }
+
+  return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/fitellipse.cpp b/C++/opencv-4.7.0/samples/cpp/fitellipse.cpp
new file mode 100644
index 00000000..f136b9c4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/fitellipse.cpp
@@ -0,0 +1,315 @@
+/********************************************************************************
+ *
+ *
+ *  This program is demonstration for ellipse fitting. Program finds
+ *  contours and approximate it by ellipses using three methods.
+ *  1: OpenCV's original method fitEllipse which implements Fitzgibbon 1995 method.
+ *  2: The Approximate Mean Square (AMS) method fitEllipseAMS  proposed by Taubin 1991
+ *  3: The Direct least square (Direct) method fitEllipseDirect proposed by Fitzgibbon1999.
+ *
+ *  Trackbar specify threshold parameter.
+ *
+ *  White lines is contours/input points and the true ellipse used to generate the data.
+ *  1: Blue lines is fitting ellipses using openCV's original method.
+ *  2: Green lines is fitting ellipses using the AMS method.
+ *  3: Red lines is fitting ellipses using the Direct method.
+ *
+ *
+ *  Original Author:  Denis Burenkov
+ *  AMS and Direct Methods Author:  Jasper Shemilt
+ *
+ *
+ ********************************************************************************/
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+class canvas{
+public:
+    bool setupQ;
+    cv::Point origin;
+    cv::Point corner;
+    int minDims,maxDims;
+    double scale;
+    int rows, cols;
+    cv::Mat img;
+
+    void init(int minD, int maxD){
+        // Initialise the canvas with minimum and maximum rows and column sizes.
+        minDims = minD; maxDims = maxD;
+        origin = cv::Point(0,0);
+        corner = cv::Point(0,0);
+        scale = 1.0;
+        rows = 0;
+        cols = 0;
+        setupQ = false;
+    }
+
+    void stretch(cv::Point2f min, cv::Point2f max){
+        // Stretch the canvas to include the points min and max.
+        if(setupQ){
+            if(corner.x < max.x){corner.x = (int)(max.x + 1.0);};
+            if(corner.y < max.y){corner.y = (int)(max.y + 1.0);};
+            if(origin.x > min.x){origin.x = (int) min.x;};
+            if(origin.y > min.y){origin.y = (int) min.y;};
+        } else {
+            origin = cv::Point((int)min.x, (int)min.y);
+            corner = cv::Point((int)(max.x + 1.0), (int)(max.y + 1.0));
+        }
+
+        int c = (int)(scale*((corner.x + 1.0) - origin.x));
+        if(c<minDims){
+            scale = scale * (double)minDims/(double)c;
+        } else {
+            if(c>maxDims){
+                scale = scale * (double)maxDims/(double)c;
+            }
+        }
+        int r = (int)(scale*((corner.y + 1.0) - origin.y));
+        if(r<minDims){
+            scale = scale * (double)minDims/(double)r;
+        } else {
+            if(r>maxDims){
+                scale = scale * (double)maxDims/(double)r;
+            }
+        }
+        cols = (int)(scale*((corner.x + 1.0) - origin.x));
+        rows = (int)(scale*((corner.y + 1.0) - origin.y));
+        setupQ = true;
+    }
+
+    void stretch(vector<Point2f> pts)
+    {   // Stretch the canvas so all the points pts are on the canvas.
+        cv::Point2f min = pts[0];
+        cv::Point2f max = pts[0];
+        for(size_t i=1; i < pts.size(); i++){
+            Point2f pnt = pts[i];
+            if(max.x < pnt.x){max.x = pnt.x;};
+            if(max.y < pnt.y){max.y = pnt.y;};
+            if(min.x > pnt.x){min.x = pnt.x;};
+            if(min.y > pnt.y){min.y = pnt.y;};
+        };
+        stretch(min, max);
+    }
+
+    void stretch(cv::RotatedRect box)
+    {   // Stretch the canvas so that the rectangle box is on the canvas.
+        cv::Point2f min = box.center;
+        cv::Point2f max = box.center;
+        cv::Point2f vtx[4];
+        box.points(vtx);
+        for( int i = 0; i < 4; i++ ){
+            cv::Point2f pnt = vtx[i];
+            if(max.x < pnt.x){max.x = pnt.x;};
+            if(max.y < pnt.y){max.y = pnt.y;};
+            if(min.x > pnt.x){min.x = pnt.x;};
+            if(min.y > pnt.y){min.y = pnt.y;};
+        }
+        stretch(min, max);
+    }
+
+    void drawEllipseWithBox(cv::RotatedRect box, cv::Scalar color, int lineThickness)
+    {
+        if(img.empty()){
+            stretch(box);
+            img = cv::Mat::zeros(rows,cols,CV_8UC3);
+        }
+
+        box.center = scale * cv::Point2f(box.center.x - origin.x, box.center.y - origin.y);
+        box.size.width  = (float)(scale * box.size.width);
+        box.size.height = (float)(scale * box.size.height);
+
+        ellipse(img, box, color, lineThickness, LINE_AA);
+
+        Point2f vtx[4];
+        box.points(vtx);
+        for( int j = 0; j < 4; j++ ){
+            line(img, vtx[j], vtx[(j+1)%4], color, lineThickness, LINE_AA);
+        }
+    }
+
+    void drawPoints(vector<Point2f> pts, cv::Scalar color)
+    {
+        if(img.empty()){
+            stretch(pts);
+            img = cv::Mat::zeros(rows,cols,CV_8UC3);
+        }
+        for(size_t i=0; i < pts.size(); i++){
+            Point2f pnt = scale * cv::Point2f(pts[i].x - origin.x, pts[i].y - origin.y);
+            img.at<cv::Vec3b>(int(pnt.y), int(pnt.x))[0] = (uchar)color[0];
+            img.at<cv::Vec3b>(int(pnt.y), int(pnt.x))[1] = (uchar)color[1];
+            img.at<cv::Vec3b>(int(pnt.y), int(pnt.x))[2] = (uchar)color[2];
+        };
+    }
+
+    void drawLabels( std::vector<std::string> text, std::vector<cv::Scalar> colors)
+    {
+        if(img.empty()){
+            img = cv::Mat::zeros(rows,cols,CV_8UC3);
+        }
+        int vPos = 0;
+        for (size_t i=0; i < text.size(); i++) {
+            cv::Scalar color = colors[i];
+            std::string txt = text[i];
+            Size textsize = getTextSize(txt, FONT_HERSHEY_COMPLEX, 1, 1, 0);
+            vPos += (int)(1.3 * textsize.height);
+            Point org((img.cols - textsize.width), vPos);
+            cv::putText(img, txt, org, FONT_HERSHEY_COMPLEX, 1, color, 1, LINE_8);
+        }
+    }
+
+};
+
+static void help(char** argv)
+{
+    cout << "\nThis program is demonstration for ellipse fitting. The program finds\n"
+            "contours and approximate it by ellipses. Three methods are used to find the \n"
+            "elliptical fits: fitEllipse, fitEllipseAMS and fitEllipseDirect.\n"
+            "Call:\n"
+        << argv[0] << " [image_name -- Default ellipses.jpg]\n" << endl;
+}
+
+int sliderPos = 70;
+
+Mat image;
+
+bool fitEllipseQ, fitEllipseAMSQ, fitEllipseDirectQ;
+cv::Scalar fitEllipseColor       = Scalar(255,  0,  0);
+cv::Scalar fitEllipseAMSColor    = Scalar(  0,255,  0);
+cv::Scalar fitEllipseDirectColor = Scalar(  0,  0,255);
+cv::Scalar fitEllipseTrueColor   = Scalar(255,255,255);
+
+void processImage(int, void*);
+
+int main( int argc, char** argv )
+{
+    fitEllipseQ       = true;
+    fitEllipseAMSQ    = true;
+    fitEllipseDirectQ = true;
+
+    cv::CommandLineParser parser(argc, argv,"{help h||}{@image|ellipses.jpg|}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    string filename = parser.get<string>("@image");
+    image = imread(samples::findFile(filename), 0);
+    if( image.empty() )
+    {
+        cout << "Couldn't open image " << filename << "\n";
+        return 0;
+    }
+
+    imshow("source", image);
+    namedWindow("result", WINDOW_NORMAL );
+
+    // Create toolbars. HighGUI use.
+    createTrackbar( "threshold", "result", &sliderPos, 255, processImage );
+
+    processImage(0, 0);
+
+    // Wait for a key stroke; the same function arranges events processing
+    waitKey();
+    return 0;
+}
+
+// Define trackbar callback function. This function finds contours,
+// draws them, and approximates by ellipses.
+void processImage(int /*h*/, void*)
+{
+    RotatedRect box, boxAMS, boxDirect;
+    vector<vector<Point> > contours;
+    Mat bimage = image >= sliderPos;
+
+    findContours(bimage, contours, RETR_LIST, CHAIN_APPROX_NONE);
+
+    canvas paper;
+    paper.init(int(0.8*MIN(bimage.rows, bimage.cols)), int(1.2*MAX(bimage.rows, bimage.cols)));
+    paper.stretch(cv::Point2f(0.0f, 0.0f), cv::Point2f((float)(bimage.cols+2.0), (float)(bimage.rows+2.0)));
+
+    std::vector<std::string> text;
+    std::vector<cv::Scalar> color;
+
+    if (fitEllipseQ) {
+        text.push_back("OpenCV");
+        color.push_back(fitEllipseColor);
+    }
+    if (fitEllipseAMSQ) {
+        text.push_back("AMS");
+        color.push_back(fitEllipseAMSColor);
+    }
+    if (fitEllipseDirectQ) {
+        text.push_back("Direct");
+        color.push_back(fitEllipseDirectColor);
+    }
+    paper.drawLabels(text, color);
+
+    int margin = 2;
+    vector< vector<Point2f> > points;
+    for(size_t i = 0; i < contours.size(); i++)
+    {
+        size_t count = contours[i].size();
+        if( count < 6 )
+            continue;
+
+        Mat pointsf;
+        Mat(contours[i]).convertTo(pointsf, CV_32F);
+
+        vector<Point2f>pts;
+        for (int j = 0; j < pointsf.rows; j++) {
+            Point2f pnt = Point2f(pointsf.at<float>(j,0), pointsf.at<float>(j,1));
+            if ((pnt.x > margin && pnt.y > margin && pnt.x < bimage.cols-margin && pnt.y < bimage.rows-margin)) {
+                if(j%20==0){
+                    pts.push_back(pnt);
+                }
+            }
+        }
+        points.push_back(pts);
+    }
+
+    for(size_t i = 0; i < points.size(); i++)
+    {
+        vector<Point2f> pts = points[i];
+
+        if (pts.size()<=5) {
+            continue;
+        }
+        if (fitEllipseQ) {
+            box = fitEllipse(pts);
+            if( MAX(box.size.width, box.size.height) > MIN(box.size.width, box.size.height)*30 ||
+               MAX(box.size.width, box.size.height) <= 0 ||
+               MIN(box.size.width, box.size.height) <= 0){continue;};
+        }
+        if (fitEllipseAMSQ) {
+            boxAMS = fitEllipseAMS(pts);
+            if( MAX(boxAMS.size.width, boxAMS.size.height) > MIN(boxAMS.size.width, boxAMS.size.height)*30 ||
+               MAX(box.size.width, box.size.height) <= 0 ||
+               MIN(box.size.width, box.size.height) <= 0){continue;};
+        }
+        if (fitEllipseDirectQ) {
+            boxDirect = fitEllipseDirect(pts);
+            if( MAX(boxDirect.size.width, boxDirect.size.height) > MIN(boxDirect.size.width, boxDirect.size.height)*30 ||
+               MAX(box.size.width, box.size.height) <= 0 ||
+               MIN(box.size.width, box.size.height) <= 0 ){continue;};
+        }
+
+        if (fitEllipseQ) {
+            paper.drawEllipseWithBox(box, fitEllipseColor, 3);
+        }
+        if (fitEllipseAMSQ) {
+            paper.drawEllipseWithBox(boxAMS, fitEllipseAMSColor, 2);
+        }
+        if (fitEllipseDirectQ) {
+            paper.drawEllipseWithBox(boxDirect, fitEllipseDirectColor, 1);
+        }
+
+        paper.drawPoints(pts, cv::Scalar(255,255,255));
+    }
+
+    imshow("result", paper.img);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/flann_search_dataset.cpp b/C++/opencv-4.7.0/samples/cpp/flann_search_dataset.cpp
new file mode 100644
index 00000000..01ef93f8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/flann_search_dataset.cpp
@@ -0,0 +1,250 @@
+// flann_search_dataset.cpp
+// Naive program to search a query picture in a dataset illustrating usage of FLANN
+
+#include <iostream>
+#include <vector>
+#include "opencv2/core.hpp"
+#include "opencv2/core/utils/filesystem.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/flann.hpp"
+
+using namespace cv;
+using std::cout;
+using std::endl;
+
+#define _ORB_
+
+const char* keys =
+    "{ help h | | Print help message. }"
+    "{ dataset | | Path to the images folder used as dataset. }"
+    "{ image |   | Path to the image to search for in the dataset. }"
+    "{ save |    | Path and filename where to save the flann structure to. }"
+    "{ load |    | Path and filename where to load the flann structure from. }";
+
+struct img_info {
+    int img_index;
+    unsigned int nbr_of_matches;
+
+    img_info(int _img_index, unsigned int _nbr_of_matches)
+        : img_index(_img_index)
+        , nbr_of_matches(_nbr_of_matches)
+    {}
+};
+
+
+int main( int argc, char* argv[] )
+{
+    //-- Test the program options
+    CommandLineParser parser( argc, argv, keys );
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return -1;
+    }
+
+    const cv::String img_path = parser.get<String>("image");
+    Mat img = imread( samples::findFile( img_path ), IMREAD_GRAYSCALE );
+    if (img.empty() )
+    {
+        cout << "Could not open the image "<< img_path << endl;
+        return -1;
+    }
+
+    const cv::String db_path = parser.get<String>("dataset");
+    if (!utils::fs::isDirectory(db_path))
+    {
+        cout << "Dataset folder "<< db_path.c_str() <<" doesn't exist!" << endl;
+        return -1;
+    }
+
+    const cv::String load_db_path = parser.get<String>("load");
+    if ((load_db_path != String()) && (!utils::fs::exists(load_db_path)))
+    {
+        cout << "File " << load_db_path.c_str()
+             << " where to load the flann structure from doesn't exist!" << endl;
+        return -1;
+    }
+
+    const cv::String save_db_path = parser.get<String>("save");
+
+    //-- Step 1: Detect the keypoints using a detector, compute the descriptors
+    //   in the folder containing the images of the dataset
+#ifdef _SIFT_
+    int minHessian = 400;
+    Ptr<Feature2D> detector = SIFT::create( minHessian );
+#elif defined(_ORB_)
+    Ptr<Feature2D> detector = ORB::create();
+#else
+    cout << "Missing or unknown defined descriptor. "
+            "Only SIFT and ORB are currently interfaced here" << endl;
+    return -1;
+#endif
+
+    std::vector<KeyPoint> db_keypoints;
+    Mat db_descriptors;
+    std::vector<unsigned int> db_images_indice_range; //store the range of indices per image
+    std::vector<int> db_indice_2_image_lut;           //match descriptor indice to its image
+
+    db_images_indice_range.push_back(0);
+    std::vector<cv::String> files;
+    utils::fs::glob(db_path, cv::String(), files);
+    for (std::vector<cv::String>::iterator itr = files.begin(); itr != files.end(); ++itr)
+    {
+        Mat tmp_img = imread( *itr, IMREAD_GRAYSCALE );
+        if (!tmp_img.empty())
+        {
+            std::vector<KeyPoint> kpts;
+            Mat descriptors;
+            detector->detectAndCompute( tmp_img, noArray(), kpts, descriptors );
+
+            db_keypoints.insert( db_keypoints.end(), kpts.begin(), kpts.end() );
+            db_descriptors.push_back( descriptors );
+            db_images_indice_range.push_back( db_images_indice_range.back()
+                                              + static_cast<unsigned int>(kpts.size()) );
+        }
+    }
+
+    //-- Set the LUT
+    db_indice_2_image_lut.resize( db_images_indice_range.back() );
+    const int nbr_of_imgs = static_cast<int>( db_images_indice_range.size()-1 );
+    for (int i = 0; i < nbr_of_imgs; ++i)
+    {
+        const unsigned int first_indice = db_images_indice_range[i];
+        const unsigned int last_indice = db_images_indice_range[i+1];
+        std::fill( db_indice_2_image_lut.begin() + first_indice,
+                   db_indice_2_image_lut.begin() + last_indice,
+                   i );
+    }
+
+    //-- Step 2: build the structure storing the descriptors
+#if defined(_SIFT_)
+    cv::Ptr<flann::GenericIndex<cvflann::L2<float> > > index;
+    if (load_db_path != String())
+        index = cv::makePtr<flann::GenericIndex<cvflann::L2<float> > >(db_descriptors,
+                                                             cvflann::SavedIndexParams(load_db_path));
+    else
+        index = cv::makePtr<flann::GenericIndex<cvflann::L2<float> > >(db_descriptors,
+                                                             cvflann::KDTreeIndexParams(4));
+
+#elif defined(_ORB_)
+    cv::Ptr<flann::GenericIndex<cvflann::Hamming<unsigned char> > > index;
+    if (load_db_path != String())
+        index  = cv::makePtr<flann::GenericIndex<cvflann::Hamming<unsigned char> > >
+                (db_descriptors, cvflann::SavedIndexParams(load_db_path));
+    else
+        index  = cv::makePtr<flann::GenericIndex<cvflann::Hamming<unsigned char> > >
+                (db_descriptors, cvflann::LshIndexParams());
+#else
+    cout<< "Descriptor not listed. Set the proper FLANN distance for this descriptor" <<endl;
+    return -1;
+#endif
+    if (save_db_path != String())
+        index->save(save_db_path);
+
+
+    // Return if no query image was set
+    if (img_path == String())
+        return 0;
+
+    //-- Detect the keypoints and compute the descriptors for the query image
+    std::vector<KeyPoint> img_keypoints;
+    Mat img_descriptors;
+    detector->detectAndCompute( img, noArray(), img_keypoints, img_descriptors );
+
+
+    //-- Step 3: retrieve the descriptors in the dataset matching the ones of the query image
+    // /!\ knnSearch doesn't follow OpenCV standards by not initialising empty Mat properties
+    const int knn = 2;
+    Mat indices(img_descriptors.rows, knn, CV_32S);
+#if defined(_SIFT_)
+#define DIST_TYPE float
+    Mat dists(img_descriptors.rows, knn, CV_32F);
+#elif defined(_ORB_)
+#define DIST_TYPE int
+    Mat dists(img_descriptors.rows, knn, CV_32S);
+#endif
+    index->knnSearch( img_descriptors, indices, dists, knn, cvflann::SearchParams(32) );
+
+    //-- Filter matches using the Lowe's ratio test
+    const float ratio_thresh = 0.7f;
+    std::vector<DMatch> good_matches; //contains
+    std::vector<unsigned int> matches_per_img_histogram( nbr_of_imgs, 0 );
+    for (int i = 0; i < dists.rows; ++i)
+    {
+        if (dists.at<DIST_TYPE>(i,0) < ratio_thresh * dists.at<DIST_TYPE>(i,1))
+        {
+            const int indice_in_db = indices.at<int>(i,0);
+            DMatch dmatch(i, indice_in_db, db_indice_2_image_lut[indice_in_db],
+                          static_cast<float>(dists.at<DIST_TYPE>(i,0)));
+            good_matches.push_back( dmatch );
+            matches_per_img_histogram[ db_indice_2_image_lut[indice_in_db] ]++;
+        }
+    }
+
+
+    //-- Step 4: find the dataset image with the highest proportion of matches
+    std::multimap<float, img_info> images_infos;
+    for (int i = 0; i < nbr_of_imgs; ++i)
+    {
+        const unsigned int nbr_of_matches = matches_per_img_histogram[i];
+        if (nbr_of_matches < 4) //we need at leat 4 points for a homography
+            continue;
+
+        const unsigned int nbr_of_kpts = db_images_indice_range[i+1] - db_images_indice_range[i];
+        const float inverse_proportion_of_retrieved_kpts =
+                static_cast<float>(nbr_of_kpts) / static_cast<float>(nbr_of_matches);
+
+        img_info info(i, nbr_of_matches);
+        images_infos.insert( std::pair<float,img_info>(inverse_proportion_of_retrieved_kpts,
+                                                       info) );
+    }
+
+    if (images_infos.begin() == images_infos.end())
+    {
+        cout<<"No good match could be found."<<endl;
+        return 0;
+    }
+
+    //-- if there are several images with a similar proportion of matches,
+    // select the one with the highest number of matches weighted by the
+    // squared ratio of proportions
+    const float best_matches_proportion = images_infos.begin()->first;
+    float new_matches_proportion = best_matches_proportion;
+    img_info best_img = images_infos.begin()->second;
+
+    std::multimap<float, img_info>::iterator it = images_infos.begin();
+    ++it;
+    while ((it!=images_infos.end()) && (it->first < 1.1*best_matches_proportion))
+    {
+        const float ratio = new_matches_proportion / it->first;
+        if( it->second.nbr_of_matches * (ratio * ratio) > best_img.nbr_of_matches)
+        {
+            new_matches_proportion = it->first;
+            best_img = it->second;
+        }
+        ++it;
+    }
+
+    //-- Step 5: filter goodmatches that belong to the best image match of the dataset
+    std::vector<DMatch> filtered_good_matches;
+    for (std::vector<DMatch>::iterator itr(good_matches.begin()); itr != good_matches.end(); ++itr)
+    {
+        if (itr->imgIdx == best_img.img_index)
+            filtered_good_matches.push_back(*itr);
+    }
+
+    //-- Retrieve the best image match from the dataset
+    Mat db_img = imread( files[best_img.img_index], IMREAD_GRAYSCALE );
+
+    //-- Draw matches
+    Mat img_matches;
+    drawMatches( img, img_keypoints, db_img, db_keypoints, filtered_good_matches, img_matches, Scalar::all(-1),
+                 Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
+
+    //-- Show detected matches
+    imshow("Good Matches", img_matches );
+    waitKey();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/grabcut.cpp b/C++/opencv-4.7.0/samples/cpp/grabcut.cpp
new file mode 100644
index 00000000..25492166
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/grabcut.cpp
@@ -0,0 +1,350 @@
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static void help(char** argv)
+{
+    cout << "\nThis program demonstrates GrabCut segmentation -- select an object in a region\n"
+            "and then grabcut will attempt to segment it out.\n"
+            "Call:\n"
+        <<  argv[0] << " <image_name>\n"
+            "\nSelect a rectangular area around the object you want to segment\n" <<
+            "\nHot keys: \n"
+            "\tESC - quit the program\n"
+            "\tr - restore the original image\n"
+            "\tn - next iteration\n"
+            "\n"
+            "\tleft mouse button - set rectangle\n"
+            "\n"
+            "\tCTRL+left mouse button - set GC_BGD pixels\n"
+            "\tSHIFT+left mouse button - set GC_FGD pixels\n"
+            "\n"
+            "\tCTRL+right mouse button - set GC_PR_BGD pixels\n"
+            "\tSHIFT+right mouse button - set GC_PR_FGD pixels\n" << endl;
+}
+
+const Scalar RED = Scalar(0,0,255);
+const Scalar PINK = Scalar(230,130,255);
+const Scalar BLUE = Scalar(255,0,0);
+const Scalar LIGHTBLUE = Scalar(255,255,160);
+const Scalar GREEN = Scalar(0,255,0);
+
+const int BGD_KEY = EVENT_FLAG_CTRLKEY;
+const int FGD_KEY = EVENT_FLAG_SHIFTKEY;
+
+static void getBinMask( const Mat& comMask, Mat& binMask )
+{
+    if( comMask.empty() || comMask.type()!=CV_8UC1 )
+        CV_Error( Error::StsBadArg, "comMask is empty or has incorrect type (not CV_8UC1)" );
+    if( binMask.empty() || binMask.rows!=comMask.rows || binMask.cols!=comMask.cols )
+        binMask.create( comMask.size(), CV_8UC1 );
+    binMask = comMask & 1;
+}
+
+class GCApplication
+{
+public:
+    enum{ NOT_SET = 0, IN_PROCESS = 1, SET = 2 };
+    static const int radius = 2;
+    static const int thickness = -1;
+
+    void reset();
+    void setImageAndWinName( const Mat& _image, const string& _winName );
+    void showImage() const;
+    void mouseClick( int event, int x, int y, int flags, void* param );
+    int nextIter();
+    int getIterCount() const { return iterCount; }
+private:
+    void setRectInMask();
+    void setLblsInMask( int flags, Point p, bool isPr );
+
+    const string* winName;
+    const Mat* image;
+    Mat mask;
+    Mat bgdModel, fgdModel;
+
+    uchar rectState, lblsState, prLblsState;
+    bool isInitialized;
+
+    Rect rect;
+    vector<Point> fgdPxls, bgdPxls, prFgdPxls, prBgdPxls;
+    int iterCount;
+};
+
+void GCApplication::reset()
+{
+    if( !mask.empty() )
+        mask.setTo(Scalar::all(GC_BGD));
+    bgdPxls.clear(); fgdPxls.clear();
+    prBgdPxls.clear();  prFgdPxls.clear();
+
+    isInitialized = false;
+    rectState = NOT_SET;
+    lblsState = NOT_SET;
+    prLblsState = NOT_SET;
+    iterCount = 0;
+}
+
+void GCApplication::setImageAndWinName( const Mat& _image, const string& _winName  )
+{
+    if( _image.empty() || _winName.empty() )
+        return;
+    image = &_image;
+    winName = &_winName;
+    mask.create( image->size(), CV_8UC1);
+    reset();
+}
+
+void GCApplication::showImage() const
+{
+    if( image->empty() || winName->empty() )
+        return;
+
+    Mat res;
+    Mat binMask;
+    image->copyTo( res );
+    if( isInitialized ){
+        getBinMask( mask, binMask);
+
+        Mat black (binMask.rows, binMask.cols, CV_8UC3, cv::Scalar(0,0,0));
+        black.setTo(Scalar::all(255), binMask);
+
+        addWeighted(black, 0.5, res, 0.5, 0.0, res);
+    }
+
+    vector<Point>::const_iterator it;
+    for( it = bgdPxls.begin(); it != bgdPxls.end(); ++it )
+        circle( res, *it, radius, BLUE, thickness );
+    for( it = fgdPxls.begin(); it != fgdPxls.end(); ++it )
+        circle( res, *it, radius, RED, thickness );
+    for( it = prBgdPxls.begin(); it != prBgdPxls.end(); ++it )
+        circle( res, *it, radius, LIGHTBLUE, thickness );
+    for( it = prFgdPxls.begin(); it != prFgdPxls.end(); ++it )
+        circle( res, *it, radius, PINK, thickness );
+
+    if( rectState == IN_PROCESS || rectState == SET )
+        rectangle( res, Point( rect.x, rect.y ), Point(rect.x + rect.width, rect.y + rect.height ), GREEN, 2);
+
+    imshow( *winName, res );
+}
+
+void GCApplication::setRectInMask()
+{
+    CV_Assert( !mask.empty() );
+    mask.setTo( GC_BGD );
+    rect.x = max(0, rect.x);
+    rect.y = max(0, rect.y);
+    rect.width = min(rect.width, image->cols-rect.x);
+    rect.height = min(rect.height, image->rows-rect.y);
+    (mask(rect)).setTo( Scalar(GC_PR_FGD) );
+}
+
+void GCApplication::setLblsInMask( int flags, Point p, bool isPr )
+{
+    vector<Point> *bpxls, *fpxls;
+    uchar bvalue, fvalue;
+    if( !isPr )
+    {
+        bpxls = &bgdPxls;
+        fpxls = &fgdPxls;
+        bvalue = GC_BGD;
+        fvalue = GC_FGD;
+    }
+    else
+    {
+        bpxls = &prBgdPxls;
+        fpxls = &prFgdPxls;
+        bvalue = GC_PR_BGD;
+        fvalue = GC_PR_FGD;
+    }
+    if( flags & BGD_KEY )
+    {
+        bpxls->push_back(p);
+        circle( mask, p, radius, bvalue, thickness );
+    }
+    if( flags & FGD_KEY )
+    {
+        fpxls->push_back(p);
+        circle( mask, p, radius, fvalue, thickness );
+    }
+}
+
+void GCApplication::mouseClick( int event, int x, int y, int flags, void* )
+{
+    // TODO add bad args check
+    switch( event )
+    {
+    case EVENT_LBUTTONDOWN: // set rect or GC_BGD(GC_FGD) labels
+        {
+            bool isb = (flags & BGD_KEY) != 0,
+                 isf = (flags & FGD_KEY) != 0;
+            if( rectState == NOT_SET && !isb && !isf )
+            {
+                rectState = IN_PROCESS;
+                rect = Rect( x, y, 1, 1 );
+            }
+            if ( (isb || isf) && rectState == SET )
+                lblsState = IN_PROCESS;
+        }
+        break;
+    case EVENT_RBUTTONDOWN: // set GC_PR_BGD(GC_PR_FGD) labels
+        {
+            bool isb = (flags & BGD_KEY) != 0,
+                 isf = (flags & FGD_KEY) != 0;
+            if ( (isb || isf) && rectState == SET )
+                prLblsState = IN_PROCESS;
+        }
+        break;
+    case EVENT_LBUTTONUP:
+        if( rectState == IN_PROCESS )
+        {
+            if(rect.x == x || rect.y == y){
+                rectState = NOT_SET;
+            }
+            else{
+                rect = Rect( Point(rect.x, rect.y), Point(x,y) );
+                rectState = SET;
+                setRectInMask();
+                CV_Assert( bgdPxls.empty() && fgdPxls.empty() && prBgdPxls.empty() && prFgdPxls.empty() );
+            }
+            showImage();
+        }
+        if( lblsState == IN_PROCESS )
+        {
+            setLblsInMask(flags, Point(x,y), false);
+            lblsState = SET;
+            nextIter();
+            showImage();
+        }
+        else{
+            if(rectState == SET){
+                nextIter();
+                showImage();
+            }
+        }
+        break;
+    case EVENT_RBUTTONUP:
+        if( prLblsState == IN_PROCESS )
+        {
+            setLblsInMask(flags, Point(x,y), true);
+            prLblsState = SET;
+        }
+        if(rectState == SET){
+            nextIter();
+            showImage();
+        }
+        break;
+    case EVENT_MOUSEMOVE:
+        if( rectState == IN_PROCESS )
+        {
+            rect = Rect( Point(rect.x, rect.y), Point(x,y) );
+            CV_Assert( bgdPxls.empty() && fgdPxls.empty() && prBgdPxls.empty() && prFgdPxls.empty() );
+            showImage();
+        }
+        else if( lblsState == IN_PROCESS )
+        {
+            setLblsInMask(flags, Point(x,y), false);
+            showImage();
+        }
+        else if( prLblsState == IN_PROCESS )
+        {
+            setLblsInMask(flags, Point(x,y), true);
+            showImage();
+        }
+        break;
+    }
+}
+
+int GCApplication::nextIter()
+{
+    if( isInitialized )
+        grabCut( *image, mask, rect, bgdModel, fgdModel, 1 );
+    else
+    {
+        if( rectState != SET )
+            return iterCount;
+
+        if( lblsState == SET || prLblsState == SET )
+            grabCut( *image, mask, rect, bgdModel, fgdModel, 1, GC_INIT_WITH_MASK );
+        else
+            grabCut( *image, mask, rect, bgdModel, fgdModel, 1, GC_INIT_WITH_RECT );
+
+        isInitialized = true;
+    }
+    iterCount++;
+
+    bgdPxls.clear(); fgdPxls.clear();
+    prBgdPxls.clear(); prFgdPxls.clear();
+
+    return iterCount;
+}
+
+GCApplication gcapp;
+
+static void on_mouse( int event, int x, int y, int flags, void* param )
+{
+    gcapp.mouseClick( event, x, y, flags, param );
+}
+
+int main( int argc, char** argv )
+{
+    cv::CommandLineParser parser(argc, argv, "{@input| messi5.jpg |}");
+    help(argv);
+
+    string filename = parser.get<string>("@input");
+    if( filename.empty() )
+    {
+        cout << "\nDurn, empty filename" << endl;
+        return 1;
+    }
+    Mat image = imread(samples::findFile(filename), IMREAD_COLOR);
+    if( image.empty() )
+    {
+        cout << "\n Durn, couldn't read image filename " << filename << endl;
+        return 1;
+    }
+
+    const string winName = "image";
+    namedWindow( winName, WINDOW_AUTOSIZE );
+    setMouseCallback( winName, on_mouse, 0 );
+
+    gcapp.setImageAndWinName( image, winName );
+    gcapp.showImage();
+
+    for(;;)
+    {
+        char c = (char)waitKey(0);
+        switch( c )
+        {
+        case '\x1b':
+            cout << "Exiting ..." << endl;
+            goto exit_main;
+        case 'r':
+            cout << endl;
+            gcapp.reset();
+            gcapp.showImage();
+            break;
+        case 'n':
+            int iterCount = gcapp.getIterCount();
+            cout << "<" << iterCount << "... ";
+            int newIterCount = gcapp.nextIter();
+            if( newIterCount > iterCount )
+            {
+                gcapp.showImage();
+                cout << iterCount << ">" << endl;
+            }
+            else
+                cout << "rect must be determined>" << endl;
+            break;
+        }
+    }
+
+exit_main:
+    destroyWindow( winName );
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/image_alignment.cpp b/C++/opencv-4.7.0/samples/cpp/image_alignment.cpp
new file mode 100644
index 00000000..fc7ab18a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/image_alignment.cpp
@@ -0,0 +1,394 @@
+/*
+* This sample demonstrates the use of the function
+* findTransformECC that implements the image alignment ECC algorithm
+*
+*
+* The demo loads an image (defaults to fruits.jpg) and it artificially creates
+* a template image based on the given motion type. When two images are given,
+* the first image is the input image and the second one defines the template image.
+* In the latter case, you can also parse the warp's initialization.
+*
+* Input and output warp files consist of the raw warp (transform) elements
+*
+* Authors: G. Evangelidis, INRIA, Grenoble, France
+*          M. Asbach, Fraunhofer IAIS, St. Augustin, Germany
+*/
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/video.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/core/utility.hpp>
+
+#include <stdio.h>
+#include <string>
+#include <time.h>
+#include <iostream>
+#include <fstream>
+
+using namespace cv;
+using namespace std;
+
+static void help(const char** argv);
+static int readWarp(string iFilename, Mat& warp, int motionType);
+static int saveWarp(string fileName, const Mat& warp, int motionType);
+static void draw_warped_roi(Mat& image, const int width, const int height, Mat& W);
+
+#define HOMO_VECTOR(H, x, y)\
+    H.at<float>(0,0) = (float)(x);\
+    H.at<float>(1,0) = (float)(y);\
+    H.at<float>(2,0) = 1.;
+
+#define GET_HOMO_VALUES(X, x, y)\
+    (x) = static_cast<float> (X.at<float>(0,0)/X.at<float>(2,0));\
+    (y) = static_cast<float> (X.at<float>(1,0)/X.at<float>(2,0));
+
+
+const std::string keys =
+    "{@inputImage    | fruits.jpg    | input image filename }"
+    "{@templateImage |               | template image filename (optional)}"
+    "{@inputWarp     |               | input warp (matrix) filename (optional)}"
+    "{n numOfIter    | 50            | ECC's iterations }"
+    "{e epsilon      | 0.0001        | ECC's convergence epsilon }"
+    "{o outputWarp   | outWarp.ecc   | output warp (matrix) filename }"
+    "{m motionType   | affine        | type of motion (translation, euclidean, affine, homography) }"
+    "{v verbose      | 1             | display initial and final images }"
+    "{w warpedImfile | warpedECC.png | warped input image }"
+    "{h help | | print help message }"
+;
+
+
+static void help(const char** argv)
+{
+
+    cout << "\nThis file demonstrates the use of the ECC image alignment algorithm. When one image"
+        " is given, the template image is artificially formed by a random warp. When both images"
+        " are given, the initialization of the warp by command line parsing is possible. "
+        "If inputWarp is missing, the identity transformation initializes the algorithm. \n" << endl;
+
+    cout << "\nUsage example (one image): \n"
+         << argv[0]
+         << " fruits.jpg -o=outWarp.ecc "
+            "-m=euclidean -e=1e-6 -N=70 -v=1 \n" << endl;
+
+    cout << "\nUsage example (two images with initialization): \n"
+         << argv[0]
+         << " yourInput.png yourTemplate.png "
+        "yourInitialWarp.ecc -o=outWarp.ecc -m=homography -e=1e-6 -N=70 -v=1 -w=yourFinalImage.png \n" << endl;
+
+}
+
+static int readWarp(string iFilename, Mat& warp, int motionType){
+
+    // it reads from file a specific number of raw values:
+    // 9 values for homography, 6 otherwise
+    CV_Assert(warp.type()==CV_32FC1);
+    int numOfElements;
+    if (motionType==MOTION_HOMOGRAPHY)
+        numOfElements=9;
+    else
+        numOfElements=6;
+
+    int i;
+    int ret_value;
+
+    ifstream myfile(iFilename.c_str());
+    if (myfile.is_open()){
+        float* matPtr = warp.ptr<float>(0);
+        for(i=0; i<numOfElements; i++){
+            myfile >> matPtr[i];
+        }
+        ret_value = 1;
+    }
+    else {
+        cout << "Unable to open file " << iFilename.c_str() << endl;
+        ret_value = 0;
+    }
+    return ret_value;
+}
+
+static int saveWarp(string fileName, const Mat& warp, int motionType)
+{
+    // it saves the raw matrix elements in a file
+    CV_Assert(warp.type()==CV_32FC1);
+
+    const float* matPtr = warp.ptr<float>(0);
+    int ret_value;
+
+    ofstream outfile(fileName.c_str());
+    if( !outfile ) {
+        cerr << "error in saving "
+            << "Couldn't open file '" << fileName.c_str() << "'!" << endl;
+        ret_value = 0;
+    }
+    else {//save the warp's elements
+        outfile << matPtr[0] << " " << matPtr[1] << " " << matPtr[2] << endl;
+        outfile << matPtr[3] << " " << matPtr[4] << " " << matPtr[5] << endl;
+        if (motionType==MOTION_HOMOGRAPHY){
+            outfile << matPtr[6] << " " << matPtr[7] << " " << matPtr[8] << endl;
+        }
+        ret_value = 1;
+    }
+    return ret_value;
+
+}
+
+
+static void draw_warped_roi(Mat& image, const int width, const int height, Mat& W)
+{
+    Point2f top_left, top_right, bottom_left, bottom_right;
+
+    Mat  H = Mat (3, 1, CV_32F);
+    Mat  U = Mat (3, 1, CV_32F);
+
+    Mat warp_mat = Mat::eye (3, 3, CV_32F);
+
+    for (int y = 0; y < W.rows; y++)
+        for (int x = 0; x < W.cols; x++)
+            warp_mat.at<float>(y,x) = W.at<float>(y,x);
+
+    //warp the corners of rectangle
+
+    // top-left
+    HOMO_VECTOR(H, 1, 1);
+    gemm(warp_mat, H, 1, 0, 0, U);
+    GET_HOMO_VALUES(U, top_left.x, top_left.y);
+
+    // top-right
+    HOMO_VECTOR(H, width, 1);
+    gemm(warp_mat, H, 1, 0, 0, U);
+    GET_HOMO_VALUES(U, top_right.x, top_right.y);
+
+    // bottom-left
+    HOMO_VECTOR(H, 1, height);
+    gemm(warp_mat, H, 1, 0, 0, U);
+    GET_HOMO_VALUES(U, bottom_left.x, bottom_left.y);
+
+    // bottom-right
+    HOMO_VECTOR(H, width, height);
+    gemm(warp_mat, H, 1, 0, 0, U);
+    GET_HOMO_VALUES(U, bottom_right.x, bottom_right.y);
+
+    // draw the warped perimeter
+    line(image, top_left, top_right, Scalar(255));
+    line(image, top_right, bottom_right, Scalar(255));
+    line(image, bottom_right, bottom_left, Scalar(255));
+    line(image, bottom_left, top_left, Scalar(255));
+}
+
+int main (const int argc, const char * argv[])
+{
+
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("ECC demo");
+
+    parser.printMessage();
+    help(argv);
+
+    string imgFile = parser.get<string>(0);
+    string tempImgFile = parser.get<string>(1);
+    string inWarpFile = parser.get<string>(2);
+
+    int number_of_iterations = parser.get<int>("n");
+    double termination_eps = parser.get<double>("e");
+    string warpType = parser.get<string>("m");
+    int verbose = parser.get<int>("v");
+    string finalWarp = parser.get<string>("o");
+    string warpedImFile = parser.get<string>("w");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return -1;
+    }
+    if (!(warpType == "translation" || warpType == "euclidean"
+        || warpType == "affine" || warpType == "homography"))
+    {
+        cerr << "Invalid motion transformation" << endl;
+        return -1;
+    }
+
+    int mode_temp;
+    if (warpType == "translation")
+        mode_temp = MOTION_TRANSLATION;
+    else if (warpType == "euclidean")
+        mode_temp = MOTION_EUCLIDEAN;
+    else if (warpType == "affine")
+        mode_temp = MOTION_AFFINE;
+    else
+        mode_temp = MOTION_HOMOGRAPHY;
+
+    Mat inputImage = imread(samples::findFile(imgFile), IMREAD_GRAYSCALE);
+    if (inputImage.empty())
+    {
+        cerr << "Unable to load the inputImage" <<  endl;
+        return -1;
+    }
+
+    Mat target_image;
+    Mat template_image;
+
+    if (tempImgFile!="") {
+        inputImage.copyTo(target_image);
+        template_image = imread(samples::findFile(tempImgFile), IMREAD_GRAYSCALE);
+        if (template_image.empty()){
+            cerr << "Unable to load the template image" << endl;
+            return -1;
+        }
+
+    }
+    else{ //apply random warp to input image
+        resize(inputImage, target_image, Size(216, 216), 0, 0, INTER_LINEAR_EXACT);
+        Mat warpGround;
+        RNG rng(getTickCount());
+        double angle;
+        switch (mode_temp) {
+        case MOTION_TRANSLATION:
+            warpGround = (Mat_<float>(2,3) << 1, 0, (rng.uniform(10.f, 20.f)),
+                0, 1, (rng.uniform(10.f, 20.f)));
+            warpAffine(target_image, template_image, warpGround,
+                Size(200,200), INTER_LINEAR + WARP_INVERSE_MAP);
+            break;
+        case MOTION_EUCLIDEAN:
+            angle = CV_PI/30 + CV_PI*rng.uniform((double)-2.f, (double)2.f)/180;
+
+            warpGround = (Mat_<float>(2,3) << cos(angle), -sin(angle), (rng.uniform(10.f, 20.f)),
+                sin(angle), cos(angle), (rng.uniform(10.f, 20.f)));
+            warpAffine(target_image, template_image, warpGround,
+                Size(200,200), INTER_LINEAR + WARP_INVERSE_MAP);
+            break;
+        case MOTION_AFFINE:
+
+            warpGround = (Mat_<float>(2,3) << (1-rng.uniform(-0.05f, 0.05f)),
+                (rng.uniform(-0.03f, 0.03f)), (rng.uniform(10.f, 20.f)),
+                (rng.uniform(-0.03f, 0.03f)), (1-rng.uniform(-0.05f, 0.05f)),
+                (rng.uniform(10.f, 20.f)));
+            warpAffine(target_image, template_image, warpGround,
+                Size(200,200), INTER_LINEAR + WARP_INVERSE_MAP);
+            break;
+        case MOTION_HOMOGRAPHY:
+            warpGround = (Mat_<float>(3,3) << (1-rng.uniform(-0.05f, 0.05f)),
+                (rng.uniform(-0.03f, 0.03f)), (rng.uniform(10.f, 20.f)),
+                (rng.uniform(-0.03f, 0.03f)), (1-rng.uniform(-0.05f, 0.05f)),(rng.uniform(10.f, 20.f)),
+                (rng.uniform(0.0001f, 0.0003f)), (rng.uniform(0.0001f, 0.0003f)), 1.f);
+            warpPerspective(target_image, template_image, warpGround,
+                Size(200,200), INTER_LINEAR + WARP_INVERSE_MAP);
+            break;
+        }
+    }
+
+
+    const int warp_mode = mode_temp;
+
+    // initialize or load the warp matrix
+    Mat warp_matrix;
+    if (warpType == "homography")
+        warp_matrix = Mat::eye(3, 3, CV_32F);
+    else
+        warp_matrix = Mat::eye(2, 3, CV_32F);
+
+    if (inWarpFile!=""){
+        int readflag = readWarp(inWarpFile, warp_matrix, warp_mode);
+        if ((!readflag) || warp_matrix.empty())
+        {
+            cerr << "-> Check warp initialization file" << endl << flush;
+            return -1;
+        }
+    }
+    else {
+
+        printf("\n ->Performance Warning: Identity warp ideally assumes images of "
+            "similar size. If the deformation is strong, the identity warp may not "
+            "be a good initialization. \n");
+
+    }
+
+    if (number_of_iterations > 200)
+        cout << "-> Warning: too many iterations " << endl;
+
+    if (warp_mode != MOTION_HOMOGRAPHY)
+        warp_matrix.rows = 2;
+
+    // start timing
+    const double tic_init = (double) getTickCount ();
+    double cc = findTransformECC (template_image, target_image, warp_matrix, warp_mode,
+        TermCriteria (TermCriteria::COUNT+TermCriteria::EPS,
+        number_of_iterations, termination_eps));
+
+    if (cc == -1)
+    {
+        cerr << "The execution was interrupted. The correlation value is going to be minimized." << endl;
+        cerr << "Check the warp initialization and/or the size of images." << endl << flush;
+    }
+
+    // end timing
+    const double toc_final  = (double) getTickCount ();
+    const double total_time = (toc_final-tic_init)/(getTickFrequency());
+    if (verbose){
+        cout << "Alignment time (" << warpType << " transformation): "
+            << total_time << " sec" << endl << flush;
+        //  cout << "Final correlation: " << cc << endl << flush;
+
+    }
+
+    // save the final warp matrix
+    saveWarp(finalWarp, warp_matrix, warp_mode);
+
+    if (verbose){
+        cout << "\nThe final warp has been saved in the file: " << finalWarp << endl << flush;
+    }
+
+    // save the final warped image
+    Mat warped_image = Mat(template_image.rows, template_image.cols, CV_32FC1);
+    if (warp_mode != MOTION_HOMOGRAPHY)
+        warpAffine      (target_image, warped_image, warp_matrix, warped_image.size(),
+        INTER_LINEAR + WARP_INVERSE_MAP);
+    else
+        warpPerspective (target_image, warped_image, warp_matrix, warped_image.size(),
+        INTER_LINEAR + WARP_INVERSE_MAP);
+
+    //save the warped image
+    imwrite(warpedImFile, warped_image);
+
+    // display resulting images
+    if (verbose)
+    {
+
+        cout << "The warped image has been saved in the file: " << warpedImFile << endl << flush;
+
+        namedWindow ("image",    WINDOW_AUTOSIZE);
+        namedWindow ("template", WINDOW_AUTOSIZE);
+        namedWindow ("warped image",   WINDOW_AUTOSIZE);
+        namedWindow ("error (black: no error)", WINDOW_AUTOSIZE);
+
+        moveWindow  ("image", 20, 300);
+        moveWindow  ("template", 300, 300);
+        moveWindow  ("warped image",   600, 300);
+        moveWindow  ("error (black: no error)", 900, 300);
+
+        // draw boundaries of corresponding regions
+        Mat identity_matrix = Mat::eye(3,3,CV_32F);
+
+        draw_warped_roi (target_image,   template_image.cols-2, template_image.rows-2, warp_matrix);
+        draw_warped_roi (template_image, template_image.cols-2, template_image.rows-2, identity_matrix);
+
+        Mat errorImage;
+        subtract(template_image, warped_image, errorImage);
+        double max_of_error;
+        minMaxLoc(errorImage, NULL, &max_of_error);
+
+        // show images
+        cout << "Press any key to exit the demo (you might need to click on the images before)." << endl << flush;
+
+        imshow ("image",    target_image);
+        waitKey (200);
+        imshow ("template", template_image);
+        waitKey (200);
+        imshow ("warped image",   warped_image);
+        waitKey(200);
+        imshow ("error (black: no error)",  abs(errorImage)*255/max_of_error);
+        waitKey(0);
+
+    }
+
+    // done
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/imagelist_creator.cpp b/C++/opencv-4.7.0/samples/cpp/imagelist_creator.cpp
new file mode 100644
index 00000000..5b2dc38d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/imagelist_creator.cpp
@@ -0,0 +1,54 @@
+/*this creates a yaml or xml list of files from the command line args
+ */
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <string>
+#include <iostream>
+
+using std::string;
+using std::cout;
+using std::endl;
+
+using namespace cv;
+
+static void help(char** av)
+{
+  cout << "\nThis creates a yaml or xml list of files from the command line args\n"
+      "usage:\n./" << av[0] << " imagelist.yaml *.png\n"
+      << "Try using different extensions.(e.g. yaml yml xml xml.gz etc...)\n"
+      << "This will serialize this list of images or whatever with opencv's FileStorage framework" << endl;
+}
+
+int main(int ac, char** av)
+{
+  cv::CommandLineParser parser(ac, av, "{help h||}{@output||}");
+  if (parser.has("help"))
+  {
+    help(av);
+    return 0;
+  }
+  string outputname = parser.get<string>("@output");
+
+  if (outputname.empty())
+  {
+    help(av);
+    return 1;
+  }
+
+  Mat m = imread(outputname); //check if the output is an image - prevent overwrites!
+  if(!m.empty()){
+    std::cerr << "fail! Please specify an output file, don't want to overwrite you images!" << endl;
+    help(av);
+    return 1;
+  }
+
+  FileStorage fs(outputname, FileStorage::WRITE);
+  fs << "images" << "[";
+  for(int i = 2; i < ac; i++){
+    fs << string(av[i]);
+  }
+  fs << "]";
+  return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/imagelist_reader.cpp b/C++/opencv-4.7.0/samples/cpp/imagelist_reader.cpp
new file mode 100644
index 00000000..1d209b93
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/imagelist_reader.cpp
@@ -0,0 +1,80 @@
+/*
+ *  Created on: Nov 23, 2010
+ *      Author: Ethan Rublee
+ *
+ * A starter sample for using opencv, load up an imagelist
+ * that was generated with imagelist_creator.cpp
+ * easy as CV_PI right?
+ */
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+#include <vector>
+
+using namespace cv;
+using namespace std;
+
+static void help(char** av)
+{
+  cout << "\nThis program gets you started being able to read images from a list in a file\n"
+          "Usage:\n./" << av[0] << " image_list.yaml\n"
+       << "\tThis is a starter sample, to get you up and going in a copy pasta fashion.\n"
+       << "\tThe program reads in an list of images from a yaml or xml file and displays\n"
+       << "one at a time\n"
+       << "\tTry running imagelist_creator to generate a list of images.\n"
+        "Using OpenCV version %s\n" << CV_VERSION << "\n" << endl;
+}
+
+static bool readStringList(const string& filename, vector<string>& l)
+{
+  l.resize(0);
+  FileStorage fs(filename, FileStorage::READ);
+  if (!fs.isOpened())
+    return false;
+  FileNode n = fs.getFirstTopLevelNode();
+  if (n.type() != FileNode::SEQ)
+    return false;
+  FileNodeIterator it = n.begin(), it_end = n.end();
+  for (; it != it_end; ++it)
+    l.push_back((string)*it);
+  return true;
+}
+
+static int process(const vector<string>& images)
+{
+    namedWindow("image", WINDOW_KEEPRATIO); //resizable window;
+    for (size_t i = 0; i < images.size(); i++)
+    {
+        Mat image = imread(images[i], IMREAD_GRAYSCALE); // do grayscale processing?
+        imshow("image",image);
+        cout << "Press a key to see the next image in the list." << endl;
+        waitKey(); // wait infinitely for a key to be pressed
+    }
+    return 0;
+}
+
+int main(int ac, char** av)
+{
+  cv::CommandLineParser parser(ac, av, "{help h||}{@input||}");
+  if (parser.has("help"))
+  {
+      help(av);
+      return 0;
+  }
+  std::string arg = parser.get<std::string>("@input");
+  if (arg.empty())
+  {
+    help(av);
+    return 1;
+  }
+  vector<string> imagelist;
+
+  if (!readStringList(arg,imagelist))
+  {
+    cerr << "Failed to read image list\n" << endl;
+    help(av);
+    return 1;
+  }
+
+  return process(imagelist);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/imgcodecs_jpeg.cpp b/C++/opencv-4.7.0/samples/cpp/imgcodecs_jpeg.cpp
new file mode 100644
index 00000000..4c22a483
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/imgcodecs_jpeg.cpp
@@ -0,0 +1,82 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <iostream>
+#include <vector>
+
+using namespace std;
+using namespace cv;
+
+int main(int /*argc*/, const char** /* argv */ )
+{
+    Mat framebuffer( 160 * 2, 160 * 5, CV_8UC3, cv::Scalar::all(255) );
+
+    Mat img( 160, 160, CV_8UC3, cv::Scalar::all(255) );
+
+    // Create test image.
+    {
+        const Point center( img.rows / 2 , img.cols /2 );
+
+        for( int radius = 5; radius < img.rows ; radius += 3 )
+        {
+            cv::circle( img, center, radius, Scalar(255,0,255) );
+        }
+        cv::rectangle( img, Point(0,0), Point(img.rows-1, img.cols-1), Scalar::all(0), 2 );
+    }
+
+    // Draw original image(s).
+    int top = 0; // Upper images
+    {
+        for( int left = 0 ; left < img.rows * 5 ; left += img.rows ){
+            Mat roi = framebuffer( Rect( left, top, img.rows, img.cols ) );
+            img.copyTo(roi);
+
+            cv::putText( roi, "original", Point(5,15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar::all(0), 2, 4, false );
+        }
+    }
+
+    // Draw lossy images
+    top += img.cols; // Lower images
+    {
+        struct test_config{
+            string comment;
+            uint32_t sampling_factor;
+        } config [] = {
+            { "411", IMWRITE_JPEG_SAMPLING_FACTOR_411 },
+            { "420", IMWRITE_JPEG_SAMPLING_FACTOR_420 },
+            { "422", IMWRITE_JPEG_SAMPLING_FACTOR_422 },
+            { "440", IMWRITE_JPEG_SAMPLING_FACTOR_440 },
+            { "444", IMWRITE_JPEG_SAMPLING_FACTOR_444 },
+        };
+
+        const int config_num = 5;
+
+        int left = 0;
+
+        for ( int i = 0 ; i < config_num; i++ )
+        {
+            // Compress images with sampling factor parameter.
+            vector<int> param;
+            param.push_back( IMWRITE_JPEG_SAMPLING_FACTOR );
+            param.push_back( config[i].sampling_factor );
+            vector<uint8_t> jpeg;
+            (void) imencode(".jpg", img, jpeg, param );
+
+            // Decompress it.
+            Mat jpegMat(jpeg);
+            Mat lossy_img = imdecode(jpegMat, -1);
+
+            // Copy into framebuffer and comment
+            Mat roi = framebuffer( Rect( left, top, lossy_img.rows, lossy_img.cols ) );
+            lossy_img.copyTo(roi);
+            cv::putText( roi, config[i].comment, Point(5,155), FONT_HERSHEY_SIMPLEX, 0.5, Scalar::all(0), 2, 4, false );
+
+            left += lossy_img.rows;
+        }
+    }
+
+    // Output framebuffer(as lossless).
+    imwrite( "imgcodecs_jpeg_samplingfactor_result.png", framebuffer );
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/inpaint.cpp b/C++/opencv-4.7.0/samples/cpp/inpaint.cpp
new file mode 100644
index 00000000..cabf5528
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/inpaint.cpp
@@ -0,0 +1,91 @@
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/photo.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help( char** argv )
+{
+    cout << "\nCool inpainging demo. Inpainting repairs damage to images by floodfilling the damage \n"
+            << "with surrounding image areas.\n"
+            "Using OpenCV version %s\n" << CV_VERSION << "\n"
+            "Usage:\n" << argv[0] <<" [image_name -- Default fruits.jpg]\n" << endl;
+
+    cout << "Hot keys: \n"
+        "\tESC - quit the program\n"
+        "\tr - restore the original image\n"
+        "\ti or SPACE - run inpainting algorithm\n"
+        "\t\t(before running it, paint something on the image)\n" << endl;
+}
+
+Mat img, inpaintMask;
+Point prevPt(-1,-1);
+
+static void onMouse( int event, int x, int y, int flags, void* )
+{
+    if( event == EVENT_LBUTTONUP || !(flags & EVENT_FLAG_LBUTTON) )
+        prevPt = Point(-1,-1);
+    else if( event == EVENT_LBUTTONDOWN )
+        prevPt = Point(x,y);
+    else if( event == EVENT_MOUSEMOVE && (flags & EVENT_FLAG_LBUTTON) )
+    {
+        Point pt(x,y);
+        if( prevPt.x < 0 )
+            prevPt = pt;
+        line( inpaintMask, prevPt, pt, Scalar::all(255), 5, 8, 0 );
+        line( img, prevPt, pt, Scalar::all(255), 5, 8, 0 );
+        prevPt = pt;
+        imshow("image", img);
+    }
+}
+
+
+int main( int argc, char** argv )
+{
+    cv::CommandLineParser parser(argc, argv, "{@image|fruits.jpg|}");
+    help(argv);
+
+    string filename = samples::findFile(parser.get<string>("@image"));
+    Mat img0 = imread(filename, IMREAD_COLOR);
+    if(img0.empty())
+    {
+        cout << "Couldn't open the image " << filename << ". Usage: inpaint <image_name>\n" << endl;
+        return 0;
+    }
+
+    namedWindow("image", WINDOW_AUTOSIZE);
+
+    img = img0.clone();
+    inpaintMask = Mat::zeros(img.size(), CV_8U);
+
+    imshow("image", img);
+    setMouseCallback( "image", onMouse, NULL);
+
+    for(;;)
+    {
+        char c = (char)waitKey();
+
+        if( c == 27 )
+            break;
+
+        if( c == 'r' )
+        {
+            inpaintMask = Scalar::all(0);
+            img0.copyTo(img);
+            imshow("image", img);
+        }
+
+        if( c == 'i' || c == ' ' )
+        {
+            Mat inpainted;
+            inpaint(img, inpaintMask, inpainted, 3, INPAINT_TELEA);
+            imshow("inpainted image", inpainted);
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/intelligent_scissors.cpp b/C++/opencv-4.7.0/samples/cpp/intelligent_scissors.cpp
new file mode 100644
index 00000000..22f72d64
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/intelligent_scissors.cpp
@@ -0,0 +1,235 @@
+#include <iostream>
+#include <cmath>
+#include <string>
+#include <vector>
+#include <queue>
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+
+using namespace cv;
+struct Pix
+{
+    Point next_point;
+    double cost;
+
+    bool operator > (const Pix &b) const
+    {
+        return cost > b.cost;
+    }
+};
+
+struct Parameters
+{
+    Mat img, img_pre_render, img_render;
+    Point end;
+    std::vector<std::vector<Point> > contours;
+    std::vector<Point> tmp_contour;
+    Mat zero_crossing, gradient_magnitude, Ix, Iy, hit_map_x, hit_map_y;
+};
+
+
+static float local_cost(const Point& p, const Point& q, const Mat& gradient_magnitude, const Mat& Iy, const Mat& Ix, const Mat& zero_crossing)
+{
+    float fG = gradient_magnitude.at<float>(q.y, q.x);
+    float dp;
+    float dq;
+    const float WEIGHT_LAP_ZERO_CROSS = 0.43f;
+    const float WEIGHT_GRADIENT_MAGNITUDE = 0.14f;
+    const float WEIGHT_GRADIENT_DIRECTION = 0.43f;
+    bool isDiag = (p.x != q.x) && (p.y != q.y);
+
+    if ((Iy.at<float>(p) * (q.x - p.x) - Ix.at<float>(p) * (q.y - p.y)) >= 0)
+    {
+        dp = Iy.at<float>(p) * (q.x - p.x) - Ix.at<float>(p) * (q.y - p.y);
+        dq = Iy.at<float>(q) * (q.x - p.x) - Ix.at<float>(q) * (q.y - p.y);
+    }
+    else
+    {
+        dp = Iy.at<float>(p) * (p.x - q.x) + (-Ix.at<float>(p)) * (p.y - q.y);
+        dq = Iy.at<float>(q) * (p.x - q.x) + (-Ix.at<float>(q)) * (p.y - q.y);
+    }
+    if (isDiag)
+    {
+        dp /= sqrtf(2);
+        dq /= sqrtf(2);
+    }
+    else
+    {
+        fG /= sqrtf(2);
+    }
+    return  WEIGHT_LAP_ZERO_CROSS * zero_crossing.at<uchar>(q) +
+            WEIGHT_GRADIENT_DIRECTION * (acosf(dp) + acosf(dq)) / static_cast<float>(CV_PI) +
+            WEIGHT_GRADIENT_MAGNITUDE * fG;
+}
+
+static void find_min_path(const Point& start, Parameters* param)
+{
+    Pix begin;
+    Mat &img = param->img;
+    Mat cost_map(img.size(), CV_32F, Scalar(FLT_MAX));
+    Mat expand(img.size(), CV_8UC1, Scalar(0));
+    Mat processed(img.size(), CV_8UC1, Scalar(0));
+    Mat removed(img.size(), CV_8UC1, Scalar(0));
+    std::priority_queue < Pix, std::vector<Pix>, std::greater<Pix> > L;
+
+    cost_map.at<float>(start) = 0;
+    processed.at<uchar>(start) = 1;
+    begin.cost = 0;
+    begin.next_point = start;
+
+    L.push(begin);
+    while (!L.empty())
+    {
+        Pix P = L.top();
+        L.pop();
+        Point p = P.next_point;
+        processed.at<uchar>(p) = 0;
+        if (removed.at<uchar>(p) == 0)
+        {
+            expand.at<uchar>(p) = 1;
+            for (int i = -1; i <= 1; i++)
+            {
+                for(int j = -1; j <= 1; j++)
+                {
+                    int tx = p.x + i;
+                    int ty = p.y + j;
+                    if (tx < 0 || tx >= img.cols || ty < 0 || ty >= img.rows)
+                        continue;
+                    if (expand.at<uchar>(ty, tx) == 0)
+                    {
+                        Point q = Point(tx, ty);
+                        float cost = cost_map.at<float>(p) + local_cost(p, q, param->gradient_magnitude, param->Iy, param->Ix, param->zero_crossing);
+                        if (processed.at<uchar>(q) == 1 && cost < cost_map.at<float>(q))
+                        {
+                            removed.at<uchar>(q) = 1;
+                        }
+                        if (processed.at<uchar>(q) == 0)
+                        {
+                            cost_map.at<float>(q) = cost;
+                            param->hit_map_x.at<int>(q)= p.x;
+                            param->hit_map_y.at<int>(q) = p.y;
+                            processed.at<uchar>(q) = 1;
+                            Pix val;
+                            val.cost = cost_map.at<float>(q);
+                            val.next_point = q;
+                            L.push(val);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+static void onMouse(int event, int x, int y, int , void* userdata)
+{
+    Parameters* param = reinterpret_cast<Parameters*>(userdata);
+    Point &end = param->end;
+    std::vector<std::vector<Point> > &contours = param->contours;
+    std::vector<Point> &tmp_contour = param->tmp_contour;
+    Mat &img_render = param->img_render;
+    Mat &img_pre_render = param->img_pre_render;
+
+    if (event == EVENT_LBUTTONDOWN)
+    {
+        end = Point(x, y);
+        if (!contours.back().empty())
+        {
+            for (int i = static_cast<int>(tmp_contour.size()) - 1; i >= 0; i--)
+            {
+                contours.back().push_back(tmp_contour[i]);
+            }
+            tmp_contour.clear();
+        }
+        else
+        {
+            contours.back().push_back(end);
+        }
+        find_min_path(end, param);
+
+        img_render.copyTo(img_pre_render);
+        imshow("lasso", img_render);
+    }
+    else if (event == EVENT_RBUTTONDOWN)
+    {
+        img_pre_render.copyTo(img_render);
+        drawContours(img_pre_render, contours, static_cast<int>(contours.size()) - 1, Scalar(0,255,0), FILLED);
+        addWeighted(img_pre_render, 0.3, img_render, 0.7, 0, img_render);
+        contours.resize(contours.size() + 1);
+        imshow("lasso", img_render);
+    }
+    else if (event == EVENT_MOUSEMOVE && !contours.back().empty())
+    {
+        tmp_contour.clear();
+        img_pre_render.copyTo(img_render);
+        Point val_point = Point(x, y);
+        while (val_point != end)
+        {
+            tmp_contour.push_back(val_point);
+            Point cur = Point(param->hit_map_x.at<int>(val_point), param->hit_map_y.at<int>(val_point));
+            line(img_render, val_point, cur, Scalar(255, 0, 0), 2);
+            val_point = cur;
+        }
+        imshow("lasso", img_render);
+    }
+}
+
+const char* keys =
+{
+    "{help h | |}"
+    "{@image | fruits.jpg| Path to image to process}"
+};
+
+
+int main( int argc, const char** argv )
+{
+    Parameters param;
+    const int EDGE_THRESHOLD_LOW = 50;
+    const int EDGE_THRESHOLD_HIGH = 100;
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("\nThis program demonstrates implementation of 'Intelligent Scissors' algorithm designed\n"
+                 "by Eric N. Mortensen and William A. Barrett, and described in article\n"
+                 "'Intelligent Scissors for Image Composition':\n"
+                 "http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.138.3811&rep=rep1&type=pdf\n"
+                 "To start drawing a new contour select a pixel, click LEFT mouse button.\n"
+                 "To fix a path click LEFT mouse button again.\n"
+                 "To finish drawing a contour click RIGHT mouse button.\n");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 1;
+    }
+    std::vector<std::vector<Point> > c(1);
+    param.contours = c;
+    std::string filename = parser.get<std::string>(0);
+
+    Mat grayscale, img_canny;
+    param.img = imread(samples::findFile(filename));
+    param.hit_map_x.create(param.img.rows, param.img.cols, CV_32SC1);
+    param.hit_map_y.create(param.img.rows, param.img.cols, CV_32SC1);
+
+    cvtColor(param.img, grayscale, COLOR_BGR2GRAY);
+    Canny(grayscale, img_canny, EDGE_THRESHOLD_LOW, EDGE_THRESHOLD_HIGH);
+
+    threshold(img_canny, param.zero_crossing, 254, 1, THRESH_BINARY_INV);
+    Sobel(grayscale, param.Ix, CV_32FC1, 1, 0, 1);
+    Sobel(grayscale, param.Iy, CV_32FC1, 0, 1, 1);
+    param.Ix.convertTo(param.Ix, CV_32F, 1.0/255);
+    param.Iy.convertTo(param.Iy, CV_32F, 1.0/255);
+
+    // Compute gradients magnitude.
+    double max_val = 0.0;
+    magnitude(param.Iy, param.Ix, param.gradient_magnitude);
+    minMaxLoc(param.gradient_magnitude, 0, &max_val);
+    param.gradient_magnitude.convertTo(param.gradient_magnitude, CV_32F, -1/max_val, 1.0);
+
+    param.img.copyTo(param.img_pre_render);
+    param.img.copyTo(param.img_render);
+
+    namedWindow("lasso");
+    setMouseCallback("lasso", onMouse, &param);
+    imshow("lasso", param.img);
+    waitKey(0);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/intersectExample.cpp b/C++/opencv-4.7.0/samples/cpp/intersectExample.cpp
new file mode 100644
index 00000000..187aebbe
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/intersectExample.cpp
@@ -0,0 +1,159 @@
+/*
+ * Author: Steve Nicholson
+ *
+ * A program that illustrates intersectConvexConvex in various scenarios
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+using namespace std;
+
+// Create a vector of points describing a rectangle with the given corners
+static vector<Point> makeRectangle(Point topLeft, Point bottomRight)
+{
+    vector<Point> rectangle;
+    rectangle.push_back(topLeft);
+    rectangle.push_back(Point(bottomRight.x, topLeft.y));
+    rectangle.push_back(bottomRight);
+    rectangle.push_back(Point(topLeft.x, bottomRight.y));
+    return rectangle;
+}
+
+static vector<Point> makeTriangle(Point point1, Point point2, Point point3)
+{
+    vector<Point> triangle;
+    triangle.push_back(point1);
+    triangle.push_back(point2);
+    triangle.push_back(point3);
+    return triangle;
+}
+
+// Run intersectConvexConvex on two polygons then draw the polygons and their intersection (if there is one)
+// Return the area of the intersection
+static float drawIntersection(Mat &image, vector<Point> polygon1, vector<Point> polygon2, bool handleNested = true)
+{
+    vector<Point> intersectionPolygon;
+
+    vector<vector<Point> > polygons;
+    polygons.push_back(polygon1);
+    polygons.push_back(polygon2);
+
+    float intersectArea = intersectConvexConvex(polygon1, polygon2, intersectionPolygon, handleNested);
+
+    if (intersectArea > 0)
+    {
+        Scalar fillColor(200, 200, 200);
+        // If the input is invalid, draw the intersection in red
+        if (!isContourConvex(polygon1) || !isContourConvex(polygon2))
+        {
+            fillColor = Scalar(0, 0, 255);
+        }
+        fillPoly(image, intersectionPolygon, fillColor);
+    }
+    polylines(image, polygons, true, Scalar(0, 0, 0));
+
+    return intersectArea;
+}
+
+static void drawDescription(Mat &image, int intersectionArea, string description, Point origin)
+{
+    const size_t bufSize=1024;
+    char caption[bufSize];
+    snprintf(caption, bufSize, "Intersection area: %d%s", intersectionArea, description.c_str());
+    putText(image, caption, origin, FONT_HERSHEY_SIMPLEX, 0.6, Scalar(0, 0, 0));
+}
+
+static void intersectConvexExample()
+{
+    Mat image(610, 550, CV_8UC3, Scalar(255, 255, 255));
+    float intersectionArea;
+
+    intersectionArea = drawIntersection(image,
+        makeRectangle(Point(10, 10), Point(50, 50)),
+        makeRectangle(Point(20, 20), Point(60, 60)));
+
+    drawDescription(image, (int)intersectionArea, "", Point(70, 40));
+
+    intersectionArea = drawIntersection(image,
+        makeRectangle(Point(10, 70), Point(35, 95)),
+        makeRectangle(Point(35, 95), Point(60, 120)));
+
+    drawDescription(image, (int)intersectionArea, "", Point(70, 100));
+
+    intersectionArea = drawIntersection(image,
+        makeRectangle(Point(10, 130), Point(60, 180)),
+        makeRectangle(Point(20, 140), Point(50, 170)),
+        true);
+
+    drawDescription(image, (int)intersectionArea, " (handleNested true)", Point(70, 160));
+
+    intersectionArea = drawIntersection(image,
+        makeRectangle(Point(10, 190), Point(60, 240)),
+        makeRectangle(Point(20, 200), Point(50, 230)),
+        false);
+
+    drawDescription(image, (int)intersectionArea, " (handleNested false)", Point(70, 220));
+
+    intersectionArea = drawIntersection(image,
+        makeRectangle(Point(10, 250), Point(60, 300)),
+        makeRectangle(Point(20, 250), Point(50, 290)),
+        true);
+
+    drawDescription(image, (int)intersectionArea, " (handleNested true)", Point(70, 280));
+
+    // These rectangles share an edge so handleNested can be false and an intersection is still found
+    intersectionArea = drawIntersection(image,
+        makeRectangle(Point(10, 310), Point(60, 360)),
+        makeRectangle(Point(20, 310), Point(50, 350)),
+        false);
+
+    drawDescription(image, (int)intersectionArea, " (handleNested false)", Point(70, 340));
+
+    intersectionArea = drawIntersection(image,
+        makeRectangle(Point(10, 370), Point(60, 420)),
+        makeRectangle(Point(20, 371), Point(50, 410)),
+        false);
+
+    drawDescription(image, (int)intersectionArea, " (handleNested false)", Point(70, 400));
+
+    // A vertex of the triangle lies on an edge of the rectangle so handleNested can be false and an intersection is still found
+    intersectionArea = drawIntersection(image,
+        makeRectangle(Point(10, 430), Point(60, 480)),
+        makeTriangle(Point(35, 430), Point(20, 470), Point(50, 470)),
+        false);
+
+    drawDescription(image, (int)intersectionArea, " (handleNested false)", Point(70, 460));
+
+    // Show intersection of overlapping rectangle and triangle
+    intersectionArea = drawIntersection(image,
+        makeRectangle(Point(10, 490), Point(40, 540)),
+        makeTriangle(Point(25, 500), Point(25, 530), Point(60, 515)),
+        false);
+
+    drawDescription(image, (int)intersectionArea, "", Point(70, 520));
+
+    // This concave polygon is invalid input to intersectConvexConvex so it returns an invalid intersection
+    vector<Point> notConvex;
+    notConvex.push_back(Point(25, 560));
+    notConvex.push_back(Point(25, 590));
+    notConvex.push_back(Point(45, 580));
+    notConvex.push_back(Point(60, 600));
+    notConvex.push_back(Point(60, 550));
+    notConvex.push_back(Point(45, 570));
+    intersectionArea = drawIntersection(image,
+        makeRectangle(Point(10, 550), Point(50, 600)),
+        notConvex,
+        false);
+
+    drawDescription(image, (int)intersectionArea, " (invalid input: not convex)", Point(70, 580));
+
+    imshow("Intersections", image);
+    waitKey(0);
+}
+
+int main()
+{
+    intersectConvexExample();
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/kalman.cpp b/C++/opencv-4.7.0/samples/cpp/kalman.cpp
new file mode 100644
index 00000000..daf0ba5a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/kalman.cpp
@@ -0,0 +1,112 @@
+#include "opencv2/video/tracking.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core/cvdef.h"
+#include <stdio.h>
+
+using namespace cv;
+
+static inline Point calcPoint(Point2f center, double R, double angle)
+{
+    return center + Point2f((float)cos(angle), (float)-sin(angle))*(float)R;
+}
+
+static void help()
+{
+    printf( "\nExample of c calls to OpenCV's Kalman filter.\n"
+"   Tracking of rotating point.\n"
+"   Point moves in a circle and is characterized by a 1D state.\n"
+"   state_k+1 = state_k + speed + process_noise N(0, 1e-5)\n"
+"   The speed is constant.\n"
+"   Both state and measurements vectors are 1D (a point angle),\n"
+"   Measurement is the real state + gaussian noise N(0, 1e-1).\n"
+"   The real and the measured points are connected with red line segment,\n"
+"   the real and the estimated points are connected with yellow line segment,\n"
+"   the real and the corrected estimated points are connected with green line segment.\n"
+"   (if Kalman filter works correctly,\n"
+"    the yellow segment should be shorter than the red one and\n"
+"    the green segment should be shorter than the yellow one)."
+            "\n"
+"   Pressing any key (except ESC) will reset the tracking.\n"
+"   Pressing ESC will stop the program.\n"
+            );
+}
+
+int main(int, char**)
+{
+    help();
+    Mat img(500, 500, CV_8UC3);
+    KalmanFilter KF(2, 1, 0);
+    Mat state(2, 1, CV_32F); /* (phi, delta_phi) */
+    Mat processNoise(2, 1, CV_32F);
+    Mat measurement = Mat::zeros(1, 1, CV_32F);
+    char code = (char)-1;
+
+    for(;;)
+    {
+        img = Scalar::all(0);
+        state.at<float>(0) = 0.0f;
+        state.at<float>(1) = 2.f * (float)CV_PI / 6;
+        KF.transitionMatrix = (Mat_<float>(2, 2) << 1, 1, 0, 1);
+
+        setIdentity(KF.measurementMatrix);
+        setIdentity(KF.processNoiseCov, Scalar::all(1e-5));
+        setIdentity(KF.measurementNoiseCov, Scalar::all(1e-1));
+        setIdentity(KF.errorCovPost, Scalar::all(1));
+
+        randn(KF.statePost, Scalar::all(0), Scalar::all(0.1));
+
+        for(;;)
+        {
+            Point2f center(img.cols*0.5f, img.rows*0.5f);
+            float R = img.cols/3.f;
+            double stateAngle = state.at<float>(0);
+            Point statePt = calcPoint(center, R, stateAngle);
+
+            Mat prediction = KF.predict();
+            double predictAngle = prediction.at<float>(0);
+            Point predictPt = calcPoint(center, R, predictAngle);
+
+            // generate measurement
+            randn( measurement, Scalar::all(0), Scalar::all(KF.measurementNoiseCov.at<float>(0)));
+            measurement += KF.measurementMatrix*state;
+
+            double measAngle = measurement.at<float>(0);
+            Point measPt = calcPoint(center, R, measAngle);
+
+            // correct the state estimates based on measurements
+            // updates statePost & errorCovPost
+            KF.correct(measurement);
+            double improvedAngle = KF.statePost.at<float>(0);
+            Point improvedPt = calcPoint(center, R, improvedAngle);
+
+            // plot points
+            img = img * 0.2;
+            drawMarker(img, measPt, Scalar(0, 0, 255), cv::MARKER_SQUARE, 5, 2);
+            drawMarker(img, predictPt, Scalar(0, 255, 255), cv::MARKER_SQUARE, 5, 2);
+            drawMarker(img, improvedPt, Scalar(0, 255, 0), cv::MARKER_SQUARE, 5, 2);
+            drawMarker(img, statePt, Scalar(255, 255, 255), cv::MARKER_STAR, 10, 1);
+            // forecast one step
+            Mat test = Mat(KF.transitionMatrix*KF.statePost);
+            drawMarker(img, calcPoint(center, R, Mat(KF.transitionMatrix*KF.statePost).at<float>(0)),
+                       Scalar(255, 255, 0), cv::MARKER_SQUARE, 12, 1);
+
+            line( img, statePt, measPt, Scalar(0,0,255), 1, LINE_AA, 0 );
+            line( img, statePt, predictPt, Scalar(0,255,255), 1, LINE_AA, 0 );
+            line( img, statePt, improvedPt, Scalar(0,255,0), 1, LINE_AA, 0 );
+
+
+            randn( processNoise, Scalar(0), Scalar::all(sqrt(KF.processNoiseCov.at<float>(0, 0))));
+            state = KF.transitionMatrix*state + processNoise;
+
+            imshow( "Kalman", img );
+            code = (char)waitKey(1000);
+
+            if( code > 0 )
+                break;
+        }
+        if( code == 27 || code == 'q' || code == 'Q' )
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/kmeans.cpp b/C++/opencv-4.7.0/samples/cpp/kmeans.cpp
new file mode 100644
index 00000000..0a2663ac
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/kmeans.cpp
@@ -0,0 +1,83 @@
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+// static void help()
+// {
+//     cout << "\nThis program demonstrates kmeans clustering.\n"
+//             "It generates an image with random points, then assigns a random number of cluster\n"
+//             "centers and uses kmeans to move those cluster centers to their representitive location\n"
+//             "Call\n"
+//             "./kmeans\n" << endl;
+// }
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    const int MAX_CLUSTERS = 5;
+    Scalar colorTab[] =
+    {
+        Scalar(0, 0, 255),
+        Scalar(0,255,0),
+        Scalar(255,100,100),
+        Scalar(255,0,255),
+        Scalar(0,255,255)
+    };
+
+    Mat img(500, 500, CV_8UC3);
+    RNG rng(12345);
+
+    for(;;)
+    {
+        int k, clusterCount = rng.uniform(2, MAX_CLUSTERS+1);
+        int i, sampleCount = rng.uniform(1, 1001);
+        Mat points(sampleCount, 1, CV_32FC2), labels;
+
+        clusterCount = MIN(clusterCount, sampleCount);
+        std::vector<Point2f> centers;
+
+        /* generate random sample from multigaussian distribution */
+        for( k = 0; k < clusterCount; k++ )
+        {
+            Point center;
+            center.x = rng.uniform(0, img.cols);
+            center.y = rng.uniform(0, img.rows);
+            Mat pointChunk = points.rowRange(k*sampleCount/clusterCount,
+                                             k == clusterCount - 1 ? sampleCount :
+                                             (k+1)*sampleCount/clusterCount);
+            rng.fill(pointChunk, RNG::NORMAL, Scalar(center.x, center.y), Scalar(img.cols*0.05, img.rows*0.05));
+        }
+
+        randShuffle(points, 1, &rng);
+
+        double compactness = kmeans(points, clusterCount, labels,
+            TermCriteria( TermCriteria::EPS+TermCriteria::COUNT, 10, 1.0),
+               3, KMEANS_PP_CENTERS, centers);
+
+        img = Scalar::all(0);
+
+        for( i = 0; i < sampleCount; i++ )
+        {
+            int clusterIdx = labels.at<int>(i);
+            Point ipt = points.at<Point2f>(i);
+            circle( img, ipt, 2, colorTab[clusterIdx], FILLED, LINE_AA );
+        }
+        for (i = 0; i < (int)centers.size(); ++i)
+        {
+            Point2f c = centers[i];
+            circle( img, c, 40, colorTab[i], 1, LINE_AA );
+        }
+        cout << "Compactness: " << compactness << endl;
+
+        imshow("clusters", img);
+
+        char key = (char)waitKey();
+        if( key == 27 || key == 'q' || key == 'Q' ) // 'ESC'
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/laplace.cpp b/C++/opencv-4.7.0/samples/cpp/laplace.cpp
new file mode 100644
index 00000000..e33a284a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/laplace.cpp
@@ -0,0 +1,98 @@
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help(char** argv)
+{
+    cout <<
+            "\nThis program demonstrates Laplace point/edge detection using OpenCV function Laplacian()\n"
+            "It captures from the camera of your choice: 0, 1, ... default 0\n"
+            "Call:\n"
+         <<  argv[0] << " -c=<camera #, default 0> -p=<index of the frame to be decoded/captured next>\n" << endl;
+}
+
+enum {GAUSSIAN, BLUR, MEDIAN};
+
+int sigma = 3;
+int smoothType = GAUSSIAN;
+
+int main( int argc, char** argv )
+{
+    cv::CommandLineParser parser(argc, argv, "{ c | 0 | }{ p | | }");
+    help(argv);
+
+    VideoCapture cap;
+    string camera = parser.get<string>("c");
+    if (camera.size() == 1 && isdigit(camera[0]))
+        cap.open(parser.get<int>("c"));
+    else
+        cap.open(samples::findFileOrKeep(camera));
+    if (!cap.isOpened())
+    {
+        cerr << "Can't open camera/video stream: " << camera << endl;
+        return 1;
+    }
+    cout << "Video " << parser.get<string>("c") <<
+        ": width=" << cap.get(CAP_PROP_FRAME_WIDTH) <<
+        ", height=" << cap.get(CAP_PROP_FRAME_HEIGHT) <<
+        ", nframes=" << cap.get(CAP_PROP_FRAME_COUNT) << endl;
+    int pos = 0;
+    if (parser.has("p"))
+    {
+        pos = parser.get<int>("p");
+    }
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    if (pos != 0)
+    {
+        cout << "seeking to frame #" << pos << endl;
+        if (!cap.set(CAP_PROP_POS_FRAMES, pos))
+        {
+            cerr << "ERROR: seekeing is not supported" << endl;
+        }
+    }
+
+    namedWindow("Laplacian", WINDOW_AUTOSIZE);
+    createTrackbar("Sigma", "Laplacian", &sigma, 15, 0);
+
+    Mat smoothed, laplace, result;
+
+    for(;;)
+    {
+        Mat frame;
+        cap >> frame;
+        if( frame.empty() )
+            break;
+
+        int ksize = (sigma*5)|1;
+        if(smoothType == GAUSSIAN)
+            GaussianBlur(frame, smoothed, Size(ksize, ksize), sigma, sigma);
+        else if(smoothType == BLUR)
+            blur(frame, smoothed, Size(ksize, ksize));
+        else
+            medianBlur(frame, smoothed, ksize);
+
+        Laplacian(smoothed, laplace, CV_16S, 5);
+        convertScaleAbs(laplace, result, (sigma+1)*0.25);
+        imshow("Laplacian", result);
+
+        char c = (char)waitKey(30);
+        if( c == ' ' )
+            smoothType = smoothType == GAUSSIAN ? BLUR : smoothType == BLUR ? MEDIAN : GAUSSIAN;
+        if( c == 'q' || c == 'Q' || c == 27 )
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/letter_recog.cpp b/C++/opencv-4.7.0/samples/cpp/letter_recog.cpp
new file mode 100644
index 00000000..bcad2f46
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/letter_recog.cpp
@@ -0,0 +1,558 @@
+#include "opencv2/core.hpp"
+#include "opencv2/ml.hpp"
+
+#include <cstdio>
+#include <vector>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+using namespace cv::ml;
+
+static void help(char** argv)
+{
+    printf("\nThe sample demonstrates how to train Random Trees classifier\n"
+    "(or Boosting classifier, or MLP, or Knearest, or Nbayes, or Support Vector Machines - see main()) using the provided dataset.\n"
+    "\n"
+    "We use the sample database letter-recognition.data\n"
+    "from UCI Repository, here is the link:\n"
+    "\n"
+    "Newman, D.J. & Hettich, S. & Blake, C.L. & Merz, C.J. (1998).\n"
+    "UCI Repository of machine learning databases\n"
+    "[http://www.ics.uci.edu/~mlearn/MLRepository.html].\n"
+    "Irvine, CA: University of California, Department of Information and Computer Science.\n"
+    "\n"
+    "The dataset consists of 20000 feature vectors along with the\n"
+    "responses - capital latin letters A..Z.\n"
+    "The first 16000 (10000 for boosting)) samples are used for training\n"
+    "and the remaining 4000 (10000 for boosting) - to test the classifier.\n"
+    "======================================================\n");
+    printf("\nThis is letter recognition sample.\n"
+            "The usage: %s [-data=<path to letter-recognition.data>] \\\n"
+            "  [-save=<output XML file for the classifier>] \\\n"
+            "  [-load=<XML file with the pre-trained classifier>] \\\n"
+            "  [-boost|-mlp|-knearest|-nbayes|-svm] # to use boost/mlp/knearest/SVM classifier instead of default Random Trees\n", argv[0] );
+}
+
+// This function reads data and responses from the file <filename>
+static bool
+read_num_class_data( const string& filename, int var_count,
+                     Mat* _data, Mat* _responses )
+{
+    const int M = 1024;
+    char buf[M+2];
+
+    Mat el_ptr(1, var_count, CV_32F);
+    int i;
+    vector<int> responses;
+
+    _data->release();
+    _responses->release();
+
+    FILE* f = fopen( filename.c_str(), "rt" );
+    if( !f )
+    {
+        cout << "Could not read the database " << filename << endl;
+        return false;
+    }
+
+    for(;;)
+    {
+        char* ptr;
+        if( !fgets( buf, M, f ) || !strchr( buf, ',' ) )
+            break;
+        responses.push_back((int)buf[0]);
+        ptr = buf+2;
+        for( i = 0; i < var_count; i++ )
+        {
+            int n = 0;
+            sscanf( ptr, "%f%n", &el_ptr.at<float>(i), &n );
+            ptr += n + 1;
+        }
+        if( i < var_count )
+            break;
+        _data->push_back(el_ptr);
+    }
+    fclose(f);
+    Mat(responses).copyTo(*_responses);
+
+    cout << "The database " << filename << " is loaded.\n";
+
+    return true;
+}
+
+template<typename T>
+static Ptr<T> load_classifier(const string& filename_to_load)
+{
+    // load classifier from the specified file
+    Ptr<T> model = StatModel::load<T>( filename_to_load );
+    if( model.empty() )
+        cout << "Could not read the classifier " << filename_to_load << endl;
+    else
+        cout << "The classifier " << filename_to_load << " is loaded.\n";
+
+    return model;
+}
+
+static Ptr<TrainData>
+prepare_train_data(const Mat& data, const Mat& responses, int ntrain_samples)
+{
+    Mat sample_idx = Mat::zeros( 1, data.rows, CV_8U );
+    Mat train_samples = sample_idx.colRange(0, ntrain_samples);
+    train_samples.setTo(Scalar::all(1));
+
+    int nvars = data.cols;
+    Mat var_type( nvars + 1, 1, CV_8U );
+    var_type.setTo(Scalar::all(VAR_ORDERED));
+    var_type.at<uchar>(nvars) = VAR_CATEGORICAL;
+
+    return TrainData::create(data, ROW_SAMPLE, responses,
+                             noArray(), sample_idx, noArray(), var_type);
+}
+
+inline TermCriteria TC(int iters, double eps)
+{
+    return TermCriteria(TermCriteria::MAX_ITER + (eps > 0 ? TermCriteria::EPS : 0), iters, eps);
+}
+
+static void test_and_save_classifier(const Ptr<StatModel>& model,
+                                     const Mat& data, const Mat& responses,
+                                     int ntrain_samples, int rdelta,
+                                     const string& filename_to_save)
+{
+    int i, nsamples_all = data.rows;
+    double train_hr = 0, test_hr = 0;
+
+    // compute prediction error on train and test data
+    for( i = 0; i < nsamples_all; i++ )
+    {
+        Mat sample = data.row(i);
+
+        float r = model->predict( sample );
+        r = std::abs(r + rdelta - responses.at<int>(i)) <= FLT_EPSILON ? 1.f : 0.f;
+
+        if( i < ntrain_samples )
+            train_hr += r;
+        else
+            test_hr += r;
+    }
+
+    test_hr /= nsamples_all - ntrain_samples;
+    train_hr = ntrain_samples > 0 ? train_hr/ntrain_samples : 1.;
+
+    printf( "Recognition rate: train = %.1f%%, test = %.1f%%\n",
+            train_hr*100., test_hr*100. );
+
+    if( !filename_to_save.empty() )
+    {
+        model->save( filename_to_save );
+    }
+}
+
+
+static bool
+build_rtrees_classifier( const string& data_filename,
+                         const string& filename_to_save,
+                         const string& filename_to_load )
+{
+    Mat data;
+    Mat responses;
+    bool ok = read_num_class_data( data_filename, 16, &data, &responses );
+    if( !ok )
+        return ok;
+
+    Ptr<RTrees> model;
+
+    int nsamples_all = data.rows;
+    int ntrain_samples = (int)(nsamples_all*0.8);
+
+    // Create or load Random Trees classifier
+    if( !filename_to_load.empty() )
+    {
+        model = load_classifier<RTrees>(filename_to_load);
+        if( model.empty() )
+            return false;
+        ntrain_samples = 0;
+    }
+    else
+    {
+        // create classifier by using <data> and <responses>
+        cout << "Training the classifier ...\n";
+//        Params( int maxDepth, int minSampleCount,
+//                   double regressionAccuracy, bool useSurrogates,
+//                   int maxCategories, const Mat& priors,
+//                   bool calcVarImportance, int nactiveVars,
+//                   TermCriteria termCrit );
+        Ptr<TrainData> tdata = prepare_train_data(data, responses, ntrain_samples);
+        model = RTrees::create();
+        model->setMaxDepth(10);
+        model->setMinSampleCount(10);
+        model->setRegressionAccuracy(0);
+        model->setUseSurrogates(false);
+        model->setMaxCategories(15);
+        model->setPriors(Mat());
+        model->setCalculateVarImportance(true);
+        model->setActiveVarCount(4);
+        model->setTermCriteria(TC(100,0.01f));
+        model->train(tdata);
+        cout << endl;
+    }
+
+    test_and_save_classifier(model, data, responses, ntrain_samples, 0, filename_to_save);
+    cout << "Number of trees: " << model->getRoots().size() << endl;
+
+    // Print variable importance
+    Mat var_importance = model->getVarImportance();
+    if( !var_importance.empty() )
+    {
+        double rt_imp_sum = sum( var_importance )[0];
+        printf("var#\timportance (in %%):\n");
+        int i, n = (int)var_importance.total();
+        for( i = 0; i < n; i++ )
+            printf( "%-2d\t%-4.1f\n", i, 100.f*var_importance.at<float>(i)/rt_imp_sum);
+    }
+
+    return true;
+}
+
+
+static bool
+build_boost_classifier( const string& data_filename,
+                        const string& filename_to_save,
+                        const string& filename_to_load )
+{
+    const int class_count = 26;
+    Mat data;
+    Mat responses;
+    Mat weak_responses;
+
+    bool ok = read_num_class_data( data_filename, 16, &data, &responses );
+    if( !ok )
+        return ok;
+
+    int i, j, k;
+    Ptr<Boost> model;
+
+    int nsamples_all = data.rows;
+    int ntrain_samples = (int)(nsamples_all*0.5);
+    int var_count = data.cols;
+
+    // Create or load Boosted Tree classifier
+    if( !filename_to_load.empty() )
+    {
+        model = load_classifier<Boost>(filename_to_load);
+        if( model.empty() )
+            return false;
+        ntrain_samples = 0;
+    }
+    else
+    {
+        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        //
+        // As currently boosted tree classifier in MLL can only be trained
+        // for 2-class problems, we transform the training database by
+        // "unrolling" each training sample as many times as the number of
+        // classes (26) that we have.
+        //
+        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+        Mat new_data( ntrain_samples*class_count, var_count + 1, CV_32F );
+        Mat new_responses( ntrain_samples*class_count, 1, CV_32S );
+
+        // 1. unroll the database type mask
+        printf( "Unrolling the database...\n");
+        for( i = 0; i < ntrain_samples; i++ )
+        {
+            const float* data_row = data.ptr<float>(i);
+            for( j = 0; j < class_count; j++ )
+            {
+                float* new_data_row = (float*)new_data.ptr<float>(i*class_count+j);
+                memcpy(new_data_row, data_row, var_count*sizeof(data_row[0]));
+                new_data_row[var_count] = (float)j;
+                new_responses.at<int>(i*class_count + j) = responses.at<int>(i) == j+'A';
+            }
+        }
+
+        Mat var_type( 1, var_count + 2, CV_8U );
+        var_type.setTo(Scalar::all(VAR_ORDERED));
+        var_type.at<uchar>(var_count) = var_type.at<uchar>(var_count+1) = VAR_CATEGORICAL;
+
+        Ptr<TrainData> tdata = TrainData::create(new_data, ROW_SAMPLE, new_responses,
+                                                 noArray(), noArray(), noArray(), var_type);
+        vector<double> priors(2);
+        priors[0] = 1;
+        priors[1] = 26;
+
+        cout << "Training the classifier (may take a few minutes)...\n";
+        model = Boost::create();
+        model->setBoostType(Boost::GENTLE);
+        model->setWeakCount(100);
+        model->setWeightTrimRate(0.95);
+        model->setMaxDepth(5);
+        model->setUseSurrogates(false);
+        model->setPriors(Mat(priors));
+        model->train(tdata);
+        cout << endl;
+    }
+
+    Mat temp_sample( 1, var_count + 1, CV_32F );
+    float* tptr = temp_sample.ptr<float>();
+
+    // compute prediction error on train and test data
+    double train_hr = 0, test_hr = 0;
+    for( i = 0; i < nsamples_all; i++ )
+    {
+        int best_class = 0;
+        double max_sum = -DBL_MAX;
+        const float* ptr = data.ptr<float>(i);
+        for( k = 0; k < var_count; k++ )
+            tptr[k] = ptr[k];
+
+        for( j = 0; j < class_count; j++ )
+        {
+            tptr[var_count] = (float)j;
+            float s = model->predict( temp_sample, noArray(), StatModel::RAW_OUTPUT );
+            if( max_sum < s )
+            {
+                max_sum = s;
+                best_class = j + 'A';
+            }
+        }
+
+        double r = std::abs(best_class - responses.at<int>(i)) < FLT_EPSILON ? 1 : 0;
+        if( i < ntrain_samples )
+            train_hr += r;
+        else
+            test_hr += r;
+    }
+
+    test_hr /= nsamples_all-ntrain_samples;
+    train_hr = ntrain_samples > 0 ? train_hr/ntrain_samples : 1.;
+    printf( "Recognition rate: train = %.1f%%, test = %.1f%%\n",
+            train_hr*100., test_hr*100. );
+
+    cout << "Number of trees: " << model->getRoots().size() << endl;
+
+    // Save classifier to file if needed
+    if( !filename_to_save.empty() )
+        model->save( filename_to_save );
+
+    return true;
+}
+
+
+static bool
+build_mlp_classifier( const string& data_filename,
+                      const string& filename_to_save,
+                      const string& filename_to_load )
+{
+    const int class_count = 26;
+    Mat data;
+    Mat responses;
+
+    bool ok = read_num_class_data( data_filename, 16, &data, &responses );
+    if( !ok )
+        return ok;
+
+    Ptr<ANN_MLP> model;
+
+    int nsamples_all = data.rows;
+    int ntrain_samples = (int)(nsamples_all*0.8);
+
+    // Create or load MLP classifier
+    if( !filename_to_load.empty() )
+    {
+        model = load_classifier<ANN_MLP>(filename_to_load);
+        if( model.empty() )
+            return false;
+        ntrain_samples = 0;
+    }
+    else
+    {
+        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        //
+        // MLP does not support categorical variables by explicitly.
+        // So, instead of the output class label, we will use
+        // a binary vector of <class_count> components for training and,
+        // therefore, MLP will give us a vector of "probabilities" at the
+        // prediction stage
+        //
+        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+        Mat train_data = data.rowRange(0, ntrain_samples);
+        Mat train_responses = Mat::zeros( ntrain_samples, class_count, CV_32F );
+
+        // 1. unroll the responses
+        cout << "Unrolling the responses...\n";
+        for( int i = 0; i < ntrain_samples; i++ )
+        {
+            int cls_label = responses.at<int>(i) - 'A';
+            train_responses.at<float>(i, cls_label) = 1.f;
+        }
+
+        // 2. train classifier
+        int layer_sz[] = { data.cols, 100, 100, class_count };
+        int nlayers = (int)(sizeof(layer_sz)/sizeof(layer_sz[0]));
+        Mat layer_sizes( 1, nlayers, CV_32S, layer_sz );
+
+#if 1
+        int method = ANN_MLP::BACKPROP;
+        double method_param = 0.001;
+        int max_iter = 300;
+#else
+        int method = ANN_MLP::RPROP;
+        double method_param = 0.1;
+        int max_iter = 1000;
+#endif
+
+        Ptr<TrainData> tdata = TrainData::create(train_data, ROW_SAMPLE, train_responses);
+
+        cout << "Training the classifier (may take a few minutes)...\n";
+        model = ANN_MLP::create();
+        model->setLayerSizes(layer_sizes);
+        model->setActivationFunction(ANN_MLP::SIGMOID_SYM, 0, 0);
+        model->setTermCriteria(TC(max_iter,0));
+        model->setTrainMethod(method, method_param);
+        model->train(tdata);
+        cout << endl;
+    }
+
+    test_and_save_classifier(model, data, responses, ntrain_samples, 'A', filename_to_save);
+    return true;
+}
+
+static bool
+build_knearest_classifier( const string& data_filename, int K )
+{
+    Mat data;
+    Mat responses;
+    bool ok = read_num_class_data( data_filename, 16, &data, &responses );
+    if( !ok )
+        return ok;
+
+
+    int nsamples_all = data.rows;
+    int ntrain_samples = (int)(nsamples_all*0.8);
+
+    // create classifier by using <data> and <responses>
+    cout << "Training the classifier ...\n";
+    Ptr<TrainData> tdata = prepare_train_data(data, responses, ntrain_samples);
+    Ptr<KNearest> model = KNearest::create();
+    model->setDefaultK(K);
+    model->setIsClassifier(true);
+    model->train(tdata);
+    cout << endl;
+
+    test_and_save_classifier(model, data, responses, ntrain_samples, 0, string());
+    return true;
+}
+
+static bool
+build_nbayes_classifier( const string& data_filename )
+{
+    Mat data;
+    Mat responses;
+    bool ok = read_num_class_data( data_filename, 16, &data, &responses );
+    if( !ok )
+        return ok;
+
+    Ptr<NormalBayesClassifier> model;
+
+    int nsamples_all = data.rows;
+    int ntrain_samples = (int)(nsamples_all*0.8);
+
+    // create classifier by using <data> and <responses>
+    cout << "Training the classifier ...\n";
+    Ptr<TrainData> tdata = prepare_train_data(data, responses, ntrain_samples);
+    model = NormalBayesClassifier::create();
+    model->train(tdata);
+    cout << endl;
+
+    test_and_save_classifier(model, data, responses, ntrain_samples, 0, string());
+    return true;
+}
+
+static bool
+build_svm_classifier( const string& data_filename,
+                      const string& filename_to_save,
+                      const string& filename_to_load )
+{
+    Mat data;
+    Mat responses;
+    bool ok = read_num_class_data( data_filename, 16, &data, &responses );
+    if( !ok )
+        return ok;
+
+    Ptr<SVM> model;
+
+    int nsamples_all = data.rows;
+    int ntrain_samples = (int)(nsamples_all*0.8);
+
+    // Create or load Random Trees classifier
+    if( !filename_to_load.empty() )
+    {
+        model = load_classifier<SVM>(filename_to_load);
+        if( model.empty() )
+            return false;
+        ntrain_samples = 0;
+    }
+    else
+    {
+        // create classifier by using <data> and <responses>
+        cout << "Training the classifier ...\n";
+        Ptr<TrainData> tdata = prepare_train_data(data, responses, ntrain_samples);
+        model = SVM::create();
+        model->setType(SVM::C_SVC);
+        model->setKernel(SVM::LINEAR);
+        model->setC(1);
+        model->train(tdata);
+        cout << endl;
+    }
+
+    test_and_save_classifier(model, data, responses, ntrain_samples, 0, filename_to_save);
+    return true;
+}
+
+int main( int argc, char *argv[] )
+{
+    string filename_to_save = "";
+    string filename_to_load = "";
+    string data_filename;
+    int method = 0;
+
+    cv::CommandLineParser parser(argc, argv, "{data|letter-recognition.data|}{save||}{load||}{boost||}"
+            "{mlp||}{knn knearest||}{nbayes||}{svm||}");
+    data_filename = samples::findFile(parser.get<string>("data"));
+    if (parser.has("save"))
+        filename_to_save = parser.get<string>("save");
+    if (parser.has("load"))
+        filename_to_load = samples::findFile(parser.get<string>("load"));
+    if (parser.has("boost"))
+        method = 1;
+    else if (parser.has("mlp"))
+        method = 2;
+    else if (parser.has("knearest"))
+        method = 3;
+    else if (parser.has("nbayes"))
+        method = 4;
+    else if (parser.has("svm"))
+        method = 5;
+
+    help(argv);
+
+    if( (method == 0 ?
+        build_rtrees_classifier( data_filename, filename_to_save, filename_to_load ) :
+        method == 1 ?
+        build_boost_classifier( data_filename, filename_to_save, filename_to_load ) :
+        method == 2 ?
+        build_mlp_classifier( data_filename, filename_to_save, filename_to_load ) :
+        method == 3 ?
+        build_knearest_classifier( data_filename, 10 ) :
+        method == 4 ?
+        build_nbayes_classifier( data_filename) :
+        method == 5 ?
+        build_svm_classifier( data_filename, filename_to_save, filename_to_load ):
+        -1) < 0)
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/lkdemo.cpp b/C++/opencv-4.7.0/samples/cpp/lkdemo.cpp
new file mode 100644
index 00000000..29f1419c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/lkdemo.cpp
@@ -0,0 +1,151 @@
+#include "opencv2/video/tracking.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+#include <ctype.h>
+
+using namespace cv;
+using namespace std;
+
+static void help()
+{
+    // print a welcome message, and the OpenCV version
+    cout << "\nThis is a demo of Lukas-Kanade optical flow lkdemo(),\n"
+            "Using OpenCV version " << CV_VERSION << endl;
+    cout << "\nIt uses camera by default, but you can provide a path to video as an argument.\n";
+    cout << "\nHot keys: \n"
+            "\tESC - quit the program\n"
+            "\tr - auto-initialize tracking\n"
+            "\tc - delete all the points\n"
+            "\tn - switch the \"night\" mode on/off\n"
+            "To add/remove a feature point click it\n" << endl;
+}
+
+Point2f point;
+bool addRemovePt = false;
+
+static void onMouse( int event, int x, int y, int /*flags*/, void* /*param*/ )
+{
+    if( event == EVENT_LBUTTONDOWN )
+    {
+        point = Point2f((float)x, (float)y);
+        addRemovePt = true;
+    }
+}
+
+int main( int argc, char** argv )
+{
+    VideoCapture cap;
+    TermCriteria termcrit(TermCriteria::COUNT|TermCriteria::EPS,20,0.03);
+    Size subPixWinSize(10,10), winSize(31,31);
+
+    const int MAX_COUNT = 500;
+    bool needToInit = false;
+    bool nightMode = false;
+
+    help();
+    cv::CommandLineParser parser(argc, argv, "{@input|0|}");
+    string input = parser.get<string>("@input");
+
+    if( input.size() == 1 && isdigit(input[0]) )
+        cap.open(input[0] - '0');
+    else
+        cap.open(input);
+
+    if( !cap.isOpened() )
+    {
+        cout << "Could not initialize capturing...\n";
+        return 0;
+    }
+
+    namedWindow( "LK Demo", 1 );
+    setMouseCallback( "LK Demo", onMouse, 0 );
+
+    Mat gray, prevGray, image, frame;
+    vector<Point2f> points[2];
+
+    for(;;)
+    {
+        cap >> frame;
+        if( frame.empty() )
+            break;
+
+        frame.copyTo(image);
+        cvtColor(image, gray, COLOR_BGR2GRAY);
+
+        if( nightMode )
+            image = Scalar::all(0);
+
+        if( needToInit )
+        {
+            // automatic initialization
+            goodFeaturesToTrack(gray, points[1], MAX_COUNT, 0.01, 10, Mat(), 3, 3, 0, 0.04);
+            cornerSubPix(gray, points[1], subPixWinSize, Size(-1,-1), termcrit);
+            addRemovePt = false;
+        }
+        else if( !points[0].empty() )
+        {
+            vector<uchar> status;
+            vector<float> err;
+            if(prevGray.empty())
+                gray.copyTo(prevGray);
+            calcOpticalFlowPyrLK(prevGray, gray, points[0], points[1], status, err, winSize,
+                                 3, termcrit, 0, 0.001);
+            size_t i, k;
+            for( i = k = 0; i < points[1].size(); i++ )
+            {
+                if( addRemovePt )
+                {
+                    if( norm(point - points[1][i]) <= 5 )
+                    {
+                        addRemovePt = false;
+                        continue;
+                    }
+                }
+
+                if( !status[i] )
+                    continue;
+
+                points[1][k++] = points[1][i];
+                circle( image, points[1][i], 3, Scalar(0,255,0), -1, 8);
+            }
+            points[1].resize(k);
+        }
+
+        if( addRemovePt && points[1].size() < (size_t)MAX_COUNT )
+        {
+            vector<Point2f> tmp;
+            tmp.push_back(point);
+            cornerSubPix( gray, tmp, winSize, Size(-1,-1), termcrit);
+            points[1].push_back(tmp[0]);
+            addRemovePt = false;
+        }
+
+        needToInit = false;
+        imshow("LK Demo", image);
+
+        char c = (char)waitKey(10);
+        if( c == 27 )
+            break;
+        switch( c )
+        {
+        case 'r':
+            needToInit = true;
+            break;
+        case 'c':
+            points[0].clear();
+            points[1].clear();
+            break;
+        case 'n':
+            nightMode = !nightMode;
+            break;
+        }
+
+        std::swap(points[1], points[0]);
+        cv::swap(prevGray, gray);
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/logistic_regression.cpp b/C++/opencv-4.7.0/samples/cpp/logistic_regression.cpp
new file mode 100644
index 00000000..1bc2bf97
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/logistic_regression.cpp
@@ -0,0 +1,127 @@
+// Logistic Regression sample
+// AUTHOR: Rahul Kavi rahulkavi[at]live[at]com
+
+#include <iostream>
+
+#include <opencv2/core.hpp>
+#include <opencv2/ml.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace std;
+using namespace cv;
+using namespace cv::ml;
+
+static void showImage(const Mat &data, int columns, const String &name)
+{
+    Mat bigImage;
+    for(int i = 0; i < data.rows; ++i)
+    {
+        bigImage.push_back(data.row(i).reshape(0, columns));
+    }
+    imshow(name, bigImage.t());
+}
+
+static float calculateAccuracyPercent(const Mat &original, const Mat &predicted)
+{
+    return 100 * (float)countNonZero(original == predicted) / predicted.rows;
+}
+
+int main()
+{
+    const String filename = samples::findFile("data01.xml");
+    cout << "**********************************************************************" << endl;
+    cout << filename
+         << " contains digits 0 and 1 of 20 samples each, collected on an Android device" << endl;
+    cout << "Each of the collected images are of size 28 x 28 re-arranged to 1 x 784 matrix"
+         << endl;
+    cout << "**********************************************************************" << endl;
+
+    Mat data, labels;
+    {
+        cout << "loading the dataset...";
+        FileStorage f;
+        if(f.open(filename, FileStorage::READ))
+        {
+            f["datamat"] >> data;
+            f["labelsmat"] >> labels;
+            f.release();
+        }
+        else
+        {
+            cerr << "file can not be opened: " << filename << endl;
+            return 1;
+        }
+        data.convertTo(data, CV_32F);
+        labels.convertTo(labels, CV_32F);
+        cout << "read " << data.rows << " rows of data" << endl;
+    }
+
+    Mat data_train, data_test;
+    Mat labels_train, labels_test;
+    for(int i = 0; i < data.rows; i++)
+    {
+        if(i % 2 == 0)
+        {
+            data_train.push_back(data.row(i));
+            labels_train.push_back(labels.row(i));
+        }
+        else
+        {
+            data_test.push_back(data.row(i));
+            labels_test.push_back(labels.row(i));
+        }
+    }
+    cout << "training/testing samples count: " << data_train.rows << "/" << data_test.rows << endl;
+
+    // display sample image
+    showImage(data_train, 28, "train data");
+    showImage(data_test, 28, "test data");
+
+    // simple case with batch gradient
+    cout << "training...";
+    //! [init]
+    Ptr<LogisticRegression> lr1 = LogisticRegression::create();
+    lr1->setLearningRate(0.001);
+    lr1->setIterations(10);
+    lr1->setRegularization(LogisticRegression::REG_L2);
+    lr1->setTrainMethod(LogisticRegression::BATCH);
+    lr1->setMiniBatchSize(1);
+    //! [init]
+    lr1->train(data_train, ROW_SAMPLE, labels_train);
+    cout << "done!" << endl;
+
+    cout << "predicting...";
+    Mat responses;
+    lr1->predict(data_test, responses);
+    cout << "done!" << endl;
+
+    // show prediction report
+    cout << "original vs predicted:" << endl;
+    labels_test.convertTo(labels_test, CV_32S);
+    cout << labels_test.t() << endl;
+    cout << responses.t() << endl;
+    cout << "accuracy: " << calculateAccuracyPercent(labels_test, responses) << "%" << endl;
+
+    // save the classifier
+    const String saveFilename = "NewLR_Trained.xml";
+    cout << "saving the classifier to " << saveFilename << endl;
+    lr1->save(saveFilename);
+
+    // load the classifier onto new object
+    cout << "loading a new classifier from " << saveFilename << endl;
+    Ptr<LogisticRegression> lr2 = StatModel::load<LogisticRegression>(saveFilename);
+
+    // predict using loaded classifier
+    cout << "predicting the dataset using the loaded classifier...";
+    Mat responses2;
+    lr2->predict(data_test, responses2);
+    cout << "done!" << endl;
+
+    // calculate accuracy
+    cout << labels_test.t() << endl;
+    cout << responses2.t() << endl;
+    cout << "accuracy: " << calculateAccuracyPercent(labels_test, responses2) << "%" << endl;
+
+    waitKey(0);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/lsd_lines.cpp b/C++/opencv-4.7.0/samples/cpp/lsd_lines.cpp
new file mode 100644
index 00000000..3feed9cb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/lsd_lines.cpp
@@ -0,0 +1,73 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv,
+                                 "{input   i|building.jpg|input image}"
+                                 "{refine  r|false|if true use LSD_REFINE_STD method, if false use LSD_REFINE_NONE method}"
+                                 "{canny   c|false|use Canny edge detector}"
+                                 "{overlay o|false|show result on input image}"
+                                 "{help    h|false|show help message}");
+
+    if (parser.get<bool>("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    parser.printMessage();
+
+    String filename = samples::findFile(parser.get<String>("input"));
+    bool useRefine = parser.get<bool>("refine");
+    bool useCanny = parser.get<bool>("canny");
+    bool overlay = parser.get<bool>("overlay");
+
+    Mat image = imread(filename, IMREAD_GRAYSCALE);
+
+    if( image.empty() )
+    {
+        cout << "Unable to load " << filename;
+        return 1;
+    }
+
+    imshow("Source Image", image);
+
+    if (useCanny)
+    {
+        Canny(image, image, 50, 200, 3); // Apply Canny edge detector
+    }
+
+    // Create and LSD detector with standard or no refinement.
+    Ptr<LineSegmentDetector> ls = useRefine ? createLineSegmentDetector(LSD_REFINE_STD) : createLineSegmentDetector(LSD_REFINE_NONE);
+
+    double start = double(getTickCount());
+    vector<Vec4f> lines_std;
+
+    // Detect the lines
+    ls->detect(image, lines_std);
+
+    double duration_ms = (double(getTickCount()) - start) * 1000 / getTickFrequency();
+    std::cout << "It took " << duration_ms << " ms." << std::endl;
+
+    // Show found lines
+    if (!overlay || useCanny)
+    {
+        image = Scalar(0, 0, 0);
+    }
+
+    ls->drawSegments(image, lines_std);
+
+    String window_name = useRefine ? "Result - standard refinement" : "Result - no refinement";
+    window_name += useCanny ? " - Canny edge detector used" : "";
+
+    imshow(window_name, image);
+
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/mask_tmpl.cpp b/C++/opencv-4.7.0/samples/cpp/mask_tmpl.cpp
new file mode 100644
index 00000000..5e374186
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/mask_tmpl.cpp
@@ -0,0 +1,74 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main( int argc, const char** argv )
+{
+    CommandLineParser parser(argc, argv,
+        "{ i | lena_tmpl.jpg |image name }"
+        "{ t | tmpl.png |template name }"
+        "{ m | mask.png |mask name }"
+        "{ cm| 3 |comparison method }");
+
+    cout << "This program demonstrates the use of template matching with mask." << endl
+         << endl
+         << "Available methods: https://docs.opencv.org/4.x/df/dfb/group__imgproc__object.html#ga3a7850640f1fe1f58fe91a2d7583695d" << endl
+         << "    TM_SQDIFF = " << (int)TM_SQDIFF << endl
+         << "    TM_SQDIFF_NORMED = " << (int)TM_SQDIFF_NORMED << endl
+         << "    TM_CCORR = " << (int)TM_CCORR << endl
+         << "    TM_CCORR_NORMED = " << (int)TM_CCORR_NORMED << endl
+         << "    TM_CCOEFF = " << (int)TM_CCOEFF << endl
+         << "    TM_CCOEFF_NORMED = " << (int)TM_CCOEFF_NORMED << endl
+         << endl;
+
+    parser.printMessage();
+
+    string filename = samples::findFile(parser.get<string>("i"));
+    string tmplname = samples::findFile(parser.get<string>("t"));
+    string maskname = samples::findFile(parser.get<string>("m"));
+    Mat img = imread(filename);
+    Mat tmpl = imread(tmplname);
+    Mat mask = imread(maskname);
+    Mat res;
+
+    if(img.empty())
+    {
+        cout << "can not open " << filename << endl;
+        return -1;
+    }
+
+    if(tmpl.empty())
+    {
+        cout << "can not open " << tmplname << endl;
+        return -1;
+    }
+
+    if(mask.empty())
+    {
+        cout << "can not open " << maskname << endl;
+        return -1;
+    }
+
+    int method = parser.get<int>("cm"); // default 3 (CV_TM_CCORR_NORMED)
+    matchTemplate(img, tmpl, res, method, mask);
+
+    double minVal, maxVal;
+    Point minLoc, maxLoc;
+    Rect rect;
+    minMaxLoc(res, &minVal, &maxVal, &minLoc, &maxLoc);
+
+    if(method == TM_SQDIFF || method == TM_SQDIFF_NORMED)
+        rect = Rect(minLoc, tmpl.size());
+    else
+        rect = Rect(maxLoc, tmpl.size());
+
+    rectangle(img, rect, Scalar(0, 255, 0), 2);
+
+    imshow("detected template", img);
+    waitKey();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/matchmethod_orb_akaze_brisk.cpp b/C++/opencv-4.7.0/samples/cpp/matchmethod_orb_akaze_brisk.cpp
new file mode 100644
index 00000000..62f56b8e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/matchmethod_orb_akaze_brisk.cpp
@@ -0,0 +1,186 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/features2d.hpp>
+#include <opencv2/highgui.hpp>
+#include <vector>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static void help(char* argv[])
+{
+    cout << "\n This program demonstrates how to detect compute and match ORB BRISK and AKAZE descriptors \n"
+            "Usage: \n  "
+         << argv[0] << " --image1=<image1(basketball1.png as default)> --image2=<image2(basketball2.png as default)>\n"
+        "Press a key when image window is active to change algorithm or descriptor";
+}
+
+
+
+int main(int argc, char *argv[])
+{
+    vector<String> typeDesc;
+    vector<String> typeAlgoMatch;
+    vector<String> fileName;
+    // This descriptor are going to be detect and compute
+    typeDesc.push_back("AKAZE-DESCRIPTOR_KAZE_UPRIGHT");    // see https://docs.opencv.org/4.x/d8/d30/classcv_1_1AKAZE.html
+    typeDesc.push_back("AKAZE");    // see http://docs.opencv.org/4.x/d8/d30/classcv_1_1AKAZE.html
+    typeDesc.push_back("ORB");      // see http://docs.opencv.org/4.x/de/dbf/classcv_1_1BRISK.html
+    typeDesc.push_back("BRISK");    // see http://docs.opencv.org/4.x/db/d95/classcv_1_1ORB.html
+    // This algorithm would be used to match descriptors see http://docs.opencv.org/4.x/db/d39/classcv_1_1DescriptorMatcher.html#ab5dc5036569ecc8d47565007fa518257
+    typeAlgoMatch.push_back("BruteForce");
+    typeAlgoMatch.push_back("BruteForce-L1");
+    typeAlgoMatch.push_back("BruteForce-Hamming");
+    typeAlgoMatch.push_back("BruteForce-Hamming(2)");
+    cv::CommandLineParser parser(argc, argv,
+        "{ @image1 | basketball1.png | }"
+        "{ @image2 | basketball2.png | }"
+        "{help h ||}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    fileName.push_back(samples::findFile(parser.get<string>(0)));
+    fileName.push_back(samples::findFile(parser.get<string>(1)));
+    Mat img1 = imread(fileName[0], IMREAD_GRAYSCALE);
+    Mat img2 = imread(fileName[1], IMREAD_GRAYSCALE);
+    if (img1.empty())
+    {
+        cerr << "Image " << fileName[0] << " is empty or cannot be found" << endl;
+        return 1;
+    }
+    if (img2.empty())
+    {
+        cerr << "Image " << fileName[1] << " is empty or cannot be found" << endl;
+        return 1;
+    }
+
+    vector<double> desMethCmp;
+    Ptr<Feature2D> b;
+
+    // Descriptor loop
+    vector<String>::iterator itDesc;
+    for (itDesc = typeDesc.begin(); itDesc != typeDesc.end(); ++itDesc)
+    {
+        Ptr<DescriptorMatcher> descriptorMatcher;
+        // Match between img1 and img2
+        vector<DMatch> matches;
+        // keypoint  for img1 and img2
+        vector<KeyPoint> keyImg1, keyImg2;
+        // Descriptor for img1 and img2
+        Mat descImg1, descImg2;
+        vector<String>::iterator itMatcher = typeAlgoMatch.end();
+        if (*itDesc == "AKAZE-DESCRIPTOR_KAZE_UPRIGHT"){
+            b = AKAZE::create(AKAZE::DESCRIPTOR_KAZE_UPRIGHT);
+        }
+        if (*itDesc == "AKAZE"){
+            b = AKAZE::create();
+        }
+        if (*itDesc == "ORB"){
+            b = ORB::create();
+        }
+        else if (*itDesc == "BRISK"){
+            b = BRISK::create();
+        }
+        try
+        {
+            // We can detect keypoint with detect method
+            b->detect(img1, keyImg1, Mat());
+            // and compute their descriptors with method  compute
+            b->compute(img1, keyImg1, descImg1);
+            // or detect and compute descriptors in one step
+            b->detectAndCompute(img2, Mat(),keyImg2, descImg2,false);
+            // Match method loop
+            for (itMatcher = typeAlgoMatch.begin(); itMatcher != typeAlgoMatch.end(); ++itMatcher){
+                descriptorMatcher = DescriptorMatcher::create(*itMatcher);
+                if ((*itMatcher == "BruteForce-Hamming" || *itMatcher == "BruteForce-Hamming(2)") && (b->descriptorType() == CV_32F || b->defaultNorm() <= NORM_L2SQR))
+                {
+                    cout << "**************************************************************************\n";
+                    cout << "It's strange. You should use Hamming distance only for a binary descriptor\n";
+                    cout << "**************************************************************************\n";
+                }
+                if ((*itMatcher == "BruteForce" || *itMatcher == "BruteForce-L1") && (b->defaultNorm() >= NORM_HAMMING))
+                {
+                    cout << "**************************************************************************\n";
+                    cout << "It's strange. You shouldn't use L1 or L2 distance for a binary descriptor\n";
+                    cout << "**************************************************************************\n";
+                }
+                try
+                {
+                    descriptorMatcher->match(descImg1, descImg2, matches, Mat());
+                    // Keep best matches only to have a nice drawing.
+                    // We sort distance between descriptor matches
+                    Mat index;
+                    int nbMatch=int(matches.size());
+                    Mat tab(nbMatch, 1, CV_32F);
+                    for (int i = 0; i<nbMatch; i++)
+                    {
+                        tab.at<float>(i, 0) = matches[i].distance;
+                    }
+                    sortIdx(tab, index, SORT_EVERY_COLUMN + SORT_ASCENDING);
+                    vector<DMatch> bestMatches;
+                    for (int i = 0; i<30; i++)
+                    {
+                        bestMatches.push_back(matches[index.at<int>(i, 0)]);
+                    }
+                    Mat result;
+                    drawMatches(img1, keyImg1, img2, keyImg2, bestMatches, result);
+                    namedWindow(*itDesc+": "+*itMatcher, WINDOW_AUTOSIZE);
+                    imshow(*itDesc + ": " + *itMatcher, result);
+                    // Saved result could be wrong due to bug 4308
+                    FileStorage fs(*itDesc + "_" + *itMatcher + ".yml", FileStorage::WRITE);
+                    fs<<"Matches"<<matches;
+                    vector<DMatch>::iterator it;
+                    cout<<"**********Match results**********\n";
+                    cout << "Index \tIndex \tdistance\n";
+                    cout << "in img1\tin img2\n";
+                    // Use to compute distance between keyPoint matches and to evaluate match algorithm
+                    double cumSumDist2=0;
+                    for (it = bestMatches.begin(); it != bestMatches.end(); ++it)
+                    {
+                        cout << it->queryIdx << "\t" <<  it->trainIdx << "\t"  <<  it->distance << "\n";
+                        Point2d p=keyImg1[it->queryIdx].pt-keyImg2[it->trainIdx].pt;
+                        cumSumDist2=p.x*p.x+p.y*p.y;
+                    }
+                    desMethCmp.push_back(cumSumDist2);
+                    waitKey();
+                }
+                catch (const Exception& e)
+                {
+                    cout << e.msg << endl;
+                    cout << "Cumulative distance cannot be computed." << endl;
+                    desMethCmp.push_back(-1);
+                }
+            }
+        }
+        catch (const Exception& e)
+        {
+            cerr << "Exception: " << e.what() << endl;
+            cout << "Feature : " << *itDesc << "\n";
+            if (itMatcher != typeAlgoMatch.end())
+            {
+                cout << "Matcher : " << *itMatcher << "\n";
+            }
+        }
+    }
+    int i=0;
+    cout << "Cumulative distance between keypoint match for different algorithm and feature detector \n\t";
+    cout << "We cannot say which is the best but we can say results are different! \n\t";
+    for (vector<String>::iterator itMatcher = typeAlgoMatch.begin(); itMatcher != typeAlgoMatch.end(); ++itMatcher)
+    {
+        cout<<*itMatcher<<"\t";
+    }
+    cout << "\n";
+    for (itDesc = typeDesc.begin(); itDesc != typeDesc.end(); ++itDesc)
+    {
+        cout << *itDesc << "\t";
+        for (vector<String>::iterator itMatcher = typeAlgoMatch.begin(); itMatcher != typeAlgoMatch.end(); ++itMatcher, ++i)
+        {
+            cout << desMethCmp[i]<<"\t";
+        }
+        cout<<"\n";
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/minarea.cpp b/C++/opencv-4.7.0/samples/cpp/minarea.cpp
new file mode 100644
index 00000000..97264721
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/minarea.cpp
@@ -0,0 +1,78 @@
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help()
+{
+    cout << "This program demonstrates finding the minimum enclosing box, triangle or circle of a set\n"
+         << "of points using functions: minAreaRect() minEnclosingTriangle() minEnclosingCircle().\n"
+         << "Random points are generated and then enclosed.\n\n"
+         << "Press ESC, 'q' or 'Q' to exit and any other key to regenerate the set of points.\n\n";
+}
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    help();
+
+    Mat img(500, 500, CV_8UC3, Scalar::all(0));
+    RNG& rng = theRNG();
+
+    for(;;)
+    {
+        int i, count = rng.uniform(1, 101);
+        vector<Point> points;
+
+        // Generate a random set of points
+        for( i = 0; i < count; i++ )
+        {
+            Point pt;
+            pt.x = rng.uniform(img.cols/4, img.cols*3/4);
+            pt.y = rng.uniform(img.rows/4, img.rows*3/4);
+
+            points.push_back(pt);
+        }
+
+        // Find the minimum area enclosing bounding box
+        Point2f vtx[4];
+        RotatedRect box = minAreaRect(points);
+        box.points(vtx);
+
+        // Find the minimum area enclosing triangle
+        vector<Point2f> triangle;
+        minEnclosingTriangle(points, triangle);
+
+        // Find the minimum area enclosing circle
+        Point2f center;
+        float radius = 0;
+        minEnclosingCircle(points, center, radius);
+
+        img = Scalar::all(0);
+
+        // Draw the points
+        for( i = 0; i < count; i++ )
+            circle( img, points[i], 3, Scalar(0, 0, 255), FILLED, LINE_AA );
+
+        // Draw the bounding box
+        for( i = 0; i < 4; i++ )
+            line(img, vtx[i], vtx[(i+1)%4], Scalar(0, 255, 0), 1, LINE_AA);
+
+        // Draw the triangle
+        for( i = 0; i < 3; i++ )
+            line(img, triangle[i], triangle[(i+1)%3], Scalar(255, 255, 0), 1, LINE_AA);
+
+        // Draw the circle
+        circle(img, center, cvRound(radius), Scalar(0, 255, 255), 1, LINE_AA);
+
+        imshow( "Rectangle, triangle & circle", img );
+
+        char key = (char)waitKey();
+        if( key == 27 || key == 'q' || key == 'Q' ) // 'ESC'
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/morphology2.cpp b/C++/opencv-4.7.0/samples/cpp/morphology2.cpp
new file mode 100644
index 00000000..f1d8d15b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/morphology2.cpp
@@ -0,0 +1,109 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+
+using namespace cv;
+
+static void help(char** argv)
+{
+
+printf("\nShow off image morphology: erosion, dialation, open and close\n"
+    "Call:\n   %s [image]\n"
+    "This program also shows use of rect, ellipse and cross kernels\n\n", argv[0]);
+printf( "Hot keys: \n"
+    "\tESC - quit the program\n"
+    "\tr - use rectangle structuring element\n"
+    "\te - use elliptic structuring element\n"
+    "\tc - use cross-shaped structuring element\n"
+    "\tSPACE - loop through all the options\n" );
+}
+
+Mat src, dst;
+
+int element_shape = MORPH_RECT;
+
+//the address of variable which receives trackbar position update
+int max_iters = 10;
+int open_close_pos = 0;
+int erode_dilate_pos = 0;
+
+// callback function for open/close trackbar
+static void OpenClose(int, void*)
+{
+    int n = open_close_pos;
+    int an = abs(n);
+    Mat element = getStructuringElement(element_shape, Size(an*2+1, an*2+1), Point(an, an) );
+    if( n < 0 )
+        morphologyEx(src, dst, MORPH_OPEN, element);
+    else
+        morphologyEx(src, dst, MORPH_CLOSE, element);
+    imshow("Open/Close",dst);
+}
+
+// callback function for erode/dilate trackbar
+static void ErodeDilate(int, void*)
+{
+    int n = erode_dilate_pos;
+    int an = abs(n);
+    Mat element = getStructuringElement(element_shape, Size(an*2+1, an*2+1), Point(an, an) );
+    if( n < 0 )
+        erode(src, dst, element);
+    else
+        dilate(src, dst, element);
+    imshow("Erode/Dilate",dst);
+}
+
+
+int main( int argc, char** argv )
+{
+    cv::CommandLineParser parser(argc, argv, "{help h||}{ @image | baboon.jpg | }");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    std::string filename = samples::findFile(parser.get<std::string>("@image"));
+    if( (src = imread(filename,IMREAD_COLOR)).empty() )
+    {
+        help(argv);
+        return -1;
+    }
+
+    //create windows for output images
+    namedWindow("Open/Close",1);
+    namedWindow("Erode/Dilate",1);
+
+    open_close_pos = erode_dilate_pos = max_iters;
+    createTrackbar("iterations", "Open/Close",&open_close_pos,max_iters*2+1,OpenClose);
+    setTrackbarMin("iterations", "Open/Close", -max_iters);
+    setTrackbarMax("iterations", "Open/Close", max_iters);
+    setTrackbarPos("iterations", "Open/Close", 0);
+
+    createTrackbar("iterations", "Erode/Dilate",&erode_dilate_pos,max_iters*2+1,ErodeDilate);
+    setTrackbarMin("iterations", "Erode/Dilate", -max_iters);
+    setTrackbarMax("iterations", "Erode/Dilate", max_iters);
+    setTrackbarPos("iterations", "Erode/Dilate", 0);
+
+    for(;;)
+    {
+        OpenClose(open_close_pos, 0);
+        ErodeDilate(erode_dilate_pos, 0);
+        char c = (char)waitKey(0);
+
+        if( c == 27 )
+            break;
+        if( c == 'e' )
+            element_shape = MORPH_ELLIPSE;
+        else if( c == 'r' )
+            element_shape = MORPH_RECT;
+        else if( c == 'c' )
+            element_shape = MORPH_CROSS;
+        else if( c == ' ' )
+            element_shape = (element_shape + 1) % 3;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/neural_network.cpp b/C++/opencv-4.7.0/samples/cpp/neural_network.cpp
new file mode 100644
index 00000000..d6e681b6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/neural_network.cpp
@@ -0,0 +1,65 @@
+#include <opencv2/ml/ml.hpp>
+
+using namespace std;
+using namespace cv;
+using namespace cv::ml;
+
+int main()
+{
+    //create random training data
+    Mat_<float> data(100, 100);
+    randn(data, Mat::zeros(1, 1, data.type()), Mat::ones(1, 1, data.type()));
+
+    //half of the samples for each class
+    Mat_<float> responses(data.rows, 2);
+    for (int i = 0; i<data.rows; ++i)
+    {
+        if (i < data.rows/2)
+        {
+            responses(i, 0) = 1;
+            responses(i, 1) = 0;
+        }
+        else
+        {
+            responses(i, 0) = 0;
+            responses(i, 1) = 1;
+        }
+    }
+
+    /*
+    //example code for just a single response (regression)
+    Mat_<float> responses(data.rows, 1);
+    for (int i=0; i<responses.rows; ++i)
+        responses(i, 0) = i < responses.rows / 2 ? 0 : 1;
+    */
+
+    //create the neural network
+    Mat_<int> layerSizes(1, 3);
+    layerSizes(0, 0) = data.cols;
+    layerSizes(0, 1) = 20;
+    layerSizes(0, 2) = responses.cols;
+
+    Ptr<ANN_MLP> network = ANN_MLP::create();
+    network->setLayerSizes(layerSizes);
+    network->setActivationFunction(ANN_MLP::SIGMOID_SYM, 0.1, 0.1);
+    network->setTrainMethod(ANN_MLP::BACKPROP, 0.1, 0.1);
+    Ptr<TrainData> trainData = TrainData::create(data, ROW_SAMPLE, responses);
+
+    network->train(trainData);
+    if (network->isTrained())
+    {
+        printf("Predict one-vector:\n");
+        Mat result;
+        network->predict(Mat::ones(1, data.cols, data.type()), result);
+        cout << result << endl;
+
+        printf("Predict training data:\n");
+        for (int i=0; i<data.rows; ++i)
+        {
+            network->predict(data.row(i), result);
+            cout << result << endl;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/npr_demo.cpp b/C++/opencv-4.7.0/samples/cpp/npr_demo.cpp
new file mode 100644
index 00000000..4d8d7879
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/npr_demo.cpp
@@ -0,0 +1,99 @@
+/*
+* npr_demo.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to use OpenCV Non-Photorealistic Rendering Module.
+* 1) Edge Preserve Smoothing
+*    -> Using Normalized convolution Filter
+*    -> Using Recursive Filter
+* 2) Detail Enhancement
+* 3) Pencil sketch/Color Pencil Drawing
+* 4) Stylization
+*
+*/
+
+#include <signal.h>
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include <iostream>
+#include <stdlib.h>
+
+using namespace std;
+using namespace cv;
+
+int main(int argc, char* argv[])
+{
+    cv::CommandLineParser parser(argc, argv, "{help h||show help message}{@image|lena.jpg|input image}");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    string filename = samples::findFile(parser.get<string>("@image"));
+
+    Mat I = imread(filename);
+
+    int num,type;
+
+    if(I.empty())
+    {
+        cout <<  "Image not found" << endl;
+        return 1;
+    }
+
+    cout << endl;
+    cout << " Edge Preserve Filter" << endl;
+    cout << "----------------------" << endl;
+
+    cout << "Options: " << endl;
+    cout << endl;
+
+    cout << "1) Edge Preserve Smoothing" << endl;
+    cout << "   -> Using Normalized convolution Filter" << endl;
+    cout << "   -> Using Recursive Filter" << endl;
+    cout << "2) Detail Enhancement" << endl;
+    cout << "3) Pencil sketch/Color Pencil Drawing" << endl;
+    cout << "4) Stylization" << endl;
+    cout << endl;
+
+    cout << "Press number 1-4 to choose from above techniques: ";
+
+    cin >> num;
+
+    Mat img;
+
+    if(num == 1)
+    {
+        cout << endl;
+        cout << "Press 1 for Normalized Convolution Filter and 2 for Recursive Filter: ";
+
+        cin >> type;
+
+        edgePreservingFilter(I,img,type);
+        imshow("Edge Preserve Smoothing",img);
+
+    }
+    else if(num == 2)
+    {
+        detailEnhance(I,img);
+        imshow("Detail Enhanced",img);
+    }
+    else if(num == 3)
+    {
+        Mat img1;
+        pencilSketch(I,img1, img, 10 , 0.1f, 0.03f);
+        imshow("Pencil Sketch",img1);
+        imshow("Color Pencil Sketch",img);
+    }
+    else if(num == 4)
+    {
+        stylization(I,img);
+        imshow("Stylization",img);
+    }
+    waitKey(0);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/opencv_version.cpp b/C++/opencv-4.7.0/samples/cpp/opencv_version.cpp
new file mode 100644
index 00000000..b500f117
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/opencv_version.cpp
@@ -0,0 +1,32 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include <opencv2/core/utility.hpp>
+#include <iostream>
+
+static const std::string keys = "{ b build | | print complete build info }"
+                                "{ h help  | | print this help           }";
+
+int main(int argc, const char* argv[])
+{
+    cv::CommandLineParser parser(argc, argv, keys);
+    parser.about("This sample outputs OpenCV version and build configuration.");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+    }
+    else if (!parser.check())
+    {
+        parser.printErrors();
+    }
+    else if (parser.has("build"))
+    {
+        std::cout << cv::getBuildInformation() << std::endl;
+    }
+    else
+    {
+        std::cout << "Welcome to OpenCV " << CV_VERSION << std::endl;
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/pca.cpp b/C++/opencv-4.7.0/samples/cpp/pca.cpp
new file mode 100644
index 00000000..a5a1c54a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/pca.cpp
@@ -0,0 +1,191 @@
+/*
+* pca.cpp
+*
+*  Author:
+*  Kevin Hughes <kevinhughes27[at]gmail[dot]com>
+*
+*  Special Thanks to:
+*  Philipp Wagner <bytefish[at]gmx[dot]de>
+*
+* This program demonstrates how to use OpenCV PCA with a
+* specified amount of variance to retain. The effect
+* is illustrated further by using a trackbar to
+* change the value for retained variance.
+*
+* The program takes as input a text file with each line
+* begin the full path to an image. PCA will be performed
+* on this list of images. The author recommends using
+* the first 15 faces of the AT&T face data set:
+* http://www.cl.cam.ac.uk/research/dtg/attarchive/facedatabase.html
+*
+* so for example your input text file would look like this:
+*
+*        <path_to_at&t_faces>/orl_faces/s1/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s2/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s3/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s4/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s5/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s6/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s7/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s8/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s9/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s10/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s11/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s12/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s13/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s14/1.pgm
+*        <path_to_at&t_faces>/orl_faces/s15/1.pgm
+*
+*/
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+
+#include <opencv2/core.hpp>
+#include "opencv2/imgcodecs.hpp"
+#include <opencv2/highgui.hpp>
+
+using namespace cv;
+using namespace std;
+
+///////////////////////
+// Functions
+static void read_imgList(const string& filename, vector<Mat>& images) {
+    std::ifstream file(filename.c_str(), ifstream::in);
+    if (!file) {
+        string error_message = "No valid input file was given, please check the given filename.";
+        CV_Error(Error::StsBadArg, error_message);
+    }
+    string line;
+    while (getline(file, line)) {
+        images.push_back(imread(line, 0));
+    }
+}
+
+static  Mat formatImagesForPCA(const vector<Mat> &data)
+{
+    Mat dst(static_cast<int>(data.size()), data[0].rows*data[0].cols, CV_32F);
+    for(unsigned int i = 0; i < data.size(); i++)
+    {
+        Mat image_row = data[i].clone().reshape(1,1);
+        Mat row_i = dst.row(i);
+        image_row.convertTo(row_i,CV_32F);
+    }
+    return dst;
+}
+
+static Mat toGrayscale(InputArray _src) {
+    Mat src = _src.getMat();
+    // only allow one channel
+    if(src.channels() != 1) {
+        CV_Error(Error::StsBadArg, "Only Matrices with one channel are supported");
+    }
+    // create and return normalized image
+    Mat dst;
+    cv::normalize(_src, dst, 0, 255, NORM_MINMAX, CV_8UC1);
+    return dst;
+}
+
+struct params
+{
+    Mat data;
+    int ch;
+    int rows;
+    PCA pca;
+    string winName;
+};
+
+static void onTrackbar(int pos, void* ptr)
+{
+    cout << "Retained Variance = " << pos << "%   ";
+    cout << "re-calculating PCA..." << std::flush;
+
+    double var = pos / 100.0;
+
+    struct params *p = (struct params *)ptr;
+
+    p->pca = PCA(p->data, cv::Mat(), PCA::DATA_AS_ROW, var);
+
+    Mat point = p->pca.project(p->data.row(0));
+    Mat reconstruction = p->pca.backProject(point);
+    reconstruction = reconstruction.reshape(p->ch, p->rows);
+    reconstruction = toGrayscale(reconstruction);
+
+    imshow(p->winName, reconstruction);
+    cout << "done!   # of principal components: " << p->pca.eigenvectors.rows << endl;
+}
+
+
+///////////////////////
+// Main
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv, "{@input||image list}{help h||show help message}");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        exit(0);
+    }
+    // Get the path to your CSV.
+    string imgList = parser.get<string>("@input");
+    if (imgList.empty())
+    {
+        parser.printMessage();
+        exit(1);
+    }
+
+    // vector to hold the images
+    vector<Mat> images;
+
+    // Read in the data. This can fail if not valid
+    try {
+        read_imgList(imgList, images);
+    } catch (const cv::Exception& e) {
+        cerr << "Error opening file \"" << imgList << "\". Reason: " << e.msg << endl;
+        exit(1);
+    }
+
+    // Quit if there are not enough images for this demo.
+    if(images.size() <= 1) {
+        string error_message = "This demo needs at least 2 images to work. Please add more images to your data set!";
+        CV_Error(Error::StsError, error_message);
+    }
+
+    // Reshape and stack images into a rowMatrix
+    Mat data = formatImagesForPCA(images);
+
+    // perform PCA
+    PCA pca(data, cv::Mat(), PCA::DATA_AS_ROW, 0.95); // trackbar is initially set here, also this is a common value for retainedVariance
+
+    // Demonstration of the effect of retainedVariance on the first image
+    Mat point = pca.project(data.row(0)); // project into the eigenspace, thus the image becomes a "point"
+    Mat reconstruction = pca.backProject(point); // re-create the image from the "point"
+    reconstruction = reconstruction.reshape(images[0].channels(), images[0].rows); // reshape from a row vector into image shape
+    reconstruction = toGrayscale(reconstruction); // re-scale for displaying purposes
+
+    // init highgui window
+    string winName = "Reconstruction | press 'q' to quit";
+    namedWindow(winName, WINDOW_NORMAL);
+
+    // params struct to pass to the trackbar handler
+    params p;
+    p.data = data;
+    p.ch = images[0].channels();
+    p.rows = images[0].rows;
+    p.pca = pca;
+    p.winName = winName;
+
+    // create the tracbar
+    int pos = 95;
+    createTrackbar("Retained Variance (%)", winName, &pos, 100, onTrackbar, (void*)&p);
+
+    // display until user presses q
+    imshow(winName, reconstruction);
+
+    char key = 0;
+    while(key != 'q')
+        key = (char)waitKey();
+
+   return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/peopledetect.cpp b/C++/opencv-4.7.0/samples/cpp/peopledetect.cpp
new file mode 100644
index 00000000..9671f3b7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/peopledetect.cpp
@@ -0,0 +1,129 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include <opencv2/objdetect.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/videoio.hpp>
+#include <iostream>
+#include <iomanip>
+
+using namespace cv;
+using namespace std;
+
+class Detector
+{
+    enum Mode { Default, Daimler } m;
+    HOGDescriptor hog, hog_d;
+public:
+    Detector() : m(Default), hog(), hog_d(Size(48, 96), Size(16, 16), Size(8, 8), Size(8, 8), 9)
+    {
+        hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());
+        hog_d.setSVMDetector(HOGDescriptor::getDaimlerPeopleDetector());
+    }
+    void toggleMode() { m = (m == Default ? Daimler : Default); }
+    string modeName() const { return (m == Default ? "Default" : "Daimler"); }
+    vector<Rect> detect(InputArray img)
+    {
+        // Run the detector with default parameters. to get a higher hit-rate
+        // (and more false alarms, respectively), decrease the hitThreshold and
+        // groupThreshold (set groupThreshold to 0 to turn off the grouping completely).
+        vector<Rect> found;
+        if (m == Default)
+            hog.detectMultiScale(img, found, 0, Size(8,8), Size(), 1.05, 2, false);
+        else if (m == Daimler)
+            hog_d.detectMultiScale(img, found, 0, Size(8,8), Size(), 1.05, 2, true);
+        return found;
+    }
+    void adjustRect(Rect & r) const
+    {
+        // The HOG detector returns slightly larger rectangles than the real objects,
+        // so we slightly shrink the rectangles to get a nicer output.
+        r.x += cvRound(r.width*0.1);
+        r.width = cvRound(r.width*0.8);
+        r.y += cvRound(r.height*0.07);
+        r.height = cvRound(r.height*0.8);
+    }
+};
+
+static const string keys = "{ help h   |   | print help message }"
+                           "{ camera c | 0 | capture video from camera (device index starting from 0) }"
+                           "{ video v  |   | use video as input }";
+
+int main(int argc, char** argv)
+{
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("This sample demonstrates the use of the HoG descriptor.");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    int camera = parser.get<int>("camera");
+    string file = parser.get<string>("video");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+
+    VideoCapture cap;
+    if (file.empty())
+        cap.open(camera);
+    else
+    {
+        file = samples::findFileOrKeep(file);
+        cap.open(file);
+    }
+    if (!cap.isOpened())
+    {
+        cout << "Can not open video stream: '" << (file.empty() ? "<camera>" : file) << "'" << endl;
+        return 2;
+    }
+
+    cout << "Press 'q' or <ESC> to quit." << endl;
+    cout << "Press <space> to toggle between Default and Daimler detector" << endl;
+    Detector detector;
+    Mat frame;
+    for (;;)
+    {
+        cap >> frame;
+        if (frame.empty())
+        {
+            cout << "Finished reading: empty frame" << endl;
+            break;
+        }
+        int64 t = getTickCount();
+        vector<Rect> found = detector.detect(frame);
+        t = getTickCount() - t;
+
+        // show the window
+        {
+            ostringstream buf;
+            buf << "Mode: " << detector.modeName() << " ||| "
+                << "FPS: " << fixed << setprecision(1) << (getTickFrequency() / (double)t);
+            putText(frame, buf.str(), Point(10, 30), FONT_HERSHEY_PLAIN, 2.0, Scalar(0, 0, 255), 2, LINE_AA);
+        }
+        for (vector<Rect>::iterator i = found.begin(); i != found.end(); ++i)
+        {
+            Rect &r = *i;
+            detector.adjustRect(r);
+            rectangle(frame, r.tl(), r.br(), cv::Scalar(0, 255, 0), 2);
+        }
+        imshow("People detector", frame);
+
+        // interact with user
+        const char key = (char)waitKey(1);
+        if (key == 27 || key == 'q') // ESC
+        {
+            cout << "Exit requested" << endl;
+            break;
+        }
+        else if (key == ' ')
+        {
+            detector.toggleMode();
+        }
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/phase_corr.cpp b/C++/opencv-4.7.0/samples/cpp/phase_corr.cpp
new file mode 100644
index 00000000..f7356666
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/phase_corr.cpp
@@ -0,0 +1,46 @@
+#include "opencv2/core.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+using namespace cv;
+
+int main(int, char* [])
+{
+    VideoCapture video(0);
+    Mat frame, curr, prev, curr64f, prev64f, hann;
+    char key;
+
+    do
+    {
+        video >> frame;
+        cvtColor(frame, curr, COLOR_RGB2GRAY);
+
+        if(prev.empty())
+        {
+            prev = curr.clone();
+            createHanningWindow(hann, curr.size(), CV_64F);
+        }
+
+        prev.convertTo(prev64f, CV_64F);
+        curr.convertTo(curr64f, CV_64F);
+
+        Point2d shift = phaseCorrelate(prev64f, curr64f, hann);
+        double radius = std::sqrt(shift.x*shift.x + shift.y*shift.y);
+
+        if(radius > 5)
+        {
+            // draw a circle and line indicating the shift direction...
+            Point center(curr.cols >> 1, curr.rows >> 1);
+            circle(frame, center, (int)radius, Scalar(0, 255, 0), 3, LINE_AA);
+            line(frame, center, Point(center.x + (int)shift.x, center.y + (int)shift.y), Scalar(0, 255, 0), 3, LINE_AA);
+        }
+
+        imshow("phase shift", frame);
+        key = (char)waitKey(2);
+
+        prev = curr.clone();
+    } while(key != 27); // Esc to exit...
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/points_classifier.cpp b/C++/opencv-4.7.0/samples/cpp/points_classifier.cpp
new file mode 100644
index 00000000..02e39349
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/points_classifier.cpp
@@ -0,0 +1,399 @@
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/ml.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <stdio.h>
+
+using namespace std;
+using namespace cv;
+using namespace cv::ml;
+
+const Scalar WHITE_COLOR = Scalar(255,255,255);
+const string winName = "points";
+const int testStep = 5;
+
+Mat img, imgDst;
+RNG rng;
+
+vector<Point>  trainedPoints;
+vector<int>    trainedPointsMarkers;
+const int MAX_CLASSES = 2;
+vector<Vec3b>  classColors(MAX_CLASSES);
+int currentClass = 0;
+vector<int> classCounters(MAX_CLASSES);
+
+#define _NBC_ 1 // normal Bayessian classifier
+#define _KNN_ 1 // k nearest neighbors classifier
+#define _SVM_ 1 // support vectors machine
+#define _DT_  1 // decision tree
+#define _BT_  1 // ADA Boost
+#define _GBT_ 0 // gradient boosted trees
+#define _RF_  1 // random forest
+#define _ANN_ 1 // artificial neural networks
+#define _EM_  1 // expectation-maximization
+
+static void on_mouse( int event, int x, int y, int /*flags*/, void* )
+{
+    if( img.empty() )
+        return;
+
+    int updateFlag = 0;
+
+    if( event == EVENT_LBUTTONUP )
+    {
+        trainedPoints.push_back( Point(x,y) );
+        trainedPointsMarkers.push_back( currentClass );
+        classCounters[currentClass]++;
+        updateFlag = true;
+    }
+
+    //draw
+    if( updateFlag )
+    {
+        img = Scalar::all(0);
+
+        // draw points
+        for( size_t i = 0; i < trainedPoints.size(); i++ )
+        {
+            Vec3b c = classColors[trainedPointsMarkers[i]];
+            circle( img, trainedPoints[i], 5, Scalar(c), -1 );
+        }
+
+        imshow( winName, img );
+   }
+}
+
+static Mat prepare_train_samples(const vector<Point>& pts)
+{
+    Mat samples;
+    Mat(pts).reshape(1, (int)pts.size()).convertTo(samples, CV_32F);
+    return samples;
+}
+
+static Ptr<TrainData> prepare_train_data()
+{
+    Mat samples = prepare_train_samples(trainedPoints);
+    return TrainData::create(samples, ROW_SAMPLE, Mat(trainedPointsMarkers));
+}
+
+static void predict_and_paint(const Ptr<StatModel>& model, Mat& dst)
+{
+    Mat testSample( 1, 2, CV_32FC1 );
+    for( int y = 0; y < img.rows; y += testStep )
+    {
+        for( int x = 0; x < img.cols; x += testStep )
+        {
+            testSample.at<float>(0) = (float)x;
+            testSample.at<float>(1) = (float)y;
+
+            int response = (int)model->predict( testSample );
+            dst.at<Vec3b>(y, x) = classColors[response];
+        }
+    }
+}
+
+#if _NBC_
+static void find_decision_boundary_NBC()
+{
+    // learn classifier
+    Ptr<NormalBayesClassifier> normalBayesClassifier = StatModel::train<NormalBayesClassifier>(prepare_train_data());
+
+    predict_and_paint(normalBayesClassifier, imgDst);
+}
+#endif
+
+
+#if _KNN_
+static void find_decision_boundary_KNN( int K )
+{
+
+    Ptr<KNearest> knn = KNearest::create();
+    knn->setDefaultK(K);
+    knn->setIsClassifier(true);
+    knn->train(prepare_train_data());
+    predict_and_paint(knn, imgDst);
+}
+#endif
+
+#if _SVM_
+static void find_decision_boundary_SVM( double C )
+{
+    Ptr<SVM> svm = SVM::create();
+    svm->setType(SVM::C_SVC);
+    svm->setKernel(SVM::POLY); //SVM::LINEAR;
+    svm->setDegree(0.5);
+    svm->setGamma(1);
+    svm->setCoef0(1);
+    svm->setNu(0.5);
+    svm->setP(0);
+    svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 1000, 0.01));
+    svm->setC(C);
+    svm->train(prepare_train_data());
+    predict_and_paint(svm, imgDst);
+
+    Mat sv = svm->getSupportVectors();
+    for( int i = 0; i < sv.rows; i++ )
+    {
+        const float* supportVector = sv.ptr<float>(i);
+        circle( imgDst, Point(saturate_cast<int>(supportVector[0]),saturate_cast<int>(supportVector[1])), 5, Scalar(255,255,255), -1 );
+    }
+}
+#endif
+
+#if _DT_
+static void find_decision_boundary_DT()
+{
+    Ptr<DTrees> dtree = DTrees::create();
+    dtree->setMaxDepth(8);
+    dtree->setMinSampleCount(2);
+    dtree->setUseSurrogates(false);
+    dtree->setCVFolds(0); // the number of cross-validation folds
+    dtree->setUse1SERule(false);
+    dtree->setTruncatePrunedTree(false);
+    dtree->train(prepare_train_data());
+    predict_and_paint(dtree, imgDst);
+}
+#endif
+
+#if _BT_
+static void find_decision_boundary_BT()
+{
+    Ptr<Boost> boost = Boost::create();
+    boost->setBoostType(Boost::DISCRETE);
+    boost->setWeakCount(100);
+    boost->setWeightTrimRate(0.95);
+    boost->setMaxDepth(2);
+    boost->setUseSurrogates(false);
+    boost->setPriors(Mat());
+    boost->train(prepare_train_data());
+    predict_and_paint(boost, imgDst);
+}
+
+#endif
+
+#if _GBT_
+static void find_decision_boundary_GBT()
+{
+    GBTrees::Params params( GBTrees::DEVIANCE_LOSS, // loss_function_type
+                         100, // weak_count
+                         0.1f, // shrinkage
+                         1.0f, // subsample_portion
+                         2, // max_depth
+                         false // use_surrogates )
+                         );
+
+    Ptr<GBTrees> gbtrees = StatModel::train<GBTrees>(prepare_train_data(), params);
+    predict_and_paint(gbtrees, imgDst);
+}
+#endif
+
+#if _RF_
+static void find_decision_boundary_RF()
+{
+    Ptr<RTrees> rtrees = RTrees::create();
+    rtrees->setMaxDepth(4);
+    rtrees->setMinSampleCount(2);
+    rtrees->setRegressionAccuracy(0.f);
+    rtrees->setUseSurrogates(false);
+    rtrees->setMaxCategories(16);
+    rtrees->setPriors(Mat());
+    rtrees->setCalculateVarImportance(false);
+    rtrees->setActiveVarCount(1);
+    rtrees->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, 5, 0));
+    rtrees->train(prepare_train_data());
+    predict_and_paint(rtrees, imgDst);
+}
+
+#endif
+
+#if _ANN_
+static void find_decision_boundary_ANN( const Mat&  layer_sizes )
+{
+    Mat trainClasses = Mat::zeros( (int)trainedPoints.size(), (int)classColors.size(), CV_32FC1 );
+    for( int i = 0; i < trainClasses.rows; i++ )
+    {
+        trainClasses.at<float>(i, trainedPointsMarkers[i]) = 1.f;
+    }
+
+    Mat samples = prepare_train_samples(trainedPoints);
+    Ptr<TrainData> tdata = TrainData::create(samples, ROW_SAMPLE, trainClasses);
+
+    Ptr<ANN_MLP> ann = ANN_MLP::create();
+    ann->setLayerSizes(layer_sizes);
+    ann->setActivationFunction(ANN_MLP::SIGMOID_SYM, 1, 1);
+    ann->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 300, FLT_EPSILON));
+    ann->setTrainMethod(ANN_MLP::BACKPROP, 0.001);
+    ann->train(tdata);
+    predict_and_paint(ann, imgDst);
+}
+#endif
+
+#if _EM_
+static void find_decision_boundary_EM()
+{
+    img.copyTo( imgDst );
+
+    Mat samples = prepare_train_samples(trainedPoints);
+
+    int i, j, nmodels = (int)classColors.size();
+    vector<Ptr<EM> > em_models(nmodels);
+    Mat modelSamples;
+
+    for( i = 0; i < nmodels; i++ )
+    {
+        const int componentCount = 3;
+
+        modelSamples.release();
+        for( j = 0; j < samples.rows; j++ )
+        {
+            if( trainedPointsMarkers[j] == i )
+                modelSamples.push_back(samples.row(j));
+        }
+
+        // learn models
+        if( !modelSamples.empty() )
+        {
+            Ptr<EM> em = EM::create();
+            em->setClustersNumber(componentCount);
+            em->setCovarianceMatrixType(EM::COV_MAT_DIAGONAL);
+            em->trainEM(modelSamples, noArray(), noArray(), noArray());
+            em_models[i] = em;
+        }
+    }
+
+    // classify coordinate plane points using the bayes classifier, i.e.
+    // y(x) = arg max_i=1_modelsCount likelihoods_i(x)
+    Mat testSample(1, 2, CV_32FC1 );
+    Mat logLikelihoods(1, nmodels, CV_64FC1, Scalar(-DBL_MAX));
+
+    for( int y = 0; y < img.rows; y += testStep )
+    {
+        for( int x = 0; x < img.cols; x += testStep )
+        {
+            testSample.at<float>(0) = (float)x;
+            testSample.at<float>(1) = (float)y;
+
+            for( i = 0; i < nmodels; i++ )
+            {
+                if( !em_models[i].empty() )
+                    logLikelihoods.at<double>(i) = em_models[i]->predict2(testSample, noArray())[0];
+            }
+            Point maxLoc;
+            minMaxLoc(logLikelihoods, 0, 0, 0, &maxLoc);
+            imgDst.at<Vec3b>(y, x) = classColors[maxLoc.x];
+        }
+    }
+}
+#endif
+
+int main()
+{
+    cout << "Use:" << endl
+         << "  key '0' .. '1' - switch to class #n" << endl
+         << "  left mouse button - to add new point;" << endl
+         << "  key 'r' - to run the ML model;" << endl
+         << "  key 'i' - to init (clear) the data." << endl << endl;
+
+    cv::namedWindow( "points", 1 );
+    img.create( 480, 640, CV_8UC3 );
+    imgDst.create( 480, 640, CV_8UC3 );
+
+    imshow( "points", img );
+    setMouseCallback( "points", on_mouse );
+
+    classColors[0] = Vec3b(0, 255, 0);
+    classColors[1] = Vec3b(0, 0, 255);
+
+    for(;;)
+    {
+        char key = (char)waitKey();
+
+        if( key == 27 ) break;
+
+        if( key == 'i' ) // init
+        {
+            img = Scalar::all(0);
+
+            trainedPoints.clear();
+            trainedPointsMarkers.clear();
+            classCounters.assign(MAX_CLASSES, 0);
+
+            imshow( winName, img );
+        }
+
+        if( key == '0' || key == '1' )
+        {
+            currentClass = key - '0';
+        }
+
+        if( key == 'r' ) // run
+        {
+            double minVal = 0;
+            minMaxLoc(classCounters, &minVal, 0, 0, 0);
+            if( minVal == 0 )
+            {
+                printf("each class should have at least 1 point\n");
+                continue;
+            }
+            img.copyTo( imgDst );
+#if _NBC_
+            find_decision_boundary_NBC();
+            imshow( "NormalBayesClassifier", imgDst );
+#endif
+#if _KNN_
+            find_decision_boundary_KNN( 3 );
+            imshow( "kNN", imgDst );
+
+            find_decision_boundary_KNN( 15 );
+            imshow( "kNN2", imgDst );
+#endif
+
+#if _SVM_
+            //(1)-(2)separable and not sets
+
+            find_decision_boundary_SVM( 1 );
+            imshow( "classificationSVM1", imgDst );
+
+            find_decision_boundary_SVM( 10 );
+            imshow( "classificationSVM2", imgDst );
+#endif
+
+#if _DT_
+            find_decision_boundary_DT();
+            imshow( "DT", imgDst );
+#endif
+
+#if _BT_
+            find_decision_boundary_BT();
+            imshow( "BT", imgDst);
+#endif
+
+#if _GBT_
+            find_decision_boundary_GBT();
+            imshow( "GBT", imgDst);
+#endif
+
+#if _RF_
+            find_decision_boundary_RF();
+            imshow( "RF", imgDst);
+#endif
+
+#if _ANN_
+            Mat layer_sizes1( 1, 3, CV_32SC1 );
+            layer_sizes1.at<int>(0) = 2;
+            layer_sizes1.at<int>(1) = 5;
+            layer_sizes1.at<int>(2) = (int)classColors.size();
+            find_decision_boundary_ANN( layer_sizes1 );
+            imshow( "ANN", imgDst );
+#endif
+
+#if _EM_
+            find_decision_boundary_EM();
+            imshow( "EM", imgDst );
+#endif
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/polar_transforms.cpp b/C++/opencv-4.7.0/samples/cpp/polar_transforms.cpp
new file mode 100644
index 00000000..cdd653a2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/polar_transforms.cpp
@@ -0,0 +1,107 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/videoio.hpp"
+#include <iostream>
+
+using namespace cv;
+
+int main( int argc, char** argv )
+{
+    VideoCapture capture;
+    Mat log_polar_img, lin_polar_img, recovered_log_polar, recovered_lin_polar_img;
+
+    CommandLineParser parser(argc, argv, "{@input|0| camera device number or video file path}");
+    parser.about("\nThis program illustrates usage of Linear-Polar and Log-Polar image transforms\n");
+    parser.printMessage();
+    std::string arg = parser.get<std::string>("@input");
+
+    if( arg.size() == 1 && isdigit(arg[0]) )
+        capture.open( arg[0] - '0' );
+    else
+        capture.open(samples::findFileOrKeep(arg));
+
+    if( !capture.isOpened() )
+    {
+        fprintf(stderr,"Could not initialize capturing...\n");
+        return -1;
+    }
+
+    namedWindow( "Linear-Polar", WINDOW_AUTOSIZE );
+    namedWindow( "Log-Polar", WINDOW_AUTOSIZE);
+    namedWindow( "Recovered Linear-Polar", WINDOW_AUTOSIZE);
+    namedWindow( "Recovered Log-Polar", WINDOW_AUTOSIZE);
+
+    moveWindow( "Linear-Polar", 20,20 );
+    moveWindow( "Log-Polar", 700,20 );
+    moveWindow( "Recovered Linear-Polar", 20, 350 );
+    moveWindow( "Recovered Log-Polar", 700, 350 );
+    int flags = INTER_LINEAR + WARP_FILL_OUTLIERS;
+    Mat src;
+    for(;;)
+    {
+        capture >> src;
+
+        if(src.empty() )
+            break;
+
+        Point2f center( (float)src.cols / 2, (float)src.rows / 2 );
+        double maxRadius = 0.7*min(center.y, center.x);
+
+#if 0 //deprecated
+        double M = frame.cols / log(maxRadius);
+        logPolar(frame, log_polar_img, center, M, flags);
+        linearPolar(frame, lin_polar_img, center, maxRadius, flags);
+
+        logPolar(log_polar_img, recovered_log_polar, center, M, flags + WARP_INVERSE_MAP);
+        linearPolar(lin_polar_img, recovered_lin_polar_img, center, maxRadius, flags + WARP_INVERSE_MAP);
+#endif
+        //! [InverseMap]
+        // direct transform
+        warpPolar(src, lin_polar_img, Size(),center, maxRadius, flags);                     // linear Polar
+        warpPolar(src, log_polar_img, Size(),center, maxRadius, flags + WARP_POLAR_LOG);    // semilog Polar
+        // inverse transform
+        warpPolar(lin_polar_img, recovered_lin_polar_img, src.size(), center, maxRadius, flags + WARP_INVERSE_MAP);
+        warpPolar(log_polar_img, recovered_log_polar, src.size(), center, maxRadius, flags + WARP_POLAR_LOG + WARP_INVERSE_MAP);
+        //! [InverseMap]
+
+        // Below is the reverse transformation for (rho, phi)->(x, y) :
+        Mat dst;
+        if (flags & WARP_POLAR_LOG)
+            dst = log_polar_img;
+        else
+            dst = lin_polar_img;
+        //get a point from the polar image
+        int rho = cvRound(dst.cols * 0.75);
+        int phi = cvRound(dst.rows / 2.0);
+
+        //! [InverseCoordinate]
+        double angleRad, magnitude;
+        double Kangle = dst.rows / CV_2PI;
+        angleRad = phi / Kangle;
+        if (flags & WARP_POLAR_LOG)
+        {
+            double Klog = dst.cols / std::log(maxRadius);
+            magnitude = std::exp(rho / Klog);
+        }
+        else
+        {
+            double Klin = dst.cols / maxRadius;
+            magnitude = rho / Klin;
+        }
+        int x = cvRound(center.x + magnitude * cos(angleRad));
+        int y = cvRound(center.y + magnitude * sin(angleRad));
+        //! [InverseCoordinate]
+        drawMarker(src, Point(x, y), Scalar(0, 255, 0));
+        drawMarker(dst, Point(rho, phi), Scalar(0, 255, 0));
+
+        imshow("Src frame", src);
+        imshow("Log-Polar", log_polar_img);
+        imshow("Linear-Polar", lin_polar_img);
+        imshow("Recovered Linear-Polar", recovered_lin_polar_img );
+        imshow("Recovered Log-Polar", recovered_log_polar );
+
+        if( waitKey(10) >= 0 )
+            break;
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/qrcode.cpp b/C++/opencv-4.7.0/samples/cpp/qrcode.cpp
new file mode 100644
index 00000000..af332d30
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/qrcode.cpp
@@ -0,0 +1,347 @@
+#include "opencv2/objdetect.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include <string>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static int liveQRCodeDetect();
+static int imageQRCodeDetect(const string& in_file);
+
+static bool g_modeMultiQR = false;
+static bool g_detectOnly = false;
+
+static string g_out_file_name, g_out_file_ext;
+static int g_save_idx = 0;
+
+static bool g_saveDetections = false;
+static bool g_saveAll = false;
+
+static string getQRModeString()
+{
+    std::ostringstream out;
+    out << "QR"
+        << (g_modeMultiQR ? " multi" : "")
+        << (g_detectOnly ? " detector" : " decoder");
+    return out.str();
+}
+
+int main(int argc, char *argv[])
+{
+    const string keys =
+        "{h help ? |        | print help messages }"
+        "{i in     |        | input image path (also switches to image detection mode) }"
+        "{detect   | false  | detect QR code only (skip decoding) }"
+        "{m multi  |        | use detect for multiple qr-codes }"
+        "{o out    | qr_code.png | path to result file }"
+        "{save_detections | false  | save all QR detections (video mode only) }"
+        "{save_all | false  | save all processed frames  (video mode only) }"
+    ;
+    CommandLineParser cmd_parser(argc, argv, keys);
+
+    cmd_parser.about("This program detects the QR-codes from camera or images using the OpenCV library.");
+    if (cmd_parser.has("help"))
+    {
+        cmd_parser.printMessage();
+        return 0;
+    }
+
+    string in_file_name = cmd_parser.get<string>("in");    // path to input image
+
+    if (cmd_parser.has("out"))
+    {
+        std::string fpath = cmd_parser.get<string>("out");   // path to output image
+        std::string::size_type idx = fpath.rfind('.');
+        if (idx != std::string::npos)
+        {
+            g_out_file_name = fpath.substr(0, idx);
+            g_out_file_ext = fpath.substr(idx);
+        }
+        else
+        {
+            g_out_file_name = fpath;
+            g_out_file_ext = ".png";
+        }
+    }
+    if (!cmd_parser.check())
+    {
+        cmd_parser.printErrors();
+        return -1;
+    }
+
+    g_modeMultiQR = cmd_parser.has("multi") && cmd_parser.get<bool>("multi");
+    g_detectOnly = cmd_parser.has("detect") && cmd_parser.get<bool>("detect");
+
+    g_saveDetections = cmd_parser.has("save_detections") && cmd_parser.get<bool>("save_detections");
+    g_saveAll = cmd_parser.has("save_all") && cmd_parser.get<bool>("save_all");
+
+    int return_code = 0;
+    if (in_file_name.empty())
+    {
+        return_code = liveQRCodeDetect();
+    }
+    else
+    {
+        return_code = imageQRCodeDetect(samples::findFile(in_file_name));
+    }
+    return return_code;
+}
+
+static
+void drawQRCodeContour(Mat &color_image, const vector<Point>& corners)
+{
+    if (!corners.empty())
+    {
+        double show_radius = (color_image.rows  > color_image.cols)
+                   ? (2.813 * color_image.rows) / color_image.cols
+                   : (2.813 * color_image.cols) / color_image.rows;
+        double contour_radius = show_radius * 0.4;
+
+        vector< vector<Point> > contours;
+        contours.push_back(corners);
+        drawContours(color_image, contours, 0, Scalar(211, 0, 148), cvRound(contour_radius));
+
+        RNG rng(1000);
+        for (size_t i = 0; i < 4; i++)
+        {
+            Scalar color = Scalar(rng.uniform(0,255), rng.uniform(0, 255), rng.uniform(0, 255));
+            circle(color_image, corners[i], cvRound(show_radius), color, -1);
+        }
+    }
+}
+
+static
+void drawFPS(Mat &color_image, double fps)
+{
+    ostringstream convert;
+    convert << cv::format("%.2f", fps) << " FPS (" << getQRModeString() << ")";
+    putText(color_image, convert.str(), Point(25, 25), FONT_HERSHEY_DUPLEX, 1, Scalar(0, 0, 255), 2);
+}
+
+static
+void drawQRCodeResults(Mat& frame, const vector<Point>& corners, const vector<cv::String>& decode_info, double fps)
+{
+    if (!corners.empty())
+    {
+        for (size_t i = 0; i < corners.size(); i += 4)
+        {
+            size_t qr_idx = i / 4;
+            vector<Point> qrcode_contour(corners.begin() + i, corners.begin() + i + 4);
+            drawQRCodeContour(frame, qrcode_contour);
+
+            cout << "QR[" << qr_idx << "] @ " << Mat(qrcode_contour).reshape(2, 1) << ": ";
+            if (decode_info.size() > qr_idx)
+            {
+                if (!decode_info[qr_idx].empty())
+                    cout << "'" << decode_info[qr_idx] << "'" << endl;
+                else
+                    cout << "can't decode QR code" << endl;
+            }
+            else
+            {
+                cout << "decode information is not available (disabled)" << endl;
+            }
+        }
+    }
+    else
+    {
+        cout << "QR code is not detected" << endl;
+    }
+
+    drawFPS(frame, fps);
+}
+
+static
+void runQR(
+    QRCodeDetector& qrcode, const Mat& input,
+    vector<Point>& corners, vector<cv::String>& decode_info
+    // +global: bool g_modeMultiQR, bool g_detectOnly
+)
+{
+    if (!g_modeMultiQR)
+    {
+        if (!g_detectOnly)
+        {
+            String decode_info1 = qrcode.detectAndDecode(input, corners);
+            decode_info.push_back(decode_info1);
+        }
+        else
+        {
+            bool detection_result = qrcode.detect(input, corners);
+            CV_UNUSED(detection_result);
+        }
+    }
+    else
+    {
+        if (!g_detectOnly)
+        {
+            bool result_detection = qrcode.detectAndDecodeMulti(input, decode_info, corners);
+            CV_UNUSED(result_detection);
+        }
+        else
+        {
+            bool result_detection = qrcode.detectMulti(input, corners);
+            CV_UNUSED(result_detection);
+        }
+    }
+}
+
+static
+double processQRCodeDetection(QRCodeDetector& qrcode, const Mat& input, Mat& result, vector<Point>& corners)
+{
+    if (input.channels() == 1)
+        cvtColor(input, result, COLOR_GRAY2BGR);
+    else
+        input.copyTo(result);
+
+    cout << "Run " << getQRModeString()
+        << " on image: " << input.size() << " (" << typeToString(input.type()) << ")"
+        << endl;
+
+    TickMeter timer;
+
+    vector<cv::String> decode_info;
+    timer.start();
+    runQR(qrcode, input, corners, decode_info);
+    timer.stop();
+
+    double fps = 1 / timer.getTimeSec();
+    drawQRCodeResults(result, corners, decode_info, fps);
+
+    return fps;
+}
+
+int liveQRCodeDetect()
+{
+    VideoCapture cap(0);
+
+    if (!cap.isOpened())
+    {
+        cout << "Cannot open a camera" << endl;
+        return 2;
+    }
+
+    cout << "Press 'm' to switch between detectAndDecode and detectAndDecodeMulti" << endl;
+    cout << "Press 'd' to switch between decoder and detector" << endl;
+    cout << "Press ' ' (space) to save result into images" << endl;
+    cout << "Press 'ESC' to exit" << endl;
+    QRCodeDetector qrcode;
+
+    for (;;)
+    {
+        Mat frame;
+        cap >> frame;
+        if (frame.empty())
+        {
+            cout << "End of video stream" << endl;
+            break;
+        }
+
+        bool forceSave = g_saveAll;
+
+        Mat result;
+
+        try
+        {
+            vector<Point> corners;
+            double fps = processQRCodeDetection(qrcode, frame, result, corners);
+            cout << "FPS: " << fps << endl;
+            forceSave |= (g_saveDetections && !corners.empty());
+            //forceSave |= fps < 1.0;
+        }
+        catch (const cv::Exception& e)
+        {
+            cerr << "ERROR exception: " << e.what() << endl;
+            forceSave = true;
+        }
+
+        if (!result.empty())
+            imshow("QR code", result);
+
+        int code = waitKey(1);
+        if (code < 0 && !forceSave)
+            continue; // timeout
+        char c = (char)code;
+        if (c == ' ' || forceSave)
+        {
+            string fsuffix = cv::format("-%05d", g_save_idx++);
+
+            string fname_input = g_out_file_name + fsuffix + "_input.png";
+            cout << "Saving QR code detection input: '" << fname_input << "' ..." << endl;
+            imwrite(fname_input, frame);
+
+            string fname = g_out_file_name + fsuffix + g_out_file_ext;
+            cout << "Saving QR code detection result: '" << fname << "' ..." << endl;
+            imwrite(fname, result);
+
+            cout << "Saved" << endl;
+        }
+        if (c == 'm')
+        {
+            g_modeMultiQR = !g_modeMultiQR;
+            cout << "Switching QR code mode ==> " << (g_modeMultiQR ? "detectAndDecodeMulti" : "detectAndDecode") << endl;
+        }
+        if (c == 'd')
+        {
+            g_detectOnly = !g_detectOnly;
+            cout << "Switching QR decoder mode ==> " << (g_detectOnly ? "detect" : "decode") << endl;
+        }
+        if (c == 27)
+        {
+            cout << "'ESC' is pressed. Exiting..." << endl;
+            break;
+        }
+    }
+    cout << "Exit." << endl;
+
+    return 0;
+}
+
+int imageQRCodeDetect(const string& in_file)
+{
+    const int count_experiments = 10;
+
+    Mat input = imread(in_file, IMREAD_COLOR);
+    cout << "Run " << getQRModeString()
+        << " on image: " << input.size() << " (" << typeToString(input.type()) << ")"
+        << endl;
+
+    QRCodeDetector qrcode;
+    vector<Point> corners;
+    vector<cv::String> decode_info;
+
+    TickMeter timer;
+    for (size_t i = 0; i < count_experiments; i++)
+    {
+        corners.clear();
+        decode_info.clear();
+
+        timer.start();
+        runQR(qrcode, input, corners, decode_info);
+        timer.stop();
+    }
+    double fps = count_experiments / timer.getTimeSec();
+    cout << "FPS: " << fps << endl;
+
+    Mat result; input.copyTo(result);
+    drawQRCodeResults(result, corners, decode_info, fps);
+
+    imshow("QR", result); waitKey(1);
+
+    if (!g_out_file_name.empty())
+    {
+        string out_file = g_out_file_name + g_out_file_ext;
+        cout << "Saving result: " << out_file << endl;
+        imwrite(out_file, result);
+    }
+
+    cout << "Press any key to exit ..." << endl;
+    waitKey(0);
+    cout << "Exit." << endl;
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/segment_objects.cpp b/C++/opencv-4.7.0/samples/cpp/segment_objects.cpp
new file mode 100644
index 00000000..2bcddddf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/segment_objects.cpp
@@ -0,0 +1,119 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/video/background_segm.hpp"
+#include <stdio.h>
+#include <string>
+
+using namespace std;
+using namespace cv;
+
+static void help(char** argv)
+{
+    printf("\n"
+            "This program demonstrated a simple method of connected components clean up of background subtraction\n"
+            "When the program starts, it begins learning the background.\n"
+            "You can toggle background learning on and off by hitting the space bar.\n"
+            "Call\n"
+            "%s [video file, else it reads camera 0]\n\n", argv[0]);
+}
+
+static void refineSegments(const Mat& img, Mat& mask, Mat& dst)
+{
+    int niters = 3;
+
+    vector<vector<Point> > contours;
+    vector<Vec4i> hierarchy;
+
+    Mat temp;
+
+    dilate(mask, temp, Mat(), Point(-1,-1), niters);
+    erode(temp, temp, Mat(), Point(-1,-1), niters*2);
+    dilate(temp, temp, Mat(), Point(-1,-1), niters);
+
+    findContours( temp, contours, hierarchy, RETR_CCOMP, CHAIN_APPROX_SIMPLE );
+
+    dst = Mat::zeros(img.size(), CV_8UC3);
+
+    if( contours.size() == 0 )
+        return;
+
+    // iterate through all the top-level contours,
+    // draw each connected component with its own random color
+    int idx = 0, largestComp = 0;
+    double maxArea = 0;
+
+    for( ; idx >= 0; idx = hierarchy[idx][0] )
+    {
+        const vector<Point>& c = contours[idx];
+        double area = fabs(contourArea(Mat(c)));
+        if( area > maxArea )
+        {
+            maxArea = area;
+            largestComp = idx;
+        }
+    }
+    Scalar color( 0, 0, 255 );
+    drawContours( dst, contours, largestComp, color, FILLED, LINE_8, hierarchy );
+}
+
+
+int main(int argc, char** argv)
+{
+    VideoCapture cap;
+    bool update_bg_model = true;
+
+    CommandLineParser parser(argc, argv, "{help h||}{@input||}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    string input = parser.get<std::string>("@input");
+    if (input.empty())
+        cap.open(0);
+    else
+        cap.open(samples::findFileOrKeep(input));
+
+    if( !cap.isOpened() )
+    {
+        printf("\nCan not open camera or video file\n");
+        return -1;
+    }
+
+    Mat tmp_frame, bgmask, out_frame;
+
+    cap >> tmp_frame;
+    if(tmp_frame.empty())
+    {
+        printf("can not read data from the video source\n");
+        return -1;
+    }
+
+    namedWindow("video", 1);
+    namedWindow("segmented", 1);
+
+    Ptr<BackgroundSubtractorMOG2> bgsubtractor=createBackgroundSubtractorMOG2();
+    bgsubtractor->setVarThreshold(10);
+
+    for(;;)
+    {
+        cap >> tmp_frame;
+        if( tmp_frame.empty() )
+            break;
+        bgsubtractor->apply(tmp_frame, bgmask, update_bg_model ? -1 : 0);
+        refineSegments(tmp_frame, bgmask, out_frame);
+        imshow("video", tmp_frame);
+        imshow("segmented", out_frame);
+        char keycode = (char)waitKey(30);
+        if( keycode == 27 )
+            break;
+        if( keycode == ' ' )
+        {
+            update_bg_model = !update_bg_model;
+            printf("Learn background is in state = %d\n",update_bg_model);
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/select3dobj.cpp b/C++/opencv-4.7.0/samples/cpp/select3dobj.cpp
new file mode 100644
index 00000000..0f19eb23
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/select3dobj.cpp
@@ -0,0 +1,608 @@
+/*
+ *
+ * select3obj.cpp With a calibration chessboard on a table, mark an object in a 3D box and
+ *                track that object in all subsequent frames as long as the camera can see
+ *                the chessboard. Also segments the object using the box projection. This
+ *                program is useful for collecting large datasets of many views of an object
+ *                on a table.
+ *
+ */
+
+#include "opencv2/core.hpp"
+#include <opencv2/core/utility.hpp>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/calib3d.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+
+using namespace std;
+using namespace cv;
+
+static string helphelp(char** argv)
+{
+    return  string("\nThis program's purpose is to collect data sets of an object and its segmentation mask.\n")
+        +   "\n"
+            "It shows how to use a calibrated camera together with a calibration pattern to\n"
+            "compute the homography of the plane the calibration pattern is on. It also shows grabCut\n"
+            "segmentation etc.\n"
+            "\n"
+        +   argv[0]
+        +   " -w=<board_width> -h=<board_height> [-s=<square_size>]\n"
+            "           -i=<camera_intrinsics_filename> -o=<output_prefix>\n"
+            "\n"
+            " -w=<board_width>          Number of chessboard corners wide\n"
+            " -h=<board_height>         Number of chessboard corners width\n"
+            " [-s=<square_size>]            Optional measure of chessboard squares in meters\n"
+            " -i=<camera_intrinsics_filename> Camera matrix .yml file from calibration.cpp\n"
+            " -o=<output_prefix>        Prefix the output segmentation images with this\n"
+            " [video_filename/cameraId]  If present, read from that video file or that ID\n"
+            "\n"
+            "Using a camera's intrinsics (from calibrating a camera -- see calibration.cpp) and an\n"
+            "image of the object sitting on a planar surface with a calibration pattern of\n"
+            "(board_width x board_height) on the surface, we draw a 3D box around the object. From\n"
+            "then on, we can move a camera and as long as it sees the chessboard calibration pattern,\n"
+            "it will store a mask of where the object is. We get successive images using <output_prefix>\n"
+            "of the segmentation mask containing the object. This makes creating training sets easy.\n"
+            "It is best if the chessboard is odd x even in dimensions to avoid ambiguous poses.\n"
+            "\n"
+            "The actions one can use while the program is running are:\n"
+            "\n"
+            "  Select object as 3D box with the mouse.\n"
+            "   First draw one line on the plane to outline the projection of that object on the plane\n"
+            "    Then extend that line into a box to encompass the projection of that object onto the plane\n"
+            "    The use the mouse again to extend the box upwards from the plane to encase the object.\n"
+            "  Then use the following commands\n"
+            "    ESC   - Reset the selection\n"
+            "    SPACE - Skip the frame; move to the next frame (not in video mode)\n"
+            "    ENTER - Confirm the selection. Grab next object in video mode.\n"
+            "    q     - Exit the program\n"
+            "\n\n";
+}
+// static void help()
+// {
+//     puts(helphelp);
+// }
+
+
+struct MouseEvent
+{
+    MouseEvent() { event = -1; buttonState = 0; }
+    Point pt;
+    int event;
+    int buttonState;
+};
+
+static void onMouse(int event, int x, int y, int flags, void* userdata)
+{
+    MouseEvent* data = (MouseEvent*)userdata;
+    data->event = event;
+    data->pt = Point(x,y);
+    data->buttonState = flags;
+}
+
+static bool readCameraMatrix(const string& filename,
+                             Mat& cameraMatrix, Mat& distCoeffs,
+                             Size& calibratedImageSize )
+{
+    FileStorage fs(filename, FileStorage::READ);
+    fs["image_width"] >> calibratedImageSize.width;
+    fs["image_height"] >> calibratedImageSize.height;
+    fs["distortion_coefficients"] >> distCoeffs;
+    fs["camera_matrix"] >> cameraMatrix;
+
+    if( distCoeffs.type() != CV_64F )
+        distCoeffs = Mat_<double>(distCoeffs);
+    if( cameraMatrix.type() != CV_64F )
+        cameraMatrix = Mat_<double>(cameraMatrix);
+
+    return true;
+}
+
+static void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners)
+{
+    corners.resize(0);
+
+    for( int i = 0; i < boardSize.height; i++ )
+        for( int j = 0; j < boardSize.width; j++ )
+            corners.push_back(Point3f(float(j*squareSize),
+                                      float(i*squareSize), 0));
+}
+
+
+static Point3f image2plane(Point2f imgpt, const Mat& R, const Mat& tvec,
+                           const Mat& cameraMatrix, double Z)
+{
+    Mat R1 = R.clone();
+    R1.col(2) = R1.col(2)*Z + tvec;
+    Mat_<double> v = (cameraMatrix*R1).inv()*(Mat_<double>(3,1) << imgpt.x, imgpt.y, 1);
+    double iw = fabs(v(2,0)) > DBL_EPSILON ? 1./v(2,0) : 0;
+    return Point3f((float)(v(0,0)*iw), (float)(v(1,0)*iw), (float)Z);
+}
+
+
+static Rect extract3DBox(const Mat& frame, Mat& shownFrame, Mat& selectedObjFrame,
+                         const Mat& cameraMatrix, const Mat& rvec, const Mat& tvec,
+                         const vector<Point3f>& box, int nobjpt, bool runExtraSegmentation)
+{
+    selectedObjFrame = Mat::zeros(frame.size(), frame.type());
+    if( nobjpt == 0 )
+        return Rect();
+    vector<Point3f> objpt;
+    vector<Point2f> imgpt;
+
+    objpt.push_back(box[0]);
+    if( nobjpt > 1 )
+        objpt.push_back(box[1]);
+    if( nobjpt > 2 )
+    {
+        objpt.push_back(box[2]);
+        objpt.push_back(objpt[2] - objpt[1] + objpt[0]);
+    }
+    if( nobjpt > 3 )
+        for( int i = 0; i < 4; i++ )
+            objpt.push_back(Point3f(objpt[i].x, objpt[i].y, box[3].z));
+
+    projectPoints(Mat(objpt), rvec, tvec, cameraMatrix, Mat(), imgpt);
+
+    if( !shownFrame.empty() )
+    {
+        if( nobjpt == 1 )
+            circle(shownFrame, imgpt[0], 3, Scalar(0,255,0), -1, LINE_AA);
+        else if( nobjpt == 2 )
+        {
+            circle(shownFrame, imgpt[0], 3, Scalar(0,255,0), -1, LINE_AA);
+            circle(shownFrame, imgpt[1], 3, Scalar(0,255,0), -1, LINE_AA);
+            line(shownFrame, imgpt[0], imgpt[1], Scalar(0,255,0), 3, LINE_AA);
+        }
+        else if( nobjpt == 3 )
+            for( int i = 0; i < 4; i++ )
+            {
+                circle(shownFrame, imgpt[i], 3, Scalar(0,255,0), -1, LINE_AA);
+                line(shownFrame, imgpt[i], imgpt[(i+1)%4], Scalar(0,255,0), 3, LINE_AA);
+            }
+        else
+            for( int i = 0; i < 8; i++ )
+            {
+                circle(shownFrame, imgpt[i], 3, Scalar(0,255,0), -1, LINE_AA);
+                line(shownFrame, imgpt[i], imgpt[(i+1)%4 + (i/4)*4], Scalar(0,255,0), 3, LINE_AA);
+                line(shownFrame, imgpt[i], imgpt[i%4], Scalar(0,255,0), 3, LINE_AA);
+            }
+    }
+
+    if( nobjpt <= 2 )
+        return Rect();
+    vector<Point> hull;
+    convexHull(Mat_<Point>(Mat(imgpt)), hull);
+    Mat selectedObjMask = Mat::zeros(frame.size(), CV_8U);
+    fillConvexPoly(selectedObjMask, &hull[0], (int)hull.size(), Scalar::all(255), 8, 0);
+    Rect roi = boundingRect(Mat(hull)) & Rect(Point(), frame.size());
+
+    if( runExtraSegmentation )
+    {
+        selectedObjMask = Scalar::all(GC_BGD);
+        fillConvexPoly(selectedObjMask, &hull[0], (int)hull.size(), Scalar::all(GC_PR_FGD), 8, 0);
+        Mat bgdModel, fgdModel;
+        grabCut(frame, selectedObjMask, roi, bgdModel, fgdModel,
+                3, GC_INIT_WITH_RECT + GC_INIT_WITH_MASK);
+        bitwise_and(selectedObjMask, Scalar::all(1), selectedObjMask);
+    }
+
+    frame.copyTo(selectedObjFrame, selectedObjMask);
+    return roi;
+}
+
+
+static int select3DBox(const string& windowname, const string& selWinName, const Mat& frame,
+                       const Mat& cameraMatrix, const Mat& rvec, const Mat& tvec,
+                       vector<Point3f>& box)
+{
+    const float eps = 1e-3f;
+    MouseEvent mouse;
+
+    setMouseCallback(windowname, onMouse, &mouse);
+    vector<Point3f> tempobj(8);
+    vector<Point2f> imgpt(4), tempimg(8);
+    vector<Point> temphull;
+    int nobjpt = 0;
+    Mat R, selectedObjMask, selectedObjFrame, shownFrame;
+    Rodrigues(rvec, R);
+    box.resize(4);
+
+    for(;;)
+    {
+        float Z = 0.f;
+        bool dragging = (mouse.buttonState & EVENT_FLAG_LBUTTON) != 0;
+        int npt = nobjpt;
+
+        if( (mouse.event == EVENT_LBUTTONDOWN ||
+             mouse.event == EVENT_LBUTTONUP ||
+             dragging) && nobjpt < 4 )
+        {
+            Point2f m = mouse.pt;
+
+            if( nobjpt < 2 )
+                imgpt[npt] = m;
+            else
+            {
+                tempobj.resize(1);
+                int nearestIdx = npt-1;
+                if( nobjpt == 3 )
+                {
+                    nearestIdx = 0;
+                    for( int i = 1; i < npt; i++ )
+                        if( norm(m - imgpt[i]) < norm(m - imgpt[nearestIdx]) )
+                            nearestIdx = i;
+                }
+
+                if( npt == 2 )
+                {
+                    float dx = box[1].x - box[0].x, dy = box[1].y - box[0].y;
+                    float len = 1.f/std::sqrt(dx*dx+dy*dy);
+                    tempobj[0] = Point3f(dy*len + box[nearestIdx].x,
+                                         -dx*len + box[nearestIdx].y, 0.f);
+                }
+                else
+                    tempobj[0] = Point3f(box[nearestIdx].x, box[nearestIdx].y, 1.f);
+
+                projectPoints(Mat(tempobj), rvec, tvec, cameraMatrix, Mat(), tempimg);
+
+                Point2f a = imgpt[nearestIdx], b = tempimg[0], d1 = b - a, d2 = m - a;
+                float n1 = (float)norm(d1), n2 = (float)norm(d2);
+                if( n1*n2 < eps )
+                    imgpt[npt] = a;
+                else
+                {
+                    Z = d1.dot(d2)/(n1*n1);
+                    imgpt[npt] = d1*Z + a;
+                }
+            }
+            box[npt] = image2plane(imgpt[npt], R, tvec, cameraMatrix, npt<3 ? 0 : Z);
+
+            if( (npt == 0 && mouse.event == EVENT_LBUTTONDOWN) ||
+               (npt > 0 && norm(box[npt] - box[npt-1]) > eps &&
+                mouse.event == EVENT_LBUTTONUP) )
+            {
+                nobjpt++;
+                if( nobjpt < 4 )
+                {
+                    imgpt[nobjpt] = imgpt[nobjpt-1];
+                    box[nobjpt] = box[nobjpt-1];
+                }
+            }
+
+            // reset the event
+            mouse.event = -1;
+            //mouse.buttonState = 0;
+            npt++;
+        }
+
+        frame.copyTo(shownFrame);
+        extract3DBox(frame, shownFrame, selectedObjFrame,
+                     cameraMatrix, rvec, tvec, box, npt, false);
+        imshow(windowname, shownFrame);
+        imshow(selWinName, selectedObjFrame);
+
+        char c = (char)waitKey(30);
+        if( c == 27 )
+        {
+            nobjpt = 0;
+        }
+        if( c == 'q' || c == 'Q' || c == ' ' )
+        {
+            box.clear();
+            return c == ' ' ? -1 : -100;
+        }
+        if( (c == '\r' || c == '\n') && nobjpt == 4 && box[3].z != 0 )
+            return 1;
+    }
+}
+
+
+static bool readModelViews( const string& filename, vector<Point3f>& box,
+                            vector<string>& imagelist,
+                            vector<Rect>& roiList, vector<Vec6f>& poseList )
+{
+    imagelist.resize(0);
+    roiList.resize(0);
+    poseList.resize(0);
+    box.resize(0);
+
+    FileStorage fs(filename, FileStorage::READ);
+    if( !fs.isOpened() )
+        return false;
+    fs["box"] >> box;
+
+    FileNode all = fs["views"];
+    if( all.type() != FileNode::SEQ )
+        return false;
+    FileNodeIterator it = all.begin(), it_end = all.end();
+
+    for(; it != it_end; ++it)
+    {
+        FileNode n = *it;
+        imagelist.push_back((string)n["image"]);
+        FileNode nr = n["rect"];
+        roiList.push_back(Rect((int)nr[0], (int)nr[1], (int)nr[2], (int)nr[3]));
+        FileNode np = n["pose"];
+        poseList.push_back(Vec6f((float)np[0], (float)np[1], (float)np[2],
+                                 (float)np[3], (float)np[4], (float)np[5]));
+    }
+
+    return true;
+}
+
+
+static bool writeModelViews(const string& filename, const vector<Point3f>& box,
+                            const vector<string>& imagelist,
+                            const vector<Rect>& roiList,
+                            const vector<Vec6f>& poseList)
+{
+    FileStorage fs(filename, FileStorage::WRITE);
+    if( !fs.isOpened() )
+        return false;
+
+    fs << "box" << "[:";
+    fs << box << "]" << "views" << "[";
+
+    size_t i, nviews = imagelist.size();
+
+    CV_Assert( nviews == roiList.size() && nviews == poseList.size() );
+
+    for( i = 0; i < nviews; i++ )
+    {
+        Rect r = roiList[i];
+        Vec6f p = poseList[i];
+
+        fs << "{" << "image" << imagelist[i] <<
+            "roi" << "[:" << r.x << r.y << r.width << r.height << "]" <<
+            "pose" << "[:" << p[0] << p[1] << p[2] << p[3] << p[4] << p[5] << "]" << "}";
+    }
+    fs << "]";
+
+    return true;
+}
+
+
+static bool readStringList( const string& filename, vector<string>& l )
+{
+    l.resize(0);
+    FileStorage fs(filename, FileStorage::READ);
+    if( !fs.isOpened() )
+        return false;
+    FileNode n = fs.getFirstTopLevelNode();
+    if( n.type() != FileNode::SEQ )
+        return false;
+    FileNodeIterator it = n.begin(), it_end = n.end();
+    for( ; it != it_end; ++it )
+        l.push_back((string)*it);
+    return true;
+}
+
+
+int main(int argc, char** argv)
+{
+    string help = string("Usage: ") + argv[0] + " -w=<board_width> -h=<board_height> [-s=<square_size>]\n" +
+           "\t-i=<intrinsics_filename> -o=<output_prefix> [video_filename/cameraId]\n";
+    const char* screen_help =
+    "Actions: \n"
+    "\tSelect object as 3D box with the mouse. That's it\n"
+    "\tESC - Reset the selection\n"
+    "\tSPACE - Skip the frame; move to the next frame (not in video mode)\n"
+    "\tENTER - Confirm the selection. Grab next object in video mode.\n"
+    "\tq - Exit the program\n";
+
+    cv::CommandLineParser parser(argc, argv, "{help h||}{w||}{h||}{s|1|}{i||}{o||}{@input|0|}");
+    if (parser.has("help"))
+    {
+        puts(helphelp(argv).c_str());
+        puts(help.c_str());
+        return 0;
+    }
+    string intrinsicsFilename;
+    string outprefix = "";
+    string inputName = "";
+    int cameraId = 0;
+    Size boardSize;
+    double squareSize;
+    vector<string> imageList;
+    intrinsicsFilename = parser.get<string>("i");
+    outprefix = parser.get<string>("o");
+    boardSize.width = parser.get<int>("w");
+    boardSize.height = parser.get<int>("h");
+    squareSize = parser.get<double>("s");
+    if ( parser.get<string>("@input").size() == 1 && isdigit(parser.get<string>("@input")[0]) )
+        cameraId = parser.get<int>("@input");
+    else
+        inputName = samples::findFileOrKeep(parser.get<string>("@input"));
+    if (!parser.check())
+    {
+        puts(help.c_str());
+        parser.printErrors();
+        return 0;
+    }
+    if ( boardSize.width <= 0 )
+    {
+        printf("Incorrect -w parameter (must be a positive integer)\n");
+        puts(help.c_str());
+        return 0;
+    }
+    if ( boardSize.height <= 0 )
+    {
+        printf("Incorrect -h parameter (must be a positive integer)\n");
+        puts(help.c_str());
+        return 0;
+    }
+    if ( squareSize <= 0 )
+    {
+        printf("Incorrect -s parameter (must be a positive real number)\n");
+        puts(help.c_str());
+        return 0;
+    }
+    Mat cameraMatrix, distCoeffs;
+    Size calibratedImageSize;
+    readCameraMatrix(intrinsicsFilename, cameraMatrix, distCoeffs, calibratedImageSize );
+
+    VideoCapture capture;
+    if( !inputName.empty() )
+    {
+        if( !readStringList(inputName, imageList) &&
+            !capture.open(inputName))
+        {
+            fprintf( stderr, "The input file could not be opened\n" );
+            return -1;
+        }
+    }
+    else
+        capture.open(cameraId);
+
+    if( !capture.isOpened() && imageList.empty() )
+        return fprintf( stderr, "Could not initialize video capture\n" ), -2;
+
+    const char* outbarename = 0;
+    {
+        outbarename = strrchr(outprefix.c_str(), '/');
+        const char* tmp = strrchr(outprefix.c_str(), '\\');
+        char cmd[1000];
+        snprintf(cmd, sizeof(cmd), "mkdir %s", outprefix.c_str());
+        if( tmp && tmp > outbarename )
+            outbarename = tmp;
+        if( outbarename )
+        {
+            cmd[6 + outbarename - outprefix.c_str()] = '\0';
+            int result = system(cmd);
+            CV_Assert(result == 0);
+            outbarename++;
+        }
+        else
+            outbarename = outprefix.c_str();
+    }
+
+    Mat frame, shownFrame, selectedObjFrame, mapxy;
+
+    namedWindow("View", 1);
+    namedWindow("Selected Object", 1);
+    setMouseCallback("View", onMouse, 0);
+    bool boardFound = false;
+
+    string indexFilename = cv::format("%s_index.yml", outprefix.c_str());
+
+    vector<string> capturedImgList;
+    vector<Rect> roiList;
+    vector<Vec6f> poseList;
+    vector<Point3f> box, boardPoints;
+
+    readModelViews(indexFilename, box, capturedImgList, roiList, poseList);
+    calcChessboardCorners(boardSize, (float)squareSize, boardPoints);
+    int frameIdx = 0;
+    bool grabNext = !imageList.empty();
+
+    puts(screen_help);
+
+    for(int i = 0;;i++)
+    {
+        Mat frame0;
+        if( !imageList.empty() )
+        {
+            if( i < (int)imageList.size() )
+                frame0 = imread(string(imageList[i]), 1);
+        }
+        else
+            capture >> frame0;
+        if( frame0.empty() )
+            break;
+        if( frame.empty() )
+        {
+            if( frame0.size() != calibratedImageSize )
+            {
+                double sx = (double)frame0.cols/calibratedImageSize.width;
+                double sy = (double)frame0.rows/calibratedImageSize.height;
+
+                // adjust the camera matrix for the new resolution
+                cameraMatrix.at<double>(0,0) *= sx;
+                cameraMatrix.at<double>(0,2) *= sx;
+                cameraMatrix.at<double>(1,1) *= sy;
+                cameraMatrix.at<double>(1,2) *= sy;
+            }
+            Mat dummy;
+            initUndistortRectifyMap(cameraMatrix, distCoeffs, Mat(),
+                                    cameraMatrix, frame0.size(),
+                                    CV_32FC2, mapxy, dummy );
+            distCoeffs = Mat::zeros(5, 1, CV_64F);
+        }
+        remap(frame0, frame, mapxy, Mat(), INTER_LINEAR);
+        vector<Point2f> foundBoardCorners;
+        boardFound = findChessboardCorners(frame, boardSize, foundBoardCorners);
+
+        Mat rvec, tvec;
+        if( boardFound )
+            solvePnP(Mat(boardPoints), Mat(foundBoardCorners), cameraMatrix,
+                     distCoeffs, rvec, tvec, false);
+
+        frame.copyTo(shownFrame);
+        drawChessboardCorners(shownFrame, boardSize, Mat(foundBoardCorners), boardFound);
+        selectedObjFrame = Mat::zeros(frame.size(), frame.type());
+
+        if( boardFound && grabNext )
+        {
+            if( box.empty() )
+            {
+                int code = select3DBox("View", "Selected Object", frame,
+                                        cameraMatrix, rvec, tvec, box);
+                if( code == -100 )
+                    break;
+            }
+
+            if( !box.empty() )
+            {
+                Rect r = extract3DBox(frame, shownFrame, selectedObjFrame,
+                                      cameraMatrix, rvec, tvec, box, 4, true);
+                if( !r.empty() )
+                {
+                    const int maxFrameIdx = 10000;
+                    char path[1000];
+                    for(;frameIdx < maxFrameIdx;frameIdx++)
+                    {
+                        snprintf(path, sizeof(path), "%s%04d.jpg", outprefix.c_str(), frameIdx);
+                        FILE* f = fopen(path, "rb");
+                        if( !f )
+                            break;
+                        fclose(f);
+                    }
+                    if( frameIdx == maxFrameIdx )
+                    {
+                        printf("Can not save the image as %s<...>.jpg", outprefix.c_str());
+                        break;
+                    }
+                    imwrite(path, selectedObjFrame(r));
+
+                    capturedImgList.push_back(string(path));
+                    roiList.push_back(r);
+
+                    float p[6];
+                    Mat RV(3, 1, CV_32F, p), TV(3, 1, CV_32F, p+3);
+                    rvec.convertTo(RV, RV.type());
+                    tvec.convertTo(TV, TV.type());
+                    poseList.push_back(Vec6f(p[0], p[1], p[2], p[3], p[4], p[5]));
+                }
+            }
+            grabNext = !imageList.empty();
+        }
+
+        imshow("View", shownFrame);
+        imshow("Selected Object", selectedObjFrame);
+        char c = (char)waitKey(imageList.empty() && !box.empty() ? 30 : 300);
+        if( c == 'q' || c == 'Q' )
+            break;
+        if( c == '\r' || c == '\n' )
+            grabNext = true;
+    }
+
+    writeModelViews(indexFilename, box, capturedImgList, roiList, poseList);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/simd_basic.cpp b/C++/opencv-4.7.0/samples/cpp/simd_basic.cpp
new file mode 100644
index 00000000..9af4d91c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/simd_basic.cpp
@@ -0,0 +1,49 @@
+#include "opencv2/core.hpp"
+#include "opencv2/core/simd_intrinsics.hpp"
+
+using namespace cv;
+
+int main(int /*argc*/, char** /*argv*/)
+{
+    printf("==================  macro dump  ===================\n");
+#ifdef CV_SIMD
+    printf("CV_SIMD is defined: " CVAUX_STR(CV_SIMD) "\n");
+#ifdef CV_SIMD_WIDTH
+    printf("CV_SIMD_WIDTH is defined: " CVAUX_STR(CV_SIMD_WIDTH) "\n");
+#endif
+#ifdef CV_SIMD128
+    printf("CV_SIMD128 is defined: " CVAUX_STR(CV_SIMD128) "\n");
+#endif
+#ifdef CV_SIMD256
+    printf("CV_SIMD256 is defined: " CVAUX_STR(CV_SIMD256) "\n");
+#endif
+#ifdef CV_SIMD512
+    printf("CV_SIMD512 is defined: " CVAUX_STR(CV_SIMD512) "\n");
+#endif
+#ifdef CV_SIMD_64F
+    printf("CV_SIMD_64F is defined: " CVAUX_STR(CV_SIMD_64F) "\n");
+#endif
+#ifdef CV_SIMD_FP16
+    printf("CV_SIMD_FP16 is defined: " CVAUX_STR(CV_SIMD_FP16) "\n");
+#endif
+#else
+    printf("CV_SIMD is NOT defined\n");
+#endif
+
+#ifdef CV_SIMD
+    printf("=================  sizeof checks  =================\n");
+    printf("sizeof(v_uint8) = %d\n", (int)sizeof(v_uint8));
+    printf("sizeof(v_int32) = %d\n", (int)sizeof(v_int32));
+    printf("sizeof(v_float32) = %d\n", (int)sizeof(v_float32));
+
+    printf("==================  arithm check  =================\n");
+    v_uint8 a = vx_setall_u8(10);
+    v_uint8 c = a + vx_setall_u8(45);
+    printf("(vx_setall_u8(10) + vx_setall_u8(45)).get0() => %d\n", (int)c.get0());
+#else
+    printf("\nSIMD intrinsics are not available. Check compilation target and passed build options.\n");
+#endif
+
+    printf("=====================  done  ======================\n");
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/smiledetect.cpp b/C++/opencv-4.7.0/samples/cpp/smiledetect.cpp
new file mode 100644
index 00000000..4da0ce87
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/smiledetect.cpp
@@ -0,0 +1,215 @@
+#include "opencv2/objdetect.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static void help(const char** argv)
+{
+    cout << "\nThis program demonstrates the smile detector.\n"
+            "Usage:\n" <<
+            argv[0] << " [--cascade=<cascade_path> this is the frontal face classifier]\n"
+            "   [--smile-cascade=[<smile_cascade_path>]]\n"
+            "   [--scale=<image scale greater or equal to 1, try 2.0 for example. The larger the faster the processing>]\n"
+            "   [--try-flip]\n"
+            "   [video_filename|camera_index]\n\n"
+            "Example:\n" <<
+            argv[0] << " --cascade=\"data/haarcascades/haarcascade_frontalface_alt.xml\" --smile-cascade=\"data/haarcascades/haarcascade_smile.xml\" --scale=2.0\n\n"
+            "During execution:\n\tHit any key to quit.\n"
+            "\tUsing OpenCV version " << CV_VERSION << "\n" << endl;
+}
+
+void detectAndDraw( Mat& img, CascadeClassifier& cascade,
+                    CascadeClassifier& nestedCascade,
+                    double scale, bool tryflip );
+
+string cascadeName;
+string nestedCascadeName;
+
+int main( int argc, const char** argv )
+{
+    VideoCapture capture;
+    Mat frame, image;
+    string inputName;
+    bool tryflip;
+
+    help(argv);
+
+    CascadeClassifier cascade, nestedCascade;
+    double scale;
+    cv::CommandLineParser parser(argc, argv,
+        "{help h||}{scale|1|}"
+        "{cascade|data/haarcascades/haarcascade_frontalface_alt.xml|}"
+        "{smile-cascade|data/haarcascades/haarcascade_smile.xml|}"
+        "{try-flip||}{@input||}");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    cascadeName = samples::findFile(parser.get<string>("cascade"));
+    nestedCascadeName = samples::findFile(parser.get<string>("smile-cascade"));
+    tryflip = parser.has("try-flip");
+    inputName = parser.get<string>("@input");
+    scale = parser.get<int>("scale");
+    if (!parser.check())
+    {
+        help(argv);
+        return 1;
+    }
+    if (scale < 1)
+        scale = 1;
+    if( !cascade.load( cascadeName ) )
+    {
+        cerr << "ERROR: Could not load face cascade" << endl;
+        help(argv);
+        return -1;
+    }
+    if( !nestedCascade.load( nestedCascadeName ) )
+    {
+        cerr << "ERROR: Could not load smile cascade" << endl;
+        help(argv);
+        return -1;
+    }
+    if( inputName.empty() || (isdigit(inputName[0]) && inputName.size() == 1) )
+    {
+        int c = inputName.empty() ? 0 : inputName[0] - '0' ;
+        if(!capture.open(c))
+            cout << "Capture from camera #" <<  c << " didn't work" << endl;
+    }
+    else if( inputName.size() )
+    {
+        inputName = samples::findFileOrKeep(inputName);
+        if(!capture.open( inputName ))
+            cout << "Could not read " << inputName << endl;
+    }
+
+    if( capture.isOpened() )
+    {
+        cout << "Video capturing has been started ..." << endl;
+        cout << endl << "NOTE: Smile intensity will only be valid after a first smile has been detected" << endl;
+
+        for(;;)
+        {
+            capture >> frame;
+            if( frame.empty() )
+                break;
+
+            Mat frame1 = frame.clone();
+            detectAndDraw( frame1, cascade, nestedCascade, scale, tryflip );
+
+            char c = (char)waitKey(10);
+            if( c == 27 || c == 'q' || c == 'Q' )
+                break;
+        }
+    }
+    else
+    {
+        cerr << "ERROR: Could not initiate capture" << endl;
+        help(argv);
+        return -1;
+    }
+
+    return 0;
+}
+
+void detectAndDraw( Mat& img, CascadeClassifier& cascade,
+                    CascadeClassifier& nestedCascade,
+                    double scale, bool tryflip)
+{
+    vector<Rect> faces, faces2;
+    const static Scalar colors[] =
+    {
+        Scalar(255,0,0),
+        Scalar(255,128,0),
+        Scalar(255,255,0),
+        Scalar(0,255,0),
+        Scalar(0,128,255),
+        Scalar(0,255,255),
+        Scalar(0,0,255),
+        Scalar(255,0,255)
+    };
+    Mat gray, smallImg;
+
+    cvtColor( img, gray, COLOR_BGR2GRAY );
+
+    double fx = 1 / scale;
+    resize( gray, smallImg, Size(), fx, fx, INTER_LINEAR_EXACT );
+    equalizeHist( smallImg, smallImg );
+
+    cascade.detectMultiScale( smallImg, faces,
+        1.1, 2, 0
+        //|CASCADE_FIND_BIGGEST_OBJECT
+        //|CASCADE_DO_ROUGH_SEARCH
+        |CASCADE_SCALE_IMAGE,
+        Size(30, 30) );
+    if( tryflip )
+    {
+        flip(smallImg, smallImg, 1);
+        cascade.detectMultiScale( smallImg, faces2,
+                                 1.1, 2, 0
+                                 //|CASCADE_FIND_BIGGEST_OBJECT
+                                 //|CASCADE_DO_ROUGH_SEARCH
+                                 |CASCADE_SCALE_IMAGE,
+                                 Size(30, 30) );
+        for( vector<Rect>::const_iterator r = faces2.begin(); r != faces2.end(); ++r )
+        {
+            faces.push_back(Rect(smallImg.cols - r->x - r->width, r->y, r->width, r->height));
+        }
+    }
+
+    for ( size_t i = 0; i < faces.size(); i++ )
+    {
+        Rect r = faces[i];
+        Mat smallImgROI;
+        vector<Rect> nestedObjects;
+        Point center;
+        Scalar color = colors[i%8];
+        int radius;
+
+        double aspect_ratio = (double)r.width/r.height;
+        if( 0.75 < aspect_ratio && aspect_ratio < 1.3 )
+        {
+            center.x = cvRound((r.x + r.width*0.5)*scale);
+            center.y = cvRound((r.y + r.height*0.5)*scale);
+            radius = cvRound((r.width + r.height)*0.25*scale);
+            circle( img, center, radius, color, 3, 8, 0 );
+        }
+        else
+            rectangle( img, Point(cvRound(r.x*scale), cvRound(r.y*scale)),
+                       Point(cvRound((r.x + r.width-1)*scale), cvRound((r.y + r.height-1)*scale)),
+                       color, 3, 8, 0);
+
+        const int half_height=cvRound((float)r.height/2);
+        r.y=r.y + half_height;
+        r.height = half_height-1;
+        smallImgROI = smallImg( r );
+        nestedCascade.detectMultiScale( smallImgROI, nestedObjects,
+            1.1, 0, 0
+            //|CASCADE_FIND_BIGGEST_OBJECT
+            //|CASCADE_DO_ROUGH_SEARCH
+            //|CASCADE_DO_CANNY_PRUNING
+            |CASCADE_SCALE_IMAGE,
+            Size(30, 30) );
+
+        // The number of detected neighbors depends on image size (and also illumination, etc.). The
+        // following steps use a floating minimum and maximum of neighbors. Intensity thus estimated will be
+        //accurate only after a first smile has been displayed by the user.
+        const int smile_neighbors = (int)nestedObjects.size();
+        static int max_neighbors=-1;
+        static int min_neighbors=-1;
+        if (min_neighbors == -1) min_neighbors = smile_neighbors;
+        max_neighbors = MAX(max_neighbors, smile_neighbors);
+
+        // Draw rectangle on the left side of the image reflecting smile intensity
+        float intensityZeroOne = ((float)smile_neighbors - min_neighbors) / (max_neighbors - min_neighbors + 1);
+        int rect_height = cvRound((float)img.rows * intensityZeroOne);
+        Scalar col = Scalar((float)255 * intensityZeroOne, 0, 0);
+        rectangle(img, Point(0, img.rows), Point(img.cols/10, img.rows - rect_height), col, -1);
+    }
+
+    imshow( "result", img );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/squares.cpp b/C++/opencv-4.7.0/samples/cpp/squares.cpp
new file mode 100644
index 00000000..2ea824de
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/squares.cpp
@@ -0,0 +1,158 @@
+
+// The "Square Detector" program.
+// It loads several images sequentially and tries to find squares in
+// each image
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help(const char* programName)
+{
+    cout <<
+    "\nA program using pyramid scaling, Canny, contours and contour simplification\n"
+    "to find squares in a list of images (pic1-6.png)\n"
+    "Returns sequence of squares detected on the image.\n"
+    "Call:\n"
+    "./" << programName << " [file_name (optional)]\n"
+    "Using OpenCV version " << CV_VERSION << "\n" << endl;
+}
+
+
+int thresh = 50, N = 11;
+const char* wndname = "Square Detection Demo";
+
+// helper function:
+// finds a cosine of angle between vectors
+// from pt0->pt1 and from pt0->pt2
+static double angle( Point pt1, Point pt2, Point pt0 )
+{
+    double dx1 = pt1.x - pt0.x;
+    double dy1 = pt1.y - pt0.y;
+    double dx2 = pt2.x - pt0.x;
+    double dy2 = pt2.y - pt0.y;
+    return (dx1*dx2 + dy1*dy2)/sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);
+}
+
+// returns sequence of squares detected on the image.
+static void findSquares( const Mat& image, vector<vector<Point> >& squares )
+{
+    squares.clear();
+
+    Mat pyr, timg, gray0(image.size(), CV_8U), gray;
+
+    // down-scale and upscale the image to filter out the noise
+    pyrDown(image, pyr, Size(image.cols/2, image.rows/2));
+    pyrUp(pyr, timg, image.size());
+    vector<vector<Point> > contours;
+
+    // find squares in every color plane of the image
+    for( int c = 0; c < 3; c++ )
+    {
+        int ch[] = {c, 0};
+        mixChannels(&timg, 1, &gray0, 1, ch, 1);
+
+        // try several threshold levels
+        for( int l = 0; l < N; l++ )
+        {
+            // hack: use Canny instead of zero threshold level.
+            // Canny helps to catch squares with gradient shading
+            if( l == 0 )
+            {
+                // apply Canny. Take the upper threshold from slider
+                // and set the lower to 0 (which forces edges merging)
+                Canny(gray0, gray, 0, thresh, 5);
+                // dilate canny output to remove potential
+                // holes between edge segments
+                dilate(gray, gray, Mat(), Point(-1,-1));
+            }
+            else
+            {
+                // apply threshold if l!=0:
+                //     tgray(x,y) = gray(x,y) < (l+1)*255/N ? 255 : 0
+                gray = gray0 >= (l+1)*255/N;
+            }
+
+            // find contours and store them all as a list
+            findContours(gray, contours, RETR_LIST, CHAIN_APPROX_SIMPLE);
+
+            vector<Point> approx;
+
+            // test each contour
+            for( size_t i = 0; i < contours.size(); i++ )
+            {
+                // approximate contour with accuracy proportional
+                // to the contour perimeter
+                approxPolyDP(contours[i], approx, arcLength(contours[i], true)*0.02, true);
+
+                // square contours should have 4 vertices after approximation
+                // relatively large area (to filter out noisy contours)
+                // and be convex.
+                // Note: absolute value of an area is used because
+                // area may be positive or negative - in accordance with the
+                // contour orientation
+                if( approx.size() == 4 &&
+                    fabs(contourArea(approx)) > 1000 &&
+                    isContourConvex(approx) )
+                {
+                    double maxCosine = 0;
+
+                    for( int j = 2; j < 5; j++ )
+                    {
+                        // find the maximum cosine of the angle between joint edges
+                        double cosine = fabs(angle(approx[j%4], approx[j-2], approx[j-1]));
+                        maxCosine = MAX(maxCosine, cosine);
+                    }
+
+                    // if cosines of all angles are small
+                    // (all angles are ~90 degree) then write quandrange
+                    // vertices to resultant sequence
+                    if( maxCosine < 0.3 )
+                        squares.push_back(approx);
+                }
+            }
+        }
+    }
+}
+
+int main(int argc, char** argv)
+{
+    const char* names[] = { "pic1.png", "pic2.png", "pic3.png",
+        "pic4.png", "pic5.png", "pic6.png", 0 };
+    help(argv[0]);
+
+    if( argc > 1)
+    {
+     names[0] =  argv[1];
+     names[1] =  0;
+    }
+
+    for( int i = 0; names[i] != 0; i++ )
+    {
+        string filename = samples::findFile(names[i]);
+        Mat image = imread(filename, IMREAD_COLOR);
+        if( image.empty() )
+        {
+            cout << "Couldn't load " << filename << endl;
+            continue;
+        }
+
+        vector<vector<Point> > squares;
+        findSquares(image, squares);
+
+        polylines(image, squares, true, Scalar(0, 255, 0), 3, LINE_AA);
+        imshow(wndname, image);
+
+        int c = waitKey();
+        if( c == 27 )
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/stereo_calib.cpp b/C++/opencv-4.7.0/samples/cpp/stereo_calib.cpp
new file mode 100644
index 00000000..9f5aa56e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/stereo_calib.cpp
@@ -0,0 +1,371 @@
+/* This is sample from the OpenCV book. The copyright notice is below */
+
+/* *************** License:**************************
+   Oct. 3, 2008
+   Right to use this code in any way you want without warranty, support or any guarantee of it working.
+
+   BOOK: It would be nice if you cited it:
+   Learning OpenCV: Computer Vision with the OpenCV Library
+     by Gary Bradski and Adrian Kaehler
+     Published by O'Reilly Media, October 3, 2008
+
+   AVAILABLE AT:
+     http://www.amazon.com/Learning-OpenCV-Computer-Vision-Library/dp/0596516134
+     Or: http://oreilly.com/catalog/9780596516130/
+     ISBN-10: 0596516134 or: ISBN-13: 978-0596516130
+
+   OPENCV WEBSITES:
+     Homepage:      http://opencv.org
+     Online docs:   http://docs.opencv.org
+     GitHub:        https://github.com/opencv/opencv/
+   ************************************************** */
+
+#include "opencv2/calib3d.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+using namespace cv;
+using namespace std;
+
+static int print_help(char** argv)
+{
+    cout <<
+            " Given a list of chessboard images, the number of corners (nx, ny)\n"
+            " on the chessboards, and a flag: useCalibrated for \n"
+            "   calibrated (0) or\n"
+            "   uncalibrated \n"
+            "     (1: use stereoCalibrate(), 2: compute fundamental\n"
+            "         matrix separately) stereo. \n"
+            " Calibrate the cameras and display the\n"
+            " rectified results along with the computed disparity images.   \n" << endl;
+    cout << "Usage:\n " << argv[0] << " -w=<board_width default=9> -h=<board_height default=6> -s=<square_size default=1.0> <image list XML/YML file default=stereo_calib.xml>\n" << endl;
+    return 0;
+}
+
+
+static void
+StereoCalib(const vector<string>& imagelist, Size boardSize, float squareSize, bool displayCorners = false, bool useCalibrated=true, bool showRectified=true)
+{
+    if( imagelist.size() % 2 != 0 )
+    {
+        cout << "Error: the image list contains odd (non-even) number of elements\n";
+        return;
+    }
+
+    const int maxScale = 2;
+    // ARRAY AND VECTOR STORAGE:
+
+    vector<vector<Point2f> > imagePoints[2];
+    vector<vector<Point3f> > objectPoints;
+    Size imageSize;
+
+    int i, j, k, nimages = (int)imagelist.size()/2;
+
+    imagePoints[0].resize(nimages);
+    imagePoints[1].resize(nimages);
+    vector<string> goodImageList;
+
+    for( i = j = 0; i < nimages; i++ )
+    {
+        for( k = 0; k < 2; k++ )
+        {
+            const string& filename = imagelist[i*2+k];
+            Mat img = imread(filename, 0);
+            if(img.empty())
+                break;
+            if( imageSize == Size() )
+                imageSize = img.size();
+            else if( img.size() != imageSize )
+            {
+                cout << "The image " << filename << " has the size different from the first image size. Skipping the pair\n";
+                break;
+            }
+            bool found = false;
+            vector<Point2f>& corners = imagePoints[k][j];
+            for( int scale = 1; scale <= maxScale; scale++ )
+            {
+                Mat timg;
+                if( scale == 1 )
+                    timg = img;
+                else
+                    resize(img, timg, Size(), scale, scale, INTER_LINEAR_EXACT);
+                found = findChessboardCorners(timg, boardSize, corners,
+                    CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_NORMALIZE_IMAGE);
+                if( found )
+                {
+                    if( scale > 1 )
+                    {
+                        Mat cornersMat(corners);
+                        cornersMat *= 1./scale;
+                    }
+                    break;
+                }
+            }
+            if( displayCorners )
+            {
+                cout << filename << endl;
+                Mat cimg, cimg1;
+                cvtColor(img, cimg, COLOR_GRAY2BGR);
+                drawChessboardCorners(cimg, boardSize, corners, found);
+                double sf = 640./MAX(img.rows, img.cols);
+                resize(cimg, cimg1, Size(), sf, sf, INTER_LINEAR_EXACT);
+                imshow("corners", cimg1);
+                char c = (char)waitKey(500);
+                if( c == 27 || c == 'q' || c == 'Q' ) //Allow ESC to quit
+                    exit(-1);
+            }
+            else
+                putchar('.');
+            if( !found )
+                break;
+            cornerSubPix(img, corners, Size(11,11), Size(-1,-1),
+                         TermCriteria(TermCriteria::COUNT+TermCriteria::EPS,
+                                      30, 0.01));
+        }
+        if( k == 2 )
+        {
+            goodImageList.push_back(imagelist[i*2]);
+            goodImageList.push_back(imagelist[i*2+1]);
+            j++;
+        }
+    }
+    cout << j << " pairs have been successfully detected.\n";
+    nimages = j;
+    if( nimages < 2 )
+    {
+        cout << "Error: too little pairs to run the calibration\n";
+        return;
+    }
+
+    imagePoints[0].resize(nimages);
+    imagePoints[1].resize(nimages);
+    objectPoints.resize(nimages);
+
+    for( i = 0; i < nimages; i++ )
+    {
+        for( j = 0; j < boardSize.height; j++ )
+            for( k = 0; k < boardSize.width; k++ )
+                objectPoints[i].push_back(Point3f(k*squareSize, j*squareSize, 0));
+    }
+
+    cout << "Running stereo calibration ...\n";
+
+    Mat cameraMatrix[2], distCoeffs[2];
+    cameraMatrix[0] = initCameraMatrix2D(objectPoints,imagePoints[0],imageSize,0);
+    cameraMatrix[1] = initCameraMatrix2D(objectPoints,imagePoints[1],imageSize,0);
+    Mat R, T, E, F;
+
+    double rms = stereoCalibrate(objectPoints, imagePoints[0], imagePoints[1],
+                    cameraMatrix[0], distCoeffs[0],
+                    cameraMatrix[1], distCoeffs[1],
+                    imageSize, R, T, E, F,
+                    CALIB_FIX_ASPECT_RATIO +
+                    CALIB_ZERO_TANGENT_DIST +
+                    CALIB_USE_INTRINSIC_GUESS +
+                    CALIB_SAME_FOCAL_LENGTH +
+                    CALIB_RATIONAL_MODEL +
+                    CALIB_FIX_K3 + CALIB_FIX_K4 + CALIB_FIX_K5,
+                    TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, 1e-5) );
+    cout << "done with RMS error=" << rms << endl;
+
+// CALIBRATION QUALITY CHECK
+// because the output fundamental matrix implicitly
+// includes all the output information,
+// we can check the quality of calibration using the
+// epipolar geometry constraint: m2^t*F*m1=0
+    double err = 0;
+    int npoints = 0;
+    vector<Vec3f> lines[2];
+    for( i = 0; i < nimages; i++ )
+    {
+        int npt = (int)imagePoints[0][i].size();
+        Mat imgpt[2];
+        for( k = 0; k < 2; k++ )
+        {
+            imgpt[k] = Mat(imagePoints[k][i]);
+            undistortPoints(imgpt[k], imgpt[k], cameraMatrix[k], distCoeffs[k], Mat(), cameraMatrix[k]);
+            computeCorrespondEpilines(imgpt[k], k+1, F, lines[k]);
+        }
+        for( j = 0; j < npt; j++ )
+        {
+            double errij = fabs(imagePoints[0][i][j].x*lines[1][j][0] +
+                                imagePoints[0][i][j].y*lines[1][j][1] + lines[1][j][2]) +
+                           fabs(imagePoints[1][i][j].x*lines[0][j][0] +
+                                imagePoints[1][i][j].y*lines[0][j][1] + lines[0][j][2]);
+            err += errij;
+        }
+        npoints += npt;
+    }
+    cout << "average epipolar err = " <<  err/npoints << endl;
+
+    // save intrinsic parameters
+    FileStorage fs("intrinsics.yml", FileStorage::WRITE);
+    if( fs.isOpened() )
+    {
+        fs << "M1" << cameraMatrix[0] << "D1" << distCoeffs[0] <<
+            "M2" << cameraMatrix[1] << "D2" << distCoeffs[1];
+        fs.release();
+    }
+    else
+        cout << "Error: can not save the intrinsic parameters\n";
+
+    Mat R1, R2, P1, P2, Q;
+    Rect validRoi[2];
+
+    stereoRectify(cameraMatrix[0], distCoeffs[0],
+                  cameraMatrix[1], distCoeffs[1],
+                  imageSize, R, T, R1, R2, P1, P2, Q,
+                  CALIB_ZERO_DISPARITY, 1, imageSize, &validRoi[0], &validRoi[1]);
+
+    fs.open("extrinsics.yml", FileStorage::WRITE);
+    if( fs.isOpened() )
+    {
+        fs << "R" << R << "T" << T << "R1" << R1 << "R2" << R2 << "P1" << P1 << "P2" << P2 << "Q" << Q;
+        fs.release();
+    }
+    else
+        cout << "Error: can not save the extrinsic parameters\n";
+
+    // OpenCV can handle left-right
+    // or up-down camera arrangements
+    bool isVerticalStereo = fabs(P2.at<double>(1, 3)) > fabs(P2.at<double>(0, 3));
+
+// COMPUTE AND DISPLAY RECTIFICATION
+    if( !showRectified )
+        return;
+
+    Mat rmap[2][2];
+// IF BY CALIBRATED (BOUGUET'S METHOD)
+    if( useCalibrated )
+    {
+        // we already computed everything
+    }
+// OR ELSE HARTLEY'S METHOD
+    else
+ // use intrinsic parameters of each camera, but
+ // compute the rectification transformation directly
+ // from the fundamental matrix
+    {
+        vector<Point2f> allimgpt[2];
+        for( k = 0; k < 2; k++ )
+        {
+            for( i = 0; i < nimages; i++ )
+                std::copy(imagePoints[k][i].begin(), imagePoints[k][i].end(), back_inserter(allimgpt[k]));
+        }
+        F = findFundamentalMat(Mat(allimgpt[0]), Mat(allimgpt[1]), FM_8POINT, 0, 0);
+        Mat H1, H2;
+        stereoRectifyUncalibrated(Mat(allimgpt[0]), Mat(allimgpt[1]), F, imageSize, H1, H2, 3);
+
+        R1 = cameraMatrix[0].inv()*H1*cameraMatrix[0];
+        R2 = cameraMatrix[1].inv()*H2*cameraMatrix[1];
+        P1 = cameraMatrix[0];
+        P2 = cameraMatrix[1];
+    }
+
+    //Precompute maps for cv::remap()
+    initUndistortRectifyMap(cameraMatrix[0], distCoeffs[0], R1, P1, imageSize, CV_16SC2, rmap[0][0], rmap[0][1]);
+    initUndistortRectifyMap(cameraMatrix[1], distCoeffs[1], R2, P2, imageSize, CV_16SC2, rmap[1][0], rmap[1][1]);
+
+    Mat canvas;
+    double sf;
+    int w, h;
+    if( !isVerticalStereo )
+    {
+        sf = 600./MAX(imageSize.width, imageSize.height);
+        w = cvRound(imageSize.width*sf);
+        h = cvRound(imageSize.height*sf);
+        canvas.create(h, w*2, CV_8UC3);
+    }
+    else
+    {
+        sf = 300./MAX(imageSize.width, imageSize.height);
+        w = cvRound(imageSize.width*sf);
+        h = cvRound(imageSize.height*sf);
+        canvas.create(h*2, w, CV_8UC3);
+    }
+
+    for( i = 0; i < nimages; i++ )
+    {
+        for( k = 0; k < 2; k++ )
+        {
+            Mat img = imread(goodImageList[i*2+k], 0), rimg, cimg;
+            remap(img, rimg, rmap[k][0], rmap[k][1], INTER_LINEAR);
+            cvtColor(rimg, cimg, COLOR_GRAY2BGR);
+            Mat canvasPart = !isVerticalStereo ? canvas(Rect(w*k, 0, w, h)) : canvas(Rect(0, h*k, w, h));
+            resize(cimg, canvasPart, canvasPart.size(), 0, 0, INTER_AREA);
+            if( useCalibrated )
+            {
+                Rect vroi(cvRound(validRoi[k].x*sf), cvRound(validRoi[k].y*sf),
+                          cvRound(validRoi[k].width*sf), cvRound(validRoi[k].height*sf));
+                rectangle(canvasPart, vroi, Scalar(0,0,255), 3, 8);
+            }
+        }
+
+        if( !isVerticalStereo )
+            for( j = 0; j < canvas.rows; j += 16 )
+                line(canvas, Point(0, j), Point(canvas.cols, j), Scalar(0, 255, 0), 1, 8);
+        else
+            for( j = 0; j < canvas.cols; j += 16 )
+                line(canvas, Point(j, 0), Point(j, canvas.rows), Scalar(0, 255, 0), 1, 8);
+        imshow("rectified", canvas);
+        char c = (char)waitKey();
+        if( c == 27 || c == 'q' || c == 'Q' )
+            break;
+    }
+}
+
+
+static bool readStringList( const string& filename, vector<string>& l )
+{
+    l.resize(0);
+    FileStorage fs(filename, FileStorage::READ);
+    if( !fs.isOpened() )
+        return false;
+    FileNode n = fs.getFirstTopLevelNode();
+    if( n.type() != FileNode::SEQ )
+        return false;
+    FileNodeIterator it = n.begin(), it_end = n.end();
+    for( ; it != it_end; ++it )
+        l.push_back((string)*it);
+    return true;
+}
+
+int main(int argc, char** argv)
+{
+    Size boardSize;
+    string imagelistfn;
+    bool showRectified;
+    cv::CommandLineParser parser(argc, argv, "{w|9|}{h|6|}{s|1.0|}{nr||}{help||}{@input|stereo_calib.xml|}");
+    if (parser.has("help"))
+        return print_help(argv);
+    showRectified = !parser.has("nr");
+    imagelistfn = samples::findFile(parser.get<string>("@input"));
+    boardSize.width = parser.get<int>("w");
+    boardSize.height = parser.get<int>("h");
+    float squareSize = parser.get<float>("s");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+    vector<string> imagelist;
+    bool ok = readStringList(imagelistfn, imagelist);
+    if(!ok || imagelist.empty())
+    {
+        cout << "can not open " << imagelistfn << " or the string list is empty" << endl;
+        return print_help(argv);
+    }
+
+    StereoCalib(imagelist, boardSize, squareSize, false, true, showRectified);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/stereo_match.cpp b/C++/opencv-4.7.0/samples/cpp/stereo_match.cpp
new file mode 100644
index 00000000..55cd89c2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/stereo_match.cpp
@@ -0,0 +1,328 @@
+/*
+ *  stereo_match.cpp
+ *  calibration
+ *
+ *  Created by Victor  Eruhimov on 1/18/10.
+ *  Copyright 2010 Argus Corp. All rights reserved.
+ *
+ */
+
+#include "opencv2/calib3d/calib3d.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core/utility.hpp"
+
+#include <stdio.h>
+#include <sstream>
+
+using namespace cv;
+
+static void print_help(char** argv)
+{
+    printf("\nDemo stereo matching converting L and R images into disparity and point clouds\n");
+    printf("\nUsage: %s <left_image> <right_image> [--algorithm=bm|sgbm|hh|hh4|sgbm3way] [--blocksize=<block_size>]\n"
+           "[--max-disparity=<max_disparity>] [--scale=scale_factor>] [-i=<intrinsic_filename>] [-e=<extrinsic_filename>]\n"
+           "[--no-display] [--color] [-o=<disparity_image>] [-p=<point_cloud_file>]\n", argv[0]);
+}
+
+static void saveXYZ(const char* filename, const Mat& mat)
+{
+    const double max_z = 1.0e4;
+    FILE* fp = fopen(filename, "wt");
+    for(int y = 0; y < mat.rows; y++)
+    {
+        for(int x = 0; x < mat.cols; x++)
+        {
+            Vec3f point = mat.at<Vec3f>(y, x);
+            if(fabs(point[2] - max_z) < FLT_EPSILON || fabs(point[2]) > max_z) continue;
+            fprintf(fp, "%f %f %f\n", point[0], point[1], point[2]);
+        }
+    }
+    fclose(fp);
+}
+
+int main(int argc, char** argv)
+{
+    std::string img1_filename = "";
+    std::string img2_filename = "";
+    std::string intrinsic_filename = "";
+    std::string extrinsic_filename = "";
+    std::string disparity_filename = "";
+    std::string point_cloud_filename = "";
+
+    enum { STEREO_BM=0, STEREO_SGBM=1, STEREO_HH=2, STEREO_VAR=3, STEREO_3WAY=4, STEREO_HH4=5 };
+    int alg = STEREO_SGBM;
+    int SADWindowSize, numberOfDisparities;
+    bool no_display;
+    bool color_display;
+    float scale;
+
+    Ptr<StereoBM> bm = StereoBM::create(16,9);
+    Ptr<StereoSGBM> sgbm = StereoSGBM::create(0,16,3);
+    cv::CommandLineParser parser(argc, argv,
+        "{@arg1||}{@arg2||}{help h||}{algorithm||}{max-disparity|0|}{blocksize|0|}{no-display||}{color||}{scale|1|}{i||}{e||}{o||}{p||}");
+    if(parser.has("help"))
+    {
+        print_help(argv);
+        return 0;
+    }
+    img1_filename = samples::findFile(parser.get<std::string>(0));
+    img2_filename = samples::findFile(parser.get<std::string>(1));
+    if (parser.has("algorithm"))
+    {
+        std::string _alg = parser.get<std::string>("algorithm");
+        alg = _alg == "bm" ? STEREO_BM :
+            _alg == "sgbm" ? STEREO_SGBM :
+            _alg == "hh" ? STEREO_HH :
+            _alg == "var" ? STEREO_VAR :
+            _alg == "hh4" ? STEREO_HH4 :
+            _alg == "sgbm3way" ? STEREO_3WAY : -1;
+    }
+    numberOfDisparities = parser.get<int>("max-disparity");
+    SADWindowSize = parser.get<int>("blocksize");
+    scale = parser.get<float>("scale");
+    no_display = parser.has("no-display");
+    color_display = parser.has("color");
+    if( parser.has("i") )
+        intrinsic_filename = parser.get<std::string>("i");
+    if( parser.has("e") )
+        extrinsic_filename = parser.get<std::string>("e");
+    if( parser.has("o") )
+        disparity_filename = parser.get<std::string>("o");
+    if( parser.has("p") )
+        point_cloud_filename = parser.get<std::string>("p");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+    if( alg < 0 )
+    {
+        printf("Command-line parameter error: Unknown stereo algorithm\n\n");
+        print_help(argv);
+        return -1;
+    }
+    if ( numberOfDisparities < 1 || numberOfDisparities % 16 != 0 )
+    {
+        printf("Command-line parameter error: The max disparity (--maxdisparity=<...>) must be a positive integer divisible by 16\n");
+        print_help(argv);
+        return -1;
+    }
+    if (scale < 0)
+    {
+        printf("Command-line parameter error: The scale factor (--scale=<...>) must be a positive floating-point number\n");
+        return -1;
+    }
+    if (SADWindowSize < 1 || SADWindowSize % 2 != 1)
+    {
+        printf("Command-line parameter error: The block size (--blocksize=<...>) must be a positive odd number\n");
+        return -1;
+    }
+    if( img1_filename.empty() || img2_filename.empty() )
+    {
+        printf("Command-line parameter error: both left and right images must be specified\n");
+        return -1;
+    }
+    if( (!intrinsic_filename.empty()) ^ (!extrinsic_filename.empty()) )
+    {
+        printf("Command-line parameter error: either both intrinsic and extrinsic parameters must be specified, or none of them (when the stereo pair is already rectified)\n");
+        return -1;
+    }
+
+    if( extrinsic_filename.empty() && !point_cloud_filename.empty() )
+    {
+        printf("Command-line parameter error: extrinsic and intrinsic parameters must be specified to compute the point cloud\n");
+        return -1;
+    }
+
+    int color_mode = alg == STEREO_BM ? 0 : -1;
+    Mat img1 = imread(img1_filename, color_mode);
+    Mat img2 = imread(img2_filename, color_mode);
+
+    if (img1.empty())
+    {
+        printf("Command-line parameter error: could not load the first input image file\n");
+        return -1;
+    }
+    if (img2.empty())
+    {
+        printf("Command-line parameter error: could not load the second input image file\n");
+        return -1;
+    }
+
+    if (scale != 1.f)
+    {
+        Mat temp1, temp2;
+        int method = scale < 1 ? INTER_AREA : INTER_CUBIC;
+        resize(img1, temp1, Size(), scale, scale, method);
+        img1 = temp1;
+        resize(img2, temp2, Size(), scale, scale, method);
+        img2 = temp2;
+    }
+
+    Size img_size = img1.size();
+
+    Rect roi1, roi2;
+    Mat Q;
+
+    if( !intrinsic_filename.empty() )
+    {
+        // reading intrinsic parameters
+        FileStorage fs(intrinsic_filename, FileStorage::READ);
+        if(!fs.isOpened())
+        {
+            printf("Failed to open file %s\n", intrinsic_filename.c_str());
+            return -1;
+        }
+
+        Mat M1, D1, M2, D2;
+        fs["M1"] >> M1;
+        fs["D1"] >> D1;
+        fs["M2"] >> M2;
+        fs["D2"] >> D2;
+
+        M1 *= scale;
+        M2 *= scale;
+
+        fs.open(extrinsic_filename, FileStorage::READ);
+        if(!fs.isOpened())
+        {
+            printf("Failed to open file %s\n", extrinsic_filename.c_str());
+            return -1;
+        }
+
+        Mat R, T, R1, P1, R2, P2;
+        fs["R"] >> R;
+        fs["T"] >> T;
+
+        stereoRectify( M1, D1, M2, D2, img_size, R, T, R1, R2, P1, P2, Q, CALIB_ZERO_DISPARITY, -1, img_size, &roi1, &roi2 );
+
+        Mat map11, map12, map21, map22;
+        initUndistortRectifyMap(M1, D1, R1, P1, img_size, CV_16SC2, map11, map12);
+        initUndistortRectifyMap(M2, D2, R2, P2, img_size, CV_16SC2, map21, map22);
+
+        Mat img1r, img2r;
+        remap(img1, img1r, map11, map12, INTER_LINEAR);
+        remap(img2, img2r, map21, map22, INTER_LINEAR);
+
+        img1 = img1r;
+        img2 = img2r;
+    }
+
+    numberOfDisparities = numberOfDisparities > 0 ? numberOfDisparities : ((img_size.width/8) + 15) & -16;
+
+    bm->setROI1(roi1);
+    bm->setROI2(roi2);
+    bm->setPreFilterCap(31);
+    bm->setBlockSize(SADWindowSize > 0 ? SADWindowSize : 9);
+    bm->setMinDisparity(0);
+    bm->setNumDisparities(numberOfDisparities);
+    bm->setTextureThreshold(10);
+    bm->setUniquenessRatio(15);
+    bm->setSpeckleWindowSize(100);
+    bm->setSpeckleRange(32);
+    bm->setDisp12MaxDiff(1);
+
+    sgbm->setPreFilterCap(63);
+    int sgbmWinSize = SADWindowSize > 0 ? SADWindowSize : 3;
+    sgbm->setBlockSize(sgbmWinSize);
+
+    int cn = img1.channels();
+
+    sgbm->setP1(8*cn*sgbmWinSize*sgbmWinSize);
+    sgbm->setP2(32*cn*sgbmWinSize*sgbmWinSize);
+    sgbm->setMinDisparity(0);
+    sgbm->setNumDisparities(numberOfDisparities);
+    sgbm->setUniquenessRatio(10);
+    sgbm->setSpeckleWindowSize(100);
+    sgbm->setSpeckleRange(32);
+    sgbm->setDisp12MaxDiff(1);
+    if(alg==STEREO_HH)
+        sgbm->setMode(StereoSGBM::MODE_HH);
+    else if(alg==STEREO_SGBM)
+        sgbm->setMode(StereoSGBM::MODE_SGBM);
+    else if(alg==STEREO_HH4)
+        sgbm->setMode(StereoSGBM::MODE_HH4);
+    else if(alg==STEREO_3WAY)
+        sgbm->setMode(StereoSGBM::MODE_SGBM_3WAY);
+
+    Mat disp, disp8;
+    //Mat img1p, img2p, dispp;
+    //copyMakeBorder(img1, img1p, 0, 0, numberOfDisparities, 0, IPL_BORDER_REPLICATE);
+    //copyMakeBorder(img2, img2p, 0, 0, numberOfDisparities, 0, IPL_BORDER_REPLICATE);
+
+    int64 t = getTickCount();
+    float disparity_multiplier = 1.0f;
+    if( alg == STEREO_BM )
+    {
+        bm->compute(img1, img2, disp);
+        if (disp.type() == CV_16S)
+            disparity_multiplier = 16.0f;
+    }
+    else if( alg == STEREO_SGBM || alg == STEREO_HH || alg == STEREO_HH4 || alg == STEREO_3WAY )
+    {
+        sgbm->compute(img1, img2, disp);
+        if (disp.type() == CV_16S)
+            disparity_multiplier = 16.0f;
+    }
+    t = getTickCount() - t;
+    printf("Time elapsed: %fms\n", t*1000/getTickFrequency());
+
+    //disp = dispp.colRange(numberOfDisparities, img1p.cols);
+    if( alg != STEREO_VAR )
+        disp.convertTo(disp8, CV_8U, 255/(numberOfDisparities*16.));
+    else
+        disp.convertTo(disp8, CV_8U);
+
+    Mat disp8_3c;
+    if (color_display)
+        cv::applyColorMap(disp8, disp8_3c, COLORMAP_TURBO);
+
+    if(!disparity_filename.empty())
+        imwrite(disparity_filename, color_display ? disp8_3c : disp8);
+
+    if(!point_cloud_filename.empty())
+    {
+        printf("storing the point cloud...");
+        fflush(stdout);
+        Mat xyz;
+        Mat floatDisp;
+        disp.convertTo(floatDisp, CV_32F, 1.0f / disparity_multiplier);
+        reprojectImageTo3D(floatDisp, xyz, Q, true);
+        saveXYZ(point_cloud_filename.c_str(), xyz);
+        printf("\n");
+    }
+
+    if( !no_display )
+    {
+        std::ostringstream oss;
+        oss << "disparity  " << (alg==STEREO_BM ? "bm" :
+                                 alg==STEREO_SGBM ? "sgbm" :
+                                 alg==STEREO_HH ? "hh" :
+                                 alg==STEREO_VAR ? "var" :
+                                 alg==STEREO_HH4 ? "hh4" :
+                                 alg==STEREO_3WAY ? "sgbm3way" : "");
+        oss << "  blocksize:" << (alg==STEREO_BM ? SADWindowSize : sgbmWinSize);
+        oss << "  max-disparity:" << numberOfDisparities;
+        std::string disp_name = oss.str();
+
+        namedWindow("left", cv::WINDOW_NORMAL);
+        imshow("left", img1);
+        namedWindow("right", cv::WINDOW_NORMAL);
+        imshow("right", img2);
+        namedWindow(disp_name, cv::WINDOW_AUTOSIZE);
+        imshow(disp_name, color_display ? disp8_3c : disp8);
+
+        printf("press ESC key or CTRL+C to close...");
+        fflush(stdout);
+        printf("\n");
+        while(1)
+        {
+            if(waitKey() == 27) //ESC (prevents closing on actions like taking screenshots)
+                break;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/stitching.cpp b/C++/opencv-4.7.0/samples/cpp/stitching.cpp
new file mode 100644
index 00000000..7de05364
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/stitching.cpp
@@ -0,0 +1,119 @@
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/stitching.hpp"
+
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+bool divide_images = false;
+Stitcher::Mode mode = Stitcher::PANORAMA;
+vector<Mat> imgs;
+string result_name = "result.jpg";
+
+void printUsage(char** argv);
+int parseCmdArgs(int argc, char** argv);
+
+int main(int argc, char* argv[])
+{
+    int retval = parseCmdArgs(argc, argv);
+    if (retval) return EXIT_FAILURE;
+
+    //![stitching]
+    Mat pano;
+    Ptr<Stitcher> stitcher = Stitcher::create(mode);
+    Stitcher::Status status = stitcher->stitch(imgs, pano);
+
+    if (status != Stitcher::OK)
+    {
+        cout << "Can't stitch images, error code = " << int(status) << endl;
+        return EXIT_FAILURE;
+    }
+    //![stitching]
+
+    imwrite(result_name, pano);
+    cout << "stitching completed successfully\n" << result_name << " saved!";
+    return EXIT_SUCCESS;
+}
+
+
+void printUsage(char** argv)
+{
+    cout <<
+         "Images stitcher.\n\n" << "Usage :\n" << argv[0] <<" [Flags] img1 img2 [...imgN]\n\n"
+         "Flags:\n"
+         "  --d3\n"
+         "      internally creates three chunks of each image to increase stitching success\n"
+         "  --mode (panorama|scans)\n"
+         "      Determines configuration of stitcher. The default is 'panorama',\n"
+         "      mode suitable for creating photo panoramas. Option 'scans' is suitable\n"
+         "      for stitching materials under affine transformation, such as scans.\n"
+         "  --output <result_img>\n"
+         "      The default is 'result.jpg'.\n\n"
+         "Example usage :\n" << argv[0] << " --d3 --mode scans img1.jpg img2.jpg\n";
+}
+
+
+int parseCmdArgs(int argc, char** argv)
+{
+    if (argc == 1)
+    {
+        printUsage(argv);
+        return EXIT_FAILURE;
+    }
+
+    for (int i = 1; i < argc; ++i)
+    {
+        if (string(argv[i]) == "--help" || string(argv[i]) == "/?")
+        {
+            printUsage(argv);
+            return EXIT_FAILURE;
+        }
+        else if (string(argv[i]) == "--d3")
+        {
+            divide_images = true;
+        }
+        else if (string(argv[i]) == "--output")
+        {
+            result_name = argv[i + 1];
+            i++;
+        }
+        else if (string(argv[i]) == "--mode")
+        {
+            if (string(argv[i + 1]) == "panorama")
+                mode = Stitcher::PANORAMA;
+            else if (string(argv[i + 1]) == "scans")
+                mode = Stitcher::SCANS;
+            else
+            {
+                cout << "Bad --mode flag value\n";
+                return EXIT_FAILURE;
+            }
+            i++;
+        }
+        else
+        {
+            Mat img = imread(samples::findFile(argv[i]));
+            if (img.empty())
+            {
+                cout << "Can't read image '" << argv[i] << "'\n";
+                return EXIT_FAILURE;
+            }
+
+            if (divide_images)
+            {
+                Rect rect(0, 0, img.cols / 2, img.rows);
+                imgs.push_back(img(rect).clone());
+                rect.x = img.cols / 3;
+                imgs.push_back(img(rect).clone());
+                rect.x = img.cols / 2;
+                imgs.push_back(img(rect).clone());
+            }
+            else
+                imgs.push_back(img);
+        }
+    }
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/stitching_detailed.cpp b/C++/opencv-4.7.0/samples/cpp/stitching_detailed.cpp
new file mode 100644
index 00000000..e5b63de9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/stitching_detailed.cpp
@@ -0,0 +1,937 @@
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include "opencv2/opencv_modules.hpp"
+#include <opencv2/core/utility.hpp>
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/stitching/detail/autocalib.hpp"
+#include "opencv2/stitching/detail/blenders.hpp"
+#include "opencv2/stitching/detail/timelapsers.hpp"
+#include "opencv2/stitching/detail/camera.hpp"
+#include "opencv2/stitching/detail/exposure_compensate.hpp"
+#include "opencv2/stitching/detail/matchers.hpp"
+#include "opencv2/stitching/detail/motion_estimators.hpp"
+#include "opencv2/stitching/detail/seam_finders.hpp"
+#include "opencv2/stitching/detail/warpers.hpp"
+#include "opencv2/stitching/warpers.hpp"
+
+#ifdef HAVE_OPENCV_XFEATURES2D
+#include "opencv2/xfeatures2d.hpp"
+#include "opencv2/xfeatures2d/nonfree.hpp"
+#endif
+
+#define ENABLE_LOG 1
+#define LOG(msg) std::cout << msg
+#define LOGLN(msg) std::cout << msg << std::endl
+
+using namespace std;
+using namespace cv;
+using namespace cv::detail;
+
+static void printUsage(char** argv)
+{
+    cout <<
+        "Rotation model images stitcher.\n\n"
+         << argv[0] << " img1 img2 [...imgN] [flags]\n\n"
+        "Flags:\n"
+        "  --preview\n"
+        "      Run stitching in the preview mode. Works faster than usual mode,\n"
+        "      but output image will have lower resolution.\n"
+        "  --try_cuda (yes|no)\n"
+        "      Try to use CUDA. The default value is 'no'. All default values\n"
+        "      are for CPU mode.\n"
+        "\nMotion Estimation Flags:\n"
+        "  --work_megapix <float>\n"
+        "      Resolution for image registration step. The default is 0.6 Mpx.\n"
+        "  --features (surf|orb|sift|akaze)\n"
+        "      Type of features used for images matching.\n"
+        "      The default is surf if available, orb otherwise.\n"
+        "  --matcher (homography|affine)\n"
+        "      Matcher used for pairwise image matching.\n"
+        "  --estimator (homography|affine)\n"
+        "      Type of estimator used for transformation estimation.\n"
+        "  --match_conf <float>\n"
+        "      Confidence for feature matching step. The default is 0.65 for surf and 0.3 for orb.\n"
+        "  --conf_thresh <float>\n"
+        "      Threshold for two images are from the same panorama confidence.\n"
+        "      The default is 1.0.\n"
+        "  --ba (no|reproj|ray|affine)\n"
+        "      Bundle adjustment cost function. The default is ray.\n"
+        "  --ba_refine_mask (mask)\n"
+        "      Set refinement mask for bundle adjustment. It looks like 'x_xxx',\n"
+        "      where 'x' means refine respective parameter and '_' means don't\n"
+        "      refine one, and has the following format:\n"
+        "      <fx><skew><ppx><aspect><ppy>. The default mask is 'xxxxx'. If bundle\n"
+        "      adjustment doesn't support estimation of selected parameter then\n"
+        "      the respective flag is ignored.\n"
+        "  --wave_correct (no|horiz|vert)\n"
+        "      Perform wave effect correction. The default is 'horiz'.\n"
+        "  --save_graph <file_name>\n"
+        "      Save matches graph represented in DOT language to <file_name> file.\n"
+        "      Labels description: Nm is number of matches, Ni is number of inliers,\n"
+        "      C is confidence.\n"
+        "\nCompositing Flags:\n"
+        "  --warp (affine|plane|cylindrical|spherical|fisheye|stereographic|compressedPlaneA2B1|compressedPlaneA1.5B1|compressedPlanePortraitA2B1|compressedPlanePortraitA1.5B1|paniniA2B1|paniniA1.5B1|paniniPortraitA2B1|paniniPortraitA1.5B1|mercator|transverseMercator)\n"
+        "      Warp surface type. The default is 'spherical'.\n"
+        "  --seam_megapix <float>\n"
+        "      Resolution for seam estimation step. The default is 0.1 Mpx.\n"
+        "  --seam (no|voronoi|gc_color|gc_colorgrad)\n"
+        "      Seam estimation method. The default is 'gc_color'.\n"
+        "  --compose_megapix <float>\n"
+        "      Resolution for compositing step. Use -1 for original resolution.\n"
+        "      The default is -1.\n"
+        "  --expos_comp (no|gain|gain_blocks|channels|channels_blocks)\n"
+        "      Exposure compensation method. The default is 'gain_blocks'.\n"
+        "  --expos_comp_nr_feeds <int>\n"
+        "      Number of exposure compensation feed. The default is 1.\n"
+        "  --expos_comp_nr_filtering <int>\n"
+        "      Number of filtering iterations of the exposure compensation gains.\n"
+        "      Only used when using a block exposure compensation method.\n"
+        "      The default is 2.\n"
+        "  --expos_comp_block_size <int>\n"
+        "      BLock size in pixels used by the exposure compensator.\n"
+        "      Only used when using a block exposure compensation method.\n"
+        "      The default is 32.\n"
+        "  --blend (no|feather|multiband)\n"
+        "      Blending method. The default is 'multiband'.\n"
+        "  --blend_strength <float>\n"
+        "      Blending strength from [0,100] range. The default is 5.\n"
+        "  --output <result_img>\n"
+        "      The default is 'result.jpg'.\n"
+        "  --timelapse (as_is|crop) \n"
+        "      Output warped images separately as frames of a time lapse movie, with 'fixed_' prepended to input file names.\n"
+        "  --rangewidth <int>\n"
+        "      uses range_width to limit number of images to match with.\n";
+}
+
+
+// Default command line args
+vector<String> img_names;
+bool preview = false;
+bool try_cuda = false;
+double work_megapix = 0.6;
+double seam_megapix = 0.1;
+double compose_megapix = -1;
+float conf_thresh = 1.f;
+#ifdef HAVE_OPENCV_XFEATURES2D
+string features_type = "surf";
+float match_conf = 0.65f;
+#else
+string features_type = "orb";
+float match_conf = 0.3f;
+#endif
+string matcher_type = "homography";
+string estimator_type = "homography";
+string ba_cost_func = "ray";
+string ba_refine_mask = "xxxxx";
+bool do_wave_correct = true;
+WaveCorrectKind wave_correct = detail::WAVE_CORRECT_HORIZ;
+bool save_graph = false;
+std::string save_graph_to;
+string warp_type = "spherical";
+int expos_comp_type = ExposureCompensator::GAIN_BLOCKS;
+int expos_comp_nr_feeds = 1;
+int expos_comp_nr_filtering = 2;
+int expos_comp_block_size = 32;
+string seam_find_type = "gc_color";
+int blend_type = Blender::MULTI_BAND;
+int timelapse_type = Timelapser::AS_IS;
+float blend_strength = 5;
+string result_name = "result.jpg";
+bool timelapse = false;
+int range_width = -1;
+
+
+static int parseCmdArgs(int argc, char** argv)
+{
+    if (argc == 1)
+    {
+        printUsage(argv);
+        return -1;
+    }
+    for (int i = 1; i < argc; ++i)
+    {
+        if (string(argv[i]) == "--help" || string(argv[i]) == "/?")
+        {
+            printUsage(argv);
+            return -1;
+        }
+        else if (string(argv[i]) == "--preview")
+        {
+            preview = true;
+        }
+        else if (string(argv[i]) == "--try_cuda")
+        {
+            if (string(argv[i + 1]) == "no")
+                try_cuda = false;
+            else if (string(argv[i + 1]) == "yes")
+                try_cuda = true;
+            else
+            {
+                cout << "Bad --try_cuda flag value\n";
+                return -1;
+            }
+            i++;
+        }
+        else if (string(argv[i]) == "--work_megapix")
+        {
+            work_megapix = atof(argv[i + 1]);
+            i++;
+        }
+        else if (string(argv[i]) == "--seam_megapix")
+        {
+            seam_megapix = atof(argv[i + 1]);
+            i++;
+        }
+        else if (string(argv[i]) == "--compose_megapix")
+        {
+            compose_megapix = atof(argv[i + 1]);
+            i++;
+        }
+        else if (string(argv[i]) == "--result")
+        {
+            result_name = argv[i + 1];
+            i++;
+        }
+        else if (string(argv[i]) == "--features")
+        {
+            features_type = argv[i + 1];
+            if (string(features_type) == "orb")
+                match_conf = 0.3f;
+            i++;
+        }
+        else if (string(argv[i]) == "--matcher")
+        {
+            if (string(argv[i + 1]) == "homography" || string(argv[i + 1]) == "affine")
+                matcher_type = argv[i + 1];
+            else
+            {
+                cout << "Bad --matcher flag value\n";
+                return -1;
+            }
+            i++;
+        }
+        else if (string(argv[i]) == "--estimator")
+        {
+            if (string(argv[i + 1]) == "homography" || string(argv[i + 1]) == "affine")
+                estimator_type = argv[i + 1];
+            else
+            {
+                cout << "Bad --estimator flag value\n";
+                return -1;
+            }
+            i++;
+        }
+        else if (string(argv[i]) == "--match_conf")
+        {
+            match_conf = static_cast<float>(atof(argv[i + 1]));
+            i++;
+        }
+        else if (string(argv[i]) == "--conf_thresh")
+        {
+            conf_thresh = static_cast<float>(atof(argv[i + 1]));
+            i++;
+        }
+        else if (string(argv[i]) == "--ba")
+        {
+            ba_cost_func = argv[i + 1];
+            i++;
+        }
+        else if (string(argv[i]) == "--ba_refine_mask")
+        {
+            ba_refine_mask = argv[i + 1];
+            if (ba_refine_mask.size() != 5)
+            {
+                cout << "Incorrect refinement mask length.\n";
+                return -1;
+            }
+            i++;
+        }
+        else if (string(argv[i]) == "--wave_correct")
+        {
+            if (string(argv[i + 1]) == "no")
+                do_wave_correct = false;
+            else if (string(argv[i + 1]) == "horiz")
+            {
+                do_wave_correct = true;
+                wave_correct = detail::WAVE_CORRECT_HORIZ;
+            }
+            else if (string(argv[i + 1]) == "vert")
+            {
+                do_wave_correct = true;
+                wave_correct = detail::WAVE_CORRECT_VERT;
+            }
+            else
+            {
+                cout << "Bad --wave_correct flag value\n";
+                return -1;
+            }
+            i++;
+        }
+        else if (string(argv[i]) == "--save_graph")
+        {
+            save_graph = true;
+            save_graph_to = argv[i + 1];
+            i++;
+        }
+        else if (string(argv[i]) == "--warp")
+        {
+            warp_type = string(argv[i + 1]);
+            i++;
+        }
+        else if (string(argv[i]) == "--expos_comp")
+        {
+            if (string(argv[i + 1]) == "no")
+                expos_comp_type = ExposureCompensator::NO;
+            else if (string(argv[i + 1]) == "gain")
+                expos_comp_type = ExposureCompensator::GAIN;
+            else if (string(argv[i + 1]) == "gain_blocks")
+                expos_comp_type = ExposureCompensator::GAIN_BLOCKS;
+            else if (string(argv[i + 1]) == "channels")
+                expos_comp_type = ExposureCompensator::CHANNELS;
+            else if (string(argv[i + 1]) == "channels_blocks")
+                expos_comp_type = ExposureCompensator::CHANNELS_BLOCKS;
+            else
+            {
+                cout << "Bad exposure compensation method\n";
+                return -1;
+            }
+            i++;
+        }
+        else if (string(argv[i]) == "--expos_comp_nr_feeds")
+        {
+            expos_comp_nr_feeds = atoi(argv[i + 1]);
+            i++;
+        }
+        else if (string(argv[i]) == "--expos_comp_nr_filtering")
+        {
+            expos_comp_nr_filtering = atoi(argv[i + 1]);
+            i++;
+        }
+        else if (string(argv[i]) == "--expos_comp_block_size")
+        {
+            expos_comp_block_size = atoi(argv[i + 1]);
+            i++;
+        }
+        else if (string(argv[i]) == "--seam")
+        {
+            if (string(argv[i + 1]) == "no" ||
+                string(argv[i + 1]) == "voronoi" ||
+                string(argv[i + 1]) == "gc_color" ||
+                string(argv[i + 1]) == "gc_colorgrad" ||
+                string(argv[i + 1]) == "dp_color" ||
+                string(argv[i + 1]) == "dp_colorgrad")
+                seam_find_type = argv[i + 1];
+            else
+            {
+                cout << "Bad seam finding method\n";
+                return -1;
+            }
+            i++;
+        }
+        else if (string(argv[i]) == "--blend")
+        {
+            if (string(argv[i + 1]) == "no")
+                blend_type = Blender::NO;
+            else if (string(argv[i + 1]) == "feather")
+                blend_type = Blender::FEATHER;
+            else if (string(argv[i + 1]) == "multiband")
+                blend_type = Blender::MULTI_BAND;
+            else
+            {
+                cout << "Bad blending method\n";
+                return -1;
+            }
+            i++;
+        }
+        else if (string(argv[i]) == "--timelapse")
+        {
+            timelapse = true;
+
+            if (string(argv[i + 1]) == "as_is")
+                timelapse_type = Timelapser::AS_IS;
+            else if (string(argv[i + 1]) == "crop")
+                timelapse_type = Timelapser::CROP;
+            else
+            {
+                cout << "Bad timelapse method\n";
+                return -1;
+            }
+            i++;
+        }
+        else if (string(argv[i]) == "--rangewidth")
+        {
+            range_width = atoi(argv[i + 1]);
+            i++;
+        }
+        else if (string(argv[i]) == "--blend_strength")
+        {
+            blend_strength = static_cast<float>(atof(argv[i + 1]));
+            i++;
+        }
+        else if (string(argv[i]) == "--output")
+        {
+            result_name = argv[i + 1];
+            i++;
+        }
+        else
+            img_names.push_back(argv[i]);
+    }
+    if (preview)
+    {
+        compose_megapix = 0.6;
+    }
+    return 0;
+}
+
+
+int main(int argc, char* argv[])
+{
+#if ENABLE_LOG
+    int64 app_start_time = getTickCount();
+#endif
+
+#if 0
+    cv::setBreakOnError(true);
+#endif
+
+    int retval = parseCmdArgs(argc, argv);
+    if (retval)
+        return retval;
+
+    // Check if have enough images
+    int num_images = static_cast<int>(img_names.size());
+    if (num_images < 2)
+    {
+        LOGLN("Need more images");
+        return -1;
+    }
+
+    double work_scale = 1, seam_scale = 1, compose_scale = 1;
+    bool is_work_scale_set = false, is_seam_scale_set = false, is_compose_scale_set = false;
+
+    LOGLN("Finding features...");
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+
+    Ptr<Feature2D> finder;
+    if (features_type == "orb")
+    {
+        finder = ORB::create();
+    }
+    else if (features_type == "akaze")
+    {
+        finder = AKAZE::create();
+    }
+#ifdef HAVE_OPENCV_XFEATURES2D
+    else if (features_type == "surf")
+    {
+        finder = xfeatures2d::SURF::create();
+    }
+#endif
+    else if (features_type == "sift")
+    {
+        finder = SIFT::create();
+    }
+    else
+    {
+        cout << "Unknown 2D features type: '" << features_type << "'.\n";
+        return -1;
+    }
+
+    Mat full_img, img;
+    vector<ImageFeatures> features(num_images);
+    vector<Mat> images(num_images);
+    vector<Size> full_img_sizes(num_images);
+    double seam_work_aspect = 1;
+
+    for (int i = 0; i < num_images; ++i)
+    {
+        full_img = imread(samples::findFile(img_names[i]));
+        full_img_sizes[i] = full_img.size();
+
+        if (full_img.empty())
+        {
+            LOGLN("Can't open image " << img_names[i]);
+            return -1;
+        }
+        if (work_megapix < 0)
+        {
+            img = full_img;
+            work_scale = 1;
+            is_work_scale_set = true;
+        }
+        else
+        {
+            if (!is_work_scale_set)
+            {
+                work_scale = min(1.0, sqrt(work_megapix * 1e6 / full_img.size().area()));
+                is_work_scale_set = true;
+            }
+            resize(full_img, img, Size(), work_scale, work_scale, INTER_LINEAR_EXACT);
+        }
+        if (!is_seam_scale_set)
+        {
+            seam_scale = min(1.0, sqrt(seam_megapix * 1e6 / full_img.size().area()));
+            seam_work_aspect = seam_scale / work_scale;
+            is_seam_scale_set = true;
+        }
+
+        computeImageFeatures(finder, img, features[i]);
+        features[i].img_idx = i;
+        LOGLN("Features in image #" << i+1 << ": " << features[i].keypoints.size());
+
+        resize(full_img, img, Size(), seam_scale, seam_scale, INTER_LINEAR_EXACT);
+        images[i] = img.clone();
+    }
+
+    full_img.release();
+    img.release();
+
+    LOGLN("Finding features, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+
+    LOG("Pairwise matching");
+#if ENABLE_LOG
+    t = getTickCount();
+#endif
+    vector<MatchesInfo> pairwise_matches;
+    Ptr<FeaturesMatcher> matcher;
+    if (matcher_type == "affine")
+        matcher = makePtr<AffineBestOf2NearestMatcher>(false, try_cuda, match_conf);
+    else if (range_width==-1)
+        matcher = makePtr<BestOf2NearestMatcher>(try_cuda, match_conf);
+    else
+        matcher = makePtr<BestOf2NearestRangeMatcher>(range_width, try_cuda, match_conf);
+
+    (*matcher)(features, pairwise_matches);
+    matcher->collectGarbage();
+
+    LOGLN("Pairwise matching, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+
+    // Check if we should save matches graph
+    if (save_graph)
+    {
+        LOGLN("Saving matches graph...");
+        ofstream f(save_graph_to.c_str());
+        f << matchesGraphAsString(img_names, pairwise_matches, conf_thresh);
+    }
+
+    // Leave only images we are sure are from the same panorama
+    vector<int> indices = leaveBiggestComponent(features, pairwise_matches, conf_thresh);
+    vector<Mat> img_subset;
+    vector<String> img_names_subset;
+    vector<Size> full_img_sizes_subset;
+    for (size_t i = 0; i < indices.size(); ++i)
+    {
+        img_names_subset.push_back(img_names[indices[i]]);
+        img_subset.push_back(images[indices[i]]);
+        full_img_sizes_subset.push_back(full_img_sizes[indices[i]]);
+    }
+
+    images = img_subset;
+    img_names = img_names_subset;
+    full_img_sizes = full_img_sizes_subset;
+
+    // Check if we still have enough images
+    num_images = static_cast<int>(img_names.size());
+    if (num_images < 2)
+    {
+        LOGLN("Need more images");
+        return -1;
+    }
+
+    Ptr<Estimator> estimator;
+    if (estimator_type == "affine")
+        estimator = makePtr<AffineBasedEstimator>();
+    else
+        estimator = makePtr<HomographyBasedEstimator>();
+
+    vector<CameraParams> cameras;
+    if (!(*estimator)(features, pairwise_matches, cameras))
+    {
+        cout << "Homography estimation failed.\n";
+        return -1;
+    }
+
+    for (size_t i = 0; i < cameras.size(); ++i)
+    {
+        Mat R;
+        cameras[i].R.convertTo(R, CV_32F);
+        cameras[i].R = R;
+        LOGLN("Initial camera intrinsics #" << indices[i]+1 << ":\nK:\n" << cameras[i].K() << "\nR:\n" << cameras[i].R);
+    }
+
+    Ptr<detail::BundleAdjusterBase> adjuster;
+    if (ba_cost_func == "reproj") adjuster = makePtr<detail::BundleAdjusterReproj>();
+    else if (ba_cost_func == "ray") adjuster = makePtr<detail::BundleAdjusterRay>();
+    else if (ba_cost_func == "affine") adjuster = makePtr<detail::BundleAdjusterAffinePartial>();
+    else if (ba_cost_func == "no") adjuster = makePtr<NoBundleAdjuster>();
+    else
+    {
+        cout << "Unknown bundle adjustment cost function: '" << ba_cost_func << "'.\n";
+        return -1;
+    }
+    adjuster->setConfThresh(conf_thresh);
+    Mat_<uchar> refine_mask = Mat::zeros(3, 3, CV_8U);
+    if (ba_refine_mask[0] == 'x') refine_mask(0,0) = 1;
+    if (ba_refine_mask[1] == 'x') refine_mask(0,1) = 1;
+    if (ba_refine_mask[2] == 'x') refine_mask(0,2) = 1;
+    if (ba_refine_mask[3] == 'x') refine_mask(1,1) = 1;
+    if (ba_refine_mask[4] == 'x') refine_mask(1,2) = 1;
+    adjuster->setRefinementMask(refine_mask);
+    if (!(*adjuster)(features, pairwise_matches, cameras))
+    {
+        cout << "Camera parameters adjusting failed.\n";
+        return -1;
+    }
+
+    // Find median focal length
+
+    vector<double> focals;
+    for (size_t i = 0; i < cameras.size(); ++i)
+    {
+        LOGLN("Camera #" << indices[i]+1 << ":\nK:\n" << cameras[i].K() << "\nR:\n" << cameras[i].R);
+        focals.push_back(cameras[i].focal);
+    }
+
+    sort(focals.begin(), focals.end());
+    float warped_image_scale;
+    if (focals.size() % 2 == 1)
+        warped_image_scale = static_cast<float>(focals[focals.size() / 2]);
+    else
+        warped_image_scale = static_cast<float>(focals[focals.size() / 2 - 1] + focals[focals.size() / 2]) * 0.5f;
+
+    if (do_wave_correct)
+    {
+        vector<Mat> rmats;
+        for (size_t i = 0; i < cameras.size(); ++i)
+            rmats.push_back(cameras[i].R.clone());
+        waveCorrect(rmats, wave_correct);
+        for (size_t i = 0; i < cameras.size(); ++i)
+            cameras[i].R = rmats[i];
+    }
+
+    LOGLN("Warping images (auxiliary)... ");
+#if ENABLE_LOG
+    t = getTickCount();
+#endif
+
+    vector<Point> corners(num_images);
+    vector<UMat> masks_warped(num_images);
+    vector<UMat> images_warped(num_images);
+    vector<Size> sizes(num_images);
+    vector<UMat> masks(num_images);
+
+    // Prepare images masks
+    for (int i = 0; i < num_images; ++i)
+    {
+        masks[i].create(images[i].size(), CV_8U);
+        masks[i].setTo(Scalar::all(255));
+    }
+
+    // Warp images and their masks
+
+    Ptr<WarperCreator> warper_creator;
+#ifdef HAVE_OPENCV_CUDAWARPING
+    if (try_cuda && cuda::getCudaEnabledDeviceCount() > 0)
+    {
+        if (warp_type == "plane")
+            warper_creator = makePtr<cv::PlaneWarperGpu>();
+        else if (warp_type == "cylindrical")
+            warper_creator = makePtr<cv::CylindricalWarperGpu>();
+        else if (warp_type == "spherical")
+            warper_creator = makePtr<cv::SphericalWarperGpu>();
+    }
+    else
+#endif
+    {
+        if (warp_type == "plane")
+            warper_creator = makePtr<cv::PlaneWarper>();
+        else if (warp_type == "affine")
+            warper_creator = makePtr<cv::AffineWarper>();
+        else if (warp_type == "cylindrical")
+            warper_creator = makePtr<cv::CylindricalWarper>();
+        else if (warp_type == "spherical")
+            warper_creator = makePtr<cv::SphericalWarper>();
+        else if (warp_type == "fisheye")
+            warper_creator = makePtr<cv::FisheyeWarper>();
+        else if (warp_type == "stereographic")
+            warper_creator = makePtr<cv::StereographicWarper>();
+        else if (warp_type == "compressedPlaneA2B1")
+            warper_creator = makePtr<cv::CompressedRectilinearWarper>(2.0f, 1.0f);
+        else if (warp_type == "compressedPlaneA1.5B1")
+            warper_creator = makePtr<cv::CompressedRectilinearWarper>(1.5f, 1.0f);
+        else if (warp_type == "compressedPlanePortraitA2B1")
+            warper_creator = makePtr<cv::CompressedRectilinearPortraitWarper>(2.0f, 1.0f);
+        else if (warp_type == "compressedPlanePortraitA1.5B1")
+            warper_creator = makePtr<cv::CompressedRectilinearPortraitWarper>(1.5f, 1.0f);
+        else if (warp_type == "paniniA2B1")
+            warper_creator = makePtr<cv::PaniniWarper>(2.0f, 1.0f);
+        else if (warp_type == "paniniA1.5B1")
+            warper_creator = makePtr<cv::PaniniWarper>(1.5f, 1.0f);
+        else if (warp_type == "paniniPortraitA2B1")
+            warper_creator = makePtr<cv::PaniniPortraitWarper>(2.0f, 1.0f);
+        else if (warp_type == "paniniPortraitA1.5B1")
+            warper_creator = makePtr<cv::PaniniPortraitWarper>(1.5f, 1.0f);
+        else if (warp_type == "mercator")
+            warper_creator = makePtr<cv::MercatorWarper>();
+        else if (warp_type == "transverseMercator")
+            warper_creator = makePtr<cv::TransverseMercatorWarper>();
+    }
+
+    if (!warper_creator)
+    {
+        cout << "Can't create the following warper '" << warp_type << "'\n";
+        return 1;
+    }
+
+    Ptr<RotationWarper> warper = warper_creator->create(static_cast<float>(warped_image_scale * seam_work_aspect));
+
+    for (int i = 0; i < num_images; ++i)
+    {
+        Mat_<float> K;
+        cameras[i].K().convertTo(K, CV_32F);
+        float swa = (float)seam_work_aspect;
+        K(0,0) *= swa; K(0,2) *= swa;
+        K(1,1) *= swa; K(1,2) *= swa;
+
+        corners[i] = warper->warp(images[i], K, cameras[i].R, INTER_LINEAR, BORDER_REFLECT, images_warped[i]);
+        sizes[i] = images_warped[i].size();
+
+        warper->warp(masks[i], K, cameras[i].R, INTER_NEAREST, BORDER_CONSTANT, masks_warped[i]);
+    }
+
+    vector<UMat> images_warped_f(num_images);
+    for (int i = 0; i < num_images; ++i)
+        images_warped[i].convertTo(images_warped_f[i], CV_32F);
+
+    LOGLN("Warping images, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+
+    LOGLN("Compensating exposure...");
+#if ENABLE_LOG
+    t = getTickCount();
+#endif
+
+    Ptr<ExposureCompensator> compensator = ExposureCompensator::createDefault(expos_comp_type);
+    if (dynamic_cast<GainCompensator*>(compensator.get()))
+    {
+        GainCompensator* gcompensator = dynamic_cast<GainCompensator*>(compensator.get());
+        gcompensator->setNrFeeds(expos_comp_nr_feeds);
+    }
+
+    if (dynamic_cast<ChannelsCompensator*>(compensator.get()))
+    {
+        ChannelsCompensator* ccompensator = dynamic_cast<ChannelsCompensator*>(compensator.get());
+        ccompensator->setNrFeeds(expos_comp_nr_feeds);
+    }
+
+    if (dynamic_cast<BlocksCompensator*>(compensator.get()))
+    {
+        BlocksCompensator* bcompensator = dynamic_cast<BlocksCompensator*>(compensator.get());
+        bcompensator->setNrFeeds(expos_comp_nr_feeds);
+        bcompensator->setNrGainsFilteringIterations(expos_comp_nr_filtering);
+        bcompensator->setBlockSize(expos_comp_block_size, expos_comp_block_size);
+    }
+
+    compensator->feed(corners, images_warped, masks_warped);
+
+    LOGLN("Compensating exposure, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+
+    LOGLN("Finding seams...");
+#if ENABLE_LOG
+    t = getTickCount();
+#endif
+
+    Ptr<SeamFinder> seam_finder;
+    if (seam_find_type == "no")
+        seam_finder = makePtr<detail::NoSeamFinder>();
+    else if (seam_find_type == "voronoi")
+        seam_finder = makePtr<detail::VoronoiSeamFinder>();
+    else if (seam_find_type == "gc_color")
+    {
+#ifdef HAVE_OPENCV_CUDALEGACY
+        if (try_cuda && cuda::getCudaEnabledDeviceCount() > 0)
+            seam_finder = makePtr<detail::GraphCutSeamFinderGpu>(GraphCutSeamFinderBase::COST_COLOR);
+        else
+#endif
+            seam_finder = makePtr<detail::GraphCutSeamFinder>(GraphCutSeamFinderBase::COST_COLOR);
+    }
+    else if (seam_find_type == "gc_colorgrad")
+    {
+#ifdef HAVE_OPENCV_CUDALEGACY
+        if (try_cuda && cuda::getCudaEnabledDeviceCount() > 0)
+            seam_finder = makePtr<detail::GraphCutSeamFinderGpu>(GraphCutSeamFinderBase::COST_COLOR_GRAD);
+        else
+#endif
+            seam_finder = makePtr<detail::GraphCutSeamFinder>(GraphCutSeamFinderBase::COST_COLOR_GRAD);
+    }
+    else if (seam_find_type == "dp_color")
+        seam_finder = makePtr<detail::DpSeamFinder>(DpSeamFinder::COLOR);
+    else if (seam_find_type == "dp_colorgrad")
+        seam_finder = makePtr<detail::DpSeamFinder>(DpSeamFinder::COLOR_GRAD);
+    if (!seam_finder)
+    {
+        cout << "Can't create the following seam finder '" << seam_find_type << "'\n";
+        return 1;
+    }
+
+    seam_finder->find(images_warped_f, corners, masks_warped);
+
+    LOGLN("Finding seams, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+
+    // Release unused memory
+    images.clear();
+    images_warped.clear();
+    images_warped_f.clear();
+    masks.clear();
+
+    LOGLN("Compositing...");
+#if ENABLE_LOG
+    t = getTickCount();
+#endif
+
+    Mat img_warped, img_warped_s;
+    Mat dilated_mask, seam_mask, mask, mask_warped;
+    Ptr<Blender> blender;
+    Ptr<Timelapser> timelapser;
+    //double compose_seam_aspect = 1;
+    double compose_work_aspect = 1;
+
+    for (int img_idx = 0; img_idx < num_images; ++img_idx)
+    {
+        LOGLN("Compositing image #" << indices[img_idx]+1);
+
+        // Read image and resize it if necessary
+        full_img = imread(samples::findFile(img_names[img_idx]));
+        if (!is_compose_scale_set)
+        {
+            if (compose_megapix > 0)
+                compose_scale = min(1.0, sqrt(compose_megapix * 1e6 / full_img.size().area()));
+            is_compose_scale_set = true;
+
+            // Compute relative scales
+            //compose_seam_aspect = compose_scale / seam_scale;
+            compose_work_aspect = compose_scale / work_scale;
+
+            // Update warped image scale
+            warped_image_scale *= static_cast<float>(compose_work_aspect);
+            warper = warper_creator->create(warped_image_scale);
+
+            // Update corners and sizes
+            for (int i = 0; i < num_images; ++i)
+            {
+                // Update intrinsics
+                cameras[i].focal *= compose_work_aspect;
+                cameras[i].ppx *= compose_work_aspect;
+                cameras[i].ppy *= compose_work_aspect;
+
+                // Update corner and size
+                Size sz = full_img_sizes[i];
+                if (std::abs(compose_scale - 1) > 1e-1)
+                {
+                    sz.width = cvRound(full_img_sizes[i].width * compose_scale);
+                    sz.height = cvRound(full_img_sizes[i].height * compose_scale);
+                }
+
+                Mat K;
+                cameras[i].K().convertTo(K, CV_32F);
+                Rect roi = warper->warpRoi(sz, K, cameras[i].R);
+                corners[i] = roi.tl();
+                sizes[i] = roi.size();
+            }
+        }
+        if (abs(compose_scale - 1) > 1e-1)
+            resize(full_img, img, Size(), compose_scale, compose_scale, INTER_LINEAR_EXACT);
+        else
+            img = full_img;
+        full_img.release();
+        Size img_size = img.size();
+
+        Mat K;
+        cameras[img_idx].K().convertTo(K, CV_32F);
+
+        // Warp the current image
+        warper->warp(img, K, cameras[img_idx].R, INTER_LINEAR, BORDER_REFLECT, img_warped);
+
+        // Warp the current image mask
+        mask.create(img_size, CV_8U);
+        mask.setTo(Scalar::all(255));
+        warper->warp(mask, K, cameras[img_idx].R, INTER_NEAREST, BORDER_CONSTANT, mask_warped);
+
+        // Compensate exposure
+        compensator->apply(img_idx, corners[img_idx], img_warped, mask_warped);
+
+        img_warped.convertTo(img_warped_s, CV_16S);
+        img_warped.release();
+        img.release();
+        mask.release();
+
+        dilate(masks_warped[img_idx], dilated_mask, Mat());
+        resize(dilated_mask, seam_mask, mask_warped.size(), 0, 0, INTER_LINEAR_EXACT);
+        mask_warped = seam_mask & mask_warped;
+
+        if (!blender && !timelapse)
+        {
+            blender = Blender::createDefault(blend_type, try_cuda);
+            Size dst_sz = resultRoi(corners, sizes).size();
+            float blend_width = sqrt(static_cast<float>(dst_sz.area())) * blend_strength / 100.f;
+            if (blend_width < 1.f)
+                blender = Blender::createDefault(Blender::NO, try_cuda);
+            else if (blend_type == Blender::MULTI_BAND)
+            {
+                MultiBandBlender* mb = dynamic_cast<MultiBandBlender*>(blender.get());
+                mb->setNumBands(static_cast<int>(ceil(log(blend_width)/log(2.)) - 1.));
+                LOGLN("Multi-band blender, number of bands: " << mb->numBands());
+            }
+            else if (blend_type == Blender::FEATHER)
+            {
+                FeatherBlender* fb = dynamic_cast<FeatherBlender*>(blender.get());
+                fb->setSharpness(1.f/blend_width);
+                LOGLN("Feather blender, sharpness: " << fb->sharpness());
+            }
+            blender->prepare(corners, sizes);
+        }
+        else if (!timelapser && timelapse)
+        {
+            timelapser = Timelapser::createDefault(timelapse_type);
+            timelapser->initialize(corners, sizes);
+        }
+
+        // Blend the current image
+        if (timelapse)
+        {
+            timelapser->process(img_warped_s, Mat::ones(img_warped_s.size(), CV_8UC1), corners[img_idx]);
+            String fixedFileName;
+            size_t pos_s = String(img_names[img_idx]).find_last_of("/\\");
+            if (pos_s == String::npos)
+            {
+                fixedFileName = "fixed_" + img_names[img_idx];
+            }
+            else
+            {
+                fixedFileName = "fixed_" + String(img_names[img_idx]).substr(pos_s + 1, String(img_names[img_idx]).length() - pos_s);
+            }
+            imwrite(fixedFileName, timelapser->getDst());
+        }
+        else
+        {
+            blender->feed(img_warped_s, mask_warped, corners[img_idx]);
+        }
+    }
+
+    if (!timelapse)
+    {
+        Mat result, result_mask;
+        blender->blend(result, result_mask);
+
+        LOGLN("Compositing, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+
+        imwrite(result_name, result);
+    }
+
+    LOGLN("Finished, total time: " << ((getTickCount() - app_start_time) / getTickFrequency()) << " sec");
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/text_skewness_correction.cpp b/C++/opencv-4.7.0/samples/cpp/text_skewness_correction.cpp
new file mode 100644
index 00000000..15df92e6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/text_skewness_correction.cpp
@@ -0,0 +1,74 @@
+/*
+This tutorial demonstrates how to correct the skewness in a text.
+The program takes as input a skewed source image and shows non skewed text.
+
+*/
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+
+#include <iostream>
+#include <iomanip>
+#include <string>
+
+using namespace cv;
+using namespace std;
+
+
+int main( int argc, char** argv )
+{
+    CommandLineParser parser(argc, argv, "{@input | imageTextR.png | input image}");
+
+    // Load image from the disk
+    Mat image = imread( samples::findFile( parser.get<String>("@input") ), IMREAD_COLOR);
+    if (image.empty())
+    {
+        cout << "Cannot load the image " + parser.get<String>("@input") << endl;
+        return -1;
+    }
+
+    Mat gray;
+    cvtColor(image, gray, COLOR_BGR2GRAY);
+
+    //Threshold the image, setting all foreground pixels to 255 and all background pixels to 0
+    Mat thresh;
+    threshold(gray, thresh, 0, 255, THRESH_BINARY_INV | THRESH_OTSU);
+
+    // Applying erode filter to remove random noise
+    int erosion_size = 1;
+    Mat element = getStructuringElement( MORPH_RECT, Size(2*erosion_size+1, 2*erosion_size+1), Point(erosion_size, erosion_size) );
+    erode(thresh, thresh, element);
+
+    cv::Mat coords;
+    findNonZero(thresh, coords);
+
+    RotatedRect box = minAreaRect(coords);
+    float angle = box.angle;
+
+    // The cv::minAreaRect function returns values in the range [-90, 0)
+    // if the angle is less than -45 we need to add 90 to it
+    if (angle < -45.0f)
+    {
+        angle = (90.0f + angle);
+    }
+
+    //Obtaining the rotation matrix
+    Point2f center((image.cols) / 2.0f, (image.rows) / 2.0f);
+    Mat M = getRotationMatrix2D(center, angle, 1.0f);
+    Mat rotated;
+
+    // Rotating the image by required angle
+    stringstream angle_to_str;
+    angle_to_str << fixed << setprecision(2) << angle;
+    warpAffine(image, rotated, M, image.size(), INTER_CUBIC, BORDER_REPLICATE);
+    putText(rotated, "Angle " + angle_to_str.str() + " degrees", Point(10, 30), FONT_HERSHEY_SIMPLEX, 0.7, Scalar(0, 0, 255), 2);
+    cout << "[INFO] angle: " << angle_to_str.str() << endl;
+
+    //Show the image
+    imshow("Input", image);
+    imshow("Rotated", rotated);
+    waitKey(0);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/train_HOG.cpp b/C++/opencv-4.7.0/samples/cpp/train_HOG.cpp
new file mode 100644
index 00000000..4a160fe4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/train_HOG.cpp
@@ -0,0 +1,392 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/ml.hpp"
+#include "opencv2/objdetect.hpp"
+#include "opencv2/videoio.hpp"
+#include <iostream>
+#include <time.h>
+
+using namespace cv;
+using namespace cv::ml;
+using namespace std;
+
+vector< float > get_svm_detector( const Ptr< SVM >& svm );
+void convert_to_ml( const std::vector< Mat > & train_samples, Mat& trainData );
+void load_images( const String & dirname, vector< Mat > & img_lst, bool showImages );
+void sample_neg( const vector< Mat > & full_neg_lst, vector< Mat > & neg_lst, const Size & size );
+void computeHOGs( const Size wsize, const vector< Mat > & img_lst, vector< Mat > & gradient_lst, bool use_flip );
+void test_trained_detector( String obj_det_filename, String test_dir, String videofilename );
+
+vector< float > get_svm_detector( const Ptr< SVM >& svm )
+{
+    // get the support vectors
+    Mat sv = svm->getSupportVectors();
+    const int sv_total = sv.rows;
+    // get the decision function
+    Mat alpha, svidx;
+    double rho = svm->getDecisionFunction( 0, alpha, svidx );
+
+    CV_Assert( alpha.total() == 1 && svidx.total() == 1 && sv_total == 1 );
+    CV_Assert( (alpha.type() == CV_64F && alpha.at<double>(0) == 1.) ||
+               (alpha.type() == CV_32F && alpha.at<float>(0) == 1.f) );
+    CV_Assert( sv.type() == CV_32F );
+
+    vector< float > hog_detector( sv.cols + 1 );
+    memcpy( &hog_detector[0], sv.ptr(), sv.cols*sizeof( hog_detector[0] ) );
+    hog_detector[sv.cols] = (float)-rho;
+    return hog_detector;
+}
+
+/*
+* Convert training/testing set to be used by OpenCV Machine Learning algorithms.
+* TrainData is a matrix of size (#samples x max(#cols,#rows) per samples), in 32FC1.
+* Transposition of samples are made if needed.
+*/
+void convert_to_ml( const vector< Mat > & train_samples, Mat& trainData )
+{
+    //--Convert data
+    const int rows = (int)train_samples.size();
+    const int cols = (int)std::max( train_samples[0].cols, train_samples[0].rows );
+    Mat tmp( 1, cols, CV_32FC1 ); //< used for transposition if needed
+    trainData = Mat( rows, cols, CV_32FC1 );
+
+    for( size_t i = 0 ; i < train_samples.size(); ++i )
+    {
+        CV_Assert( train_samples[i].cols == 1 || train_samples[i].rows == 1 );
+
+        if( train_samples[i].cols == 1 )
+        {
+            transpose( train_samples[i], tmp );
+            tmp.copyTo( trainData.row( (int)i ) );
+        }
+        else if( train_samples[i].rows == 1 )
+        {
+            train_samples[i].copyTo( trainData.row( (int)i ) );
+        }
+    }
+}
+
+void load_images( const String & dirname, vector< Mat > & img_lst, bool showImages = false )
+{
+    vector< String > files;
+    glob( dirname, files );
+
+    for ( size_t i = 0; i < files.size(); ++i )
+    {
+        Mat img = imread( files[i] ); // load the image
+        if ( img.empty() )
+        {
+            cout << files[i] << " is invalid!" << endl; // invalid image, skip it.
+            continue;
+        }
+
+        if ( showImages )
+        {
+            imshow( "image", img );
+            waitKey( 1 );
+        }
+        img_lst.push_back( img );
+    }
+}
+
+void sample_neg( const vector< Mat > & full_neg_lst, vector< Mat > & neg_lst, const Size & size )
+{
+    Rect box;
+    box.width = size.width;
+    box.height = size.height;
+
+    srand( (unsigned int)time( NULL ) );
+
+    for ( size_t i = 0; i < full_neg_lst.size(); i++ )
+        if ( full_neg_lst[i].cols > box.width && full_neg_lst[i].rows > box.height )
+        {
+            box.x = rand() % ( full_neg_lst[i].cols - box.width );
+            box.y = rand() % ( full_neg_lst[i].rows - box.height );
+            Mat roi = full_neg_lst[i]( box );
+            neg_lst.push_back( roi.clone() );
+        }
+}
+
+void computeHOGs( const Size wsize, const vector< Mat > & img_lst, vector< Mat > & gradient_lst, bool use_flip )
+{
+    HOGDescriptor hog;
+    hog.winSize = wsize;
+    Mat gray;
+    vector< float > descriptors;
+
+    for( size_t i = 0 ; i < img_lst.size(); i++ )
+    {
+        if ( img_lst[i].cols >= wsize.width && img_lst[i].rows >= wsize.height )
+        {
+            Rect r = Rect(( img_lst[i].cols - wsize.width ) / 2,
+                          ( img_lst[i].rows - wsize.height ) / 2,
+                          wsize.width,
+                          wsize.height);
+            cvtColor( img_lst[i](r), gray, COLOR_BGR2GRAY );
+            hog.compute( gray, descriptors, Size( 8, 8 ), Size( 0, 0 ) );
+            gradient_lst.push_back( Mat( descriptors ).clone() );
+            if ( use_flip )
+            {
+                flip( gray, gray, 1 );
+                hog.compute( gray, descriptors, Size( 8, 8 ), Size( 0, 0 ) );
+                gradient_lst.push_back( Mat( descriptors ).clone() );
+            }
+        }
+    }
+}
+
+void test_trained_detector( String obj_det_filename, String test_dir, String videofilename )
+{
+    cout << "Testing trained detector..." << endl;
+    HOGDescriptor hog;
+    hog.load( obj_det_filename );
+
+    vector< String > files;
+    glob( test_dir, files );
+
+    int delay = 0;
+    VideoCapture cap;
+
+    if ( videofilename != "" )
+    {
+        if ( videofilename.size() == 1 && isdigit( videofilename[0] ) )
+            cap.open( videofilename[0] - '0' );
+        else
+            cap.open( videofilename );
+    }
+
+    obj_det_filename = "testing " + obj_det_filename;
+    namedWindow( obj_det_filename, WINDOW_NORMAL );
+
+    for( size_t i=0;; i++ )
+    {
+        Mat img;
+
+        if ( cap.isOpened() )
+        {
+            cap >> img;
+            delay = 1;
+        }
+        else if( i < files.size() )
+        {
+            img = imread( files[i] );
+        }
+
+        if ( img.empty() )
+        {
+            return;
+        }
+
+        vector< Rect > detections;
+        vector< double > foundWeights;
+
+        hog.detectMultiScale( img, detections, foundWeights );
+        for ( size_t j = 0; j < detections.size(); j++ )
+        {
+            Scalar color = Scalar( 0, foundWeights[j] * foundWeights[j] * 200, 0 );
+            rectangle( img, detections[j], color, img.cols / 400 + 1 );
+        }
+
+        imshow( obj_det_filename, img );
+
+        if( waitKey( delay ) == 27 )
+        {
+            return;
+        }
+    }
+}
+
+int main( int argc, char** argv )
+{
+    const char* keys =
+    {
+        "{help h|     | show help message}"
+        "{pd    |     | path of directory contains positive images}"
+        "{nd    |     | path of directory contains negative images}"
+        "{td    |     | path of directory contains test images}"
+        "{tv    |     | test video file name}"
+        "{dw    |     | width of the detector}"
+        "{dh    |     | height of the detector}"
+        "{f     |false| indicates if the program will generate and use mirrored samples or not}"
+        "{d     |false| train twice}"
+        "{t     |false| test a trained detector}"
+        "{v     |false| visualize training steps}"
+        "{fn    |my_detector.yml| file name of trained SVM}"
+    };
+
+    CommandLineParser parser( argc, argv, keys );
+
+    if ( parser.has( "help" ) )
+    {
+        parser.printMessage();
+        exit( 0 );
+    }
+
+    String pos_dir = parser.get< String >( "pd" );
+    String neg_dir = parser.get< String >( "nd" );
+    String test_dir = parser.get< String >( "td" );
+    String obj_det_filename = parser.get< String >( "fn" );
+    String videofilename = parser.get< String >( "tv" );
+    int detector_width = parser.get< int >( "dw" );
+    int detector_height = parser.get< int >( "dh" );
+    bool test_detector = parser.get< bool >( "t" );
+    bool train_twice = parser.get< bool >( "d" );
+    bool visualization = parser.get< bool >( "v" );
+    bool flip_samples = parser.get< bool >( "f" );
+
+    if ( test_detector )
+    {
+        test_trained_detector( obj_det_filename, test_dir, videofilename );
+        exit( 0 );
+    }
+
+    if( pos_dir.empty() || neg_dir.empty() )
+    {
+        parser.printMessage();
+        cout << "Wrong number of parameters.\n\n"
+             << "Example command line:\n" << argv[0] << " -dw=64 -dh=128 -pd=/INRIAPerson/96X160H96/Train/pos -nd=/INRIAPerson/neg -td=/INRIAPerson/Test/pos -fn=HOGpedestrian64x128.xml -d\n"
+             << "\nExample command line for testing trained detector:\n" << argv[0] << " -t -fn=HOGpedestrian64x128.xml -td=/INRIAPerson/Test/pos";
+        exit( 1 );
+    }
+
+    vector< Mat > pos_lst, full_neg_lst, neg_lst, gradient_lst;
+    vector< int > labels;
+
+    clog << "Positive images are being loaded..." ;
+    load_images( pos_dir, pos_lst, visualization );
+    if ( pos_lst.size() > 0 )
+    {
+        clog << "...[done] " << pos_lst.size() << " files." << endl;
+    }
+    else
+    {
+        clog << "no image in " << pos_dir <<endl;
+        return 1;
+    }
+
+    Size pos_image_size = pos_lst[0].size();
+
+    if ( detector_width && detector_height )
+    {
+        pos_image_size = Size( detector_width, detector_height );
+    }
+    else
+    {
+        for ( size_t i = 0; i < pos_lst.size(); ++i )
+        {
+            if( pos_lst[i].size() != pos_image_size )
+            {
+                cout << "All positive images should be same size!" << endl;
+                exit( 1 );
+            }
+        }
+        pos_image_size = pos_image_size / 8 * 8;
+    }
+
+    clog << "Negative images are being loaded...";
+    load_images( neg_dir, full_neg_lst, visualization );
+    clog << "...[done] " << full_neg_lst.size() << " files." << endl;
+
+    clog << "Negative images are being processed...";
+    sample_neg( full_neg_lst, neg_lst, pos_image_size );
+    clog << "...[done] " << neg_lst.size() << " files." << endl;
+
+    clog << "Histogram of Gradients are being calculated for positive images...";
+    computeHOGs( pos_image_size, pos_lst, gradient_lst, flip_samples );
+    size_t positive_count = gradient_lst.size();
+    labels.assign( positive_count, +1 );
+    clog << "...[done] ( positive images count : " << positive_count << " )" << endl;
+
+    clog << "Histogram of Gradients are being calculated for negative images...";
+    computeHOGs( pos_image_size, neg_lst, gradient_lst, flip_samples );
+    size_t negative_count = gradient_lst.size() - positive_count;
+    labels.insert( labels.end(), negative_count, -1 );
+    CV_Assert( positive_count < labels.size() );
+    clog << "...[done] ( negative images count : " << negative_count << " )" << endl;
+
+    Mat train_data;
+    convert_to_ml( gradient_lst, train_data );
+
+    clog << "Training SVM...";
+    Ptr< SVM > svm = SVM::create();
+    /* Default values to train SVM */
+    svm->setCoef0( 0.0 );
+    svm->setDegree( 3 );
+    svm->setTermCriteria( TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 1000, 1e-3 ) );
+    svm->setGamma( 0 );
+    svm->setKernel( SVM::LINEAR );
+    svm->setNu( 0.5 );
+    svm->setP( 0.1 ); // for EPSILON_SVR, epsilon in loss function?
+    svm->setC( 0.01 ); // From paper, soft classifier
+    svm->setType( SVM::EPS_SVR ); // C_SVC; // EPSILON_SVR; // may be also NU_SVR; // do regression task
+    svm->train( train_data, ROW_SAMPLE, labels );
+    clog << "...[done]" << endl;
+
+    if ( train_twice )
+    {
+        clog << "Testing trained detector on negative images. This might take a few minutes...";
+        HOGDescriptor my_hog;
+        my_hog.winSize = pos_image_size;
+
+        // Set the trained svm to my_hog
+        my_hog.setSVMDetector( get_svm_detector( svm ) );
+
+        vector< Rect > detections;
+        vector< double > foundWeights;
+
+        for ( size_t i = 0; i < full_neg_lst.size(); i++ )
+        {
+            if ( full_neg_lst[i].cols >= pos_image_size.width && full_neg_lst[i].rows >= pos_image_size.height )
+                my_hog.detectMultiScale( full_neg_lst[i], detections, foundWeights );
+            else
+                detections.clear();
+
+            for ( size_t j = 0; j < detections.size(); j++ )
+            {
+                Mat detection = full_neg_lst[i]( detections[j] ).clone();
+                resize( detection, detection, pos_image_size, 0, 0, INTER_LINEAR_EXACT);
+                neg_lst.push_back( detection );
+            }
+
+            if ( visualization )
+            {
+                for ( size_t j = 0; j < detections.size(); j++ )
+                {
+                    rectangle( full_neg_lst[i], detections[j], Scalar( 0, 255, 0 ), 2 );
+                }
+                imshow( "testing trained detector on negative images", full_neg_lst[i] );
+                waitKey( 5 );
+            }
+        }
+        clog << "...[done]" << endl;
+
+        gradient_lst.clear();
+        clog << "Histogram of Gradients are being calculated for positive images...";
+        computeHOGs( pos_image_size, pos_lst, gradient_lst, flip_samples );
+        positive_count = gradient_lst.size();
+        clog << "...[done] ( positive count : " << positive_count << " )" << endl;
+
+        clog << "Histogram of Gradients are being calculated for negative images...";
+        computeHOGs( pos_image_size, neg_lst, gradient_lst, flip_samples );
+        negative_count = gradient_lst.size() - positive_count;
+        clog << "...[done] ( negative count : " << negative_count << " )" << endl;
+
+        labels.clear();
+        labels.assign(positive_count, +1);
+        labels.insert(labels.end(), negative_count, -1);
+
+        clog << "Training SVM again...";
+        convert_to_ml( gradient_lst, train_data );
+        svm->train( train_data, ROW_SAMPLE, labels );
+        clog << "...[done]" << endl;
+    }
+
+    HOGDescriptor hog;
+    hog.winSize = pos_image_size;
+    hog.setSVMDetector( get_svm_detector( svm ) );
+    hog.save( obj_det_filename );
+
+    test_trained_detector( obj_det_filename, test_dir, videofilename );
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/train_svmsgd.cpp b/C++/opencv-4.7.0/samples/cpp/train_svmsgd.cpp
new file mode 100644
index 00000000..bfd837d5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/train_svmsgd.cpp
@@ -0,0 +1,211 @@
+#include "opencv2/core.hpp"
+#include "opencv2/video/tracking.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/ml.hpp"
+
+using namespace cv;
+using namespace cv::ml;
+
+
+struct Data
+{
+    Mat img;
+    Mat samples;          //Set of train samples. Contains points on image
+    Mat responses;        //Set of responses for train samples
+
+    Data()
+    {
+        const int WIDTH = 841;
+        const int HEIGHT = 594;
+        img = Mat::zeros(HEIGHT, WIDTH, CV_8UC3);
+        imshow("Train svmsgd", img);
+    }
+};
+
+//Train with SVMSGD algorithm
+//(samples, responses) is a train set
+//weights is a required vector for decision function of SVMSGD algorithm
+bool doTrain(const Mat samples, const Mat responses, Mat &weights, float &shift);
+
+//function finds two points for drawing line (wx = 0)
+bool findPointsForLine(const Mat &weights, float shift, Point points[], int width, int height);
+
+// function finds cross point of line (wx = 0) and segment ( (y = HEIGHT, 0 <= x <= WIDTH) or (x = WIDTH, 0 <= y <= HEIGHT) )
+bool findCrossPointWithBorders(const Mat &weights, float shift, const std::pair<Point,Point> &segment, Point &crossPoint);
+
+//segments' initialization ( (y = HEIGHT, 0 <= x <= WIDTH) and (x = WIDTH, 0 <= y <= HEIGHT) )
+void fillSegments(std::vector<std::pair<Point,Point> > &segments, int width, int height);
+
+//redraw points' set and line (wx = 0)
+void redraw(Data data, const Point points[2]);
+
+//add point in train set, train SVMSGD algorithm and draw results on image
+void addPointRetrainAndRedraw(Data &data, int x, int y, int response);
+
+
+bool doTrain( const Mat samples, const Mat responses, Mat &weights, float &shift)
+{
+    cv::Ptr<SVMSGD> svmsgd = SVMSGD::create();
+
+    cv::Ptr<TrainData> trainData = TrainData::create(samples, cv::ml::ROW_SAMPLE, responses);
+    svmsgd->train( trainData );
+
+    if (svmsgd->isTrained())
+    {
+        weights = svmsgd->getWeights();
+        shift = svmsgd->getShift();
+
+        return true;
+    }
+    return false;
+}
+
+void fillSegments(std::vector<std::pair<Point,Point> > &segments, int width, int height)
+{
+    std::pair<Point,Point> currentSegment;
+
+    currentSegment.first = Point(width, 0);
+    currentSegment.second = Point(width, height);
+    segments.push_back(currentSegment);
+
+    currentSegment.first = Point(0, height);
+    currentSegment.second = Point(width, height);
+    segments.push_back(currentSegment);
+
+    currentSegment.first = Point(0, 0);
+    currentSegment.second = Point(width, 0);
+    segments.push_back(currentSegment);
+
+    currentSegment.first = Point(0, 0);
+    currentSegment.second = Point(0, height);
+    segments.push_back(currentSegment);
+}
+
+
+bool findCrossPointWithBorders(const Mat &weights, float shift, const std::pair<Point,Point> &segment, Point &crossPoint)
+{
+    int x = 0;
+    int y = 0;
+    int xMin = std::min(segment.first.x, segment.second.x);
+    int xMax = std::max(segment.first.x, segment.second.x);
+    int yMin = std::min(segment.first.y, segment.second.y);
+    int yMax = std::max(segment.first.y, segment.second.y);
+
+    CV_Assert(weights.type() == CV_32FC1);
+    CV_Assert(xMin == xMax || yMin == yMax);
+
+    if (xMin == xMax && weights.at<float>(1) != 0)
+    {
+        x = xMin;
+        y = static_cast<int>(std::floor( - (weights.at<float>(0) * x + shift) / weights.at<float>(1)));
+        if (y >= yMin && y <= yMax)
+        {
+            crossPoint.x = x;
+            crossPoint.y = y;
+            return true;
+        }
+    }
+    else if (yMin == yMax && weights.at<float>(0) != 0)
+    {
+        y = yMin;
+        x = static_cast<int>(std::floor( - (weights.at<float>(1) * y + shift) / weights.at<float>(0)));
+        if (x >= xMin && x <= xMax)
+        {
+            crossPoint.x = x;
+            crossPoint.y = y;
+            return true;
+        }
+    }
+    return false;
+}
+
+bool findPointsForLine(const Mat &weights, float shift, Point points[2], int width, int height)
+{
+    if (weights.empty())
+    {
+        return false;
+    }
+
+    int foundPointsCount = 0;
+    std::vector<std::pair<Point,Point> > segments;
+    fillSegments(segments, width, height);
+
+    for (uint i = 0; i < segments.size(); i++)
+    {
+        if (findCrossPointWithBorders(weights, shift, segments[i], points[foundPointsCount]))
+            foundPointsCount++;
+        if (foundPointsCount >= 2)
+            break;
+    }
+
+    return true;
+}
+
+void redraw(Data data, const Point points[2])
+{
+    data.img.setTo(0);
+    Point center;
+    int radius = 3;
+    Scalar color;
+    CV_Assert((data.samples.type() == CV_32FC1) && (data.responses.type() == CV_32FC1));
+    for (int i = 0; i < data.samples.rows; i++)
+    {
+        center.x = static_cast<int>(data.samples.at<float>(i,0));
+        center.y = static_cast<int>(data.samples.at<float>(i,1));
+        color = (data.responses.at<float>(i) > 0) ? Scalar(128,128,0) : Scalar(0,128,128);
+        circle(data.img, center, radius, color, 5);
+    }
+    line(data.img, points[0], points[1],cv::Scalar(1,255,1));
+
+    imshow("Train svmsgd", data.img);
+}
+
+void addPointRetrainAndRedraw(Data &data, int x, int y, int response)
+{
+    Mat currentSample(1, 2, CV_32FC1);
+
+    currentSample.at<float>(0,0) = (float)x;
+    currentSample.at<float>(0,1) = (float)y;
+    data.samples.push_back(currentSample);
+    data.responses.push_back(static_cast<float>(response));
+
+    Mat weights(1, 2, CV_32FC1);
+    float shift = 0;
+
+    if (doTrain(data.samples, data.responses, weights, shift))
+    {
+        Point points[2];
+        findPointsForLine(weights, shift, points, data.img.cols, data.img.rows);
+
+        redraw(data, points);
+    }
+}
+
+
+static void onMouse( int event, int x, int y, int, void* pData)
+{
+    Data &data = *(Data*)pData;
+
+    switch( event )
+    {
+    case EVENT_LBUTTONUP:
+        addPointRetrainAndRedraw(data, x, y, 1);
+        break;
+
+    case EVENT_RBUTTONDOWN:
+        addPointRetrainAndRedraw(data, x, y, -1);
+        break;
+    }
+
+}
+
+int main()
+{
+    Data data;
+
+    setMouseCallback( "Train svmsgd", onMouse, &data );
+    waitKey();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/travelsalesman.cpp b/C++/opencv-4.7.0/samples/cpp/travelsalesman.cpp
new file mode 100644
index 00000000..256ff55b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/travelsalesman.cpp
@@ -0,0 +1,109 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/ml.hpp>
+
+using namespace cv;
+
+class TravelSalesman
+{
+private :
+    const std::vector<Point>& posCity;
+    std::vector<int>& next;
+    RNG rng;
+    int d0,d1,d2,d3;
+
+public:
+    TravelSalesman(std::vector<Point> &p, std::vector<int> &n) :
+        posCity(p), next(n)
+    {
+        rng = theRNG();
+    }
+    /** Give energy value for a state of system.*/
+    double energy() const;
+    /** Function which change the state of system (random perturbation).*/
+    void changeState();
+    /** Function to reverse to the previous state.*/
+    void reverseState();
+
+};
+
+void TravelSalesman::changeState()
+{
+    d0 = rng.uniform(0,static_cast<int>(posCity.size()));
+    d1 = next[d0];
+    d2 = next[d1];
+    d3 = next[d2];
+
+    next[d0] = d2;
+    next[d2] = d1;
+    next[d1] = d3;
+}
+
+
+void TravelSalesman::reverseState()
+{
+    next[d0] = d1;
+    next[d1] = d2;
+    next[d2] = d3;
+}
+
+double TravelSalesman::energy() const
+{
+    double e = 0;
+    for (size_t i = 0; i < next.size(); i++)
+    {
+        e += norm(posCity[i]-posCity[next[i]]);
+    }
+    return e;
+}
+
+
+static void DrawTravelMap(Mat &img, std::vector<Point> &p, std::vector<int> &n)
+{
+    for (size_t i = 0; i < n.size(); i++)
+    {
+        circle(img,p[i],5,Scalar(0,0,255),2);
+        line(img,p[i],p[n[i]],Scalar(0,255,0),2);
+    }
+}
+int main(void)
+{
+    int nbCity=40;
+    Mat img(500,500,CV_8UC3,Scalar::all(0));
+    RNG rng(123456);
+    int radius=static_cast<int>(img.cols*0.45);
+    Point center(img.cols/2,img.rows/2);
+
+    std::vector<Point> posCity(nbCity);
+    std::vector<int> next(nbCity);
+    for (size_t i = 0; i < posCity.size(); i++)
+    {
+        double theta = rng.uniform(0., 2 * CV_PI);
+        posCity[i].x = static_cast<int>(radius*cos(theta)) + center.x;
+        posCity[i].y = static_cast<int>(radius*sin(theta)) + center.y;
+        next[i]=(i+1)%nbCity;
+    }
+    TravelSalesman ts_system(posCity, next);
+
+    DrawTravelMap(img,posCity,next);
+    imshow("Map",img);
+    waitKey(10);
+    double currentTemperature = 100.0;
+    for (int i = 0, zeroChanges = 0; zeroChanges < 10; i++)
+    {
+        int changesApplied = ml::simulatedAnnealingSolver(ts_system, currentTemperature, currentTemperature*0.97, 0.99, 10000*nbCity, &currentTemperature, rng);
+        img.setTo(Scalar::all(0));
+        DrawTravelMap(img, posCity, next);
+        imshow("Map", img);
+        int k = waitKey(10);
+        std::cout << "i=" << i << " changesApplied=" << changesApplied << " temp=" << currentTemperature << " result=" << ts_system.energy() << std::endl;
+        if (k == 27 || k == 'q' || k == 'Q')
+            return 0;
+        if (changesApplied == 0)
+            zeroChanges++;
+    }
+    std::cout << "Done" << std::endl;
+    waitKey(0);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tree_engine.cpp b/C++/opencv-4.7.0/samples/cpp/tree_engine.cpp
new file mode 100644
index 00000000..956deb8f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tree_engine.cpp
@@ -0,0 +1,116 @@
+#include "opencv2/ml.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/core/utility.hpp"
+#include <stdio.h>
+#include <string>
+#include <map>
+
+using namespace cv;
+using namespace cv::ml;
+
+static void help(char** argv)
+{
+    printf(
+        "\nThis sample demonstrates how to use different decision trees and forests including boosting and random trees.\n"
+        "Usage:\n\t%s [-r=<response_column>] [-ts=type_spec] <csv filename>\n"
+        "where -r=<response_column> specified the 0-based index of the response (0 by default)\n"
+        "-ts= specifies the var type spec in the form ord[n1,n2-n3,n4-n5,...]cat[m1-m2,m3,m4-m5,...]\n"
+        "<csv filename> is the name of training data file in comma-separated value format\n\n", argv[0]);
+}
+
+static void train_and_print_errs(Ptr<StatModel> model, const Ptr<TrainData>& data)
+{
+    bool ok = model->train(data);
+    if( !ok )
+    {
+        printf("Training failed\n");
+    }
+    else
+    {
+        printf( "train error: %f\n", model->calcError(data, false, noArray()) );
+        printf( "test error: %f\n\n", model->calcError(data, true, noArray()) );
+    }
+}
+
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv, "{ help h | | }{r | 0 | }{ts | | }{@input | | }");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    std::string filename = parser.get<std::string>("@input");
+    int response_idx;
+    std::string typespec;
+    response_idx = parser.get<int>("r");
+    typespec = parser.get<std::string>("ts");
+    if( filename.empty() || !parser.check() )
+    {
+        parser.printErrors();
+        help(argv);
+        return 0;
+    }
+    printf("\nReading in %s...\n\n",filename.c_str());
+    const double train_test_split_ratio = 0.5;
+
+    Ptr<TrainData> data = TrainData::loadFromCSV(filename, 0, response_idx, response_idx+1, typespec);
+    if( data.empty() )
+    {
+        printf("ERROR: File %s can not be read\n", filename.c_str());
+        return 0;
+    }
+
+    data->setTrainTestSplitRatio(train_test_split_ratio);
+    std::cout << "Test/Train: " << data->getNTestSamples() << "/" << data->getNTrainSamples();
+
+    printf("======DTREE=====\n");
+    Ptr<DTrees> dtree = DTrees::create();
+    dtree->setMaxDepth(10);
+    dtree->setMinSampleCount(2);
+    dtree->setRegressionAccuracy(0);
+    dtree->setUseSurrogates(false);
+    dtree->setMaxCategories(16);
+    dtree->setCVFolds(0);
+    dtree->setUse1SERule(false);
+    dtree->setTruncatePrunedTree(false);
+    dtree->setPriors(Mat());
+    train_and_print_errs(dtree, data);
+
+    if( (int)data->getClassLabels().total() <= 2 ) // regression or 2-class classification problem
+    {
+        printf("======BOOST=====\n");
+        Ptr<Boost> boost = Boost::create();
+        boost->setBoostType(Boost::GENTLE);
+        boost->setWeakCount(100);
+        boost->setWeightTrimRate(0.95);
+        boost->setMaxDepth(2);
+        boost->setUseSurrogates(false);
+        boost->setPriors(Mat());
+        train_and_print_errs(boost, data);
+    }
+
+    printf("======RTREES=====\n");
+    Ptr<RTrees> rtrees = RTrees::create();
+    rtrees->setMaxDepth(10);
+    rtrees->setMinSampleCount(2);
+    rtrees->setRegressionAccuracy(0);
+    rtrees->setUseSurrogates(false);
+    rtrees->setMaxCategories(16);
+    rtrees->setPriors(Mat());
+    rtrees->setCalculateVarImportance(true);
+    rtrees->setActiveVarCount(0);
+    rtrees->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, 100, 0));
+    train_and_print_errs(rtrees, data);
+    cv::Mat ref_labels = data->getClassLabels();
+    cv::Mat test_data = data->getTestSampleIdx();
+    cv::Mat predict_labels;
+    rtrees->predict(data->getSamples(), predict_labels);
+
+    cv::Mat variable_importance = rtrees->getVarImportance();
+    std::cout << "Estimated variable importance" << std::endl;
+    for (int i = 0; i < variable_importance.rows; i++) {
+        std::cout << "Variable " << i << ": " << variable_importance.at<float>(i, 0) << std::endl;
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp
new file mode 100644
index 00000000..82bbb374
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp
@@ -0,0 +1,73 @@
+/**
+ * @file AddingImagesTrackbar.cpp
+ * @brief Simple linear blender ( dst = alpha*src1 + beta*src2 )
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+using std::cout;
+
+/** Global Variables */
+const int alpha_slider_max = 100;
+int alpha_slider;
+double alpha;
+double beta;
+
+/** Matrices to store images */
+Mat src1;
+Mat src2;
+Mat dst;
+
+//![on_trackbar]
+/**
+ * @function on_trackbar
+ * @brief Callback for trackbar
+ */
+static void on_trackbar( int, void* )
+{
+   alpha = (double) alpha_slider/alpha_slider_max ;
+   beta = ( 1.0 - alpha );
+   addWeighted( src1, alpha, src2, beta, 0.0, dst);
+   imshow( "Linear Blend", dst );
+}
+//![on_trackbar]
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( void )
+{
+   //![load]
+   /// Read images ( both have to be of the same size and type )
+   src1 = imread( samples::findFile("LinuxLogo.jpg") );
+   src2 = imread( samples::findFile("WindowsLogo.jpg") );
+   //![load]
+
+   if( src1.empty() ) { cout << "Error loading src1 \n"; return -1; }
+   if( src2.empty() ) { cout << "Error loading src2 \n"; return -1; }
+
+   /// Initialize values
+   alpha_slider = 0;
+
+   //![window]
+   namedWindow("Linear Blend", WINDOW_AUTOSIZE); // Create Window
+   //![window]
+
+   //![create_trackbar]
+   char TrackbarName[50];
+   snprintf( TrackbarName, sizeof(TrackbarName), "Alpha x %d", alpha_slider_max );
+   createTrackbar( TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar );
+   //![create_trackbar]
+
+   /// Show some stuff
+   on_trackbar( alpha_slider, 0 );
+
+   /// Wait until user press some key
+   waitKey(0);
+   return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/HighGUI/BasicLinearTransformsTrackbar.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/HighGUI/BasicLinearTransformsTrackbar.cpp
new file mode 100644
index 00000000..cdd33fb5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/HighGUI/BasicLinearTransformsTrackbar.cpp
@@ -0,0 +1,73 @@
+/**
+ * @file BasicLinearTransformsTrackbar.cpp
+ * @brief Simple program to change contrast and brightness
+ * @date Mon, June 6, 2011
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+// we're NOT "using namespace std;" here, to avoid collisions between the beta variable and std::beta in c++17
+using namespace cv;
+
+/** Global Variables */
+const int alpha_max = 5;
+const int beta_max = 125;
+int alpha; /**< Simple contrast control */
+int beta;  /**< Simple brightness control*/
+
+/** Matrices to store images */
+Mat image;
+
+/**
+ * @function on_trackbar
+ * @brief Called whenever any of alpha or beta changes
+ */
+static void on_trackbar( int, void* )
+{
+    Mat new_image = Mat::zeros( image.size(), image.type() );
+
+    for( int y = 0; y < image.rows; y++ )
+        for( int x = 0; x < image.cols; x++ )
+            for( int c = 0; c < 3; c++ )
+                new_image.at<Vec3b>(y,x)[c] = saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
+
+    imshow("New Image", new_image);
+}
+
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( int argc, char** argv )
+{
+   /// Read image given by user
+   String imageName("lena.jpg"); // by default
+   if (argc > 1)
+   {
+      imageName = argv[1];
+   }
+   image = imread( samples::findFile( imageName ) );
+
+   /// Initialize values
+   alpha = 1;
+   beta = 0;
+
+   /// Create Windows
+   namedWindow("Original Image", 1);
+   namedWindow("New Image", 1);
+
+   /// Create Trackbars
+   createTrackbar( "Contrast", "New Image", &alpha, alpha_max, on_trackbar );
+   createTrackbar( "Brightness", "New Image", &beta, beta_max, on_trackbar );
+
+   /// Show some stuff
+   imshow("Original Image", image);
+   imshow("New Image", image);
+
+   /// Wait until user press some key
+   waitKey();
+   return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp
new file mode 100644
index 00000000..7f1c55b8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp
@@ -0,0 +1,51 @@
+/**
+ * @function EqualizeHist_Demo.cpp
+ * @brief Demo code for equalizeHist function
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //! [Load image]
+    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    //! [Load image]
+
+    //! [Convert to grayscale]
+    cvtColor( src, src, COLOR_BGR2GRAY );
+    //! [Convert to grayscale]
+
+    //! [Apply Histogram Equalization]
+    Mat dst;
+    equalizeHist( src, dst );
+    //! [Apply Histogram Equalization]
+
+    //! [Display results]
+    imshow( "Source image", src );
+    imshow( "Equalized Image", dst );
+    //! [Display results]
+
+    //! [Wait until user exits the program]
+    waitKey();
+    //! [Wait until user exits the program]
+
+    return 0;
+
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp
new file mode 100644
index 00000000..f9abbae9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp
@@ -0,0 +1,137 @@
+/**
+ * @file MatchTemplate_Demo.cpp
+ * @brief Sample code to use the function MatchTemplate
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+//! [declare]
+/// Global Variables
+bool use_mask;
+Mat img; Mat templ; Mat mask; Mat result;
+const char* image_window = "Source Image";
+const char* result_window = "Result window";
+
+int match_method;
+int max_Trackbar = 5;
+//! [declare]
+
+/// Function Headers
+void MatchingMethod( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  if (argc < 3)
+  {
+    cout << "Not enough parameters" << endl;
+    cout << "Usage:\n" << argv[0] << " <image_name> <template_name> [<mask_name>]" << endl;
+    return -1;
+  }
+
+  //! [load_image]
+  /// Load image and template
+  img = imread( argv[1], IMREAD_COLOR );
+  templ = imread( argv[2], IMREAD_COLOR );
+
+  if(argc > 3) {
+    use_mask = true;
+    mask = imread( argv[3], IMREAD_COLOR );
+  }
+
+  if(img.empty() || templ.empty() || (use_mask && mask.empty()))
+  {
+    cout << "Can't read one of the images" << endl;
+    return EXIT_FAILURE;
+  }
+  //! [load_image]
+
+  //! [create_windows]
+  /// Create windows
+  namedWindow( image_window, WINDOW_AUTOSIZE );
+  namedWindow( result_window, WINDOW_AUTOSIZE );
+  //! [create_windows]
+
+  //! [create_trackbar]
+  /// Create Trackbar
+  const char* trackbar_label = "Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED";
+  createTrackbar( trackbar_label, image_window, &match_method, max_Trackbar, MatchingMethod );
+  //! [create_trackbar]
+
+  MatchingMethod( 0, 0 );
+
+  //! [wait_key]
+  waitKey(0);
+  return EXIT_SUCCESS;
+  //! [wait_key]
+}
+
+/**
+ * @function MatchingMethod
+ * @brief Trackbar callback
+ */
+void MatchingMethod( int, void* )
+{
+  //! [copy_source]
+  /// Source image to display
+  Mat img_display;
+  img.copyTo( img_display );
+  //! [copy_source]
+
+  //! [create_result_matrix]
+  /// Create the result matrix
+  int result_cols = img.cols - templ.cols + 1;
+  int result_rows = img.rows - templ.rows + 1;
+
+  result.create( result_rows, result_cols, CV_32FC1 );
+  //! [create_result_matrix]
+
+  //! [match_template]
+  /// Do the Matching and Normalize
+  bool method_accepts_mask = (TM_SQDIFF == match_method || match_method == TM_CCORR_NORMED);
+  if (use_mask && method_accepts_mask)
+    { matchTemplate( img, templ, result, match_method, mask); }
+  else
+    { matchTemplate( img, templ, result, match_method); }
+  //! [match_template]
+
+  //! [normalize]
+  normalize( result, result, 0, 1, NORM_MINMAX, -1, Mat() );
+  //! [normalize]
+
+  //! [best_match]
+  /// Localizing the best match with minMaxLoc
+  double minVal; double maxVal; Point minLoc; Point maxLoc;
+  Point matchLoc;
+
+  minMaxLoc( result, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
+  //! [best_match]
+
+  //! [match_loc]
+  /// For SQDIFF and SQDIFF_NORMED, the best matches are lower values. For all the other methods, the higher the better
+  if( match_method  == TM_SQDIFF || match_method == TM_SQDIFF_NORMED )
+    { matchLoc = minLoc; }
+  else
+    { matchLoc = maxLoc; }
+  //! [match_loc]
+
+  //! [imshow]
+  /// Show me what you got
+  rectangle( img_display, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 );
+  rectangle( result, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 );
+
+  imshow( image_window, img_display );
+  imshow( result_window, result );
+  //! [imshow]
+
+  return;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp
new file mode 100644
index 00000000..bcb547a2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp
@@ -0,0 +1,106 @@
+/**
+ * @file BackProject_Demo1.cpp
+ * @brief Sample code for backproject function usage
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global Variables
+Mat hue;
+int bins = 25;
+
+/// Function Headers
+void Hist_and_Backproj(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char* argv[] )
+{
+    //! [Read the image]
+    CommandLineParser parser( argc, argv, "{@input |  | input image}" );
+    Mat src = imread( parser.get<String>( "@input" ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    //! [Read the image]
+
+    //! [Transform it to HSV]
+    Mat hsv;
+    cvtColor( src, hsv, COLOR_BGR2HSV );
+    //! [Transform it to HSV]
+
+    //! [Use only the Hue value]
+    hue.create(hsv.size(), hsv.depth());
+    int ch[] = { 0, 0 };
+    mixChannels( &hsv, 1, &hue, 1, ch, 1 );
+    //! [Use only the Hue value]
+
+    //! [Create Trackbar to enter the number of bins]
+    const char* window_image = "Source image";
+    namedWindow( window_image );
+    createTrackbar("* Hue  bins: ", window_image, &bins, 180, Hist_and_Backproj );
+    Hist_and_Backproj(0, 0);
+    //! [Create Trackbar to enter the number of bins]
+
+    //! [Show the image]
+    imshow( window_image, src );
+    // Wait until user exits the program
+    waitKey();
+    //! [Show the image]
+
+    return 0;
+}
+
+/**
+ * @function Hist_and_Backproj
+ * @brief Callback to Trackbar
+ */
+void Hist_and_Backproj(int, void* )
+{
+    //! [initialize]
+    int histSize = MAX( bins, 2 );
+    float hue_range[] = { 0, 180 };
+    const float* ranges[] = { hue_range };
+    //! [initialize]
+
+    //! [Get the Histogram and normalize it]
+    Mat hist;
+    calcHist( &hue, 1, 0, Mat(), hist, 1, &histSize, ranges, true, false );
+    normalize( hist, hist, 0, 255, NORM_MINMAX, -1, Mat() );
+    //! [Get the Histogram and normalize it]
+
+    //! [Get Backprojection]
+    Mat backproj;
+    calcBackProject( &hue, 1, 0, hist, backproj, ranges, 1, true );
+    //! [Get Backprojection]
+
+    //! [Draw the backproj]
+    imshow( "BackProj", backproj );
+    //! [Draw the backproj]
+
+    //! [Draw the histogram]
+    int w = 400, h = 400;
+    int bin_w = cvRound( (double) w / histSize );
+    Mat histImg = Mat::zeros( h, w, CV_8UC3 );
+
+    for (int i = 0; i < bins; i++)
+    {
+        rectangle( histImg, Point( i*bin_w, h ), Point( (i+1)*bin_w, h - cvRound( hist.at<float>(i)*h/255.0 ) ),
+                   Scalar( 0, 0, 255 ), FILLED );
+    }
+
+    imshow( "Histogram", histImg );
+    //! [Draw the histogram]
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp
new file mode 100644
index 00000000..9c42c0fc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp
@@ -0,0 +1,105 @@
+/**
+ * @file BackProject_Demo2.cpp
+ * @brief Sample code for backproject function usage ( a bit more elaborated )
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global Variables
+Mat src, hsv, mask;
+
+int low = 20, up = 20;
+const char* window_image = "Source image";
+
+/// Function Headers
+void Hist_and_Backproj( );
+void pickPoint (int event, int x, int y, int, void* );
+
+/**
+ * @function main
+ */
+int main( int, char** argv )
+{
+    /// Read the image
+    src = imread( argv[1] );
+
+    /// Transform it to HSV
+    cvtColor( src, hsv, COLOR_BGR2HSV );
+
+    /// Show the image
+    namedWindow( window_image );
+    imshow( window_image, src );
+
+    /// Set Trackbars for floodfill thresholds
+    createTrackbar( "Low thresh", window_image, &low, 255, 0 );
+    createTrackbar( "High thresh", window_image, &up, 255, 0 );
+    /// Set a Mouse Callback
+    setMouseCallback( window_image, pickPoint, 0 );
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function pickPoint
+ */
+void pickPoint (int event, int x, int y, int, void* )
+{
+    if( event != EVENT_LBUTTONDOWN )
+    {
+        return;
+    }
+
+    // Fill and get the mask
+    Point seed = Point( x, y );
+
+    int newMaskVal = 255;
+    Scalar newVal = Scalar( 120, 120, 120 );
+
+    int connectivity = 8;
+    int flags = connectivity + (newMaskVal << 8 ) + FLOODFILL_FIXED_RANGE + FLOODFILL_MASK_ONLY;
+
+    Mat mask2 = Mat::zeros( src.rows + 2, src.cols + 2, CV_8U );
+    floodFill( src, mask2, seed, newVal, 0, Scalar( low, low, low ), Scalar( up, up, up), flags );
+    mask = mask2( Range( 1, mask2.rows - 1 ), Range( 1, mask2.cols - 1 ) );
+
+    imshow( "Mask", mask );
+
+    Hist_and_Backproj( );
+}
+
+/**
+ * @function Hist_and_Backproj
+ */
+void Hist_and_Backproj( )
+{
+    Mat hist;
+    int h_bins = 30; int s_bins = 32;
+    int histSize[] = { h_bins, s_bins };
+
+    float h_range[] = { 0, 180 };
+    float s_range[] = { 0, 256 };
+    const float* ranges[] = { h_range, s_range };
+
+    int channels[] = { 0, 1 };
+
+    /// Get the Histogram and normalize it
+    calcHist( &hsv, 1, channels, mask, hist, 2, histSize, ranges, true, false );
+
+    normalize( hist, hist, 0, 255, NORM_MINMAX, -1, Mat() );
+
+    /// Get Backprojection
+    Mat backproj;
+    calcBackProject( &hsv, 1, channels, hist, backproj, ranges, 1, true );
+
+    /// Draw the backproj
+    imshow( "BackProj", backproj );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp
new file mode 100644
index 00000000..a7582e42
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp
@@ -0,0 +1,89 @@
+/**
+ * @function calcHist_Demo.cpp
+ * @brief Demo code to use the function calcHist
+ * @author
+ */
+
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main(int argc, char** argv)
+{
+    //! [Load image]
+    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
+    if( src.empty() )
+    {
+        return EXIT_FAILURE;
+    }
+    //! [Load image]
+
+    //! [Separate the image in 3 places ( B, G and R )]
+    vector<Mat> bgr_planes;
+    split( src, bgr_planes );
+    //! [Separate the image in 3 places ( B, G and R )]
+
+    //! [Establish the number of bins]
+    int histSize = 256;
+    //! [Establish the number of bins]
+
+    //! [Set the ranges ( for B,G,R) )]
+    float range[] = { 0, 256 }; //the upper boundary is exclusive
+    const float* histRange[] = { range };
+    //! [Set the ranges ( for B,G,R) )]
+
+    //! [Set histogram param]
+    bool uniform = true, accumulate = false;
+    //! [Set histogram param]
+
+    //! [Compute the histograms]
+    Mat b_hist, g_hist, r_hist;
+    calcHist( &bgr_planes[0], 1, 0, Mat(), b_hist, 1, &histSize, histRange, uniform, accumulate );
+    calcHist( &bgr_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, histRange, uniform, accumulate );
+    calcHist( &bgr_planes[2], 1, 0, Mat(), r_hist, 1, &histSize, histRange, uniform, accumulate );
+    //! [Compute the histograms]
+
+    //! [Draw the histograms for B, G and R]
+    int hist_w = 512, hist_h = 400;
+    int bin_w = cvRound( (double) hist_w/histSize );
+
+    Mat histImage( hist_h, hist_w, CV_8UC3, Scalar( 0,0,0) );
+    //! [Draw the histograms for B, G and R]
+
+    //! [Normalize the result to ( 0, histImage.rows )]
+    normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+    normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+    normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+    //! [Normalize the result to ( 0, histImage.rows )]
+
+    //! [Draw for each channel]
+    for( int i = 1; i < histSize; i++ )
+    {
+        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ),
+              Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ),
+              Scalar( 255, 0, 0), 2, 8, 0  );
+        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ),
+              Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),
+              Scalar( 0, 255, 0), 2, 8, 0  );
+        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ),
+              Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),
+              Scalar( 0, 0, 255), 2, 8, 0  );
+    }
+    //! [Draw for each channel]
+
+    //! [Display]
+    imshow("Source image", src );
+    imshow("calcHist Demo", histImage );
+    waitKey();
+    //! [Display]
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp
new file mode 100644
index 00000000..aa5fce20
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp
@@ -0,0 +1,95 @@
+/**
+ * @file compareHist_Demo.cpp
+ * @brief Sample code to use the function compareHist
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+const char* keys =
+    "{ help  h| | Print help message. }"
+    "{ @input1 | | Path to input image 1. }"
+    "{ @input2 | | Path to input image 2. }"
+    "{ @input3 | | Path to input image 3. }";
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //! [Load three images with different environment settings]
+    CommandLineParser parser( argc, argv, keys );
+    Mat src_base = imread( parser.get<String>("input1") );
+    Mat src_test1 = imread( parser.get<String>("input2") );
+    Mat src_test2 = imread( parser.get<String>("input3") );
+    if( src_base.empty() || src_test1.empty() || src_test2.empty() )
+    {
+        cout << "Could not open or find the images!\n" << endl;
+        parser.printMessage();
+        return -1;
+    }
+    //! [Load three images with different environment settings]
+
+    //! [Convert to HSV]
+    Mat hsv_base, hsv_test1, hsv_test2;
+    cvtColor( src_base, hsv_base, COLOR_BGR2HSV );
+    cvtColor( src_test1, hsv_test1, COLOR_BGR2HSV );
+    cvtColor( src_test2, hsv_test2, COLOR_BGR2HSV );
+    //! [Convert to HSV]
+
+    //! [Convert to HSV half]
+    Mat hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows ), Range( 0, hsv_base.cols ) );
+    //! [Convert to HSV half]
+
+    //! [Using 50 bins for hue and 60 for saturation]
+    int h_bins = 50, s_bins = 60;
+    int histSize[] = { h_bins, s_bins };
+
+    // hue varies from 0 to 179, saturation from 0 to 255
+    float h_ranges[] = { 0, 180 };
+    float s_ranges[] = { 0, 256 };
+
+    const float* ranges[] = { h_ranges, s_ranges };
+
+    // Use the 0-th and 1-st channels
+    int channels[] = { 0, 1 };
+    //! [Using 50 bins for hue and 60 for saturation]
+
+    //! [Calculate the histograms for the HSV images]
+    Mat hist_base, hist_half_down, hist_test1, hist_test2;
+
+    calcHist( &hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
+    normalize( hist_base, hist_base, 0, 1, NORM_MINMAX, -1, Mat() );
+
+    calcHist( &hsv_half_down, 1, channels, Mat(), hist_half_down, 2, histSize, ranges, true, false );
+    normalize( hist_half_down, hist_half_down, 0, 1, NORM_MINMAX, -1, Mat() );
+
+    calcHist( &hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false );
+    normalize( hist_test1, hist_test1, 0, 1, NORM_MINMAX, -1, Mat() );
+
+    calcHist( &hsv_test2, 1, channels, Mat(), hist_test2, 2, histSize, ranges, true, false );
+    normalize( hist_test2, hist_test2, 0, 1, NORM_MINMAX, -1, Mat() );
+    //! [Calculate the histograms for the HSV images]
+
+    //! [Apply the histogram comparison methods]
+    for( int compare_method = 0; compare_method < 4; compare_method++ )
+    {
+        double base_base = compareHist( hist_base, hist_base, compare_method );
+        double base_half = compareHist( hist_base, hist_half_down, compare_method );
+        double base_test1 = compareHist( hist_base, hist_test1, compare_method );
+        double base_test2 = compareHist( hist_base, hist_test2, compare_method );
+
+        cout << "Method " << compare_method << " Perfect, Base-Half, Base-Test(1), Base-Test(2) : "
+             <<  base_base << " / " << base_half << " / " << base_test1 << " / " << base_test2 << endl;
+    }
+    //! [Apply the histogram comparison methods]
+
+    cout << "Done \n";
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp
new file mode 100644
index 00000000..dc7b849f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp
@@ -0,0 +1,74 @@
+/**
+ * @file BasicLinearTransforms.cpp
+ * @brief Simple program to change contrast and brightness
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+// we're NOT "using namespace std;" here, to avoid collisions between the beta variable and std::beta in c++17
+using std::cin;
+using std::cout;
+using std::endl;
+using namespace cv;
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( int argc, char** argv )
+{
+    /// Read image given by user
+    //! [basic-linear-transform-load]
+    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
+    Mat image = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if( image.empty() )
+    {
+      cout << "Could not open or find the image!\n" << endl;
+      cout << "Usage: " << argv[0] << " <Input image>" << endl;
+      return -1;
+    }
+    //! [basic-linear-transform-load]
+
+    //! [basic-linear-transform-output]
+    Mat new_image = Mat::zeros( image.size(), image.type() );
+    //! [basic-linear-transform-output]
+
+    //! [basic-linear-transform-parameters]
+    double alpha = 1.0; /*< Simple contrast control */
+    int beta = 0;       /*< Simple brightness control */
+
+    /// Initialize values
+    cout << " Basic Linear Transforms " << endl;
+    cout << "-------------------------" << endl;
+    cout << "* Enter the alpha value [1.0-3.0]: "; cin >> alpha;
+    cout << "* Enter the beta value [0-100]: ";    cin >> beta;
+    //! [basic-linear-transform-parameters]
+
+    /// Do the operation new_image(i,j) = alpha*image(i,j) + beta
+    /// Instead of these 'for' loops we could have used simply:
+    /// image.convertTo(new_image, -1, alpha, beta);
+    /// but we wanted to show you how to access the pixels :)
+    //! [basic-linear-transform-operation]
+    for( int y = 0; y < image.rows; y++ ) {
+        for( int x = 0; x < image.cols; x++ ) {
+            for( int c = 0; c < image.channels(); c++ ) {
+                new_image.at<Vec3b>(y,x)[c] =
+                  saturate_cast<uchar>( alpha*image.at<Vec3b>(y,x)[c] + beta );
+            }
+        }
+    }
+    //! [basic-linear-transform-operation]
+
+    //! [basic-linear-transform-display]
+    /// Show stuff
+    imshow("Original Image", image);
+    imshow("New Image", new_image);
+
+    /// Wait until the user press a key
+    waitKey();
+    //! [basic-linear-transform-display]
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/HitMiss/HitMiss.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/HitMiss/HitMiss.cpp
new file mode 100644
index 00000000..0901191b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/HitMiss/HitMiss.cpp
@@ -0,0 +1,44 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace cv;
+
+int main(){
+    Mat input_image = (Mat_<uchar>(8, 8) <<
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 255, 255, 255, 0, 0, 0, 255,
+        0, 255, 255, 255, 0, 0, 0, 0,
+        0, 255, 255, 255, 0, 255, 0, 0,
+        0, 0, 255, 0, 0, 0, 0, 0,
+        0, 0, 255, 0, 0, 255, 255, 0,
+        0, 255, 0, 255, 0, 0, 255, 0,
+        0, 255, 255, 255, 0, 0, 0, 0);
+
+    Mat kernel = (Mat_<int>(3, 3) <<
+        0, 1, 0,
+        1, -1, 1,
+        0, 1, 0);
+
+    Mat output_image;
+    morphologyEx(input_image, output_image, MORPH_HITMISS, kernel);
+
+    const int rate = 50;
+    kernel = (kernel + 1) * 127;
+    kernel.convertTo(kernel, CV_8U);
+
+    resize(kernel, kernel, Size(), rate, rate, INTER_NEAREST);
+    imshow("kernel", kernel);
+    moveWindow("kernel", 0, 0);
+
+    resize(input_image, input_image, Size(), rate, rate, INTER_NEAREST);
+    imshow("Original", input_image);
+    moveWindow("Original", 0, 200);
+
+    resize(output_image, output_image, Size(), rate, rate, INTER_NEAREST);
+    imshow("Hit or Miss", output_image);
+    moveWindow("Hit or Miss", 500, 200);
+
+    waitKey(0);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp
new file mode 100644
index 00000000..33e00626
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp
@@ -0,0 +1,118 @@
+/**
+ * @file Morphology_1.cpp
+ * @brief Erosion and Dilation sample code
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+Mat src, erosion_dst, dilation_dst;
+
+int erosion_elem = 0;
+int erosion_size = 0;
+int dilation_elem = 0;
+int dilation_size = 0;
+int const max_elem = 2;
+int const max_kernel_size = 21;
+
+/** Function Headers */
+void Erosion( int, void* );
+void Dilation( int, void* );
+
+//![main]
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load an image
+  CommandLineParser parser( argc, argv, "{@input | LinuxLogo.jpg | input image}" );
+  src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
+  if( src.empty() )
+  {
+    cout << "Could not open or find the image!\n" << endl;
+    cout << "Usage: " << argv[0] << " <Input image>" << endl;
+    return -1;
+  }
+
+  /// Create windows
+  namedWindow( "Erosion Demo", WINDOW_AUTOSIZE );
+  namedWindow( "Dilation Demo", WINDOW_AUTOSIZE );
+  moveWindow( "Dilation Demo", src.cols, 0 );
+
+  /// Create Erosion Trackbar
+  createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse", "Erosion Demo",
+          &erosion_elem, max_elem,
+          Erosion );
+
+  createTrackbar( "Kernel size:\n 2n +1", "Erosion Demo",
+          &erosion_size, max_kernel_size,
+          Erosion );
+
+  /// Create Dilation Trackbar
+  createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse", "Dilation Demo",
+          &dilation_elem, max_elem,
+          Dilation );
+
+  createTrackbar( "Kernel size:\n 2n +1", "Dilation Demo",
+          &dilation_size, max_kernel_size,
+          Dilation );
+
+  /// Default start
+  Erosion( 0, 0 );
+  Dilation( 0, 0 );
+
+  waitKey(0);
+  return 0;
+}
+//![main]
+
+//![erosion]
+/**
+ * @function Erosion
+ */
+void Erosion( int, void* )
+{
+  int erosion_type = 0;
+  if( erosion_elem == 0 ){ erosion_type = MORPH_RECT; }
+  else if( erosion_elem == 1 ){ erosion_type = MORPH_CROSS; }
+  else if( erosion_elem == 2) { erosion_type = MORPH_ELLIPSE; }
+
+  //![kernel]
+  Mat element = getStructuringElement( erosion_type,
+                       Size( 2*erosion_size + 1, 2*erosion_size+1 ),
+                       Point( erosion_size, erosion_size ) );
+  //![kernel]
+
+  /// Apply the erosion operation
+  erode( src, erosion_dst, element );
+  imshow( "Erosion Demo", erosion_dst );
+}
+//![erosion]
+
+//![dilation]
+/**
+ * @function Dilation
+ */
+void Dilation( int, void* )
+{
+  int dilation_type = 0;
+  if( dilation_elem == 0 ){ dilation_type = MORPH_RECT; }
+  else if( dilation_elem == 1 ){ dilation_type = MORPH_CROSS; }
+  else if( dilation_elem == 2) { dilation_type = MORPH_ELLIPSE; }
+
+  Mat element = getStructuringElement( dilation_type,
+                       Size( 2*dilation_size + 1, 2*dilation_size+1 ),
+                       Point( dilation_size, dilation_size ) );
+
+  /// Apply the dilation operation
+  dilate( src, dilation_dst, element );
+  imshow( "Dilation Demo", dilation_dst );
+}
+//![dilation]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp
new file mode 100644
index 00000000..3bc40d3b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp
@@ -0,0 +1,93 @@
+/**
+ * @file Morphology_2.cpp
+ * @brief Advanced morphology Transformations sample code
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+
+/// Global variables
+Mat src, dst;
+
+int morph_elem = 0;
+int morph_size = 0;
+int morph_operator = 0;
+int const max_operator = 4;
+int const max_elem = 2;
+int const max_kernel_size = 21;
+
+const char* window_name = "Morphology Transformations Demo";
+
+
+/** Function Headers */
+void Morphology_Operations( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  //![load]
+  CommandLineParser parser( argc, argv, "{@input | baboon.jpg | input image}" );
+  src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
+  if (src.empty())
+  {
+    std::cout << "Could not open or find the image!\n" << std::endl;
+    std::cout << "Usage: " << argv[0] << " <Input image>" << std::endl;
+    return EXIT_FAILURE;
+  }
+  //![load]
+
+  //![window]
+  namedWindow( window_name, WINDOW_AUTOSIZE ); // Create window
+  //![window]
+
+  //![create_trackbar1]
+  /// Create Trackbar to select Morphology operation
+  createTrackbar("Operator:\n 0: Opening - 1: Closing  \n 2: Gradient - 3: Top Hat \n 4: Black Hat", window_name, &morph_operator, max_operator, Morphology_Operations );
+  //![create_trackbar1]
+
+  //![create_trackbar2]
+  /// Create Trackbar to select kernel type
+  createTrackbar( "Element:\n 0: Rect - 1: Cross - 2: Ellipse", window_name,
+                  &morph_elem, max_elem,
+                  Morphology_Operations );
+  //![create_trackbar2]
+
+  //![create_trackbar3]
+  /// Create Trackbar to choose kernel size
+  createTrackbar( "Kernel size:\n 2n +1", window_name,
+                  &morph_size, max_kernel_size,
+                  Morphology_Operations );
+  //![create_trackbar3]
+
+  /// Default start
+  Morphology_Operations( 0, 0 );
+
+  waitKey(0);
+  return 0;
+}
+
+//![morphology_operations]
+/**
+ * @function Morphology_Operations
+ */
+void Morphology_Operations( int, void* )
+{
+  // Since MORPH_X : 2,3,4,5 and 6
+  //![operation]
+  int operation = morph_operator + 2;
+  //![operation]
+
+  Mat element = getStructuringElement( morph_elem, Size( 2*morph_size + 1, 2*morph_size+1 ), Point( morph_size, morph_size ) );
+
+  /// Apply the specified morphology operation
+  morphologyEx( src, dst, operation, element );
+  imshow( window_name, dst );
+}
+//![morphology_operations]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Pyramids/Pyramids.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Pyramids/Pyramids.cpp
new file mode 100644
index 00000000..22192b5a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Pyramids/Pyramids.cpp
@@ -0,0 +1,69 @@
+/**
+ * @file Pyramids.cpp
+ * @brief Sample code of image pyramids (pyrDown and pyrUp)
+ * @author OpenCV team
+ */
+
+#include "iostream"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace std;
+using namespace cv;
+
+const char* window_name = "Pyramids Demo";
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    /// General instructions
+    cout << "\n Zoom In-Out demo \n "
+            "------------------  \n"
+            " * [i] -> Zoom in   \n"
+            " * [o] -> Zoom out  \n"
+            " * [ESC] -> Close program \n" << endl;
+
+    //![load]
+    const char* filename = argc >=2 ? argv[1] : "chicky_512.png";
+
+    // Loads an image
+    Mat src = imread( samples::findFile( filename ) );
+
+    // Check if image is loaded fine
+    if(src.empty()){
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default chicky_512.png] \n");
+        return EXIT_FAILURE;
+    }
+    //![load]
+
+    //![loop]
+    for(;;)
+    {
+        //![show_image]
+        imshow( window_name, src );
+        //![show_image]
+        char c = (char)waitKey(0);
+
+        if( c == 27 )
+        { break; }
+        //![pyrup]
+        else if( c == 'i' )
+        { pyrUp( src, src, Size( src.cols*2, src.rows*2 ) );
+            printf( "** Zoom In: Image x 2 \n" );
+        }
+        //![pyrup]
+        //![pyrdown]
+        else if( c == 'o' )
+        { pyrDown( src, src, Size( src.cols/2, src.rows/2 ) );
+            printf( "** Zoom Out: Image / 2 \n" );
+        }
+        //![pyrdown]
+    }
+    //![loop]
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp
new file mode 100644
index 00000000..f561c543
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp
@@ -0,0 +1,153 @@
+/**
+ * file Smoothing.cpp
+ * brief Sample code for simple filters
+ * author OpenCV team
+ */
+
+#include <iostream>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace std;
+using namespace cv;
+
+/// Global Variables
+int DELAY_CAPTION = 1500;
+int DELAY_BLUR = 100;
+int MAX_KERNEL_LENGTH = 31;
+
+Mat src; Mat dst;
+char window_name[] = "Smoothing Demo";
+
+/// Function headers
+int display_caption( const char* caption );
+int display_dst( int delay );
+
+
+/**
+ * function main
+ */
+int main( int argc, char ** argv )
+{
+    namedWindow( window_name, WINDOW_AUTOSIZE );
+
+    /// Load the source image
+    const char* filename = argc >=2 ? argv[1] : "lena.jpg";
+
+    src = imread( samples::findFile( filename ), IMREAD_COLOR );
+    if (src.empty())
+    {
+        printf(" Error opening image\n");
+        printf(" Usage:\n %s [image_name-- default lena.jpg] \n", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    if( display_caption( "Original Image" ) != 0 )
+    {
+        return 0;
+    }
+
+    dst = src.clone();
+    if( display_dst( DELAY_CAPTION ) != 0 )
+    {
+        return 0;
+    }
+
+    /// Applying Homogeneous blur
+    if( display_caption( "Homogeneous Blur" ) != 0 )
+    {
+        return 0;
+    }
+
+    //![blur]
+    for ( int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2 )
+    {
+        blur( src, dst, Size( i, i ), Point(-1,-1) );
+        if( display_dst( DELAY_BLUR ) != 0 )
+        {
+            return 0;
+        }
+    }
+    //![blur]
+
+    /// Applying Gaussian blur
+    if( display_caption( "Gaussian Blur" ) != 0 )
+    {
+        return 0;
+    }
+
+    //![gaussianblur]
+    for ( int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2 )
+    {
+        GaussianBlur( src, dst, Size( i, i ), 0, 0 );
+        if( display_dst( DELAY_BLUR ) != 0 )
+        {
+            return 0;
+        }
+    }
+    //![gaussianblur]
+
+    /// Applying Median blur
+    if( display_caption( "Median Blur" ) != 0 )
+    {
+        return 0;
+    }
+
+    //![medianblur]
+    for ( int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2 )
+    {
+        medianBlur ( src, dst, i );
+        if( display_dst( DELAY_BLUR ) != 0 )
+        {
+            return 0;
+        }
+    }
+    //![medianblur]
+
+    /// Applying Bilateral Filter
+    if( display_caption( "Bilateral Blur" ) != 0 )
+    {
+        return 0;
+    }
+
+    //![bilateralfilter]
+    for ( int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2 )
+    {
+        bilateralFilter ( src, dst, i, i*2, i/2 );
+        if( display_dst( DELAY_BLUR ) != 0 )
+        {
+            return 0;
+        }
+    }
+    //![bilateralfilter]
+
+    /// Done
+    display_caption( "Done!" );
+
+    return 0;
+}
+
+/**
+ * @function display_caption
+ */
+int display_caption( const char* caption )
+{
+    dst = Mat::zeros( src.size(), src.type() );
+    putText( dst, caption,
+             Point( src.cols/4, src.rows/2),
+             FONT_HERSHEY_COMPLEX, 1, Scalar(255, 255, 255) );
+
+    return display_dst(DELAY_CAPTION);
+}
+
+/**
+ * @function display_dst
+ */
+int display_dst( int delay )
+{
+    imshow( window_name, dst );
+    int c = waitKey ( delay );
+    if( c >= 0 ) { return -1; }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Threshold.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Threshold.cpp
new file mode 100644
index 00000000..e44291c3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Threshold.cpp
@@ -0,0 +1,87 @@
+/**
+ * @file Threshold.cpp
+ * @brief Sample code that shows how to use the diverse threshold options offered by OpenCV
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+using std::cout;
+
+/// Global variables
+
+int threshold_value = 0;
+int threshold_type = 3;
+int const max_value = 255;
+int const max_type = 4;
+int const max_binary_value = 255;
+
+Mat src, src_gray, dst;
+const char* window_name = "Threshold Demo";
+
+const char* trackbar_type = "Type: \n 0: Binary \n 1: Binary Inverted \n 2: Truncate \n 3: To Zero \n 4: To Zero Inverted";
+const char* trackbar_value = "Value";
+
+//![Threshold_Demo]
+/**
+ * @function Threshold_Demo
+ */
+static void Threshold_Demo( int, void* )
+{
+    /* 0: Binary
+     1: Binary Inverted
+     2: Threshold Truncated
+     3: Threshold to Zero
+     4: Threshold to Zero Inverted
+    */
+    threshold( src_gray, dst, threshold_value, max_binary_value, threshold_type );
+    imshow( window_name, dst );
+}
+//![Threshold_Demo]
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //! [load]
+    String imageName("stuff.jpg"); // by default
+    if (argc > 1)
+    {
+        imageName = argv[1];
+    }
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
+
+    if (src.empty())
+    {
+        cout << "Cannot read the image: " << imageName << std::endl;
+        return -1;
+    }
+
+    cvtColor( src, src_gray, COLOR_BGR2GRAY ); // Convert the image to Gray
+    //! [load]
+
+    //! [window]
+    namedWindow( window_name, WINDOW_AUTOSIZE ); // Create a window to display results
+    //! [window]
+
+    //! [trackbar]
+    createTrackbar( trackbar_type,
+                    window_name, &threshold_type,
+                    max_type, Threshold_Demo ); // Create a Trackbar to choose type of Threshold
+
+    createTrackbar( trackbar_value,
+                    window_name, &threshold_value,
+                    max_value, Threshold_Demo ); // Create a Trackbar to choose Threshold value
+    //! [trackbar]
+
+    Threshold_Demo( 0, 0 ); // Call the function to initialize
+
+    /// Wait until the user finishes the program
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Threshold_inRange.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Threshold_inRange.cpp
new file mode 100644
index 00000000..d2ced1fc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/Threshold_inRange.cpp
@@ -0,0 +1,105 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/videoio.hpp"
+#include <iostream>
+
+using namespace cv;
+
+/** Global Variables */
+const int max_value_H = 360/2;
+const int max_value = 255;
+const String window_capture_name = "Video Capture";
+const String window_detection_name = "Object Detection";
+int low_H = 0, low_S = 0, low_V = 0;
+int high_H = max_value_H, high_S = max_value, high_V = max_value;
+
+//! [low]
+static void on_low_H_thresh_trackbar(int, void *)
+{
+    low_H = min(high_H-1, low_H);
+    setTrackbarPos("Low H", window_detection_name, low_H);
+}
+//! [low]
+
+//! [high]
+static void on_high_H_thresh_trackbar(int, void *)
+{
+    high_H = max(high_H, low_H+1);
+    setTrackbarPos("High H", window_detection_name, high_H);
+}
+
+//! [high]
+static void on_low_S_thresh_trackbar(int, void *)
+{
+    low_S = min(high_S-1, low_S);
+    setTrackbarPos("Low S", window_detection_name, low_S);
+}
+
+static void on_high_S_thresh_trackbar(int, void *)
+{
+    high_S = max(high_S, low_S+1);
+    setTrackbarPos("High S", window_detection_name, high_S);
+}
+
+static void on_low_V_thresh_trackbar(int, void *)
+{
+    low_V = min(high_V-1, low_V);
+    setTrackbarPos("Low V", window_detection_name, low_V);
+}
+
+static void on_high_V_thresh_trackbar(int, void *)
+{
+    high_V = max(high_V, low_V+1);
+    setTrackbarPos("High V", window_detection_name, high_V);
+}
+
+int main(int argc, char* argv[])
+{
+    //! [cap]
+    VideoCapture cap(argc > 1 ? atoi(argv[1]) : 0);
+    //! [cap]
+
+    //! [window]
+    namedWindow(window_capture_name);
+    namedWindow(window_detection_name);
+    //! [window]
+
+    //! [trackbar]
+    // Trackbars to set thresholds for HSV values
+    createTrackbar("Low H", window_detection_name, &low_H, max_value_H, on_low_H_thresh_trackbar);
+    createTrackbar("High H", window_detection_name, &high_H, max_value_H, on_high_H_thresh_trackbar);
+    createTrackbar("Low S", window_detection_name, &low_S, max_value, on_low_S_thresh_trackbar);
+    createTrackbar("High S", window_detection_name, &high_S, max_value, on_high_S_thresh_trackbar);
+    createTrackbar("Low V", window_detection_name, &low_V, max_value, on_low_V_thresh_trackbar);
+    createTrackbar("High V", window_detection_name, &high_V, max_value, on_high_V_thresh_trackbar);
+    //! [trackbar]
+
+    Mat frame, frame_HSV, frame_threshold;
+    while (true) {
+        //! [while]
+        cap >> frame;
+        if(frame.empty())
+        {
+            break;
+        }
+
+        // Convert from BGR to HSV colorspace
+        cvtColor(frame, frame_HSV, COLOR_BGR2HSV);
+        // Detect the object based on HSV Range Values
+        inRange(frame_HSV, Scalar(low_H, low_S, low_V), Scalar(high_H, high_S, high_V), frame_threshold);
+        //! [while]
+
+        //! [show]
+        // Show the frames
+        imshow(window_capture_name, frame);
+        imshow(window_detection_name, frame_threshold);
+        //! [show]
+
+        char key = (char) waitKey(30);
+        if (key == 'q' || key == 27)
+        {
+            break;
+        }
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp
new file mode 100644
index 00000000..a402e1de
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp
@@ -0,0 +1,113 @@
+/**
+* @brief You will learn how to segment an anisotropic image with a single local orientation by a gradient structure tensor (GST)
+* @author Karpushin Vladislav, karpushin@ngs.ru, https://github.com/VladKarpushin
+*/
+
+#include <iostream>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+
+using namespace cv;
+using namespace std;
+
+//! [calcGST_proto]
+void calcGST(const Mat& inputImg, Mat& imgCoherencyOut, Mat& imgOrientationOut, int w);
+//! [calcGST_proto]
+
+int main()
+{
+    int W = 52;             // window size is WxW
+    double C_Thr = 0.43;    // threshold for coherency
+    int LowThr = 35;        // threshold1 for orientation, it ranges from 0 to 180
+    int HighThr = 57;       // threshold2 for orientation, it ranges from 0 to 180
+
+    Mat imgIn = imread("input.jpg", IMREAD_GRAYSCALE);
+    if (imgIn.empty()) //check whether the image is loaded or not
+    {
+        cout << "ERROR : Image cannot be loaded..!!" << endl;
+        return -1;
+    }
+
+    //! [main_extra]
+    //! [main]
+    Mat imgCoherency, imgOrientation;
+    calcGST(imgIn, imgCoherency, imgOrientation, W);
+
+    //! [thresholding]
+    Mat imgCoherencyBin;
+    imgCoherencyBin = imgCoherency > C_Thr;
+    Mat imgOrientationBin;
+    inRange(imgOrientation, Scalar(LowThr), Scalar(HighThr), imgOrientationBin);
+    //! [thresholding]
+
+    //! [combining]
+    Mat imgBin;
+    imgBin = imgCoherencyBin & imgOrientationBin;
+    //! [combining]
+    //! [main]
+
+    normalize(imgCoherency, imgCoherency, 0, 255, NORM_MINMAX);
+    normalize(imgOrientation, imgOrientation, 0, 255, NORM_MINMAX);
+
+    imwrite("result.jpg", 0.5*(imgIn + imgBin));
+    imwrite("Coherency.jpg", imgCoherency);
+    imwrite("Orientation.jpg", imgOrientation);
+    //! [main_extra]
+    return 0;
+}
+//! [calcGST]
+//! [calcJ_header]
+void calcGST(const Mat& inputImg, Mat& imgCoherencyOut, Mat& imgOrientationOut, int w)
+{
+    Mat img;
+    inputImg.convertTo(img, CV_32F);
+
+    // GST components calculation (start)
+    // J =  (J11 J12; J12 J22) - GST
+    Mat imgDiffX, imgDiffY, imgDiffXY;
+    Sobel(img, imgDiffX, CV_32F, 1, 0, 3);
+    Sobel(img, imgDiffY, CV_32F, 0, 1, 3);
+    multiply(imgDiffX, imgDiffY, imgDiffXY);
+    //! [calcJ_header]
+
+    Mat imgDiffXX, imgDiffYY;
+    multiply(imgDiffX, imgDiffX, imgDiffXX);
+    multiply(imgDiffY, imgDiffY, imgDiffYY);
+
+    Mat J11, J22, J12;      // J11, J22 and J12 are GST components
+    boxFilter(imgDiffXX, J11, CV_32F, Size(w, w));
+    boxFilter(imgDiffYY, J22, CV_32F, Size(w, w));
+    boxFilter(imgDiffXY, J12, CV_32F, Size(w, w));
+    // GST components calculation (stop)
+
+    // eigenvalue calculation (start)
+    // lambda1 = 0.5*(J11 + J22 + sqrt((J11-J22)^2 + 4*J12^2))
+    // lambda2 = 0.5*(J11 + J22 - sqrt((J11-J22)^2 + 4*J12^2))
+    Mat tmp1, tmp2, tmp3, tmp4;
+    tmp1 = J11 + J22;
+    tmp2 = J11 - J22;
+    multiply(tmp2, tmp2, tmp2);
+    multiply(J12, J12, tmp3);
+    sqrt(tmp2 + 4.0 * tmp3, tmp4);
+
+    Mat lambda1, lambda2;
+    lambda1 = tmp1 + tmp4;
+    lambda1 = 0.5*lambda1;      // biggest eigenvalue
+    lambda2 = tmp1 - tmp4;
+    lambda2 = 0.5*lambda2;      // smallest eigenvalue
+    // eigenvalue calculation (stop)
+
+    // Coherency calculation (start)
+    // Coherency = (lambda1 - lambda2)/(lambda1 + lambda2)) - measure of anisotropism
+    // Coherency is anisotropy degree (consistency of local orientation)
+    divide(lambda1 - lambda2, lambda1 + lambda2, imgCoherencyOut);
+    // Coherency calculation (stop)
+
+    // orientation angle calculation (start)
+    // tan(2*Alpha) = 2*J12/(J22 - J11)
+    // Alpha = 0.5 atan2(2*J12/(J22 - J11))
+    phase(J22 - J11, 2.0*J12, imgOrientationOut, true);
+    imgOrientationOut = 0.5*imgOrientationOut;
+    // orientation angle calculation (stop)
+}
+//! [calcGST]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_1.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_1.cpp
new file mode 100644
index 00000000..3f23a0b6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_1.cpp
@@ -0,0 +1,185 @@
+/**
+ * @file Drawing_1.cpp
+ * @brief Simple geometric drawing
+ * @author OpenCV team
+ */
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+#define w 400
+
+using namespace cv;
+
+/// Function headers
+void MyEllipse( Mat img, double angle );
+void MyFilledCircle( Mat img, Point center );
+void MyPolygon( Mat img );
+void MyLine( Mat img, Point start, Point end );
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( void ){
+
+  //![create_images]
+  /// Windows names
+  char atom_window[] = "Drawing 1: Atom";
+  char rook_window[] = "Drawing 2: Rook";
+
+  /// Create black empty images
+  Mat atom_image = Mat::zeros( w, w, CV_8UC3 );
+  Mat rook_image = Mat::zeros( w, w, CV_8UC3 );
+  //![create_images]
+
+  /// 1. Draw a simple atom:
+  /// -----------------------
+
+  //![draw_atom]
+  /// 1.a. Creating ellipses
+  MyEllipse( atom_image, 90 );
+  MyEllipse( atom_image, 0 );
+  MyEllipse( atom_image, 45 );
+  MyEllipse( atom_image, -45 );
+
+  /// 1.b. Creating circles
+  MyFilledCircle( atom_image, Point( w/2, w/2) );
+  //![draw_atom]
+
+  /// 2. Draw a rook
+  /// ------------------
+
+  //![draw_rook]
+  /// 2.a. Create a convex polygon
+  MyPolygon( rook_image );
+
+  //![rectangle]
+  /// 2.b. Creating rectangles
+  rectangle( rook_image,
+         Point( 0, 7*w/8 ),
+         Point( w, w),
+         Scalar( 0, 255, 255 ),
+         FILLED,
+         LINE_8 );
+  //![rectangle]
+
+  /// 2.c. Create a few lines
+  MyLine( rook_image, Point( 0, 15*w/16 ), Point( w, 15*w/16 ) );
+  MyLine( rook_image, Point( w/4, 7*w/8 ), Point( w/4, w ) );
+  MyLine( rook_image, Point( w/2, 7*w/8 ), Point( w/2, w ) );
+  MyLine( rook_image, Point( 3*w/4, 7*w/8 ), Point( 3*w/4, w ) );
+  //![draw_rook]
+
+  /// 3. Display your stuff!
+  imshow( atom_window, atom_image );
+  moveWindow( atom_window, 0, 200 );
+  imshow( rook_window, rook_image );
+  moveWindow( rook_window, w, 200 );
+
+  waitKey( 0 );
+  return(0);
+}
+
+/// Function Declaration
+
+/**
+ * @function MyEllipse
+ * @brief Draw a fixed-size ellipse with different angles
+ */
+//![my_ellipse]
+void MyEllipse( Mat img, double angle )
+{
+  int thickness = 2;
+  int lineType = 8;
+
+  ellipse( img,
+       Point( w/2, w/2 ),
+       Size( w/4, w/16 ),
+       angle,
+       0,
+       360,
+       Scalar( 255, 0, 0 ),
+       thickness,
+       lineType );
+}
+//![my_ellipse]
+
+/**
+ * @function MyFilledCircle
+ * @brief Draw a fixed-size filled circle
+ */
+//![my_filled_circle]
+void MyFilledCircle( Mat img, Point center )
+{
+  circle( img,
+      center,
+      w/32,
+      Scalar( 0, 0, 255 ),
+      FILLED,
+      LINE_8 );
+}
+//![my_filled_circle]
+
+/**
+ * @function MyPolygon
+ * @brief Draw a simple concave polygon (rook)
+ */
+//![my_polygon]
+void MyPolygon( Mat img )
+{
+  int lineType = LINE_8;
+
+  /** Create some points */
+  Point rook_points[1][20];
+  rook_points[0][0]  = Point(    w/4,   7*w/8 );
+  rook_points[0][1]  = Point(  3*w/4,   7*w/8 );
+  rook_points[0][2]  = Point(  3*w/4,  13*w/16 );
+  rook_points[0][3]  = Point( 11*w/16, 13*w/16 );
+  rook_points[0][4]  = Point( 19*w/32,  3*w/8 );
+  rook_points[0][5]  = Point(  3*w/4,   3*w/8 );
+  rook_points[0][6]  = Point(  3*w/4,     w/8 );
+  rook_points[0][7]  = Point( 26*w/40,    w/8 );
+  rook_points[0][8]  = Point( 26*w/40,    w/4 );
+  rook_points[0][9]  = Point( 22*w/40,    w/4 );
+  rook_points[0][10] = Point( 22*w/40,    w/8 );
+  rook_points[0][11] = Point( 18*w/40,    w/8 );
+  rook_points[0][12] = Point( 18*w/40,    w/4 );
+  rook_points[0][13] = Point( 14*w/40,    w/4 );
+  rook_points[0][14] = Point( 14*w/40,    w/8 );
+  rook_points[0][15] = Point(    w/4,     w/8 );
+  rook_points[0][16] = Point(    w/4,   3*w/8 );
+  rook_points[0][17] = Point( 13*w/32,  3*w/8 );
+  rook_points[0][18] = Point(  5*w/16, 13*w/16 );
+  rook_points[0][19] = Point(    w/4,  13*w/16 );
+
+  const Point* ppt[1] = { rook_points[0] };
+  int npt[] = { 20 };
+
+  fillPoly( img,
+        ppt,
+        npt,
+        1,
+        Scalar( 255, 255, 255 ),
+        lineType );
+}
+//![my_polygon]
+
+/**
+ * @function MyLine
+ * @brief Draw a simple line
+ */
+//![my_line]
+void MyLine( Mat img, Point start, Point end )
+{
+  int thickness = 2;
+  int lineType = LINE_8;
+
+  line( img,
+    start,
+    end,
+    Scalar( 0, 0, 0 ),
+    thickness,
+    lineType );
+}
+//![my_line]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_2.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_2.cpp
new file mode 100644
index 00000000..d8aeff0a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_2.cpp
@@ -0,0 +1,326 @@
+/**
+ * @file Drawing_2.cpp
+ * @brief Simple sample code
+ */
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+
+/// Global Variables
+const int NUMBER = 100;
+const int DELAY = 5;
+
+const int window_width = 900;
+const int window_height = 600;
+int x_1 = -window_width/2;
+int x_2 = window_width*3/2;
+int y_1 = -window_width/2;
+int y_2 = window_width*3/2;
+
+/// Function headers
+static Scalar randomColor( RNG& rng );
+int Drawing_Random_Lines( Mat image, char* window_name, RNG rng );
+int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng );
+int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng );
+int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng );
+int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng );
+int Drawing_Random_Circles( Mat image, char* window_name, RNG rng );
+int Displaying_Random_Text( Mat image, char* window_name, RNG rng );
+int Displaying_Big_End( Mat image, char* window_name, RNG rng );
+
+
+/**
+ * @function main
+ */
+int main( void )
+{
+  int c;
+
+  /// Start creating a window
+  char window_name[] = "Drawing_2 Tutorial";
+
+  /// Also create a random object (RNG)
+  RNG rng( 0xFFFFFFFF );
+
+  /// Initialize a matrix filled with zeros
+  Mat image = Mat::zeros( window_height, window_width, CV_8UC3 );
+  /// Show it in a window during DELAY ms
+  imshow( window_name, image );
+  waitKey( DELAY );
+
+  /// Now, let's draw some lines
+  c = Drawing_Random_Lines(image, window_name, rng);
+  if( c != 0 ) return 0;
+
+  /// Go on drawing, this time nice rectangles
+  c = Drawing_Random_Rectangles(image, window_name, rng);
+  if( c != 0 ) return 0;
+
+  /// Draw some ellipses
+  c = Drawing_Random_Ellipses( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  /// Now some polylines
+  c = Drawing_Random_Polylines( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  /// Draw filled polygons
+  c = Drawing_Random_Filled_Polygons( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  /// Draw circles
+  c = Drawing_Random_Circles( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  /// Display text in random positions
+  c = Displaying_Random_Text( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  /// Displaying the big end!
+  c = Displaying_Big_End( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  waitKey(0);
+  return 0;
+}
+
+/// Function definitions
+
+/**
+ * @function randomColor
+ * @brief Produces a random color given a random object
+ */
+static Scalar randomColor( RNG& rng )
+{
+  int icolor = (unsigned) rng;
+  return Scalar( icolor&255, (icolor>>8)&255, (icolor>>16)&255 );
+}
+
+
+/**
+ * @function Drawing_Random_Lines
+ */
+int Drawing_Random_Lines( Mat image, char* window_name, RNG rng )
+{
+  Point pt1, pt2;
+
+  for( int i = 0; i < NUMBER; i++ )
+  {
+    pt1.x = rng.uniform( x_1, x_2 );
+    pt1.y = rng.uniform( y_1, y_2 );
+    pt2.x = rng.uniform( x_1, x_2 );
+    pt2.y = rng.uniform( y_1, y_2 );
+
+    line( image, pt1, pt2, randomColor(rng), rng.uniform(1, 10), 8 );
+    imshow( window_name, image );
+    if( waitKey( DELAY ) >= 0 )
+      { return -1; }
+  }
+
+  return 0;
+}
+
+/**
+ * @function Drawing_Rectangles
+ */
+int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng )
+{
+  Point pt1, pt2;
+  int lineType = 8;
+  int thickness = rng.uniform( -3, 10 );
+
+  for( int i = 0; i < NUMBER; i++ )
+  {
+    pt1.x = rng.uniform( x_1, x_2 );
+    pt1.y = rng.uniform( y_1, y_2 );
+    pt2.x = rng.uniform( x_1, x_2 );
+    pt2.y = rng.uniform( y_1, y_2 );
+
+    rectangle( image, pt1, pt2, randomColor(rng), MAX( thickness, -1 ), lineType );
+
+    imshow( window_name, image );
+    if( waitKey( DELAY ) >= 0 )
+      { return -1; }
+  }
+
+  return 0;
+}
+
+/**
+ * @function Drawing_Random_Ellipses
+ */
+int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+
+  for ( int i = 0; i < NUMBER; i++ )
+  {
+    Point center;
+    center.x = rng.uniform(x_1, x_2);
+    center.y = rng.uniform(y_1, y_2);
+
+    Size axes;
+    axes.width = rng.uniform(0, 200);
+    axes.height = rng.uniform(0, 200);
+
+    double angle = rng.uniform(0, 180);
+
+    ellipse( image, center, axes, angle, angle - 100, angle + 200,
+             randomColor(rng), rng.uniform(-1,9), lineType );
+
+    imshow( window_name, image );
+
+    if( waitKey(DELAY) >= 0 )
+      { return -1; }
+  }
+
+  return 0;
+}
+
+/**
+ * @function Drawing_Random_Polylines
+ */
+int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+
+  for( int i = 0; i< NUMBER; i++ )
+  {
+    Point pt[2][3];
+    pt[0][0].x = rng.uniform(x_1, x_2);
+    pt[0][0].y = rng.uniform(y_1, y_2);
+    pt[0][1].x = rng.uniform(x_1, x_2);
+    pt[0][1].y = rng.uniform(y_1, y_2);
+    pt[0][2].x = rng.uniform(x_1, x_2);
+    pt[0][2].y = rng.uniform(y_1, y_2);
+    pt[1][0].x = rng.uniform(x_1, x_2);
+    pt[1][0].y = rng.uniform(y_1, y_2);
+    pt[1][1].x = rng.uniform(x_1, x_2);
+    pt[1][1].y = rng.uniform(y_1, y_2);
+    pt[1][2].x = rng.uniform(x_1, x_2);
+    pt[1][2].y = rng.uniform(y_1, y_2);
+
+    const Point* ppt[2] = {pt[0], pt[1]};
+    int npt[] = {3, 3};
+
+    polylines(image, ppt, npt, 2, true, randomColor(rng), rng.uniform(1,10), lineType);
+
+    imshow( window_name, image );
+    if( waitKey(DELAY) >= 0 )
+      { return -1; }
+  }
+  return 0;
+}
+
+/**
+ * @function Drawing_Random_Filled_Polygons
+ */
+int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+
+  for ( int i = 0; i < NUMBER; i++ )
+  {
+    Point pt[2][3];
+    pt[0][0].x = rng.uniform(x_1, x_2);
+    pt[0][0].y = rng.uniform(y_1, y_2);
+    pt[0][1].x = rng.uniform(x_1, x_2);
+    pt[0][1].y = rng.uniform(y_1, y_2);
+    pt[0][2].x = rng.uniform(x_1, x_2);
+    pt[0][2].y = rng.uniform(y_1, y_2);
+    pt[1][0].x = rng.uniform(x_1, x_2);
+    pt[1][0].y = rng.uniform(y_1, y_2);
+    pt[1][1].x = rng.uniform(x_1, x_2);
+    pt[1][1].y = rng.uniform(y_1, y_2);
+    pt[1][2].x = rng.uniform(x_1, x_2);
+    pt[1][2].y = rng.uniform(y_1, y_2);
+
+    const Point* ppt[2] = {pt[0], pt[1]};
+    int npt[] = {3, 3};
+
+    fillPoly( image, ppt, npt, 2, randomColor(rng), lineType );
+
+    imshow( window_name, image );
+    if( waitKey(DELAY) >= 0 )
+       { return -1; }
+  }
+  return 0;
+}
+
+/**
+ * @function Drawing_Random_Circles
+ */
+int Drawing_Random_Circles( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+
+  for (int i = 0; i < NUMBER; i++)
+  {
+    Point center;
+    center.x = rng.uniform(x_1, x_2);
+    center.y = rng.uniform(y_1, y_2);
+
+    circle( image, center, rng.uniform(0, 300), randomColor(rng),
+            rng.uniform(-1, 9), lineType );
+
+    imshow( window_name, image );
+    if( waitKey(DELAY) >= 0 )
+      { return -1; }
+  }
+
+  return 0;
+}
+
+/**
+ * @function Displaying_Random_Text
+ */
+int Displaying_Random_Text( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+
+  for ( int i = 1; i < NUMBER; i++ )
+  {
+    Point org;
+    org.x = rng.uniform(x_1, x_2);
+    org.y = rng.uniform(y_1, y_2);
+
+    putText( image, "Testing text rendering", org, rng.uniform(0,8),
+             rng.uniform(0,100)*0.05+0.1, randomColor(rng), rng.uniform(1, 10), lineType);
+
+    imshow( window_name, image );
+    if( waitKey(DELAY) >= 0 )
+      { return -1; }
+  }
+
+  return 0;
+}
+
+/**
+ * @function Displaying_Big_End
+ */
+int Displaying_Big_End( Mat image, char* window_name, RNG )
+{
+  Size textsize = getTextSize("OpenCV forever!", FONT_HERSHEY_COMPLEX, 3, 5, 0);
+  Point org((window_width - textsize.width)/2, (window_height - textsize.height)/2);
+  int lineType = 8;
+
+  Mat image2;
+
+  for( int i = 0; i < 255; i += 2 )
+  {
+    image2 = image - Scalar::all(i);
+    putText( image2, "OpenCV forever!", org, FONT_HERSHEY_COMPLEX, 3,
+             Scalar(i, i, 255), 5, lineType );
+
+    imshow( window_name, image2 );
+    if( waitKey(DELAY) >= 0 )
+       { return -1; }
+  }
+
+  return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/changing_contrast_brightness_image/changing_contrast_brightness_image.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/changing_contrast_brightness_image/changing_contrast_brightness_image.cpp
new file mode 100644
index 00000000..51936c4b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/changing_contrast_brightness_image/changing_contrast_brightness_image.cpp
@@ -0,0 +1,98 @@
+#include <iostream>
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+// we're NOT "using namespace std;" here, to avoid collisions between the beta variable and std::beta in c++17
+using std::cout;
+using std::endl;
+using namespace cv;
+
+namespace
+{
+/** Global Variables */
+int alpha = 100;
+int beta = 100;
+int gamma_cor = 100;
+Mat img_original, img_corrected, img_gamma_corrected;
+
+void basicLinearTransform(const Mat &img, const double alpha_, const int beta_)
+{
+    Mat res;
+    img.convertTo(res, -1, alpha_, beta_);
+
+    hconcat(img, res, img_corrected);
+    imshow("Brightness and contrast adjustments", img_corrected);
+}
+
+void gammaCorrection(const Mat &img, const double gamma_)
+{
+    CV_Assert(gamma_ >= 0);
+    //! [changing-contrast-brightness-gamma-correction]
+    Mat lookUpTable(1, 256, CV_8U);
+    uchar* p = lookUpTable.ptr();
+    for( int i = 0; i < 256; ++i)
+        p[i] = saturate_cast<uchar>(pow(i / 255.0, gamma_) * 255.0);
+
+    Mat res = img.clone();
+    LUT(img, lookUpTable, res);
+    //! [changing-contrast-brightness-gamma-correction]
+
+    hconcat(img, res, img_gamma_corrected);
+    imshow("Gamma correction", img_gamma_corrected);
+}
+
+void on_linear_transform_alpha_trackbar(int, void *)
+{
+    double alpha_value = alpha / 100.0;
+    int beta_value = beta - 100;
+    basicLinearTransform(img_original, alpha_value, beta_value);
+}
+
+void on_linear_transform_beta_trackbar(int, void *)
+{
+    double alpha_value = alpha / 100.0;
+    int beta_value = beta - 100;
+    basicLinearTransform(img_original, alpha_value, beta_value);
+}
+
+void on_gamma_correction_trackbar(int, void *)
+{
+    double gamma_value = gamma_cor / 100.0;
+    gammaCorrection(img_original, gamma_value);
+}
+}
+
+int main( int argc, char** argv )
+{
+    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
+    img_original = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if( img_original.empty() )
+    {
+      cout << "Could not open or find the image!\n" << endl;
+      cout << "Usage: " << argv[0] << " <Input image>" << endl;
+      return -1;
+    }
+
+    img_corrected = Mat(img_original.rows, img_original.cols*2, img_original.type());
+    img_gamma_corrected = Mat(img_original.rows, img_original.cols*2, img_original.type());
+
+    hconcat(img_original, img_original, img_corrected);
+    hconcat(img_original, img_original, img_gamma_corrected);
+
+    namedWindow("Brightness and contrast adjustments");
+    namedWindow("Gamma correction");
+
+    createTrackbar("Alpha gain (contrast)", "Brightness and contrast adjustments", &alpha, 500, on_linear_transform_alpha_trackbar);
+    createTrackbar("Beta bias (brightness)", "Brightness and contrast adjustments", &beta, 200, on_linear_transform_beta_trackbar);
+    createTrackbar("Gamma correction", "Gamma correction", &gamma_cor, 200, on_gamma_correction_trackbar);
+
+    on_linear_transform_alpha_trackbar(0, 0);
+    on_gamma_correction_trackbar(0, 0);
+
+    waitKey();
+
+    imwrite("linear_transform_correction.png", img_corrected);
+    imwrite("gamma_correction.png", img_gamma_corrected);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/morph_lines_detection/Morphology_3.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/morph_lines_detection/Morphology_3.cpp
new file mode 100644
index 00000000..9a909de9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/morph_lines_detection/Morphology_3.cpp
@@ -0,0 +1,139 @@
+/**
+ * @file Morphology_3(Extract_Lines).cpp
+ * @brief Use morphology transformations for extracting horizontal and vertical lines sample code
+ * @author OpenCV team
+ */
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+void show_wait_destroy(const char* winname, cv::Mat img);
+
+using namespace std;
+using namespace cv;
+
+int main(int argc, char** argv)
+{
+    //! [load_image]
+    CommandLineParser parser(argc, argv, "{@input | notes.png | input image}");
+    Mat src = imread( samples::findFile( parser.get<String>("@input") ), IMREAD_COLOR);
+    if (src.empty())
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+
+    // Show source image
+    imshow("src", src);
+    //! [load_image]
+
+    //! [gray]
+    // Transform source image to gray if it is not already
+    Mat gray;
+
+    if (src.channels() == 3)
+    {
+        cvtColor(src, gray, COLOR_BGR2GRAY);
+    }
+    else
+    {
+        gray = src;
+    }
+
+    // Show gray image
+    show_wait_destroy("gray", gray);
+    //! [gray]
+
+    //! [bin]
+    // Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
+    Mat bw;
+    adaptiveThreshold(~gray, bw, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 15, -2);
+
+    // Show binary image
+    show_wait_destroy("binary", bw);
+    //! [bin]
+
+    //! [init]
+    // Create the images that will use to extract the horizontal and vertical lines
+    Mat horizontal = bw.clone();
+    Mat vertical = bw.clone();
+    //! [init]
+
+    //! [horiz]
+    // Specify size on horizontal axis
+    int horizontal_size = horizontal.cols / 30;
+
+    // Create structure element for extracting horizontal lines through morphology operations
+    Mat horizontalStructure = getStructuringElement(MORPH_RECT, Size(horizontal_size, 1));
+
+    // Apply morphology operations
+    erode(horizontal, horizontal, horizontalStructure, Point(-1, -1));
+    dilate(horizontal, horizontal, horizontalStructure, Point(-1, -1));
+
+    // Show extracted horizontal lines
+    show_wait_destroy("horizontal", horizontal);
+    //! [horiz]
+
+    //! [vert]
+    // Specify size on vertical axis
+    int vertical_size = vertical.rows / 30;
+
+    // Create structure element for extracting vertical lines through morphology operations
+    Mat verticalStructure = getStructuringElement(MORPH_RECT, Size(1, vertical_size));
+
+    // Apply morphology operations
+    erode(vertical, vertical, verticalStructure, Point(-1, -1));
+    dilate(vertical, vertical, verticalStructure, Point(-1, -1));
+
+    // Show extracted vertical lines
+    show_wait_destroy("vertical", vertical);
+    //! [vert]
+
+    //! [smooth]
+    // Inverse vertical image
+    bitwise_not(vertical, vertical);
+    show_wait_destroy("vertical_bit", vertical);
+
+    // Extract edges and smooth image according to the logic
+    // 1. extract edges
+    // 2. dilate(edges)
+    // 3. src.copyTo(smooth)
+    // 4. blur smooth img
+    // 5. smooth.copyTo(src, edges)
+
+    // Step 1
+    Mat edges;
+    adaptiveThreshold(vertical, edges, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 3, -2);
+    show_wait_destroy("edges", edges);
+
+    // Step 2
+    Mat kernel = Mat::ones(2, 2, CV_8UC1);
+    dilate(edges, edges, kernel);
+    show_wait_destroy("dilate", edges);
+
+    // Step 3
+    Mat smooth;
+    vertical.copyTo(smooth);
+
+    // Step 4
+    blur(smooth, smooth, Size(2, 2));
+
+    // Step 5
+    smooth.copyTo(vertical, edges);
+
+    // Show final result
+    show_wait_destroy("smooth - final", vertical);
+    //! [smooth]
+
+    return 0;
+}
+
+void show_wait_destroy(const char* winname, cv::Mat img) {
+    imshow(winname, img);
+    moveWindow(winname, 500, 0);
+    waitKey(0);
+    destroyWindow(winname);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/motion_deblur_filter/motion_deblur_filter.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/motion_deblur_filter/motion_deblur_filter.cpp
new file mode 100644
index 00000000..f1ea892c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/motion_deblur_filter/motion_deblur_filter.cpp
@@ -0,0 +1,184 @@
+/**
+* @brief You will learn how to recover an image with motion blur distortion using a Wiener filter
+* @author Karpushin Vladislav, karpushin@ngs.ru, https://github.com/VladKarpushin
+*/
+#include <iostream>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+
+using namespace cv;
+using namespace std;
+
+void help();
+void calcPSF(Mat& outputImg, Size filterSize, int len, double theta);
+void fftshift(const Mat& inputImg, Mat& outputImg);
+void filter2DFreq(const Mat& inputImg, Mat& outputImg, const Mat& H);
+void calcWnrFilter(const Mat& input_h_PSF, Mat& output_G, double nsr);
+void edgetaper(const Mat& inputImg, Mat& outputImg, double gamma = 5.0, double beta = 0.2);
+
+const String keys =
+"{help h usage ? |             | print this message				}"
+"{image          |input.png    | input image name				}"
+"{LEN            |125          | length of a motion				}"
+"{THETA          |0            | angle of a motion in degrees	}"
+"{SNR            |700          | signal to noise ratio			}"
+;
+
+int main(int argc, char *argv[])
+{
+    help();
+    CommandLineParser parser(argc, argv, keys);
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    int LEN = parser.get<int>("LEN");
+    double THETA = parser.get<double>("THETA");
+    int snr = parser.get<int>("SNR");
+    string strInFileName = parser.get<String>("image");
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 0;
+    }
+
+    Mat imgIn;
+    imgIn = imread(strInFileName, IMREAD_GRAYSCALE);
+    if (imgIn.empty()) //check whether the image is loaded or not
+    {
+        cout << "ERROR : Image cannot be loaded..!!" << endl;
+        return -1;
+    }
+
+    Mat imgOut;
+
+//! [main]
+    // it needs to process even image only
+    Rect roi = Rect(0, 0, imgIn.cols & -2, imgIn.rows & -2);
+
+    //Hw calculation (start)
+    Mat Hw, h;
+    calcPSF(h, roi.size(), LEN, THETA);
+    calcWnrFilter(h, Hw, 1.0 / double(snr));
+    //Hw calculation (stop)
+
+    imgIn.convertTo(imgIn, CV_32F);
+    edgetaper(imgIn, imgIn);
+
+    // filtering (start)
+    filter2DFreq(imgIn(roi), imgOut, Hw);
+    // filtering (stop)
+//! [main]
+
+    imgOut.convertTo(imgOut, CV_8U);
+    normalize(imgOut, imgOut, 0, 255, NORM_MINMAX);
+    imwrite("result.jpg", imgOut);
+    return 0;
+}
+
+void help()
+{
+    cout << "2018-08-14" << endl;
+    cout << "Motion_deblur_v2" << endl;
+    cout << "You will learn how to recover an image with motion blur distortion using a Wiener filter" << endl;
+}
+
+//! [calcPSF]
+void calcPSF(Mat& outputImg, Size filterSize, int len, double theta)
+{
+    Mat h(filterSize, CV_32F, Scalar(0));
+    Point point(filterSize.width / 2, filterSize.height / 2);
+    ellipse(h, point, Size(0, cvRound(float(len) / 2.0)), 90.0 - theta, 0, 360, Scalar(255), FILLED);
+    Scalar summa = sum(h);
+    outputImg = h / summa[0];
+}
+//! [calcPSF]
+
+//! [fftshift]
+void fftshift(const Mat& inputImg, Mat& outputImg)
+{
+    outputImg = inputImg.clone();
+    int cx = outputImg.cols / 2;
+    int cy = outputImg.rows / 2;
+    Mat q0(outputImg, Rect(0, 0, cx, cy));
+    Mat q1(outputImg, Rect(cx, 0, cx, cy));
+    Mat q2(outputImg, Rect(0, cy, cx, cy));
+    Mat q3(outputImg, Rect(cx, cy, cx, cy));
+    Mat tmp;
+    q0.copyTo(tmp);
+    q3.copyTo(q0);
+    tmp.copyTo(q3);
+    q1.copyTo(tmp);
+    q2.copyTo(q1);
+    tmp.copyTo(q2);
+}
+//! [fftshift]
+
+//! [filter2DFreq]
+void filter2DFreq(const Mat& inputImg, Mat& outputImg, const Mat& H)
+{
+    Mat planes[2] = { Mat_<float>(inputImg.clone()), Mat::zeros(inputImg.size(), CV_32F) };
+    Mat complexI;
+    merge(planes, 2, complexI);
+    dft(complexI, complexI, DFT_SCALE);
+
+    Mat planesH[2] = { Mat_<float>(H.clone()), Mat::zeros(H.size(), CV_32F) };
+    Mat complexH;
+    merge(planesH, 2, complexH);
+    Mat complexIH;
+    mulSpectrums(complexI, complexH, complexIH, 0);
+
+    idft(complexIH, complexIH);
+    split(complexIH, planes);
+    outputImg = planes[0];
+}
+//! [filter2DFreq]
+
+//! [calcWnrFilter]
+void calcWnrFilter(const Mat& input_h_PSF, Mat& output_G, double nsr)
+{
+    Mat h_PSF_shifted;
+    fftshift(input_h_PSF, h_PSF_shifted);
+    Mat planes[2] = { Mat_<float>(h_PSF_shifted.clone()), Mat::zeros(h_PSF_shifted.size(), CV_32F) };
+    Mat complexI;
+    merge(planes, 2, complexI);
+    dft(complexI, complexI);
+    split(complexI, planes);
+    Mat denom;
+    pow(abs(planes[0]), 2, denom);
+    denom += nsr;
+    divide(planes[0], denom, output_G);
+}
+//! [calcWnrFilter]
+
+//! [edgetaper]
+void edgetaper(const Mat& inputImg, Mat& outputImg, double gamma, double beta)
+{
+    int Nx = inputImg.cols;
+    int Ny = inputImg.rows;
+    Mat w1(1, Nx, CV_32F, Scalar(0));
+    Mat w2(Ny, 1, CV_32F, Scalar(0));
+
+    float* p1 = w1.ptr<float>(0);
+    float* p2 = w2.ptr<float>(0);
+    float dx = float(2.0 * CV_PI / Nx);
+    float x = float(-CV_PI);
+    for (int i = 0; i < Nx; i++)
+    {
+        p1[i] = float(0.5 * (tanh((x + gamma / 2) / beta) - tanh((x - gamma / 2) / beta)));
+        x += dx;
+    }
+    float dy = float(2.0 * CV_PI / Ny);
+    float y = float(-CV_PI);
+    for (int i = 0; i < Ny; i++)
+    {
+        p2[i] = float(0.5 * (tanh((y + gamma / 2) / beta) - tanh((y - gamma / 2) / beta)));
+        y += dy;
+    }
+    Mat w = w2 * w1;
+    multiply(inputImg, w, outputImg);
+}
+//! [edgetaper]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/out_of_focus_deblur_filter/out_of_focus_deblur_filter.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/out_of_focus_deblur_filter/out_of_focus_deblur_filter.cpp
new file mode 100644
index 00000000..059df8bd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/out_of_focus_deblur_filter/out_of_focus_deblur_filter.cpp
@@ -0,0 +1,149 @@
+/**
+* @brief You will learn how to recover an out-of-focus image by Wiener filter
+* @author Karpushin Vladislav, karpushin@ngs.ru, https://github.com/VladKarpushin
+*/
+#include <iostream>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+
+using namespace cv;
+using namespace std;
+
+void help();
+void calcPSF(Mat& outputImg, Size filterSize, int R);
+void fftshift(const Mat& inputImg, Mat& outputImg);
+void filter2DFreq(const Mat& inputImg, Mat& outputImg, const Mat& H);
+void calcWnrFilter(const Mat& input_h_PSF, Mat& output_G, double nsr);
+
+const String keys =
+"{help h usage ? |             | print this message   }"
+"{image          |original.JPG | input image name     }"
+"{R              |53           | radius               }"
+"{SNR            |5200         | signal to noise ratio}"
+;
+
+int main(int argc, char *argv[])
+{
+    help();
+    CommandLineParser parser(argc, argv, keys);
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    int R = parser.get<int>("R");
+    int snr = parser.get<int>("SNR");
+    string strInFileName = parser.get<String>("image");
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 0;
+    }
+
+    Mat imgIn;
+    imgIn = imread(strInFileName, IMREAD_GRAYSCALE);
+    if (imgIn.empty()) //check whether the image is loaded or not
+    {
+        cout << "ERROR : Image cannot be loaded..!!" << endl;
+        return -1;
+    }
+
+    Mat imgOut;
+
+//! [main]
+    // it needs to process even image only
+    Rect roi = Rect(0, 0, imgIn.cols & -2, imgIn.rows & -2);
+
+    //Hw calculation (start)
+    Mat Hw, h;
+    calcPSF(h, roi.size(), R);
+    calcWnrFilter(h, Hw, 1.0 / double(snr));
+    //Hw calculation (stop)
+
+    // filtering (start)
+    filter2DFreq(imgIn(roi), imgOut, Hw);
+    // filtering (stop)
+//! [main]
+
+    imgOut.convertTo(imgOut, CV_8U);
+    normalize(imgOut, imgOut, 0, 255, NORM_MINMAX);
+    imwrite("result.jpg", imgOut);
+    return 0;
+}
+
+void help()
+{
+    cout << "2018-07-12" << endl;
+    cout << "DeBlur_v8" << endl;
+    cout << "You will learn how to recover an out-of-focus image by Wiener filter" << endl;
+}
+
+//! [calcPSF]
+void calcPSF(Mat& outputImg, Size filterSize, int R)
+{
+    Mat h(filterSize, CV_32F, Scalar(0));
+    Point point(filterSize.width / 2, filterSize.height / 2);
+    circle(h, point, R, 255, -1, 8);
+    Scalar summa = sum(h);
+    outputImg = h / summa[0];
+}
+//! [calcPSF]
+
+//! [fftshift]
+void fftshift(const Mat& inputImg, Mat& outputImg)
+{
+    outputImg = inputImg.clone();
+    int cx = outputImg.cols / 2;
+    int cy = outputImg.rows / 2;
+    Mat q0(outputImg, Rect(0, 0, cx, cy));
+    Mat q1(outputImg, Rect(cx, 0, cx, cy));
+    Mat q2(outputImg, Rect(0, cy, cx, cy));
+    Mat q3(outputImg, Rect(cx, cy, cx, cy));
+    Mat tmp;
+    q0.copyTo(tmp);
+    q3.copyTo(q0);
+    tmp.copyTo(q3);
+    q1.copyTo(tmp);
+    q2.copyTo(q1);
+    tmp.copyTo(q2);
+}
+//! [fftshift]
+
+//! [filter2DFreq]
+void filter2DFreq(const Mat& inputImg, Mat& outputImg, const Mat& H)
+{
+    Mat planes[2] = { Mat_<float>(inputImg.clone()), Mat::zeros(inputImg.size(), CV_32F) };
+    Mat complexI;
+    merge(planes, 2, complexI);
+    dft(complexI, complexI, DFT_SCALE);
+
+    Mat planesH[2] = { Mat_<float>(H.clone()), Mat::zeros(H.size(), CV_32F) };
+    Mat complexH;
+    merge(planesH, 2, complexH);
+    Mat complexIH;
+    mulSpectrums(complexI, complexH, complexIH, 0);
+
+    idft(complexIH, complexIH);
+    split(complexIH, planes);
+    outputImg = planes[0];
+}
+//! [filter2DFreq]
+
+//! [calcWnrFilter]
+void calcWnrFilter(const Mat& input_h_PSF, Mat& output_G, double nsr)
+{
+    Mat h_PSF_shifted;
+    fftshift(input_h_PSF, h_PSF_shifted);
+    Mat planes[2] = { Mat_<float>(h_PSF_shifted.clone()), Mat::zeros(h_PSF_shifted.size(), CV_32F) };
+    Mat complexI;
+    merge(planes, 2, complexI);
+    dft(complexI, complexI);
+    split(complexI, planes);
+    Mat denom;
+    pow(abs(planes[0]), 2, denom);
+    denom += nsr;
+    divide(planes[0], denom, output_G);
+}
+//! [calcWnrFilter]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/periodic_noise_removing_filter/periodic_noise_removing_filter.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/periodic_noise_removing_filter/periodic_noise_removing_filter.cpp
new file mode 100644
index 00000000..0f49b698
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgProc/periodic_noise_removing_filter/periodic_noise_removing_filter.cpp
@@ -0,0 +1,148 @@
+/**
+* @brief You will learn how to remove periodic noise in the Fourier domain
+* @author Karpushin Vladislav, karpushin@ngs.ru, https://github.com/VladKarpushin
+*/
+#include <iostream>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+
+using namespace cv;
+using namespace std;
+
+void fftshift(const Mat& inputImg, Mat& outputImg);
+void filter2DFreq(const Mat& inputImg, Mat& outputImg, const Mat& H);
+void synthesizeFilterH(Mat& inputOutput_H, Point center, int radius);
+void calcPSD(const Mat& inputImg, Mat& outputImg, int flag = 0);
+
+int main()
+{
+    Mat imgIn = imread("input.jpg", IMREAD_GRAYSCALE);
+    if (imgIn.empty()) //check whether the image is loaded or not
+    {
+        cout << "ERROR : Image cannot be loaded..!!" << endl;
+        return -1;
+    }
+
+    imgIn.convertTo(imgIn, CV_32F);
+
+//! [main]
+    // it needs to process even image only
+    Rect roi = Rect(0, 0, imgIn.cols & -2, imgIn.rows & -2);
+    imgIn = imgIn(roi);
+
+    // PSD calculation (start)
+    Mat imgPSD;
+    calcPSD(imgIn, imgPSD);
+    fftshift(imgPSD, imgPSD);
+    normalize(imgPSD, imgPSD, 0, 255, NORM_MINMAX);
+    // PSD calculation (stop)
+
+    //H calculation (start)
+    Mat H = Mat(roi.size(), CV_32F, Scalar(1));
+    const int r = 21;
+    synthesizeFilterH(H, Point(705, 458), r);
+    synthesizeFilterH(H, Point(850, 391), r);
+    synthesizeFilterH(H, Point(993, 325), r);
+    //H calculation (stop)
+    // filtering (start)
+    Mat imgOut;
+    fftshift(H, H);
+    filter2DFreq(imgIn, imgOut, H);
+    // filtering (stop)
+//! [main]
+
+    imgOut.convertTo(imgOut, CV_8U);
+    normalize(imgOut, imgOut, 0, 255, NORM_MINMAX);
+    imwrite("result.jpg", imgOut);
+    imwrite("PSD.jpg", imgPSD);
+    fftshift(H, H);
+    normalize(H, H, 0, 255, NORM_MINMAX);
+    imwrite("filter.jpg", H);
+    return 0;
+}
+
+//! [fftshift]
+void fftshift(const Mat& inputImg, Mat& outputImg)
+{
+    outputImg = inputImg.clone();
+    int cx = outputImg.cols / 2;
+    int cy = outputImg.rows / 2;
+    Mat q0(outputImg, Rect(0, 0, cx, cy));
+    Mat q1(outputImg, Rect(cx, 0, cx, cy));
+    Mat q2(outputImg, Rect(0, cy, cx, cy));
+    Mat q3(outputImg, Rect(cx, cy, cx, cy));
+    Mat tmp;
+    q0.copyTo(tmp);
+    q3.copyTo(q0);
+    tmp.copyTo(q3);
+    q1.copyTo(tmp);
+    q2.copyTo(q1);
+    tmp.copyTo(q2);
+}
+//! [fftshift]
+
+//! [filter2DFreq]
+void filter2DFreq(const Mat& inputImg, Mat& outputImg, const Mat& H)
+{
+    Mat planes[2] = { Mat_<float>(inputImg.clone()), Mat::zeros(inputImg.size(), CV_32F) };
+    Mat complexI;
+    merge(planes, 2, complexI);
+    dft(complexI, complexI, DFT_SCALE);
+
+    Mat planesH[2] = { Mat_<float>(H.clone()), Mat::zeros(H.size(), CV_32F) };
+    Mat complexH;
+    merge(planesH, 2, complexH);
+    Mat complexIH;
+    mulSpectrums(complexI, complexH, complexIH, 0);
+
+    idft(complexIH, complexIH);
+    split(complexIH, planes);
+    outputImg = planes[0];
+}
+//! [filter2DFreq]
+
+//! [synthesizeFilterH]
+void synthesizeFilterH(Mat& inputOutput_H, Point center, int radius)
+{
+    Point c2 = center, c3 = center, c4 = center;
+    c2.y = inputOutput_H.rows - center.y;
+    c3.x = inputOutput_H.cols - center.x;
+    c4 = Point(c3.x,c2.y);
+    circle(inputOutput_H, center, radius, 0, -1, 8);
+    circle(inputOutput_H, c2, radius, 0, -1, 8);
+    circle(inputOutput_H, c3, radius, 0, -1, 8);
+    circle(inputOutput_H, c4, radius, 0, -1, 8);
+}
+//! [synthesizeFilterH]
+
+// Function calculates PSD(Power spectrum density) by fft with two flags
+// flag = 0 means to return PSD
+// flag = 1 means to return log(PSD)
+//! [calcPSD]
+void calcPSD(const Mat& inputImg, Mat& outputImg, int flag)
+{
+    Mat planes[2] = { Mat_<float>(inputImg.clone()), Mat::zeros(inputImg.size(), CV_32F) };
+    Mat complexI;
+    merge(planes, 2, complexI);
+    dft(complexI, complexI);
+    split(complexI, planes);            // planes[0] = Re(DFT(I)), planes[1] = Im(DFT(I))
+
+    planes[0].at<float>(0) = 0;
+    planes[1].at<float>(0) = 0;
+
+    // compute the PSD = sqrt(Re(DFT(I))^2 + Im(DFT(I))^2)^2
+    Mat imgPSD;
+    magnitude(planes[0], planes[1], imgPSD);		//imgPSD = sqrt(Power spectrum density)
+    pow(imgPSD, 2, imgPSD);							//it needs ^2 in order to get PSD
+    outputImg = imgPSD;
+
+    // logPSD = log(1 + PSD)
+    if (flag)
+    {
+        Mat imglogPSD;
+        imglogPSD = imgPSD + Scalar::all(1);
+        log(imglogPSD, imglogPSD);
+        outputImg = imglogPSD;
+    }
+}
+//! [calcPSD]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp
new file mode 100644
index 00000000..0ac1a969
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp
@@ -0,0 +1,97 @@
+/**
+ * @file CannyDetector_Demo.cpp
+ * @brief Sample code showing how to detect edges using the Canny Detector
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+
+//![variables]
+Mat src, src_gray;
+Mat dst, detected_edges;
+
+int lowThreshold = 0;
+const int max_lowThreshold = 100;
+const int ratio = 3;
+const int kernel_size = 3;
+const char* window_name = "Edge Map";
+//![variables]
+
+/**
+ * @function CannyThreshold
+ * @brief Trackbar callback - Canny thresholds input with a ratio 1:3
+ */
+static void CannyThreshold(int, void*)
+{
+    //![reduce_noise]
+    /// Reduce noise with a kernel 3x3
+    blur( src_gray, detected_edges, Size(3,3) );
+    //![reduce_noise]
+
+    //![canny]
+    /// Canny detector
+    Canny( detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size );
+    //![canny]
+
+    /// Using Canny's output as a mask, we display our result
+    //![fill]
+    dst = Scalar::all(0);
+    //![fill]
+
+    //![copyto]
+    src.copyTo( dst, detected_edges);
+    //![copyto]
+
+    //![display]
+    imshow( window_name, dst );
+    //![display]
+}
+
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  //![load]
+  CommandLineParser parser( argc, argv, "{@input | fruits.jpg | input image}" );
+  src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR ); // Load an image
+
+  if( src.empty() )
+  {
+    std::cout << "Could not open or find the image!\n" << std::endl;
+    std::cout << "Usage: " << argv[0] << " <Input image>" << std::endl;
+    return -1;
+  }
+  //![load]
+
+  //![create_mat]
+  /// Create a matrix of the same type and size as src (for dst)
+  dst.create( src.size(), src.type() );
+  //![create_mat]
+
+  //![convert_to_gray]
+  cvtColor( src, src_gray, COLOR_BGR2GRAY );
+  //![convert_to_gray]
+
+  //![create_window]
+  namedWindow( window_name, WINDOW_AUTOSIZE );
+  //![create_window]
+
+  //![create_trackbar]
+  /// Create a Trackbar for user to enter threshold
+  createTrackbar( "Min Threshold:", window_name, &lowThreshold, max_lowThreshold, CannyThreshold );
+  //![create_trackbar]
+
+  /// Show the image
+  CannyThreshold(0, 0);
+
+  /// Wait until user exit program by pressing a key
+  waitKey(0);
+
+  return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp
new file mode 100644
index 00000000..65ca1847
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp
@@ -0,0 +1,82 @@
+/**
+ * @function Geometric_Transforms_Demo.cpp
+ * @brief Demo code for Geometric Transforms
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //! [Load the image]
+    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    //! [Load the image]
+
+    //! [Set your 3 points to calculate the  Affine Transform]
+    Point2f srcTri[3];
+    srcTri[0] = Point2f( 0.f, 0.f );
+    srcTri[1] = Point2f( src.cols - 1.f, 0.f );
+    srcTri[2] = Point2f( 0.f, src.rows - 1.f );
+
+    Point2f dstTri[3];
+    dstTri[0] = Point2f( 0.f, src.rows*0.33f );
+    dstTri[1] = Point2f( src.cols*0.85f, src.rows*0.25f );
+    dstTri[2] = Point2f( src.cols*0.15f, src.rows*0.7f );
+    //! [Set your 3 points to calculate the  Affine Transform]
+
+    //! [Get the Affine Transform]
+    Mat warp_mat = getAffineTransform( srcTri, dstTri );
+    //! [Get the Affine Transform]
+
+    //! [Apply the Affine Transform just found to the src image]
+    /// Set the dst image the same type and size as src
+    Mat warp_dst = Mat::zeros( src.rows, src.cols, src.type() );
+
+    warpAffine( src, warp_dst, warp_mat, warp_dst.size() );
+    //! [Apply the Affine Transform just found to the src image]
+
+    /** Rotating the image after Warp */
+
+    //! [Compute a rotation matrix with respect to the center of the image]
+    Point center = Point( warp_dst.cols/2, warp_dst.rows/2 );
+    double angle = -50.0;
+    double scale = 0.6;
+    //! [Compute a rotation matrix with respect to the center of the image]
+
+    //! [Get the rotation matrix with the specifications above]
+    Mat rot_mat = getRotationMatrix2D( center, angle, scale );
+    //! [Get the rotation matrix with the specifications above]
+
+    //! [Rotate the warped image]
+    Mat warp_rotate_dst;
+    warpAffine( warp_dst, warp_rotate_dst, rot_mat, warp_dst.size() );
+    //! [Rotate the warped image]
+
+    //! [Show what you got]
+    imshow( "Source image", src );
+    imshow( "Warp", warp_dst );
+    imshow( "Warp + Rotate", warp_rotate_dst );
+    //! [Show what you got]
+
+    //! [Wait until user exits the program]
+    waitKey();
+    //! [Wait until user exits the program]
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp
new file mode 100644
index 00000000..ea081f49
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp
@@ -0,0 +1,106 @@
+/**
+ * @file HoughCircle_Demo.cpp
+ * @brief Demo code for Hough Transform
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+namespace
+{
+    // windows and trackbars name
+    const std::string windowName = "Hough Circle Detection Demo";
+    const std::string cannyThresholdTrackbarName = "Canny threshold";
+    const std::string accumulatorThresholdTrackbarName = "Accumulator Threshold";
+
+    // initial and max values of the parameters of interests.
+    const int cannyThresholdInitialValue = 100;
+    const int accumulatorThresholdInitialValue = 50;
+    const int maxAccumulatorThreshold = 200;
+    const int maxCannyThreshold = 255;
+
+    void HoughDetection(const Mat& src_gray, const Mat& src_display, int cannyThreshold, int accumulatorThreshold)
+    {
+        // will hold the results of the detection
+        std::vector<Vec3f> circles;
+        // runs the actual detection
+        HoughCircles( src_gray, circles, HOUGH_GRADIENT, 1, src_gray.rows/8, cannyThreshold, accumulatorThreshold, 0, 0 );
+
+        // clone the colour, input image for displaying purposes
+        Mat display = src_display.clone();
+        for( size_t i = 0; i < circles.size(); i++ )
+        {
+            Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
+            int radius = cvRound(circles[i][2]);
+            // circle center
+            circle( display, center, 3, Scalar(0,255,0), -1, 8, 0 );
+            // circle outline
+            circle( display, center, radius, Scalar(0,0,255), 3, 8, 0 );
+        }
+
+        // shows the results
+        imshow( windowName, display);
+    }
+}
+
+
+int main(int argc, char** argv)
+{
+    Mat src, src_gray;
+
+    // Read the image
+    String imageName("stuff.jpg"); // by default
+    if (argc > 1)
+    {
+       imageName = argv[1];
+    }
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR );
+
+    if( src.empty() )
+    {
+        std::cerr << "Invalid input image\n";
+        std::cout << "Usage : " << argv[0] << " <path_to_input_image>\n";;
+        return -1;
+    }
+
+    // Convert it to gray
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+
+    // Reduce the noise so we avoid false circle detection
+    GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );
+
+    //declare and initialize both parameters that are subjects to change
+    int cannyThreshold = cannyThresholdInitialValue;
+    int accumulatorThreshold = accumulatorThresholdInitialValue;
+
+    // create the main window, and attach the trackbars
+    namedWindow( windowName, WINDOW_AUTOSIZE );
+    createTrackbar(cannyThresholdTrackbarName, windowName, &cannyThreshold,maxCannyThreshold);
+    createTrackbar(accumulatorThresholdTrackbarName, windowName, &accumulatorThreshold, maxAccumulatorThreshold);
+
+    // infinite loop to display
+    // and refresh the content of the output image
+    // until the user presses q or Q
+    char key = 0;
+    while(key != 'q' && key != 'Q')
+    {
+        // those parameters cannot be =0
+        // so we must check here
+        cannyThreshold = std::max(cannyThreshold, 1);
+        accumulatorThreshold = std::max(accumulatorThreshold, 1);
+
+        //runs the detection, and update the display
+        HoughDetection(src_gray, src, cannyThreshold, accumulatorThreshold);
+
+        // get user key
+        key = (char)waitKey(10);
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp
new file mode 100644
index 00000000..5d1736a7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp
@@ -0,0 +1,133 @@
+/**
+ * @file HoughLines_Demo.cpp
+ * @brief Demo code for Hough Transform
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+
+/** General variables */
+Mat src, edges;
+Mat src_gray;
+Mat standard_hough, probabilistic_hough;
+int min_threshold = 50;
+int max_trackbar = 150;
+
+const char* standard_name = "Standard Hough Lines Demo";
+const char* probabilistic_name = "Probabilistic Hough Lines Demo";
+
+int s_trackbar = max_trackbar;
+int p_trackbar = max_trackbar;
+
+/// Function Headers
+void help();
+void Standard_Hough( int, void* );
+void Probabilistic_Hough( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+   // Read the image
+    String imageName("building.jpg"); // by default
+    if (argc > 1)
+    {
+        imageName = argv[1];
+    }
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR );
+
+   if( src.empty() )
+     { help();
+       return -1;
+     }
+
+   /// Pass the image to gray
+   cvtColor( src, src_gray, COLOR_RGB2GRAY );
+
+   /// Apply Canny edge detector
+   Canny( src_gray, edges, 50, 200, 3 );
+
+   /// Create Trackbars for Thresholds
+   char thresh_label[50];
+   snprintf( thresh_label, sizeof(thresh_label), "Thres: %d + input", min_threshold );
+
+   namedWindow( standard_name, WINDOW_AUTOSIZE );
+   createTrackbar( thresh_label, standard_name, &s_trackbar, max_trackbar, Standard_Hough);
+
+   namedWindow( probabilistic_name, WINDOW_AUTOSIZE );
+   createTrackbar( thresh_label, probabilistic_name, &p_trackbar, max_trackbar, Probabilistic_Hough);
+
+   /// Initialize
+   Standard_Hough(0, 0);
+   Probabilistic_Hough(0, 0);
+   waitKey(0);
+   return 0;
+}
+
+/**
+ * @function help
+ * @brief Indications of how to run this program and why is it for
+ */
+void help()
+{
+  printf("\t Hough Transform to detect lines \n ");
+  printf("\t---------------------------------\n ");
+  printf(" Usage: ./HoughLines_Demo <image_name> \n");
+}
+
+/**
+ * @function Standard_Hough
+ */
+void Standard_Hough( int, void* )
+{
+  vector<Vec2f> s_lines;
+  cvtColor( edges, standard_hough, COLOR_GRAY2BGR );
+
+  /// 1. Use Standard Hough Transform
+  HoughLines( edges, s_lines, 1, CV_PI/180, min_threshold + s_trackbar, 0, 0 );
+
+  /// Show the result
+  for( size_t i = 0; i < s_lines.size(); i++ )
+     {
+      float r = s_lines[i][0], t = s_lines[i][1];
+      double cos_t = cos(t), sin_t = sin(t);
+      double x0 = r*cos_t, y0 = r*sin_t;
+      double alpha = 1000;
+
+       Point pt1( cvRound(x0 + alpha*(-sin_t)), cvRound(y0 + alpha*cos_t) );
+       Point pt2( cvRound(x0 - alpha*(-sin_t)), cvRound(y0 - alpha*cos_t) );
+       line( standard_hough, pt1, pt2, Scalar(255,0,0), 3, LINE_AA);
+     }
+
+   imshow( standard_name, standard_hough );
+}
+
+/**
+ * @function Probabilistic_Hough
+ */
+void Probabilistic_Hough( int, void* )
+{
+  vector<Vec4i> p_lines;
+  cvtColor( edges, probabilistic_hough, COLOR_GRAY2BGR );
+
+  /// 2. Use Probabilistic Hough Transform
+  HoughLinesP( edges, p_lines, 1, CV_PI/180, min_threshold + p_trackbar, 30, 10 );
+
+  /// Show the result
+  for( size_t i = 0; i < p_lines.size(); i++ )
+     {
+       Vec4i l = p_lines[i];
+       line( probabilistic_hough, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(255,0,0), 3, LINE_AA);
+     }
+
+   imshow( probabilistic_name, probabilistic_hough );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp
new file mode 100644
index 00000000..0c8b1f16
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp
@@ -0,0 +1,67 @@
+/**
+ * @file Laplace_Demo.cpp
+ * @brief Sample code showing how to detect edges using the Laplace operator
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //![variables]
+    // Declare the variables we are going to use
+    Mat src, src_gray, dst;
+    int kernel_size = 3;
+    int scale = 1;
+    int delta = 0;
+    int ddepth = CV_16S;
+    const char* window_name = "Laplace Demo";
+    //![variables]
+
+    //![load]
+    const char* imageName = argc >=2 ? argv[1] : "lena.jpg";
+
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
+
+    // Check if image is loaded fine
+    if(src.empty()){
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default lena.jpg] \n");
+        return -1;
+    }
+    //![load]
+
+    //![reduce_noise]
+    // Reduce noise by blurring with a Gaussian filter ( kernel size = 3 )
+    GaussianBlur( src, src, Size(3, 3), 0, 0, BORDER_DEFAULT );
+    //![reduce_noise]
+
+    //![convert_to_gray]
+    cvtColor( src, src_gray, COLOR_BGR2GRAY ); // Convert the image to grayscale
+    //![convert_to_gray]
+
+    /// Apply Laplace function
+    Mat abs_dst;
+    //![laplacian]
+    Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );
+    //![laplacian]
+
+    //![convert]
+    // converting back to CV_8U
+    convertScaleAbs( dst, abs_dst );
+    //![convert]
+
+    //![display]
+    imshow( window_name, abs_dst );
+    waitKey(0);
+    //![display]
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp
new file mode 100644
index 00000000..d4ff193c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp
@@ -0,0 +1,114 @@
+/**
+ * @function Remap_Demo.cpp
+ * @brief Demo code for Remap
+ * @author Ana Huaman
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+
+/// Function Headers
+void update_map( int &ind, Mat &map_x, Mat &map_y );
+
+/**
+ * @function main
+ */
+int main(int argc, const char** argv)
+{
+    CommandLineParser parser(argc, argv, "{@image |chicky_512.png|input image name}");
+    std::string filename = parser.get<std::string>(0);
+    //! [Load]
+    /// Load the image
+    Mat src = imread( samples::findFile( filename ), IMREAD_COLOR );
+    if (src.empty())
+    {
+        std::cout << "Cannot read image: " << filename << std::endl;
+        return -1;
+    }
+    //! [Load]
+
+    //! [Create]
+    /// Create dst, map_x and map_y with the same size as src:
+    Mat dst(src.size(), src.type());
+    Mat map_x(src.size(), CV_32FC1);
+    Mat map_y(src.size(), CV_32FC1);
+    //! [Create]
+
+    //! [Window]
+    /// Create window
+    const char* remap_window = "Remap demo";
+    namedWindow( remap_window, WINDOW_AUTOSIZE );
+    //! [Window]
+
+    //! [Loop]
+    /// Index to switch between the remap modes
+    int ind = 0;
+    for(;;)
+    {
+        /// Update map_x & map_y. Then apply remap
+        update_map(ind, map_x, map_y);
+        remap( src, dst, map_x, map_y, INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0) );
+
+        /// Display results
+        imshow( remap_window, dst );
+
+        /// Each 1 sec. Press ESC to exit the program
+        char c = (char)waitKey( 1000 );
+        if( c == 27 )
+        {
+            break;
+        }
+    }
+    //! [Loop]
+    return 0;
+}
+
+/**
+ * @function update_map
+ * @brief Fill the map_x and map_y matrices with 4 types of mappings
+ */
+//! [Update]
+void update_map( int &ind, Mat &map_x, Mat &map_y )
+{
+    for( int i = 0; i < map_x.rows; i++ )
+    {
+        for( int j = 0; j < map_x.cols; j++ )
+        {
+            switch( ind )
+            {
+            case 0:
+                if( j > map_x.cols*0.25 && j < map_x.cols*0.75 && i > map_x.rows*0.25 && i < map_x.rows*0.75 )
+                {
+                    map_x.at<float>(i, j) = 2*( j - map_x.cols*0.25f ) + 0.5f;
+                    map_y.at<float>(i, j) = 2*( i - map_x.rows*0.25f ) + 0.5f;
+                }
+                else
+                {
+                    map_x.at<float>(i, j) = 0;
+                    map_y.at<float>(i, j) = 0;
+                }
+                break;
+            case 1:
+                map_x.at<float>(i, j) = (float)j;
+                map_y.at<float>(i, j) = (float)(map_x.rows - i);
+                break;
+            case 2:
+                map_x.at<float>(i, j) = (float)(map_x.cols - j);
+                map_y.at<float>(i, j) = (float)i;
+                break;
+            case 3:
+                map_x.at<float>(i, j) = (float)(map_x.cols - j);
+                map_y.at<float>(i, j) = (float)(map_x.rows - i);
+                break;
+            default:
+                break;
+            } // end of switch
+        }
+    }
+    ind = (ind+1) % 4;
+}
+//! [Update]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp
new file mode 100644
index 00000000..9b48f6aa
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp
@@ -0,0 +1,124 @@
+/**
+ * @file Sobel_Demo.cpp
+ * @brief Sample code uses Sobel or Scharr OpenCV functions for edge detection
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  cv::CommandLineParser parser(argc, argv,
+                               "{@input   |lena.jpg|input image}"
+                               "{ksize   k|1|ksize (hit 'K' to increase its value at run time)}"
+                               "{scale   s|1|scale (hit 'S' to increase its value at run time)}"
+                               "{delta   d|0|delta (hit 'D' to increase its value at run time)}"
+                               "{help    h|false|show help message}");
+
+  cout << "The sample uses Sobel or Scharr OpenCV functions for edge detection\n\n";
+  parser.printMessage();
+  cout << "\nPress 'ESC' to exit program.\nPress 'R' to reset values ( ksize will be -1 equal to Scharr function )";
+
+  //![variables]
+  // First we declare the variables we are going to use
+  Mat image,src, src_gray;
+  Mat grad;
+  const String window_name = "Sobel Demo - Simple Edge Detector";
+  int ksize = parser.get<int>("ksize");
+  int scale = parser.get<int>("scale");
+  int delta = parser.get<int>("delta");
+  int ddepth = CV_16S;
+  //![variables]
+
+  //![load]
+  String imageName = parser.get<String>("@input");
+  // As usual we load our source image (src)
+  image = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
+
+  // Check if image is loaded fine
+  if( image.empty() )
+  {
+    printf("Error opening image: %s\n", imageName.c_str());
+    return EXIT_FAILURE;
+  }
+  //![load]
+
+  for (;;)
+  {
+    //![reduce_noise]
+    // Remove noise by blurring with a Gaussian filter ( kernel size = 3 )
+    GaussianBlur(image, src, Size(3, 3), 0, 0, BORDER_DEFAULT);
+    //![reduce_noise]
+
+    //![convert_to_gray]
+    // Convert the image to grayscale
+    cvtColor(src, src_gray, COLOR_BGR2GRAY);
+    //![convert_to_gray]
+
+    //![sobel]
+    /// Generate grad_x and grad_y
+    Mat grad_x, grad_y;
+    Mat abs_grad_x, abs_grad_y;
+
+    /// Gradient X
+    Sobel(src_gray, grad_x, ddepth, 1, 0, ksize, scale, delta, BORDER_DEFAULT);
+
+    /// Gradient Y
+    Sobel(src_gray, grad_y, ddepth, 0, 1, ksize, scale, delta, BORDER_DEFAULT);
+    //![sobel]
+
+    //![convert]
+    // converting back to CV_8U
+    convertScaleAbs(grad_x, abs_grad_x);
+    convertScaleAbs(grad_y, abs_grad_y);
+    //![convert]
+
+    //![blend]
+    /// Total Gradient (approximate)
+    addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad);
+    //![blend]
+
+    //![display]
+    imshow(window_name, grad);
+    char key = (char)waitKey(0);
+    //![display]
+
+    if(key == 27)
+    {
+      return EXIT_SUCCESS;
+    }
+
+    if (key == 'k' || key == 'K')
+    {
+      ksize = ksize < 30 ? ksize+2 : -1;
+    }
+
+    if (key == 's' || key == 'S')
+    {
+      scale++;
+    }
+
+    if (key == 'd' || key == 'D')
+    {
+      delta++;
+    }
+
+    if (key == 'r' || key == 'R')
+    {
+      scale =  1;
+      ksize = -1;
+      delta =  0;
+    }
+  }
+  return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp
new file mode 100644
index 00000000..2eeff1cf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp
@@ -0,0 +1,84 @@
+/**
+ * @file copyMakeBorder_demo.cpp
+ * @brief Sample code that shows the functionality of copyMakeBorder
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+
+//![variables]
+// Declare the variables
+Mat src, dst;
+int top, bottom, left, right;
+int borderType = BORDER_CONSTANT;
+const char* window_name = "copyMakeBorder Demo";
+RNG rng(12345);
+//![variables]
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //![load]
+    const char* imageName = argc >=2 ? argv[1] : "lena.jpg";
+
+    // Loads an image
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
+
+    // Check if image is loaded fine
+    if( src.empty()) {
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default lena.jpg] \n");
+        return -1;
+    }
+    //![load]
+
+    // Brief how-to for this program
+    printf( "\n \t copyMakeBorder Demo: \n" );
+    printf( "\t -------------------- \n" );
+    printf( " ** Press 'c' to set the border to a random constant value \n");
+    printf( " ** Press 'r' to set the border to be replicated \n");
+    printf( " ** Press 'ESC' to exit the program \n");
+
+    //![create_window]
+    namedWindow( window_name, WINDOW_AUTOSIZE );
+    //![create_window]
+
+    //![init_arguments]
+    // Initialize arguments for the filter
+    top = (int) (0.05*src.rows); bottom = top;
+    left = (int) (0.05*src.cols); right = left;
+    //![init_arguments]
+
+    for(;;)
+    {
+        //![update_value]
+        Scalar value( rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255) );
+        //![update_value]
+
+        //![copymakeborder]
+        copyMakeBorder( src, dst, top, bottom, left, right, borderType, value );
+        //![copymakeborder]
+
+        //![display]
+        imshow( window_name, dst );
+        //![display]
+
+        //![check_keypress]
+        char c = (char)waitKey(500);
+        if( c == 27 )
+        { break; }
+        else if( c == 'c' )
+        { borderType = BORDER_CONSTANT; }
+        else if( c == 'r' )
+        { borderType = BORDER_REPLICATE; }
+        //![check_keypress]
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp
new file mode 100644
index 00000000..37fb6f6e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp
@@ -0,0 +1,74 @@
+/**
+ * @file filter2D_demo.cpp
+ * @brief Sample code that shows how to implement your own linear filters by using filter2D function
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main ( int argc, char** argv )
+{
+    // Declare variables
+    Mat src, dst;
+
+    Mat kernel;
+    Point anchor;
+    double delta;
+    int ddepth;
+    int kernel_size;
+    const char* window_name = "filter2D Demo";
+
+    //![load]
+    const char* imageName = argc >=2 ? argv[1] : "lena.jpg";
+
+    // Loads an image
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
+
+    if( src.empty() )
+    {
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default lena.jpg] \n");
+        return EXIT_FAILURE;
+    }
+    //![load]
+
+    //![init_arguments]
+    // Initialize arguments for the filter
+    anchor = Point( -1, -1 );
+    delta = 0;
+    ddepth = -1;
+    //![init_arguments]
+
+    // Loop - Will filter the image with different kernel sizes each 0.5 seconds
+    int ind = 0;
+    for(;;)
+    {
+        //![update_kernel]
+        // Update kernel size for a normalized box filter
+        kernel_size = 3 + 2*( ind%5 );
+        kernel = Mat::ones( kernel_size, kernel_size, CV_32F )/ (float)(kernel_size*kernel_size);
+        //![update_kernel]
+
+        //![apply_filter]
+        // Apply filter
+        filter2D(src, dst, ddepth , kernel, anchor, delta, BORDER_DEFAULT );
+        //![apply_filter]
+        imshow( window_name, dst );
+
+        char c = (char)waitKey(500);
+        // Press 'ESC' to exit the program
+        if( c == 27 )
+        { break; }
+
+        ind++;
+    }
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/generalizedHoughTransform.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/generalizedHoughTransform.cpp
new file mode 100644
index 00000000..dca52b13
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/generalizedHoughTransform.cpp
@@ -0,0 +1,108 @@
+/**
+  @file generalizedHoughTransform.cpp
+  @author Markus Heck
+  @brief Detects an object, given by a template, in an image using GeneralizedHoughBallard and GeneralizedHoughGuil.
+*/
+
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+using namespace cv;
+using namespace std;
+
+int main() {
+    //! [generalized-hough-transform-load-and-setup]
+//  load source image and grayscale template
+    Mat image = imread("images/generalized_hough_mini_image.jpg");
+    Mat templ = imread("images/generalized_hough_mini_template.jpg", IMREAD_GRAYSCALE);
+
+//  create grayscale image
+    Mat grayImage;
+    cvtColor(image, grayImage, COLOR_RGB2GRAY);
+
+//  create variable for location, scale and rotation of detected templates
+    vector<Vec4f> positionBallard, positionGuil;
+
+//  template width and height
+    int w = templ.cols;
+    int h = templ.rows;
+    //! [generalized-hough-transform-load-and-setup]
+
+
+    //! [generalized-hough-transform-setup-parameters]
+//  create ballard and set options
+    Ptr<GeneralizedHoughBallard> ballard = createGeneralizedHoughBallard();
+    ballard->setMinDist(10);
+    ballard->setLevels(360);
+    ballard->setDp(2);
+    ballard->setMaxBufferSize(1000);
+    ballard->setVotesThreshold(40);
+
+    ballard->setCannyLowThresh(30);
+    ballard->setCannyHighThresh(110);
+    ballard->setTemplate(templ);
+
+
+//  create guil and set options
+    Ptr<GeneralizedHoughGuil> guil = createGeneralizedHoughGuil();
+    guil->setMinDist(10);
+    guil->setLevels(360);
+    guil->setDp(3);
+    guil->setMaxBufferSize(1000);
+
+    guil->setMinAngle(0);
+    guil->setMaxAngle(360);
+    guil->setAngleStep(1);
+    guil->setAngleThresh(1500);
+
+    guil->setMinScale(0.5);
+    guil->setMaxScale(2.0);
+    guil->setScaleStep(0.05);
+    guil->setScaleThresh(50);
+
+    guil->setPosThresh(10);
+
+    guil->setCannyLowThresh(30);
+    guil->setCannyHighThresh(110);
+
+    guil->setTemplate(templ);
+    //! [generalized-hough-transform-setup-parameters]
+
+
+    //! [generalized-hough-transform-run]
+//  execute ballard detection
+    ballard->detect(grayImage, positionBallard);
+//  execute guil detection
+    guil->detect(grayImage, positionGuil);
+    //! [generalized-hough-transform-run]
+
+
+    //! [generalized-hough-transform-draw-results]
+//  draw ballard
+    for (vector<Vec4f>::iterator iter = positionBallard.begin(); iter != positionBallard.end(); ++iter) {
+        RotatedRect rRect = RotatedRect(Point2f((*iter)[0], (*iter)[1]),
+                                        Size2f(w * (*iter)[2], h * (*iter)[2]),
+                                        (*iter)[3]);
+        Point2f vertices[4];
+        rRect.points(vertices);
+        for (int i = 0; i < 4; i++)
+            line(image, vertices[i], vertices[(i + 1) % 4], Scalar(255, 0, 0), 6);
+    }
+
+//  draw guil
+    for (vector<Vec4f>::iterator iter = positionGuil.begin(); iter != positionGuil.end(); ++iter) {
+        RotatedRect rRect = RotatedRect(Point2f((*iter)[0], (*iter)[1]),
+                                        Size2f(w * (*iter)[2], h * (*iter)[2]),
+                                        (*iter)[3]);
+        Point2f vertices[4];
+        rRect.points(vertices);
+        for (int i = 0; i < 4; i++)
+            line(image, vertices[i], vertices[(i + 1) % 4], Scalar(0, 255, 0), 2);
+    }
+
+    imshow("result_img", image);
+    waitKey();
+    //! [generalized-hough-transform-draw-results]
+
+    return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp
new file mode 100644
index 00000000..0cec4456
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp
@@ -0,0 +1,65 @@
+/**
+ * @file houghcircles.cpp
+ * @brief This program demonstrates circle finding with the Hough transform
+ */
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char** argv)
+{
+    //![load]
+    const char* filename = argc >=2 ? argv[1] : "smarties.png";
+
+    // Loads an image
+    Mat src = imread( samples::findFile( filename ), IMREAD_COLOR );
+
+    // Check if image is loaded fine
+    if(src.empty()){
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default %s] \n", filename);
+        return EXIT_FAILURE;
+    }
+    //![load]
+
+    //![convert_to_gray]
+    Mat gray;
+    cvtColor(src, gray, COLOR_BGR2GRAY);
+    //![convert_to_gray]
+
+    //![reduce_noise]
+    medianBlur(gray, gray, 5);
+    //![reduce_noise]
+
+    //![houghcircles]
+    vector<Vec3f> circles;
+    HoughCircles(gray, circles, HOUGH_GRADIENT, 1,
+                 gray.rows/16,  // change this value to detect circles with different distances to each other
+                 100, 30, 1, 30 // change the last two parameters
+            // (min_radius & max_radius) to detect larger circles
+    );
+    //![houghcircles]
+
+    //![draw]
+    for( size_t i = 0; i < circles.size(); i++ )
+    {
+        Vec3i c = circles[i];
+        Point center = Point(c[0], c[1]);
+        // circle center
+        circle( src, center, 1, Scalar(0,100,100), 3, LINE_AA);
+        // circle outline
+        int radius = c[2];
+        circle( src, center, radius, Scalar(255,0,255), 3, LINE_AA);
+    }
+    //![draw]
+
+    //![display]
+    imshow("detected circles", src);
+    waitKey();
+    //![display]
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/houghlines.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/houghlines.cpp
new file mode 100644
index 00000000..0052c185
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/houghlines.cpp
@@ -0,0 +1,89 @@
+/**
+ * @file houghlines.cpp
+ * @brief This program demonstrates line finding with the Hough transform
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char** argv)
+{
+    // Declare the output variables
+    Mat dst, cdst, cdstP;
+
+    //![load]
+    const char* default_file = "sudoku.png";
+    const char* filename = argc >=2 ? argv[1] : default_file;
+
+    // Loads an image
+    Mat src = imread( samples::findFile( filename ), IMREAD_GRAYSCALE );
+
+    // Check if image is loaded fine
+    if(src.empty()){
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default %s] \n", default_file);
+        return -1;
+    }
+    //![load]
+
+    //![edge_detection]
+    // Edge detection
+    Canny(src, dst, 50, 200, 3);
+    //![edge_detection]
+
+    // Copy edges to the images that will display the results in BGR
+    cvtColor(dst, cdst, COLOR_GRAY2BGR);
+    cdstP = cdst.clone();
+
+    //![hough_lines]
+    // Standard Hough Line Transform
+    vector<Vec2f> lines; // will hold the results of the detection
+    HoughLines(dst, lines, 1, CV_PI/180, 150, 0, 0 ); // runs the actual detection
+    //![hough_lines]
+    //![draw_lines]
+    // Draw the lines
+    for( size_t i = 0; i < lines.size(); i++ )
+    {
+        float rho = lines[i][0], theta = lines[i][1];
+        Point pt1, pt2;
+        double a = cos(theta), b = sin(theta);
+        double x0 = a*rho, y0 = b*rho;
+        pt1.x = cvRound(x0 + 1000*(-b));
+        pt1.y = cvRound(y0 + 1000*(a));
+        pt2.x = cvRound(x0 - 1000*(-b));
+        pt2.y = cvRound(y0 - 1000*(a));
+        line( cdst, pt1, pt2, Scalar(0,0,255), 3, LINE_AA);
+    }
+    //![draw_lines]
+
+    //![hough_lines_p]
+    // Probabilistic Line Transform
+    vector<Vec4i> linesP; // will hold the results of the detection
+    HoughLinesP(dst, linesP, 1, CV_PI/180, 50, 50, 10 ); // runs the actual detection
+    //![hough_lines_p]
+    //![draw_lines_p]
+    // Draw the lines
+    for( size_t i = 0; i < linesP.size(); i++ )
+    {
+        Vec4i l = linesP[i];
+        line( cdstP, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0,0,255), 3, LINE_AA);
+    }
+    //![draw_lines_p]
+
+    //![imshow]
+    // Show results
+    imshow("Source", src);
+    imshow("Detected Lines (in red) - Standard Hough Line Transform", cdst);
+    imshow("Detected Lines (in red) - Probabilistic Line Transform", cdstP);
+    //![imshow]
+
+    //![exit]
+    // Wait and Exit
+    waitKey();
+    return 0;
+    //![exit]
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp
new file mode 100644
index 00000000..818fcb47
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp
@@ -0,0 +1,168 @@
+/**
+ * @brief Sample code showing how to segment overlapping objects using Laplacian filtering, in addition to Watershed and Distance Transformation
+ * @author OpenCV Team
+ */
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main(int argc, char *argv[])
+{
+    //! [load_image]
+    // Load the image
+    CommandLineParser parser( argc, argv, "{@input | cards.png | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+
+    // Show the source image
+    imshow("Source Image", src);
+    //! [load_image]
+
+    //! [black_bg]
+    // Change the background from white to black, since that will help later to extract
+    // better results during the use of Distance Transform
+    Mat mask;
+    inRange(src, Scalar(255, 255, 255), Scalar(255, 255, 255), mask);
+    src.setTo(Scalar(0, 0, 0), mask);
+
+    // Show output image
+    imshow("Black Background Image", src);
+    //! [black_bg]
+
+    //! [sharp]
+    // Create a kernel that we will use to sharpen our image
+    Mat kernel = (Mat_<float>(3,3) <<
+                  1,  1, 1,
+                  1, -8, 1,
+                  1,  1, 1); // an approximation of second derivative, a quite strong kernel
+
+    // do the laplacian filtering as it is
+    // well, we need to convert everything in something more deeper then CV_8U
+    // because the kernel has some negative values,
+    // and we can expect in general to have a Laplacian image with negative values
+    // BUT a 8bits unsigned int (the one we are working with) can contain values from 0 to 255
+    // so the possible negative number will be truncated
+    Mat imgLaplacian;
+    filter2D(src, imgLaplacian, CV_32F, kernel);
+    Mat sharp;
+    src.convertTo(sharp, CV_32F);
+    Mat imgResult = sharp - imgLaplacian;
+
+    // convert back to 8bits gray scale
+    imgResult.convertTo(imgResult, CV_8UC3);
+    imgLaplacian.convertTo(imgLaplacian, CV_8UC3);
+
+    // imshow( "Laplace Filtered Image", imgLaplacian );
+    imshow( "New Sharped Image", imgResult );
+    //! [sharp]
+
+    //! [bin]
+    // Create binary image from source image
+    Mat bw;
+    cvtColor(imgResult, bw, COLOR_BGR2GRAY);
+    threshold(bw, bw, 40, 255, THRESH_BINARY | THRESH_OTSU);
+    imshow("Binary Image", bw);
+    //! [bin]
+
+    //! [dist]
+    // Perform the distance transform algorithm
+    Mat dist;
+    distanceTransform(bw, dist, DIST_L2, 3);
+
+    // Normalize the distance image for range = {0.0, 1.0}
+    // so we can visualize and threshold it
+    normalize(dist, dist, 0, 1.0, NORM_MINMAX);
+    imshow("Distance Transform Image", dist);
+    //! [dist]
+
+    //! [peaks]
+    // Threshold to obtain the peaks
+    // This will be the markers for the foreground objects
+    threshold(dist, dist, 0.4, 1.0, THRESH_BINARY);
+
+    // Dilate a bit the dist image
+    Mat kernel1 = Mat::ones(3, 3, CV_8U);
+    dilate(dist, dist, kernel1);
+    imshow("Peaks", dist);
+    //! [peaks]
+
+    //! [seeds]
+    // Create the CV_8U version of the distance image
+    // It is needed for findContours()
+    Mat dist_8u;
+    dist.convertTo(dist_8u, CV_8U);
+
+    // Find total markers
+    vector<vector<Point> > contours;
+    findContours(dist_8u, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
+
+    // Create the marker image for the watershed algorithm
+    Mat markers = Mat::zeros(dist.size(), CV_32S);
+
+    // Draw the foreground markers
+    for (size_t i = 0; i < contours.size(); i++)
+    {
+        drawContours(markers, contours, static_cast<int>(i), Scalar(static_cast<int>(i)+1), -1);
+    }
+
+    // Draw the background marker
+    circle(markers, Point(5,5), 3, Scalar(255), -1);
+    Mat markers8u;
+    markers.convertTo(markers8u, CV_8U, 10);
+    imshow("Markers", markers8u);
+    //! [seeds]
+
+    //! [watershed]
+    // Perform the watershed algorithm
+    watershed(imgResult, markers);
+
+    Mat mark;
+    markers.convertTo(mark, CV_8U);
+    bitwise_not(mark, mark);
+    //    imshow("Markers_v2", mark); // uncomment this if you want to see how the mark
+    // image looks like at that point
+
+    // Generate random colors
+    vector<Vec3b> colors;
+    for (size_t i = 0; i < contours.size(); i++)
+    {
+        int b = theRNG().uniform(0, 256);
+        int g = theRNG().uniform(0, 256);
+        int r = theRNG().uniform(0, 256);
+
+        colors.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
+    }
+
+    // Create the result image
+    Mat dst = Mat::zeros(markers.size(), CV_8UC3);
+
+    // Fill labeled objects with random colors
+    for (int i = 0; i < markers.rows; i++)
+    {
+        for (int j = 0; j < markers.cols; j++)
+        {
+            int index = markers.at<int>(i,j);
+            if (index > 0 && index <= static_cast<int>(contours.size()))
+            {
+                dst.at<Vec3b>(i,j) = colors[index-1];
+            }
+        }
+    }
+
+    // Visualize the final image
+    imshow("Final Result", dst);
+    //! [watershed]
+
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp
new file mode 100644
index 00000000..15990b51
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp
@@ -0,0 +1,78 @@
+/**
+ * @function findContours_Demo.cpp
+ * @brief Demo code to find contours in an image
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+Mat src_gray;
+int thresh = 100;
+RNG rng(12345);
+
+/// Function header
+void thresh_callback(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    /// Load source image
+    CommandLineParser parser( argc, argv, "{@input | HappyFish.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if( src.empty() )
+    {
+      cout << "Could not open or find the image!\n" << endl;
+      cout << "Usage: " << argv[0] << " <Input image>" << endl;
+      return -1;
+    }
+
+    /// Convert image to gray and blur it
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+    blur( src_gray, src_gray, Size(3,3) );
+
+    /// Create Window
+    const char* source_window = "Source";
+    namedWindow( source_window );
+    imshow( source_window, src );
+
+    const int max_thresh = 255;
+    createTrackbar( "Canny thresh:", source_window, &thresh, max_thresh, thresh_callback );
+    thresh_callback( 0, 0 );
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function thresh_callback
+ */
+void thresh_callback(int, void* )
+{
+    /// Detect edges using Canny
+    Mat canny_output;
+    Canny( src_gray, canny_output, thresh, thresh*2 );
+
+    /// Find contours
+    vector<vector<Point> > contours;
+    vector<Vec4i> hierarchy;
+    findContours( canny_output, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE );
+
+    /// Draw contours
+    Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
+    for( size_t i = 0; i< contours.size(); i++ )
+    {
+        Scalar color = Scalar( rng.uniform(0, 256), rng.uniform(0,256), rng.uniform(0,256) );
+        drawContours( drawing, contours, (int)i, color, 2, LINE_8, hierarchy, 0 );
+    }
+
+    /// Show in a window
+    imshow( "Contours", drawing );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp
new file mode 100644
index 00000000..68fa2b97
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp
@@ -0,0 +1,111 @@
+/**
+ * @function generalContours_demo1.cpp
+ * @brief Demo code to find contours in an image
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+Mat src_gray;
+int thresh = 100;
+RNG rng(12345);
+
+/// Function header
+void thresh_callback(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //! [setup]
+    /// Load source image
+    CommandLineParser parser( argc, argv, "{@input | stuff.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+
+    /// Convert image to gray and blur it
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+    blur( src_gray, src_gray, Size(3,3) );
+    //! [setup]
+
+    //! [createWindow]
+    /// Create Window
+    const char* source_window = "Source";
+    namedWindow( source_window );
+    imshow( source_window, src );
+    //! [createWindow]
+
+    //! [trackbar]
+    const int max_thresh = 255;
+    createTrackbar( "Canny thresh:", source_window, &thresh, max_thresh, thresh_callback );
+    thresh_callback( 0, 0 );
+    //! [trackbar]
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function thresh_callback
+ */
+void thresh_callback(int, void* )
+{
+    //! [Canny]
+    /// Detect edges using Canny
+    Mat canny_output;
+    Canny( src_gray, canny_output, thresh, thresh*2 );
+    //! [Canny]
+
+    //! [findContours]
+    /// Find contours
+    vector<vector<Point> > contours;
+    findContours( canny_output, contours, RETR_TREE, CHAIN_APPROX_SIMPLE );
+    //! [findContours]
+
+    //! [allthework]
+    /// Approximate contours to polygons + get bounding rects and circles
+    vector<vector<Point> > contours_poly( contours.size() );
+    vector<Rect> boundRect( contours.size() );
+    vector<Point2f>centers( contours.size() );
+    vector<float>radius( contours.size() );
+
+    for( size_t i = 0; i < contours.size(); i++ )
+    {
+        approxPolyDP( contours[i], contours_poly[i], 3, true );
+        boundRect[i] = boundingRect( contours_poly[i] );
+        minEnclosingCircle( contours_poly[i], centers[i], radius[i] );
+    }
+    //! [allthework]
+
+    //! [zeroMat]
+    Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
+    //! [zeroMat]
+
+    //! [forContour]
+    /// Draw polygonal contour + bonding rects + circles
+    for( size_t i = 0; i< contours.size(); i++ )
+    {
+        Scalar color = Scalar( rng.uniform(0, 256), rng.uniform(0,256), rng.uniform(0,256) );
+        drawContours( drawing, contours_poly, (int)i, color );
+        rectangle( drawing, boundRect[i].tl(), boundRect[i].br(), color, 2 );
+        circle( drawing, centers[i], (int)radius[i], color, 2 );
+    }
+    //! [forContour]
+
+    //! [showDrawings]
+    /// Show in a window
+    imshow( "Contours", drawing );
+    //! [showDrawings]
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp
new file mode 100644
index 00000000..81e5fd75
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp
@@ -0,0 +1,98 @@
+/**
+ * @function generalContours_demo2.cpp
+ * @brief Demo code to obtain ellipses and rotated rectangles that contain detected contours
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+Mat src_gray;
+int thresh = 100;
+RNG rng(12345);
+
+/// Function header
+void thresh_callback(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    /// Load source image and convert it to gray
+    CommandLineParser parser( argc, argv, "{@input | stuff.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+
+    /// Convert image to gray and blur it
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+    blur( src_gray, src_gray, Size(3,3) );
+
+    /// Create Window
+    const char* source_window = "Source";
+    namedWindow( source_window );
+    imshow( source_window, src );
+
+    const int max_thresh = 255;
+    createTrackbar( "Canny thresh:", source_window, &thresh, max_thresh, thresh_callback );
+    thresh_callback( 0, 0 );
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function thresh_callback
+ */
+void thresh_callback(int, void* )
+{
+    /// Detect edges using Canny
+    Mat canny_output;
+    Canny( src_gray, canny_output, thresh, thresh*2 );
+    /// Find contours
+    vector<vector<Point> > contours;
+    findContours( canny_output, contours, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+    /// Find the rotated rectangles and ellipses for each contour
+    vector<RotatedRect> minRect( contours.size() );
+    vector<RotatedRect> minEllipse( contours.size() );
+    for( size_t i = 0; i < contours.size(); i++ )
+    {
+        minRect[i] = minAreaRect( contours[i] );
+        if( contours[i].size() > 5 )
+        {
+            minEllipse[i] = fitEllipse( contours[i] );
+        }
+    }
+
+    /// Draw contours + rotated rects + ellipses
+    Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
+    for( size_t i = 0; i< contours.size(); i++ )
+    {
+        Scalar color = Scalar( rng.uniform(0, 256), rng.uniform(0,256), rng.uniform(0,256) );
+        // contour
+        drawContours( drawing, contours, (int)i, color );
+        // ellipse
+        ellipse( drawing, minEllipse[i], color, 2 );
+        // rotated rectangle
+        Point2f rect_points[4];
+        minRect[i].points( rect_points );
+        for ( int j = 0; j < 4; j++ )
+        {
+            line( drawing, rect_points[j], rect_points[(j+1)%4], color );
+        }
+    }
+
+    /// Show in a window
+    imshow( "Contours", drawing );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp
new file mode 100644
index 00000000..3b46f9e9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp
@@ -0,0 +1,85 @@
+/**
+ * @function hull_demo.cpp
+ * @brief Demo code to find contours in an image
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+Mat src_gray;
+int thresh = 100;
+RNG rng(12345);
+
+/// Function header
+void thresh_callback(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    /// Load source image and convert it to gray
+    CommandLineParser parser( argc, argv, "{@input | stuff.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+
+    /// Convert image to gray and blur it
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+    blur( src_gray, src_gray, Size(3,3) );
+
+    /// Create Window
+    const char* source_window = "Source";
+    namedWindow( source_window );
+    imshow( source_window, src );
+
+    const int max_thresh = 255;
+    createTrackbar( "Canny thresh:", source_window, &thresh, max_thresh, thresh_callback );
+    thresh_callback( 0, 0 );
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function thresh_callback
+ */
+void thresh_callback(int, void* )
+{
+    /// Detect edges using Canny
+    Mat canny_output;
+    Canny( src_gray, canny_output, thresh, thresh*2 );
+
+    /// Find contours
+    vector<vector<Point> > contours;
+    findContours( canny_output, contours, RETR_TREE, CHAIN_APPROX_SIMPLE );
+
+    /// Find the convex hull object for each contour
+    vector<vector<Point> >hull( contours.size() );
+    for( size_t i = 0; i < contours.size(); i++ )
+    {
+        convexHull( contours[i], hull[i] );
+    }
+
+    /// Draw contours + hull results
+    Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
+    for( size_t i = 0; i< contours.size(); i++ )
+    {
+        Scalar color = Scalar( rng.uniform(0, 256), rng.uniform(0,256), rng.uniform(0,256) );
+        drawContours( drawing, contours, (int)i, color );
+        drawContours( drawing, hull, (int)i, color );
+    }
+
+    /// Show in a window
+    imshow( "Hull demo", drawing );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp
new file mode 100644
index 00000000..9b243ca5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp
@@ -0,0 +1,104 @@
+/**
+ * @function moments_demo.cpp
+ * @brief Demo code to calculate moments
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+#include <iomanip>
+
+using namespace cv;
+using namespace std;
+
+Mat src_gray;
+int thresh = 100;
+RNG rng(12345);
+
+/// Function header
+void thresh_callback(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    /// Load source image
+    CommandLineParser parser( argc, argv, "{@input | stuff.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+
+    /// Convert image to gray and blur it
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+    blur( src_gray, src_gray, Size(3,3) );
+
+    /// Create Window
+    const char* source_window = "Source";
+    namedWindow( source_window );
+    imshow( source_window, src );
+
+    const int max_thresh = 255;
+    createTrackbar( "Canny thresh:", source_window, &thresh, max_thresh, thresh_callback );
+    thresh_callback( 0, 0 );
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function thresh_callback
+ */
+void thresh_callback(int, void* )
+{
+    /// Detect edges using canny
+    Mat canny_output;
+    Canny( src_gray, canny_output, thresh, thresh*2, 3 );
+    /// Find contours
+    vector<vector<Point> > contours;
+    findContours( canny_output, contours, RETR_TREE, CHAIN_APPROX_SIMPLE );
+
+    /// Get the moments
+    vector<Moments> mu(contours.size() );
+    for( size_t i = 0; i < contours.size(); i++ )
+    {
+        mu[i] = moments( contours[i] );
+    }
+
+    ///  Get the mass centers
+    vector<Point2f> mc( contours.size() );
+    for( size_t i = 0; i < contours.size(); i++ )
+    {
+        //add 1e-5 to avoid division by zero
+        mc[i] = Point2f( static_cast<float>(mu[i].m10 / (mu[i].m00 + 1e-5)),
+                         static_cast<float>(mu[i].m01 / (mu[i].m00 + 1e-5)) );
+        cout << "mc[" << i << "]=" << mc[i] << endl;
+    }
+
+    /// Draw contours
+    Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
+    for( size_t i = 0; i< contours.size(); i++ )
+    {
+        Scalar color = Scalar( rng.uniform(0, 256), rng.uniform(0,256), rng.uniform(0,256) );
+        drawContours( drawing, contours, (int)i, color, 2 );
+        circle( drawing, mc[i], 4, color, -1 );
+    }
+
+    /// Show in a window
+    imshow( "Contours", drawing );
+
+    /// Calculate the area with the moments 00 and compare with the result of the OpenCV function
+    cout << "\t Info: Area and Contour Length \n";
+    for( size_t i = 0; i < contours.size(); i++ )
+    {
+        cout << " * Contour[" << i << "] - Area (M_00) = " << std::fixed << std::setprecision(2) << mu[i].m00
+             << " - Area OpenCV: " << contourArea(contours[i]) << " - Length: " << arcLength( contours[i], true ) << endl;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp
new file mode 100644
index 00000000..e62dc847
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp
@@ -0,0 +1,88 @@
+/**
+ * @function pointPolygonTest_demo.cpp
+ * @brief Demo code to use the pointPolygonTest function...fairly easy
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function main
+ */
+int main( void )
+{
+    /// Create an image
+    const int r = 100;
+    Mat src = Mat::zeros( Size( 4*r, 4*r ), CV_8U );
+
+    /// Create a sequence of points to make a contour
+    vector<Point2f> vert(6);
+    vert[0] = Point( 3*r/2, static_cast<int>(1.34*r) );
+    vert[1] = Point( 1*r, 2*r );
+    vert[2] = Point( 3*r/2, static_cast<int>(2.866*r) );
+    vert[3] = Point( 5*r/2, static_cast<int>(2.866*r) );
+    vert[4] = Point( 3*r, 2*r );
+    vert[5] = Point( 5*r/2, static_cast<int>(1.34*r) );
+
+    /// Draw it in src
+    for( int i = 0; i < 6; i++ )
+    {
+        line( src, vert[i],  vert[(i+1)%6], Scalar( 255 ), 3 );
+    }
+
+    /// Get the contours
+    vector<vector<Point> > contours;
+    findContours( src, contours, RETR_TREE, CHAIN_APPROX_SIMPLE);
+
+    /// Calculate the distances to the contour
+    Mat raw_dist( src.size(), CV_32F );
+    for( int i = 0; i < src.rows; i++ )
+    {
+        for( int j = 0; j < src.cols; j++ )
+        {
+            raw_dist.at<float>(i,j) = (float)pointPolygonTest( contours[0], Point2f((float)j, (float)i), true );
+        }
+    }
+
+    double minVal, maxVal;
+    Point maxDistPt; // inscribed circle center
+    minMaxLoc(raw_dist, &minVal, &maxVal, NULL, &maxDistPt);
+    minVal = abs(minVal);
+    maxVal = abs(maxVal);
+
+    /// Depicting the  distances graphically
+    Mat drawing = Mat::zeros( src.size(), CV_8UC3 );
+    for( int i = 0; i < src.rows; i++ )
+    {
+        for( int j = 0; j < src.cols; j++ )
+        {
+            if( raw_dist.at<float>(i,j) < 0 )
+            {
+                drawing.at<Vec3b>(i,j)[0] = (uchar)(255 - abs(raw_dist.at<float>(i,j)) * 255 / minVal);
+            }
+            else if( raw_dist.at<float>(i,j) > 0 )
+            {
+                drawing.at<Vec3b>(i,j)[2] = (uchar)(255 - raw_dist.at<float>(i,j) * 255 / maxVal);
+            }
+            else
+            {
+                drawing.at<Vec3b>(i,j)[0] = 255;
+                drawing.at<Vec3b>(i,j)[1] = 255;
+                drawing.at<Vec3b>(i,j)[2] = 255;
+            }
+        }
+    }
+    circle(drawing, maxDistPt, (int)maxVal, Scalar(255,255,255));
+
+    /// Show your results
+    imshow( "Source", src );
+    imshow( "Distance and inscribed circle", drawing );
+
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp
new file mode 100644
index 00000000..e2835531
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp
@@ -0,0 +1,130 @@
+/**
+ * @function cornerDetector_Demo.cpp
+ * @brief Demo code for detecting corners using OpenCV built-in functions
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+Mat src, src_gray;
+Mat myHarris_dst, myHarris_copy, Mc;
+Mat myShiTomasi_dst, myShiTomasi_copy;
+
+int myShiTomasi_qualityLevel = 50;
+int myHarris_qualityLevel = 50;
+int max_qualityLevel = 100;
+
+double myHarris_minVal, myHarris_maxVal;
+double myShiTomasi_minVal, myShiTomasi_maxVal;
+
+RNG rng(12345);
+
+const char* myHarris_window = "My Harris corner detector";
+const char* myShiTomasi_window = "My Shi Tomasi corner detector";
+
+/// Function headers
+void myShiTomasi_function( int, void* );
+void myHarris_function( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    /// Load source image and convert it to gray
+    CommandLineParser parser( argc, argv, "{@input | building.jpg | input image}" );
+    src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if ( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+
+    /// Set some parameters
+    int blockSize = 3, apertureSize = 3;
+
+    /// My Harris matrix -- Using cornerEigenValsAndVecs
+    cornerEigenValsAndVecs( src_gray, myHarris_dst, blockSize, apertureSize );
+
+    /* calculate Mc */
+    Mc = Mat( src_gray.size(), CV_32FC1 );
+    for( int i = 0; i < src_gray.rows; i++ )
+    {
+        for( int j = 0; j < src_gray.cols; j++ )
+        {
+            float lambda_1 = myHarris_dst.at<Vec6f>(i, j)[0];
+            float lambda_2 = myHarris_dst.at<Vec6f>(i, j)[1];
+            Mc.at<float>(i, j) = lambda_1*lambda_2 - 0.04f*((lambda_1 + lambda_2) * (lambda_1 + lambda_2));
+        }
+    }
+
+    minMaxLoc( Mc, &myHarris_minVal, &myHarris_maxVal );
+
+    /* Create Window and Trackbar */
+    namedWindow( myHarris_window );
+    createTrackbar( "Quality Level:", myHarris_window, &myHarris_qualityLevel, max_qualityLevel, myHarris_function );
+    myHarris_function( 0, 0 );
+
+    /// My Shi-Tomasi -- Using cornerMinEigenVal
+    cornerMinEigenVal( src_gray, myShiTomasi_dst, blockSize, apertureSize );
+
+    minMaxLoc( myShiTomasi_dst, &myShiTomasi_minVal, &myShiTomasi_maxVal );
+
+    /* Create Window and Trackbar */
+    namedWindow( myShiTomasi_window );
+    createTrackbar( "Quality Level:", myShiTomasi_window, &myShiTomasi_qualityLevel, max_qualityLevel, myShiTomasi_function );
+    myShiTomasi_function( 0, 0 );
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function myShiTomasi_function
+ */
+void myShiTomasi_function( int, void* )
+{
+    myShiTomasi_copy = src.clone();
+    myShiTomasi_qualityLevel = MAX(myShiTomasi_qualityLevel, 1);
+
+    for( int i = 0; i < src_gray.rows; i++ )
+    {
+        for( int j = 0; j < src_gray.cols; j++ )
+        {
+            if( myShiTomasi_dst.at<float>(i,j) > myShiTomasi_minVal + ( myShiTomasi_maxVal - myShiTomasi_minVal )*myShiTomasi_qualityLevel/max_qualityLevel )
+            {
+                circle( myShiTomasi_copy, Point(j,i), 4, Scalar( rng.uniform(0,256), rng.uniform(0,256), rng.uniform(0,256) ), FILLED );
+            }
+        }
+    }
+    imshow( myShiTomasi_window, myShiTomasi_copy );
+}
+
+/**
+ * @function myHarris_function
+ */
+void myHarris_function( int, void* )
+{
+    myHarris_copy = src.clone();
+    myHarris_qualityLevel = MAX(myHarris_qualityLevel, 1);
+
+    for( int i = 0; i < src_gray.rows; i++ )
+    {
+        for( int j = 0; j < src_gray.cols; j++ )
+        {
+            if( Mc.at<float>(i,j) > myHarris_minVal + ( myHarris_maxVal - myHarris_minVal )*myHarris_qualityLevel/max_qualityLevel )
+            {
+                circle( myHarris_copy, Point(j,i), 4, Scalar( rng.uniform(0,256), rng.uniform(0,256), rng.uniform(0,256) ), FILLED );
+            }
+        }
+    }
+    imshow( myHarris_window, myHarris_copy );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp
new file mode 100644
index 00000000..298f9523
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp
@@ -0,0 +1,87 @@
+/**
+ * @function cornerHarris_Demo.cpp
+ * @brief Demo code for detecting corners using Harris-Stephens method
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+Mat src, src_gray;
+int thresh = 200;
+int max_thresh = 255;
+
+const char* source_window = "Source image";
+const char* corners_window = "Corners detected";
+
+/// Function header
+void cornerHarris_demo( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    /// Load source image and convert it to gray
+    CommandLineParser parser( argc, argv, "{@input | building.jpg | input image}" );
+    src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if ( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+
+    /// Create a window and a trackbar
+    namedWindow( source_window );
+    createTrackbar( "Threshold: ", source_window, &thresh, max_thresh, cornerHarris_demo );
+    imshow( source_window, src );
+
+    cornerHarris_demo( 0, 0 );
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function cornerHarris_demo
+ * @brief Executes the corner detection and draw a circle around the possible corners
+ */
+void cornerHarris_demo( int, void* )
+{
+    /// Detector parameters
+    int blockSize = 2;
+    int apertureSize = 3;
+    double k = 0.04;
+
+    /// Detecting corners
+    Mat dst = Mat::zeros( src.size(), CV_32FC1 );
+    cornerHarris( src_gray, dst, blockSize, apertureSize, k );
+
+    /// Normalizing
+    Mat dst_norm, dst_norm_scaled;
+    normalize( dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat() );
+    convertScaleAbs( dst_norm, dst_norm_scaled );
+
+    /// Drawing a circle around corners
+    for( int i = 0; i < dst_norm.rows ; i++ )
+    {
+        for( int j = 0; j < dst_norm.cols; j++ )
+        {
+            if( (int) dst_norm.at<float>(i,j) > thresh )
+            {
+                circle( dst_norm_scaled, Point(j,i), 5,  Scalar(0), 2, 8, 0 );
+            }
+        }
+    }
+
+    /// Showing the result
+    namedWindow( corners_window );
+    imshow( corners_window, dst_norm_scaled );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp
new file mode 100644
index 00000000..5004496a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp
@@ -0,0 +1,112 @@
+/**
+ * @function cornerSubPix_Demo.cpp
+ * @brief Demo code for refining corner locations
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+Mat src, src_gray;
+
+int maxCorners = 10;
+int maxTrackbar = 25;
+
+RNG rng(12345);
+const char* source_window = "Image";
+
+/// Function header
+void goodFeaturesToTrack_Demo( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    /// Load source image and convert it to gray
+    CommandLineParser parser( argc, argv, "{@input | pic3.png | input image}" );
+    src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+
+    /// Create Window
+    namedWindow( source_window );
+
+    /// Create Trackbar to set the number of corners
+    createTrackbar( "Max corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );
+
+    imshow( source_window, src );
+
+    goodFeaturesToTrack_Demo( 0, 0 );
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function goodFeaturesToTrack_Demo.cpp
+ * @brief Apply Shi-Tomasi corner detector
+ */
+void goodFeaturesToTrack_Demo( int, void* )
+{
+    /// Parameters for Shi-Tomasi algorithm
+    maxCorners = MAX(maxCorners, 1);
+    vector<Point2f> corners;
+    double qualityLevel = 0.01;
+    double minDistance = 10;
+    int blockSize = 3, gradientSize = 3;
+    bool useHarrisDetector = false;
+    double k = 0.04;
+
+    /// Copy the source image
+    Mat copy = src.clone();
+
+    /// Apply corner detection
+    goodFeaturesToTrack( src_gray,
+                         corners,
+                         maxCorners,
+                         qualityLevel,
+                         minDistance,
+                         Mat(),
+                         blockSize,
+                         gradientSize,
+                         useHarrisDetector,
+                         k );
+
+
+    /// Draw corners detected
+    cout << "** Number of corners detected: " << corners.size() << endl;
+    int radius = 4;
+    for( size_t i = 0; i < corners.size(); i++ )
+    {
+        circle( copy, corners[i], radius, Scalar(rng.uniform(0,255), rng.uniform(0, 256), rng.uniform(0, 256)), FILLED );
+    }
+
+    /// Show what you got
+    namedWindow( source_window );
+    imshow( source_window, copy );
+
+    /// Set the needed parameters to find the refined corners
+    Size winSize = Size( 5, 5 );
+    Size zeroZone = Size( -1, -1 );
+    TermCriteria criteria = TermCriteria( TermCriteria::EPS + TermCriteria::COUNT, 40, 0.001 );
+
+    /// Calculate the refined corner locations
+    cornerSubPix( src_gray, corners, winSize, zeroZone, criteria );
+
+    /// Write them down
+    for( size_t i = 0; i < corners.size(); i++ )
+    {
+        cout << " -- Refined Corner [" << i << "]  (" << corners[i].x << "," << corners[i].y << ")" << endl;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp
new file mode 100644
index 00000000..f306f304
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp
@@ -0,0 +1,99 @@
+/**
+ * @function goodFeaturesToTrack_Demo.cpp
+ * @brief Demo code for detecting corners using Shi-Tomasi method
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+Mat src, src_gray;
+
+int maxCorners = 23;
+int maxTrackbar = 100;
+
+RNG rng(12345);
+const char* source_window = "Image";
+
+/// Function header
+void goodFeaturesToTrack_Demo( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    /// Load source image and convert it to gray
+    CommandLineParser parser( argc, argv, "{@input | pic3.png | input image}" );
+    src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+
+    /// Create Window
+    namedWindow( source_window );
+
+    /// Create Trackbar to set the number of corners
+    createTrackbar( "Max corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );
+
+    imshow( source_window, src );
+
+    goodFeaturesToTrack_Demo( 0, 0 );
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function goodFeaturesToTrack_Demo.cpp
+ * @brief Apply Shi-Tomasi corner detector
+ */
+void goodFeaturesToTrack_Demo( int, void* )
+{
+    /// Parameters for Shi-Tomasi algorithm
+    maxCorners = MAX(maxCorners, 1);
+    vector<Point2f> corners;
+    double qualityLevel = 0.01;
+    double minDistance = 10;
+    int blockSize = 3, gradientSize = 3;
+    bool useHarrisDetector = false;
+    double k = 0.04;
+
+    /// Copy the source image
+    Mat copy = src.clone();
+
+    /// Apply corner detection
+    goodFeaturesToTrack( src_gray,
+                         corners,
+                         maxCorners,
+                         qualityLevel,
+                         minDistance,
+                         Mat(),
+                         blockSize,
+                         gradientSize,
+                         useHarrisDetector,
+                         k );
+
+
+    /// Draw corners detected
+    cout << "** Number of corners detected: " << corners.size() << endl;
+    int radius = 4;
+    for( size_t i = 0; i < corners.size(); i++ )
+    {
+        circle( copy, corners[i], radius, Scalar(rng.uniform(0,255), rng.uniform(0, 256), rng.uniform(0, 256)), FILLED );
+    }
+
+    /// Show what you got
+    namedWindow( source_window );
+    imshow( source_window, copy );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/VID5.xml b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/VID5.xml
new file mode 100644
index 00000000..ac5bce79
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/VID5.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+<opencv_storage>
+<images>
+images/CameraCalibraation/VID5/xx1.jpg
+images/CameraCalibraation/VID5/xx2.jpg
+images/CameraCalibraation/VID5/xx3.jpg
+images/CameraCalibraation/VID5/xx4.jpg
+images/CameraCalibraation/VID5/xx5.jpg
+images/CameraCalibraation/VID5/xx6.jpg
+images/CameraCalibraation/VID5/xx7.jpg
+images/CameraCalibraation/VID5/xx8.jpg
+</images>
+</opencv_storage>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp
new file mode 100644
index 00000000..b57ea65b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp
@@ -0,0 +1,751 @@
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <ctime>
+#include <cstdio>
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/calib3d.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace cv;
+using namespace std;
+
+class Settings
+{
+public:
+    Settings() : goodInput(false) {}
+    enum Pattern { NOT_EXISTING, CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
+    enum InputType { INVALID, CAMERA, VIDEO_FILE, IMAGE_LIST };
+
+    void write(FileStorage& fs) const                        //Write serialization for this class
+    {
+        fs << "{"
+                  << "BoardSize_Width"  << boardSize.width
+                  << "BoardSize_Height" << boardSize.height
+                  << "Square_Size"         << squareSize
+                  << "Calibrate_Pattern" << patternToUse
+                  << "Calibrate_NrOfFrameToUse" << nrFrames
+                  << "Calibrate_FixAspectRatio" << aspectRatio
+                  << "Calibrate_AssumeZeroTangentialDistortion" << calibZeroTangentDist
+                  << "Calibrate_FixPrincipalPointAtTheCenter" << calibFixPrincipalPoint
+
+                  << "Write_DetectedFeaturePoints" << writePoints
+                  << "Write_extrinsicParameters"   << writeExtrinsics
+                  << "Write_gridPoints" << writeGrid
+                  << "Write_outputFileName"  << outputFileName
+
+                  << "Show_UndistortedImage" << showUndistorted
+
+                  << "Input_FlipAroundHorizontalAxis" << flipVertical
+                  << "Input_Delay" << delay
+                  << "Input" << input
+           << "}";
+    }
+    void read(const FileNode& node)                          //Read serialization for this class
+    {
+        node["BoardSize_Width" ] >> boardSize.width;
+        node["BoardSize_Height"] >> boardSize.height;
+        node["Calibrate_Pattern"] >> patternToUse;
+        node["Square_Size"]  >> squareSize;
+        node["Calibrate_NrOfFrameToUse"] >> nrFrames;
+        node["Calibrate_FixAspectRatio"] >> aspectRatio;
+        node["Write_DetectedFeaturePoints"] >> writePoints;
+        node["Write_extrinsicParameters"] >> writeExtrinsics;
+        node["Write_gridPoints"] >> writeGrid;
+        node["Write_outputFileName"] >> outputFileName;
+        node["Calibrate_AssumeZeroTangentialDistortion"] >> calibZeroTangentDist;
+        node["Calibrate_FixPrincipalPointAtTheCenter"] >> calibFixPrincipalPoint;
+        node["Calibrate_UseFisheyeModel"] >> useFisheye;
+        node["Input_FlipAroundHorizontalAxis"] >> flipVertical;
+        node["Show_UndistortedImage"] >> showUndistorted;
+        node["Input"] >> input;
+        node["Input_Delay"] >> delay;
+        node["Fix_K1"] >> fixK1;
+        node["Fix_K2"] >> fixK2;
+        node["Fix_K3"] >> fixK3;
+        node["Fix_K4"] >> fixK4;
+        node["Fix_K5"] >> fixK5;
+
+        validate();
+    }
+    void validate()
+    {
+        goodInput = true;
+        if (boardSize.width <= 0 || boardSize.height <= 0)
+        {
+            cerr << "Invalid Board size: " << boardSize.width << " " << boardSize.height << endl;
+            goodInput = false;
+        }
+        if (squareSize <= 10e-6)
+        {
+            cerr << "Invalid square size " << squareSize << endl;
+            goodInput = false;
+        }
+        if (nrFrames <= 0)
+        {
+            cerr << "Invalid number of frames " << nrFrames << endl;
+            goodInput = false;
+        }
+
+        if (input.empty())      // Check for valid input
+                inputType = INVALID;
+        else
+        {
+            if (input[0] >= '0' && input[0] <= '9')
+            {
+                stringstream ss(input);
+                ss >> cameraID;
+                inputType = CAMERA;
+            }
+            else
+            {
+                if (isListOfImages(input) && readStringList(input, imageList))
+                {
+                    inputType = IMAGE_LIST;
+                    nrFrames = (nrFrames < (int)imageList.size()) ? nrFrames : (int)imageList.size();
+                }
+                else
+                    inputType = VIDEO_FILE;
+            }
+            if (inputType == CAMERA)
+                inputCapture.open(cameraID);
+            if (inputType == VIDEO_FILE)
+                inputCapture.open(input);
+            if (inputType != IMAGE_LIST && !inputCapture.isOpened())
+                    inputType = INVALID;
+        }
+        if (inputType == INVALID)
+        {
+            cerr << " Input does not exist: " << input;
+            goodInput = false;
+        }
+
+        flag = 0;
+        if(calibFixPrincipalPoint) flag |= CALIB_FIX_PRINCIPAL_POINT;
+        if(calibZeroTangentDist)   flag |= CALIB_ZERO_TANGENT_DIST;
+        if(aspectRatio)            flag |= CALIB_FIX_ASPECT_RATIO;
+        if(fixK1)                  flag |= CALIB_FIX_K1;
+        if(fixK2)                  flag |= CALIB_FIX_K2;
+        if(fixK3)                  flag |= CALIB_FIX_K3;
+        if(fixK4)                  flag |= CALIB_FIX_K4;
+        if(fixK5)                  flag |= CALIB_FIX_K5;
+
+        if (useFisheye) {
+            // the fisheye model has its own enum, so overwrite the flags
+            flag = fisheye::CALIB_FIX_SKEW | fisheye::CALIB_RECOMPUTE_EXTRINSIC;
+            if(fixK1)                   flag |= fisheye::CALIB_FIX_K1;
+            if(fixK2)                   flag |= fisheye::CALIB_FIX_K2;
+            if(fixK3)                   flag |= fisheye::CALIB_FIX_K3;
+            if(fixK4)                   flag |= fisheye::CALIB_FIX_K4;
+            if (calibFixPrincipalPoint) flag |= fisheye::CALIB_FIX_PRINCIPAL_POINT;
+        }
+
+        calibrationPattern = NOT_EXISTING;
+        if (!patternToUse.compare("CHESSBOARD")) calibrationPattern = CHESSBOARD;
+        if (!patternToUse.compare("CIRCLES_GRID")) calibrationPattern = CIRCLES_GRID;
+        if (!patternToUse.compare("ASYMMETRIC_CIRCLES_GRID")) calibrationPattern = ASYMMETRIC_CIRCLES_GRID;
+        if (calibrationPattern == NOT_EXISTING)
+        {
+            cerr << " Camera calibration mode does not exist: " << patternToUse << endl;
+            goodInput = false;
+        }
+        atImageList = 0;
+
+    }
+    Mat nextImage()
+    {
+        Mat result;
+        if( inputCapture.isOpened() )
+        {
+            Mat view0;
+            inputCapture >> view0;
+            view0.copyTo(result);
+        }
+        else if( atImageList < imageList.size() )
+            result = imread(imageList[atImageList++], IMREAD_COLOR);
+
+        return result;
+    }
+
+    static bool readStringList( const string& filename, vector<string>& l )
+    {
+        l.clear();
+        FileStorage fs(filename, FileStorage::READ);
+        if( !fs.isOpened() )
+            return false;
+        FileNode n = fs.getFirstTopLevelNode();
+        if( n.type() != FileNode::SEQ )
+            return false;
+        FileNodeIterator it = n.begin(), it_end = n.end();
+        for( ; it != it_end; ++it )
+            l.push_back((string)*it);
+        return true;
+    }
+
+    static bool isListOfImages( const string& filename)
+    {
+        string s(filename);
+        // Look for file extension
+        if( s.find(".xml") == string::npos && s.find(".yaml") == string::npos && s.find(".yml") == string::npos )
+            return false;
+        else
+            return true;
+    }
+public:
+    Size boardSize;              // The size of the board -> Number of items by width and height
+    Pattern calibrationPattern;  // One of the Chessboard, circles, or asymmetric circle pattern
+    float squareSize;            // The size of a square in your defined unit (point, millimeter,etc).
+    int nrFrames;                // The number of frames to use from the input for calibration
+    float aspectRatio;           // The aspect ratio
+    int delay;                   // In case of a video input
+    bool writePoints;            // Write detected feature points
+    bool writeExtrinsics;        // Write extrinsic parameters
+    bool writeGrid;              // Write refined 3D target grid points
+    bool calibZeroTangentDist;   // Assume zero tangential distortion
+    bool calibFixPrincipalPoint; // Fix the principal point at the center
+    bool flipVertical;           // Flip the captured images around the horizontal axis
+    string outputFileName;       // The name of the file where to write
+    bool showUndistorted;        // Show undistorted images after calibration
+    string input;                // The input ->
+    bool useFisheye;             // use fisheye camera model for calibration
+    bool fixK1;                  // fix K1 distortion coefficient
+    bool fixK2;                  // fix K2 distortion coefficient
+    bool fixK3;                  // fix K3 distortion coefficient
+    bool fixK4;                  // fix K4 distortion coefficient
+    bool fixK5;                  // fix K5 distortion coefficient
+
+    int cameraID;
+    vector<string> imageList;
+    size_t atImageList;
+    VideoCapture inputCapture;
+    InputType inputType;
+    bool goodInput;
+    int flag;
+
+private:
+    string patternToUse;
+
+
+};
+
+static inline void read(const FileNode& node, Settings& x, const Settings& default_value = Settings())
+{
+    if(node.empty())
+        x = default_value;
+    else
+        x.read(node);
+}
+
+enum { DETECTION = 0, CAPTURING = 1, CALIBRATED = 2 };
+
+bool runCalibrationAndSave(Settings& s, Size imageSize, Mat&  cameraMatrix, Mat& distCoeffs,
+                           vector<vector<Point2f> > imagePoints, float grid_width, bool release_object);
+
+int main(int argc, char* argv[])
+{
+    const String keys
+        = "{help h usage ? |           | print this message            }"
+          "{@settings      |default.xml| input setting file            }"
+          "{d              |           | actual distance between top-left and top-right corners of "
+          "the calibration grid }"
+          "{winSize        | 11        | Half of search window for cornerSubPix }";
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("This is a camera calibration sample.\n"
+                 "Usage: camera_calibration [configuration_file -- default ./default.xml]\n"
+                 "Near the sample file you'll find the configuration file, which has detailed help of "
+                 "how to edit it. It may be any OpenCV supported file format XML/YAML.");
+    if (!parser.check()) {
+        parser.printErrors();
+        return 0;
+    }
+
+    if (parser.has("help")) {
+        parser.printMessage();
+        return 0;
+    }
+
+    //! [file_read]
+    Settings s;
+    const string inputSettingsFile = parser.get<string>(0);
+    FileStorage fs(inputSettingsFile, FileStorage::READ); // Read the settings
+    if (!fs.isOpened())
+    {
+        cout << "Could not open the configuration file: \"" << inputSettingsFile << "\"" << endl;
+        parser.printMessage();
+        return -1;
+    }
+    fs["Settings"] >> s;
+    fs.release();                                         // close Settings file
+    //! [file_read]
+
+    //FileStorage fout("settings.yml", FileStorage::WRITE); // write config as YAML
+    //fout << "Settings" << s;
+
+    if (!s.goodInput)
+    {
+        cout << "Invalid input detected. Application stopping. " << endl;
+        return -1;
+    }
+
+    int winSize = parser.get<int>("winSize");
+
+    float grid_width = s.squareSize * (s.boardSize.width - 1);
+    bool release_object = false;
+    if (parser.has("d")) {
+        grid_width = parser.get<float>("d");
+        release_object = true;
+    }
+
+    vector<vector<Point2f> > imagePoints;
+    Mat cameraMatrix, distCoeffs;
+    Size imageSize;
+    int mode = s.inputType == Settings::IMAGE_LIST ? CAPTURING : DETECTION;
+    clock_t prevTimestamp = 0;
+    const Scalar RED(0,0,255), GREEN(0,255,0);
+    const char ESC_KEY = 27;
+
+    //! [get_input]
+    for(;;)
+    {
+        Mat view;
+        bool blinkOutput = false;
+
+        view = s.nextImage();
+
+        //-----  If no more image, or got enough, then stop calibration and show result -------------
+        if( mode == CAPTURING && imagePoints.size() >= (size_t)s.nrFrames )
+        {
+          if(runCalibrationAndSave(s, imageSize,  cameraMatrix, distCoeffs, imagePoints, grid_width,
+                                   release_object))
+              mode = CALIBRATED;
+          else
+              mode = DETECTION;
+        }
+        if(view.empty())          // If there are no more images stop the loop
+        {
+            // if calibration threshold was not reached yet, calibrate now
+            if( mode != CALIBRATED && !imagePoints.empty() )
+                runCalibrationAndSave(s, imageSize,  cameraMatrix, distCoeffs, imagePoints, grid_width,
+                                      release_object);
+            break;
+        }
+        //! [get_input]
+
+        imageSize = view.size();  // Format input image.
+        if( s.flipVertical )    flip( view, view, 0 );
+
+        //! [find_pattern]
+        vector<Point2f> pointBuf;
+
+        bool found;
+
+        int chessBoardFlags = CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_NORMALIZE_IMAGE;
+
+        if(!s.useFisheye) {
+            // fast check erroneously fails with high distortions like fisheye
+            chessBoardFlags |= CALIB_CB_FAST_CHECK;
+        }
+
+        switch( s.calibrationPattern ) // Find feature points on the input format
+        {
+        case Settings::CHESSBOARD:
+            found = findChessboardCorners( view, s.boardSize, pointBuf, chessBoardFlags);
+            break;
+        case Settings::CIRCLES_GRID:
+            found = findCirclesGrid( view, s.boardSize, pointBuf );
+            break;
+        case Settings::ASYMMETRIC_CIRCLES_GRID:
+            found = findCirclesGrid( view, s.boardSize, pointBuf, CALIB_CB_ASYMMETRIC_GRID );
+            break;
+        default:
+            found = false;
+            break;
+        }
+        //! [find_pattern]
+        //! [pattern_found]
+        if ( found)                // If done with success,
+        {
+              // improve the found corners' coordinate accuracy for chessboard
+                if( s.calibrationPattern == Settings::CHESSBOARD)
+                {
+                    Mat viewGray;
+                    cvtColor(view, viewGray, COLOR_BGR2GRAY);
+                    cornerSubPix( viewGray, pointBuf, Size(winSize,winSize),
+                        Size(-1,-1), TermCriteria( TermCriteria::EPS+TermCriteria::COUNT, 30, 0.0001 ));
+                }
+
+                if( mode == CAPTURING &&  // For camera only take new samples after delay time
+                    (!s.inputCapture.isOpened() || clock() - prevTimestamp > s.delay*1e-3*CLOCKS_PER_SEC) )
+                {
+                    imagePoints.push_back(pointBuf);
+                    prevTimestamp = clock();
+                    blinkOutput = s.inputCapture.isOpened();
+                }
+
+                // Draw the corners.
+                drawChessboardCorners( view, s.boardSize, Mat(pointBuf), found );
+        }
+        //! [pattern_found]
+        //----------------------------- Output Text ------------------------------------------------
+        //! [output_text]
+        string msg = (mode == CAPTURING) ? "100/100" :
+                      mode == CALIBRATED ? "Calibrated" : "Press 'g' to start";
+        int baseLine = 0;
+        Size textSize = getTextSize(msg, 1, 1, 1, &baseLine);
+        Point textOrigin(view.cols - 2*textSize.width - 10, view.rows - 2*baseLine - 10);
+
+        if( mode == CAPTURING )
+        {
+            if(s.showUndistorted)
+                msg = cv::format( "%d/%d Undist", (int)imagePoints.size(), s.nrFrames );
+            else
+                msg = cv::format( "%d/%d", (int)imagePoints.size(), s.nrFrames );
+        }
+
+        putText( view, msg, textOrigin, 1, 1, mode == CALIBRATED ?  GREEN : RED);
+
+        if( blinkOutput )
+            bitwise_not(view, view);
+        //! [output_text]
+        //------------------------- Video capture  output  undistorted ------------------------------
+        //! [output_undistorted]
+        if( mode == CALIBRATED && s.showUndistorted )
+        {
+            Mat temp = view.clone();
+            if (s.useFisheye)
+            {
+                Mat newCamMat;
+                fisheye::estimateNewCameraMatrixForUndistortRectify(cameraMatrix, distCoeffs, imageSize,
+                                                                    Matx33d::eye(), newCamMat, 1);
+                cv::fisheye::undistortImage(temp, view, cameraMatrix, distCoeffs, newCamMat);
+            }
+            else
+              undistort(temp, view, cameraMatrix, distCoeffs);
+        }
+        //! [output_undistorted]
+        //------------------------------ Show image and check for input commands -------------------
+        //! [await_input]
+        imshow("Image View", view);
+        char key = (char)waitKey(s.inputCapture.isOpened() ? 50 : s.delay);
+
+        if( key  == ESC_KEY )
+            break;
+
+        if( key == 'u' && mode == CALIBRATED )
+           s.showUndistorted = !s.showUndistorted;
+
+        if( s.inputCapture.isOpened() && key == 'g' )
+        {
+            mode = CAPTURING;
+            imagePoints.clear();
+        }
+        //! [await_input]
+    }
+
+    // -----------------------Show the undistorted image for the image list ------------------------
+    //! [show_results]
+    if( s.inputType == Settings::IMAGE_LIST && s.showUndistorted && !cameraMatrix.empty())
+    {
+        Mat view, rview, map1, map2;
+
+        if (s.useFisheye)
+        {
+            Mat newCamMat;
+            fisheye::estimateNewCameraMatrixForUndistortRectify(cameraMatrix, distCoeffs, imageSize,
+                                                                Matx33d::eye(), newCamMat, 1);
+            fisheye::initUndistortRectifyMap(cameraMatrix, distCoeffs, Matx33d::eye(), newCamMat, imageSize,
+                                             CV_16SC2, map1, map2);
+        }
+        else
+        {
+            initUndistortRectifyMap(
+                cameraMatrix, distCoeffs, Mat(),
+                getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, 1, imageSize, 0), imageSize,
+                CV_16SC2, map1, map2);
+        }
+
+        for(size_t i = 0; i < s.imageList.size(); i++ )
+        {
+            view = imread(s.imageList[i], IMREAD_COLOR);
+            if(view.empty())
+                continue;
+            remap(view, rview, map1, map2, INTER_LINEAR);
+            imshow("Image View", rview);
+            char c = (char)waitKey();
+            if( c  == ESC_KEY || c == 'q' || c == 'Q' )
+                break;
+        }
+    }
+    //! [show_results]
+
+    return 0;
+}
+
+//! [compute_errors]
+static double computeReprojectionErrors( const vector<vector<Point3f> >& objectPoints,
+                                         const vector<vector<Point2f> >& imagePoints,
+                                         const vector<Mat>& rvecs, const vector<Mat>& tvecs,
+                                         const Mat& cameraMatrix , const Mat& distCoeffs,
+                                         vector<float>& perViewErrors, bool fisheye)
+{
+    vector<Point2f> imagePoints2;
+    size_t totalPoints = 0;
+    double totalErr = 0, err;
+    perViewErrors.resize(objectPoints.size());
+
+    for(size_t i = 0; i < objectPoints.size(); ++i )
+    {
+        if (fisheye)
+        {
+            fisheye::projectPoints(objectPoints[i], imagePoints2, rvecs[i], tvecs[i], cameraMatrix,
+                                   distCoeffs);
+        }
+        else
+        {
+            projectPoints(objectPoints[i], rvecs[i], tvecs[i], cameraMatrix, distCoeffs, imagePoints2);
+        }
+        err = norm(imagePoints[i], imagePoints2, NORM_L2);
+
+        size_t n = objectPoints[i].size();
+        perViewErrors[i] = (float) std::sqrt(err*err/n);
+        totalErr        += err*err;
+        totalPoints     += n;
+    }
+
+    return std::sqrt(totalErr/totalPoints);
+}
+//! [compute_errors]
+//! [board_corners]
+static void calcBoardCornerPositions(Size boardSize, float squareSize, vector<Point3f>& corners,
+                                     Settings::Pattern patternType /*= Settings::CHESSBOARD*/)
+{
+    corners.clear();
+
+    switch(patternType)
+    {
+    case Settings::CHESSBOARD:
+    case Settings::CIRCLES_GRID:
+        for( int i = 0; i < boardSize.height; ++i )
+            for( int j = 0; j < boardSize.width; ++j )
+                corners.push_back(Point3f(j*squareSize, i*squareSize, 0));
+        break;
+
+    case Settings::ASYMMETRIC_CIRCLES_GRID:
+        for( int i = 0; i < boardSize.height; i++ )
+            for( int j = 0; j < boardSize.width; j++ )
+                corners.push_back(Point3f((2*j + i % 2)*squareSize, i*squareSize, 0));
+        break;
+    default:
+        break;
+    }
+}
+//! [board_corners]
+static bool runCalibration( Settings& s, Size& imageSize, Mat& cameraMatrix, Mat& distCoeffs,
+                            vector<vector<Point2f> > imagePoints, vector<Mat>& rvecs, vector<Mat>& tvecs,
+                            vector<float>& reprojErrs,  double& totalAvgErr, vector<Point3f>& newObjPoints,
+                            float grid_width, bool release_object)
+{
+    //! [fixed_aspect]
+    cameraMatrix = Mat::eye(3, 3, CV_64F);
+    if( !s.useFisheye && s.flag & CALIB_FIX_ASPECT_RATIO )
+        cameraMatrix.at<double>(0,0) = s.aspectRatio;
+    //! [fixed_aspect]
+    if (s.useFisheye) {
+        distCoeffs = Mat::zeros(4, 1, CV_64F);
+    } else {
+        distCoeffs = Mat::zeros(8, 1, CV_64F);
+    }
+
+    vector<vector<Point3f> > objectPoints(1);
+    calcBoardCornerPositions(s.boardSize, s.squareSize, objectPoints[0], s.calibrationPattern);
+    objectPoints[0][s.boardSize.width - 1].x = objectPoints[0][0].x + grid_width;
+    newObjPoints = objectPoints[0];
+
+    objectPoints.resize(imagePoints.size(),objectPoints[0]);
+
+    //Find intrinsic and extrinsic camera parameters
+    double rms;
+
+    if (s.useFisheye) {
+        Mat _rvecs, _tvecs;
+        rms = fisheye::calibrate(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, _rvecs,
+                                 _tvecs, s.flag);
+
+        rvecs.reserve(_rvecs.rows);
+        tvecs.reserve(_tvecs.rows);
+        for(int i = 0; i < int(objectPoints.size()); i++){
+            rvecs.push_back(_rvecs.row(i));
+            tvecs.push_back(_tvecs.row(i));
+        }
+    } else {
+        int iFixedPoint = -1;
+        if (release_object)
+            iFixedPoint = s.boardSize.width - 1;
+        rms = calibrateCameraRO(objectPoints, imagePoints, imageSize, iFixedPoint,
+                                cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints,
+                                s.flag | CALIB_USE_LU);
+    }
+
+    if (release_object) {
+        cout << "New board corners: " << endl;
+        cout << newObjPoints[0] << endl;
+        cout << newObjPoints[s.boardSize.width - 1] << endl;
+        cout << newObjPoints[s.boardSize.width * (s.boardSize.height - 1)] << endl;
+        cout << newObjPoints.back() << endl;
+    }
+
+    cout << "Re-projection error reported by calibrateCamera: "<< rms << endl;
+
+    bool ok = checkRange(cameraMatrix) && checkRange(distCoeffs);
+
+    objectPoints.clear();
+    objectPoints.resize(imagePoints.size(), newObjPoints);
+    totalAvgErr = computeReprojectionErrors(objectPoints, imagePoints, rvecs, tvecs, cameraMatrix,
+                                            distCoeffs, reprojErrs, s.useFisheye);
+
+    return ok;
+}
+
+// Print camera parameters to the output file
+static void saveCameraParams( Settings& s, Size& imageSize, Mat& cameraMatrix, Mat& distCoeffs,
+                              const vector<Mat>& rvecs, const vector<Mat>& tvecs,
+                              const vector<float>& reprojErrs, const vector<vector<Point2f> >& imagePoints,
+                              double totalAvgErr, const vector<Point3f>& newObjPoints )
+{
+    FileStorage fs( s.outputFileName, FileStorage::WRITE );
+
+    time_t tm;
+    time( &tm );
+    struct tm *t2 = localtime( &tm );
+    char buf[1024];
+    strftime( buf, sizeof(buf), "%c", t2 );
+
+    fs << "calibration_time" << buf;
+
+    if( !rvecs.empty() || !reprojErrs.empty() )
+        fs << "nr_of_frames" << (int)std::max(rvecs.size(), reprojErrs.size());
+    fs << "image_width" << imageSize.width;
+    fs << "image_height" << imageSize.height;
+    fs << "board_width" << s.boardSize.width;
+    fs << "board_height" << s.boardSize.height;
+    fs << "square_size" << s.squareSize;
+
+    if( !s.useFisheye && s.flag & CALIB_FIX_ASPECT_RATIO )
+        fs << "fix_aspect_ratio" << s.aspectRatio;
+
+    if (s.flag)
+    {
+        std::stringstream flagsStringStream;
+        if (s.useFisheye)
+        {
+            flagsStringStream << "flags:"
+                << (s.flag & fisheye::CALIB_FIX_SKEW ? " +fix_skew" : "")
+                << (s.flag & fisheye::CALIB_FIX_K1 ? " +fix_k1" : "")
+                << (s.flag & fisheye::CALIB_FIX_K2 ? " +fix_k2" : "")
+                << (s.flag & fisheye::CALIB_FIX_K3 ? " +fix_k3" : "")
+                << (s.flag & fisheye::CALIB_FIX_K4 ? " +fix_k4" : "")
+                << (s.flag & fisheye::CALIB_RECOMPUTE_EXTRINSIC ? " +recompute_extrinsic" : "");
+        }
+        else
+        {
+            flagsStringStream << "flags:"
+                << (s.flag & CALIB_USE_INTRINSIC_GUESS ? " +use_intrinsic_guess" : "")
+                << (s.flag & CALIB_FIX_ASPECT_RATIO ? " +fix_aspectRatio" : "")
+                << (s.flag & CALIB_FIX_PRINCIPAL_POINT ? " +fix_principal_point" : "")
+                << (s.flag & CALIB_ZERO_TANGENT_DIST ? " +zero_tangent_dist" : "")
+                << (s.flag & CALIB_FIX_K1 ? " +fix_k1" : "")
+                << (s.flag & CALIB_FIX_K2 ? " +fix_k2" : "")
+                << (s.flag & CALIB_FIX_K3 ? " +fix_k3" : "")
+                << (s.flag & CALIB_FIX_K4 ? " +fix_k4" : "")
+                << (s.flag & CALIB_FIX_K5 ? " +fix_k5" : "");
+        }
+        fs.writeComment(flagsStringStream.str());
+    }
+
+    fs << "flags" << s.flag;
+
+    fs << "fisheye_model" << s.useFisheye;
+
+    fs << "camera_matrix" << cameraMatrix;
+    fs << "distortion_coefficients" << distCoeffs;
+
+    fs << "avg_reprojection_error" << totalAvgErr;
+    if (s.writeExtrinsics && !reprojErrs.empty())
+        fs << "per_view_reprojection_errors" << Mat(reprojErrs);
+
+    if(s.writeExtrinsics && !rvecs.empty() && !tvecs.empty() )
+    {
+        CV_Assert(rvecs[0].type() == tvecs[0].type());
+        Mat bigmat((int)rvecs.size(), 6, CV_MAKETYPE(rvecs[0].type(), 1));
+        bool needReshapeR = rvecs[0].depth() != 1 ? true : false;
+        bool needReshapeT = tvecs[0].depth() != 1 ? true : false;
+
+        for( size_t i = 0; i < rvecs.size(); i++ )
+        {
+            Mat r = bigmat(Range(int(i), int(i+1)), Range(0,3));
+            Mat t = bigmat(Range(int(i), int(i+1)), Range(3,6));
+
+            if(needReshapeR)
+                rvecs[i].reshape(1, 1).copyTo(r);
+            else
+            {
+                //*.t() is MatExpr (not Mat) so we can use assignment operator
+                CV_Assert(rvecs[i].rows == 3 && rvecs[i].cols == 1);
+                r = rvecs[i].t();
+            }
+
+            if(needReshapeT)
+                tvecs[i].reshape(1, 1).copyTo(t);
+            else
+            {
+                CV_Assert(tvecs[i].rows == 3 && tvecs[i].cols == 1);
+                t = tvecs[i].t();
+            }
+        }
+        fs.writeComment("a set of 6-tuples (rotation vector + translation vector) for each view");
+        fs << "extrinsic_parameters" << bigmat;
+    }
+
+    if(s.writePoints && !imagePoints.empty() )
+    {
+        Mat imagePtMat((int)imagePoints.size(), (int)imagePoints[0].size(), CV_32FC2);
+        for( size_t i = 0; i < imagePoints.size(); i++ )
+        {
+            Mat r = imagePtMat.row(int(i)).reshape(2, imagePtMat.cols);
+            Mat imgpti(imagePoints[i]);
+            imgpti.copyTo(r);
+        }
+        fs << "image_points" << imagePtMat;
+    }
+
+    if( s.writeGrid && !newObjPoints.empty() )
+    {
+        fs << "grid_points" << newObjPoints;
+    }
+}
+
+//! [run_and_save]
+bool runCalibrationAndSave(Settings& s, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs,
+                           vector<vector<Point2f> > imagePoints, float grid_width, bool release_object)
+{
+    vector<Mat> rvecs, tvecs;
+    vector<float> reprojErrs;
+    double totalAvgErr = 0;
+    vector<Point3f> newObjPoints;
+
+    bool ok = runCalibration(s, imageSize, cameraMatrix, distCoeffs, imagePoints, rvecs, tvecs, reprojErrs,
+                             totalAvgErr, newObjPoints, grid_width, release_object);
+    cout << (ok ? "Calibration succeeded" : "Calibration failed")
+         << ". avg re projection error = " << totalAvgErr << endl;
+
+    if (ok)
+        saveCameraParams(s, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, reprojErrs, imagePoints,
+                         totalAvgErr, newObjPoints);
+    return ok;
+}
+//! [run_and_save]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/in_VID5.xml b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/in_VID5.xml
new file mode 100644
index 00000000..42e80c85
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/in_VID5.xml
@@ -0,0 +1,59 @@
+<?xml version="1.0"?>
+<opencv_storage>
+<Settings>
+  <!-- Number of inner corners per a item row and column. (square, circle) -->
+  <BoardSize_Width> 9</BoardSize_Width>
+  <BoardSize_Height>6</BoardSize_Height>
+  
+  <!-- The size of a square in some user defined metric system (pixel, millimeter)-->
+  <Square_Size>50</Square_Size>
+  
+  <!-- The type of input used for camera calibration. One of: CHESSBOARD CIRCLES_GRID ASYMMETRIC_CIRCLES_GRID -->
+  <Calibrate_Pattern>"CHESSBOARD"</Calibrate_Pattern>
+  
+  <!-- The input to use for calibration. 
+		To use an input camera -> give the ID of the camera, like "1"
+		To use an input video  -> give the path of the input video, like "/tmp/x.avi"
+		To use an image list   -> give the path to the XML or YAML file containing the list of the images, like "/tmp/circles_list.xml"
+		-->
+  <Input>"images/CameraCalibration/VID5/VID5.xml"</Input>
+  <!--  If true (non-zero) we flip the input images around the horizontal axis.-->
+  <Input_FlipAroundHorizontalAxis>0</Input_FlipAroundHorizontalAxis>
+  
+  <!-- Time delay between frames in case of camera. -->
+  <Input_Delay>100</Input_Delay>	
+  
+  <!-- How many frames to use, for calibration. -->
+  <Calibrate_NrOfFrameToUse>25</Calibrate_NrOfFrameToUse>
+  <!-- Consider only fy as a free parameter, the ratio fx/fy stays the same as in the input cameraMatrix. 
+	   Use or not setting. 0 - False Non-Zero - True-->
+  <Calibrate_FixAspectRatio> 1 </Calibrate_FixAspectRatio>
+  <!-- If true (non-zero) tangential distortion coefficients  are set to zeros and stay zero.-->
+  <Calibrate_AssumeZeroTangentialDistortion>1</Calibrate_AssumeZeroTangentialDistortion>
+  <!-- If true (non-zero) the principal point is not changed during the global optimization.-->
+  <Calibrate_FixPrincipalPointAtTheCenter> 1 </Calibrate_FixPrincipalPointAtTheCenter>
+  
+  <!-- The name of the output log file. -->
+  <Write_outputFileName>"out_camera_data.xml"</Write_outputFileName>
+  <!-- If true (non-zero) we write to the output file the feature points.-->
+  <Write_DetectedFeaturePoints>1</Write_DetectedFeaturePoints>
+  <!-- If true (non-zero) we write to the output file the extrinsic camera parameters.-->
+  <Write_extrinsicParameters>1</Write_extrinsicParameters>
+  <!-- If true (non-zero) we write to the output file the refined 3D target grid points.-->
+  <Write_gridPoints>1</Write_gridPoints>
+  <!-- If true (non-zero) we show after calibration the undistorted images.-->
+  <Show_UndistortedImage>1</Show_UndistortedImage>
+  <!-- If true (non-zero) will be used fisheye camera model.-->
+  <Calibrate_UseFisheyeModel>0</Calibrate_UseFisheyeModel>
+  <!-- If true (non-zero) distortion coefficient k1 will be equals to zero.-->
+  <Fix_K1>0</Fix_K1>
+  <!-- If true (non-zero) distortion coefficient k2 will be equals to zero.-->
+  <Fix_K2>0</Fix_K2>
+  <!-- If true (non-zero) distortion coefficient k3 will be equals to zero.-->
+  <Fix_K3>0</Fix_K3>
+  <!-- If true (non-zero) distortion coefficient k4 will be equals to zero.-->
+  <Fix_K4>1</Fix_K4>
+  <!-- If true (non-zero) distortion coefficient k5 will be equals to zero.-->
+  <Fix_K5>1</Fix_K5>
+</Settings>
+</opencv_storage>
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/out_camera_data.yml b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/out_camera_data.yml
new file mode 100644
index 00000000..c8c960bb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/camera_calibration/out_camera_data.yml
@@ -0,0 +1,352 @@
+%YAML:1.0
+calibration_Time: "08/19/11 20:44:38"
+nrOfFrames: 8
+image_Width: 640
+image_Height: 480
+board_Width: 9
+board_Height: 6
+square_Size: 50.
+FixAspectRatio: 1.
+# flags:  +fix_aspectRatio +fix_principal_point +zero_tangent_dist
+flagValue: 14
+Camera_Matrix: !!opencv-matrix
+   rows: 3
+   cols: 3
+   dt: d
+   data: [ 6.5746697810243404e+002, 0., 3.1950000000000000e+002, 0.,
+       6.5746697810243404e+002, 2.3950000000000000e+002, 0., 0., 1. ]
+Distortion_Coefficients: !!opencv-matrix
+   rows: 5
+   cols: 1
+   dt: d
+   data: [ -4.1802327018241026e-001, 5.0715243805833121e-001, 0., 0.,
+       -5.7843596847939704e-001 ]
+Avg_Reprojection_Error: 3.8441346462381665e-001
+Per_View_Reprojection_Errors: !!opencv-matrix
+   rows: 8
+   cols: 1
+   dt: f
+   data: [ 5.04357755e-001, 4.85754758e-001, 3.99563968e-001,
+       4.13829178e-001, 3.53570908e-001, 3.21116358e-001,
+       2.74473161e-001, 2.39761785e-001 ]
+# a set of 6-tuples (rotation vector + translation vector) for each view
+Extrinsic_Parameters: !!opencv-matrix
+   rows: 8
+   cols: 6
+   dt: d
+   data: [ -7.8704123655486097e-002, -1.5922384772614945e-001,
+       3.1166227207451498e+000, 2.4224388101960471e+002,
+       1.1795590397660339e+002, 6.2576484126093249e+002,
+       -1.4117480285164308e-001, -1.7917415443804836e-002,
+       3.1333182268743949e+000, 2.5943034781849354e+002,
+       1.4039780562976958e+002, 6.3848706527260981e+002,
+       7.2230525186138789e-002, -7.5445981266787754e-002,
+       1.5712860749221762e+000, 1.7426560451795339e+002,
+       -1.9309240362258871e+002, 7.0891416556762647e+002,
+       2.0367310600105853e-002, 6.8565520026996951e-002,
+       -5.4313033031644169e-004, -2.0146314940404827e+002,
+       -1.3305643514116997e+002, 7.4933554744027231e+002,
+       -3.4468530027734055e-002, 2.1921265175331925e-002,
+       -1.5731053528054522e+000, -1.1155718744299284e+002,
+       2.0307615364261443e+002, 8.4915903914333899e+002,
+       3.7425562109513817e-002, 7.4883169379022230e-002,
+       -3.6031632305130512e-002, -2.0094505419395196e+002,
+       -1.1627359108310560e+002, 9.2021583518760133e+002,
+       6.8105689976949157e-002, 6.4426739692440949e-002,
+       -7.0967130057087435e-002, -1.9233852871740035e+002,
+       -1.0334652096641923e+002, 1.0755293563503658e+003,
+       -5.8017546499862287e-002, -1.6909812666033443e-003,
+       -1.5876137659782963e+000, -1.0242234847115104e+002,
+       2.2583088401423066e+002, 1.1125972190244058e+003 ]
+Image_points: !!opencv-matrix
+   rows: 8
+   cols: 54
+   dt: "2f"
+   data: [ 5.58494690e+002, 3.55650085e+002, 5.13314697e+002,
+       3.59107666e+002, 4.65728333e+002, 3.62133911e+002,
+       4.15701111e+002, 3.65026459e+002, 3.64399353e+002,
+       3.67339203e+002, 3.12101196e+002, 3.69211914e+002,
+       2.59208405e+002, 3.70413513e+002, 2.07456192e+002,
+       3.71175995e+002, 1.56619507e+002, 3.72176544e+002,
+       5.60868713e+002, 3.08104828e+002, 5.15191772e+002,
+       3.10485626e+002, 4.67032959e+002, 3.12660004e+002,
+       4.16112152e+002, 3.14887177e+002, 3.64010712e+002,
+       3.16825775e+002, 3.10712372e+002, 3.18640808e+002,
+       2.56853943e+002, 3.20017365e+002, 2.04168182e+002,
+       3.20908417e+002, 1.52469528e+002, 3.22105377e+002,
+       5.62328369e+002, 2.58646881e+002, 5.16396301e+002,
+       2.59919281e+002, 4.67907654e+002, 2.61257874e+002,
+       4.16463440e+002, 2.62675537e+002, 3.63546570e+002,
+       2.64064117e+002, 3.09528137e+002, 2.65489990e+002,
+       2.54765533e+002, 2.66862030e+002, 2.01299225e+002,
+       2.67997345e+002, 1.48913437e+002, 2.69627167e+002,
+       5.63098022e+002, 2.08423523e+002, 5.16782654e+002,
+       2.08424667e+002, 4.68059296e+002, 2.08661697e+002,
+       4.16216431e+002, 2.09268982e+002, 3.62888763e+002,
+       2.10013397e+002, 3.08458557e+002, 2.11074738e+002,
+       2.53267990e+002, 2.12496582e+002, 1.99121384e+002,
+       2.14005814e+002, 1.46551376e+002, 2.15851318e+002,
+       5.62997437e+002, 1.57966492e+002, 5.16406494e+002,
+       1.56580688e+002, 4.67334900e+002, 1.55756500e+002,
+       4.15378235e+002, 1.55492874e+002, 3.62096710e+002,
+       1.55498734e+002, 3.07522827e+002, 1.56133240e+002,
+       2.52235214e+002, 1.57516571e+002, 1.97876328e+002,
+       1.59318787e+002, 1.45078247e+002, 1.61638428e+002,
+       5.62097168e+002, 1.07469536e+002, 5.15766846e+002,
+       1.04902527e+002, 4.66562866e+002, 1.03045807e+002,
+       4.14651459e+002, 1.01924713e+002, 3.61240662e+002,
+       1.01357826e+002, 3.06746613e+002, 1.01582802e+002,
+       2.51568024e+002, 1.02920105e+002, 1.97343307e+002,
+       1.04941299e+002, 1.44756821e+002, 1.07737488e+002,
+       5.68062500e+002, 3.73591125e+002, 5.25272644e+002,
+       3.77019318e+002, 4.79870941e+002, 3.80086578e+002,
+       4.31823730e+002, 3.83036652e+002, 3.81995758e+002,
+       3.85271759e+002, 3.30728729e+002, 3.86998779e+002,
+       2.78071167e+002, 3.88151031e+002, 2.26231567e+002,
+       3.88669586e+002, 1.74855331e+002, 3.89197998e+002,
+       5.69792542e+002, 3.27097382e+002, 5.26866028e+002,
+       3.29362366e+002, 4.81278229e+002, 3.31532928e+002,
+       4.32783203e+002, 3.33552185e+002, 3.82408234e+002,
+       3.35186554e+002, 3.30427399e+002, 3.36404053e+002,
+       2.77138519e+002, 3.37450958e+002, 2.24525131e+002,
+       3.37957092e+002, 1.72285507e+002, 3.38503540e+002,
+       5.70942749e+002, 2.79243713e+002, 5.27789307e+002,
+       2.80073486e+002, 4.82146576e+002, 2.81226410e+002,
+       4.33247375e+002, 2.82237427e+002, 3.82503662e+002,
+       2.83062286e+002, 3.30138885e+002, 2.83794434e+002,
+       2.76433228e+002, 2.84549286e+002, 2.23158783e+002,
+       2.84981049e+002, 1.70520218e+002, 2.85720886e+002,
+       5.71001953e+002, 2.30928329e+002, 5.27846863e+002,
+       2.30519928e+002, 4.82114563e+002, 2.30268906e+002,
+       4.33114563e+002, 2.30243515e+002, 3.82384857e+002,
+       2.30311340e+002, 3.29870392e+002, 2.30454620e+002,
+       2.76012634e+002, 2.30882156e+002, 2.22529434e+002,
+       2.31355362e+002, 1.69742065e+002, 2.32063004e+002,
+       5.70199036e+002, 1.82609772e+002, 5.27030884e+002,
+       1.80973267e+002, 4.81193573e+002, 1.79573792e+002,
+       4.32409821e+002, 1.78475616e+002, 3.81855530e+002,
+       1.77680283e+002, 3.29641937e+002, 1.77092087e+002,
+       2.75895782e+002, 1.77155502e+002, 2.22438889e+002,
+       1.77605667e+002, 1.69884583e+002, 1.78365585e+002,
+       5.69026245e+002, 1.34654831e+002, 5.26171570e+002,
+       1.31798691e+002, 4.80653503e+002, 1.29171509e+002,
+       4.31869904e+002, 1.27280067e+002, 3.81419739e+002,
+       1.25591202e+002, 3.29466644e+002, 1.24407089e+002,
+       2.76225342e+002, 1.24174736e+002, 2.23024109e+002,
+       1.24463333e+002, 1.70838898e+002, 1.25398903e+002,
+       4.73812897e+002, 6.94673386e+001, 4.74245453e+002,
+       1.12387466e+002, 4.74243347e+002, 1.56034164e+002,
+       4.73834778e+002, 2.00523651e+002, 4.72891602e+002,
+       2.44457306e+002, 4.71412811e+002, 2.87981171e+002,
+       4.69708252e+002, 3.30783173e+002, 4.67558228e+002,
+       3.71818420e+002, 4.65495667e+002, 4.11996979e+002,
+       4.31027649e+002, 6.75546722e+001, 4.31269440e+002,
+       1.10960022e+002, 4.31185486e+002, 1.55113556e+002,
+       4.30830139e+002, 2.00061066e+002, 4.30168427e+002,
+       2.44456863e+002, 4.29107544e+002, 2.88479645e+002,
+       4.27829071e+002, 3.31813507e+002, 4.26131653e+002,
+       3.73071228e+002, 4.24718811e+002, 4.13476563e+002,
+       3.86868805e+002, 6.61982269e+001, 3.86895416e+002,
+       1.09904411e+002, 3.86690216e+002, 1.54396423e+002,
+       3.86368591e+002, 1.99800369e+002, 3.85792206e+002,
+       2.44538574e+002, 3.85117279e+002, 2.88826447e+002,
+       3.84405273e+002, 3.32408020e+002, 3.83303772e+002,
+       3.74074097e+002, 3.82477448e+002, 4.14638977e+002,
+       3.41941437e+002, 6.54462357e+001, 3.41628204e+002,
+       1.09383698e+002, 3.41402344e+002, 1.54105545e+002,
+       3.41168854e+002, 1.99655045e+002, 3.40816681e+002,
+       2.44469910e+002, 3.40516937e+002, 2.88975800e+002,
+       3.40365662e+002, 3.32670990e+002, 3.39935211e+002,
+       3.74465759e+002, 3.39847626e+002, 4.14742279e+002,
+       2.96694000e+002, 6.56859589e+001, 2.96075226e+002,
+       1.09505333e+002, 2.95704895e+002, 1.54202652e+002,
+       2.95653107e+002, 1.99734131e+002, 2.95589661e+002,
+       2.44549530e+002, 2.95629547e+002, 2.88889496e+002,
+       2.96138733e+002, 3.32610931e+002, 2.96520905e+002,
+       3.74608551e+002, 2.96987091e+002, 4.14774902e+002,
+       2.51414978e+002, 6.65755463e+001, 2.50681854e+002,
+       1.10189331e+002, 2.50183380e+002, 1.54658005e+002,
+       2.50331161e+002, 2.00073761e+002, 2.50590790e+002,
+       2.44719513e+002, 2.51083817e+002, 2.88868286e+002,
+       2.52134262e+002, 3.32266937e+002, 2.53097809e+002,
+       3.74022491e+002, 2.54404007e+002, 4.14018066e+002,
+       1.49524078e+002, 1.27699501e+002, 1.89511658e+002,
+       1.25816605e+002, 2.31050888e+002, 1.24260918e+002,
+       2.74076721e+002, 1.23023209e+002, 3.17643005e+002,
+       1.22288109e+002, 3.61785889e+002, 1.22105164e+002,
+       4.06142670e+002, 1.22401566e+002, 4.49623962e+002,
+       1.23246025e+002, 4.92677216e+002, 1.24087708e+002,
+       1.48706085e+002, 1.69077423e+002, 1.88827805e+002,
+       1.67750443e+002, 2.30439865e+002, 1.66769333e+002,
+       2.73830933e+002, 1.65871170e+002, 3.17596741e+002,
+       1.65410919e+002, 3.61983459e+002, 1.65327866e+002,
+       4.06748322e+002, 1.65463974e+002, 4.50450226e+002,
+       1.66126526e+002, 4.93614655e+002, 1.66970413e+002,
+       1.48312607e+002, 2.11499451e+002, 1.88574097e+002,
+       2.10860214e+002, 2.30130676e+002, 2.10261612e+002,
+       2.73557709e+002, 2.09837143e+002, 3.17542572e+002,
+       2.09633057e+002, 3.62091248e+002, 2.09732620e+002,
+       4.06934570e+002, 2.09926758e+002, 4.50914612e+002,
+       2.10320221e+002, 4.94044495e+002, 2.10900925e+002,
+       1.48613831e+002, 2.53997177e+002, 1.88797791e+002,
+       2.53912842e+002, 2.30240204e+002, 2.53975067e+002,
+       2.73746704e+002, 2.54010208e+002, 3.17718262e+002,
+       2.54106003e+002, 3.62188965e+002, 2.54205475e+002,
+       4.06908783e+002, 2.54317505e+002, 4.50824951e+002,
+       2.54539490e+002, 4.93825714e+002, 2.54753876e+002,
+       1.49541687e+002, 2.96404175e+002, 1.89357727e+002,
+       2.97117523e+002, 2.30807007e+002, 2.97805603e+002,
+       2.74325470e+002, 2.97966522e+002, 3.18042206e+002,
+       2.98304535e+002, 3.62105774e+002, 2.98552643e+002,
+       4.06672272e+002, 2.98572418e+002, 4.50363068e+002,
+       2.98569550e+002, 4.93109894e+002, 2.98516205e+002,
+       1.50883698e+002, 3.38493195e+002, 1.90633621e+002,
+       3.39862610e+002, 2.31920990e+002, 3.40869415e+002,
+       2.74971252e+002, 3.41453766e+002, 3.18235229e+002,
+       3.41952637e+002, 3.62063477e+002, 3.42314026e+002,
+       4.06098938e+002, 3.42221802e+002, 4.49477386e+002,
+       3.42063812e+002, 4.91864716e+002, 3.41727600e+002,
+       2.36129852e+002, 3.92798004e+002, 2.34999939e+002,
+       3.56118683e+002, 2.34376099e+002, 3.18607025e+002,
+       2.33822159e+002, 2.80400696e+002, 2.33565445e+002,
+       2.42213104e+002, 2.33583069e+002, 2.03937286e+002,
+       2.34028824e+002, 1.65756607e+002, 2.34613373e+002,
+       1.28586639e+002, 2.35190308e+002, 9.18279037e+001,
+       2.73031616e+002, 3.93267242e+002, 2.72295166e+002,
+       3.56342743e+002, 2.71799347e+002, 3.18847412e+002,
+       2.71418854e+002, 2.80287872e+002, 2.71161469e+002,
+       2.41881134e+002, 2.71248962e+002, 2.03348145e+002,
+       2.71379303e+002, 1.64895874e+002, 2.71946045e+002,
+       1.27450935e+002, 2.72322418e+002, 9.06900787e+001,
+       3.10670715e+002, 3.93568848e+002, 3.10389160e+002,
+       3.56545959e+002, 3.10084625e+002, 3.18814514e+002,
+       3.09801544e+002, 2.80242737e+002, 3.09678711e+002,
+       2.41574814e+002, 3.09779663e+002, 2.02989838e+002,
+       3.09842712e+002, 1.64338043e+002, 3.10076782e+002,
+       1.26870911e+002, 3.10243286e+002, 8.98413315e+001,
+       3.48618134e+002, 3.93563202e+002, 3.48617065e+002,
+       3.56472382e+002, 3.48608795e+002, 3.18855621e+002,
+       3.48544556e+002, 2.80011017e+002, 3.48556396e+002,
+       2.41388168e+002, 3.48585388e+002, 2.02692429e+002,
+       3.48435089e+002, 1.64099731e+002, 3.48442902e+002,
+       1.26549957e+002, 3.48338043e+002, 8.98002014e+001,
+       3.86625610e+002, 3.93188599e+002, 3.87047729e+002,
+       3.56377594e+002, 3.87306274e+002, 3.18714752e+002,
+       3.87337799e+002, 2.79868896e+002, 3.87402740e+002,
+       2.41228760e+002, 3.87295166e+002, 2.02695313e+002,
+       3.87030273e+002, 1.64203415e+002, 3.86741211e+002,
+       1.26606262e+002, 3.86337311e+002, 8.99655075e+001,
+       4.24534088e+002, 3.92702545e+002, 4.25310822e+002,
+       3.55900452e+002, 4.25869019e+002, 3.18160614e+002,
+       4.25909790e+002, 2.79615753e+002, 4.25977295e+002,
+       2.41165100e+002, 4.25826477e+002, 2.02876389e+002,
+       4.25331665e+002, 1.64527618e+002, 4.24775787e+002,
+       1.27097328e+002, 4.23985138e+002, 9.08176651e+001,
+       1.79142670e+002, 1.58573654e+002, 2.12791580e+002,
+       1.56291031e+002, 2.47140106e+002, 1.54265656e+002,
+       2.82607300e+002, 1.52373688e+002, 3.18175507e+002,
+       1.50692184e+002, 3.54185852e+002, 1.49404175e+002,
+       3.90455200e+002, 1.48229370e+002, 4.26106689e+002,
+       1.47507843e+002, 4.61576141e+002, 1.46712479e+002,
+       1.80388336e+002, 1.93027603e+002, 2.14026459e+002,
+       1.91128204e+002, 2.48376541e+002, 1.89414978e+002,
+       2.83795807e+002, 1.87720856e+002, 3.19472473e+002,
+       1.86192383e+002, 3.55483826e+002, 1.84929199e+002,
+       3.91970764e+002, 1.83747040e+002, 4.27654572e+002,
+       1.82931534e+002, 4.63295227e+002, 1.81977234e+002,
+       1.81914261e+002, 2.27955460e+002, 2.15291260e+002,
+       2.26512482e+002, 2.49628265e+002, 2.25067520e+002,
+       2.85066406e+002, 2.23593185e+002, 3.20846680e+002,
+       2.22337708e+002, 3.56862885e+002, 2.21191040e+002,
+       3.93279907e+002, 2.19905640e+002, 4.29202271e+002,
+       2.18870361e+002, 4.64728424e+002, 2.17972977e+002,
+       1.83496948e+002, 2.62963226e+002, 2.16930527e+002,
+       2.61755219e+002, 2.51115829e+002, 2.60777222e+002,
+       2.86553406e+002, 2.59500336e+002, 3.22299896e+002,
+       2.58380737e+002, 3.58307648e+002, 2.57236694e+002,
+       3.94551819e+002, 2.56009125e+002, 4.30358948e+002,
+       2.54925797e+002, 4.65684998e+002, 2.54021484e+002,
+       1.85461685e+002, 2.97687378e+002, 2.18712234e+002,
+       2.96999207e+002, 2.52770218e+002, 2.96270752e+002,
+       2.88213776e+002, 2.95168213e+002, 3.23698334e+002,
+       2.94233032e+002, 3.59477722e+002, 2.93170715e+002,
+       3.95647766e+002, 2.91897400e+002, 4.31309845e+002,
+       2.90856995e+002, 4.66494110e+002, 2.89726410e+002,
+       1.87661331e+002, 3.32186188e+002, 2.20767746e+002,
+       3.31906250e+002, 2.54839096e+002, 3.31398651e+002,
+       2.89963745e+002, 3.30524139e+002, 3.25207642e+002,
+       3.29771820e+002, 3.60686035e+002, 3.28762695e+002,
+       3.96576447e+002, 3.27542206e+002, 4.31994415e+002,
+       3.26294189e+002, 4.66894653e+002, 3.24949921e+002,
+       2.03543015e+002, 1.77473557e+002, 2.32777847e+002,
+       1.74712509e+002, 2.62628723e+002, 1.72331970e+002,
+       2.93045898e+002, 1.69686768e+002, 3.23527618e+002,
+       1.67496246e+002, 3.54206787e+002, 1.65446075e+002,
+       3.85180176e+002, 1.63360580e+002, 4.15484253e+002,
+       1.61536423e+002, 4.45720947e+002, 1.59896164e+002,
+       2.05864395e+002, 2.07228104e+002, 2.35242096e+002,
+       2.04699326e+002, 2.64853973e+002, 2.02407455e+002,
+       2.95353882e+002, 1.99972321e+002, 3.25811890e+002,
+       1.97671921e+002, 3.56471252e+002, 1.95763168e+002,
+       3.87280548e+002, 1.93597977e+002, 4.17615814e+002,
+       1.91867371e+002, 4.48018677e+002, 1.90067413e+002,
+       2.08421249e+002, 2.37166977e+002, 2.37513824e+002,
+       2.34982773e+002, 2.67261261e+002, 2.32802841e+002,
+       2.97555817e+002, 2.30466080e+002, 3.28118103e+002,
+       2.28462463e+002, 3.58699707e+002, 2.26417038e+002,
+       3.89468842e+002, 2.24356827e+002, 4.19895996e+002,
+       2.22421921e+002, 4.50077850e+002, 2.20683517e+002,
+       2.11095444e+002, 2.66940186e+002, 2.40241348e+002,
+       2.64970093e+002, 2.69563019e+002, 2.63153290e+002,
+       2.99863464e+002, 2.60983551e+002, 3.30282440e+002,
+       2.58911560e+002, 3.60724792e+002, 2.56935730e+002,
+       3.91487915e+002, 2.54799423e+002, 4.21789093e+002,
+       2.52929688e+002, 4.51818481e+002, 2.51059357e+002,
+       2.13829117e+002, 2.96591217e+002, 2.42742859e+002,
+       2.94884583e+002, 2.72209076e+002, 2.93215668e+002,
+       3.02402985e+002, 2.91230591e+002, 3.32536072e+002,
+       2.89165192e+002, 3.62860901e+002, 2.87413605e+002,
+       3.93481842e+002, 2.85199615e+002, 4.23728851e+002,
+       2.83277496e+002, 4.53453094e+002, 2.81229309e+002,
+       2.16799316e+002, 3.25975220e+002, 2.45605515e+002,
+       3.24619904e+002, 2.74777344e+002, 3.22958679e+002,
+       3.04762817e+002, 3.21008057e+002, 3.34797150e+002,
+       3.19291443e+002, 3.65005798e+002, 3.17295044e+002,
+       3.95311981e+002, 3.15296021e+002, 4.25312592e+002,
+       3.13086945e+002, 4.54931152e+002, 3.11027130e+002,
+       2.60550232e+002, 3.70739563e+002, 2.59674011e+002,
+       3.42115936e+002, 2.58910492e+002, 3.13278015e+002,
+       2.58195618e+002, 2.84013580e+002, 2.57727173e+002,
+       2.55017166e+002, 2.57326263e+002, 2.25760986e+002,
+       2.57096619e+002, 1.96577972e+002, 2.57031860e+002,
+       1.68026199e+002, 2.56873383e+002, 1.39550308e+002,
+       2.89019318e+002, 3.70481354e+002, 2.88355560e+002,
+       3.41833252e+002, 2.87601471e+002, 3.12872925e+002,
+       2.87057190e+002, 2.83485535e+002, 2.86599762e+002,
+       2.54255096e+002, 2.86174438e+002, 2.25023285e+002,
+       2.85775940e+002, 1.95715347e+002, 2.85577087e+002,
+       1.66989502e+002, 2.85395477e+002, 1.38597382e+002,
+       3.18072754e+002, 3.70118317e+002, 3.17432709e+002,
+       3.41398743e+002, 3.16917267e+002, 3.12476044e+002,
+       3.16284363e+002, 2.83001587e+002, 3.15799072e+002,
+       2.53725845e+002, 3.15411957e+002, 2.24337708e+002,
+       3.15070374e+002, 1.95034119e+002, 3.14736847e+002,
+       1.66195313e+002, 3.14439789e+002, 1.37797058e+002,
+       3.47083588e+002, 3.69678101e+002, 3.46717987e+002,
+       3.40949524e+002, 3.46185303e+002, 3.12009857e+002,
+       3.45728088e+002, 2.82454071e+002, 3.45226624e+002,
+       2.53109863e+002, 3.44883606e+002, 2.23839539e+002,
+       3.44373535e+002, 1.94399933e+002, 3.43879852e+002,
+       1.65690643e+002, 3.43438629e+002, 1.37252930e+002,
+       3.76341522e+002, 3.68972321e+002, 3.76086884e+002,
+       3.40412842e+002, 3.75708893e+002, 3.11398376e+002,
+       3.75143494e+002, 2.81901520e+002, 3.74762970e+002,
+       2.52577988e+002, 3.74223969e+002, 2.23348221e+002,
+       3.73600891e+002, 1.93979538e+002, 3.72983917e+002,
+       1.65201294e+002, 3.72517273e+002, 1.36871033e+002,
+       4.05512115e+002, 3.68243225e+002, 4.05366333e+002,
+       3.39678650e+002, 4.05090027e+002, 3.10679108e+002,
+       4.04612366e+002, 2.81203522e+002, 4.04152649e+002,
+       2.52051605e+002, 4.03539703e+002, 2.22930420e+002,
+       4.02903351e+002, 1.93625381e+002, 4.02272827e+002,
+       1.65004440e+002, 4.01353333e+002, 1.36796814e+002 ]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/CMakeLists.txt b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/CMakeLists.txt
new file mode 100644
index 00000000..5b5520f2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/CMakeLists.txt
@@ -0,0 +1,21 @@
+set(sample_dir ${CMAKE_CURRENT_SOURCE_DIR}/tutorial_code/calib3d/real_time_pose_estimation/src/)
+set(target example_tutorial_)
+
+set(sample_pnplib
+        ${sample_dir}CsvReader.cpp
+        ${sample_dir}CsvWriter.cpp
+        ${sample_dir}ModelRegistration.cpp
+        ${sample_dir}Mesh.cpp
+        ${sample_dir}Model.cpp
+        ${sample_dir}PnPProblem.cpp
+        ${sample_dir}Utils.cpp
+        ${sample_dir}RobustMatcher.cpp
+)
+
+ocv_include_modules_recurse(${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
+
+add_executable( ${target}pnp_registration ${sample_dir}main_registration.cpp ${sample_pnplib} )
+add_executable( ${target}pnp_detection ${sample_dir}main_detection.cpp ${sample_pnplib} )
+
+ocv_target_link_libraries(${target}pnp_registration PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
+ocv_target_link_libraries(${target}pnp_detection PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/box.mp4 b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/box.mp4
new file mode 100644
index 00000000..e5a6cf41
Binary files /dev/null and b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/box.mp4 differ
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/box.ply b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/box.ply
new file mode 100644
index 00000000..0979e3e3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/box.ply
@@ -0,0 +1,31 @@
+ply
+format ascii 1.0
+comment made by anonymous
+comment this file is a cube
+element vertex 8
+property float32 x
+property float32 y
+property float32 z
+element face 12
+property list uint8 int32 vertex_index
+end_header
+0 0 0
+0 25.8 0
+18.9 0 0
+18.9 25.8 0
+0 0 7.5
+0 25.8 7.5
+18.9 0 7.5
+18.9 25.8 7.5
+3 5 1 0
+3 5 4 0
+3 4 0 2
+3 4 6 2
+3 7 5 4
+3 7 6 4
+3 3 2 1
+3 1 2 0
+3 5 7 1
+3 7 1 3
+3 7 6 3
+3 6 3 2
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/cookies_ORB.yml b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/cookies_ORB.yml
new file mode 100644
index 00000000..f1195982
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/cookies_ORB.yml
@@ -0,0 +1,31793 @@
+%YAML:1.0
+points_3d: !!opencv-matrix
+   rows: 5914
+   cols: 1
+   dt: "3f"
+   data: [ 5.81652069e+00, 6.59059143e+00, 7.50000000e+00, 0.,
+       6.58016205e-02, 3.27301025e-02, 7.62939453e-06, 7.74074554e-01,
+       2.94036865e-01, 0., 1.09350014e+00, 3.25691223e-01,
+       1.78939514e+01, 2.47868404e+01, 7.50000000e+00, 0.,
+       1.50090218e+00, 2.29133606e-01, 0., 7.57560730e-01,
+       6.19583130e-01, 1.77171707e+01, 2.41349888e+01, 7.50000000e+00,
+       0., 1.08206367e+00, 5.42961121e-01, 0., 2.80006027e+00,
+       1.37336731e-01, 0., 3.12296295e+00, 1.69082642e-01,
+       1.75166321e+01, 2.43375950e+01, 7.50000000e+00, 7.62939453e-06,
+       3.53643608e+00, 7.16323853e-02, 7.62939453e-06, 2.95099068e+00,
+       3.17375183e-01, 0., 3.10879707e+00, 3.87962341e-01, 0.,
+       1.05927849e+00, 9.75822449e-01, 1.75225830e+01, 2.35742168e+01,
+       7.50000000e+00, 0., 3.43171501e+00, 4.19860840e-01,
+       -7.62939453e-06, 4.84415627e+00, 8.88748169e-02, 1.72289734e+01,
+       2.42151966e+01, 7.50000000e+00, 1.72852173e+01, 2.39520588e+01,
+       7.49999237e+00, 0., 5.17886925e+00, 1.04370117e-02, 0.,
+       5.58975983e+00, 2.26593018e-02, 7.62939453e-06, 4.82766342e+00,
+       3.08975220e-01, 1.71792755e+01, 2.37161732e+01, 7.50000000e+00,
+       0., 5.15344048e+00, 3.40988159e-01, -7.62939453e-06,
+       5.57223701e+00, 2.43392944e-01, 1.71484070e+01, 2.31312656e+01,
+       7.50000000e+00, 7.62939453e-06, 2.31677818e+00, 1.42794800e+00,
+       0., 3.87520409e+00, 1.06752777e+00, 1.69494400e+01,
+       2.33334141e+01, 7.50000000e+00, 0., 7.22212410e+00,
+       2.93464661e-01, 0., 7.56184769e+00, 2.14889526e-01,
+       7.62939453e-06, 4.19805717e+00, 1.09983063e+00, 1.67694626e+01,
+       2.34479961e+01, 7.50000763e+00, 0., 4.18252373e+00,
+       1.31696320e+00, 0., 8.89687920e+00, 2.32788086e-01,
+       7.62939453e-06, 9.31528664e+00, 2.45361328e-01, 0.,
+       9.57364845e+00, 1.86058044e-01, 1.68025513e+01, 2.18503704e+01,
+       7.50000000e+00, 0., 7.50762939e-01, 2.31622314e+00, 0.,
+       1.07202721e+00, 2.24260712e+00, 0., 2.28437424e+00,
+       1.96485138e+00, 7.62939453e-06, 3.99455261e+00, 1.67926025e+00,
+       0., 3.74039459e+00, 1.84337616e+00, 0., 1.12716084e+01,
+       1.24443054e-01, 0., 1.05511475e+00, 2.56096649e+00, 0.,
+       1.15206470e+01, 1.76811218e-01, 0., 2.09669113e+00,
+       2.42869568e+00, 0., 3.97175026e+00, 2.00234985e+00, 0.,
+       1.28099003e+01, 1.02241516e-01, 7.62939453e-06, 3.79263306e+00,
+       2.25417328e+00, 7.62939453e-06, 1.31488285e+01, 1.34834290e-01,
+       0., 7.92762756e-01, 3.03775787e+00, 0., 1.03266907e+00,
+       2.98352051e+00, 0., 1.34882412e+01, 1.67465210e-01, 0.,
+       3.94149399e+00, 2.43115997e+00, 0., 1.01459560e+01,
+       1.13888550e+00, 1.54052734e+01, 2.47663975e+01, 7.50000000e+00,
+       0., 1.49706364e+01, 5.22232056e-02, 0., 2.13953400e+00,
+       3.04643250e+00, 0., 3.76289558e+00, 2.68149567e+00, 0.,
+       1.53131580e+01, 8.49761963e-02, 0., 7.14962578e+00,
+       2.02642059e+00, 0., 1.56561756e+01, 1.17767334e-01,
+       7.62939453e-06, 3.74808884e+00, 2.89432526e+00, 0.,
+       3.81482887e+00, 3.08843231e+00, 0., 7.20427322e+00,
+       2.33226013e+00, 0., 9.23216438e+00, 1.87984467e+00, 0.,
+       9.40264702e+00, 1.84181213e+00, 1.49480209e+01, 2.47572079e+01,
+       7.50000000e+00, 1.50042267e+01, 2.44971561e+01, 7.50000000e+00,
+       0., 1.70499897e+01, 1.35726929e-01, 0., 1.74128208e+01,
+       5.47714233e-02, 1.53780899e+01, 2.27673550e+01, 7.49999237e+00,
+       0., 7.95060539e+00, 2.27185059e+00, 0., 1.38152790e+01,
+       9.65957642e-01, 1.52759171e+01, 2.25362339e+01, 7.50000000e+00,
+       0., 3.71858215e+00, 3.31835175e+00, 7.62939453e-06,
+       9.38010216e+00, 2.06010437e+00, 0., 1.22229023e+01,
+       1.42830658e+00, 7.62939453e-06, 7.51008606e+00, 2.58134460e+00,
+       0., 7.84598351e+00, 2.50685120e+00, 0., 1.23838711e+01,
+       1.50024414e+00, 0., 1.87282696e+01, 9.29183960e-02, 0.,
+       3.78518105e+00, 3.51154327e+00, 0., 8.17239571e+00,
+       2.54022980e+00, 0., 1.19356556e+01, 1.70705414e+00, 0.,
+       1.90768261e+01, 1.26022339e-01, 7.62939453e-06, 1.94444675e+01,
+       4.46243286e-02, -7.62939453e-06, 8.58371162e+00, 2.55500793e+00,
+       7.62939453e-06, 9.34639549e+00, 2.38646698e+00, 0.,
+       1.21831417e+01, 1.75962067e+00, 0., 7.22652435e-01,
+       4.39448547e+00, 0., 9.60508347e-01, 4.34202576e+00,
+       7.62939453e-06, 8.82657814e+00, 2.60713959e+00, 7.62939453e-06,
+       1.35533314e+01, 1.67233276e+00, 7.62939453e-06, 2.06808376e+01,
+       1.03363037e-01, 1.42352524e+01, 2.45406704e+01, 7.50000000e+00,
+       7.62939453e-06, 2.08664570e+01, 6.25000000e-02, 0.,
+       1.38025303e+01, 1.72512817e+00, 7.62939453e-06, 2.10325832e+01,
+       1.36619568e-01, 0., 1.02325630e+00, 4.63497162e+00,
+       7.62939453e-06, 3.74833298e+00, 4.03739166e+00, 7.62939453e-06,
+       1.04939785e+01, 2.55815887e+00, 0., 1.13525982e+01,
+       2.36988068e+00, 0., 1.29129543e+01, 2.02771759e+00, 0.,
+       1.30875225e+01, 1.98944092e+00, 0., 1.35108242e+01,
+       2.00387573e+00, 0., 1.05554981e+01, 2.75659180e+00,
+       1.40343781e+01, 2.40759945e+01, 7.50000000e+00, 0.,
+       1.14996090e+01, 2.55035400e+00, 0., 1.31471119e+01,
+       2.19046783e+00, 0., 6.90683365e-01, 5.01313782e+00,
+       7.62939453e-06, 3.72633743e+00, 4.35128021e+00, 0.,
+       1.00117111e+00, 5.04707336e+00, -7.62939453e-06, 2.27261353e+00,
+       4.77040100e+00, 0., 1.03608303e+01, 3.01034546e+00, 0.,
+       1.34684925e+01, 2.33409882e+00, 0., 1.39939098e+01,
+       2.21976471e+00, 7.62939453e-06, 1.75527973e+01, 1.44532776e+00,
+       1.38408356e+01, 2.42741642e+01, 7.50000000e+00, 7.62939453e-06,
+       3.87338638e+00, 4.52476501e+00, 0., 1.69062595e+01,
+       1.69418335e+00, 0., 9.11245346e-01, 5.26945496e+00, 0.,
+       1.36150036e+01, 2.51565552e+00, 0., 1.51976604e+01,
+       2.17259216e+00, 7.62939453e-06, 1.65316257e+01, 1.88341522e+00,
+       0., 1.76088161e+01, 1.64991760e+00, 7.62939453e-06,
+       2.25361633e+00, 5.08023834e+00, 0., 3.77783775e+00,
+       4.75048065e+00, 7.62939453e-06, 1.03252926e+01, 3.33391571e+00,
+       0., 1.37756062e+01, 2.58744049e+00, 0., 1.40381947e+01,
+       2.53062439e+00, 0., 1.43013248e+01, 2.47370148e+00, 0.,
+       1.53592892e+01, 2.24481201e+00, 0., 1.89499264e+01,
+       1.46796417e+00, 0., 2.08805656e+00, 5.21765900e+00, 0.,
+       1.10810909e+01, 3.27574921e+00, 7.62939453e-06, 1.46381092e+01,
+       2.50765228e+00, 0., 1.63206730e+01, 2.14433289e+00, 0.,
+       1.71254215e+01, 1.97055817e+00, 7.62939453e-06, 1.92050114e+01,
+       1.52149963e+00, 0., 1.13254910e+01, 3.32827759e+00, 0.,
+       1.41844006e+01, 2.71213531e+00, 1.74314880e+01, 6.41291046e+00,
+       7.49999237e+00, 7.62939453e-06, 1.67507000e+01, 2.15904999e+00,
+       0., 1.80081310e+01, 1.88804626e+00, 0., 1.89138241e+01,
+       1.69285583e+00, 0., 2.16692295e+01, 1.09901428e+00, 0.,
+       1.09710293e+01, 3.50971222e+00, 0., 1.14843082e+01,
+       3.39930725e+00, 0., 1.19996777e+01, 3.28845215e+00, 0.,
+       1.21719341e+01, 3.25139618e+00, 0., 1.44327793e+01,
+       2.76508331e+00, 0., 1.46962376e+01, 2.70841980e+00, 0.,
+       1.71816349e+01, 2.17379761e+00, 0., 2.19276752e+01,
+       1.15290833e+00, 7.62939453e-06, 2.21137028e+01, 1.11289215e+00,
+       -7.62939453e-06, 3.90969658e+00, 5.13059998e+00, 7.62939453e-06,
+       1.83344517e+01, 2.03379059e+00, 0., 1.86964397e+01,
+       1.95607758e+00, 0., 2.14267159e+00, 5.61107635e+00,
+       -7.62939453e-06, 1.22318516e+01, 3.44924927e+00, 1.71923752e+01,
+       6.16588402e+00, 7.50000000e+00, 0., 1.27496471e+01,
+       3.33830261e+00, 0., 1.63452702e+01, 2.56786346e+00,
+       7.62939453e-06, 1.81364079e+01, 2.18406677e+00, 0.,
+       2.21658535e+01, 1.32067871e+00, 7.62939453e-06, 1.19608097e+01,
+       3.61238098e+00, 7.62939453e-06, 1.88419018e+01, 2.14081573e+00,
+       7.62939453e-06, 2.16815968e+01, 1.53352356e+00, 1.81250381e+01,
+       1.22525215e+00, 7.50000000e+00, 7.62939453e-06, 3.72672462e+00,
+       5.47483063e+00, 7.62939453e-06, 1.00736675e+01, 4.12012482e+00,
+       7.62939453e-06, 1.24638882e+01, 3.60994720e+00, 0.,
+       1.28090611e+01, 3.53627777e+00, 7.62939453e-06, 1.61356258e+01,
+       2.82624054e+00, 0., 1.81016178e+01, 2.40660858e+00,
+       1.77216949e+01, 2.40773773e+00, 7.50000000e+00, 7.62939453e-06,
+       1.95503864e+01, 2.09738159e+00, 0., 3.88015556e+00,
+       5.54355621e+00, 0., 9.72452354e+00, 4.29853058e+00, 0.,
+       1.77248363e+01, 2.59423065e+00, 0., 9.96608162e+00,
+       4.35093689e+00, 1.74960175e+01, 2.77709198e+00, 7.50000763e+00,
+       1.77801971e+01, 1.47755051e+00, 7.50000000e+00, 0.,
+       6.95226669e-01, 6.42198181e+00, 0., 9.30147171e-01,
+       6.37213135e+00, 0., 4.18703079e+00, 5.68101501e+00,
+       1.70567398e+01, 4.12325668e+00, 7.50000000e+00, 1.74128876e+01,
+       2.49587822e+00, 7.49999237e+00, 1.75194550e+01, 2.00885010e+00,
+       7.50000000e+00, 0., 1.58227329e+01, 3.21187592e+00, 0.,
+       1.61764622e+01, 3.13680267e+00, 0., 1.09584141e+01,
+       4.34811401e+00, 0., 1.12135258e+01, 4.29408264e+00, 0.,
+       1.67814579e+01, 3.11484528e+00, 7.62939453e-06, 3.77060318e+00,
+       5.97135925e+00, 0., 4.01124001e+00, 5.92050171e+00,
+       1.72410889e+01, 2.62098885e+00, 7.50000000e+00, 0.,
+       1.07765636e+01, 4.49044800e+00, 0., 1.76566944e+01,
+       3.03612518e+00, 0., 1.64827023e+01, 3.39031982e+00, 0.,
+       6.74215317e-01, 6.82484436e+00, 0., 9.86732483e-01,
+       6.75904083e+00, 0., 1.07524929e+01, 4.70277405e+00, 0.,
+       1.67324810e+01, 3.44363403e+00, 7.62939453e-06, 2.37496967e+01,
+       1.96609497e+00, 0., 1.37282372e+00, 6.77732849e+00, 0.,
+       1.70713100e+01, 3.47831726e+00, 0., 1.81425419e+01,
+       3.25319672e+00, 7.62939453e-06, 1.21047783e+00, 6.91084290e+00,
+       0., 1.83045063e+01, 3.32556915e+00, 0., 2.20348797e+01,
+       2.54315948e+00, 0., 6.58527374e-01, 7.12566376e+00, 0.,
+       9.70439911e-01, 7.06037140e+00, 0., 2.38721218e+01,
+       2.26636505e+00, 0., 1.35578728e+00, 7.07892609e+00, 0.,
+       2.69387245e+00, 6.79936981e+00, 0., 2.93153763e+00,
+       6.74972534e+00, 0., 1.05357914e+01, 5.16102600e+00,
+       1.27654037e+01, 2.03780689e+01, 7.50000000e+00, 0.,
+       1.98919315e+01, 3.20632935e+00, 0., 3.40125275e+00,
+       6.75151825e+00, 7.62939453e-06, 2.38289852e+01, 2.49206543e+00,
+       7.62939453e-06, 1.95834484e+01, 3.48372650e+00, 0.,
+       1.97642956e+01, 3.44609833e+00, 1.69647598e+01, 1.26134491e+00,
+       7.50000000e+00, 0., 2.67428589e+00, 7.10202026e+00,
+       1.25759888e+01, 2.05754375e+01, 7.49999237e+00, 7.62939453e-06,
+       2.37859669e+01, 2.71715546e+00, 0., 2.98393250e+00,
+       7.13711548e+00, 7.62939453e-06, 3.30091858e+00, 7.07139587e+00,
+       7.62939453e-06, 4.73755646e+00, 6.77359009e+00, 7.62939453e-06,
+       1.02365780e+01, 5.63368988e+00, 0., 1.04045048e+01,
+       5.59888458e+00, 1.67766190e+01, 1.46722984e+00, 7.50000000e+00,
+       0., 1.98178082e+01, 3.64759064e+00, 1.15315475e+01,
+       2.46601505e+01, 7.50000000e+00, 0., 4.56933594e+00,
+       6.90839386e+00, -7.62939453e-06, 5.05101585e+00, 6.80874634e+00,
+       7.62939453e-06, 5.28433800e+00, 6.86056519e+00, 7.62939453e-06,
+       2.00520267e+01, 3.81134033e+00, 0., 2.14161777e+01,
+       3.52967834e+00, 7.62939453e-06, 4.71397781e+00, 7.07809448e+00,
+       0., 5.02683258e+00, 7.11338043e+00, 1.50443344e+01,
+       8.04078102e+00, 7.50000000e+00, 1.50802765e+01, 7.87748146e+00,
+       7.50000000e+00, 0., 5.34836197e+00, 7.04724884e+00,
+       7.62939453e-06, 6.72427559e+00, 6.76425934e+00, 7.62939453e-06,
+       2.37718563e+01, 3.25807953e+00, 0., 2.01769085e+01,
+       4.10322571e+00, 1.59034882e+01, 4.13844681e+00, 7.50000000e+00,
+       0., 2.05200405e+01, 4.13855743e+00, 1.65074081e+01,
+       1.39536476e+00, 7.50000000e+00, 0., 2.14289608e+01,
+       3.95236206e+00, 0., 2.36363239e+01, 3.50015259e+00,
+       7.62939453e-06, 6.69678307e+00, 7.07048035e+00, 1.21573257e+01,
+       2.04939060e+01, 7.50000000e+00, 0., 7.02210045e+00,
+       7.00397491e+00, 0., 8.41427040e+00, 6.71932983e+00,
+       9.71450806e-01, 1.00404358e+00, 7.50000000e+00, 1.47485580e+01,
+       8.73320580e+00, 7.50000000e+00, 1.58584290e+01, 3.69581604e+00,
+       7.50000000e+00, 0., 7.33869553e+00, 7.03945160e+00, 0.,
+       8.73358345e+00, 6.75482178e+00, 7.62939453e-06, 9.06407356e+00,
+       6.68737793e+00, 0., 2.13897915e+01, 4.17224884e+00,
+       1.20614395e+01, 2.02712116e+01, 7.50000000e+00, 7.62939453e-06,
+       2.05537586e+01, 4.44824982e+00, 1.25620270e+00, 7.78184891e-01,
+       7.50000000e+00, 1.15271759e+00, 1.21305847e+00, 7.50000000e+00,
+       0., 8.38340569e+00, 7.02717590e+00, 0., 2.03542194e+01,
+       4.59409332e+00, 1.47049561e+01, 8.28211403e+00, 7.50000000e+00,
+       1.47768555e+01, 7.95598412e+00, 7.50000000e+00, 1.48307495e+01,
+       7.71155357e+00, 7.50000000e+00, 0., 2.07157116e+01,
+       4.52061462e+00, 9.32380676e-01, 2.62651062e+00, 7.50000000e+00,
+       0., 8.70208549e+00, 7.06280518e+00, 0., 9.03189659e+00,
+       6.99590302e+00, 0., 1.04433460e+01, 6.70958710e+00, 0.,
+       2.08776722e+01, 4.59297943e+00, 1.62745972e+01, 1.16327286e+00,
+       7.50000000e+00, 7.62939453e-06, 2.11496220e+01, 4.53781128e+00,
+       7.62939453e-06, 2.20601902e+01, 4.35310364e+00, 1.40374756e+00,
+       1.13228226e+00, 7.50000000e+00, 9.71290588e-01, 2.95162010e+00,
+       7.50000000e+00, 7.62939453e-06, 1.07658749e+01, 6.74526978e+00,
+       1.61583710e+00, 7.28586197e-01, 7.50000000e+00, 1.56407928e+00,
+       9.46477890e-01, 7.50000000e+00, 1.20099640e+00, 2.47480202e+00,
+       7.50000000e+00, 0., 1.11726894e+01, 6.76406097e+00, 0.,
+       2.12016163e+01, 4.73772430e+00, 1.51731873e+00, 1.63345528e+00,
+       7.50000000e+00, 1.44205475e+01, 8.27839851e+00, 7.50000000e+00,
+       1.15357208e+00, 3.16547012e+00, 7.50000000e+00, 0.,
+       1.04083958e+01, 7.01920319e+00, 1.33174133e+00, 2.90705109e+00,
+       7.50000000e+00, -7.62939453e-06, 1.07302761e+01, 7.05503082e+00,
+       0., 1.10646648e+01, 6.98773193e+00, 7.62939453e-06,
+       1.25804348e+01, 6.68267059e+00, 1.16274033e+01, 2.02744350e+01,
+       7.50000000e+00, 7.62939453e-06, 2.09820042e+01, 4.99186707e+00,
+       0., 2.11629391e+01, 4.95545959e+00, 0., 2.13441410e+01,
+       4.91899109e+00, 0., 2.36303654e+01, 4.45888519e+00,
+       1.51009369e+00, 2.64836121e+00, 7.50000000e+00, 1.42337952e+01,
+       8.47994041e+00, 7.50000000e+00, 1.00599670e+00, 4.77389526e+00,
+       7.50000000e+00, 1.54134140e+01, 3.14184570e+00, 7.50000000e+00,
+       1.54667053e+01, 2.90075874e+00, 7.50000000e+00, 9.36279297e-01,
+       5.06789017e+00, 7.50000000e+00, -7.62939453e-06, 1.29063854e+01,
+       6.71856689e+00, 0., 1.32463665e+01, 6.65028381e+00,
+       2.01744843e+00, 1.00213814e+00, 7.50000000e+00, 1.16728973e+00,
+       4.58890724e+00, 7.50000000e+00, 0., 2.14864750e+01,
+       5.10002899e+00, 2.04048157e+00, 1.39931488e+00, 7.50000000e+00,
+       1.93663788e+00, 1.83768082e+00, 7.50000000e+00, 1.88467407e+00,
+       2.05702972e+00, 7.50000000e+00, 1.83268738e+00, 2.27648926e+00,
+       7.50000000e+00, 1.36361694e+00, 4.25665474e+00, 7.50000000e+00,
+       1.11953735e+00, 5.28697777e+00, 7.50000000e+00, 1.53870544e+01,
+       2.62289238e+00, 7.50000000e+00, 0., 1.25411282e+01,
+       6.99423218e+00, 0., 2.16482563e+01, 5.17231750e+00,
+       1.14008942e+01, 1.99985218e+01, 7.50000000e+00, 0.,
+       2.20115948e+01, 5.09961700e+00, 1.22278671e+01, 1.62617474e+01,
+       7.50000000e+00, 1.35103607e+00, 4.80714607e+00, 7.50000000e+00,
+       1.28125763e+00, 5.10188866e+00, 7.50000000e+00, 1.39329605e+01,
+       8.55711555e+00, 7.50000000e+00, 1.40048599e+01, 8.23225594e+00,
+       7.50000000e+00, 7.62939453e-06, 1.28664265e+01, 7.03025818e+00,
+       0., 1.32056942e+01, 6.96252441e+00, 0., 1.44860477e+01,
+       6.70689392e+00, 2.29459381e+00, 1.31827736e+00, 7.50000000e+00,
+       2.17338562e+00, 1.83049202e+00, 7.50000763e+00, 0.,
+       2.35249310e+01, 5.00743103e+00, 2.49114227e+00, 9.85025406e-01,
+       7.50000763e+00, 2.10994720e+00, 2.59698296e+00, 7.50000000e+00,
+       1.08060455e+00, 6.94977379e+00, 7.50000000e+00, 1.20230789e+01,
+       1.65418644e+01, 7.50000000e+00, 0., 1.49722462e+01,
+       6.81333160e+00, 0., 2.37797031e+01, 5.06184387e+00,
+       1.30067368e+01, 1.21004009e+01, 7.50000000e+00, 1.37109985e+01,
+       8.92045021e+00, 7.50000000e+00, 2.54949951e+00, 1.23698807e+00,
+       7.50000000e+00, 2.49755096e+00, 1.45675468e+00, 7.50000000e+00,
+       2.41092682e+00, 1.82328224e+00, 7.50000000e+00, 2.27217102e+00,
+       2.41036987e+00, 7.50000000e+00, 1.24300385e+00, 6.76488686e+00,
+       7.50000000e+00, 0., 1.44428349e+01, 7.01998138e+00, 0.,
+       1.64270077e+01, 6.62618256e+00, 7.62939453e-06, 2.34829578e+01,
+       5.22580719e+00, 2.69455719e+00, 1.12296486e+00, 7.50000000e+00,
+       1.10830994e+01, 2.01399136e+01, 7.50000000e+00, 1.77304077e+00,
+       5.02423477e+00, 7.50000000e+00, 7.62939453e-06, 1.51146641e+01,
+       6.98814392e+00, 1.25848236e+01, 1.33642063e+01, 7.50000000e+00,
+       1.36691208e+01, 8.47182655e+00, 7.50000000e+00, 0.,
+       1.67592030e+01, 6.66241455e+00, 2.77056122e+00, 1.30215836e+00,
+       7.50000000e+00, 2.47569275e+00, 2.55124092e+00, 7.50000000e+00,
+       2.16254425e+00, 3.87772751e+00, 7.50000000e+00, 1.83095551e+00,
+       5.28232574e+00, 7.50000000e+00, 1.17789993e+01, 1.63581448e+01,
+       7.50000000e+00, 1.74352264e+00, 5.65271950e+00, 7.50000000e+00,
+       -7.62939453e-06, 1.70918560e+01, 6.69870758e+00, 2.23829651e+00,
+       4.06049919e+00, 7.50000000e+00, 2.18598175e+00, 4.28225517e+00,
+       7.50000000e+00, 1.27619247e+01, 1.19264469e+01, 7.50000763e+00,
+       1.34656830e+01, 8.75344658e+00, 7.50000000e+00, 1.09868622e+00,
+       8.89066887e+00, 7.50000000e+00, 1.02815247e+00, 9.18966866e+00,
+       7.50000000e+00, 9.96955872e+00, 2.38706608e+01, 7.50000000e+00,
+       7.62939453e-06, 1.63797474e+01, 6.94123840e+00, 2.73207855e+00,
+       2.47148705e+00, 7.50000000e+00, 2.40141296e+00, 3.87385750e+00,
+       7.49999237e+00, 1.22862244e+01, 1.34331684e+01, 7.49999237e+00,
+       2.01718140e+00, 5.50332832e+00, 7.50000000e+00, 1.87711334e+00,
+       6.09738731e+00, 7.49999237e+00, 1.80699158e+00, 6.39471626e+00,
+       7.50000000e+00, 1.33883057e+01, 8.46779823e+00, 7.50000000e+00,
+       -7.62939453e-06, 1.67112522e+01, 6.97762299e+00, 0.,
+       1.84614964e+01, 6.63301849e+00, 3.17291260e+00, 1.10616875e+00,
+       7.49999237e+00, 9.87667847e+00, 2.36452351e+01, 7.50000763e+00,
+       2.47753143e+00, 4.05692101e+00, 7.50000000e+00, 0.,
+       1.70432224e+01, 7.01405334e+00, 1.07098007e+01, 1.98944073e+01,
+       7.50000000e+00, 7.62939453e-06, 1.82683353e+01, 6.77332306e+00,
+       1.15359039e+01, 1.61751652e+01, 7.50000000e+00, 1.18644028e+01,
+       1.46962185e+01, 7.50000000e+00, 0., 1.87969418e+01,
+       6.66946411e+00, 0., 1.91505451e+01, 6.59997559e+00,
+       2.55381775e+00, 4.24036980e+00, 7.50000763e+00, 1.35620956e+01,
+       7.05292511e+00, 7.50000000e+00, 2.51891327e+00, 4.38862419e+00,
+       7.50000000e+00, 2.27415466e+00, 5.42780876e+00, 7.50000000e+00,
+       0., 1.84099674e+01, 6.94979095e+00, 3.54241943e+00,
+       1.05664825e+00, 7.50000000e+00, 1.14969177e+01, 1.57141514e+01,
+       7.50000000e+00, 1.24779205e+01, 1.13007412e+01, 7.49999237e+00,
+       1.25502014e+01, 1.09755802e+01, 7.49999237e+00, 1.32879257e+01,
+       7.65659332e+00, 7.50000000e+00, 3.07327271e+00, 3.05093956e+00,
+       7.50000000e+00, 0., 1.87447147e+01, 6.98638916e+00, 0.,
+       1.90975513e+01, 6.91747284e+00, 0., 2.04292431e+01,
+       6.65737915e+00, 9.58008575e+00, 2.36970425e+01, 7.50000000e+00,
+       0., 2.07866611e+01, 6.58756256e+00, 1.04682999e+01,
+       1.97039394e+01, 7.50000000e+00, 1.05419617e+01, 1.93728085e+01,
+       7.50000000e+00, 0., 2.12156315e+01, 6.60671997e+00,
+       1.14215546e+01, 1.54184399e+01, 7.50000000e+00, 1.16402206e+01,
+       1.44353771e+01, 7.50000000e+00, 3.15766907e+00, 3.71358681e+00,
+       7.50000000e+00, 1.22028732e+01, 1.19059467e+01, 7.50000000e+00,
+       3.20001984e+00, 4.04612160e+00, 7.50000763e+00, 3.14760590e+00,
+       4.26934433e+00, 7.50000000e+00, 1.32468872e+01, 7.21239471e+00,
+       7.50000000e+00, 0., 2.03735523e+01, 6.97573853e+00, 0.,
+       2.07301884e+01, 6.90649414e+00, 3.88742065e+00, 1.63142014e+00,
+       7.50000000e+00, 1.45274429e+01, 1.45546913e+00, 7.50000000e+00,
+       3.60902405e+00, 2.81762314e+00, 7.50000000e+00, 3.46954346e+00,
+       3.41194916e+00, 7.50000000e+00, 3.38227844e+00, 3.78381729e+00,
+       7.50000000e+00, 3.10249329e+00, 4.97593498e+00, 7.50000000e+00,
+       1.03018646e+01, 1.98158474e+01, 7.50000000e+00, 1.05778275e+01,
+       1.85761585e+01, 7.50000000e+00, 0., 2.10687580e+01,
+       6.94329071e+00, 1.11091309e+01, 1.61892490e+01, 7.50000763e+00,
+       1.12552032e+01, 1.55330715e+01, 7.50000000e+00, 0.,
+       2.25079441e+01, 6.66445160e+00, 0., 2.28702030e+01,
+       6.59426880e+00, 1.22354660e+01, 1.11293049e+01, 7.50000000e+00,
+       7.62939453e-06, 2.48805714e+01, 6.20475006e+00, 0.,
+       2.51570797e+01, 6.15118408e+00, 1.29732132e+01, 7.81506538e+00,
+       7.49999237e+00, 1.31880875e+01, 6.84978867e+00, 7.50000000e+00,
+       3.65195465e+00, 3.14927864e+00, 7.50000000e+00, 3.14491272e+00,
+       5.31104851e+00, 7.50000000e+00, 7.62939453e-06, 2.32128544e+01,
+       6.63111877e+00, 1.02829666e+01, 1.92664013e+01, 7.50000000e+00,
+       1.03932800e+01, 1.87711658e+01, 7.50000000e+00, 1.11985245e+01,
+       1.51563473e+01, 7.50000000e+00, 0., 2.24678211e+01,
+       6.87801361e+00, 4.40005493e+00, 9.89566803e-01, 7.50000000e+00,
+       1.19248428e+01, 1.18957500e+01, 7.50000000e+00, 1.21597290e+01,
+       1.08412609e+01, 7.50000000e+00, 4.36531830e+00, 1.13781548e+00,
+       7.50000000e+00, 1.28968658e+01, 7.53213692e+00, 7.50000000e+00,
+       3.98250580e+00, 2.77191544e+00, 7.49999237e+00, 3.79053497e+00,
+       3.59127617e+00, 7.50000000e+00, 2.27719879e+00, 1.00510654e+01,
+       7.50000000e+00, 0., 2.28092594e+01, 6.91497040e+00,
+       7.62939453e-06, 2.45398083e+01, 6.58169556e+00, 4.16551208e+00,
+       2.50844193e+00, 7.49999237e+00, 4.02598572e+00, 3.10432434e+00,
+       7.50000763e+00, 3.48354340e+00, 5.42114258e+00, 7.50000000e+00,
+       2.46083832e+00, 9.78927422e+00, 7.49999237e+00, 1.00618362e+01,
+       1.96260548e+01, 7.50000000e+00, 1.06491547e+01, 1.69914074e+01,
+       7.50000000e+00, 0., 2.31511860e+01, 6.95197296e+00,
+       1.11055527e+01, 1.49439907e+01, 7.50000000e+00, 1.15779724e+01,
+       1.28247585e+01, 7.50000000e+00, 1.16504517e+01, 1.24996281e+01,
+       7.50000000e+00, 0., 2.48851986e+01, 6.61870575e+00, 0.,
+       2.50690517e+01, 6.58336639e+00, 4.72347260e+00, 1.16227722e+00,
+       7.50000000e+00, 1.24980469e+01, 8.69736290e+00, 7.50000000e+00,
+       1.26953583e+01, 7.81223106e+00, 7.50000000e+00, 4.20068359e+00,
+       3.39786339e+00, 7.50000000e+00, 1.00627136e+00, 1.70579433e+01,
+       7.50000000e+00, 0., 2.44752483e+01, 6.90386963e+00,
+       4.88961792e+00, 9.72127914e-01, 7.50000000e+00, 4.43678284e+00,
+       2.90974426e+00, 7.50000000e+00, 4.26206970e+00, 3.65729332e+00,
+       7.50000000e+00, 9.87777710e+00, 1.98202534e+01, 7.50000000e+00,
+       1.01719437e+01, 1.85015507e+01, 7.50000000e+00, 1.02453461e+01,
+       1.81724873e+01, 7.50000000e+00, 1.03736801e+01, 1.75972271e+01,
+       7.50000000e+00, 1.04103165e+01, 1.74330044e+01, 7.49999237e+00,
+       1.05932693e+01, 1.66127987e+01, 7.50000763e+00, 4.19210052e+00,
+       3.95667458e+00, 7.50000000e+00, 3.78884888e+00, 5.68213463e+00,
+       7.50000000e+00, 2.32017517e+00, 1.19662914e+01, 7.50000000e+00,
+       1.31373291e+01, 5.20843506e+00, 7.50000000e+00, 0.,
+       2.48199024e+01, 6.94104004e+00, 4.65556335e+00, 2.49602890e+00,
+       7.50000000e+00, 1.40060730e+01, 1.31410217e+00, 7.50000000e+00,
+       2.20773315e+00, 1.35064526e+01, 7.50000000e+00, 1.00177002e+00,
+       1.86727161e+01, 7.50000000e+00, 9.62024689e+00, 2.03443317e+01,
+       7.49999237e+00, 9.67552185e+00, 2.00966969e+01, 7.50000000e+00,
+       9.71235657e+00, 1.99316883e+01, 7.50000000e+00, 9.93309021e+00,
+       1.89429226e+01, 7.50000000e+00, 1.01533279e+01, 1.79563694e+01,
+       7.50000000e+00, 1.01899872e+01, 1.77921581e+01, 7.50000000e+00,
+       1.05375443e+01, 1.62351933e+01, 7.50000000e+00, 5.16325378e+00,
+       1.36915207e+00, 7.50000000e+00, 1.12108917e+01, 1.32189503e+01,
+       7.50000000e+00, 1.13739777e+01, 1.24883900e+01, 7.50000000e+00,
+       5.34767151e+00, 1.10381126e+00, 7.50000000e+00, 8.29132080e-01,
+       2.04845829e+01, 7.50000000e+00, 5.50823212e+00, 1.46916962e+00,
+       7.50000000e+00, 1.22750778e+01, 8.45180321e+00, 7.50000763e+00,
+       1.26153336e+01, 6.92763901e+00, 7.50000000e+00, 5.43852234e+00,
+       1.76854706e+00, 7.50000000e+00, 9.65370178e-01, 2.09781208e+01,
+       7.49999237e+00, 1.33408356e+00, 1.99349766e+01, 7.50000763e+00,
+       1.17034912e+00, 2.06385441e+01, 7.50000000e+00, 1.19338989e+00,
+       2.10817852e+01, 7.50000000e+00, 7.54943848e-01, 2.29669476e+01,
+       7.50000000e+00, 1.52631378e+00, 2.01932850e+01, 7.49999237e+00,
+       1.02262573e+01, 1.70032825e+01, 7.50000000e+00, 1.02628174e+01,
+       1.68395748e+01, 7.49999237e+00, 1.39884949e+00, 2.07416553e+01,
+       7.50000000e+00, 1.14079285e+01, 1.17136555e+01, 7.50000000e+00,
+       1.25576248e+01, 6.56712914e+00, 7.50000000e+00, 7.95837402e-01,
+       2.33360157e+01, 7.50000000e+00, 1.38575745e+00, 2.13429241e+01,
+       7.50000000e+00, 9.83505249e-01, 2.30746326e+01, 7.49999237e+00,
+       1.86492920e+00, 1.98253155e+01, 7.50000000e+00, 1.66463470e+00,
+       2.06880779e+01, 7.50000000e+00, 1.87074280e+00, 2.03470516e+01,
+       7.50000000e+00, 1.23120117e+00, 2.31036892e+01, 7.50000000e+00,
+       9.34545135e+00, 2.03188496e+01, 7.50000000e+00, 9.91494751e+00,
+       1.77713413e+01, 7.50000000e+00, 9.37507629e-01, 2.43695965e+01,
+       7.50000000e+00, 4.54124451e+00, 9.37762642e+00, 7.50000763e+00,
+       1.10984726e+01, 1.24771862e+01, 7.50000763e+00, 2.20439911e+00,
+       1.94564037e+01, 7.50000000e+00, 2.14984131e+00, 1.96917400e+01,
+       7.49999237e+00, 4.53302002e+00, 9.95601082e+00, 7.50000000e+00,
+       1.19992523e+01, 8.44784355e+00, 7.50000000e+00, 1.20530319e+01,
+       8.20725822e+00, 7.50000763e+00, 1.21426163e+01, 7.80659294e+00,
+       7.49999237e+00, 1.23393860e+01, 6.92639732e+00, 7.50000000e+00,
+       1.25892410e+01, 5.80871964e+00, 7.50000000e+00, 1.47975922e+00,
+       2.31328411e+01, 7.50000000e+00, 1.09391785e+00, 2.47980213e+01,
+       7.50000000e+00, 4.93393707e+00, 8.76922798e+00, 7.49999237e+00,
+       9.64035797e+00, 1.83753872e+01, 7.50000000e+00, 1.01525421e+01,
+       1.60858974e+01, 7.50000763e+00, 1.63187408e+00, 2.30286503e+01,
+       7.50000000e+00, 1.50341797e+00, 2.35833569e+01, 7.50000000e+00,
+       1.10425034e+01, 1.21077671e+01, 7.50000000e+00, 6.23359680e+00,
+       3.69834137e+00, 7.50000000e+00, 1.21213379e+01, 7.28531837e+00,
+       7.50000000e+00, 1.23178406e+01, 6.40695953e+00, 7.49999237e+00,
+       1.26207352e+01, 5.05297089e+00, 7.50000000e+00, 5.45832062e+00,
+       7.04831314e+00, 7.50000000e+00, 5.42295074e+00, 7.20120430e+00,
+       7.49999237e+00, 4.90850830e+00, 9.42410469e+00, 7.50000000e+00,
+       4.80174255e+00, 9.88542747e+00, 7.50000000e+00, 4.73049927e+00,
+       1.01932507e+01, 7.50000763e+00, 9.91519165e+00, 1.65254383e+01,
+       7.50000000e+00, 1.71083069e+00, 2.32413921e+01, 7.50000000e+00,
+       1.43517303e+00, 2.44324780e+01, 7.50000000e+00, 1.21001282e+01,
+       6.76559448e+00, 7.50000000e+00, 5.29191589e+00, 8.31300926e+00,
+       7.50000000e+00, 5.23867035e+00, 8.54322243e+00, 7.50000000e+00,
+       4.95423889e+00, 9.77307701e+00, 7.49999237e+00, 1.40357208e+00,
+       2.51252384e+01, 7.50000000e+00, 6.02842712e+00, 5.67381096e+00,
+       7.50000000e+00, 8.94431305e+00, 2.02397060e+01, 7.50000763e+00,
+       5.49782562e+00, 7.96940422e+00, 7.50000000e+00, 5.26703644e+00,
+       8.96793175e+00, 7.50000000e+00, 4.48194122e+00, 1.23646030e+01,
+       7.50000000e+00, 2.23616791e+00, 2.20809040e+01, 7.50000000e+00,
+       9.75108337e+00, 1.66384563e+01, 7.50000000e+00, 1.72212982e+00,
+       2.43048115e+01, 7.50000000e+00, 6.21659088e+00, 5.40608025e+00,
+       7.50000000e+00, 6.00477600e+00, 6.32308197e+00, 7.50000000e+00,
+       1.17574615e+01, 7.68256950e+00, 7.50000000e+00, 5.86331177e+00,
+       6.93548965e+00, 7.50000000e+00, 5.75708771e+00, 7.39536667e+00,
+       7.50000000e+00, 8.55922699e+00, 2.13369427e+01, 7.49999237e+00,
+       8.76200104e+00, 2.04324207e+01, 7.50000000e+00, 5.57978821e+00,
+       8.16290092e+00, 7.50000000e+00, 5.08170319e+00, 1.03192158e+01,
+       7.50000000e+00, 4.84960938e+00, 1.13239918e+01, 7.50000000e+00,
+       9.69676208e+00, 1.62628117e+01, 7.50000000e+00, 2.46238708e+00,
+       2.16587238e+01, 7.50000000e+00, 2.04064178e+00, 2.34844990e+01,
+       7.50000000e+00, 1.80150604e+00, 2.45198002e+01, 7.50000000e+00,
+       1.19331512e+01, 6.28715324e+00, 7.50000000e+00, 1.20044556e+01,
+       5.96912384e+00, 7.50000000e+00, 1.20400772e+01, 5.81019783e+00,
+       7.50000763e+00, 1.21291046e+01, 5.41313171e+00, 7.50000000e+00,
+       6.36970520e+00, 5.29079628e+00, 7.50000000e+00, 6.17556763e+00,
+       6.13179970e+00, 7.50000000e+00, 5.73293304e+00, 8.04923820e+00,
+       7.50000000e+00, 4.87758636e+00, 1.17545223e+01, 7.50000000e+00,
+       2.61561584e+00, 2.15531826e+01, 7.50000000e+00, 2.19388580e+00,
+       2.33800831e+01, 7.50000000e+00, 1.11256561e+01, 9.27733803e+00,
+       7.50000000e+00, 1.12691498e+01, 8.63769722e+00, 7.50000000e+00,
+       1.13229218e+01, 8.39807701e+00, 7.49999237e+00, 1.13766403e+01,
+       8.15858269e+00, 7.50000000e+00, 1.14303360e+01, 7.91921806e+00,
+       7.50000000e+00, 1.14661255e+01, 7.75971794e+00, 7.50000000e+00,
+       1.16626892e+01, 6.88350868e+00, 7.50000000e+00, 6.43483734e+00,
+       5.55764008e+00, 7.50000000e+00, 6.13439941e+00, 6.85997009e+00,
+       7.50000000e+00, 6.01042175e+00, 7.39735794e+00, 7.50000000e+00,
+       8.47177124e+00, 2.04889240e+01, 7.50000000e+00, 5.88628387e+00,
+       7.93541145e+00, 7.50000000e+00, 9.35157776e+00, 1.65698948e+01,
+       7.50000000e+00, 9.40631866e+00, 1.63261127e+01, 7.50000000e+00,
+       5.67314911e+00, 8.85933495e+00, 7.50000000e+00, 5.61978149e+00,
+       9.09062004e+00, 7.50000763e+00, 1.04223938e+01, 1.18001041e+01,
+       7.50000000e+00, 5.04886627e+00, 1.15653324e+01, 7.50000000e+00,
+       1.16422424e+01, 6.36645126e+00, 7.50000000e+00, 1.17491531e+01,
+       5.89024925e+00, 7.50000000e+00, 2.14503479e+00, 2.41524563e+01,
+       7.50000000e+00, 2.05294037e+00, 2.45516415e+01, 7.50000000e+00,
+       6.79992676e+00, 4.52476692e+00, 7.50000000e+00, 6.60604095e+00,
+       5.36571884e+00, 7.50000000e+00, 6.50012207e+00, 5.82510948e+00,
+       7.50000000e+00, 6.19942474e+00, 7.12935066e+00, 7.50000763e+00,
+       6.16399384e+00, 7.28305054e+00, 7.50000000e+00, 6.05762482e+00,
+       7.74447060e+00, 7.49999237e+00, 1.02593765e+01, 1.19156742e+01,
+       7.50000000e+00, 1.09967499e+01, 8.63342476e+00, 7.50000000e+00,
+       1.14258194e+01, 6.72350502e+00, 7.50000000e+00, 5.29190063e+00,
+       1.10656681e+01, 7.50000000e+00, 5.04134369e+00, 1.21524639e+01,
+       7.50000000e+00, 2.68460083e+00, 2.23745823e+01, 7.50000000e+00,
+       8.09045410e+00, 2.09547977e+01, 7.50000000e+00, 6.84798431e+00,
+       4.86743736e+00, 7.50000000e+00, 6.49483490e+00, 6.40017700e+00,
+       7.50000000e+00, 6.42405701e+00, 6.70737267e+00, 7.50000000e+00,
+       6.24688721e+00, 7.47631645e+00, 7.50000000e+00, 9.95206451e+00,
+       1.26739902e+01, 7.50000000e+00, 1.02048721e+01, 1.15494976e+01,
+       7.50000000e+00, 1.03490295e+01, 1.09082203e+01, 7.50000000e+00,
+       2.98512268e+00, 2.16328793e+01, 7.50000000e+00, 1.09951706e+01,
+       8.03407860e+00, 7.50000000e+00, 1.11917572e+01, 7.15963173e+00,
+       7.50000000e+00, 1.14769974e+01, 5.89084053e+00, 7.50000000e+00,
+       1.15303802e+01, 5.65335464e+00, 7.50000000e+00, 2.83850861e+00,
+       2.22692089e+01, 7.50000000e+00, 2.21303558e+00, 2.49838505e+01,
+       7.49999237e+00, 6.50724792e+00, 6.90005875e+00, 7.50000000e+00,
+       6.31221008e+00, 7.74706841e+00, 7.50000000e+00, 3.15755463e+00,
+       2.14474354e+01, 7.50000000e+00, 3.02931213e+00, 2.20044193e+01,
+       7.50000000e+00, 9.98822021e+00, 1.19055843e+01, 7.50000000e+00,
+       2.91925812e+00, 2.24823933e+01, 7.50000000e+00, 2.44095612e+00,
+       2.45595760e+01, 7.50000000e+00, 2.38563538e+00, 2.47998791e+01,
+       7.50000000e+00, 1.09042511e+01, 7.83376884e+00, 7.50000000e+00,
+       1.09578705e+01, 7.59542656e+00, 7.50000000e+00, 1.14746780e+01,
+       5.29818535e+00, 7.50000000e+00, 7.92869568e+00, 1.27826881e+00,
+       7.50000000e+00, 7.08567810e+00, 4.94175529e+00, 7.50000000e+00,
+       6.76770020e+00, 6.32357788e+00, 7.50000000e+00, 6.71459961e+00,
+       6.55430412e+00, 7.50000000e+00, 5.50354004e+00, 1.18172436e+01,
+       7.50000000e+00, 7.32826996e+00, 4.44231796e+00, 7.50000000e+00,
+       6.69189453e+00, 7.20955276e+00, 7.50000000e+00, 3.68598175e+00,
+       2.02806721e+01, 7.50000000e+00, 9.69953918e+00, 1.25822849e+01,
+       7.50000000e+00, 1.00062332e+01, 1.12198811e+01, 7.50000000e+00,
+       1.00962677e+01, 1.08199863e+01, 7.50000000e+00, 1.09028244e+01,
+       7.23727226e+00, 7.50000000e+00, 2.78681183e+00, 2.41906986e+01,
+       7.50000000e+00, 1.14013443e+01, 5.02280807e+00, 7.50000000e+00,
+       2.56538391e+00, 2.51535320e+01, 7.50000000e+00, 7.37715149e+00,
+       4.78602982e+00, 7.50000000e+00, 7.76889038e+00, 2.05476627e+01,
+       7.49999237e+00, 6.93521118e+00, 6.70902252e+00, 7.50000000e+00,
+       3.32795715e+00, 2.24050999e+01, 7.50000000e+00, 2.81253815e+00,
+       2.46478481e+01, 7.50000000e+00, 9.66390991e+00, 1.21358089e+01,
+       7.49999237e+00, 2.73868561e+00, 2.49691639e+01, 7.50000000e+00,
+       4.14186859e+00, 1.94305859e+01, 7.49999237e+00, 2.81985474e+00,
+       2.51867046e+01, 7.50000000e+00, 7.72242737e+00, 4.39932632e+00,
+       7.50000000e+00, 1.12039108e+01, 5.29981613e+00, 7.49999237e+00,
+       7.06795502e+00, 7.25074196e+00, 7.50000000e+00, 6.56982422e+00,
+       9.42105675e+00, 7.50000000e+00, 3.71169281e+00, 2.18734684e+01,
+       7.50000763e+00, 3.61991882e+00, 2.22733402e+01, 7.50000000e+00,
+       3.56481171e+00, 2.25134335e+01, 7.50000000e+00, 2.97514343e+00,
+       2.50825367e+01, 7.50000000e+00, 7.22333527e+00, 7.13556671e+00,
+       7.50000000e+00, 4.41612244e+00, 1.93740520e+01, 7.50000000e+00,
+       4.36136627e+00, 1.96127872e+01, 7.50000000e+00, 3.25994873e+00,
+       2.44146061e+01, 7.50000000e+00, 3.16762543e+00, 2.48171177e+01,
+       7.49999237e+00, 7.98042297e+00, 4.39618874e+00, 7.50000000e+00,
+       1.12374878e+01, 4.55268669e+00, 7.50000000e+00, 3.94952393e+00,
+       2.19809437e+01, 7.50000000e+00, 3.74737549e+00, 2.28628597e+01,
+       7.49999237e+00, 6.91178894e+00, 9.62413979e+00, 7.50000000e+00,
+       4.56343079e+00, 1.98754520e+01, 7.50000763e+00, 3.81133270e+00,
+       2.31586781e+01, 7.49999237e+00, 3.38695526e+00, 2.50111866e+01,
+       7.50000000e+00, 4.15148926e+00, 2.22493572e+01, 7.50000000e+00,
+       9.59294128e+00, 1.12465649e+01, 7.50000000e+00, 1.04533844e+01,
+       7.43235588e+00, 7.49999237e+00, 4.05953979e+00, 2.26509342e+01,
+       7.50000000e+00, 3.96752930e+00, 2.30528851e+01, 7.50000000e+00,
+       3.87543488e+00, 2.34551983e+01, 7.50000000e+00, 6.66921997e+00,
+       1.18216572e+01, 7.50000000e+00, 4.12397003e+00, 2.29469433e+01,
+       7.50000000e+00, 7.30226135e+00, 2.07944851e+01, 7.50000000e+00,
+       7.37581635e+00, 2.04686375e+01, 7.50000000e+00, 8.49910736e+00,
+       4.38989258e+00, 7.49999237e+00, 4.13324738e+00, 2.34855137e+01,
+       7.50000000e+00, 8.53216553e+00, 4.81352615e+00, 7.50000000e+00,
+       8.75978088e+00, 4.38671875e+00, 7.50000000e+00, 8.72444153e+00,
+       4.54142952e+00, 7.50000763e+00, 6.40096283e+00, 1.47173443e+01,
+       7.50000000e+00, 4.41041565e+00, 2.34351559e+01, 7.50000000e+00,
+       1.16921844e+01, 1.34796333e+00, 7.50000000e+00, 4.37351990e+00,
+       2.35967312e+01, 7.50000000e+00, 4.33661652e+00, 2.37583675e+01,
+       7.50000000e+00, 4.05939484e+00, 2.49725208e+01, 7.50000000e+00,
+       8.22062683e+00, 1.61246777e+01, 7.50000000e+00, 4.49524689e+00,
+       2.48191624e+01, 7.50000000e+00, 9.81262970e+00, 2.05831146e+00,
+       7.50000000e+00, 1.01490021e+01, 7.58822060e+00, 7.49999237e+00,
+       1.01846848e+01, 7.43023682e+00, 7.50000000e+00, 6.94113159e+00,
+       1.46676273e+01, 7.50000000e+00, 1.07716751e+01, 4.83176613e+00,
+       7.50000000e+00, 1.08603134e+01, 4.43941116e+00, 7.50000000e+00,
+       7.00885010e+00, 1.49534664e+01, 7.50000000e+00, 4.90419006e+00,
+       2.42015324e+01, 7.50000000e+00, 7.23973846e+00, 1.45232601e+01,
+       7.50000000e+00, 4.95172882e+00, 2.45836430e+01, 7.50000000e+00,
+       9.49341583e+00, 5.19332886e+00, 7.50000000e+00, 6.99852753e+00,
+       2.09312649e+01, 7.50000000e+00, 7.07207489e+00, 2.06058903e+01,
+       7.50000000e+00, 5.03646088e+00, 2.48036823e+01, 7.50000000e+00,
+       9.81153870e+00, 4.37393761e+00, 7.50000000e+00, 9.56360626e+00,
+       5.46560287e+00, 7.50000000e+00, 9.52812195e+00, 5.62177658e+00,
+       7.50000000e+00, 5.25107574e+00, 2.44531918e+01, 7.50000000e+00,
+       6.22891998e+00, 2.37319431e+01, 7.50000000e+00, 6.70896912e+00,
+       2.16097698e+01, 7.50000000e+00, 6.81941986e+00, 2.11214809e+01,
+       7.50000000e+00, 9.89981079e+00, 4.56723595e+00, 7.50000000e+00,
+       9.74037933e+00, 5.26963043e+00, 7.50000000e+00, 8.37120056e+00,
+       1.42614422e+01, 7.50000000e+00, 9.98825836e+00, 4.76095772e+00,
+       7.50000000e+00, 9.82873535e+00, 5.46427727e+00, 7.50000000e+00,
+       9.72223663e+00, 5.93379021e+00, 7.50000000e+00, 9.86341858e+00,
+       7.66470718e+00, 7.50000000e+00, 6.36286926e+00, 2.07445965e+01,
+       7.50000763e+00, 6.32612610e+00, 2.09065990e+01, 7.50000000e+00,
+       6.03168488e+00, 2.22047215e+01, 7.50000000e+00, 5.44021606e+00,
+       2.48124447e+01, 7.50000000e+00, 1.01654739e+01, 4.56434441e+00,
+       7.50000000e+00, 9.70403290e+00, 6.60012627e+00, 7.50000000e+00,
+       6.54096222e+00, 2.05548763e+01, 7.50000000e+00, 1.03429260e+01,
+       4.36747932e+00, 7.50000000e+00, 6.25924683e+00, 2.23959713e+01,
+       7.50000000e+00, 5.98219299e+00, 2.36190929e+01, 7.50000000e+00,
+       1.02370453e+01, 5.42307472e+00, 7.50000000e+00, 1.04320831e+01,
+       4.56144905e+00, 7.50000000e+00, 5.92669678e+00, 2.38641262e+01,
+       7.50000000e+00, 1.12435074e+01, 9.76715088e-01, 7.50000000e+00,
+       1.11908112e+01, 1.20960045e+00, 7.50000000e+00, 0.,
+       3.03560257e-01, 8.35342407e-02, 1.82220764e+01, 2.47341747e+01,
+       7.50000000e+00, 0., 1.48293304e+00, 5.55572510e-01,
+       1.77601776e+01, 2.31959896e+01, 7.50000000e+00, 6.35142517e+00,
+       2.19890118e+01, 7.50000000e+00, 7.62939453e-06, 2.69728279e+00,
+       4.84573364e-01, 1.74724197e+01, 2.30760441e+01, 7.50000000e+00,
+       1.79201736e+01, 2.09806385e+01, 7.50000763e+00, 7.62939453e-06,
+       5.82420158e+00, 1.84669495e-01, 1.01657486e+01, 5.14967537e+00,
+       7.50000000e+00, 1.69424820e+01, 2.40932903e+01, 7.50000000e+00,
+       1.74098358e+01, 2.19098797e+01, 7.50000000e+00, 6.33876038e+00,
+       2.14470005e+01, 7.50000000e+00, 1.76519470e+01, 2.07787418e+01,
+       7.50000000e+00, 7.92701721e+00, 1.44399281e+01, 7.50000000e+00,
+       7.99944305e+00, 1.41204319e+01, 7.50000000e+00, 8.05372620e+00,
+       1.38809643e+01, 7.50000000e+00, -7.62939453e-06, 6.80836296e+00,
+       2.80906677e-01, 0., 2.15388107e+00, 1.46562958e+00,
+       1.67434464e+01, 2.42949696e+01, 7.50000763e+00, 0.,
+       4.53736496e+00, 9.14382935e-01, 6.53007507e+00, 2.17995129e+01,
+       7.50000000e+00, 1.09414825e+01, 1.14079475e+00, 7.50000000e+00,
+       5.40312958e+00, 2.49759350e+01, 7.50000000e+00, 6.43791962e+00,
+       2.22066593e+01, 7.50000000e+00, 5.62541199e+00, 2.39958744e+01,
+       7.50000763e+00, 0., 7.81724739e+00, 1.55815125e-01, 0.,
+       3.70278168e+00, 1.21416473e+00, 1.00238876e+01, 6.95535278e+00,
+       7.50000000e+00, 7.71301270e+00, 1.47920933e+01, 7.50000000e+00,
+       1.65447083e+01, 2.44963779e+01, 7.49999237e+00, 1.70683365e+01,
+       2.20540104e+01, 7.50000000e+00, 0., 9.27942276e-01,
+       1.96013641e+00, 0., 4.43850517e+00, 1.15127563e+00,
+       7.62939453e-06, 4.68722534e+00, 1.09396362e+00, 7.62939453e-06,
+       5.01963997e+00, 1.01737213e+00, 0., 5.42779541e+00,
+       1.03058624e+00, 0., 4.58818245e+00, 1.33042145e+00, 0.,
+       5.92050171e+00, 1.02459717e+00, 1.74651489e+01, 1.94827328e+01,
+       7.50000000e+00, 1.68584442e+01, 2.15900898e+01, 7.50000000e+00,
+       -7.62939453e-06, 5.41059494e+00, 1.24862671e+00, 0.,
+       6.16280174e+00, 1.07627869e+00, 5.85375214e+00, 2.23935490e+01,
+       7.50000000e+00, 5.94588470e+00, 2.19876537e+01, 7.50000000e+00,
+       -7.62939453e-06, 5.23558998e+00, 1.39548492e+00, 0.,
+       5.65206718e+00, 1.30023956e+00, 7.62939453e-06, 6.65736771e+00,
+       1.07035065e+00, 7.62939453e-06, 7.07866096e+00, 9.74006653e-01,
+       0., 4.15157509e+00, 1.74952698e+00, 0., 6.31215096e+00,
+       1.25639343e+00, 0., 7.49135590e+00, 9.87251282e-01,
+       1.59213257e+01, 2.45141163e+01, 7.50000000e+00, 1.66495667e+01,
+       2.11283817e+01, 7.50000000e+00, 1.04117508e+01, 2.31167793e+00,
+       7.50000000e+00, 1.04469604e+01, 2.15655518e+00, 7.50000000e+00,
+       7.62939453e-06, 4.30861473e+00, 1.81977844e+00, -7.62939453e-06,
+       6.55452347e+00, 1.30814362e+00, 1.70208664e+01, 1.94021015e+01,
+       7.50000000e+00, 0., 7.04949188e+00, 1.30253601e+00,
+       7.62939453e-06, 7.21806145e+00, 1.26419830e+00, 0.,
+       8.57485390e+00, 9.55703735e-01, 1.57052612e+01, 2.48015842e+01,
+       7.50000000e+00, 0., 2.33315849e+00, 2.47991943e+00, 0.,
+       8.99082756e+00, 9.68971252e-01, 1.57427597e+01, 2.46273785e+01,
+       7.50000000e+00, 9.35057831e+00, 6.40349960e+00, 7.50000763e+00,
+       1.02378082e+01, 6.60143852e+00, 7.49999237e+00, 0.,
+       5.94149780e+00, 1.76741791e+00, -7.62939453e-06, 6.44274330e+00,
+       1.65388489e+00, 0., 8.04352379e+00, 1.29127502e+00, 0.,
+       9.15075874e+00, 1.04046631e+00, 7.62939453e-06, 9.40767097e+00,
+       9.82269287e-01, 5.18457031e+00, 2.41520367e+01, 7.50000000e+00,
+       0., 9.75103951e+00, 9.04487610e-01, 5.92183685e+00,
+       2.09080601e+01, 7.50000000e+00, 1.63407898e+01, 2.18493061e+01,
+       7.49999237e+00, 6.90650940e+00, 2.13383198e+01, 7.50000000e+00,
+       1.01115875e+01, 2.47336578e+00, 7.50000000e+00, 1.04455566e+01,
+       1.00393677e+00, 7.50000000e+00, 6.31559753e+00, 2.39523563e+01,
+       7.50000000e+00, 7.62939453e-06, 8.79810905e+00, 1.22785187e+00,
+       5.74469757e+00, 2.10969639e+01, 7.50000000e+00, 5.90988159e+00,
+       2.03706532e+01, 7.50000000e+00, 0., 8.96873665e+00,
+       1.18927002e+00, -7.62939453e-06, 9.91137123e+00, 9.76165771e-01,
+       0., 1.00835247e+01, 9.37232971e-01, 1.62371140e+01,
+       2.16184483e+01, 7.49999237e+00, 0., 6.25715446e+00,
+       1.90861511e+00, 0., 6.75905991e+00, 1.79535675e+00,
+       4.68202209e+00, 2.51777821e+01, 7.50000000e+00, 0.,
+       9.38500404e+00, 1.20278931e+00, 4.94116974e+00, 2.40390339e+01,
+       7.50000000e+00, 0., 1.03301983e+01, 9.89494324e-01,
+       5.58615875e+00, 2.12048931e+01, 7.50000000e+00, 0.,
+       1.05892162e+01, 9.31045532e-01, 0., 6.41498947e+00,
+       1.97921753e+00, 1.16368332e+01, 1.00190353e+00, 7.50000000e+00,
+       0., 9.54490089e+00, 1.27426910e+00, 1.53490067e+01,
+       2.50273304e+01, 7.50000000e+00, 1.01463165e+01, 1.16712761e+00,
+       7.50000000e+00, 0., 1.07499027e+01, 1.00286102e+00,
+       7.62939453e-06, 1.10096226e+01, 9.44358826e-01, 5.55636597e+00,
+       2.07483654e+01, 7.50000000e+00, 5.66638947e+00, 2.02652454e+01,
+       7.49999237e+00, 0., 1.12698803e+01, 8.85742188e-01,
+       1.55551224e+01, 2.40713139e+01, 7.50000000e+00, 7.03155518e+00,
+       1.42705059e+01, 7.50000000e+00, 7.13997650e+00, 1.37944393e+01,
+       7.49999237e+00, 0., 9.36044693e-01, 3.31698608e+00,
+       9.03610229e+00, 5.46824265e+00, 7.49999237e+00, 9.08923340e+00,
+       5.23489189e+00, 7.50000000e+00, 1.59287796e+01, 2.23383694e+01,
+       7.50000000e+00, 1.62638092e+01, 2.07844944e+01, 7.50000000e+00,
+       0., 4.00826645e+00, 2.62633514e+00, 0., 1.16918850e+01,
+       8.99040222e-01, 4.42117310e+00, 2.51442242e+01, 7.50000000e+00,
+       0., 7.82288551e+00, 1.87535858e+00, 7.62939453e-06,
+       1.15050335e+01, 1.04917908e+00, 0., 1.20274830e+01,
+       9.31953430e-01, 5.48999023e+00, 2.04539356e+01, 7.50000000e+00,
+       1.53400040e+01, 2.43581104e+01, 7.50000000e+00, 0.,
+       2.36871338e+00, 3.20323944e+00, 0., 8.06592751e+00,
+       1.92736053e+00, 7.16242218e+00, 1.31148739e+01, 7.50000000e+00,
+       7.62939453e-06, 1.11453762e+01, 1.23772430e+00, 0.,
+       1.24510288e+01, 9.45327759e-01, 0., 1.28014851e+01,
+       8.66844177e-01, 7.62939453e-06, 7.04640579e+00, 2.26164246e+00,
+       7.62939453e-06, 1.19140606e+01, 1.17361450e+00, 0.,
+       1.32268772e+01, 8.80180359e-01, 9.91816711e+00, 1.02192879e+00,
+       7.50000000e+00, 1.54057846e+01, 2.33449383e+01, 7.50000000e+00,
+       1.57228928e+01, 2.18766346e+01, 7.50000000e+00, 7.62939453e-06,
+       1.30371609e+01, 1.03096771e+00, 7.62939453e-06, 1.36531773e+01,
+       8.93531799e-01, 5.30282593e+00, 2.01078548e+01, 7.50000000e+00,
+       1.51165314e+01, 2.39775066e+01, 7.50000000e+00, 1.53034286e+01,
+       2.31127682e+01, 7.50000000e+00, 0., 6.94352150e+00,
+       2.49609375e+00, 1.50892868e+01, 2.33990383e+01, 7.50000000e+00,
+       9.58570099e+00, 1.33823204e+00, 7.50000000e+00, 9.62077332e+00,
+       1.18452835e+00, 7.50000000e+00, 0., 8.45721245e+00,
+       2.15904236e+00, 0., 9.56196022e+00, 1.91304779e+00,
+       6.93850708e+00, 2.18003902e+01, 7.50000000e+00, 1.52012939e+01,
+       2.28811512e+01, 7.50000000e+00, 1.04882889e+01, 6.68099785e+00,
+       7.50000000e+00, 7.62939453e-06, 1.39919491e+01, 9.26620483e-01,
+       5.23697662e+00, 1.98151760e+01, 7.50000000e+00, 7.62939453e-06,
+       1.43460217e+01, 8.47770691e-01, 0., 1.76683140e+01,
+       1.08001709e-01, 1.02207184e+01, 7.86627007e+00, 7.50000000e+00,
+       6.59967041e+00, 1.38470783e+01, 7.50000000e+00, 9.10699463e+00,
+       1.27998257e+01, 7.50000000e+00, 1.53877106e+01, 2.20193539e+01,
+       7.50000000e+00, 9.27058411e+00, 2.14958763e+00, 7.50000000e+00,
+       9.53376770e+00, 9.96971130e-01, 7.50000000e+00, 4.01322174e+00,
+       2.45917187e+01, 7.50000000e+00, 0., 2.34290695e+00,
+       3.62409210e+00, 6.51478577e+00, 1.36430683e+01, 7.50000000e+00,
+       0., 9.03983879e+00, 2.13573456e+00, 1.70675278e+01,
+       1.42532864e+01, 7.49999237e+00, 0., 1.27467175e+01,
+       1.31188202e+00, 0., 1.47748470e+01, 8.61152649e-01,
+       4.37265015e+00, 2.24383869e+01, 7.50000000e+00, 0.,
+       8.97560120e-01, 4.04814911e+00, 5.01439667e+00, 1.96314373e+01,
+       7.50000763e+00, 0., 2.09547424e+00, 3.78242493e+00, 0.,
+       7.34246826e+00, 2.61853790e+00, 1.45946274e+01, 2.49819698e+01,
+       7.50000000e+00, 6.35796356e+00, 1.37549267e+01, 7.50000000e+00,
+       7.62939453e-06, 1.45822201e+01, 1.01259613e+00, 1.51739807e+01,
+       2.23056583e+01, 7.50000000e+00, 1.71653671e+01, 1.31063480e+01,
+       7.50000000e+00, 0., 1.30693378e+01, 1.45606232e+00, 0.,
+       3.94043732e+00, 3.58104706e+00, 7.62939453e-06, 7.82566261e+00,
+       2.72251129e+00, 7.62939453e-06, 1.35817623e+01, 1.45056152e+00,
+       7.62939453e-06, 1.59772396e+01, 9.21226501e-01, 0.,
+       1.48031445e+01, 1.28900909e+00, 0., 1.56038036e+01,
+       1.11241913e+00, 0., 1.61403637e+01, 9.94079590e-01, 0.,
+       2.07046700e+00, 4.20005035e+00, 9.11635590e+00, 1.12524605e+00,
+       7.50000000e+00, 7.62939453e-06, 3.68191147e+00, 3.84532166e+00,
+       0., 1.24174213e+01, 1.92238617e+00, 1.17652893e+01,
+       1.61684036e+00, 7.50000000e+00, 7.62939453e-06, 1.43457012e+01,
+       1.49790192e+00, 8.50672913e+00, 1.60615597e+01, 7.49999237e+00,
+       4.26168823e+00, 2.17679310e+01, 7.50000000e+00, 0.,
+       1.52319088e+01, 1.30283356e+00, 4.88396454e+00, 1.90497341e+01,
+       7.50000000e+00, 0., 2.30444145e+00, 4.25134277e+00,
+       5.79217529e+00, 1.50825748e+01, 7.50000000e+00, 0.,
+       8.04691124e+00, 2.98968506e+00, 7.62939453e-06, 1.07631359e+01,
+       2.39289856e+00, 0., 1.41545582e+01, 1.64778900e+00, 0.,
+       1.49501896e+01, 1.47297668e+00, -7.62939453e-06, 1.58400478e+01,
+       1.27747345e+00, 7.62939453e-06, 2.15913792e+01, 1.38549805e-02,
+       7.35326385e+00, 2.11746807e+01, 7.50000000e+00, 4.87366486e+00,
+       1.85212383e+01, 7.50000000e+00, 7.62939453e-06, 3.91053963e+00,
+       4.00182343e+00, 0., 8.28861427e+00, 3.04177856e+00,
+       1.85002518e+01, 4.88497734e+00, 7.50000000e+00, 0.,
+       1.21303730e+01, 2.19932556e+00, 0., 1.43161983e+01,
+       1.72000885e+00, 0., 1.45810337e+01, 1.66193390e+00,
+       3.21247101e+00, 2.51963329e+01, 7.50000763e+00, 0.,
+       1.53788319e+01, 1.48698425e+00, 0., 1.56458721e+01,
+       1.42842865e+00, 0., 1.63607006e+01, 1.27167511e+00, 0.,
+       1.78023434e+01, 9.55543518e-01, 0., 2.12917385e+01,
+       1.90368652e-01, 4.93613434e+00, 1.76769047e+01, 7.50000000e+00,
+       0., 1.08244953e+01, 2.59182739e+00, 5.60662079e+00,
+       1.47519093e+01, 7.50000000e+00, 0., 1.27250500e+01,
+       2.17585754e+00, 0., 1.58975773e+01, 1.48150635e+00, 0.,
+       1.65969715e+01, 1.43685913e+00, 1.06862106e+01, 6.99811172e+00,
+       7.50000000e+00, 3.31529999e+00, 2.41732731e+01, 7.50000000e+00,
+       4.27003479e+00, 2.00109501e+01, 7.50000000e+00, 9.97027588e+00,
+       1.01739254e+01, 7.50000000e+00, 7.62939453e-06, 4.21262550e+00,
+       4.24525452e+00, 0., 1.53324032e+01, 1.82086945e+00, 0.,
+       1.92966061e+01, 9.56565857e-01, 6.11701202e+00, 1.19587269e+01,
+       7.50000000e+00, 0., 2.27261181e+01, 2.08847046e-01,
+       1.79177856e+01, 6.20689774e+00, 7.50000000e+00, 1.82045288e+01,
+       4.88743973e+00, 7.50000000e+00, 7.62939453e-06, 1.57610455e+01,
+       1.83522034e+00, 1.37285843e+01, 2.47903461e+01, 7.50000000e+00,
+       0., 1.90955296e+01, 1.10961914e+00, 0., 2.30810261e+01,
+       2.42347717e-01, 5.34966278e+00, 1.47371311e+01, 7.50000000e+00,
+       0., 3.71171761e+00, 4.55988312e+00, 1.20882568e+01,
+       1.37424278e+00, 7.50000000e+00, 7.62939453e-06, 1.13756771e+01,
+       2.89535522e+00, 1.05979462e+01, 7.98962212e+00, 7.50000763e+00,
+       0., 2.33421841e+01, 2.96386719e-01, 8.46015930e+00,
+       1.18512726e+00, 7.50000000e+00, 1.05085220e+01, 8.38658714e+00,
+       7.50000000e+00, 3.70309448e+00, 2.13409901e+01, 7.50000000e+00,
+       7.62939453e-06, 2.46680431e+01, 8.41522217e-03, 0.,
+       1.26574039e+01, 2.72323608e+00, 0., 1.56407795e+01,
+       2.07653046e+00, 1.78510895e+01, 5.83575439e+00, 7.50000000e+00,
+       0., 1.86041737e+01, 1.43415070e+00, 8.52029419e+00,
+       1.72122250e+01, 7.50000000e+00, 3.85904694e+00, 2.00941601e+01,
+       7.50000000e+00, 3.95033264e+00, 1.96969395e+01, 7.50000000e+00,
+       1.38344498e+01, 2.36135044e+01, 7.50000000e+00, 0.,
+       1.18663197e+01, 3.00051880e+00, 1.78562088e+01, 5.13653374e+00,
+       7.50000000e+00, 0., 2.52900486e+01, 9.62600708e-02, 0.,
+       1.06540623e+01, 3.36795807e+00, 0., 1.30642300e+01,
+       2.84751129e+00, 0., 2.19683132e+01, 9.24804688e-01, 0.,
+       2.22478657e+01, 8.64448547e-01, 0., 2.46007824e+01,
+       3.56369019e-01, 6.22976685e+00, 9.21911049e+00, 7.50000000e+00,
+       9.13777924e+00, 1.50776119e+01, 7.50000000e+00, 6.92216492e+00,
+       6.20824051e+00, 7.50000000e+00, 0., 1.23576641e+01,
+       3.10582733e+00, 7.41633606e+00, 4.05937386e+00, 7.50000000e+00,
+       7.99561310e+00, 1.54036522e+00, 7.50000000e+00, 0.,
+       1.60376225e+01, 2.31272888e+00, 1.75211945e+01, 6.00109100e+00,
+       7.50000000e+00, 1.81645966e+01, 3.04744339e+00, 7.49999237e+00,
+       0., 2.14837208e+01, 1.13899994e+00, 0., 2.50536861e+01,
+       3.69598389e-01, 7.72850037e+00, 2.13376293e+01, 7.50000000e+00,
+       7.69162750e+00, 2.15014133e+01, 7.50000000e+00, 0.,
+       2.52442646e+01, 3.28536987e-01, 0., 1.02050037e+01,
+       3.67449188e+00, 7.62939453e-06, 1.73610134e+01, 2.13520050e+00,
+       1.08148270e+01, 8.23129082e+00, 7.49999237e+00, 0.,
+       2.11862049e+01, 1.31240845e+00, 1.83822708e+01, 1.37887001e+00,
+       7.50000000e+00, 0., 2.22999859e+01, 1.07282257e+00,
+       1.34057846e+01, 2.35220776e+01, 7.49999237e+00, 9.87989044e+00,
+       1.23871212e+01, 7.50000000e+00, 0., 3.66085243e+00,
+       5.28577423e+00, 3.35877991e+00, 2.05735989e+01, 7.50000000e+00,
+       1.73357468e+01, 5.50873184e+00, 7.50000000e+00, 0.,
+       1.30960178e+01, 3.26407623e+00, 7.62939453e-06, 1.92230854e+01,
+       1.95121765e+00, 0., 1.97698383e+01, 1.83406067e+00, 0.,
+       2.04106197e+01, 1.69676971e+00, 0., 2.23519840e+01,
+       1.28079224e+00, 0., 2.49856968e+01, 7.16453552e-01, 0.,
+       9.83166313e+00, 4.06772614e+00, 0., 1.90232601e+01,
+       2.10202789e+00, 0., 2.37347431e+01, 1.09445190e+00,
+       2.39738464e+00, 2.41836987e+01, 7.50000000e+00, 0.,
+       8.67923737e-01, 6.08502960e+00, 1.73833618e+01, 3.95611382e+00,
+       7.50000000e+00, 0., 1.75624638e+01, 2.52169037e+00, 0.,
+       2.04641018e+01, 1.90235901e+00, 0., 2.39012165e+01,
+       1.16873169e+00, 4.65618134e+00, 1.43802471e+01, 7.50000000e+00,
+       7.62939453e-06, 9.38786888e+00, 4.37024689e+00, 5.10554504e+00,
+       1.24299107e+01, 7.50000000e+00, 9.91590118e+00, 1.28348713e+01,
+       7.50000000e+00, 0., 1.02311916e+01, 4.19060516e+00, 0.,
+       2.22903500e+01, 1.62164307e+00, 0., 9.20889091e+00,
+       4.51192474e+00, 0., 1.79770374e+01, 2.64767456e+00, 0.,
+       1.83369389e+01, 2.57115173e+00, 0., 1.98777103e+01,
+       2.24355316e+00, 3.01419830e+00, 2.09450016e+01, 7.50000000e+00,
+       3.14207458e+00, 2.03902950e+01, 7.50000000e+00, 3.97851562e+00,
+       1.67623386e+01, 7.50000000e+00, 7.25791168e+00, 2.46580563e+01,
+       7.50000000e+00, 0., 2.36699696e+01, 1.43727112e+00,
+       1.25268402e+01, 2.48230000e+01, 7.49999237e+00, 5.95112610e+00,
+       8.20638084e+00, 7.49999237e+00, 9.18848419e+00, 1.66824894e+01,
+       7.50000000e+00, 8.95095825e+00, 1.77397976e+01, 7.50000000e+00,
+       7.62939453e-06, 3.62479973e+00, 5.80031586e+00, 1.70032120e+01,
+       4.36789322e+00, 7.50000000e+00, 0., 9.53365135e+00,
+       4.54643250e+00, 1.75549545e+01, 1.84663010e+00, 7.50000000e+00,
+       0., 1.71542492e+01, 2.92931366e+00, 7.62413025e+00,
+       9.49859619e-01, 7.50000000e+00, 7.32794189e+00, 2.49642582e+01,
+       7.50000000e+00, 1.19448395e+01, 5.01856041e+00, 7.50000000e+00,
+       2.34733582e+00, 2.32755108e+01, 7.50000000e+00, 2.86051941e+00,
+       2.10510921e+01, 7.50000000e+00, 7.62939453e-06, 2.14170361e+01,
+       2.02473450e+00, 0., 4.50169563e+00, 5.71559143e+00, 0.,
+       4.66312218e+00, 5.68140411e+00, 0., 8.51863670e+00,
+       4.86483765e+00, 4.81601715e+00, 1.25747051e+01, 7.49999237e+00,
+       1.06207504e+01, 1.09165325e+01, 7.50000000e+00, 5.28119659e+00,
+       1.05582905e+01, 7.50000000e+00, 7.62939453e-06, 9.18696022e+00,
+       4.72328949e+00, 0., 1.01117496e+01, 4.52743530e+00,
+       9.11407471e+00, 1.76278667e+01, 7.50000000e+00, 8.23213196e+00,
+       2.15563374e+01, 7.50000000e+00, 7.49116516e+00, 2.48569241e+01,
+       7.49999237e+00, 1.33777390e+01, 2.02614117e+01, 7.50000000e+00,
+       6.54067230e+00, 5.09892845e+00, 7.50000000e+00, 6.57592010e+00,
+       4.94613075e+00, 7.50000000e+00, 6.78716278e+00, 4.03047562e+00,
+       7.49999237e+00, 0., 1.83919277e+01, 2.77375793e+00,
+       7.62939453e-06, 4.25234985e+00, 5.86952972e+00, 2.67049408e+00,
+       2.13154507e+01, 7.49999237e+00, 7.62939453e-06, 4.89763260e+00,
+       5.73313141e+00, 7.62939453e-06, 5.54631424e+00, 5.59600830e+00,
+       7.62939453e-06, 9.76332283e+00, 4.70462036e+00, 0.,
+       1.86445637e+01, 2.82730865e+00, 0., 4.48617935e+00,
+       5.92121887e+00, 7.62939453e-06, 5.86325645e+00, 5.63069153e+00,
+       0., 1.98941555e+01, 2.67060852e+00, 7.62939453e-06,
+       4.88159752e+00, 5.93893433e+00, 0., 8.90363503e+00,
+       5.09207153e+00, 1.69094086e+00, 2.49984417e+01, 7.50000000e+00,
+       1.29414139e+01, 2.09107761e+01, 7.50000000e+00, 0.,
+       1.96938686e+01, 2.82008362e+00, 1.04418640e+01, 1.29391880e+01,
+       7.50000763e+00, 7.62939453e-06, 2.22603588e+01, 2.27969360e+00,
+       0., 5.27780342e+00, 5.95670319e+00, 0., 5.52097130e+00,
+       5.90559387e+00, 1.67381439e+01, 3.60084343e+00, 7.50000000e+00,
+       0., 1.98569279e+01, 2.89292145e+00, 9.42274475e+00,
+       1.74850750e+01, 7.50000000e+00, 0., 2.11347218e+01,
+       2.62439728e+00, 5.50878906e+00, 8.47029305e+00, 7.50000000e+00,
+       9.27629852e+00, 1.81383457e+01, 7.50000000e+00, 1.24527512e+01,
+       4.57901764e+00, 7.50000000e+00, 1.24171982e+01, 4.73763466e+00,
+       7.50000000e+00, 1.08768234e+01, 1.16135044e+01, 7.50000000e+00,
+       1.07322998e+01, 1.22586575e+01, 7.50000000e+00, 6.55105591e+00,
+       3.95811272e+00, 7.50000000e+00, 6.58618927e+00, 3.80596924e+00,
+       7.50000763e+00, 7.19919586e+00, 1.15218353e+00, 7.50000000e+00,
+       0., 2.39153728e+01, 2.04004669e+00, 0., 5.75602531e+00,
+       5.95747375e+00, 0., 6.98066330e+00, 5.70061493e+00, 0.,
+       1.03907681e+01, 4.98538208e+00, 1.71114426e+01, 1.89895630e+00,
+       7.50000000e+00, 4.44611359e+00, 1.25196247e+01, 7.50000000e+00,
+       9.33019257e+00, 1.85172634e+01, 7.50000000e+00, 9.22010040e+00,
+       1.90087032e+01, 7.50000000e+00, 9.18337250e+00, 1.91726437e+01,
+       7.49999237e+00, 5.56874847e+00, 7.66262627e+00, 7.49999237e+00,
+       0., 2.08405323e+01, 2.79365540e+00, 0., 1.59667969e+00,
+       6.92928314e+00, 7.11618042e+00, 9.67697144e-01, 7.50000000e+00,
+       7.62939453e-06, 6.72553062e+00, 5.85565948e+00, 0.,
+       1.90962811e+01, 3.26609039e+00, 2.68590546e+00, 1.95807552e+01,
+       7.50000000e+00, 0., 2.10956821e+01, 2.84755707e+00,
+       1.64245148e+01, 4.37462807e+00, 7.50000000e+00, 1.64958496e+01,
+       4.04965973e+00, 7.50000000e+00, 0., 6.87995911e+00,
+       5.92481232e+00, 7.62939453e-06, 2.49767628e+01, 2.14400482e+00,
+       0., 2.52598057e+01, 2.08486938e+00, 6.03438568e+00,
+       5.10275078e+00, 7.50000000e+00, 1.05884933e+01, 1.35178661e+01,
+       7.50000000e+00, 1.04069672e+01, 1.43286915e+01, 7.50000000e+00,
+       7.62939453e-06, 2.74791718e-02, 7.45499420e+00, 0.,
+       8.43512917e+00, 5.70188904e+00, 0., 8.85011864e+00,
+       5.61536407e+00, 0., 1.80734539e+01, 3.69217682e+00,
+       7.62939453e-06, 1.82523327e+01, 3.65486908e+00, 7.62939453e-06,
+       1.91504154e+01, 3.46761322e+00, 7.62939453e-06, 2.00547314e+01,
+       3.27904510e+00, 0., 2.03272495e+01, 3.22222137e+00,
+       1.04804077e+01, 1.46203556e+01, 7.49999237e+00, 0.,
+       2.14230289e+01, 2.99374390e+00, 0., 2.22509098e+01,
+       2.82112122e+00, 1.60393982e+01, 5.47388077e+00, 7.50000000e+00,
+       4.09604645e+00, 1.23875294e+01, 7.50000000e+00, 0.,
+       9.33892632e+00, 5.61566925e+00, 8.99636078e+00, 2.12540646e+01,
+       7.49999237e+00, 5.04039764e+00, 8.30946159e+00, 7.50000000e+00,
+       7.62939453e-06, 1.86829243e+01, 3.67113495e+00, 5.55340576e+00,
+       6.09409904e+00, 7.50000763e+00, 5.74732208e+00, 5.25673485e+00,
+       7.50000000e+00, 5.90570068e+00, 4.57281303e+00, 7.50000000e+00,
+       7.62939453e-06, 2.16785030e+01, 3.04774475e+00, 0.,
+       3.62585258e+00, 6.90437317e+00, 0., 9.49475670e+00,
+       5.68541718e+00, 1.36528397e+01, 1.05101204e+00, 7.50000000e+00,
+       7.62939453e-06, 1.92945232e+01, 3.65002441e+00, 2.08318329e+00,
+       2.05287151e+01, 7.50000000e+00, 4.08708954e+00, 1.18805103e+01,
+       7.50000000e+00, 7.62939453e-06, 2.22102871e+01, 3.04441833e+00,
+       1.53308029e+01, 8.04407310e+00, 7.50000000e+00, 6.27983856e+00,
+       2.41736603e+00, 7.50000000e+00, 0., 8.81817436e+00,
+       5.92771912e+00, 0., 9.15047264e+00, 5.85884094e+00,
+       1.58330765e+01, 5.75931740e+00, 7.50000000e+00, 0.,
+       5.45386505e+00, 6.72540283e+00, 0., 9.47258186e+00,
+       5.89398193e+00, 1.13334808e+01, 1.14259853e+01, 7.50000000e+00,
+       7.62939453e-06, 9.72288322e+00, 5.84220123e+00, 4.04245758e+00,
+       1.15289555e+01, 7.50000000e+00, 0., 1.08975697e+01,
+       5.59917450e+00, 1.08810425e+01, 1.34497776e+01, 7.50000000e+00,
+       5.12599182e+00, 6.85567665e+00, 7.50000000e+00, 5.39065552e+00,
+       5.71414566e+00, 7.50000000e+00, 1.08266220e+01, 1.36932659e+01,
+       7.50000000e+00, 5.00396729e-01, 9.41219330e-02, 7.50000000e+00,
+       0., 9.87867165e+00, 5.91193390e+00, 0., 1.01296253e+01,
+       5.86012268e+00, 0., 1.11384945e+01, 5.65180969e+00,
+       1.67304077e+01, 1.02893639e+00, 7.50000000e+00, 1.14357529e+01,
+       2.44311581e+01, 7.50000000e+00, 7.62939453e-06, 2.38147221e+01,
+       3.03443146e+00, 4.10491180e+00, 1.07171459e+01, 7.50000000e+00,
+       4.53173065e+00, 8.87748146e+00, 7.49999237e+00, 0.,
+       2.50304813e+01, 2.78339386e+00, 4.93905640e+00, 7.12170601e+00,
+       7.50000000e+00, 0., 2.52185154e+01, 2.74456787e+00,
+       6.02899170e+00, 2.42378044e+00, 7.50000000e+00, 0.,
+       5.67921066e+00, 6.87918091e+00, 6.94099426e-01, 2.48687916e+01,
+       7.50000000e+00, 7.67677307e-01, 2.45518932e+01, 7.49999237e+00,
+       9.88059998e-01, 2.36025295e+01, 7.50000000e+00, 8.36411285e+00,
+       2.47085400e+01, 7.50000763e+00, 0., 1.03694019e+01,
+       5.91265106e+00, 2.55383301e+00, 1.68577518e+01, 7.50000000e+00,
+       0., 1.07052326e+01, 5.84344482e+00, 7.62939453e-06,
+       1.15487423e+01, 5.66961670e+00, 0., 1.18877201e+01,
+       5.59976196e+00, 0., 1.98527241e+01, 3.95838165e+00, 0.,
+       2.03049030e+01, 3.86519623e+00, 7.62939453e-06, 1.10298252e+01,
+       5.87873840e+00, 0., 1.12827816e+01, 5.82672119e+00,
+       1.31629257e+01, 3.85758018e+00, 7.50000000e+00, 1.28429489e+01,
+       5.28994179e+00, 7.50000000e+00, 7.62939453e-06, 2.22010365e+01,
+       3.58115387e+00, 0., 7.44925499e+00, 6.71577454e+00, 0.,
+       1.15237751e+01, 5.87941742e+00, 4.35331726e+00, 8.56764412e+00,
+       7.50000000e+00, 0., 1.20318851e+01, 5.77511597e+00, 0.,
+       1.32254391e+01, 5.53012085e+00, 0., 1.21887722e+01,
+       5.84532166e+00, 1.60992813e+01, 3.24907303e+00, 7.50000000e+00,
+       0., 2.11556225e+01, 4.00835419e+00, 1.26647263e+01,
+       6.08774757e+00, 7.50000000e+00, 9.15519714e-01, 7.55279541e-01,
+       7.49999237e+00, 1.19824219e+00, 2.16047535e+01, 7.50000000e+00,
+       1.22682343e+01, 1.99905605e+01, 7.50000000e+00, 9.96986389e+00,
+       1.81509647e+01, 7.50000000e+00, 2.19740295e+00, 1.73060131e+01,
+       7.50000000e+00, 2.46821594e+00, 1.61408672e+01, 7.50000000e+00,
+       0., 7.67530441e+00, 6.87042236e+00, 4.09595490e+00,
+       9.13786507e+00, 7.50000000e+00, 7.62939453e-06, 1.28564777e+01,
+       5.81108093e+00, 0., 1.39703045e+01, 5.58335114e+00, 0.,
+       2.16830654e+01, 4.00641632e+00, 8.28155518e-01, 2.26521969e+01,
+       7.50000000e+00, 0., 2.22321873e+01, 3.89414215e+00,
+       1.52100372e+00, 1.96731701e+01, 7.50000000e+00, 2.17310333e+00,
+       1.68693485e+01, 7.50000000e+00, 2.49759674e+00, 1.54741001e+01,
+       7.50000000e+00, 1.60362473e+01, 2.88877869e+00, 7.50000000e+00,
+       7.62939453e-06, 8.15733147e+00, 6.87240601e+00, 4.58203888e+00,
+       6.51169777e+00, 7.50000000e+00, 4.63492584e+00, 6.28429413e+00,
+       7.50000000e+00, 1.64439774e+01, 1.03827858e+00, 7.50000000e+00,
+       5.82636261e+00, 1.16152382e+00, 7.50000000e+00, 9.69871521e-01,
+       2.14999866e+01, 7.50000763e+00, 1.11329498e+01, 2.44821949e+01,
+       7.50000000e+00, 0., 1.30137081e+01, 5.88143158e+00, 0.,
+       1.33556080e+01, 5.81167603e+00, 2.14885712e+00, 1.64338436e+01,
+       7.50000000e+00, 2.29302979e+00, 1.58143291e+01, 7.50000000e+00,
+       2.50891113e+00, 1.48866825e+01, 7.50000000e+00, 2.54484558e+00,
+       1.47322636e+01, 7.50000763e+00, 0., 1.47324352e+01,
+       5.53071594e+00, 0., 2.11168575e+01, 4.22794342e+00,
+       9.92988586e-01, 1.39830589e+00, 7.50000000e+00, 1.36820374e+01,
+       2.14927292e+00, 7.50000000e+00, 1.40164185e+00, 1.91045437e+01,
+       7.50000000e+00, 1.89025879e+00, 1.70062504e+01, 7.50000000e+00,
+       2.53813934e+00, 1.42239819e+01, 7.50000000e+00, 0.,
+       1.37702541e+01, 5.82973480e+00, 0., 1.39420033e+01,
+       5.79476166e+00, 7.62939453e-06, 9.29070473e+00, 6.84276581e+00,
+       1.36112823e+01, 2.46619606e+00, 7.50000000e+00, 1.19876404e+01,
+       9.73946571e+00, 7.50000000e+00, 0., 1.41857510e+01,
+       5.84783936e+00, 7.97012329e-01, 2.11609516e+01, 7.50000000e+00,
+       9.97238159e-01, 2.03016186e+01, 7.50000000e+00, 0.,
+       1.55699253e+01, 5.56649780e+00, 1.15725708e+00, 1.68098068e+00,
+       7.50000000e+00, 2.51351929e+00, 1.37940350e+01, 7.50000000e+00,
+       2.62096405e+00, 1.33328686e+01, 7.50000763e+00, 1.50460358e+01,
+       6.73518753e+00, 7.50000000e+00, 4.23692322e+00, 6.39754677e+00,
+       7.50000000e+00, 1.50818634e+01, 6.57266998e+00, 7.50000000e+00,
+       1.51176834e+01, 6.41021538e+00, 7.50000000e+00, 1.96865845e+00,
+       1.55969715e+01, 7.50000000e+00, 2.63204956e+00, 1.27515774e+01,
+       7.50000000e+00, 1.56355743e+01, 4.06142616e+00, 7.50000000e+00,
+       0., 1.46021099e+01, 5.86598206e+00, 7.62939453e-06,
+       1.51208019e+01, 5.76076508e+00, 1.62215118e+01, 1.40404510e+00,
+       7.50000000e+00, 0., 1.02649212e+01, 6.84668732e+00,
+       1.17714920e+01, 1.07077007e+01, 7.49999237e+00, 1.04256439e+00,
+       1.90327854e+01, 7.50000000e+00, 1.15125275e+00, 1.85668812e+01,
+       7.50000000e+00, 2.03459167e+00, 1.47803593e+01, 7.50000000e+00,
+       2.46448517e+00, 1.29375668e+01, 7.50000763e+00, 0.,
+       1.53658085e+01, 5.81401825e+00, 0., 2.22229061e+01,
+       4.42580414e+00, 1.08110809e+01, 1.50098934e+01, 7.50000000e+00,
+       1.58042297e+01, 2.65339470e+00, 7.50000000e+00, 8.74954224e-01,
+       1.92159863e+01, 7.50000000e+00, 9.43574524e+00, 2.11707630e+01,
+       7.50000763e+00, 2.02863312e+00, 1.42736874e+01, 7.50000000e+00,
+       9.38034058e+00, 2.14189968e+01, 7.50000000e+00, 2.45792389e+00,
+       1.24345608e+01, 7.50000000e+00, 2.52930450e+00, 1.21287899e+01,
+       7.50000000e+00, 8.34403992e-01, 1.88559208e+01, 7.50000000e+00,
+       1.60523987e+01, 1.52870369e+00, 7.50000000e+00, 2.23725891e+00,
+       1.28497524e+01, 7.49999237e+00, 2.48703003e+00, 1.17803631e+01,
+       7.50000000e+00, 2.59388733e+00, 1.13228474e+01, 7.50000000e+00,
+       3.86754608e+00, 5.86979866e+00, 7.50000763e+00, 1.61762390e+01,
+       9.67453003e-01, 7.50000000e+00, 9.92950439e-01, 3.35056305e+00,
+       7.50000000e+00, 7.62939453e-06, 1.56978703e+01, 5.84974670e+00,
+       5.05596161e+00, 7.81745911e-01, 7.50000000e+00, 0.,
+       2.50951481e+01, 6.88846588e+00, 1.34751129e+01, 3.69423103e+00,
+       7.50000000e+00, 7.93930054e-01, 1.84967403e+01, 7.50000763e+00,
+       0., 2.35803852e+01, 4.25708771e+00, 1.08296967e+00,
+       1.72600498e+01, 7.50000000e+00, 1.17312622e+00, 1.68742924e+01,
+       7.50000000e+00, 1.99886322e+00, 1.33411274e+01, 7.50000000e+00,
+       1.25120087e+01, 8.01164436e+00, 7.50000000e+00, 2.42705536e+00,
+       1.15089664e+01, 7.50000000e+00, 1.23325958e+01, 8.81588554e+00,
+       7.50000000e+00, 0., 2.37651501e+01, 4.21975708e+00,
+       9.71190643e+00, 2.05637493e+01, 7.50000000e+00, 1.26607666e+01,
+       1.62477474e+01, 7.50000000e+00, 4.61118317e+00, 2.16347885e+00,
+       7.50000000e+00, 1.48510513e+01, 6.32882500e+00, 7.50000763e+00,
+       1.42066498e+01, 1.03267288e+00, 7.50000000e+00, 1.41007309e+01,
+       1.50776672e+00, 7.50000763e+00, 1.54220810e+01, 3.74292564e+00,
+       7.50000000e+00, 2.02867889e+00, 1.26859150e+01, 7.49999237e+00,
+       2.06436157e+00, 1.25332966e+01, 7.49999237e+00, 2.15352631e+00,
+       1.21519833e+01, 7.50000000e+00, 2.47389984e+00, 1.07820187e+01,
+       7.49999237e+00, 0., 1.14122448e+01, 6.81678009e+00,
+       1.36404648e+01, 3.57255936e+00, 7.50000000e+00, 0.,
+       1.79605808e+01, 5.49631500e+00, 8.39622498e-01, 1.72413692e+01,
+       7.49999237e+00, 1.54932175e+01, 3.42076874e+00, 7.49999237e+00,
+       1.22761536e+00, 3.34586525e+00, 7.49999237e+00, 2.11181641e+00,
+       1.18043919e+01, 7.50000000e+00, 1.17550659e+00, 3.56543541e+00,
+       7.50000000e+00, 4.69651794e+00, 7.58216858e-01, 7.50000000e+00,
+       1.59897079e+01, 1.17234802e+00, 7.50000000e+00, 1.17590637e+01,
+       1.20123920e+01, 7.50000000e+00, 0., 2.42437153e+01,
+       6.74199677e+00, 1.09232559e+01, 1.57618160e+01, 7.50000000e+00,
+       7.99316406e-01, 1.68857403e+01, 7.50000763e+00, 8.71345520e-01,
+       1.65781498e+01, 7.50000000e+00, 1.15891266e+00, 1.53499050e+01,
+       7.50000000e+00, 0., 1.68879871e+01, 5.81578827e+00,
+       2.54940796e+00, 9.41098213e+00, 7.50000000e+00, 2.63789368e+00,
+       9.03301811e+00, 7.50000000e+00, 0., 2.49281101e+01,
+       4.19771576e+00, 3.76387787e+00, 4.22382355e+00, 7.50000000e+00,
+       0., 2.52078495e+01, 4.14141846e+00, 4.13064575e+00,
+       2.65733528e+00, 7.50000000e+00, 1.12790680e+00, 4.25988007e+00,
+       7.50000000e+00, 4.30482483e+00, 1.91337204e+00, 7.50000000e+00,
+       1.46823273e+01, 6.45021820e+00, 7.50000000e+00, 0.,
+       1.23136005e+01, 6.83762360e+00, 1.19004059e+00, 1.46916561e+01,
+       7.50000000e+00, 1.99315643e+00, 1.12635174e+01, 7.50000000e+00,
+       2.11752319e+00, 1.07326565e+01, 7.49999237e+00, 1.11811066e+01,
+       2.16417713e+01, 7.50000000e+00, 0., 1.77502804e+01,
+       5.74565887e+00, 3.31784058e+00, 5.60904121e+00, 7.49999237e+00,
+       3.56322479e+00, 4.56162262e+00, 7.50000000e+00, 0.,
+       1.89012547e+01, 5.51448822e+00, 1.31651611e+01, 6.32773209e+00,
+       7.50000000e+00, 1.23940582e+01, 9.78930855e+00, 7.50000000e+00,
+       1.16712341e+01, 1.30342007e+01, 7.50000763e+00, 0.,
+       2.34649639e+01, 6.68559265e+00, 9.58015442e-01, 5.47184181e+00,
+       7.50000000e+00, 1.33250427e+01, 1.19471035e+01, 7.50000000e+00,
+       2.04054260e+00, 1.05396023e+01, 7.50000000e+00, 2.09376526e+00,
+       1.03125744e+01, 7.50000763e+00, 3.41527557e+00, 4.67501831e+00,
+       7.50000000e+00, 4.09574890e+00, 1.77214050e+00, 7.50000000e+00,
+       1.43083878e+01, 1.81696892e+00, 7.50000000e+00, 8.58451843e-01,
+       1.50593281e+01, 7.49999237e+00, 1.51739502e+01, 3.58656311e+00,
+       7.50000000e+00, 2.08778381e+00, 9.81808281e+00, 7.50000000e+00,
+       0., 1.34744587e+01, 6.80751801e+00, 7.62939453e-06,
+       1.90437603e+01, 5.69335175e+00, 1.28476486e+01, 8.37913322e+00,
+       7.50000000e+00, 1.28480759e+01, 1.34593029e+01, 7.50000000e+00,
+       1.16920929e+01, 1.35703831e+01, 7.50000000e+00, 1.15648651e+01,
+       1.41419277e+01, 7.50000000e+00, 1.07613525e+01, 1.77516270e+01,
+       7.50000000e+00, 8.18367004e-01, 1.47084484e+01, 7.50000763e+00,
+       1.14155579e+00, 5.69197845e+00, 7.50000000e+00, 1.12229919e+00,
+       1.34134083e+01, 7.50000000e+00, 1.22937012e+00, 1.29572544e+01,
+       7.49999237e+00, 2.04644012e+00, 9.47571754e+00, 7.50000000e+00,
+       2.11717987e+00, 9.17428017e+00, 7.50000000e+00, 2.78681946e+00,
+       6.32099152e+00, 7.50000000e+00, 2.83950043e+00, 6.09652710e+00,
+       7.50000000e+00, 9.85872650e+00, 2.18066196e+01, 7.50000000e+00,
+       3.20750427e+00, 4.52850533e+00, 7.50000000e+00, 9.48790741e+00,
+       2.34724636e+01, 7.50000000e+00, 8.96614075e-01, 6.72656059e+00,
+       7.50000763e+00, 1.43814392e+01, 6.53067589e+00, 7.50000000e+00,
+       3.81789398e+00, 1.92766571e+00, 7.50000000e+00, 7.62939453e-06,
+       1.88484631e+01, 5.83589935e+00, 0., 2.14463825e+01,
+       6.76745605e+00, 0., 2.02760105e+01, 5.55088806e+00, 0.,
+       2.38221455e+01, 4.84287262e+00, 1.17112732e+00, 1.26859570e+01,
+       7.50000000e+00, 2.05819702e+00, 8.90845299e+00, 7.50000763e+00,
+       1.63493347e+00, 4.10618973e+00, 7.50000000e+00, 9.35928345e-01,
+       7.06031799e+00, 7.50000000e+00, 1.25280838e+01, 1.04439259e+01,
+       7.50000000e+00, 3.80959320e+00, 1.45032120e+00, 7.50000000e+00,
+       0., 2.50165882e+01, 5.97014618e+00, 0., 1.52454853e+01,
+       6.65718842e+00, 8.81347656e-01, 1.34013653e+01, 7.50000000e+00,
+       0., 2.05266247e+01, 5.60486603e+00, 7.62939453e-06,
+       2.11569538e+01, 5.47926331e+00, 1.08360367e+01, 1.80507336e+01,
+       7.50000000e+00, 8.41415405e-01, 1.30540600e+01, 7.50000000e+00,
+       9.30503845e-01, 1.26751499e+01, 7.50000000e+00, 1.16823578e+00,
+       6.57919312e+00, 7.50000000e+00, 3.56768036e+00, 1.45821190e+00,
+       7.50000000e+00, 9.57786560e-01, 7.46911049e+00, 7.50000000e+00,
+       0., 1.99703808e+01, 5.81938934e+00, 7.62939453e-06,
+       2.02388439e+01, 5.76599884e+00, 0., 2.06875057e+01,
+       5.67678070e+00, 1.13935089e+00, 1.12718143e+01, 7.49999237e+00,
+       1.22805023e+00, 1.08947544e+01, 7.49999237e+00, 2.26897430e+00,
+       6.46988869e+00, 7.50000000e+00, 2.32162476e+00, 6.24608994e+00,
+       7.50000000e+00, 1.36814804e+01, 5.88603973e+00, 7.50000000e+00,
+       1.01919174e+01, 2.15851879e+01, 7.50000000e+00, 0.,
+       2.13182278e+01, 5.55135345e+00, 0., 1.93806400e+01,
+       6.75983429e+00, 0., 2.21336269e+01, 5.38919067e+00,
+       1.06379700e+00, 1.10791912e+01, 7.50000000e+00, 1.17016602e+00,
+       1.06273403e+01, 7.49999237e+00, 1.27708359e+01, 1.31655407e+01,
+       7.50000000e+00, 0., 2.49813786e+01, 4.82288361e+00,
+       2.90936279e+00, 3.23852921e+00, 7.49999237e+00, 3.48257446e+00,
+       8.03270340e-01, 7.50000000e+00, 7.62939453e-06, 2.51672230e+01,
+       4.78591919e+00, 1.41776886e+01, 6.81328583e+00, 7.49999237e+00,
+       8.99757385e-01, 1.12634068e+01, 7.50000000e+00, 1.09469604e+00,
+       1.04356976e+01, 7.50000000e+00, 1.51042938e+01, 2.62933922e+00,
+       7.50000000e+00, 1.51574860e+01, 2.38918495e+00, 7.50000000e+00,
+       2.16799164e+00, 2.85121536e+00, 7.50000000e+00, 1.76760101e+00,
+       4.54526901e+00, 7.50000000e+00, 1.53699417e+01, 1.42989731e+00,
+       7.50000000e+00, 1.12021637e+00, 7.28443336e+00, 7.50000000e+00,
+       1.02676849e+01, 2.38190022e+01, 7.50000000e+00, 2.97189331e+00,
+       2.46529388e+00, 7.50000000e+00, 0., 2.04891109e+01,
+       5.81999207e+00, 1.25542755e+01, 1.15902691e+01, 7.50000763e+00,
+       2.78105927e+00, 7.56725311e-01, 7.50000000e+00, 1.28283691e+00,
+       7.09952545e+00, 7.50000763e+00, 8.60023499e-01, 1.09206944e+01,
+       7.50000763e+00, 9.30885315e-01, 1.06200161e+01, 7.50000000e+00,
+       1.23149109e+00, 9.34441948e+00, 7.50000000e+00, 9.91385651e+00,
+       2.34778538e+01, 7.50000000e+00, 2.56472015e+00, 3.68697739e+00,
+       7.50000000e+00, 1.50270767e+01, 1.08448601e+00, 7.50000000e+00,
+       1.19506073e+00, 7.47116280e+00, 7.50000000e+00, 9.13642883e-01,
+       8.66251564e+00, 7.50000000e+00, 1.23847046e+01, 1.42671032e+01,
+       7.50000000e+00, 1.29200974e+01, 1.05772953e+01, 7.50000000e+00,
+       0., 2.14600582e+01, 5.73131561e+00, 1.39920654e+01,
+       7.01474571e+00, 7.50000000e+00, 1.09507065e+01, 1.94501629e+01,
+       7.50000000e+00, 1.06370697e+01, 2.08632565e+01, 7.50000000e+00,
+       1.52730942e+01, 1.23476982e+00, 7.50000000e+00, 8.65020752e-01,
+       9.37404060e+00, 7.50000000e+00, 0., 2.19634113e+01,
+       5.83969116e+00, 0., 2.17116413e+01, 5.78548431e+00,
+       7.62939453e-06, 1.73375530e+01, 6.75228119e+00, 0.,
+       2.35327511e+01, 5.42549133e+00, 1.40393219e+01, 6.16707802e+00,
+       7.50000000e+00, 1.37887726e+01, 7.29672432e+00, 7.50000000e+00,
+       1.15157318e+00, 8.66655922e+00, 7.50000000e+00, 1.25080566e+01,
+       1.30711231e+01, 7.50000000e+00, 4.67006683e+00, 2.34655399e+01,
+       7.50000000e+00, 2.02886200e+00, 4.94819641e+00, 7.50000000e+00,
+       8.72251129e+00, 5.12113762e+00, 7.50000000e+00, 0.,
+       1.52045879e+01, 8.74549866e-01, 1.68912659e+01, 1.43725910e+01,
+       7.50000000e+00, 0., 1.56352482e+01, 8.87977600e-01,
+       6.29151154e+00, 1.34726162e+01, 7.49999237e+00, 7.62939453e-06,
+       1.64094830e+01, 9.34722900e-01, 1.07655334e+00, 8.47801781e+00,
+       7.50000000e+00, 5.82832336e+00, 1.49246235e+01, 7.50000000e+00,
+       5.86447906e+00, 1.47667408e+01, 7.50000000e+00, 4.73562622e+00,
+       2.37643414e+01, 7.50000000e+00, 3.48949432e+00, 2.39878292e+01,
+       7.50000000e+00, 0., 1.79836903e+01, 9.15779114e-01,
+       4.97248840e+00, 1.75182972e+01, 7.50000000e+00, 1.07575150e+01,
+       6.68179703e+00, 7.50000000e+00, 7.44126129e+00, 2.13923550e+01,
+       7.49999237e+00, 0., 1.61508694e+01, 6.78291321e+00, 0.,
+       8.66686821e+00, 3.37896729e+00, 5.71466827e+00, 2.06402416e+01,
+       7.50000000e+00, 0., 1.81682911e+01, 1.42008209e+00, 0.,
+       8.64552498e+00, 3.59289551e+00, 0., 7.68453217e+00,
+       1.58650970e+00, 5.78844452e+00, 1.22612972e+01, 7.50000000e+00,
+       1.84288788e+00, 4.72857285e+00, 7.50000000e+00, 9.04835510e+00,
+       1.48681698e+01, 7.50000000e+00, 1.09538345e+01, 2.07231846e+01,
+       7.50000000e+00, 4.15088654e+00, 1.88243160e+01, 7.50000000e+00,
+       1.72816696e+01, 7.77611732e+00, 7.50000000e+00, 1.79635391e+01,
+       4.64338875e+00, 7.50000000e+00, 9.59104919e+00, 1.30641422e+01,
+       7.50000000e+00, 3.94142914e+00, 1.91698360e+01, 7.50000000e+00,
+       1.69636307e+01, 8.56068611e+00, 7.50000000e+00, 2.48398590e+00,
+       4.53692818e+00, 7.50000000e+00, 8.11806488e+00, 1.00791359e+00,
+       7.50000000e+00, 6.27855682e+00, 2.41162510e+01, 7.50000000e+00,
+       0., 7.02043915e+00, 1.62976074e+00, 1.69342575e+01,
+       8.02110100e+00, 7.50000000e+00, 2.75394440e+00, 2.32003117e+01,
+       7.50000000e+00, 4.15966034e+00, 1.70954113e+01, 7.50000000e+00,
+       4.73817444e+00, 1.45829639e+01, 7.50000000e+00, 5.99224854e+00,
+       9.13664818e+00, 7.50000000e+00, 0., 2.52481823e+01,
+       7.70782471e-01, 2.74676514e+00, 2.26673794e+01, 7.50000000e+00,
+       1.05289459e+01, 1.01079502e+01, 7.49999237e+00, 1.32216568e+01,
+       2.23240681e+01, 7.49999237e+00, 1.67101288e+01, 6.37104988e+00,
+       7.50000000e+00, 1.77676773e+01, 8.74588013e-01, 7.50000000e+00,
+       1.68135071e+01, 4.57336235e+00, 7.50000763e+00, 1.01176758e+01,
+       2.12802410e+01, 7.50000000e+00, 0., 4.58563614e+00,
+       2.57537842e-01, 1.13250122e+01, 8.99983406e+00, 7.50000000e+00,
+       0., 8.15974998e+00, 9.42451477e-01, 0., 7.90490913e+00,
+       1.00051117e+00, 1.08813248e+01, 2.16972179e+01, 7.50000000e+00,
+       4.20410156e+00, 1.41185513e+01, 7.50000000e+00, 1.17675629e+01,
+       1.38629398e+01, 7.50000000e+00, 1.09524536e+00, 1.24910564e+01,
+       7.50000000e+00, 1.69160843e+01, 2.78958702e+00, 7.50000000e+00,
+       9.60489655e+00, 1.72910480e+01, 7.50000000e+00, 1.63709793e+01,
+       4.61851311e+00, 7.50000000e+00, 8.76003265e+00, 2.10622845e+01,
+       7.50000763e+00, 0., 7.87645149e+00, 5.61473846e+00,
+       5.08429718e+00, 2.51875057e+01, 7.50000000e+00, 4.04220581e+00,
+       1.37164936e+01, 7.49999237e+00, 7.84313965e+00, 1.36285954e+01,
+       7.50000000e+00, 0., 7.28043938e+00, 5.94265747e+00,
+       4.06916046e+00, 1.30509434e+01, 7.50000000e+00, 8.01631165e+00,
+       2.50075359e+01, 7.50000000e+00, 0., 8.01141548e+00,
+       5.89193726e+00, 5.48281097e+00, 6.39900017e+00, 7.50000000e+00,
+       -7.62939453e-06, 8.41438103e+00, 5.90982056e+00, 1.29095383e+01,
+       4.37591553e+00, 7.50000000e+00, 0., 1.06002216e+01,
+       5.96389771e-02, 6.59420776e+00, 1.06065941e+00, 7.50000000e+00,
+       6.64650726e+00, 8.34957123e-01, 7.50000000e+00, 2.61488342e+00,
+       1.71395779e+01, 7.50000000e+00, 5.05247498e+00, 6.09455109e+00,
+       7.50000000e+00, 1.53674164e+01, 6.57329941e+00, 7.50000000e+00,
+       0., 1.84227886e+01, 5.81758118e+00, 4.76018524e+00,
+       6.81607819e+00, 7.50000000e+00, 7.62939453e-06, 9.91897011e+00,
+       1.06796265e-01, 5.54065704e+00, 2.92227745e+00, 7.50000763e+00,
+       8.43601990e+00, 2.50170078e+01, 7.50000000e+00, 1.39645233e+01,
+       8.83890152e-01, 7.49999237e+00, 4.14879608e+00, 6.77576065e+00,
+       7.50000000e+00, 4.21031189e+00, 5.98209953e+00, 7.50000000e+00,
+       1.32136612e+01, 1.43936749e+01, 7.50000000e+00, 5.30240631e+00,
+       7.72663116e-01, 7.50000000e+00, 1.73290558e+01, 2.08378582e+01,
+       7.50000000e+00, 0., 1.94179173e+01, 5.51467133e+00,
+       1.34505157e+01, 5.04669762e+00, 7.50000763e+00, 1.76390457e+01,
+       2.01142826e+01, 7.50000000e+00, 1.74025803e+01, 1.40988102e+01,
+       7.50000000e+00, 1.21214600e+01, 1.73896275e+01, 7.50000000e+00,
+       1.15260315e+01, 1.36860752e+01, 7.50000000e+00, 1.33436050e+01,
+       5.52664185e+00, 7.50000000e+00, 2.56045532e+00, 8.84196663e+00,
+       7.50000000e+00, 0., 1.73103008e+01, 5.83403778e+00,
+       1.12551956e+01, 2.13067913e+01, 7.49999237e+00, 1.73600693e+01,
+       2.14165096e+01, 7.50000000e+00, 8.73828125e+00, 5.62491608e+00,
+       7.50000000e+00, 5.26619720e+00, 2.02683620e+01, 7.50000000e+00,
+       1.43898010e+01, 8.30089569e-01, 7.50000000e+00, 8.82070923e+00,
+       2.51937504e+01, 7.50000000e+00, 1.56575241e+01, 2.14744167e+01,
+       7.49999237e+00, 1.02374191e+01, 6.01134300e+00, 7.50000000e+00,
+       9.11852264e+00, 2.38577785e+01, 7.50000000e+00, 0.,
+       2.50078793e+01, 5.13389587e+00, 0., 1.16273632e+01,
+       1.45314026e+00, 1.32396164e+01, 1.29788418e+01, 7.50000000e+00,
+       0., 1.03564320e+01, 1.52178192e+00, 5.27355957e+00,
+       1.96549702e+01, 7.50000000e+00, 0., 1.87410336e+01,
+       5.44286346e+00, 7.62939453e-06, 1.71510906e+01, 5.76284027e+00,
+       0., 1.80326595e+01, 2.68707275e-02, 8.83565521e+00,
+       1.40018368e+01, 7.50000000e+00, 8.80731201e+00, 5.89665604e+00,
+       7.50000000e+00, 1.21022110e+01, 1.04730244e+01, 7.50000763e+00,
+       8.65434265e+00, 1.48050060e+01, 7.50000000e+00, 1.19957733e+00,
+       1.57030048e+01, 7.50000000e+00, 1.05573273e+00, 1.63176975e+01,
+       7.50000763e+00, 1.23183289e+01, 9.50358772e+00, 7.50000000e+00,
+       0., 1.61175022e+01, 5.86797333e+00, 8.41483307e+00,
+       1.22878284e+01, 7.50000000e+00, 3.93827057e+00, 4.51999664e+00,
+       7.50000000e+00, 1.71041031e+01, 1.40841236e+01, 7.50000000e+00,
+       9.18804169e+00, 8.28898430e+00, 7.50000000e+00, 9.43485260e+00,
+       2.18057079e+01, 7.50000000e+00, 1.17923737e+01, 1.12375431e+01,
+       7.50000000e+00, 1.02883911e+00, 1.74916668e+01, 7.50000000e+00,
+       0., 6.46148682e+00, 2.39238739e+00, 0., 1.71838741e+01,
+       5.54949951e+00, 4.79501343e+00, 1.89898491e+00, 7.50000000e+00,
+       9.31293488e+00, 7.73829460e+00, 7.50000000e+00, 1.72320557e+01,
+       1.34926052e+01, 7.50000000e+00, 4.48296356e+00, 2.19559307e+01,
+       7.50000000e+00, 4.18349457e+00, 4.51714516e+00, 7.50000000e+00,
+       9.79171753e-01, 1.82361164e+01, 7.50000000e+00, 6.08706665e+00,
+       1.49397831e+01, 7.50000000e+00, 6.30384064e+00, 1.39916363e+01,
+       7.50000763e+00, 1.48566971e+01, 2.37713108e+01, 7.50000000e+00,
+       1.35231400e+01, 1.29911213e+01, 7.50000000e+00, 4.98160553e+00,
+       2.67387772e+00, 7.50000000e+00, 1.34140244e+01, 1.34856281e+01,
+       7.50000000e+00, 1.95179749e+00, 1.09182377e+01, 7.50000000e+00,
+       6.53815460e+00, 1.29667950e+01, 7.50000000e+00, 1.63453369e+01,
+       8.42449188e-01, 7.50000000e+00, 4.92920685e+00, 2.89863777e+00,
+       7.50000000e+00, 1.05913620e+01, 3.85774994e+00, 7.50000000e+00,
+       6.59215546e+00, 1.27306347e+01, 7.50000000e+00, 3.80479431e+00,
+       7.72147560e+00, 7.50000000e+00, 1.18075409e+01, 1.05461750e+01,
+       7.50000000e+00, 1.71763535e+01, 1.58480129e+01, 7.50000000e+00,
+       1.93852997e+00, 1.62617855e+01, 7.50000000e+00, 1.49025650e+01,
+       7.38585091e+00, 7.50000000e+00, 9.38425446e+00, 7.42393494e+00,
+       7.50000000e+00, 0., 9.69832039e+00, 2.20239258e+00,
+       1.70564117e+01, 2.13876858e+01, 7.50000000e+00, 1.79826889e+01,
+       2.51140499e+01, 7.50000000e+00, 5.19413757e+00, 2.81799889e+00,
+       7.50000000e+00, 1.39647675e+01, 1.16390209e+01, 7.50000000e+00,
+       1.39285202e+01, 1.18034344e+01, 7.50000000e+00, 1.28712463e+01,
+       1.65984325e+01, 7.50000000e+00, 3.94563293e+00, 8.17965889e+00,
+       7.49999237e+00, 3.80397797e+00, 8.78795052e+00, 7.49999237e+00,
+       1.68615875e+01, 1.38163700e+01, 7.50000000e+00, 5.74555206e+00,
+       9.78733063e-01, 7.50000000e+00, 1.72991791e+01, 1.17965603e+01,
+       7.50000000e+00, 1.46539764e+01, 2.33075771e+01, 7.49999237e+00,
+       3.79469299e+00, 9.36164665e+00, 7.50000000e+00, 1.55199432e+00,
+       1.89986210e+01, 7.50000000e+00, 8.80500031e+00, 1.23437099e+01,
+       7.50000000e+00, 1.50850067e+01, 3.98872566e+00, 7.50000000e+00,
+       1.49336014e+01, 2.20178242e+01, 7.50000000e+00, 4.38787842e+00,
+       7.34652710e+00, 7.49999237e+00, 4.24643707e+00, 7.95467949e+00,
+       7.50000000e+00, 1.72689819e+01, 1.12464695e+01, 7.50000000e+00,
+       1.00172424e+00, 1.44484196e+01, 7.50000763e+00, 1.23263092e+01,
+       1.38905773e+01, 7.49999237e+00, 6.32754517e+00, 1.33151150e+01,
+       7.49999237e+00, 8.16218567e+00, 1.34024105e+01, 7.50000763e+00,
+       -7.62939453e-06, 1.26008167e+01, 5.86336517e+00, 6.37819672e+00,
+       2.48878803e+01, 7.50000000e+00, 0., 2.37869282e+01,
+       5.47994232e+00, 1.06095810e+01, 1.52873516e+01, 7.50000000e+00,
+       7.62939453e-06, 1.67691898e+01, 8.55392456e-01, 1.61667862e+01,
+       2.48109417e+01, 7.49999237e+00, 8.64254761e+00, 1.30618763e+01,
+       7.50000000e+00, 1.73234711e+01, 1.09951992e+01, 7.49999237e+00,
+       9.18637848e+00, 8.19095612e-01, 7.50000763e+00, 5.70906067e+00,
+       2.73123550e+00, 7.50000000e+00, 0., 1.24437580e+01,
+       5.79308319e+00, 4.86481476e+00, 2.31973934e+01, 7.50000000e+00,
+       0., 2.50572071e+01, 3.10146332e+00, 7.62939453e-06,
+       9.32400322e+00, 2.60332489e+00, 0., 1.42432079e+01,
+       6.65372467e+00, 4.53041840e+00, 7.80522728e+00, 7.50000000e+00,
+       6.32247925e+00, 2.51346836e+01, 7.50000000e+00, 3.80233002e+00,
+       1.09396305e+01, 7.50000000e+00, 1.55285568e+01, 5.84140968e+00,
+       7.50000000e+00, 0., 1.72033443e+01, 8.68858337e-01, 0.,
+       1.24699955e+01, 5.58254242e+00, 6.24418640e+00, 9.61097717e-01,
+       7.50000000e+00, 1.84962387e+01, 5.58613968e+00, 7.49999237e+00,
+       1.54390640e+01, 6.24786186e+00, 7.50000000e+00, 1.35451431e+01,
+       5.24573708e+00, 7.50000000e+00, 1.67660828e+01, 1.28771038e+01,
+       7.50000000e+00, 0., 2.10316486e+01, 3.71543884e+00,
+       5.98250580e+00, 2.08825684e+00, 7.50000000e+00, 5.22860718e+00,
+       5.33580971e+00, 7.50000000e+00, 5.08772278e+00, 5.94269371e+00,
+       7.50000000e+00, 8.71678162e+00, 1.21392193e+01, 7.50000000e+00,
+       4.52220917e+00, 8.37874031e+00, 7.50000000e+00, 8.25240326e+00,
+       2.52082348e+01, 7.50000000e+00, 0., 6.48937416e+00,
+       6.71222687e+00, 6.20368958e+00, 1.67079544e+00, 7.50000000e+00,
+       1.71002731e+01, 2.04639797e+01, 7.49999237e+00, 5.85399628e+00,
+       3.17808151e+00, 7.50000000e+00, 5.75599670e+00, 1.52405758e+01,
+       7.50000000e+00, 3.96224213e+00, 1.13320904e+01, 7.50000000e+00,
+       3.80149841e+00, 1.20249462e+01, 7.50000000e+00, 5.69261932e+00,
+       2.42975826e+01, 7.50000000e+00, 1.20530396e+01, 1.51226330e+01,
+       7.49999237e+00, 8.40132141e+00, 2.45420971e+01, 7.50000000e+00,
+       1.67016602e+00, 2.12115726e+01, 7.50000763e+00, 1.61802902e+01,
+       3.52942657e+00, 7.50000000e+00, 1.06936340e+01, 2.12517605e+01,
+       7.50000000e+00, 2.83628082e+00, 2.02957344e+00, 7.50000000e+00,
+       4.34559631e+00, 1.02215328e+01, 7.49999237e+00, 3.77421570e+00,
+       1.26858158e+01, 7.50000000e+00, 8.31158447e+00, 1.57220554e+01,
+       7.50000000e+00, 0., 4.74579620e+00, 1.40093231e+00,
+       8.30628967e+00, 1.69500637e+01, 7.49999237e+00, 1.08873901e+01,
+       7.96890259e-01, 7.49999237e+00, 1.14568176e+01, 2.49998226e+01,
+       7.50000000e+00, 0., 6.41455460e+00, 1.01860809e+00,
+       1.24519730e+01, 1.01566753e+01, 7.50000000e+00, 0.,
+       1.73670712e+01, 9.41970825e-01, 0., 1.76384335e+01,
+       8.82354736e-01, 1.53847580e+01, 7.79870796e+00, 7.49999237e+00,
+       6.01711273e+00, 3.55121040e+00, 7.50000000e+00, 1.05087280e+00,
+       1.37177868e+01, 7.50000000e+00, 1.64929352e+01, 2.25731411e+01,
+       7.50000000e+00, 1.72388992e+01, 1.06980839e+01, 7.50000000e+00,
+       9.15298462e+00, 2.49770908e+01, 7.50000000e+00, 8.90978241e+00,
+       1.30739498e+01, 7.50000000e+00, 1.71883240e+01, 1.64966335e+01,
+       7.50000000e+00, 0., 4.42450905e+00, 6.73849487e+00,
+       6.43181610e+00, 2.30083275e+00, 7.50000000e+00, 1.70178833e+01,
+       1.01956367e+00, 7.49999237e+00, 9.68949890e+00, 2.59900665e+00,
+       7.50000763e+00, 1.66632309e+01, 2.63402176e+00, 7.50000000e+00,
+       7.62939453e-06, 6.57283783e+00, 2.04981232e+00, 1.46686859e+01,
+       8.20507050e-01, 7.50000000e+00, 4.36421967e+00, 1.12294941e+01,
+       7.49999237e+00, 1.44708786e+01, 6.12652016e+00, 7.50000000e+00,
+       0., 8.79411125e+00, 2.93092346e+00, 1.72352600e+00,
+       2.26328602e+01, 7.50000000e+00, 0., 5.90589523e+00,
+       2.19974518e+00, 1.13313522e+01, 1.08165646e+01, 7.50000000e+00,
+       6.24897766e+00, 1.25175266e+01, 7.50000000e+00, 1.42468796e+01,
+       2.37914944e+01, 7.50000000e+00, 7.20581818e+00, 2.18282185e+01,
+       7.50000000e+00, 8.14652252e+00, 2.44259052e+01, 7.50000000e+00,
+       6.01950836e+00, 2.16632023e+01, 7.50000000e+00, 8.77654266e+00,
+       2.16116505e+01, 7.50000000e+00, 1.38181152e+01, 4.64432907e+00,
+       7.50000000e+00, 1.35150757e+01, 6.00672913e+00, 7.50000000e+00,
+       8.18911743e+00, 4.04820824e+00, 7.50000000e+00, 1.20674210e+01,
+       8.71202469e-01, 7.49999237e+00, 6.05632019e+00, 2.15010738e+01,
+       7.50000000e+00, 1.24133224e+01, 1.28605022e+01, 7.50000000e+00,
+       4.80877686e+00, 1.82324734e+01, 7.50000000e+00, 1.24503784e+01,
+       2.18121471e+01, 7.50000000e+00, 0., 9.86311531e+00,
+       5.30155945e+00, 9.40747833e+00, 3.83742714e+00, 7.50000000e+00,
+       8.28058624e+00, 1.46620312e+01, 7.50000000e+00, 1.25402679e+01,
+       1.22885838e+01, 7.50000000e+00, 4.22166443e+00, 1.29404621e+01,
+       7.50000763e+00, 1.56084671e+01, 9.86253738e-01, 7.50000000e+00,
+       3.98830414e+00, 1.39495678e+01, 7.49999237e+00, 1.73937225e+00,
+       3.66480255e+00, 7.50000000e+00, 0., 1.77504177e+01,
+       3.54782104e+00, 1.68459091e+01, 1.18229580e+01, 7.50000000e+00,
+       7.62939453e-06, 1.86936245e+01, 8.69544983e-01, 1.69186172e+01,
+       1.14881344e+01, 7.50000000e+00, -7.62939453e-06, 6.48028183e+00,
+       5.90700531e+00, 7.62939453e-06, 6.23552513e+00, 5.95822906e+00,
+       0., 2.38404465e+00, 6.76445770e+00, 1.26362457e+01,
+       9.95766640e+00, 7.50000000e+00, 1.76648941e+01, 2.14454479e+01,
+       7.50000763e+00, 9.28384399e+00, 4.38035202e+00, 7.50000000e+00,
+       1.26401443e+01, 2.16151676e+01, 7.50000000e+00, 0.,
+       5.05271912e+00, 1.65026093e+00, 9.17773438e+00, 4.84625435e+00,
+       7.50000000e+00, 2.41911316e+00, 2.12893429e+01, 7.50000000e+00,
+       7.62939453e-06, 1.92750187e+01, 5.85426331e+00, 0.,
+       8.09993553e+00, 3.29299927e+00, 7.62939453e-06, 1.94530888e+01,
+       5.81877899e+00, 1.13706589e+01, 1.58995628e+00, 7.50000000e+00,
+       7.28646851e+00, 7.74396896e-01, 7.49999237e+00, 9.36785889e+00,
+       1.77299442e+01, 7.49999237e+00, 1.73175201e+01, 9.65116310e+00,
+       7.50000000e+00, 1.16194687e+01, 1.83642979e+01, 7.50000000e+00,
+       4.07809448e+00, 1.46640110e+01, 7.50000000e+00, 7.62939453e-06,
+       9.47782707e+00, 5.07407379e+00, 3.73532104e+00, 1.61479664e+01,
+       7.50000000e+00, 0., 1.48162174e+01, 1.82585907e+00,
+       1.10244598e+01, 5.49766922e+00, 7.50000000e+00, 5.52842712e+00,
+       2.32320271e+01, 7.50000000e+00, 2.62694550e+00, 2.09463367e+01,
+       7.50000000e+00, 1.11454315e+01, 9.80090904e+00, 7.50000000e+00,
+       1.80317993e+01, 2.04583416e+01, 7.50000000e+00, 1.28858185e+01,
+       2.11642742e+01, 7.50000000e+00, 1.31205521e+01, 9.90642548e-01,
+       7.50000000e+00, 0., 6.50753593e+00, 5.59658813e+00, 0.,
+       6.26227951e+00, 5.64822388e+00, 0., 1.91320210e+01,
+       8.83079529e-01, -7.62939453e-06, 2.09193134e+01, 5.83842468e+00,
+       1.56302261e+01, 2.51502094e+01, 7.50000000e+00, 0.,
+       2.08985844e+01, 2.45870209e+00, 0., 2.06238880e+01,
+       2.51665497e+00, 1.72513275e+01, 9.27355385e+00, 7.50000000e+00,
+       1.72874680e+01, 9.10723686e+00, 7.49999237e+00, 9.64257050e+00,
+       1.58881474e+01, 7.50000000e+00, 4.62673187e+00, 1.28411694e+01,
+       7.50000000e+00, 8.83201599e+00, 1.52230892e+01, 7.50000000e+00,
+       0., 1.20909863e+01, 2.52757263e+00, 4.89370728e+00,
+       2.36581936e+01, 7.50000000e+00, 1.65704727e+01, 5.02311516e+00,
+       7.50000000e+00, 0., 1.60562534e+01, 3.37442780e+00,
+       7.62939453e-06, 5.45945168e+00, 1.66407013e+00, 4.44718170e+00,
+       1.36189976e+01, 7.50000000e+00, 4.03298187e+00, 1.54132633e+01,
+       7.49999237e+00, 6.04521942e+00, 1.22717342e+01, 7.50000000e+00,
+       1.04049988e+01, 1.24896641e+01, 7.50000000e+00, 1.22425385e+01,
+       1.55509853e+01, 7.50000000e+00, 0., 1.95713558e+01,
+       8.96667480e-01, 0., 2.06623058e+01, 2.29291534e+00, 0.,
+       1.94767818e+01, 2.54399872e+00, 8.50437927e+00, 1.66764469e+01,
+       7.50000000e+00, 1.38486633e+01, 7.66173363e+00, 7.50000763e+00,
+       1.02340164e+01, 7.81785965e-01, 7.50000000e+00, 1.21967926e+01,
+       4.50277710e+00, 7.50000000e+00, 0., 1.25594234e+01,
+       4.96978760e-02, 1.00788345e+01, 1.33304882e+01, 7.50000000e+00,
+       4.20445251e+00, 1.52256222e+01, 7.50000000e+00, 3.98770905e+00,
+       1.61650715e+01, 7.50000000e+00, 3.89727783e+00, 1.65571079e+01,
+       7.50000000e+00, 1.05027008e+00, 9.60392952e+00, 7.50000000e+00,
+       0., 1.93135738e+01, 2.47109222e+00, 0., 1.86800556e+01,
+       2.60552979e+00, 6.95828247e+00, 3.83792496e+00, 7.50000000e+00,
+       9.39402008e+00, 2.45334835e+01, 7.50000000e+00, 8.03204346e+00,
+       2.18301296e+01, 7.50000000e+00, 8.49256897e+00, 1.97802296e+01,
+       7.50000000e+00, 0., 1.23374691e+01, 2.58022308e+00,
+       1.85260925e+01, 3.40782547e+00, 7.50000000e+00, 1.36536636e+01,
+       2.51347904e+01, 7.50000000e+00, 1.24519958e+01, 2.51649570e+01,
+       7.50000000e+00, 7.38595581e+00, 2.16376553e+01, 7.50000000e+00,
+       1.27546539e+01, 8.08553696e-01, 7.50000000e+00, 7.62939453e-06,
+       2.08844585e+01, 2.02950287e+00, 4.40651703e+00, 1.88462543e+01,
+       7.50000000e+00, 0., 2.01956272e+01, 8.70231628e-01,
+       7.28559875e+00, 1.54954319e+01, 7.50000000e+00, 0.,
+       1.68142262e+01, 2.89490509e+00, 7.62939453e-06, 5.61715508e+00,
+       1.73461151e+00, 5.02417755e+00, 1.61551838e+01, 7.50000000e+00,
+       9.38996887e+00, 1.51742573e+01, 7.50000763e+00, 9.60794067e+00,
+       1.42047215e+01, 7.50000000e+00, 6.66426086e+00, 2.48389835e+01,
+       7.50000763e+00, 0., 6.20097160e+00, 1.60211945e+00,
+       9.66235352e+00, 1.39626713e+01, 7.50000000e+00, 7.62939453e-06,
+       6.61897278e+00, 2.46283722e+00, 6.07454681e+00, 2.50187283e+01,
+       7.50000000e+00, 1.37171783e+01, 5.72543716e+00, 7.50000763e+00,
+       1.14236450e+00, 7.69429398e+00, 7.49999237e+00, 7.62939453e-06,
+       2.07297153e+01, 8.63777161e-01, 1.26246338e+01, 2.50542202e+01,
+       7.50000000e+00, 7.68396759e+00, 1.37414341e+01, 7.50000000e+00,
+       0., 2.01802349e+01, 6.60334015e+00, 7.00225830e+00,
+       2.51784611e+01, 7.50000000e+00, 1.02218018e+01, 9.65930748e+00,
+       7.50000000e+00, 1.68959351e+01, 1.02274227e+01, 7.49999237e+00,
+       7.62939453e-06, 7.97523689e+00, 3.73818970e+00, 1.27975693e+01,
+       2.49433117e+01, 7.50000763e+00, 1.82136459e+01, 8.19440842e-01,
+       7.50000000e+00, 1.79522629e+01, 2.15617924e+01, 7.49999237e+00,
+       1.47617798e+01, 2.27974510e+00, 7.50000000e+00, 1.02848587e+01,
+       2.18075237e+01, 7.50000000e+00, 1.74132080e+01, 4.48550987e+00,
+       7.50000000e+00, 1.05165329e+01, 1.26996231e+00, 7.50000000e+00,
+       1.70045395e+01, 9.72802544e+00, 7.50000000e+00, 0.,
+       1.72209988e+01, 2.48746490e+00, 7.96871185e+00, 1.66394100e+01,
+       7.50000000e+00, 1.72755432e+01, 8.48202705e+00, 7.50000000e+00,
+       0., 9.15787697e+00, 4.21181488e+00, 6.17012787e+00,
+       8.36410713e+00, 7.50000000e+00, 2.42044830e+00, 5.31559563e+00,
+       7.50000000e+00, 8.42752838e+00, 7.70635605e-01, 7.49999237e+00,
+       7.62939453e-06, 2.14239521e+01, 1.47963715e+00, 0.,
+       2.09623737e+01, 1.57854462e+00, 1.00601578e+01, 1.03768444e+01,
+       7.50000000e+00, 4.30459595e+00, 1.64659519e+01, 7.50000000e+00,
+       1.81522827e+01, 2.13580379e+01, 7.50000763e+00, 0.,
+       1.96987743e+01, 1.19687653e+00, 0., 2.11726627e+01,
+       8.77388000e-01, 0., 1.50180645e+01, 2.85224152e+00,
+       4.03266144e+00, 1.76469212e+01, 7.50000000e+00, 3.70539093e+00,
+       1.90682888e+01, 7.50000000e+00, 1.69049835e+01, 7.48316956e+00,
+       7.50000000e+00, 0., 1.07761555e+01, 3.76116180e+00,
+       9.19101715e+00, 1.54492283e+01, 7.50000000e+00, 7.62939453e-06,
+       2.43605862e+01, 1.86340332e-01, 1.93011475e+00, 4.35927391e+00,
+       7.50000000e+00, 1.25806580e+01, 1.27437687e+01, 7.49999237e+00,
+       1.85300369e+01, 2.71408653e+00, 7.50000000e+00, 1.72003479e+01,
+       1.71474209e+01, 7.49999237e+00, 5.24005127e+00, 2.39079113e+01,
+       7.50000000e+00, 7.62939453e-06, 7.26002121e+00, 4.41132355e+00,
+       1.05998535e+01, 9.18682671e+00, 7.50000000e+00, 1.74040070e+01,
+       2.48654842e+01, 7.50000000e+00, 6.63356781e+00, 8.02152443e+00,
+       7.50000763e+00, 2.58836365e+00, 2.39194050e+01, 7.50000000e+00,
+       1.06715546e+01, 8.86808205e+00, 7.50000000e+00, 1.69419556e+01,
+       1.83467045e+01, 7.50000000e+00, 5.30287933e+00, 2.30396366e+01,
+       7.50000000e+00, 1.25392914e+00, 9.75964165e+00, 7.50000000e+00,
+       7.62939453e-06, 1.58026943e+01, 2.14887238e+00, 7.81715393e+00,
+       1.19843349e+01, 7.50000000e+00, 0., 2.15237026e+01,
+       9.11125183e-01, 7.40027618e+00, 2.21838818e+01, 7.50000000e+00,
+       1.11345978e+01, 6.20772552e+00, 7.50000000e+00, 1.37721329e+01,
+       2.32118130e+01, 7.50000000e+00, 1.30774994e+01, 9.23468971e+00,
+       7.49999237e+00, 0., 9.86603737e+00, 3.74740601e+00,
+       7.38439941e+00, 1.38871479e+01, 7.50000000e+00, 0.,
+       7.44538689e+00, 4.16452026e+00, 7.62939453e-06, 8.19513893e+00,
+       4.00292206e+00, 1.69275360e+01, 8.72633934e+00, 7.50000763e+00,
+       1.32431183e+01, 2.49528980e+01, 7.50000000e+00, 1.37588425e+01,
+       6.16718483e+00, 7.50000000e+00, 1.40264816e+01, 4.96225548e+00,
+       7.50000000e+00, 3.98712921e+00, 1.84070721e+01, 7.50000000e+00,
+       3.85972595e+00, 1.89607067e+01, 7.50000000e+00, 0.,
+       1.57712345e+01, 2.37014771e+00, 4.49513245e+00, 1.61994686e+01,
+       7.50000000e+00, 2.36163330e+00, 5.05638504e+00, 7.50000000e+00,
+       8.97409058e+00, 1.58047314e+01, 7.50000000e+00, 4.67594147e+00,
+       1.54137096e+01, 7.50000000e+00, 7.61784363e+00, 2.18291721e+01,
+       7.50000000e+00, 7.62939453e-06, 6.94805336e+00, 4.27169800e+00,
+       -7.62939453e-06, 7.60169029e+00, 4.23446655e+00, 9.96949005e+00,
+       2.51644611e+01, 7.50000000e+00, 1.84216309e+01, 9.38000298e+00,
+       7.50000000e+00, 1.67469101e+01, 9.55554771e+00, 7.50000763e+00,
+       0., 1.00869083e+01, 1.68915558e+00, 1.37099915e+01,
+       2.28112164e+01, 7.50000000e+00, 1.35480881e+01, 2.42404079e+01,
+       7.50000000e+00, 1.38592529e+01, 3.21180916e+00, 7.50000000e+00,
+       1.57330933e+01, 2.39578915e+01, 7.50000000e+00, 1.59271851e+01,
+       8.16928864e-01, 7.50000000e+00, 9.74267578e+00, 1.79204369e+00,
+       7.50000000e+00, 6.07462311e+00, 2.32110081e+01, 7.50000000e+00,
+       8.00254822e+00, 1.35155888e+01, 7.50000000e+00, 4.17037201e+00,
+       2.44864597e+01, 7.50000000e+00, 1.71939240e+01, 1.78861370e+01,
+       7.50000000e+00, 1.54455338e+01, 1.48500576e+01, 7.50000000e+00,
+       1.07133026e+01, 2.18084393e+01, 7.50000000e+00, 8.76429749e+00,
+       8.40137291e+00, 7.50000763e+00, 0., 1.04184322e+01,
+       1.72233582e+00, 1.46339111e+01, 1.99405575e+01, 7.50000000e+00,
+       1.84886551e+01, 8.90876770e-01, 7.50000000e+00, 1.33122559e+01,
+       1.26500835e+01, 7.50000000e+00, 0., 8.88698769e+00,
+       3.64511108e+00, 1.79793243e+01, 2.29050922e+01, 7.50000000e+00,
+       7.62939453e-06, 9.43243599e+00, 3.94493866e+00, 1.24001999e+01,
+       1.67773609e+01, 7.50000000e+00, 9.76687622e+00, 2.09493046e+01,
+       7.50000000e+00, 1.33442459e+01, 2.31216526e+01, 7.50000000e+00,
+       1.34932327e+01, 2.24392605e+01, 7.50000000e+00, 1.05500641e+01,
+       2.51496601e+01, 7.50000000e+00, 7.62939453e-06, 1.10953541e+01,
+       1.67889404e+00, 1.39203033e+01, 2.04832325e+01, 7.50000000e+00,
+       1.22571564e+01, 1.80755444e+01, 7.49999237e+00, 8.88127899e+00,
+       1.68260517e+01, 7.50000000e+00, 7.62939453e-06, 4.72313690e+00,
+       2.78094482e+00, 8.62233734e+00, 1.37478619e+01, 7.50000000e+00,
+       0., 9.48847389e+00, 3.41016388e+00, 1.83384399e+01,
+       2.04855022e+01, 7.50000000e+00, 0., 1.04971867e+01,
+       4.02972412e+00, 1.29658279e+01, 2.41732502e+01, 7.50000000e+00,
+       1.59861603e+01, 2.34966831e+01, 7.50000000e+00, 8.37261963e+00,
+       1.56652069e+00, 7.50000000e+00, 3.86039734e+00, 1.78340092e+01,
+       7.50000763e+00, 4.51195526e+00, 1.50061855e+01, 7.50000000e+00,
+       1.36524277e+01, 2.89940071e+00, 7.50000000e+00, 5.45211792e+00,
+       1.77169361e+01, 7.50000000e+00, 0., 7.81831169e+00,
+       3.66797638e+00, 1.72865143e+01, 1.53374882e+01, 7.50000000e+00,
+       0., 7.00791931e+00, 2.69274139e+00, 5.53103638e+00,
+       2.14471111e+01, 7.50000000e+00, 1.48083725e+01, 1.98256512e+01,
+       7.50000000e+00, 1.55189743e+01, 1.18182354e+01, 7.50000763e+00,
+       1.43220520e+01, 3.00424194e+00, 7.49999237e+00, 1.28890915e+01,
+       1.39184017e+01, 7.50000763e+00, 7.81370544e+00, 2.21857738e+01,
+       7.50000000e+00, 1.45135193e+01, 3.39830589e+00, 7.49999237e+00,
+       0., 2.50850315e+01, 1.13639832e+00, 5.36337280e+00,
+       1.07556553e+01, 7.50000000e+00, 8.65783691e+00, 1.90445881e+01,
+       7.49999237e+00, 8.54768372e+00, 1.95348759e+01, 7.50000000e+00,
+       4.97159576e+00, 2.19066811e+00, 7.50000000e+00, 1.08886108e+01,
+       2.49305973e+01, 7.50000000e+00, 2.95188141e+00, 2.06550503e+01,
+       7.50000000e+00, 4.61422729e+00, 4.24965477e+00, 7.50000000e+00,
+       1.34518127e+01, 1.13738079e+01, 7.50000763e+00, 4.93917847e+00,
+       3.38363838e+00, 7.50000000e+00, 1.09280014e+01, 1.01583767e+01,
+       7.50000000e+00, 5.62071228e+00, 2.28257236e+01, 7.50000000e+00,
+       3.90658569e+00, 1.59607983e+01, 7.50000000e+00, 4.50109100e+00,
+       1.33855114e+01, 7.49999237e+00, 0., 1.90960903e+01,
+       2.73187256e+00, 1.47284393e+01, 5.60111046e+00, 7.50000000e+00,
+       0., 6.50769424e+00, 3.74488068e+00, -7.62939453e-06,
+       3.52331924e+00, 6.12435913e+00, 1.74421768e+01, 1.04582977e+00,
+       7.50000000e+00, 1.82784195e+01, 2.44689846e+01, 7.50000000e+00,
+       1.26630783e+01, 2.21797276e+01, 7.50000000e+00, 1.72799301e+01,
+       1.81977100e+01, 7.50000000e+00, 1.95359802e+00, 3.25815010e+00,
+       7.50000000e+00, 1.88446045e+00, 1.64938450e+01, 7.50000000e+00,
+       6.66409302e+00, 1.24159412e+01, 7.50000000e+00, 1.05230865e+01,
+       5.93225479e+00, 7.49999237e+00, 1.02308502e+01, 2.46342487e+01,
+       7.50000000e+00, 1.00428391e+01, 1.53361835e+01, 7.50000000e+00,
+       3.90711975e+00, 1.48515682e+01, 7.50000000e+00, 1.27143478e+01,
+       2.12771664e+01, 7.49999237e+00, 8.59389496e+00, 2.18039188e+01,
+       7.50000000e+00, 1.81851425e+01, 1.90130291e+01, 7.49999237e+00,
+       8.75410461e+00, 6.13015747e+00, 7.50000000e+00, 0.,
+       1.74829082e+01, 3.60382080e+00, 6.09309387e+00, 1.26296787e+01,
+       7.50000000e+00, 0., 1.01212635e+01, 6.67395020e+00,
+       1.34560013e+01, 1.39464436e+01, 7.50000000e+00, 0.,
+       4.48467827e+00, 2.72937775e+00, 1.52853775e+01, 8.90639687e+00,
+       7.50000000e+00, 3.84742737e+00, 2.41557293e+01, 7.50000000e+00,
+       1.13969574e+01, 3.84529495e+00, 7.50000000e+00, 2.44229126e+00,
+       2.00807285e+01, 7.50000000e+00, 3.54480743e+00, 2.37465229e+01,
+       7.50000000e+00, 1.43996048e+01, 2.51806240e+01, 7.50000000e+00,
+       1.53394318e+01, 8.66031456e+00, 7.50000000e+00, 1.54625015e+01,
+       2.02743778e+01, 7.50000763e+00, 0., 4.74734116e+00,
+       2.46018982e+00, 1.68266602e+01, 1.74685917e+01, 7.50000000e+00,
+       8.94918823e+00, 1.17063274e+01, 7.50000000e+00, 1.17281952e+01,
+       2.17825527e+01, 7.50000000e+00, 1.29226990e+01, 3.70319366e+00,
+       7.50000000e+00, 1.03530273e+01, 1.51897068e+01, 7.50000000e+00,
+       3.97198486e+00, 8.59977150e+00, 7.50000000e+00, 1.64675980e+01,
+       3.52454567e+00, 7.50000763e+00, 6.30930328e+00, 2.82989311e+00,
+       7.50000000e+00, 0., 6.61827850e+00, 3.40805817e+00,
+       1.66859055e+01, 1.39357433e+01, 7.50000763e+00, 1.41484985e+01,
+       7.58325195e+00, 7.50000000e+00, 1.42068787e+01, 1.11917171e+01,
+       7.50000000e+00, 7.62939453e-06, 1.07016544e+01, 2.19359589e+00,
+       1.73476715e+01, 1.01967678e+01, 7.50000000e+00, 9.03020477e+00,
+       2.23572330e+01, 7.50000000e+00, 5.68050385e+00, 2.32061768e+00,
+       7.50000000e+00, 1.28024902e+01, 1.75657940e+01, 7.50000000e+00,
+       1.37231750e+01, 4.44592667e+00, 7.50000000e+00, 1.66312790e+01,
+       8.32767487e-01, 7.50000000e+00, 5.98848724e+00, 1.52826118e+00,
+       7.50000000e+00, 8.36276245e+00, 3.85384750e+00, 7.50000000e+00,
+       1.68025360e+01, 1.27091007e+01, 7.50000000e+00, 0.,
+       2.06150379e+01, 3.58877563e+00, 9.01325226e+00, 2.18048153e+01,
+       7.50000000e+00, 2.14361572e+00, 1.91708813e+01, 7.50000000e+00,
+       4.79756165e+00, 7.73160744e+00, 7.50000000e+00, 5.07747650e+00,
+       5.45019341e+00, 7.50000000e+00, 6.05235291e+00, 1.78739548e+00,
+       7.50000000e+00, 3.64180756e+00, 1.16306896e+01, 7.49999237e+00,
+       1.57786713e+01, 4.70536041e+00, 7.50000000e+00, 1.12355499e+01,
+       3.96509552e+00, 7.50000000e+00, 1.82268906e+01, 6.82843590e+00,
+       7.50000000e+00, 3.98039246e+00, 1.01730671e+01, 7.49999237e+00,
+       1.41411209e+01, 1.21432095e+01, 7.50000000e+00, 1.26198730e+01,
+       1.57832699e+01, 7.50000000e+00, 4.70507812e+00, 2.21446590e+01,
+       7.50000000e+00, 5.74788666e+00, 1.75776119e+01, 7.50000000e+00,
+       1.14980164e+01, 2.08599873e+01, 7.50000000e+00, 7.24526978e+00,
+       6.47824669e+00, 7.50000000e+00, 7.62939453e-06, 6.82023621e+00,
+       3.88474274e+00, 0., 1.06521893e+01, 1.88436890e+00,
+       1.95861816e+00, 6.76756477e+00, 7.50000000e+00, 1.84495316e+01,
+       1.06472111e+01, 7.50000000e+00, 8.22933197e+00, 2.21876850e+01,
+       7.49999237e+00, 7.78621674e+00, 5.24340439e+00, 7.50000763e+00,
+       7.62939453e-06, 6.28689384e+00, 3.48072052e+00, 1.66383514e+01,
+       3.40044975e+00, 7.50000000e+00, 8.75282288e+00, 1.19799976e+01,
+       7.50000000e+00, 1.81213913e+01, 1.49960270e+01, 7.50000000e+00,
+       1.31656876e+01, 2.00584412e+00, 7.50000000e+00, 3.92124176e+00,
+       2.38330669e+01, 7.49999237e+00, 1.81733093e+01, 4.35426903e+00,
+       7.50000000e+00, 4.97991943e+00, 1.29751301e+01, 7.50000000e+00,
+       8.50720978e+00, 1.12906055e+01, 7.50000000e+00, 1.84635620e+01,
+       1.12839718e+01, 7.50000000e+00, 5.57708740e+00, 1.89059200e+01,
+       7.50000000e+00, 1.53157196e+01, 1.81800556e+01, 7.50000000e+00,
+       1.54913940e+01, 1.39625072e+01, 7.50000000e+00, 1.83508759e+01,
+       1.53547993e+01, 7.50000000e+00, 1.83420944e+01, 1.68323841e+01,
+       7.49999237e+00, 1.47946930e+01, 3.39324188e+00, 7.50000763e+00,
+       1.62523727e+01, 2.51348286e+01, 7.50000000e+00, 1.53614731e+01,
+       1.86587276e+01, 7.50000000e+00, 0., 6.79207420e+00,
+       4.20190430e+00, 1.84983063e+01, 2.56844273e+01, 7.50000000e+00,
+       1.78440247e+01, 2.51701946e+01, 7.50000000e+00, 1.79116821e+01,
+       2.48522129e+01, 7.50000000e+00, 1.80693588e+01, 2.41111431e+01,
+       7.50000000e+00, 1.81593552e+01, 2.36882343e+01, 7.50000000e+00,
+       1.79018173e+01, 2.31212292e+01, 7.50000000e+00, 1.71287689e+01,
+       2.49775829e+01, 7.50000000e+00, 1.73089142e+01, 2.41343098e+01,
+       7.50000763e+00, 1.74438019e+01, 2.35029202e+01, 7.50000000e+00,
+       1.78249283e+01, 2.17188168e+01, 7.49999237e+00, 1.79814072e+01,
+       2.09862652e+01, 7.50000000e+00, 1.81822357e+01, 2.00462055e+01,
+       7.50000000e+00, 1.72041779e+01, 2.37457829e+01, 7.50000000e+00,
+       1.82101364e+01, 1.90414524e+01, 7.50000000e+00, 1.70773239e+01,
+       2.34633656e+01, 7.50000000e+00, 1.67036743e+01, 2.43352757e+01,
+       7.50000000e+00, 1.67125092e+01, 2.34239902e+01, 7.50000763e+00,
+       1.70038910e+01, 2.20653820e+01, 7.50000000e+00, 1.62272720e+01,
+       2.48180218e+01, 7.49999237e+00, 1.68779755e+01, 2.17868443e+01,
+       7.50000763e+00, 1.71459503e+01, 2.05386181e+01, 7.50000000e+00,
+       1.73686752e+01, 1.95011082e+01, 7.50000000e+00, 1.65287323e+01,
+       2.25501881e+01, 7.50000000e+00, 1.66630096e+01, 2.19252491e+01,
+       7.50000000e+00, 1.70201950e+01, 2.02630596e+01, 7.50000000e+00,
+       1.57749939e+01, 2.51943722e+01, 7.50000000e+00, 1.70282898e+01,
+       1.93676472e+01, 7.50000000e+00, 1.72725372e+01, 1.82320766e+01,
+       7.50000000e+00, 1.66005936e+01, 1.96474323e+01, 7.50000763e+00,
+       1.68892899e+01, 1.83078480e+01, 7.50000000e+00, 1.71107635e+01,
+       1.72801571e+01, 7.50000000e+00, 1.71992188e+01, 1.68697529e+01,
+       7.50000000e+00, 1.81010513e+01, 1.26850338e+01, 7.50000000e+00,
+       1.54035492e+01, 2.43476086e+01, 7.50000000e+00, 1.54484863e+01,
+       2.41392803e+01, 7.50000000e+00, 1.62315292e+01, 2.05093517e+01,
+       7.50000000e+00, 1.67869263e+01, 1.79346676e+01, 7.50000000e+00,
+       1.68976212e+01, 1.74215260e+01, 7.50000000e+00, 1.70744553e+01,
+       1.66017437e+01, 7.50000763e+00, 1.72289276e+01, 1.58856907e+01,
+       7.50000000e+00, 1.72730103e+01, 1.56813145e+01, 7.50000000e+00,
+       1.82159576e+01, 1.13101444e+01, 7.49999237e+00, 1.51680832e+01,
+       2.45872936e+01, 7.50000000e+00, 1.54150925e+01, 2.34433651e+01,
+       7.50000763e+00, 1.71704712e+01, 1.53136768e+01, 7.50000000e+00,
+       1.84389038e+01, 9.43927193e+00, 7.50000000e+00, 1.51127930e+01,
+       2.39948177e+01, 7.50000000e+00, 1.52922211e+01, 2.31646061e+01,
+       7.50000000e+00, 1.53818207e+01, 2.27500858e+01, 7.50000000e+00,
+       1.55160446e+01, 2.21290340e+01, 7.50000000e+00, 1.55830841e+01,
+       2.18188229e+01, 7.50000000e+00, 1.56500931e+01, 2.15088444e+01,
+       7.50000000e+00, 1.58507919e+01, 2.05801907e+01, 7.50000000e+00,
+       1.47208481e+01, 2.49614658e+01, 7.50000000e+00, 1.47883072e+01,
+       2.46496220e+01, 7.50000000e+00, 1.50576935e+01, 2.34044361e+01,
+       7.50000000e+00, 1.52592316e+01, 2.24728374e+01, 7.50000000e+00,
+       1.72077484e+01, 1.34659214e+01, 7.50000000e+00, 1.72515640e+01,
+       1.32633419e+01, 7.50000000e+00, 1.68428040e+01, 1.43188496e+01,
+       7.50000000e+00, 1.83509598e+01, 6.53006744e+00, 7.50000000e+00,
+       1.42891006e+01, 2.44319592e+01, 7.50000000e+00, 1.44461670e+01,
+       2.37079372e+01, 7.50000000e+00, 1.67719574e+01, 1.29875927e+01,
+       7.50000000e+00, 1.72521667e+01, 1.07741680e+01, 7.50000000e+00,
+       1.73827057e+01, 1.01724415e+01, 7.50000000e+00, 1.40336304e+01,
+       2.47734814e+01, 7.50000000e+00, 1.43925095e+01, 2.31208630e+01,
+       7.50000000e+00, 1.49728394e+01, 2.04484272e+01, 7.50000000e+00,
+       1.51729050e+01, 1.95271053e+01, 7.50000000e+00, 1.68459091e+01,
+       1.18229580e+01, 7.50000000e+00, 1.73247528e+01, 9.61783028e+00,
+       7.50000763e+00, 1.81892548e+01, 5.63684654e+00, 7.50000000e+00,
+       1.37560501e+01, 2.52179661e+01, 7.50000763e+00, 1.40031281e+01,
+       2.40812473e+01, 7.50000000e+00, 1.51626053e+01, 1.87467785e+01,
+       7.50000763e+00, 1.52955093e+01, 1.81353931e+01, 7.50000000e+00,
+       1.68977280e+01, 1.07640896e+01, 7.50000000e+00, 1.70282364e+01,
+       1.01637096e+01, 7.49999237e+00, 1.72670059e+01, 9.06514168e+00,
+       7.50000000e+00, 1.73753586e+01, 8.56670952e+00, 7.49999237e+00,
+       1.81732407e+01, 4.89591599e+00, 7.50000000e+00, 1.36587067e+01,
+       2.48350086e+01, 7.50000000e+00, 1.53291855e+01, 1.71568851e+01,
+       7.50000000e+00, 1.81143951e+01, 4.35495186e+00, 7.50000000e+00,
+       1.81787033e+01, 4.05936813e+00, 7.50000763e+00, 1.83071823e+01,
+       3.46880531e+00, 7.50000000e+00, 1.37410507e+01, 2.36294689e+01,
+       7.50000000e+00, 1.52965927e+01, 1.64862537e+01, 7.50000000e+00,
+       1.68923416e+01, 9.15841103e+00, 7.50000000e+00, 1.69356766e+01,
+       8.95936012e+00, 7.50000763e+00, 1.71953430e+01, 7.76699257e+00,
+       7.50000000e+00, 1.74758377e+01, 6.47892761e+00, 7.50000000e+00,
+       1.77555084e+01, 5.19466782e+00, 7.50000000e+00, 1.83764114e+01,
+       2.34339905e+00, 7.49999237e+00, 1.87810059e+01, 4.85448837e-01,
+       7.50000000e+00, 1.32629089e+01, 2.49993458e+01, 7.50000000e+00,
+       1.37335892e+01, 2.28399563e+01, 7.50000000e+00, 1.43131714e+01,
+       2.01809177e+01, 7.50000000e+00, 1.52641296e+01, 1.58181248e+01,
+       7.50000000e+00, 1.53960648e+01, 1.52127743e+01, 7.50000763e+00,
+       1.68355637e+01, 8.60862541e+00, 7.50000000e+00, 1.69653473e+01,
+       8.01316261e+00, 7.50000000e+00, 1.73967056e+01, 6.03415871e+00,
+       7.50000000e+00, 1.80828171e+01, 2.88637543e+00, 7.50000763e+00,
+       1.54731369e+01, 1.40462017e+01, 7.50000000e+00, 1.68870010e+01,
+       7.56562996e+00, 7.50000000e+00, 1.73178329e+01, 5.59081650e+00,
+       7.50000000e+00, 1.33170395e+01, 2.31099644e+01, 7.50000000e+00,
+       1.52653275e+01, 1.41880741e+01, 7.50000000e+00, 1.77316971e+01,
+       2.89367676e+00, 7.50000000e+00, 1.78170700e+01, 2.50265503e+00,
+       7.50000000e+00, 1.80727692e+01, 1.33171463e+00, 7.50000000e+00,
+       1.81578522e+01, 9.42100525e-01, 7.50000000e+00, 1.29078369e+01,
+       2.41665554e+01, 7.50000000e+00, 1.29526672e+01, 2.39615116e+01,
+       7.50000000e+00, 1.53861465e+01, 1.28279362e+01, 7.50000000e+00,
+       1.67956238e+01, 6.37933350e+00, 7.50000000e+00, 1.72251511e+01,
+       4.41419792e+00, 7.50000000e+00, 1.35708618e+01, 2.03219242e+01,
+       7.50000000e+00, 1.69755936e+01, 4.75905991e+00, 7.50000000e+00,
+       1.71041336e+01, 4.17142296e+00, 7.50000000e+00, 1.71897430e+01,
+       3.78010750e+00, 7.50000000e+00, 1.74674454e+01, 2.51076698e+00,
+       7.50000000e+00, 1.76379318e+01, 1.73148155e+00, 7.50000763e+00,
+       1.78293686e+01, 8.56458664e-01, 7.50000000e+00, 1.24038696e+01,
+       2.48433132e+01, 7.50000000e+00, 1.30078735e+01, 2.20849628e+01,
+       7.50000000e+00, 1.53650818e+01, 1.13201008e+01, 7.50000763e+00,
+       1.54738312e+01, 1.08234692e+01, 7.50000000e+00, 1.68549957e+01,
+       4.51598167e+00, 7.50000000e+00, 1.72612076e+01, 2.66092682e+00,
+       7.50000000e+00, 1.74104233e+01, 1.97948074e+00, 7.50000000e+00,
+       1.76019287e+01, 1.10491180e+00, 7.50000000e+00, 1.30686722e+01,
+       2.10004635e+01, 7.50000000e+00, 1.31798325e+01, 2.04933414e+01,
+       7.50000000e+00, 1.43721542e+01, 1.50531750e+01, 7.50000000e+00,
+       1.64774933e+01, 5.44734383e+00, 7.50000000e+00, 1.65633240e+01,
+       5.05573273e+00, 7.50000000e+00, 1.25506897e+01, 2.25581036e+01,
+       7.50000000e+00, 1.25953140e+01, 2.23546886e+01, 7.50000000e+00,
+       1.28626099e+01, 2.11361561e+01, 7.50000763e+00, 1.67644653e+01,
+       3.34971237e+00, 7.50000000e+00, 1.72119675e+01, 1.30979729e+00,
+       7.50000000e+00, 1.25679169e+01, 2.16770878e+01, 7.50000000e+00,
+       1.53554459e+01, 8.98175240e+00, 7.50000000e+00, 1.63454742e+01,
+       4.47280121e+00, 7.50000000e+00, 1.64524689e+01, 3.98550606e+00,
+       7.49999237e+00, 1.70919189e+01, 1.07317543e+00, 7.50000000e+00,
+       1.25850830e+01, 2.07997341e+01, 7.50000000e+00, 1.59477692e+01,
+       5.49870110e+00, 7.50000000e+00, 1.60335541e+01, 5.10832405e+00,
+       7.50000000e+00, 1.62263107e+01, 4.23125267e+00, 7.50000000e+00,
+       1.68235092e+01, 1.51388359e+00, 7.50000000e+00, 1.14871979e+01,
+       2.49947948e+01, 7.50000763e+00, 1.15544662e+01, 2.46890316e+01,
+       7.50000763e+00, 1.20685806e+01, 2.23517933e+01, 7.50000000e+00,
+       1.57218781e+01, 5.74339294e+00, 7.49999237e+00, 1.61716080e+01,
+       3.69888115e+00, 7.50000000e+00, 1.14394836e+01, 2.44142017e+01,
+       7.50000000e+00, 1.22867584e+01, 2.05658436e+01, 7.50000000e+00,
+       1.41338577e+01, 1.21761837e+01, 7.50000000e+00, 1.53674164e+01,
+       6.57329559e+00, 7.50000000e+00, 1.57750931e+01, 4.72156525e+00,
+       7.50000000e+00, 1.66277390e+01, 8.48829269e-01, 7.50000000e+00,
+       1.18603668e+01, 2.17098446e+01, 7.50000000e+00, 1.22379456e+01,
+       1.99964199e+01, 7.50000000e+00, 1.27685013e+01, 1.75887280e+01,
+       7.50000000e+00, 1.41693039e+01, 1.12318974e+01, 7.50000000e+00,
+       1.46677933e+01, 8.96975899e+00, 7.50000000e+00, 1.47542191e+01,
+       8.57753563e+00, 7.50000000e+00, 1.47974167e+01, 8.38155937e+00,
+       7.50000000e+00, 1.49052887e+01, 7.89199257e+00, 7.50000000e+00,
+       1.59987793e+01, 2.92968178e+00, 7.50000763e+00, 1.63605194e+01,
+       1.28811646e+00, 7.50000000e+00, 1.09642410e+01, 2.49832897e+01,
+       7.50000000e+00, 1.10314560e+01, 2.46785221e+01, 7.50000000e+00,
+       1.20120621e+01, 2.02325382e+01, 7.50000000e+00, 1.28070984e+01,
+       1.66278820e+01, 7.50000000e+00, 1.32897644e+01, 1.44394741e+01,
+       7.50000000e+00, 1.33991241e+01, 1.39436245e+01, 7.50000000e+00,
+       1.34865341e+01, 1.35473537e+01, 7.50000000e+00, 1.35956650e+01,
+       1.30525074e+01, 7.50000000e+00, 1.38571014e+01, 1.18671703e+01,
+       7.50000000e+00, 1.50248795e+01, 6.57254410e+00, 7.50000000e+00,
+       1.55821075e+01, 4.04605293e+00, 7.50000000e+00, 1.61573715e+01,
+       1.43787575e+00, 7.50000000e+00, 1.62847290e+01, 8.60410690e-01,
+       7.50000000e+00, 1.13641663e+01, 2.23816051e+01, 7.50000000e+00,
+       1.24056854e+01, 1.76636448e+01, 7.50000000e+00, 1.27137756e+01,
+       1.62679920e+01, 7.50000000e+00, 1.54647064e+01, 3.80651474e+00,
+       7.50000000e+00, 1.55287399e+01, 3.51641083e+00, 7.50000000e+00,
+       1.55927353e+01, 3.22650909e+00, 7.50000000e+00, 1.57206039e+01,
+       2.64727783e+00, 7.50000000e+00, 1.58908234e+01, 1.87617302e+00,
+       7.50000000e+00, 1.59545822e+01, 1.58736229e+00, 7.50000000e+00,
+       1.13170090e+01, 2.18097324e+01, 7.50000000e+00, 1.15170059e+01,
+       2.09045315e+01, 7.50000000e+00, 1.17165985e+01, 2.00011806e+01,
+       7.50000000e+00, 1.24669647e+01, 1.66051235e+01, 7.50000000e+00,
+       1.26426773e+01, 1.58098354e+01, 7.50000000e+00, 1.29275513e+01,
+       1.45205708e+01, 7.49999237e+00, 1.31897583e+01, 1.33338223e+01,
+       7.50000000e+00, 1.33423767e+01, 1.26430302e+01, 7.50000000e+00,
+       1.42962875e+01, 8.32572746e+00, 7.50000000e+00, 1.55181503e+01,
+       2.79570770e+00, 7.50000000e+00, 1.59432144e+01, 8.71940613e-01,
+       7.50000000e+00, 1.19561615e+01, 1.81370296e+01, 7.50000000e+00,
+       1.21104507e+01, 1.74394093e+01, 7.50000000e+00, 1.25498962e+01,
+       1.54522762e+01, 7.50000763e+00, 1.26156311e+01, 1.51549778e+01,
+       7.50000000e+00, 1.27032318e+01, 1.47588978e+01, 7.50000000e+00,
+       1.33359222e+01, 1.18979397e+01, 7.50000000e+00, 1.34445801e+01,
+       1.14065495e+01, 7.50000000e+00, 1.51028061e+01, 3.90825844e+00,
+       7.50000000e+00, 1.79752426e+01, 0., 6.04354858e+00,
+       1.08453827e+01, 2.23786449e+01, 7.50000000e+00, 1.13782883e+01,
+       1.99709911e+01, 7.50000000e+00, 1.28071594e+01, 1.35154972e+01,
+       7.50000000e+00, 1.38273926e+01, 8.90612984e+00, 7.50000763e+00,
+       1.43442459e+01, 6.57105064e+00, 7.50000000e+00, 1.45802078e+01,
+       5.50497818e+00, 7.50000000e+00, 1.55607376e+01, 1.07500648e+00,
+       7.50000000e+00, 1.00404510e+01, 2.52338810e+01, 7.50000000e+00,
+       1.04875107e+01, 2.32158146e+01, 7.50000000e+00, 1.08214874e+01,
+       2.17082806e+01, 7.50000000e+00, 1.11543350e+01, 2.02058582e+01,
+       7.50000000e+00, 1.15522461e+01, 1.84096622e+01, 7.50000000e+00,
+       1.29323196e+01, 1.21800861e+01, 7.50000000e+00, 1.39923096e+01,
+       7.39536476e+00, 7.50000000e+00, 1.40568314e+01, 7.10412216e+00,
+       7.49999237e+00, 1.41212997e+01, 6.81306839e+00, 7.50000000e+00,
+       1.11078415e+01, 1.96415615e+01, 7.50000000e+00, 1.25568924e+01,
+       1.31063519e+01, 7.50000000e+00, 1.35110779e+01, 8.80301476e+00,
+       7.50000000e+00, 1.51797562e+01, 1.27729416e+00, 7.50000000e+00,
+       9.74968719e+00, 2.49903393e+01, 7.50000763e+00, 1.01740723e+01,
+       2.30781384e+01, 7.50000000e+00, 1.06631546e+01, 2.08742504e+01,
+       7.50000000e+00, 1.08625336e+01, 1.99758129e+01, 7.50000000e+00,
+       1.10836029e+01, 1.89796925e+01, 7.50000000e+00, 1.16340790e+01,
+       1.64991856e+01, 7.50000000e+00, 1.17218781e+01, 1.61036015e+01,
+       7.50000000e+00, 1.21596451e+01, 1.41309834e+01, 7.50000000e+00,
+       1.22905960e+01, 1.35409222e+01, 7.50000000e+00, 1.29427032e+01,
+       1.06024799e+01, 7.50000000e+00, 1.34612503e+01, 8.26586342e+00,
+       7.50000000e+00, 1.45327072e+01, 3.43780899e+00, 7.50000000e+00,
+       1.50640030e+01, 1.04377747e+00, 7.50000000e+00, 9.86180115e+00,
+       2.37122021e+01, 7.50000000e+00, 9.90642548e+00, 2.35113239e+01,
+       7.50000000e+00, 1.15212784e+01, 1.62410069e+01, 7.50000000e+00,
+       1.16090012e+01, 1.58460789e+01, 7.50000000e+00, 1.18279572e+01,
+       1.48603001e+01, 7.50000000e+00, 1.18716888e+01, 1.46634083e+01,
+       7.50000000e+00, 1.22643967e+01, 1.28953571e+01, 7.50000763e+00,
+       1.25470428e+01, 1.16228542e+01, 7.50000000e+00, 1.30667114e+01,
+       9.28329659e+00, 7.49999237e+00, 1.34331131e+01, 7.63366127e+00,
+       7.50000000e+00, 1.35621033e+01, 7.05292130e+00, 7.50000000e+00,
+       1.37981415e+01, 5.99025154e+00, 7.50000000e+00, 1.01067276e+01,
+       2.18404675e+01, 7.50000000e+00, 1.01733475e+01, 2.15407772e+01,
+       7.50000000e+00, 1.23034973e+01, 1.19588909e+01, 7.50000000e+00,
+       1.24337463e+01, 1.13730068e+01, 7.50000000e+00, 1.25204773e+01,
+       1.09828510e+01, 7.50000000e+00, 1.27369766e+01, 1.00089817e+01,
+       7.50000000e+00, 1.38977966e+01, 4.78735542e+00, 7.50000000e+00,
+       9.23795319e+00, 2.49789715e+01, 7.50000000e+00, 9.32738495e+00,
+       2.45770245e+01, 7.50000000e+00, 1.03722153e+01, 1.98812122e+01,
+       7.50000000e+00, 1.04827118e+01, 1.93845730e+01, 7.50000763e+00,
+       1.05489655e+01, 1.90868664e+01, 7.49999237e+00, 1.11870041e+01,
+       1.62192974e+01, 7.50000000e+00, 1.18209076e+01, 1.33702984e+01,
+       7.50000000e+00, 1.31839676e+01, 7.24422836e+00, 7.50000000e+00,
+       1.32269287e+01, 7.05115128e+00, 7.50000000e+00, 1.44645386e+01,
+       1.48892593e+00, 7.50000000e+00, 1.06799774e+01, 1.77371387e+01,
+       7.50000000e+00, 1.12503433e+01, 1.51759357e+01, 7.50000000e+00,
+       1.16214905e+01, 1.35093327e+01, 7.50000000e+00, 1.29417191e+01,
+       7.58086586e+00, 7.49999237e+00, 1.32207794e+01, 6.32777023e+00,
+       7.49999237e+00, 1.39042740e+01, 3.25852013e+00, 7.50000000e+00,
+       1.39893799e+01, 2.87638474e+00, 7.50000000e+00, 8.97311401e+00,
+       2.46371708e+01, 7.50000000e+00, 9.15170288e+00, 2.38359776e+01,
+       7.49999237e+00, 9.44119263e+00, 2.25370922e+01, 7.50000000e+00,
+       1.00618591e+01, 1.97523899e+01, 7.50000000e+00, 1.03046417e+01,
+       1.86631870e+01, 7.50000000e+00, 1.06786499e+01, 1.69851360e+01,
+       7.50000000e+00, 1.07445068e+01, 1.66896763e+01, 7.50000000e+00,
+       1.15966110e+01, 1.28666134e+01, 7.49999237e+00, 1.16835861e+01,
+       1.24763775e+01, 7.50000000e+00, 1.18573151e+01, 1.16969547e+01,
+       7.50000000e+00, 1.20307236e+01, 1.09189167e+01, 7.50000000e+00,
+       1.25275726e+01, 8.68974495e+00, 7.50000000e+00, 1.27213058e+01,
+       7.82055092e+00, 7.50000000e+00, 1.33001862e+01, 5.22332954e+00,
+       7.50000000e+00, 1.36628952e+01, 3.59596825e+00, 7.50000763e+00,
+       1.42150269e+01, 1.11882591e+00, 7.50000000e+00, 9.15331268e+00,
+       2.30677929e+01, 7.50000000e+00, 9.46444702e+00, 2.16730709e+01,
+       7.50000000e+00, 9.53099060e+00, 2.13747692e+01, 7.50000000e+00,
+       9.70822144e+00, 2.05802937e+01, 7.50000000e+00, 1.02820282e+01,
+       1.80080471e+01, 7.50000000e+00, 1.04359360e+01, 1.73180752e+01,
+       7.50000000e+00, 1.12237320e+01, 1.37866497e+01, 7.50000000e+00,
+       1.13108749e+01, 1.33960171e+01, 7.49999237e+00, 1.23289948e+01,
+       8.83197975e+00, 7.50000000e+00, 1.36559601e+01, 2.88351631e+00,
+       7.50000000e+00, 1.37621918e+01, 2.40733337e+00, 7.50000000e+00,
+       9.68666840e+00, 1.99209614e+01, 7.50000763e+00, 9.88534546e+00,
+       1.90311565e+01, 7.50000000e+00, 1.05008621e+01, 1.62742863e+01,
+       7.50000000e+00, 1.12213821e+01, 1.30471554e+01, 7.50000000e+00,
+       1.19582214e+01, 9.74688911e+00, 7.49999237e+00, 1.22384872e+01,
+       8.49158287e+00, 7.50000000e+00, 1.24750061e+01, 7.43221283e+00,
+       7.50000000e+00, 1.27537918e+01, 6.18354797e+00, 7.50000000e+00,
+       1.29249573e+01, 5.41691399e+00, 7.50000000e+00, 1.32237778e+01,
+       4.07855797e+00, 7.50000000e+00, 1.39456406e+01, 8.45354080e-01,
+       7.50000000e+00, 8.55606079e+00, 2.42275105e+01, 7.50000000e+00,
+       9.08999634e+00, 2.18380871e+01, 7.50000000e+00, 9.64313507e+00,
+       1.93627453e+01, 7.50000000e+00, 1.02589874e+01, 1.66067410e+01,
+       7.50000000e+00, 1.10016632e+01, 1.32832088e+01, 7.50000000e+00,
+       1.11755905e+01, 1.25048466e+01, 7.50000000e+00, 1.13925705e+01,
+       1.15338306e+01, 7.50000000e+00, 1.16739273e+01, 1.02747288e+01,
+       7.50000000e+00, 1.23630676e+01, 7.19078064e+00, 7.50000000e+00,
+       1.24059753e+01, 6.99875069e+00, 7.50000000e+00, 1.26630249e+01,
+       5.84837914e+00, 7.50000000e+00, 1.28767319e+01, 4.89206123e+00,
+       7.50000000e+00, 8.80343628e+00, 2.23670063e+01, 7.50000000e+00,
+       9.04743195e+00, 2.12759991e+01, 7.50000000e+00, 9.26873016e+00,
+       2.02865086e+01, 7.50000000e+00, 1.02146912e+01, 1.60568066e+01,
+       7.50000000e+00, 1.10865784e+01, 1.21583805e+01, 7.50000000e+00,
+       1.13682785e+01, 1.08988209e+01, 7.50000000e+00, 1.23585739e+01,
+       6.47085953e+00, 7.50000000e+00, 1.24656143e+01, 5.99226189e+00,
+       7.50000000e+00, 1.35718765e+01, 1.04586983e+00, 7.50000000e+00,
+       9.42443085e+00, 1.88420467e+01, 7.50000000e+00, 9.95169830e+00,
+       1.64864979e+01, 7.50000000e+00, 1.04325485e+01, 1.43382626e+01,
+       7.49999237e+00, 1.06068268e+01, 1.35596828e+01, 7.50000000e+00,
+       1.06938477e+01, 1.31709118e+01, 7.50000000e+00, 1.07373199e+01,
+       1.29766521e+01, 7.50000000e+00, 1.08459396e+01, 1.24913883e+01,
+       7.50000000e+00, 1.17966537e+01, 8.24411583e+00, 7.49999237e+00,
+       1.25249863e+01, 4.99023056e+00, 7.50000000e+00, 1.26529617e+01,
+       4.41853905e+00, 7.49999237e+00, 1.31843414e+01, 2.04454994e+00,
+       7.50000000e+00, 1.32267380e+01, 1.85519409e+00, 7.50000000e+00,
+       8.00831604e+00, 2.44177418e+01, 7.50000000e+00, 8.76371765e+00,
+       2.10458164e+01, 7.50000000e+00, 8.94062805e+00, 2.02561436e+01,
+       7.50000000e+00, 9.20540619e+00, 1.90742702e+01, 7.50000000e+00,
+       9.33753204e+00, 1.84845181e+01, 7.50000000e+00, 9.60124207e+00,
+       1.73073711e+01, 7.50000000e+00, 1.00391922e+01, 1.53524303e+01,
+       7.50000763e+00, 1.08876495e+01, 1.15651493e+01, 7.50000000e+00,
+       1.19862061e+01, 6.66152191e+00, 7.50000000e+00, 1.21574020e+01,
+       5.89730453e+00, 7.50000000e+00, 1.24136429e+01, 4.75349617e+00,
+       7.50000000e+00, 1.24562912e+01, 4.56315613e+00, 7.50000000e+00,
+       1.31360397e+01, 1.52898979e+00, 7.49999237e+00, 1.32417984e+01,
+       1.05681229e+00, 7.50000763e+00, 7.78929901e+00, 2.46467075e+01,
+       7.50000000e+00, 8.45632172e+00, 2.16717663e+01, 7.50000000e+00,
+       9.25088501e+00, 1.81280384e+01, 7.50000000e+00, 9.29483795e+00,
+       1.79319973e+01, 7.50000000e+00, 9.33877563e+00, 1.77360401e+01,
+       7.50000000e+00, 1.11235046e+01, 9.77622414e+00, 7.50000000e+00,
+       1.13604584e+01, 8.71936607e+00, 7.50000000e+00, 1.19610596e+01,
+       6.04068947e+00, 7.50000000e+00, 1.20892792e+01, 5.46883202e+00,
+       7.50000000e+00, 7.59291840e+00, 2.47758617e+01, 7.50000000e+00,
+       8.52558899e+00, 2.06197071e+01, 7.50000000e+00, 9.47145844e+00,
+       1.64046917e+01, 7.50000000e+00, 9.53710938e+00, 1.61121159e+01,
+       7.50000000e+00, 9.82110596e+00, 1.48465519e+01, 7.50000000e+00,
+       1.07114716e+01, 1.08788967e+01, 7.50000000e+00, 1.08626785e+01,
+       1.02050724e+01, 7.49999237e+00, 1.10567474e+01, 9.34024620e+00,
+       7.50000000e+00, 1.13578720e+01, 7.99836159e+00, 7.50000000e+00,
+       1.15938263e+01, 6.94691849e+00, 7.49999237e+00, 1.29131470e+01,
+       1.06771278e+00, 7.50000000e+00, 8.55043793e+00, 1.97687168e+01,
+       7.50000763e+00, 8.59454346e+00, 1.95723667e+01, 7.50000000e+00,
+       8.70469666e+00, 1.90818577e+01, 7.50000000e+00, 8.92466736e+00,
+       1.81024761e+01, 7.50000000e+00, 9.23179626e+00, 1.67349911e+01,
+       7.50000000e+00, 1.03209457e+01, 1.18855419e+01, 7.50000000e+00,
+       1.04508286e+01, 1.13071918e+01, 7.50000000e+00, 1.10332336e+01,
+       8.71406746e+00, 7.50000000e+00, 1.15694275e+01, 6.32669640e+00,
+       7.49999237e+00, 1.20388412e+01, 4.23658752e+00, 7.50000000e+00,
+       7.20126343e+00, 2.50334721e+01, 7.50000000e+00, 7.55764771e+00,
+       2.34480152e+01, 7.50000000e+00, 7.89060974e+00, 2.19667759e+01,
+       7.49999237e+00, 9.40798187e+00, 1.52163029e+01, 7.50000000e+00,
+       9.62596893e+00, 1.42465038e+01, 7.50000000e+00, 1.02121506e+01,
+       1.16387081e+01, 7.50000000e+00, 1.10098038e+01, 8.09011269e+00,
+       7.50000000e+00, 1.15023956e+01, 5.89869881e+00, 7.50000000e+00,
+       1.25435944e+01, 1.26658440e+00, 7.50000000e+00, 1.25858612e+01,
+       1.07856750e+00, 7.50000000e+00, 1.26281052e+01, 8.90632629e-01,
+       7.50000000e+00, 7.00597382e+00, 2.51619244e+01, 7.50000000e+00,
+       7.25114441e+00, 2.40721531e+01, 7.49999237e+00, 7.62884521e+00,
+       2.23931980e+01, 7.50000000e+00, 7.98303223e+00, 2.08187962e+01,
+       7.50000763e+00, 9.38729095e+00, 1.45767651e+01, 7.50000000e+00,
+       9.51792908e+00, 1.39960957e+01, 7.50000000e+00, 9.71355438e+00,
+       1.31265163e+01, 7.49999237e+00, 9.82206726e+00, 1.26441593e+01,
+       7.50000000e+00, 9.99543762e+00, 1.18734989e+01, 7.50000000e+00,
+       1.01252670e+01, 1.12963924e+01, 7.50000000e+00, 1.05998535e+01,
+       9.18682671e+00, 7.50000000e+00, 1.09006805e+01, 7.84966087e+00,
+       7.50000000e+00, 1.09435730e+01, 7.65897179e+00, 7.50000000e+00,
+       1.14782333e+01, 5.28238106e+00, 7.50000000e+00, 1.22218704e+01,
+       1.97685814e+00, 7.50000000e+00, 7.58908081e+00, 2.18345699e+01,
+       7.50000000e+00, 7.69973755e+00, 2.13431149e+01, 7.50000000e+00,
+       9.73574066e+00, 1.23003635e+01, 7.50000000e+00, 1.00602341e+01,
+       1.08591328e+01, 7.50000000e+00, 1.05342560e+01, 8.75389671e+00,
+       7.50000000e+00, 1.08989716e+01, 7.13405037e+00, 7.50000000e+00,
+       8.64885712e+00, 1.63988934e+01, 7.50000000e+00, 8.99813080e+00,
+       1.48489857e+01, 7.49999237e+00, 1.00385590e+01, 1.02318325e+01,
+       7.50000000e+00, 1.01463013e+01, 9.75366402e+00, 7.50000000e+00,
+       1.04473724e+01, 8.41758537e+00, 7.50000000e+00, 1.05332260e+01,
+       8.03659630e+00, 7.50000763e+00, 1.13025360e+01, 4.62264252e+00,
+       7.50000000e+00, 1.10660934e+01, 4.95472145e+00, 7.50000763e+00,
+       7.24986267e+00, 2.11476917e+01, 7.50000763e+00, 7.38233948e+00,
+       2.05607777e+01, 7.50000000e+00, 7.64676666e+00, 1.93892803e+01,
+       7.50000000e+00, 8.10782623e+00, 1.73466129e+01, 7.50000000e+00,
+       8.87152100e+00, 1.39630833e+01, 7.50000763e+00, 9.58624268e+00,
+       1.07966290e+01, 7.50000000e+00, 1.05098190e+01, 6.70475197e+00,
+       7.50000000e+00, 1.17208710e+01, 1.33931541e+00, 7.50000000e+00,
+       6.21325684e+00, 2.50108891e+01, 7.50000000e+00, 6.76876068e+00,
+       2.25517902e+01, 7.50000000e+00, 7.14475250e+00, 2.08873577e+01,
+       7.50000000e+00, 8.15509796e+00, 1.64147968e+01, 7.50000000e+00,
+       8.22062683e+00, 1.61246777e+01, 7.50000000e+00, 8.30794525e+00,
+       1.57381496e+01, 7.50000763e+00, 8.56942749e+00, 1.45806065e+01,
+       7.49999237e+00, 8.89532471e+00, 1.31379604e+01, 7.50000000e+00,
+       1.01454239e+01, 7.60402107e+00, 7.50000000e+00, 1.01882477e+01,
+       7.41444016e+00, 7.50000000e+00, 1.07645874e+01, 4.86316681e+00,
+       7.50000000e+00, 1.08709412e+01, 4.39234924e+00, 7.50000000e+00,
+       1.15066681e+01, 1.57812309e+00, 7.50000000e+00, 1.16333084e+01,
+       1.01746368e+00, 7.50000000e+00, 6.24267578e+00, 2.41540203e+01,
+       7.50000000e+00, 6.28713226e+00, 2.39573803e+01, 7.50000000e+00,
+       7.94019318e+00, 1.66456165e+01, 7.50000000e+00, 8.55038452e+00,
+       1.39466877e+01, 7.50000000e+00, 1.01878738e+01, 6.70374870e+00,
+       7.50000000e+00, 6.86921692e+00, 2.06610889e+01, 7.50000000e+00,
+       8.29252625e+00, 1.43706913e+01, 7.50000000e+00, 8.59644318e+00,
+       1.30275326e+01, 7.50000000e+00, 8.89942932e+00, 1.16884785e+01,
+       7.50000000e+00, 9.41667938e+00, 9.40244484e+00, 7.50000000e+00,
+       9.97399902e+00, 6.93935204e+00, 7.50000000e+00, 1.01875153e+01,
+       5.99570274e+00, 7.50000000e+00, 1.04856644e+01, 4.67802811e+00,
+       7.50000000e+00, 1.12481918e+01, 1.30798721e+00, 7.50000000e+00,
+       1.13114700e+01, 1.02833366e+00, 7.50000000e+00, 6.01296997e+00,
+       2.37233257e+01, 7.49999237e+00, 7.96967316e+00, 1.50825443e+01,
+       7.50000000e+00, 1.01445694e+01, 5.47835350e+00, 7.49999237e+00,
+       1.02935410e+01, 4.82048988e+00, 7.50000000e+00, 1.03785629e+01,
+       4.44501495e+00, 7.50000000e+00, 5.70979309e+00, 2.43416691e+01,
+       7.50000000e+00, 5.97616577e+00, 2.31663113e+01, 7.50000763e+00,
+       6.55091095e+00, 2.06303616e+01, 7.50000000e+00, 7.73415375e+00,
+       1.54094486e+01, 7.49999237e+00, 7.77770233e+00, 1.52172604e+01,
+       7.50000000e+00, 7.95173645e+00, 1.44493732e+01, 7.50000000e+00,
+       8.01691437e+00, 1.41617527e+01, 7.50000000e+00, 8.42876434e+00,
+       1.23445606e+01, 7.50000000e+00, 8.53684998e+00, 1.18676052e+01,
+       7.50000000e+00, 1.01867905e+01, 4.58749771e+00, 7.50000000e+00,
+       5.38458252e+00, 2.50576992e+01, 7.49999237e+00, 6.18270111e+00,
+       2.15389614e+01, 7.50000000e+00, 6.35919952e+00, 2.07607937e+01,
+       7.50000000e+00, 7.71663666e+00, 1.47761173e+01, 7.50000000e+00,
+       7.93385315e+00, 1.38184185e+01, 7.50000000e+00, 8.02061462e+00,
+       1.34359303e+01, 7.50000000e+00, 8.51800537e+00, 1.12430515e+01,
+       7.50000000e+00, 8.69042206e+00, 1.04828815e+01, 7.50000000e+00,
+       9.18446350e+00, 8.30472374e+00, 7.50000000e+00, 9.31293488e+00,
+       7.73829460e+00, 7.50000000e+00, 9.37711334e+00, 7.45535469e+00,
+       7.50000000e+00, 9.44125366e+00, 7.17260170e+00, 7.50000000e+00,
+       9.61207581e+00, 6.41948318e+00, 7.50000000e+00, 9.97409821e+00,
+       4.82343102e+00, 7.50000000e+00, 1.03771286e+01, 3.04651642e+00,
+       7.50000000e+00, 1.05674591e+01, 2.20735550e+00, 7.50000000e+00,
+       5.28215790e+00, 2.47926006e+01, 7.50000000e+00, 5.72596741e+00,
+       2.28375034e+01, 7.50000000e+00, 5.81450653e+00, 2.24475231e+01,
+       7.50000000e+00, 7.17678833e+00, 1.64463024e+01, 7.50000000e+00,
+       7.50360107e+00, 1.50065861e+01, 7.50000000e+00, 8.32677460e+00,
+       1.13803043e+01, 7.50000000e+00, 8.86464691e+00, 9.01088142e+00,
+       7.49999237e+00, 9.71919250e+00, 5.24637032e+00, 7.50000000e+00,
+       5.02434540e+00, 2.52134113e+01, 7.50000000e+00, 5.33544922e+00,
+       2.38440762e+01, 7.50000000e+00, 7.13848114e+00, 1.59076290e+01,
+       7.50000000e+00, 8.82389069e+00, 8.48895454e+00, 7.50000000e+00,
+       9.29412842e+00, 6.41908264e+00, 7.50000763e+00, 9.52841187e+00,
+       5.38782501e+00, 7.50000000e+00, 9.74092102e+00, 4.45244026e+00,
+       7.50000000e+00, 1.01645660e+01, 2.58769608e+00, 7.50000000e+00,
+       1.02490616e+01, 2.21570587e+00, 7.50000000e+00, 1.04600220e+01,
+       1.28713417e+00, 7.50000000e+00, 4.94485474e+00, 2.48508282e+01,
+       7.50000000e+00, 5.01152802e+00, 2.45575886e+01, 7.49999237e+00,
+       5.71997833e+00, 2.14416943e+01, 7.50000000e+00, 5.96235657e+00,
+       2.03756504e+01, 7.50000000e+00, 6.07233429e+00, 1.98919353e+01,
+       7.50000000e+00, 4.93218994e+00, 2.41965923e+01, 7.49999237e+00,
+       5.70597839e+00, 2.07959995e+01, 7.50000000e+00, 7.04051971e+00,
+       1.49311123e+01, 7.50000000e+00, 7.19253540e+00, 1.42630672e+01,
+       7.50000000e+00, 7.71197510e+00, 1.19803104e+01, 7.50000000e+00,
+       7.81984711e+00, 1.15062275e+01, 7.50000000e+00, 9.19042206e+00,
+       5.48302650e+00, 7.50000000e+00, 9.46652222e+00, 4.26968002e+00,
+       7.50000000e+00, 9.95310211e+00, 2.13127136e+00, 7.50000000e+00,
+       1.02481155e+01, 8.34781647e-01, 7.50000000e+00, 4.58666992e+00,
+       2.50064106e+01, 7.50000000e+00, 5.67005157e+00, 2.02491474e+01,
+       7.50000000e+00, 7.26270294e+00, 1.32555180e+01, 7.49999237e+00,
+       7.47891998e+00, 1.23061008e+01, 7.49999237e+00, 7.82387543e+00,
+       1.07912922e+01, 7.50000000e+00, 9.17066956e+00, 4.87733269e+00,
+       7.50000000e+00, 9.70005798e+00, 2.55263519e+00, 7.50000000e+00,
+       4.37475586e+00, 2.52302952e+01, 7.50000000e+00, 5.94119263e+00,
+       1.83572903e+01, 7.49999237e+00, 6.02870941e+00, 1.79732380e+01,
+       7.50000000e+00, 6.24720001e+00, 1.70145741e+01, 7.50000000e+00,
+       9.44731140e+00, 2.97353745e+00, 7.50000000e+00, 9.61624146e+00,
+       2.23230934e+00, 7.50000000e+00, 5.33506775e+00, 2.03159199e+01,
+       7.50000000e+00, 5.66429138e+00, 1.88725681e+01, 7.50000000e+00,
+       6.51525116e+00, 1.51418018e+01, 7.50000000e+00, 9.63798523e+00,
+       1.45108223e+00, 7.50000000e+00, 4.17411804e+00, 2.47035389e+01,
+       7.50000000e+00, 4.39585114e+00, 2.37322063e+01, 7.50000000e+00,
+       5.27793884e+00, 1.98680363e+01, 7.49999237e+00, 8.77316284e+00,
+       4.55632782e+00, 7.50000000e+00, 8.96379089e+00, 3.72122574e+00,
+       7.50000000e+00, 9.32287598e+00, 2.14818573e+00, 7.50000000e+00,
+       9.53348541e+00, 1.22552681e+00, 7.50000000e+00, 9.57555389e+00,
+       1.04123306e+00, 7.50000000e+00, 4.56095123e+00, 2.23105488e+01,
+       7.50000000e+00, 5.46188354e+00, 1.83669262e+01, 7.50000000e+00,
+       6.35482788e+00, 1.44582539e+01, 7.50000000e+00, 7.79711914e+00,
+       8.14494896e+00, 7.50000000e+00, 8.54234314e+00, 4.88291740e+00,
+       7.50000000e+00, 3.81932068e+00, 2.48585758e+01, 7.50000000e+00,
+       4.48296356e+00, 2.19559307e+01, 7.50000000e+00, 5.14227295e+00,
+       1.90721874e+01, 7.50000000e+00, 6.07983398e+00, 1.49714222e+01,
+       7.50000000e+00, 6.29662323e+00, 1.40232143e+01, 7.50000000e+00,
+       6.33992004e+00, 1.38338146e+01, 7.50000000e+00, 6.55615234e+00,
+       1.28880596e+01, 7.50000000e+00, 6.66409302e+00, 1.24159412e+01,
+       7.50000000e+00, 8.65078735e+00, 3.72639465e+00, 7.50000000e+00,
+       9.19918823e+00, 1.32781219e+00, 7.50000000e+00, 9.26226807e+00,
+       1.05190659e+00, 7.50000000e+00, 4.03004456e+00, 2.32418118e+01,
+       7.49999237e+00, 4.95432281e+00, 1.92022953e+01, 7.50000000e+00,
+       6.26022339e+00, 1.34949856e+01, 7.49999237e+00, 6.64869690e+00,
+       1.17971478e+01, 7.50000000e+00, 9.15863037e+00, 8.27672958e-01,
+       7.50000000e+00, 3.82028961e+00, 2.34652424e+01, 7.50000000e+00,
+       3.95288086e+00, 2.28862133e+01, 7.50000000e+00, 4.04117584e+00,
+       2.25006123e+01, 7.50000000e+00, 4.91995239e+00, 1.86629887e+01,
+       7.50000000e+00, 5.81283569e+00, 1.47637653e+01, 7.50000000e+00,
+       3.25634766e+00, 2.52352848e+01, 7.50000000e+00, 3.98618317e+00,
+       2.20505657e+01, 7.50000000e+00, 4.99483490e+00, 1.76491528e+01,
+       7.50000000e+00, 5.08207703e+00, 1.72684917e+01, 7.50000000e+00,
+       6.83253479e+00, 9.63017464e+00, 7.50000000e+00, 7.83438110e+00,
+       5.25849152e+00, 7.50000000e+00, 8.02508545e+00, 4.42635155e+00,
+       7.50000000e+00, 8.84724426e+00, 8.38748932e-01, 7.50000000e+00,
+       3.33537292e+00, 2.42005558e+01, 7.49999237e+00, 4.30480957e+00,
+       1.99735126e+01, 7.50000000e+00, 4.43630219e+00, 1.94002209e+01,
+       7.50000000e+00, 4.74243164e+00, 1.80654125e+01, 7.50000000e+00,
+       5.09117126e+00, 1.65448589e+01, 7.49999237e+00, 6.00089264e+00,
+       1.25782337e+01, 7.50000000e+00, 6.06555939e+00, 1.22962742e+01,
+       7.50000000e+00, 6.10864258e+00, 1.21083927e+01, 7.50000000e+00,
+       7.24379730e+00, 7.15893364e+00, 7.49999237e+00, 8.66053772e+00,
+       9.81563568e-01, 7.50000000e+00, 3.08227539e+00, 2.46157856e+01,
+       7.50000000e+00, 3.23723602e+00, 2.39406605e+01, 7.50000000e+00,
+       3.41403198e+00, 2.31703472e+01, 7.50000000e+00, 3.61257935e+00,
+       2.23053455e+01, 7.50000000e+00, 3.70068359e+00, 2.19214344e+01,
+       7.50000000e+00, 4.40287781e+00, 1.88621349e+01, 7.50000000e+00,
+       5.33882141e+00, 1.47843227e+01, 7.50000000e+00, 7.18501282e+00,
+       6.74073792e+00, 7.50000000e+00, 7.71537018e+00, 4.43005180e+00,
+       7.50000000e+00, 2.87379456e+00, 2.48375607e+01, 7.50000763e+00,
+       3.66840363e+00, 2.13782291e+01, 7.50000000e+00, 3.95383453e+00,
+       2.01356411e+01, 7.50000000e+00, 4.01958466e+00, 1.98493786e+01,
+       7.50000763e+00, 4.10719299e+00, 1.94680004e+01, 7.49999237e+00,
+       5.08755493e+00, 1.51999683e+01, 7.50000000e+00, 6.72195435e+00,
+       8.08466911e+00, 7.50000000e+00, 7.10517120e+00, 6.41630745e+00,
+       7.50000763e+00, 8.35108185e+00, 9.92290497e-01, 7.49999237e+00,
+       2.62130737e+00, 2.52518826e+01, 7.49999237e+00, 2.77640533e+00,
+       2.45771809e+01, 7.50000000e+00, 3.37244415e+00, 2.19843349e+01,
+       7.50000000e+00, 3.48244476e+00, 2.15058422e+01, 7.50000000e+00,
+       3.74594879e+00, 2.03595524e+01, 7.50000000e+00, 4.44529724e+00,
+       1.73172550e+01, 7.50000000e+00, 7.32231140e+00, 4.80186462e+00,
+       7.50000000e+00, 7.40693665e+00, 4.43373680e+00, 7.50000000e+00,
+       8.06036377e+00, 1.59128189e+00, 7.50000000e+00, 4.01982117e+00,
+       1.84903736e+01, 7.50000000e+00, 4.54244232e+00, 1.62186527e+01,
+       7.50000000e+00, 7.13685608e+00, 4.94131660e+00, 7.49999237e+00,
+       7.97993469e+00, 1.27658272e+00, 7.50000000e+00, 8.04287720e+00,
+       1.00297546e+00, 7.50000000e+00, 2.40541840e+00, 2.48271618e+01,
+       7.50000000e+00, 2.47182465e+00, 2.45387440e+01, 7.50000000e+00,
+       2.62658691e+00, 2.38665066e+01, 7.50000000e+00, 3.00148773e+00,
+       2.22381573e+01, 7.50000000e+00, 3.11148071e+00, 2.17603664e+01,
+       7.50000000e+00, 3.26528931e+00, 2.10923328e+01, 7.50000000e+00,
+       3.39692688e+00, 2.05205250e+01, 7.50000763e+00, 3.72530365e+00,
+       1.90942440e+01, 7.50000000e+00, 3.92182922e+00, 1.82406864e+01,
+       7.50000000e+00, 4.05262756e+00, 1.76725597e+01, 7.50000000e+00,
+       4.16149139e+00, 1.71996784e+01, 7.50000000e+00, 4.44401550e+00,
+       1.59725704e+01, 7.50000000e+00, 4.59580994e+00, 1.53132267e+01,
+       7.50000763e+00, 4.76902008e+00, 1.45609112e+01, 7.50000000e+00,
+       5.45890045e+00, 1.15644703e+01, 7.50000000e+00, 6.33594513e+00,
+       7.75503731e+00, 7.50000000e+00, 6.50617981e+00, 7.01559639e+00,
+       7.50000000e+00, 6.67613983e+00, 6.27740860e+00, 7.50000000e+00,
+       2.15396118e+00, 2.52402020e+01, 7.50000000e+00, 2.19827271e+00,
+       2.50479259e+01, 7.50000000e+00, 2.75044250e+00, 2.26514492e+01,
+       7.50000000e+00, 2.92650604e+00, 2.18873005e+01, 7.49999237e+00,
+       3.03639221e+00, 2.14103794e+01, 7.50000000e+00, 3.86766815e+00,
+       1.78024921e+01, 7.50000000e+00, 4.15049744e+00, 1.65749569e+01,
+       7.50000000e+00, 4.51916504e+00, 1.49748707e+01, 7.50000000e+00,
+       5.10195923e+00, 1.24454784e+01, 7.50000000e+00, 5.38136292e+00,
+       1.12328091e+01, 7.50000000e+00, 6.23625183e+00, 7.52249336e+00,
+       7.50000000e+00, 6.42759705e+00, 6.69201088e+00, 7.50000000e+00,
+       6.47006989e+00, 6.50766945e+00, 7.50000000e+00, 7.52606201e+00,
+       1.92446709e+00, 7.50000000e+00, 7.63105774e+00, 1.46880341e+00,
+       7.50000000e+00, 7.73593903e+00, 1.01361656e+00, 7.50000000e+00,
+       3.00537109e+00, 2.08710995e+01, 7.50000000e+00, 3.11498260e+00,
+       2.03957615e+01, 7.50000000e+00, 3.94413757e+00, 1.67997913e+01,
+       7.50000000e+00, 4.07444763e+00, 1.62346783e+01, 7.50000000e+00,
+       4.16122437e+00, 1.58583393e+01, 7.50000763e+00, 5.71060944e+00,
+       9.13888359e+00, 7.50000000e+00, 5.77465820e+00, 8.86113548e+00,
+       7.50000000e+00, 5.92393494e+00, 8.21373940e+00, 7.50000000e+00,
+       6.00914001e+00, 7.84422874e+00, 7.50000000e+00, 6.13679504e+00,
+       7.29055214e+00, 7.50000000e+00, 6.51883698e+00, 5.63373756e+00,
+       7.50000000e+00, 6.64585876e+00, 5.08286667e+00, 7.50000000e+00,
+       6.75158691e+00, 4.62433815e+00, 7.50000000e+00, 6.83608246e+00,
+       4.25786209e+00, 7.50000763e+00, 2.00626373e+00, 2.45292950e+01,
+       7.50000000e+00, 2.68936157e+00, 2.15690899e+01, 7.50000000e+00,
+       4.10695648e+00, 1.54258251e+01, 7.50000000e+00, 4.69004822e+00,
+       1.28990078e+01, 7.50000000e+00, 5.22695160e+00, 1.05722752e+01,
+       7.50000000e+00, 5.95259094e+00, 7.42767525e+00, 7.50000000e+00,
+       6.24987030e+00, 6.13940620e+00, 7.50000000e+00, 6.29226685e+00,
+       5.95568085e+00, 7.50000000e+00, 7.43023682e+00, 1.02420998e+00,
+       7.50000000e+00, 1.73377228e+00, 2.50369091e+01, 7.50000000e+00,
+       2.10926819e+00, 2.34109325e+01, 7.49999237e+00, 2.59315491e+00,
+       2.13155231e+01, 7.50000763e+00, 4.24735260e+00, 1.41524220e+01,
+       7.49999237e+00, 4.87151337e+00, 1.14496021e+01, 7.50000000e+00,
+       5.55580902e+00, 8.48644066e+00, 7.50000000e+00, 5.91745758e+00,
+       6.92040253e+00, 7.50000000e+00, 6.27780914e+00, 5.35998535e+00,
+       7.50000000e+00, 7.22547150e+00, 1.25633812e+00, 7.50000000e+00,
+       7.33021545e+00, 8.02768707e-01, 7.50000000e+00, 1.79320526e+00,
+       2.41089001e+01, 7.50000000e+00, 1.92556763e+00, 2.35361233e+01,
+       7.50000000e+00, 2.23377991e+00, 2.22025242e+01, 7.50000000e+00,
+       2.29970551e+00, 2.19172764e+01, 7.50000000e+00, 2.34362793e+00,
+       2.17272053e+01, 7.50000000e+00, 2.51913452e+00, 2.09677639e+01,
+       7.50000000e+00, 3.93408203e+00, 1.48452473e+01, 7.50000000e+00,
+       4.51609802e+00, 1.23268986e+01, 7.50000000e+00, 5.28694153e+00,
+       8.99147224e+00, 7.50000000e+00, 5.45743561e+00, 8.25370598e+00,
+       7.50000000e+00, 5.58512878e+00, 7.70120811e+00, 7.50000000e+00,
+       5.84001923e+00, 6.59830475e+00, 7.50000000e+00, 5.90363312e+00,
+       6.32301521e+00, 7.50000000e+00, 6.05193329e+00, 5.68134880e+00,
+       7.50000000e+00, 7.12578583e+00, 1.03476715e+00, 7.50000000e+00,
+       1.38881683e+00, 2.51890087e+01, 7.50000000e+00, 1.56566620e+00,
+       2.44243984e+01, 7.50000000e+00, 2.66404724e+00, 1.96752148e+01,
+       7.50000763e+00, 3.96672058e+00, 1.40428295e+01, 7.50000000e+00,
+       4.78318024e+00, 1.05126514e+01, 7.50000763e+00, 5.25288391e+00,
+       8.48182106e+00, 7.49999237e+00, 5.52940369e+00, 7.28620911e+00,
+       7.49999237e+00, 5.57186890e+00, 7.10255814e+00, 7.50000000e+00,
+       6.03791046e+00, 5.08752060e+00, 7.50000000e+00, 7.02634430e+00,
+       8.13758850e-01, 7.50000000e+00, 1.33842468e+00, 2.47394772e+01,
+       7.50000000e+00, 1.58119965e+00, 2.36906071e+01, 7.50000000e+00,
+       1.80139160e+00, 2.27392292e+01, 7.50000000e+00, 1.99916840e+00,
+       2.18847370e+01, 7.50000000e+00, 2.08694458e+00, 2.15054913e+01,
+       7.50000000e+00, 2.43730927e+00, 1.99917507e+01, 7.50000000e+00,
+       4.04227448e+00, 1.30575161e+01, 7.50000000e+00, 4.70716095e+00,
+       1.01848850e+01, 7.50000000e+00, 4.77126312e+00, 9.90788078e+00,
+       7.50000000e+00, 4.87803650e+00, 9.44660759e+00, 7.50000000e+00,
+       5.00600433e+00, 8.89372063e+00, 7.50000000e+00, 6.59203339e+00,
+       2.04126549e+00, 7.50000000e+00, 1.55265808e+00, 2.31495266e+01,
+       7.50000000e+00, 4.03160858e+00, 1.24472523e+01, 7.49999237e+00,
+       5.50316620e+00, 6.09414291e+00, 7.50000000e+00, 6.07319641e+00,
+       3.63315773e+00, 7.50000000e+00, 6.26248932e+00, 2.81591988e+00,
+       7.50000000e+00, 6.49337006e+00, 1.81916809e+00, 7.50000000e+00,
+       1.06163788e+00, 2.46057949e+01, 7.50000000e+00, 1.14990234e+00,
+       2.42249889e+01, 7.50000763e+00, 1.63404846e+00, 2.21363888e+01,
+       7.50000000e+00, 2.00659943e+00, 2.05291843e+01, 7.50000000e+00,
+       2.24694824e+00, 1.94923382e+01, 7.50000000e+00, 4.08530426e+00,
+       1.15615788e+01, 7.50000000e+00, 5.17255402e+00, 6.87113953e+00,
+       7.50000000e+00, 5.42668152e+00, 5.77479935e+00, 7.50000000e+00,
+       6.20624542e+00, 2.41174698e+00, 7.50000000e+00, 7.69104004e-01,
+       2.52055912e+01, 7.50000000e+00, 1.16616058e+00, 2.34939671e+01,
+       7.49999237e+00, 1.23218536e+00, 2.32093334e+01, 7.50000000e+00,
+       2.06487274e+00, 1.96197567e+01, 7.50000000e+00, 3.79605103e+00,
+       1.21569500e+01, 7.50000000e+00, 4.11739349e+00, 1.07716846e+01,
+       7.50000000e+00, 4.20291901e+00, 1.04030285e+01, 7.49999237e+00,
+       4.54426575e+00, 8.93147850e+00, 7.50000000e+00, 4.82077789e+00,
+       7.73948860e+00, 7.50000000e+00, 4.94815063e+00, 7.19044304e+00,
+       7.49999237e+00, 5.39266205e+00, 5.27420044e+00, 7.50000000e+00,
+       7.63999939e-01, 2.45677319e+01, 7.49999237e+00, 8.52210999e-01,
+       2.41877308e+01, 7.50000000e+00, 9.62371826e-01, 2.37131863e+01,
+       7.50000000e+00, 1.20432281e+00, 2.26709766e+01, 7.50000000e+00,
+       1.83944702e+00, 1.99350224e+01, 7.50000000e+00, 2.47068787e+00,
+       1.72159214e+01, 7.50000000e+00, 2.55744171e+00, 1.68421803e+01,
+       7.50000000e+00, 3.80726624e+00, 1.14584255e+01, 7.50000000e+00,
+       4.12801361e+00, 1.00767727e+01, 7.50000000e+00, 4.23470306e+00,
+       9.61719322e+00, 7.50000000e+00, 4.76647949e+00, 7.32651901e+00,
+       7.50000000e+00, 4.95722961e+00, 6.50481796e+00, 7.50000000e+00,
+       5.08420563e+00, 5.95787811e+00, 7.50000000e+00, 5.14762115e+00,
+       5.68466187e+00, 7.50000000e+00, 5.21100616e+00, 5.41162491e+00,
+       7.49999237e+00, 5.82169342e+00, 2.78104019e+00, 7.50000000e+00,
+       5.90563202e+00, 2.41945076e+00, 7.50000000e+00, 5.98949432e+00,
+       2.05816078e+00, 7.50000000e+00, 6.24069977e+00, 9.76106644e-01,
+       7.50000000e+00, 9.34944153e-01, 2.31742458e+01, 7.50000000e+00,
+       1.19847107e+00, 2.20399418e+01, 7.50000000e+00, 1.24232483e+00,
+       2.18511715e+01, 7.50000000e+00, 1.35188293e+00, 2.13795986e+01,
+       7.50000000e+00, 5.93387604e+00, 1.65668488e+00, 7.50000000e+00,
+       7.53822327e-01, 2.32986050e+01, 7.50000000e+00, 1.47689056e+00,
+       2.01884937e+01, 7.50000000e+00, 2.41149139e+00, 1.61685085e+01,
+       7.49999237e+00, 2.54122925e+00, 1.56104832e+01, 7.50000000e+00,
+       2.62760925e+00, 1.52388592e+01, 7.50000763e+00, 4.04272461e+00,
+       9.15213966e+00, 7.50000763e+00, 4.63716888e+00, 6.59529114e+00,
+       7.50000000e+00, 4.70064545e+00, 6.32222939e+00, 7.50000000e+00,
+       5.62718201e+00, 2.33695412e+00, 7.50000000e+00, 2.18276978e-02,
+       2.57917614e+01, 7.49999237e+00, 7.48756409e-01, 2.26673222e+01,
+       7.50000000e+00, 1.16498566e+00, 2.08783398e+01, 7.50000000e+00,
+       1.44880676e+00, 1.96584568e+01, 7.50000000e+00, 2.01410675e+00,
+       1.72287579e+01, 7.50000000e+00, 2.36043549e+00, 1.57401905e+01,
+       7.50000000e+00, 2.57629395e+00, 1.48123837e+01, 7.50000000e+00,
+       4.07468414e+00, 8.37219048e+00, 7.50000000e+00, 4.68902588e+00,
+       5.73169327e+00, 7.49999237e+00, 4.75236511e+00, 5.45945168e+00,
+       7.49999237e+00, 5.78133392e+00, 1.03683281e+00, 7.50000000e+00,
+       9.84481812e-01, 2.10041103e+01, 7.50000000e+00, 1.09374237e+00,
+       2.05348721e+01, 7.50000000e+00, 1.42081451e+00, 1.91301250e+01,
+       7.49999237e+00, 2.56818390e+00, 1.42022228e+01, 7.50000000e+00,
+       3.97920227e+00, 8.14198875e+00, 7.50000000e+00, 4.12770844e+00,
+       7.50413895e+00, 7.50000000e+00, 4.97219849e+00, 3.87712860e+00,
+       7.50000000e+00, 5.20320129e+00, 2.88498878e+00, 7.50000000e+00,
+       5.34992218e+00, 2.25480843e+00, 7.50000000e+00, 5.45459747e+00,
+       1.80523872e+00, 7.50000000e+00, 1.03801346e+01, -1.90734863e-06,
+       3.84992218e+00, 7.82440186e-01, 2.12235165e+01, 7.50000000e+00,
+       1.00087738e+00, 2.02860012e+01, 7.50000000e+00, 1.87004089e+00,
+       1.65557499e+01, 7.50000000e+00, 1.97816467e+00, 1.60916805e+01,
+       7.50000000e+00, 2.62455750e+00, 1.33175106e+01, 7.50000000e+00,
+       4.13822174e+00, 6.82116508e+00, 7.50000000e+00, 4.87617493e+00,
+       3.65403175e+00, 7.50000000e+00, 4.93917847e+00, 3.38363838e+00,
+       7.50000000e+00, 7.99186707e-01, 2.05055485e+01, 7.50000000e+00,
+       1.01721191e+00, 1.95705051e+01, 7.50000000e+00, 2.01422119e+00,
+       1.52946377e+01, 7.50000000e+00, 2.12201691e+00, 1.48323650e+01,
+       7.50000000e+00, 2.35875702e+00, 1.38170719e+01, 7.50000000e+00,
+       2.59494019e+00, 1.28041210e+01, 7.50000000e+00, 4.67537689e+00,
+       3.88185310e+00, 7.50000000e+00, 4.94818115e+00, 2.71191788e+00,
+       7.49999237e+00, 5.24113464e+00, 1.45550537e+00, 7.50000000e+00,
+       5.38729858e+00, 8.28668594e-01, 7.50000000e+00, 1.09867859e+00,
+       1.85782032e+01, 7.49999237e+00, 2.11470032e+00, 1.42240009e+01,
+       7.50000000e+00, 2.52259827e+00, 1.24759655e+01, 7.49999237e+00,
+       4.60091400e+00, 3.56922913e+00, 7.50000000e+00, 4.93622589e+00,
+       2.13223839e+00, 7.50000000e+00, 7.88993835e-01, 1.92636929e+01,
+       7.50000000e+00, 2.42902374e+00, 1.22403774e+01, 7.50000000e+00,
+       2.64288330e+00, 1.13245716e+01, 7.50000000e+00, 8.05641174e-01,
+       1.85530186e+01, 7.50000000e+00, 1.02253723e+00, 1.76249027e+01,
+       7.49999237e+00, 2.03579712e+00, 1.32887707e+01, 7.50000000e+00,
+       2.37847137e+00, 1.18223629e+01, 7.50000000e+00, 3.80104828e+00,
+       5.73466873e+00, 7.50000763e+00, 4.22187805e+00, 3.93382645e+00,
+       7.50000000e+00, 4.43163300e+00, 3.03619766e+00, 7.50000000e+00,
+       4.53635406e+00, 2.58808136e+00, 7.50000763e+00, 4.64096069e+00,
+       2.14042664e+00, 7.50000000e+00, 4.91244507e+00, 9.78689194e-01,
+       7.50000000e+00, 7.62939453e-06, 2.44203777e+01, 6.91436768e+00,
+       9.95452881e-01, 1.71042004e+01, 7.50000000e+00, 1.18997192e+00,
+       1.62723789e+01, 7.50000000e+00, 2.02867889e+00, 1.26859150e+01,
+       7.49999237e+00, 2.15708923e+00, 1.21367359e+01, 7.50000763e+00,
+       2.41345978e+00, 1.10404606e+01, 7.50000000e+00, 2.45612335e+00,
+       1.08580151e+01, 7.50000000e+00, 2.58400726e+00, 1.03111286e+01,
+       7.50000000e+00, 3.93827057e+00, 4.51999664e+00, 7.50000000e+00,
+       8.17123413e-01, 1.72317982e+01, 7.50000000e+00, 1.01164246e+00,
+       1.64005680e+01, 7.50000763e+00, 2.08568573e+00, 1.18110638e+01,
+       7.49999237e+00, 2.53343964e+00, 9.89771461e+00, 7.50000000e+00,
+       3.57063293e+00, 5.46559715e+00, 7.50000763e+00, 4.11673737e+00,
+       3.13207817e+00, 7.49999237e+00, 4.20048523e+00, 2.77418900e+00,
+       7.50000000e+00, 4.36778259e+00, 2.05928802e+00, 7.50000000e+00,
+       4.55567169e+00, 1.25644112e+00, 7.50000000e+00, 4.65989685e+00,
+       8.11058044e-01, 7.50000000e+00, 0., 2.44719028e+01,
+       6.65680695e+00, -7.62939453e-06, 2.31593914e+01, 6.90926361e+00,
+       8.33633423e-01, 1.65285435e+01, 7.50000000e+00, 1.09243011e+00,
+       1.54234638e+01, 7.50000000e+00, 2.07848358e+00, 1.12129116e+01,
+       7.50000000e+00, 2.16378784e+00, 1.08486843e+01, 7.49999237e+00,
+       2.52551270e+00, 9.30408669e+00, 7.50000000e+00, 2.63165283e+00,
+       8.85082817e+00, 7.50000000e+00, 3.87590790e+00, 3.53774452e+00,
+       7.50000000e+00, 4.10622406e+00, 2.55432320e+00, 7.50000000e+00,
+       0., 2.24237080e+01, 6.92761230e+00, 2.15647888e+00,
+       1.02534046e+01, 7.50000000e+00, 2.19902802e+00, 1.00718288e+01,
+       7.50000000e+00, 3.61438751e+00, 4.03249168e+00, 7.49999237e+00,
+       4.28348541e+00, 1.17739677e+00, 7.50000000e+00, 4.32516479e+00,
+       9.99578476e-01, 7.50000000e+00, 0., 2.35362301e+01,
+       6.58924866e+00, 0., 2.32087307e+01, 6.65255737e+00,
+       8.23432922e-01, 1.53130970e+01, 7.50000000e+00, 1.01695251e+00,
+       1.44879665e+01, 7.50000000e+00, 3.16392517e+00, 5.33331299e+00,
+       7.50000000e+00, 3.35307312e+00, 4.52681160e+00, 7.50000000e+00,
+       3.56281281e+00, 3.63244247e+00, 7.50000763e+00, 3.66753387e+00,
+       3.18595314e+00, 7.50000000e+00, 4.10614777e+00, 1.31569672e+00,
+       7.50000000e+00, 7.62939453e-06, 2.48805676e+01, 6.20475006e+00,
+       0., 2.27976742e+01, 6.60832214e+00, 0., 2.24717655e+01,
+       6.67146301e+00, 0., 2.21466694e+01, 6.73445129e+00, 0.,
+       2.10687580e+01, 6.94329071e+00, 8.18367004e-01, 1.47084446e+01,
+       7.50000763e+00, 1.05444336e+00, 1.37025585e+01, 7.50000000e+00,
+       1.11872864e+00, 1.34286251e+01, 7.50000000e+00, 2.05705261e+00,
+       9.43048668e+00, 7.50000000e+00, 2.12071991e+00, 9.15921593e+00,
+       7.49999237e+00, 2.79736328e+00, 6.27608871e+00, 7.50000000e+00,
+       3.09198761e+00, 5.02069855e+00, 7.50000000e+00, 3.25995636e+00,
+       4.30496216e+00, 7.50000000e+00, 3.86656952e+00, 1.72027206e+00,
+       7.50000000e+00, 0., 2.04485149e+01, 6.94071198e+00,
+       1.13456726e+00, 1.27379856e+01, 7.49999237e+00, 3.18804169e+00,
+       3.99442101e+00, 7.50000000e+00, 3.89816284e+00, 9.70821381e-01,
+       7.50000000e+00, 0., 2.11144886e+01, 6.68812561e+00,
+       8.51097107e-01, 1.33230534e+01, 7.50000000e+00, 2.57048035e+00,
+       6.00720596e+00, 7.50000763e+00, 2.88574982e+00, 4.66579628e+00,
+       7.50000000e+00, 2.92771149e+00, 4.48725319e+00, 7.50000000e+00,
+       3.20004272e+00, 3.32851410e+00, 7.50000763e+00, 3.63842773e+00,
+       1.46323013e+00, 7.50000000e+00, 0., 1.91081562e+01,
+       6.95626831e+00, 8.46008301e-01, 1.27249165e+01, 7.50000000e+00,
+       1.27252960e+00, 1.09113941e+01, 7.49999237e+00, 2.31008911e+00,
+       6.49982643e+00, 7.50000000e+00, 2.66761017e+00, 4.97966385e+00,
+       7.50000000e+00, 7.62939453e-06, 2.03013515e+01, 6.60018921e+00,
+       0., 1.94479389e+01, 6.76714325e+00, 0., 1.83889599e+01,
+       6.97430420e+00, 1.07534790e+00, 1.11327534e+01, 7.50000000e+00,
+       1.26673889e+00, 1.03195133e+01, 7.50000000e+00, 2.21843719e+00,
+       6.27588844e+00, 7.50000763e+00, 2.36568451e+00, 5.65023994e+00,
+       7.50000000e+00, 2.93167877e+00, 3.24543762e+00, 7.50000000e+00,
+       3.22391510e+00, 2.00373077e+00, 7.50000000e+00, 3.49454498e+00,
+       8.53900909e-01, 7.50000000e+00, 0., 1.96824436e+01,
+       6.59817505e+00, 0., 1.91505527e+01, 6.70247650e+00,
+       8.99757385e-01, 1.12634068e+01, 7.50000000e+00, 1.09115601e+00,
+       1.04507275e+01, 7.50000000e+00, 2.27415466e+00, 5.42780876e+00,
+       7.50000000e+00, 2.35813904e+00, 5.07123566e+00, 7.50000000e+00,
+       2.54683685e+00, 4.27001762e+00, 7.50000000e+00, 3.31899261e+00,
+       9.91596222e-01, 7.50000000e+00, -7.62939453e-06, 1.88534107e+01,
+       6.63787842e+00, 0., 1.70638828e+01, 6.98964691e+00,
+       8.94599915e-01, 1.06718769e+01, 7.50000000e+00, 1.90966034e+00,
+       6.36506462e+00, 7.50000000e+00, 3.14372253e+00, 1.12906075e+00,
+       7.50000000e+00, 0., 2.37375431e+01, 5.55242920e+00,
+       7.62939453e-06, 1.84507580e+01, 6.59416199e+00, 7.62939453e-06,
+       1.63529720e+01, 7.00751495e+00, 1.81880951e+00, 6.14200211e+00,
+       7.49999237e+00, 1.86085510e+00, 5.96374130e+00, 7.50000000e+00,
+       1.96588135e+00, 5.51840210e+00, 7.50000000e+00, 2.23847198e+00,
+       4.36267090e+00, 7.49999237e+00, 2.30126953e+00, 4.09639740e+00,
+       7.50000000e+00, 2.63555145e+00, 2.67903328e+00, 7.50000000e+00,
+       2.69811249e+00, 2.41379547e+00, 7.50000000e+00, 0.,
+       2.35426998e+01, 5.46537018e+00, 0., 2.17942371e+01,
+       5.81072998e+00, 0., 1.71028156e+01, 6.73737335e+00,
+       9.05540466e-01, 9.40498924e+00, 7.50000000e+00, 1.77019501e+00,
+       5.74149704e+00, 7.50000000e+00, 1.87513733e+00, 5.29682922e+00,
+       7.50000000e+00, 2.23115540e+00, 3.78836250e+00, 7.50000000e+00,
+       7.62939453e-06, 2.11675472e+01, 5.81001282e+00, 0.,
+       2.09514866e+01, 5.85279083e+00, 0., 1.68082676e+01,
+       6.67311859e+00, 0., 1.61824322e+01, 6.79703522e+00, 0.,
+       1.51460896e+01, 7.00222015e+00, 9.21554565e-01, 8.73004341e+00,
+       7.50000000e+00, 1.13272095e+00, 7.83592796e+00, 7.50000763e+00,
+       1.21707153e+00, 7.47880173e+00, 7.50000000e+00, 2.59889984e+00,
+       1.62812614e+00, 7.49999237e+00, 2.64047241e+00, 1.45205879e+00,
+       7.50000000e+00, 2.78588104e+00, 8.36385727e-01, 7.50000000e+00,
+       0., 2.38137035e+01, 5.16017151e+00, 7.62939453e-06,
+       2.34829578e+01, 5.22580719e+00, 0., 2.21681805e+01,
+       5.48674774e+00, 0., 2.04353046e+01, 5.83067322e+00, 0.,
+       1.96843128e+01, 5.97971344e+00, 0., 1.64096203e+01,
+       6.62963104e+00, 0., 1.44428349e+01, 7.01998138e+00,
+       1.12724304e+00, 7.25472641e+00, 7.50000000e+00, 1.23249054e+00,
+       6.80939484e+00, 7.50000000e+00, 1.44266510e+00, 5.92009163e+00,
+       7.50000000e+00, 1.65242767e+00, 5.03261375e+00, 7.50000000e+00,
+       1.75714111e+00, 4.58954811e+00, 7.50000000e+00, 2.09151459e+00,
+       3.17478180e+00, 7.49999237e+00, 2.21662903e+00, 2.64543533e+00,
+       7.49999237e+00, 2.25827789e+00, 2.46912193e+00, 7.50000000e+00,
+       7.62939453e-06, 2.51716709e+01, 4.76389313e+00, 7.62939453e-06,
+       2.49486637e+01, 4.80826569e+00, 0., 2.00277081e+01,
+       5.78725433e+00, 9.32342529e-01, 7.47632408e+00, 7.50000000e+00,
+       1.81332397e+00, 3.75141525e+00, 7.50000000e+00, 1.91769409e+00,
+       3.31009483e+00, 7.50000000e+00, 2.41722107e+00, 1.19799042e+00,
+       7.50000000e+00, 2.45874023e+00, 1.02244759e+00, 7.50000000e+00,
+       0., 1.92999668e+01, 5.80789185e+00, 0., 1.31466503e+01,
+       7.03497314e+00, 9.48226929e-01, 6.80824089e+00, 7.50000763e+00,
+       1.34696960e+00, 5.12345695e+00, 7.50000000e+00, 7.62939453e-06,
+       2.36690540e+01, 4.81021118e+00, 7.62939453e-06, 2.20218220e+01,
+       5.13948059e+00, 0., 2.02871799e+01, 5.48623657e+00, 0.,
+       1.84689808e+01, 5.84969330e+00, 0., 1.25528011e+01,
+       7.03230286e+00, 1.06894684e+00, 5.69961739e+00, 7.50000000e+00,
+       1.17372894e+00, 5.25718689e+00, 7.50000000e+00, 1.27841187e+00,
+       4.81520844e+00, 7.49999237e+00, 1.40387726e+00, 4.28542137e+00,
+       7.49999237e+00, 1.92503357e+00, 2.08493233e+00, 7.49999237e+00,
+       1.98739624e+00, 1.82162094e+00, 7.50000000e+00, 7.62939453e-06,
+       2.15007076e+01, 5.11810303e+00, 0., 2.10663052e+01,
+       5.20515442e+00, 0., 1.94500065e+01, 5.52901459e+00,
+       7.62939453e-06, 1.78534946e+01, 5.84890747e+00, 0.,
+       1.37925625e+01, 6.66261292e+00, 9.79820251e-01, 5.47907829e+00,
+       7.50000763e+00, 1.08452606e+00, 5.03730965e+00, 7.50000000e+00,
+       1.33536530e+00, 3.97888947e+00, 7.50000000e+00, 1.73128510e+00,
+       2.30832100e+00, 7.50000000e+00, 2.04277802e+00, 9.93991852e-01,
+       7.50000000e+00, 0., 2.06560268e+01, 5.16204071e+00, 0.,
+       1.87235126e+01, 5.55018616e+00, 7.62939453e-06, 1.73454456e+01,
+       5.82697296e+00, 0., 1.32974415e+01, 6.64001465e+00, 0.,
+       1.11697598e+01, 7.06737518e+00, 9.95544434e-01, 4.81797791e+00,
+       7.50000000e+00, 1.07916260e+00, 4.46541405e+00, 7.49999237e+00,
+       1.49621582e+00, 2.70685577e+00, 7.50000000e+00, 7.62939453e-06,
+       2.51936588e+01, 4.12297821e+00, 0., 2.49698086e+01,
+       4.16804504e+00, 0., 2.10039196e+01, 4.96649933e+00, 0.,
+       1.69438076e+01, 5.78392029e+00, 0., 1.25999928e+01,
+       6.65847015e+00, 0., 1.04824085e+01, 7.08479309e+00,
+       1.13637543e+00, 3.63175392e+00, 7.50000000e+00, 1.28221130e+00,
+       3.01723671e+00, 7.50000000e+00, 1.32383728e+00, 2.84181976e+00,
+       7.50000000e+00, 1.59402466e+00, 1.70333672e+00, 7.50000000e+00,
+       1.75994110e+00, 1.00421906e+00, 7.50000000e+00, 0.,
+       2.38818188e+01, 4.25986481e+00, 0., 2.35492496e+01,
+       4.32698059e+00, 7.62939453e-06, 1.61237659e+01, 5.82550812e+00,
+       1.58786011e+00, 1.14019203e+00, 7.50000000e+00, 1.67071533e+00,
+       7.91288376e-01, 7.50000000e+00, 0., 2.22514210e+01,
+       4.46228027e+00, 0., 2.15947742e+01, 4.59510040e+00,
+       7.62939453e-06, 1.54118023e+01, 5.84584808e+00, 0.,
+       1.12135563e+01, 6.69511414e+00, 9.38316345e-01, 3.28625679e+00,
+       7.50000000e+00, 1.14630127e+00, 2.41105461e+00, 7.50000763e+00,
+       0., 2.20561848e+01, 4.37504578e+00, 0., 2.11820469e+01,
+       4.55229950e+00, 0., 2.09644146e+01, 4.59643555e+00, 0.,
+       1.63711071e+01, 5.52781677e+00, 0., 1.45991917e+01,
+       5.88710785e+00, 7.62939453e-06, 1.07251797e+01, 6.67263794e+00,
+       0., 1.05245228e+01, 6.71333313e+00, 0., 9.02975655e+00,
+       7.01642609e+00, 9.54002380e-01, 2.63320160e+00, 7.50000763e+00,
+       1.16161346e+00, 1.76017570e+00, 7.50000000e+00, 1.32740784e+00,
+       1.06302452e+00, 7.50000000e+00, 7.62939453e-06, 2.07700253e+01,
+       4.50956726e+00, 0., 2.03361721e+01, 4.59775543e+00,
+       7.62939453e-06, 1.55525341e+01, 5.57003784e+00, 0.,
+       1.32769184e+01, 6.03256226e+00, -7.62939453e-06, 1.01379261e+01,
+       6.67057037e+00, 0., 8.35053825e+00, 7.03385162e+00,
+       1.15616608e+00, 1.19855499e+00, 7.50000763e+00, 1.25965118e+00,
+       7.63692856e-01, 7.50000000e+00, 7.62939453e-06, 2.05756321e+01,
+       4.42272186e+00, 0., 1.47379742e+01, 5.61204529e+00,
+       7.62939453e-06, 1.38073940e+01, 5.80163574e+00, 7.62939453e-06,
+       9.05547905e+00, 6.76976776e+00, 9.64508057e-01, 1.42083168e+00,
+       7.50000000e+00, 0., 2.37877178e+01, 3.64021301e+00, 0.,
+       2.16894512e+01, 4.06871796e+00, 7.62939453e-06, 1.31045208e+01,
+       5.82189941e+00, 0., 7.39149857e+00, 6.98860168e+00,
+       9.80072021e-01, 7.74307251e-01, 7.50000000e+00, 0.,
+       2.11660595e+01, 4.04859924e+00, 0., 1.22005825e+01,
+       5.88383484e+00, 0., 6.71852112e+00, 7.00601196e+00, 0.,
+       2.02093258e+01, 4.11769867e+00, 0., 1.32398396e+01,
+       5.54772949e+00, 0., 1.15043850e+01, 5.90383148e+00, 0.,
+       7.41460037e+00, 6.74299622e+00, 7.62939453e-06, 2.22010365e+01,
+       3.58115387e+00, 7.62939453e-06, 2.09941082e+01, 3.82938385e+00,
+       0., 1.24359150e+01, 5.58954620e+00, 0., 1.10129795e+01,
+       5.88220215e+00, 7.62939453e-06, 1.08110027e+01, 5.92373657e+00,
+       0., 6.74055099e+00, 6.76091766e+00, 7.62939453e-06,
+       5.38056374e+00, 7.04061890e+00, 0., 5.09107208e+00,
+       7.10016632e+00, 0., 2.52381039e+01, 2.82698059e+00, 0.,
+       2.38906307e+01, 3.10477448e+00, 0., 1.98203106e+01,
+       3.94389343e+00, 0., 1.16359119e+01, 5.63115692e+00, 0.,
+       1.03214359e+01, 5.90213776e+00, 0., 4.71554756e+00,
+       7.05782318e+00, 5.89218140e-01, 1.04547501e-01, 7.50000000e+00,
+       -7.62939453e-06, 2.50394382e+01, 2.73831940e+00, 0.,
+       2.35814114e+01, 3.03959656e+00, 0., 2.06036015e+01,
+       3.65494537e+00, 0., 2.00594807e+01, 3.76737976e+00, 0.,
+       1.09409046e+01, 5.65166473e+00, 0., 9.93337059e+00,
+       5.85986328e+00, 0., 5.40047073e+00, 6.79654694e+00, 0.,
+       9.74633980e+00, 5.77615356e+00, 0., 9.14613152e+00,
+       5.90046692e+00, 0., 5.02368164e+00, 6.75434113e+00, 0.,
+       4.73440361e+00, 6.81427002e+00, 0., 3.29814529e+00,
+       7.11176300e+00, 2.71560669e-01, 2.88646698e-01, 7.50000000e+00,
+       7.62939453e-06, 2.49803715e+01, 2.49075317e+00, 0.,
+       2.22983799e+01, 3.04759216e+00, 0., 2.20773182e+01,
+       3.09349060e+00, 7.62939453e-06, 1.93449688e+01, 3.66076660e+00,
+       7.62939453e-06, 1.00613003e+01, 5.58821106e+00, 0.,
+       8.36268425e+00, 5.94087982e+00, 7.62939453e-06, 3.68811989e+00,
+       6.91138458e+00, 0., 2.64139175e+00, 7.12871552e+00, 0.,
+       2.03447208e+01, 3.32530212e+00, 7.62939453e-06, 1.95834484e+01,
+       3.48372650e+00, 0., 9.37229347e+00, 5.60873413e+00, 0.,
+       7.97840691e+00, 5.89879608e+00, 0., 2.52605762e+01,
+       2.17180634e+00, 0., 2.39080334e+01, 2.45393372e+00,
+       7.62939453e-06, 2.36839428e+01, 2.50067902e+00, 0.,
+       2.16840153e+01, 2.91786194e+00, 0., 1.98227062e+01,
+       3.30611420e+00, 0., 1.87400684e+01, 3.53194427e+00, 0.,
+       1.80947819e+01, 3.66654968e+00, 0., 1.04926205e+01,
+       5.25231934e+00, 0., 8.58646202e+00, 5.64994049e+00, 0.,
+       7.29878235e+00, 5.91853333e+00, 0., 3.41856956e+00,
+       6.72792816e+00, 0., 3.03719330e+00, 6.80747986e+00, 0.,
+       1.33560753e+00, 7.16242981e+00, 7.62939453e-06, 2.50611782e+01,
+       2.08281708e+00, 0., 2.10473843e+01, 2.92203522e+00, 0.,
+       1.89773464e+01, 3.35485840e+00, 0., 1.77937565e+01,
+       3.60232544e+00, 0., 2.66482735e+00, 6.76554871e+00, 0.,
+       9.67182159e-01, 7.12050629e+00, 0., 3.42140198e-02,
+       7.31556702e+00, 0., 2.08510990e+01, 2.83438110e+00, 0.,
+       1.80288029e+01, 3.42586517e+00, 0., 5.85009384e+00,
+       5.97821808e+00, 7.62939453e-06, 6.92829132e-01, 7.05905151e+00,
+       4.36553955e-01, 1.90734863e-06, 6.82308960e+00, -7.62939453e-06,
+       2.36490612e+01, 2.11774445e+00, 0., 1.91287174e+01,
+       3.06731415e+00, 0., 1.83723125e+01, 3.22621155e+00, 0.,
+       1.78347111e+01, 3.33913422e+00, 0., 1.70857868e+01,
+       3.49645996e+00, 7.62939453e-06, 7.03746223e+00, 5.60727692e+00,
+       0., 5.27615356e+00, 5.97727203e+00, 7.62939453e-06,
+       1.45013237e+00, 6.78098297e+00, 7.62939453e-06, 2.22233372e+01,
+       2.28748322e+00, 0., 1.67857265e+01, 3.43242645e+00, 0.,
+       1.64665852e+01, 3.49962616e+00, 0., 9.53926277e+00,
+       4.95822906e+00, 0., 8.93701363e+00, 5.08503723e+00, 0.,
+       6.36032104e+00, 5.62757874e+00, 0., 4.80085564e+00,
+       5.95594025e+00, 0., 9.86732483e-01, 6.75904083e+00,
+       7.62939453e-06, 7.05432892e-01, 6.81826019e+00, 0.,
+       2.14720974e+01, 2.31610107e+00, 0., 2.07009296e+01,
+       2.47885895e+00, 0., 1.87385540e+01, 2.89302063e+00, 0.,
+       1.76609859e+01, 3.12044525e+00, 0., 5.58830261e+00,
+       5.66840363e+00, 0., 4.51995850e+00, 5.89387512e+00, 0.,
+       4.03739357e+00, 5.99571991e+00, 0., 3.55672073e+00,
+       6.09716797e+00, 0., 1.99567013e+01, 2.50691986e+00, 0.,
+       1.71454716e+01, 3.10162354e+00, 0., 1.60802631e+01,
+       3.32695770e+00, 7.62939453e-06, 1.07813931e+01, 4.44790649e+00,
+       -7.62939453e-06, 9.26413918e+00, 4.76888275e+00, 0.,
+       8.56231880e+00, 4.91734314e+00, 0., 1.86729450e+01,
+       2.64994049e+00, 7.62939453e-06, 1.57811604e+01, 3.26310730e+00,
+       0., 1.12039204e+01, 4.23365784e+00, 0., 9.57959175e+00,
+       4.57808685e+00, 0., 8.97584343e+00, 4.70609283e+00, 0.,
+       3.67000198e+00, 5.83113861e+00, 0., 1.00636673e+00,
+       6.39594269e+00, 0., 7.24409103e-01, 6.45572662e+00,
+       7.62939453e-06, 2.36656666e+01, 1.46006012e+00, 7.62939453e-06,
+       1.98922138e+01, 2.26204681e+00, 0., 1.68643703e+01,
+       2.90557861e+00, -7.62939453e-06, 1.10144024e+01, 4.14889526e+00,
+       7.62939453e-06, 1.06066761e+01, 4.23554230e+00, 0.,
+       2.22346096e+01, 1.63351440e+00, 0., 2.04633007e+01,
+       2.01086426e+00, 0., 1.94773617e+01, 2.22089386e+00, 0.,
+       1.77427845e+01, 2.59040833e+00, 0., 1.75275822e+01,
+       2.63625336e+00, 0., 1.19521236e+01, 3.82399750e+00, 0.,
+       9.30384636e+00, 4.38815308e+00, 0., 3.88015556e+00,
+       5.54355621e+00, 0., 3.68734360e+00, 5.58463287e+00, 0.,
+       2.37174435e+01, 1.18600464e+00, 0., 2.17025738e+01,
+       1.61623383e+00, 0., 1.61565456e+01, 2.80045319e+00, 0.,
+       1.01267338e+01, 4.08797455e+00, 0., 9.62011528e+00,
+       4.19614410e+00, 0., 4.17901230e+00, 5.35797119e+00, 0.,
+       9.31814194e-01, 6.05133057e+00, 0., 2.53334522e+01,
+       7.08320618e-01, 0., 2.49911251e+01, 7.81593323e-01, 0.,
+       1.98499699e+01, 1.88191223e+00, 0., 1.51146107e+01,
+       2.89539337e+00, 0., 1.31224461e+01, 3.32176208e+00, 0.,
+       1.28107128e+01, 3.38848114e+00, 0., 1.20863094e+01,
+       3.54351807e+00, 0., 1.07518787e+01, 3.82911682e+00, 0.,
+       9.93764687e+00, 4.00337982e+00, 0., 9.12865639e+00,
+       4.17652893e+00, 0., 1.96531811e+01, 1.79405212e+00, 0.,
+       1.81288204e+01, 2.12105560e+00, 7.62939453e-06, 1.63015652e+01,
+       2.51303864e+00, 7.62939453e-06, 1.59817715e+01, 2.58164215e+00,
+       0., 1.47105045e+01, 2.85436249e+00, 0., 1.43946476e+01,
+       2.92211151e+00, 0., 1.13810482e+01, 3.56859589e+00, 0.,
+       8.94020653e+00, 4.09220123e+00, 0., 7.33898926e+00,
+       4.43570709e+00, 0., 3.71346283e+00, 5.21344757e+00, 0.,
+       2.52740345e+01, 4.55276489e-01, 7.62939453e-06, 2.23331509e+01,
+       1.08762360e+00, 0., 2.21096134e+01, 1.13568878e+00, 0.,
+       2.12192326e+01, 1.32714081e+00, 0., 2.06657963e+01,
+       1.44614410e+00, 0., 2.01146870e+01, 1.56464386e+00, 0.,
+       1.86925869e+01, 1.87042236e+00, 7.62939453e-06, 1.84751759e+01,
+       1.91716766e+00, 7.62939453e-06, 1.73935413e+01, 2.14973450e+00,
+       0., 1.20142956e+01, 3.30638123e+00, 7.62939453e-06,
+       1.02705555e+01, 3.68131256e+00, 0., 9.86374092e+00,
+       3.76879883e+00, 0., 9.45824242e+00, 3.85597992e+00,
+       7.62939453e-06, 7.64958000e+00, 4.24487305e+00, 0.,
+       2.18570328e+00, 5.41971588e+00, 0., 2.50727329e+01,
+       3.65493774e-01, 7.62939453e-06, 2.16877995e+01, 1.09500885e+00,
+       0., 1.80622921e+01, 1.87637329e+00, 0., 1.71983776e+01,
+       2.06256104e+00, 0., 1.60198421e+01, 2.31656647e+00, 0.,
+       1.42194500e+01, 2.70458221e+00, 0., 8.36236000e+00,
+       3.96689606e+00, 7.62939453e-06, 6.96459579e+00, 4.26813507e+00,
+       0., 2.46432476e+01, 3.25012207e-01, 0., 2.20468845e+01,
+       8.85864258e-01, 0., 1.89536686e+01, 1.55406189e+00, 0.,
+       1.63595600e+01, 2.11444092e+00, 0., 1.54000492e+01,
+       2.32170868e+00, 0., 1.46586819e+01, 2.48185730e+00, 0.,
+       1.40266247e+01, 2.61840057e+00, 0., 1.38166294e+01,
+       2.66375732e+00, 7.62939453e-06, 1.14262829e+01, 3.18011475e+00,
+       0., 1.07076435e+01, 3.33535004e+00, 0., 1.04009075e+01,
+       3.40161896e+00, 0., 8.97926903e+00, 3.70871735e+00, 0.,
+       2.39207077e+00, 5.13166809e+00, 0., 2.50129185e+01,
+       1.11717224e-01, 0., 2.11793308e+01, 9.41772461e-01, 0.,
+       1.85390110e+01, 1.51345062e+00, 7.62939453e-06, 1.76706638e+01,
+       1.70145416e+00, 0., 1.65933514e+01, 1.93471527e+00, 0.,
+       1.58445454e+01, 2.09684753e+00, 0., 1.52061634e+01,
+       2.23506927e+00, 0., 1.42545033e+01, 2.44112396e+00, 0.,
+       1.29965496e+01, 2.71349335e+00, 0., 1.26839962e+01,
+       2.78116608e+00, 0., 1.12354908e+01, 3.09480286e+00,
+       7.62939453e-06, 8.68953514e+00, 3.64604187e+00, 7.62939453e-06,
+       2.46971188e+01, 4.66308594e-02, 0., 2.07588902e+01,
+       9.01306152e-01, 0., 1.97649670e+01, 1.11701202e+00, 0.,
+       1.68279018e+01, 1.75440979e+00, 0., 1.40613689e+01,
+       2.35480499e+00, 7.62939453e-06, 1.37459621e+01, 2.42325592e+00,
+       0., 7.89779091e+00, 3.69243622e+00, 0., 2.33593426e+01,
+       2.03971863e-01, 0., 1.90188885e+01, 1.14810944e+00, 0.,
+       1.82548428e+01, 1.31431580e+00, 0., 1.74952717e+01,
+       1.47954559e+00, 0., 1.59893780e+01, 1.80710602e+00, 0.,
+       1.57756863e+01, 1.85358429e+00, 0., 1.34482021e+01,
+       2.35986328e+00, 7.62939453e-06, 1.10595303e+01, 2.87946320e+00,
+       0., 1.04437466e+01, 3.01340485e+00, 0., 9.72911263e+00,
+       3.16885376e+00, 7.62939453e-06, 8.71521568e+00, 3.38939667e+00,
+       0., 6.21591377e+00, 3.93305969e+00, 0., 9.84260559e-01,
+       5.07106018e+00, 7.62939453e-06, 2.27073383e+01, 2.12936401e-01,
+       0., 1.95896931e+01, 8.92669678e-01, 0., 1.53678989e+01,
+       1.81312561e+00, 0., 1.49426022e+01, 1.90585327e+00,
+       7.62939453e-06, 1.42017155e+01, 2.06738281e+00, 0.,
+       1.21082821e+01, 2.52381134e+00, 7.62939453e-06, 1.00488644e+01,
+       2.97280884e+00, 0., 7.62128639e+00, 3.50209045e+00, 0.,
+       4.26135445e+00, 4.23464203e+00, 0., 3.96923828e+00,
+       4.29832458e+00, 0., 2.32693291e+00, 4.65638733e+00, 0.,
+       2.13516617e+00, 4.69820404e+00, 0., 7.06460953e-01,
+       5.00969696e+00, 0., 1.65643864e+01, 1.42230988e+00, 0.,
+       1.31673489e+01, 2.16465759e+00, 7.62939453e-06, 1.07804546e+01,
+       2.68625641e+00, 0., 1.05750103e+01, 2.73115540e+00, 0.,
+       8.13554573e+00, 3.26425934e+00, 0., 5.84163094e+00,
+       3.76554108e+00, 7.62939453e-06, 1.27653141e+01, 2.12427521e+00,
+       0., 1.21398144e+01, 2.26128387e+00, 0., 1.14139538e+01,
+       2.42027283e+00, 0., 6.64587975e+00, 3.46464539e+00, 0.,
+       1.38319340e+01, 1.76170349e+00, 0., 1.09127598e+01,
+       2.40257263e+00, 0., 1.06039448e+01, 2.47036743e+00, 0.,
+       9.68202400e+00, 2.67276764e+00, 0., 8.05958748e+00,
+       3.02895355e+00, 0., 7.45656967e+00, 3.16133881e+00,
+       7.62939453e-06, 2.34997368e+00, 4.28242493e+00, 0.,
+       2.15774536e+00, 4.32463837e+00, 7.62939453e-06, 2.06769428e+01,
+       1.26335144e-01, 0., 1.80332737e+01, 7.08061218e-01, 0.,
+       1.72722187e+01, 8.75526428e-01, 0., 1.44841061e+01,
+       1.48903656e+00, 0., 1.41662693e+01, 1.55897522e+00, 0.,
+       1.30075665e+01, 1.81394196e+00, 0., 1.24843464e+01,
+       1.92907715e+00, 0., 8.67840385e+00, 2.76655579e+00, 0.,
+       7.16775894e+00, 3.09896851e+00, 7.62939453e-06, 1.68592701e+01,
+       8.35525513e-01, 0., 1.61045246e+01, 1.00198364e+00, 0.,
+       1.21872959e+01, 1.86593628e+00, 0., 8.18528938e+00,
+       2.74858093e+00, 0., 1.02401543e+00, 4.32801819e+00, 0.,
+       7.38494873e-01, 4.39099121e+00, 0., 1.93928204e+01,
+       1.44401550e-01, 0., 1.53728085e+01, 1.03305817e+00, 0.,
+       1.31458263e+01, 1.52535248e+00, 0., 1.19946499e+01,
+       1.77983093e+00, 0., 8.60274696e+00, 2.52964020e+00, 0.,
+       1.87540607e+01, 1.53381348e-01, 0., 1.06620884e+01,
+       1.94629669e+00, 0., 8.21027565e+00, 2.48953247e+00, 0.,
+       1.48754749e+01, 8.82301331e-01, 7.62939453e-06, 1.22350140e+01,
+       1.46868896e+00, 0., 1.15054035e+01, 1.63071442e+00, 0.,
+       1.11939983e+01, 1.69987488e+00, 0., 9.34153557e+00,
+       2.11126709e+00, 0., 9.48553085e-01, 3.97513580e+00, 0.,
+       1.81386318e+01, 2.53372192e-02, 0., 1.77012424e+01,
+       1.22703552e-01, 0., 1.40420742e+01, 9.37171936e-01,
+       7.62939453e-06, 1.38300457e+01, 9.84359741e-01, 7.62939453e-06,
+       8.23534203e+00, 2.22966766e+00, 0., 1.70681019e+01,
+       1.31690979e-01, 7.62939453e-06, 1.31074085e+01, 1.01529694e+00,
+       0., 1.06025600e+01, 1.57411957e+00, 0., 1.01898670e+01,
+       1.66618347e+00, 0., 9.26623726e+00, 1.87224579e+00, 0.,
+       7.23780441e+00, 2.32477570e+00, 7.62939453e-06, 6.63566017e+00,
+       2.45911407e+00, 0., 5.14297104e+00, 2.79212952e+00,
+       7.62939453e-06, 1.19689388e+01, 1.13973999e+00, 0.,
+       4.65899849e+00, 2.77430725e+00, 7.62939453e-06, 1.55928555e+01,
+       1.97830200e-01, 0., 1.25089397e+01, 8.88999939e-01, 0.,
+       1.11503963e+01, 1.19347382e+00, 7.62939453e-06, 7.86738777e+00,
+       1.92925262e+00, 0., 1.17912083e+01, 9.20028687e-01, 0.,
+       5.86910057e+00, 2.25032043e+00, 7.62939453e-06, 5.17304230e+00,
+       2.40666962e+00, 7.62939453e-06, 4.77704811e+00, 2.49563599e+00,
+       7.62939453e-06, 3.98886681e+00, 2.67268372e+00, 0.,
+       9.81735229e-01, 3.34818268e+00, 0., 1.49854488e+01,
+       7.08465576e-02, 7.62939453e-06, 1.12847157e+01, 9.04045105e-01,
+       0., 1.10764713e+01, 9.50927734e-01, 7.62939453e-06,
+       6.37973785e+00, 2.00837708e+00, 0., 1.46821537e+01,
+       7.43103027e-03, 0., 1.05719280e+01, 9.34944153e-01,
+       7.62939453e-06, 9.43638039e+00, 1.19118500e+00, 0.,
+       7.70141792e+00, 1.58270264e+00, 7.62939453e-06, 6.79259872e+00,
+       1.78778076e+00, 0., 4.00705338e+00, 2.41636658e+00, 0.,
+       1.35264950e+01, 1.36917114e-01, 0., 1.00686588e+01,
+       9.18998718e-01, 0., 8.83440208e+00, 1.19815063e+00, 0.,
+       3.72117996e+00, 2.35462952e+00, 0., 1.09785271e+00,
+       2.94795227e+00, 0., 8.09829712e-01, 3.01309967e+00, 0.,
+       1.28016224e+01, 1.69754028e-01, 7.62939453e-06, 9.36076927e+00,
+       9.49760437e-01, 0., 8.03071404e+00, 1.25125885e+00, 0.,
+       6.31255150e+00, 1.64075470e+00, 0., 2.36167526e+00,
+       2.53636932e+00, 7.62939453e-06, 7.23099327e+00, 1.30411530e+00,
+       7.62939453e-06, 5.62238121e+00, 1.66960144e+00, 7.62939453e-06,
+       4.52847290e+00, 1.91814423e+00, 0., 1.15704784e+01,
+       1.87286377e-01, -7.62939453e-06, 6.53586388e+00, 1.33379364e+00,
+       0., 5.03446960e+00, 1.67568970e+00, 0., 1.08536434e+01,
+       2.19841003e-01, 0., 7.55907440e+00, 9.71794128e-01,
+       7.62939453e-06, 7.15329933e+00, 1.06439972e+00, 0.,
+       3.95403671e+00, 1.79460907e+00, 0., 3.75681686e+00,
+       1.83962250e+00, 0., 6.65925598e+00, 1.04845428e+00, 0.,
+       5.65381622e+00, 1.27846527e+00, 0., 1.03535843e+00,
+       2.33498383e+00, 0., 7.46417999e-01, 2.40107727e+00, 0.,
+       9.63570213e+00, 2.37113953e-01, -7.62939453e-06, 5.96535110e+00,
+       1.07865143e+00, 7.62939453e-06, 4.76563454e+00, 1.35371399e+00,
+       7.62939453e-06, 2.30320930e+00, 1.91829681e+00, 0.,
+       8.92677879e+00, 2.69378662e-01, 0., 5.47441483e+00,
+       1.06272888e+00, 0., 3.78368759e+00, 1.45125580e+00,
+       7.62939453e-06, 4.98469543e+00, 1.04684448e+00, -7.62939453e-06,
+       3.99053955e+00, 1.27582550e+00, 7.62939453e-06, 9.59020615e-01,
+       1.97404480e+00, 0., 7.72182655e+00, 2.86399841e-01,
+       7.62939453e-06, 4.19805717e+00, 1.09983063e+00, 0.,
+       2.22885704e+00, 1.55440521e+00, 0., 3.90974617e+00,
+       1.03814697e+00, -7.62939453e-06, 5.83922386e+00, 2.02842712e-01,
+       0., 5.53693199e+00, 2.73246765e-01, 7.62939453e-06,
+       5.13503075e+00, 3.66867065e-01, 0., 9.92641449e-01,
+       1.33178711e+00, 7.62939453e-06, 4.84434700e+00, 3.05076599e-01,
+       0., 5.55790710e+00, 8.42285156e-03, 7.62939453e-06,
+       4.86418533e+00, 4.08401489e-02, 0., 3.46768951e+00,
+       3.68347168e-01, 0., 3.07159233e+00, 4.61242676e-01, 0.,
+       1.11018181e+00, 9.21234131e-01, 0., 8.18679810e-01,
+       9.89593506e-01, -7.62939453e-06, 2.78357697e+00, 3.99803162e-01,
+       0., 3.48527527e+00, 1.05308533e-01, 0., 1.51431847e+00,
+       5.69610596e-01, 0., 2.80005646e+00, 1.37336731e-01, 0.,
+       1.71734428e+00, 3.92974854e-01, 0., 8.38602066e-01,
+       6.00440979e-01, 0., 8.51938248e-01, 3.39996338e-01, 0.,
+       2.87357330e-01, 8.74023438e-02, 0., 9.91840363e-02,
+       3.20434570e-03, 1.86299744e+01, 2.57879086e+01, 7.50000000e+00,
+       1.79252014e+01, 2.47886448e+01, 7.50000000e+00, 1.74275818e+01,
+       2.49909801e+01, 7.50000000e+00, 1.78055801e+01, 2.32187252e+01,
+       7.50000000e+00, 1.79208221e+01, 2.16211414e+01, 7.50000000e+00,
+       1.80549545e+01, 2.09930286e+01, 7.49999237e+00, 1.69865341e+01,
+       2.49392796e+01, 7.50000000e+00, 1.70676270e+01, 2.45599880e+01,
+       7.49999237e+00, 1.73643646e+01, 2.31720028e+01, 7.50000000e+00,
+       1.71042786e+01, 2.33374920e+01, 7.50000000e+00, 1.66559601e+01,
+       2.43836231e+01, 7.50000000e+00, 1.71407013e+01, 2.21216221e+01,
+       7.50000763e+00, 1.63430099e+01, 2.47992840e+01, 7.50000000e+00,
+       1.74710999e+01, 1.95412655e+01, 7.50000000e+00, 1.65967484e+01,
+       2.25784740e+01, 7.50000000e+00, 1.68651657e+01, 2.13288441e+01,
+       7.50000763e+00, 1.71061020e+01, 2.02071934e+01, 7.50000000e+00,
+       1.65539322e+01, 2.17446232e+01, 7.50000000e+00, 1.67415314e+01,
+       2.08723316e+01, 7.50000000e+00, 1.70622482e+01, 1.93809643e+01,
+       7.50000000e+00, 1.61477890e+01, 2.15780468e+01, 7.50000000e+00,
+       1.63352432e+01, 2.07084141e+01, 7.50000000e+00, 1.65757217e+01,
+       1.95928173e+01, 7.50000000e+00, 1.70813828e+01, 1.72468777e+01,
+       7.49999237e+00, 1.72140045e+01, 1.66315937e+01, 7.50000000e+00,
+       1.58651581e+01, 2.18677731e+01, 7.50000000e+00, 1.71438065e+01,
+       1.59426479e+01, 7.50000000e+00, 1.72760162e+01, 1.53300076e+01,
+       7.50000000e+00, 1.49640198e+01, 2.50224705e+01, 7.49999237e+00,
+       1.53682175e+01, 2.31515331e+01, 7.50000000e+00, 1.55831070e+01,
+       2.21569233e+01, 7.50000000e+00, 1.57439499e+01, 2.14124203e+01,
+       7.50000000e+00, 1.59312592e+01, 2.05454197e+01, 7.50000000e+00,
+       1.51135254e+01, 2.33150501e+01, 7.50000000e+00, 1.53016205e+01,
+       2.24454861e+01, 7.50000000e+00, 1.72412949e+01, 1.34776707e+01,
+       7.50000763e+00, 1.68559647e+01, 1.42580166e+01, 7.50000763e+00,
+       1.71978226e+01, 1.26793118e+01, 7.50000000e+00, 1.72592697e+01,
+       1.14014187e+01, 7.50000000e+00, 1.42183151e+01, 2.44237499e+01,
+       7.50000000e+00, 1.52902069e+01, 1.94848957e+01, 7.50000000e+00,
+       1.69544678e+01, 1.18166332e+01, 7.50000000e+00, 1.38310623e+01,
+       2.52058239e+01, 7.50000000e+00, 1.52243881e+01, 1.87931957e+01,
+       7.50000000e+00, 1.69641418e+01, 1.07861423e+01, 7.50000000e+00,
+       1.71207352e+01, 1.00654202e+01, 7.50000763e+00, 1.73551483e+01,
+       8.98657417e+00, 7.50000000e+00, 1.81581421e+01, 5.29085350e+00,
+       7.50000000e+00, 1.82097092e+01, 5.05349731e+00, 7.50000000e+00,
+       1.36871490e+01, 2.48701878e+01, 7.50000000e+00, 1.47596970e+01,
+       1.99393787e+01, 7.50000000e+00, 1.53445511e+01, 1.72506924e+01,
+       7.50000000e+00, 1.72339478e+01, 8.56463814e+00, 7.50000000e+00,
+       1.77005005e+01, 6.41983032e+00, 7.50000000e+00, 1.77780304e+01,
+       6.06338501e+00, 7.50000000e+00, 1.78296890e+01, 5.82592010e+00,
+       7.50000000e+00, 1.81647415e+01, 4.28553772e+00, 7.50000763e+00,
+       1.34358902e+01, 2.50307636e+01, 7.50000000e+00, 1.37320938e+01,
+       2.36706219e+01, 7.50000000e+00, 1.69053574e+01, 9.09869194e+00,
+       7.50000000e+00, 1.71910172e+01, 7.78683662e+00, 7.50000000e+00,
+       1.53983383e+01, 1.50394650e+01, 7.50000000e+00, 1.72517471e+01,
+       6.53788376e+00, 7.50000000e+00, 1.80754089e+01, 2.75973892e+00,
+       7.50000000e+00, 1.30160141e+01, 2.49801807e+01, 7.50000000e+00,
+       1.34194870e+01, 2.31315517e+01, 7.50000000e+00, 1.53592834e+01,
+       1.42435818e+01, 7.49999237e+00, 1.29819183e+01, 2.41540699e+01,
+       7.50000000e+00, 1.54777832e+01, 1.27308712e+01, 7.50000000e+00,
+       1.72436371e+01, 4.64885330e+00, 7.50000000e+00, 1.76031494e+01,
+       3.00337791e+00, 7.50000000e+00, 1.79868469e+01, 1.24727821e+00,
+       7.50000000e+00, 1.36167068e+01, 2.02742748e+01, 7.50000000e+00,
+       1.54125900e+01, 1.20638638e+01, 7.50000000e+00, 1.66344910e+01,
+       6.47760391e+00, 7.50000000e+00, 1.69182129e+01, 5.18045807e+00,
+       7.50000000e+00, 1.71497269e+01, 4.12203217e+00, 7.50000000e+00,
+       1.75087357e+01, 2.48070335e+00, 7.50000000e+00, 1.76621933e+01,
+       1.77917862e+00, 7.50000000e+00, 1.24038696e+01, 2.48433132e+01,
+       7.50000000e+00, 1.53998947e+01, 1.11611156e+01, 7.50000000e+00,
+       1.76189270e+01, 1.02725983e+00, 7.50000763e+00, 1.31741257e+01,
+       2.03584423e+01, 7.50000763e+00, 1.43397369e+01, 1.50412197e+01,
+       7.49999237e+00, 1.55173950e+01, 9.66890907e+00, 7.50000000e+00,
+       1.64492188e+01, 5.41813660e+00, 7.50000000e+00, 1.65264587e+01,
+       5.06576920e+00, 7.50000000e+00, 1.68348083e+01, 3.65916824e+00,
+       7.50000000e+00, 1.70398178e+01, 2.72396088e+00, 7.50000000e+00,
+       1.73465118e+01, 1.32492828e+00, 7.49999237e+00, 1.26868286e+01,
+       2.16163349e+01, 7.50000000e+00, 1.72021484e+01, 1.04078102e+00,
+       7.50000763e+00, 1.26271286e+01, 2.09275837e+01, 7.50000000e+00,
+       1.27604218e+01, 2.03209209e+01, 7.50000000e+00, 1.62910538e+01,
+       4.24986458e+00, 7.50000000e+00, 1.63680573e+01, 3.89936829e+00,
+       7.50000000e+00, 1.43615952e+01, 1.20849514e+01, 7.49999237e+00,
+       1.54272842e+01, 7.23926163e+00, 7.50000000e+00, 1.13050385e+01,
+       2.50249081e+01, 7.50000000e+00, 1.14126129e+01, 2.45362759e+01,
+       7.50000000e+00, 1.22956390e+01, 2.05255108e+01, 7.50000000e+00,
+       1.43253326e+01, 1.13064671e+01, 7.50000000e+00, 1.58007889e+01,
+       4.60487747e+00, 7.50000000e+00, 1.65428162e+01, 1.23454666e+00,
+       7.50000000e+00, 1.18373871e+01, 2.16559467e+01, 7.50000000e+00,
+       1.21838608e+01, 2.00839062e+01, 7.50000000e+00, 1.27409668e+01,
+       1.75562229e+01, 7.50000000e+00, 1.47308044e+01, 8.52803230e+00,
+       7.49999237e+00, 1.48602676e+01, 7.94055367e+00, 7.50000000e+00,
+       1.49637375e+01, 7.47113991e+00, 7.49999237e+00, 1.15930252e+01,
+       2.18170414e+01, 7.50000000e+00, 1.28136902e+01, 1.62845478e+01,
+       7.50000000e+00, 1.32347107e+01, 1.43763866e+01, 7.50000000e+00,
+       1.37845230e+01, 1.18844280e+01, 7.50000000e+00, 1.49522476e+01,
+       6.59187698e+00, 7.50000000e+00, 1.56973419e+01, 3.21489906e+00,
+       7.50000000e+00, 1.15892639e+01, 2.08908863e+01, 7.49999237e+00,
+       1.29911194e+01, 1.45440083e+01, 7.50000000e+00, 1.34103699e+01,
+       1.26458263e+01, 7.50000000e+00, 1.42952957e+01, 8.63932610e+00,
+       7.50000000e+00, 1.49922867e+01, 5.48369598e+00, 7.49999237e+00,
+       1.54285431e+01, 3.50850677e+00, 7.50000000e+00, 1.55820541e+01,
+       2.81352425e+00, 7.50000000e+00, 1.58628311e+01, 1.54227257e+00,
+       7.50000000e+00, 1.60156403e+01, 8.50437164e-01, 7.50000000e+00,
+       1.21421051e+01, 1.74518185e+01, 7.50000000e+00, 1.26429520e+01,
+       1.51866550e+01, 7.50000000e+00, 1.27217865e+01, 1.48300610e+01,
+       7.50000763e+00, 1.32980499e+01, 1.22238636e+01, 7.50000000e+00,
+       1.33763580e+01, 1.18696690e+01, 7.50000000e+00, 1.41560440e+01,
+       8.34342384e+00, 7.50000000e+00, 1.43887100e+01, 7.29107857e+00,
+       7.50000000e+00, 1.55692444e+01, 1.95187759e+00, 7.50000000e+00,
+       1.57730789e+01, 1.02999496e+00, 7.50000000e+00, 1.17407913e+01,
+       1.83332767e+01, 7.49999237e+00, 1.33685303e+01, 1.09792385e+01,
+       7.50000000e+00, 1.43528366e+01, 6.53224182e+00, 7.50000000e+00,
+       1.04605713e+01, 2.31818905e+01, 7.49999237e+00, 1.12335663e+01,
+       1.96932468e+01, 7.49999237e+00, 1.26829987e+01, 1.31516781e+01,
+       7.50000000e+00, 1.36460648e+01, 8.80523872e+00, 7.50000000e+00,
+       9.84349823e+00, 2.50330029e+01, 7.50000000e+00, 1.07527084e+01,
+       2.09338665e+01, 7.50000000e+00, 1.20484009e+01, 1.50923786e+01,
+       7.50000000e+00, 1.24154510e+01, 1.34375210e+01, 7.50000000e+00,
+       1.30414886e+01, 1.06150875e+01, 7.50000000e+00, 1.51249237e+01,
+       1.22204590e+00, 7.50000000e+00, 1.51758041e+01, 9.92671967e-01,
+       7.50000000e+00, 9.92421722e+00, 2.37399731e+01, 7.49999237e+00,
+       1.15180664e+01, 1.65617046e+01, 7.50000000e+00, 1.15970840e+01,
+       1.62058353e+01, 7.50000000e+00, 1.19387512e+01, 1.46670704e+01,
+       7.50000000e+00, 1.31381836e+01, 9.26516151e+00, 7.50000000e+00,
+       1.01378784e+01, 2.18538761e+01, 7.50000000e+00, 1.02178268e+01,
+       2.14941807e+01, 7.50000000e+00, 1.06961670e+01, 1.93421459e+01,
+       7.50000000e+00, 1.14882507e+01, 1.57785702e+01, 7.50000000e+00,
+       1.23521805e+01, 1.18917179e+01, 7.50000000e+00, 1.25604706e+01,
+       1.09546223e+01, 7.50000000e+00, 1.31309738e+01, 8.38791466e+00,
+       7.50000000e+00, 1.33891754e+01, 7.22620010e+00, 7.50000763e+00,
+       1.36724319e+01, 5.95189285e+00, 7.50000000e+00, 1.37752151e+01,
+       5.48942947e+00, 7.50000000e+00, 1.40060959e+01, 4.45068550e+00,
+       7.50000763e+00, 1.03766403e+01, 1.98613377e+01, 7.50000000e+00,
+       1.08266907e+01, 1.78386631e+01, 7.50000000e+00, 1.17729645e+01,
+       1.35857868e+01, 7.49999237e+00, 1.18252716e+01, 1.33507175e+01,
+       7.49999237e+00, 1.30979843e+01, 7.63063812e+00, 7.50000000e+00,
+       1.32784576e+01, 6.81957436e+00, 7.50000000e+00, 1.33814316e+01,
+       6.35678673e+00, 7.50000000e+00, 1.44814911e+01, 1.41270065e+00,
+       7.50000000e+00, 9.89806366e+00, 2.10958233e+01, 7.50000000e+00,
+       1.01106491e+01, 2.01413822e+01, 7.50000000e+00, 1.09037781e+01,
+       1.65805073e+01, 7.50000000e+00, 1.12454834e+01, 1.50463543e+01,
+       7.50000000e+00, 1.14289856e+01, 1.42224865e+01, 7.50000000e+00,
+       1.23932343e+01, 9.89329720e+00, 7.50000000e+00, 1.37835770e+01,
+       3.65110397e+00, 7.50000000e+00, 1.38857803e+01, 3.19227219e+00,
+       7.49999237e+00, 9.57929230e+00, 2.16134892e+01, 7.50000000e+00,
+       9.97787476e+00, 1.98258038e+01, 7.50000000e+00, 1.02691422e+01,
+       1.85194149e+01, 7.50000000e+00, 1.05331879e+01, 1.73351383e+01,
+       7.50000000e+00, 1.13211060e+01, 1.38013134e+01, 7.50000000e+00,
+       1.32378464e+01, 5.20458221e+00, 7.50000000e+00, 1.38769531e+01,
+       2.33823013e+00, 7.49999237e+00, 8.56558990e+00, 2.52459126e+01,
+       7.50000000e+00, 9.95143127e+00, 1.90367031e+01, 7.50000763e+00,
+       1.01893387e+01, 1.79708309e+01, 7.50000000e+00, 1.04529953e+01,
+       1.67895374e+01, 7.50000000e+00, 1.05845490e+01, 1.62000751e+01,
+       7.50000000e+00, 1.11874771e+01, 1.34987049e+01, 7.50000000e+00,
+       1.12919617e+01, 1.30305920e+01, 7.50000000e+00, 1.18646011e+01,
+       1.04648838e+01, 7.50000000e+00, 1.20202026e+01, 9.76775169e+00,
+       7.50000000e+00, 1.23048019e+01, 8.49255180e+00, 7.50000000e+00,
+       1.25370560e+01, 7.45198059e+00, 7.50000000e+00, 1.26658325e+01,
+       6.87495041e+00, 7.50000000e+00, 1.28201599e+01, 6.18353081e+00,
+       7.50000000e+00, 1.29742432e+01, 5.49320602e+00, 7.50000000e+00,
+       1.35625916e+01, 2.85708427e+00, 7.50000000e+00, 1.38172989e+01,
+       1.71592712e+00, 7.49999237e+00, 8.59567261e+00, 2.42014751e+01,
+       7.50000000e+00, 8.99639130e+00, 2.24079266e+01, 7.49999237e+00,
+       9.66065216e+00, 1.94347248e+01, 7.50000000e+00, 1.12108154e+01,
+       1.24964733e+01, 7.49999237e+00, 1.14451370e+01, 1.14476681e+01,
+       7.50000000e+00, 1.26854401e+01, 5.89618683e+00, 7.50000000e+00,
+       1.29162521e+01, 4.86311531e+00, 7.50000000e+00, 1.30186539e+01,
+       4.40475845e+00, 7.50000000e+00, 8.91884613e+00, 2.18509197e+01,
+       7.50000000e+00, 9.05186462e+00, 2.12561855e+01, 7.50000000e+00,
+       9.29083252e+00, 2.01876812e+01, 7.50000000e+00, 1.08432388e+01,
+       1.32464542e+01, 7.50000000e+00, 1.13639526e+01, 1.09181728e+01,
+       7.49999237e+00, 1.33431396e+01, 2.06855774e+00, 7.50000000e+00,
+       1.35718765e+01, 1.04586983e+00, 7.50000000e+00, 8.01419830e+00,
+       2.49918842e+01, 7.50000000e+00, 8.60211182e+00, 2.23658504e+01,
+       7.50000000e+00, 9.05401611e+00, 2.03472462e+01, 7.50000000e+00,
+       1.07109680e+01, 1.29460850e+01, 7.50000000e+00, 1.09714203e+01,
+       1.17826786e+01, 7.50000000e+00, 1.18002701e+01, 8.08045006e+00,
+       7.50000000e+00, 1.18518372e+01, 7.85009575e+00, 7.50000763e+00,
+       1.19806442e+01, 7.27475548e+00, 7.50000000e+00, 1.21349792e+01,
+       6.58534622e+00, 7.50000000e+00, 1.25709534e+01, 4.63793182e+00,
+       7.50000763e+00, 1.32085800e+01, 1.78987694e+00, 7.50000000e+00,
+       7.93850708e+00, 2.44297543e+01, 7.50000000e+00, 8.55211639e+00,
+       2.16916714e+01, 7.50000000e+00, 9.13552856e+00, 1.90883923e+01,
+       7.50000000e+00, 9.29403687e+00, 1.83810635e+01, 7.50000000e+00,
+       9.39957428e+00, 1.79101391e+01, 7.50000000e+00, 9.47865295e+00,
+       1.75572758e+01, 7.50000000e+00, 1.02136688e+01, 1.42774563e+01,
+       7.50000000e+00, 1.22070389e+01, 5.38257980e+00, 7.50000000e+00,
+       7.67588043e+00, 2.47043362e+01, 7.50000000e+00, 8.58196259e+00,
+       2.06653309e+01, 7.50000000e+00, 9.53237915e+00, 1.64285755e+01,
+       7.50000000e+00, 9.61117554e+00, 1.60773487e+01, 7.50000000e+00,
+       9.89954376e+00, 1.47918987e+01, 7.50000000e+00, 1.05517960e+01,
+       1.18843403e+01, 7.50000000e+00, 1.11480560e+01, 9.22633934e+00,
+       7.50000000e+00, 1.14319534e+01, 7.96082115e+00, 7.50000000e+00,
+       1.16893158e+01, 6.81352806e+00, 7.50000000e+00, 1.29914474e+01,
+       1.00900459e+00, 7.50000000e+00, 7.41377258e+00, 2.49783916e+01,
+       7.50000000e+00, 8.58518219e+00, 1.97618122e+01, 7.50000000e+00,
+       8.74385834e+00, 1.90552006e+01, 7.50000000e+00, 9.27094269e+00,
+       1.67079830e+01, 7.50000000e+00, 1.04986038e+01, 1.12408390e+01,
+       7.50000000e+00, 1.05764542e+01, 1.08941784e+01, 7.50000000e+00,
+       1.10680466e+01, 8.70502281e+00, 7.50000000e+00, 1.13515167e+01,
+       7.44261169e+00, 7.50000763e+00, 8.13848877e+00, 2.08640041e+01,
+       7.50000000e+00, 9.40361023e+00, 1.52357235e+01, 7.50000000e+00,
+       9.66515350e+00, 1.40721645e+01, 7.50000000e+00, 9.87389374e+00,
+       1.31435413e+01, 7.50000000e+00, 1.10398560e+01, 7.95640755e+00,
+       7.50000000e+00, 9.97813416e+00, 1.18049450e+01, 7.49999237e+00,
+       1.00819855e+01, 1.13433704e+01, 7.50000000e+00, 1.06512451e+01,
+       8.81336784e+00, 7.50000000e+00, 1.14989929e+01, 5.04568481e+00,
+       7.50000000e+00, 9.09293365e+00, 1.48641720e+01, 7.50000763e+00,
+       1.02370071e+01, 9.78460121e+00, 7.50000000e+00, 1.05467224e+01,
+       8.40944099e+00, 7.50000000e+00, 1.05982590e+01, 8.18066978e+00,
+       7.49999237e+00, 1.08040848e+01, 7.26677704e+00, 7.50000000e+00,
+       8.54549408e+00, 1.64214840e+01, 7.50000000e+00, 1.11350784e+01,
+       4.93528938e+00, 7.50000000e+00, 6.37864685e+00, 2.51536694e+01,
+       7.50000000e+00, 7.41666412e+00, 2.05540676e+01, 7.50000000e+00,
+       7.68109131e+00, 1.93823452e+01, 7.50000000e+00, 8.12902069e+00,
+       1.73975239e+01, 7.50000000e+00, 8.88850403e+00, 1.40321598e+01,
+       7.49999237e+00, 9.22708130e+00, 1.25318851e+01, 7.49999237e+00,
+       9.61630249e+00, 1.08071537e+01, 7.50000000e+00, 1.05442352e+01,
+       6.69538307e+00, 7.50000000e+00, 1.17426300e+01, 1.38507843e+00,
+       7.50000000e+00, 1.18186340e+01, 1.04832458e+00, 7.50000000e+00,
+       6.75989532e+00, 2.25910206e+01, 7.50000000e+00, 8.23809814e+00,
+       1.60473461e+01, 7.50000000e+00, 1.01325760e+01, 7.66090965e+00,
+       7.50000000e+00, 1.08751907e+01, 4.37352562e+00, 7.50000000e+00,
+       1.15108871e+01, 1.55941963e+00, 7.50000000e+00, 6.26189423e+00,
+       2.39241047e+01, 7.49999237e+00, 6.82029724e+00, 2.14545345e+01,
+       7.50000000e+00, 6.97927856e+00, 2.07514706e+01, 7.50000000e+00,
+       7.05867004e+00, 2.04003544e+01, 7.50000000e+00, 9.84973907e+00,
+       8.05703163e+00, 7.50000000e+00, 1.01578979e+01, 6.69420052e+00,
+       7.50000000e+00, 6.21714783e+00, 2.32540951e+01, 7.50000000e+00,
+       1.02598038e+01, 5.39319229e+00, 7.50000000e+00, 1.12514801e+01,
+       1.01187325e+00, 7.50000000e+00, 5.77325439e+00, 2.43494167e+01,
+       7.50000000e+00, 5.90654755e+00, 2.37610989e+01, 7.50000000e+00,
+       6.59682465e+00, 2.07143421e+01, 7.50000000e+00, 7.80654144e+00,
+       1.53748760e+01, 7.50000000e+00, 8.01544952e+00, 1.44528484e+01,
+       7.49999237e+00, 8.09365845e+00, 1.41075878e+01, 7.50000000e+00,
+       8.24992371e+00, 1.34178753e+01, 7.50000000e+00, 8.48384857e+00,
+       1.23853397e+01, 7.50000000e+00, 1.02081909e+01, 4.77445030e+00,
+       7.50000000e+00, 6.23426056e+00, 2.14545879e+01, 7.50000000e+00,
+       6.34017181e+00, 2.09875126e+01, 7.50000763e+00, 7.99385071e+00,
+       1.36956501e+01, 7.50000000e+00, 8.56491089e+00, 1.11775265e+01,
+       7.50000000e+00, 8.72009277e+00, 1.04932690e+01, 7.50000000e+00,
+       9.33837891e+00, 7.76692390e+00, 7.49999237e+00, 1.04365463e+01,
+       2.92451477e+00, 7.50000000e+00, 1.06141663e+01, 2.14130402e+00,
+       7.50000000e+00, 1.09179001e+01, 8.01948547e-01, 7.50000000e+00,
+       5.49988556e+00, 2.38335361e+01, 7.50000000e+00, 5.81892395e+00,
+       2.24280262e+01, 7.50000000e+00, 6.21632385e+00, 2.06774044e+01,
+       7.50000000e+00, 7.16368103e+00, 1.65039845e+01, 7.50000763e+00,
+       7.39913940e+00, 1.54667835e+01, 7.50000000e+00, 9.59574127e+00,
+       5.79020691e+00, 7.50000000e+00, 9.90194702e+00, 4.44123459e+00,
+       7.50000000e+00, 9.26454163e+00, 6.40966034e+00, 7.50000000e+00,
+       4.93533325e+00, 2.46083889e+01, 7.50000000e+00, 5.67910004e+00,
+       2.13382626e+01, 7.49999237e+00, 5.96978760e+00, 2.00601482e+01,
+       7.50000000e+00, 7.12420654e+00, 1.49843998e+01, 7.50000000e+00,
+       8.93370819e+00, 7.02843857e+00, 7.50000000e+00, 9.39372253e+00,
+       5.00585556e+00, 7.50000000e+00, 5.18588257e+00, 2.26574917e+01,
+       7.50000000e+00, 7.10459137e+00, 1.42294140e+01, 7.50000000e+00,
+       7.31263733e+00, 1.33155231e+01, 7.50000000e+00, 9.08927917e+00,
+       5.51151085e+00, 7.50000000e+00, 9.82657623e+00, 2.27287102e+00,
+       7.50000000e+00, 1.01048126e+01, 1.05072403e+00, 7.50000000e+00,
+       6.27636719e+00, 1.70264263e+01, 7.50000000e+00, 4.33205414e+00,
+       2.47134037e+01, 7.50000000e+00, 4.54496765e+00, 2.37798939e+01,
+       7.50000000e+00, 5.33946991e+00, 2.02966518e+01, 7.50000000e+00,
+       5.65552521e+00, 1.89109936e+01, 7.50000000e+00, 6.51959991e+00,
+       1.51227551e+01, 7.49999237e+00, 4.10528564e+00, 2.48649349e+01,
+       7.49999237e+00, 4.68978119e+00, 2.23048038e+01, 7.50000000e+00,
+       8.73969269e+00, 4.56596375e+00, 7.50000000e+00, 4.56944275e+00,
+       2.19948368e+01, 7.50000000e+00, 4.86013794e+00, 2.07227688e+01,
+       7.50000000e+00, 5.12368011e+00, 1.95695171e+01, 7.50000000e+00,
+       6.43116760e+00, 1.38480587e+01, 7.50000000e+00, 6.69063568e+00,
+       1.27126522e+01, 7.50000000e+00, 9.29933929e+00, 1.29716873e+00,
+       7.50000000e+00, 9.37504578e+00, 9.65921402e-01, 7.50000000e+00,
+       3.89273834e+00, 2.41197872e+01, 7.50000000e+00, 3.97245789e+00,
+       2.37712612e+01, 7.50000000e+00, 4.07865143e+00, 2.33069859e+01,
+       7.50000000e+00, 4.63437653e+00, 2.08774929e+01, 7.50000000e+00,
+       6.07550812e+00, 1.45771732e+01, 7.50000000e+00, 6.12752533e+00,
+       1.43497601e+01, 7.50000000e+00, 6.33533478e+00, 1.34412937e+01,
+       7.50000000e+00, 6.72380066e+00, 1.17429676e+01, 7.50000000e+00,
+       8.31365204e+00, 4.79244995e+00, 7.50000000e+00, 3.98596191e+00,
+       2.28800755e+01, 7.50000000e+00, 4.96181488e+00, 1.86178226e+01,
+       7.50000000e+00, 5.27629852e+00, 1.72442608e+01, 7.50000000e+00,
+       8.82369995e+00, 1.75030136e+00, 7.50000000e+00, 3.25634766e+00,
+       2.52352848e+01, 7.50000000e+00, 3.99940491e+00, 2.19928761e+01,
+       7.50000000e+00, 4.57943726e+00, 1.94618206e+01, 7.49999237e+00,
+       6.27397156e+00, 1.20674992e+01, 7.50000000e+00, 6.84109497e+00,
+       9.59277916e+00, 7.50000000e+00, 7.86405945e+00, 5.12894058e+00,
+       7.50000000e+00, 8.04200745e+00, 4.35246086e+00, 7.50000000e+00,
+       8.85144043e+00, 8.20426941e-01, 7.50000000e+00, 3.21827698e+00,
+       2.45733051e+01, 7.50000000e+00, 4.51276398e+00, 1.89299145e+01,
+       7.50000000e+00, 4.72254944e+00, 1.80153522e+01, 7.50000000e+00,
+       7.23201752e+00, 7.07519341e+00, 7.50000000e+00, 7.28310394e+00,
+       6.85247803e+00, 7.50000000e+00, 7.81793976e+00, 4.52084351e+00,
+       7.50000000e+00, 2.96781921e+00, 2.48396549e+01, 7.50000000e+00,
+       3.73616791e+00, 2.14931240e+01, 7.50000000e+00, 3.99977112e+00,
+       2.03449841e+01, 7.50000000e+00, 4.18389130e+00, 1.95430622e+01,
+       7.50000000e+00, 5.17758179e+00, 1.52150135e+01, 7.50000000e+00,
+       5.28161621e+00, 1.47618961e+01, 7.50000000e+00, 6.80373383e+00,
+       8.13227654e+00, 7.50000763e+00, 2.69122314e+00, 2.52212811e+01,
+       7.50000000e+00, 3.30141449e+00, 2.25660534e+01, 7.50000000e+00,
+       3.43359375e+00, 2.19909344e+01, 7.50000000e+00, 4.51092529e+00,
+       1.73029156e+01, 7.50000000e+00, 7.04038239e+00, 6.29601669e+00,
+       7.50000000e+00, 8.13040924e+00, 1.55281067e+00, 7.50000763e+00,
+       8.25639343e+00, 1.00463295e+00, 7.49999237e+00, 3.21068573e+00,
+       2.21433887e+01, 7.50000763e+00, 3.47453308e+00, 2.09964008e+01,
+       7.50000000e+00, 4.05255890e+00, 1.84834423e+01, 7.49999237e+00,
+       4.60125732e+00, 1.60979900e+01, 7.50000000e+00, 4.96540070e+00,
+       1.45148373e+01, 7.50000000e+00, 7.17391205e+00, 4.91344070e+00,
+       7.50000000e+00, 2.35226440e+00, 2.50580273e+01, 7.50000000e+00,
+       2.40541840e+00, 2.48271618e+01, 7.50000000e+00, 2.61775208e+00,
+       2.39048939e+01, 7.49999237e+00, 4.06569672e+00, 1.76157894e+01,
+       7.49999237e+00, 4.17020416e+00, 1.71618710e+01, 7.50000000e+00,
+       5.41590881e+00, 1.17511463e+01, 7.50000000e+00, 5.46749115e+00,
+       1.15271435e+01, 7.50000000e+00, 6.34020233e+00, 7.73653221e+00,
+       7.50000763e+00, 6.49343109e+00, 7.07101059e+00, 7.50000000e+00,
+       2.31622314e+00, 2.44005985e+01, 7.50000000e+00, 2.71347809e+00,
+       2.26766949e+01, 7.50000000e+00, 4.05268860e+00, 1.68651562e+01,
+       7.50000000e+00, 5.37447357e+00, 1.11293507e+01, 7.49999237e+00,
+       5.83687592e+00, 9.12274361e+00, 7.49999237e+00, 6.04170227e+00,
+       8.23386955e+00, 7.50000000e+00, 6.11840820e+00, 7.90101051e+00,
+       7.50000000e+00, 6.45011902e+00, 6.46154594e+00, 7.50000763e+00,
+       6.78073883e+00, 5.02683258e+00, 7.50000000e+00, 2.78234863e+00,
+       2.15691509e+01, 7.50000000e+00, 4.86944580e+00, 1.25204639e+01,
+       7.50000000e+00, 5.30747223e+00, 1.06213970e+01, 7.50000000e+00,
+       5.74359131e+00, 8.73054695e+00, 7.50000000e+00, 6.43241119e+00,
+       5.74419212e+00, 7.50000000e+00, 6.71169281e+00, 4.53338051e+00,
+       7.50000000e+00, 1.79405975e+00, 2.50447674e+01, 7.50000000e+00,
+       2.16519165e+00, 2.34371891e+01, 7.50000000e+00, 2.50861359e+00,
+       2.19496479e+01, 7.50000000e+00, 2.66672516e+00, 2.12647686e+01,
+       7.50000000e+00, 4.28633881e+00, 1.42492237e+01, 7.50000000e+00,
+       5.65064240e+00, 8.33967018e+00, 7.50000000e+00, 5.98246765e+00,
+       6.90228844e+00, 7.50000000e+00, 6.21157074e+00, 5.90995026e+00,
+       7.50000000e+00, 6.36400604e+00, 5.24965286e+00, 7.50000000e+00,
+       1.78575134e+00, 2.42750721e+01, 7.50000000e+00, 1.94464111e+00,
+       2.35874386e+01, 7.50000000e+00, 2.26168060e+00, 2.22153530e+01,
+       7.50000000e+00, 2.86664581e+00, 1.95973644e+01, 7.50000000e+00,
+       4.55710602e+00, 1.22816486e+01, 7.49999237e+00, 5.32788849e+00,
+       8.94587517e+00, 7.50000763e+00, 5.60905457e+00, 7.72912407e+00,
+       7.49999237e+00, 5.94031525e+00, 6.29550552e+00, 7.50000000e+00,
+       6.09284973e+00, 5.63543129e+00, 7.50000000e+00, 1.37997437e+00,
+       2.52272739e+01, 7.50000000e+00, 2.25244141e+00, 2.14549389e+01,
+       7.50000000e+00, 4.59468842e+00, 1.13276386e+01, 7.50000000e+00,
+       4.90293884e+00, 9.99481010e+00, 7.50000000e+00, 5.56762695e+00,
+       7.12092018e+00, 7.50000763e+00, 7.03471375e+00, 7.77566910e-01,
+       7.50000000e+00, 1.29301453e+00, 2.48024426e+01, 7.50000000e+00,
+       1.66358948e+00, 2.32016239e+01, 7.50000000e+00, 4.16912842e+00,
+       1.23781033e+01, 7.50000000e+00, 4.68342590e+00, 1.01563663e+01,
+       7.50000000e+00, 4.86281586e+00, 9.38142204e+00, 7.50000000e+00,
+       4.99076080e+00, 8.82872963e+00, 7.50000763e+00, 5.62805176e+00,
+       6.07573891e+00, 7.50000000e+00, 6.38750458e+00, 2.79499626e+00,
+       7.50000000e+00, 6.61423492e+00, 1.81559563e+00, 7.50000000e+00,
+       2.31269073e+00, 1.96041965e+01, 7.49999237e+00, 4.18181610e+00,
+       1.15370998e+01, 7.50000000e+00, 8.28643799e-01, 2.52134762e+01,
+       7.50000000e+00, 1.22573853e+00, 2.35011158e+01, 7.50000000e+00,
+       1.27857971e+00, 2.32733097e+01, 7.49999237e+00, 1.56865692e+00,
+       2.20224056e+01, 7.50000000e+00, 3.86024475e+00, 1.21408710e+01,
+       7.49999237e+00, 4.19444275e+00, 1.06997585e+01, 7.50000000e+00,
+       4.27140808e+00, 1.03678646e+01, 7.50000000e+00, 4.60425568e+00,
+       8.93258095e+00, 7.50000000e+00, 7.95906067e-01, 2.45620174e+01,
+       7.50000000e+00, 9.81079102e-01, 2.37642422e+01, 7.50000000e+00,
+       1.16592407e+00, 2.29679012e+01, 7.50000000e+00, 1.63970947e+00,
+       2.09267063e+01, 7.50000000e+00, 1.84957886e+00, 2.00225239e+01,
+       7.50000000e+00, 1.95434570e+00, 1.95711193e+01, 7.50000000e+00,
+       2.55473328e+00, 1.69845028e+01, 7.50000000e+00, 4.18140411e+00,
+       9.97638893e+00, 7.50000000e+00, 4.28380585e+00, 9.53518867e+00,
+       7.50000763e+00, 4.79429626e+00, 7.33588600e+00, 7.50000000e+00,
+       4.99777222e+00, 6.45926094e+00, 7.50000000e+00, 5.25154114e+00,
+       5.36595726e+00, 7.50000000e+00, 5.85798645e+00, 2.75320816e+00,
+       7.50000000e+00, 5.95870972e+00, 2.31927872e+00, 7.49999237e+00,
+       1.26424408e+00, 2.17568150e+01, 7.50000000e+00, 1.60559845e+00,
+       2.02874851e+01, 7.50000000e+00, 2.31095123e+00, 1.72513332e+01,
+       7.49999237e+00, 4.19396973e+00, 9.14594460e+00, 7.50000000e+00,
+       8.62648010e-01, 2.26997700e+01, 7.50000000e+00, 2.37963867e+00,
+       1.61757793e+01, 7.50000000e+00, 2.45748901e+00, 1.58409367e+01,
+       7.50000763e+00, 2.53529358e+00, 1.55063610e+01, 7.50000000e+00,
+       4.61369324e+00, 6.56790924e+00, 7.50000000e+00, 5.62456512e+00,
+       2.22057343e+00, 7.50000000e+00, 5.90077972e+00, 1.03265953e+00,
+       7.50000000e+00, 1.17141724e+00, 2.05906239e+01, 7.50000763e+00,
+       2.49975586e+00, 1.48829975e+01, 7.50000000e+00, 2.65489960e+00,
+       1.42163563e+01, 7.50000000e+00, 4.21897888e+00, 7.49580574e+00,
+       7.50000000e+00, 1.05933914e+01, 0., 3.75273895e+00,
+       8.50097656e-01, 2.11921177e+01, 7.50000000e+00, 1.08600616e+00,
+       2.01793613e+01, 7.50000000e+00, 4.20600128e+00, 6.78506279e+00,
+       7.50000000e+00, 4.28215027e+00, 6.45813179e+00, 7.50000000e+00,
+       5.56807709e+00, 9.37595367e-01, 7.50000000e+00, 8.17665100e-01,
+       2.05552883e+01, 7.50000000e+00, 1.02701569e+00, 1.96573200e+01,
+       7.50000000e+00, 2.14503479e+00, 1.48618450e+01, 7.50000000e+00,
+       2.53218842e+00, 1.32012348e+01, 7.50000000e+00, 2.60943604e+00,
+       1.28698597e+01, 7.50000763e+00, 4.72391510e+00, 3.80026436e+00,
+       7.50000000e+00, 5.00086975e+00, 2.61233902e+00, 7.50000000e+00,
+       5.10137939e+00, 2.18117142e+00, 7.50000763e+00, 5.27705383e+00,
+       1.42765999e+00, 7.50000763e+00, 2.13620758e+00, 1.41318188e+01,
+       7.50000000e+00, 2.65105438e+00, 1.19254017e+01, 7.50000000e+00,
+       0., 2.50330257e+01, 7.01992035e+00, 9.09683228e-01,
+       1.86188717e+01, 7.50000000e+00, 1.22196198e+00, 1.72817287e+01,
+       7.50000000e+00, 2.05011749e+00, 1.37357388e+01, 7.50000000e+00,
+       2.17890930e+00, 1.31842594e+01, 7.50000763e+00, 2.25611877e+00,
+       1.28537045e+01, 7.50000000e+00, 2.38465118e+00, 1.23033237e+01,
+       7.50000763e+00, 2.64124298e+00, 1.12046452e+01, 7.50000763e+00,
+       4.41954041e+00, 3.59040260e+00, 7.49999237e+00, 4.74638367e+00,
+       2.19089508e+00, 7.50000000e+00, 5.07217407e+00, 7.95900345e-01,
+       7.50000000e+00, 0., 2.44049435e+01, 6.99149323e+00,
+       2.52912903e+00, 1.09247112e+01, 7.50000000e+00, 2.68262482e+00,
+       1.02680378e+01, 7.50000000e+00, 4.00332642e+00, 4.61791420e+00,
+       7.50000000e+00, 4.17980957e+00, 3.86289787e+00, 7.50000000e+00,
+       8.71116638e-01, 1.72547703e+01, 7.49999237e+00, 2.13560486e+00,
+       1.18498631e+01, 7.50000000e+00, 3.63771057e+00, 5.42928505e+00,
+       7.50000000e+00, 3.94052124e+00, 4.13491058e+00, 7.50000000e+00,
+       4.16704559e+00, 3.16666222e+00, 7.50000000e+00, 4.26757050e+00,
+       2.73702049e+00, 7.50000000e+00, 4.61858368e+00, 1.23662376e+00,
+       7.50000000e+00, 4.71865082e+00, 8.08898926e-01, 7.49999237e+00,
+       0., 2.51277714e+01, 6.55551910e+00, 0., 2.48629704e+01,
+       6.60642242e+00, 0., 2.44667416e+01, 6.68260193e+00, 0.,
+       2.31544666e+01, 6.93489075e+00, 8.64891052e-01, 1.65214062e+01,
+       7.50000000e+00, 1.12370300e+00, 1.54161320e+01, 7.49999237e+00,
+       1.27867126e+00, 1.47542896e+01, 7.50000000e+00, 2.12686157e+00,
+       1.11319256e+01, 7.50000000e+00, 2.40803528e+00, 9.93109703e+00,
+       7.50000763e+00, 2.56108856e+00, 9.27749062e+00, 7.50000000e+00,
+       3.87794495e+00, 3.65360260e+00, 7.50000000e+00, 4.15433502e+00,
+       2.47321129e+00, 7.50000000e+00, 4.50502777e+00, 9.75528717e-01,
+       7.50000000e+00, 2.16925049e+00, 1.01989231e+01, 7.50000000e+00,
+       3.31183624e+00, 5.32344246e+00, 7.50000000e+00, 3.61438751e+00,
+       4.03249168e+00, 7.49999237e+00, 0., 2.51912403e+01,
+       6.24441528e+00, 0., 2.49258633e+01, 6.29573822e+00, 0.,
+       2.32136784e+01, 6.62683105e+00, 0., 2.11363544e+01,
+       7.02853394e+00, 9.29939270e-01, 1.47336292e+01, 7.50000000e+00,
+       1.23896027e+00, 1.34161587e+01, 7.50000000e+00, 2.05849457e+00,
+       9.92216682e+00, 7.50000000e+00, 2.28781128e+00, 8.94449425e+00,
+       7.50000000e+00, 2.92213440e+00, 6.24017906e+00, 7.50000000e+00,
+       3.19999695e+00, 5.05558586e+00, 7.50000000e+00, 3.72834778e+00,
+       2.80302238e+00, 7.50000000e+00, 3.95393372e+00, 1.84120750e+00,
+       7.50000000e+00, 0., 2.24596920e+01, 6.62434387e+00, 0.,
+       2.03924007e+01, 7.02527618e+00, 3.18922424e+00, 4.35934639e+00,
+       7.50000000e+00, 3.28987122e+00, 3.93058205e+00, 7.50000763e+00,
+       3.86670685e+00, 1.47341537e+00, 7.50000763e+00, 0.,
+       2.11913624e+01, 6.72249603e+00, 8.91685486e-01, 1.33988056e+01,
+       7.50000000e+00, 2.59893799e+00, 6.13257790e+00, 7.50000000e+00,
+       3.22874451e+00, 3.45205498e+00, 7.50000000e+00, 0.,
+       2.04458866e+01, 6.71983337e+00, 0., 1.90403728e+01,
+       6.99398804e+00, 8.85490417e-01, 1.26807766e+01, 7.50000000e+00,
+       2.33686829e+00, 6.50884247e+00, 7.49999237e+00, 7.62939453e-06,
+       1.84311581e+01, 6.96604919e+00, 2.37829590e+00, 5.59665489e+00,
+       7.50000000e+00, 2.63020325e+00, 4.52634239e+00, 7.49999237e+00,
+       2.93167877e+00, 3.24543762e+00, 7.50000000e+00, 3.50700378e+00,
+       8.00901413e-01, 7.50000763e+00, 0., 1.92185192e+01,
+       6.66455841e+00, 1.30648041e+00, 9.41386604e+00, 7.50000763e+00,
+       3.24647522e+00, 1.17800140e+00, 7.50000000e+00, 0.,
+       1.84806576e+01, 6.66201782e+00, 0., 1.63416767e+01,
+       7.08288574e+00, 1.85646057e+00, 6.34716034e+00, 7.49999237e+00,
+       1.95740509e+00, 5.91900063e+00, 7.50000000e+00, 2.33503723e+00,
+       4.31714249e+00, 7.50000000e+00, 2.38529205e+00, 4.10401154e+00,
+       7.50000000e+00, 2.71129608e+00, 2.72117805e+00, 7.50000000e+00,
+       2.78637695e+00, 2.40268898e+00, 7.50000000e+00, 0.,
+       2.36866741e+01, 5.48715973e+00, 0., 2.18499279e+01,
+       5.84960938e+00, 7.62939453e-06, 1.71159611e+01, 6.78375244e+00,
+       9.62684631e-01, 9.40625572e+00, 7.50000000e+00, 1.84842682e+00,
+       5.65229797e+00, 7.50000000e+00, 2.30099487e+00, 3.73423195e+00,
+       7.50000000e+00, 0., 2.10980816e+01, 5.84868622e+00,
+       -7.62939453e-06, 1.67626019e+01, 6.70666504e+00, 0.,
+       1.51425228e+01, 7.02726746e+00, 9.56413269e-01, 8.70368385e+00,
+       7.50000000e+00, 1.38674927e+00, 6.88139343e+00, 7.50000000e+00,
+       2.06652069e+00, 4.00276566e+00, 7.50000000e+00, 2.41723633e+00,
+       2.51762581e+00, 7.50000000e+00, 2.66701508e+00, 1.45992088e+00,
+       7.50000000e+00, 2.84149170e+00, 7.21061707e-01, 7.50000000e+00,
+       7.62939453e-06, 2.52119045e+01, 4.88266754e+00, 0.,
+       2.49444485e+01, 4.93574524e+00, 7.62939453e-06, 2.34829578e+01,
+       5.22580719e+00, 0., 2.21681805e+01, 5.48674774e+00, 0.,
+       1.64096203e+01, 6.62963104e+00, 7.62939453e-06, 1.44222927e+01,
+       7.02405548e+00, 1.65662384e+00, 5.01488304e+00, 7.50000000e+00,
+       2.20829010e+00, 2.68070412e+00, 7.50000000e+00, 2.43311310e+00,
+       1.72942162e+00, 7.49999237e+00, -7.62939453e-06, 1.51853924e+01,
+       6.72618103e+00, 1.77440643e+00, 3.79605293e+00, 7.50000000e+00,
+       2.39910889e+00, 1.15509605e+00, 7.50000000e+00, 2.44892120e+00,
+       9.44513321e-01, 7.50000000e+00, 0., 2.51420612e+01,
+       4.59204865e+00, 0., 2.36759243e+01, 4.88470459e+00, 0.,
+       2.02737789e+01, 5.56380463e+00, 0., 1.44637280e+01,
+       6.72354889e+00, 0., 1.25028400e+01, 7.11495972e+00,
+       1.36557770e+00, 4.80553055e+00, 7.50000000e+00, 7.62939453e-06,
+       2.14695873e+01, 5.17457581e+00, 0., 2.12089024e+01,
+       5.22676849e+00, 7.62939453e-06, 1.95270290e+01, 5.56344604e+00,
+       0., 1.78665524e+01, 5.89584351e+00, 0., 1.37448864e+01,
+       6.72092438e+00, 1.03221130e+00, 5.49647522e+00, 7.50000000e+00,
+       1.38362885e+00, 4.01325798e+00, 7.50000763e+00, 1.80874634e+00,
+       2.21900368e+00, 7.50000000e+00, 1.85865021e+00, 2.00840378e+00,
+       7.50000000e+00, 1.95837402e+00, 1.58750725e+00, 7.50000000e+00,
+       7.62939453e-06, 2.05866184e+01, 5.20104980e+00, 0.,
+       1.86554012e+01, 5.58875275e+00, 7.62939453e-06, 1.31512356e+01,
+       6.69374084e+00, -7.62939453e-06, 1.25404682e+01, 6.81636810e+00,
+       0., 1.10865078e+01, 7.10825348e+00, 1.02587128e+00,
+       4.80888176e+00, 7.50000000e+00, 1.12620544e+00, 4.38575935e+00,
+       7.50000000e+00, 1.52655792e+00, 2.69738960e+00, 7.50000000e+00,
+       1.95024109e+00, 9.10675049e-01, 7.50000000e+00, 7.62939453e-06,
+       2.52384701e+01, 4.11395264e+00, 0., 2.49698086e+01,
+       4.16804504e+00, 0., 1.03824444e+01, 7.10492706e+00, 0.,
+       2.35321674e+01, 4.30500031e+00, 0., 2.15540981e+01,
+       4.70437622e+00, 0., 2.11620197e+01, 4.78353882e+00, 0.,
+       1.71779652e+01, 5.58794403e+00, 0., 1.11213627e+01,
+       6.81079865e+00, 1.46225739e+00, 1.55142403e+00, 7.50000000e+00,
+       1.53689575e+00, 1.23716354e+00, 7.50000000e+00, 7.62939453e-06,
+       2.09288692e+01, 4.67935181e+00, 0., 8.98245811e+00,
+       7.09828949e+00, 1.03194427e+00, 2.65733147e+00, 7.50000000e+00,
+       1.23130798e+00, 1.81865311e+00, 7.50000000e+00, 7.62939453e-06,
+       2.03055325e+01, 4.65441895e+00, 0., 1.55869389e+01,
+       5.61257935e+00, 0., 1.00724545e+01, 6.73234558e+00, 0.,
+       8.40476799e+00, 7.07098389e+00, 1.32397461e+00, 7.26783752e-01,
+       7.50000000e+00, 7.62939453e-06, 2.05927982e+01, 4.44451141e+00,
+       0., 1.47344418e+01, 5.63749695e+00, 0., 9.01322365e+00,
+       6.80255127e+00, 0., 7.35810089e+00, 7.13959503e+00,
+       9.94529724e-01, 1.41119385e+00, 7.50000000e+00, 0.,
+       2.37877178e+01, 3.64021301e+00, 0., 8.43443108e+00,
+       6.77561951e+00, 0., 6.66856575e+00, 7.13623810e+00,
+       7.62939453e-06, 2.16960506e+01, 3.91461945e+00, 7.62939453e-06,
+       2.01263485e+01, 4.23608398e+00, 0., 7.38574219e+00,
+       6.84532928e+00, 0., 2.22526035e+01, 3.64731598e+00, 0.,
+       2.09365520e+01, 3.91761017e+00, 0., 1.24469166e+01,
+       5.66120148e+00, 0., 6.69489288e+00, 6.84253693e+00, 0.,
+       2.52272854e+01, 2.88105011e+00, 7.62939453e-06, 2.12267551e+01,
+       3.70500183e+00, 0., 2.05716419e+01, 3.83993530e+00,
+       -7.62939453e-06, 1.17315273e+01, 5.66066742e+00, 0.,
+       1.03963146e+01, 5.93566132e+00, 0., 4.73100853e+00,
+       7.10249329e+00, 6.48757935e-01, 8.49151611e-02, 7.50000000e+00,
+       7.62939453e-06, 1.95565052e+01, 3.89672089e+00, 7.62939453e-06,
+       1.08975582e+01, 5.68518066e+00, 0., 5.43717957e+00,
+       6.81299591e+00, 7.62939453e-06, 1.00676289e+01, 5.70959473e+00,
+       0., 8.98656273e+00, 5.93351746e+00, 0., 4.75366783e+00,
+       6.81027985e+00, 0., 3.26007462e+00, 7.11963654e+00,
+       2.92167664e-01, 2.02493668e-01, 7.50000000e+00, 0.,
+       1.96092129e+01, 3.58041382e+00, 0., 9.36171913e+00,
+       5.70896912e+00, 0., 2.58610725e+00, 7.11635590e+00, 0.,
+       2.02883434e+01, 3.28583527e+00, 0., 1.98963299e+01,
+       3.36750031e+00, -7.62939453e-06, 1.83399639e+01, 3.69168854e+00,
+       0., 1.80823689e+01, 3.74535370e+00, -7.62939453e-06,
+       1.05852032e+01, 5.30702209e+00, 0., 3.39443207e+00,
+       6.80485535e+00, 0., 2.52542133e+01, 2.09474945e+00,
+       7.62939453e-06, 2.49825077e+01, 2.15150452e+00, 0.,
+       2.18971004e+01, 2.79601288e+00, 0., 1.91417522e+01,
+       3.37157440e+00, 7.62939453e-06, 1.88823452e+01, 3.42575836e+00,
+       0., 2.60474014e+00, 6.82596588e+00, 0., 9.08420563e-01,
+       7.18030548e+00, 7.62939453e-06, 6.84026718e-01, 7.22717285e+00,
+       6.28356934e-01, 0., 6.82273102e+00, 0., 2.36630268e+01,
+       2.27111053e+00, 0., 2.13961620e+01, 2.74596405e+00, 0.,
+       2.11320171e+01, 2.80129242e+00, 0., 2.07367954e+01,
+       2.88407898e+00, 0., 1.85194798e+01, 3.34856415e+00,
+       7.62939453e-06, 1.80032024e+01, 3.45670319e+00, 0.,
+       7.02385902e+00, 5.75662994e+00, 0., 5.84801865e+00,
+       6.00293732e+00, 7.62939453e-06, 1.77703495e+01, 3.35265350e+00,
+       7.62939453e-06, 1.71284657e+01, 3.48749542e+00, 0.,
+       1.67448597e+01, 3.56807709e+00, 7.62939453e-06, 1.06366138e+01,
+       4.85121155e+00, -7.62939453e-06, 6.32992554e+00, 5.75591278e+00,
+       7.62939453e-06, 1.37482262e+00, 6.79680634e+00, 0.,
+       1.03650284e+00, 6.86788177e+00, 5.87699890e-01, 1.90734863e-06,
+       6.57160950e+00, 0., 2.14530735e+01, 2.42378235e+00, 0.,
+       1.86998768e+01, 3.00375366e+00, 0., 1.08977070e+01,
+       4.64733887e+00, 0., 7.06693649e-01, 6.79415131e+00, 0.,
+       1.98995533e+01, 2.59642029e+00, -7.62939453e-06, 1.71762791e+01,
+       3.17171478e+00, 7.62939453e-06, 1.64085979e+01, 3.33388519e+00,
+       0., 9.09553719e+00, 4.87875366e+00, 0., 8.49480629e+00,
+       5.00566101e+00, 7.62939453e-06, 4.02170181e+00, 5.95059204e+00,
+       0., 1.81026478e+01, 2.82218933e+00, 7.62939453e-06,
+       1.13001766e+01, 4.26322937e+00, 0., 1.08104382e+01,
+       4.36698151e+00, 7.62939453e-06, 9.47341347e+00, 4.65021515e+00,
+       0., 4.61238480e+00, 5.67998505e+00, 7.62939453e-06,
+       9.47319031e-01, 6.45639801e+00, 7.62939453e-06, 7.21876144e-01,
+       6.50415039e+00, 7.62939453e-06, 2.36830120e+01, 1.48264313e+00,
+       0., 1.94291134e+01, 2.38632202e+00, 0., 1.19335499e+01,
+       3.97864532e+00, 0., 1.78936367e+01, 2.55827332e+00, 0.,
+       9.99111366e+00, 4.24174500e+00, 0., 9.02194023e+00,
+       4.44820404e+00, 0., 2.49694347e+01, 8.92204285e-01, 0.,
+       2.37451916e+01, 1.15373230e+00, 7.62939453e-06, 2.17296162e+01,
+       1.58430481e+00, 7.62939453e-06, 1.98758564e+01, 1.98031616e+00,
+       0., 1.90893536e+01, 2.14833069e+00, 0., 1.47204418e+01,
+       3.08164215e+00, 7.62939453e-06, 1.28392200e+01, 3.48352051e+00,
+       7.62939453e-06, 1.18471508e+01, 3.69544220e+00, 0.,
+       4.18083000e+00, 5.33317566e+00, 0., 1.87235622e+01,
+       2.07120514e+00, 0., 1.62686596e+01, 2.59709930e+00, 0.,
+       1.58852711e+01, 2.67923737e+00, 0., 1.51219120e+01,
+       2.84275818e+00, 0., 7.25250435e+00, 4.52856445e+00, 0.,
+       2.53087978e+01, 5.01029968e-01, 0., 2.23232670e+01,
+       1.14237976e+00, 0., 2.05902882e+01, 1.51465607e+00, 0.,
+       2.00616360e+01, 1.62822723e+00, 7.62939453e-06, 1.94038143e+01,
+       1.76953888e+00, 0., 1.83581562e+01, 1.99416351e+00, 0.,
+       1.78384609e+01, 2.10580444e+00, -7.62939453e-06, 1.20080585e+01,
+       3.35829163e+00, 7.62939453e-06, 1.15134411e+01, 3.46453857e+00,
+       0., 1.10207348e+01, 3.57038879e+00, 7.62939453e-06,
+       1.02852802e+01, 3.72837067e+00, 0., 9.43263435e+00,
+       3.91155243e+00, 0., 7.62485886e+00, 4.29989624e+00, 0.,
+       2.12546921e+00, 5.48126221e+00, 0., 2.50672741e+01,
+       3.93310547e-01, 0., 1.81231365e+01, 1.88919830e+00, 0.,
+       1.72158794e+01, 2.08464050e+00, 0., 1.68290005e+01,
+       2.16797638e+00, 7.62939453e-06, 1.60586948e+01, 2.33390808e+00,
+       7.62939453e-06, 8.23945427e+00, 4.01832581e+00, 7.62939453e-06,
+       1.89318371e+01, 1.55877686e+00, 0., 1.84089336e+01,
+       1.67173767e+00, 0., 1.43001347e+01, 2.55931091e+00, 0.,
+       1.09330616e+01, 3.28665924e+00, 0., 1.06871700e+01,
+       3.33978271e+00, 0., 8.85816383e+00, 3.73487854e+00,
+       7.62939453e-06, 2.37292671e+00, 5.13581085e+00, 0.,
+       1.76531353e+01, 1.67928314e+00, 7.62939453e-06, 1.68765621e+01,
+       1.84750366e+00, 0., 1.50825176e+01, 2.23612976e+00,
+       7.62939453e-06, 1.47013226e+01, 2.31870270e+00, 0.,
+       1.39423084e+01, 2.48312378e+00, 0., 1.26872349e+01,
+       2.75499725e+00, 0., 9.48104286e+00, 3.44952393e+00, 0.,
+       3.65338707e+00, 4.71190643e+00, 0., 2.31179180e+01,
+       3.36227417e-01, 0., 1.83292332e+01, 1.37643433e+00,
+       7.62939453e-06, 1.74181614e+01, 1.57433319e+00, 0.,
+       1.04760990e+01, 3.08230591e+00, 0., 8.64695168e+00,
+       3.47963715e+00, 0., 6.72492218e+00, 3.89714050e+00, 0.,
+       1.01822662e+00, 5.13675690e+00, 7.62939453e-06, 2.27423382e+01,
+       2.58476257e-01, 0., 2.03308506e+01, 7.83760071e-01, 0.,
+       1.96687870e+01, 9.27970886e-01, 0., 1.42369022e+01,
+       2.11117554e+00, 0., 1.34793110e+01, 2.27619171e+00,
+       -7.62939453e-06, 1.01249714e+01, 3.00685883e+00, 0.,
+       4.25766945e+00, 4.28489685e+00, 7.62939453e-06, 3.90732765e+00,
+       4.36120605e+00, 0., 2.28550529e+00, 4.71447754e+00, 0.,
+       6.84980392e-01, 5.06311035e+00, 0., 1.65604610e+01,
+       1.44916534e+00, 0., 1.57883854e+01, 1.61780548e+00,
+       7.62939453e-06, 1.18718090e+01, 2.47329712e+00, 0.,
+       1.37725430e+01, 1.90365601e+00, 0., 1.21398144e+01,
+       2.26128387e+00, 0., 8.20841408e+00, 3.12239838e+00, 0.,
+       6.64587975e+00, 3.46464539e+00, 7.62939453e-06, 2.18860054e+00,
+       4.44093323e+00, 0., 2.06804905e+01, 2.31658936e-01, 0.,
+       1.09157085e+01, 2.37639618e+00, 0., 8.95194054e+00,
+       2.80772400e+00, 7.62939453e-06, 8.58713722e+00, 2.88784790e+00,
+       0., 1.21777859e+01, 1.94515228e+00, 0., 3.71640968e+00,
+       3.80875397e+00, 0., 9.43853378e-01, 4.41940308e+00,
+       7.62939453e-06, 7.15637207e-01, 4.46966553e+00, 0.,
+       1.94059925e+01, 1.94458008e-01, 7.62939453e-06, 1.32022152e+01,
+       1.56459045e+00, 7.62939453e-06, 1.19467182e+01, 1.84187317e+00,
+       7.62939453e-06, 1.16971035e+01, 1.89700317e+00, 0.,
+       5.85045052e+00, 3.18827057e+00, 0., 1.87717037e+01,
+       1.75933838e-01, 0., 1.24667606e+01, 1.57226562e+00,
+       7.62939453e-06, 8.14709663e+00, 2.52891541e+00, 0.,
+       7.78367043e+00, 2.60939789e+00, 0., 1.77459507e+01,
+       2.44842529e-01, 0., 9.25984001e+00, 2.12940216e+00, 0.,
+       2.34998703e+00, 3.66390991e+00, 0., 1.69867802e+01,
+       2.55371094e-01, 0., 6.60667229e+00, 2.56688690e+00, 0.,
+       5.05592346e+00, 2.91220856e+00, 0., 2.12755966e+00,
+       3.56432343e+00, 0., 7.10168839e+00, 2.30435181e+00, 0.,
+       4.59411621e+00, 2.86428833e+00, 0., 1.56068020e+01,
+       2.47367859e-01, 7.62939453e-06, 1.11651592e+01, 1.24191284e+00,
+       0., 7.84223747e+00, 1.98596191e+00, 0., 4.36917686e+00,
+       2.76363373e+00, 0., 2.26174545e+00, 3.23551941e+00, 0.,
+       1.49848042e+01, 2.28958130e-01, 0., 1.03123798e+01,
+       1.27804565e+00, 0., 5.92680931e+00, 2.26274109e+00, 0.,
+       9.46384621e+00, 1.31401062e+00, 7.62939453e-06, 6.29960251e+00,
+       2.02641296e+00, 0., 1.34915485e+01, 2.49870300e-01,
+       7.62939453e-06, 8.74211693e+00, 1.32209778e+00, 7.62939453e-06,
+       1.01561737e+00, 3.06644440e+00, 0., 7.85436630e-01,
+       3.11842346e+00, 7.62939453e-06, 6.32601357e+00, 1.71438599e+00,
+       0., 8.52789116e+00, 1.06111908e+00, 7.62939453e-06,
+       7.18582153e+00, 1.36576843e+00, 7.62939453e-06, 2.19143677e+00,
+       2.49948120e+00, 7.62939453e-06, 1.15254612e+01, 2.23716736e-01,
+       7.62939453e-06, 6.47322655e+00, 1.37371063e+00, 7.62939453e-06,
+       5.03247452e+00, 1.70165253e+00, 7.62939453e-06, 3.73711395e+00,
+       1.84411621e+00, 0., 1.09341984e+01, 4.43115234e-02,
+       7.62939453e-06, 5.89652061e+00, 1.19724274e+00, 0.,
+       1.05600166e+00, 2.30506897e+00, 0., 7.09243774e-01,
+       2.38442993e+00, 0., 8.95998955e+00, 3.39950562e-01, 0.,
+       3.75856018e+00, 1.53360748e+00, 0., 9.59576607e+00,
+       3.71780396e-02, 7.62939453e-06, 5.68118477e+00, 9.37965393e-01,
+       -7.62939453e-06, 4.96074867e+00, 1.10375214e+00, 0.,
+       4.13666153e+00, 1.13965607e+00, 0., 2.24684715e+00,
+       1.57570648e+00, -7.62939453e-06, 9.64380264e-01, 1.87162018e+00,
+       0., 7.52985191e+00, 2.00584412e-01, 0., 5.49042320e+00,
+       3.61900330e-01, 0., 4.78033257e+00, 3.71833801e-01,
+       7.62939453e-06, 5.63647079e+00, 1.60675049e-02, -7.62939453e-06,
+       7.79867172e-01, 9.98703003e-01, -7.62939453e-06, 3.49809074e+00,
+       2.05963135e-01, 0., 2.79510689e+00, 2.16163635e-01, 0.,
+       1.38037109e+00, 5.49728394e-01, 0., 7.95724869e-01,
+       6.87583923e-01, 0., 3.60113144e-01, 1.73294067e-01, 0.,
+       1.78890228e-02, 1.00128174e-01, 1.85823135e+01, 2.57952671e+01,
+       7.50000000e+00, 1.77382889e+01, 2.45979710e+01, 7.50000000e+00,
+       1.77802200e+01, 2.31256466e+01, 7.50000000e+00, 1.71104889e+01,
+       2.49927425e+01, 7.49999237e+00, 1.71753769e+01, 2.46889973e+01,
+       7.49999237e+00, 1.72726288e+01, 2.42337666e+01, 7.50000000e+00,
+       1.78218613e+01, 2.16629391e+01, 7.50000000e+00, 1.80149384e+01,
+       2.07591343e+01, 7.50000000e+00, 1.71866837e+01, 2.33720798e+01,
+       7.50000000e+00, 1.72513123e+01, 2.30699253e+01, 7.50000000e+00,
+       1.71334305e+01, 2.23642712e+01, 7.50000000e+00, 1.63375931e+01,
+       2.48244686e+01, 7.50000000e+00, 1.74657593e+01, 1.95661564e+01,
+       7.50000763e+00, 1.65774155e+01, 2.24614239e+01, 7.50000000e+00,
+       1.68350449e+01, 2.12623577e+01, 7.50000000e+00, 1.70598984e+01,
+       2.02158260e+01, 7.50000000e+00, 1.64617920e+01, 2.17611027e+01,
+       7.50000000e+00, 1.69754257e+01, 1.93738079e+01, 7.50000000e+00,
+       1.69233246e+01, 1.83878269e+01, 7.50000000e+00, 1.63924255e+01,
+       1.96277828e+01, 7.50000763e+00, 1.69352188e+01, 1.71119709e+01,
+       7.50000000e+00, 1.71895828e+01, 1.59330082e+01, 7.50000000e+00,
+       1.56689224e+01, 2.17596951e+01, 7.50000000e+00, 1.71055832e+01,
+       1.51099224e+01, 7.50000763e+00, 1.72638855e+01, 1.43772221e+01,
+       7.50000000e+00, 1.47825317e+01, 2.46425533e+01, 7.50000000e+00,
+       1.50734177e+01, 2.32979832e+01, 7.50000000e+00, 1.52668686e+01,
+       2.24038677e+01, 7.49999237e+00, 1.71799927e+01, 1.35608311e+01,
+       7.50000000e+00, 1.71280212e+01, 1.26031666e+01, 7.50000000e+00,
+       1.42709045e+01, 2.45827007e+01, 7.50000000e+00, 1.70449066e+01,
+       1.17954731e+01, 7.50000000e+00, 1.38706970e+01, 2.52233868e+01,
+       7.50000000e+00, 1.69935608e+01, 1.08474751e+01, 7.50000000e+00,
+       1.71814804e+01, 9.98241234e+00, 7.50000000e+00, 1.82084122e+01,
+       5.25498581e+00, 7.50000000e+00, 1.36979294e+01, 2.48206043e+01,
+       7.50000000e+00, 1.53339462e+01, 1.72994289e+01, 7.50000000e+00,
+       1.76901474e+01, 6.46737289e+00, 7.50000000e+00, 1.81853256e+01,
+       4.19091988e+00, 7.50000000e+00, 1.33964996e+01, 2.50133114e+01,
+       7.50000763e+00, 1.36872940e+01, 2.36782665e+01, 7.50000000e+00,
+       1.53821564e+01, 1.58969593e+01, 7.50000763e+00, 1.71720810e+01,
+       7.67929077e+00, 7.50000000e+00, 1.87454758e+01, 4.55732346e-01,
+       7.50000000e+00, 1.53036423e+01, 1.50831089e+01, 7.50000000e+00,
+       1.71519165e+01, 6.60883522e+00, 7.50000000e+00, 1.79858932e+01,
+       2.78505135e+00, 7.50000763e+00, 1.30547409e+01, 2.42129688e+01,
+       7.50000000e+00, 1.66789246e+01, 6.46585274e+00, 7.50000000e+00,
+       1.70810623e+01, 4.62698174e+00, 7.50000000e+00, 1.72660828e+01,
+       3.78088760e+00, 7.50000000e+00, 1.75429611e+01, 2.51483917e+00,
+       7.50000000e+00, 1.78190079e+01, 1.25247574e+00, 7.50000000e+00,
+       1.53842316e+01, 1.12326527e+01, 7.50000000e+00, 1.69380875e+01,
+       4.13651085e+00, 7.50000000e+00, 1.74606705e+01, 1.74997520e+00,
+       7.50000000e+00, 1.43008347e+01, 1.50268764e+01, 7.50000000e+00,
+       1.54940262e+01, 9.58497810e+00, 7.50000000e+00, 1.73788071e+01,
+       9.88864899e-01, 7.50000000e+00, 1.26041565e+01, 2.16081448e+01,
+       7.50000000e+00, 1.25007935e+01, 2.09280033e+01, 7.50000000e+00,
+       1.26287384e+01, 2.03460522e+01, 7.50000000e+00, 1.61745529e+01,
+       4.21637154e+00, 7.50000000e+00, 1.13379517e+01, 2.50665836e+01,
+       7.50000000e+00, 1.12374802e+01, 2.43778515e+01, 7.50000000e+00,
+       1.41589966e+01, 1.11223698e+01, 7.50000000e+00, 1.47826004e+01,
+       8.29294395e+00, 7.50000000e+00, 1.48758011e+01, 7.87011147e+00,
+       7.50000000e+00, 1.49689026e+01, 7.44768143e+00, 7.50000000e+00,
+       1.53712997e+01, 5.62188911e+00, 7.50000000e+00, 1.18747787e+01,
+       2.03512897e+01, 7.50000000e+00, 1.27649155e+01, 1.63177547e+01,
+       7.50000000e+00, 1.37410049e+01, 1.18947773e+01, 7.50000000e+00,
+       1.44277649e+01, 8.78276634e+00, 7.50000000e+00, 1.48622665e+01,
+       6.81389236e+00, 7.50000000e+00, 1.56640091e+01, 3.18088531e+00,
+       7.50000763e+00, 1.07484131e+01, 2.43201580e+01, 7.50000000e+00,
+       1.13265686e+01, 2.17036648e+01, 7.50000763e+00, 1.28833160e+01,
+       1.46584911e+01, 7.50000000e+00, 1.42602463e+01, 8.42708397e+00,
+       7.50000000e+00, 1.53416595e+01, 3.53308105e+00, 7.50000763e+00,
+       1.55258255e+01, 2.69962120e+00, 7.50000000e+00, 1.55871429e+01,
+       2.42215538e+00, 7.50000000e+00, 1.57096329e+01, 1.86775780e+00,
+       7.50000000e+00, 1.20229034e+01, 1.74310398e+01, 7.50000000e+00,
+       1.44342041e+01, 6.53239632e+00, 7.50000000e+00, 1.08402252e+01,
+       2.16547794e+01, 7.50000000e+00, 1.11597366e+01, 2.02124653e+01,
+       7.50000000e+00, 1.12872543e+01, 1.96368580e+01, 7.49999237e+00,
+       1.15735550e+01, 1.83444729e+01, 7.50000000e+00, 1.36788406e+01,
+       8.84098625e+00, 7.50000000e+00, 1.38341293e+01, 8.13997841e+00,
+       7.50000000e+00, 1.07739944e+01, 2.08378658e+01, 7.50000000e+00,
+       1.11882782e+01, 1.89701252e+01, 7.50000000e+00, 1.23892822e+01,
+       1.35555134e+01, 7.50000000e+00, 1.30778885e+01, 1.04510059e+01,
+       7.50000000e+00, 1.51147537e+01, 1.26793671e+00, 7.50000000e+00,
+       1.51758041e+01, 9.92668152e-01, 7.50000000e+00, 9.58638000e+00,
+       2.50758343e+01, 7.50000000e+00, 9.87603760e+00, 2.37715359e+01,
+       7.50000000e+00, 1.03569336e+01, 2.16061954e+01, 7.50000000e+00,
+       1.14699478e+01, 1.65945988e+01, 7.50000000e+00, 1.15647507e+01,
+       1.61676693e+01, 7.50000000e+00, 1.22572632e+01, 1.30494900e+01,
+       7.50000000e+00, 1.29137192e+01, 1.00935879e+01, 7.50000000e+00,
+       1.31004639e+01, 9.25270271e+00, 7.50000763e+00, 1.39055710e+01,
+       5.62749672e+00, 7.50000000e+00, 1.14027557e+01, 1.57972469e+01,
+       7.50000000e+00, 1.22822800e+01, 1.18419018e+01, 7.50000000e+00,
+       1.33396912e+01, 7.08656311e+00, 7.50000000e+00, 9.20326233e+00,
+       2.45826473e+01, 7.50000000e+00, 9.97251892e+00, 2.11275005e+01,
+       7.50000000e+00, 1.07358093e+01, 1.76991291e+01, 7.50000000e+00,
+       1.09889221e+01, 1.65622387e+01, 7.50000000e+00, 1.22759705e+01,
+       1.07813969e+01, 7.50000000e+00, 1.34230194e+01, 5.62934113e+00,
+       7.50000000e+00, 1.43737106e+01, 1.35927391e+00, 7.50000000e+00,
+       9.62170410e+00, 2.16055584e+01, 7.50000000e+00, 9.94071960e+00,
+       2.01744938e+01, 7.50000000e+00, 1.00043945e+01, 1.98888378e+01,
+       7.50000000e+00, 1.03221741e+01, 1.84633121e+01, 7.50000000e+00,
+       1.13007812e+01, 1.40732708e+01, 7.50000000e+00, 1.32598572e+01,
+       5.28487587e+00, 7.50000000e+00, 9.94084167e+00, 1.90841312e+01,
+       7.50000000e+00, 1.01946106e+01, 1.79471684e+01, 7.50000000e+00,
+       1.05740356e+01, 1.62472057e+01, 7.50000000e+00, 1.11717911e+01,
+       1.35689640e+01, 7.50000000e+00, 1.12971725e+01, 1.30071964e+01,
+       7.50000000e+00, 1.18594131e+01, 1.04881382e+01, 7.50000000e+00,
+       1.23254700e+01, 8.39995766e+00, 7.50000000e+00, 1.25112686e+01,
+       7.56747246e+00, 7.50000000e+00, 1.26658325e+01, 6.87494659e+00,
+       7.50000000e+00, 1.28201599e+01, 6.18352890e+00, 7.50000000e+00,
+       1.36798325e+01, 2.33177376e+00, 7.50000000e+00, 8.53743744e+00,
+       2.42806377e+01, 7.50000000e+00, 9.24169922e+00, 2.11290646e+01,
+       7.50000000e+00, 9.43290710e+00, 2.02734280e+01, 7.50000000e+00,
+       9.59196472e+00, 1.95616627e+01, 7.50000000e+00, 1.02572174e+01,
+       1.65847073e+01, 7.50000000e+00, 1.11685486e+01, 1.25065212e+01,
+       7.50000000e+00, 1.13872681e+01, 1.15277882e+01, 7.50000000e+00,
+       1.18232269e+01, 9.57686043e+00, 7.50000000e+00, 1.26585541e+01,
+       5.83882713e+00, 7.50000000e+00, 1.08215790e+01, 1.29862461e+01,
+       7.50000000e+00, 1.19111328e+01, 8.11645699e+00, 7.50000000e+00,
+       1.19730377e+01, 7.83981514e+00, 7.50000000e+00, 1.25898361e+01,
+       5.08304596e+00, 7.50000000e+00, 8.00087738e+00, 2.45109272e+01,
+       7.50000000e+00, 8.92810059e+00, 2.03717785e+01, 7.50000000e+00,
+       9.53090668e+00, 1.76807766e+01, 7.50000763e+00, 1.02871399e+01,
+       1.43049526e+01, 7.50000000e+00, 1.18750381e+01, 7.21650124e+00,
+       7.50000000e+00, 1.20601654e+01, 6.39008522e+00, 7.50000000e+00,
+       1.22141724e+01, 5.70260048e+00, 7.50000000e+00, 1.22756958e+01,
+       5.42790794e+00, 7.50000763e+00, 1.24600677e+01, 4.60488510e+00,
+       7.50000000e+00, 8.42193604e+00, 2.15570927e+01, 7.50000763e+00,
+       8.54946136e+00, 2.09885540e+01, 7.50000000e+00, 9.59523773e+00,
+       1.63257809e+01, 7.50000000e+00, 1.05676575e+01, 1.19901600e+01,
+       7.49999237e+00, 1.11899414e+01, 9.21558189e+00, 7.50000000e+00,
+       1.30333862e+01, 9.96374130e-01, 7.50000000e+00, 8.42626190e+00,
+       2.04695530e+01, 7.50000000e+00, 9.24991608e+00, 1.68016262e+01,
+       7.50000000e+00, 1.13103485e+01, 7.62600708e+00, 7.50000000e+00,
+       1.14955139e+01, 6.80133438e+00, 7.50000000e+00, 8.11281586e+00,
+       2.08012409e+01, 7.50000000e+00, 9.12600708e+00, 1.62946529e+01,
+       7.49999237e+00, 1.00041275e+01, 1.23888988e+01, 7.50000000e+00,
+       1.01912766e+01, 1.15564556e+01, 7.50000000e+00, 1.09981842e+01,
+       7.96742439e+00, 7.50000000e+00, 1.14260559e+01, 5.02355766e+00,
+       7.50000000e+00, 8.59668732e+00, 1.65431576e+01, 7.50000000e+00,
+       9.00531769e+00, 1.47299366e+01, 7.50000000e+00, 1.04996414e+01,
+       8.09919548e+00, 7.50000000e+00, 6.40910339e+00, 2.51941357e+01,
+       7.50000000e+00, 7.43138123e+00, 2.06633816e+01, 7.50000000e+00,
+       7.71702576e+00, 1.93974209e+01, 7.50000000e+00, 9.22672272e+00,
+       1.27063732e+01, 7.50000763e+00, 9.66275787e+00, 1.07738819e+01,
+       7.50000000e+00, 1.17231293e+01, 1.64228249e+00, 7.50000000e+00,
+       8.22761536e+00, 1.60937443e+01, 7.50000000e+00, 1.01582718e+01,
+       7.54713249e+00, 7.50000763e+00, 5.98065948e+00, 2.49936924e+01,
+       7.50000000e+00, 6.20492554e+00, 2.40020771e+01, 7.50000000e+00,
+       6.77932739e+00, 2.14623508e+01, 7.50000000e+00, 6.62928009e+00,
+       2.10879040e+01, 7.50000000e+00, 8.11196136e+00, 1.45397739e+01,
+       7.50000763e+00, 9.78862000e+00, 7.13504601e+00, 7.50000000e+00,
+       1.01880341e+01, 5.37103653e+00, 7.50000763e+00, 1.03106155e+01,
+       4.82970428e+00, 7.50000000e+00, 1.10428619e+01, 1.59580803e+00,
+       7.50000000e+00, 5.81097412e+00, 2.36653728e+01, 7.50000000e+00,
+       5.90679169e+00, 2.32426701e+01, 7.50000000e+00, 8.08580780e+00,
+       1.36305332e+01, 7.50000000e+00, 8.36655426e+00, 1.23921146e+01,
+       7.50000000e+00, 9.72773743e+00, 6.38762283e+00, 7.50000000e+00,
+       5.85420990e+00, 2.24438648e+01, 7.50000000e+00, 9.66712952e+00,
+       5.64371490e+00, 7.50000000e+00, 6.05587006e+00, 2.05310612e+01,
+       7.50000000e+00, 9.26965332e+00, 6.38713455e+00, 7.50000000e+00,
+       9.69856262e+00, 4.49951935e+00, 7.50000000e+00, 4.76158905e+00,
+       2.52017689e+01, 7.50000000e+00, 4.92163849e+00, 2.44982319e+01,
+       7.50000000e+00, 5.14527130e+00, 2.35151463e+01, 7.50000000e+00,
+       5.33656311e+00, 2.26742344e+01, 7.50000000e+00, 5.65457916e+00,
+       2.12762508e+01, 7.50000763e+00, 7.10462952e+00, 1.49019299e+01,
+       7.50000000e+00, 7.22973633e+00, 1.43519764e+01, 7.50000000e+00,
+       8.84195709e+00, 7.26475906e+00, 7.49999237e+00, 9.36339569e+00,
+       4.97253609e+00, 7.50000000e+00, 7.20595551e+00, 1.34488468e+01,
+       7.50000000e+00, 7.26829529e+00, 1.31751003e+01, 7.50000000e+00,
+       9.76091003e+00, 2.23035622e+00, 7.50000000e+00, 1.00340195e+01,
+       1.03111458e+00, 7.50000000e+00, 4.37492371e+00, 2.48630848e+01,
+       7.50000000e+00, 4.43887329e+00, 2.45825939e+01, 7.50000000e+00,
+       6.18191528e+00, 1.69378567e+01, 7.50000000e+00, 6.74585724e+00,
+       1.44644375e+01, 7.50000000e+00, 9.00087738e+00, 4.57422829e+00,
+       7.50000000e+00, 5.08943939e+00, 2.07216473e+01, 7.50000763e+00,
+       5.31094360e+00, 1.97512760e+01, 7.50000000e+00, 6.37994385e+00,
+       1.50681286e+01, 7.50000000e+00, 6.91020203e+00, 1.27451267e+01,
+       7.50000000e+00, 4.56413269e+00, 2.20179882e+01, 7.50000000e+00,
+       6.54541016e+00, 1.33481159e+01, 7.50000000e+00, 3.84764099e+00,
+       2.41501141e+01, 7.50000000e+00, 4.03887177e+00, 2.33142643e+01,
+       7.50000000e+00, 4.19794464e+00, 2.26189175e+01, 7.50000000e+00,
+       4.89495087e+00, 1.95723286e+01, 7.50000763e+00, 4.98963928e+00,
+       1.91585140e+01, 7.49999237e+00, 6.08765411e+00, 1.43590908e+01,
+       7.50000000e+00, 6.67873383e+00, 1.17754803e+01, 7.50000000e+00,
+       8.27878571e+00, 4.78168297e+00, 7.50000000e+00, 9.19031525e+00,
+       7.97405243e-01, 7.49999237e+00, 3.92777252e+00, 2.28022480e+01,
+       7.50000000e+00, 4.18180847e+00, 2.16931629e+01, 7.50000000e+00,
+       4.87709808e+00, 1.86574268e+01, 7.50000000e+00, 5.22296906e+00,
+       1.71473560e+01, 7.50000000e+00, 6.22241974e+00, 1.27836628e+01,
+       7.50000763e+00, 6.37770081e+00, 1.21057415e+01, 7.50000000e+00,
+       8.73889160e+00, 1.79660416e+00, 7.50000000e+00, 4.48160553e+00,
+       1.93945293e+01, 7.50000000e+00, 4.76503754e+00, 1.81583996e+01,
+       7.50000000e+00, 6.72711182e+00, 9.60148048e+00, 7.50000000e+00,
+       3.00723267e+00, 2.48327618e+01, 7.50000000e+00, 3.73865509e+00,
+       2.16464787e+01, 7.50000000e+00, 4.02343750e+00, 2.04058819e+01,
+       7.50000000e+00, 4.37041473e+00, 1.88943081e+01, 7.50000000e+00,
+       4.68482971e+00, 1.75246372e+01, 7.50000000e+00, 5.21710205e+00,
+       1.52059193e+01, 7.50000000e+00, 5.34192657e+00, 1.46621151e+01,
+       7.50000000e+00, 7.07348633e+00, 7.11886215e+00, 7.50000763e+00,
+       7.16541290e+00, 6.71841431e+00, 7.50000763e+00, 8.14553070e+00,
+       1.48698807e+00, 7.50000000e+00, 3.26651764e+00, 2.17377148e+01,
+       7.50000000e+00, 3.45634460e+00, 2.09125347e+01, 7.50000000e+00,
+       3.51955414e+00, 2.06378231e+01, 7.50000000e+00, 4.02375793e+00,
+       1.84462147e+01, 7.50000000e+00, 4.55674744e+00, 1.61295071e+01,
+       7.50000000e+00, 6.47707367e+00, 7.78247261e+00, 7.50000000e+00,
+       7.14974976e+00, 4.85856819e+00, 7.50000000e+00, 7.27157593e+00,
+       4.32906151e+00, 7.50000000e+00, 4.72692871e+00, 1.44215565e+01,
+       7.50000000e+00, 5.37869263e+00, 1.15916729e+01, 7.50000000e+00,
+       5.47145844e+00, 1.11888905e+01, 7.50000000e+00, 5.93400574e+00,
+       9.18054008e+00, 7.50000000e+00, 6.42506409e+00, 7.04843330e+00,
+       7.50000000e+00, 6.54746246e+00, 6.51703644e+00, 7.50000000e+00,
+       7.82359314e+00, 9.76261139e-01, 7.50000000e+00, 2.13018036e+00,
+       2.47207241e+01, 7.50000000e+00, 2.63867188e+00, 2.25153637e+01,
+       7.50000000e+00, 3.08152771e+00, 2.05946293e+01, 7.50000000e+00,
+       4.95794678e+00, 1.24563770e+01, 7.49999237e+00, 5.79111481e+00,
+       8.84284019e+00, 7.50000000e+00, 5.94464874e+00, 8.17693138e+00,
+       7.50000000e+00, 6.52595520e+00, 5.65573692e+00, 7.50000000e+00,
+       6.67838287e+00, 4.99468803e+00, 7.50000000e+00, 6.98252106e+00,
+       3.67560005e+00, 7.50000000e+00, 1.83291626e+00, 2.50379734e+01,
+       7.50000000e+00, 2.53166962e+00, 2.20107059e+01, 7.50000000e+00,
+       5.18726349e+00, 1.05057201e+01, 7.50000000e+00, 6.01641846e+00,
+       6.91349602e+00, 7.50000763e+00, 6.38274384e+00, 5.32641029e+00,
+       7.50000763e+00, 1.79104614e+00, 2.42521381e+01, 7.50000000e+00,
+       1.94993591e+00, 2.35645351e+01, 7.50000000e+00, 2.55146027e+00,
+       2.09613323e+01, 7.50000000e+00, 2.86664581e+00, 1.95973606e+01,
+       7.50000000e+00, 3.96214294e+00, 1.48563824e+01, 7.50000000e+00,
+       4.58288574e+00, 1.21700382e+01, 7.50000000e+00, 5.32277679e+00,
+       8.96803474e+00, 7.49999237e+00, 5.47623444e+00, 8.30389214e+00,
+       7.50000000e+00, 5.62946320e+00, 7.64076042e+00, 7.50000000e+00,
+       5.69068909e+00, 7.37579155e+00, 7.50000000e+00, 5.93523407e+00,
+       6.31752968e+00, 7.50000000e+00, 5.99626923e+00, 6.05335999e+00,
+       7.50000000e+00, 2.03457642e+00, 2.22370510e+01, 7.50000763e+00,
+       2.22428131e+00, 2.14170094e+01, 7.50000000e+00, 4.56618500e+00,
+       1.12930202e+01, 7.50000000e+00, 4.87439728e+00, 9.96063042e+00,
+       7.50000000e+00, 5.54916382e+00, 7.04360580e+00, 7.50000000e+00,
+       7.00586700e+00, 7.46326447e-01, 7.50000763e+00, 1.23181915e+00,
+       2.47473850e+01, 7.50000000e+00, 4.61113739e+00, 1.01544399e+01,
+       7.50000000e+00, 5.56071472e+00, 6.05386543e+00, 7.50000000e+00,
+       6.32004547e+00, 2.77488899e+00, 7.50000000e+00, 6.53163147e+00,
+       1.86120033e+00, 7.50000000e+00, 1.63500977e+00, 2.20529728e+01,
+       7.50000000e+00, 2.23380280e+00, 1.94699802e+01, 7.50000000e+00,
+       7.38853455e-01, 2.49661083e+01, 7.50000000e+00, 9.29496765e-01,
+       2.41446133e+01, 7.50000000e+00, 1.11979675e+00, 2.33246365e+01,
+       7.49999237e+00, 5.37113190e+00, 5.00547409e+00, 7.49999237e+00,
+       5.88643646e+00, 2.78493309e+00, 7.50000763e+00, 6.00732422e+00,
+       2.26410484e+00, 7.50000000e+00, 1.23793793e+00, 2.18700428e+01,
+       7.50000000e+00, 1.77323151e+00, 1.95659161e+01, 7.50000000e+00,
+       4.62243652e+00, 7.30166435e+00, 7.50000763e+00, 1.26094818e+00,
+       2.08303699e+01, 7.50000000e+00, 2.35698700e+00, 1.61175213e+01,
+       7.50000000e+00, 2.51261902e+00, 1.54483509e+01, 7.50000000e+00,
+       2.66800690e+00, 1.47802029e+01, 7.50000000e+00, 4.57537842e+00,
+       6.57874107e+00, 7.50000000e+00, 2.40796661e+00, 1.49676800e+01,
+       7.50000000e+00, 2.59411621e+00, 1.41680584e+01, 7.50000763e+00,
+       4.13237762e+00, 7.56075668e+00, 7.50000000e+00, 5.67773438e+00,
+       9.23004150e-01, 7.50000000e+00, 1.05048904e+01, 0.,
+       3.76395416e+00, 9.61608887e-01, 2.02476902e+01, 7.50000000e+00,
+       2.61334991e+00, 1.31604137e+01, 7.50000000e+00, 4.17794037e+00,
+       6.44707298e+00, 7.50000000e+00, 5.32822418e+00, 1.51143837e+00,
+       7.50000000e+00, 1.22716522e+00, 1.72594776e+01, 7.50000000e+00,
+       2.18921661e+00, 1.31401730e+01, 7.49999237e+00, 2.25096893e+00,
+       1.28757267e+01, 7.50000000e+00, 2.65148926e+00, 1.11607533e+01,
+       7.50000000e+00, 4.41951752e+00, 3.59039307e+00, 7.50000000e+00,
+       5.08218384e+00, 7.53046036e-01, 7.49999237e+00, 0.,
+       2.48858013e+01, 6.86986542e+00, 0., 2.44111195e+01,
+       6.96064758e+00, 1.18771362e+00, 1.65107365e+01, 7.50000000e+00,
+       2.67042542e+00, 1.01686611e+01, 7.50000000e+00, 3.98065948e+00,
+       4.56434250e+00, 7.49999237e+00, 4.73473358e+00, 1.33894157e+00,
+       7.50000000e+00, 8.06327820e-01, 1.72272015e+01, 7.50000000e+00,
+       3.87516022e+00, 4.11437988e+00, 7.50000000e+00, 3.96581268e+00,
+       3.72702599e+00, 7.50000000e+00, 4.08656311e+00, 3.21109581e+00,
+       7.49999237e+00, 4.20716858e+00, 2.69577026e+00, 7.50000000e+00,
+       4.65814972e+00, 7.68758774e-01, 7.50000000e+00, 0.,
+       2.44853306e+01, 6.58969879e+00, 0., 2.24425030e+01,
+       6.98313141e+00, 7.67951965e-01, 1.64807224e+01, 7.50000000e+00,
+       2.31066132e+00, 9.89573097e+00, 7.50000000e+00, 8.22792053e-01,
+       1.53410015e+01, 7.49999237e+00, 2.05510712e+00, 1.00862598e+01,
+       7.49999237e+00, 2.33035278e+00, 8.91258812e+00, 7.50000000e+00,
+       2.93935394e+00, 6.31568909e+00, 7.50000000e+00, 3.18195343e+00,
+       5.28125572e+00, 7.50000000e+00, 3.99645996e+00, 1.80812836e+00,
+       7.50000000e+00, 4.08655548e+00, 1.42393684e+00, 7.50000000e+00,
+       0., 2.25117970e+01, 6.61423492e+00, 3.28986359e+00,
+       3.93058205e+00, 7.50000763e+00, 0., 2.11452389e+01,
+       6.70186615e+00, 8.69888306e-01, 1.33424129e+01, 7.50000000e+00,
+       2.55153656e+00, 6.18636513e+00, 7.50000763e+00, 0.,
+       1.90250721e+01, 6.93815613e+00, 2.99302673e+00, 3.42466354e+00,
+       7.50000000e+00, -7.62939453e-06, 1.84459820e+01, 6.87496185e+00,
+       2.28714752e+00, 5.54356194e+00, 7.50000763e+00, 2.52892303e+00,
+       4.51687431e+00, 7.49999237e+00, 2.64958191e+00, 4.00443459e+00,
+       7.50000000e+00, 1.88333130e+00, 6.37932587e+00, 7.50000000e+00,
+       0., 2.36338367e+01, 5.49758911e+00, 0., 2.17457371e+01,
+       5.87016296e+00, 0., 1.71410885e+01, 6.77880096e+00,
+       9.62692261e-01, 9.40625191e+00, 7.50000000e+00, 1.84339142e+00,
+       5.67365265e+00, 7.50000000e+00, 2.32608032e+00, 3.62792206e+00,
+       7.50000000e+00, 2.56657410e+00, 2.60866356e+00, 7.50000000e+00,
+       7.62939453e-06, 2.09999027e+01, 5.83822632e+00, 0.,
+       1.50725040e+01, 7.01192474e+00, 9.24728394e-01, 8.69235420e+00,
+       7.50000000e+00, 1.31964874e+00, 7.02028275e+00, 7.50000000e+00,
+       2.61521149e+00, 1.53498268e+00, 7.50000000e+00, 2.70498657e+00,
+       1.15486526e+00, 7.50000000e+00, 2.79469299e+00, 7.75083542e-01,
+       7.49999237e+00, 0., 2.49838886e+01, 4.86714935e+00, 0.,
+       2.21273441e+01, 5.43473053e+00, 0., 1.45045643e+01,
+       6.94934082e+00, 1.61336517e+00, 4.90913391e+00, 7.49999237e+00,
+       2.03473663e+00, 3.12681198e+00, 7.50000763e+00, 2.12481689e+00,
+       2.74584007e+00, 7.50000000e+00, 2.21481323e+00, 2.36519623e+00,
+       7.50000000e+00, 0., 2.35842762e+01, 4.96362305e+00,
+       2.29411316e+00, 1.16919899e+00, 7.50000000e+00, 2.35387421e+00,
+       9.16687012e-01, 7.50000000e+00, 7.62939453e-06, 2.10992413e+01,
+       5.27880096e+00, 0., 1.93933697e+01, 5.62008667e+00,
+       1.38504028e+00, 4.15027809e+00, 7.50000763e+00, 1.98492432e+00,
+       1.61797523e+00, 7.50000000e+00, 7.62939453e-06, 1.32492313e+01,
+       6.67407227e+00, 1.01582336e+00, 4.85121536e+00, 7.50000763e+00,
+       1.13623810e+00, 4.34346962e+00, 7.49999237e+00, 1.94526672e+00,
+       9.31650162e-01, 7.50000000e+00, -7.62939453e-06, 2.49761944e+01,
+       4.13612366e+00, 0., 2.10094471e+01, 4.93519592e+00, 0.,
+       2.05413647e+01, 5.02948761e+00, 0., 1.25387096e+01,
+       6.64158630e+00, 0., 1.03618031e+01, 7.08010864e+00,
+       1.33826447e+00, 2.63926315e+00, 7.50000763e+00, 0.,
+       2.16701984e+01, 4.62029266e+00, 0., 1.71874218e+01,
+       5.52642059e+00, 1.47929382e+00, 1.19763374e+00, 7.50000000e+00,
+       7.62939453e-06, 8.96790886e+00, 7.01449585e+00, 1.38135529e+00,
+       7.65968323e-01, 7.50000000e+00, 0., 2.03271160e+01,
+       4.52892303e+00, 0., 2.37177258e+01, 3.46978760e+00, 0.,
+       2.07052135e+01, 4.08708191e+00, 0., 2.00797024e+01,
+       4.21525574e+00, 0., 1.32429829e+01, 5.61619568e+00,
+       7.62939453e-06, 7.45914841e+00, 6.80137634e+00, 0.,
+       1.25280895e+01, 5.58538055e+00, 7.62939453e-06, 6.77048683e+00,
+       6.76921082e+00, 0., 5.37163734e+00, 7.05683136e+00,
+       7.56050110e-01, 4.95376587e-02, 7.50000000e+00, 0.,
+       2.52467594e+01, 2.78370667e+00, 0., 2.14014225e+01,
+       3.57704163e+00, 0., 2.06142254e+01, 3.73944855e+00,
+       7.62939453e-06, 1.16692066e+01, 5.58490753e+00, 7.62939453e-06,
+       1.07936306e+01, 5.76554871e+00, 0., 4.69162941e+00,
+       7.02445984e+00, 7.62939453e-06, 3.32661057e+00, 7.13448334e+00,
+       2.98072815e-01, 3.14842224e-01, 7.50000000e+00, 0.,
+       9.24171257e+00, 5.73388672e+00, 0., 1.99277821e+01,
+       3.33024597e+00, 0., 1.96148930e+01, 3.39546204e+00, 0.,
+       1.83707714e+01, 3.65476990e+00, 0., 3.35063553e+00,
+       6.78523254e+00, 0., 2.50769215e+01, 2.06906891e+00, 0.,
+       2.16966038e+01, 2.77597046e+00, 0., 1.90223141e+01,
+       3.33523560e+00, 0., 1.07307301e+01, 5.06920624e+00, 0.,
+       9.42392159e+00, 5.34249115e+00, 7.62939453e-06, 2.67685127e+00,
+       6.75345612e+00, 0., 1.04640388e+00, 7.09442902e+00, 0.,
+       2.36546535e+01, 2.17910767e+00, 0., 2.14132137e+01,
+       2.64942932e+00, 0., 1.85864544e+01, 3.24256897e+00,
+       7.62939453e-06, 1.79665203e+01, 3.37265778e+00, 0.,
+       1.67636395e+01, 3.44216156e+00, 0., 1.07722301e+01,
+       4.70358276e+00, 0., 6.31674194e+00, 5.64163208e+00, 0.,
+       9.30160522e-01, 6.77571869e+00, 0., 6.60230637e-01,
+       6.83255768e+00, 0., 2.14816151e+01, 2.26220703e+00, 0.,
+       2.06882000e+01, 2.42981720e+00, 0., 1.98995533e+01,
+       2.59642029e+00, 0., 8.61472511e+00, 4.98032379e+00, 0.,
+       8.18356133e+00, 5.07140350e+00, 0., 1.80558910e+01,
+       2.80130768e+00, 0., 1.72821751e+01, 2.96530151e+00,
+       7.62939453e-06, 1.63597927e+01, 3.16080475e+00, 0.,
+       1.12546787e+01, 4.24288940e+00, 0., 4.66116524e+00,
+       5.64044952e+00, 7.62939453e-06, 9.48883057e-01, 6.42729950e+00,
+       0., 6.78348541e-01, 6.48464966e+00, 0., 2.36413708e+01,
+       1.42845154e+00, 0., 1.20150623e+01, 3.90106201e+00, 0.,
+       1.06880741e+01, 4.18326569e+00, 0., 9.95684624e+00,
+       4.33878326e+00, 0., 3.70034981e+00, 5.66936493e+00, 0.,
+       2.17447033e+01, 1.64382935e+00, 0., 1.99965725e+01,
+       2.01686096e+00, 0., 8.95889854e+00, 4.37216187e+00, 0.,
+       2.50228214e+01, 7.53593445e-01, 0., 2.14594822e+01,
+       1.51651764e+00, 0., 1.47629147e+01, 2.95026398e+00,
+       7.62939453e-06, 1.28050137e+01, 3.36945343e+00, 0.,
+       1.08768024e+01, 3.78228760e+00, 0., 4.28259850e+00,
+       5.19412994e+00, 0., 1.88015347e+01, 1.89891815e+00, 0.,
+       1.61637211e+01, 2.46557617e+00, 0., 1.58569012e+01,
+       2.53148651e+00, 7.62939453e-06, 1.52454586e+01, 2.66282654e+00,
+       0., 1.43337078e+01, 2.85868835e+00, 7.62939453e-06,
+       1.19337406e+01, 3.37425232e+00, 0., 1.14887562e+01,
+       3.46984863e+00, 0., 1.03097210e+01, 3.72312164e+00, 0.,
+       9.43263435e+00, 3.91155243e+00, 0., 7.55309296e+00,
+       4.31529999e+00, 0., 2.21704483e+00, 5.46158600e+00,
+       7.62939453e-06, 2.51012554e+01, 3.54011536e-01, 7.62939453e-06,
+       1.55776882e+01, 2.40671539e+00, 0., 1.40561924e+01,
+       2.73465729e+00, 7.62939453e-06, 8.29059029e+00, 3.97735596e+00,
+       7.62939453e-06, 1.90208912e+01, 1.47695160e+00, 0.,
+       1.87065716e+01, 1.54492950e+00, 0., 1.59114780e+01,
+       2.14939880e+00, 0., 1.25757656e+01, 2.87076569e+00, 0.,
+       1.09401188e+01, 3.22449493e+00, 0., 8.88860512e+00,
+       3.66815948e+00, 7.62939453e-06, 1.76419582e+01, 1.58814240e+00,
+       0., 1.45619907e+01, 2.25643921e+00, 0., 1.39547596e+01,
+       2.38820648e+00, 0., 1.73598499e+01, 1.46215820e+00, 0.,
+       1.42833424e+01, 2.13192749e+00, 0., 1.32237720e+01,
+       2.36260223e+00, -7.62939453e-06, 1.05390491e+01, 2.94707489e+00,
+       0., 4.34903526e+00, 4.29466248e+00, 0., 1.02458572e+00,
+       5.01840973e+00, 7.62939453e-06, 7.51605988e-01, 5.07782745e+00,
+       7.62939453e-06, 1.66120968e+01, 1.43788910e+00, 0.,
+       1.58397121e+01, 1.60659790e+00, 7.62939453e-06, 1.01173115e+01,
+       2.85652924e+00, -7.62939453e-06, 8.79908562e+00, 3.14448547e+00,
+       0., 1.38778515e+01, 1.84965515e+00, 0., 1.22185154e+01,
+       2.21331024e+00, 0., 8.23560143e+00, 3.08618927e+00,
+       7.62939453e-06, 6.79200554e+00, 3.40255737e+00, 0.,
+       2.28261375e+00, 4.39081573e+00, 0., 2.06116238e+01,
+       1.83151245e-01, 0., 1.45123386e+01, 1.52429199e+00, 0.,
+       1.31449146e+01, 1.82495880e+00, 0., 1.10466022e+01,
+       2.28633881e+00, 0., 7.24012375e+00, 3.12331390e+00,
+       7.62939453e-06, 1.22642994e+01, 1.83351135e+00, 0.,
+       7.88711548e-01, 4.36516571e+00, 0., 1.94008656e+01,
+       6.84204102e-02, 0., 1.19867764e+01, 1.70947266e+00,
+       7.62939453e-06, 9.33336830e+00, 2.11306763e+00, 0.,
+       8.01641655e+00, 2.40553284e+00, 0., 1.05365772e+01,
+       1.66087341e+00, 7.62939453e-06, 6.58535004e+00, 2.54124451e+00,
+       0., 2.19885063e+00, 3.51861572e+00, 0., 9.22486687e+00,
+       1.76873016e+00, 0., 7.17968941e+00, 2.22591400e+00, 0.,
+       5.02514076e+00, 2.70755005e+00, 0., 4.45688438e+00,
+       2.83457947e+00, 0., 1.55946026e+01, 1.55296326e-01, 0.,
+       1.11760044e+01, 1.14631653e+00, 7.62939453e-06, 5.32487679e+00,
+       2.45861816e+00, 7.62939453e-06, 6.48934174e+00, 2.01425934e+00,
+       0., 5.91309929e+00, 2.14393616e+00, 7.62939453e-06,
+       3.91718102e+00, 2.59305573e+00, 0., 9.43087959e+00,
+       1.16661072e+00, 0., 6.37683487e+00, 1.67221069e+00, 0.,
+       7.26432037e+00, 1.28625488e+00, 0., 5.52735138e+00,
+       1.68098450e+00, 7.62939453e-06, 2.26507187e+00, 2.42231750e+00,
+       0., 1.01186180e+00, 2.70711517e+00, 0., 1.15869274e+01,
+       1.15409851e-01, 7.62939453e-06, 6.40878868e+00, 1.29598236e+00,
+       0., 7.44474411e-01, 2.58740234e+00, 7.62939453e-06,
+       1.08554211e+01, 9.37728882e-02, 0., 3.84036446e+00,
+       1.69839478e+00, 7.62939453e-06, 3.72404099e+00, 1.35765076e+00,
+       0., 8.38072395e+00, 9.77478027e-02, 7.62939453e-06,
+       4.16493416e+00, 1.07154846e+00, 0., 2.18023109e+00,
+       1.52999878e+00, 7.62939453e-06, 7.51407814e+00, 1.10420227e-01,
+       0., 6.94420052e+00, 5.50003052e-02, 0., 4.78033066e+00,
+       3.71833801e-01, 0., 5.51800919e+00, 1.25503540e-02, 0.,
+       3.51556969e+00, 2.95043945e-01, 7.62939453e-06, 8.29629898e-01,
+       9.25621033e-01, 7.62939453e-06, 1.40040588e+00, 6.06719971e-01,
+       0., 7.08726883e-01, 5.84869385e-01, 0., 4.56521988e-01,
+       8.83483887e-02, 7.62939453e-06, 4.55284119e-02, 5.34057617e-04,
+       1.79255066e+01, 2.47443943e+01, 7.50000000e+00, 1.78975220e+01,
+       2.33396626e+01, 7.50000000e+00, 1.79084091e+01, 2.17636662e+01,
+       7.50000000e+00, 1.81015472e+01, 2.08590717e+01, 7.50000000e+00,
+       1.72232285e+01, 2.34533253e+01, 7.50000763e+00, 1.71205292e+01,
+       2.24244862e+01, 7.50000000e+00, 1.76993790e+01, 1.97226849e+01,
+       7.50000000e+00, 1.62820206e+01, 2.48334522e+01, 7.50000763e+00,
+       1.64924316e+01, 2.23608036e+01, 7.50000000e+00, 1.66084061e+01,
+       2.18212910e+01, 7.50000000e+00, 1.67242432e+01, 2.12824306e+01,
+       7.50000763e+00, 1.71093597e+01, 1.94909649e+01, 7.50000000e+00,
+       1.70080414e+01, 1.84847546e+01, 7.50000000e+00, 1.59465408e+01,
+       2.19393101e+01, 7.49999237e+00, 1.69838028e+01, 1.71302586e+01,
+       7.50000000e+00, 1.70738907e+01, 1.52566051e+01, 7.50000000e+00,
+       1.47473984e+01, 2.45617657e+01, 7.50000000e+00, 1.50188751e+01,
+       2.33073444e+01, 7.49999237e+00, 1.51736450e+01, 2.25921116e+01,
+       7.50000000e+00, 1.72767868e+01, 1.28734379e+01, 7.50000000e+00,
+       1.72142181e+01, 1.17283306e+01, 7.50000000e+00, 1.72647781e+01,
+       1.00712948e+01, 7.50000000e+00, 1.83105927e+01, 5.25436592e+00,
+       7.50000000e+00, 1.37324295e+01, 2.49010334e+01, 7.50000000e+00,
+       1.77255325e+01, 6.53880692e+00, 7.49999237e+00, 1.82084503e+01,
+       4.31804657e+00, 7.50000763e+00, 1.36808472e+01, 2.37078915e+01,
+       7.50000000e+00, 1.71409607e+01, 7.82213402e+00, 7.50000000e+00,
+       1.82177582e+01, 2.87848663e+00, 7.50000000e+00, 1.32815552e+01,
+       2.41177845e+01, 7.50000000e+00, 1.38093109e+01, 2.02890987e+01,
+       7.50000763e+00, 1.71671295e+01, 4.92226791e+00, 7.50000000e+00,
+       1.73893127e+01, 3.90550613e+00, 7.50000000e+00, 1.79424820e+01,
+       1.37398148e+00, 7.50000000e+00, 1.54655380e+01, 1.13217335e+01,
+       7.50000000e+00, 1.70322037e+01, 4.16337013e+00, 7.50000000e+00,
+       1.73645935e+01, 2.64464760e+00, 7.50000000e+00, 1.30944366e+01,
+       2.07606030e+01, 7.50000000e+00, 1.42779770e+01, 1.53613338e+01,
+       7.49999237e+00, 1.55595322e+01, 9.51485252e+00, 7.50000000e+00,
+       1.63954163e+01, 4.33956337e+00, 7.50000000e+00, 1.25761261e+01,
+       2.03560886e+01, 7.50000000e+00, 1.12202148e+01, 2.51425343e+01,
+       7.50000000e+00, 1.13364105e+01, 2.46148891e+01, 7.50000000e+00,
+       1.48715057e+01, 8.56314659e+00, 7.50000000e+00, 1.49834213e+01,
+       8.05500221e+00, 7.50000000e+00, 1.50951996e+01, 7.54744911e+00,
+       7.50000000e+00, 1.28630142e+01, 1.63241215e+01, 7.50000000e+00,
+       1.38078918e+01, 1.20404072e+01, 7.50000000e+00, 1.44825134e+01,
+       8.98186684e+00, 7.50000000e+00, 1.49296494e+01, 6.95468712e+00,
+       7.50000000e+00, 1.13657761e+01, 2.17520695e+01, 7.50000000e+00,
+       1.23219910e+01, 1.74235287e+01, 7.50000000e+00, 1.28533936e+01,
+       1.50179882e+01, 7.50000000e+00, 1.53937683e+01, 3.51833344e+00,
+       7.50000763e+00, 1.55411377e+01, 2.85125160e+00, 7.50000000e+00,
+       1.56882935e+01, 2.18519974e+00, 7.49999237e+00, 1.15142593e+01,
+       1.97300434e+01, 7.50000000e+00, 1.18578873e+01, 1.81769047e+01,
+       7.50000000e+00, 1.34456406e+01, 1.10005398e+01, 7.50000000e+00,
+       1.38945465e+01, 8.97155571e+00, 7.50000000e+00, 1.44156494e+01,
+       6.61627579e+00, 7.50000000e+00, 1.09356613e+01, 2.10004940e+01,
+       7.50000000e+00, 1.20413818e+01, 1.60103436e+01, 7.50000000e+00,
+       1.38071976e+01, 8.04135704e+00, 7.50000000e+00, 1.00109711e+01,
+       2.38316288e+01, 7.49999237e+00, 1.05495758e+01, 2.14045773e+01,
+       7.50000000e+00, 1.08560257e+01, 2.00236454e+01, 7.50000000e+00,
+       1.09324951e+01, 1.96790867e+01, 7.50000000e+00, 1.10470734e+01,
+       1.91627483e+01, 7.50000000e+00, 1.15800400e+01, 1.67611370e+01,
+       7.50000000e+00, 1.22987213e+01, 1.35226345e+01, 7.49999237e+00,
+       1.23740616e+01, 1.31831226e+01, 7.50000000e+00, 1.30121384e+01,
+       1.03078709e+01, 7.50000000e+00, 1.31990128e+01, 9.46579170e+00,
+       7.50000000e+00, 1.49381714e+01, 1.62887383e+00, 7.50000000e+00,
+       1.14990311e+01, 1.58032207e+01, 7.50000763e+00, 1.23661575e+01,
+       1.19016819e+01, 7.50000000e+00, 1.25536575e+01, 1.10580997e+01,
+       7.50000000e+00, 1.33743286e+01, 7.36555672e+00, 7.50000000e+00,
+       9.24143982e+00, 2.46317997e+01, 7.50000000e+00, 1.02022400e+01,
+       2.03152637e+01, 7.50000000e+00, 1.08122559e+01, 1.75746250e+01,
+       7.50000000e+00, 1.10021133e+01, 1.67216587e+01, 7.50000000e+00,
+       1.34372406e+01, 5.78150177e+00, 7.50000000e+00, 1.35112076e+01,
+       5.44919014e+00, 7.50000000e+00, 1.00107574e+01, 1.98602810e+01,
+       7.50000000e+00, 1.03538895e+01, 1.83210087e+01, 7.50000000e+00,
+       1.10743561e+01, 1.50889874e+01, 7.50000000e+00, 1.13761292e+01,
+       1.37352161e+01, 7.50000000e+00, 1.25367966e+01, 8.52851295e+00,
+       7.50000000e+00, 1.27227097e+01, 7.69450378e+00, 7.50000000e+00,
+       1.39041977e+01, 2.39438820e+00, 7.49999237e+00, 9.59107971e+00,
+       2.04336491e+01, 7.50000000e+00, 1.04285202e+01, 1.66824780e+01,
+       7.50000000e+00, 1.12212906e+01, 1.31313915e+01, 7.49999237e+00,
+       1.13340073e+01, 1.26264286e+01, 7.50000000e+00, 1.28247833e+01,
+       5.94878006e+00, 7.50000000e+00, 9.78272247e+00, 1.82758579e+01,
+       7.49999237e+00, 1.17032013e+01, 9.68596840e+00, 7.50000000e+00,
+       1.36232147e+01, 1.09826088e+00, 7.50000000e+00, 8.06295776e+00,
+       2.46658688e+01, 7.50000763e+00, 8.71641541e+00, 2.17473660e+01,
+       7.50000763e+00, 8.98425293e+00, 2.05511990e+01, 7.50000000e+00,
+       9.28945160e+00, 1.91881046e+01, 7.50000000e+00, 9.63169098e+00,
+       1.76596317e+01, 7.49999237e+00, 1.03502808e+01, 1.44501743e+01,
+       7.50000000e+00, 1.21056137e+01, 6.61054420e+00, 7.50000000e+00,
+       1.22905045e+01, 5.78476715e+00, 7.50000000e+00, 1.25119171e+01,
+       4.79590988e+00, 7.50000000e+00, 9.59502411e+00, 1.65398464e+01,
+       7.50000000e+00, 1.06116867e+01, 1.20058537e+01, 7.49999237e+00,
+       1.12464447e+01, 9.17500114e+00, 7.50000000e+00, 1.17661133e+01,
+       6.85741997e+00, 7.50000000e+00, 9.06675720e+00, 1.76172123e+01,
+       7.50000000e+00, 9.25621796e+00, 1.67735271e+01, 7.50000000e+00,
+       9.40752411e+00, 1.60997448e+01, 7.50000000e+00, 1.13165207e+01,
+       7.59849548e+00, 7.50000000e+00, 8.08203125e+00, 2.07259731e+01,
+       7.50000000e+00, 9.93544006e+00, 1.24841976e+01, 7.50000000e+00,
+       1.01226196e+01, 1.16518269e+01, 7.50000000e+00, 1.15705185e+01,
+       5.21323776e+00, 7.50000763e+00, 9.11047363e+00, 1.48910465e+01,
+       7.50000000e+00, 9.37376404e+00, 1.37219028e+01, 7.50000000e+00,
+       1.06427231e+01, 8.08718681e+00, 7.50000000e+00, 7.52397919e+00,
+       2.06722889e+01, 7.50000000e+00, 7.79064941e+00, 1.94898739e+01,
+       7.50000000e+00, 9.30086517e+00, 1.27933979e+01, 7.50000000e+00,
+       9.74948120e+00, 1.08042202e+01, 7.50000000e+00, 1.04556198e+01,
+       7.67308426e+00, 7.50000000e+00, 1.10831528e+01, 4.89048195e+00,
+       7.50000763e+00, 1.18163376e+01, 1.63951302e+00, 7.50000000e+00,
+       6.77932739e+00, 2.14623508e+01, 7.50000000e+00, 8.29508972e+00,
+       1.47602673e+01, 7.50000000e+00, 1.00100937e+01, 7.17727470e+00,
+       7.50000000e+00, 1.04894028e+01, 5.05792427e+00, 7.50000000e+00,
+       1.11857758e+01, 1.97890854e+00, 7.50000000e+00, 5.98741913e+00,
+       2.37150822e+01, 7.50000000e+00, 6.06410980e+00, 2.33764439e+01,
+       7.50000000e+00, 8.63737488e+00, 1.20145664e+01, 7.50000000e+00,
+       8.00669098e+00, 1.35709476e+01, 7.50000000e+00, 9.78937531e+00,
+       5.71080208e+00, 7.50000000e+00, 5.21003723e+00, 2.46643391e+01,
+       7.50000000e+00, 6.12774658e+00, 2.06235943e+01, 7.50000000e+00,
+       7.26321411e+00, 1.56240711e+01, 7.50000000e+00, 9.12740326e+00,
+       7.41599274e+00, 7.50000000e+00, 7.12185669e+00, 1.50284290e+01,
+       7.50000763e+00, 7.19697571e+00, 1.46981831e+01, 7.50000000e+00,
+       7.27202606e+00, 1.43681850e+01, 7.50000000e+00, 7.45941162e+00,
+       1.35442715e+01, 7.50000000e+00, 1.00098419e+01, 2.33013916e+00,
+       7.50000000e+00, 6.37936401e+00, 1.70783253e+01, 7.50000000e+00,
+       9.20626068e+00, 4.66567230e+00, 7.50000763e+00, 1.00097733e+01,
+       1.13757515e+00, 7.50000000e+00, 4.37796021e+00, 2.46470699e+01,
+       7.50000000e+00, 7.06558228e+00, 1.28621540e+01, 7.50000000e+00,
+       4.66346741e+00, 2.21854458e+01, 7.49999237e+00, 3.95590973e+00,
+       2.40773067e+01, 7.50000000e+00, 4.03244781e+00, 2.37426357e+01,
+       7.50000000e+00, 4.10892487e+00, 2.34082165e+01, 7.50000000e+00,
+       4.29985809e+00, 2.25732632e+01, 7.50000000e+00, 4.98425293e+00,
+       1.95804081e+01, 7.50000000e+00, 5.06001282e+00, 1.92491207e+01,
+       7.50000000e+00, 5.13571930e+00, 1.89180698e+01, 7.50000000e+00,
+       6.11471558e+00, 1.46369915e+01, 7.50000000e+00, 6.74969482e+00,
+       1.18602085e+01, 7.50000000e+00, 4.20405579e+00, 2.17948055e+01,
+       7.50000000e+00, 5.26438141e+00, 1.71643543e+01, 7.50000000e+00,
+       6.23907471e+00, 1.29078045e+01, 7.50000000e+00, 6.94541931e+00,
+       9.82317543e+00, 7.50000000e+00, 8.12387085e+00, 4.67679977e+00,
+       7.50000000e+00, 8.74430084e+00, 1.96738052e+00, 7.50000000e+00,
+       3.72821808e+00, 2.26801586e+01, 7.50000000e+00, 4.79019928e+00,
+       1.80486889e+01, 7.50000000e+00, 5.24194336e+00, 1.60785580e+01,
+       7.50000000e+00, 2.94717407e+00, 2.48966351e+01, 7.50000000e+00,
+       4.65628052e+00, 1.74528904e+01, 7.50000000e+00, 5.14469910e+00,
+       1.53256397e+01, 7.50000000e+00, 7.03825378e+00, 7.07854652e+00,
+       7.50000763e+00, 3.35083771e+00, 2.19584522e+01, 7.50000000e+00,
+       4.67327881e+00, 1.62064228e+01, 7.50000000e+00, 5.04797363e+00,
+       1.45766811e+01, 7.50000000e+00, 7.37698364e+00, 4.44656563e+00,
+       7.49999237e+00, 8.06886292e+00, 1.43716240e+00, 7.50000000e+00,
+       5.43574524e+00, 1.17292843e+01, 7.50000000e+00, 5.54711151e+00,
+       1.12455578e+01, 7.49999237e+00, 5.99133301e+00, 9.31597710e+00,
+       7.50000000e+00, 6.36000824e+00, 7.71447563e+00, 7.50000763e+00,
+       6.50710297e+00, 7.07552147e+00, 7.50000000e+00, 6.58057404e+00,
+       6.75639915e+00, 7.50000000e+00, 6.65399170e+00, 6.43750954e+00,
+       7.49999237e+00, 2.13872528e+00, 2.48783627e+01, 7.50000000e+00,
+       5.41308594e+00, 1.06739559e+01, 7.50000000e+00, 5.81964874e+00,
+       8.91027641e+00, 7.50000000e+00, 5.89338684e+00, 8.59036827e+00,
+       7.50000763e+00, 6.51803589e+00, 5.88061714e+00, 7.50000000e+00,
+       6.70101166e+00, 5.08683586e+00, 7.50000000e+00, 2.12570190e+00,
+       2.37695141e+01, 7.50000000e+00, 2.50634766e+00, 2.21204281e+01,
+       7.49999237e+00, 2.69613647e+00, 2.12981815e+01, 7.50000000e+00,
+       5.05766296e+00, 1.10671787e+01, 7.50000000e+00, 2.18877411e+00,
+       2.23384113e+01, 7.50000000e+00, 2.79489136e+00, 1.97159138e+01,
+       7.50000000e+00, 4.66609192e+00, 1.16197681e+01, 7.50000000e+00,
+       5.55213928e+00, 7.78610420e+00, 7.50000000e+00, 5.95565033e+00,
+       6.04020882e+00, 7.50000000e+00, 1.33883667e+00, 2.48602848e+01,
+       7.50000000e+00, 4.68280792e+00, 1.04107151e+01, 7.50000000e+00,
+       1.40442657e+00, 2.34287891e+01, 7.50000000e+00, 1.70839691e+00,
+       2.21169872e+01, 7.49999237e+00, 2.31365967e+00, 1.95049801e+01,
+       7.50000000e+00, 1.99897766e+00, 1.97251148e+01, 7.50000000e+00,
+       6.02942657e+00, 2.35407639e+00, 7.50000000e+00, 2.28700256e+00,
+       1.73544445e+01, 7.49999237e+00, 4.76892090e+00, 6.67113304e+00,
+       7.50000000e+00, 2.27378082e+00, 1.62887020e+01, 7.50000000e+00,
+       2.46055603e+00, 1.54857464e+01, 7.50000000e+00, 2.75869751e+00,
+       1.42040577e+01, 7.50000000e+00, 4.27310944e+00, 7.69363403e+00,
+       7.50000763e+00, 4.29082489e+00, 6.51264000e+00, 7.50000763e+00,
+       5.45359802e+00, 1.52027321e+00, 7.50000000e+00, 2.24758148e+00,
+       1.41760159e+01, 7.50000763e+00, 2.27165985e+00, 1.29702320e+01,
+       7.50000000e+00, 4.47108459e+00, 3.55080605e+00, 7.50000000e+00,
+       4.65222931e+00, 2.77498055e+00, 7.50000000e+00, 0.,
+       2.45059147e+01, 6.94252014e+00, 3.76245117e+00, 5.49772453e+00,
+       7.49999237e+00, 4.74073792e+00, 1.31323433e+00, 7.50000000e+00,
+       3.81784058e+00, 4.17956352e+00, 7.50000000e+00, 0.,
+       2.32701054e+01, 6.75254059e+00, 0., 2.25187588e+01,
+       6.89745331e+00, 2.41637421e+00, 9.08439445e+00, 7.50000763e+00,
+       3.03793335e+00, 6.43239212e+00, 7.50000763e+00, 3.29277039e+00,
+       5.34507370e+00, 7.50000000e+00, 4.08956146e+00, 1.94539833e+00,
+       7.50000000e+00, 4.16168976e+00, 1.63765526e+00, 7.50000000e+00,
+       4.03557587e+00, 1.10843277e+00, 7.50000000e+00, 2.49919128e+00,
+       6.58670235e+00, 7.50000000e+00, 0., 1.91166325e+01,
+       6.92028046e+00, 2.84833527e+00, 4.03971863e+00, 7.50000000e+00,
+       2.95687103e+00, 3.57834435e+00, 7.50000000e+00, 2.03673553e+00,
+       6.43098259e+00, 7.49999237e+00, 2.47234344e+00, 4.58143616e+00,
+       7.50000000e+00, 0., 2.36753941e+01, 5.59777832e+00, 0.,
+       1.71845226e+01, 6.87595367e+00, 1.07710266e+00, 9.44779778e+00,
+       7.50000000e+00, 2.09718323e+00, 5.12197113e+00, 7.49999237e+00,
+       2.42290497e+00, 3.74061203e+00, 7.50000000e+00, 0.,
+       1.64956341e+01, 6.80059052e+00, 0., 1.52405682e+01,
+       7.04875946e+00, 9.94705200e-01, 8.74534416e+00, 7.50000000e+00,
+       1.35941315e+00, 7.20060349e+00, 7.50000000e+00, 2.44580841e+00,
+       2.59903145e+00, 7.50000000e+00, 7.62939453e-06, 2.51046200e+01,
+       4.87963867e+00, 0., 1.45588017e+01, 6.97360992e+00,
+       2.50446320e+00, 1.31244087e+00, 7.50000763e+00, 1.55619812e+00,
+       4.28723717e+00, 7.50000000e+00, 2.16850281e+00, 1.69995880e+00,
+       7.50000000e+00, 7.62939453e-06, 1.33774662e+01, 6.78862762e+00,
+       1.25698090e+00, 4.51917648e+00, 7.50000000e+00, 2.08453369e+00,
+       1.02648926e+00, 7.50000763e+00, 0., 2.50498104e+01,
+       4.23158264e+00, 7.62939453e-06, 2.04907055e+01, 5.14810181e+00,
+       7.62939453e-06, 1.25251369e+01, 6.74942780e+00, 7.62939453e-06,
+       1.11286106e+01, 7.03017426e+00, 1.42720795e+00, 2.77517128e+00,
+       7.50000000e+00, 1.78620148e+00, 1.26182556e+00, 7.50000763e+00,
+       0., 2.16565762e+01, 4.69580841e+00, 0., 2.04207363e+01,
+       4.50986481e+00, 0., 2.36882496e+01, 3.62361145e+00,
+       7.62939453e-06, 2.00851727e+01, 4.35991669e+00, 0.,
+       7.44579124e+00, 6.94286346e+00, 0., 2.04990177e+01,
+       4.05622864e+00, 0., 1.26616955e+01, 5.66439056e+00, 0.,
+       7.12698364e+00, 6.80007172e+00, 0., 6.78906250e+00,
+       6.86940765e+00, 7.62939453e-06, 5.44649506e+00, 7.14489746e+00,
+       0., 5.11311722e+00, 7.21330261e+00, 8.43383789e-01,
+       1.81314468e-01, 7.50000000e+00, 0., 4.79699707e+00,
+       7.07167053e+00, 2.93296814e-01, 4.99448776e-01, 7.49999237e+00,
+       7.62939453e-06, 2.38659229e+01, 2.69622803e+00, 7.62939453e-06,
+       2.00522175e+01, 3.48838806e+00, 0., 1.96768703e+01,
+       3.56635284e+00, 7.62939453e-06, 3.33860970e+00, 6.96004486e+00,
+       0., 2.50783978e+01, 2.21920013e+00, 0., 1.08308887e+01,
+       5.19064331e+00, 0., 2.69516182e+00, 6.88742828e+00, 0.,
+       1.06582260e+00, 7.22724915e+00, 7.62939453e-06, 2.37615681e+01,
+       2.26920319e+00, 0., 2.14562244e+01, 2.75195312e+00,
+       7.62939453e-06, 1.86302891e+01, 3.34371948e+00, 7.62939453e-06,
+       1.80723743e+01, 3.46055603e+00, 0., 9.28714943e+00,
+       5.30023193e+00, 0., 1.08809566e+01, 4.75223541e+00,
+       7.62939453e-06, 7.64465332e-01, 6.87927246e+00, 0.,
+       1.81441021e+01, 3.00413513e+00, 7.62939453e-06, 1.74016743e+01,
+       3.16086578e+00, 0., 8.12265587e+00, 5.11972809e+00,
+       7.62939453e-06, 2.37014027e+01, 1.60468292e+00, 7.62939453e-06,
+       1.63291569e+01, 3.16729736e+00, 7.62939453e-06, 1.19927158e+01,
+       4.08644867e+00, 7.62939453e-06, 1.05794735e+01, 4.38600159e+00,
+       0., 1.00535603e+01, 4.49747467e+00, 0., 3.74325562e+00,
+       5.83501434e+00, 0., 2.16210918e+01, 1.82056427e+00, 0.,
+       1.13099041e+01, 4.01494598e+00, 0., 1.09565754e+01,
+       4.09013367e+00, 7.62939453e-06, 9.03079033e+00, 4.49996948e+00,
+       0., 1.54774456e+01, 2.90766907e+00, 7.62939453e-06,
+       1.29404240e+01, 3.44975281e+00, 7.62939453e-06, 4.27467346e+00,
+       5.30139160e+00, 7.62939453e-06, 1.88518391e+01, 1.96282959e+00,
+       7.62939453e-06, 1.62448330e+01, 2.52211761e+00, 0.,
+       1.38703594e+01, 3.03153229e+00, 0., 1.18951054e+01,
+       3.45528412e+00, 0., 1.04776478e+01, 3.75937653e+00, 0.,
+       7.51758766e+00, 4.39440918e+00, 0., 2.29513741e+00,
+       5.51479340e+00, 0., 2.50604839e+01, 4.01153564e-01, 0.,
+       1.81377316e+01, 1.89227295e+00, 0., 1.68331966e+01,
+       2.17326355e+00, 0., 1.42630634e+01, 2.72685242e+00, 0.,
+       2.57022038e+01, 3.20663452e-02, 7.62939453e-06, 1.87379704e+01,
+       1.53813171e+00, 0., 1.76124058e+01, 1.78154755e+00, 0.,
+       1.46579800e+01, 2.42047119e+00, 0., 1.10583630e+01,
+       3.19892883e+00, 7.62939453e-06, 1.72742786e+01, 1.63052368e+00,
+       7.62939453e-06, 1.32346859e+01, 2.50762177e+00, 7.62939453e-06,
+       1.07290630e+01, 3.05165863e+00, -7.62939453e-06, 4.50681305e+00,
+       4.40267181e+00, 0., 8.53237152e-01, 5.19594574e+00,
+       7.62939453e-06, 1.58233166e+01, 1.72210693e+00, 0.,
+       1.12877674e+01, 2.71083832e+00, 0., 8.99190712e+00,
+       3.21131897e+00, 0., 1.45679035e+01, 1.77285767e+00, 0.,
+       8.31551552e+00, 3.14128876e+00, 0., 1.31401119e+01,
+       1.86310577e+00, 0., 1.26253834e+01, 1.75386047e+00, 0.,
+       1.91530933e+01, 8.51058960e-02, 0., 1.15716953e+01,
+       1.76430511e+00, 7.62939453e-06, 9.25909996e+00, 2.27651978e+00,
+       7.62939453e-06, 8.03127480e+00, 2.54846954e+00, 0.,
+       1.05240536e+01, 1.77470398e+00, 0., 6.66208649e+00,
+       2.63348389e+00, 0., 5.80081940e+00, 2.82500458e+00, 0.,
+       9.12885094e+00, 1.86397552e+00, 7.62939453e-06, 7.20193291e+00,
+       2.29415131e+00, -7.62939453e-06, 2.26107597e+00, 3.39721680e+00,
+       -7.62939453e-06, 1.56821728e+01, 1.73606873e-01, 0.,
+       9.70727348e+00, 1.29016113e+00, 0., 3.97376060e+00,
+       2.58032227e+00, 0., 6.56647110e+00, 1.77650452e+00, 0.,
+       8.68982506e+00, 1.07395172e+00, 0., 7.28325272e+00,
+       1.39297485e+00, 7.62939453e-06, 4.00519562e+00, 2.13643646e+00,
+       0., 6.60534286e+00, 1.32514954e+00, 0., 8.23743820e-01,
+       2.64159393e+00, 0., 3.86618042e+00, 1.72915649e+00, 0.,
+       9.31497383e+00, 3.27606201e-02, 0., 4.23991966e+00,
+       1.20198059e+00, 0., 2.36822319e+00, 1.63320160e+00, 0.,
+       7.56238747e+00, 2.11807251e-01, 0., 4.97935295e+00,
+       3.62731934e-01, 0., 9.03902054e-01, 1.09230042e+00, 0.,
+       1.20649338e-01, 1.68479919e-01, 1.85181961e+01, 2.56803493e+01,
+       7.50000000e+00, 1.79332962e+01, 2.47077847e+01, 7.50000000e+00,
+       1.77736435e+01, 2.17875652e+01, 7.50000000e+00, 1.70452118e+01,
+       2.33785229e+01, 7.50000000e+00, 1.67551117e+01, 2.11388416e+01,
+       7.50000000e+00, 1.69572067e+01, 1.84265804e+01, 7.49999237e+00,
+       1.48706055e+01, 2.45761166e+01, 7.50000000e+00, 1.51498566e+01,
+       2.32848721e+01, 7.50000000e+00, 1.72795105e+01, 1.17130413e+01,
+       7.50000000e+00, 1.37453537e+01, 2.45547428e+01, 7.50000763e+00,
+       1.38849411e+01, 2.39131107e+01, 7.50000000e+00, 1.71303940e+01,
+       8.99373055e+00, 7.50000000e+00, 1.76681824e+01, 6.52156067e+00,
+       7.50000000e+00, 1.81584778e+01, 4.26767540e+00, 7.50000000e+00,
+       1.70118942e+01, 7.85518074e+00, 7.50000000e+00, 1.81255569e+01,
+       2.74553680e+00, 7.50000000e+00, 1.69554443e+01, 4.78873062e+00,
+       7.50000000e+00, 1.72218399e+01, 3.57111740e+00, 7.50000000e+00,
+       1.74432755e+01, 2.55904579e+00, 7.49999237e+00, 1.30867462e+01,
+       2.07956448e+01, 7.50000763e+00, 1.63245850e+01, 4.39079475e+00,
+       7.50000000e+00, 1.21888428e+01, 2.15669918e+01, 7.50000000e+00,
+       1.45856857e+01, 9.05172157e+00, 7.50000000e+00, 1.51221619e+01,
+       6.61802483e+00, 7.50000000e+00, 1.18501282e+01, 1.98301220e+01,
+       7.50000000e+00, 1.26277695e+01, 1.63088436e+01, 7.50000000e+00,
+       1.29461823e+01, 1.48670559e+01, 7.50000000e+00, 1.46120071e+01,
+       7.32397652e+00, 7.50000000e+00, 1.55890121e+01, 2.90000534e+00,
+       7.50000000e+00, 1.57655716e+01, 2.10046959e+00, 7.50000000e+00,
+       1.18883743e+01, 1.80391102e+01, 7.50000000e+00, 1.34756393e+01,
+       1.08649807e+01, 7.50000000e+00, 1.41033249e+01, 8.02791405e+00,
+       7.49999237e+00, 1.07355499e+01, 2.16353970e+01, 7.50000000e+00,
+       1.11493759e+01, 1.97684155e+01, 7.50000000e+00, 1.19717865e+01,
+       1.60579739e+01, 7.50000000e+00, 1.26066895e+01, 1.31935558e+01,
+       7.50000763e+00, 1.51935425e+01, 1.52278137e+00, 7.49999237e+00,
+       9.90301514e+00, 2.37835484e+01, 7.50000000e+00, 1.14641037e+01,
+       1.67532101e+01, 7.50000000e+00, 1.30902939e+01, 9.42974663e+00,
+       7.50000000e+00, 1.32693176e+01, 8.62354469e+00, 7.50000000e+00,
+       9.39499664e+00, 2.44721241e+01, 7.50000000e+00, 1.13220215e+01,
+       1.58094807e+01, 7.50000000e+00, 1.24063950e+01, 1.09348545e+01,
+       7.50000000e+00, 1.32118149e+01, 7.31420517e+00, 7.50000000e+00,
+       1.35232391e+01, 5.91426086e+00, 7.49999237e+00, 1.04074326e+01,
+       1.83426189e+01, 7.50000000e+00, 1.14523926e+01, 1.36535053e+01,
+       7.50000000e+00, 1.27542343e+01, 7.81175041e+00, 7.50000763e+00,
+       1.39948425e+01, 2.24478722e+00, 7.50000000e+00, 1.13565521e+01,
+       1.25255032e+01, 7.49999237e+00, 9.31050110e+00, 2.01284924e+01,
+       7.50000000e+00, 9.40210724e+00, 1.97189159e+01, 7.50000000e+00,
+       9.76766205e+00, 1.80843716e+01, 7.50000000e+00, 1.16648178e+01,
+       9.60133934e+00, 7.50000000e+00, 1.20220337e+01, 8.00399208e+00,
+       7.50000763e+00, 1.25111084e+01, 5.81716537e+00, 7.50000000e+00,
+       9.76853943e+00, 1.65344410e+01, 7.50000000e+00, 1.02217789e+01,
+       1.45113506e+01, 7.50000000e+00, 1.24128647e+01, 4.73115540e+00,
+       7.50000000e+00, 1.11176071e+01, 8.98940086e+00, 7.50000000e+00,
+       1.13850403e+01, 7.79778481e+00, 7.50000000e+00, 1.17848206e+01,
+       6.01644516e+00, 7.50000000e+00, 8.13424683e+00, 2.07483463e+01,
+       7.50000000e+00, 9.18260193e+00, 1.60851307e+01, 7.50000000e+00,
+       9.99537659e+00, 1.24698315e+01, 7.49999237e+00, 1.02199554e+01,
+       1.14708385e+01, 7.50000763e+00, 1.16452637e+01, 5.13090515e+00,
+       7.50000763e+00, 9.14060211e+00, 1.47572689e+01, 7.50000000e+00,
+       1.06204681e+01, 8.18599510e+00, 7.49999237e+00, 7.73884583e+00,
+       1.94681034e+01, 7.50000000e+00, 9.23389435e+00, 1.28408184e+01,
+       7.50000000e+00, 9.72725677e+00, 1.06537685e+01, 7.50000000e+00,
+       1.18078613e+01, 1.43077660e+00, 7.50000000e+00, 6.92591858e+00,
+       2.15637608e+01, 7.50000000e+00, 7.15486145e+00, 2.05506039e+01,
+       7.50000000e+00, 1.06155930e+01, 5.23577118e+00, 7.50000000e+00,
+       6.06662750e+00, 2.38636379e+01, 7.50000000e+00, 8.11807251e+00,
+       1.48007298e+01, 7.49999237e+00, 9.86239624e+00, 7.09462166e+00,
+       7.49999237e+00, 8.08037567e+00, 1.34909840e+01, 7.50000000e+00,
+       9.81871033e+00, 5.82427025e+00, 7.50000000e+00, 5.36357117e+00,
+       2.39883251e+01, 7.49999237e+00, 5.63935089e+00, 2.27740765e+01,
+       7.49999237e+00, 6.14297485e+00, 2.05565586e+01, 7.50000000e+00,
+       7.27827454e+00, 1.55577908e+01, 7.50000000e+00, 9.11262512e+00,
+       7.48104858e+00, 7.50000000e+00, 7.15373993e+00, 1.46456013e+01,
+       7.50000000e+00, 7.42360687e+00, 1.34593296e+01, 7.50000000e+00,
+       9.95146179e+00, 2.34756851e+00, 7.50000000e+00, 9.11933136e+00,
+       4.57025719e+00, 7.50000000e+00, 4.22796631e+00, 2.45764217e+01,
+       7.50000763e+00, 5.73522186e+00, 1.79727459e+01, 7.50000000e+00,
+       6.36790466e+00, 1.52007542e+01, 7.50000000e+00, 4.20450592e+00,
+       2.32305889e+01, 7.50000000e+00, 4.34197235e+00, 2.26292896e+01,
+       7.50000000e+00, 5.20828247e+00, 1.88399258e+01, 7.50000000e+00,
+       3.72327423e+00, 2.38944302e+01, 7.49999237e+00, 4.22689056e+00,
+       2.16950665e+01, 7.50000763e+00, 5.27190399e+00, 1.71314449e+01,
+       7.50000000e+00, 6.52964783e+00, 1.16388493e+01, 7.50000000e+00,
+       8.12387085e+00, 4.67679596e+00, 7.50000000e+00, 8.78067017e+00,
+       1.80852318e+00, 7.50000000e+00, 4.43090820e+00, 1.93787632e+01,
+       7.50000000e+00, 4.79352570e+00, 1.77977581e+01, 7.50000000e+00,
+       5.19992065e+00, 1.60258846e+01, 7.50000000e+00, 5.96310425e+00,
+       1.26983700e+01, 7.50000000e+00, 6.67613983e+00, 9.58950996e+00,
+       7.50000000e+00, 7.25177765e+00, 7.07975960e+00, 7.50000000e+00,
+       3.58923340e+00, 2.16279125e+01, 7.49999237e+00, 4.81343079e+00,
+       1.62989216e+01, 7.49999237e+00, 5.08347321e+00, 1.51234035e+01,
+       7.50000000e+00, 8.22509003e+00, 1.44787979e+00, 7.50000000e+00,
+       2.51747131e+00, 2.48757687e+01, 7.50000000e+00, 4.92292023e+00,
+       1.44214840e+01, 7.50000000e+00, 6.52478790e+00, 7.45965385e+00,
+       7.49999237e+00, 5.25443268e+00, 1.15925808e+01, 7.50000000e+00,
+       6.58181000e+00, 5.83281136e+00, 7.50000000e+00, 6.75747681e+00,
+       5.07056427e+00, 7.50000000e+00, 2.02650452e+00, 2.41992817e+01,
+       7.49999237e+00, 2.16381836e+00, 2.36043186e+01, 7.50000000e+00,
+       5.18355560e+00, 1.05217495e+01, 7.49999237e+00, 5.40533447e+00,
+       9.56088829e+00, 7.50000000e+00, 6.15576935e+00, 6.30971336e+00,
+       7.50000000e+00, 2.14817047e+00, 2.22833271e+01, 7.50000000e+00,
+       2.37583923e+00, 2.12985401e+01, 7.50000000e+00, 2.73905182e+00,
+       1.97274189e+01, 7.49999237e+00, 4.62496948e+00, 1.15697422e+01,
+       7.50000000e+00, 5.51083374e+00, 7.73785973e+00, 7.50000000e+00,
+       1.26592255e+00, 2.47149792e+01, 7.50000000e+00, 4.55648041e+00,
+       1.05035229e+01, 7.50000000e+00, 1.25354004e+00, 2.33939114e+01,
+       7.50000000e+00, 1.57257080e+00, 2.20181713e+01, 7.50000000e+00,
+       1.83087158e+00, 1.95436077e+01, 7.50000000e+00, 2.37215424e+00,
+       1.72130871e+01, 7.50000763e+00, 2.31115723e+00, 1.61279888e+01,
+       7.50000763e+00, 4.52943420e+00, 6.59173775e+00, 7.50000000e+00,
+       1.03607178e+00, 2.02632351e+01, 7.50000000e+00, 5.42027283e+00,
+       1.44437599e+00, 7.50000000e+00, 4.61334229e+00, 3.59465599e+00,
+       7.50000000e+00, 2.13059235e+00, 1.29155903e+01, 7.50000000e+00,
+       4.50295258e+00, 2.76307487e+00, 7.50000000e+00, 4.80647278e+00,
+       1.46420479e+00, 7.49999237e+00, 0., 2.49219723e+01,
+       6.69159698e+00, 2.40904999e+00, 9.11569405e+00, 7.50000000e+00,
+       3.06708527e+00, 6.30798531e+00, 7.50000000e+00, 3.28549957e+00,
+       5.37609863e+00, 7.50000000e+00, 2.81349945e+00, 4.82373428e+00,
+       7.50000000e+00, 1.86722565e+00, 6.30731964e+00, 7.50000000e+00,
+       0., 2.36429768e+01, 5.38727570e+00, 0., 1.65316792e+01,
+       6.79345703e+00, 2.24388885e+00, 3.45429230e+00, 7.49999237e+00,
+       2.46021271e+00, 2.53800011e+00, 7.50000000e+00, 0.,
+       2.50752888e+01, 4.84168243e+00, 0., 2.18777561e+01,
+       5.47710419e+00, 2.48744965e+00, 1.17749977e+00, 7.50000000e+00,
+       1.52307892e+00, 4.01406288e+00, 7.50000000e+00, 1.55363464e+00,
+       2.65148163e+00, 7.50000000e+00, 0., 2.15730152e+01,
+       4.75627899e+00, 7.62939453e-06, 2.04471798e+01, 4.98335266e+00,
+       0., 1.11487255e+01, 6.85879517e+00, 1.62696075e+00,
+       1.11768723e+00, 7.50000000e+00, 0., 1.99135647e+01,
+       4.30760193e+00, 7.24342346e-01, 8.28971863e-02, 7.49999237e+00,
+       7.62939453e-06, 2.13635616e+01, 3.48171997e+00, 3.73100281e-01,
+       3.63380432e-01, 7.50000000e+00, 0., 2.00522213e+01,
+       3.48838806e+00, 0., 2.51659718e+01, 2.15581512e+00, 0.,
+       1.09410419e+01, 5.12495422e+00, 0., 2.15107403e+01,
+       2.65129089e+00, 0., 1.85703716e+01, 3.26802063e+00, 0.,
+       1.79011364e+01, 3.40838623e+00, 7.62939453e-06, 1.74987774e+01,
+       3.22859955e+00, 0., 8.68282318e-01, 6.73374939e+00, 0.,
+       1.79866657e+01, 2.86029816e+00, 0., 1.62123203e+01,
+       3.23608398e+00, 0., 1.18808422e+01, 4.15344238e+00, 0.,
+       1.12436466e+01, 4.28839874e+00, 0., 7.89870262e+00,
+       4.99681854e+00, 0., 2.37461452e+01, 1.36831665e+00, 0.,
+       1.06394215e+01, 4.15763092e+00, -7.62939453e-06, 9.79756355e+00,
+       4.33679199e+00, 0., 8.96130943e+00, 4.51475525e+00,
+       7.62939453e-06, 2.21710720e+01, 1.43212891e+00, 0.,
+       2.14790516e+01, 1.58011627e+00, 0., 1.54106426e+01,
+       2.87781525e+00, 0., 1.28025646e+01, 3.43553925e+00,
+       7.62939453e-06, 1.15182934e+01, 3.71016693e+00, 0.,
+       4.27783775e+00, 5.25850677e+00, 7.62939453e-06, 1.92437115e+01,
+       1.78894043e+00, 7.62939453e-06, 1.39184551e+01, 2.93321991e+00,
+       0., 7.35369873e+00, 4.34384155e+00, 0., 2.10252190e+00,
+       5.47219849e+00, 0., 2.50887661e+01, 2.56927490e-01, 0.,
+       1.86101894e+01, 1.65573120e+00, 7.62939453e-06, 1.68166103e+01,
+       2.04298401e+00, 0., 1.61503773e+01, 2.18683624e+00, 0.,
+       1.77530231e+01, 1.57154083e+00, 0., 4.53727722e+00,
+       4.43871307e+00, 0., 1.42448330e+01, 2.06620789e+00,
+       -7.62939453e-06, 1.12164974e+01, 2.72637177e+00, 0.,
+       9.09694862e+00, 3.18842316e+00, 0., 2.14908791e+00,
+       4.70300293e+00, 0., 7.66204834e-01, 5.00446320e+00, 0.,
+       1.32242222e+01, 1.75553894e+00, 0., 1.26060543e+01,
+       1.62443542e+00, 0., 9.39085197e+00, 2.33544159e+00,
+       7.62939453e-06, 2.21186638e+00, 3.66597748e+00, 0.,
+       9.02297401e+00, 1.88761139e+00, 0., 7.13241196e+00,
+       2.30967712e+00, 0., 5.68158913e+00, 2.63357544e+00, 0.,
+       2.24355125e+00, 3.14250946e+00, 0., 8.87905121e-01,
+       2.67031097e+00, 0., 3.93439865e+00, 1.71356964e+00, 0.,
+       8.36298561e+00, 1.61964417e-01, 0., 4.17778587e+00,
+       1.12770081e+00, 0., 2.33984947e+00, 1.55179596e+00,
+       7.62939453e-06, 4.07575607e-01, 4.11827087e-01, 1.78237762e+01,
+       2.48526363e+01, 7.50000000e+00, 1.67273407e+01, 2.12680683e+01,
+       7.49999237e+00, 1.49699631e+01, 2.30678196e+01, 7.50000000e+00,
+       1.70298615e+01, 1.14945164e+01, 7.50000000e+00, 1.37546692e+01,
+       2.45119381e+01, 7.50000000e+00, 1.38663483e+01, 2.39986095e+01,
+       7.49999237e+00, 1.71034317e+01, 9.11770821e+00, 7.50000000e+00,
+       1.76413651e+01, 6.64483643e+00, 7.50000000e+00, 1.81228943e+01,
+       4.43119812e+00, 7.50000000e+00, 1.88671036e+01, 1.01006508e+00,
+       7.50000000e+00, 1.70880890e+01, 5.17359352e+00, 7.50000000e+00,
+       1.76207199e+01, 2.73631096e+00, 7.50000000e+00, 1.78859177e+01,
+       1.52279091e+00, 7.50000000e+00, 1.27452393e+01, 2.10208378e+01,
+       7.50000000e+00, 1.15128021e+01, 2.46395702e+01, 7.50000000e+00,
+       1.59804535e+01, 4.33442497e+00, 7.50000000e+00, 1.21138458e+01,
+       1.99383068e+01, 7.50000000e+00, 1.32104950e+01, 1.49651470e+01,
+       7.50000000e+00, 1.45103149e+01, 9.07077599e+00, 7.50000000e+00,
+       1.36821747e+01, 1.08916073e+01, 7.50000000e+00, 1.43279266e+01,
+       7.96965981e+00, 7.50000763e+00, 1.52885361e+01, 3.62317848e+00,
+       7.50000000e+00, 1.20933914e+01, 1.61490574e+01, 7.50000000e+00,
+       9.93997955e+00, 2.39375134e+01, 7.50000000e+00, 1.04940338e+01,
+       2.14414654e+01, 7.50000000e+00, 1.08249817e+01, 1.99505634e+01,
+       7.49999237e+00, 1.23005066e+01, 1.33031902e+01, 7.50000763e+00,
+       1.48695755e+01, 1.72935486e+00, 7.50000000e+00, 1.03265152e+01,
+       2.02845974e+01, 7.50000000e+00, 1.10945892e+01, 1.68318729e+01,
+       7.50000000e+00, 1.15307922e+01, 1.48709698e+01, 7.50000000e+00,
+       1.23973999e+01, 1.09752522e+01, 7.50000000e+00, 1.32029037e+01,
+       7.35427094e+00, 7.50000000e+00, 1.13608856e+01, 1.37515507e+01,
+       7.50000000e+00, 1.38772583e+01, 2.46380615e+00, 7.50000000e+00,
+       9.50159454e+00, 2.02087917e+01, 7.50000000e+00, 8.07015991e+00,
+       2.47375507e+01, 7.50000763e+00, 1.03217316e+01, 1.46803799e+01,
+       7.50000000e+00, 1.23103180e+01, 5.79790115e+00, 7.50000000e+00,
+       1.01037674e+01, 1.38121281e+01, 7.50000000e+00, 1.11809998e+01,
+       9.01051903e+00, 7.50000763e+00, 1.13950348e+01, 8.05649376e+00,
+       7.50000000e+00, 8.14340973e+00, 2.07075863e+01, 7.50000000e+00,
+       9.12818146e+00, 1.63272152e+01, 7.50000000e+00, 9.99537659e+00,
+       1.24698277e+01, 7.49999237e+00, 1.02109909e+01, 1.15107555e+01,
+       7.50000000e+00, 1.16010513e+01, 5.32763863e+00, 7.49999237e+00,
+       9.13223267e+00, 1.44928761e+01, 7.50000000e+00, 9.94162750e+00,
+       1.09000378e+01, 7.50000000e+00, 7.28559875e+00, 2.08737850e+01,
+       7.50000000e+00, 1.01021881e+01, 8.39678001e+00, 7.50000000e+00,
+       1.16387253e+01, 1.59016228e+00, 7.49999237e+00, 6.75005341e+00,
+       2.14420986e+01, 7.50000000e+00, 8.22353363e+00, 1.49279881e+01,
+       7.50000000e+00, 9.99530029e+00, 7.09537697e+00, 7.50000000e+00,
+       1.04200592e+01, 5.21754456e+00, 7.50000000e+00, 8.17784882e+00,
+       1.33553066e+01, 7.50000000e+00, 6.12471008e+00, 2.06370029e+01,
+       7.50000000e+00, 9.09488678e+00, 7.55912590e+00, 7.50000000e+00,
+       1.02585144e+01, 2.43565941e+00, 7.50000000e+00, 5.26607513e+00,
+       2.26497517e+01, 7.50000000e+00, 7.06588745e+00, 1.47408848e+01,
+       7.50000000e+00, 4.40799713e+00, 2.46612148e+01, 7.50000000e+00,
+       7.07940674e+00, 1.29455090e+01, 7.50000000e+00, 4.43403625e+00,
+       2.28040600e+01, 7.50000000e+00, 6.12425995e+00, 1.54059429e+01,
+       7.50000000e+00, 6.57166290e+00, 1.17387066e+01, 7.50000000e+00,
+       4.43090820e+00, 1.93787632e+01, 7.50000000e+00, 4.75732422e+00,
+       1.79555988e+01, 7.50000000e+00, 5.89152527e+00, 1.30104733e+01,
+       7.50000000e+00, 6.64060211e+00, 9.74442863e+00, 7.50000000e+00,
+       7.22528076e+00, 7.19527245e+00, 7.50000000e+00, 7.75384521e+00,
+       4.89074135e+00, 7.50000000e+00, 3.47557068e+00, 2.18396053e+01,
+       7.50000000e+00, 3.69437408e+00, 2.08874645e+01, 7.50000000e+00,
+       4.72727966e+00, 1.63926296e+01, 7.50000000e+00, 5.15905762e+00,
+       1.45137081e+01, 7.50000000e+00, 8.13061523e+00, 1.58259964e+00,
+       7.50000000e+00, 2.40971375e+00, 2.47798100e+01, 7.50000000e+00,
+       5.87557220e+00, 9.72640038e+00, 7.50000000e+00, 6.56526947e+00,
+       6.73080444e+00, 7.50000000e+00, 5.09619141e+00, 1.14506207e+01,
+       7.50000000e+00, 5.25630188e+00, 1.07565250e+01, 7.50000000e+00,
+       5.73511505e+00, 8.68085289e+00, 7.49999237e+00, 1.87722778e+00,
+       2.37326107e+01, 7.50000000e+00, 2.42462921e+00, 2.13640842e+01,
+       7.50000000e+00, 2.75165558e+00, 1.99490147e+01, 7.50000000e+00,
+       1.25675964e+00, 2.47545490e+01, 7.50000000e+00, 1.18718719e+00,
+       2.34062138e+01, 7.50000763e+00, 1.51530457e+00, 2.19917927e+01,
+       7.50000000e+00, 4.63388824e+00, 8.54804420e+00, 7.50000000e+00,
+       6.05357361e+00, 2.42800903e+00, 7.50000000e+00, 1.66243744e+00,
+       1.97268505e+01, 7.50000000e+00, 4.65785980e+00, 6.83783150e+00,
+       7.49999237e+00, 5.86294556e+00, 1.65244865e+00, 7.50000000e+00,
+       2.13138580e+00, 1.60961475e+01, 7.50000763e+00, 2.48748016e+00,
+       1.29706287e+01, 7.50000000e+00, 4.46820831e+00, 2.91176224e+00,
+       7.50000000e+00, 4.78048706e+00, 1.57538223e+00, 7.50000000e+00,
+       7.62939453e-06, 2.48414211e+01, 6.65560150e+00, 2.27072144e+00,
+       9.18834496e+00, 7.50000000e+00, 3.42597961e+00, 4.26208687e+00,
+       7.50000000e+00, 2.93365479e+00, 4.82257271e+00, 7.50000763e+00,
+       1.84976959e+00, 6.38134193e+00, 7.50000000e+00, 2.14558411e+00,
+       3.62049484e+00, 7.50000000e+00, 0., 2.35792027e+01,
+       5.03440857e+00, 0., 2.19426174e+01, 5.36028290e+00,
+       1.66080475e+00, 4.17622566e+00, 7.50000000e+00, 2.07608795e+00,
+       2.42077065e+00, 7.50000000e+00, 0., 2.04378338e+01,
+       5.03732300e+00, 1.31945801e+00, 2.65728569e+00, 7.50000000e+00,
+       1.62953186e+00, 1.35104370e+00, 7.50000000e+00, 0.,
+       2.15766277e+01, 4.49355316e+00, 0., 1.94743214e+01,
+       4.60674286e+00, 8.67218018e-01, 2.01017380e-01, 7.50000763e+00,
+       7.58438110e-02, 6.58544540e-01, 7.50000000e+00, 0.,
+       1.91531734e+01, 3.41085052e+00, 0., 1.10673466e+01,
+       5.09860229e+00, 0., 2.38755322e+01, 2.10121155e+00, 0.,
+       1.78651524e+01, 3.36309052e+00, 0., 2.37246571e+01,
+       1.48184967e+00, 7.62939453e-06, 9.91206932e+00, 4.41570282e+00,
+       0., 2.15611744e+01, 1.61676788e+00, 0., 1.30110722e+01,
+       3.44339752e+00, 0., 1.14694386e+01, 3.77275848e+00, 0.,
+       1.07056065e+01, 3.93593597e+00, 0., 1.94250431e+01,
+       1.74998474e+00, 0., 1.54050617e+01, 2.61378479e+00, 0.,
+       1.40924511e+01, 2.89584351e+00, 7.62939453e-06, 7.47755814e+00,
+       4.31722260e+00, 0., 2.37962532e+00, 5.41265106e+00, 0.,
+       2.56230259e+01, 8.61511230e-02, 0., 1.86642323e+01,
+       1.59008789e+00, 0., 1.70477352e+01, 1.93944550e+00, 0.,
+       1.44418240e+01, 2.18334961e+00, 0., 1.28744030e+01,
+       2.52405548e+00, 7.62939453e-06, 1.10698338e+01, 2.91630554e+00,
+       0., 9.79645348e+00, 3.19309998e+00, -7.62939453e-06,
+       4.58558464e+00, 4.32578278e+00, 0., 9.32394600e+00,
+       2.98176575e+00, 0., 1.01039124e+00, 4.79927826e+00, 0.,
+       1.27363758e+01, 1.59561920e+00, 0., 5.91145897e+00,
+       2.79168701e+00, 0., 4.06109810e+00, 1.63174438e+00, 0.,
+       2.37063980e+00, 1.70292664e+00, 0., 2.20441818e+00,
+       4.67857361e-01, 0., 5.20465851e-01, 5.45036316e-01,
+       1.79857864e+01, 2.49795895e+01, 7.50000000e+00, 1.58985672e+01,
+       2.17152386e+01, 7.50000000e+00, 1.60318909e+01, 2.10974216e+01,
+       7.50000000e+00, 1.50641327e+01, 2.30515270e+01, 7.50000000e+00,
+       1.37397690e+01, 2.41681652e+01, 7.50000000e+00, 1.75481339e+01,
+       6.66924858e+00, 7.50000000e+00, 1.87632675e+01, 1.08589172e+00,
+       7.49999237e+00, 1.75881271e+01, 1.69984627e+00, 7.50000000e+00,
+       1.28143845e+01, 2.11046619e+01, 7.50000763e+00, 1.66553574e+01,
+       3.60064697e+00, 7.50000000e+00, 1.14681778e+01, 2.48423443e+01,
+       7.50000000e+00, 1.59804535e+01, 4.33442497e+00, 7.50000000e+00,
+       1.20566635e+01, 1.98058491e+01, 7.50000763e+00, 1.30438385e+01,
+       1.53312283e+01, 7.50000000e+00, 1.43446045e+01, 9.43511772e+00,
+       7.50000000e+00, 1.46026611e+01, 8.26537514e+00, 7.50000000e+00,
+       1.48600388e+01, 7.09876251e+00, 7.50000000e+00, 1.01178589e+01,
+       2.39067554e+01, 7.50000000e+00, 1.09809418e+01, 2.00151653e+01,
+       7.50000000e+00, 1.19019775e+01, 1.58622036e+01, 7.50000000e+00,
+       1.24244156e+01, 1.35065670e+01, 7.50000000e+00, 1.50585556e+01,
+       1.62929916e+00, 7.49999237e+00, 1.03819656e+01, 2.04161129e+01,
+       7.50000000e+00, 1.11721878e+01, 1.68621845e+01, 7.50000000e+00,
+       1.17607193e+01, 1.42154408e+01, 7.50000000e+00, 1.24752350e+01,
+       1.10020542e+01, 7.50000000e+00, 1.33129349e+01, 7.23461914e+00,
+       7.50000763e+00, 1.27181854e+01, 7.66306305e+00, 7.50000000e+00,
+       1.38666840e+01, 2.51122475e+00, 7.49999237e+00, 1.05733795e+01,
+       1.50388851e+01, 7.50000000e+00, 1.03102646e+01, 1.39935551e+01,
+       7.50000000e+00, 1.06997147e+01, 1.22554302e+01, 7.50000000e+00,
+       1.14097214e+01, 9.08669853e+00, 7.50000000e+00, 8.28301239e+00,
+       2.08210468e+01, 7.50000000e+00, 9.33358765e+00, 1.61441021e+01,
+       7.50000000e+00, 1.01142502e+01, 1.26687260e+01, 7.50000000e+00,
+       1.11455917e+01, 8.07738304e+00, 7.50000000e+00, 1.17847214e+01,
+       5.23214722e+00, 7.49999237e+00, 9.20731354e+00, 1.45213184e+01,
+       7.50000000e+00, 9.40221405e+00, 1.36558399e+01, 7.50000000e+00,
+       7.12064362e+00, 2.16045132e+01, 7.50000000e+00, 7.31855011e+00,
+       2.07277775e+01, 7.50000763e+00, 8.49786377e+00, 1.55036488e+01,
+       7.50000000e+00, 1.00487823e+01, 8.63340569e+00, 7.49999237e+00,
+       1.07515259e+01, 5.52029419e+00, 7.50000000e+00, 1.16387253e+01,
+       1.59016228e+00, 7.49999237e+00, 5.57362366e+00, 2.41303043e+01,
+       7.50000000e+00, 6.36634827e+00, 2.06357059e+01, 7.50000000e+00,
+       7.16869354e+00, 1.49876461e+01, 7.50000000e+00, 1.00477982e+01,
+       2.32597160e+00, 7.50000000e+00, 4.50225830e+00, 2.45982304e+01,
+       7.50000000e+00, 6.53675842e+00, 1.56722126e+01, 7.50000000e+00,
+       7.24888611e+00, 1.25478840e+01, 7.50000000e+00, 9.03894806e+00,
+       4.69434929e+00, 7.50000000e+00, 3.70771790e+00, 2.39049091e+01,
+       7.50000000e+00, 6.76734161e+00, 1.05442791e+01, 7.50000000e+00,
+       6.89550018e+00, 9.98465919e+00, 7.50000000e+00, 8.04154205e+00,
+       4.98013306e+00, 7.50000000e+00, 3.67687988e+00, 2.19833889e+01,
+       7.50000000e+00, 4.72357941e+00, 1.74232845e+01, 7.50000000e+00,
+       4.85366821e+00, 1.68565769e+01, 7.50000000e+00, 5.37231445e+00,
+       1.45969944e+01, 7.50000000e+00, 5.75956726e+00, 1.29099064e+01,
+       7.50000000e+00, 8.36642456e+00, 1.55271149e+00, 7.50000000e+00,
+       2.52803040e+00, 2.49429073e+01, 7.50000000e+00, 6.73898315e+00,
+       6.63937378e+00, 7.50000000e+00, 6.92915344e+00, 5.81278419e+00,
+       7.50000763e+00, 2.89759064e+00, 2.13163738e+01, 7.50000000e+00,
+       5.23063660e+00, 1.11985340e+01, 7.50000000e+00, 5.80559540e+00,
+       8.70512199e+00, 7.50000000e+00, 1.62444305e+00, 2.48264065e+01,
+       7.50000000e+00, 2.74076843e+00, 1.99961071e+01, 7.50000763e+00,
+       4.61734009e+00, 1.18762989e+01, 7.50000000e+00, 1.34163666e+00,
+       2.40573101e+01, 7.50000000e+00, 1.80161285e+00, 2.20714703e+01,
+       7.50000000e+00, 4.86523438e+00, 6.90690231e+00, 7.50000000e+00,
+       5.93543243e+00, 2.29693604e+00, 7.50000000e+00, 0.,
+       2.56847935e+01, 7.17250824e+00, 4.79453278e+00, 3.39433289e+00,
+       7.50000000e+00, 4.75970459e+00, 1.66434479e+00, 7.50000000e+00,
+       2.52908325e+00, 9.32967949e+00, 7.50000000e+00, 3.13478088e+00,
+       4.88730431e+00, 7.50000000e+00, 3.26016235e+00, 4.35301971e+00,
+       7.50000000e+00, 1.20128632e+00, 9.43620491e+00, 7.50000000e+00,
+       1.89502716e+00, 6.49253273e+00, 7.49999237e+00, 1.54324341e+00,
+       4.37506676e+00, 7.50000000e+00, 1.52500153e+00, 2.67389679e+00,
+       7.50000000e+00, 1.83521271e+00, 1.36568260e+00, 7.50000000e+00,
+       0., 2.14445972e+01, 4.64611053e+00, 7.62939453e-06,
+       1.95706615e+01, 4.64979553e+00, 3.50509644e-01, 6.47829056e-01,
+       7.50000000e+00, 7.62939453e-06, 1.91209202e+01, 3.60791779e+00,
+       0., 2.37938824e+01, 2.24803925e+00, 0., 1.76388874e+01,
+       3.15670013e+00, 0., 1.08217945e+01, 4.22247314e+00,
+       7.62939453e-06, 9.91206551e+00, 4.41570282e+00, 7.62939453e-06,
+       7.81466484e+00, 4.86119843e+00, 7.62939453e-06, 2.16836681e+01,
+       1.52550507e+00, 7.62939453e-06, 1.58432865e+01, 2.77467346e+00,
+       0., 1.39536800e+01, 3.17883301e+00, 0., 1.17839146e+01,
+       3.64292145e+00, 7.62939453e-06, 2.33968353e+00, 5.30012512e+00,
+       0., 1.09528103e+01, 3.06786346e+00, 0., 4.67332840e+00,
+       4.42967987e+00, 0., 1.44245472e+01, 1.93085480e+00, 0.,
+       9.46905708e+00, 3.01297760e+00, 7.62939453e-06, 1.32172756e+01,
+       1.81051636e+00, 7.62939453e-06, 8.29743004e+00, 2.89228058e+00,
+       7.62939453e-06, 1.26402073e+01, 1.55262756e+00, 0.,
+       3.98917961e+00, 1.96472168e+00 ]
+points_2d: !!opencv-matrix
+   rows: 5914
+   cols: 1
+   dt: "2f"
+   data: [ 366., 251., 430., 385., 421., 381., 417., 380., 213., 137.,
+       412., 380., 421., 378., 219., 139., 417., 378., 396., 378., 392.,
+       377., 216., 140., 387., 377., 394., 376., 392., 375., 417., 374.,
+       224., 141., 388., 374., 371., 374., 216., 142., 219., 142., 367.,
+       374., 362., 373., 371., 372., 221., 143., 367., 371., 362., 371.,
+       227., 144., 401., 367., 382., 367., 224., 145., 342., 367., 338.,
+       367., 378., 366., 222., 146., 378., 364., 322., 364., 317., 363.,
+       314., 363., 239., 148., 420., 362., 416., 362., 401., 362., 380.,
+       361., 383., 360., 294., 360., 416., 359., 291., 359., 403., 358.,
+       380., 358., 276., 357., 382., 356., 272., 356., 419., 355., 416.,
+       355., 268., 355., 380., 354., 306., 353., 202., 153., 251., 353.,
+       402., 352., 382., 352., 247., 352., 341., 351., 243., 351., 382.,
+       350., 381., 348., 340., 348., 316., 348., 314., 348., 200., 156.,
+       203., 156., 227., 348., 223., 348., 223., 156., 331., 347., 263.,
+       347., 225., 157., 382., 346., 314., 346., 281., 346., 336., 345.,
+       332., 345., 279., 345., 208., 345., 381., 344., 328., 344., 284.,
+       344., 204., 344., 200., 344., 323., 343., 314., 343., 281., 343.,
+       419., 342., 416., 342., 320., 342., 265., 341., 186., 341., 199.,
+       161., 184., 341., 262., 340., 182., 340., 415., 339., 381., 339.,
+       300., 339., 290., 339., 272., 339., 270., 339., 265., 338., 299.,
+       337., 203., 163., 288., 337., 269., 337., 419., 336., 381., 336.,
+       415., 335., 399., 335., 301., 335., 265., 335., 259., 335., 219.,
+       335., 200., 164., 379., 334., 226., 334., 416., 333., 263., 333.,
+       245., 333., 230., 333., 218., 333., 399., 332., 380., 332., 301.,
+       332., 261., 332., 258., 332., 255., 332., 243., 332., 203., 332.,
+       401., 331., 292., 331., 251., 331., 232., 331., 223., 331., 200.,
+       331., 289., 330., 256., 330., 411., 166., 227., 330., 213., 330.,
+       203., 330., 173., 330., 293., 329., 287., 329., 281., 329., 279.,
+       329., 253., 329., 250., 329., 222., 329., 170., 329., 168., 329.,
+       378., 328., 209., 328., 205., 328., 400., 327., 278., 327., 413.,
+       168., 272., 327., 231., 327., 211., 327., 167., 327., 281., 326.,
+       203., 326., 172., 326., 473., 169., 380., 325., 303., 325., 275.,
+       325., 271., 325., 233., 325., 211., 325., 458., 170., 195., 325.,
+       378., 324., 307., 324., 215., 324., 304., 323., 453., 171., 469.,
+       171., 418., 322., 415., 322., 374., 322., 436., 172., 456., 172.,
+       462., 172., 236., 322., 232., 322., 292., 321., 289., 321., 225.,
+       321., 379., 320., 376., 320., 454., 173., 294., 320., 215., 320.,
+       228., 319., 418., 318., 414., 318., 294., 318., 225., 318., 148.,
+       318., 409., 317., 221., 317., 209., 317., 411., 316., 207., 316.,
+       166., 316., 418., 315., 414., 315., 146., 315., 409., 314., 392.,
+       314., 389., 314., 296., 314., 237., 177., 189., 314., 383., 313.,
+       146., 313., 192., 312., 190., 312., 469., 177., 392., 311., 234.,
+       178., 146., 311., 388., 310., 384., 310., 366., 310., 299., 310.,
+       297., 310., 466., 178., 189., 310., 185., 179., 368., 309., 362.,
+       309., 359., 308., 186., 308., 171., 308., 366., 307., 362., 306.,
+       384., 180., 386., 180., 358., 306., 341., 306., 145., 306., 184.,
+       305., 432., 180., 180., 304., 466., 180., 170., 304., 146., 304.,
+       341., 303., 233., 181., 337., 303., 320., 303., 417., 302., 375.,
+       181., 437., 181., 333., 302., 316., 302., 312., 302., 170., 302.,
+       235., 182., 179., 301., 421., 300., 415., 300., 320., 300., 181.,
+       300., 380., 182., 384., 182., 387., 182., 177., 300., 396., 299.,
+       316., 299., 312., 299., 295., 299., 175., 299., 468., 182., 172.,
+       299., 162., 299., 417., 298., 392., 298., 291., 298., 423., 297.,
+       420., 297., 399., 297., 286., 297., 171., 297., 411., 296., 379.,
+       184., 390., 296., 295., 296., 394., 295., 291., 295., 287., 295.,
+       269., 295., 233., 185., 173., 295., 171., 295., 169., 295., 144.,
+       295., 398., 294., 376., 185., 369., 294., 442., 185., 445., 185.,
+       365., 294., 265., 294., 261., 294., 421., 293., 372., 293., 167.,
+       293., 416., 292., 410., 292., 407., 292., 404., 292., 377., 292.,
+       363., 292., 448., 186., 269., 292., 165., 292., 235., 187., 161.,
+       292., 280., 187., 370., 291., 366., 291., 374., 187., 378., 187.,
+       265., 291., 261., 291., 246., 291., 418., 290., 411., 290., 144.,
+       290., 423., 289., 401., 289., 342., 289., 276., 188., 240., 289.,
+       141., 289., 330., 188., 369., 188., 420., 288., 417., 288., 412.,
+       288., 404., 288., 345., 288., 246., 288., 223., 288., 144., 288.,
+       422., 287., 232., 189., 369., 287., 238., 287., 314., 189., 374.,
+       189., 219., 287., 420., 286., 403., 286., 385., 286., 366., 286.,
+       277., 190., 361., 286., 215., 286., 383., 285., 380., 285., 331.,
+       190., 370., 190., 318., 285., 314., 285., 186., 191., 223., 285.,
+       405., 284., 386., 284., 312., 191., 364., 284., 356., 284., 352.,
+       284., 373., 191., 219., 284., 199., 284., 424., 283., 188., 192.,
+       384., 283., 215., 283., 233., 192., 201., 283., 278., 192., 296.,
+       192., 195., 283., 191., 283., 382., 282., 390., 192., 380., 282.,
+       366., 282., 199., 281., 426., 280., 283., 193., 337., 193., 341.,
+       193., 382., 193., 399., 280., 195., 280., 191., 280., 176., 280.,
+       186., 194., 172., 280., 234., 194., 238., 194., 167., 279., 286.,
+       194., 298., 194., 391., 278., 329., 194., 387., 277., 384., 277.,
+       387., 194., 176., 277., 172., 277., 420., 276., 459., 194., 404.,
+       276., 396., 276., 391., 276., 375., 276., 232., 195., 247., 195.,
+       168., 276., 276., 195., 284., 195., 152., 276., 148., 276., 338.,
+       195., 126., 276., 123., 276., 379., 195., 391., 195., 400., 275.,
+       371., 275., 144., 275., 238., 196., 244., 196., 288., 196., 152.,
+       274., 430., 273., 328., 196., 341., 196., 428., 273., 382., 196.,
+       406., 273., 395., 273., 309., 273., 148., 273., 129., 273., 410.,
+       272., 402., 272., 371., 272., 313., 272., 233., 197., 265., 197.,
+       144., 272., 290., 197., 316., 197., 320., 197., 125., 272., 123.,
+       272., 429., 270., 367., 197., 378., 197., 399., 270., 219., 270.,
+       129., 270., 432., 269., 406., 269., 396., 269., 230., 198., 246.,
+       198., 250., 198., 257., 198., 259., 198., 269., 198., 392., 269.,
+       369., 269., 286., 269., 410., 198., 125., 269., 412., 268., 459.,
+       198., 267., 267., 200., 267., 223., 199., 226., 199., 228., 199.,
+       240., 199., 252., 199., 254., 199., 273., 199., 428., 266., 310.,
+       199., 319., 199., 432., 265., 178., 265., 428., 263., 369., 199.,
+       388., 199., 424., 263., 173., 263., 187., 262., 178., 262., 173.,
+       261., 149., 261., 185., 260., 263., 200., 265., 200., 178., 260.,
+       328., 200., 392., 200., 145., 260., 171., 259., 149., 259., 191.,
+       258., 180., 258., 185., 257., 150., 257., 222., 201., 253., 201.,
+       134., 257., 327., 256., 318., 201., 197., 256., 194., 256., 320.,
+       255., 368., 201., 371., 201., 376., 201., 387., 201., 401., 201.,
+       151., 255., 130., 255., 336., 254., 245., 202., 273., 202., 153.,
+       254., 146., 254., 322., 202., 403., 253., 382., 202., 393., 202.,
+       410., 202., 359., 253., 357., 253., 328., 253., 322., 253., 318.,
+       253., 267., 203., 151., 253., 136., 253., 388., 203., 343., 252.,
+       340., 252., 324., 252., 128., 252., 378., 251., 221., 204., 348.,
+       251., 335., 251., 291., 251., 167., 251., 265., 204., 139., 251.,
+       382., 250., 370., 250., 376., 204., 362., 250., 356., 250., 207.,
+       205., 218., 205., 346., 250., 318., 250., 305., 250., 269., 205.,
+       173., 250., 150., 250., 137., 250., 393., 205., 397., 205., 399.,
+       205., 404., 205., 384., 249., 373., 249., 348., 249., 300., 249.,
+       175., 249., 152., 249., 355., 206., 363., 206., 366., 206., 369.,
+       206., 372., 206., 374., 206., 385., 206., 381., 248., 364., 248.,
+       357., 248., 216., 207., 350., 248., 264., 207., 267., 207., 338.,
+       248., 335., 248., 323., 207., 303., 248., 391., 207., 397., 207.,
+       143., 248., 138., 248., 395., 247., 384., 247., 378., 247., 361.,
+       247., 359., 247., 353., 247., 321., 208., 362., 208., 386., 208.,
+       310., 247., 296., 247., 166., 247., 209., 209., 391., 246., 371.,
+       246., 367., 246., 357., 246., 311., 209., 325., 209., 333., 209.,
+       176., 246., 369., 209., 380., 209., 396., 209., 399., 209., 168.,
+       246., 134., 246., 365., 245., 354., 245., 179., 245., 172., 245.,
+       320., 210., 166., 245., 140., 245., 137., 245., 371., 210., 374.,
+       210., 403., 210., 439., 244., 391., 244., 373., 244., 370., 244.,
+       302., 244., 398., 243., 362., 243., 195., 243., 311., 211., 328.,
+       211., 333., 211., 378., 211., 146., 243., 406., 211., 134., 243.,
+       394., 242., 212., 212., 369., 242., 169., 242., 141., 242., 316.,
+       212., 137., 242., 207., 241., 135., 241., 400., 240., 402., 212.,
+       363., 240., 335., 240., 177., 240., 172., 240., 169., 240., 137.,
+       240., 365., 239., 209., 239., 206., 239., 146., 239., 141., 239.,
+       401., 238., 411., 213., 177., 238., 166., 238., 334., 237., 204.,
+       237., 163., 237., 140., 237., 175., 236., 326., 214., 374., 214.,
+       170., 236., 165., 236., 160., 236., 307., 235., 167., 235., 207.,
+       215., 211., 215., 403., 234., 161., 234., 398., 233., 404., 232.,
+       402., 232., 272., 232., 163., 232., 451., 215., 161., 232., 159.,
+       232., 144., 232., 264., 216., 148., 229., 436., 228., 371., 216.,
+       373., 216., 275., 228., 406., 216., 411., 216., 272., 227., 157.,
+       227., 278., 226., 153., 226., 397., 225., 204., 217., 208., 217.,
+       151., 225., 408., 224., 394., 224., 392., 224., 156., 224., 169.,
+       218., 195., 218., 201., 218., 406., 223., 397., 223., 286., 218.,
+       404., 222., 395., 222., 389., 222., 369., 218., 203., 222., 201.,
+       222., 185., 222., 153., 222., 407., 221., 381., 221., 206., 221.,
+       410., 220., 184., 220., 169., 220., 397., 219., 408., 219., 166.,
+       220., 454., 219., 451., 219., 427., 384., 215., 135., 412., 377.,
+       229., 140., 189., 220., 397., 375., 229., 142., 253., 142., 359.,
+       371., 400., 220., 216., 144., 241., 144., 195., 221., 254., 144.,
+       282., 221., 286., 221., 289., 221., 347., 368., 403., 367., 213.,
+       145., 374., 367., 192., 219., 451., 221., 151., 222., 187., 219.,
+       163., 222., 335., 367., 384., 366., 378., 218., 277., 222., 210.,
+       146., 238., 146., 418., 365., 375., 365., 372., 365., 368., 365.,
+       363., 364., 373., 363., 357., 363., 267., 147., 242., 148., 363.,
+       362., 354., 362., 182., 223., 187., 223., 365., 361., 360., 361.,
+       348., 361., 343., 361., 378., 360., 352., 360., 338., 360., 207.,
+       150., 246., 150., 435., 223., 437., 223., 376., 359., 349., 359.,
+       266., 150., 343., 358., 341., 358., 325., 358., 203., 151., 400.,
+       357., 320., 357., 205., 151., 382., 224., 383., 217., 356., 356.,
+       350., 356., 331., 356., 318., 356., 315., 356., 159., 225., 311.,
+       356., 199., 225., 237., 151., 199., 217., 432., 225., 451., 225.,
+       167., 217., 322., 355., 196., 226., 205., 226., 320., 355., 309.,
+       355., 307., 355., 239., 152., 352., 354., 346., 354., 145., 227.,
+       315., 354., 159., 227., 304., 354., 194., 227., 301., 354., 350.,
+       353., 455., 216., 313., 353., 199., 153., 448., 227., 299., 353.,
+       296., 353., 199., 228., 205., 228., 293., 353., 210., 153., 280.,
+       228., 286., 228., 417., 352., 392., 228., 395., 228., 230., 153.,
+       248., 153., 379., 352., 288., 352., 144., 229., 333., 351., 290.,
+       351., 284., 351., 202., 229., 206., 154., 399., 350., 330., 350.,
+       294., 229., 294., 350., 279., 350., 275., 350., 342., 349., 285.,
+       349., 270., 349., 449., 229., 217., 155., 234., 155., 272., 348.,
+       265., 348., 205., 231., 209., 156., 219., 156., 343., 347., 215.,
+       157., 444., 231., 446., 231., 325., 347., 312., 347., 194., 216.,
+       221., 157., 383., 215., 261., 347., 208., 232., 257., 347., 220.,
+       347., 368., 215., 283., 232., 306., 215., 231., 157., 433., 232.,
+       448., 232., 148., 233., 399., 346., 285., 233., 318., 346., 322.,
+       157., 275., 346., 252., 346., 174., 234., 417., 345., 209., 234.,
+       402., 345., 338., 345., 196., 158., 283., 234., 254., 345., 227.,
+       158., 335., 158., 271., 344., 379., 343., 332., 343., 265., 343.,
+       238., 343., 251., 342., 242., 342., 236., 342., 402., 341., 445.,
+       235., 382., 341., 278., 341., 448., 214., 256., 341., 266., 214.,
+       181., 236., 246., 341., 215., 236., 399., 340., 265., 236., 329.,
+       340., 297., 340., 258., 340., 249., 340., 239., 340., 176., 340.,
+       203., 214., 221., 237., 379., 339., 326., 339., 432., 161., 281.,
+       339., 256., 339., 253., 339., 137., 238., 244., 339., 241., 339.,
+       233., 339., 217., 339., 179., 339., 231., 238., 296., 338., 268.,
+       238., 274., 338., 238., 338., 230., 337., 380., 213., 149., 239.,
+       201., 239., 340., 213., 375., 336., 244., 336., 200., 336., 303.,
+       239., 163., 336., 415., 163., 431., 163., 239., 335., 194., 164.,
+       202., 335., 159., 335., 267., 240., 381., 334., 452., 212., 289.,
+       334., 368., 212., 156., 334., 442., 240., 363., 212., 183., 241.,
+       142., 334., 274., 333., 240., 333., 419., 164., 207., 333., 253.,
+       212., 198., 242., 203., 242., 207., 165., 283., 332., 427., 165.,
+       135., 332., 297., 331., 269., 331., 170., 331., 167., 331., 142.,
+       331., 336., 243., 280., 211., 375., 243., 277., 330., 403., 243.,
+       436., 243., 235., 330., 416., 166., 452., 166., 175., 330., 137.,
+       330., 203., 211., 201., 211., 135., 330., 302., 329., 220., 329.,
+       366., 210., 178., 329., 472., 167., 166., 329., 206., 168., 314.,
+       210., 381., 327., 190., 245., 421., 168., 268., 327., 199., 327.,
+       193., 327., 186., 327., 165., 327., 137., 327., 306., 326., 201.,
+       326., 150., 326., 144., 246., 416., 325., 439., 170., 217., 325.,
+       185., 325., 148., 325., 268., 246., 311., 324., 293., 246., 309.,
+       209., 301., 324., 165., 324., 313., 323., 212., 323., 208., 323.,
+       191., 323., 184., 247., 191., 247., 237., 247., 164., 209., 150.,
+       323., 188., 172., 347., 247., 262., 208., 249., 208., 381., 322.,
+       433., 172., 309., 322., 464., 172., 221., 322., 442., 247., 161.,
+       208., 408., 207., 154., 248., 182., 248., 174., 322., 370., 321.,
+       368., 321., 321., 321., 290., 248., 334., 207., 316., 248., 313.,
+       321., 302., 321., 251., 207., 203., 207., 163., 207., 241., 173.,
+       387., 248., 389., 248., 401., 248., 207., 321., 373., 320., 178.,
+       249., 365., 320., 357., 320., 306., 320., 204., 320., 370., 319.,
+       353., 319., 190., 319., 365., 318., 316., 318., 131., 250., 232.,
+       175., 192., 318., 310., 205., 164., 318., 360., 317., 357., 317.,
+       441., 175., 190., 317., 254., 205., 176., 317., 342., 250., 246.,
+       205., 415., 204., 413., 204., 327., 204., 319., 204., 401., 250.,
+       403., 250., 438., 250., 146., 317., 354., 316., 339., 316., 298.,
+       316., 462., 175., 289., 251., 242., 204., 236., 204., 234., 204.,
+       352., 251., 179., 316., 406., 315., 440., 251., 342., 315., 198.,
+       315., 198., 252., 176., 315., 431., 176., 435., 176., 340., 314.,
+       134., 314., 131., 314., 385., 252., 304., 203., 294., 203., 426.,
+       313., 321., 313., 316., 313., 209., 313., 207., 313., 197., 313.,
+       187., 313., 184., 313., 291., 202., 172., 313., 163., 313., 417.,
+       177., 289., 254., 310., 312., 210., 202., 342., 254., 202., 312.,
+       371., 254., 382., 254., 391., 254., 169., 312., 380., 311., 308.,
+       311., 461., 201., 195., 311., 184., 255., 295., 255., 163., 311.,
+       385., 178., 419., 255., 316., 310., 312., 310., 413., 178., 357.,
+       309., 308., 309., 331., 201., 305., 309., 299., 256., 291., 309.,
+       306., 201., 360., 256., 375., 256., 303., 201., 427., 308., 303.,
+       308., 300., 308., 288., 308., 471., 179., 187., 180., 145., 308.,
+       309., 257., 333., 257., 132., 308., 356., 257., 130., 308., 418.,
+       257., 354., 307., 127., 258., 131., 258., 143., 258., 169., 201.,
+       297., 307., 229., 258., 293., 307., 283., 307., 279., 307., 188.,
+       307., 183., 307., 289., 306., 286., 306., 426., 200., 408., 200.,
+       162., 306., 332., 305., 283., 305., 336., 259., 277., 305., 263.,
+       305., 275., 304., 443., 180., 173., 304., 398., 200., 420., 303.,
+       167., 260., 239., 181., 249., 200., 222., 260., 237., 260., 329.,
+       303., 328., 260., 267., 303., 254., 303., 167., 303., 153., 261.,
+       161., 303., 191., 261., 227., 261., 245., 261., 447., 181., 323.,
+       302., 362., 261., 365., 261., 470., 181., 433., 261., 167., 262.,
+       185., 182., 265., 302., 261., 302., 232., 262., 240., 262., 252.,
+       262., 254., 262., 245., 302., 173., 302., 412., 301., 448., 199.,
+       197., 263., 224., 263., 260., 263., 256., 301., 254., 301., 309.,
+       300., 444., 199., 353., 199., 251., 300., 170., 264., 181., 264.,
+       235., 300., 409., 299., 265., 264., 271., 264., 399., 182., 362.,
+       264., 401., 182., 403., 182., 241., 265., 278., 265., 432., 182.,
+       246., 299., 240., 299., 465., 182., 297., 298., 341., 199., 196.,
+       266., 202., 266., 251., 266., 275., 266., 237., 298., 160., 298.,
+       288., 199., 449., 183., 193., 267., 213., 199., 257., 267., 210.,
+       199., 281., 267., 285., 267., 197., 268., 463., 183., 275., 268.,
+       289., 268., 295., 268., 367., 268., 470., 183., 387., 297., 233.,
+       297., 435., 268., 122., 269., 429., 198., 201., 269., 145., 297.,
+       217., 269., 222., 269., 268., 269., 375., 198., 292., 269., 365.,
+       198., 143., 297., 221., 198., 282., 184., 416., 269., 403., 184.,
+       463., 197., 457., 197., 435., 184., 276., 270., 278., 270., 283.,
+       270., 301., 270., 283., 296., 431., 197., 207., 296., 216., 271.,
+       439., 184., 388., 295., 287., 271., 385., 295., 434., 271., 467.,
+       184., 326., 197., 132., 272., 280., 197., 220., 272., 224., 272.,
+       240., 272., 219., 295., 318., 272., 323., 272., 130., 295., 387.,
+       272., 127., 295., 408., 272., 376., 294., 418., 272., 401., 185.,
+       272., 294., 248., 273., 293., 273., 300., 273., 216., 186., 209.,
+       294., 368., 273., 382., 273., 196., 294., 397., 196., 354., 196.,
+       314., 196., 141., 274., 360., 293., 333., 186., 302., 274., 305.,
+       274., 380., 274., 419., 274., 454., 195., 242., 275., 436., 186.,
+       311., 275., 258., 292., 194., 292., 372., 195., 314., 187., 308.,
+       195., 301., 195., 257., 195., 246., 276., 358., 291., 263., 276.,
+       269., 276., 315., 276., 319., 276., 357., 276., 360., 276., 208.,
+       195., 381., 276., 188., 195., 344., 291., 399., 187., 416., 276.,
+       196., 291., 164., 277., 180., 291., 141., 291., 272., 277., 322.,
+       277., 380., 290., 340., 290., 347., 194., 422., 277., 125., 278.,
+       237., 290., 262., 278., 177., 290., 170., 290., 254., 194., 266.,
+       279., 271., 279., 347., 289., 421., 279., 335., 289., 183., 289.,
+       180., 289., 175., 289., 289., 280., 294., 280., 353., 280., 356.,
+       280., 404., 193., 212., 193., 168., 289., 188., 281., 159., 289.,
+       291., 281., 297., 281., 317., 188., 128., 289., 396., 281., 429.,
+       281., 126., 289., 395., 188., 288., 282., 299., 282., 447., 188.,
+       450., 188., 398., 288., 375., 288., 462., 188., 338., 288., 188.,
+       189., 406., 282., 177., 288., 334., 192., 427., 287., 341., 287.,
+       292., 283., 296., 283., 313., 283., 190., 192., 389., 283., 465.,
+       191., 336., 287., 320., 287., 303., 189., 347., 191., 166., 287.,
+       392., 189., 239., 191., 222., 191., 464., 189., 311., 286., 160.,
+       285., 163., 286., 212., 285., 143., 286., 402., 190., 388., 190.,
+       321., 285., 317., 190., 164., 230., 371., 285., 395., 231., 247.,
+       345., 320., 158., 242., 344., 286., 235., 233., 342., 323., 286.,
+       267., 236., 269., 236., 161., 229., 152., 238., 215., 339., 233.,
+       238., 384., 213., 201., 213., 226., 287., 321., 335., 201., 227.,
+       212., 334., 321., 333., 335., 354., 298., 241., 373., 287., 282.,
+       212., 225., 189., 214., 242., 395., 165., 433., 165., 305., 211.,
+       209., 243., 385., 166., 378., 282., 443., 243., 165., 217., 343.,
+       355., 391., 167., 157., 245., 234., 245., 266., 245., 336., 245.,
+       134., 326., 163., 246., 343., 209., 218., 171., 409., 171., 476.,
+       172., 430., 173., 215., 194., 374., 373., 359., 205., 330., 359.,
+       333., 359., 214., 188., 269., 250., 305., 194., 274., 278., 451.,
+       175., 257., 204., 428., 176., 211., 204., 328., 315., 147., 224.,
+       273., 252., 291., 223., 335., 313., 281., 253., 164., 203., 326.,
+       312., 367., 254., 321., 311., 419., 201., 302., 362., 437., 255.,
+       440., 255., 226., 257., 369., 258., 402., 180., 201., 292., 359.,
+       259., 310., 363., 410., 260., 166., 200., 464., 199., 357., 264.,
+       367., 265., 305., 183., 436., 266., 252., 146., 190., 293., 413.,
+       196., 261., 145., 325., 155., 267., 186., 306., 196., 407., 196.,
+       325., 273., 214., 294., 220., 186., 246., 145., 389., 230., 203.,
+       231., 466., 196., 166., 197., 238., 156., 390., 218., 182., 197.,
+       127., 286., 288., 347., 321., 185., 303., 349., 210., 232., 198.,
+       295., 216., 295., 216., 347., 291., 215., 386., 229., 345., 197.,
+       281., 215., 236., 271., 228., 271., 357., 197., 228., 296., 309.,
+       221., 384., 270., 324., 157., 359., 222., 206., 198., 335., 198.,
+       214., 269., 349., 349., 216., 297., 420., 268., 366., 222., 331.,
+       157., 180., 234., 385., 268., 205., 268., 268., 234., 280., 234.,
+       210., 158., 322., 183., 411., 265., 316., 183., 297., 274., 293.,
+       234., 472., 182., 408., 265., 417., 219., 296., 234., 344., 265.,
+       343., 199., 305., 154., 233., 264., 391., 182., 370., 222., 310.,
+       344., 245., 147., 210., 136., 410., 263., 339., 182., 337., 182.,
+       279., 182., 339., 263., 331., 263., 326., 159., 435., 262., 350.,
+       159., 214., 160., 324., 262., 199., 262., 310., 218., 431., 186.,
+       229., 160., 351., 261., 343., 261., 356., 160., 250., 275., 307.,
+       190., 288., 235., 295., 221., 270., 303., 157., 215., 140., 285.,
+       284., 200., 229., 342., 205., 148., 301., 218., 359., 160., 449.,
+       235., 413., 259., 272., 304., 168., 229., 131., 305., 314., 341.,
+       249., 292., 346., 259., 154., 215., 305., 259., 411., 180., 224.,
+       341., 272., 306., 437., 258., 424., 160., 406., 180., 411., 195.,
+       336., 161., 175., 307., 422., 258., 379., 258., 371., 258., 312.,
+       219., 339., 258., 163., 201., 344., 307., 428., 257., 255., 148.,
+       408., 257., 263., 236., 301., 257., 292., 257., 160., 221., 292.,
+       190., 171., 201., 174., 257., 440., 179., 218., 190., 411., 284.,
+       316., 256., 284., 256., 269., 216., 371., 362., 255., 214., 455.,
+       222., 181., 179., 351., 362., 350., 195., 222., 340., 219., 340.,
+       388., 178., 404., 255., 259., 276., 230., 149., 362., 161., 170.,
+       195., 302., 216., 298., 153., 370., 311., 421., 254., 472., 177.,
+       429., 228., 452., 177., 348., 352., 467., 194., 304., 254., 404.,
+       187., 320., 339., 158., 254., 356., 352., 338., 202., 297., 237.,
+       207., 162., 195., 214., 171., 203., 191., 223., 205., 203., 419.,
+       194., 402., 194., 406., 237., 458., 213., 193., 223., 319., 191.,
+       224., 238., 220., 177., 304., 314., 413., 228., 281., 218., 326.,
+       191., 283., 252., 468., 187., 270., 252., 386., 290., 213., 315.,
+       348., 162., 207., 338., 352., 162., 345., 315., 348., 315., 396.,
+       315., 353., 194., 247., 143., 406., 228., 223., 176., 367., 359.,
+       400., 228., 177., 251., 191., 290., 328., 337., 189., 290., 447.,
+       217., 443., 250., 251., 205., 374., 162., 254., 188., 262., 250.,
+       309., 317., 243., 250., 250., 337., 399., 213., 171., 224., 182.,
+       250., 349., 205., 259., 142., 229., 175., 460., 205., 345., 318.,
+       348., 318., 202., 337., 172., 287., 199., 151., 179., 319., 182.,
+       319., 378., 163., 380., 163., 273., 206., 286., 249., 277., 213.,
+       281., 336., 163., 228., 424., 174., 233., 320., 362., 358., 276.,
+       249., 253., 249., 299., 239., 315., 206., 288., 188., 197., 336.,
+       182., 321., 195., 321., 259., 213., 384., 189., 453., 227., 415.,
+       206., 279., 358., 304., 207., 256., 248., 244., 248., 239., 248.,
+       309., 284., 197., 322., 204., 322., 404., 247., 176., 194., 199.,
+       208., 224., 208., 278., 335., 449., 163., 190., 164., 184., 172.,
+       198., 213., 461., 208., 180., 323., 215., 240., 190., 335., 267.,
+       224., 225., 323., 360., 357., 249., 240., 280., 209., 292., 209.,
+       159., 213., 353., 357., 295., 209., 347., 348., 154., 217., 406.,
+       193., 333., 287., 184., 334., 186., 171., 289., 224., 179., 281.,
+       157., 210., 347., 212., 366., 164., 329., 333., 188., 170., 478.,
+       169., 247., 141., 450., 191., 210., 192., 433., 169., 448., 224.,
+       372., 164., 221., 326., 257., 217., 387., 164., 314., 326., 346.,
+       245., 368., 281., 447., 241., 175., 327., 180., 327., 338., 212.,
+       242., 245., 250., 140., 195., 333., 179., 333., 246., 327., 227.,
+       245., 209., 245., 397., 168., 295., 327., 276., 210., 145., 333.,
+       378., 287., 321., 190., 457., 164., 291., 152., 162., 225., 337.,
+       328., 354., 210., 210., 140., 352., 242., 148., 245., 358., 210.,
+       277., 152., 172., 226., 308., 282., 238., 332., 310., 226., 175.,
+       332., 192., 212., 391., 211., 211., 166., 363., 192., 306., 329.,
+       286., 226., 335., 330., 326., 330., 383., 166., 190., 167., 401.,
+       192., 416., 192., 218., 244., 211., 244., 238., 330., 246., 244.,
+       371., 282., 271., 211., 256., 244., 197., 211., 341., 330., 333.,
+       329., 172., 189., 381., 155., 373., 166., 306., 348., 215., 167.,
+       199., 166., 436., 196., 212., 152., 471., 185., 439., 229., 174.,
+       220., 293., 222., 150., 232., 283., 151., 309., 167., 212., 189.,
+       356., 225., 302., 347., 250., 165., 478., 167., 325., 185., 318.,
+       332., 233., 139., 311., 328., 275., 185., 217., 197., 210., 169.,
+       218., 169., 175., 185., 294., 346., 241., 169., 260., 184., 259.,
+       210., 370., 349., 293., 217., 311., 333., 260., 140., 298., 325.,
+       197., 170., 218., 151., 437., 240., 224., 246., 260., 246., 439.,
+       198., 233., 234., 331., 334., 311., 154., 342., 345., 191., 227.,
+       252., 164., 343., 171., 440., 193., 309., 186., 194., 209., 436.,
+       191., 135., 323., 314., 247., 233., 208., 227., 208., 417., 266.,
+       179., 183., 187., 248., 390., 265., 340., 186., 402., 264., 344.,
+       206., 176., 224., 246., 249., 279., 249., 199., 320., 411., 186.,
+       347., 336., 382., 319., 473., 174., 218., 135., 217., 175., 280.,
+       150., 392., 289., 230., 264., 300., 234., 392., 216., 179., 188.,
+       281., 204., 259., 251., 227., 176., 202., 204., 275., 143., 383.,
+       229., 216., 315., 295., 238., 299., 300., 311., 182., 373., 350.,
+       375., 177., 152., 235., 420., 213., 191., 253., 155., 238., 193.,
+       159., 378., 177., 250., 159., 370., 352., 286., 154., 318., 218.,
+       217., 182., 427., 202., 284., 202., 334., 262., 441., 177., 414.,
+       254., 346., 339., 324., 160., 386., 187., 345., 181., 298., 342.,
+       368., 161., 198., 200., 418., 260., 268., 181., 421., 195., 473.,
+       180., 429., 259., 409., 236., 338., 161., 180., 309., 204., 201.,
+       200., 257., 348., 257., 377., 259., 426., 258., 296., 259., 425.,
+       180., 418., 214., 409., 160., 315., 259., 334., 180., 287., 185.,
+       179., 232., 236., 232., 226., 185., 373., 240., 343., 334., 299.,
+       345., 348., 282., 367., 153., 196., 206., 390., 238., 350., 339.,
+       443., 176., 314., 219., 318., 149., 448., 203., 156., 235., 437.,
+       164., 286., 246., 321., 222., 360., 152., 220., 231., 272., 163.,
+       319., 168., 315., 147., 299., 145., 437., 189., 202., 147., 267.,
+       162., 343., 331., 2.06400009e+02, 132., 2.08800003e+02,
+       1.36800003e+02, 2.12400009e+02, 1.36800003e+02, 2.20800003e+02,
+       1.36800003e+02, 2.25600006e+02, 1.36800003e+02, 2.30400009e+02,
+       1.39200012e+02, 2.07600006e+02, 1.41600006e+02, 2.17200012e+02,
+       1.41600006e+02, 2.24400009e+02, 1.41600006e+02, 2.44800003e+02,
+       1.41600006e+02, 2.53200012e+02, 1.41600006e+02, 264.,
+       1.41600006e+02, 2.20800003e+02, 1.42800003e+02, 2.74800018e+02,
+       1.42800003e+02, 2.23200012e+02, 144., 2.12400009e+02,
+       1.45200012e+02, 2.22000015e+02, 1.46400009e+02, 2.37600006e+02,
+       1.46400009e+02, 2.05200012e+02, 1.47600006e+02, 2.40000015e+02,
+       1.47600006e+02, 2.54400009e+02, 1.47600006e+02, 2.66400024e+02,
+       1.47600006e+02, 2.30400009e+02, 1.48800003e+02, 2.37600006e+02,
+       1.48800003e+02, 2.56800018e+02, 1.48800003e+02, 1.99200012e+02,
+       150., 2.66400024e+02, 150., 2.79600006e+02, 150., 2.61600006e+02,
+       1.52400009e+02, 2.77200012e+02, 1.52400009e+02, 2.89200012e+02,
+       1.52400009e+02, 294., 1.52400009e+02, 3.43200012e+02,
+       1.52400009e+02, 2.06400009e+02, 1.53600006e+02, 2.08800003e+02,
+       1.53600006e+02, 2.50800003e+02, 1.53600006e+02, 2.80800018e+02,
+       1.53600006e+02, 2.86800018e+02, 1.53600006e+02, 2.96400024e+02,
+       1.53600006e+02, 3.04800018e+02, 1.53600006e+02, 3.07200012e+02,
+       1.53600006e+02, 3.58800018e+02, 1.53600006e+02, 2.02800003e+02,
+       1.54800003e+02, 2.16000015e+02, 1.54800003e+02, 3.10800018e+02,
+       1.54800003e+02, 3.80400024e+02, 1.54800003e+02, 2.08800003e+02,
+       156., 2.18400009e+02, 156., 2.23200012e+02, 156., 2.30400009e+02,
+       156., 2.34000015e+02, 156., 2.37600006e+02, 156., 2.48400009e+02,
+       156., 1.96800003e+02, 1.57200012e+02, 2.00400009e+02,
+       1.57200012e+02, 2.14800003e+02, 1.57200012e+02, 2.25600006e+02,
+       1.57200012e+02, 3.31200012e+02, 1.57200012e+02, 3.33600006e+02,
+       1.57200012e+02, 3.20400024e+02, 1.58400009e+02, 4.12800018e+02,
+       1.59600006e+02, 2.00400009e+02, 1.60800003e+02, 2.08800003e+02,
+       1.60800003e+02, 3.34800018e+02, 1.60800003e+02, 3.61200012e+02,
+       1.60800003e+02, 3.68400024e+02, 1.60800003e+02, 1.95600006e+02,
+       162., 2.14800003e+02, 162., 2.46000015e+02, 162., 2.56800018e+02,
+       162., 348., 162., 3.74400024e+02, 162., 4.22400024e+02, 162.,
+       1.89600006e+02, 1.63200012e+02, 2.02800003e+02, 1.63200012e+02,
+       2.65200012e+02, 1.63200012e+02, 2.72400024e+02, 1.63200012e+02,
+       360., 1.63200012e+02, 3.67200012e+02, 1.63200012e+02,
+       3.80400024e+02, 1.63200012e+02, 3.86400024e+02, 1.63200012e+02,
+       4.30800018e+02, 1.63200012e+02, 1.93200012e+02, 1.64400009e+02,
+       2.83200012e+02, 1.64400009e+02, 4.36800018e+02, 1.64400009e+02,
+       4.40400024e+02, 1.64400009e+02, 4.47600006e+02, 1.64400009e+02,
+       2.06400009e+02, 1.65600006e+02, 2.90400024e+02, 1.65600006e+02,
+       378., 1.65600006e+02, 3.80400024e+02, 1.65600006e+02,
+       3.94800018e+02, 1.65600006e+02, 4.10400024e+02, 1.65600006e+02,
+       4.26000031e+02, 1.65600006e+02, 4.60800018e+02, 1.65600006e+02,
+       4.83600006e+02, 1.65600006e+02, 1.89600006e+02, 1.66800003e+02,
+       2.14800003e+02, 1.66800003e+02, 2.46000015e+02, 1.66800003e+02,
+       2.97600006e+02, 1.66800003e+02, 3.04800018e+02, 1.66800003e+02,
+       384., 1.66800003e+02, 3.91200012e+02, 1.66800003e+02,
+       4.15200012e+02, 1.66800003e+02, 4.53600006e+02, 1.66800003e+02,
+       318., 168., 3.96000031e+02, 168., 4.20000031e+02, 168.,
+       2.10000015e+02, 1.69200012e+02, 3.15600006e+02, 1.69200012e+02,
+       4.52400024e+02, 1.69200012e+02, 4.57200012e+02, 1.69200012e+02,
+       4.71600006e+02, 1.69200012e+02, 4.76400024e+02, 1.69200012e+02,
+       1.96800003e+02, 1.70400009e+02, 1.99200012e+02, 1.70400009e+02,
+       3.31200012e+02, 1.70400009e+02, 4.09200012e+02, 1.70400009e+02,
+       4.33200012e+02, 1.70400009e+02, 2.41200012e+02, 1.71600006e+02,
+       4.28400024e+02, 1.71600006e+02, 4.35600006e+02, 1.71600006e+02,
+       4.40400024e+02, 1.71600006e+02, 4.56000031e+02, 1.71600006e+02,
+       4.65600006e+02, 1.71600006e+02, 4.76400024e+02, 1.71600006e+02,
+       1.87200012e+02, 1.72800003e+02, 2.19600006e+02, 1.72800003e+02,
+       348., 1.72800003e+02, 354., 1.72800003e+02, 4.30800018e+02,
+       1.72800003e+02, 4.53600006e+02, 1.72800003e+02, 4.62000031e+02,
+       1.72800003e+02, 4.72800018e+02, 1.72800003e+02, 2.31600006e+02,
+       174., 2.37600006e+02, 174., 3.02400024e+02, 174., 4.18800018e+02,
+       174., 4.23600006e+02, 174., 2.12400009e+02, 1.75200012e+02,
+       2.14800003e+02, 1.75200012e+02, 2.29200012e+02, 1.75200012e+02,
+       4.44000031e+02, 1.75200012e+02, 4.69200012e+02, 1.75200012e+02,
+       2.22000015e+02, 1.76400009e+02, 3.74400024e+02, 1.76400009e+02,
+       4.29600006e+02, 1.76400009e+02, 4.35600006e+02, 1.76400009e+02,
+       4.71600006e+02, 1.76400009e+02, 2.31600006e+02, 1.77600006e+02,
+       4.16400024e+02, 1.77600006e+02, 4.21200012e+02, 1.77600006e+02,
+       4.32000031e+02, 1.77600006e+02, 4.65600006e+02, 1.77600006e+02,
+       1.81200012e+02, 1.78800003e+02, 1.84800003e+02, 1.78800003e+02,
+       2.12400009e+02, 1.78800003e+02, 4.12800018e+02, 1.78800003e+02,
+       4.38000031e+02, 1.78800003e+02, 1.87200012e+02, 180.,
+       2.32800003e+02, 180., 3.33600006e+02, 180., 4.02000031e+02, 180.,
+       4.24800018e+02, 180., 4.72800018e+02, 180., 2.18400009e+02,
+       1.81200012e+02, 2.38800003e+02, 1.81200012e+02, 2.67600006e+02,
+       1.81200012e+02, 3.44400024e+02, 1.81200012e+02, 372.,
+       1.81200012e+02, 3.76800018e+02, 1.81200012e+02, 3.79200012e+02,
+       1.81200012e+02, 3.85200012e+02, 1.81200012e+02, 4.46400024e+02,
+       1.81200012e+02, 4.66800018e+02, 1.81200012e+02, 1.78800003e+02,
+       1.82400009e+02, 1.82400009e+02, 1.82400009e+02, 2.35200012e+02,
+       1.82400009e+02, 2.78400024e+02, 1.82400009e+02, 3.04800018e+02,
+       1.82400009e+02, 3.10800018e+02, 1.82400009e+02, 3.15600006e+02,
+       1.82400009e+02, 3.21600006e+02, 1.82400009e+02, 336.,
+       1.82400009e+02, 4.00800018e+02, 1.82400009e+02, 4.32000031e+02,
+       1.82400009e+02, 4.64400024e+02, 1.82400009e+02, 4.71600006e+02,
+       1.82400009e+02, 2.08800003e+02, 1.83600006e+02, 2.65200012e+02,
+       1.83600006e+02, 282., 1.83600006e+02, 4.34400024e+02,
+       1.83600006e+02, 4.38000031e+02, 1.83600006e+02, 4.41600006e+02,
+       1.83600006e+02, 4.48800018e+02, 1.83600006e+02, 4.58400024e+02,
+       1.83600006e+02, 4.62000031e+02, 1.83600006e+02, 2.14800003e+02,
+       1.84800003e+02, 2.25600006e+02, 1.84800003e+02, 2.36400009e+02,
+       1.84800003e+02, 2.77200012e+02, 1.84800003e+02, 2.86800018e+02,
+       1.84800003e+02, 3.02400024e+02, 1.84800003e+02, 3.16800018e+02,
+       1.84800003e+02, 3.25200012e+02, 1.84800003e+02, 378.,
+       1.84800003e+02, 4.46400024e+02, 1.84800003e+02, 4.70400024e+02,
+       1.84800003e+02, 258., 186., 2.66400024e+02, 186., 2.90400024e+02,
+       186., 294., 186., 2.98800018e+02, 186., 3.33600006e+02, 186.,
+       3.39600006e+02, 186., 4.32000031e+02, 186., 4.87200012e+02, 186.,
+       2.06400009e+02, 1.87200012e+02, 2.35200012e+02, 1.87200012e+02,
+       3.13200012e+02, 1.87200012e+02, 3.69600006e+02, 1.87200012e+02,
+       3.98400024e+02, 1.87200012e+02, 4.11600006e+02, 1.87200012e+02,
+       4.66800018e+02, 1.87200012e+02, 1.71600006e+02, 1.88400009e+02,
+       1.95600006e+02, 1.88400009e+02, 2.13600006e+02, 1.88400009e+02,
+       2.31600006e+02, 1.88400009e+02, 2.53200012e+02, 1.88400009e+02,
+       3.28800018e+02, 1.88400009e+02, 3.87600006e+02, 1.88400009e+02,
+       3.91200012e+02, 1.88400009e+02, 3.94800018e+02, 1.88400009e+02,
+       2.37600006e+02, 1.89600006e+02, 3.16800018e+02, 1.89600006e+02,
+       3.69600006e+02, 1.89600006e+02, 4.63200012e+02, 1.89600006e+02,
+       1.72800003e+02, 1.90800003e+02, 1.95600006e+02, 1.90800003e+02,
+       2.22000015e+02, 1.90800003e+02, 2.32800003e+02, 1.90800003e+02,
+       2.44800003e+02, 1.90800003e+02, 2.74800018e+02, 1.90800003e+02,
+       2.79600006e+02, 1.90800003e+02, 3.03600006e+02, 1.90800003e+02,
+       3.10800018e+02, 1.90800003e+02, 3.46800018e+02, 1.90800003e+02,
+       3.75600006e+02, 1.90800003e+02, 4.35600006e+02, 1.90800003e+02,
+       4.65600006e+02, 1.90800003e+02, 1.87200012e+02, 192.,
+       1.89600006e+02, 192., 2.77200012e+02, 192., 282., 192., 294.,
+       192., 2.96400024e+02, 192., 318., 192., 3.33600006e+02, 192.,
+       3.62400024e+02, 192., 3.82800018e+02, 192., 3.90000031e+02, 192.,
+       4.03200012e+02, 192., 2.08800003e+02, 1.93200012e+02,
+       2.12400009e+02, 1.93200012e+02, 3.28800018e+02, 1.93200012e+02,
+       336., 1.93200012e+02, 3.40800018e+02, 1.93200012e+02,
+       3.52800018e+02, 1.93200012e+02, 4.17600006e+02, 1.93200012e+02,
+       1.70400009e+02, 1.94400009e+02, 1.75200012e+02, 1.94400009e+02,
+       2.31600006e+02, 1.94400009e+02, 2.37600006e+02, 1.94400009e+02,
+       2.41200012e+02, 1.94400009e+02, 276., 1.94400009e+02,
+       3.10800018e+02, 1.94400009e+02, 3.86400024e+02, 1.94400009e+02,
+       3.88800018e+02, 1.94400009e+02, 4.58400024e+02, 1.94400009e+02,
+       2.56800018e+02, 1.95600006e+02, 288., 1.95600006e+02,
+       3.08400024e+02, 1.95600006e+02, 3.81600006e+02, 1.95600006e+02,
+       3.97200012e+02, 1.95600006e+02, 4.35600006e+02, 1.95600006e+02,
+       4.40400024e+02, 1.95600006e+02, 1.72800003e+02, 1.96800003e+02,
+       1.82400009e+02, 1.96800003e+02, 1.98000015e+02, 1.96800003e+02,
+       2.31600006e+02, 1.96800003e+02, 2.44800003e+02, 1.96800003e+02,
+       2.65200012e+02, 1.96800003e+02, 2.68800018e+02, 1.96800003e+02,
+       3.15600006e+02, 1.96800003e+02, 3.20400024e+02, 1.96800003e+02,
+       330., 1.96800003e+02, 3.39600006e+02, 1.96800003e+02,
+       3.67200012e+02, 1.96800003e+02, 378., 1.96800003e+02,
+       4.10400024e+02, 1.96800003e+02, 4.30800018e+02, 1.96800003e+02,
+       4.62000031e+02, 1.96800003e+02, 1.90800003e+02, 1.98000015e+02,
+       2.07600006e+02, 1.98000015e+02, 2.11200012e+02, 1.98000015e+02,
+       2.20800003e+02, 1.98000015e+02, 2.52000015e+02, 1.98000015e+02,
+       2.60400024e+02, 1.98000015e+02, 3.03600006e+02, 1.98000015e+02,
+       3.08400024e+02, 1.98000015e+02, 3.64800018e+02, 1.98000015e+02,
+       4.39200012e+02, 1.98000015e+02, 4.45200012e+02, 1.98000015e+02,
+       2.28000015e+02, 1.99200012e+02, 2.38800003e+02, 1.99200012e+02,
+       2.72400024e+02, 1.99200012e+02, 312., 1.99200012e+02,
+       3.52800018e+02, 1.99200012e+02, 3.68400024e+02, 1.99200012e+02,
+       3.81600006e+02, 1.99200012e+02, 3.97200012e+02, 1.99200012e+02,
+       4.06800018e+02, 1.99200012e+02, 4.23600006e+02, 1.99200012e+02,
+       4.64400024e+02, 1.99200012e+02, 1.75200012e+02, 2.00400009e+02,
+       2.04000015e+02, 2.00400009e+02, 2.34000015e+02, 2.00400009e+02,
+       2.67600006e+02, 2.00400009e+02, 3.08400024e+02, 2.00400009e+02,
+       318., 2.00400009e+02, 330., 2.00400009e+02, 3.45600006e+02,
+       2.00400009e+02, 384., 2.00400009e+02, 3.86400024e+02,
+       2.00400009e+02, 4.00800018e+02, 2.00400009e+02, 4.12800018e+02,
+       2.00400009e+02, 1.96800003e+02, 2.01600006e+02, 2.10000015e+02,
+       2.01600006e+02, 2.22000015e+02, 2.01600006e+02, 2.73600006e+02,
+       2.01600006e+02, 3.21600006e+02, 2.01600006e+02, 3.37200012e+02,
+       2.01600006e+02, 3.92400024e+02, 2.01600006e+02, 3.98400024e+02,
+       2.01600006e+02, 4.60800018e+02, 2.01600006e+02, 2.38800003e+02,
+       2.02800003e+02, 2.67600006e+02, 2.02800003e+02, 294.,
+       2.02800003e+02, 3.03600006e+02, 2.02800003e+02, 3.08400024e+02,
+       2.02800003e+02, 3.10800018e+02, 2.02800003e+02, 3.16800018e+02,
+       2.02800003e+02, 3.69600006e+02, 2.02800003e+02, 4.10400024e+02,
+       2.02800003e+02, 4.17600006e+02, 2.02800003e+02, 4.47600006e+02,
+       2.02800003e+02, 4.50000031e+02, 2.02800003e+02, 1.70400009e+02,
+       2.04000015e+02, 2.11200012e+02, 2.04000015e+02, 2.20800003e+02,
+       2.04000015e+02, 2.35200012e+02, 2.04000015e+02, 2.42400009e+02,
+       2.04000015e+02, 2.56800018e+02, 2.04000015e+02, 2.80800018e+02,
+       2.04000015e+02, 3.27600006e+02, 2.04000015e+02, 3.88800018e+02,
+       2.04000015e+02, 3.98400024e+02, 2.04000015e+02, 4.12800018e+02,
+       2.04000015e+02, 4.15200012e+02, 2.04000015e+02, 4.53600006e+02,
+       2.04000015e+02, 4.59600006e+02, 2.04000015e+02, 1.66800003e+02,
+       2.05200012e+02, 2.02800003e+02, 2.05200012e+02, 2.46000015e+02,
+       2.05200012e+02, 2.48400009e+02, 2.05200012e+02, 2.50800003e+02,
+       2.05200012e+02, 3.49200012e+02, 2.05200012e+02, 3.62400024e+02,
+       2.05200012e+02, 3.96000031e+02, 2.05200012e+02, 4.03200012e+02,
+       2.05200012e+02, 1.64400009e+02, 2.06400009e+02, 2.14800003e+02,
+       2.06400009e+02, 2.66400024e+02, 2.06400009e+02, 270.,
+       2.06400009e+02, 2.85600006e+02, 2.06400009e+02, 3.34800018e+02,
+       2.06400009e+02, 3.43200012e+02, 2.06400009e+02, 354.,
+       2.06400009e+02, 3.70800018e+02, 2.06400009e+02, 384.,
+       2.06400009e+02, 4.58400024e+02, 2.06400009e+02, 2.24400009e+02,
+       2.07600006e+02, 2.26800003e+02, 2.07600006e+02, 2.32800003e+02,
+       2.07600006e+02, 2.44800003e+02, 2.07600006e+02, 2.61600006e+02,
+       2.07600006e+02, 3.21600006e+02, 2.07600006e+02, 3.28800018e+02,
+       2.07600006e+02, 3.61200012e+02, 2.07600006e+02, 3.91200012e+02,
+       2.07600006e+02, 4.17600006e+02, 2.07600006e+02, 1.59600006e+02,
+       2.08800003e+02, 1.78800003e+02, 2.08800003e+02, 1.96800003e+02,
+       2.08800003e+02, 2.79600006e+02, 2.08800003e+02, 2.91600006e+02,
+       2.08800003e+02, 324., 2.08800003e+02, 3.68400024e+02,
+       2.08800003e+02, 3.96000031e+02, 2.08800003e+02, 4.54800018e+02,
+       2.08800003e+02, 4.57200012e+02, 2.08800003e+02, 4.59600006e+02,
+       2.08800003e+02, 1.57200012e+02, 2.10000015e+02, 1.70400009e+02,
+       2.10000015e+02, 1.90800003e+02, 2.10000015e+02, 2.10000015e+02,
+       2.10000015e+02, 2.86800018e+02, 2.10000015e+02, 294.,
+       2.10000015e+02, 3.04800018e+02, 2.10000015e+02, 3.10800018e+02,
+       2.10000015e+02, 3.20400024e+02, 2.10000015e+02, 3.27600006e+02,
+       2.10000015e+02, 354., 2.10000015e+02, 3.70800018e+02,
+       2.10000015e+02, 3.73200012e+02, 2.10000015e+02, 4.03200012e+02,
+       2.10000015e+02, 4.45200012e+02, 2.10000015e+02, 1.96800003e+02,
+       2.11200012e+02, 2.02800003e+02, 2.11200012e+02, 3.14400024e+02,
+       2.11200012e+02, 3.32400024e+02, 2.11200012e+02, 3.58800018e+02,
+       2.11200012e+02, 3.79200012e+02, 2.11200012e+02, 2.62800018e+02,
+       2.12400009e+02, 282., 2.12400009e+02, 3.39600006e+02,
+       2.12400009e+02, 3.45600006e+02, 2.12400009e+02, 3.62400024e+02,
+       2.12400009e+02, 3.67200012e+02, 2.12400009e+02, 4.10400024e+02,
+       2.12400009e+02, 4.05600006e+02, 2.13600006e+02, 2.02800003e+02,
+       2.14800003e+02, 2.10000015e+02, 2.14800003e+02, 2.24400009e+02,
+       2.14800003e+02, 2.49600006e+02, 2.14800003e+02, 2.91600006e+02,
+       2.14800003e+02, 3.31200012e+02, 2.14800003e+02, 3.82800018e+02,
+       2.14800003e+02, 4.51200012e+02, 2.14800003e+02, 1.54800003e+02,
+       2.16000015e+02, 1.84800003e+02, 2.16000015e+02, 2.05200012e+02,
+       2.16000015e+02, 2.60400024e+02, 2.16000015e+02, 264.,
+       2.16000015e+02, 2.68800018e+02, 2.16000015e+02, 2.83200012e+02,
+       2.16000015e+02, 3.01200012e+02, 2.16000015e+02, 3.70800018e+02,
+       2.16000015e+02, 3.73200012e+02, 2.16000015e+02, 4.05600006e+02,
+       2.16000015e+02, 4.11600006e+02, 2.16000015e+02, 4.47600006e+02,
+       2.16000015e+02, 4.54800018e+02, 2.16000015e+02, 1.64400009e+02,
+       2.17200012e+02, 1.66800003e+02, 2.17200012e+02, 2.56800018e+02,
+       2.17200012e+02, 2.90400024e+02, 2.17200012e+02, 3.81600006e+02,
+       2.17200012e+02, 2.06400009e+02, 2.18400009e+02, 2.84400024e+02,
+       2.18400009e+02, 3.01200012e+02, 2.18400009e+02, 318.,
+       2.18400009e+02, 3.46800018e+02, 2.18400009e+02, 378.,
+       2.18400009e+02, 3.90000031e+02, 2.18400009e+02, 4.06800018e+02,
+       2.18400009e+02, 4.50000031e+02, 2.18400009e+02, 4.53600006e+02,
+       2.18400009e+02, 168., 2.19600006e+02, 2.74800018e+02,
+       2.19600006e+02, 3.96000031e+02, 2.19600006e+02, 4.04400024e+02,
+       2.19600006e+02, 4.09200012e+02, 2.19600006e+02, 1.59600006e+02,
+       2.20800003e+02, 174., 2.20800003e+02, 2.05200012e+02,
+       2.20800003e+02, 270., 2.20800003e+02, 2.72400024e+02,
+       2.20800003e+02, 282., 2.20800003e+02, 2.85600006e+02,
+       2.20800003e+02, 3.08400024e+02, 2.20800003e+02, 3.14400024e+02,
+       2.20800003e+02, 4.06800018e+02, 2.20800003e+02, 150.,
+       2.22000015e+02, 1.93200012e+02, 2.22000015e+02, 2.02800003e+02,
+       2.22000015e+02, 2.77200012e+02, 2.22000015e+02, 2.89200012e+02,
+       2.22000015e+02, 294., 2.22000015e+02, 3.21600006e+02,
+       2.22000015e+02, 3.31200012e+02, 2.22000015e+02, 3.58800018e+02,
+       2.22000015e+02, 366., 2.22000015e+02, 3.69600006e+02,
+       2.22000015e+02, 3.73200012e+02, 2.22000015e+02, 3.82800018e+02,
+       2.22000015e+02, 4.03200012e+02, 2.22000015e+02, 4.26000031e+02,
+       2.22000015e+02, 4.36800018e+02, 2.22000015e+02, 1.52400009e+02,
+       2.23200012e+02, 1.76400009e+02, 2.23200012e+02, 1.81200012e+02,
+       2.23200012e+02, 2.55600006e+02, 2.23200012e+02, 2.73600006e+02,
+       2.23200012e+02, 3.19200012e+02, 2.23200012e+02, 3.49200012e+02,
+       2.23200012e+02, 3.97200012e+02, 2.23200012e+02, 1.46400009e+02,
+       2.24400009e+02, 1.63200012e+02, 2.24400009e+02, 2.61600006e+02,
+       2.24400009e+02, 3.55200012e+02, 2.24400009e+02, 3.81600006e+02,
+       2.24400009e+02, 3.94800018e+02, 2.24400009e+02, 4.06800018e+02,
+       2.24400009e+02, 4.30800018e+02, 2.24400009e+02, 4.35600006e+02,
+       2.24400009e+02, 4.47600006e+02, 2.24400009e+02, 150.,
+       2.25600006e+02, 1.53600006e+02, 2.25600006e+02, 192.,
+       2.25600006e+02, 2.05200012e+02, 2.25600006e+02, 2.11200012e+02,
+       2.25600006e+02, 1.57200012e+02, 2.26800003e+02, 1.99200012e+02,
+       2.26800003e+02, 2.72400024e+02, 2.26800003e+02, 2.80800018e+02,
+       2.26800003e+02, 3.09600006e+02, 2.26800003e+02, 3.15600006e+02,
+       2.26800003e+02, 3.92400024e+02, 2.26800003e+02, 4.08000031e+02,
+       2.26800003e+02, 4.35600006e+02, 2.26800003e+02, 4.52400024e+02,
+       2.26800003e+02, 1.46400009e+02, 2.28000015e+02, 2.05200012e+02,
+       2.28000015e+02, 2.92800018e+02, 2.28000015e+02, 3.04800018e+02,
+       2.28000015e+02, 324., 2.28000015e+02, 3.99600006e+02,
+       2.28000015e+02, 4.29600006e+02, 2.28000015e+02, 1.42800003e+02,
+       2.29200012e+02, 2.28000015e+02, 2.29200012e+02, 2.32800003e+02,
+       2.29200012e+02, 2.44800003e+02, 2.29200012e+02, 4.23600006e+02,
+       2.29200012e+02, 4.33200012e+02, 2.29200012e+02, 2.02800003e+02,
+       2.30400009e+02, 2.20800003e+02, 2.30400009e+02, 2.67600006e+02,
+       2.30400009e+02, 4.42800018e+02, 2.30400009e+02, 1.47600006e+02,
+       2.31600006e+02, 1.59600006e+02, 2.31600006e+02, 2.07600006e+02,
+       2.31600006e+02, 4.02000031e+02, 2.31600006e+02, 4.12800018e+02,
+       2.31600006e+02, 4.33200012e+02, 2.31600006e+02, 4.45200012e+02,
+       2.31600006e+02, 4.47600006e+02, 2.31600006e+02, 1.76400009e+02,
+       2.32800003e+02, 2.25600006e+02, 2.32800003e+02, 2.74800018e+02,
+       2.32800003e+02, 3.55200012e+02, 2.32800003e+02, 3.97200012e+02,
+       2.32800003e+02, 144., 2.34000015e+02, 180., 2.34000015e+02,
+       2.16000015e+02, 2.34000015e+02, 2.67600006e+02, 2.34000015e+02,
+       2.79600006e+02, 2.34000015e+02, 282., 2.34000015e+02, 294.,
+       2.34000015e+02, 300., 2.34000015e+02, 4.11600006e+02,
+       2.34000015e+02, 4.42800018e+02, 2.34000015e+02, 4.46400024e+02,
+       2.34000015e+02, 1.63200012e+02, 2.35200012e+02, 2.13600006e+02,
+       2.35200012e+02, 2.85600006e+02, 2.35200012e+02, 3.07200012e+02,
+       2.35200012e+02, 4.48800018e+02, 2.35200012e+02, 1.59600006e+02,
+       2.36400009e+02, 1.66800003e+02, 2.36400009e+02, 1.71600006e+02,
+       2.36400009e+02, 2.19600006e+02, 2.36400009e+02, 2.68800018e+02,
+       2.36400009e+02, 1.36800003e+02, 2.37600006e+02, 1.76400009e+02,
+       2.37600006e+02, 2.31600006e+02, 2.37600006e+02, 2.36400009e+02,
+       2.37600006e+02, 3.33600006e+02, 2.37600006e+02, 3.90000031e+02,
+       2.37600006e+02, 4.00800018e+02, 2.37600006e+02, 4.47600006e+02,
+       2.37600006e+02, 1.48800003e+02, 2.38800003e+02, 2.01600006e+02,
+       2.38800003e+02, 2.08800003e+02, 2.38800003e+02, 2.25600006e+02,
+       2.38800003e+02, 2.44800003e+02, 2.38800003e+02, 2.95200012e+02,
+       2.38800003e+02, 2.98800018e+02, 2.38800003e+02, 3.01200012e+02,
+       2.38800003e+02, 3.64800018e+02, 2.38800003e+02, 4.45200012e+02,
+       2.38800003e+02, 1.42800003e+02, 2.40000015e+02, 1.51200012e+02,
+       2.40000015e+02, 1.60800003e+02, 2.40000015e+02, 1.71600006e+02,
+       2.40000015e+02, 1.76400009e+02, 2.40000015e+02, 2.14800003e+02,
+       2.40000015e+02, 2.66400024e+02, 2.40000015e+02, 3.69600006e+02,
+       2.40000015e+02, 3.99600006e+02, 2.40000015e+02, 1.39200012e+02,
+       2.41200012e+02, 1.82400009e+02, 2.41200012e+02, 1.98000015e+02,
+       2.41200012e+02, 2.01600006e+02, 2.41200012e+02, 2.06400009e+02,
+       2.41200012e+02, 2.60400024e+02, 2.41200012e+02, 3.51600006e+02,
+       2.41200012e+02, 3.73200012e+02, 2.41200012e+02, 4.44000031e+02,
+       2.41200012e+02, 1.33200012e+02, 2.42400009e+02, 1.41600006e+02,
+       2.42400009e+02, 174., 2.42400009e+02, 180., 2.42400009e+02,
+       1.94400009e+02, 2.42400009e+02, 2.32800003e+02, 2.42400009e+02,
+       3.93600006e+02, 2.42400009e+02, 3.98400024e+02, 2.42400009e+02,
+       4.35600006e+02, 2.42400009e+02, 2.17200012e+02, 2.43600006e+02,
+       2.46000015e+02, 2.43600006e+02, 3.91200012e+02, 2.43600006e+02,
+       4.39200012e+02, 2.43600006e+02, 4.42800018e+02, 2.43600006e+02,
+       1.36800003e+02, 2.44800003e+02, 1.40400009e+02, 2.44800003e+02,
+       1.48800003e+02, 2.44800003e+02, 1.69200012e+02, 2.44800003e+02,
+       1.75200012e+02, 2.44800003e+02, 1.83600006e+02, 2.44800003e+02,
+       1.90800003e+02, 2.44800003e+02, 2.08800003e+02, 2.44800003e+02,
+       2.19600006e+02, 2.44800003e+02, 2.26800003e+02, 2.44800003e+02,
+       2.32800003e+02, 2.44800003e+02, 2.48400009e+02, 2.44800003e+02,
+       2.56800018e+02, 2.44800003e+02, 2.66400024e+02, 2.44800003e+02,
+       3.04800018e+02, 2.44800003e+02, 354., 2.44800003e+02,
+       3.63600006e+02, 2.44800003e+02, 3.73200012e+02, 2.44800003e+02,
+       1.30800003e+02, 2.46000015e+02, 1.33200012e+02, 2.46000015e+02,
+       1.63200012e+02, 2.46000015e+02, 1.72800003e+02, 2.46000015e+02,
+       1.78800003e+02, 2.46000015e+02, 2.24400009e+02, 2.46000015e+02,
+       2.40000015e+02, 2.46000015e+02, 2.60400024e+02, 2.46000015e+02,
+       2.92800018e+02, 2.46000015e+02, 3.08400024e+02, 2.46000015e+02,
+       3.56400024e+02, 2.46000015e+02, 3.67200012e+02, 2.46000015e+02,
+       3.69600006e+02, 2.46000015e+02, 4.29600006e+02, 2.46000015e+02,
+       4.35600006e+02, 2.46000015e+02, 4.41600006e+02, 2.46000015e+02,
+       1.84800003e+02, 2.47200012e+02, 1.90800003e+02, 2.47200012e+02,
+       2.36400009e+02, 2.47200012e+02, 2.43600006e+02, 2.47200012e+02,
+       2.48400009e+02, 2.47200012e+02, 3.34800018e+02, 2.47200012e+02,
+       3.38400024e+02, 2.47200012e+02, 3.46800018e+02, 2.47200012e+02,
+       3.51600006e+02, 2.47200012e+02, 3.58800018e+02, 2.47200012e+02,
+       3.80400024e+02, 2.47200012e+02, 3.87600006e+02, 2.47200012e+02,
+       3.93600006e+02, 2.47200012e+02, 3.98400024e+02, 2.47200012e+02,
+       138., 2.48400009e+02, 1.75200012e+02, 2.48400009e+02,
+       2.53200012e+02, 2.48400009e+02, 2.85600006e+02, 2.48400009e+02,
+       3.15600006e+02, 2.48400009e+02, 3.56400024e+02, 2.48400009e+02,
+       3.73200012e+02, 2.48400009e+02, 3.75600006e+02, 2.48400009e+02,
+       4.40400024e+02, 2.48400009e+02, 1.30800003e+02, 2.49600006e+02,
+       1.51200012e+02, 2.49600006e+02, 1.77600006e+02, 2.49600006e+02,
+       2.68800018e+02, 2.49600006e+02, 3.03600006e+02, 2.49600006e+02,
+       342., 2.49600006e+02, 3.62400024e+02, 2.49600006e+02,
+       3.82800018e+02, 2.49600006e+02, 4.36800018e+02, 2.49600006e+02,
+       4.42800018e+02, 2.49600006e+02, 1.41600006e+02, 2.50800003e+02,
+       1.48800003e+02, 2.50800003e+02, 1.65600006e+02, 2.50800003e+02,
+       1.69200012e+02, 2.50800003e+02, 1.71600006e+02, 2.50800003e+02,
+       1.81200012e+02, 2.50800003e+02, 2.59200012e+02, 2.50800003e+02,
+       2.91600006e+02, 2.50800003e+02, 3.34800018e+02, 2.50800003e+02,
+       3.44400024e+02, 2.50800003e+02, 3.51600006e+02, 2.50800003e+02,
+       366., 2.50800003e+02, 3.69600006e+02, 2.50800003e+02, 378.,
+       2.50800003e+02, 4.39200012e+02, 2.50800003e+02, 1.27200005e+02,
+       2.52000015e+02, 1.36800003e+02, 2.52000015e+02, 1.96800003e+02,
+       2.52000015e+02, 2.68800018e+02, 2.52000015e+02, 3.14400024e+02,
+       2.52000015e+02, 3.40800018e+02, 2.52000015e+02, 3.56400024e+02,
+       2.52000015e+02, 3.58800018e+02, 2.52000015e+02, 3.85200012e+02,
+       2.52000015e+02, 4.41600006e+02, 2.52000015e+02, 132.,
+       2.53200012e+02, 1.45200012e+02, 2.53200012e+02, 1.57200012e+02,
+       2.53200012e+02, 168., 2.53200012e+02, 1.72800003e+02,
+       2.53200012e+02, 192., 2.53200012e+02, 2.80800018e+02,
+       2.53200012e+02, 318., 2.53200012e+02, 3.21600006e+02,
+       2.53200012e+02, 3.27600006e+02, 2.53200012e+02, 3.34800018e+02,
+       2.53200012e+02, 4.24800018e+02, 2.53200012e+02, 1.51200012e+02,
+       2.54400009e+02, 288., 2.54400009e+02, 3.70800018e+02,
+       2.54400009e+02, 4.03200012e+02, 2.54400009e+02, 4.14000031e+02,
+       2.54400009e+02, 4.27200012e+02, 2.54400009e+02, 132.,
+       2.55600006e+02, 1.36800003e+02, 2.55600006e+02, 1.63200012e+02,
+       2.55600006e+02, 1.83600006e+02, 2.55600006e+02, 1.96800003e+02,
+       2.55600006e+02, 2.98800018e+02, 2.55600006e+02, 360.,
+       2.55600006e+02, 3.74400024e+02, 2.55600006e+02, 4.18800018e+02,
+       2.55600006e+02, 1.23600006e+02, 2.56800018e+02, 1.45200012e+02,
+       2.56800018e+02, 1.48800003e+02, 2.56800018e+02, 1.94400009e+02,
+       2.56800018e+02, 2.90400024e+02, 2.56800018e+02, 3.08400024e+02,
+       2.56800018e+02, 3.13200012e+02, 2.56800018e+02, 3.32400024e+02,
+       2.56800018e+02, 348., 2.56800018e+02, 3.55200012e+02,
+       2.56800018e+02, 3.80400024e+02, 2.56800018e+02, 1.30800003e+02,
+       258., 1.35600006e+02, 258., 1.41600006e+02, 258., 1.54800003e+02,
+       258., 1.89600006e+02, 258., 2.24400009e+02, 258., 2.29200012e+02,
+       258., 2.98800018e+02, 258., 3.16800018e+02, 258., 3.22800018e+02,
+       258., 3.52800018e+02, 258., 3.63600006e+02, 258., 3.70800018e+02,
+       258., 3.74400024e+02, 258., 378., 258., 4.12800018e+02, 258.,
+       4.17600006e+02, 258., 4.22400024e+02, 258., 4.36800018e+02, 258.,
+       1.47600006e+02, 2.59200012e+02, 162., 2.59200012e+02,
+       1.64400009e+02, 2.59200012e+02, 1.70400009e+02, 2.59200012e+02,
+       4.27200012e+02, 2.59200012e+02, 1.45200012e+02, 2.60400024e+02,
+       1.84800003e+02, 2.60400024e+02, 2.36400009e+02, 2.60400024e+02,
+       2.43600006e+02, 2.60400024e+02, 2.48400009e+02, 2.60400024e+02,
+       3.27600006e+02, 2.60400024e+02, 3.61200012e+02, 2.60400024e+02,
+       3.64800018e+02, 2.60400024e+02, 4.17600006e+02, 2.60400024e+02,
+       1.12800003e+02, 2.61600006e+02, 1.52400009e+02, 2.61600006e+02,
+       1.75200012e+02, 2.61600006e+02, 1.90800003e+02, 2.61600006e+02,
+       2.22000015e+02, 2.61600006e+02, 2.41200012e+02, 2.61600006e+02,
+       2.53200012e+02, 2.61600006e+02, 3.37200012e+02, 2.61600006e+02,
+       372., 2.61600006e+02, 3.75600006e+02, 2.61600006e+02,
+       4.34400024e+02, 2.61600006e+02, 1.72800003e+02, 2.62800018e+02,
+       1.78800003e+02, 2.62800018e+02, 1.96800003e+02, 2.62800018e+02,
+       2.60400024e+02, 2.62800018e+02, 3.39600006e+02, 2.62800018e+02,
+       348., 2.62800018e+02, 3.96000031e+02, 2.62800018e+02,
+       4.09200012e+02, 2.62800018e+02, 4.17600006e+02, 2.62800018e+02,
+       4.23600006e+02, 2.62800018e+02, 4.64400024e+02, 2.62800018e+02,
+       1.69200012e+02, 264., 1.81200012e+02, 264., 2.29200012e+02, 264.,
+       2.35200012e+02, 264., 2.71200012e+02, 264., 3.56400024e+02, 264.,
+       3.98400024e+02, 264., 4.02000031e+02, 264., 1.77600006e+02,
+       2.65200012e+02, 1.89600006e+02, 2.65200012e+02, 2.44800003e+02,
+       2.65200012e+02, 2.50800003e+02, 2.65200012e+02, 264.,
+       2.65200012e+02, 2.77200012e+02, 2.65200012e+02, 3.94800018e+02,
+       2.65200012e+02, 4.10400024e+02, 2.65200012e+02, 4.27200012e+02,
+       2.65200012e+02, 4.35600006e+02, 2.65200012e+02, 2.01600006e+02,
+       2.66400024e+02, 258., 2.66400024e+02, 2.80800018e+02,
+       2.66400024e+02, 3.98400024e+02, 2.66400024e+02, 4.17600006e+02,
+       2.66400024e+02, 192., 2.67600006e+02, 2.83200012e+02,
+       2.67600006e+02, 2.95200012e+02, 2.67600006e+02, 2.00400009e+02,
+       2.68800018e+02, 2.12400009e+02, 2.68800018e+02, 2.68800018e+02,
+       2.68800018e+02, 288., 2.68800018e+02, 3.68400024e+02,
+       2.68800018e+02, 3.92400024e+02, 2.68800018e+02, 4.04400024e+02,
+       2.68800018e+02, 4.10400024e+02, 2.68800018e+02, 4.16400024e+02,
+       2.68800018e+02, 4.32000031e+02, 2.68800018e+02, 1.29600006e+02,
+       270., 2.18400009e+02, 270., 2.29200012e+02, 270., 276., 270.,
+       2.83200012e+02, 270., 2.97600006e+02, 270., 300., 270.,
+       3.07200012e+02, 270., 384., 270., 2.16000015e+02, 2.71200012e+02,
+       2.26800003e+02, 2.71200012e+02, 2.86800018e+02, 2.71200012e+02,
+       312., 2.71200012e+02, 3.70800018e+02, 2.71200012e+02,
+       4.02000031e+02, 2.71200012e+02, 4.06800018e+02, 2.71200012e+02,
+       4.16400024e+02, 2.71200012e+02, 4.27200012e+02, 2.71200012e+02,
+       4.33200012e+02, 2.71200012e+02, 1.29600006e+02, 2.72400024e+02,
+       144., 2.72400024e+02, 2.24400009e+02, 2.72400024e+02,
+       2.38800003e+02, 2.72400024e+02, 294., 2.72400024e+02,
+       2.98800018e+02, 2.72400024e+02, 3.19200012e+02, 2.72400024e+02,
+       3.25200012e+02, 2.72400024e+02, 3.96000031e+02, 2.72400024e+02,
+       4.09200012e+02, 2.72400024e+02, 1.52400009e+02, 2.73600006e+02,
+       306., 2.73600006e+02, 3.08400024e+02, 2.73600006e+02,
+       3.88800018e+02, 2.73600006e+02, 4.27200012e+02, 2.73600006e+02,
+       4.29600006e+02, 2.73600006e+02, 1.40400009e+02, 2.74800018e+02,
+       144., 2.74800018e+02, 2.38800003e+02, 2.74800018e+02,
+       2.49600006e+02, 2.74800018e+02, 3.70800018e+02, 2.74800018e+02,
+       3.81600006e+02, 2.74800018e+02, 3.93600006e+02, 2.74800018e+02,
+       3.99600006e+02, 2.74800018e+02, 4.24800018e+02, 2.74800018e+02,
+       1.26000008e+02, 276., 1.48800003e+02, 276., 1.52400009e+02, 276.,
+       156., 276., 168., 276., 2.46000015e+02, 276., 2.59200012e+02,
+       276., 2.62800018e+02, 276., 3.15600006e+02, 276., 3.19200012e+02,
+       276., 3.57600006e+02, 276., 3.74400024e+02, 276., 384., 276.,
+       4.18800018e+02, 276., 1.75200012e+02, 2.77200012e+02,
+       2.71200012e+02, 2.77200012e+02, 3.87600006e+02, 2.77200012e+02,
+       4.28400024e+02, 2.77200012e+02, 168., 2.78400024e+02,
+       2.62800018e+02, 2.78400024e+02, 360., 2.78400024e+02, 378.,
+       2.78400024e+02, 3.80400024e+02, 2.78400024e+02, 3.96000031e+02,
+       2.78400024e+02, 4.21200012e+02, 2.78400024e+02, 1.90800003e+02,
+       2.79600006e+02, 270., 2.79600006e+02, 294., 2.79600006e+02,
+       3.52800018e+02, 2.79600006e+02, 3.73200012e+02, 2.79600006e+02,
+       1.77600006e+02, 2.80800018e+02, 1.87200012e+02, 2.80800018e+02,
+       1.99200012e+02, 2.80800018e+02, 2.90400024e+02, 2.80800018e+02,
+       3.01200012e+02, 2.80800018e+02, 3.55200012e+02, 2.80800018e+02,
+       3.63600006e+02, 2.80800018e+02, 3.96000031e+02, 2.80800018e+02,
+       4.12800018e+02, 2.80800018e+02, 4.28400024e+02, 2.80800018e+02,
+       1.84800003e+02, 282., 1.90800003e+02, 282., 288., 282.,
+       2.98800018e+02, 282., 366., 282., 3.70800018e+02, 282.,
+       3.81600006e+02, 282., 4.26000031e+02, 282., 1.94400009e+02,
+       2.83200012e+02, 2.14800003e+02, 2.83200012e+02, 2.95200012e+02,
+       2.83200012e+02, 3.52800018e+02, 2.83200012e+02, 4.23600006e+02,
+       2.83200012e+02, 1.40400009e+02, 2.84400024e+02, 1.99200012e+02,
+       2.84400024e+02, 2.23200012e+02, 2.84400024e+02, 3.55200012e+02,
+       2.84400024e+02, 3.57600006e+02, 2.84400024e+02, 3.63600006e+02,
+       2.84400024e+02, 3.79200012e+02, 2.84400024e+02, 3.82800018e+02,
+       2.84400024e+02, 4.02000031e+02, 2.84400024e+02, 4.05600006e+02,
+       2.84400024e+02, 1.42800003e+02, 2.85600006e+02, 162.,
+       2.85600006e+02, 2.14800003e+02, 2.85600006e+02, 3.10800018e+02,
+       2.85600006e+02, 360., 2.85600006e+02, 366., 2.85600006e+02,
+       3.86400024e+02, 2.85600006e+02, 1.69200012e+02, 2.86800018e+02,
+       1.71600006e+02, 2.86800018e+02, 2.18400009e+02, 2.86800018e+02,
+       2.25600006e+02, 2.86800018e+02, 2.37600006e+02, 2.86800018e+02,
+       3.19200012e+02, 2.86800018e+02, 3.31200012e+02, 2.86800018e+02,
+       336., 2.86800018e+02, 4.15200012e+02, 2.86800018e+02,
+       4.17600006e+02, 2.86800018e+02, 4.26000031e+02, 2.86800018e+02,
+       1.40400009e+02, 288., 144., 288., 1.58400009e+02, 288.,
+       1.77600006e+02, 288., 186., 288., 2.23200012e+02, 288.,
+       2.46000015e+02, 288., 3.38400024e+02, 288., 3.44400024e+02, 288.,
+       3.56400024e+02, 288., 3.68400024e+02, 288., 3.74400024e+02, 288.,
+       3.93600006e+02, 288., 4.00800018e+02, 288., 4.03200012e+02, 288.,
+       1.26000008e+02, 2.89200012e+02, 1.28400009e+02, 2.89200012e+02,
+       1.82400009e+02, 2.89200012e+02, 3.34800018e+02, 2.89200012e+02,
+       3.85200012e+02, 2.89200012e+02, 3.91200012e+02, 2.89200012e+02,
+       4.20000031e+02, 2.89200012e+02, 4.22400024e+02, 2.89200012e+02,
+       1.90800003e+02, 2.90400024e+02, 2.61600006e+02, 2.90400024e+02,
+       3.43200012e+02, 2.90400024e+02, 366., 2.90400024e+02,
+       1.42800003e+02, 2.91600006e+02, 1.60800003e+02, 2.91600006e+02,
+       180., 2.91600006e+02, 2.00400009e+02, 2.91600006e+02,
+       2.68800018e+02, 2.91600006e+02, 3.57600006e+02, 2.91600006e+02,
+       3.63600006e+02, 2.91600006e+02, 3.69600006e+02, 2.91600006e+02,
+       3.76800018e+02, 2.91600006e+02, 4.06800018e+02, 2.91600006e+02,
+       4.10400024e+02, 2.91600006e+02, 1.66800003e+02, 2.92800018e+02,
+       1.71600006e+02, 2.92800018e+02, 1.89600006e+02, 2.92800018e+02,
+       2.07600006e+02, 2.92800018e+02, 2.54400009e+02, 2.92800018e+02,
+       360., 2.92800018e+02, 366., 2.92800018e+02, 3.80400024e+02,
+       2.92800018e+02, 4.03200012e+02, 2.92800018e+02, 4.21200012e+02,
+       2.92800018e+02, 1.76400009e+02, 294., 1.98000015e+02, 294.,
+       2.13600006e+02, 294., 2.60400024e+02, 294., 2.85600006e+02, 294.,
+       3.68400024e+02, 294., 3.73200012e+02, 294., 3.97200012e+02, 294.,
+       1.27200005e+02, 2.95200012e+02, 1.29600006e+02, 2.95200012e+02,
+       1.72800003e+02, 2.95200012e+02, 2.18400009e+02, 2.95200012e+02,
+       2.68800018e+02, 2.95200012e+02, 294., 2.95200012e+02, 384.,
+       2.95200012e+02, 3.92400024e+02, 2.95200012e+02, 3.94800018e+02,
+       2.95200012e+02, 4.10400024e+02, 2.95200012e+02, 4.20000031e+02,
+       2.95200012e+02, 1.41600006e+02, 2.96400024e+02, 1.45200012e+02,
+       2.96400024e+02, 2.28000015e+02, 2.96400024e+02, 4.17600006e+02,
+       2.96400024e+02, 4.22400024e+02, 2.96400024e+02, 1.59600006e+02,
+       2.97600006e+02, 1.66800003e+02, 2.97600006e+02, 2.36400009e+02,
+       2.97600006e+02, 2.85600006e+02, 2.97600006e+02, 3.87600006e+02,
+       2.97600006e+02, 3.99600006e+02, 2.97600006e+02, 162.,
+       2.98800018e+02, 1.71600006e+02, 2.98800018e+02, 174.,
+       2.98800018e+02, 2.25600006e+02, 2.98800018e+02, 2.46000015e+02,
+       2.98800018e+02, 2.91600006e+02, 2.98800018e+02, 294.,
+       2.98800018e+02, 312., 2.98800018e+02, 3.96000031e+02,
+       2.98800018e+02, 4.08000031e+02, 2.98800018e+02, 4.17600006e+02,
+       2.98800018e+02, 1.76400009e+02, 300., 1.81200012e+02, 300.,
+       2.35200012e+02, 300., 2.61600006e+02, 300., 2.98800018e+02, 300.,
+       3.20400024e+02, 300., 4.15200012e+02, 300., 4.21200012e+02, 300.,
+       1.78800003e+02, 3.01200012e+02, 2.44800003e+02, 3.01200012e+02,
+       2.55600006e+02, 3.01200012e+02, 312., 3.01200012e+02,
+       4.11600006e+02, 3.01200012e+02, 144., 3.02400024e+02,
+       1.66800003e+02, 3.02400024e+02, 264., 3.02400024e+02,
+       3.32400024e+02, 3.02400024e+02, 4.20000031e+02, 3.02400024e+02,
+       1.72800003e+02, 3.03600006e+02, 2.74800018e+02, 3.03600006e+02,
+       3.40800018e+02, 3.03600006e+02, 1.83600006e+02, 3.04800018e+02,
+       2.62800018e+02, 3.04800018e+02, 2.83200012e+02, 3.04800018e+02,
+       3.32400024e+02, 3.04800018e+02, 162., 306., 1.75200012e+02, 306.,
+       2.72400024e+02, 306., 2.89200012e+02, 306., 2.91600006e+02, 306.,
+       3.40800018e+02, 306., 3.57600006e+02, 306., 3.61200012e+02, 306.,
+       1.29600006e+02, 3.07200012e+02, 144., 3.07200012e+02,
+       1.88400009e+02, 3.07200012e+02, 282., 3.07200012e+02,
+       2.97600006e+02, 3.07200012e+02, 366., 3.07200012e+02,
+       4.27200012e+02, 3.07200012e+02, 132., 3.08400024e+02,
+       1.47600006e+02, 3.08400024e+02, 180., 3.08400024e+02, 186.,
+       3.08400024e+02, 2.90400024e+02, 3.08400024e+02, 3.02400024e+02,
+       3.08400024e+02, 3.57600006e+02, 3.08400024e+02, 3.04800018e+02,
+       3.09600006e+02, 312., 3.09600006e+02, 3.62400024e+02,
+       3.09600006e+02, 366., 3.09600006e+02, 384., 3.09600006e+02,
+       4.23600006e+02, 3.09600006e+02, 1.33200012e+02, 3.10800018e+02,
+       162., 3.10800018e+02, 1.64400009e+02, 3.10800018e+02,
+       1.94400009e+02, 3.10800018e+02, 3.01200012e+02, 3.10800018e+02,
+       3.21600006e+02, 3.10800018e+02, 3.79200012e+02, 3.10800018e+02,
+       3.92400024e+02, 3.10800018e+02, 1.83600006e+02, 312., 192., 312.,
+       3.09600006e+02, 312., 3.26400024e+02, 312., 1.30800003e+02,
+       3.13200012e+02, 1.45200012e+02, 3.13200012e+02, 1.47600006e+02,
+       3.13200012e+02, 1.69200012e+02, 3.13200012e+02, 1.89600006e+02,
+       3.13200012e+02, 2.01600006e+02, 3.13200012e+02, 2.08800003e+02,
+       3.13200012e+02, 2.96400024e+02, 3.13200012e+02, 3.19200012e+02,
+       3.13200012e+02, 3.34800018e+02, 3.13200012e+02, 3.82800018e+02,
+       3.13200012e+02, 3.87600006e+02, 3.13200012e+02, 4.09200012e+02,
+       3.13200012e+02, 1.33200012e+02, 3.14400024e+02, 1.76400009e+02,
+       3.14400024e+02, 1.99200012e+02, 3.14400024e+02, 2.12400009e+02,
+       3.14400024e+02, 3.92400024e+02, 3.14400024e+02, 4.14000031e+02,
+       3.14400024e+02, 4.26000031e+02, 3.14400024e+02, 1.78800003e+02,
+       3.15600006e+02, 2.10000015e+02, 3.15600006e+02, 3.52800018e+02,
+       3.15600006e+02, 4.17600006e+02, 3.15600006e+02, 4.28400024e+02,
+       3.15600006e+02, 1.48800003e+02, 3.16800018e+02, 1.98000015e+02,
+       3.16800018e+02, 2.06400009e+02, 3.16800018e+02, 2.12400009e+02,
+       3.16800018e+02, 2.20800003e+02, 3.16800018e+02, 3.38400024e+02,
+       3.16800018e+02, 360., 3.16800018e+02, 4.08000031e+02,
+       3.16800018e+02, 1.64400009e+02, 318., 2.24400009e+02, 318.,
+       2.28000015e+02, 318., 3.08400024e+02, 318., 3.15600006e+02, 318.,
+       3.46800018e+02, 318., 366., 318., 4.14000031e+02, 318.,
+       4.17600006e+02, 318., 1.72800003e+02, 3.19200012e+02,
+       1.81200012e+02, 3.19200012e+02, 2.02800003e+02, 3.19200012e+02,
+       2.14800003e+02, 3.19200012e+02, 3.56400024e+02, 3.19200012e+02,
+       3.69600006e+02, 3.19200012e+02, 3.75600006e+02, 3.19200012e+02,
+       3.81600006e+02, 3.19200012e+02, 1.89600006e+02, 3.20400024e+02,
+       2.20800003e+02, 3.20400024e+02, 2.32800003e+02, 3.20400024e+02,
+       294., 3.20400024e+02, 312., 3.20400024e+02, 3.20400024e+02,
+       3.20400024e+02, 2.04000015e+02, 3.21600006e+02, 2.36400009e+02,
+       3.21600006e+02, 2.89200012e+02, 3.21600006e+02, 3.08400024e+02,
+       3.21600006e+02, 3.15600006e+02, 3.21600006e+02, 3.80400024e+02,
+       3.21600006e+02, 4.14000031e+02, 3.21600006e+02, 4.17600006e+02,
+       3.21600006e+02, 150., 3.22800018e+02, 1.90800003e+02,
+       3.22800018e+02, 2.24400009e+02, 3.22800018e+02, 2.91600006e+02,
+       3.22800018e+02, 2.96400024e+02, 3.22800018e+02, 1.65600006e+02,
+       324., 1.84800003e+02, 324., 1.95600006e+02, 324., 2.14800003e+02,
+       324., 2.17200012e+02, 324., 2.80800018e+02, 324., 312., 324.,
+       378., 324., 3.80400024e+02, 324., 150., 3.25200012e+02,
+       1.71600006e+02, 3.25200012e+02, 2.32800003e+02, 3.25200012e+02,
+       3.02400024e+02, 3.25200012e+02, 3.08400024e+02, 3.25200012e+02,
+       3.74400024e+02, 3.25200012e+02, 4.15200012e+02, 3.25200012e+02,
+       1.33200012e+02, 3.26400024e+02, 1.36800003e+02, 3.26400024e+02,
+       192., 3.26400024e+02, 2.44800003e+02, 3.26400024e+02,
+       2.67600006e+02, 3.26400024e+02, 2.71200012e+02, 3.26400024e+02,
+       2.79600006e+02, 3.26400024e+02, 2.95200012e+02, 3.26400024e+02,
+       3.04800018e+02, 3.26400024e+02, 3.14400024e+02, 3.26400024e+02,
+       1.94400009e+02, 3.27600006e+02, 2.11200012e+02, 3.27600006e+02,
+       2.31600006e+02, 3.27600006e+02, 2.35200012e+02, 3.27600006e+02,
+       2.49600006e+02, 3.27600006e+02, 2.53200012e+02, 3.27600006e+02,
+       288., 3.27600006e+02, 3.16800018e+02, 3.27600006e+02, 336.,
+       3.27600006e+02, 3.80400024e+02, 3.27600006e+02, 1.34400009e+02,
+       3.28800018e+02, 1.65600006e+02, 3.28800018e+02, 168.,
+       3.28800018e+02, 1.77600006e+02, 3.28800018e+02, 1.83600006e+02,
+       3.28800018e+02, 1.89600006e+02, 3.28800018e+02, 2.05200012e+02,
+       3.28800018e+02, 2.07600006e+02, 3.28800018e+02, 2.19600006e+02,
+       3.28800018e+02, 2.80800018e+02, 3.28800018e+02, 3.01200012e+02,
+       3.28800018e+02, 306., 3.28800018e+02, 3.10800018e+02,
+       3.28800018e+02, 3.32400024e+02, 3.28800018e+02, 3.99600006e+02,
+       3.28800018e+02, 1.36800003e+02, 330., 1.72800003e+02, 330.,
+       2.12400009e+02, 330., 2.22000015e+02, 330., 2.35200012e+02, 330.,
+       2.55600006e+02, 330., 324., 330., 3.40800018e+02, 330.,
+       1.41600006e+02, 3.31200012e+02, 1.69200012e+02, 3.31200012e+02,
+       2.02800003e+02, 3.31200012e+02, 2.31600006e+02, 3.31200012e+02,
+       2.42400009e+02, 3.31200012e+02, 2.50800003e+02, 3.31200012e+02,
+       258., 3.31200012e+02, 2.60400024e+02, 3.31200012e+02, 288.,
+       3.31200012e+02, 2.96400024e+02, 3.31200012e+02, 300.,
+       3.31200012e+02, 3.16800018e+02, 3.31200012e+02, 3.97200012e+02,
+       3.31200012e+02, 138., 3.32400024e+02, 1.78800003e+02,
+       3.32400024e+02, 2.07600006e+02, 3.32400024e+02, 2.17200012e+02,
+       3.32400024e+02, 2.29200012e+02, 3.32400024e+02, 2.37600006e+02,
+       3.32400024e+02, 2.44800003e+02, 3.32400024e+02, 2.55600006e+02,
+       3.32400024e+02, 270., 3.32400024e+02, 2.73600006e+02,
+       3.32400024e+02, 2.90400024e+02, 3.32400024e+02, 3.20400024e+02,
+       3.32400024e+02, 1.41600006e+02, 3.33600006e+02, 1.83600006e+02,
+       3.33600006e+02, 1.94400009e+02, 3.33600006e+02, 2.26800003e+02,
+       3.33600006e+02, 258., 3.33600006e+02, 2.61600006e+02,
+       3.33600006e+02, 330., 3.33600006e+02, 156., 3.34800018e+02,
+       2.02800003e+02, 3.34800018e+02, 2.11200012e+02, 3.34800018e+02,
+       2.19600006e+02, 3.34800018e+02, 2.36400009e+02, 3.34800018e+02,
+       2.38800003e+02, 3.34800018e+02, 2.65200012e+02, 3.34800018e+02,
+       2.92800018e+02, 3.34800018e+02, 300., 3.34800018e+02,
+       3.08400024e+02, 3.34800018e+02, 3.20400024e+02, 3.34800018e+02,
+       3.50400024e+02, 3.34800018e+02, 4.15200012e+02, 3.34800018e+02,
+       1.63200012e+02, 336., 1.96800003e+02, 336., 2.43600006e+02, 336.,
+       2.48400009e+02, 336., 2.56800018e+02, 336., 2.80800018e+02, 336.,
+       3.04800018e+02, 336., 3.33600006e+02, 336., 3.74400024e+02, 336.,
+       378., 336., 3.98400024e+02, 336., 4.00800018e+02, 336.,
+       4.18800018e+02, 336., 2.30400009e+02, 3.37200012e+02,
+       2.68800018e+02, 3.37200012e+02, 2.96400024e+02, 3.37200012e+02,
+       2.98800018e+02, 3.37200012e+02, 3.27600006e+02, 3.37200012e+02,
+       3.55200012e+02, 3.37200012e+02, 2.73600006e+02, 3.38400024e+02,
+       2.80800018e+02, 3.38400024e+02, 2.89200012e+02, 3.38400024e+02,
+       3.45600006e+02, 3.38400024e+02, 2.61600006e+02, 3.39600006e+02,
+       2.95200012e+02, 3.39600006e+02, 2.98800018e+02, 3.39600006e+02,
+       3.09600006e+02, 3.39600006e+02, 3.28800018e+02, 3.39600006e+02,
+       336., 3.39600006e+02, 3.98400024e+02, 3.39600006e+02,
+       4.00800018e+02, 3.39600006e+02, 186., 3.40800018e+02,
+       2.14800003e+02, 3.40800018e+02, 2.23200012e+02, 3.40800018e+02,
+       2.54400009e+02, 3.40800018e+02, 258., 3.40800018e+02,
+       2.71200012e+02, 3.40800018e+02, 2.77200012e+02, 3.40800018e+02,
+       3.21600006e+02, 3.40800018e+02, 3.39600006e+02, 3.40800018e+02,
+       2.28000015e+02, 342., 2.36400009e+02, 342., 2.80800018e+02, 342.,
+       3.27600006e+02, 342., 4.15200012e+02, 342., 4.18800018e+02, 342.,
+       2.00400009e+02, 3.43200012e+02, 2.44800003e+02, 3.43200012e+02,
+       270., 3.43200012e+02, 2.83200012e+02, 3.43200012e+02,
+       3.22800018e+02, 3.43200012e+02, 2.07600006e+02, 3.44400024e+02,
+       2.98800018e+02, 3.44400024e+02, 3.27600006e+02, 3.44400024e+02,
+       2.50800003e+02, 3.45600006e+02, 2.80800018e+02, 3.45600006e+02,
+       2.89200012e+02, 3.45600006e+02, 2.92800018e+02, 3.45600006e+02,
+       3.14400024e+02, 3.45600006e+02, 4.16400024e+02, 3.45600006e+02,
+       2.14800003e+02, 3.46800018e+02, 2.19600006e+02, 3.46800018e+02,
+       2.60400024e+02, 3.46800018e+02, 2.62800018e+02, 3.46800018e+02,
+       3.27600006e+02, 3.46800018e+02, 2.26800003e+02, 348.,
+       2.71200012e+02, 348., 300., 348., 3.04800018e+02, 348.,
+       3.15600006e+02, 348., 3.39600006e+02, 348., 3.46800018e+02, 348.,
+       3.64800018e+02, 348., 2.84400024e+02, 3.49200012e+02,
+       3.70800018e+02, 3.49200012e+02, 2.43600006e+02, 3.50400024e+02,
+       2.78400024e+02, 3.50400024e+02, 294., 3.50400024e+02,
+       3.32400024e+02, 3.50400024e+02, 2.86800018e+02, 3.51600006e+02,
+       3.56400024e+02, 3.51600006e+02, 3.64800018e+02, 3.51600006e+02,
+       3.69600006e+02, 3.51600006e+02, 3.79200012e+02, 3.51600006e+02,
+       4.16400024e+02, 3.51600006e+02, 2.50800003e+02, 3.52800018e+02,
+       2.92800018e+02, 3.52800018e+02, 2.95200012e+02, 3.52800018e+02,
+       3.50400024e+02, 3.52800018e+02, 2.54400009e+02, 354.,
+       3.01200012e+02, 354., 3.14400024e+02, 354., 3.34800018e+02, 354.,
+       3.45600006e+02, 354., 3.79200012e+02, 354., 2.67600006e+02,
+       3.55200012e+02, 3.07200012e+02, 3.55200012e+02, 3.21600006e+02,
+       3.55200012e+02, 3.82800018e+02, 3.55200012e+02, 4.15200012e+02,
+       3.55200012e+02, 4.18800018e+02, 3.55200012e+02, 276.,
+       3.56400024e+02, 3.15600006e+02, 3.56400024e+02, 3.31200012e+02,
+       3.56400024e+02, 3.51600006e+02, 3.56400024e+02, 3.99600006e+02,
+       3.56400024e+02, 3.40800018e+02, 3.57600006e+02, 360.,
+       3.57600006e+02, 3.73200012e+02, 3.57600006e+02, 2.90400024e+02,
+       3.58800018e+02, 3.49200012e+02, 3.58800018e+02, 3.67200012e+02,
+       3.58800018e+02, 2.98800018e+02, 360., 3.37200012e+02, 360., 342.,
+       360., 3.80400024e+02, 360., 3.82800018e+02, 360., 348.,
+       3.61200012e+02, 360., 3.61200012e+02, 4.16400024e+02,
+       3.61200012e+02, 4.20000031e+02, 3.61200012e+02, 3.13200012e+02,
+       3.62400024e+02, 3.56400024e+02, 3.62400024e+02, 3.70800018e+02,
+       3.62400024e+02, 4.00800018e+02, 3.62400024e+02, 3.21600006e+02,
+       3.63600006e+02, 3.62400024e+02, 3.63600006e+02, 3.82800018e+02,
+       3.63600006e+02, 3.68400024e+02, 3.64800018e+02, 3.80400024e+02,
+       3.64800018e+02, 4.17600006e+02, 3.64800018e+02, 336., 366., 378.,
+       366., 4.02000031e+02, 366., 3.81600006e+02, 3.67200012e+02,
+       3.58800018e+02, 3.70800018e+02, 3.62400024e+02, 3.70800018e+02,
+       3.67200012e+02, 3.70800018e+02, 4.17600006e+02, 3.70800018e+02,
+       3.70800018e+02, 372., 3.62400024e+02, 3.73200012e+02,
+       3.70800018e+02, 3.74400024e+02, 3.87600006e+02, 3.74400024e+02,
+       3.92400024e+02, 3.74400024e+02, 4.16400024e+02, 3.74400024e+02,
+       4.20000031e+02, 3.74400024e+02, 3.96000031e+02, 3.75600006e+02,
+       3.87600006e+02, 3.76800018e+02, 4.11600006e+02, 3.76800018e+02,
+       3.96000031e+02, 378., 4.09200012e+02, 378., 4.20000031e+02, 378.,
+       4.20000031e+02, 3.80400024e+02, 4.27200012e+02, 384.,
+       4.29600006e+02, 3.85200012e+02, 2.05920013e+02, 1.31040009e+02,
+       2.13120010e+02, 1.36800003e+02, 2.08800003e+02, 1.39680008e+02,
+       2.28960007e+02, 1.39680008e+02, 2.46240005e+02, 1.41120010e+02,
+       2.53440002e+02, 1.41120010e+02, 2.07360016e+02, 1.42560013e+02,
+       2.11680008e+02, 1.42560013e+02, 2.27520004e+02, 1.42560013e+02,
+       2.24640015e+02, 144., 2.11680008e+02, 1.45440002e+02,
+       2.37600006e+02, 1.45440002e+02, 2.05920013e+02, 1.46880005e+02,
+       2.66400024e+02, 1.46880005e+02, 2.30400009e+02, 1.48320007e+02,
+       2.44800003e+02, 1.48320007e+02, 2.57760010e+02, 1.48320007e+02,
+       2.39040009e+02, 1.49760010e+02, 2.49120010e+02, 1.49760010e+02,
+       2.66400024e+02, 1.49760010e+02, 2.39040009e+02, 1.52639999e+02,
+       2.49120010e+02, 1.52639999e+02, 2.62080017e+02, 1.52639999e+02,
+       2.89440002e+02, 1.52639999e+02, 2.96640015e+02, 1.52639999e+02,
+       2.34720016e+02, 1.54080002e+02, 3.03840027e+02, 1.54080002e+02,
+       3.11040009e+02, 1.54080002e+02, 1.97280014e+02, 1.55520004e+02,
+       2.18880005e+02, 1.55520004e+02, 2.30400009e+02, 1.55520004e+02,
+       2.39040009e+02, 1.55520004e+02, 2.49120010e+02, 1.55520004e+02,
+       2.16000015e+02, 1.56960007e+02, 2.26080002e+02, 1.56960007e+02,
+       3.31200012e+02, 1.56960007e+02, 3.21120026e+02, 1.58400009e+02,
+       3.39840027e+02, 1.58400009e+02, 3.54240021e+02, 1.59840012e+02,
+       2.00160004e+02, 1.61279999e+02, 2.57760010e+02, 1.61279999e+02,
+       3.48480011e+02, 1.61279999e+02, 1.90080002e+02, 1.62720001e+02,
+       2.64960022e+02, 1.62720001e+02, 360., 1.62720001e+02,
+       3.68640015e+02, 1.62720001e+02, 3.81600006e+02, 1.62720001e+02,
+       4.26240021e+02, 1.62720001e+02, 4.29120026e+02, 1.62720001e+02,
+       1.92960007e+02, 1.64160004e+02, 2.50560013e+02, 1.64160004e+02,
+       2.82240021e+02, 1.64160004e+02, 3.85920013e+02, 1.64160004e+02,
+       4.11840027e+02, 1.64160004e+02, 4.16160004e+02, 1.64160004e+02,
+       4.19040009e+02, 1.64160004e+02, 4.37760010e+02, 1.64160004e+02,
+       1.90080002e+02, 1.65600006e+02, 2.05920013e+02, 1.65600006e+02,
+       3.78720001e+02, 1.65600006e+02, 3.94560028e+02, 1.65600006e+02,
+       3.06720001e+02, 1.67040009e+02, 4.08960022e+02, 1.67040009e+02,
+       4.55040009e+02, 1.67040009e+02, 1.88640015e+02, 1.68480011e+02,
+       2.10240005e+02, 1.68480011e+02, 3.15360016e+02, 1.68480011e+02,
+       1.97280014e+02, 1.69920013e+02, 3.32640015e+02, 1.69920013e+02,
+       4.30560028e+02, 1.69920013e+02, 4.50720032e+02, 1.69920013e+02,
+       4.72320007e+02, 1.69920013e+02, 2.41920013e+02, 1.71360001e+02,
+       3.39840027e+02, 1.71360001e+02, 4.07520020e+02, 1.71360001e+02,
+       4.23360016e+02, 1.71360001e+02, 4.36320007e+02, 1.71360001e+02,
+       4.56480011e+02, 1.71360001e+02, 4.65120026e+02, 1.71360001e+02,
+       1.87200012e+02, 1.72800003e+02, 3.49920013e+02, 1.72800003e+02,
+       4.73760010e+02, 1.72800003e+02, 2.39040009e+02, 1.74240005e+02,
+       3.02400024e+02, 1.74240005e+02, 3.67200012e+02, 1.74240005e+02,
+       4.19040009e+02, 1.74240005e+02, 4.23360016e+02, 1.74240005e+02,
+       4.40640015e+02, 1.74240005e+02, 4.52160004e+02, 1.74240005e+02,
+       4.69440033e+02, 1.74240005e+02, 2.23200012e+02, 1.75680008e+02,
+       4.72320007e+02, 1.75680008e+02, 2.30400009e+02, 1.77120010e+02,
+       2.37600006e+02, 1.77120010e+02, 4.32000031e+02, 1.77120010e+02,
+       4.36320007e+02, 1.77120010e+02, 3.35520020e+02, 1.78560013e+02,
+       3.94560028e+02, 1.78560013e+02, 180., 180., 1.85760010e+02, 180.,
+       2.33280014e+02, 180., 3.44160004e+02, 180., 4.26240021e+02, 180.,
+       4.68000031e+02, 180., 2.18880005e+02, 1.81440002e+02,
+       2.37600006e+02, 1.81440002e+02, 2.67839996e+02, 1.81440002e+02,
+       3.77280029e+02, 1.81440002e+02, 3.84480011e+02, 1.81440002e+02,
+       3.90240021e+02, 1.81440002e+02, 2.16000015e+02, 1.82880005e+02,
+       2.82240021e+02, 1.82880005e+02, 3.05279999e+02, 1.82880005e+02,
+       3.35520020e+02, 1.82880005e+02, 4.00320007e+02, 1.82880005e+02,
+       4.42080017e+02, 1.82880005e+02, 2.26080002e+02, 1.84320007e+02,
+       3.02400024e+02, 1.84320007e+02, 3.25440002e+02, 1.84320007e+02,
+       3.74400024e+02, 1.84320007e+02, 4.13280029e+02, 1.84320007e+02,
+       4.37760010e+02, 1.84320007e+02, 4.46400024e+02, 1.84320007e+02,
+       4.62240021e+02, 1.84320007e+02, 4.70880005e+02, 1.84320007e+02,
+       2.66400024e+02, 1.85760010e+02, 2.93760010e+02, 1.85760010e+02,
+       2.98080017e+02, 1.85760010e+02, 3.29760010e+02, 1.85760010e+02,
+       3.34080017e+02, 1.85760010e+02, 3.77280029e+02, 1.85760010e+02,
+       3.90240021e+02, 1.85760010e+02, 4.56480011e+02, 1.85760010e+02,
+       4.68000031e+02, 1.85760010e+02, 2.54880005e+02, 1.87200012e+02,
+       3.44160004e+02, 1.87200012e+02, 3.98880005e+02, 1.87200012e+02,
+       1.95840012e+02, 1.88640015e+02, 2.37600006e+02, 1.88640015e+02,
+       3.16800018e+02, 1.88640015e+02, 3.70080017e+02, 1.88640015e+02,
+       1.72800003e+02, 1.90080002e+02, 2.21760010e+02, 1.90080002e+02,
+       2.92320007e+02, 1.90080002e+02, 3.12480011e+02, 1.90080002e+02,
+       3.47040009e+02, 1.90080002e+02, 4.63680023e+02, 1.90080002e+02,
+       4.66560028e+02, 1.90080002e+02, 1.87200012e+02, 1.91520004e+02,
+       2.73600006e+02, 1.91520004e+02, 2.77920013e+02, 1.91520004e+02,
+       2.96640015e+02, 1.91520004e+02, 3.62880005e+02, 1.91520004e+02,
+       2.08800003e+02, 1.92960007e+02, 2.13120010e+02, 1.92960007e+02,
+       2.39040009e+02, 1.92960007e+02, 2.82240021e+02, 1.92960007e+02,
+       3.29760010e+02, 1.92960007e+02, 3.41279999e+02, 1.92960007e+02,
+       3.72960022e+02, 1.92960007e+02, 3.87360016e+02, 1.92960007e+02,
+       4.03200012e+02, 1.92960007e+02, 4.08960022e+02, 1.92960007e+02,
+       4.21920013e+02, 1.92960007e+02, 2.31840012e+02, 1.94400009e+02,
+       2.56320007e+02, 1.94400009e+02, 3.08160004e+02, 1.94400009e+02,
+       3.11040009e+02, 1.94400009e+02, 3.81600006e+02, 1.94400009e+02,
+       3.91680023e+02, 1.94400009e+02, 3.97440002e+02, 1.94400009e+02,
+       4.59360016e+02, 1.94400009e+02, 2.16000015e+02, 1.95840012e+02,
+       2.27520004e+02, 1.95840012e+02, 2.70720001e+02, 1.95840012e+02,
+       2.89440002e+02, 1.95840012e+02, 2.99520020e+02, 1.95840012e+02,
+       3.52800018e+02, 1.95840012e+02, 4.30560028e+02, 1.95840012e+02,
+       4.36320007e+02, 1.95840012e+02, 2.08800003e+02, 1.97280014e+02,
+       2.30400009e+02, 1.97280014e+02, 2.46240005e+02, 1.97280014e+02,
+       2.60640015e+02, 1.97280014e+02, 3.03840027e+02, 1.97280014e+02,
+       4.10400024e+02, 1.97280014e+02, 4.46400024e+02, 1.97280014e+02,
+       1.64160004e+02, 1.98720001e+02, 2.39040009e+02, 1.98720001e+02,
+       2.52000015e+02, 1.98720001e+02, 2.66400024e+02, 1.98720001e+02,
+       2.73600006e+02, 1.98720001e+02, 3.06720001e+02, 1.98720001e+02,
+       3.12480011e+02, 1.98720001e+02, 3.44160004e+02, 1.98720001e+02,
+       3.52800018e+02, 1.98720001e+02, 3.68640015e+02, 1.98720001e+02,
+       3.81600006e+02, 1.98720001e+02, 3.88800018e+02, 1.98720001e+02,
+       3.97440002e+02, 1.98720001e+02, 4.06080017e+02, 1.98720001e+02,
+       4.39200012e+02, 1.98720001e+02, 4.53600006e+02, 1.98720001e+02,
+       1.75680008e+02, 2.00160004e+02, 1.97280014e+02, 2.00160004e+02,
+       2.33280014e+02, 2.00160004e+02, 3.18240021e+02, 2.00160004e+02,
+       3.31200012e+02, 2.00160004e+02, 4.00320007e+02, 2.00160004e+02,
+       4.13280029e+02, 2.00160004e+02, 4.19040009e+02, 2.00160004e+02,
+       2.03040009e+02, 2.01600006e+02, 2.10240005e+02, 2.01600006e+02,
+       2.23200012e+02, 2.01600006e+02, 3.08160004e+02, 2.01600006e+02,
+       3.36960022e+02, 2.01600006e+02, 4.47840027e+02, 2.01600006e+02,
+       4.60800018e+02, 2.01600006e+02, 1.64160004e+02, 2.03040009e+02,
+       1.95840012e+02, 2.03040009e+02, 2.20320007e+02, 2.03040009e+02,
+       3.11040009e+02, 2.03040009e+02, 3.25440002e+02, 2.03040009e+02,
+       3.71520020e+02, 2.03040009e+02, 3.74400024e+02, 2.03040009e+02,
+       3.81600006e+02, 2.03040009e+02, 3.90240021e+02, 2.03040009e+02,
+       4.14720032e+02, 2.03040009e+02, 4.50720032e+02, 2.03040009e+02,
+       1.69920013e+02, 2.04480011e+02, 2.03040009e+02, 2.04480011e+02,
+       2.34720016e+02, 2.04480011e+02, 2.43360016e+02, 2.04480011e+02,
+       2.49120010e+02, 2.04480011e+02, 2.53440002e+02, 2.04480011e+02,
+       2.93760010e+02, 2.04480011e+02, 4.04640015e+02, 2.04480011e+02,
+       1.65600006e+02, 2.05920013e+02, 2.14560013e+02, 2.05920013e+02,
+       2.66400024e+02, 2.05920013e+02, 2.70720001e+02, 2.05920013e+02,
+       2.86559998e+02, 2.05920013e+02, 3.22559998e+02, 2.05920013e+02,
+       3.55680023e+02, 2.05920013e+02, 3.71520020e+02, 2.05920013e+02,
+       3.85920013e+02, 2.05920013e+02, 4.59360016e+02, 2.05920013e+02,
+       1.61279999e+02, 2.07360016e+02, 2.24640015e+02, 2.07360016e+02,
+       2.33280014e+02, 2.07360016e+02, 2.62080017e+02, 2.07360016e+02,
+       3.29760010e+02, 2.07360016e+02, 3.34080017e+02, 2.07360016e+02,
+       3.61440002e+02, 2.07360016e+02, 3.77280029e+02, 2.07360016e+02,
+       2.10240005e+02, 2.08800003e+02, 2.79360016e+02, 2.08800003e+02,
+       2.93760010e+02, 2.08800003e+02, 3.05279999e+02, 2.08800003e+02,
+       3.70080017e+02, 2.08800003e+02, 3.21120026e+02, 2.10240005e+02,
+       3.26880005e+02, 2.10240005e+02, 3.58560028e+02, 2.10240005e+02,
+       4.06080017e+02, 2.10240005e+02, 2.82240021e+02, 2.11680008e+02,
+       3.45600006e+02, 2.11680008e+02, 3.62880005e+02, 2.11680008e+02,
+       3.65760010e+02, 2.11680008e+02, 3.77280029e+02, 2.11680008e+02,
+       2.62080017e+02, 2.13120010e+02, 4.06080017e+02, 2.13120010e+02,
+       1.54080002e+02, 2.14560013e+02, 2.10240005e+02, 2.14560013e+02,
+       2.24640015e+02, 2.14560013e+02, 2.49120010e+02, 2.14560013e+02,
+       2.90880005e+02, 2.14560013e+02, 3.09600006e+02, 2.14560013e+02,
+       3.31200012e+02, 2.14560013e+02, 3.83040009e+02, 2.14560013e+02,
+       4.50720032e+02, 2.14560013e+02, 4.55040009e+02, 2.14560013e+02,
+       1.84320007e+02, 2.16000015e+02, 2.64960022e+02, 2.16000015e+02,
+       3.70080017e+02, 2.16000015e+02, 4.11840027e+02, 2.16000015e+02,
+       4.47840027e+02, 2.16000015e+02, 1.67040009e+02, 2.17440002e+02,
+       1.97280014e+02, 2.17440002e+02, 2.05920013e+02, 2.17440002e+02,
+       2.10240005e+02, 2.17440002e+02, 3.64320007e+02, 2.17440002e+02,
+       3.81600006e+02, 2.17440002e+02, 1.74240005e+02, 2.18880005e+02,
+       3.97440002e+02, 2.18880005e+02, 4.53600006e+02, 2.18880005e+02,
+       1.59840012e+02, 2.20320007e+02, 1.67040009e+02, 2.20320007e+02,
+       2.04480011e+02, 2.20320007e+02, 2.70720001e+02, 2.20320007e+02,
+       2.82240021e+02, 2.20320007e+02, 2.86559998e+02, 2.20320007e+02,
+       2.95200012e+02, 2.20320007e+02, 3.08160004e+02, 2.20320007e+02,
+       4.04640015e+02, 2.20320007e+02, 1.94400009e+02, 2.21760010e+02,
+       2.00160004e+02, 2.21760010e+02, 2.90880005e+02, 2.21760010e+02,
+       3.22559998e+02, 2.21760010e+02, 3.31200012e+02, 2.21760010e+02,
+       3.65760010e+02, 2.21760010e+02, 4.27680023e+02, 2.21760010e+02,
+       4.37760010e+02, 2.21760010e+02, 4.55040009e+02, 2.21760010e+02,
+       1.64160004e+02, 2.23200012e+02, 1.81440002e+02, 2.23200012e+02,
+       2.03040009e+02, 2.23200012e+02, 2.54880005e+02, 2.23200012e+02,
+       2.67839996e+02, 2.23200012e+02, 3.90240021e+02, 2.23200012e+02,
+       4.07520020e+02, 2.23200012e+02, 3.81600006e+02, 2.24640015e+02,
+       1.52639999e+02, 2.26080002e+02, 1.92960007e+02, 2.26080002e+02,
+       2.08800003e+02, 2.26080002e+02, 2.72160004e+02, 2.26080002e+02,
+       3.72960022e+02, 2.26080002e+02, 3.98880005e+02, 2.26080002e+02,
+       1.75680008e+02, 2.27520004e+02, 2.80800018e+02, 2.27520004e+02,
+       2.92320007e+02, 2.27520004e+02, 3.91680023e+02, 2.27520004e+02,
+       4.33440002e+02, 2.27520004e+02, 4.49280029e+02, 2.27520004e+02,
+       2.44800003e+02, 2.28960007e+02, 1.48320007e+02, 2.30400009e+02,
+       1.59840012e+02, 2.30400009e+02, 2.03040009e+02, 2.30400009e+02,
+       2.20320007e+02, 2.30400009e+02, 2.67839996e+02, 2.30400009e+02,
+       1.45440002e+02, 2.31840012e+02, 1.77120010e+02, 2.31840012e+02,
+       4.01760010e+02, 2.31840012e+02, 180., 2.33280014e+02,
+       1.95840012e+02, 2.33280014e+02, 2.10240005e+02, 2.33280014e+02,
+       2.82240021e+02, 2.33280014e+02, 2.96640015e+02, 2.33280014e+02,
+       4.43520020e+02, 2.33280014e+02, 4.47840027e+02, 2.33280014e+02,
+       1.52639999e+02, 2.34720016e+02, 1.56960007e+02, 2.34720016e+02,
+       1.62720001e+02, 2.34720016e+02, 1.92960007e+02, 2.34720016e+02,
+       2.72160004e+02, 2.34720016e+02, 2.75040009e+02, 2.34720016e+02,
+       2.86559998e+02, 2.34720016e+02, 3.08160004e+02, 2.34720016e+02,
+       3.97440002e+02, 2.34720016e+02, 1.67040009e+02, 2.36160004e+02,
+       2.20320007e+02, 2.36160004e+02, 2.37600006e+02, 2.36160004e+02,
+       4.36320007e+02, 2.36160004e+02, 1.36800003e+02, 2.37600006e+02,
+       1.77120010e+02, 2.37600006e+02, 2.08800003e+02, 2.37600006e+02,
+       3.02400024e+02, 2.37600006e+02, 3.34080017e+02, 2.37600006e+02,
+       3.91680023e+02, 2.37600006e+02, 4.01760010e+02, 2.37600006e+02,
+       4.47840027e+02, 2.37600006e+02, 144., 2.39040009e+02,
+       2.14560013e+02, 2.39040009e+02, 2.26080002e+02, 2.39040009e+02,
+       3.65760010e+02, 2.39040009e+02, 3.68640015e+02, 2.39040009e+02,
+       3.98880005e+02, 2.39040009e+02, 1.39680008e+02, 2.40480011e+02,
+       1.81440002e+02, 2.40480011e+02, 1.95840012e+02, 2.40480011e+02,
+       2.05920013e+02, 2.40480011e+02, 2.60640015e+02, 2.40480011e+02,
+       2.66400024e+02, 2.40480011e+02, 3.51360016e+02, 2.40480011e+02,
+       1.33919998e+02, 2.41920013e+02, 1.67040009e+02, 2.41920013e+02,
+       1.74240005e+02, 2.41920013e+02, 2.33280014e+02, 2.41920013e+02,
+       3.74400024e+02, 2.41920013e+02, 4.36320007e+02, 2.41920013e+02,
+       4.43520020e+02, 2.41920013e+02, 1.71360001e+02, 2.43360016e+02,
+       1.85760010e+02, 2.43360016e+02, 2.17440002e+02, 2.43360016e+02,
+       2.47680008e+02, 2.43360016e+02, 2.67839996e+02, 2.43360016e+02,
+       3.91680023e+02, 2.43360016e+02, 1.33919998e+02, 2.44800003e+02,
+       1.36800003e+02, 2.44800003e+02, 1.48320007e+02, 2.44800003e+02,
+       2.27520004e+02, 2.44800003e+02, 2.33280014e+02, 2.44800003e+02,
+       3.02400024e+02, 2.44800003e+02, 3.05279999e+02, 2.44800003e+02,
+       3.54240021e+02, 2.44800003e+02, 3.62880005e+02, 2.44800003e+02,
+       1.41120010e+02, 2.46240005e+02, 1.62720001e+02, 2.46240005e+02,
+       2.36160004e+02, 2.46240005e+02, 3.09600006e+02, 2.46240005e+02,
+       3.35520020e+02, 2.46240005e+02, 3.47040009e+02, 2.46240005e+02,
+       3.51360016e+02, 2.46240005e+02, 3.70080017e+02, 2.46240005e+02,
+       3.88800018e+02, 2.46240005e+02, 1.75680008e+02, 2.47680008e+02,
+       2.90880005e+02, 2.47680008e+02, 3.15360016e+02, 2.47680008e+02,
+       3.39840027e+02, 2.47680008e+02, 3.78720001e+02, 2.47680008e+02,
+       3.94560028e+02, 2.47680008e+02, 1.31040009e+02, 2.49120010e+02,
+       1.51200012e+02, 2.49120010e+02, 1.69920013e+02, 2.49120010e+02,
+       1.78560013e+02, 2.49120010e+02, 2.67839996e+02, 2.49120010e+02,
+       3.44160004e+02, 2.49120010e+02, 3.62880005e+02, 2.49120010e+02,
+       3.75840027e+02, 2.49120010e+02, 3.84480011e+02, 2.49120010e+02,
+       1.39680008e+02, 2.50560013e+02, 1.48320007e+02, 2.50560013e+02,
+       1.65600006e+02, 2.50560013e+02, 1.98720001e+02, 2.50560013e+02,
+       2.92320007e+02, 2.50560013e+02, 3.35520020e+02, 2.50560013e+02,
+       3.51360016e+02, 2.50560013e+02, 3.70080017e+02, 2.50560013e+02,
+       3.78720001e+02, 2.50560013e+02, 1.26720001e+02, 2.52000015e+02,
+       1.74240005e+02, 2.52000015e+02, 3.03840027e+02, 2.52000015e+02,
+       3.21120026e+02, 2.52000015e+02, 3.58560028e+02, 2.52000015e+02,
+       4.42080017e+02, 2.52000015e+02, 1.31040009e+02, 2.53440002e+02,
+       1.51200012e+02, 2.53440002e+02, 2.89440002e+02, 2.53440002e+02,
+       3.18240021e+02, 2.53440002e+02, 3.28320007e+02, 2.53440002e+02,
+       3.35520020e+02, 2.53440002e+02, 3.71520020e+02, 2.53440002e+02,
+       4.14720032e+02, 2.53440002e+02, 4.27680023e+02, 2.53440002e+02,
+       1.95840012e+02, 2.54880005e+02, 2.99520020e+02, 2.54880005e+02,
+       1.23840004e+02, 2.56320007e+02, 1.45440002e+02, 2.56320007e+02,
+       1.48320007e+02, 2.56320007e+02, 1.64160004e+02, 2.56320007e+02,
+       2.90880005e+02, 2.56320007e+02, 3.09600006e+02, 2.56320007e+02,
+       3.13920013e+02, 2.56320007e+02, 3.32640015e+02, 2.56320007e+02,
+       1.31040009e+02, 2.57760010e+02, 1.41120010e+02, 2.57760010e+02,
+       1.51200012e+02, 2.57760010e+02, 1.77120010e+02, 2.57760010e+02,
+       1.88640015e+02, 2.57760010e+02, 1.94400009e+02, 2.57760010e+02,
+       2.27520004e+02, 2.57760010e+02, 3.18240021e+02, 2.57760010e+02,
+       324., 2.57760010e+02, 3.52800018e+02, 2.57760010e+02,
+       3.64320007e+02, 2.57760010e+02, 3.78720001e+02, 2.57760010e+02,
+       4.13280029e+02, 2.57760010e+02, 4.19040009e+02, 2.57760010e+02,
+       1.65600006e+02, 2.59200012e+02, 1.84320007e+02, 2.59200012e+02,
+       2.23200012e+02, 2.59200012e+02, 3.28320007e+02, 2.59200012e+02,
+       1.52639999e+02, 2.60640015e+02, 2.36160004e+02, 2.60640015e+02,
+       2.40480011e+02, 2.60640015e+02, 2.44800003e+02, 2.60640015e+02,
+       3.61440002e+02, 2.60640015e+02, 4.19040009e+02, 2.60640015e+02,
+       4.34880005e+02, 2.60640015e+02, 1.78560013e+02, 2.62080017e+02,
+       2.52000015e+02, 2.62080017e+02, 2.60640015e+02, 2.62080017e+02,
+       3.48480011e+02, 2.62080017e+02, 4.65120026e+02, 2.62080017e+02,
+       1.69920013e+02, 2.63520020e+02, 1.82880005e+02, 2.63520020e+02,
+       3.57120026e+02, 2.63520020e+02, 3.61440002e+02, 2.63520020e+02,
+       4.34880005e+02, 2.63520020e+02, 1.77120010e+02, 2.64960022e+02,
+       1.88640015e+02, 2.64960022e+02, 2.50560013e+02, 2.64960022e+02,
+       2.72160004e+02, 2.64960022e+02, 2.76480011e+02, 2.64960022e+02,
+       3.96000031e+02, 2.64960022e+02, 4.11840027e+02, 2.64960022e+02,
+       4.17600006e+02, 2.64960022e+02, 4.27680023e+02, 2.64960022e+02,
+       2.59200012e+02, 2.66400024e+02, 288., 2.66400024e+02,
+       1.22400002e+02, 2.67839996e+02, 2.00160004e+02, 2.67839996e+02,
+       2.17440002e+02, 2.67839996e+02, 2.63520020e+02, 2.67839996e+02,
+       2.70720001e+02, 2.67839996e+02, 2.75040009e+02, 2.67839996e+02,
+       2.82240021e+02, 2.67839996e+02, 2.96640015e+02, 2.67839996e+02,
+       3.97440002e+02, 2.67839996e+02, 4.16160004e+02, 2.67839996e+02,
+       4.34880005e+02, 2.67839996e+02, 1.29600006e+02, 2.69279999e+02,
+       2.99520020e+02, 2.69279999e+02, 3.08160004e+02, 2.69279999e+02,
+       3.83040009e+02, 2.69279999e+02, 3.93120026e+02, 2.69279999e+02,
+       2.16000015e+02, 2.70720001e+02, 2.86559998e+02, 2.70720001e+02,
+       3.71520020e+02, 2.70720001e+02, 3.88800018e+02, 2.70720001e+02,
+       4.01760010e+02, 2.70720001e+02, 4.07520020e+02, 2.70720001e+02,
+       4.27680023e+02, 2.70720001e+02, 4.33440002e+02, 2.70720001e+02,
+       1.22400002e+02, 2.72160004e+02, 1.25280006e+02, 2.72160004e+02,
+       1.29600006e+02, 2.72160004e+02, 144., 2.72160004e+02,
+       2.24640015e+02, 2.72160004e+02, 2.39040009e+02, 2.72160004e+02,
+       2.47680008e+02, 2.72160004e+02, 2.95200012e+02, 2.72160004e+02,
+       3.11040009e+02, 2.72160004e+02, 3.19680023e+02, 2.72160004e+02,
+       3.94560028e+02, 2.72160004e+02, 4.10400024e+02, 2.72160004e+02,
+       4.30560028e+02, 2.72160004e+02, 3.06720001e+02, 2.73600006e+02,
+       3.71520020e+02, 2.73600006e+02, 3.88800018e+02, 2.73600006e+02,
+       1.22400002e+02, 2.75040009e+02, 1.25280006e+02, 2.75040009e+02,
+       144., 2.75040009e+02, 1.67040009e+02, 2.75040009e+02,
+       2.46240005e+02, 2.75040009e+02, 2.63520020e+02, 2.75040009e+02,
+       3.09600006e+02, 2.75040009e+02, 3.22559998e+02, 2.75040009e+02,
+       3.58560028e+02, 2.75040009e+02, 3.74400024e+02, 2.75040009e+02,
+       4.04640015e+02, 2.75040009e+02, 4.17600006e+02, 2.75040009e+02,
+       1.52639999e+02, 2.76480011e+02, 1.75680008e+02, 2.76480011e+02,
+       3.83040009e+02, 2.76480011e+02, 3.88800018e+02, 2.76480011e+02,
+       4.21920013e+02, 2.76480011e+02, 1.67040009e+02, 2.77920013e+02,
+       2.62080017e+02, 2.77920013e+02, 3.58560028e+02, 2.77920013e+02,
+       3.94560028e+02, 2.77920013e+02, 1.75680008e+02, 2.79360016e+02,
+       1.91520004e+02, 2.79360016e+02, 2.70720001e+02, 2.79360016e+02,
+       3.52800018e+02, 2.79360016e+02, 1.98720001e+02, 2.80800018e+02,
+       3.64320007e+02, 2.80800018e+02, 3.78720001e+02, 2.80800018e+02,
+       3.96000031e+02, 2.80800018e+02, 4.29120026e+02, 2.80800018e+02,
+       1.90080002e+02, 2.82240021e+02, 3.12480011e+02, 2.82240021e+02,
+       4.23360016e+02, 2.82240021e+02, 1.98720001e+02, 2.83680023e+02,
+       2.23200012e+02, 2.83680023e+02, 3.52800018e+02, 2.83680023e+02,
+       3.58560028e+02, 2.83680023e+02, 3.80160004e+02, 2.83680023e+02,
+       3.83040009e+02, 2.83680023e+02, 4.01760010e+02, 2.83680023e+02,
+       4.06080017e+02, 2.83680023e+02, 1.41120010e+02, 2.85120026e+02,
+       1.61279999e+02, 2.85120026e+02, 2.14560013e+02, 2.85120026e+02,
+       3.11040009e+02, 2.85120026e+02, 3.61440002e+02, 2.85120026e+02,
+       3.87360016e+02, 2.85120026e+02, 1.69920013e+02, 2.86559998e+02,
+       2.18880005e+02, 2.86559998e+02, 2.37600006e+02, 2.86559998e+02,
+       3.19680023e+02, 2.86559998e+02, 3.44160004e+02, 2.86559998e+02,
+       3.83040009e+02, 2.86559998e+02, 4.03200012e+02, 2.86559998e+02,
+       4.17600006e+02, 2.86559998e+02, 4.27680023e+02, 2.86559998e+02,
+       1.25280006e+02, 288., 1.28160004e+02, 288., 144., 288.,
+       1.58400009e+02, 288., 2.23200012e+02, 288., 2.46240005e+02, 288.,
+       3.68640015e+02, 288., 4.00320007e+02, 288., 4.13280029e+02, 288.,
+       2.37600006e+02, 2.89440002e+02, 3.84480011e+02, 2.89440002e+02,
+       4.20480011e+02, 2.89440002e+02, 4.23360016e+02, 2.89440002e+02,
+       1.26720001e+02, 2.90880005e+02, 1.42560013e+02, 2.90880005e+02,
+       180., 2.90880005e+02, 2.46240005e+02, 2.90880005e+02,
+       2.69279999e+02, 2.90880005e+02, 3.70080017e+02, 2.90880005e+02,
+       1.67040009e+02, 2.92320007e+02, 1.69920013e+02, 2.92320007e+02,
+       1.88640015e+02, 2.92320007e+02, 2.07360016e+02, 2.92320007e+02,
+       2.54880005e+02, 2.92320007e+02, 360., 2.92320007e+02,
+       3.80160004e+02, 2.92320007e+02, 4.04640015e+02, 2.92320007e+02,
+       4.07520020e+02, 2.92320007e+02, 4.13280029e+02, 2.92320007e+02,
+       1.77120010e+02, 2.93760010e+02, 1.98720001e+02, 2.93760010e+02,
+       2.62080017e+02, 2.93760010e+02, 2.69279999e+02, 2.93760010e+02,
+       2.86559998e+02, 2.93760010e+02, 3.68640015e+02, 2.93760010e+02,
+       3.74400024e+02, 2.93760010e+02, 3.97440002e+02, 2.93760010e+02,
+       4.21920013e+02, 2.93760010e+02, 1.26720001e+02, 2.95200012e+02,
+       1.29600006e+02, 2.95200012e+02, 2.95200012e+02, 2.95200012e+02,
+       1.45440002e+02, 2.96640015e+02, 1.67040009e+02, 2.96640015e+02,
+       1.71360001e+02, 2.96640015e+02, 2.16000015e+02, 2.96640015e+02,
+       2.86559998e+02, 2.96640015e+02, 4.11840027e+02, 2.96640015e+02,
+       4.16160004e+02, 2.96640015e+02, 1.74240005e+02, 2.98080017e+02,
+       3.12480011e+02, 2.98080017e+02, 3.96000031e+02, 2.98080017e+02,
+       4.07520020e+02, 2.98080017e+02, 1.81440002e+02, 2.99520020e+02,
+       2.34720016e+02, 2.99520020e+02, 2.99520020e+02, 2.99520020e+02,
+       3.19680023e+02, 2.99520020e+02, 4.21920013e+02, 2.99520020e+02,
+       1.78560013e+02, 3.00960022e+02, 2.44800003e+02, 3.00960022e+02,
+       3.12480011e+02, 3.00960022e+02, 3.32640015e+02, 3.00960022e+02,
+       4.11840027e+02, 3.00960022e+02, 144., 3.02400024e+02,
+       3.19680023e+02, 3.02400024e+02, 3.41279999e+02, 3.02400024e+02,
+       1.67040009e+02, 3.03840027e+02, 1.84320007e+02, 3.03840027e+02,
+       3.32640015e+02, 3.03840027e+02, 1.61279999e+02, 3.05279999e+02,
+       1.75680008e+02, 3.05279999e+02, 2.72160004e+02, 3.05279999e+02,
+       3.41279999e+02, 3.05279999e+02, 1.29600006e+02, 3.06720001e+02,
+       1.72800003e+02, 3.06720001e+02, 180., 3.06720001e+02,
+       2.80800018e+02, 3.06720001e+02, 2.96640015e+02, 3.06720001e+02,
+       3.65760010e+02, 3.06720001e+02, 4.27680023e+02, 3.06720001e+02,
+       1.91520004e+02, 3.08160004e+02, 2.90880005e+02, 3.08160004e+02,
+       3.57120026e+02, 3.08160004e+02, 3.00960022e+02, 3.09600006e+02,
+       3.13920013e+02, 3.09600006e+02, 3.65760010e+02, 3.09600006e+02,
+       3.84480011e+02, 3.09600006e+02, 4.24800018e+02, 3.09600006e+02,
+       1.91520004e+02, 3.11040009e+02, 3.09600006e+02, 3.11040009e+02,
+       3.93120026e+02, 3.11040009e+02, 1.84320007e+02, 3.12480011e+02,
+       1.88640015e+02, 3.12480011e+02, 2.05920013e+02, 3.12480011e+02,
+       2.08800003e+02, 3.12480011e+02, 2.95200012e+02, 3.12480011e+02,
+       3.83040009e+02, 3.12480011e+02, 1.31040009e+02, 3.13920013e+02,
+       1.33919998e+02, 3.13920013e+02, 1.67040009e+02, 3.13920013e+02,
+       1.97280014e+02, 3.13920013e+02, 2.00160004e+02, 3.13920013e+02,
+       3.93120026e+02, 3.13920013e+02, 4.14720032e+02, 3.13920013e+02,
+       4.17600006e+02, 3.13920013e+02, 4.29120026e+02, 3.13920013e+02,
+       1.48320007e+02, 3.15360016e+02, 1.72800003e+02, 3.15360016e+02,
+       1.75680008e+02, 3.15360016e+02, 180., 3.15360016e+02,
+       2.04480011e+02, 3.15360016e+02, 2.10240005e+02, 3.15360016e+02,
+       3.38400024e+02, 3.15360016e+02, 3.52800018e+02, 3.15360016e+02,
+       2.13120010e+02, 3.16800018e+02, 2.20320007e+02, 3.16800018e+02,
+       2.24640015e+02, 3.16800018e+02, 2.95200012e+02, 3.16800018e+02,
+       3.47040009e+02, 3.16800018e+02, 4.08960022e+02, 3.16800018e+02,
+       4.13280029e+02, 3.16800018e+02, 4.29120026e+02, 3.16800018e+02,
+       1.72800003e+02, 3.18240021e+02, 2.03040009e+02, 3.18240021e+02,
+       2.92320007e+02, 3.18240021e+02, 4.17600006e+02, 3.18240021e+02,
+       1.90080002e+02, 3.19680023e+02, 2.20320007e+02, 3.19680023e+02,
+       2.28960007e+02, 3.19680023e+02, 3.13920013e+02, 3.19680023e+02,
+       3.21120026e+02, 3.19680023e+02, 3.75840027e+02, 3.19680023e+02,
+       2.10240005e+02, 3.21120026e+02, 288., 3.21120026e+02,
+       2.93760010e+02, 3.21120026e+02, 3.09600006e+02, 3.21120026e+02,
+       3.68640015e+02, 3.21120026e+02, 4.14720032e+02, 3.21120026e+02,
+       4.17600006e+02, 3.21120026e+02, 1.49760010e+02, 3.22559998e+02,
+       1.95840012e+02, 3.22559998e+02, 2.80800018e+02, 3.22559998e+02,
+       2.13120010e+02, 324., 3.03840027e+02, 324., 3.15360016e+02, 324.,
+       1.36800003e+02, 3.25440002e+02, 1.49760010e+02, 3.25440002e+02,
+       1.71360001e+02, 3.25440002e+02, 1.91520004e+02, 3.25440002e+02,
+       2.00160004e+02, 3.25440002e+02, 2.49120010e+02, 3.25440002e+02,
+       2.70720001e+02, 3.25440002e+02, 2.82240021e+02, 3.25440002e+02,
+       3.74400024e+02, 3.25440002e+02, 2.04480011e+02, 3.26880005e+02,
+       2.31840012e+02, 3.26880005e+02, 2.36160004e+02, 3.26880005e+02,
+       2.44800003e+02, 3.26880005e+02, 3.36960022e+02, 3.26880005e+02,
+       1.33919998e+02, 3.28320007e+02, 1.65600006e+02, 3.28320007e+02,
+       1.84320007e+02, 3.28320007e+02, 1.90080002e+02, 3.28320007e+02,
+       1.97280014e+02, 3.28320007e+02, 2.08800003e+02, 3.28320007e+02,
+       2.14560013e+02, 3.28320007e+02, 2.80800018e+02, 3.28320007e+02,
+       2.86559998e+02, 3.28320007e+02, 2.92320007e+02, 3.28320007e+02,
+       3.00960022e+02, 3.28320007e+02, 3.11040009e+02, 3.28320007e+02,
+       3.32640015e+02, 3.28320007e+02, 4.00320007e+02, 3.28320007e+02,
+       1.36800003e+02, 3.29760010e+02, 2.11680008e+02, 3.29760010e+02,
+       2.21760010e+02, 3.29760010e+02, 2.26080002e+02, 3.29760010e+02,
+       2.34720016e+02, 3.29760010e+02, 3.25440002e+02, 3.29760010e+02,
+       2.03040009e+02, 3.31200012e+02, 2.08800003e+02, 3.31200012e+02,
+       2.54880005e+02, 3.31200012e+02, 2.93760010e+02, 3.31200012e+02,
+       2.96640015e+02, 3.31200012e+02, 3.18240021e+02, 3.31200012e+02,
+       3.97440002e+02, 3.31200012e+02, 2.17440002e+02, 3.32640015e+02,
+       2.26080002e+02, 3.32640015e+02, 2.46240005e+02, 3.32640015e+02,
+       2.50560013e+02, 3.32640015e+02, 2.59200012e+02, 3.32640015e+02,
+       2.73600006e+02, 3.32640015e+02, 3.11040009e+02, 3.32640015e+02,
+       3.81600006e+02, 3.32640015e+02, 1.58400009e+02, 3.34080017e+02,
+       2.10240005e+02, 3.34080017e+02, 2.20320007e+02, 3.34080017e+02,
+       2.99520020e+02, 3.34080017e+02, 3.21120026e+02, 3.34080017e+02,
+       3.44160004e+02, 3.34080017e+02, 4.14720032e+02, 3.34080017e+02,
+       1.62720001e+02, 3.35520020e+02, 1.88640015e+02, 3.35520020e+02,
+       1.95840012e+02, 3.35520020e+02, 2.56320007e+02, 3.35520020e+02,
+       2.64960022e+02, 3.35520020e+02, 3.03840027e+02, 3.35520020e+02,
+       3.74400024e+02, 3.35520020e+02, 3.78720001e+02, 3.35520020e+02,
+       3.98880005e+02, 3.35520020e+02, 4.19040009e+02, 3.35520020e+02,
+       2.30400009e+02, 3.36960022e+02, 2.39040009e+02, 3.36960022e+02,
+       2.83680023e+02, 3.36960022e+02, 2.62080017e+02, 3.38400024e+02,
+       2.80800018e+02, 3.38400024e+02, 3.26880005e+02, 3.38400024e+02,
+       3.45600006e+02, 3.38400024e+02, 4.00320007e+02, 3.38400024e+02,
+       1.85760010e+02, 3.39840027e+02, 2.95200012e+02, 3.39840027e+02,
+       3.18240021e+02, 3.39840027e+02, 3.22559998e+02, 3.39840027e+02,
+       2.80800018e+02, 3.41279999e+02, 3.81600006e+02, 3.41279999e+02,
+       4.16160004e+02, 3.41279999e+02, 4.19040009e+02, 3.41279999e+02,
+       2.00160004e+02, 3.42720001e+02, 2.69279999e+02, 3.42720001e+02,
+       2.83680023e+02, 3.42720001e+02, 2.86559998e+02, 3.42720001e+02,
+       3.55680023e+02, 3.42720001e+02, 2.07360016e+02, 3.44160004e+02,
+       2.77920013e+02, 3.44160004e+02, 3.28320007e+02, 3.44160004e+02,
+       3.32640015e+02, 3.44160004e+02, 2.18880005e+02, 3.45600006e+02,
+       3.15360016e+02, 3.45600006e+02, 3.98880005e+02, 3.45600006e+02,
+       2.27520004e+02, 3.47040009e+02, 3.47040009e+02, 3.47040009e+02,
+       3.65760010e+02, 3.47040009e+02, 4.01760010e+02, 3.47040009e+02,
+       3.41279999e+02, 3.48480011e+02, 3.71520020e+02, 3.48480011e+02,
+       2.43360016e+02, 3.49920013e+02, 2.93760010e+02, 3.49920013e+02,
+       3.32640015e+02, 3.49920013e+02, 3.74400024e+02, 3.49920013e+02,
+       4.00320007e+02, 3.49920013e+02, 2.50560013e+02, 3.51360016e+02,
+       3.03840027e+02, 3.51360016e+02, 3.55680023e+02, 3.51360016e+02,
+       3.13920013e+02, 3.52800018e+02, 3.51360016e+02, 3.52800018e+02,
+       2.67839996e+02, 3.54240021e+02, 3.22559998e+02, 3.54240021e+02,
+       4.16160004e+02, 3.54240021e+02, 4.19040009e+02, 3.54240021e+02,
+       3.51360016e+02, 3.55680023e+02, 3.25440002e+02, 3.57120026e+02,
+       3.41279999e+02, 3.57120026e+02, 4.01760010e+02, 3.57120026e+02,
+       2.90880005e+02, 3.58560028e+02, 3.49920013e+02, 3.58560028e+02,
+       3.67200012e+02, 3.58560028e+02, 3.83040009e+02, 360.,
+       2.98080017e+02, 3.61440002e+02, 3.57120026e+02, 3.61440002e+02,
+       4.16160004e+02, 3.61440002e+02, 4.20480011e+02, 3.61440002e+02,
+       3.21120026e+02, 3.62880005e+02, 3.83040009e+02, 3.62880005e+02,
+       3.13920013e+02, 3.64320007e+02, 360., 3.64320007e+02,
+       3.68640015e+02, 3.64320007e+02, 3.78720001e+02, 3.65760010e+02,
+       4.01760010e+02, 3.65760010e+02, 4.17600006e+02, 3.65760010e+02,
+       3.38400024e+02, 3.67200012e+02, 3.62880005e+02, 3.70080017e+02,
+       3.71520020e+02, 3.71520020e+02, 3.61440002e+02, 3.72960022e+02,
+       4.20480011e+02, 3.74400024e+02, 3.87360016e+02, 3.75840027e+02,
+       3.96000031e+02, 3.77280029e+02, 4.13280029e+02, 3.77280029e+02,
+       4.20480011e+02, 3.77280029e+02, 4.26240021e+02, 3.83040009e+02,
+       4.30560028e+02, 3.84480011e+02, 2.05632019e+02, 1.31328018e+02,
+       2.14272018e+02, 1.38240021e+02, 2.29824020e+02, 1.39968018e+02,
+       2.07360016e+02, 1.41696014e+02, 2.10816025e+02, 1.41696014e+02,
+       2.16000015e+02, 1.41696014e+02, 2.45376022e+02, 1.41696014e+02,
+       2.55744019e+02, 1.41696014e+02, 2.24640015e+02, 1.43424011e+02,
+       2.28096024e+02, 1.43424011e+02, 2.35008026e+02, 1.45152008e+02,
+       2.05632019e+02, 1.46880020e+02, 2.66112030e+02, 1.46880020e+02,
+       2.31552017e+02, 1.48608017e+02, 2.45376022e+02, 1.48608017e+02,
+       2.57472015e+02, 1.48608017e+02, 2.38464020e+02, 1.50336014e+02,
+       2.66112030e+02, 1.50336014e+02, 2.76480042e+02, 1.52064011e+02,
+       2.60928040e+02, 1.53792007e+02, 2.90304016e+02, 1.53792007e+02,
+       3.04128021e+02, 1.53792007e+02, 2.35008026e+02, 1.55520020e+02,
+       3.12768036e+02, 1.55520020e+02, 3.21408020e+02, 1.55520020e+02,
+       2.00448013e+02, 1.57248016e+02, 2.16000015e+02, 1.57248016e+02,
+       2.26368027e+02, 1.57248016e+02, 3.30048035e+02, 1.57248016e+02,
+       3.40416046e+02, 1.58976013e+02, 1.98720016e+02, 1.60704010e+02,
+       3.49056030e+02, 1.60704010e+02, 1.90080017e+02, 1.62432022e+02,
+       3.59424042e+02, 1.62432022e+02, 3.69792023e+02, 1.62432022e+02,
+       4.26816040e+02, 1.62432022e+02, 1.93536011e+02, 1.64160019e+02,
+       2.81664032e+02, 1.64160019e+02, 4.11264038e+02, 1.64160019e+02,
+       4.38912048e+02, 1.64160019e+02, 1.90080017e+02, 1.65888016e+02,
+       2.05632019e+02, 1.65888016e+02, 2.97216034e+02, 1.65888016e+02,
+       3.95712036e+02, 1.65888016e+02, 4.83840057e+02, 1.65888016e+02,
+       3.05856018e+02, 1.67616013e+02, 4.07808044e+02, 1.67616013e+02,
+       4.54464050e+02, 1.67616013e+02, 1.96992020e+02, 1.69344009e+02,
+       4.07808044e+02, 1.71072021e+02, 4.30272034e+02, 1.71072021e+02,
+       4.40640045e+02, 1.71072021e+02, 4.56192047e+02, 1.71072021e+02,
+       4.71744049e+02, 1.71072021e+02, 3.49056030e+02, 1.72800018e+02,
+       4.35456055e+02, 1.72800018e+02, 4.64832031e+02, 1.72800018e+02,
+       3.02400024e+02, 1.74528015e+02, 3.68064026e+02, 1.74528015e+02,
+       4.73472046e+02, 1.74528015e+02, 2.22912018e+02, 1.76256012e+02,
+       2.29824020e+02, 1.77984024e+02, 2.36736023e+02, 1.77984024e+02,
+       4.32000031e+02, 1.77984024e+02, 1.79712021e+02, 1.79712021e+02,
+       1.86624023e+02, 1.81440018e+02, 3.45600037e+02, 1.81440018e+02,
+       3.80160034e+02, 1.81440018e+02, 3.85344025e+02, 1.81440018e+02,
+       3.90528046e+02, 1.81440018e+02, 4.12992035e+02, 1.81440018e+02,
+       2.33280029e+02, 1.83168015e+02, 2.81664032e+02, 1.83168015e+02,
+       3.35232025e+02, 1.83168015e+02, 3.73248047e+02, 1.83168015e+02,
+       3.97440033e+02, 1.83168015e+02, 4.42368042e+02, 1.83168015e+02,
+       1.84896011e+02, 1.84896011e+02, 2.16000015e+02, 1.84896011e+02,
+       3.00672028e+02, 1.84896011e+02, 3.76704041e+02, 1.84896011e+02,
+       4.37184052e+02, 1.84896011e+02, 4.47552032e+02, 1.84896011e+02,
+       4.51008057e+02, 1.84896011e+02, 4.57920044e+02, 1.84896011e+02,
+       2.66112030e+02, 1.86624023e+02, 3.99168030e+02, 1.86624023e+02,
+       2.14272018e+02, 1.88352020e+02, 2.31552017e+02, 1.88352020e+02,
+       2.38464020e+02, 1.88352020e+02, 2.54016022e+02, 1.88352020e+02,
+       3.69792023e+02, 1.88352020e+02, 3.78432037e+02, 1.88352020e+02,
+       2.22912018e+02, 1.90080017e+02, 2.45376022e+02, 1.90080017e+02,
+       3.11040039e+02, 1.90080017e+02, 3.49056030e+02, 1.90080017e+02,
+       4.63104034e+02, 1.90080017e+02, 4.66560059e+02, 1.90080017e+02,
+       1.71072021e+02, 1.91808014e+02, 1.86624023e+02, 1.91808014e+02,
+       2.12544022e+02, 1.91808014e+02, 2.73024017e+02, 1.91808014e+02,
+       2.78208038e+02, 1.91808014e+02, 3.16224030e+02, 1.91808014e+02,
+       3.52512024e+02, 1.91808014e+02, 3.62880035e+02, 1.91808014e+02,
+       4.07808044e+02, 1.91808014e+02, 2.81664032e+02, 1.93536011e+02,
+       3.30048035e+02, 1.93536011e+02, 3.88800049e+02, 1.93536011e+02,
+       1.74528015e+02, 1.95264023e+02, 2.16000015e+02, 1.95264023e+02,
+       2.57472015e+02, 1.95264023e+02, 2.71296021e+02, 1.95264023e+02,
+       3.42144043e+02, 1.95264023e+02, 4.06080048e+02, 1.95264023e+02,
+       4.59648041e+02, 1.95264023e+02, 2.09088013e+02, 1.96992020e+02,
+       2.26368027e+02, 1.96992020e+02, 2.29824020e+02, 1.96992020e+02,
+       2.47104019e+02, 1.96992020e+02, 3.00672028e+02, 1.96992020e+02,
+       4.09536041e+02, 1.96992020e+02, 2.38464020e+02, 1.98720016e+02,
+       2.52288025e+02, 1.98720016e+02, 2.73024017e+02, 1.98720016e+02,
+       3.05856018e+02, 1.98720016e+02, 3.12768036e+02, 1.98720016e+02,
+       3.43872040e+02, 1.98720016e+02, 3.69792023e+02, 1.98720016e+02,
+       3.80160034e+02, 1.98720016e+02, 3.88800049e+02, 1.98720016e+02,
+       3.97440033e+02, 1.98720016e+02, 4.45824036e+02, 1.98720016e+02,
+       1.74528015e+02, 2.00448013e+02, 2.12544022e+02, 2.00448013e+02,
+       2.22912018e+02, 2.00448013e+02, 2.31552017e+02, 2.00448013e+02,
+       2.67840027e+02, 2.00448013e+02, 3.17952026e+02, 2.00448013e+02,
+       3.30048035e+02, 2.00448013e+02, 3.54240021e+02, 2.00448013e+02,
+       4.00896027e+02, 2.00448013e+02, 3.11040039e+02, 2.02176025e+02,
+       3.71520050e+02, 2.02176025e+02, 3.74976044e+02, 2.02176025e+02,
+       4.09536041e+02, 2.02176025e+02, 1.69344009e+02, 2.03904022e+02,
+       2.19456024e+02, 2.03904022e+02, 2.52288025e+02, 2.03904022e+02,
+       2.93760040e+02, 2.03904022e+02, 3.81888031e+02, 2.03904022e+02,
+       3.92256042e+02, 2.03904022e+02, 4.00896027e+02, 2.03904022e+02,
+       4.04352051e+02, 2.03904022e+02, 4.14720032e+02, 2.03904022e+02,
+       2.03904022e+02, 2.05632019e+02, 2.10816025e+02, 2.05632019e+02,
+       2.67840027e+02, 2.05632019e+02, 3.21408020e+02, 2.05632019e+02,
+       3.55968048e+02, 2.05632019e+02, 4.59648041e+02, 2.05632019e+02,
+       2.16000015e+02, 2.07360016e+02, 2.60928040e+02, 2.07360016e+02,
+       3.74976044e+02, 2.07360016e+02, 3.85344025e+02, 2.07360016e+02,
+       2.10816025e+02, 2.09088013e+02, 2.66112030e+02, 2.09088013e+02,
+       3.14496033e+02, 2.09088013e+02, 3.24864044e+02, 2.09088013e+02,
+       3.69792023e+02, 2.09088013e+02, 4.06080048e+02, 2.10816025e+02,
+       2.60928040e+02, 2.12544022e+02, 2.83392029e+02, 2.12544022e+02,
+       3.66336029e+02, 2.12544022e+02, 1.53792007e+02, 2.14272018e+02,
+       2.09088013e+02, 2.14272018e+02, 2.24640015e+02, 2.14272018e+02,
+       3.07584015e+02, 2.14272018e+02, 3.31776031e+02, 2.14272018e+02,
+       4.47552032e+02, 2.14272018e+02, 2.64384033e+02, 2.16000015e+02,
+       3.71520050e+02, 2.16000015e+02, 1.53792007e+02, 2.17728027e+02,
+       1.65888016e+02, 2.17728027e+02, 1.96992020e+02, 2.17728027e+02,
+       2.00448013e+02, 2.19456024e+02, 2.81664032e+02, 2.19456024e+02,
+       3.74976044e+02, 2.19456024e+02, 3.97440033e+02, 2.19456024e+02,
+       4.04352051e+02, 2.19456024e+02, 4.45824036e+02, 2.19456024e+02,
+       1.67616013e+02, 2.21184021e+02, 1.72800018e+02, 2.21184021e+02,
+       2.92032013e+02, 2.21184021e+02, 3.07584015e+02, 2.21184021e+02,
+       3.83616028e+02, 2.21184021e+02, 1.81440018e+02, 2.22912018e+02,
+       3.92256042e+02, 2.22912018e+02, 2.03904022e+02, 2.24640015e+02,
+       3.81888031e+02, 2.24640015e+02, 4.06080048e+02, 2.24640015e+02,
+       1.45152008e+02, 2.26368027e+02, 1.53792007e+02, 2.26368027e+02,
+       1.65888016e+02, 2.26368027e+02, 1.76256012e+02, 2.26368027e+02,
+       1.93536011e+02, 2.26368027e+02, 2.73024017e+02, 2.26368027e+02,
+       2.79936035e+02, 2.26368027e+02, 3.69792023e+02, 2.26368027e+02,
+       3.99168030e+02, 2.26368027e+02, 2.90304016e+02, 2.28096024e+02,
+       2.93760040e+02, 2.28096024e+02, 4.33728027e+02, 2.28096024e+02,
+       4.49280029e+02, 2.28096024e+02, 1.46880020e+02, 2.29824020e+02,
+       1.50336014e+02, 2.29824020e+02, 2.45376022e+02, 2.29824020e+02,
+       2.76480042e+02, 2.29824020e+02, 4.02624023e+02, 2.29824020e+02,
+       1.96992020e+02, 2.31552017e+02, 2.09088013e+02, 2.31552017e+02,
+       2.67840027e+02, 2.31552017e+02, 2.97216034e+02, 2.31552017e+02,
+       1.79712021e+02, 2.33280029e+02, 2.88576019e+02, 2.33280029e+02,
+       1.52064011e+02, 2.35008026e+02, 1.62432022e+02, 2.35008026e+02,
+       1.71072021e+02, 2.35008026e+02, 2.09088013e+02, 2.35008026e+02,
+       2.14272018e+02, 2.35008026e+02, 2.74752014e+02, 2.35008026e+02,
+       3.07584015e+02, 2.35008026e+02, 3.97440033e+02, 2.35008026e+02,
+       4.49280029e+02, 2.35008026e+02, 1.67616013e+02, 2.36736023e+02,
+       1.81440018e+02, 2.36736023e+02, 2.19456024e+02, 2.36736023e+02,
+       2.38464020e+02, 2.36736023e+02, 2.93760040e+02, 2.36736023e+02,
+       3.02400024e+02, 2.36736023e+02, 4.35456055e+02, 2.36736023e+02,
+       2.09088013e+02, 2.38464020e+02, 2.24640015e+02, 2.38464020e+02,
+       3.33504028e+02, 2.38464020e+02, 1.39968018e+02, 2.40192017e+02,
+       1.79712021e+02, 2.40192017e+02, 1.95264023e+02, 2.40192017e+02,
+       2.14272018e+02, 2.40192017e+02, 2.31552017e+02, 2.40192017e+02,
+       2.60928040e+02, 2.40192017e+02, 2.67840027e+02, 2.40192017e+02,
+       3.64608032e+02, 2.40192017e+02, 3.69792023e+02, 2.40192017e+02,
+       4.37184052e+02, 2.41920029e+02, 1.76256012e+02, 2.43648026e+02,
+       1.86624023e+02, 2.43648026e+02, 1.90080017e+02, 2.43648026e+02,
+       2.17728027e+02, 2.43648026e+02, 2.47104019e+02, 2.43648026e+02,
+       3.54240021e+02, 2.43648026e+02, 3.92256042e+02, 2.43648026e+02,
+       3.99168030e+02, 2.43648026e+02, 2.67840027e+02, 2.45376022e+02,
+       3.04128021e+02, 2.45376022e+02, 3.09312042e+02, 2.45376022e+02,
+       3.35232025e+02, 2.45376022e+02, 3.62880035e+02, 2.45376022e+02,
+       3.69792023e+02, 2.45376022e+02, 4.42368042e+02, 2.45376022e+02,
+       1.36512009e+02, 2.47104019e+02, 1.64160019e+02, 2.47104019e+02,
+       1.88352020e+02, 2.47104019e+02, 2.92032013e+02, 2.47104019e+02,
+       3.38688019e+02, 2.47104019e+02, 3.47328033e+02, 2.47104019e+02,
+       3.80160034e+02, 2.47104019e+02, 3.88800049e+02, 2.47104019e+02,
+       4.06080048e+02, 2.47104019e+02, 1.31328018e+02, 2.48832031e+02,
+       1.69344009e+02, 2.48832031e+02, 3.16224030e+02, 2.48832031e+02,
+       3.62880035e+02, 2.48832031e+02, 3.83616028e+02, 2.48832031e+02,
+       1.39968018e+02, 2.50560028e+02, 1.48608017e+02, 2.50560028e+02,
+       1.81440018e+02, 2.50560028e+02, 1.98720016e+02, 2.50560028e+02,
+       2.59200012e+02, 2.50560028e+02, 2.93760040e+02, 2.50560028e+02,
+       3.35232025e+02, 2.50560028e+02, 3.43872040e+02, 2.50560028e+02,
+       3.52512024e+02, 2.50560028e+02, 3.55968048e+02, 2.50560028e+02,
+       3.69792023e+02, 2.50560028e+02, 3.73248047e+02, 2.50560028e+02,
+       1.64160019e+02, 2.52288025e+02, 1.74528015e+02, 2.52288025e+02,
+       3.04128021e+02, 2.52288025e+02, 3.21408020e+02, 2.52288025e+02,
+       3.59424042e+02, 2.52288025e+02, 4.42368042e+02, 2.52288025e+02,
+       1.31328018e+02, 2.54016022e+02, 3.17952026e+02, 2.54016022e+02,
+       3.71520050e+02, 2.54016022e+02, 4.14720032e+02, 2.54016022e+02,
+       4.26816040e+02, 2.54016022e+02, 1.64160019e+02, 2.55744019e+02,
+       1.96992020e+02, 2.55744019e+02, 1.26144012e+02, 2.57472015e+02,
+       1.36512009e+02, 2.57472015e+02, 1.46880020e+02, 2.57472015e+02,
+       3.83616028e+02, 2.57472015e+02, 4.12992035e+02, 2.57472015e+02,
+       4.19904053e+02, 2.57472015e+02, 1.64160019e+02, 2.59200012e+02,
+       1.93536011e+02, 2.59200012e+02, 3.52512024e+02, 2.59200012e+02,
+       1.76256012e+02, 2.60928040e+02, 2.36736023e+02, 2.60928040e+02,
+       2.45376022e+02, 2.60928040e+02, 2.54016022e+02, 2.60928040e+02,
+       3.61152039e+02, 2.60928040e+02, 2.50560028e+02, 2.62656036e+02,
+       2.60928040e+02, 2.62656036e+02, 3.47328033e+02, 2.62656036e+02,
+       4.35456055e+02, 2.62656036e+02, 4.64832031e+02, 2.62656036e+02,
+       1.81440018e+02, 2.64384033e+02, 2.73024017e+02, 2.64384033e+02,
+       3.61152039e+02, 2.64384033e+02, 4.26816040e+02, 2.64384033e+02,
+       2.17728027e+02, 2.67840027e+02, 2.71296021e+02, 2.67840027e+02,
+       2.74752014e+02, 2.67840027e+02, 2.97216034e+02, 2.67840027e+02,
+       3.97440033e+02, 2.67840027e+02, 4.35456055e+02, 2.67840027e+02,
+       1.24416016e+02, 2.69568024e+02, 1.29600006e+02, 2.69568024e+02,
+       2.26368027e+02, 2.69568024e+02, 3.09312042e+02, 2.69568024e+02,
+       3.83616028e+02, 2.69568024e+02, 4.26816040e+02, 2.69568024e+02,
+       2.16000015e+02, 2.71296021e+02, 3.88800049e+02, 2.71296021e+02,
+       3.93984039e+02, 2.71296021e+02, 4.00896027e+02, 2.71296021e+02,
+       4.07808044e+02, 2.71296021e+02, 4.33728027e+02, 2.71296021e+02,
+       1.29600006e+02, 2.73024017e+02, 1.52064011e+02, 2.73024017e+02,
+       2.24640015e+02, 2.73024017e+02, 3.11040039e+02, 2.73024017e+02,
+       2.38464020e+02, 2.74752014e+02, 3.07584015e+02, 2.74752014e+02,
+       3.23136017e+02, 2.74752014e+02, 3.57696045e+02, 2.74752014e+02,
+       3.71520050e+02, 2.74752014e+02, 4.18176025e+02, 2.74752014e+02,
+       4.23360046e+02, 2.74752014e+02, 1.52064011e+02, 2.76480042e+02,
+       3.88800049e+02, 2.76480042e+02, 1.67616013e+02, 2.78208038e+02,
+       2.62656036e+02, 2.78208038e+02, 3.57696045e+02, 2.78208038e+02,
+       1.91808014e+02, 2.79936035e+02, 3.93984039e+02, 2.79936035e+02,
+       1.98720016e+02, 2.81664032e+02, 3.64608032e+02, 2.81664032e+02,
+       3.78432037e+02, 2.81664032e+02, 3.85344025e+02, 2.81664032e+02,
+       3.52512024e+02, 2.83392029e+02, 1.41696014e+02, 2.85120026e+02,
+       1.62432022e+02, 2.85120026e+02, 2.14272018e+02, 2.85120026e+02,
+       3.11040039e+02, 2.85120026e+02, 3.61152039e+02, 2.85120026e+02,
+       3.88800049e+02, 2.85120026e+02, 4.02624023e+02, 2.85120026e+02,
+       1.71072021e+02, 2.86848022e+02, 2.38464020e+02, 2.86848022e+02,
+       3.19680023e+02, 2.86848022e+02, 3.42144043e+02, 2.86848022e+02,
+       4.16448029e+02, 2.86848022e+02, 4.21632050e+02, 2.86848022e+02,
+       4.26816040e+02, 2.86848022e+02, 1.27872009e+02, 2.88576019e+02,
+       1.58976013e+02, 2.88576019e+02, 2.45376022e+02, 2.88576019e+02,
+       3.69792023e+02, 2.88576019e+02, 3.93984039e+02, 2.88576019e+02,
+       3.99168030e+02, 2.88576019e+02, 4.04352051e+02, 2.88576019e+02,
+       1.43424011e+02, 2.90304016e+02, 4.19904053e+02, 2.90304016e+02,
+       4.23360046e+02, 2.90304016e+02, 1.71072021e+02, 2.92032013e+02,
+       1.90080017e+02, 2.92032013e+02, 3.78432037e+02, 2.92032013e+02,
+       4.12992035e+02, 2.92032013e+02, 2.60928040e+02, 2.93760040e+02,
+       3.68064026e+02, 2.93760040e+02, 3.74976044e+02, 2.93760040e+02,
+       4.21632050e+02, 2.93760040e+02, 1.29600006e+02, 2.95488037e+02,
+       1.72800018e+02, 2.95488037e+02, 1.77984024e+02, 2.95488037e+02,
+       2.69568024e+02, 2.95488037e+02, 2.95488037e+02, 2.95488037e+02,
+       3.97440033e+02, 2.95488037e+02, 1.65888016e+02, 2.97216034e+02,
+       2.16000015e+02, 2.97216034e+02, 4.16448029e+02, 2.97216034e+02,
+       3.12768036e+02, 2.98944031e+02, 4.21632050e+02, 2.98944031e+02,
+       1.81440018e+02, 3.00672028e+02, 1.45152008e+02, 3.04128021e+02,
+       1.77984024e+02, 3.04128021e+02, 1.84896011e+02, 3.04128021e+02,
+       2.62656036e+02, 3.04128021e+02, 3.31776031e+02, 3.04128021e+02,
+       2.71296021e+02, 3.05856018e+02, 3.40416046e+02, 3.05856018e+02,
+       3.57696045e+02, 3.05856018e+02, 4.28544037e+02, 3.05856018e+02,
+       1.29600006e+02, 3.07584015e+02, 1.71072021e+02, 3.07584015e+02,
+       1.79712021e+02, 3.07584015e+02, 2.81664032e+02, 3.07584015e+02,
+       2.92032013e+02, 3.07584015e+02, 3.66336029e+02, 3.07584015e+02,
+       3.83616028e+02, 3.09312042e+02, 4.23360046e+02, 3.09312042e+02,
+       3.11040039e+02, 3.11040039e+02, 1.88352020e+02, 3.12768036e+02,
+       1.91808014e+02, 3.12768036e+02, 2.05632019e+02, 3.12768036e+02,
+       3.83616028e+02, 3.12768036e+02, 1.33056015e+02, 3.14496033e+02,
+       1.69344009e+02, 3.14496033e+02, 1.98720016e+02, 3.14496033e+02,
+       2.93760040e+02, 3.14496033e+02, 3.09312042e+02, 3.14496033e+02,
+       3.92256042e+02, 3.14496033e+02, 4.12992035e+02, 3.14496033e+02,
+       1.48608017e+02, 3.16224030e+02, 1.72800018e+02, 3.16224030e+02,
+       2.03904022e+02, 3.16224030e+02, 2.10816025e+02, 3.16224030e+02,
+       2.24640015e+02, 3.17952026e+02, 2.93760040e+02, 3.17952026e+02,
+       3.47328033e+02, 3.17952026e+02, 4.14720032e+02, 3.17952026e+02,
+       4.18176025e+02, 3.17952026e+02, 1.72800018e+02, 3.19680023e+02,
+       1.81440018e+02, 3.19680023e+02, 1.90080017e+02, 3.19680023e+02,
+       3.19680023e+02, 3.19680023e+02, 3.24864044e+02, 3.19680023e+02,
+       2.10816025e+02, 3.21408020e+02, 2.19456024e+02, 3.21408020e+02,
+       2.29824020e+02, 3.21408020e+02, 2.88576019e+02, 3.21408020e+02,
+       3.68064026e+02, 3.21408020e+02, 4.14720032e+02, 3.21408020e+02,
+       4.18176025e+02, 3.21408020e+02, 1.50336014e+02, 3.23136017e+02,
+       2.79936035e+02, 3.23136017e+02, 2.95488037e+02, 3.23136017e+02,
+       3.04128021e+02, 3.23136017e+02, 3.80160034e+02, 3.23136017e+02,
+       1.71072021e+02, 3.24864044e+02, 1.90080017e+02, 3.24864044e+02,
+       3.16224030e+02, 3.24864044e+02, 1.36512009e+02, 3.26592041e+02,
+       1.74528015e+02, 3.26592041e+02, 2.48832031e+02, 3.26592041e+02,
+       2.71296021e+02, 3.26592041e+02, 2.93760040e+02, 3.26592041e+02,
+       3.73248047e+02, 3.26592041e+02, 2.03904022e+02, 3.28320038e+02,
+       2.33280029e+02, 3.28320038e+02, 2.36736023e+02, 3.28320038e+02,
+       2.43648026e+02, 3.28320038e+02, 2.54016022e+02, 3.28320038e+02,
+       2.81664032e+02, 3.28320038e+02, 2.86848022e+02, 3.28320038e+02,
+       3.00672028e+02, 3.28320038e+02, 3.11040039e+02, 3.28320038e+02,
+       3.33504028e+02, 3.28320038e+02, 3.99168030e+02, 3.28320038e+02,
+       1.36512009e+02, 3.30048035e+02, 2.40192017e+02, 3.30048035e+02,
+       2.57472015e+02, 3.30048035e+02, 3.24864044e+02, 3.30048035e+02,
+       2.02176025e+02, 3.31776031e+02, 2.05632019e+02, 3.31776031e+02,
+       2.36736023e+02, 3.31776031e+02, 2.74752014e+02, 3.31776031e+02,
+       2.93760040e+02, 3.31776031e+02, 3.17952026e+02, 3.31776031e+02,
+       2.17728027e+02, 3.33504028e+02, 2.52288025e+02, 3.33504028e+02,
+       2.59200012e+02, 3.33504028e+02, 2.21184021e+02, 3.35232025e+02,
+       2.55744019e+02, 3.35232025e+02, 2.67840027e+02, 3.35232025e+02,
+       2.98944031e+02, 3.35232025e+02, 3.73248047e+02, 3.35232025e+02,
+       4.14720032e+02, 3.35232025e+02, 4.18176025e+02, 3.35232025e+02,
+       2.29824020e+02, 3.36960022e+02, 2.38464020e+02, 3.36960022e+02,
+       3.04128021e+02, 3.36960022e+02, 3.19680023e+02, 3.36960022e+02,
+       2.60928040e+02, 3.38688019e+02, 2.79936035e+02, 3.38688019e+02,
+       3.26592041e+02, 3.38688019e+02, 3.43872040e+02, 3.38688019e+02,
+       3.99168030e+02, 3.38688019e+02, 1.86624023e+02, 3.40416046e+02,
+       2.54016022e+02, 3.40416046e+02, 2.69568024e+02, 3.40416046e+02,
+       2.93760040e+02, 3.40416046e+02, 3.38688019e+02, 3.40416046e+02,
+       2.79936035e+02, 3.42144043e+02, 4.18176025e+02, 3.42144043e+02,
+       2.00448013e+02, 3.43872040e+02, 2.83392029e+02, 3.43872040e+02,
+       3.14496033e+02, 3.45600037e+02, 3.30048035e+02, 3.45600037e+02,
+       3.00672028e+02, 3.47328033e+02, 3.47328033e+02, 3.47328033e+02,
+       4.00896027e+02, 3.47328033e+02, 3.16224030e+02, 3.49056030e+02,
+       3.40416046e+02, 3.49056030e+02, 3.66336029e+02, 3.49056030e+02,
+       3.73248047e+02, 3.49056030e+02, 2.43648026e+02, 3.50784027e+02,
+       2.93760040e+02, 3.50784027e+02, 3.62880035e+02, 3.50784027e+02,
+       3.49056030e+02, 3.52512024e+02, 3.55968048e+02, 3.52512024e+02,
+       3.80160034e+02, 3.52512024e+02, 3.14496033e+02, 3.54240021e+02,
+       3.50784027e+02, 3.55968048e+02, 3.40416046e+02, 3.57696045e+02,
+       3.61152039e+02, 3.57696045e+02, 4.00896027e+02, 3.57696045e+02,
+       4.16448029e+02, 3.57696045e+02, 2.90304016e+02, 3.59424042e+02,
+       3.50784027e+02, 3.59424042e+02, 4.19904053e+02, 3.59424042e+02,
+       2.98944031e+02, 3.61152039e+02, 3.81888031e+02, 3.61152039e+02,
+       3.83616028e+02, 3.64608032e+02, 3.28320038e+02, 3.66336029e+02,
+       3.78432037e+02, 3.66336029e+02, 4.02624023e+02, 3.66336029e+02,
+       3.38688019e+02, 3.68064026e+02, 3.45600037e+02, 3.69792023e+02,
+       3.71520050e+02, 3.71520050e+02, 3.62880035e+02, 3.73248047e+02,
+       3.87072021e+02, 3.74976044e+02, 4.19904053e+02, 3.74976044e+02,
+       4.12992035e+02, 3.76704041e+02, 4.21632050e+02, 3.78432037e+02,
+       4.25088043e+02, 3.83616028e+02, 4.30272034e+02, 3.85344025e+02,
+       2.13580826e+02, 1.36857620e+02, 2.28096039e+02, 1.38931213e+02,
+       2.44684830e+02, 1.41004822e+02, 2.55052841e+02, 1.41004822e+02,
+       2.23948837e+02, 1.43078415e+02, 2.34316833e+02, 1.45152023e+02,
+       2.65420837e+02, 1.45152023e+02, 2.05286423e+02, 1.47225616e+02,
+       2.32243225e+02, 1.49299225e+02, 2.38464035e+02, 1.49299225e+02,
+       2.44684830e+02, 1.49299225e+02, 2.65420837e+02, 1.49299225e+02,
+       2.75788849e+02, 1.51372818e+02, 2.34316833e+02, 1.53446426e+02,
+       2.90304047e+02, 1.53446426e+02, 3.11040039e+02, 1.55520020e+02,
+       2.01139221e+02, 1.57593628e+02, 2.15654434e+02, 1.57593628e+02,
+       2.23948837e+02, 1.57593628e+02, 3.37996857e+02, 1.57593628e+02,
+       3.50438446e+02, 1.59667221e+02, 3.69100861e+02, 1.61740829e+02,
+       4.27161652e+02, 1.61740829e+02, 1.92844833e+02, 1.63814423e+02,
+       4.10572845e+02, 1.63814423e+02, 4.37529663e+02, 1.63814423e+02,
+       2.05286423e+02, 1.65888031e+02, 3.93984070e+02, 1.65888031e+02,
+       4.54118469e+02, 1.65888031e+02, 1.99065628e+02, 1.67961624e+02,
+       2.42611237e+02, 1.70035217e+02, 4.27161652e+02, 1.70035217e+02,
+       4.39603271e+02, 1.70035217e+02, 4.70707275e+02, 1.70035217e+02,
+       3.48364838e+02, 1.72108826e+02, 4.35456055e+02, 1.72108826e+02,
+       4.54118469e+02, 1.72108826e+02, 2.34316833e+02, 1.74182419e+02,
+       2.98598450e+02, 1.74182419e+02, 3.69100861e+02, 1.74182419e+02,
+       4.31308868e+02, 1.76256027e+02, 2.36390427e+02, 1.78329620e+02,
+       1.78329620e+02, 1.80403229e+02, 1.84550430e+02, 1.80403229e+02,
+       3.77395264e+02, 1.80403229e+02, 3.83616058e+02, 1.80403229e+02,
+       3.89836853e+02, 1.80403229e+02, 2.82009644e+02, 1.82476822e+02,
+       3.33849640e+02, 1.82476822e+02, 3.71174438e+02, 1.82476822e+02,
+       3.96057648e+02, 1.82476822e+02, 2.15654434e+02, 1.84550430e+02,
+       2.67494446e+02, 1.84550430e+02, 2.96524841e+02, 1.84550430e+02,
+       4.37529663e+02, 1.84550430e+02, 4.45824066e+02, 1.84550430e+02,
+       4.54118469e+02, 1.84550430e+02, 2.38464035e+02, 1.86624023e+02,
+       2.57126434e+02, 1.86624023e+02, 3.44217651e+02, 1.86624023e+02,
+       3.69100861e+02, 1.86624023e+02, 3.98131256e+02, 1.86624023e+02,
+       2.21875229e+02, 1.88697632e+02, 2.82009644e+02, 1.88697632e+02,
+       3.79468842e+02, 1.88697632e+02, 1.86624023e+02, 1.90771225e+02,
+       2.15654434e+02, 1.90771225e+02, 2.32243225e+02, 1.90771225e+02,
+       2.36390427e+02, 1.90771225e+02, 2.42611237e+02, 1.90771225e+02,
+       2.71641632e+02, 1.90771225e+02, 3.11040039e+02, 1.90771225e+02,
+       3.15187256e+02, 1.90771225e+02, 3.50438446e+02, 1.90771225e+02,
+       3.60806458e+02, 1.90771225e+02, 4.58265656e+02, 1.90771225e+02,
+       2.82009644e+02, 1.92844833e+02, 3.29702454e+02, 1.92844833e+02,
+       3.40070435e+02, 1.92844833e+02, 3.85689667e+02, 1.92844833e+02,
+       1.74182419e+02, 1.94918427e+02, 2.26022430e+02, 1.94918427e+02,
+       2.59200043e+02, 1.94918427e+02, 2.69568024e+02, 1.94918427e+02,
+       4.04352051e+02, 1.94918427e+02, 4.08499268e+02, 1.94918427e+02,
+       2.30169632e+02, 1.96992035e+02, 2.48832031e+02, 1.96992035e+02,
+       2.88230438e+02, 1.96992035e+02, 3.04819244e+02, 1.96992035e+02,
+       3.69100861e+02, 1.96992035e+02, 3.79468842e+02, 1.96992035e+02,
+       4.45824066e+02, 1.96992035e+02, 2.21875229e+02, 1.99065628e+02,
+       2.67494446e+02, 1.99065628e+02, 3.11040039e+02, 1.99065628e+02,
+       3.17260834e+02, 1.99065628e+02, 4.00204865e+02, 1.99065628e+02,
+       2.46758438e+02, 2.01139221e+02, 3.52512054e+02, 2.01139221e+02,
+       4.60339264e+02, 2.01139221e+02, 1.67961624e+02, 2.03212830e+02,
+       2.03212830e+02, 2.03212830e+02, 2.17728027e+02, 2.03212830e+02,
+       2.34316833e+02, 2.03212830e+02, 2.52979233e+02, 2.03212830e+02,
+       2.92377655e+02, 2.03212830e+02, 3.89836853e+02, 2.03212830e+02,
+       4.00204865e+02, 2.03212830e+02, 4.12646454e+02, 2.03212830e+02,
+       2.65420837e+02, 2.05286423e+02, 3.21408051e+02, 2.05286423e+02,
+       3.56659241e+02, 2.05286423e+02, 3.85689667e+02, 2.05286423e+02,
+       2.50905640e+02, 2.07360031e+02, 2.61273651e+02, 2.07360031e+02,
+       2.69568024e+02, 2.07360031e+02, 3.75321655e+02, 2.07360031e+02,
+       2.11507233e+02, 2.09433624e+02, 3.13113647e+02, 2.09433624e+02,
+       3.23481659e+02, 2.09433624e+02, 4.04352051e+02, 2.09433624e+02,
+       2.82009644e+02, 2.11507233e+02, 2.96524841e+02, 2.11507233e+02,
+       3.67027252e+02, 2.11507233e+02, 2.09433624e+02, 2.13580826e+02,
+       2.23948837e+02, 2.13580826e+02, 3.06892853e+02, 2.13580826e+02,
+       3.31776062e+02, 2.13580826e+02, 3.71174438e+02, 2.13580826e+02,
+       4.06425659e+02, 2.13580826e+02, 4.47897675e+02, 2.13580826e+02,
+       1.96992035e+02, 2.17728027e+02, 2.79936035e+02, 2.17728027e+02,
+       3.75321655e+02, 2.17728027e+02, 4.02278442e+02, 2.17728027e+02,
+       4.41676849e+02, 2.17728027e+02, 1.67961624e+02, 2.19801636e+02,
+       1.72108826e+02, 2.19801636e+02, 3.13113647e+02, 2.19801636e+02,
+       2.92377655e+02, 2.21875229e+02, 3.91910461e+02, 2.21875229e+02,
+       1.53446426e+02, 2.23948837e+02, 2.03212830e+02, 2.23948837e+02,
+       2.65420837e+02, 2.23948837e+02, 3.69100861e+02, 2.23948837e+02,
+       2.71641632e+02, 2.26022430e+02, 2.75788849e+02, 2.26022430e+02,
+       2.79936035e+02, 2.26022430e+02, 2.90304047e+02, 2.26022430e+02,
+       4.33382446e+02, 2.26022430e+02, 2.44684830e+02, 2.28096039e+02,
+       4.02278442e+02, 2.28096039e+02, 4.47897675e+02, 2.28096039e+02,
+       1.49299225e+02, 2.30169632e+02, 2.96524841e+02, 2.30169632e+02,
+       1.78329620e+02, 2.32243225e+02, 1.53446426e+02, 2.34316833e+02,
+       1.57593628e+02, 2.34316833e+02, 1.61740829e+02, 2.34316833e+02,
+       1.72108826e+02, 2.34316833e+02, 2.09433624e+02, 2.34316833e+02,
+       2.13580826e+02, 2.34316833e+02, 2.17728027e+02, 2.34316833e+02,
+       2.71641632e+02, 2.34316833e+02, 3.06892853e+02, 2.34316833e+02,
+       1.80403229e+02, 2.36390427e+02, 2.38464035e+02, 2.36390427e+02,
+       2.92377655e+02, 2.36390427e+02, 3.31776062e+02, 2.36390427e+02,
+       3.98131256e+02, 2.36390427e+02, 4.33382446e+02, 2.36390427e+02,
+       1.67961624e+02, 2.38464035e+02, 2.26022430e+02, 2.38464035e+02,
+       2.50905640e+02, 2.38464035e+02, 1.38931213e+02, 2.40537628e+02,
+       2.32243225e+02, 2.40537628e+02, 2.59200043e+02, 2.40537628e+02,
+       3.64953644e+02, 2.40537628e+02, 1.74182419e+02, 2.42611237e+02,
+       2.46758438e+02, 2.42611237e+02, 2.67494446e+02, 2.42611237e+02,
+       3.98131256e+02, 2.42611237e+02, 4.37529663e+02, 2.42611237e+02,
+       3.02745636e+02, 2.44684830e+02, 3.08966431e+02, 2.44684830e+02,
+       3.33849640e+02, 2.44684830e+02, 3.54585663e+02, 2.44684830e+02,
+       3.62880066e+02, 2.44684830e+02, 3.67027252e+02, 2.44684830e+02,
+       3.71174438e+02, 2.44684830e+02, 1.34784012e+02, 2.46758438e+02,
+       3.15187256e+02, 2.46758438e+02, 3.37996857e+02, 2.46758438e+02,
+       3.42144043e+02, 2.46758438e+02, 3.77395264e+02, 2.46758438e+02,
+       3.87763245e+02, 2.46758438e+02, 1.47225616e+02, 2.48832031e+02,
+       1.67961624e+02, 2.48832031e+02, 1.78329620e+02, 2.48832031e+02,
+       3.08966431e+02, 2.48832031e+02, 1.63814423e+02, 2.50905640e+02,
+       1.96992035e+02, 2.50905640e+02, 3.00672028e+02, 2.50905640e+02,
+       3.50438446e+02, 2.50905640e+02, 3.73248047e+02, 2.50905640e+02,
+       1.30636826e+02, 2.52979233e+02, 3.15187256e+02, 2.52979233e+02,
+       1.47225616e+02, 2.55052841e+02, 1.63814423e+02, 2.55052841e+02,
+       1.96992035e+02, 2.55052841e+02, 1.92844833e+02, 2.57126434e+02,
+       4.18867249e+02, 2.57126434e+02, 2.21875229e+02, 2.59200043e+02,
+       3.60806458e+02, 2.59200043e+02, 2.34316833e+02, 2.61273651e+02,
+       2.44684830e+02, 2.61273651e+02, 2.61273651e+02, 2.61273651e+02,
+       3.46291260e+02, 2.61273651e+02, 3.60806458e+02, 2.63347229e+02,
+       4.27161652e+02, 2.63347229e+02, 2.59200043e+02, 2.65420837e+02,
+       2.73715240e+02, 2.67494446e+02, 3.98131256e+02, 2.67494446e+02,
+       4.08499268e+02, 2.67494446e+02, 1.28563217e+02, 2.69568024e+02,
+       3.71174438e+02, 2.69568024e+02, 4.27161652e+02, 2.69568024e+02,
+       3.87763245e+02, 2.71641632e+02, 1.43078415e+02, 2.73715240e+02,
+       1.51372818e+02, 2.73715240e+02, 3.21408051e+02, 2.73715240e+02,
+       3.56659241e+02, 2.73715240e+02, 3.71174438e+02, 2.73715240e+02,
+       4.16793671e+02, 2.73715240e+02, 4.20940857e+02, 2.73715240e+02,
+       4.27161652e+02, 2.75788849e+02, 3.52512054e+02, 2.77862427e+02,
+       1.90771225e+02, 2.79936035e+02, 3.85689667e+02, 2.79936035e+02,
+       3.91910461e+02, 2.79936035e+02, 3.52512054e+02, 2.82009644e+02,
+       3.77395264e+02, 2.82009644e+02, 1.41004822e+02, 2.84083252e+02,
+       2.13580826e+02, 2.84083252e+02, 3.11040039e+02, 2.84083252e+02,
+       3.69100861e+02, 2.84083252e+02, 3.87763245e+02, 2.84083252e+02,
+       2.21875229e+02, 2.86156830e+02, 2.36390427e+02, 2.86156830e+02,
+       3.19334442e+02, 2.86156830e+02, 3.40070435e+02, 2.86156830e+02,
+       4.02278442e+02, 2.86156830e+02, 1.26489616e+02, 2.88230438e+02,
+       2.44684830e+02, 2.88230438e+02, 4.18867249e+02, 2.88230438e+02,
+       3.77395264e+02, 2.90304047e+02, 4.12646454e+02, 2.90304047e+02,
+       2.59200043e+02, 2.92377655e+02, 3.73248047e+02, 2.92377655e+02,
+       4.20940857e+02, 2.92377655e+02, 1.28563217e+02, 2.94451233e+02,
+       1.78329620e+02, 2.94451233e+02, 2.69568024e+02, 2.94451233e+02,
+       2.86156830e+02, 2.94451233e+02, 3.96057648e+02, 2.94451233e+02,
+       4.16793671e+02, 2.94451233e+02, 1.65888031e+02, 2.96524841e+02,
+       1.80403229e+02, 3.00672028e+02, 1.45152023e+02, 3.02745636e+02,
+       1.84550430e+02, 3.02745636e+02, 3.31776062e+02, 3.02745636e+02,
+       1.80403229e+02, 3.04819244e+02, 2.69568024e+02, 3.04819244e+02,
+       3.35923248e+02, 3.04819244e+02, 3.40070435e+02, 3.04819244e+02,
+       3.56659241e+02, 3.04819244e+02, 3.60806458e+02, 3.04819244e+02,
+       4.27161652e+02, 3.04819244e+02, 3.64953644e+02, 3.06892853e+02,
+       4.20940857e+02, 3.08966431e+02, 1.45152023e+02, 3.11040039e+02,
+       1.86624023e+02, 3.11040039e+02, 1.90771225e+02, 3.11040039e+02,
+       3.83616058e+02, 3.11040039e+02, 1.32710419e+02, 3.13113647e+02,
+       2.92377655e+02, 3.13113647e+02, 3.91910461e+02, 3.13113647e+02,
+       4.12646454e+02, 3.13113647e+02, 1.47225616e+02, 3.15187256e+02,
+       1.72108826e+02, 3.15187256e+02, 2.03212830e+02, 3.15187256e+02,
+       2.09433624e+02, 3.15187256e+02, 3.11040039e+02, 3.15187256e+02,
+       2.92377655e+02, 3.17260834e+02, 4.16793671e+02, 3.17260834e+02,
+       2.09433624e+02, 3.19334442e+02, 2.17728027e+02, 3.19334442e+02,
+       3.25555237e+02, 3.19334442e+02, 1.49299225e+02, 3.21408051e+02,
+       2.30169632e+02, 3.21408051e+02, 2.79936035e+02, 3.21408051e+02,
+       2.96524841e+02, 3.21408051e+02, 3.02745636e+02, 3.21408051e+02,
+       3.79468842e+02, 3.21408051e+02, 1.72108826e+02, 3.23481659e+02,
+       2.88230438e+02, 3.23481659e+02, 2.92377655e+02, 3.23481659e+02,
+       3.15187256e+02, 3.23481659e+02, 2.40537628e+02, 3.25555237e+02,
+       2.69568024e+02, 3.25555237e+02, 3.73248047e+02, 3.25555237e+02,
+       2.03212830e+02, 3.27628845e+02, 2.32243225e+02, 3.27628845e+02,
+       2.59200043e+02, 3.27628845e+02, 2.82009644e+02, 3.27628845e+02,
+       2.98598450e+02, 3.27628845e+02, 3.33849640e+02, 3.27628845e+02,
+       3.98131256e+02, 3.27628845e+02, 1.36857620e+02, 3.29702454e+02,
+       2.11507233e+02, 3.29702454e+02, 2.26022430e+02, 3.29702454e+02,
+       2.55052841e+02, 3.29702454e+02, 1.30636826e+02, 3.31776062e+02,
+       2.05286423e+02, 3.31776062e+02, 2.17728027e+02, 3.31776062e+02,
+       2.50905640e+02, 3.31776062e+02, 2.92377655e+02, 3.31776062e+02,
+       2.21875229e+02, 3.33849640e+02, 2.67494446e+02, 3.33849640e+02,
+       2.96524841e+02, 3.33849640e+02, 3.71174438e+02, 3.33849640e+02,
+       4.16793671e+02, 3.33849640e+02, 2.38464035e+02, 3.35923248e+02,
+       2.90304047e+02, 3.35923248e+02, 3.17260834e+02, 3.35923248e+02,
+       2.52979233e+02, 3.37996857e+02, 3.25555237e+02, 3.37996857e+02,
+       2.69568024e+02, 3.40070435e+02, 2.75788849e+02, 3.42144043e+02,
+       2.03212830e+02, 3.44217651e+02, 2.88230438e+02, 3.44217651e+02,
+       3.15187256e+02, 3.44217651e+02, 3.29702454e+02, 3.44217651e+02,
+       3.00672028e+02, 3.46291260e+02, 3.46291260e+02, 3.46291260e+02,
+       3.56659241e+02, 3.46291260e+02, 3.17260834e+02, 3.48364838e+02,
+       3.40070435e+02, 3.48364838e+02, 4.00204865e+02, 3.48364838e+02,
+       2.42611237e+02, 3.50438446e+02, 3.11040039e+02, 3.52512054e+02,
+       3.79468842e+02, 3.52512054e+02, 3.48364838e+02, 3.54585663e+02,
+       3.23481659e+02, 3.56659241e+02, 3.40070435e+02, 3.56659241e+02,
+       3.79468842e+02, 3.56659241e+02, 3.48364838e+02, 3.58732849e+02,
+       4.18867249e+02, 3.58732849e+02, 3.81542450e+02, 3.60806458e+02,
+       3.17260834e+02, 3.64953644e+02, 3.77395264e+02, 3.64953644e+02,
+       4.00204865e+02, 3.64953644e+02, 3.37996857e+02, 3.67027252e+02,
+       3.69100861e+02, 3.71174438e+02, 4.18867249e+02, 3.73248047e+02,
+       4.29235260e+02, 3.83616058e+02, 2.06530609e+02, 1.31880997e+02,
+       2.13995575e+02, 1.36857635e+02, 2.43855423e+02, 1.41834274e+02,
+       2.23948853e+02, 1.44322601e+02, 2.46343735e+02, 1.49299240e+02,
+       2.76203583e+02, 1.51787552e+02, 2.01553970e+02, 1.56764191e+02,
+       2.16483887e+02, 1.56764191e+02, 3.50853210e+02, 1.59252518e+02,
+       1.96577332e+02, 1.64229156e+02, 2.04042282e+02, 1.64229156e+02,
+       3.80713043e+02, 1.64229156e+02, 4.10572906e+02, 1.64229156e+02,
+       4.37944427e+02, 1.64229156e+02, 3.93154663e+02, 1.66717484e+02,
+       4.55362671e+02, 1.66717484e+02, 4.27991150e+02, 1.71694122e+02,
+       4.42921051e+02, 1.71694122e+02, 4.55362671e+02, 1.71694122e+02,
+       2.33902130e+02, 1.74182434e+02, 4.30479462e+02, 1.76670761e+02,
+       2.21460526e+02, 1.79159088e+02, 3.70759766e+02, 1.81647400e+02,
+       4.00619629e+02, 1.81647400e+02, 2.38878784e+02, 1.84135727e+02,
+       2.81180237e+02, 1.84135727e+02, 2.98598480e+02, 1.84135727e+02,
+       3.90666321e+02, 1.84135727e+02, 4.45409393e+02, 1.84135727e+02,
+       4.55362671e+02, 1.84135727e+02, 2.58785339e+02, 1.86624039e+02,
+       3.45876556e+02, 1.86624039e+02, 3.80713043e+02, 1.86624039e+02,
+       2.13995575e+02, 1.89112366e+02, 2.36390457e+02, 1.89112366e+02,
+       2.81180237e+02, 1.89112366e+02, 3.16016724e+02, 1.89112366e+02,
+       4.60339294e+02, 1.89112366e+02, 1.86624039e+02, 1.91600693e+02,
+       2.71226959e+02, 1.91600693e+02, 3.60806488e+02, 1.91600693e+02,
+       3.70759766e+02, 1.91600693e+02, 1.76670761e+02, 1.94089005e+02,
+       2.81180237e+02, 1.94089005e+02, 3.40899933e+02, 1.94089005e+02,
+       3.85689697e+02, 1.94089005e+02, 4.03107941e+02, 1.94089005e+02,
+       2.48832062e+02, 1.96577332e+02, 3.06063446e+02, 1.96577332e+02,
+       3.78224731e+02, 1.96577332e+02, 4.47897705e+02, 1.96577332e+02,
+       3.18505035e+02, 1.99065643e+02, 2.23948853e+02, 2.01553970e+02,
+       2.28925491e+02, 2.01553970e+02, 2.48832062e+02, 2.01553970e+02,
+       3.53341522e+02, 2.01553970e+02, 3.73248077e+02, 2.01553970e+02,
+       4.00619629e+02, 2.01553970e+02, 2.66250305e+02, 2.04042282e+02,
+       2.91133514e+02, 2.04042282e+02, 4.13061218e+02, 2.04042282e+02,
+       3.58318176e+02, 2.06530609e+02, 3.73248077e+02, 2.06530609e+02,
+       3.95642975e+02, 2.06530609e+02, 2.11507248e+02, 2.09018936e+02,
+       2.68738617e+02, 2.09018936e+02, 3.13528381e+02, 2.09018936e+02,
+       3.25970001e+02, 2.09018936e+02, 4.05596252e+02, 2.09018936e+02,
+       2.83668549e+02, 2.11507248e+02, 3.65783112e+02, 2.11507248e+02,
+       2.23948853e+02, 2.13995575e+02, 3.06063446e+02, 2.13995575e+02,
+       3.33434967e+02, 2.13995575e+02, 4.50386017e+02, 2.13995575e+02,
+       1.96577332e+02, 2.16483887e+02, 2.09018936e+02, 2.16483887e+02,
+       4.00619629e+02, 2.16483887e+02, 1.66717484e+02, 2.18972214e+02,
+       2.78691895e+02, 2.18972214e+02, 3.75736420e+02, 2.18972214e+02,
+       2.93621826e+02, 2.21460526e+02, 3.90666321e+02, 2.21460526e+02,
+       1.61740845e+02, 2.23948853e+02, 1.76670761e+02, 2.23948853e+02,
+       2.04042282e+02, 2.23948853e+02, 2.66250305e+02, 2.23948853e+02,
+       3.68271454e+02, 2.23948853e+02, 2.76203583e+02, 2.26437180e+02,
+       2.91133514e+02, 2.26437180e+02, 4.32967773e+02, 2.26437180e+02,
+       4.03107941e+02, 2.28925491e+02, 1.49299240e+02, 2.31413818e+02,
+       2.31413818e+02, 2.31413818e+02, 2.66250305e+02, 2.31413818e+02,
+       1.64229156e+02, 2.33902130e+02, 1.71694122e+02, 2.33902130e+02,
+       2.18972214e+02, 2.33902130e+02, 1.54275879e+02, 2.36390457e+02,
+       1.81647400e+02, 2.36390457e+02, 2.38878784e+02, 2.36390457e+02,
+       3.08551758e+02, 2.36390457e+02, 3.98131287e+02, 2.36390457e+02,
+       4.35456116e+02, 2.36390457e+02, 2.09018936e+02, 2.38878784e+02,
+       2.28925491e+02, 2.38878784e+02, 2.51320374e+02, 2.38878784e+02,
+       2.93621826e+02, 2.38878784e+02, 3.33434967e+02, 2.38878784e+02,
+       3.65783112e+02, 2.38878784e+02, 1.79159088e+02, 2.41367096e+02,
+       2.46343735e+02, 2.41367096e+02, 2.61273651e+02, 2.41367096e+02,
+       4.37944427e+02, 2.41367096e+02, 1.36857635e+02, 2.43855423e+02,
+       2.68738617e+02, 2.43855423e+02, 3.58318176e+02, 2.43855423e+02,
+       3.03575104e+02, 2.46343735e+02, 3.78224731e+02, 2.46343735e+02,
+       3.88178009e+02, 2.46343735e+02, 1.41834274e+02, 2.48832062e+02,
+       1.49299240e+02, 2.48832062e+02, 3.16016724e+02, 2.48832062e+02,
+       3.28458313e+02, 2.48832062e+02, 3.70759766e+02, 2.48832062e+02,
+       1.64229156e+02, 2.51320374e+02, 1.76670761e+02, 2.51320374e+02,
+       1.96577332e+02, 2.51320374e+02, 3.01086792e+02, 2.51320374e+02,
+       3.50853210e+02, 2.51320374e+02, 1.31880997e+02, 2.53808701e+02,
+       3.13528381e+02, 2.53808701e+02, 1.46810913e+02, 2.56297028e+02,
+       1.64229156e+02, 2.56297028e+02, 1.94089005e+02, 2.58785339e+02,
+       2.23948853e+02, 2.58785339e+02, 2.36390457e+02, 2.61273651e+02,
+       3.60806488e+02, 2.61273651e+02, 1.81647400e+02, 2.63761993e+02,
+       4.27991150e+02, 2.63761993e+02, 3.98131287e+02, 2.66250305e+02,
+       2.73715271e+02, 2.68738617e+02, 4.08084564e+02, 2.68738617e+02,
+       4.25502808e+02, 2.68738617e+02, 1.24416031e+02, 2.71226959e+02,
+       3.20993347e+02, 2.73715271e+02, 3.58318176e+02, 2.73715271e+02,
+       3.70759766e+02, 2.73715271e+02, 3.75736420e+02, 2.78691895e+02,
+       3.53341522e+02, 2.83668549e+02, 1.41834274e+02, 2.86156860e+02,
+       2.21460526e+02, 2.86156860e+02, 3.90666321e+02, 2.86156860e+02,
+       4.03107941e+02, 2.86156860e+02, 1.26904350e+02, 2.88645203e+02,
+       1.61740845e+02, 2.88645203e+02, 4.20526184e+02, 2.88645203e+02,
+       3.80713043e+02, 2.91133514e+02, 3.98131287e+02, 2.93621826e+02,
+       1.66717484e+02, 2.96110138e+02, 1.79159088e+02, 2.96110138e+02,
+       2.86156860e+02, 2.96110138e+02, 4.18037872e+02, 2.96110138e+02,
+       1.86624039e+02, 3.03575104e+02, 4.27991150e+02, 3.06063446e+02,
+       1.71694122e+02, 3.08551758e+02, 4.23014496e+02, 3.08551758e+02,
+       1.86624039e+02, 3.11040070e+02, 1.31880997e+02, 3.13528381e+02,
+       2.91133514e+02, 3.13528381e+02, 1.71694122e+02, 3.16016724e+02,
+       2.04042282e+02, 3.16016724e+02, 2.11507248e+02, 3.16016724e+02,
+       2.16483887e+02, 3.18505035e+02, 4.15549530e+02, 3.18505035e+02,
+       2.11507248e+02, 3.20993347e+02, 2.31413818e+02, 3.20993347e+02,
+       2.81180237e+02, 3.20993347e+02, 2.88645203e+02, 3.20993347e+02,
+       3.28458313e+02, 3.20993347e+02, 1.49299240e+02, 3.23481689e+02,
+       2.96110138e+02, 3.23481689e+02, 3.06063446e+02, 3.23481689e+02,
+       3.16016724e+02, 3.23481689e+02, 1.66717484e+02, 3.25970001e+02,
+       1.74182434e+02, 3.25970001e+02, 2.41367096e+02, 3.25970001e+02,
+       2.71226959e+02, 3.25970001e+02, 2.86156860e+02, 3.25970001e+02,
+       3.73248077e+02, 3.25970001e+02, 1.99065643e+02, 3.28458313e+02,
+       2.58785339e+02, 3.28458313e+02, 3.35923279e+02, 3.28458313e+02,
+       4.00619629e+02, 3.28458313e+02, 1.36857635e+02, 3.30946625e+02,
+       2.06530609e+02, 3.30946625e+02, 2.26437180e+02, 3.30946625e+02,
+       2.33902130e+02, 3.30946625e+02, 2.16483887e+02, 3.33434967e+02,
+       3.70759766e+02, 3.33434967e+02, 2.56297028e+02, 3.35923279e+02,
+       2.91133514e+02, 3.35923279e+02, 3.16016724e+02, 3.35923279e+02,
+       4.00619629e+02, 3.35923279e+02, 4.18037872e+02, 3.35923279e+02,
+       2.68738617e+02, 3.40899933e+02, 2.76203583e+02, 3.43388245e+02,
+       3.13528381e+02, 3.43388245e+02, 4.00619629e+02, 3.45876556e+02,
+       3.18505035e+02, 3.48364868e+02, 3.40899933e+02, 3.48364868e+02,
+       3.58318176e+02, 3.48364868e+02, 4.00619629e+02, 3.50853210e+02,
+       4.18037872e+02, 3.58318176e+02, 3.80713043e+02, 3.60806488e+02,
+       3.28458313e+02, 3.65783112e+02, 3.78224731e+02, 3.65783112e+02,
+       4.00619629e+02, 3.65783112e+02, 4.25502808e+02, 3.80713043e+02,
+       2.12004913e+02, 1.37355301e+02, 2.44850754e+02, 1.49299240e+02,
+       2.17976898e+02, 1.58257202e+02, 3.52346191e+02, 1.61243179e+02,
+       1.97074997e+02, 1.64229156e+02, 2.03046967e+02, 1.64229156e+02,
+       3.79220062e+02, 1.64229156e+02, 4.09079926e+02, 1.64229156e+02,
+       4.35953796e+02, 1.64229156e+02, 4.77757568e+02, 1.64229156e+02,
+       4.24009827e+02, 1.70201141e+02, 4.53869690e+02, 1.70201141e+02,
+       4.68799622e+02, 1.70201141e+02, 2.29920837e+02, 1.76173096e+02,
+       1.85131058e+02, 1.79159088e+02, 4.29981812e+02, 1.79159088e+02,
+       2.38878784e+02, 1.82145081e+02, 2.98598480e+02, 1.82145081e+02,
+       3.70262115e+02, 1.82145081e+02, 3.46374237e+02, 1.85131058e+02,
+       3.82206055e+02, 1.85131058e+02, 4.35953796e+02, 1.85131058e+02,
+       2.80682556e+02, 1.88117035e+02, 1.85131058e+02, 1.91103027e+02,
+       2.14990906e+02, 1.91103027e+02, 2.32906815e+02, 1.91103027e+02,
+       3.13528412e+02, 1.91103027e+02, 4.56855682e+02, 1.91103027e+02,
+       2.26934845e+02, 1.94089020e+02, 2.68738647e+02, 1.94089020e+02,
+       2.92626526e+02, 1.94089020e+02, 3.40402283e+02, 1.94089020e+02,
+       3.85192047e+02, 1.94089020e+02, 3.04570435e+02, 1.97074997e+02,
+       4.44911743e+02, 1.97074997e+02, 2.23948853e+02, 2.00060974e+02,
+       1.67215149e+02, 2.03046967e+02, 2.89640533e+02, 2.03046967e+02,
+       4.00121948e+02, 2.03046967e+02, 2.98598480e+02, 2.06032959e+02,
+       3.58318176e+02, 2.06032959e+02, 3.70262115e+02, 2.06032959e+02,
+       2.12004913e+02, 2.09018936e+02, 2.65752655e+02, 2.09018936e+02,
+       3.13528412e+02, 2.09018936e+02, 3.25472351e+02, 2.09018936e+02,
+       4.03107941e+02, 2.09018936e+02, 2.86654541e+02, 2.12004913e+02,
+       3.31444305e+02, 2.12004913e+02, 2.06032959e+02, 2.14990906e+02,
+       3.61304169e+02, 2.14990906e+02, 4.47897705e+02, 2.14990906e+02,
+       1.97074997e+02, 2.17976898e+02, 2.77696594e+02, 2.17976898e+02,
+       3.76234070e+02, 2.17976898e+02, 4.00121948e+02, 2.17976898e+02,
+       2.95612488e+02, 2.20962875e+02, 2.03046967e+02, 2.23948853e+02,
+       3.67276123e+02, 2.23948853e+02, 4.32967804e+02, 2.23948853e+02,
+       1.76173096e+02, 2.26934845e+02, 2.74710602e+02, 2.26934845e+02,
+       1.49299240e+02, 2.29920837e+02, 2.95612488e+02, 2.29920837e+02,
+       1.70201141e+02, 2.32906815e+02, 2.62766663e+02, 2.32906815e+02,
+       3.07556427e+02, 2.35892792e+02, 2.09018936e+02, 2.38878784e+02,
+       2.26934845e+02, 2.38878784e+02, 2.89640533e+02, 2.38878784e+02,
+       3.31444305e+02, 2.38878784e+02, 3.64290161e+02, 2.38878784e+02,
+       3.94149994e+02, 2.38878784e+02, 1.76173096e+02, 2.41864777e+02,
+       1.88117035e+02, 2.41864777e+02, 2.44850754e+02, 2.41864777e+02,
+       2.68738647e+02, 2.41864777e+02, 4.35953796e+02, 2.41864777e+02,
+       1.37355301e+02, 2.44850754e+02, 3.28458313e+02, 2.44850754e+02,
+       3.67276123e+02, 2.44850754e+02, 3.04570435e+02, 2.47836731e+02,
+       3.13528412e+02, 2.47836731e+02, 3.40402283e+02, 2.47836731e+02,
+       1.46313263e+02, 2.50822723e+02, 1.76173096e+02, 2.50822723e+02,
+       1.94089020e+02, 2.50822723e+02, 1.31383331e+02, 2.53808716e+02,
+       1.46313263e+02, 2.56794678e+02, 1.64229156e+02, 2.56794678e+02,
+       3.37416290e+02, 2.56794678e+02, 4.18037872e+02, 2.56794678e+02,
+       1.91103027e+02, 2.59780670e+02, 3.58318176e+02, 2.59780670e+02,
+       4.26995819e+02, 2.59780670e+02, 2.35892792e+02, 2.62766663e+02,
+       2.74710602e+02, 2.65752655e+02, 4.06093933e+02, 2.68738647e+02,
+       4.24009827e+02, 2.68738647e+02, 1.25411362e+02, 2.71724609e+02,
+       3.19500366e+02, 2.74710602e+02, 3.85192047e+02, 2.74710602e+02,
+       3.76234070e+02, 2.77696594e+02, 3.52346191e+02, 2.83668549e+02,
+       3.88178040e+02, 2.86654541e+02, 1.43327271e+02, 2.89640533e+02,
+       1.61243179e+02, 2.89640533e+02, 3.79220062e+02, 2.89640533e+02,
+       4.03107941e+02, 2.89640533e+02, 1.79159088e+02, 2.95612488e+02,
+       3.97135986e+02, 2.95612488e+02, 4.15051880e+02, 2.95612488e+02,
+       1.67215149e+02, 2.98598480e+02, 1.91103027e+02, 3.01584473e+02,
+       4.26995819e+02, 3.04570435e+02, 4.18037872e+02, 3.10542419e+02,
+       1.97074997e+02, 3.13528412e+02, 2.89640533e+02, 3.13528412e+02,
+       1.46313263e+02, 3.16514404e+02, 2.12004913e+02, 3.16514404e+02,
+       1.49299240e+02, 3.22486359e+02, 3.04570435e+02, 3.22486359e+02,
+       1.73187119e+02, 3.25472351e+02, 2.68738647e+02, 3.25472351e+02,
+       2.86654541e+02, 3.25472351e+02, 2.95612488e+02, 3.25472351e+02,
+       1.97074997e+02, 3.28458313e+02, 2.41864777e+02, 3.28458313e+02,
+       2.56794678e+02, 3.28458313e+02, 3.34430298e+02, 3.28458313e+02,
+       3.97135986e+02, 3.28458313e+02, 1.31383331e+02, 3.31444305e+02,
+       2.06032959e+02, 3.31444305e+02, 2.23948853e+02, 3.31444305e+02,
+       2.53808716e+02, 3.34430298e+02, 2.71724609e+02, 3.34430298e+02,
+       2.92626526e+02, 3.34430298e+02, 3.07556427e+02, 3.34430298e+02,
+       3.70262115e+02, 3.34430298e+02, 3.13528412e+02, 3.37416290e+02,
+       4.15051880e+02, 3.37416290e+02, 2.74710602e+02, 3.43388245e+02,
+       3.55332184e+02, 3.46374237e+02, 3.79220062e+02, 3.61304169e+02,
+       4.00121948e+02, 3.64290161e+02, 4.03107941e+02, 3.76234070e+02,
+       4.24009827e+02, 3.79220062e+02, 2.11407730e+02, 1.36160904e+02,
+       2.36490005e+02, 1.54076813e+02, 2.43656372e+02, 1.54076813e+02,
+       2.18574097e+02, 1.57660004e+02, 2.00658188e+02, 1.64826370e+02,
+       4.08482727e+02, 1.64826370e+02, 4.76563202e+02, 1.64826370e+02,
+       4.65813629e+02, 1.71992737e+02, 2.29323639e+02, 1.75575912e+02,
+       4.40731354e+02, 1.75575912e+02, 1.82742279e+02, 1.79159088e+02,
+       4.29981812e+02, 1.79159088e+02, 2.40073181e+02, 1.82742279e+02,
+       2.93820923e+02, 1.82742279e+02, 3.65484558e+02, 1.82742279e+02,
+       3.79817291e+02, 1.82742279e+02, 3.94149994e+02, 1.82742279e+02,
+       1.86325455e+02, 1.89908646e+02, 2.32906815e+02, 1.89908646e+02,
+       2.83071381e+02, 1.89908646e+02, 3.11736816e+02, 1.89908646e+02,
+       4.58647278e+02, 1.89908646e+02, 2.25740463e+02, 1.93491821e+02,
+       2.68738647e+02, 1.93491821e+02, 3.00987274e+02, 1.93491821e+02,
+       3.40402283e+02, 1.93491821e+02, 3.86983643e+02, 1.93491821e+02,
+       3.79817291e+02, 1.97074997e+02, 4.44314545e+02, 1.97074997e+02,
+       2.86654541e+02, 2.00658188e+02, 2.97404083e+02, 2.04241364e+02,
+       3.18903198e+02, 2.04241364e+02, 3.58318176e+02, 2.04241364e+02,
+       2.11407730e+02, 2.07824554e+02, 2.68738647e+02, 2.07824554e+02,
+       3.11736816e+02, 2.07824554e+02, 3.69067719e+02, 2.07824554e+02,
+       4.04899536e+02, 2.07824554e+02, 2.86654541e+02, 2.11407730e+02,
+       2.97404083e+02, 2.11407730e+02, 1.97074997e+02, 2.14990906e+02,
+       2.07824554e+02, 2.14990906e+02, 2.72321808e+02, 2.14990906e+02,
+       3.58318176e+02, 2.14990906e+02, 3.97733185e+02, 2.14990906e+02,
+       4.47897736e+02, 2.14990906e+02, 1.61243179e+02, 2.22157272e+02,
+       2.04241364e+02, 2.22157272e+02, 2.72321808e+02, 2.25740463e+02,
+       4.33565002e+02, 2.25740463e+02, 1.50493637e+02, 2.29323639e+02,
+       2.61572266e+02, 2.29323639e+02, 3.00987274e+02, 2.29323639e+02,
+       4.01316376e+02, 2.29323639e+02, 1.54076813e+02, 2.36490005e+02,
+       3.22486359e+02, 2.36490005e+02, 3.29652740e+02, 2.36490005e+02,
+       3.94149994e+02, 2.36490005e+02, 1.75575912e+02, 2.40073181e+02,
+       2.32906815e+02, 2.40073181e+02, 2.40073181e+02, 2.40073181e+02,
+       2.68738647e+02, 2.40073181e+02, 2.90237732e+02, 2.40073181e+02,
+       4.37148193e+02, 2.40073181e+02, 1.36160904e+02, 2.43656372e+02,
+       3.69067719e+02, 2.43656372e+02, 3.79817291e+02, 2.43656372e+02,
+       1.79159088e+02, 2.47239548e+02, 3.08153625e+02, 2.47239548e+02,
+       3.40402283e+02, 2.47239548e+02, 1.32577728e+02, 2.50822723e+02,
+       1.93491821e+02, 2.50822723e+02, 2.97404083e+02, 2.50822723e+02,
+       1.39744095e+02, 2.54405914e+02, 1.64826370e+02, 2.54405914e+02,
+       3.58318176e+02, 2.57989105e+02, 4.19232269e+02, 2.57989105e+02,
+       1.14661819e+02, 2.65155457e+02, 4.01316376e+02, 2.65155457e+02,
+       4.22815460e+02, 2.68738647e+02, 3.18903198e+02, 2.72321808e+02,
+       3.76234100e+02, 2.75904999e+02, 3.83400452e+02, 2.75904999e+02,
+       3.11736816e+02, 2.83071381e+02, 3.51151825e+02, 2.83071381e+02,
+       3.76234100e+02, 2.90237732e+02, 3.97733185e+02, 2.93820923e+02,
+       4.15649109e+02, 2.93820923e+02, 1.68409546e+02, 2.97404083e+02,
+       1.89908646e+02, 3.00987274e+02, 4.19232269e+02, 3.08153625e+02,
+       1.97074997e+02, 3.11736816e+02, 1.46910461e+02, 3.15320007e+02,
+       2.14990906e+02, 3.18903198e+02, 2.93820923e+02, 3.22486359e+02,
+       3.04570465e+02, 3.22486359e+02, 3.29652740e+02, 3.22486359e+02,
+       1.71992737e+02, 3.26069550e+02, 2.36490005e+02, 3.26069550e+02,
+       2.57989105e+02, 3.26069550e+02, 2.83071381e+02, 3.26069550e+02,
+       3.97733185e+02, 3.29652740e+02, 2.93820923e+02, 3.33235901e+02,
+       3.69067719e+02, 3.33235901e+02, 2.54405914e+02, 3.36819092e+02,
+       3.11736816e+02, 3.36819092e+02, 2.68738647e+02, 3.40402283e+02,
+       3.26069550e+02, 3.40402283e+02, 2.75904999e+02, 3.43985474e+02,
+       3.79817291e+02, 3.58318176e+02 ]
+keypoints: [ 366., 251., 31., 2.8541571044921875e+02,
+    1.8004997400566936e-04, 0, -1, 430., 385., 31.,
+    1.8296289062500000e+02, 2.5608087889850140e-04, 0, -1, 421., 381.,
+    31., 2.3781155395507812e+02, 2.4833605857565999e-04, 0, -1, 417.,
+    380., 31., 2.4993954467773438e+02, 4.8137045814655721e-04, 0, -1,
+    213., 137., 31., 1.9315652465820312e+02, 1.8050690414384007e-04, 0,
+    -1, 412., 380., 31., 2.6964505004882812e+02, 2.8769188793376088e-04,
+    0, -1, 421., 378., 31., 2.3037370300292969e+02,
+    3.7284294376149774e-04, 0, -1, 219., 139., 31.,
+    1.8927716064453125e+02, 2.3585508461110294e-04, 0, -1, 417., 378.,
+    31., 2.4620399475097656e+02, 6.6236295970156789e-04, 0, -1, 396.,
+    378., 31., 2.7374093627929688e+02, 3.1888185185380280e-04, 0, -1,
+    392., 377., 31., 2.7146557617187500e+02, 3.5050045698881149e-04, 0,
+    -1, 216., 140., 31., 1.8188301086425781e+02, 2.1777790971100330e-04,
+    0, -1, 387., 377., 31., 2.7461798095703125e+02,
+    2.6407814584672451e-04, 0, -1, 394., 376., 31.,
+    2.6866110229492188e+02, 4.1158654494211078e-04, 0, -1, 392., 375.,
+    31., 2.6879797363281250e+02, 2.8430070960894227e-04, 0, -1, 417.,
+    374., 31., 2.2843566894531250e+02, 3.5608466714620590e-04, 0, -1,
+    224., 141., 31., 6.8645853996276855e+00, 4.1050484287552536e-04, 0,
+    -1, 388., 374., 31., 2.7620989990234375e+02, 2.1249131532385945e-04,
+    0, -1, 371., 374., 31., 2.7977655029296875e+02,
+    2.1718442440032959e-04, 0, -1, 216., 142., 31.,
+    1.9635176086425781e+02, 1.8212271970696747e-04, 0, -1, 219., 142.,
+    31., 1.8545530700683594e+02, 2.1866401948500425e-04, 0, -1, 367.,
+    374., 31., 2.7594940185546875e+02, 3.3028901088982821e-04, 0, -1,
+    362., 373., 31., 2.7350588989257812e+02, 2.8574996395036578e-04, 0,
+    -1, 371., 372., 31., 2.7703475952148438e+02, 1.9978181808255613e-04,
+    0, -1, 221., 143., 31., 2.2544238281250000e+02,
+    2.8466415824368596e-04, 0, -1, 367., 371., 31.,
+    2.7635159301757812e+02, 2.0876261987723410e-04, 0, -1, 362., 371.,
+    31., 2.7523120117187500e+02, 2.6332639390602708e-04, 0, -1, 227.,
+    144., 31., 2.3209768676757812e+02, 1.8151338736061007e-04, 0, -1,
+    401., 367., 31., 1.2495741271972656e+02, 1.9744894234463573e-04, 0,
+    -1, 382., 367., 31., 3.2388766479492188e+02, 1.8828047905117273e-04,
+    0, -1, 224., 145., 31., 2.6912042236328125e+02,
+    3.3045906457118690e-04, 0, -1, 342., 367., 31.,
+    2.7668814086914062e+02, 2.4543699692003429e-04, 0, -1, 338., 367.,
+    31., 2.7374032592773438e+02, 2.5437460863031447e-04, 0, -1, 378.,
+    366., 31., 3.2650100708007812e+02, 1.8006001482717693e-04, 0, -1,
+    222., 146., 31., 2.5990408325195312e+02, 1.9242663984186947e-04, 0,
+    -1, 378., 364., 31., 2.8062530517578125e+01, 2.8969053528271616e-04,
+    0, -1, 322., 364., 31., 2.8089035034179688e+02,
+    1.9107350090052933e-04, 0, -1, 317., 363., 31.,
+    2.7605706787109375e+02, 2.3474564659409225e-04, 0, -1, 314., 363.,
+    31., 2.7643942260742188e+02, 2.3887134739197791e-04, 0, -1, 239.,
+    148., 31., 5.5301803588867188e+01, 2.1923554595559835e-04, 0, -1,
+    420., 362., 31., 1.8183424377441406e+02, 2.4213307187892497e-04, 0,
+    -1, 416., 362., 31., 1.9320503234863281e+02, 2.5065834051929414e-04,
+    0, -1, 401., 362., 31., 1.3521139526367188e+02,
+    3.7597134360112250e-04, 0, -1, 380., 361., 31.,
+    1.6736539840698242e+01, 2.6384470402263105e-04, 0, -1, 383., 360.,
+    31., 1.3539625167846680e+01, 2.5851681130006909e-04, 0, -1, 294.,
+    360., 31., 2.7950097656250000e+02, 3.1103924266062677e-04, 0, -1,
+    416., 359., 31., 1.9271385192871094e+02, 3.8292692624963820e-04, 0,
+    -1, 291., 359., 31., 2.7994830322265625e+02, 2.0474272605497390e-04,
+    0, -1, 403., 358., 31., 1.9474111938476562e+02,
+    2.1760487288702279e-04, 0, -1, 380., 358., 31.,
+    4.0849013328552246e+00, 2.3782449716236442e-04, 0, -1, 276., 357.,
+    31., 2.9675680541992188e+02, 1.9577736384235322e-04, 0, -1, 382.,
+    356., 31., 3.5503475952148438e+02, 2.3746069928165525e-04, 0, -1,
+    272., 356., 31., 3.0849124145507812e+02, 2.1989816741552204e-04, 0,
+    -1, 419., 355., 31., 1.8130163574218750e+02, 3.0999036971479654e-04,
+    0, -1, 416., 355., 31., 1.8479714965820312e+02,
+    2.8618602664209902e-04, 0, -1, 268., 355., 31.,
+    1.4609124755859375e+02, 1.8489458307158202e-04, 0, -1, 380., 354.,
+    31., 3.3845410156250000e+02, 2.1072219533380121e-04, 0, -1, 306.,
+    353., 31., 2.8059561157226562e+02, 2.0756188314408064e-04, 0, -1,
+    202., 153., 31., 2.3410859680175781e+02, 2.2061815252527595e-04, 0,
+    -1, 251., 353., 31., 2.8290081787109375e+02, 2.7428986504673958e-04,
+    0, -1, 402., 352., 31., 2.4645272827148438e+02,
+    2.1829779143445194e-04, 0, -1, 382., 352., 31.,
+    3.2639282226562500e+02, 2.5568905402906239e-04, 0, -1, 247., 352.,
+    31., 2.6786791992187500e+02, 2.8764540911652148e-04, 0, -1, 341.,
+    351., 31., 2.7441604614257812e+02, 2.9504529084078968e-04, 0, -1,
+    243., 351., 31., 2.6877172851562500e+02, 1.9258268002886325e-04, 0,
+    -1, 382., 350., 31., 3.2419979858398438e+02, 2.7082083397544920e-04,
+    0, -1, 381., 348., 31., 3.0975503540039062e+02,
+    3.2948868465609848e-04, 0, -1, 340., 348., 31.,
+    2.8994711303710938e+02, 3.5091477911919355e-04, 0, -1, 316., 348.,
+    31., 2.1925999450683594e+02, 1.9047045498155057e-04, 0, -1, 314.,
+    348., 31., 2.3928656005859375e+02, 2.2954393352847546e-04, 0, -1,
+    200., 156., 31., 2.2885305786132812e+02, 4.1341569158248603e-04, 0,
+    -1, 203., 156., 31., 2.3366111755371094e+02, 2.6536066434346139e-04,
+    0, -1, 227., 348., 31., 2.9929220581054688e+02,
+    2.0438905630726367e-04, 0, -1, 223., 348., 31.,
+    2.8507095336914062e+02, 2.7189514366909862e-04, 0, -1, 223., 156.,
+    31., 1.3185658264160156e+02, 1.9628273730631918e-04, 0, -1, 331.,
+    347., 31., 2.7280508422851562e+02, 4.4259714195504785e-04, 0, -1,
+    263., 347., 31., 8.2072357177734375e+01, 1.8076629203278571e-04, 0,
+    -1, 225., 157., 31., 1.1788008117675781e+02, 1.8903365707956254e-04,
+    0, -1, 382., 346., 31., 2.9962094116210938e+02,
+    2.3853422317188233e-04, 0, -1, 314., 346., 31.,
+    2.0808872985839844e+02, 3.0625986983068287e-04, 0, -1, 281., 346.,
+    31., 1.0360227584838867e+01, 2.5744707090780139e-04, 0, -1, 336.,
+    345., 31., 2.9746105957031250e+02, 2.3138997494243085e-04, 0, -1,
+    332., 345., 31., 2.8144085693359375e+02, 3.4515329753048718e-04, 0,
+    -1, 279., 345., 31., 8.1809539794921875e+00, 2.7646217495203018e-04,
+    0, -1, 208., 345., 31., 2.8596124267578125e+02,
+    1.9603181863203645e-04, 0, -1, 381., 344., 31.,
+    2.8056341552734375e+02, 3.0454830266535282e-04, 0, -1, 328., 344.,
+    31., 2.8223132324218750e+02, 1.9369729852769524e-04, 0, -1, 284.,
+    344., 31., 4.4078273773193359e+01, 2.7113553369417787e-04, 0, -1,
+    204., 344., 31., 2.8012365722656250e+02, 2.0622820011340082e-04, 0,
+    -1, 200., 344., 31., 2.7746585083007812e+02, 1.8169742543250322e-04,
+    0, -1, 323., 343., 31., 1.9176969909667969e+02,
+    1.8617314344737679e-04, 0, -1, 314., 343., 31.,
+    1.6327806091308594e+02, 1.8824594735633582e-04, 0, -1, 281., 343.,
+    31., 2.4340263366699219e+01, 4.3656997149810195e-04, 0, -1, 419.,
+    342., 31., 1.8222865295410156e+02, 2.5314002414233983e-04, 0, -1,
+    416., 342., 31., 1.8633226013183594e+02, 3.0720201903022826e-04, 0,
+    -1, 320., 342., 31., 1.7370788574218750e+02, 2.3966180742718279e-04,
+    0, -1, 265., 341., 31., 2.1353126525878906e+01,
+    2.6056528440676630e-04, 0, -1, 186., 341., 31.,
+    2.8407849121093750e+02, 1.9107230764348060e-04, 0, -1, 199., 161.,
+    31., 1.9764724731445312e+02, 4.6924484195187688e-04, 0, -1, 184.,
+    341., 31., 2.8480700683593750e+02, 2.8075053705833852e-04, 0, -1,
+    262., 340., 31., 1.6095516204833984e+01, 2.6493766927160323e-04, 0,
+    -1, 182., 340., 31., 2.9023748779296875e+02, 2.1014774392824620e-04,
+    0, -1, 415., 339., 31., 1.8742114257812500e+02,
+    3.5598184331320226e-04, 0, -1, 381., 339., 31.,
+    2.3982504272460938e+02, 1.9946040993090719e-04, 0, -1, 300., 339.,
+    31., 3.0667263031005859e+01, 2.0096002845093608e-04, 0, -1, 290.,
+    339., 31., 3.9175315856933594e+01, 2.4564459454268217e-04, 0, -1,
+    272., 339., 31., 3.5035028076171875e+02, 2.2460805485025048e-04, 0,
+    -1, 270., 339., 31., 3.4678652954101562e+02, 3.4485376090742648e-04,
+    0, -1, 265., 338., 31., 3.2723577880859375e+02,
+    3.9325759280472994e-04, 0, -1, 299., 337., 31.,
+    5.1793014526367188e+01, 3.5364349605515599e-04, 0, -1, 203., 163.,
+    31., 1.6038755798339844e+02, 2.1353039483074099e-04, 0, -1, 288.,
+    337., 31., 3.5868473052978516e+01, 2.1838782413396984e-04, 0, -1,
+    269., 337., 31., 3.1334307861328125e+02, 3.0909891938790679e-04, 0,
+    -1, 419., 336., 31., 1.7985159301757812e+02, 2.3981196864042431e-04,
+    0, -1, 381., 336., 31., 2.2774018859863281e+02,
+    2.5066116359084845e-04, 0, -1, 415., 335., 31.,
+    1.8789038085937500e+02, 2.6249265647493303e-04, 0, -1, 399., 335.,
+    31., 2.3141625976562500e+02, 2.1352077601477504e-04, 0, -1, 301.,
+    335., 31., 6.6698226928710938e+01, 4.3825636385008693e-04, 0, -1,
+    265., 335., 31., 2.9878088378906250e+02, 5.9309147763997316e-04, 0,
+    -1, 259., 335., 31., 2.9331817626953125e+02, 2.2401667956728488e-04,
+    0, -1, 219., 335., 31., 1.0156559753417969e+02,
+    2.2186698333825916e-04, 0, -1, 200., 164., 31.,
+    1.7481721496582031e+02, 2.5876483414322138e-04, 0, -1, 379., 334.,
+    31., 2.1258660888671875e+02, 2.2880079632159323e-04, 0, -1, 226.,
+    334., 31., 1.0384925079345703e+02, 2.1599243336822838e-04, 0, -1,
+    416., 333., 31., 1.8100788879394531e+02, 2.0011402375530452e-04, 0,
+    -1, 263., 333., 31., 2.8867352294921875e+02, 2.9727997025474906e-04,
+    0, -1, 245., 333., 31., 2.9591958618164062e+02,
+    2.5272814673371613e-04, 0, -1, 230., 333., 31.,
+    1.0678242492675781e+02, 2.2983543749433011e-04, 0, -1, 218., 333.,
+    31., 1.0236621093750000e+02, 3.4753562067635357e-04, 0, -1, 399.,
+    332., 31., 2.4492742919921875e+02, 2.3743187193758786e-04, 0, -1,
+    380., 332., 31., 2.0392831420898438e+02, 1.8693553283810616e-04, 0,
+    -1, 301., 332., 31., 5.5864181518554688e+01, 2.8796243714168668e-04,
+    0, -1, 261., 332., 31., 2.8623083496093750e+02,
+    2.8547013062052429e-04, 0, -1, 258., 332., 31.,
+    2.8799966430664062e+02, 2.5503645883873105e-04, 0, -1, 255., 332.,
+    31., 2.9286746215820312e+02, 4.8100249841809273e-04, 0, -1, 243.,
+    332., 31., 2.9925292968750000e+02, 2.0529664470814168e-04, 0, -1,
+    203., 332., 31., 1.0064601135253906e+02, 3.3317290944978595e-04, 0,
+    -1, 401., 331., 31., 2.5824511718750000e+02, 2.0327612583059818e-04,
+    0, -1, 292., 331., 31., 1.6365618896484375e+02,
+    2.3978533863555640e-04, 0, -1, 251., 331., 31.,
+    2.9221371459960938e+02, 4.9093435518443584e-04, 0, -1, 232., 331.,
+    31., 9.7489135742187500e+01, 2.2049578547012061e-04, 0, -1, 223.,
+    331., 31., 9.9417701721191406e+01, 2.1260345238260925e-04, 0, -1,
+    200., 331., 31., 1.0402758026123047e+02, 2.7033782680518925e-04, 0,
+    -1, 289., 330., 31., 2.3549017333984375e+02, 2.6891237939707935e-04,
+    0, -1, 256., 330., 31., 2.8969885253906250e+02,
+    6.4721138915047050e-04, 0, -1, 411., 166., 31.,
+    1.3090689086914062e+02, 2.5853345869109035e-04, 0, -1, 227., 330.,
+    31., 1.0601760101318359e+02, 1.8204067600890994e-04, 0, -1, 213.,
+    330., 31., 1.0862316131591797e+02, 4.9227051204070449e-04, 0, -1,
+    203., 330., 31., 1.0163941955566406e+02, 6.5762083977460861e-04, 0,
+    -1, 173., 330., 31., 1.2241291809082031e+02, 1.8020511197391897e-04,
+    0, -1, 293., 329., 31., 2.4638101196289062e+02,
+    2.9455614276230335e-04, 0, -1, 287., 329., 31.,
+    2.4426799011230469e+02, 2.0259041048120707e-04, 0, -1, 281., 329.,
+    31., 2.4194590759277344e+02, 1.9795970001723617e-04, 0, -1, 279.,
+    329., 31., 2.4642568969726562e+02, 2.0237431454006582e-04, 0, -1,
+    253., 329., 31., 2.8922546386718750e+02, 6.5891299163922668e-04, 0,
+    -1, 250., 329., 31., 2.9073797607421875e+02, 5.4888101294636726e-04,
+    0, -1, 222., 329., 31., 9.2481086730957031e+01,
+    2.0299840252846479e-04, 0, -1, 170., 329., 31.,
+    1.3292578125000000e+02, 2.9959343373775482e-04, 0, -1, 168., 329.,
+    31., 1.3945249938964844e+02, 2.5981952785514295e-04, 0, -1, 378.,
+    328., 31., 1.6907041931152344e+02, 1.9564374815672636e-04, 0, -1,
+    209., 328., 31., 1.1017781829833984e+02, 2.7932177181355655e-04, 0,
+    -1, 205., 328., 31., 1.0523035430908203e+02, 6.0922355623915792e-04,
+    0, -1, 400., 327., 31., 2.4494268798828125e+02,
+    2.1999719319865108e-04, 0, -1, 278., 327., 31.,
+    2.4401004028320312e+02, 1.9303776207379997e-04, 0, -1, 413., 168.,
+    31., 1.2262852478027344e+02, 2.1199186448939145e-04, 0, -1, 272.,
+    327., 31., 2.5967294311523438e+02, 7.0265098474919796e-04, 0, -1,
+    231., 327., 31., 2.8796121215820312e+02, 3.0386672005988657e-04, 0,
+    -1, 211., 327., 31., 1.2376006317138672e+02, 4.5912689529359341e-04,
+    0, -1, 167., 327., 31., 1.4324740600585938e+02,
+    3.0310745933093131e-04, 0, -1, 281., 326., 31.,
+    2.4412304687500000e+02, 2.3079413222149014e-04, 0, -1, 203., 326.,
+    31., 1.1608281707763672e+02, 2.0532010239548981e-04, 0, -1, 172.,
+    326., 31., 1.3249279785156250e+02, 4.2430660687386990e-04, 0, -1,
+    473., 169., 31., 1.3767915344238281e+02, 2.4640376796014607e-04, 0,
+    -1, 380., 325., 31., 1.4799388122558594e+02, 2.9310272657312453e-04,
+    0, -1, 303., 325., 31., 3.1596136474609375e+02,
+    2.5110517162829638e-04, 0, -1, 275., 325., 31.,
+    2.3802929687500000e+02, 2.6185662136413157e-04, 0, -1, 271., 325.,
+    31., 2.5200245666503906e+02, 6.4317480428144336e-04, 0, -1, 233.,
+    325., 31., 2.9012170410156250e+02, 3.2717440626583993e-04, 0, -1,
+    211., 325., 31., 2.4807510375976562e+02, 4.9422105075791478e-04, 0,
+    -1, 458., 170., 31., 1.5342437744140625e+02, 4.5782563393004239e-04,
+    0, -1, 195., 325., 31., 8.9226486206054688e+01,
+    2.7044623857364058e-04, 0, -1, 378., 324., 31.,
+    1.3904884338378906e+02, 2.3946567671373487e-04, 0, -1, 307., 324.,
+    31., 6.1195003509521484e+01, 1.9159703515470028e-04, 0, -1, 215.,
+    324., 31., 2.7096038818359375e+02, 2.6558240642771125e-04, 0, -1,
+    304., 323., 31., 2.8280374145507812e+02, 2.8314028168097138e-04, 0,
+    -1, 453., 171., 31., 1.2033665466308594e+02, 3.6673722206614912e-04,
+    0, -1, 469., 171., 31., 5.2757591247558594e+01,
+    4.0157453622668982e-04, 0, -1, 418., 322., 31.,
+    1.7994332885742188e+02, 3.4352572401985526e-04, 0, -1, 415., 322.,
+    31., 1.8924128723144531e+02, 3.8308143848553300e-04, 0, -1, 374.,
+    322., 31., 1.2875746154785156e+02, 2.0179925195407122e-04, 0, -1,
+    436., 172., 31., 3.1326522827148438e+02, 3.6315794568508863e-04, 0,
+    -1, 456., 172., 31., 1.6452424621582031e+02, 4.5462962589226663e-04,
+    0, -1, 462., 172., 31., 1.5211189270019531e+02,
+    2.1972550894133747e-04, 0, -1, 236., 322., 31.,
+    2.9134176635742188e+02, 2.2859238379169255e-04, 0, -1, 232., 322.,
+    31., 2.8855673217773438e+02, 5.7539867702871561e-04, 0, -1, 292.,
+    321., 31., 2.3658355712890625e+02, 3.0554897966794670e-04, 0, -1,
+    289., 321., 31., 2.3566545104980469e+02, 1.8819358956534415e-04, 0,
+    -1, 225., 321., 31., 2.8548248291015625e+02, 7.4856373248621821e-04,
+    0, -1, 379., 320., 31., 1.3423886108398438e+02,
+    2.0159689302090555e-04, 0, -1, 376., 320., 31.,
+    1.2815051269531250e+02, 1.9308221817482263e-04, 0, -1, 454., 173.,
+    31., 1.7543278503417969e+02, 3.6648230161517859e-04, 0, -1, 294.,
+    320., 31., 2.2927061462402344e+02, 3.5787941305898130e-04, 0, -1,
+    215., 320., 31., 2.7705145263671875e+02, 1.8577072478365153e-04, 0,
+    -1, 228., 319., 31., 2.8644479370117188e+02, 5.1580666331574321e-04,
+    0, -1, 418., 318., 31., 1.5980767822265625e+02,
+    5.1500706467777491e-04, 0, -1, 414., 318., 31.,
+    1.5263789367675781e+02, 7.4328528717160225e-04, 0, -1, 294., 318.,
+    31., 2.1755938720703125e+02, 2.1647670655511320e-04, 0, -1, 225.,
+    318., 31., 2.8537872314453125e+02, 6.6070957109332085e-04, 0, -1,
+    148., 318., 31., 7.1743026733398438e+01, 2.1393848874140531e-04, 0,
+    -1, 409., 317., 31., 1.1553491210937500e+02, 2.0725421200040728e-04,
+    0, -1, 221., 317., 31., 2.8258590698242188e+02,
+    2.3536432127002627e-04, 0, -1, 209., 317., 31.,
+    2.7684591674804688e+02, 3.0313871684484184e-04, 0, -1, 411., 316.,
+    31., 1.1769738769531250e+02, 5.0731253577396274e-04, 0, -1, 207.,
+    316., 31., 2.7736239624023438e+02, 4.3659645598381758e-04, 0, -1,
+    166., 316., 31., 1.6787425231933594e+02, 4.4399203034117818e-04, 0,
+    -1, 418., 315., 31., 1.4804226684570312e+02, 1.8553812697064131e-04,
+    0, -1, 414., 315., 31., 1.3142654418945312e+02,
+    4.1329828673042357e-04, 0, -1, 146., 315., 31.,
+    9.6108184814453125e+01, 2.6890469598583877e-04, 0, -1, 409., 314.,
+    31., 1.1065659332275391e+02, 2.1553004626184702e-04, 0, -1, 392.,
+    314., 31., 9.7535415649414062e+01, 2.6765305665321648e-04, 0, -1,
+    389., 314., 31., 8.7739654541015625e+01, 2.3792324645910412e-04, 0,
+    -1, 296., 314., 31., 1.8913475036621094e+02, 3.4338992554694414e-04,
+    0, -1, 237., 177., 31., 1.9709509611129761e+00,
+    3.1575022148899734e-04, 0, -1, 189., 314., 31.,
+    3.0297106933593750e+02, 2.1834185463376343e-04, 0, -1, 383., 313.,
+    31., 8.6904205322265625e+01, 1.8641843053046614e-04, 0, -1, 146.,
+    313., 31., 7.5572906494140625e+01, 2.2394311963580549e-04, 0, -1,
+    192., 312., 31., 2.9995278930664062e+02, 2.9640918364748359e-04, 0,
+    -1, 190., 312., 31., 3.0215441894531250e+02, 2.3848807904869318e-04,
+    0, -1, 469., 177., 31., 2.0542633056640625e+02,
+    3.0684852390550077e-04, 0, -1, 392., 311., 31.,
+    9.7708259582519531e+01, 2.5114801246672869e-04, 0, -1, 234., 178.,
+    31., 3.5161907958984375e+02, 4.5203120680525899e-04, 0, -1, 146.,
+    311., 31., 4.3056411743164062e+01, 2.8578750789165497e-04, 0, -1,
+    388., 310., 31., 1.0049657440185547e+02, 2.3642661108169705e-04, 0,
+    -1, 384., 310., 31., 1.0181316375732422e+02, 2.6349068502895534e-04,
+    0, -1, 366., 310., 31., 8.5310363769531250e+01,
+    2.5054338038899004e-04, 0, -1, 299., 310., 31.,
+    1.8305505371093750e+02, 2.0224163017701358e-04, 0, -1, 297., 310.,
+    31., 1.6636561584472656e+02, 2.0862546807620674e-04, 0, -1, 466.,
+    178., 31., 1.6244567871093750e+02, 1.9480893388390541e-04, 0, -1,
+    189., 310., 31., 3.0526535034179688e+02, 3.0550526571460068e-04, 0,
+    -1, 185., 179., 31., 2.3764961242675781e+02, 2.4467005277983844e-04,
+    0, -1, 368., 309., 31., 9.3549781799316406e+01,
+    2.2059744514990598e-04, 0, -1, 362., 309., 31.,
+    1.0183359527587891e+02, 2.8390646912157536e-04, 0, -1, 359., 308.,
+    31., 1.0563219451904297e+02, 3.5414675949141383e-04, 0, -1, 186.,
+    308., 31., 3.0969168090820312e+02, 2.3728077940177172e-04, 0, -1,
+    171., 308., 31., 2.0694485473632812e+02, 2.0155579841230065e-04, 0,
+    -1, 366., 307., 31., 9.4493766784667969e+01, 2.3815504391677678e-04,
+    0, -1, 362., 306., 31., 1.0091304016113281e+02,
+    2.1634751465171576e-04, 0, -1, 384., 180., 31.,
+    1.9976849365234375e+02, 3.2522325636819005e-04, 0, -1, 386., 180.,
+    31., 2.1273095703125000e+02, 3.2165396260097623e-04, 0, -1, 358.,
+    306., 31., 1.0660655975341797e+02, 2.5771022774279118e-04, 0, -1,
+    341., 306., 31., 8.7576545715332031e+01, 2.3650805815123022e-04, 0,
+    -1, 145., 306., 31., 3.5887930297851562e+02, 2.9599611298181117e-04,
+    0, -1, 184., 305., 31., 3.1481781005859375e+02,
+    3.2498943619430065e-04, 0, -1, 432., 180., 31.,
+    1.4667860412597656e+02, 2.3837623302824795e-04, 0, -1, 180., 304.,
+    31., 3.1241595458984375e+02, 3.7534351577050984e-04, 0, -1, 466.,
+    180., 31., 1.4374125671386719e+02, 2.2974706371314824e-04, 0, -1,
+    170., 304., 31., 2.2957919311523438e+02, 2.6397625333629549e-04, 0,
+    -1, 146., 304., 31., 3.3582409667968750e+02, 2.0429976575542241e-04,
+    0, -1, 341., 303., 31., 9.3823043823242188e+01,
+    2.0880281226709485e-04, 0, -1, 233., 181., 31.,
+    3.5196054077148438e+02, 5.6651461636647582e-04, 0, -1, 337., 303.,
+    31., 9.9216270446777344e+01, 2.7858617249876261e-04, 0, -1, 320.,
+    303., 31., 9.0838317871093750e+01, 2.1254496823530644e-04, 0, -1,
+    417., 302., 31., 1.1057952880859375e+02, 2.1579609892796725e-04, 0,
+    -1, 375., 181., 31., 1.7665356445312500e+02, 2.5541722425259650e-04,
+    0, -1, 437., 181., 31., 1.1301279449462891e+02,
+    2.2897988674230874e-04, 0, -1, 333., 302., 31.,
+    1.0114958953857422e+02, 2.3888442956376821e-04, 0, -1, 316., 302.,
+    31., 9.3986213684082031e+01, 2.8194166952744126e-04, 0, -1, 312.,
+    302., 31., 1.1184677886962891e+02, 2.2216138313524425e-04, 0, -1,
+    170., 302., 31., 2.3957293701171875e+02, 2.0799595222342759e-04, 0,
+    -1, 235., 182., 31., 3.5823965454101562e+02, 4.6970936818979681e-04,
+    0, -1, 179., 301., 31., 3.1257891845703125e+02,
+    8.9187914272770286e-04, 0, -1, 421., 300., 31.,
+    1.2477304077148438e+02, 3.2720412127673626e-04, 0, -1, 415., 300.,
+    31., 1.0318630218505859e+02, 3.5717798164114356e-04, 0, -1, 320.,
+    300., 31., 9.7220687866210938e+01, 2.0976457744836807e-04, 0, -1,
+    181., 300., 31., 3.1931771850585938e+02, 6.8471237318590283e-04, 0,
+    -1, 380., 182., 31., 1.8648292541503906e+02, 3.8931568269617856e-04,
+    0, -1, 384., 182., 31., 1.9618975830078125e+02,
+    3.2309308880940080e-04, 0, -1, 387., 182., 31.,
+    2.1375073242187500e+02, 1.9136315677314997e-04, 0, -1, 177., 300.,
+    31., 3.0760488891601562e+02, 8.5360993398353457e-04, 0, -1, 396.,
+    299., 31., 1.0695870208740234e+02, 2.4627178208902478e-04, 0, -1,
+    316., 299., 31., 9.8100059509277344e+01, 2.3582746507599950e-04, 0,
+    -1, 312., 299., 31., 1.0542681121826172e+02, 2.4011175264604390e-04,
+    0, -1, 295., 299., 31., 8.4658683776855469e+01,
+    2.0620429131668061e-04, 0, -1, 175., 299., 31.,
+    2.9917556762695312e+02, 8.5595721611753106e-04, 0, -1, 468., 182.,
+    31., 1.7484867858886719e+02, 1.9451366097200662e-04, 0, -1, 172.,
+    299., 31., 2.7850869750976562e+02, 5.8520637685433030e-04, 0, -1,
+    162., 299., 31., 1.9968440246582031e+02, 2.8347727493382990e-04, 0,
+    -1, 417., 298., 31., 1.0424327087402344e+02, 8.8603683980181813e-04,
+    0, -1, 392., 298., 31., 1.0058141326904297e+02,
+    2.0788716210518032e-04, 0, -1, 291., 298., 31.,
+    9.6764068603515625e+01, 2.5802126037888229e-04, 0, -1, 423., 297.,
+    31., 1.3213957214355469e+02, 2.1420318807940930e-04, 0, -1, 420.,
+    297., 31., 1.1282711791992188e+02, 6.4544175984337926e-04, 0, -1,
+    399., 297., 31., 1.0936354064941406e+02, 3.2911810558289289e-04, 0,
+    -1, 286., 297., 31., 1.1146369171142578e+02, 2.2899695613887161e-04,
+    0, -1, 171., 297., 31., 2.7261953735351562e+02,
+    7.5581186683848500e-04, 0, -1, 411., 296., 31.,
+    1.0031962585449219e+02, 3.9242210914380848e-04, 0, -1, 379., 184.,
+    31., 1.8418872070312500e+02, 7.8465597471222281e-04, 0, -1, 390.,
+    296., 31., 9.4924095153808594e+01, 2.3188283375930041e-04, 0, -1,
+    295., 296., 31., 9.4616775512695312e+01, 2.0282827608752996e-04, 0,
+    -1, 394., 295., 31., 1.0442562866210938e+02, 4.0913510019890964e-04,
+    0, -1, 291., 295., 31., 9.9512374877929688e+01,
+    2.0252844842616469e-04, 0, -1, 287., 295., 31.,
+    1.0695024108886719e+02, 2.5584254763089120e-04, 0, -1, 269., 295.,
+    31., 7.3247665405273438e+01, 2.4905553436838090e-04, 0, -1, 233.,
+    185., 31., 3.5687951660156250e+02, 4.6103989006951451e-04, 0, -1,
+    173., 295., 31., 2.9219641113281250e+02, 8.4836175665259361e-04, 0,
+    -1, 171., 295., 31., 2.7740414428710938e+02, 6.7826989106833935e-04,
+    0, -1, 169., 295., 31., 2.5897906494140625e+02,
+    6.8446394288912416e-04, 0, -1, 144., 295., 31.,
+    2.9191693115234375e+02, 2.4041385040618479e-04, 0, -1, 398., 294.,
+    31., 1.1190650939941406e+02, 6.4499781001359224e-04, 0, -1, 376.,
+    185., 31., 1.8320051574707031e+02, 5.3145887795835733e-04, 0, -1,
+    369., 294., 31., 9.8896820068359375e+01, 3.7694408092647791e-04, 0,
+    -1, 442., 185., 31., 2.8914752197265625e+02, 2.3314308782573789e-04,
+    0, -1, 445., 185., 31., 2.8009442138671875e+02,
+    3.0796360806562006e-04, 0, -1, 365., 294., 31.,
+    1.0032174682617188e+02, 2.8519020997919142e-04, 0, -1, 265., 294.,
+    31., 9.7951301574707031e+01, 3.0067027546465397e-04, 0, -1, 261.,
+    294., 31., 9.8097930908203125e+01, 2.1722739620599896e-04, 0, -1,
+    421., 293., 31., 1.2336479187011719e+02, 2.3767213860992342e-04, 0,
+    -1, 372., 293., 31., 9.7826560974121094e+01, 2.9486746643669903e-04,
+    0, -1, 167., 293., 31., 2.4989831542968750e+02,
+    4.5479650725610554e-04, 0, -1, 416., 292., 31.,
+    8.8197952270507812e+01, 3.3819890813902020e-04, 0, -1, 410., 292.,
+    31., 1.3102027893066406e+02, 3.7493478157557547e-04, 0, -1, 407.,
+    292., 31., 1.3732159423828125e+02, 5.5603479268029332e-04, 0, -1,
+    404., 292., 31., 1.4002476501464844e+02, 7.7877426519989967e-04, 0,
+    -1, 377., 292., 31., 9.6277511596679688e+01, 2.5400723097845912e-04,
+    0, -1, 363., 292., 31., 1.0000423431396484e+02,
+    2.9048617579974234e-04, 0, -1, 448., 186., 31.,
+    2.6859970092773438e+02, 3.0255989986471832e-04, 0, -1, 269., 292.,
+    31., 9.3382431030273438e+01, 2.5124003877863288e-04, 0, -1, 165.,
+    292., 31., 2.3647296142578125e+02, 2.0706241775769740e-04, 0, -1,
+    235., 187., 31., 4.1805477142333984e+00, 3.8336272700689733e-04, 0,
+    -1, 161., 292., 31., 2.1913714599609375e+02, 2.0151383068878204e-04,
+    0, -1, 280., 187., 31., 2.4324243164062500e+02,
+    2.3001142835710198e-04, 0, -1, 370., 291., 31.,
+    1.0050301361083984e+02, 5.0858868053182960e-04, 0, -1, 366., 291.,
+    31., 9.7214042663574219e+01, 4.6172941802069545e-04, 0, -1, 374.,
+    187., 31., 1.7800311279296875e+02, 3.5424574161879718e-04, 0, -1,
+    378., 187., 31., 1.7843011474609375e+02, 2.9979372629895806e-04, 0,
+    -1, 265., 291., 31., 9.8408889770507812e+01, 2.5463430210947990e-04,
+    0, -1, 261., 291., 31., 1.0012564086914062e+02,
+    2.2924072982277721e-04, 0, -1, 246., 291., 31.,
+    9.1035934448242188e+01, 2.2666754375677556e-04, 0, -1, 418., 290.,
+    31., 2.9674345016479492e+01, 5.5250106379389763e-04, 0, -1, 411.,
+    290., 31., 1.9206408691406250e+02, 4.5922733261249959e-04, 0, -1,
+    144., 290., 31., 2.9040243530273438e+02, 3.2080590608529747e-04, 0,
+    -1, 423., 289., 31., 2.1780534362792969e+02, 2.1522199676837772e-04,
+    0, -1, 401., 289., 31., 1.5553253173828125e+02,
+    4.7950405860319734e-04, 0, -1, 342., 289., 31.,
+    1.1076595306396484e+02, 2.4514205870218575e-04, 0, -1, 276., 188.,
+    31., 2.2869598388671875e+02, 4.8013660125434399e-04, 0, -1, 240.,
+    289., 31., 9.8826225280761719e+01, 3.9980476140044630e-04, 0, -1,
+    141., 289., 31., 2.6048831176757812e+02, 2.4463006411679089e-04, 0,
+    -1, 330., 188., 31., 2.9736730957031250e+02, 2.0607480837497860e-04,
+    0, -1, 369., 188., 31., 1.7781065368652344e+02,
+    4.5427118311636150e-04, 0, -1, 420., 288., 31.,
+    2.6885745239257812e+02, 5.4196169367060065e-04, 0, -1, 417., 288.,
+    31., 2.8167962646484375e+02, 3.1643666443414986e-04, 0, -1, 412.,
+    288., 31., 2.3548483276367188e+02, 2.7085436158813536e-04, 0, -1,
+    404., 288., 31., 2.0387182617187500e+02, 6.8695540539920330e-04, 0,
+    -1, 345., 288., 31., 1.1347621917724609e+02, 1.9912514835596085e-04,
+    0, -1, 246., 288., 31., 9.4017898559570312e+01,
+    1.9389810040593147e-04, 0, -1, 223., 288., 31.,
+    8.8065963745117188e+01, 2.0676161511801183e-04, 0, -1, 144., 288.,
+    31., 2.8021466064453125e+02, 3.1213389593176544e-04, 0, -1, 422.,
+    287., 31., 2.2573664855957031e+02, 4.5893131755292416e-04, 0, -1,
+    232., 189., 31., 1.5004040718078613e+01, 6.3662533648312092e-04, 0,
+    -1, 369., 287., 31., 9.9100608825683594e+01, 3.9159820880740881e-04,
+    0, -1, 238., 287., 31., 9.8349426269531250e+01,
+    2.1466534235514700e-04, 0, -1, 314., 189., 31.,
+    2.4972094726562500e+02, 1.8616596935316920e-04, 0, -1, 374., 189.,
+    31., 1.7446699523925781e+02, 4.4026260729879141e-04, 0, -1, 219.,
+    287., 31., 9.1074188232421875e+01, 3.1455309363082051e-04, 0, -1,
+    420., 286., 31., 2.5515754699707031e+02, 3.9845713763497770e-04, 0,
+    -1, 403., 286., 31., 2.1593190002441406e+02, 4.0833628736436367e-04,
+    0, -1, 385., 286., 31., 8.5286102294921875e+01,
+    4.7705171164125204e-04, 0, -1, 366., 286., 31.,
+    9.2899520874023438e+01, 3.7737592356279492e-04, 0, -1, 277., 190.,
+    31., 2.2187155151367188e+02, 1.0982347885146737e-03, 0, -1, 361.,
+    286., 31., 1.1038690185546875e+02, 2.6549460017122328e-04, 0, -1,
+    215., 286., 31., 9.9919151306152344e+01, 2.9673599055968225e-04, 0,
+    -1, 383., 285., 31., 9.5957839965820312e+01, 3.9917341200634837e-04,
+    0, -1, 380., 285., 31., 9.3089241027832031e+01,
+    2.1311169257387519e-04, 0, -1, 331., 190., 31.,
+    3.0916119384765625e+02, 2.1323349210433662e-04, 0, -1, 370., 190.,
+    31., 1.7993264770507812e+02, 4.9972132546827197e-04, 0, -1, 318.,
+    285., 31., 9.3733268737792969e+01, 1.8790035392157733e-04, 0, -1,
+    314., 285., 31., 9.7873428344726562e+01, 1.9326430629007518e-04, 0,
+    -1, 186., 191., 31., 2.9684064865112305e+01, 2.4354479683097452e-04,
+    0, -1, 223., 285., 31., 9.2384223937988281e+01,
+    2.3375554883386940e-04, 0, -1, 405., 284., 31.,
+    2.1412294006347656e+02, 2.9796393937431276e-04, 0, -1, 386., 284.,
+    31., 6.8006774902343750e+01, 4.8760999925434589e-04, 0, -1, 312.,
+    191., 31., 2.5843420410156250e+02, 2.3331369447987527e-04, 0, -1,
+    364., 284., 31., 1.0785961151123047e+02, 5.6763784959912300e-04, 0,
+    -1, 356., 284., 31., 1.5071798706054688e+02, 3.7021015305072069e-04,
+    0, -1, 352., 284., 31., 1.5309059143066406e+02,
+    3.1324184965342283e-04, 0, -1, 373., 191., 31.,
+    1.7838655090332031e+02, 2.8152970480732620e-04, 0, -1, 219., 284.,
+    31., 9.5728851318359375e+01, 2.8075432055629790e-04, 0, -1, 199.,
+    284., 31., 8.6035507202148438e+01, 2.3967181914485991e-04, 0, -1,
+    424., 283., 31., 1.5273951721191406e+02, 3.8836518069729209e-04, 0,
+    -1, 188., 192., 31., 2.9611066818237305e+01, 2.4954634136520326e-04,
+    0, -1, 384., 283., 31., 8.8189109802246094e+01,
+    4.0866871131584048e-04, 0, -1, 215., 283., 31.,
+    1.0110674285888672e+02, 2.0173187658656389e-04, 0, -1, 233., 192.,
+    31., 2.5286256790161133e+01, 9.2355866217985749e-04, 0, -1, 201.,
+    283., 31., 9.1756126403808594e+01, 1.9241250993218273e-04, 0, -1,
+    278., 192., 31., 2.1039167785644531e+02, 1.4738717582076788e-03, 0,
+    -1, 296., 192., 31., 2.8424420166015625e+02, 1.8201644707005471e-04,
+    0, -1, 195., 283., 31., 9.2449127197265625e+01,
+    3.2394970185123384e-04, 0, -1, 191., 283., 31.,
+    9.8462806701660156e+01, 2.3304816568270326e-04, 0, -1, 382., 282.,
+    31., 1.2323835754394531e+02, 2.9993112548254430e-04, 0, -1, 390.,
+    192., 31., 1.3159489440917969e+02, 1.9607257854659110e-04, 0, -1,
+    380., 282., 31., 1.5189965820312500e+02, 1.8118898151442409e-04, 0,
+    -1, 366., 282., 31., 2.8472409057617188e+02, 1.8829996406566352e-04,
+    0, -1, 199., 281., 31., 9.0590408325195312e+01,
+    2.3735816648695618e-04, 0, -1, 426., 280., 31.,
+    1.3809788513183594e+02, 2.0804075757041574e-04, 0, -1, 283., 193.,
+    31., 2.1558518981933594e+02, 1.1370540596544743e-03, 0, -1, 337.,
+    193., 31., 3.5079110717773438e+02, 2.1740076772402972e-04, 0, -1,
+    341., 193., 31., 3.5623229980468750e+02, 3.7917456938885152e-04, 0,
+    -1, 382., 193., 31., 1.5793267822265625e+02, 2.5846905191428959e-04,
+    0, -1, 399., 280., 31., 7.1920082092285156e+01,
+    2.0076862710993737e-04, 0, -1, 195., 280., 31.,
+    9.7869293212890625e+01, 2.6783859357237816e-04, 0, -1, 191., 280.,
+    31., 9.9824081420898438e+01, 2.4631878477521241e-04, 0, -1, 176.,
+    280., 31., 8.3510276794433594e+01, 2.5299878325313330e-04, 0, -1,
+    186., 194., 31., 4.7896881103515625e+01, 2.8264769935049117e-04, 0,
+    -1, 172., 280., 31., 6.2874851226806641e+01, 2.9467474087141454e-04,
+    0, -1, 234., 194., 31., 2.8234529495239258e+01,
+    5.8808468747884035e-04, 0, -1, 238., 194., 31.,
+    1.5272552490234375e+01, 2.7241618954576552e-04, 0, -1, 167., 279.,
+    31., 1.0626411437988281e+02, 1.9457322196103632e-04, 0, -1, 286.,
+    194., 31., 2.2797174072265625e+02, 7.1012967964634299e-04, 0, -1,
+    298., 194., 31., 2.8558496093750000e+02, 2.2184741101227701e-04, 0,
+    -1, 391., 278., 31., 7.7252609252929688e+01, 3.7745558074675500e-04,
+    0, -1, 329., 194., 31., 3.5377807617187500e+02,
+    2.5253821513615549e-04, 0, -1, 387., 277., 31.,
+    1.6799459838867188e+02, 3.3910994534380734e-04, 0, -1, 384., 277.,
+    31., 2.3021638488769531e+02, 3.5172858042642474e-04, 0, -1, 387.,
+    194., 31., 1.3809461975097656e+02, 2.1112302783876657e-04, 0, -1,
+    176., 277., 31., 9.2076629638671875e+01, 2.0619998394977301e-04, 0,
+    -1, 172., 277., 31., 9.3052955627441406e+01, 3.0463945586234331e-04,
+    0, -1, 420., 276., 31., 1.1558860778808594e+02,
+    1.9323850574437529e-04, 0, -1, 459., 194., 31.,
+    3.2325775146484375e+02, 2.8388330247253180e-04, 0, -1, 404., 276.,
+    31., 7.3968231201171875e+01, 1.9267143215984106e-04, 0, -1, 396.,
+    276., 31., 6.8467720031738281e+01, 4.0019708103500307e-04, 0, -1,
+    391., 276., 31., 1.1079888916015625e+02, 4.1161730769090354e-04, 0,
+    -1, 375., 276., 31., 2.3321987915039062e+02, 3.0411672196350992e-04,
+    0, -1, 232., 195., 31., 3.4722496032714844e+01,
+    5.9131957823410630e-04, 0, -1, 247., 195., 31.,
+    3.2873745727539062e+02, 4.3145220843143761e-04, 0, -1, 168., 276.,
+    31., 1.0067353057861328e+02, 2.3804017109796405e-04, 0, -1, 276.,
+    195., 31., 1.8454995727539062e+02, 2.7680970379151404e-04, 0, -1,
+    284., 195., 31., 1.9961125183105469e+02, 8.8070746278390288e-04, 0,
+    -1, 152., 276., 31., 8.3439025878906250e+01, 3.0669255647808313e-04,
+    0, -1, 148., 276., 31., 7.9999473571777344e+01,
+    3.4435381530784070e-04, 0, -1, 338., 195., 31.,
+    8.6978855133056641e+00, 2.5682416162453592e-04, 0, -1, 126., 276.,
+    31., 1.7177454233169556e+00, 2.4964581825770438e-04, 0, -1, 123.,
+    276., 31., 3.5173410034179688e+02, 1.9611841707956046e-04, 0, -1,
+    379., 195., 31., 1.7140472412109375e+02, 3.0387530568987131e-04, 0,
+    -1, 391., 195., 31., 1.2267272949218750e+02, 3.2970812753774226e-04,
+    0, -1, 400., 275., 31., 6.6956871032714844e+01,
+    2.9441271908581257e-04, 0, -1, 371., 275., 31.,
+    2.5837152099609375e+02, 2.0620720169972628e-04, 0, -1, 144., 275.,
+    31., 9.5882881164550781e+01, 2.9461085796356201e-04, 0, -1, 238.,
+    196., 31., 2.7113229751586914e+01, 3.6533540696837008e-04, 0, -1,
+    244., 196., 31., 3.5526882934570312e+02, 6.8781059235334396e-04, 0,
+    -1, 288., 196., 31., 2.2655426025390625e+02, 3.6973919486626983e-04,
+    0, -1, 152., 274., 31., 9.1451591491699219e+01,
+    2.9899075161665678e-04, 0, -1, 430., 273., 31.,
+    9.2795639038085938e+01, 2.1425214072223753e-04, 0, -1, 328., 196.,
+    31., 5.5985317230224609e+00, 2.7728712302632630e-04, 0, -1, 341.,
+    196., 31., 1.6508253097534180e+01, 2.4513428797945380e-04, 0, -1,
+    428., 273., 31., 9.1759254455566406e+01, 3.0941487057134509e-04, 0,
+    -1, 382., 196., 31., 1.4000262451171875e+02, 4.9774604849517345e-04,
+    0, -1, 406., 273., 31., 8.3717956542968750e+01,
+    2.5490595726296306e-04, 0, -1, 395., 273., 31.,
+    7.2370635986328125e+01, 4.2255056905560195e-04, 0, -1, 309., 273.,
+    31., 2.9311724853515625e+02, 2.2839760640636086e-04, 0, -1, 148.,
+    273., 31., 9.2379684448242188e+01, 3.4542346838861704e-04, 0, -1,
+    129., 273., 31., 9.3542930603027344e+01, 3.8151364424265921e-04, 0,
+    -1, 410., 272., 31., 1.2045898437500000e+02, 2.0649781799875200e-04,
+    0, -1, 402., 272., 31., 2.4822591781616211e+01,
+    5.4947682656347752e-04, 0, -1, 371., 272., 31.,
+    2.7069076538085938e+02, 2.7813678025268018e-04, 0, -1, 313., 272.,
+    31., 3.0433023071289062e+02, 1.8515417468734086e-04, 0, -1, 233.,
+    197., 31., 4.1891960144042969e+01, 6.7837134702131152e-04, 0, -1,
+    265., 197., 31., 2.0410650634765625e+02, 3.8430327549576759e-04, 0,
+    -1, 144., 272., 31., 9.7863113403320312e+01, 2.2607062419410795e-04,
+    0, -1, 290., 197., 31., 2.4378433227539062e+02,
+    1.9406930368859321e-04, 0, -1, 316., 197., 31.,
+    2.2762651443481445e+01, 1.8341744726058096e-04, 0, -1, 320., 197.,
+    31., 3.8076091766357422e+01, 2.8337654657661915e-04, 0, -1, 125.,
+    272., 31., 6.1724277496337891e+01, 5.7517888490110636e-04, 0, -1,
+    123., 272., 31., 3.7422779083251953e+01, 4.1310401866212487e-04, 0,
+    -1, 429., 270., 31., 6.9676620483398438e+01, 5.1167747005820274e-04,
+    0, -1, 367., 197., 31., 2.3042657470703125e+02,
+    2.1339229715522379e-04, 0, -1, 378., 197., 31.,
+    1.5789012145996094e+02, 3.7231459282338619e-04, 0, -1, 399., 270.,
+    31., 2.8338684082031250e+02, 3.7700822576880455e-04, 0, -1, 219.,
+    270., 31., 1.0320908355712891e+02, 1.9944265659432858e-04, 0, -1,
+    129., 270., 31., 9.4805061340332031e+01, 2.7921368018724024e-04, 0,
+    -1, 432., 269., 31., 5.0214481353759766e+01, 2.7775153284892440e-04,
+    0, -1, 406., 269., 31., 1.4848680114746094e+02,
+    2.3193575907498598e-04, 0, -1, 396., 269., 31.,
+    2.5614361572265625e+02, 2.1724878752138466e-04, 0, -1, 230., 198.,
+    31., 5.0067295074462891e+01, 4.0367481415160000e-04, 0, -1, 246.,
+    198., 31., 3.4181555175781250e+02, 5.0587404984980822e-04, 0, -1,
+    250., 198., 31., 2.8745837402343750e+02, 3.4847675124183297e-04, 0,
+    -1, 257., 198., 31., 2.3715951538085938e+02, 3.6201279726810753e-04,
+    0, -1, 259., 198., 31., 2.3318788146972656e+02,
+    4.7798134619370103e-04, 0, -1, 269., 198., 31.,
+    2.0251791381835938e+02, 8.6252274923026562e-04, 0, -1, 392., 269.,
+    31., 2.4523919677734375e+02, 2.9915638151578605e-04, 0, -1, 369.,
+    269., 31., 3.3516293334960938e+02, 2.1355409990064800e-04, 0, -1,
+    286., 269., 31., 2.6919171142578125e+02, 1.8119525338988751e-04, 0,
+    -1, 410., 198., 31., 3.1756903076171875e+02, 1.8616655142977834e-04,
+    0, -1, 125., 269., 31., 8.4611221313476562e+01,
+    2.4507901980541646e-04, 0, -1, 412., 268., 31.,
+    1.5164343261718750e+02, 1.8902002193499357e-04, 0, -1, 459., 198.,
+    31., 7.5965690612792969e+00, 1.8979716696776450e-04, 0, -1, 267.,
+    267., 31., 2.8572772216796875e+02, 1.9038518075831234e-04, 0, -1,
+    200., 267., 31., 8.3304924011230469e+01, 1.9856802828144282e-04, 0,
+    -1, 223., 199., 31., 6.2358444213867188e+01, 2.8310430934652686e-04,
+    0, -1, 226., 199., 31., 5.8225952148437500e+01,
+    2.5195462512783706e-04, 0, -1, 228., 199., 31.,
+    5.5247398376464844e+01, 2.9650554643012583e-04, 0, -1, 240., 199.,
+    31., 3.0817512512207031e+01, 2.7907223557122052e-04, 0, -1, 252.,
+    199., 31., 2.4793762207031250e+02, 2.2222747793421149e-04, 0, -1,
+    254., 199., 31., 2.5358853149414062e+02, 1.9391994283068925e-04, 0,
+    -1, 273., 199., 31., 1.9564448547363281e+02, 3.1118851620703936e-04,
+    0, -1, 428., 266., 31., 4.8741344451904297e+01,
+    4.5380066148936749e-04, 0, -1, 310., 199., 31.,
+    3.4283441162109375e+02, 2.6240304578095675e-04, 0, -1, 319., 199.,
+    31., 2.4865541458129883e+01, 4.0558210457675159e-04, 0, -1, 432.,
+    265., 31., 1.6374126434326172e+01, 2.7251412393525243e-04, 0, -1,
+    178., 265., 31., 9.5340744018554688e+01, 2.0480445527937263e-04, 0,
+    -1, 428., 263., 31., 3.5796163940429688e+02, 2.7805860736407340e-04,
+    0, -1, 369., 199., 31., 2.1158451843261719e+02,
+    3.3239566255360842e-04, 0, -1, 388., 199., 31.,
+    1.1325564575195312e+02, 5.8232183801010251e-04, 0, -1, 424., 263.,
+    31., 2.7291317749023438e+02, 2.9711789102293551e-04, 0, -1, 173.,
+    263., 31., 9.7732849121093750e+01, 3.3817192888818681e-04, 0, -1,
+    187., 262., 31., 9.4463127136230469e+01, 2.2520605125464499e-04, 0,
+    -1, 178., 262., 31., 9.4233306884765625e+01, 5.4317421745508909e-04,
+    0, -1, 173., 261., 31., 9.8438240051269531e+01,
+    4.2113199015147984e-04, 0, -1, 149., 261., 31.,
+    9.3969703674316406e+01, 2.4784382549114525e-04, 0, -1, 185., 260.,
+    31., 9.7935066223144531e+01, 2.8643733821809292e-04, 0, -1, 263.,
+    200., 31., 2.2028584289550781e+02, 3.3489998895674944e-04, 0, -1,
+    265., 200., 31., 2.1309629821777344e+02, 4.9577723257243633e-04, 0,
+    -1, 178., 260., 31., 9.3387145996093750e+01, 4.9003364983946085e-04,
+    0, -1, 328., 200., 31., 4.5888679504394531e+01,
+    2.1433747315313667e-04, 0, -1, 392., 200., 31.,
+    1.1706099700927734e+02, 2.6660217554308474e-04, 0, -1, 145., 260.,
+    31., 9.0659095764160156e+01, 1.8320308299735188e-04, 0, -1, 171.,
+    259., 31., 1.0253680419921875e+02, 1.8971931422129273e-04, 0, -1,
+    149., 259., 31., 9.3030700683593750e+01, 5.6516518816351891e-04, 0,
+    -1, 191., 258., 31., 5.5855491638183594e+01, 4.4411281123757362e-04,
+    0, -1, 180., 258., 31., 8.8860946655273438e+01,
+    2.9100291430950165e-04, 0, -1, 185., 257., 31.,
+    8.1555122375488281e+01, 4.5639311429113150e-04, 0, -1, 150., 257.,
+    31., 9.0800788879394531e+01, 9.0301822638139129e-04, 0, -1, 222.,
+    201., 31., 6.4241561889648438e+01, 6.8595859920606017e-04, 0, -1,
+    253., 201., 31., 2.4517523193359375e+02, 1.9746596808545291e-04, 0,
+    -1, 134., 257., 31., 1.1565017700195312e+02, 2.2596617054659873e-04,
+    0, -1, 327., 256., 31., 1.0043696594238281e+02,
+    3.8244898314587772e-04, 0, -1, 318., 201., 31.,
+    3.5490646362304688e+02, 4.4408353278413415e-04, 0, -1, 197., 256.,
+    31., 3.4850677490234375e+02, 3.8346226210705936e-04, 0, -1, 194.,
+    256., 31., 3.4512353515625000e+02, 7.2011578595265746e-04, 0, -1,
+    320., 255., 31., 1.1290781402587891e+02, 3.8686726475134492e-04, 0,
+    -1, 368., 201., 31., 1.9415077209472656e+02, 2.4052595836110413e-04,
+    0, -1, 371., 201., 31., 1.8260798645019531e+02,
+    2.4135102285072207e-04, 0, -1, 376., 201., 31.,
+    1.3540026855468750e+02, 2.2291738423518836e-04, 0, -1, 387., 201.,
+    31., 1.0980084991455078e+02, 5.4966693278402090e-04, 0, -1, 401.,
+    201., 31., 1.3134436035156250e+02, 2.9685508343391120e-04, 0, -1,
+    151., 255., 31., 8.6591201782226562e+01, 5.5711250752210617e-04, 0,
+    -1, 130., 255., 31., 1.2512836456298828e+02, 4.9863720778375864e-04,
+    0, -1, 336., 254., 31., 1.0900527954101562e+01,
+    3.4621401573531330e-04, 0, -1, 245., 202., 31.,
+    6.7614564895629883e+00, 2.3224043252412230e-04, 0, -1, 273., 202.,
+    31., 2.0909844970703125e+02, 3.0484626768156886e-04, 0, -1, 153.,
+    254., 31., 9.1833053588867188e+01, 3.6747445119544864e-04, 0, -1,
+    146., 254., 31., 7.3983787536621094e+01, 8.9913897681981325e-04, 0,
+    -1, 322., 202., 31., 1.0152459144592285e+01, 2.0057875372003764e-04,
+    0, -1, 403., 253., 31., 2.4271081542968750e+02,
+    2.2745902242604643e-04, 0, -1, 382., 202., 31.,
+    1.0563555145263672e+02, 6.4317526994273067e-04, 0, -1, 393., 202.,
+    31., 1.2088165283203125e+02, 3.8477167254313827e-04, 0, -1, 410.,
+    202., 31., 1.7856634140014648e+01, 2.1177188318688422e-04, 0, -1,
+    359., 253., 31., 2.5931994628906250e+02, 2.7725455584004521e-04, 0,
+    -1, 357., 253., 31., 2.5603164672851562e+02, 2.8822117019444704e-04,
+    0, -1, 328., 253., 31., 8.1620185852050781e+01,
+    1.8663959053810686e-04, 0, -1, 322., 253., 31.,
+    1.1177529907226562e+02, 5.1215558778494596e-04, 0, -1, 318., 253.,
+    31., 1.1503324127197266e+02, 4.9407623009756207e-04, 0, -1, 267.,
+    203., 31., 2.3060861206054688e+02, 7.3569867527112365e-04, 0, -1,
+    151., 253., 31., 6.5867393493652344e+01, 4.1356650763191283e-04, 0,
+    -1, 136., 253., 31., 1.3262876892089844e+02, 7.0995051646605134e-04,
+    0, -1, 388., 203., 31., 1.0815644073486328e+02,
+    7.1569695137441158e-04, 0, -1, 343., 252., 31.,
+    2.8786486816406250e+02, 1.9940586935263127e-04, 0, -1, 340., 252.,
+    31., 3.1137216186523438e+02, 3.3939428976736963e-04, 0, -1, 324.,
+    252., 31., 1.0555886077880859e+02, 6.2319729477167130e-04, 0, -1,
+    128., 252., 31., 1.3766101074218750e+02, 2.3930589668452740e-04, 0,
+    -1, 378., 251., 31., 3.0288311767578125e+02, 6.5889384131878614e-04,
+    0, -1, 221., 204., 31., 5.8968986511230469e+01,
+    7.6048239134252071e-04, 0, -1, 348., 251., 31.,
+    2.6657156372070312e+02, 3.8551088073290884e-04, 0, -1, 335., 251.,
+    31., 3.4681030273437500e+02, 7.6532462844625115e-04, 0, -1, 291.,
+    251., 31., 8.2331199645996094e+01, 2.3657589918002486e-04, 0, -1,
+    167., 251., 31., 1.6062855529785156e+02, 7.7669287566095591e-04, 0,
+    -1, 265., 204., 31., 2.3141979980468750e+02, 4.9816322280094028e-04,
+    0, -1, 139., 251., 31., 1.4702867126464844e+02,
+    4.3248842121101916e-04, 0, -1, 382., 250., 31.,
+    2.8681030273437500e+02, 2.5085988454520702e-04, 0, -1, 370., 250.,
+    31., 2.8775415039062500e+02, 3.3544056350365281e-04, 0, -1, 376.,
+    204., 31., 1.1151436614990234e+02, 2.1462191944010556e-04, 0, -1,
+    362., 250., 31., 2.6647973632812500e+02, 4.1481677908450365e-04, 0,
+    -1, 356., 250., 31., 2.5393089294433594e+02, 5.0132261822000146e-04,
+    0, -1, 207., 205., 31., 8.3834739685058594e+01,
+    2.1077235578559339e-04, 0, -1, 218., 205., 31.,
+    5.4213695526123047e+01, 7.4315210804343224e-04, 0, -1, 346., 250.,
+    31., 2.7939642333984375e+02, 6.5512349829077721e-04, 0, -1, 318.,
+    250., 31., 1.1603260040283203e+02, 5.1342340884730220e-04, 0, -1,
+    305., 250., 31., 8.4085548400878906e+01, 3.3687797258608043e-04, 0,
+    -1, 269., 205., 31., 2.1932385253906250e+02, 7.3674699524417520e-04,
+    0, -1, 173., 250., 31., 1.5702233886718750e+02,
+    2.1654806914739311e-04, 0, -1, 150., 250., 31.,
+    6.1425805091857910e-01, 4.9077230505645275e-04, 0, -1, 137., 250.,
+    31., 1.7880102539062500e+02, 6.3152192160487175e-04, 0, -1, 393.,
+    205., 31., 1.1976337432861328e+02, 6.2021933263167739e-04, 0, -1,
+    397., 205., 31., 1.2486946105957031e+02, 4.6708350419066846e-04, 0,
+    -1, 399., 205., 31., 1.2250895690917969e+02, 3.8280597073026001e-04,
+    0, -1, 404., 205., 31., 1.2151197052001953e+02,
+    5.1768292905762792e-04, 0, -1, 384., 249., 31.,
+    2.7795349121093750e+02, 2.9702149913646281e-04, 0, -1, 373., 249.,
+    31., 2.9208535766601562e+02, 5.3220544941723347e-04, 0, -1, 348.,
+    249., 31., 2.7024813842773438e+02, 6.1406707391142845e-04, 0, -1,
+    300., 249., 31., 6.9684555053710938e+01, 1.9801434245891869e-04, 0,
+    -1, 175., 249., 31., 1.0118844604492188e+02, 2.3795294691808522e-04,
+    0, -1, 152., 249., 31., 3.3407644653320312e+02,
+    2.5289770564995706e-04, 0, -1, 355., 206., 31.,
+    1.3031399536132812e+02, 2.1396587544586509e-04, 0, -1, 363., 206.,
+    31., 1.5959475708007812e+02, 1.9857312145177275e-04, 0, -1, 366.,
+    206., 31., 1.5019396972656250e+02, 2.1895937970839441e-04, 0, -1,
+    369., 206., 31., 1.2759663391113281e+02, 2.3237493587657809e-04, 0,
+    -1, 372., 206., 31., 1.1979164123535156e+02, 2.1739720250479877e-04,
+    0, -1, 374., 206., 31., 1.0996075439453125e+02,
+    2.0729165407828987e-04, 0, -1, 385., 206., 31.,
+    9.5378112792968750e+01, 5.4636393906548619e-04, 0, -1, 381., 248.,
+    31., 2.8452081298828125e+02, 3.6119646392762661e-04, 0, -1, 364.,
+    248., 31., 2.7057742309570312e+02, 5.1605090266093612e-04, 0, -1,
+    357., 248., 31., 2.5473126220703125e+02, 6.3267588848248124e-04, 0,
+    -1, 216., 207., 31., 5.1493263244628906e+01, 4.5409426093101501e-04,
+    0, -1, 350., 248., 31., 2.6318099975585938e+02,
+    3.4211925230920315e-04, 0, -1, 264., 207., 31.,
+    2.1262762451171875e+02, 2.8344723978079855e-04, 0, -1, 267., 207.,
+    31., 2.1099494934082031e+02, 7.7191332820802927e-04, 0, -1, 338.,
+    248., 31., 3.2000048828125000e+02, 6.2039139447733760e-04, 0, -1,
+    335., 248., 31., 3.3138565063476562e+02, 6.4340117387473583e-04, 0,
+    -1, 323., 207., 31., 3.4021176147460938e+02, 2.2576663468498737e-04,
+    0, -1, 303., 248., 31., 7.2515838623046875e+01,
+    4.6461803140118718e-04, 0, -1, 391., 207., 31.,
+    1.1332912445068359e+02, 3.1848298385739326e-04, 0, -1, 397., 207.,
+    31., 1.2160044860839844e+02, 5.5509479716420174e-04, 0, -1, 143.,
+    248., 31., 2.7477569580078125e+02, 3.5090799792669713e-04, 0, -1,
+    138., 248., 31., 2.1952587890625000e+02, 5.2646984113380313e-04, 0,
+    -1, 395., 247., 31., 2.2574459838867188e+02, 1.8616855959407985e-04,
+    0, -1, 384., 247., 31., 2.7354425048828125e+02,
+    2.1808252495247871e-04, 0, -1, 378., 247., 31.,
+    2.8806396484375000e+02, 4.7073472524061799e-04, 0, -1, 361., 247.,
+    31., 2.6250436401367188e+02, 5.8985862415283918e-04, 0, -1, 359.,
+    247., 31., 2.6033139038085938e+02, 5.9017504099756479e-04, 0, -1,
+    353., 247., 31., 2.5313035583496094e+02, 3.0924097518436611e-04, 0,
+    -1, 321., 208., 31., 3.4267117309570312e+02, 2.0269934611860663e-04,
+    0, -1, 362., 208., 31., 1.7982333374023438e+02,
+    3.2270950032398105e-04, 0, -1, 386., 208., 31.,
+    9.3365798950195312e+01, 3.1108045368455350e-04, 0, -1, 310., 247.,
+    31., 1.1176450347900391e+02, 2.6579279801808298e-04, 0, -1, 296.,
+    247., 31., 5.6512508392333984e+01, 2.1279965585563332e-04, 0, -1,
+    166., 247., 31., 1.5507125854492188e+02, 4.3608661508187652e-04, 0,
+    -1, 209., 209., 31., 4.8847721099853516e+01, 6.2238593818619847e-04,
+    0, -1, 391., 246., 31., 2.3665130615234375e+02,
+    3.2065671985037625e-04, 0, -1, 371., 246., 31.,
+    2.8160095214843750e+02, 5.1592977251857519e-04, 0, -1, 367., 246.,
+    31., 2.7511972045898438e+02, 3.5282541648484766e-04, 0, -1, 357.,
+    246., 31., 2.5424275207519531e+02, 4.9500860041007400e-04, 0, -1,
+    311., 209., 31., 8.4862661361694336e-01, 1.8455917597748339e-04, 0,
+    -1, 325., 209., 31., 3.2808465576171875e+02, 2.4164406931959093e-04,
+    0, -1, 333., 209., 31., 3.2743420410156250e+02,
+    2.6740948669612408e-04, 0, -1, 176., 246., 31.,
+    3.5844143676757812e+02, 3.4504229552112520e-04, 0, -1, 369., 209.,
+    31., 1.2138752746582031e+02, 1.8868234474211931e-04, 0, -1, 380.,
+    209., 31., 7.0473388671875000e+01, 2.1615868899971247e-04, 0, -1,
+    396., 209., 31., 1.2146611022949219e+02, 2.1633850701618940e-04, 0,
+    -1, 399., 209., 31., 1.2731522369384766e+02, 2.5044666836038232e-04,
+    0, -1, 168., 246., 31., 1.5352751159667969e+02,
+    4.7315619303844869e-04, 0, -1, 134., 246., 31.,
+    2.2149882507324219e+02, 2.4844525614753366e-04, 0, -1, 365., 245.,
+    31., 2.6883343505859375e+02, 5.8646593242883682e-04, 0, -1, 354.,
+    245., 31., 2.5297409057617188e+02, 2.9014897882007062e-04, 0, -1,
+    179., 245., 31., 3.4450506591796875e+02, 1.9202775729354471e-04, 0,
+    -1, 172., 245., 31., 1.0991419982910156e+02, 5.1716726738959551e-04,
+    0, -1, 320., 210., 31., 3.5485659790039062e+02,
+    3.6565502523444593e-04, 0, -1, 166., 245., 31.,
+    1.7041894531250000e+02, 2.3641544976271689e-04, 0, -1, 140., 245.,
+    31., 2.4120387268066406e+02, 6.8855402059853077e-04, 0, -1, 137.,
+    245., 31., 2.3278088378906250e+02, 6.7661586217582226e-04, 0, -1,
+    371., 210., 31., 1.1736278533935547e+02, 2.2312159126158804e-04, 0,
+    -1, 374., 210., 31., 8.8522872924804688e+01, 3.2440136419609189e-04,
+    0, -1, 403., 210., 31., 1.4029095458984375e+02,
+    2.3350435367319733e-04, 0, -1, 439., 244., 31.,
+    1.5115429687500000e+02, 1.9475481531117111e-04, 0, -1, 391., 244.,
+    31., 2.1742324829101562e+02, 2.2919481853023171e-04, 0, -1, 373.,
+    244., 31., 2.8041693115234375e+02, 2.2006503422744572e-04, 0, -1,
+    370., 244., 31., 2.7594638061523438e+02, 2.7590044192038476e-04, 0,
+    -1, 302., 244., 31., 3.3658972167968750e+02, 3.7613225867971778e-04,
+    0, -1, 398., 243., 31., 1.8202557373046875e+02,
+    3.6468016332946718e-04, 0, -1, 362., 243., 31.,
+    2.6058743286132812e+02, 3.6736839683726430e-04, 0, -1, 195., 243.,
+    31., 3.0291473388671875e+02, 2.1317716164048761e-04, 0, -1, 311.,
+    211., 31., 2.2304096221923828e+01, 2.1641988132614642e-04, 0, -1,
+    328., 211., 31., 3.3382159423828125e+02, 9.6463499357923865e-04, 0,
+    -1, 333., 211., 31., 3.2953384399414062e+02, 2.1180370822548866e-04,
+    0, -1, 378., 211., 31., 6.3157417297363281e+01,
+    2.7173481066711247e-04, 0, -1, 146., 243., 31.,
+    2.8041754150390625e+02, 1.9624766719061881e-04, 0, -1, 406., 211.,
+    31., 1.4320999145507812e+02, 2.4117574503179640e-04, 0, -1, 134.,
+    243., 31., 2.3307934570312500e+02, 1.9265068112872541e-04, 0, -1,
+    394., 242., 31., 1.8587615966796875e+02, 2.7379466337151825e-04, 0,
+    -1, 212., 212., 31., 4.7064506530761719e+01, 2.6663369499146938e-04,
+    0, -1, 369., 242., 31., 2.7366882324218750e+02,
+    3.8890528958290815e-04, 0, -1, 169., 242., 31.,
+    1.5693392944335938e+02, 2.7112220413982868e-04, 0, -1, 141., 242.,
+    31., 2.4411997985839844e+02, 9.7553763771429658e-04, 0, -1, 316.,
+    212., 31., 2.8352024078369141e+01, 2.7279974892735481e-04, 0, -1,
+    137., 242., 31., 2.3894796752929688e+02, 6.1896775150671601e-04, 0,
+    -1, 207., 241., 31., 3.2369125366210938e+02, 3.3872705535031855e-04,
+    0, -1, 135., 241., 31., 2.3851620483398438e+02,
+    1.9197579240426421e-04, 0, -1, 400., 240., 31.,
+    1.4896673583984375e+02, 6.7418138496577740e-04, 0, -1, 402., 212.,
+    31., 1.5723361206054688e+02, 2.2670590260531753e-04, 0, -1, 363.,
+    240., 31., 2.5084613037109375e+02, 4.5658991439267993e-04, 0, -1,
+    335., 240., 31., 3.2401879882812500e+02, 2.7490418870002031e-04, 0,
+    -1, 177., 240., 31., 3.4271780395507812e+02, 2.8184364782646298e-04,
+    0, -1, 172., 240., 31., 3.3462332153320312e+02,
+    4.7881191130727530e-04, 0, -1, 169., 240., 31.,
+    1.6735485839843750e+02, 2.4919075076468289e-04, 0, -1, 137., 240.,
+    31., 2.3393119812011719e+02, 3.3045109012164176e-04, 0, -1, 365.,
+    239., 31., 2.4352557373046875e+02, 4.7851426643319428e-04, 0, -1,
+    209., 239., 31., 3.0734384155273438e+02, 4.2175833368673921e-04, 0,
+    -1, 206., 239., 31., 3.0094644165039062e+02, 4.2221817420795560e-04,
+    0, -1, 146., 239., 31., 2.2226541137695312e+02,
+    2.7669742121361196e-04, 0, -1, 141., 239., 31.,
+    2.2783529663085938e+02, 6.9776730379089713e-04, 0, -1, 401., 238.,
+    31., 1.3069465637207031e+02, 4.0284573333337903e-04, 0, -1, 411.,
+    213., 31., 1.1732341003417969e+02, 3.3874844666570425e-04, 0, -1,
+    177., 238., 31., 3.3724038696289062e+02, 3.6265820381231606e-04, 0,
+    -1, 166., 238., 31., 1.6094981384277344e+02, 4.4578575761988759e-04,
+    0, -1, 334., 237., 31., 3.2097235107421875e+02,
+    7.0421793498098850e-04, 0, -1, 204., 237., 31.,
+    2.8462139892578125e+02, 2.4722635862417519e-04, 0, -1, 163., 237.,
+    31., 1.4596467590332031e+02, 5.4133200319483876e-04, 0, -1, 140.,
+    237., 31., 2.1584037780761719e+02, 3.0320553923957050e-04, 0, -1,
+    175., 236., 31., 3.2685006713867188e+02, 2.3028353461995721e-04, 0,
+    -1, 326., 214., 31., 2.8592479705810547e+01, 4.2752875015139580e-04,
+    0, -1, 374., 214., 31., 3.0307232666015625e+02,
+    2.9416603501886129e-04, 0, -1, 170., 236., 31.,
+    2.7011862182617188e+02, 2.3529073223471642e-04, 0, -1, 165., 236.,
+    31., 1.5418243408203125e+02, 3.4491860424168408e-04, 0, -1, 160.,
+    236., 31., 1.1547925567626953e+02, 5.5810017511248589e-04, 0, -1,
+    307., 235., 31., 2.7478857421875000e+02, 2.3202008742373437e-04, 0,
+    -1, 167., 235., 31., 1.7241566467285156e+02, 4.0034161065705121e-04,
+    0, -1, 207., 215., 31., 4.3508018493652344e+01,
+    3.1574332388117909e-04, 0, -1, 211., 215., 31.,
+    4.6894931793212891e+01, 4.8149813665077090e-04, 0, -1, 403., 234.,
+    31., 1.2271475219726562e+02, 5.3266785107553005e-04, 0, -1, 161.,
+    234., 31., 1.1983610534667969e+02, 5.7242595357820392e-04, 0, -1,
+    398., 233., 31., 1.4986508178710938e+02, 2.4431961355730891e-04, 0,
+    -1, 404., 232., 31., 1.2534425354003906e+02, 2.2836690186522901e-04,
+    0, -1, 402., 232., 31., 1.5007015991210938e+02,
+    4.0934214484877884e-04, 0, -1, 272., 232., 31.,
+    2.2386557006835938e+02, 2.5231257313862443e-04, 0, -1, 163., 232.,
+    31., 1.1232486724853516e+02, 3.5672265221364796e-04, 0, -1, 451.,
+    215., 31., 2.1184060668945312e+02, 1.9483649521134794e-04, 0, -1,
+    161., 232., 31., 1.2905615234375000e+02, 2.6138566317968071e-04, 0,
+    -1, 159., 232., 31., 1.3739553833007812e+02, 2.5287957396358252e-04,
+    0, -1, 144., 232., 31., 2.0745576477050781e+02,
+    1.9304611487314105e-04, 0, -1, 264., 216., 31.,
+    1.4149053955078125e+02, 1.9589201838243753e-04, 0, -1, 148., 229.,
+    31., 1.9775520324707031e+02, 2.8736123931594193e-04, 0, -1, 436.,
+    228., 31., 2.0751646423339844e+02, 1.9287431496195495e-04, 0, -1,
+    371., 216., 31., 2.8730258178710938e+02, 3.3500682911835611e-04, 0,
+    -1, 373., 216., 31., 2.9830905151367188e+02, 2.1407470921985805e-04,
+    0, -1, 275., 228., 31., 2.2929267883300781e+02,
+    2.0715242135338485e-04, 0, -1, 406., 216., 31.,
+    1.6868547058105469e+02, 4.9792591016739607e-04, 0, -1, 411., 216.,
+    31., 1.0152167510986328e+02, 3.5918716457672417e-04, 0, -1, 272.,
+    227., 31., 2.1623266601562500e+02, 2.7864801813848317e-04, 0, -1,
+    157., 227., 31., 1.8657502746582031e+02, 2.9410902061499655e-04, 0,
+    -1, 278., 226., 31., 2.2638890075683594e+02, 1.8214042938780040e-04,
+    0, -1, 153., 226., 31., 1.9796685791015625e+02,
+    5.5971776600927114e-04, 0, -1, 397., 225., 31.,
+    2.1444087219238281e+02, 2.2583045938517898e-04, 0, -1, 204., 217.,
+    31., 5.0421012878417969e+01, 2.5823508622124791e-04, 0, -1, 208.,
+    217., 31., 4.1336223602294922e+01, 3.7011117092333734e-04, 0, -1,
+    151., 225., 31., 2.0196748352050781e+02, 4.6964603825472295e-04, 0,
+    -1, 408., 224., 31., 2.8365264892578125e+02, 2.3160564887803048e-04,
+    0, -1, 394., 224., 31., 2.2783142089843750e+02,
+    3.4149564453400671e-04, 0, -1, 392., 224., 31.,
+    2.3132521057128906e+02, 3.3092702506110072e-04, 0, -1, 156., 224.,
+    31., 2.1066926574707031e+02, 3.3847609302029014e-04, 0, -1, 169.,
+    218., 31., 3.2643209838867188e+02, 1.9071977294515818e-04, 0, -1,
+    195., 218., 31., 1.4412991333007812e+02, 2.1643556829076260e-04, 0,
+    -1, 201., 218., 31., 5.3027923583984375e+01, 1.8722121603786945e-04,
+    0, -1, 406., 223., 31., 2.0594142150878906e+02,
+    5.6249304907396436e-04, 0, -1, 397., 223., 31.,
+    2.1364741516113281e+02, 3.9340180228464305e-04, 0, -1, 286., 218.,
+    31., 1.3980198669433594e+02, 1.9304892339278013e-04, 0, -1, 404.,
+    222., 31., 2.0335778808593750e+02, 5.0935847684741020e-04, 0, -1,
+    395., 222., 31., 2.2187919616699219e+02, 5.5289641022682190e-04, 0,
+    -1, 389., 222., 31., 2.4894274902343750e+02, 1.9476437591947615e-04,
+    0, -1, 369., 218., 31., 1.4985557556152344e+02,
+    3.7739388062618673e-04, 0, -1, 203., 222., 31.,
+    3.7644557952880859e+01, 4.2196980211883783e-04, 0, -1, 201., 222.,
+    31., 5.1684417724609375e+01, 4.2142783058807254e-04, 0, -1, 185.,
+    222., 31., 1.8182278442382812e+02, 2.2094804444350302e-04, 0, -1,
+    153., 222., 31., 2.1537536621093750e+02, 2.6894046459347010e-04, 0,
+    -1, 407., 221., 31., 2.0636146545410156e+02, 5.4990767966955900e-04,
+    0, -1, 381., 221., 31., 3.4132650756835938e+02,
+    3.4808384953066707e-04, 0, -1, 206., 221., 31.,
+    3.5271209716796875e+01, 4.7154005733318627e-04, 0, -1, 410., 220.,
+    31., 3.6703853607177734e+01, 2.0392691658344120e-04, 0, -1, 184.,
+    220., 31., 1.9618592834472656e+02, 1.8056125554721802e-04, 0, -1,
+    169., 220., 31., 3.2105651855468750e+02, 2.4935786495916545e-04, 0,
+    -1, 397., 219., 31., 2.1146069335937500e+02, 2.6518970844335854e-04,
+    0, -1, 408., 219., 31., 1.9672390747070312e+02,
+    6.3112203497439623e-04, 0, -1, 166., 220., 31.,
+    2.9587915039062500e+02, 2.0843594393227249e-04, 0, -1, 454., 219.,
+    31., 2.1571635437011719e+02, 7.6631287811324000e-05, 0, -1, 451.,
+    219., 31., 2.2880528259277344e+02, 1.0972784366458654e-04, 0, -1,
+    427., 384., 31., 1.9870449829101562e+02, 1.6036794113460928e-04, 0,
+    -1, 215., 135., 31., 2.0605770874023438e+02, 7.7780343417543918e-05,
+    0, -1, 412., 377., 31., 2.7199591064453125e+02,
+    1.7526345618534833e-04, 0, -1, 229., 140., 31.,
+    2.4280914306640625e+02, 1.0027360258391127e-04, 0, -1, 189., 220.,
+    31., 1.5938471984863281e+02, 9.4473783974535763e-05, 0, -1, 397.,
+    375., 31., 2.7020181274414062e+02, 1.4120439300313592e-04, 0, -1,
+    229., 142., 31., 2.2756216430664062e+02, 1.0232470958726481e-04, 0,
+    -1, 253., 142., 31., 2.6639157104492188e+02, 9.7225027275271714e-05,
+    0, -1, 359., 371., 31., 2.7481893920898438e+02,
+    8.2614802522584796e-05, 0, -1, 400., 220., 31.,
+    2.0383795166015625e+02, 1.2359382526483387e-04, 0, -1, 216., 144.,
+    31., 2.0667039489746094e+02, 9.0017820184584707e-05, 0, -1, 241.,
+    144., 31., 2.7334036254882812e+02, 9.2727677838411182e-05, 0, -1,
+    195., 221., 31., 1.2100531005859375e+02, 1.3825391943100840e-04, 0,
+    -1, 254., 144., 31., 3.4461495971679688e+02, 1.7255655257031322e-04,
+    0, -1, 282., 221., 31., 1.6036396789550781e+02,
+    8.7242209701798856e-05, 0, -1, 286., 221., 31.,
+    1.2337917327880859e+02, 1.1267772788414732e-04, 0, -1, 289., 221.,
+    31., 9.9251800537109375e+01, 1.0227310121990740e-04, 0, -1, 347.,
+    368., 31., 2.7722634887695312e+02, 1.7030719027388841e-04, 0, -1,
+    403., 367., 31., 1.0140367889404297e+02, 1.7588434275239706e-04, 0,
+    -1, 213., 145., 31., 2.0350311279296875e+02, 9.9713666713796556e-05,
+    0, -1, 374., 367., 31., 2.8809375000000000e+02,
+    8.6491687397938222e-05, 0, -1, 192., 219., 31.,
+    1.5503744506835938e+02, 1.5817333769518882e-04, 0, -1, 451., 221.,
+    31., 2.2692465209960938e+02, 1.1990032362518832e-04, 0, -1, 151.,
+    222., 31., 2.1354844665527344e+02, 1.5786313451826572e-04, 0, -1,
+    187., 219., 31., 1.6831692504882812e+02, 1.0588621807983145e-04, 0,
+    -1, 163., 222., 31., 2.6717431640625000e+02, 8.9267407020088285e-05,
+    0, -1, 335., 367., 31., 2.7604113769531250e+02,
+    8.1049445725511760e-05, 0, -1, 384., 366., 31.,
+    3.4441464233398438e+02, 1.3323070015758276e-04, 0, -1, 378., 218.,
+    31., 3.2684765625000000e+02, 9.9609744211193174e-05, 0, -1, 277.,
+    222., 31., 1.7968719482421875e+02, 1.1058172094635665e-04, 0, -1,
+    210., 146., 31., 2.0659544372558594e+02, 1.0093109449371696e-04, 0,
+    -1, 238., 146., 31., 3.0810818481445312e+02, 1.6545641119591892e-04,
+    0, -1, 418., 365., 31., 1.8723590087890625e+02,
+    1.2271807645447552e-04, 0, -1, 375., 365., 31.,
+    3.3496487426757812e+02, 1.3297575060278177e-04, 0, -1, 372., 365.,
+    31., 2.4328289794921875e+02, 8.5997227870393544e-05, 0, -1, 368.,
+    365., 31., 2.4485977172851562e+02, 8.7838154286146164e-05, 0, -1,
+    363., 364., 31., 2.6657592773437500e+02, 1.1167984484927729e-04, 0,
+    -1, 373., 363., 31., 1.6002954101562500e+02, 9.5236842753365636e-05,
+    0, -1, 357., 363., 31., 2.9192608642578125e+02,
+    1.2217952462378889e-04, 0, -1, 267., 147., 31.,
+    5.0302001953125000e+01, 1.1540983541635796e-04, 0, -1, 242., 148.,
+    31., 9.9290527343750000e+01, 1.1749151599360630e-04, 0, -1, 363.,
+    362., 31., 2.8062817382812500e+02, 1.7978460527956486e-04, 0, -1,
+    354., 362., 31., 3.1414871215820312e+02, 1.3184477575123310e-04, 0,
+    -1, 182., 223., 31., 3.2493713378906250e+02, 1.4580259448848665e-04,
+    0, -1, 187., 223., 31., 1.5662467956542969e+02,
+    1.0321386071154848e-04, 0, -1, 365., 361., 31.,
+    2.4853488159179688e+02, 1.0390929674031213e-04, 0, -1, 360., 361.,
+    31., 2.5395050048828125e+02, 1.2862449511885643e-04, 0, -1, 348.,
+    361., 31., 1.3661715507507324e+01, 1.3887725071981549e-04, 0, -1,
+    343., 361., 31., 1.7899133300781250e+02, 9.9362456239759922e-05, 0,
+    -1, 378., 360., 31., 3.0789182662963867e+01, 1.1608937347773463e-04,
+    0, -1, 352., 360., 31., 3.3997845458984375e+02,
+    1.3750957441516221e-04, 0, -1, 338., 360., 31.,
+    2.0112338256835938e+02, 9.2358073743525892e-05, 0, -1, 207., 150.,
+    31., 2.2087054443359375e+02, 7.8889199357945472e-05, 0, -1, 246.,
+    150., 31., 7.3917510986328125e+01, 1.0126709094038233e-04, 0, -1,
+    435., 223., 31., 2.0808488464355469e+02, 1.1973440996371210e-04, 0,
+    -1, 437., 223., 31., 2.0538330078125000e+02, 8.6963016656227410e-05,
+    0, -1, 376., 359., 31., 6.9825317382812500e+01,
+    1.0860674956347793e-04, 0, -1, 349., 359., 31.,
+    3.2744030761718750e+02, 1.1939003161387518e-04, 0, -1, 266., 150.,
+    31., 5.9452140808105469e+01, 8.4903294919058681e-05, 0, -1, 343.,
+    358., 31., 1.8417568969726562e+02, 1.3572158059105277e-04, 0, -1,
+    341., 358., 31., 1.6516992187500000e+02, 9.8577060271054506e-05, 0,
+    -1, 325., 358., 31., 2.7379821777343750e+02, 9.0044151875190437e-05,
+    0, -1, 203., 151., 31., 2.2704484558105469e+02,
+    1.0831947292899713e-04, 0, -1, 400., 357., 31.,
+    2.0025712585449219e+02, 1.7715312424115837e-04, 0, -1, 320., 357.,
+    31., 2.7175866699218750e+02, 1.3307484914548695e-04, 0, -1, 205.,
+    151., 31., 2.2595278930664062e+02, 1.4559368719346821e-04, 0, -1,
+    382., 224., 31., 2.4676588058471680e+01, 8.9037821453530341e-05, 0,
+    -1, 383., 217., 31., 3.0807980346679688e+02, 1.2516998685896397e-04,
+    0, -1, 356., 356., 31., 2.9360272216796875e+02,
+    7.7028176747262478e-05, 0, -1, 350., 356., 31.,
+    2.9925811767578125e+02, 9.3892966106068343e-05, 0, -1, 331., 356.,
+    31., 1.6591604614257812e+02, 9.9663659057114273e-05, 0, -1, 318.,
+    356., 31., 2.6590054321289062e+02, 1.6873249842319638e-04, 0, -1,
+    315., 356., 31., 2.6465734863281250e+02, 1.2077274732291698e-04, 0,
+    -1, 159., 225., 31., 2.1260072326660156e+02, 1.3618580123875290e-04,
+    0, -1, 311., 356., 31., 2.6756909179687500e+02,
+    1.1415311746532097e-04, 0, -1, 199., 225., 31.,
+    6.6059700012207031e+01, 1.6216997755691409e-04, 0, -1, 237., 151.,
+    31., 7.3181747436523438e+01, 1.5473566600121558e-04, 0, -1, 199.,
+    217., 31., 8.0615425109863281e+01, 1.1274161079199985e-04, 0, -1,
+    432., 225., 31., 2.0343727111816406e+02, 1.5805699513293803e-04, 0,
+    -1, 451., 225., 31., 2.1149786376953125e+02, 1.1367524712113664e-04,
+    0, -1, 167., 217., 31., 3.0455780029296875e+02,
+    1.3733665400650352e-04, 0, -1, 322., 355., 31.,
+    1.7743635559082031e+02, 1.4215600094757974e-04, 0, -1, 196., 226.,
+    31., 8.8591171264648438e+01, 1.1499150423333049e-04, 0, -1, 205.,
+    226., 31., 2.3101427078247070e+01, 7.6715099567081779e-05, 0, -1,
+    320., 355., 31., 2.1442105102539062e+02, 1.7981698329094797e-04, 0,
+    -1, 309., 355., 31., 2.7011801147460938e+02, 1.5584468201268464e-04,
+    0, -1, 307., 355., 31., 2.7527090454101562e+02,
+    1.5479780267924070e-04, 0, -1, 239., 152., 31.,
+    7.5560516357421875e+01, 1.0945054236799479e-04, 0, -1, 352., 354.,
+    31., 2.9908663940429688e+02, 7.9414174251724035e-05, 0, -1, 346.,
+    354., 31., 2.7961990356445312e+02, 8.1293757830280811e-05, 0, -1,
+    145., 227., 31., 2.0648648071289062e+02, 1.3000558828935027e-04, 0,
+    -1, 315., 354., 31., 2.5648593139648438e+02, 1.6149073780979961e-04,
+    0, -1, 159., 227., 31., 1.9181968688964844e+02,
+    1.1283170897513628e-04, 0, -1, 304., 354., 31.,
+    2.8114062500000000e+02, 1.2952019460499287e-04, 0, -1, 194., 227.,
+    31., 1.0032351684570312e+02, 1.1168125638505444e-04, 0, -1, 301.,
+    354., 31., 2.8218695068359375e+02, 1.3614422641694546e-04, 0, -1,
+    350., 353., 31., 2.9183813476562500e+02, 8.0861289461608976e-05, 0,
+    -1, 455., 216., 31., 2.1668215942382812e+02, 1.1236212594667450e-04,
+    0, -1, 313., 353., 31., 2.5447657775878906e+02,
+    1.2135532597312704e-04, 0, -1, 199., 153., 31.,
+    2.2978013610839844e+02, 1.2602323840837926e-04, 0, -1, 448., 227.,
+    31., 2.5574955749511719e+02, 8.6928841483313590e-05, 0, -1, 299.,
+    353., 31., 2.8715057373046875e+02, 1.3859153841622174e-04, 0, -1,
+    296., 353., 31., 2.9083435058593750e+02, 9.5310664619319141e-05, 0,
+    -1, 199., 228., 31., 6.2273109436035156e+01, 9.1408102889545262e-05,
+    0, -1, 205., 228., 31., 1.5773172378540039e+01,
+    1.0323401511413977e-04, 0, -1, 293., 353., 31.,
+    2.9632830810546875e+02, 7.7269636676646769e-05, 0, -1, 210., 153.,
+    31., 2.4026782226562500e+02, 9.6044088422786444e-05, 0, -1, 280.,
+    228., 31., 2.4856382751464844e+02, 9.4810064183548093e-05, 0, -1,
+    286., 228., 31., 2.8659915161132812e+02, 1.5390559565275908e-04, 0,
+    -1, 417., 352., 31., 1.8220802307128906e+02, 1.1078829265898094e-04,
+    0, -1, 392., 228., 31., 1.6024501037597656e+02,
+    1.4497053052764386e-04, 0, -1, 395., 228., 31.,
+    1.8238853454589844e+02, 1.2118086306145415e-04, 0, -1, 230., 153.,
+    31., 8.8757812500000000e+01, 1.4584918972104788e-04, 0, -1, 248.,
+    153., 31., 7.4829483032226562e+01, 1.0260425187880173e-04, 0, -1,
+    379., 352., 31., 3.0654089355468750e+02, 1.6671435150783509e-04, 0,
+    -1, 288., 352., 31., 3.3052490234375000e+02, 1.0652037599356845e-04,
+    0, -1, 144., 229., 31., 2.1046691894531250e+02,
+    1.4199790894053876e-04, 0, -1, 333., 351., 31.,
+    2.0723640441894531e+02, 1.1688281665556133e-04, 0, -1, 290., 351.,
+    31., 7.7802968025207520e+00, 1.1999628623016179e-04, 0, -1, 284.,
+    351., 31., 3.5441165161132812e+02, 8.2054888480342925e-05, 0, -1,
+    202., 229., 31., 3.1125461578369141e+01, 1.0168056178372353e-04, 0,
+    -1, 206., 154., 31., 2.3497184753417969e+02, 1.3954022142570466e-04,
+    0, -1, 399., 350., 31., 1.8628518676757812e+02,
+    1.6159226652234793e-04, 0, -1, 330., 350., 31.,
+    1.7770443725585938e+02, 1.5613934374414384e-04, 0, -1, 294., 229.,
+    31., 3.1835870361328125e+02, 1.2610825069714338e-04, 0, -1, 294.,
+    350., 31., 2.3140417098999023e+01, 7.9932979133445770e-05, 0, -1,
+    279., 350., 31., 1.0059351921081543e+01, 1.1245292262174189e-04, 0,
+    -1, 275., 350., 31., 1.8839754104614258e+01, 7.7543532825075090e-05,
+    0, -1, 342., 349., 31., 2.8628662109375000e+02,
+    1.6617822984699160e-04, 0, -1, 285., 349., 31.,
+    2.1458189010620117e+01, 1.1354680464137346e-04, 0, -1, 270., 349.,
+    31., 6.2587604522705078e+01, 1.1558428377611563e-04, 0, -1, 449.,
+    229., 31., 1.3910485839843750e+02, 9.0839195763692260e-05, 0, -1,
+    217., 155., 31., 4.5421772003173828e+01, 8.6658452346455306e-05, 0,
+    -1, 234., 155., 31., 6.9683303833007812e+01, 1.3502822548616678e-04,
+    0, -1, 272., 348., 31., 4.2743782043457031e+01,
+    1.7649152141530067e-04, 0, -1, 265., 348., 31.,
+    8.1037551879882812e+01, 1.2271146988496184e-04, 0, -1, 205., 231.,
+    31., 3.4358508300781250e+02, 1.0708660556701943e-04, 0, -1, 209.,
+    156., 31., 2.5896069335937500e+02, 9.1255067673046142e-05, 0, -1,
+    219., 156., 31., 9.6648933410644531e+01, 9.8408076155465096e-05, 0,
+    -1, 343., 347., 31., 2.9351843261718750e+02, 8.0947182141244411e-05,
+    0, -1, 215., 157., 31., 1.6885257720947266e+01,
+    1.7743933130986989e-04, 0, -1, 444., 231., 31.,
+    1.8937773132324219e+02, 1.1914434435311705e-04, 0, -1, 446., 231.,
+    31., 3.9779006958007812e+01, 1.6515064635314047e-04, 0, -1, 325.,
+    347., 31., 1.9083387756347656e+02, 1.1192297824891284e-04, 0, -1,
+    312., 347., 31., 2.4936134338378906e+02, 1.4837610069662333e-04, 0,
+    -1, 194., 216., 31., 1.6868214416503906e+02, 9.0000976342707872e-05,
+    0, -1, 221., 157., 31., 1.1975970458984375e+02,
+    1.5262940723914653e-04, 0, -1, 383., 215., 31.,
+    3.1976773071289062e+02, 1.2616159801837057e-04, 0, -1, 261., 347.,
+    31., 8.7749542236328125e+01, 1.3730180216953158e-04, 0, -1, 208.,
+    232., 31., 3.2053866577148438e+02, 1.0017873864853755e-04, 0, -1,
+    257., 347., 31., 9.6779579162597656e+01, 8.6757776443846524e-05, 0,
+    -1, 220., 347., 31., 2.6983203125000000e+02, 1.5756576613057405e-04,
+    0, -1, 368., 215., 31., 2.6472000122070312e+02,
+    8.8922228314913809e-05, 0, -1, 283., 232., 31.,
+    2.7179315185546875e+02, 1.4767986431252211e-04, 0, -1, 306., 215.,
+    31., 5.4736789703369141e+01, 8.1941077951341867e-05, 0, -1, 231.,
+    157., 31., 7.4611907958984375e+01, 1.2340304965618998e-04, 0, -1,
+    433., 232., 31., 1.9295111083984375e+02, 8.3993705629836768e-05, 0,
+    -1, 448., 232., 31., 1.0279388427734375e+02, 9.7524556622374803e-05,
+    0, -1, 148., 233., 31., 1.9134840393066406e+02,
+    1.7266963550355285e-04, 0, -1, 399., 346., 31.,
+    1.9389686584472656e+02, 8.7905747932381928e-05, 0, -1, 285., 233.,
+    31., 2.8425350952148438e+02, 1.2737212819047272e-04, 0, -1, 318.,
+    346., 31., 1.9074899291992188e+02, 1.2475706171244383e-04, 0, -1,
+    322., 157., 31., 8.9792190551757812e+01, 8.4818850154988468e-05, 0,
+    -1, 275., 346., 31., 6.9918456077575684e+00, 1.0893315629800782e-04,
+    0, -1, 252., 346., 31., 1.0346416473388672e+02,
+    9.2158108600415289e-05, 0, -1, 174., 234., 31.,
+    3.3052566528320312e+02, 1.4668186486233026e-04, 0, -1, 417., 345.,
+    31., 1.8588757324218750e+02, 1.2467769556678832e-04, 0, -1, 209.,
+    234., 31., 3.0816903686523438e+02, 8.6870262748561800e-05, 0, -1,
+    402., 345., 31., 2.1391511535644531e+02, 1.3038191536907107e-04, 0,
+    -1, 338., 345., 31., 3.0112680053710938e+02, 1.0962150554405525e-04,
+    0, -1, 196., 158., 31., 2.0650372314453125e+02,
+    1.0698169353418052e-04, 0, -1, 283., 234., 31.,
+    2.7390524291992188e+02, 1.2355874059721828e-04, 0, -1, 254., 345.,
+    31., 9.9877044677734375e+01, 1.5431985957548022e-04, 0, -1, 227.,
+    158., 31., 1.0604334259033203e+02, 1.5884614549577236e-04, 0, -1,
+    335., 158., 31., 8.9298149108886719e+01, 7.7667828008998185e-05, 0,
+    -1, 271., 344., 31., 1.9629638671875000e+01, 8.4101047832518816e-05,
+    0, -1, 379., 343., 31., 2.6091424560546875e+02,
+    1.1710532999131829e-04, 0, -1, 332., 343., 31.,
+    2.9777484130859375e+02, 1.6847158258315176e-04, 0, -1, 265., 343.,
+    31., 4.8716300964355469e+01, 1.5484586765524000e-04, 0, -1, 238.,
+    343., 31., 1.0442784881591797e+02, 8.3538718172349036e-05, 0, -1,
+    251., 342., 31., 9.9979568481445312e+01, 1.4286655641626567e-04, 0,
+    -1, 242., 342., 31., 1.0961946868896484e+02, 1.2241781223565340e-04,
+    0, -1, 236., 342., 31., 9.9260375976562500e+01,
+    1.3216224033385515e-04, 0, -1, 402., 341., 31.,
+    1.8222697448730469e+02, 1.2953452824149281e-04, 0, -1, 445., 235.,
+    31., 1.0124326324462891e+02, 1.1658811126835644e-04, 0, -1, 382.,
+    341., 31., 2.5664288330078125e+02, 1.5433001681230962e-04, 0, -1,
+    278., 341., 31., 2.2719755172729492e+01, 1.2539559975266457e-04, 0,
+    -1, 448., 214., 31., 2.0234156799316406e+02, 8.4773324488196522e-05,
+    0, -1, 256., 341., 31., 8.3756576538085938e+01,
+    1.3723962183576077e-04, 0, -1, 266., 214., 31.,
+    1.5723091125488281e+02, 1.5693121531512588e-04, 0, -1, 181., 236.,
+    31., 3.3516552734375000e+02, 9.5267889264505357e-05, 0, -1, 246.,
+    341., 31., 1.0640711975097656e+02, 1.0776572889881209e-04, 0, -1,
+    215., 236., 31., 2.8393612670898438e+02, 1.2987563968636096e-04, 0,
+    -1, 399., 340., 31., 1.8956005859375000e+02, 1.7550571647007018e-04,
+    0, -1, 265., 236., 31., 2.1913986206054688e+02,
+    8.9975153969135135e-05, 0, -1, 329., 340., 31.,
+    5.4067863464355469e+01, 1.0088477574754506e-04, 0, -1, 297., 340.,
+    31., 2.4721590042114258e+01, 1.4733472198713571e-04, 0, -1, 258.,
+    340., 31., 4.9534843444824219e+01, 1.3406583457253873e-04, 0, -1,
+    249., 340., 31., 1.0099623870849609e+02, 9.7085234301630408e-05, 0,
+    -1, 239., 340., 31., 1.0631370544433594e+02, 1.4306683442555368e-04,
+    0, -1, 176., 340., 31., 2.8464578247070312e+02,
+    1.0669309995137155e-04, 0, -1, 203., 214., 31.,
+    5.6825305938720703e+01, 9.8779004474636167e-05, 0, -1, 221., 237.,
+    31., 2.5551890563964844e+02, 1.3850242248736322e-04, 0, -1, 379.,
+    339., 31., 2.3700592041015625e+02, 1.6906848759390414e-04, 0, -1,
+    326., 339., 31., 1.0612670898437500e+02, 1.6287979087792337e-04, 0,
+    -1, 432., 161., 31., 9.4571998596191406e+01, 8.7672255176585168e-05,
+    0, -1, 281., 339., 31., 3.1957847595214844e+01,
+    1.0415928409202024e-04, 0, -1, 256., 339., 31.,
+    2.8286237716674805e+01, 1.1869996524183080e-04, 0, -1, 253., 339.,
+    31., 7.1281219482421875e+01, 8.3148224803153425e-05, 0, -1, 137.,
+    238., 31., 2.2055488586425781e+02, 1.2992881238460541e-04, 0, -1,
+    244., 339., 31., 1.0462459564208984e+02, 1.0623318667057902e-04, 0,
+    -1, 241., 339., 31., 1.0718928527832031e+02, 1.0767422645585611e-04,
+    0, -1, 233., 339., 31., 9.8930374145507812e+01,
+    1.1302260099910200e-04, 0, -1, 217., 339., 31.,
+    1.0181156921386719e+02, 8.5148181824479252e-05, 0, -1, 179., 339.,
+    31., 3.0273834228515625e+02, 1.3801475870423019e-04, 0, -1, 231.,
+    238., 31., 2.4955450439453125e+02, 1.4327964163385332e-04, 0, -1,
+    296., 338., 31., 3.5498840332031250e+01, 1.5934219118207693e-04, 0,
+    -1, 268., 238., 31., 2.1319100952148438e+02, 9.0410801931284368e-05,
+    0, -1, 274., 338., 31., 3.3543035888671875e+02,
+    1.1059774260502309e-04, 0, -1, 238., 338., 31.,
+    1.0288815307617188e+02, 1.3410163228400052e-04, 0, -1, 230., 337.,
+    31., 1.0548356628417969e+02, 1.4772603753954172e-04, 0, -1, 380.,
+    213., 31., 1.8842473030090332e+00, 1.4185873442329466e-04, 0, -1,
+    149., 239., 31., 1.8716050720214844e+02, 1.6871448315214366e-04, 0,
+    -1, 201., 239., 31., 2.5028158569335938e+02, 1.2164048530394211e-04,
+    0, -1, 340., 213., 31., 3.3061669921875000e+02,
+    8.7247906776610762e-05, 0, -1, 375., 336., 31.,
+    2.1464678955078125e+02, 8.1449601566419005e-05, 0, -1, 244., 336.,
+    31., 9.4915367126464844e+01, 1.8002450815401971e-04, 0, -1, 200.,
+    336., 31., 1.0546617889404297e+02, 8.9585038949735463e-05, 0, -1,
+    303., 239., 31., 2.8989392089843750e+02, 8.0478341260459274e-05, 0,
+    -1, 163., 336., 31., 2.6952001953125000e+02, 1.3548573770094663e-04,
+    0, -1, 415., 163., 31., 1.2990847778320312e+02,
+    8.1609381595626473e-05, 0, -1, 431., 163., 31.,
+    2.4147622680664062e+02, 1.4128306065686047e-04, 0, -1, 239., 335.,
+    31., 9.0253196716308594e+01, 1.4388264389708638e-04, 0, -1, 194.,
+    164., 31., 1.8105355834960938e+02, 9.0688830823637545e-05, 0, -1,
+    202., 335., 31., 1.0291534423828125e+02, 1.3986704288981855e-04, 0,
+    -1, 159., 335., 31., 2.8025985717773438e+02, 1.2750753376167268e-04,
+    0, -1, 267., 240., 31., 2.1261460876464844e+02,
+    7.8030345321167260e-05, 0, -1, 381., 334., 31.,
+    2.1785632324218750e+02, 1.4960550470277667e-04, 0, -1, 452., 212.,
+    31., 1.7663854980468750e+02, 1.2403506843838841e-04, 0, -1, 289.,
+    334., 31., 9.1559000015258789e+00, 9.7690979600884020e-05, 0, -1,
+    368., 212., 31., 2.6435925292968750e+02, 1.7989074694924057e-04, 0,
+    -1, 156., 334., 31., 2.8516766357421875e+02, 7.7242119004949927e-05,
+    0, -1, 442., 240., 31., 1.4964773559570312e+02,
+    9.8425021860748529e-05, 0, -1, 363., 212., 31.,
+    2.3442594909667969e+02, 1.2045852054143324e-04, 0, -1, 183., 241.,
+    31., 3.3213461303710938e+02, 7.9511133662890643e-05, 0, -1, 142.,
+    334., 31., 2.8348806762695312e+02, 1.7384185048285872e-04, 0, -1,
+    274., 333., 31., 2.8331378173828125e+02, 8.1646219769027084e-05, 0,
+    -1, 240., 333., 31., 3.5661489868164062e+02, 1.1522592103574425e-04,
+    0, -1, 419., 164., 31., 1.1032286071777344e+02,
+    1.1793323938036337e-04, 0, -1, 207., 333., 31.,
+    1.0133250427246094e+02, 1.4241405006032437e-04, 0, -1, 253., 212.,
+    31., 1.6546458435058594e+02, 8.9052489784080535e-05, 0, -1, 198.,
+    242., 31., 2.7492669677734375e+02, 1.6576569760218263e-04, 0, -1,
+    203., 242., 31., 1.6109309387207031e+02, 1.0468353866599500e-04, 0,
+    -1, 207., 165., 31., 7.0511489868164062e+01, 8.5791543824598193e-05,
+    0, -1, 283., 332., 31., 2.4725291442871094e+02,
+    1.0770602966658771e-04, 0, -1, 427., 165., 31.,
+    2.0410891723632812e+02, 1.5069077198859304e-04, 0, -1, 135., 332.,
+    31., 3.0061807250976562e+02, 1.0968172864522785e-04, 0, -1, 297.,
+    331., 31., 6.1461685180664062e+01, 1.0071771976072341e-04, 0, -1,
+    269., 331., 31., 2.8047900390625000e+02, 1.1188851203769445e-04, 0,
+    -1, 170., 331., 31., 1.3511555480957031e+02, 9.6484327514190227e-05,
+    0, -1, 167., 331., 31., 1.5283930969238281e+02,
+    8.4863779193256050e-05, 0, -1, 142., 331., 31.,
+    2.8118072509765625e+02, 1.0049595584860072e-04, 0, -1, 336., 243.,
+    31., 3.2299438476562500e+02, 7.7552933362312615e-05, 0, -1, 280.,
+    211., 31., 1.8515440368652344e+02, 1.1107406317023560e-04, 0, -1,
+    375., 243., 31., 2.8522842407226562e+02, 1.0655360529199243e-04, 0,
+    -1, 277., 330., 31., 2.5836083984375000e+02, 1.4789524720981717e-04,
+    0, -1, 403., 243., 31., 1.5651911926269531e+02,
+    1.0020617628470063e-04, 0, -1, 436., 243., 31.,
+    1.6208721923828125e+02, 8.5137340647634119e-05, 0, -1, 235., 330.,
+    31., 3.0638757324218750e+02, 8.0601370427757502e-05, 0, -1, 416.,
+    166., 31., 1.1938639831542969e+02, 1.5273154713213444e-04, 0, -1,
+    452., 166., 31., 1.1597212219238281e+02, 1.6205749125219882e-04, 0,
+    -1, 175., 330., 31., 1.1632536315917969e+02, 1.3881815539207309e-04,
+    0, -1, 137., 330., 31., 2.9555914306640625e+02,
+    1.4244040357880294e-04, 0, -1, 203., 211., 31.,
+    7.1564910888671875e+01, 1.0504799138288945e-04, 0, -1, 201., 211.,
+    31., 1.1923766326904297e+02, 1.0404331987956539e-04, 0, -1, 135.,
+    330., 31., 3.0230108642578125e+02, 1.0719410784076899e-04, 0, -1,
+    302., 329., 31., 3.9265621185302734e+01, 1.3123691314831376e-04, 0,
+    -1, 220., 329., 31., 9.8291786193847656e+01, 8.8234286522492766e-05,
+    0, -1, 366., 210., 31., 2.1102932739257812e+02,
+    1.6464831423945725e-04, 0, -1, 178., 329., 31.,
+    1.0878356933593750e+02, 1.0014402505476028e-04, 0, -1, 472., 167.,
+    31., 9.6645919799804688e+01, 1.4435929188039154e-04, 0, -1, 166.,
+    329., 31., 1.4766217041015625e+02, 1.0875779116759077e-04, 0, -1,
+    206., 168., 31., 7.8982109069824219e+01, 1.3543824024964124e-04, 0,
+    -1, 314., 210., 31., 6.1632499694824219e+00, 1.7788022523745894e-04,
+    0, -1, 381., 327., 31., 1.5816229248046875e+02,
+    1.6470928676426411e-04, 0, -1, 190., 245., 31.,
+    3.1754946899414062e+02, 1.0715889948187396e-04, 0, -1, 421., 168.,
+    31., 1.4213024902343750e+02, 1.0913883306784555e-04, 0, -1, 268.,
+    327., 31., 2.7044958496093750e+02, 1.6479034093208611e-04, 0, -1,
+    199., 327., 31., 1.0514990234375000e+02, 1.2629987031687051e-04, 0,
+    -1, 193., 327., 31., 8.9681182861328125e+01, 1.4091192861087620e-04,
+    0, -1, 186., 327., 31., 9.1698265075683594e+01,
+    1.2018704001093283e-04, 0, -1, 165., 327., 31.,
+    1.4765313720703125e+02, 1.3610658061224967e-04, 0, -1, 137., 327.,
+    31., 2.9615121459960938e+02, 9.9800949101336300e-05, 0, -1, 306.,
+    326., 31., 1.6534976959228516e+01, 1.7508056771475822e-04, 0, -1,
+    201., 326., 31., 1.1126060485839844e+02, 1.2084419722668827e-04, 0,
+    -1, 150., 326., 31., 3.2851992797851562e+02, 8.9336906967218965e-05,
+    0, -1, 144., 246., 31., 2.7918447875976562e+02,
+    1.0423565254313871e-04, 0, -1, 416., 325., 31.,
+    1.8520608520507812e+02, 1.1101039126515388e-04, 0, -1, 439., 170.,
+    31., 3.4140548706054688e+02, 1.5034626994747669e-04, 0, -1, 217.,
+    325., 31., 2.7030618286132812e+02, 1.5950264059938490e-04, 0, -1,
+    185., 325., 31., 9.1952949523925781e+01, 1.5130324754863977e-04, 0,
+    -1, 148., 325., 31., 3.3684579467773438e+02, 9.0585155703593045e-05,
+    0, -1, 268., 246., 31., 1.5813507080078125e+02,
+    9.7458185337018222e-05, 0, -1, 311., 324., 31.,
+    5.3442043304443359e+01, 1.1955911031691357e-04, 0, -1, 293., 246.,
+    31., 4.2741577148437500e+01, 1.5556425205431879e-04, 0, -1, 309.,
+    209., 31., 6.3727335929870605e+00, 1.6319716814905405e-04, 0, -1,
+    301., 324., 31., 2.7131634521484375e+02, 8.7386244558729231e-05, 0,
+    -1, 165., 324., 31., 1.5404861450195312e+02, 1.2545540812425315e-04,
+    0, -1, 313., 323., 31., 1.2713233947753906e+01,
+    1.3918514014221728e-04, 0, -1, 212., 323., 31.,
+    2.7370794677734375e+02, 1.7527080490253866e-04, 0, -1, 208., 323.,
+    31., 2.6759252929687500e+02, 1.5983893536031246e-04, 0, -1, 191.,
+    323., 31., 6.6385330200195312e+01, 1.0629293683450669e-04, 0, -1,
+    184., 247., 31., 3.2769830322265625e+02, 1.4675411512143910e-04, 0,
+    -1, 191., 247., 31., 3.0951257324218750e+02, 1.2089389929315075e-04,
+    0, -1, 237., 247., 31., 1.2718968200683594e+02,
+    8.8605651399120688e-05, 0, -1, 164., 209., 31.,
+    2.3670063781738281e+02, 1.1290857219137251e-04, 0, -1, 150., 323.,
+    31., 5.0040500640869141e+01, 1.1232472024857998e-04, 0, -1, 188.,
+    172., 31., 1.8059889221191406e+02, 9.1765912657137960e-05, 0, -1,
+    347., 247., 31., 2.7808184814453125e+02, 1.3068731641396880e-04, 0,
+    -1, 262., 208., 31., 1.9746516418457031e+02, 8.6284868302755058e-05,
+    0, -1, 249., 208., 31., 1.9321086120605469e+02,
+    1.0660456609912217e-04, 0, -1, 381., 322., 31.,
+    1.3006382751464844e+02, 1.6368972137570381e-04, 0, -1, 433., 172.,
+    31., 3.0827822875976562e+02, 1.2915626575704664e-04, 0, -1, 309.,
+    322., 31., 1.9407703399658203e+01, 1.6314379172399640e-04, 0, -1,
+    464., 172., 31., 1.3601089477539062e+02, 1.5446035831701010e-04, 0,
+    -1, 221., 322., 31., 2.8336495971679688e+02, 8.0581427027937025e-05,
+    0, -1, 442., 247., 31., 1.7412980651855469e+02,
+    1.1136412649648264e-04, 0, -1, 161., 208., 31.,
+    2.2466320800781250e+02, 1.0916895553236827e-04, 0, -1, 408., 207.,
+    31., 1.1768791198730469e+02, 1.2655573664233088e-04, 0, -1, 154.,
+    248., 31., 2.7058624267578125e+02, 1.1687197547871619e-04, 0, -1,
+    182., 248., 31., 3.3123800659179688e+02, 9.6187992312479764e-05, 0,
+    -1, 174., 322., 31., 1.3480375671386719e+02, 1.0385271161794662e-04,
+    0, -1, 370., 321., 31., 1.1673779296875000e+02,
+    9.6205360023304820e-05, 0, -1, 368., 321., 31.,
+    1.1202386474609375e+02, 8.1470891018398106e-05, 0, -1, 321., 321.,
+    31., 3.4934213256835938e+02, 1.2975055142305791e-04, 0, -1, 290.,
+    248., 31., 7.4939407348632812e+01, 1.5110230015125126e-04, 0, -1,
+    334., 207., 31., 3.3392953491210938e+02, 1.1211748642381281e-04, 0,
+    -1, 316., 248., 31., 1.2094110107421875e+02, 1.7253118858207017e-04,
+    0, -1, 313., 321., 31., 3.4200189208984375e+02,
+    1.5065791376400739e-04, 0, -1, 302., 321., 31.,
+    2.4473692321777344e+02, 8.9798188128042966e-05, 0, -1, 251., 207.,
+    31., 2.1507730102539062e+02, 9.3520291557069868e-05, 0, -1, 203.,
+    207., 31., 1.9521757507324219e+02, 1.1444615665823221e-04, 0, -1,
+    163., 207., 31., 2.2914482116699219e+02, 1.4493800699710846e-04, 0,
+    -1, 241., 173., 31., 2.1028533935546875e+01, 1.1512739729369059e-04,
+    0, -1, 387., 248., 31., 2.6302465820312500e+02,
+    1.2351665645837784e-04, 0, -1, 389., 248., 31.,
+    2.5256268310546875e+02, 1.5230370627250522e-04, 0, -1, 401., 248.,
+    31., 2.1630195617675781e+02, 9.7580712463241071e-05, 0, -1, 207.,
+    321., 31., 2.7262863159179688e+02, 1.0664516594260931e-04, 0, -1,
+    373., 320., 31., 1.2007237243652344e+02, 1.7195274995174259e-04, 0,
+    -1, 178., 249., 31., 3.5536218261718750e+02, 8.0793695815373212e-05,
+    0, -1, 365., 320., 31., 1.0366261291503906e+02,
+    1.3436708832159638e-04, 0, -1, 357., 320., 31.,
+    9.7738754272460938e+01, 8.4136241639498621e-05, 0, -1, 306., 320.,
+    31., 2.2059011840820312e+02, 8.1618934927973896e-05, 0, -1, 204.,
+    320., 31., 2.7260839843750000e+02, 1.2360344408079982e-04, 0, -1,
+    370., 319., 31., 1.1288089752197266e+02, 8.4500585217028856e-05, 0,
+    -1, 353., 319., 31., 9.6143753051757812e+01, 1.2255180627107620e-04,
+    0, -1, 190., 319., 31., 3.2741156005859375e+02,
+    1.2431835057213902e-04, 0, -1, 365., 318., 31.,
+    9.9245681762695312e+01, 9.2346679593902081e-05, 0, -1, 316., 318.,
+    31., 3.2968109130859375e+02, 1.6492621216457337e-04, 0, -1, 131.,
+    250., 31., 1.6465191650390625e+02, 1.6649803728796542e-04, 0, -1,
+    232., 175., 31., 3.4104727172851562e+02, 1.1932161578442901e-04, 0,
+    -1, 192., 318., 31., 3.0999032592773438e+02, 1.2949727533850819e-04,
+    0, -1, 310., 205., 31., 3.4514276123046875e+02,
+    8.2793842011597008e-05, 0, -1, 164., 318., 31.,
+    1.6448431396484375e+02, 8.0815014371182770e-05, 0, -1, 360., 317.,
+    31., 9.5903556823730469e+01, 8.6370811914093792e-05, 0, -1, 357.,
+    317., 31., 1.0078413391113281e+02, 9.8699048976413906e-05, 0, -1,
+    441., 175., 31., 3.2252188110351562e+02, 9.3921182269696146e-05, 0,
+    -1, 190., 317., 31., 3.0942483520507812e+02, 1.4134863158687949e-04,
+    0, -1, 254., 205., 31., 2.2846630859375000e+02,
+    9.2191847215872258e-05, 0, -1, 176., 317., 31.,
+    1.5130708312988281e+02, 1.3296224642544985e-04, 0, -1, 342., 250.,
+    31., 2.9961904907226562e+02, 1.6478712495882064e-04, 0, -1, 246.,
+    205., 31., 6.8231994628906250e+01, 1.4001491945236921e-04, 0, -1,
+    415., 204., 31., 5.5613675117492676e+00, 1.4585218741558492e-04, 0,
+    -1, 413., 204., 31., 2.3201450347900391e+01, 1.1118709517177194e-04,
+    0, -1, 327., 204., 31., 3.5840478515625000e+02,
+    1.2428154877852648e-04, 0, -1, 319., 204., 31.,
+    3.3785058593750000e+02, 1.3686816964764148e-04, 0, -1, 401., 250.,
+    31., 2.2480693054199219e+02, 8.4120438259560615e-05, 0, -1, 403.,
+    250., 31., 2.2493473815917969e+02, 1.2727372813969851e-04, 0, -1,
+    438., 250., 31., 2.1201882934570312e+02, 1.0677325190044940e-04, 0,
+    -1, 146., 317., 31., 9.1889457702636719e+01, 1.6322381270583719e-04,
+    0, -1, 354., 316., 31., 1.0178534698486328e+02,
+    9.6407413366250694e-05, 0, -1, 339., 316., 31.,
+    9.2665328979492188e+01, 1.2580178736243397e-04, 0, -1, 298., 316.,
+    31., 2.0498860168457031e+02, 1.7551597557030618e-04, 0, -1, 462.,
+    175., 31., 1.6967224121093750e+02, 8.9819171989802271e-05, 0, -1,
+    289., 251., 31., 8.8818092346191406e+01, 1.6239525575656444e-04, 0,
+    -1, 242., 204., 31., 6.2249298095703125e+01, 1.7082627164199948e-04,
+    0, -1, 236., 204., 31., 5.7020023345947266e+01,
+    9.2489804956130683e-05, 0, -1, 234., 204., 31.,
+    5.5880069732666016e+01, 8.3445615018717945e-05, 0, -1, 352., 251.,
+    31., 2.5786349487304688e+02, 1.7538589600007981e-04, 0, -1, 179.,
+    316., 31., 2.0595639038085938e+02, 8.3953345892950892e-05, 0, -1,
+    406., 315., 31., 1.1373989868164062e+02, 8.7107087892945856e-05, 0,
+    -1, 440., 251., 31., 1.9204417419433594e+02, 1.3625284191220999e-04,
+    0, -1, 342., 315., 31., 9.0241172790527344e+01,
+    1.2963051267433912e-04, 0, -1, 198., 315., 31.,
+    2.9089575195312500e+02, 1.1714156426023692e-04, 0, -1, 198., 252.,
+    31., 3.3317376708984375e+02, 1.4502229169011116e-04, 0, -1, 176.,
+    315., 31., 1.7775500488281250e+02, 8.9921559265349060e-05, 0, -1,
+    431., 176., 31., 1.3877612304687500e+02, 1.5460632857866585e-04, 0,
+    -1, 435., 176., 31., 1.8330932617187500e+02, 1.7655073315836489e-04,
+    0, -1, 340., 314., 31., 9.3738090515136719e+01,
+    1.1768256081268191e-04, 0, -1, 134., 314., 31.,
+    3.3179959106445312e+02, 8.0368743510916829e-05, 0, -1, 131., 314.,
+    31., 3.4510208129882812e+02, 8.4225379396229982e-05, 0, -1, 385.,
+    252., 31., 2.7264437866210938e+02, 1.5087837527971715e-04, 0, -1,
+    304., 203., 31., 3.2750772094726562e+02, 1.2503555626608431e-04, 0,
+    -1, 294., 203., 31., 2.5127072143554688e+02, 1.5325307322200388e-04,
+    0, -1, 426., 313., 31., 1.6248780822753906e+02,
+    8.5972373199183494e-05, 0, -1, 321., 313., 31.,
+    4.1335552215576172e+01, 9.1741501819342375e-05, 0, -1, 316., 313.,
+    31., 3.5563919067382812e+02, 9.6521544037386775e-05, 0, -1, 209.,
+    313., 31., 2.7818164062500000e+02, 1.2153663556091487e-04, 0, -1,
+    207., 313., 31., 2.7847467041015625e+02, 1.6115912876557559e-04, 0,
+    -1, 197., 313., 31., 2.9037588500976562e+02, 1.6248770407401025e-04,
+    0, -1, 187., 313., 31., 3.0309036254882812e+02,
+    1.5230444842018187e-04, 0, -1, 184., 313., 31.,
+    3.0791677856445312e+02, 8.1395759480074048e-05, 0, -1, 291., 202.,
+    31., 2.1304704284667969e+02, 9.6312542154919356e-05, 0, -1, 172.,
+    313., 31., 1.7559123229980469e+02, 1.3005366781726480e-04, 0, -1,
+    163., 313., 31., 1.7057514953613281e+02, 1.0326642950531095e-04, 0,
+    -1, 417., 177., 31., 1.2265348815917969e+02, 1.0662519343895838e-04,
+    0, -1, 289., 254., 31., 9.3118751525878906e+01,
+    9.0061221271753311e-05, 0, -1, 310., 312., 31.,
+    2.8975421142578125e+02, 1.2446424807421863e-04, 0, -1, 210., 202.,
+    31., 8.0080116271972656e+01, 8.9299952378496528e-05, 0, -1, 342.,
+    254., 31., 2.9454101562500000e+02, 1.2555837747640908e-04, 0, -1,
+    202., 312., 31., 2.8369464111328125e+02, 7.6984688348602504e-05, 0,
+    -1, 371., 254., 31., 3.2580267333984375e+02, 1.3153029431123286e-04,
+    0, -1, 382., 254., 31., 2.9533142089843750e+02,
+    9.3741735327057540e-05, 0, -1, 391., 254., 31.,
+    2.4221334838867188e+02, 8.1691170635167509e-05, 0, -1, 169., 312.,
+    31., 1.7164729309082031e+02, 1.3536217738874257e-04, 0, -1, 380.,
+    311., 31., 9.6990585327148438e+01, 9.4000934041105211e-05, 0, -1,
+    308., 311., 31., 2.6402355957031250e+02, 1.4075866783969104e-04, 0,
+    -1, 461., 201., 31., 7.6235305786132812e+01, 8.5774554463569075e-05,
+    0, -1, 195., 311., 31., 2.9643011474609375e+02,
+    1.0474460577825084e-04, 0, -1, 184., 255., 31.,
+    3.3403839111328125e+01, 8.5354819020722061e-05, 0, -1, 295., 255.,
+    31., 7.7759223937988281e+01, 7.8120428952388465e-05, 0, -1, 163.,
+    311., 31., 1.6976553344726562e+02, 1.1168720811838284e-04, 0, -1,
+    385., 178., 31., 2.0935714721679688e+02, 9.8721298854798079e-05, 0,
+    -1, 419., 255., 31., 2.3036752319335938e+02, 1.0481981007615104e-04,
+    0, -1, 316., 310., 31., 3.4278958129882812e+02,
+    8.2549304352141917e-05, 0, -1, 312., 310., 31.,
+    3.0336883544921875e+02, 1.2294341286178678e-04, 0, -1, 413., 178.,
+    31., 1.0321845245361328e+02, 1.6682081331964582e-04, 0, -1, 357.,
+    309., 31., 1.0662225341796875e+02, 1.7224956536665559e-04, 0, -1,
+    308., 309., 31., 2.6290936279296875e+02, 8.3644488768186420e-05, 0,
+    -1, 331., 201., 31., 4.3431655883789062e+01, 9.4780836661811918e-05,
+    0, -1, 305., 309., 31., 2.4609201049804688e+02,
+    1.5590441762469709e-04, 0, -1, 299., 256., 31.,
+    7.3063644409179688e+01, 9.2128779215272516e-05, 0, -1, 291., 309.,
+    31., 1.3110922241210938e+02, 1.4342546637635678e-04, 0, -1, 306.,
+    201., 31., 3.3184454345703125e+02, 1.7303046479355544e-04, 0, -1,
+    360., 256., 31., 2.9134313964843750e+02, 1.2965485802851617e-04, 0,
+    -1, 375., 256., 31., 3.5867056274414062e+02, 1.0172379552386701e-04,
+    0, -1, 303., 201., 31., 3.1554284667968750e+02,
+    9.9661257991101593e-05, 0, -1, 427., 308., 31.,
+    1.5766778564453125e+02, 9.1401881945785135e-05, 0, -1, 303., 308.,
+    31., 2.3001910400390625e+02, 1.5080625598784536e-04, 0, -1, 300.,
+    308., 31., 1.8645791625976562e+02, 7.7891796536277980e-05, 0, -1,
+    288., 308., 31., 1.3007043457031250e+02, 1.5880019054748118e-04, 0,
+    -1, 471., 179., 31., 1.9301164245605469e+02, 1.0582721006358042e-04,
+    0, -1, 187., 180., 31., 2.4468893432617188e+02,
+    1.6961283108685166e-04, 0, -1, 145., 308., 31.,
+    9.4142208099365234e+00, 1.5636919124517590e-04, 0, -1, 309., 257.,
+    31., 9.0479171752929688e+01, 9.4253191491588950e-05, 0, -1, 333.,
+    257., 31., 7.4329994201660156e+01, 9.9557866633404046e-05, 0, -1,
+    132., 308., 31., 3.4808111572265625e+02, 1.1887630535056815e-04, 0,
+    -1, 356., 257., 31., 2.5905505371093750e+02, 8.3046674262732267e-05,
+    0, -1, 130., 308., 31., 3.4714785766601562e+02,
+    9.0852401626762003e-05, 0, -1, 418., 257., 31.,
+    2.3439715576171875e+02, 1.1921169789275154e-04, 0, -1, 354., 307.,
+    31., 1.0767311096191406e+02, 7.9704965173732489e-05, 0, -1, 127.,
+    258., 31., 1.1761580657958984e+02, 9.7113850642926991e-05, 0, -1,
+    131., 258., 31., 1.1630156707763672e+02, 1.4236342394724488e-04, 0,
+    -1, 143., 258., 31., 9.0414047241210938e+01, 8.5164851043373346e-05,
+    0, -1, 169., 201., 31., 1.9477676391601562e+02,
+    7.8823286457918584e-05, 0, -1, 297., 307., 31.,
+    1.6052311706542969e+02, 1.1321515921736136e-04, 0, -1, 229., 258.,
+    31., 2.0798483276367188e+02, 8.6579624621663243e-05, 0, -1, 293.,
+    307., 31., 1.2901695251464844e+02, 1.7691963876131922e-04, 0, -1,
+    283., 307., 31., 1.0755419921875000e+02, 1.1700427421601489e-04, 0,
+    -1, 279., 307., 31., 9.9625450134277344e+01, 1.1649919179035351e-04,
+    0, -1, 188., 307., 31., 3.1156958007812500e+02,
+    1.7108861356973648e-04, 0, -1, 183., 307., 31.,
+    3.1171685791015625e+02, 1.4449786976911128e-04, 0, -1, 289., 306.,
+    31., 1.2883847045898438e+02, 8.7268526840489358e-05, 0, -1, 286.,
+    306., 31., 1.2032781219482422e+02, 1.4564611774403602e-04, 0, -1,
+    426., 200., 31., 1.2345818281173706e+00, 1.1334050941513851e-04, 0,
+    -1, 408., 200., 31., 3.4398983764648438e+02, 1.6739792772568762e-04,
+    0, -1, 162., 306., 31., 1.7727902221679688e+02,
+    1.4266042853705585e-04, 0, -1, 332., 305., 31.,
+    9.9469154357910156e+01, 1.7568645125720650e-04, 0, -1, 283., 305.,
+    31., 9.8810028076171875e+01, 9.9816788861062378e-05, 0, -1, 336.,
+    259., 31., 8.4458557128906250e+01, 8.5769395809620619e-05, 0, -1,
+    277., 305., 31., 9.9916671752929688e+01, 1.3072801812086254e-04, 0,
+    -1, 263., 305., 31., 9.9250656127929688e+01, 1.0439575271448120e-04,
+    0, -1, 275., 304., 31., 9.7803741455078125e+01,
+    1.2295876513235271e-04, 0, -1, 443., 180., 31.,
+    3.5420315551757812e+02, 8.5213694546837360e-05, 0, -1, 173., 304.,
+    31., 2.6908352661132812e+02, 1.3280744315125048e-04, 0, -1, 398.,
+    200., 31., 1.3206329345703125e+02, 1.7197032866533846e-04, 0, -1,
+    420., 303., 31., 1.2403382873535156e+02, 8.8470827904529870e-05, 0,
+    -1, 167., 260., 31., 1.0641563415527344e+02, 1.3148017751518637e-04,
+    0, -1, 239., 181., 31., 4.6684813499450684e+00,
+    9.8676639026962221e-05, 0, -1, 249., 200., 31.,
+    2.9478665161132812e+02, 1.0361111344536766e-04, 0, -1, 222., 260.,
+    31., 2.1758229064941406e+02, 1.7784576630219817e-04, 0, -1, 237.,
+    260., 31., 2.4457798767089844e+02, 8.8967448391485959e-05, 0, -1,
+    329., 303., 31., 1.0235804748535156e+02, 8.9126595412380993e-05, 0,
+    -1, 328., 260., 31., 9.9579193115234375e+01, 1.0971834126394242e-04,
+    0, -1, 267., 303., 31., 9.5433456420898438e+01,
+    1.2523646000772715e-04, 0, -1, 254., 303., 31.,
+    1.0009564971923828e+02, 8.8430242612957954e-05, 0, -1, 167., 303.,
+    31., 2.0579980468750000e+02, 1.6233052883762866e-04, 0, -1, 153.,
+    261., 31., 9.3648315429687500e+01, 1.3881959603168070e-04, 0, -1,
+    161., 303., 31., 1.8528977966308594e+02, 1.3152048632036895e-04, 0,
+    -1, 191., 261., 31., 8.5006217956542969e+01, 1.5994676505215466e-04,
+    0, -1, 227., 261., 31., 2.2865063476562500e+02,
+    1.6485499509144574e-04, 0, -1, 245., 261., 31.,
+    2.5645751953125000e+02, 1.3144795957487077e-04, 0, -1, 447., 181.,
+    31., 3.0678768920898438e+02, 1.2774539936799556e-04, 0, -1, 323.,
+    302., 31., 9.8541030883789062e+01, 9.1647882072720677e-05, 0, -1,
+    362., 261., 31., 6.1630626678466797e+01, 1.5723402611911297e-04, 0,
+    -1, 365., 261., 31., 5.8169837951660156e+01, 1.0025380470324308e-04,
+    0, -1, 470., 181., 31., 1.8064343261718750e+02,
+    1.5578231250401586e-04, 0, -1, 433., 261., 31.,
+    3.4320642089843750e+02, 1.0737745469668880e-04, 0, -1, 167., 262.,
+    31., 1.0522128295898438e+02, 1.5291148156393319e-04, 0, -1, 185.,
+    182., 31., 2.4682122802734375e+02, 9.1657879238482565e-05, 0, -1,
+    265., 302., 31., 9.6183532714843750e+01, 1.2092457473045215e-04, 0,
+    -1, 261., 302., 31., 9.9456275939941406e+01, 1.1135490058222786e-04,
+    0, -1, 232., 262., 31., 2.2036515808105469e+02,
+    1.6130370204336941e-04, 0, -1, 240., 262., 31.,
+    2.3048638916015625e+02, 1.4718083548359573e-04, 0, -1, 252., 262.,
+    31., 2.9100704956054688e+02, 1.3023900100961328e-04, 0, -1, 254.,
+    262., 31., 2.9448620605468750e+02, 1.5199623885564506e-04, 0, -1,
+    245., 302., 31., 1.0026124572753906e+02, 9.8524571512825787e-05, 0,
+    -1, 173., 302., 31., 2.7780261230468750e+02, 1.6383844194933772e-04,
+    0, -1, 412., 301., 31., 9.9455360412597656e+01,
+    1.7550316988490522e-04, 0, -1, 448., 199., 31.,
+    1.3972911071777344e+02, 9.5722716650925577e-05, 0, -1, 197., 263.,
+    31., 7.4824630737304688e+01, 8.8510474597569555e-05, 0, -1, 224.,
+    263., 31., 1.7252239990234375e+02, 1.1361980432411656e-04, 0, -1,
+    260., 263., 31., 2.9154400634765625e+02, 1.0291831131326035e-04, 0,
+    -1, 256., 301., 31., 1.0046425628662109e+02, 1.1139841080876067e-04,
+    0, -1, 254., 301., 31., 1.0072182464599609e+02,
+    9.2851332738064229e-05, 0, -1, 309., 300., 31.,
+    1.0305349731445312e+02, 8.7104926933534443e-05, 0, -1, 444., 199.,
+    31., 1.4403955078125000e+02, 1.5731663734186441e-04, 0, -1, 353.,
+    199., 31., 2.4614617919921875e+02, 1.2271157174836844e-04, 0, -1,
+    251., 300., 31., 1.0165122985839844e+02, 9.1737339971587062e-05, 0,
+    -1, 170., 264., 31., 1.0158328247070312e+02, 1.3239074905868620e-04,
+    0, -1, 181., 264., 31., 1.0018921661376953e+02,
+    1.5688499843236059e-04, 0, -1, 235., 300., 31.,
+    1.0238758087158203e+02, 8.2450642366893589e-05, 0, -1, 409., 299.,
+    31., 1.0308024597167969e+02, 1.3748175115324557e-04, 0, -1, 265.,
+    264., 31., 2.7239404296875000e+02, 1.6247597523033619e-04, 0, -1,
+    271., 264., 31., 2.7984753417968750e+02, 8.8302658696193248e-05, 0,
+    -1, 399., 182., 31., 2.9221246337890625e+02, 1.0234379442408681e-04,
+    0, -1, 362., 264., 31., 6.8380943298339844e+01,
+    1.1344910308253020e-04, 0, -1, 401., 182., 31.,
+    3.0296893310546875e+02, 1.3380330346990377e-04, 0, -1, 403., 182.,
+    31., 3.1065338134765625e+02, 1.0097709309775382e-04, 0, -1, 241.,
+    265., 31., 1.6454586791992188e+02, 1.1637122952379286e-04, 0, -1,
+    278., 265., 31., 3.0493276977539062e+02, 8.1567042798269540e-05, 0,
+    -1, 432., 182., 31., 1.5096786499023438e+02, 1.6652411432005465e-04,
+    0, -1, 246., 299., 31., 9.6981231689453125e+01,
+    9.6456649771425873e-05, 0, -1, 240., 299., 31.,
+    1.0162008666992188e+02, 9.0986752184107900e-05, 0, -1, 465., 182.,
+    31., 1.4336454772949219e+02, 1.7945982108358294e-04, 0, -1, 297.,
+    298., 31., 9.5168548583984375e+01, 1.5769996389281005e-04, 0, -1,
+    341., 199., 31., 3.4644569396972656e+01, 8.4110914031043649e-05, 0,
+    -1, 196., 266., 31., 8.5843261718750000e+01, 1.5394728688988835e-04,
+    0, -1, 202., 266., 31., 7.9702468872070312e+01,
+    1.2627227988559753e-04, 0, -1, 251., 266., 31.,
+    2.4022651672363281e+01, 1.2803250865545124e-04, 0, -1, 275., 266.,
+    31., 2.8285671997070312e+02, 1.1503887071739882e-04, 0, -1, 237.,
+    298., 31., 1.0255554199218750e+02, 8.4211314970161766e-05, 0, -1,
+    160., 298., 31., 1.9856927490234375e+02, 9.5605340902693570e-05, 0,
+    -1, 288., 199., 31., 2.0083489990234375e+02, 9.3722679594065994e-05,
+    0, -1, 449., 183., 31., 2.7381930541992188e+02,
+    1.7518718959763646e-04, 0, -1, 193., 267., 31.,
+    8.9941352844238281e+01, 1.1146713950438425e-04, 0, -1, 213., 199.,
+    31., 8.6961883544921875e+01, 7.8918390499893576e-05, 0, -1, 257.,
+    267., 31., 7.0252906799316406e+01, 1.3611822214443237e-04, 0, -1,
+    210., 199., 31., 1.5540646362304688e+02, 1.7817119078245014e-04, 0,
+    -1, 281., 267., 31., 2.8020574951171875e+02, 1.3836602738592774e-04,
+    0, -1, 285., 267., 31., 2.8667623901367188e+02,
+    9.2964044597465545e-05, 0, -1, 197., 268., 31.,
+    8.7577491760253906e+01, 1.4040534733794630e-04, 0, -1, 463., 183.,
+    31., 1.7943251037597656e+02, 1.2182332284282893e-04, 0, -1, 275.,
+    268., 31., 2.9391921997070312e+02, 1.2921221787109971e-04, 0, -1,
+    289., 268., 31., 2.8388494873046875e+02, 1.3766813208349049e-04, 0,
+    -1, 295., 268., 31., 2.6720294189453125e+02, 8.7203858129214495e-05,
+    0, -1, 367., 268., 31., 5.4331908226013184e+00,
+    1.2921185407321900e-04, 0, -1, 470., 183., 31.,
+    1.9024739074707031e+02, 9.5412498922087252e-05, 0, -1, 387., 297.,
+    31., 9.7048423767089844e+01, 1.0616362851578742e-04, 0, -1, 233.,
+    297., 31., 1.0238419342041016e+02, 7.8501005191355944e-05, 0, -1,
+    435., 268., 31., 3.4604530334472656e+01, 8.3287261077202857e-05, 0,
+    -1, 122., 269., 31., 5.6145977020263672e+01, 1.2788281310349703e-04,
+    0, -1, 429., 198., 31., 1.2797216796875000e+02,
+    1.7700657190289348e-04, 0, -1, 201., 269., 31.,
+    8.5945846557617188e+01, 1.2075251288479194e-04, 0, -1, 145., 297.,
+    31., 3.1653262329101562e+02, 1.2627780961338431e-04, 0, -1, 217.,
+    269., 31., 1.0368949890136719e+02, 1.6380473971366882e-04, 0, -1,
+    222., 269., 31., 1.0539881896972656e+02, 1.2046085612382740e-04, 0,
+    -1, 268., 269., 31., 1.1698918914794922e+02, 7.7296346717048436e-05,
+    0, -1, 375., 198., 31., 1.8387028503417969e+02,
+    1.5408541366923600e-04, 0, -1, 292., 269., 31.,
+    2.6915777587890625e+02, 1.3486068928614259e-04, 0, -1, 365., 198.,
+    31., 2.2796472167968750e+02, 1.6888596292119473e-04, 0, -1, 143.,
+    297., 31., 2.1509593200683594e+02, 1.5176070155575871e-04, 0, -1,
+    221., 198., 31., 6.5124961853027344e+01, 1.3365938502829522e-04, 0,
+    -1, 282., 184., 31., 2.6200170898437500e+02, 9.2039888841100037e-05,
+    0, -1, 416., 269., 31., 1.2982151794433594e+02,
+    1.7691610264591873e-04, 0, -1, 403., 184., 31.,
+    3.1023876953125000e+02, 1.0808664956130087e-04, 0, -1, 463., 197.,
+    31., 2.7119769287109375e+02, 1.3685986050404608e-04, 0, -1, 457.,
+    197., 31., 7.6859455108642578e+00, 1.5418180555570871e-04, 0, -1,
+    435., 184., 31., 1.4002819824218750e+02, 9.8727330623660237e-05, 0,
+    -1, 276., 270., 31., 7.6603096008300781e+01, 9.4090515631251037e-05,
+    0, -1, 278., 270., 31., 3.5112265014648438e+02,
+    1.0022911010310054e-04, 0, -1, 283., 270., 31.,
+    2.9814031982421875e+02, 1.6006780788302422e-04, 0, -1, 301., 270.,
+    31., 3.0425512695312500e+02, 1.7234799452126026e-04, 0, -1, 283.,
+    296., 31., 1.1144719696044922e+02, 8.0304205766879022e-05, 0, -1,
+    431., 197., 31., 1.3750677490234375e+02, 9.8506076028570533e-05, 0,
+    -1, 207., 296., 31., 1.0236299896240234e+02, 7.9768840805627406e-05,
+    0, -1, 216., 271., 31., 1.0252798461914062e+02,
+    1.0866673255804926e-04, 0, -1, 439., 184., 31.,
+    9.2694725036621094e+01, 1.5390805492643267e-04, 0, -1, 388., 295.,
+    31., 9.4357650756835938e+01, 1.4994430239312351e-04, 0, -1, 287.,
+    271., 31., 2.3011041259765625e+02, 1.0224393190583214e-04, 0, -1,
+    385., 295., 31., 9.5941055297851562e+01, 1.0371738608228043e-04, 0,
+    -1, 434., 271., 31., 1.3869653320312500e+02, 7.9406076110899448e-05,
+    0, -1, 467., 184., 31., 1.9636943054199219e+02,
+    1.4859520888421685e-04, 0, -1, 326., 197., 31.,
+    4.0911221504211426e+00, 1.5695080219302326e-04, 0, -1, 132., 272.,
+    31., 1.0049432373046875e+02, 1.2446260370779783e-04, 0, -1, 280.,
+    197., 31., 1.7927227783203125e+02, 7.6998105214443058e-05, 0, -1,
+    220., 272., 31., 1.0028283691406250e+02, 1.2093580880900845e-04, 0,
+    -1, 224., 272., 31., 1.0076174163818359e+02, 1.3388595834840089e-04,
+    0, -1, 240., 272., 31., 1.0133715820312500e+02,
+    1.5445346070919186e-04, 0, -1, 219., 295., 31.,
+    9.6766258239746094e+01, 9.3698377895634621e-05, 0, -1, 318., 272.,
+    31., 3.3366070556640625e+02, 1.5706803242210299e-04, 0, -1, 323.,
+    272., 31., 1.5356917381286621e+00, 8.3343737060204148e-05, 0, -1,
+    130., 295., 31., 3.2518191528320312e+02, 1.0109954746440053e-04, 0,
+    -1, 387., 272., 31., 2.1386880493164062e+02, 1.3714836677536368e-04,
+    0, -1, 127., 295., 31., 3.4372100830078125e+02,
+    1.1144656309625134e-04, 0, -1, 408., 272., 31.,
+    1.1766690063476562e+02, 1.2623901420738548e-04, 0, -1, 376., 294.,
+    31., 9.6162841796875000e+01, 1.1480088141979650e-04, 0, -1, 418.,
+    272., 31., 1.1555011749267578e+02, 1.1305293446639553e-04, 0, -1,
+    401., 185., 31., 3.0039456176757812e+02, 1.4438564539887011e-04, 0,
+    -1, 272., 294., 31., 9.3292961120605469e+01, 1.0678003309294581e-04,
+    0, -1, 248., 273., 31., 9.8780265808105469e+01,
+    9.8987460660282522e-05, 0, -1, 293., 273., 31.,
+    1.2521086120605469e+02, 8.0266079748980701e-05, 0, -1, 300., 273.,
+    31., 3.2462158203125000e+02, 8.8995991973206401e-05, 0, -1, 216.,
+    186., 31., 2.1396823120117188e+02, 9.1454829089343548e-05, 0, -1,
+    209., 294., 31., 1.0297093963623047e+02, 1.0217450471827760e-04, 0,
+    -1, 368., 273., 31., 2.9066064453125000e+02, 1.7931999173015356e-04,
+    0, -1, 382., 273., 31., 2.2380850219726562e+02,
+    1.0909207048825920e-04, 0, -1, 196., 294., 31.,
+    9.4935997009277344e+01, 1.1146532051498070e-04, 0, -1, 397., 196.,
+    31., 1.2782072448730469e+02, 1.5335394709836692e-04, 0, -1, 354.,
+    196., 31., 2.7521041870117188e+02, 7.9750607255846262e-05, 0, -1,
+    314., 196., 31., 4.9342794418334961e+00, 7.9021410783752799e-05, 0,
+    -1, 141., 274., 31., 9.6978126525878906e+01, 7.7806471381336451e-05,
+    0, -1, 360., 293., 31., 1.0184429931640625e+02,
+    1.0359859152231365e-04, 0, -1, 333., 186., 31.,
+    2.9815652465820312e+02, 1.6978444182313979e-04, 0, -1, 302., 274.,
+    31., 2.0356147766113281e+01, 9.6128103905357420e-05, 0, -1, 305.,
+    274., 31., 3.2949594116210938e+02, 1.3261483400128782e-04, 0, -1,
+    380., 274., 31., 2.3173391723632812e+02, 1.6814931586850435e-04, 0,
+    -1, 419., 274., 31., 1.1661066436767578e+02, 1.5893489762675017e-04,
+    0, -1, 454., 195., 31., 3.4757775878906250e+02,
+    1.4437499339692295e-04, 0, -1, 242., 275., 31.,
+    9.9785766601562500e+01, 1.1979572445852682e-04, 0, -1, 436., 186.,
+    31., 1.3287750244140625e+02, 8.4950057498645037e-05, 0, -1, 311.,
+    275., 31., 2.9465118408203125e+02, 1.3428971578832716e-04, 0, -1,
+    258., 292., 31., 1.0361104583740234e+02, 7.8062330430839211e-05, 0,
+    -1, 194., 292., 31., 9.3978355407714844e+01, 1.2598393368534744e-04,
+    0, -1, 372., 195., 31., 2.0460742187500000e+02,
+    1.0271471546730027e-04, 0, -1, 314., 187., 31.,
+    2.4840612792968750e+02, 8.8866923761088401e-05, 0, -1, 308., 195.,
+    31., 2.9912490844726562e+02, 9.0677043772302568e-05, 0, -1, 301.,
+    195., 31., 2.8139086914062500e+02, 1.6768621571827680e-04, 0, -1,
+    257., 195., 31., 2.4347482299804688e+02, 1.6087362018879503e-04, 0,
+    -1, 246., 276., 31., 9.7420257568359375e+01, 1.2169921683380380e-04,
+    0, -1, 358., 291., 31., 1.0445317077636719e+02,
+    8.7328007793985307e-05, 0, -1, 263., 276., 31.,
+    1.0110787963867188e+02, 1.4712517440784723e-04, 0, -1, 269., 276.,
+    31., 9.8719123840332031e+01, 1.3383262557908893e-04, 0, -1, 315.,
+    276., 31., 9.9483060836791992e+00, 9.2245863925199956e-05, 0, -1,
+    319., 276., 31., 3.5160528564453125e+02, 7.9725788964424282e-05, 0,
+    -1, 357., 276., 31., 2.2105052185058594e+02, 1.4671984536107630e-04,
+    0, -1, 360., 276., 31., 2.4116831970214844e+02,
+    8.8831438915804029e-05, 0, -1, 208., 195., 31.,
+    2.0872192382812500e+02, 9.8661941592581570e-05, 0, -1, 381., 276.,
+    31., 2.3724411010742188e+02, 1.5221405192278326e-04, 0, -1, 188.,
+    195., 31., 4.3798336029052734e+01, 1.3739695714320987e-04, 0, -1,
+    344., 291., 31., 1.0551057434082031e+02, 1.5075410192366689e-04, 0,
+    -1, 399., 187., 31., 2.9931521606445312e+02, 9.0550740424077958e-05,
+    0, -1, 416., 276., 31., 1.3422067260742188e+02,
+    8.7190834165085107e-05, 0, -1, 196., 291., 31.,
+    9.6981285095214844e+01, 7.8531593317165971e-05, 0, -1, 164., 277.,
+    31., 1.1043589782714844e+02, 8.3187995187472552e-05, 0, -1, 180.,
+    291., 31., 3.3261804199218750e+02, 1.0358435247326270e-04, 0, -1,
+    141., 291., 31., 2.6372985839843750e+02, 1.5397678362205625e-04, 0,
+    -1, 272., 277., 31., 9.8518501281738281e+01, 1.2674913159571588e-04,
+    0, -1, 322., 277., 31., 1.1746326684951782e+00,
+    1.2869670172221959e-04, 0, -1, 380., 290., 31.,
+    9.3061004638671875e+01, 1.0116495104739442e-04, 0, -1, 340., 290.,
+    31., 1.0840328979492188e+02, 1.5540690219495445e-04, 0, -1, 347.,
+    194., 31., 3.5601242065429688e+02, 1.3160759408492595e-04, 0, -1,
+    422., 277., 31., 1.1587014007568359e+02, 1.0731772636063397e-04, 0,
+    -1, 125., 278., 31., 3.4557986450195312e+02, 1.6021849296521395e-04,
+    0, -1, 237., 290., 31., 9.3328231811523438e+01,
+    1.6517918265890330e-04, 0, -1, 262., 278., 31.,
+    1.0027793121337891e+02, 1.0455442679813132e-04, 0, -1, 177., 290.,
+    31., 3.1759692382812500e+02, 1.4963958528824151e-04, 0, -1, 170.,
+    290., 31., 2.7847836303710938e+02, 1.0888823453569785e-04, 0, -1,
+    254., 194., 31., 2.5269390869140625e+02, 1.2472536764107645e-04, 0,
+    -1, 266., 279., 31., 9.9656936645507812e+01, 1.1120722774649039e-04,
+    0, -1, 271., 279., 31., 9.8730529785156250e+01,
+    1.4570311759598553e-04, 0, -1, 347., 289., 31.,
+    1.1249273681640625e+02, 1.3599247904494405e-04, 0, -1, 421., 279.,
+    31., 1.2522343444824219e+02, 1.6496836906298995e-04, 0, -1, 335.,
+    289., 31., 1.0472944641113281e+02, 9.4635361165273935e-05, 0, -1,
+    183., 289., 31., 9.4869279861450195e+00, 9.4955561507958919e-05, 0,
+    -1, 180., 289., 31., 3.3524371337890625e+02, 8.3697806985583156e-05,
+    0, -1, 175., 289., 31., 3.1111373901367188e+02,
+    1.1243687913520262e-04, 0, -1, 289., 280., 31.,
+    1.0099018859863281e+02, 1.5215194434858859e-04, 0, -1, 294., 280.,
+    31., 9.8970771789550781e+01, 1.1890245514223352e-04, 0, -1, 353.,
+    280., 31., 2.0743647766113281e+02, 9.0058951172977686e-05, 0, -1,
+    356., 280., 31., 2.1045782470703125e+02, 8.5083855083212256e-05, 0,
+    -1, 404., 193., 31., 3.2698980712890625e+02, 7.9824567364994437e-05,
+    0, -1, 212., 193., 31., 2.0926484680175781e+02,
+    1.0569154255790636e-04, 0, -1, 168., 289., 31.,
+    2.6222317504882812e+02, 1.5851334319449961e-04, 0, -1, 188., 281.,
+    31., 1.0168836212158203e+02, 9.3233669758774340e-05, 0, -1, 159.,
+    289., 31., 2.2350782775878906e+02, 1.7492074402980506e-04, 0, -1,
+    291., 281., 31., 9.9692375183105469e+01, 1.5934246766846627e-04, 0,
+    -1, 297., 281., 31., 9.8008003234863281e+01, 1.3643670536112040e-04,
+    0, -1, 317., 188., 31., 2.6872097778320312e+02,
+    1.1201039160368964e-04, 0, -1, 128., 289., 31.,
+    3.4390209960937500e+02, 1.6759400023147464e-04, 0, -1, 396., 281.,
+    31., 4.6995910644531250e+01, 1.6902701463550329e-04, 0, -1, 429.,
+    281., 31., 1.6322125244140625e+02, 8.5392741311807185e-05, 0, -1,
+    126., 289., 31., 3.4740026855468750e+02, 1.2848275946453214e-04, 0,
+    -1, 395., 188., 31., 2.7288519287109375e+02, 8.1745522038545460e-05,
+    0, -1, 288., 282., 31., 1.0167831420898438e+02,
+    1.0947504779323936e-04, 0, -1, 299., 282., 31.,
+    9.8431419372558594e+01, 9.1749519924633205e-05, 0, -1, 447., 188.,
+    31., 2.5392248535156250e+02, 1.7997714166995138e-04, 0, -1, 450.,
+    188., 31., 2.6730120849609375e+02, 1.5537453873548657e-04, 0, -1,
+    398., 288., 31., 9.3877265930175781e+01, 1.1099850962636992e-04, 0,
+    -1, 375., 288., 31., 9.5330398559570312e+01, 1.0085561370942742e-04,
+    0, -1, 462., 188., 31., 2.6821627807617188e+02,
+    1.0617016960168257e-04, 0, -1, 338., 288., 31.,
+    1.1061625671386719e+02, 1.7980059783440083e-04, 0, -1, 188., 189.,
+    31., 1.8052064895629883e+01, 8.4928527940064669e-05, 0, -1, 406.,
+    282., 31., 1.5244137573242188e+02, 1.4411064330488443e-04, 0, -1,
+    177., 288., 31., 3.1946478271484375e+02, 8.9513094280846417e-05, 0,
+    -1, 334., 192., 31., 3.2732098388671875e+02, 1.7027865396812558e-04,
+    0, -1, 427., 287., 31., 2.0201873779296875e+02,
+    1.1093587818322703e-04, 0, -1, 341., 287., 31.,
+    1.1544007110595703e+02, 1.4545106387231499e-04, 0, -1, 292., 283.,
+    31., 9.9048362731933594e+01, 1.1651262320810929e-04, 0, -1, 296.,
+    283., 31., 9.7910179138183594e+01, 1.2501601304393262e-04, 0, -1,
+    313., 283., 31., 9.7970260620117188e+01, 1.4010368613526225e-04, 0,
+    -1, 190., 192., 31., 2.7038953781127930e+01, 9.5130519184749573e-05,
+    0, -1, 389., 283., 31., 5.5010921478271484e+01,
+    1.1367557453922927e-04, 0, -1, 465., 191., 31.,
+    2.4456738281250000e+02, 1.5412442735396326e-04, 0, -1, 336., 287.,
+    31., 1.0838539123535156e+02, 1.3399976887740195e-04, 0, -1, 320.,
+    287., 31., 9.4446281433105469e+01, 1.1578372505027801e-04, 0, -1,
+    303., 189., 31., 2.7335931396484375e+02, 8.8742395746521652e-05, 0,
+    -1, 347., 191., 31., 3.4689077758789062e+02, 9.2963964561931789e-05,
+    0, -1, 166., 287., 31., 2.4996673583984375e+02,
+    1.1334754526615143e-04, 0, -1, 392., 189., 31.,
+    1.5443611145019531e+02, 1.2463015445973724e-04, 0, -1, 239., 191.,
+    31., 3.4911992549896240e+00, 8.8898072135634720e-05, 0, -1, 222.,
+    191., 31., 6.4172592163085938e+01, 1.1637155694188550e-04, 0, -1,
+    464., 189., 31., 2.5452349853515625e+02, 1.2078483996447176e-04, 0,
+    -1, 311., 286., 31., 9.9088127136230469e+01, 1.0250404011458158e-04,
+    0, -1, 160., 285., 31., 2.2682731628417969e+02,
+    1.2111679825466126e-04, 0, -1, 163., 286., 31.,
+    2.3044049072265625e+02, 1.3561025843955576e-04, 0, -1, 212., 285.,
+    31., 9.8219085693359375e+01, 8.7190113845281303e-05, 0, -1, 143.,
+    286., 31., 2.6320187377929688e+02, 1.3766420306637883e-04, 0, -1,
+    402., 190., 31., 3.3575909423828125e+02, 9.3127433501649648e-05, 0,
+    -1, 388., 190., 31., 1.5471176147460938e+02, 1.5752918261568993e-04,
+    0, -1, 321., 285., 31., 9.1778182983398438e+01,
+    1.2655992759391665e-04, 0, -1, 317., 190., 31.,
+    2.7225003051757812e+02, 1.4759210171177983e-04, 0, -1, 164., 230.,
+    31., 9.1549194335937500e+01, 6.8308771005831659e-05, 0, -1, 371.,
+    285., 31., 1.2060550689697266e+02, 6.9576264650095254e-05, 0, -1,
+    395., 231., 31., 1.5983206176757812e+02, 7.5736046710517257e-05, 0,
+    -1, 247., 345., 31., 1.0900497436523438e+02, 7.5154261139687151e-05,
+    0, -1, 320., 158., 31., 9.1495559692382812e+01,
+    6.9883048126939684e-05, 0, -1, 242., 344., 31.,
+    1.1069661712646484e+02, 7.0442372816614807e-05, 0, -1, 286., 235.,
+    31., 2.9232449340820312e+02, 7.0462854637298733e-05, 0, -1, 233.,
+    342., 31., 9.6379684448242188e+01, 7.4698247772175819e-05, 0, -1,
+    323., 286., 31., 9.2280212402343750e+01, 7.5993841164745390e-05, 0,
+    -1, 267., 236., 31., 2.1627145385742188e+02, 6.8434048444032669e-05,
+    0, -1, 269., 236., 31., 2.1420086669921875e+02,
+    7.3565723141655326e-05, 0, -1, 161., 229., 31.,
+    1.5433520507812500e+02, 7.5477320933714509e-05, 0, -1, 152., 238.,
+    31., 1.3220822143554688e+02, 6.9720932515338063e-05, 0, -1, 215.,
+    339., 31., 1.0468019104003906e+02, 6.9952038757037371e-05, 0, -1,
+    233., 238., 31., 2.5379820251464844e+02, 7.0767135184723884e-05, 0,
+    -1, 384., 213., 31., 2.9928592681884766e+01, 7.5546624429989606e-05,
+    0, -1, 201., 213., 31., 8.5049713134765625e+01,
+    6.9905538111925125e-05, 0, -1, 226., 287., 31.,
+    8.8917472839355469e+01, 7.1784437750466168e-05, 0, -1, 321., 335.,
+    31., 2.1462104797363281e+02, 6.8604225816670805e-05, 0, -1, 201.,
+    227., 31., 4.7035625457763672e+01, 7.0161142502911389e-05, 0, -1,
+    212., 334., 31., 1.0421760559082031e+02, 6.9812536821700633e-05, 0,
+    -1, 321., 333., 31., 2.8568045043945312e+02, 7.1080852649174631e-05,
+    0, -1, 335., 354., 31., 1.8384829711914062e+02,
+    7.0836365921422839e-05, 0, -1, 298., 241., 31.,
+    3.0827716064453125e+02, 6.8966779508627951e-05, 0, -1, 373., 287.,
+    31., 9.9120491027832031e+01, 7.4426789069548249e-05, 0, -1, 282.,
+    212., 31., 1.8433477783203125e+02, 6.8779532739426941e-05, 0, -1,
+    225., 189., 31., 2.7899335861206055e+01, 7.1058006142266095e-05, 0,
+    -1, 214., 242., 31., 2.7788583374023438e+02, 7.3717761551961303e-05,
+    0, -1, 395., 165., 31., 9.4031875610351562e+01,
+    7.3617891757749021e-05, 0, -1, 433., 165., 31.,
+    3.1811199951171875e+02, 7.5446878327056766e-05, 0, -1, 305., 211.,
+    31., 2.9177307128906250e+01, 6.9367364631034434e-05, 0, -1, 209.,
+    243., 31., 3.5296124267578125e+02, 7.2715454734861851e-05, 0, -1,
+    385., 166., 31., 9.2917755126953125e+01, 7.1655980718787760e-05, 0,
+    -1, 378., 282., 31., 1.7944306945800781e+02, 6.9720947067253292e-05,
+    0, -1, 443., 243., 31., 1.6516081237792969e+02,
+    7.0916910772211850e-05, 0, -1, 165., 217., 31.,
+    2.6820794677734375e+02, 7.0723843236919492e-05, 0, -1, 343., 355.,
+    31., 2.5860922241210938e+02, 6.9292305852286518e-05, 0, -1, 391.,
+    167., 31., 7.7449546813964844e+01, 7.1195026976056397e-05, 0, -1,
+    157., 245., 31., 1.9418359375000000e+02, 7.0923459134064615e-05, 0,
+    -1, 234., 245., 31., 1.6735165405273438e+02, 7.3218630859628320e-05,
+    0, -1, 266., 245., 31., 1.7706817626953125e+02,
+    7.3771894676610827e-05, 0, -1, 336., 245., 31.,
+    3.2374984741210938e+02, 7.3763410910032690e-05, 0, -1, 134., 326.,
+    31., 3.1349679565429688e+02, 7.2199960413854569e-05, 0, -1, 163.,
+    246., 31., 1.7165873718261719e+02, 7.5125957664567977e-05, 0, -1,
+    343., 209., 31., 3.2084829711914062e+02, 7.6305921538732946e-05, 0,
+    -1, 218., 171., 31., 1.4973678588867188e+02, 7.2721428296063095e-05,
+    0, -1, 409., 171., 31., 1.1795173645019531e+02,
+    7.1280650445260108e-05, 0, -1, 476., 172., 31.,
+    1.9901411437988281e+02, 7.2342976636718959e-05, 0, -1, 430., 173.,
+    31., 1.6378622436523438e+02, 7.4550967838149518e-05, 0, -1, 215.,
+    194., 31., 1.6681941223144531e+02, 7.4901421612594277e-05, 0, -1,
+    374., 373., 31., 2.7938513183593750e+02, 7.3756164056248963e-05, 0,
+    -1, 359., 205., 31., 1.4142262268066406e+02, 7.0927606429904699e-05,
+    0, -1, 330., 359., 31., 2.4685955810546875e+02,
+    7.2937626100610942e-05, 0, -1, 333., 359., 31.,
+    2.1956201171875000e+02, 7.4180286901537329e-05, 0, -1, 214., 188.,
+    31., 2.0866847229003906e+02, 6.8588880822062492e-05, 0, -1, 269.,
+    250., 31., 1.2427940368652344e+02, 7.5573043432086706e-05, 0, -1,
+    305., 194., 31., 2.8446313476562500e+02, 6.8624096456915140e-05, 0,
+    -1, 274., 278., 31., 9.8776374816894531e+01, 6.9969719334039837e-05,
+    0, -1, 451., 175., 31., 2.9915112304687500e+02,
+    7.0614762080367655e-05, 0, -1, 257., 204., 31.,
+    2.3292860412597656e+02, 7.3079761932604015e-05, 0, -1, 428., 176.,
+    31., 1.3807397460937500e+02, 7.6025055022910237e-05, 0, -1, 211.,
+    204., 31., 6.0265647888183594e+01, 6.8507608375512064e-05, 0, -1,
+    328., 315., 31., 8.0937667846679688e+01, 7.5224248575977981e-05, 0,
+    -1, 147., 224., 31., 2.0702609252929688e+02, 7.4370014772284776e-05,
+    0, -1, 273., 252., 31., 1.1057676696777344e+02,
+    7.0699003117624670e-05, 0, -1, 291., 223., 31.,
+    7.4676841735839844e+01, 7.2764960350468755e-05, 0, -1, 335., 313.,
+    31., 1.0111258697509766e+02, 7.5736286817118526e-05, 0, -1, 281.,
+    253., 31., 9.6609451293945312e+01, 7.0778180088382214e-05, 0, -1,
+    164., 203., 31., 2.1377375793457031e+02, 7.1567068516742438e-05, 0,
+    -1, 326., 312., 31., 7.8599990844726562e+01, 7.5202537118457258e-05,
+    0, -1, 367., 254., 31., 3.1753994750976562e+02,
+    7.2539281973149627e-05, 0, -1, 321., 311., 31.,
+    4.1166027069091797e+01, 7.0279282226692885e-05, 0, -1, 419., 201.,
+    31., 3.4450711059570312e+02, 7.1496426244266331e-05, 0, -1, 302.,
+    362., 31., 2.7875793457031250e+02, 7.5385622039902955e-05, 0, -1,
+    437., 255., 31., 2.6200128173828125e+02, 7.6178534072823822e-05, 0,
+    -1, 440., 255., 31., 2.0707592773437500e+02, 7.3860079282894731e-05,
+    0, -1, 226., 257., 31., 1.9204306030273438e+02,
+    7.1839196607470512e-05, 0, -1, 369., 258., 31.,
+    3.3964817047119141e+01, 7.0289832365233451e-05, 0, -1, 402., 180.,
+    31., 3.1150268554687500e+02, 7.1732931246515363e-05, 0, -1, 201.,
+    292., 31., 9.5555404663085938e+01, 6.8984030804131180e-05, 0, -1,
+    359., 259., 31., 5.9814514160156250e+01, 7.4708579631987959e-05, 0,
+    -1, 310., 363., 31., 2.7648712158203125e+02, 7.3848015745170414e-05,
+    0, -1, 410., 260., 31., 2.2767669677734375e+02,
+    7.1207570726983249e-05, 0, -1, 166., 200., 31.,
+    2.0003352355957031e+02, 7.4624811531975865e-05, 0, -1, 464., 199.,
+    31., 1.8604988098144531e+02, 7.0429610786959529e-05, 0, -1, 357.,
+    264., 31., 8.8716339111328125e+01, 7.5090552854817361e-05, 0, -1,
+    367., 265., 31., 4.7775882720947266e+01, 7.6611213444266468e-05, 0,
+    -1, 305., 183., 31., 2.3727040100097656e+02, 7.5241187005303800e-05,
+    0, -1, 436., 266., 31., 2.9626049804687500e+02,
+    7.5450072472449392e-05, 0, -1, 252., 146., 31.,
+    7.1651458740234375e+01, 7.0402442361228168e-05, 0, -1, 190., 293.,
+    31., 7.2134811401367188e+01, 6.9015979534015059e-05, 0, -1, 413.,
+    196., 31., 3.1793942260742188e+02, 7.3439812695141882e-05, 0, -1,
+    261., 145., 31., 3.5178466796875000e+01, 7.0262460212688893e-05, 0,
+    -1, 325., 155., 31., 8.8314689636230469e+01, 3.3907486795214936e-05,
+    0, -1, 267., 186., 31., 2.3388755798339844e+02,
+    5.3884974477114156e-05, 0, -1, 306., 196., 31.,
+    2.9905670166015625e+02, 4.7798806917853653e-05, 0, -1, 407., 196.,
+    31., 3.1023645019531250e+02, 4.4913093006471172e-05, 0, -1, 325.,
+    273., 31., 4.3472137451171875e+00, 6.5906635427381843e-05, 0, -1,
+    214., 294., 31., 1.0146842956542969e+02, 6.1033962992951274e-05, 0,
+    -1, 220., 186., 31., 2.2181872558593750e+02, 5.1802158850478008e-05,
+    0, -1, 246., 145., 31., 2.8007446289062500e+02,
+    3.4702879929682240e-05, 0, -1, 389., 230., 31.,
+    1.3305007934570312e+02, 6.4491374359931797e-05, 0, -1, 203., 231.,
+    31., 1.5980676412582397e+00, 6.6252912802156061e-05, 0, -1, 466.,
+    196., 31., 2.1267193603515625e+02, 4.8653950216248631e-05, 0, -1,
+    166., 197., 31., 2.0434570312500000e+02, 4.3933847337029874e-05, 0,
+    -1, 238., 156., 31., 7.0340576171875000e+01, 4.1926719859475270e-05,
+    0, -1, 390., 218., 31., 2.4778552246093750e+02,
+    5.2609659178415313e-05, 0, -1, 182., 197., 31.,
+    4.6613471984863281e+01, 5.0541824748506770e-05, 0, -1, 127., 286.,
+    31., 3.5694042968750000e+02, 6.7824010329786688e-05, 0, -1, 288.,
+    347., 31., 4.1356388092041016e+01, 4.6589506382588297e-05, 0, -1,
+    321., 185., 31., 2.8749194335937500e+02, 4.1139439417747781e-05, 0,
+    -1, 303., 349., 31., 3.0142413330078125e+02, 5.7543766160961241e-05,
+    0, -1, 210., 232., 31., 3.0964190673828125e+02,
+    5.1401006203377619e-05, 0, -1, 198., 295., 31.,
+    9.7225654602050781e+01, 5.7012450270121917e-05, 0, -1, 216., 295.,
+    31., 9.8458770751953125e+01, 6.4451909565832466e-05, 0, -1, 216.,
+    347., 31., 2.7688754272460938e+02, 5.3128878789721057e-05, 0, -1,
+    291., 215., 31., 1.3806367492675781e+02, 5.2531882829498500e-05, 0,
+    -1, 386., 229., 31., 1.1997004699707031e+02, 6.1184611695352942e-05,
+    0, -1, 345., 197., 31., 1.2815616607666016e+01,
+    6.4499974541831762e-05, 0, -1, 281., 215., 31.,
+    1.7183926391601562e+02, 5.2706349379150197e-05, 0, -1, 236., 271.,
+    31., 1.0265174865722656e+02, 4.5677501475438476e-05, 0, -1, 228.,
+    271., 31., 1.0146142578125000e+02, 6.4225474488921463e-05, 0, -1,
+    357., 197., 31., 2.4241838073730469e+02, 3.7390527722891420e-05, 0,
+    -1, 228., 296., 31., 9.5659660339355469e+01, 5.9992722526658326e-05,
+    0, -1, 309., 221., 31., 6.8227951049804688e+01,
+    6.3287217926699668e-05, 0, -1, 384., 270., 31.,
+    2.2531787109375000e+02, 5.4714320867788047e-05, 0, -1, 324., 157.,
+    31., 8.6695953369140625e+01, 5.3765721531817690e-05, 0, -1, 359.,
+    222., 31., 1.2193547821044922e+02, 4.2643347114790231e-05, 0, -1,
+    206., 198., 31., 2.0120783996582031e+02, 4.7937697672750801e-05, 0,
+    -1, 335., 198., 31., 2.4794809341430664e+01, 6.1338359955698252e-05,
+    0, -1, 214., 269., 31., 1.0195641326904297e+02,
+    4.8458266974193975e-05, 0, -1, 349., 349., 31.,
+    2.8328103637695312e+02, 5.1830254960805178e-05, 0, -1, 216., 297.,
+    31., 9.9964675903320312e+01, 6.3714687712490559e-05, 0, -1, 420.,
+    268., 31., 1.1252178955078125e+02, 3.4694483474595472e-05, 0, -1,
+    366., 222., 31., 1.1054016113281250e+02, 4.2968858906533569e-05, 0,
+    -1, 331., 157., 31., 8.5899002075195312e+01, 5.0245980673935264e-05,
+    0, -1, 180., 234., 31., 3.3385186767578125e+02,
+    6.1791164625901729e-05, 0, -1, 385., 268., 31.,
+    2.3169332885742188e+02, 4.0048977098194882e-05, 0, -1, 205., 268.,
+    31., 8.4496116638183594e+01, 4.8754998715594411e-05, 0, -1, 268.,
+    234., 31., 2.1341194152832031e+02, 4.9618069169810042e-05, 0, -1,
+    280., 234., 31., 2.5603851318359375e+02, 6.5522501245141029e-05, 0,
+    -1, 210., 158., 31., 3.2520944213867188e+02, 5.8212983276462182e-05,
+    0, -1, 322., 183., 31., 2.8988720703125000e+02,
+    3.4620621590875089e-05, 0, -1, 411., 265., 31.,
+    1.8820578002929688e+02, 5.8985053328797221e-05, 0, -1, 316., 183.,
+    31., 2.5505941772460938e+02, 5.0526145059848204e-05, 0, -1, 297.,
+    274., 31., 9.0504745483398438e+01, 4.6080731408437714e-05, 0, -1,
+    293., 234., 31., 3.0371591186523438e+02, 6.1322396504692733e-05, 0,
+    -1, 472., 182., 31., 1.9424369812011719e+02, 4.1200786654371768e-05,
+    0, -1, 408., 265., 31., 1.9152041625976562e+02,
+    5.6256190873682499e-05, 0, -1, 417., 219., 31.,
+    4.7545673370361328e+01, 3.5987428418593481e-05, 0, -1, 296., 234.,
+    31., 3.0141506958007812e+02, 5.2349365432746708e-05, 0, -1, 344.,
+    265., 31., 1.0221742248535156e+02, 4.8822690587257966e-05, 0, -1,
+    343., 199., 31., 3.3533927917480469e+01, 5.4471427574753761e-05, 0,
+    -1, 305., 154., 31., 9.1578269958496094e+01, 6.0727590607712045e-05,
+    0, -1, 233., 264., 31., 1.6758430480957031e+02,
+    6.2935636378824711e-05, 0, -1, 391., 182., 31.,
+    2.6433703613281250e+02, 4.7014134906930849e-05, 0, -1, 370., 222.,
+    31., 1.0395592498779297e+02, 5.5893720855237916e-05, 0, -1, 310.,
+    344., 31., 2.5508941650390625e+01, 3.5827993997372687e-05, 0, -1,
+    245., 147., 31., 4.9307964324951172e+01, 4.1479765059193596e-05, 0,
+    -1, 210., 136., 31., 1.8951013183593750e+02, 3.7809550121892244e-05,
+    0, -1, 410., 263., 31., 2.1104748535156250e+02,
+    5.5358876124955714e-05, 0, -1, 339., 182., 31.,
+    2.4964574813842773e+01, 3.8371828850358725e-05, 0, -1, 337., 182.,
+    31., 2.1807134628295898e+01, 4.6884710172889754e-05, 0, -1, 279.,
+    182., 31., 2.5588668823242188e+02, 5.2219642384443432e-05, 0, -1,
+    339., 263., 31., 1.0396791076660156e+02, 6.0520487750181928e-05, 0,
+    -1, 331., 263., 31., 9.7543502807617188e+01, 4.1782943299040198e-05,
+    0, -1, 326., 159., 31., 9.0410682678222656e+01,
+    4.9072703404817730e-05, 0, -1, 435., 262., 31.,
+    3.3928317260742188e+02, 6.1275197367649525e-05, 0, -1, 350., 159.,
+    31., 1.0795714569091797e+02, 4.1135030187433586e-05, 0, -1, 214.,
+    160., 31., 2.4367221832275391e+01, 5.4251337132882327e-05, 0, -1,
+    324., 262., 31., 1.0154624176025391e+02, 4.5069933548802510e-05, 0,
+    -1, 199., 262., 31., 5.9242958068847656e+01, 3.6997673305450007e-05,
+    0, -1, 310., 218., 31., 6.7081192016601562e+01,
+    5.7218414440285414e-05, 0, -1, 431., 186., 31.,
+    1.4423683166503906e+02, 6.1516271671280265e-05, 0, -1, 229., 160.,
+    31., 8.6514015197753906e+01, 5.6202989071607590e-05, 0, -1, 351.,
+    261., 31., 1.1061492156982422e+02, 6.2355160480365157e-05, 0, -1,
+    343., 261., 31., 1.1158784484863281e+02, 5.5204978707479313e-05, 0,
+    -1, 356., 160., 31., 1.1503463745117188e+02, 6.1120525060687214e-05,
+    0, -1, 250., 275., 31., 9.7146934509277344e+01,
+    5.8206558605888858e-05, 0, -1, 307., 190., 31.,
+    2.6895068359375000e+02, 5.5991407862165943e-05, 0, -1, 288., 235.,
+    31., 2.9961270141601562e+02, 3.5902095987694338e-05, 0, -1, 295.,
+    221., 31., 8.0172615051269531e+01, 3.8833408325444907e-05, 0, -1,
+    270., 303., 31., 9.4657920837402344e+01, 5.5953812989173457e-05, 0,
+    -1, 157., 215., 31., 2.2868096923828125e+02, 6.0416892665671185e-05,
+    0, -1, 140., 285., 31., 2.2485806274414062e+02,
+    6.2643208366353065e-05, 0, -1, 284., 200., 31.,
+    1.8545433044433594e+02, 3.5151791962562129e-05, 0, -1, 229., 342.,
+    31., 1.0071798706054688e+02, 4.8803824029164389e-05, 0, -1, 205.,
+    148., 31., 2.1237159729003906e+02, 6.7610992118716240e-05, 0, -1,
+    301., 218., 31., 6.9658859252929688e+01, 6.0344962548697367e-05, 0,
+    -1, 359., 160., 31., 1.1168191528320312e+02, 5.1712548156501725e-05,
+    0, -1, 449., 235., 31., 1.8207347106933594e+02,
+    5.8091489336220548e-05, 0, -1, 413., 259., 31.,
+    2.2853262329101562e+02, 5.0182683480670676e-05, 0, -1, 272., 304.,
+    31., 9.5804481506347656e+01, 6.4634652517270297e-05, 0, -1, 168.,
+    229., 31., 3.3872286987304688e+02, 3.4461649192962795e-05, 0, -1,
+    131., 305., 31., 3.4702798461914062e+02, 4.9754540668800473e-05, 0,
+    -1, 314., 341., 31., 1.4160520935058594e+02, 5.9118166973348707e-05,
+    0, -1, 249., 292., 31., 7.8472824096679688e+01,
+    5.4768377594882622e-05, 0, -1, 346., 259., 31.,
+    1.5746934509277344e+02, 4.7657529648859054e-05, 0, -1, 154., 215.,
+    31., 2.2748814392089844e+02, 4.0119488403433934e-05, 0, -1, 305.,
+    259., 31., 4.6182544708251953e+01, 3.9397131331497803e-05, 0, -1,
+    411., 180., 31., 6.5484642028808594e+01, 6.2924911617301404e-05, 0,
+    -1, 224., 341., 31., 1.0666693115234375e+02, 6.3648731156717986e-05,
+    0, -1, 272., 306., 31., 9.9546157836914062e+01,
+    5.8639609051169828e-05, 0, -1, 437., 258., 31.,
+    2.9019357299804688e+02, 3.8784353819210082e-05, 0, -1, 424., 160.,
+    31., 8.9737213134765625e+01, 4.5520300773205236e-05, 0, -1, 406.,
+    180., 31., 3.2771783447265625e+02, 4.4144093408249319e-05, 0, -1,
+    411., 195., 31., 3.1473489379882812e+02, 5.7009128795471042e-05, 0,
+    -1, 336., 161., 31., 9.6159202575683594e+01, 4.2844538256758824e-05,
+    0, -1, 175., 307., 31., 2.7692950439453125e+02,
+    6.0484035202534869e-05, 0, -1, 422., 258., 31.,
+    2.4186791992187500e+02, 6.2300103309098631e-05, 0, -1, 379., 258.,
+    31., 3.3576861572265625e+02, 4.1290219087386504e-05, 0, -1, 371.,
+    258., 31., 3.1063476562500000e+01, 6.3407518609892577e-05, 0, -1,
+    312., 219., 31., 7.2404769897460938e+01, 5.8992733102058992e-05, 0,
+    -1, 339., 258., 31., 8.1527664184570312e+01, 4.0094717405736446e-05,
+    0, -1, 163., 201., 31., 1.9976425170898438e+02,
+    3.9458936953451484e-05, 0, -1, 344., 307., 31.,
+    8.5626495361328125e+01, 6.5178828663192689e-05, 0, -1, 428., 257.,
+    31., 2.8795370483398438e+02, 3.8276761188171804e-05, 0, -1, 255.,
+    148., 31., 7.1426353454589844e+01, 6.1438578995876014e-05, 0, -1,
+    408., 257., 31., 2.3788960266113281e+02, 5.2993200370110571e-05, 0,
+    -1, 263., 236., 31., 2.2286337280273438e+02, 3.7027701182523742e-05,
+    0, -1, 301., 257., 31., 7.3486236572265625e+01,
+    6.1120437749195844e-05, 0, -1, 292., 257., 31.,
+    9.3413223266601562e+01, 4.5847398723708466e-05, 0, -1, 160., 221.,
+    31., 2.3841488647460938e+02, 3.9891325286589563e-05, 0, -1, 292.,
+    190., 31., 2.8068530273437500e+02, 3.5892495361622423e-05, 0, -1,
+    171., 201., 31., 1.9021089172363281e+02, 4.9070273234974593e-05, 0,
+    -1, 174., 257., 31., 9.7991104125976562e+01, 6.2154147599358112e-05,
+    0, -1, 440., 179., 31., 9.1855592727661133e+00,
+    5.3292194934329018e-05, 0, -1, 218., 190., 31.,
+    1.9149209594726562e+02, 4.7522833483526483e-05, 0, -1, 411., 284.,
+    31., 2.1797164916992188e+02, 5.0344824558123946e-05, 0, -1, 316.,
+    256., 31., 1.1120586395263672e+02, 5.2769555622944608e-05, 0, -1,
+    284., 256., 31., 9.4745498657226562e+01, 4.0655220800545067e-05, 0,
+    -1, 269., 216., 31., 1.4788946533203125e+02, 5.1248716772533953e-05,
+    0, -1, 371., 362., 31., 1.9554289245605469e+02,
+    5.0544786063255742e-05, 0, -1, 255., 214., 31.,
+    1.6098454284667969e+02, 6.3379760831594467e-05, 0, -1, 455., 222.,
+    31., 2.0050471496582031e+02, 5.6770124501781538e-05, 0, -1, 181.,
+    179., 31., 2.3216139221191406e+02, 6.5938438638113439e-05, 0, -1,
+    351., 362., 31., 3.2167916870117188e+02, 4.9274487537331879e-05, 0,
+    -1, 350., 195., 31., 3.3734490966796875e+02, 6.6460364905651659e-05,
+    0, -1, 222., 340., 31., 1.0353144073486328e+02,
+    5.6084205425577238e-05, 0, -1, 219., 340., 31.,
+    1.0419149017333984e+02, 5.3992120228940621e-05, 0, -1, 388., 178.,
+    31., 2.3845553588867188e+02, 6.3565777963958681e-05, 0, -1, 404.,
+    255., 31., 2.4912844848632812e+02, 6.6116466769017279e-05, 0, -1,
+    259., 276., 31., 9.8631240844726562e+01, 4.4465381506597623e-05, 0,
+    -1, 230., 149., 31., 2.0453807067871094e+02, 5.4952495702309534e-05,
+    0, -1, 362., 161., 31., 9.4555335998535156e+01,
+    6.8129840656183660e-05, 0, -1, 170., 195., 31.,
+    2.1038204956054688e+02, 3.7237161450320855e-05, 0, -1, 302., 216.,
+    31., 6.5040222167968750e+01, 6.6738677560351789e-05, 0, -1, 298.,
+    153., 31., 1.0503188323974609e+02, 4.7121364332269877e-05, 0, -1,
+    370., 311., 31., 8.4045509338378906e+01, 6.2389415688812733e-05, 0,
+    -1, 421., 254., 31., 2.3856216430664062e+02, 5.4047741286922246e-05,
+    0, -1, 472., 177., 31., 2.1234716796875000e+02,
+    3.4383898309897631e-05, 0, -1, 429., 228., 31.,
+    1.9346354675292969e+02, 5.2231607696739957e-05, 0, -1, 452., 177.,
+    31., 2.4284405517578125e+02, 3.9833012124290690e-05, 0, -1, 348.,
+    352., 31., 2.8200064086914062e+02, 3.5396820749156177e-05, 0, -1,
+    467., 194., 31., 2.1113504028320312e+02, 3.8055874028941616e-05, 0,
+    -1, 304., 254., 31., 8.2357048034667969e+01, 5.1176593842683360e-05,
+    0, -1, 404., 187., 31., 3.1637292480468750e+02,
+    5.4452477343147621e-05, 0, -1, 320., 339., 31.,
+    1.5925442504882812e+02, 3.4626809792825952e-05, 0, -1, 158., 254.,
+    31., 1.1221483612060547e+02, 4.9393540393793955e-05, 0, -1, 356.,
+    352., 31., 2.8916064453125000e+02, 3.6440229450818151e-05, 0, -1,
+    338., 202., 31., 4.1189720153808594e+01, 4.4170526962261647e-05, 0,
+    -1, 297., 237., 31., 2.9758108520507812e+02, 6.0259855672484264e-05,
+    0, -1, 207., 162., 31., 6.1435287475585938e+01,
+    5.1478353270795196e-05, 0, -1, 195., 214., 31.,
+    1.7793464660644531e+02, 4.9334867071593180e-05, 0, -1, 171., 203.,
+    31., 1.9812767028808594e+02, 5.3926054533803836e-05, 0, -1, 191.,
+    223., 31., 1.4074177551269531e+02, 6.4215848396997899e-05, 0, -1,
+    205., 203., 31., 1.9827772521972656e+02, 4.8129746573977172e-05, 0,
+    -1, 419., 194., 31., 3.1950140380859375e+02, 3.8712969399057329e-05,
+    0, -1, 402., 194., 31., 3.2488418579101562e+02,
+    5.8574398281052709e-05, 0, -1, 406., 237., 31.,
+    1.0270700836181641e+02, 3.8393885915866122e-05, 0, -1, 458., 213.,
+    31., 2.0804101562500000e+02, 6.5533626184333116e-05, 0, -1, 193.,
+    223., 31., 1.2770267486572266e+02, 6.5957858168985695e-05, 0, -1,
+    319., 191., 31., 2.9122473144531250e+02, 5.3789415687788278e-05, 0,
+    -1, 224., 238., 31., 2.4928594970703125e+02, 6.4435058447998017e-05,
+    0, -1, 220., 177., 31., 2.3304847717285156e+02,
+    3.9136841223808005e-05, 0, -1, 304., 314., 31.,
+    2.2323660278320312e+02, 5.3133186156628653e-05, 0, -1, 413., 228.,
+    31., 6.7364063262939453e+00, 4.8429825255880132e-05, 0, -1, 281.,
+    218., 31., 1.5568777465820312e+02, 5.2931805839762092e-05, 0, -1,
+    326., 191., 31., 3.1854721069335938e+02, 4.0289880416821688e-05, 0,
+    -1, 283., 252., 31., 9.5977661132812500e+01, 6.4708394347690046e-05,
+    0, -1, 468., 187., 31., 2.2120791625976562e+02,
+    6.0332225984893739e-05, 0, -1, 270., 252., 31.,
+    1.1781565093994141e+02, 5.0352831749478355e-05, 0, -1, 386., 290.,
+    31., 9.2872917175292969e+01, 5.0282476877328008e-05, 0, -1, 213.,
+    315., 31., 2.7900268554687500e+02, 6.7031847720500082e-05, 0, -1,
+    348., 162., 31., 1.1057388305664062e+02, 4.1440867789788172e-05, 0,
+    -1, 207., 338., 31., 1.0163349151611328e+02, 6.0313068388495594e-05,
+    0, -1, 352., 162., 31., 1.0960824584960938e+02,
+    3.5647855838760734e-05, 0, -1, 345., 315., 31.,
+    9.5441329956054688e+01, 6.3330364355351776e-05, 0, -1, 348., 315.,
+    31., 9.5774108886718750e+01, 4.1374194552190602e-05, 0, -1, 396.,
+    315., 31., 1.1763902282714844e+02, 5.9871323173865676e-05, 0, -1,
+    353., 194., 31., 3.1274780273437500e+02, 3.6003053537569940e-05, 0,
+    -1, 247., 143., 31., 2.6515484619140625e+02, 3.9205173379741609e-05,
+    0, -1, 406., 228., 31., 1.6973585510253906e+02,
+    6.0738246247638017e-05, 0, -1, 223., 176., 31.,
+    2.4834617614746094e+02, 6.7469751229509711e-05, 0, -1, 367., 359.,
+    31., 2.3072383117675781e+02, 3.4340802812948823e-05, 0, -1, 400.,
+    228., 31., 1.9172535705566406e+02, 4.7923127567628399e-05, 0, -1,
+    177., 251., 31., 1.0038133621215820e+01, 6.2271399656310678e-05, 0,
+    -1, 191., 290., 31., 9.2722412109375000e+01, 5.1837232604157180e-05,
+    0, -1, 328., 337., 31., 3.0671273803710938e+02,
+    4.9710404709912837e-05, 0, -1, 189., 290., 31.,
+    9.0533439636230469e+01, 5.7710447435965762e-05, 0, -1, 447., 217.,
+    31., 2.2615768432617188e+02, 4.0143815567716956e-05, 0, -1, 443.,
+    250., 31., 1.8122114562988281e+02, 4.8917285312199965e-05, 0, -1,
+    251., 205., 31., 2.4375160217285156e+02, 6.3244056946132332e-05, 0,
+    -1, 374., 162., 31., 1.0598323059082031e+02, 3.9800888771424070e-05,
+    0, -1, 254., 188., 31., 2.4649841308593750e+02,
+    6.4536914578638971e-05, 0, -1, 262., 250., 31.,
+    1.3431224060058594e+02, 4.9592064897296950e-05, 0, -1, 309., 317.,
+    31., 2.8669702148437500e+02, 6.5515021560713649e-05, 0, -1, 243.,
+    250., 31., 8.1858016967773438e+01, 4.6544533688575029e-05, 0, -1,
+    250., 337., 31., 3.4720199584960938e+01, 4.7458681365242228e-05, 0,
+    -1, 399., 213., 31., 1.6621824645996094e+02, 5.4347878176486120e-05,
+    0, -1, 171., 224., 31., 3.2498101806640625e+02,
+    4.3226958950981498e-05, 0, -1, 182., 250., 31.,
+    3.3541674804687500e+02, 5.8828849432757124e-05, 0, -1, 349., 205.,
+    31., 7.9057823181152344e+01, 3.5001972719328478e-05, 0, -1, 259.,
+    142., 31., 3.0744281005859375e+02, 5.0503658712841570e-05, 0, -1,
+    229., 175., 31., 3.1506192016601562e+02, 4.5148750359658152e-05, 0,
+    -1, 460., 205., 31., 1.1116641235351562e+02, 4.2080348066519946e-05,
+    0, -1, 345., 318., 31., 8.7913040161132812e+01,
+    5.5512879043817520e-05, 0, -1, 348., 318., 31.,
+    8.9677589416503906e+01, 5.2878425776725635e-05, 0, -1, 202., 337.,
+    31., 1.0633772277832031e+02, 6.8154673499520868e-05, 0, -1, 172.,
+    287., 31., 2.9774523925781250e+02, 5.3715608373750001e-05, 0, -1,
+    199., 151., 31., 2.2873083496093750e+02, 3.6111516237724572e-05, 0,
+    -1, 179., 319., 31., 1.1871011352539062e+02, 5.4150259529706091e-05,
+    0, -1, 182., 319., 31., 7.8796501159667969e+01,
+    3.6937322875019163e-05, 0, -1, 378., 163., 31.,
+    1.0129417419433594e+02, 5.2813720685662702e-05, 0, -1, 380., 163.,
+    31., 1.0339805603027344e+02, 4.9433198000770062e-05, 0, -1, 273.,
+    206., 31., 2.1001377868652344e+02, 5.7980239944299683e-05, 0, -1,
+    286., 249., 31., 9.2350723266601562e+01, 5.5728905863361433e-05, 0,
+    -1, 277., 213., 31., 1.8863948059082031e+02, 3.8032179872971028e-05,
+    0, -1, 281., 336., 31., 2.9834133911132812e+02,
+    4.2656902223825455e-05, 0, -1, 163., 228., 31.,
+    1.9827130126953125e+02, 6.0469075833680108e-05, 0, -1, 424., 174.,
+    31., 1.3651280212402344e+02, 5.3145471611060202e-05, 0, -1, 233.,
+    320., 31., 2.8871527099609375e+02, 5.9960999351460487e-05, 0, -1,
+    362., 358., 31., 2.8390246582031250e+02, 6.0072383348597214e-05, 0,
+    -1, 276., 249., 31., 1.0827770233154297e+02, 3.6571160308085382e-05,
+    0, -1, 253., 249., 31., 1.3564471244812012e+01,
+    5.8005891332868487e-05, 0, -1, 299., 239., 31.,
+    2.9756732177734375e+02, 3.8833593862364069e-05, 0, -1, 315., 206.,
+    31., 3.3615075683593750e+02, 4.8498972319066525e-05, 0, -1, 288.,
+    188., 31., 2.7269860839843750e+02, 4.0821447328198701e-05, 0, -1,
+    197., 336., 31., 1.0632254028320312e+02, 4.6130160626489669e-05, 0,
+    -1, 182., 321., 31., 9.5661682128906250e+01, 4.4063101086067036e-05,
+    0, -1, 195., 321., 31., 3.1554425048828125e+02,
+    4.9378249968867749e-05, 0, -1, 259., 213., 31.,
+    1.6796667480468750e+02, 4.1189308831235394e-05, 0, -1, 384., 189.,
+    31., 1.7150100708007812e+02, 4.1099581721937284e-05, 0, -1, 453.,
+    227., 31., 1.9147189331054688e+02, 4.5697943278355524e-05, 0, -1,
+    415., 206., 31., 2.3637510299682617e+01, 6.3547151512466371e-05, 0,
+    -1, 279., 358., 31., 2.8912561035156250e+02, 6.8273046053946018e-05,
+    0, -1, 304., 207., 31., 3.4867626953125000e+02,
+    4.1417049942538142e-05, 0, -1, 256., 248., 31.,
+    1.5264129638671875e+02, 5.1094313676003367e-05, 0, -1, 244., 248.,
+    31., 6.3508468627929688e+01, 5.1220875320723280e-05, 0, -1, 239.,
+    248., 31., 1.0628702545166016e+02, 5.4811222071293741e-05, 0, -1,
+    309., 284., 31., 9.9254112243652344e+01, 5.8830646594287828e-05, 0,
+    -1, 197., 322., 31., 3.0559191894531250e+02, 4.4780485040973872e-05,
+    0, -1, 204., 322., 31., 2.6839382934570312e+02,
+    4.5805834815837443e-05, 0, -1, 404., 247., 31.,
+    2.1325708007812500e+02, 5.5265700211748481e-05, 0, -1, 176., 194.,
+    31., 2.1085810852050781e+02, 4.2762021621456370e-05, 0, -1, 199.,
+    208., 31., 2.0007650756835938e+02, 4.8037683882284909e-05, 0, -1,
+    224., 208., 31., 6.6490348815917969e+01, 5.5168919061543420e-05, 0,
+    -1, 278., 335., 31., 2.8123745727539062e+02, 6.3701270846650004e-05,
+    0, -1, 449., 163., 31., 1.0743470764160156e+02,
+    3.6060420825378969e-05, 0, -1, 190., 164., 31.,
+    1.8298292541503906e+02, 5.0318107241764665e-05, 0, -1, 184., 172.,
+    31., 1.8754937744140625e+02, 4.3849213398061693e-05, 0, -1, 198.,
+    213., 31., 1.5037164306640625e+02, 5.3764211770612746e-05, 0, -1,
+    461., 208., 31., 1.9389009094238281e+02, 3.8656875403830782e-05, 0,
+    -1, 180., 323., 31., 1.0635705566406250e+02, 3.7425092159537598e-05,
+    0, -1, 215., 240., 31., 2.8431494140625000e+02,
+    3.5156725061824545e-05, 0, -1, 190., 335., 31.,
+    9.2533691406250000e+01, 6.4803047280292958e-05, 0, -1, 267., 224.,
+    31., 1.7101161193847656e+02, 4.5612527173943818e-05, 0, -1, 225.,
+    323., 31., 2.8485894775390625e+02, 4.0811260987538844e-05, 0, -1,
+    360., 357., 31., 2.7867288208007812e+02, 4.7675544919911772e-05, 0,
+    -1, 249., 240., 31., 2.9997390747070312e+02, 3.5705317714018747e-05,
+    0, -1, 280., 209., 31., 1.9095217895507812e+02,
+    5.7956058299168944e-05, 0, -1, 292., 209., 31.,
+    1.5305581665039062e+02, 4.6472243411699310e-05, 0, -1, 159., 213.,
+    31., 2.2562127685546875e+02, 5.3416319133248180e-05, 0, -1, 353.,
+    357., 31., 3.1094635009765625e+02, 4.8030706238932908e-05, 0, -1,
+    295., 209., 31., 1.3645605468750000e+02, 4.8335728934034705e-05, 0,
+    -1, 347., 348., 31., 2.8762451171875000e+02, 5.2385752496775240e-05,
+    0, -1, 154., 217., 31., 2.2804139709472656e+02,
+    3.9474678487749770e-05, 0, -1, 406., 193., 31.,
+    3.2000473022460938e+02, 6.5181666286662221e-05, 0, -1, 333., 287.,
+    31., 1.0243410491943359e+02, 5.2078768931096420e-05, 0, -1, 184.,
+    334., 31., 9.0922416687011719e+01, 5.5987980886129662e-05, 0, -1,
+    186., 171., 31., 1.7994812011718750e+02, 6.0809212300227955e-05, 0,
+    -1, 289., 224., 31., 6.4437194824218750e+01, 6.7901339207310230e-05,
+    0, -1, 179., 281., 31., 8.1706756591796875e+01,
+    6.5443971834611148e-05, 0, -1, 157., 210., 31.,
+    2.1571336364746094e+02, 4.5839678932679817e-05, 0, -1, 347., 212.,
+    31., 2.9168298339843750e+02, 4.9979520554188639e-05, 0, -1, 366.,
+    164., 31., 9.9539688110351562e+01, 6.1309750890359282e-05, 0, -1,
+    329., 333., 31., 2.9495501708984375e+02, 4.3872056266991422e-05, 0,
+    -1, 188., 170., 31., 1.8663607788085938e+02, 4.8681326006771997e-05,
+    0, -1, 478., 169., 31., 1.8080149841308594e+02,
+    4.5827757276128978e-05, 0, -1, 247., 141., 31.,
+    2.6120050048828125e+02, 3.4012569813057780e-05, 0, -1, 450., 191.,
+    31., 2.5223727416992188e+02, 4.2951043724315241e-05, 0, -1, 210.,
+    192., 31., 2.1576647949218750e+02, 5.6473349104635417e-05, 0, -1,
+    433., 169., 31., 3.3163601684570312e+02, 4.5293945731827989e-05, 0,
+    -1, 448., 224., 31., 2.5121751403808594e+02, 4.9353242502547801e-05,
+    0, -1, 372., 164., 31., 1.1073123931884766e+02,
+    5.4218788136495277e-05, 0, -1, 221., 326., 31.,
+    2.8572027587890625e+02, 4.6924225898692384e-05, 0, -1, 257., 217.,
+    31., 1.3124107360839844e+02, 3.7817393604200333e-05, 0, -1, 387.,
+    164., 31., 8.2822357177734375e+01, 5.2883558964822441e-05, 0, -1,
+    314., 326., 31., 3.2777484893798828e+01, 5.4237105359788984e-05, 0,
+    -1, 346., 245., 31., 2.8804214477539062e+02, 5.3371073590824381e-05,
+    0, -1, 368., 281., 31., 2.8105438232421875e+02,
+    6.1241000366862863e-05, 0, -1, 447., 241., 31.,
+    1.8736724853515625e+02, 5.0539820222184062e-05, 0, -1, 175., 327.,
+    31., 1.2110870361328125e+02, 6.4287305576726794e-05, 0, -1, 180.,
+    327., 31., 1.0446744537353516e+02, 4.7341032768599689e-05, 0, -1,
+    338., 212., 31., 3.3344552612304688e+02, 5.2884537581121549e-05, 0,
+    -1, 242., 245., 31., 3.3149191284179688e+02, 4.2490308260312304e-05,
+    0, -1, 250., 140., 31., 2.6973886108398438e+02,
+    5.8368488680571318e-05, 0, -1, 195., 333., 31.,
+    1.0008293914794922e+02, 4.8123914893949404e-05, 0, -1, 179., 333.,
+    31., 1.0341786956787109e+02, 5.1982733566546813e-05, 0, -1, 246.,
+    327., 31., 2.9156979370117188e+02, 6.2954393797554076e-05, 0, -1,
+    227., 245., 31., 1.7155206298828125e+02, 3.9519392885267735e-05, 0,
+    -1, 209., 245., 31., 3.6558921813964844e+01, 5.5524706112919375e-05,
+    0, -1, 397., 168., 31., 1.3099987792968750e+02,
+    4.3636355258058757e-05, 0, -1, 295., 327., 31.,
+    2.5529095458984375e+02, 4.5584103645524010e-05, 0, -1, 276., 210.,
+    31., 1.8188500976562500e+02, 3.9769416616763920e-05, 0, -1, 145.,
+    333., 31., 2.8180477905273438e+02, 3.5842629586113617e-05, 0, -1,
+    378., 287., 31., 9.3585853576660156e+01, 6.4329913584515452e-05, 0,
+    -1, 321., 190., 31., 2.9811517333984375e+02, 4.5305212552193552e-05,
+    0, -1, 457., 164., 31., 1.3192248535156250e+02,
+    5.2939951274311170e-05, 0, -1, 291., 152., 31.,
+    1.0251033020019531e+02, 5.4279225878417492e-05, 0, -1, 162., 225.,
+    31., 2.4482588195800781e+02, 6.3565392338205129e-05, 0, -1, 337.,
+    328., 31., 3.5329019165039062e+02, 3.4021675674011931e-05, 0, -1,
+    354., 210., 31., 2.5292372131347656e+02, 3.4932778362417594e-05, 0,
+    -1, 210., 140., 31., 1.7850256347656250e+02, 4.9439946451457217e-05,
+    0, -1, 352., 242., 31., 2.5084622192382812e+02,
+    4.5924676669528708e-05, 0, -1, 148., 245., 31.,
+    3.2431539916992188e+02, 5.6463413784513250e-05, 0, -1, 358., 210.,
+    31., 2.2197480773925781e+02, 3.6173540138406679e-05, 0, -1, 277.,
+    152., 31., 8.4942108154296875e+01, 6.6741726186592132e-05, 0, -1,
+    172., 226., 31., 3.2970925903320312e+02, 3.6380530218593776e-05, 0,
+    -1, 308., 282., 31., 9.8610267639160156e+01, 3.5705124901141971e-05,
+    0, -1, 238., 332., 31., 3.4101196289062500e+02,
+    6.4335290517192334e-05, 0, -1, 310., 226., 31.,
+    3.5023048400878906e+01, 3.5604221920948476e-05, 0, -1, 175., 332.,
+    31., 1.1606593322753906e+02, 4.4157372030895203e-05, 0, -1, 192.,
+    212., 31., 1.9585111999511719e+02, 3.4461842005839571e-05, 0, -1,
+    391., 211., 31., 1.1275210571289062e+02, 4.7614652430638671e-05, 0,
+    -1, 211., 166., 31., 6.0400592803955078e+01, 4.2248630052199587e-05,
+    0, -1, 363., 192., 31., 2.3935083007812500e+02,
+    4.2144860344706103e-05, 0, -1, 306., 329., 31.,
+    3.2516117095947266e+01, 5.9088743000756949e-05, 0, -1, 286., 226.,
+    31., 2.9006558227539062e+02, 6.7486944317352027e-05, 0, -1, 335.,
+    330., 31., 3.2124423217773438e+02, 5.4865166021045297e-05, 0, -1,
+    326., 330., 31., 2.9306774902343750e+02, 4.5426710130413994e-05, 0,
+    -1, 383., 166., 31., 9.9846290588378906e+01, 3.9801452658139169e-05,
+    0, -1, 190., 167., 31., 1.8284880065917969e+02,
+    4.3995609303237870e-05, 0, -1, 401., 192., 31.,
+    3.4784115600585938e+02, 5.4699783504474908e-05, 0, -1, 416., 192.,
+    31., 3.1713928222656250e+02, 3.4208398574264720e-05, 0, -1, 218.,
+    244., 31., 1.7342474365234375e+02, 4.6877703425707296e-05, 0, -1,
+    211., 244., 31., 2.2327375411987305e+01, 4.5033702917862684e-05, 0,
+    -1, 238., 330., 31., 3.0500503540039062e+02, 4.3701500544557348e-05,
+    0, -1, 246., 244., 31., 3.2140390014648438e+02,
+    2.0431909433682449e-05, 0, -1, 371., 282., 31.,
+    2.3033175659179688e+02, 2.6969719328917563e-05, 0, -1, 271., 211.,
+    31., 1.7600462341308594e+02, 2.5733086658874527e-05, 0, -1, 256.,
+    244., 31., 2.5534387207031250e+02, 2.6031779270851985e-05, 0, -1,
+    197., 211., 31., 1.8280601501464844e+02, 2.5155237381113693e-05, 0,
+    -1, 341., 330., 31., 3.4500454711914062e+02, 2.3032298486214131e-05,
+    0, -1, 333., 329., 31., 3.2479907226562500e+02,
+    3.2149229809874669e-05, 0, -1, 172., 189., 31.,
+    2.1404389953613281e+02, 3.3678257750580087e-05, 0, -1, 381., 155.,
+    31., 9.6383918762207031e+01, 2.2683321731165051e-05, 0, -1, 373.,
+    166., 31., 1.0595195007324219e+02, 2.6479954613023438e-05, 0, -1,
+    306., 348., 31., 2.9553433227539062e+02, 2.7654776204144582e-05, 0,
+    -1, 215., 167., 31., 6.6275222778320312e+01, 2.6476405764697120e-05,
+    0, -1, 199., 166., 31., 1.5773654174804688e+02,
+    3.0692186555825174e-05, 0, -1, 436., 196., 31.,
+    1.4696815490722656e+02, 2.1281475710566156e-05, 0, -1, 212., 152.,
+    31., 2.2012713623046875e+02, 2.4863978978828527e-05, 0, -1, 471.,
+    185., 31., 2.0880305480957031e+02, 3.2281699532177299e-05, 0, -1,
+    439., 229., 31., 2.0727455139160156e+02, 2.1028305127401836e-05, 0,
+    -1, 174., 220., 31., 3.2866864013671875e+02, 2.6136127416975796e-05,
+    0, -1, 293., 222., 31., 8.0045845031738281e+01,
+    2.4350609237444587e-05, 0, -1, 150., 232., 31.,
+    1.8700918579101562e+02, 2.4950257284217514e-05, 0, -1, 283., 151.,
+    31., 1.0540250396728516e+02, 2.3299184249481186e-05, 0, -1, 309.,
+    167., 31., 1.0337147521972656e+02, 2.0478575606830418e-05, 0, -1,
+    212., 189., 31., 2.1141505432128906e+02, 3.2960590033326298e-05, 0,
+    -1, 356., 225., 31., 1.0442419433593750e+02, 2.5944576918845996e-05,
+    0, -1, 302., 347., 31., 7.6105852127075195e+00,
+    2.8234011551830918e-05, 0, -1, 250., 165., 31.,
+    6.7535987854003906e+01, 2.0998442778363824e-05, 0, -1, 478., 167.,
+    31., 1.6933984375000000e+02, 3.3874232030939311e-05, 0, -1, 325.,
+    185., 31., 2.9327230834960938e+02, 2.8913606001879089e-05, 0, -1,
+    318., 332., 31., 3.1255712890625000e+02, 2.1475158064276911e-05, 0,
+    -1, 233., 139., 31., 2.5517868041992188e+02, 3.1387629860546440e-05,
+    0, -1, 311., 328., 31., 4.1389438629150391e+01,
+    3.1931391276884824e-05, 0, -1, 275., 185., 31.,
+    2.3285539245605469e+02, 2.0666369891841896e-05, 0, -1, 217., 197.,
+    31., 8.2647468566894531e+01, 2.5497212845948525e-05, 0, -1, 210.,
+    169., 31., 7.4751144409179688e+01, 2.7903808586415835e-05, 0, -1,
+    218., 169., 31., 1.0294670867919922e+02, 2.8732629289152101e-05, 0,
+    -1, 175., 185., 31., 2.1123558044433594e+02, 2.3852522645029239e-05,
+    0, -1, 294., 346., 31., 4.4011188507080078e+01,
+    2.2547656044480391e-05, 0, -1, 241., 169., 31.,
+    3.5574085235595703e+01, 2.2137099222163670e-05, 0, -1, 260., 184.,
+    31., 2.4142846679687500e+02, 2.7558920919545926e-05, 0, -1, 259.,
+    210., 31., 1.7405697631835938e+02, 3.3246276871068403e-05, 0, -1,
+    370., 349., 31., 2.3032588195800781e+02, 2.6708868972491473e-05, 0,
+    -1, 293., 217., 31., 1.0483919525146484e+02, 3.2246713089989498e-05,
+    0, -1, 311., 333., 31., 7.1689178466796875e+01,
+    2.5129789719358087e-05, 0, -1, 260., 140., 31.,
+    2.8922402954101562e+02, 2.1235506210359745e-05, 0, -1, 298., 325.,
+    31., 2.5371524047851562e+02, 2.3130876797949895e-05, 0, -1, 197.,
+    170., 31., 1.3627810668945312e+02, 2.8413116524461657e-05, 0, -1,
+    218., 151., 31., 1.2117050170898438e+02, 2.2056665329728276e-05, 0,
+    -1, 437., 240., 31., 1.5099331665039062e+02, 2.6301429898012429e-05,
+    0, -1, 224., 246., 31., 1.6172706604003906e+02,
+    2.4875984308891930e-05, 0, -1, 260., 246., 31.,
+    1.8723738098144531e+02, 2.4810855393297970e-05, 0, -1, 439., 198.,
+    31., 1.4385650634765625e+02, 2.6915651687886566e-05, 0, -1, 233.,
+    234., 31., 2.6184454345703125e+02, 2.7261559807811864e-05, 0, -1,
+    331., 334., 31., 3.0358993530273438e+02, 2.5953280783141963e-05, 0,
+    -1, 311., 154., 31., 9.6521957397460938e+01, 3.3205706131411716e-05,
+    0, -1, 342., 345., 31., 3.0441775512695312e+02,
+    2.6952044208883308e-05, 0, -1, 191., 227., 31.,
+    1.1911515808105469e+02, 2.7689115086104721e-05, 0, -1, 252., 164.,
+    31., 7.6327529907226562e+01, 2.1622705389745533e-05, 0, -1, 343.,
+    171., 31., 9.7812149047851562e+01, 2.2425223505706526e-05, 0, -1,
+    440., 193., 31., 1.5486029052734375e+02, 2.3749551473883912e-05, 0,
+    -1, 309., 186., 31., 2.4143893432617188e+02, 2.1428062609629706e-05,
+    0, -1, 194., 209., 31., 2.0150645446777344e+02,
+    3.1672076147515327e-05, 0, -1, 436., 191., 31.,
+    1.4501132202148438e+02, 2.0681793102994561e-05, 0, -1, 135., 323.,
+    31., 3.1623516845703125e+02, 3.3707958209561184e-05, 0, -1, 314.,
+    247., 31., 1.2905491638183594e+02, 3.0222441637306474e-05, 0, -1,
+    233., 208., 31., 7.1868240356445312e+01, 2.6170844648731872e-05, 0,
+    -1, 227., 208., 31., 6.9638656616210938e+01, 2.0728961317217909e-05,
+    0, -1, 417., 266., 31., 1.6008532714843750e+02,
+    3.1997977202991024e-05, 0, -1, 179., 183., 31.,
+    2.2576934814453125e+02, 3.0392538974410854e-05, 0, -1, 187., 248.,
+    31., 3.1717739868164062e+02, 2.3712009351584129e-05, 0, -1, 390.,
+    265., 31., 2.3946139526367188e+02, 2.2399954104912467e-05, 0, -1,
+    340., 186., 31., 3.3566082763671875e+02, 2.3800246708560735e-05, 0,
+    -1, 402., 264., 31., 2.4558912658691406e+02, 2.1944742911728099e-05,
+    0, -1, 344., 206., 31., 3.3233390808105469e+01,
+    3.2031861337600276e-05, 0, -1, 176., 224., 31.,
+    3.3047494506835938e+02, 3.0349068765644915e-05, 0, -1, 246., 249.,
+    31., 6.1703956604003906e+01, 3.3314259781036526e-05, 0, -1, 279.,
+    249., 31., 9.9151420593261719e+01, 2.5419582016183995e-05, 0, -1,
+    199., 320., 31., 2.8797357177734375e+02, 2.7457102987682447e-05, 0,
+    -1, 411., 186., 31., 3.2664337158203125e+02, 3.0073146263021044e-05,
+    0, -1, 347., 336., 31., 3.0496676635742188e+02,
+    2.9491167879314162e-05, 0, -1, 382., 319., 31.,
+    2.1385470581054688e+02, 3.2201860449276865e-05, 0, -1, 473., 174.,
+    31., 2.0503169250488281e+02, 3.1667404982727021e-05, 0, -1, 218.,
+    135., 31., 2.1948480224609375e+02, 2.1120620658621192e-05, 0, -1,
+    217., 175., 31., 2.2230111694335938e+02, 2.0499228412518278e-05, 0,
+    -1, 280., 150., 31., 8.6721488952636719e+01, 2.1165382349863648e-05,
+    0, -1, 392., 289., 31., 8.4106208801269531e+01,
+    3.3555708796484396e-05, 0, -1, 230., 264., 31.,
+    1.5097048950195312e+02, 3.0268935006461106e-05, 0, -1, 300., 234.,
+    31., 2.9297088623046875e+02, 2.6523493943386711e-05, 0, -1, 392.,
+    216., 31., 2.2676681518554688e+02, 2.7187499654246494e-05, 0, -1,
+    179., 188., 31., 2.1189291381835938e+02, 2.1480560462805443e-05, 0,
+    -1, 281., 204., 31., 1.7874813842773438e+02, 2.2745216483599506e-05,
+    0, -1, 259., 251., 31., 1.2105319976806641e+02,
+    2.3943239284562878e-05, 0, -1, 227., 176., 31.,
+    2.9083477783203125e+02, 3.0764804250793532e-05, 0, -1, 202., 204.,
+    31., 2.0566003417968750e+02, 2.6051038730656728e-05, 0, -1, 275.,
+    143., 31., 5.8843147277832031e+01, 2.9571083359769545e-05, 0, -1,
+    383., 229., 31., 1.1004206085205078e+02, 2.7458565455162898e-05, 0,
+    -1, 216., 315., 31., 2.7858493041992188e+02, 3.1362611480290070e-05,
+    0, -1, 295., 238., 31., 3.0219122314453125e+02,
+    3.3021227864082903e-05, 0, -1, 299., 300., 31.,
+    8.5214263916015625e+01, 2.6195863028988242e-05, 0, -1, 311., 182.,
+    31., 2.2562844848632812e+02, 2.7271946237306111e-05, 0, -1, 373.,
+    350., 31., 2.2975476074218750e+02, 2.3634263925487176e-05, 0, -1,
+    375., 177., 31., 1.5594363403320312e+02, 2.9501648896257393e-05, 0,
+    -1, 152., 235., 31., 1.6446641540527344e+02, 3.1058578315423802e-05,
+    0, -1, 420., 213., 31., 2.9503837585449219e+01,
+    3.1479943572776392e-05, 0, -1, 191., 253., 31.,
+    3.0984619140625000e+02, 2.4102451789076440e-05, 0, -1, 155., 238.,
+    31., 1.1220906066894531e+02, 2.2194628400029615e-05, 0, -1, 193.,
+    159., 31., 1.9766862487792969e+02, 2.0827126718359068e-05, 0, -1,
+    378., 177., 31., 1.7720623779296875e+02, 2.3566926756757312e-05, 0,
+    -1, 250., 159., 31., 7.4078849792480469e+01, 2.0548879547277465e-05,
+    0, -1, 370., 352., 31., 2.2304754638671875e+02,
+    2.2711452402290888e-05, 0, -1, 286., 154., 31.,
+    1.0139330291748047e+02, 3.1780338758835569e-05, 0, -1, 318., 218.,
+    31., 7.8640182495117188e+01, 2.7393471100367606e-05, 0, -1, 217.,
+    182., 31., 2.1846623229980469e+02, 2.7091073206975125e-05, 0, -1,
+    427., 202., 31., 3.5618484497070312e+02, 2.6053250621771440e-05, 0,
+    -1, 284., 202., 31., 1.7846636962890625e+02, 3.1425497581949458e-05,
+    0, -1, 334., 262., 31., 9.6501655578613281e+01,
+    2.9495751732611097e-05, 0, -1, 441., 177., 31.,
+    3.4334454345703125e+02, 2.8069078325643204e-05, 0, -1, 414., 254.,
+    31., 2.2910745239257812e+02, 2.6697955036070198e-05, 0, -1, 346.,
+    339., 31., 3.0077612304687500e+02, 2.0901763491565362e-05, 0, -1,
+    324., 160., 31., 9.1159423828125000e+01, 2.7571311875362881e-05, 0,
+    -1, 386., 187., 31., 2.0205810546875000e+02, 3.1076295272214338e-05,
+    0, -1, 345., 181., 31., 4.8557453155517578e+01,
+    2.2840189558337443e-05, 0, -1, 298., 342., 31.,
+    2.2796571731567383e+01, 3.2787022064439952e-05, 0, -1, 368., 161.,
+    31., 1.0048081207275391e+02, 3.3361524401698261e-05, 0, -1, 198.,
+    200., 31., 2.0993432617187500e+02, 2.4664417651365511e-05, 0, -1,
+    418., 260., 31., 2.2535339355468750e+02, 2.4051532818702981e-05, 0,
+    -1, 268., 181., 31., 2.3291824340820312e+02, 2.4345566998817958e-05,
+    0, -1, 421., 195., 31., 3.3169454956054688e+02,
+    2.1013363948441111e-05, 0, -1, 473., 180., 31.,
+    1.9421604919433594e+02, 2.7704105377779342e-05, 0, -1, 429., 259.,
+    31., 3.0861776733398438e+02, 2.1850273697054945e-05, 0, -1, 409.,
+    236., 31., 7.9946472167968750e+01, 3.2325111533282325e-05, 0, -1,
+    338., 161., 31., 1.0129460906982422e+02, 2.1032945369370282e-05, 0,
+    -1, 180., 309., 31., 3.0336322021484375e+02, 2.5462853955104947e-05,
+    0, -1, 204., 201., 31., 2.0605314636230469e+02,
+    2.1140962417121045e-05, 0, -1, 200., 257., 31.,
+    3.5476379394531250e+02, 2.5453025955357589e-05, 0, -1, 348., 257.,
+    31., 2.2607810974121094e+02, 2.8249365641386248e-05, 0, -1, 377.,
+    259., 31., 2.1986606597900391e+01, 2.5001138055813499e-05, 0, -1,
+    426., 258., 31., 2.6776477050781250e+02, 3.3191950933542103e-05, 0,
+    -1, 296., 259., 31., 7.8934226989746094e+01, 2.2079339032643475e-05,
+    0, -1, 425., 180., 31., 1.4221109008789062e+02,
+    2.7855503503815271e-05, 0, -1, 418., 214., 31.,
+    3.7673553466796875e+01, 3.2594300137134269e-05, 0, -1, 409., 160.,
+    31., 1.4099948120117188e+02, 3.3473676012363285e-05, 0, -1, 315.,
+    259., 31., 1.1447019958496094e+02, 2.2476289814221673e-05, 0, -1,
+    334., 180., 31., 5.4443553924560547e+01, 1.7991287677432410e-05, 0,
+    -1, 287., 185., 31., 2.7672528076171875e+02, 1.9836830688291229e-05,
+    0, -1, 179., 232., 31., 3.3252157592773438e+02,
+    1.9533090380718932e-05, 0, -1, 236., 232., 31.,
+    2.7282818603515625e+02, 1.8468428606865928e-05, 0, -1, 226., 185.,
+    31., 3.2497085571289062e+02, 1.9239880202803761e-05, 0, -1, 373.,
+    240., 31., 2.7724298095703125e+02, 1.8968536096508615e-05, 0, -1,
+    343., 334., 31., 3.0865213012695312e+02, 1.8612778148963116e-05, 0,
+    -1, 299., 345., 31., 3.2410255432128906e+01, 2.0305960788391531e-05,
+    0, -1, 348., 282., 31., 1.8028550720214844e+02,
+    1.7991695131058805e-05, 0, -1, 367., 153., 31.,
+    9.7756507873535156e+01, 1.8018667105934583e-05, 0, -1, 196., 206.,
+    31., 2.0667385864257812e+02, 1.8411445125821047e-05, 0, -1, 390.,
+    238., 31., 1.5250222778320312e+02, 2.0006049453513697e-05, 0, -1,
+    350., 339., 31., 2.9466845703125000e+02, 2.0356519598863088e-05, 0,
+    -1, 443., 176., 31., 3.4009265136718750e+02, 1.8235561583423987e-05,
+    0, -1, 314., 219., 31., 7.8172218322753906e+01,
+    1.9785631593549624e-05, 0, -1, 318., 149., 31.,
+    9.9968421936035156e+01, 1.8489448848413303e-05, 0, -1, 448., 203.,
+    31., 1.6415231323242188e+02, 1.8532105968915857e-05, 0, -1, 156.,
+    235., 31., 1.3277186584472656e+02, 1.9117545889457688e-05, 0, -1,
+    437., 164., 31., 2.0578901290893555e+01, 1.7371072317473590e-05, 0,
+    -1, 286., 246., 31., 8.2597373962402344e+01, 1.7743426724337041e-05,
+    0, -1, 321., 222., 31., 9.2904808044433594e+01,
+    1.7718488379614428e-05, 0, -1, 360., 152., 31.,
+    1.0662668609619141e+02, 1.7457612557336688e-05, 0, -1, 220., 231.,
+    31., 2.7298669433593750e+02, 1.7449547158321366e-05, 0, -1, 272.,
+    163., 31., 9.8613616943359375e+01, 1.7584181478014216e-05, 0, -1,
+    319., 168., 31., 9.8516563415527344e+01, 1.7882153770187870e-05, 0,
+    -1, 315., 147., 31., 1.0034318542480469e+02, 1.7430287698516622e-05,
+    0, -1, 299., 145., 31., 1.0057727050781250e+02,
+    1.7971873603528365e-05, 0, -1, 437., 189., 31.,
+    1.3965766906738281e+02, 1.7246075003640726e-05, 0, -1, 202., 147.,
+    31., 2.0528549194335938e+02, 1.7261610992136411e-05, 0, -1, 267.,
+    162., 31., 9.2628692626953125e+01, 1.7200951333506964e-05, 0, -1,
+    343., 331., 31., 3.3875543212890625e+02, 1.7163272787001915e-05, 0,
+    -1, 2.0640000915527344e+02, 132., 3.7200000762939453e+01,
+    1.7159017944335938e+02, 8.2953583842027001e-06, 1, -1,
+    2.0880000305175781e+02, 1.3680000305175781e+02,
+    3.7200000762939453e+01, 1.7051710510253906e+02,
+    2.2632148102275096e-05, 1, -1, 2.1240000915527344e+02,
+    1.3680000305175781e+02, 3.7200000762939453e+01,
+    1.7165689086914062e+02, 1.1002109386026859e-04, 1, -1,
+    2.2080000305175781e+02, 1.3680000305175781e+02,
+    3.7200000762939453e+01, 1.9256497192382812e+02,
+    1.2263707503734622e-05, 1, -1, 2.2560000610351562e+02,
+    1.3680000305175781e+02, 3.7200000762939453e+01,
+    2.4293338012695312e+02, 7.1842732722871006e-06, 1, -1,
+    2.3040000915527344e+02, 1.3920001220703125e+02,
+    3.7200000762939453e+01, 2.5082397460937500e+02,
+    1.9088985936832614e-05, 1, -1, 2.0760000610351562e+02,
+    1.4160000610351562e+02, 3.7200000762939453e+01,
+    1.9319615173339844e+02, 1.7026903151418082e-05, 1, -1,
+    2.1720001220703125e+02, 1.4160000610351562e+02,
+    3.7200000762939453e+01, 2.1399496459960938e+02,
+    1.6690701886545867e-04, 1, -1, 2.2440000915527344e+02,
+    1.4160000610351562e+02, 3.7200000762939453e+01,
+    2.3891853332519531e+02, 2.2220276878215373e-04, 1, -1,
+    2.4480000305175781e+02, 1.4160000610351562e+02,
+    3.7200000762939453e+01, 2.7905923461914062e+02,
+    1.2907711607113015e-05, 1, -1, 2.5320001220703125e+02,
+    1.4160000610351562e+02, 3.7200000762939453e+01,
+    3.3086804199218750e+02, 2.8633834517677315e-05, 1, -1, 264.,
+    1.4160000610351562e+02, 3.7200000762939453e+01,
+    3.2405494689941406e+01, 5.7436582210357301e-06, 1, -1,
+    2.2080000305175781e+02, 1.4280000305175781e+02,
+    3.7200000762939453e+01, 2.3206588745117188e+02,
+    1.2762605911120772e-04, 1, -1, 2.7480001831054688e+02,
+    1.4280000305175781e+02, 3.7200000762939453e+01,
+    6.7064270019531250e+01, 8.2338628999423236e-06, 1, -1,
+    2.2320001220703125e+02, 144., 3.7200000762939453e+01,
+    2.3242285156250000e+02, 1.5220700879581273e-04, 1, -1,
+    2.1240000915527344e+02, 1.4520001220703125e+02,
+    3.7200000762939453e+01, 2.1681120300292969e+02,
+    5.7124740123981610e-05, 1, -1, 2.2200001525878906e+02,
+    1.4640000915527344e+02, 3.7200000762939453e+01,
+    2.1593591308593750e+02, 1.0823761840583757e-04, 1, -1,
+    2.3760000610351562e+02, 1.4640000915527344e+02,
+    3.7200000762939453e+01, 4.4619995117187500e+01,
+    1.0071003634948283e-04, 1, -1, 2.0520001220703125e+02,
+    1.4760000610351562e+02, 3.7200000762939453e+01,
+    2.1317205810546875e+02, 1.7685035345493816e-05, 1, -1,
+    2.4000001525878906e+02, 1.4760000610351562e+02,
+    3.7200000762939453e+01, 6.7601715087890625e+01,
+    1.0532484157010913e-04, 1, -1, 2.5440000915527344e+02,
+    1.4760000610351562e+02, 3.7200000762939453e+01,
+    5.7316383361816406e+01, 2.1068914065835997e-05, 1, -1,
+    2.6640002441406250e+02, 1.4760000610351562e+02,
+    3.7200000762939453e+01, 6.1561187744140625e+01,
+    4.6217730414355174e-05, 1, -1, 2.3040000915527344e+02,
+    1.4880000305175781e+02, 3.7200000762939453e+01,
+    8.2349754333496094e+01, 2.9046412237221375e-05, 1, -1,
+    2.3760000610351562e+02, 1.4880000305175781e+02,
+    3.7200000762939453e+01, 6.6065673828125000e+01,
+    1.1132832150906324e-04, 1, -1, 2.5680001831054688e+02,
+    1.4880000305175781e+02, 3.7200000762939453e+01,
+    6.5806991577148438e+01, 2.6970812541549094e-05, 1, -1,
+    1.9920001220703125e+02, 150., 3.7200000762939453e+01,
+    2.1985317993164062e+02, 6.8981416916358285e-06, 1, -1,
+    2.6640002441406250e+02, 150., 3.7200000762939453e+01,
+    7.3455039978027344e+01, 4.9150130507769063e-05, 1, -1,
+    2.7960000610351562e+02, 150., 3.7200000762939453e+01,
+    9.1980163574218750e+01, 1.8184628061135300e-05, 1, -1,
+    2.6160000610351562e+02, 1.5240000915527344e+02,
+    3.7200000762939453e+01, 8.5031845092773438e+01,
+    1.8942477254313417e-05, 1, -1, 2.7720001220703125e+02,
+    1.5240000915527344e+02, 3.7200000762939453e+01,
+    8.6532409667968750e+01, 2.6568777684587985e-05, 1, -1,
+    2.8920001220703125e+02, 1.5240000915527344e+02,
+    3.7200000762939453e+01, 1.0019437408447266e+02,
+    3.9739905332680792e-05, 1, -1, 294., 1.5240000915527344e+02,
+    3.7200000762939453e+01, 9.9683433532714844e+01,
+    5.8881410950561985e-05, 1, -1, 3.4320001220703125e+02,
+    1.5240000915527344e+02, 3.7200000762939453e+01,
+    1.0111724853515625e+02, 2.7751518700824818e-06, 1, -1,
+    2.0640000915527344e+02, 1.5360000610351562e+02,
+    3.7200000762939453e+01, 2.2353724670410156e+02,
+    8.9367917098570615e-05, 1, -1, 2.0880000305175781e+02,
+    1.5360000610351562e+02, 3.7200000762939453e+01,
+    2.1240985107421875e+02, 5.5150674597825855e-05, 1, -1,
+    2.5080000305175781e+02, 1.5360000610351562e+02,
+    3.7200000762939453e+01, 7.2560729980468750e+01,
+    2.3296013750950806e-05, 1, -1, 2.8080001831054688e+02,
+    1.5360000610351562e+02, 3.7200000762939453e+01,
+    9.4248374938964844e+01, 1.1292187991784886e-05, 1, -1,
+    2.8680001831054688e+02, 1.5360000610351562e+02,
+    3.7200000762939453e+01, 1.0089862823486328e+02,
+    1.7384654711349867e-05, 1, -1, 2.9640002441406250e+02,
+    1.5360000610351562e+02, 3.7200000762939453e+01,
+    1.0173667907714844e+02, 4.8657904699211940e-05, 1, -1,
+    3.0480001831054688e+02, 1.5360000610351562e+02,
+    3.7200000762939453e+01, 1.0193135070800781e+02,
+    4.1132600017590448e-05, 1, -1, 3.0720001220703125e+02,
+    1.5360000610351562e+02, 3.7200000762939453e+01,
+    9.8652854919433594e+01, 3.6690955312224105e-05, 1, -1,
+    3.5880001831054688e+02, 1.5360000610351562e+02,
+    3.7200000762939453e+01, 1.0701841735839844e+02,
+    3.5855869100487325e-06, 1, -1, 2.0280000305175781e+02,
+    1.5480000305175781e+02, 3.7200000762939453e+01,
+    2.1542651367187500e+02, 1.5301257371902466e-04, 1, -1,
+    2.1600001525878906e+02, 1.5480000305175781e+02,
+    3.7200000762939453e+01, 7.6934913635253906e+01,
+    8.5764761024620384e-05, 1, -1, 3.1080001831054688e+02,
+    1.5480000305175781e+02, 3.7200000762939453e+01,
+    9.8089210510253906e+01, 3.1592520826961845e-05, 1, -1,
+    3.8040002441406250e+02, 1.5480000305175781e+02,
+    3.7200000762939453e+01, 1.0238420867919922e+02,
+    6.5732792791095562e-06, 1, -1, 2.0880000305175781e+02, 156.,
+    3.7200000762939453e+01, 2.1738130187988281e+02,
+    5.4277661547530442e-05, 1, -1, 2.1840000915527344e+02, 156.,
+    3.7200000762939453e+01, 6.7771591186523438e+01,
+    9.1246787633281201e-05, 1, -1, 2.2320001220703125e+02, 156.,
+    3.7200000762939453e+01, 1.0231358337402344e+02,
+    7.1121168730314821e-05, 1, -1, 2.3040000915527344e+02, 156.,
+    3.7200000762939453e+01, 8.1978515625000000e+01,
+    7.9396391811314970e-05, 1, -1, 2.3400001525878906e+02, 156.,
+    3.7200000762939453e+01, 7.4571746826171875e+01,
+    5.8439618442207575e-05, 1, -1, 2.3760000610351562e+02, 156.,
+    3.7200000762939453e+01, 7.2342041015625000e+01,
+    2.5393963369424455e-05, 1, -1, 2.4840000915527344e+02, 156.,
+    3.7200000762939453e+01, 7.4564903259277344e+01,
+    6.7415538069326431e-05, 1, -1, 1.9680000305175781e+02,
+    1.5720001220703125e+02, 3.7200000762939453e+01,
+    2.0319857788085938e+02, 1.8547372019384056e-04, 1, -1,
+    2.0040000915527344e+02, 1.5720001220703125e+02,
+    3.7200000762939453e+01, 2.0251795959472656e+02,
+    4.6312322956509888e-04, 1, -1, 2.1480000305175781e+02,
+    1.5720001220703125e+02, 3.7200000762939453e+01,
+    5.5064739227294922e+01, 1.1282451305305585e-04, 1, -1,
+    2.2560000610351562e+02, 1.5720001220703125e+02,
+    3.7200000762939453e+01, 1.0544547271728516e+02,
+    9.8824901215266436e-05, 1, -1, 3.3120001220703125e+02,
+    1.5720001220703125e+02, 3.7200000762939453e+01,
+    9.2672233581542969e+01, 3.8128553569549695e-05, 1, -1,
+    3.3360000610351562e+02, 1.5720001220703125e+02,
+    3.7200000762939453e+01, 9.4972648620605469e+01,
+    3.4379227145109326e-05, 1, -1, 3.2040002441406250e+02,
+    1.5840000915527344e+02, 3.7200000762939453e+01,
+    9.4123512268066406e+01, 3.3479191188234836e-05, 1, -1,
+    4.1280001831054688e+02, 1.5960000610351562e+02,
+    3.7200000762939453e+01, 1.3304185485839844e+02,
+    5.6193757700384595e-06, 1, -1, 2.0040000915527344e+02,
+    1.6080000305175781e+02, 3.7200000762939453e+01,
+    1.8517350769042969e+02, 3.2089455635286868e-04, 1, -1,
+    2.0880000305175781e+02, 1.6080000305175781e+02,
+    3.7200000762939453e+01, 1.1840370178222656e+02,
+    2.5113145966315642e-05, 1, -1, 3.3480001831054688e+02,
+    1.6080000305175781e+02, 3.7200000762939453e+01,
+    9.7795646667480469e+01, 3.8983333070063964e-05, 1, -1,
+    3.6120001220703125e+02, 1.6080000305175781e+02,
+    3.7200000762939453e+01, 1.0320585632324219e+02,
+    4.6077486331341788e-05, 1, -1, 3.6840002441406250e+02,
+    1.6080000305175781e+02, 3.7200000762939453e+01,
+    1.0350190734863281e+02, 3.8536101783392951e-05, 1, -1,
+    1.9560000610351562e+02, 162., 3.7200000762939453e+01,
+    1.8181932067871094e+02, 1.0802334145409986e-04, 1, -1,
+    2.1480000305175781e+02, 162., 3.7200000762939453e+01,
+    4.2322219848632812e+01, 3.1670526368543506e-05, 1, -1,
+    2.4600001525878906e+02, 162., 3.7200000762939453e+01,
+    6.5300209045410156e+01, 7.4808303907047957e-07, 1, -1,
+    2.5680001831054688e+02, 162., 3.7200000762939453e+01,
+    8.3061073303222656e+01, 1.0906833267654292e-05, 1, -1, 348., 162.,
+    3.7200000762939453e+01, 9.9826957702636719e+01,
+    3.6300774809205905e-05, 1, -1, 3.7440002441406250e+02, 162.,
+    3.7200000762939453e+01, 9.9704223632812500e+01,
+    2.3885591872385703e-05, 1, -1, 4.2240002441406250e+02, 162.,
+    3.7200000762939453e+01, 1.4333020019531250e+02,
+    4.5356933696893975e-05, 1, -1, 1.8960000610351562e+02,
+    1.6320001220703125e+02, 3.7200000762939453e+01,
+    1.8189828491210938e+02, 1.0173760529141873e-05, 1, -1,
+    2.0280000305175781e+02, 1.6320001220703125e+02,
+    3.7200000762939453e+01, 1.6198376464843750e+02,
+    1.4936093066353351e-04, 1, -1, 2.6520001220703125e+02,
+    1.6320001220703125e+02, 3.7200000762939453e+01,
+    8.9247436523437500e+01, 7.2753209678921849e-06, 1, -1,
+    2.7240002441406250e+02, 1.6320001220703125e+02,
+    3.7200000762939453e+01, 9.5094566345214844e+01,
+    6.9522438934654929e-06, 1, -1, 360., 1.6320001220703125e+02,
+    3.7200000762939453e+01, 1.0270735931396484e+02,
+    5.2381645218702033e-05, 1, -1, 3.6720001220703125e+02,
+    1.6320001220703125e+02, 3.7200000762939453e+01,
+    1.0055334472656250e+02, 4.7076711780391634e-05, 1, -1,
+    3.8040002441406250e+02, 1.6320001220703125e+02,
+    3.7200000762939453e+01, 1.0058953094482422e+02,
+    3.8592104829149321e-05, 1, -1, 3.8640002441406250e+02,
+    1.6320001220703125e+02, 3.7200000762939453e+01,
+    9.4698646545410156e+01, 3.1608749850420281e-05, 1, -1,
+    4.3080001831054688e+02, 1.6320001220703125e+02,
+    3.7200000762939453e+01, 9.1064025878906250e+01,
+    3.7971803976688534e-05, 1, -1, 1.9320001220703125e+02,
+    1.6440000915527344e+02, 3.7200000762939453e+01,
+    1.7913142395019531e+02, 2.2936194000067189e-05, 1, -1,
+    2.8320001220703125e+02, 1.6440000915527344e+02,
+    3.7200000762939453e+01, 9.8709381103515625e+01,
+    5.6852495617931709e-06, 1, -1, 4.3680001831054688e+02,
+    1.6440000915527344e+02, 3.7200000762939453e+01,
+    4.3590114593505859e+01, 1.1168713172082789e-05, 1, -1,
+    4.4040002441406250e+02, 1.6440000915527344e+02,
+    3.7200000762939453e+01, 6.1257736206054688e+01,
+    2.0962349935871316e-06, 1, -1, 4.4760000610351562e+02,
+    1.6440000915527344e+02, 3.7200000762939453e+01,
+    8.4489151000976562e+01, 6.4008386289060581e-06, 1, -1,
+    2.0640000915527344e+02, 1.6560000610351562e+02,
+    3.7200000762939453e+01, 1.0783009338378906e+02,
+    1.1134758824482560e-04, 1, -1, 2.9040002441406250e+02,
+    1.6560000610351562e+02, 3.7200000762939453e+01,
+    9.7368721008300781e+01, 7.2638590609130915e-06, 1, -1, 378.,
+    1.6560000610351562e+02, 3.7200000762939453e+01,
+    1.0982910919189453e+02, 3.7767789763165638e-05, 1, -1,
+    3.8040002441406250e+02, 1.6560000610351562e+02,
+    3.7200000762939453e+01, 1.0928968811035156e+02,
+    4.2327999835833907e-05, 1, -1, 3.9480001831054688e+02,
+    1.6560000610351562e+02, 3.7200000762939453e+01,
+    1.1812629699707031e+02, 6.4055711845867336e-05, 1, -1,
+    4.1040002441406250e+02, 1.6560000610351562e+02,
+    3.7200000762939453e+01, 1.1920813751220703e+02,
+    1.2507705832831562e-04, 1, -1, 4.2600003051757812e+02,
+    1.6560000610351562e+02, 3.7200000762939453e+01,
+    1.4030566406250000e+02, 4.9387977924197912e-05, 1, -1,
+    4.6080001831054688e+02, 1.6560000610351562e+02,
+    3.7200000762939453e+01, 1.2819081115722656e+02,
+    1.6707874237908982e-05, 1, -1, 4.8360000610351562e+02,
+    1.6560000610351562e+02, 3.7200000762939453e+01,
+    1.9242782592773438e+02, 6.0807901718362700e-06, 1, -1,
+    1.8960000610351562e+02, 1.6680000305175781e+02,
+    3.7200000762939453e+01, 1.7327281188964844e+02,
+    1.5145949873840436e-05, 1, -1, 2.1480000305175781e+02,
+    1.6680000305175781e+02, 3.7200000762939453e+01,
+    7.0757133483886719e+01, 1.4871222447254695e-05, 1, -1,
+    2.4600001525878906e+02, 1.6680000305175781e+02,
+    3.7200000762939453e+01, 5.3402130126953125e+01,
+    -2.2897414453382225e-07, 1, -1, 2.9760000610351562e+02,
+    1.6680000305175781e+02, 3.7200000762939453e+01,
+    1.0219776153564453e+02, 5.2856771617371123e-06, 1, -1,
+    3.0480001831054688e+02, 1.6680000305175781e+02,
+    3.7200000762939453e+01, 1.0665876007080078e+02,
+    7.8542398114223033e-06, 1, -1, 384., 1.6680000305175781e+02,
+    3.7200000762939453e+01, 1.0454878234863281e+02,
+    3.6246405215933919e-05, 1, -1, 3.9120001220703125e+02,
+    1.6680000305175781e+02, 3.7200000762939453e+01,
+    1.1514425659179688e+02, 4.8247966333292425e-05, 1, -1,
+    4.1520001220703125e+02, 1.6680000305175781e+02,
+    3.7200000762939453e+01, 1.2983164978027344e+02,
+    6.7896675318479538e-05, 1, -1, 4.5360000610351562e+02,
+    1.6680000305175781e+02, 3.7200000762939453e+01,
+    1.2134649658203125e+02, 1.3657184899784625e-04, 1, -1, 318., 168.,
+    3.7200000762939453e+01, 1.0310820007324219e+02,
+    6.1702003222308122e-06, 1, -1, 3.9600003051757812e+02, 168.,
+    3.7200000762939453e+01, 1.3255310058593750e+02,
+    4.8053905629785731e-05, 1, -1, 4.2000003051757812e+02, 168.,
+    3.7200000762939453e+01, 1.4382865905761719e+02,
+    4.6006880438653752e-05, 1, -1, 2.1000001525878906e+02,
+    1.6920001220703125e+02, 3.7200000762939453e+01,
+    9.2099021911621094e+01, 2.0544723156490363e-05, 1, -1,
+    3.1560000610351562e+02, 1.6920001220703125e+02,
+    3.7200000762939453e+01, 1.0843373870849609e+02,
+    7.8909706644481048e-06, 1, -1, 4.5240002441406250e+02,
+    1.6920001220703125e+02, 3.7200000762939453e+01,
+    1.2171486663818359e+02, 1.6762680024839938e-04, 1, -1,
+    4.5720001220703125e+02, 1.6920001220703125e+02,
+    3.7200000762939453e+01, 1.3855548095703125e+02,
+    3.6065149470232427e-04, 1, -1, 4.7160000610351562e+02,
+    1.6920001220703125e+02, 3.7200000762939453e+01,
+    1.4921559143066406e+02, 1.8347053264733404e-04, 1, -1,
+    4.7640002441406250e+02, 1.6920001220703125e+02,
+    3.7200000762939453e+01, 1.8147827148437500e+02,
+    3.9401245885528624e-05, 1, -1, 1.9680000305175781e+02,
+    1.7040000915527344e+02, 3.7200000762939453e+01,
+    1.4057652282714844e+02, 8.5770088844583370e-06, 1, -1,
+    1.9920001220703125e+02, 1.7040000915527344e+02,
+    3.7200000762939453e+01, 1.3044500732421875e+02,
+    1.0179644050367642e-05, 1, -1, 3.3120001220703125e+02,
+    1.7040000915527344e+02, 3.7200000762939453e+01,
+    1.0095420074462891e+02, 6.9175443968561012e-06, 1, -1,
+    4.0920001220703125e+02, 1.7040000915527344e+02,
+    3.7200000762939453e+01, 1.1502964782714844e+02,
+    5.6032153224805370e-05, 1, -1, 4.3320001220703125e+02,
+    1.7040000915527344e+02, 3.7200000762939453e+01,
+    3.5751666259765625e+02, 5.3872532589593902e-05, 1, -1,
+    2.4120001220703125e+02, 1.7160000610351562e+02,
+    3.7200000762939453e+01, 2.8391687393188477e+01,
+    8.1829057307913899e-05, 1, -1, 4.2840002441406250e+02,
+    1.7160000610351562e+02, 3.7200000762939453e+01,
+    1.4014631652832031e+02, 3.4824701288016513e-05, 1, -1,
+    4.3560000610351562e+02, 1.7160000610351562e+02,
+    3.7200000762939453e+01, 3.2735766601562500e+02,
+    1.4829541032668203e-04, 1, -1, 4.4040002441406250e+02,
+    1.7160000610351562e+02, 3.7200000762939453e+01,
+    3.2508370971679688e+02, 1.2457709817681462e-04, 1, -1,
+    4.5600003051757812e+02, 1.7160000610351562e+02,
+    3.7200000762939453e+01, 1.5449346923828125e+02,
+    2.7980582672171295e-04, 1, -1, 4.6560000610351562e+02,
+    1.7160000610351562e+02, 3.7200000762939453e+01,
+    1.3341036987304688e+02, 1.4066763105802238e-04, 1, -1,
+    4.7640002441406250e+02, 1.7160000610351562e+02,
+    3.7200000762939453e+01, 1.8532003784179688e+02,
+    3.0736962798982859e-05, 1, -1, 1.8720001220703125e+02,
+    1.7280000305175781e+02, 3.7200000762939453e+01,
+    1.8207695007324219e+02, 2.7670615963870659e-05, 1, -1,
+    2.1960000610351562e+02, 1.7280000305175781e+02,
+    3.7200000762939453e+01, 2.1096374511718750e+02,
+    1.3754112842434552e-05, 1, -1, 348., 1.7280000305175781e+02,
+    3.7200000762939453e+01, 8.9604629516601562e+01,
+    6.5338995227648411e-06, 1, -1, 354., 1.7280000305175781e+02,
+    3.7200000762939453e+01, 9.0209411621093750e+01,
+    8.9626655608299188e-06, 1, -1, 4.3080001831054688e+02,
+    1.7280000305175781e+02, 3.7200000762939453e+01,
+    1.4605259704589844e+02, 6.7655644670594484e-05, 1, -1,
+    4.5360000610351562e+02, 1.7280000305175781e+02,
+    3.7200000762939453e+01, 1.7170288085937500e+02,
+    1.4177305274643004e-04, 1, -1, 4.6200003051757812e+02,
+    1.7280000305175781e+02, 3.7200000762939453e+01,
+    1.5060995483398438e+02, 8.2473503425717354e-05, 1, -1,
+    4.7280001831054688e+02, 1.7280000305175781e+02,
+    3.7200000762939453e+01, 1.7873791503906250e+02,
+    4.7753728722454980e-05, 1, -1, 2.3160000610351562e+02, 174.,
+    3.7200000762939453e+01, 3.5801681518554688e+02,
+    6.6333901486359537e-05, 1, -1, 2.3760000610351562e+02, 174.,
+    3.7200000762939453e+01, 1.0082198143005371e+01,
+    1.9040136248804629e-04, 1, -1, 3.0240002441406250e+02, 174.,
+    3.7200000762939453e+01, 1.3600260925292969e+02,
+    3.6506444303086028e-06, 1, -1, 4.1880001831054688e+02, 174.,
+    3.7200000762939453e+01, 1.3963978576660156e+02,
+    1.4775522686250042e-05, 1, -1, 4.2360000610351562e+02, 174.,
+    3.7200000762939453e+01, 1.4082968139648438e+02,
+    2.5555991669534706e-05, 1, -1, 2.1240000915527344e+02,
+    1.7520001220703125e+02, 3.7200000762939453e+01,
+    1.7928266906738281e+02, -8.0039887961902423e-07, 1, -1,
+    2.1480000305175781e+02, 1.7520001220703125e+02,
+    3.7200000762939453e+01, 1.9902793884277344e+02,
+    3.2047262266132748e-06, 1, -1, 2.2920001220703125e+02,
+    1.7520001220703125e+02, 3.7200000762939453e+01,
+    3.4627404785156250e+02, 2.9708493457292207e-05, 1, -1,
+    4.4400003051757812e+02, 1.7520001220703125e+02,
+    3.7200000762939453e+01, 3.3559970092773438e+02,
+    8.9819322965922765e-06, 1, -1, 4.6920001220703125e+02,
+    1.7520001220703125e+02, 3.7200000762939453e+01,
+    1.8794517517089844e+02, 1.8159777391701937e-04, 1, -1,
+    2.2200001525878906e+02, 1.7640000915527344e+02,
+    3.7200000762939453e+01, 2.5664230346679688e+02,
+    2.6995974621968344e-05, 1, -1, 3.7440002441406250e+02,
+    1.7640000915527344e+02, 3.7200000762939453e+01,
+    1.5213414001464844e+02, 1.6522420992259867e-05, 1, -1,
+    4.2960000610351562e+02, 1.7640000915527344e+02,
+    3.7200000762939453e+01, 1.3407296752929688e+02,
+    5.6479831982869655e-05, 1, -1, 4.3560000610351562e+02,
+    1.7640000915527344e+02, 3.7200000762939453e+01,
+    1.1424206542968750e+02, 1.4084804570302367e-04, 1, -1,
+    4.7160000610351562e+02, 1.7640000915527344e+02,
+    3.7200000762939453e+01, 1.9867498779296875e+02,
+    5.0550723244668916e-05, 1, -1, 2.3160000610351562e+02,
+    1.7760000610351562e+02, 3.7200000762939453e+01,
+    3.4425381469726562e+02, 1.8937300774268806e-04, 1, -1,
+    4.1640002441406250e+02, 1.7760000610351562e+02,
+    3.7200000762939453e+01, 1.2731854248046875e+02,
+    7.6800388342235237e-05, 1, -1, 4.2120001220703125e+02,
+    1.7760000610351562e+02, 3.7200000762939453e+01,
+    1.3246496582031250e+02, 4.6472065150737762e-05, 1, -1,
+    4.3200003051757812e+02, 1.7760000610351562e+02,
+    3.7200000762939453e+01, 1.3407943725585938e+02,
+    1.0998678044416010e-04, 1, -1, 4.6560000610351562e+02,
+    1.7760000610351562e+02, 3.7200000762939453e+01,
+    2.0679002380371094e+02, 1.2039749708492309e-04, 1, -1,
+    1.8120001220703125e+02, 1.7880000305175781e+02,
+    3.7200000762939453e+01, 2.3612210083007812e+02,
+    4.2824081901926547e-05, 1, -1, 1.8480000305175781e+02,
+    1.7880000305175781e+02, 3.7200000762939453e+01,
+    2.2989450073242188e+02, 1.5787679876666516e-04, 1, -1,
+    2.1240000915527344e+02, 1.7880000305175781e+02,
+    3.7200000762939453e+01, 2.0320341491699219e+02,
+    1.7269719592150068e-06, 1, -1, 4.1280001831054688e+02,
+    1.7880000305175781e+02, 3.7200000762939453e+01,
+    1.1511951446533203e+02, 8.6971987911965698e-05, 1, -1,
+    4.3800003051757812e+02, 1.7880000305175781e+02,
+    3.7200000762939453e+01, 9.8665283203125000e+01,
+    2.9731076210737228e-05, 1, -1, 1.8720001220703125e+02, 180.,
+    3.7200000762939453e+01, 2.3101214599609375e+02,
+    1.1496690422063693e-04, 1, -1, 2.3280000305175781e+02, 180.,
+    3.7200000762939453e+01, 3.4332855224609375e+02,
+    2.4508446222171187e-04, 1, -1, 3.3360000610351562e+02, 180.,
+    3.7200000762939453e+01, 3.4951382446289062e+02,
+    1.7875148841994815e-05, 1, -1, 4.0200003051757812e+02, 180.,
+    3.7200000762939453e+01, 3.1021823120117188e+02,
+    2.2398147848434746e-05, 1, -1, 4.2480001831054688e+02, 180.,
+    3.7200000762939453e+01, 1.3110026550292969e+02,
+    1.3621788639284205e-05, 1, -1, 4.7280001831054688e+02, 180.,
+    3.7200000762939453e+01, 2.1305541992187500e+02,
+    1.0375097190262750e-05, 1, -1, 2.1840000915527344e+02,
+    1.8120001220703125e+02, 3.7200000762939453e+01,
+    2.3209179687500000e+02, 1.0664753972378094e-05, 1, -1,
+    2.3880000305175781e+02, 1.8120001220703125e+02,
+    3.7200000762939453e+01, 3.5659179687500000e+02,
+    9.1033391072414815e-05, 1, -1, 2.6760000610351562e+02,
+    1.8120001220703125e+02, 3.7200000762939453e+01,
+    2.2793774414062500e+02, 2.0226236301823519e-05, 1, -1,
+    3.4440002441406250e+02, 1.8120001220703125e+02,
+    3.7200000762939453e+01, 3.6296741485595703e+01,
+    1.2466557564039249e-05, 1, -1, 372., 1.8120001220703125e+02,
+    3.7200000762939453e+01, 1.6341831970214844e+02,
+    5.7678087614476681e-05, 1, -1, 3.7680001831054688e+02,
+    1.8120001220703125e+02, 3.7200000762939453e+01,
+    1.7103494262695312e+02, 2.1399180695880204e-04, 1, -1,
+    3.7920001220703125e+02, 1.8120001220703125e+02,
+    3.7200000762939453e+01, 1.7553179931640625e+02,
+    2.1083760657347739e-04, 1, -1, 3.8520001220703125e+02,
+    1.8120001220703125e+02, 3.7200000762939453e+01,
+    1.9767944335937500e+02, 1.2840703129768372e-04, 1, -1,
+    4.4640002441406250e+02, 1.8120001220703125e+02,
+    3.7200000762939453e+01, 2.9967791748046875e+02,
+    9.7179639851674438e-05, 1, -1, 4.6680001831054688e+02,
+    1.8120001220703125e+02, 3.7200000762939453e+01,
+    2.0818194580078125e+02, 9.8558033641893417e-05, 1, -1,
+    1.7880000305175781e+02, 1.8240000915527344e+02,
+    3.7200000762939453e+01, 2.2959342956542969e+02,
+    2.1030455172876827e-05, 1, -1, 1.8240000915527344e+02,
+    1.8240000915527344e+02, 3.7200000762939453e+01,
+    2.4506015014648438e+02, 6.0134061641292647e-05, 1, -1,
+    2.3520001220703125e+02, 1.8240000915527344e+02,
+    3.7200000762939453e+01, 3.5342407226562500e+02,
+    2.5383470347151160e-04, 1, -1, 2.7840002441406250e+02,
+    1.8240000915527344e+02, 3.7200000762939453e+01,
+    2.4396432495117188e+02, 2.3694590709055774e-05, 1, -1,
+    3.0480001831054688e+02, 1.8240000915527344e+02,
+    3.7200000762939453e+01, 2.5261660766601562e+02,
+    3.5417262552073225e-05, 1, -1, 3.1080001831054688e+02,
+    1.8240000915527344e+02, 3.7200000762939453e+01,
+    2.2317184448242188e+02, 1.6150233932421543e-05, 1, -1,
+    3.1560000610351562e+02, 1.8240000915527344e+02,
+    3.7200000762939453e+01, 2.3384469604492188e+02,
+    2.3962807972566225e-05, 1, -1, 3.2160000610351562e+02,
+    1.8240000915527344e+02, 3.7200000762939453e+01,
+    2.7914028930664062e+02, 9.6427629614481702e-06, 1, -1, 336.,
+    1.8240000915527344e+02, 3.7200000762939453e+01,
+    3.3468914031982422e+00, 4.3284901039442047e-05, 1, -1,
+    4.0080001831054688e+02, 1.8240000915527344e+02,
+    3.7200000762939453e+01, 3.0260601806640625e+02,
+    5.6941637012641877e-05, 1, -1, 4.3200003051757812e+02,
+    1.8240000915527344e+02, 3.7200000762939453e+01,
+    1.3918774414062500e+02, 8.4053375758230686e-05, 1, -1,
+    4.6440002441406250e+02, 1.8240000915527344e+02,
+    3.7200000762939453e+01, 2.0791098022460938e+02,
+    6.9964487920515239e-05, 1, -1, 4.7160000610351562e+02,
+    1.8240000915527344e+02, 3.7200000762939453e+01,
+    2.0425988769531250e+02, 1.7018317521433346e-05, 1, -1,
+    2.0880000305175781e+02, 1.8360000610351562e+02,
+    3.7200000762939453e+01, 2.0157212829589844e+02,
+    1.9517597138474230e-07, 1, -1, 2.6520001220703125e+02,
+    1.8360000610351562e+02, 3.7200000762939453e+01,
+    2.3076260375976562e+02, 5.2910731028532609e-05, 1, -1, 282.,
+    1.8360000610351562e+02, 3.7200000762939453e+01,
+    2.5694555664062500e+02, 2.2117827029433101e-05, 1, -1,
+    4.3440002441406250e+02, 1.8360000610351562e+02,
+    3.7200000762939453e+01, 1.4586074829101562e+02,
+    8.5690095147583634e-05, 1, -1, 4.3800003051757812e+02,
+    1.8360000610351562e+02, 3.7200000762939453e+01,
+    1.5816909790039062e+02, 1.0287601617164910e-04, 1, -1,
+    4.4160000610351562e+02, 1.8360000610351562e+02,
+    3.7200000762939453e+01, 2.0114721679687500e+02,
+    1.1740084300981835e-04, 1, -1, 4.4880001831054688e+02,
+    1.8360000610351562e+02, 3.7200000762939453e+01,
+    2.7694229125976562e+02, 1.0928912524832413e-04, 1, -1,
+    4.5840002441406250e+02, 1.8360000610351562e+02,
+    3.7200000762939453e+01, 2.5032846069335938e+02,
+    3.2090134482132271e-05, 1, -1, 4.6200003051757812e+02,
+    1.8360000610351562e+02, 3.7200000762939453e+01,
+    2.3112280273437500e+02, 6.9759953476022929e-05, 1, -1,
+    2.1480000305175781e+02, 1.8480000305175781e+02,
+    3.7200000762939453e+01, 2.1328353881835938e+02,
+    4.3810552597278729e-05, 1, -1, 2.2560000610351562e+02,
+    1.8480000305175781e+02, 3.7200000762939453e+01,
+    3.4308361816406250e+02, 1.1922315934498329e-05, 1, -1,
+    2.3640000915527344e+02, 1.8480000305175781e+02,
+    3.7200000762939453e+01, 9.7032600641250610e-01,
+    1.5355742652900517e-04, 1, -1, 2.7720001220703125e+02,
+    1.8480000305175781e+02, 3.7200000762939453e+01,
+    2.4359494018554688e+02, 3.4923119528684765e-05, 1, -1,
+    2.8680001831054688e+02, 1.8480000305175781e+02,
+    3.7200000762939453e+01, 2.6724652099609375e+02,
+    1.1870888556586578e-06, 1, -1, 3.0240002441406250e+02,
+    1.8480000305175781e+02, 3.7200000762939453e+01,
+    2.7075341796875000e+02, 5.9855574363609776e-05, 1, -1,
+    3.1680001831054688e+02, 1.8480000305175781e+02,
+    3.7200000762939453e+01, 2.5017300415039062e+02,
+    3.3462431019870564e-05, 1, -1, 3.2520001220703125e+02,
+    1.8480000305175781e+02, 3.7200000762939453e+01,
+    2.9313650512695312e+02, 1.4533305147779174e-05, 1, -1, 378.,
+    1.8480000305175781e+02, 3.7200000762939453e+01,
+    1.8394923400878906e+02, 4.6287817531265318e-04, 1, -1,
+    4.4640002441406250e+02, 1.8480000305175781e+02,
+    3.7200000762939453e+01, 2.5576416015625000e+02,
+    2.3511229665018618e-04, 1, -1, 4.7040002441406250e+02,
+    1.8480000305175781e+02, 3.7200000762939453e+01,
+    2.0000332641601562e+02, 1.3421816220215987e-05, 1, -1, 258., 186.,
+    3.7200000762939453e+01, 2.5488053894042969e+02,
+    -3.1046773074194789e-05, 1, -1, 2.6640002441406250e+02, 186.,
+    3.7200000762939453e+01, 2.2728878784179688e+02,
+    3.8770904211560264e-05, 1, -1, 2.9040002441406250e+02, 186.,
+    3.7200000762939453e+01, 2.7203085327148438e+02,
+    1.9224657989980187e-06, 1, -1, 294., 186., 3.7200000762939453e+01,
+    2.7578646850585938e+02, -2.2157007606438128e-06, 1, -1,
+    2.9880001831054688e+02, 186., 3.7200000762939453e+01,
+    2.7331954956054688e+02, 5.1504233852028847e-05, 1, -1,
+    3.3360000610351562e+02, 186., 3.7200000762939453e+01,
+    3.3135659790039062e+02, 5.7542005379218608e-05, 1, -1,
+    3.3960000610351562e+02, 186., 3.7200000762939453e+01,
+    6.0557851791381836e+00, 2.3033837351249531e-05, 1, -1,
+    4.3200003051757812e+02, 186., 3.7200000762939453e+01,
+    1.4960862731933594e+02, 3.6597011785488576e-05, 1, -1,
+    4.8720001220703125e+02, 186., 3.7200000762939453e+01,
+    2.0403866577148438e+02, 8.8036733814078616e-07, 1, -1,
+    2.0640000915527344e+02, 1.8720001220703125e+02,
+    3.7200000762939453e+01, 2.0966781616210938e+02,
+    -1.0392780041001970e-06, 1, -1, 2.3520001220703125e+02,
+    1.8720001220703125e+02, 3.7200000762939453e+01,
+    5.9596943855285645e+00, 2.7301133377477527e-04, 1, -1,
+    3.1320001220703125e+02, 1.8720001220703125e+02,
+    3.7200000762939453e+01, 2.5427793884277344e+02,
+    6.2105609686113894e-05, 1, -1, 3.6960000610351562e+02,
+    1.8720001220703125e+02, 3.7200000762939453e+01,
+    1.7217892456054688e+02, 2.9158557299524546e-04, 1, -1,
+    3.9840002441406250e+02, 1.8720001220703125e+02,
+    3.7200000762939453e+01, 2.9437826538085938e+02,
+    4.1043967939913273e-05, 1, -1, 4.1160000610351562e+02,
+    1.8720001220703125e+02, 3.7200000762939453e+01,
+    3.2152575683593750e+02, 1.0515953363210429e-05, 1, -1,
+    4.6680001831054688e+02, 1.8720001220703125e+02,
+    3.7200000762939453e+01, 2.1124674987792969e+02,
+    3.5900578950531781e-05, 1, -1, 1.7160000610351562e+02,
+    1.8840000915527344e+02, 3.7200000762939453e+01,
+    2.0413558959960938e+02, 8.0835279732127674e-06, 1, -1,
+    1.9560000610351562e+02, 1.8840000915527344e+02,
+    3.7200000762939453e+01, 2.5598742675781250e+02,
+    8.0390300354338251e-06, 1, -1, 2.1360000610351562e+02,
+    1.8840000915527344e+02, 3.7200000762939453e+01,
+    2.1116421508789062e+02, 3.5473734897095710e-05, 1, -1,
+    2.3160000610351562e+02, 1.8840000915527344e+02,
+    3.7200000762939453e+01, 1.4233183860778809e+01,
+    3.3303763484582305e-04, 1, -1, 2.5320001220703125e+02,
+    1.8840000915527344e+02, 3.7200000762939453e+01,
+    2.7104858398437500e+02, 1.7207239579875022e-05, 1, -1,
+    3.2880001831054688e+02, 1.8840000915527344e+02,
+    3.7200000762939453e+01, 3.1447741699218750e+02,
+    6.8445842771325260e-05, 1, -1, 3.8760000610351562e+02,
+    1.8840000915527344e+02, 3.7200000762939453e+01,
+    1.8371678161621094e+02, 5.6946104450616986e-05, 1, -1,
+    3.9120001220703125e+02, 1.8840000915527344e+02,
+    3.7200000762939453e+01, 2.0407623291015625e+02,
+    3.4922963095596060e-05, 1, -1, 3.9480001831054688e+02,
+    1.8840000915527344e+02, 3.7200000762939453e+01,
+    2.7706930541992188e+02, 3.1231593311531469e-05, 1, -1,
+    2.3760000610351562e+02, 1.8960000610351562e+02,
+    3.7200000762939453e+01, 1.1894824028015137e+01,
+    2.2837113647256047e-04, 1, -1, 3.1680001831054688e+02,
+    1.8960000610351562e+02, 3.7200000762939453e+01,
+    2.6787359619140625e+02, 7.8692530223634094e-05, 1, -1,
+    3.6960000610351562e+02, 1.8960000610351562e+02,
+    3.7200000762939453e+01, 1.8171096801757812e+02,
+    3.2295836717821658e-04, 1, -1, 4.6320001220703125e+02,
+    1.8960000610351562e+02, 3.7200000762939453e+01,
+    2.3990383911132812e+02, 1.1809563147835433e-04, 1, -1,
+    1.7280000305175781e+02, 1.9080000305175781e+02,
+    3.7200000762939453e+01, 2.0112901306152344e+02,
+    2.4769306037342176e-05, 1, -1, 1.9560000610351562e+02,
+    1.9080000305175781e+02, 3.7200000762939453e+01,
+    2.3526216125488281e+02, 9.2647042038151994e-06, 1, -1,
+    2.2200001525878906e+02, 1.9080000305175781e+02,
+    3.7200000762939453e+01, 4.6288196563720703e+01,
+    5.9046800743089989e-05, 1, -1, 2.3280000305175781e+02,
+    1.9080000305175781e+02, 3.7200000762939453e+01,
+    2.0702402114868164e+01, 4.7806400107219815e-04, 1, -1,
+    2.4480000305175781e+02, 1.9080000305175781e+02,
+    3.7200000762939453e+01, 3.5896951293945312e+02,
+    -8.5149645201454405e-07, 1, -1, 2.7480001831054688e+02,
+    1.9080000305175781e+02, 3.7200000762939453e+01,
+    2.2646409606933594e+02, 6.7637790925800800e-04, 1, -1,
+    2.7960000610351562e+02, 1.9080000305175781e+02,
+    3.7200000762939453e+01, 2.3641084289550781e+02,
+    8.4063131362199783e-04, 1, -1, 3.0360000610351562e+02,
+    1.9080000305175781e+02, 3.7200000762939453e+01,
+    2.7662579345703125e+02, 2.0093049897695892e-05, 1, -1,
+    3.1080001831054688e+02, 1.9080000305175781e+02,
+    3.7200000762939453e+01, 2.8105667114257812e+02,
+    1.0379929153714329e-04, 1, -1, 3.4680001831054688e+02,
+    1.9080000305175781e+02, 3.7200000762939453e+01,
+    4.2984576225280762e+00, 6.7822948039975017e-05, 1, -1,
+    3.7560000610351562e+02, 1.9080000305175781e+02,
+    3.7200000762939453e+01, 1.8056526184082031e+02,
+    1.5381028060801327e-04, 1, -1, 4.3560000610351562e+02,
+    1.9080000305175781e+02, 3.7200000762939453e+01,
+    1.4353558349609375e+02, 1.1499567335704342e-05, 1, -1,
+    4.6560000610351562e+02, 1.9080000305175781e+02,
+    3.7200000762939453e+01, 2.2356048583984375e+02,
+    4.1978153603849933e-05, 1, -1, 1.8720001220703125e+02, 192.,
+    3.7200000762939453e+01, 5.0260284423828125e+01,
+    1.0399833990959451e-04, 1, -1, 1.8960000610351562e+02, 192.,
+    3.7200000762939453e+01, 2.9029623031616211e+01,
+    5.1003000407945365e-05, 1, -1, 2.7720001220703125e+02, 192.,
+    3.7200000762939453e+01, 2.2624403381347656e+02,
+    8.0924748908728361e-04, 1, -1, 282., 192., 3.7200000762939453e+01,
+    2.3900198364257812e+02, 6.7666894756257534e-04, 1, -1, 294., 192.,
+    3.7200000762939453e+01, 2.7611206054687500e+02,
+    6.1038947023916990e-05, 1, -1, 2.9640002441406250e+02, 192.,
+    3.7200000762939453e+01, 2.7233654785156250e+02,
+    6.2979255744721740e-05, 1, -1, 318., 192., 3.7200000762939453e+01,
+    2.8609313964843750e+02, 5.2341318223625422e-05, 1, -1,
+    3.3360000610351562e+02, 192., 3.7200000762939453e+01,
+    3.4810729980468750e+02, 7.7219578088261187e-05, 1, -1,
+    3.6240002441406250e+02, 192., 3.7200000762939453e+01,
+    2.1069573974609375e+02, 3.9123922761064023e-05, 1, -1,
+    3.8280001831054688e+02, 192., 3.7200000762939453e+01,
+    1.6741250610351562e+02, 1.0364094487158582e-04, 1, -1,
+    3.9000003051757812e+02, 192., 3.7200000762939453e+01,
+    1.5222621154785156e+02, 1.3377166760619730e-04, 1, -1,
+    4.0320001220703125e+02, 192., 3.7200000762939453e+01,
+    3.0852047729492188e+02, 4.0664581320015714e-05, 1, -1,
+    2.0880000305175781e+02, 1.9320001220703125e+02,
+    3.7200000762939453e+01, 1.9721134948730469e+02,
+    3.8817222957732156e-05, 1, -1, 2.1240000915527344e+02,
+    1.9320001220703125e+02, 3.7200000762939453e+01,
+    1.7925230407714844e+02, 7.0068068453110754e-05, 1, -1,
+    3.2880001831054688e+02, 1.9320001220703125e+02,
+    3.7200000762939453e+01, 3.3243920898437500e+02,
+    8.5639287135563791e-05, 1, -1, 336., 1.9320001220703125e+02,
+    3.7200000762939453e+01, 1.0624111890792847e+00,
+    1.2169760157121345e-04, 1, -1, 3.4080001831054688e+02,
+    1.9320001220703125e+02, 3.7200000762939453e+01,
+    8.1469535827636719e+00, 2.7138271252624691e-04, 1, -1,
+    3.5280001831054688e+02, 1.9320001220703125e+02,
+    3.7200000762939453e+01, 3.1737298583984375e+02,
+    -3.1265477673514397e-07, 1, -1, 4.1760000610351562e+02,
+    1.9320001220703125e+02, 3.7200000762939453e+01,
+    3.2812295532226562e+02, 1.1545957022462972e-05, 1, -1,
+    1.7040000915527344e+02, 1.9440000915527344e+02,
+    3.7200000762939453e+01, 1.9480966186523438e+02,
+    1.8180664483224973e-05, 1, -1, 1.7520001220703125e+02,
+    1.9440000915527344e+02, 3.7200000762939453e+01,
+    1.9360404968261719e+02, 2.6165454983129166e-05, 1, -1,
+    2.3160000610351562e+02, 1.9440000915527344e+02,
+    3.7200000762939453e+01, 3.3886917114257812e+01,
+    3.9949303027242422e-04, 1, -1, 2.3760000610351562e+02,
+    1.9440000915527344e+02, 3.7200000762939453e+01,
+    2.3225988388061523e+01, 2.1970387024339288e-04, 1, -1,
+    2.4120001220703125e+02, 1.9440000915527344e+02,
+    3.7200000762939453e+01, 1.3300939559936523e+01,
+    3.1477119773626328e-04, 1, -1, 276., 1.9440000915527344e+02,
+    3.7200000762939453e+01, 2.1371789550781250e+02,
+    1.5099906886462122e-04, 1, -1, 3.1080001831054688e+02,
+    1.9440000915527344e+02, 3.7200000762939453e+01,
+    3.0614096069335938e+02, 1.8654155428521335e-04, 1, -1,
+    3.8640002441406250e+02, 1.9440000915527344e+02,
+    3.7200000762939453e+01, 1.4078895568847656e+02,
+    1.4698630548082292e-04, 1, -1, 3.8880001831054688e+02,
+    1.9440000915527344e+02, 3.7200000762939453e+01,
+    1.3475389099121094e+02, 2.0229192159604281e-04, 1, -1,
+    4.5840002441406250e+02, 1.9440000915527344e+02,
+    3.7200000762939453e+01, 2.7448962402343750e+02,
+    1.1773049482144415e-04, 1, -1, 2.5680001831054688e+02,
+    1.9560000610351562e+02, 3.7200000762939453e+01,
+    2.3318577575683594e+02, 1.7640560690779239e-04, 1, -1, 288.,
+    1.9560000610351562e+02, 3.7200000762939453e+01,
+    2.5046899414062500e+02, 1.5865649038460106e-04, 1, -1,
+    3.0840002441406250e+02, 1.9560000610351562e+02,
+    3.7200000762939453e+01, 3.0791595458984375e+02,
+    1.5153638378251344e-04, 1, -1, 3.8160000610351562e+02,
+    1.9560000610351562e+02, 3.7200000762939453e+01,
+    1.5183052062988281e+02, 2.4394072534050792e-04, 1, -1,
+    3.9720001220703125e+02, 1.9560000610351562e+02,
+    3.7200000762939453e+01, 1.1863085174560547e+02,
+    5.0204183935420588e-05, 1, -1, 4.3560000610351562e+02,
+    1.9560000610351562e+02, 3.7200000762939453e+01,
+    1.4489062500000000e+02, 1.5431718566105701e-05, 1, -1,
+    4.4040002441406250e+02, 1.9560000610351562e+02,
+    3.7200000762939453e+01, 1.5088760375976562e+02,
+    3.2860461942618713e-05, 1, -1, 1.7280000305175781e+02,
+    1.9680000305175781e+02, 3.7200000762939453e+01,
+    1.8288208007812500e+02, 2.1104291590745561e-05, 1, -1,
+    1.8240000915527344e+02, 1.9680000305175781e+02,
+    3.7200000762939453e+01, 6.4839942932128906e+01,
+    1.9328741473145783e-05, 1, -1, 1.9800001525878906e+02,
+    1.9680000305175781e+02, 3.7200000762939453e+01,
+    2.1228929138183594e+02, 1.9627250367193483e-06, 1, -1,
+    2.3160000610351562e+02, 1.9680000305175781e+02,
+    3.7200000762939453e+01, 4.0019023895263672e+01,
+    3.4801149740815163e-04, 1, -1, 2.4480000305175781e+02,
+    1.9680000305175781e+02, 3.7200000762939453e+01,
+    2.4045195579528809e+00, 3.8903622771613300e-04, 1, -1,
+    2.6520001220703125e+02, 1.9680000305175781e+02,
+    3.7200000762939453e+01, 2.0622280883789062e+02,
+    8.4386920207180083e-05, 1, -1, 2.6880001831054688e+02,
+    1.9680000305175781e+02, 3.7200000762939453e+01,
+    2.0001495361328125e+02, 2.7220934862270951e-04, 1, -1,
+    3.1560000610351562e+02, 1.9680000305175781e+02,
+    3.7200000762939453e+01, 3.1954095458984375e+02,
+    1.4222390018403530e-04, 1, -1, 3.2040002441406250e+02,
+    1.9680000305175781e+02, 3.7200000762939453e+01,
+    3.2000573730468750e+02, 9.9395168945193291e-05, 1, -1, 330.,
+    1.9680000305175781e+02, 3.7200000762939453e+01,
+    5.6646758317947388e-01, 9.3738104624208063e-05, 1, -1,
+    3.3960000610351562e+02, 1.9680000305175781e+02,
+    3.7200000762939453e+01, 2.8774095535278320e+01,
+    1.1341469507897273e-04, 1, -1, 3.6720001220703125e+02,
+    1.9680000305175781e+02, 3.7200000762939453e+01,
+    2.0305049133300781e+02, 9.9130658782087266e-05, 1, -1, 378.,
+    1.9680000305175781e+02, 3.7200000762939453e+01,
+    1.6107194519042969e+02, 2.5105313397943974e-04, 1, -1,
+    4.1040002441406250e+02, 1.9680000305175781e+02,
+    3.7200000762939453e+01, 3.2978927612304688e+02,
+    7.4885538197122514e-05, 1, -1, 4.3080001831054688e+02,
+    1.9680000305175781e+02, 3.7200000762939453e+01,
+    1.3971153259277344e+02, 4.8297566536348313e-05, 1, -1,
+    4.6200003051757812e+02, 1.9680000305175781e+02,
+    3.7200000762939453e+01, 2.2466204833984375e+02,
+    9.8690186860039830e-05, 1, -1, 1.9080000305175781e+02,
+    1.9800001525878906e+02, 3.7200000762939453e+01,
+    1.7527114868164062e+02, 7.1447002483182587e-06, 1, -1,
+    2.0760000610351562e+02, 1.9800001525878906e+02,
+    3.7200000762939453e+01, 1.8917793273925781e+02,
+    6.8248671595938504e-05, 1, -1, 2.1120001220703125e+02,
+    1.9800001525878906e+02, 3.7200000762939453e+01,
+    1.3624148559570312e+02, 7.3341863753739744e-05, 1, -1,
+    2.2080000305175781e+02, 1.9800001525878906e+02,
+    3.7200000762939453e+01, 6.5212104797363281e+01,
+    1.3080069038551301e-04, 1, -1, 2.5200001525878906e+02,
+    1.9800001525878906e+02, 3.7200000762939453e+01,
+    2.6395611572265625e+02, 1.8723453104030341e-04, 1, -1,
+    2.6040002441406250e+02, 1.9800001525878906e+02,
+    3.7200000762939453e+01, 2.1434570312500000e+02,
+    1.0041616042144597e-04, 1, -1, 3.0360000610351562e+02,
+    1.9800001525878906e+02, 3.7200000762939453e+01,
+    2.9955215454101562e+02, 8.5081330325920135e-05, 1, -1,
+    3.0840002441406250e+02, 1.9800001525878906e+02,
+    3.7200000762939453e+01, 3.1562091064453125e+02,
+    1.5306487330235541e-04, 1, -1, 3.6480001831054688e+02,
+    1.9800001525878906e+02, 3.7200000762939453e+01,
+    2.0463655090332031e+02, 9.0407382231205702e-05, 1, -1,
+    4.3920001220703125e+02, 1.9800001525878906e+02,
+    3.7200000762939453e+01, 1.5102233886718750e+02,
+    2.3281527319340967e-05, 1, -1, 4.4520001220703125e+02,
+    1.9800001525878906e+02, 3.7200000762939453e+01,
+    1.5623812866210938e+02, 1.4911121979821473e-04, 1, -1,
+    2.2800001525878906e+02, 1.9920001220703125e+02,
+    3.7200000762939453e+01, 5.0287872314453125e+01,
+    1.9161189266014844e-04, 1, -1, 2.3880000305175781e+02,
+    1.9920001220703125e+02, 3.7200000762939453e+01,
+    2.9759950637817383e+01, 1.7415815091226250e-04, 1, -1,
+    2.7240002441406250e+02, 1.9920001220703125e+02,
+    3.7200000762939453e+01, 1.8566546630859375e+02,
+    1.8189621914643794e-04, 1, -1, 312., 1.9920001220703125e+02,
+    3.7200000762939453e+01, 3.2608020019531250e+02,
+    2.6874207833316177e-05, 1, -1, 3.5280001831054688e+02,
+    1.9920001220703125e+02, 3.7200000762939453e+01,
+    5.7554100036621094e+01, 5.3334315452957526e-05, 1, -1,
+    3.6840002441406250e+02, 1.9920001220703125e+02,
+    3.7200000762939453e+01, 1.9542628479003906e+02,
+    1.2095674901502207e-04, 1, -1, 3.8160000610351562e+02,
+    1.9920001220703125e+02, 3.7200000762939453e+01,
+    1.2583631896972656e+02, 3.3302480005659163e-04, 1, -1,
+    3.9720001220703125e+02, 1.9920001220703125e+02,
+    3.7200000762939453e+01, 1.1785154724121094e+02,
+    6.6035841882694513e-05, 1, -1, 4.0680001831054688e+02,
+    1.9920001220703125e+02, 3.7200000762939453e+01,
+    6.4517654418945312e+01, 6.9416171754710376e-05, 1, -1,
+    4.2360000610351562e+02, 1.9920001220703125e+02,
+    3.7200000762939453e+01, 7.7061548233032227e+00,
+    1.5904992324067280e-05, 1, -1, 4.6440002441406250e+02,
+    1.9920001220703125e+02, 3.7200000762939453e+01,
+    2.0828950500488281e+02, 1.3133433640177827e-05, 1, -1,
+    1.7520001220703125e+02, 2.0040000915527344e+02,
+    3.7200000762939453e+01, 1.6681254577636719e+02,
+    1.3027199202042539e-05, 1, -1, 2.0400001525878906e+02,
+    2.0040000915527344e+02, 3.7200000762939453e+01,
+    1.9315121459960938e+02, 9.2696418505511247e-06, 1, -1,
+    2.3400001525878906e+02, 2.0040000915527344e+02,
+    3.7200000762939453e+01, 4.2509761810302734e+01,
+    1.4316663146018982e-04, 1, -1, 2.6760000610351562e+02,
+    2.0040000915527344e+02, 3.7200000762939453e+01,
+    1.9278648376464844e+02, 4.6650500735267997e-04, 1, -1,
+    3.0840002441406250e+02, 2.0040000915527344e+02,
+    3.7200000762939453e+01, 3.2550762939453125e+02,
+    1.2846637400798500e-04, 1, -1, 318., 2.0040000915527344e+02,
+    3.7200000762939453e+01, 3.3465618896484375e+02,
+    2.5816552806645632e-04, 1, -1, 330., 2.0040000915527344e+02,
+    3.7200000762939453e+01, 6.6619224548339844e+00,
+    5.4326810641214252e-05, 1, -1, 3.4560000610351562e+02,
+    2.0040000915527344e+02, 3.7200000762939453e+01,
+    4.3297801971435547e+01, 1.3371047316468321e-05, 1, -1, 384.,
+    2.0040000915527344e+02, 3.7200000762939453e+01,
+    1.1306315612792969e+02, 3.9269475382752717e-04, 1, -1,
+    3.8640002441406250e+02, 2.0040000915527344e+02,
+    3.7200000762939453e+01, 1.1461857604980469e+02,
+    3.8651991053484380e-04, 1, -1, 4.0080001831054688e+02,
+    2.0040000915527344e+02, 3.7200000762939453e+01,
+    1.1753031158447266e+02, 7.8663426393177360e-05, 1, -1,
+    4.1280001831054688e+02, 2.0040000915527344e+02,
+    3.7200000762939453e+01, 3.4627816772460938e+02,
+    8.9799395937006921e-05, 1, -1, 1.9680000305175781e+02,
+    2.0160000610351562e+02, 3.7200000762939453e+01,
+    2.0928314208984375e+02, 2.7410235361458035e-06, 1, -1,
+    2.1000001525878906e+02, 2.0160000610351562e+02,
+    3.7200000762939453e+01, 8.9666183471679688e+01,
+    7.2010872827377170e-05, 1, -1, 2.2200001525878906e+02,
+    2.0160000610351562e+02, 3.7200000762939453e+01,
+    5.9020858764648438e+01, 6.4734608167782426e-04, 1, -1,
+    2.7360000610351562e+02, 2.0160000610351562e+02,
+    3.7200000762939453e+01, 1.8015493774414062e+02,
+    9.4334398454520851e-05, 1, -1, 3.2160000610351562e+02,
+    2.0160000610351562e+02, 3.7200000762939453e+01,
+    3.4926824951171875e+02, 1.3782278983853757e-04, 1, -1,
+    3.3720001220703125e+02, 2.0160000610351562e+02,
+    3.7200000762939453e+01, 4.5923504829406738e+00,
+    2.0792009308934212e-05, 1, -1, 3.9240002441406250e+02,
+    2.0160000610351562e+02, 3.7200000762939453e+01,
+    1.1759178924560547e+02, 2.4364190176129341e-04, 1, -1,
+    3.9840002441406250e+02, 2.0160000610351562e+02,
+    3.7200000762939453e+01, 1.2154701995849609e+02,
+    1.9086225074715912e-04, 1, -1, 4.6080001831054688e+02,
+    2.0160000610351562e+02, 3.7200000762939453e+01,
+    1.9499702453613281e+02, 2.5314047888969071e-05, 1, -1,
+    2.3880000305175781e+02, 2.0280000305175781e+02,
+    3.7200000762939453e+01, 3.7254558563232422e+01,
+    1.6217541997320950e-04, 1, -1, 2.6760000610351562e+02,
+    2.0280000305175781e+02, 3.7200000762939453e+01,
+    1.9450979614257812e+02, 5.2966090152040124e-04, 1, -1, 294.,
+    2.0280000305175781e+02, 3.7200000762939453e+01,
+    2.4673611450195312e+02, 6.2220831750892103e-05, 1, -1,
+    3.0360000610351562e+02, 2.0280000305175781e+02,
+    3.7200000762939453e+01, 3.2530065917968750e+02,
+    7.5597381510306150e-05, 1, -1, 3.0840002441406250e+02,
+    2.0280000305175781e+02, 3.7200000762939453e+01,
+    3.3629931640625000e+02, 1.0606737487250939e-04, 1, -1,
+    3.1080001831054688e+02, 2.0280000305175781e+02,
+    3.7200000762939453e+01, 3.3635971069335938e+02,
+    3.9742400986142457e-05, 1, -1, 3.1680001831054688e+02,
+    2.0280000305175781e+02, 3.7200000762939453e+01,
+    3.3872167968750000e+02, 1.4901111717335880e-04, 1, -1,
+    3.6960000610351562e+02, 2.0280000305175781e+02,
+    3.7200000762939453e+01, 1.4703912353515625e+02,
+    2.7977154240943491e-04, 1, -1, 4.1040002441406250e+02,
+    2.0280000305175781e+02, 3.7200000762939453e+01,
+    6.3442203521728516e+01, 7.3208058893214911e-05, 1, -1,
+    4.1760000610351562e+02, 2.0280000305175781e+02,
+    3.7200000762939453e+01, 3.5784204101562500e+02,
+    3.2806503440951928e-05, 1, -1, 4.4760000610351562e+02,
+    2.0280000305175781e+02, 3.7200000762939453e+01,
+    1.5080389404296875e+02, 3.3047064789570868e-05, 1, -1,
+    4.5000003051757812e+02, 2.0280000305175781e+02,
+    3.7200000762939453e+01, 1.4613812255859375e+02,
+    2.1570223907474428e-05, 1, -1, 1.7040000915527344e+02,
+    2.0400001525878906e+02, 3.7200000762939453e+01,
+    2.3630535888671875e+02, 6.7757791839540005e-05, 1, -1,
+    2.1120001220703125e+02, 2.0400001525878906e+02,
+    3.7200000762939453e+01, 6.5806785583496094e+01,
+    4.2917301470879465e-05, 1, -1, 2.2080000305175781e+02,
+    2.0400001525878906e+02, 3.7200000762939453e+01,
+    5.9227378845214844e+01, 5.5416318355128169e-04, 1, -1,
+    2.3520001220703125e+02, 2.0400001525878906e+02,
+    3.7200000762939453e+01, 5.3206611633300781e+01,
+    7.2794398874975741e-05, 1, -1, 2.4240000915527344e+02,
+    2.0400001525878906e+02, 3.7200000762939453e+01,
+    3.7130489349365234e+01, 1.1099364928668365e-04, 1, -1,
+    2.5680001831054688e+02, 2.0400001525878906e+02,
+    3.7200000762939453e+01, 2.1337544250488281e+02,
+    4.7274988901335746e-05, 1, -1, 2.8080001831054688e+02,
+    2.0400001525878906e+02, 3.7200000762939453e+01,
+    1.7349513244628906e+02, 8.1063180914497934e-06, 1, -1,
+    3.2760000610351562e+02, 2.0400001525878906e+02,
+    3.7200000762939453e+01, 5.5273618698120117e+00,
+    1.0937893966911361e-04, 1, -1, 3.8880001831054688e+02,
+    2.0400001525878906e+02, 3.7200000762939453e+01,
+    1.1234609985351562e+02, 3.1954000587575138e-04, 1, -1,
+    3.9840002441406250e+02, 2.0400001525878906e+02,
+    3.7200000762939453e+01, 1.2656072235107422e+02,
+    2.1619026665575802e-04, 1, -1, 4.1280001831054688e+02,
+    2.0400001525878906e+02, 3.7200000762939453e+01,
+    3.4463947296142578e+01, 5.6398192100459710e-05, 1, -1,
+    4.1520001220703125e+02, 2.0400001525878906e+02,
+    3.7200000762939453e+01, 1.5124208450317383e+01,
+    6.0479731473606080e-05, 1, -1, 4.5360000610351562e+02,
+    2.0400001525878906e+02, 3.7200000762939453e+01,
+    1.4173645019531250e+02, 9.5093664640444331e-06, 1, -1,
+    4.5960000610351562e+02, 2.0400001525878906e+02,
+    3.7200000762939453e+01, 1.6985870361328125e+02,
+    1.6956100807874463e-05, 1, -1, 1.6680000305175781e+02,
+    2.0520001220703125e+02, 3.7200000762939453e+01,
+    2.3981559753417969e+02, 1.0775774717330933e-04, 1, -1,
+    2.0280000305175781e+02, 2.0520001220703125e+02,
+    3.7200000762939453e+01, 1.5903053283691406e+02,
+    3.8861478969920427e-05, 1, -1, 2.4600001525878906e+02,
+    2.0520001220703125e+02, 3.7200000762939453e+01,
+    1.4690934753417969e+02, 2.9582281058537774e-05, 1, -1,
+    2.4840000915527344e+02, 2.0520001220703125e+02,
+    3.7200000762939453e+01, 2.0265295410156250e+02,
+    2.1660014681401663e-05, 1, -1, 2.5080000305175781e+02,
+    2.0520001220703125e+02, 3.7200000762939453e+01,
+    2.0770246887207031e+02, 3.2481064408784732e-05, 1, -1,
+    3.4920001220703125e+02, 2.0520001220703125e+02,
+    3.7200000762939453e+01, 3.0343304443359375e+02,
+    2.1037993064965121e-05, 1, -1, 3.6240002441406250e+02,
+    2.0520001220703125e+02, 3.7200000762939453e+01,
+    1.8615701293945312e+02, 9.5749499450903386e-05, 1, -1,
+    3.9600003051757812e+02, 2.0520001220703125e+02,
+    3.7200000762939453e+01, 1.2598695373535156e+02,
+    3.0695527675561607e-04, 1, -1, 4.0320001220703125e+02,
+    2.0520001220703125e+02, 3.7200000762939453e+01,
+    1.2412492370605469e+02, 2.0564475562423468e-04, 1, -1,
+    1.6440000915527344e+02, 2.0640000915527344e+02,
+    3.7200000762939453e+01, 2.3889068603515625e+02,
+    9.3763897893950343e-05, 1, -1, 2.1480000305175781e+02,
+    2.0640000915527344e+02, 3.7200000762939453e+01,
+    5.8081436157226562e+01, 2.0368336117826402e-04, 1, -1,
+    2.6640002441406250e+02, 2.0640000915527344e+02,
+    3.7200000762939453e+01, 2.1880931091308594e+02,
+    4.9962417688220739e-04, 1, -1, 270., 2.0640000915527344e+02,
+    3.7200000762939453e+01, 2.1073931884765625e+02,
+    2.4676986504346132e-04, 1, -1, 2.8560000610351562e+02,
+    2.0640000915527344e+02, 3.7200000762939453e+01,
+    1.6226759338378906e+02, 9.9521630545496009e-06, 1, -1,
+    3.3480001831054688e+02, 2.0640000915527344e+02,
+    3.7200000762939453e+01, 3.4808352661132812e+02,
+    3.7991449062246829e-05, 1, -1, 3.4320001220703125e+02,
+    2.0640000915527344e+02, 3.7200000762939453e+01,
+    3.3356362915039062e+02, 8.6012532847234979e-06, 1, -1, 354.,
+    2.0640000915527344e+02, 3.7200000762939453e+01,
+    2.3395335388183594e+02, 1.0119540820596740e-04, 1, -1,
+    3.7080001831054688e+02, 2.0640000915527344e+02,
+    3.7200000762939453e+01, 1.4295545959472656e+02,
+    2.2638366499450058e-04, 1, -1, 384., 2.0640000915527344e+02,
+    3.7200000762939453e+01, 9.5244888305664062e+01,
+    3.4857157152146101e-04, 1, -1, 4.5840002441406250e+02,
+    2.0640000915527344e+02, 3.7200000762939453e+01,
+    1.6155020141601562e+02, 1.7098702301154844e-05, 1, -1,
+    2.2440000915527344e+02, 2.0760000610351562e+02,
+    3.7200000762939453e+01, 6.1133106231689453e+01,
+    6.4863234001677483e-05, 1, -1, 2.2680000305175781e+02,
+    2.0760000610351562e+02, 3.7200000762939453e+01,
+    6.5046081542968750e+01, 1.6980291547952220e-05, 1, -1,
+    2.3280000305175781e+02, 2.0760000610351562e+02,
+    3.7200000762939453e+01, 6.6985496520996094e+01,
+    2.2617698050453328e-05, 1, -1, 2.4480000305175781e+02,
+    2.0760000610351562e+02, 3.7200000762939453e+01,
+    1.0990415191650391e+02, 2.1130927052581683e-05, 1, -1,
+    2.6160000610351562e+02, 2.0760000610351562e+02,
+    3.7200000762939453e+01, 2.1658207702636719e+02,
+    7.5362164352554828e-05, 1, -1, 3.2160000610351562e+02,
+    2.0760000610351562e+02, 3.7200000762939453e+01,
+    1.9389842748641968e+00, 2.6388699188828468e-04, 1, -1,
+    3.2880001831054688e+02, 2.0760000610351562e+02,
+    3.7200000762939453e+01, 3.5651843261718750e+02,
+    3.5756287979893386e-04, 1, -1, 3.6120001220703125e+02,
+    2.0760000610351562e+02, 3.7200000762939453e+01,
+    2.2310549926757812e+02, 1.3190935715101659e-04, 1, -1,
+    3.9120001220703125e+02, 2.0760000610351562e+02,
+    3.7200000762939453e+01, 1.2265565490722656e+02,
+    3.0886186868883669e-04, 1, -1, 4.1760000610351562e+02,
+    2.0760000610351562e+02, 3.7200000762939453e+01,
+    2.5360954284667969e+01, 9.6585708888596855e-06, 1, -1,
+    1.5960000610351562e+02, 2.0880000305175781e+02,
+    3.7200000762939453e+01, 2.3334426879882812e+02,
+    3.0097331546130590e-05, 1, -1, 1.7880000305175781e+02,
+    2.0880000305175781e+02, 3.7200000762939453e+01,
+    1.8465396881103516e+01, 2.4975179258035496e-06, 1, -1,
+    1.9680000305175781e+02, 2.0880000305175781e+02,
+    3.7200000762939453e+01, 1.7360644531250000e+02,
+    1.1067080777138472e-05, 1, -1, 2.7960000610351562e+02,
+    2.0880000305175781e+02, 3.7200000762939453e+01,
+    1.8739562988281250e+02, 2.4399994799750857e-05, 1, -1,
+    2.9160000610351562e+02, 2.0880000305175781e+02,
+    3.7200000762939453e+01, 1.4773561096191406e+02,
+    3.8705788028892130e-05, 1, -1, 324., 2.0880000305175781e+02,
+    3.7200000762939453e+01, 9.9864492416381836e+00,
+    3.2099502277560532e-04, 1, -1, 3.6840002441406250e+02,
+    2.0880000305175781e+02, 3.7200000762939453e+01,
+    2.2480169677734375e+02, 2.1097283752169460e-04, 1, -1,
+    3.9600003051757812e+02, 2.0880000305175781e+02,
+    3.7200000762939453e+01, 1.3837394714355469e+02,
+    2.1380928228609264e-04, 1, -1, 4.5480001831054688e+02,
+    2.0880000305175781e+02, 3.7200000762939453e+01,
+    1.6120681762695312e+02, 2.2544918465428054e-05, 1, -1,
+    4.5720001220703125e+02, 2.0880000305175781e+02,
+    3.7200000762939453e+01, 1.6406533813476562e+02,
+    1.9770437575061806e-05, 1, -1, 4.5960000610351562e+02,
+    2.0880000305175781e+02, 3.7200000762939453e+01,
+    1.7270632934570312e+02, 1.0140423000848386e-05, 1, -1,
+    1.5720001220703125e+02, 2.1000001525878906e+02,
+    3.7200000762939453e+01, 2.2723391723632812e+02,
+    1.4824576282990165e-05, 1, -1, 1.7040000915527344e+02,
+    2.1000001525878906e+02, 3.7200000762939453e+01,
+    2.8098880004882812e+02, 1.0930897587968502e-05, 1, -1,
+    1.9080000305175781e+02, 2.1000001525878906e+02,
+    3.7200000762939453e+01, 1.8478511047363281e+02,
+    -8.8647072971070884e-07, 1, -1, 2.1000001525878906e+02,
+    2.1000001525878906e+02, 3.7200000762939453e+01,
+    5.3580360412597656e+01, 6.4192258287221193e-04, 1, -1,
+    2.8680001831054688e+02, 2.1000001525878906e+02,
+    3.7200000762939453e+01, 1.5868969726562500e+02,
+    2.8711712730000727e-05, 1, -1, 294., 2.1000001525878906e+02,
+    3.7200000762939453e+01, 1.2401502990722656e+02,
+    3.4989545383723453e-05, 1, -1, 3.0480001831054688e+02,
+    2.1000001525878906e+02, 3.7200000762939453e+01,
+    3.3713760375976562e+01, 3.0014123694854788e-05, 1, -1,
+    3.1080001831054688e+02, 2.1000001525878906e+02,
+    3.7200000762939453e+01, 2.7178768157958984e+01,
+    1.7180450959131122e-04, 1, -1, 3.2040002441406250e+02,
+    2.1000001525878906e+02, 3.7200000762939453e+01,
+    2.1281211853027344e+01, 2.6175525272265077e-04, 1, -1,
+    3.2760000610351562e+02, 2.1000001525878906e+02,
+    3.7200000762939453e+01, 9.2646818161010742e+00,
+    6.6766282543540001e-04, 1, -1, 354., 2.1000001525878906e+02,
+    3.7200000762939453e+01, 2.3631091308593750e+02,
+    3.2102281693369150e-05, 1, -1, 3.7080001831054688e+02,
+    2.1000001525878906e+02, 3.7200000762939453e+01,
+    2.5293444824218750e+02, 1.9100961799267679e-04, 1, -1,
+    3.7320001220703125e+02, 2.1000001525878906e+02,
+    3.7200000762939453e+01, 2.7248556518554688e+02,
+    1.9901861378457397e-04, 1, -1, 4.0320001220703125e+02,
+    2.1000001525878906e+02, 3.7200000762939453e+01,
+    1.4140141296386719e+02, 1.4949032629374415e-04, 1, -1,
+    4.4520001220703125e+02, 2.1000001525878906e+02,
+    3.7200000762939453e+01, 1.8001582336425781e+02,
+    9.6541025413898751e-06, 1, -1, 1.9680000305175781e+02,
+    2.1120001220703125e+02, 3.7200000762939453e+01,
+    1.5567816162109375e+02, 1.6034593500080518e-05, 1, -1,
+    2.0280000305175781e+02, 2.1120001220703125e+02,
+    3.7200000762939453e+01, 7.4181640625000000e+01,
+    4.8006597353378311e-05, 1, -1, 3.1440002441406250e+02,
+    2.1120001220703125e+02, 3.7200000762939453e+01,
+    3.2056892395019531e+01, 1.3860834587831050e-04, 1, -1,
+    3.3240002441406250e+02, 2.1120001220703125e+02,
+    3.7200000762939453e+01, 6.8451719284057617e+00,
+    3.1672036857344210e-04, 1, -1, 3.5880001831054688e+02,
+    2.1120001220703125e+02, 3.7200000762939453e+01,
+    2.2666529846191406e+02, 1.7225242118001916e-05, 1, -1,
+    3.7920001220703125e+02, 2.1120001220703125e+02,
+    3.7200000762939453e+01, 8.6420249938964844e+00,
+    1.0975296027027071e-04, 1, -1, 2.6280001831054688e+02,
+    2.1240000915527344e+02, 3.7200000762939453e+01,
+    1.6170698547363281e+02, 7.9838850069791079e-05, 1, -1, 282.,
+    2.1240000915527344e+02, 3.7200000762939453e+01,
+    1.8041255187988281e+02, 3.9163551264209673e-05, 1, -1,
+    3.3960000610351562e+02, 2.1240000915527344e+02,
+    3.7200000762939453e+01, 4.1339254379272461e+00,
+    3.3466298191342503e-05, 1, -1, 3.4560000610351562e+02,
+    2.1240000915527344e+02, 3.7200000762939453e+01,
+    3.3753033447265625e+02, 1.5936018826323561e-05, 1, -1,
+    3.6240002441406250e+02, 2.1240000915527344e+02,
+    3.7200000762939453e+01, 2.2647680664062500e+02,
+    6.3041006796993315e-05, 1, -1, 3.6720001220703125e+02,
+    2.1240000915527344e+02, 3.7200000762939453e+01,
+    2.3432865905761719e+02, 2.2032079868949950e-04, 1, -1,
+    4.1040002441406250e+02, 2.1240000915527344e+02,
+    3.7200000762939453e+01, 1.0584098815917969e+02,
+    8.7131047621369362e-05, 1, -1, 4.0560000610351562e+02,
+    2.1360000610351562e+02, 3.7200000762939453e+01,
+    1.5809022521972656e+02, 1.7539945838507265e-04, 1, -1,
+    2.0280000305175781e+02, 2.1480000305175781e+02,
+    3.7200000762939453e+01, 5.5656986236572266e+01,
+    6.3399798818863928e-05, 1, -1, 2.1000001525878906e+02,
+    2.1480000305175781e+02, 3.7200000762939453e+01,
+    4.6657039642333984e+01, 3.3722547232173383e-04, 1, -1,
+    2.2440000915527344e+02, 2.1480000305175781e+02,
+    3.7200000762939453e+01, 5.7336933135986328e+01,
+    5.9671292547136545e-06, 1, -1, 2.4960000610351562e+02,
+    2.1480000305175781e+02, 3.7200000762939453e+01,
+    1.2081367492675781e+02, 4.4412659008230548e-06, 1, -1,
+    2.9160000610351562e+02, 2.1480000305175781e+02,
+    3.7200000762939453e+01, 1.2014104461669922e+02,
+    2.4324159312527627e-05, 1, -1, 3.3120001220703125e+02,
+    2.1480000305175781e+02, 3.7200000762939453e+01,
+    4.2032863616943359e+01, 3.5437039332464337e-04, 1, -1,
+    3.8280001831054688e+02, 2.1480000305175781e+02,
+    3.7200000762939453e+01, 1.0834565162658691e+01,
+    2.5174531401717104e-05, 1, -1, 4.5120001220703125e+02,
+    2.1480000305175781e+02, 3.7200000762939453e+01,
+    1.9159255981445312e+02, 1.3298439444042742e-04, 1, -1,
+    1.5480000305175781e+02, 2.1600001525878906e+02,
+    3.7200000762939453e+01, 2.2856294250488281e+02,
+    1.5544439520454034e-05, 1, -1, 1.8480000305175781e+02,
+    2.1600001525878906e+02, 3.7200000762939453e+01,
+    1.9344380187988281e+02, 8.5822994151385501e-06, 1, -1,
+    2.0520001220703125e+02, 2.1600001525878906e+02,
+    3.7200000762939453e+01, 4.7867275238037109e+01,
+    1.6733715892769396e-04, 1, -1, 2.6040002441406250e+02,
+    2.1600001525878906e+02, 3.7200000762939453e+01,
+    1.3948812866210938e+02, 3.3064177841879427e-05, 1, -1, 264.,
+    2.1600001525878906e+02, 3.7200000762939453e+01,
+    1.4374523925781250e+02, 5.2521631005220115e-05, 1, -1,
+    2.6880001831054688e+02, 2.1600001525878906e+02,
+    3.7200000762939453e+01, 1.5486837768554688e+02,
+    2.6985873773810454e-05, 1, -1, 2.8320001220703125e+02,
+    2.1600001525878906e+02, 3.7200000762939453e+01,
+    1.5305783081054688e+02, 6.8934037699364126e-05, 1, -1,
+    3.0120001220703125e+02, 2.1600001525878906e+02,
+    3.7200000762939453e+01, 6.2839576721191406e+01,
+    1.9618631995399483e-05, 1, -1, 3.7080001831054688e+02,
+    2.1600001525878906e+02, 3.7200000762939453e+01,
+    4.1233528137207031e+01, 1.9538891501724720e-04, 1, -1,
+    3.7320001220703125e+02, 2.1600001525878906e+02,
+    3.7200000762939453e+01, 1.6289802551269531e+01,
+    1.2490135850384831e-04, 1, -1, 4.0560000610351562e+02,
+    2.1600001525878906e+02, 3.7200000762939453e+01,
+    1.7215330505371094e+02, 2.6637740666046739e-04, 1, -1,
+    4.1160000610351562e+02, 2.1600001525878906e+02,
+    3.7200000762939453e+01, 7.7453636169433594e+01,
+    6.0991256759734824e-05, 1, -1, 4.4760000610351562e+02,
+    2.1600001525878906e+02, 3.7200000762939453e+01,
+    2.0344015502929688e+02, 7.8140597906894982e-05, 1, -1,
+    4.5480001831054688e+02, 2.1600001525878906e+02,
+    3.7200000762939453e+01, 1.9943321228027344e+02,
+    7.0263442466966808e-05, 1, -1, 1.6440000915527344e+02,
+    2.1720001220703125e+02, 3.7200000762939453e+01,
+    2.6066308593750000e+02, 5.4419782827608287e-05, 1, -1,
+    1.6680000305175781e+02, 2.1720001220703125e+02,
+    3.7200000762939453e+01, 2.7874264526367188e+02,
+    1.2011732906103134e-04, 1, -1, 2.5680001831054688e+02,
+    2.1720001220703125e+02, 3.7200000762939453e+01,
+    1.3150212097167969e+02, 1.4752497918379959e-05, 1, -1,
+    2.9040002441406250e+02, 2.1720001220703125e+02,
+    3.7200000762939453e+01, 1.1476541900634766e+02,
+    5.8853776863543317e-05, 1, -1, 3.8160000610351562e+02,
+    2.1720001220703125e+02, 3.7200000762939453e+01,
+    3.4083270263671875e+02, 4.2747353290906176e-05, 1, -1,
+    2.0640000915527344e+02, 2.1840000915527344e+02,
+    3.7200000762939453e+01, 4.0351043701171875e+01,
+    2.7296252665109932e-04, 1, -1, 2.8440002441406250e+02,
+    2.1840000915527344e+02, 3.7200000762939453e+01,
+    1.4378514099121094e+02, 1.2911031080875546e-04, 1, -1,
+    3.0120001220703125e+02, 2.1840000915527344e+02,
+    3.7200000762939453e+01, 6.3324714660644531e+01,
+    2.6488241928745992e-05, 1, -1, 318., 2.1840000915527344e+02,
+    3.7200000762939453e+01, 6.4609291076660156e+01,
+    1.5901285223662853e-05, 1, -1, 3.4680001831054688e+02,
+    2.1840000915527344e+02, 3.7200000762939453e+01,
+    7.5894744873046875e+01, -9.4169417934608646e-06, 1, -1, 378.,
+    2.1840000915527344e+02, 3.7200000762939453e+01,
+    1.2889903068542480e+01, 1.7066876171156764e-04, 1, -1,
+    3.9000003051757812e+02, 2.1840000915527344e+02,
+    3.7200000762939453e+01, 1.9593699645996094e+02,
+    2.4378221496590413e-05, 1, -1, 4.0680001831054688e+02,
+    2.1840000915527344e+02, 3.7200000762939453e+01,
+    1.5521076965332031e+02, 3.0174196581356227e-04, 1, -1,
+    4.5000003051757812e+02, 2.1840000915527344e+02,
+    3.7200000762939453e+01, 2.1830876159667969e+02,
+    7.4090588896069676e-05, 1, -1, 4.5360000610351562e+02,
+    2.1840000915527344e+02, 3.7200000762939453e+01,
+    2.0972654724121094e+02, 2.9585651645902544e-05, 1, -1, 168.,
+    2.1960000610351562e+02, 3.7200000762939453e+01,
+    2.9681866455078125e+02, 1.9653167692013085e-04, 1, -1,
+    2.7480001831054688e+02, 2.1960000610351562e+02,
+    3.7200000762939453e+01, 1.7627238464355469e+02,
+    2.0894593035336584e-05, 1, -1, 3.9600003051757812e+02,
+    2.1960000610351562e+02, 3.7200000762939453e+01,
+    1.8659851074218750e+02, 1.9824430637527257e-04, 1, -1,
+    4.0440002441406250e+02, 2.1960000610351562e+02,
+    3.7200000762939453e+01, 1.7106842041015625e+02,
+    3.7342502037063241e-04, 1, -1, 4.0920001220703125e+02,
+    2.1960000610351562e+02, 3.7200000762939453e+01,
+    1.2064910125732422e+02, 1.3463958748616278e-04, 1, -1,
+    1.5960000610351562e+02, 2.2080000305175781e+02,
+    3.7200000762939453e+01, 2.3568911743164062e+02,
+    2.2534077288582921e-05, 1, -1, 174., 2.2080000305175781e+02,
+    3.7200000762939453e+01, 3.3171499633789062e+02,
+    2.1063988242531195e-05, 1, -1, 2.0520001220703125e+02,
+    2.2080000305175781e+02, 3.7200000762939453e+01,
+    3.6790996551513672e+01, 3.6851706681773067e-04, 1, -1, 270.,
+    2.2080000305175781e+02, 3.7200000762939453e+01,
+    1.7311763000488281e+02, 1.9532646547304466e-05, 1, -1,
+    2.7240002441406250e+02, 2.2080000305175781e+02,
+    3.7200000762939453e+01, 1.7855021667480469e+02,
+    2.7409134418121539e-05, 1, -1, 282., 2.2080000305175781e+02,
+    3.7200000762939453e+01, 1.7676684570312500e+02,
+    7.6146185165271163e-05, 1, -1, 2.8560000610351562e+02,
+    2.2080000305175781e+02, 3.7200000762939453e+01,
+    1.5078997802734375e+02, 8.2892336649820209e-05, 1, -1,
+    3.0840002441406250e+02, 2.2080000305175781e+02,
+    3.7200000762939453e+01, 5.7623538970947266e+01,
+    2.6633470042725094e-05, 1, -1, 3.1440002441406250e+02,
+    2.2080000305175781e+02, 3.7200000762939453e+01,
+    6.3501983642578125e+01, 9.3421094788936898e-06, 1, -1,
+    4.0680001831054688e+02, 2.2080000305175781e+02,
+    3.7200000762939453e+01, 1.5404277038574219e+02,
+    2.7048663469031453e-04, 1, -1, 150., 2.2200001525878906e+02,
+    3.7200000762939453e+01, 2.0616589355468750e+02,
+    3.1172901799436659e-05, 1, -1, 1.9320001220703125e+02,
+    2.2200001525878906e+02, 3.7200000762939453e+01,
+    1.2640234375000000e+02, 3.6397534131538123e-05, 1, -1,
+    2.0280000305175781e+02, 2.2200001525878906e+02,
+    3.7200000762939453e+01, 4.1565822601318359e+01,
+    3.0449047335423529e-04, 1, -1, 2.7720001220703125e+02,
+    2.2200001525878906e+02, 3.7200000762939453e+01,
+    1.8973934936523438e+02, 3.8338923332048580e-05, 1, -1,
+    2.8920001220703125e+02, 2.2200001525878906e+02,
+    3.7200000762939453e+01, 1.0527791595458984e+02,
+    5.8667221310315654e-05, 1, -1, 294., 2.2200001525878906e+02,
+    3.7200000762939453e+01, 6.6040679931640625e+01,
+    1.0355519407312386e-05, 1, -1, 3.2160000610351562e+02,
+    2.2200001525878906e+02, 3.7200000762939453e+01,
+    4.1464172363281250e+01, 6.7968899202242028e-06, 1, -1,
+    3.3120001220703125e+02, 2.2200001525878906e+02,
+    3.7200000762939453e+01, 4.9543109893798828e+01,
+    8.4469020293909125e-06, 1, -1, 3.5880001831054688e+02,
+    2.2200001525878906e+02, 3.7200000762939453e+01,
+    1.1528662109375000e+02, -2.5857536456896923e-05, 1, -1, 366.,
+    2.2200001525878906e+02, 3.7200000762939453e+01,
+    1.0572984313964844e+02, 4.2450301407370716e-05, 1, -1,
+    3.6960000610351562e+02, 2.2200001525878906e+02,
+    3.7200000762939453e+01, 1.0001018524169922e+02,
+    6.5997875935863703e-05, 1, -1, 3.7320001220703125e+02,
+    2.2200001525878906e+02, 3.7200000762939453e+01,
+    9.1934898376464844e+01, 2.6194506062893197e-05, 1, -1,
+    3.8280001831054688e+02, 2.2200001525878906e+02,
+    3.7200000762939453e+01, 7.9288948059082031e+01,
+    1.6707024769857526e-04, 1, -1, 4.0320001220703125e+02,
+    2.2200001525878906e+02, 3.7200000762939453e+01,
+    1.7174563598632812e+02, 3.1733018113300204e-04, 1, -1,
+    4.2600003051757812e+02, 2.2200001525878906e+02,
+    3.7200000762939453e+01, 1.9973040771484375e+02,
+    6.5580206864979118e-06, 1, -1, 4.3680001831054688e+02,
+    2.2200001525878906e+02, 3.7200000762939453e+01,
+    2.0727415466308594e+02, 2.2886542865308002e-05, 1, -1,
+    1.5240000915527344e+02, 2.2320001220703125e+02,
+    3.7200000762939453e+01, 2.0590821838378906e+02,
+    1.6370763478334993e-04, 1, -1, 1.7640000915527344e+02,
+    2.2320001220703125e+02, 3.7200000762939453e+01,
+    3.2567044067382812e+02, 2.7159776436747052e-05, 1, -1,
+    1.8120001220703125e+02, 2.2320001220703125e+02,
+    3.7200000762939453e+01, 3.2396817016601562e+02,
+    4.7426226956304163e-05, 1, -1, 2.5560000610351562e+02,
+    2.2320001220703125e+02, 3.7200000762939453e+01,
+    1.3190861511230469e+02, 3.4804340884875273e-06, 1, -1,
+    2.7360000610351562e+02, 2.2320001220703125e+02,
+    3.7200000762939453e+01, 1.9350570678710938e+02,
+    9.4479277322534472e-05, 1, -1, 3.1920001220703125e+02,
+    2.2320001220703125e+02, 3.7200000762939453e+01,
+    2.2722167968750000e+01, 1.6722658983781002e-05, 1, -1,
+    3.4920001220703125e+02, 2.2320001220703125e+02,
+    3.7200000762939453e+01, 9.6007110595703125e+01,
+    -3.9050162740750238e-05, 1, -1, 3.9720001220703125e+02,
+    2.2320001220703125e+02, 3.7200000762939453e+01,
+    1.7028085327148438e+02, 2.4297593336086720e-04, 1, -1,
+    1.4640000915527344e+02, 2.2440000915527344e+02,
+    3.7200000762939453e+01, 2.0245443725585938e+02,
+    1.3601072168967221e-05, 1, -1, 1.6320001220703125e+02,
+    2.2440000915527344e+02, 3.7200000762939453e+01,
+    2.5976327514648438e+02, 1.7949958419194445e-05, 1, -1,
+    2.6160000610351562e+02, 2.2440000915527344e+02,
+    3.7200000762939453e+01, 1.7129936218261719e+02,
+    8.3520599218900315e-06, 1, -1, 3.5520001220703125e+02,
+    2.2440000915527344e+02, 3.7200000762939453e+01,
+    1.1091204833984375e+02, -2.0207395209581591e-05, 1, -1,
+    3.8160000610351562e+02, 2.2440000915527344e+02,
+    3.7200000762939453e+01, 9.4222671508789062e+01,
+    4.7084264224395156e-05, 1, -1, 3.9480001831054688e+02,
+    2.2440000915527344e+02, 3.7200000762939453e+01,
+    1.7438517761230469e+02, 1.8669824930839241e-04, 1, -1,
+    4.0680001831054688e+02, 2.2440000915527344e+02,
+    3.7200000762939453e+01, 1.4360171508789062e+02,
+    1.2791711196769029e-04, 1, -1, 4.3080001831054688e+02,
+    2.2440000915527344e+02, 3.7200000762939453e+01,
+    2.0371676635742188e+02, 3.9140773878898472e-05, 1, -1,
+    4.3560000610351562e+02, 2.2440000915527344e+02,
+    3.7200000762939453e+01, 2.0463279724121094e+02,
+    7.4870848038699478e-05, 1, -1, 4.4760000610351562e+02,
+    2.2440000915527344e+02, 3.7200000762939453e+01,
+    2.1907504272460938e+02, 2.3903525288915262e-05, 1, -1, 150.,
+    2.2560000610351562e+02, 3.7200000762939453e+01,
+    1.9698312377929688e+02, 1.6877338930498809e-04, 1, -1,
+    1.5360000610351562e+02, 2.2560000610351562e+02,
+    3.7200000762939453e+01, 1.9623937988281250e+02,
+    2.2024048666935414e-04, 1, -1, 192., 2.2560000610351562e+02,
+    3.7200000762939453e+01, 1.0512754058837891e+02,
+    1.6701020285836421e-05, 1, -1, 2.0520001220703125e+02,
+    2.2560000610351562e+02, 3.7200000762939453e+01,
+    1.9961631774902344e+01, 1.6784243052825332e-04, 1, -1,
+    2.1120001220703125e+02, 2.2560000610351562e+02,
+    3.7200000762939453e+01, 3.5776644897460938e+02,
+    8.5903893705108203e-06, 1, -1, 1.5720001220703125e+02,
+    2.2680000305175781e+02, 3.7200000762939453e+01,
+    1.9993876647949219e+02, 9.5782073913142085e-05, 1, -1,
+    1.9920001220703125e+02, 2.2680000305175781e+02,
+    3.7200000762939453e+01, 6.3434322357177734e+01,
+    4.7995730710681528e-05, 1, -1, 2.7240002441406250e+02,
+    2.2680000305175781e+02, 3.7200000762939453e+01,
+    2.1103132629394531e+02, 1.8090535013470799e-04, 1, -1,
+    2.8080001831054688e+02, 2.2680000305175781e+02,
+    3.7200000762939453e+01, 2.4070706176757812e+02,
+    6.7836313974112272e-05, 1, -1, 3.0960000610351562e+02,
+    2.2680000305175781e+02, 3.7200000762939453e+01,
+    3.1561090087890625e+02, 1.5001780411694199e-05, 1, -1,
+    3.1560000610351562e+02, 2.2680000305175781e+02,
+    3.7200000762939453e+01, 2.8979064941406250e+02,
+    3.5397513329371577e-06, 1, -1, 3.9240002441406250e+02,
+    2.2680000305175781e+02, 3.7200000762939453e+01,
+    1.8620884704589844e+02, 1.1234644625801593e-04, 1, -1,
+    4.0800003051757812e+02, 2.2680000305175781e+02,
+    3.7200000762939453e+01, 1.2972763061523438e+02,
+    3.5230194043833762e-05, 1, -1, 4.3560000610351562e+02,
+    2.2680000305175781e+02, 3.7200000762939453e+01,
+    2.0232063293457031e+02, 1.0231105261482298e-04, 1, -1,
+    4.5240002441406250e+02, 2.2680000305175781e+02,
+    3.7200000762939453e+01, 2.0182406616210938e+02,
+    1.2696787052846048e-05, 1, -1, 1.4640000915527344e+02,
+    2.2800001525878906e+02, 3.7200000762939453e+01,
+    2.0129345703125000e+02, 8.2794234913308173e-05, 1, -1,
+    2.0520001220703125e+02, 2.2800001525878906e+02,
+    3.7200000762939453e+01, 1.8458059310913086e+01,
+    5.9069552662549540e-05, 1, -1, 2.9280001831054688e+02,
+    2.2800001525878906e+02, 3.7200000762939453e+01,
+    3.2352764892578125e+02, 6.1960352468304336e-05, 1, -1,
+    3.0480001831054688e+02, 2.2800001525878906e+02,
+    3.7200000762939453e+01, 3.3311596679687500e+02,
+    7.2741609074000735e-06, 1, -1, 324., 2.2800001525878906e+02,
+    3.7200000762939453e+01, 3.0411026000976562e+02,
+    1.8621354911374510e-06, 1, -1, 3.9960000610351562e+02,
+    2.2800001525878906e+02, 3.7200000762939453e+01,
+    1.8597151184082031e+02, 7.3197828896809369e-05, 1, -1,
+    4.2960000610351562e+02, 2.2800001525878906e+02,
+    3.7200000762939453e+01, 2.0133670043945312e+02,
+    3.5752680560108274e-05, 1, -1, 1.4280000305175781e+02,
+    2.2920001220703125e+02, 3.7200000762939453e+01,
+    2.0980752563476562e+02, 3.1072380807017908e-05, 1, -1,
+    2.2800001525878906e+02, 2.2920001220703125e+02,
+    3.7200000762939453e+01, 2.6016592407226562e+02,
+    3.6469969018071424e-06, 1, -1, 2.3280000305175781e+02,
+    2.2920001220703125e+02, 3.7200000762939453e+01,
+    2.6514642333984375e+02, 4.6448740249616094e-06, 1, -1,
+    2.4480000305175781e+02, 2.2920001220703125e+02,
+    3.7200000762939453e+01, 2.9003765869140625e+02,
+    4.9804298214439768e-06, 1, -1, 4.2360000610351562e+02,
+    2.2920001220703125e+02, 3.7200000762939453e+01,
+    1.8237004089355469e+02, 7.9556912169209681e-06, 1, -1,
+    4.3320001220703125e+02, 2.2920001220703125e+02,
+    3.7200000762939453e+01, 2.0068620300292969e+02,
+    8.4174760559108108e-05, 1, -1, 2.0280000305175781e+02,
+    2.3040000915527344e+02, 3.7200000762939453e+01,
+    3.7963607788085938e+01, 5.1458533562254161e-05, 1, -1,
+    2.2080000305175781e+02, 2.3040000915527344e+02,
+    3.7200000762939453e+01, 2.7249963378906250e+02,
+    6.2268109104479663e-06, 1, -1, 2.6760000610351562e+02,
+    2.3040000915527344e+02, 3.7200000762939453e+01,
+    2.1577967834472656e+02, 1.3767604832537472e-04, 1, -1,
+    4.4280001831054688e+02, 2.3040000915527344e+02,
+    3.7200000762939453e+01, 1.8192808532714844e+02,
+    4.3378604459576309e-05, 1, -1, 1.4760000610351562e+02,
+    2.3160000610351562e+02, 3.7200000762939453e+01,
+    2.0341893005371094e+02, 1.3271528587210923e-04, 1, -1,
+    1.5960000610351562e+02, 2.3160000610351562e+02,
+    3.7200000762939453e+01, 1.7271418762207031e+02,
+    1.5564658679068089e-04, 1, -1, 2.0760000610351562e+02,
+    2.3160000610351562e+02, 3.7200000762939453e+01,
+    3.5867196655273438e+02, 4.1442272049607709e-05, 1, -1,
+    4.0200003051757812e+02, 2.3160000610351562e+02,
+    3.7200000762939453e+01, 1.6996154785156250e+02,
+    3.4710625186562538e-04, 1, -1, 4.1280001831054688e+02,
+    2.3160000610351562e+02, 3.7200000762939453e+01,
+    7.2948822021484375e+01, -2.7615763542598870e-07, 1, -1,
+    4.3320001220703125e+02, 2.3160000610351562e+02,
+    3.7200000762939453e+01, 1.9437785339355469e+02,
+    2.9429736969177611e-05, 1, -1, 4.4520001220703125e+02,
+    2.3160000610351562e+02, 3.7200000762939453e+01,
+    1.8384233093261719e+02, 6.9218549469951540e-05, 1, -1,
+    4.4760000610351562e+02, 2.3160000610351562e+02,
+    3.7200000762939453e+01, 1.8776171875000000e+02,
+    5.4910819017095491e-05, 1, -1, 1.7640000915527344e+02,
+    2.3280000305175781e+02, 3.7200000762939453e+01,
+    3.4410198974609375e+02, 6.2493680161423981e-05, 1, -1,
+    2.2560000610351562e+02, 2.3280000305175781e+02,
+    3.7200000762939453e+01, 2.6117639160156250e+02,
+    -3.6901393940524940e-08, 1, -1, 2.7480001831054688e+02,
+    2.3280000305175781e+02, 3.7200000762939453e+01,
+    2.2610089111328125e+02, 4.6631914301542565e-05, 1, -1,
+    3.5520001220703125e+02, 2.3280000305175781e+02,
+    3.7200000762939453e+01, 1.2287976074218750e+02,
+    8.3743924506052281e-07, 1, -1, 3.9720001220703125e+02,
+    2.3280000305175781e+02, 3.7200000762939453e+01,
+    1.7031668090820312e+02, 2.0377566397655755e-04, 1, -1, 144.,
+    2.3400001525878906e+02, 3.7200000762939453e+01,
+    2.1451947021484375e+02, 7.4460316682234406e-05, 1, -1, 180.,
+    2.3400001525878906e+02, 3.7200000762939453e+01,
+    3.4203668212890625e+02, 3.0230166885303333e-05, 1, -1,
+    2.1600001525878906e+02, 2.3400001525878906e+02,
+    3.7200000762939453e+01, 2.8033337402343750e+02,
+    2.0228411813150160e-05, 1, -1, 2.6760000610351562e+02,
+    2.3400001525878906e+02, 3.7200000762939453e+01,
+    2.1629440307617188e+02, 2.7313692044117488e-05, 1, -1,
+    2.7960000610351562e+02, 2.3400001525878906e+02,
+    3.7200000762939453e+01, 2.4656842041015625e+02,
+    2.1705667677451856e-05, 1, -1, 282., 2.3400001525878906e+02,
+    3.7200000762939453e+01, 2.6463735961914062e+02,
+    4.8905010771704838e-05, 1, -1, 294., 2.3400001525878906e+02,
+    3.7200000762939453e+01, 3.0675512695312500e+02,
+    5.3081770602148026e-05, 1, -1, 300., 2.3400001525878906e+02,
+    3.7200000762939453e+01, 3.0231610107421875e+02,
+    8.0373865785077214e-05, 1, -1, 4.1160000610351562e+02,
+    2.3400001525878906e+02, 3.7200000762939453e+01,
+    8.3553688049316406e+01, 2.0971651792933699e-07, 1, -1,
+    4.4280001831054688e+02, 2.3400001525878906e+02,
+    3.7200000762939453e+01, 1.8166738891601562e+02,
+    2.7049052732763812e-05, 1, -1, 4.4640002441406250e+02,
+    2.3400001525878906e+02, 3.7200000762939453e+01,
+    1.8198458862304688e+02, 3.1334380764747038e-05, 1, -1,
+    1.6320001220703125e+02, 2.3520001220703125e+02,
+    3.7200000762939453e+01, 1.3579716491699219e+02,
+    4.7490489669144154e-04, 1, -1, 2.1360000610351562e+02,
+    2.3520001220703125e+02, 3.7200000762939453e+01,
+    2.8935607910156250e+02, 4.1694915125845000e-05, 1, -1,
+    2.8560000610351562e+02, 2.3520001220703125e+02,
+    3.7200000762939453e+01, 2.9020016479492188e+02,
+    3.6175795685267076e-05, 1, -1, 3.0720001220703125e+02,
+    2.3520001220703125e+02, 3.7200000762939453e+01,
+    2.8645886230468750e+02, 1.8117610306944698e-04, 1, -1,
+    4.4880001831054688e+02, 2.3520001220703125e+02,
+    3.7200000762939453e+01, 1.8430715942382812e+02,
+    1.1389392057026271e-05, 1, -1, 1.5960000610351562e+02,
+    2.3640000915527344e+02, 3.7200000762939453e+01,
+    1.4811189270019531e+02, 2.4801440304145217e-04, 1, -1,
+    1.6680000305175781e+02, 2.3640000915527344e+02,
+    3.7200000762939453e+01, 1.1296392822265625e+02,
+    2.2903011995367706e-04, 1, -1, 1.7160000610351562e+02,
+    2.3640000915527344e+02, 3.7200000762939453e+01,
+    7.2901787757873535e+00, 3.0796119244769216e-04, 1, -1,
+    2.1960000610351562e+02, 2.3640000915527344e+02,
+    3.7200000762939453e+01, 2.6215045166015625e+02,
+    1.1572630319278687e-04, 1, -1, 2.6880001831054688e+02,
+    2.3640000915527344e+02, 3.7200000762939453e+01,
+    2.1084968566894531e+02, 5.7048346207011491e-05, 1, -1,
+    1.3680000305175781e+02, 2.3760000610351562e+02,
+    3.7200000762939453e+01, 2.3101283264160156e+02,
+    2.4639377443236299e-05, 1, -1, 1.7640000915527344e+02,
+    2.3760000610351562e+02, 3.7200000762939453e+01,
+    3.4038293457031250e+02, 1.8959108274430037e-04, 1, -1,
+    2.3160000610351562e+02, 2.3760000610351562e+02,
+    3.7200000762939453e+01, 2.5658630371093750e+02,
+    1.0402505722595379e-04, 1, -1, 2.3640000915527344e+02,
+    2.3760000610351562e+02, 3.7200000762939453e+01,
+    2.6851324462890625e+02, 1.5499177607125603e-05, 1, -1,
+    3.3360000610351562e+02, 2.3760000610351562e+02,
+    3.7200000762939453e+01, 3.2522567749023438e+02,
+    6.6916976356878877e-04, 1, -1, 3.9000003051757812e+02,
+    2.3760000610351562e+02, 3.7200000762939453e+01,
+    1.6286915588378906e+02, 7.1909826147020794e-06, 1, -1,
+    4.0080001831054688e+02, 2.3760000610351562e+02,
+    3.7200000762939453e+01, 1.4232263183593750e+02,
+    1.6466205124743283e-04, 1, -1, 4.4760000610351562e+02,
+    2.3760000610351562e+02, 3.7200000762939453e+01,
+    1.8205192565917969e+02, 2.2335842004395090e-05, 1, -1,
+    1.4880000305175781e+02, 2.3880000305175781e+02,
+    3.7200000762939453e+01, 2.1166232299804688e+02,
+    6.3550251070410013e-05, 1, -1, 2.0160000610351562e+02,
+    2.3880000305175781e+02, 3.7200000762939453e+01,
+    3.1230728149414062e+02, 3.9901220588944852e-05, 1, -1,
+    2.0880000305175781e+02, 2.3880000305175781e+02,
+    3.7200000762939453e+01, 3.0074621582031250e+02,
+    2.0027931896038353e-04, 1, -1, 2.2560000610351562e+02,
+    2.3880000305175781e+02, 3.7200000762939453e+01,
+    2.4878424072265625e+02, 3.8772544940002263e-05, 1, -1,
+    2.4480000305175781e+02, 2.3880000305175781e+02,
+    3.7200000762939453e+01, 2.9341250610351562e+02,
+    -2.4443652364425361e-05, 1, -1, 2.9520001220703125e+02,
+    2.3880000305175781e+02, 3.7200000762939453e+01,
+    3.1006497192382812e+02, 1.9286986571387388e-05, 1, -1,
+    2.9880001831054688e+02, 2.3880000305175781e+02,
+    3.7200000762939453e+01, 3.0430038452148438e+02,
+    5.1439561502775177e-05, 1, -1, 3.0120001220703125e+02,
+    2.3880000305175781e+02, 3.7200000762939453e+01,
+    3.0123937988281250e+02, 9.0682442532852292e-05, 1, -1,
+    3.6480001831054688e+02, 2.3880000305175781e+02,
+    3.7200000762939453e+01, 2.3298812866210938e+02,
+    2.3144048464018852e-04, 1, -1, 4.4520001220703125e+02,
+    2.3880000305175781e+02, 3.7200000762939453e+01,
+    1.7641664123535156e+02, 4.3196941987844184e-05, 1, -1,
+    1.4280000305175781e+02, 2.4000001525878906e+02,
+    3.7200000762939453e+01, 2.3901029968261719e+02,
+    3.3891107887029648e-04, 1, -1, 1.5120001220703125e+02,
+    2.4000001525878906e+02, 3.7200000762939453e+01,
+    1.9249331665039062e+02, 4.4858006731374189e-05, 1, -1,
+    1.6080000305175781e+02, 2.4000001525878906e+02,
+    3.7200000762939453e+01, 1.4671047973632812e+02,
+    8.4823695942759514e-05, 1, -1, 1.7160000610351562e+02,
+    2.4000001525878906e+02, 3.7200000762939453e+01,
+    3.2521499633789062e+02, 3.4378262353129685e-04, 1, -1,
+    1.7640000915527344e+02, 2.4000001525878906e+02,
+    3.7200000762939453e+01, 3.2830725097656250e+02,
+    2.2350452491082251e-04, 1, -1, 2.1480000305175781e+02,
+    2.4000001525878906e+02, 3.7200000762939453e+01,
+    2.6537860107421875e+02, 4.6878056309651583e-05, 1, -1,
+    2.6640002441406250e+02, 2.4000001525878906e+02,
+    3.7200000762939453e+01, 2.0320039367675781e+02,
+    7.8758297604508698e-05, 1, -1, 3.6960000610351562e+02,
+    2.4000001525878906e+02, 3.7200000762939453e+01,
+    2.5774990844726562e+02, 7.7908363891765475e-05, 1, -1,
+    3.9960000610351562e+02, 2.4000001525878906e+02,
+    3.7200000762939453e+01, 1.3935980224609375e+02,
+    2.3461629461962730e-04, 1, -1, 1.3920001220703125e+02,
+    2.4120001220703125e+02, 3.7200000762939453e+01,
+    2.3103363037109375e+02, 4.2679600301198661e-04, 1, -1,
+    1.8240000915527344e+02, 2.4120001220703125e+02,
+    3.7200000762939453e+01, 3.2334127807617188e+02,
+    4.4062231609132141e-05, 1, -1, 1.9800001525878906e+02,
+    2.4120001220703125e+02, 3.7200000762939453e+01,
+    3.0827127075195312e+02, 7.6433367212302983e-05, 1, -1,
+    2.0160000610351562e+02, 2.4120001220703125e+02,
+    3.7200000762939453e+01, 3.0450302124023438e+02,
+    4.3853622628375888e-05, 1, -1, 2.0640000915527344e+02,
+    2.4120001220703125e+02, 3.7200000762939453e+01,
+    3.0628732299804688e+02, 1.3490435958374292e-04, 1, -1,
+    2.6040002441406250e+02, 2.4120001220703125e+02,
+    3.7200000762939453e+01, 2.1876449584960938e+02,
+    2.7023685106541961e-05, 1, -1, 3.5160000610351562e+02,
+    2.4120001220703125e+02, 3.7200000762939453e+01,
+    2.6333923339843750e+02, 1.1069971151300706e-05, 1, -1,
+    3.7320001220703125e+02, 2.4120001220703125e+02,
+    3.7200000762939453e+01, 2.7468414306640625e+02,
+    3.0796178180025890e-05, 1, -1, 4.4400003051757812e+02,
+    2.4120001220703125e+02, 3.7200000762939453e+01,
+    1.7466616821289062e+02, 5.2043385949218646e-05, 1, -1,
+    1.3320001220703125e+02, 2.4240000915527344e+02,
+    3.7200000762939453e+01, 2.2387234497070312e+02,
+    1.5578783859382384e-05, 1, -1, 1.4160000610351562e+02,
+    2.4240000915527344e+02, 3.7200000762939453e+01,
+    2.3596969604492188e+02, 4.1212007636204362e-04, 1, -1, 174.,
+    2.4240000915527344e+02, 3.7200000762939453e+01,
+    3.1748348999023438e+02, 3.9934585220180452e-04, 1, -1, 180.,
+    2.4240000915527344e+02, 3.7200000762939453e+01,
+    3.2568344116210938e+02, 1.3215557555668056e-04, 1, -1,
+    1.9440000915527344e+02, 2.4240000915527344e+02,
+    3.7200000762939453e+01, 3.1826931762695312e+02,
+    1.4871814346406609e-04, 1, -1, 2.3280000305175781e+02,
+    2.4240000915527344e+02, 3.7200000762939453e+01,
+    2.4115040588378906e+02, 3.9313286833930761e-05, 1, -1,
+    3.9360000610351562e+02, 2.4240000915527344e+02,
+    3.7200000762939453e+01, 1.6198672485351562e+02,
+    1.6365194460377097e-04, 1, -1, 3.9840002441406250e+02,
+    2.4240000915527344e+02, 3.7200000762939453e+01,
+    1.4814903259277344e+02, 2.1919603750575334e-04, 1, -1,
+    4.3560000610351562e+02, 2.4240000915527344e+02,
+    3.7200000762939453e+01, 1.7302540588378906e+02,
+    8.6191343143582344e-05, 1, -1, 2.1720001220703125e+02,
+    2.4360000610351562e+02, 3.7200000762939453e+01,
+    2.2651280212402344e+02, 2.3081631297827698e-05, 1, -1,
+    2.4600001525878906e+02, 2.4360000610351562e+02,
+    3.7200000762939453e+01, 3.0379437255859375e+02,
+    1.3271890566102229e-05, 1, -1, 3.9120001220703125e+02,
+    2.4360000610351562e+02, 3.7200000762939453e+01,
+    1.8222248840332031e+02, 9.3996728537604213e-05, 1, -1,
+    4.3920001220703125e+02, 2.4360000610351562e+02,
+    3.7200000762939453e+01, 1.7642570495605469e+02,
+    1.6164201952051371e-04, 1, -1, 4.4280001831054688e+02,
+    2.4360000610351562e+02, 3.7200000762939453e+01,
+    1.8264657592773438e+02, 3.6649271351052448e-05, 1, -1,
+    1.3680000305175781e+02, 2.4480000305175781e+02,
+    3.7200000762939453e+01, 2.1852360534667969e+02,
+    2.4667184334248304e-04, 1, -1, 1.4040000915527344e+02,
+    2.4480000305175781e+02, 3.7200000762939453e+01,
+    2.2917700195312500e+02, 3.7140538915991783e-04, 1, -1,
+    1.4880000305175781e+02, 2.4480000305175781e+02,
+    3.7200000762939453e+01, 2.9064428710937500e+02,
+    2.4943379685282707e-05, 1, -1, 1.6920001220703125e+02,
+    2.4480000305175781e+02, 3.7200000762939453e+01,
+    1.7137872314453125e+02, 2.3912699543870986e-04, 1, -1,
+    1.7520001220703125e+02, 2.4480000305175781e+02,
+    3.7200000762939453e+01, 3.2518954467773438e+02,
+    2.7105055050924420e-04, 1, -1, 1.8360000610351562e+02,
+    2.4480000305175781e+02, 3.7200000762939453e+01,
+    3.2175048828125000e+02, 8.6742860730737448e-05, 1, -1,
+    1.9080000305175781e+02, 2.4480000305175781e+02,
+    3.7200000762939453e+01, 3.2271789550781250e+02,
+    1.3804237823933363e-04, 1, -1, 2.0880000305175781e+02,
+    2.4480000305175781e+02, 3.7200000762939453e+01,
+    5.1407108306884766e+00, 1.5937215721351095e-05, 1, -1,
+    2.1960000610351562e+02, 2.4480000305175781e+02,
+    3.7200000762939453e+01, 2.0414097595214844e+02,
+    1.4729175745742396e-05, 1, -1, 2.2680000305175781e+02,
+    2.4480000305175781e+02, 3.7200000762939453e+01,
+    2.1114521789550781e+02, 2.4954897526185960e-05, 1, -1,
+    2.3280000305175781e+02, 2.4480000305175781e+02,
+    3.7200000762939453e+01, 2.2631661987304688e+02,
+    2.9503404221031815e-05, 1, -1, 2.4840000915527344e+02,
+    2.4480000305175781e+02, 3.7200000762939453e+01,
+    3.0197406005859375e+02, 2.9357983294175938e-05, 1, -1,
+    2.5680001831054688e+02, 2.4480000305175781e+02,
+    3.7200000762939453e+01, 2.3551493835449219e+02,
+    1.6686770322849043e-05, 1, -1, 2.6640002441406250e+02,
+    2.4480000305175781e+02, 3.7200000762939453e+01,
+    1.8344190979003906e+02, 7.6128460932523012e-05, 1, -1,
+    3.0480001831054688e+02, 2.4480000305175781e+02,
+    3.7200000762939453e+01, 3.2550970458984375e+02,
+    3.1434331322088838e-04, 1, -1, 354., 2.4480000305175781e+02,
+    3.7200000762939453e+01, 2.5747579956054688e+02,
+    1.3840380415786058e-04, 1, -1, 3.6360000610351562e+02,
+    2.4480000305175781e+02, 3.7200000762939453e+01,
+    2.7172497558593750e+02, 3.3606201759539545e-04, 1, -1,
+    3.7320001220703125e+02, 2.4480000305175781e+02,
+    3.7200000762939453e+01, 2.7940386962890625e+02,
+    2.1317564824130386e-04, 1, -1, 1.3080000305175781e+02,
+    2.4600001525878906e+02, 3.7200000762939453e+01,
+    1.8772550964355469e+02, -3.2570280836807797e-06, 1, -1,
+    1.3320001220703125e+02, 2.4600001525878906e+02,
+    3.7200000762939453e+01, 1.9850880432128906e+02,
+    2.3079166567185894e-05, 1, -1, 1.6320001220703125e+02,
+    2.4600001525878906e+02, 3.7200000762939453e+01,
+    1.5920291137695312e+02, 1.1925561557291076e-04, 1, -1,
+    1.7280000305175781e+02, 2.4600001525878906e+02,
+    3.7200000762939453e+01, 3.3978338623046875e+02,
+    2.7143888291902840e-04, 1, -1, 1.7880000305175781e+02,
+    2.4600001525878906e+02, 3.7200000762939453e+01,
+    3.2768566894531250e+02, 1.0479996853973716e-04, 1, -1,
+    2.2440000915527344e+02, 2.4600001525878906e+02,
+    3.7200000762939453e+01, 1.8599369812011719e+02,
+    1.3997559108247515e-05, 1, -1, 2.4000001525878906e+02,
+    2.4600001525878906e+02, 3.7200000762939453e+01,
+    2.7847229003906250e+02, 3.1134775781538337e-05, 1, -1,
+    2.6040002441406250e+02, 2.4600001525878906e+02,
+    3.7200000762939453e+01, 2.0333229064941406e+02,
+    1.9480638002278283e-05, 1, -1, 2.9280001831054688e+02,
+    2.4600001525878906e+02, 3.7200000762939453e+01,
+    5.2969318389892578e+01, 6.3856408814899623e-05, 1, -1,
+    3.0840002441406250e+02, 2.4600001525878906e+02,
+    3.7200000762939453e+01, 1.3907827758789062e+02,
+    2.1513573301490396e-04, 1, -1, 3.5640002441406250e+02,
+    2.4600001525878906e+02, 3.7200000762939453e+01,
+    2.5801815795898438e+02, 2.1502845629584044e-04, 1, -1,
+    3.6720001220703125e+02, 2.4600001525878906e+02,
+    3.7200000762939453e+01, 2.7645874023437500e+02,
+    2.2216705838218331e-04, 1, -1, 3.6960000610351562e+02,
+    2.4600001525878906e+02, 3.7200000762939453e+01,
+    2.7882763671875000e+02, 2.3601399152539670e-04, 1, -1,
+    4.2960000610351562e+02, 2.4600001525878906e+02,
+    3.7200000762939453e+01, 2.2262205505371094e+02,
+    6.2744134083914105e-06, 1, -1, 4.3560000610351562e+02,
+    2.4600001525878906e+02, 3.7200000762939453e+01,
+    1.9527268981933594e+02, 4.7586050641257316e-05, 1, -1,
+    4.4160000610351562e+02, 2.4600001525878906e+02,
+    3.7200000762939453e+01, 1.8665409851074219e+02,
+    6.5939893829636276e-05, 1, -1, 1.8480000305175781e+02,
+    2.4720001220703125e+02, 3.7200000762939453e+01,
+    3.3060626220703125e+02, 6.4330844907090068e-05, 1, -1,
+    1.9080000305175781e+02, 2.4720001220703125e+02,
+    3.7200000762939453e+01, 3.2734478759765625e+02,
+    6.9300971517805010e-05, 1, -1, 2.3640000915527344e+02,
+    2.4720001220703125e+02, 3.7200000762939453e+01,
+    2.2942303466796875e+02, 3.4392880479572341e-05, 1, -1,
+    2.4360000610351562e+02, 2.4720001220703125e+02,
+    3.7200000762939453e+01, 2.9696487426757812e+02,
+    1.6525182218174450e-05, 1, -1, 2.4840000915527344e+02,
+    2.4720001220703125e+02, 3.7200000762939453e+01,
+    3.0865188598632812e+02, 2.8635060516535304e-05, 1, -1,
+    3.3480001831054688e+02, 2.4720001220703125e+02,
+    3.7200000762939453e+01, 3.2196499633789062e+02,
+    2.9837049078196287e-04, 1, -1, 3.3840002441406250e+02,
+    2.4720001220703125e+02, 3.7200000762939453e+01,
+    3.1381347656250000e+02, 3.1252039480023086e-04, 1, -1,
+    3.4680001831054688e+02, 2.4720001220703125e+02,
+    3.7200000762939453e+01, 2.8740545654296875e+02,
+    1.9964769307989627e-04, 1, -1, 3.5160000610351562e+02,
+    2.4720001220703125e+02, 3.7200000762939453e+01,
+    2.6189373779296875e+02, 2.0311857224442065e-04, 1, -1,
+    3.5880001831054688e+02, 2.4720001220703125e+02,
+    3.7200000762939453e+01, 2.6043148803710938e+02,
+    2.9563173302449286e-04, 1, -1, 3.8040002441406250e+02,
+    2.4720001220703125e+02, 3.7200000762939453e+01,
+    2.8287576293945312e+02, 2.8292916249483824e-04, 1, -1,
+    3.8760000610351562e+02, 2.4720001220703125e+02,
+    3.7200000762939453e+01, 2.5601962280273438e+02,
+    9.6431205747649074e-05, 1, -1, 3.9360000610351562e+02,
+    2.4720001220703125e+02, 3.7200000762939453e+01,
+    2.1945651245117188e+02, 1.2372194032650441e-04, 1, -1,
+    3.9840002441406250e+02, 2.4720001220703125e+02,
+    3.7200000762939453e+01, 2.0891061401367188e+02,
+    4.6078959712758660e-05, 1, -1, 138., 2.4840000915527344e+02,
+    3.7200000762939453e+01, 1.6891717529296875e+02,
+    4.0264255949296057e-04, 1, -1, 1.7520001220703125e+02,
+    2.4840000915527344e+02, 3.7200000762939453e+01,
+    3.3399852752685547e+01, 1.8580369942355901e-04, 1, -1,
+    2.5320001220703125e+02, 2.4840000915527344e+02,
+    3.7200000762939453e+01, 2.7052331542968750e+02,
+    2.4030558051890694e-05, 1, -1, 2.8560000610351562e+02,
+    2.4840000915527344e+02, 3.7200000762939453e+01,
+    8.2077606201171875e+01, 3.7618210626533255e-05, 1, -1,
+    3.1560000610351562e+02, 2.4840000915527344e+02,
+    3.7200000762939453e+01, 1.2959126281738281e+02,
+    2.3457153292838484e-04, 1, -1, 3.5640002441406250e+02,
+    2.4840000915527344e+02, 3.7200000762939453e+01,
+    2.5753063964843750e+02, 2.7331543969921768e-04, 1, -1,
+    3.7320001220703125e+02, 2.4840000915527344e+02,
+    3.7200000762939453e+01, 2.8892138671875000e+02,
+    4.2152241803705692e-04, 1, -1, 3.7560000610351562e+02,
+    2.4840000915527344e+02, 3.7200000762939453e+01,
+    2.8818859863281250e+02, 4.3232410098426044e-04, 1, -1,
+    4.4040002441406250e+02, 2.4840000915527344e+02,
+    3.7200000762939453e+01, 1.9583712768554688e+02,
+    8.4877901826985180e-05, 1, -1, 1.3080000305175781e+02,
+    2.4960000610351562e+02, 3.7200000762939453e+01,
+    1.4420468139648438e+02, 6.8592693423852324e-05, 1, -1,
+    1.5120001220703125e+02, 2.4960000610351562e+02,
+    3.7200000762939453e+01, 8.0883453369140625e+01,
+    3.0226295348256826e-04, 1, -1, 1.7760000610351562e+02,
+    2.4960000610351562e+02, 3.7200000762939453e+01,
+    1.1117566108703613e+01, 7.6851545600220561e-05, 1, -1,
+    2.6880001831054688e+02, 2.4960000610351562e+02,
+    3.7200000762939453e+01, 1.4627261352539062e+02,
+    3.7820536817889661e-05, 1, -1, 3.0360000610351562e+02,
+    2.4960000610351562e+02, 3.7200000762939453e+01,
+    8.2260581970214844e+01, 1.6043132927734405e-04, 1, -1, 342.,
+    2.4960000610351562e+02, 3.7200000762939453e+01,
+    3.0756445312500000e+02, 1.9127366249449551e-04, 1, -1,
+    3.6240002441406250e+02, 2.4960000610351562e+02,
+    3.7200000762939453e+01, 2.7314544677734375e+02,
+    1.8884078599512577e-04, 1, -1, 3.8280001831054688e+02,
+    2.4960000610351562e+02, 3.7200000762939453e+01,
+    2.7854693603515625e+02, 1.3236919767223299e-04, 1, -1,
+    4.3680001831054688e+02, 2.4960000610351562e+02,
+    3.7200000762939453e+01, 2.1534620666503906e+02,
+    3.9111513615353033e-05, 1, -1, 4.4280001831054688e+02,
+    2.4960000610351562e+02, 3.7200000762939453e+01,
+    1.9518292236328125e+02, 1.5576388250337914e-05, 1, -1,
+    1.4160000610351562e+02, 2.5080000305175781e+02,
+    3.7200000762939453e+01, 1.1619255065917969e+02,
+    2.7169610257260501e-04, 1, -1, 1.4880000305175781e+02,
+    2.5080000305175781e+02, 3.7200000762939453e+01,
+    6.8811981201171875e+01, 3.7900567986071110e-04, 1, -1,
+    1.6560000610351562e+02, 2.5080000305175781e+02,
+    3.7200000762939453e+01, 1.2806101989746094e+02,
+    4.2572556412778795e-04, 1, -1, 1.6920001220703125e+02,
+    2.5080000305175781e+02, 3.7200000762939453e+01,
+    1.3039430236816406e+02, 4.3448555516079068e-04, 1, -1,
+    1.7160000610351562e+02, 2.5080000305175781e+02,
+    3.7200000762939453e+01, 1.2050128936767578e+02,
+    1.9774817337747663e-04, 1, -1, 1.8120001220703125e+02,
+    2.5080000305175781e+02, 3.7200000762939453e+01,
+    2.6217136383056641e+00, 2.4969614969450049e-05, 1, -1,
+    2.5920001220703125e+02, 2.5080000305175781e+02,
+    3.7200000762939453e+01, 1.7036907958984375e+02,
+    1.4932775229681283e-05, 1, -1, 2.9160000610351562e+02,
+    2.5080000305175781e+02, 3.7200000762939453e+01,
+    7.5937187194824219e+01, 1.0881829803111032e-04, 1, -1,
+    3.3480001831054688e+02, 2.5080000305175781e+02,
+    3.7200000762939453e+01, 3.4255920410156250e+02,
+    4.3004486360587180e-04, 1, -1, 3.4440002441406250e+02,
+    2.5080000305175781e+02, 3.7200000762939453e+01,
+    2.9523989868164062e+02, 2.8187266434542835e-04, 1, -1,
+    3.5160000610351562e+02, 2.5080000305175781e+02,
+    3.7200000762939453e+01, 2.5819546508789062e+02,
+    1.4219300646800548e-04, 1, -1, 366., 2.5080000305175781e+02,
+    3.7200000762939453e+01, 2.8478237915039062e+02,
+    7.9856778029352427e-05, 1, -1, 3.6960000610351562e+02,
+    2.5080000305175781e+02, 3.7200000762939453e+01,
+    2.9332885742187500e+02, 1.2414243246894330e-04, 1, -1, 378.,
+    2.5080000305175781e+02, 3.7200000762939453e+01,
+    2.9640231323242188e+02, 3.6925388849340379e-04, 1, -1,
+    4.3920001220703125e+02, 2.5080000305175781e+02,
+    3.7200000762939453e+01, 2.0622503662109375e+02,
+    2.8123338779550977e-05, 1, -1, 1.2720000457763672e+02,
+    2.5200001525878906e+02, 3.7200000762939453e+01,
+    1.2485066223144531e+02, 1.2363921268843114e-04, 1, -1,
+    1.3680000305175781e+02, 2.5200001525878906e+02,
+    3.7200000762939453e+01, 1.2734693908691406e+02,
+    4.0100610931403935e-04, 1, -1, 1.9680000305175781e+02,
+    2.5200001525878906e+02, 3.7200000762939453e+01,
+    3.3708477783203125e+02, 1.6938810585997999e-04, 1, -1,
+    2.6880001831054688e+02, 2.5200001525878906e+02,
+    3.7200000762939453e+01, 1.3243365478515625e+02,
+    1.4062811715120915e-05, 1, -1, 3.1440002441406250e+02,
+    2.5200001525878906e+02, 3.7200000762939453e+01,
+    1.0667007446289062e+02, 2.7620613764156587e-05, 1, -1,
+    3.4080001831054688e+02, 2.5200001525878906e+02,
+    3.7200000762939453e+01, 3.1777297973632812e+02,
+    1.1422286479501054e-04, 1, -1, 3.5640002441406250e+02,
+    2.5200001525878906e+02, 3.7200000762939453e+01,
+    2.5607934570312500e+02, 1.6342979506589472e-04, 1, -1,
+    3.5880001831054688e+02, 2.5200001525878906e+02,
+    3.7200000762939453e+01, 2.5988629150390625e+02,
+    1.5815765073057264e-04, 1, -1, 3.8520001220703125e+02,
+    2.5200001525878906e+02, 3.7200000762939453e+01,
+    2.6936032104492188e+02, 9.5014627731870860e-05, 1, -1,
+    4.4160000610351562e+02, 2.5200001525878906e+02,
+    3.7200000762939453e+01, 2.0318072509765625e+02,
+    1.6469160982524045e-05, 1, -1, 132., 2.5320001220703125e+02,
+    3.7200000762939453e+01, 1.2721191406250000e+02,
+    5.8711745077744126e-04, 1, -1, 1.4520001220703125e+02,
+    2.5320001220703125e+02, 3.7200000762939453e+01,
+    8.7308723449707031e+01, 4.6640401706099510e-04, 1, -1,
+    1.5720001220703125e+02, 2.5320001220703125e+02,
+    3.7200000762939453e+01, 1.1416414642333984e+02,
+    1.2697068086708896e-05, 1, -1, 168., 2.5320001220703125e+02,
+    3.7200000762939453e+01, 1.1952445220947266e+02,
+    1.9636197248473763e-04, 1, -1, 1.7280000305175781e+02,
+    2.5320001220703125e+02, 3.7200000762939453e+01,
+    1.0964286041259766e+02, 5.8457055274629965e-05, 1, -1, 192.,
+    2.5320001220703125e+02, 3.7200000762939453e+01,
+    3.4624554443359375e+02, 1.9272320787422359e-04, 1, -1,
+    2.8080001831054688e+02, 2.5320001220703125e+02,
+    3.7200000762939453e+01, 9.7295989990234375e+01,
+    2.5743065634742379e-05, 1, -1, 318., 2.5320001220703125e+02,
+    3.7200000762939453e+01, 1.0875688171386719e+02,
+    3.0503442394547164e-04, 1, -1, 3.2160000610351562e+02,
+    2.5320001220703125e+02, 3.7200000762939453e+01,
+    1.0330480957031250e+02, 2.5692934286780655e-04, 1, -1,
+    3.2760000610351562e+02, 2.5320001220703125e+02,
+    3.7200000762939453e+01, 7.0349670410156250e+01,
+    1.0833296255441383e-04, 1, -1, 3.3480001831054688e+02,
+    2.5320001220703125e+02, 3.7200000762939453e+01,
+    1.2943994522094727e+01, 2.7184892678633332e-04, 1, -1,
+    4.2480001831054688e+02, 2.5320001220703125e+02,
+    3.7200000762939453e+01, 2.3798492431640625e+02,
+    1.6444786524516530e-05, 1, -1, 1.5120001220703125e+02,
+    2.5440000915527344e+02, 3.7200000762939453e+01,
+    8.8575576782226562e+01, 3.3712477306835353e-04, 1, -1, 288.,
+    2.5440000915527344e+02, 3.7200000762939453e+01,
+    8.8146247863769531e+01, 2.4638349714223295e-05, 1, -1,
+    3.7080001831054688e+02, 2.5440000915527344e+02,
+    3.7200000762939453e+01, 3.1794973754882812e+02,
+    8.0756071838550270e-05, 1, -1, 4.0320001220703125e+02,
+    2.5440000915527344e+02, 3.7200000762939453e+01,
+    2.3747581481933594e+02, 3.0607418011641130e-05, 1, -1,
+    4.1400003051757812e+02, 2.5440000915527344e+02,
+    3.7200000762939453e+01, 2.3695690917968750e+02,
+    2.2428594093071297e-05, 1, -1, 4.2720001220703125e+02,
+    2.5440000915527344e+02, 3.7200000762939453e+01,
+    2.4713076782226562e+02, 1.0566566743364092e-05, 1, -1, 132.,
+    2.5560000610351562e+02, 3.7200000762939453e+01,
+    1.2074115753173828e+02, 3.0811270698904991e-04, 1, -1,
+    1.3680000305175781e+02, 2.5560000610351562e+02,
+    3.7200000762939453e+01, 1.1432164001464844e+02,
+    1.8151922267861664e-04, 1, -1, 1.6320001220703125e+02,
+    2.5560000610351562e+02, 3.7200000762939453e+01,
+    1.0870623779296875e+02, 3.4827433410100639e-05, 1, -1,
+    1.8360000610351562e+02, 2.5560000610351562e+02,
+    3.7200000762939453e+01, 6.4912139892578125e+01,
+    1.0048984404420480e-04, 1, -1, 1.9680000305175781e+02,
+    2.5560000610351562e+02, 3.7200000762939453e+01,
+    1.0560900688171387e+01, 2.6848199195228517e-04, 1, -1,
+    2.9880001831054688e+02, 2.5560000610351562e+02,
+    3.7200000762939453e+01, 7.3851676940917969e+01,
+    3.0203931601135992e-05, 1, -1, 360., 2.5560000610351562e+02,
+    3.7200000762939453e+01, 2.6257781982421875e+02,
+    6.4734580519143492e-05, 1, -1, 3.7440002441406250e+02,
+    2.5560000610351562e+02, 3.7200000762939453e+01,
+    3.1818978881835938e+02, 6.7110799136571586e-05, 1, -1,
+    4.1880001831054688e+02, 2.5560000610351562e+02,
+    3.7200000762939453e+01, 2.3900349426269531e+02,
+    1.2541809701360762e-04, 1, -1, 1.2360000610351562e+02,
+    2.5680001831054688e+02, 3.7200000762939453e+01,
+    1.0503186798095703e+02, 1.7240459783351980e-05, 1, -1,
+    1.4520001220703125e+02, 2.5680001831054688e+02,
+    3.7200000762939453e+01, 9.0769966125488281e+01,
+    4.4878249173052609e-04, 1, -1, 1.4880000305175781e+02,
+    2.5680001831054688e+02, 3.7200000762939453e+01,
+    8.6742980957031250e+01, 4.4834392610937357e-04, 1, -1,
+    1.9440000915527344e+02, 2.5680001831054688e+02,
+    3.7200000762939453e+01, 3.6547557830810547e+01,
+    4.5934907393530011e-04, 1, -1, 2.9040002441406250e+02,
+    2.5680001831054688e+02, 3.7200000762939453e+01,
+    8.4271583557128906e+01, 2.1195332010393031e-05, 1, -1,
+    3.0840002441406250e+02, 2.5680001831054688e+02,
+    3.7200000762939453e+01, 9.3512229919433594e+01,
+    3.4638505894690752e-05, 1, -1, 3.1320001220703125e+02,
+    2.5680001831054688e+02, 3.7200000762939453e+01,
+    1.0651969909667969e+02, 4.2909523472189903e-05, 1, -1,
+    3.3240002441406250e+02, 2.5680001831054688e+02,
+    3.7200000762939453e+01, 7.1925918579101562e+01,
+    1.2694258475676179e-04, 1, -1, 348., 2.5680001831054688e+02,
+    3.7200000762939453e+01, 2.5364225769042969e+02,
+    2.3796841560397297e-05, 1, -1, 3.5520001220703125e+02,
+    2.5680001831054688e+02, 3.7200000762939453e+01,
+    2.4539129638671875e+02, 4.2686311644501984e-05, 1, -1,
+    3.8040002441406250e+02, 2.5680001831054688e+02,
+    3.7200000762939453e+01, 2.8402307128906250e+02,
+    1.5641879144823179e-05, 1, -1, 1.3080000305175781e+02, 258.,
+    3.7200000762939453e+01, 1.1569035339355469e+02,
+    8.8297310867346823e-05, 1, -1, 1.3560000610351562e+02, 258.,
+    3.7200000762939453e+01, 1.1168455505371094e+02,
+    4.8136975237866864e-05, 1, -1, 1.4160000610351562e+02, 258.,
+    3.7200000762939453e+01, 9.6596542358398438e+01,
+    4.4822445488534868e-05, 1, -1, 1.5480000305175781e+02, 258.,
+    3.7200000762939453e+01, 1.0110254669189453e+02,
+    3.1992527510738000e-05, 1, -1, 1.8960000610351562e+02, 258.,
+    3.7200000762939453e+01, 6.8638374328613281e+01,
+    2.7899557608179748e-04, 1, -1, 2.2440000915527344e+02, 258.,
+    3.7200000762939453e+01, 1.5241531372070312e+02,
+    1.3230099284555763e-04, 1, -1, 2.2920001220703125e+02, 258.,
+    3.7200000762939453e+01, 1.4327542114257812e+02,
+    5.2904073527315632e-05, 1, -1, 2.9880001831054688e+02, 258.,
+    3.7200000762939453e+01, 7.1808517456054688e+01,
+    2.1259693312458694e-05, 1, -1, 3.1680001831054688e+02, 258.,
+    3.7200000762939453e+01, 1.1303039550781250e+02,
+    2.7905725801247172e-05, 1, -1, 3.2280001831054688e+02, 258.,
+    3.7200000762939453e+01, 1.0638027954101562e+02,
+    7.2636830736882985e-05, 1, -1, 3.5280001831054688e+02, 258.,
+    3.7200000762939453e+01, 2.3874934387207031e+02,
+    2.1132495021447539e-05, 1, -1, 3.6360000610351562e+02, 258.,
+    3.7200000762939453e+01, 3.5523294067382812e+02,
+    3.6844136047875509e-05, 1, -1, 3.7080001831054688e+02, 258.,
+    3.7200000762939453e+01, 3.4029821777343750e+02,
+    2.5500741685391404e-05, 1, -1, 3.7440002441406250e+02, 258.,
+    3.7200000762939453e+01, 3.2081936645507812e+02,
+    2.4525408662157133e-05, 1, -1, 378., 258., 3.7200000762939453e+01,
+    3.0225314331054688e+02, 1.0944309906335548e-05, 1, -1,
+    4.1280001831054688e+02, 258., 3.7200000762939453e+01,
+    2.3049784851074219e+02, 3.2003878004616126e-05, 1, -1,
+    4.1760000610351562e+02, 258., 3.7200000762939453e+01,
+    2.3459020996093750e+02, 9.3208283942658454e-05, 1, -1,
+    4.2240002441406250e+02, 258., 3.7200000762939453e+01,
+    2.4217469787597656e+02, 5.3127972932998091e-05, 1, -1,
+    4.3680001831054688e+02, 258., 3.7200000762939453e+01,
+    2.6196923828125000e+02, 9.7498932518647052e-06, 1, -1,
+    1.4760000610351562e+02, 2.5920001220703125e+02,
+    3.7200000762939453e+01, 8.8654380798339844e+01,
+    2.3056304780766368e-04, 1, -1, 162., 2.5920001220703125e+02,
+    3.7200000762939453e+01, 1.0253897094726562e+02,
+    1.1364146303094458e-05, 1, -1, 1.6440000915527344e+02,
+    2.5920001220703125e+02, 3.7200000762939453e+01,
+    1.0265025329589844e+02, 1.9852801415254362e-05, 1, -1,
+    1.7040000915527344e+02, 2.5920001220703125e+02,
+    3.7200000762939453e+01, 1.0400877380371094e+02,
+    7.3300398071296513e-05, 1, -1, 4.2720001220703125e+02,
+    2.5920001220703125e+02, 3.7200000762939453e+01,
+    2.6530059814453125e+02, 1.4586339602828957e-05, 1, -1,
+    1.4520001220703125e+02, 2.6040002441406250e+02,
+    3.7200000762939453e+01, 9.1764427185058594e+01,
+    5.2144743676763028e-05, 1, -1, 1.8480000305175781e+02,
+    2.6040002441406250e+02, 3.7200000762939453e+01,
+    8.8927391052246094e+01, 1.3739732094109058e-04, 1, -1,
+    2.3640000915527344e+02, 2.6040002441406250e+02,
+    3.7200000762939453e+01, 1.5009681701660156e+02,
+    1.0093540186062455e-04, 1, -1, 2.4360000610351562e+02,
+    2.6040002441406250e+02, 3.7200000762939453e+01,
+    1.2859638977050781e+02, 5.3833169658901170e-05, 1, -1,
+    2.4840000915527344e+02, 2.6040002441406250e+02,
+    3.7200000762939453e+01, 9.5617042541503906e+01,
+    4.9470265366835520e-05, 1, -1, 3.2760000610351562e+02,
+    2.6040002441406250e+02, 3.7200000762939453e+01,
+    9.6494606018066406e+01, 3.9915659726830199e-05, 1, -1,
+    3.6120001220703125e+02, 2.6040002441406250e+02,
+    3.7200000762939453e+01, 5.5632221221923828e+01,
+    5.2574854635167867e-05, 1, -1, 3.6480001831054688e+02,
+    2.6040002441406250e+02, 3.7200000762939453e+01,
+    3.2127162933349609e+01, 3.9258666220121086e-05, 1, -1,
+    4.1760000610351562e+02, 2.6040002441406250e+02,
+    3.7200000762939453e+01, 2.2877694702148438e+02,
+    4.2778054194059223e-05, 1, -1, 1.1280000305175781e+02,
+    2.6160000610351562e+02, 3.7200000762939453e+01,
+    4.1042881011962891e+01, 8.8797474745661020e-05, 1, -1,
+    1.5240000915527344e+02, 2.6160000610351562e+02,
+    3.7200000762939453e+01, 9.6236923217773438e+01,
+    4.4168155000079423e-05, 1, -1, 1.7520001220703125e+02,
+    2.6160000610351562e+02, 3.7200000762939453e+01,
+    9.9372085571289062e+01, 1.8175142758991569e-04, 1, -1,
+    1.9080000305175781e+02, 2.6160000610351562e+02,
+    3.7200000762939453e+01, 8.3470794677734375e+01,
+    1.0627497249515727e-04, 1, -1, 2.2200001525878906e+02,
+    2.6160000610351562e+02, 3.7200000762939453e+01,
+    1.2999368286132812e+02, 1.0655756341293454e-04, 1, -1,
+    2.4120001220703125e+02, 2.6160000610351562e+02,
+    3.7200000762939453e+01, 1.2719505310058594e+02,
+    1.1185121547896415e-04, 1, -1, 2.5320001220703125e+02,
+    2.6160000610351562e+02, 3.7200000762939453e+01,
+    6.5985076904296875e+01, 8.4139086538925767e-05, 1, -1,
+    3.3720001220703125e+02, 2.6160000610351562e+02,
+    3.7200000762939453e+01, 9.3923912048339844e+01,
+    2.8225580535945483e-05, 1, -1, 372., 2.6160000610351562e+02,
+    3.7200000762939453e+01, 2.5528915405273438e+01,
+    2.2073154468671419e-05, 1, -1, 3.7560000610351562e+02,
+    2.6160000610351562e+02, 3.7200000762939453e+01,
+    3.2171649169921875e+02, 1.1172967788297683e-05, 1, -1,
+    4.3440002441406250e+02, 2.6160000610351562e+02,
+    3.7200000762939453e+01, 2.8582647705078125e+02,
+    2.2986274416325614e-05, 1, -1, 1.7280000305175781e+02,
+    2.6280001831054688e+02, 3.7200000762939453e+01,
+    9.8921134948730469e+01, 1.0563476826064289e-04, 1, -1,
+    1.7880000305175781e+02, 2.6280001831054688e+02,
+    3.7200000762939453e+01, 9.5521781921386719e+01,
+    1.4061630645301193e-04, 1, -1, 1.9680000305175781e+02,
+    2.6280001831054688e+02, 3.7200000762939453e+01,
+    7.4103851318359375e+01, 2.5054099751287140e-05, 1, -1,
+    2.6040002441406250e+02, 2.6280001831054688e+02,
+    3.7200000762939453e+01, 1.2789688110351562e+02,
+    6.5111009462270886e-05, 1, -1, 3.3960000610351562e+02,
+    2.6280001831054688e+02, 3.7200000762939453e+01,
+    9.9048683166503906e+01, 2.3516955479863100e-05, 1, -1, 348.,
+    2.6280001831054688e+02, 3.7200000762939453e+01,
+    1.2802340698242188e+02, 3.2763855415396392e-05, 1, -1,
+    3.9600003051757812e+02, 2.6280001831054688e+02,
+    3.7200000762939453e+01, 2.4660339355468750e+02,
+    2.4554951778554823e-06, 1, -1, 4.0920001220703125e+02,
+    2.6280001831054688e+02, 3.7200000762939453e+01,
+    2.0036863708496094e+02, 2.7191810659132898e-05, 1, -1,
+    4.1760000610351562e+02, 2.6280001831054688e+02,
+    3.7200000762939453e+01, 2.1101889038085938e+02,
+    2.3150767447077669e-05, 1, -1, 4.2360000610351562e+02,
+    2.6280001831054688e+02, 3.7200000762939453e+01,
+    2.2900621032714844e+02, 1.3618865341413766e-04, 1, -1,
+    4.6440002441406250e+02, 2.6280001831054688e+02,
+    3.7200000762939453e+01, 2.0156546020507812e+02,
+    2.0307018075982342e-06, 1, -1, 1.6920001220703125e+02, 264.,
+    3.7200000762939453e+01, 1.0243161773681641e+02,
+    5.7079141697613522e-05, 1, -1, 1.8120001220703125e+02, 264.,
+    3.7200000762939453e+01, 9.4180244445800781e+01,
+    7.5853713497053832e-05, 1, -1, 2.2920001220703125e+02, 264.,
+    3.7200000762939453e+01, 1.2174703216552734e+02,
+    2.7337080609868281e-05, 1, -1, 2.3520001220703125e+02, 264.,
+    3.7200000762939453e+01, 1.2089430236816406e+02,
+    9.1065441665705293e-05, 1, -1, 2.7120001220703125e+02, 264.,
+    3.7200000762939453e+01, 1.0145370483398438e+02,
+    4.5107048208592460e-05, 1, -1, 3.5640002441406250e+02, 264.,
+    3.7200000762939453e+01, 9.4568237304687500e+01,
+    1.9715373127837665e-05, 1, -1, 3.9840002441406250e+02, 264.,
+    3.7200000762939453e+01, 2.5302742004394531e+02,
+    7.9071205618674867e-06, 1, -1, 4.0200003051757812e+02, 264.,
+    3.7200000762939453e+01, 2.2883291625976562e+02,
+    1.6854932255228050e-05, 1, -1, 1.7760000610351562e+02,
+    2.6520001220703125e+02, 3.7200000762939453e+01,
+    9.6557868957519531e+01, 6.9736488512717187e-05, 1, -1,
+    1.8960000610351562e+02, 2.6520001220703125e+02,
+    3.7200000762939453e+01, 9.1399375915527344e+01,
+    1.2985207831661683e-05, 1, -1, 2.4480000305175781e+02,
+    2.6520001220703125e+02, 3.7200000762939453e+01,
+    1.0678494262695312e+02, 5.3305277106119320e-05, 1, -1,
+    2.5080000305175781e+02, 2.6520001220703125e+02,
+    3.7200000762939453e+01, 9.2486671447753906e+01,
+    9.9557968496810645e-05, 1, -1, 264., 2.6520001220703125e+02,
+    3.7200000762939453e+01, 9.3612762451171875e+01,
+    1.1376383190508932e-04, 1, -1, 2.7720001220703125e+02,
+    2.6520001220703125e+02, 3.7200000762939453e+01,
+    8.8331809997558594e+01, 5.0773418479366228e-05, 1, -1,
+    3.9480001831054688e+02, 2.6520001220703125e+02,
+    3.7200000762939453e+01, 2.4934944152832031e+02,
+    6.1196755268611014e-05, 1, -1, 4.1040002441406250e+02,
+    2.6520001220703125e+02, 3.7200000762939453e+01,
+    1.9238548278808594e+02, 4.5172721002018079e-05, 1, -1,
+    4.2720001220703125e+02, 2.6520001220703125e+02,
+    3.7200000762939453e+01, 7.0018905639648438e+01,
+    2.2327687474898994e-04, 1, -1, 4.3560000610351562e+02,
+    2.6520001220703125e+02, 3.7200000762939453e+01,
+    2.3145800781250000e+02, 1.7426300473744050e-05, 1, -1,
+    2.0160000610351562e+02, 2.6640002441406250e+02,
+    3.7200000762939453e+01, 7.9804771423339844e+01,
+    2.8570622816914693e-05, 1, -1, 258., 2.6640002441406250e+02,
+    3.7200000762939453e+01, 1.0820127868652344e+02,
+    9.1652691480703652e-05, 1, -1, 2.8080001831054688e+02,
+    2.6640002441406250e+02, 3.7200000762939453e+01,
+    1.0672941589355469e+02, 8.0691956100054085e-05, 1, -1,
+    3.9840002441406250e+02, 2.6640002441406250e+02,
+    3.7200000762939453e+01, 2.6305270385742188e+02,
+    9.3158407253213227e-05, 1, -1, 4.1760000610351562e+02,
+    2.6640002441406250e+02, 3.7200000762939453e+01,
+    1.6669415283203125e+02, 5.1088729378534481e-05, 1, -1, 192.,
+    2.6760000610351562e+02, 3.7200000762939453e+01,
+    9.0346672058105469e+01, 1.8602195268613286e-05, 1, -1,
+    2.8320001220703125e+02, 2.6760000610351562e+02,
+    3.7200000762939453e+01, 1.1264755249023438e+02,
+    8.9781431597657502e-05, 1, -1, 2.9520001220703125e+02,
+    2.6760000610351562e+02, 3.7200000762939453e+01,
+    9.7911384582519531e+01, 4.7757352149346843e-05, 1, -1,
+    2.0040000915527344e+02, 2.6880001831054688e+02,
+    3.7200000762939453e+01, 8.5612945556640625e+01,
+    3.5598506656242535e-05, 1, -1, 2.1240000915527344e+02,
+    2.6880001831054688e+02, 3.7200000762939453e+01,
+    9.7980758666992188e+01, 1.1705559700203594e-05, 1, -1,
+    2.6880001831054688e+02, 2.6880001831054688e+02,
+    3.7200000762939453e+01, 9.5660842895507812e+01,
+    5.4088082833914086e-05, 1, -1, 288., 2.6880001831054688e+02,
+    3.7200000762939453e+01, 8.2927162170410156e+01,
+    1.1124216689495370e-04, 1, -1, 3.6840002441406250e+02,
+    2.6880001831054688e+02, 3.7200000762939453e+01,
+    3.1838894653320312e+02, 1.2964503548573703e-04, 1, -1,
+    3.9240002441406250e+02, 2.6880001831054688e+02,
+    3.7200000762939453e+01, 2.2619921875000000e+02,
+    1.7041905084624887e-04, 1, -1, 4.0440002441406250e+02,
+    2.6880001831054688e+02, 3.7200000762939453e+01,
+    1.9849261474609375e+02, 2.0152311481069773e-04, 1, -1,
+    4.1040002441406250e+02, 2.6880001831054688e+02,
+    3.7200000762939453e+01, 1.6379046630859375e+02,
+    2.0907052385155112e-04, 1, -1, 4.1640002441406250e+02,
+    2.6880001831054688e+02, 3.7200000762939453e+01,
+    1.4331439208984375e+02, 6.9832225563004613e-05, 1, -1,
+    4.3200003051757812e+02, 2.6880001831054688e+02,
+    3.7200000762939453e+01, 1.3539981079101562e+02,
+    8.9975394075736403e-05, 1, -1, 1.2960000610351562e+02, 270.,
+    3.7200000762939453e+01, 9.6868743896484375e+01,
+    3.9424787246389315e-05, 1, -1, 2.1840000915527344e+02, 270.,
+    3.7200000762939453e+01, 1.0377822875976562e+02,
+    5.2455852710409090e-05, 1, -1, 2.2920001220703125e+02, 270.,
+    3.7200000762939453e+01, 1.0452349853515625e+02,
+    1.1501461813168135e-05, 1, -1, 276., 270., 3.7200000762939453e+01,
+    9.5827056884765625e+01, 4.4173360947752371e-05, 1, -1,
+    2.8320001220703125e+02, 270., 3.7200000762939453e+01,
+    1.0735749053955078e+02, 9.6874900918919593e-05, 1, -1,
+    2.9760000610351562e+02, 270., 3.7200000762939453e+01,
+    8.6254745483398438e+01, 8.8035252701956779e-05, 1, -1, 300., 270.,
+    3.7200000762939453e+01, 7.3923950195312500e+01,
+    1.1591414659051225e-04, 1, -1, 3.0720001220703125e+02, 270.,
+    3.7200000762939453e+01, 8.9205055236816406e+01,
+    8.9579210907686502e-05, 1, -1, 384., 270., 3.7200000762939453e+01,
+    2.2300764465332031e+02, 2.9099770472384989e-05, 1, -1,
+    2.1600001525878906e+02, 2.7120001220703125e+02,
+    3.7200000762939453e+01, 1.0166796112060547e+02,
+    4.2145318730035797e-05, 1, -1, 2.2680000305175781e+02,
+    2.7120001220703125e+02, 3.7200000762939453e+01,
+    1.0210894775390625e+02, 2.1616482626996003e-05, 1, -1,
+    2.8680001831054688e+02, 2.7120001220703125e+02,
+    3.7200000762939453e+01, 9.2287895202636719e+01,
+    6.3838910136837512e-05, 1, -1, 312., 2.7120001220703125e+02,
+    3.7200000762939453e+01, 6.0732837677001953e+01,
+    1.0106252739205956e-04, 1, -1, 3.7080001831054688e+02,
+    2.7120001220703125e+02, 3.7200000762939453e+01,
+    2.4513931274414062e+02, 2.0974942890461534e-04, 1, -1,
+    4.0200003051757812e+02, 2.7120001220703125e+02,
+    3.7200000762939453e+01, 2.8275820922851562e+02,
+    3.4312761272303760e-04, 1, -1, 4.0680001831054688e+02,
+    2.7120001220703125e+02, 3.7200000762939453e+01,
+    1.6194097900390625e+02, 1.8992542754858732e-04, 1, -1,
+    4.1640002441406250e+02, 2.7120001220703125e+02,
+    3.7200000762939453e+01, 1.2971257019042969e+02,
+    7.8716315329074860e-05, 1, -1, 4.2720001220703125e+02,
+    2.7120001220703125e+02, 3.7200000762939453e+01,
+    1.0554112243652344e+02, 2.7491609216667712e-04, 1, -1,
+    4.3320001220703125e+02, 2.7120001220703125e+02,
+    3.7200000762939453e+01, 1.6757852172851562e+02,
+    3.4745124139590189e-05, 1, -1, 1.2960000610351562e+02,
+    2.7240002441406250e+02, 3.7200000762939453e+01,
+    9.2224746704101562e+01, 5.8185811212752014e-05, 1, -1, 144.,
+    2.7240002441406250e+02, 3.7200000762939453e+01,
+    9.4132827758789062e+01, 6.2542967498302460e-05, 1, -1,
+    2.2440000915527344e+02, 2.7240002441406250e+02,
+    3.7200000762939453e+01, 1.0289589691162109e+02,
+    3.2280961022479460e-05, 1, -1, 2.3880000305175781e+02,
+    2.7240002441406250e+02, 3.7200000762939453e+01,
+    1.0107096862792969e+02, 3.4723158023552969e-05, 1, -1, 294.,
+    2.7240002441406250e+02, 3.7200000762939453e+01,
+    1.0349336242675781e+02, 5.8110639656661078e-05, 1, -1,
+    2.9880001831054688e+02, 2.7240002441406250e+02,
+    3.7200000762939453e+01, 9.0277732849121094e+01,
+    6.3640887674409896e-05, 1, -1, 3.1920001220703125e+02,
+    2.7240002441406250e+02, 3.7200000762939453e+01,
+    4.6455646514892578e+01, 1.0170457971980795e-04, 1, -1,
+    3.2520001220703125e+02, 2.7240002441406250e+02,
+    3.7200000762939453e+01, 4.8899116516113281e+01,
+    3.0353932743309997e-05, 1, -1, 3.9600003051757812e+02,
+    2.7240002441406250e+02, 3.7200000762939453e+01,
+    2.4712277221679688e+02, 3.8694564136676490e-04, 1, -1,
+    4.0920001220703125e+02, 2.7240002441406250e+02,
+    3.7200000762939453e+01, 1.5331202697753906e+02,
+    1.5270673611667007e-04, 1, -1, 1.5240000915527344e+02,
+    2.7360000610351562e+02, 3.7200000762939453e+01,
+    9.4364074707031250e+01, 5.1863338740076870e-05, 1, -1, 306.,
+    2.7360000610351562e+02, 3.7200000762939453e+01,
+    9.3565879821777344e+01, 1.4788923726882786e-04, 1, -1,
+    3.0840002441406250e+02, 2.7360000610351562e+02,
+    3.7200000762939453e+01, 8.1732696533203125e+01,
+    1.4714260760229081e-04, 1, -1, 3.8880001831054688e+02,
+    2.7360000610351562e+02, 3.7200000762939453e+01,
+    2.1372114562988281e+02, 2.5208803708665073e-04, 1, -1,
+    4.2720001220703125e+02, 2.7360000610351562e+02,
+    3.7200000762939453e+01, 1.2400547790527344e+02,
+    1.5292111493181437e-04, 1, -1, 4.2960000610351562e+02,
+    2.7360000610351562e+02, 3.7200000762939453e+01,
+    1.4568963623046875e+02, 1.1418887152103707e-04, 1, -1,
+    1.4040000915527344e+02, 2.7480001831054688e+02,
+    3.7200000762939453e+01, 9.6539581298828125e+01,
+    2.2813901523477398e-05, 1, -1, 144., 2.7480001831054688e+02,
+    3.7200000762939453e+01, 9.4193222045898438e+01,
+    7.5065116106998175e-05, 1, -1, 2.3880000305175781e+02,
+    2.7480001831054688e+02, 3.7200000762939453e+01,
+    1.0047447204589844e+02, 3.9791138988221064e-05, 1, -1,
+    2.4960000610351562e+02, 2.7480001831054688e+02,
+    3.7200000762939453e+01, 9.7906082153320312e+01,
+    2.0674735424108803e-05, 1, -1, 3.7080001831054688e+02,
+    2.7480001831054688e+02, 3.7200000762939453e+01,
+    2.4013546752929688e+02, 9.3800699687562883e-05, 1, -1,
+    3.8160000610351562e+02, 2.7480001831054688e+02,
+    3.7200000762939453e+01, 2.3884585571289062e+02,
+    6.1645267123822123e-05, 1, -1, 3.9360000610351562e+02,
+    2.7480001831054688e+02, 3.7200000762939453e+01,
+    2.0477789306640625e+02, 2.6537085068412125e-04, 1, -1,
+    3.9960000610351562e+02, 2.7480001831054688e+02,
+    3.7200000762939453e+01, 8.6352472305297852e+00,
+    2.2124956012703478e-04, 1, -1, 4.2480001831054688e+02,
+    2.7480001831054688e+02, 3.7200000762939453e+01,
+    1.1535630035400391e+02, 9.2993395810481161e-05, 1, -1,
+    1.2600000762939453e+02, 276., 3.7200000762939453e+01,
+    2.2109342575073242e+01, 5.5738575611030683e-05, 1, -1,
+    1.4880000305175781e+02, 276., 3.7200000762939453e+01,
+    9.3573120117187500e+01, 8.5692568973172456e-05, 1, -1,
+    1.5240000915527344e+02, 276., 3.7200000762939453e+01,
+    9.3104705810546875e+01, 5.6865632359404117e-05, 1, -1, 156., 276.,
+    3.7200000762939453e+01, 9.7490722656250000e+01,
+    1.7673328329692595e-05, 1, -1, 168., 276., 3.7200000762939453e+01,
+    9.7826210021972656e+01, 5.2389612392289564e-05, 1, -1,
+    2.4600001525878906e+02, 276., 3.7200000762939453e+01,
+    9.8587203979492188e+01, 4.1261053411290050e-05, 1, -1,
+    2.5920001220703125e+02, 276., 3.7200000762939453e+01,
+    9.9456314086914062e+01, 2.1105772248120047e-05, 1, -1,
+    2.6280001831054688e+02, 276., 3.7200000762939453e+01,
+    9.9354278564453125e+01, 4.4253447413211688e-05, 1, -1,
+    3.1560000610351562e+02, 276., 3.7200000762939453e+01,
+    7.0383995056152344e+01, 6.6682900069281459e-05, 1, -1,
+    3.1920001220703125e+02, 276., 3.7200000762939453e+01,
+    6.2928970336914062e+01, 8.2085520261898637e-05, 1, -1,
+    3.5760000610351562e+02, 276., 3.7200000762939453e+01,
+    1.9936230468750000e+02, 1.5661012730561197e-04, 1, -1,
+    3.7440002441406250e+02, 276., 3.7200000762939453e+01,
+    2.4246353149414062e+02, 1.5873649681452662e-04, 1, -1, 384., 276.,
+    3.7200000762939453e+01, 2.3806774902343750e+02,
+    1.6596590285189450e-04, 1, -1, 4.1880001831054688e+02, 276.,
+    3.7200000762939453e+01, 1.1456272888183594e+02,
+    1.2700704974122345e-04, 1, -1, 1.7520001220703125e+02,
+    2.7720001220703125e+02, 3.7200000762939453e+01,
+    9.4916778564453125e+01, 4.4223765144124627e-05, 1, -1,
+    2.7120001220703125e+02, 2.7720001220703125e+02,
+    3.7200000762939453e+01, 9.7750831604003906e+01,
+    2.5698022000142373e-05, 1, -1, 3.8760000610351562e+02,
+    2.7720001220703125e+02, 3.7200000762939453e+01,
+    2.1880422973632812e+02, 1.4777448086533695e-04, 1, -1,
+    4.2840002441406250e+02, 2.7720001220703125e+02,
+    3.7200000762939453e+01, 1.5470471191406250e+02,
+    4.7895573516143486e-05, 1, -1, 168., 2.7840002441406250e+02,
+    3.7200000762939453e+01, 9.9386550903320312e+01,
+    6.3491999753750861e-05, 1, -1, 2.6280001831054688e+02,
+    2.7840002441406250e+02, 3.7200000762939453e+01,
+    1.0001161193847656e+02, 4.7171375626930967e-05, 1, -1, 360.,
+    2.7840002441406250e+02, 3.7200000762939453e+01,
+    2.1362063598632812e+02, 8.8422260887455195e-05, 1, -1, 378.,
+    2.7840002441406250e+02, 3.7200000762939453e+01,
+    2.4022602844238281e+02, 1.3344205217435956e-04, 1, -1,
+    3.8040002441406250e+02, 2.7840002441406250e+02,
+    3.7200000762939453e+01, 2.4110208129882812e+02,
+    1.0634026693878695e-04, 1, -1, 3.9600003051757812e+02,
+    2.7840002441406250e+02, 3.7200000762939453e+01,
+    8.7194030761718750e+01, 2.0831676374655217e-04, 1, -1,
+    4.2120001220703125e+02, 2.7840002441406250e+02,
+    3.7200000762939453e+01, 1.1980741882324219e+02,
+    1.1609716602833942e-04, 1, -1, 1.9080000305175781e+02,
+    2.7960000610351562e+02, 3.7200000762939453e+01,
+    9.8449844360351562e+01, 6.7566630605142564e-05, 1, -1, 270.,
+    2.7960000610351562e+02, 3.7200000762939453e+01,
+    9.8436988830566406e+01, 3.3844156860141084e-05, 1, -1, 294.,
+    2.7960000610351562e+02, 3.7200000762939453e+01,
+    9.9871398925781250e+01, 3.5664408642333001e-05, 1, -1,
+    3.5280001831054688e+02, 2.7960000610351562e+02,
+    3.7200000762939453e+01, 1.8081541442871094e+02,
+    1.3736910477746278e-04, 1, -1, 3.7320001220703125e+02,
+    2.7960000610351562e+02, 3.7200000762939453e+01,
+    2.2270541381835938e+02, 9.8905424238182604e-05, 1, -1,
+    1.7760000610351562e+02, 2.8080001831054688e+02,
+    3.7200000762939453e+01, 8.4892890930175781e+01,
+    3.0145107302814722e-05, 1, -1, 1.8720001220703125e+02,
+    2.8080001831054688e+02, 3.7200000762939453e+01,
+    9.8444641113281250e+01, 3.6790803278563544e-05, 1, -1,
+    1.9920001220703125e+02, 2.8080001831054688e+02,
+    3.7200000762939453e+01, 9.6726989746093750e+01,
+    4.4353768316796049e-05, 1, -1, 2.9040002441406250e+02,
+    2.8080001831054688e+02, 3.7200000762939453e+01,
+    1.0072741699218750e+02, 4.9307534936815500e-05, 1, -1,
+    3.0120001220703125e+02, 2.8080001831054688e+02,
+    3.7200000762939453e+01, 9.6981773376464844e+01,
+    9.9533908723969944e-06, 1, -1, 3.5520001220703125e+02,
+    2.8080001831054688e+02, 3.7200000762939453e+01,
+    1.6873124694824219e+02, 2.7820901595987380e-04, 1, -1,
+    3.6360000610351562e+02, 2.8080001831054688e+02,
+    3.7200000762939453e+01, 1.9923696899414062e+02,
+    1.2105475616408512e-04, 1, -1, 3.9600003051757812e+02,
+    2.8080001831054688e+02, 3.7200000762939453e+01,
+    7.7360015869140625e+01, 1.1288613313809037e-04, 1, -1,
+    4.1280001831054688e+02, 2.8080001831054688e+02,
+    3.7200000762939453e+01, 1.4901248168945312e+02,
+    1.6244433936662972e-05, 1, -1, 4.2840002441406250e+02,
+    2.8080001831054688e+02, 3.7200000762939453e+01,
+    1.7529997253417969e+02, 2.9653074307134375e-05, 1, -1,
+    1.8480000305175781e+02, 282., 3.7200000762939453e+01,
+    9.1693946838378906e+01, -2.5540425667713862e-06, 1, -1,
+    1.9080000305175781e+02, 282., 3.7200000762939453e+01,
+    9.7993446350097656e+01, 8.4170082118362188e-05, 1, -1, 288., 282.,
+    3.7200000762939453e+01, 1.0060778045654297e+02,
+    4.2509742343099788e-05, 1, -1, 2.9880001831054688e+02, 282.,
+    3.7200000762939453e+01, 9.9076332092285156e+01,
+    2.6214695026283152e-05, 1, -1, 366., 282., 3.7200000762939453e+01,
+    1.6475767517089844e+02, 1.0300182475475594e-04, 1, -1,
+    3.7080001831054688e+02, 282., 3.7200000762939453e+01,
+    1.6060382080078125e+02, 2.3900598534964956e-05, 1, -1,
+    3.8160000610351562e+02, 282., 3.7200000762939453e+01,
+    9.7847419738769531e+01, 2.2751402866560966e-04, 1, -1,
+    4.2600003051757812e+02, 282., 3.7200000762939453e+01,
+    1.7420539855957031e+02, 8.1132697232533246e-05, 1, -1,
+    1.9440000915527344e+02, 2.8320001220703125e+02,
+    3.7200000762939453e+01, 9.7159393310546875e+01,
+    6.5694315708242357e-05, 1, -1, 2.1480000305175781e+02,
+    2.8320001220703125e+02, 3.7200000762939453e+01,
+    9.7511207580566406e+01, 5.1341412472538650e-05, 1, -1,
+    2.9520001220703125e+02, 2.8320001220703125e+02,
+    3.7200000762939453e+01, 9.9321228027343750e+01,
+    4.7153811465250328e-05, 1, -1, 3.5280001831054688e+02,
+    2.8320001220703125e+02, 3.7200000762939453e+01,
+    1.4010281372070312e+02, 3.3370274468325078e-04, 1, -1,
+    4.2360000610351562e+02, 2.8320001220703125e+02,
+    3.7200000762939453e+01, 1.7406759643554688e+02,
+    1.2899714056402445e-04, 1, -1, 1.4040000915527344e+02,
+    2.8440002441406250e+02, 3.7200000762939453e+01,
+    2.5460185241699219e+02, 2.5260531401727349e-05, 1, -1,
+    1.9920001220703125e+02, 2.8440002441406250e+02,
+    3.7200000762939453e+01, 9.6859001159667969e+01,
+    3.5481236409395933e-05, 1, -1, 2.2320001220703125e+02,
+    2.8440002441406250e+02, 3.7200000762939453e+01,
+    9.6846099853515625e+01, 4.2935796955134720e-05, 1, -1,
+    3.5520001220703125e+02, 2.8440002441406250e+02,
+    3.7200000762939453e+01, 1.3068470764160156e+02,
+    3.2300679595209658e-04, 1, -1, 3.5760000610351562e+02,
+    2.8440002441406250e+02, 3.7200000762939453e+01,
+    1.2432095336914062e+02, 2.6280194288119674e-04, 1, -1,
+    3.6360000610351562e+02, 2.8440002441406250e+02,
+    3.7200000762939453e+01, 1.1412277984619141e+02,
+    2.7521973242983222e-04, 1, -1, 3.7920001220703125e+02,
+    2.8440002441406250e+02, 3.7200000762939453e+01,
+    1.0235949707031250e+02, 1.0113180906046182e-04, 1, -1,
+    3.8280001831054688e+02, 2.8440002441406250e+02,
+    3.7200000762939453e+01, 8.7177330017089844e+01,
+    2.9451551381498575e-04, 1, -1, 4.0200003051757812e+02,
+    2.8440002441406250e+02, 3.7200000762939453e+01,
+    1.0032420349121094e+02, 2.2528781846631318e-04, 1, -1,
+    4.0560000610351562e+02, 2.8440002441406250e+02,
+    3.7200000762939453e+01, 1.4442810058593750e+02,
+    2.0274019334465265e-04, 1, -1, 1.4280000305175781e+02,
+    2.8560000610351562e+02, 3.7200000762939453e+01,
+    2.6428424072265625e+02, 7.6164185884408653e-05, 1, -1, 162.,
+    2.8560000610351562e+02, 3.7200000762939453e+01,
+    2.4636129760742188e+02, 2.0158098777756095e-05, 1, -1,
+    2.1480000305175781e+02, 2.8560000610351562e+02,
+    3.7200000762939453e+01, 9.7099678039550781e+01,
+    7.4816649430431426e-05, 1, -1, 3.1080001831054688e+02,
+    2.8560000610351562e+02, 3.7200000762939453e+01,
+    9.8647537231445312e+01, 3.0291190341813490e-05, 1, -1, 360.,
+    2.8560000610351562e+02, 3.7200000762939453e+01,
+    1.1382299041748047e+02, 2.1967827342450619e-04, 1, -1, 366.,
+    2.8560000610351562e+02, 3.7200000762939453e+01,
+    1.0839992523193359e+02, 2.2668752353638411e-04, 1, -1,
+    3.8640002441406250e+02, 2.8560000610351562e+02,
+    3.7200000762939453e+01, 9.9547195434570312e+01,
+    3.7395142135210335e-04, 1, -1, 1.6920001220703125e+02,
+    2.8680001831054688e+02, 3.7200000762939453e+01,
+    2.7245080566406250e+02, 1.7699554518912919e-05, 1, -1,
+    1.7160000610351562e+02, 2.8680001831054688e+02,
+    3.7200000762939453e+01, 2.8466619873046875e+02,
+    1.6994494217215106e-05, 1, -1, 2.1840000915527344e+02,
+    2.8680001831054688e+02, 3.7200000762939453e+01,
+    9.7416732788085938e+01, 7.2421171353198588e-05, 1, -1,
+    2.2560000610351562e+02, 2.8680001831054688e+02,
+    3.7200000762939453e+01, 9.6513755798339844e+01,
+    3.5741883039008826e-05, 1, -1, 2.3760000610351562e+02,
+    2.8680001831054688e+02, 3.7200000762939453e+01,
+    9.7929885864257812e+01, 4.4874937884742394e-05, 1, -1,
+    3.1920001220703125e+02, 2.8680001831054688e+02,
+    3.7200000762939453e+01, 9.3891716003417969e+01,
+    3.0103343306109309e-05, 1, -1, 3.3120001220703125e+02,
+    2.8680001831054688e+02, 3.7200000762939453e+01,
+    9.8196701049804688e+01, 1.4536706657963805e-05, 1, -1, 336.,
+    2.8680001831054688e+02, 3.7200000762939453e+01,
+    1.0739999389648438e+02, 4.5569293433800340e-05, 1, -1,
+    4.1520001220703125e+02, 2.8680001831054688e+02,
+    3.7200000762939453e+01, 1.4990515136718750e+02,
+    1.5488165081478655e-04, 1, -1, 4.1760000610351562e+02,
+    2.8680001831054688e+02, 3.7200000762939453e+01,
+    1.5818804931640625e+02, 2.7510069776326418e-04, 1, -1,
+    4.2600003051757812e+02, 2.8680001831054688e+02,
+    3.7200000762939453e+01, 1.8781011962890625e+02,
+    3.1314382795244455e-05, 1, -1, 1.4040000915527344e+02, 288.,
+    3.7200000762939453e+01, 2.0727770996093750e+02,
+    1.1995476961601526e-04, 1, -1, 144., 288., 3.7200000762939453e+01,
+    2.4818499755859375e+02, 1.6602553660050035e-04, 1, -1,
+    1.5840000915527344e+02, 288., 3.7200000762939453e+01,
+    2.4552377319335938e+02, 2.2507603716803715e-05, 1, -1,
+    1.7760000610351562e+02, 288., 3.7200000762939453e+01,
+    3.1509573364257812e+02, 2.5966131943278015e-05, 1, -1, 186., 288.,
+    3.7200000762939453e+01, 2.3460775375366211e+01,
+    1.8936307242256589e-05, 1, -1, 2.2320001220703125e+02, 288.,
+    3.7200000762939453e+01, 9.7413009643554688e+01,
+    5.0320195441599935e-05, 1, -1, 2.4600001525878906e+02, 288.,
+    3.7200000762939453e+01, 9.7351669311523438e+01,
+    3.7273381167324260e-05, 1, -1, 3.3840002441406250e+02, 288.,
+    3.7200000762939453e+01, 1.1121431732177734e+02,
+    5.3417974413605407e-05, 1, -1, 3.4440002441406250e+02, 288.,
+    3.7200000762939453e+01, 1.1483199310302734e+02,
+    5.7212721003452316e-05, 1, -1, 3.5640002441406250e+02, 288.,
+    3.7200000762939453e+01, 1.1191461944580078e+02,
+    1.4544524310622364e-04, 1, -1, 3.6840002441406250e+02, 288.,
+    3.7200000762939453e+01, 1.0040727996826172e+02,
+    2.7840412803925574e-04, 1, -1, 3.7440002441406250e+02, 288.,
+    3.7200000762939453e+01, 9.8937705993652344e+01,
+    9.9458171462174505e-05, 1, -1, 3.9360000610351562e+02, 288.,
+    3.7200000762939453e+01, 8.7368164062500000e+01,
+    6.0998640947218519e-06, 1, -1, 4.0080001831054688e+02, 288.,
+    3.7200000762939453e+01, 1.1201438140869141e+02,
+    3.2724873744882643e-04, 1, -1, 4.0320001220703125e+02, 288.,
+    3.7200000762939453e+01, 1.3875149536132812e+02,
+    4.4478554627858102e-04, 1, -1, 1.2600000762939453e+02,
+    2.8920001220703125e+02, 3.7200000762939453e+01,
+    3.5047943115234375e+02, 2.1957215722068213e-05, 1, -1,
+    1.2840000915527344e+02, 2.8920001220703125e+02,
+    3.7200000762939453e+01, 3.4705868530273438e+02,
+    2.2069520127843134e-05, 1, -1, 1.8240000915527344e+02,
+    2.8920001220703125e+02, 3.7200000762939453e+01,
+    3.3382070922851562e+02, 3.8619342376478016e-05, 1, -1,
+    3.3480001831054688e+02, 2.8920001220703125e+02,
+    3.7200000762939453e+01, 1.0538860321044922e+02,
+    4.2770774598466232e-05, 1, -1, 3.8520001220703125e+02,
+    2.8920001220703125e+02, 3.7200000762939453e+01,
+    9.9106353759765625e+01, 5.4226016800384969e-05, 1, -1,
+    3.9120001220703125e+02, 2.8920001220703125e+02,
+    3.7200000762939453e+01, 9.4845726013183594e+01,
+    8.5688907347503118e-06, 1, -1, 4.2000003051757812e+02,
+    2.8920001220703125e+02, 3.7200000762939453e+01,
+    1.6720651245117188e+02, 2.1150005341041833e-04, 1, -1,
+    4.2240002441406250e+02, 2.8920001220703125e+02,
+    3.7200000762939453e+01, 1.8486911010742188e+02,
+    7.5719915912486613e-05, 1, -1, 1.9080000305175781e+02,
+    2.9040002441406250e+02, 3.7200000762939453e+01,
+    5.1037040710449219e+01, 2.7734495233744383e-05, 1, -1,
+    2.6160000610351562e+02, 2.9040002441406250e+02,
+    3.7200000762939453e+01, 9.9100608825683594e+01,
+    4.7527581045869738e-05, 1, -1, 3.4320001220703125e+02,
+    2.9040002441406250e+02, 3.7200000762939453e+01,
+    1.0964907836914062e+02, 5.2035040425835177e-05, 1, -1, 366.,
+    2.9040002441406250e+02, 3.7200000762939453e+01,
+    1.0019883728027344e+02, 1.9399341545067728e-04, 1, -1,
+    1.4280000305175781e+02, 2.9160000610351562e+02,
+    3.7200000762939453e+01, 2.3198999023437500e+02,
+    1.1299164907541126e-04, 1, -1, 1.6080000305175781e+02,
+    2.9160000610351562e+02, 3.7200000762939453e+01,
+    2.3011073303222656e+02, 2.9871371225453913e-05, 1, -1, 180.,
+    2.9160000610351562e+02, 3.7200000762939453e+01,
+    3.2147109985351562e+02, 3.9709171687718481e-05, 1, -1,
+    2.0040000915527344e+02, 2.9160000610351562e+02,
+    3.7200000762939453e+01, 9.7972732543945312e+01,
+    1.8750117305899039e-05, 1, -1, 2.6880001831054688e+02,
+    2.9160000610351562e+02, 3.7200000762939453e+01,
+    9.8133750915527344e+01, 5.2090432291151956e-05, 1, -1,
+    3.5760000610351562e+02, 2.9160000610351562e+02,
+    3.7200000762939453e+01, 1.0489270019531250e+02,
+    3.0309211069834419e-05, 1, -1, 3.6360000610351562e+02,
+    2.9160000610351562e+02, 3.7200000762939453e+01,
+    9.9920333862304688e+01, 1.0308308264939114e-04, 1, -1,
+    3.6960000610351562e+02, 2.9160000610351562e+02,
+    3.7200000762939453e+01, 9.7881294250488281e+01,
+    1.9736403191927820e-04, 1, -1, 3.7680001831054688e+02,
+    2.9160000610351562e+02, 3.7200000762939453e+01,
+    9.5458717346191406e+01, 1.1012432514689863e-04, 1, -1,
+    4.0680001831054688e+02, 2.9160000610351562e+02,
+    3.7200000762939453e+01, 1.2168370819091797e+02,
+    3.7357182009145617e-04, 1, -1, 4.1040002441406250e+02,
+    2.9160000610351562e+02, 3.7200000762939453e+01,
+    1.1580450439453125e+02, 2.5774165987968445e-04, 1, -1,
+    1.6680000305175781e+02, 2.9280001831054688e+02,
+    3.7200000762939453e+01, 2.4293368530273438e+02,
+    1.7863954417407513e-04, 1, -1, 1.7160000610351562e+02,
+    2.9280001831054688e+02, 3.7200000762939453e+01,
+    2.7901776123046875e+02, 2.4862398277036846e-04, 1, -1,
+    1.8960000610351562e+02, 2.9280001831054688e+02,
+    3.7200000762939453e+01, 1.2321524322032928e-01,
+    3.7778834666823968e-05, 1, -1, 2.0760000610351562e+02,
+    2.9280001831054688e+02, 3.7200000762939453e+01,
+    1.0032387542724609e+02, 1.8682063455344178e-05, 1, -1,
+    2.5440000915527344e+02, 2.9280001831054688e+02,
+    3.7200000762939453e+01, 9.8803993225097656e+01,
+    -3.4528604828665266e-06, 1, -1, 360., 2.9280001831054688e+02,
+    3.7200000762939453e+01, 1.0282647705078125e+02,
+    4.3374544475227594e-05, 1, -1, 366., 2.9280001831054688e+02,
+    3.7200000762939453e+01, 9.8141998291015625e+01,
+    1.2135473662056029e-04, 1, -1, 3.8040002441406250e+02,
+    2.9280001831054688e+02, 3.7200000762939453e+01,
+    9.7145782470703125e+01, 1.9969489585491829e-05, 1, -1,
+    4.0320001220703125e+02, 2.9280001831054688e+02,
+    3.7200000762939453e+01, 1.1783476257324219e+02,
+    5.1735900342464447e-04, 1, -1, 4.2120001220703125e+02,
+    2.9280001831054688e+02, 3.7200000762939453e+01,
+    1.4108302307128906e+02, 4.5836422941647470e-05, 1, -1,
+    1.7640000915527344e+02, 294., 3.7200000762939453e+01,
+    3.0679953002929688e+02, 2.0428236166480929e-04, 1, -1,
+    1.9800001525878906e+02, 294., 3.7200000762939453e+01,
+    8.3804283142089844e+01, 4.2209674575133249e-05, 1, -1,
+    2.1360000610351562e+02, 294., 3.7200000762939453e+01,
+    9.8787185668945312e+01, 2.2103784431237727e-05, 1, -1,
+    2.6040002441406250e+02, 294., 3.7200000762939453e+01,
+    9.8254539489746094e+01, 5.8755129430210218e-05, 1, -1,
+    2.8560000610351562e+02, 294., 3.7200000762939453e+01,
+    1.0176118469238281e+02, 4.0316481317859143e-05, 1, -1,
+    3.6840002441406250e+02, 294., 3.7200000762939453e+01,
+    9.8223175048828125e+01, 1.3143569231033325e-04, 1, -1,
+    3.7320001220703125e+02, 294., 3.7200000762939453e+01,
+    9.6925086975097656e+01, 1.5949546650517732e-04, 1, -1,
+    3.9720001220703125e+02, 294., 3.7200000762939453e+01,
+    1.0090383911132812e+02, 2.3166651953943074e-04, 1, -1,
+    1.2720000457763672e+02, 2.9520001220703125e+02,
+    3.7200000762939453e+01, 3.4103717041015625e+02,
+    2.2460857508121990e-05, 1, -1, 1.2960000610351562e+02,
+    2.9520001220703125e+02, 3.7200000762939453e+01,
+    3.3425067138671875e+02, 1.9723094737855718e-05, 1, -1,
+    1.7280000305175781e+02, 2.9520001220703125e+02,
+    3.7200000762939453e+01, 2.8546038818359375e+02,
+    4.4412235729396343e-04, 1, -1, 2.1840000915527344e+02,
+    2.9520001220703125e+02, 3.7200000762939453e+01,
+    9.8009284973144531e+01, 3.3807296858867630e-05, 1, -1,
+    2.6880001831054688e+02, 2.9520001220703125e+02,
+    3.7200000762939453e+01, 9.9663467407226562e+01,
+    5.4761967476224527e-05, 1, -1, 294., 2.9520001220703125e+02,
+    3.7200000762939453e+01, 9.8592201232910156e+01,
+    3.9702819776721299e-05, 1, -1, 384., 2.9520001220703125e+02,
+    3.7200000762939453e+01, 9.7676704406738281e+01,
+    3.8305963244056329e-05, 1, -1, 3.9240002441406250e+02,
+    2.9520001220703125e+02, 3.7200000762939453e+01,
+    9.8400970458984375e+01, 8.2492100773379207e-05, 1, -1,
+    3.9480001831054688e+02, 2.9520001220703125e+02,
+    3.7200000762939453e+01, 9.9104461669921875e+01,
+    1.1979566625086591e-04, 1, -1, 4.1040002441406250e+02,
+    2.9520001220703125e+02, 3.7200000762939453e+01,
+    1.0589219665527344e+02, 3.3869023900479078e-04, 1, -1,
+    4.2000003051757812e+02, 2.9520001220703125e+02,
+    3.7200000762939453e+01, 1.2655198669433594e+02,
+    1.5686349070165306e-04, 1, -1, 1.4160000610351562e+02,
+    2.9640002441406250e+02, 3.7200000762939453e+01,
+    2.4305154418945312e+02, 4.7228619223460555e-05, 1, -1,
+    1.4520001220703125e+02, 2.9640002441406250e+02,
+    3.7200000762939453e+01, 2.3376589965820312e+02,
+    5.1511407946236432e-05, 1, -1, 2.2800001525878906e+02,
+    2.9640002441406250e+02, 3.7200000762939453e+01,
+    9.7781776428222656e+01, 2.3109392714104615e-05, 1, -1,
+    4.1760000610351562e+02, 2.9640002441406250e+02,
+    3.7200000762939453e+01, 1.1551287841796875e+02,
+    5.0094653852283955e-04, 1, -1, 4.2240002441406250e+02,
+    2.9640002441406250e+02, 3.7200000762939453e+01,
+    1.3557374572753906e+02, 1.0608937736833468e-04, 1, -1,
+    1.5960000610351562e+02, 2.9760000610351562e+02,
+    3.7200000762939453e+01, 2.2060253906250000e+02,
+    1.9432580302236602e-05, 1, -1, 1.6680000305175781e+02,
+    2.9760000610351562e+02, 3.7200000762939453e+01,
+    2.3584722900390625e+02, 2.3998541291803122e-04, 1, -1,
+    2.3640000915527344e+02, 2.9760000610351562e+02,
+    3.7200000762939453e+01, 9.9356765747070312e+01,
+    1.8988946976605803e-05, 1, -1, 2.8560000610351562e+02,
+    2.9760000610351562e+02, 3.7200000762939453e+01,
+    9.8402870178222656e+01, 4.9274793127551675e-05, 1, -1,
+    3.8760000610351562e+02, 2.9760000610351562e+02,
+    3.7200000762939453e+01, 9.8117233276367188e+01,
+    4.1768889786908403e-05, 1, -1, 3.9960000610351562e+02,
+    2.9760000610351562e+02, 3.7200000762939453e+01,
+    1.0978034210205078e+02, 9.0500652731861919e-05, 1, -1, 162.,
+    2.9880001831054688e+02, 3.7200000762939453e+01,
+    2.1748605346679688e+02, 1.0581958486000076e-04, 1, -1,
+    1.7160000610351562e+02, 2.9880001831054688e+02,
+    3.7200000762939453e+01, 2.6936755371093750e+02,
+    3.4320543636567891e-04, 1, -1, 174., 2.9880001831054688e+02,
+    3.7200000762939453e+01, 2.8726666259765625e+02,
+    4.6073083649389446e-04, 1, -1, 2.2560000610351562e+02,
+    2.9880001831054688e+02, 3.7200000762939453e+01,
+    9.7467468261718750e+01, 2.8044454666087404e-05, 1, -1,
+    2.4600001525878906e+02, 2.9880001831054688e+02,
+    3.7200000762939453e+01, 1.0175554656982422e+02,
+    2.9335549697862007e-05, 1, -1, 2.9160000610351562e+02,
+    2.9880001831054688e+02, 3.7200000762939453e+01,
+    1.0104938507080078e+02, 5.6729601055849344e-05, 1, -1, 294.,
+    2.9880001831054688e+02, 3.7200000762939453e+01,
+    1.0308435058593750e+02, 5.5589003750355914e-05, 1, -1, 312.,
+    2.9880001831054688e+02, 3.7200000762939453e+01,
+    9.7346328735351562e+01, 5.9006473748013377e-05, 1, -1,
+    3.9600003051757812e+02, 2.9880001831054688e+02,
+    3.7200000762939453e+01, 1.0363246917724609e+02,
+    6.1431237554643303e-05, 1, -1, 4.0800003051757812e+02,
+    2.9880001831054688e+02, 3.7200000762939453e+01,
+    1.0502326202392578e+02, 7.3101669840980321e-05, 1, -1,
+    4.1760000610351562e+02, 2.9880001831054688e+02,
+    3.7200000762939453e+01, 1.1758766174316406e+02,
+    2.8521683998405933e-04, 1, -1, 1.7640000915527344e+02, 300.,
+    3.7200000762939453e+01, 2.9846984863281250e+02,
+    4.3999982881359756e-04, 1, -1, 1.8120001220703125e+02, 300.,
+    3.7200000762939453e+01, 3.1503100585937500e+02,
+    3.2121106050908566e-04, 1, -1, 2.3520001220703125e+02, 300.,
+    3.7200000762939453e+01, 1.0137678527832031e+02,
+    3.4250693715875968e-05, 1, -1, 2.6160000610351562e+02, 300.,
+    3.7200000762939453e+01, 9.8101737976074219e+01,
+    1.9770785002037883e-05, 1, -1, 2.9880001831054688e+02, 300.,
+    3.7200000762939453e+01, 1.0867430877685547e+02,
+    1.9502129362081178e-05, 1, -1, 3.2040002441406250e+02, 300.,
+    3.7200000762939453e+01, 9.8758895874023438e+01,
+    3.6219083995092660e-05, 1, -1, 4.1520001220703125e+02, 300.,
+    3.7200000762939453e+01, 1.1199844360351562e+02,
+    2.4904511519707739e-04, 1, -1, 4.2120001220703125e+02, 300.,
+    3.7200000762939453e+01, 1.3176882934570312e+02,
+    7.1722555730957538e-05, 1, -1, 1.7880000305175781e+02,
+    3.0120001220703125e+02, 3.7200000762939453e+01,
+    3.0817208862304688e+02, 4.9212080193683505e-04, 1, -1,
+    2.4480000305175781e+02, 3.0120001220703125e+02,
+    3.7200000762939453e+01, 1.0144833374023438e+02,
+    3.8001791835995391e-05, 1, -1, 2.5560000610351562e+02,
+    3.0120001220703125e+02, 3.7200000762939453e+01,
+    9.8847877502441406e+01, 3.8585578295169398e-05, 1, -1, 312.,
+    3.0120001220703125e+02, 3.7200000762939453e+01,
+    9.5962066650390625e+01, 6.4252213633153588e-05, 1, -1,
+    4.1160000610351562e+02, 3.0120001220703125e+02,
+    3.7200000762939453e+01, 1.0555498504638672e+02,
+    9.2034628323744982e-05, 1, -1, 144., 3.0240002441406250e+02,
+    3.7200000762939453e+01, 1.9994729614257812e+02,
+    7.5439915235619992e-05, 1, -1, 1.6680000305175781e+02,
+    3.0240002441406250e+02, 3.7200000762939453e+01,
+    2.1660612487792969e+02, 7.0466048782691360e-05, 1, -1, 264.,
+    3.0240002441406250e+02, 3.7200000762939453e+01,
+    9.8577056884765625e+01, 4.3638283386826515e-05, 1, -1,
+    3.3240002441406250e+02, 3.0240002441406250e+02,
+    3.7200000762939453e+01, 9.8509811401367188e+01,
+    6.8705514422617853e-05, 1, -1, 4.2000003051757812e+02,
+    3.0240002441406250e+02, 3.7200000762939453e+01,
+    1.3086482238769531e+02, 4.8113575758179650e-05, 1, -1,
+    1.7280000305175781e+02, 3.0360000610351562e+02,
+    3.7200000762939453e+01, 2.6501022338867188e+02,
+    7.2879156505223364e-05, 1, -1, 2.7480001831054688e+02,
+    3.0360000610351562e+02, 3.7200000762939453e+01,
+    9.9592437744140625e+01, 2.4740495064179413e-05, 1, -1,
+    3.4080001831054688e+02, 3.0360000610351562e+02,
+    3.7200000762939453e+01, 9.9089118957519531e+01,
+    7.2372626163996756e-05, 1, -1, 1.8360000610351562e+02,
+    3.0480001831054688e+02, 3.7200000762939453e+01,
+    3.1450631713867188e+02, 3.6167647340334952e-04, 1, -1,
+    2.6280001831054688e+02, 3.0480001831054688e+02,
+    3.7200000762939453e+01, 9.9722793579101562e+01,
+    5.2165782108204439e-05, 1, -1, 2.8320001220703125e+02,
+    3.0480001831054688e+02, 3.7200000762939453e+01,
+    1.2705440521240234e+02, 3.5975419450551271e-05, 1, -1,
+    3.3240002441406250e+02, 3.0480001831054688e+02,
+    3.7200000762939453e+01, 9.7280151367187500e+01,
+    6.7837267124559730e-05, 1, -1, 162., 306., 3.7200000762939453e+01,
+    1.8978611755371094e+02, 5.8510682720225304e-05, 1, -1,
+    1.7520001220703125e+02, 306., 3.7200000762939453e+01,
+    2.8013125610351562e+02, 5.4558815463678911e-05, 1, -1,
+    2.7240002441406250e+02, 306., 3.7200000762939453e+01,
+    9.9878143310546875e+01, 3.1936098821461201e-05, 1, -1,
+    2.8920001220703125e+02, 306., 3.7200000762939453e+01,
+    1.4342639160156250e+02, 3.9514394302386791e-05, 1, -1,
+    2.9160000610351562e+02, 306., 3.7200000762939453e+01,
+    1.5369416809082031e+02, 4.0257516957353801e-05, 1, -1,
+    3.4080001831054688e+02, 306., 3.7200000762939453e+01,
+    9.9976943969726562e+01, 6.8858527811244130e-05, 1, -1,
+    3.5760000610351562e+02, 306., 3.7200000762939453e+01,
+    1.0114599609375000e+02, 6.3568979385308921e-05, 1, -1,
+    3.6120001220703125e+02, 306., 3.7200000762939453e+01,
+    1.0144754028320312e+02, 5.7282406487502158e-05, 1, -1,
+    1.2960000610351562e+02, 3.0720001220703125e+02,
+    3.7200000762939453e+01, 3.4912857055664062e+02,
+    1.0415346878289711e-05, 1, -1, 144., 3.0720001220703125e+02,
+    3.7200000762939453e+01, 1.5462310791015625e+02,
+    7.9242767242249101e-05, 1, -1, 1.8840000915527344e+02,
+    3.0720001220703125e+02, 3.7200000762939453e+01,
+    3.1076599121093750e+02, 1.1224580521229655e-04, 1, -1, 282.,
+    3.0720001220703125e+02, 3.7200000762939453e+01,
+    1.3448930358886719e+02, 3.4807755582733080e-05, 1, -1,
+    2.9760000610351562e+02, 3.0720001220703125e+02,
+    3.7200000762939453e+01, 1.9992572021484375e+02,
+    4.0919931052485481e-05, 1, -1, 366., 3.0720001220703125e+02,
+    3.7200000762939453e+01, 9.9046737670898438e+01,
+    5.2401686843950301e-05, 1, -1, 4.2720001220703125e+02,
+    3.0720001220703125e+02, 3.7200000762939453e+01,
+    1.5647152709960938e+02, 5.6350745580857620e-05, 1, -1, 132.,
+    3.0840002441406250e+02, 3.7200000762939453e+01,
+    3.4422503662109375e+02, 1.6455589502584189e-05, 1, -1,
+    1.4760000610351562e+02, 3.0840002441406250e+02,
+    3.7200000762939453e+01, 1.3401515197753906e+02,
+    1.0721766739152372e-04, 1, -1, 180., 3.0840002441406250e+02,
+    3.7200000762939453e+01, 3.0145309448242188e+02,
+    3.8822825445095077e-05, 1, -1, 186., 3.0840002441406250e+02,
+    3.7200000762939453e+01, 3.0969171142578125e+02,
+    1.9332069496158510e-04, 1, -1, 2.9040002441406250e+02,
+    3.0840002441406250e+02, 3.7200000762939453e+01,
+    1.5115156555175781e+02, 7.1608345024287701e-05, 1, -1,
+    3.0240002441406250e+02, 3.0840002441406250e+02,
+    3.7200000762939453e+01, 2.2571055603027344e+02,
+    5.7829543948173523e-05, 1, -1, 3.5760000610351562e+02,
+    3.0840002441406250e+02, 3.7200000762939453e+01,
+    1.0014259338378906e+02, 6.4437619585078210e-05, 1, -1,
+    3.0480001831054688e+02, 3.0960000610351562e+02,
+    3.7200000762939453e+01, 2.3569940185546875e+02,
+    4.8835339839570224e-05, 1, -1, 312., 3.0960000610351562e+02,
+    3.7200000762939453e+01, 2.9991955566406250e+02,
+    2.8988306439714506e-05, 1, -1, 3.6240002441406250e+02,
+    3.0960000610351562e+02, 3.7200000762939453e+01,
+    9.8609527587890625e+01, 4.8996997065842152e-05, 1, -1, 366.,
+    3.0960000610351562e+02, 3.7200000762939453e+01,
+    9.9056427001953125e+01, 5.4889664170332253e-05, 1, -1, 384.,
+    3.0960000610351562e+02, 3.7200000762939453e+01,
+    9.7809051513671875e+01, 7.1419650339521468e-05, 1, -1,
+    4.2360000610351562e+02, 3.0960000610351562e+02,
+    3.7200000762939453e+01, 1.5104962158203125e+02,
+    1.4900436508469284e-04, 1, -1, 1.3320001220703125e+02,
+    3.1080001831054688e+02, 3.7200000762939453e+01,
+    3.4191436767578125e+02, 1.6250749467872083e-05, 1, -1, 162.,
+    3.1080001831054688e+02, 3.7200000762939453e+01,
+    1.7319377136230469e+02, 2.7003345167031512e-05, 1, -1,
+    1.6440000915527344e+02, 3.1080001831054688e+02,
+    3.7200000762939453e+01, 1.7685675048828125e+02,
+    1.1139315029140562e-04, 1, -1, 1.9440000915527344e+02,
+    3.1080001831054688e+02, 3.7200000762939453e+01,
+    3.0001153564453125e+02, 1.3213187048677355e-04, 1, -1,
+    3.0120001220703125e+02, 3.1080001831054688e+02,
+    3.7200000762939453e+01, 2.0888401794433594e+02,
+    9.0555273345671594e-05, 1, -1, 3.2160000610351562e+02,
+    3.1080001831054688e+02, 3.7200000762939453e+01,
+    1.2004157066345215e+01, 2.0658415451180190e-05, 1, -1,
+    3.7920001220703125e+02, 3.1080001831054688e+02,
+    3.7200000762939453e+01, 9.6692077636718750e+01,
+    2.9946073482278734e-05, 1, -1, 3.9240002441406250e+02,
+    3.1080001831054688e+02, 3.7200000762939453e+01,
+    1.0317276000976562e+02, 5.1139952120138332e-05, 1, -1,
+    1.8360000610351562e+02, 312., 3.7200000762939453e+01,
+    3.0524172973632812e+02, 4.4941156374989077e-05, 1, -1, 192., 312.,
+    3.7200000762939453e+01, 3.0268664550781250e+02,
+    1.9592227181419730e-04, 1, -1, 3.0960000610351562e+02, 312.,
+    3.7200000762939453e+01, 2.8121777343750000e+02,
+    5.7057110097957775e-05, 1, -1, 3.2640002441406250e+02, 312.,
+    3.7200000762939453e+01, 5.4049457550048828e+01,
+    2.0086132280994207e-05, 1, -1, 1.3080000305175781e+02,
+    3.1320001220703125e+02, 3.7200000762939453e+01,
+    3.4329196166992188e+02, 1.4768966138944961e-05, 1, -1,
+    1.4520001220703125e+02, 3.1320001220703125e+02,
+    3.7200000762939453e+01, 1.1125754547119141e+02,
+    9.3801245384383947e-05, 1, -1, 1.4760000610351562e+02,
+    3.1320001220703125e+02, 3.7200000762939453e+01,
+    1.0528756713867188e+02, 1.5384421567432582e-04, 1, -1,
+    1.6920001220703125e+02, 3.1320001220703125e+02,
+    3.7200000762939453e+01, 1.7384370422363281e+02,
+    4.4818360038334504e-05, 1, -1, 1.8960000610351562e+02,
+    3.1320001220703125e+02, 3.7200000762939453e+01,
+    3.0480023193359375e+02, 1.3173572369851172e-04, 1, -1,
+    2.0160000610351562e+02, 3.1320001220703125e+02,
+    3.7200000762939453e+01, 2.8699603271484375e+02,
+    -2.3319084903050680e-06, 1, -1, 2.0880000305175781e+02,
+    3.1320001220703125e+02, 3.7200000762939453e+01,
+    2.8010665893554688e+02, 1.2304798292461783e-04, 1, -1,
+    2.9640002441406250e+02, 3.1320001220703125e+02,
+    3.7200000762939453e+01, 2.0680657958984375e+02,
+    1.9460316980257630e-04, 1, -1, 3.1920001220703125e+02,
+    3.1320001220703125e+02, 3.7200000762939453e+01,
+    3.4432513427734375e+02, 3.0782368412474170e-05, 1, -1,
+    3.3480001831054688e+02, 3.1320001220703125e+02,
+    3.7200000762939453e+01, 8.0252433776855469e+01,
+    2.6663206881494261e-05, 1, -1, 3.8280001831054688e+02,
+    3.1320001220703125e+02, 3.7200000762939453e+01,
+    9.3567077636718750e+01, 6.9287329097278416e-05, 1, -1,
+    3.8760000610351562e+02, 3.1320001220703125e+02,
+    3.7200000762939453e+01, 9.6429313659667969e+01,
+    8.4647501353174448e-05, 1, -1, 4.0920001220703125e+02,
+    3.1320001220703125e+02, 3.7200000762939453e+01,
+    1.1232232666015625e+02, 5.1478829846018925e-05, 1, -1,
+    1.3320001220703125e+02, 3.1440002441406250e+02,
+    3.7200000762939453e+01, 3.3800234985351562e+02,
+    1.2910520126752090e-05, 1, -1, 1.7640000915527344e+02,
+    3.1440002441406250e+02, 3.7200000762939453e+01,
+    2.1545051574707031e+02, 4.5712964492850006e-05, 1, -1,
+    1.9920001220703125e+02, 3.1440002441406250e+02,
+    3.7200000762939453e+01, 2.8984527587890625e+02,
+    3.0153114494169131e-05, 1, -1, 2.1240000915527344e+02,
+    3.1440002441406250e+02, 3.7200000762939453e+01,
+    2.7953735351562500e+02, 5.6224802392534912e-05, 1, -1,
+    3.9240002441406250e+02, 3.1440002441406250e+02,
+    3.7200000762939453e+01, 1.0512287139892578e+02,
+    4.1032009903574362e-05, 1, -1, 4.1400003051757812e+02,
+    3.1440002441406250e+02, 3.7200000762939453e+01,
+    1.3362350463867188e+02, 1.0775717964861542e-04, 1, -1,
+    4.2600003051757812e+02, 3.1440002441406250e+02,
+    3.7200000762939453e+01, 1.6227624511718750e+02,
+    -5.7244096751674078e-06, 1, -1, 1.7880000305175781e+02,
+    3.1560000610351562e+02, 3.7200000762939453e+01,
+    2.5629345703125000e+02, 3.3887041354319081e-05, 1, -1,
+    2.1000001525878906e+02, 3.1560000610351562e+02,
+    3.7200000762939453e+01, 2.7938421630859375e+02,
+    2.2358045680448413e-04, 1, -1, 3.5280001831054688e+02,
+    3.1560000610351562e+02, 3.7200000762939453e+01,
+    9.5758804321289062e+01, 2.4881619538064115e-05, 1, -1,
+    4.1760000610351562e+02, 3.1560000610351562e+02,
+    3.7200000762939453e+01, 1.4936380004882812e+02,
+    1.1747014650609344e-04, 1, -1, 4.2840002441406250e+02,
+    3.1560000610351562e+02, 3.7200000762939453e+01,
+    1.6605731201171875e+02, -7.5588839536067098e-05, 1, -1,
+    1.4880000305175781e+02, 3.1680001831054688e+02,
+    3.7200000762939453e+01, 1.0035498809814453e+02,
+    1.0631258192006499e-04, 1, -1, 1.9800001525878906e+02,
+    3.1680001831054688e+02, 3.7200000762939453e+01,
+    2.9037298583984375e+02, 2.2907292077434249e-05, 1, -1,
+    2.0640000915527344e+02, 3.1680001831054688e+02,
+    3.7200000762939453e+01, 2.7927905273437500e+02,
+    2.0453521574381739e-04, 1, -1, 2.1240000915527344e+02,
+    3.1680001831054688e+02, 3.7200000762939453e+01,
+    2.7952999877929688e+02, 1.7781477072276175e-04, 1, -1,
+    2.2080000305175781e+02, 3.1680001831054688e+02,
+    3.7200000762939453e+01, 2.8171777343750000e+02,
+    1.5327362052630633e-04, 1, -1, 3.3840002441406250e+02,
+    3.1680001831054688e+02, 3.7200000762939453e+01,
+    7.9092239379882812e+01, 3.9878355892142281e-05, 1, -1, 360.,
+    3.1680001831054688e+02, 3.7200000762939453e+01,
+    9.7903785705566406e+01, 2.6284875275450759e-05, 1, -1,
+    4.0800003051757812e+02, 3.1680001831054688e+02,
+    3.7200000762939453e+01, 1.1451504516601562e+02,
+    5.6181292166002095e-05, 1, -1, 1.6440000915527344e+02, 318.,
+    3.7200000762939453e+01, 1.6010711669921875e+02,
+    4.5485434384318069e-05, 1, -1, 2.2440000915527344e+02, 318.,
+    3.7200000762939453e+01, 2.8508062744140625e+02,
+    4.8605771735310555e-04, 1, -1, 2.2800001525878906e+02, 318.,
+    3.7200000762939453e+01, 2.8705908203125000e+02,
+    2.8380783624015749e-04, 1, -1, 3.0840002441406250e+02, 318.,
+    3.7200000762939453e+01, 2.6979251098632812e+02,
+    5.4702082707080990e-05, 1, -1, 3.1560000610351562e+02, 318.,
+    3.7200000762939453e+01, 3.4717663574218750e+02,
+    8.3504324720706791e-05, 1, -1, 3.4680001831054688e+02, 318.,
+    3.7200000762939453e+01, 8.0443702697753906e+01,
+    4.3221123632974923e-05, 1, -1, 366., 318., 3.7200000762939453e+01,
+    1.0827853393554688e+02, 2.8821354135288857e-05, 1, -1,
+    4.1400003051757812e+02, 318., 3.7200000762939453e+01,
+    1.5017291259765625e+02, 1.9120519573334605e-04, 1, -1,
+    4.1760000610351562e+02, 318., 3.7200000762939453e+01,
+    1.5835620117187500e+02, 1.5219674969557673e-04, 1, -1,
+    1.7280000305175781e+02, 3.1920001220703125e+02,
+    3.7200000762939453e+01, 1.4473437500000000e+02,
+    1.9920984414056875e-05, 1, -1, 1.8120001220703125e+02,
+    3.1920001220703125e+02, 3.7200000762939453e+01,
+    9.0758689880371094e+01, 2.5094363081734627e-05, 1, -1,
+    2.0280000305175781e+02, 3.1920001220703125e+02,
+    3.7200000762939453e+01, 2.8104605102539062e+02,
+    6.0392922023311257e-05, 1, -1, 2.1480000305175781e+02,
+    3.1920001220703125e+02, 3.7200000762939453e+01,
+    2.7832962036132812e+02, 1.0112398013006896e-04, 1, -1,
+    3.5640002441406250e+02, 3.1920001220703125e+02,
+    3.7200000762939453e+01, 9.4958000183105469e+01,
+    3.6880930565530434e-05, 1, -1, 3.6960000610351562e+02,
+    3.1920001220703125e+02, 3.7200000762939453e+01,
+    1.1656272888183594e+02, 4.3388161429902539e-05, 1, -1,
+    3.7560000610351562e+02, 3.1920001220703125e+02,
+    3.7200000762939453e+01, 1.2950964355468750e+02,
+    5.0788330554496497e-05, 1, -1, 3.8160000610351562e+02,
+    3.1920001220703125e+02, 3.7200000762939453e+01,
+    1.4449488830566406e+02, 1.6096326362458058e-05, 1, -1,
+    1.8960000610351562e+02, 3.2040002441406250e+02,
+    3.7200000762939453e+01, 3.4506372070312500e+02,
+    5.6912642321549356e-05, 1, -1, 2.2080000305175781e+02,
+    3.2040002441406250e+02, 3.7200000762939453e+01,
+    2.8127352905273438e+02, 2.3230840452015400e-04, 1, -1,
+    2.3280000305175781e+02, 3.2040002441406250e+02,
+    3.7200000762939453e+01, 2.9038833618164062e+02,
+    3.2495041523361579e-05, 1, -1, 294., 3.2040002441406250e+02,
+    3.7200000762939453e+01, 2.3268437194824219e+02,
+    2.5349098723381758e-04, 1, -1, 312., 3.2040002441406250e+02,
+    3.7200000762939453e+01, 3.5844039916992188e+02,
+    7.8031524026300758e-05, 1, -1, 3.2040002441406250e+02,
+    3.2040002441406250e+02, 3.7200000762939453e+01,
+    3.5447622680664062e+02, 4.5355172915151343e-05, 1, -1,
+    2.0400001525878906e+02, 3.2160000610351562e+02,
+    3.7200000762939453e+01, 2.7794421386718750e+02,
+    4.1849049011943862e-05, 1, -1, 2.3640000915527344e+02,
+    3.2160000610351562e+02, 3.7200000762939453e+01,
+    2.9222265625000000e+02, 9.1086600150447339e-05, 1, -1,
+    2.8920001220703125e+02, 3.2160000610351562e+02,
+    3.7200000762939453e+01, 2.3006950378417969e+02,
+    2.1039295825175941e-04, 1, -1, 3.0840002441406250e+02,
+    3.2160000610351562e+02, 3.7200000762939453e+01,
+    3.3262185668945312e+02, 1.2379034887999296e-04, 1, -1,
+    3.1560000610351562e+02, 3.2160000610351562e+02,
+    3.7200000762939453e+01, 2.8175961971282959e+00,
+    7.2177892434410751e-05, 1, -1, 3.8040002441406250e+02,
+    3.2160000610351562e+02, 3.7200000762939453e+01,
+    1.4767903137207031e+02, 4.7632900532335043e-05, 1, -1,
+    4.1400003051757812e+02, 3.2160000610351562e+02,
+    3.7200000762939453e+01, 1.7390721130371094e+02,
+    9.7900745458900928e-05, 1, -1, 4.1760000610351562e+02,
+    3.2160000610351562e+02, 3.7200000762939453e+01,
+    1.7037594604492188e+02, 1.0717558325268328e-04, 1, -1, 150.,
+    3.2280001831054688e+02, 3.7200000762939453e+01,
+    2.6729144287109375e+02, 3.8686626794515178e-05, 1, -1,
+    1.9080000305175781e+02, 3.2280001831054688e+02,
+    3.7200000762939453e+01, 4.4828395843505859e+01,
+    5.6570836022729054e-05, 1, -1, 2.2440000915527344e+02,
+    3.2280001831054688e+02, 3.7200000762939453e+01,
+    2.8640307617187500e+02, 1.3617430522572249e-04, 1, -1,
+    2.9160000610351562e+02, 3.2280001831054688e+02,
+    3.7200000762939453e+01, 2.2382603454589844e+02,
+    2.2691416961606592e-04, 1, -1, 2.9640002441406250e+02,
+    3.2280001831054688e+02, 3.7200000762939453e+01,
+    2.4017547607421875e+02, 3.4585664252517745e-05, 1, -1,
+    1.6560000610351562e+02, 324., 3.7200000762939453e+01,
+    1.4534695434570312e+02, 5.0572158215800300e-05, 1, -1,
+    1.8480000305175781e+02, 324., 3.7200000762939453e+01,
+    9.0578765869140625e+01, 1.0180061508435756e-04, 1, -1,
+    1.9560000610351562e+02, 324., 3.7200000762939453e+01,
+    6.7790306091308594e+01, 1.2385754962451756e-04, 1, -1,
+    2.1480000305175781e+02, 324., 3.7200000762939453e+01,
+    2.7481555175781250e+02, 1.5681983495596796e-04, 1, -1,
+    2.1720001220703125e+02, 324., 3.7200000762939453e+01,
+    2.7777038574218750e+02, 7.5484844273887575e-05, 1, -1,
+    2.8080001831054688e+02, 324., 3.7200000762939453e+01,
+    2.3412731933593750e+02, 7.9459008702542633e-05, 1, -1, 312., 324.,
+    3.7200000762939453e+01, 2.7728086471557617e+01,
+    7.2985356382559985e-05, 1, -1, 378., 324., 3.7200000762939453e+01,
+    1.4958786010742188e+02, 1.1498889216454700e-04, 1, -1,
+    3.8040002441406250e+02, 324., 3.7200000762939453e+01,
+    1.5123472595214844e+02, 7.0579495513811707e-05, 1, -1, 150.,
+    3.2520001220703125e+02, 3.7200000762939453e+01,
+    2.7882446289062500e+02, 2.5565488613210618e-05, 1, -1,
+    1.7160000610351562e+02, 3.2520001220703125e+02,
+    3.7200000762939453e+01, 1.3394558715820312e+02,
+    1.8797368102241307e-04, 1, -1, 2.3280000305175781e+02,
+    3.2520001220703125e+02, 3.7200000762939453e+01,
+    2.9255807495117188e+02, 2.4440881679765880e-04, 1, -1,
+    3.0240002441406250e+02, 3.2520001220703125e+02,
+    3.7200000762939453e+01, 3.4269403076171875e+02,
+    1.5873085067141801e-04, 1, -1, 3.0840002441406250e+02,
+    3.2520001220703125e+02, 3.7200000762939453e+01,
+    3.0904392242431641e+01, 1.1214831465622410e-04, 1, -1,
+    3.7440002441406250e+02, 3.2520001220703125e+02,
+    3.7200000762939453e+01, 1.5122851562500000e+02,
+    6.7616478190757334e-05, 1, -1, 4.1520001220703125e+02,
+    3.2520001220703125e+02, 3.7200000762939453e+01,
+    1.8911387634277344e+02, 2.8898015443701297e-05, 1, -1,
+    1.3320001220703125e+02, 3.2640002441406250e+02,
+    3.7200000762939453e+01, 3.1456359863281250e+02,
+    1.1852596799144521e-05, 1, -1, 1.3680000305175781e+02,
+    3.2640002441406250e+02, 3.7200000762939453e+01,
+    3.0535662841796875e+02, 2.0791119823115878e-05, 1, -1, 192.,
+    3.2640002441406250e+02, 3.7200000762939453e+01,
+    8.7809585571289062e+01, 7.2805276431608945e-05, 1, -1,
+    2.4480000305175781e+02, 3.2640002441406250e+02,
+    3.7200000762939453e+01, 2.9251135253906250e+02,
+    7.5156618549954146e-05, 1, -1, 2.6760000610351562e+02,
+    3.2640002441406250e+02, 3.7200000762939453e+01,
+    2.7305761718750000e+02, 1.0231839405605569e-04, 1, -1,
+    2.7120001220703125e+02, 3.2640002441406250e+02,
+    3.7200000762939453e+01, 2.6761706542968750e+02,
+    4.5258778845891356e-04, 1, -1, 2.7960000610351562e+02,
+    3.2640002441406250e+02, 3.7200000762939453e+01,
+    2.4874169921875000e+02, 1.5830475604161620e-04, 1, -1,
+    2.9520001220703125e+02, 3.2640002441406250e+02,
+    3.7200000762939453e+01, 2.2067712402343750e+02,
+    6.3937572122085840e-05, 1, -1, 3.0480001831054688e+02,
+    3.2640002441406250e+02, 3.7200000762939453e+01,
+    2.8078735351562500e+01, 1.1999114212812856e-04, 1, -1,
+    3.1440002441406250e+02, 3.2640002441406250e+02,
+    3.7200000762939453e+01, 2.1147716522216797e+01,
+    3.7081856135046110e-05, 1, -1, 1.9440000915527344e+02,
+    3.2760000610351562e+02, 3.7200000762939453e+01,
+    9.3601936340332031e+01, 6.6181237343698740e-05, 1, -1,
+    2.1120001220703125e+02, 3.2760000610351562e+02,
+    3.7200000762939453e+01, 1.3879342651367188e+02,
+    2.6688104844652116e-04, 1, -1, 2.3160000610351562e+02,
+    3.2760000610351562e+02, 3.7200000762939453e+01,
+    2.9515466308593750e+02, 1.6089505515992641e-04, 1, -1,
+    2.3520001220703125e+02, 3.2760000610351562e+02,
+    3.7200000762939453e+01, 2.9624176025390625e+02,
+    1.6046354721765965e-04, 1, -1, 2.4960000610351562e+02,
+    3.2760000610351562e+02, 3.7200000762939453e+01,
+    2.9059930419921875e+02, 3.4071845584549010e-04, 1, -1,
+    2.5320001220703125e+02, 3.2760000610351562e+02,
+    3.7200000762939453e+01, 2.8986154174804688e+02,
+    2.4161879264283925e-04, 1, -1, 288., 3.2760000610351562e+02,
+    3.7200000762939453e+01, 2.4041139221191406e+02,
+    2.1755234047304839e-04, 1, -1, 3.1680001831054688e+02,
+    3.2760000610351562e+02, 3.7200000762939453e+01,
+    8.3389625549316406e+00, 1.1860768609039951e-05, 1, -1, 336.,
+    3.2760000610351562e+02, 3.7200000762939453e+01,
+    3.4561593627929688e+02, 1.4742878192919306e-05, 1, -1,
+    3.8040002441406250e+02, 3.2760000610351562e+02,
+    3.7200000762939453e+01, 1.6989122009277344e+02,
+    4.1261289879912511e-05, 1, -1, 1.3440000915527344e+02,
+    3.2880001831054688e+02, 3.7200000762939453e+01,
+    3.0895974731445312e+02, 2.1359504899010062e-05, 1, -1,
+    1.6560000610351562e+02, 3.2880001831054688e+02,
+    3.7200000762939453e+01, 1.5760954284667969e+02,
+    2.1027781258453615e-05, 1, -1, 168., 3.2880001831054688e+02,
+    3.7200000762939453e+01, 1.4922967529296875e+02,
+    7.0652160502504557e-05, 1, -1, 1.7760000610351562e+02,
+    3.2880001831054688e+02, 3.7200000762939453e+01,
+    1.1465456390380859e+02, 5.3203515562927350e-05, 1, -1,
+    1.8360000610351562e+02, 3.2880001831054688e+02,
+    3.7200000762939453e+01, 9.8970756530761719e+01,
+    5.4257187002804130e-05, 1, -1, 1.8960000610351562e+02,
+    3.2880001831054688e+02, 3.7200000762939453e+01,
+    9.1196800231933594e+01, 2.5889679818646982e-05, 1, -1,
+    2.0520001220703125e+02, 3.2880001831054688e+02,
+    3.7200000762939453e+01, 1.1092904663085938e+02,
+    3.3683839137665927e-04, 1, -1, 2.0760000610351562e+02,
+    3.2880001831054688e+02, 3.7200000762939453e+01,
+    1.1365760803222656e+02, 2.5825502234511077e-04, 1, -1,
+    2.1960000610351562e+02, 3.2880001831054688e+02,
+    3.7200000762939453e+01, 1.1185604095458984e+02,
+    1.2721042730845511e-04, 1, -1, 2.8080001831054688e+02,
+    3.2880001831054688e+02, 3.7200000762939453e+01,
+    2.5746444702148438e+02, 1.7646880587562919e-04, 1, -1,
+    3.0120001220703125e+02, 3.2880001831054688e+02,
+    3.7200000762939453e+01, 2.8515321731567383e+01,
+    1.1452264880063012e-04, 1, -1, 306., 3.2880001831054688e+02,
+    3.7200000762939453e+01, 3.9007671356201172e+01,
+    5.9633093769662082e-05, 1, -1, 3.1080001831054688e+02,
+    3.2880001831054688e+02, 3.7200000762939453e+01,
+    2.9846307754516602e+01, 3.5092252801405266e-05, 1, -1,
+    3.3240002441406250e+02, 3.2880001831054688e+02,
+    3.7200000762939453e+01, 3.2573446655273438e+02,
+    1.6067140677478164e-05, 1, -1, 3.9960000610351562e+02,
+    3.2880001831054688e+02, 3.7200000762939453e+01,
+    2.2242028808593750e+02, 1.3842602493241429e-04, 1, -1,
+    1.3680000305175781e+02, 330., 3.7200000762939453e+01,
+    3.0130648803710938e+02, 2.7146481443196535e-05, 1, -1,
+    1.7280000305175781e+02, 330., 3.7200000762939453e+01,
+    1.3260763549804688e+02, 7.0622831117361784e-05, 1, -1,
+    2.1240000915527344e+02, 330., 3.7200000762939453e+01,
+    1.1089655303955078e+02, 2.4516845587641001e-04, 1, -1,
+    2.2200001525878906e+02, 330., 3.7200000762939453e+01,
+    9.9253875732421875e+01, 1.2953071563970298e-04, 1, -1,
+    2.3520001220703125e+02, 330., 3.7200000762939453e+01,
+    3.0083712768554688e+02, 6.8059016484767199e-05, 1, -1,
+    2.5560000610351562e+02, 330., 3.7200000762939453e+01,
+    2.8831414794921875e+02, 3.1868732185102999e-04, 1, -1, 324., 330.,
+    3.7200000762939453e+01, 3.2179492187500000e+02,
+    3.4512144338805228e-05, 1, -1, 3.4080001831054688e+02, 330.,
+    3.7200000762939453e+01, 3.3990808105468750e+02,
+    9.9204889920656569e-06, 1, -1, 1.4160000610351562e+02,
+    3.3120001220703125e+02, 3.7200000762939453e+01,
+    2.8875906372070312e+02, 2.3460524971596897e-05, 1, -1,
+    1.6920001220703125e+02, 3.3120001220703125e+02,
+    3.7200000762939453e+01, 1.5481802368164062e+02,
+    1.9430761312833056e-05, 1, -1, 2.0280000305175781e+02,
+    3.3120001220703125e+02, 3.7200000762939453e+01,
+    1.0530342102050781e+02, 2.5647017173469067e-04, 1, -1,
+    2.3160000610351562e+02, 3.3120001220703125e+02,
+    3.7200000762939453e+01, 3.3795678710937500e+02,
+    7.6155149145051837e-05, 1, -1, 2.4240000915527344e+02,
+    3.3120001220703125e+02, 3.7200000762939453e+01,
+    3.0148483276367188e+02, 9.5856761618051678e-05, 1, -1,
+    2.5080000305175781e+02, 3.3120001220703125e+02,
+    3.7200000762939453e+01, 2.9370129394531250e+02,
+    3.1995316385291517e-04, 1, -1, 258., 3.3120001220703125e+02,
+    3.7200000762939453e+01, 2.8845196533203125e+02,
+    1.8446192552801222e-04, 1, -1, 2.6040002441406250e+02,
+    3.3120001220703125e+02, 3.7200000762939453e+01,
+    2.8678265380859375e+02, 1.6391793906223029e-04, 1, -1, 288.,
+    3.3120001220703125e+02, 3.7200000762939453e+01,
+    2.6144500732421875e+02, 1.4877495414111763e-04, 1, -1,
+    2.9640002441406250e+02, 3.3120001220703125e+02,
+    3.7200000762939453e+01, 6.8583984375000000e+01,
+    7.7583434176631272e-05, 1, -1, 300., 3.3120001220703125e+02,
+    3.7200000762939453e+01, 5.6875663757324219e+01,
+    1.5140372852329165e-04, 1, -1, 3.1680001831054688e+02,
+    3.3120001220703125e+02, 3.7200000762939453e+01,
+    1.8879751205444336e+01, 1.2787447303708177e-05, 1, -1,
+    3.9720001220703125e+02, 3.3120001220703125e+02,
+    3.7200000762939453e+01, 2.4740640258789062e+02,
+    9.9116194178350270e-05, 1, -1, 138., 3.3240002441406250e+02,
+    3.7200000762939453e+01, 2.9527386474609375e+02,
+    4.8543523007538170e-05, 1, -1, 1.7880000305175781e+02,
+    3.3240002441406250e+02, 3.7200000762939453e+01,
+    1.0812068176269531e+02, 1.4156787983665708e-05, 1, -1,
+    2.0760000610351562e+02, 3.3240002441406250e+02,
+    3.7200000762939453e+01, 1.0651489257812500e+02,
+    1.2710067676380277e-04, 1, -1, 2.1720001220703125e+02,
+    3.3240002441406250e+02, 3.7200000762939453e+01,
+    1.0335374450683594e+02, 2.0437747298274189e-04, 1, -1,
+    2.2920001220703125e+02, 3.3240002441406250e+02,
+    3.7200000762939453e+01, 9.3613914489746094e+01,
+    6.6169144702143967e-05, 1, -1, 2.3760000610351562e+02,
+    3.3240002441406250e+02, 3.7200000762939453e+01,
+    3.2524398803710938e+02, 4.5297489123186097e-05, 1, -1,
+    2.4480000305175781e+02, 3.3240002441406250e+02,
+    3.7200000762939453e+01, 3.0011981201171875e+02,
+    1.1087692837463692e-04, 1, -1, 2.5560000610351562e+02,
+    3.3240002441406250e+02, 3.7200000762939453e+01,
+    2.9149578857421875e+02, 2.3582512221764773e-04, 1, -1, 270.,
+    3.3240002441406250e+02, 3.7200000762939453e+01,
+    2.8534338378906250e+02, 8.7212829384952784e-05, 1, -1,
+    2.7360000610351562e+02, 3.3240002441406250e+02,
+    3.7200000762939453e+01, 2.7652645874023438e+02,
+    6.7953405959997326e-05, 1, -1, 2.9040002441406250e+02,
+    3.3240002441406250e+02, 3.7200000762939453e+01,
+    2.6783569335937500e+02, 1.3937201583757997e-04, 1, -1,
+    3.2040002441406250e+02, 3.3240002441406250e+02,
+    3.7200000762939453e+01, 3.3165005493164062e+02,
+    3.4664124541450292e-05, 1, -1, 1.4160000610351562e+02,
+    3.3360000610351562e+02, 3.7200000762939453e+01,
+    2.8835241699218750e+02, 5.2528375817928463e-05, 1, -1,
+    1.8360000610351562e+02, 3.3360000610351562e+02,
+    3.7200000762939453e+01, 9.5097328186035156e+01,
+    1.4635833395004738e-05, 1, -1, 1.9440000915527344e+02,
+    3.3360000610351562e+02, 3.7200000762939453e+01,
+    9.7890808105468750e+01, 2.5016557628987357e-05, 1, -1,
+    2.2680000305175781e+02, 3.3360000610351562e+02,
+    3.7200000762939453e+01, 1.0331128692626953e+02,
+    1.0299239511368796e-04, 1, -1, 258., 3.3360000610351562e+02,
+    3.7200000762939453e+01, 2.9271893310546875e+02,
+    1.8368742894381285e-04, 1, -1, 2.6160000610351562e+02,
+    3.3360000610351562e+02, 3.7200000762939453e+01,
+    2.8956320190429688e+02, 3.2673383248038590e-04, 1, -1, 330.,
+    3.3360000610351562e+02, 3.7200000762939453e+01,
+    3.0233847045898438e+02, 2.1533474864554591e-05, 1, -1, 156.,
+    3.3480001831054688e+02, 3.7200000762939453e+01,
+    2.8200775146484375e+02, 2.9335442377487198e-05, 1, -1,
+    2.0280000305175781e+02, 3.3480001831054688e+02,
+    3.7200000762939453e+01, 1.0255816650390625e+02,
+    6.0836868215119466e-05, 1, -1, 2.1120001220703125e+02,
+    3.3480001831054688e+02, 3.7200000762939453e+01,
+    1.0477589416503906e+02, 4.5520766434492543e-05, 1, -1,
+    2.1960000610351562e+02, 3.3480001831054688e+02,
+    3.7200000762939453e+01, 1.0027246093750000e+02,
+    1.3285850582178682e-04, 1, -1, 2.3640000915527344e+02,
+    3.3480001831054688e+02, 3.7200000762939453e+01,
+    7.9182846069335938e+01, 8.9237335487268865e-05, 1, -1,
+    2.3880000305175781e+02, 3.3480001831054688e+02,
+    3.7200000762939453e+01, 5.7906024932861328e+01,
+    8.0122597864829004e-05, 1, -1, 2.6520001220703125e+02,
+    3.3480001831054688e+02, 3.7200000762939453e+01,
+    2.9289315795898438e+02, 3.8941286038607359e-04, 1, -1,
+    2.9280001831054688e+02, 3.3480001831054688e+02,
+    3.7200000762939453e+01, 2.1300727844238281e+01,
+    1.6728298214729875e-04, 1, -1, 300., 3.3480001831054688e+02,
+    3.7200000762939453e+01, 5.9115272521972656e+01,
+    3.2551947515457869e-04, 1, -1, 3.0840002441406250e+02,
+    3.3480001831054688e+02, 3.7200000762939453e+01,
+    6.2744918823242188e+01, 1.1158941561006941e-05, 1, -1,
+    3.2040002441406250e+02, 3.3480001831054688e+02,
+    3.7200000762939453e+01, 6.9389923095703125e+01,
+    4.8942558350972831e-05, 1, -1, 3.5040002441406250e+02,
+    3.3480001831054688e+02, 3.7200000762939453e+01,
+    3.0956082153320312e+02, 4.2105025386263151e-06, 1, -1,
+    4.1520001220703125e+02, 3.3480001831054688e+02,
+    3.7200000762939453e+01, 1.7846282958984375e+02,
+    6.6707994847092777e-05, 1, -1, 1.6320001220703125e+02, 336.,
+    3.7200000762939453e+01, 2.5899356079101562e+02,
+    2.5915416699717753e-05, 1, -1, 1.9680000305175781e+02, 336.,
+    3.7200000762939453e+01, 1.0160481262207031e+02,
+    2.0322906493674964e-05, 1, -1, 2.4360000610351562e+02, 336.,
+    3.7200000762939453e+01, 3.1671390533447266e+01,
+    1.0453222057549283e-04, 1, -1, 2.4840000915527344e+02, 336.,
+    3.7200000762939453e+01, 3.1868066406250000e+02,
+    3.8771780964452773e-05, 1, -1, 2.5680001831054688e+02, 336.,
+    3.7200000762939453e+01, 3.0300207519531250e+02,
+    1.2798361422028393e-04, 1, -1, 2.8080001831054688e+02, 336.,
+    3.7200000762939453e+01, 2.8997155761718750e+02,
+    3.6182449548505247e-05, 1, -1, 3.0480001831054688e+02, 336.,
+    3.7200000762939453e+01, 6.0682975769042969e+01,
+    7.2885028203018010e-05, 1, -1, 3.3360000610351562e+02, 336.,
+    3.7200000762939453e+01, 3.0576473999023438e+02,
+    1.2202645848446991e-05, 1, -1, 3.7440002441406250e+02, 336.,
+    3.7200000762939453e+01, 2.1569744873046875e+02,
+    4.9500155000714585e-05, 1, -1, 378., 336., 3.7200000762939453e+01,
+    2.2400546264648438e+02, 6.8425601057242602e-05, 1, -1,
+    3.9840002441406250e+02, 336., 3.7200000762939453e+01,
+    2.3210281372070312e+02, 1.2782301928382367e-04, 1, -1,
+    4.0080001831054688e+02, 336., 3.7200000762939453e+01,
+    2.2711218261718750e+02, 1.3779850269202143e-04, 1, -1,
+    4.1880001831054688e+02, 336., 3.7200000762939453e+01,
+    1.7862329101562500e+02, 7.5706571806222200e-05, 1, -1,
+    2.3040000915527344e+02, 3.3720001220703125e+02,
+    3.7200000762939453e+01, 1.0363407135009766e+02,
+    4.1133287595584989e-05, 1, -1, 2.6880001831054688e+02,
+    3.3720001220703125e+02, 3.7200000762939453e+01,
+    3.1146771240234375e+02, 1.1915589129785076e-04, 1, -1,
+    2.9640002441406250e+02, 3.3720001220703125e+02,
+    3.7200000762939453e+01, 4.0947578430175781e+01,
+    1.4118173567112535e-04, 1, -1, 2.9880001831054688e+02,
+    3.3720001220703125e+02, 3.7200000762939453e+01,
+    5.1026073455810547e+01, 2.4857802782207727e-04, 1, -1,
+    3.2760000610351562e+02, 3.3720001220703125e+02,
+    3.7200000762939453e+01, 2.8780117797851562e+02,
+    4.1487328417133540e-05, 1, -1, 3.5520001220703125e+02,
+    3.3720001220703125e+02, 3.7200000762939453e+01,
+    2.8812622070312500e+02, -2.2248295863391832e-06, 1, -1,
+    2.7360000610351562e+02, 3.3840002441406250e+02,
+    3.7200000762939453e+01, 3.2545718383789062e+02,
+    3.3234995498787612e-05, 1, -1, 2.8080001831054688e+02,
+    3.3840002441406250e+02, 3.7200000762939453e+01,
+    3.5308456420898438e+02, 6.4817846578080207e-05, 1, -1,
+    2.8920001220703125e+02, 3.3840002441406250e+02,
+    3.7200000762939453e+01, 1.5912531852722168e+01,
+    1.7821374058257788e-04, 1, -1, 3.4560000610351562e+02,
+    3.3840002441406250e+02, 3.7200000762939453e+01,
+    3.0650408935546875e+02, 9.2541586127481423e-06, 1, -1,
+    2.6160000610351562e+02, 3.3960000610351562e+02,
+    3.7200000762939453e+01, 3.4255291748046875e+02,
+    1.9108995911665261e-04, 1, -1, 2.9520001220703125e+02,
+    3.3960000610351562e+02, 3.7200000762939453e+01,
+    2.7308887481689453e+01, 8.9765686425380409e-05, 1, -1,
+    2.9880001831054688e+02, 3.3960000610351562e+02,
+    3.7200000762939453e+01, 4.4367652893066406e+01,
+    1.4537668903358281e-04, 1, -1, 3.0960000610351562e+02,
+    3.3960000610351562e+02, 3.7200000762939453e+01,
+    6.7350860595703125e+01, 4.9008904170477763e-06, 1, -1,
+    3.2880001831054688e+02, 3.3960000610351562e+02,
+    3.7200000762939453e+01, 2.8398748779296875e+02,
+    4.7921083023538813e-05, 1, -1, 336., 3.3960000610351562e+02,
+    3.7200000762939453e+01, 3.0448934936523438e+02,
+    9.1442807388375513e-06, 1, -1, 3.9840002441406250e+02,
+    3.3960000610351562e+02, 3.7200000762939453e+01,
+    2.2031169128417969e+02, 1.2233956658747047e-04, 1, -1,
+    4.0080001831054688e+02, 3.3960000610351562e+02,
+    3.7200000762939453e+01, 2.1479882812500000e+02,
+    1.4226652274373919e-04, 1, -1, 186., 3.4080001831054688e+02,
+    3.7200000762939453e+01, 3.0964068603515625e+02,
+    4.5224885980132967e-05, 1, -1, 2.1480000305175781e+02,
+    3.4080001831054688e+02, 3.7200000762939453e+01,
+    1.0927172851562500e+02, 1.3752841368841473e-05, 1, -1,
+    2.2320001220703125e+02, 3.4080001831054688e+02,
+    3.7200000762939453e+01, 1.0034674835205078e+02,
+    2.0210087313898839e-05, 1, -1, 2.5440000915527344e+02,
+    3.4080001831054688e+02, 3.7200000762939453e+01,
+    5.6485187530517578e+01, 8.0371952208224684e-05, 1, -1, 258.,
+    3.4080001831054688e+02, 3.7200000762939453e+01,
+    2.8723022460937500e+01, 9.3163980636745691e-05, 1, -1,
+    2.7120001220703125e+02, 3.4080001831054688e+02,
+    3.7200000762939453e+01, 3.5994497680664062e+02,
+    8.5132021922618151e-05, 1, -1, 2.7720001220703125e+02,
+    3.4080001831054688e+02, 3.7200000762939453e+01,
+    2.2952026367187500e+01, 6.3497733208350837e-05, 1, -1,
+    3.2160000610351562e+02, 3.4080001831054688e+02,
+    3.7200000762939453e+01, 2.0994253540039062e+02,
+    1.0145139094674960e-04, 1, -1, 3.3960000610351562e+02,
+    3.4080001831054688e+02, 3.7200000762939453e+01,
+    3.0633547973632812e+02, 4.5793735807819758e-06, 1, -1,
+    2.2800001525878906e+02, 342., 3.7200000762939453e+01,
+    1.0593044281005859e+02, 1.9960642021032982e-05, 1, -1,
+    2.3640000915527344e+02, 342., 3.7200000762939453e+01,
+    1.0464349365234375e+02, 3.1687766750110313e-05, 1, -1,
+    2.8080001831054688e+02, 342., 3.7200000762939453e+01,
+    4.9006519317626953e+01, 1.9509588310029358e-04, 1, -1,
+    3.2760000610351562e+02, 342., 3.7200000762939453e+01,
+    2.5807296752929688e+02, 8.9270673925057054e-05, 1, -1,
+    4.1520001220703125e+02, 342., 3.7200000762939453e+01,
+    1.9294297790527344e+02, 6.8910761910956353e-05, 1, -1,
+    4.1880001831054688e+02, 342., 3.7200000762939453e+01,
+    1.8271322631835938e+02, 7.1406022470910102e-05, 1, -1,
+    2.0040000915527344e+02, 3.4320001220703125e+02,
+    3.7200000762939453e+01, 2.7229025268554688e+02,
+    1.9861379769281484e-05, 1, -1, 2.4480000305175781e+02,
+    3.4320001220703125e+02, 3.7200000762939453e+01,
+    1.0678182220458984e+02, 3.6109584470978007e-05, 1, -1, 270.,
+    3.4320001220703125e+02, 3.7200000762939453e+01,
+    2.8472394943237305e+01, 5.6048083934001625e-05, 1, -1,
+    2.8320001220703125e+02, 3.4320001220703125e+02,
+    3.7200000762939453e+01, 5.7824966430664062e+01,
+    1.9850028911605477e-04, 1, -1, 3.2280001831054688e+02,
+    3.4320001220703125e+02, 3.7200000762939453e+01,
+    2.0817453002929688e+02, 1.3674150977749377e-04, 1, -1,
+    2.0760000610351562e+02, 3.4440002441406250e+02,
+    3.7200000762939453e+01, 2.5829449462890625e+02,
+    3.5048047720920295e-05, 1, -1, 2.9880001831054688e+02,
+    3.4440002441406250e+02, 3.7200000762939453e+01,
+    1.1497306823730469e+01, 8.8251954366569407e-06, 1, -1,
+    3.2760000610351562e+02, 3.4440002441406250e+02,
+    3.7200000762939453e+01, 2.4374014282226562e+02,
+    1.1727279343176633e-04, 1, -1, 2.5080000305175781e+02,
+    3.4560000610351562e+02, 3.7200000762939453e+01,
+    1.0131136322021484e+02, 3.1204854167299345e-05, 1, -1,
+    2.8080001831054688e+02, 3.4560000610351562e+02,
+    3.7200000762939453e+01, 4.1314365386962891e+01,
+    1.1877456563524902e-04, 1, -1, 2.8920001220703125e+02,
+    3.4560000610351562e+02, 3.7200000762939453e+01,
+    3.7941329956054688e+01, 1.7035552446031943e-05, 1, -1,
+    2.9280001831054688e+02, 3.4560000610351562e+02,
+    3.7200000762939453e+01, 1.3532415390014648e+01,
+    1.0334367289033253e-05, 1, -1, 3.1440002441406250e+02,
+    3.4560000610351562e+02, 3.7200000762939453e+01,
+    1.6802886962890625e+02, 1.8329230078961700e-04, 1, -1,
+    4.1640002441406250e+02, 3.4560000610351562e+02,
+    3.7200000762939453e+01, 1.8661729431152344e+02,
+    4.3021485907956958e-05, 1, -1, 2.1480000305175781e+02,
+    3.4680001831054688e+02, 3.7200000762939453e+01,
+    2.8994818115234375e+02, 1.3782544556306675e-05, 1, -1,
+    2.1960000610351562e+02, 3.4680001831054688e+02,
+    3.7200000762939453e+01, 2.9791424560546875e+02,
+    3.5251785448053852e-05, 1, -1, 2.6040002441406250e+02,
+    3.4680001831054688e+02, 3.7200000762939453e+01,
+    6.6147911071777344e+01, 5.6743207096587867e-05, 1, -1,
+    2.6280001831054688e+02, 3.4680001831054688e+02,
+    3.7200000762939453e+01, 5.6403091430664062e+01,
+    6.1805432778783143e-05, 1, -1, 3.2760000610351562e+02,
+    3.4680001831054688e+02, 3.7200000762939453e+01,
+    2.4772875976562500e+02, 7.8635028330609202e-05, 1, -1,
+    2.2680000305175781e+02, 348., 3.7200000762939453e+01,
+    2.2468759155273438e+02, 4.8168833018280566e-05, 1, -1,
+    2.7120001220703125e+02, 348., 3.7200000762939453e+01,
+    9.4917650222778320e+00, 4.5432083425112069e-05, 1, -1, 300., 348.,
+    3.7200000762939453e+01, 1.8097127914428711e+01,
+    3.3476168027846143e-05, 1, -1, 3.0480001831054688e+02, 348.,
+    3.7200000762939453e+01, 3.5513626098632812e+02,
+    1.5853138393140398e-05, 1, -1, 3.1560000610351562e+02, 348.,
+    3.7200000762939453e+01, 2.0378242492675781e+02,
+    1.6604516713414341e-04, 1, -1, 3.3960000610351562e+02, 348.,
+    3.7200000762939453e+01, 2.9640933227539062e+02,
+    1.7454373301006854e-04, 1, -1, 3.4680001831054688e+02, 348.,
+    3.7200000762939453e+01, 2.9048596191406250e+02,
+    2.5947418180294335e-05, 1, -1, 3.6480001831054688e+02, 348.,
+    3.7200000762939453e+01, 2.5304565429687500e+02,
+    2.3884085749159567e-05, 1, -1, 2.8440002441406250e+02,
+    3.4920001220703125e+02, 3.7200000762939453e+01,
+    3.4308969116210938e+02, 5.2475843403954059e-05, 1, -1,
+    3.7080001831054688e+02, 3.4920001220703125e+02,
+    3.7200000762939453e+01, 2.4429850769042969e+02,
+    1.7843363821157254e-05, 1, -1, 2.4360000610351562e+02,
+    3.5040002441406250e+02, 3.7200000762939453e+01,
+    1.2271307373046875e+02, 3.3589516533538699e-05, 1, -1,
+    2.7840002441406250e+02, 3.5040002441406250e+02,
+    3.7200000762939453e+01, 3.2620831298828125e+02,
+    2.3554013750981539e-05, 1, -1, 294., 3.5040002441406250e+02,
+    3.7200000762939453e+01, 3.5362500000000000e+02,
+    4.7553199692629278e-05, 1, -1, 3.3240002441406250e+02,
+    3.5040002441406250e+02, 3.7200000762939453e+01,
+    2.6381494140625000e+02, 1.2161544873379171e-04, 1, -1,
+    2.8680001831054688e+02, 3.5160000610351562e+02,
+    3.7200000762939453e+01, 3.1587780761718750e+02,
+    2.6532175979809836e-05, 1, -1, 3.5640002441406250e+02,
+    3.5160000610351562e+02, 3.7200000762939453e+01,
+    2.8246127319335938e+02, 1.4647964235336985e-05, 1, -1,
+    3.6480001831054688e+02, 3.5160000610351562e+02,
+    3.7200000762939453e+01, 2.4837739562988281e+02,
+    1.4920365174475592e-05, 1, -1, 3.6960000610351562e+02,
+    3.5160000610351562e+02, 3.7200000762939453e+01,
+    2.4245111083984375e+02, 1.8531189198256470e-05, 1, -1,
+    3.7920001220703125e+02, 3.5160000610351562e+02,
+    3.7200000762939453e+01, 2.9576611328125000e+02,
+    5.5282733228523284e-05, 1, -1, 4.1640002441406250e+02,
+    3.5160000610351562e+02, 3.7200000762939453e+01,
+    1.7982055664062500e+02, 2.7964731998508796e-05, 1, -1,
+    2.5080000305175781e+02, 3.5280001831054688e+02,
+    3.7200000762939453e+01, 1.3738595581054688e+02,
+    6.4571060647722334e-05, 1, -1, 2.9280001831054688e+02,
+    3.5280001831054688e+02, 3.7200000762939453e+01,
+    3.1601864624023438e+02, 2.4526894776499830e-05, 1, -1,
+    2.9520001220703125e+02, 3.5280001831054688e+02,
+    3.7200000762939453e+01, 3.1360913085937500e+02,
+    3.1844123441260308e-05, 1, -1, 3.5040002441406250e+02,
+    3.5280001831054688e+02, 3.7200000762939453e+01,
+    2.7941259765625000e+02, 3.4908865927718580e-05, 1, -1,
+    2.5440000915527344e+02, 354., 3.7200000762939453e+01,
+    1.5653710937500000e+02, 2.7439955374575220e-05, 1, -1,
+    3.0120001220703125e+02, 354., 3.7200000762939453e+01,
+    2.8106030273437500e+02, 5.7655877753859386e-05, 1, -1,
+    3.1440002441406250e+02, 354., 3.7200000762939453e+01,
+    2.5629565429687500e+02, 5.8014742535306141e-05, 1, -1,
+    3.3480001831054688e+02, 354., 3.7200000762939453e+01,
+    2.2605763244628906e+02, 3.8307920476654544e-05, 1, -1,
+    3.4560000610351562e+02, 354., 3.7200000762939453e+01,
+    2.8779125976562500e+02, 2.8253582058823667e-05, 1, -1,
+    3.7920001220703125e+02, 354., 3.7200000762939453e+01,
+    3.2978515625000000e+02, 5.7084595027845353e-05, 1, -1,
+    2.6760000610351562e+02, 3.5520001220703125e+02,
+    3.7200000762939453e+01, 3.1805838012695312e+02,
+    3.7783724110340700e-05, 1, -1, 3.0720001220703125e+02,
+    3.5520001220703125e+02, 3.7200000762939453e+01,
+    2.7609115600585938e+02, 3.2674670364940539e-05, 1, -1,
+    3.2160000610351562e+02, 3.5520001220703125e+02,
+    3.7200000762939453e+01, 2.4521772766113281e+02,
+    5.0109334551962093e-05, 1, -1, 3.8280001831054688e+02,
+    3.5520001220703125e+02, 3.7200000762939453e+01,
+    3.4178967285156250e+02, 3.5810357076115906e-05, 1, -1,
+    4.1520001220703125e+02, 3.5520001220703125e+02,
+    3.7200000762939453e+01, 1.8410690307617188e+02,
+    4.9680606025503948e-05, 1, -1, 4.1880001831054688e+02,
+    3.5520001220703125e+02, 3.7200000762939453e+01,
+    1.7840510559082031e+02, 6.4418156398460269e-05, 1, -1, 276.,
+    3.5640002441406250e+02, 3.7200000762939453e+01,
+    3.0282324218750000e+02, 4.7717239795019850e-05, 1, -1,
+    3.1560000610351562e+02, 3.5640002441406250e+02,
+    3.7200000762939453e+01, 2.6502560424804688e+02,
+    4.9543177738087252e-05, 1, -1, 3.3120001220703125e+02,
+    3.5640002441406250e+02, 3.7200000762939453e+01,
+    2.4114739990234375e+02, 2.3769216568325646e-05, 1, -1,
+    3.5160000610351562e+02, 3.5640002441406250e+02,
+    3.7200000762939453e+01, 2.9351171875000000e+02,
+    3.9133690734161064e-05, 1, -1, 3.9960000610351562e+02,
+    3.5640002441406250e+02, 3.7200000762939453e+01,
+    1.8392874145507812e+02, 1.2331371544860303e-04, 1, -1,
+    3.4080001831054688e+02, 3.5760000610351562e+02,
+    3.7200000762939453e+01, 2.5847485351562500e+02,
+    5.2113235142314807e-05, 1, -1, 360., 3.5760000610351562e+02,
+    3.7200000762939453e+01, 2.7182992553710938e+02,
+    1.9695311493705958e-05, 1, -1, 3.7320001220703125e+02,
+    3.5760000610351562e+02, 3.7200000762939453e+01,
+    2.7713354492187500e+02, 8.0435402196599171e-06, 1, -1,
+    2.9040002441406250e+02, 3.5880001831054688e+02,
+    3.7200000762939453e+01, 2.8390142822265625e+02,
+    4.1203769796993583e-05, 1, -1, 3.4920001220703125e+02,
+    3.5880001831054688e+02, 3.7200000762939453e+01,
+    2.9304284667968750e+02, 7.9924910096451640e-05, 1, -1,
+    3.6720001220703125e+02, 3.5880001831054688e+02,
+    3.7200000762939453e+01, 2.1572058105468750e+02,
+    1.7239455701201223e-05, 1, -1, 2.9880001831054688e+02, 360.,
+    3.7200000762939453e+01, 2.7826348876953125e+02,
+    4.4707558117806911e-05, 1, -1, 3.3720001220703125e+02, 360.,
+    3.7200000762939453e+01, 2.5223695373535156e+02,
+    2.0231565940775909e-05, 1, -1, 342., 360., 3.7200000762939453e+01,
+    2.6221380615234375e+02, 4.4007727410644293e-05, 1, -1,
+    3.8040002441406250e+02, 360., 3.7200000762939453e+01,
+    3.5513549804687500e+02, 7.6953139796387404e-05, 1, -1,
+    3.8280001831054688e+02, 360., 3.7200000762939453e+01,
+    3.3971884155273438e+02, 5.5844080634415150e-05, 1, -1, 348.,
+    3.6120001220703125e+02, 3.7200000762939453e+01,
+    2.8474026489257812e+02, 5.7210287195630372e-05, 1, -1, 360.,
+    3.6120001220703125e+02, 3.7200000762939453e+01,
+    2.7704315185546875e+02, 4.7690220526419580e-05, 1, -1,
+    4.1640002441406250e+02, 3.6120001220703125e+02,
+    3.7200000762939453e+01, 1.9093743896484375e+02,
+    6.3284751377068460e-05, 1, -1, 4.2000003051757812e+02,
+    3.6120001220703125e+02, 3.7200000762939453e+01,
+    1.8280543518066406e+02, 5.5679764045635238e-05, 1, -1,
+    3.1320001220703125e+02, 3.6240002441406250e+02,
+    3.7200000762939453e+01, 2.7886666870117188e+02,
+    3.2878859201446176e-05, 1, -1, 3.5640002441406250e+02,
+    3.6240002441406250e+02, 3.7200000762939453e+01,
+    2.7861151123046875e+02, 3.3443197025917470e-05, 1, -1,
+    3.7080001831054688e+02, 3.6240002441406250e+02,
+    3.7200000762939453e+01, 2.7106402587890625e+02,
+    4.0186107071349397e-05, 1, -1, 4.0080001831054688e+02,
+    3.6240002441406250e+02, 3.7200000762939453e+01,
+    1.6510745239257812e+02, 2.0971415506210178e-04, 1, -1,
+    3.2160000610351562e+02, 3.6360000610351562e+02,
+    3.7200000762939453e+01, 2.7546215820312500e+02,
+    5.9946298279101029e-05, 1, -1, 3.6240002441406250e+02,
+    3.6360000610351562e+02, 3.7200000762939453e+01,
+    2.7310919189453125e+02, 4.7165452997433022e-05, 1, -1,
+    3.8280001831054688e+02, 3.6360000610351562e+02,
+    3.7200000762939453e+01, 2.8608862304687500e+02,
+    6.9023357355035841e-05, 1, -1, 3.6840002441406250e+02,
+    3.6480001831054688e+02, 3.7200000762939453e+01,
+    2.6678210449218750e+02, 3.4741842682706192e-05, 1, -1,
+    3.8040002441406250e+02, 3.6480001831054688e+02,
+    3.7200000762939453e+01, 2.9839337158203125e+02,
+    8.4289997175801545e-05, 1, -1, 4.1760000610351562e+02,
+    3.6480001831054688e+02, 3.7200000762939453e+01,
+    1.8456150817871094e+02, 4.2979623685823753e-05, 1, -1, 336., 366.,
+    3.7200000762939453e+01, 2.7316592407226562e+02,
+    1.9603236069087870e-05, 1, -1, 378., 366., 3.7200000762939453e+01,
+    2.9342651367187500e+02, 3.8428526750067249e-05, 1, -1,
+    4.0200003051757812e+02, 366., 3.7200000762939453e+01,
+    2.4511849975585938e+02, 1.3916194438934326e-04, 1, -1,
+    3.8160000610351562e+02, 3.6720001220703125e+02,
+    3.7200000762939453e+01, 2.8610391235351562e+02,
+    2.7580119422054850e-05, 1, -1, 3.5880001831054688e+02,
+    3.7080001831054688e+02, 3.7200000762939453e+01,
+    2.8011428833007812e+02, 2.7445792511571199e-05, 1, -1,
+    3.6240002441406250e+02, 3.7080001831054688e+02,
+    3.7200000762939453e+01, 2.7961657714843750e+02,
+    5.8757126680575311e-05, 1, -1, 3.6720001220703125e+02,
+    3.7080001831054688e+02, 3.7200000762939453e+01,
+    2.7347222900390625e+02, 5.7002616813406348e-05, 1, -1,
+    4.1760000610351562e+02, 3.7080001831054688e+02,
+    3.7200000762939453e+01, 2.0893304443359375e+02,
+    2.6128576791961677e-05, 1, -1, 3.7080001831054688e+02, 372.,
+    3.7200000762939453e+01, 2.7421771240234375e+02,
+    6.2586288549937308e-05, 1, -1, 3.6240002441406250e+02,
+    3.7320001220703125e+02, 3.7200000762939453e+01,
+    2.7820919799804688e+02, 1.2505482300184667e-04, 1, -1,
+    3.7080001831054688e+02, 3.7440002441406250e+02,
+    3.7200000762939453e+01, 2.7415075683593750e+02,
+    1.3160318485461175e-04, 1, -1, 3.8760000610351562e+02,
+    3.7440002441406250e+02, 3.7200000762939453e+01,
+    2.7597686767578125e+02, 6.1692175222560763e-05, 1, -1,
+    3.9240002441406250e+02, 3.7440002441406250e+02,
+    3.7200000762939453e+01, 2.7204956054687500e+02,
+    5.3307056077755988e-05, 1, -1, 4.1640002441406250e+02,
+    3.7440002441406250e+02, 3.7200000762939453e+01,
+    2.3338056945800781e+02, 9.7794392786454409e-05, 1, -1,
+    4.2000003051757812e+02, 3.7440002441406250e+02,
+    3.7200000762939453e+01, 2.0824023437500000e+02,
+    7.2875649493653327e-05, 1, -1, 3.9600003051757812e+02,
+    3.7560000610351562e+02, 3.7200000762939453e+01,
+    2.7088363647460938e+02, 6.8366432969924062e-05, 1, -1,
+    3.8760000610351562e+02, 3.7680001831054688e+02,
+    3.7200000762939453e+01, 2.7582299804687500e+02,
+    1.3249157927930355e-04, 1, -1, 4.1160000610351562e+02,
+    3.7680001831054688e+02, 3.7200000762939453e+01,
+    2.7023941040039062e+02, 7.3294031608384103e-05, 1, -1,
+    3.9600003051757812e+02, 378., 3.7200000762939453e+01,
+    2.7033383178710938e+02, 1.3482253416441381e-04, 1, -1,
+    4.0920001220703125e+02, 378., 3.7200000762939453e+01,
+    2.7788812255859375e+02, 4.5720636990154162e-05, 1, -1,
+    4.2000003051757812e+02, 378., 3.7200000762939453e+01,
+    2.1807348632812500e+02, 7.4493545980658382e-05, 1, -1,
+    4.2000003051757812e+02, 3.8040002441406250e+02,
+    3.7200000762939453e+01, 2.2388574218750000e+02,
+    1.1865554552059621e-04, 1, -1, 4.2720001220703125e+02, 384.,
+    3.7200000762939453e+01, 1.9050807189941406e+02,
+    1.1709031241480261e-04, 1, -1, 4.2960000610351562e+02,
+    3.8520001220703125e+02, 3.7200000762939453e+01,
+    1.8027026367187500e+02, 1.2678249913733453e-04, 1, -1,
+    2.0592001342773438e+02, 1.3104000854492188e+02,
+    4.4640003204345703e+01, 1.5637887573242188e+02,
+    4.3647828533721622e-06, 2, -1, 2.1312001037597656e+02,
+    1.3680000305175781e+02, 4.4640003204345703e+01,
+    1.8886749267578125e+02, 1.0648513853084296e-04, 2, -1,
+    2.0880000305175781e+02, 1.3968000793457031e+02,
+    4.4640003204345703e+01, 1.9851919555664062e+02,
+    4.0030412492342293e-05, 2, -1, 2.2896000671386719e+02,
+    1.3968000793457031e+02, 4.4640003204345703e+01,
+    2.5268096923828125e+02, 3.1752060749568045e-05, 2, -1,
+    2.4624000549316406e+02, 1.4112001037597656e+02,
+    4.4640003204345703e+01, 3.3905575561523438e+02,
+    8.5542678789352067e-06, 2, -1, 2.5344000244140625e+02,
+    1.4112001037597656e+02, 4.4640003204345703e+01,
+    3.1483612060546875e+01, 9.2874261099495925e-06, 2, -1,
+    2.0736001586914062e+02, 1.4256001281738281e+02,
+    4.4640003204345703e+01, 2.0589096069335938e+02,
+    1.3055875569989439e-05, 2, -1, 2.1168000793457031e+02,
+    1.4256001281738281e+02, 4.4640003204345703e+01,
+    2.1093025207519531e+02, 5.3967964049661532e-05, 2, -1,
+    2.2752000427246094e+02, 1.4256001281738281e+02,
+    4.4640003204345703e+01, 2.3813412475585938e+02,
+    6.8993576860520989e-05, 2, -1, 2.2464001464843750e+02, 144.,
+    4.4640003204345703e+01, 2.0955453491210938e+02,
+    6.9402798544615507e-05, 2, -1, 2.1168000793457031e+02,
+    1.4544000244140625e+02, 4.4640003204345703e+01,
+    2.1461880493164062e+02, 3.6537196137942374e-05, 2, -1,
+    2.3760000610351562e+02, 1.4544000244140625e+02,
+    4.4640003204345703e+01, 7.8382873535156250e+01,
+    5.0788446969818324e-05, 2, -1, 2.0592001342773438e+02,
+    1.4688000488281250e+02, 4.4640003204345703e+01,
+    2.1617993164062500e+02, 8.7633325165370479e-06, 2, -1,
+    2.6640002441406250e+02, 1.4688000488281250e+02,
+    4.4640003204345703e+01, 7.9226478576660156e+01,
+    2.3767697712173685e-05, 2, -1, 2.3040000915527344e+02,
+    1.4832000732421875e+02, 4.4640003204345703e+01,
+    7.4008659362792969e+01, 4.1857885662466288e-05, 2, -1,
+    2.4480000305175781e+02, 1.4832000732421875e+02,
+    4.4640003204345703e+01, 6.8858032226562500e+01,
+    4.0745322621660307e-05, 2, -1, 2.5776000976562500e+02,
+    1.4832000732421875e+02, 4.4640003204345703e+01,
+    7.1716873168945312e+01, 7.3302239798067603e-06, 2, -1,
+    2.3904000854492188e+02, 1.4976000976562500e+02,
+    4.4640003204345703e+01, 7.6938377380371094e+01,
+    6.0933372878935188e-05, 2, -1, 2.4912001037597656e+02,
+    1.4976000976562500e+02, 4.4640003204345703e+01,
+    7.2636909484863281e+01, 1.5437630281667225e-05, 2, -1,
+    2.6640002441406250e+02, 1.4976000976562500e+02,
+    4.4640003204345703e+01, 8.4699684143066406e+01,
+    2.3425291146850213e-05, 2, -1, 2.3904000854492188e+02,
+    1.5263999938964844e+02, 4.4640003204345703e+01,
+    7.1072250366210938e+01, 3.8459911593236029e-05, 2, -1,
+    2.4912001037597656e+02, 1.5263999938964844e+02,
+    4.4640003204345703e+01, 7.3155380249023438e+01,
+    1.7958043827093206e-05, 2, -1, 2.6208001708984375e+02,
+    1.5263999938964844e+02, 4.4640003204345703e+01,
+    8.3154869079589844e+01, 9.7759475465863943e-06, 2, -1,
+    2.8944000244140625e+02, 1.5263999938964844e+02,
+    4.4640003204345703e+01, 9.9990066528320312e+01,
+    1.9091266949544661e-05, 2, -1, 2.9664001464843750e+02,
+    1.5263999938964844e+02, 4.4640003204345703e+01,
+    9.8732917785644531e+01, 3.2185271265916526e-05, 2, -1,
+    2.3472001647949219e+02, 1.5408000183105469e+02,
+    4.4640003204345703e+01, 6.9980865478515625e+01,
+    4.6960511099314317e-05, 2, -1, 3.0384002685546875e+02,
+    1.5408000183105469e+02, 4.4640003204345703e+01,
+    1.0228738403320312e+02, 2.9417746191029437e-05, 2, -1,
+    3.1104000854492188e+02, 1.5408000183105469e+02,
+    4.4640003204345703e+01, 9.8893089294433594e+01,
+    2.5925437512341887e-05, 2, -1, 1.9728001403808594e+02,
+    1.5552000427246094e+02, 4.4640003204345703e+01,
+    1.8707231140136719e+02, 1.2452036025933921e-04, 2, -1,
+    2.1888000488281250e+02, 1.5552000427246094e+02,
+    4.4640003204345703e+01, 9.8407135009765625e+01,
+    6.1543920310214162e-05, 2, -1, 2.3040000915527344e+02,
+    1.5552000427246094e+02, 4.4640003204345703e+01,
+    8.3305419921875000e+01, 5.5735436035320163e-05, 2, -1,
+    2.3904000854492188e+02, 1.5552000427246094e+02,
+    4.4640003204345703e+01, 6.6715484619140625e+01,
+    1.9637534933281131e-05, 2, -1, 2.4912001037597656e+02,
+    1.5552000427246094e+02, 4.4640003204345703e+01,
+    7.1618911743164062e+01, 1.4888114492350724e-05, 2, -1,
+    2.1600001525878906e+02, 1.5696000671386719e+02,
+    4.4640003204345703e+01, 1.1649685668945312e+02,
+    6.9703841290902346e-05, 2, -1, 2.2608000183105469e+02,
+    1.5696000671386719e+02, 4.4640003204345703e+01,
+    7.3927589416503906e+01, 6.2861006881576031e-05, 2, -1,
+    3.3120001220703125e+02, 1.5696000671386719e+02,
+    4.4640003204345703e+01, 9.3091407775878906e+01,
+    2.2690877813147381e-05, 2, -1, 3.2112002563476562e+02,
+    1.5840000915527344e+02, 4.4640003204345703e+01,
+    9.7471649169921875e+01, 1.7933891285792924e-05, 2, -1,
+    3.3984002685546875e+02, 1.5840000915527344e+02,
+    4.4640003204345703e+01, 9.8484024047851562e+01,
+    5.1489291763573419e-06, 2, -1, 3.5424002075195312e+02,
+    1.5984001159667969e+02, 4.4640003204345703e+01,
+    1.0150732421875000e+02, 1.5527288269368000e-05, 2, -1,
+    2.0016000366210938e+02, 1.6127999877929688e+02,
+    4.4640003204345703e+01, 1.6403225708007812e+02,
+    1.2628390686586499e-04, 2, -1, 2.5776000976562500e+02,
+    1.6127999877929688e+02, 4.4640003204345703e+01,
+    7.9898086547851562e+01, 7.0322121246135794e-06, 2, -1,
+    3.4848001098632812e+02, 1.6127999877929688e+02,
+    4.4640003204345703e+01, 9.8834487915039062e+01,
+    2.2544210878550075e-05, 2, -1, 1.9008000183105469e+02,
+    1.6272000122070312e+02, 4.4640003204345703e+01,
+    1.6901666259765625e+02, 1.0067248695122544e-05, 2, -1,
+    2.6496002197265625e+02, 1.6272000122070312e+02,
+    4.4640003204345703e+01, 8.8654335021972656e+01,
+    2.0806651264138054e-06, 2, -1, 360., 1.6272000122070312e+02,
+    4.4640003204345703e+01, 1.0028858184814453e+02,
+    2.9309258025023155e-05, 2, -1, 3.6864001464843750e+02,
+    1.6272000122070312e+02, 4.4640003204345703e+01,
+    1.0290103149414062e+02, 2.2496262317872606e-05, 2, -1,
+    3.8160000610351562e+02, 1.6272000122070312e+02,
+    4.4640003204345703e+01, 1.0465580749511719e+02,
+    2.2268013708526269e-05, 2, -1, 4.2624002075195312e+02,
+    1.6272000122070312e+02, 4.4640003204345703e+01,
+    1.2367174530029297e+02, 8.2291553553659469e-06, 2, -1,
+    4.2912002563476562e+02, 1.6272000122070312e+02,
+    4.4640003204345703e+01, 1.1065707397460938e+02,
+    1.0468446816958021e-05, 2, -1, 1.9296000671386719e+02,
+    1.6416000366210938e+02, 4.4640003204345703e+01,
+    1.5760644531250000e+02, 1.5706507838331163e-05, 2, -1,
+    2.5056001281738281e+02, 1.6416000366210938e+02,
+    4.4640003204345703e+01, 6.7388557434082031e+01,
+    6.2917240484239301e-07, 2, -1, 2.8224002075195312e+02,
+    1.6416000366210938e+02, 4.4640003204345703e+01,
+    9.8284111022949219e+01, 1.4389997886610217e-06, 2, -1,
+    3.8592001342773438e+02, 1.6416000366210938e+02,
+    4.4640003204345703e+01, 1.1345373535156250e+02,
+    2.0820099962293170e-05, 2, -1, 4.1184002685546875e+02,
+    1.6416000366210938e+02, 4.4640003204345703e+01,
+    1.2256275939941406e+02, 4.2297306208638474e-05, 2, -1,
+    4.1616000366210938e+02, 1.6416000366210938e+02,
+    4.4640003204345703e+01, 1.3411433410644531e+02,
+    2.2034288122085854e-05, 2, -1, 4.1904000854492188e+02,
+    1.6416000366210938e+02, 4.4640003204345703e+01,
+    1.3826354980468750e+02, 1.4038762856216636e-05, 2, -1,
+    4.3776000976562500e+02, 1.6416000366210938e+02,
+    4.4640003204345703e+01, 7.3273139953613281e+01,
+    1.5011045434221160e-05, 2, -1, 1.9008000183105469e+02,
+    1.6560000610351562e+02, 4.4640003204345703e+01,
+    1.5493692016601562e+02, 1.3068002772342879e-05, 2, -1,
+    2.0592001342773438e+02, 1.6560000610351562e+02,
+    4.4640003204345703e+01, 1.5573832702636719e+02,
+    8.0856894783210009e-05, 2, -1, 3.7872000122070312e+02,
+    1.6560000610351562e+02, 4.4640003204345703e+01,
+    1.1677537536621094e+02, 2.0064555428689346e-05, 2, -1,
+    3.9456002807617188e+02, 1.6560000610351562e+02,
+    4.4640003204345703e+01, 1.2595372009277344e+02,
+    3.8940510421525687e-05, 2, -1, 3.0672000122070312e+02,
+    1.6704000854492188e+02, 4.4640003204345703e+01,
+    1.1136824035644531e+02, 2.9652928787982091e-06, 2, -1,
+    4.0896002197265625e+02, 1.6704000854492188e+02,
+    4.4640003204345703e+01, 1.1785065460205078e+02,
+    3.9917391404742375e-05, 2, -1, 4.5504000854492188e+02,
+    1.6704000854492188e+02, 4.4640003204345703e+01,
+    1.1270974731445312e+02, 7.4402050813660026e-05, 2, -1,
+    1.8864001464843750e+02, 1.6848001098632812e+02,
+    4.4640003204345703e+01, 1.5306031799316406e+02,
+    1.0367073628003709e-05, 2, -1, 2.1024000549316406e+02,
+    1.6848001098632812e+02, 4.4640003204345703e+01,
+    1.5672848510742188e+02, 2.5708783141453750e-05, 2, -1,
+    3.1536001586914062e+02, 1.6848001098632812e+02,
+    4.4640003204345703e+01, 1.1534618377685547e+02,
+    2.0763566226378316e-06, 2, -1, 1.9728001403808594e+02,
+    1.6992001342773438e+02, 4.4640003204345703e+01,
+    1.4795687866210938e+02, 5.6938943089335226e-06, 2, -1,
+    3.3264001464843750e+02, 1.6992001342773438e+02,
+    4.4640003204345703e+01, 9.8996582031250000e+01,
+    2.1521204871532973e-06, 2, -1, 4.3056002807617188e+02,
+    1.6992001342773438e+02, 4.4640003204345703e+01,
+    1.1991713714599609e+02, 3.0985043849796057e-05, 2, -1,
+    4.5072003173828125e+02, 1.6992001342773438e+02,
+    4.4640003204345703e+01, 7.8087471008300781e+01,
+    3.8455054891528562e-05, 2, -1, 4.7232000732421875e+02,
+    1.6992001342773438e+02, 4.4640003204345703e+01,
+    1.6947460937500000e+02, 9.8766919109039009e-05, 2, -1,
+    2.4192001342773438e+02, 1.7136000061035156e+02,
+    4.4640003204345703e+01, 2.8242536544799805e+01,
+    5.4922948038438335e-05, 2, -1, 3.3984002685546875e+02,
+    1.7136000061035156e+02, 4.4640003204345703e+01,
+    8.9798858642578125e+01, 1.6222945760091534e-06, 2, -1,
+    4.0752001953125000e+02, 1.7136000061035156e+02,
+    4.4640003204345703e+01, 1.0752309417724609e+02,
+    1.3348187167139258e-05, 2, -1, 4.2336001586914062e+02,
+    1.7136000061035156e+02, 4.4640003204345703e+01,
+    1.3427394104003906e+02, 6.2661142692377325e-06, 2, -1,
+    4.3632000732421875e+02, 1.7136000061035156e+02,
+    4.4640003204345703e+01, 1.1766807556152344e+02,
+    8.1489510193932801e-05, 2, -1, 4.5648001098632812e+02,
+    1.7136000061035156e+02, 4.4640003204345703e+01,
+    1.3644737243652344e+02, 6.9368259573820978e-05, 2, -1,
+    4.6512002563476562e+02, 1.7136000061035156e+02,
+    4.4640003204345703e+01, 1.5856799316406250e+02,
+    1.0788067447720096e-04, 2, -1, 1.8720001220703125e+02,
+    1.7280000305175781e+02, 4.4640003204345703e+01,
+    1.5434547424316406e+02, 2.0728954041260295e-05, 2, -1,
+    3.4992001342773438e+02, 1.7280000305175781e+02,
+    4.4640003204345703e+01, 8.9826843261718750e+01,
+    2.9224872832855908e-06, 2, -1, 4.7376000976562500e+02,
+    1.7280000305175781e+02, 4.4640003204345703e+01,
+    1.8120982360839844e+02, 3.7200406950432807e-05, 2, -1,
+    2.3904000854492188e+02, 1.7424000549316406e+02,
+    4.4640003204345703e+01, 1.4072114944458008e+01,
+    1.0227673192275688e-04, 2, -1, 3.0240002441406250e+02,
+    1.7424000549316406e+02, 4.4640003204345703e+01,
+    1.5353271484375000e+02, 4.1388952922716271e-06, 2, -1,
+    3.6720001220703125e+02, 1.7424000549316406e+02,
+    4.4640003204345703e+01, 1.2361346435546875e+02,
+    2.3242366751219379e-06, 2, -1, 4.1904000854492188e+02,
+    1.7424000549316406e+02, 4.4640003204345703e+01,
+    1.4078250122070312e+02, 2.5158708012895659e-05, 2, -1,
+    4.2336001586914062e+02, 1.7424000549316406e+02,
+    4.4640003204345703e+01, 1.3449922180175781e+02,
+    2.0127023162785918e-05, 2, -1, 4.4064001464843750e+02,
+    1.7424000549316406e+02, 4.4640003204345703e+01,
+    1.0442240142822266e+02, 5.2309136663097888e-05, 2, -1,
+    4.5216000366210938e+02, 1.7424000549316406e+02,
+    4.4640003204345703e+01, 2.8724874877929688e+02,
+    2.3804432203178294e-05, 2, -1, 4.6944003295898438e+02,
+    1.7424000549316406e+02, 4.4640003204345703e+01,
+    1.8436087036132812e+02, 1.4129382907412946e-04, 2, -1,
+    2.2320001220703125e+02, 1.7568000793457031e+02,
+    4.4640003204345703e+01, 3.2874645996093750e+02,
+    9.6205285444739275e-06, 2, -1, 4.7232000732421875e+02,
+    1.7568000793457031e+02, 4.4640003204345703e+01,
+    1.8981802368164062e+02, 3.6840687243966386e-05, 2, -1,
+    2.3040000915527344e+02, 1.7712001037597656e+02,
+    4.4640003204345703e+01, 3.4949880981445312e+02,
+    5.7470755564281717e-05, 2, -1, 2.3760000610351562e+02,
+    1.7712001037597656e+02, 4.4640003204345703e+01,
+    5.1544636487960815e-01, 1.3484232476912439e-04, 2, -1,
+    4.3200003051757812e+02, 1.7712001037597656e+02,
+    4.4640003204345703e+01, 1.2722912597656250e+02,
+    6.0996124375378713e-05, 2, -1, 4.3632000732421875e+02,
+    1.7712001037597656e+02, 4.4640003204345703e+01,
+    1.3663040161132812e+02, 6.9181223807390779e-05, 2, -1,
+    3.3552001953125000e+02, 1.7856001281738281e+02,
+    4.4640003204345703e+01, 5.8752067565917969e+01,
+    9.9123217296437360e-06, 2, -1, 3.9456002807617188e+02,
+    1.7856001281738281e+02, 4.4640003204345703e+01,
+    2.3900445556640625e+02, 3.5531675166566856e-06, 2, -1, 180., 180.,
+    4.4640003204345703e+01, 2.1944453430175781e+02,
+    2.7803131160908379e-05, 2, -1, 1.8576000976562500e+02, 180.,
+    4.4640003204345703e+01, 1.6709567260742188e+02,
+    1.0455861774971709e-04, 2, -1, 2.3328001403808594e+02, 180.,
+    4.4640003204345703e+01, 3.5269097900390625e+02,
+    1.2487520871218294e-04, 2, -1, 3.4416000366210938e+02, 180.,
+    4.4640003204345703e+01, 6.1538547515869141e+01,
+    5.5658074415987357e-06, 2, -1, 4.2624002075195312e+02, 180.,
+    4.4640003204345703e+01, 1.3111175537109375e+02,
+    1.5478372006327845e-05, 2, -1, 4.6800003051757812e+02, 180.,
+    4.4640003204345703e+01, 2.1423262023925781e+02,
+    5.1858864026144147e-05, 2, -1, 2.1888000488281250e+02,
+    1.8144000244140625e+02, 4.4640003204345703e+01,
+    2.4885926818847656e+02, 1.2054800208716188e-05, 2, -1,
+    2.3760000610351562e+02, 1.8144000244140625e+02,
+    4.4640003204345703e+01, 3.5756713867187500e+02,
+    8.2163467595819384e-05, 2, -1, 2.6783999633789062e+02,
+    1.8144000244140625e+02, 4.4640003204345703e+01,
+    2.0961822509765625e+02, 2.0802712242584676e-05, 2, -1,
+    3.7728002929687500e+02, 1.8144000244140625e+02,
+    4.4640003204345703e+01, 1.6421365356445312e+02,
+    1.8590442778076977e-04, 2, -1, 3.8448001098632812e+02,
+    1.8144000244140625e+02, 4.4640003204345703e+01,
+    1.7919224548339844e+02, 6.8104243837296963e-05, 2, -1,
+    3.9024002075195312e+02, 1.8144000244140625e+02,
+    4.4640003204345703e+01, 2.0414292907714844e+02,
+    1.8794116840581410e-05, 2, -1, 2.1600001525878906e+02,
+    1.8288000488281250e+02, 4.4640003204345703e+01,
+    2.2459368896484375e+02, 1.7872402167995460e-05, 2, -1,
+    2.8224002075195312e+02, 1.8288000488281250e+02,
+    4.4640003204345703e+01, 2.4764735412597656e+02,
+    -2.9874527172069065e-06, 2, -1, 3.0527999877929688e+02,
+    1.8288000488281250e+02, 4.4640003204345703e+01,
+    2.6912991333007812e+02, 2.3442236852133647e-05, 2, -1,
+    3.3552001953125000e+02, 1.8288000488281250e+02,
+    4.4640003204345703e+01, 8.5848541259765625e+00,
+    3.6134566471446306e-05, 2, -1, 4.0032000732421875e+02,
+    1.8288000488281250e+02, 4.4640003204345703e+01,
+    3.0758709716796875e+02, 2.2924341465113685e-05, 2, -1,
+    4.4208001708984375e+02, 1.8288000488281250e+02,
+    4.4640003204345703e+01, 1.6878341674804688e+02,
+    6.9467234425246716e-05, 2, -1, 2.2608000183105469e+02,
+    1.8432000732421875e+02, 4.4640003204345703e+01,
+    3.4531497192382812e+02, 1.4879245100019034e-05, 2, -1,
+    3.0240002441406250e+02, 1.8432000732421875e+02,
+    4.4640003204345703e+01, 2.6925781250000000e+02,
+    4.5960950956214219e-05, 2, -1, 3.2544000244140625e+02,
+    1.8432000732421875e+02, 4.4640003204345703e+01,
+    3.0404595947265625e+02, 5.6564076658105478e-06, 2, -1,
+    3.7440002441406250e+02, 1.8432000732421875e+02,
+    4.4640003204345703e+01, 1.6608462524414062e+02,
+    2.5858846493065357e-04, 2, -1, 4.1328002929687500e+02,
+    1.8432000732421875e+02, 4.4640003204345703e+01,
+    1.5485540628433228e+00, 8.7776861619204283e-06, 2, -1,
+    4.3776000976562500e+02, 1.8432000732421875e+02,
+    4.4640003204345703e+01, 1.5787132263183594e+02,
+    7.2917209763545543e-05, 2, -1, 4.4640002441406250e+02,
+    1.8432000732421875e+02, 4.4640003204345703e+01,
+    1.5525682067871094e+02, 1.0802697215694934e-04, 2, -1,
+    4.6224002075195312e+02, 1.8432000732421875e+02,
+    4.4640003204345703e+01, 2.2880558776855469e+02,
+    3.7097466702107340e-05, 2, -1, 4.7088000488281250e+02,
+    1.8432000732421875e+02, 4.4640003204345703e+01,
+    2.1086614990234375e+02, 7.7611412052647211e-06, 2, -1,
+    2.6640002441406250e+02, 1.8576000976562500e+02,
+    4.4640003204345703e+01, 2.2804737854003906e+02,
+    2.0510498870862648e-05, 2, -1, 2.9376000976562500e+02,
+    1.8576000976562500e+02, 4.4640003204345703e+01,
+    2.6358587646484375e+02, -1.3306062101037242e-06, 2, -1,
+    2.9808001708984375e+02, 1.8576000976562500e+02,
+    4.4640003204345703e+01, 2.6716024780273438e+02,
+    4.9524787755217403e-05, 2, -1, 3.2976000976562500e+02,
+    1.8576000976562500e+02, 4.4640003204345703e+01,
+    3.3957546997070312e+02, 2.4616010705358349e-05, 2, -1,
+    3.3408001708984375e+02, 1.8576000976562500e+02,
+    4.4640003204345703e+01, 3.5907528686523438e+02,
+    3.8488793506985530e-05, 2, -1, 3.7728002929687500e+02,
+    1.8576000976562500e+02, 4.4640003204345703e+01,
+    1.7415429687500000e+02, 2.3164940648712218e-04, 2, -1,
+    3.9024002075195312e+02, 1.8576000976562500e+02,
+    4.4640003204345703e+01, 1.9581433105468750e+02,
+    2.2808235371485353e-05, 2, -1, 4.5648001098632812e+02,
+    1.8576000976562500e+02, 4.4640003204345703e+01,
+    2.4132954406738281e+02, 1.4837820344837382e-05, 2, -1,
+    4.6800003051757812e+02, 1.8576000976562500e+02,
+    4.4640003204345703e+01, 2.1225843811035156e+02,
+    2.1697351257898845e-05, 2, -1, 2.5488000488281250e+02,
+    1.8720001220703125e+02, 4.4640003204345703e+01,
+    2.9036105346679688e+02, 7.4380754995218012e-06, 2, -1,
+    3.4416000366210938e+02, 1.8720001220703125e+02,
+    4.4640003204345703e+01, 2.8247070312500000e+01,
+    8.9130786363966763e-05, 2, -1, 3.9888000488281250e+02,
+    1.8720001220703125e+02, 4.4640003204345703e+01,
+    2.9253619384765625e+02, 1.7050580936484039e-05, 2, -1,
+    1.9584001159667969e+02, 1.8864001464843750e+02,
+    4.4640003204345703e+01, 2.1022091674804688e+02,
+    5.3156486501393374e-06, 2, -1, 2.3760000610351562e+02,
+    1.8864001464843750e+02, 4.4640003204345703e+01,
+    1.3382908821105957e+01, 1.3269112969283015e-04, 2, -1,
+    3.1680001831054688e+02, 1.8864001464843750e+02,
+    4.4640003204345703e+01, 2.8084265136718750e+02,
+    4.2666903027566150e-05, 2, -1, 3.7008001708984375e+02,
+    1.8864001464843750e+02, 4.4640003204345703e+01,
+    1.8507138061523438e+02, 1.8278844072483480e-04, 2, -1,
+    1.7280000305175781e+02, 1.9008000183105469e+02,
+    4.4640003204345703e+01, 1.7541247558593750e+02,
+    1.2585847798618488e-05, 2, -1, 2.2176000976562500e+02,
+    1.9008000183105469e+02, 4.4640003204345703e+01,
+    4.0719558715820312e+01, 3.1519444746663794e-05, 2, -1,
+    2.9232000732421875e+02, 1.9008000183105469e+02,
+    4.4640003204345703e+01, 2.6104223632812500e+02,
+    2.6698457077145576e-05, 2, -1, 3.1248001098632812e+02,
+    1.9008000183105469e+02, 4.4640003204345703e+01,
+    2.8872375488281250e+02, 5.8259829529561102e-05, 2, -1,
+    3.4704000854492188e+02, 1.9008000183105469e+02,
+    4.4640003204345703e+01, 2.7848585128784180e+01,
+    8.8090513600036502e-05, 2, -1, 4.6368002319335938e+02,
+    1.9008000183105469e+02, 4.4640003204345703e+01,
+    2.2228303527832031e+02, 6.5320797148160636e-05, 2, -1,
+    4.6656002807617188e+02, 1.9008000183105469e+02,
+    4.4640003204345703e+01, 2.1798443603515625e+02,
+    2.3557400709250942e-05, 2, -1, 1.8720001220703125e+02,
+    1.9152000427246094e+02, 4.4640003204345703e+01,
+    2.1826138305664062e+02, 4.3661792005877942e-05, 2, -1,
+    2.7360000610351562e+02, 1.9152000427246094e+02,
+    4.4640003204345703e+01, 2.2958438110351562e+02,
+    3.2445145188830793e-04, 2, -1, 2.7792001342773438e+02,
+    1.9152000427246094e+02, 4.4640003204345703e+01,
+    2.3737709045410156e+02, 4.6703306725248694e-04, 2, -1,
+    2.9664001464843750e+02, 1.9152000427246094e+02,
+    4.4640003204345703e+01, 2.6735168457031250e+02,
+    4.6344397560460493e-05, 2, -1, 3.6288000488281250e+02,
+    1.9152000427246094e+02, 4.4640003204345703e+01,
+    1.7540689086914062e+02, 4.4868116674479097e-05, 2, -1,
+    2.0880000305175781e+02, 1.9296000671386719e+02,
+    4.4640003204345703e+01, 1.8809078979492188e+02,
+    1.7756718079908751e-05, 2, -1, 2.1312001037597656e+02,
+    1.9296000671386719e+02, 4.4640003204345703e+01,
+    1.5351083374023438e+02, 4.0681188693270087e-05, 2, -1,
+    2.3904000854492188e+02, 1.9296000671386719e+02,
+    4.4640003204345703e+01, 2.0554471969604492e+01,
+    1.3219454558566213e-04, 2, -1, 2.8224002075195312e+02,
+    1.9296000671386719e+02, 4.4640003204345703e+01,
+    2.4383316040039062e+02, 3.7230629823170602e-04, 2, -1,
+    3.2976000976562500e+02, 1.9296000671386719e+02,
+    4.4640003204345703e+01, 3.4278515625000000e+02,
+    2.6816071112989448e-05, 2, -1, 3.4127999877929688e+02,
+    1.9296000671386719e+02, 4.4640003204345703e+01,
+    2.1357076644897461e+01, 1.6778829740360379e-04, 2, -1,
+    3.7296002197265625e+02, 1.9296000671386719e+02,
+    4.4640003204345703e+01, 1.7529902648925781e+02,
+    1.0728467168519273e-04, 2, -1, 3.8736001586914062e+02,
+    1.9296000671386719e+02, 4.4640003204345703e+01,
+    1.5444360351562500e+02, 1.3285051682032645e-04, 2, -1,
+    4.0320001220703125e+02, 1.9296000671386719e+02,
+    4.4640003204345703e+01, 3.3959375000000000e+02,
+    2.1996020223014057e-05, 2, -1, 4.0896002197265625e+02,
+    1.9296000671386719e+02, 4.4640003204345703e+01,
+    3.3443157958984375e+02, 2.1737985662184656e-05, 2, -1,
+    4.2192001342773438e+02, 1.9296000671386719e+02,
+    4.4640003204345703e+01, 6.8098907470703125e+01,
+    8.2439566995162750e-07, 2, -1, 2.3184001159667969e+02,
+    1.9440000915527344e+02, 4.4640003204345703e+01,
+    3.0713207244873047e+01, 3.1219719676300883e-04, 2, -1,
+    2.5632000732421875e+02, 1.9440000915527344e+02,
+    4.4640003204345703e+01, 2.3766940307617188e+02,
+    8.1520491221453995e-05, 2, -1, 3.0816000366210938e+02,
+    1.9440000915527344e+02, 4.4640003204345703e+01,
+    2.9273272705078125e+02, 8.7576707301195711e-05, 2, -1,
+    3.1104000854492188e+02, 1.9440000915527344e+02,
+    4.4640003204345703e+01, 2.9538232421875000e+02,
+    1.0834771819645539e-04, 2, -1, 3.8160000610351562e+02,
+    1.9440000915527344e+02, 4.4640003204345703e+01,
+    1.5604235839843750e+02, 1.3059431512374431e-04, 2, -1,
+    3.9168002319335938e+02, 1.9440000915527344e+02,
+    4.4640003204345703e+01, 1.3872671508789062e+02,
+    1.2062226596754044e-04, 2, -1, 3.9744000244140625e+02,
+    1.9440000915527344e+02, 4.4640003204345703e+01,
+    1.2119531250000000e+02, 1.9648163288366050e-05, 2, -1,
+    4.5936001586914062e+02, 1.9440000915527344e+02,
+    4.4640003204345703e+01, 2.1246719360351562e+02,
+    6.2417784647550434e-05, 2, -1, 2.1600001525878906e+02,
+    1.9584001159667969e+02, 4.4640003204345703e+01,
+    9.3456581115722656e+01, 2.6323288693674840e-05, 2, -1,
+    2.2752000427246094e+02, 1.9584001159667969e+02,
+    4.4640003204345703e+01, 4.1312839508056641e+01,
+    1.9767187768593431e-04, 2, -1, 2.7072000122070312e+02,
+    1.9584001159667969e+02, 4.4640003204345703e+01,
+    2.1055389404296875e+02, 1.7013949400279671e-04, 2, -1,
+    2.8944000244140625e+02, 1.9584001159667969e+02,
+    4.4640003204345703e+01, 2.5636511230468750e+02,
+    6.7190143454354256e-05, 2, -1, 2.9952001953125000e+02,
+    1.9584001159667969e+02, 4.4640003204345703e+01,
+    2.7838940429687500e+02, 5.7248358643846586e-05, 2, -1,
+    3.5280001831054688e+02, 1.9584001159667969e+02,
+    4.4640003204345703e+01, 4.0107635498046875e+01,
+    1.6694837540853769e-05, 2, -1, 4.3056002807617188e+02,
+    1.9584001159667969e+02, 4.4640003204345703e+01,
+    1.4012677001953125e+02, 1.2508744475780986e-05, 2, -1,
+    4.3632000732421875e+02, 1.9584001159667969e+02,
+    4.4640003204345703e+01, 1.4682431030273438e+02,
+    9.9643493740586564e-06, 2, -1, 2.0880000305175781e+02,
+    1.9728001403808594e+02, 4.4640003204345703e+01,
+    1.4924546813964844e+02, 3.1782386940903962e-05, 2, -1,
+    2.3040000915527344e+02, 1.9728001403808594e+02,
+    4.4640003204345703e+01, 3.9256397247314453e+01,
+    1.9135774346068501e-04, 2, -1, 2.4624000549316406e+02,
+    1.9728001403808594e+02, 4.4640003204345703e+01,
+    3.5602932739257812e+02, 1.7301920161116868e-04, 2, -1,
+    2.6064001464843750e+02, 1.9728001403808594e+02,
+    4.4640003204345703e+01, 2.1873867797851562e+02,
+    3.0863979191053659e-05, 2, -1, 3.0384002685546875e+02,
+    1.9728001403808594e+02, 4.4640003204345703e+01,
+    2.9167950439453125e+02, 6.0132890212116763e-05, 2, -1,
+    4.1040002441406250e+02, 1.9728001403808594e+02,
+    4.4640003204345703e+01, 1.1880126953125000e+01,
+    5.4307329264702275e-05, 2, -1, 4.4640002441406250e+02,
+    1.9728001403808594e+02, 4.4640003204345703e+01,
+    1.6585740661621094e+02, 8.7409745901823044e-05, 2, -1,
+    1.6416000366210938e+02, 1.9872000122070312e+02,
+    4.4640003204345703e+01, 2.1058004760742188e+02,
+    4.3858849494426977e-06, 2, -1, 2.3904000854492188e+02,
+    1.9872000122070312e+02, 4.4640003204345703e+01,
+    2.5154462814331055e+01, 1.0756558185676113e-04, 2, -1,
+    2.5200001525878906e+02, 1.9872000122070312e+02,
+    4.4640003204345703e+01, 2.4998399353027344e+02,
+    9.4475566584151238e-05, 2, -1, 2.6640002441406250e+02,
+    1.9872000122070312e+02, 4.4640003204345703e+01,
+    2.0195574951171875e+02, 1.2703584798146039e-04, 2, -1,
+    2.7360000610351562e+02, 1.9872000122070312e+02,
+    4.4640003204345703e+01, 1.9589115905761719e+02,
+    7.4361254519317299e-05, 2, -1, 3.0672000122070312e+02,
+    1.9872000122070312e+02, 4.4640003204345703e+01,
+    3.0210177612304688e+02, 2.2737479594070464e-04, 2, -1,
+    3.1248001098632812e+02, 1.9872000122070312e+02,
+    4.4640003204345703e+01, 3.1232992553710938e+02,
+    5.5708951549604535e-05, 2, -1, 3.4416000366210938e+02,
+    1.9872000122070312e+02, 4.4640003204345703e+01,
+    3.5238314819335938e+02, 3.3552460081409663e-05, 2, -1,
+    3.5280001831054688e+02, 1.9872000122070312e+02,
+    4.4640003204345703e+01, 3.4445919799804688e+02,
+    1.8588723833090626e-05, 2, -1, 3.6864001464843750e+02,
+    1.9872000122070312e+02, 4.4640003204345703e+01,
+    1.6849557495117188e+02, 5.0345937779638916e-05, 2, -1,
+    3.8160000610351562e+02, 1.9872000122070312e+02,
+    4.4640003204345703e+01, 1.3549139404296875e+02,
+    1.5275517944246531e-04, 2, -1, 3.8880001831054688e+02,
+    1.9872000122070312e+02, 4.4640003204345703e+01,
+    1.2431309509277344e+02, 2.1557405125349760e-04, 2, -1,
+    3.9744000244140625e+02, 1.9872000122070312e+02,
+    4.4640003204345703e+01, 1.1275104522705078e+02,
+    4.4777912989957258e-05, 2, -1, 4.0608001708984375e+02,
+    1.9872000122070312e+02, 4.4640003204345703e+01,
+    8.6505790710449219e+01, 2.5971903596655466e-05, 2, -1,
+    4.3920001220703125e+02, 1.9872000122070312e+02,
+    4.4640003204345703e+01, 1.5650097656250000e+02,
+    1.3467544704326428e-05, 2, -1, 4.5360000610351562e+02,
+    1.9872000122070312e+02, 4.4640003204345703e+01,
+    1.8621595764160156e+02, 1.0409343303763308e-05, 2, -1,
+    1.7568000793457031e+02, 2.0016000366210938e+02,
+    4.4640003204345703e+01, 2.2208628845214844e+02,
+    1.4186512089509051e-05, 2, -1, 1.9728001403808594e+02,
+    2.0016000366210938e+02, 4.4640003204345703e+01,
+    1.9975361633300781e+02, 1.3902717910241336e-06, 2, -1,
+    2.3328001403808594e+02, 2.0016000366210938e+02,
+    4.4640003204345703e+01, 4.0868579864501953e+01,
+    1.0105561523232609e-04, 2, -1, 3.1824002075195312e+02,
+    2.0016000366210938e+02, 4.4640003204345703e+01,
+    3.3103829956054688e+02, 1.2214893649797887e-04, 2, -1,
+    3.3120001220703125e+02, 2.0016000366210938e+02,
+    4.4640003204345703e+01, 3.4790383911132812e+02,
+    1.5309464288293384e-05, 2, -1, 4.0032000732421875e+02,
+    2.0016000366210938e+02, 4.4640003204345703e+01,
+    1.1323177337646484e+02, 5.6624208809807897e-05, 2, -1,
+    4.1328002929687500e+02, 2.0016000366210938e+02,
+    4.4640003204345703e+01, 2.3958196640014648e+01,
+    4.6789358748355880e-05, 2, -1, 4.1904000854492188e+02,
+    2.0016000366210938e+02, 4.4640003204345703e+01,
+    1.0684124946594238e+01, 7.4619661063479725e-06, 2, -1,
+    2.0304000854492188e+02, 2.0160000610351562e+02,
+    4.4640003204345703e+01, 1.4529895019531250e+02,
+    3.5601090075942921e-06, 2, -1, 2.1024000549316406e+02,
+    2.0160000610351562e+02, 4.4640003204345703e+01,
+    8.9378944396972656e+01, 5.3192172345006838e-05, 2, -1,
+    2.2320001220703125e+02, 2.0160000610351562e+02,
+    4.4640003204345703e+01, 5.5233062744140625e+01,
+    3.3645742223598063e-04, 2, -1, 3.0816000366210938e+02,
+    2.0160000610351562e+02, 4.4640003204345703e+01,
+    3.2462646484375000e+02, 1.9344296015333384e-04, 2, -1,
+    3.3696002197265625e+02, 2.0160000610351562e+02,
+    4.4640003204345703e+01, 3.4053195190429688e+02,
+    1.2545714525913354e-05, 2, -1, 4.4784002685546875e+02,
+    2.0160000610351562e+02, 4.4640003204345703e+01,
+    1.6204641723632812e+02, 5.1003913540625945e-05, 2, -1,
+    4.6080001831054688e+02, 2.0160000610351562e+02,
+    4.4640003204345703e+01, 2.0450413513183594e+02,
+    9.6432231657672673e-06, 2, -1, 1.6416000366210938e+02,
+    2.0304000854492188e+02, 4.4640003204345703e+01,
+    2.3977159118652344e+02, 4.0808041376294568e-05, 2, -1,
+    1.9584001159667969e+02, 2.0304000854492188e+02,
+    4.4640003204345703e+01, 1.8501223754882812e+02,
+    1.1565340400920832e-06, 2, -1, 2.2032000732421875e+02,
+    2.0304000854492188e+02, 4.4640003204345703e+01,
+    6.1009124755859375e+01, 3.3792204339988530e-04, 2, -1,
+    3.1104000854492188e+02, 2.0304000854492188e+02,
+    4.4640003204345703e+01, 3.4697445678710938e+02,
+    5.2409857744351029e-05, 2, -1, 3.2544000244140625e+02,
+    2.0304000854492188e+02, 4.4640003204345703e+01,
+    3.5609100341796875e+02, 7.0686379331164062e-05, 2, -1,
+    3.7152001953125000e+02, 2.0304000854492188e+02,
+    4.4640003204345703e+01, 1.7079476928710938e+02,
+    1.0745449253590778e-04, 2, -1, 3.7440002441406250e+02,
+    2.0304000854492188e+02, 4.4640003204345703e+01,
+    1.4783518981933594e+02, 6.0843380197184160e-05, 2, -1,
+    3.8160000610351562e+02, 2.0304000854492188e+02,
+    4.4640003204345703e+01, 1.1882933044433594e+02,
+    1.9487425743136555e-04, 2, -1, 3.9024002075195312e+02,
+    2.0304000854492188e+02, 4.4640003204345703e+01,
+    1.1823253631591797e+02, 2.7233143919147551e-04, 2, -1,
+    4.1472003173828125e+02, 2.0304000854492188e+02,
+    4.4640003204345703e+01, 3.3345840454101562e+01,
+    2.8287729946896434e-05, 2, -1, 4.5072003173828125e+02,
+    2.0304000854492188e+02, 4.4640003204345703e+01,
+    1.6799195861816406e+02, 1.0249678780382965e-05, 2, -1,
+    1.6992001342773438e+02, 2.0448001098632812e+02,
+    4.4640003204345703e+01, 2.4895774841308594e+02,
+    5.7470770116196945e-05, 2, -1, 2.0304000854492188e+02,
+    2.0448001098632812e+02, 4.4640003204345703e+01,
+    1.0811455535888672e+02, 2.0593886802089401e-05, 2, -1,
+    2.3472001647949219e+02, 2.0448001098632812e+02,
+    4.4640003204345703e+01, 5.2587284088134766e+01,
+    3.2114417990669608e-05, 2, -1, 2.4336001586914062e+02,
+    2.0448001098632812e+02, 4.4640003204345703e+01,
+    4.6311626434326172e+01, 4.3469652155181393e-05, 2, -1,
+    2.4912001037597656e+02, 2.0448001098632812e+02,
+    4.4640003204345703e+01, 1.8137808227539062e+02,
+    1.4543198631145060e-05, 2, -1, 2.5344000244140625e+02,
+    2.0448001098632812e+02, 4.4640003204345703e+01,
+    1.9474655151367188e+02, 2.6607236577547155e-05, 2, -1,
+    2.9376000976562500e+02, 2.0448001098632812e+02,
+    4.4640003204345703e+01, 2.1751606750488281e+02,
+    4.3645344703691080e-05, 2, -1, 4.0464001464843750e+02,
+    2.0448001098632812e+02, 4.4640003204345703e+01,
+    1.2591313934326172e+02, 6.5177599026355892e-05, 2, -1,
+    1.6560000610351562e+02, 2.0592001342773438e+02,
+    4.4640003204345703e+01, 2.4971949768066406e+02,
+    4.9980968469753861e-05, 2, -1, 2.1456001281738281e+02,
+    2.0592001342773438e+02, 4.4640003204345703e+01,
+    6.4202133178710938e+01, 2.0119635155424476e-04, 2, -1,
+    2.6640002441406250e+02, 2.0592001342773438e+02,
+    4.4640003204345703e+01, 1.8788769531250000e+02,
+    2.8951221611350775e-04, 2, -1, 2.7072000122070312e+02,
+    2.0592001342773438e+02, 4.4640003204345703e+01,
+    1.8970574951171875e+02, 1.7868007125798613e-04, 2, -1,
+    2.8655999755859375e+02, 2.0592001342773438e+02,
+    4.4640003204345703e+01, 1.7690223693847656e+02,
+    9.0413741418160498e-06, 2, -1, 3.2255999755859375e+02,
+    2.0592001342773438e+02, 4.4640003204345703e+01,
+    2.0806493759155273e+01, 1.9526590767782182e-04, 2, -1,
+    3.5568002319335938e+02, 2.0592001342773438e+02,
+    4.4640003204345703e+01, 2.5659857177734375e+02,
+    9.5104958745650947e-05, 2, -1, 3.7152001953125000e+02,
+    2.0592001342773438e+02, 4.4640003204345703e+01,
+    1.9735687255859375e+02, 1.0541242954786867e-04, 2, -1,
+    3.8592001342773438e+02, 2.0592001342773438e+02,
+    4.4640003204345703e+01, 1.1974434661865234e+02,
+    2.2547409753315151e-04, 2, -1, 4.5936001586914062e+02,
+    2.0592001342773438e+02, 4.4640003204345703e+01,
+    1.8957928466796875e+02, 5.6391872931271791e-06, 2, -1,
+    1.6127999877929688e+02, 2.0736001586914062e+02,
+    4.4640003204345703e+01, 2.4209277343750000e+02,
+    2.2530133719556034e-05, 2, -1, 2.2464001464843750e+02,
+    2.0736001586914062e+02, 4.4640003204345703e+01,
+    5.7167240142822266e+01, 5.2269944717409089e-05, 2, -1,
+    2.3328001403808594e+02, 2.0736001586914062e+02,
+    4.4640003204345703e+01, 6.3767723083496094e+01,
+    1.3712442523683421e-05, 2, -1, 2.6208001708984375e+02,
+    2.0736001586914062e+02, 4.4640003204345703e+01,
+    1.8433009338378906e+02, 5.2248888096073642e-05, 2, -1,
+    3.2976000976562500e+02, 2.0736001586914062e+02,
+    4.4640003204345703e+01, 2.1770936965942383e+01,
+    2.4834301439113915e-04, 2, -1, 3.3408001708984375e+02,
+    2.0736001586914062e+02, 4.4640003204345703e+01,
+    1.2315121650695801e+01, 4.0768758481135592e-05, 2, -1,
+    3.6144000244140625e+02, 2.0736001586914062e+02,
+    4.4640003204345703e+01, 2.2945416259765625e+02,
+    5.1919847464887425e-05, 2, -1, 3.7728002929687500e+02,
+    2.0736001586914062e+02, 4.4640003204345703e+01,
+    1.2696171569824219e+02, 6.5792803070507944e-05, 2, -1,
+    2.1024000549316406e+02, 2.0880000305175781e+02,
+    4.4640003204345703e+01, 6.2811317443847656e+01,
+    4.2045244481414557e-04, 2, -1, 2.7936001586914062e+02,
+    2.0880000305175781e+02, 4.4640003204345703e+01,
+    1.7417126464843750e+02, 2.6960953618981875e-05, 2, -1,
+    2.9376000976562500e+02, 2.0880000305175781e+02,
+    4.4640003204345703e+01, 1.1175851440429688e+02,
+    3.1903160561341792e-05, 2, -1, 3.0527999877929688e+02,
+    2.0880000305175781e+02, 4.4640003204345703e+01,
+    4.2282810211181641e+01, 2.6942077965941280e-05, 2, -1,
+    3.7008001708984375e+02, 2.0880000305175781e+02,
+    4.4640003204345703e+01, 1.8586145019531250e+02,
+    1.2416669051162899e-04, 2, -1, 3.2112002563476562e+02,
+    2.1024000549316406e+02, 4.4640003204345703e+01,
+    3.9836444854736328e+01, 1.7554641817696393e-04, 2, -1,
+    3.2688000488281250e+02, 2.1024000549316406e+02,
+    4.4640003204345703e+01, 4.2293571472167969e+01,
+    4.5914936345070601e-04, 2, -1, 3.5856002807617188e+02,
+    2.1024000549316406e+02, 4.4640003204345703e+01,
+    2.0694252014160156e+02, 3.5639288398670033e-05, 2, -1,
+    4.0608001708984375e+02, 2.1024000549316406e+02,
+    4.4640003204345703e+01, 1.2891787719726562e+02,
+    9.8091579275205731e-05, 2, -1, 2.8224002075195312e+02,
+    2.1168000793457031e+02, 4.4640003204345703e+01,
+    1.6274015808105469e+02, 3.4242155379615724e-05, 2, -1,
+    3.4560000610351562e+02, 2.1168000793457031e+02,
+    4.4640003204345703e+01, 4.4391029357910156e+01,
+    1.1824050488939974e-05, 2, -1, 3.6288000488281250e+02,
+    2.1168000793457031e+02, 4.4640003204345703e+01,
+    1.8292710876464844e+02, 5.4727897804696113e-05, 2, -1,
+    3.6576000976562500e+02, 2.1168000793457031e+02,
+    4.4640003204345703e+01, 1.7902391052246094e+02,
+    1.4294416178017855e-04, 2, -1, 3.7728002929687500e+02,
+    2.1168000793457031e+02, 4.4640003204345703e+01,
+    1.1223699951171875e+02, 7.8678167483303696e-05, 2, -1,
+    2.6208001708984375e+02, 2.1312001037597656e+02,
+    4.4640003204345703e+01, 1.5903779602050781e+02,
+    3.6503155570244417e-05, 2, -1, 4.0608001708984375e+02,
+    2.1312001037597656e+02, 4.4640003204345703e+01,
+    1.3472181701660156e+02, 1.0145586566068232e-04, 2, -1,
+    1.5408000183105469e+02, 2.1456001281738281e+02,
+    4.4640003204345703e+01, 2.2463299560546875e+02,
+    6.5912527134059928e-06, 2, -1, 2.1024000549316406e+02,
+    2.1456001281738281e+02, 4.4640003204345703e+01,
+    4.8019733428955078e+01, 2.7431015041656792e-04, 2, -1,
+    2.2464001464843750e+02, 2.1456001281738281e+02,
+    4.4640003204345703e+01, 5.9387325286865234e+01,
+    4.6856839617248625e-06, 2, -1, 2.4912001037597656e+02,
+    2.1456001281738281e+02, 4.4640003204345703e+01,
+    1.1893612670898438e+02, 2.8609838409465738e-06, 2, -1,
+    2.9088000488281250e+02, 2.1456001281738281e+02,
+    4.4640003204345703e+01, 1.1354219818115234e+02,
+    2.3721631805528887e-05, 2, -1, 3.0960000610351562e+02,
+    2.1456001281738281e+02, 4.4640003204345703e+01,
+    4.9018321990966797e+01, 5.9547364799072966e-05, 2, -1,
+    3.3120001220703125e+02, 2.1456001281738281e+02,
+    4.4640003204345703e+01, 4.9261741638183594e+01,
+    2.2453472774941474e-04, 2, -1, 3.8304000854492188e+02,
+    2.1456001281738281e+02, 4.4640003204345703e+01,
+    1.0939412689208984e+02, 1.6257303286693059e-05, 2, -1,
+    4.5072003173828125e+02, 2.1456001281738281e+02,
+    4.4640003204345703e+01, 1.9116534423828125e+02,
+    7.2877439379226416e-05, 2, -1, 4.5504000854492188e+02,
+    2.1456001281738281e+02, 4.4640003204345703e+01,
+    1.8868174743652344e+02, 2.8067743187421001e-05, 2, -1,
+    1.8432000732421875e+02, 2.1600001525878906e+02,
+    4.4640003204345703e+01, 3.5612570190429688e+02,
+    4.7801454456930514e-06, 2, -1, 2.6496002197265625e+02,
+    2.1600001525878906e+02, 4.4640003204345703e+01,
+    1.6669729614257812e+02, 1.8176402591052465e-05, 2, -1,
+    3.7008001708984375e+02, 2.1600001525878906e+02,
+    4.4640003204345703e+01, 1.1564866638183594e+02,
+    2.3335384321399033e-04, 2, -1, 4.1184002685546875e+02,
+    2.1600001525878906e+02, 4.4640003204345703e+01,
+    1.0286009216308594e+02, 2.5457396986894310e-05, 2, -1,
+    4.4784002685546875e+02, 2.1600001525878906e+02,
+    4.4640003204345703e+01, 1.9424702453613281e+02,
+    5.8448847994441167e-05, 2, -1, 1.6704000854492188e+02,
+    2.1744000244140625e+02, 4.4640003204345703e+01,
+    2.7357080078125000e+02, 7.1011127147357911e-05, 2, -1,
+    1.9728001403808594e+02, 2.1744000244140625e+02,
+    4.4640003204345703e+01, 8.9333389282226562e+01,
+    8.6162202933337539e-05, 2, -1, 2.0592001342773438e+02,
+    2.1744000244140625e+02, 4.4640003204345703e+01,
+    4.8675189971923828e+01, 2.3400397913064808e-04, 2, -1,
+    2.1024000549316406e+02, 2.1744000244140625e+02,
+    4.4640003204345703e+01, 3.8905967712402344e+01,
+    1.7822270456235856e-04, 2, -1, 3.6432000732421875e+02,
+    2.1744000244140625e+02, 4.4640003204345703e+01,
+    1.2468771362304688e+02, 1.3811179087497294e-04, 2, -1,
+    3.8160000610351562e+02, 2.1744000244140625e+02,
+    4.4640003204345703e+01, 9.9719383239746094e+01,
+    5.4302607168210670e-05, 2, -1, 1.7424000549316406e+02,
+    2.1888000488281250e+02, 4.4640003204345703e+01,
+    3.1459002685546875e+02, 1.8653276129043661e-05, 2, -1,
+    3.9744000244140625e+02, 2.1888000488281250e+02,
+    4.4640003204345703e+01, 1.5425097656250000e+02,
+    1.4695193385705352e-04, 2, -1, 4.5360000610351562e+02,
+    2.1888000488281250e+02, 4.4640003204345703e+01,
+    2.0394316101074219e+02, 1.7926786313182674e-05, 2, -1,
+    1.5984001159667969e+02, 2.2032000732421875e+02,
+    4.4640003204345703e+01, 2.2928890991210938e+02,
+    1.9791807062574662e-05, 2, -1, 1.6704000854492188e+02,
+    2.2032000732421875e+02, 4.4640003204345703e+01,
+    2.7509338378906250e+02, 1.1800167703768238e-04, 2, -1,
+    2.0448001098632812e+02, 2.2032000732421875e+02,
+    4.4640003204345703e+01, 4.3873935699462891e+01,
+    2.4104000476654619e-04, 2, -1, 2.7072000122070312e+02,
+    2.2032000732421875e+02, 4.4640003204345703e+01,
+    1.8810847473144531e+02, 1.9015962607227266e-05, 2, -1,
+    2.8224002075195312e+02, 2.2032000732421875e+02,
+    4.4640003204345703e+01, 1.9849089050292969e+02,
+    5.1835497288266197e-05, 2, -1, 2.8655999755859375e+02,
+    2.2032000732421875e+02, 4.4640003204345703e+01,
+    1.8040019226074219e+02, 4.1704912291606888e-05, 2, -1,
+    2.9520001220703125e+02, 2.2032000732421875e+02,
+    4.4640003204345703e+01, 5.8035499572753906e+01,
+    9.0622261268435977e-06, 2, -1, 3.0816000366210938e+02,
+    2.2032000732421875e+02, 4.4640003204345703e+01,
+    3.6761283874511719e+01, 2.0308641978772357e-05, 2, -1,
+    4.0464001464843750e+02, 2.2032000732421875e+02,
+    4.4640003204345703e+01, 1.4717088317871094e+02,
+    2.5290844496339560e-04, 2, -1, 1.9440000915527344e+02,
+    2.2176000976562500e+02, 4.4640003204345703e+01,
+    7.6580856323242188e+01, 3.2015370379667729e-05, 2, -1,
+    2.0016000366210938e+02, 2.2176000976562500e+02,
+    4.4640003204345703e+01, 6.1055194854736328e+01,
+    1.4887831639498472e-04, 2, -1, 2.9088000488281250e+02,
+    2.2176000976562500e+02, 4.4640003204345703e+01,
+    6.9179588317871094e+01, 2.9995386285008863e-05, 2, -1,
+    3.2255999755859375e+02, 2.2176000976562500e+02,
+    4.4640003204345703e+01, 3.3513922119140625e+02,
+    3.6805513445870019e-06, 2, -1, 3.3120001220703125e+02,
+    2.2176000976562500e+02, 4.4640003204345703e+01,
+    3.5450997924804688e+02, 2.4723808564885985e-06, 2, -1,
+    3.6576000976562500e+02, 2.2176000976562500e+02,
+    4.4640003204345703e+01, 1.0947528076171875e+02,
+    1.1113123036921024e-05, 2, -1, 4.2768002319335938e+02,
+    2.2176000976562500e+02, 4.4640003204345703e+01,
+    1.9691601562500000e+02, 5.5475466069765389e-06, 2, -1,
+    4.3776000976562500e+02, 2.2176000976562500e+02,
+    4.4640003204345703e+01, 2.0797850036621094e+02,
+    7.4735489761224017e-06, 2, -1, 4.5504000854492188e+02,
+    2.2176000976562500e+02, 4.4640003204345703e+01,
+    2.0890783691406250e+02, 7.2205534706881735e-06, 2, -1,
+    1.6416000366210938e+02, 2.2320001220703125e+02,
+    4.4640003204345703e+01, 2.4831918334960938e+02,
+    3.0802570108789951e-05, 2, -1, 1.8144000244140625e+02,
+    2.2320001220703125e+02, 4.4640003204345703e+01,
+    3.2983416748046875e+02, 1.3277643120090943e-05, 2, -1,
+    2.0304000854492188e+02, 2.2320001220703125e+02,
+    4.4640003204345703e+01, 4.3995590209960938e+01,
+    2.0397399202920496e-04, 2, -1, 2.5488000488281250e+02,
+    2.2320001220703125e+02, 4.4640003204345703e+01,
+    2.0896540832519531e+02, 1.1255467597948154e-06, 2, -1,
+    2.6783999633789062e+02, 2.2320001220703125e+02,
+    4.4640003204345703e+01, 1.9482942199707031e+02,
+    3.5045090044150129e-05, 2, -1, 3.9024002075195312e+02,
+    2.2320001220703125e+02, 4.4640003204345703e+01,
+    1.4901367187500000e+02, 1.3561011292040348e-04, 2, -1,
+    4.0752001953125000e+02, 2.2320001220703125e+02,
+    4.4640003204345703e+01, 1.3772827148437500e+02,
+    9.0126603026874363e-05, 2, -1, 3.8160000610351562e+02,
+    2.2464001464843750e+02, 4.4640003204345703e+01,
+    1.0535631561279297e+02, 1.6931740901782177e-05, 2, -1,
+    1.5263999938964844e+02, 2.2608000183105469e+02,
+    4.4640003204345703e+01, 2.0455099487304688e+02,
+    7.0357935328502208e-05, 2, -1, 1.9296000671386719e+02,
+    2.2608000183105469e+02, 4.4640003204345703e+01,
+    3.6086200714111328e+01, 6.6649145082919858e-06, 2, -1,
+    2.0880000305175781e+02, 2.2608000183105469e+02,
+    4.4640003204345703e+01, 1.9263322830200195e+01,
+    3.0886018066667020e-05, 2, -1, 2.7216000366210938e+02,
+    2.2608000183105469e+02, 4.4640003204345703e+01,
+    2.0608564758300781e+02, 8.2528160419315100e-05, 2, -1,
+    3.7296002197265625e+02, 2.2608000183105469e+02,
+    4.4640003204345703e+01, 9.9380912780761719e+01,
+    -7.9085511970333755e-05, 2, -1, 3.9888000488281250e+02,
+    2.2608000183105469e+02, 4.4640003204345703e+01,
+    1.6160025024414062e+02, 7.6728152635041624e-05, 2, -1,
+    1.7568000793457031e+02, 2.2752000427246094e+02,
+    4.4640003204345703e+01, 3.2925891113281250e+02,
+    1.7311638657702133e-05, 2, -1, 2.8080001831054688e+02,
+    2.2752000427246094e+02, 4.4640003204345703e+01,
+    2.3501388549804688e+02, 1.7395002942066640e-05, 2, -1,
+    2.9232000732421875e+02, 2.2752000427246094e+02,
+    4.4640003204345703e+01, 3.1434039306640625e+02,
+    6.3745137595105916e-05, 2, -1, 3.9168002319335938e+02,
+    2.2752000427246094e+02, 4.4640003204345703e+01,
+    1.6671578979492188e+02, 2.0696465071523562e-05, 2, -1,
+    4.3344000244140625e+02, 2.2752000427246094e+02,
+    4.4640003204345703e+01, 1.9559973144531250e+02,
+    4.6778663090663031e-05, 2, -1, 4.4928002929687500e+02,
+    2.2752000427246094e+02, 4.4640003204345703e+01,
+    2.0302586364746094e+02, 2.1925981855019927e-05, 2, -1,
+    2.4480000305175781e+02, 2.2896000671386719e+02,
+    4.4640003204345703e+01, 2.8557183837890625e+02,
+    4.1554153540346306e-06, 2, -1, 1.4832000732421875e+02,
+    2.3040000915527344e+02, 4.4640003204345703e+01,
+    2.0188748168945312e+02, 9.5559698820579797e-05, 2, -1,
+    1.5984001159667969e+02, 2.3040000915527344e+02,
+    4.4640003204345703e+01, 2.0868125915527344e+02,
+    9.5314928330481052e-05, 2, -1, 2.0304000854492188e+02,
+    2.3040000915527344e+02, 4.4640003204345703e+01,
+    2.3990669250488281e+01, 2.6641568183549680e-05, 2, -1,
+    2.2032000732421875e+02, 2.3040000915527344e+02,
+    4.4640003204345703e+01, 2.8643048095703125e+02,
+    8.3174018072895706e-06, 2, -1, 2.6783999633789062e+02,
+    2.3040000915527344e+02, 4.4640003204345703e+01,
+    2.1270851135253906e+02, 1.6458136087749153e-04, 2, -1,
+    1.4544000244140625e+02, 2.3184001159667969e+02,
+    4.4640003204345703e+01, 2.0810597229003906e+02,
+    4.9033576942747459e-05, 2, -1, 1.7712001037597656e+02,
+    2.3184001159667969e+02, 4.4640003204345703e+01,
+    3.4279299926757812e+02, 3.6271543649490923e-05, 2, -1,
+    4.0176000976562500e+02, 2.3184001159667969e+02,
+    4.4640003204345703e+01, 1.7297807312011719e+02,
+    2.2415292914956808e-04, 2, -1, 180., 2.3328001403808594e+02,
+    4.4640003204345703e+01, 3.3959689331054688e+02,
+    2.5083187210839242e-05, 2, -1, 1.9584001159667969e+02,
+    2.3328001403808594e+02, 4.4640003204345703e+01,
+    3.5689700317382812e+02, 8.5674628280685283e-06, 2, -1,
+    2.1024000549316406e+02, 2.3328001403808594e+02,
+    4.4640003204345703e+01, 3.5232431030273438e+02,
+    3.5930082958657295e-05, 2, -1, 2.8224002075195312e+02,
+    2.3328001403808594e+02, 4.4640003204345703e+01,
+    2.4487728881835938e+02, 1.9248382159275934e-05, 2, -1,
+    2.9664001464843750e+02, 2.3328001403808594e+02,
+    4.4640003204345703e+01, 3.1818460083007812e+02,
+    5.5803331633796915e-05, 2, -1, 4.4352001953125000e+02,
+    2.3328001403808594e+02, 4.4640003204345703e+01,
+    1.9025364685058594e+02, 2.5041701519512571e-05, 2, -1,
+    4.4784002685546875e+02, 2.3328001403808594e+02,
+    4.4640003204345703e+01, 1.9389372253417969e+02,
+    1.7723425116855651e-05, 2, -1, 1.5263999938964844e+02,
+    2.3472001647949219e+02, 4.4640003204345703e+01,
+    1.9348526000976562e+02, 1.3750594007433392e-05, 2, -1,
+    1.5696000671386719e+02, 2.3472001647949219e+02,
+    4.4640003204345703e+01, 1.9199093627929688e+02,
+    8.0002202594187111e-05, 2, -1, 1.6272000122070312e+02,
+    2.3472001647949219e+02, 4.4640003204345703e+01,
+    1.9412983703613281e+02, 2.0067689183633775e-04, 2, -1,
+    1.9296000671386719e+02, 2.3472001647949219e+02,
+    4.4640003204345703e+01, 3.4018386840820312e+02,
+    9.6377370937261730e-06, 2, -1, 2.7216000366210938e+02,
+    2.3472001647949219e+02, 4.4640003204345703e+01,
+    2.1212796020507812e+02, 1.1539445404196158e-04, 2, -1,
+    2.7504000854492188e+02, 2.3472001647949219e+02,
+    4.4640003204345703e+01, 2.1579785156250000e+02,
+    3.4981483622686937e-05, 2, -1, 2.8655999755859375e+02,
+    2.3472001647949219e+02, 4.4640003204345703e+01,
+    2.8343643188476562e+02, 5.9626058828143869e-06, 2, -1,
+    3.0816000366210938e+02, 2.3472001647949219e+02,
+    4.4640003204345703e+01, 2.9499243164062500e+02,
+    9.9326462077442557e-05, 2, -1, 3.9744000244140625e+02,
+    2.3472001647949219e+02, 4.4640003204345703e+01,
+    1.7751075744628906e+02, 1.4725278015248477e-04, 2, -1,
+    1.6704000854492188e+02, 2.3616000366210938e+02,
+    4.4640003204345703e+01, 6.4364185333251953e+00,
+    1.5059600991662592e-04, 2, -1, 2.2032000732421875e+02,
+    2.3616000366210938e+02, 4.4640003204345703e+01,
+    2.6069836425781250e+02, 7.4441748438403010e-05, 2, -1,
+    2.3760000610351562e+02, 2.3616000366210938e+02,
+    4.4640003204345703e+01, 2.7438061523437500e+02,
+    1.6285079254885204e-05, 2, -1, 4.3632000732421875e+02,
+    2.3616000366210938e+02, 4.4640003204345703e+01,
+    1.9089306640625000e+02, 1.5797390005900525e-05, 2, -1,
+    1.3680000305175781e+02, 2.3760000610351562e+02,
+    4.4640003204345703e+01, 2.2638433837890625e+02,
+    2.4759419829933904e-05, 2, -1, 1.7712001037597656e+02,
+    2.3760000610351562e+02, 4.4640003204345703e+01,
+    3.3599887084960938e+02, 1.1242971959291026e-04, 2, -1,
+    2.0880000305175781e+02, 2.3760000610351562e+02,
+    4.4640003204345703e+01, 3.2446582031250000e+02,
+    4.6349188778549433e-05, 2, -1, 3.0240002441406250e+02,
+    2.3760000610351562e+02, 4.4640003204345703e+01,
+    3.0983596801757812e+02, 1.1912533227587119e-04, 2, -1,
+    3.3408001708984375e+02, 2.3760000610351562e+02,
+    4.4640003204345703e+01, 3.2452951049804688e+02,
+    5.2641727961599827e-04, 2, -1, 3.9168002319335938e+02,
+    2.3760000610351562e+02, 4.4640003204345703e+01,
+    1.7628302001953125e+02, 1.6255389709840529e-05, 2, -1,
+    4.0176000976562500e+02, 2.3760000610351562e+02,
+    4.4640003204345703e+01, 1.6301707458496094e+02,
+    1.2943564797751606e-04, 2, -1, 4.4784002685546875e+02,
+    2.3760000610351562e+02, 4.4640003204345703e+01,
+    1.8710104370117188e+02, 9.5008408607100137e-06, 2, -1, 144.,
+    2.3904000854492188e+02, 4.4640003204345703e+01,
+    2.1793258666992188e+02, 1.0025314986705780e-04, 2, -1,
+    2.1456001281738281e+02, 2.3904000854492188e+02,
+    4.4640003204345703e+01, 2.7907507324218750e+02,
+    3.7256893847370520e-05, 2, -1, 2.2608000183105469e+02,
+    2.3904000854492188e+02, 4.4640003204345703e+01,
+    2.5215177917480469e+02, 7.8274333645822480e-06, 2, -1,
+    3.6576000976562500e+02, 2.3904000854492188e+02,
+    4.4640003204345703e+01, 2.5324995422363281e+02,
+    1.2821178825106472e-04, 2, -1, 3.6864001464843750e+02,
+    2.3904000854492188e+02, 4.4640003204345703e+01,
+    2.5502325439453125e+02, 8.3989078120794147e-05, 2, -1,
+    3.9888000488281250e+02, 2.3904000854492188e+02,
+    4.4640003204345703e+01, 1.6029348754882812e+02,
+    1.1914295464521274e-04, 2, -1, 1.3968000793457031e+02,
+    2.4048001098632812e+02, 4.4640003204345703e+01,
+    2.1981938171386719e+02, 1.6267337196040899e-04, 2, -1,
+    1.8144000244140625e+02, 2.4048001098632812e+02,
+    4.4640003204345703e+01, 3.1834039306640625e+02,
+    5.1361566875129938e-05, 2, -1, 1.9584001159667969e+02,
+    2.4048001098632812e+02, 4.4640003204345703e+01,
+    3.3276150512695312e+02, 2.3094293283065781e-05, 2, -1,
+    2.0592001342773438e+02, 2.4048001098632812e+02,
+    4.4640003204345703e+01, 3.2124383544921875e+02,
+    3.1597035558661446e-05, 2, -1, 2.6064001464843750e+02,
+    2.4048001098632812e+02, 4.4640003204345703e+01,
+    2.1214215087890625e+02, 7.3091301601380110e-05, 2, -1,
+    2.6640002441406250e+02, 2.4048001098632812e+02,
+    4.4640003204345703e+01, 1.9507565307617188e+02,
+    1.2203677033539861e-04, 2, -1, 3.5136001586914062e+02,
+    2.4048001098632812e+02, 4.4640003204345703e+01,
+    2.7951266479492188e+02, 5.3094458962732460e-06, 2, -1,
+    1.3391999816894531e+02, 2.4192001342773438e+02,
+    4.4640003204345703e+01, 1.9600479125976562e+02,
+    1.8064683899865486e-05, 2, -1, 1.6704000854492188e+02,
+    2.4192001342773438e+02, 4.4640003204345703e+01,
+    9.5505363464355469e+01, 3.4039301681332290e-05, 2, -1,
+    1.7424000549316406e+02, 2.4192001342773438e+02,
+    4.4640003204345703e+01, 3.2145233154296875e+02,
+    1.9591295858845115e-04, 2, -1, 2.3328001403808594e+02,
+    2.4192001342773438e+02, 4.4640003204345703e+01,
+    2.6281094360351562e+02, 6.3053063058760017e-05, 2, -1,
+    3.7440002441406250e+02, 2.4192001342773438e+02,
+    4.4640003204345703e+01, 2.6911160278320312e+02,
+    3.8462942029582337e-05, 2, -1, 4.3632000732421875e+02,
+    2.4192001342773438e+02, 4.4640003204345703e+01,
+    1.9761074829101562e+02, 8.5186351498123258e-05, 2, -1,
+    4.4352001953125000e+02, 2.4192001342773438e+02,
+    4.4640003204345703e+01, 1.8416203308105469e+02,
+    3.1300220143748447e-05, 2, -1, 1.7136000061035156e+02,
+    2.4336001586914062e+02, 4.4640003204345703e+01,
+    3.2338198852539062e+02, 1.2977456208318472e-04, 2, -1,
+    1.8576000976562500e+02, 2.4336001586914062e+02,
+    4.4640003204345703e+01, 3.2987078857421875e+02,
+    6.4803120039869100e-05, 2, -1, 2.1744000244140625e+02,
+    2.4336001586914062e+02, 4.4640003204345703e+01,
+    2.4446820068359375e+02, 7.5155967351747677e-06, 2, -1,
+    2.4768000793457031e+02, 2.4336001586914062e+02,
+    4.4640003204345703e+01, 2.7895840454101562e+02,
+    2.1434345399029553e-05, 2, -1, 2.6783999633789062e+02,
+    2.4336001586914062e+02, 4.4640003204345703e+01,
+    1.8845126342773438e+02, 8.6657571955583990e-05, 2, -1,
+    3.9168002319335938e+02, 2.4336001586914062e+02,
+    4.4640003204345703e+01, 1.7608259582519531e+02,
+    7.4794734246097505e-05, 2, -1, 1.3391999816894531e+02,
+    2.4480000305175781e+02, 4.4640003204345703e+01,
+    1.5732485961914062e+02, 4.1868210246320814e-05, 2, -1,
+    1.3680000305175781e+02, 2.4480000305175781e+02,
+    4.4640003204345703e+01, 1.5912203979492188e+02,
+    1.7472107720095664e-04, 2, -1, 1.4832000732421875e+02,
+    2.4480000305175781e+02, 4.4640003204345703e+01,
+    1.5896228027343750e+02, 3.0818737286608666e-05, 2, -1,
+    2.2752000427246094e+02, 2.4480000305175781e+02,
+    4.4640003204345703e+01, 2.2648152160644531e+02,
+    7.5611114880302921e-06, 2, -1, 2.3328001403808594e+02,
+    2.4480000305175781e+02, 4.4640003204345703e+01,
+    2.5030767822265625e+02, 1.8533855836722068e-05, 2, -1,
+    3.0240002441406250e+02, 2.4480000305175781e+02,
+    4.4640003204345703e+01, 2.2271312713623047e+01,
+    3.7822296144440770e-04, 2, -1, 3.0527999877929688e+02,
+    2.4480000305175781e+02, 4.4640003204345703e+01,
+    3.5413418579101562e+02, 3.1720247352495790e-04, 2, -1,
+    3.5424002075195312e+02, 2.4480000305175781e+02,
+    4.4640003204345703e+01, 2.6906970214843750e+02,
+    6.4619984186720103e-05, 2, -1, 3.6288000488281250e+02,
+    2.4480000305175781e+02, 4.4640003204345703e+01,
+    2.6563629150390625e+02, 1.7427586135454476e-04, 2, -1,
+    1.4112001037597656e+02, 2.4624000549316406e+02,
+    4.4640003204345703e+01, 1.3817710876464844e+02,
+    1.7133244546130300e-04, 2, -1, 1.6272000122070312e+02,
+    2.4624000549316406e+02, 4.4640003204345703e+01,
+    1.2288913726806641e+02, 7.8523808042518795e-05, 2, -1,
+    2.3616000366210938e+02, 2.4624000549316406e+02,
+    4.4640003204345703e+01, 2.5184263610839844e+02,
+    1.5085780432855245e-05, 2, -1, 3.0960000610351562e+02,
+    2.4624000549316406e+02, 4.4640003204345703e+01,
+    1.4063371276855469e+02, 9.5574556326027960e-05, 2, -1,
+    3.3552001953125000e+02, 2.4624000549316406e+02,
+    4.4640003204345703e+01, 3.1375625610351562e+02,
+    2.1947921777609736e-04, 2, -1, 3.4704000854492188e+02,
+    2.4624000549316406e+02, 4.4640003204345703e+01,
+    2.9053921508789062e+02, 1.2361456174403429e-04, 2, -1,
+    3.5136001586914062e+02, 2.4624000549316406e+02,
+    4.4640003204345703e+01, 2.7945834350585938e+02,
+    1.4334556180983782e-04, 2, -1, 3.7008001708984375e+02,
+    2.4624000549316406e+02, 4.4640003204345703e+01,
+    2.8129144287109375e+02, 1.2358598178252578e-04, 2, -1,
+    3.8880001831054688e+02, 2.4624000549316406e+02,
+    4.4640003204345703e+01, 2.1801155090332031e+02,
+    9.6531635790597647e-05, 2, -1, 1.7568000793457031e+02,
+    2.4768000793457031e+02, 4.4640003204345703e+01,
+    4.4982307434082031e+01, 1.2640643399208784e-04, 2, -1,
+    2.9088000488281250e+02, 2.4768000793457031e+02,
+    4.4640003204345703e+01, 6.4819473266601562e+01,
+    3.7781061109853908e-05, 2, -1, 3.1536001586914062e+02,
+    2.4768000793457031e+02, 4.4640003204345703e+01,
+    1.4226879882812500e+02, 1.7482873226981610e-04, 2, -1,
+    3.3984002685546875e+02, 2.4768000793457031e+02,
+    4.4640003204345703e+01, 3.1187716674804688e+02,
+    3.3449108013883233e-04, 2, -1, 3.7872000122070312e+02,
+    2.4768000793457031e+02, 4.4640003204345703e+01,
+    2.7913052368164062e+02, 2.1613803983200341e-04, 2, -1,
+    3.9456002807617188e+02, 2.4768000793457031e+02,
+    4.4640003204345703e+01, 2.1851950073242188e+02,
+    5.2754068747162819e-05, 2, -1, 1.3104000854492188e+02,
+    2.4912001037597656e+02, 4.4640003204345703e+01,
+    1.2750603485107422e+02, 6.4762076362967491e-05, 2, -1,
+    1.5120001220703125e+02, 2.4912001037597656e+02,
+    4.4640003204345703e+01, 1.0604107666015625e+02,
+    8.5257961472962052e-05, 2, -1, 1.6992001342773438e+02,
+    2.4912001037597656e+02, 4.4640003204345703e+01,
+    1.0800910949707031e+02, 2.4827063316479325e-04, 2, -1,
+    1.7856001281738281e+02, 2.4912001037597656e+02,
+    4.4640003204345703e+01, 4.4911819458007812e+01,
+    7.8123783168848604e-05, 2, -1, 2.6783999633789062e+02,
+    2.4912001037597656e+02, 4.4640003204345703e+01,
+    1.7370007324218750e+02, 2.2875690774526447e-05, 2, -1,
+    3.4416000366210938e+02, 2.4912001037597656e+02,
+    4.4640003204345703e+01, 3.0274649047851562e+02,
+    1.8351193284615874e-04, 2, -1, 3.6288000488281250e+02,
+    2.4912001037597656e+02, 4.4640003204345703e+01,
+    2.7235028076171875e+02, 1.2363822315819561e-04, 2, -1,
+    3.7584002685546875e+02, 2.4912001037597656e+02,
+    4.4640003204345703e+01, 2.8328918457031250e+02,
+    2.2904484649188817e-04, 2, -1, 3.8448001098632812e+02,
+    2.4912001037597656e+02, 4.4640003204345703e+01,
+    2.6585983276367188e+02, 7.7131648140493780e-05, 2, -1,
+    1.3968000793457031e+02, 2.5056001281738281e+02,
+    4.4640003204345703e+01, 1.1666340637207031e+02,
+    2.2742371947970241e-04, 2, -1, 1.4832000732421875e+02,
+    2.5056001281738281e+02, 4.4640003204345703e+01,
+    1.0797182464599609e+02, 2.0881409000139683e-04, 2, -1,
+    1.6560000610351562e+02, 2.5056001281738281e+02,
+    4.4640003204345703e+01, 1.1208123779296875e+02,
+    1.9132530724164099e-04, 2, -1, 1.9872000122070312e+02,
+    2.5056001281738281e+02, 4.4640003204345703e+01,
+    4.0328197479248047e+00, 5.4944066505413502e-05, 2, -1,
+    2.9232000732421875e+02, 2.5056001281738281e+02,
+    4.4640003204345703e+01, 6.8942352294921875e+01,
+    4.5663375203730538e-05, 2, -1, 3.3552001953125000e+02,
+    2.5056001281738281e+02, 4.4640003204345703e+01,
+    3.3340777587890625e+02, 3.7560146301984787e-04, 2, -1,
+    3.5136001586914062e+02, 2.5056001281738281e+02,
+    4.4640003204345703e+01, 2.7557254028320312e+02,
+    1.2841558782383800e-04, 2, -1, 3.7008001708984375e+02,
+    2.5056001281738281e+02, 4.4640003204345703e+01,
+    2.8959567260742188e+02, 7.0340611273422837e-05, 2, -1,
+    3.7872000122070312e+02, 2.5056001281738281e+02,
+    4.4640003204345703e+01, 2.8029830932617188e+02,
+    2.1608834504149854e-04, 2, -1, 1.2672000122070312e+02,
+    2.5200001525878906e+02, 4.4640003204345703e+01,
+    1.1502176666259766e+02, 6.1577156884595752e-05, 2, -1,
+    1.7424000549316406e+02, 2.5200001525878906e+02,
+    4.4640003204345703e+01, 9.9018768310546875e+01,
+    4.8450925532961264e-05, 2, -1, 3.0384002685546875e+02,
+    2.5200001525878906e+02, 4.4640003204345703e+01,
+    8.5738037109375000e+01, 7.6641132181975991e-05, 2, -1,
+    3.2112002563476562e+02, 2.5200001525878906e+02,
+    4.4640003204345703e+01, 8.2911590576171875e+01,
+    2.0075375505257398e-04, 2, -1, 3.5856002807617188e+02,
+    2.5200001525878906e+02, 4.4640003204345703e+01,
+    2.6474084472656250e+02, 7.7072843851055950e-05, 2, -1,
+    4.4208001708984375e+02, 2.5200001525878906e+02,
+    4.4640003204345703e+01, 2.0682592773437500e+02,
+    7.0521514317078982e-06, 2, -1, 1.3104000854492188e+02,
+    2.5344000244140625e+02, 4.4640003204345703e+01,
+    1.1696553039550781e+02, 2.2151667508296669e-04, 2, -1,
+    1.5120001220703125e+02, 2.5344000244140625e+02,
+    4.4640003204345703e+01, 9.8576644897460938e+01,
+    1.6858137678354979e-04, 2, -1, 2.8944000244140625e+02,
+    2.5344000244140625e+02, 4.4640003204345703e+01,
+    7.7030479431152344e+01, 1.4308152458397672e-05, 2, -1,
+    3.1824002075195312e+02, 2.5344000244140625e+02,
+    4.4640003204345703e+01, 1.0223902893066406e+02,
+    2.1867107716389000e-04, 2, -1, 3.2832000732421875e+02,
+    2.5344000244140625e+02, 4.4640003204345703e+01,
+    4.7825981140136719e+01, 9.7123956948053092e-05, 2, -1,
+    3.3552001953125000e+02, 2.5344000244140625e+02,
+    4.4640003204345703e+01, 6.6947755813598633e+00,
+    2.1964716142974794e-04, 2, -1, 3.7152001953125000e+02,
+    2.5344000244140625e+02, 4.4640003204345703e+01,
+    2.9313977050781250e+02, 6.0491518524941057e-05, 2, -1,
+    4.1472003173828125e+02, 2.5344000244140625e+02,
+    4.4640003204345703e+01, 2.3783753967285156e+02,
+    1.6460937331430614e-05, 2, -1, 4.2768002319335938e+02,
+    2.5344000244140625e+02, 4.4640003204345703e+01,
+    2.3555549621582031e+02, 4.4879548113385681e-06, 2, -1,
+    1.9584001159667969e+02, 2.5488000488281250e+02,
+    4.4640003204345703e+01, 5.4743278503417969e+01,
+    1.8119097512681037e-04, 2, -1, 2.9952001953125000e+02,
+    2.5488000488281250e+02, 4.4640003204345703e+01,
+    8.0542770385742188e+01, 9.6308795036748052e-06, 2, -1,
+    1.2384000396728516e+02, 2.5632000732421875e+02,
+    4.4640003204345703e+01, 9.6273780822753906e+01,
+    1.8134107449441217e-05, 2, -1, 1.4544000244140625e+02,
+    2.5632000732421875e+02, 4.4640003204345703e+01,
+    9.7892677307128906e+01, 2.6702551986090839e-04, 2, -1,
+    1.4832000732421875e+02, 2.5632000732421875e+02,
+    4.4640003204345703e+01, 9.5973495483398438e+01,
+    2.0556697563733906e-04, 2, -1, 1.6416000366210938e+02,
+    2.5632000732421875e+02, 4.4640003204345703e+01,
+    1.0398639678955078e+02, 4.7332381654996425e-05, 2, -1,
+    2.9088000488281250e+02, 2.5632000732421875e+02,
+    4.4640003204345703e+01, 7.9590614318847656e+01,
+    7.6261922004050575e-06, 2, -1, 3.0960000610351562e+02,
+    2.5632000732421875e+02, 4.4640003204345703e+01,
+    9.9193061828613281e+01, 2.1371926777646877e-05, 2, -1,
+    3.1392001342773438e+02, 2.5632000732421875e+02,
+    4.4640003204345703e+01, 1.0291386413574219e+02,
+    1.8614700820762664e-05, 2, -1, 3.3264001464843750e+02,
+    2.5632000732421875e+02, 4.4640003204345703e+01,
+    5.6683773040771484e+01, 1.0507377010071650e-04, 2, -1,
+    1.3104000854492188e+02, 2.5776000976562500e+02,
+    4.4640003204345703e+01, 1.1077632141113281e+02,
+    6.7238936026114970e-05, 2, -1, 1.4112001037597656e+02,
+    2.5776000976562500e+02, 4.4640003204345703e+01,
+    1.0338089752197266e+02, 2.3354261429631151e-05, 2, -1,
+    1.5120001220703125e+02, 2.5776000976562500e+02,
+    4.4640003204345703e+01, 9.5480194091796875e+01,
+    8.9099783508572727e-05, 2, -1, 1.7712001037597656e+02,
+    2.5776000976562500e+02, 4.4640003204345703e+01,
+    9.7135726928710938e+01, 4.3188523704884574e-05, 2, -1,
+    1.8864001464843750e+02, 2.5776000976562500e+02,
+    4.4640003204345703e+01, 7.0198059082031250e+01,
+    7.9619407188147306e-05, 2, -1, 1.9440000915527344e+02,
+    2.5776000976562500e+02, 4.4640003204345703e+01,
+    6.7550079345703125e+01, 1.5899550635367632e-04, 2, -1,
+    2.2752000427246094e+02, 2.5776000976562500e+02,
+    4.4640003204345703e+01, 1.2079187011718750e+02,
+    3.6831985198659822e-05, 2, -1, 3.1824002075195312e+02,
+    2.5776000976562500e+02, 4.4640003204345703e+01,
+    1.0296989440917969e+02, 2.4583912818343379e-05, 2, -1, 324.,
+    2.5776000976562500e+02, 4.4640003204345703e+01,
+    9.1923980712890625e+01, 3.8360896724043414e-05, 2, -1,
+    3.5280001831054688e+02, 2.5776000976562500e+02,
+    4.4640003204345703e+01, 2.4232490539550781e+02,
+    1.7997022951021791e-05, 2, -1, 3.6432000732421875e+02,
+    2.5776000976562500e+02, 4.4640003204345703e+01,
+    2.9252969360351562e+02, 1.3933960872236639e-05, 2, -1,
+    3.7872000122070312e+02, 2.5776000976562500e+02,
+    4.4640003204345703e+01, 2.7687799072265625e+02,
+    9.2474037955980748e-06, 2, -1, 4.1328002929687500e+02,
+    2.5776000976562500e+02, 4.4640003204345703e+01,
+    2.2798243713378906e+02, 3.9503593143308535e-05, 2, -1,
+    4.1904000854492188e+02, 2.5776000976562500e+02,
+    4.4640003204345703e+01, 2.3181274414062500e+02,
+    9.8771059128921479e-05, 2, -1, 1.6560000610351562e+02,
+    2.5920001220703125e+02, 4.4640003204345703e+01,
+    1.0173817443847656e+02, 1.2173833056294825e-05, 2, -1,
+    1.8432000732421875e+02, 2.5920001220703125e+02,
+    4.4640003204345703e+01, 8.2680091857910156e+01,
+    5.3636616939911619e-05, 2, -1, 2.2320001220703125e+02,
+    2.5920001220703125e+02, 4.4640003204345703e+01,
+    1.1253850555419922e+02, 8.1186677562072873e-05, 2, -1,
+    3.2832000732421875e+02, 2.5920001220703125e+02,
+    4.4640003204345703e+01, 8.3570793151855469e+01,
+    2.5952067517209798e-05, 2, -1, 1.5263999938964844e+02,
+    2.6064001464843750e+02, 4.4640003204345703e+01,
+    9.7511962890625000e+01, 3.0735889595234767e-05, 2, -1,
+    2.3616000366210938e+02, 2.6064001464843750e+02,
+    4.4640003204345703e+01, 1.0820153045654297e+02,
+    8.5215586295817047e-05, 2, -1, 2.4048001098632812e+02,
+    2.6064001464843750e+02, 4.4640003204345703e+01,
+    1.0415753173828125e+02, 8.3914688730146736e-05, 2, -1,
+    2.4480000305175781e+02, 2.6064001464843750e+02,
+    4.4640003204345703e+01, 9.6710296630859375e+01,
+    4.5709468395216390e-05, 2, -1, 3.6144000244140625e+02,
+    2.6064001464843750e+02, 4.4640003204345703e+01,
+    2.8688867187500000e+02, 2.4413689970970154e-05, 2, -1,
+    4.1904000854492188e+02, 2.6064001464843750e+02,
+    4.4640003204345703e+01, 2.2321502685546875e+02,
+    4.3235599150648341e-05, 2, -1, 4.3488000488281250e+02,
+    2.6064001464843750e+02, 4.4640003204345703e+01,
+    2.1598379516601562e+02, 1.8345421267440543e-05, 2, -1,
+    1.7856001281738281e+02, 2.6208001708984375e+02,
+    4.4640003204345703e+01, 9.6050491333007812e+01,
+    5.1391423767199740e-05, 2, -1, 2.5200001525878906e+02,
+    2.6208001708984375e+02, 4.4640003204345703e+01,
+    9.6988632202148438e+01, 6.9586953031830490e-05, 2, -1,
+    2.6064001464843750e+02, 2.6208001708984375e+02,
+    4.4640003204345703e+01, 1.0465301513671875e+02,
+    3.8572015910176560e-05, 2, -1, 3.4848001098632812e+02,
+    2.6208001708984375e+02, 4.4640003204345703e+01,
+    1.8381256103515625e+02, 1.3287546607898548e-05, 2, -1,
+    4.6512002563476562e+02, 2.6208001708984375e+02,
+    4.4640003204345703e+01, 2.0174383544921875e+02,
+    1.5602141729686991e-06, 2, -1, 1.6992001342773438e+02,
+    2.6352001953125000e+02, 4.4640003204345703e+01,
+    1.0070998382568359e+02, 1.2861092727689538e-05, 2, -1,
+    1.8288000488281250e+02, 2.6352001953125000e+02,
+    4.4640003204345703e+01, 9.1168266296386719e+01,
+    3.8894497265573591e-05, 2, -1, 3.5712002563476562e+02,
+    2.6352001953125000e+02, 4.4640003204345703e+01,
+    1.9217698669433594e+02, 1.1720186193997506e-05, 2, -1,
+    3.6144000244140625e+02, 2.6352001953125000e+02,
+    4.4640003204345703e+01, 2.8661216735839844e+01,
+    1.7179965652758256e-05, 2, -1, 4.3488000488281250e+02,
+    2.6352001953125000e+02, 4.4640003204345703e+01,
+    2.0567134094238281e+02, 1.4885856217006221e-05, 2, -1,
+    1.7712001037597656e+02, 2.6496002197265625e+02,
+    4.4640003204345703e+01, 9.8241737365722656e+01,
+    1.9172168322256766e-05, 2, -1, 1.8864001464843750e+02,
+    2.6496002197265625e+02, 4.4640003204345703e+01,
+    8.9549415588378906e+01, 1.0518858289287891e-05, 2, -1,
+    2.5056001281738281e+02, 2.6496002197265625e+02,
+    4.4640003204345703e+01, 1.0084539794921875e+02,
+    6.6559070546645671e-05, 2, -1, 2.7216000366210938e+02,
+    2.6496002197265625e+02, 4.4640003204345703e+01,
+    9.7374412536621094e+01, 5.3017713071312755e-05, 2, -1,
+    2.7648001098632812e+02, 2.6496002197265625e+02,
+    4.4640003204345703e+01, 1.0021911621093750e+02,
+    3.4389999200357124e-05, 2, -1, 3.9600003051757812e+02,
+    2.6496002197265625e+02, 4.4640003204345703e+01,
+    2.3366049194335938e+02, 6.9260087911970913e-05, 2, -1,
+    4.1184002685546875e+02, 2.6496002197265625e+02,
+    4.4640003204345703e+01, 1.9511122131347656e+02,
+    3.4287124435650185e-05, 2, -1, 4.1760000610351562e+02,
+    2.6496002197265625e+02, 4.4640003204345703e+01,
+    2.0339350891113281e+02, 3.2044546969700605e-05, 2, -1,
+    4.2768002319335938e+02, 2.6496002197265625e+02,
+    4.4640003204345703e+01, 2.0125244140625000e+02,
+    9.2917238362133503e-05, 2, -1, 2.5920001220703125e+02,
+    2.6640002441406250e+02, 4.4640003204345703e+01,
+    9.7138420104980469e+01, 4.5627533836523071e-05, 2, -1, 288.,
+    2.6640002441406250e+02, 4.4640003204345703e+01,
+    9.7514465332031250e+01, 3.2209467462962493e-05, 2, -1,
+    1.2240000152587891e+02, 2.6783999633789062e+02,
+    4.4640003204345703e+01, 5.9785469055175781e+01,
+    5.8265663938072976e-06, 2, -1, 2.0016000366210938e+02,
+    2.6783999633789062e+02, 4.4640003204345703e+01,
+    8.5485374450683594e+01, 1.1565659406187478e-05, 2, -1,
+    2.1744000244140625e+02, 2.6783999633789062e+02,
+    4.4640003204345703e+01, 1.0214159393310547e+02,
+    7.2524912866356317e-06, 2, -1, 2.6352001953125000e+02,
+    2.6783999633789062e+02, 4.4640003204345703e+01,
+    9.6282272338867188e+01, 3.0959021387388930e-05, 2, -1,
+    2.7072000122070312e+02, 2.6783999633789062e+02,
+    4.4640003204345703e+01, 9.7390945434570312e+01,
+    6.7772081820294261e-05, 2, -1, 2.7504000854492188e+02,
+    2.6783999633789062e+02, 4.4640003204345703e+01,
+    1.0042393493652344e+02, 4.9200745706912130e-05, 2, -1,
+    2.8224002075195312e+02, 2.6783999633789062e+02,
+    4.4640003204345703e+01, 9.8927536010742188e+01,
+    6.1941595049574971e-05, 2, -1, 2.9664001464843750e+02,
+    2.6783999633789062e+02, 4.4640003204345703e+01,
+    9.2813667297363281e+01, 3.2249979994958267e-05, 2, -1,
+    3.9744000244140625e+02, 2.6783999633789062e+02,
+    4.4640003204345703e+01, 2.2445404052734375e+02,
+    1.7041261889971793e-04, 2, -1, 4.1616000366210938e+02,
+    2.6783999633789062e+02, 4.4640003204345703e+01,
+    1.8369252014160156e+02, 6.2661463744007051e-05, 2, -1,
+    4.3488000488281250e+02, 2.6783999633789062e+02,
+    4.4640003204345703e+01, 1.9328135681152344e+02,
+    1.8564105630503036e-05, 2, -1, 1.2960000610351562e+02,
+    2.6927999877929688e+02, 4.4640003204345703e+01,
+    9.0395996093750000e+01, 8.5655219663749449e-06, 2, -1,
+    2.9952001953125000e+02, 2.6927999877929688e+02,
+    4.4640003204345703e+01, 9.3955307006835938e+01,
+    5.8301720855524763e-05, 2, -1, 3.0816000366210938e+02,
+    2.6927999877929688e+02, 4.4640003204345703e+01,
+    7.3424560546875000e+01, 5.4730982810724527e-05, 2, -1,
+    3.8304000854492188e+02, 2.6927999877929688e+02,
+    4.4640003204345703e+01, 2.4146229553222656e+02,
+    1.1047800398955587e-05, 2, -1, 3.9312002563476562e+02,
+    2.6927999877929688e+02, 4.4640003204345703e+01,
+    2.2424543762207031e+02, 1.3636138464789838e-04, 2, -1,
+    2.1600001525878906e+02, 2.7072000122070312e+02,
+    4.4640003204345703e+01, 9.9024642944335938e+01,
+    8.9550376287661493e-06, 2, -1, 2.8655999755859375e+02,
+    2.7072000122070312e+02, 4.4640003204345703e+01,
+    9.8467666625976562e+01, 4.9390480853617191e-05, 2, -1,
+    3.7152001953125000e+02, 2.7072000122070312e+02,
+    4.4640003204345703e+01, 2.3657089233398438e+02,
+    1.0860765905817971e-04, 2, -1, 3.8880001831054688e+02,
+    2.7072000122070312e+02, 4.4640003204345703e+01,
+    2.2158709716796875e+02, 1.0035995364887640e-04, 2, -1,
+    4.0176000976562500e+02, 2.7072000122070312e+02,
+    4.4640003204345703e+01, 2.0804008483886719e+02,
+    1.4875440683681518e-04, 2, -1, 4.0752001953125000e+02,
+    2.7072000122070312e+02, 4.4640003204345703e+01,
+    1.7929341125488281e+02, 1.5481423179153353e-04, 2, -1,
+    4.2768002319335938e+02, 2.7072000122070312e+02,
+    4.4640003204345703e+01, 1.5616802978515625e+02,
+    1.4740609913133085e-04, 2, -1, 4.3344000244140625e+02,
+    2.7072000122070312e+02, 4.4640003204345703e+01,
+    1.8115782165527344e+02, 2.4938848582678474e-05, 2, -1,
+    1.2240000152587891e+02, 2.7216000366210938e+02,
+    4.4640003204345703e+01, 3.9157268524169922e+01,
+    1.2156324373790994e-05, 2, -1, 1.2528000640869141e+02,
+    2.7216000366210938e+02, 4.4640003204345703e+01,
+    5.4878780364990234e+01, 2.2067717509344220e-05, 2, -1,
+    1.2960000610351562e+02, 2.7216000366210938e+02,
+    4.4640003204345703e+01, 8.3637680053710938e+01,
+    1.3036837117397226e-05, 2, -1, 144., 2.7216000366210938e+02,
+    4.4640003204345703e+01, 9.3290481567382812e+01,
+    1.4236506103770807e-05, 2, -1, 2.2464001464843750e+02,
+    2.7216000366210938e+02, 4.4640003204345703e+01,
+    1.0440394592285156e+02, 1.1555393939488567e-05, 2, -1,
+    2.3904000854492188e+02, 2.7216000366210938e+02,
+    4.4640003204345703e+01, 9.9370170593261719e+01,
+    1.1135770364489872e-05, 2, -1, 2.4768000793457031e+02,
+    2.7216000366210938e+02, 4.4640003204345703e+01,
+    1.0021265411376953e+02, 5.0851331252488308e-06, 2, -1,
+    2.9520001220703125e+02, 2.7216000366210938e+02,
+    4.4640003204345703e+01, 9.7570617675781250e+01,
+    3.8777459849370643e-05, 2, -1, 3.1104000854492188e+02,
+    2.7216000366210938e+02, 4.4640003204345703e+01,
+    8.4136100769042969e+01, 6.7942492023576051e-05, 2, -1,
+    3.1968002319335938e+02, 2.7216000366210938e+02,
+    4.4640003204345703e+01, 8.0400421142578125e+01,
+    8.4234146925155073e-05, 2, -1, 3.9456002807617188e+02,
+    2.7216000366210938e+02, 4.4640003204345703e+01,
+    2.2643481445312500e+02, 1.8605250807013363e-04, 2, -1,
+    4.1040002441406250e+02, 2.7216000366210938e+02,
+    4.4640003204345703e+01, 1.6512692260742188e+02,
+    1.0553546599112451e-04, 2, -1, 4.3056002807617188e+02,
+    2.7216000366210938e+02, 4.4640003204345703e+01,
+    1.6776246643066406e+02, 7.7637057984247804e-05, 2, -1,
+    3.0672000122070312e+02, 2.7360000610351562e+02,
+    4.4640003204345703e+01, 9.1605323791503906e+01,
+    7.6544885814655572e-05, 2, -1, 3.7152001953125000e+02,
+    2.7360000610351562e+02, 4.4640003204345703e+01,
+    2.3483012390136719e+02, 7.4792318628169596e-05, 2, -1,
+    3.8880001831054688e+02, 2.7360000610351562e+02,
+    4.4640003204345703e+01, 2.2952380371093750e+02,
+    1.0612582991598174e-04, 2, -1, 1.2240000152587891e+02,
+    2.7504000854492188e+02, 4.4640003204345703e+01,
+    2.1142902374267578e+01, 9.0417543106013909e-06, 2, -1,
+    1.2528000640869141e+02, 2.7504000854492188e+02,
+    4.4640003204345703e+01, 3.4037475585937500e+01,
+    1.3040114026807714e-05, 2, -1, 144., 2.7504000854492188e+02,
+    4.4640003204345703e+01, 9.3951835632324219e+01,
+    1.4076178558752872e-05, 2, -1, 1.6704000854492188e+02,
+    2.7504000854492188e+02, 4.4640003204345703e+01,
+    9.8201248168945312e+01, 8.0284935393137857e-06, 2, -1,
+    2.4624000549316406e+02, 2.7504000854492188e+02,
+    4.4640003204345703e+01, 1.0010243988037109e+02,
+    8.0676099969423376e-06, 2, -1, 2.6352001953125000e+02,
+    2.7504000854492188e+02, 4.4640003204345703e+01,
+    9.7278121948242188e+01, 8.6240042946883477e-06, 2, -1,
+    3.0960000610351562e+02, 2.7504000854492188e+02,
+    4.4640003204345703e+01, 8.8788055419921875e+01,
+    5.9173151385039091e-05, 2, -1, 3.2255999755859375e+02,
+    2.7504000854492188e+02, 4.4640003204345703e+01,
+    8.5206138610839844e+01, 7.8384451626334339e-05, 2, -1,
+    3.5856002807617188e+02, 2.7504000854492188e+02,
+    4.4640003204345703e+01, 1.3868350219726562e+02,
+    5.6626238801982254e-05, 2, -1, 3.7440002441406250e+02,
+    2.7504000854492188e+02, 4.4640003204345703e+01,
+    2.3893415832519531e+02, 8.7379703472834080e-05, 2, -1,
+    4.0464001464843750e+02, 2.7504000854492188e+02,
+    4.4640003204345703e+01, 1.9043006896972656e+02,
+    8.8657077867537737e-05, 2, -1, 4.1760000610351562e+02,
+    2.7504000854492188e+02, 4.4640003204345703e+01,
+    1.2453541564941406e+02, 5.4362073569791391e-05, 2, -1,
+    1.5263999938964844e+02, 2.7648001098632812e+02,
+    4.4640003204345703e+01, 1.0001173400878906e+02,
+    6.6422571762814187e-06, 2, -1, 1.7568000793457031e+02,
+    2.7648001098632812e+02, 4.4640003204345703e+01,
+    9.4774749755859375e+01, 8.7085409177234396e-06, 2, -1,
+    3.8304000854492188e+02, 2.7648001098632812e+02,
+    4.4640003204345703e+01, 2.2214949035644531e+02,
+    8.2141028542537242e-05, 2, -1, 3.8880001831054688e+02,
+    2.7648001098632812e+02, 4.4640003204345703e+01,
+    2.1326261901855469e+02, 1.1944704601773992e-04, 2, -1,
+    4.2192001342773438e+02, 2.7648001098632812e+02,
+    4.4640003204345703e+01, 1.2787811279296875e+02,
+    7.2313065174967051e-05, 2, -1, 1.6704000854492188e+02,
+    2.7792001342773438e+02, 4.4640003204345703e+01,
+    1.0009276580810547e+02, 9.8808031907537952e-06, 2, -1,
+    2.6208001708984375e+02, 2.7792001342773438e+02,
+    4.4640003204345703e+01, 9.7633651733398438e+01,
+    1.0919226951955352e-05, 2, -1, 3.5856002807617188e+02,
+    2.7792001342773438e+02, 4.4640003204345703e+01,
+    1.3296725463867188e+02, 8.0968246038537472e-05, 2, -1,
+    3.9456002807617188e+02, 2.7792001342773438e+02,
+    4.4640003204345703e+01, 2.0946726989746094e+02,
+    8.9193250460084528e-05, 2, -1, 1.7568000793457031e+02,
+    2.7936001586914062e+02, 4.4640003204345703e+01,
+    8.8992164611816406e+01, 9.9333465186646208e-06, 2, -1,
+    1.9152000427246094e+02, 2.7936001586914062e+02,
+    4.4640003204345703e+01, 9.4802200317382812e+01,
+    1.0380679668742232e-05, 2, -1, 2.7072000122070312e+02,
+    2.7936001586914062e+02, 4.4640003204345703e+01,
+    9.9609260559082031e+01, 8.2390206443960778e-06, 2, -1,
+    3.5280001831054688e+02, 2.7936001586914062e+02,
+    4.4640003204345703e+01, 1.3280044555664062e+02,
+    1.0948612180072814e-04, 2, -1, 1.9872000122070312e+02,
+    2.8080001831054688e+02, 4.4640003204345703e+01,
+    9.6919342041015625e+01, 6.8369140535651240e-06, 2, -1,
+    3.6432000732421875e+02, 2.8080001831054688e+02,
+    4.4640003204345703e+01, 1.3397262573242188e+02,
+    6.3231695094145834e-05, 2, -1, 3.7872000122070312e+02,
+    2.8080001831054688e+02, 4.4640003204345703e+01,
+    1.0804566955566406e+02, 1.1815546167781577e-04, 2, -1,
+    3.9600003051757812e+02, 2.8080001831054688e+02,
+    4.4640003204345703e+01, 1.0572321319580078e+02,
+    6.0591566580114886e-05, 2, -1, 4.2912002563476562e+02,
+    2.8080001831054688e+02, 4.4640003204345703e+01,
+    1.7872964477539062e+02, 6.0484539972094353e-06, 2, -1,
+    1.9008000183105469e+02, 2.8224002075195312e+02,
+    4.4640003204345703e+01, 9.2206329345703125e+01,
+    7.8907705756137148e-06, 2, -1, 3.1248001098632812e+02,
+    2.8224002075195312e+02, 4.4640003204345703e+01,
+    9.2178642272949219e+01, 8.4891553342458792e-06, 2, -1,
+    4.2336001586914062e+02, 2.8224002075195312e+02,
+    4.4640003204345703e+01, 1.6042727661132812e+02,
+    3.4169315767940134e-05, 2, -1, 1.9872000122070312e+02,
+    2.8368002319335938e+02, 4.4640003204345703e+01,
+    9.8553962707519531e+01, 5.4205202104640193e-06, 2, -1,
+    2.2320001220703125e+02, 2.8368002319335938e+02,
+    4.4640003204345703e+01, 9.9337005615234375e+01,
+    8.1324951679562218e-06, 2, -1, 3.5280001831054688e+02,
+    2.8368002319335938e+02, 4.4640003204345703e+01,
+    1.2308032226562500e+02, 1.7331737035419792e-04, 2, -1,
+    3.5856002807617188e+02, 2.8368002319335938e+02,
+    4.4640003204345703e+01, 1.1908769226074219e+02,
+    1.9825695198960602e-04, 2, -1, 3.8016000366210938e+02,
+    2.8368002319335938e+02, 4.4640003204345703e+01,
+    1.0027317810058594e+02, 7.1777714765630662e-05, 2, -1,
+    3.8304000854492188e+02, 2.8368002319335938e+02,
+    4.4640003204345703e+01, 1.0504772186279297e+02,
+    2.0480852981563658e-04, 2, -1, 4.0176000976562500e+02,
+    2.8368002319335938e+02, 4.4640003204345703e+01,
+    9.4809799194335938e+01, 1.1262972839176655e-04, 2, -1,
+    4.0608001708984375e+02, 2.8368002319335938e+02,
+    4.4640003204345703e+01, 1.0487483215332031e+02,
+    1.1684366472763941e-04, 2, -1, 1.4112001037597656e+02,
+    2.8512002563476562e+02, 4.4640003204345703e+01,
+    2.1548100280761719e+02, 5.1146103942301124e-05, 2, -1,
+    1.6127999877929688e+02, 2.8512002563476562e+02,
+    4.4640003204345703e+01, 2.5482484436035156e+02,
+    5.4124097914609592e-06, 2, -1, 2.1456001281738281e+02,
+    2.8512002563476562e+02, 4.4640003204345703e+01,
+    9.6638435363769531e+01, 1.4954259313526563e-05, 2, -1,
+    3.1104000854492188e+02, 2.8512002563476562e+02,
+    4.4640003204345703e+01, 9.4787292480468750e+01,
+    9.8884856924996711e-06, 2, -1, 3.6144000244140625e+02,
+    2.8512002563476562e+02, 4.4640003204345703e+01,
+    1.1524403381347656e+02, 8.0680627434048802e-05, 2, -1,
+    3.8736001586914062e+02, 2.8512002563476562e+02,
+    4.4640003204345703e+01, 1.0181172943115234e+02,
+    2.2420554887503386e-04, 2, -1, 1.6992001342773438e+02,
+    2.8655999755859375e+02, 4.4640003204345703e+01,
+    2.6457086181640625e+02, 1.3240032785688527e-05, 2, -1,
+    2.1888000488281250e+02, 2.8655999755859375e+02,
+    4.4640003204345703e+01, 9.8467300415039062e+01,
+    1.3531196600524709e-05, 2, -1, 2.3760000610351562e+02,
+    2.8655999755859375e+02, 4.4640003204345703e+01,
+    9.6414573669433594e+01, 1.0591949830995873e-05, 2, -1,
+    3.1968002319335938e+02, 2.8655999755859375e+02,
+    4.4640003204345703e+01, 9.4965919494628906e+01,
+    1.1983400327153504e-05, 2, -1, 3.4416000366210938e+02,
+    2.8655999755859375e+02, 4.4640003204345703e+01,
+    1.1814852142333984e+02, 1.2408496331772767e-05, 2, -1,
+    3.8304000854492188e+02, 2.8655999755859375e+02,
+    4.4640003204345703e+01, 1.0066383361816406e+02,
+    1.5603592328261584e-04, 2, -1, 4.0320001220703125e+02,
+    2.8655999755859375e+02, 4.4640003204345703e+01,
+    9.8242141723632812e+01, 1.8212832219433039e-04, 2, -1,
+    4.1760000610351562e+02, 2.8655999755859375e+02,
+    4.4640003204345703e+01, 1.3254298400878906e+02,
+    1.4885314158163965e-04, 2, -1, 4.2768002319335938e+02,
+    2.8655999755859375e+02, 4.4640003204345703e+01,
+    1.8209187316894531e+02, 6.3974016484280583e-06, 2, -1,
+    1.2528000640869141e+02, 288., 4.4640003204345703e+01,
+    3.4689178466796875e+02, 4.4707012420985848e-06, 2, -1,
+    1.2816000366210938e+02, 288., 4.4640003204345703e+01,
+    3.4594268798828125e+02, 3.9743636079947464e-06, 2, -1, 144., 288.,
+    4.4640003204345703e+01, 2.2636053466796875e+02,
+    8.3089697000104934e-05, 2, -1, 1.5840000915527344e+02, 288.,
+    4.4640003204345703e+01, 2.5211486816406250e+02,
+    5.0947060117323417e-06, 2, -1, 2.2320001220703125e+02, 288.,
+    4.4640003204345703e+01, 9.8870613098144531e+01,
+    8.3353907029959373e-06, 2, -1, 2.4624000549316406e+02, 288.,
+    4.4640003204345703e+01, 9.9137855529785156e+01,
+    9.0752273536054417e-06, 2, -1, 3.6864001464843750e+02, 288.,
+    4.4640003204345703e+01, 1.0450904083251953e+02,
+    8.7406595412176102e-05, 2, -1, 4.0032000732421875e+02, 288.,
+    4.4640003204345703e+01, 9.7337516784667969e+01,
+    1.5791661280672997e-04, 2, -1, 4.1328002929687500e+02, 288.,
+    4.4640003204345703e+01, 1.1603938293457031e+02,
+    1.7645751358941197e-04, 2, -1, 2.3760000610351562e+02,
+    2.8944000244140625e+02, 4.4640003204345703e+01,
+    9.8248413085937500e+01, 1.0448174180055503e-05, 2, -1,
+    3.8448001098632812e+02, 2.8944000244140625e+02,
+    4.4640003204345703e+01, 9.8459976196289062e+01,
+    1.0187182488152757e-04, 2, -1, 4.2048001098632812e+02,
+    2.8944000244140625e+02, 4.4640003204345703e+01,
+    1.4132557678222656e+02, 1.1121040733996779e-04, 2, -1,
+    4.2336001586914062e+02, 2.8944000244140625e+02,
+    4.4640003204345703e+01, 1.5364834594726562e+02,
+    3.8548350858036429e-05, 2, -1, 1.2672000122070312e+02,
+    2.9088000488281250e+02, 4.4640003204345703e+01,
+    3.4585964965820312e+02, 6.0492634474940132e-06, 2, -1,
+    1.4256001281738281e+02, 2.9088000488281250e+02,
+    4.4640003204345703e+01, 2.0267825317382812e+02,
+    6.1562088376376778e-05, 2, -1, 180., 2.9088000488281250e+02,
+    4.4640003204345703e+01, 3.1228042602539062e+02,
+    1.4452379218710121e-05, 2, -1, 2.4624000549316406e+02,
+    2.9088000488281250e+02, 4.4640003204345703e+01,
+    1.0033843994140625e+02, 8.1694670370779932e-06, 2, -1,
+    2.6927999877929688e+02, 2.9088000488281250e+02,
+    4.4640003204345703e+01, 9.9907104492187500e+01,
+    1.1033661394321825e-05, 2, -1, 3.7008001708984375e+02,
+    2.9088000488281250e+02, 4.4640003204345703e+01,
+    9.9108619689941406e+01, 6.9489811721723527e-05, 2, -1,
+    1.6704000854492188e+02, 2.9232000732421875e+02,
+    4.4640003204345703e+01, 2.5233923339843750e+02,
+    1.1116316454717889e-04, 2, -1, 1.6992001342773438e+02,
+    2.9232000732421875e+02, 4.4640003204345703e+01,
+    2.6317156982421875e+02, 1.9391166279092431e-04, 2, -1,
+    1.8864001464843750e+02, 2.9232000732421875e+02,
+    4.4640003204345703e+01, 3.3041082763671875e+02,
+    1.3726930774282664e-05, 2, -1, 2.0736001586914062e+02,
+    2.9232000732421875e+02, 4.4640003204345703e+01,
+    9.5979057312011719e+01, 6.6286097535339650e-06, 2, -1,
+    2.5488000488281250e+02, 2.9232000732421875e+02,
+    4.4640003204345703e+01, 9.8106109619140625e+01,
+    4.3020891098421998e-06, 2, -1, 360., 2.9232000732421875e+02,
+    4.4640003204345703e+01, 1.0417811584472656e+02,
+    1.8545331840869039e-05, 2, -1, 3.8016000366210938e+02,
+    2.9232000732421875e+02, 4.4640003204345703e+01,
+    9.7344459533691406e+01, 5.3386076615424827e-05, 2, -1,
+    4.0464001464843750e+02, 2.9232000732421875e+02,
+    4.4640003204345703e+01, 1.0615444946289062e+02,
+    3.3877091482281685e-04, 2, -1, 4.0752001953125000e+02,
+    2.9232000732421875e+02, 4.4640003204345703e+01,
+    1.0918034362792969e+02, 2.7522328309714794e-04, 2, -1,
+    4.1328002929687500e+02, 2.9232000732421875e+02,
+    4.4640003204345703e+01, 1.1690963745117188e+02,
+    2.7815220528282225e-04, 2, -1, 1.7712001037597656e+02,
+    2.9376000976562500e+02, 4.4640003204345703e+01,
+    2.9872021484375000e+02, 1.4505167200695723e-04, 2, -1,
+    1.9872000122070312e+02, 2.9376000976562500e+02,
+    4.4640003204345703e+01, 2.4130102157592773e+01,
+    1.2924720067530870e-05, 2, -1, 2.6208001708984375e+02,
+    2.9376000976562500e+02, 4.4640003204345703e+01,
+    9.7248718261718750e+01, 1.8314238332095556e-05, 2, -1,
+    2.6927999877929688e+02, 2.9376000976562500e+02,
+    4.4640003204345703e+01, 9.9997451782226562e+01,
+    1.3612717339128722e-05, 2, -1, 2.8655999755859375e+02,
+    2.9376000976562500e+02, 4.4640003204345703e+01,
+    9.8873977661132812e+01, 8.9998256953549571e-06, 2, -1,
+    3.6864001464843750e+02, 2.9376000976562500e+02,
+    4.4640003204345703e+01, 9.8928428649902344e+01,
+    5.2792885981034487e-05, 2, -1, 3.7440002441406250e+02,
+    2.9376000976562500e+02, 4.4640003204345703e+01,
+    9.7846450805664062e+01, 9.2080103058833629e-05, 2, -1,
+    3.9744000244140625e+02, 2.9376000976562500e+02,
+    4.4640003204345703e+01, 1.0026808166503906e+02,
+    7.9939913121052086e-05, 2, -1, 4.2192001342773438e+02,
+    2.9376000976562500e+02, 4.4640003204345703e+01,
+    1.4252827453613281e+02, 1.5037198863865342e-05, 2, -1,
+    1.2672000122070312e+02, 2.9520001220703125e+02,
+    4.4640003204345703e+01, 3.4250595092773438e+02,
+    6.5474841903778724e-06, 2, -1, 1.2960000610351562e+02,
+    2.9520001220703125e+02, 4.4640003204345703e+01,
+    3.4031039428710938e+02, 4.6048226067796350e-06, 2, -1,
+    2.9520001220703125e+02, 2.9520001220703125e+02,
+    4.4640003204345703e+01, 1.0315614318847656e+02,
+    7.8558668974437751e-06, 2, -1, 1.4544000244140625e+02,
+    2.9664001464843750e+02, 4.4640003204345703e+01,
+    2.0032479858398438e+02, 2.9325692594284192e-05, 2, -1,
+    1.6704000854492188e+02, 2.9664001464843750e+02,
+    4.4640003204345703e+01, 2.4274630737304688e+02,
+    1.7032663163263351e-04, 2, -1, 1.7136000061035156e+02,
+    2.9664001464843750e+02, 4.4640003204345703e+01,
+    2.6371636962890625e+02, 1.8818558601196855e-04, 2, -1,
+    2.1600001525878906e+02, 2.9664001464843750e+02,
+    4.4640003204345703e+01, 9.6473587036132812e+01,
+    2.6267798602930270e-06, 2, -1, 2.8655999755859375e+02,
+    2.9664001464843750e+02, 4.4640003204345703e+01,
+    1.0179551696777344e+02, 1.0115270924870856e-05, 2, -1,
+    4.1184002685546875e+02, 2.9664001464843750e+02,
+    4.4640003204345703e+01, 1.1573224639892578e+02,
+    2.0957115339115262e-04, 2, -1, 4.1616000366210938e+02,
+    2.9664001464843750e+02, 4.4640003204345703e+01,
+    1.2531494140625000e+02, 3.0213387799449265e-04, 2, -1,
+    1.7424000549316406e+02, 2.9808001708984375e+02,
+    4.4640003204345703e+01, 2.7967416381835938e+02,
+    1.9470108964014798e-04, 2, -1, 3.1248001098632812e+02,
+    2.9808001708984375e+02, 4.4640003204345703e+01,
+    9.7339202880859375e+01, 1.4715907127538230e-05, 2, -1,
+    3.9600003051757812e+02, 2.9808001708984375e+02,
+    4.4640003204345703e+01, 1.0119599914550781e+02,
+    4.7263831220334396e-05, 2, -1, 4.0752001953125000e+02,
+    2.9808001708984375e+02, 4.4640003204345703e+01,
+    1.0896224975585938e+02, 3.8202309951884672e-05, 2, -1,
+    1.8144000244140625e+02, 2.9952001953125000e+02,
+    4.4640003204345703e+01, 3.0883721923828125e+02,
+    2.1718906646128744e-04, 2, -1, 2.3472001647949219e+02,
+    2.9952001953125000e+02, 4.4640003204345703e+01,
+    9.8215972900390625e+01, 1.1538955732248724e-05, 2, -1,
+    2.9952001953125000e+02, 2.9952001953125000e+02,
+    4.4640003204345703e+01, 1.0746020507812500e+02,
+    4.9413497436034959e-06, 2, -1, 3.1968002319335938e+02,
+    2.9952001953125000e+02, 4.4640003204345703e+01,
+    9.8022407531738281e+01, 1.0094207937072497e-05, 2, -1,
+    4.2192001342773438e+02, 2.9952001953125000e+02,
+    4.4640003204345703e+01, 1.4028698730468750e+02,
+    2.8939666663063690e-05, 2, -1, 1.7856001281738281e+02,
+    3.0096002197265625e+02, 4.4640003204345703e+01,
+    2.9755740356445312e+02, 2.7537520509213209e-04, 2, -1,
+    2.4480000305175781e+02, 3.0096002197265625e+02,
+    4.4640003204345703e+01, 9.9701614379882812e+01,
+    1.1445163181633689e-05, 2, -1, 3.1248001098632812e+02,
+    3.0096002197265625e+02, 4.4640003204345703e+01,
+    9.8321899414062500e+01, 1.5876525139901787e-05, 2, -1,
+    3.3264001464843750e+02, 3.0096002197265625e+02,
+    4.4640003204345703e+01, 9.6859451293945312e+01,
+    9.7499932962819003e-06, 2, -1, 4.1184002685546875e+02,
+    3.0096002197265625e+02, 4.4640003204345703e+01,
+    1.1530487823486328e+02, 3.3845928555820137e-05, 2, -1, 144.,
+    3.0240002441406250e+02, 4.4640003204345703e+01,
+    1.7488281250000000e+02, 4.4530450395541266e-05, 2, -1,
+    3.1968002319335938e+02, 3.0240002441406250e+02,
+    4.4640003204345703e+01, 9.4798294067382812e+01,
+    8.5186366050038487e-06, 2, -1, 3.4127999877929688e+02,
+    3.0240002441406250e+02, 4.4640003204345703e+01,
+    1.0070983886718750e+02, 1.4318687135528307e-05, 2, -1,
+    1.6704000854492188e+02, 3.0384002685546875e+02,
+    4.4640003204345703e+01, 2.2748071289062500e+02,
+    4.9303336709272116e-05, 2, -1, 1.8432000732421875e+02,
+    3.0384002685546875e+02, 4.4640003204345703e+01,
+    3.0858096313476562e+02, 3.3486387110315263e-04, 2, -1,
+    3.3264001464843750e+02, 3.0384002685546875e+02,
+    4.4640003204345703e+01, 9.5844902038574219e+01,
+    1.2263687494851183e-05, 2, -1, 1.6127999877929688e+02,
+    3.0527999877929688e+02, 4.4640003204345703e+01,
+    1.9906875610351562e+02, 8.2940587162738666e-06, 2, -1,
+    1.7568000793457031e+02, 3.0527999877929688e+02,
+    4.4640003204345703e+01, 2.7397399902343750e+02,
+    4.9725284043233842e-05, 2, -1, 2.7216000366210938e+02,
+    3.0527999877929688e+02, 4.4640003204345703e+01,
+    1.0975787353515625e+02, 1.0454577932250686e-05, 2, -1,
+    3.4127999877929688e+02, 3.0527999877929688e+02,
+    4.4640003204345703e+01, 9.9772644042968750e+01,
+    1.6248233805526979e-05, 2, -1, 1.2960000610351562e+02,
+    3.0672000122070312e+02, 4.4640003204345703e+01,
+    3.4604992675781250e+02, 4.4808821257902309e-06, 2, -1,
+    1.7280000305175781e+02, 3.0672000122070312e+02,
+    4.4640003204345703e+01, 2.4704449462890625e+02,
+    2.9350967452046461e-05, 2, -1, 180., 3.0672000122070312e+02,
+    4.4640003204345703e+01, 2.9543389892578125e+02,
+    8.8453576609026641e-05, 2, -1, 2.8080001831054688e+02,
+    3.0672000122070312e+02, 4.4640003204345703e+01,
+    1.6156863403320312e+02, 1.4251793800212909e-05, 2, -1,
+    2.9664001464843750e+02, 3.0672000122070312e+02,
+    4.4640003204345703e+01, 1.7959906005859375e+02,
+    1.6116337064886466e-05, 2, -1, 3.6576000976562500e+02,
+    3.0672000122070312e+02, 4.4640003204345703e+01,
+    1.0029695129394531e+02, 1.0663412467692979e-05, 2, -1,
+    4.2768002319335938e+02, 3.0672000122070312e+02,
+    4.4640003204345703e+01, 1.5588502502441406e+02,
+    6.3130974012892693e-05, 2, -1, 1.9152000427246094e+02,
+    3.0816000366210938e+02, 4.4640003204345703e+01,
+    3.0907373046875000e+02, 8.1718309957068413e-05, 2, -1,
+    2.9088000488281250e+02, 3.0816000366210938e+02,
+    4.4640003204345703e+01, 1.9662214660644531e+02,
+    1.9109462300548330e-05, 2, -1, 3.5712002563476562e+02,
+    3.0816000366210938e+02, 4.4640003204345703e+01,
+    9.8454620361328125e+01, 1.2586008779180702e-05, 2, -1,
+    3.0096002197265625e+02, 3.0960000610351562e+02,
+    4.4640003204345703e+01, 2.2057839965820312e+02,
+    4.3445368646644056e-05, 2, -1, 3.1392001342773438e+02,
+    3.0960000610351562e+02, 4.4640003204345703e+01,
+    3.1372885131835938e+02, 6.8212270889489446e-06, 2, -1,
+    3.6576000976562500e+02, 3.0960000610351562e+02,
+    4.4640003204345703e+01, 1.0099804687500000e+02,
+    9.0662679212982766e-06, 2, -1, 3.8448001098632812e+02,
+    3.0960000610351562e+02, 4.4640003204345703e+01,
+    9.7225181579589844e+01, 1.7369791748933494e-05, 2, -1,
+    4.2480001831054688e+02, 3.0960000610351562e+02,
+    4.4640003204345703e+01, 1.5343092346191406e+02,
+    1.3878387107979506e-04, 2, -1, 1.9152000427246094e+02,
+    3.1104000854492188e+02, 4.4640003204345703e+01,
+    3.0915356445312500e+02, 1.2918225547764450e-04, 2, -1,
+    3.0960000610351562e+02, 3.1104000854492188e+02,
+    4.4640003204345703e+01, 2.7119808959960938e+02,
+    1.4481910511676688e-05, 2, -1, 3.9312002563476562e+02,
+    3.1104000854492188e+02, 4.4640003204345703e+01,
+    1.0305755615234375e+02, 1.0777104762382805e-05, 2, -1,
+    1.8432000732421875e+02, 3.1248001098632812e+02,
+    4.4640003204345703e+01, 3.0930029296875000e+02,
+    2.7972335374215618e-05, 2, -1, 1.8864001464843750e+02,
+    3.1248001098632812e+02, 4.4640003204345703e+01,
+    3.1120480346679688e+02, 8.2295904576312751e-05, 2, -1,
+    2.0592001342773438e+02, 3.1248001098632812e+02,
+    4.4640003204345703e+01, 2.8586508178710938e+02,
+    6.9828063715249300e-05, 2, -1, 2.0880000305175781e+02,
+    3.1248001098632812e+02, 4.4640003204345703e+01,
+    2.8267968750000000e+02, 7.3916293331421912e-05, 2, -1,
+    2.9520001220703125e+02, 3.1248001098632812e+02,
+    4.4640003204345703e+01, 2.2901397705078125e+02,
+    1.1586097389226779e-04, 2, -1, 3.8304000854492188e+02,
+    3.1248001098632812e+02, 4.4640003204345703e+01,
+    1.0055541992187500e+02, 1.3776122614217456e-05, 2, -1,
+    1.3104000854492188e+02, 3.1392001342773438e+02,
+    4.4640003204345703e+01, 3.3782891845703125e+02,
+    3.6557912608259358e-06, 2, -1, 1.3391999816894531e+02,
+    3.1392001342773438e+02, 4.4640003204345703e+01,
+    3.3868328857421875e+02, 2.2756155431125080e-06, 2, -1,
+    1.6704000854492188e+02, 3.1392001342773438e+02,
+    4.4640003204345703e+01, 1.7243684387207031e+02,
+    1.4755895790585782e-05, 2, -1, 1.9728001403808594e+02,
+    3.1392001342773438e+02, 4.4640003204345703e+01,
+    2.9767504882812500e+02, 3.2355119401472621e-06, 2, -1,
+    2.0016000366210938e+02, 3.1392001342773438e+02,
+    4.4640003204345703e+01, 2.9068429565429688e+02,
+    1.2223134149280668e-07, 2, -1, 3.9312002563476562e+02,
+    3.1392001342773438e+02, 4.4640003204345703e+01,
+    1.0507263183593750e+02, 9.1068686742801219e-06, 2, -1,
+    4.1472003173828125e+02, 3.1392001342773438e+02,
+    4.4640003204345703e+01, 1.3929725646972656e+02,
+    2.9646023904206231e-05, 2, -1, 4.1760000610351562e+02,
+    3.1392001342773438e+02, 4.4640003204345703e+01,
+    1.4650274658203125e+02, 1.8011947759077884e-05, 2, -1,
+    4.2912002563476562e+02, 3.1392001342773438e+02,
+    4.4640003204345703e+01, 1.6379409790039062e+02,
+    -8.3288214227650315e-06, 2, -1, 1.4832000732421875e+02,
+    3.1536001586914062e+02, 4.4640003204345703e+01,
+    1.5845960998535156e+02, 5.0049140554619953e-05, 2, -1,
+    1.7280000305175781e+02, 3.1536001586914062e+02,
+    4.4640003204345703e+01, 1.6964526367187500e+02,
+    2.1884417947148904e-05, 2, -1, 1.7568000793457031e+02,
+    3.1536001586914062e+02, 4.4640003204345703e+01,
+    1.8166479492187500e+02, 2.9524620913434774e-05, 2, -1, 180.,
+    3.1536001586914062e+02, 4.4640003204345703e+01,
+    2.8052551269531250e+02, 1.5907915440038778e-05, 2, -1,
+    2.0448001098632812e+02, 3.1536001586914062e+02,
+    4.4640003204345703e+01, 2.8663296508789062e+02,
+    1.0635382204782218e-04, 2, -1, 2.1024000549316406e+02,
+    3.1536001586914062e+02, 4.4640003204345703e+01,
+    2.7981134033203125e+02, 1.5615481243003160e-04, 2, -1,
+    3.3840002441406250e+02, 3.1536001586914062e+02,
+    4.4640003204345703e+01, 6.3111370086669922e+01,
+    2.2170341253513470e-05, 2, -1, 3.5280001831054688e+02,
+    3.1536001586914062e+02, 4.4640003204345703e+01,
+    8.6796279907226562e+01, 1.2888363016827498e-05, 2, -1,
+    2.1312001037597656e+02, 3.1680001831054688e+02,
+    4.4640003204345703e+01, 2.7952331542968750e+02,
+    1.1110131890745834e-04, 2, -1, 2.2032000732421875e+02,
+    3.1680001831054688e+02, 4.4640003204345703e+01,
+    2.8255120849609375e+02, 1.7921606195159256e-04, 2, -1,
+    2.2464001464843750e+02, 3.1680001831054688e+02,
+    4.4640003204345703e+01, 2.8466387939453125e+02,
+    3.0193437123671174e-04, 2, -1, 2.9520001220703125e+02,
+    3.1680001831054688e+02, 4.4640003204345703e+01,
+    2.3358435058593750e+02, 1.0372514952905476e-04, 2, -1,
+    3.4704000854492188e+02, 3.1680001831054688e+02,
+    4.4640003204345703e+01, 8.1792121887207031e+01,
+    1.3771996236755513e-05, 2, -1, 4.0896002197265625e+02,
+    3.1680001831054688e+02, 4.4640003204345703e+01,
+    1.2748286437988281e+02, 2.2384581825463101e-05, 2, -1,
+    4.1328002929687500e+02, 3.1680001831054688e+02,
+    4.4640003204345703e+01, 1.4304733276367188e+02,
+    2.7049361960962415e-05, 2, -1, 4.2912002563476562e+02,
+    3.1680001831054688e+02, 4.4640003204345703e+01,
+    1.6667767333984375e+02, -6.5742242441046983e-05, 2, -1,
+    1.7280000305175781e+02, 3.1824002075195312e+02,
+    4.4640003204345703e+01, 1.4888748168945312e+02,
+    1.8585224097478203e-05, 2, -1, 2.0304000854492188e+02,
+    3.1824002075195312e+02, 4.4640003204345703e+01,
+    2.8784506225585938e+02, 3.6757621273864061e-05, 2, -1,
+    2.9232000732421875e+02, 3.1824002075195312e+02,
+    4.4640003204345703e+01, 2.2416845703125000e+02,
+    1.1308656394248828e-04, 2, -1, 4.1760000610351562e+02,
+    3.1824002075195312e+02, 4.4640003204345703e+01,
+    1.5703279113769531e+02, 3.1578067137161270e-05, 2, -1,
+    1.9008000183105469e+02, 3.1968002319335938e+02,
+    4.4640003204345703e+01, 3.2390493774414062e+02,
+    2.0707482690340839e-05, 2, -1, 2.2032000732421875e+02,
+    3.1968002319335938e+02, 4.4640003204345703e+01,
+    2.8281109619140625e+02, 2.4787307484075427e-04, 2, -1,
+    2.2896000671386719e+02, 3.1968002319335938e+02,
+    4.4640003204345703e+01, 2.8987091064453125e+02,
+    1.9762557349167764e-04, 2, -1, 3.1392001342773438e+02,
+    3.1968002319335938e+02, 4.4640003204345703e+01,
+    6.7831845283508301e+00, 4.6415643737418577e-05, 2, -1,
+    3.2112002563476562e+02, 3.1968002319335938e+02,
+    4.4640003204345703e+01, 3.5773968505859375e+02,
+    3.0990762752480805e-05, 2, -1, 3.7584002685546875e+02,
+    3.1968002319335938e+02, 4.4640003204345703e+01,
+    1.3075610351562500e+02, 2.4217713871621527e-05, 2, -1,
+    2.1024000549316406e+02, 3.2112002563476562e+02,
+    4.4640003204345703e+01, 2.7614929199218750e+02,
+    9.5275929197669029e-05, 2, -1, 288., 3.2112002563476562e+02,
+    4.4640003204345703e+01, 2.1440296936035156e+02,
+    1.7338006000500172e-04, 2, -1, 2.9376000976562500e+02,
+    3.2112002563476562e+02, 4.4640003204345703e+01,
+    2.2090211486816406e+02, 1.8071892554871738e-04, 2, -1,
+    3.0960000610351562e+02, 3.2112002563476562e+02,
+    4.4640003204345703e+01, 3.4448178100585938e+02,
+    8.6935142462607473e-05, 2, -1, 3.6864001464843750e+02,
+    3.2112002563476562e+02, 4.4640003204345703e+01,
+    1.3582470703125000e+02, 1.3103402125125285e-05, 2, -1,
+    4.1472003173828125e+02, 3.2112002563476562e+02,
+    4.4640003204345703e+01, 1.6381602478027344e+02,
+    3.1542353099212050e-05, 2, -1, 4.1760000610351562e+02,
+    3.2112002563476562e+02, 4.4640003204345703e+01,
+    1.6525112915039062e+02, 2.7039259293815121e-05, 2, -1,
+    1.4976000976562500e+02, 3.2255999755859375e+02,
+    4.4640003204345703e+01, 2.3973205566406250e+02,
+    1.7373164155287668e-05, 2, -1, 1.9584001159667969e+02,
+    3.2255999755859375e+02, 4.4640003204345703e+01,
+    3.2095678710937500e+02, 6.7012442741543055e-05, 2, -1,
+    2.8080001831054688e+02, 3.2255999755859375e+02,
+    4.4640003204345703e+01, 2.3372196960449219e+02,
+    3.4228960430482402e-05, 2, -1, 2.1312001037597656e+02, 324.,
+    4.4640003204345703e+01, 2.7518301391601562e+02,
+    1.0451397974975407e-04, 2, -1, 3.0384002685546875e+02, 324.,
+    4.4640003204345703e+01, 3.4700549316406250e+02,
+    9.2780443083029240e-05, 2, -1, 3.1536001586914062e+02, 324.,
+    4.4640003204345703e+01, 3.4563082885742188e+02,
+    6.1394144722726196e-05, 2, -1, 1.3680000305175781e+02,
+    3.2544000244140625e+02, 4.4640003204345703e+01,
+    3.1212094116210938e+02, 6.0747584029741120e-06, 2, -1,
+    1.4976000976562500e+02, 3.2544000244140625e+02,
+    4.4640003204345703e+01, 2.6286627197265625e+02,
+    6.2579183577327058e-06, 2, -1, 1.7136000061035156e+02,
+    3.2544000244140625e+02, 4.4640003204345703e+01,
+    1.3977796936035156e+02, 7.7306875027716160e-05, 2, -1,
+    1.9152000427246094e+02, 3.2544000244140625e+02,
+    4.4640003204345703e+01, 7.9528411865234375e+01,
+    4.8675170546630397e-05, 2, -1, 2.0016000366210938e+02,
+    3.2544000244140625e+02, 4.4640003204345703e+01,
+    4.9111717224121094e+01, 9.3744296464137733e-05, 2, -1,
+    2.4912001037597656e+02, 3.2544000244140625e+02,
+    4.4640003204345703e+01, 2.9216284179687500e+02,
+    2.0063349802512676e-04, 2, -1, 2.7072000122070312e+02,
+    3.2544000244140625e+02, 4.4640003204345703e+01,
+    2.7095062255859375e+02, 2.4513600510545075e-04, 2, -1,
+    2.8224002075195312e+02, 3.2544000244140625e+02,
+    4.4640003204345703e+01, 2.4528967285156250e+02,
+    1.3277273683343083e-04, 2, -1, 3.7440002441406250e+02,
+    3.2544000244140625e+02, 4.4640003204345703e+01,
+    1.6619801330566406e+02, 5.0401777116348967e-05, 2, -1,
+    2.0448001098632812e+02, 3.2688000488281250e+02,
+    4.4640003204345703e+01, 1.3595787048339844e+02,
+    1.7053016927093267e-04, 2, -1, 2.3184001159667969e+02,
+    3.2688000488281250e+02, 4.4640003204345703e+01,
+    2.9559219360351562e+02, 6.2224113207776099e-05, 2, -1,
+    2.3616000366210938e+02, 3.2688000488281250e+02,
+    4.4640003204345703e+01, 2.9542019653320312e+02,
+    9.7804091637954116e-05, 2, -1, 2.4480000305175781e+02,
+    3.2688000488281250e+02, 4.4640003204345703e+01,
+    2.9419570922851562e+02, 1.2685921683441848e-04, 2, -1,
+    3.3696002197265625e+02, 3.2688000488281250e+02,
+    4.4640003204345703e+01, 3.4451535034179688e+02,
+    4.2222090996801853e-06, 2, -1, 1.3391999816894531e+02,
+    3.2832000732421875e+02, 4.4640003204345703e+01,
+    3.1301031494140625e+02, 1.1670455933199264e-05, 2, -1,
+    1.6560000610351562e+02, 3.2832000732421875e+02,
+    4.4640003204345703e+01, 1.6568997192382812e+02,
+    9.1221463662805036e-06, 2, -1, 1.8432000732421875e+02,
+    3.2832000732421875e+02, 4.4640003204345703e+01,
+    9.9634567260742188e+01, 1.0408286470919847e-05, 2, -1,
+    1.9008000183105469e+02, 3.2832000732421875e+02,
+    4.4640003204345703e+01, 9.1475227355957031e+01,
+    2.3885522750788368e-05, 2, -1, 1.9728001403808594e+02,
+    3.2832000732421875e+02, 4.4640003204345703e+01,
+    9.1784149169921875e+01, 1.1086172889918089e-04, 2, -1,
+    2.0880000305175781e+02, 3.2832000732421875e+02,
+    4.4640003204345703e+01, 1.3672918701171875e+02,
+    2.0404656243044883e-04, 2, -1, 2.1456001281738281e+02,
+    3.2832000732421875e+02, 4.4640003204345703e+01,
+    2.3171334838867188e+02, 1.6701078857295215e-04, 2, -1,
+    2.8080001831054688e+02, 3.2832000732421875e+02,
+    4.4640003204345703e+01, 2.6373925781250000e+02,
+    1.2496701674535871e-04, 2, -1, 2.8655999755859375e+02,
+    3.2832000732421875e+02, 4.4640003204345703e+01,
+    2.5201562500000000e+02, 2.1143155754543841e-04, 2, -1,
+    2.9232000732421875e+02, 3.2832000732421875e+02,
+    4.4640003204345703e+01, 2.3129884338378906e+02,
+    2.0485497952904552e-04, 2, -1, 3.0096002197265625e+02,
+    3.2832000732421875e+02, 4.4640003204345703e+01,
+    5.8998916625976562e+01, 9.9038246844429523e-05, 2, -1,
+    3.1104000854492188e+02, 3.2832000732421875e+02,
+    4.4640003204345703e+01, 3.3202175140380859e+01,
+    4.3663731048582122e-05, 2, -1, 3.3264001464843750e+02,
+    3.2832000732421875e+02, 4.4640003204345703e+01,
+    3.3253164672851562e+02, 7.0078426688269246e-06, 2, -1,
+    4.0032000732421875e+02, 3.2832000732421875e+02,
+    4.4640003204345703e+01, 2.3026812744140625e+02,
+    7.5595315138343722e-05, 2, -1, 1.3680000305175781e+02,
+    3.2976000976562500e+02, 4.4640003204345703e+01,
+    3.0636505126953125e+02, 1.5047104170662351e-05, 2, -1,
+    2.1168000793457031e+02, 3.2976000976562500e+02,
+    4.4640003204345703e+01, 1.2157823181152344e+02,
+    1.3064179802313447e-04, 2, -1, 2.2176000976562500e+02,
+    3.2976000976562500e+02, 4.4640003204345703e+01,
+    2.6275405883789062e+02, 7.4239615059923381e-05, 2, -1,
+    2.2608000183105469e+02, 3.2976000976562500e+02,
+    4.4640003204345703e+01, 3.0106369018554688e+02,
+    4.1901701479218900e-05, 2, -1, 2.3472001647949219e+02,
+    3.2976000976562500e+02, 4.4640003204345703e+01,
+    3.0182254028320312e+02, 4.1459832573309541e-05, 2, -1,
+    3.2544000244140625e+02, 3.2976000976562500e+02,
+    4.4640003204345703e+01, 3.6049087047576904e+00,
+    1.4252237633627374e-05, 2, -1, 2.0304000854492188e+02,
+    3.3120001220703125e+02, 4.4640003204345703e+01,
+    1.0907720184326172e+02, 1.7520933761261404e-04, 2, -1,
+    2.0880000305175781e+02, 3.3120001220703125e+02,
+    4.4640003204345703e+01, 1.1565550231933594e+02,
+    1.2673978926613927e-04, 2, -1, 2.5488000488281250e+02,
+    3.3120001220703125e+02, 4.4640003204345703e+01,
+    2.9317184448242188e+02, 1.8846181046683341e-04, 2, -1,
+    2.9376000976562500e+02, 3.3120001220703125e+02,
+    4.4640003204345703e+01, 2.7073547363281250e+02,
+    1.8616905435919762e-04, 2, -1, 2.9664001464843750e+02,
+    3.3120001220703125e+02, 4.4640003204345703e+01,
+    2.8959960937500000e+02, 1.2543618504423648e-04, 2, -1,
+    3.1824002075195312e+02, 3.3120001220703125e+02,
+    4.4640003204345703e+01, 2.9568807601928711e+01,
+    1.3692245374841150e-05, 2, -1, 3.9744000244140625e+02,
+    3.3120001220703125e+02, 4.4640003204345703e+01,
+    2.4611959838867188e+02, 8.6892367107793689e-05, 2, -1,
+    2.1744000244140625e+02, 3.3264001464843750e+02,
+    4.4640003204345703e+01, 1.0859219360351562e+02,
+    1.0134610056411475e-04, 2, -1, 2.2608000183105469e+02,
+    3.3264001464843750e+02, 4.4640003204345703e+01,
+    8.2737899780273438e+01, 5.2571100241038948e-05, 2, -1,
+    2.4624000549316406e+02, 3.3264001464843750e+02,
+    4.4640003204345703e+01, 3.0317819213867188e+02,
+    6.9715802965220064e-05, 2, -1, 2.5056001281738281e+02,
+    3.3264001464843750e+02, 4.4640003204345703e+01,
+    2.9790930175781250e+02, 1.1619949509622529e-04, 2, -1,
+    2.5920001220703125e+02, 3.3264001464843750e+02,
+    4.4640003204345703e+01, 2.9216143798828125e+02,
+    1.9851257093250751e-04, 2, -1, 2.7360000610351562e+02,
+    3.3264001464843750e+02, 4.4640003204345703e+01,
+    2.8023248291015625e+02, 6.0680322349071503e-05, 2, -1,
+    3.1104000854492188e+02, 3.3264001464843750e+02,
+    4.4640003204345703e+01, 2.1643119812011719e+01,
+    1.0376751561125275e-05, 2, -1, 3.8160000610351562e+02,
+    3.3264001464843750e+02, 4.4640003204345703e+01,
+    1.9931115722656250e+02, 6.1992041082703508e-06, 2, -1,
+    1.5840000915527344e+02, 3.3408001708984375e+02,
+    4.4640003204345703e+01, 2.6447525024414062e+02,
+    3.8036321257095551e-06, 2, -1, 2.1024000549316406e+02,
+    3.3408001708984375e+02, 4.4640003204345703e+01,
+    1.1129790496826172e+02, 3.3477128454251215e-05, 2, -1,
+    2.2032000732421875e+02, 3.3408001708984375e+02,
+    4.4640003204345703e+01, 1.0580415344238281e+02,
+    1.2764414714183658e-04, 2, -1, 2.9952001953125000e+02,
+    3.3408001708984375e+02, 4.4640003204345703e+01,
+    1.6888591766357422e+01, 2.8895831201225519e-04, 2, -1,
+    3.2112002563476562e+02, 3.3408001708984375e+02,
+    4.4640003204345703e+01, 3.5400234985351562e+02,
+    2.8685022698482499e-05, 2, -1, 3.4416000366210938e+02,
+    3.3408001708984375e+02, 4.4640003204345703e+01,
+    3.2592193603515625e+02, 4.7139033085841220e-06, 2, -1,
+    4.1472003173828125e+02, 3.3408001708984375e+02,
+    4.4640003204345703e+01, 1.8218344116210938e+02,
+    1.3563507309299894e-05, 2, -1, 1.6272000122070312e+02,
+    3.3552001953125000e+02, 4.4640003204345703e+01,
+    2.5573359680175781e+02, 6.2423337112704758e-06, 2, -1,
+    1.8864001464843750e+02, 3.3552001953125000e+02,
+    4.4640003204345703e+01, 9.6781829833984375e+01,
+    6.9217853706504684e-06, 2, -1, 1.9584001159667969e+02,
+    3.3552001953125000e+02, 4.4640003204345703e+01,
+    9.3088783264160156e+01, 8.5632136688218452e-06, 2, -1,
+    2.5632000732421875e+02, 3.3552001953125000e+02,
+    4.4640003204345703e+01, 3.0247634887695312e+02,
+    1.2655727914534509e-04, 2, -1, 2.6496002197265625e+02,
+    3.3552001953125000e+02, 4.4640003204345703e+01,
+    2.9333819580078125e+02, 2.5095886667259037e-04, 2, -1,
+    3.0384002685546875e+02, 3.3552001953125000e+02,
+    4.4640003204345703e+01, 4.6402034759521484e+01,
+    9.0202098363079131e-05, 2, -1, 3.7440002441406250e+02,
+    3.3552001953125000e+02, 4.4640003204345703e+01,
+    2.1094281005859375e+02, 4.3114090658491477e-05, 2, -1,
+    3.7872000122070312e+02, 3.3552001953125000e+02,
+    4.4640003204345703e+01, 2.1256695556640625e+02,
+    2.7790183594333939e-05, 2, -1, 3.9888000488281250e+02,
+    3.3552001953125000e+02, 4.4640003204345703e+01,
+    2.5327877807617188e+02, 7.0829082687851042e-05, 2, -1,
+    4.1904000854492188e+02, 3.3552001953125000e+02,
+    4.4640003204345703e+01, 1.7840266418457031e+02,
+    2.0702771507785656e-05, 2, -1, 2.3040000915527344e+02,
+    3.3696002197265625e+02, 4.4640003204345703e+01,
+    9.8480155944824219e+01, 2.5766308681340888e-05, 2, -1,
+    2.3904000854492188e+02, 3.3696002197265625e+02,
+    4.4640003204345703e+01, 4.6154693603515625e+01,
+    3.2674357498763129e-05, 2, -1, 2.8368002319335938e+02,
+    3.3696002197265625e+02, 4.4640003204345703e+01,
+    3.1606124877929688e+02, 8.9939152530860156e-05, 2, -1,
+    2.6208001708984375e+02, 3.3840002441406250e+02,
+    4.4640003204345703e+01, 3.1082800292968750e+02,
+    1.7338788893539459e-04, 2, -1, 2.8080001831054688e+02,
+    3.3840002441406250e+02, 4.4640003204345703e+01,
+    3.1752856445312500e+02, 7.3359457019250840e-05, 2, -1,
+    3.2688000488281250e+02, 3.3840002441406250e+02,
+    4.4640003204345703e+01, 2.7511877441406250e+02,
+    4.5756747567793354e-05, 2, -1, 3.4560000610351562e+02,
+    3.3840002441406250e+02, 4.4640003204345703e+01,
+    3.0470385742187500e+02, 4.6350382945092861e-06, 2, -1,
+    4.0032000732421875e+02, 3.3840002441406250e+02,
+    4.4640003204345703e+01, 2.4827569580078125e+02,
+    9.1672685812227428e-05, 2, -1, 1.8576000976562500e+02,
+    3.3984002685546875e+02, 4.4640003204345703e+01,
+    7.5277221679687500e+01, 7.5179609666520264e-06, 2, -1,
+    2.9520001220703125e+02, 3.3984002685546875e+02,
+    4.4640003204345703e+01, 3.2105655670166016e+01,
+    4.8950958444038406e-05, 2, -1, 3.1824002075195312e+02,
+    3.3984002685546875e+02, 4.4640003204345703e+01,
+    1.9210412979125977e+01, 3.7480891478480771e-05, 2, -1,
+    3.2255999755859375e+02, 3.3984002685546875e+02,
+    4.4640003204345703e+01, 2.6479748535156250e+02,
+    5.2746694564120844e-05, 2, -1, 2.8080001831054688e+02,
+    3.4127999877929688e+02, 4.4640003204345703e+01,
+    9.7709054946899414e+00, 1.1562770669115707e-04, 2, -1,
+    3.8160000610351562e+02, 3.4127999877929688e+02,
+    4.4640003204345703e+01, 2.2067807006835938e+02,
+    8.5684423538623378e-06, 2, -1, 4.1616000366210938e+02,
+    3.4127999877929688e+02, 4.4640003204345703e+01,
+    1.8290853881835938e+02, 1.7829663192969747e-05, 2, -1,
+    4.1904000854492188e+02, 3.4127999877929688e+02,
+    4.4640003204345703e+01, 1.8082429504394531e+02,
+    1.5297304344130680e-05, 2, -1, 2.0016000366210938e+02,
+    3.4272000122070312e+02, 4.4640003204345703e+01,
+    2.9105670166015625e+02, 4.6947939154051710e-06, 2, -1,
+    2.6927999877929688e+02, 3.4272000122070312e+02,
+    4.4640003204345703e+01, 3.4646545410156250e+02,
+    4.2593783291522413e-05, 2, -1, 2.8368002319335938e+02,
+    3.4272000122070312e+02, 4.4640003204345703e+01,
+    1.6744039535522461e+01, 1.1861262464663014e-04, 2, -1,
+    2.8655999755859375e+02, 3.4272000122070312e+02,
+    4.4640003204345703e+01, 1.4082292556762695e+01,
+    1.2505182530730963e-04, 2, -1, 3.5568002319335938e+02,
+    3.4272000122070312e+02, 4.4640003204345703e+01,
+    2.8145642089843750e+02, 2.2828089640825056e-06, 2, -1,
+    2.0736001586914062e+02, 3.4416000366210938e+02,
+    4.4640003204345703e+01, 2.1986425781250000e+02,
+    5.1395104492257815e-06, 2, -1, 2.7792001342773438e+02,
+    3.4416000366210938e+02, 4.4640003204345703e+01,
+    1.5575631141662598e+01, 1.0297774133505300e-04, 2, -1,
+    3.2832000732421875e+02, 3.4416000366210938e+02,
+    4.4640003204345703e+01, 2.4856591796875000e+02,
+    5.2778195822611451e-05, 2, -1, 3.3264001464843750e+02,
+    3.4416000366210938e+02, 4.4640003204345703e+01,
+    2.8385995483398438e+02, 8.1133766798302531e-05, 2, -1,
+    2.1888000488281250e+02, 3.4560000610351562e+02,
+    4.4640003204345703e+01, 9.9737182617187500e+01,
+    3.1779002256371314e-06, 2, -1, 3.1536001586914062e+02,
+    3.4560000610351562e+02, 4.4640003204345703e+01,
+    1.8279216003417969e+02, 1.0553647007327527e-04, 2, -1,
+    3.9888000488281250e+02, 3.4560000610351562e+02,
+    4.4640003204345703e+01, 2.4632086181640625e+02,
+    5.4020420066080987e-05, 2, -1, 2.2752000427246094e+02,
+    3.4704000854492188e+02, 4.4640003204345703e+01,
+    1.1455427551269531e+02, 9.6004969236673787e-06, 2, -1,
+    3.4704000854492188e+02, 3.4704000854492188e+02,
+    4.4640003204345703e+01, 2.9298971557617188e+02,
+    8.6718710008426569e-06, 2, -1, 3.6576000976562500e+02,
+    3.4704000854492188e+02, 4.4640003204345703e+01,
+    2.5450189208984375e+02, 1.4634107174060773e-05, 2, -1,
+    4.0176000976562500e+02, 3.4704000854492188e+02,
+    4.4640003204345703e+01, 2.0937040710449219e+02,
+    6.0458914958871901e-05, 2, -1, 3.4127999877929688e+02,
+    3.4848001098632812e+02, 4.4640003204345703e+01,
+    2.9526074218750000e+02, 8.0386686022393405e-05, 2, -1,
+    3.7152001953125000e+02, 3.4848001098632812e+02,
+    4.4640003204345703e+01, 2.5364260864257812e+02,
+    9.9997932920814492e-06, 2, -1, 2.4336001586914062e+02,
+    3.4992001342773438e+02, 4.4640003204345703e+01,
+    1.1436309814453125e+02, 4.8029178287833929e-06, 2, -1,
+    2.9376000976562500e+02, 3.4992001342773438e+02,
+    4.4640003204345703e+01, 3.1207052612304688e+02,
+    2.2693635401083156e-05, 2, -1, 3.3264001464843750e+02,
+    3.4992001342773438e+02, 4.4640003204345703e+01,
+    2.5638552856445312e+02, 9.6570038294885308e-05, 2, -1,
+    3.7440002441406250e+02, 3.4992001342773438e+02,
+    4.4640003204345703e+01, 2.5787088012695312e+02,
+    1.3433314961730503e-05, 2, -1, 4.0032000732421875e+02,
+    3.4992001342773438e+02, 4.4640003204345703e+01,
+    2.2430853271484375e+02, 7.7853561379015446e-05, 2, -1,
+    2.5056001281738281e+02, 3.5136001586914062e+02,
+    4.4640003204345703e+01, 1.1871558380126953e+02,
+    7.7064405559212901e-06, 2, -1, 3.0384002685546875e+02,
+    3.5136001586914062e+02, 4.4640003204345703e+01,
+    3.0238134765625000e+02, 1.7893680706038140e-05, 2, -1,
+    3.5568002319335938e+02, 3.5136001586914062e+02,
+    4.4640003204345703e+01, 2.7497991943359375e+02,
+    1.2944067748321686e-05, 2, -1, 3.1392001342773438e+02,
+    3.5280001831054688e+02, 4.4640003204345703e+01,
+    2.5876336669921875e+02, 3.0328275897772983e-05, 2, -1,
+    3.5136001586914062e+02, 3.5280001831054688e+02,
+    4.4640003204345703e+01, 2.8185052490234375e+02,
+    1.3027078239247203e-05, 2, -1, 2.6783999633789062e+02,
+    3.5424002075195312e+02, 4.4640003204345703e+01,
+    3.1477392578125000e+02, 1.2881645488960203e-05, 2, -1,
+    3.2255999755859375e+02, 3.5424002075195312e+02,
+    4.4640003204345703e+01, 2.5206393432617188e+02,
+    8.4944322225055657e-06, 2, -1, 4.1616000366210938e+02,
+    3.5424002075195312e+02, 4.4640003204345703e+01,
+    1.8035800170898438e+02, 8.1417474575573578e-06, 2, -1,
+    4.1904000854492188e+02, 3.5424002075195312e+02,
+    4.4640003204345703e+01, 1.7960398864746094e+02,
+    1.0252550055156462e-05, 2, -1, 3.5136001586914062e+02,
+    3.5568002319335938e+02, 4.4640003204345703e+01,
+    2.7673519897460938e+02, 3.3811524190241471e-05, 2, -1,
+    3.2544000244140625e+02, 3.5712002563476562e+02,
+    4.4640003204345703e+01, 2.6276983642578125e+02,
+    -4.8476713345735334e-06, 2, -1, 3.4127999877929688e+02,
+    3.5712002563476562e+02, 4.4640003204345703e+01,
+    2.8048712158203125e+02, 1.8523225662647747e-05, 2, -1,
+    4.0176000976562500e+02, 3.5712002563476562e+02,
+    4.4640003204345703e+01, 2.2812750244140625e+02,
+    9.4354596512857825e-05, 2, -1, 2.9088000488281250e+02,
+    3.5856002807617188e+02, 4.4640003204345703e+01,
+    2.9118365478515625e+02, 9.4193665063357912e-06, 2, -1,
+    3.4992001342773438e+02, 3.5856002807617188e+02,
+    4.4640003204345703e+01, 2.7607550048828125e+02,
+    2.7574735213420354e-05, 2, -1, 3.6720001220703125e+02,
+    3.5856002807617188e+02, 4.4640003204345703e+01,
+    2.6334140014648438e+02, 9.6187504823319614e-06, 2, -1,
+    3.8304000854492188e+02, 360., 4.4640003204345703e+01,
+    2.5273823547363281e+02, 1.3546367881644983e-05, 2, -1,
+    2.9808001708984375e+02, 3.6144000244140625e+02,
+    4.4640003204345703e+01, 2.7937060546875000e+02,
+    2.7804249839391559e-05, 2, -1, 3.5712002563476562e+02,
+    3.6144000244140625e+02, 4.4640003204345703e+01,
+    2.7731304931640625e+02, 1.8530186935095116e-05, 2, -1,
+    4.1616000366210938e+02, 3.6144000244140625e+02,
+    4.4640003204345703e+01, 1.7997245788574219e+02,
+    6.6538987084641121e-06, 2, -1, 4.2048001098632812e+02,
+    3.6144000244140625e+02, 4.4640003204345703e+01,
+    1.7990121459960938e+02, 7.3955998232122511e-06, 2, -1,
+    3.2112002563476562e+02, 3.6288000488281250e+02,
+    4.4640003204345703e+01, 2.7473791503906250e+02,
+    1.3819816558680031e-05, 2, -1, 3.8304000854492188e+02,
+    3.6288000488281250e+02, 4.4640003204345703e+01,
+    2.6753527832031250e+02, 2.2632373656961136e-05, 2, -1,
+    3.1392001342773438e+02, 3.6432000732421875e+02,
+    4.4640003204345703e+01, 2.7932205200195312e+02,
+    2.3980828700587153e-05, 2, -1, 360., 3.6432000732421875e+02,
+    4.4640003204345703e+01, 2.7549279785156250e+02,
+    1.1564481610548683e-05, 2, -1, 3.6864001464843750e+02,
+    3.6432000732421875e+02, 4.4640003204345703e+01,
+    2.7669851684570312e+02, 1.5786308722454123e-05, 2, -1,
+    3.7872000122070312e+02, 3.6576000976562500e+02,
+    4.4640003204345703e+01, 2.8092166137695312e+02,
+    1.5002443433331791e-05, 2, -1, 4.0176000976562500e+02,
+    3.6576000976562500e+02, 4.4640003204345703e+01,
+    2.5873779296875000e+02, 5.0986272981390357e-05, 2, -1,
+    4.1760000610351562e+02, 3.6576000976562500e+02,
+    4.4640003204345703e+01, 1.9456416320800781e+02,
+    5.4936485867074225e-06, 2, -1, 3.3840002441406250e+02,
+    3.6720001220703125e+02, 4.4640003204345703e+01,
+    2.7476498413085938e+02, 1.3354109796637204e-05, 2, -1,
+    3.6288000488281250e+02, 3.7008001708984375e+02,
+    4.4640003204345703e+01, 2.7702737426757812e+02,
+    1.1765821000153664e-05, 2, -1, 3.7152001953125000e+02,
+    3.7152001953125000e+02, 4.4640003204345703e+01,
+    2.7682257080078125e+02, 1.4512826965074055e-05, 2, -1,
+    3.6144000244140625e+02, 3.7296002197265625e+02,
+    4.4640003204345703e+01, 2.7777102661132812e+02,
+    2.5944793378585018e-05, 2, -1, 4.2048001098632812e+02,
+    3.7440002441406250e+02, 4.4640003204345703e+01,
+    2.0321450805664062e+02, 1.3390836102189496e-05, 2, -1,
+    3.8736001586914062e+02, 3.7584002685546875e+02,
+    4.4640003204345703e+01, 2.7833746337890625e+02,
+    2.2685699150315486e-05, 2, -1, 3.9600003051757812e+02,
+    3.7728002929687500e+02, 4.4640003204345703e+01,
+    2.7008990478515625e+02, 2.6723910195869394e-05, 2, -1,
+    4.1328002929687500e+02, 3.7728002929687500e+02,
+    4.4640003204345703e+01, 2.5208752441406250e+02,
+    2.0834087990806438e-05, 2, -1, 4.2048001098632812e+02,
+    3.7728002929687500e+02, 4.4640003204345703e+01,
+    2.0742492675781250e+02, 1.6767669876571745e-05, 2, -1,
+    4.2624002075195312e+02, 3.8304000854492188e+02,
+    4.4640003204345703e+01, 1.9305873107910156e+02,
+    1.1177566193509847e-04, 2, -1, 4.3056002807617188e+02,
+    3.8448001098632812e+02, 4.4640003204345703e+01,
+    1.7807135009765625e+02, 1.3458756438922137e-04, 2, -1,
+    2.0563201904296875e+02, 1.3132801818847656e+02,
+    5.3568004608154297e+01, 1.5254138183593750e+02,
+    3.8105304156488273e-06, 3, -1, 2.1427201843261719e+02,
+    1.3824002075195312e+02, 5.3568004608154297e+01,
+    2.0910852050781250e+02, 1.0711304639698938e-04, 3, -1,
+    2.2982402038574219e+02, 1.3996801757812500e+02,
+    5.3568004608154297e+01, 2.0842584228515625e+02,
+    1.7905882486957125e-05, 3, -1, 2.0736001586914062e+02,
+    1.4169601440429688e+02, 5.3568004608154297e+01,
+    2.0990402221679688e+02, 9.1751362560898997e-06, 3, -1,
+    2.1081602478027344e+02, 1.4169601440429688e+02,
+    5.3568004608154297e+01, 2.0902792358398438e+02,
+    4.1520219383528456e-05, 3, -1, 2.1600001525878906e+02,
+    1.4169601440429688e+02, 5.3568004608154297e+01,
+    2.0616485595703125e+02, 8.6234722402878106e-05, 3, -1,
+    2.4537602233886719e+02, 1.4169601440429688e+02,
+    5.3568004608154297e+01, 5.4459022521972656e+01,
+    1.0842487426998559e-05, 3, -1, 2.5574401855468750e+02,
+    1.4169601440429688e+02, 5.3568004608154297e+01,
+    6.2606510162353516e+01, 3.0445526135736145e-06, 3, -1,
+    2.2464001464843750e+02, 1.4342401123046875e+02,
+    5.3568004608154297e+01, 1.8499536132812500e+02,
+    4.2187970393570140e-05, 3, -1, 2.2809602355957031e+02,
+    1.4342401123046875e+02, 5.3568004608154297e+01,
+    1.7019567871093750e+02, 3.4461478207958862e-05, 3, -1,
+    2.3500802612304688e+02, 1.4515200805664062e+02,
+    5.3568004608154297e+01, 7.8548362731933594e+01,
+    2.9460943551384844e-05, 3, -1, 2.0563201904296875e+02,
+    1.4688002014160156e+02, 5.3568004608154297e+01,
+    1.9393414306640625e+02, 7.3934056672442239e-06, 3, -1,
+    2.6611203002929688e+02, 1.4688002014160156e+02,
+    5.3568004608154297e+01, 8.3519020080566406e+01,
+    1.2490771041484550e-05, 3, -1, 2.3155201721191406e+02,
+    1.4860801696777344e+02, 5.3568004608154297e+01,
+    8.1384658813476562e+01, 3.5067449061898515e-05, 3, -1,
+    2.4537602233886719e+02, 1.4860801696777344e+02,
+    5.3568004608154297e+01, 6.7257965087890625e+01,
+    3.4000488085439429e-05, 3, -1, 2.5747201538085938e+02,
+    1.4860801696777344e+02, 5.3568004608154297e+01,
+    7.4272933959960938e+01, 4.4638936742558144e-06, 3, -1,
+    2.3846401977539062e+02, 1.5033601379394531e+02,
+    5.3568004608154297e+01, 6.8437820434570312e+01,
+    4.7732617531437427e-05, 3, -1, 2.6611203002929688e+02,
+    1.5033601379394531e+02, 5.3568004608154297e+01,
+    8.5091827392578125e+01, 9.8805321613326669e-06, 3, -1,
+    2.7648004150390625e+02, 1.5206401062011719e+02,
+    5.3568004608154297e+01, 9.1686912536621094e+01,
+    5.0566313802846707e-06, 3, -1, 2.6092803955078125e+02,
+    1.5379200744628906e+02, 5.3568004608154297e+01,
+    7.8159240722656250e+01, 6.4293622017430607e-06, 3, -1,
+    2.9030401611328125e+02, 1.5379200744628906e+02,
+    5.3568004608154297e+01, 9.8427597045898438e+01,
+    1.0765012120828032e-05, 3, -1, 3.0412802124023438e+02,
+    1.5379200744628906e+02, 5.3568004608154297e+01,
+    1.0159361267089844e+02, 2.3031270757201128e-05, 3, -1,
+    2.3500802612304688e+02, 1.5552001953125000e+02,
+    5.3568004608154297e+01, 6.1294479370117188e+01,
+    4.5962540752952918e-05, 3, -1, 3.1276803588867188e+02,
+    1.5552001953125000e+02, 5.3568004608154297e+01,
+    1.0026150512695312e+02, 1.5412924767588265e-05, 3, -1,
+    3.2140802001953125e+02, 1.5552001953125000e+02,
+    5.3568004608154297e+01, 9.6152381896972656e+01,
+    1.1503374480525963e-05, 3, -1, 2.0044801330566406e+02,
+    1.5724801635742188e+02, 5.3568004608154297e+01,
+    1.5699140930175781e+02, 7.0005335146561265e-05, 3, -1,
+    2.1600001525878906e+02, 1.5724801635742188e+02,
+    5.3568004608154297e+01, 1.7810780334472656e+02,
+    4.7588931920472533e-05, 3, -1, 2.2636802673339844e+02,
+    1.5724801635742188e+02, 5.3568004608154297e+01,
+    4.3409843444824219e+01, 5.3174320783000439e-05, 3, -1,
+    3.3004803466796875e+02, 1.5724801635742188e+02,
+    5.3568004608154297e+01, 9.7612174987792969e+01,
+    9.7069569164887071e-06, 3, -1, 3.4041604614257812e+02,
+    1.5897601318359375e+02, 5.3568004608154297e+01,
+    9.8377151489257812e+01, 4.5603192120324820e-06, 3, -1,
+    1.9872001647949219e+02, 1.6070401000976562e+02,
+    5.3568004608154297e+01, 1.5279837036132812e+02,
+    7.1153881435748190e-05, 3, -1, 3.4905603027343750e+02,
+    1.6070401000976562e+02, 5.3568004608154297e+01,
+    9.8136428833007812e+01, 1.1762372196244542e-05, 3, -1,
+    1.9008001708984375e+02, 1.6243202209472656e+02,
+    5.3568004608154297e+01, 1.4377770996093750e+02,
+    1.1328324944770429e-05, 3, -1, 3.5942404174804688e+02,
+    1.6243202209472656e+02, 5.3568004608154297e+01,
+    9.9771965026855469e+01, 1.0404563909105491e-05, 3, -1,
+    3.6979202270507812e+02, 1.6243202209472656e+02,
+    5.3568004608154297e+01, 1.0977439880371094e+02,
+    1.0561214367044158e-05, 3, -1, 4.2681604003906250e+02,
+    1.6243202209472656e+02, 5.3568004608154297e+01,
+    1.2348623657226562e+02, 4.8411334319098387e-06, 3, -1,
+    1.9353601074218750e+02, 1.6416001892089844e+02,
+    5.3568004608154297e+01, 1.4528656005859375e+02,
+    2.3144451915868558e-05, 3, -1, 2.8166403198242188e+02,
+    1.6416001892089844e+02, 5.3568004608154297e+01,
+    9.6933418273925781e+01, -9.9364501693344209e-07, 3, -1,
+    4.1126403808593750e+02, 1.6416001892089844e+02,
+    5.3568004608154297e+01, 1.2745597076416016e+02,
+    1.5794767023180611e-05, 3, -1, 4.3891204833984375e+02,
+    1.6416001892089844e+02, 5.3568004608154297e+01,
+    1.0584379577636719e+02, 1.5860945495660417e-05, 3, -1,
+    1.9008001708984375e+02, 1.6588801574707031e+02,
+    5.3568004608154297e+01, 1.4526283264160156e+02,
+    1.3482344002113678e-05, 3, -1, 2.0563201904296875e+02,
+    1.6588801574707031e+02, 5.3568004608154297e+01,
+    1.7978945922851562e+02, 5.2788254834013060e-05, 3, -1,
+    2.9721603393554688e+02, 1.6588801574707031e+02,
+    5.3568004608154297e+01, 1.0742456054687500e+02,
+    1.8826348195943865e-06, 3, -1, 3.9571203613281250e+02,
+    1.6588801574707031e+02, 5.3568004608154297e+01,
+    1.2371813964843750e+02, 2.2676464141113684e-05, 3, -1,
+    4.8384005737304688e+02, 1.6588801574707031e+02,
+    5.3568004608154297e+01, 1.9944183349609375e+02,
+    6.8362751335371286e-06, 3, -1, 3.0585601806640625e+02,
+    1.6761601257324219e+02, 5.3568004608154297e+01,
+    1.1755332946777344e+02, 2.4900859898480121e-06, 3, -1,
+    4.0780804443359375e+02, 1.6761601257324219e+02,
+    5.3568004608154297e+01, 1.1953540802001953e+02,
+    1.5225356946757529e-05, 3, -1, 4.5446405029296875e+02,
+    1.6761601257324219e+02, 5.3568004608154297e+01,
+    6.6529319763183594e+01, 2.7175005016033538e-05, 3, -1,
+    1.9699201965332031e+02, 1.6934400939941406e+02,
+    5.3568004608154297e+01, 1.6024653625488281e+02,
+    8.3399463619571179e-06, 3, -1, 4.0780804443359375e+02,
+    1.7107202148437500e+02, 5.3568004608154297e+01,
+    1.3340710449218750e+02, 9.3438829935621470e-06, 3, -1,
+    4.3027203369140625e+02, 1.7107202148437500e+02,
+    5.3568004608154297e+01, 1.2290013122558594e+02,
+    2.2298036128631793e-05, 3, -1, 4.4064004516601562e+02,
+    1.7107202148437500e+02, 5.3568004608154297e+01,
+    1.2785029602050781e+02, 3.0995128327049315e-05, 3, -1,
+    4.5619204711914062e+02, 1.7107202148437500e+02,
+    5.3568004608154297e+01, 2.3973485946655273e+01,
+    3.0541748856194317e-05, 3, -1, 4.7174404907226562e+02,
+    1.7107202148437500e+02, 5.3568004608154297e+01,
+    1.7903308105468750e+02, 7.5333875429350883e-05, 3, -1,
+    3.4905603027343750e+02, 1.7280001831054688e+02,
+    5.3568004608154297e+01, 8.7051582336425781e+01,
+    1.9122958292427938e-06, 3, -1, 4.3545605468750000e+02,
+    1.7280001831054688e+02, 5.3568004608154297e+01,
+    1.2352886199951172e+02, 4.5189732190920040e-05, 3, -1,
+    4.6483203125000000e+02, 1.7280001831054688e+02,
+    5.3568004608154297e+01, 1.8445690917968750e+02,
+    4.6271816245280206e-05, 3, -1, 3.0240002441406250e+02,
+    1.7452801513671875e+02, 5.3568004608154297e+01,
+    2.1092102050781250e+02, 6.6680422605713829e-06, 3, -1,
+    3.6806402587890625e+02, 1.7452801513671875e+02,
+    5.3568004608154297e+01, 1.3297866821289062e+02,
+    2.3956797576829558e-06, 3, -1, 4.7347204589843750e+02,
+    1.7452801513671875e+02, 5.3568004608154297e+01,
+    1.8684867858886719e+02, 1.8513524992158636e-05, 3, -1,
+    2.2291201782226562e+02, 1.7625601196289062e+02,
+    5.3568004608154297e+01, 1.4467766284942627e+00,
+    5.2719055929628666e-06, 3, -1, 2.2982402038574219e+02,
+    1.7798402404785156e+02, 5.3568004608154297e+01,
+    1.1703875541687012e+01, 3.6825109418714419e-05, 3, -1,
+    2.3673602294921875e+02, 1.7798402404785156e+02,
+    5.3568004608154297e+01, 1.0951107025146484e+01,
+    9.1818808868993074e-05, 3, -1, 4.3200003051757812e+02,
+    1.7798402404785156e+02, 5.3568004608154297e+01,
+    1.3593609619140625e+02, 3.9228263631230220e-05, 3, -1,
+    1.7971202087402344e+02, 1.7971202087402344e+02,
+    5.3568004608154297e+01, 1.0202954101562500e+02,
+    1.9135623006150126e-05, 3, -1, 1.8662402343750000e+02,
+    1.8144001770019531e+02, 5.3568004608154297e+01,
+    1.5196685791015625e+02, 4.3845255277119577e-05, 3, -1,
+    3.4560003662109375e+02, 1.8144001770019531e+02,
+    5.3568004608154297e+01, 6.8707710266113281e+01,
+    4.8600841182633303e-06, 3, -1, 3.8016003417968750e+02,
+    1.8144001770019531e+02, 5.3568004608154297e+01,
+    1.6367909240722656e+02, 1.1192135571036488e-04, 3, -1,
+    3.8534402465820312e+02, 1.8144001770019531e+02,
+    5.3568004608154297e+01, 1.6710371398925781e+02,
+    3.1045990908751264e-05, 3, -1, 3.9052804565429688e+02,
+    1.8144001770019531e+02, 5.3568004608154297e+01,
+    1.7523135375976562e+02, 1.4353629012475722e-05, 3, -1,
+    4.1299203491210938e+02, 1.8144001770019531e+02,
+    5.3568004608154297e+01, 1.3209362792968750e+02,
+    1.3806987226416823e-05, 3, -1, 2.3328002929687500e+02,
+    1.8316801452636719e+02, 5.3568004608154297e+01,
+    8.1198377609252930e+00, 3.7461148167494684e-05, 3, -1,
+    2.8166403198242188e+02, 1.8316801452636719e+02,
+    5.3568004608154297e+01, 2.3744020080566406e+02,
+    1.3863828826288227e-05, 3, -1, 3.3523202514648438e+02,
+    1.8316801452636719e+02, 5.3568004608154297e+01,
+    3.9601375579833984e+01, 1.7350663256365806e-05, 3, -1,
+    3.7324804687500000e+02, 1.8316801452636719e+02,
+    5.3568004608154297e+01, 1.6398913574218750e+02,
+    1.8193163850810379e-04, 3, -1, 3.9744003295898438e+02,
+    1.8316801452636719e+02, 5.3568004608154297e+01,
+    1.9952203369140625e+02, 1.0546252269705292e-05, 3, -1,
+    4.4236804199218750e+02, 1.8316801452636719e+02,
+    5.3568004608154297e+01, 1.5707464599609375e+02,
+    5.0905589887406677e-05, 3, -1, 1.8489601135253906e+02,
+    1.8489601135253906e+02, 5.3568004608154297e+01,
+    1.7252493286132812e+02, 5.0372309488011524e-05, 3, -1,
+    2.1600001525878906e+02, 1.8489601135253906e+02,
+    5.3568004608154297e+01, 8.7899772644042969e+01,
+    1.2957548278791364e-05, 3, -1, 3.0067202758789062e+02,
+    1.8489601135253906e+02, 5.3568004608154297e+01,
+    2.6630364990234375e+02, 4.9391474021831527e-05, 3, -1,
+    3.7670404052734375e+02, 1.8489601135253906e+02,
+    5.3568004608154297e+01, 1.6802313232421875e+02,
+    1.6938915359787643e-04, 3, -1, 4.3718405151367188e+02,
+    1.8489601135253906e+02, 5.3568004608154297e+01,
+    1.5162490844726562e+02, 3.5221564758103341e-05, 3, -1,
+    4.4755203247070312e+02, 1.8489601135253906e+02,
+    5.3568004608154297e+01, 1.5912385559082031e+02,
+    4.2853000195464119e-05, 3, -1, 4.5100805664062500e+02,
+    1.8489601135253906e+02, 5.3568004608154297e+01,
+    1.6093899536132812e+02, 2.7340865926817060e-05, 3, -1,
+    4.5792004394531250e+02, 1.8489601135253906e+02,
+    5.3568004608154297e+01, 2.1395071411132812e+02,
+    9.8305281426291913e-06, 3, -1, 2.6611203002929688e+02,
+    1.8662402343750000e+02, 5.3568004608154297e+01,
+    2.2236065673828125e+02, 6.5276603891106788e-06, 3, -1,
+    3.9916802978515625e+02, 1.8662402343750000e+02,
+    5.3568004608154297e+01, 1.9275057983398438e+02,
+    1.1225705748074688e-05, 3, -1, 2.1427201843261719e+02,
+    1.8835202026367188e+02, 5.3568004608154297e+01,
+    1.1678593444824219e+02, 2.5193388864863664e-05, 3, -1,
+    2.3155201721191406e+02, 1.8835202026367188e+02,
+    5.3568004608154297e+01, 1.3809826850891113e+01,
+    6.3108629547059536e-05, 3, -1, 2.3846401977539062e+02,
+    1.8835202026367188e+02, 5.3568004608154297e+01,
+    1.2001511573791504e+01, 8.0292513302993029e-05, 3, -1,
+    2.5401602172851562e+02, 1.8835202026367188e+02,
+    5.3568004608154297e+01, 3.2728500366210938e+02,
+    5.0348512559139635e-06, 3, -1, 3.6979202270507812e+02,
+    1.8835202026367188e+02, 5.3568004608154297e+01,
+    1.6379446411132812e+02, 1.2270902516320348e-04, 3, -1,
+    3.7843203735351562e+02, 1.8835202026367188e+02,
+    5.3568004608154297e+01, 1.6415211486816406e+02,
+    1.4752491551917046e-04, 3, -1, 2.2291201782226562e+02,
+    1.9008001708984375e+02, 5.3568004608154297e+01,
+    2.4274984359741211e+01, 1.9017823433387093e-05, 3, -1,
+    2.4537602233886719e+02, 1.9008001708984375e+02,
+    5.3568004608154297e+01, 9.2578210830688477e+00,
+    1.8405238733976148e-05, 3, -1, 3.1104003906250000e+02,
+    1.9008001708984375e+02, 5.3568004608154297e+01,
+    2.8877239990234375e+02, 2.2036147129256278e-05, 3, -1,
+    3.4905603027343750e+02, 1.9008001708984375e+02,
+    5.3568004608154297e+01, 5.9490459442138672e+01,
+    2.8236088837729767e-05, 3, -1, 4.6310403442382812e+02,
+    1.9008001708984375e+02, 5.3568004608154297e+01,
+    2.0826388549804688e+02, 3.9618636947125196e-05, 3, -1,
+    4.6656005859375000e+02, 1.9008001708984375e+02,
+    5.3568004608154297e+01, 2.0975994873046875e+02,
+    1.4837697563052643e-05, 3, -1, 1.7107202148437500e+02,
+    1.9180801391601562e+02, 5.3568004608154297e+01,
+    1.1529666137695312e+02, 7.5061807365273125e-06, 3, -1,
+    1.8662402343750000e+02, 1.9180801391601562e+02,
+    5.3568004608154297e+01, 2.1257620239257812e+02,
+    2.5123354134848341e-05, 3, -1, 2.1254402160644531e+02,
+    1.9180801391601562e+02, 5.3568004608154297e+01,
+    1.2320042419433594e+02, 2.3490245439461432e-05, 3, -1,
+    2.7302401733398438e+02, 1.9180801391601562e+02,
+    5.3568004608154297e+01, 2.2873608398437500e+02,
+    2.2474574507214129e-04, 3, -1, 2.7820803833007812e+02,
+    1.9180801391601562e+02, 5.3568004608154297e+01,
+    2.3685351562500000e+02, 3.0429154867306352e-04, 3, -1,
+    3.1622402954101562e+02, 1.9180801391601562e+02,
+    5.3568004608154297e+01, 2.9421008300781250e+02,
+    3.5072778700850904e-05, 3, -1, 3.5251202392578125e+02,
+    1.9180801391601562e+02, 5.3568004608154297e+01,
+    8.8509521484375000e+01, 1.7398265299561899e-06, 3, -1,
+    3.6288003540039062e+02, 1.9180801391601562e+02,
+    5.3568004608154297e+01, 1.5459147644042969e+02,
+    5.6543558457633480e-05, 3, -1, 4.0780804443359375e+02,
+    1.9180801391601562e+02, 5.3568004608154297e+01,
+    6.6045730590820312e+01, 1.1741365597117692e-05, 3, -1,
+    2.8166403198242188e+02, 1.9353601074218750e+02,
+    5.3568004608154297e+01, 2.4025942993164062e+02,
+    2.5753895170055330e-04, 3, -1, 3.3004803466796875e+02,
+    1.9353601074218750e+02, 5.3568004608154297e+01,
+    3.4124517822265625e+02, 8.2413580457796343e-06, 3, -1,
+    3.8880004882812500e+02, 1.9353601074218750e+02,
+    5.3568004608154297e+01, 1.5302726745605469e+02,
+    9.3650858616456389e-05, 3, -1, 1.7452801513671875e+02,
+    1.9526402282714844e+02, 5.3568004608154297e+01,
+    2.0451330566406250e+02, 1.4062056834518444e-05, 3, -1,
+    2.1600001525878906e+02, 1.9526402282714844e+02,
+    5.3568004608154297e+01, 7.4818191528320312e+01,
+    2.9297671062522568e-05, 3, -1, 2.5747201538085938e+02,
+    1.9526402282714844e+02, 5.3568004608154297e+01,
+    2.3466893005371094e+02, 3.8561600376851857e-05, 3, -1,
+    2.7129602050781250e+02, 1.9526402282714844e+02,
+    5.3568004608154297e+01, 2.1988551330566406e+02,
+    1.6902192146517336e-04, 3, -1, 3.4214404296875000e+02,
+    1.9526402282714844e+02, 5.3568004608154297e+01,
+    3.4908831787109375e+02, 7.3534240073058754e-05, 3, -1,
+    4.0608004760742188e+02, 1.9526402282714844e+02,
+    5.3568004608154297e+01, 8.4043861389160156e+01,
+    2.4692646547919139e-05, 3, -1, 4.5964804077148438e+02,
+    1.9526402282714844e+02, 5.3568004608154297e+01,
+    2.0143963623046875e+02, 2.9427877962007187e-05, 3, -1,
+    2.0908801269531250e+02, 1.9699201965332031e+02,
+    5.3568004608154297e+01, 1.1577494812011719e+02,
+    1.0909621778409928e-05, 3, -1, 2.2636802673339844e+02,
+    1.9699201965332031e+02, 5.3568004608154297e+01,
+    3.9869377136230469e+01, 2.2876565344631672e-04, 3, -1,
+    2.2982402038574219e+02, 1.9699201965332031e+02,
+    5.3568004608154297e+01, 3.5953792572021484e+01,
+    1.4198019925970584e-04, 3, -1, 2.4710401916503906e+02,
+    1.9699201965332031e+02, 5.3568004608154297e+01,
+    6.9732532501220703e+00, 9.0947331045754254e-05, 3, -1,
+    3.0067202758789062e+02, 1.9699201965332031e+02,
+    5.3568004608154297e+01, 2.7920977783203125e+02,
+    2.7727743145078421e-05, 3, -1, 4.0953604125976562e+02,
+    1.9699201965332031e+02, 5.3568004608154297e+01,
+    6.8379684448242188e+01, 2.4816405129968189e-05, 3, -1,
+    2.3846401977539062e+02, 1.9872001647949219e+02,
+    5.3568004608154297e+01, 3.2410972595214844e+01,
+    5.7970475609181449e-05, 3, -1, 2.5228802490234375e+02,
+    1.9872001647949219e+02, 5.3568004608154297e+01,
+    2.6156622314453125e+02, 4.5370168663794175e-05, 3, -1,
+    2.7302401733398438e+02, 1.9872001647949219e+02,
+    5.3568004608154297e+01, 2.1161015319824219e+02,
+    1.0010554251493886e-04, 3, -1, 3.0585601806640625e+02,
+    1.9872001647949219e+02, 5.3568004608154297e+01,
+    2.9327868652343750e+02, 1.8909534264821559e-04, 3, -1,
+    3.1276803588867188e+02, 1.9872001647949219e+02,
+    5.3568004608154297e+01, 3.0992150878906250e+02,
+    7.7932527347002178e-05, 3, -1, 3.4387203979492188e+02,
+    1.9872001647949219e+02, 5.3568004608154297e+01,
+    3.2885128784179688e+02, 2.6087889636983164e-05, 3, -1,
+    3.6979202270507812e+02, 1.9872001647949219e+02,
+    5.3568004608154297e+01, 1.6670129394531250e+02,
+    3.7504261854337528e-05, 3, -1, 3.8016003417968750e+02,
+    1.9872001647949219e+02, 5.3568004608154297e+01,
+    1.4737435913085938e+02, 1.0263043805025518e-04, 3, -1,
+    3.8880004882812500e+02, 1.9872001647949219e+02,
+    5.3568004608154297e+01, 1.3930303955078125e+02,
+    1.6895677254069597e-04, 3, -1, 3.9744003295898438e+02,
+    1.9872001647949219e+02, 5.3568004608154297e+01,
+    1.2666900634765625e+02, 3.7412934034364298e-05, 3, -1,
+    4.4582403564453125e+02, 1.9872001647949219e+02,
+    5.3568004608154297e+01, 1.7052101135253906e+02,
+    4.4492109736893326e-05, 3, -1, 1.7452801513671875e+02,
+    2.0044801330566406e+02, 5.3568004608154297e+01,
+    2.3686856079101562e+02, 1.8743920009001158e-05, 3, -1,
+    2.1254402160644531e+02, 2.0044801330566406e+02,
+    5.3568004608154297e+01, 8.4053977966308594e+01,
+    2.6174771846854128e-05, 3, -1, 2.2291201782226562e+02,
+    2.0044801330566406e+02, 5.3568004608154297e+01,
+    5.3508872985839844e+01, 1.7973881040234119e-04, 3, -1,
+    2.3155201721191406e+02, 2.0044801330566406e+02,
+    5.3568004608154297e+01, 4.1411277770996094e+01,
+    8.3144470409024507e-05, 3, -1, 2.6784002685546875e+02,
+    2.0044801330566406e+02, 5.3568004608154297e+01,
+    2.0351113891601562e+02, 1.8898323469329625e-04, 3, -1,
+    3.1795202636718750e+02, 2.0044801330566406e+02,
+    5.3568004608154297e+01, 3.2975765991210938e+02,
+    6.3797255279496312e-05, 3, -1, 3.3004803466796875e+02,
+    2.0044801330566406e+02, 5.3568004608154297e+01,
+    3.4325744628906250e+02, 9.0317435024189763e-06, 3, -1,
+    3.5424002075195312e+02, 2.0044801330566406e+02,
+    5.3568004608154297e+01, 2.6499176025390625e+02,
+    1.6224394130404107e-05, 3, -1, 4.0089602661132812e+02,
+    2.0044801330566406e+02, 5.3568004608154297e+01,
+    1.1678703308105469e+02, 4.1580817196518183e-05, 3, -1,
+    3.1104003906250000e+02, 2.0217602539062500e+02,
+    5.3568004608154297e+01, 3.3218511962890625e+02,
+    8.7623404397163540e-05, 3, -1, 3.7152005004882812e+02,
+    2.0217602539062500e+02, 5.3568004608154297e+01,
+    1.8044712829589844e+02, 5.9751677326858044e-05, 3, -1,
+    3.7497604370117188e+02, 2.0217602539062500e+02,
+    5.3568004608154297e+01, 1.6724468994140625e+02,
+    4.4522821553982794e-05, 3, -1, 4.0953604125976562e+02,
+    2.0217602539062500e+02, 5.3568004608154297e+01,
+    6.9094367980957031e+01, 2.5344175810460001e-05, 3, -1,
+    1.6934400939941406e+02, 2.0390402221679688e+02,
+    5.3568004608154297e+01, 2.5046011352539062e+02,
+    4.0180766518460587e-05, 3, -1, 2.1945602416992188e+02,
+    2.0390402221679688e+02, 5.3568004608154297e+01,
+    6.1198776245117188e+01, 1.7893021868076175e-04, 3, -1,
+    2.5228802490234375e+02, 2.0390402221679688e+02,
+    5.3568004608154297e+01, 1.8052523803710938e+02,
+    3.5910084989154711e-05, 3, -1, 2.9376004028320312e+02,
+    2.0390402221679688e+02, 5.3568004608154297e+01,
+    2.5217826843261719e+02, 3.9509221096523106e-05, 3, -1,
+    3.8188803100585938e+02, 2.0390402221679688e+02,
+    5.3568004608154297e+01, 1.5284910583496094e+02,
+    1.4791970897931606e-04, 3, -1, 3.9225604248046875e+02,
+    2.0390402221679688e+02, 5.3568004608154297e+01,
+    1.3946385192871094e+02, 1.5399178664665669e-04, 3, -1,
+    4.0089602661132812e+02, 2.0390402221679688e+02,
+    5.3568004608154297e+01, 1.2567561340332031e+02,
+    7.2440918302163482e-05, 3, -1, 4.0435205078125000e+02,
+    2.0390402221679688e+02, 5.3568004608154297e+01,
+    1.0809612274169922e+02, 3.8144858990563080e-05, 3, -1,
+    4.1472003173828125e+02, 2.0390402221679688e+02,
+    5.3568004608154297e+01, 6.5684089660644531e+01,
+    9.2920518000028096e-06, 3, -1, 2.0390402221679688e+02,
+    2.0563201904296875e+02, 5.3568004608154297e+01,
+    8.4619857788085938e+01, 5.2793802751693875e-05, 3, -1,
+    2.1081602478027344e+02, 2.0563201904296875e+02,
+    5.3568004608154297e+01, 7.5801544189453125e+01,
+    1.8969731172546744e-04, 3, -1, 2.6784002685546875e+02,
+    2.0563201904296875e+02, 5.3568004608154297e+01,
+    1.7945936584472656e+02, 1.5552318654954433e-04, 3, -1,
+    3.2140802001953125e+02, 2.0563201904296875e+02,
+    5.3568004608154297e+01, 1.7544511795043945e+01,
+    1.5796016668900847e-04, 3, -1, 3.5596804809570312e+02,
+    2.0563201904296875e+02, 5.3568004608154297e+01,
+    2.5010479736328125e+02, 6.0438538639573380e-05, 3, -1,
+    4.5964804077148438e+02, 2.0563201904296875e+02,
+    5.3568004608154297e+01, 1.9678276062011719e+02,
+    3.8152397792146076e-06, 3, -1, 2.1600001525878906e+02,
+    2.0736001586914062e+02, 5.3568004608154297e+01,
+    6.5283065795898438e+01, 2.5787664344534278e-04, 3, -1,
+    2.6092803955078125e+02, 2.0736001586914062e+02,
+    5.3568004608154297e+01, 1.6741528320312500e+02,
+    3.0405732104554772e-05, 3, -1, 3.7497604370117188e+02,
+    2.0736001586914062e+02, 5.3568004608154297e+01,
+    1.5524072265625000e+02, 3.6757621273864061e-05, 3, -1,
+    3.8534402465820312e+02, 2.0736001586914062e+02,
+    5.3568004608154297e+01, 1.4083106994628906e+02,
+    8.6645617557223886e-05, 3, -1, 2.1081602478027344e+02,
+    2.0908801269531250e+02, 5.3568004608154297e+01,
+    6.8207656860351562e+01, 3.3093683305196464e-04, 3, -1,
+    2.6611203002929688e+02, 2.0908801269531250e+02,
+    5.3568004608154297e+01, 1.7205235290527344e+02,
+    1.4916194777470082e-04, 3, -1, 3.1449603271484375e+02,
+    2.0908801269531250e+02, 5.3568004608154297e+01,
+    3.6802848815917969e+01, 1.7775585001800209e-04, 3, -1,
+    3.2486404418945312e+02, 2.0908801269531250e+02,
+    5.3568004608154297e+01, 3.5888137817382812e+01,
+    3.2550474861636758e-04, 3, -1, 3.6979202270507812e+02,
+    2.0908801269531250e+02, 5.3568004608154297e+01,
+    1.6073619079589844e+02, 1.2946367496624589e-04, 3, -1,
+    4.0608004760742188e+02, 2.1081602478027344e+02,
+    5.3568004608154297e+01, 1.1993179321289062e+02,
+    4.7039735363796353e-05, 3, -1, 2.6092803955078125e+02,
+    2.1254402160644531e+02, 5.3568004608154297e+01,
+    1.7304519653320312e+02, 3.0304947358672507e-05, 3, -1,
+    2.8339202880859375e+02, 2.1254402160644531e+02,
+    5.3568004608154297e+01, 1.6862640380859375e+02,
+    3.4294160286663100e-05, 3, -1, 3.6633602905273438e+02,
+    2.1254402160644531e+02, 5.3568004608154297e+01,
+    1.3417251586914062e+02, 1.3580273662228137e-04, 3, -1,
+    1.5379200744628906e+02, 2.1427201843261719e+02,
+    5.3568004608154297e+01, 2.2535757446289062e+02,
+    4.2725823732325807e-06, 3, -1, 2.0908801269531250e+02,
+    2.1427201843261719e+02, 5.3568004608154297e+01,
+    5.5050251007080078e+01, 2.3076671641319990e-04, 3, -1,
+    2.2464001464843750e+02, 2.1427201843261719e+02,
+    5.3568004608154297e+01, 5.1868122100830078e+01,
+    3.8393504837586079e-06, 3, -1, 3.0758401489257812e+02,
+    2.1427201843261719e+02, 5.3568004608154297e+01,
+    3.4364192962646484e+01, 7.0963011239655316e-05, 3, -1,
+    3.3177603149414062e+02, 2.1427201843261719e+02,
+    5.3568004608154297e+01, 3.1457859039306641e+01,
+    1.6529967251699418e-04, 3, -1, 4.4755203247070312e+02,
+    2.1427201843261719e+02, 5.3568004608154297e+01,
+    1.8909927368164062e+02, 2.7945265173912048e-05, 3, -1,
+    2.6438403320312500e+02, 2.1600001525878906e+02,
+    5.3568004608154297e+01, 1.9232908630371094e+02,
+    1.6409330783062615e-05, 3, -1, 3.7152005004882812e+02,
+    2.1600001525878906e+02, 5.3568004608154297e+01,
+    1.1880685424804688e+02, 2.3097654047887772e-04, 3, -1,
+    1.5379200744628906e+02, 2.1772802734375000e+02,
+    5.3568004608154297e+01, 2.1889321899414062e+02,
+    5.0255516725883354e-06, 3, -1, 1.6588801574707031e+02,
+    2.1772802734375000e+02, 5.3568004608154297e+01,
+    2.5747192382812500e+02, 3.8404268707381561e-05, 3, -1,
+    1.9699201965332031e+02, 2.1772802734375000e+02,
+    5.3568004608154297e+01, 6.4567497253417969e+01,
+    2.9942784749437124e-05, 3, -1, 2.0044801330566406e+02,
+    2.1945602416992188e+02, 5.3568004608154297e+01,
+    5.9770256042480469e+01, 6.7755296186078340e-05, 3, -1,
+    2.8166403198242188e+02, 2.1945602416992188e+02,
+    5.3568004608154297e+01, 1.9834289550781250e+02,
+    4.6926943468861282e-05, 3, -1, 3.7497604370117188e+02,
+    2.1945602416992188e+02, 5.3568004608154297e+01,
+    1.1026028442382812e+02, 1.4935120998416096e-04, 3, -1,
+    3.9744003295898438e+02, 2.1945602416992188e+02,
+    5.3568004608154297e+01, 1.3545176696777344e+02,
+    1.1343204096192494e-04, 3, -1, 4.0435205078125000e+02,
+    2.1945602416992188e+02, 5.3568004608154297e+01,
+    1.2904524230957031e+02, 1.6899734328035265e-04, 3, -1,
+    4.4582403564453125e+02, 2.1945602416992188e+02,
+    5.3568004608154297e+01, 1.9405477905273438e+02,
+    1.6988233255688101e-05, 3, -1, 1.6761601257324219e+02,
+    2.2118402099609375e+02, 5.3568004608154297e+01,
+    2.6275680541992188e+02, 5.9490332205314189e-05, 3, -1,
+    1.7280001831054688e+02, 2.2118402099609375e+02,
+    5.3568004608154297e+01, 2.8195214843750000e+02,
+    3.8961472455412149e-05, 3, -1, 2.9203201293945312e+02,
+    2.2118402099609375e+02, 5.3568004608154297e+01,
+    3.0367196655273438e+02, 1.9981038349214941e-05, 3, -1,
+    3.0758401489257812e+02, 2.2118402099609375e+02,
+    5.3568004608154297e+01, 5.0366640090942383e+00,
+    8.4613056969828904e-06, 3, -1, 3.8361602783203125e+02,
+    2.2118402099609375e+02, 5.3568004608154297e+01,
+    1.2442543792724609e+02, 4.9946273065870628e-05, 3, -1,
+    1.8144001770019531e+02, 2.2291201782226562e+02,
+    5.3568004608154297e+01, 3.3717681884765625e+02,
+    9.3451881184591912e-06, 3, -1, 3.9225604248046875e+02,
+    2.2291201782226562e+02, 5.3568004608154297e+01,
+    1.4146781921386719e+02, 8.3270715549588203e-05, 3, -1,
+    2.0390402221679688e+02, 2.2464001464843750e+02,
+    5.3568004608154297e+01, 4.0956447601318359e+01,
+    9.7726420790422708e-05, 3, -1, 3.8188803100585938e+02,
+    2.2464001464843750e+02, 5.3568004608154297e+01,
+    1.3441160583496094e+02, 2.6517695005168207e-05, 3, -1,
+    4.0608004760742188e+02, 2.2464001464843750e+02,
+    5.3568004608154297e+01, 1.4789958190917969e+02,
+    1.1379805073374882e-04, 3, -1, 1.4515200805664062e+02,
+    2.2636802673339844e+02, 5.3568004608154297e+01,
+    2.0922183227539062e+02, 1.6425923604401760e-05, 3, -1,
+    1.5379200744628906e+02, 2.2636802673339844e+02,
+    5.3568004608154297e+01, 2.1768955993652344e+02,
+    2.5067596652661450e-05, 3, -1, 1.6588801574707031e+02,
+    2.2636802673339844e+02, 5.3568004608154297e+01,
+    2.5306672668457031e+02, 1.5477262422791682e-05, 3, -1,
+    1.7625601196289062e+02, 2.2636802673339844e+02,
+    5.3568004608154297e+01, 3.3055191040039062e+02,
+    2.3059561499394476e-05, 3, -1, 1.9353601074218750e+02,
+    2.2636802673339844e+02, 5.3568004608154297e+01,
+    3.5570727539062500e+02, 1.6668611351633444e-05, 3, -1,
+    2.7302401733398438e+02, 2.2636802673339844e+02,
+    5.3568004608154297e+01, 2.0586210632324219e+02,
+    8.3387822087388486e-05, 3, -1, 2.7993603515625000e+02,
+    2.2636802673339844e+02, 5.3568004608154297e+01,
+    2.1307046508789062e+02, 4.2053110519191250e-05, 3, -1,
+    3.6979202270507812e+02, 2.2636802673339844e+02,
+    5.3568004608154297e+01, 1.2673522186279297e+02,
+    -9.3641683633904904e-05, 3, -1, 3.9916802978515625e+02,
+    2.2636802673339844e+02, 5.3568004608154297e+01,
+    1.5284265136718750e+02, 1.7472100444138050e-04, 3, -1,
+    2.9030401611328125e+02, 2.2809602355957031e+02,
+    5.3568004608154297e+01, 2.7680194091796875e+02,
+    5.7495810324326158e-05, 3, -1, 2.9376004028320312e+02,
+    2.2809602355957031e+02, 5.3568004608154297e+01,
+    3.0932916259765625e+02, 4.9429443606641144e-05, 3, -1,
+    4.3372802734375000e+02, 2.2809602355957031e+02,
+    5.3568004608154297e+01, 1.9485133361816406e+02,
+    2.5673209165688604e-05, 3, -1, 4.4928002929687500e+02,
+    2.2809602355957031e+02, 5.3568004608154297e+01,
+    2.0145623779296875e+02, 1.4582542462449055e-05, 3, -1,
+    1.4688002014160156e+02, 2.2982402038574219e+02,
+    5.3568004608154297e+01, 2.1054818725585938e+02,
+    4.4738426367985085e-05, 3, -1, 1.5033601379394531e+02,
+    2.2982402038574219e+02, 5.3568004608154297e+01,
+    2.1087902832031250e+02, 5.9178728406550363e-05, 3, -1,
+    2.4537602233886719e+02, 2.2982402038574219e+02,
+    5.3568004608154297e+01, 2.5902786254882812e+02,
+    3.6059423109691124e-06, 3, -1, 2.7648004150390625e+02,
+    2.2982402038574219e+02, 5.3568004608154297e+01,
+    2.0656509399414062e+02, 6.8215813371352851e-05, 3, -1,
+    4.0262402343750000e+02, 2.2982402038574219e+02,
+    5.3568004608154297e+01, 1.5905142211914062e+02,
+    1.2472776870708913e-04, 3, -1, 1.9699201965332031e+02,
+    2.3155201721191406e+02, 5.3568004608154297e+01,
+    3.5447866821289062e+02, 7.0972168941807467e-06, 3, -1,
+    2.0908801269531250e+02, 2.3155201721191406e+02,
+    5.3568004608154297e+01, 1.1535293579101562e+01,
+    2.3338416212936863e-05, 3, -1, 2.6784002685546875e+02,
+    2.3155201721191406e+02, 5.3568004608154297e+01,
+    2.0449333190917969e+02, 2.0166742615401745e-04, 3, -1,
+    2.9721603393554688e+02, 2.3155201721191406e+02,
+    5.3568004608154297e+01, 3.3782827758789062e+02,
+    4.8155117838177830e-05, 3, -1, 1.7971202087402344e+02,
+    2.3328002929687500e+02, 5.3568004608154297e+01,
+    3.3126187133789062e+02, 2.1562718757195398e-05, 3, -1,
+    2.8857601928710938e+02, 2.3328002929687500e+02,
+    5.3568004608154297e+01, 2.6469842529296875e+02,
+    2.6572912247502245e-05, 3, -1, 1.5206401062011719e+02,
+    2.3500802612304688e+02, 5.3568004608154297e+01,
+    2.0855001831054688e+02, 1.2146804692747537e-05, 3, -1,
+    1.6243202209472656e+02, 2.3500802612304688e+02,
+    5.3568004608154297e+01, 2.4119645690917969e+02,
+    9.3825161457061768e-05, 3, -1, 1.7107202148437500e+02,
+    2.3500802612304688e+02, 5.3568004608154297e+01,
+    3.2060940551757812e+02, 8.9260422100778669e-05, 3, -1,
+    2.0908801269531250e+02, 2.3500802612304688e+02,
+    5.3568004608154297e+01, 3.5266635131835938e+02,
+    2.3814654923626222e-05, 3, -1, 2.1427201843261719e+02,
+    2.3500802612304688e+02, 5.3568004608154297e+01,
+    3.2502542114257812e+02, 1.5614812582498416e-05, 3, -1,
+    2.7475201416015625e+02, 2.3500802612304688e+02,
+    5.3568004608154297e+01, 1.9966090393066406e+02,
+    7.6541567977983505e-05, 3, -1, 3.0758401489257812e+02,
+    2.3500802612304688e+02, 5.3568004608154297e+01,
+    3.1909765625000000e+02, 6.2416635046247393e-05, 3, -1,
+    3.9744003295898438e+02, 2.3500802612304688e+02,
+    5.3568004608154297e+01, 1.8146466064453125e+02,
+    1.3875341392122209e-04, 3, -1, 4.4928002929687500e+02,
+    2.3500802612304688e+02, 5.3568004608154297e+01,
+    1.9470422363281250e+02, 6.0066308833484072e-06, 3, -1,
+    1.6761601257324219e+02, 2.3673602294921875e+02,
+    5.3568004608154297e+01, 3.1676513671875000e+02,
+    1.0638316598488018e-04, 3, -1, 1.8144001770019531e+02,
+    2.3673602294921875e+02, 5.3568004608154297e+01,
+    3.2861044311523438e+02, 2.5455912691541016e-05, 3, -1,
+    2.1945602416992188e+02, 2.3673602294921875e+02,
+    5.3568004608154297e+01, 2.8312322998046875e+02,
+    4.9555776058696210e-05, 3, -1, 2.3846401977539062e+02,
+    2.3673602294921875e+02, 5.3568004608154297e+01,
+    2.7797042846679688e+02, 5.1425040510366671e-06, 3, -1,
+    2.9376004028320312e+02, 2.3673602294921875e+02,
+    5.3568004608154297e+01, 3.5155038452148438e+02,
+    2.6295376301277429e-05, 3, -1, 3.0240002441406250e+02,
+    2.3673602294921875e+02, 5.3568004608154297e+01,
+    3.4274896240234375e+02, 9.9495657195802778e-05, 3, -1,
+    4.3545605468750000e+02, 2.3673602294921875e+02,
+    5.3568004608154297e+01, 2.0163647460937500e+02,
+    1.8226117390440777e-05, 3, -1, 2.0908801269531250e+02,
+    2.3846401977539062e+02, 5.3568004608154297e+01,
+    3.3798635864257812e+02, 1.8713515601120889e-05, 3, -1,
+    2.2464001464843750e+02, 2.3846401977539062e+02,
+    5.3568004608154297e+01, 2.5639892578125000e+02,
+    3.7692000205424847e-06, 3, -1, 3.3350402832031250e+02,
+    2.3846401977539062e+02, 5.3568004608154297e+01,
+    3.2021163940429688e+02, 5.0082505913451314e-04, 3, -1,
+    1.3996801757812500e+02, 2.4019201660156250e+02,
+    5.3568004608154297e+01, 1.7181260681152344e+02,
+    5.8153094869339839e-05, 3, -1, 1.7971202087402344e+02,
+    2.4019201660156250e+02, 5.3568004608154297e+01,
+    3.3600946044921875e+02, 6.2986364355310798e-05, 3, -1,
+    1.9526402282714844e+02, 2.4019201660156250e+02,
+    5.3568004608154297e+01, 3.4434896850585938e+02,
+    1.6370866433135234e-05, 3, -1, 2.1427201843261719e+02,
+    2.4019201660156250e+02, 5.3568004608154297e+01,
+    2.9159991455078125e+02, 2.1997333533363417e-05, 3, -1,
+    2.3155201721191406e+02, 2.4019201660156250e+02,
+    5.3568004608154297e+01, 2.6403070068359375e+02,
+    1.7691992297841352e-06, 3, -1, 2.6092803955078125e+02,
+    2.4019201660156250e+02, 5.3568004608154297e+01,
+    2.1264266967773438e+02, 1.8128758529201150e-04, 3, -1,
+    2.6784002685546875e+02, 2.4019201660156250e+02,
+    5.3568004608154297e+01, 2.0174053955078125e+02,
+    1.7997782560996711e-04, 3, -1, 3.6460803222656250e+02,
+    2.4019201660156250e+02, 5.3568004608154297e+01,
+    2.5174134826660156e+02, 8.6575026216451079e-05, 3, -1,
+    3.6979202270507812e+02, 2.4019201660156250e+02,
+    5.3568004608154297e+01, 2.5958343505859375e+02,
+    7.0271162257995456e-05, 3, -1, 4.3718405151367188e+02,
+    2.4192002868652344e+02, 5.3568004608154297e+01,
+    2.0611553955078125e+02, 5.6769196817185730e-05, 3, -1,
+    1.7625601196289062e+02, 2.4364802551269531e+02,
+    5.3568004608154297e+01, 1.6588100433349609e+01,
+    1.1185765470145270e-04, 3, -1, 1.8662402343750000e+02,
+    2.4364802551269531e+02, 5.3568004608154297e+01,
+    3.4605264282226562e+02, 3.4842007153201848e-05, 3, -1,
+    1.9008001708984375e+02, 2.4364802551269531e+02,
+    5.3568004608154297e+01, 3.4591473388671875e+02,
+    2.7140542442793958e-05, 3, -1, 2.1772802734375000e+02,
+    2.4364802551269531e+02, 5.3568004608154297e+01,
+    2.6331506347656250e+02, 8.5106876213103533e-06, 3, -1,
+    2.4710401916503906e+02, 2.4364802551269531e+02,
+    5.3568004608154297e+01, 2.5806665039062500e+02,
+    2.7433130526333116e-05, 3, -1, 3.5424002075195312e+02,
+    2.4364802551269531e+02, 5.3568004608154297e+01,
+    2.9149822998046875e+02, 3.4568372939247638e-05, 3, -1,
+    3.9225604248046875e+02, 2.4364802551269531e+02,
+    5.3568004608154297e+01, 2.1037348937988281e+02,
+    7.2907248977571726e-05, 3, -1, 3.9916802978515625e+02,
+    2.4364802551269531e+02, 5.3568004608154297e+01,
+    2.0910267639160156e+02, 4.4170446926727891e-05, 3, -1,
+    2.6784002685546875e+02, 2.4537602233886719e+02,
+    5.3568004608154297e+01, 1.9060932922363281e+02,
+    7.1518406912218779e-05, 3, -1, 3.0412802124023438e+02,
+    2.4537602233886719e+02, 5.3568004608154297e+01,
+    3.5203027343750000e+02, 3.1212641624733806e-04, 3, -1,
+    3.0931204223632812e+02, 2.4537602233886719e+02,
+    5.3568004608154297e+01, 2.9819088745117188e+02,
+    6.1542697949334979e-05, 3, -1, 3.3523202514648438e+02,
+    2.4537602233886719e+02, 5.3568004608154297e+01,
+    3.1881634521484375e+02, 1.2930281809531152e-04, 3, -1,
+    3.6288003540039062e+02, 2.4537602233886719e+02,
+    5.3568004608154297e+01, 2.6431893920898438e+02,
+    1.1782805813709274e-04, 3, -1, 3.6979202270507812e+02,
+    2.4537602233886719e+02, 5.3568004608154297e+01,
+    2.7093365478515625e+02, 9.6319039585068822e-05, 3, -1,
+    4.4236804199218750e+02, 2.4537602233886719e+02,
+    5.3568004608154297e+01, 2.0112435913085938e+02,
+    2.8535419914987870e-05, 3, -1, 1.3651200866699219e+02,
+    2.4710401916503906e+02, 5.3568004608154297e+01,
+    1.1882192230224609e+02, 1.2916690320707858e-04, 3, -1,
+    1.6416001892089844e+02, 2.4710401916503906e+02,
+    5.3568004608154297e+01, 9.7089706420898438e+01,
+    7.0187918026931584e-05, 3, -1, 1.8835202026367188e+02,
+    2.4710401916503906e+02, 5.3568004608154297e+01,
+    1.5522247314453125e+01, 3.2962896511889994e-05, 3, -1,
+    2.9203201293945312e+02, 2.4710401916503906e+02,
+    5.3568004608154297e+01, 4.8127029418945312e+01,
+    1.5474322935915552e-05, 3, -1, 3.3868801879882812e+02,
+    2.4710401916503906e+02, 5.3568004608154297e+01,
+    3.1387286376953125e+02, 3.3361968235112727e-04, 3, -1,
+    3.4732803344726562e+02, 2.4710401916503906e+02,
+    5.3568004608154297e+01, 3.0184259033203125e+02,
+    9.6364696219097823e-05, 3, -1, 3.8016003417968750e+02,
+    2.4710401916503906e+02, 5.3568004608154297e+01,
+    2.5161077880859375e+02, 7.9130237281788141e-05, 3, -1,
+    3.8880004882812500e+02, 2.4710401916503906e+02,
+    5.3568004608154297e+01, 2.2463999938964844e+02,
+    5.5410644563380629e-05, 3, -1, 4.0608004760742188e+02,
+    2.4710401916503906e+02, 5.3568004608154297e+01,
+    2.1481842041015625e+02, 4.9725399549060967e-06, 3, -1,
+    1.3132801818847656e+02, 2.4883203125000000e+02,
+    5.3568004608154297e+01, 1.1492244720458984e+02,
+    4.5251206756802276e-05, 3, -1, 1.6934400939941406e+02,
+    2.4883203125000000e+02, 5.3568004608154297e+01,
+    9.1391387939453125e+01, 1.4002858370076865e-04, 3, -1,
+    3.1622402954101562e+02, 2.4883203125000000e+02,
+    5.3568004608154297e+01, 3.2776196289062500e+02,
+    1.4242915494833142e-04, 3, -1, 3.6288003540039062e+02,
+    2.4883203125000000e+02, 5.3568004608154297e+01,
+    2.7054830932617188e+02, 7.2652219387236983e-05, 3, -1,
+    3.8361602783203125e+02, 2.4883203125000000e+02,
+    5.3568004608154297e+01, 2.4377966308593750e+02,
+    5.0698941777227446e-05, 3, -1, 1.3996801757812500e+02,
+    2.5056002807617188e+02, 5.3568004608154297e+01,
+    1.1439529418945312e+02, 1.6363659233320504e-04, 3, -1,
+    1.4860801696777344e+02, 2.5056002807617188e+02,
+    5.3568004608154297e+01, 1.1785471343994141e+02,
+    3.9741946238791570e-05, 3, -1, 1.8144001770019531e+02,
+    2.5056002807617188e+02, 5.3568004608154297e+01,
+    7.0513259887695312e+01, 2.6625933969626203e-05, 3, -1,
+    1.9872001647949219e+02, 2.5056002807617188e+02,
+    5.3568004608154297e+01, 3.2297512054443359e+01,
+    3.2355510484194383e-05, 3, -1, 2.5920001220703125e+02,
+    2.5056002807617188e+02, 5.3568004608154297e+01,
+    2.0111959838867188e+02, 3.5241116620454704e-06, 3, -1,
+    2.9376004028320312e+02, 2.5056002807617188e+02,
+    5.3568004608154297e+01, 6.5807113647460938e+01,
+    2.5930357878678478e-05, 3, -1, 3.3523202514648438e+02,
+    2.5056002807617188e+02, 5.3568004608154297e+01,
+    3.2285742187500000e+02, 2.4733881582506001e-04, 3, -1,
+    3.4387203979492188e+02, 2.5056002807617188e+02,
+    5.3568004608154297e+01, 3.0542221069335938e+02,
+    1.3136732741259038e-04, 3, -1, 3.5251202392578125e+02,
+    2.5056002807617188e+02, 5.3568004608154297e+01,
+    2.8744708251953125e+02, 7.3810406320262700e-05, 3, -1,
+    3.5596804809570312e+02, 2.5056002807617188e+02,
+    5.3568004608154297e+01, 2.8233160400390625e+02,
+    5.1245442591607571e-05, 3, -1, 3.6979202270507812e+02,
+    2.5056002807617188e+02, 5.3568004608154297e+01,
+    2.7335736083984375e+02, 6.5436230215709656e-05, 3, -1,
+    3.7324804687500000e+02, 2.5056002807617188e+02,
+    5.3568004608154297e+01, 2.7443426513671875e+02,
+    9.9031640274915844e-05, 3, -1, 1.6416001892089844e+02,
+    2.5228802490234375e+02, 5.3568004608154297e+01,
+    1.0223065948486328e+02, 6.6965818405151367e-05, 3, -1,
+    1.7452801513671875e+02, 2.5228802490234375e+02,
+    5.3568004608154297e+01, 9.2655189514160156e+01,
+    3.6544668546412140e-05, 3, -1, 3.0412802124023438e+02,
+    2.5228802490234375e+02, 5.3568004608154297e+01,
+    8.7002868652343750e+01, 3.5859669878846034e-05, 3, -1,
+    3.2140802001953125e+02, 2.5228802490234375e+02,
+    5.3568004608154297e+01, 5.2981128692626953e+00,
+    1.3499539636541158e-04, 3, -1, 3.5942404174804688e+02,
+    2.5228802490234375e+02, 5.3568004608154297e+01,
+    2.7299237060546875e+02, 3.5922057577408850e-05, 3, -1,
+    4.4236804199218750e+02, 2.5228802490234375e+02,
+    5.3568004608154297e+01, 2.1282031250000000e+02,
+    2.2124763745523524e-06, 3, -1, 1.3132801818847656e+02,
+    2.5401602172851562e+02, 5.3568004608154297e+01,
+    1.0628929901123047e+02, 1.1378827912267298e-04, 3, -1,
+    3.1795202636718750e+02, 2.5401602172851562e+02,
+    5.3568004608154297e+01, 6.3504409790039062e+01,
+    1.5431121573783457e-04, 3, -1, 3.7152005004882812e+02,
+    2.5401602172851562e+02, 5.3568004608154297e+01,
+    2.7454421997070312e+02, 3.3783257094910368e-05, 3, -1,
+    4.1472003173828125e+02, 2.5401602172851562e+02,
+    5.3568004608154297e+01, 2.2399310302734375e+02,
+    2.5882907721097581e-05, 3, -1, 4.2681604003906250e+02,
+    2.5401602172851562e+02, 5.3568004608154297e+01,
+    2.1803306579589844e+02, 1.0787355677166488e-05, 3, -1,
+    1.6416001892089844e+02, 2.5574401855468750e+02,
+    5.3568004608154297e+01, 1.0306658935546875e+02,
+    5.8878802519757301e-05, 3, -1, 1.9699201965332031e+02,
+    2.5574401855468750e+02, 5.3568004608154297e+01,
+    6.9278259277343750e+01, 6.8853842094540596e-05, 3, -1,
+    1.2614401245117188e+02, 2.5747201538085938e+02,
+    5.3568004608154297e+01, 9.4540664672851562e+01,
+    6.6269742092117667e-05, 3, -1, 1.3651200866699219e+02,
+    2.5747201538085938e+02, 5.3568004608154297e+01,
+    1.0669750976562500e+02, 5.3033283620607108e-05, 3, -1,
+    1.4688002014160156e+02, 2.5747201538085938e+02,
+    5.3568004608154297e+01, 1.0491247558593750e+02,
+    7.1273236244451255e-05, 3, -1, 3.8361602783203125e+02,
+    2.5747201538085938e+02, 5.3568004608154297e+01,
+    2.6313952636718750e+02, 3.3754602100088960e-06, 3, -1,
+    4.1299203491210938e+02, 2.5747201538085938e+02,
+    5.3568004608154297e+01, 2.2264172363281250e+02,
+    3.3767566492315382e-05, 3, -1, 4.1990405273437500e+02,
+    2.5747201538085938e+02, 5.3568004608154297e+01,
+    2.2520169067382812e+02, 7.7306358434725553e-05, 3, -1,
+    1.6416001892089844e+02, 2.5920001220703125e+02,
+    5.3568004608154297e+01, 1.0175610351562500e+02,
+    1.5112733308342285e-05, 3, -1, 1.9353601074218750e+02,
+    2.5920001220703125e+02, 5.3568004608154297e+01,
+    7.4352676391601562e+01, 6.1234975873958319e-05, 3, -1,
+    3.5251202392578125e+02, 2.5920001220703125e+02,
+    5.3568004608154297e+01, 2.5921951293945312e+02,
+    1.0881041816901416e-05, 3, -1, 1.7625601196289062e+02,
+    2.6092803955078125e+02, 5.3568004608154297e+01,
+    9.7553993225097656e+01, 1.1873326911882032e-05, 3, -1,
+    2.3673602294921875e+02, 2.6092803955078125e+02,
+    5.3568004608154297e+01, 1.0733055877685547e+02,
+    5.3618063247995451e-05, 3, -1, 2.4537602233886719e+02,
+    2.6092803955078125e+02, 5.3568004608154297e+01,
+    9.6141265869140625e+01, 4.0657112549524754e-05, 3, -1,
+    2.5401602172851562e+02, 2.6092803955078125e+02,
+    5.3568004608154297e+01, 1.0372760772705078e+02,
+    3.0089619031059556e-05, 3, -1, 3.6115203857421875e+02,
+    2.6092803955078125e+02, 5.3568004608154297e+01,
+    2.6545159912109375e+02, 1.0924606613116339e-05, 3, -1,
+    2.5056002807617188e+02, 2.6265603637695312e+02,
+    5.3568004608154297e+01, 9.8329299926757812e+01,
+    3.9570539229316637e-05, 3, -1, 2.6092803955078125e+02,
+    2.6265603637695312e+02, 5.3568004608154297e+01,
+    1.0253806304931641e+02, 2.9605282179545611e-05, 3, -1,
+    3.4732803344726562e+02, 2.6265603637695312e+02,
+    5.3568004608154297e+01, 2.4087957763671875e+02,
+    4.9914251576410607e-06, 3, -1, 4.3545605468750000e+02,
+    2.6265603637695312e+02, 5.3568004608154297e+01,
+    2.0668058776855469e+02, 6.1476275732275099e-06, 3, -1,
+    4.6483203125000000e+02, 2.6265603637695312e+02,
+    5.3568004608154297e+01, 2.0169938659667969e+02,
+    1.0695354148992919e-06, 3, -1, 1.8144001770019531e+02,
+    2.6438403320312500e+02, 5.3568004608154297e+01,
+    9.2484580993652344e+01, 1.6865615179995075e-05, 3, -1,
+    2.7302401733398438e+02, 2.6438403320312500e+02,
+    5.3568004608154297e+01, 1.0271024322509766e+02,
+    3.1441777537111193e-05, 3, -1, 3.6115203857421875e+02,
+    2.6438403320312500e+02, 5.3568004608154297e+01,
+    2.4954812622070312e+02, 1.1164879651914816e-05, 3, -1,
+    4.2681604003906250e+02, 2.6438403320312500e+02,
+    5.3568004608154297e+01, 2.0329681396484375e+02,
+    3.2974516216199845e-05, 3, -1, 2.1772802734375000e+02,
+    2.6784002685546875e+02, 5.3568004608154297e+01,
+    9.6431358337402344e+01, 3.8501648305100389e-06, 3, -1,
+    2.7129602050781250e+02, 2.6784002685546875e+02,
+    5.3568004608154297e+01, 1.0006079101562500e+02,
+    3.5442371881799772e-05, 3, -1, 2.7475201416015625e+02,
+    2.6784002685546875e+02, 5.3568004608154297e+01,
+    1.0021142578125000e+02, 3.2667172490619123e-05, 3, -1,
+    2.9721603393554688e+02, 2.6784002685546875e+02,
+    5.3568004608154297e+01, 9.0761230468750000e+01,
+    2.5004732378874905e-05, 3, -1, 3.9744003295898438e+02,
+    2.6784002685546875e+02, 5.3568004608154297e+01,
+    2.1244778442382812e+02, 1.1166679178131744e-04, 3, -1,
+    4.3545605468750000e+02, 2.6784002685546875e+02,
+    5.3568004608154297e+01, 1.9823490905761719e+02,
+    9.2946411314187571e-06, 3, -1, 1.2441601562500000e+02,
+    2.6956802368164062e+02, 5.3568004608154297e+01,
+    6.2871963500976562e+01, 8.9901877800002694e-06, 3, -1,
+    1.2960000610351562e+02, 2.6956802368164062e+02,
+    5.3568004608154297e+01, 8.1969314575195312e+01,
+    5.4798501878394745e-06, 3, -1, 2.2636802673339844e+02,
+    2.6956802368164062e+02, 5.3568004608154297e+01,
+    1.0506326293945312e+02, 2.4895105070754653e-06, 3, -1,
+    3.0931204223632812e+02, 2.6956802368164062e+02,
+    5.3568004608154297e+01, 9.0141082763671875e+01,
+    3.1930358090903610e-05, 3, -1, 3.8361602783203125e+02,
+    2.6956802368164062e+02, 5.3568004608154297e+01,
+    2.5716787719726562e+02, 1.8177357560489327e-05, 3, -1,
+    4.2681604003906250e+02, 2.6956802368164062e+02,
+    5.3568004608154297e+01, 1.9250939941406250e+02,
+    6.9710986281279474e-05, 3, -1, 2.1600001525878906e+02,
+    2.7129602050781250e+02, 5.3568004608154297e+01,
+    9.6222953796386719e+01, -3.3672451991151320e-06, 3, -1,
+    3.8880004882812500e+02, 2.7129602050781250e+02,
+    5.3568004608154297e+01, 2.3772227478027344e+02,
+    7.5900774390902370e-05, 3, -1, 3.9398403930664062e+02,
+    2.7129602050781250e+02, 5.3568004608154297e+01,
+    2.2935789489746094e+02, 1.0106786066899076e-04, 3, -1,
+    4.0089602661132812e+02, 2.7129602050781250e+02,
+    5.3568004608154297e+01, 2.0162655639648438e+02,
+    8.8765547843649983e-05, 3, -1, 4.0780804443359375e+02,
+    2.7129602050781250e+02, 5.3568004608154297e+01,
+    2.0198851013183594e+02, 1.0010892583522946e-04, 3, -1,
+    4.3372802734375000e+02, 2.7129602050781250e+02,
+    5.3568004608154297e+01, 1.9208090209960938e+02,
+    1.6398975276388228e-05, 3, -1, 1.2960000610351562e+02,
+    2.7302401733398438e+02, 5.3568004608154297e+01,
+    7.2479415893554688e+01, 4.9783870963437948e-06, 3, -1,
+    1.5206401062011719e+02, 2.7302401733398438e+02,
+    5.3568004608154297e+01, 9.9056030273437500e+01,
+    1.8679356799111702e-06, 3, -1, 2.2464001464843750e+02,
+    2.7302401733398438e+02, 5.3568004608154297e+01,
+    1.0423166656494141e+02, -2.9505340535251889e-06, 3, -1,
+    3.1104003906250000e+02, 2.7302401733398438e+02,
+    5.3568004608154297e+01, 8.9224693298339844e+01,
+    3.1393217795994133e-05, 3, -1, 2.3846401977539062e+02,
+    2.7475201416015625e+02, 5.3568004608154297e+01,
+    1.0027110290527344e+02, -3.7409849937830586e-06, 3, -1,
+    3.0758401489257812e+02, 2.7475201416015625e+02,
+    5.3568004608154297e+01, 9.1334625244140625e+01,
+    3.7698988307965919e-05, 3, -1, 3.2313601684570312e+02,
+    2.7475201416015625e+02, 5.3568004608154297e+01,
+    9.4537773132324219e+01, 3.9044403820298612e-05, 3, -1,
+    3.5769604492187500e+02, 2.7475201416015625e+02,
+    5.3568004608154297e+01, 1.1660046386718750e+02,
+    2.3048936782288365e-05, 3, -1, 3.7152005004882812e+02,
+    2.7475201416015625e+02, 5.3568004608154297e+01,
+    1.2399540710449219e+02, 3.0955314286984503e-05, 3, -1,
+    4.1817602539062500e+02, 2.7475201416015625e+02,
+    5.3568004608154297e+01, 1.7399497985839844e+02,
+    3.3931752113858238e-05, 3, -1, 4.2336004638671875e+02,
+    2.7475201416015625e+02, 5.3568004608154297e+01,
+    1.8301766967773438e+02, 4.4068870920455083e-05, 3, -1,
+    1.5206401062011719e+02, 2.7648004150390625e+02,
+    5.3568004608154297e+01, 1.0118123626708984e+02,
+    1.8662572074390482e-06, 3, -1, 3.8880004882812500e+02,
+    2.7648004150390625e+02, 5.3568004608154297e+01,
+    1.7693397521972656e+02, 1.1120464478153735e-04, 3, -1,
+    1.6761601257324219e+02, 2.7820803833007812e+02,
+    5.3568004608154297e+01, 1.0057023620605469e+02,
+    3.0778826385358116e-06, 3, -1, 2.6265603637695312e+02,
+    2.7820803833007812e+02, 5.3568004608154297e+01,
+    9.6777503967285156e+01, -2.8214089979883283e-06, 3, -1,
+    3.5769604492187500e+02, 2.7820803833007812e+02,
+    5.3568004608154297e+01, 1.1572864532470703e+02,
+    5.2199597121216357e-05, 3, -1, 1.9180801391601562e+02,
+    2.7993603515625000e+02, 5.3568004608154297e+01,
+    8.9615493774414062e+01, 3.2340135476260912e-06, 3, -1,
+    3.9398403930664062e+02, 2.7993603515625000e+02,
+    5.3568004608154297e+01, 1.2909349060058594e+02,
+    3.6555033148033544e-05, 3, -1, 1.9872001647949219e+02,
+    2.8166403198242188e+02, 5.3568004608154297e+01,
+    9.5650062561035156e+01, 1.8827477106242441e-06, 3, -1,
+    3.6460803222656250e+02, 2.8166403198242188e+02,
+    5.3568004608154297e+01, 1.1757377624511719e+02,
+    2.5353807359351777e-05, 3, -1, 3.7843203735351562e+02,
+    2.8166403198242188e+02, 5.3568004608154297e+01,
+    1.0937550354003906e+02, 7.5734489655587822e-05, 3, -1,
+    3.8534402465820312e+02, 2.8166403198242188e+02,
+    5.3568004608154297e+01, 1.1413365173339844e+02,
+    1.3538620260078460e-04, 3, -1, 3.5251202392578125e+02,
+    2.8339202880859375e+02, 5.3568004608154297e+01,
+    1.1460690307617188e+02, 8.3602732047438622e-05, 3, -1,
+    1.4169601440429688e+02, 2.8512002563476562e+02,
+    5.3568004608154297e+01, 1.0527517700195312e+02,
+    1.4957427083572838e-05, 3, -1, 1.6243202209472656e+02,
+    2.8512002563476562e+02, 5.3568004608154297e+01,
+    1.4712852478027344e+02, 3.9843057493271772e-06, 3, -1,
+    2.1427201843261719e+02, 2.8512002563476562e+02,
+    5.3568004608154297e+01, 9.7819618225097656e+01,
+    4.1084772419708315e-06, 3, -1, 3.1104003906250000e+02,
+    2.8512002563476562e+02, 5.3568004608154297e+01,
+    9.3530761718750000e+01, -8.6747121486041578e-07, 3, -1,
+    3.6115203857421875e+02, 2.8512002563476562e+02,
+    5.3568004608154297e+01, 1.1553450012207031e+02,
+    4.7830060793785378e-05, 3, -1, 3.8880004882812500e+02,
+    2.8512002563476562e+02, 5.3568004608154297e+01,
+    1.0673106384277344e+02, 1.1788063420681283e-04, 3, -1,
+    4.0262402343750000e+02, 2.8512002563476562e+02,
+    5.3568004608154297e+01, 1.0180177307128906e+02,
+    5.4869426094228402e-05, 3, -1, 1.7107202148437500e+02,
+    2.8684802246093750e+02, 5.3568004608154297e+01,
+    2.6107913208007812e+02, 5.4751544666942209e-06, 3, -1,
+    2.3846401977539062e+02, 2.8684802246093750e+02,
+    5.3568004608154297e+01, 9.7738914489746094e+01,
+    2.5290978555858601e-06, 3, -1, 3.1968002319335938e+02,
+    2.8684802246093750e+02, 5.3568004608154297e+01,
+    9.5419471740722656e+01, -8.2044374494216754e-07, 3, -1,
+    3.4214404296875000e+02, 2.8684802246093750e+02,
+    5.3568004608154297e+01, 1.1088015747070312e+02,
+    7.0319410951924510e-06, 3, -1, 4.1644802856445312e+02,
+    2.8684802246093750e+02, 5.3568004608154297e+01,
+    1.2616317749023438e+02, 6.6997636167798191e-05, 3, -1,
+    4.2163204956054688e+02, 2.8684802246093750e+02,
+    5.3568004608154297e+01, 1.4324041748046875e+02,
+    2.7676449462887831e-05, 3, -1, 4.2681604003906250e+02,
+    2.8684802246093750e+02, 5.3568004608154297e+01,
+    1.6073944091796875e+02, 8.6070713223307393e-06, 3, -1,
+    1.2787200927734375e+02, 2.8857601928710938e+02,
+    5.3568004608154297e+01, 3.4325378417968750e+02,
+    2.0495915578067070e-06, 3, -1, 1.5897601318359375e+02,
+    2.8857601928710938e+02, 5.3568004608154297e+01,
+    2.3146531677246094e+02, 2.2941540009924211e-06, 3, -1,
+    2.4537602233886719e+02, 2.8857601928710938e+02,
+    5.3568004608154297e+01, 9.9715629577636719e+01,
+    1.6361811958631733e-06, 3, -1, 3.6979202270507812e+02,
+    2.8857601928710938e+02, 5.3568004608154297e+01,
+    1.0586273956298828e+02, 2.7251770006841980e-05, 3, -1,
+    3.9398403930664062e+02, 2.8857601928710938e+02,
+    5.3568004608154297e+01, 1.0424153137207031e+02,
+    7.7416652857209556e-06, 3, -1, 3.9916802978515625e+02,
+    2.8857601928710938e+02, 5.3568004608154297e+01,
+    1.0142012023925781e+02, 7.8639866842422634e-05, 3, -1,
+    4.0435205078125000e+02, 2.8857601928710938e+02,
+    5.3568004608154297e+01, 9.7642410278320312e+01,
+    1.0189165914198384e-04, 3, -1, 1.4342401123046875e+02,
+    2.9030401611328125e+02, 5.3568004608154297e+01,
+    2.3122476196289062e+02, 1.9292107026558369e-05, 3, -1,
+    4.1990405273437500e+02, 2.9030401611328125e+02,
+    5.3568004608154297e+01, 1.3796194458007812e+02,
+    5.4243108024820685e-05, 3, -1, 4.2336004638671875e+02,
+    2.9030401611328125e+02, 5.3568004608154297e+01,
+    1.4809436035156250e+02, 1.9450597392278723e-05, 3, -1,
+    1.7107202148437500e+02, 2.9203201293945312e+02,
+    5.3568004608154297e+01, 2.6980346679687500e+02,
+    1.1984311277046800e-04, 3, -1, 1.9008001708984375e+02,
+    2.9203201293945312e+02, 5.3568004608154297e+01,
+    3.4146255493164062e+02, -1.6071516029114719e-06, 3, -1,
+    3.7843203735351562e+02, 2.9203201293945312e+02,
+    5.3568004608154297e+01, 1.0035742187500000e+02,
+    2.0644161850214005e-05, 3, -1, 4.1299203491210938e+02,
+    2.9203201293945312e+02, 5.3568004608154297e+01,
+    1.2130967712402344e+02, 1.5622339560650289e-04, 3, -1,
+    2.6092803955078125e+02, 2.9376004028320312e+02,
+    5.3568004608154297e+01, 9.8281776428222656e+01,
+    2.9045377232250758e-06, 3, -1, 3.6806402587890625e+02,
+    2.9376004028320312e+02, 5.3568004608154297e+01,
+    1.0286844635009766e+02, 1.8256649127579294e-05, 3, -1,
+    3.7497604370117188e+02, 2.9376004028320312e+02,
+    5.3568004608154297e+01, 1.0018029785156250e+02,
+    3.6269691918278113e-05, 3, -1, 4.2163204956054688e+02,
+    2.9376004028320312e+02, 5.3568004608154297e+01,
+    1.4441381835937500e+02, 4.0589351556263864e-05, 3, -1,
+    1.2960000610351562e+02, 2.9548803710937500e+02,
+    5.3568004608154297e+01, 3.4627069091796875e+02,
+    2.2823812741989968e-06, 3, -1, 1.7280001831054688e+02,
+    2.9548803710937500e+02, 5.3568004608154297e+01,
+    2.7091473388671875e+02, 1.0073905286844820e-04, 3, -1,
+    1.7798402404785156e+02, 2.9548803710937500e+02,
+    5.3568004608154297e+01, 2.9100967407226562e+02,
+    1.5899626305326819e-04, 3, -1, 2.6956802368164062e+02,
+    2.9548803710937500e+02, 5.3568004608154297e+01,
+    1.0046273803710938e+02, 2.1490941435331479e-06, 3, -1,
+    2.9548803710937500e+02, 2.9548803710937500e+02,
+    5.3568004608154297e+01, 1.0439042663574219e+02,
+    2.0685688468802255e-06, 3, -1, 3.9744003295898438e+02,
+    2.9548803710937500e+02, 5.3568004608154297e+01,
+    1.0095678710937500e+02, 3.5931530874222517e-05, 3, -1,
+    1.6588801574707031e+02, 2.9721603393554688e+02,
+    5.3568004608154297e+01, 2.5676959228515625e+02,
+    7.7829885412938893e-05, 3, -1, 2.1600001525878906e+02,
+    2.9721603393554688e+02, 5.3568004608154297e+01,
+    7.2501487731933594e+01, -1.8092893014909350e-06, 3, -1,
+    4.1644802856445312e+02, 2.9721603393554688e+02,
+    5.3568004608154297e+01, 1.3463427734375000e+02,
+    1.3642043631989509e-04, 3, -1, 3.1276803588867188e+02,
+    2.9894403076171875e+02, 5.3568004608154297e+01,
+    9.6633415222167969e+01, 2.6095187877217541e-06, 3, -1,
+    4.2163204956054688e+02, 2.9894403076171875e+02,
+    5.3568004608154297e+01, 1.4570320129394531e+02,
+    3.0340901503222995e-05, 3, -1, 1.8144001770019531e+02,
+    3.0067202758789062e+02, 5.3568004608154297e+01,
+    2.9662322998046875e+02, 2.1874385129194707e-04, 3, -1,
+    1.4515200805664062e+02, 3.0412802124023438e+02,
+    5.3568004608154297e+01, 1.8464039611816406e+02,
+    1.8189108232036233e-05, 3, -1, 1.7798402404785156e+02,
+    3.0412802124023438e+02, 5.3568004608154297e+01,
+    2.8054147338867188e+02, 1.1275600263616070e-04, 3, -1,
+    1.8489601135253906e+02, 3.0412802124023438e+02,
+    5.3568004608154297e+01, 3.0376190185546875e+02,
+    2.1675965399481356e-04, 3, -1, 2.6265603637695312e+02,
+    3.0412802124023438e+02, 5.3568004608154297e+01,
+    1.0664151763916016e+02, 2.9683778848266229e-06, 3, -1,
+    3.3177603149414062e+02, 3.0412802124023438e+02,
+    5.3568004608154297e+01, 9.5670715332031250e+01,
+    2.3182706172519829e-06, 3, -1, 2.7129602050781250e+02,
+    3.0585601806640625e+02, 5.3568004608154297e+01,
+    1.3218411254882812e+02, 7.0930486799625214e-06, 3, -1,
+    3.4041604614257812e+02, 3.0585601806640625e+02,
+    5.3568004608154297e+01, 9.8505096435546875e+01,
+    2.7672010673995828e-06, 3, -1, 3.5769604492187500e+02,
+    3.0585601806640625e+02, 5.3568004608154297e+01,
+    9.8565650939941406e+01, 2.6990037440555170e-06, 3, -1,
+    4.2854403686523438e+02, 3.0585601806640625e+02,
+    5.3568004608154297e+01, 1.5789941406250000e+02,
+    4.1283547034254298e-05, 3, -1, 1.2960000610351562e+02,
+    3.0758401489257812e+02, 5.3568004608154297e+01,
+    3.4483840942382812e+02, 4.4987605178903323e-06, 3, -1,
+    1.7107202148437500e+02, 3.0758401489257812e+02,
+    5.3568004608154297e+01, 2.4536405944824219e+02,
+    2.0122826754231937e-05, 3, -1, 1.7971202087402344e+02,
+    3.0758401489257812e+02, 5.3568004608154297e+01,
+    2.8511157226562500e+02, 7.9050863860175014e-05, 3, -1,
+    2.8166403198242188e+02, 3.0758401489257812e+02,
+    5.3568004608154297e+01, 1.4552711486816406e+02,
+    7.1350614234688692e-06, 3, -1, 2.9203201293945312e+02,
+    3.0758401489257812e+02, 5.3568004608154297e+01,
+    1.6409466552734375e+02, 8.8662973212194629e-06, 3, -1,
+    3.6633602905273438e+02, 3.0758401489257812e+02,
+    5.3568004608154297e+01, 1.0121700286865234e+02,
+    1.7723059499985538e-06, 3, -1, 3.8361602783203125e+02,
+    3.0931204223632812e+02, 5.3568004608154297e+01,
+    9.9872932434082031e+01, 3.6059136618860066e-06, 3, -1,
+    4.2336004638671875e+02, 3.0931204223632812e+02,
+    5.3568004608154297e+01, 1.5143667602539062e+02,
+    1.2582418275997043e-04, 3, -1, 3.1104003906250000e+02,
+    3.1104003906250000e+02, 5.3568004608154297e+01,
+    9.0387420654296875e+01, 4.5715883061347995e-06, 3, -1,
+    1.8835202026367188e+02, 3.1276803588867188e+02,
+    5.3568004608154297e+01, 3.1072830200195312e+02,
+    7.5741001637652516e-05, 3, -1, 1.9180801391601562e+02,
+    3.1276803588867188e+02, 5.3568004608154297e+01,
+    3.1025765991210938e+02, 8.6995911260601133e-05, 3, -1,
+    2.0563201904296875e+02, 3.1276803588867188e+02,
+    5.3568004608154297e+01, 2.9131417846679688e+02,
+    5.2164545195410028e-05, 3, -1, 3.8361602783203125e+02,
+    3.1276803588867188e+02, 5.3568004608154297e+01,
+    1.0394853210449219e+02, 3.5807918266073102e-06, 3, -1,
+    1.3305601501464844e+02, 3.1449603271484375e+02,
+    5.3568004608154297e+01, 3.3600942993164062e+02,
+    1.4091240245761583e-06, 3, -1, 1.6934400939941406e+02,
+    3.1449603271484375e+02, 5.3568004608154297e+01,
+    1.8427612304687500e+02, 1.3038065844739322e-05, 3, -1,
+    1.9872001647949219e+02, 3.1449603271484375e+02,
+    5.3568004608154297e+01, 3.0230114746093750e+02,
+    -8.3352897490840405e-06, 3, -1, 2.9376004028320312e+02,
+    3.1449603271484375e+02, 5.3568004608154297e+01,
+    2.2825076293945312e+02, 7.1362090238835663e-05, 3, -1,
+    3.0931204223632812e+02, 3.1449603271484375e+02,
+    5.3568004608154297e+01, 3.0594705200195312e+02,
+    1.6274492736556567e-05, 3, -1, 3.9225604248046875e+02,
+    3.1449603271484375e+02, 5.3568004608154297e+01,
+    1.0720132446289062e+02, 3.1627298540115589e-06, 3, -1,
+    4.1299203491210938e+02, 3.1449603271484375e+02,
+    5.3568004608154297e+01, 1.3853942871093750e+02,
+    8.2498891060822643e-06, 3, -1, 1.4860801696777344e+02,
+    3.1622402954101562e+02, 5.3568004608154297e+01,
+    1.9371891784667969e+02, 1.1152055776619818e-05, 3, -1,
+    1.7280001831054688e+02, 3.1622402954101562e+02,
+    5.3568004608154297e+01, 1.8352986145019531e+02,
+    1.4151048162602820e-05, 3, -1, 2.0390402221679688e+02,
+    3.1622402954101562e+02, 5.3568004608154297e+01,
+    2.9307678222656250e+02, 7.3738701757974923e-05, 3, -1,
+    2.1081602478027344e+02, 3.1622402954101562e+02,
+    5.3568004608154297e+01, 2.8517337036132812e+02,
+    1.1644574988167733e-04, 3, -1, 2.2464001464843750e+02,
+    3.1795202636718750e+02, 5.3568004608154297e+01,
+    2.8770727539062500e+02, 2.2914102009963244e-04, 3, -1,
+    2.9376004028320312e+02, 3.1795202636718750e+02,
+    5.3568004608154297e+01, 2.1589729309082031e+02,
+    9.9163640697952360e-05, 3, -1, 3.4732803344726562e+02,
+    3.1795202636718750e+02, 5.3568004608154297e+01,
+    7.7822898864746094e+01, 5.2478048928605858e-06, 3, -1,
+    4.1472003173828125e+02, 3.1795202636718750e+02,
+    5.3568004608154297e+01, 1.4988648986816406e+02,
+    1.9137758499709889e-05, 3, -1, 4.1817602539062500e+02,
+    3.1795202636718750e+02, 5.3568004608154297e+01,
+    1.5448841857910156e+02, 2.0410685465321876e-05, 3, -1,
+    1.7280001831054688e+02, 3.1968002319335938e+02,
+    5.3568004608154297e+01, 1.6094648742675781e+02,
+    1.5365263607236557e-05, 3, -1, 1.8144001770019531e+02,
+    3.1968002319335938e+02, 5.3568004608154297e+01,
+    2.2394880676269531e+02, 6.6698553382593673e-06, 3, -1,
+    1.9008001708984375e+02, 3.1968002319335938e+02,
+    5.3568004608154297e+01, 3.1581710815429688e+02,
+    1.2448449524526950e-05, 3, -1, 3.1968002319335938e+02,
+    3.1968002319335938e+02, 5.3568004608154297e+01,
+    3.3423132324218750e+02, 2.5390794689883478e-05, 3, -1,
+    3.2486404418945312e+02, 3.1968002319335938e+02,
+    5.3568004608154297e+01, 3.5097222900390625e+02,
+    1.7494518033345230e-05, 3, -1, 2.1081602478027344e+02,
+    3.2140802001953125e+02, 5.3568004608154297e+01,
+    2.8323651123046875e+02, 1.1950221960432827e-04, 3, -1,
+    2.1945602416992188e+02, 3.2140802001953125e+02,
+    5.3568004608154297e+01, 2.8323822021484375e+02,
+    1.6284502635244280e-04, 3, -1, 2.2982402038574219e+02,
+    3.2140802001953125e+02, 5.3568004608154297e+01,
+    2.9241290283203125e+02, 1.9191313185729086e-04, 3, -1,
+    2.8857601928710938e+02, 3.2140802001953125e+02,
+    5.3568004608154297e+01, 2.1442846679687500e+02,
+    1.4198780991137028e-04, 3, -1, 3.6806402587890625e+02,
+    3.2140802001953125e+02, 5.3568004608154297e+01,
+    1.3231539916992188e+02, 2.7594392122409772e-06, 3, -1,
+    4.1472003173828125e+02, 3.2140802001953125e+02,
+    5.3568004608154297e+01, 1.5670433044433594e+02,
+    9.6759695225046016e-06, 3, -1, 4.1817602539062500e+02,
+    3.2140802001953125e+02, 5.3568004608154297e+01,
+    1.6043757629394531e+02, 8.8654469436733052e-06, 3, -1,
+    1.5033601379394531e+02, 3.2313601684570312e+02,
+    5.3568004608154297e+01, 2.3676742553710938e+02,
+    8.4891808000975288e-06, 3, -1, 2.7993603515625000e+02,
+    3.2313601684570312e+02, 5.3568004608154297e+01,
+    2.4910861206054688e+02, 6.1071477830410004e-05, 3, -1,
+    2.9548803710937500e+02, 3.2313601684570312e+02,
+    5.3568004608154297e+01, 2.1572875976562500e+02,
+    9.0913163148798048e-05, 3, -1, 3.0412802124023438e+02,
+    3.2313601684570312e+02, 5.3568004608154297e+01,
+    2.7453051757812500e+02, 4.5761575165670365e-05, 3, -1,
+    3.8016003417968750e+02, 3.2313601684570312e+02,
+    5.3568004608154297e+01, 1.5690318298339844e+02,
+    9.6157637017313391e-06, 3, -1, 1.7107202148437500e+02,
+    3.2486404418945312e+02, 5.3568004608154297e+01,
+    1.4879637145996094e+02, 5.1991744840051979e-05, 3, -1,
+    1.9008001708984375e+02, 3.2486404418945312e+02,
+    5.3568004608154297e+01, 3.5216046142578125e+02,
+    1.6935600797296502e-05, 3, -1, 3.1622402954101562e+02,
+    3.2486404418945312e+02, 5.3568004608154297e+01,
+    1.1281450271606445e+01, 4.8529884224990383e-05, 3, -1,
+    1.3651200866699219e+02, 3.2659204101562500e+02,
+    5.3568004608154297e+01, 3.1421618652343750e+02,
+    3.4316751680307789e-06, 3, -1, 1.7452801513671875e+02,
+    3.2659204101562500e+02, 5.3568004608154297e+01,
+    1.4286294555664062e+02, 5.4983589507173747e-05, 3, -1,
+    2.4883203125000000e+02, 3.2659204101562500e+02,
+    5.3568004608154297e+01, 2.9420599365234375e+02,
+    1.3447360834106803e-04, 3, -1, 2.7129602050781250e+02,
+    3.2659204101562500e+02, 5.3568004608154297e+01,
+    2.7328509521484375e+02, 1.2650642020162195e-04, 3, -1,
+    2.9376004028320312e+02, 3.2659204101562500e+02,
+    5.3568004608154297e+01, 2.4837802124023438e+02,
+    2.0505573775153607e-04, 3, -1, 3.7324804687500000e+02,
+    3.2659204101562500e+02, 5.3568004608154297e+01,
+    1.7455935668945312e+02, 4.6081127948127687e-05, 3, -1,
+    2.0390402221679688e+02, 3.2832003784179688e+02,
+    5.3568004608154297e+01, 2.8663079833984375e+02,
+    9.0666224423330277e-05, 3, -1, 2.3328002929687500e+02,
+    3.2832003784179688e+02, 5.3568004608154297e+01,
+    2.9755596923828125e+02, 4.8282719944836572e-05, 3, -1,
+    2.3673602294921875e+02, 3.2832003784179688e+02,
+    5.3568004608154297e+01, 2.9666470336914062e+02,
+    5.3021249186713248e-05, 3, -1, 2.4364802551269531e+02,
+    3.2832003784179688e+02, 5.3568004608154297e+01,
+    2.9634860229492188e+02, 6.6609631176106632e-05, 3, -1,
+    2.5401602172851562e+02, 3.2832003784179688e+02,
+    5.3568004608154297e+01, 2.9338156127929688e+02,
+    7.9797944636084139e-05, 3, -1, 2.8166403198242188e+02,
+    3.2832003784179688e+02, 5.3568004608154297e+01,
+    2.6085455322265625e+02, 8.6430671217385679e-05, 3, -1,
+    2.8684802246093750e+02, 3.2832003784179688e+02,
+    5.3568004608154297e+01, 2.5295251464843750e+02,
+    1.9486801465973258e-04, 3, -1, 3.0067202758789062e+02,
+    3.2832003784179688e+02, 5.3568004608154297e+01,
+    2.5388183593750000e+02, 8.6245687271002680e-05, 3, -1,
+    3.1104003906250000e+02, 3.2832003784179688e+02,
+    5.3568004608154297e+01, 3.5059387207031250e+02,
+    5.4465708672069013e-05, 3, -1, 3.3350402832031250e+02,
+    3.2832003784179688e+02, 5.3568004608154297e+01,
+    3.5976132202148438e+02, 3.5243208458268782e-06, 3, -1,
+    3.9916802978515625e+02, 3.2832003784179688e+02,
+    5.3568004608154297e+01, 2.2536566162109375e+02,
+    3.2206477044383064e-05, 3, -1, 1.3651200866699219e+02,
+    3.3004803466796875e+02, 5.3568004608154297e+01,
+    3.1084411621093750e+02, 1.3843809938407503e-05, 3, -1,
+    2.4019201660156250e+02, 3.3004803466796875e+02,
+    5.3568004608154297e+01, 2.9730627441406250e+02,
+    6.0625021433224902e-05, 3, -1, 2.5747201538085938e+02,
+    3.3004803466796875e+02, 5.3568004608154297e+01,
+    2.9106304931640625e+02, 9.7686679509934038e-05, 3, -1,
+    3.2486404418945312e+02, 3.3004803466796875e+02,
+    5.3568004608154297e+01, 2.1910999715328217e-01,
+    9.0125004135188647e-06, 3, -1, 2.0217602539062500e+02,
+    3.3177603149414062e+02, 5.3568004608154297e+01,
+    1.0205895233154297e+02, 8.0246951256413013e-05, 3, -1,
+    2.0563201904296875e+02, 3.3177603149414062e+02,
+    5.3568004608154297e+01, 2.0704264831542969e+02,
+    8.3446037024259567e-05, 3, -1, 2.3673602294921875e+02,
+    3.3177603149414062e+02, 5.3568004608154297e+01,
+    2.9835998535156250e+02, 1.7544685761095025e-05, 3, -1,
+    2.7475201416015625e+02, 3.3177603149414062e+02,
+    5.3568004608154297e+01, 2.7863366699218750e+02,
+    8.3382386947050691e-05, 3, -1, 2.9376004028320312e+02,
+    3.3177603149414062e+02, 5.3568004608154297e+01,
+    2.7652038574218750e+02, 2.5290658231824636e-04, 3, -1,
+    3.1795202636718750e+02, 3.3177603149414062e+02,
+    5.3568004608154297e+01, 3.5307992553710938e+02,
+    2.1283514797687531e-05, 3, -1, 2.1772802734375000e+02,
+    3.3350402832031250e+02, 5.3568004608154297e+01,
+    2.4640295410156250e+02, 6.1297832871787250e-05, 3, -1,
+    2.5228802490234375e+02, 3.3350402832031250e+02,
+    5.3568004608154297e+01, 2.9942425537109375e+02,
+    1.1030221503460780e-04, 3, -1, 2.5920001220703125e+02,
+    3.3350402832031250e+02, 5.3568004608154297e+01,
+    2.9348831176757812e+02, 1.6030717233661562e-04, 3, -1,
+    2.2118402099609375e+02, 3.3523202514648438e+02,
+    5.3568004608154297e+01, 2.6858160400390625e+02,
+    6.2943334341980517e-05, 3, -1, 2.5574401855468750e+02,
+    3.3523202514648438e+02, 5.3568004608154297e+01,
+    2.9645764160156250e+02, 1.0749903594842181e-04, 3, -1,
+    2.6784002685546875e+02, 3.3523202514648438e+02,
+    5.3568004608154297e+01, 2.8458877563476562e+02,
+    1.6375166887883097e-04, 3, -1, 2.9894403076171875e+02,
+    3.3523202514648438e+02, 5.3568004608154297e+01,
+    3.1433767700195312e+02, 2.1151198598090559e-04, 3, -1,
+    3.7324804687500000e+02, 3.3523202514648438e+02,
+    5.3568004608154297e+01, 2.0814848327636719e+02,
+    4.1250310459872708e-05, 3, -1, 4.1472003173828125e+02,
+    3.3523202514648438e+02, 5.3568004608154297e+01,
+    1.8364193725585938e+02, 3.6788853776670294e-06, 3, -1,
+    4.1817602539062500e+02, 3.3523202514648438e+02,
+    5.3568004608154297e+01, 1.8028526306152344e+02,
+    4.3201439439144451e-06, 3, -1, 2.2982402038574219e+02,
+    3.3696002197265625e+02, 5.3568004608154297e+01,
+    3.1599877929687500e+02, 1.7383797967340797e-05, 3, -1,
+    2.3846401977539062e+02, 3.3696002197265625e+02,
+    5.3568004608154297e+01, 3.0228576660156250e+02,
+    2.0793011572095565e-05, 3, -1, 3.0412802124023438e+02,
+    3.3696002197265625e+02, 5.3568004608154297e+01,
+    1.4055688858032227e+01, 6.6052773036062717e-05, 3, -1,
+    3.1968002319335938e+02, 3.3696002197265625e+02,
+    5.3568004608154297e+01, 3.4566128540039062e+02,
+    3.2000738428905606e-05, 3, -1, 2.6092803955078125e+02,
+    3.3868801879882812e+02, 5.3568004608154297e+01,
+    2.9752401733398438e+02, 1.2123730266466737e-04, 3, -1,
+    2.7993603515625000e+02, 3.3868801879882812e+02,
+    5.3568004608154297e+01, 3.0094317626953125e+02,
+    5.4051524784881622e-05, 3, -1, 3.2659204101562500e+02,
+    3.3868801879882812e+02, 5.3568004608154297e+01,
+    3.0673431396484375e+02, 3.0526960472343490e-05, 3, -1,
+    3.4387203979492188e+02, 3.3868801879882812e+02,
+    5.3568004608154297e+01, 3.0584710693359375e+02,
+    2.0629136088246014e-06, 3, -1, 3.9916802978515625e+02,
+    3.3868801879882812e+02, 5.3568004608154297e+01,
+    2.4967219543457031e+02, 4.0279290260514244e-05, 3, -1,
+    1.8662402343750000e+02, 3.4041604614257812e+02,
+    5.3568004608154297e+01, 9.7498840332031250e+01,
+    2.1364423901104601e-06, 3, -1, 2.5401602172851562e+02,
+    3.4041604614257812e+02, 5.3568004608154297e+01,
+    2.9938717651367188e+02, 3.5824046790366992e-05, 3, -1,
+    2.6956802368164062e+02, 3.4041604614257812e+02,
+    5.3568004608154297e+01, 2.9371215820312500e+02,
+    1.9870198229909874e-05, 3, -1, 2.9376004028320312e+02,
+    3.4041604614257812e+02, 5.3568004608154297e+01,
+    3.4418417358398438e+02, 9.6421732450835407e-05, 3, -1,
+    3.3868801879882812e+02, 3.4041604614257812e+02,
+    5.3568004608154297e+01, 3.0258123779296875e+02,
+    1.3195932297094259e-05, 3, -1, 2.7993603515625000e+02,
+    3.4214404296875000e+02, 5.3568004608154297e+01,
+    3.1087521362304688e+02, 6.1607912357430905e-05, 3, -1,
+    4.1817602539062500e+02, 3.4214404296875000e+02,
+    5.3568004608154297e+01, 1.7920736694335938e+02,
+    4.3655472836690024e-06, 3, -1, 2.0044801330566406e+02,
+    3.4387203979492188e+02, 5.3568004608154297e+01,
+    9.9576416015625000e+01, 1.6873156027941150e-06, 3, -1,
+    2.8339202880859375e+02, 3.4387203979492188e+02,
+    5.3568004608154297e+01, 3.2017965698242188e+02,
+    6.7516833951231092e-05, 3, -1, 3.1449603271484375e+02,
+    3.4560003662109375e+02, 5.3568004608154297e+01,
+    3.3211361694335938e+02, 5.5155716836452484e-05, 3, -1,
+    3.3004803466796875e+02, 3.4560003662109375e+02,
+    5.3568004608154297e+01, 2.7421798706054688e+02,
+    3.3569205697858706e-05, 3, -1, 3.0067202758789062e+02,
+    3.4732803344726562e+02, 5.3568004608154297e+01,
+    3.1562640380859375e+02, 8.0339405030827038e-06, 3, -1,
+    3.4732803344726562e+02, 3.4732803344726562e+02,
+    5.3568004608154297e+01, 2.9282244873046875e+02,
+    6.3441825659538154e-07, 3, -1, 4.0089602661132812e+02,
+    3.4732803344726562e+02, 5.3568004608154297e+01,
+    2.5927932739257812e+02, 3.2591364288236946e-05, 3, -1,
+    3.1622402954101562e+02, 3.4905603027343750e+02,
+    5.3568004608154297e+01, 2.7657614135742188e+02,
+    6.9431640440598130e-05, 3, -1, 3.4041604614257812e+02,
+    3.4905603027343750e+02, 5.3568004608154297e+01,
+    2.8982781982421875e+02, 4.8613132094033062e-05, 3, -1,
+    3.6633602905273438e+02, 3.4905603027343750e+02,
+    5.3568004608154297e+01, 2.5829598999023438e+02,
+    8.3306431406526826e-06, 3, -1, 3.7324804687500000e+02,
+    3.4905603027343750e+02, 5.3568004608154297e+01,
+    2.5365370178222656e+02, 8.0274330684915185e-06, 3, -1,
+    2.4364802551269531e+02, 3.5078402709960938e+02,
+    5.3568004608154297e+01, 1.0133866882324219e+02,
+    2.1607261260214727e-06, 3, -1, 2.9376004028320312e+02,
+    3.5078402709960938e+02, 5.3568004608154297e+01,
+    3.1148358154296875e+02, 5.6463936743966769e-06, 3, -1,
+    3.6288003540039062e+02, 3.5078402709960938e+02,
+    5.3568004608154297e+01, 2.5993090820312500e+02,
+    1.0988844223902561e-05, 3, -1, 3.4905603027343750e+02,
+    3.5251202392578125e+02, 5.3568004608154297e+01,
+    2.8424636840820312e+02, 2.9286916287674103e-06, 3, -1,
+    3.5596804809570312e+02, 3.5251202392578125e+02,
+    5.3568004608154297e+01, 2.6898907470703125e+02,
+    9.5892091849236749e-06, 3, -1, 3.8016003417968750e+02,
+    3.5251202392578125e+02, 5.3568004608154297e+01,
+    2.3177320861816406e+02, 6.0264756029937416e-06, 3, -1,
+    3.1449603271484375e+02, 3.5424002075195312e+02,
+    5.3568004608154297e+01, 2.6835705566406250e+02,
+    1.1244516826991457e-05, 3, -1, 3.5078402709960938e+02,
+    3.5596804809570312e+02, 5.3568004608154297e+01,
+    2.7797375488281250e+02, 1.5993491615517996e-05, 3, -1,
+    3.4041604614257812e+02, 3.5769604492187500e+02,
+    5.3568004608154297e+01, 2.8322003173828125e+02,
+    7.5604311859933659e-06, 3, -1, 3.6115203857421875e+02,
+    3.5769604492187500e+02, 5.3568004608154297e+01,
+    2.6892517089843750e+02, 1.1748271390388254e-05, 3, -1,
+    4.0089602661132812e+02, 3.5769604492187500e+02,
+    5.3568004608154297e+01, 2.6534304809570312e+02,
+    4.1165192669723183e-05, 3, -1, 4.1644802856445312e+02,
+    3.5769604492187500e+02, 5.3568004608154297e+01,
+    1.7967756652832031e+02, 4.5124279495212249e-06, 3, -1,
+    2.9030401611328125e+02, 3.5942404174804688e+02,
+    5.3568004608154297e+01, 2.9295843505859375e+02,
+    1.6198118828469887e-06, 3, -1, 3.5078402709960938e+02,
+    3.5942404174804688e+02, 5.3568004608154297e+01,
+    2.7615771484375000e+02, 1.5566687579848804e-05, 3, -1,
+    4.1990405273437500e+02, 3.5942404174804688e+02,
+    5.3568004608154297e+01, 1.8151318359375000e+02,
+    3.5953512451669667e-06, 3, -1, 2.9894403076171875e+02,
+    3.6115203857421875e+02, 5.3568004608154297e+01,
+    2.8532952880859375e+02, 2.6489749416214181e-06, 3, -1,
+    3.8188803100585938e+02, 3.6115203857421875e+02,
+    5.3568004608154297e+01, 2.6581982421875000e+02,
+    1.0780856428027619e-05, 3, -1, 3.8361602783203125e+02,
+    3.6460803222656250e+02, 5.3568004608154297e+01,
+    2.7259494018554688e+02, 9.9197222880320624e-06, 3, -1,
+    3.2832003784179688e+02, 3.6633602905273438e+02,
+    5.3568004608154297e+01, 2.7194683837890625e+02,
+    1.6909551732169348e-06, 3, -1, 3.7843203735351562e+02,
+    3.6633602905273438e+02, 5.3568004608154297e+01,
+    2.7217385864257812e+02, 1.0694233424146660e-05, 3, -1,
+    4.0262402343750000e+02, 3.6633602905273438e+02,
+    5.3568004608154297e+01, 2.6856478881835938e+02,
+    2.4937535272329114e-05, 3, -1, 3.3868801879882812e+02,
+    3.6806402587890625e+02, 5.3568004608154297e+01,
+    2.7568344116210938e+02, 1.8210225789516699e-06, 3, -1,
+    3.4560003662109375e+02, 3.6979202270507812e+02,
+    5.3568004608154297e+01, 2.7708325195312500e+02,
+    4.0262275433633476e-06, 3, -1, 3.7152005004882812e+02,
+    3.7152005004882812e+02, 5.3568004608154297e+01,
+    2.7844332885742188e+02, 8.8773467723513022e-06, 3, -1,
+    3.6288003540039062e+02, 3.7324804687500000e+02,
+    5.3568004608154297e+01, 2.7602954101562500e+02,
+    6.1836631175538059e-06, 3, -1, 3.8707202148437500e+02,
+    3.7497604370117188e+02, 5.3568004608154297e+01,
+    2.7699737548828125e+02, 4.7853254727669992e-06, 3, -1,
+    4.1990405273437500e+02, 3.7497604370117188e+02,
+    5.3568004608154297e+01, 2.0030892944335938e+02,
+    4.5081364987709094e-06, 3, -1, 4.1299203491210938e+02,
+    3.7670404052734375e+02, 5.3568004608154297e+01,
+    2.3114009094238281e+02, 5.4719648687751032e-06, 3, -1,
+    4.2163204956054688e+02, 3.7843203735351562e+02,
+    5.3568004608154297e+01, 1.9834797668457031e+02,
+    2.5643736080382951e-05, 3, -1, 4.2508804321289062e+02,
+    3.8361602783203125e+02, 5.3568004608154297e+01,
+    1.9244049072265625e+02, 9.0701549197547138e-05, 3, -1,
+    4.3027203369140625e+02, 3.8534402465820312e+02,
+    5.3568004608154297e+01, 1.7856018066406250e+02,
+    9.7358373750466853e-05, 3, -1, 2.1358082580566406e+02,
+    1.3685762023925781e+02, 6.4281608581542969e+01,
+    1.9866731262207031e+02, 5.3252755606081337e-05, 4, -1,
+    2.2809603881835938e+02, 1.3893121337890625e+02,
+    6.4281608581542969e+01, 1.7213641357421875e+02,
+    1.3192633559810929e-05, 4, -1, 2.4468482971191406e+02,
+    1.4100482177734375e+02, 6.4281608581542969e+01,
+    6.8325271606445312e+01, 1.0940289939753711e-05, 4, -1,
+    2.5505284118652344e+02, 1.4100482177734375e+02,
+    6.4281608581542969e+01, 7.4230453491210938e+01,
+    1.9256119685451267e-06, 4, -1, 2.2394883728027344e+02,
+    1.4307841491699219e+02, 6.4281608581542969e+01,
+    1.7386457824707031e+02, 2.2278749383985996e-05, 4, -1,
+    2.3431683349609375e+02, 1.4515202331542969e+02,
+    6.4281608581542969e+01, 7.7831352233886719e+01,
+    1.5312241885112599e-05, 4, -1, 2.6542083740234375e+02,
+    1.4515202331542969e+02, 6.4281608581542969e+01,
+    8.4003944396972656e+01, 5.2109912758169230e-06, 4, -1,
+    2.0528642272949219e+02, 1.4722561645507812e+02,
+    6.4281608581542969e+01, 1.6293807983398438e+02,
+    1.3537483027903363e-05, 4, -1, 2.3224322509765625e+02,
+    1.4929922485351562e+02, 6.4281608581542969e+01,
+    6.1752105712890625e+01, 2.8315118470345624e-05, 4, -1,
+    2.3846403503417969e+02, 1.4929922485351562e+02,
+    6.4281608581542969e+01, 6.1863319396972656e+01,
+    2.9418850317597389e-05, 4, -1, 2.4468482971191406e+02,
+    1.4929922485351562e+02, 6.4281608581542969e+01,
+    6.6640899658203125e+01, 2.6496963982935995e-05, 4, -1,
+    2.6542083740234375e+02, 1.4929922485351562e+02,
+    6.4281608581542969e+01, 8.3700248718261719e+01,
+    3.6913609164912486e-06, 4, -1, 2.7578884887695312e+02,
+    1.5137281799316406e+02, 6.4281608581542969e+01,
+    9.2442779541015625e+01, 3.2769671634014230e-06, 4, -1,
+    2.3431683349609375e+02, 1.5344642639160156e+02,
+    6.4281608581542969e+01, 5.1822944641113281e+01,
+    3.7190402508713305e-05, 4, -1, 2.9030404663085938e+02,
+    1.5344642639160156e+02, 6.4281608581542969e+01,
+    9.9053939819335938e+01, 3.5774014577327762e-06, 4, -1,
+    3.1104003906250000e+02, 1.5552001953125000e+02,
+    6.4281608581542969e+01, 1.0494914245605469e+02,
+    7.2454486144124530e-06, 4, -1, 2.0113922119140625e+02,
+    1.5759362792968750e+02, 6.4281608581542969e+01,
+    1.5670195007324219e+02, 3.2380405173171312e-05, 4, -1,
+    2.1565443420410156e+02, 1.5759362792968750e+02,
+    6.4281608581542969e+01, 1.8109439086914062e+02,
+    2.5282688511651941e-05, 4, -1, 2.2394883728027344e+02,
+    1.5759362792968750e+02, 6.4281608581542969e+01,
+    4.8336708068847656e+01, 2.1130957975401543e-05, 4, -1,
+    3.3799685668945312e+02, 1.5759362792968750e+02,
+    6.4281608581542969e+01, 9.7129814147949219e+01,
+    3.6989849832025357e-06, 4, -1, 3.5043844604492188e+02,
+    1.5966722106933594e+02, 6.4281608581542969e+01,
+    9.7363815307617188e+01, 6.2181698012864217e-06, 4, -1,
+    3.6910086059570312e+02, 1.6174082946777344e+02,
+    6.4281608581542969e+01, 1.1494815826416016e+02,
+    3.4862873690144625e-06, 4, -1, 4.2716165161132812e+02,
+    1.6174082946777344e+02, 6.4281608581542969e+01,
+    1.2612386322021484e+02, 4.9205491450265981e-06, 4, -1,
+    1.9284483337402344e+02, 1.6381442260742188e+02,
+    6.4281608581542969e+01, 1.4840370178222656e+02,
+    2.4575607312726788e-05, 4, -1, 4.1057284545898438e+02,
+    1.6381442260742188e+02, 6.4281608581542969e+01,
+    1.2710249328613281e+02, 6.6991019593842793e-06, 4, -1,
+    4.3752966308593750e+02, 1.6381442260742188e+02,
+    6.4281608581542969e+01, 1.1976071929931641e+02,
+    2.0383882656460628e-05, 4, -1, 2.0528642272949219e+02,
+    1.6588803100585938e+02, 6.4281608581542969e+01,
+    1.8715213012695312e+02, 3.4030912502203137e-05, 4, -1,
+    3.9398406982421875e+02, 1.6588803100585938e+02,
+    6.4281608581542969e+01, 1.3058854675292969e+02,
+    1.1747880307666492e-05, 4, -1, 4.5411846923828125e+02,
+    1.6588803100585938e+02, 6.4281608581542969e+01,
+    1.2748911285400391e+02, 1.2847218386013992e-05, 4, -1,
+    1.9906562805175781e+02, 1.6796162414550781e+02,
+    6.4281608581542969e+01, 1.8608496093750000e+02,
+    2.1248468328849413e-05, 4, -1, 2.4261123657226562e+02,
+    1.7003521728515625e+02, 6.4281608581542969e+01,
+    3.7019020080566406e+01, 1.9955012248829007e-05, 4, -1,
+    4.2716165161132812e+02, 1.7003521728515625e+02,
+    6.4281608581542969e+01, 1.2586112976074219e+02,
+    1.7145297533716075e-05, 4, -1, 4.3960327148437500e+02,
+    1.7003521728515625e+02, 6.4281608581542969e+01,
+    1.4051312255859375e+02, 2.3427111955243163e-05, 4, -1,
+    4.7070727539062500e+02, 1.7003521728515625e+02,
+    6.4281608581542969e+01, 1.8837825012207031e+02,
+    3.8873797166161239e-05, 4, -1, 3.4836483764648438e+02,
+    1.7210882568359375e+02, 6.4281608581542969e+01,
+    9.2669792175292969e+01, 1.2195932868053205e-06, 4, -1,
+    4.3545605468750000e+02, 1.7210882568359375e+02,
+    6.4281608581542969e+01, 1.3835350036621094e+02,
+    3.2496092899236828e-05, 4, -1, 4.5411846923828125e+02,
+    1.7210882568359375e+02, 6.4281608581542969e+01,
+    1.6149755859375000e+02, 8.8913666331791319e-06, 4, -1,
+    2.3431683349609375e+02, 1.7418241882324219e+02,
+    6.4281608581542969e+01, 2.3871837615966797e+01,
+    4.2193776607746258e-05, 4, -1, 2.9859844970703125e+02,
+    1.7418241882324219e+02, 6.4281608581542969e+01,
+    2.1113269042968750e+02, 1.2232378139742650e-05, 4, -1,
+    3.6910086059570312e+02, 1.7418241882324219e+02,
+    6.4281608581542969e+01, 1.3423040771484375e+02,
+    8.9264876805827953e-06, 4, -1, 4.3130886840820312e+02,
+    1.7625602722167969e+02, 6.4281608581542969e+01,
+    1.3708110046386719e+02, 4.0233586332760751e-05, 4, -1,
+    2.3639042663574219e+02, 1.7832962036132812e+02,
+    6.4281608581542969e+01, 2.4343105316162109e+01,
+    4.7214965888997540e-05, 4, -1, 1.7832962036132812e+02,
+    1.8040322875976562e+02, 6.4281608581542969e+01,
+    1.1403530120849609e+02, 1.5111261745914817e-05, 4, -1,
+    1.8455043029785156e+02, 1.8040322875976562e+02,
+    6.4281608581542969e+01, 1.6620741271972656e+02,
+    2.6093064661836252e-05, 4, -1, 3.7739526367187500e+02,
+    1.8040322875976562e+02, 6.4281608581542969e+01,
+    1.5250906372070312e+02, 6.4821098931133747e-05, 4, -1,
+    3.8361605834960938e+02, 1.8040322875976562e+02,
+    6.4281608581542969e+01, 1.5385903930664062e+02,
+    2.3836806576582603e-05, 4, -1, 3.8983685302734375e+02,
+    1.8040322875976562e+02, 6.4281608581542969e+01,
+    1.5273611450195312e+02, 1.2958052138856146e-05, 4, -1,
+    2.8200964355468750e+02, 1.8247682189941406e+02,
+    6.4281608581542969e+01, 2.2623693847656250e+02,
+    5.0132508476963267e-05, 4, -1, 3.3384963989257812e+02,
+    1.8247682189941406e+02, 6.4281608581542969e+01,
+    5.2651493072509766e+01, 9.1833107944694348e-06, 4, -1,
+    3.7117443847656250e+02, 1.8247682189941406e+02,
+    6.4281608581542969e+01, 1.4711257934570312e+02,
+    1.1461293615866452e-04, 4, -1, 3.9605764770507812e+02,
+    1.8247682189941406e+02, 6.4281608581542969e+01,
+    1.5074400329589844e+02, 7.4061845225514844e-06, 4, -1,
+    2.1565443420410156e+02, 1.8455043029785156e+02,
+    6.4281608581542969e+01, 4.4381065368652344e+01,
+    1.4486660802504048e-05, 4, -1, 2.6749444580078125e+02,
+    1.8455043029785156e+02, 6.4281608581542969e+01,
+    2.1395086669921875e+02, 3.6128127248957753e-05, 4, -1,
+    2.9652484130859375e+02, 1.8455043029785156e+02,
+    6.4281608581542969e+01, 2.5376632690429688e+02,
+    7.2240589361172169e-05, 4, -1, 4.3752966308593750e+02,
+    1.8455043029785156e+02, 6.4281608581542969e+01,
+    1.4716894531250000e+02, 2.7657310056383722e-05, 4, -1,
+    4.4582406616210938e+02, 1.8455043029785156e+02,
+    6.4281608581542969e+01, 1.5884988403320312e+02,
+    2.4324102923856117e-05, 4, -1, 4.5411846923828125e+02,
+    1.8455043029785156e+02, 6.4281608581542969e+01,
+    1.8130027770996094e+02, 1.3821876564179547e-05, 4, -1,
+    2.3846403503417969e+02, 1.8662402343750000e+02,
+    6.4281608581542969e+01, 1.4753758430480957e+01,
+    5.4727606766391546e-05, 4, -1, 2.5712643432617188e+02,
+    1.8662402343750000e+02, 6.4281608581542969e+01,
+    3.1502249145507812e+02, 3.9967690099729225e-06, 4, -1,
+    3.4421765136718750e+02, 1.8662402343750000e+02,
+    6.4281608581542969e+01, 6.1960502624511719e+01,
+    4.0982187783811241e-05, 4, -1, 3.6910086059570312e+02,
+    1.8662402343750000e+02, 6.4281608581542969e+01,
+    1.4227355957031250e+02, 1.0145059059141204e-04, 4, -1,
+    3.9813125610351562e+02, 1.8662402343750000e+02,
+    6.4281608581542969e+01, 1.3667060852050781e+02,
+    1.0126422239409294e-05, 4, -1, 2.2187522888183594e+02,
+    1.8869763183593750e+02, 6.4281608581542969e+01,
+    3.2906990051269531e+01, 1.8234199160360731e-05, 4, -1,
+    2.8200964355468750e+02, 1.8869763183593750e+02,
+    6.4281608581542969e+01, 2.3075306701660156e+02,
+    2.2523211373481899e-04, 4, -1, 3.7946884155273438e+02,
+    1.8869763183593750e+02, 6.4281608581542969e+01,
+    1.4680784606933594e+02, 1.3390080130193383e-04, 4, -1,
+    1.8662402343750000e+02, 1.9077122497558594e+02,
+    6.4281608581542969e+01, 1.9624948120117188e+02,
+    1.3344049875740893e-05, 4, -1, 2.1565443420410156e+02,
+    1.9077122497558594e+02, 6.4281608581542969e+01,
+    4.6657356262207031e+01, 2.2437374354922213e-05, 4, -1,
+    2.3224322509765625e+02, 1.9077122497558594e+02,
+    6.4281608581542969e+01, 2.0910099029541016e+01,
+    8.3801496657542884e-05, 4, -1, 2.3639042663574219e+02,
+    1.9077122497558594e+02, 6.4281608581542969e+01,
+    1.7876039505004883e+01, 6.6980013798456639e-05, 4, -1,
+    2.4261123657226562e+02, 1.9077122497558594e+02,
+    6.4281608581542969e+01, 1.2131252288818359e+01,
+    4.0948551031760871e-05, 4, -1, 2.7164163208007812e+02,
+    1.9077122497558594e+02, 6.4281608581542969e+01,
+    2.2216900634765625e+02, 1.6124156536534429e-04, 4, -1,
+    3.1104003906250000e+02, 1.9077122497558594e+02,
+    6.4281608581542969e+01, 2.9212210083007812e+02,
+    1.7018521248246543e-05, 4, -1, 3.1518725585937500e+02,
+    1.9077122497558594e+02, 6.4281608581542969e+01,
+    3.0222583007812500e+02, 1.4137876860331744e-05, 4, -1,
+    3.5043844604492188e+02, 1.9077122497558594e+02,
+    6.4281608581542969e+01, 1.0908139038085938e+02,
+    1.4715289580635726e-05, 4, -1, 3.6080645751953125e+02,
+    1.9077122497558594e+02, 6.4281608581542969e+01,
+    1.3955871582031250e+02, 2.4186416339944117e-05, 4, -1,
+    4.5826565551757812e+02, 1.9077122497558594e+02,
+    6.4281608581542969e+01, 1.9578686523437500e+02,
+    1.8512913811719045e-05, 4, -1, 2.8200964355468750e+02,
+    1.9284483337402344e+02, 6.4281608581542969e+01,
+    2.3083801269531250e+02, 1.3696309179067612e-04, 4, -1,
+    3.2970245361328125e+02, 1.9284483337402344e+02,
+    6.4281608581542969e+01, 3.3776773071289062e+02,
+    4.0754307519819122e-06, 4, -1, 3.4007043457031250e+02,
+    1.9284483337402344e+02, 6.4281608581542969e+01,
+    3.5124874877929688e+02, 4.3411517253844067e-05, 4, -1,
+    3.8568966674804688e+02, 1.9284483337402344e+02,
+    6.4281608581542969e+01, 1.5024142456054688e+02,
+    6.8927860411349684e-05, 4, -1, 1.7418241882324219e+02,
+    1.9491842651367188e+02, 6.4281608581542969e+01,
+    2.3485626220703125e+02, 1.3402397598838434e-05, 4, -1,
+    2.2602243041992188e+02, 1.9491842651367188e+02,
+    6.4281608581542969e+01, 3.1939767837524414e+01,
+    1.6263120051007718e-04, 4, -1, 2.5920004272460938e+02,
+    1.9491842651367188e+02, 6.4281608581542969e+01,
+    2.2066505432128906e+02, 1.4277582522481680e-05, 4, -1,
+    2.6956802368164062e+02, 1.9491842651367188e+02,
+    6.4281608581542969e+01, 2.2126049804687500e+02,
+    1.2894078099634498e-04, 4, -1, 4.0435205078125000e+02,
+    1.9491842651367188e+02, 6.4281608581542969e+01,
+    1.1321388244628906e+02, 1.7400741853634827e-05, 4, -1,
+    4.0849926757812500e+02, 1.9491842651367188e+02,
+    6.4281608581542969e+01, 1.0919738769531250e+02,
+    1.0086243491969071e-05, 4, -1, 2.3016963195800781e+02,
+    1.9699203491210938e+02, 6.4281608581542969e+01,
+    3.3323314666748047e+01, 8.3633938629645854e-05, 4, -1,
+    2.4883203125000000e+02, 1.9699203491210938e+02,
+    6.4281608581542969e+01, 2.1311899185180664e+01,
+    2.7450250854599290e-05, 4, -1, 2.8823043823242188e+02,
+    1.9699203491210938e+02, 6.4281608581542969e+01,
+    2.4153323364257812e+02, 5.1882048865081742e-05, 4, -1,
+    3.0481924438476562e+02, 1.9699203491210938e+02,
+    6.4281608581542969e+01, 2.9230142211914062e+02,
+    1.1105453449999914e-04, 4, -1, 3.6910086059570312e+02,
+    1.9699203491210938e+02, 6.4281608581542969e+01,
+    1.6605416870117188e+02, 3.5889319406123832e-05, 4, -1,
+    3.7946884155273438e+02, 1.9699203491210938e+02,
+    6.4281608581542969e+01, 1.6726954650878906e+02,
+    7.5189454946666956e-05, 4, -1, 4.4582406616210938e+02,
+    1.9699203491210938e+02, 6.4281608581542969e+01,
+    1.7858000183105469e+02, 2.2920068659004755e-05, 4, -1,
+    2.2187522888183594e+02, 1.9906562805175781e+02,
+    6.4281608581542969e+01, 4.7509880065917969e+01,
+    1.2311441241763532e-04, 4, -1, 2.6749444580078125e+02,
+    1.9906562805175781e+02, 6.4281608581542969e+01,
+    2.0782035827636719e+02, 9.9754361144732684e-05, 4, -1,
+    3.1104003906250000e+02, 1.9906562805175781e+02,
+    6.4281608581542969e+01, 3.2314089965820312e+02,
+    6.9539848482236266e-05, 4, -1, 3.1726083374023438e+02,
+    1.9906562805175781e+02, 6.4281608581542969e+01,
+    3.4006372070312500e+02, 3.9746773836668581e-05, 4, -1,
+    4.0020486450195312e+02, 1.9906562805175781e+02,
+    6.4281608581542969e+01, 1.3858108520507812e+02,
+    3.2520882086828351e-05, 4, -1, 2.4675843811035156e+02,
+    2.0113922119140625e+02, 6.4281608581542969e+01,
+    4.6701702117919922e+01, 2.5934024961316027e-05, 4, -1,
+    3.5251205444335938e+02, 2.0113922119140625e+02,
+    6.4281608581542969e+01, 1.0091078948974609e+02,
+    1.7662308891885914e-05, 4, -1, 4.6033926391601562e+02,
+    2.0113922119140625e+02, 6.4281608581542969e+01,
+    1.9870219421386719e+02, 2.4175885755539639e-06, 4, -1,
+    1.6796162414550781e+02, 2.0321282958984375e+02,
+    6.4281608581542969e+01, 2.5357147216796875e+02,
+    2.2405845811590552e-05, 4, -1, 2.0321282958984375e+02,
+    2.0321282958984375e+02, 6.4281608581542969e+01,
+    8.4932357788085938e+01, 2.6115872969967313e-05, 4, -1,
+    2.1772802734375000e+02, 2.0321282958984375e+02,
+    6.4281608581542969e+01, 5.8760963439941406e+01,
+    9.6534640761092305e-05, 4, -1, 2.3431683349609375e+02,
+    2.0321282958984375e+02, 6.4281608581542969e+01,
+    4.3648277282714844e+01, 1.7206077245646156e-05, 4, -1,
+    2.5297923278808594e+02, 2.0321282958984375e+02,
+    6.4281608581542969e+01, 1.3823132324218750e+02,
+    1.7629334251978435e-05, 4, -1, 2.9237765502929688e+02,
+    2.0321282958984375e+02, 6.4281608581542969e+01,
+    2.4697067260742188e+02, 4.9007823690772057e-05, 4, -1,
+    3.8983685302734375e+02, 2.0321282958984375e+02,
+    6.4281608581542969e+01, 1.5687223815917969e+02,
+    7.8869161370676011e-05, 4, -1, 4.0020486450195312e+02,
+    2.0321282958984375e+02, 6.4281608581542969e+01,
+    1.1868112182617188e+02, 5.6404194765491411e-05, 4, -1,
+    4.1264645385742188e+02, 2.0321282958984375e+02,
+    6.4281608581542969e+01, 1.1904675292968750e+02,
+    7.8923303590272553e-06, 4, -1, 2.6542083740234375e+02,
+    2.0528642272949219e+02, 6.4281608581542969e+01,
+    1.8734962463378906e+02, 6.5954060119111091e-05, 4, -1,
+    3.2140805053710938e+02, 2.0528642272949219e+02,
+    6.4281608581542969e+01, 5.8335514068603516e+00,
+    1.2716732453554869e-04, 4, -1, 3.5665924072265625e+02,
+    2.0528642272949219e+02, 6.4281608581542969e+01,
+    1.2411376953125000e+02, 3.1695210054749623e-05, 4, -1,
+    3.8568966674804688e+02, 2.0528642272949219e+02,
+    6.4281608581542969e+01, 1.5198320007324219e+02,
+    4.5851786126149818e-05, 4, -1, 2.5090563964843750e+02,
+    2.0736003112792969e+02, 6.4281608581542969e+01,
+    1.3462553405761719e+02, 7.2380444180453196e-06, 4, -1,
+    2.6127365112304688e+02, 2.0736003112792969e+02,
+    6.4281608581542969e+01, 1.8367929077148438e+02,
+    4.9080634198617190e-05, 4, -1, 2.6956802368164062e+02,
+    2.0736003112792969e+02, 6.4281608581542969e+01,
+    1.8795729064941406e+02, 6.2908657127991319e-05, 4, -1,
+    3.7532165527343750e+02, 2.0736003112792969e+02,
+    6.4281608581542969e+01, 1.4651895141601562e+02,
+    4.4101674575358629e-05, 4, -1, 2.1150723266601562e+02,
+    2.0943362426757812e+02, 6.4281608581542969e+01,
+    6.3793716430664062e+01, 2.1465991449076682e-04, 4, -1,
+    3.1311364746093750e+02, 2.0943362426757812e+02,
+    6.4281608581542969e+01, 1.8364344835281372e+00,
+    1.1285087384749204e-04, 4, -1, 3.2348165893554688e+02,
+    2.0943362426757812e+02, 6.4281608581542969e+01,
+    5.8380756378173828e+00, 1.5005092427600175e-04, 4, -1,
+    4.0435205078125000e+02, 2.0943362426757812e+02,
+    6.4281608581542969e+01, 1.1168308258056641e+02,
+    3.5989840398542583e-05, 4, -1, 2.8200964355468750e+02,
+    2.1150723266601562e+02, 6.4281608581542969e+01,
+    2.0081529235839844e+02, 2.9538225135183893e-05, 4, -1,
+    2.9652484130859375e+02, 2.1150723266601562e+02,
+    6.4281608581542969e+01, 3.1165866088867188e+02,
+    2.8078849936719052e-05, 4, -1, 3.6702725219726562e+02,
+    2.1150723266601562e+02, 6.4281608581542969e+01,
+    1.3449455261230469e+02, 1.2916408013552427e-04, 4, -1,
+    2.0943362426757812e+02, 2.1358082580566406e+02,
+    6.4281608581542969e+01, 6.1865402221679688e+01,
+    1.8589023966342211e-04, 4, -1, 2.2394883728027344e+02,
+    2.1358082580566406e+02, 6.4281608581542969e+01,
+    3.8773128509521484e+01, 3.8516568565682974e-06, 4, -1,
+    3.0689285278320312e+02, 2.1358082580566406e+02,
+    6.4281608581542969e+01, 3.5291210937500000e+02,
+    7.6664800872094929e-05, 4, -1, 3.3177606201171875e+02,
+    2.1358082580566406e+02, 6.4281608581542969e+01,
+    1.2001254081726074e+01, 1.0487395775271580e-04, 4, -1,
+    3.7117443847656250e+02, 2.1358082580566406e+02,
+    6.4281608581542969e+01, 1.3368783569335938e+02,
+    1.3678046525456011e-04, 4, -1, 4.0642565917968750e+02,
+    2.1358082580566406e+02, 6.4281608581542969e+01,
+    1.2967689514160156e+02, 7.9786346759647131e-05, 4, -1,
+    4.4789767456054688e+02, 2.1358082580566406e+02,
+    6.4281608581542969e+01, 1.8915391540527344e+02,
+    1.7005728295771405e-05, 4, -1, 1.9699203491210938e+02,
+    2.1772802734375000e+02, 6.4281608581542969e+01,
+    3.0063257217407227e+01, 2.6688634534366429e-05, 4, -1,
+    2.7993603515625000e+02, 2.1772802734375000e+02,
+    6.4281608581542969e+01, 1.9548341369628906e+02,
+    3.3681670174701139e-05, 4, -1, 3.7532165527343750e+02,
+    2.1772802734375000e+02, 6.4281608581542969e+01,
+    1.3338885498046875e+02, 9.1922905994579196e-05, 4, -1,
+    4.0227844238281250e+02, 2.1772802734375000e+02,
+    6.4281608581542969e+01, 1.3244613647460938e+02,
+    1.3910028792452067e-04, 4, -1, 4.4167684936523438e+02,
+    2.1772802734375000e+02, 6.4281608581542969e+01,
+    1.8653500366210938e+02, 1.3091544133203570e-05, 4, -1,
+    1.6796162414550781e+02, 2.1980163574218750e+02,
+    6.4281608581542969e+01, 2.4788525390625000e+02,
+    3.8010639400454238e-05, 4, -1, 1.7210882568359375e+02,
+    2.1980163574218750e+02, 6.4281608581542969e+01,
+    2.5739996337890625e+02, 2.8373431632644497e-05, 4, -1,
+    3.1311364746093750e+02, 2.1980163574218750e+02,
+    6.4281608581542969e+01, 3.5299597167968750e+02,
+    1.3064327504253015e-05, 4, -1, 2.9237765502929688e+02,
+    2.2187522888183594e+02, 6.4281608581542969e+01,
+    2.8289639282226562e+02, 3.3190259273396805e-05, 4, -1,
+    3.9191046142578125e+02, 2.2187522888183594e+02,
+    6.4281608581542969e+01, 1.3813386535644531e+02,
+    5.3599957027472556e-05, 4, -1, 1.5344642639160156e+02,
+    2.2394883728027344e+02, 6.4281608581542969e+01,
+    2.2829046630859375e+02, 1.1579381862247828e-05, 4, -1,
+    2.0321282958984375e+02, 2.2394883728027344e+02,
+    6.4281608581542969e+01, 2.2978488922119141e+01,
+    5.9376590797910467e-05, 4, -1, 2.6542083740234375e+02,
+    2.2394883728027344e+02, 6.4281608581542969e+01,
+    2.0977536010742188e+02, 2.5933823053492233e-05, 4, -1,
+    3.6910086059570312e+02, 2.2394883728027344e+02,
+    6.4281608581542969e+01, 1.5742285156250000e+02,
+    -4.3154621380381286e-05, 4, -1, 2.7164163208007812e+02,
+    2.2602243041992188e+02, 6.4281608581542969e+01,
+    2.0270297241210938e+02, 1.0934417514363304e-04, 4, -1,
+    2.7578884887695312e+02, 2.2602243041992188e+02,
+    6.4281608581542969e+01, 1.9896824645996094e+02,
+    8.2663158536888659e-05, 4, -1, 2.7993603515625000e+02,
+    2.2602243041992188e+02, 6.4281608581542969e+01,
+    1.9498437500000000e+02, 3.0207891541067511e-05, 4, -1,
+    2.9030404663085938e+02, 2.2602243041992188e+02,
+    6.4281608581542969e+01, 2.3752896118164062e+02,
+    4.7233534132828936e-05, 4, -1, 4.3338244628906250e+02,
+    2.2602243041992188e+02, 6.4281608581542969e+01,
+    1.9387387084960938e+02, 1.4573690350516699e-05, 4, -1,
+    2.4468482971191406e+02, 2.2809603881835938e+02,
+    6.4281608581542969e+01, 2.3194512939453125e+02,
+    4.7760936467966530e-06, 4, -1, 4.0227844238281250e+02,
+    2.2809603881835938e+02, 6.4281608581542969e+01,
+    1.6070858764648438e+02, 1.0678539547370747e-04, 4, -1,
+    4.4789767456054688e+02, 2.2809603881835938e+02,
+    6.4281608581542969e+01, 1.9651872253417969e+02,
+    5.2227569540264085e-06, 4, -1, 1.4929922485351562e+02,
+    2.3016963195800781e+02, 6.4281608581542969e+01,
+    2.1750555419921875e+02, 3.6475805245572701e-05, 4, -1,
+    2.9652484130859375e+02, 2.3016963195800781e+02,
+    6.4281608581542969e+01, 3.5074874877929688e+02,
+    5.0459850172046572e-05, 4, -1, 1.7832962036132812e+02,
+    2.3224322509765625e+02, 6.4281608581542969e+01,
+    3.2699877929687500e+02, 2.4749942895141430e-05, 4, -1,
+    1.5344642639160156e+02, 2.3431683349609375e+02,
+    6.4281608581542969e+01, 2.0752841186523438e+02,
+    2.9479439035640098e-05, 4, -1, 1.5759362792968750e+02,
+    2.3431683349609375e+02, 6.4281608581542969e+01,
+    2.2752468872070312e+02, 4.6505821956088766e-05, 4, -1,
+    1.6174082946777344e+02, 2.3431683349609375e+02,
+    6.4281608581542969e+01, 2.4659379577636719e+02,
+    5.2808885811828077e-05, 4, -1, 1.7210882568359375e+02,
+    2.3431683349609375e+02, 6.4281608581542969e+01,
+    2.9781564331054688e+02, 3.9463553548557684e-05, 4, -1,
+    2.0943362426757812e+02, 2.3431683349609375e+02,
+    6.4281608581542969e+01, 3.5356008911132812e+02,
+    1.8396629457129166e-05, 4, -1, 2.1358082580566406e+02,
+    2.3431683349609375e+02, 6.4281608581542969e+01,
+    3.4854754638671875e+02, 1.8589236788102426e-05, 4, -1,
+    2.1772802734375000e+02, 2.3431683349609375e+02,
+    6.4281608581542969e+01, 3.3113204956054688e+02,
+    2.7765767299570143e-05, 4, -1, 2.7164163208007812e+02,
+    2.3431683349609375e+02, 6.4281608581542969e+01,
+    1.9519740295410156e+02, 2.8442018083296716e-04, 4, -1,
+    3.0689285278320312e+02, 2.3431683349609375e+02,
+    6.4281608581542969e+01, 5.1237983703613281e+00,
+    1.9450764739303850e-05, 4, -1, 1.8040322875976562e+02,
+    2.3639042663574219e+02, 6.4281608581542969e+01,
+    3.4613153076171875e+02, 3.6317698686616495e-05, 4, -1,
+    2.3846403503417969e+02, 2.3639042663574219e+02,
+    6.4281608581542969e+01, 2.5729162597656250e+02,
+    1.8880263041864964e-06, 4, -1, 2.9237765502929688e+02,
+    2.3639042663574219e+02, 6.4281608581542969e+01,
+    9.9266082763671875e+01, 4.1223524021916091e-05, 4, -1,
+    3.3177606201171875e+02, 2.3639042663574219e+02,
+    6.4281608581542969e+01, 3.2350189208984375e+02,
+    3.7834752583876252e-04, 4, -1, 3.9813125610351562e+02,
+    2.3639042663574219e+02, 6.4281608581542969e+01,
+    2.0361183166503906e+02, 1.6640554531477392e-04, 4, -1,
+    4.3338244628906250e+02, 2.3639042663574219e+02,
+    6.4281608581542969e+01, 2.0909394836425781e+02,
+    2.3186032194644213e-05, 4, -1, 1.6796162414550781e+02,
+    2.3846403503417969e+02, 6.4281608581542969e+01,
+    5.4479923248291016e+01, 7.2578171966597438e-05, 4, -1,
+    2.2602243041992188e+02, 2.3846403503417969e+02,
+    6.4281608581542969e+01, 2.7763360595703125e+02,
+    8.3248432929394767e-06, 4, -1, 2.5090563964843750e+02,
+    2.3846403503417969e+02, 6.4281608581542969e+01,
+    2.2293957519531250e+02, 2.5951067073037848e-05, 4, -1,
+    1.3893121337890625e+02, 2.4053762817382812e+02,
+    6.4281608581542969e+01, 1.3447030639648438e+02,
+    2.9568762329290621e-05, 4, -1, 2.3224322509765625e+02,
+    2.4053762817382812e+02, 6.4281608581542969e+01,
+    2.6786184692382812e+02, -1.3106977121424279e-06, 4, -1,
+    2.5920004272460938e+02, 2.4053762817382812e+02,
+    6.4281608581542969e+01, 2.1015759277343750e+02,
+    1.7087545711547136e-04, 4, -1, 3.6495364379882812e+02,
+    2.4053762817382812e+02, 6.4281608581542969e+01,
+    2.6415289306640625e+02, 8.7712011008989066e-05, 4, -1,
+    1.7418241882324219e+02, 2.4261123657226562e+02,
+    6.4281608581542969e+01, 6.8489196777343750e+01,
+    7.4824849434662610e-05, 4, -1, 2.4675843811035156e+02,
+    2.4261123657226562e+02, 6.4281608581542969e+01,
+    2.3239691162109375e+02, 4.9572313400858548e-06, 4, -1,
+    2.6749444580078125e+02, 2.4261123657226562e+02,
+    6.4281608581542969e+01, 1.9919616699218750e+02,
+    1.4419175568036735e-04, 4, -1, 3.9813125610351562e+02,
+    2.4261123657226562e+02, 6.4281608581542969e+01,
+    2.2343133544921875e+02, 3.1193172617349774e-05, 4, -1,
+    4.3752966308593750e+02, 2.4261123657226562e+02,
+    6.4281608581542969e+01, 2.0784918212890625e+02,
+    3.0674447771161795e-05, 4, -1, 3.0274563598632812e+02,
+    2.4468482971191406e+02, 6.4281608581542969e+01,
+    3.0781776428222656e+01, 2.3329304531216621e-04, 4, -1,
+    3.0896643066406250e+02, 2.4468482971191406e+02,
+    6.4281608581542969e+01, 3.5708410644531250e+02,
+    9.1745772806461900e-05, 4, -1, 3.3384963989257812e+02,
+    2.4468482971191406e+02, 6.4281608581542969e+01,
+    3.2588214111328125e+02, 2.1155118884053081e-04, 4, -1,
+    3.5458566284179688e+02, 2.4468482971191406e+02,
+    6.4281608581542969e+01, 3.0454949951171875e+02,
+    4.9971517000813037e-05, 4, -1, 3.6288006591796875e+02,
+    2.4468482971191406e+02, 6.4281608581542969e+01,
+    2.7552566528320312e+02, 8.1764766946434975e-05, 4, -1,
+    3.6702725219726562e+02, 2.4468482971191406e+02,
+    6.4281608581542969e+01, 2.5649649047851562e+02,
+    9.6547249995637685e-05, 4, -1, 3.7117443847656250e+02,
+    2.4468482971191406e+02, 6.4281608581542969e+01,
+    2.4913937377929688e+02, 8.3560225903056562e-05, 4, -1,
+    1.3478401184082031e+02, 2.4675843811035156e+02,
+    6.4281608581542969e+01, 1.1272502899169922e+02,
+    6.6078122472390532e-05, 4, -1, 3.1518725585937500e+02,
+    2.4675843811035156e+02, 6.4281608581542969e+01,
+    3.4494265747070312e+02, 6.3515326473861933e-05, 4, -1,
+    3.3799685668945312e+02, 2.4675843811035156e+02,
+    6.4281608581542969e+01, 3.2572790527343750e+02,
+    4.1093060281127691e-04, 4, -1, 3.4214404296875000e+02,
+    2.4675843811035156e+02, 6.4281608581542969e+01,
+    3.2012857055664062e+02, 3.4820698783732951e-04, 4, -1,
+    3.7739526367187500e+02, 2.4675843811035156e+02,
+    6.4281608581542969e+01, 2.4376568603515625e+02,
+    5.0060221838066354e-05, 4, -1, 3.8776324462890625e+02,
+    2.4675843811035156e+02, 6.4281608581542969e+01,
+    2.3322921752929688e+02, 3.3367330615874380e-05, 4, -1,
+    1.4722561645507812e+02, 2.4883203125000000e+02,
+    6.4281608581542969e+01, 1.1985968780517578e+02,
+    1.5816862287465483e-05, 4, -1, 1.6796162414550781e+02,
+    2.4883203125000000e+02, 6.4281608581542969e+01,
+    8.9663162231445312e+01, 6.4702588133513927e-05, 4, -1,
+    1.7832962036132812e+02, 2.4883203125000000e+02,
+    6.4281608581542969e+01, 8.0034378051757812e+01,
+    4.3664680561050773e-05, 4, -1, 3.0896643066406250e+02,
+    2.4883203125000000e+02, 6.4281608581542969e+01,
+    8.8795137405395508e+00, 6.3519473769702017e-05, 4, -1,
+    1.6381442260742188e+02, 2.5090563964843750e+02,
+    6.4281608581542969e+01, 9.4682975769042969e+01,
+    4.7688969061709940e-05, 4, -1, 1.9699203491210938e+02,
+    2.5090563964843750e+02, 6.4281608581542969e+01,
+    5.8129127502441406e+01, 2.4318131181644276e-05, 4, -1,
+    3.0067202758789062e+02, 2.5090563964843750e+02,
+    6.4281608581542969e+01, 6.6797775268554688e+01,
+    9.2230235168244690e-05, 4, -1, 3.5043844604492188e+02,
+    2.5090563964843750e+02, 6.4281608581542969e+01,
+    3.0358010864257812e+02, 5.2710154704982415e-05, 4, -1,
+    3.7324804687500000e+02, 2.5090563964843750e+02,
+    6.4281608581542969e+01, 2.5330490112304688e+02,
+    5.0566446589073166e-05, 4, -1, 1.3063682556152344e+02,
+    2.5297923278808594e+02, 6.4281608581542969e+01,
+    9.6214920043945312e+01, 1.0939172352664173e-04, 4, -1,
+    3.1518725585937500e+02, 2.5297923278808594e+02,
+    6.4281608581542969e+01, 1.1261159896850586e+01,
+    7.6502248703036457e-05, 4, -1, 1.4722561645507812e+02,
+    2.5505284118652344e+02, 6.4281608581542969e+01,
+    1.1107586669921875e+02, 3.6956455005565658e-05, 4, -1,
+    1.6381442260742188e+02, 2.5505284118652344e+02,
+    6.4281608581542969e+01, 9.6089523315429688e+01,
+    3.7811256333952770e-05, 4, -1, 1.9699203491210938e+02,
+    2.5505284118652344e+02, 6.4281608581542969e+01,
+    7.3927192687988281e+01, 3.2923933758866042e-05, 4, -1,
+    1.9284483337402344e+02, 2.5712643432617188e+02,
+    6.4281608581542969e+01, 7.9215820312500000e+01,
+    3.3591597457416356e-05, 4, -1, 4.1886724853515625e+02,
+    2.5712643432617188e+02, 6.4281608581542969e+01,
+    2.1152992248535156e+02, 5.7834298786474392e-05, 4, -1,
+    2.2187522888183594e+02, 2.5920004272460938e+02,
+    6.4281608581542969e+01, 1.0329373168945312e+02,
+    1.3369886801228859e-05, 4, -1, 3.6080645751953125e+02,
+    2.5920004272460938e+02, 6.4281608581542969e+01,
+    2.6327600097656250e+02, 9.4141696536098607e-06, 4, -1,
+    2.3431683349609375e+02, 2.6127365112304688e+02,
+    6.4281608581542969e+01, 1.0722219085693359e+02,
+    1.9824048649752513e-05, 4, -1, 2.4468482971191406e+02,
+    2.6127365112304688e+02, 6.4281608581542969e+01,
+    1.0519688415527344e+02, 2.6770252588903531e-05, 4, -1,
+    2.6127365112304688e+02, 2.6127365112304688e+02,
+    6.4281608581542969e+01, 1.0928516387939453e+02,
+    1.5803192582097836e-05, 4, -1, 3.4629125976562500e+02,
+    2.6127365112304688e+02, 6.4281608581542969e+01,
+    2.7949050903320312e+02, 2.4975238375191111e-06, 4, -1,
+    3.6080645751953125e+02, 2.6334722900390625e+02,
+    6.4281608581542969e+01, 2.5023410034179688e+02,
+    6.5661788539728150e-06, 4, -1, 4.2716165161132812e+02,
+    2.6334722900390625e+02, 6.4281608581542969e+01,
+    2.0526744079589844e+02, 2.0618666894733906e-05, 4, -1,
+    2.5920004272460938e+02, 2.6542083740234375e+02,
+    6.4281608581542969e+01, 1.0259883117675781e+02,
+    2.1798374291392975e-05, 4, -1, 2.7371524047851562e+02,
+    2.6749444580078125e+02, 6.4281608581542969e+01,
+    1.0095189666748047e+02, 1.4930599718354642e-05, 4, -1,
+    3.9813125610351562e+02, 2.6749444580078125e+02,
+    6.4281608581542969e+01, 2.1945408630371094e+02,
+    5.4456108045997098e-05, 4, -1, 4.0849926757812500e+02,
+    2.6749444580078125e+02, 6.4281608581542969e+01,
+    2.1773606872558594e+02, 4.5817399950465187e-05, 4, -1,
+    1.2856321716308594e+02, 2.6956802368164062e+02,
+    6.4281608581542969e+01, 6.9935455322265625e+01,
+    5.0448920774215367e-06, 4, -1, 3.7117443847656250e+02,
+    2.6956802368164062e+02, 6.4281608581542969e+01,
+    1.7553672790527344e+02, 1.5477100532734767e-05, 4, -1,
+    4.2716165161132812e+02, 2.6956802368164062e+02,
+    6.4281608581542969e+01, 2.0239752197265625e+02,
+    2.5898849344230257e-05, 4, -1, 3.8776324462890625e+02,
+    2.7164163208007812e+02, 6.4281608581542969e+01,
+    1.8938821411132812e+02, 6.1704318795818835e-05, 4, -1,
+    1.4307841491699219e+02, 2.7371524047851562e+02,
+    6.4281608581542969e+01, 9.8510818481445312e+01,
+    1.6292121927108383e-06, 4, -1, 1.5137281799316406e+02,
+    2.7371524047851562e+02, 6.4281608581542969e+01,
+    1.0002404022216797e+02, 1.5578347074551857e-06, 4, -1,
+    3.2140805053710938e+02, 2.7371524047851562e+02,
+    6.4281608581542969e+01, 9.7208442687988281e+01,
+    2.1661953724105842e-05, 4, -1, 3.5665924072265625e+02,
+    2.7371524047851562e+02, 6.4281608581542969e+01,
+    1.2347024536132812e+02, 1.0761247722257394e-05, 4, -1,
+    3.7117443847656250e+02, 2.7371524047851562e+02,
+    6.4281608581542969e+01, 1.0861427307128906e+02,
+    2.3074142518453300e-05, 4, -1, 4.1679367065429688e+02,
+    2.7371524047851562e+02, 6.4281608581542969e+01,
+    1.8461090087890625e+02, 2.3369815608020872e-05, 4, -1,
+    4.2094085693359375e+02, 2.7371524047851562e+02,
+    6.4281608581542969e+01, 1.9001640319824219e+02,
+    2.1860034394194372e-05, 4, -1, 4.2716165161132812e+02,
+    2.7578884887695312e+02, 6.4281608581542969e+01,
+    1.8941567993164062e+02, 1.0239918083243538e-05, 4, -1,
+    3.5251205444335938e+02, 2.7786242675781250e+02,
+    6.4281608581542969e+01, 1.1220871734619141e+02,
+    3.0871022318024188e-05, 4, -1, 1.9077122497558594e+02,
+    2.7993603515625000e+02, 6.4281608581542969e+01,
+    7.8606094360351562e+01, 6.5648350755509455e-07, 4, -1,
+    3.8568966674804688e+02, 2.7993603515625000e+02,
+    6.4281608581542969e+01, 1.0900947570800781e+02,
+    9.6470655989833176e-05, 4, -1, 3.9191046142578125e+02,
+    2.7993603515625000e+02, 6.4281608581542969e+01,
+    1.1716323852539062e+02, 4.4091604650020599e-05, 4, -1,
+    3.5251205444335938e+02, 2.8200964355468750e+02,
+    6.4281608581542969e+01, 1.0970835876464844e+02,
+    3.1593343010172248e-05, 4, -1, 3.7739526367187500e+02,
+    2.8200964355468750e+02, 6.4281608581542969e+01,
+    1.0814862823486328e+02, 5.6960529036587104e-05, 4, -1,
+    1.4100482177734375e+02, 2.8408325195312500e+02,
+    6.4281608581542969e+01, 8.2256896972656250e+01,
+    8.5381034296005964e-06, 4, -1, 2.1358082580566406e+02,
+    2.8408325195312500e+02, 6.4281608581542969e+01,
+    9.8128883361816406e+01, 2.3569600671180524e-06, 4, -1,
+    3.1104003906250000e+02, 2.8408325195312500e+02,
+    6.4281608581542969e+01, 9.4902603149414062e+01,
+    -6.1259279391379096e-06, 4, -1, 3.6910086059570312e+02,
+    2.8408325195312500e+02, 6.4281608581542969e+01,
+    1.0763467407226562e+02, 7.2479442678741179e-06, 4, -1,
+    3.8776324462890625e+02, 2.8408325195312500e+02,
+    6.4281608581542969e+01, 1.0884208679199219e+02,
+    6.4939144067466259e-05, 4, -1, 2.2187522888183594e+02,
+    2.8615682983398438e+02, 6.4281608581542969e+01,
+    9.8376106262207031e+01, 2.2753420125809498e-06, 4, -1,
+    2.3639042663574219e+02, 2.8615682983398438e+02,
+    6.4281608581542969e+01, 9.9089759826660156e+01,
+    6.9604396912836819e-07, 4, -1, 3.1933444213867188e+02,
+    2.8615682983398438e+02, 6.4281608581542969e+01,
+    9.5605865478515625e+01, -6.8379149524844252e-06, 4, -1,
+    3.4007043457031250e+02, 2.8615682983398438e+02,
+    6.4281608581542969e+01, 1.0717977142333984e+02,
+    5.9997973949066363e-06, 4, -1, 4.0227844238281250e+02,
+    2.8615682983398438e+02, 6.4281608581542969e+01,
+    1.0960502624511719e+02, 4.4439668272389099e-05, 4, -1,
+    1.2648961639404297e+02, 2.8823043823242188e+02,
+    6.4281608581542969e+01, 3.5476507568359375e+02,
+    1.6513025684616878e-06, 4, -1, 2.4468482971191406e+02,
+    2.8823043823242188e+02, 6.4281608581542969e+01,
+    9.8058700561523438e+01, 6.7669827785721282e-07, 4, -1,
+    4.1886724853515625e+02, 2.8823043823242188e+02,
+    6.4281608581542969e+01, 1.3931639099121094e+02,
+    2.2997453925199807e-05, 4, -1, 3.7739526367187500e+02,
+    2.9030404663085938e+02, 6.4281608581542969e+01,
+    1.0365924835205078e+02, 3.2805688533699140e-05, 4, -1,
+    4.1264645385742188e+02, 2.9030404663085938e+02,
+    6.4281608581542969e+01, 1.2390562438964844e+02,
+    8.7965068814810365e-05, 4, -1, 2.5920004272460938e+02,
+    2.9237765502929688e+02, 6.4281608581542969e+01,
+    9.9583488464355469e+01, 5.2681502893392462e-07, 4, -1,
+    3.7324804687500000e+02, 2.9237765502929688e+02,
+    6.4281608581542969e+01, 1.0377601623535156e+02,
+    1.3791905075777322e-05, 4, -1, 4.2094085693359375e+02,
+    2.9237765502929688e+02, 6.4281608581542969e+01,
+    1.4555502319335938e+02, 2.5137484044535086e-05, 4, -1,
+    1.2856321716308594e+02, 2.9445123291015625e+02,
+    6.4281608581542969e+01, 3.4530969238281250e+02,
+    2.2985534542385722e-06, 4, -1, 1.7832962036132812e+02,
+    2.9445123291015625e+02, 6.4281608581542969e+01,
+    2.8625985717773438e+02, 1.0783110337797552e-04, 4, -1,
+    2.6956802368164062e+02, 2.9445123291015625e+02,
+    6.4281608581542969e+01, 1.0159552001953125e+02,
+    8.9979181439048261e-07, 4, -1, 2.8615682983398438e+02,
+    2.9445123291015625e+02, 6.4281608581542969e+01,
+    1.0460892486572266e+02, 1.6899361980904359e-06, 4, -1,
+    3.9605764770507812e+02, 2.9445123291015625e+02,
+    6.4281608581542969e+01, 1.0259939575195312e+02,
+    3.3708798582665622e-05, 4, -1, 4.1679367065429688e+02,
+    2.9445123291015625e+02, 6.4281608581542969e+01,
+    1.3791215515136719e+02, 8.3465245552361012e-05, 4, -1,
+    1.6588803100585938e+02, 2.9652484130859375e+02,
+    6.4281608581542969e+01, 2.5615582275390625e+02,
+    4.7804609494050965e-05, 4, -1, 1.8040322875976562e+02,
+    3.0067202758789062e+02, 6.4281608581542969e+01,
+    2.8445556640625000e+02, 1.2432946823537350e-04, 4, -1,
+    1.4515202331542969e+02, 3.0274563598632812e+02,
+    6.4281608581542969e+01, 2.0516401672363281e+02,
+    4.2439828575879801e-06, 4, -1, 1.8455043029785156e+02,
+    3.0274563598632812e+02, 6.4281608581542969e+01,
+    2.9422256469726562e+02, 9.8232194432057440e-05, 4, -1,
+    3.3177606201171875e+02, 3.0274563598632812e+02,
+    6.4281608581542969e+01, 9.5122787475585938e+01,
+    5.5501203632957186e-07, 4, -1, 1.8040322875976562e+02,
+    3.0481924438476562e+02, 6.4281608581542969e+01,
+    2.8217706298828125e+02, 7.9227327660191804e-05, 4, -1,
+    2.6956802368164062e+02, 3.0481924438476562e+02,
+    6.4281608581542969e+01, 1.2184475708007812e+02,
+    2.2141325644042809e-06, 4, -1, 3.3592324829101562e+02,
+    3.0481924438476562e+02, 6.4281608581542969e+01,
+    9.5627838134765625e+01, 2.0881943783024326e-06, 4, -1,
+    3.4007043457031250e+02, 3.0481924438476562e+02,
+    6.4281608581542969e+01, 9.8162132263183594e+01,
+    1.3517217212211108e-06, 4, -1, 3.5665924072265625e+02,
+    3.0481924438476562e+02, 6.4281608581542969e+01,
+    1.0066004943847656e+02, 1.4382682138602831e-06, 4, -1,
+    3.6080645751953125e+02, 3.0481924438476562e+02,
+    6.4281608581542969e+01, 1.0039314270019531e+02,
+    2.7868954930454493e-06, 4, -1, 4.2716165161132812e+02,
+    3.0481924438476562e+02, 6.4281608581542969e+01,
+    1.5872937011718750e+02, 5.6673266954021528e-05, 4, -1,
+    3.6495364379882812e+02, 3.0689285278320312e+02,
+    6.4281608581542969e+01, 1.0078372192382812e+02,
+    5.4005357696951251e-07, 4, -1, 4.2094085693359375e+02,
+    3.0896643066406250e+02, 6.4281608581542969e+01,
+    1.5272814941406250e+02, 1.3884119107387960e-04, 4, -1,
+    1.4515202331542969e+02, 3.1104003906250000e+02,
+    6.4281608581542969e+01, 2.3626214599609375e+02,
+    1.2433511074050330e-06, 4, -1, 1.8662402343750000e+02,
+    3.1104003906250000e+02, 6.4281608581542969e+01,
+    2.9553036499023438e+02, 5.0767986977007240e-05, 4, -1,
+    1.9077122497558594e+02, 3.1104003906250000e+02,
+    6.4281608581542969e+01, 3.0543478393554688e+02,
+    4.3865467887371778e-05, 4, -1, 3.8361605834960938e+02,
+    3.1104003906250000e+02, 6.4281608581542969e+01,
+    1.0680554962158203e+02, 9.1324403683756827e-07, 4, -1,
+    1.3271041870117188e+02, 3.1311364746093750e+02,
+    6.4281608581542969e+01, 3.3221005249023438e+02,
+    2.1335906694730511e-06, 4, -1, 2.9237765502929688e+02,
+    3.1311364746093750e+02, 6.4281608581542969e+01,
+    1.7002801513671875e+02, 6.2170642195269465e-05, 4, -1,
+    3.9191046142578125e+02, 3.1311364746093750e+02,
+    6.4281608581542969e+01, 1.0801755523681641e+02,
+    9.7119254860444926e-07, 4, -1, 4.1264645385742188e+02,
+    3.1311364746093750e+02, 6.4281608581542969e+01,
+    1.4428553771972656e+02, 1.4382538211066276e-05, 4, -1,
+    1.4722561645507812e+02, 3.1518725585937500e+02,
+    6.4281608581542969e+01, 2.2765670776367188e+02,
+    7.7251718266779790e-07, 4, -1, 1.7210882568359375e+02,
+    3.1518725585937500e+02, 6.4281608581542969e+01,
+    2.2703379821777344e+02, 1.2868580597569235e-05, 4, -1,
+    2.0321282958984375e+02, 3.1518725585937500e+02,
+    6.4281608581542969e+01, 3.0256445312500000e+02,
+    5.8782312407856807e-05, 4, -1, 2.0943362426757812e+02,
+    3.1518725585937500e+02, 6.4281608581542969e+01,
+    2.9427758789062500e+02, 6.8105618993286043e-05, 4, -1,
+    3.1104003906250000e+02, 3.1518725585937500e+02,
+    6.4281608581542969e+01, 6.6234497070312500e+01,
+    2.2121606889413670e-05, 4, -1, 2.9237765502929688e+02,
+    3.1726083374023438e+02, 6.4281608581542969e+01,
+    2.1764462280273438e+02, 1.1373860616004094e-04, 4, -1,
+    4.1679367065429688e+02, 3.1726083374023438e+02,
+    6.4281608581542969e+01, 1.5391497802734375e+02,
+    2.0749008399434388e-05, 4, -1, 2.0943362426757812e+02,
+    3.1933444213867188e+02, 6.4281608581542969e+01,
+    2.9201467895507812e+02, 9.8074015113525093e-05, 4, -1,
+    2.1772802734375000e+02, 3.1933444213867188e+02,
+    6.4281608581542969e+01, 2.8855346679687500e+02,
+    6.8830449890810996e-05, 4, -1, 3.2555523681640625e+02,
+    3.1933444213867188e+02, 6.4281608581542969e+01,
+    3.2541473388671875e+01, 6.4075443333422299e-06, 4, -1,
+    1.4929922485351562e+02, 3.2140805053710938e+02,
+    6.4281608581542969e+01, 2.3805569458007812e+02,
+    4.8433503252454102e-06, 4, -1, 2.3016963195800781e+02,
+    3.2140805053710938e+02, 6.4281608581542969e+01,
+    2.9401739501953125e+02, 1.1605695908656344e-04, 4, -1,
+    2.7993603515625000e+02, 3.2140805053710938e+02,
+    6.4281608581542969e+01, 2.5295822143554688e+02,
+    6.4979707531165332e-05, 4, -1, 2.9652484130859375e+02,
+    3.2140805053710938e+02, 6.4281608581542969e+01,
+    2.4673989868164062e+02, 8.1574857176747173e-05, 4, -1,
+    3.0274563598632812e+02, 3.2140805053710938e+02,
+    6.4281608581542969e+01, 2.6761764526367188e+02,
+    3.2294236007146537e-05, 4, -1, 3.7946884155273438e+02,
+    3.2140805053710938e+02, 6.4281608581542969e+01,
+    1.2743077087402344e+02, 6.4259688770107459e-06, 4, -1,
+    1.7210882568359375e+02, 3.2348165893554688e+02,
+    6.4281608581542969e+01, 2.0590527343750000e+02,
+    5.2406245231395587e-05, 4, -1, 2.8823043823242188e+02,
+    3.2348165893554688e+02, 6.4281608581542969e+01,
+    2.5520477294921875e+02, 1.4976394595578313e-04, 4, -1,
+    2.9237765502929688e+02, 3.2348165893554688e+02,
+    6.4281608581542969e+01, 2.5156578063964844e+02,
+    1.6789299843367189e-04, 4, -1, 3.1518725585937500e+02,
+    3.2348165893554688e+02, 6.4281608581542969e+01,
+    3.3806045532226562e+02, 3.5197044780943543e-05, 4, -1,
+    2.4053762817382812e+02, 3.2555523681640625e+02,
+    6.4281608581542969e+01, 2.9834259033203125e+02,
+    -7.2048214860842563e-06, 4, -1, 2.6956802368164062e+02,
+    3.2555523681640625e+02, 6.4281608581542969e+01,
+    2.7881039428710938e+02, 6.5289517806377262e-05, 4, -1,
+    3.7324804687500000e+02, 3.2555523681640625e+02,
+    6.4281608581542969e+01, 1.6148300170898438e+02,
+    3.8963858969509602e-05, 4, -1, 2.0321282958984375e+02,
+    3.2762884521484375e+02, 6.4281608581542969e+01,
+    2.9109918212890625e+02, 4.7146852011792362e-05, 4, -1,
+    2.3224322509765625e+02, 3.2762884521484375e+02,
+    6.4281608581542969e+01, 2.9423147583007812e+02,
+    4.0671075112186372e-05, 4, -1, 2.5920004272460938e+02,
+    3.2762884521484375e+02, 6.4281608581542969e+01,
+    2.9096447753906250e+02, 9.2869049694854766e-05, 4, -1,
+    2.8200964355468750e+02, 3.2762884521484375e+02,
+    6.4281608581542969e+01, 2.7143786621093750e+02,
+    1.3953413872513920e-04, 4, -1, 2.9859844970703125e+02,
+    3.2762884521484375e+02, 6.4281608581542969e+01,
+    2.7262820434570312e+02, 1.1109317711088806e-04, 4, -1,
+    3.3384963989257812e+02, 3.2762884521484375e+02,
+    6.4281608581542969e+01, 3.4424630737304688e+02,
+    1.9766359855566407e-06, 4, -1, 3.9813125610351562e+02,
+    3.2762884521484375e+02, 6.4281608581542969e+01,
+    1.6258381652832031e+02, 1.8865048332372680e-05, 4, -1,
+    1.3685762023925781e+02, 3.2970245361328125e+02,
+    6.4281608581542969e+01, 3.1058200073242188e+02,
+    8.1921216406044550e-06, 4, -1, 2.1150723266601562e+02,
+    3.2970245361328125e+02, 6.4281608581542969e+01,
+    2.8070092773437500e+02, 4.5167911594035104e-05, 4, -1,
+    2.2602243041992188e+02, 3.2970245361328125e+02,
+    6.4281608581542969e+01, 2.8901248168945312e+02,
+    1.8283659301232547e-05, 4, -1, 2.5505284118652344e+02,
+    3.2970245361328125e+02, 6.4281608581542969e+01,
+    2.9550811767578125e+02, 6.3682971813250333e-05, 4, -1,
+    1.3063682556152344e+02, 3.3177606201171875e+02,
+    6.4281608581542969e+01, 3.1599237060546875e+02,
+    2.3565948140458204e-05, 4, -1, 2.0528642272949219e+02,
+    3.3177606201171875e+02, 6.4281608581542969e+01,
+    2.8605700683593750e+02, 3.2505358831258491e-05, 4, -1,
+    2.1772802734375000e+02, 3.3177606201171875e+02,
+    6.4281608581542969e+01, 2.8156228637695312e+02,
+    3.1786188628757372e-05, 4, -1, 2.5090563964843750e+02,
+    3.3177606201171875e+02, 6.4281608581542969e+01,
+    2.9559051513671875e+02, 8.9855697297025472e-05, 4, -1,
+    2.9237765502929688e+02, 3.3177606201171875e+02,
+    6.4281608581542969e+01, 2.8022717285156250e+02,
+    2.9671986703760922e-04, 4, -1, 2.2187522888183594e+02,
+    3.3384963989257812e+02, 6.4281608581542969e+01,
+    2.8369305419921875e+02, 2.7740235964301974e-05, 4, -1,
+    2.6749444580078125e+02, 3.3384963989257812e+02,
+    6.4281608581542969e+01, 2.8759207153320312e+02,
+    1.1623364116530865e-04, 4, -1, 2.9652484130859375e+02,
+    3.3384963989257812e+02, 6.4281608581542969e+01,
+    2.9450393676757812e+02, 1.9102489750366658e-04, 4, -1,
+    3.7117443847656250e+02, 3.3384963989257812e+02,
+    6.4281608581542969e+01, 2.1879437255859375e+02,
+    4.7231154894689098e-05, 4, -1, 4.1679367065429688e+02,
+    3.3384963989257812e+02, 6.4281608581542969e+01,
+    1.7688183593750000e+02, 2.7970304472546559e-06, 4, -1,
+    2.3846403503417969e+02, 3.3592324829101562e+02,
+    6.4281608581542969e+01, 2.9723654174804688e+02,
+    1.0351875971537083e-05, 4, -1, 2.9030404663085938e+02,
+    3.3592324829101562e+02, 6.4281608581542969e+01,
+    2.9433364868164062e+02, 1.9004606292583048e-04, 4, -1,
+    3.1726083374023438e+02, 3.3592324829101562e+02,
+    6.4281608581542969e+01, 3.3111441040039062e+02,
+    2.4859069526428357e-05, 4, -1, 2.5297923278808594e+02,
+    3.3799685668945312e+02, 6.4281608581542969e+01,
+    2.9739617919921875e+02, 4.0067458030534908e-05, 4, -1,
+    3.2555523681640625e+02, 3.3799685668945312e+02,
+    6.4281608581542969e+01, 3.2312872314453125e+02,
+    2.4042501536314376e-05, 4, -1, 2.6956802368164062e+02,
+    3.4007043457031250e+02, 6.4281608581542969e+01,
+    2.8922747802734375e+02, 6.8472245402517729e-06, 4, -1,
+    2.7578884887695312e+02, 3.4214404296875000e+02,
+    6.4281608581542969e+01, 2.9398608398437500e+02,
+    3.4065262298099697e-05, 4, -1, 2.0321282958984375e+02,
+    3.4421765136718750e+02, 6.4281608581542969e+01,
+    1.1603143310546875e+02, 2.1870778255106416e-06, 4, -1,
+    2.8823043823242188e+02, 3.4421765136718750e+02,
+    6.4281608581542969e+01, 3.0178735351562500e+02,
+    5.4756619647378102e-05, 4, -1, 3.1518725585937500e+02,
+    3.4421765136718750e+02, 6.4281608581542969e+01,
+    2.8959573364257812e+02, 4.4661166612058878e-05, 4, -1,
+    3.2970245361328125e+02, 3.4421765136718750e+02,
+    6.4281608581542969e+01, 2.8732421875000000e+02,
+    2.6747326046461239e-05, 4, -1, 3.0067202758789062e+02,
+    3.4629125976562500e+02, 6.4281608581542969e+01,
+    2.9942388916015625e+02, 4.6331847443070728e-06, 4, -1,
+    3.4629125976562500e+02, 3.4629125976562500e+02,
+    6.4281608581542969e+01, 2.8458419799804688e+02,
+    -1.3694265135200112e-06, 4, -1, 3.5665924072265625e+02,
+    3.4629125976562500e+02, 6.4281608581542969e+01,
+    2.6710461425781250e+02, 7.4691392910608556e-06, 4, -1,
+    3.1726083374023438e+02, 3.4836483764648438e+02,
+    6.4281608581542969e+01, 2.8733721923828125e+02,
+    4.0170365537051111e-05, 4, -1, 3.4007043457031250e+02,
+    3.4836483764648438e+02, 6.4281608581542969e+01,
+    2.8532403564453125e+02, 2.4008024411159568e-05, 4, -1,
+    4.0020486450195312e+02, 3.4836483764648438e+02,
+    6.4281608581542969e+01, 2.1123658752441406e+02,
+    1.0249083970848005e-05, 4, -1, 2.4261123657226562e+02,
+    3.5043844604492188e+02, 6.4281608581542969e+01,
+    2.9947683715820312e+02, -2.6193508801952703e-06, 4, -1,
+    3.1104003906250000e+02, 3.5251205444335938e+02,
+    6.4281608581542969e+01, 2.8208300781250000e+02,
+    8.5514884631265886e-06, 4, -1, 3.7946884155273438e+02,
+    3.5251205444335938e+02, 6.4281608581542969e+01,
+    2.5037149047851562e+02, 3.5917985314881662e-06, 4, -1,
+    3.4836483764648438e+02, 3.5458566284179688e+02,
+    6.4281608581542969e+01, 2.7726947021484375e+02,
+    6.5984436332655605e-06, 4, -1, 3.2348165893554688e+02,
+    3.5665924072265625e+02, 6.4281608581542969e+01,
+    2.6941882324218750e+02, -1.3471349120663945e-06, 4, -1,
+    3.4007043457031250e+02, 3.5665924072265625e+02,
+    6.4281608581542969e+01, 2.8059582519531250e+02,
+    3.4673937534535071e-06, 4, -1, 3.7946884155273438e+02,
+    3.5665924072265625e+02, 6.4281608581542969e+01,
+    2.6027703857421875e+02, 5.6184967434091959e-06, 4, -1,
+    3.4836483764648438e+02, 3.5873284912109375e+02,
+    6.4281608581542969e+01, 2.7642236328125000e+02,
+    4.8611818783683702e-06, 4, -1, 4.1886724853515625e+02,
+    3.5873284912109375e+02, 6.4281608581542969e+01,
+    1.8705703735351562e+02, 3.4597399007907370e-06, 4, -1,
+    3.8154244995117188e+02, 3.6080645751953125e+02,
+    6.4281608581542969e+01, 2.6866265869140625e+02,
+    1.0772051609819755e-05, 4, -1, 3.1726083374023438e+02,
+    3.6495364379882812e+02, 6.4281608581542969e+01,
+    2.7157385253906250e+02, 3.1871659302851185e-06, 4, -1,
+    3.7739526367187500e+02, 3.6495364379882812e+02,
+    6.4281608581542969e+01, 2.7127737426757812e+02,
+    8.9598033810034394e-06, 4, -1, 4.0020486450195312e+02,
+    3.6495364379882812e+02, 6.4281608581542969e+01,
+    2.5451443481445312e+02, 1.3480361303663813e-05, 4, -1,
+    3.3799685668945312e+02, 3.6702725219726562e+02,
+    6.4281608581542969e+01, 2.7756259155273438e+02,
+    7.6182135444469168e-07, 4, -1, 3.6910086059570312e+02,
+    3.7117443847656250e+02, 6.4281608581542969e+01,
+    2.7631570434570312e+02, 1.8440996427671053e-06, 4, -1,
+    4.1886724853515625e+02, 3.7324804687500000e+02,
+    6.4281608581542969e+01, 1.9579324340820312e+02,
+    3.9645133256271947e-06, 4, -1, 4.2923526000976562e+02,
+    3.8361605834960938e+02, 6.4281608581542969e+01,
+    1.7713423156738281e+02, 7.4140232754871249e-05, 4, -1,
+    2.0653060913085938e+02, 1.3188099670410156e+02,
+    7.7137939453125000e+01, 1.7117657470703125e+02,
+    8.2635433500399813e-06, 5, -1, 2.1399557495117188e+02,
+    1.3685763549804688e+02, 7.7137939453125000e+01,
+    1.6366664123535156e+02, 3.2789550459710881e-05, 5, -1,
+    2.4385542297363281e+02, 1.4183427429199219e+02,
+    7.7137939453125000e+01, 7.2224227905273438e+01,
+    1.1486744369904045e-05, 5, -1, 2.2394885253906250e+02,
+    1.4432260131835938e+02, 7.7137939453125000e+01,
+    1.4031869506835938e+02, 1.3638764357892796e-05, 5, -1,
+    2.4634373474121094e+02, 1.4929924011230469e+02,
+    7.7137939453125000e+01, 6.5567802429199219e+01,
+    1.6873047570697963e-05, 5, -1, 2.7620358276367188e+02,
+    1.5178755187988281e+02, 7.7137939453125000e+01,
+    9.0823219299316406e+01, 2.5124390958808362e-06, 5, -1,
+    2.0155397033691406e+02, 1.5676419067382812e+02,
+    7.7137939453125000e+01, 1.7068386840820312e+02,
+    1.9955692550865933e-05, 5, -1, 2.1648388671875000e+02,
+    1.5676419067382812e+02, 7.7137939453125000e+01,
+    1.5623370361328125e+02, 1.8633476429386064e-05, 5, -1,
+    3.5085321044921875e+02, 1.5925251770019531e+02,
+    7.7137939453125000e+01, 9.9209083557128906e+01,
+    2.3647460238862550e-06, 5, -1, 1.9657733154296875e+02,
+    1.6422915649414062e+02, 7.7137939453125000e+01,
+    1.7775744628906250e+02, 3.2102219847729430e-05, 5, -1,
+    2.0404228210449219e+02, 1.6422915649414062e+02,
+    7.7137939453125000e+01, 1.8808859252929688e+02,
+    3.2152271160157397e-05, 5, -1, 3.8071304321289062e+02,
+    1.6422915649414062e+02, 7.7137939453125000e+01,
+    1.2997967529296875e+02, 2.1765370092907688e-06, 5, -1,
+    4.1057290649414062e+02, 1.6422915649414062e+02,
+    7.7137939453125000e+01, 1.2628047943115234e+02,
+    3.9457377170037944e-06, 5, -1, 4.3794442749023438e+02,
+    1.6422915649414062e+02, 7.7137939453125000e+01,
+    1.3768920898437500e+02, 1.7992535504163243e-05, 5, -1,
+    3.9315466308593750e+02, 1.6671748352050781e+02,
+    7.7137939453125000e+01, 1.3169514465332031e+02,
+    5.3004741857876070e-06, 5, -1, 4.5536267089843750e+02,
+    1.6671748352050781e+02, 7.7137939453125000e+01,
+    1.6435108947753906e+02, 6.6928955675393809e-06, 5, -1,
+    4.2799114990234375e+02, 1.7169412231445312e+02,
+    7.7137939453125000e+01, 1.3175140380859375e+02,
+    1.3679531548405066e-05, 5, -1, 4.4292105102539062e+02,
+    1.7169412231445312e+02, 7.7137939453125000e+01,
+    1.3304681396484375e+02, 1.1363204066583421e-05, 5, -1,
+    4.5536267089843750e+02, 1.7169412231445312e+02,
+    7.7137939453125000e+01, 1.6138758850097656e+02,
+    5.5790078477002680e-06, 5, -1, 2.3390213012695312e+02,
+    1.7418243408203125e+02, 7.7137939453125000e+01,
+    3.8970664978027344e+01, 3.0240076739573851e-05, 5, -1,
+    4.3047946166992188e+02, 1.7667076110839844e+02,
+    7.7137939453125000e+01, 1.3214790344238281e+02,
+    2.1580841348622926e-05, 5, -1, 2.2146052551269531e+02,
+    1.7915908813476562e+02, 7.7137939453125000e+01,
+    3.7019947052001953e+01, 7.5273692345945165e-06, 5, -1,
+    3.7075976562500000e+02, 1.8164739990234375e+02,
+    7.7137939453125000e+01, 1.3125227355957031e+02,
+    5.6624201533850282e-05, 5, -1, 4.0061962890625000e+02,
+    1.8164739990234375e+02, 7.7137939453125000e+01,
+    1.3463162231445312e+02, 4.1858620534185320e-06, 5, -1,
+    2.3887878417968750e+02, 1.8413572692871094e+02,
+    7.7137939453125000e+01, 3.1735509872436523e+01,
+    3.9650472899666056e-05, 5, -1, 2.8118023681640625e+02,
+    1.8413572692871094e+02, 7.7137939453125000e+01,
+    2.0970001220703125e+02, 1.2922336463816464e-04, 5, -1,
+    2.9859848022460938e+02, 1.8413572692871094e+02,
+    7.7137939453125000e+01, 2.4328666687011719e+02,
+    6.9899608206469566e-05, 5, -1, 3.9066632080078125e+02,
+    1.8413572692871094e+02, 7.7137939453125000e+01,
+    1.3707704162597656e+02, 1.6777268683654256e-05, 5, -1,
+    4.4540939331054688e+02, 1.8413572692871094e+02,
+    7.7137939453125000e+01, 1.5815367126464844e+02,
+    1.2982178304810077e-05, 5, -1, 4.5536267089843750e+02,
+    1.8413572692871094e+02, 7.7137939453125000e+01,
+    1.7475178527832031e+02, 1.2554182831081562e-05, 5, -1,
+    2.5878533935546875e+02, 1.8662403869628906e+02,
+    7.7137939453125000e+01, 4.8445110321044922e+01,
+    4.2247274905093946e-06, 5, -1, 3.4587655639648438e+02,
+    1.8662403869628906e+02, 7.7137939453125000e+01,
+    8.2881523132324219e+01, 2.5462517442065291e-05, 5, -1,
+    3.8071304321289062e+02, 1.8662403869628906e+02,
+    7.7137939453125000e+01, 1.4153643798828125e+02,
+    8.2163816841784865e-05, 5, -1, 2.1399557495117188e+02,
+    1.8911236572265625e+02, 7.7137939453125000e+01,
+    5.0239482879638672e+01, 1.2338977285253350e-05, 5, -1,
+    2.3639045715332031e+02, 1.8911236572265625e+02,
+    7.7137939453125000e+01, 3.1219198226928711e+01,
+    3.4457923902664334e-05, 5, -1, 2.8118023681640625e+02,
+    1.8911236572265625e+02, 7.7137939453125000e+01,
+    2.1922084045410156e+02, 1.9859880558215082e-04, 5, -1,
+    3.1601672363281250e+02, 1.8911236572265625e+02,
+    7.7137939453125000e+01, 3.2769976806640625e+02,
+    1.6142503227456473e-05, 5, -1, 4.6033929443359375e+02,
+    1.8911236572265625e+02, 7.7137939453125000e+01,
+    1.8894465637207031e+02, 8.4693838289240375e-06, 5, -1,
+    1.8662403869628906e+02, 1.9160069274902344e+02,
+    7.7137939453125000e+01, 1.7272468566894531e+02,
+    8.1482530731591396e-06, 5, -1, 2.7122695922851562e+02,
+    1.9160069274902344e+02, 7.7137939453125000e+01,
+    2.1494735717773438e+02, 1.1194718535989523e-04, 5, -1,
+    3.6080648803710938e+02, 1.9160069274902344e+02,
+    7.7137939453125000e+01, 1.3642045593261719e+02,
+    1.2612304999493062e-05, 5, -1, 3.7075976562500000e+02,
+    1.9160069274902344e+02, 7.7137939453125000e+01,
+    1.4485458374023438e+02, 6.1957871366757900e-05, 5, -1,
+    1.7667076110839844e+02, 1.9408900451660156e+02,
+    7.7137939453125000e+01, 2.0478794860839844e+02,
+    9.5308187155751511e-06, 5, -1, 2.8118023681640625e+02,
+    1.9408900451660156e+02, 7.7137939453125000e+01,
+    2.2132527160644531e+02, 9.3726164777763188e-05, 5, -1,
+    3.4089993286132812e+02, 1.9408900451660156e+02,
+    7.7137939453125000e+01, 4.0407260894775391e+01,
+    2.4164615751942620e-05, 5, -1, 3.8568969726562500e+02,
+    1.9408900451660156e+02, 7.7137939453125000e+01,
+    1.6159391784667969e+02, 5.5399108532583341e-05, 5, -1,
+    4.0310794067382812e+02, 1.9408900451660156e+02,
+    7.7137939453125000e+01, 1.4066461181640625e+02,
+    8.9709119492908940e-06, 5, -1, 2.4883206176757812e+02,
+    1.9657733154296875e+02, 7.7137939453125000e+01,
+    4.5600261688232422e+01, 1.1232156793994363e-05, 5, -1,
+    3.0606344604492188e+02, 1.9657733154296875e+02,
+    7.7137939453125000e+01, 2.9585900878906250e+02,
+    8.4888801211491227e-05, 5, -1, 3.7822473144531250e+02,
+    1.9657733154296875e+02, 7.7137939453125000e+01,
+    1.5543038940429688e+02, 4.3159485358046368e-05, 5, -1,
+    4.4789770507812500e+02, 1.9657733154296875e+02,
+    7.7137939453125000e+01, 1.8660572814941406e+02,
+    1.4130955605651252e-05, 5, -1, 3.1850503540039062e+02,
+    1.9906564331054688e+02, 7.7137939453125000e+01,
+    3.4569003295898438e+02, 3.4311386116314679e-05, 5, -1,
+    2.2394885253906250e+02, 2.0155397033691406e+02,
+    7.7137939453125000e+01, 3.7143825531005859e+01,
+    6.8106783146504313e-05, 5, -1, 2.2892549133300781e+02,
+    2.0155397033691406e+02, 7.7137939453125000e+01,
+    3.4526020050048828e+01, 4.9575952289160341e-05, 5, -1,
+    2.4883206176757812e+02, 2.0155397033691406e+02,
+    7.7137939453125000e+01, 5.2389553070068359e+01,
+    8.8946480900631286e-06, 5, -1, 3.5334152221679688e+02,
+    2.0155397033691406e+02, 7.7137939453125000e+01,
+    9.9422592163085938e+01, 1.5276573321898468e-05, 5, -1,
+    3.7324807739257812e+02, 2.0155397033691406e+02,
+    7.7137939453125000e+01, 1.4623986816406250e+02,
+    2.3909962692414410e-05, 5, -1, 4.0061962890625000e+02,
+    2.0155397033691406e+02, 7.7137939453125000e+01,
+    1.3471783447265625e+02, 2.8636408387683332e-05, 5, -1,
+    2.6625030517578125e+02, 2.0404228210449219e+02,
+    7.7137939453125000e+01, 2.0742164611816406e+02,
+    3.5620265407487750e-05, 5, -1, 2.9113351440429688e+02,
+    2.0404228210449219e+02, 7.7137939453125000e+01,
+    2.4637899780273438e+02, 4.3988271499983966e-05, 5, -1,
+    4.1306121826171875e+02, 2.0404228210449219e+02,
+    7.7137939453125000e+01, 1.3812963867187500e+02,
+    1.0957718586723786e-05, 5, -1, 3.5831817626953125e+02,
+    2.0653060913085938e+02, 7.7137939453125000e+01,
+    1.1081562805175781e+02, 1.9857492588926107e-05, 5, -1,
+    3.7324807739257812e+02, 2.0653060913085938e+02,
+    7.7137939453125000e+01, 1.4475802612304688e+02,
+    4.9932295951293781e-05, 5, -1, 3.9564297485351562e+02,
+    2.0653060913085938e+02, 7.7137939453125000e+01,
+    1.3655833435058594e+02, 5.1550050557125360e-05, 5, -1,
+    2.1150724792480469e+02, 2.0901893615722656e+02,
+    7.7137939453125000e+01, 6.0279426574707031e+01,
+    1.1731166159734130e-04, 5, -1, 2.6873861694335938e+02,
+    2.0901893615722656e+02, 7.7137939453125000e+01,
+    2.0828894042968750e+02, 2.5434548660996370e-05, 5, -1,
+    3.1352838134765625e+02, 2.0901893615722656e+02,
+    7.7137939453125000e+01, 3.2560134887695312e+02,
+    8.7452463048975915e-05, 5, -1, 3.2597000122070312e+02,
+    2.0901893615722656e+02, 7.7137939453125000e+01,
+    3.4744860839843750e+02, 7.5480871601030231e-05, 5, -1,
+    4.0559625244140625e+02, 2.0901893615722656e+02,
+    7.7137939453125000e+01, 1.2785379028320312e+02,
+    3.3201944461325184e-05, 5, -1, 2.8366854858398438e+02,
+    2.1150724792480469e+02, 7.7137939453125000e+01,
+    2.2786392211914062e+02, 2.4857594326022081e-05, 5, -1,
+    3.6578311157226562e+02, 2.1150724792480469e+02,
+    7.7137939453125000e+01, 1.3369325256347656e+02,
+    7.2346556407865137e-05, 5, -1, 2.2394885253906250e+02,
+    2.1399557495117188e+02, 7.7137939453125000e+01,
+    3.3689132690429688e+01, 6.2194721976993605e-06, 5, -1,
+    3.0606344604492188e+02, 2.1399557495117188e+02,
+    7.7137939453125000e+01, 3.1739666748046875e+02,
+    7.6846983574796468e-05, 5, -1, 3.3343496704101562e+02,
+    2.1399557495117188e+02, 7.7137939453125000e+01,
+    3.5704150390625000e+02, 6.9093883212190121e-05, 5, -1,
+    4.5038601684570312e+02, 2.1399557495117188e+02,
+    7.7137939453125000e+01, 1.9400048828125000e+02,
+    9.3738372015650384e-06, 5, -1, 1.9657733154296875e+02,
+    2.1648388671875000e+02, 7.7137939453125000e+01,
+    2.1473482131958008e+01, 1.5483352399314754e-05, 5, -1,
+    2.0901893615722656e+02, 2.1648388671875000e+02,
+    7.7137939453125000e+01, 5.4224456787109375e+01,
+    8.1708472862374038e-05, 5, -1, 4.0061962890625000e+02,
+    2.1648388671875000e+02, 7.7137939453125000e+01,
+    1.3013406372070312e+02, 1.4473112241830677e-04, 5, -1,
+    1.6671748352050781e+02, 2.1897221374511719e+02,
+    7.7137939453125000e+01, 2.3963468933105469e+02,
+    2.1971403839415871e-05, 5, -1, 2.7869189453125000e+02,
+    2.1897221374511719e+02, 7.7137939453125000e+01,
+    1.9905842590332031e+02, 2.9114913559169509e-05, 5, -1,
+    3.7573641967773438e+02, 2.1897221374511719e+02,
+    7.7137939453125000e+01, 1.5876918029785156e+02,
+    8.5916624811943620e-05, 5, -1, 2.9362182617187500e+02,
+    2.2146052551269531e+02, 7.7137939453125000e+01,
+    2.3833569335937500e+02, 2.6586776584736072e-05, 5, -1,
+    3.9066632080078125e+02, 2.2146052551269531e+02,
+    7.7137939453125000e+01, 1.3815921020507812e+02,
+    2.5434166673221625e-05, 5, -1, 1.6174084472656250e+02,
+    2.2394885253906250e+02, 7.7137939453125000e+01,
+    2.4707710266113281e+02, 2.0901265088468790e-05, 5, -1,
+    1.7667076110839844e+02, 2.2394885253906250e+02,
+    7.7137939453125000e+01, 2.7145523071289062e+02,
+    2.1119800294400193e-05, 5, -1, 2.0404228210449219e+02,
+    2.2394885253906250e+02, 7.7137939453125000e+01,
+    1.6870582580566406e+01, 4.1039846109924838e-05, 5, -1,
+    2.6625030517578125e+02, 2.2394885253906250e+02,
+    7.7137939453125000e+01, 2.0216380310058594e+02,
+    3.7470570532605052e-05, 5, -1, 3.6827145385742188e+02,
+    2.2394885253906250e+02, 7.7137939453125000e+01,
+    1.8738142395019531e+02, 2.2557818738278002e-05, 5, -1,
+    2.7620358276367188e+02, 2.2643717956542969e+02,
+    7.7137939453125000e+01, 1.8694271850585938e+02,
+    1.1936650116695091e-04, 5, -1, 2.9113351440429688e+02,
+    2.2643717956542969e+02, 7.7137939453125000e+01,
+    1.7213134765625000e+02, 4.2291445424780250e-05, 5, -1,
+    4.3296777343750000e+02, 2.2643717956542969e+02,
+    7.7137939453125000e+01, 1.9541511535644531e+02,
+    9.0523735707392916e-06, 5, -1, 4.0310794067382812e+02,
+    2.2892549133300781e+02, 7.7137939453125000e+01,
+    1.7500773620605469e+02, 1.1040917161153629e-04, 5, -1,
+    1.4929924011230469e+02, 2.3141381835937500e+02,
+    7.7137939453125000e+01, 1.7507424926757812e+02,
+    2.7419215257395990e-05, 5, -1, 2.3141381835937500e+02,
+    2.3141381835937500e+02, 7.7137939453125000e+01,
+    3.2710351562500000e+02, -8.1491816672496498e-06, 5, -1,
+    2.6625030517578125e+02, 2.3141381835937500e+02,
+    7.7137939453125000e+01, 2.0649023437500000e+02,
+    2.1746958373114467e-04, 5, -1, 1.6422915649414062e+02,
+    2.3390213012695312e+02, 7.7137939453125000e+01,
+    1.7772727966308594e+02, 3.5036737244809046e-05, 5, -1,
+    1.7169412231445312e+02, 2.3390213012695312e+02,
+    7.7137939453125000e+01, 1.9064360046386719e+02,
+    3.0996503483038396e-05, 5, -1, 2.1897221374511719e+02,
+    2.3390213012695312e+02, 7.7137939453125000e+01,
+    3.4960656738281250e+02, 1.7248759832000360e-05, 5, -1,
+    1.5427587890625000e+02, 2.3639045715332031e+02,
+    7.7137939453125000e+01, 1.3794570922851562e+02,
+    2.2869757231092080e-05, 5, -1, 1.8164739990234375e+02,
+    2.3639045715332031e+02, 7.7137939453125000e+01,
+    3.6395565032958984e+01, 3.3740907383617014e-05, 5, -1,
+    2.3887878417968750e+02, 2.3639045715332031e+02,
+    7.7137939453125000e+01, 2.4034054565429688e+02,
+    3.9128212847572286e-06, 5, -1, 3.0855175781250000e+02,
+    2.3639045715332031e+02, 7.7137939453125000e+01,
+    8.7288637161254883e+00, 5.2628827688749880e-05, 5, -1,
+    3.9813128662109375e+02, 2.3639045715332031e+02,
+    7.7137939453125000e+01, 2.0346578979492188e+02,
+    1.3132319145370275e-04, 5, -1, 4.3545611572265625e+02,
+    2.3639045715332031e+02, 7.7137939453125000e+01,
+    2.0534234619140625e+02, 1.7100961485994048e-05, 5, -1,
+    2.0901893615722656e+02, 2.3887878417968750e+02,
+    7.7137939453125000e+01, 9.5119466781616211e+00,
+    1.2348833479336463e-05, 5, -1, 2.2892549133300781e+02,
+    2.3887878417968750e+02, 7.7137939453125000e+01,
+    2.9199789428710938e+02, 4.7572539187967777e-06, 5, -1,
+    2.5132037353515625e+02, 2.3887878417968750e+02,
+    7.7137939453125000e+01, 2.1604542541503906e+02,
+    1.6687670722603798e-05, 5, -1, 2.9362182617187500e+02,
+    2.3887878417968750e+02, 7.7137939453125000e+01,
+    1.3522225952148438e+02, 7.0502828748431057e-05, 5, -1,
+    3.3343496704101562e+02, 2.3887878417968750e+02,
+    7.7137939453125000e+01, 3.2394296264648438e+02,
+    3.2217148691415787e-04, 5, -1, 3.6578311157226562e+02,
+    2.3887878417968750e+02, 7.7137939453125000e+01,
+    2.6596740722656250e+02, 4.8146455810638145e-05, 5, -1,
+    1.7915908813476562e+02, 2.4136709594726562e+02,
+    7.7137939453125000e+01, 6.6567886352539062e+01,
+    4.2655236029531807e-05, 5, -1, 2.4634373474121094e+02,
+    2.4136709594726562e+02, 7.7137939453125000e+01,
+    2.1622283935546875e+02, -1.2617893844435457e-05, 5, -1,
+    2.6127365112304688e+02, 2.4136709594726562e+02,
+    7.7137939453125000e+01, 2.0107571411132812e+02,
+    2.3720784520264715e-04, 5, -1, 4.3794442749023438e+02,
+    2.4136709594726562e+02, 7.7137939453125000e+01,
+    2.0594493103027344e+02, 1.5177669411059469e-05, 5, -1,
+    1.3685763549804688e+02, 2.4385542297363281e+02,
+    7.7137939453125000e+01, 1.1778451538085938e+02,
+    2.5260789698222652e-05, 5, -1, 2.6873861694335938e+02,
+    2.4385542297363281e+02, 7.7137939453125000e+01,
+    1.8582881164550781e+02, 1.7371203284710646e-04, 5, -1,
+    3.5831817626953125e+02, 2.4385542297363281e+02,
+    7.7137939453125000e+01, 2.9561968994140625e+02,
+    3.6795659980271012e-05, 5, -1, 3.0357510375976562e+02,
+    2.4634373474121094e+02, 7.7137939453125000e+01,
+    3.6473453521728516e+01, 1.3825247879140079e-04, 5, -1,
+    3.7822473144531250e+02, 2.4634373474121094e+02,
+    7.7137939453125000e+01, 2.3889241027832031e+02,
+    3.3977517887251452e-05, 5, -1, 3.8817800903320312e+02,
+    2.4634373474121094e+02, 7.7137939453125000e+01,
+    2.3319645690917969e+02, 1.6147072528838180e-05, 5, -1,
+    1.4183427429199219e+02, 2.4883206176757812e+02,
+    7.7137939453125000e+01, 1.1497075653076172e+02,
+    4.2086197936441749e-05, 5, -1, 1.4929924011230469e+02,
+    2.4883206176757812e+02, 7.7137939453125000e+01,
+    1.1548412322998047e+02, 8.2946135080419481e-06, 5, -1,
+    3.1601672363281250e+02, 2.4883206176757812e+02,
+    7.7137939453125000e+01, 1.0445798873901367e+01,
+    4.2482995922910050e-05, 5, -1, 3.2845831298828125e+02,
+    2.4883206176757812e+02, 7.7137939453125000e+01,
+    3.4651492309570312e+02, 9.4376817287411541e-05, 5, -1,
+    3.7075976562500000e+02, 2.4883206176757812e+02,
+    7.7137939453125000e+01, 2.4607476806640625e+02,
+    6.3706560467835516e-05, 5, -1, 1.6422915649414062e+02,
+    2.5132037353515625e+02, 7.7137939453125000e+01,
+    9.8934585571289062e+01, 2.4669676349731162e-05, 5, -1,
+    1.7667076110839844e+02, 2.5132037353515625e+02,
+    7.7137939453125000e+01, 8.3487083435058594e+01,
+    1.8278145944350399e-05, 5, -1, 1.9657733154296875e+02,
+    2.5132037353515625e+02, 7.7137939453125000e+01,
+    7.1735778808593750e+01, 1.3091670552967116e-05, 5, -1,
+    3.0108679199218750e+02, 2.5132037353515625e+02,
+    7.7137939453125000e+01, 6.7639732360839844e+01,
+    7.9192483099177480e-05, 5, -1, 3.5085321044921875e+02,
+    2.5132037353515625e+02, 7.7137939453125000e+01,
+    3.0301965332031250e+02, 1.9981171135441400e-05, 5, -1,
+    1.3188099670410156e+02, 2.5380870056152344e+02,
+    7.7137939453125000e+01, 9.4124496459960938e+01,
+    1.4049214951228350e-04, 5, -1, 3.1352838134765625e+02,
+    2.5380870056152344e+02, 7.7137939453125000e+01,
+    3.0222204208374023e+01, 3.3227734093088657e-05, 5, -1,
+    1.4681091308593750e+02, 2.5629702758789062e+02,
+    7.7137939453125000e+01, 1.1072020721435547e+02,
+    4.0347418689634651e-05, 5, -1, 1.6422915649414062e+02,
+    2.5629702758789062e+02, 7.7137939453125000e+01,
+    9.6357940673828125e+01, 2.7221658456255682e-05, 5, -1,
+    1.9408900451660156e+02, 2.5878533935546875e+02,
+    7.7137939453125000e+01, 8.2785255432128906e+01,
+    1.3981318261357956e-05, 5, -1, 2.2394885253906250e+02,
+    2.5878533935546875e+02, 7.7137939453125000e+01,
+    1.0036559295654297e+02, 7.4284489528508857e-06, 5, -1,
+    2.3639045715332031e+02, 2.6127365112304688e+02,
+    7.7137939453125000e+01, 1.0770463562011719e+02,
+    1.3054103874310385e-05, 5, -1, 3.6080648803710938e+02,
+    2.6127365112304688e+02, 7.7137939453125000e+01,
+    2.5411868286132812e+02, 7.4573085839801934e-06, 5, -1,
+    1.8164739990234375e+02, 2.6376199340820312e+02,
+    7.7137939453125000e+01, 8.6304222106933594e+01,
+    -3.4543481319815328e-07, 5, -1, 4.2799114990234375e+02,
+    2.6376199340820312e+02, 7.7137939453125000e+01,
+    2.0346151733398438e+02, 1.3181520444049966e-05, 5, -1,
+    3.9813128662109375e+02, 2.6625030517578125e+02,
+    7.7137939453125000e+01, 2.1393836975097656e+02,
+    3.9290367567446083e-05, 5, -1, 2.7371527099609375e+02,
+    2.6873861694335938e+02, 7.7137939453125000e+01,
+    1.0193054962158203e+02, 4.7735770749568474e-06, 5, -1,
+    4.0808456420898438e+02, 2.6873861694335938e+02,
+    7.7137939453125000e+01, 1.9660813903808594e+02,
+    2.6651438020053320e-05, 5, -1, 4.2550280761718750e+02,
+    2.6873861694335938e+02, 7.7137939453125000e+01,
+    2.0012605285644531e+02, 2.6422774681122974e-05, 5, -1,
+    1.2441603088378906e+02, 2.7122695922851562e+02,
+    7.7137939453125000e+01, 5.3756458282470703e+01,
+    6.8443073359958362e-06, 5, -1, 3.2099334716796875e+02,
+    2.7371527099609375e+02, 7.7137939453125000e+01,
+    9.6787796020507812e+01, 1.1524439287313726e-05, 5, -1,
+    3.5831817626953125e+02, 2.7371527099609375e+02,
+    7.7137939453125000e+01, 1.2116638183593750e+02,
+    6.4812466007424518e-06, 5, -1, 3.7075976562500000e+02,
+    2.7371527099609375e+02, 7.7137939453125000e+01,
+    1.2251750946044922e+02, 1.2483106729632709e-05, 5, -1,
+    3.7573641967773438e+02, 2.7869189453125000e+02,
+    7.7137939453125000e+01, 1.0891815185546875e+02,
+    5.5918691941769794e-05, 5, -1, 3.5334152221679688e+02,
+    2.8366854858398438e+02, 7.7137939453125000e+01,
+    1.0762493133544922e+02, 1.2809329746232834e-05, 5, -1,
+    1.4183427429199219e+02, 2.8615686035156250e+02,
+    7.7137939453125000e+01, 7.5043014526367188e+01,
+    4.0601662476547062e-06, 5, -1, 2.2146052551269531e+02,
+    2.8615686035156250e+02, 7.7137939453125000e+01,
+    9.8187705993652344e+01, 1.0555714879956213e-06, 5, -1,
+    3.9066632080078125e+02, 2.8615686035156250e+02,
+    7.7137939453125000e+01, 1.0809831237792969e+02,
+    2.6877183699980378e-05, 5, -1, 4.0310794067382812e+02,
+    2.8615686035156250e+02, 7.7137939453125000e+01,
+    1.2005610656738281e+02, 1.4949231626815163e-05, 5, -1,
+    1.2690435028076172e+02, 2.8864520263671875e+02,
+    7.7137939453125000e+01, 1.4150213241577148e+01,
+    1.1228230505366810e-06, 5, -1, 1.6174084472656250e+02,
+    2.8864520263671875e+02, 7.7137939453125000e+01,
+    1.2545884704589844e+02, 8.8774031610228121e-06, 5, -1,
+    4.2052618408203125e+02, 2.8864520263671875e+02,
+    7.7137939453125000e+01, 1.4499311828613281e+02,
+    7.5631633080774918e-06, 5, -1, 3.8071304321289062e+02,
+    2.9113351440429688e+02, 7.7137939453125000e+01,
+    1.0635705566406250e+02, 4.6602057409472764e-05, 5, -1,
+    3.9813128662109375e+02, 2.9362182617187500e+02,
+    7.7137939453125000e+01, 1.1198156738281250e+02,
+    3.4012035030173138e-05, 5, -1, 1.6671748352050781e+02,
+    2.9611013793945312e+02, 7.7137939453125000e+01,
+    2.1314688110351562e+02, 3.6652803828474134e-05, 5, -1,
+    1.7915908813476562e+02, 2.9611013793945312e+02,
+    7.7137939453125000e+01, 3.1407916259765625e+02,
+    6.9870802690275013e-05, 5, -1, 2.8615686035156250e+02,
+    2.9611013793945312e+02, 7.7137939453125000e+01,
+    1.0899887084960938e+02, 6.1615611457455088e-07, 5, -1,
+    4.1803787231445312e+02, 2.9611013793945312e+02,
+    7.7137939453125000e+01, 1.4079525756835938e+02,
+    5.8227324188919738e-05, 5, -1, 1.8662403869628906e+02,
+    3.0357510375976562e+02, 7.7137939453125000e+01,
+    2.8675924682617188e+02, 5.6494696764275432e-05, 5, -1,
+    4.2799114990234375e+02, 3.0606344604492188e+02,
+    7.7137939453125000e+01, 1.6044738769531250e+02,
+    6.7633292928803712e-05, 5, -1, 1.7169412231445312e+02,
+    3.0855175781250000e+02, 7.7137939453125000e+01,
+    2.5490438842773438e+02, 2.2489328330266289e-05, 5, -1,
+    4.2301449584960938e+02, 3.0855175781250000e+02,
+    7.7137939453125000e+01, 1.5727479553222656e+02,
+    1.6573144239373505e-04, 5, -1, 1.8662403869628906e+02,
+    3.1104006958007812e+02, 7.7137939453125000e+01,
+    2.8457412719726562e+02, 2.6619714844855480e-05, 5, -1,
+    1.3188099670410156e+02, 3.1352838134765625e+02,
+    7.7137939453125000e+01, 3.2578430175781250e+02,
+    2.2077272205933696e-06, 5, -1, 2.9113351440429688e+02,
+    3.1352838134765625e+02, 7.7137939453125000e+01,
+    1.3443756103515625e+02, 4.9126821977552027e-05, 5, -1,
+    1.7169412231445312e+02, 3.1601672363281250e+02,
+    7.7137939453125000e+01, 2.5228332519531250e+02,
+    5.3266253416950349e-06, 5, -1, 2.0404228210449219e+02,
+    3.1601672363281250e+02, 7.7137939453125000e+01,
+    3.0655065917968750e+02, 3.5021184885408729e-05, 5, -1,
+    2.1150724792480469e+02, 3.1601672363281250e+02,
+    7.7137939453125000e+01, 3.0109399414062500e+02,
+    -8.7486597522001830e-07, 5, -1, 2.1648388671875000e+02,
+    3.1850503540039062e+02, 7.7137939453125000e+01,
+    2.9622573852539062e+02, 2.0591514839907177e-05, 5, -1,
+    4.1554953002929688e+02, 3.1850503540039062e+02,
+    7.7137939453125000e+01, 1.5485859680175781e+02,
+    1.0869909601751715e-05, 5, -1, 2.1150724792480469e+02,
+    3.2099334716796875e+02, 7.7137939453125000e+01,
+    2.9925985717773438e+02, 3.6974699469283223e-05, 5, -1,
+    2.3141381835937500e+02, 3.2099334716796875e+02,
+    7.7137939453125000e+01, 2.9314746093750000e+02,
+    1.1033715964003932e-05, 5, -1, 2.8118023681640625e+02,
+    3.2099334716796875e+02, 7.7137939453125000e+01,
+    2.7036672973632812e+02, 7.6130156230647117e-05, 5, -1,
+    2.8864520263671875e+02, 3.2099334716796875e+02,
+    7.7137939453125000e+01, 2.5718341064453125e+02,
+    8.8314191089011729e-05, 5, -1, 3.2845831298828125e+02,
+    3.2099334716796875e+02, 7.7137939453125000e+01,
+    5.9527168273925781e+01, 3.0233434245019453e-06, 5, -1,
+    1.4929924011230469e+02, 3.2348168945312500e+02,
+    7.7137939453125000e+01, 2.5629904174804688e+02,
+    2.8605927582248114e-06, 5, -1, 2.9611013793945312e+02,
+    3.2348168945312500e+02, 7.7137939453125000e+01,
+    2.6235574340820312e+02, 1.3015206786803901e-04, 5, -1,
+    3.0606344604492188e+02, 3.2348168945312500e+02,
+    7.7137939453125000e+01, 2.9180697631835938e+02,
+    5.0256501708645374e-05, 5, -1, 3.1601672363281250e+02,
+    3.2348168945312500e+02, 7.7137939453125000e+01,
+    1.7675979614257812e+01, 2.6663403332349844e-05, 5, -1,
+    1.6671748352050781e+02, 3.2597000122070312e+02,
+    7.7137939453125000e+01, 2.3903178405761719e+02,
+    2.4081104129436426e-05, 5, -1, 1.7418243408203125e+02,
+    3.2597000122070312e+02, 7.7137939453125000e+01,
+    2.5197834777832031e+02, 4.1613639041315764e-05, 5, -1,
+    2.4136709594726562e+02, 3.2597000122070312e+02,
+    7.7137939453125000e+01, 2.9543963623046875e+02,
+    -5.1038434321526438e-05, 5, -1, 2.7122695922851562e+02,
+    3.2597000122070312e+02, 7.7137939453125000e+01,
+    2.8166659545898438e+02, 5.8793695643544197e-05, 5, -1,
+    2.8615686035156250e+02, 3.2597000122070312e+02,
+    7.7137939453125000e+01, 2.7441485595703125e+02,
+    1.6618585505057126e-04, 5, -1, 3.7324807739257812e+02,
+    3.2597000122070312e+02, 7.7137939453125000e+01,
+    1.3143617248535156e+02, 3.7592180888168514e-05, 5, -1,
+    1.9906564331054688e+02, 3.2845831298828125e+02,
+    7.7137939453125000e+01, 2.9233508300781250e+02,
+    2.1105888663441874e-05, 5, -1, 2.5878533935546875e+02,
+    3.2845831298828125e+02, 7.7137939453125000e+01,
+    2.9016943359375000e+02, 8.4997198428027332e-05, 5, -1,
+    3.3592327880859375e+02, 3.2845831298828125e+02,
+    7.7137939453125000e+01, 3.5381063842773438e+02,
+    2.9184579943830613e-06, 5, -1, 4.0061962890625000e+02,
+    3.2845831298828125e+02, 7.7137939453125000e+01,
+    1.5384860229492188e+02, 9.0278917923569679e-06, 5, -1,
+    1.3685763549804688e+02, 3.3094662475585938e+02,
+    7.7137939453125000e+01, 3.0962115478515625e+02,
+    1.1932685993087944e-05, 5, -1, 2.0653060913085938e+02,
+    3.3094662475585938e+02, 7.7137939453125000e+01,
+    2.9026904296875000e+02, 2.3041086024022661e-05, 5, -1,
+    2.2643717956542969e+02, 3.3094662475585938e+02,
+    7.7137939453125000e+01, 2.8939086914062500e+02,
+    1.7658696378930472e-05, 5, -1, 2.3390213012695312e+02,
+    3.3094662475585938e+02, 7.7137939453125000e+01,
+    2.9296005249023438e+02, 1.8913406165665947e-05, 5, -1,
+    2.1648388671875000e+02, 3.3343496704101562e+02,
+    7.7137939453125000e+01, 2.8685900878906250e+02,
+    1.7856738850241527e-05, 5, -1, 3.7075976562500000e+02,
+    3.3343496704101562e+02, 7.7137939453125000e+01,
+    2.1458245849609375e+02, 5.2452400268521160e-05, 5, -1,
+    2.5629702758789062e+02, 3.3592327880859375e+02,
+    7.7137939453125000e+01, 2.9125537109375000e+02,
+    4.5669145038118586e-05, 5, -1, 2.9113351440429688e+02,
+    3.3592327880859375e+02, 7.7137939453125000e+01,
+    2.8439968872070312e+02, 1.6050841077230871e-04, 5, -1,
+    3.1601672363281250e+02, 3.3592327880859375e+02,
+    7.7137939453125000e+01, 3.0650421142578125e+02,
+    2.1397499949671328e-05, 5, -1, 4.0061962890625000e+02,
+    3.3592327880859375e+02, 7.7137939453125000e+01,
+    1.7875025939941406e+02, 4.4921725930180401e-06, 5, -1,
+    4.1803787231445312e+02, 3.3592327880859375e+02,
+    7.7137939453125000e+01, 1.7388908386230469e+02,
+    2.9644145342899719e-06, 5, -1, 2.6873861694335938e+02,
+    3.4089993286132812e+02, 7.7137939453125000e+01,
+    2.9062536621093750e+02, 2.8116121029597707e-05, 5, -1,
+    2.7620358276367188e+02, 3.4338824462890625e+02,
+    7.7137939453125000e+01, 2.8967620849609375e+02,
+    2.4678211048012599e-05, 5, -1, 3.1352838134765625e+02,
+    3.4338824462890625e+02, 7.7137939453125000e+01,
+    2.9492700195312500e+02, 2.1289912183419801e-05, 5, -1,
+    4.0061962890625000e+02, 3.4587655639648438e+02,
+    7.7137939453125000e+01, 1.9805145263671875e+02,
+    4.7477597036049701e-06, 5, -1, 3.1850503540039062e+02,
+    3.4836486816406250e+02, 7.7137939453125000e+01,
+    2.8796676635742188e+02, 3.2117659429786727e-05, 5, -1,
+    3.4089993286132812e+02, 3.4836486816406250e+02,
+    7.7137939453125000e+01, 2.8028903198242188e+02,
+    1.2535750101960730e-05, 5, -1, 3.5831817626953125e+02,
+    3.4836486816406250e+02, 7.7137939453125000e+01,
+    2.7417578125000000e+02, 5.4360621106752660e-06, 5, -1,
+    4.0061962890625000e+02, 3.5085321044921875e+02,
+    7.7137939453125000e+01, 2.0920272827148438e+02,
+    3.5832777030009311e-06, 5, -1, 4.1803787231445312e+02,
+    3.5831817626953125e+02, 7.7137939453125000e+01,
+    1.8839714050292969e+02, 2.5364436169184046e-06, 5, -1,
+    3.8071304321289062e+02, 3.6080648803710938e+02,
+    7.7137939453125000e+01, 2.6584020996093750e+02,
+    8.1108983067679219e-06, 5, -1, 3.2845831298828125e+02,
+    3.6578311157226562e+02, 7.7137939453125000e+01,
+    2.7530700683593750e+02, 1.6162850897671888e-06, 5, -1,
+    3.7822473144531250e+02, 3.6578311157226562e+02,
+    7.7137939453125000e+01, 2.6986059570312500e+02,
+    7.7802633313694969e-06, 5, -1, 4.0061962890625000e+02,
+    3.6578311157226562e+02, 7.7137939453125000e+01,
+    2.3698709106445312e+02, 1.0784811820485629e-05, 5, -1,
+    4.2550280761718750e+02, 3.8071304321289062e+02,
+    7.7137939453125000e+01, 1.8442039489746094e+02,
+    3.4529504773672670e-05, 5, -1, 2.1200491333007812e+02,
+    1.3735530090332031e+02, 9.2565528869628906e+01,
+    1.4520652770996094e+02, 1.9513061488396488e-05, 6, -1,
+    2.4485075378417969e+02, 1.4929924011230469e+02,
+    9.2565528869628906e+01, 6.2168498992919922e+01,
+    1.4181376172928140e-05, 6, -1, 2.1797689819335938e+02,
+    1.5825720214843750e+02, 9.2565528869628906e+01,
+    7.3200439453125000e+01, 8.0845620686886832e-06, 6, -1,
+    3.5234619140625000e+02, 1.6124317932128906e+02,
+    9.2565528869628906e+01, 1.0692942047119141e+02,
+    8.1166598420168157e-07, 6, -1, 1.9707499694824219e+02,
+    1.6422915649414062e+02, 9.2565528869628906e+01,
+    1.7712597656250000e+02, 3.8142476114444435e-05, 6, -1,
+    2.0304696655273438e+02, 1.6422915649414062e+02,
+    9.2565528869628906e+01, 1.5854774475097656e+02,
+    3.1642564863432199e-05, 6, -1, 3.7922006225585938e+02,
+    1.6422915649414062e+02, 9.2565528869628906e+01,
+    1.2673857116699219e+02, 1.3078033589408733e-06, 6, -1,
+    4.0907992553710938e+02, 1.6422915649414062e+02,
+    9.2565528869628906e+01, 1.3021153259277344e+02,
+    3.4494917144911597e-06, 6, -1, 4.3595379638671875e+02,
+    1.6422915649414062e+02, 9.2565528869628906e+01,
+    1.3481396484375000e+02, 1.1361547876731493e-05, 6, -1,
+    4.7775756835937500e+02, 1.6422915649414062e+02,
+    9.2565528869628906e+01, 2.1490136718750000e+02,
+    9.4510214694309980e-06, 6, -1, 4.2400982666015625e+02,
+    1.7020114135742188e+02, 9.2565528869628906e+01,
+    1.2962670898437500e+02, 1.0208943422185257e-05, 6, -1,
+    4.5386968994140625e+02, 1.7020114135742188e+02,
+    9.2565528869628906e+01, 1.6765437316894531e+02,
+    3.5172076877643121e-06, 6, -1, 4.6879962158203125e+02,
+    1.7020114135742188e+02, 9.2565528869628906e+01,
+    2.0070086669921875e+02, 1.1286398148513399e-05, 6, -1,
+    2.2992083740234375e+02, 1.7617309570312500e+02,
+    9.2565528869628906e+01, 4.6338352203369141e+01,
+    3.3328346034977585e-05, 6, -1, 1.8513105773925781e+02,
+    1.7915908813476562e+02, 9.2565528869628906e+01,
+    1.7324281311035156e+02, 9.0060839283978567e-06, 6, -1,
+    4.2998181152343750e+02, 1.7915908813476562e+02,
+    9.2565528869628906e+01, 1.3602102661132812e+02,
+    2.1618172468151897e-05, 6, -1, 2.3887878417968750e+02,
+    1.8214508056640625e+02, 9.2565528869628906e+01,
+    5.0336521148681641e+01, 2.8699985705316067e-05, 6, -1,
+    2.9859848022460938e+02, 1.8214508056640625e+02,
+    9.2565528869628906e+01, 1.9669416809082031e+02,
+    6.3673374825157225e-05, 6, -1, 3.7026211547851562e+02,
+    1.8214508056640625e+02, 9.2565528869628906e+01,
+    1.3222097778320312e+02, 3.6934947274858132e-05, 6, -1,
+    3.4637423706054688e+02, 1.8513105773925781e+02,
+    9.2565528869628906e+01, 1.0831694793701172e+02,
+    1.1533203178260010e-05, 6, -1, 3.8220605468750000e+02,
+    1.8513105773925781e+02, 9.2565528869628906e+01,
+    1.4159339904785156e+02, 4.8505982704227790e-05, 6, -1,
+    4.3595379638671875e+02, 1.8513105773925781e+02,
+    9.2565528869628906e+01, 1.5670779418945312e+02,
+    1.4005146113049705e-05, 6, -1, 2.8068255615234375e+02,
+    1.8811703491210938e+02, 9.2565528869628906e+01,
+    1.9504426574707031e+02, 1.6920705093070865e-04, 6, -1,
+    1.8513105773925781e+02, 1.9110302734375000e+02,
+    9.2565528869628906e+01, 1.4691613769531250e+02,
+    7.1972494879446458e-06, 6, -1, 2.1499090576171875e+02,
+    1.9110302734375000e+02, 9.2565528869628906e+01,
+    5.0245059967041016e+01, 1.8935701518785208e-05, 6, -1,
+    2.3290681457519531e+02, 1.9110302734375000e+02,
+    9.2565528869628906e+01, 4.6847446441650391e+01,
+    9.1487054305616766e-05, 6, -1, 3.1352841186523438e+02,
+    1.9110302734375000e+02, 9.2565528869628906e+01,
+    2.8720405101776123e+00, 1.8689141143113375e-05, 6, -1,
+    4.5685568237304688e+02, 1.9110302734375000e+02,
+    9.2565528869628906e+01, 1.8827047729492188e+02,
+    7.0983578552841209e-06, 6, -1, 2.2693484497070312e+02,
+    1.9408901977539062e+02, 9.2565528869628906e+01,
+    3.9339847564697266e+01, 9.4828385044820607e-05, 6, -1,
+    2.6873864746093750e+02, 1.9408901977539062e+02,
+    9.2565528869628906e+01, 1.9704142761230469e+02,
+    5.7580738939577714e-05, 6, -1, 2.9262652587890625e+02,
+    1.9408901977539062e+02, 9.2565528869628906e+01,
+    2.3015715026855469e+02, 1.2086202332284302e-04, 6, -1,
+    3.4040228271484375e+02, 1.9408901977539062e+02,
+    9.2565528869628906e+01, 7.2664237976074219e+01,
+    1.3024759937252384e-05, 6, -1, 3.8519204711914062e+02,
+    1.9408901977539062e+02, 9.2565528869628906e+01,
+    1.4121974182128906e+02, 3.1628507713321596e-05, 6, -1,
+    3.0457043457031250e+02, 1.9707499694824219e+02,
+    9.2565528869628906e+01, 2.8840805053710938e+02,
+    7.7189790317788720e-05, 6, -1, 4.4491174316406250e+02,
+    1.9707499694824219e+02, 9.2565528869628906e+01,
+    1.8461872863769531e+02, 1.4852551430521999e-05, 6, -1,
+    2.2394885253906250e+02, 2.0006097412109375e+02,
+    9.2565528869628906e+01, 3.0403276443481445e+01,
+    4.2151641537202522e-05, 6, -1, 1.6721514892578125e+02,
+    2.0304696655273438e+02, 9.2565528869628906e+01,
+    2.2026036071777344e+02, 6.4689206737966742e-06, 6, -1,
+    2.8964053344726562e+02, 2.0304696655273438e+02,
+    9.2565528869628906e+01, 2.4373690795898438e+02,
+    5.9226415032753721e-05, 6, -1, 4.0012194824218750e+02,
+    2.0304696655273438e+02, 9.2565528869628906e+01,
+    1.4339321899414062e+02, 2.4453636797261424e-05, 6, -1,
+    2.9859848022460938e+02, 2.0603295898437500e+02,
+    9.2565528869628906e+01, 2.7119705200195312e+02,
+    7.7433192927855998e-05, 6, -1, 3.5831817626953125e+02,
+    2.0603295898437500e+02, 9.2565528869628906e+01,
+    1.2062747955322266e+02, 2.2144216927699745e-05, 6, -1,
+    3.7026211547851562e+02, 2.0603295898437500e+02,
+    9.2565528869628906e+01, 1.4201295471191406e+02,
+    2.4571789253968745e-05, 6, -1, 2.1200491333007812e+02,
+    2.0901893615722656e+02, 9.2565528869628906e+01,
+    3.7803043365478516e+01, 6.4894280512817204e-05, 6, -1,
+    2.6575265502929688e+02, 2.0901893615722656e+02,
+    9.2565528869628906e+01, 2.2406019592285156e+02,
+    1.1615488801908214e-05, 6, -1, 3.1352841186523438e+02,
+    2.0901893615722656e+02, 9.2565528869628906e+01,
+    3.2276696777343750e+02, 6.6446715209167451e-05, 6, -1,
+    3.2547235107421875e+02, 2.0901893615722656e+02,
+    9.2565528869628906e+01, 3.4439492797851562e+02,
+    3.5105218557873741e-05, 6, -1, 4.0310794067382812e+02,
+    2.0901893615722656e+02, 9.2565528869628906e+01,
+    1.4920210266113281e+02, 4.4646916649071500e-05, 6, -1,
+    2.8665454101562500e+02, 2.1200491333007812e+02,
+    9.2565528869628906e+01, 2.3533064270019531e+02,
+    4.4210028136149049e-05, 6, -1, 3.3144430541992188e+02,
+    2.1200491333007812e+02, 9.2565528869628906e+01,
+    3.4406301879882812e+02, 3.8096884964033961e-05, 6, -1,
+    2.0603295898437500e+02, 2.1499090576171875e+02,
+    9.2565528869628906e+01, 2.9001649856567383e+01,
+    6.5994790929835290e-05, 6, -1, 3.6130416870117188e+02,
+    2.1499090576171875e+02, 9.2565528869628906e+01,
+    1.6270349121093750e+02, 3.6220928450347856e-05, 6, -1,
+    4.4789770507812500e+02, 2.1499090576171875e+02,
+    9.2565528869628906e+01, 1.9445053100585938e+02,
+    3.9727665352984332e-06, 6, -1, 1.9707499694824219e+02,
+    2.1797689819335938e+02, 9.2565528869628906e+01,
+    1.2240897178649902e+01, 2.6834881282411516e-05, 6, -1,
+    2.7769659423828125e+02, 2.1797689819335938e+02,
+    9.2565528869628906e+01, 2.1613430786132812e+02,
+    3.0745763069717214e-05, 6, -1, 3.7623406982421875e+02,
+    2.1797689819335938e+02, 9.2565528869628906e+01,
+    1.6106988525390625e+02, 4.3893320253118873e-05, 6, -1,
+    4.0012194824218750e+02, 2.1797689819335938e+02,
+    9.2565528869628906e+01, 1.6322207641601562e+02,
+    9.9079115898348391e-05, 6, -1, 2.9561248779296875e+02,
+    2.2096287536621094e+02, 9.2565528869628906e+01,
+    2.5179516601562500e+02, 2.0304965801187791e-05, 6, -1,
+    2.0304696655273438e+02, 2.2394885253906250e+02,
+    9.2565528869628906e+01, 1.4537775993347168e+01,
+    4.0031194657785818e-05, 6, -1, 3.6727612304687500e+02,
+    2.2394885253906250e+02, 9.2565528869628906e+01,
+    1.9096165466308594e+02, 1.1072939742007293e-05, 6, -1,
+    4.3296780395507812e+02, 2.2394885253906250e+02,
+    9.2565528869628906e+01, 1.9064242553710938e+02,
+    7.2548205025668722e-06, 6, -1, 1.7617309570312500e+02,
+    2.2693484497070312e+02, 9.2565528869628906e+01,
+    1.7505195617675781e+01, 2.0675701307482086e-05, 6, -1,
+    2.7471060180664062e+02, 2.2693484497070312e+02,
+    9.2565528869628906e+01, 1.9501597595214844e+02,
+    1.3700406998395920e-04, 6, -1, 1.4929924011230469e+02,
+    2.2992083740234375e+02, 9.2565528869628906e+01,
+    1.3091015625000000e+02, 2.9149776310077868e-05, 6, -1,
+    2.9561248779296875e+02, 2.2992083740234375e+02,
+    9.2565528869628906e+01, 1.5235168457031250e+02,
+    5.7091096095973626e-05, 6, -1, 1.7020114135742188e+02,
+    2.3290681457519531e+02, 9.2565528869628906e+01,
+    9.8064712524414062e+01, 3.5329798265593126e-05, 6, -1,
+    2.6276666259765625e+02, 2.3290681457519531e+02,
+    9.2565528869628906e+01, 2.0166015625000000e+02,
+    2.4167649098671973e-04, 6, -1, 3.0755642700195312e+02,
+    2.3589279174804688e+02, 9.2565528869628906e+01,
+    1.1913596153259277e+01, 4.9534228310221806e-05, 6, -1,
+    2.0901893615722656e+02, 2.3887878417968750e+02,
+    9.2565528869628906e+01, 4.3802371978759766e+01,
+    8.1290991147398017e-06, 6, -1, 2.2693484497070312e+02,
+    2.3887878417968750e+02, 9.2565528869628906e+01,
+    5.8679538726806641e+01, 4.4957100726605859e-06, 6, -1,
+    2.8964053344726562e+02, 2.3887878417968750e+02,
+    9.2565528869628906e+01, 1.4811726379394531e+02,
+    4.5063516154186800e-05, 6, -1, 3.3144430541992188e+02,
+    2.3887878417968750e+02, 9.2565528869628906e+01,
+    3.4710940551757812e+02, 3.1063237111084163e-04, 6, -1,
+    3.6429016113281250e+02, 2.3887878417968750e+02,
+    9.2565528869628906e+01, 2.5975524902343750e+02,
+    6.4783504058141261e-05, 6, -1, 3.9414999389648438e+02,
+    2.3887878417968750e+02, 9.2565528869628906e+01,
+    1.9970738220214844e+02, 1.0187345469603315e-04, 6, -1,
+    1.7617309570312500e+02, 2.4186477661132812e+02,
+    9.2565528869628906e+01, 8.3591407775878906e+01,
+    3.8034206227166578e-05, 6, -1, 1.8811703491210938e+02,
+    2.4186477661132812e+02, 9.2565528869628906e+01,
+    6.8748054504394531e+01, 1.7069371097022668e-05, 6, -1,
+    2.4485075378417969e+02, 2.4186477661132812e+02,
+    9.2565528869628906e+01, 1.8104650878906250e+02,
+    -1.3104612662573345e-05, 6, -1, 2.6873864746093750e+02,
+    2.4186477661132812e+02, 9.2565528869628906e+01,
+    1.6634391784667969e+02, 2.7211135602556169e-04, 6, -1,
+    4.3595379638671875e+02, 2.4186477661132812e+02,
+    9.2565528869628906e+01, 2.0201132202148438e+02,
+    8.4726916611543857e-06, 6, -1, 1.3735530090332031e+02,
+    2.4485075378417969e+02, 9.2565528869628906e+01,
+    1.0710668945312500e+02, 1.8833088688552380e-05, 6, -1,
+    3.2845831298828125e+02, 2.4485075378417969e+02,
+    9.2565528869628906e+01, 3.4528750610351562e+02,
+    3.5394143196754158e-04, 6, -1, 3.6727612304687500e+02,
+    2.4485075378417969e+02, 9.2565528869628906e+01,
+    2.5438739013671875e+02, 6.4337866206187755e-05, 6, -1,
+    3.0457043457031250e+02, 2.4783673095703125e+02,
+    9.2565528869628906e+01, 5.6334686279296875e+01,
+    7.3846655141096562e-05, 6, -1, 3.1352841186523438e+02,
+    2.4783673095703125e+02, 9.2565528869628906e+01,
+    3.0863748550415039e+01, 2.1514792024390772e-05, 6, -1,
+    3.4040228271484375e+02, 2.4783673095703125e+02,
+    9.2565528869628906e+01, 3.1910232543945312e+02,
+    4.0767344762571156e-04, 6, -1, 1.4631326293945312e+02,
+    2.5082272338867188e+02, 9.2565528869628906e+01,
+    1.0595077514648438e+02, 1.9550639990484342e-05, 6, -1,
+    1.7617309570312500e+02, 2.5082272338867188e+02,
+    9.2565528869628906e+01, 8.5348480224609375e+01,
+    1.9458660972304642e-05, 6, -1, 1.9408901977539062e+02,
+    2.5082272338867188e+02, 9.2565528869628906e+01,
+    7.9394699096679688e+01, 8.7260368673014455e-06, 6, -1,
+    1.3138333129882812e+02, 2.5380871582031250e+02,
+    9.2565528869628906e+01, 9.1929679870605469e+01,
+    1.2453433009795845e-04, 6, -1, 1.4631326293945312e+02,
+    2.5679467773437500e+02, 9.2565528869628906e+01,
+    1.0349166107177734e+02, 2.7193034839001484e-05, 6, -1,
+    1.6422915649414062e+02, 2.5679467773437500e+02,
+    9.2565528869628906e+01, 9.8211341857910156e+01,
+    2.9188860935391858e-05, 6, -1, 3.3741629028320312e+02,
+    2.5679467773437500e+02, 9.2565528869628906e+01,
+    4.1571033477783203e+01, 1.1864868429256603e-04, 6, -1,
+    4.1803787231445312e+02, 2.5679467773437500e+02,
+    9.2565528869628906e+01, 2.0397628784179688e+02,
+    3.1997678888728842e-05, 6, -1, 1.9110302734375000e+02,
+    2.5978067016601562e+02, 9.2565528869628906e+01,
+    8.4268569946289062e+01, 2.1471769287018105e-05, 6, -1,
+    3.5831817626953125e+02, 2.5978067016601562e+02,
+    9.2565528869628906e+01, 1.7246858215332031e+02,
+    9.4577553682029247e-06, 6, -1, 4.2699581909179688e+02,
+    2.5978067016601562e+02, 9.2565528869628906e+01,
+    2.0164486694335938e+02, 1.3548929928219877e-05, 6, -1,
+    2.3589279174804688e+02, 2.6276666259765625e+02,
+    9.2565528869628906e+01, 1.0591405487060547e+02,
+    3.7724000776506728e-06, 6, -1, 2.7471060180664062e+02,
+    2.6575265502929688e+02, 9.2565528869628906e+01,
+    1.0511474609375000e+02, 1.8033617834589677e-06, 6, -1,
+    4.0609393310546875e+02, 2.6873864746093750e+02,
+    9.2565528869628906e+01, 1.6664651489257812e+02,
+    2.9582801289507188e-05, 6, -1, 4.2400982666015625e+02,
+    2.6873864746093750e+02, 9.2565528869628906e+01,
+    1.8732879638671875e+02, 1.3911535461375024e-05, 6, -1,
+    1.2541136169433594e+02, 2.7172460937500000e+02,
+    9.2565528869628906e+01, 5.4176395416259766e+01,
+    9.3525395641336218e-06, 6, -1, 3.1950036621093750e+02,
+    2.7471060180664062e+02, 9.2565528869628906e+01,
+    9.5454505920410156e+01, 5.3783383009431418e-06, 6, -1,
+    3.8519204711914062e+02, 2.7471060180664062e+02,
+    9.2565528869628906e+01, 1.2761894226074219e+02,
+    5.0164631829829887e-05, 6, -1, 3.7623406982421875e+02,
+    2.7769659423828125e+02, 9.2565528869628906e+01,
+    1.2057135772705078e+02, 4.2424610001035035e-05, 6, -1,
+    3.5234619140625000e+02, 2.8366854858398438e+02,
+    9.2565528869628906e+01, 1.0507907867431641e+02,
+    1.3869617760065012e-05, 6, -1, 3.8817803955078125e+02,
+    2.8665454101562500e+02, 9.2565528869628906e+01,
+    1.1313687133789062e+02, 3.4177399356849492e-05, 6, -1,
+    1.4332727050781250e+02, 2.8964053344726562e+02,
+    9.2565528869628906e+01, 6.6978622436523438e+01,
+    1.8709976075115264e-06, 6, -1, 1.6124317932128906e+02,
+    2.8964053344726562e+02, 9.2565528869628906e+01,
+    1.0971428680419922e+02, 1.1088794963143300e-05, 6, -1,
+    3.7922006225585938e+02, 2.8964053344726562e+02,
+    9.2565528869628906e+01, 1.0800332641601562e+02,
+    5.8740464737638831e-05, 6, -1, 4.0310794067382812e+02,
+    2.8964053344726562e+02, 9.2565528869628906e+01,
+    1.3116349792480469e+02, 1.7405016478733160e-05, 6, -1,
+    1.7915908813476562e+02, 2.9561248779296875e+02,
+    9.2565528869628906e+01, 8.9936431884765625e+01,
+    3.9586211642017588e-05, 6, -1, 3.9713598632812500e+02,
+    2.9561248779296875e+02, 9.2565528869628906e+01,
+    1.2363321685791016e+02, 1.8377066226094030e-05, 6, -1,
+    4.1505187988281250e+02, 2.9561248779296875e+02,
+    9.2565528869628906e+01, 1.4607214355468750e+02,
+    4.7943613026291132e-05, 6, -1, 1.6721514892578125e+02,
+    2.9859848022460938e+02, 9.2565528869628906e+01,
+    1.3161727905273438e+02, 5.0694616220425814e-05, 6, -1,
+    1.9110302734375000e+02, 3.0158447265625000e+02,
+    9.2565528869628906e+01, 2.2964815139770508e+01,
+    5.0738563004415482e-05, 6, -1, 4.2699581909179688e+02,
+    3.0457043457031250e+02, 9.2565528869628906e+01,
+    1.5999636840820312e+02, 7.1171285526361316e-05, 6, -1,
+    4.1803787231445312e+02, 3.1054241943359375e+02,
+    9.2565528869628906e+01, 1.5497895812988281e+02,
+    2.0190967188682407e-04, 6, -1, 1.9707499694824219e+02,
+    3.1352841186523438e+02, 9.2565528869628906e+01,
+    2.9335775756835938e+02, 4.7204444854287431e-05, 6, -1,
+    2.8964053344726562e+02, 3.1352841186523438e+02,
+    9.2565528869628906e+01, 1.0959263610839844e+02,
+    4.3422660382930189e-05, 6, -1, 1.4631326293945312e+02,
+    3.1651440429687500e+02, 9.2565528869628906e+01,
+    2.8845080566406250e+02, 7.2178227128461003e-07, 6, -1,
+    2.1200491333007812e+02, 3.1651440429687500e+02,
+    9.2565528869628906e+01, 3.0677789306640625e+02,
+    -1.6382113244617358e-05, 6, -1, 1.4929924011230469e+02,
+    3.2248635864257812e+02, 9.2565528869628906e+01,
+    2.8321636962890625e+02, 1.9683131995407166e-06, 6, -1,
+    3.0457043457031250e+02, 3.2248635864257812e+02,
+    9.2565528869628906e+01, 9.1851058959960938e+01,
+    3.9562550227856264e-05, 6, -1, 1.7318711853027344e+02,
+    3.2547235107421875e+02, 9.2565528869628906e+01,
+    2.6540728759765625e+02, 5.2444625907810405e-05, 6, -1,
+    2.6873864746093750e+02, 3.2547235107421875e+02,
+    9.2565528869628906e+01, 2.8779028320312500e+02,
+    5.7221401220886037e-05, 6, -1, 2.8665454101562500e+02,
+    3.2547235107421875e+02, 9.2565528869628906e+01,
+    2.8100451660156250e+02, 1.2321337999310344e-04, 6, -1,
+    2.9561248779296875e+02, 3.2547235107421875e+02,
+    9.2565528869628906e+01, 2.7955468750000000e+02,
+    1.0202972043771297e-04, 6, -1, 1.9707499694824219e+02,
+    3.2845831298828125e+02, 9.2565528869628906e+01,
+    2.8608929443359375e+02, 1.5199875633697957e-05, 6, -1,
+    2.4186477661132812e+02, 3.2845831298828125e+02,
+    9.2565528869628906e+01, 2.9022839355468750e+02,
+    -4.4440588681027293e-05, 6, -1, 2.5679467773437500e+02,
+    3.2845831298828125e+02, 9.2565528869628906e+01,
+    2.8969534301757812e+02, 8.2842016126960516e-05, 6, -1,
+    3.3443029785156250e+02, 3.2845831298828125e+02,
+    9.2565528869628906e+01, 5.4263557434082031e+01,
+    5.9000717556045856e-06, 6, -1, 3.9713598632812500e+02,
+    3.2845831298828125e+02, 9.2565528869628906e+01,
+    1.5108187866210938e+02, 4.5945294004923198e-06, 6, -1,
+    1.3138333129882812e+02, 3.3144430541992188e+02,
+    9.2565528869628906e+01, 3.1456121826171875e+02,
+    1.3407923688646406e-05, 6, -1, 2.0603295898437500e+02,
+    3.3144430541992188e+02, 9.2565528869628906e+01,
+    2.9283444213867188e+02, 1.3336721167434007e-05, 6, -1,
+    2.2394885253906250e+02, 3.3144430541992188e+02,
+    9.2565528869628906e+01, 2.9172235107421875e+02,
+    1.2827377759094816e-05, 6, -1, 2.5380871582031250e+02,
+    3.3443029785156250e+02, 9.2565528869628906e+01,
+    2.9038122558593750e+02, 4.7941415687091649e-05, 6, -1,
+    2.7172460937500000e+02, 3.3443029785156250e+02,
+    9.2565528869628906e+01, 2.8730194091796875e+02,
+    1.1629702930804342e-04, 6, -1, 2.9262652587890625e+02,
+    3.3443029785156250e+02, 9.2565528869628906e+01,
+    2.8273489379882812e+02, 1.2948417861480266e-04, 6, -1,
+    3.0755642700195312e+02, 3.3443029785156250e+02,
+    9.2565528869628906e+01, 2.8963366699218750e+02,
+    3.6625191569328308e-05, 6, -1, 3.7026211547851562e+02,
+    3.3443029785156250e+02, 9.2565528869628906e+01,
+    1.6332191467285156e+02, 4.6211251174099743e-05, 6, -1,
+    3.1352841186523438e+02, 3.3741629028320312e+02,
+    9.2565528869628906e+01, 2.9200610351562500e+02,
+    1.9167391656083055e-05, 6, -1, 4.1505187988281250e+02,
+    3.3741629028320312e+02, 9.2565528869628906e+01,
+    1.7136286926269531e+02, 8.2370735299264197e-07, 6, -1,
+    2.7471060180664062e+02, 3.4338824462890625e+02,
+    9.2565528869628906e+01, 2.8739361572265625e+02,
+    2.9256720154080540e-05, 6, -1, 3.5533218383789062e+02,
+    3.4637423706054688e+02, 9.2565528869628906e+01,
+    2.7028778076171875e+02, 6.4314926930819638e-06, 6, -1,
+    3.7922006225585938e+02, 3.6130416870117188e+02,
+    9.2565528869628906e+01, 2.6491833496093750e+02,
+    5.2434147619351279e-06, 6, -1, 4.0012194824218750e+02,
+    3.6429016113281250e+02, 9.2565528869628906e+01,
+    2.1611038208007812e+02, 4.1121170397673268e-06, 6, -1,
+    4.0310794067382812e+02, 3.7623406982421875e+02,
+    9.2565528869628906e+01, 2.1739161682128906e+02,
+    6.4752262005640659e-06, 6, -1, 4.2400982666015625e+02,
+    3.7922006225585938e+02, 9.2565528869628906e+01,
+    1.8220074462890625e+02, 4.2078972910530865e-05, 6, -1,
+    2.1140773010253906e+02, 1.3616090393066406e+02,
+    1.1107863616943359e+02, 1.1448304748535156e+02,
+    9.7118818302988075e-06, 7, -1, 2.3649000549316406e+02,
+    1.5407681274414062e+02, 1.1107863616943359e+02,
+    6.4921249389648438e+01, 7.5707439464167692e-06, 7, -1,
+    2.4365637207031250e+02, 1.5407681274414062e+02,
+    1.1107863616943359e+02, 6.4469680786132812e+01,
+    9.4475717560271733e-06, 7, -1, 2.1857409667968750e+02,
+    1.5766000366210938e+02, 1.1107863616943359e+02,
+    6.8372406005859375e+01, 8.0646268543205224e-06, 7, -1,
+    2.0065818786621094e+02, 1.6482637023925781e+02,
+    1.1107863616943359e+02, 9.4255203247070312e+01,
+    2.4678498448338360e-05, 7, -1, 4.0848272705078125e+02,
+    1.6482637023925781e+02, 1.1107863616943359e+02,
+    1.3098809814453125e+02, 3.2208056381932693e-06, 7, -1,
+    4.7656320190429688e+02, 1.6482637023925781e+02,
+    1.1107863616943359e+02, 2.1774073791503906e+02,
+    6.1306263887672685e-06, 7, -1, 4.6581362915039062e+02,
+    1.7199273681640625e+02, 1.1107863616943359e+02,
+    1.9473477172851562e+02, 4.8688816605135798e-06, 7, -1,
+    2.2932363891601562e+02, 1.7557591247558594e+02,
+    1.1107863616943359e+02, 6.0531951904296875e+01,
+    3.7497702578548342e-05, 7, -1, 4.4073135375976562e+02,
+    1.7557591247558594e+02, 1.1107863616943359e+02,
+    1.6629483032226562e+02, 7.0191690610954538e-06, 7, -1,
+    1.8274227905273438e+02, 1.7915908813476562e+02,
+    1.1107863616943359e+02, 1.3114974975585938e+02,
+    5.1077327043458354e-06, 7, -1, 4.2998181152343750e+02,
+    1.7915908813476562e+02, 1.1107863616943359e+02,
+    1.5047074890136719e+02, 1.3917792784923222e-05, 7, -1,
+    2.4007318115234375e+02, 1.8274227905273438e+02,
+    1.1107863616943359e+02, 6.3107406616210938e+01,
+    2.8531829229905270e-05, 7, -1, 2.9382092285156250e+02,
+    1.8274227905273438e+02, 1.1107863616943359e+02,
+    1.4450724792480469e+02, 9.4299022748600692e-05, 7, -1,
+    3.6548455810546875e+02, 1.8274227905273438e+02,
+    1.1107863616943359e+02, 1.1994295501708984e+02,
+    2.5156921765301377e-05, 7, -1, 3.7981729125976562e+02,
+    1.8274227905273438e+02, 1.1107863616943359e+02,
+    1.2977819824218750e+02, 3.2971667678793892e-05, 7, -1,
+    3.9414999389648438e+02, 1.8274227905273438e+02,
+    1.1107863616943359e+02, 1.3412004089355469e+02,
+    1.0103952263307292e-05, 7, -1, 1.8632545471191406e+02,
+    1.8990864562988281e+02, 1.1107863616943359e+02,
+    8.7538604736328125e+01, 3.8273096834018361e-06, 7, -1,
+    2.3290681457519531e+02, 1.8990864562988281e+02,
+    1.1107863616943359e+02, 5.1365734100341797e+01,
+    7.7280288678593934e-05, 7, -1, 2.8307138061523438e+02,
+    1.8990864562988281e+02, 1.1107863616943359e+02,
+    1.9386112976074219e+02, 1.5515163249801844e-04, 7, -1,
+    3.1173681640625000e+02, 1.8990864562988281e+02,
+    1.1107863616943359e+02, 3.5891302490234375e+02,
+    4.0972190618049353e-05, 7, -1, 4.5864727783203125e+02,
+    1.8990864562988281e+02, 1.1107863616943359e+02,
+    1.9184089660644531e+02, 5.1742017603828572e-06, 7, -1,
+    2.2574046325683594e+02, 1.9349182128906250e+02,
+    1.1107863616943359e+02, 4.5275405883789062e+01,
+    8.4693034295924008e-05, 7, -1, 2.6873864746093750e+02,
+    1.9349182128906250e+02, 1.1107863616943359e+02,
+    1.9473742675781250e+02, 5.1256552978884429e-05, 7, -1,
+    3.0098727416992188e+02, 1.9349182128906250e+02,
+    1.1107863616943359e+02, 2.5882278442382812e+02,
+    1.3101167860440910e-04, 7, -1, 3.4040228271484375e+02,
+    1.9349182128906250e+02, 1.1107863616943359e+02,
+    7.3242904663085938e+01, 9.0106259449385107e-06, 7, -1,
+    3.8698364257812500e+02, 1.9349182128906250e+02,
+    1.1107863616943359e+02, 1.3416302490234375e+02,
+    1.9188151782145724e-05, 7, -1, 3.7981729125976562e+02,
+    1.9707499694824219e+02, 1.1107863616943359e+02,
+    1.3333128356933594e+02, 2.7001013222616166e-05, 7, -1,
+    4.4431454467773438e+02, 1.9707499694824219e+02,
+    1.1107863616943359e+02, 1.8259304809570312e+02,
+    1.3237547136668582e-05, 7, -1, 2.8665454101562500e+02,
+    2.0065818786621094e+02, 1.1107863616943359e+02,
+    2.2573930358886719e+02, 5.4783002269687131e-05, 7, -1,
+    2.9740408325195312e+02, 2.0424136352539062e+02,
+    1.1107863616943359e+02, 2.5595513916015625e+02,
+    9.4057919341139495e-05, 7, -1, 3.1890319824218750e+02,
+    2.0424136352539062e+02, 1.1107863616943359e+02,
+    3.3172375488281250e+02, 2.3849292119848542e-05, 7, -1,
+    3.5831817626953125e+02, 2.0424136352539062e+02,
+    1.1107863616943359e+02, 1.3027087402343750e+02,
+    1.1029848792531993e-05, 7, -1, 2.1140773010253906e+02,
+    2.0782455444335938e+02, 1.1107863616943359e+02,
+    2.2336048126220703e+01, 4.0796752728056163e-05, 7, -1,
+    2.6873864746093750e+02, 2.0782455444335938e+02,
+    1.1107863616943359e+02, 2.2274977111816406e+02,
+    1.2699784747383092e-05, 7, -1, 3.1173681640625000e+02,
+    2.0782455444335938e+02, 1.1107863616943359e+02,
+    3.1884884643554688e+02, 8.2256614405196160e-05, 7, -1,
+    3.6906771850585938e+02, 2.0782455444335938e+02,
+    1.1107863616943359e+02, 1.4498976135253906e+02,
+    1.7958125681616366e-05, 7, -1, 4.0489953613281250e+02,
+    2.0782455444335938e+02, 1.1107863616943359e+02,
+    1.6119613647460938e+02, 4.5355118345469236e-05, 7, -1,
+    2.8665454101562500e+02, 2.1140773010253906e+02,
+    1.1107863616943359e+02, 2.3138529968261719e+02,
+    4.5186821807874367e-05, 7, -1, 2.9740408325195312e+02,
+    2.1140773010253906e+02, 1.1107863616943359e+02,
+    2.6068280029296875e+02, 9.3825794465374202e-05, 7, -1,
+    1.9707499694824219e+02, 2.1499090576171875e+02,
+    1.1107863616943359e+02, 1.9922227859497070e+01,
+    2.6586103558656760e-05, 7, -1, 2.0782455444335938e+02,
+    2.1499090576171875e+02, 1.1107863616943359e+02,
+    1.1212203979492188e+01, 3.8688143831677735e-05, 7, -1,
+    2.7232180786132812e+02, 2.1499090576171875e+02,
+    1.1107863616943359e+02, 2.2416629028320312e+02,
+    2.8637121431529522e-05, 7, -1, 3.5831817626953125e+02,
+    2.1499090576171875e+02, 1.1107863616943359e+02,
+    1.5726628112792969e+02, 7.1433278208132833e-06, 7, -1,
+    3.9773318481445312e+02, 2.1499090576171875e+02,
+    1.1107863616943359e+02, 1.7296134948730469e+02,
+    7.1354785177391022e-05, 7, -1, 4.4789773559570312e+02,
+    2.1499090576171875e+02, 1.1107863616943359e+02,
+    1.9726145935058594e+02, 3.3700011954351794e-06, 7, -1,
+    1.6124317932128906e+02, 2.2215727233886719e+02,
+    1.1107863616943359e+02, 1.1226290893554688e+02,
+    2.5355991965625435e-05, 7, -1, 2.0424136352539062e+02,
+    2.2215727233886719e+02, 1.1107863616943359e+02,
+    2.9855642318725586e+01, 4.2943258449668065e-05, 7, -1,
+    2.7232180786132812e+02, 2.2574046325683594e+02,
+    1.1107863616943359e+02, 2.1338552856445312e+02,
+    1.5362323028966784e-04, 7, -1, 4.3356500244140625e+02,
+    2.2574046325683594e+02, 1.1107863616943359e+02,
+    1.9411329650878906e+02, 5.1903348321502563e-06, 7, -1,
+    1.5049363708496094e+02, 2.2932363891601562e+02,
+    1.1107863616943359e+02, 1.1107180023193359e+02,
+    2.6288040317012928e-05, 7, -1, 2.6157226562500000e+02,
+    2.2932363891601562e+02, 1.1107863616943359e+02,
+    1.9019950866699219e+02, 1.9655322830658406e-04, 7, -1,
+    3.0098727416992188e+02, 2.2932363891601562e+02,
+    1.1107863616943359e+02, 3.2115966796875000e+02,
+    5.9822385082952678e-05, 7, -1, 4.0131637573242188e+02,
+    2.2932363891601562e+02, 1.1107863616943359e+02,
+    1.8812530517578125e+02, 8.3496961451601237e-05, 7, -1,
+    1.5407681274414062e+02, 2.3649000549316406e+02,
+    1.1107863616943359e+02, 1.0583865356445312e+02,
+    2.0150151613052003e-05, 7, -1, 3.2248635864257812e+02,
+    2.3649000549316406e+02, 1.1107863616943359e+02,
+    5.6347498893737793e+00, 3.8571446202695370e-04, 7, -1,
+    3.2965274047851562e+02, 2.3649000549316406e+02,
+    1.1107863616943359e+02, 3.5820034790039062e+02,
+    3.2198912231251597e-04, 7, -1, 3.9414999389648438e+02,
+    2.3649000549316406e+02, 1.1107863616943359e+02,
+    1.9592910766601562e+02, 6.9511421315837651e-05, 7, -1,
+    1.7557591247558594e+02, 2.4007318115234375e+02,
+    1.1107863616943359e+02, 9.0440742492675781e+01,
+    3.1826020858716220e-05, 7, -1, 2.3290681457519531e+02,
+    2.4007318115234375e+02, 1.1107863616943359e+02,
+    1.0455052185058594e+02, 6.3035158746060915e-06, 7, -1,
+    2.4007318115234375e+02, 2.4007318115234375e+02,
+    1.1107863616943359e+02, 1.2171218872070312e+02,
+    8.8295828390982933e-06, 7, -1, 2.6873864746093750e+02,
+    2.4007318115234375e+02, 1.1107863616943359e+02,
+    1.4805172729492188e+02, 2.5494192959740758e-04, 7, -1,
+    2.9023773193359375e+02, 2.4007318115234375e+02,
+    1.1107863616943359e+02, 1.0774274444580078e+02,
+    5.6920132919913158e-05, 7, -1, 4.3714819335937500e+02,
+    2.4007318115234375e+02, 1.1107863616943359e+02,
+    1.9837681579589844e+02, 4.3585669118328951e-06, 7, -1,
+    1.3616090393066406e+02, 2.4365637207031250e+02,
+    1.1107863616943359e+02, 9.3630516052246094e+01,
+    1.8537977666710503e-05, 7, -1, 3.6906771850585938e+02,
+    2.4365637207031250e+02, 1.1107863616943359e+02,
+    2.2677925109863281e+02, 4.2945415771100670e-05, 7, -1,
+    3.7981729125976562e+02, 2.4365637207031250e+02,
+    1.1107863616943359e+02, 2.1121910095214844e+02,
+    3.1738523830426857e-05, 7, -1, 1.7915908813476562e+02,
+    2.4723954772949219e+02, 1.1107863616943359e+02,
+    8.8354393005371094e+01, 1.7340775229968131e-05, 7, -1,
+    3.0815362548828125e+02, 2.4723954772949219e+02,
+    1.1107863616943359e+02, 6.8183082580566406e+01,
+    7.2782066126819700e-05, 7, -1, 3.4040228271484375e+02,
+    2.4723954772949219e+02, 1.1107863616943359e+02,
+    1.4819642066955566e+01, 3.8287867209874094e-04, 7, -1,
+    1.3257772827148438e+02, 2.5082272338867188e+02,
+    1.1107863616943359e+02, 8.7616432189941406e+01,
+    9.9059972853865474e-05, 7, -1, 1.9349182128906250e+02,
+    2.5082272338867188e+02, 1.1107863616943359e+02,
+    8.1407272338867188e+01, 1.0326120900572278e-05, 7, -1,
+    2.9740408325195312e+02, 2.5082272338867188e+02,
+    1.1107863616943359e+02, 9.0298706054687500e+01,
+    3.5869466955773532e-05, 7, -1, 1.3974409484863281e+02,
+    2.5440591430664062e+02, 1.1107863616943359e+02,
+    9.0718566894531250e+01, 6.9979250838514417e-05, 7, -1,
+    1.6482637023925781e+02, 2.5440591430664062e+02,
+    1.1107863616943359e+02, 9.7510620117187500e+01,
+    3.8117021176731214e-05, 7, -1, 3.5831817626953125e+02,
+    2.5798910522460938e+02, 1.1107863616943359e+02,
+    1.2743331909179688e+02, 9.2738800958613865e-06, 7, -1,
+    4.1923226928710938e+02, 2.5798910522460938e+02,
+    1.1107863616943359e+02, 1.9042784118652344e+02,
+    2.4467919502058066e-05, 7, -1, 1.1466181945800781e+02,
+    2.6515545654296875e+02, 1.1107863616943359e+02,
+    4.6886680603027344e+01, 5.0054797611664981e-05, 7, -1,
+    4.0131637573242188e+02, 2.6515545654296875e+02,
+    1.1107863616943359e+02, 1.6321005249023438e+02,
+    2.3989843612071127e-05, 7, -1, 4.2281546020507812e+02,
+    2.6873864746093750e+02, 1.1107863616943359e+02,
+    1.7797206115722656e+02, 8.8416527432855219e-06, 7, -1,
+    3.1890319824218750e+02, 2.7232180786132812e+02,
+    1.1107863616943359e+02, 9.1400733947753906e+01,
+    2.7307567052048398e-06, 7, -1, 3.7623410034179688e+02,
+    2.7590499877929688e+02, 1.1107863616943359e+02,
+    1.2304295349121094e+02, 2.9688875656574965e-05, 7, -1,
+    3.8340045166015625e+02, 2.7590499877929688e+02,
+    1.1107863616943359e+02, 1.2731600952148438e+02,
+    3.4203774703200907e-05, 7, -1, 3.1173681640625000e+02,
+    2.8307138061523438e+02, 1.1107863616943359e+02,
+    9.7609878540039062e+01, -1.9440528831182746e-07, 7, -1,
+    3.5115182495117188e+02, 2.8307138061523438e+02,
+    1.1107863616943359e+02, 1.0263454437255859e+02,
+    1.6897003661142662e-05, 7, -1, 3.7623410034179688e+02,
+    2.9023773193359375e+02, 1.1107863616943359e+02,
+    1.1400324249267578e+02, 4.7364646889036521e-05, 7, -1,
+    3.9773318481445312e+02, 2.9382092285156250e+02,
+    1.1107863616943359e+02, 1.3516607666015625e+02,
+    1.7665697669144720e-05, 7, -1, 4.1564910888671875e+02,
+    2.9382092285156250e+02, 1.1107863616943359e+02,
+    1.5397152709960938e+02, 5.2301205869298428e-05, 7, -1,
+    1.6840954589843750e+02, 2.9740408325195312e+02,
+    1.1107863616943359e+02, 9.9131164550781250e+01,
+    5.6119359214790165e-05, 7, -1, 1.8990864562988281e+02,
+    3.0098727416992188e+02, 1.1107863616943359e+02,
+    7.2438423156738281e+01, 5.1009068556595594e-05, 7, -1,
+    4.1923226928710938e+02, 3.0815362548828125e+02,
+    1.1107863616943359e+02, 1.5590457153320312e+02,
+    2.1427513274829835e-04, 7, -1, 1.9707499694824219e+02,
+    3.1173681640625000e+02, 1.1107863616943359e+02,
+    3.0186312866210938e+02, 4.1285431507276371e-05, 7, -1,
+    1.4691046142578125e+02, 3.1532000732421875e+02,
+    1.1107863616943359e+02, 3.0398776245117188e+02,
+    9.5870871064107632e-07, 7, -1, 2.1499090576171875e+02,
+    3.1890319824218750e+02, 1.1107863616943359e+02,
+    3.0607424926757812e+02, -4.0449969674227759e-05, 7, -1,
+    2.9382092285156250e+02, 3.2248635864257812e+02,
+    1.1107863616943359e+02, 6.1548133850097656e+01,
+    5.8435463870409876e-05, 7, -1, 3.0457046508789062e+02,
+    3.2248635864257812e+02, 1.1107863616943359e+02,
+    7.5178840637207031e+01, 3.1017352739581838e-05, 7, -1,
+    3.2965274047851562e+02, 3.2248635864257812e+02,
+    1.1107863616943359e+02, 9.5632553100585938e+01,
+    2.6295890620531281e-06, 7, -1, 1.7199273681640625e+02,
+    3.2606954956054688e+02, 1.1107863616943359e+02,
+    2.7524066162109375e+02, 4.4946031266590580e-05, 7, -1,
+    2.3649000549316406e+02, 3.2606954956054688e+02,
+    1.1107863616943359e+02, 2.9141656494140625e+02,
+    -4.5051561755826697e-05, 7, -1, 2.5798910522460938e+02,
+    3.2606954956054688e+02, 1.1107863616943359e+02,
+    2.9300201416015625e+02, 6.0987822507740930e-05, 7, -1,
+    2.8307138061523438e+02, 3.2606954956054688e+02,
+    1.1107863616943359e+02, 2.9120642089843750e+02,
+    7.5194933742750436e-05, 7, -1, 3.9773318481445312e+02,
+    3.2965274047851562e+02, 1.1107863616943359e+02,
+    1.5744473266601562e+02, 2.1600815216515912e-06, 7, -1,
+    2.9382092285156250e+02, 3.3323590087890625e+02,
+    1.1107863616943359e+02, 2.8683276367187500e+02,
+    7.4569259595591575e-05, 7, -1, 3.6906771850585938e+02,
+    3.3323590087890625e+02, 1.1107863616943359e+02,
+    1.2719861602783203e+02, 5.0363956688670442e-05, 7, -1,
+    2.5440591430664062e+02, 3.3681909179687500e+02,
+    1.1107863616943359e+02, 2.8909362792968750e+02,
+    2.9645327231264673e-05, 7, -1, 3.1173681640625000e+02,
+    3.3681909179687500e+02, 1.1107863616943359e+02,
+    2.9189529418945312e+02, 1.9618873920990154e-05, 7, -1,
+    2.6873864746093750e+02, 3.4040228271484375e+02,
+    1.1107863616943359e+02, 2.8703833007812500e+02,
+    2.6950818210025318e-05, 7, -1, 3.2606954956054688e+02,
+    3.4040228271484375e+02, 1.1107863616943359e+02,
+    2.8406396484375000e+02, 1.1423299838497769e-05, 7, -1,
+    2.7590499877929688e+02, 3.4398547363281250e+02,
+    1.1107863616943359e+02, 2.8553250122070312e+02,
+    3.3666347007965669e-05, 7, -1, 3.7981729125976562e+02,
+    3.5831817626953125e+02, 1.1107863616943359e+02,
+    2.5144844055175781e+02, 2.8380200092215091e-06, 7, -1 ]
+descriptors: !!opencv-matrix
+   rows: 5914
+   cols: 32
+   dt: u
+   data: [ 3, 178, 85, 153, 235, 209, 184, 71, 159, 91, 80, 247, 172,
+       158, 230, 143, 231, 59, 183, 149, 151, 92, 162, 209, 14, 82, 90,
+       235, 158, 4, 45, 221, 189, 69, 105, 236, 124, 75, 198, 248, 86,
+       224, 253, 78, 243, 200, 185, 32, 122, 236, 22, 239, 237, 34, 79,
+       159, 246, 207, 165, 188, 125, 187, 88, 128, 255, 244, 45, 99, 45,
+       95, 95, 184, 19, 254, 157, 141, 235, 76, 219, 55, 221, 236, 221,
+       127, 237, 86, 237, 190, 175, 219, 237, 189, 22, 191, 86, 124, 94,
+       180, 33, 250, 57, 229, 154, 232, 31, 223, 153, 171, 253, 222, 93,
+       34, 223, 219, 253, 243, 42, 67, 251, 247, 187, 221, 143, 255, 23,
+       39, 39, 119, 56, 133, 112, 235, 213, 221, 86, 239, 87, 33, 125,
+       26, 27, 185, 60, 128, 217, 155, 151, 1, 94, 58, 88, 151, 107, 221,
+       132, 103, 119, 14, 220, 130, 210, 117, 23, 220, 42, 199, 59, 76,
+       174, 168, 67, 34, 220, 222, 96, 99, 166, 61, 123, 227, 67, 69,
+       186, 213, 181, 176, 11, 190, 20, 19, 165, 179, 255, 245, 233, 227,
+       189, 93, 223, 141, 91, 252, 151, 169, 219, 125, 223, 46, 221, 212,
+       253, 251, 236, 118, 253, 162, 235, 217, 141, 247, 134, 255, 214,
+       118, 163, 212, 105, 139, 84, 215, 239, 253, 95, 85, 92, 150, 48,
+       196, 190, 100, 89, 8, 19, 141, 231, 22, 124, 215, 37, 28, 158,
+       228, 29, 30, 208, 252, 70, 244, 177, 250, 191, 68, 154, 136, 139,
+       17, 153, 58, 236, 255, 76, 198, 223, 211, 255, 211, 91, 71, 251,
+       243, 185, 222, 143, 254, 149, 7, 165, 98, 34, 35, 110, 204, 78,
+       211, 216, 76, 143, 188, 252, 43, 64, 201, 118, 66, 232, 172, 239,
+       193, 6, 123, 139, 213, 86, 57, 137, 191, 117, 10, 126, 202, 66,
+       33, 127, 220, 79, 193, 187, 72, 206, 148, 232, 2, 112, 223, 117,
+       98, 248, 125, 123, 225, 66, 99, 186, 219, 85, 60, 139, 47, 85, 35,
+       117, 226, 163, 208, 33, 203, 84, 214, 175, 253, 94, 85, 85, 150,
+       176, 92, 190, 100, 92, 9, 19, 141, 243, 158, 124, 215, 37, 44,
+       138, 196, 29, 134, 176, 252, 131, 113, 23, 205, 14, 199, 169, 72,
+       174, 224, 66, 66, 212, 214, 116, 96, 162, 61, 123, 235, 65, 213,
+       155, 212, 133, 56, 139, 46, 28, 16, 17, 178, 34, 161, 254, 252,
+       76, 192, 177, 200, 142, 148, 248, 35, 96, 255, 110, 2, 217, 121,
+       99, 208, 2, 99, 234, 217, 93, 162, 207, 47, 81, 42, 100, 226, 4,
+       169, 191, 255, 93, 192, 177, 232, 158, 149, 104, 2, 244, 247, 105,
+       98, 249, 123, 35, 208, 2, 99, 186, 125, 77, 162, 207, 79, 81, 42,
+       101, 226, 52, 144, 149, 251, 141, 101, 198, 200, 142, 19, 169, 18,
+       92, 118, 105, 239, 249, 83, 250, 50, 51, 99, 91, 209, 145, 214,
+       83, 127, 153, 123, 231, 178, 147, 201, 62, 184, 159, 213, 150,
+       230, 196, 64, 194, 2, 56, 24, 54, 97, 232, 163, 26, 209, 253, 169,
+       22, 253, 185, 11, 158, 75, 61, 12, 185, 14, 13, 209, 151, 215, 21,
+       206, 161, 184, 254, 208, 66, 66, 244, 241, 40, 227, 113, 116, 58,
+       120, 33, 240, 59, 125, 13, 174, 71, 68, 128, 42, 101, 32, 48, 99,
+       78, 140, 92, 67, 193, 76, 94, 161, 122, 138, 82, 136, 118, 128,
+       122, 205, 98, 193, 73, 251, 143, 93, 28, 34, 225, 5, 29, 42, 248,
+       136, 139, 28, 47, 223, 72, 214, 185, 114, 180, 86, 214, 150, 249,
+       94, 183, 39, 108, 113, 155, 239, 225, 205, 54, 237, 71, 43, 234,
+       128, 15, 165, 53, 252, 147, 94, 7, 159, 26, 246, 136, 222, 156,
+       90, 216, 199, 236, 78, 183, 201, 206, 35, 159, 165, 231, 133, 119,
+       125, 160, 50, 218, 130, 29, 84, 33, 221, 130, 99, 71, 205, 94,
+       131, 170, 72, 206, 164, 194, 66, 64, 202, 116, 64, 232, 45, 107,
+       225, 64, 227, 155, 221, 20, 40, 139, 44, 85, 19, 33, 136, 18, 96,
+       31, 173, 14, 195, 170, 72, 174, 176, 65, 70, 197, 202, 113, 66,
+       178, 109, 107, 227, 67, 213, 155, 93, 148, 160, 139, 45, 28, 35,
+       17, 130, 41, 193, 142, 156, 95, 211, 129, 232, 146, 245, 100, 175,
+       114, 224, 234, 0, 121, 236, 162, 96, 12, 114, 190, 29, 92, 7, 239,
+       109, 209, 40, 124, 218, 139, 196, 134, 147, 193, 118, 236, 182,
+       52, 115, 70, 150, 89, 38, 186, 239, 109, 198, 178, 174, 229, 212,
+       61, 196, 70, 107, 254, 132, 47, 212, 185, 220, 4, 219, 143, 159,
+       89, 198, 161, 232, 150, 212, 228, 6, 116, 230, 43, 1, 121, 106,
+       34, 244, 33, 243, 58, 125, 93, 3, 207, 69, 208, 40, 37, 242, 16,
+       240, 143, 157, 20, 202, 161, 168, 190, 220, 66, 102, 244, 242,
+       168, 194, 113, 108, 170, 112, 67, 209, 187, 93, 140, 34, 239, 68,
+       8, 42, 53, 120, 7, 236, 229, 21, 202, 71, 172, 191, 238, 114, 18,
+       199, 124, 124, 29, 43, 55, 71, 123, 239, 231, 212, 29, 125, 44,
+       10, 255, 196, 109, 240, 131, 212, 151, 78, 78, 190, 4, 130, 202,
+       96, 212, 2, 219, 198, 113, 195, 177, 65, 122, 232, 23, 239, 236,
+       151, 12, 46, 144, 170, 170, 128, 61, 187, 112, 136, 173, 33, 232,
+       99, 236, 93, 207, 216, 82, 242, 53, 24, 83, 221, 223, 56, 24, 200,
+       119, 106, 218, 114, 255, 32, 79, 201, 229, 61, 119, 251, 222, 224,
+       61, 85, 32, 164, 183, 118, 23, 255, 81, 234, 159, 166, 95, 117,
+       187, 229, 95, 86, 149, 47, 249, 147, 125, 142, 251, 231, 173, 151,
+       182, 254, 180, 117, 12, 154, 142, 159, 221, 214, 165, 232, 150,
+       222, 197, 38, 120, 244, 171, 201, 121, 106, 162, 0, 37, 243, 58,
+       125, 93, 7, 103, 69, 216, 40, 45, 210, 28, 210, 143, 181, 21, 206,
+       161, 184, 190, 221, 70, 103, 244, 226, 106, 194, 113, 108, 170,
+       177, 3, 241, 187, 93, 157, 35, 239, 68, 8, 42, 61, 82, 167, 241,
+       233, 18, 228, 21, 207, 216, 82, 234, 149, 222, 80, 196, 255, 44,
+       93, 200, 22, 239, 235, 102, 252, 115, 64, 24, 173, 188, 93, 187,
+       210, 244, 63, 213, 135, 134, 179, 118, 15, 189, 17, 233, 95, 228,
+       76, 119, 170, 228, 95, 70, 149, 60, 185, 211, 121, 140, 170, 246,
+       207, 198, 174, 246, 168, 245, 226, 69, 108, 204, 77, 117, 216,
+       238, 201, 84, 172, 11, 32, 12, 63, 39, 200, 195, 211, 225, 166,
+       35, 242, 253, 23, 56, 202, 59, 85, 93, 94, 206, 44, 150, 138, 156,
+       85, 83, 133, 248, 18, 238, 244, 47, 104, 230, 171, 133, 121, 236,
+       166, 160, 45, 82, 122, 31, 127, 7, 255, 173, 155, 108, 62, 219,
+       12, 154, 143, 159, 213, 214, 177, 248, 150, 220, 214, 102, 116,
+       244, 171, 107, 249, 106, 166, 48, 165, 241, 58, 125, 93, 7, 103,
+       199, 216, 40, 45, 247, 28, 146, 143, 151, 21, 222, 161, 184, 190,
+       221, 214, 103, 244, 246, 170, 75, 113, 100, 174, 176, 37, 241, 59,
+       125, 217, 39, 239, 199, 136, 40, 45, 83, 150, 247, 123, 178, 242,
+       197, 31, 244, 24, 93, 17, 255, 29, 223, 232, 49, 183, 217, 149,
+       247, 227, 86, 184, 231, 249, 129, 47, 238, 44, 147, 167, 241, 95,
+       156, 247, 182, 178, 2, 30, 248, 187, 130, 145, 227, 253, 255, 185,
+       97, 55, 247, 61, 231, 168, 73, 14, 255, 186, 207, 239, 190, 181,
+       247, 33, 1, 221, 199, 151, 187, 166, 0, 174, 128, 236, 16, 219,
+       66, 205, 226, 169, 207, 115, 71, 42, 254, 67, 193, 143, 224, 180,
+       162, 239, 192, 175, 243, 161, 164, 183, 4, 99, 204, 70, 54, 234,
+       120, 85, 194, 83, 214, 81, 76, 53, 233, 126, 168, 19, 175, 237,
+       183, 52, 206, 19, 46, 203, 4, 125, 237, 112, 244, 162, 61, 103,
+       142, 77, 100, 184, 106, 137, 196, 208, 131, 44, 188, 117, 3, 236,
+       243, 19, 197, 36, 43, 50, 232, 19, 16, 202, 171, 21, 109, 53, 222,
+       130, 9, 31, 154, 68, 132, 168, 192, 140, 18, 64, 66, 180, 210,
+       101, 73, 236, 59, 19, 195, 64, 159, 18, 224, 21, 16, 202, 8, 16,
+       9, 33, 138, 0, 146, 142, 157, 20, 66, 161, 248, 22, 216, 214, 6,
+       116, 226, 106, 193, 121, 232, 162, 224, 35, 240, 27, 93, 76, 3,
+       239, 69, 153, 40, 41, 208, 133, 207, 23, 187, 230, 130, 175, 212,
+       196, 18, 219, 66, 213, 67, 185, 77, 123, 226, 42, 254, 67, 144,
+       15, 117, 180, 162, 239, 196, 189, 251, 161, 160, 20, 150, 142,
+       149, 150, 78, 33, 184, 182, 222, 86, 102, 240, 226, 234, 65, 113,
+       108, 46, 160, 33, 241, 59, 93, 121, 39, 231, 196, 168, 40, 45,
+       113, 230, 249, 59, 218, 239, 213, 158, 212, 139, 92, 60, 47, 44,
+       221, 103, 61, 142, 91, 151, 83, 199, 35, 186, 241, 51, 89, 12,
+       235, 151, 95, 167, 223, 210, 28, 118, 212, 71, 244, 184, 98, 137,
+       202, 152, 167, 44, 190, 55, 15, 238, 241, 151, 229, 164, 139, 50,
+       236, 83, 56, 202, 170, 5, 37, 37, 223, 129, 46, 137, 165, 116, 3,
+       103, 122, 84, 162, 74, 210, 243, 34, 128, 64, 89, 76, 2, 172, 41,
+       186, 77, 14, 236, 134, 165, 36, 60, 234, 48, 168, 150, 12, 82,
+       196, 101, 162, 254, 226, 169, 130, 186, 3, 12, 170, 53, 85, 238,
+       241, 31, 227, 96, 139, 0, 236, 147, 24, 202, 3, 5, 97, 33, 142,
+       25, 7, 81, 229, 52, 3, 79, 59, 116, 162, 90, 66, 243, 35, 129,
+       225, 122, 238, 12, 238, 105, 152, 77, 14, 228, 143, 165, 132, 40,
+       242, 32, 40, 39, 140, 225, 214, 244, 3, 238, 234, 211, 146, 177,
+       250, 113, 105, 253, 35, 221, 242, 23, 175, 248, 106, 78, 255, 46,
+       30, 199, 174, 213, 250, 112, 136, 164, 239, 81, 155, 236, 161,
+       206, 196, 86, 50, 249, 218, 245, 225, 249, 0, 91, 234, 2, 94, 122,
+       178, 78, 51, 36, 128, 175, 56, 213, 251, 209, 160, 253, 97, 192,
+       69, 172, 27, 78, 152, 65, 160, 182, 206, 83, 1, 209, 182, 88, 196,
+       76, 110, 201, 227, 213, 8, 178, 201, 165, 52, 111, 251, 90, 32,
+       29, 72, 246, 229, 87, 30, 123, 180, 97, 192, 118, 130, 89, 61,
+       183, 107, 110, 244, 181, 236, 136, 248, 53, 236, 87, 239, 210,
+       133, 103, 189, 112, 74, 86, 84, 241, 246, 151, 106, 207, 136, 91,
+       151, 49, 58, 199, 127, 40, 47, 59, 241, 5, 177, 48, 100, 188, 202,
+       185, 214, 207, 63, 165, 123, 213, 98, 7, 173, 29, 187, 248, 165,
+       186, 227, 142, 25, 89, 80, 188, 243, 40, 8, 135, 59, 27, 23, 147,
+       73, 10, 245, 12, 22, 122, 232, 144, 67, 129, 161, 32, 160, 206,
+       188, 84, 3, 160, 105, 18, 176, 224, 11, 100, 226, 32, 1, 121, 204,
+       34, 233, 32, 250, 15, 29, 28, 6, 223, 44, 145, 40, 112, 136, 6,
+       167, 104, 139, 215, 179, 186, 75, 30, 5, 93, 179, 200, 236, 190,
+       128, 251, 11, 147, 181, 150, 26, 14, 247, 46, 85, 155, 239, 149,
+       79, 189, 199, 60, 72, 110, 236, 69, 86, 207, 116, 85, 134, 246, 2,
+       91, 57, 51, 249, 120, 228, 147, 234, 104, 179, 52, 140, 115, 239,
+       192, 1, 119, 249, 116, 226, 20, 169, 150, 158, 29, 128, 160, 232,
+       158, 145, 224, 2, 96, 224, 108, 198, 233, 235, 106, 208, 10, 107,
+       138, 113, 25, 178, 199, 75, 81, 42, 116, 142, 73, 161, 109, 229,
+       102, 194, 121, 25, 98, 244, 87, 162, 221, 77, 210, 98, 54, 156,
+       53, 237, 131, 208, 175, 221, 78, 235, 163, 132, 39, 128, 20, 113,
+       84, 136, 134, 151, 29, 128, 160, 224, 182, 145, 195, 3, 102, 226,
+       105, 66, 233, 238, 42, 81, 14, 249, 155, 113, 153, 162, 207, 67,
+       128, 42, 120, 14, 60, 68, 106, 108, 69, 86, 207, 112, 81, 134,
+       244, 2, 83, 249, 51, 121, 120, 236, 19, 234, 104, 179, 48, 136,
+       115, 239, 193, 9, 247, 251, 116, 226, 39, 73, 107, 92, 76, 70,
+       239, 112, 197, 194, 117, 2, 80, 249, 181, 111, 120, 224, 18, 234,
+       193, 163, 54, 232, 85, 62, 195, 8, 87, 251, 116, 228, 216, 132,
+       248, 228, 118, 10, 94, 187, 25, 130, 58, 170, 255, 127, 217, 114,
+       119, 213, 21, 173, 104, 14, 204, 207, 250, 239, 175, 172, 36, 232,
+       101, 40, 236, 244, 233, 225, 208, 70, 125, 185, 50, 245, 5, 159,
+       81, 71, 88, 19, 53, 156, 81, 188, 251, 86, 249, 6, 111, 137, 173,
+       236, 165, 128, 214, 242, 74, 252, 97, 178, 81, 197, 91, 174, 59,
+       117, 8, 9, 189, 31, 72, 17, 135, 219, 17, 215, 106, 78, 250, 247,
+       233, 221, 159, 124, 20, 17, 7, 122, 67, 131, 147, 154, 252, 141,
+       186, 97, 142, 9, 89, 96, 252, 251, 108, 64, 214, 59, 55, 1, 18,
+       10, 138, 245, 12, 60, 58, 234, 148, 10, 161, 161, 38, 145, 59,
+       154, 252, 229, 152, 201, 143, 89, 153, 111, 220, 252, 108, 32,
+       220, 49, 183, 21, 146, 35, 26, 213, 217, 20, 11, 254, 208, 11,
+       181, 215, 145, 46, 145, 173, 148, 35, 79, 107, 84, 162, 72, 194,
+       211, 99, 144, 64, 123, 76, 2, 174, 105, 186, 77, 14, 172, 134,
+       165, 4, 184, 234, 96, 136, 1, 134, 142, 157, 22, 2, 160, 106, 86,
+       128, 226, 66, 229, 226, 32, 192, 121, 100, 42, 168, 32, 201, 15,
+       95, 8, 38, 223, 4, 177, 40, 105, 168, 38, 52, 232, 187, 207, 161,
+       187, 74, 26, 247, 89, 159, 64, 236, 127, 8, 223, 249, 179, 149,
+       150, 118, 222, 210, 93, 7, 219, 239, 213, 111, 23, 210, 23, 139,
+       229, 215, 52, 26, 234, 184, 95, 241, 86, 230, 225, 108, 158, 228,
+       119, 198, 52, 221, 143, 240, 109, 237, 142, 126, 207, 196, 175,
+       174, 80, 116, 245, 233, 3, 174, 29, 197, 194, 232, 195, 160, 160,
+       10, 35, 210, 101, 180, 216, 232, 74, 98, 79, 35, 136, 191, 177,
+       216, 131, 62, 113, 59, 114, 140, 6, 56, 185, 186, 78, 225, 187,
+       202, 26, 243, 89, 171, 44, 255, 101, 8, 191, 89, 179, 147, 18, 87,
+       154, 242, 93, 6, 219, 239, 149, 47, 37, 243, 35, 204, 99, 94, 77,
+       197, 167, 230, 205, 66, 252, 2, 32, 208, 181, 37, 72, 234, 18,
+       202, 225, 43, 62, 253, 53, 26, 208, 42, 83, 253, 112, 236, 236, 5,
+       203, 236, 220, 102, 75, 152, 19, 161, 237, 18, 83, 247, 121, 122,
+       88, 222, 17, 250, 25, 83, 216, 2, 219, 173, 129, 60, 184, 251,
+       112, 50, 128, 131, 108, 203, 156, 135, 45, 253, 132, 20, 196, 135,
+       241, 103, 42, 65, 92, 18, 27, 236, 114, 136, 81, 93, 109, 3, 174,
+       192, 53, 136, 180, 250, 189, 229, 80, 224, 228, 152, 110, 217,
+       233, 16, 188, 72, 159, 219, 217, 183, 62, 219, 86, 250, 74, 34,
+       14, 209, 246, 217, 39, 44, 103, 243, 194, 32, 165, 141, 105, 67,
+       244, 9, 239, 177, 93, 98, 62, 146, 113, 105, 157, 39, 127, 194,
+       22, 174, 249, 176, 109, 239, 38, 14, 165, 4, 253, 250, 208, 164,
+       146, 135, 45, 201, 158, 131, 141, 173, 140, 21, 222, 178, 244, 71,
+       184, 69, 94, 19, 27, 237, 242, 137, 99, 93, 169, 32, 238, 208, 20,
+       8, 181, 120, 33, 132, 197, 157, 85, 11, 226, 233, 82, 160, 64, 74,
+       229, 226, 32, 197, 89, 108, 34, 40, 33, 126, 95, 31, 172, 134,
+       223, 44, 184, 40, 17, 160, 35, 204, 39, 152, 77, 149, 156, 231,
+       205, 82, 216, 78, 40, 200, 54, 165, 201, 163, 146, 135, 207, 43,
+       86, 253, 50, 90, 222, 59, 95, 28, 249, 156, 199, 207, 109, 211,
+       238, 0, 175, 165, 200, 82, 26, 246, 209, 104, 157, 99, 111, 99,
+       27, 239, 245, 34, 237, 234, 36, 46, 238, 136, 141, 243, 241, 244,
+       255, 12, 198, 182, 3, 38, 94, 96, 185, 194, 163, 221, 79, 102, 35,
+       219, 247, 229, 253, 166, 45, 199, 136, 234, 144, 243, 203, 147,
+       168, 117, 43, 22, 4, 130, 142, 157, 31, 2, 160, 232, 150, 144,
+       226, 66, 224, 226, 104, 201, 121, 236, 34, 168, 34, 240, 11, 93,
+       76, 6, 215, 69, 241, 40, 104, 128, 80, 128, 134, 157, 7, 138, 33,
+       40, 190, 148, 194, 2, 230, 226, 108, 202, 113, 236, 40, 128, 10,
+       241, 139, 93, 152, 162, 207, 69, 1, 32, 61, 32, 201, 149, 62, 189,
+       45, 214, 213, 55, 236, 90, 198, 20, 246, 26, 50, 99, 192, 37, 120,
+       45, 253, 173, 51, 13, 225, 235, 250, 64, 8, 0, 185, 94, 61, 133,
+       5, 225, 157, 79, 79, 187, 71, 48, 136, 64, 211, 97, 24, 167, 89,
+       194, 90, 58, 123, 33, 121, 157, 169, 216, 133, 84, 114, 250, 208,
+       32, 72, 94, 254, 253, 10, 2, 63, 182, 164, 6, 214, 167, 113, 103,
+       163, 75, 102, 116, 171, 202, 64, 133, 35, 41, 99, 163, 230, 129,
+       37, 241, 45, 121, 87, 221, 247, 182, 178, 34, 30, 252, 187, 130,
+       145, 243, 253, 255, 249, 98, 55, 243, 125, 231, 184, 69, 14, 255,
+       186, 206, 223, 190, 181, 247, 161, 5, 213, 205, 87, 155, 174, 160,
+       175, 229, 172, 18, 139, 210, 85, 227, 185, 66, 119, 227, 42, 255,
+       114, 133, 11, 235, 184, 166, 143, 68, 157, 243, 161, 32, 9, 157,
+       45, 45, 20, 206, 203, 51, 76, 101, 202, 5, 247, 44, 18, 97, 200,
+       38, 88, 45, 189, 169, 117, 29, 229, 125, 10, 80, 80, 8, 85, 120,
+       27, 155, 10, 168, 151, 149, 158, 231, 4, 64, 218, 199, 173, 136,
+       50, 192, 252, 43, 155, 197, 222, 137, 20, 253, 186, 101, 142, 201,
+       61, 14, 185, 92, 32, 160, 141, 156, 92, 67, 224, 105, 82, 176, 96,
+       74, 241, 226, 32, 1, 89, 236, 34, 184, 32, 250, 79, 29, 93, 6,
+       223, 44, 177, 40, 118, 130, 43, 169, 106, 75, 84, 150, 251, 97,
+       109, 69, 124, 130, 57, 156, 182, 160, 122, 169, 147, 221, 150,
+       186, 52, 253, 119, 109, 130, 73, 119, 135, 126, 236, 32, 160, 135,
+       157, 92, 66, 160, 105, 86, 160, 96, 66, 113, 226, 32, 9, 121, 108,
+       34, 168, 32, 218, 31, 93, 77, 166, 223, 4, 17, 40, 113, 160, 26,
+       159, 42, 168, 214, 131, 186, 247, 4, 69, 88, 231, 45, 136, 50, 64,
+       254, 171, 151, 197, 222, 154, 4, 255, 248, 69, 170, 201, 61, 14,
+       185, 219, 0, 132, 143, 157, 84, 2, 166, 106, 86, 162, 66, 66, 209,
+       99, 32, 65, 121, 68, 34, 168, 33, 220, 29, 78, 44, 166, 247, 4,
+       184, 40, 33, 160, 149, 205, 94, 187, 230, 161, 174, 196, 132, 18,
+       219, 194, 85, 227, 185, 73, 123, 235, 10, 218, 114, 179, 15, 115,
+       176, 130, 238, 64, 189, 251, 161, 128, 62, 166, 232, 186, 159,
+       241, 218, 202, 23, 53, 157, 187, 11, 205, 126, 136, 255, 139, 135,
+       149, 30, 7, 74, 147, 219, 69, 185, 255, 183, 79, 188, 194, 56,
+       169, 28, 234, 61, 205, 82, 105, 135, 40, 168, 8, 183, 87, 32, 48,
+       200, 179, 95, 64, 74, 43, 90, 61, 235, 209, 1, 121, 16, 10, 78,
+       10, 44, 133, 216, 66, 245, 123, 212, 221, 83, 175, 53, 58, 74, 61,
+       206, 188, 89, 154, 134, 56, 56, 114, 104, 146, 127, 223, 117, 119,
+       247, 254, 222, 163, 90, 157, 19, 204, 147, 228, 55, 55, 61, 5,
+       106, 96, 124, 183, 32, 116, 246, 183, 44, 128, 89, 153, 48, 255,
+       177, 182, 18, 66, 50, 66, 165, 123, 74, 157, 19, 254, 211, 224,
+       51, 55, 53, 65, 74, 96, 44, 183, 32, 244, 247, 187, 178, 128, 19,
+       154, 48, 255, 189, 246, 26, 66, 178, 70, 165, 63, 11, 176, 147,
+       219, 243, 181, 184, 71, 63, 25, 112, 84, 172, 154, 100, 236, 231,
+       59, 146, 16, 23, 152, 50, 209, 15, 92, 26, 234, 154, 4, 169, 173,
+       178, 72, 39, 172, 13, 198, 80, 100, 133, 12, 210, 3, 38, 157, 32,
+       73, 200, 181, 191, 67, 72, 143, 16, 172, 145, 242, 218, 19, 16,
+       25, 52, 106, 147, 83, 98, 139, 246, 19, 190, 93, 93, 69, 117, 231,
+       41, 12, 190, 164, 126, 139, 150, 165, 247, 176, 36, 205, 54, 8,
+       174, 129, 127, 158, 253, 221, 35, 161, 233, 67, 245, 83, 225, 157,
+       83, 249, 127, 2, 80, 57, 220, 172, 89, 30, 51, 88, 155, 248, 237,
+       144, 79, 29, 181, 229, 199, 138, 214, 172, 75, 138, 210, 91, 97,
+       188, 232, 3, 127, 21, 103, 208, 168, 130, 150, 252, 231, 42, 162,
+       28, 151, 252, 166, 209, 14, 126, 82, 67, 194, 132, 203, 141, 167,
+       205, 229, 222, 252, 34, 238, 252, 211, 218, 153, 243, 113, 253,
+       189, 33, 93, 246, 55, 239, 168, 103, 14, 255, 58, 94, 207, 190,
+       215, 255, 240, 196, 190, 162, 170, 186, 15, 241, 152, 200, 151,
+       87, 149, 187, 13, 205, 107, 8, 255, 153, 151, 145, 30, 71, 202,
+       179, 219, 69, 155, 255, 183, 95, 60, 210, 165, 237, 81, 187, 228,
+       161, 206, 204, 86, 18, 217, 202, 245, 193, 185, 136, 91, 234, 6,
+       222, 123, 178, 78, 51, 36, 128, 175, 248, 148, 251, 176, 160, 6,
+       150, 58, 186, 242, 225, 187, 75, 30, 79, 93, 179, 236, 254, 46,
+       64, 247, 27, 147, 145, 150, 148, 42, 247, 76, 23, 26, 203, 148,
+       75, 165, 215, 86, 0, 131, 247, 3, 228, 233, 0, 169, 149, 67, 19,
+       221, 23, 12, 74, 232, 245, 59, 146, 25, 212, 248, 224, 149, 246,
+       218, 2, 160, 3, 37, 114, 42, 42, 226, 145, 79, 153, 176, 67, 239,
+       53, 198, 159, 138, 140, 86, 142, 232, 169, 235, 21, 6, 190, 215,
+       209, 87, 81, 26, 115, 199, 12, 127, 222, 58, 16, 98, 216, 87, 217,
+       248, 67, 13, 69, 244, 155, 8, 31, 54, 220, 232, 153, 151, 145, 30,
+       186, 112, 208, 147, 81, 154, 251, 55, 12, 60, 222, 166, 236, 241,
+       243, 244, 169, 254, 196, 91, 161, 185, 250, 255, 125, 93, 2, 159,
+       251, 95, 91, 187, 240, 220, 227, 188, 220, 143, 242, 205, 219,
+       211, 128, 147, 25, 99, 201, 86, 135, 235, 116, 52, 68, 82, 199,
+       57, 12, 182, 32, 126, 169, 19, 253, 183, 184, 52, 223, 116, 12,
+       138, 192, 109, 142, 113, 252, 158, 240, 186, 186, 11, 193, 25,
+       200, 158, 31, 149, 51, 60, 223, 106, 9, 235, 27, 191, 145, 26, 71,
+       10, 241, 219, 193, 122, 251, 144, 17, 45, 195, 63, 144, 116, 255,
+       39, 150, 220, 57, 21, 90, 247, 231, 232, 127, 190, 237, 223, 253,
+       159, 163, 252, 194, 104, 253, 211, 251, 223, 146, 23, 236, 224,
+       119, 164, 239, 193, 186, 252, 169, 206, 230, 25, 18, 121, 218,
+       243, 104, 221, 17, 91, 235, 71, 107, 122, 118, 206, 187, 44, 158,
+       229, 184, 213, 251, 210, 128, 106, 50, 162, 200, 91, 209, 144, 75,
+       143, 109, 148, 43, 12, 158, 102, 140, 204, 185, 251, 145, 14, 11,
+       242, 209, 147, 85, 155, 255, 19, 12, 61, 215, 10, 146, 116, 81,
+       53, 220, 249, 19, 235, 93, 54, 177, 153, 29, 150, 189, 134, 49,
+       245, 29, 151, 188, 117, 212, 71, 249, 48, 195, 230, 132, 78, 127,
+       26, 18, 246, 245, 39, 86, 120, 89, 47, 221, 214, 167, 108, 255,
+       159, 126, 246, 189, 183, 149, 141, 216, 179, 200, 219, 123, 250,
+       131, 167, 164, 45, 95, 103, 252, 251, 112, 244, 156, 254, 223,
+       187, 91, 120, 233, 238, 253, 221, 52, 191, 217, 117, 55, 230, 117,
+       170, 243, 255, 252, 7, 238, 199, 244, 195, 247, 3, 151, 106, 171,
+       210, 181, 187, 111, 30, 69, 95, 135, 236, 222, 46, 64, 247, 59,
+       147, 149, 150, 152, 28, 223, 108, 5, 154, 195, 29, 6, 185, 223,
+       150, 240, 190, 186, 235, 225, 157, 204, 138, 31, 149, 59, 29, 223,
+       106, 11, 235, 81, 255, 195, 2, 71, 138, 241, 219, 193, 239, 251,
+       180, 27, 175, 195, 204, 120, 251, 227, 198, 108, 123, 144, 161,
+       147, 55, 146, 25, 223, 89, 58, 38, 245, 253, 218, 131, 212, 188,
+       224, 87, 233, 170, 193, 167, 243, 110, 50, 106, 48, 50, 200, 91,
+       213, 144, 75, 143, 205, 148, 43, 44, 158, 102, 244, 220, 185, 255,
+       145, 7, 11, 178, 213, 155, 85, 155, 255, 18, 12, 45, 87, 58, 16,
+       50, 232, 31, 215, 144, 107, 141, 77, 180, 15, 14, 158, 38, 212,
+       236, 185, 223, 1, 12, 139, 48, 221, 147, 121, 26, 123, 83, 12, 47,
+       215, 90, 16, 54, 172, 31, 222, 176, 99, 45, 69, 246, 31, 46, 30,
+       38, 212, 236, 145, 219, 129, 172, 175, 49, 207, 147, 117, 26, 19,
+       83, 12, 45, 95, 107, 152, 116, 113, 101, 252, 217, 23, 201, 93,
+       54, 189, 170, 29, 150, 191, 134, 49, 245, 21, 135, 236, 246, 213,
+       71, 121, 16, 211, 71, 140, 92, 255, 182, 60, 240, 245, 254, 33,
+       250, 122, 89, 162, 248, 222, 109, 249, 85, 135, 255, 223, 87, 33,
+       176, 115, 212, 202, 62, 222, 79, 186, 239, 236, 83, 141, 3, 149,
+       98, 139, 215, 149, 186, 109, 31, 65, 93, 131, 105, 204, 62, 228,
+       222, 27, 147, 181, 215, 154, 60, 223, 47, 93, 138, 207, 23, 142,
+       185, 212, 34, 243, 121, 75, 250, 217, 179, 204, 15, 53, 56, 170,
+       40, 157, 236, 36, 62, 27, 135, 80, 2, 56, 44, 241, 46, 4, 36, 239,
+       213, 155, 199, 255, 122, 16, 114, 228, 117, 94, 216, 115, 57, 205,
+       182, 43, 14, 63, 54, 220, 238, 181, 215, 129, 140, 187, 48, 204,
+       147, 255, 154, 147, 71, 12, 126, 95, 91, 115, 122, 64, 123, 220,
+       57, 88, 169, 204, 151, 239, 61, 223, 222, 100, 54, 189, 255, 252,
+       135, 3, 180, 192, 87, 217, 35, 171, 47, 134, 47, 123, 47, 50, 111,
+       232, 117, 95, 249, 88, 207, 220, 84, 175, 251, 221, 183, 175, 94,
+       56, 151, 125, 143, 240, 118, 156, 79, 219, 225, 173, 222, 174, 92,
+       247, 114, 156, 241, 229, 122, 44, 250, 114, 57, 98, 250, 251, 120,
+       61, 149, 18, 175, 245, 119, 165, 169, 119, 209, 207, 54, 190, 73,
+       178, 77, 232, 98, 145, 179, 90, 111, 77, 28, 215, 137, 120, 68,
+       76, 214, 230, 112, 92, 182, 101, 92, 176, 23, 237, 239, 159, 119,
+       31, 87, 41, 168, 128, 61, 140, 116, 253, 210, 48, 62, 140, 29,
+       223, 185, 107, 173, 76, 148, 13, 174, 158, 38, 4, 236, 49, 223,
+       37, 228, 47, 178, 223, 147, 112, 10, 59, 80, 12, 47, 95, 167, 80,
+       235, 154, 197, 229, 187, 200, 95, 83, 101, 151, 154, 220, 127,
+       108, 251, 217, 179, 151, 135, 55, 190, 243, 87, 28, 155, 111, 213,
+       93, 117, 246, 10, 146, 238, 237, 45, 86, 121, 89, 143, 125, 86,
+       167, 137, 143, 246, 230, 206, 149, 191, 133, 141, 153, 183, 145,
+       199, 249, 235, 199, 22, 140, 124, 245, 218, 59, 252, 212, 47, 215,
+       25, 51, 159, 238, 150, 183, 172, 63, 70, 119, 206, 183, 255, 129,
+       253, 203, 243, 206, 219, 219, 255, 179, 38, 164, 37, 95, 235, 52,
+       245, 245, 127, 62, 184, 123, 121, 203, 244, 251, 106, 125, 148,
+       47, 255, 183, 215, 33, 188, 254, 229, 207, 95, 127, 186, 202, 239,
+       236, 86, 247, 16, 206, 95, 251, 246, 226, 106, 230, 52, 1, 91,
+       210, 117, 227, 176, 64, 123, 106, 2, 168, 48, 152, 13, 127, 252,
+       166, 170, 64, 181, 146, 165, 136, 169, 194, 104, 73, 53, 219, 97,
+       29, 119, 69, 118, 4, 171, 137, 178, 244, 88, 168, 134, 28, 143,
+       188, 117, 29, 70, 237, 48, 65, 123, 140, 92, 252, 186, 26, 110,
+       92, 86, 214, 155, 112, 16, 200, 214, 231, 113, 125, 182, 35, 124,
+       245, 181, 231, 233, 254, 117, 141, 83, 107, 233, 128, 109, 172,
+       116, 251, 143, 92, 254, 214, 100, 50, 255, 216, 249, 214, 86, 34,
+       93, 231, 191, 239, 103, 112, 55, 238, 225, 245, 62, 232, 70, 219,
+       231, 132, 134, 247, 125, 225, 15, 6, 254, 211, 228, 58, 125, 152,
+       253, 86, 119, 178, 217, 107, 191, 111, 247, 82, 181, 190, 164,
+       244, 46, 224, 70, 251, 231, 133, 166, 245, 125, 229, 98, 16, 59,
+       172, 109, 77, 88, 99, 169, 238, 176, 9, 174, 158, 39, 82, 206,
+       181, 255, 33, 76, 15, 240, 222, 147, 212, 138, 187, 16, 44, 39,
+       223, 114, 20, 115, 236, 125, 110, 216, 67, 41, 238, 176, 43, 14,
+       30, 39, 19, 238, 189, 223, 161, 12, 43, 240, 200, 151, 252, 154,
+       187, 65, 108, 103, 223, 41, 115, 239, 76, 108, 95, 233, 88, 207,
+       204, 53, 237, 187, 205, 247, 38, 14, 8, 215, 109, 195, 33, 182,
+       153, 70, 89, 33, 188, 95, 174, 94, 253, 17, 206, 75, 171, 150,
+       163, 106, 231, 52, 1, 91, 66, 113, 227, 48, 64, 123, 171, 7, 173,
+       58, 152, 13, 127, 248, 174, 170, 64, 189, 210, 177, 128, 17, 205,
+       11, 175, 148, 166, 111, 239, 116, 0, 203, 70, 113, 226, 48, 96,
+       120, 234, 10, 172, 26, 153, 29, 127, 248, 174, 171, 64, 57, 74,
+       240, 128, 180, 20, 59, 226, 135, 108, 81, 77, 137, 7, 189, 19, 94,
+       223, 40, 16, 250, 147, 21, 51, 42, 39, 56, 194, 209, 201, 2, 91,
+       113, 74, 165, 115, 42, 148, 228, 181, 53, 220, 185, 55, 27, 125,
+       86, 151, 175, 44, 22, 134, 207, 23, 245, 5, 167, 248, 245, 197,
+       207, 127, 154, 211, 199, 140, 95, 223, 106, 48, 231, 81, 117, 254,
+       249, 19, 121, 205, 118, 189, 136, 60, 150, 188, 175, 150, 247,
+       149, 181, 250, 117, 206, 79, 127, 242, 195, 207, 132, 94, 223, 3,
+       149, 40, 155, 213, 181, 186, 67, 95, 73, 93, 23, 40, 250, 62, 96,
+       249, 43, 147, 145, 150, 186, 10, 247, 123, 93, 154, 203, 153, 78,
+       253, 135, 188, 76, 110, 115, 165, 186, 255, 144, 117, 22, 119,
+       151, 75, 9, 191, 89, 123, 252, 149, 234, 172, 244, 124, 238, 71,
+       251, 210, 1, 231, 253, 124, 130, 191, 112, 227, 155, 87, 180, 250,
+       192, 31, 91, 83, 247, 12, 220, 124, 236, 255, 185, 151, 149, 183,
+       246, 56, 227, 21, 124, 186, 194, 151, 29, 180, 245, 138, 6, 228,
+       247, 197, 122, 253, 7, 29, 55, 215, 19, 141, 47, 87, 207, 235,
+       151, 191, 129, 48, 252, 97, 192, 199, 211, 218, 163, 167, 252,
+       221, 202, 27, 50, 121, 105, 57, 221, 89, 27, 143, 77, 60, 237,
+       159, 157, 246, 164, 134, 25, 213, 53, 143, 40, 50, 212, 203, 217,
+       40, 255, 222, 132, 15, 221, 138, 186, 38, 189, 53, 252, 184, 39,
+       185, 77, 86, 21, 174, 172, 22, 135, 132, 35, 253, 5, 180, 236,
+       242, 207, 207, 115, 218, 195, 70, 12, 127, 223, 21, 205, 11, 203,
+       212, 167, 234, 231, 86, 1, 203, 66, 113, 242, 48, 96, 121, 234,
+       18, 184, 27, 187, 28, 127, 57, 174, 143, 64, 185, 90, 240, 160,
+       188, 76, 122, 250, 117, 248, 126, 208, 245, 2, 119, 147, 107, 203,
+       63, 221, 123, 232, 135, 110, 108, 180, 28, 238, 230, 249, 128, 1,
+       127, 253, 104, 128, 235, 18, 190, 81, 113, 254, 121, 19, 127, 93,
+       118, 52, 12, 30, 134, 252, 231, 183, 183, 16, 182, 222, 97, 198,
+       95, 127, 18, 195, 130, 132, 111, 127, 3, 216, 234, 187, 86, 163,
+       186, 212, 30, 67, 91, 215, 85, 207, 56, 96, 127, 187, 19, 149,
+       162, 150, 28, 255, 124, 79, 191, 196, 189, 219, 49, 185, 247, 92,
+       197, 181, 143, 115, 140, 137, 150, 242, 130, 187, 209, 60, 83,
+       171, 79, 213, 249, 227, 109, 69, 127, 136, 145, 66, 223, 182, 61,
+       125, 24, 94, 141, 92, 125, 216, 199, 118, 183, 216, 80, 222, 118,
+       18, 80, 125, 63, 107, 53, 84, 19, 234, 161, 228, 57, 226, 83, 171,
+       99, 12, 247, 113, 101, 243, 203, 222, 39, 150, 226, 132, 189, 183,
+       188, 222, 82, 231, 124, 110, 179, 75, 167, 115, 191, 135, 229,
+       205, 34, 239, 112, 35, 254, 128, 4, 52, 181, 89, 184, 4, 126, 252,
+       95, 103, 209, 106, 81, 166, 245, 27, 11, 13, 55, 25, 120, 180,
+       199, 35, 104, 231, 113, 142, 211, 235, 193, 53, 119, 169, 118,
+       234, 186, 4, 118, 253, 15, 115, 85, 106, 149, 182, 230, 19, 11,
+       159, 35, 207, 233, 149, 171, 162, 104, 231, 115, 210, 215, 211,
+       219, 63, 51, 108, 124, 226, 23, 179, 120, 225, 54, 188, 249, 19,
+       171, 93, 60, 167, 140, 222, 214, 36, 166, 25, 221, 157, 150, 33,
+       166, 209, 203, 217, 171, 247, 199, 132, 71, 247, 7, 115, 105, 67,
+       114, 11, 59, 24, 44, 108, 95, 230, 221, 79, 154, 36, 54, 25, 23,
+       111, 131, 144, 45, 84, 70, 13, 43, 196, 46, 151, 17, 241, 23, 145,
+       124, 137, 142, 115, 154, 138, 79, 113, 157, 34, 92, 122, 127, 106,
+       235, 147, 187, 145, 23, 35, 95, 213, 218, 71, 219, 79, 157, 67,
+       41, 86, 13, 123, 120, 233, 126, 95, 235, 24, 168, 108, 53, 230,
+       157, 23, 155, 2, 110, 132, 223, 238, 193, 32, 108, 221, 198, 201,
+       171, 164, 63, 163, 91, 241, 140, 92, 127, 89, 230, 102, 255, 222,
+       84, 94, 116, 2, 80, 29, 39, 41, 125, 80, 23, 106, 225, 164, 49,
+       106, 99, 139, 102, 132, 83, 249, 229, 251, 7, 155, 39, 187, 229,
+       164, 168, 209, 140, 91, 80, 103, 236, 220, 60, 236, 205, 43, 23,
+       149, 151, 138, 50, 245, 132, 86, 250, 194, 156, 77, 177, 245, 15,
+       114, 105, 97, 50, 86, 153, 24, 75, 109, 86, 231, 217, 28, 159,
+       108, 22, 29, 149, 253, 135, 144, 101, 212, 70, 125, 171, 212, 239,
+       135, 7, 117, 19, 6, 151, 133, 146, 34, 60, 39, 173, 131, 203, 243,
+       44, 47, 164, 199, 103, 55, 31, 133, 48, 153, 5, 206, 162, 54, 30,
+       130, 165, 192, 161, 13, 164, 65, 238, 250, 196, 205, 240, 192,
+       222, 81, 97, 25, 211, 205, 63, 9, 152, 136, 83, 83, 14, 231, 26,
+       49, 199, 25, 80, 121, 80, 25, 214, 226, 38, 26, 239, 221, 174, 99,
+       185, 75, 142, 42, 211, 243, 80, 188, 165, 11, 206, 53, 59, 163,
+       48, 129, 67, 200, 68, 34, 235, 146, 149, 121, 21, 163, 214, 223,
+       247, 254, 186, 98, 30, 236, 147, 146, 153, 243, 109, 255, 233, 99,
+       119, 243, 189, 227, 120, 71, 14, 255, 184, 198, 239, 191, 181,
+       115, 165, 51, 214, 223, 87, 250, 170, 224, 191, 252, 172, 18, 219,
+       226, 117, 246, 169, 99, 119, 211, 47, 242, 115, 129, 46, 107, 176,
+       160, 111, 142, 181, 115, 165, 49, 184, 93, 121, 232, 226, 71, 127,
+       95, 16, 108, 124, 6, 29, 31, 34, 48, 230, 155, 23, 250, 240, 27,
+       48, 94, 115, 205, 36, 168, 113, 208, 166, 251, 243, 199, 111, 140,
+       14, 6, 79, 249, 197, 84, 240, 7, 67, 72, 190, 97, 122, 128, 63,
+       239, 236, 39, 39, 221, 114, 42, 227, 29, 117, 168, 240, 68, 19,
+       149, 190, 191, 134, 96, 181, 107, 124, 67, 73, 51, 244, 120, 46,
+       105, 243, 19, 27, 163, 119, 163, 31, 197, 241, 38, 90, 10, 29, 66,
+       165, 146, 214, 181, 56, 234, 250, 132, 27, 248, 170, 29, 205, 183,
+       28, 223, 42, 81, 246, 27, 25, 245, 182, 11, 186, 87, 91, 33, 42,
+       237, 52, 3, 167, 83, 38, 8, 218, 193, 246, 42, 250, 66, 173, 33,
+       251, 19, 28, 42, 52, 74, 238, 207, 95, 149, 16, 187, 129, 224, 20,
+       188, 186, 192, 133, 201, 241, 128, 130, 169, 104, 227, 244, 137,
+       248, 193, 173, 49, 179, 131, 189, 10, 92, 34, 238, 147, 95, 213,
+       146, 41, 65, 213, 222, 152, 154, 194, 101, 138, 225, 169, 118,
+       165, 144, 230, 157, 97, 222, 235, 155, 175, 185, 26, 78, 249, 93,
+       30, 153, 247, 221, 179, 56, 99, 136, 202, 187, 222, 143, 127, 193,
+       107, 207, 2, 124, 165, 144, 226, 221, 233, 214, 203, 203, 191,
+       185, 26, 142, 250, 105, 20, 249, 139, 206, 179, 26, 35, 138, 210,
+       185, 213, 143, 127, 210, 106, 246, 134, 194, 124, 117, 236, 126,
+       140, 250, 116, 169, 2, 176, 251, 173, 31, 149, 38, 238, 177, 87,
+       165, 161, 6, 210, 239, 182, 252, 154, 170, 79, 148, 99, 189, 162,
+       157, 111, 87, 134, 82, 181, 183, 80, 230, 78, 162, 48, 53, 150,
+       39, 76, 246, 19, 161, 225, 216, 117, 77, 101, 10, 222, 130, 101,
+       122, 212, 254, 48, 157, 121, 199, 210, 103, 157, 119, 16, 236,
+       124, 38, 48, 63, 6, 33, 125, 54, 151, 168, 241, 154, 113, 79, 111,
+       137, 164, 225, 241, 234, 228, 251, 16, 69, 30, 183, 54, 234, 181,
+       7, 236, 66, 90, 34, 245, 88, 41, 99, 98, 59, 58, 33, 65, 177, 3,
+       77, 224, 163, 122, 1, 76, 82, 33, 139, 126, 110, 244, 244, 45, 98,
+       210, 138, 123, 190, 176, 56, 106, 123, 69, 27, 217, 247, 229, 19,
+       40, 103, 202, 170, 155, 255, 213, 63, 195, 113, 94, 3, 15, 181,
+       117, 229, 118, 22, 249, 121, 77, 217, 253, 162, 157, 63, 254, 39,
+       110, 155, 151, 173, 148, 48, 44, 200, 127, 217, 170, 132, 119,
+       238, 229, 241, 67, 232, 83, 207, 76, 8, 236, 79, 45, 48, 250, 66,
+       28, 130, 116, 114, 106, 141, 126, 137, 67, 31, 195, 209, 180, 56,
+       218, 108, 29, 10, 225, 168, 174, 254, 236, 191, 142, 114, 159,
+       174, 18, 243, 152, 179, 205, 126, 221, 43, 95, 215, 253, 179, 254,
+       70, 239, 243, 236, 71, 255, 255, 181, 253, 180, 243, 158, 148,
+       212, 219, 138, 35, 158, 217, 22, 19, 153, 243, 93, 111, 169, 201,
+       127, 219, 23, 178, 59, 103, 11, 242, 218, 195, 239, 236, 191, 123,
+       161, 147, 252, 222, 212, 116, 175, 74, 84, 174, 25, 182, 182, 59,
+       111, 57, 5, 91, 211, 213, 164, 98, 104, 110, 203, 170, 251, 243,
+       85, 23, 99, 120, 206, 11, 147, 105, 87, 145, 78, 137, 232, 70, 44,
+       144, 250, 66, 188, 138, 85, 3, 106, 169, 78, 217, 67, 250, 215,
+       225, 148, 152, 138, 8, 77, 24, 97, 168, 3, 149, 42, 170, 148, 215,
+       190, 109, 6, 69, 217, 135, 225, 236, 62, 64, 220, 11, 147, 165,
+       222, 171, 28, 221, 43, 5, 138, 69, 29, 14, 185, 222, 180, 239, 90,
+       250, 236, 161, 94, 204, 147, 22, 245, 31, 67, 195, 111, 25, 249,
+       203, 7, 246, 106, 103, 10, 179, 240, 201, 165, 61, 49, 251, 234,
+       130, 6, 11, 80, 169, 70, 137, 232, 64, 15, 48, 242, 203, 133, 138,
+       117, 72, 122, 169, 110, 215, 66, 50, 65, 208, 148, 144, 138, 100,
+       61, 11, 113, 128, 91, 200, 241, 233, 103, 28, 248, 148, 109, 17,
+       246, 130, 155, 11, 29, 234, 110, 149, 63, 205, 202, 176, 213, 225,
+       215, 253, 178, 132, 39, 157, 241, 0, 180, 111, 94, 250, 206, 49,
+       207, 252, 147, 150, 177, 26, 65, 235, 253, 27, 249, 219, 23, 242,
+       120, 103, 10, 186, 122, 203, 231, 44, 117, 249, 246, 128, 90, 96,
+       244, 229, 53, 58, 250, 20, 117, 33, 242, 146, 171, 11, 28, 254,
+       110, 221, 127, 204, 136, 244, 197, 224, 214, 253, 146, 128, 231,
+       149, 96, 0, 34, 8, 242, 253, 236, 11, 252, 110, 125, 162, 240,
+       138, 111, 171, 117, 88, 254, 253, 63, 129, 188, 255, 135, 234, 22,
+       254, 223, 138, 215, 252, 225, 142, 238, 182, 237, 19, 140, 123,
+       157, 159, 82, 247, 159, 189, 193, 108, 223, 43, 95, 214, 253, 183,
+       190, 101, 239, 130, 111, 83, 253, 245, 229, 252, 212, 117, 182,
+       84, 236, 247, 206, 51, 223, 248, 147, 178, 177, 154, 81, 125, 253,
+       43, 127, 215, 255, 227, 232, 103, 127, 186, 123, 75, 237, 180,
+       245, 251, 244, 178, 163, 201, 69, 223, 116, 145, 238, 237, 93, 64,
+       84, 198, 185, 8, 182, 165, 90, 42, 18, 205, 231, 184, 117, 253,
+       38, 24, 142, 128, 95, 156, 248, 188, 188, 237, 238, 254, 220, 39,
+       79, 255, 147, 190, 189, 58, 67, 233, 255, 23, 121, 222, 21, 234,
+       120, 103, 8, 174, 122, 207, 229, 188, 247, 251, 242, 162, 133,
+       205, 83, 211, 132, 108, 239, 166, 124, 67, 74, 18, 213, 58, 57,
+       99, 97, 199, 10, 202, 113, 188, 61, 226, 173, 174, 150, 64, 169,
+       123, 225, 0, 149, 76, 19, 211, 133, 102, 230, 231, 84, 11, 106,
+       18, 16, 54, 36, 109, 233, 210, 2, 170, 121, 252, 56, 230, 49, 142,
+       214, 64, 193, 89, 240, 170, 8, 30, 254, 119, 130, 234, 49, 150,
+       180, 135, 126, 176, 241, 167, 33, 10, 47, 114, 227, 152, 48, 252,
+       35, 42, 79, 231, 116, 1, 227, 241, 45, 171, 53, 71, 106, 236, 84,
+       15, 79, 248, 84, 224, 254, 78, 115, 73, 59, 32, 124, 236, 23, 238,
+       201, 179, 61, 61, 115, 173, 161, 4, 125, 187, 120, 160, 122, 217,
+       121, 224, 173, 221, 221, 55, 139, 124, 188, 47, 31, 189, 87, 48,
+       174, 179, 245, 1, 205, 42, 114, 213, 243, 221, 253, 191, 119, 204,
+       212, 123, 180, 79, 24, 186, 229, 97, 87, 231, 17, 31, 120, 59, 2,
+       61, 35, 25, 249, 218, 134, 163, 120, 126, 8, 178, 113, 146, 244,
+       171, 209, 89, 246, 203, 35, 135, 104, 137, 215, 151, 140, 111, 78,
+       65, 92, 199, 161, 8, 62, 192, 92, 11, 147, 181, 214, 186, 85, 221,
+       46, 77, 138, 197, 61, 12, 248, 156, 118, 124, 121, 240, 188, 13,
+       153, 255, 137, 186, 176, 107, 159, 159, 213, 59, 207, 147, 95,
+       113, 146, 111, 194, 196, 251, 219, 62, 250, 132, 8, 131, 251, 114,
+       216, 121, 240, 108, 237, 221, 247, 15, 120, 184, 107, 159, 31, 84,
+       48, 239, 145, 223, 129, 200, 43, 114, 213, 255, 223, 255, 250, 85,
+       56, 135, 243, 158, 255, 214, 179, 151, 179, 62, 199, 127, 183, 29,
+       246, 109, 234, 239, 137, 183, 123, 133, 211, 246, 213, 12, 243,
+       170, 213, 31, 227, 167, 215, 141, 13, 151, 205, 253, 215, 182,
+       230, 190, 175, 219, 210, 10, 146, 253, 250, 125, 97, 183, 115, 57,
+       203, 243, 76, 30, 255, 173, 30, 223, 68, 156, 243, 129, 32, 49,
+       67, 107, 77, 86, 7, 239, 252, 85, 104, 254, 198, 81, 77, 181, 100,
+       126, 236, 22, 239, 201, 178, 53, 222, 117, 172, 163, 128, 127,
+       187, 112, 248, 6, 172, 234, 184, 94, 225, 187, 202, 30, 87, 81,
+       179, 4, 206, 127, 8, 251, 25, 147, 149, 54, 22, 14, 211, 92, 6,
+       187, 239, 149, 77, 53, 210, 134, 205, 229, 214, 150, 98, 191, 239,
+       211, 246, 25, 146, 120, 125, 61, 1, 255, 115, 49, 239, 240, 96,
+       62, 255, 107, 30, 223, 108, 245, 247, 229, 232, 182, 205, 232,
+       246, 244, 34, 223, 239, 147, 134, 41, 155, 97, 105, 125, 3, 219,
+       243, 19, 227, 124, 98, 142, 175, 123, 15, 197, 45, 181, 251, 254,
+       130, 148, 94, 151, 179, 133, 38, 228, 183, 53, 127, 90, 119, 0,
+       58, 37, 205, 249, 230, 6, 130, 253, 252, 9, 226, 60, 182, 246,
+       194, 137, 88, 248, 31, 172, 194, 140, 219, 200, 133, 61, 245, 158,
+       23, 69, 151, 80, 199, 106, 75, 77, 2, 163, 156, 114, 77, 90, 117,
+       79, 35, 246, 109, 144, 136, 252, 210, 162, 139, 109, 217, 232,
+       225, 41, 6, 142, 61, 164, 176, 128, 167, 100, 95, 77, 50, 107,
+       152, 50, 73, 106, 117, 77, 18, 218, 255, 144, 193, 68, 242, 136,
+       92, 183, 221, 32, 238, 161, 18, 156, 206, 86, 48, 180, 149, 161,
+       107, 64, 60, 31, 8, 33, 253, 32, 10, 69, 170, 114, 144, 210, 121,
+       5, 251, 66, 217, 185, 248, 108, 173, 251, 222, 31, 57, 184, 106,
+       190, 223, 104, 49, 239, 219, 95, 193, 139, 51, 194, 241, 213, 220,
+       58, 190, 28, 217, 1, 59, 6, 156, 187, 152, 236, 165, 185, 198,
+       158, 27, 216, 87, 156, 190, 125, 74, 239, 27, 59, 149, 179, 11,
+       18, 208, 77, 20, 122, 238, 156, 72, 33, 179, 214, 205, 192, 243,
+       149, 40, 238, 167, 121, 19, 75, 87, 229, 98, 29, 77, 113, 71, 8,
+       211, 112, 220, 25, 238, 172, 182, 223, 64, 168, 115, 249, 0, 156,
+       207, 94, 146, 215, 224, 239, 228, 220, 22, 105, 22, 109, 98, 59,
+       129, 123, 66, 2, 251, 115, 162, 56, 106, 40, 135, 143, 0, 157,
+       123, 237, 160, 189, 205, 90, 154, 196, 161, 143, 237, 144, 22,
+       137, 18, 113, 226, 121, 144, 91, 202, 130, 235, 123, 7, 28, 106,
+       248, 7, 175, 44, 157, 123, 250, 128, 37, 56, 27, 251, 252, 141,
+       255, 81, 45, 138, 241, 98, 190, 223, 165, 121, 255, 187, 31, 218,
+       147, 143, 90, 236, 221, 154, 190, 232, 152, 139, 227, 169, 146,
+       92, 122, 156, 119, 209, 176, 102, 157, 197, 84, 163, 44, 190, 39,
+       69, 238, 123, 147, 193, 36, 221, 38, 255, 63, 82, 218, 139, 23,
+       28, 45, 223, 198, 205, 214, 215, 150, 130, 46, 175, 59, 147, 10,
+       146, 237, 107, 121, 75, 179, 99, 49, 211, 114, 220, 14, 239, 172,
+       30, 223, 70, 132, 241, 145, 4, 134, 205, 229, 214, 150, 34, 142,
+       239, 211, 130, 8, 210, 113, 121, 61, 1, 191, 115, 49, 235, 240,
+       96, 14, 255, 40, 30, 207, 46, 229, 243, 225, 136, 104, 173, 40,
+       42, 209, 149, 218, 231, 115, 77, 236, 29, 42, 140, 86, 16, 221,
+       171, 131, 149, 254, 42, 242, 119, 123, 157, 148, 105, 121, 4, 254,
+       218, 251, 173, 98, 88, 89, 213, 90, 230, 243, 73, 236, 25, 42,
+       218, 118, 180, 216, 170, 151, 212, 127, 11, 210, 255, 59, 221,
+       136, 123, 91, 4, 250, 94, 247, 237, 200, 254, 252, 35, 206, 237,
+       154, 130, 153, 90, 112, 232, 125, 19, 249, 211, 19, 239, 120, 99,
+       10, 110, 56, 14, 205, 60, 253, 251, 242, 160, 150, 223, 135, 179,
+       149, 102, 166, 167, 53, 31, 91, 118, 0, 34, 37, 205, 249, 207, 6,
+       163, 121, 252, 9, 226, 189, 182, 254, 194, 137, 89, 245, 29, 198,
+       88, 51, 192, 237, 213, 158, 212, 137, 90, 144, 107, 140, 223, 101,
+       43, 135, 81, 223, 83, 198, 7, 170, 226, 179, 88, 14, 187, 22, 63,
+       5, 87, 9, 199, 83, 225, 116, 175, 235, 118, 108, 9, 123, 100, 221,
+       243, 152, 224, 126, 44, 94, 44, 129, 176, 1, 93, 244, 191, 34,
+       132, 76, 218, 225, 161, 231, 27, 110, 156, 110, 84, 185, 120, 137,
+       220, 245, 199, 40, 222, 55, 123, 236, 241, 183, 231, 204, 67, 246,
+       233, 83, 58, 202, 171, 29, 37, 118, 215, 9, 11, 115, 239, 116, 14,
+       235, 184, 108, 136, 90, 230, 253, 11, 145, 224, 254, 69, 31, 127,
+       145, 184, 69, 237, 252, 189, 42, 192, 12, 139, 81, 169, 129, 92,
+       149, 157, 44, 63, 76, 18, 92, 106, 80, 76, 183, 16, 145, 239, 204,
+       101, 94, 13, 161, 78, 85, 59, 132, 58, 122, 144, 24, 249, 25, 189,
+       18, 79, 106, 152, 211, 151, 190, 230, 189, 196, 94, 135, 44, 142,
+       55, 196, 110, 171, 147, 215, 198, 155, 20, 255, 50, 4, 158, 203,
+       55, 29, 61, 220, 185, 65, 96, 225, 167, 18, 94, 85, 81, 32, 246,
+       146, 27, 15, 149, 249, 126, 132, 149, 234, 248, 178, 117, 142,
+       242, 201, 130, 1, 39, 156, 240, 224, 198, 205, 199, 247, 150, 162,
+       46, 175, 59, 147, 10, 210, 237, 107, 121, 75, 179, 99, 49, 243,
+       114, 216, 15, 239, 172, 86, 223, 70, 132, 243, 145, 4, 49, 81,
+       107, 79, 84, 215, 239, 124, 69, 200, 255, 6, 81, 223, 191, 32,
+       120, 168, 23, 238, 201, 178, 61, 220, 119, 173, 166, 132, 127,
+       154, 112, 248, 134, 205, 206, 247, 150, 34, 174, 239, 82, 146, 8,
+       210, 113, 107, 61, 1, 251, 99, 19, 235, 112, 105, 12, 111, 40, 14,
+       207, 68, 189, 243, 233, 136, 212, 95, 147, 179, 149, 102, 71, 167,
+       53, 15, 203, 119, 2, 50, 37, 201, 233, 198, 8, 162, 121, 253, 25,
+       98, 177, 166, 214, 66, 169, 89, 244, 26, 217, 214, 62, 255, 46,
+       12, 220, 53, 173, 58, 242, 115, 255, 31, 25, 99, 238, 151, 253,
+       195, 232, 229, 65, 237, 243, 251, 250, 144, 12, 216, 33, 27, 66,
+       52, 218, 218, 211, 225, 49, 71, 47, 5, 109, 41, 44, 247, 111, 88,
+       179, 187, 171, 144, 2, 10, 178, 115, 95, 149, 20, 107, 146, 210,
+       165, 251, 211, 91, 107, 86, 118, 250, 123, 48, 121, 206, 86, 239,
+       123, 92, 183, 121, 54, 244, 149, 103, 161, 180, 52, 110, 50, 46,
+       32, 130, 109, 179, 116, 125, 166, 205, 193, 246, 244, 34, 206,
+       175, 211, 130, 57, 218, 97, 104, 61, 129, 219, 226, 19, 43, 120,
+       102, 78, 191, 44, 30, 197, 46, 149, 251, 210, 128, 180, 207, 11,
+       154, 150, 96, 230, 231, 156, 7, 249, 87, 64, 96, 45, 201, 121,
+       194, 2, 131, 113, 238, 24, 98, 41, 134, 222, 65, 249, 123, 252,
+       146, 141, 237, 18, 138, 205, 241, 231, 204, 198, 22, 237, 130,
+       201, 194, 235, 236, 91, 74, 130, 250, 71, 3, 46, 179, 246, 193,
+       135, 45, 190, 255, 169, 132, 19, 77, 98, 154, 85, 147, 170, 230,
+       149, 200, 222, 231, 40, 136, 183, 196, 232, 235, 147, 207, 204,
+       155, 4, 255, 58, 60, 142, 195, 31, 63, 57, 220, 57, 101, 107, 236,
+       116, 215, 71, 124, 69, 200, 252, 2, 83, 219, 53, 112, 216, 188,
+       23, 232, 73, 179, 104, 158, 243, 253, 165, 132, 57, 186, 118, 235,
+       45, 203, 66, 231, 100, 26, 110, 113, 101, 128, 95, 230, 211, 3,
+       144, 228, 122, 236, 62, 238, 201, 152, 69, 204, 172, 237, 166,
+       192, 46, 170, 90, 161, 222, 88, 191, 176, 169, 116, 93, 18, 185,
+       222, 150, 53, 223, 191, 99, 123, 167, 117, 253, 19, 188, 197, 178,
+       226, 219, 251, 127, 219, 130, 117, 37, 83, 187, 149, 126, 225,
+       166, 150, 254, 241, 5, 88, 246, 243, 219, 31, 190, 97, 255, 159,
+       159, 227, 252, 184, 97, 151, 239, 249, 170, 198, 53, 136, 240,
+       243, 150, 205, 244, 246, 182, 162, 78, 172, 91, 146, 10, 18, 229,
+       107, 121, 73, 179, 115, 57, 235, 112, 77, 14, 255, 168, 222, 223,
+       87, 164, 243, 161, 4, 53, 107, 72, 205, 180, 26, 110, 49, 117,
+       160, 255, 230, 211, 2, 145, 244, 90, 236, 46, 110, 221, 184, 69,
+       44, 166, 239, 164, 144, 46, 186, 216, 4, 50, 173, 123, 210, 215,
+       209, 187, 103, 27, 141, 124, 186, 44, 183, 100, 148, 127, 186,
+       151, 152, 114, 26, 160, 255, 59, 213, 132, 235, 151, 140, 247,
+       235, 170, 175, 106, 88, 85, 197, 251, 247, 83, 69, 124, 159, 42,
+       141, 54, 21, 124, 186, 147, 133, 250, 58, 52, 255, 123, 92, 16,
+       107, 119, 140, 246, 202, 59, 141, 106, 120, 81, 151, 90, 99, 85,
+       4, 228, 142, 43, 202, 54, 177, 252, 187, 130, 164, 255, 186, 52,
+       191, 51, 221, 128, 41, 123, 140, 106, 156, 29, 203, 74, 229, 118,
+       19, 110, 113, 101, 160, 255, 226, 219, 3, 210, 228, 126, 204, 14,
+       238, 204, 178, 229, 140, 246, 237, 167, 132, 47, 186, 104, 140, 3,
+       1, 126, 251, 236, 173, 184, 15, 175, 25, 91, 51, 140, 187, 180,
+       104, 231, 27, 63, 21, 146, 152, 11, 213, 142, 58, 218, 194, 148,
+       202, 161, 139, 150, 205, 228, 214, 150, 130, 142, 236, 83, 146, 8,
+       210, 97, 233, 125, 129, 251, 115, 49, 235, 112, 105, 14, 255, 42,
+       30, 207, 102, 149, 243, 225, 132, 183, 205, 194, 222, 244, 35,
+       206, 238, 155, 130, 56, 218, 112, 232, 125, 2, 219, 195, 19, 235,
+       121, 99, 10, 110, 56, 14, 205, 60, 157, 251, 250, 136, 144, 86,
+       151, 179, 132, 102, 164, 183, 21, 123, 218, 119, 0, 42, 36, 201,
+       249, 230, 6, 130, 253, 252, 17, 234, 180, 182, 246, 194, 136, 88,
+       252, 31, 57, 203, 82, 164, 86, 19, 111, 97, 69, 164, 255, 130, 75,
+       131, 178, 228, 122, 204, 6, 238, 76, 179, 45, 204, 242, 237, 135,
+       5, 103, 186, 106, 164, 5, 148, 165, 209, 133, 118, 37, 159, 118,
+       115, 134, 80, 145, 55, 200, 239, 97, 22, 58, 152, 187, 220, 125,
+       82, 141, 154, 223, 68, 130, 208, 181, 116, 60, 195, 74, 228, 87,
+       82, 239, 248, 69, 192, 254, 70, 81, 73, 182, 132, 120, 236, 6,
+       234, 201, 179, 60, 204, 114, 205, 167, 5, 111, 186, 120, 160, 2,
+       149, 27, 191, 242, 164, 189, 55, 60, 11, 90, 112, 180, 55, 32, 64,
+       247, 59, 51, 1, 179, 152, 3, 79, 101, 54, 62, 192, 156, 80, 161,
+       187, 153, 157, 124, 237, 166, 86, 253, 59, 46, 126, 157, 183, 189,
+       63, 178, 97, 230, 19, 159, 163, 253, 28, 57, 253, 231, 235, 234,
+       197, 63, 140, 253, 115, 23, 36, 252, 243, 108, 35, 248, 72, 207,
+       179, 181, 211, 141, 223, 220, 11, 239, 157, 95, 191, 166, 103,
+       207, 208, 150, 218, 219, 175, 23, 143, 105, 133, 132, 205, 138,
+       155, 150, 96, 231, 231, 28, 15, 121, 22, 100, 98, 43, 9, 105, 195,
+       2, 211, 115, 172, 24, 106, 40, 6, 254, 64, 249, 123, 233, 128,
+       222, 60, 190, 176, 139, 124, 17, 146, 179, 255, 134, 63, 15, 191,
+       67, 155, 167, 247, 253, 145, 60, 71, 186, 194, 219, 211, 93, 255,
+       163, 117, 15, 83, 216, 80, 190, 252, 42, 84, 29, 63, 168, 94, 150,
+       181, 253, 255, 187, 107, 198, 119, 253, 199, 229, 197, 179, 169,
+       243, 251, 250, 153, 46, 240, 173, 123, 130, 157, 189, 218, 187,
+       212, 186, 247, 143, 89, 157, 119, 140, 158, 118, 102, 239, 59,
+       255, 149, 246, 13, 250, 241, 255, 88, 158, 235, 150, 6, 165, 223,
+       173, 237, 18, 170, 205, 177, 143, 204, 194, 22, 141, 14, 77, 227,
+       251, 196, 123, 74, 130, 254, 83, 39, 14, 178, 248, 193, 175, 61,
+       191, 255, 185, 160, 61, 219, 99, 206, 87, 215, 199, 241, 69, 204,
+       253, 102, 114, 221, 166, 164, 124, 232, 134, 238, 205, 179, 60,
+       189, 114, 77, 167, 138, 123, 190, 252, 245, 47, 114, 250, 241,
+       245, 246, 251, 87, 219, 239, 125, 183, 153, 159, 246, 164, 95,
+       189, 151, 157, 133, 246, 244, 194, 79, 221, 183, 171, 239, 204,
+       255, 247, 178, 189, 123, 249, 183, 211, 149, 231, 222, 52, 180,
+       50, 60, 158, 228, 161, 234, 59, 150, 80, 115, 171, 48, 255, 43,
+       217, 143, 115, 81, 8, 239, 175, 255, 120, 114, 224, 238, 55, 222,
+       216, 89, 250, 180, 186, 29, 31, 215, 63, 238, 213, 223, 239, 172,
+       103, 229, 232, 214, 251, 235, 190, 103, 253, 115, 245, 198, 207,
+       215, 247, 151, 162, 46, 175, 59, 147, 11, 82, 229, 107, 121, 75,
+       179, 99, 49, 211, 114, 220, 30, 239, 173, 54, 223, 70, 132, 113,
+       145, 6, 15, 112, 244, 243, 239, 125, 190, 216, 139, 127, 189, 191,
+       204, 125, 222, 46, 223, 211, 223, 211, 151, 99, 251, 225, 87, 95,
+       254, 191, 223, 255, 151, 247, 134, 205, 228, 214, 182, 34, 174,
+       238, 211, 146, 8, 210, 96, 235, 125, 1, 187, 115, 49, 235, 114,
+       104, 14, 255, 40, 30, 223, 110, 157, 243, 225, 136, 183, 237, 193,
+       158, 252, 35, 206, 236, 154, 130, 152, 90, 112, 232, 125, 147, 89,
+       219, 19, 239, 120, 99, 10, 126, 56, 14, 205, 60, 181, 251, 242,
+       168, 168, 22, 150, 253, 165, 38, 180, 87, 156, 31, 90, 117, 196,
+       57, 160, 203, 201, 38, 166, 0, 180, 252, 3, 138, 2, 246, 246, 131,
+       154, 124, 184, 19, 60, 17, 123, 236, 116, 211, 119, 121, 69, 65,
+       253, 42, 31, 221, 48, 112, 122, 189, 151, 99, 89, 178, 96, 140,
+       247, 253, 161, 109, 119, 138, 246, 227, 54, 113, 99, 72, 95, 215,
+       86, 252, 69, 232, 248, 239, 66, 220, 47, 116, 124, 252, 199, 242,
+       205, 179, 60, 28, 51, 76, 133, 159, 123, 63, 118, 215, 61, 123,
+       99, 78, 127, 151, 215, 244, 69, 200, 253, 239, 114, 220, 167, 52,
+       220, 248, 150, 110, 204, 163, 44, 188, 115, 77, 165, 138, 115,
+       190, 116, 247, 47, 77, 99, 94, 255, 145, 159, 247, 205, 64, 124,
+       167, 40, 204, 183, 228, 94, 122, 146, 110, 197, 171, 46, 255, 34,
+       28, 4, 138, 87, 159, 248, 253, 39, 89, 103, 143, 77, 150, 239,
+       112, 196, 192, 223, 70, 112, 72, 183, 229, 104, 224, 18, 239, 197,
+       163, 60, 236, 33, 40, 202, 0, 127, 191, 120, 252, 110, 176, 162,
+       210, 253, 213, 155, 217, 139, 93, 149, 191, 236, 222, 126, 164,
+       223, 19, 223, 145, 151, 71, 250, 243, 123, 93, 143, 251, 150, 14,
+       189, 215, 137, 253, 63, 121, 157, 223, 247, 229, 254, 93, 240, 16,
+       158, 152, 50, 33, 232, 51, 78, 81, 254, 173, 48, 63, 239, 217, 6,
+       87, 80, 0, 199, 226, 199, 200, 242, 255, 108, 153, 248, 208, 255,
+       148, 246, 179, 237, 223, 253, 111, 230, 125, 255, 223, 230, 119,
+       143, 226, 158, 249, 207, 206, 22, 173, 97, 141, 157, 203, 81, 232,
+       2, 67, 79, 248, 69, 68, 189, 130, 91, 67, 185, 36, 126, 200, 22,
+       234, 201, 6, 44, 88, 240, 200, 171, 172, 55, 179, 32, 224, 189,
+       75, 73, 232, 220, 71, 79, 252, 64, 164, 172, 10, 81, 67, 179, 112,
+       120, 192, 6, 250, 73, 35, 108, 30, 249, 205, 167, 60, 53, 187,
+       118, 232, 7, 195, 254, 237, 236, 3, 252, 236, 207, 145, 240, 195,
+       237, 255, 60, 194, 238, 211, 127, 205, 196, 227, 7, 240, 182, 218,
+       206, 131, 149, 156, 105, 141, 156, 207, 202, 154, 197, 96, 231,
+       230, 28, 6, 120, 86, 68, 96, 43, 129, 121, 203, 2, 242, 115, 173,
+       24, 106, 32, 6, 190, 64, 185, 123, 233, 130, 172, 223, 8, 154,
+       197, 97, 199, 230, 24, 78, 253, 94, 86, 224, 43, 193, 73, 202, 2,
+       210, 127, 46, 120, 114, 180, 5, 174, 41, 185, 91, 236, 208, 218,
+       94, 174, 188, 9, 212, 93, 51, 176, 222, 134, 181, 169, 46, 19,
+       203, 224, 247, 253, 135, 236, 77, 243, 171, 211, 227, 218, 153,
+       34, 36, 61, 90, 207, 112, 115, 224, 105, 188, 120, 88, 123, 234,
+       117, 177, 189, 223, 247, 124, 247, 185, 255, 159, 198, 55, 174,
+       211, 215, 223, 187, 174, 6, 165, 39, 247, 11, 205, 96, 95, 215,
+       221, 190, 231, 95, 64, 124, 130, 41, 204, 55, 228, 46, 59, 147,
+       207, 198, 168, 118, 255, 39, 92, 158, 235, 87, 29, 153, 204, 3,
+       50, 173, 145, 54, 61, 185, 95, 30, 253, 84, 239, 181, 12, 222, 40,
+       134, 27, 159, 21, 135, 248, 101, 128, 206, 29, 56, 178, 220, 204,
+       29, 221, 122, 61, 224, 26, 223, 240, 184, 71, 171, 69, 60, 187,
+       40, 189, 87, 148, 34, 187, 213, 145, 22, 43, 166, 243, 55, 117,
+       26, 171, 231, 196, 255, 223, 122, 138, 226, 150, 79, 240, 184, 71,
+       171, 85, 156, 163, 40, 172, 118, 142, 239, 183, 163, 133, 142, 43,
+       166, 241, 23, 117, 154, 171, 231, 70, 255, 222, 42, 214, 230, 154,
+       79, 240, 188, 103, 137, 87, 221, 183, 8, 172, 118, 207, 235, 163,
+       179, 133, 220, 127, 246, 208, 23, 115, 222, 235, 215, 78, 191,
+       222, 15, 22, 120, 233, 247, 127, 251, 91, 93, 79, 125, 255, 159,
+       125, 187, 164, 191, 155, 151, 61, 183, 176, 36, 222, 230, 221, 34,
+       239, 254, 205, 77, 247, 43, 217, 247, 237, 124, 23, 248, 255, 207,
+       120, 244, 227, 29, 191, 180, 38, 238, 221, 255, 237, 214, 187,
+       103, 197, 95, 217, 239, 246, 23, 172, 103, 247, 48, 169, 249, 228,
+       212, 79, 71, 237, 64, 164, 184, 10, 115, 41, 20, 0, 88, 206, 6,
+       107, 89, 186, 97, 46, 241, 140, 165, 48, 101, 186, 212, 40, 134,
+       207, 199, 215, 150, 162, 110, 167, 59, 147, 10, 18, 229, 107, 121,
+       75, 179, 99, 49, 219, 114, 220, 14, 235, 173, 22, 223, 69, 132,
+       241, 177, 4, 19, 197, 42, 137, 213, 213, 188, 239, 94, 109, 88, 7,
+       56, 188, 54, 32, 249, 139, 19, 213, 214, 184, 53, 255, 127, 13,
+       158, 225, 85, 28, 189, 222, 84, 57, 58, 236, 63, 139, 151, 73,
+       143, 172, 253, 45, 206, 207, 100, 0, 254, 61, 239, 34, 90, 33,
+       186, 223, 243, 213, 3, 63, 80, 42, 135, 115, 0, 133, 43, 175, 180,
+       198, 173, 231, 20, 41, 90, 147, 213, 255, 56, 96, 247, 63, 19,
+       165, 113, 152, 16, 95, 233, 166, 190, 196, 20, 2, 165, 250, 189,
+       12, 107, 221, 70, 115, 239, 112, 84, 194, 126, 130, 121, 205, 183,
+       97, 122, 232, 19, 238, 225, 180, 52, 234, 118, 107, 226, 128, 119,
+       255, 116, 224, 219, 114, 121, 244, 111, 213, 185, 88, 185, 238,
+       149, 255, 28, 159, 215, 255, 230, 181, 255, 175, 229, 71, 178,
+       218, 215, 219, 235, 187, 14, 165, 47, 247, 219, 211, 119, 228, 63,
+       84, 219, 120, 205, 204, 150, 239, 191, 223, 246, 39, 238, 145,
+       255, 237, 207, 39, 167, 205, 243, 121, 171, 155, 79, 172, 45, 127,
+       232, 193, 39, 177, 221, 205, 100, 53, 85, 72, 82, 88, 246, 89, 24,
+       165, 136, 162, 123, 121, 251, 124, 115, 191, 255, 91, 68, 72, 66,
+       12, 212, 106, 137, 221, 63, 184, 205, 207, 117, 255, 221, 82, 246,
+       7, 190, 25, 50, 97, 232, 131, 90, 111, 239, 45, 51, 253, 245, 27,
+       86, 68, 90, 24, 240, 74, 150, 205, 228, 214, 150, 34, 142, 238,
+       83, 146, 8, 146, 97, 233, 125, 1, 251, 115, 17, 235, 112, 105, 14,
+       255, 40, 30, 207, 100, 157, 243, 225, 128, 166, 205, 197, 246,
+       212, 32, 206, 239, 83, 146, 41, 218, 99, 105, 125, 129, 219, 227,
+       19, 227, 120, 98, 14, 175, 56, 30, 197, 108, 149, 251, 242, 136,
+       148, 223, 131, 179, 149, 102, 167, 167, 60, 15, 91, 119, 192, 34,
+       45, 73, 241, 199, 12, 147, 121, 252, 25, 98, 168, 166, 254, 194,
+       137, 89, 241, 31, 214, 91, 91, 228, 118, 2, 187, 240, 139, 168,
+       50, 230, 93, 159, 225, 102, 54, 213, 21, 234, 161, 49, 172, 222,
+       126, 232, 171, 230, 47, 179, 1, 185, 35, 170, 227, 5, 87, 240,
+       171, 72, 123, 100, 121, 231, 40, 204, 246, 148, 122, 44, 147, 221,
+       135, 58, 172, 255, 30, 60, 131, 238, 71, 135, 119, 245, 163, 72,
+       103, 222, 76, 151, 238, 240, 213, 10, 208, 70, 113, 205, 181, 101,
+       72, 232, 19, 239, 237, 175, 54, 253, 35, 42, 226, 128, 95, 189,
+       112, 172, 118, 93, 107, 102, 199, 36, 222, 172, 32, 194, 187, 79,
+       83, 124, 93, 18, 181, 215, 117, 231, 205, 39, 152, 42, 113, 237,
+       141, 28, 109, 115, 250, 18, 235, 134, 34, 90, 205, 157, 236, 101,
+       221, 86, 101, 28, 40, 200, 126, 173, 205, 42, 162, 28, 246, 126,
+       118, 210, 15, 88, 84, 107, 211, 12, 216, 204, 2, 144, 190, 218,
+       239, 181, 184, 215, 159, 91, 17, 119, 188, 222, 124, 106, 167, 27,
+       183, 145, 150, 76, 26, 243, 15, 94, 218, 239, 156, 12, 165, 223,
+       151, 76, 111, 223, 6, 246, 175, 80, 252, 194, 214, 198, 113, 228,
+       183, 109, 118, 228, 58, 239, 161, 181, 53, 236, 48, 42, 202, 128,
+       61, 243, 49, 116, 164, 207, 211, 154, 212, 96, 239, 230, 88, 22,
+       104, 18, 96, 106, 61, 129, 89, 107, 2, 227, 112, 246, 24, 111, 40,
+       134, 207, 68, 149, 123, 240, 128, 83, 201, 110, 174, 15, 208, 158,
+       101, 165, 68, 206, 131, 45, 78, 50, 64, 106, 163, 153, 197, 76,
+       137, 23, 253, 241, 112, 138, 131, 55, 22, 185, 76, 128, 0, 220,
+       145, 238, 233, 176, 3, 222, 151, 16, 50, 164, 58, 213, 75, 107,
+       171, 34, 145, 48, 108, 70, 192, 12, 18, 94, 107, 133, 72, 197,
+       138, 237, 217, 17, 218, 205, 93, 70, 189, 95, 234, 160, 72, 210,
+       116, 100, 244, 209, 222, 42, 74, 89, 62, 123, 183, 173, 158, 85,
+       124, 24, 58, 208, 60, 14, 147, 44, 131, 187, 151, 56, 57, 143, 61,
+       141, 167, 76, 95, 46, 204, 247, 17, 187, 148, 150, 137, 107, 213,
+       15, 87, 219, 215, 150, 14, 141, 71, 66, 154, 184, 94, 59, 84, 152,
+       45, 139, 29, 228, 161, 236, 190, 38, 70, 206, 113, 251, 129, 134,
+       11, 162, 209, 3, 118, 90, 155, 16, 36, 45, 207, 123, 177, 193, 71,
+       49, 220, 202, 53, 41, 225, 237, 140, 43, 23, 156, 180, 30, 254,
+       148, 204, 223, 186, 244, 201, 59, 252, 128, 114, 111, 134, 202,
+       252, 46, 103, 99, 234, 213, 167, 107, 84, 7, 5, 125, 130, 9, 231,
+       113, 84, 124, 187, 147, 216, 26, 146, 56, 254, 127, 204, 133, 40,
+       183, 219, 228, 224, 130, 176, 191, 216, 127, 245, 184, 95, 159,
+       95, 20, 55, 172, 222, 118, 111, 199, 59, 159, 145, 182, 79, 178,
+       243, 75, 92, 154, 235, 150, 12, 165, 223, 214, 205, 214, 247, 150,
+       162, 62, 175, 59, 147, 11, 146, 237, 107, 121, 75, 179, 99, 49,
+       243, 114, 220, 14, 239, 168, 214, 223, 71, 132, 113, 145, 6, 148,
+       95, 11, 147, 148, 102, 167, 183, 52, 79, 251, 118, 66, 34, 167,
+       73, 249, 198, 12, 162, 125, 253, 9, 106, 176, 166, 246, 194, 137,
+       89, 252, 91, 163, 201, 102, 220, 92, 147, 204, 228, 197, 0, 208,
+       194, 32, 136, 180, 101, 72, 168, 19, 207, 238, 171, 70, 253, 34,
+       58, 210, 9, 85, 152, 248, 140, 119, 121, 139, 134, 206, 84, 151,
+       200, 136, 208, 141, 10, 80, 254, 111, 42, 120, 213, 241, 226, 65,
+       3, 186, 96, 241, 37, 207, 60, 9, 59, 59, 242, 30, 153, 122, 224,
+       215, 218, 186, 240, 173, 13, 254, 167, 12, 159, 38, 64, 254, 117,
+       207, 97, 84, 155, 16, 224, 246, 245, 11, 215, 175, 47, 173, 147,
+       191, 23, 110, 188, 167, 94, 93, 113, 185, 222, 182, 191, 79, 63,
+       191, 255, 174, 181, 221, 167, 253, 199, 53, 206, 243, 123, 236,
+       147, 47, 244, 190, 119, 166, 205, 228, 246, 212, 162, 206, 239,
+       83, 146, 40, 154, 96, 105, 125, 1, 219, 242, 19, 163, 112, 106,
+       78, 191, 40, 30, 197, 100, 157, 250, 210, 128, 139, 140, 96, 217,
+       215, 183, 250, 127, 29, 81, 92, 150, 41, 62, 182, 229, 127, 27,
+       151, 189, 183, 152, 53, 255, 47, 127, 154, 195, 191, 140, 185,
+       221, 235, 193, 72, 222, 108, 221, 76, 53, 21, 106, 84, 74, 115,
+       85, 176, 245, 88, 172, 51, 110, 105, 30, 210, 191, 127, 59, 244,
+       232, 30, 136, 216, 184, 148, 223, 131, 187, 149, 102, 167, 247,
+       20, 79, 123, 119, 64, 32, 45, 201, 249, 194, 6, 163, 121, 252, 24,
+       106, 45, 134, 246, 194, 201, 89, 244, 223, 14, 1, 238, 211, 153,
+       243, 56, 73, 175, 53, 143, 131, 76, 79, 62, 88, 99, 19, 139, 144,
+       22, 129, 47, 212, 75, 87, 159, 87, 150, 135, 173, 70, 86, 1, 10,
+       170, 148, 165, 90, 68, 7, 33, 205, 15, 32, 243, 107, 64, 216, 171,
+       27, 212, 30, 3, 24, 252, 251, 133, 139, 121, 152, 11, 184, 10, 67,
+       159, 57, 155, 186, 164, 61, 183, 62, 73, 91, 245, 252, 247, 168,
+       96, 102, 27, 63, 129, 211, 24, 47, 119, 108, 37, 58, 200, 28, 194,
+       129, 121, 63, 31, 105, 109, 55, 247, 95, 51, 85, 110, 212, 231,
+       187, 62, 151, 245, 78, 189, 149, 165, 189, 146, 117, 142, 230,
+       255, 160, 128, 191, 228, 124, 85, 95, 30, 199, 172, 7, 54, 174,
+       96, 172, 194, 218, 199, 109, 174, 179, 235, 102, 101, 191, 231,
+       229, 209, 20, 232, 144, 98, 202, 130, 174, 247, 57, 85, 11, 57,
+       114, 200, 119, 253, 121, 83, 237, 76, 126, 7, 44, 158, 55, 244,
+       166, 59, 223, 21, 199, 169, 54, 213, 83, 89, 8, 203, 71, 140, 77,
+       95, 164, 207, 200, 154, 213, 225, 199, 231, 24, 14, 121, 30, 100,
+       98, 43, 129, 89, 203, 130, 227, 123, 38, 24, 110, 56, 6, 174, 109,
+       153, 123, 251, 136, 10, 151, 41, 153, 186, 245, 61, 63, 142, 93,
+       92, 247, 188, 254, 170, 96, 215, 59, 191, 5, 215, 8, 119, 215,
+       111, 21, 187, 238, 28, 12, 149, 117, 15, 188, 169, 145, 179, 253,
+       185, 219, 14, 125, 28, 215, 188, 252, 222, 40, 173, 11, 151, 157,
+       151, 120, 254, 209, 79, 93, 191, 238, 223, 76, 151, 247, 130, 166,
+       158, 208, 236, 165, 184, 119, 154, 155, 112, 88, 172, 170, 196,
+       43, 135, 51, 55, 17, 178, 110, 66, 194, 12, 26, 126, 234, 132,
+       200, 137, 137, 97, 220, 201, 236, 92, 86, 70, 191, 83, 106, 232,
+       76, 115, 210, 116, 240, 217, 204, 52, 202, 207, 30, 220, 187, 36,
+       255, 181, 60, 25, 186, 250, 156, 31, 141, 242, 231, 180, 150, 254,
+       241, 89, 200, 95, 163, 221, 127, 191, 100, 255, 211, 151, 255,
+       246, 184, 45, 239, 250, 255, 175, 199, 167, 175, 241, 245, 63,
+       157, 241, 238, 244, 52, 254, 242, 73, 202, 252, 227, 125, 127,
+       189, 164, 255, 243, 151, 239, 132, 34, 76, 239, 254, 223, 175,
+       174, 191, 255, 113, 215, 75, 64, 162, 196, 44, 16, 184, 81, 135,
+       32, 86, 162, 141, 159, 240, 228, 126, 61, 191, 205, 196, 21, 167,
+       208, 86, 121, 171, 174, 22, 140, 49, 245, 150, 205, 198, 247, 151,
+       224, 110, 167, 59, 147, 10, 19, 229, 107, 121, 75, 51, 99, 49,
+       211, 114, 220, 15, 231, 169, 214, 223, 69, 132, 113, 153, 10, 61,
+       104, 138, 170, 141, 181, 150, 207, 130, 1, 137, 9, 166, 216, 113,
+       168, 217, 227, 217, 3, 14, 35, 26, 177, 179, 213, 139, 59, 136,
+       95, 186, 6, 3, 155, 153, 187, 242, 177, 58, 251, 62, 89, 89, 245,
+       164, 54, 168, 80, 199, 27, 6, 20, 183, 26, 10, 119, 140, 148, 58,
+       234, 152, 0, 163, 157, 139, 158, 102, 157, 171, 246, 184, 247,
+       189, 94, 150, 183, 237, 62, 182, 239, 231, 51, 255, 164, 245, 205,
+       55, 221, 2, 251, 218, 211, 30, 228, 41, 223, 27, 30, 42, 200, 53,
+       223, 253, 119, 157, 78, 92, 52, 12, 190, 182, 229, 238, 48, 151,
+       44, 181, 137, 48, 222, 178, 125, 154, 139, 158, 236, 248, 93, 170,
+       174, 102, 154, 127, 177, 184, 103, 159, 29, 92, 183, 44, 174, 182,
+       197, 239, 187, 151, 149, 182, 31, 6, 245, 30, 112, 154, 203, 151,
+       4, 61, 223, 11, 159, 194, 154, 255, 181, 184, 231, 159, 93, 92,
+       167, 44, 168, 182, 196, 239, 171, 147, 133, 182, 59, 6, 255, 30,
+       86, 154, 235, 159, 76, 57, 205, 35, 236, 200, 77, 64, 22, 206,
+       254, 18, 106, 252, 68, 49, 147, 181, 112, 88, 236, 19, 206, 205,
+       158, 212, 187, 102, 237, 174, 176, 59, 242, 122, 152, 134, 205,
+       228, 215, 151, 162, 174, 239, 91, 146, 8, 18, 225, 107, 125, 11,
+       251, 115, 49, 243, 112, 120, 30, 239, 40, 30, 223, 70, 133, 115,
+       161, 132, 150, 222, 135, 179, 133, 102, 165, 183, 53, 127, 210,
+       119, 4, 42, 167, 205, 253, 78, 6, 130, 253, 252, 9, 226, 176, 182,
+       246, 194, 136, 89, 244, 95, 135, 134, 229, 129, 230, 51, 237, 138,
+       86, 251, 147, 242, 209, 108, 220, 175, 127, 197, 126, 191, 189,
+       213, 109, 210, 140, 2, 239, 228, 165, 253, 177, 229, 6, 200, 246,
+       253, 6, 130, 104, 65, 143, 1, 82, 130, 73, 235, 60, 76, 122, 189,
+       59, 136, 0, 145, 23, 208, 6, 254, 195, 7, 62, 170, 120, 132, 130,
+       147, 9, 136, 250, 193, 145, 127, 158, 93, 220, 247, 132, 246, 170,
+       64, 222, 27, 159, 1, 183, 11, 98, 215, 204, 20, 186, 255, 156, 8,
+       149, 223, 166, 205, 229, 214, 212, 34, 206, 239, 83, 162, 41, 218,
+       96, 105, 61, 1, 219, 246, 49, 171, 248, 98, 14, 191, 56, 30, 197,
+       46, 165, 250, 242, 136, 22, 27, 6, 148, 211, 151, 190, 66, 189,
+       204, 218, 167, 76, 206, 182, 228, 254, 253, 179, 197, 213, 155, 6,
+       236, 176, 118, 139, 195, 143, 37, 165, 245, 214, 223, 133, 179,
+       149, 110, 102, 167, 121, 31, 90, 87, 226, 42, 9, 203, 241, 199, 4,
+       147, 120, 220, 25, 230, 173, 246, 222, 195, 169, 113, 241, 15,
+       222, 90, 206, 180, 34, 162, 58, 84, 176, 134, 214, 231, 61, 171,
+       163, 74, 102, 245, 189, 231, 36, 213, 128, 234, 240, 231, 238,
+       129, 45, 241, 41, 91, 58, 93, 114, 238, 109, 213, 86, 96, 157, 76,
+       252, 11, 42, 221, 55, 52, 216, 185, 151, 99, 76, 35, 58, 191, 243,
+       221, 128, 59, 119, 63, 118, 255, 132, 223, 139, 155, 150, 98, 166,
+       247, 28, 79, 122, 86, 64, 34, 45, 201, 249, 203, 6, 147, 117, 252,
+       24, 98, 40, 134, 246, 195, 233, 91, 253, 155, 172, 223, 8, 154,
+       197, 225, 167, 247, 16, 78, 125, 95, 72, 226, 43, 197, 89, 202,
+       134, 254, 115, 54, 124, 114, 244, 5, 174, 233, 185, 95, 237, 241,
+       41, 219, 104, 25, 21, 223, 164, 103, 87, 69, 94, 7, 162, 136, 54,
+       164, 72, 42, 130, 5, 223, 184, 118, 189, 39, 69, 144, 3, 127, 12,
+       216, 222, 73, 43, 55, 60, 99, 156, 180, 71, 232, 156, 114, 101,
+       46, 216, 134, 59, 166, 41, 102, 4, 196, 248, 162, 65, 22, 185,
+       114, 10, 64, 4, 231, 207, 59, 79, 102, 92, 125, 219, 86, 230, 205,
+       68, 124, 8, 42, 200, 183, 181, 40, 162, 130, 110, 228, 171, 38,
+       253, 50, 123, 64, 27, 83, 159, 122, 204, 34, 27, 100, 193, 77, 80,
+       232, 87, 69, 244, 180, 135, 41, 13, 54, 71, 104, 128, 163, 128,
+       135, 58, 55, 221, 23, 80, 146, 35, 127, 140, 124, 222, 150, 205,
+       198, 247, 151, 160, 46, 167, 58, 147, 74, 18, 237, 235, 121, 79,
+       51, 107, 49, 211, 114, 220, 31, 231, 173, 214, 223, 69, 164, 113,
+       145, 10, 223, 102, 198, 37, 44, 58, 252, 8, 241, 234, 151, 255,
+       203, 40, 215, 43, 63, 229, 253, 191, 237, 245, 197, 202, 218, 75,
+       255, 149, 239, 245, 123, 20, 218, 95, 234, 188, 34, 146, 62, 118,
+       189, 198, 86, 231, 45, 175, 183, 83, 102, 239, 189, 197, 228, 157,
+       132, 234, 242, 99, 238, 139, 45, 244, 57, 91, 26, 126, 234, 251,
+       178, 163, 187, 87, 22, 13, 94, 167, 189, 143, 162, 8, 127, 59,
+       151, 148, 146, 156, 1, 251, 238, 197, 190, 128, 183, 222, 181,
+       251, 26, 143, 110, 168, 50, 162, 91, 246, 5, 5, 222, 167, 45, 35,
+       34, 64, 119, 163, 15, 181, 170, 155, 5, 253, 248, 199, 186, 193,
+       180, 198, 45, 75, 89, 93, 250, 127, 98, 0, 191, 182, 120, 206,
+       126, 167, 185, 250, 135, 112, 126, 239, 53, 195, 204, 190, 180,
+       235, 102, 44, 126, 128, 109, 112, 99, 223, 93, 33, 196, 53, 140,
+       34, 228, 43, 102, 186, 211, 66, 81, 120, 217, 203, 121, 196, 120,
+       189, 157, 240, 207, 0, 28, 43, 231, 68, 237, 229, 248, 128, 134,
+       205, 229, 215, 182, 162, 174, 239, 91, 146, 8, 210, 97, 235, 125,
+       129, 251, 115, 49, 227, 112, 104, 14, 255, 40, 30, 223, 70, 149,
+       243, 161, 140, 166, 205, 196, 246, 212, 32, 206, 239, 83, 146, 41,
+       154, 97, 105, 125, 1, 219, 227, 19, 163, 120, 106, 14, 255, 56,
+       30, 197, 108, 157, 250, 240, 136, 148, 93, 151, 179, 149, 102, 38,
+       167, 21, 55, 75, 23, 66, 58, 32, 77, 249, 246, 0, 130, 61, 252,
+       25, 162, 169, 182, 222, 66, 136, 89, 188, 14, 19, 146, 131, 165,
+       54, 7, 168, 118, 29, 171, 210, 227, 20, 63, 180, 40, 255, 185, 23,
+       133, 137, 185, 1, 222, 144, 14, 250, 134, 149, 8, 49, 169, 160,
+       20, 158, 223, 205, 38, 180, 3, 220, 23, 103, 21, 196, 57, 45, 203,
+       205, 51, 162, 1, 48, 236, 82, 130, 71, 179, 82, 3, 216, 105, 141,
+       146, 3, 15, 170, 222, 86, 246, 186, 98, 191, 202, 214, 231, 104,
+       254, 183, 101, 124, 123, 187, 205, 177, 203, 6, 239, 56, 54, 139,
+       203, 15, 37, 57, 151, 3, 157, 182, 223, 255, 144, 191, 166, 222,
+       142, 90, 167, 168, 232, 247, 68, 227, 107, 43, 213, 242, 232, 182,
+       239, 44, 62, 222, 138, 159, 116, 33, 222, 173, 239, 0, 138, 228,
+       177, 142, 212, 212, 30, 29, 254, 237, 226, 235, 132, 91, 74, 6,
+       110, 242, 34, 12, 178, 52, 5, 175, 172, 159, 255, 169, 128, 219,
+       95, 66, 148, 50, 178, 62, 246, 177, 202, 222, 231, 45, 174, 183,
+       199, 102, 229, 191, 199, 229, 221, 164, 238, 178, 99, 238, 131,
+       47, 245, 41, 93, 186, 93, 122, 238, 93, 213, 87, 236, 209, 76,
+       252, 11, 43, 221, 55, 52, 216, 185, 215, 99, 110, 35, 114, 191,
+       243, 221, 0, 59, 115, 63, 118, 126, 2, 8, 190, 213, 71, 196, 185,
+       103, 236, 27, 70, 2, 188, 187, 32, 110, 162, 51, 59, 137, 0, 217,
+       18, 193, 69, 58, 90, 2, 128, 0, 33, 171, 35, 175, 234, 30, 240,
+       177, 190, 199, 122, 15, 120, 175, 32, 168, 55, 16, 237, 235, 163,
+       197, 150, 58, 134, 243, 54, 28, 190, 171, 221, 85, 251, 207, 159,
+       206, 111, 201, 54, 194, 171, 208, 116, 70, 94, 226, 25, 77, 181,
+       100, 126, 120, 23, 239, 226, 181, 36, 238, 96, 44, 170, 196, 103,
+       179, 117, 225, 19, 26, 55, 217, 34, 229, 185, 18, 174, 94, 86,
+       230, 188, 150, 165, 108, 166, 49, 63, 151, 131, 129, 51, 209, 128,
+       208, 250, 130, 156, 65, 37, 253, 152, 106, 243, 53, 115, 220, 177,
+       118, 120, 206, 118, 117, 172, 137, 151, 140, 166, 111, 229, 13,
+       224, 252, 164, 238, 100, 127, 54, 128, 71, 132, 103, 249, 150,
+       205, 246, 247, 151, 224, 62, 175, 186, 147, 74, 18, 237, 235, 89,
+       75, 51, 127, 49, 219, 114, 220, 143, 255, 175, 214, 223, 69, 164,
+       117, 145, 10, 134, 205, 198, 215, 150, 160, 238, 175, 91, 147, 91,
+       19, 225, 235, 125, 75, 251, 107, 35, 147, 114, 248, 15, 231, 46,
+       30, 223, 71, 133, 114, 241, 138, 41, 206, 101, 91, 52, 155, 74,
+       182, 87, 1, 250, 206, 163, 0, 148, 164, 72, 226, 14, 220, 171,
+       184, 109, 191, 46, 207, 180, 80, 119, 139, 80, 44, 35, 165, 37,
+       155, 223, 245, 184, 111, 206, 81, 89, 19, 168, 252, 60, 167, 200,
+       35, 147, 149, 182, 42, 62, 221, 45, 24, 138, 75, 213, 12, 183,
+       238, 0, 162, 73, 2, 58, 137, 10, 156, 46, 37, 128, 200, 167, 134,
+       200, 32, 86, 24, 74, 92, 130, 12, 205, 51, 172, 4, 38, 188, 20,
+       138, 15, 173, 67, 33, 216, 129, 56, 202, 104, 3, 175, 224, 146,
+       200, 159, 134, 87, 126, 6, 37, 124, 157, 149, 201, 213, 64, 140,
+       24, 15, 208, 140, 128, 9, 12, 146, 158, 239, 181, 178, 224, 184,
+       103, 189, 135, 82, 179, 45, 175, 164, 65, 231, 59, 135, 145, 176,
+       216, 0, 206, 8, 119, 126, 195, 165, 68, 165, 251, 125, 111, 248,
+       229, 132, 58, 79, 27, 67, 164, 158, 10, 83, 41, 211, 106, 122,
+       196, 108, 43, 200, 242, 229, 8, 250, 237, 229, 53, 165, 250, 80,
+       40, 47, 31, 99, 156, 212, 242, 171, 90, 180, 204, 218, 231, 120,
+       223, 183, 196, 120, 234, 179, 205, 189, 155, 38, 254, 118, 47,
+       186, 200, 135, 173, 116, 241, 131, 188, 148, 91, 219, 242, 184,
+       79, 90, 179, 224, 176, 156, 58, 102, 251, 235, 27, 146, 145, 55,
+       126, 95, 255, 12, 18, 223, 103, 153, 64, 171, 158, 166, 207, 193,
+       214, 244, 34, 206, 239, 83, 138, 57, 218, 96, 104, 61, 129, 223,
+       247, 23, 227, 248, 98, 14, 255, 58, 30, 229, 174, 149, 251, 242,
+       137, 220, 124, 219, 100, 38, 90, 118, 198, 241, 202, 118, 34, 31,
+       185, 229, 255, 162, 252, 188, 114, 105, 245, 160, 170, 179, 233,
+       101, 3, 227, 249, 111, 43, 218, 95, 255, 188, 242, 194, 61, 119,
+       184, 206, 118, 179, 45, 167, 163, 83, 102, 119, 141, 128, 96, 221,
+       160, 111, 241, 227, 126, 131, 38, 244, 165, 123, 148, 205, 151,
+       243, 149, 102, 229, 167, 85, 91, 75, 18, 80, 59, 36, 109, 233,
+       118, 34, 144, 57, 252, 25, 162, 169, 254, 214, 66, 129, 89, 244,
+       42, 164, 12, 191, 251, 229, 98, 181, 231, 29, 31, 122, 51, 0, 63,
+       36, 73, 201, 91, 2, 16, 56, 252, 35, 234, 39, 150, 214, 3, 209,
+       121, 244, 235, 27, 63, 37, 169, 183, 179, 186, 198, 12, 73, 88,
+       231, 173, 44, 181, 160, 190, 171, 151, 213, 159, 184, 4, 253, 170,
+       87, 170, 131, 156, 93, 185, 221, 181, 237, 120, 106, 188, 113,
+       142, 236, 198, 210, 185, 10, 211, 232, 127, 33, 219, 74, 2, 123,
+       238, 35, 76, 58, 106, 201, 165, 61, 213, 123, 216, 128, 165, 205,
+       236, 126, 244, 51, 206, 238, 82, 226, 189, 154, 81, 248, 191, 33,
+       217, 238, 48, 111, 253, 231, 108, 63, 106, 79, 229, 61, 221, 123,
+       216, 196, 157, 125, 222, 167, 182, 42, 179, 208, 100, 224, 90,
+       231, 223, 57, 131, 11, 46, 229, 87, 243, 173, 240, 5, 104, 236,
+       129, 47, 128, 237, 243, 35, 147, 40, 121, 196, 181, 109, 217, 228,
+       19, 10, 248, 86, 237, 191, 157, 83, 142, 8, 44, 247, 69, 65, 248,
+       211, 160, 69, 81, 233, 161, 79, 60, 94, 250, 113, 243, 81, 128,
+       122, 139, 153, 152, 43, 53, 176, 205, 143, 130, 68, 16, 54, 133,
+       108, 125, 198, 43, 212, 85, 152, 144, 11, 124, 76, 132, 3, 65,
+       116, 226, 241, 161, 188, 8, 74, 140, 67, 117, 177, 87, 195, 72,
+       220, 78, 217, 204, 108, 255, 218, 98, 207, 145, 174, 216, 135,
+       126, 175, 190, 208, 4, 182, 143, 200, 186, 214, 49, 222, 231, 25,
+       6, 121, 255, 109, 104, 43, 137, 251, 203, 134, 243, 126, 126, 76,
+       250, 60, 199, 223, 235, 253, 127, 250, 149, 139, 207, 207, 191,
+       242, 214, 190, 246, 220, 202, 122, 226, 120, 254, 53, 224, 111,
+       123, 178, 194, 229, 152, 46, 255, 46, 47, 238, 137, 21, 249, 104,
+       141, 162, 174, 39, 217, 245, 183, 237, 103, 158, 23, 73, 149, 160,
+       231, 52, 141, 201, 58, 147, 12, 114, 220, 51, 223, 45, 30, 222,
+       192, 154, 76, 215, 244, 218, 94, 78, 180, 114, 146, 60, 118, 185,
+       142, 94, 231, 45, 174, 163, 215, 102, 231, 189, 197, 228, 221, 4,
+       238, 178, 99, 254, 131, 47, 244, 43, 93, 150, 205, 183, 247, 151,
+       228, 255, 167, 123, 151, 66, 18, 237, 127, 121, 107, 179, 119, 49,
+       211, 114, 220, 59, 227, 173, 254, 223, 70, 164, 113, 181, 42, 148,
+       75, 95, 111, 150, 74, 71, 240, 228, 132, 243, 34, 87, 67, 169, 81,
+       114, 228, 12, 106, 104, 165, 45, 44, 240, 225, 38, 64, 101, 179,
+       101, 97, 99, 15, 200, 94, 202, 177, 206, 167, 75, 136, 124, 238,
+       40, 98, 149, 180, 79, 234, 150, 204, 149, 10, 198, 251, 62, 60,
+       158, 171, 159, 245, 250, 157, 139, 159, 71, 201, 183, 179, 170,
+       230, 141, 72, 218, 230, 168, 92, 181, 229, 238, 51, 158, 253, 183,
+       185, 37, 253, 46, 88, 138, 194, 31, 141, 57, 189, 148, 75, 91,
+       173, 146, 194, 47, 112, 228, 4, 242, 162, 51, 195, 161, 80, 118,
+       233, 14, 234, 88, 153, 4, 46, 240, 161, 38, 1, 49, 179, 37, 129,
+       58, 111, 227, 181, 37, 90, 236, 118, 49, 194, 82, 226, 47, 173,
+       209, 174, 62, 126, 149, 137, 105, 253, 132, 202, 160, 118, 220,
+       131, 231, 252, 182, 252, 160, 6, 31, 152, 60, 239, 64, 114, 220,
+       168, 208, 120, 150, 131, 160, 65, 200, 176, 78, 32, 184, 143, 0,
+       30, 144, 129, 234, 144, 16, 8, 53, 161, 210, 51, 19, 225, 48, 141,
+       16, 19, 169, 233, 144, 109, 174, 159, 196, 144, 132, 57, 205, 17,
+       207, 29, 144, 192, 139, 208, 10, 242, 8, 132, 11, 159, 199, 22,
+       191, 200, 108, 37, 152, 107, 137, 154, 152, 121, 28, 254, 117, 35,
+       207, 17, 95, 161, 160, 7, 2, 210, 153, 28, 239, 190, 156, 104, 49,
+       51, 134, 205, 238, 215, 150, 240, 191, 167, 91, 151, 94, 19, 233,
+       253, 125, 75, 123, 123, 51, 211, 114, 248, 47, 227, 111, 95, 223,
+       199, 133, 113, 245, 170, 148, 221, 154, 210, 144, 164, 191, 247,
+       180, 67, 207, 22, 117, 247, 41, 105, 117, 243, 27, 238, 113, 205,
+       24, 106, 249, 174, 222, 64, 137, 243, 161, 32, 66, 157, 151, 249,
+       160, 172, 45, 151, 188, 23, 66, 16, 188, 179, 32, 127, 199, 51,
+       59, 24, 51, 216, 50, 224, 205, 246, 222, 194, 136, 192, 161, 41,
+       181, 233, 105, 74, 212, 215, 195, 232, 87, 104, 244, 74, 82, 216,
+       189, 48, 88, 136, 22, 122, 251, 178, 124, 63, 59, 12, 161, 100,
+       117, 139, 118, 228, 101, 131, 133, 43, 236, 40, 229, 157, 86, 19,
+       185, 209, 211, 97, 216, 74, 89, 70, 106, 61, 19, 96, 79, 0, 76,
+       62, 118, 92, 220, 218, 208, 160, 135, 59, 31, 248, 234, 165, 185,
+       218, 142, 24, 80, 98, 148, 223, 97, 11, 167, 25, 19, 83, 195, 65,
+       2, 80, 4, 144, 111, 238, 28, 24, 33, 161, 34, 31, 98, 172, 116,
+       162, 207, 122, 85, 192, 126, 163, 99, 237, 183, 100, 92, 238, 19,
+       237, 184, 186, 71, 175, 36, 126, 131, 138, 127, 175, 116, 244,
+       100, 130, 181, 187, 189, 121, 192, 169, 95, 123, 153, 120, 230,
+       120, 88, 168, 211, 2, 254, 49, 30, 96, 107, 149, 140, 86, 117,
+       127, 214, 78, 212, 71, 46, 207, 228, 246, 244, 34, 222, 191, 83,
+       150, 57, 251, 105, 233, 253, 129, 223, 247, 181, 227, 244, 234,
+       78, 191, 42, 95, 213, 231, 247, 255, 218, 135, 95, 95, 67, 180,
+       242, 178, 174, 118, 189, 202, 218, 231, 109, 166, 183, 197, 102,
+       231, 159, 199, 229, 217, 4, 238, 176, 118, 238, 130, 175, 245, 57,
+       93, 23, 160, 107, 163, 211, 20, 234, 200, 36, 65, 207, 135, 81,
+       78, 122, 112, 121, 137, 19, 255, 31, 146, 61, 241, 223, 13, 139,
+       68, 173, 11, 184, 208, 25, 129, 105, 231, 23, 210, 233, 37, 100,
+       97, 206, 2, 121, 26, 24, 224, 104, 135, 25, 141, 27, 152, 117,
+       237, 181, 237, 154, 65, 37, 2, 240, 106, 166, 148, 173, 219, 236,
+       38, 173, 27, 158, 123, 151, 86, 208, 109, 29, 107, 221, 6, 123,
+       191, 178, 100, 123, 210, 79, 27, 223, 212, 149, 249, 208, 224,
+       231, 68, 229, 151, 45, 51, 140, 136, 207, 242, 147, 218, 201, 108,
+       221, 175, 205, 69, 125, 239, 173, 101, 127, 160, 130, 90, 207,
+       150, 151, 255, 80, 116, 17, 77, 127, 237, 86, 194, 235, 230, 92,
+       128, 106, 66, 53, 51, 49, 96, 98, 111, 19, 248, 97, 185, 16, 110,
+       121, 172, 174, 0, 37, 17, 97, 168, 101, 25, 241, 143, 190, 106,
+       135, 17, 78, 193, 155, 226, 212, 240, 197, 110, 70, 36, 126, 29,
+       145, 32, 239, 192, 44, 60, 39, 222, 158, 238, 209, 117, 6, 111,
+       199, 196, 180, 43, 107, 86, 141, 164, 26, 230, 36, 231, 177, 142,
+       126, 96, 79, 127, 33, 209, 1, 232, 176, 20, 167, 128, 174, 255,
+       20, 113, 198, 184, 255, 218, 239, 248, 184, 130, 155, 95, 20, 187,
+       172, 252, 127, 43, 135, 115, 251, 17, 182, 77, 186, 241, 27, 58,
+       94, 235, 148, 77, 21, 87, 131, 149, 240, 217, 247, 148, 248, 247,
+       155, 91, 49, 243, 156, 63, 252, 163, 239, 155, 151, 145, 246, 78,
+       32, 199, 79, 94, 222, 238, 151, 140, 241, 215, 214, 221, 175, 246,
+       147, 230, 63, 191, 187, 211, 8, 151, 125, 239, 109, 75, 55, 247,
+       49, 247, 243, 205, 62, 239, 249, 198, 223, 70, 173, 240, 165, 120,
+       1, 79, 7, 229, 20, 134, 234, 182, 52, 136, 218, 70, 177, 1, 177,
+       96, 120, 230, 22, 253, 201, 184, 1, 44, 236, 174, 166, 192, 109,
+       144, 112, 40, 146, 29, 58, 184, 146, 225, 191, 199, 156, 7, 216,
+       183, 60, 254, 35, 64, 239, 59, 147, 145, 50, 141, 18, 255, 240, 6,
+       158, 139, 189, 89, 165, 219, 67, 49, 229, 209, 236, 20, 120, 7,
+       43, 241, 22, 179, 140, 62, 214, 127, 230, 149, 253, 149, 150, 74,
+       181, 192, 95, 122, 218, 239, 134, 149, 167, 127, 49, 31, 121, 207,
+       214, 182, 194, 126, 85, 68, 126, 198, 115, 40, 183, 224, 88, 238,
+       2, 108, 189, 186, 117, 191, 103, 175, 146, 0, 253, 139, 120, 252,
+       162, 174, 167, 147, 213, 173, 105, 134, 155, 23, 64, 223, 160,
+       229, 124, 141, 205, 42, 147, 29, 50, 220, 178, 183, 13, 26, 220,
+       226, 134, 76, 212, 236, 191, 226, 156, 196, 44, 21, 90, 232, 139,
+       188, 149, 34, 110, 131, 231, 167, 207, 84, 238, 110, 76, 71, 235,
+       201, 154, 219, 69, 191, 6, 169, 40, 5, 246, 19, 163, 86, 140, 194,
+       198, 241, 244, 140, 247, 112, 64, 243, 252, 70, 88, 116, 45, 250,
+       24, 231, 170, 34, 123, 190, 231, 195, 195, 35, 244, 35, 230, 91,
+       166, 94, 189, 192, 135, 212, 196, 140, 214, 96, 96, 243, 229, 110,
+       216, 118, 173, 122, 152, 227, 170, 170, 123, 58, 167, 219, 130,
+       59, 244, 35, 109, 160, 152, 171, 173, 93, 212, 141, 70, 251, 145,
+       56, 214, 216, 90, 170, 217, 12, 126, 57, 95, 38, 203, 144, 206,
+       221, 53, 127, 216, 78, 216, 15, 3, 33, 226, 193, 231, 25, 248, 73,
+       41, 177, 49, 155, 13, 31, 92, 62, 190, 153, 243, 157, 150, 82,
+       182, 192, 31, 88, 218, 231, 231, 132, 227, 230, 213, 64, 255, 100,
+       15, 78, 71, 200, 233, 146, 167, 10, 87, 213, 93, 123, 48, 212,
+       104, 106, 105, 101, 187, 0, 243, 234, 69, 30, 97, 59, 103, 34, 62,
+       201, 228, 227, 7, 10, 94, 160, 17, 48, 50, 2, 107, 43, 25, 29,
+       122, 213, 21, 218, 72, 240, 93, 168, 187, 219, 196, 1, 167, 191,
+       80, 10, 158, 122, 195, 240, 101, 200, 252, 208, 137, 206, 80, 235,
+       14, 157, 97, 138, 238, 249, 151, 65, 69, 55, 160, 192, 146, 217,
+       174, 170, 143, 189, 119, 219, 167, 172, 172, 215, 141, 116, 221,
+       175, 154, 247, 13, 21, 240, 237, 94, 11, 201, 74, 51, 157, 178,
+       108, 251, 243, 111, 95, 223, 104, 146, 108, 212, 218, 26, 238,
+       238, 188, 159, 195, 191, 230, 134, 247, 152, 163, 45, 236, 99, 2,
+       43, 127, 187, 193, 70, 137, 134, 255, 248, 103, 191, 175, 165,
+       124, 53, 202, 35, 204, 96, 136, 85, 137, 70, 231, 83, 0, 232, 139,
+       34, 136, 52, 240, 217, 170, 2, 5, 94, 62, 196, 191, 59, 60, 148,
+       107, 117, 28, 242, 142, 66, 184, 241, 236, 114, 4, 152, 59, 171,
+       136, 48, 233, 60, 191, 245, 50, 166, 113, 21, 37, 224, 75, 128,
+       206, 155, 126, 79, 190, 84, 160, 35, 187, 61, 77, 106, 231, 118,
+       82, 255, 120, 69, 192, 95, 130, 121, 79, 183, 224, 126, 252, 151,
+       238, 200, 176, 45, 236, 243, 237, 171, 129, 39, 191, 124, 248, 8,
+       138, 209, 249, 100, 13, 237, 254, 63, 22, 120, 199, 189, 175, 113,
+       144, 63, 11, 7, 140, 195, 56, 82, 211, 70, 221, 118, 172, 127,
+       240, 67, 185, 57, 73, 217, 249, 86, 171, 230, 214, 95, 3, 126,
+       130, 187, 73, 189, 172, 127, 186, 6, 72, 11, 176, 101, 251, 102,
+       207, 48, 0, 255, 216, 72, 184, 57, 76, 80, 79, 87, 187, 227, 214,
+       87, 97, 126, 142, 107, 17, 167, 100, 122, 238, 6, 88, 15, 186,
+       117, 191, 118, 238, 16, 0, 255, 223, 120, 140, 178, 207, 115, 94,
+       211, 181, 175, 230, 125, 7, 108, 142, 35, 166, 181, 228, 125, 250,
+       2, 206, 234, 58, 60, 255, 53, 254, 158, 42, 83, 89, 231, 252, 208,
+       239, 137, 99, 151, 78, 235, 252, 82, 168, 26, 74, 51, 9, 93, 66,
+       49, 206, 29, 251, 107, 125, 153, 43, 125, 173, 183, 229, 45, 27,
+       89, 42, 216, 141, 233, 103, 23, 64, 235, 172, 118, 165, 191, 2,
+       121, 41, 93, 194, 57, 198, 121, 218, 34, 124, 137, 99, 125, 173,
+       165, 37, 101, 131, 68, 42, 109, 164, 40, 163, 237, 45, 67, 169,
+       83, 123, 181, 28, 211, 120, 90, 59, 217, 132, 116, 63, 159, 118,
+       217, 23, 221, 223, 229, 116, 200, 107, 218, 18, 3, 233, 43, 143,
+       114, 132, 189, 119, 172, 64, 88, 199, 188, 142, 182, 32, 238, 59,
+       19, 205, 199, 153, 52, 237, 100, 60, 142, 128, 12, 128, 163, 221,
+       95, 143, 227, 198, 214, 22, 111, 255, 113, 230, 222, 198, 105,
+       102, 158, 182, 127, 246, 148, 234, 249, 219, 173, 238, 58, 46,
+       239, 132, 47, 246, 246, 125, 53, 32, 43, 234, 29, 66, 195, 73, 68,
+       105, 203, 18, 82, 216, 60, 232, 248, 140, 26, 187, 25, 179, 169,
+       128, 145, 237, 130, 67, 177, 11, 240, 162, 18, 45, 2, 164, 151,
+       131, 46, 103, 36, 128, 202, 131, 45, 163, 96, 0, 122, 187, 19,
+       156, 88, 155, 4, 204, 185, 196, 142, 1, 38, 78, 161, 138, 86, 132,
+       254, 233, 62, 58, 250, 106, 255, 149, 243, 131, 207, 235, 116, 99,
+       255, 149, 127, 183, 188, 241, 173, 204, 155, 251, 203, 199, 167,
+       173, 113, 7, 18, 187, 107, 193, 86, 201, 187, 67, 46, 5, 90, 171,
+       56, 157, 52, 0, 62, 185, 19, 145, 146, 184, 20, 197, 93, 44, 10,
+       192, 237, 136, 117, 186, 125, 59, 192, 166, 244, 20, 90, 27, 19,
+       128, 84, 239, 191, 11, 211, 216, 214, 238, 149, 93, 159, 90, 213,
+       170, 222, 237, 169, 232, 174, 173, 90, 17, 31, 232, 240, 176, 175,
+       83, 92, 222, 87, 246, 20, 167, 15, 170, 243, 205, 151, 77, 183,
+       124, 102, 91, 175, 208, 250, 219, 95, 255, 182, 188, 173, 206, 27,
+       83, 102, 77, 87, 215, 185, 113, 77, 100, 85, 167, 40, 12, 182,
+       165, 46, 41, 146, 229, 197, 184, 52, 221, 38, 88, 202, 131, 127,
+       142, 109, 221, 171, 88, 246, 245, 100, 159, 248, 212, 93, 232,
+       246, 227, 173, 31, 181, 238, 238, 253, 183, 197, 132, 255, 97,
+       224, 215, 251, 218, 130, 7, 157, 97, 207, 41, 118, 121, 239, 117,
+       252, 251, 119, 89, 204, 125, 228, 191, 157, 214, 164, 206, 62,
+       151, 28, 167, 186, 244, 143, 103, 253, 50, 234, 110, 142, 222,
+       253, 31, 120, 252, 225, 39, 246, 251, 80, 47, 253, 151, 183, 157,
+       31, 214, 238, 238, 221, 223, 223, 135, 215, 237, 224, 215, 217,
+       235, 247, 39, 151, 63, 245, 203, 90, 243, 247, 101, 220, 255, 212,
+       237, 204, 246, 167, 188, 157, 247, 109, 238, 247, 255, 215, 199,
+       245, 182, 232, 119, 121, 254, 131, 7, 159, 125, 255, 186, 67, 118,
+       239, 45, 18, 254, 125, 77, 32, 251, 195, 107, 11, 180, 194, 238,
+       151, 127, 235, 200, 187, 69, 204, 182, 249, 138, 147, 119, 222,
+       120, 143, 111, 242, 122, 250, 245, 220, 123, 149, 89, 77, 117, 63,
+       255, 221, 170, 252, 222, 27, 151, 91, 215, 50, 248, 247, 119, 253,
+       50, 235, 30, 159, 175, 247, 123, 173, 131, 190, 157, 84, 79, 237,
+       146, 201, 200, 0, 50, 254, 112, 242, 216, 238, 29, 205, 89, 75,
+       234, 170, 185, 124, 174, 184, 145, 38, 242, 110, 123, 137, 131,
+       172, 221, 84, 66, 174, 130, 73, 216, 9, 114, 248, 48, 208, 216,
+       206, 53, 221, 31, 11, 194, 181, 187, 125, 252, 248, 152, 14, 240,
+       74, 63, 122, 109, 225, 231, 255, 255, 144, 169, 126, 156, 231,
+       221, 95, 215, 190, 239, 253, 223, 223, 141, 144, 252, 224, 199,
+       217, 171, 182, 175, 247, 31, 243, 109, 81, 154, 236, 173, 86, 23,
+       208, 194, 228, 172, 44, 214, 249, 43, 96, 216, 100, 248, 98, 77,
+       35, 248, 48, 243, 255, 5, 27, 90, 123, 254, 99, 31, 202, 252, 121,
+       57, 83, 90, 202, 87, 95, 244, 37, 77, 239, 175, 93, 247, 65, 172,
+       222, 142, 67, 43, 241, 218, 223, 87, 207, 146, 245, 44, 87, 62,
+       133, 114, 233, 127, 19, 250, 120, 77, 33, 253, 218, 75, 73, 188,
+       180, 126, 153, 23, 255, 188, 179, 69, 206, 254, 221, 163, 212,
+       255, 143, 248, 131, 139, 91, 118, 222, 111, 212, 253, 117, 173,
+       94, 118, 167, 60, 223, 183, 231, 174, 243, 191, 199, 199, 45, 178,
+       233, 119, 121, 110, 139, 79, 180, 237, 127, 219, 133, 114, 239,
+       53, 22, 250, 116, 77, 104, 255, 162, 249, 127, 190, 102, 126, 151,
+       159, 175, 236, 179, 101, 207, 247, 253, 170, 129, 119, 142, 120,
+       253, 155, 19, 98, 132, 118, 19, 238, 81, 93, 200, 87, 239, 73, 72,
+       183, 132, 126, 169, 151, 237, 213, 178, 5, 200, 54, 104, 170, 138,
+       47, 174, 185, 85, 31, 123, 249, 225, 170, 93, 223, 156, 13, 252,
+       180, 239, 223, 127, 223, 171, 191, 209, 221, 246, 137, 32, 121,
+       192, 234, 221, 109, 190, 255, 255, 77, 113, 167, 211, 249, 195,
+       100, 84, 123, 248, 201, 89, 117, 230, 88, 95, 252, 54, 94, 208,
+       23, 126, 211, 150, 124, 227, 110, 28, 165, 198, 190, 187, 242,
+       245, 91, 86, 105, 247, 54, 86, 251, 53, 121, 76, 215, 166, 249,
+       127, 158, 229, 126, 149, 157, 175, 173, 144, 109, 207, 242, 255,
+       170, 128, 47, 134, 125, 121, 153, 232, 80, 185, 226, 141, 109,
+       255, 63, 26, 112, 19, 157, 195, 66, 28, 123, 139, 23, 157, 66,
+       156, 198, 211, 197, 223, 254, 236, 48, 16, 131, 233, 209, 172,
+       105, 71, 22, 121, 42, 168, 122, 240, 65, 10, 245, 8, 25, 49, 51,
+       207, 17, 223, 167, 92, 253, 63, 253, 8, 61, 52, 36, 3, 19, 40, 2,
+       216, 190, 220, 107, 212, 188, 71, 175, 91, 80, 119, 188, 158, 38,
+       98, 230, 59, 191, 129, 194, 13, 18, 241, 23, 60, 158, 139, 20, 84,
+       165, 223, 107, 219, 99, 206, 125, 223, 222, 249, 137, 204, 188,
+       239, 233, 255, 190, 52, 158, 243, 223, 230, 213, 43, 42, 253, 251,
+       253, 175, 219, 87, 174, 199, 119, 225, 240, 56, 250, 109, 141, 87,
+       252, 203, 88, 149, 76, 246, 216, 63, 48, 208, 64, 94, 111, 203,
+       39, 218, 189, 241, 153, 161, 190, 24, 27, 90, 43, 163, 25, 106,
+       61, 240, 140, 185, 119, 124, 77, 114, 149, 176, 140, 54, 112, 238,
+       59, 55, 149, 210, 184, 52, 95, 101, 62, 186, 192, 85, 0, 231, 219,
+       163, 155, 122, 88, 240, 212, 185, 119, 93, 77, 122, 23, 168, 142,
+       182, 97, 238, 59, 50, 149, 214, 184, 54, 245, 110, 89, 190, 202,
+       93, 4, 229, 223, 70, 181, 181, 206, 249, 119, 154, 248, 139, 221,
+       185, 109, 108, 254, 111, 36, 151, 83, 255, 177, 135, 3, 186, 221,
+       59, 94, 15, 255, 150, 102, 39, 215, 46, 35, 225, 65, 246, 98, 105,
+       220, 99, 140, 124, 226, 41, 195, 207, 190, 94, 218, 134, 248, 154,
+       210, 230, 232, 14, 24, 165, 170, 231, 151, 102, 237, 43, 97, 225,
+       79, 121, 114, 238, 76, 107, 137, 249, 232, 104, 118, 220, 182, 90,
+       220, 212, 234, 131, 130, 236, 203, 38, 60, 165, 190, 71, 246, 98,
+       165, 109, 78, 246, 10, 123, 177, 178, 206, 239, 69, 106, 101, 8,
+       8, 167, 212, 167, 225, 234, 84, 134, 47, 47, 255, 62, 126, 7, 78,
+       219, 215, 97, 77, 158, 200, 224, 184, 151, 249, 118, 142, 255,
+       214, 4, 147, 11, 236, 119, 221, 243, 200, 169, 87, 190, 100, 62,
+       242, 235, 95, 7, 111, 182, 253, 252, 86, 91, 34, 122, 78, 27, 156,
+       89, 80, 105, 77, 247, 13, 42, 159, 150, 246, 164, 172, 236, 12,
+       142, 43, 162, 205, 211, 249, 0, 219, 98, 135, 110, 79, 27, 83,
+       109, 191, 50, 86, 123, 56, 33, 77, 87, 231, 253, 95, 155, 121, 54,
+       189, 181, 239, 133, 144, 109, 237, 198, 235, 234, 128, 47, 135,
+       15, 249, 130, 144, 33, 154, 205, 213, 188, 239, 159, 87, 208, 147,
+       172, 222, 126, 65, 205, 155, 147, 145, 214, 15, 114, 247, 31, 16,
+       218, 235, 23, 12, 181, 222, 2, 170, 130, 153, 251, 176, 184, 199,
+       190, 29, 88, 247, 172, 138, 118, 204, 231, 43, 179, 149, 150, 89,
+       134, 241, 12, 20, 154, 235, 156, 68, 57, 159, 234, 141, 177, 90,
+       153, 240, 129, 75, 250, 15, 168, 16, 168, 190, 68, 164, 201, 51,
+       224, 144, 62, 47, 226, 55, 11, 252, 18, 123, 209, 64, 231, 174,
+       41, 165, 168, 174, 221, 45, 79, 223, 67, 65, 77, 13, 179, 233, 90,
+       16, 216, 202, 19, 141, 159, 42, 216, 251, 231, 29, 143, 56, 185,
+       95, 218, 216, 159, 82, 127, 119, 34, 94, 121, 48, 161, 92, 119,
+       245, 223, 95, 139, 251, 6, 53, 181, 196, 133, 212, 53, 140, 194,
+       251, 96, 194, 46, 166, 13, 121, 31, 91, 105, 161, 118, 23, 239,
+       254, 100, 236, 94, 230, 25, 12, 211, 32, 110, 205, 23, 253, 197,
+       152, 37, 220, 110, 77, 175, 228, 191, 181, 113, 241, 37, 216, 189,
+       123, 110, 157, 179, 188, 206, 89, 33, 104, 246, 244, 76, 32, 135,
+       90, 114, 82, 195, 108, 122, 53, 141, 159, 84, 122, 208, 11, 5,
+       235, 31, 4, 204, 31, 203, 114, 252, 169, 150, 247, 103, 183, 73,
+       100, 239, 207, 115, 70, 162, 174, 53, 212, 63, 138, 14, 103, 85,
+       5, 251, 255, 236, 212, 182, 248, 231, 89, 129, 212, 212, 198, 247,
+       94, 242, 51, 42, 220, 111, 221, 233, 251, 141, 211, 110, 244, 114,
+       224, 35, 80, 212, 19, 243, 125, 244, 95, 86, 132, 110, 126, 177,
+       240, 218, 232, 255, 87, 183, 185, 111, 236, 62, 93, 183, 211, 237,
+       39, 190, 99, 63, 255, 155, 119, 87, 91, 214, 199, 111, 86, 30,
+       191, 98, 145, 215, 243, 186, 67, 31, 109, 95, 183, 12, 158, 38,
+       132, 167, 59, 147, 149, 23, 152, 4, 214, 62, 20, 143, 199, 151,
+       76, 189, 215, 107, 185, 115, 232, 125, 213, 89, 65, 203, 73, 181,
+       41, 62, 159, 246, 180, 206, 185, 215, 133, 207, 43, 226, 209, 83,
+       125, 160, 187, 87, 134, 78, 223, 43, 121, 96, 200, 125, 221, 219,
+       81, 201, 76, 188, 15, 42, 157, 54, 148, 174, 185, 215, 205, 203,
+       43, 242, 205, 51, 221, 128, 187, 95, 142, 106, 255, 29, 191, 107,
+       107, 118, 219, 123, 112, 87, 72, 125, 230, 251, 221, 178, 96, 94,
+       186, 23, 94, 199, 184, 124, 191, 110, 205, 161, 232, 127, 143, 88,
+       241, 122, 51, 178, 104, 59, 87, 155, 90, 7, 237, 220, 47, 76, 222,
+       46, 180, 220, 157, 223, 241, 159, 131, 121, 157, 123, 77, 137,
+       255, 155, 14, 46, 87, 126, 176, 176, 196, 125, 119, 155, 202, 19,
+       238, 156, 47, 76, 255, 78, 36, 221, 221, 255, 181, 159, 83, 251,
+       223, 91, 95, 141, 183, 147, 108, 30, 87, 251, 225, 67, 168, 85,
+       134, 106, 44, 33, 64, 67, 135, 121, 78, 30, 212, 120, 173, 17,
+       239, 79, 154, 20, 253, 167, 232, 138, 68, 47, 134, 250, 212, 199,
+       83, 105, 207, 50, 0, 171, 56, 44, 76, 95, 230, 245, 71, 156, 96,
+       54, 73, 31, 238, 195, 144, 45, 111, 116, 40, 170, 128, 61, 179,
+       33, 241, 58, 122, 234, 156, 79, 240, 184, 194, 137, 199, 220, 167,
+       44, 174, 55, 142, 238, 251, 147, 149, 6, 11, 166, 225, 18, 116,
+       218, 139, 151, 125, 61, 223, 246, 156, 238, 59, 151, 252, 82, 128,
+       191, 91, 195, 27, 74, 252, 30, 89, 241, 219, 189, 147, 190, 148,
+       219, 247, 187, 118, 156, 199, 185, 93, 252, 86, 88, 16, 30, 225,
+       48, 206, 89, 19, 45, 13, 182, 9, 159, 23, 2, 88, 166, 145, 125,
+       20, 10, 137, 17, 21, 211, 229, 48, 209, 32, 128, 5, 123, 88, 152,
+       26, 188, 41, 236, 80, 7, 169, 29, 160, 25, 174, 159, 98, 91, 132,
+       179, 237, 0, 26, 75, 146, 193, 211, 241, 90, 123, 2, 0, 167, 91,
+       59, 49, 122, 232, 51, 87, 27, 88, 7, 205, 252, 39, 74, 221, 174,
+       196, 252, 153, 151, 245, 159, 171, 113, 156, 251, 221, 32, 223,
+       123, 143, 44, 215, 163, 177, 104, 154, 205, 221, 240, 239, 223,
+       93, 52, 31, 40, 156, 126, 13, 201, 11, 147, 21, 214, 110, 254,
+       213, 15, 24, 158, 127, 215, 12, 222, 206, 130, 180, 186, 218, 203,
+       245, 152, 71, 159, 87, 229, 25, 44, 255, 110, 31, 239, 187, 147,
+       129, 54, 111, 178, 211, 215, 216, 90, 123, 210, 76, 135, 222, 220,
+       171, 170, 176, 188, 32, 97, 215, 118, 61, 214, 120, 135, 129, 250,
+       89, 249, 142, 110, 25, 186, 123, 195, 209, 248, 177, 174, 221,
+       128, 88, 249, 3, 80, 83, 58, 172, 62, 196, 121, 16, 172, 76, 219,
+       39, 183, 159, 34, 64, 230, 189, 125, 129, 138, 147, 131, 9, 209,
+       225, 42, 137, 36, 130, 37, 91, 18, 184, 58, 240, 75, 225, 144, 70,
+       187, 21, 176, 59, 46, 159, 102, 24, 171, 187, 203, 145, 18, 111,
+       130, 243, 219, 213, 26, 123, 208, 4, 47, 11, 57, 137, 251, 238,
+       118, 22, 251, 252, 81, 97, 126, 130, 91, 255, 186, 48, 126, 221,
+       23, 236, 217, 186, 45, 173, 126, 233, 165, 196, 103, 174, 114,
+       241, 187, 92, 210, 94, 79, 80, 246, 236, 237, 2, 244, 34, 104,
+       216, 191, 244, 123, 225, 134, 202, 229, 39, 110, 251, 54, 126, 82,
+       11, 127, 182, 106, 143, 187, 96, 71, 175, 82, 150, 106, 124, 33,
+       68, 226, 199, 121, 79, 20, 144, 62, 173, 209, 231, 205, 150, 21,
+       237, 182, 239, 138, 0, 45, 150, 34, 216, 202, 43, 226, 0, 115,
+       144, 184, 67, 171, 197, 213, 183, 8, 142, 246, 134, 110, 173, 247,
+       149, 148, 91, 134, 192, 30, 80, 143, 239, 231, 132, 191, 213, 202,
+       182, 54, 250, 109, 244, 80, 81, 171, 31, 165, 25, 174, 223, 110,
+       91, 193, 51, 221, 16, 62, 71, 154, 225, 211, 209, 218, 123, 146,
+       4, 167, 67, 139, 186, 166, 209, 229, 245, 185, 87, 223, 95, 84,
+       150, 168, 172, 246, 237, 111, 59, 151, 157, 179, 122, 54, 209, 15,
+       26, 222, 234, 159, 204, 181, 253, 234, 248, 34, 18, 91, 141, 145,
+       133, 155, 107, 150, 191, 108, 156, 14, 28, 173, 183, 255, 81, 166,
+       79, 154, 247, 85, 54, 152, 251, 79, 29, 154, 31, 74, 187, 124,
+       216, 111, 217, 185, 19, 175, 29, 180, 175, 172, 143, 198, 78, 166,
+       179, 239, 129, 146, 73, 162, 209, 223, 209, 90, 251, 22, 140, 133,
+       127, 43, 121, 34, 192, 125, 221, 248, 87, 171, 73, 188, 47, 168,
+       159, 87, 132, 236, 169, 223, 221, 135, 43, 242, 209, 151, 217,
+       138, 186, 11, 14, 122, 207, 98, 142, 78, 152, 95, 225, 184, 71,
+       155, 87, 144, 159, 44, 174, 102, 143, 235, 163, 163, 149, 54, 79,
+       18, 215, 30, 18, 218, 235, 149, 76, 189, 222, 64, 54, 186, 200,
+       172, 33, 144, 3, 206, 155, 154, 116, 150, 168, 197, 106, 205, 151,
+       110, 17, 152, 43, 195, 194, 220, 157, 190, 30, 200, 104, 56, 13,
+       88, 18, 63, 165, 48, 206, 88, 17, 44, 205, 146, 101, 159, 31, 0,
+       88, 166, 181, 125, 17, 136, 201, 209, 12, 195, 227, 58, 145, 32,
+       0, 37, 83, 58, 48, 224, 65, 7, 127, 97, 91, 37, 237, 206, 143, 2,
+       29, 86, 156, 120, 156, 255, 53, 140, 186, 241, 128, 215, 101, 209,
+       247, 235, 44, 94, 222, 79, 178, 237, 117, 170, 28, 169, 25, 162,
+       253, 23, 228, 217, 239, 218, 238, 55, 93, 253, 189, 147, 80, 191,
+       192, 78, 79, 239, 228, 174, 166, 23, 241, 139, 222, 106, 201, 80,
+       135, 111, 245, 52, 4, 228, 135, 25, 199, 54, 81, 126, 168, 147,
+       238, 224, 150, 20, 127, 102, 137, 134, 76, 63, 146, 232, 240, 219,
+       24, 195, 196, 35, 80, 108, 80, 33, 194, 86, 230, 121, 190, 181,
+       255, 118, 253, 181, 139, 205, 215, 183, 202, 18, 123, 218, 138,
+       47, 231, 58, 157, 2, 9, 255, 213, 230, 250, 180, 70, 237, 194, 90,
+       162, 36, 188, 181, 104, 226, 127, 146, 65, 21, 185, 36, 232, 36,
+       54, 218, 3, 132, 121, 61, 140, 11, 188, 227, 65, 215, 150, 174,
+       215, 123, 225, 92, 198, 40, 172, 244, 164, 127, 10, 146, 157, 215,
+       184, 180, 239, 46, 28, 158, 226, 175, 198, 251, 252, 226, 189,
+       254, 246, 203, 237, 191, 167, 185, 23, 155, 27, 244, 254, 12, 3,
+       143, 243, 123, 131, 112, 235, 218, 239, 181, 18, 222, 187, 5, 122,
+       135, 27, 102, 57, 231, 246, 237, 72, 181, 167, 139, 243, 153, 171,
+       226, 253, 77, 59, 205, 247, 243, 1, 88, 107, 218, 224, 191, 118,
+       223, 186, 133, 122, 214, 95, 98, 185, 239, 246, 77, 205, 220, 181,
+       131, 249, 184, 11, 114, 253, 92, 50, 204, 247, 245, 209, 204, 107,
+       242, 128, 95, 249, 205, 187, 197, 46, 86, 123, 51, 57, 105, 101,
+       94, 205, 155, 121, 67, 236, 244, 175, 51, 221, 87, 48, 94, 185,
+       215, 231, 205, 62, 244, 156, 95, 9, 169, 185, 125, 170, 86, 243,
+       234, 146, 176, 250, 61, 189, 18, 16, 175, 61, 147, 121, 174, 159,
+       104, 210, 196, 51, 255, 19, 158, 47, 202, 227, 211, 241, 18, 123,
+       18, 15, 21, 11, 171, 28, 227, 249, 229, 245, 248, 83, 95, 91, 116,
+       23, 172, 189, 118, 172, 207, 43, 183, 157, 183, 124, 114, 210, 79,
+       95, 158, 235, 215, 204, 252, 223, 88, 17, 191, 173, 38, 142, 24,
+       16, 46, 72, 210, 165, 247, 159, 1, 64, 246, 61, 125, 65, 137, 217,
+       211, 9, 193, 225, 106, 144, 44, 138, 37, 91, 83, 91, 175, 134, 46,
+       18, 175, 152, 238, 244, 150, 230, 244, 198, 215, 102, 102, 197,
+       125, 239, 193, 65, 175, 249, 208, 40, 235, 158, 12, 179, 49, 125,
+       88, 221, 90, 79, 19, 208, 58, 180, 164, 68, 78, 167, 109, 195,
+       170, 212, 50, 247, 142, 226, 82, 152, 44, 125, 226, 229, 34, 65,
+       63, 135, 45, 26, 17, 78, 63, 188, 13, 143, 188, 103, 204, 166, 74,
+       1, 166, 136, 55, 73, 229, 43, 51, 13, 228, 189, 18, 29, 227, 59,
+       94, 16, 16, 88, 209, 202, 36, 105, 185, 177, 204, 109, 165, 206,
+       94, 176, 80, 75, 148, 157, 113, 9, 216, 89, 51, 81, 3, 114, 210,
+       16, 77, 0, 255, 44, 144, 121, 21, 162, 2, 46, 44, 171, 60, 229,
+       185, 198, 142, 237, 24, 135, 181, 12, 51, 8, 205, 35, 91, 149,
+       130, 9, 115, 60, 205, 5, 186, 209, 148, 75, 21, 218, 50, 106, 171,
+       186, 188, 225, 159, 85, 14, 207, 217, 171, 183, 140, 115, 8, 223,
+       187, 23, 149, 142, 6, 104, 42, 241, 5, 190, 185, 148, 90, 21, 91,
+       162, 53, 235, 212, 206, 101, 189, 119, 25, 222, 93, 190, 48, 191,
+       196, 47, 110, 122, 151, 131, 113, 250, 242, 224, 55, 16, 252, 170,
+       37, 104, 180, 255, 35, 188, 31, 214, 207, 245, 184, 119, 137, 251,
+       89, 122, 180, 190, 228, 39, 173, 119, 179, 161, 181, 94, 178, 236,
+       31, 82, 222, 234, 141, 76, 189, 159, 195, 188, 158, 180, 123, 149,
+       185, 119, 154, 239, 148, 63, 172, 186, 194, 10, 175, 39, 247, 149,
+       164, 95, 146, 254, 94, 95, 255, 251, 140, 4, 139, 223, 226, 80,
+       31, 188, 61, 167, 152, 14, 155, 167, 144, 29, 238, 218, 38, 13,
+       135, 37, 125, 17, 36, 111, 18, 255, 153, 214, 91, 123, 148, 9, 13,
+       71, 226, 56, 50, 250, 41, 236, 112, 71, 187, 25, 177, 57, 174,
+       159, 68, 159, 201, 179, 253, 144, 42, 79, 194, 192, 159, 216, 218,
+       251, 130, 4, 118, 15, 11, 154, 247, 177, 235, 157, 184, 215, 175,
+       93, 82, 183, 172, 143, 110, 203, 167, 3, 255, 149, 150, 216, 19,
+       209, 94, 91, 90, 194, 142, 132, 161, 223, 107, 251, 241, 136, 111,
+       157, 113, 95, 203, 93, 252, 42, 172, 153, 214, 166, 206, 25, 255,
+       17, 134, 122, 226, 193, 31, 88, 158, 235, 134, 12, 86, 239, 162,
+       30, 220, 221, 40, 169, 180, 23, 140, 170, 176, 252, 134, 179, 133,
+       203, 199, 52, 238, 8, 97, 45, 194, 218, 134, 186, 114, 178, 216,
+       248, 75, 153, 81, 129, 61, 173, 40, 206, 184, 40, 174, 89, 210,
+       131, 247, 78, 16, 66, 230, 61, 127, 197, 70, 249, 203, 21, 197,
+       235, 107, 208, 80, 2, 33, 90, 152, 86, 115, 79, 54, 219, 183, 116,
+       93, 102, 119, 234, 127, 93, 181, 165, 54, 184, 158, 99, 225, 181,
+       37, 159, 48, 224, 32, 131, 119, 186, 69, 109, 152, 198, 115, 77,
+       114, 219, 183, 244, 116, 6, 118, 242, 111, 92, 172, 101, 126, 185,
+       134, 226, 224, 180, 36, 127, 244, 234, 34, 129, 119, 186, 165,
+       229, 232, 56, 153, 112, 121, 237, 81, 87, 187, 189, 164, 24, 190,
+       159, 65, 26, 137, 187, 236, 16, 10, 111, 210, 80, 223, 209, 20,
+       123, 194, 8, 70, 59, 168, 184, 59, 240, 93, 237, 113, 71, 223, 53,
+       36, 24, 62, 159, 100, 56, 137, 187, 211, 16, 58, 63, 50, 211, 95,
+       221, 16, 123, 210, 8, 70, 170, 71, 106, 221, 109, 232, 54, 108,
+       150, 233, 154, 120, 96, 157, 35, 193, 250, 135, 247, 124, 152,
+       129, 82, 226, 64, 134, 255, 126, 132, 128, 241, 35, 161, 87, 123,
+       173, 132, 42, 4, 11, 8, 170, 252, 129, 236, 220, 198, 215, 122,
+       182, 229, 125, 247, 131, 67, 174, 72, 144, 48, 171, 190, 140, 55,
+       7, 117, 194, 47, 156, 182, 234, 101, 189, 103, 136, 174, 185, 27,
+       180, 54, 64, 3, 173, 119, 91, 131, 112, 79, 193, 234, 249, 146,
+       94, 59, 0, 82, 167, 139, 102, 121, 185, 246, 238, 37, 157, 199,
+       154, 187, 176, 74, 180, 191, 69, 11, 207, 247, 119, 147, 97, 98,
+       218, 232, 189, 158, 255, 186, 144, 120, 131, 171, 99, 122, 226,
+       84, 97, 152, 184, 80, 235, 140, 116, 172, 40, 202, 247, 188, 238,
+       57, 178, 197, 134, 118, 166, 193, 22, 120, 146, 235, 71, 132, 107,
+       205, 59, 251, 122, 230, 247, 213, 223, 245, 9, 236, 124, 175, 61,
+       159, 247, 20, 190, 187, 151, 245, 198, 186, 176, 237, 123, 221,
+       173, 235, 39, 142, 246, 255, 188, 76, 107, 241, 84, 150, 111, 50,
+       21, 198, 198, 19, 147, 11, 50, 65, 88, 168, 19, 255, 232, 246,
+       113, 142, 231, 217, 134, 65, 38, 152, 116, 224, 234, 18, 148, 233,
+       45, 201, 80, 3, 175, 63, 179, 57, 174, 137, 64, 210, 134, 55, 237,
+       0, 20, 13, 195, 208, 134, 244, 16, 187, 18, 140, 13, 11, 210, 168,
+       178, 240, 101, 253, 240, 71, 63, 59, 112, 57, 174, 156, 116, 157,
+       169, 187, 215, 17, 122, 126, 194, 211, 151, 216, 18, 235, 67, 12,
+       79, 142, 74, 178, 222, 213, 235, 28, 184, 87, 175, 51, 118, 231,
+       172, 175, 228, 78, 167, 23, 239, 16, 210, 89, 147, 241, 95, 243,
+       90, 227, 207, 132, 143, 155, 66, 250, 252, 221, 107, 24, 176, 95,
+       111, 49, 118, 170, 140, 158, 196, 110, 231, 31, 255, 17, 210, 120,
+       231, 193, 222, 246, 94, 231, 206, 136, 135, 191, 35, 169, 175,
+       217, 60, 211, 232, 206, 174, 249, 184, 1, 144, 158, 118, 98, 200,
+       43, 127, 213, 30, 75, 203, 245, 155, 217, 191, 253, 144, 0, 115,
+       202, 79, 123, 147, 229, 233, 38, 61, 151, 171, 170, 174, 192, 156,
+       183, 65, 250, 196, 119, 253, 144, 129, 73, 162, 98, 239, 253, 255,
+       128, 130, 240, 35, 57, 17, 193, 46, 173, 12, 70, 31, 61, 134, 93,
+       143, 151, 213, 111, 58, 66, 196, 5, 61, 167, 92, 137, 89, 21, 225,
+       231, 234, 213, 20, 42, 181, 82, 194, 158, 157, 188, 92, 173, 176,
+       42, 155, 222, 184, 93, 230, 238, 102, 82, 221, 51, 111, 5, 180,
+       111, 74, 223, 141, 150, 91, 127, 144, 40, 13, 91, 72, 154, 54, 93,
+       9, 221, 113, 55, 229, 77, 238, 53, 162, 149, 34, 244, 192, 58,
+       234, 0, 30, 152, 243, 29, 135, 241, 16, 3, 18, 12, 12, 127, 155,
+       211, 99, 174, 55, 147, 74, 240, 100, 104, 218, 239, 111, 78, 186,
+       224, 254, 229, 157, 231, 205, 131, 44, 189, 176, 197, 170, 144,
+       63, 151, 51, 93, 188, 171, 69, 201, 222, 83, 79, 249, 21, 48, 181,
+       234, 75, 71, 136, 181, 126, 144, 151, 250, 123, 10, 77, 157, 122,
+       201, 165, 245, 55, 170, 222, 160, 11, 144, 21, 184, 122, 197, 24,
+       83, 191, 89, 176, 245, 188, 30, 38, 25, 174, 177, 215, 148, 23,
+       11, 18, 213, 210, 219, 90, 218, 216, 4, 35, 211, 248, 64, 106,
+       236, 85, 70, 91, 100, 32, 4, 238, 11, 19, 15, 22, 80, 104, 156,
+       217, 226, 72, 151, 245, 6, 243, 233, 130, 21, 33, 131, 126, 114,
+       138, 4, 234, 217, 245, 183, 248, 87, 31, 7, 118, 147, 8, 191, 182,
+       108, 127, 186, 179, 156, 178, 190, 119, 211, 71, 63, 146, 195,
+       215, 204, 248, 222, 147, 180, 111, 153, 246, 242, 185, 103, 253,
+       87, 86, 178, 156, 190, 182, 105, 239, 27, 31, 145, 182, 221, 53,
+       199, 29, 58, 218, 195, 133, 68, 181, 197, 66, 242, 244, 217, 239,
+       25, 112, 95, 79, 181, 88, 106, 174, 184, 220, 110, 231, 93, 239,
+       17, 146, 122, 195, 209, 159, 94, 87, 111, 150, 140, 135, 175, 56,
+       156, 250, 116, 211, 171, 119, 231, 117, 143, 126, 38, 47, 51, 162,
+       20, 59, 251, 134, 16, 56, 187, 32, 111, 251, 231, 52, 67, 227, 64,
+       167, 235, 201, 78, 77, 245, 164, 2, 108, 55, 253, 58, 146, 244,
+       177, 3, 177, 251, 71, 182, 44, 138, 233, 156, 101, 252, 166, 243,
+       246, 128, 22, 240, 224, 41, 225, 95, 101, 161, 60, 139, 73, 55,
+       68, 232, 154, 236, 147, 1, 145, 113, 78, 166, 92, 252, 173, 248,
+       101, 28, 236, 136, 165, 244, 44, 136, 82, 57, 184, 68, 116, 220,
+       13, 93, 209, 105, 205, 30, 245, 27, 106, 89, 62, 143, 200, 32,
+       239, 45, 104, 103, 115, 159, 83, 123, 192, 27, 83, 44, 212, 230,
+       135, 59, 251, 89, 224, 165, 173, 87, 94, 138, 112, 114, 180, 222,
+       229, 105, 247, 59, 22, 88, 227, 176, 34, 82, 101, 8, 55, 168, 152,
+       240, 225, 185, 191, 129, 247, 160, 229, 94, 120, 199, 41, 117,
+       106, 17, 15, 174, 110, 222, 234, 207, 160, 85, 28, 251, 177, 160,
+       155, 249, 86, 71, 194, 13, 234, 198, 4, 108, 153, 250, 232, 101,
+       141, 206, 30, 190, 56, 80, 148, 178, 97, 75, 195, 75, 46, 26, 3,
+       103, 235, 114, 253, 128, 127, 44, 144, 113, 39, 161, 21, 252, 153,
+       234, 172, 37, 143, 206, 30, 187, 184, 66, 148, 250, 97, 104, 221,
+       91, 30, 211, 19, 75, 218, 114, 185, 140, 63, 108, 144, 115, 161,
+       161, 188, 143, 69, 233, 60, 203, 203, 57, 5, 48, 188, 226, 155,
+       69, 144, 165, 94, 144, 151, 232, 121, 40, 97, 157, 110, 200, 165,
+       212, 119, 172, 212, 160, 6, 169, 83, 232, 242, 137, 106, 196, 175,
+       1, 72, 130, 158, 203, 117, 80, 246, 185, 31, 217, 18, 25, 0, 240,
+       188, 28, 142, 108, 180, 147, 163, 136, 131, 0, 39, 177, 230, 226,
+       185, 103, 61, 211, 82, 147, 220, 190, 54, 109, 231, 175, 55, 149,
+       181, 220, 53, 206, 157, 50, 218, 194, 132, 68, 181, 247, 38, 162,
+       252, 153, 252, 171, 224, 143, 223, 177, 248, 96, 228, 232, 84,
+       122, 211, 126, 251, 17, 18, 200, 203, 240, 14, 54, 223, 127, 148,
+       72, 214, 143, 170, 217, 37, 216, 45, 221, 223, 232, 207, 124, 180,
+       24, 170, 93, 62, 167, 204, 144, 223, 99, 234, 47, 122, 181, 119,
+       217, 133, 63, 83, 140, 84, 126, 27, 235, 2, 168, 54, 7, 174, 217,
+       6, 168, 152, 231, 189, 201, 243, 128, 126, 9, 23, 253, 195, 3, 5,
+       159, 248, 77, 175, 172, 61, 190, 57, 217, 90, 121, 175, 180, 199,
+       72, 53, 134, 171, 229, 14, 175, 60, 183, 67, 90, 162, 247, 249,
+       69, 1, 217, 178, 232, 253, 101, 222, 131, 174, 116, 21, 122, 137,
+       227, 32, 169, 60, 15, 79, 253, 29, 60, 16, 93, 159, 9, 18, 1, 148,
+       136, 93, 111, 248, 44, 89, 159, 236, 209, 45, 124, 126, 172, 147,
+       97, 98, 121, 171, 132, 93, 197, 184, 69, 139, 205, 152, 15, 44,
+       252, 119, 2, 236, 115, 243, 213, 134, 11, 178, 193, 63, 16, 143,
+       187, 69, 46, 55, 223, 6, 57, 179, 138, 254, 133, 186, 212, 143,
+       169, 152, 227, 188, 158, 117, 96, 238, 123, 31, 213, 147, 11, 146,
+       240, 61, 28, 175, 234, 156, 27, 33, 155, 133, 73, 51, 185, 164,
+       174, 173, 135, 126, 74, 82, 96, 149, 216, 181, 105, 247, 43, 22,
+       85, 243, 180, 4, 82, 4, 58, 126, 196, 220, 80, 225, 161, 6, 12,
+       230, 209, 211, 48, 172, 199, 181, 19, 194, 147, 129, 39, 49, 207,
+       111, 211, 155, 181, 48, 216, 69, 226, 63, 118, 222, 65, 167, 253,
+       181, 168, 21, 145, 29, 233, 26, 199, 83, 248, 6, 128, 136, 66,
+       245, 95, 40, 96, 246, 217, 31, 243, 91, 2, 91, 29, 249, 140, 47,
+       108, 56, 42, 33, 51, 255, 78, 103, 221, 78, 54, 76, 57, 81, 202,
+       211, 214, 73, 110, 181, 239, 127, 229, 55, 174, 233, 198, 189,
+       206, 22, 106, 235, 132, 47, 228, 112, 244, 240, 33, 56, 236, 24,
+       197, 83, 72, 135, 4, 172, 8, 115, 223, 41, 112, 216, 184, 121,
+       224, 10, 3, 242, 31, 243, 237, 129, 57, 48, 10, 102, 122, 162,
+       140, 68, 217, 93, 231, 88, 78, 31, 7, 120, 19, 42, 11, 52, 24,
+       217, 138, 23, 128, 62, 190, 67, 223, 23, 94, 144, 67, 55, 140,
+       124, 142, 170, 12, 254, 93, 87, 247, 184, 66, 94, 7, 246, 19, 104,
+       236, 52, 97, 255, 59, 179, 136, 180, 191, 55, 223, 71, 63, 146,
+       73, 215, 200, 109, 134, 35, 42, 138, 17, 245, 185, 232, 71, 95,
+       143, 94, 191, 160, 168, 246, 136, 201, 42, 130, 21, 134, 252, 70,
+       195, 14, 23, 156, 163, 205, 204, 216, 204, 165, 49, 97, 77, 76,
+       79, 195, 24, 69, 232, 245, 78, 243, 13, 157, 36, 88, 128, 86, 110,
+       137, 50, 125, 31, 71, 156, 161, 52, 123, 171, 84, 240, 135, 164,
+       135, 181, 194, 230, 108, 103, 189, 242, 195, 146, 204, 254, 0,
+       251, 255, 191, 123, 165, 49, 214, 147, 206, 157, 178, 223, 66,
+       140, 96, 162, 148, 210, 89, 190, 150, 159, 130, 7, 132, 217, 181,
+       130, 22, 102, 16, 33, 79, 224, 247, 232, 83, 104, 203, 183, 108,
+       185, 50, 94, 83, 128, 25, 181, 46, 95, 143, 67, 166, 178, 144, 62,
+       231, 173, 140, 218, 231, 45, 230, 161, 208, 246, 243, 206, 230,
+       125, 139, 4, 236, 186, 224, 175, 139, 36, 246, 171, 157, 129, 75,
+       31, 177, 180, 143, 109, 55, 188, 200, 18, 84, 190, 3, 48, 97, 132,
+       34, 30, 92, 225, 189, 17, 191, 229, 155, 54, 128, 24, 152, 217, 9,
+       1, 111, 47, 113, 52, 143, 105, 23, 110, 233, 90, 76, 179, 0, 144,
+       32, 132, 46, 92, 29, 171, 184, 101, 44, 237, 220, 52, 128, 200,
+       136, 208, 57, 94, 1, 167, 188, 205, 255, 68, 75, 233, 142, 105, 9,
+       110, 250, 55, 190, 160, 161, 240, 33, 28, 163, 50, 200, 147, 254,
+       91, 11, 146, 119, 135, 102, 227, 42, 200, 30, 197, 184, 252, 198,
+       91, 134, 100, 155, 40, 234, 87, 156, 251, 235, 162, 133, 68, 126,
+       198, 227, 22, 126, 214, 43, 79, 116, 218, 140, 20, 81, 123, 236,
+       58, 70, 95, 121, 4, 136, 218, 66, 117, 87, 41, 96, 118, 25, 31,
+       234, 193, 131, 17, 95, 241, 172, 43, 136, 56, 162, 33, 51, 1, 139,
+       158, 185, 246, 168, 170, 132, 174, 17, 74, 66, 157, 195, 224, 72,
+       98, 47, 42, 216, 18, 152, 3, 113, 196, 166, 186, 68, 148, 131,
+       161, 128, 45, 244, 41, 105, 93, 77, 67, 184, 66, 248, 164, 8, 211,
+       85, 88, 48, 29, 152, 81, 123, 203, 98, 249, 23, 237, 157, 5, 124,
+       208, 139, 86, 176, 195, 164, 3, 177, 57, 132, 105, 115, 168, 89,
+       202, 84, 189, 150, 80, 115, 231, 15, 127, 157, 243, 217, 247, 199,
+       149, 244, 186, 192, 12, 0, 35, 168, 168, 140, 246, 125, 93, 163,
+       178, 107, 222, 2, 122, 19, 104, 233, 52, 64, 249, 59, 35, 129, 34,
+       190, 2, 255, 103, 110, 147, 1, 85, 104, 109, 138, 41, 59, 122, 97,
+       116, 143, 123, 87, 124, 236, 118, 77, 55, 153, 87, 48, 150, 40,
+       23, 60, 182, 184, 52, 14, 111, 141, 48, 224, 77, 136, 66, 203, 2,
+       249, 191, 152, 205, 229, 180, 231, 138, 91, 88, 3, 188, 252, 108,
+       10, 205, 123, 51, 1, 195, 123, 146, 193, 7, 26, 223, 170, 128,
+       124, 183, 251, 87, 123, 230, 86, 50, 18, 174, 180, 248, 140, 214,
+       230, 233, 230, 215, 230, 54, 117, 236, 239, 197, 209, 173, 236,
+       56, 110, 239, 130, 47, 183, 41, 53, 7, 59, 151, 187, 236, 165,
+       172, 150, 142, 25, 88, 64, 188, 219, 113, 72, 197, 59, 55, 209,
+       131, 216, 11, 240, 77, 28, 190, 196, 152, 83, 161, 169, 190, 217,
+       230, 170, 139, 209, 31, 205, 131, 85, 140, 171, 12, 238, 107, 6,
+       238, 211, 145, 209, 94, 3, 58, 241, 251, 84, 142, 255, 183, 63,
+       181, 222, 5, 139, 22, 185, 180, 162, 168, 150, 126, 25, 90, 96,
+       213, 99, 168, 200, 87, 42, 34, 156, 18, 152, 71, 117, 140, 190,
+       186, 192, 152, 129, 169, 128, 189, 115, 97, 65, 124, 27, 198, 56,
+       80, 232, 179, 108, 211, 8, 149, 180, 92, 236, 70, 111, 237, 178,
+       125, 30, 36, 204, 37, 52, 127, 187, 82, 165, 93, 213, 29, 238, 42,
+       194, 23, 188, 36, 0, 206, 32, 255, 119, 41, 97, 114, 213, 60, 234,
+       73, 1, 59, 61, 241, 227, 106, 28, 56, 51, 37, 42, 194, 204, 135,
+       190, 93, 224, 71, 238, 223, 146, 194, 18, 164, 242, 37, 111, 193,
+       239, 58, 145, 42, 79, 250, 251, 185, 178, 223, 11, 144, 121, 52,
+       46, 49, 205, 42, 223, 116, 135, 198, 127, 87, 74, 252, 70, 115,
+       233, 182, 96, 216, 170, 6, 140, 239, 186, 114, 191, 242, 143, 178,
+       0, 121, 138, 112, 136, 39, 120, 234, 222, 71, 244, 248, 80, 153,
+       206, 244, 7, 40, 222, 119, 104, 253, 169, 19, 135, 133, 135, 178,
+       194, 19, 61, 154, 171, 29, 119, 123, 223, 219, 115, 234, 68, 67,
+       20, 188, 85, 249, 228, 119, 255, 73, 206, 247, 190, 62, 189, 183,
+       135, 196, 151, 182, 192, 18, 105, 203, 171, 111, 182, 47, 221,
+       115, 57, 122, 96, 83, 220, 48, 71, 57, 193, 110, 46, 63, 156, 37,
+       176, 166, 187, 148, 16, 151, 186, 176, 202, 59, 253, 16, 75, 233,
+       0, 43, 31, 1, 74, 148, 187, 228, 169, 168, 135, 30, 25, 90, 96,
+       180, 131, 225, 200, 205, 43, 34, 24, 2, 216, 67, 241, 12, 186,
+       254, 192, 144, 216, 145, 137, 210, 204, 149, 254, 157, 197, 133,
+       231, 223, 23, 128, 26, 166, 240, 32, 103, 201, 243, 106, 1, 122,
+       111, 114, 179, 185, 214, 94, 123, 144, 88, 149, 46, 19, 152, 63,
+       186, 195, 180, 57, 215, 141, 91, 92, 67, 44, 223, 42, 254, 167,
+       187, 151, 149, 147, 11, 50, 245, 131, 223, 218, 234, 146, 67, 165,
+       247, 14, 223, 186, 202, 178, 244, 190, 215, 62, 73, 126, 116, 188,
+       191, 234, 96, 182, 59, 151, 24, 147, 9, 160, 243, 99, 253, 38,
+       203, 154, 210, 173, 123, 218, 240, 245, 83, 163, 93, 89, 157, 127,
+       127, 53, 60, 206, 127, 206, 188, 151, 27, 245, 16, 191, 76, 251,
+       211, 203, 223, 116, 247, 210, 196, 207, 127, 3, 175, 53, 215, 236,
+       173, 252, 167, 201, 27, 48, 121, 188, 189, 212, 43, 135, 91, 87,
+       1, 178, 108, 194, 241, 45, 24, 126, 234, 84, 72, 211, 171, 57,
+       107, 72, 69, 116, 27, 198, 118, 68, 232, 254, 110, 115, 0, 151,
+       180, 88, 236, 6, 108, 205, 178, 69, 14, 54, 140, 165, 144, 111,
+       185, 90, 141, 9, 77, 66, 15, 118, 154, 234, 48, 108, 192, 123,
+       230, 249, 194, 183, 228, 118, 104, 22, 238, 197, 176, 12, 237, 36,
+       60, 34, 128, 111, 167, 105, 132, 7, 122, 171, 210, 96, 180, 187,
+       208, 189, 206, 88, 199, 56, 206, 247, 40, 255, 121, 23, 135, 133,
+       183, 178, 226, 83, 28, 186, 136, 205, 119, 39, 215, 67, 144, 153,
+       220, 9, 212, 88, 15, 43, 65, 236, 0, 188, 247, 12, 246, 132, 179,
+       249, 136, 75, 10, 243, 195, 147, 253, 154, 10, 10, 0, 170, 62, 49,
+       207, 107, 236, 20, 131, 79, 242, 84, 196, 218, 199, 115, 233, 176,
+       96, 120, 234, 22, 236, 232, 187, 37, 63, 240, 174, 166, 128, 53,
+       250, 112, 104, 129, 23, 249, 229, 246, 42, 111, 23, 121, 71, 95,
+       246, 151, 44, 146, 100, 54, 14, 22, 13, 177, 188, 101, 66, 100,
+       188, 178, 128, 228, 200, 209, 253, 215, 145, 28, 223, 29, 62, 80,
+       184, 201, 57, 165, 16, 206, 115, 12, 255, 193, 20, 60, 56, 31, 97,
+       91, 213, 139, 250, 66, 86, 26, 3, 232, 7, 226, 164, 80, 225, 204,
+       41, 232, 111, 77, 179, 185, 154, 131, 40, 92, 19, 107, 131, 74,
+       57, 48, 119, 197, 194, 60, 152, 86, 124, 197, 72, 210, 128, 30,
+       122, 243, 161, 118, 203, 186, 208, 189, 205, 82, 231, 157, 141,
+       243, 136, 174, 249, 151, 215, 133, 177, 36, 224, 198, 197, 43,
+       130, 231, 191, 37, 211, 30, 30, 78, 179, 34, 163, 186, 114, 149,
+       134, 95, 231, 77, 11, 179, 9, 110, 161, 151, 167, 164, 149, 28,
+       254, 214, 67, 235, 128, 47, 231, 41, 209, 117, 79, 109, 76, 174,
+       75, 94, 239, 69, 230, 184, 171, 67, 40, 183, 113, 122, 198, 78,
+       108, 236, 35, 37, 30, 122, 14, 37, 181, 117, 254, 212, 76, 35, 91,
+       99, 229, 246, 2, 237, 117, 88, 160, 114, 231, 121, 43, 149, 209,
+       118, 237, 23, 237, 225, 154, 21, 204, 36, 46, 175, 128, 45, 176,
+       243, 185, 82, 144, 53, 233, 9, 244, 88, 41, 15, 17, 133, 16, 204,
+       87, 8, 254, 209, 17, 185, 168, 27, 4, 123, 213, 139, 242, 218, 95,
+       26, 4, 20, 54, 45, 105, 156, 241, 36, 157, 101, 150, 70, 188, 54,
+       8, 183, 129, 211, 152, 72, 104, 46, 88, 75, 240, 99, 48, 198, 201,
+       101, 49, 218, 152, 88, 40, 9, 0, 70, 165, 68, 42, 232, 18, 108,
+       146, 118, 198, 223, 3, 145, 107, 106, 164, 106, 44, 5, 244, 85,
+       140, 196, 235, 114, 0, 111, 136, 113, 168, 106, 128, 37, 184, 45,
+       192, 89, 15, 143, 95, 128, 49, 172, 63, 0, 76, 193, 19, 189, 1,
+       26, 10, 99, 209, 193, 118, 218, 219, 150, 4, 149, 123, 66, 0, 187,
+       216, 29, 229, 169, 71, 223, 121, 146, 18, 140, 158, 116, 108, 236,
+       181, 123, 153, 131, 109, 179, 208, 157, 24, 154, 93, 149, 8, 53,
+       46, 81, 148, 190, 205, 158, 110, 161, 27, 238, 25, 222, 82, 212,
+       178, 36, 98, 97, 94, 122, 152, 145, 185, 179, 195, 93, 174, 218,
+       64, 153, 40, 241, 34, 41, 69, 66, 77, 116, 154, 236, 55, 108, 72,
+       122, 68, 179, 24, 148, 228, 90, 174, 22, 12, 193, 184, 69, 78, 36,
+       188, 178, 128, 109, 152, 248, 173, 9, 105, 154, 229, 44, 141, 237,
+       85, 204, 136, 116, 64, 191, 147, 113, 163, 136, 121, 62, 89, 65,
+       120, 146, 128, 229, 217, 103, 40, 72, 184, 73, 169, 80, 89, 27,
+       252, 19, 204, 53, 118, 172, 73, 110, 5, 62, 151, 32, 80, 166, 63,
+       61, 64, 65, 153, 16, 125, 241, 165, 18, 2, 24, 16, 37, 123, 1,
+       141, 51, 205, 116, 150, 236, 55, 124, 73, 122, 64, 188, 26, 180,
+       228, 198, 47, 22, 140, 193, 152, 37, 239, 36, 60, 186, 128, 12,
+       128, 225, 189, 24, 89, 51, 254, 83, 196, 55, 118, 172, 4, 110, 2,
+       60, 151, 33, 112, 230, 59, 19, 66, 65, 152, 48, 237, 245, 172, 26,
+       2, 34, 18, 37, 187, 74, 251, 16, 185, 251, 249, 56, 207, 47, 53,
+       104, 173, 172, 142, 74, 144, 167, 27, 227, 17, 86, 24, 130, 245,
+       190, 213, 30, 251, 144, 20, 143, 219, 97, 121, 59, 228, 116, 12,
+       207, 119, 200, 200, 152, 74, 183, 189, 144, 34, 142, 228, 87, 109,
+       193, 43, 176, 140, 241, 220, 44, 184, 76, 186, 211, 41, 93, 121,
+       163, 230, 157, 117, 222, 196, 131, 229, 141, 15, 30, 156, 122, 10,
+       248, 211, 155, 215, 14, 35, 56, 162, 251, 221, 142, 123, 199, 95,
+       244, 82, 8, 121, 179, 245, 109, 197, 181, 69, 140, 136, 112, 32,
+       188, 157, 65, 43, 174, 121, 247, 65, 65, 123, 146, 224, 101, 217,
+       110, 170, 65, 56, 167, 187, 138, 120, 211, 253, 99, 192, 181, 70,
+       186, 136, 112, 35, 60, 159, 33, 139, 174, 121, 183, 193, 64, 223,
+       130, 224, 209, 195, 126, 131, 2, 48, 39, 171, 246, 64, 82, 238, 7,
+       42, 74, 64, 117, 130, 227, 26, 107, 75, 57, 217, 122, 229, 45,
+       234, 40, 167, 1, 202, 147, 250, 194, 17, 37, 251, 98, 2, 122, 221,
+       102, 222, 61, 216, 94, 167, 137, 87, 174, 175, 106, 252, 46, 215,
+       192, 247, 253, 66, 76, 139, 178, 239, 178, 121, 196, 147, 6, 222,
+       220, 94, 188, 73, 110, 238, 7, 19, 206, 248, 149, 32, 245, 2, 123,
+       73, 49, 97, 120, 240, 23, 235, 104, 183, 12, 191, 243, 235, 235,
+       5, 119, 187, 116, 162, 11, 146, 39, 189, 103, 215, 185, 113, 149,
+       220, 87, 167, 232, 252, 182, 173, 126, 41, 183, 165, 133, 216, 55,
+       221, 79, 91, 251, 195, 47, 36, 53, 247, 25, 130, 196, 157, 52, 83,
+       73, 59, 87, 231, 70, 134, 97, 34, 178, 229, 82, 12, 162, 172, 173,
+       216, 117, 159, 142, 231, 209, 5, 54, 172, 92, 92, 49, 142, 204,
+       69, 54, 27, 68, 123, 85, 238, 222, 178, 99, 32, 146, 36, 63, 164,
+       4, 44, 252, 184, 101, 142, 250, 207, 53, 145, 119, 232, 88, 77,
+       67, 161, 167, 145, 205, 244, 188, 199, 190, 241, 130, 23, 140,
+       238, 94, 238, 229, 15, 251, 149, 151, 90, 247, 192, 157, 18, 223,
+       110, 142, 68, 187, 212, 93, 113, 19, 101, 114, 78, 99, 88, 32,
+       200, 103, 76, 95, 19, 129, 48, 54, 212, 84, 106, 65, 176, 177, 8,
+       241, 233, 37, 4, 106, 179, 99, 177, 58, 77, 66, 12, 85, 82, 206,
+       102, 85, 164, 202, 131, 33, 136, 54, 132, 120, 236, 131, 239, 76,
+       187, 4, 172, 48, 36, 140, 1, 103, 62, 254, 204, 71, 32, 166, 148,
+       137, 244, 184, 67, 191, 215, 203, 19, 140, 238, 119, 206, 229, 47,
+       251, 149, 22, 73, 146, 192, 153, 118, 223, 75, 128, 101, 185, 70,
+       7, 31, 227, 77, 118, 178, 171, 82, 94, 192, 94, 230, 185, 236,
+       183, 236, 126, 109, 22, 157, 133, 176, 36, 202, 4, 44, 171, 128,
+       223, 237, 121, 245, 71, 8, 167, 156, 205, 244, 161, 3, 203, 219,
+       159, 18, 136, 252, 118, 239, 201, 102, 250, 153, 23, 105, 243,
+       192, 29, 58, 222, 90, 146, 108, 241, 102, 63, 13, 106, 79, 244,
+       179, 235, 112, 85, 192, 125, 130, 121, 125, 183, 32, 126, 234, 23,
+       239, 169, 178, 124, 255, 103, 205, 160, 128, 231, 239, 114, 228,
+       163, 205, 99, 77, 84, 135, 235, 120, 84, 68, 252, 70, 112, 65,
+       180, 100, 92, 168, 18, 238, 233, 186, 117, 223, 37, 62, 130, 64,
+       95, 138, 112, 252, 162, 56, 238, 209, 109, 197, 249, 67, 143, 21,
+       116, 19, 40, 155, 118, 10, 232, 41, 243, 145, 18, 253, 50, 192,
+       71, 25, 218, 99, 193, 8, 119, 234, 0, 24, 190, 217, 44, 231, 177,
+       67, 206, 27, 246, 18, 144, 157, 36, 106, 201, 49, 123, 145, 10,
+       173, 115, 208, 69, 22, 155, 14, 208, 8, 116, 178, 190, 45, 98,
+       238, 87, 179, 218, 224, 65, 128, 253, 138, 107, 201, 53, 176, 122,
+       234, 23, 234, 72, 178, 92, 191, 115, 221, 129, 41, 103, 255, 114,
+       138, 2, 235, 3, 152, 95, 129, 184, 69, 143, 17, 80, 227, 172, 138,
+       100, 204, 238, 57, 147, 209, 6, 27, 2, 245, 156, 16, 154, 234,
+       156, 14, 177, 143, 185, 73, 106, 108, 84, 135, 79, 120, 69, 64,
+       228, 6, 113, 67, 49, 17, 88, 168, 18, 238, 104, 178, 20, 29, 115,
+       169, 160, 8, 123, 186, 98, 184, 185, 72, 106, 76, 84, 135, 111,
+       240, 84, 128, 116, 14, 115, 193, 49, 16, 120, 232, 19, 238, 233,
+       183, 16, 15, 115, 141, 161, 0, 123, 187, 122, 184, 57, 29, 122,
+       108, 245, 119, 95, 83, 117, 204, 125, 38, 27, 253, 183, 244, 254,
+       188, 151, 168, 153, 178, 36, 206, 114, 253, 161, 131, 183, 239,
+       254, 245, 25, 193, 106, 239, 82, 6, 111, 125, 4, 73, 95, 6, 113,
+       71, 186, 96, 126, 138, 23, 238, 203, 144, 61, 29, 113, 173, 162,
+       132, 63, 138, 168, 50, 27, 159, 106, 139, 150, 147, 255, 247, 4,
+       4, 94, 166, 57, 28, 182, 228, 126, 171, 151, 221, 222, 184, 37,
+       253, 234, 13, 174, 193, 119, 158, 248, 233, 170, 144, 254, 248,
+       79, 208, 240, 71, 201, 29, 116, 51, 44, 153, 118, 59, 234, 185,
+       179, 145, 22, 127, 130, 193, 87, 121, 210, 203, 215, 12, 126, 143,
+       33, 16, 49, 72, 69, 205, 193, 80, 65, 73, 116, 8, 18, 145, 54, 52,
+       200, 136, 18, 8, 195, 58, 114, 213, 85, 24, 16, 104, 91, 136, 114,
+       238, 33, 141, 104, 75, 84, 135, 203, 120, 86, 76, 124, 12, 49,
+       209, 54, 52, 88, 168, 18, 252, 235, 58, 120, 63, 111, 140, 161,
+       124, 123, 138, 114, 248, 17, 143, 90, 76, 180, 158, 110, 55, 125,
+       9, 126, 68, 98, 40, 182, 116, 54, 170, 6, 12, 223, 184, 37, 111,
+       42, 62, 48, 128, 104, 138, 232, 13, 33, 240, 49, 72, 117, 205,
+       225, 121, 83, 72, 100, 12, 50, 145, 86, 52, 216, 136, 82, 8, 139,
+       58, 114, 25, 71, 24, 16, 104, 91, 136, 82, 248, 41, 173, 105, 106,
+       92, 197, 71, 249, 67, 72, 236, 9, 51, 211, 56, 48, 88, 168, 23,
+       238, 91, 42, 88, 61, 123, 201, 165, 124, 123, 138, 114, 138, 119,
+       97, 75, 236, 80, 159, 74, 104, 225, 160, 233, 10, 83, 194, 63, 48,
+       184, 168, 80, 238, 76, 19, 60, 29, 179, 204, 129, 60, 113, 171,
+       82, 100, 239, 75, 100, 68, 109, 58, 196, 160, 201, 190, 182, 237,
+       10, 40, 151, 255, 76, 228, 230, 110, 140, 122, 228, 192, 22, 121,
+       65, 191, 95, 253, 90, 205, 106, 184, 62, 188, 75, 205, 16, 103,
+       171, 85, 160, 25, 46, 221, 98, 19, 174, 187, 194, 1, 22, 107, 146,
+       213, 87, 209, 80, 107, 80, 12, 7, 219, 226, 168, 26, 184, 105,
+       241, 144, 71, 159, 29, 240, 185, 172, 142, 38, 153, 204, 187, 226,
+       129, 54, 79, 162, 241, 151, 241, 90, 107, 80, 12, 175, 222, 16,
+       235, 138, 255, 52, 131, 71, 252, 20, 136, 194, 98, 119, 65, 57,
+       64, 120, 248, 13, 235, 104, 145, 9, 47, 240, 167, 175, 0, 36, 187,
+       48, 40, 102, 41, 115, 236, 124, 168, 218, 96, 201, 0, 249, 139,
+       111, 201, 117, 16, 254, 189, 87, 102, 66, 35, 202, 221, 178, 252,
+       3, 58, 69, 171, 66, 4, 97, 49, 89, 72, 100, 205, 81, 25, 67, 121,
+       116, 8, 18, 23, 36, 52, 200, 152, 6, 24, 91, 58, 112, 20, 83, 153,
+       32, 123, 112, 8, 70, 35, 88, 217, 191, 124, 3, 196, 181, 39, 232,
+       69, 110, 1, 190, 190, 34, 98, 162, 55, 104, 1, 80, 137, 178, 73,
+       241, 165, 94, 3, 64, 0, 165, 107, 32, 168, 25, 189, 109, 205, 49,
+       71, 155, 117, 96, 9, 190, 157, 97, 27, 193, 59, 147, 16, 66, 126,
+       210, 241, 71, 153, 80, 43, 80, 8, 7, 250, 78, 178, 164, 177, 185,
+       124, 57, 27, 59, 253, 23, 53, 140, 62, 94, 223, 135, 23, 253, 149,
+       151, 88, 241, 192, 207, 89, 91, 231, 142, 68, 141, 87, 21, 92, 7,
+       175, 20, 6, 198, 248, 36, 136, 218, 102, 119, 80, 49, 129, 120,
+       228, 76, 227, 73, 161, 25, 44, 176, 165, 175, 20, 105, 51, 48, 41,
+       29, 133, 104, 233, 214, 7, 235, 251, 6, 101, 220, 134, 81, 79, 58,
+       96, 120, 137, 23, 238, 219, 154, 61, 61, 253, 141, 171, 196, 61,
+       171, 176, 242, 108, 161, 152, 226, 252, 205, 82, 159, 82, 169, 44,
+       8, 151, 49, 72, 48, 153, 202, 68, 16, 30, 58, 201, 51, 239, 205,
+       53, 125, 240, 10, 206, 11, 56, 48, 89, 97, 50, 75, 81, 24, 33,
+       168, 53, 40, 22, 23, 192, 48, 18, 144, 84, 104, 11, 48, 112, 16,
+       195, 221, 33, 55, 114, 138, 70, 51, 159, 213, 67, 200, 215, 179,
+       234, 220, 23, 73, 88, 230, 73, 219, 189, 228, 127, 153, 151, 249,
+       147, 146, 12, 215, 58, 124, 139, 206, 191, 159, 57, 181, 191, 253,
+       104, 43, 242, 63, 95, 248, 17, 198, 77, 141, 83, 237, 91, 48, 55,
+       203, 149, 103, 236, 146, 60, 62, 235, 77, 5, 181, 247, 255, 222,
+       210, 190, 125, 36, 170, 255, 213, 222, 232, 137, 116, 133, 143,
+       77, 223, 123, 3, 206, 209, 217, 247, 238, 7, 252, 189, 243, 81,
+       143, 255, 54, 191, 150, 210, 61, 199, 101, 79, 52, 27, 199, 184,
+       118, 168, 187, 238, 211, 96, 189, 176, 91, 204, 78, 106, 233, 32,
+       109, 30, 172, 207, 37, 20, 117, 187, 84, 36, 50, 129, 112, 234,
+       245, 221, 214, 239, 11, 45, 184, 11, 14, 189, 108, 20, 153, 155,
+       135, 17, 94, 58, 72, 213, 187, 212, 5, 127, 83, 14, 198, 142, 197,
+       201, 151, 215, 178, 206, 41, 168, 190, 153, 66, 0, 252, 246, 232,
+       98, 183, 127, 42, 88, 3, 216, 187, 125, 205, 170, 111, 68, 128,
+       34, 37, 43, 188, 229, 250, 192, 212, 70, 255, 252, 80, 134, 244,
+       18, 81, 249, 253, 97, 121, 220, 147, 250, 248, 247, 176, 162, 123,
+       173, 165, 101, 231, 249, 254, 162, 162, 137, 43, 138, 240, 193,
+       175, 229, 204, 76, 248, 3, 48, 204, 54, 81, 248, 171, 27, 199, 82,
+       171, 38, 125, 121, 40, 142, 216, 81, 10, 229, 106, 38, 203, 140,
+       190, 254, 193, 16, 232, 154, 157, 252, 171, 100, 238, 106, 18,
+       219, 251, 167, 17, 6, 107, 202, 125, 90, 3, 237, 255, 149, 42, 62,
+       203, 167, 237, 103, 83, 212, 198, 236, 229, 240, 210, 83, 82, 81,
+       124, 188, 43, 249, 110, 16, 255, 245, 210, 188, 76, 45, 42, 207,
+       196, 165, 240, 242, 228, 178, 11, 70, 172, 77, 2, 72, 97, 161,
+       144, 240, 11, 43, 42, 37, 147, 232, 129, 6, 225, 44, 235, 18, 204,
+       145, 224, 194, 3, 37, 40, 118, 134, 80, 178, 157, 157, 25, 206,
+       97, 184, 190, 248, 203, 69, 246, 226, 65, 214, 113, 228, 108, 248,
+       11, 208, 219, 93, 140, 162, 239, 4, 8, 35, 41, 26, 33, 161, 185,
+       99, 124, 205, 67, 157, 83, 233, 60, 24, 178, 145, 88, 48, 153,
+       154, 86, 88, 27, 122, 250, 51, 79, 157, 53, 124, 104, 138, 210,
+       170, 159, 86, 239, 21, 3, 118, 189, 113, 172, 246, 87, 183, 221,
+       118, 178, 111, 38, 53, 249, 175, 229, 213, 55, 200, 195, 99, 251,
+       129, 47, 244, 37, 245, 11, 129, 112, 233, 180, 179, 120, 59, 127,
+       17, 95, 16, 141, 43, 244, 100, 183, 27, 53, 152, 150, 152, 35,
+       215, 142, 221, 154, 199, 182, 132, 129, 12, 9, 156, 99, 169, 151,
+       247, 235, 247, 22, 77, 122, 231, 57, 191, 178, 64, 125, 43, 150,
+       149, 151, 184, 53, 255, 47, 237, 162, 192, 191, 206, 244, 249, 18,
+       143, 47, 185, 178, 226, 185, 231, 142, 77, 90, 163, 12, 143, 162,
+       64, 231, 51, 159, 209, 50, 153, 32, 253, 232, 68, 190, 195, 180,
+       4, 165, 107, 53, 107, 106, 101, 36, 15, 231, 244, 96, 232, 114,
+       77, 51, 136, 87, 48, 184, 108, 36, 79, 204, 182, 180, 42, 96, 141,
+       37, 32, 73, 187, 82, 200, 34, 159, 107, 5, 214, 235, 206, 39, 84,
+       229, 250, 239, 98, 44, 150, 64, 120, 174, 3, 133, 252, 186, 101,
+       30, 62, 46, 180, 147, 101, 200, 212, 94, 3, 190, 163, 28, 123,
+       181, 176, 111, 159, 207, 216, 119, 44, 190, 230, 100, 197, 59,
+       187, 145, 150, 203, 166, 223, 27, 118, 159, 235, 146, 68, 165,
+       223, 44, 154, 140, 158, 223, 215, 133, 232, 146, 222, 244, 15,
+       126, 228, 106, 141, 89, 234, 162, 44, 43, 98, 106, 61, 89, 7, 111,
+       109, 211, 44, 60, 243, 144, 72, 78, 252, 6, 192, 173, 100, 148, 6,
+       194, 130, 49, 139, 49, 73, 106, 241, 35, 227, 104, 141, 22, 111,
+       209, 163, 218, 1, 53, 56, 53, 138, 31, 84, 255, 87, 3, 118, 61,
+       48, 125, 230, 23, 134, 221, 127, 183, 238, 55, 117, 189, 175, 129,
+       213, 61, 202, 195, 111, 251, 132, 175, 246, 5, 113, 62, 223, 228,
+       50, 187, 163, 159, 140, 27, 37, 185, 239, 106, 108, 223, 128, 191,
+       219, 165, 211, 222, 163, 79, 247, 56, 70, 173, 247, 247, 87, 182,
+       87, 19, 223, 98, 200, 223, 151, 254, 229, 197, 68, 220, 135, 41,
+       202, 54, 0, 238, 163, 151, 228, 222, 139, 52, 253, 186, 220, 130,
+       203, 63, 142, 240, 222, 254, 87, 108, 170, 251, 85, 159, 248, 128,
+       92, 149, 175, 93, 79, 59, 11, 222, 209, 223, 247, 232, 3, 122,
+       188, 115, 67, 237, 189, 55, 255, 158, 211, 102, 105, 82, 238, 94,
+       137, 202, 224, 139, 128, 249, 10, 39, 200, 125, 16, 250, 233, 67,
+       115, 66, 35, 202, 125, 60, 188, 9, 56, 117, 43, 66, 136, 224, 139,
+       46, 186, 252, 133, 183, 229, 198, 12, 240, 35, 48, 216, 48, 112,
+       200, 99, 83, 209, 246, 11, 14, 127, 125, 38, 175, 105, 81, 10,
+       247, 234, 15, 203, 230, 154, 235, 145, 190, 193, 143, 28, 84, 163,
+       44, 206, 247, 239, 239, 123, 147, 215, 214, 9, 46, 240, 62, 89,
+       207, 171, 151, 55, 169, 213, 80, 178, 140, 157, 28, 206, 97, 184,
+       190, 221, 198, 68, 230, 226, 74, 210, 113, 228, 236, 216, 9, 208,
+       235, 93, 141, 163, 239, 69, 40, 32, 45, 120, 54, 164, 16, 234,
+       253, 61, 210, 204, 11, 57, 185, 8, 206, 249, 77, 24, 153, 155, 69,
+       51, 30, 35, 218, 212, 155, 220, 5, 127, 210, 79, 74, 130, 193, 63,
+       15, 69, 52, 222, 76, 55, 169, 232, 170, 76, 182, 23, 144, 182, 0,
+       38, 92, 76, 201, 201, 176, 73, 163, 184, 4, 16, 74, 144, 210, 57,
+       189, 173, 44, 35, 157, 255, 210, 200, 198, 249, 189, 9, 203, 88,
+       94, 163, 137, 68, 220, 119, 190, 225, 121, 156, 235, 217, 37, 119,
+       219, 111, 90, 70, 95, 4, 244, 229, 167, 62, 254, 154, 105, 178,
+       31, 2, 221, 127, 159, 110, 55, 85, 253, 171, 164, 113, 173, 202,
+       211, 255, 203, 7, 167, 247, 77, 39, 98, 89, 111, 28, 67, 198, 29,
+       38, 161, 196, 194, 135, 40, 142, 39, 83, 200, 183, 233, 193, 77,
+       139, 50, 205, 19, 50, 218, 131, 33, 20, 54, 126, 221, 205, 86,
+       162, 170, 40, 94, 169, 169, 146, 26, 96, 207, 227, 201, 210, 183,
+       243, 125, 239, 114, 5, 138, 234, 184, 253, 47, 156, 140, 243, 171,
+       1, 55, 118, 237, 130, 28, 23, 207, 89, 94, 238, 149, 222, 112, 68,
+       191, 172, 93, 192, 22, 255, 239, 135, 125, 126, 56, 14, 173, 180,
+       157, 255, 80, 245, 198, 62, 190, 211, 164, 172, 185, 23, 250, 191,
+       23, 80, 148, 36, 84, 111, 133, 22, 59, 25, 178, 92, 241, 226, 77,
+       26, 222, 192, 128, 72, 149, 41, 195, 166, 189, 209, 228, 112, 169,
+       183, 122, 123, 86, 112, 144, 51, 212, 111, 67, 30, 55, 153, 179,
+       252, 229, 70, 76, 26, 254, 228, 132, 192, 181, 165, 128, 204, 117,
+       117, 228, 234, 239, 183, 113, 238, 62, 114, 113, 125, 148, 37, 35,
+       102, 53, 170, 241, 252, 41, 191, 46, 254, 245, 128, 103, 241, 213,
+       249, 16, 171, 75, 223, 20, 195, 106, 33, 148, 192, 87, 227, 241,
+       199, 176, 65, 120, 56, 27, 236, 107, 136, 106, 61, 111, 129, 171,
+       193, 53, 138, 116, 232, 109, 77, 185, 198, 252, 119, 143, 220, 82,
+       239, 149, 26, 92, 101, 219, 188, 31, 86, 211, 239, 177, 103, 56,
+       234, 123, 15, 239, 188, 199, 251, 191, 113, 157, 8, 199, 229, 70,
+       126, 238, 80, 85, 234, 115, 194, 89, 109, 177, 235, 126, 228, 54,
+       238, 161, 180, 61, 202, 23, 235, 227, 132, 111, 251, 112, 144, 90,
+       82, 103, 168, 43, 225, 25, 72, 143, 85, 128, 163, 12, 143, 38, 73,
+       198, 17, 187, 145, 6, 7, 50, 213, 211, 112, 154, 255, 22, 5, 37,
+       83, 236, 223, 120, 246, 37, 30, 215, 184, 216, 134, 181, 10, 127,
+       119, 99, 49, 56, 224, 133, 106, 224, 101, 184, 239, 115, 203, 101,
+       61, 67, 255, 94, 99, 191, 241, 108, 211, 143, 85, 94, 248, 3, 246,
+       77, 134, 107, 253, 90, 175, 92, 218, 149, 226, 220, 82, 254, 177,
+       171, 217, 205, 175, 55, 255, 158, 247, 92, 106, 152, 182, 235, 51,
+       20, 204, 146, 182, 128, 155, 68, 234, 107, 203, 217, 109, 168,
+       211, 46, 71, 202, 170, 154, 199, 223, 63, 128, 125, 44, 6, 67,
+       201, 3, 158, 216, 192, 175, 229, 148, 0, 64, 66, 180, 215, 48, 32,
+       104, 113, 91, 203, 113, 11, 138, 125, 173, 38, 142, 72, 20, 24,
+       177, 168, 173, 4, 215, 109, 214, 106, 229, 31, 17, 195, 115, 242,
+       83, 117, 168, 36, 122, 156, 18, 56, 49, 180, 101, 138, 39, 238,
+       36, 4, 231, 232, 196, 224, 173, 212, 215, 101, 197, 70, 79, 255,
+       85, 226, 242, 86, 83, 60, 188, 231, 217, 198, 22, 47, 253, 254,
+       117, 174, 44, 234, 212, 68, 111, 252, 240, 252, 235, 192, 64, 144,
+       205, 29, 100, 57, 89, 114, 7, 94, 74, 152, 86, 252, 17, 132, 178,
+       47, 213, 62, 215, 215, 30, 90, 213, 110, 31, 140, 216, 4, 224,
+       203, 109, 237, 40, 6, 79, 187, 130, 54, 164, 193, 145, 7, 144, 83,
+       76, 212, 109, 238, 232, 14, 225, 29, 227, 233, 235, 181, 16, 176,
+       198, 96, 103, 9, 110, 144, 207, 212, 188, 97, 137, 222, 209, 159,
+       8, 236, 118, 15, 238, 189, 147, 167, 212, 247, 182, 192, 23, 48,
+       203, 235, 69, 47, 191, 214, 102, 6, 108, 202, 121, 241, 90, 200,
+       143, 253, 189, 171, 72, 110, 191, 247, 205, 177, 151, 176, 142, 3,
+       110, 252, 59, 92, 137, 255, 151, 223, 124, 86, 227, 80, 140, 191,
+       45, 36, 72, 140, 146, 83, 128, 21, 241, 99, 91, 91, 201, 68, 121,
+       237, 47, 71, 219, 139, 196, 251, 218, 28, 156, 117, 120, 218, 195,
+       241, 180, 210, 237, 13, 220, 143, 155, 187, 16, 121, 140, 158,
+       220, 63, 135, 219, 117, 21, 214, 79, 138, 192, 187, 90, 95, 254,
+       132, 20, 131, 95, 201, 234, 50, 99, 36, 156, 122, 48, 233, 8, 55,
+       104, 191, 153, 208, 176, 134, 19, 93, 75, 194, 188, 160, 229, 198,
+       217, 32, 192, 78, 130, 75, 9, 175, 149, 242, 252, 124, 55, 186,
+       252, 31, 73, 116, 251, 121, 252, 191, 33, 223, 91, 23, 117, 182,
+       50, 104, 223, 127, 221, 39, 174, 215, 220, 99, 223, 43, 214, 248,
+       204, 127, 87, 219, 216, 91, 93, 244, 239, 88, 252, 255, 33, 221,
+       153, 151, 53, 167, 114, 126, 157, 94, 93, 161, 175, 223, 172, 124,
+       215, 35, 52, 224, 73, 215, 253, 184, 206, 91, 71, 124, 134, 168,
+       140, 87, 172, 191, 123, 147, 157, 135, 48, 246, 226, 7, 28, 26,
+       171, 223, 93, 75, 220, 63, 116, 232, 74, 27, 211, 26, 204, 215,
+       231, 175, 167, 72, 222, 111, 252, 119, 177, 159, 178, 174, 7, 61,
+       254, 59, 95, 133, 151, 191, 23, 108, 86, 148, 94, 106, 206, 36,
+       67, 207, 112, 116, 142, 247, 98, 83, 83, 177, 53, 120, 248, 23,
+       234, 232, 183, 32, 110, 240, 139, 163, 128, 103, 187, 101, 43,
+       211, 153, 46, 176, 165, 143, 124, 55, 141, 228, 6, 15, 54, 153,
+       51, 65, 162, 38, 123, 93, 212, 153, 16, 188, 250, 89, 13, 82, 12,
+       140, 89, 94, 50, 79, 47, 225, 180, 175, 73, 23, 132, 173, 158,
+       203, 163, 7, 209, 64, 76, 166, 15, 156, 136, 153, 97, 12, 239,
+       133, 173, 145, 160, 216, 84, 105, 134, 231, 245, 243, 132, 224,
+       223, 143, 223, 23, 27, 19, 237, 233, 92, 74, 147, 219, 53, 147,
+       58, 108, 139, 247, 233, 158, 159, 111, 181, 211, 213, 10, 3, 172,
+       153, 153, 252, 169, 168, 142, 186, 27, 24, 80, 156, 138, 92, 10,
+       135, 91, 91, 25, 50, 76, 138, 241, 12, 28, 186, 236, 148, 81, 131,
+       136, 2, 248, 187, 154, 98, 237, 186, 198, 143, 89, 80, 117, 188,
+       158, 108, 104, 167, 59, 23, 81, 147, 12, 178, 241, 5, 28, 26, 234,
+       156, 9, 133, 243, 154, 236, 209, 247, 213, 228, 238, 135, 123, 3,
+       106, 18, 41, 123, 84, 132, 35, 251, 49, 152, 51, 252, 153, 247,
+       47, 255, 150, 64, 47, 209, 216, 136, 70, 232, 185, 210, 236, 141,
+       184, 206, 155, 59, 16, 121, 156, 158, 93, 58, 135, 91, 87, 81,
+       130, 78, 138, 241, 13, 30, 94, 254, 148, 17, 131, 143, 211, 31,
+       198, 158, 102, 160, 46, 194, 149, 194, 210, 231, 40, 234, 183,
+       207, 102, 235, 155, 199, 165, 207, 6, 234, 48, 34, 202, 138, 47,
+       245, 57, 221, 113, 13, 200, 229, 164, 63, 76, 55, 65, 170, 158,
+       72, 179, 33, 144, 182, 28, 230, 124, 172, 221, 184, 197, 10, 162,
+       190, 101, 144, 40, 232, 216, 12, 178, 1, 126, 251, 23, 238, 216,
+       0, 81, 29, 243, 27, 106, 93, 60, 89, 248, 155, 181, 209, 26, 242,
+       65, 149, 211, 248, 144, 211, 103, 15, 244, 3, 31, 89, 227, 123,
+       167, 220, 89, 148, 63, 89, 118, 167, 59, 157, 191, 252, 182, 187,
+       181, 213, 143, 144, 55, 241, 195, 121, 144, 194, 119, 149, 212,
+       127, 38, 110, 109, 161, 188, 175, 233, 150, 6, 180, 154, 207, 129,
+       13, 81, 9, 77, 66, 91, 93, 170, 216, 101, 60, 172, 5, 173, 244,
+       164, 217, 84, 120, 153, 236, 220, 247, 149, 182, 238, 167, 115,
+       163, 110, 18, 41, 43, 82, 132, 41, 238, 32, 152, 46, 252, 217,
+       255, 111, 207, 150, 65, 107, 192, 248, 138, 152, 206, 108, 247,
+       213, 186, 238, 183, 119, 38, 30, 22, 105, 41, 18, 5, 41, 230, 33,
+       136, 110, 252, 77, 255, 110, 239, 149, 65, 39, 212, 216, 138, 61,
+       155, 235, 233, 247, 214, 123, 87, 21, 237, 126, 102, 25, 63, 178,
+       228, 126, 190, 151, 156, 153, 152, 52, 138, 127, 237, 166, 197,
+       175, 172, 244, 241, 216, 78, 237, 125, 207, 114, 111, 175, 255,
+       150, 62, 147, 105, 107, 23, 11, 35, 231, 105, 170, 100, 68, 111,
+       251, 103, 235, 197, 1, 39, 245, 212, 98, 202, 184, 22, 153, 107,
+       177, 48, 71, 191, 21, 64, 183, 172, 154, 226, 207, 231, 43, 187,
+       21, 54, 93, 134, 247, 30, 50, 90, 235, 30, 4, 185, 207, 14, 243,
+       163, 170, 173, 197, 191, 220, 142, 93, 157, 231, 156, 223, 250,
+       34, 205, 89, 191, 215, 214, 3, 42, 224, 107, 81, 175, 255, 150,
+       159, 181, 211, 34, 168, 242, 216, 103, 176, 184, 71, 27, 31, 80,
+       191, 44, 174, 118, 141, 239, 187, 151, 149, 150, 95, 130, 211, 31,
+       30, 218, 235, 159, 76, 191, 159, 130, 141, 99, 251, 182, 131, 222,
+       253, 29, 2, 80, 147, 239, 207, 189, 69, 222, 251, 23, 127, 114,
+       188, 10, 255, 170, 250, 150, 202, 54, 221, 161, 140, 246, 223,
+       125, 110, 186, 98, 23, 188, 213, 202, 155, 230, 82, 125, 169, 98,
+       215, 243, 189, 99, 237, 1, 125, 170, 59, 102, 37, 150, 255, 243,
+       164, 119, 3, 135, 83, 206, 86, 210, 170, 97, 109, 65, 123, 226,
+       104, 242, 172, 228, 126, 170, 22, 238, 211, 152, 44, 255, 52, 60,
+       2, 194, 31, 143, 225, 165, 245, 151, 44, 168, 188, 47, 67, 184, 6,
+       124, 157, 127, 82, 81, 250, 65, 89, 128, 31, 127, 186, 34, 105,
+       150, 216, 75, 161, 252, 60, 47, 80, 99, 3, 140, 99, 89, 16, 183,
+       233, 39, 30, 67, 114, 214, 48, 226, 180, 68, 125, 42, 51, 140,
+       179, 188, 53, 223, 13, 46, 154, 64, 93, 136, 225, 252, 66, 169,
+       191, 176, 153, 236, 16, 203, 171, 157, 128, 25, 142, 190, 66, 26,
+       161, 87, 249, 17, 22, 75, 146, 65, 153, 85, 30, 127, 128, 4, 167,
+       66, 232, 26, 181, 220, 44, 112, 192, 142, 87, 90, 208, 122, 162,
+       24, 181, 239, 200, 210, 174, 65, 175, 110, 231, 179, 144, 112,
+       240, 59, 84, 89, 84, 45, 156, 76, 229, 247, 135, 96, 237, 143,
+       243, 150, 63, 147, 105, 111, 93, 43, 43, 247, 165, 163, 40, 116,
+       255, 234, 103, 235, 199, 1, 231, 245, 212, 98, 222, 101, 245, 119,
+       135, 98, 223, 143, 219, 246, 123, 146, 207, 237, 93, 106, 51, 255,
+       181, 147, 112, 244, 174, 226, 235, 243, 77, 69, 231, 245, 215, 98,
+       14, 209, 183, 251, 169, 133, 186, 148, 143, 25, 155, 115, 220,
+       223, 120, 200, 199, 19, 191, 209, 147, 137, 10, 240, 203, 221,
+       190, 198, 148, 23, 161, 59, 114, 192, 243, 246, 85, 230, 217, 102,
+       25, 33, 179, 26, 120, 63, 20, 44, 254, 181, 29, 129, 40, 239, 80,
+       207, 147, 254, 154, 18, 5, 12, 116, 110, 11, 115, 104, 65, 42,
+       183, 249, 23, 108, 224, 94, 164, 153, 141, 215, 234, 38, 29, 255,
+       220, 213, 144, 181, 192, 70, 105, 170, 128, 47, 215, 217, 245,
+       180, 201, 2, 170, 29, 131, 66, 232, 149, 0, 161, 75, 98, 194, 44,
+       65, 248, 161, 74, 227, 106, 167, 24, 253, 177, 160, 131, 94, 57,
+       27, 120, 2, 184, 212, 238, 224, 213, 118, 117, 247, 85, 167, 238,
+       151, 3, 45, 50, 67, 249, 198, 163, 176, 124, 255, 17, 142, 123,
+       227, 148, 71, 227, 220, 252, 218, 135, 63, 195, 205, 246, 182,
+       171, 83, 122, 200, 90, 230, 24, 174, 247, 228, 118, 47, 22, 157,
+       149, 184, 164, 194, 12, 60, 170, 192, 141, 229, 121, 245, 246,
+       229, 253, 242, 215, 122, 78, 140, 91, 243, 57, 154, 223, 127, 92,
+       189, 19, 223, 53, 123, 59, 100, 62, 246, 171, 222, 223, 95, 167,
+       83, 215, 114, 49, 141, 105, 173, 213, 231, 107, 119, 119, 65, 76,
+       2, 112, 127, 16, 48, 121, 170, 18, 169, 63, 184, 53, 95, 127, 15,
+       148, 64, 181, 130, 250, 168, 167, 213, 249, 210, 180, 247, 94,
+       190, 27, 83, 45, 156, 117, 255, 92, 48, 151, 215, 49, 222, 223,
+       43, 62, 247, 43, 222, 157, 118, 157, 211, 202, 28, 59, 64, 247,
+       244, 87, 22, 216, 86, 89, 161, 242, 146, 123, 63, 20, 188, 254,
+       181, 53, 141, 168, 250, 21, 205, 19, 255, 154, 18, 103, 141, 112,
+       44, 255, 237, 106, 34, 135, 124, 222, 232, 113, 198, 173, 10, 75,
+       252, 95, 176, 53, 203, 209, 239, 237, 34, 190, 170, 123, 109, 13,
+       63, 111, 119, 254, 86, 188, 215, 238, 228, 213, 70, 87, 127, 21,
+       143, 246, 151, 67, 189, 46, 83, 221, 212, 135, 112, 120, 191, 49,
+       142, 123, 227, 228, 71, 243, 248, 244, 251, 65, 141, 16, 187, 228,
+       169, 175, 39, 126, 19, 75, 0, 181, 163, 128, 64, 35, 43, 42, 136,
+       18, 152, 75, 117, 76, 134, 122, 64, 144, 194, 129, 136, 190, 162,
+       224, 242, 151, 113, 219, 216, 19, 183, 149, 187, 73, 205, 90, 13,
+       59, 216, 197, 243, 62, 71, 172, 162, 218, 213, 157, 255, 167, 173,
+       126, 198, 99, 221, 249, 206, 252, 165, 158, 252, 155, 65, 185, 76,
+       116, 122, 60, 48, 158, 83, 81, 199, 135, 11, 26, 127, 123, 30,
+       143, 58, 77, 211, 131, 26, 247, 223, 58, 198, 190, 134, 159, 252,
+       216, 204, 185, 111, 116, 122, 60, 32, 150, 247, 93, 103, 224, 43,
+       152, 239, 248, 62, 47, 184, 77, 51, 163, 83, 195, 152, 246, 154,
+       215, 177, 176, 167, 223, 85, 82, 247, 236, 232, 118, 205, 167, 47,
+       171, 145, 182, 216, 159, 241, 12, 114, 95, 203, 159, 12, 169, 14,
+       82, 152, 190, 188, 137, 124, 144, 143, 171, 95, 138, 25, 142, 190,
+       71, 90, 161, 87, 233, 17, 22, 73, 178, 209, 153, 247, 90, 127,
+       128, 96, 7, 78, 246, 95, 51, 166, 191, 6, 159, 244, 153, 238, 145,
+       111, 126, 124, 29, 19, 158, 245, 93, 231, 232, 7, 184, 238, 241,
+       190, 239, 178, 13, 119, 183, 115, 114, 56, 236, 30, 73, 249, 80,
+       72, 219, 214, 165, 137, 106, 252, 71, 63, 136, 249, 225, 67, 76,
+       103, 254, 240, 147, 82, 81, 59, 83, 111, 94, 94, 75, 168, 191,
+       211, 207, 212, 189, 135, 254, 115, 6, 18, 188, 190, 86, 239, 225,
+       79, 123, 157, 19, 92, 187, 241, 95, 27, 222, 111, 134, 84, 245,
+       238, 119, 172, 226, 172, 254, 3, 142, 235, 91, 162, 152, 203, 108,
+       234, 61, 16, 191, 199, 23, 167, 244, 99, 12, 255, 56, 30, 143,
+       190, 245, 246, 35, 132, 164, 237, 209, 122, 252, 169, 206, 231,
+       89, 50, 120, 216, 247, 104, 93, 16, 27, 235, 70, 107, 122, 54,
+       204, 59, 60, 158, 5, 60, 213, 251, 210, 128, 10, 143, 46, 155,
+       155, 241, 184, 71, 158, 85, 93, 179, 172, 175, 34, 192, 207, 59,
+       155, 145, 54, 137, 34, 247, 110, 103, 154, 203, 151, 12, 189, 218,
+       26, 206, 38, 187, 23, 148, 186, 230, 149, 5, 94, 199, 108, 202,
+       58, 197, 236, 43, 147, 197, 230, 153, 6, 255, 38, 119, 154, 195,
+       55, 140, 57, 206, 230, 123, 59, 90, 233, 117, 150, 218, 155, 222,
+       180, 237, 40, 252, 103, 63, 205, 251, 247, 70, 245, 99, 186, 240,
+       51, 24, 69, 187, 219, 125, 198, 215, 112, 235, 240, 225, 36, 74,
+       65, 38, 107, 180, 190, 141, 131, 9, 86, 22, 10, 228, 108, 93, 88,
+       248, 229, 136, 156, 216, 213, 117, 239, 140, 86, 108, 95, 73, 99,
+       196, 23, 86, 239, 53, 197, 192, 210, 198, 73, 140, 181, 230, 110,
+       228, 56, 237, 205, 149, 181, 202, 48, 124, 142, 130, 47, 190, 240,
+       116, 196, 99, 172, 178, 236, 73, 189, 200, 130, 255, 145, 185,
+       213, 205, 91, 11, 25, 81, 127, 119, 82, 71, 202, 0, 213, 0, 239,
+       189, 68, 59, 151, 242, 240, 66, 70, 174, 28, 3, 66, 104, 237, 2,
+       227, 66, 98, 194, 45, 65, 120, 165, 74, 227, 104, 167, 25, 95,
+       144, 162, 138, 24, 57, 59, 96, 0, 182, 41, 122, 80, 211, 194, 59,
+       66, 177, 132, 100, 171, 40, 215, 103, 29, 46, 249, 193, 208, 48,
+       223, 128, 110, 123, 128, 133, 235, 163, 161, 38, 243, 95, 149, 44,
+       170, 189, 191, 150, 171, 206, 109, 143, 7, 206, 120, 62, 192, 129,
+       3, 253, 53, 156, 9, 91, 181, 232, 87, 138, 87, 158, 78, 153, 87,
+       45, 52, 168, 178, 196, 45, 240, 218, 82, 167, 93, 31, 181, 201,
+       91, 8, 153, 11, 35, 21, 134, 54, 218, 18, 204, 7, 191, 109, 252,
+       75, 27, 194, 66, 10, 190, 146, 139, 241, 184, 7, 175, 149, 134,
+       179, 172, 190, 102, 78, 227, 55, 235, 145, 22, 73, 130, 240, 159,
+       54, 222, 251, 144, 68, 141, 79, 38, 56, 189, 154, 219, 229, 144,
+       200, 139, 221, 177, 47, 44, 220, 103, 58, 205, 249, 211, 23, 134,
+       99, 250, 240, 27, 22, 139, 251, 209, 111, 7, 215, 66, 82, 113,
+       251, 108, 172, 249, 20, 143, 89, 145, 243, 188, 159, 244, 106,
+       206, 17, 95, 81, 131, 40, 194, 241, 134, 152, 186, 250, 28, 139,
+       1, 185, 64, 234, 219, 86, 224, 216, 36, 23, 234, 11, 124, 96, 60,
+       182, 196, 246, 163, 63, 36, 8, 67, 220, 162, 99, 39, 189, 54, 139,
+       64, 80, 231, 173, 165, 107, 201, 229, 228, 11, 79, 217, 22, 168,
+       144, 236, 211, 101, 209, 43, 28, 204, 118, 110, 201, 242, 205, 8,
+       252, 136, 229, 180, 108, 251, 82, 177, 3, 88, 140, 159, 45, 84,
+       148, 173, 143, 83, 130, 5, 236, 122, 55, 207, 192, 103, 251, 71,
+       68, 193, 83, 225, 130, 114, 222, 19, 26, 124, 153, 30, 45, 165,
+       168, 161, 212, 191, 242, 75, 66, 225, 121, 11, 17, 184, 90, 160,
+       153, 11, 147, 21, 151, 58, 92, 18, 78, 13, 173, 109, 221, 74, 218,
+       130, 41, 181, 217, 65, 213, 253, 242, 71, 75, 97, 109, 88, 8, 184,
+       84, 176, 157, 154, 146, 24, 151, 58, 244, 215, 47, 29, 21, 111,
+       217, 74, 202, 132, 90, 132, 248, 228, 54, 74, 90, 59, 25, 166,
+       150, 147, 255, 111, 152, 97, 127, 213, 29, 173, 168, 124, 13, 207,
+       251, 239, 239, 133, 229, 168, 36, 32, 211, 133, 8, 170, 149, 211,
+       86, 173, 93, 65, 130, 23, 239, 88, 62, 225, 208, 131, 157, 229,
+       127, 11, 93, 159, 184, 241, 142, 95, 60, 14, 185, 30, 184, 233,
+       90, 106, 91, 197, 82, 228, 23, 4, 228, 11, 59, 201, 34, 144, 88,
+       248, 130, 242, 110, 47, 88, 63, 251, 193, 5, 121, 115, 26, 110,
+       138, 222, 4, 134, 20, 9, 118, 56, 107, 189, 218, 135, 149, 76,
+       230, 38, 223, 165, 37, 249, 167, 37, 69, 146, 192, 147, 115, 203,
+       143, 138, 101, 45, 86, 199, 52, 205, 177, 172, 54, 140, 159, 2,
+       250, 154, 246, 213, 126, 219, 107, 87, 71, 124, 189, 253, 68, 247,
+       192, 172, 42, 239, 212, 140, 240, 185, 85, 6, 40, 121, 219, 230,
+       169, 188, 194, 11, 18, 112, 203, 189, 156, 117, 41, 175, 91, 23,
+       71, 130, 112, 206, 241, 7, 88, 90, 170, 85, 217, 17, 141, 162,
+       253, 115, 90, 213, 221, 199, 229, 93, 4, 100, 10, 42, 220, 52,
+       181, 88, 58, 2, 120, 243, 190, 48, 191, 47, 24, 4, 106, 115, 140,
+       214, 236, 245, 233, 2, 170, 29, 133, 66, 232, 135, 0, 160, 10, 35,
+       208, 97, 148, 216, 232, 74, 111, 74, 39, 152, 191, 177, 212, 131,
+       58, 113, 63, 122, 12, 88, 152, 190, 187, 41, 237, 81, 178, 236,
+       95, 134, 21, 191, 191, 98, 107, 133, 17, 253, 17, 158, 109, 51,
+       32, 203, 193, 114, 19, 144, 64, 5, 91, 35, 34, 234, 1, 85, 63,
+       240, 71, 107, 181, 180, 27, 8, 8, 86, 158, 233, 140, 194, 21, 150,
+       250, 228, 192, 30, 93, 144, 103, 199, 12, 94, 206, 118, 129, 229,
+       230, 205, 101, 222, 169, 195, 245, 169, 11, 104, 254, 127, 59,
+       200, 211, 241, 247, 158, 67, 250, 240, 43, 88, 205, 127, 151, 103,
+       246, 214, 212, 135, 199, 233, 142, 41, 238, 167, 172, 18, 154,
+       195, 207, 107, 57, 66, 123, 211, 75, 235, 72, 33, 77, 194, 180,
+       192, 143, 4, 52, 250, 241, 8, 95, 65, 196, 165, 14, 6, 204, 184,
+       0, 240, 90, 199, 89, 40, 147, 75, 118, 197, 61, 239, 141, 208,
+       157, 136, 144, 107, 239, 148, 173, 255, 25, 20, 156, 54, 104, 161,
+       246, 50, 126, 83, 81, 166, 95, 183, 15, 9, 211, 129, 127, 221,
+       133, 179, 188, 244, 133, 138, 250, 197, 173, 165, 167, 253, 188,
+       67, 128, 250, 93, 248, 104, 128, 104, 182, 172, 16, 112, 224, 181,
+       151, 165, 83, 70, 121, 23, 208, 195, 74, 70, 109, 132, 184, 118,
+       232, 20, 144, 33, 137, 73, 90, 146, 180, 96, 12, 109, 23, 41, 14,
+       110, 205, 63, 163, 3, 94, 38, 236, 61, 12, 64, 156, 146, 99, 212,
+       182, 80, 136, 42, 244, 163, 89, 202, 237, 49, 178, 25, 197, 43,
+       168, 186, 20, 136, 9, 189, 151, 64, 16, 135, 219, 89, 218, 98, 79,
+       154, 247, 249, 212, 143, 104, 18, 3, 7, 106, 63, 233, 99, 202,
+       215, 151, 238, 245, 197, 64, 252, 198, 41, 77, 180, 132, 126, 232,
+       151, 239, 219, 187, 60, 253, 58, 93, 143, 192, 127, 159, 248, 252,
+       166, 232, 173, 186, 75, 101, 189, 206, 154, 183, 16, 19, 12, 239,
+       127, 11, 237, 89, 147, 151, 34, 71, 154, 242, 93, 18, 223, 239,
+       149, 117, 55, 218, 101, 75, 220, 69, 204, 15, 77, 159, 66, 184,
+       184, 78, 19, 34, 213, 122, 76, 196, 124, 252, 205, 98, 231, 8,
+       116, 168, 229, 180, 153, 248, 82, 13, 244, 105, 27, 142, 28, 133,
+       195, 232, 135, 160, 168, 10, 54, 208, 97, 52, 248, 232, 106, 106,
+       74, 35, 154, 125, 177, 132, 135, 58, 81, 59, 118, 168, 65, 41, 58,
+       113, 32, 201, 125, 19, 236, 236, 22, 1, 183, 15, 146, 41, 130, 37,
+       93, 9, 152, 248, 225, 12, 197, 143, 50, 177, 96, 128, 7, 233, 112,
+       233, 151, 174, 88, 141, 146, 236, 166, 160, 234, 11, 114, 209, 96,
+       2, 232, 244, 106, 66, 74, 107, 139, 125, 253, 160, 7, 57, 64, 10,
+       36, 10, 84, 136, 150, 182, 29, 128, 0, 224, 183, 149, 130, 3, 98,
+       226, 104, 66, 233, 230, 104, 208, 10, 233, 138, 113, 153, 162,
+       207, 67, 128, 42, 52, 14, 78, 155, 135, 31, 123, 148, 177, 184,
+       174, 93, 70, 229, 236, 230, 234, 230, 228, 105, 170, 212, 199, 73,
+       191, 113, 12, 32, 79, 202, 24, 38, 37, 253, 75, 59, 190, 28, 106,
+       243, 177, 90, 214, 244, 68, 173, 76, 196, 242, 237, 87, 124, 234,
+       13, 150, 83, 166, 81, 86, 33, 73, 175, 22, 173, 47, 245, 19, 153,
+       107, 205, 246, 198, 239, 113, 68, 200, 95, 230, 113, 253, 180,
+       101, 126, 124, 55, 239, 209, 184, 45, 141, 101, 233, 239, 128,
+       127, 170, 245, 249, 130, 232, 97, 211, 70, 169, 232, 198, 59, 49,
+       48, 155, 156, 11, 85, 27, 47, 155, 87, 223, 194, 126, 142, 241,
+       29, 24, 222, 236, 69, 145, 67, 136, 91, 153, 186, 135, 34, 84, 57,
+       81, 174, 125, 87, 166, 252, 246, 234, 98, 54, 109, 191, 204, 197,
+       145, 175, 193, 214, 125, 107, 133, 142, 166, 41, 125, 208, 105,
+       127, 36, 58, 66, 93, 39, 160, 212, 134, 177, 183, 39, 130, 83, 34,
+       245, 109, 225, 104, 205, 135, 13, 224, 227, 126, 145, 36, 144,
+       167, 106, 221, 64, 111, 207, 6, 18, 111, 121, 96, 194, 215, 130,
+       89, 71, 185, 107, 126, 244, 63, 238, 225, 149, 189, 200, 115, 171,
+       239, 128, 39, 243, 240, 112, 130, 16, 63, 250, 110, 173, 184, 80,
+       175, 89, 49, 117, 188, 158, 108, 11, 166, 57, 55, 83, 147, 12, 26,
+       241, 5, 24, 122, 234, 156, 11, 129, 243, 153, 26, 234, 85, 131,
+       59, 112, 86, 119, 231, 86, 247, 139, 141, 134, 236, 126, 156, 166,
+       140, 157, 252, 229, 146, 70, 111, 176, 199, 127, 140, 120, 221,
+       109, 88, 227, 196, 100, 70, 79, 150, 17, 226, 206, 206, 19, 165,
+       81, 126, 85, 252, 57, 143, 201, 86, 245, 138, 245, 46, 213, 8,
+       166, 252, 116, 120, 178, 205, 68, 245, 70, 234, 108, 39, 73, 178,
+       122, 82, 107, 107, 20, 83, 107, 239, 53, 163, 104, 244, 69, 207,
+       39, 250, 193, 129, 37, 248, 80, 138, 3, 167, 32, 137, 180, 167,
+       139, 111, 94, 77, 217, 151, 160, 44, 190, 4, 221, 11, 23, 181,
+       182, 184, 101, 223, 172, 28, 154, 246, 149, 76, 149, 236, 96, 171,
+       132, 191, 94, 138, 32, 236, 78, 177, 234, 227, 228, 224, 8, 64,
+       120, 238, 106, 65, 86, 250, 207, 117, 28, 38, 215, 82, 48, 10, 53,
+       142, 158, 22, 117, 163, 54, 107, 56, 80, 15, 121, 19, 247, 223,
+       63, 41, 203, 231, 21, 159, 113, 179, 145, 9, 220, 203, 209, 43,
+       214, 182, 143, 21, 115, 215, 141, 215, 146, 170, 40, 46, 175, 189,
+       146, 139, 80, 212, 227, 201, 83, 183, 115, 125, 111, 114, 5, 138,
+       99, 184, 62, 47, 156, 132, 243, 161, 33, 65, 104, 62, 229, 36,
+       234, 233, 55, 104, 68, 126, 0, 183, 30, 146, 120, 162, 45, 92,
+       136, 128, 152, 180, 77, 197, 171, 122, 1, 4, 2, 71, 106, 166, 240,
+       190, 154, 203, 245, 185, 201, 155, 87, 133, 159, 12, 222, 111, 11,
+       239, 25, 147, 147, 6, 71, 58, 209, 91, 16, 219, 127, 149, 13, 167,
+       215, 76, 233, 82, 224, 160, 136, 110, 153, 171, 16, 184, 96, 159,
+       211, 217, 112, 114, 217, 92, 122, 74, 33, 138, 192, 180, 216, 39,
+       252, 12, 179, 227, 128, 50, 169, 210, 173, 213, 136, 226, 103, 11,
+       1, 232, 11, 34, 170, 52, 20, 248, 171, 2, 129, 26, 186, 208, 233,
+       53, 180, 146, 11, 113, 10, 242, 142, 41, 58, 14, 137, 75, 27, 177,
+       94, 22, 124, 244, 238, 128, 180, 226, 236, 108, 140, 162, 133,
+       149, 250, 230, 208, 22, 33, 115, 231, 243, 44, 62, 253, 112, 171,
+       78, 175, 93, 201, 226, 232, 174, 4, 251, 47, 224, 202, 96, 80,
+       104, 172, 106, 192, 74, 171, 203, 245, 156, 33, 131, 91, 17, 10,
+       116, 138, 6, 184, 155, 250, 110, 164, 186, 218, 154, 19, 81, 83,
+       188, 223, 105, 104, 151, 123, 51, 17, 19, 92, 154, 243, 77, 20,
+       155, 234, 156, 1, 33, 187, 146, 165, 112, 243, 151, 160, 234, 143,
+       123, 147, 25, 82, 237, 75, 92, 0, 59, 239, 117, 153, 58, 124, 159,
+       247, 175, 220, 159, 229, 101, 193, 243, 130, 3, 143, 38, 185, 157,
+       151, 140, 231, 204, 92, 216, 135, 161, 40, 54, 229, 204, 35, 27,
+       229, 223, 169, 119, 253, 168, 90, 222, 195, 29, 14, 185, 220, 58,
+       135, 102, 186, 239, 145, 92, 111, 133, 31, 156, 167, 41, 174, 54,
+       193, 207, 163, 159, 133, 222, 11, 2, 181, 242, 83, 222, 219, 55,
+       12, 188, 223, 173, 65, 120, 251, 228, 153, 238, 156, 85, 16, 116,
+       74, 121, 73, 185, 185, 94, 234, 22, 126, 198, 52, 78, 177, 102,
+       201, 224, 40, 119, 155, 218, 160, 35, 201, 103, 79, 84, 211, 239,
+       244, 205, 64, 116, 194, 120, 92, 181, 229, 120, 96, 18, 239, 193,
+       185, 44, 253, 36, 42, 198, 128, 119, 154, 112, 236, 128, 68, 7,
+       223, 204, 111, 164, 79, 118, 51, 227, 82, 209, 211, 8, 111, 121,
+       78, 106, 136, 114, 244, 219, 53, 101, 162, 247, 4, 112, 88, 161,
+       162, 54, 234, 80, 235, 126, 137, 250, 64, 207, 1, 177, 67, 239,
+       203, 92, 192, 250, 169, 79, 211, 14, 39, 206, 245, 158, 220, 131,
+       253, 55, 139, 121, 132, 69, 200, 151, 187, 236, 172, 173, 132,
+       126, 83, 66, 2, 245, 227, 217, 105, 115, 79, 58, 91, 51, 216, 255,
+       225, 140, 166, 222, 0, 132, 217, 161, 168, 180, 37, 31, 155, 205,
+       107, 165, 203, 182, 50, 227, 26, 208, 243, 105, 89, 121, 158, 106,
+       178, 58, 227, 203, 83, 245, 34, 199, 45, 193, 89, 228, 162, 239,
+       95, 121, 242, 225, 212, 95, 150, 137, 94, 180, 253, 25, 31, 255,
+       191, 135, 211, 149, 214, 255, 14, 50, 226, 99, 89, 174, 251, 158,
+       213, 238, 127, 208, 151, 239, 173, 50, 66, 21, 123, 32, 6, 218,
+       163, 49, 47, 160, 67, 110, 213, 173, 161, 104, 201, 165, 13, 240,
+       163, 234, 149, 37, 112, 180, 123, 63, 183, 96, 186, 221, 181, 216,
+       75, 223, 125, 157, 159, 10, 232, 126, 133, 221, 139, 151, 149,
+       190, 43, 76, 215, 186, 85, 153, 255, 223, 78, 216, 215, 82, 78,
+       175, 148, 10, 98, 15, 134, 168, 134, 194, 226, 245, 166, 161, 110,
+       102, 245, 125, 227, 73, 197, 162, 106, 177, 38, 234, 144, 4, 115,
+       37, 121, 45, 24, 170, 248, 13, 133, 216, 80, 134, 9, 144, 11, 190,
+       223, 49, 200, 200, 177, 31, 153, 15, 35, 82, 146, 211, 221, 170,
+       56, 218, 90, 48, 18, 185, 72, 98, 234, 87, 211, 91, 112, 85, 64,
+       245, 130, 123, 79, 187, 116, 122, 168, 23, 238, 200, 178, 44, 189,
+       211, 237, 160, 129, 119, 143, 118, 232, 218, 29, 118, 140, 47, 80,
+       86, 106, 201, 196, 204, 39, 110, 249, 51, 215, 226, 226, 253, 111,
+       100, 107, 182, 205, 178, 121, 66, 27, 54, 228, 125, 79, 9, 108,
+       231, 189, 84, 164, 170, 82, 134, 128, 218, 194, 177, 139, 49, 236,
+       78, 123, 19, 221, 3, 190, 86, 238, 77, 126, 186, 128, 140, 137,
+       49, 168, 7, 168, 210, 211, 100, 137, 170, 192, 175, 145, 114, 196,
+       236, 202, 125, 214, 238, 121, 127, 93, 3, 80, 138, 241, 156, 28,
+       203, 238, 140, 171, 33, 129, 48, 0, 40, 233, 4, 143, 97, 18, 7,
+       13, 246, 2, 131, 21, 2, 100, 108, 152, 78, 8, 10, 184, 97, 149,
+       199, 253, 146, 83, 113, 136, 84, 101, 66, 88, 56, 218, 108, 164,
+       184, 148, 201, 89, 80, 117, 156, 159, 244, 107, 198, 57, 63, 209,
+       131, 14, 194, 241, 7, 56, 186, 234, 148, 5, 161, 251, 112, 221,
+       56, 126, 60, 207, 87, 180, 196, 12, 238, 8, 243, 209, 33, 112,
+       200, 242, 108, 106, 72, 171, 123, 61, 227, 239, 33, 25, 112, 139,
+       68, 42, 19, 201, 69, 137, 19, 148, 174, 230, 13, 65, 202, 199, 45,
+       14, 52, 196, 108, 195, 155, 197, 215, 152, 87, 229, 176, 100, 158,
+       194, 61, 22, 185, 220, 168, 164, 57, 235, 125, 233, 210, 200, 15,
+       41, 57, 25, 183, 221, 72, 16, 153, 27, 215, 3, 10, 38, 88, 63,
+       199, 221, 32, 125, 82, 11, 86, 234, 35, 201, 99, 74, 84, 151, 175,
+       116, 76, 72, 253, 198, 112, 204, 180, 228, 124, 168, 18, 239, 193,
+       171, 52, 253, 52, 28, 130, 136, 95, 158, 113, 252, 62, 170, 112,
+       232, 46, 153, 250, 88, 203, 0, 177, 234, 143, 219, 221, 128, 254,
+       185, 223, 91, 194, 35, 206, 209, 150, 217, 131, 255, 119, 143, 75,
+       129, 7, 201, 221, 219, 236, 72, 173, 237, 174, 19, 114, 2, 220,
+       234, 124, 107, 239, 83, 123, 75, 83, 248, 219, 224, 188, 58, 222,
+       68, 212, 58, 129, 168, 64, 32, 151, 133, 30, 10, 168, 40, 62, 161,
+       67, 64, 228, 226, 64, 207, 50, 108, 104, 156, 33, 217, 159, 92,
+       140, 34, 219, 4, 8, 32, 33, 4, 131, 56, 250, 217, 111, 253, 185,
+       67, 138, 93, 148, 23, 184, 156, 118, 47, 175, 51, 251, 149, 150,
+       109, 178, 209, 79, 25, 154, 251, 199, 12, 7, 254, 244, 67, 123,
+       108, 120, 75, 91, 120, 1, 172, 248, 169, 83, 157, 173, 16, 222,
+       156, 85, 110, 72, 163, 224, 12, 210, 233, 33, 157, 113, 171, 102,
+       99, 62, 180, 106, 250, 155, 241, 27, 75, 151, 21, 157, 187, 45,
+       207, 42, 64, 239, 155, 159, 144, 58, 11, 40, 151, 219, 197, 154,
+       251, 183, 76, 172, 82, 58, 20, 107, 77, 87, 114, 209, 114, 85,
+       238, 246, 166, 17, 61, 183, 109, 120, 156, 151, 168, 169, 186,
+       117, 140, 83, 107, 176, 131, 119, 204, 116, 254, 11, 176, 167, 93,
+       11, 151, 40, 90, 247, 249, 66, 116, 72, 222, 244, 254, 149, 125,
+       248, 144, 135, 221, 159, 213, 11, 122, 221, 206, 154, 4, 40, 53,
+       76, 51, 187, 64, 162, 106, 35, 16, 234, 172, 143, 32, 213, 247,
+       193, 126, 54, 84, 108, 250, 145, 129, 173, 64, 221, 173, 39, 244,
+       160, 227, 7, 97, 35, 159, 98, 138, 246, 179, 234, 246, 69, 64, 88,
+       231, 41, 200, 182, 164, 126, 171, 146, 213, 151, 186, 4, 253, 46,
+       77, 170, 192, 127, 143, 248, 157, 57, 201, 107, 232, 86, 87, 107,
+       248, 69, 64, 116, 130, 49, 13, 179, 32, 126, 200, 23, 238, 201,
+       178, 60, 189, 119, 201, 160, 164, 119, 187, 114, 232, 160, 224,
+       84, 153, 204, 43, 224, 207, 94, 51, 224, 18, 135, 130, 88, 201,
+       105, 142, 98, 25, 82, 126, 199, 81, 4, 0, 218, 101, 80, 88, 217,
+       136, 70, 248, 247, 238, 108, 133, 248, 216, 171, 208, 176, 235,
+       252, 223, 117, 2, 238, 241, 127, 213, 131, 67, 138, 241, 158, 216,
+       143, 186, 12, 166, 99, 155, 71, 232, 181, 254, 108, 12, 189, 136,
+       175, 17, 16, 99, 252, 254, 117, 98, 238, 81, 127, 71, 195, 75,
+       218, 241, 140, 24, 207, 174, 20, 186, 33, 169, 38, 44, 254, 243,
+       236, 107, 239, 195, 251, 182, 249, 10, 207, 107, 85, 90, 251, 239,
+       95, 163, 24, 243, 204, 232, 247, 158, 207, 37, 165, 251, 246, 130,
+       36, 36, 133, 131, 223, 107, 160, 79, 126, 163, 169, 66, 212, 178,
+       65, 106, 105, 254, 106, 154, 1, 251, 105, 90, 93, 134, 151, 100,
+       177, 122, 165, 168, 145, 7, 213, 101, 54, 2, 111, 59, 116, 162,
+       75, 66, 211, 35, 128, 99, 115, 78, 40, 46, 113, 216, 13, 14, 236,
+       174, 103, 4, 40, 242, 97, 40, 189, 83, 66, 172, 114, 18, 203, 112,
+       37, 204, 243, 231, 75, 204, 175, 208, 252, 173, 134, 230, 205,
+       179, 5, 140, 176, 229, 162, 132, 111, 175, 100, 241, 184, 5, 57,
+       42, 189, 237, 215, 111, 197, 76, 249, 17, 51, 221, 58, 0, 216, 58,
+       151, 33, 122, 163, 82, 159, 227, 221, 32, 123, 83, 78, 246, 210,
+       49, 73, 59, 238, 52, 199, 103, 117, 196, 72, 254, 2, 179, 213, 49,
+       96, 216, 186, 22, 202, 75, 187, 112, 61, 225, 237, 162, 8, 48, 11,
+       116, 234, 75, 140, 83, 94, 51, 248, 96, 39, 121, 75, 122, 112,
+       238, 50, 164, 244, 183, 191, 180, 8, 145, 184, 129, 207, 38, 254,
+       18, 194, 98, 196, 225, 45, 66, 129, 253, 195, 238, 9, 249, 172,
+       143, 177, 176, 170, 253, 127, 92, 98, 238, 213, 127, 241, 211,
+       105, 75, 229, 158, 218, 79, 254, 149, 154, 65, 173, 70, 14, 250,
+       246, 230, 42, 190, 230, 185, 138, 122, 171, 236, 235, 53, 72, 255,
+       119, 223, 39, 176, 243, 138, 238, 182, 254, 223, 139, 132, 249,
+       105, 137, 45, 165, 169, 75, 24, 127, 202, 152, 82, 121, 173, 88,
+       211, 119, 93, 176, 153, 26, 88, 56, 171, 96, 249, 31, 139, 221,
+       161, 52, 208, 195, 70, 240, 199, 115, 217, 33, 178, 46, 75, 152,
+       43, 232, 58, 236, 215, 50, 207, 58, 54, 69, 92, 126, 133, 81, 173,
+       96, 172, 152, 37, 212, 236, 243, 3, 117, 159, 18, 206, 165, 194,
+       50, 184, 83, 112, 191, 115, 247, 201, 46, 159, 234, 111, 21, 230,
+       165, 180, 212, 133, 194, 4, 39, 251, 133, 237, 100, 47, 149, 65,
+       46, 187, 119, 100, 142, 101, 55, 248, 203, 126, 76, 182, 177, 16,
+       50, 133, 46, 92, 12, 241, 252, 176, 46, 229, 191, 116, 0, 72, 224,
+       195, 57, 72, 140, 58, 122, 49, 236, 113, 23, 255, 13, 111, 16,
+       190, 183, 34, 80, 161, 58, 73, 24, 18, 45, 178, 87, 203, 191, 16,
+       73, 192, 0, 231, 34, 123, 120, 120, 236, 46, 149, 91, 120, 193,
+       204, 181, 175, 59, 223, 183, 52, 190, 185, 221, 239, 205, 39, 188,
+       221, 210, 249, 161, 187, 119, 166, 70, 113, 5, 225, 131, 145, 206,
+       7, 110, 220, 118, 179, 64, 66, 213, 210, 105, 44, 121, 72, 106,
+       254, 71, 82, 159, 82, 77, 6, 223, 44, 184, 115, 161, 172, 207,
+       184, 185, 243, 235, 140, 189, 151, 170, 27, 18, 116, 188, 159, 72,
+       235, 167, 59, 191, 17, 211, 92, 154, 241, 77, 217, 126, 234, 136,
+       80, 129, 187, 36, 169, 156, 254, 77, 197, 177, 232, 134, 149, 164,
+       11, 96, 245, 104, 18, 201, 250, 99, 80, 2, 107, 218, 49, 89, 130,
+       199, 123, 209, 42, 100, 234, 111, 123, 224, 144, 239, 21, 188,
+       221, 27, 254, 20, 175, 8, 222, 215, 191, 191, 73, 151, 215, 199,
+       83, 174, 240, 30, 91, 223, 175, 31, 253, 251, 221, 56, 150, 22,
+       124, 189, 179, 84, 39, 209, 143, 249, 59, 42, 121, 36, 129, 217,
+       178, 133, 32, 124, 170, 66, 143, 227, 247, 84, 27, 210, 108, 204,
+       3, 123, 241, 104, 226, 62, 149, 91, 248, 71, 100, 149, 175, 123,
+       221, 222, 32, 62, 145, 221, 255, 207, 35, 253, 189, 250, 205, 161,
+       252, 47, 142, 94, 121, 56, 137, 42, 232, 148, 199, 79, 117, 196,
+       132, 220, 2, 51, 209, 50, 96, 120, 170, 19, 248, 88, 171, 48, 188,
+       251, 205, 167, 73, 51, 138, 244, 234, 135, 97, 209, 138, 206, 47,
+       238, 204, 95, 240, 248, 198, 172, 226, 121, 140, 59, 203, 34, 223,
+       67, 113, 31, 242, 156, 16, 15, 44, 220, 123, 105, 140, 4, 128,
+       191, 253, 29, 198, 161, 233, 214, 149, 230, 2, 112, 247, 40, 99,
+       121, 126, 34, 184, 34, 249, 187, 93, 93, 130, 199, 69, 241, 40,
+       100, 162, 53, 73, 107, 238, 84, 198, 111, 112, 101, 200, 255, 66,
+       115, 215, 176, 96, 120, 168, 22, 238, 201, 147, 52, 172, 241, 172,
+       162, 0, 57, 186, 112, 240, 190, 224, 170, 186, 143, 241, 152, 200,
+       147, 87, 149, 187, 13, 223, 107, 11, 239, 217, 255, 211, 14, 71,
+       138, 177, 211, 209, 219, 255, 181, 93, 63, 211, 233, 148, 45, 127,
+       44, 44, 205, 190, 80, 95, 119, 84, 243, 29, 158, 41, 221, 6, 53,
+       47, 235, 100, 121, 63, 71, 251, 240, 148, 89, 200, 212, 121, 87,
+       163, 168, 130, 220, 148, 170, 201, 42, 233, 153, 207, 192, 202,
+       222, 0, 254, 141, 91, 253, 151, 3, 156, 210, 56, 28, 143, 252,
+       141, 6, 187, 212, 15, 137, 230, 95, 227, 22, 189, 183, 56, 87, 71,
+       145, 253, 125, 190, 239, 7, 95, 177, 79, 240, 216, 63, 225, 111,
+       127, 94, 194, 134, 212, 161, 252, 21, 132, 167, 213, 21, 78, 97,
+       170, 246, 128, 230, 2, 112, 241, 32, 103, 113, 116, 42, 184, 33,
+       249, 59, 95, 109, 46, 215, 4, 163, 104, 116, 40, 143, 22, 103,
+       151, 36, 50, 105, 48, 188, 210, 87, 215, 217, 108, 146, 239, 71,
+       36, 63, 175, 177, 212, 117, 206, 132, 58, 251, 128, 174, 237, 144,
+       245, 83, 51, 140, 133, 139, 124, 188, 7, 170, 253, 11, 135, 172,
+       174, 71, 202, 164, 103, 249, 149, 20, 73, 183, 192, 157, 54, 223,
+       179, 136, 118, 141, 95, 226, 193, 61, 216, 236, 205, 244, 237,
+       239, 25, 113, 26, 118, 216, 124, 49, 171, 131, 119, 9, 86, 106,
+       74, 213, 95, 24, 116, 111, 81, 8, 213, 167, 170, 98, 102, 205,
+       109, 115, 240, 78, 199, 191, 246, 50, 72, 137, 214, 207, 72, 156,
+       235, 136, 2, 239, 195, 213, 70, 114, 145, 155, 87, 140, 124, 174,
+       111, 184, 180, 86, 203, 212, 144, 171, 203, 245, 164, 43, 104,
+       252, 70, 255, 197, 247, 251, 145, 151, 107, 254, 241, 27, 115, 95,
+       127, 211, 36, 45, 94, 43, 174, 226, 88, 199, 176, 188, 71, 219, 7,
+       116, 191, 40, 168, 246, 141, 235, 171, 130, 133, 150, 126, 166,
+       243, 30, 94, 222, 235, 215, 68, 255, 206, 198, 255, 249, 162, 234,
+       97, 191, 239, 138, 222, 28, 175, 156, 236, 255, 34, 167, 83, 223,
+       119, 215, 99, 174, 114, 56, 5, 47, 189, 213, 122, 143, 241, 134,
+       167, 126, 233, 172, 35, 222, 235, 95, 178, 152, 242, 205, 251,
+       116, 193, 223, 59, 31, 163, 252, 199, 10, 218, 170, 220, 207, 183,
+       148, 248, 233, 129, 131, 129, 248, 30, 223, 148, 156, 105, 95, 65,
+       241, 87, 104, 248, 62, 231, 254, 171, 18, 133, 247, 106, 222, 225,
+       54, 60, 94, 43, 93, 68, 169, 143, 139, 190, 149, 179, 169, 189,
+       184, 183, 238, 31, 26, 245, 172, 236, 192, 162, 135, 51, 236, 17,
+       166, 108, 11, 247, 140, 86, 126, 195, 20, 68, 5, 29, 1, 149, 17,
+       205, 176, 150, 44, 55, 36, 65, 94, 228, 180, 39, 128, 100, 102,
+       26, 14, 12, 211, 152, 81, 31, 172, 188, 50, 194, 28, 128, 161,
+       189, 194, 149, 119, 205, 62, 196, 248, 55, 173, 64, 154, 230, 188,
+       31, 180, 98, 230, 53, 127, 173, 193, 9, 21, 223, 181, 56, 138,
+       130, 29, 128, 33, 57, 91, 50, 231, 133, 75, 102, 185, 91, 130,
+       254, 150, 230, 92, 55, 151, 175, 39, 53, 255, 173, 129, 213, 183,
+       200, 85, 43, 251, 150, 175, 100, 37, 243, 35, 128, 165, 95, 45,
+       116, 192, 174, 95, 91, 66, 64, 240, 56, 189, 238, 201, 66, 50,
+       137, 147, 248, 119, 241, 13, 62, 218, 2, 150, 76, 112, 44, 91,
+       140, 173, 181, 155, 234, 88, 39, 51, 247, 194, 155, 239, 62, 22,
+       107, 227, 247, 125, 133, 60, 220, 197, 175, 217, 255, 219, 211,
+       164, 4, 135, 78, 223, 85, 250, 164, 170, 48, 29, 217, 169, 214,
+       12, 165, 93, 239, 251, 91, 183, 117, 253, 239, 196, 67, 190, 200,
+       243, 89, 239, 173, 166, 246, 37, 115, 14, 186, 164, 146, 233, 213,
+       185, 253, 155, 223, 20, 53, 236, 255, 78, 143, 133, 123, 255, 21,
+       150, 75, 186, 241, 79, 83, 223, 239, 130, 36, 31, 255, 17, 143,
+       75, 175, 22, 138, 111, 228, 116, 128, 203, 199, 115, 99, 184, 64,
+       114, 238, 12, 238, 121, 185, 13, 63, 240, 166, 163, 0, 37, 242,
+       161, 40, 25, 197, 71, 47, 20, 6, 103, 61, 100, 128, 234, 70, 115,
+       97, 56, 113, 112, 228, 40, 238, 201, 177, 29, 45, 240, 168, 231,
+       0, 41, 178, 224, 40, 166, 146, 212, 221, 123, 195, 144, 232, 159,
+       191, 176, 171, 96, 254, 46, 27, 219, 125, 227, 48, 38, 231, 74,
+       221, 10, 150, 69, 255, 209, 44, 68, 135, 33, 180, 121, 121, 125,
+       221, 225, 123, 87, 57, 124, 26, 178, 217, 44, 181, 217, 138, 2, 8,
+       251, 122, 114, 151, 23, 223, 145, 110, 91, 8, 218, 170, 18, 219,
+       14, 187, 174, 155, 158, 229, 140, 92, 155, 167, 239, 104, 58, 65,
+       238, 35, 239, 71, 94, 169, 15, 253, 232, 195, 111, 215, 60, 14,
+       189, 91, 18, 172, 16, 140, 92, 175, 80, 238, 95, 33, 200, 90, 38,
+       152, 52, 64, 249, 139, 14, 17, 46, 62, 73, 223, 157, 22, 155, 126,
+       16, 8, 16, 14, 15, 150, 254, 83, 165, 62, 253, 155, 255, 95, 55,
+       48, 220, 126, 190, 111, 183, 83, 253, 188, 182, 224, 43, 192, 79,
+       91, 127, 199, 198, 244, 237, 119, 191, 70, 69, 141, 84, 18, 202,
+       56, 81, 226, 211, 199, 211, 8, 155, 239, 120, 204, 23, 175, 237,
+       246, 77, 140, 4, 106, 225, 132, 127, 191, 120, 84, 181, 78, 105,
+       173, 78, 71, 79, 120, 84, 74, 241, 118, 83, 109, 177, 97, 120,
+       160, 22, 239, 233, 38, 109, 27, 116, 42, 227, 156, 53, 187, 112,
+       97, 122, 178, 226, 16, 123, 245, 25, 87, 139, 93, 156, 191, 40,
+       156, 230, 182, 133, 187, 221, 149, 159, 11, 246, 193, 91, 85, 16,
+       251, 135, 140, 30, 95, 14, 115, 232, 251, 239, 209, 252, 220, 159,
+       93, 84, 231, 141, 206, 255, 9, 191, 73, 151, 215, 135, 86, 62,
+       240, 78, 81, 255, 239, 183, 215, 175, 215, 237, 165, 56, 68, 221,
+       55, 223, 235, 193, 162, 172, 10, 88, 126, 103, 50, 221, 208, 82,
+       46, 252, 35, 184, 142, 123, 223, 69, 62, 83, 250, 106, 142, 1,
+       140, 95, 255, 86, 234, 234, 198, 60, 1, 114, 146, 245, 227, 184,
+       100, 114, 47, 58, 152, 33, 184, 5, 127, 252, 174, 186, 64, 181,
+       152, 161, 168, 208, 132, 190, 180, 31, 98, 149, 43, 87, 182, 146,
+       26, 203, 249, 116, 67, 249, 213, 109, 161, 56, 111, 139, 139, 185,
+       246, 223, 31, 165, 104, 53, 42, 138, 184, 186, 88, 127, 245, 177,
+       71, 222, 95, 148, 191, 172, 156, 118, 46, 239, 59, 219, 17, 182,
+       111, 182, 211, 95, 21, 26, 251, 223, 12, 191, 223, 35, 174, 98, 8,
+       247, 179, 186, 231, 75, 69, 124, 175, 40, 168, 182, 132, 255, 171,
+       147, 149, 150, 186, 36, 255, 62, 30, 154, 235, 223, 142, 251, 223,
+       210, 164, 189, 181, 31, 98, 93, 47, 59, 183, 138, 27, 255, 59, 80,
+       67, 163, 215, 125, 161, 56, 203, 219, 202, 249, 242, 223, 63, 165,
+       96, 183, 74, 151, 121, 241, 67, 230, 63, 111, 208, 121, 250, 51,
+       94, 27, 60, 213, 191, 39, 207, 86, 254, 177, 240, 189, 226, 55,
+       88, 36, 166, 239, 247, 195, 229, 41, 50, 248, 108, 109, 95, 217,
+       89, 75, 236, 117, 108, 30, 157, 246, 182, 134, 13, 150, 12, 133,
+       99, 179, 201, 83, 217, 33, 189, 95, 164, 79, 253, 95, 76, 6, 182,
+       41, 246, 152, 34, 172, 210, 131, 21, 205, 74, 54, 203, 197, 37,
+       249, 183, 173, 197, 211, 204, 138, 115, 218, 211, 14, 36, 57, 86,
+       131, 9, 87, 155, 246, 162, 233, 196, 62, 1, 82, 194, 252, 202, 57,
+       232, 118, 171, 59, 221, 3, 152, 19, 247, 148, 58, 154, 0, 12, 139,
+       33, 168, 2, 162, 174, 188, 60, 134, 153, 63, 158, 189, 16, 213,
+       229, 239, 114, 3, 151, 101, 125, 141, 160, 201, 139, 29, 201, 35,
+       255, 252, 20, 36, 21, 121, 17, 141, 15, 111, 148, 135, 103, 245,
+       116, 0, 235, 70, 115, 242, 56, 96, 120, 238, 10, 234, 89, 187, 29,
+       63, 249, 174, 167, 68, 57, 42, 240, 32, 2, 217, 31, 253, 102, 198,
+       233, 246, 140, 80, 82, 194, 181, 31, 176, 97, 106, 49, 55, 232,
+       65, 184, 18, 221, 85, 162, 250, 132, 61, 152, 33, 184, 88, 63, 90,
+       36, 178, 168, 54, 231, 161, 140, 174, 173, 47, 179, 35, 16, 166,
+       239, 205, 226, 84, 139, 128, 110, 250, 229, 36, 171, 106, 214,
+       171, 11, 157, 20, 253, 114, 199, 102, 255, 89, 80, 87, 13, 18, 89,
+       125, 120, 105, 51, 82, 17, 170, 177, 228, 187, 130, 115, 235, 231,
+       12, 167, 243, 245, 242, 70, 64, 215, 188, 40, 42, 108, 140, 63,
+       178, 34, 249, 207, 139, 105, 219, 163, 69, 125, 54, 4, 69, 139,
+       80, 146, 242, 95, 190, 144, 241, 1, 9, 90, 150, 62, 186, 43, 244,
+       16, 170, 141, 93, 151, 51, 108, 254, 46, 203, 231, 83, 253, 33,
+       190, 73, 43, 245, 219, 243, 218, 223, 146, 5, 173, 87, 14, 8, 244,
+       211, 233, 240, 188, 135, 191, 23, 86, 17, 140, 63, 70, 111, 231,
+       91, 191, 144, 54, 216, 99, 224, 143, 219, 222, 195, 150, 84, 173,
+       207, 74, 18, 240, 88, 37, 254, 89, 17, 127, 79, 119, 181, 203,
+       159, 182, 92, 183, 172, 189, 140, 173, 212, 55, 208, 195, 251,
+       112, 195, 126, 132, 76, 87, 29, 249, 104, 161, 116, 156, 123, 208,
+       99, 224, 246, 166, 155, 31, 210, 98, 110, 252, 158, 222, 205, 178,
+       236, 164, 222, 233, 163, 228, 39, 175, 126, 241, 45, 201, 252,
+       205, 230, 154, 255, 241, 237, 81, 247, 162, 157, 31, 178, 118,
+       110, 240, 223, 206, 192, 185, 100, 225, 246, 121, 98, 129, 119,
+       190, 227, 225, 53, 141, 27, 206, 148, 231, 99, 235, 86, 129, 239,
+       2, 115, 241, 32, 96, 121, 250, 2, 56, 27, 187, 24, 63, 249, 174,
+       135, 64, 185, 75, 240, 160, 212, 141, 158, 188, 141, 108, 7, 235,
+       158, 158, 138, 26, 230, 241, 105, 79, 249, 214, 108, 35, 120, 103,
+       139, 2, 249, 166, 79, 31, 144, 120, 181, 34, 190, 3, 100, 193,
+       198, 35, 185, 88, 20, 52, 149, 215, 73, 105, 191, 9, 126, 133, 23,
+       191, 168, 51, 13, 216, 86, 72, 235, 164, 255, 239, 112, 208, 74,
+       18, 250, 88, 113, 254, 89, 18, 127, 93, 118, 52, 14, 143, 166,
+       252, 199, 29, 175, 24, 166, 221, 49, 192, 87, 255, 18, 211, 146,
+       132, 109, 127, 61, 133, 104, 234, 228, 19, 79, 184, 69, 66, 61,
+       138, 83, 109, 186, 32, 89, 200, 21, 238, 200, 34, 125, 189, 106,
+       205, 165, 60, 119, 255, 208, 224, 35, 170, 226, 84, 97, 24, 184,
+       96, 121, 135, 116, 173, 40, 232, 247, 188, 223, 109, 179, 140,
+       132, 254, 166, 225, 14, 126, 208, 235, 207, 164, 106, 141, 212,
+       253, 151, 82, 186, 232, 54, 236, 253, 154, 43, 112, 92, 243, 105,
+       83, 179, 115, 125, 115, 115, 69, 154, 106, 185, 182, 111, 142,
+       136, 115, 161, 35, 49, 72, 234, 63, 6, 32, 163, 74, 116, 70, 240,
+       7, 179, 200, 51, 72, 122, 233, 6, 207, 142, 182, 7, 59, 192, 173,
+       50, 8, 125, 123, 115, 138, 15, 114, 105, 65, 32, 94, 249, 16, 47,
+       236, 86, 229, 153, 28, 215, 252, 150, 29, 181, 220, 135, 144, 229,
+       192, 70, 89, 169, 132, 14, 182, 84, 117, 15, 155, 127, 227, 230,
+       156, 255, 177, 201, 76, 62, 166, 157, 159, 246, 102, 110, 245,
+       183, 207, 209, 168, 46, 244, 238, 185, 171, 200, 55, 175, 229,
+       241, 189, 81, 108, 238, 180, 23, 95, 184, 81, 232, 157, 174, 123,
+       109, 191, 49, 92, 192, 149, 238, 201, 98, 45, 168, 99, 201, 229,
+       156, 55, 255, 240, 113, 18, 79, 106, 156, 86, 210, 190, 102, 188,
+       132, 94, 131, 32, 170, 55, 64, 250, 171, 3, 197, 68, 185, 4, 239,
+       50, 37, 138, 131, 37, 12, 125, 206, 3, 27, 86, 159, 98, 178, 56,
+       55, 173, 65, 91, 231, 172, 34, 162, 204, 102, 35, 191, 133, 149,
+       153, 7, 236, 4, 54, 250, 130, 158, 196, 169, 157, 189, 251, 74,
+       170, 118, 131, 254, 244, 20, 72, 117, 231, 49, 207, 178, 0, 126,
+       169, 23, 231, 236, 158, 12, 63, 114, 205, 172, 193, 125, 154, 122,
+       211, 24, 156, 122, 245, 114, 234, 115, 230, 53, 135, 126, 162, 47,
+       51, 162, 84, 63, 251, 134, 144, 48, 184, 0, 239, 104, 231, 52, 67,
+       231, 138, 37, 171, 82, 132, 150, 197, 179, 50, 120, 3, 175, 167,
+       142, 176, 140, 54, 166, 102, 167, 55, 253, 144, 20, 137, 33, 206,
+       138, 246, 30, 83, 166, 196, 173, 14, 52, 109, 155, 235, 212, 227,
+       231, 201, 86, 129, 235, 2, 113, 241, 40, 0, 121, 234, 3, 152, 26,
+       178, 88, 63, 253, 164, 135, 64, 241, 91, 244, 162, 88, 16, 126,
+       238, 2, 218, 49, 97, 229, 6, 231, 162, 127, 222, 170, 96, 54, 181,
+       238, 32, 68, 149, 37, 77, 208, 163, 114, 3, 97, 138, 45, 11, 75,
+       146, 121, 164, 62, 86, 155, 56, 9, 109, 31, 239, 253, 28, 158,
+       160, 182, 21, 221, 45, 149, 1, 53, 205, 194, 95, 42, 210, 14, 134,
+       5, 117, 75, 19, 121, 230, 114, 86, 59, 57, 9, 236, 21, 237, 189,
+       63, 150, 49, 150, 53, 149, 172, 193, 8, 224, 205, 102, 253, 170,
+       184, 62, 166, 7, 249, 51, 243, 107, 229, 118, 18, 111, 117, 97,
+       236, 95, 230, 113, 73, 156, 48, 126, 200, 23, 238, 217, 178, 45,
+       237, 118, 205, 165, 128, 47, 182, 242, 241, 110, 61, 250, 224,
+       241, 125, 115, 86, 171, 173, 60, 8, 142, 183, 71, 190, 133, 127,
+       245, 16, 2, 67, 176, 130, 203, 221, 157, 191, 130, 125, 70, 187,
+       218, 97, 86, 180, 171, 11, 92, 101, 173, 242, 130, 179, 207, 195,
+       32, 219, 162, 229, 253, 102, 100, 69, 3, 200, 178, 211, 79, 29,
+       54, 180, 169, 2, 0, 144, 19, 181, 112, 172, 169, 55, 188, 9, 91,
+       116, 189, 179, 32, 64, 166, 59, 51, 1, 147, 152, 16, 79, 5, 182,
+       58, 192, 8, 0, 1, 185, 2, 180, 191, 208, 242, 228, 184, 231, 187,
+       91, 122, 117, 188, 254, 108, 27, 167, 27, 55, 17, 179, 216, 146,
+       226, 13, 22, 126, 202, 136, 64, 135, 187, 2, 164, 40, 169, 148,
+       165, 185, 11, 30, 5, 72, 19, 181, 15, 50, 64, 217, 11, 19, 149,
+       18, 136, 83, 215, 205, 132, 154, 76, 148, 72, 181, 202, 60, 105,
+       110, 102, 85, 87, 71, 252, 65, 164, 252, 10, 83, 217, 55, 49, 120,
+       252, 23, 234, 72, 179, 56, 44, 115, 201, 165, 53, 115, 187, 118,
+       234, 88, 8, 159, 165, 56, 14, 31, 59, 172, 170, 130, 129, 255,
+       103, 1, 66, 166, 245, 125, 37, 41, 201, 193, 142, 233, 231, 111,
+       144, 160, 160, 1, 57, 241, 204, 75, 213, 118, 219, 70, 61, 222,
+       104, 86, 10, 118, 152, 179, 97, 178, 44, 30, 111, 229, 189, 44,
+       191, 246, 11, 161, 181, 60, 184, 88, 13, 96, 196, 8, 255, 124,
+       233, 69, 141, 27, 49, 109, 9, 246, 199, 106, 80, 209, 10, 3, 12,
+       74, 16, 202, 177, 103, 189, 148, 57, 48, 218, 220, 170, 131, 93,
+       181, 149, 139, 86, 173, 183, 200, 234, 18, 70, 60, 62, 149, 231,
+       164, 119, 60, 197, 229, 216, 55, 232, 37, 26, 239, 130, 24, 116,
+       177, 125, 211, 66, 111, 140, 46, 82, 75, 56, 225, 68, 214, 135,
+       105, 79, 190, 83, 114, 196, 61, 238, 204, 7, 39, 205, 82, 42, 234,
+       141, 55, 164, 116, 84, 88, 6, 123, 232, 166, 96, 188, 75, 12, 7,
+       95, 178, 93, 79, 168, 200, 118, 145, 191, 161, 16, 132, 39, 193,
+       214, 167, 186, 201, 180, 194, 173, 35, 38, 242, 115, 106, 242,
+       227, 27, 216, 191, 93, 113, 225, 28, 215, 173, 116, 183, 25, 23,
+       112, 179, 3, 42, 247, 42, 212, 35, 238, 144, 131, 39, 245, 111,
+       90, 114, 224, 119, 63, 250, 80, 137, 202, 54, 239, 221, 29, 183,
+       46, 174, 177, 215, 49, 164, 39, 32, 206, 83, 95, 58, 171, 231,
+       191, 87, 247, 135, 22, 253, 21, 226, 47, 189, 151, 63, 255, 18,
+       253, 220, 62, 198, 63, 167, 87, 119, 149, 177, 220, 167, 98, 12,
+       18, 125, 198, 141, 240, 135, 253, 130, 4, 214, 147, 228, 170, 168,
+       7, 60, 179, 107, 80, 148, 35, 84, 27, 163, 47, 50, 25, 48, 248, 1,
+       66, 12, 62, 94, 64, 204, 200, 131, 136, 59, 83, 33, 236, 122, 199,
+       155, 88, 5, 200, 217, 230, 124, 93, 181, 32, 254, 57, 23, 239,
+       201, 147, 113, 220, 113, 12, 171, 140, 29, 190, 49, 241, 45, 32,
+       181, 232, 77, 69, 73, 73, 202, 145, 33, 8, 217, 255, 89, 186, 152,
+       25, 19, 24, 19, 66, 250, 145, 79, 201, 201, 124, 146, 42, 83, 162,
+       62, 61, 187, 96, 245, 249, 123, 86, 43, 237, 60, 41, 14, 191, 67,
+       30, 163, 126, 213, 16, 18, 91, 176, 160, 255, 221, 21, 251, 194,
+       221, 214, 251, 3, 115, 234, 141, 102, 51, 188, 220, 95, 109, 84,
+       231, 40, 236, 247, 8, 254, 221, 183, 229, 135, 50, 190, 209, 22,
+       25, 235, 175, 255, 253, 127, 221, 156, 52, 58, 232, 36, 100, 95,
+       123, 19, 206, 60, 53, 31, 223, 107, 112, 247, 153, 21, 169, 172,
+       7, 48, 154, 251, 205, 175, 173, 52, 224, 37, 115, 212, 20, 58,
+       236, 44, 92, 95, 216, 142, 206, 148, 5, 159, 223, 123, 96, 215,
+       81, 29, 107, 170, 5, 58, 154, 251, 221, 47, 189, 52, 233, 37, 115,
+       229, 253, 85, 81, 236, 95, 100, 183, 89, 242, 38, 72, 18, 50, 197,
+       255, 131, 116, 50, 90, 81, 90, 240, 160, 47, 154, 85, 116, 10,
+       248, 202, 188, 45, 219, 107, 75, 118, 146, 251, 216, 100, 96, 127,
+       230, 121, 157, 191, 96, 126, 156, 23, 254, 195, 179, 45, 221, 126,
+       13, 163, 196, 127, 138, 114, 249, 249, 187, 101, 109, 236, 2, 79,
+       184, 82, 250, 176, 238, 19, 1, 144, 115, 78, 196, 124, 239, 249,
+       110, 237, 31, 180, 170, 229, 244, 61, 168, 210, 49, 88, 40, 230,
+       49, 5, 219, 96, 7, 109, 229, 102, 133, 171, 12, 22, 255, 32, 172,
+       234, 24, 76, 252, 181, 64, 199, 251, 82, 1, 227, 4, 79, 206, 97,
+       220, 15, 220, 117, 223, 66, 51, 141, 72, 118, 76, 166, 133, 180,
+       245, 192, 32, 14, 78, 201, 189, 48, 189, 39, 184, 0, 82, 26, 168,
+       88, 61, 24, 26, 54, 255, 33, 146, 48, 54, 245, 30, 70, 33, 175,
+       187, 163, 207, 224, 62, 173, 130, 108, 221, 35, 168, 195, 243, 90,
+       131, 178, 212, 45, 79, 120, 31, 208, 174, 62, 233, 18, 140, 78, 0,
+       200, 106, 175, 216, 193, 100, 210, 250, 142, 67, 142, 42, 203,
+       187, 176, 244, 16, 59, 22, 159, 21, 15, 61, 91, 107, 239, 54, 114,
+       123, 80, 101, 72, 255, 230, 59, 31, 183, 116, 126, 188, 149, 255,
+       139, 178, 45, 168, 210, 237, 162, 128, 127, 191, 116, 117, 131, 6,
+       151, 215, 226, 172, 184, 7, 184, 27, 123, 112, 188, 187, 172, 123,
+       167, 63, 55, 17, 48, 220, 0, 98, 12, 58, 122, 130, 128, 64, 163,
+       169, 189, 70, 76, 237, 78, 30, 94, 120, 81, 226, 245, 223, 83, 75,
+       27, 89, 126, 204, 85, 238, 237, 246, 93, 14, 242, 235, 225, 21,
+       127, 187, 122, 144, 216, 98, 62, 224, 40, 219, 120, 20, 173, 45,
+       183, 153, 143, 143, 18, 10, 134, 49, 205, 17, 20, 45, 3, 132, 195,
+       209, 122, 209, 66, 133, 15, 11, 24, 99, 58, 101, 32, 216, 249, 16,
+       40, 132, 173, 137, 191, 79, 19, 24, 166, 177, 221, 201, 136, 132,
+       240, 8, 195, 241, 10, 1, 100, 130, 15, 240, 131, 125, 108, 91,
+       212, 166, 253, 183, 121, 82, 69, 20, 177, 28, 62, 105, 5, 110, 19,
+       159, 245, 212, 60, 239, 103, 59, 218, 64, 12, 209, 249, 214, 139,
+       251, 121, 229, 96, 28, 125, 57, 169, 220, 52, 228, 189, 159, 215,
+       115, 134, 153, 149, 237, 193, 24, 180, 201, 230, 217, 174, 172,
+       30, 166, 7, 249, 168, 52, 121, 236, 242, 103, 89, 127, 16, 239,
+       124, 62, 28, 63, 194, 48, 159, 155, 23, 168, 177, 18, 48, 78, 123,
+       143, 177, 173, 177, 224, 164, 251, 184, 169, 124, 96, 123, 219,
+       51, 96, 235, 116, 164, 41, 46, 25, 70, 22, 170, 185, 195, 66, 54,
+       43, 0, 253, 91, 209, 1, 127, 115, 141, 78, 203, 157, 218, 248,
+       252, 60, 93, 255, 248, 152, 204, 52, 46, 255, 255, 127, 33, 191,
+       241, 151, 227, 231, 37, 58, 239, 235, 217, 239, 189, 60, 186, 77,
+       243, 78, 213, 240, 227, 245, 124, 127, 167, 169, 71, 188, 11, 142,
+       63, 30, 230, 239, 147, 159, 129, 246, 42, 112, 232, 255, 223, 158,
+       115, 150, 252, 237, 126, 34, 139, 29, 137, 254, 129, 153, 75, 142,
+       21, 249, 226, 164, 142, 36, 0, 206, 27, 7, 81, 22, 42, 98, 117,
+       172, 20, 42, 251, 212, 11, 135, 229, 13, 123, 127, 225, 102, 156,
+       125, 144, 237, 92, 126, 228, 191, 95, 215, 59, 38, 153, 151, 127,
+       195, 180, 38, 192, 230, 217, 39, 128, 110, 183, 67, 241, 188, 52,
+       184, 228, 124, 102, 89, 123, 16, 238, 156, 63, 29, 127, 115, 41,
+       159, 157, 21, 169, 185, 71, 48, 142, 211, 207, 249, 189, 52, 224,
+       38, 115, 30, 148, 250, 178, 183, 124, 249, 227, 121, 87, 181, 147,
+       111, 126, 30, 45, 255, 147, 151, 177, 60, 235, 56, 206, 219, 223,
+       222, 67, 231, 108, 239, 246, 58, 185, 118, 220, 107, 209, 52, 103,
+       173, 85, 172, 59, 44, 190, 38, 151, 172, 179, 219, 129, 86, 75,
+       50, 197, 19, 87, 218, 27, 3, 4, 175, 95, 9, 216, 124, 228, 36, 86,
+       219, 57, 90, 204, 52, 167, 127, 221, 246, 32, 150, 49, 181, 239,
+       197, 100, 54, 157, 235, 219, 173, 181, 125, 168, 79, 115, 97, 203,
+       108, 12, 250, 5, 207, 191, 82, 60, 176, 237, 49, 8, 150, 81, 78,
+       199, 100, 237, 206, 106, 231, 61, 124, 41, 37, 188, 117, 160, 194,
+       205, 43, 44, 227, 92, 93, 245, 226, 194, 223, 66, 124, 10, 40,
+       216, 183, 172, 217, 170, 146, 139, 135, 62, 118, 251, 23, 92, 144,
+       43, 87, 93, 124, 236, 23, 87, 107, 173, 54, 18, 238, 248, 52, 192,
+       218, 230, 81, 78, 189, 224, 126, 236, 31, 239, 205, 145, 37, 142,
+       178, 109, 171, 128, 45, 179, 121, 241, 106, 180, 62, 208, 57, 252,
+       89, 115, 169, 93, 188, 29, 46, 159, 102, 151, 134, 187, 213, 1,
+       150, 201, 178, 197, 219, 219, 82, 123, 2, 4, 207, 95, 41, 156,
+       174, 85, 180, 222, 227, 167, 86, 227, 86, 18, 243, 57, 182, 96,
+       89, 110, 58, 29, 61, 252, 117, 63, 110, 191, 181, 68, 221, 136,
+       216, 26, 54, 41, 202, 156, 204, 171, 230, 203, 63, 130, 232, 11,
+       98, 232, 117, 88, 249, 235, 35, 131, 74, 118, 202, 251, 21, 46,
+       207, 45, 117, 123, 234, 130, 106, 145, 252, 228, 119, 214, 89, 62,
+       203, 205, 60, 165, 253, 255, 214, 48, 134, 181, 181, 145, 135,
+       104, 246, 221, 107, 221, 173, 195, 63, 132, 78, 127, 122, 144,
+       252, 228, 53, 214, 217, 63, 219, 237, 60, 175, 175, 63, 22, 148,
+       151, 19, 181, 5, 158, 104, 178, 221, 203, 223, 159, 187, 134, 132,
+       207, 91, 55, 45, 88, 73, 218, 251, 66, 202, 3, 160, 172, 170, 3,
+       19, 199, 52, 120, 152, 70, 248, 31, 10, 101, 28, 62, 140, 133,
+       119, 187, 170, 74, 132, 58, 177, 126, 112, 45, 213, 217, 55, 237,
+       237, 188, 29, 174, 191, 6, 148, 142, 179, 221, 0, 220, 43, 114,
+       213, 203, 223, 80, 187, 67, 4, 206, 127, 38, 123, 212, 79, 42, 41,
+       151, 152, 14, 4, 109, 237, 230, 99, 143, 12, 30, 66, 227, 70, 2,
+       32, 91, 57, 100, 148, 2, 26, 93, 219, 67, 152, 235, 27, 240, 92,
+       247, 156, 248, 23, 203, 200, 118, 238, 40, 140, 183, 247, 102,
+       181, 182, 28, 197, 124, 166, 200, 54, 121, 36, 138, 79, 172, 72,
+       253, 88, 152, 157, 244, 41, 236, 81, 51, 169, 61, 162, 25, 191,
+       183, 64, 91, 134, 183, 253, 0, 24, 73, 211, 1, 211, 241, 112, 59,
+       2, 0, 7, 91, 205, 111, 40, 67, 156, 152, 162, 144, 194, 168, 159,
+       70, 243, 192, 209, 226, 96, 110, 104, 91, 226, 37, 173, 42, 108,
+       33, 39, 121, 45, 27, 121, 32, 11, 30, 242, 153, 119, 243, 185,
+       210, 31, 202, 94, 231, 172, 158, 183, 228, 103, 57, 151, 149, 165,
+       156, 36, 254, 70, 124, 186, 194, 158, 205, 53, 221, 6, 159, 106,
+       193, 247, 247, 186, 83, 29, 109, 95, 247, 12, 174, 182, 196, 230,
+       63, 151, 145, 151, 153, 36, 222, 122, 117, 170, 199, 151, 77, 189,
+       215, 205, 54, 147, 115, 180, 46, 233, 17, 120, 235, 51, 220, 219,
+       97, 220, 27, 53, 142, 76, 60, 177, 244, 173, 70, 206, 154, 117,
+       68, 200, 194, 195, 145, 213, 253, 120, 96, 182, 157, 215, 254,
+       107, 248, 60, 124, 158, 24, 202, 32, 183, 78, 76, 126, 215, 105,
+       185, 54, 186, 217, 37, 126, 206, 155, 195, 37, 135, 92, 174, 23,
+       224, 247, 189, 182, 252, 83, 70, 149, 116, 126, 31, 43, 135, 115,
+       179, 143, 245, 212, 62, 119, 103, 27, 222, 0, 140, 213, 171, 247,
+       167, 220, 175, 27, 194, 119, 63, 254, 180, 82, 70, 21, 80, 246,
+       175, 63, 141, 67, 178, 238, 229, 212, 58, 247, 111, 11, 221, 7,
+       137, 117, 170, 255, 148, 223, 60, 170, 178, 231, 23, 156, 14, 118,
+       157, 189, 255, 87, 43, 64, 151, 83, 157, 99, 227, 129, 121, 63,
+       227, 129, 36, 147, 60, 211, 141, 83, 179, 193, 97, 137, 215, 209,
+       206, 237, 93, 65, 84, 2, 40, 24, 190, 165, 120, 138, 18, 237, 247,
+       186, 117, 253, 46, 8, 158, 66, 127, 12, 248, 204, 91, 144, 252,
+       240, 55, 214, 217, 63, 27, 125, 52, 191, 110, 189, 62, 172, 183,
+       23, 181, 21, 150, 105, 54, 213, 203, 95, 88, 251, 199, 132, 79,
+       95, 62, 201, 228, 243, 213, 146, 78, 164, 89, 20, 182, 2, 107, 43,
+       54, 245, 122, 195, 149, 218, 92, 186, 68, 237, 255, 251, 198, 65,
+       103, 188, 252, 46, 28, 151, 254, 101, 151, 186, 179, 51, 230, 181,
+       31, 179, 203, 237, 32, 67, 39, 54, 233, 16, 48, 249, 41, 14, 111,
+       231, 37, 69, 231, 224, 173, 35, 144, 240, 58, 182, 34, 132, 49,
+       116, 56, 140, 66, 167, 63, 223, 34, 16, 182, 59, 149, 69, 198,
+       157, 178, 47, 209, 225, 58, 170, 40, 18, 39, 91, 127, 153, 250,
+       238, 118, 22, 219, 248, 17, 97, 254, 170, 91, 63, 190, 244, 126,
+       221, 151, 236, 152, 186, 125, 237, 250, 255, 135, 196, 231, 174,
+       102, 249, 84, 237, 59, 94, 22, 140, 135, 160, 248, 12, 129, 74,
+       242, 240, 245, 96, 32, 254, 12, 203, 74, 43, 172, 121, 177, 44,
+       175, 58, 0, 59, 33, 44, 50, 233, 36, 202, 157, 193, 135, 236, 142,
+       60, 188, 0, 226, 211, 125, 4, 217, 234, 13, 218, 74, 3, 10, 253,
+       249, 152, 143, 255, 16, 27, 247, 46, 54, 237, 42, 194, 188, 197,
+       151, 236, 139, 60, 156, 42, 98, 241, 254, 4, 153, 74, 85, 122, 74,
+       3, 138, 255, 249, 156, 135, 255, 16, 90, 215, 139, 19, 155, 122,
+       233, 62, 157, 154, 64, 207, 76, 176, 143, 159, 142, 54, 96, 238,
+       177, 223, 229, 206, 43, 118, 213, 151, 221, 170, 251, 93, 11, 13,
+       215, 90, 43, 82, 132, 119, 208, 58, 70, 171, 165, 94, 175, 44,
+       174, 102, 132, 166, 191, 131, 81, 20, 155, 160, 236, 50, 117, 10,
+       235, 38, 6, 173, 95, 247, 237, 18, 170, 172, 33, 86, 237, 131,
+       138, 185, 121, 70, 233, 249, 147, 217, 195, 68, 227, 110, 35, 202,
+       186, 184, 212, 37, 191, 222, 251, 186, 1, 132, 222, 189, 251, 186,
+       111, 183, 191, 30, 127, 88, 244, 244, 53, 136, 11, 7, 91, 55, 31,
+       177, 76, 107, 34, 108, 143, 127, 254, 148, 249, 133, 249, 31, 200,
+       116, 245, 39, 208, 255, 160, 225, 212, 118, 131, 121, 79, 87, 167,
+       46, 249, 181, 238, 206, 240, 45, 237, 103, 217, 199, 133, 103,
+       182, 120, 236, 235, 28, 124, 255, 173, 189, 216, 55, 45, 234, 191,
+       249, 191, 31, 151, 125, 207, 183, 255, 133, 220, 46, 227, 206,
+       215, 251, 250, 155, 70, 204, 65, 95, 147, 57, 67, 253, 102, 131,
+       237, 127, 23, 168, 82, 226, 53, 244, 176, 36, 126, 251, 23, 200,
+       209, 184, 17, 159, 36, 174, 185, 128, 61, 168, 48, 185, 75, 90,
+       242, 148, 99, 212, 57, 119, 9, 239, 126, 175, 44, 190, 231, 180,
+       230, 191, 183, 20, 197, 158, 176, 194, 95, 127, 20, 195, 162, 140,
+       44, 127, 59, 208, 96, 200, 53, 223, 93, 189, 71, 108, 148, 110,
+       139, 29, 183, 164, 92, 128, 157, 109, 207, 36, 117, 159, 163, 93,
+       129, 182, 127, 158, 88, 125, 79, 196, 160, 144, 109, 116, 248,
+       131, 235, 127, 87, 18, 8, 184, 126, 239, 225, 132, 179, 13, 135,
+       118, 190, 209, 23, 126, 218, 239, 158, 85, 252, 102, 11, 232, 100,
+       228, 101, 146, 91, 184, 235, 132, 54, 130, 121, 223, 214, 181,
+       150, 253, 181, 238, 198, 216, 46, 221, 99, 217, 141, 135, 39, 164,
+       80, 109, 164, 140, 148, 155, 205, 99, 164, 239, 19, 51, 104, 27,
+       64, 40, 108, 139, 233, 203, 162, 16, 118, 126, 75, 243, 61, 22,
+       213, 103, 209, 88, 240, 142, 166, 237, 228, 223, 221, 162, 174,
+       175, 210, 178, 249, 147, 96, 233, 92, 15, 91, 110, 51, 163, 114,
+       246, 207, 191, 46, 62, 223, 34, 213, 251, 208, 136, 220, 82, 58,
+       242, 165, 220, 83, 144, 203, 95, 149, 27, 94, 221, 107, 57, 149,
+       209, 157, 83, 138, 39, 186, 177, 211, 217, 0, 123, 146, 159, 92,
+       99, 2, 107, 80, 169, 74, 129, 62, 102, 140, 4, 248, 239, 173, 134,
+       161, 196, 110, 185, 207, 198, 66, 11, 198, 241, 180, 128, 42, 184,
+       61, 154, 45, 153, 26, 27, 198, 164, 18, 146, 186, 85, 173, 133,
+       90, 231, 45, 139, 166, 196, 38, 237, 175, 197, 196, 153, 134, 237,
+       178, 101, 170, 131, 47, 134, 41, 157, 97, 188, 150, 191, 189, 173,
+       112, 183, 255, 155, 250, 76, 238, 248, 68, 219, 129, 111, 110, 20,
+       191, 233, 219, 253, 175, 255, 85, 26, 72, 72, 202, 143, 85, 25,
+       241, 205, 14, 124, 131, 10, 71, 194, 200, 2, 251, 124, 21, 238,
+       126, 223, 56, 235, 137, 48, 119, 168, 133, 238, 10, 18, 181, 251,
+       21, 100, 31, 7, 102, 160, 190, 39, 75, 120, 133, 172, 159, 207,
+       79, 73, 187, 197, 126, 132, 95, 127, 168, 131, 13, 156, 250, 75,
+       41, 212, 55, 175, 48, 113, 112, 4, 199, 141, 77, 43, 64, 107, 61,
+       162, 251, 26, 98, 32, 4, 215, 120, 204, 110, 160, 8, 243, 193,
+       204, 149, 166, 211, 22, 97, 104, 114, 140, 240, 33, 198, 165, 93,
+       42, 96, 110, 61, 160, 251, 26, 99, 40, 20, 222, 120, 205, 110,
+       160, 12, 251, 193, 204, 157, 182, 211, 19, 225, 104, 114, 140,
+       114, 43, 120, 236, 172, 41, 220, 35, 43, 162, 186, 171, 175, 171,
+       85, 26, 206, 183, 127, 133, 216, 107, 195, 218, 210, 254, 219,
+       186, 68, 232, 195, 9, 122, 89, 249, 236, 253, 92, 93, 159, 139,
+       125, 244, 47, 31, 189, 55, 114, 238, 153, 151, 193, 143, 58, 242,
+       209, 247, 253, 173, 191, 255, 188, 84, 251, 42, 248, 111, 232,
+       109, 212, 217, 118, 137, 204, 188, 167, 25, 159, 119, 38, 206,
+       145, 215, 253, 203, 11, 242, 204, 107, 249, 172, 207, 111, 180,
+       118, 251, 82, 57, 187, 212, 51, 216, 53, 103, 233, 205, 126, 32,
+       46, 183, 230, 96, 162, 127, 236, 0, 64, 153, 160, 233, 179, 245,
+       58, 11, 0, 0, 39, 111, 202, 126, 118, 252, 45, 244, 253, 23, 189,
+       206, 150, 183, 172, 159, 182, 237, 230, 179, 255, 133, 231, 73,
+       179, 223, 243, 121, 254, 131, 22, 212, 189, 127, 194, 239, 70,
+       156, 76, 43, 236, 239, 63, 178, 234, 90, 228, 234, 5, 81, 123,
+       239, 106, 162, 98, 251, 203, 253, 180, 50, 223, 44, 29, 120, 115,
+       8, 211, 65, 71, 52, 9, 74, 76, 47, 173, 242, 162, 153, 198, 166,
+       69, 219, 162, 197, 121, 230, 108, 69, 147, 64, 149, 178, 223, 62,
+       32, 112, 11, 78, 50, 165, 114, 236, 220, 3, 238, 237, 239, 128,
+       233, 138, 99, 235, 60, 20, 122, 223, 91, 234, 88, 35, 223, 223,
+       182, 252, 135, 62, 117, 242, 226, 132, 202, 203, 80, 190, 254,
+       129, 158, 229, 26, 160, 148, 74, 172, 170, 179, 129, 130, 99, 31,
+       201, 102, 11, 10, 255, 184, 23, 158, 185, 22, 16, 139, 141, 98,
+       138, 254, 216, 95, 240, 184, 71, 139, 21, 144, 187, 44, 156, 118,
+       122, 239, 179, 251, 145, 22, 15, 162, 215, 95, 119, 218, 203, 151,
+       4, 191, 207, 216, 16, 186, 248, 35, 237, 81, 19, 175, 29, 182, 53,
+       191, 159, 34, 88, 134, 177, 221, 17, 10, 9, 18, 17, 195, 193, 50,
+       83, 178, 0, 13, 123, 242, 229, 212, 165, 94, 10, 236, 111, 47,
+       177, 186, 155, 199, 42, 84, 67, 107, 197, 110, 181, 124, 251, 205,
+       221, 188, 178, 207, 116, 229, 40, 243, 134, 58, 166, 98, 26, 215,
+       241, 185, 103, 95, 69, 124, 187, 40, 188, 118, 164, 191, 59, 147,
+       149, 150, 186, 164, 215, 63, 92, 156, 235, 247, 78, 254, 206, 254,
+       180, 172, 186, 143, 113, 82, 200, 139, 87, 133, 27, 78, 223, 110,
+       159, 233, 145, 221, 179, 62, 71, 186, 209, 219, 211, 203, 127,
+       151, 7, 63, 82, 197, 215, 190, 87, 178, 86, 191, 183, 120, 219,
+       118, 112, 213, 62, 158, 105, 151, 87, 52, 24, 241, 252, 41, 98,
+       110, 175, 118, 196, 132, 208, 165, 121, 235, 219, 246, 253, 125,
+       158, 252, 151, 159, 93, 246, 183, 157, 31, 183, 231, 238, 183,
+       255, 149, 231, 237, 99, 197, 255, 251, 190, 210, 103, 156, 245,
+       127, 182, 173, 216, 186, 215, 49, 214, 231, 217, 22, 169, 27, 106,
+       104, 31, 155, 153, 195, 193, 3, 124, 110, 88, 239, 187, 151, 85,
+       123, 245, 123, 222, 2, 48, 135, 76, 227, 213, 192, 101, 231, 103,
+       61, 122, 3, 97, 59, 12, 84, 233, 138, 7, 128, 94, 184, 17, 149,
+       63, 205, 134, 71, 225, 66, 244, 138, 144, 19, 91, 101, 146, 78,
+       65, 122, 100, 224, 226, 194, 83, 53, 0, 113, 120, 148, 72, 120,
+       121, 184, 117, 12, 249, 161, 37, 68, 97, 160, 102, 56, 194, 97,
+       217, 229, 124, 41, 248, 78, 171, 177, 176, 88, 157, 235, 85, 91,
+       198, 253, 127, 177, 34, 99, 194, 194, 156, 152, 171, 188, 132,
+       248, 35, 129, 79, 15, 202, 143, 246, 50, 238, 223, 80, 207, 95,
+       246, 73, 104, 183, 108, 127, 239, 6, 191, 181, 146, 141, 234, 126,
+       47, 191, 132, 175, 255, 184, 149, 188, 109, 98, 250, 215, 147, 70,
+       237, 85, 130, 228, 10, 107, 249, 61, 49, 121, 234, 23, 234, 106,
+       178, 28, 191, 243, 201, 133, 57, 119, 254, 254, 170, 146, 172, 86,
+       141, 92, 43, 238, 239, 63, 178, 250, 90, 166, 234, 4, 65, 123,
+       207, 107, 162, 106, 235, 195, 255, 188, 50, 159, 60, 5, 72, 241,
+       8, 107, 169, 128, 72, 189, 213, 146, 143, 203, 73, 168, 9, 42,
+       184, 70, 244, 201, 130, 249, 20, 31, 11, 210, 247, 59, 125, 148,
+       123, 218, 14, 218, 78, 50, 157, 111, 232, 21, 231, 219, 102, 205,
+       72, 248, 103, 56, 221, 53, 96, 236, 187, 151, 209, 155, 171, 80,
+       253, 57, 28, 138, 194, 93, 12, 116, 251, 70, 149, 88, 202, 250,
+       242, 26, 168, 133, 48, 253, 160, 73, 247, 173, 245, 82, 245, 190,
+       226, 89, 3, 108, 221, 58, 122, 131, 255, 63, 163, 44, 52, 11, 235,
+       18, 139, 45, 145, 108, 228, 79, 156, 92, 68, 172, 130, 231, 196,
+       227, 107, 162, 222, 199, 9, 42, 241, 40, 89, 94, 107, 26, 151,
+       169, 141, 82, 173, 6, 190, 157, 228, 22, 230, 143, 143, 138, 9,
+       166, 248, 32, 246, 193, 119, 232, 65, 60, 11, 147, 174, 185, 244,
+       142, 27, 16, 92, 53, 14, 173, 237, 10, 154, 205, 241, 199, 196,
+       196, 86, 141, 30, 253, 226, 107, 192, 91, 234, 130, 218, 119, 3,
+       62, 51, 240, 193, 175, 57, 179, 127, 173, 192, 48, 151, 31, 160,
+       213, 102, 85, 231, 1, 29, 122, 101, 6, 54, 38, 84, 233, 159, 134,
+       48, 88, 186, 48, 4, 249, 244, 6, 195, 193, 74, 230, 223, 109, 120,
+       176, 110, 45, 189, 87, 184, 207, 198, 45, 13, 254, 237, 115, 176,
+       149, 96, 169, 78, 141, 32, 250, 179, 227, 221, 5, 62, 218, 255,
+       90, 114, 44, 23, 83, 109, 252, 182, 246, 119, 196, 203, 127, 117,
+       80, 249, 168, 128, 221, 38, 130, 40, 209, 186, 64, 142, 110, 237,
+       36, 200, 219, 202, 240, 147, 188, 109, 110, 122, 213, 211, 70,
+       236, 81, 6, 101, 26, 107, 89, 61, 57, 121, 250, 149, 235, 104,
+       246, 8, 191, 243, 203, 193, 41, 115, 91, 254, 130, 134, 121, 145,
+       200, 43, 69, 41, 218, 31, 184, 0, 98, 28, 151, 229, 253, 199, 24,
+       63, 216, 67, 67, 179, 208, 153, 216, 7, 174, 18, 241, 37, 113, 18,
+       234, 195, 25, 18, 219, 40, 200, 54, 89, 82, 231, 45, 198, 128,
+       220, 54, 173, 239, 212, 7, 216, 7, 117, 20, 32, 187, 192, 63, 133,
+       41, 221, 234, 48, 234, 154, 79, 208, 144, 64, 139, 85, 245, 155,
+       40, 158, 126, 159, 232, 153, 147, 145, 6, 11, 178, 241, 23, 81,
+       154, 235, 151, 12, 63, 222, 43, 233, 130, 136, 213, 149, 174, 199,
+       75, 193, 104, 142, 40, 136, 118, 164, 252, 235, 146, 213, 215, 58,
+       182, 241, 61, 28, 142, 107, 223, 94, 251, 156, 24, 251, 82, 168,
+       91, 201, 150, 236, 205, 4, 184, 42, 46, 130, 33, 148, 238, 185,
+       202, 98, 70, 35, 2, 255, 176, 212, 2, 59, 115, 30, 47, 143, 106,
+       188, 179, 250, 169, 237, 16, 198, 191, 27, 168, 24, 190, 255, 100,
+       251, 201, 123, 251, 16, 51, 75, 218, 241, 219, 219, 94, 123, 218,
+       80, 135, 187, 0, 30, 248, 95, 252, 169, 163, 51, 94, 130, 189,
+       238, 176, 97, 181, 4, 95, 34, 10, 14, 178, 45, 69, 127, 70, 14,
+       50, 24, 223, 233, 73, 185, 173, 153, 14, 178, 205, 157, 112, 225,
+       214, 115, 21, 31, 28, 216, 114, 139, 169, 163, 251, 87, 246, 111,
+       26, 181, 94, 67, 249, 125, 188, 13, 152, 210, 150, 121, 49, 185,
+       10, 71, 29, 223, 135, 252, 144, 3, 148, 151, 97, 79, 230, 121, 63,
+       219, 74, 65, 19, 208, 193, 144, 79, 174, 48, 248, 37, 115, 140,
+       172, 188, 179, 234, 233, 191, 231, 190, 63, 28, 56, 253, 255, 202,
+       11, 163, 123, 119, 27, 50, 92, 42, 51, 108, 199, 127, 225, 180,
+       113, 143, 171, 2, 28, 169, 144, 221, 229, 184, 71, 155, 247, 152,
+       31, 156, 188, 119, 10, 237, 27, 179, 149, 182, 107, 178, 208, 95,
+       20, 158, 126, 213, 76, 53, 222, 134, 121, 59, 152, 235, 197, 158,
+       196, 139, 92, 144, 47, 44, 223, 103, 11, 174, 113, 215, 211, 198,
+       35, 186, 240, 51, 16, 79, 191, 21, 125, 39, 215, 182, 5, 86, 250,
+       199, 35, 220, 111, 113, 178, 233, 154, 75, 43, 60, 31, 123, 223,
+       19, 170, 120, 247, 92, 202, 243, 250, 214, 29, 231, 249, 234, 130,
+       57, 205, 107, 239, 118, 146, 79, 245, 65, 64, 252, 138, 51, 45,
+       182, 48, 126, 254, 21, 238, 201, 186, 60, 189, 122, 237, 164, 128,
+       119, 174, 240, 248, 214, 204, 150, 182, 150, 34, 102, 174, 190,
+       146, 138, 18, 100, 98, 41, 193, 115, 227, 40, 243, 120, 197, 9,
+       111, 184, 166, 207, 4, 148, 115, 161, 0, 59, 83, 115, 96, 55, 214,
+       219, 80, 65, 76, 255, 167, 43, 28, 182, 164, 238, 184, 149, 239,
+       205, 179, 52, 140, 83, 217, 160, 131, 111, 142, 126, 255, 150,
+       204, 151, 246, 150, 162, 30, 174, 31, 178, 139, 18, 237, 227, 121,
+       67, 179, 247, 57, 227, 122, 197, 139, 255, 184, 230, 207, 4, 164,
+       115, 161, 2, 18, 157, 103, 173, 151, 198, 255, 99, 205, 72, 218,
+       71, 104, 30, 52, 102, 238, 181, 159, 225, 217, 169, 21, 253, 179,
+       120, 138, 194, 61, 46, 244, 55, 237, 239, 24, 154, 236, 33, 143,
+       236, 152, 22, 173, 8, 231, 224, 121, 131, 155, 194, 202, 107, 122,
+       35, 202, 58, 184, 133, 15, 61, 213, 123, 219, 160, 131, 145, 17,
+       219, 253, 165, 184, 79, 31, 25, 81, 82, 188, 222, 108, 204, 207,
+       27, 179, 145, 147, 74, 90, 213, 13, 26, 154, 206, 152, 12, 161,
+       187, 130, 153, 54, 218, 111, 133, 188, 119, 159, 25, 82, 119, 188,
+       158, 36, 193, 231, 59, 191, 129, 211, 141, 18, 247, 53, 58, 186,
+       202, 28, 4, 169, 155, 191, 25, 242, 225, 247, 58, 250, 210, 85,
+       224, 246, 162, 27, 29, 151, 36, 110, 221, 151, 221, 140, 186, 117,
+       206, 95, 253, 163, 197, 231, 173, 114, 249, 61, 13, 106, 227, 199,
+       119, 239, 64, 21, 130, 253, 130, 89, 61, 55, 41, 120, 168, 19,
+       239, 24, 179, 52, 136, 115, 201, 195, 5, 231, 251, 116, 226, 34,
+       110, 172, 147, 108, 237, 121, 87, 143, 223, 28, 159, 164, 141, 83,
+       14, 13, 40, 75, 29, 2, 109, 2, 224, 205, 22, 148, 179, 132, 222,
+       148, 235, 33, 196, 45, 93, 13, 221, 212, 175, 206, 81, 172, 0,
+       178, 24, 62, 32, 201, 2, 88, 65, 223, 45, 115, 181, 107, 95, 144,
+       123, 81, 12, 220, 78, 58, 56, 17, 196, 79, 117, 17, 122, 129, 250,
+       152, 110, 60, 183, 65, 135, 108, 188, 215, 169, 1, 79, 242, 200,
+       151, 208, 203, 186, 50, 46, 54, 251, 64, 182, 177, 188, 252, 68,
+       191, 127, 136, 143, 24, 105, 157, 190, 112, 19, 207, 19, 23, 33,
+       240, 75, 138, 219, 125, 150, 191, 236, 148, 104, 135, 235, 6, 150,
+       248, 210, 244, 168, 248, 51, 249, 31, 177, 255, 244, 110, 190, 11,
+       255, 179, 31, 161, 182, 97, 12, 207, 222, 30, 254, 254, 133, 232,
+       69, 81, 193, 45, 19, 251, 252, 173, 107, 89, 62, 9, 113, 96, 183,
+       211, 129, 120, 230, 31, 126, 24, 35, 190, 195, 127, 196, 188, 58,
+       136, 152, 129, 33, 169, 1, 209, 187, 202, 116, 143, 250, 212, 110,
+       9, 251, 70, 220, 223, 188, 96, 254, 185, 31, 200, 193, 179, 40,
+       212, 221, 156, 170, 196, 220, 154, 97, 185, 26, 124, 179, 164, 15,
+       69, 149, 119, 128, 252, 152, 15, 189, 191, 98, 3, 204, 53, 115,
+       161, 72, 107, 210, 136, 241, 192, 207, 186, 37, 42, 23, 251, 98,
+       189, 56, 164, 234, 69, 189, 119, 136, 236, 144, 43, 180, 191, 99,
+       3, 204, 115, 83, 161, 192, 11, 146, 141, 253, 132, 255, 184, 1,
+       32, 39, 219, 148, 73, 43, 47, 150, 2, 206, 236, 116, 128, 194, 66,
+       243, 233, 49, 96, 120, 237, 17, 235, 104, 176, 29, 46, 225, 175,
+       175, 4, 117, 51, 115, 170, 10, 122, 178, 145, 103, 247, 185, 70,
+       155, 189, 16, 51, 140, 190, 119, 137, 239, 61, 151, 145, 132, 120,
+       160, 192, 93, 16, 186, 227, 135, 116, 39, 223, 129, 173, 215, 149,
+       244, 171, 168, 39, 62, 161, 122, 82, 180, 162, 0, 64, 99, 111,
+       106, 0, 48, 252, 193, 206, 172, 54, 223, 64, 132, 40, 129, 168,
+       172, 223, 8, 154, 205, 233, 199, 246, 24, 70, 125, 30, 107, 98,
+       11, 149, 89, 202, 130, 122, 123, 38, 124, 50, 181, 5, 172, 120,
+       185, 91, 220, 232, 99, 144, 253, 244, 52, 198, 89, 59, 75, 93, 48,
+       161, 124, 191, 246, 56, 135, 23, 53, 149, 150, 72, 162, 213, 203,
+       30, 249, 242, 148, 128, 86, 91, 191, 105, 106, 206, 127, 145, 94,
+       240, 197, 192, 180, 138, 123, 79, 191, 247, 110, 240, 223, 238,
+       200, 39, 124, 236, 243, 201, 135, 57, 119, 191, 106, 232, 6, 22,
+       252, 244, 36, 54, 216, 25, 219, 223, 181, 255, 204, 111, 254, 29,
+       159, 145, 149, 165, 188, 100, 46, 216, 138, 222, 251, 254, 207,
+       228, 79, 87, 110, 157, 249, 240, 244, 204, 255, 183, 137, 123,
+       188, 239, 188, 127, 63, 98, 239, 211, 151, 241, 249, 58, 112, 236,
+       255, 221, 238, 230, 159, 248, 197, 251, 47, 18, 244, 241, 37, 22,
+       216, 24, 91, 222, 53, 229, 205, 223, 255, 191, 151, 181, 181, 183,
+       133, 100, 58, 216, 194, 219, 233, 182, 30, 165, 74, 213, 17, 57,
+       159, 53, 130, 204, 184, 71, 238, 193, 34, 0, 188, 186, 65, 34,
+       166, 127, 120, 209, 21, 217, 147, 104, 201, 160, 30, 2, 136, 0,
+       35, 138, 19, 65, 99, 67, 86, 19, 235, 244, 101, 224, 94, 194, 89,
+       14, 183, 100, 126, 140, 19, 239, 133, 144, 37, 220, 54, 12, 139,
+       132, 39, 151, 113, 252, 91, 146, 126, 108, 27, 22, 81, 120, 103,
+       117, 175, 3, 74, 155, 14, 246, 118, 149, 252, 128, 140, 139, 167,
+       213, 219, 249, 80, 95, 35, 6, 108, 79, 222, 28, 191, 180, 175,
+       172, 120, 18, 169, 154, 147, 121, 159, 191, 65, 219, 167, 245,
+       253, 3, 185, 197, 210, 226, 215, 251, 123, 154, 136, 97, 11, 19,
+       170, 219, 119, 250, 237, 212, 252, 245, 175, 93, 244, 231, 44,
+       223, 190, 117, 238, 155, 151, 199, 223, 11, 50, 245, 119, 121,
+       254, 203, 87, 156, 229, 223, 124, 253, 49, 238, 189, 219, 71, 232,
+       195, 232, 252, 40, 251, 209, 73, 244, 216, 236, 220, 114, 75, 35,
+       232, 189, 187, 253, 37, 127, 82, 42, 86, 227, 126, 114, 4, 197,
+       13, 55, 210, 24, 129, 170, 151, 110, 90, 29, 209, 174, 12, 244,
+       253, 227, 137, 39, 219, 136, 147, 115, 233, 186, 111, 63, 90, 55,
+       93, 9, 139, 174, 29, 228, 74, 128, 134, 192, 202, 2, 51, 247, 113,
+       66, 200, 224, 59, 207, 11, 3, 210, 169, 209, 237, 138, 8, 184,
+       123, 48, 50, 60, 1, 126, 228, 197, 115, 215, 81, 196, 164, 239, 2,
+       83, 249, 59, 4, 120, 176, 131, 42, 24, 179, 48, 140, 115, 205,
+       129, 1, 243, 234, 252, 162, 228, 237, 216, 146, 220, 41, 207, 164,
+       152, 130, 41, 24, 247, 96, 93, 131, 27, 226, 64, 107, 112, 103,
+       204, 107, 188, 134, 77, 60, 221, 123, 203, 0, 22, 233, 116, 251,
+       238, 129, 238, 229, 239, 52, 184, 130, 173, 203, 85, 66, 234, 251,
+       123, 195, 66, 43, 203, 241, 188, 152, 15, 107, 85, 178, 227, 136,
+       91, 217, 117, 245, 55, 214, 219, 184, 75, 216, 52, 230, 253, 95,
+       212, 182, 166, 241, 181, 233, 197, 120, 126, 221, 235, 219, 175,
+       198, 63, 164, 119, 255, 126, 150, 232, 210, 245, 248, 251, 49, 89,
+       95, 53, 191, 237, 111, 191, 61, 255, 179, 151, 167, 188, 96, 60,
+       207, 223, 223, 223, 239, 183, 237, 77, 87, 130, 221, 58, 152, 211,
+       241, 188, 71, 191, 77, 90, 163, 44, 158, 38, 64, 230, 59, 147,
+       145, 86, 155, 50, 255, 63, 54, 158, 203, 21, 20, 165, 223, 254,
+       105, 118, 229, 172, 26, 254, 80, 237, 132, 182, 130, 11, 155, 213,
+       111, 238, 213, 127, 255, 236, 245, 165, 232, 246, 249, 206, 147,
+       39, 189, 120, 15, 0, 47, 159, 149, 244, 170, 172, 39, 60, 129, 90,
+       224, 180, 163, 128, 65, 99, 111, 42, 8, 48, 248, 65, 110, 44, 54,
+       126, 0, 140, 200, 129, 169, 9, 83, 107, 193, 116, 215, 235, 118,
+       69, 236, 94, 230, 153, 29, 182, 164, 126, 168, 151, 236, 145, 184,
+       101, 220, 102, 95, 178, 128, 63, 158, 244, 253, 95, 9, 171, 166,
+       141, 86, 206, 65, 196, 192, 219, 3, 121, 220, 55, 98, 248, 229,
+       57, 223, 220, 163, 188, 232, 241, 109, 138, 24, 197, 47, 120, 70,
+       56, 1, 98, 236, 197, 99, 84, 103, 69, 130, 234, 11, 75, 57, 60,
+       216, 248, 140, 135, 160, 28, 179, 0, 136, 211, 239, 208, 1, 163,
+       252, 252, 130, 124, 134, 37, 46, 28, 10, 67, 40, 232, 21, 235, 25,
+       211, 96, 12, 83, 216, 132, 109, 39, 58, 99, 203, 45, 217, 163, 98,
+       84, 209, 43, 214, 34, 212, 204, 216, 178, 144, 104, 78, 164, 249,
+       22, 139, 16, 231, 98, 29, 211, 51, 227, 8, 227, 120, 68, 152, 111,
+       169, 166, 207, 64, 132, 115, 131, 2, 63, 73, 78, 205, 31, 151,
+       234, 64, 197, 132, 244, 130, 73, 203, 55, 229, 120, 233, 186, 235,
+       8, 163, 30, 252, 83, 201, 203, 9, 55, 63, 120, 160, 29, 73, 102,
+       188, 15, 214, 250, 232, 229, 4, 231, 3, 75, 204, 59, 110, 120,
+       228, 234, 235, 12, 163, 63, 253, 211, 239, 195, 5, 115, 47, 101,
+       70, 9, 140, 165, 145, 133, 109, 173, 159, 62, 127, 4, 16, 156, 39,
+       80, 47, 33, 83, 123, 152, 51, 88, 123, 113, 205, 18, 223, 100,
+       146, 80, 133, 232, 29, 141, 27, 73, 209, 255, 167, 99, 86, 128,
+       108, 2, 50, 245, 97, 224, 121, 42, 2, 24, 17, 186, 48, 62, 109,
+       141, 7, 97, 241, 106, 97, 232, 194, 209, 115, 250, 244, 148, 188,
+       245, 189, 89, 240, 247, 188, 159, 188, 97, 238, 187, 159, 197,
+       246, 187, 162, 245, 55, 122, 222, 202, 87, 156, 231, 255, 2, 187,
+       169, 152, 223, 197, 185, 227, 154, 93, 16, 183, 156, 190, 102, 11,
+       239, 27, 179, 145, 22, 75, 178, 213, 93, 16, 222, 238, 148, 12,
+       181, 211, 107, 153, 117, 229, 119, 214, 89, 188, 203, 204, 20,
+       231, 125, 223, 150, 116, 134, 53, 181, 221, 129, 216, 182, 221,
+       79, 217, 169, 194, 55, 132, 84, 127, 26, 145, 252, 228, 52, 214,
+       217, 63, 75, 205, 60, 167, 127, 189, 214, 32, 150, 147, 181, 133,
+       142, 104, 54, 221, 203, 223, 191, 243, 199, 132, 93, 91, 95, 9,
+       171, 140, 149, 246, 74, 64, 197, 64, 207, 134, 115, 252, 183, 228,
+       248, 236, 24, 239, 157, 131, 60, 169, 179, 237, 138, 8, 61, 111,
+       120, 116, 53, 9, 235, 76, 148, 102, 235, 65, 196, 192, 203, 2, 80,
+       252, 53, 96, 120, 232, 51, 235, 153, 179, 52, 200, 17, 44, 130, 8,
+       213, 107, 112, 96, 133, 135, 23, 153, 228, 169, 173, 195, 142, 18,
+       88, 64, 148, 195, 233, 75, 167, 43, 19, 27, 82, 144, 2, 209, 36,
+       144, 106, 168, 28, 216, 129, 161, 5, 3, 26, 184, 228, 169, 173,
+       195, 174, 24, 88, 96, 148, 195, 249, 73, 166, 59, 18, 25, 82, 16,
+       2, 208, 68, 144, 42, 236, 156, 152, 161, 129, 239, 222, 240, 242,
+       245, 220, 255, 180, 89, 78, 180, 254, 237, 111, 255, 229, 127,
+       209, 159, 239, 237, 36, 108, 234, 190, 219, 230, 254, 63, 189, 73,
+       253, 57, 137, 99, 196, 86, 3, 239, 240, 101, 32, 126, 194, 89, 9,
+       181, 100, 122, 204, 19, 238, 192, 186, 37, 220, 114, 45, 163, 196,
+       103, 163, 112, 168, 63, 45, 114, 233, 252, 179, 218, 83, 93, 9,
+       249, 235, 31, 95, 181, 232, 254, 187, 151, 189, 158, 179, 69, 222,
+       178, 253, 170, 210, 255, 207, 112, 147, 18, 215, 105, 233, 182, 2,
+       157, 95, 20, 69, 220, 230, 149, 15, 176, 96, 94, 153, 31, 169,
+       251, 152, 117, 223, 228, 165, 170, 196, 61, 128, 181, 249, 11, 19,
+       107, 141, 118, 82, 175, 248, 100, 68, 94, 230, 249, 110, 191, 96,
+       126, 221, 23, 239, 133, 144, 53, 207, 102, 45, 170, 128, 47, 247,
+       49, 245, 235, 129, 98, 222, 227, 144, 108, 103, 249, 67, 117, 242,
+       40, 242, 188, 244, 126, 170, 146, 136, 245, 158, 166, 199, 54, 62,
+       222, 202, 47, 132, 250, 172, 133, 202, 17, 187, 236, 169, 172,
+       128, 142, 16, 25, 64, 148, 195, 249, 74, 207, 9, 19, 223, 66, 4,
+       202, 241, 4, 176, 170, 44, 20, 211, 1, 160, 111, 146, 252, 244,
+       245, 82, 217, 57, 91, 253, 53, 189, 77, 127, 190, 189, 151, 21,
+       181, 61, 150, 104, 166, 212, 202, 223, 241, 239, 151, 132, 79, 87,
+       127, 18, 244, 244, 53, 114, 217, 27, 91, 223, 53, 191, 79, 126,
+       190, 189, 183, 149, 181, 61, 182, 98, 46, 212, 202, 223, 243, 239,
+       167, 228, 77, 85, 164, 237, 208, 154, 220, 33, 207, 239, 152, 130,
+       169, 26, 226, 224, 125, 129, 91, 194, 66, 111, 123, 99, 14, 107,
+       56, 6, 77, 60, 213, 123, 218, 0, 29, 133, 105, 233, 150, 195, 234,
+       251, 6, 113, 220, 195, 157, 31, 176, 224, 123, 137, 23, 172, 219,
+       26, 117, 151, 238, 205, 171, 228, 191, 138, 168, 208, 217, 251,
+       109, 135, 50, 6, 107, 184, 32, 196, 22, 230, 117, 71, 155, 119,
+       54, 68, 93, 110, 193, 144, 189, 45, 228, 168, 225, 128, 46, 163,
+       1, 121, 31, 16, 244, 244, 37, 54, 217, 25, 27, 238, 180, 172, 79,
+       127, 151, 189, 151, 181, 181, 173, 173, 103, 38, 216, 194, 223,
+       121, 190, 207, 165, 75, 117, 162, 112, 119, 245, 100, 143, 248,
+       102, 29, 139, 112, 243, 172, 159, 52, 137, 238, 189, 23, 197, 161,
+       254, 4, 236, 22, 94, 218, 130, 15, 156, 99, 141, 75, 176, 127,
+       227, 36, 60, 248, 57, 109, 121, 127, 161, 205, 63, 158, 125, 247,
+       157, 255, 133, 148, 248, 171, 213, 223, 251, 218, 198, 6, 134, 37,
+       95, 106, 148, 249, 240, 245, 252, 255, 183, 137, 79, 188, 46, 220,
+       126, 254, 160, 255, 179, 159, 161, 241, 43, 48, 203, 255, 223,
+       127, 255, 159, 110, 197, 115, 47, 126, 241, 237, 117, 189, 254,
+       83, 175, 74, 253, 235, 187, 189, 213, 44, 239, 185, 151, 129, 142,
+       50, 224, 194, 247, 252, 170, 170, 215, 254, 119, 255, 54, 105,
+       194, 229, 133, 10, 238, 228, 97, 163, 178, 10, 3, 41, 21, 10, 234,
+       199, 79, 227, 120, 187, 209, 226, 179, 156, 150, 19, 229, 123,
+       242, 142, 212, 77, 67, 138, 204, 160, 238, 231, 172, 2, 234, 66,
+       4, 10, 41, 83, 106, 131, 74, 130, 88, 43, 80, 230, 180, 160, 138,
+       8, 133, 90, 225, 136, 166, 232, 163, 216, 116, 133, 139, 200, 30,
+       144, 241, 19, 112, 222, 125, 104, 253, 185, 19, 213, 2, 87, 138,
+       211, 25, 28, 143, 232, 149, 41, 113, 160, 182, 72, 67, 218, 95,
+       211, 82, 224, 215, 128, 224, 35, 96, 218, 37, 197, 248, 232, 130,
+       242, 110, 163, 10, 253, 186, 226, 131, 91, 51, 63, 124, 134, 4,
+       226, 138, 249, 124, 131, 162, 202, 158, 137, 216, 99, 84, 219,
+       249, 64, 251, 185, 55, 177, 2, 167, 10, 82, 92, 5, 175, 236, 149,
+       42, 49, 131, 12, 54, 210, 169, 244, 163, 170, 219, 30, 130, 88,
+       230, 213, 250, 233, 200, 255, 57, 51, 177, 147, 178, 10, 222, 28,
+       199, 175, 236, 220, 235, 57, 129, 202, 149, 66, 222, 219, 208, 60,
+       109, 141, 65, 77, 178, 104, 255, 174, 245, 102, 147, 179, 128, 87,
+       11, 54, 215, 63, 114, 154, 203, 55, 134, 173, 30, 133, 195, 27,
+       249, 180, 141, 33, 213, 254, 25, 82, 84, 148, 211, 169, 105, 166,
+       9, 6, 92, 35, 148, 2, 81, 132, 152, 58, 196, 152, 152, 161, 161,
+       6, 114, 163, 150, 98, 196, 185, 81, 184, 206, 209, 199, 60, 222,
+       119, 10, 254, 57, 151, 135, 196, 231, 162, 192, 81, 30, 250, 138,
+       5, 38, 39, 211, 171, 218, 124, 245, 38, 22, 89, 56, 91, 216, 20,
+       226, 253, 95, 151, 183, 150, 61, 181, 239, 225, 192, 166, 221,
+       194, 217, 233, 132, 47, 164, 88, 125, 43, 153, 241, 228, 53, 70,
+       217, 63, 155, 200, 180, 239, 253, 63, 54, 176, 190, 241, 149, 205,
+       195, 107, 54, 221, 107, 223, 175, 186, 79, 164, 67, 91, 137, 78,
+       4, 29, 44, 63, 74, 154, 86, 90, 148, 76, 179, 64, 151, 239, 70,
+       192, 94, 239, 175, 100, 103, 59, 132, 42, 227, 188, 60, 253, 89,
+       13, 214, 207, 217, 179, 150, 104, 238, 167, 120, 18, 75, 82, 229,
+       98, 29, 201, 113, 103, 8, 211, 115, 220, 137, 111, 172, 182, 223,
+       65, 168, 113, 233, 0, 137, 185, 126, 251, 246, 207, 123, 112, 85,
+       196, 117, 166, 49, 93, 178, 33, 126, 186, 23, 249, 179, 184, 40,
+       125, 110, 137, 32, 192, 127, 139, 112, 249, 59, 69, 106, 237, 118,
+       18, 223, 248, 69, 64, 254, 162, 121, 95, 191, 100, 126, 221, 151,
+       238, 200, 178, 37, 237, 115, 237, 162, 128, 103, 191, 112, 249,
+       29, 73, 107, 231, 118, 82, 127, 56, 100, 228, 95, 130, 89, 31,
+       179, 96, 118, 252, 23, 238, 193, 144, 61, 140, 103, 237, 171, 132,
+       39, 179, 112, 241, 171, 199, 101, 201, 118, 219, 164, 236, 92,
+       120, 80, 226, 104, 28, 188, 165, 126, 8, 150, 105, 231, 188, 45,
+       221, 36, 88, 35, 198, 119, 156, 213, 237, 6, 140, 80, 187, 244,
+       169, 238, 227, 141, 2, 184, 146, 165, 42, 60, 65, 235, 131, 31,
+       189, 114, 9, 0, 202, 164, 28, 158, 176, 148, 88, 209, 128, 107,
+       145, 253, 228, 117, 214, 217, 63, 27, 237, 60, 173, 125, 63, 54,
+       48, 150, 151, 181, 133, 151, 75, 48, 213, 75, 223, 191, 187, 159,
+       132, 85, 127, 129, 149, 31, 189, 50, 170, 173, 55, 60, 11, 90,
+       116, 181, 51, 168, 96, 119, 59, 54, 12, 243, 152, 17, 79, 228,
+       174, 62, 128, 12, 192, 161, 169, 82, 29, 191, 84, 35, 200, 53, 39,
+       172, 142, 110, 32, 60, 187, 37, 51, 162, 55, 237, 0, 96, 201, 162,
+       74, 243, 179, 118, 3, 64, 112, 167, 43, 60, 105, 56, 104, 136, 89,
+       87, 205, 134, 164, 172, 9, 147, 133, 67, 18, 72, 192, 74, 122, 74,
+       35, 107, 16, 247, 133, 37, 61, 112, 250, 196, 234, 63, 203, 114,
+       236, 119, 147, 222, 248, 85, 0, 252, 202, 75, 73, 188, 180, 126,
+       253, 23, 239, 204, 179, 108, 255, 115, 253, 167, 221, 119, 174,
+       122, 129, 194, 188, 106, 24, 123, 240, 177, 71, 171, 85, 180, 187,
+       44, 156, 102, 3, 239, 179, 219, 145, 54, 111, 166, 213, 91, 49,
+       26, 251, 215, 4, 175, 223, 189, 22, 83, 172, 100, 35, 68, 112, 21,
+       74, 121, 255, 87, 73, 160, 129, 222, 168, 6, 38, 173, 182, 64,
+       142, 210, 225, 32, 128, 111, 237, 120, 145, 33, 59, 107, 79, 246,
+       146, 175, 113, 80, 200, 124, 230, 49, 196, 183, 100, 126, 106, 18,
+       220, 215, 186, 36, 236, 108, 45, 174, 136, 29, 138, 114, 253, 230,
+       172, 209, 210, 228, 168, 238, 224, 121, 3, 177, 90, 44, 106, 29,
+       19, 235, 131, 22, 187, 34, 38, 72, 226, 180, 156, 6, 104, 197, 83,
+       99, 128, 199, 140, 25, 139, 236, 137, 174, 128, 172, 18, 25, 80,
+       148, 194, 89, 82, 195, 3, 74, 75, 82, 4, 202, 227, 164, 144, 138,
+       40, 156, 91, 1, 160, 56, 71, 114, 238, 55, 18, 254, 252, 69, 128,
+       252, 130, 123, 75, 189, 96, 126, 253, 23, 239, 204, 179, 12, 236,
+       242, 237, 167, 129, 119, 191, 120, 138, 225, 20, 127, 76, 108,
+       102, 65, 63, 80, 235, 247, 88, 82, 53, 140, 51, 88, 148, 116, 40,
+       121, 231, 225, 14, 83, 171, 112, 212, 65, 232, 226, 49, 3, 182,
+       63, 200, 252, 37, 156, 111, 137, 155, 152, 115, 188, 190, 116, 3,
+       143, 19, 23, 37, 242, 43, 2, 223, 57, 28, 191, 190, 156, 104, 209,
+       155, 134, 204, 83, 146, 174, 137, 174, 128, 172, 18, 176, 194,
+       188, 202, 125, 67, 163, 33, 75, 123, 98, 37, 0, 226, 164, 20, 14,
+       40, 132, 123, 1, 128, 114, 5, 66, 168, 197, 34, 70, 111, 117, 3,
+       232, 11, 3, 42, 61, 89, 248, 139, 2, 161, 120, 187, 16, 196, 177,
+       244, 146, 7, 177, 88, 242, 14, 204, 54, 188, 113, 234, 104, 49,
+       11, 122, 191, 183, 184, 159, 21, 192, 58, 7, 149, 236, 17, 50,
+       102, 227, 66, 205, 211, 113, 127, 196, 225, 7, 35, 5, 140, 149,
+       218, 168, 237, 13, 191, 158, 87, 12, 16, 253, 231, 72, 111, 7, 82,
+       58, 28, 51, 72, 250, 117, 237, 158, 94, 120, 146, 209, 133, 104,
+       251, 97, 119, 228, 124, 35, 250, 220, 201, 168, 178, 235, 79, 153,
+       245, 183, 238, 245, 255, 239, 172, 119, 132, 200, 182, 248, 203,
+       190, 103, 189, 98, 141, 26, 144, 253, 244, 53, 118, 217, 59, 27,
+       125, 180, 187, 78, 125, 190, 44, 151, 149, 181, 53, 158, 107, 50,
+       212, 203, 223, 89, 255, 215, 132, 71, 119, 52, 77, 79, 128, 212,
+       130, 110, 102, 196, 128, 202, 194, 113, 162, 161, 64, 120, 230,
+       42, 252, 88, 155, 5, 44, 56, 166, 175, 64, 165, 186, 48, 8, 71,
+       178, 165, 19, 173, 62, 141, 153, 202, 255, 131, 93, 194, 108, 95,
+       111, 197, 68, 121, 31, 151, 101, 255, 128, 143, 26, 223, 252, 136,
+       125, 213, 117, 220, 201, 190, 190, 139, 113, 20, 140, 158, 150,
+       129, 17, 238, 232, 107, 203, 129, 115, 233, 83, 102, 101, 138, 48,
+       235, 211, 95, 63, 144, 117, 173, 2, 60, 73, 115, 236, 23, 18, 126,
+       248, 101, 132, 254, 2, 75, 107, 53, 244, 122, 252, 31, 234, 200,
+       179, 60, 236, 243, 237, 131, 133, 39, 191, 124, 2, 189, 1, 106,
+       77, 69, 86, 237, 112, 85, 198, 247, 2, 83, 13, 191, 109, 120, 172,
+       18, 238, 168, 182, 53, 140, 83, 235, 192, 4, 119, 175, 112, 228,
+       47, 148, 241, 208, 245, 181, 248, 27, 155, 89, 61, 251, 140, 61,
+       254, 47, 239, 147, 151, 145, 182, 106, 34, 196, 95, 94, 222, 238,
+       151, 204, 215, 247, 10, 152, 244, 252, 127, 213, 184, 63, 155, 95,
+       20, 247, 172, 191, 190, 47, 175, 19, 151, 133, 230, 77, 50, 247,
+       75, 91, 250, 171, 23, 132, 165, 223, 15, 234, 82, 147, 37, 153,
+       113, 212, 239, 85, 119, 148, 143, 130, 238, 205, 162, 42, 130, 94,
+       151, 176, 54, 241, 134, 89, 18, 107, 154, 141, 205, 212, 125, 198,
+       65, 163, 230, 11, 103, 57, 5, 239, 95, 111, 86, 119, 186, 84, 119,
+       132, 63, 46, 216, 144, 41, 148, 246, 46, 165, 196, 54, 174, 208,
+       97, 54, 137, 242, 226, 199, 0, 238, 228, 121, 1, 250, 3, 43, 43,
+       61, 81, 122, 203, 21, 193, 88, 186, 21, 224, 187, 254, 214, 65,
+       229, 242, 224, 10, 103, 145, 193, 10, 188, 80, 202, 29, 47, 193,
+       155, 236, 214, 230, 220, 244, 214, 12, 62, 125, 223, 10, 253, 192,
+       44, 60, 143, 222, 204, 166, 243, 117, 2, 148, 147, 154, 51, 225,
+       184, 64, 159, 91, 81, 179, 172, 223, 104, 204, 247, 59, 147, 145,
+       19, 13, 26, 247, 139, 86, 154, 203, 150, 5, 37, 247, 43, 152, 120,
+       253, 104, 37, 249, 119, 27, 59, 120, 253, 189, 191, 102, 0, 207,
+       59, 183, 132, 128, 30, 146, 209, 70, 219, 122, 170, 94, 128, 99,
+       155, 180, 76, 66, 238, 21, 131, 202, 64, 85, 128, 249, 3, 99, 203,
+       53, 192, 120, 168, 23, 234, 108, 167, 28, 191, 179, 236, 131, 25,
+       125, 187, 122, 130, 170, 249, 27, 248, 75, 197, 17, 246, 138, 24,
+       72, 8, 60, 159, 97, 48, 132, 123, 179, 65, 67, 26, 178, 49, 221,
+       209, 29, 43, 16, 0, 7, 251, 38, 122, 131, 140, 108, 3, 184, 90,
+       94, 162, 240, 111, 16, 152, 229, 136, 255, 253, 55, 177, 128, 62,
+       131, 202, 28, 6, 191, 174, 213, 168, 115, 131, 125, 37, 232, 6,
+       172, 62, 71, 184, 65, 250, 189, 12, 91, 120, 223, 182, 89, 196,
+       220, 110, 221, 35, 253, 138, 242, 93, 197, 189, 110, 255, 90, 84,
+       35, 204, 106, 88, 116, 145, 202, 102, 85, 66, 124, 3, 32, 137,
+       182, 240, 217, 170, 19, 140, 238, 190, 68, 255, 38, 94, 144, 43,
+       127, 156, 122, 206, 158, 115, 243, 164, 103, 75, 184, 81, 159,
+       232, 83, 239, 29, 221, 117, 136, 190, 61, 151, 23, 193, 209, 60,
+       192, 151, 213, 43, 166, 47, 174, 53, 243, 176, 22, 83, 236, 116,
+       99, 85, 89, 21, 74, 241, 127, 71, 92, 169, 113, 222, 176, 6, 34,
+       173, 183, 32, 142, 146, 244, 32, 130, 121, 232, 100, 215, 35, 46,
+       42, 177, 149, 189, 178, 198, 30, 165, 88, 135, 132, 136, 115, 0,
+       237, 43, 19, 21, 150, 184, 20, 190, 108, 69, 139, 233, 221, 13,
+       89, 198, 98, 52, 189, 204, 109, 100, 153, 107, 137, 251, 152, 95,
+       28, 190, 100, 2, 141, 17, 95, 161, 161, 15, 146, 194, 25, 28, 219,
+       190, 144, 104, 39, 243, 129, 115, 31, 248, 236, 133, 180, 223,
+       142, 24, 80, 96, 180, 215, 97, 9, 167, 27, 19, 81, 67, 64, 2, 80,
+       133, 144, 126, 238, 24, 24, 161, 169, 173, 239, 16, 170, 236, 33,
+       143, 236, 130, 146, 173, 8, 221, 225, 249, 130, 91, 194, 194, 107,
+       115, 39, 202, 50, 120, 133, 47, 60, 222, 251, 171, 128, 220, 234,
+       188, 182, 143, 19, 20, 204, 83, 182, 128, 27, 79, 234, 107, 203,
+       209, 221, 232, 211, 110, 71, 203, 170, 250, 195, 221, 63, 176,
+       125, 172, 14, 239, 150, 114, 242, 247, 188, 250, 177, 185, 71, 61,
+       191, 221, 111, 254, 173, 127, 147, 159, 173, 181, 37, 44, 202,
+       254, 223, 47, 174, 135, 238, 77, 245, 166, 21, 113, 250, 244, 165,
+       248, 67, 29, 27, 121, 251, 140, 191, 124, 9, 239, 155, 23, 149,
+       177, 26, 64, 194, 30, 92, 26, 234, 157, 205, 225, 133, 177, 72,
+       107, 229, 118, 2, 235, 180, 88, 224, 114, 231, 17, 14, 149, 113,
+       126, 237, 23, 239, 225, 156, 5, 204, 100, 42, 235, 128, 45, 177,
+       114, 153, 255, 93, 118, 228, 230, 62, 255, 214, 121, 234, 182,
+       170, 27, 29, 151, 255, 238, 245, 221, 239, 236, 247, 165, 232,
+       114, 249, 236, 146, 103, 253, 86, 125, 87, 1, 227, 196, 212, 70,
+       239, 65, 97, 192, 203, 194, 81, 116, 189, 228, 124, 172, 16, 253,
+       153, 147, 181, 204, 185, 44, 143, 132, 173, 166, 177, 116, 251,
+       85, 115, 228, 166, 30, 220, 87, 109, 234, 190, 171, 123, 29, 183,
+       116, 254, 181, 221, 237, 236, 167, 37, 202, 243, 249, 164, 146,
+       103, 252, 244, 127, 216, 148, 157, 241, 171, 116, 16, 135, 162,
+       59, 131, 56, 158, 63, 72, 251, 135, 87, 237, 144, 58, 79, 235, 0,
+       203, 243, 120, 247, 128, 65, 141, 59, 196, 205, 253, 91, 136, 236,
+       111, 191, 251, 87, 47, 16, 243, 103, 28, 121, 35, 242, 56, 10,
+       115, 76, 255, 115, 111, 175, 116, 64, 242, 209, 196, 120, 99, 15,
+       225, 222, 249, 145, 78, 190, 7, 201, 252, 236, 170, 100, 149, 244,
+       74, 226, 183, 220, 155, 10, 79, 251, 46, 62, 148, 186, 150, 220,
+       248, 45, 215, 221, 251, 214, 178, 36, 63, 190, 184, 146, 11, 214,
+       244, 119, 41, 115, 55, 115, 25, 227, 241, 69, 184, 111, 249, 174,
+       79, 70, 172, 243, 161, 57, 201, 125, 223, 117, 160, 79, 109, 23,
+       248, 226, 38, 12, 189, 55, 17, 59, 34, 100, 120, 108, 225, 221,
+       177, 106, 229, 139, 117, 0, 104, 112, 75, 184, 130, 135, 242, 249,
+       244, 128, 252, 103, 93, 19, 241, 211, 141, 59, 60, 193, 239, 155,
+       23, 149, 242, 254, 68, 194, 190, 222, 158, 194, 149, 204, 233,
+       129, 2, 204, 250, 243, 180, 136, 252, 231, 253, 19, 178, 147, 173,
+       63, 53, 75, 231, 211, 31, 133, 226, 237, 0, 235, 190, 254, 222,
+       131, 132, 220, 233, 15, 43, 26, 245, 244, 245, 150, 248, 59, 219,
+       206, 116, 239, 121, 253, 183, 44, 223, 245, 183, 133, 180, 106,
+       230, 223, 79, 223, 251, 171, 135, 172, 119, 255, 43, 155, 117,
+       229, 55, 214, 89, 56, 75, 200, 52, 231, 253, 95, 214, 180, 150,
+       181, 181, 205, 197, 232, 118, 221, 234, 217, 171, 210, 63, 132,
+       79, 125, 22, 158, 89, 233, 146, 227, 11, 154, 6, 97, 216, 226,
+       157, 103, 160, 96, 119, 155, 29, 188, 59, 136, 33, 95, 233, 133,
+       171, 196, 180, 129, 37, 49, 208, 195, 44, 174, 140, 6, 77, 61, 20,
+       20, 199, 23, 241, 99, 58, 65, 84, 130, 61, 239, 104, 15, 91, 29,
+       241, 163, 238, 140, 52, 144, 180, 104, 172, 132, 148, 89, 205, 99,
+       180, 239, 210, 59, 32, 19, 64, 185, 108, 139, 201, 82, 162, 16,
+       54, 126, 11, 243, 47, 18, 213, 103, 211, 93, 252, 138, 183, 129,
+       106, 200, 94, 71, 235, 88, 203, 100, 245, 138, 89, 221, 126, 100,
+       126, 157, 19, 253, 147, 51, 188, 208, 125, 8, 139, 236, 119, 171,
+       113, 240, 166, 236, 229, 223, 221, 162, 142, 175, 210, 147, 232,
+       18, 97, 233, 93, 143, 89, 110, 51, 191, 114, 126, 207, 191, 47,
+       30, 223, 6, 215, 249, 208, 128, 136, 28, 150, 251, 165, 172, 61,
+       7, 188, 19, 70, 16, 189, 51, 33, 77, 195, 51, 59, 8, 51, 156, 19,
+       227, 197, 242, 90, 0, 152, 216, 129, 42, 31, 52, 115, 225, 54,
+       189, 122, 90, 111, 97, 127, 171, 255, 221, 255, 36, 191, 185, 223,
+       61, 142, 180, 61, 223, 214, 221, 33, 162, 247, 207, 69, 247, 9,
+       235, 16, 121, 116, 141, 235, 158, 126, 9, 124, 68, 190, 195, 192,
+       52, 135, 106, 6, 92, 195, 56, 218, 113, 108, 156, 54, 232, 90,
+       152, 195, 169, 243, 97, 234, 204, 108, 65, 216, 77, 91, 200, 240,
+       123, 16, 156, 247, 40, 248, 189, 119, 245, 204, 103, 162, 194, 26,
+       24, 227, 191, 69, 56, 118, 199, 214, 205, 200, 243, 148, 104, 102,
+       167, 121, 19, 11, 16, 227, 106, 13, 73, 113, 71, 8, 146, 120, 220,
+       89, 106, 172, 182, 223, 67, 168, 113, 233, 2, 91, 146, 244, 244,
+       55, 22, 121, 60, 91, 234, 20, 231, 253, 255, 255, 101, 183, 31,
+       181, 173, 132, 72, 167, 221, 203, 255, 255, 231, 22, 164, 5, 127,
+       139, 202, 18, 219, 37, 185, 120, 208, 255, 93, 103, 52, 172, 194,
+       190, 237, 162, 42, 134, 28, 182, 156, 46, 245, 6, 91, 82, 67, 26,
+       133, 41, 69, 162, 104, 235, 177, 238, 193, 181, 71, 154, 182, 80,
+       187, 160, 156, 103, 9, 206, 59, 147, 145, 98, 126, 102, 208, 69,
+       0, 222, 171, 85, 28, 151, 218, 63, 59, 250, 224, 247, 223, 253,
+       95, 61, 204, 244, 175, 63, 60, 183, 189, 254, 187, 215, 241, 159,
+       179, 112, 204, 255, 223, 14, 163, 231, 220, 111, 255, 107, 146,
+       252, 244, 245, 118, 217, 61, 27, 223, 53, 253, 221, 127, 190, 185,
+       151, 213, 181, 181, 183, 73, 42, 212, 74, 223, 251, 255, 142, 132,
+       93, 113, 1, 190, 153, 191, 52, 132, 99, 185, 118, 200, 89, 68,
+       245, 227, 120, 64, 113, 106, 50, 141, 195, 56, 154, 119, 237, 12,
+       39, 76, 24, 162, 113, 168, 144, 192, 126, 219, 22, 130, 233, 117,
+       52, 1, 118, 146, 241, 19, 60, 101, 122, 24, 27, 156, 98, 188, 21,
+       205, 79, 171, 178, 64, 39, 136, 112, 168, 29, 201, 248, 243, 149,
+       28, 255, 228, 121, 0, 166, 2, 63, 61, 21, 33, 120, 211, 147, 251,
+       120, 184, 48, 236, 251, 217, 198, 65, 99, 186, 245, 40, 12, 113,
+       64, 225, 45, 83, 233, 88, 6, 32, 134, 130, 153, 7, 209, 236, 74,
+       152, 251, 241, 75, 144, 245, 144, 197, 193, 170, 245, 55, 141, 60,
+       48, 247, 80, 253, 100, 46, 4, 159, 152, 201, 218, 146, 235, 247,
+       92, 93, 107, 214, 245, 125, 243, 200, 103, 239, 200, 187, 152,
+       239, 158, 101, 186, 113, 119, 63, 123, 115, 195, 199, 38, 191,
+       216, 97, 116, 123, 199, 89, 77, 127, 12, 127, 221, 19, 255, 149,
+       179, 61, 228, 127, 12, 135, 68, 239, 191, 226, 208, 167, 175, 192,
+       154, 213, 61, 206, 231, 25, 10, 185, 223, 238, 104, 157, 157, 159,
+       203, 134, 167, 253, 110, 76, 239, 188, 22, 221, 252, 253, 127,
+       218, 148, 99, 189, 115, 248, 252, 135, 252, 255, 31, 57, 112, 235,
+       140, 191, 245, 1, 255, 189, 23, 173, 144, 122, 198, 212, 62, 94,
+       223, 238, 159, 252, 99, 157, 144, 18, 83, 17, 194, 105, 161, 71,
+       116, 51, 242, 247, 145, 6, 161, 9, 107, 159, 106, 144, 50, 254,
+       69, 70, 20, 2, 118, 69, 229, 88, 39, 154, 131, 199, 119, 9, 55,
+       219, 166, 109, 93, 121, 81, 242, 72, 28, 188, 165, 58, 8, 150,
+       109, 247, 184, 45, 221, 46, 88, 33, 198, 119, 142, 217, 229, 162,
+       234, 169, 177, 108, 193, 189, 199, 154, 247, 80, 187, 161, 140,
+       82, 8, 205, 59, 147, 149, 70, 94, 230, 130, 68, 21, 190, 169, 132,
+       28, 151, 218, 88, 140, 94, 85, 38, 174, 233, 50, 252, 2, 246, 130,
+       219, 51, 180, 69, 106, 52, 127, 168, 40, 189, 5, 111, 71, 175,
+       114, 0, 111, 160, 105, 40, 9, 238, 193, 91, 52, 141, 235, 158, 95,
+       13, 120, 100, 187, 193, 208, 164, 76, 106, 6, 92, 195, 184, 106,
+       63, 174, 220, 52, 224, 90, 155, 80, 168, 131, 130, 103, 159, 71,
+       209, 172, 103, 220, 70, 86, 151, 40, 140, 182, 228, 110, 35, 178,
+       133, 229, 190, 38, 215, 4, 62, 218, 139, 85, 12, 41, 220, 6, 141,
+       242, 251, 244, 160, 254, 227, 221, 2, 248, 211, 237, 127, 61, 193,
+       255, 243, 23, 175, 240, 235, 8, 238, 190, 222, 207, 194, 151, 237,
+       233, 133, 30, 89, 249, 225, 54, 143, 120, 80, 15, 232, 23, 227,
+       157, 159, 225, 232, 254, 57, 151, 212, 131, 144, 8, 208, 198, 217,
+       171, 180, 190, 174, 9, 147, 242, 52, 189, 196, 63, 119, 144, 123,
+       137, 234, 144, 127, 28, 60, 37, 42, 207, 49, 221, 33, 168, 111,
+       48, 206, 19, 30, 123, 186, 69, 44, 54, 127, 164, 205, 217, 154,
+       220, 41, 207, 239, 152, 6, 169, 26, 230, 96, 93, 133, 27, 194, 66,
+       111, 121, 103, 94, 107, 56, 6, 77, 60, 220, 123, 218, 160, 27,
+       137, 124, 245, 21, 214, 249, 164, 107, 212, 46, 2, 251, 127, 87,
+       34, 254, 243, 177, 221, 202, 248, 58, 237, 235, 217, 143, 69, 103,
+       134, 116, 106, 93, 208, 85, 101, 10, 31, 188, 61, 101, 242, 187,
+       238, 91, 28, 156, 162, 63, 149, 252, 175, 221, 181, 29, 212, 176,
+       235, 101, 84, 111, 186, 169, 17, 59, 132, 98, 201, 215, 247, 250,
+       239, 93, 65, 92, 18, 41, 56, 182, 228, 255, 139, 147, 189, 190,
+       186, 52, 223, 63, 125, 130, 71, 183, 204, 248, 206, 66, 187, 150,
+       151, 171, 216, 188, 135, 171, 189, 14, 165, 172, 174, 70, 142,
+       167, 119, 233, 145, 20, 216, 131, 224, 14, 54, 95, 195, 134, 68,
+       141, 95, 122, 253, 56, 104, 25, 221, 87, 239, 83, 108, 188, 9, 43,
+       157, 70, 148, 152, 154, 197, 98, 78, 43, 120, 191, 251, 221, 5,
+       127, 83, 30, 206, 123, 44, 31, 159, 190, 236, 226, 87, 113, 137,
+       206, 125, 165, 118, 229, 163, 219, 222, 115, 132, 38, 57, 227,
+       106, 44, 64, 183, 96, 138, 216, 235, 166, 243, 134, 141, 250, 243,
+       244, 40, 254, 229, 125, 2, 243, 147, 207, 107, 61, 73, 255, 211,
+       31, 175, 240, 189, 13, 238, 190, 254, 222, 195, 231, 250, 233, 5,
+       99, 57, 243, 244, 253, 159, 248, 119, 141, 201, 246, 239, 190,
+       189, 244, 36, 206, 183, 223, 145, 148, 235, 224, 204, 95, 94, 254,
+       250, 199, 140, 119, 255, 111, 86, 241, 244, 245, 22, 248, 218,
+       219, 203, 52, 235, 125, 125, 255, 45, 255, 245, 183, 189, 164, 99,
+       174, 206, 95, 223, 255, 238, 151, 252, 87, 255, 15, 179, 245, 252,
+       55, 22, 249, 185, 91, 221, 20, 231, 253, 255, 254, 37, 191, 93,
+       181, 173, 151, 104, 175, 221, 203, 127, 239, 231, 151, 164, 37,
+       247, 131, 157, 115, 1, 183, 219, 178, 227, 94, 105, 120, 35, 136,
+       24, 182, 164, 170, 43, 146, 85, 247, 184, 36, 253, 46, 89, 35,
+       227, 93, 12, 217, 199, 39, 61, 168, 161, 148, 191, 186, 66, 78,
+       225, 90, 7, 149, 156, 119, 32, 169, 43, 19, 21, 151, 184, 53, 158,
+       77, 77, 139, 224, 221, 77, 89, 214, 120, 225, 51, 232, 93, 212,
+       85, 229, 195, 5, 205, 10, 10, 221, 56, 116, 216, 186, 147, 1, 90,
+       11, 186, 215, 251, 221, 143, 127, 18, 10, 246, 234, 90, 233, 58,
+       236, 77, 209, 250, 238, 79, 37, 140, 11, 168, 137, 118, 132, 232,
+       155, 155, 193, 14, 43, 146, 245, 243, 213, 154, 59, 23, 14, 125,
+       138, 127, 89, 250, 228, 252, 23, 255, 208, 233, 232, 254, 174, 27,
+       191, 247, 54, 110, 245, 255, 221, 157, 187, 164, 224, 250, 221,
+       166, 150, 231, 191, 122, 253, 74, 28, 127, 93, 34, 190, 185, 50,
+       172, 72, 95, 100, 253, 55, 180, 108, 102, 55, 61, 8, 144, 153, 49,
+       205, 199, 255, 122, 128, 14, 129, 37, 49, 5, 132, 83, 184, 116,
+       163, 238, 99, 28, 2, 218, 194, 213, 226, 176, 64, 123, 161, 26,
+       169, 97, 149, 4, 94, 176, 14, 47, 68, 20, 248, 49, 0, 3, 142, 254,
+       251, 244, 172, 184, 135, 191, 27, 82, 179, 172, 187, 124, 72, 231,
+       27, 191, 21, 178, 220, 131, 243, 142, 62, 218, 194, 148, 200, 233,
+       139, 243, 113, 106, 64, 79, 85, 220, 101, 121, 236, 244, 143, 11,
+       140, 214, 61, 110, 140, 151, 205, 205, 118, 244, 192, 83, 89, 208,
+       171, 111, 140, 126, 223, 97, 175, 93, 115, 244, 143, 102, 180,
+       104, 104, 46, 76, 183, 113, 147, 49, 130, 98, 92, 110, 247, 56,
+       73, 63, 236, 189, 37, 80, 200, 211, 218, 9, 27, 152, 125, 229, 55,
+       214, 217, 57, 203, 192, 52, 134, 255, 93, 22, 36, 182, 61, 181,
+       237, 193, 232, 182, 221, 203, 249, 9, 194, 103, 166, 71, 253, 237,
+       255, 17, 174, 252, 33, 142, 252, 152, 138, 185, 108, 212, 225,
+       233, 130, 31, 67, 86, 111, 241, 35, 202, 58, 40, 4, 47, 188, 92,
+       251, 131, 161, 62, 103, 193, 231, 158, 83, 78, 201, 23, 226, 157,
+       171, 67, 68, 237, 132, 127, 220, 143, 242, 73, 67, 13, 154, 186,
+       198, 173, 181, 55, 255, 188, 52, 83, 205, 38, 172, 58, 144, 30,
+       230, 133, 68, 202, 167, 233, 14, 50, 192, 110, 225, 157, 199, 204,
+       141, 4, 239, 176, 100, 138, 139, 63, 150, 185, 92, 11, 147, 244,
+       246, 55, 20, 121, 57, 219, 217, 21, 163, 253, 255, 254, 101, 182,
+       115, 181, 173, 230, 72, 46, 253, 203, 223, 255, 226, 22, 164, 5,
+       127, 21, 61, 123, 193, 214, 251, 178, 66, 78, 225, 56, 2, 144,
+       184, 117, 160, 171, 59, 146, 17, 23, 184, 48, 156, 47, 205, 11,
+       103, 205, 73, 89, 130, 43, 151, 235, 225, 181, 247, 251, 95, 95,
+       77, 95, 118, 153, 63, 178, 236, 223, 18, 151, 189, 179, 184, 49,
+       222, 111, 223, 190, 196, 158, 204, 252, 241, 134, 184, 182, 219,
+       228, 165, 184, 195, 159, 27, 81, 115, 140, 158, 124, 169, 239, 27,
+       183, 149, 178, 92, 2, 243, 142, 30, 218, 202, 156, 76, 161, 131,
+       82, 143, 46, 174, 29, 180, 218, 39, 132, 68, 202, 135, 231, 232,
+       50, 64, 232, 167, 249, 197, 156, 169, 23, 189, 241, 97, 202, 89,
+       61, 14, 185, 94, 121, 143, 76, 95, 22, 219, 202, 178, 69, 64, 254,
+       226, 115, 72, 148, 245, 122, 230, 174, 238, 237, 170, 77, 189, 62,
+       111, 160, 209, 127, 175, 120, 12, 165, 237, 252, 86, 212, 251,
+       198, 175, 90, 242, 61, 26, 115, 104, 223, 49, 25, 234, 18, 42,
+       255, 118, 126, 63, 63, 143, 245, 61, 221, 251, 218, 140, 164, 223,
+       1, 154, 215, 101, 199, 247, 24, 79, 121, 127, 66, 96, 43, 153, 73,
+       202, 6, 131, 121, 126, 88, 114, 60, 6, 244, 234, 217, 91, 212,
+       211, 166, 76, 241, 250, 252, 169, 254, 244, 217, 18, 184, 219,
+       109, 255, 125, 9, 255, 243, 23, 183, 161, 103, 92, 234, 190, 222,
+       223, 174, 157, 255, 97, 141, 62, 245, 208, 238, 155, 23, 23, 249,
+       23, 170, 141, 10, 120, 247, 107, 164, 125, 221, 149, 242, 72, 67,
+       187, 184, 251, 207, 143, 191, 51, 127, 168, 163, 38, 235, 82, 218,
+       124, 129, 206, 232, 203, 128, 89, 202, 237, 202, 124, 128, 154,
+       235, 6, 203, 194, 42, 142, 253, 42, 28, 175, 233, 29, 139, 91,
+       136, 44, 116, 62, 56, 232, 247, 21, 117, 129, 206, 253, 173, 215,
+       245, 171, 61, 221, 56, 150, 34, 248, 131, 98, 12, 243, 215, 101,
+       191, 210, 254, 174, 247, 6, 143, 242, 251, 244, 160, 254, 226, 93,
+       3, 249, 210, 205, 107, 60, 193, 255, 219, 23, 171, 242, 187, 72,
+       226, 190, 222, 142, 206, 151, 253, 233, 129, 7, 141, 250, 243,
+       180, 136, 254, 181, 125, 19, 119, 179, 237, 127, 189, 101, 255,
+       243, 31, 175, 246, 120, 12, 239, 190, 222, 222, 194, 151, 254,
+       233, 13, 130, 188, 63, 218, 121, 245, 184, 87, 191, 93, 16, 117,
+       172, 222, 102, 109, 199, 59, 191, 145, 182, 77, 178, 247, 15, 90,
+       154, 235, 150, 4, 37, 223, 253, 207, 69, 95, 78, 19, 206, 176, 81,
+       34, 249, 234, 99, 104, 149, 247, 90, 244, 166, 239, 237, 186, 108,
+       191, 54, 106, 197, 56, 119, 190, 90, 172, 167, 208, 241, 250, 236,
+       165, 252, 212, 155, 27, 177, 251, 188, 191, 253, 43, 239, 27, 183,
+       145, 179, 70, 194, 225, 22, 88, 218, 170, 159, 221, 225, 151, 126,
+       198, 193, 143, 110, 2, 79, 185, 19, 15, 221, 231, 193, 103, 152,
+       84, 95, 200, 39, 174, 202, 6, 239, 147, 100, 46, 239, 156, 63,
+       247, 240, 241, 118, 213, 84, 202, 155, 115, 22, 232, 7, 176, 137,
+       162, 65, 118, 173, 247, 123, 209, 187, 242, 47, 3, 31, 252, 186,
+       196, 143, 255, 191, 243, 44, 22, 29, 243, 145, 238, 155, 23, 31,
+       248, 87, 172, 157, 66, 108, 243, 233, 164, 253, 120, 150, 234,
+       201, 67, 42, 152, 187, 207, 47, 190, 50, 182, 41, 165, 127, 156,
+       241, 244, 245, 22, 250, 250, 219, 203, 188, 235, 125, 125, 255,
+       36, 255, 241, 151, 189, 182, 107, 172, 223, 127, 223, 255, 254,
+       151, 236, 87, 255, 11, 147, 252, 252, 119, 22, 249, 121, 91, 220,
+       20, 231, 253, 127, 190, 37, 191, 113, 183, 173, 165, 104, 46, 221,
+       75, 91, 239, 231, 23, 164, 37, 247, 57, 77, 106, 238, 84, 151,
+       238, 244, 101, 64, 124, 14, 59, 205, 51, 32, 124, 235, 23, 237,
+       207, 187, 52, 189, 115, 205, 160, 0, 127, 154, 122, 248, 57, 213,
+       107, 111, 85, 151, 235, 244, 68, 64, 124, 6, 121, 207, 63, 160,
+       124, 171, 146, 236, 207, 186, 52, 221, 119, 237, 166, 0, 123, 154,
+       104, 248, 138, 145, 116, 249, 47, 148, 120, 57, 143, 17, 55, 18,
+       172, 223, 40, 239, 230, 147, 191, 208, 214, 100, 119, 241, 207,
+       249, 90, 203, 54, 133, 169, 39, 123, 211, 251, 238, 47, 86, 219,
+       252, 1, 76, 254, 230, 123, 95, 191, 118, 254, 213, 191, 234, 201,
+       163, 117, 225, 243, 253, 162, 146, 47, 191, 116, 121, 50, 255, 64,
+       195, 213, 193, 230, 230, 67, 13, 120, 39, 32, 170, 230, 0, 233,
+       202, 135, 208, 94, 58, 8, 255, 62, 28, 150, 227, 117, 10, 254,
+       142, 164, 207, 216, 154, 220, 105, 207, 175, 24, 130, 169, 30,
+       247, 96, 89, 129, 27, 235, 66, 107, 121, 102, 216, 107, 60, 7, 77,
+       61, 221, 123, 218, 0, 0, 143, 27, 175, 180, 194, 39, 55, 20, 9,
+       219, 96, 245, 119, 32, 64, 80, 58, 31, 168, 88, 152, 97, 31, 233,
+       165, 174, 192, 16, 50, 181, 33, 47, 157, 240, 252, 244, 148, 254,
+       250, 91, 218, 52, 227, 125, 127, 189, 37, 255, 243, 151, 189, 244,
+       106, 108, 255, 126, 223, 239, 238, 151, 236, 99, 255, 31, 146,
+       246, 244, 39, 22, 125, 189, 91, 202, 20, 163, 253, 255, 255, 101,
+       183, 113, 181, 141, 228, 205, 46, 221, 203, 223, 255, 131, 150,
+       164, 5, 127, 138, 141, 113, 201, 247, 181, 218, 119, 95, 65, 92,
+       147, 172, 189, 180, 100, 94, 187, 151, 157, 178, 56, 100, 223,
+       111, 92, 134, 226, 247, 206, 213, 255, 148, 205, 158, 190, 151,
+       224, 102, 167, 254, 147, 139, 19, 103, 106, 61, 201, 241, 227, 40,
+       179, 124, 197, 27, 239, 169, 231, 223, 5, 165, 115, 169, 2, 117,
+       200, 148, 28, 141, 18, 68, 239, 205, 146, 192, 2, 130, 184, 55,
+       111, 200, 228, 108, 75, 76, 239, 199, 128, 144, 58, 87, 27, 28,
+       56, 120, 14, 231, 182, 149, 145, 172, 45, 148, 159, 223, 251, 18,
+       93, 142, 60, 92, 171, 135, 71, 252, 21, 183, 108, 203, 146, 142,
+       90, 93, 246, 216, 252, 145, 85, 150, 204, 158, 246, 150, 162, 30,
+       239, 158, 146, 139, 147, 125, 235, 121, 67, 179, 103, 57, 227,
+       122, 197, 14, 255, 186, 231, 207, 5, 180, 243, 169, 2, 115, 22,
+       111, 68, 126, 83, 219, 120, 217, 238, 183, 239, 75, 60, 182, 164,
+       254, 181, 213, 165, 173, 163, 36, 206, 50, 126, 169, 150, 127,
+       174, 116, 117, 38, 157, 114, 250, 252, 165, 254, 246, 153, 11,
+       184, 251, 236, 255, 253, 32, 255, 243, 23, 191, 179, 51, 204, 234,
+       190, 222, 143, 238, 159, 255, 225, 133, 31, 216, 240, 247, 52, 30,
+       126, 184, 251, 202, 182, 161, 255, 127, 191, 102, 247, 243, 157,
+       173, 236, 96, 44, 235, 235, 223, 255, 146, 150, 244, 5, 127, 49,
+       129, 107, 197, 84, 66, 234, 124, 81, 225, 94, 66, 113, 57, 148,
+       36, 120, 206, 51, 236, 153, 186, 245, 175, 127, 109, 165, 196, 47,
+       138, 112, 168, 112, 137, 121, 101, 84, 14, 195, 55, 113, 33, 122,
+       10, 115, 57, 20, 48, 120, 158, 53, 41, 152, 186, 117, 143, 255,
+       254, 128, 64, 101, 138, 86, 170, 173, 115, 108, 46, 104, 115, 79,
+       88, 66, 236, 189, 173, 91, 69, 219, 187, 30, 196, 198, 110, 207,
+       99, 255, 24, 114, 73, 33, 189, 127, 247, 110, 241, 46, 82, 250,
+       117, 231, 116, 189, 214, 91, 127, 126, 254, 28, 189, 223, 170,
+       223, 221, 183, 17, 151, 246, 240, 194, 71, 127, 118, 167, 207,
+       253, 206, 243, 50, 130, 148, 186, 47, 105, 144, 72, 31, 59, 209,
+       59, 174, 252, 110, 77, 201, 27, 167, 17, 30, 118, 74, 145, 152,
+       210, 91, 255, 148, 77, 29, 135, 166, 184, 183, 218, 239, 245, 184,
+       210, 155, 91, 17, 119, 140, 254, 125, 43, 239, 27, 151, 145, 182,
+       79, 186, 240, 15, 90, 222, 234, 158, 77, 183, 215, 95, 105, 234,
+       204, 86, 144, 123, 64, 234, 64, 199, 130, 157, 210, 251, 114, 118,
+       45, 185, 222, 198, 19, 164, 193, 211, 233, 139, 173, 38, 166, 41,
+       228, 60, 36, 101, 97, 141, 127, 73, 136, 67, 243, 33, 24, 91, 84,
+       221, 191, 25, 92, 85, 58, 185, 86, 253, 144, 75, 202, 197, 116,
+       171, 253, 86, 244, 23, 213, 56, 74, 155, 23, 86, 220, 215, 156,
+       173, 2, 110, 211, 47, 116, 245, 209, 12, 254, 206, 3, 43, 255,
+       187, 207, 5, 63, 179, 243, 168, 71, 131, 180, 147, 191, 234, 224,
+       188, 71, 26, 83, 81, 187, 188, 190, 96, 171, 175, 59, 147, 145,
+       115, 94, 146, 195, 149, 22, 94, 234, 156, 76, 163, 187, 156, 221,
+       172, 119, 145, 118, 110, 189, 118, 222, 207, 22, 241, 119, 155,
+       229, 113, 238, 177, 238, 249, 216, 61, 47, 235, 239, 247, 5, 170,
+       247, 188, 122, 138, 176, 183, 216, 239, 245, 152, 203, 159, 95,
+       20, 183, 12, 222, 126, 46, 175, 27, 183, 145, 150, 111, 186, 211,
+       91, 90, 219, 239, 151, 12, 165, 215, 150, 143, 114, 251, 244, 160,
+       254, 247, 93, 2, 248, 211, 239, 107, 61, 193, 255, 219, 23, 239,
+       250, 251, 12, 239, 190, 222, 142, 207, 151, 253, 233, 137, 151,
+       204, 250, 243, 164, 8, 254, 245, 253, 2, 246, 179, 237, 107, 189,
+       101, 255, 243, 159, 175, 244, 253, 12, 239, 254, 223, 222, 195,
+       183, 252, 233, 141, 47, 155, 241, 244, 117, 86, 219, 56, 91, 206,
+       60, 231, 121, 253, 247, 36, 255, 245, 183, 141, 133, 226, 108,
+       223, 79, 95, 239, 131, 183, 254, 84, 255, 22, 200, 214, 255, 7,
+       130, 110, 128, 213, 3, 99, 2, 67, 234, 52, 88, 112, 229, 34, 128,
+       8, 176, 29, 193, 1, 254, 210, 3, 181, 58, 104, 6, 40, 151, 209,
+       127, 112, 136, 177, 55, 46, 29, 114, 245, 191, 49, 168, 80, 166,
+       26, 6, 8, 50, 184, 65, 117, 108, 176, 48, 192, 82, 136, 199, 171,
+       244, 117, 120, 96, 190, 91, 215, 232, 65, 228, 188, 43, 83, 93,
+       223, 35, 58, 196, 221, 115, 108, 35, 253, 62, 251, 201, 5, 63,
+       101, 187, 94, 114, 110, 178, 247, 218, 237, 117, 184, 222, 155,
+       219, 20, 127, 44, 252, 127, 63, 207, 211, 151, 149, 166, 103, 186,
+       224, 95, 90, 223, 191, 215, 125, 247, 223, 150, 207, 114, 227,
+       182, 24, 254, 245, 109, 0, 251, 130, 75, 107, 188, 101, 254, 211,
+       31, 239, 252, 185, 13, 234, 254, 249, 142, 195, 39, 255, 249, 133,
+       70, 179, 180, 225, 169, 108, 188, 15, 171, 189, 155, 57, 140, 255,
+       78, 26, 135, 87, 253, 17, 22, 73, 203, 192, 143, 244, 95, 255,
+       128, 70, 143, 83, 210, 15, 111, 238, 90, 192, 31, 35, 160, 4, 202,
+       171, 101, 247, 32, 83, 102, 247, 253, 194, 88, 139, 162, 109, 243,
+       161, 170, 155, 32, 34, 165, 122, 34, 183, 19, 136, 245, 195, 180,
+       255, 31, 13, 120, 101, 12, 188, 236, 68, 217, 27, 134, 17, 86,
+       186, 0, 198, 42, 84, 54, 207, 218, 12, 230, 219, 130, 218, 195,
+       220, 67, 208, 56, 70, 189, 29, 212, 242, 40, 135, 100, 221, 110,
+       187, 167, 128, 2, 223, 162, 193, 23, 50, 218, 139, 39, 0, 37, 127,
+       74, 175, 135, 181, 241, 192, 188, 230, 191, 219, 66, 225, 172,
+       254, 66, 219, 231, 123, 255, 209, 118, 217, 130, 233, 189, 119,
+       223, 203, 134, 116, 191, 207, 43, 184, 99, 17, 67, 244, 185, 87,
+       169, 89, 116, 183, 56, 158, 246, 188, 236, 187, 151, 149, 151,
+       154, 54, 196, 31, 24, 154, 194, 207, 4, 247, 255, 190, 225, 252,
+       162, 111, 89, 210, 200, 203, 176, 177, 171, 78, 93, 79, 138, 170,
+       209, 235, 115, 78, 103, 74, 176, 90, 67, 65, 127, 87, 191, 92,
+       146, 38, 204, 113, 250, 252, 169, 254, 230, 73, 2, 248, 203, 127,
+       111, 61, 0, 255, 211, 23, 191, 251, 54, 76, 250, 182, 222, 142,
+       170, 159, 251, 225, 137, 0, 159, 88, 171, 178, 169, 187, 187, 30,
+       33, 72, 197, 181, 35, 3, 64, 151, 11, 3, 21, 146, 152, 89, 63,
+       236, 135, 58, 80, 156, 200, 9, 137, 0, 63, 152, 187, 246, 169,
+       178, 115, 30, 1, 93, 117, 180, 248, 166, 0, 143, 59, 3, 17, 150,
+       184, 66, 127, 108, 149, 30, 107, 220, 74, 137, 155, 164, 239, 217,
+       154, 221, 105, 70, 231, 25, 6, 169, 94, 230, 96, 25, 145, 25, 227,
+       2, 35, 121, 110, 88, 110, 61, 134, 69, 120, 221, 123, 218, 128,
+       50, 141, 38, 216, 157, 209, 132, 231, 196, 21, 216, 2, 32, 200,
+       52, 65, 200, 2, 11, 193, 94, 171, 2, 253, 33, 96, 138, 91, 85, 12,
+       252, 142, 67, 112, 186, 219, 101, 188, 248, 22, 171, 11, 124, 33,
+       172, 158, 102, 252, 167, 57, 179, 21, 134, 156, 178, 193, 71, 126,
+       18, 203, 130, 4, 107, 223, 194, 94, 74, 220, 122, 208, 56, 87,
+       189, 11, 86, 242, 44, 135, 164, 248, 230, 187, 183, 128, 99, 159,
+       130, 207, 22, 55, 186, 139, 26, 144, 172, 61, 159, 221, 126, 231,
+       182, 18, 127, 177, 121, 192, 95, 162, 249, 127, 158, 229, 54, 247,
+       149, 238, 252, 152, 45, 239, 238, 223, 239, 196, 39, 166, 245,
+       113, 171, 151, 115, 200, 247, 245, 155, 119, 93, 77, 92, 183, 172,
+       189, 182, 164, 222, 59, 151, 189, 183, 58, 116, 223, 111, 92, 142,
+       234, 151, 204, 149, 253, 35, 139, 107, 77, 116, 142, 107, 55, 49,
+       65, 94, 199, 49, 45, 148, 96, 30, 174, 21, 140, 153, 152, 229, 15,
+       110, 44, 176, 192, 109, 136, 82, 249, 74, 30, 240, 180, 105, 116,
+       180, 3, 187, 207, 61, 189, 44, 190, 103, 158, 167, 179, 253, 133,
+       164, 111, 182, 194, 223, 87, 95, 175, 198, 100, 13, 95, 88, 217,
+       62, 252, 19, 208, 49, 103, 172, 5, 206, 163, 188, 150, 34, 96,
+       226, 51, 185, 129, 68, 137, 50, 253, 241, 231, 90, 67, 50, 4, 165,
+       122, 5, 174, 207, 23, 208, 171, 38, 135, 126, 163, 107, 196, 225,
+       34, 148, 108, 121, 78, 106, 156, 183, 216, 205, 125, 44, 46, 247,
+       64, 168, 202, 193, 132, 178, 207, 207, 180, 86, 207, 96, 227, 89,
+       60, 250, 78, 99, 40, 52, 80, 249, 163, 6, 129, 105, 190, 0, 239,
+       189, 130, 228, 129, 109, 40, 92, 11, 129, 12, 207, 87, 148, 46,
+       102, 150, 116, 163, 66, 82, 241, 33, 153, 105, 113, 110, 42, 138,
+       177, 252, 221, 46, 205, 174, 214, 64, 168, 217, 193, 168, 137, 10,
+       195, 81, 228, 186, 104, 23, 127, 103, 118, 244, 169, 131, 147,
+       204, 115, 46, 166, 28, 149, 188, 37, 210, 134, 255, 50, 193, 174,
+       204, 73, 252, 180, 44, 31, 154, 220, 239, 183, 202, 182, 178, 233,
+       59, 86, 213, 97, 83, 233, 252, 106, 50, 106, 103, 203, 114, 245,
+       36, 135, 61, 81, 123, 38, 130, 223, 205, 240, 231, 167, 26, 127,
+       180, 121, 226, 183, 162, 251, 127, 158, 117, 127, 213, 157, 239,
+       236, 176, 45, 239, 239, 255, 231, 133, 39, 182, 224, 121, 56, 217,
+       58, 127, 60, 205, 83, 246, 198, 12, 252, 32, 179, 209, 32, 96,
+       200, 58, 15, 72, 74, 170, 114, 61, 227, 205, 34, 25, 112, 11, 68,
+       43, 32, 185, 56, 249, 124, 205, 211, 254, 78, 13, 252, 34, 183,
+       221, 32, 32, 200, 58, 6, 72, 74, 42, 114, 61, 229, 205, 34, 57,
+       80, 11, 244, 171, 178, 106, 234, 188, 98, 128, 184, 66, 185, 142,
+       112, 163, 44, 142, 231, 26, 238, 237, 167, 213, 70, 223, 134, 192,
+       82, 35, 254, 131, 101, 52, 111, 203, 82, 76, 215, 5, 18, 122, 102,
+       38, 249, 227, 106, 242, 104, 51, 133, 214, 34, 230, 108, 136, 33,
+       217, 133, 110, 52, 38, 116, 131, 231, 244, 133, 45, 0, 44, 133,
+       215, 200, 107, 38, 71, 118, 162, 235, 82, 241, 179, 65, 110, 105,
+       126, 106, 154, 64, 220, 201, 42, 205, 134, 247, 32, 160, 122, 133,
+       168, 55, 83, 66, 172, 85, 23, 75, 80, 37, 204, 251, 199, 75, 14,
+       191, 116, 252, 165, 6, 230, 141, 179, 52, 204, 144, 248, 130, 130,
+       121, 175, 114, 212, 228, 232, 60, 248, 237, 205, 85, 239, 162,
+       158, 164, 25, 146, 87, 66, 27, 137, 32, 73, 8, 122, 79, 210, 21,
+       109, 155, 245, 121, 16, 48, 214, 242, 42, 186, 230, 219, 227, 241,
+       184, 71, 155, 93, 124, 179, 40, 156, 118, 172, 239, 59, 179, 145,
+       150, 254, 166, 209, 15, 88, 218, 235, 215, 76, 230, 223, 214, 222,
+       133, 179, 149, 106, 102, 167, 121, 31, 83, 87, 227, 34, 13, 89,
+       241, 199, 12, 147, 121, 220, 89, 106, 169, 166, 222, 194, 169,
+       113, 225, 14, 219, 131, 2, 170, 155, 148, 30, 101, 61, 9, 139,
+       199, 44, 234, 58, 212, 246, 171, 223, 229, 126, 9, 146, 223, 186,
+       116, 138, 218, 46, 6, 185, 30, 194, 170, 174, 152, 233, 216, 184,
+       103, 171, 61, 6, 179, 172, 238, 102, 207, 225, 63, 251, 17, 22,
+       73, 130, 241, 31, 50, 218, 251, 146, 4, 157, 207, 198, 77, 126,
+       248, 238, 40, 253, 142, 189, 22, 242, 131, 124, 235, 61, 91, 231,
+       211, 127, 245, 114, 69, 131, 254, 188, 186, 94, 206, 148, 240,
+       225, 9, 125, 23, 79, 228, 150, 6, 222, 49, 0, 232, 155, 71, 91,
+       61, 25, 2, 188, 245, 93, 231, 205, 161, 17, 142, 241, 237, 173,
+       148, 109, 122, 250, 19, 129, 125, 30, 16, 151, 255, 176, 70, 236,
+       200, 42, 72, 182, 152, 117, 43, 168, 123, 82, 81, 165, 233, 16,
+       108, 41, 24, 5, 82, 200, 89, 11, 159, 170, 56, 179, 184, 75, 229,
+       145, 79, 158, 221, 192, 27, 44, 159, 98, 9, 201, 59, 131, 145, 18,
+       111, 50, 208, 89, 209, 154, 107, 144, 76, 39, 250, 110, 82, 250,
+       84, 231, 124, 253, 151, 57, 255, 118, 191, 10, 61, 207, 191, 223,
+       221, 181, 2, 205, 118, 243, 192, 87, 251, 116, 135, 207, 252, 110,
+       123, 154, 203, 46, 191, 62, 131, 31, 173, 134, 28, 151, 167, 239,
+       201, 58, 65, 226, 35, 175, 71, 78, 9, 11, 189, 224, 225, 174, 147,
+       52, 30, 189, 75, 26, 50, 114, 192, 118, 155, 184, 80, 45, 204, 94,
+       239, 45, 206, 183, 164, 54, 185, 151, 241, 132, 128, 36, 204, 86,
+       93, 43, 187, 39, 174, 13, 85, 173, 12, 57, 243, 228, 100, 253,
+       144, 216, 122, 85, 48, 157, 29, 191, 41, 143, 3, 23, 31, 247, 124,
+       40, 226, 70, 91, 250, 160, 148, 217, 209, 225, 206, 101, 244, 225,
+       174, 43, 126, 143, 143, 179, 27, 147, 141, 139, 81, 74, 135, 87,
+       125, 31, 146, 69, 143, 146, 166, 217, 159, 252, 182, 223, 145, 0,
+       29, 60, 211, 225, 146, 163, 42, 210, 54, 160, 203, 226, 25, 115,
+       225, 172, 127, 253, 22, 186, 9, 144, 17, 74, 152, 204, 171, 228,
+       171, 243, 40, 177, 58, 30, 98, 168, 51, 163, 218, 114, 61, 77, 90,
+       231, 45, 171, 54, 192, 254, 171, 151, 181, 158, 155, 4, 255, 250,
+       101, 170, 194, 191, 199, 57, 211, 167, 238, 108, 26, 205, 177,
+       186, 202, 207, 90, 148, 151, 8, 200, 247, 46, 205, 75, 178, 215,
+       182, 39, 78, 243, 62, 92, 143, 255, 223, 125, 120, 197, 242, 207,
+       213, 246, 84, 192, 232, 163, 25, 16, 250, 70, 99, 75, 52, 81, 123,
+       227, 38, 209, 75, 62, 65, 237, 28, 170, 230, 193, 109, 40, 120,
+       10, 125, 120, 82, 76, 67, 139, 183, 112, 121, 162, 112, 238, 74,
+       208, 166, 180, 58, 172, 70, 106, 196, 183, 132, 95, 52, 44, 1, 42,
+       111, 190, 106, 133, 11, 30, 228, 151, 224, 54, 45, 23, 63, 255,
+       31, 245, 201, 38, 147, 127, 7, 87, 253, 156, 181, 220, 231, 226,
+       6, 122, 254, 128, 142, 244, 155, 125, 162, 206, 106, 219, 87, 176,
+       186, 70, 221, 13, 116, 179, 40, 136, 182, 196, 232, 170, 131, 148,
+       182, 190, 38, 247, 6, 125, 146, 203, 151, 141, 252, 207, 19, 23,
+       65, 136, 178, 43, 29, 91, 61, 230, 89, 253, 141, 38, 147, 60, 54,
+       169, 21, 165, 181, 144, 52, 94, 176, 20, 11, 178, 156, 246, 131,
+       85, 188, 206, 198, 229, 5, 34, 226, 230, 69, 178, 250, 115, 11,
+       25, 48, 131, 233, 198, 167, 243, 108, 255, 1, 162, 250, 225, 214,
+       71, 99, 89, 124, 138, 97, 133, 13, 87, 140, 79, 197, 189, 86, 114,
+       175, 8, 211, 33, 24, 111, 89, 70, 120, 46, 121, 116, 249, 19, 231,
+       239, 213, 52, 112, 122, 208, 104, 18, 223, 122, 190, 50, 192, 189,
+       103, 164, 4, 218, 163, 45, 190, 162, 64, 102, 187, 157, 129, 64,
+       139, 6, 239, 240, 165, 190, 131, 37, 0, 165, 203, 19, 79, 106,
+       140, 246, 146, 238, 102, 245, 132, 222, 231, 41, 232, 183, 196,
+       122, 236, 134, 239, 196, 187, 4, 238, 50, 108, 170, 129, 109, 190,
+       121, 205, 40, 188, 113, 120, 125, 237, 225, 91, 95, 57, 116, 24,
+       154, 153, 68, 177, 201, 154, 66, 24, 187, 62, 82, 151, 95, 221,
+       17, 126, 211, 8, 214, 162, 212, 236, 156, 144, 140, 106, 71, 174,
+       186, 182, 142, 26, 212, 243, 65, 75, 113, 212, 121, 186, 114, 69,
+       187, 66, 249, 163, 207, 125, 128, 113, 181, 34, 215, 227, 0, 169,
+       156, 141, 78, 153, 7, 113, 135, 223, 195, 65, 218, 69, 80, 132,
+       125, 254, 90, 68, 203, 149, 254, 216, 133, 124, 62, 158, 144, 0,
+       124, 108, 233, 101, 222, 99, 71, 222, 66, 242, 188, 170, 19, 33,
+       209, 58, 89, 204, 76, 250, 73, 118, 229, 26, 248, 205, 165, 53,
+       247, 248, 86, 32, 244, 120, 189, 96, 13, 111, 83, 216, 226, 250,
+       164, 8, 87, 21, 65, 59, 129, 212, 124, 114, 9, 103, 251, 48, 219,
+       203, 69, 127, 224, 121, 70, 98, 2, 170, 218, 216, 124, 161, 168,
+       75, 159, 3, 213, 26, 160, 195, 180, 4, 219, 40, 43, 140, 2, 47, 2,
+       215, 4, 30, 155, 58, 20, 136, 121, 172, 111, 173, 164, 31, 157,
+       54, 78, 191, 83, 223, 140, 29, 240, 122, 94, 127, 209, 78, 57,
+       158, 191, 72, 255, 191, 111, 95, 221, 188, 154, 244, 216, 94, 184,
+       120, 118, 83, 55, 251, 241, 68, 233, 52, 188, 41, 42, 29, 39, 150,
+       170, 49, 206, 64, 34, 171, 48, 253, 99, 217, 16, 51, 67, 30, 70,
+       239, 39, 95, 99, 136, 246, 130, 107, 245, 65, 200, 88, 230, 81,
+       99, 177, 116, 126, 168, 22, 253, 155, 154, 36, 252, 60, 44, 174,
+       200, 191, 147, 242, 245, 104, 163, 204, 156, 124, 83, 129, 105,
+       26, 189, 181, 170, 227, 224, 194, 144, 91, 236, 230, 40, 40, 106,
+       239, 29, 156, 3, 117, 253, 69, 42, 222, 165, 166, 185, 169, 145,
+       204, 205, 189, 67, 30, 254, 144, 27, 144, 156, 84, 42, 201, 9, 51,
+       21, 210, 124, 242, 80, 77, 10, 255, 252, 85, 8, 215, 242, 214,
+       172, 174, 81, 132, 112, 237, 198, 112, 191, 150, 18, 16, 61, 215,
+       111, 105, 214, 125, 155, 40, 127, 173, 98, 95, 11, 254, 133, 133,
+       81, 244, 106, 237, 12, 141, 191, 141, 242, 64, 35, 208, 210, 195,
+       16, 243, 124, 17, 235, 201, 102, 120, 155, 61, 206, 255, 172, 143,
+       123, 222, 89, 140, 109, 248, 70, 63, 25, 127, 232, 183, 223, 223,
+       245, 13, 108, 244, 47, 95, 61, 183, 56, 254, 185, 151, 117, 157,
+       187, 112, 252, 251, 223, 175, 210, 247, 159, 247, 243, 2, 93, 155,
+       188, 116, 198, 181, 119, 190, 9, 90, 101, 180, 191, 33, 64, 198,
+       59, 19, 1, 227, 137, 18, 127, 101, 54, 62, 138, 24, 16, 33, 187,
+       90, 185, 176, 176, 187, 221, 50, 199, 171, 253, 142, 41, 142, 190,
+       70, 150, 167, 119, 253, 81, 22, 73, 146, 242, 251, 85, 29, 255,
+       130, 4, 143, 95, 15, 216, 245, 247, 53, 156, 126, 189, 251, 218,
+       52, 161, 237, 127, 255, 117, 247, 115, 157, 141, 228, 108, 46,
+       255, 235, 223, 255, 226, 150, 164, 5, 127, 150, 231, 140, 51, 139,
+       89, 28, 173, 135, 247, 141, 181, 199, 230, 74, 87, 3, 66, 232, 38,
+       126, 69, 239, 177, 170, 210, 205, 127, 186, 254, 140, 86, 53, 219,
+       93, 175, 74, 15, 54, 216, 42, 114, 41, 207, 127, 99, 43, 144, 55,
+       73, 194, 102, 71, 16, 93, 113, 118, 37, 65, 52, 63, 255, 11, 144,
+       63, 248, 121, 65, 61, 223, 219, 253, 79, 236, 180, 14, 154, 29,
+       214, 164, 158, 144, 223, 125, 207, 171, 116, 157, 171, 221, 5,
+       246, 255, 142, 218, 119, 114, 154, 190, 216, 111, 228, 177, 67,
+       203, 29, 182, 51, 44, 159, 38, 111, 231, 179, 255, 17, 130, 111,
+       146, 209, 211, 58, 90, 219, 135, 12, 101, 107, 56, 136, 246, 227,
+       231, 98, 80, 198, 81, 51, 226, 3, 11, 59, 36, 219, 235, 222, 161,
+       16, 8, 251, 17, 160, 219, 219, 84, 71, 231, 217, 124, 138, 52,
+       233, 1, 170, 93, 201, 194, 232, 135, 128, 224, 10, 34, 194, 101,
+       0, 248, 232, 74, 211, 74, 43, 218, 125, 189, 128, 135, 123, 81,
+       27, 114, 130, 131, 79, 23, 221, 124, 143, 172, 230, 188, 136, 114,
+       98, 180, 250, 181, 64, 238, 123, 127, 193, 97, 220, 2, 111, 44,
+       62, 63, 192, 68, 48, 33, 169, 202, 168, 164, 155, 155, 156, 184,
+       134, 187, 19, 4, 17, 172, 255, 82, 202, 163, 123, 251, 21, 54, 76,
+       222, 243, 207, 87, 94, 107, 130, 4, 143, 206, 27, 137, 252, 236,
+       53, 150, 216, 47, 91, 224, 188, 139, 63, 189, 52, 164, 158, 183,
+       181, 77, 138, 107, 54, 221, 203, 217, 136, 123, 87, 132, 75, 47,
+       22, 100, 247, 254, 158, 171, 238, 105, 255, 163, 251, 155, 239,
+       233, 61, 128, 251, 245, 123, 227, 104, 167, 205, 255, 181, 254,
+       143, 42, 229, 251, 227, 132, 210, 4, 86, 253, 6, 2, 104, 110, 61,
+       19, 195, 18, 39, 10, 60, 89, 106, 129, 10, 161, 56, 151, 65, 95,
+       144, 162, 218, 1, 53, 0, 112, 0, 92, 251, 252, 103, 100, 80, 243,
+       156, 98, 188, 150, 34, 57, 29, 211, 106, 42, 212, 253, 218, 138,
+       112, 175, 225, 79, 201, 231, 133, 39, 179, 116, 235, 43, 182, 170,
+       155, 87, 241, 176, 71, 94, 71, 92, 183, 168, 140, 190, 140, 255,
+       43, 147, 21, 183, 190, 54, 215, 78, 87, 154, 235, 159, 76, 255,
+       222, 127, 49, 193, 175, 150, 114, 74, 25, 112, 192, 203, 226, 213,
+       126, 145, 224, 82, 172, 21, 181, 189, 130, 245, 138, 172, 109,
+       175, 202, 173, 231, 240, 213, 19, 158, 234, 221, 54, 130, 250,
+       230, 63, 7, 90, 183, 32, 170, 182, 96, 255, 255, 19, 129, 182,
+       157, 149, 239, 122, 62, 154, 195, 157, 128, 120, 29, 32, 179, 156,
+       156, 93, 79, 65, 59, 26, 253, 244, 14, 226, 224, 66, 24, 89, 236,
+       102, 33, 9, 234, 251, 93, 157, 130, 245, 252, 89, 40, 218, 202,
+       254, 38, 192, 174, 139, 52, 90, 200, 147, 151, 129, 155, 79, 234,
+       95, 159, 223, 197, 237, 247, 62, 71, 206, 194, 146, 209, 201, 191,
+       167, 117, 62, 68, 212, 221, 175, 222, 145, 102, 7, 253, 150, 202,
+       141, 82, 242, 247, 41, 97, 113, 114, 29, 234, 121, 69, 58, 47,
+       249, 134, 229, 156, 160, 115, 180, 115, 173, 149, 60, 107, 157,
+       207, 209, 189, 70, 121, 177, 31, 211, 57, 30, 1, 217, 2, 89, 49,
+       191, 40, 121, 151, 105, 219, 149, 117, 217, 10, 208, 210, 237,
+       121, 107, 78, 68, 132, 107, 240, 96, 192, 228, 142, 50, 221, 103,
+       112, 124, 252, 18, 206, 201, 154, 188, 110, 115, 45, 128, 40, 41,
+       163, 114, 248, 29, 135, 18, 169, 244, 163, 34, 248, 6, 1, 89, 98,
+       197, 243, 168, 192, 255, 110, 6, 57, 18, 144, 9, 157, 172, 231,
+       175, 196, 188, 234, 57, 129, 47, 80, 253, 245, 102, 86, 89, 152,
+       203, 216, 52, 230, 253, 95, 159, 251, 150, 181, 181, 239, 197,
+       240, 126, 216, 70, 219, 235, 134, 63, 182, 88, 245, 187, 65, 99,
+       204, 70, 18, 235, 64, 133, 192, 214, 130, 121, 205, 181, 164, 126,
+       172, 91, 237, 193, 163, 52, 200, 82, 105, 138, 136, 103, 174, 112,
+       244, 208, 178, 141, 149, 9, 206, 97, 56, 190, 221, 150, 68, 230,
+       230, 74, 209, 113, 229, 236, 144, 9, 212, 187, 93, 153, 162, 239,
+       196, 8, 32, 47, 123, 124, 105, 219, 164, 36, 90, 90, 208, 35, 224,
+       186, 239, 79, 139, 83, 146, 186, 237, 237, 214, 12, 51, 201, 128,
+       242, 197, 37, 53, 231, 183, 106, 66, 180, 41, 2, 232, 29, 195,
+       194, 72, 69, 128, 225, 11, 3, 217, 49, 0, 248, 168, 3, 243, 12,
+       167, 80, 156, 147, 192, 131, 123, 113, 11, 118, 130, 14, 158, 158,
+       186, 234, 176, 20, 239, 158, 159, 92, 245, 236, 242, 226, 219,
+       131, 99, 237, 17, 54, 73, 138, 113, 232, 115, 127, 203, 148, 85,
+       169, 139, 145, 46, 74, 237, 86, 3, 234, 122, 116, 160, 250, 198,
+       179, 129, 177, 128, 122, 172, 6, 237, 41, 178, 69, 78, 148, 172,
+       171, 128, 109, 168, 121, 136, 162, 255, 54, 126, 25, 141, 20, 230,
+       159, 21, 136, 9, 174, 233, 36, 1, 204, 115, 235, 67, 122, 235, 82,
+       189, 43, 242, 92, 123, 80, 25, 150, 138, 216, 201, 30, 190, 9,
+       199, 84, 228, 181, 150, 160, 25, 111, 223, 33, 219, 192, 241, 233,
+       98, 108, 79, 18, 172, 251, 243, 79, 27, 50, 57, 45, 10, 108, 112,
+       149, 99, 9, 125, 80, 8, 131, 49, 165, 24, 218, 83, 73, 158, 129,
+       148, 249, 24, 11, 101, 219, 144, 207, 219, 17, 119, 218, 79, 74,
+       34, 41, 22, 97, 105, 100, 62, 205, 17, 81, 206, 125, 246, 155, 13,
+       151, 237, 94, 188, 150, 44, 185, 182, 100, 142, 70, 217, 160, 128,
+       127, 254, 122, 245, 44, 1, 191, 228, 197, 118, 65, 71, 197, 69,
+       230, 0, 82, 189, 50, 106, 216, 212, 51, 56, 24, 187, 48, 128, 91,
+       255, 208, 69, 243, 105, 244, 226, 2, 120, 186, 153, 46, 217, 185,
+       80, 223, 228, 118, 174, 188, 150, 227, 108, 166, 57, 254, 82, 131,
+       149, 55, 240, 197, 145, 11, 49, 20, 25, 5, 247, 147, 94, 103, 135,
+       2, 22, 171, 176, 108, 66, 82, 230, 253, 46, 183, 101, 102, 245,
+       63, 207, 229, 156, 53, 237, 148, 42, 234, 130, 45, 183, 49, 125,
+       203, 109, 116, 125, 171, 50, 254, 63, 245, 130, 62, 144, 153, 191,
+       149, 111, 7, 119, 125, 174, 240, 76, 231, 234, 103, 255, 223, 137,
+       231, 245, 193, 172, 125, 76, 231, 207, 143, 118, 239, 216, 197,
+       194, 255, 2, 89, 237, 191, 238, 120, 228, 59, 238, 132, 177, 45,
+       200, 83, 111, 231, 132, 231, 255, 112, 224, 74, 187, 182, 18, 187,
+       217, 48, 135, 171, 189, 138, 169, 140, 158, 70, 150, 167, 119,
+       233, 81, 22, 89, 138, 241, 175, 84, 31, 251, 130, 6, 143, 95, 188,
+       122, 250, 225, 229, 87, 255, 208, 5, 42, 180, 18, 25, 31, 243, 42,
+       238, 209, 151, 248, 136, 183, 48, 226, 215, 205, 171, 165, 175,
+       185, 120, 179, 209, 193, 12, 175, 12, 6, 77, 189, 20, 86, 195, 23,
+       247, 73, 58, 65, 216, 130, 57, 111, 236, 5, 91, 31, 225, 227, 226,
+       20, 56, 26, 176, 10, 11, 146, 252, 228, 52, 214, 217, 63, 91, 109,
+       60, 172, 191, 189, 150, 164, 150, 29, 181, 141, 159, 106, 38, 213,
+       203, 93, 58, 218, 79, 132, 79, 127, 58, 187, 240, 221, 115, 210,
+       249, 87, 43, 205, 116, 167, 44, 63, 166, 180, 238, 189, 151, 208,
+       148, 250, 224, 200, 159, 121, 154, 163, 103, 132, 47, 255, 2, 52,
+       241, 241, 54, 174, 184, 18, 91, 187, 89, 115, 140, 189, 84, 8,
+       143, 27, 149, 145, 146, 252, 195, 194, 14, 93, 155, 226, 134, 197,
+       19, 147, 0, 144, 191, 217, 177, 236, 185, 23, 190, 95, 86, 84,
+       156, 247, 36, 104, 167, 27, 187, 16, 147, 136, 50, 87, 77, 191,
+       122, 194, 144, 64, 165, 243, 218, 176, 190, 240, 11, 241, 16, 15,
+       175, 151, 135, 49, 174, 158, 98, 107, 227, 51, 237, 1, 30, 77, 51,
+       209, 147, 211, 90, 27, 18, 68, 45, 78, 167, 151, 131, 5, 148, 43,
+       175, 187, 22, 234, 90, 245, 209, 101, 189, 69, 93, 70, 43, 174,
+       241, 224, 93, 30, 44, 14, 231, 132, 205, 254, 208, 240, 112, 104,
+       144, 170, 93, 201, 130, 72, 135, 132, 224, 11, 34, 192, 101, 16,
+       248, 168, 74, 208, 14, 39, 210, 184, 145, 148, 131, 123, 81, 11,
+       118, 142, 11, 8, 84, 187, 54, 170, 233, 3, 31, 17, 81, 146, 173,
+       3, 48, 205, 99, 43, 31, 153, 3, 156, 69, 253, 132, 242, 154, 192,
+       189, 9, 41, 168, 100, 251, 146, 82, 29, 133, 66, 160, 202, 140,
+       169, 72, 226, 209, 77, 18, 192, 96, 104, 82, 74, 107, 218, 33, 59,
+       20, 133, 123, 72, 11, 84, 10, 179, 16, 105, 221, 86, 7, 208, 91,
+       27, 201, 240, 127, 48, 28, 20, 57, 220, 185, 23, 133, 185, 250,
+       240, 220, 23, 56, 210, 234, 125, 8, 242, 247, 221, 205, 146, 182,
+       186, 34, 94, 172, 185, 130, 139, 0, 223, 226, 73, 83, 51, 231,
+       108, 235, 108, 69, 138, 110, 248, 231, 79, 28, 172, 115, 169, 0,
+       223, 104, 130, 166, 13, 80, 186, 128, 169, 210, 130, 131, 172,
+       218, 115, 230, 224, 101, 249, 199, 77, 71, 134, 234, 146, 113,
+       203, 27, 14, 55, 57, 78, 3, 169, 81, 177, 214, 169, 168, 199, 174,
+       17, 88, 66, 188, 218, 112, 0, 59, 59, 2, 145, 18, 24, 18, 245,
+       173, 20, 154, 104, 157, 0, 129, 138, 140, 209, 251, 123, 160, 200,
+       165, 133, 126, 21, 98, 48, 149, 211, 105, 121, 82, 26, 34, 88, 66,
+       240, 127, 49, 101, 169, 54, 64, 148, 16, 197, 170, 80, 124, 105,
+       117, 20, 206, 241, 55, 112, 164, 242, 8, 179, 25, 80, 33, 34, 188,
+       93, 169, 200, 248, 245, 12, 197, 169, 186, 16, 100, 128, 71, 234,
+       173, 200, 112, 227, 197, 28, 254, 228, 121, 34, 166, 26, 159, 25,
+       61, 229, 106, 211, 155, 251, 120, 58, 124, 234, 255, 217, 134, 65,
+       247, 191, 241, 32, 11, 147, 253, 228, 53, 222, 89, 63, 75, 205,
+       60, 230, 125, 255, 214, 36, 150, 179, 149, 141, 135, 104, 54, 221,
+       235, 221, 175, 242, 143, 132, 85, 125, 80, 160, 133, 149, 74, 138,
+       96, 41, 186, 148, 162, 10, 102, 226, 72, 82, 49, 229, 104, 128,
+       10, 210, 139, 93, 157, 162, 199, 68, 33, 32, 99, 10, 11, 221, 19,
+       187, 215, 132, 191, 245, 92, 73, 88, 118, 188, 210, 32, 228, 119,
+       123, 146, 219, 243, 152, 26, 255, 45, 126, 30, 194, 30, 22, 169,
+       189, 135, 178, 191, 217, 96, 236, 185, 210, 190, 91, 85, 116, 156,
+       223, 238, 107, 199, 27, 55, 28, 163, 84, 34, 209, 71, 27, 122,
+       206, 144, 193, 37, 243, 35, 1, 103, 73, 245, 211, 170, 238, 205,
+       65, 250, 162, 104, 88, 180, 229, 122, 34, 178, 252, 151, 184, 101,
+       253, 46, 58, 130, 194, 87, 140, 249, 140, 216, 217, 23, 238, 59,
+       192, 85, 181, 161, 28, 222, 32, 126, 247, 32, 215, 64, 246, 173,
+       194, 74, 11, 234, 253, 243, 176, 238, 155, 50, 50, 164, 59, 43,
+       146, 253, 220, 117, 255, 216, 63, 27, 255, 53, 125, 250, 253, 190,
+       61, 159, 181, 181, 1, 174, 107, 58, 221, 75, 95, 121, 187, 87,
+       236, 86, 127, 75, 28, 241, 244, 180, 188, 88, 146, 251, 201, 188,
+       161, 173, 127, 215, 126, 167, 243, 189, 149, 180, 73, 166, 235,
+       223, 95, 127, 250, 134, 229, 5, 127, 81, 193, 235, 97, 150, 86,
+       239, 188, 70, 225, 94, 134, 81, 44, 178, 96, 54, 197, 52, 253,
+       213, 152, 53, 12, 233, 45, 175, 196, 45, 146, 185, 120, 111, 18,
+       252, 116, 111, 82, 89, 24, 203, 222, 52, 231, 93, 223, 223, 58,
+       150, 61, 181, 165, 133, 208, 174, 216, 66, 219, 233, 135, 175,
+       167, 78, 87, 253, 237, 122, 238, 27, 151, 95, 236, 133, 0, 236,
+       136, 127, 223, 43, 116, 94, 249, 221, 110, 106, 35, 124, 191, 243,
+       217, 1, 61, 118, 191, 102, 98, 24, 129, 139, 233, 87, 203, 104,
+       89, 87, 1, 65, 19, 83, 203, 56, 200, 248, 137, 3, 241, 26, 176,
+       17, 147, 215, 229, 178, 69, 181, 136, 244, 130, 186, 69, 101, 245,
+       71, 32, 236, 55, 65, 186, 122, 82, 105, 11, 21, 211, 107, 231, 53,
+       170, 104, 244, 65, 203, 39, 234, 199, 128, 103, 241, 242, 130, 70,
+       252, 190, 154, 235, 229, 158, 206, 139, 91, 152, 43, 12, 254, 109,
+       10, 237, 83, 211, 211, 134, 67, 154, 240, 59, 16, 207, 191, 152,
+       127, 175, 215, 189, 97, 107, 232, 124, 83, 219, 216, 197, 244,
+       244, 171, 27, 205, 255, 243, 126, 204, 215, 255, 222, 179, 164,
+       140, 250, 201, 167, 252, 119, 191, 126, 240, 39, 255, 232, 90,
+       242, 241, 187, 214, 90, 77, 252, 230, 48, 108, 247, 52, 95, 123,
+       22, 94, 135, 170, 236, 251, 118, 60, 164, 170, 221, 251, 118, 221,
+       47, 20, 241, 242, 244, 60, 216, 19, 27, 91, 185, 251, 206, 125,
+       221, 46, 223, 147, 215, 149, 190, 102, 110, 194, 79, 94, 218, 190,
+       199, 237, 83, 119, 54, 132, 67, 252, 213, 99, 230, 224, 81, 2,
+       240, 75, 67, 104, 61, 17, 249, 168, 2, 164, 44, 179, 16, 206, 177,
+       206, 199, 12, 253, 120, 114, 142, 75, 159, 249, 208, 245, 220,
+       255, 183, 217, 125, 60, 174, 189, 127, 183, 166, 255, 243, 151,
+       173, 245, 40, 52, 205, 255, 223, 238, 238, 151, 252, 197, 127, 35,
+       217, 51, 76, 125, 149, 177, 127, 200, 72, 248, 76, 52, 252, 165,
+       48, 204, 59, 23, 1, 131, 43, 114, 221, 53, 30, 56, 170, 88, 24,
+       114, 191, 238, 253, 58, 218, 253, 213, 159, 252, 139, 92, 156, 43,
+       92, 220, 126, 35, 143, 243, 213, 115, 178, 99, 58, 253, 123, 89,
+       143, 255, 215, 23, 183, 119, 206, 100, 224, 209, 199, 184, 124,
+       143, 219, 179, 30, 83, 73, 75, 93, 235, 51, 247, 61, 190, 178, 84,
+       207, 211, 39, 125, 143, 165, 167, 245, 216, 2, 23, 76, 70, 193,
+       22, 167, 170, 82, 180, 128, 222, 194, 189, 195, 33, 228, 110, 180,
+       27, 157, 145, 153, 21, 252, 152, 4, 139, 64, 167, 169, 57, 160,
+       22, 160, 2, 233, 149, 231, 193, 73, 95, 37, 209, 18, 75, 202, 44,
+       192, 249, 153, 7, 177, 26, 179, 25, 215, 145, 132, 139, 71, 177,
+       8, 253, 130, 61, 65, 106, 231, 55, 82, 127, 120, 113, 224, 255,
+       130, 91, 95, 155, 244, 126, 220, 149, 238, 232, 176, 125, 206,
+       243, 237, 167, 133, 103, 183, 104, 112, 56, 249, 56, 105, 56, 201,
+       51, 255, 46, 5, 108, 40, 183, 151, 66, 16, 145, 26, 195, 80, 82,
+       56, 211, 53, 239, 197, 52, 121, 80, 8, 207, 171, 38, 49, 18, 140,
+       105, 209, 144, 72, 139, 68, 248, 173, 12, 236, 110, 150, 222, 41,
+       202, 101, 23, 35, 146, 209, 16, 20, 11, 59, 216, 47, 110, 215, 16,
+       125, 91, 236, 82, 193, 19, 71, 6, 4, 76, 171, 53, 151, 33, 16, 62,
+       187, 131, 192, 74, 155, 16, 61, 113, 165, 40, 41, 53, 26, 36, 122,
+       17, 173, 26, 179, 214, 172, 162, 231, 126, 41, 74, 66, 181, 50,
+       64, 64, 105, 43, 34, 24, 19, 152, 129, 118, 188, 164, 58, 64, 168,
+       8, 161, 168, 39, 125, 67, 69, 214, 22, 238, 121, 81, 232, 120,
+       198, 88, 104, 149, 164, 62, 236, 18, 239, 229, 176, 61, 206, 46,
+       44, 165, 132, 111, 254, 122, 156, 42, 165, 82, 200, 221, 183, 210,
+       111, 207, 1, 232, 10, 10, 216, 108, 148, 248, 138, 130, 144, 30,
+       171, 18, 213, 27, 28, 129, 127, 211, 14, 252, 134, 242, 87, 43,
+       136, 106, 119, 17, 87, 4, 76, 252, 255, 22, 22, 162, 80, 236, 128,
+       206, 37, 205, 7, 113, 94, 240, 33, 42, 159, 24, 13, 36, 87, 225,
+       78, 59, 127, 52, 174, 107, 55, 117, 79, 254, 116, 243, 41, 150,
+       112, 212, 174, 44, 12, 173, 188, 101, 47, 102, 254, 48, 128, 192,
+       128, 192, 105, 45, 248, 156, 190, 184, 133, 159, 190, 158, 223, 4,
+       8, 244, 245, 106, 43, 197, 115, 123, 91, 115, 74, 250, 49, 233,
+       23, 127, 248, 144, 121, 133, 123, 181, 125, 99, 1, 244, 151, 238,
+       248, 84, 224, 248, 70, 80, 88, 189, 165, 120, 232, 22, 255, 237,
+       178, 60, 238, 62, 8, 167, 164, 125, 255, 122, 180, 0, 255, 153,
+       145, 240, 172, 165, 55, 62, 59, 90, 240, 188, 54, 68, 96, 167, 27,
+       63, 17, 211, 216, 81, 103, 45, 22, 62, 192, 128, 80, 129, 185, 97,
+       142, 125, 127, 48, 143, 75, 55, 127, 105, 123, 116, 243, 35, 148,
+       112, 215, 46, 44, 12, 255, 252, 97, 63, 78, 190, 48, 144, 80, 128,
+       192, 105, 64, 37, 223, 173, 92, 107, 233, 27, 62, 161, 251, 82,
+       181, 163, 0, 64, 123, 174, 42, 137, 17, 248, 193, 31, 204, 231,
+       59, 0, 157, 104, 33, 168, 173, 185, 126, 217, 246, 139, 107, 241,
+       21, 0, 118, 230, 49, 87, 177, 33, 126, 186, 23, 252, 243, 186,
+       113, 63, 126, 143, 164, 192, 63, 136, 112, 185, 242, 101, 100,
+       245, 231, 43, 252, 15, 203, 162, 58, 155, 41, 235, 85, 127, 35,
+       245, 53, 171, 224, 100, 134, 202, 38, 216, 205, 165, 47, 253, 216,
+       6, 202, 147, 83, 222, 203, 208, 180, 109, 157, 81, 241, 242, 108,
+       254, 172, 245, 102, 179, 162, 128, 119, 11, 6, 213, 54, 114, 218,
+       203, 31, 4, 173, 159, 159, 73, 106, 202, 102, 145, 250, 192, 204,
+       16, 87, 130, 189, 222, 191, 96, 110, 185, 183, 223, 202, 182, 46,
+       241, 215, 105, 170, 137, 54, 159, 57, 104, 127, 217, 121, 254,
+       173, 212, 159, 188, 155, 89, 156, 237, 124, 253, 190, 49, 150,
+       211, 181, 231, 207, 3, 58, 245, 243, 127, 109, 250, 31, 183, 151,
+       119, 215, 161, 173, 55, 174, 107, 165, 169, 122, 243, 3, 56, 214,
+       124, 201, 43, 131, 71, 124, 35, 49, 208, 239, 0, 141, 2, 125, 55,
+       132, 112, 149, 103, 137, 196, 121, 67, 114, 11, 111, 182, 125, 98,
+       118, 244, 147, 3, 152, 53, 22, 10, 22, 110, 227, 188, 101, 63,
+       100, 136, 48, 196, 110, 152, 194, 249, 56, 165, 16, 170, 197, 205,
+       22, 107, 15, 37, 169, 9, 14, 219, 40, 144, 153, 155, 134, 1, 94,
+       58, 88, 149, 187, 213, 1, 127, 82, 14, 143, 130, 188, 111, 107,
+       68, 86, 75, 239, 124, 113, 164, 116, 10, 19, 1, 209, 52, 58, 252,
+       22, 234, 233, 178, 188, 78, 119, 140, 165, 164, 103, 187, 86, 224,
+       93, 36, 185, 225, 141, 127, 81, 27, 202, 251, 31, 24, 214, 189,
+       74, 42, 145, 20, 124, 59, 152, 112, 251, 16, 219, 223, 113, 119,
+       208, 107, 85, 99, 93, 48, 189, 98, 143, 127, 81, 24, 202, 250, 15,
+       24, 214, 188, 67, 42, 129, 85, 124, 19, 29, 117, 249, 0, 219, 207,
+       113, 54, 224, 107, 83, 99, 240, 109, 66, 174, 93, 199, 66, 224,
+       133, 4, 232, 11, 99, 200, 39, 80, 248, 232, 74, 227, 44, 43, 24,
+       191, 177, 196, 129, 59, 113, 43, 124, 10, 4, 32, 222, 151, 116,
+       171, 233, 64, 62, 55, 227, 146, 220, 202, 28, 72, 187, 45, 106,
+       143, 2, 244, 219, 213, 20, 54, 218, 64, 12, 11, 97, 128, 100, 233,
+       215, 154, 77, 201, 102, 204, 238, 53, 226, 10, 174, 130, 113, 204,
+       104, 205, 106, 211, 66, 251, 171, 241, 181, 128, 215, 121, 129,
+       27, 237, 42, 182, 90, 215, 183, 7, 102, 193, 224, 121, 158, 242,
+       70, 98, 106, 13, 143, 121, 193, 6, 210, 9, 246, 81, 232, 153, 130,
+       230, 130, 105, 121, 118, 128, 40, 108, 3, 88, 209, 245, 37, 199,
+       118, 7, 108, 0, 186, 179, 97, 184, 137, 58, 130, 24, 2, 26, 50,
+       59, 111, 215, 20, 41, 210, 80, 102, 170, 103, 73, 172, 226, 236,
+       39, 222, 196, 27, 57, 153, 107, 92, 61, 29, 139, 157, 215, 87, 87,
+       144, 99, 9, 224, 48, 26, 253, 246, 205, 123, 219, 33, 19, 68, 103,
+       69, 6, 95, 239, 116, 84, 226, 210, 66, 81, 60, 149, 175, 56, 228,
+       50, 235, 233, 245, 53, 204, 52, 10, 207, 4, 101, 252, 112, 236,
+       72, 233, 212, 155, 205, 59, 236, 231, 30, 53, 234, 2, 141, 162,
+       82, 201, 106, 207, 42, 211, 84, 248, 211, 240, 60, 161, 222, 65,
+       149, 88, 137, 138, 147, 27, 227, 143, 114, 18, 171, 240, 61, 64,
+       91, 231, 125, 238, 191, 100, 118, 237, 23, 239, 165, 144, 37, 238,
+       52, 44, 170, 128, 45, 183, 33, 253, 189, 93, 123, 238, 116, 86,
+       95, 252, 85, 198, 254, 38, 91, 119, 187, 49, 126, 244, 151, 234,
+       233, 163, 57, 174, 115, 239, 165, 20, 127, 251, 100, 241, 7, 124,
+       90, 211, 54, 171, 186, 82, 172, 131, 223, 226, 156, 147, 225, 236,
+       103, 61, 27, 158, 129, 149, 0, 254, 156, 30, 139, 192, 142, 147,
+       41, 161, 136, 234, 145, 179, 69, 144, 168, 198, 126, 49, 82, 82,
+       141, 130, 80, 200, 107, 15, 162, 152, 18, 124, 131, 224, 12, 241,
+       186, 69, 134, 5, 161, 136, 0, 24, 57, 253, 118, 236, 185, 55, 60,
+       73, 90, 115, 188, 159, 36, 96, 230, 59, 55, 129, 131, 184, 82, 87,
+       69, 60, 58, 192, 84, 8, 5, 187, 2, 146, 186, 241, 116, 172, 185,
+       7, 63, 9, 83, 113, 156, 158, 60, 72, 247, 27, 63, 17, 146, 152, 3,
+       193, 13, 60, 58, 194, 132, 8, 145, 147, 79, 249, 52, 246, 254,
+       132, 159, 244, 138, 57, 153, 234, 124, 127, 12, 130, 175, 211,
+       223, 243, 144, 67, 138, 229, 57, 30, 235, 250, 141, 55, 163, 177,
+       15, 140, 248, 247, 180, 156, 126, 187, 123, 202, 190, 161, 239,
+       127, 157, 116, 247, 243, 157, 143, 254, 108, 45, 239, 238, 255,
+       223, 198, 167, 228, 97, 111, 78, 30, 182, 181, 171, 60, 188, 134,
+       175, 255, 154, 165, 204, 254, 71, 202, 167, 119, 253, 21, 132, 65,
+       147, 224, 135, 119, 95, 147, 142, 117, 13, 95, 137, 10, 115, 49,
+       180, 190, 105, 23, 125, 79, 118, 116, 175, 2, 147, 252, 119, 46,
+       38, 28, 183, 188, 37, 238, 134, 254, 50, 192, 170, 132, 97, 237,
+       74, 188, 182, 152, 57, 253, 49, 99, 175, 85, 44, 169, 174, 254,
+       102, 180, 135, 51, 235, 17, 6, 9, 178, 215, 223, 119, 27, 123,
+       146, 68, 15, 126, 31, 248, 117, 229, 39, 86, 88, 184, 235, 216,
+       20, 230, 255, 93, 215, 167, 182, 253, 181, 239, 197, 224, 190,
+       221, 195, 217, 105, 134, 111, 180, 89, 85, 67, 235, 21, 155, 60,
+       141, 168, 166, 174, 24, 16, 96, 188, 170, 213, 67, 199, 123, 123,
+       221, 66, 72, 195, 253, 44, 26, 254, 232, 148, 0, 17, 169, 8, 150,
+       40, 187, 53, 245, 16, 23, 22, 13, 93, 49, 174, 255, 42, 192, 193,
+       58, 157, 17, 26, 136, 67, 151, 203, 247, 186, 203, 146, 14, 189,
+       107, 201, 125, 183, 117, 165, 15, 101, 183, 248, 250, 34, 108,
+       150, 48, 65, 59, 133, 118, 124, 17, 233, 253, 241, 10, 237, 146,
+       85, 22, 200, 120, 83, 59, 242, 104, 134, 191, 74, 171, 54, 196,
+       182, 162, 194, 227, 224, 194, 65, 72, 232, 236, 106, 194, 68, 221,
+       203, 122, 188, 32, 95, 51, 16, 123, 36, 138, 230, 33, 212, 211,
+       237, 40, 236, 1, 123, 179, 179, 27, 207, 9, 93, 203, 235, 135,
+       107, 145, 50, 116, 203, 192, 156, 184, 223, 38, 133, 105, 241, 6,
+       56, 159, 58, 236, 245, 247, 81, 115, 85, 76, 252, 47, 107, 253,
+       182, 208, 220, 170, 151, 160, 157, 186, 112, 157, 251, 253, 161,
+       235, 91, 110, 126, 211, 71, 249, 57, 222, 250, 165, 158, 196, 139,
+       41, 153, 235, 124, 94, 12, 128, 182, 115, 127, 211, 130, 3, 8,
+       229, 49, 28, 47, 250, 4, 19, 163, 51, 70, 190, 133, 19, 235, 105,
+       165, 143, 158, 247, 2, 252, 140, 164, 204, 175, 135, 87, 234, 21,
+       179, 88, 251, 97, 45, 22, 93, 246, 192, 92, 133, 252, 91, 67, 215,
+       166, 39, 20, 94, 116, 161, 140, 219, 107, 111, 234, 209, 210, 238,
+       229, 125, 231, 77, 147, 129, 200, 178, 237, 238, 146, 39, 182, 43,
+       9, 31, 90, 116, 244, 38, 158, 88, 152, 91, 216, 52, 231, 127, 95,
+       223, 171, 182, 241, 181, 239, 165, 112, 62, 200, 194, 219, 237,
+       134, 47, 180, 73, 85, 75, 49, 243, 78, 115, 252, 113, 83, 107, 73,
+       125, 32, 60, 159, 166, 254, 166, 187, 149, 16, 147, 11, 178, 193,
+       19, 124, 16, 171, 130, 198, 231, 255, 214, 205, 151, 182, 146,
+       170, 110, 174, 187, 146, 138, 80, 102, 98, 25, 83, 51, 231, 104,
+       227, 120, 69, 137, 111, 184, 166, 207, 4, 160, 115, 163, 0, 41,
+       108, 165, 117, 221, 47, 233, 159, 82, 187, 112, 72, 147, 41, 81,
+       171, 217, 76, 18, 185, 171, 126, 209, 24, 109, 207, 255, 100, 201,
+       120, 83, 168, 240, 22, 151, 181, 160, 98, 84, 119, 49, 155, 242,
+       117, 70, 41, 128, 93, 241, 222, 164, 32, 189, 254, 1, 138, 176,
+       246, 246, 135, 136, 112, 188, 19, 18, 157, 58, 156, 83, 208, 185,
+       103, 156, 5, 72, 163, 44, 158, 38, 64, 230, 59, 147, 129, 86, 139,
+       34, 255, 113, 38, 154, 11, 21, 4, 173, 222, 65, 237, 20, 181, 236,
+       128, 172, 166, 254, 18, 66, 194, 165, 162, 208, 195, 99, 111, 42,
+       218, 82, 88, 207, 117, 44, 162, 223, 64, 4, 145, 161, 136, 168,
+       237, 124, 123, 252, 203, 101, 247, 209, 28, 100, 56, 51, 81, 160,
+       51, 201, 186, 6, 120, 122, 254, 98, 63, 111, 201, 116, 105, 114,
+       136, 214, 234, 64, 164, 156, 177, 141, 237, 17, 143, 30, 247, 142,
+       25, 150, 49, 74, 11, 129, 7, 121, 17, 58, 72, 211, 17, 205, 195,
+       95, 125, 128, 72, 157, 66, 129, 227, 135, 159, 64, 140, 36, 173,
+       254, 17, 74, 214, 225, 226, 172, 101, 120, 74, 106, 110, 230, 240,
+       207, 125, 36, 34, 198, 0, 104, 26, 225, 140, 207, 222, 241, 178,
+       116, 156, 250, 176, 217, 122, 48, 255, 253, 126, 191, 255, 255,
+       225, 31, 239, 167, 116, 44, 239, 158, 218, 239, 172, 31, 189, 73,
+       93, 239, 180, 133, 19, 201, 61, 136, 11, 251, 251, 129, 93, 140,
+       204, 92, 191, 141, 139, 234, 31, 247, 70, 219, 209, 141, 16, 223,
+       126, 202, 68, 155, 150, 96, 186, 175, 124, 104, 197, 145, 30, 134,
+       252, 52, 45, 113, 205, 246, 34, 133, 124, 121, 0, 134, 105, 250,
+       17, 79, 11, 117, 185, 80, 8, 84, 251, 21, 133, 83, 77, 178, 163,
+       15, 185, 54, 160, 203, 196, 215, 98, 168, 96, 87, 74, 30, 110,
+       217, 145, 125, 31, 168, 174, 37, 68, 60, 235, 160, 53, 63, 120,
+       115, 185, 63, 225, 107, 82, 159, 236, 240, 166, 157, 158, 99, 108,
+       222, 41, 30, 83, 139, 183, 114, 240, 145, 208, 2, 186, 54, 13, 36,
+       117, 16, 183, 142, 147, 151, 78, 225, 247, 44, 221, 158, 70, 174,
+       98, 74, 130, 105, 131, 78, 156, 27, 233, 17, 228, 184, 6, 190,
+       209, 169, 106, 173, 120, 27, 115, 107, 197, 114, 19, 235, 220,
+       101, 64, 94, 230, 121, 70, 159, 36, 62, 201, 23, 254, 129, 176,
+       37, 204, 118, 12, 170, 128, 111, 151, 41, 253, 19, 13, 106, 203,
+       245, 215, 255, 103, 205, 77, 92, 6, 40, 156, 182, 36, 238, 171,
+       151, 157, 212, 185, 52, 252, 47, 92, 158, 195, 215, 142, 253, 223,
+       235, 180, 164, 26, 205, 181, 216, 175, 203, 119, 173, 29, 168,
+       232, 94, 191, 201, 131, 250, 21, 182, 111, 250, 243, 31, 90, 222,
+       127, 218, 76, 218, 222, 105, 105, 251, 76, 86, 132, 171, 84, 98,
+       192, 100, 138, 49, 221, 115, 112, 126, 252, 18, 78, 193, 186, 188,
+       122, 119, 45, 3, 40, 87, 187, 98, 248, 189, 85, 127, 110, 108, 87,
+       87, 120, 229, 198, 255, 46, 91, 125, 191, 54, 254, 244, 215, 234,
+       201, 167, 58, 174, 243, 233, 65, 28, 119, 191, 102, 242, 125, 72,
+       107, 226, 46, 19, 95, 248, 193, 196, 180, 138, 91, 78, 191, 114,
+       126, 225, 29, 238, 205, 39, 44, 168, 242, 201, 163, 156, 119, 191,
+       120, 113, 180, 160, 22, 184, 29, 199, 66, 104, 151, 24, 225, 27,
+       70, 208, 32, 209, 216, 168, 72, 99, 110, 39, 26, 157, 145, 208,
+       131, 127, 80, 9, 116, 6, 150, 86, 147, 181, 164, 102, 4, 183, 49,
+       79, 250, 117, 6, 50, 131, 89, 249, 199, 12, 162, 253, 252, 1, 106,
+       176, 182, 246, 135, 136, 113, 248, 31, 106, 235, 146, 136, 221,
+       192, 178, 199, 139, 13, 248, 43, 12, 216, 118, 196, 200, 187, 147,
+       209, 86, 43, 194, 209, 127, 52, 142, 235, 215, 30, 191, 143, 187,
+       20, 104, 232, 55, 51, 219, 121, 85, 196, 253, 130, 27, 76, 183,
+       165, 94, 184, 149, 175, 236, 166, 117, 158, 210, 201, 161, 217,
+       119, 174, 124, 245, 70, 42, 166, 1, 168, 42, 162, 136, 238, 183,
+       139, 236, 198, 160, 213, 206, 227, 84, 111, 51, 136, 1, 143, 64,
+       156, 52, 139, 20, 140, 115, 49, 36, 120, 217, 56, 110, 60, 207,
+       87, 176, 196, 168, 238, 8, 115, 249, 1, 80, 216, 244, 108, 106,
+       72, 43, 219, 61, 243, 239, 37, 25, 112, 187, 78, 42, 184, 108, 42,
+       254, 5, 211, 86, 237, 81, 2, 229, 26, 107, 89, 49, 153, 121, 234,
+       133, 235, 104, 246, 24, 191, 243, 195, 193, 41, 115, 25, 254, 138,
+       180, 107, 67, 174, 220, 139, 230, 204, 239, 160, 234, 74, 99, 200,
+       109, 16, 120, 237, 106, 243, 74, 35, 202, 121, 189, 132, 135, 61,
+       113, 59, 114, 128, 18, 27, 42, 160, 133, 245, 252, 71, 173, 77,
+       254, 7, 8, 174, 55, 68, 236, 179, 223, 193, 156, 171, 48, 192,
+       179, 116, 138, 211, 135, 92, 253, 95, 63, 93, 123, 238, 125, 215,
+       222, 80, 197, 200, 253, 11, 91, 223, 55, 52, 220, 177, 151, 238,
+       236, 163, 56, 206, 243, 217, 131, 155, 119, 191, 114, 247, 61, 73,
+       239, 71, 86, 82, 239, 80, 64, 224, 247, 131, 81, 45, 55, 34, 126,
+       228, 19, 239, 141, 178, 61, 236, 119, 15, 231, 0, 229, 187, 112,
+       240, 75, 127, 126, 212, 239, 84, 127, 119, 233, 206, 20, 173, 45,
+       238, 246, 183, 166, 113, 221, 103, 229, 203, 182, 232, 243, 91,
+       111, 139, 14, 244, 175, 127, 128, 250, 59, 240, 50, 201, 176, 103,
+       174, 112, 2, 176, 174, 158, 96, 33, 166, 61, 203, 1, 103, 253,
+       178, 87, 137, 209, 27, 99, 64, 0, 37, 59, 57, 179, 107, 192, 54,
+       214, 235, 112, 68, 204, 222, 230, 49, 29, 246, 32, 126, 184, 31,
+       253, 139, 185, 36, 140, 122, 13, 167, 224, 47, 138, 112, 249, 127,
+       140, 225, 76, 205, 113, 68, 107, 65, 134, 173, 10, 106, 112, 116,
+       246, 201, 230, 240, 138, 92, 43, 251, 130, 27, 223, 213, 59, 147,
+       110, 118, 238, 6, 156, 180, 218, 252, 165, 190, 184, 159, 219, 25,
+       117, 220, 254, 125, 106, 215, 115, 55, 243, 182, 68, 26, 243, 45,
+       30, 239, 238, 156, 115, 161, 151, 180, 173, 30, 158, 142, 171,
+       230, 232, 142, 176, 171, 10, 102, 226, 109, 66, 121, 239, 106,
+       227, 88, 99, 155, 127, 185, 130, 207, 125, 113, 123, 97, 2, 219,
+       13, 110, 84, 185, 246, 94, 35, 169, 204, 190, 152, 106, 238, 182,
+       247, 160, 246, 253, 44, 124, 201, 166, 204, 179, 251, 192, 155,
+       34, 228, 110, 92, 217, 75, 30, 172, 15, 23, 84, 127, 69, 200, 150,
+       79, 63, 8, 51, 225, 236, 133, 254, 109, 237, 47, 5, 156, 242, 227,
+       97, 157, 127, 44, 56, 13, 131, 227, 166, 158, 255, 148, 188, 101,
+       253, 221, 81, 151, 44, 232, 62, 7, 166, 43, 147, 21, 246, 255, 30,
+       237, 54, 24, 94, 139, 15, 68, 249, 223, 44, 159, 173, 87, 242,
+       250, 183, 190, 18, 222, 95, 245, 225, 100, 137, 137, 31, 126, 166,
+       66, 179, 248, 110, 63, 108, 7, 103, 133, 196, 255, 149, 241, 129,
+       5, 147, 187, 242, 168, 168, 3, 60, 19, 67, 80, 181, 163, 168, 73,
+       102, 47, 42, 156, 51, 152, 3, 97, 4, 160, 122, 64, 144, 65, 161,
+       168, 159, 241, 192, 215, 141, 81, 95, 248, 23, 244, 213, 166, 107,
+       229, 250, 175, 88, 216, 181, 226, 79, 82, 254, 161, 130, 209, 197,
+       191, 63, 255, 156, 244, 2, 158, 172, 187, 189, 167, 153, 135, 134,
+       21, 152, 183, 164, 140, 50, 0, 205, 51, 219, 149, 62, 12, 67, 183,
+       233, 87, 154, 243, 148, 12, 181, 218, 197, 169, 5, 137, 221, 28,
+       166, 239, 110, 81, 232, 86, 192, 226, 40, 100, 121, 206, 106, 236,
+       211, 105, 223, 215, 60, 34, 135, 76, 24, 10, 225, 164, 5, 173,
+       133, 137, 220, 47, 32, 207, 118, 177, 234, 66, 209, 114, 65, 108,
+       121, 206, 106, 184, 22, 216, 207, 20, 125, 6, 135, 108, 176, 106,
+       225, 164, 98, 139, 58, 200, 93, 213, 81, 101, 199, 29, 204, 40,
+       34, 209, 102, 116, 200, 186, 234, 89, 90, 43, 162, 245, 29, 48,
+       128, 107, 16, 10, 244, 46, 77, 162, 196, 23, 207, 50, 164, 45, 86,
+       183, 55, 230, 201, 99, 202, 143, 95, 70, 234, 188, 145, 240, 207,
+       128, 14, 239, 245, 4, 175, 238, 200, 164, 111, 152, 245, 244, 228,
+       30, 222, 185, 219, 218, 180, 251, 239, 125, 156, 63, 223, 243,
+       213, 175, 236, 102, 108, 235, 255, 223, 205, 182, 87, 252, 210,
+       119, 120, 163, 56, 174, 62, 201, 82, 57, 6, 44, 253, 169, 231,
+       205, 42, 80, 146, 160, 141, 97, 78, 58, 73, 31, 250, 197, 33, 253,
+       116, 10, 30, 75, 226, 109, 117, 230, 246, 170, 222, 15, 123, 130,
+       57, 154, 175, 11, 20, 80, 167, 251, 53, 195, 242, 28, 158, 255,
+       34, 216, 154, 162, 37, 211, 209, 12, 118, 65, 210, 238, 77, 41,
+       234, 72, 105, 0, 233, 10, 35, 203, 125, 24, 120, 205, 74, 227, 72,
+       35, 136, 192, 21, 184, 130, 57, 113, 59, 106, 130, 41, 147, 106,
+       237, 212, 214, 249, 115, 68, 76, 126, 6, 89, 253, 182, 96, 120,
+       170, 23, 232, 156, 186, 36, 157, 127, 233, 161, 193, 119, 138,
+       252, 243, 243, 79, 124, 246, 54, 162, 158, 100, 153, 168, 185,
+       250, 124, 27, 28, 17, 166, 119, 21, 67, 192, 199, 136, 253, 112,
+       58, 106, 242, 21, 147, 235, 9, 178, 86, 147, 177, 133, 38, 4, 55,
+       49, 207, 250, 119, 2, 34, 132, 205, 253, 199, 140, 162, 253, 252,
+       65, 170, 176, 246, 246, 130, 137, 84, 236, 95, 42, 189, 99, 200,
+       117, 227, 217, 70, 95, 69, 248, 7, 58, 156, 55, 0, 216, 187, 151,
+       17, 138, 170, 112, 223, 111, 28, 146, 107, 85, 12, 116, 250, 158,
+       255, 242, 183, 147, 59, 190, 252, 27, 166, 73, 255, 109, 236, 125,
+       133, 55, 123, 209, 243, 240, 87, 142, 250, 59, 86, 77, 175, 247,
+       247, 143, 149, 178, 76, 118, 255, 215, 130, 94, 103, 93, 2, 114,
+       19, 107, 107, 53, 217, 123, 227, 39, 131, 252, 188, 87, 255, 55,
+       250, 210, 3, 127, 152, 232, 14, 196, 119, 158, 230, 168, 104, 53,
+       159, 170, 191, 142, 121, 212, 243, 201, 74, 135, 87, 109, 80, 82,
+       69, 139, 66, 232, 177, 103, 127, 128, 115, 133, 3, 59, 64, 254,
+       229, 87, 22, 248, 24, 91, 161, 118, 130, 57, 11, 182, 124, 126,
+       173, 53, 173, 140, 248, 21, 205, 75, 251, 211, 133, 103, 164, 120,
+       172, 165, 159, 131, 13, 212, 47, 231, 251, 86, 234, 88, 197, 240,
+       101, 187, 0, 89, 78, 50, 46, 245, 240, 29, 15, 108, 46, 229, 132,
+       200, 252, 80, 208, 63, 12, 238, 255, 134, 114, 127, 128, 21, 243,
+       119, 146, 91, 125, 59, 123, 127, 214, 53, 238, 56, 244, 45, 170,
+       211, 239, 212, 1, 231, 255, 248, 96, 162, 114, 229, 93, 108, 14,
+       248, 87, 91, 175, 240, 127, 32, 170, 212, 26, 236, 189, 103, 129,
+       132, 254, 193, 194, 22, 62, 242, 163, 77, 40, 247, 159, 1, 56, 59,
+       81, 68, 221, 161, 67, 126, 201, 98, 92, 176, 152, 118, 40, 160,
+       41, 50, 28, 135, 188, 54, 17, 13, 159, 18, 64, 200, 8, 65, 222,
+       106, 16, 176, 244, 109, 124, 145, 55, 155, 255, 182, 61, 46, 189,
+       70, 158, 133, 151, 253, 0, 29, 111, 242, 194, 95, 255, 80, 251,
+       194, 108, 94, 95, 224, 48, 26, 252, 125, 11, 208, 107, 153, 162,
+       160, 58, 166, 179, 32, 17, 216, 177, 75, 33, 40, 47, 16, 223, 153,
+       150, 211, 127, 80, 40, 98, 170, 122, 185, 233, 238, 87, 53, 218,
+       198, 26, 69, 105, 143, 59, 191, 86, 176, 252, 219, 147, 196, 142,
+       58, 254, 241, 127, 205, 146, 41, 241, 79, 118, 250, 137, 186, 30,
+       251, 164, 189, 121, 146, 190, 25, 84, 84, 188, 211, 168, 108, 135,
+       58, 62, 24, 147, 152, 98, 181, 207, 219, 50, 202, 154, 137, 137,
+       161, 155, 20, 113, 173, 51, 242, 88, 55, 61, 67, 94, 247, 61, 63,
+       178, 245, 230, 183, 149, 164, 237, 156, 53, 207, 211, 255, 186,
+       130, 62, 196, 37, 123, 63, 233, 99, 234, 87, 151, 239, 249, 197,
+       64, 253, 134, 121, 204, 190, 36, 126, 233, 23, 255, 207, 179, 60,
+       253, 127, 76, 143, 228, 127, 174, 242, 212, 31, 17, 109, 193, 38,
+       26, 249, 184, 64, 244, 23, 135, 89, 61, 222, 35, 62, 213, 23, 255,
+       145, 240, 61, 204, 78, 75, 239, 212, 231, 171, 81, 240, 58, 157,
+       98, 236, 223, 133, 126, 247, 173, 0, 234, 227, 43, 253, 36, 212,
+       238, 179, 219, 225, 217, 169, 16, 189, 59, 248, 128, 74, 127, 142,
+       248, 158, 59, 210, 107, 226, 38, 81, 251, 248, 5, 68, 247, 166,
+       123, 29, 251, 36, 126, 152, 191, 239, 201, 51, 125, 241, 210, 205,
+       162, 132, 127, 191, 116, 249, 55, 204, 150, 182, 246, 166, 190,
+       167, 189, 139, 90, 114, 102, 250, 37, 213, 253, 255, 37, 177, 56,
+       220, 9, 238, 168, 246, 223, 194, 137, 80, 168, 15, 206, 145, 117,
+       248, 47, 241, 25, 186, 143, 85, 148, 182, 156, 223, 234, 231, 198,
+       19, 191, 225, 183, 73, 114, 213, 203, 217, 203, 255, 22, 133, 5,
+       115, 50, 79, 74, 172, 84, 83, 206, 105, 20, 132, 218, 163, 97,
+       104, 183, 64, 122, 172, 131, 229, 76, 147, 69, 142, 48, 37, 175,
+       129, 37, 190, 124, 216, 223, 205, 227, 86, 145, 118, 79, 172, 215,
+       226, 174, 18, 123, 117, 191, 245, 121, 230, 152, 238, 121, 71,
+       125, 174, 187, 207, 197, 127, 163, 247, 252, 100, 50, 157, 106,
+       204, 242, 183, 155, 247, 108, 73, 222, 162, 50, 55, 182, 112, 126,
+       178, 151, 236, 218, 154, 36, 253, 251, 47, 170, 195, 55, 138, 188,
+       43, 178, 179, 122, 202, 247, 213, 176, 119, 141, 77, 252, 191, 42,
+       156, 230, 36, 236, 187, 151, 17, 158, 43, 34, 223, 123, 89, 48,
+       235, 87, 14, 254, 223, 188, 67, 90, 172, 122, 2, 83, 120, 1, 236,
+       245, 171, 87, 21, 171, 80, 94, 156, 4, 110, 72, 183, 97, 142, 242,
+       237, 33, 149, 103, 170, 100, 99, 2, 72, 118, 152, 207, 135, 188,
+       103, 223, 144, 66, 131, 172, 136, 52, 105, 238, 189, 51, 149, 84,
+       253, 23, 221, 31, 58, 222, 66, 53, 140, 177, 142, 11, 164, 194,
+       177, 241, 178, 120, 83, 55, 105, 91, 215, 9, 238, 126, 192, 253,
+       47, 179, 148, 151, 152, 4, 146, 78, 93, 159, 199, 175, 196, 184,
+       214, 185, 225, 98, 232, 95, 147, 76, 229, 197, 36, 244, 10, 43,
+       137, 52, 177, 106, 170, 23, 237, 74, 171, 4, 157, 251, 201, 132,
+       57, 119, 156, 240, 138, 97, 253, 95, 78, 248, 156, 102, 247, 233,
+       200, 108, 76, 50, 178, 132, 115, 128, 230, 76, 108, 197, 171, 178,
+       109, 55, 185, 36, 10, 72, 210, 234, 45, 34, 177, 171, 154, 223,
+       252, 176, 71, 139, 89, 89, 27, 44, 188, 110, 42, 173, 59, 179, 17,
+       151, 107, 186, 209, 31, 52, 158, 171, 145, 94, 215, 223, 87, 100,
+       115, 238, 254, 171, 254, 105, 125, 163, 219, 139, 207, 249, 61,
+       32, 255, 247, 95, 183, 188, 163, 13, 254, 178, 254, 15, 18, 231,
+       255, 161, 2, 124, 253, 250, 108, 219, 54, 23, 188, 112, 238, 174,
+       14, 91, 247, 111, 112, 61, 214, 225, 226, 248, 35, 187, 42, 123,
+       237, 37, 31, 99, 115, 230, 115, 1, 79, 159, 253, 116, 142, 175,
+       182, 190, 138, 90, 96, 180, 243, 161, 64, 199, 123, 63, 73, 33,
+       216, 66, 127, 44, 190, 62, 128, 16, 16, 33, 169, 89, 219, 255,
+       255, 55, 94, 125, 183, 113, 77, 94, 230, 255, 55, 146, 230, 38,
+       71, 149, 204, 193, 216, 53, 237, 230, 255, 118, 128, 46, 150, 173,
+       125, 176, 64, 86, 181, 84, 139, 232, 64, 125, 33, 242, 26, 75, 8,
+       52, 73, 120, 173, 110, 225, 56, 183, 65, 204, 149, 178, 210, 65,
+       101, 9, 240, 128, 141, 166, 18, 136, 109, 57, 171, 74, 142, 182,
+       13, 152, 141, 194, 242, 135, 139, 8, 194, 62, 39, 37, 46, 210, 46,
+       213, 75, 45, 150, 239, 9, 132, 229, 206, 6, 191, 90, 136, 34, 224,
+       244, 17, 203, 243, 225, 98, 136, 67, 125, 226, 106, 227, 54, 220,
+       79, 63, 60, 34, 11, 65, 48, 11, 161, 132, 9, 134, 80, 170, 253,
+       49, 171, 108, 140, 23, 149, 18, 141, 227, 250, 198, 75, 75, 154,
+       169, 48, 11, 78, 242, 236, 149, 218, 109, 158, 239, 169, 128, 31,
+       64, 244, 245, 39, 58, 217, 152, 219, 214, 52, 131, 111, 93, 223,
+       175, 182, 245, 181, 239, 132, 116, 62, 216, 194, 219, 73, 135,
+       103, 189, 93, 85, 47, 16, 252, 241, 47, 114, 88, 24, 203, 214, 21,
+       167, 205, 223, 223, 254, 151, 61, 181, 181, 133, 208, 254, 208,
+       70, 251, 201, 199, 167, 165, 94, 87, 197, 97, 151, 179, 236, 8,
+       111, 156, 232, 80, 11, 68, 213, 211, 217, 107, 54, 67, 120, 126,
+       195, 64, 186, 96, 100, 152, 111, 76, 12, 243, 161, 224, 22, 144,
+       189, 169, 137, 103, 185, 223, 30, 59, 80, 51, 149, 63, 104, 10,
+       253, 27, 183, 145, 19, 216, 83, 209, 205, 199, 255, 230, 152, 72,
+       165, 243, 156, 32, 208, 241, 71, 74, 232, 88, 83, 179, 116, 18, 9,
+       169, 93, 15, 123, 141, 55, 153, 0, 244, 131, 192, 79, 203, 211,
+       37, 231, 232, 73, 130, 182, 83, 106, 174, 86, 18, 158, 112, 5, 68,
+       215, 167, 97, 204, 183, 64, 126, 169, 151, 231, 204, 135, 36, 206,
+       114, 101, 170, 139, 39, 174, 60, 215, 131, 140, 115, 221, 214,
+       131, 252, 103, 61, 3, 98, 147, 180, 30, 52, 96, 239, 63, 19, 149,
+       102, 188, 117, 239, 45, 62, 158, 66, 5, 136, 161, 140, 188, 20,
+       93, 77, 66, 99, 99, 250, 52, 122, 120, 122, 81, 119, 137, 185, 57,
+       144, 82, 234, 41, 182, 123, 31, 71, 143, 97, 4, 105, 249, 102,
+       241, 11, 91, 70, 140, 62, 147, 186, 104, 140, 64, 216, 231, 236,
+       202, 183, 192, 126, 41, 179, 229, 197, 131, 6, 221, 20, 43, 234,
+       139, 31, 142, 57, 221, 254, 187, 82, 80, 123, 153, 18, 96, 171,
+       188, 177, 189, 46, 198, 196, 149, 142, 185, 196, 130, 62, 95, 224,
+       221, 154, 209, 1, 251, 98, 5, 14, 183, 11, 160, 232, 225, 53, 212,
+       121, 41, 203, 69, 70, 130, 57, 223, 94, 100, 18, 157, 177, 220, 3,
+       24, 183, 213, 75, 253, 129, 101, 39, 134, 84, 126, 122, 5, 106,
+       74, 215, 242, 219, 99, 141, 4, 255, 139, 11, 41, 54, 208, 106,
+       166, 155, 168, 92, 187, 100, 206, 114, 109, 130, 81, 119, 206,
+       252, 74, 26, 160, 232, 243, 23, 212, 121, 41, 195, 85, 7, 3, 89,
+       221, 94, 32, 50, 185, 177, 153, 18, 120, 191, 209, 79, 221, 145,
+       69, 167, 134, 84, 98, 218, 145, 22, 186, 7, 212, 89, 192, 175, 80,
+       197, 19, 158, 159, 106, 239, 228, 153, 185, 209, 91, 75, 154, 241,
+       153, 241, 218, 78, 58, 4, 169, 58, 70, 190, 181, 19, 170, 232,
+       149, 159, 155, 255, 18, 125, 164, 188, 196, 75, 135, 87, 127, 17,
+       179, 104, 235, 113, 12, 18, 125, 254, 196, 88, 133, 127, 37, 19,
+       199, 31, 40, 143, 135, 49, 12, 228, 235, 229, 210, 229, 174, 4,
+       222, 44, 106, 70, 153, 160, 91, 28, 0, 182, 65, 82, 220, 171, 192,
+       82, 230, 107, 179, 242, 236, 166, 158, 132, 27, 185, 185, 121, 92,
+       31, 221, 184, 151, 215, 117, 215, 154, 67, 136, 240, 56, 58, 221,
+       254, 133, 211, 163, 35, 211, 233, 216, 161, 6, 0, 123, 134, 43,
+       49, 178, 147, 55, 10, 84, 114, 231, 215, 53, 213, 14, 248, 143,
+       227, 221, 140, 182, 196, 37, 152, 96, 8, 8, 221, 17, 185, 241,
+       205, 173, 183, 62, 91, 72, 80, 188, 183, 32, 64, 133, 59, 19, 25,
+       115, 24, 18, 119, 237, 150, 62, 192, 152, 80, 129, 187, 56, 215,
+       103, 46, 95, 220, 114, 253, 197, 76, 124, 231, 99, 221, 174, 68,
+       92, 178, 151, 100, 207, 42, 118, 189, 119, 105, 160, 203, 115,
+       142, 116, 223, 48, 169, 18, 172, 29, 129, 194, 232, 195, 128, 160,
+       11, 99, 216, 101, 144, 248, 168, 72, 192, 78, 43, 154, 157, 152,
+       244, 131, 127, 121, 42, 114, 138, 43, 191, 99, 75, 214, 151, 170,
+       113, 68, 192, 88, 198, 40, 232, 180, 164, 126, 42, 146, 253, 215,
+       186, 52, 252, 46, 12, 174, 192, 95, 142, 248, 253, 80, 217, 223,
+       127, 10, 78, 87, 184, 228, 2, 227, 0, 247, 115, 8, 115, 50, 245,
+       108, 98, 105, 197, 155, 45, 227, 171, 100, 16, 40, 179, 37, 42,
+       32, 107, 233, 161, 244, 251, 234, 198, 90, 229, 120, 170, 145, 8,
+       213, 184, 90, 236, 22, 89, 140, 186, 100, 138, 78, 93, 183, 165,
+       197, 219, 94, 232, 124, 63, 186, 52, 211, 252, 117, 199, 171, 207,
+       188, 41, 46, 189, 67, 26, 165, 255, 253, 21, 18, 107, 162, 224,
+       255, 245, 53, 171, 194, 116, 134, 99, 124, 9, 252, 103, 153, 30,
+       83, 136, 115, 160, 166, 8, 123, 61, 17, 122, 50, 244, 248, 122, 8,
+       240, 249, 40, 67, 239, 69, 21, 227, 243, 70, 42, 129, 74, 147,
+       221, 53, 143, 32, 87, 126, 11, 82, 80, 188, 131, 32, 72, 162, 41,
+       38, 12, 2, 156, 2, 223, 197, 190, 122, 0, 16, 8, 1, 137, 22, 95,
+       107, 175, 114, 130, 191, 240, 36, 132, 91, 231, 113, 79, 177, 64,
+       126, 253, 23, 231, 192, 153, 12, 108, 116, 165, 174, 128, 37, 178,
+       37, 209, 244, 106, 237, 37, 40, 74, 73, 188, 32, 182, 150, 185,
+       211, 37, 211, 27, 38, 196, 109, 111, 104, 229, 197, 0, 192, 131,
+       229, 149, 100, 177, 86, 64, 190, 200, 234, 242, 7, 91, 219, 228,
+       21, 54, 246, 27, 75, 61, 63, 189, 105, 211, 151, 211, 108, 247,
+       57, 228, 219, 219, 214, 67, 231, 61, 124, 110, 62, 136, 252, 243,
+       71, 86, 91, 192, 89, 118, 247, 19, 75, 63, 63, 253, 235, 215, 149,
+       215, 44, 246, 125, 224, 219, 255, 214, 67, 247, 175, 124, 70, 5,
+       192, 195, 139, 208, 175, 98, 220, 126, 17, 66, 66, 209, 194, 233,
+       108, 121, 74, 106, 124, 166, 148, 15, 127, 44, 14, 151, 100, 184,
+       155, 97, 164, 13, 201, 194, 26, 181, 153, 110, 252, 207, 196, 109,
+       132, 233, 226, 251, 228, 83, 104, 170, 94, 199, 0, 62, 249, 170,
+       93, 7, 104, 30, 190, 233, 244, 65, 175, 28, 177, 212, 168, 96, 39,
+       118, 51, 74, 16, 181, 3, 0, 73, 35, 10, 42, 152, 18, 216, 71, 55,
+       204, 166, 150, 64, 160, 192, 137, 136, 59, 187, 102, 13, 127, 82,
+       216, 248, 73, 204, 244, 167, 40, 12, 151, 213, 254, 205, 135, 245,
+       134, 171, 101, 205, 26, 89, 162, 147, 111, 142, 126, 223, 31, 251,
+       235, 140, 178, 208, 159, 121, 45, 204, 92, 231, 63, 212, 178, 36,
+       94, 121, 151, 95, 219, 186, 36, 173, 250, 77, 46, 202, 111, 134,
+       165, 245, 166, 233, 240, 226, 244, 35, 222, 204, 75, 49, 57, 250,
+       92, 153, 92, 0, 191, 91, 53, 87, 146, 47, 138, 247, 40, 156, 142,
+       250, 77, 211, 195, 129, 166, 237, 244, 206, 180, 167, 158, 196,
+       11, 41, 185, 251, 124, 25, 60, 0, 159, 91, 53, 87, 210, 171, 10,
+       247, 32, 24, 8, 242, 28, 155, 211, 129, 166, 231, 103, 195, 244,
+       131, 239, 245, 29, 132, 117, 246, 105, 77, 180, 133, 94, 184, 23,
+       255, 248, 186, 44, 254, 46, 216, 165, 192, 87, 158, 244, 249, 63,
+       146, 235, 225, 54, 223, 123, 80, 39, 237, 246, 231, 123, 93, 190,
+       116, 126, 157, 183, 221, 139, 176, 101, 200, 218, 221, 163, 132,
+       239, 142, 116, 113, 218, 219, 14, 190, 43, 6, 28, 180, 140, 30,
+       134, 229, 236, 103, 42, 195, 230, 247, 237, 227, 236, 77, 83, 253,
+       242, 243, 222, 147, 26, 52, 141, 91, 219, 156, 150, 60, 21, 190,
+       80, 123, 251, 79, 102, 29, 110, 248, 46, 189, 177, 102, 228, 36,
+       182, 237, 50, 159, 155, 255, 85, 95, 202, 100, 203, 79, 131, 183,
+       99, 145, 242, 183, 168, 119, 56, 233, 80, 246, 140, 174, 212, 181,
+       55, 59, 147, 149, 183, 216, 180, 214, 44, 16, 154, 226, 140, 4,
+       131, 253, 106, 57, 250, 116, 225, 92, 125, 215, 59, 173, 60, 8,
+       62, 191, 71, 62, 142, 255, 213, 16, 8, 123, 176, 192, 219, 253,
+       20, 187, 194, 116, 70, 239, 0, 33, 95, 225, 220, 11, 233, 71, 44,
+       49, 243, 146, 156, 11, 116, 67, 106, 133, 107, 185, 16, 187, 65,
+       196, 220, 0, 154, 64, 197, 10, 225, 168, 190, 122, 112, 99, 41,
+       157, 86, 212, 133, 54, 231, 61, 11, 137, 79, 154, 206, 153, 229,
+       82, 78, 22, 202, 162, 195, 217, 0, 115, 119, 159, 94, 131, 130,
+       28, 123, 212, 102, 223, 248, 119, 189, 234, 82, 103, 12, 190, 181,
+       108, 239, 189, 191, 133, 229, 189, 48, 222, 223, 126, 218, 130,
+       140, 108, 37, 223, 35, 165, 161, 74, 212, 165, 203, 207, 87, 65,
+       105, 76, 176, 168, 92, 32, 217, 138, 18, 157, 159, 58, 124, 87,
+       45, 28, 156, 104, 221, 74, 210, 156, 140, 248, 185, 248, 233, 173,
+       177, 219, 158, 25, 84, 116, 188, 223, 105, 169, 133, 59, 243, 17,
+       131, 108, 154, 209, 205, 209, 63, 234, 154, 64, 3, 187, 185, 188,
+       121, 113, 215, 255, 86, 247, 119, 235, 60, 120, 63, 56, 129, 184,
+       155, 250, 212, 0, 189, 254, 117, 62, 111, 207, 53, 118, 251, 88,
+       202, 171, 191, 77, 99, 206, 100, 183, 222, 112, 85, 192, 253, 138,
+       123, 205, 181, 101, 126, 184, 23, 239, 232, 179, 44, 222, 115,
+       253, 163, 136, 119, 191, 112, 229, 5, 225, 131, 221, 206, 10, 102,
+       221, 118, 146, 64, 66, 209, 211, 97, 111, 121, 76, 42, 250, 64,
+       84, 203, 8, 125, 138, 231, 44, 48, 120, 225, 160, 62, 115, 123,
+       98, 62, 213, 155, 252, 237, 204, 157, 231, 125, 221, 191, 32, 254,
+       49, 223, 241, 205, 163, 46, 204, 123, 93, 173, 203, 111, 150, 60,
+       127, 90, 156, 178, 216, 27, 244, 152, 67, 155, 85, 140, 27, 44,
+       190, 102, 206, 163, 187, 249, 145, 30, 11, 178, 211, 155, 117, 26,
+       123, 151, 4, 45, 86, 131, 241, 70, 30, 203, 144, 182, 237, 189,
+       80, 214, 247, 104, 218, 190, 135, 126, 211, 251, 227, 230, 111,
+       30, 229, 50, 58, 222, 203, 79, 20, 171, 158, 75, 31, 35, 156, 111,
+       148, 93, 54, 29, 78, 222, 231, 108, 191, 178, 196, 118, 167, 191,
+       140, 192, 26, 55, 255, 182, 126, 218, 138, 54, 252, 48, 125, 15,
+       191, 151, 151, 168, 180, 39, 183, 150, 223, 95, 116, 252, 246,
+       234, 239, 197, 111, 180, 30, 243, 218, 187, 115, 168, 54, 127,
+       198, 136, 117, 161, 125, 3, 31, 107, 216, 246, 247, 187, 83, 157,
+       205, 94, 231, 28, 190, 182, 96, 238, 59, 151, 149, 149, 153, 48,
+       254, 10, 125, 170, 194, 157, 237, 53, 213, 97, 166, 153, 180, 92,
+       11, 130, 111, 90, 163, 224, 220, 213, 96, 16, 0, 91, 68, 66, 40,
+       33, 250, 221, 30, 172, 134, 127, 52, 72, 168, 67, 168, 3, 121, 19,
+       185, 111, 205, 189, 70, 158, 80, 80, 70, 188, 158, 115, 41, 238,
+       41, 50, 69, 199, 91, 178, 241, 21, 24, 90, 170, 28, 28, 33, 221,
+       0, 157, 59, 176, 147, 228, 181, 199, 188, 77, 74, 17, 180, 191,
+       32, 64, 161, 59, 3, 17, 82, 153, 16, 119, 233, 150, 30, 67, 144,
+       80, 165, 251, 56, 233, 42, 106, 93, 197, 67, 232, 199, 12, 236,
+       10, 51, 217, 51, 48, 120, 168, 87, 234, 74, 43, 40, 63, 251, 205,
+       129, 57, 115, 138, 118, 170, 65, 8, 90, 197, 116, 138, 169, 101,
+       46, 161, 67, 130, 180, 130, 48, 64, 98, 45, 42, 9, 0, 152, 129,
+       93, 84, 44, 26, 64, 12, 136, 1, 168, 47, 220, 241, 246, 244, 29,
+       222, 189, 89, 234, 180, 235, 255, 125, 157, 53, 223, 243, 151,
+       175, 254, 102, 108, 239, 254, 223, 221, 246, 215, 254, 82, 255,
+       154, 152, 180, 184, 15, 244, 145, 71, 135, 87, 132, 19, 14, 159,
+       102, 140, 201, 145, 249, 145, 46, 79, 50, 211, 211, 215, 154, 127,
+       179, 4, 61, 94, 9, 122, 121, 225, 110, 93, 127, 56, 233, 200, 52,
+       228, 157, 31, 215, 50, 166, 49, 215, 110, 193, 32, 38, 200, 102,
+       221, 39, 174, 78, 162, 67, 249, 143, 189, 61, 219, 213, 244, 191,
+       183, 88, 82, 69, 20, 252, 116, 31, 109, 133, 122, 19, 31, 183,
+       220, 60, 231, 103, 59, 28, 96, 154, 84, 153, 244, 27, 24, 122,
+       228, 38, 23, 95, 48, 29, 226, 182, 163, 31, 63, 183, 100, 126,
+       181, 157, 237, 232, 161, 36, 220, 211, 255, 193, 144, 119, 172,
+       100, 113, 123, 41, 107, 238, 118, 90, 219, 112, 97, 228, 255, 170,
+       59, 157, 182, 48, 126, 180, 255, 239, 152, 187, 229, 204, 218,
+       237, 162, 200, 103, 175, 126, 97, 113, 151, 199, 172, 172, 42, 70,
+       191, 151, 227, 219, 237, 195, 236, 171, 194, 87, 230, 108, 37,
+       189, 233, 207, 10, 168, 118, 117, 148, 236, 238, 144, 93, 42, 186,
+       164, 95, 41, 217, 81, 135, 151, 253, 150, 177, 234, 101, 198, 143,
+       73, 110, 237, 16, 26, 200, 239, 177, 206, 115, 213, 243, 198, 140,
+       92, 126, 120, 16, 253, 117, 19, 70, 81, 122, 19, 169, 230, 27, 82,
+       53, 0, 189, 24, 252, 181, 40, 41, 254, 113, 14, 219, 239, 81, 82,
+       99, 40, 82, 122, 124, 201, 18, 250, 157, 213, 86, 233, 135, 4,
+       236, 9, 111, 241, 32, 208, 216, 242, 205, 82, 90, 43, 74, 191,
+       251, 245, 4, 123, 82, 31, 236, 2, 252, 109, 18, 170, 93, 197, 82,
+       200, 131, 164, 169, 9, 78, 217, 105, 144, 216, 248, 197, 114, 14,
+       39, 218, 187, 187, 209, 1, 127, 82, 63, 126, 2, 35, 235, 234, 72,
+       86, 145, 170, 244, 70, 69, 124, 238, 33, 204, 182, 36, 126, 232,
+       18, 221, 199, 186, 36, 255, 62, 76, 166, 232, 127, 158, 250, 221,
+       44, 172, 189, 87, 221, 234, 183, 174, 218, 183, 110, 16, 242, 245,
+       73, 43, 89, 126, 98, 26, 50, 120, 251, 51, 109, 39, 85, 85, 192,
+       121, 212, 106, 62, 115, 118, 170, 255, 212, 157, 252, 137, 204,
+       220, 175, 108, 223, 191, 5, 254, 243, 151, 245, 151, 67, 50, 236,
+       127, 81, 174, 219, 159, 158, 175, 223, 136, 64, 115, 226, 100,
+       233, 249, 80, 77, 37, 53, 16, 157, 139, 116, 40, 202, 41, 23, 25,
+       162, 60, 48, 242, 195, 217, 58, 232, 22, 143, 213, 225, 52, 172,
+       158, 190, 219, 3, 150, 234, 154, 146, 168, 11, 118, 241, 41, 18,
+       249, 214, 234, 50, 106, 103, 75, 63, 249, 6, 79, 125, 209, 107,
+       38, 170, 214, 149, 60, 186, 142, 105, 144, 169, 142, 53, 135, 147,
+       199, 126, 10, 75, 227, 19, 253, 51, 62, 73, 91, 181, 217, 195,
+       219, 95, 148, 73, 157, 83, 234, 80, 113, 252, 127, 214, 220, 17,
+       153, 78, 180, 255, 173, 31, 151, 62, 206, 177, 213, 197, 229, 7,
+       112, 207, 67, 255, 186, 154, 95, 148, 71, 255, 184, 122, 120, 107,
+       109, 241, 82, 212, 69, 36, 117, 57, 11, 157, 71, 24, 202, 152,
+       231, 82, 10, 182, 227, 178, 87, 217, 0, 47, 119, 159, 110, 131,
+       138, 56, 153, 249, 67, 229, 185, 87, 30, 25, 84, 86, 188, 151, 96,
+       109, 238, 59, 179, 144, 3, 92, 114, 209, 197, 145, 218, 234, 26,
+       8, 33, 187, 27, 135, 6, 59, 182, 211, 190, 229, 222, 89, 89, 231,
+       236, 72, 190, 129, 191, 43, 134, 247, 247, 184, 12, 253, 40, 67,
+       47, 199, 93, 14, 169, 221, 163, 186, 106, 12, 94, 135, 233, 106,
+       91, 228, 244, 175, 32, 200, 247, 0, 124, 168, 19, 173, 198, 59,
+       166, 223, 30, 12, 137, 174, 93, 172, 118, 221, 3, 169, 129, 209,
+       252, 141, 172, 167, 62, 57, 18, 114, 180, 186, 212, 64, 207, 27,
+       123, 21, 210, 104, 195, 241, 44, 30, 190, 238, 148, 72, 209, 168,
+       226, 88, 106, 26, 245, 210, 248, 132, 251, 69, 179, 177, 78, 221,
+       63, 120, 179, 145, 157, 21, 166, 165, 60, 247, 83, 126, 154, 219,
+       215, 149, 247, 94, 34, 34, 106, 12, 127, 211, 216, 104, 135, 236,
+       220, 175, 40, 204, 183, 132, 126, 169, 151, 165, 140, 35, 38, 221,
+       18, 28, 139, 187, 87, 174, 126, 223, 182, 141, 67, 169, 213, 107,
+       238, 227, 125, 2, 248, 71, 3, 107, 61, 81, 249, 203, 11, 163, 125,
+       179, 80, 202, 188, 142, 142, 28, 253, 120, 114, 130, 69, 232, 20,
+       157, 110, 137, 174, 162, 174, 144, 74, 192, 189, 226, 192, 99, 34,
+       105, 106, 203, 64, 72, 138, 125, 44, 34, 111, 40, 4, 162, 35, 136,
+       30, 147, 53, 235, 143, 244, 120, 24, 237, 25, 255, 86, 207, 91,
+       44, 205, 238, 147, 255, 154, 158, 144, 25, 241, 199, 217, 82, 199,
+       251, 135, 169, 19, 239, 210, 245, 242, 237, 29, 220, 185, 137, 90,
+       181, 255, 206, 253, 255, 47, 223, 145, 223, 167, 254, 103, 234,
+       193, 95, 90, 79, 191, 215, 255, 199, 119, 242, 169, 134, 188, 155,
+       147, 22, 234, 179, 176, 224, 139, 102, 226, 98, 146, 121, 237,
+       234, 101, 108, 207, 142, 15, 185, 38, 79, 31, 97, 44, 42, 14, 124,
+       108, 122, 126, 93, 215, 86, 196, 211, 164, 164, 9, 99, 217, 101,
+       17, 216, 248, 197, 98, 104, 39, 90, 184, 243, 221, 5, 59, 115, 59,
+       126, 10, 90, 160, 172, 145, 137, 252, 185, 199, 175, 55, 134, 19,
+       140, 190, 94, 107, 161, 135, 249, 145, 22, 89, 179, 241, 223, 83,
+       222, 127, 130, 68, 189, 110, 244, 86, 151, 181, 149, 102, 68, 167,
+       49, 243, 226, 117, 2, 50, 0, 221, 249, 207, 0, 32, 57, 252, 17,
+       42, 176, 242, 214, 6, 136, 113, 160, 94, 36, 133, 132, 129, 205,
+       43, 164, 75, 30, 179, 234, 18, 134, 34, 8, 202, 121, 142, 106,
+       144, 56, 250, 69, 82, 140, 38, 223, 69, 209, 104, 217, 128, 112,
+       180, 221, 100, 27, 71, 65, 107, 80, 226, 160, 26, 83, 117, 0, 51,
+       89, 212, 104, 32, 105, 235, 241, 15, 249, 166, 81, 52, 105, 40,
+       70, 58, 128, 234, 88, 145, 84, 200, 236, 32, 184, 210, 177, 14,
+       188, 74, 82, 129, 59, 225, 78, 227, 99, 102, 92, 205, 172, 131,
+       239, 61, 4, 40, 9, 128, 120, 159, 59, 236, 120, 213, 147, 248,
+       128, 204, 188, 239, 56, 221, 163, 48, 236, 177, 223, 230, 205, 43,
+       162, 255, 115, 13, 43, 186, 83, 47, 39, 251, 124, 108, 122, 102,
+       21, 83, 86, 228, 209, 164, 191, 10, 107, 217, 53, 145, 248, 252,
+       197, 226, 104, 163, 152, 172, 243, 205, 133, 59, 99, 59, 126, 10,
+       77, 184, 140, 177, 173, 63, 101, 143, 218, 255, 6, 28, 214, 48,
+       90, 175, 129, 70, 120, 29, 183, 124, 255, 48, 140, 30, 93, 116,
+       136, 124, 219, 116, 188, 64, 210, 181, 69, 11, 228, 80, 23, 178,
+       115, 19, 3, 219, 97, 8, 249, 168, 38, 130, 104, 246, 3, 130, 146,
+       211, 211, 39, 251, 120, 112, 130, 1, 137, 105, 9, 84, 205, 107,
+       17, 102, 97, 78, 68, 177, 16, 150, 100, 114, 136, 18, 220, 131,
+       152, 117, 93, 100, 13, 162, 128, 30, 134, 112, 236, 91, 17, 247,
+       238, 109, 22, 122, 244, 237, 200, 254, 103, 126, 191, 189, 254,
+       238, 221, 255, 231, 205, 163, 113, 232, 215, 255, 126, 138, 135,
+       255, 37, 255, 23, 42, 235, 160, 230, 38, 169, 83, 56, 206, 90,
+       199, 29, 139, 83, 8, 62, 45, 23, 157, 132, 214, 132, 74, 84, 14,
+       191, 128, 165, 229, 119, 241, 190, 50, 226, 186, 139, 113, 27,
+       200, 151, 87, 181, 183, 74, 207, 111, 14, 253, 217, 141, 210, 62,
+       71, 186, 226, 211, 213, 137, 191, 183, 127, 60, 214, 69, 76, 152,
+       174, 124, 32, 171, 108, 136, 159, 53, 48, 220, 163, 226, 78, 207,
+       65, 83, 169, 48, 71, 138, 226, 108, 151, 255, 236, 156, 227, 169,
+       129, 26, 50, 250, 116, 35, 86, 89, 82, 117, 206, 182, 39, 58, 157,
+       247, 252, 166, 189, 189, 145, 141, 229, 55, 192, 83, 93, 48, 131,
+       111, 132, 108, 95, 82, 189, 54, 150, 155, 247, 152, 103, 143, 245,
+       158, 43, 44, 62, 70, 134, 239, 179, 223, 145, 158, 203, 112, 236,
+       59, 81, 30, 51, 135, 68, 45, 95, 202, 236, 96, 213, 215, 176, 126,
+       55, 121, 2, 62, 146, 41, 107, 21, 97, 35, 178, 31, 168, 162, 76,
+       183, 255, 103, 111, 147, 129, 39, 212, 248, 142, 27, 78, 70, 159,
+       3, 22, 40, 97, 173, 70, 198, 199, 104, 6, 63, 213, 102, 167, 203,
+       164, 236, 159, 5, 221, 146, 122, 218, 131, 47, 132, 58, 220, 213,
+       13, 156, 181, 168, 46, 93, 185, 169, 186, 130, 200, 215, 119, 65,
+       123, 198, 117, 124, 110, 120, 193, 203, 8, 249, 243, 111, 20, 128,
+       248, 129, 33, 35, 145, 38, 168, 93, 87, 80, 95, 133, 84, 228, 143,
+       3, 12, 46, 38, 204, 144, 195, 180, 205, 59, 112, 140, 31, 208,
+       144, 79, 123, 140, 124, 222, 79, 157, 148, 178, 171, 244, 22, 167,
+       190, 219, 14, 53, 252, 242, 194, 239, 135, 103, 184, 23, 55, 73,
+       187, 49, 232, 119, 95, 203, 138, 85, 169, 95, 131, 155, 250, 219,
+       118, 163, 187, 212, 30, 1, 83, 163, 253, 223, 185, 72, 127, 59,
+       23, 213, 130, 177, 13, 251, 92, 13, 186, 132, 149, 219, 33, 249,
+       131, 57, 115, 251, 246, 129, 122, 124, 189, 64, 82, 227, 188, 159,
+       253, 105, 230, 59, 31, 213, 179, 153, 10, 253, 190, 216, 154, 202,
+       158, 135, 33, 159, 33, 62, 191, 119, 52, 174, 109, 23, 232, 233,
+       62, 76, 182, 37, 17, 50, 132, 102, 92, 12, 129, 184, 240, 42, 237,
+       191, 52, 128, 200, 248, 210, 249, 166, 162, 234, 26, 199, 241,
+       184, 72, 91, 85, 117, 191, 8, 204, 126, 8, 255, 139, 147, 149,
+       150, 118, 142, 211, 94, 21, 154, 239, 213, 15, 255, 214, 180, 98,
+       2, 144, 64, 11, 36, 65, 52, 130, 225, 18, 6, 130, 97, 25, 249,
+       168, 2, 130, 104, 215, 0, 74, 144, 130, 219, 42, 1, 121, 39, 128,
+       240, 37, 127, 142, 220, 67, 207, 109, 201, 162, 177, 26, 85, 106,
+       28, 51, 122, 197, 126, 161, 57, 111, 185, 206, 185, 186, 207, 60,
+       165, 42, 247, 32, 65, 141, 135, 149, 84, 142, 98, 102, 116, 161,
+       194, 194, 241, 98, 176, 101, 120, 230, 122, 108, 52, 219, 197,
+       110, 60, 46, 215, 0, 32, 168, 240, 172, 178, 53, 115, 224, 237,
+       79, 252, 91, 29, 234, 176, 79, 14, 29, 117, 25, 254, 153, 87, 177,
+       248, 51, 80, 204, 179, 216, 10, 190, 93, 8, 103, 147, 26, 77, 118,
+       188, 18, 192, 61, 103, 164, 4, 202, 163, 45, 175, 35, 65, 106,
+       243, 141, 193, 110, 139, 6, 237, 240, 225, 62, 137, 39, 148, 37,
+       74, 37, 181, 121, 75, 244, 111, 99, 254, 82, 105, 124, 74, 19, 17,
+       216, 48, 89, 154, 22, 56, 147, 50, 125, 31, 127, 13, 33, 100, 245,
+       202, 210, 161, 1, 180, 149, 247, 168, 164, 60, 51, 62, 187, 67,
+       84, 244, 115, 72, 107, 197, 127, 58, 154, 241, 92, 219, 98, 205,
+       174, 254, 130, 136, 64, 161, 171, 121, 162, 120, 65, 49, 223, 81,
+       63, 127, 101, 38, 12, 43, 12, 134, 116, 16, 136, 132, 28, 142,
+       184, 117, 157, 139, 223, 16, 119, 114, 132, 78, 94, 27, 157, 46,
+       177, 179, 151, 188, 247, 156, 85, 154, 247, 252, 62, 50, 129, 231,
+       35, 219, 181, 247, 201, 21, 253, 168, 67, 191, 210, 188, 12, 185,
+       83, 186, 162, 196, 188, 126, 139, 80, 89, 151, 180, 116, 255, 107,
+       233, 66, 22, 31, 236, 231, 52, 14, 246, 203, 157, 222, 210, 69,
+       239, 119, 172, 78, 199, 15, 190, 233, 211, 244, 116, 249, 210, 91,
+       255, 92, 119, 152, 60, 223, 168, 223, 91, 151, 157, 151, 248, 251,
+       226, 79, 93, 191, 230, 143, 197, 119, 247, 34, 187, 57, 218, 255,
+       213, 176, 87, 11, 77, 216, 239, 44, 156, 102, 0, 204, 187, 151,
+       145, 158, 42, 226, 213, 59, 28, 30, 251, 85, 14, 166, 223, 107,
+       157, 108, 69, 93, 122, 238, 55, 233, 224, 142, 170, 251, 60, 148,
+       183, 10, 246, 249, 43, 253, 107, 245, 140, 119, 123, 205, 25, 71,
+       238, 222, 252, 166, 105, 240, 234, 172, 34, 218, 142, 27, 33, 185,
+       58, 76, 25, 28, 8, 223, 95, 53, 87, 154, 131, 201, 247, 8, 60,
+       138, 242, 149, 155, 211, 1, 90, 219, 114, 230, 55, 144, 154, 244,
+       139, 196, 156, 163, 45, 190, 246, 164, 166, 243, 149, 213, 134, 9,
+       172, 255, 250, 93, 14, 251, 55, 135, 45, 95, 220, 85, 23, 238,
+       154, 66, 23, 185, 164, 240, 139, 34, 87, 119, 41, 115, 118, 213,
+       125, 226, 105, 193, 57, 60, 241, 162, 239, 20, 56, 243, 165, 51,
+       70, 129, 157, 183, 162, 104, 61, 167, 170, 179, 10, 48, 220, 115,
+       72, 123, 167, 87, 121, 145, 18, 88, 203, 96, 205, 182, 94, 194,
+       128, 80, 133, 42, 56, 133, 104, 239, 213, 197, 199, 127, 85, 5,
+       125, 2, 51, 121, 62, 96, 88, 154, 131, 168, 90, 186, 113, 157,
+       103, 237, 160, 9, 115, 218, 244, 170, 36, 191, 156, 191, 158, 170,
+       182, 235, 90, 183, 72, 183, 229, 96, 12, 75, 219, 127, 234, 17,
+       50, 250, 219, 63, 172, 167, 95, 118, 156, 121, 151, 144, 72, 121,
+       251, 229, 210, 98, 39, 215, 32, 193, 74, 162, 17, 181, 225, 96,
+       118, 254, 19, 216, 1, 154, 148, 72, 109, 164, 166, 12, 165, 243,
+       36, 184, 86, 64, 175, 165, 139, 102, 188, 134, 172, 243, 139, 1,
+       204, 254, 89, 78, 227, 85, 125, 177, 24, 193, 147, 192, 193, 118,
+       223, 151, 132, 119, 181, 70, 176, 6, 69, 229, 29, 71, 64, 123, 69,
+       168, 250, 82, 67, 9, 20, 6, 88, 140, 37, 160, 44, 182, 65, 142,
+       163, 216, 161, 151, 103, 168, 120, 3, 105, 98, 242, 86, 116, 190,
+       253, 86, 123, 175, 126, 104, 170, 168, 213, 62, 190, 238, 6, 29,
+       128, 250, 164, 202, 86, 253, 52, 160, 199, 218, 66, 173, 47, 146,
+       245, 116, 53, 94, 217, 57, 91, 222, 53, 173, 123, 125, 158, 53,
+       159, 149, 149, 45, 239, 116, 110, 221, 75, 251, 229, 247, 95, 172,
+       86, 127, 107, 170, 230, 26, 207, 240, 176, 71, 235, 87, 100, 155,
+       40, 172, 118, 190, 171, 163, 227, 149, 150, 107, 166, 209, 30,
+       126, 218, 107, 215, 76, 255, 206, 108, 172, 184, 122, 141, 237,
+       81, 3, 211, 151, 173, 24, 182, 241, 64, 56, 193, 50, 232, 16, 26,
+       107, 250, 51, 219, 215, 21, 123, 210, 72, 214, 34, 144, 12, 79,
+       127, 18, 170, 102, 118, 116, 130, 74, 82, 243, 115, 32, 96, 112,
+       110, 42, 168, 49, 152, 21, 47, 173, 174, 162, 64, 32, 234, 224,
+       168, 188, 233, 98, 234, 213, 211, 234, 200, 86, 129, 229, 2, 123,
+       219, 124, 112, 120, 232, 19, 250, 90, 179, 152, 191, 251, 205,
+       135, 105, 103, 27, 240, 130, 196, 251, 159, 49, 168, 232, 37, 155,
+       174, 216, 66, 112, 149, 215, 225, 75, 37, 88, 106, 88, 83, 213,
+       131, 16, 77, 162, 103, 68, 136, 240, 133, 163, 211, 67, 82, 164,
+       44, 8, 238, 228, 233, 136, 250, 230, 111, 138, 157, 86, 122, 229,
+       108, 239, 200, 167, 133, 202, 176, 184, 170, 152, 45, 178, 99, 13,
+       60, 140, 248, 119, 69, 127, 114, 122, 83, 38, 111, 11, 123, 105,
+       25, 25, 57, 222, 131, 42, 104, 240, 57, 157, 87, 203, 81, 37, 119,
+       235, 86, 130, 183, 32, 99, 193, 100, 51, 232, 72, 83, 224, 113,
+       250, 25, 8, 221, 173, 120, 140, 22, 191, 173, 182, 37, 214, 20, 8,
+       171, 228, 237, 237, 90, 164, 6, 239, 66, 142, 254, 33, 174, 236,
+       200, 146, 25, 195, 76, 232, 125, 130, 123, 75, 3, 231, 80, 35, 14,
+       255, 56, 4, 143, 44, 21, 127, 179, 128, 13, 222, 151, 191, 250,
+       134, 175, 252, 30, 11, 88, 102, 252, 247, 169, 32, 247, 121, 55,
+       235, 227, 148, 11, 127, 253, 166, 47, 200, 152, 123, 161, 177, 5,
+       121, 59, 206, 108, 141, 190, 112, 204, 200, 221, 226, 181, 213,
+       225, 102, 206, 120, 95, 110, 192, 35, 170, 185, 114, 152, 35, 170,
+       94, 186, 33, 179, 64, 139, 213, 154, 84, 192, 233, 46, 158, 20,
+       177, 70, 165, 42, 48, 65, 122, 227, 14, 201, 67, 40, 92, 253, 188,
+       146, 254, 88, 21, 42, 97, 8, 124, 205, 122, 110, 29, 210, 86, 244,
+       245, 4, 230, 8, 107, 209, 40, 117, 88, 248, 132, 106, 72, 163, 10,
+       173, 243, 233, 133, 27, 115, 187, 254, 34, 74, 112, 178, 154, 75,
+       244, 184, 70, 159, 79, 92, 35, 44, 222, 111, 252, 229, 59, 179,
+       145, 6, 11, 178, 209, 19, 86, 154, 139, 146, 84, 37, 95, 69, 142,
+       222, 253, 54, 175, 250, 190, 54, 57, 250, 3, 85, 107, 0, 64, 183,
+       119, 111, 144, 52, 121, 11, 255, 126, 175, 101, 213, 225, 224,
+       104, 139, 18, 215, 54, 190, 58, 192, 189, 231, 140, 4, 200, 163,
+       44, 239, 42, 65, 230, 179, 155, 193, 98, 139, 2, 253, 240, 32,
+       158, 139, 53, 20, 165, 91, 39, 164, 97, 75, 117, 163, 171, 233,
+       95, 97, 121, 70, 64, 88, 188, 164, 89, 8, 18, 188, 147, 50, 108,
+       223, 44, 28, 129, 238, 223, 143, 242, 180, 123, 48, 166, 80, 41,
+       244, 153, 23, 139, 127, 150, 189, 40, 156, 214, 174, 142, 183,
+       253, 133, 156, 79, 242, 192, 83, 93, 216, 251, 135, 132, 60, 127,
+       174, 178, 170, 186, 79, 229, 185, 64, 154, 95, 85, 191, 172, 220,
+       126, 8, 253, 59, 179, 145, 150, 118, 186, 241, 95, 17, 218, 235,
+       213, 77, 183, 215, 49, 211, 121, 73, 122, 27, 207, 252, 71, 96,
+       188, 238, 83, 76, 220, 160, 30, 216, 6, 110, 203, 50, 101, 21,
+       118, 141, 37, 252, 125, 186, 72, 53, 222, 143, 39, 189, 180, 150,
+       110, 183, 165, 92, 210, 211, 237, 46, 176, 227, 230, 39, 63, 237,
+       252, 137, 37, 255, 169, 115, 238, 193, 22, 164, 189, 109, 173, 84,
+       105, 109, 116, 63, 91, 56, 80, 104, 117, 188, 211, 29, 155, 112,
+       94, 156, 21, 110, 233, 182, 101, 14, 70, 233, 160, 148, 119, 170,
+       86, 241, 55, 41, 107, 204, 86, 215, 203, 120, 67, 192, 252, 138,
+       113, 205, 245, 180, 126, 232, 23, 254, 203, 187, 188, 255, 59, 77,
+       161, 168, 119, 175, 114, 252, 29, 213, 29, 235, 146, 198, 23, 184,
+       36, 72, 139, 68, 255, 83, 41, 96, 118, 83, 29, 250, 107, 129, 57,
+       63, 233, 172, 47, 80, 56, 19, 161, 51, 28, 222, 23, 239, 58, 166,
+       187, 248, 132, 8, 90, 102, 253, 247, 41, 66, 245, 127, 61, 251,
+       131, 145, 27, 63, 233, 230, 175, 196, 136, 115, 33, 177, 80, 105,
+       6, 136, 77, 2, 98, 236, 236, 144, 226, 2, 38, 130, 97, 211, 104,
+       196, 106, 242, 90, 235, 195, 124, 176, 32, 142, 89, 1, 9, 123, 8,
+       34, 50, 206, 156, 77, 247, 192, 10, 222, 253, 118, 86, 64, 224,
+       118, 138, 73, 238, 102, 145, 25, 250, 251, 85, 8, 134, 249, 109,
+       201, 72, 120, 132, 4, 36, 145, 153, 205, 120, 225, 19, 236, 86,
+       109, 22, 141, 226, 107, 78, 107, 42, 74, 42, 51, 22, 246, 194, 12,
+       164, 170, 40, 244, 104, 37, 224, 88, 81, 221, 115, 194, 206, 49,
+       21, 54, 53, 99, 51, 241, 23, 8, 88, 118, 190, 35, 16, 18, 176, 81,
+       48, 69, 163, 112, 65, 225, 1, 164, 179, 68, 107, 195, 1, 28, 10,
+       162, 64, 174, 160, 131, 238, 131, 128, 209, 206, 98, 196, 106,
+       222, 1, 33, 197, 64, 156, 4, 175, 116, 140, 187, 57, 4, 27, 95,
+       99, 136, 86, 151, 170, 112, 20, 64, 90, 199, 57, 142, 180, 164,
+       126, 185, 147, 237, 225, 153, 20, 223, 48, 76, 138, 192, 63, 142,
+       57, 252, 40, 104, 200, 165, 96, 107, 120, 6, 54, 179, 110, 169,
+       147, 167, 67, 24, 75, 236, 243, 20, 12, 208, 197, 18, 206, 197,
+       181, 53, 228, 248, 94, 218, 121, 249, 53, 34, 25, 221, 85, 188,
+       163, 125, 164, 45, 42, 21, 74, 183, 164, 146, 236, 64, 223, 11,
+       251, 181, 251, 195, 117, 255, 107, 6, 206, 127, 220, 149, 142,
+       254, 153, 70, 23, 249, 150, 174, 141, 54, 114, 247, 43, 97, 125,
+       246, 185, 170, 121, 67, 187, 63, 251, 135, 197, 126, 178, 114,
+       164, 115, 15, 17, 102, 129, 75, 243, 185, 65, 172, 125, 219, 135,
+       216, 140, 182, 234, 238, 5, 255, 213, 148, 129, 55, 212, 68, 56,
+       234, 193, 159, 7, 181, 215, 60, 165, 113, 233, 159, 167, 83, 233,
+       71, 37, 217, 2, 67, 92, 40, 224, 95, 154, 142, 243, 26, 162, 125,
+       157, 185, 197, 1, 118, 247, 11, 180, 102, 74, 172, 182, 154, 57,
+       189, 56, 131, 175, 87, 12, 153, 172, 254, 98, 182, 135, 59, 251,
+       21, 22, 77, 186, 247, 207, 119, 31, 123, 146, 68, 15, 222, 215,
+       29, 111, 239, 166, 6, 239, 121, 68, 194, 215, 134, 81, 103, 179,
+       99, 118, 245, 63, 239, 249, 149, 61, 204, 240, 43, 239, 128, 61,
+       178, 177, 112, 243, 73, 244, 230, 230, 34, 156, 4, 25, 162, 179,
+       251, 88, 27, 21, 57, 142, 253, 117, 199, 200, 199, 193, 232, 144,
+       58, 216, 146, 5, 211, 195, 33, 103, 158, 241, 220, 252, 22, 254,
+       187, 155, 202, 188, 237, 253, 254, 255, 35, 223, 193, 23, 167,
+       245, 79, 58, 239, 122, 222, 239, 190, 28, 240, 67, 213, 63, 209,
+       117, 232, 253, 31, 95, 121, 13, 121, 245, 43, 95, 63, 182, 117,
+       222, 145, 223, 239, 220, 35, 121, 253, 247, 251, 234, 158, 55,
+       191, 230, 243, 194, 18, 25, 155, 236, 200, 249, 68, 173, 87, 176,
+       151, 156, 142, 110, 75, 235, 3, 78, 149, 119, 5, 244, 227, 133,
+       16, 154, 235, 28, 25, 229, 222, 66, 110, 151, 182, 11, 96, 180, 6,
+       188, 146, 130, 241, 236, 247, 65, 207, 167, 119, 233, 130, 96, 69,
+       131, 96, 148, 242, 90, 139, 128, 117, 47, 11, 156, 30, 215, 250,
+       165, 236, 94, 208, 191, 31, 115, 125, 239, 107, 105, 219, 239,
+       219, 167, 210, 62, 246, 90, 242, 155, 251, 119, 195, 218, 245,
+       228, 19, 197, 56, 148, 53, 173, 60, 165, 135, 250, 251, 2, 92,
+       214, 56, 83, 171, 129, 103, 120, 21, 181, 237, 183, 96, 140, 58,
+       85, 50, 200, 116, 211, 92, 0, 160, 137, 145, 212, 172, 168, 135,
+       62, 1, 74, 82, 177, 163, 72, 72, 105, 27, 35, 153, 19, 88, 211,
+       195, 13, 134, 158, 64, 136, 64, 161, 168, 214, 120, 153, 176, 46,
+       77, 153, 138, 139, 254, 144, 187, 143, 159, 65, 142, 135, 213,
+       253, 215, 75, 69, 242, 162, 145, 209, 207, 190, 180, 61, 29, 113,
+       252, 69, 210, 228, 205, 2, 86, 239, 1, 164, 184, 11, 75, 41, 53,
+       18, 216, 197, 165, 241, 76, 35, 1, 138, 187, 237, 197, 31, 227,
+       126, 252, 14, 155, 132, 71, 137, 22, 83, 104, 107, 85, 65, 195,
+       214, 121, 72, 184, 229, 122, 138, 30, 173, 239, 150, 117, 223,
+       176, 104, 154, 132, 63, 140, 56, 140, 185, 76, 111, 95, 84, 246,
+       235, 240, 212, 64, 246, 2, 113, 249, 181, 97, 120, 228, 18, 234,
+       169, 189, 52, 191, 115, 107, 224, 0, 119, 187, 116, 232, 34, 156,
+       39, 184, 77, 253, 145, 103, 137, 95, 120, 63, 46, 188, 38, 153,
+       173, 179, 243, 1, 182, 47, 50, 213, 147, 86, 90, 235, 209, 12, 23,
+       223, 17, 74, 223, 253, 98, 14, 109, 244, 100, 138, 114, 70, 241,
+       34, 185, 106, 102, 108, 38, 206, 193, 208, 7, 104, 68, 170, 242,
+       128, 41, 177, 96, 169, 97, 143, 197, 101, 180, 14, 111, 191, 112,
+       234, 122, 204, 243, 33, 152, 50, 21, 70, 68, 44, 233, 248, 101,
+       15, 236, 174, 53, 132, 108, 248, 82, 57, 112, 193, 144, 137, 140,
+       11, 132, 79, 14, 161, 232, 74, 134, 162, 96, 128, 120, 140, 106,
+       160, 88, 171, 193, 80, 180, 132, 143, 124, 81, 10, 232, 128, 70,
+       168, 130, 146, 203, 52, 184, 128, 171, 241, 131, 141, 204, 238,
+       78, 218, 165, 69, 251, 149, 22, 81, 155, 192, 30, 54, 159, 239,
+       136, 39, 41, 22, 156, 22, 252, 117, 228, 62, 124, 27, 117, 251,
+       119, 119, 91, 57, 159, 27, 63, 142, 181, 140, 188, 244, 65, 194,
+       206, 255, 117, 133, 239, 224, 216, 147, 54, 19, 198, 206, 196, 35,
+       196, 65, 69, 138, 251, 106, 66, 123, 173, 157, 120, 180, 135, 163,
+       152, 179, 0, 200, 144, 162, 202, 131, 253, 107, 122, 130, 191,
+       203, 37, 201, 221, 150, 206, 255, 19, 89, 192, 214, 9, 78, 116,
+       245, 77, 202, 147, 254, 255, 10, 239, 245, 63, 120, 143, 236, 51,
+       148, 254, 252, 11, 126, 108, 181, 164, 59, 252, 182, 44, 254, 26,
+       237, 157, 40, 147, 139, 135, 101, 255, 181, 205, 248, 69, 140,
+       238, 199, 255, 164, 140, 252, 25, 25, 10, 141, 86, 153, 215, 177,
+       184, 71, 173, 5, 238, 147, 172, 170, 38, 196, 106, 59, 138, 145,
+       22, 152, 86, 245, 30, 117, 154, 67, 191, 76, 169, 140, 49, 143,
+       72, 109, 116, 15, 77, 191, 96, 0, 240, 76, 51, 33, 144, 81, 92,
+       138, 6, 108, 232, 186, 81, 29, 228, 171, 228, 80, 121, 136, 82,
+       136, 160, 169, 14, 81, 4, 137, 96, 103, 118, 49, 66, 0, 179, 128,
+       32, 65, 72, 170, 2, 64, 72, 248, 68, 21, 77, 128, 80, 97, 112, 8,
+       80, 170, 89, 160, 248, 113, 49, 222, 81, 19, 63, 229, 38, 16, 143,
+       151, 194, 124, 179, 140, 236, 28, 30, 216, 177, 192, 203, 223, 21,
+       71, 162, 132, 12, 70, 18, 207, 98, 153, 118, 131, 235, 246, 117,
+       4, 94, 231, 41, 130, 182, 68, 110, 234, 6, 213, 214, 153, 4, 255,
+       124, 36, 174, 193, 55, 132, 61, 141, 253, 233, 100, 77, 173, 90,
+       68, 185, 97, 240, 166, 8, 75, 8, 158, 247, 128, 196, 236, 110,
+       205, 240, 229, 133, 170, 123, 69, 87, 98, 164, 218, 68, 177, 15,
+       109, 199, 52, 91, 203, 120, 85, 232, 246, 102, 115, 89, 179, 33,
+       120, 224, 22, 238, 237, 180, 109, 190, 118, 202, 161, 144, 127,
+       169, 80, 233, 24, 213, 55, 190, 19, 192, 52, 103, 164, 5, 206, 35,
+       45, 215, 34, 192, 162, 179, 153, 129, 74, 139, 50, 173, 243, 229,
+       30, 3, 35, 20, 165, 122, 54, 79, 74, 142, 118, 147, 174, 240, 132,
+       164, 217, 231, 105, 232, 183, 128, 126, 237, 135, 231, 196, 131,
+       12, 236, 50, 68, 175, 169, 53, 191, 57, 141, 52, 60, 249, 233,
+       158, 171, 195, 218, 86, 165, 252, 162, 147, 149, 193, 108, 95,
+       220, 14, 216, 154, 186, 245, 178, 217, 196, 145, 124, 245, 201,
+       84, 224, 43, 33, 99, 108, 124, 134, 235, 104, 199, 224, 209, 2,
+       113, 220, 53, 228, 216, 44, 123, 111, 193, 163, 178, 157, 17, 120,
+       129, 58, 69, 174, 114, 244, 114, 187, 47, 172, 75, 213, 147, 120,
+       129, 204, 252, 111, 32, 222, 167, 55, 236, 177, 247, 225, 204, 43,
+       178, 157, 115, 81, 171, 187, 59, 46, 54, 223, 214, 101, 113, 234,
+       174, 35, 94, 159, 91, 51, 25, 219, 79, 153, 125, 40, 151, 223, 53,
+       87, 210, 38, 159, 242, 162, 220, 29, 254, 183, 223, 177, 5, 76,
+       75, 220, 249, 166, 8, 109, 128, 172, 20, 66, 134, 223, 195, 137,
+       202, 98, 193, 110, 202, 3, 144, 199, 97, 132, 161, 106, 64, 172,
+       179, 17, 32, 88, 173, 90, 236, 157, 200, 215, 167, 133, 4, 172, 3,
+       35, 171, 54, 64, 104, 234, 9, 168, 90, 41, 128, 255, 123, 173,
+       134, 121, 115, 138, 220, 10, 214, 150, 215, 250, 165, 236, 95,
+       184, 187, 31, 113, 85, 207, 251, 44, 219, 247, 203, 141, 18, 122,
+       244, 26, 243, 155, 254, 223, 207, 152, 115, 231, 3, 46, 150, 212,
+       181, 245, 58, 250, 186, 219, 223, 52, 167, 204, 106, 191, 141,
+       223, 227, 135, 181, 180, 96, 28, 254, 142, 87, 223, 231, 158, 245,
+       75, 149, 73, 58, 186, 212, 117, 172, 240, 87, 251, 139, 116, 93,
+       188, 187, 103, 10, 166, 63, 215, 24, 130, 120, 146, 195, 71, 189,
+       54, 170, 200, 72, 75, 139, 186, 13, 110, 188, 29, 214, 252, 103,
+       181, 148, 214, 19, 47, 15, 50, 195, 232, 183, 221, 227, 124, 239,
+       19, 189, 243, 227, 202, 17, 39, 108, 252, 202, 60, 105, 226, 232,
+       223, 131, 206, 201, 71, 164, 233, 10, 75, 249, 113, 80, 120, 252,
+       51, 218, 90, 51, 218, 216, 127, 205, 135, 45, 247, 187, 244, 130,
+       201, 131, 93, 189, 104, 28, 124, 57, 233, 30, 243, 121, 255, 122,
+       138, 219, 166, 7, 238, 46, 244, 205, 195, 69, 214, 251, 114, 201,
+       64, 128, 171, 65, 236, 196, 158, 83, 137, 124, 118, 140, 242, 183,
+       167, 16, 211, 243, 73, 91, 113, 86, 232, 218, 58, 69, 203, 34,
+       111, 227, 213, 85, 162, 113, 252, 2, 72, 8, 114, 85, 33, 218, 105,
+       7, 253, 167, 102, 16, 171, 130, 22, 253, 160, 46, 42, 156, 116,
+       220, 181, 72, 135, 251, 82, 1, 2, 132, 237, 76, 53, 247, 147, 18,
+       178, 5, 151, 252, 222, 253, 57, 237, 70, 228, 236, 2, 159, 91, 38,
+       114, 223, 115, 26, 34, 184, 150, 39, 110, 200, 123, 161, 81, 118,
+       23, 199, 172, 250, 34, 6, 191, 19, 226, 184, 237, 70, 101, 235,
+       222, 95, 199, 237, 118, 153, 203, 207, 8, 184, 54, 237, 190, 237,
+       254, 170, 81, 18, 75, 202, 168, 118, 154, 178, 71, 124, 13, 126,
+       167, 173, 136, 182, 64, 126, 45, 134, 69, 196, 187, 4, 202, 246,
+       37, 42, 131, 109, 156, 171, 207, 1, 161, 31, 147, 228, 136, 172,
+       103, 172, 17, 107, 64, 148, 130, 72, 66, 163, 43, 34, 25, 81, 184,
+       3, 96, 12, 20, 126, 64, 196, 8, 163, 136, 218, 122, 188, 245, 47,
+       28, 93, 51, 161, 190, 150, 63, 46, 63, 65, 31, 167, 245, 253, 2,
+       72, 68, 195, 130, 215, 243, 117, 155, 34, 120, 12, 59, 166, 32,
+       146, 154, 77, 230, 224, 73, 222, 134, 225, 27, 64, 218, 101, 138,
+       248, 173, 162, 145, 8, 119, 146, 202, 21, 48, 147, 11, 129, 107,
+       122, 130, 121, 157, 59, 101, 20, 46, 231, 51, 96, 104, 122, 78,
+       115, 57, 16, 114, 184, 102, 116, 110, 153, 184, 241, 45, 229, 173,
+       32, 0, 105, 107, 208, 251, 176, 26, 118, 238, 101, 139, 240, 120,
+       197, 128, 241, 103, 43, 89, 52, 149, 202, 184, 199, 98, 108, 167,
+       82, 221, 130, 216, 128, 43, 127, 170, 94, 138, 1, 160, 131, 238,
+       153, 228, 65, 13, 238, 203, 169, 0, 242, 246, 120, 162, 217, 59,
+       120, 153, 27, 3, 250, 19, 137, 222, 159, 120, 216, 74, 162, 186,
+       52, 108, 200, 69, 108, 235, 233, 202, 62, 162, 108, 137, 147, 165,
+       87, 24, 59, 252, 227, 24, 8, 114, 213, 18, 68, 5, 5, 61, 229, 253,
+       94, 216, 56, 233, 42, 234, 93, 209, 67, 228, 199, 12, 252, 10, 51,
+       217, 98, 48, 88, 248, 199, 90, 74, 43, 10, 189, 251, 205, 133,
+       121, 115, 155, 118, 170, 59, 26, 114, 221, 101, 31, 249, 115, 61,
+       238, 246, 231, 8, 191, 183, 125, 255, 189, 191, 140, 141, 251, 37,
+       200, 222, 255, 251, 135, 151, 172, 109, 223, 15, 82, 191, 248, 45,
+       220, 89, 89, 139, 93, 52, 53, 159, 223, 186, 239, 196, 17, 221,
+       21, 159, 101, 50, 145, 195, 251, 250, 223, 218, 141, 77, 243, 132,
+       204, 185, 101, 228, 11, 239, 188, 118, 162, 74, 72, 213, 225, 209,
+       32, 19, 109, 115, 235, 224, 212, 237, 26, 108, 143, 239, 164, 132,
+       242, 3, 168, 167, 126, 159, 246, 236, 36, 255, 252, 155, 154, 184,
+       124, 212, 251, 253, 59, 223, 83, 119, 111, 225, 103, 138, 234,
+       248, 154, 239, 190, 140, 251, 179, 161, 102, 114, 245, 65, 235, 9,
+       173, 204, 235, 54, 52, 238, 8, 0, 205, 63, 39, 84, 98, 122, 193,
+       118, 172, 192, 28, 24, 71, 46, 199, 181, 199, 165, 238, 253, 226,
+       94, 217, 180, 238, 191, 179, 150, 136, 223, 104, 239, 93, 143,
+       157, 243, 241, 215, 250, 71, 154, 235, 59, 126, 207, 172, 143,
+       247, 186, 222, 50, 137, 120, 72, 85, 217, 210, 238, 11, 53, 188,
+       11, 42, 25, 46, 20, 152, 147, 135, 64, 14, 43, 90, 247, 59, 92, 1,
+       127, 83, 14, 78, 14, 178, 169, 6, 158, 221, 133, 164, 231, 158,
+       19, 192, 31, 108, 234, 36, 201, 233, 227, 171, 129, 50, 239, 26,
+       255, 57, 50, 223, 75, 153, 8, 185, 138, 249, 36, 96, 229, 15, 51,
+       126, 63, 85, 162, 222, 147, 25, 47, 16, 233, 110, 148, 95, 175,
+       188, 157, 197, 158, 119, 239, 176, 145, 39, 213, 240, 2, 217, 127,
+       237, 69, 48, 94, 79, 178, 98, 236, 158, 236, 251, 37, 211, 166, 6,
+       228, 252, 110, 205, 88, 253, 46, 234, 201, 101, 176, 46, 183, 12,
+       125, 91, 150, 86, 26, 123, 185, 184, 99, 237, 25, 63, 246, 108,
+       250, 174, 245, 167, 19, 254, 5, 182, 9, 14, 213, 26, 124, 26, 203,
+       159, 198, 169, 133, 1, 174, 249, 119, 180, 43, 104, 55, 127, 225,
+       114, 212, 179, 33, 144, 112, 131, 142, 44, 28, 187, 248, 101, 39,
+       206, 222, 52, 192, 172, 128, 192, 41, 64, 179, 148, 111, 169, 29,
+       20, 143, 203, 53, 173, 9, 198, 33, 72, 6, 135, 87, 232, 16, 18,
+       105, 219, 49, 175, 246, 85, 127, 210, 74, 143, 15, 43, 129, 96,
+       239, 116, 152, 250, 37, 123, 33, 113, 139, 175, 28, 148, 116, 238,
+       155, 23, 141, 206, 56, 132, 255, 247, 252, 154, 34, 23, 142, 82,
+       142, 111, 246, 193, 200, 236, 49, 78, 154, 91, 123, 249, 252, 200,
+       226, 221, 190, 95, 206, 182, 126, 159, 86, 239, 243, 30, 30, 229,
+       238, 158, 255, 250, 149, 137, 142, 145, 145, 240, 46, 169, 23, 62,
+       11, 90, 112, 148, 51, 128, 232, 71, 31, 50, 24, 51, 216, 65, 66,
+       12, 182, 122, 196, 136, 192, 129, 161, 18, 155, 123, 140, 242,
+       194, 191, 230, 188, 192, 90, 227, 52, 158, 165, 64, 238, 251, 19,
+       193, 196, 153, 32, 239, 120, 36, 170, 194, 53, 0, 37, 219, 59, 88,
+       254, 239, 119, 191, 123, 80, 69, 69, 255, 167, 123, 31, 191, 244,
+       110, 149, 255, 207, 140, 179, 61, 253, 214, 253, 130, 144, 247,
+       143, 108, 121, 210, 178, 248, 193, 166, 26, 233, 159, 107, 63, 22,
+       247, 201, 8, 222, 79, 55, 199, 45, 189, 146, 244, 197, 193, 204,
+       138, 254, 196, 173, 128, 217, 29, 135, 82, 121, 219, 228, 200,
+       249, 20, 173, 91, 84, 240, 189, 143, 249, 107, 71, 59, 55, 31,
+       211, 84, 102, 241, 70, 24, 122, 200, 148, 153, 5, 249, 176, 97,
+       70, 141, 92, 171, 96, 73, 61, 1, 243, 26, 99, 72, 40, 80, 120,
+       137, 78, 240, 42, 179, 65, 205, 148, 162, 130, 1, 101, 11, 98,
+       130, 137, 152, 27, 248, 237, 181, 49, 219, 190, 27, 86, 84, 156,
+       215, 32, 109, 197, 58, 183, 24, 147, 141, 50, 209, 203, 249, 58,
+       202, 154, 8, 169, 179, 210, 86, 147, 177, 132, 38, 20, 247, 49,
+       239, 250, 117, 2, 50, 133, 73, 253, 198, 12, 34, 253, 252, 65,
+       106, 176, 182, 246, 134, 136, 112, 240, 31, 186, 172, 184, 186,
+       221, 253, 210, 231, 159, 13, 232, 25, 46, 252, 102, 144, 201, 187,
+       227, 17, 62, 47, 122, 183, 251, 215, 16, 123, 209, 12, 222, 202,
+       11, 123, 190, 53, 160, 158, 188, 55, 232, 207, 122, 101, 188, 174,
+       150, 163, 164, 39, 253, 5, 213, 217, 34, 77, 230, 127, 126, 131,
+       72, 196, 139, 221, 254, 156, 60, 184, 139, 97, 25, 248, 147, 54,
+       165, 185, 207, 119, 67, 15, 79, 213, 253, 243, 56, 71, 219, 180,
+       217, 211, 75, 127, 178, 117, 39, 114, 223, 31, 78, 173, 178, 2,
+       62, 57, 60, 192, 95, 231, 125, 103, 160, 83, 54, 247, 61, 238,
+       241, 217, 13, 110, 248, 171, 111, 192, 173, 163, 169, 17, 34, 143,
+       248, 237, 244, 137, 188, 166, 47, 1, 120, 66, 162, 40, 52, 64,
+       238, 219, 19, 65, 26, 56, 67, 125, 172, 156, 30, 66, 213, 152,
+       240, 136, 59, 150, 110, 160, 51, 150, 184, 83, 61, 201, 250, 247,
+       41, 28, 54, 208, 255, 187, 159, 145, 189, 141, 21, 206, 218, 127,
+       186, 195, 205, 12, 120, 91, 81, 107, 146, 117, 129, 158, 116, 23,
+       243, 183, 230, 25, 135, 128, 66, 253, 160, 124, 232, 16, 110, 221,
+       149, 136, 147, 241, 21, 51, 34, 52, 139, 14, 50, 43, 146, 172,
+       157, 133, 134, 79, 135, 173, 232, 11, 38, 232, 36, 132, 216, 171,
+       194, 17, 78, 43, 66, 187, 185, 148, 4, 59, 81, 94, 230, 142, 108,
+       166, 172, 185, 141, 44, 153, 139, 138, 63, 141, 29, 142, 111, 74,
+       10, 205, 71, 237, 7, 30, 71, 219, 147, 217, 215, 219, 125, 146,
+       109, 159, 66, 78, 48, 237, 224, 171, 119, 159, 216, 150, 254, 149,
+       59, 88, 255, 207, 170, 151, 85, 255, 242, 145, 71, 251, 144, 91,
+       79, 233, 255, 151, 253, 6, 243, 80, 91, 232, 165, 174, 75, 157,
+       151, 14, 172, 158, 239, 183, 37, 195, 64, 6, 247, 125, 20, 72, 24,
+       225, 58, 232, 133, 45, 177, 148, 248, 149, 123, 40, 96, 218, 148,
+       87, 121, 233, 74, 248, 133, 49, 30, 205, 98, 114, 137, 59, 193,
+       194, 169, 33, 103, 52, 206, 28, 135, 219, 45, 133, 41, 111, 160,
+       189, 83, 227, 227, 229, 126, 91, 216, 67, 232, 119, 231, 91, 157,
+       255, 124, 126, 220, 181, 255, 143, 182, 253, 128, 215, 249, 161,
+       196, 239, 191, 116, 241, 74, 124, 226, 204, 255, 252, 190, 79,
+       175, 70, 238, 163, 140, 159, 119, 116, 239, 189, 251, 133, 198,
+       27, 178, 211, 119, 125, 158, 43, 7, 116, 167, 254, 52, 205, 11,
+       127, 212, 133, 230, 231, 86, 136, 232, 66, 113, 216, 53, 64, 248,
+       106, 3, 195, 72, 187, 152, 61, 113, 172, 175, 40, 89, 58, 242,
+       138, 237, 127, 133, 165, 236, 47, 68, 159, 83, 250, 186, 108, 138,
+       49, 209, 190, 205, 196, 124, 93, 201, 118, 193, 146, 172, 222,
+       245, 182, 202, 252, 82, 61, 246, 104, 86, 250, 79, 201, 202, 192,
+       207, 48, 226, 10, 239, 202, 117, 93, 234, 233, 107, 219, 11, 99,
+       223, 241, 181, 184, 139, 57, 117, 27, 73, 132, 136, 43, 19, 225,
+       188, 143, 65, 55, 141, 172, 18, 76, 142, 1, 80, 135, 134, 44, 79,
+       92, 240, 248, 192, 252, 173, 216, 5, 114, 2, 136, 147, 41, 131,
+       207, 31, 220, 44, 146, 188, 101, 204, 80, 212, 102, 244, 227, 180,
+       71, 78, 99, 106, 110, 228, 203, 6, 253, 178, 58, 74, 24, 24, 184,
+       169, 141, 255, 212, 255, 124, 171, 22, 93, 251, 147, 234, 182,
+       109, 122, 253, 189, 119, 149, 245, 253, 165, 233, 199, 187, 159,
+       123, 255, 229, 158, 127, 228, 118, 127, 180, 90, 137, 143, 68, 70,
+       199, 240, 49, 78, 240, 102, 18, 50, 139, 157, 120, 204, 134, 226,
+       105, 183, 113, 108, 144, 162, 230, 150, 249, 121, 118, 251, 27,
+       11, 103, 205, 39, 82, 175, 35, 204, 76, 218, 167, 235, 108, 182,
+       228, 234, 102, 191, 143, 205, 185, 39, 204, 51, 127, 234, 131,
+       103, 110, 245, 117, 232, 139, 186, 248, 157, 132, 81, 15, 211, 29,
+       132, 24, 170, 249, 114, 114, 193, 58, 233, 24, 58, 107, 242, 163,
+       235, 253, 150, 123, 146, 8, 244, 42, 124, 160, 57, 163, 119, 201,
+       82, 205, 42, 61, 41, 57, 143, 223, 72, 144, 179, 25, 213, 17, 26,
+       62, 138, 151, 221, 213, 13, 127, 224, 2, 135, 163, 150, 77, 118,
+       238, 172, 34, 222, 134, 73, 178, 57, 251, 207, 189, 53, 11, 134,
+       119, 53, 71, 200, 228, 11, 226, 162, 250, 69, 146, 21, 251, 209,
+       11, 114, 198, 86, 188, 95, 135, 196, 111, 223, 134, 232, 74, 100,
+       234, 44, 215, 249, 239, 106, 161, 120, 107, 202, 223, 184, 178,
+       207, 122, 57, 58, 251, 134, 90, 157, 107, 237, 151, 214, 94, 115,
+       37, 72, 222, 231, 29, 63, 178, 224, 118, 181, 157, 237, 221, 137,
+       53, 223, 243, 237, 170, 209, 63, 166, 189, 115, 184, 236, 83, 122,
+       93, 205, 86, 228, 85, 2, 224, 15, 35, 201, 33, 17, 216, 232, 134,
+       98, 111, 39, 88, 191, 243, 217, 5, 57, 123, 27, 90, 26, 198, 29,
+       19, 198, 242, 34, 166, 247, 60, 130, 202, 226, 244, 115, 161, 97,
+       127, 119, 27, 114, 113, 155, 24, 110, 60, 38, 207, 194, 140, 123,
+       177, 184, 37, 248, 188, 190, 250, 201, 151, 172, 154, 223, 20,
+       169, 244, 252, 75, 43, 135, 115, 127, 83, 114, 105, 250, 49, 109,
+       7, 125, 250, 208, 121, 143, 251, 34, 235, 194, 136, 93, 129, 168,
+       198, 15, 132, 120, 195, 40, 136, 117, 196, 232, 171, 147, 209, 6,
+       58, 130, 241, 60, 20, 142, 235, 85, 12, 120, 142, 28, 93, 51, 188,
+       19, 198, 183, 97, 148, 140, 218, 35, 124, 255, 33, 64, 252, 121,
+       179, 227, 72, 131, 18, 206, 241, 167, 175, 136, 49, 50, 37, 235,
+       72, 131, 76, 147, 221, 217, 237, 167, 174, 180, 6, 6, 237, 98, 98,
+       195, 99, 163, 202, 248, 99, 9, 63, 221, 188, 7, 255, 37, 144, 0,
+       13, 40, 27, 211, 123, 235, 118, 20, 251, 208, 79, 105, 124, 230,
+       93, 223, 255, 96, 182, 157, 151, 239, 135, 48, 188, 249, 119, 253,
+       170, 172, 63, 159, 65, 253, 63, 224, 110, 235, 102, 83, 123, 248,
+       5, 80, 247, 163, 91, 31, 190, 240, 126, 153, 159, 207, 207, 183,
+       109, 245, 214, 217, 186, 197, 55, 142, 124, 249, 32, 185, 58, 253,
+       86, 206, 185, 119, 56, 69, 116, 7, 181, 191, 18, 16, 234, 63, 19,
+       5, 148, 184, 144, 95, 101, 173, 186, 97, 1, 0, 215, 218, 151, 95,
+       107, 77, 118, 18, 239, 112, 116, 72, 86, 230, 81, 84, 181, 100,
+       126, 236, 22, 239, 225, 180, 53, 206, 36, 40, 170, 132, 109, 179,
+       113, 245, 52, 108, 234, 75, 213, 225, 99, 198, 87, 165, 108, 2,
+       50, 177, 113, 52, 121, 250, 18, 216, 26, 186, 188, 115, 111, 12,
+       148, 33, 241, 91, 246, 170, 58, 237, 99, 200, 213, 212, 254, 103,
+       89, 5, 124, 3, 40, 221, 118, 180, 248, 187, 147, 145, 222, 171,
+       50, 254, 59, 92, 142, 107, 215, 12, 254, 238, 244, 239, 146, 174,
+       217, 133, 18, 236, 131, 13, 169, 77, 34, 200, 100, 20, 200, 226,
+       106, 82, 94, 43, 138, 183, 184, 148, 133, 127, 88, 15, 250, 14,
+       38, 129, 52, 202, 236, 137, 236, 233, 78, 57, 49, 89, 220, 88, 92,
+       33, 233, 3, 119, 123, 82, 106, 75, 213, 125, 24, 103, 237, 80, 10,
+       215, 130, 2, 189, 57, 221, 244, 173, 240, 166, 31, 25, 120, 97,
+       188, 58, 4, 0, 206, 123, 23, 213, 130, 56, 83, 253, 47, 28, 54,
+       234, 152, 88, 193, 155, 235, 121, 228, 244, 237, 89, 221, 117,
+       193, 182, 180, 186, 105, 61, 215, 191, 78, 244, 245, 234, 232,
+       103, 255, 168, 118, 91, 197, 179, 103, 252, 222, 253, 69, 207, 24,
+       187, 228, 172, 175, 132, 190, 27, 123, 116, 212, 243, 152, 73,
+       247, 91, 50, 91, 50, 144, 74, 115, 36, 62, 238, 196, 152, 83, 161,
+       161, 232, 187, 184, 82, 185, 217, 145, 143, 219, 53, 164, 56, 174,
+       177, 70, 62, 131, 82, 232, 16, 22, 109, 235, 115, 255, 213, 20,
+       123, 210, 24, 197, 111, 54, 41, 67, 238, 94, 139, 235, 64, 205,
+       128, 249, 74, 123, 201, 53, 0, 122, 169, 87, 239, 72, 183, 8, 223,
+       180, 140, 131, 40, 117, 171, 112, 160, 215, 141, 86, 193, 50, 179,
+       40, 112, 188, 176, 143, 178, 221, 115, 160, 101, 102, 181, 126,
+       232, 176, 145, 9, 220, 188, 232, 203, 68, 62, 161, 41, 36, 56,
+       137, 246, 108, 126, 3, 146, 104, 82, 160, 240, 42, 119, 249, 32,
+       48, 62, 252, 51, 97, 64, 235, 139, 157, 90, 239, 65, 25, 119, 170,
+       66, 130, 27, 223, 98, 129, 246, 146, 238, 243, 77, 200, 94, 231,
+       25, 14, 183, 228, 110, 173, 151, 239, 213, 154, 36, 236, 62, 76,
+       175, 196, 47, 164, 248, 221, 98, 164, 1, 154, 216, 137, 34, 239,
+       27, 3, 104, 73, 100, 226, 40, 80, 217, 187, 3, 49, 114, 26, 202,
+       127, 60, 22, 159, 106, 144, 8, 178, 142, 197, 102, 157, 210, 236,
+       37, 175, 216, 218, 186, 57, 126, 212, 251, 249, 43, 191, 67, 23,
+       255, 227, 103, 138, 242, 60, 26, 239, 252, 156, 251, 129, 161, 70,
+       179, 147, 179, 147, 12, 177, 131, 170, 189, 11, 245, 204, 231, 72,
+       138, 183, 95, 235, 17, 18, 89, 138, 192, 141, 20, 31, 111, 128,
+       98, 135, 211, 43, 205, 99, 88, 215, 211, 238, 247, 87, 64, 124,
+       226, 40, 212, 180, 228, 123, 186, 146, 200, 195, 186, 36, 255, 62,
+       28, 135, 234, 127, 158, 240, 172, 80, 226, 222, 152, 31, 195, 65,
+       15, 94, 241, 70, 18, 92, 226, 86, 192, 51, 77, 104, 153, 19, 217,
+       159, 85, 136, 162, 255, 93, 172, 0, 141, 0, 54, 41, 214, 229, 207,
+       75, 222, 105, 207, 160, 250, 11, 107, 235, 117, 18, 122, 253, 111,
+       227, 72, 51, 203, 248, 159, 222, 199, 61, 117, 235, 99, 138, 101,
+       124, 149, 101, 172, 14, 79, 150, 98, 186, 186, 76, 215, 51, 209,
+       123, 5, 244, 124, 106, 201, 112, 249, 40, 228, 250, 101, 180, 200,
+       249, 194, 49, 191, 159, 189, 254, 188, 166, 95, 191, 219, 218, 56,
+       112, 127, 127, 189, 115, 151, 243, 53, 111, 251, 97, 10, 255, 235,
+       254, 101, 158, 222, 248, 192, 57, 229, 43, 65, 193, 252, 139, 72,
+       155, 47, 184, 18, 204, 131, 3, 209, 213, 2, 228, 78, 92, 27, 88,
+       197, 152, 174, 152, 37, 244, 186, 168, 208, 52, 61, 81, 255, 110,
+       101, 95, 215, 88, 229, 236, 255, 46, 91, 221, 191, 62, 254, 244,
+       247, 106, 201, 179, 59, 136, 243, 249, 225, 150, 119, 255, 118,
+       243, 8, 159, 142, 156, 213, 118, 165, 255, 22, 223, 92, 54, 233,
+       230, 226, 161, 121, 122, 166, 128, 53, 233, 63, 191, 107, 71, 247,
+       197, 187, 108, 173, 253, 88, 90, 123, 228, 34, 22, 94, 48, 165,
+       202, 247, 100, 127, 223, 161, 210, 182, 245, 189, 226, 201, 149,
+       176, 232, 242, 251, 106, 130, 42, 178, 45, 51, 144, 120, 147, 241,
+       50, 152, 52, 198, 191, 131, 102, 176, 172, 147, 193, 221, 167,
+       121, 204, 16, 35, 221, 0, 235, 164, 246, 30, 130, 170, 208, 3,
+       173, 65, 88, 152, 190, 46, 164, 91, 18, 170, 91, 94, 69, 189, 243,
+       19, 90, 162, 103, 61, 79, 5, 76, 210, 97, 198, 191, 122, 136, 44,
+       241, 25, 91, 25, 115, 107, 197, 118, 93, 251, 88, 68, 108, 84,
+       230, 25, 207, 251, 32, 126, 136, 23, 238, 195, 48, 180, 221, 86,
+       201, 171, 172, 47, 174, 117, 241, 99, 33, 48, 201, 252, 7, 188,
+       109, 205, 1, 249, 42, 148, 187, 180, 118, 204, 151, 91, 173, 80,
+       43, 195, 216, 118, 60, 142, 60, 149, 138, 243, 168, 57, 2, 222,
+       181, 228, 98, 201, 75, 18, 175, 247, 186, 77, 96, 146, 137, 90,
+       238, 166, 169, 61, 242, 197, 28, 84, 167, 249, 145, 199, 233, 122,
+       128, 84, 160, 236, 180, 56, 8, 120, 136, 186, 180, 128, 169, 247,
+       239, 75, 74, 23, 92, 125, 116, 14, 65, 202, 89, 202, 135, 103, 61,
+       164, 170, 4, 82, 79, 133, 240, 246, 245, 122, 255, 184, 91, 199,
+       189, 154, 207, 109, 191, 175, 255, 195, 151, 255, 176, 98, 44,
+       238, 254, 223, 207, 229, 151, 255, 237, 116, 7, 156, 253, 244,
+       180, 22, 222, 187, 219, 218, 181, 227, 253, 127, 252, 33, 223,
+       243, 149, 167, 253, 97, 62, 255, 235, 223, 239, 246, 159, 228,
+       199, 115, 40, 164, 198, 157, 221, 115, 201, 143, 26, 183, 124,
+       158, 200, 225, 146, 140, 91, 78, 162, 156, 50, 250, 127, 95, 72,
+       39, 255, 84, 151, 108, 215, 232, 136, 168, 223, 157, 28, 211, 137,
+       79, 30, 181, 214, 150, 125, 226, 178, 129, 27, 47, 164, 153, 51,
+       253, 35, 95, 136, 35, 255, 65, 156, 0, 45, 104, 223, 146, 92, 233,
+       56, 134, 88, 56, 173, 25, 182, 116, 223, 27, 142, 91, 198, 145,
+       125, 184, 190, 13, 67, 213, 218, 251, 98, 214, 218, 129, 105, 3,
+       246, 2, 150, 140, 77, 109, 128, 72, 158, 183, 227, 27, 6, 128,
+       109, 91, 248, 133, 106, 49, 44, 103, 211, 64, 145, 178, 82, 63,
+       209, 105, 110, 134, 191, 72, 252, 247, 228, 122, 223, 184, 91,
+       134, 183, 130, 123, 107, 191, 57, 255, 245, 53, 235, 232, 244, 45,
+       234, 234, 223, 231, 133, 231, 251, 122, 96, 29, 149, 17, 235, 146,
+       198, 23, 157, 118, 73, 235, 68, 215, 83, 40, 96, 215, 91, 28, 122,
+       243, 128, 57, 63, 233, 175, 39, 68, 184, 19, 161, 51, 94, 116,
+       144, 176, 57, 188, 16, 202, 59, 187, 128, 25, 143, 206, 67, 158,
+       149, 93, 205, 17, 46, 70, 154, 130, 153, 212, 31, 63, 130, 85, 15,
+       7, 44, 149, 88, 97, 241, 173, 115, 250, 22, 45, 125, 41, 11, 187,
+       98, 16, 25, 26, 131, 16, 18, 58, 72, 23, 79, 207, 49, 109, 243,
+       139, 78, 131, 164, 137, 120, 67, 244, 237, 243, 218, 94, 45, 125,
+       26, 16, 153, 116, 32, 89, 26, 3, 88, 18, 58, 120, 182, 79, 141,
+       177, 109, 211, 137, 84, 162, 161, 244, 105, 81, 68, 223, 167, 255,
+       94, 126, 93, 26, 16, 220, 254, 37, 25, 8, 18, 47, 247, 190, 124,
+       215, 111, 15, 181, 109, 87, 140, 220, 228, 190, 84, 82, 122, 149,
+       223, 86, 213, 21, 10, 241, 19, 74, 219, 45, 149, 216, 248, 132,
+       114, 124, 167, 88, 174, 179, 220, 4, 91, 115, 255, 238, 6, 184,
+       196, 82, 228, 213, 66, 86, 255, 17, 166, 244, 11, 75, 185, 97,
+       145, 89, 220, 133, 176, 108, 255, 144, 142, 123, 235, 165, 37, 99,
+       252, 246, 138, 176, 76, 22, 254, 13, 206, 84, 102, 149, 14, 224,
+       1, 107, 11, 37, 217, 200, 224, 204, 98, 108, 175, 82, 174, 179,
+       242, 212, 27, 115, 28, 108, 14, 62, 76, 102, 61, 141, 118, 253,
+       51, 165, 86, 223, 131, 201, 125, 55, 111, 201, 32, 185, 143, 156,
+       197, 119, 200, 67, 123, 218, 131, 167, 245, 252, 214, 31, 204,
+       230, 209, 197, 118, 237, 254, 85, 126, 94, 2, 73, 121, 187, 173,
+       121, 218, 182, 234, 201, 240, 63, 229, 39, 219, 215, 135, 167,
+       253, 252, 228, 0, 5, 212, 129, 180, 170, 104, 3, 15, 161, 59, 82,
+       158, 42, 32, 72, 99, 3, 14, 144, 18, 184, 65, 214, 140, 150, 18,
+       68, 148, 72, 1, 0, 82, 221, 87, 250, 179, 194, 53, 39, 172, 1, 74,
+       50, 188, 151, 32, 96, 167, 51, 155, 144, 83, 157, 16, 255, 237,
+       182, 30, 194, 188, 0, 161, 59, 215, 26, 207, 167, 34, 54, 58, 16,
+       56, 226, 83, 231, 93, 38, 147, 251, 38, 101, 125, 239, 181, 213,
+       189, 200, 214, 43, 235, 128, 172, 231, 43, 81, 31, 193, 230, 87,
+       133, 118, 126, 132, 103, 127, 95, 3, 73, 62, 191, 238, 121, 70,
+       183, 206, 132, 208, 45, 224, 7, 127, 222, 135, 183, 247, 248, 220,
+       75, 240, 209, 129, 164, 44, 232, 159, 106, 115, 18, 213, 189, 46,
+       222, 202, 39, 7, 125, 157, 151, 120, 189, 241, 140, 28, 126, 228,
+       140, 196, 209, 89, 15, 201, 134, 133, 199, 84, 174, 156, 166, 241,
+       30, 198, 233, 246, 251, 238, 51, 70, 186, 206, 135, 80, 191, 241,
+       14, 111, 239, 133, 159, 247, 57, 252, 82, 17, 246, 228, 147, 102,
+       152, 7, 169, 161, 154, 139, 76, 63, 29, 110, 182, 247, 253, 177,
+       156, 193, 145, 200, 155, 254, 159, 151, 167, 231, 165, 23, 95,
+       251, 130, 166, 154, 20, 175, 140, 42, 101, 138, 143, 237, 226,
+       107, 194, 54, 199, 236, 213, 199, 17, 158, 225, 188, 229, 175,
+       188, 140, 119, 169, 92, 131, 254, 125, 209, 114, 135, 187, 178,
+       184, 88, 20, 230, 61, 95, 193, 33, 7, 113, 23, 206, 227, 220, 62,
+       255, 110, 10, 169, 192, 13, 177, 35, 249, 102, 33, 212, 177, 197,
+       8, 236, 9, 43, 177, 179, 26, 206, 106, 92, 91, 233, 199, 106, 177,
+       82, 112, 203, 192, 156, 144, 223, 103, 129, 104, 203, 130, 158,
+       52, 58, 226, 114, 85, 27, 120, 18, 74, 157, 234, 125, 215, 169,
+       49, 190, 153, 149, 162, 235, 7, 40, 223, 211, 193, 171, 188, 54,
+       163, 39, 241, 185, 30, 108, 205, 78, 55, 235, 120, 85, 238, 244,
+       102, 49, 29, 183, 45, 126, 136, 23, 175, 172, 182, 101, 157, 71,
+       75, 160, 164, 119, 237, 116, 249, 148, 6, 255, 197, 102, 98, 237,
+       81, 97, 142, 127, 98, 81, 115, 185, 110, 126, 180, 22, 170, 169,
+       180, 37, 200, 212, 234, 226, 128, 229, 251, 100, 161, 250, 50,
+       106, 68, 125, 212, 146, 113, 193, 204, 191, 47, 106, 220, 254, 54,
+       220, 180, 238, 33, 205, 103, 182, 143, 19, 125, 129, 187, 75, 46,
+       126, 215, 142, 254, 43, 226, 48, 213, 155, 248, 146, 216, 149,
+       239, 157, 223, 243, 33, 223, 217, 149, 231, 235, 71, 168, 223,
+       251, 209, 171, 188, 6, 167, 53, 115, 190, 30, 108, 236, 86, 55,
+       216, 121, 85, 202, 245, 103, 91, 89, 183, 97, 124, 185, 151, 171,
+       173, 166, 37, 222, 83, 235, 161, 137, 127, 175, 124, 147, 64, 164,
+       128, 145, 209, 233, 32, 134, 38, 53, 202, 18, 128, 34, 72, 72, 97,
+       14, 106, 152, 18, 216, 199, 21, 13, 166, 146, 69, 128, 72, 165,
+       128, 156, 22, 82, 229, 36, 55, 124, 81, 53, 202, 247, 103, 91, 11,
+       161, 201, 126, 172, 143, 170, 169, 182, 0, 202, 86, 233, 162, 129,
+       47, 241, 104, 147, 242, 14, 100, 231, 133, 98, 110, 55, 85, 43,
+       242, 82, 11, 41, 20, 93, 106, 134, 93, 136, 184, 188, 69, 174,
+       167, 254, 240, 129, 175, 217, 216, 11, 155, 82, 59, 137, 6, 214,
+       169, 88, 141, 76, 222, 103, 190, 214, 175, 224, 252, 169, 158,
+       229, 201, 149, 50, 204, 145, 161, 170, 130, 57, 8, 37, 245, 176,
+       22, 77, 165, 52, 103, 65, 63, 21, 238, 254, 126, 67, 12, 134, 21,
+       252, 132, 4, 161, 173, 182, 97, 142, 176, 242, 177, 150, 105, 168,
+       244, 85, 190, 239, 216, 162, 151, 123, 207, 207, 91, 167, 60, 158,
+       79, 10, 95, 136, 187, 207, 164, 91, 115, 165, 189, 242, 184, 157,
+       175, 245, 173, 89, 223, 72, 230, 141, 92, 234, 188, 226, 207, 143,
+       91, 55, 184, 158, 93, 106, 31, 144, 139, 203, 21, 147, 123, 174,
+       89, 247, 160, 188, 172, 221, 156, 209, 200, 8, 92, 23, 166, 94,
+       177, 118, 118, 249, 183, 238, 223, 102, 91, 247, 163, 109, 117,
+       244, 191, 170, 169, 193, 59, 191, 91, 239, 229, 135, 163, 247,
+       252, 119, 34, 121, 185, 110, 105, 141, 154, 200, 139, 120, 176,
+       105, 62, 222, 117, 50, 142, 89, 119, 71, 198, 43, 202, 241, 19,
+       92, 25, 186, 80, 31, 3, 223, 235, 240, 120, 102, 105, 29, 223,
+       252, 139, 108, 188, 173, 59, 157, 222, 48, 134, 81, 221, 110, 206,
+       47, 250, 183, 115, 221, 33, 191, 82, 158, 78, 123, 115, 249, 233,
+       161, 94, 79, 67, 214, 3, 236, 188, 174, 18, 28, 198, 52, 108, 156,
+       222, 209, 201, 58, 245, 146, 253, 149, 165, 246, 109, 10, 86, 255,
+       249, 23, 13, 140, 77, 118, 197, 127, 24, 238, 189, 126, 26, 54,
+       167, 223, 108, 196, 166, 162, 237, 103, 241, 204, 209, 163, 251,
+       181, 91, 124, 126, 121, 188, 83, 218, 132, 215, 115, 239, 94, 10,
+       237, 188, 30, 77, 6, 243, 140, 59, 199, 198, 249, 21, 103, 60,
+       194, 219, 7, 255, 253, 207, 127, 239, 241, 204, 93, 92, 190, 237,
+       242, 223, 167, 137, 22, 188, 30, 253, 106, 62, 131, 43, 199, 206,
+       195, 115, 99, 58, 255, 112, 59, 206, 89, 29, 83, 239, 81, 230,
+       109, 222, 246, 236, 98, 223, 134, 27, 162, 188, 156, 220, 170, 93,
+       138, 143, 119, 117, 91, 113, 231, 154, 226, 48, 27, 79, 178, 140,
+       123, 219, 9, 166, 108, 250, 242, 172, 98, 207, 198, 91, 162, 56,
+       152, 220, 171, 93, 136, 159, 223, 53, 147, 249, 229, 155, 226,
+       168, 156, 143, 188, 204, 241, 203, 0, 56, 23, 231, 55, 145, 119,
+       87, 123, 83, 239, 117, 191, 107, 109, 162, 45, 93, 254, 165, 164,
+       189, 242, 125, 158, 203, 247, 245, 135, 231, 237, 222, 215, 34,
+       233, 208, 234, 124, 137, 218, 204, 143, 17, 56, 139, 173, 139,
+       117, 0, 138, 219, 23, 209, 2, 42, 202, 241, 142, 156, 26, 126,
+       213, 155, 1, 12, 74, 249, 160, 85, 165, 222, 212, 23, 91, 255, 22,
+       12, 184, 61, 214, 46, 133, 54, 253, 25, 198, 120, 241, 144, 111,
+       223, 245, 179, 130, 92, 212, 127, 142, 238, 89, 234, 244, 99, 79,
+       158, 91, 39, 24, 222, 205, 171, 125, 128, 155, 207, 21, 155, 115,
+       46, 152, 242, 168, 156, 175, 252, 156, 91, 137, 1, 41, 178, 196,
+       157, 93, 243, 129, 95, 86, 253, 118, 54, 217, 164, 130, 172, 89,
+       78, 166, 16, 151, 250, 119, 148, 79, 227, 243, 213, 219, 12, 93,
+       255, 249, 122, 56, 110, 109, 253, 211, 216, 67, 76, 252, 45, 58,
+       221, 199, 180, 204, 248, 213, 70, 143, 39, 242, 187, 83, 253, 32,
+       187, 91, 175, 94, 255, 95, 251, 168, 241, 181, 54, 220, 159, 82,
+       251, 158, 32, 155, 61, 215, 110, 199, 86, 189, 153, 138, 120, 229,
+       144, 239, 223, 255, 245, 134, 252, 212, 109, 198, 241, 185, 222,
+       207, 69, 188, 204, 138, 178, 129, 27, 124, 223, 125, 11, 239, 211,
+       115, 195, 67, 71, 154, 241, 21, 24, 207, 63, 29, 114, 167, 186,
+       15, 105, 80, 243, 231, 169, 189, 196, 154, 18, 48, 138, 189, 202,
+       85, 137, 175, 123, 147, 223, 66, 80, 138, 241, 68, 25, 255, 168,
+       215, 85, 203, 137, 14, 105, 212, 187, 199, 185, 173, 198, 14, 55,
+       116, 2, 189, 10, 83, 140, 43, 171, 147, 219, 2, 112, 94, 241, 197,
+       153, 218, 97, 151, 93, 137, 168, 31, 73, 92, 155, 135, 249, 105,
+       0, 15, 21, 71, 2, 173, 3, 51, 204, 98, 163, 170, 218, 18, 152,
+       103, 245, 199, 215, 154, 65, 182, 31, 141, 224, 120, 113, 233, 69,
+       203, 95, 113, 23, 35, 236, 190, 143, 154, 61, 67, 50, 108, 252,
+       255, 16, 217, 251, 241, 72, 255, 5, 245, 181, 227, 44, 86, 123,
+       50, 137, 18, 169, 85, 141, 226, 68, 15, 1, 232, 3, 34, 136, 36,
+       212, 248, 139, 2, 208, 30, 187, 144, 253, 57, 180, 146, 107, 209,
+       11, 250, 142, 58, 233, 112, 203, 87, 153, 250, 196, 79, 1, 120,
+       10, 43, 137, 125, 212, 120, 155, 19, 216, 10, 58, 80, 245, 63,
+       220, 130, 107, 247, 159, 112, 142, 73, 12, 252, 197, 164, 58, 233,
+       51, 72, 247, 30, 176, 153, 61, 215, 43, 7, 22, 53, 61, 177, 248,
+       229, 128, 78, 251, 247, 132, 198, 232, 85, 109, 6, 120, 147, 250,
+       207, 229, 190, 200, 26, 147, 64, 74, 188, 223, 105, 40, 183, 89,
+       51, 211, 3, 86, 154, 243, 93, 20, 159, 46, 157, 19, 33, 171, 214,
+       191, 201, 227, 148, 104, 239, 158, 123, 247, 58, 86, 201, 234, 85,
+       72, 179, 207, 53, 147, 243, 120, 157, 242, 172, 158, 159, 228,
+       141, 115, 217, 146, 150, 173, 89, 179, 182, 96, 207, 143, 123, 55,
+       25, 87, 205, 234, 92, 129, 147, 79, 53, 251, 59, 120, 221, 247,
+       168, 214, 143, 228, 173, 83, 155, 145, 185, 223, 79, 150, 199,
+       252, 231, 55, 24, 94, 255, 126, 190, 102, 162, 209, 105, 234, 134,
+       38, 237, 254, 56, 239, 245, 131, 254, 129, 107, 125, 221, 251,
+       107, 189, 100, 68, 111, 92, 253, 183, 233, 252, 60, 170, 107, 60,
+       214, 183, 14, 246, 245, 231, 221, 122, 230, 233, 54, 121, 197,
+       187, 111, 254, 218, 253, 179, 101, 107, 203, 86, 213, 239, 204,
+       84, 68, 116, 2, 57, 156, 62, 32, 120, 136, 19, 253, 230, 190, 52,
+       255, 119, 13, 138, 97, 117, 154, 244, 238, 150, 122, 170, 176,
+       194, 224, 185, 194, 190, 220, 84, 183, 12, 142, 103, 72, 167, 121,
+       183, 213, 134, 221, 134, 224, 88, 1, 190, 227, 165, 21, 45, 219,
+       137, 247, 133, 131, 149, 126, 103, 190, 172, 221, 159, 247, 220,
+       118, 202, 230, 109, 194, 206, 254, 183, 105, 125, 231, 255, 71,
+       174, 197, 138, 79, 173, 115, 206, 205, 94, 218, 255, 225, 159,
+       238, 153, 6, 60, 154, 124, 234, 63, 145, 179, 227, 151, 75, 115,
+       67, 10, 255, 48, 25, 15, 185, 28, 83, 203, 33, 230, 205, 222, 214,
+       172, 34, 223, 167, 153, 50, 186, 56, 126, 248, 61, 3, 151, 247,
+       53, 3, 112, 231, 138, 226, 176, 62, 77, 146, 140, 251, 217, 1, 56,
+       161, 42, 232, 84, 195, 211, 125, 196, 5, 252, 2, 51, 217, 58, 0,
+       88, 184, 3, 249, 26, 187, 16, 159, 123, 173, 162, 73, 117, 10,
+       116, 170, 184, 68, 110, 69, 70, 99, 229, 114, 84, 166, 254, 18,
+       115, 33, 183, 19, 120, 244, 3, 170, 104, 183, 5, 14, 119, 139,
+       225, 1, 103, 248, 126, 170, 202, 252, 190, 244, 173, 87, 220, 191,
+       155, 190, 188, 13, 252, 255, 81, 139, 149, 117, 253, 227, 224,
+       103, 186, 168, 99, 251, 253, 191, 10, 124, 92, 91, 56, 183, 222,
+       254, 245, 94, 126, 189, 123, 159, 127, 20, 239, 235, 62, 144, 179,
+       203, 165, 48, 127, 248, 59, 255, 235, 255, 55, 197, 194, 202, 205,
+       75, 173, 87, 136, 146, 197, 125, 247, 222, 154, 254, 189, 63, 140,
+       230, 227, 175, 121, 226, 206, 114, 37, 103, 122, 250, 253, 195,
+       239, 189, 154, 127, 220, 215, 230, 239, 249, 242, 228, 98, 207,
+       142, 91, 167, 56, 218, 92, 235, 93, 16, 159, 223, 53, 211, 251,
+       126, 154, 242, 40, 158, 141, 236, 197, 211, 234, 8, 190, 123, 168,
+       165, 173, 89, 212, 69, 197, 230, 148, 175, 171, 140, 215, 142,
+       200, 96, 237, 71, 204, 225, 246, 128, 130, 209, 207, 179, 79, 126,
+       223, 222, 56, 141, 16, 186, 153, 217, 86, 237, 135, 4, 232, 9,
+       111, 233, 35, 208, 208, 187, 132, 80, 94, 43, 74, 189, 251, 245,
+       5, 123, 114, 14, 140, 10, 155, 211, 103, 139, 214, 23, 174, 125,
+       84, 64, 83, 215, 73, 76, 190, 161, 126, 137, 147, 239, 247, 183,
+       52, 205, 52, 8, 142, 132, 125, 158, 177, 220, 188, 93, 252, 247,
+       197, 94, 223, 188, 121, 222, 180, 15, 251, 111, 31, 95, 123, 230,
+       167, 234, 232, 242, 126, 237, 251, 219, 231, 21, 103, 255, 246,
+       250, 95, 209, 245, 246, 247, 122, 250, 184, 91, 221, 181, 142,
+       207, 127, 223, 175, 123, 197, 183, 251, 189, 98, 62, 236, 191,
+       219, 207, 199, 231, 255, 245, 245, 200, 221, 82, 150, 215, 248,
+       239, 244, 248, 69, 61, 22, 173, 231, 122, 229, 35, 226, 138, 202,
+       103, 73, 190, 239, 127, 209, 46, 233, 15, 31, 239, 250, 192, 95,
+       220, 150, 196, 239, 239, 149, 154, 222, 189, 30, 253, 110, 51, 11,
+       43, 227, 14, 203, 97, 101, 126, 235, 245, 147, 255, 185, 28, 123,
+       205, 89, 150, 237, 93, 250, 180, 227, 207, 175, 91, 51, 57, 158,
+       254, 106, 61, 0, 187, 195, 21, 91, 115, 36, 27, 247, 168, 158,
+       175, 244, 157, 91, 193, 9, 230, 143, 116, 255, 238, 160, 254, 167,
+       249, 2, 59, 210, 233, 235, 29, 91, 131, 99, 119, 131, 240, 76, 78,
+       255, 38, 254, 223, 138, 157, 241, 209, 133, 3, 154, 214, 23, 109,
+       148, 232, 154, 219, 153, 114, 102, 108, 248, 254, 238, 151, 107,
+       52, 21, 135, 232, 142, 241, 12, 122, 127, 202, 205, 36, 121, 133,
+       184, 137, 58, 236, 93, 215, 83, 117, 196, 132, 236, 2, 115, 209,
+       34, 64, 88, 184, 131, 104, 88, 171, 16, 159, 123, 205, 166, 73,
+       51, 138, 124, 170, 14, 154, 244, 214, 117, 158, 250, 248, 219,
+       223, 181, 231, 236, 111, 247, 12, 255, 243, 159, 133, 164, 105,
+       62, 253, 223, 95, 223, 243, 151, 175, 69, 223, 78, 49, 179, 252,
+       185, 228, 29, 3, 201, 193, 129, 16, 204, 254, 105, 110, 214, 53,
+       249, 49, 145, 67, 178, 192, 153, 244, 15, 90, 130, 100, 165, 55,
+       80, 176, 187, 192, 186, 68, 177, 215, 234, 185, 134, 48, 156, 183,
+       72, 106, 165, 87, 105, 16, 19, 107, 177, 64, 217, 144, 23, 110,
+       128, 0, 165, 59, 73, 184, 157, 95, 77, 221, 97, 153, 239, 221, 36,
+       0, 248, 243, 76, 38, 161, 106, 120, 24, 3, 104, 186, 49, 15, 251,
+       69, 110, 98, 160, 68, 230, 2, 88, 191, 189, 54, 226, 185, 86, 156,
+       7, 82, 179, 189, 191, 33, 72, 230, 121, 51, 149, 32, 220, 48, 232,
+       197, 231, 250, 130, 164, 129, 37, 251, 7, 144, 252, 247, 116, 158,
+       255, 185, 251, 219, 181, 35, 255, 126, 62, 97, 255, 243, 191, 161,
+       164, 105, 46, 207, 223, 223, 255, 215, 213, 168, 101, 211, 132,
+       239, 31, 162, 252, 73, 238, 252, 204, 81, 25, 214, 181, 231, 248,
+       34, 34, 67, 74, 106, 55, 9, 62, 119, 108, 133, 47, 108, 28, 155,
+       133, 249, 133, 205, 25, 182, 252, 201, 174, 252, 204, 64, 17, 214,
+       245, 227, 248, 3, 34, 67, 10, 106, 99, 1, 30, 127, 108, 132, 174,
+       104, 28, 155, 129, 185, 69, 195, 149, 147, 174, 4, 189, 156, 138,
+       57, 147, 98, 220, 115, 201, 235, 135, 87, 127, 91, 19, 65, 203,
+       224, 140, 50, 111, 244, 136, 59, 129, 33, 55, 121, 162, 216, 205,
+       21, 253, 221, 219, 218, 80, 67, 10, 220, 127, 175, 253, 219, 151,
+       215, 206, 114, 186, 208, 23, 88, 207, 174, 211, 127, 240, 231,
+       126, 120, 232, 168, 219, 81, 95, 220, 7, 228, 132, 171, 11, 151,
+       99, 84, 90, 217, 159, 210, 78, 7, 248, 146, 243, 197, 173, 189,
+       183, 183, 60, 115, 107, 189, 104, 164, 87, 47, 95, 119, 1, 228,
+       92, 207, 113, 61, 18, 18, 30, 230, 85, 175, 253, 58, 244, 142,
+       255, 109, 173, 184, 47, 238, 146, 251, 194, 170, 151, 88, 170,
+       232, 33, 199, 190, 31, 160, 112, 172, 182, 68, 255, 167, 51, 234,
+       16, 19, 77, 162, 113, 157, 178, 94, 122, 128, 64, 167, 109, 40,
+       201, 122, 126, 221, 212, 87, 245, 197, 4, 236, 8, 99, 209, 34, 80,
+       88, 250, 134, 74, 90, 171, 122, 61, 99, 237, 36, 89, 114, 186,
+       238, 170, 197, 106, 67, 1, 116, 138, 234, 64, 108, 160, 146, 238,
+       147, 128, 209, 70, 34, 228, 110, 222, 129, 183, 133, 74, 28, 0,
+       35, 240, 44, 129, 83, 0, 189, 219, 221, 183, 236, 76, 94, 183,
+       147, 127, 48, 117, 159, 63, 67, 155, 239, 195, 255, 70, 253, 120,
+       107, 162, 238, 219, 116, 212, 250, 252, 198, 217, 102, 156, 249,
+       244, 244, 14, 251, 186, 187, 206, 180, 162, 245, 127, 241, 98,
+       127, 241, 31, 172, 161, 109, 250, 207, 237, 158, 127, 172, 132,
+       232, 101, 241, 67, 180, 241, 196, 124, 79, 235, 123, 219, 234, 17,
+       126, 244, 254, 180, 35, 159, 85, 95, 45, 177, 111, 56, 222, 45,
+       30, 255, 174, 28, 168, 1, 253, 129, 223, 1, 159, 212, 140, 175,
+       180, 120, 10, 113, 198, 181, 98, 160, 97, 122, 106, 6, 206, 225,
+       94, 124, 127, 101, 0, 254, 168, 56, 59, 225, 185, 5, 74, 151, 183,
+       236, 35, 174, 212, 92, 187, 19, 116, 221, 99, 169, 139, 163, 65,
+       42, 126, 49, 213, 11, 96, 140, 146, 127, 68, 152, 249, 129, 161,
+       31, 120, 231, 185, 157, 247, 186, 204, 159, 81, 144, 215, 205,
+       222, 125, 233, 255, 89, 159, 213, 167, 197, 63, 244, 139, 90, 159,
+       246, 158, 21, 53, 215, 113, 45, 60, 100, 143, 103, 223, 111, 192,
+       246, 172, 10, 114, 57, 86, 35, 233, 199, 88, 47, 76, 99, 250, 138,
+       251, 201, 69, 63, 65, 122, 102, 234, 66, 194, 245, 244, 124, 3,
+       250, 250, 27, 170, 176, 234, 213, 123, 180, 35, 223, 213, 127,
+       161, 176, 73, 8, 221, 28, 158, 255, 254, 148, 168, 67, 1, 5, 150,
+       149, 247, 170, 36, 42, 184, 22, 155, 67, 84, 244, 115, 72, 239,
+       213, 95, 62, 10, 179, 212, 203, 99, 141, 174, 127, 196, 152, 97,
+       161, 161, 86, 146, 53, 184, 43, 244, 152, 170, 143, 93, 155, 167,
+       76, 254, 46, 202, 231, 209, 255, 181, 150, 11, 27, 245, 155, 114,
+       91, 223, 150, 7, 45, 87, 17, 88, 223, 117, 48, 14, 105, 18, 116,
+       193, 98, 68, 179, 51, 129, 121, 118, 108, 52, 152, 129, 216, 53,
+       8, 196, 174, 114, 0, 232, 161, 97, 32, 7, 182, 219, 229, 252, 11,
+       174, 251, 156, 170, 24, 230, 213, 235, 245, 66, 247, 117, 95, 35,
+       241, 73, 138, 94, 172, 158, 239, 172, 156, 232, 1, 161, 180, 97,
+       60, 104, 141, 69, 212, 205, 206, 146, 168, 1, 150, 249, 121, 11,
+       201, 73, 107, 115, 66, 99, 26, 80, 227, 153, 71, 61, 80, 122, 231,
+       138, 85, 88, 249, 168, 142, 5, 159, 221, 70, 229, 128, 7, 85, 159,
+       115, 72, 253, 201, 59, 215, 202, 39, 123, 82, 219, 13, 143, 60,
+       181, 123, 245, 74, 238, 76, 229, 213, 173, 123, 204, 143, 198,
+       182, 150, 186, 193, 44, 209, 239, 73, 244, 253, 179, 236, 69, 239,
+       128, 134, 83, 221, 181, 134, 253, 20, 124, 79, 184, 172, 145, 173,
+       63, 117, 159, 251, 255, 6, 29, 222, 176, 210, 174, 129, 70, 121,
+       29, 182, 92, 255, 178, 207, 95, 93, 118, 142, 108, 153, 126, 146,
+       207, 70, 156, 84, 134, 170, 246, 188, 4, 94, 199, 41, 194, 182,
+       69, 108, 171, 131, 205, 228, 153, 4, 253, 48, 32, 138, 192, 31,
+       132, 57, 156, 18, 207, 103, 188, 54, 146, 186, 102, 172, 12, 218,
+       227, 45, 142, 164, 193, 102, 179, 143, 193, 100, 153, 36, 253,
+       176, 227, 170, 129, 53, 4, 37, 237, 141, 133, 240, 212, 117, 26,
+       235, 184, 219, 130, 181, 138, 253, 115, 185, 165, 127, 224, 159,
+       238, 160, 99, 14, 223, 254, 223, 199, 60, 54, 236, 65, 168, 162,
+       106, 130, 218, 125, 177, 170, 68, 95, 7, 241, 152, 173, 200, 180,
+       76, 219, 41, 10, 155, 34, 39, 78, 243, 128, 212, 154, 123, 148, 9,
+       249, 164, 3, 181, 190, 225, 148, 182, 184, 23, 236, 217, 26, 80,
+       145, 62, 80, 35, 204, 59, 29, 145, 151, 216, 49, 196, 237, 217,
+       190, 192, 136, 64, 187, 155, 189, 0, 205, 245, 196, 46, 88, 24,
+       53, 243, 247, 19, 83, 47, 27, 59, 89, 196, 117, 174, 173, 246, 81,
+       8, 215, 235, 241, 4, 237, 233, 122, 210, 188, 181, 123, 98, 51,
+       221, 211, 112, 105, 76, 125, 8, 58, 221, 46, 180, 188, 26, 213,
+       106, 223, 169, 48, 167, 211, 217, 0, 107, 99, 15, 111, 247, 225,
+       8, 233, 173, 78, 2, 233, 58, 80, 102, 240, 23, 145, 40, 53, 75,
+       74, 141, 35, 141, 200, 62, 245, 139, 68, 42, 242, 12, 117, 40,
+       113, 234, 176, 201, 101, 41, 78, 67, 133, 235, 84, 52, 240, 43,
+       19, 9, 80, 17, 120, 136, 66, 233, 120, 62, 71, 29, 124, 136, 97,
+       125, 117, 40, 118, 226, 20, 145, 181, 169, 158, 38, 130, 168, 70,
+       17, 201, 3, 215, 123, 40, 192, 242, 219, 57, 193, 27, 42, 219, 49,
+       217, 236, 107, 76, 181, 107, 49, 34, 158, 94, 117, 88, 186, 211,
+       158, 220, 31, 90, 48, 246, 92, 94, 165, 169, 255, 17, 151, 114,
+       231, 101, 43, 222, 59, 218, 103, 142, 95, 149, 37, 245, 103, 188,
+       172, 145, 185, 189, 73, 191, 139, 245, 14, 29, 192, 226, 94, 54,
+       129, 70, 121, 28, 150, 72, 255, 51, 207, 30, 157, 246, 154, 68,
+       218, 126, 188, 73, 126, 102, 69, 71, 215, 240, 192, 164, 252, 10,
+       115, 217, 63, 16, 216, 244, 133, 98, 72, 163, 24, 44, 115, 201,
+       165, 17, 115, 187, 126, 170, 162, 188, 148, 184, 253, 173, 144,
+       131, 143, 25, 184, 121, 166, 248, 68, 150, 201, 43, 234, 17, 54,
+       110, 194, 179, 143, 148, 28, 123, 216, 12, 90, 143, 62, 153, 252,
+       247, 247, 216, 49, 225, 27, 213, 182, 179, 110, 127, 78, 94, 255,
+       211, 183, 145, 30, 250, 123, 229, 219, 215, 223, 71, 231, 172,
+       172, 87, 50, 216, 189, 247, 53, 220, 209, 181, 251, 221, 182, 39,
+       110, 127, 78, 55, 237, 251, 181, 145, 206, 120, 251, 253, 223,
+       219, 215, 195, 225, 8, 116, 127, 187, 145, 122, 70, 7, 221, 215,
+       113, 205, 78, 183, 10, 106, 221, 62, 164, 184, 186, 222, 107, 205,
+       165, 48, 255, 243, 221, 0, 19, 103, 14, 220, 119, 24, 133, 150,
+       175, 158, 66, 39, 45, 228, 11, 223, 50, 247, 115, 168, 70, 114,
+       18, 124, 170, 106, 161, 75, 15, 224, 166, 62, 20, 170, 218, 161,
+       41, 156, 182, 121, 232, 90, 198, 59, 248, 52, 84, 65, 215, 21, 87,
+       40, 81, 119, 25, 19, 238, 178, 7, 58, 119, 89, 11, 43, 236, 53,
+       129, 39, 243, 102, 167, 172, 219, 204, 52, 205, 159, 138, 63, 141,
+       213, 192, 110, 94, 74, 205, 87, 249, 157, 158, 72, 235, 113, 79,
+       63, 255, 253, 148, 112, 222, 0, 223, 86, 103, 229, 38, 30, 237,
+       48, 124, 226, 211, 214, 217, 14, 149, 239, 118, 229, 125, 239,
+       233, 212, 117, 204, 132, 235, 235, 132, 47, 181, 113, 117, 189,
+       68, 110, 237, 12, 15, 111, 120, 68, 234, 247, 6, 83, 65, 187, 107,
+       120, 196, 127, 238, 233, 245, 117, 14, 87, 171, 225, 20, 107, 187,
+       112, 176, 93, 149, 87, 103, 48, 46, 67, 184, 37, 40, 187, 72, 247,
+       115, 136, 112, 20, 214, 92, 106, 57, 176, 89, 47, 225, 255, 33,
+       16, 106, 227, 66, 33, 67, 26, 154, 183, 234, 44, 61, 7, 171, 203,
+       91, 105, 188, 178, 78, 74, 167, 127, 127, 4, 65, 73, 130, 224,
+       148, 182, 126, 138, 128, 114, 139, 15, 34, 49, 186, 246, 241, 140,
+       242, 65, 171, 141, 177, 108, 46, 223, 68, 18, 134, 63, 221, 80,
+       150, 203, 144, 232, 251, 220, 28, 187, 72, 2, 135, 159, 90, 176,
+       148, 186, 139, 109, 16, 143, 171, 63, 161, 57, 238, 255, 72, 154,
+       129, 19, 233, 16, 54, 109, 203, 147, 219, 215, 84, 127, 210, 76,
+       143, 11, 226, 175, 148, 186, 169, 233, 144, 135, 143, 21, 168, 25,
+       174, 232, 70, 19, 201, 51, 235, 17, 54, 111, 194, 243, 137, 210,
+       86, 123, 208, 76, 143, 14, 159, 86, 111, 167, 54, 18, 238, 48, 36,
+       234, 211, 231, 221, 14, 147, 99, 118, 229, 29, 239, 237, 149, 45,
+       76, 226, 235, 234, 128, 45, 179, 57, 81, 225, 43, 74, 65, 208,
+       139, 104, 39, 162, 176, 38, 140, 179, 130, 215, 81, 8, 174, 106,
+       92, 60, 90, 196, 28, 62, 137, 165, 101, 136, 136, 90, 8, 8, 166,
+       188, 179, 130, 48, 188, 191, 50, 151, 212, 147, 233, 111, 90, 11,
+       253, 219, 161, 145, 126, 238, 202, 163, 239, 199, 254, 73, 165,
+       208, 173, 202, 3, 204, 75, 157, 116, 170, 173, 103, 188, 3, 74,
+       130, 180, 178, 52, 96, 235, 59, 19, 141, 34, 152, 4, 127, 101, 46,
+       158, 0, 132, 8, 161, 168, 246, 88, 157, 242, 40, 105, 89, 140,
+       131, 182, 132, 184, 223, 23, 65, 31, 79, 245, 253, 210, 40, 71,
+       251, 176, 219, 211, 221, 63, 178, 177, 6, 122, 179, 209, 109, 195,
+       125, 223, 95, 53, 207, 108, 151, 10, 26, 28, 182, 100, 206, 176,
+       95, 111, 205, 47, 117, 159, 227, 93, 129, 178, 87, 158, 208, 127,
+       147, 22, 109, 77, 34, 82, 89, 123, 85, 78, 87, 246, 81, 38, 178,
+       101, 94, 188, 151, 174, 237, 158, 101, 207, 226, 235, 234, 132,
+       63, 228, 36, 125, 30, 254, 172, 246, 153, 149, 190, 255, 178, 151,
+       132, 215, 233, 239, 90, 139, 189, 123, 241, 147, 254, 75, 154,
+       191, 235, 199, 255, 173, 135, 240, 175, 136, 177, 67, 99, 207, 20,
+       22, 235, 120, 84, 200, 211, 198, 81, 76, 189, 225, 124, 236, 23,
+       239, 233, 177, 61, 174, 178, 237, 170, 128, 61, 171, 112, 248, 66,
+       96, 139, 148, 8, 72, 36, 15, 186, 166, 130, 153, 132, 178, 65, 90,
+       35, 229, 106, 129, 64, 79, 135, 66, 149, 38, 223, 29, 0, 112, 135,
+       42, 100, 105, 209, 33, 248, 169, 224, 71, 171, 165, 184, 137, 142,
+       171, 69, 26, 139, 255, 74, 16, 2, 107, 192, 104, 188, 148, 23, 56,
+       192, 114, 195, 136, 251, 86, 101, 204, 125, 23, 95, 29, 197, 110,
+       180, 143, 43, 28, 183, 116, 204, 165, 157, 238, 237, 7, 117, 159,
+       115, 125, 160, 150, 31, 158, 84, 127, 212, 223, 30, 178, 146, 174,
+       54, 229, 189, 23, 139, 183, 71, 110, 43, 89, 167, 243, 237, 83,
+       254, 5, 24, 119, 250, 231, 94, 69, 161, 83, 173, 75, 1, 139, 155,
+       249, 240, 168, 41, 147, 60, 17, 74, 80, 149, 163, 160, 73, 115,
+       10, 34, 156, 18, 152, 2, 65, 204, 162, 58, 64, 144, 128, 161, 160,
+       2, 0, 141, 152, 124, 165, 168, 3, 142, 25, 16, 66, 156, 186, 113,
+       74, 205, 27, 59, 145, 2, 74, 194, 208, 140, 20, 190, 236, 144, 72,
+       49, 169, 98, 168, 154, 190, 141, 193, 149, 231, 159, 23, 168, 9,
+       166, 250, 100, 82, 201, 123, 234, 1, 86, 111, 146, 243, 153, 182,
+       30, 123, 80, 8, 167, 138, 214, 137, 22, 158, 143, 196, 20, 163,
+       204, 144, 130, 27, 230, 240, 33, 75, 192, 247, 104, 67, 120, 75,
+       147, 105, 185, 34, 79, 27, 0, 120, 53, 14, 131, 94, 239, 95, 98,
+       26, 191, 49, 188, 74, 86, 231, 113, 230, 191, 99, 54, 96, 55, 174,
+       229, 212, 39, 75, 102, 42, 98, 128, 45, 240, 97, 253, 98, 48, 161,
+       178, 109, 133, 152, 4, 139, 249, 145, 91, 188, 156, 116, 10, 204,
+       25, 127, 149, 131, 111, 218, 224, 141, 24, 154, 186, 152, 10, 21,
+       219, 61, 65, 99, 77, 116, 135, 239, 112, 85, 200, 255, 70, 115,
+       217, 180, 100, 124, 168, 23, 238, 201, 178, 124, 156, 119, 236,
+       163, 128, 127, 186, 112, 240, 229, 122, 205, 86, 96, 29, 108, 20,
+       49, 226, 38, 220, 115, 69, 221, 191, 20, 228, 100, 110, 225, 212,
+       242, 42, 6, 251, 101, 48, 72, 251, 82, 60, 29, 135, 210, 169, 50,
+       163, 74, 250, 87, 129, 74, 198, 199, 227, 160, 64, 119, 12, 4,
+       124, 30, 152, 5, 31, 168, 228, 39, 68, 180, 170, 40, 128, 100,
+       187, 85, 224, 252, 201, 226, 237, 206, 49, 184, 106, 130, 25, 84,
+       129, 233, 144, 79, 113, 18, 43, 90, 212, 124, 152, 135, 124, 213,
+       11, 214, 130, 30, 190, 238, 61, 27, 27, 18, 248, 22, 166, 198,
+       231, 111, 109, 35, 129, 63, 125, 253, 99, 172, 241, 29, 190, 251,
+       231, 69, 151, 231, 173, 29, 211, 2, 41, 250, 157, 246, 128, 188,
+       71, 63, 1, 66, 131, 172, 190, 116, 64, 230, 63, 179, 133, 150,
+       155, 148, 195, 55, 60, 154, 3, 133, 68, 165, 142, 60, 237, 25,
+       238, 124, 207, 87, 249, 66, 136, 253, 40, 119, 217, 1, 48, 216,
+       250, 68, 98, 75, 171, 234, 63, 251, 237, 37, 57, 112, 186, 78,
+       169, 184, 204, 21, 126, 77, 205, 70, 230, 213, 18, 224, 9, 35, 89,
+       33, 145, 200, 226, 66, 70, 104, 175, 90, 191, 115, 219, 85, 59,
+       115, 89, 66, 138, 232, 167, 185, 251, 252, 76, 81, 29, 82, 61, 53,
+       56, 150, 81, 72, 123, 209, 26, 205, 48, 58, 110, 235, 19, 207,
+       241, 52, 125, 208, 200, 214, 99, 92, 180, 177, 106, 155, 236, 51,
+       11, 58, 7, 169, 24, 158, 247, 76, 216, 179, 27, 233, 16, 19, 6,
+       250, 83, 217, 221, 23, 126, 192, 66, 167, 243, 60, 181, 249, 107,
+       211, 113, 19, 75, 122, 13, 173, 56, 190, 254, 108, 48, 219, 155,
+       134, 144, 58, 74, 248, 211, 235, 221, 55, 127, 209, 72, 231, 243,
+       56, 181, 249, 219, 245, 241, 145, 79, 27, 29, 189, 58, 27, 127,
+       76, 48, 217, 155, 151, 144, 58, 234, 104, 215, 235, 221, 148, 127,
+       145, 72, 230, 227, 42, 188, 108, 27, 93, 183, 217, 239, 199, 93,
+       252, 21, 40, 13, 54, 21, 201, 138, 147, 149, 186, 170, 114, 255,
+       79, 95, 144, 107, 83, 12, 246, 222, 124, 74, 68, 41, 29, 139, 67,
+       152, 134, 52, 162, 73, 195, 65, 9, 218, 72, 196, 237, 115, 10, 35,
+       73, 52, 209, 225, 33, 85, 114, 43, 86, 32, 212, 207, 252, 254,
+       254, 232, 87, 188, 155, 30, 61, 57, 111, 123, 43, 83, 179, 243,
+       45, 98, 118, 69, 10, 183, 250, 231, 101, 255, 180, 243, 205, 67,
+       1, 161, 151, 177, 100, 136, 168, 35, 236, 17, 74, 64, 181, 131,
+       232, 64, 34, 43, 34, 8, 83, 152, 7, 97, 12, 128, 58, 64, 72, 128,
+       161, 160, 2, 185, 29, 185, 106, 133, 185, 115, 30, 25, 81, 82,
+       188, 151, 96, 96, 230, 27, 51, 129, 19, 88, 18, 213, 13, 128, 250,
+       236, 24, 0, 161, 185, 60, 121, 123, 236, 84, 207, 83, 112, 69,
+       192, 253, 74, 115, 217, 32, 112, 88, 184, 22, 106, 201, 178, 120,
+       31, 119, 237, 33, 17, 113, 170, 118, 163, 184, 204, 82, 254, 85,
+       199, 82, 228, 213, 4, 232, 11, 99, 217, 37, 17, 216, 250, 131, 66,
+       106, 191, 24, 191, 243, 239, 128, 11, 115, 25, 118, 138, 82, 76,
+       150, 188, 9, 100, 20, 230, 175, 154, 130, 17, 238, 210, 97, 207,
+       225, 117, 235, 3, 108, 71, 131, 200, 145, 242, 95, 27, 0, 117, 45,
+       14, 56, 172, 56, 186, 61, 233, 211, 198, 150, 13, 244, 25, 183,
+       221, 98, 1, 201, 59, 199, 17, 62, 111, 66, 63, 219, 215, 48, 123,
+       208, 9, 94, 202, 170, 40, 176, 120, 253, 249, 208, 66, 223, 13,
+       244, 57, 42, 152, 103, 156, 201, 187, 130, 16, 62, 111, 194, 179,
+       27, 215, 16, 123, 211, 77, 94, 142, 0, 161, 154, 129, 216, 163,
+       32, 71, 38, 1, 202, 0, 148, 162, 96, 192, 248, 14, 10, 24, 18,
+       187, 1, 84, 188, 164, 30, 76, 128, 74, 161, 136, 205, 96, 183,
+       118, 100, 108, 103, 20, 233, 234, 23, 8, 118, 117, 219, 63, 176,
+       100, 125, 110, 1, 117, 163, 42, 213, 186, 117, 152, 74, 243, 82,
+       107, 8, 98, 218, 169, 126, 131, 168, 77, 30, 161, 80, 226, 149,
+       195, 225, 0, 127, 57, 3, 177, 2, 183, 0, 26, 124, 133, 191, 108,
+       149, 152, 57, 137, 31, 41, 227, 172, 108, 4, 217, 72, 41, 192,
+       208, 195, 61, 223, 53, 174, 254, 249, 55, 199, 201, 131, 150, 225,
+       145, 120, 202, 136, 23, 165, 51, 176, 244, 205, 248, 254, 224,
+       104, 87, 172, 185, 30, 57, 57, 231, 119, 9, 18, 179, 242, 69, 66,
+       120, 36, 138, 35, 229, 246, 100, 171, 224, 243, 198, 227, 60, 248,
+       190, 254, 58, 67, 19, 248, 22, 156, 212, 169, 246, 247, 235, 97,
+       87, 124, 253, 114, 34, 67, 235, 61, 218, 135, 101, 191, 182, 169,
+       12, 99, 118, 237, 158, 186, 157, 237, 67, 198, 143, 188, 168, 8,
+       166, 210, 101, 86, 201, 242, 106, 80, 11, 107, 154, 245, 185, 148,
+       23, 123, 208, 9, 110, 14, 60, 76, 246, 126, 77, 54, 198, 208, 197,
+       130, 233, 6, 99, 233, 53, 222, 216, 240, 162, 106, 9, 163, 90,
+       170, 51, 255, 193, 26, 251, 251, 120, 130, 176, 77, 74, 174, 85,
+       199, 198, 64, 85, 6, 232, 11, 35, 217, 51, 80, 248, 232, 6, 227,
+       108, 167, 16, 191, 179, 206, 128, 27, 113, 59, 120, 138, 158, 50,
+       179, 160, 54, 7, 184, 81, 175, 201, 147, 247, 29, 223, 244, 142,
+       174, 185, 223, 215, 129, 197, 144, 192, 145, 209, 11, 130, 15,
+       173, 37, 241, 158, 114, 117, 179, 15, 237, 185, 76, 143, 119, 147,
+       183, 172, 92, 79, 143, 167, 17, 223, 17, 162, 69, 59, 208, 149,
+       82, 90, 243, 135, 28, 133, 247, 38, 146, 164, 26, 205, 177, 180,
+       207, 223, 63, 93, 63, 200, 232, 126, 140, 217, 27, 162, 145, 150,
+       58, 30, 209, 14, 87, 218, 111, 223, 76, 189, 214, 120, 105, 59,
+       100, 28, 73, 87, 101, 4, 164, 168, 9, 179, 133, 97, 0, 88, 252,
+       78, 106, 72, 59, 193, 40, 243, 197, 37, 57, 96, 186, 196, 10, 82,
+       162, 156, 186, 41, 237, 81, 201, 191, 61, 69, 25, 6, 194, 106, 89,
+       161, 137, 173, 1, 30, 81, 138, 49, 217, 243, 80, 127, 144, 3, 143,
+       67, 76, 99, 158, 162, 232, 201, 87, 216, 170, 157, 189, 41, 222,
+       195, 107, 26, 128, 113, 207, 82, 2, 67, 138, 32, 216, 209, 47,
+       249, 128, 83, 175, 131, 18, 41, 114, 232, 215, 207, 248, 71, 173,
+       128, 240, 11, 47, 191, 53, 48, 254, 187, 91, 241, 30, 171, 0, 204,
+       251, 216, 14, 59, 231, 12, 39, 142, 11, 89, 99, 199, 118, 215,
+       239, 116, 237, 232, 90, 230, 120, 220, 181, 228, 126, 61, 23, 239,
+       197, 176, 52, 204, 38, 28, 171, 128, 15, 182, 113, 253, 124, 249,
+       123, 236, 91, 143, 87, 97, 175, 164, 237, 8, 47, 223, 32, 80, 254,
+       253, 206, 98, 90, 187, 184, 189, 251, 229, 5, 59, 114, 42, 135,
+       50, 188, 76, 110, 252, 85, 247, 230, 112, 213, 134, 246, 2, 121,
+       249, 53, 105, 120, 248, 147, 234, 104, 183, 52, 190, 115, 239,
+       192, 1, 119, 251, 124, 170, 180, 77, 66, 236, 85, 129, 206, 96,
+       85, 0, 248, 10, 35, 201, 53, 132, 120, 232, 6, 203, 104, 167, 80,
+       255, 177, 252, 131, 57, 117, 187, 114, 164, 70, 41, 148, 129, 139,
+       40, 56, 11, 175, 177, 139, 17, 204, 162, 64, 90, 163, 87, 107,
+       145, 18, 73, 203, 192, 157, 182, 95, 119, 128, 99, 135, 2, 178,
+       164, 114, 200, 213, 247, 210, 71, 223, 7, 249, 26, 10, 216, 124,
+       132, 249, 186, 131, 144, 62, 191, 16, 214, 59, 92, 145, 111, 211,
+       76, 252, 134, 0, 169, 129, 145, 212, 172, 160, 7, 62, 25, 90, 66,
+       148, 179, 64, 72, 105, 58, 2, 152, 18, 88, 195, 81, 13, 132, 190,
+       64, 136, 72, 177, 168, 8, 221, 55, 248, 239, 193, 245, 231, 205,
+       86, 120, 34, 188, 30, 32, 33, 235, 179, 130, 49, 86, 41, 50, 253,
+       125, 147, 22, 75, 83, 10, 229, 235, 57, 153, 81, 236, 212, 79, 71,
+       125, 68, 224, 248, 74, 83, 117, 32, 176, 88, 252, 2, 104, 89, 186,
+       112, 15, 121, 140, 165, 36, 113, 170, 112, 168, 69, 168, 191, 94,
+       56, 199, 27, 184, 150, 221, 69, 0, 244, 247, 233, 127, 213, 120,
+       56, 90, 34, 75, 250, 61, 73, 155, 101, 124, 144, 163, 36, 97, 150,
+       195, 205, 195, 198, 74, 234, 164, 46, 49, 187, 86, 213, 10, 92,
+       66, 107, 199, 59, 219, 67, 248, 31, 224, 156, 162, 254, 68, 173,
+       26, 169, 8, 125, 14, 234, 206, 132, 54, 207, 144, 212, 198, 223,
+       2, 81, 233, 183, 238, 120, 228, 59, 234, 168, 167, 189, 234, 115,
+       47, 199, 9, 231, 251, 116, 100, 176, 109, 66, 254, 93, 141, 206,
+       226, 85, 0, 248, 10, 35, 201, 53, 16, 216, 232, 7, 202, 106, 43,
+       90, 255, 177, 220, 128, 56, 81, 155, 114, 138, 96, 237, 17, 170,
+       125, 141, 198, 228, 239, 32, 184, 8, 182, 152, 100, 16, 200, 251,
+       78, 67, 74, 43, 218, 255, 181, 144, 2, 58, 80, 27, 67, 138, 66,
+       225, 145, 163, 249, 201, 52, 173, 171, 49, 169, 24, 142, 218, 76,
+       18, 131, 27, 106, 80, 82, 43, 202, 209, 189, 148, 22, 127, 192, 2,
+       135, 10, 9, 157, 7, 43, 144, 174, 107, 183, 108, 65, 106, 68, 157,
+       35, 48, 208, 54, 38, 24, 60, 145, 152, 53, 63, 237, 239, 34, 64,
+       186, 82, 193, 121, 216, 106, 255, 118, 46, 74, 117, 52, 232, 158,
+       55, 176, 255, 13, 129, 59, 166, 117, 108, 98, 96, 229, 163, 104,
+       241, 227, 100, 1, 100, 176, 39, 105, 135, 0, 22, 208, 54, 167,
+       184, 65, 173, 145, 87, 210, 220, 211, 165, 111, 166, 49, 95, 184,
+       33, 213, 20, 204, 156, 152, 139, 198, 142, 128, 41, 5, 139, 158,
+       255, 121, 178, 246, 120, 151, 127, 91, 86, 245, 121, 63, 182, 236,
+       183, 63, 181, 148, 179, 220, 35, 247, 78, 255, 126, 194, 190, 196,
+       237, 127, 112, 233, 30, 158, 77, 205, 103, 233, 238, 54, 233, 10,
+       242, 194, 78, 83, 249, 238, 106, 194, 74, 99, 251, 117, 189, 162,
+       199, 60, 17, 42, 231, 2, 94, 105, 58, 174, 51, 203, 27, 96, 175,
+       140, 254, 171, 174, 223, 34, 80, 234, 253, 207, 64, 88, 187, 136,
+       252, 243, 245, 43, 251, 72, 47, 165, 83, 186, 140, 102, 219, 31,
+       243, 248, 111, 221, 19, 192, 19, 41, 56, 54, 239, 235, 131, 155,
+       161, 62, 237, 23, 223, 187, 251, 218, 67, 151, 76, 120, 142, 161,
+       185, 25, 245, 205, 221, 100, 61, 94, 232, 96, 88, 183, 176, 64,
+       176, 144, 62, 114, 88, 247, 124, 219, 55, 175, 223, 85, 124, 88,
+       8, 200, 188, 179, 53, 107, 198, 110, 83, 248, 96, 65, 108, 249,
+       171, 0, 156, 254, 51, 238, 141, 23, 231, 220, 186, 164, 192, 22,
+       88, 232, 171, 101, 142, 118, 215, 192, 164, 155, 117, 108, 11,
+       237, 41, 118, 162, 67, 24, 241, 225, 208, 65, 19, 108, 98, 40,
+       112, 252, 203, 15, 76, 174, 231, 40, 4, 224, 83, 168, 252, 172,
+       187, 102, 176, 118, 223, 249, 114, 142, 109, 24, 123, 245, 57, 48,
+       181, 126, 53, 42, 232, 119, 184, 15, 123, 239, 101, 44, 195, 242,
+       102, 104, 242, 229, 22, 136, 25, 3, 4, 109, 140, 4, 168, 9, 6,
+       130, 41, 214, 216, 129, 202, 96, 78, 43, 194, 93, 176, 16, 5, 63,
+       80, 24, 170, 14, 125, 97, 193, 100, 77, 26, 79, 184, 1, 160, 172,
+       202, 75, 97, 201, 183, 88, 196, 252, 234, 73, 67, 237, 168, 176,
+       249, 197, 60, 47, 255, 90, 36, 59, 217, 119, 224, 127, 31, 88,
+       113, 141, 160, 246, 11, 31, 31, 52, 244, 238, 177, 255, 117, 220,
+       187, 49, 220, 255, 221, 143, 86, 55, 174, 100, 250, 26, 219, 90,
+       160, 23, 130, 186, 228, 173, 12, 254, 167, 12, 223, 39, 64, 254,
+       253, 151, 225, 4, 155, 16, 236, 250, 245, 138, 203, 39, 15, 45,
+       219, 197, 96, 29, 188, 56, 160, 185, 24, 138, 152, 17, 120, 213,
+       211, 232, 43, 134, 117, 125, 125, 35, 69, 138, 92, 200, 177, 43,
+       252, 28, 163, 3, 129, 0, 163, 155, 179, 244, 165, 189, 87, 94, 31,
+       89, 116, 188, 171, 224, 8, 135, 59, 38, 17, 146, 152, 138, 81,
+       204, 150, 62, 224, 148, 194, 161, 137, 75, 25, 98, 156, 247, 244,
+       123, 87, 29, 73, 94, 167, 44, 183, 182, 244, 118, 170, 147, 157,
+       151, 154, 52, 239, 54, 116, 138, 202, 158, 196, 60, 95, 155, 159,
+       34, 184, 214, 146, 62, 119, 85, 69, 86, 246, 173, 158, 178, 229,
+       118, 171, 151, 213, 247, 155, 36, 223, 190, 97, 158, 201, 62, 132,
+       185, 93, 123, 82, 106, 68, 87, 86, 219, 112, 89, 109, 215, 175,
+       91, 44, 190, 229, 126, 149, 151, 229, 173, 179, 53, 204, 83, 127,
+       202, 135, 111, 175, 126, 245, 74, 171, 135, 190, 27, 213, 62, 99,
+       174, 196, 202, 193, 236, 238, 32, 192, 166, 119, 235, 195, 150,
+       137, 10, 253, 189, 119, 15, 131, 4, 39, 45, 206, 171, 132, 117,
+       217, 119, 191, 248, 99, 93, 83, 85, 147, 172, 61, 180, 173, 239,
+       59, 151, 189, 178, 252, 100, 223, 15, 90, 218, 226, 151, 204, 85,
+       255, 41, 220, 153, 111, 28, 95, 70, 191, 82, 232, 168, 72, 243,
+       80, 20, 240, 217, 108, 88, 10, 207, 174, 217, 63, 227, 253, 165,
+       52, 88, 58, 218, 152, 244, 117, 120, 224, 158, 77, 215, 248, 1,
+       166, 180, 11, 82, 93, 79, 3, 62, 208, 93, 99, 104, 39, 248, 26,
+       241, 137, 5, 61, 101, 59, 86, 98, 112, 65, 18, 172, 29, 3, 70,
+       236, 5, 4, 160, 11, 34, 11, 37, 145, 248, 128, 206, 224, 76, 43,
+       0, 157, 177, 212, 132, 31, 113, 24, 126, 14, 125, 197, 64, 79,
+       210, 2, 70, 188, 113, 162, 238, 74, 83, 97, 141, 180, 93, 196, 80,
+       234, 233, 178, 93, 30, 122, 239, 133, 20, 107, 251, 218, 0, 35,
+       48, 99, 8, 116, 148, 184, 83, 169, 73, 80, 229, 44, 158, 182, 188,
+       206, 41, 215, 157, 151, 155, 36, 192, 22, 92, 154, 202, 207, 132,
+       123, 221, 27, 25, 2, 168, 251, 146, 186, 228, 173, 12, 218, 167,
+       12, 222, 39, 192, 254, 249, 255, 213, 85, 139, 2, 236, 152, 116,
+       138, 203, 157, 15, 41, 223, 75, 143, 151, 189, 155, 118, 188, 167,
+       222, 211, 202, 210, 237, 174, 33, 235, 231, 119, 170, 129, 245,
+       220, 7, 239, 173, 119, 94, 3, 148, 116, 169, 12, 223, 24, 199,
+       180, 194, 54, 110, 80, 53, 194, 67, 199, 93, 238, 179, 251, 118,
+       237, 63, 247, 141, 213, 189, 232, 152, 98, 239, 128, 172, 247, 33,
+       84, 151, 76, 231, 133, 134, 114, 175, 98, 189, 194, 210, 198, 221,
+       174, 183, 111, 126, 229, 63, 239, 165, 213, 181, 232, 176, 42,
+       207, 128, 173, 247, 49, 244, 86, 187, 178, 160, 185, 204, 26, 143,
+       171, 189, 152, 173, 142, 191, 70, 18, 167, 55, 253, 81, 22, 73,
+       146, 242, 187, 213, 31, 255, 130, 4, 135, 95, 3, 30, 183, 159,
+       169, 116, 188, 7, 175, 219, 219, 247, 172, 190, 54, 239, 231, 55,
+       187, 133, 133, 201, 179, 193, 7, 62, 222, 131, 132, 116, 173, 223,
+       210, 105, 138, 172, 3, 4, 63, 101, 160, 6, 198, 135, 37, 199, 34,
+       83, 100, 237, 121, 198, 72, 199, 146, 41, 241, 225, 202, 25, 32,
+       48, 182, 90, 49, 77, 138, 237, 20, 62, 238, 214, 48, 72, 254, 68,
+       179, 246, 181, 96, 216, 110, 21, 206, 201, 144, 240, 41, 227, 237,
+       170, 128, 25, 123, 122, 184, 201, 130, 92, 169, 104, 24, 120, 58,
+       105, 23, 119, 25, 221, 43, 154, 219, 227, 5, 110, 172, 20, 126,
+       199, 65, 222, 251, 114, 77, 84, 160, 43, 0, 61, 189, 117, 100,
+       215, 95, 87, 251, 80, 238, 124, 10, 91, 125, 145, 32, 61, 222, 21,
+       43, 233, 178, 61, 14, 115, 207, 37, 52, 99, 254, 214, 115, 3, 10,
+       135, 141, 118, 166, 168, 3, 30, 41, 82, 98, 52, 58, 164, 64, 230,
+       149, 59, 157, 19, 152, 1, 204, 28, 46, 186, 128, 149, 136, 49, 41,
+       50, 72, 198, 156, 23, 130, 232, 1, 143, 1, 226, 2, 64, 202, 36,
+       80, 120, 173, 42, 193, 8, 177, 2, 192, 144, 164, 130, 1, 49, 42,
+       104, 6, 95, 94, 199, 164, 194, 54, 126, 210, 161, 194, 90, 199,
+       93, 238, 51, 219, 102, 237, 191, 247, 133, 213, 149, 232, 152, 99,
+       239, 128, 173, 247, 41, 81, 87, 95, 231, 149, 150, 38, 175, 66,
+       173, 194, 90, 198, 93, 174, 183, 231, 110, 229, 63, 255, 229, 213,
+       181, 236, 176, 34, 207, 130, 173, 245, 49, 117, 57, 93, 123, 254,
+       117, 215, 223, 112, 213, 200, 252, 10, 123, 253, 55, 52, 220, 249,
+       151, 107, 237, 163, 114, 175, 243, 255, 128, 155, 119, 191, 116,
+       251, 56, 221, 120, 110, 125, 221, 87, 252, 87, 72, 252, 42, 59,
+       93, 62, 52, 220, 154, 151, 106, 234, 42, 122, 191, 243, 221, 32,
+       187, 119, 158, 86, 251, 162, 158, 62, 218, 244, 245, 186, 114, 29,
+       95, 85, 183, 104, 125, 190, 45, 207, 187, 151, 183, 182, 126, 104,
+       255, 79, 90, 218, 203, 87, 205, 244, 215, 2, 183, 171, 203, 178,
+       163, 191, 220, 30, 13, 92, 227, 245, 247, 168, 96, 127, 59, 151,
+       149, 130, 144, 36, 255, 237, 5, 190, 128, 180, 218, 181, 249, 101,
+       68, 63, 82, 13, 245, 135, 232, 198, 134, 175, 8, 210, 216, 125,
+       46, 217, 112, 122, 42, 201, 167, 122, 36, 27, 30, 69, 92, 65, 123,
+       116, 164, 67, 31, 234, 109, 114, 162, 187, 118, 56, 200, 126, 231,
+       185, 174, 183, 112, 246, 127, 21, 133, 133, 152, 164, 237, 100,
+       44, 174, 129, 13, 240, 43, 153, 27, 58, 178, 29, 51, 144, 177, 86,
+       125, 77, 116, 180, 172, 154, 167, 236, 166, 59, 134, 145, 166,
+       253, 36, 226, 80, 246, 26, 131, 207, 4, 39, 159, 95, 214, 126,
+       200, 125, 60, 121, 218, 237, 125, 190, 102, 11, 9, 254, 247, 110,
+       132, 223, 248, 155, 35, 53, 212, 122, 249, 163, 199, 255, 133,
+       108, 117, 121, 65, 106, 236, 95, 16, 75, 124, 65, 132, 253, 138,
+       123, 201, 190, 176, 122, 232, 215, 238, 200, 35, 228, 137, 243,
+       237, 164, 185, 119, 190, 114, 32, 189, 201, 107, 106, 214, 150,
+       79, 252, 85, 64, 124, 198, 83, 205, 179, 116, 126, 232, 22, 238,
+       217, 186, 60, 191, 126, 237, 164, 200, 127, 170, 112, 240, 38,
+       179, 235, 154, 246, 225, 180, 73, 26, 91, 89, 247, 100, 253, 108,
+       8, 255, 27, 179, 129, 19, 114, 142, 211, 28, 22, 191, 239, 221,
+       78, 183, 211, 26, 215, 106, 171, 182, 163, 123, 222, 5, 13, 94,
+       167, 125, 79, 186, 64, 126, 251, 159, 245, 138, 152, 1, 253, 238,
+       69, 190, 193, 191, 223, 184, 91, 91, 137, 78, 172, 246, 147, 126,
+       230, 141, 64, 222, 167, 109, 42, 50, 65, 246, 163, 159, 229, 252,
+       155, 21, 253, 250, 99, 234, 193, 60, 140, 169, 26, 144, 128, 157,
+       249, 152, 103, 25, 15, 22, 57, 130, 18, 148, 55, 64, 104, 197, 19,
+       63, 144, 59, 92, 67, 87, 201, 134, 254, 84, 144, 72, 165, 34, 17,
+       158, 22, 181, 114, 162, 42, 162, 62, 160, 106, 102, 116, 242, 32,
+       193, 255, 239, 50, 160, 61, 216, 1, 127, 156, 166, 203, 64, 140,
+       33, 41, 8, 120, 73, 18, 108, 69, 67, 86, 236, 193, 4, 224, 11, 42,
+       217, 37, 144, 248, 232, 198, 226, 76, 35, 16, 188, 179, 244, 128,
+       59, 83, 63, 126, 138, 184, 72, 110, 229, 71, 86, 75, 120, 69, 128,
+       254, 2, 123, 9, 51, 96, 120, 148, 55, 234, 72, 190, 53, 142, 83,
+       233, 128, 1, 103, 142, 124, 42, 35, 27, 99, 141, 220, 146, 170,
+       222, 28, 193, 218, 231, 160, 204, 181, 236, 124, 234, 147, 221,
+       149, 154, 102, 252, 30, 62, 154, 195, 151, 143, 117, 252, 3, 141,
+       202, 159, 158, 192, 190, 230, 222, 194, 94, 167, 240, 248, 55, 69,
+       247, 107, 59, 199, 231, 232, 14, 239, 108, 62, 222, 11, 29, 79,
+       57, 158, 3, 205, 166, 159, 151, 132, 165, 166, 158, 71, 78, 151,
+       172, 181, 54, 69, 107, 106, 59, 13, 114, 248, 19, 255, 44, 62,
+       222, 2, 159, 92, 241, 254, 94, 126, 214, 196, 226, 170, 63, 242,
+       169, 166, 190, 231, 77, 167, 231, 94, 39, 245, 239, 254, 32, 213,
+       128, 238, 222, 198, 103, 198, 175, 243, 39, 49, 3, 137, 238, 158,
+       247, 240, 188, 231, 187, 215, 94, 167, 108, 238, 63, 79, 231, 111,
+       179, 149, 150, 217, 166, 225, 14, 54, 222, 131, 135, 68, 189, 223,
+       18, 106, 243, 21, 55, 216, 184, 71, 253, 203, 86, 243, 174, 205,
+       149, 132, 62, 43, 221, 13, 163, 253, 164, 207, 166, 118, 18, 131,
+       103, 132, 47, 253, 26, 122, 162, 181, 39, 216, 240, 87, 191, 201,
+       86, 167, 174, 204, 146, 172, 166, 57, 199, 5, 197, 248, 38, 201,
+       134, 115, 90, 131, 110, 140, 31, 253, 110, 97, 232, 234, 205, 81,
+       254, 217, 2, 108, 157, 139, 217, 205, 91, 0, 88, 24, 247, 223, 94,
+       2, 234, 144, 127, 205, 175, 237, 183, 159, 254, 210, 229, 91, 221,
+       95, 186, 200, 151, 156, 158, 76, 116, 228, 247, 245, 143, 74, 86,
+       114, 44, 86, 147, 96, 235, 43, 110, 191, 100, 152, 220, 187, 197,
+       241, 7, 95, 231, 148, 242, 178, 175, 242, 173, 194, 94, 230, 232,
+       238, 183, 231, 102, 237, 63, 239, 197, 217, 164, 236, 50, 62, 239,
+       130, 47, 247, 57, 253, 66, 251, 166, 150, 251, 148, 184, 197, 171,
+       221, 86, 167, 108, 238, 254, 198, 167, 111, 251, 213, 214, 201,
+       170, 225, 30, 48, 222, 203, 142, 6, 175, 223, 26, 111, 231, 197,
+       119, 178, 238, 214, 41, 136, 90, 230, 44, 45, 149, 134, 46, 255,
+       215, 221, 225, 248, 161, 238, 54, 46, 46, 130, 231, 244, 63, 253,
+       57, 122, 74, 225, 7, 87, 25, 112, 4, 236, 148, 170, 155, 23, 195,
+       164, 92, 184, 159, 233, 201, 18, 116, 136, 243, 193, 170, 177, 39,
+       172, 30, 107, 56, 96, 202, 53, 0, 105, 120, 71, 54, 167, 126, 153,
+       179, 161, 66, 24, 59, 174, 255, 24, 14, 212, 197, 2, 198, 133,
+       180, 33, 229, 216, 222, 202, 0, 43, 186, 225, 180, 173, 233, 83,
+       111, 173, 124, 32, 183, 137, 211, 0, 170, 42, 7, 28, 146, 184, 96,
+       206, 204, 221, 50, 225, 196, 136, 87, 249, 185, 65, 106, 76, 69,
+       86, 227, 248, 69, 4, 246, 2, 115, 153, 183, 96, 120, 236, 51, 234,
+       200, 183, 53, 142, 115, 105, 128, 1, 119, 187, 116, 234, 0, 188,
+       11, 251, 116, 233, 160, 55, 28, 3, 121, 240, 181, 29, 0, 32, 205,
+       59, 19, 1, 51, 188, 80, 79, 69, 22, 186, 64, 204, 8, 23, 184, 77,
+       196, 6, 158, 91, 151, 166, 105, 214, 160, 235, 110, 224, 226, 168,
+       197, 125, 236, 234, 162, 117, 227, 207, 95, 60, 38, 207, 126, 27,
+       46, 171, 132, 43, 13, 98, 221, 213, 167, 235, 94, 87, 69, 88, 135,
+       97, 237, 55, 100, 92, 110, 19, 253, 146, 186, 117, 191, 37, 110,
+       146, 74, 255, 159, 112, 252, 162, 140, 6, 153, 213, 239, 165, 103,
+       30, 91, 76, 19, 164, 49, 54, 13, 169, 42, 19, 13, 114, 220, 19,
+       223, 45, 30, 222, 194, 158, 76, 241, 190, 124, 146, 241, 171, 190,
+       123, 18, 141, 79, 189, 25, 106, 199, 120, 200, 160, 151, 21, 238,
+       49, 151, 48, 111, 145, 190, 199, 37, 118, 244, 234, 149, 101, 92,
+       50, 249, 32, 174, 123, 214, 217, 79, 234, 57, 106, 86, 216, 200,
+       168, 179, 93, 238, 51, 212, 49, 173, 18, 222, 197, 37, 127, 228,
+       235, 143, 67, 179, 132, 224, 95, 207, 48, 222, 239, 85, 23, 252,
+       178, 104, 104, 190, 229, 95, 210, 150, 167, 254, 46, 111, 255, 54,
+       127, 214, 143, 255, 252, 248, 140, 183, 231, 72, 72, 223, 51, 222,
+       237, 67, 55, 189, 186, 74, 8, 222, 149, 127, 138, 134, 182, 126,
+       63, 109, 215, 58, 89, 133, 127, 119, 142, 254, 196, 35, 183, 200,
+       13, 254, 49, 188, 255, 90, 111, 124, 239, 49, 40, 222, 32, 127,
+       207, 150, 165, 151, 58, 229, 211, 126, 13, 190, 165, 221, 222,
+       251, 221, 131, 159, 101, 219, 190, 135, 175, 245, 205, 64, 87,
+       230, 184, 21, 180, 37, 110, 50, 59, 239, 241, 184, 63, 253, 45,
+       24, 142, 194, 23, 143, 245, 253, 121, 81, 194, 164, 85, 31, 104,
+       220, 19, 225, 199, 207, 91, 233, 123, 216, 56, 204, 55, 237, 141,
+       114, 156, 128, 146, 237, 129, 44, 191, 254, 88, 20, 150, 111, 67,
+       196, 246, 243, 106, 214, 61, 192, 94, 230, 117, 39, 181, 133, 54,
+       238, 55, 254, 33, 218, 37, 238, 62, 12, 165, 128, 175, 249, 112,
+       57, 14, 122, 190, 145, 54, 251, 185, 83, 189, 220, 94, 163, 140,
+       159, 227, 105, 238, 57, 159, 17, 6, 153, 48, 192, 199, 81, 58,
+       131, 150, 92, 37, 251, 120, 226, 158, 182, 139, 19, 20, 205, 18,
+       182, 131, 139, 103, 232, 75, 154, 249, 221, 233, 147, 76, 215,
+       219, 10, 219, 199, 221, 55, 160, 122, 30, 10, 239, 85, 109, 69,
+       232, 22, 239, 189, 5, 234, 190, 230, 80, 101, 159, 230, 92, 196,
+       186, 238, 201, 131, 253, 74, 100, 43, 237, 148, 111, 254, 248,
+       245, 66, 174, 180, 176, 171, 225, 21, 135, 187, 63, 136, 185, 140,
+       190, 66, 155, 135, 87, 237, 145, 54, 75, 138, 243, 153, 86, 94,
+       255, 128, 68, 135, 79, 185, 97, 107, 226, 86, 210, 203, 244, 65,
+       192, 244, 138, 91, 77, 183, 48, 122, 228, 23, 254, 201, 163, 44,
+       172, 251, 201, 161, 144, 103, 187, 114, 248, 43, 255, 99, 13, 119,
+       179, 170, 71, 94, 65, 88, 231, 40, 232, 182, 196, 254, 43, 146,
+       133, 135, 186, 36, 255, 36, 62, 154, 234, 95, 14, 251, 221, 11,
+       152, 241, 253, 103, 173, 249, 87, 31, 41, 116, 211, 189, 191, 100,
+       136, 206, 59, 55, 12, 147, 28, 210, 209, 71, 221, 58, 168, 86,
+       128, 67, 233, 212, 247, 104, 231, 22, 92, 199, 57, 66, 236, 191,
+       14, 115, 79, 75, 35, 56, 196, 108, 242, 110, 116, 253, 15, 251,
+       225, 165, 53, 97, 42, 84, 114, 96, 147, 177, 255, 188, 88, 22,
+       191, 91, 25, 88, 108, 230, 240, 200, 226, 215, 90, 140, 97, 223,
+       10, 239, 177, 172, 245, 175, 186, 148, 122, 212, 45, 122, 239, 18,
+       56, 123, 217, 22, 229, 173, 12, 188, 169, 46, 206, 38, 148, 182,
+       187, 207, 67, 70, 43, 0, 255, 179, 85, 1, 59, 82, 30, 175, 79, 75,
+       251, 198, 28, 219, 144, 184, 205, 175, 213, 70, 231, 44, 206, 230,
+       214, 102, 235, 251, 213, 215, 203, 166, 225, 30, 50, 143, 203, 15,
+       132, 171, 221, 127, 49, 192, 140, 209, 62, 106, 216, 19, 225, 96,
+       207, 73, 235, 127, 220, 124, 204, 147, 253, 143, 18, 156, 202, 62,
+       108, 133, 172, 191, 239, 90, 156, 36, 173, 120, 193, 180, 235,
+       105, 51, 111, 164, 254, 160, 147, 5, 195, 68, 75, 190, 79, 24, 26,
+       184, 101, 156, 236, 157, 167, 81, 214, 136, 84, 120, 139, 207, 53,
+       233, 52, 207, 253, 55, 141, 105, 90, 80, 191, 31, 176, 97, 196,
+       39, 31, 13, 235, 152, 97, 157, 231, 249, 186, 212, 22, 140, 145,
+       233, 57, 12, 251, 73, 86, 251, 226, 198, 86, 105, 254, 2, 115, 24,
+       191, 224, 120, 138, 134, 156, 47, 186, 117, 63, 119, 175, 48, 1,
+       241, 216, 112, 234, 43, 141, 32, 94, 213, 151, 175, 238, 95, 15,
+       108, 2, 105, 102, 188, 116, 249, 234, 2, 206, 114, 186, 62, 255,
+       61, 222, 158, 66, 211, 94, 229, 236, 109, 188, 227, 32, 229, 47,
+       67, 242, 83, 238, 118, 29, 82, 57, 83, 28, 217, 204, 55, 127, 153,
+       246, 248, 162, 94, 94, 229, 118, 207, 253, 82, 226, 107, 142, 229,
+       92, 253, 18, 142, 191, 83, 75, 212, 246, 233, 108, 182, 236, 93,
+       198, 182, 173, 191, 234, 239, 239, 46, 126, 223, 201, 159, 236,
+       248, 124, 189, 124, 65, 34, 84, 47, 74, 120, 84, 226, 97, 207, 83,
+       64, 49, 181, 94, 168, 2, 110, 237, 182, 92, 62, 52, 72, 129, 36,
+       127, 191, 82, 208, 42, 99, 226, 77, 95, 30, 107, 92, 11, 164, 125,
+       206, 73, 195, 223, 86, 126, 204, 131, 124, 130, 146, 188, 200,
+       118, 44, 133, 164, 47, 190, 90, 220, 147, 111, 242, 148, 255, 147,
+       252, 71, 223, 166, 178, 51, 40, 234, 231, 206, 235, 227, 138, 148,
+       228, 207, 68, 202, 58, 30, 159, 147, 135, 124, 249, 79, 92, 115,
+       122, 104, 63, 215, 91, 88, 71, 76, 180, 39, 15, 223, 235, 116,
+       118, 140, 204, 250, 206, 35, 161, 148, 211, 237, 33, 127, 51, 135,
+       108, 119, 43, 91, 98, 140, 118, 18, 158, 244, 221, 76, 86, 231,
+       173, 140, 183, 196, 94, 121, 135, 103, 197, 185, 36, 255, 34, 102,
+       170, 130, 63, 191, 61, 221, 149, 77, 107, 167, 150, 10, 79, 181,
+       116, 160, 195, 194, 247, 97, 17, 96, 122, 228, 29, 239, 105, 145,
+       77, 46, 225, 175, 173, 16, 44, 178, 176, 40, 91, 150, 135, 148,
+       147, 18, 4, 59, 119, 234, 210, 246, 235, 96, 136, 245, 93, 255,
+       172, 161, 253, 222, 69, 159, 184, 118, 255, 134, 174, 100, 184,
+       29, 147, 92, 111, 7, 86, 22, 239, 112, 112, 194, 66, 199, 113, 14,
+       183, 97, 124, 237, 16, 239, 237, 151, 53, 78, 113, 43, 234, 132,
+       45, 179, 50, 220, 61, 193, 106, 232, 15, 211, 75, 248, 197, 128,
+       244, 138, 91, 221, 186, 32, 122, 192, 95, 234, 200, 39, 54, 156,
+       243, 201, 163, 253, 119, 175, 122, 226, 57, 141, 43, 158, 117,
+       231, 222, 254, 22, 104, 220, 11, 112, 253, 56, 32, 89, 234, 23,
+       237, 46, 58, 8, 191, 123, 31, 165, 189, 87, 234, 90, 202, 47, 164,
+       232, 202, 253, 47, 67, 221, 7, 109, 221, 13, 210, 197, 222, 20,
+       217, 136, 23, 62, 27, 2, 217, 147, 111, 156, 165, 252, 154, 74,
+       210, 242, 75, 235, 198, 153, 121, 146, 40, 158, 55, 89, 210, 228,
+       169, 134, 214, 244, 92, 237, 190, 213, 207, 218, 231, 245, 14, 50,
+       191, 204, 15, 132, 184, 92, 175, 207, 97, 193, 237, 59, 78, 191,
+       91, 122, 56, 252, 139, 105, 156, 181, 91, 74, 151, 110, 251, 48,
+       76, 183, 38, 216, 229, 244, 62, 255, 210, 229, 107, 247, 65, 65,
+       197, 63, 236, 191, 99, 123, 62, 222, 73, 36, 222, 180, 61, 198,
+       246, 172, 215, 120, 237, 215, 62, 95, 245, 228, 239, 222, 218,
+       125, 177, 204, 91, 122, 84, 143, 110, 245, 113, 98, 96, 78, 115,
+       67, 48, 241, 120, 168, 18, 110, 105, 190, 24, 63, 55, 239, 0, 96,
+       121, 154, 234, 152, 22, 41, 234, 148, 141, 211, 212, 199, 223,
+       214, 162, 131, 42, 172, 119, 207, 233, 251, 171, 145, 110, 105,
+       54, 234, 187, 86, 215, 63, 213, 116, 252, 94, 22, 232, 238, 144,
+       157, 211, 92, 199, 95, 246, 130, 131, 14, 172, 119, 89, 227, 237,
+       139, 145, 110, 109, 63, 216, 187, 86, 215, 63, 148, 116, 253, 94,
+       117, 112, 107, 72, 116, 91, 91, 88, 105, 76, 245, 173, 27, 223,
+       191, 112, 242, 136, 215, 110, 207, 39, 52, 93, 83, 121, 32, 173,
+       127, 135, 102, 119, 131, 122, 234, 153, 114, 178, 184, 86, 191,
+       207, 94, 247, 172, 142, 167, 104, 239, 59, 151, 149, 134, 156, 38,
+       202, 134, 20, 154, 131, 189, 212, 37, 223, 114, 163, 142, 142, 79,
+       3, 162, 232, 174, 132, 248, 107, 100, 226, 44, 146, 248, 237, 234,
+       227, 8, 243, 202, 93, 152, 38, 203, 27, 1, 43, 123, 138, 162, 134,
+       174, 186, 223, 224, 184, 71, 139, 21, 81, 179, 44, 174, 118, 75,
+       239, 59, 163, 145, 54, 79, 130, 211, 31, 48, 218, 235, 149, 4,
+       191, 222, 56, 162, 74, 177, 100, 137, 105, 127, 55, 63, 116, 112,
+       139, 131, 192, 212, 121, 138, 7, 140, 90, 158, 67, 211, 222, 223,
+       242, 229, 179, 136, 102, 169, 46, 174, 233, 65, 196, 55, 206, 218,
+       83, 63, 253, 222, 65, 109, 221, 188, 93, 204, 51, 254, 155, 54,
+       249, 178, 15, 31, 197, 100, 215, 255, 86, 240, 77, 250, 81, 96,
+       174, 25, 231, 188, 111, 121, 49, 236, 159, 193, 216, 180, 55, 64,
+       254, 126, 211, 60, 175, 241, 236, 216, 37, 252, 94, 159, 209, 33,
+       111, 179, 225, 72, 205, 53, 207, 89, 91, 218, 241, 94, 89, 108,
+       212, 188, 93, 136, 51, 191, 153, 102, 255, 210, 29, 30, 199, 236,
+       211, 239, 242, 229, 86, 152, 236, 124, 57, 64, 91, 200, 175, 85,
+       160, 129, 79, 255, 55, 90, 227, 213, 253, 113, 14, 43, 27, 245,
+       219, 254, 65, 95, 213, 37, 102, 86, 114, 112, 107, 104, 124, 208,
+       83, 88, 235, 69, 247, 41, 91, 221, 126, 112, 178, 156, 253, 97,
+       142, 39, 178, 213, 83, 249, 1, 127, 103, 135, 118, 119, 76, 190,
+       222, 54, 242, 154, 54, 191, 186, 159, 85, 181, 109, 235, 171, 27,
+       151, 111, 165, 23, 118, 205, 142, 47, 106, 231, 125, 139, 174,
+       244, 171, 155, 96, 239, 88, 154, 252, 193, 118, 247, 87, 9, 184,
+       97, 32, 241, 106, 208, 89, 90, 134, 82, 118, 10, 72, 119, 110, 23,
+       181, 239, 54, 218, 248, 139, 163, 167, 33, 74, 217, 55, 203, 221,
+       22, 13, 249, 140, 81, 71, 60, 52, 220, 154, 23, 252, 186, 3, 120,
+       29, 123, 157, 174, 252, 145, 90, 246, 248, 218, 251, 66, 172, 115,
+       144, 186, 118, 165, 72, 210, 231, 45, 142, 182, 192, 110, 169,
+       159, 197, 206, 139, 134, 239, 50, 101, 170, 136, 47, 132, 41, 157,
+       10, 107, 66, 140, 91, 129, 172, 103, 141, 8, 248, 207, 172, 134,
+       162, 212, 110, 169, 207, 196, 69, 27, 70, 249, 180, 16, 138, 169,
+       27, 156, 171, 157, 107, 249, 167, 153, 21, 150, 97, 150, 119, 109,
+       70, 70, 176, 128, 50, 228, 64, 44, 59, 221, 203, 216, 117, 189,
+       13, 62, 154, 192, 26, 12, 112, 124, 105, 216, 164, 221, 21, 150,
+       193, 183, 87, 233, 86, 86, 242, 49, 182, 236, 81, 100, 55, 28,
+       187, 252, 113, 191, 111, 62, 181, 210, 154, 12, 208, 127, 173,
+       159, 117, 97, 254, 47, 87, 255, 95, 234, 56, 124, 30, 57, 145,
+       177, 167, 66, 86, 47, 245, 56, 105, 191, 238, 222, 37, 246, 126,
+       252, 210, 233, 34, 187, 106, 60, 100, 164, 251, 246, 240, 78, 124,
+       133, 32, 173, 54, 0, 205, 106, 3, 71, 214, 187, 174, 103, 126, 47,
+       177, 237, 85, 241, 118, 219, 27, 207, 96, 141, 114, 145, 190, 224,
+       13, 68, 92, 167, 109, 76, 183, 196, 118, 249, 147, 231, 196, 144,
+       44, 255, 54, 109, 10, 139, 55, 190, 41, 221, 3, 28, 75, 221, 118,
+       182, 184, 70, 60, 65, 90, 135, 49, 46, 183, 96, 238, 43, 19, 149,
+       167, 152, 53, 127, 30, 47, 186, 192, 157, 200, 121, 216, 217, 93,
+       122, 237, 98, 4, 127, 62, 117, 66, 118, 198, 49, 7, 177, 113, 102,
+       212, 61, 206, 233, 142, 55, 111, 118, 233, 242, 136, 47, 176, 96,
+       57, 193, 94, 123, 212, 98, 2, 109, 54, 112, 66, 118, 246, 61, 55,
+       177, 117, 38, 244, 54, 200, 225, 156, 53, 111, 118, 171, 114, 136,
+       47, 176, 33, 121, 2, 16, 189, 154, 111, 229, 152, 7, 159, 251, 17,
+       127, 188, 188, 116, 43, 143, 51, 55, 17, 179, 108, 90, 240, 205,
+       18, 90, 186, 156, 76, 149, 255, 66, 24, 179, 216, 111, 228, 176,
+       71, 155, 93, 176, 119, 172, 159, 100, 202, 239, 51, 255, 145, 19,
+       111, 146, 209, 151, 54, 26, 219, 154, 12, 39, 155, 232, 186, 26,
+       176, 172, 137, 96, 23, 119, 62, 214, 125, 135, 131, 210, 93, 205,
+       142, 110, 28, 218, 254, 195, 210, 204, 241, 182, 236, 142, 136,
+       250, 9, 54, 255, 34, 206, 188, 129, 71, 236, 207, 40, 24, 108,
+       231, 242, 237, 4, 219, 250, 5, 99, 202, 35, 10, 191, 184, 212,
+       175, 190, 20, 122, 215, 47, 32, 215, 89, 171, 252, 129, 118, 167,
+       66, 9, 120, 125, 38, 225, 104, 144, 194, 203, 134, 81, 86, 138,
+       194, 55, 46, 37, 36, 233, 20, 218, 218, 139, 22, 201, 2, 82, 19,
+       135, 239, 228, 167, 172, 186, 77, 107, 227, 231, 148, 189, 233,
+       71, 238, 73, 187, 24, 124, 184, 220, 37, 236, 121, 62, 99, 216,
+       39, 238, 201, 9, 236, 59, 238, 158, 91, 251, 120, 237, 129, 172,
+       215, 186, 95, 205, 246, 221, 135, 114, 239, 210, 46, 31, 165, 172,
+       221, 253, 218, 213, 77, 180, 39, 99, 149, 46, 111, 55, 121, 219,
+       43, 84, 218, 117, 88, 191, 149, 70, 88, 62, 185, 244, 185, 198,
+       237, 222, 85, 68, 202, 71, 195, 112, 118, 220, 142, 184, 159, 236,
+       151, 174, 187, 31, 146, 27, 214, 126, 12, 27, 253, 211, 125, 179,
+       58, 67, 154, 247, 249, 54, 207, 223, 129, 81, 151, 83, 114, 177,
+       235, 228, 116, 72, 241, 104, 171, 193, 113, 169, 119, 221, 124,
+       50, 186, 29, 119, 65, 2, 115, 146, 1, 25, 180, 171, 170, 69, 10,
+       87, 251, 26, 159, 42, 144, 215, 214, 189, 247, 189, 77, 94, 167,
+       28, 158, 54, 224, 238, 187, 147, 149, 212, 153, 48, 221, 123, 45,
+       174, 199, 31, 4, 189, 215, 3, 31, 115, 216, 246, 246, 187, 114,
+       157, 201, 90, 231, 188, 174, 183, 228, 230, 59, 151, 149, 177,
+       152, 52, 254, 14, 60, 186, 194, 159, 205, 37, 253, 193, 94, 215,
+       85, 98, 58, 173, 178, 248, 218, 114, 116, 29, 50, 165, 255, 39,
+       101, 124, 78, 225, 253, 165, 106, 4, 186, 122, 128, 76, 241, 99,
+       189, 66, 185, 181, 83, 170, 232, 165, 135, 170, 255, 58, 176, 188,
+       54, 196, 191, 131, 119, 232, 16, 51, 88, 227, 96, 13, 50, 126,
+       211, 192, 80, 135, 123, 2, 156, 149, 184, 232, 164, 185, 23, 158,
+       27, 80, 112, 156, 191, 96, 75, 199, 27, 51, 17, 179, 72, 18, 210,
+       205, 22, 254, 238, 152, 64, 161, 187, 179, 89, 99, 78, 214, 151,
+       239, 244, 69, 64, 116, 206, 113, 65, 181, 245, 124, 232, 18, 238,
+       249, 186, 52, 255, 55, 40, 128, 200, 127, 143, 240, 252, 162, 51,
+       144, 213, 201, 93, 84, 19, 153, 107, 37, 92, 174, 151, 68, 190,
+       132, 90, 202, 10, 227, 197, 208, 195, 7, 222, 84, 59, 138, 236,
+       202, 53, 84, 231, 26, 160, 114, 153, 54, 237, 102, 45, 153, 106,
+       15, 200, 234, 128, 51, 153, 198, 35, 70, 51, 136, 83, 186, 197,
+       37, 189, 117, 90, 141, 3, 88, 227, 18, 172, 91, 153, 14, 204, 198,
+       41, 25, 234, 15, 232, 232, 128, 55, 223, 142, 227, 78, 51, 12,
+       241, 176, 197, 37, 189, 113, 91, 137, 1, 221, 241, 152, 120, 169,
+       53, 86, 216, 243, 158, 164, 28, 78, 211, 235, 190, 149, 65, 236,
+       122, 111, 71, 186, 51, 186, 217, 69, 127, 250, 247, 170, 5, 148,
+       153, 62, 179, 182, 219, 146, 224, 204, 85, 147, 51, 215, 220, 58,
+       33, 234, 113, 125, 67, 252, 233, 63, 53, 233, 195, 235, 215, 52,
+       11, 157, 67, 98, 177, 155, 246, 108, 77, 177, 104, 138, 129, 81,
+       136, 247, 255, 108, 2, 158, 255, 115, 65, 80, 107, 154, 0, 221,
+       182, 95, 58, 132, 106, 23, 186, 35, 48, 105, 229, 84, 207, 251,
+       88, 0, 232, 249, 203, 177, 157, 80, 32, 94, 185, 87, 163, 201,
+       186, 208, 28, 69, 140, 169, 176, 109, 138, 86, 243, 3, 158, 151,
+       184, 240, 164, 184, 151, 190, 27, 80, 112, 156, 179, 224, 73, 199,
+       27, 55, 145, 50, 216, 130, 195, 77, 182, 254, 206, 136, 64, 161,
+       169, 9, 26, 147, 221, 44, 173, 176, 87, 172, 11, 50, 92, 190, 176,
+       228, 202, 199, 51, 238, 4, 149, 41, 146, 192, 132, 191, 114, 26,
+       136, 136, 9, 153, 24, 94, 98, 79, 3, 39, 239, 244, 37, 6, 254,
+       134, 233, 79, 63, 100, 126, 249, 131, 238, 200, 180, 61, 255, 119,
+       239, 194, 4, 127, 243, 32, 184, 186, 206, 103, 219, 70, 23, 239,
+       244, 20, 6, 118, 134, 233, 78, 180, 101, 125, 241, 3, 238, 232,
+       188, 125, 255, 101, 202, 223, 0, 117, 186, 229, 252, 49, 171, 232,
+       104, 254, 17, 221, 207, 82, 172, 252, 175, 3, 168, 215, 16, 223,
+       141, 70, 149, 206, 58, 231, 26, 126, 205, 189, 173, 245, 248, 126,
+       207, 233, 254, 165, 77, 45, 31, 79, 178, 83, 234, 188, 76, 155,
+       37, 208, 183, 77, 228, 124, 110, 233, 116, 241, 171, 231, 255,
+       229, 180, 90, 252, 82, 121, 252, 107, 197, 65, 173, 123, 70, 138,
+       83, 178, 176, 234, 11, 1, 213, 191, 73, 212, 236, 250, 121, 98,
+       197, 146, 186, 218, 197, 125, 247, 253, 94, 36, 68, 18, 150, 189,
+       168, 98, 36, 18, 172, 155, 91, 96, 196, 115, 137, 74, 195, 118,
+       238, 34, 16, 193, 195, 64, 132, 166, 115, 135, 128, 115, 173, 3,
+       40, 191, 227, 229, 246, 195, 175, 242, 134, 207, 90, 227, 177,
+       253, 172, 32, 127, 123, 23, 226, 67, 144, 32, 47, 101, 134, 175,
+       128, 5, 250, 245, 251, 195, 124, 158, 184, 189, 175, 144, 14, 159,
+       151, 144, 29, 182, 158, 39, 9, 131, 99, 125, 17, 38, 111, 18, 247,
+       129, 150, 90, 122, 144, 89, 129, 75, 65, 177, 149, 49, 169, 125,
+       180, 31, 238, 251, 58, 124, 158, 52, 64, 175, 133, 87, 120, 17,
+       177, 105, 243, 64, 141, 18, 125, 126, 200, 64, 137, 63, 115, 164,
+       197, 45, 186, 75, 74, 31, 151, 227, 219, 253, 195, 229, 218, 214,
+       87, 236, 125, 44, 189, 206, 207, 154, 184, 118, 37, 156, 175, 172,
+       152, 85, 119, 181, 197, 172, 250, 2, 14, 175, 19, 224, 187, 239,
+       83, 230, 206, 82, 95, 239, 124, 180, 29, 75, 223, 14, 56, 166,
+       173, 188, 237, 238, 130, 93, 37, 247, 211, 34, 250, 15, 63, 252,
+       130, 208, 184, 237, 85, 228, 235, 2, 23, 91, 78, 119, 195, 99,
+       158, 61, 56, 196, 45, 252, 108, 250, 161, 241, 248, 132, 228, 68,
+       75, 90, 91, 248, 65, 246, 164, 159, 75, 36, 94, 183, 43, 196, 224,
+       46, 236, 127, 181, 142, 91, 203, 65, 53, 103, 173, 78, 212, 88,
+       94, 115, 239, 86, 59, 51, 112, 77, 134, 110, 206, 111, 105, 165,
+       224, 54, 253, 131, 98, 128, 177, 53, 172, 55, 237, 0, 3, 103, 251,
+       69, 45, 215, 121, 223, 241, 243, 192, 63, 196, 170, 240, 6, 36,
+       28, 151, 65, 122, 162, 127, 121, 208, 81, 217, 178, 96, 255, 137,
+       207, 226, 168, 49, 163, 186, 221, 28, 183, 125, 21, 110, 99, 146,
+       248, 66, 106, 20, 30, 179, 33, 123, 224, 100, 56, 76, 161, 245,
+       176, 42, 197, 174, 82, 0, 202, 113, 83, 114, 70, 14, 175, 159, 45,
+       106, 180, 35, 204, 143, 155, 163, 236, 124, 180, 74, 195, 119,
+       253, 1, 68, 225, 195, 192, 128, 54, 254, 155, 132, 110, 53, 7,
+       128, 245, 157, 183, 202, 229, 53, 245, 190, 186, 3, 87, 244, 247,
+       72, 11, 37, 123, 106, 138, 98, 220, 218, 99, 237, 130, 126, 40, 0,
+       82, 167, 171, 0, 13, 107, 252, 116, 181, 250, 114, 157, 72, 90,
+       227, 189, 191, 177, 96, 110, 59, 23, 205, 144, 184, 32, 255, 111,
+       124, 186, 200, 20, 136, 49, 235, 1, 135, 150, 177, 244, 138, 172,
+       167, 126, 19, 74, 80, 189, 163, 192, 202, 35, 42, 34, 24, 114,
+       216, 1, 103, 172, 150, 126, 64, 128, 192, 129, 136, 112, 163, 212,
+       164, 14, 10, 64, 169, 3, 49, 171, 235, 71, 43, 72, 210, 250, 197,
+       108, 96, 94, 107, 203, 149, 152, 224, 197, 119, 97, 10, 200, 2,
+       57, 233, 99, 78, 85, 213, 75, 212, 67, 64, 253, 10, 51, 221, 53,
+       52, 120, 232, 19, 202, 139, 179, 188, 189, 115, 205, 129, 41, 115,
+       158, 118, 232, 159, 227, 36, 187, 188, 211, 158, 233, 206, 89,
+       147, 231, 255, 108, 186, 129, 254, 67, 223, 247, 223, 161, 79,
+       253, 232, 83, 239, 213, 92, 143, 185, 85, 42, 35, 99, 136, 94,
+       195, 169, 106, 94, 228, 80, 143, 48, 140, 246, 0, 122, 169, 19,
+       173, 131, 58, 38, 221, 84, 12, 187, 172, 85, 12, 118, 252, 86, 57,
+       223, 241, 178, 194, 55, 194, 185, 251, 86, 162, 29, 183, 225, 123,
+       99, 127, 189, 211, 49, 217, 160, 232, 250, 163, 255, 195, 164,
+       113, 165, 99, 71, 18, 164, 153, 173, 182, 185, 6, 205, 87, 159,
+       162, 204, 124, 158, 238, 197, 23, 248, 17, 133, 161, 103, 192,
+       133, 118, 218, 215, 134, 94, 189, 101, 12, 125, 153, 225, 178,
+       239, 55, 158, 22, 161, 10, 32, 213, 243, 65, 72, 87, 127, 42, 88,
+       18, 208, 121, 58, 237, 133, 47, 52, 144, 115, 133, 171, 5, 148,
+       181, 81, 172, 63, 229, 155, 126, 251, 22, 92, 214, 116, 223, 47,
+       135, 70, 126, 61, 181, 244, 117, 128, 77, 26, 117, 230, 202, 249,
+       209, 245, 73, 144, 149, 145, 173, 61, 165, 159, 206, 251, 30, 92,
+       156, 48, 202, 47, 133, 70, 126, 29, 151, 104, 251, 80, 141, 30,
+       125, 246, 138, 124, 145, 117, 65, 249, 157, 155, 141, 205, 132,
+       143, 202, 123, 128, 92, 182, 180, 64, 174, 129, 87, 120, 17, 23,
+       105, 251, 49, 141, 22, 93, 126, 152, 88, 129, 126, 1, 137, 132,
+       145, 212, 139, 164, 167, 126, 49, 74, 16, 133, 34, 64, 194, 99,
+       14, 42, 28, 114, 248, 85, 32, 44, 166, 86, 68, 128, 200, 201, 136,
+       35, 167, 106, 28, 215, 177, 176, 111, 90, 69, 92, 179, 40, 168,
+       246, 32, 187, 43, 178, 21, 150, 58, 134, 255, 62, 15, 158, 235,
+       85, 76, 251, 206, 36, 185, 147, 106, 221, 197, 214, 204, 199, 5,
+       232, 13, 34, 249, 101, 20, 216, 250, 2, 82, 90, 43, 154, 177, 123,
+       220, 5, 122, 219, 27, 242, 154, 131, 176, 21, 184, 123, 197, 185,
+       67, 191, 81, 80, 144, 188, 22, 0, 125, 167, 49, 91, 149, 51, 78,
+       114, 213, 149, 18, 90, 234, 152, 4, 35, 249, 60, 239, 99, 169,
+       214, 195, 223, 234, 22, 76, 88, 163, 55, 205, 123, 0, 123, 200,
+       23, 245, 90, 186, 46, 159, 249, 68, 173, 237, 247, 174, 244, 227,
+       43, 254, 98, 138, 95, 209, 186, 104, 143, 72, 216, 239, 104, 220,
+       63, 132, 222, 185, 151, 225, 206, 39, 30, 221, 18, 92, 139, 186,
+       31, 14, 57, 223, 31, 159, 70, 172, 55, 166, 234, 115, 37, 72, 219,
+       231, 109, 111, 178, 192, 126, 163, 151, 181, 189, 153, 5, 221,
+       184, 110, 170, 192, 47, 134, 48, 81, 155, 159, 71, 164, 242, 146,
+       110, 113, 165, 140, 250, 231, 109, 230, 160, 209, 118, 239, 206,
+       231, 229, 139, 4, 109, 176, 225, 175, 136, 45, 166, 43, 157, 94,
+       122, 235, 180, 182, 130, 59, 240, 186, 188, 22, 231, 77, 236, 243,
+       75, 55, 253, 189, 243, 224, 221, 172, 232, 248, 67, 239, 197, 164,
+       183, 53, 97, 220, 30, 255, 252, 162, 114, 55, 66, 252, 78, 94,
+       178, 29, 183, 163, 122, 103, 247, 174, 66, 48, 157, 36, 106, 210,
+       167, 98, 131, 181, 241, 37, 99, 86, 225, 147, 193, 137, 64, 46,
+       141, 42, 185, 139, 0, 156, 179, 72, 82, 160, 87, 125, 208, 18, 9,
+       139, 64, 185, 180, 175, 215, 128, 2, 161, 35, 14, 153, 164, 219,
+       197, 246, 244, 151, 199, 31, 78, 38, 200, 57, 22, 206, 225, 98,
+       187, 153, 146, 216, 123, 240, 79, 95, 222, 71, 155, 84, 253, 142,
+       54, 143, 94, 218, 149, 243, 222, 229, 95, 39, 113, 18, 104, 105,
+       61, 137, 153, 115, 129, 19, 126, 249, 24, 254, 59, 150, 221, 67,
+       213, 91, 252, 14, 25, 153, 25, 237, 26, 7, 75, 184, 6, 168, 216,
+       66, 215, 23, 33, 96, 94, 153, 30, 232, 73, 26, 81, 29, 205, 140,
+       35, 20, 56, 170, 1, 33, 189, 177, 57, 161, 36, 79, 125, 121, 108,
+       252, 53, 60, 151, 21, 202, 49, 183, 12, 92, 62, 249, 52, 249, 22,
+       206, 201, 37, 244, 108, 138, 195, 241, 43, 233, 99, 72, 85, 149,
+       239, 245, 67, 72, 124, 6, 57, 200, 182, 164, 120, 232, 19, 220,
+       207, 186, 52, 191, 38, 77, 164, 168, 127, 158, 242, 252, 138, 184,
+       186, 154, 127, 241, 184, 71, 158, 95, 85, 179, 172, 156, 118, 8,
+       175, 59, 219, 149, 182, 111, 162, 243, 95, 21, 26, 235, 215, 12,
+       189, 223, 215, 123, 106, 22, 34, 146, 174, 244, 240, 192, 214,
+       230, 233, 202, 151, 229, 54, 237, 252, 239, 205, 215, 172, 236,
+       176, 97, 175, 128, 47, 183, 187, 29, 88, 220, 127, 116, 34, 250,
+       55, 226, 252, 70, 126, 162, 63, 191, 162, 113, 34, 245, 236, 66,
+       96, 173, 36, 111, 210, 231, 112, 131, 103, 241, 37, 107, 86, 161,
+       163, 160, 145, 68, 90, 3, 43, 169, 138, 137, 143, 190, 65, 82,
+       176, 215, 253, 145, 26, 9, 129, 192, 185, 213, 143, 191, 128, 38,
+       167, 106, 97, 129, 61, 107, 140, 95, 68, 57, 68, 97, 169, 88, 210,
+       93, 24, 48, 152, 144, 122, 56, 217, 34, 123, 21, 79, 159, 81, 124,
+       80, 10, 196, 48, 202, 159, 100, 156, 107, 146, 156, 231, 207, 52,
+       244, 167, 40, 42, 182, 199, 238, 183, 238, 193, 236, 107, 103,
+       253, 54, 112, 202, 139, 95, 164, 44, 94, 92, 211, 38, 174, 63,
+       129, 95, 252, 133, 28, 215, 175, 111, 199, 170, 69, 118, 243, 175,
+       227, 90, 3, 10, 189, 240, 225, 239, 217, 54, 159, 180, 115, 208,
+       121, 255, 116, 162, 200, 54, 103, 185, 138, 178, 42, 46, 223, 225,
+       179, 162, 245, 236, 66, 112, 237, 130, 106, 187, 227, 118, 139,
+       101, 48, 167, 43, 65, 127, 158, 54, 37, 140, 116, 55, 232, 138,
+       42, 77, 190, 177, 3, 19, 160, 38, 104, 12, 196, 249, 144, 40, 225,
+       185, 84, 0, 72, 80, 203, 10, 90, 33, 162, 164, 177, 84, 90, 71,
+       43, 237, 139, 141, 175, 190, 66, 80, 182, 143, 253, 149, 30, 25,
+       177, 192, 249, 245, 142, 239, 160, 6, 167, 94, 87, 153, 128, 128,
+       153, 212, 184, 133, 175, 73, 138, 33, 140, 190, 86, 228, 160, 135,
+       253, 213, 151, 9, 167, 193, 185, 116, 142, 251, 152, 22, 173, 86,
+       23, 79, 66, 143, 86, 146, 234, 224, 117, 4, 123, 130, 105, 72,
+       191, 196, 122, 232, 6, 239, 204, 176, 12, 255, 54, 44, 162, 129,
+       119, 175, 120, 140, 89, 81, 83, 237, 114, 70, 99, 60, 32, 192,
+       238, 100, 95, 23, 129, 244, 118, 220, 20, 234, 73, 146, 177, 76,
+       245, 237, 34, 4, 42, 162, 98, 41, 2, 176, 186, 208, 47, 241, 185,
+       71, 206, 29, 148, 51, 172, 159, 118, 11, 235, 51, 251, 145, 18,
+       109, 178, 193, 87, 25, 154, 235, 213, 12, 53, 235, 65, 144, 62,
+       217, 29, 140, 161, 3, 254, 49, 198, 18, 148, 147, 96, 102, 225,
+       61, 122, 152, 179, 61, 179, 208, 221, 188, 154, 76, 152, 8, 49,
+       40, 244, 228, 238, 210, 142, 50, 199, 254, 80, 183, 159, 186, 83,
+       109, 253, 43, 123, 214, 95, 251, 248, 103, 45, 46, 123, 15, 245,
+       220, 229, 251, 244, 97, 246, 152, 240, 250, 79, 181, 152, 192,
+       159, 27, 148, 31, 12, 254, 46, 141, 205, 211, 255, 145, 54, 71,
+       218, 247, 155, 87, 218, 251, 159, 13, 189, 151, 3, 203, 18, 154,
+       246, 145, 174, 231, 143, 29, 92, 231, 172, 138, 182, 196, 239, 43,
+       18, 221, 214, 26, 14, 245, 62, 28, 158, 235, 22, 150, 169, 141,
+       219, 20, 71, 134, 71, 54, 108, 113, 61, 66, 203, 199, 77, 234, 63,
+       213, 118, 165, 187, 175, 165, 151, 29, 207, 146, 126, 203, 134,
+       47, 230, 57, 212, 244, 165, 245, 65, 187, 107, 83, 137, 170, 189,
+       33, 56, 86, 119, 200, 19, 177, 20, 77, 58, 50, 113, 169, 20, 201,
+       216, 37, 118, 192, 106, 71, 99, 165, 124, 168, 254, 213, 164, 79,
+       183, 17, 203, 92, 30, 178, 125, 18, 41, 221, 122, 21, 15, 185,
+       254, 250, 170, 231, 255, 244, 8, 136, 249, 208, 243, 65, 233, 20,
+       157, 108, 137, 168, 34, 238, 144, 74, 64, 189, 194, 209, 194, 66,
+       43, 106, 204, 66, 8, 199, 125, 12, 180, 202, 40, 20, 128, 33, 136,
+       49, 201, 3, 175, 20, 134, 135, 236, 20, 128, 233, 64, 243, 208,
+       40, 224, 92, 124, 0, 107, 73, 187, 40, 63, 169, 166, 47, 16, 81,
+       58, 160, 168, 2, 48, 187, 209, 45, 196, 185, 66, 142, 21, 150, 19,
+       188, 159, 116, 10, 232, 49, 251, 145, 2, 105, 178, 192, 85, 24,
+       154, 75, 192, 8, 117, 186, 98, 157, 110, 156, 251, 217, 188, 231,
+       137, 87, 158, 187, 108, 254, 46, 19, 167, 179, 251, 1, 116, 11,
+       50, 229, 59, 48, 78, 219, 4, 12, 173, 87, 242, 157, 126, 220, 125,
+       248, 180, 239, 169, 92, 190, 171, 44, 252, 46, 83, 227, 243, 255,
+       33, 102, 75, 162, 237, 51, 113, 202, 155, 21, 108, 127, 95, 242,
+       13, 126, 92, 235, 84, 124, 103, 169, 214, 246, 27, 45, 174, 54,
+       219, 162, 231, 253, 38, 244, 75, 162, 224, 19, 251, 94, 139, 69,
+       100, 239, 79, 97, 157, 90, 74, 240, 150, 86, 247, 236, 9, 237, 68,
+       112, 50, 166, 112, 248, 242, 22, 234, 215, 59, 56, 127, 63, 173,
+       38, 66, 24, 2, 234, 45, 41, 17, 106, 233, 244, 231, 249, 115, 68,
+       68, 124, 38, 49, 253, 182, 96, 220, 58, 147, 120, 145, 186, 114,
+       157, 111, 233, 162, 64, 95, 138, 244, 250, 26, 246, 80, 161, 242,
+       25, 56, 255, 43, 53, 52, 255, 15, 2, 202, 149, 55, 27, 133, 48,
+       246, 124, 141, 213, 190, 193, 61, 231, 46, 132, 139, 157, 28, 43,
+       250, 97, 242, 235, 51, 65, 234, 189, 63, 187, 31, 149, 227, 123,
+       35, 125, 132, 50, 16, 241, 168, 64, 222, 129, 33, 231, 231, 235,
+       15, 195, 157, 113, 115, 69, 99, 78, 99, 112, 97, 232, 102, 104,
+       31, 23, 129, 180, 50, 220, 84, 234, 201, 146, 177, 78, 247, 252,
+       33, 6, 106, 179, 102, 177, 34, 25, 42, 156, 217, 197, 149, 103,
+       150, 204, 200, 9, 32, 222, 38, 64, 200, 59, 131, 129, 94, 139,
+       114, 31, 121, 21, 138, 251, 17, 8, 188, 219, 173, 85, 27, 234,
+       149, 228, 95, 212, 128, 204, 189, 20, 26, 159, 114, 80, 204, 250,
+       159, 254, 105, 7, 120, 174, 251, 221, 166, 120, 154, 219, 248,
+       210, 39, 252, 175, 54, 213, 102, 127, 254, 115, 215, 76, 21, 113,
+       253, 59, 57, 153, 238, 19, 159, 251, 255, 62, 47, 107, 111, 213,
+       4, 139, 247, 246, 250, 34, 75, 110, 154, 254, 209, 189, 199, 222,
+       21, 80, 163, 32, 140, 54, 73, 234, 59, 131, 209, 86, 59, 38, 245,
+       119, 48, 158, 203, 149, 28, 245, 206, 167, 222, 74, 154, 215, 145,
+       254, 196, 223, 5, 116, 183, 40, 200, 191, 204, 251, 235, 130, 213,
+       182, 190, 14, 247, 62, 61, 150, 203, 223, 29, 248, 142, 66, 181,
+       62, 150, 219, 229, 184, 103, 173, 149, 155, 27, 44, 254, 102, 3,
+       239, 179, 251, 145, 22, 75, 18, 239, 63, 16, 26, 219, 133, 64,
+       173, 95, 2, 139, 78, 153, 214, 217, 168, 71, 175, 85, 90, 131,
+       164, 174, 182, 64, 99, 43, 2, 149, 22, 152, 38, 245, 46, 52, 154,
+       195, 180, 140, 189, 204, 192, 104, 159, 84, 69, 204, 100, 7, 184,
+       192, 102, 8, 182, 149, 65, 123, 160, 116, 112, 88, 97, 252, 178,
+       8, 247, 169, 84, 0, 8, 24, 67, 42, 34, 56, 159, 217, 45, 205, 177,
+       67, 142, 17, 228, 16, 180, 157, 100, 10, 200, 48, 123, 16, 3, 109,
+       82, 208, 69, 25, 90, 27, 80, 8, 117, 186, 33, 143, 123, 14, 244,
+       142, 239, 55, 124, 77, 122, 68, 114, 40, 182, 112, 152, 42, 6, 45,
+       246, 186, 37, 111, 116, 46, 36, 64, 73, 130, 242, 73, 41, 137,
+       123, 252, 245, 245, 89, 115, 87, 69, 108, 1, 59, 253, 50, 48, 218,
+       58, 147, 12, 154, 186, 114, 157, 111, 249, 0, 73, 119, 142, 126,
+       234, 173, 101, 107, 110, 212, 114, 239, 88, 80, 162, 237, 138, 83,
+       205, 123, 233, 122, 236, 19, 254, 104, 178, 252, 42, 119, 233,
+       133, 45, 247, 251, 120, 224, 205, 81, 236, 71, 198, 22, 237, 144,
+       100, 242, 86, 150, 249, 63, 219, 107, 38, 68, 51, 239, 193, 212,
+       189, 224, 71, 107, 239, 132, 47, 243, 89, 240, 84, 62, 250, 112,
+       114, 226, 51, 66, 177, 132, 94, 171, 15, 207, 227, 24, 38, 253,
+       237, 211, 4, 211, 132, 106, 208, 133, 41, 203, 229, 225, 47, 75,
+       100, 167, 241, 67, 213, 111, 67, 217, 83, 37, 45, 24, 82, 241,
+       204, 52, 25, 206, 66, 56, 18, 50, 232, 18, 127, 156, 5, 126, 243,
+       203, 214, 227, 173, 99, 82, 69, 116, 30, 238, 112, 113, 232, 118,
+       76, 219, 64, 149, 180, 60, 108, 6, 110, 237, 180, 37, 14, 38, 217,
+       37, 4, 75, 191, 90, 181, 126, 245, 100, 226, 221, 215, 94, 232,
+       129, 112, 141, 15, 125, 127, 59, 131, 125, 211, 219, 255, 105, 3,
+       24, 189, 243, 201, 143, 61, 63, 127, 182, 210, 191, 189, 232, 119,
+       151, 111, 95, 248, 51, 230, 76, 31, 91, 109, 31, 16, 61, 202, 17,
+       239, 252, 208, 56, 47, 251, 79, 205, 85, 229, 247, 214, 242, 47,
+       78, 67, 200, 85, 183, 202, 219, 87, 200, 216, 198, 40, 202, 245,
+       228, 125, 184, 146, 188, 139, 183, 60, 222, 59, 28, 143, 238, 159,
+       190, 120, 164, 28, 124, 254, 35, 63, 251, 146, 198, 235, 244, 188,
+       45, 175, 220, 71, 178, 134, 113, 204, 83, 142, 233, 182, 168, 171,
+       221, 5, 51, 196, 127, 79, 223, 45, 177, 209, 65, 213, 95, 226,
+       217, 91, 185, 121, 72, 10, 209, 220, 188, 25, 12, 2, 24, 19, 114,
+       248, 144, 15, 28, 5, 110, 195, 175, 210, 164, 173, 97, 97, 65,
+       117, 31, 98, 120, 105, 232, 63, 76, 74, 88, 221, 180, 184, 140,
+       86, 110, 197, 180, 53, 142, 55, 92, 1, 54, 107, 191, 90, 180, 54,
+       79, 66, 134, 86, 19, 198, 224, 69, 164, 218, 175, 99, 8, 183, 132,
+       120, 236, 131, 231, 76, 179, 77, 172, 50, 4, 141, 19, 111, 191,
+       124, 204, 82, 93, 43, 136, 213, 196, 188, 103, 141, 77, 218, 71,
+       44, 190, 38, 64, 236, 179, 159, 213, 156, 171, 48, 226, 187, 52,
+       142, 202, 145, 28, 180, 95, 60, 141, 104, 233, 159, 203, 67, 234,
+       71, 164, 188, 138, 131, 8, 3, 4, 88, 252, 142, 240, 24, 184, 101,
+       156, 169, 197, 129, 85, 245, 11, 84, 98, 32, 168, 31, 221, 77,
+       205, 176, 71, 138, 21, 160, 1, 188, 159, 96, 11, 168, 59, 251, 0,
+       2, 107, 146, 81, 71, 17, 82, 59, 80, 8, 7, 234, 214, 45, 188, 179,
+       189, 255, 152, 134, 142, 189, 154, 11, 143, 44, 87, 11, 167, 119,
+       205, 81, 62, 97, 89, 184, 251, 209, 15, 119, 192, 125, 15, 87,
+       150, 57, 60, 178, 191, 191, 146, 130, 207, 244, 146, 61, 142, 92,
+       71, 139, 135, 115, 205, 115, 190, 105, 91, 188, 139, 211, 79, 119,
+       196, 125, 31, 87, 157, 121, 190, 103, 22, 95, 211, 208, 228, 232,
+       182, 12, 215, 88, 19, 35, 168, 229, 76, 115, 237, 225, 56, 44,
+       241, 201, 37, 17, 105, 59, 75, 11, 49, 79, 43, 39, 52, 14, 239,
+       116, 112, 204, 122, 79, 243, 97, 177, 0, 56, 110, 4, 111, 192,
+       184, 164, 46, 224, 173, 38, 0, 109, 186, 211, 233, 56, 205, 120,
+       122, 221, 219, 95, 229, 85, 4, 228, 10, 123, 115, 51, 48, 120,
+       242, 83, 234, 106, 171, 120, 63, 243, 207, 133, 57, 115, 154, 230,
+       170, 188, 77, 98, 110, 77, 93, 71, 232, 197, 134, 173, 10, 107,
+       217, 57, 178, 120, 224, 83, 234, 72, 39, 90, 187, 243, 237, 129,
+       57, 115, 127, 118, 162, 173, 67, 104, 5, 116, 27, 238, 56, 84,
+       236, 119, 238, 211, 72, 159, 161, 92, 204, 134, 111, 237, 180,
+       101, 30, 38, 73, 161, 180, 111, 191, 88, 212, 48, 173, 83, 172,
+       93, 233, 194, 226, 3, 160, 248, 11, 34, 202, 101, 16, 248, 235,
+       66, 195, 74, 59, 208, 255, 181, 132, 129, 59, 113, 43, 114, 138,
+       59, 141, 106, 232, 214, 167, 123, 247, 69, 1, 78, 130, 59, 63, 54,
+       100, 126, 186, 19, 217, 154, 152, 36, 191, 235, 237, 138, 64, 55,
+       138, 248, 170, 34, 168, 55, 184, 75, 201, 176, 71, 139, 21, 96,
+       57, 172, 159, 98, 27, 170, 187, 227, 1, 6, 123, 130, 209, 87, 81,
+       90, 107, 80, 12, 7, 202, 221, 144, 60, 178, 141, 223, 208, 232,
+       223, 254, 183, 59, 207, 88, 78, 171, 169, 197, 252, 115, 124, 101,
+       11, 148, 155, 219, 73, 247, 82, 45, 93, 71, 2, 175, 183, 157, 122,
+       162, 184, 103, 30, 137, 90, 243, 36, 186, 36, 64, 215, 63, 51,
+       145, 50, 219, 3, 95, 8, 38, 250, 202, 149, 64, 161, 171, 90, 168,
+       176, 250, 9, 221, 24, 198, 191, 23, 164, 25, 174, 154, 68, 188,
+       161, 187, 251, 145, 6, 79, 210, 243, 223, 215, 26, 123, 146, 4,
+       15, 46, 160, 232, 43, 90, 93, 197, 199, 206, 214, 20, 172, 8, 50,
+       209, 116, 52, 201, 232, 50, 74, 74, 47, 250, 51, 115, 156, 133,
+       57, 83, 24, 246, 234, 160, 137, 126, 94, 93, 199, 199, 241, 212,
+       4, 228, 2, 114, 245, 53, 33, 72, 242, 2, 202, 121, 171, 58, 63,
+       107, 139, 192, 9, 81, 43, 116, 186, 102, 255, 186, 184, 252, 165,
+       159, 207, 139, 159, 184, 47, 60, 254, 103, 2, 143, 115, 87, 81,
+       194, 11, 138, 243, 121, 28, 15, 190, 152, 120, 167, 219, 110, 221,
+       116, 248, 189, 213, 158, 191, 139, 216, 156, 43, 124, 221, 253,
+       33, 151, 115, 213, 119, 210, 43, 10, 255, 251, 91, 143, 255, 215,
+       246, 183, 59, 223, 221, 121, 254, 164, 148, 223, 189, 219, 90, 28,
+       169, 125, 253, 191, 160, 151, 115, 181, 239, 239, 8, 62, 255, 227,
+       253, 237, 222, 22, 246, 209, 123, 143, 205, 121, 127, 182, 148,
+       127, 180, 121, 66, 92, 178, 249, 127, 159, 100, 55, 123, 53, 206,
+       227, 156, 174, 255, 102, 255, 172, 128, 47, 246, 193, 121, 141,
+       223, 109, 115, 166, 58, 127, 190, 116, 242, 23, 246, 217, 39, 147,
+       105, 23, 110, 21, 238, 241, 216, 109, 62, 110, 235, 255, 132, 188,
+       241, 145, 113, 39, 227, 96, 65, 125, 31, 202, 184, 79, 232, 189,
+       206, 75, 8, 223, 180, 220, 140, 214, 111, 205, 50, 77, 158, 38,
+       92, 129, 246, 95, 175, 90, 148, 224, 205, 3, 26, 217, 195, 162,
+       231, 94, 33, 201, 24, 96, 224, 40, 80, 89, 2, 74, 16, 98, 159, 73,
+       63, 60, 6, 22, 123, 16, 10, 167, 142, 35, 112, 240, 237, 119, 31,
+       248, 90, 95, 249, 112, 171, 25, 157, 180, 45, 223, 189, 23, 53,
+       132, 250, 112, 156, 87, 91, 81, 166, 119, 172, 82, 223, 48, 45,
+       114, 204, 87, 235, 206, 99, 89, 128, 248, 10, 43, 233, 53, 17,
+       122, 170, 7, 225, 40, 186, 80, 191, 51, 252, 129, 9, 119, 235,
+       114, 138, 50, 102, 202, 99, 19, 107, 129, 77, 54, 164, 236, 139,
+       99, 225, 79, 20, 121, 172, 199, 176, 10, 178, 197, 24, 245, 197,
+       141, 49, 227, 126, 86, 170, 118, 106, 138, 182, 203, 147, 22, 205,
+       146, 175, 137, 139, 100, 234, 75, 10, 217, 237, 237, 147, 78, 71,
+       202, 170, 218, 7, 253, 191, 128, 126, 174, 139, 132, 235, 151,
+       181, 160, 78, 165, 151, 62, 26, 66, 112, 151, 135, 96, 75, 161,
+       125, 47, 73, 115, 220, 131, 33, 205, 162, 127, 68, 0, 48, 133,
+       161, 222, 208, 60, 186, 45, 93, 148, 169, 207, 127, 147, 57, 206,
+       216, 94, 139, 137, 21, 253, 35, 110, 101, 219, 209, 155, 211, 95,
+       127, 16, 44, 157, 87, 233, 173, 49, 90, 157, 237, 71, 175, 83, 85,
+       168, 24, 178, 81, 68, 181, 201, 138, 80, 24, 59, 42, 123, 183, 45,
+       220, 20, 122, 210, 72, 214, 110, 215, 20, 120, 130, 132, 124, 255,
+       194, 121, 70, 189, 22, 142, 62, 31, 47, 235, 131, 31, 163, 189,
+       38, 112, 226, 179, 144, 138, 19, 245, 123, 101, 118, 47, 161, 96,
+       139, 221, 145, 138, 201, 78, 249, 157, 207, 136, 200, 254, 164,
+       217, 136, 146, 247, 158, 98, 206, 213, 46, 29, 143, 253, 223, 15,
+       250, 132, 180, 233, 18, 170, 29, 133, 134, 232, 149, 160, 224, 10,
+       38, 192, 33, 149, 248, 232, 74, 114, 110, 43, 90, 61, 185, 144, 7,
+       59, 89, 27, 34, 142, 211, 107, 106, 142, 127, 145, 186, 96, 137,
+       204, 148, 163, 44, 206, 183, 166, 238, 241, 223, 231, 196, 15,
+       142, 253, 58, 88, 139, 187, 23, 47, 41, 223, 196, 145, 28, 181,
+       168, 106, 53, 169, 182, 63, 131, 49, 215, 119, 10, 75, 131, 87,
+       109, 35, 48, 197, 91, 21, 217, 163, 123, 85, 144, 97, 165, 19, 4,
+       252, 58, 186, 236, 237, 189, 199, 174, 87, 24, 149, 156, 142, 123,
+       106, 167, 3, 27, 151, 86, 4, 178, 241, 101, 17, 126, 232, 148, 89,
+       165, 251, 255, 223, 117, 230, 174, 58, 223, 184, 201, 98, 61, 254,
+       223, 93, 157, 183, 135, 213, 29, 111, 225, 36, 44, 254, 162, 249,
+       143, 246, 111, 247, 209, 117, 47, 163, 100, 139, 221, 145, 178,
+       205, 87, 85, 221, 215, 200, 200, 126, 132, 217, 11, 146, 181, 214,
+       34, 95, 213, 46, 93, 143, 111, 223, 14, 248, 198, 182, 199, 109,
+       138, 94, 83, 143, 232, 23, 228, 213, 163, 65, 76, 191, 101, 126,
+       204, 151, 231, 236, 23, 109, 158, 114, 0, 171, 189, 55, 191, 116,
+       245, 38, 132, 71, 219, 214, 139, 238, 236, 29, 2, 113, 2, 232,
+       234, 60, 77, 123, 235, 19, 171, 114, 180, 78, 255, 44, 62, 158,
+       64, 53, 88, 112, 140, 43, 176, 117, 205, 127, 55, 184, 90, 79, 89,
+       116, 227, 9, 29, 183, 45, 222, 25, 183, 253, 130, 250, 99, 221,
+       78, 90, 219, 198, 119, 141, 113, 253, 111, 93, 242, 206, 239, 84,
+       159, 220, 201, 74, 189, 174, 92, 247, 239, 182, 87, 211, 247, 106,
+       193, 35, 190, 226, 119, 61, 111, 190, 119, 255, 167, 245, 188, 13,
+       102, 236, 221, 243, 198, 98, 85, 128, 248, 2, 107, 105, 49, 1,
+       120, 234, 7, 227, 40, 171, 80, 189, 243, 201, 129, 25, 119, 43,
+       114, 138, 185, 13, 110, 77, 215, 242, 251, 83, 85, 68, 124, 2, 57,
+       41, 183, 32, 122, 170, 23, 237, 188, 184, 116, 174, 103, 109, 162,
+       1, 247, 233, 116, 224, 40, 140, 59, 251, 213, 247, 99, 103, 86, 5,
+       108, 18, 49, 185, 48, 240, 121, 186, 2, 153, 26, 184, 48, 63, 111,
+       71, 144, 65, 177, 8, 244, 234, 66, 184, 187, 186, 217, 200, 48,
+       71, 171, 145, 128, 57, 188, 159, 64, 26, 161, 179, 235, 17, 18,
+       75, 146, 113, 223, 17, 30, 123, 128, 0, 135, 10, 64, 40, 149, 148,
+       233, 44, 97, 15, 171, 183, 168, 24, 174, 163, 65, 94, 129, 70,
+       104, 24, 18, 73, 219, 192, 141, 246, 85, 62, 130, 112, 199, 42,
+       139, 31, 111, 73, 182, 150, 249, 115, 124, 192, 86, 182, 25, 28,
+       182, 228, 126, 46, 151, 189, 245, 188, 53, 206, 110, 45, 174, 192,
+       111, 140, 249, 245, 130, 186, 130, 153, 107, 177, 184, 71, 191,
+       19, 66, 247, 172, 200, 116, 204, 231, 43, 187, 149, 54, 220, 150,
+       215, 14, 54, 154, 235, 28, 4, 185, 158, 78, 40, 132, 188, 205,
+       244, 152, 11, 139, 159, 136, 17, 172, 254, 115, 202, 193, 107,
+       251, 149, 30, 75, 210, 224, 157, 117, 218, 123, 128, 69, 191, 198,
+       66, 184, 182, 208, 205, 212, 181, 135, 206, 31, 6, 18, 140, 184,
+       102, 110, 193, 127, 251, 17, 18, 107, 178, 225, 15, 26, 222, 107,
+       130, 92, 245, 239, 253, 110, 204, 101, 172, 27, 78, 184, 112, 166,
+       182, 204, 211, 1, 211, 59, 24, 196, 108, 110, 236, 246, 229, 10,
+       230, 207, 229, 180, 111, 249, 90, 0, 253, 237, 76, 38, 154, 67,
+       71, 253, 80, 166, 174, 142, 83, 97, 139, 18, 24, 230, 104, 238,
+       120, 211, 253, 14, 248, 167, 229, 53, 33, 250, 222, 104, 19, 207,
+       46, 158, 23, 147, 186, 236, 221, 85, 222, 135, 108, 104, 62, 197,
+       248, 163, 155, 229, 230, 139, 31, 253, 50, 115, 218, 195, 31, 14,
+       185, 222, 151, 213, 103, 158, 91, 212, 158, 248, 157, 80, 193,
+       231, 124, 222, 45, 229, 126, 121, 147, 227, 231, 7, 58, 255, 51,
+       32, 203, 142, 63, 55, 33, 247, 11, 17, 103, 205, 109, 54, 184, 90,
+       199, 220, 220, 167, 237, 221, 183, 236, 254, 17, 191, 253, 131,
+       163, 35, 213, 94, 91, 235, 206, 23, 143, 117, 245, 79, 188, 181,
+       86, 179, 86, 22, 185, 51, 218, 87, 244, 252, 247, 203, 255, 87,
+       126, 181, 162, 251, 222, 255, 191, 174, 111, 117, 198, 174, 244,
+       184, 119, 180, 73, 6, 174, 13, 135, 70, 105, 213, 2, 241, 2, 99,
+       201, 33, 65, 248, 224, 15, 226, 108, 167, 88, 157, 177, 226, 195,
+       27, 121, 59, 112, 2, 66, 184, 190, 190, 171, 232, 48, 7, 171, 29,
+       129, 57, 174, 191, 64, 90, 163, 55, 233, 17, 18, 73, 130, 193,
+       217, 245, 26, 123, 128, 64, 167, 11, 61, 107, 129, 229, 164, 15,
+       79, 149, 86, 170, 114, 76, 211, 1, 209, 52, 92, 236, 20, 110, 201,
+       180, 77, 42, 228, 140, 165, 180, 106, 187, 80, 161, 109, 126, 157,
+       103, 180, 63, 70, 148, 224, 186, 46, 76, 215, 49, 209, 191, 129,
+       100, 124, 126, 169, 116, 249, 40, 239, 219, 101, 52, 202, 251, 90,
+       33, 125, 71, 71, 71, 182, 10, 79, 173, 97, 164, 171, 138, 67, 97,
+       153, 151, 58, 198, 108, 238, 108, 242, 237, 12, 184, 234, 197, 20,
+       103, 254, 210, 68, 27, 67, 40, 174, 31, 145, 154, 72, 142, 68,
+       221, 231, 237, 202, 179, 196, 126, 161, 159, 199, 204, 131, 71,
+       221, 176, 101, 138, 153, 63, 142, 57, 221, 38, 140, 214, 255, 214,
+       130, 238, 161, 221, 2, 106, 2, 105, 234, 60, 64, 251, 227, 51,
+       131, 100, 184, 79, 239, 52, 190, 222, 0, 181, 122, 233, 12, 244,
+       64, 2, 142, 13, 35, 2, 104, 212, 2, 227, 10, 98, 194, 41, 213,
+       120, 228, 106, 226, 104, 39, 88, 95, 145, 38, 195, 24, 17, 123,
+       98, 0, 102, 203, 174, 190, 29, 128, 130, 168, 198, 156, 137, 7,
+       224, 232, 53, 67, 201, 98, 106, 211, 78, 107, 90, 61, 45, 114,
+       207, 91, 89, 58, 124, 142, 52, 139, 150, 222, 95, 203, 226, 232,
+       223, 128, 97, 75, 98, 225, 45, 134, 121, 234, 34, 66, 71, 105, 26,
+       253, 63, 134, 69, 59, 123, 42, 72, 142, 121, 173, 4, 229, 159, 19,
+       198, 239, 82, 162, 204, 10, 99, 97, 81, 134, 121, 230, 106, 168,
+       120, 251, 205, 31, 56, 199, 197, 61, 123, 234, 120, 136, 50, 142,
+       22, 188, 73, 171, 22, 231, 155, 30, 232, 25, 102, 226, 32, 151,
+       201, 227, 226, 1, 108, 79, 66, 191, 177, 246, 92, 59, 16, 92, 142,
+       142, 11, 145, 226, 221, 39, 144, 184, 121, 175, 129, 215, 163,
+       233, 254, 244, 100, 254, 61, 191, 197, 132, 145, 167, 193, 70,
+       125, 203, 131, 54, 174, 57, 151, 66, 146, 142, 159, 235, 160, 184,
+       7, 174, 31, 67, 183, 236, 234, 110, 75, 231, 51, 235, 145, 22, 73,
+       131, 225, 12, 50, 222, 203, 152, 68, 173, 159, 84, 96, 204, 164,
+       26, 10, 105, 72, 50, 180, 129, 139, 215, 227, 89, 82, 50, 221,
+       121, 244, 10, 65, 143, 8, 217, 167, 237, 60, 164, 160, 6, 2, 90,
+       161, 154, 161, 147, 207, 56, 199, 190, 53, 138, 1, 143, 151, 74,
+       208, 181, 159, 233, 145, 30, 217, 152, 21, 251, 197, 31, 103, 160,
+       6, 175, 74, 186, 22, 234, 165, 230, 114, 125, 95, 17, 206, 118,
+       247, 9, 45, 179, 73, 127, 222, 135, 190, 188, 246, 37, 138, 118,
+       111, 244, 133, 175, 253, 188, 217, 60, 64, 230, 237, 7, 18, 94,
+       220, 5, 130, 254, 130, 75, 107, 57, 107, 122, 212, 61, 234, 72,
+       241, 5, 136, 243, 235, 199, 5, 39, 255, 120, 2, 150, 30, 78, 177,
+       178, 163, 185, 114, 188, 190, 18, 247, 141, 39, 162, 9, 39, 33,
+       207, 181, 176, 221, 5, 206, 220, 3, 251, 196, 172, 132, 45, 209,
+       82, 144, 158, 178, 171, 232, 176, 3, 172, 19, 131, 49, 252, 254,
+       40, 75, 163, 55, 249, 17, 16, 77, 19, 209, 153, 243, 90, 91, 128,
+       64, 37, 27, 158, 74, 91, 238, 114, 194, 59, 96, 180, 132, 215,
+       163, 125, 207, 35, 64, 118, 185, 151, 226, 104, 135, 2, 206, 241,
+       229, 170, 137, 37, 179, 37, 251, 16, 21, 27, 229, 18, 38, 96, 115,
+       53, 168, 207, 82, 87, 55, 32, 116, 54, 181, 29, 168, 49, 145, 17,
+       78, 147, 228, 35, 130, 41, 160, 161, 49, 219, 49, 250, 196, 34,
+       144, 59, 81, 175, 68, 215, 166, 189, 223, 246, 98, 118, 189, 191,
+       204, 134, 145, 166, 193, 210, 121, 171, 171, 6, 167, 45, 117, 142,
+       62, 236, 215, 246, 50, 125, 183, 49, 255, 86, 183, 73, 45, 146,
+       15, 47, 254, 151, 156, 180, 220, 101, 234, 110, 79, 245, 193, 167,
+       244, 252, 241, 12, 254, 236, 19, 226, 186, 189, 183, 242, 191, 86,
+       245, 201, 165, 218, 15, 7, 110, 247, 159, 240, 220, 206, 226, 110,
+       95, 127, 197, 134, 213, 159, 233, 71, 144, 23, 193, 226, 142, 56,
+       115, 173, 59, 83, 242, 221, 23, 168, 111, 167, 149, 63, 169, 209,
+       157, 17, 213, 156, 178, 219, 198, 30, 128, 41, 49, 85, 97, 110,
+       172, 14, 83, 218, 72, 166, 164, 131, 139, 85, 202, 51, 66, 50,
+       165, 121, 231, 76, 3, 142, 220, 211, 233, 139, 61, 53, 162, 47,
+       66, 42, 251, 80, 168, 91, 157, 186, 206, 11, 37, 120, 143, 44,
+       143, 102, 144, 174, 155, 211, 85, 70, 42, 146, 245, 127, 213, 26,
+       107, 95, 28, 143, 219, 113, 28, 157, 165, 20, 46, 75, 55, 48, 162,
+       234, 94, 119, 51, 0, 112, 85, 230, 40, 168, 57, 218, 81, 14, 253,
+       174, 49, 16, 40, 224, 0, 56, 80, 89, 59, 254, 18, 192, 51, 96,
+       165, 4, 206, 163, 61, 215, 35, 80, 102, 243, 173, 194, 76, 139,
+       162, 109, 243, 229, 42, 131, 32, 179, 37, 123, 214, 4, 214, 228,
+       198, 42, 106, 72, 121, 130, 179, 82, 79, 43, 29, 91, 123, 197, 77,
+       250, 56, 199, 137, 234, 152, 190, 219, 68, 229, 225, 99, 0, 135,
+       13, 7, 211, 180, 167, 104, 32, 188, 128, 211, 82, 213, 227, 177,
+       105, 96, 55, 59, 220, 49, 217, 3, 236, 140, 186, 235, 192, 12,
+       129, 33, 160, 112, 50, 57, 97, 56, 203, 81, 80, 36, 44, 242, 120,
+       23, 7, 128, 16, 238, 156, 77, 24, 138, 158, 97, 22, 208, 172, 32,
+       240, 80, 136, 6, 51, 24, 249, 24, 105, 58, 201, 19, 254, 46, 37,
+       108, 41, 191, 151, 2, 16, 182, 27, 207, 80, 74, 56, 81, 61, 255,
+       197, 32, 113, 112, 154, 143, 11, 99, 121, 83, 140, 91, 157, 146,
+       73, 139, 68, 232, 143, 44, 222, 39, 148, 206, 185, 131, 69, 199,
+       43, 210, 253, 51, 84, 9, 59, 89, 46, 11, 215, 35, 43, 115, 136,
+       107, 209, 177, 64, 14, 196, 228, 171, 12, 132, 230, 244, 238, 169,
+       162, 85, 133, 27, 166, 208, 20, 36, 10, 107, 21, 14, 55, 253, 97,
+       150, 59, 124, 116, 174, 107, 55, 253, 75, 122, 84, 246, 233, 180,
+       112, 213, 38, 108, 12, 179, 173, 0, 79, 101, 190, 50, 192, 72,
+       128, 195, 41, 65, 142, 29, 115, 176, 172, 107, 183, 124, 73, 114,
+       84, 247, 99, 136, 112, 135, 103, 108, 28, 179, 220, 65, 127, 236,
+       190, 50, 192, 200, 128, 193, 41, 80, 21, 31, 228, 18, 70, 53, 115,
+       36, 160, 206, 66, 85, 23, 32, 97, 114, 181, 93, 168, 73, 147, 17,
+       76, 241, 161, 43, 0, 33, 32, 37, 59, 158, 22, 254, 81, 166, 114,
+       189, 87, 61, 255, 126, 183, 73, 63, 231, 109, 127, 94, 151, 176,
+       176, 220, 37, 206, 111, 207, 247, 199, 167, 244, 228, 243, 14,
+       174, 237, 83, 162, 123, 173, 151, 62, 255, 22, 178, 200, 54, 214,
+       175, 39, 86, 247, 152, 177, 216, 175, 224, 46, 15, 255, 199, 167,
+       212, 149, 253, 85, 88, 30, 224, 60, 159, 80, 208, 199, 184, 182,
+       2, 23, 147, 227, 104, 224, 36, 92, 88, 14, 37, 17, 188, 219, 217,
+       33, 247, 184, 153, 24, 3, 160, 22, 121, 233, 20, 236, 81, 19, 108,
+       13, 115, 24, 147, 21, 4, 112, 76, 184, 14, 24, 10, 188, 97, 21,
+       197, 168, 178, 64, 112, 8, 84, 43, 9, 2, 194, 209, 100, 152, 104,
+       83, 127, 65, 118, 231, 169, 132, 246, 236, 126, 40, 166, 156, 135,
+       184, 39, 193, 14, 127, 50, 193, 238, 140, 105, 220, 129, 0, 223,
+       251, 164, 42, 104, 23, 125, 19, 115, 80, 151, 3, 144, 105, 98, 15,
+       46, 28, 145, 220, 199, 96, 132, 186, 242, 64, 140, 209, 129, 168,
+       79, 234, 165, 19, 186, 217, 173, 134, 158, 255, 30, 184, 236, 228,
+       192, 174, 7, 119, 254, 93, 19, 88, 239, 49, 12, 23, 127, 247, 132,
+       92, 133, 253, 69, 154, 23, 80, 42, 251, 48, 162, 254, 56, 178,
+       104, 94, 50, 165, 251, 167, 53, 238, 112, 53, 73, 11, 116, 154,
+       179, 99, 215, 152, 33, 9, 7, 181, 107, 97, 72, 116, 211, 79, 216,
+       101, 196, 252, 198, 3, 3, 181, 244, 122, 232, 22, 254, 201, 54,
+       101, 216, 54, 152, 129, 12, 55, 179, 112, 108, 2, 186, 60, 147,
+       234, 249, 184, 35, 142, 119, 23, 183, 140, 12, 102, 10, 135, 51,
+       251, 5, 150, 60, 62, 213, 78, 23, 90, 231, 28, 12, 141, 215, 184,
+       51, 123, 96, 98, 75, 91, 88, 32, 36, 245, 168, 23, 7, 161, 16,
+       126, 156, 71, 106, 72, 183, 97, 14, 210, 201, 32, 52, 103, 171,
+       102, 241, 48, 217, 57, 233, 124, 205, 87, 254, 68, 4, 124, 34,
+       183, 149, 160, 32, 90, 58, 6, 72, 74, 186, 112, 61, 229, 141, 34,
+       56, 112, 138, 68, 171, 1, 234, 132, 155, 228, 169, 100, 135, 110,
+       49, 74, 192, 165, 2, 209, 200, 67, 10, 42, 28, 66, 248, 71, 49, 4,
+       130, 118, 64, 148, 216, 201, 136, 7, 48, 167, 186, 53, 166, 185,
+       64, 189, 200, 209, 71, 156, 222, 117, 43, 236, 57, 31, 157, 163,
+       199, 18, 200, 209, 24, 139, 138, 133, 36, 53, 243, 187, 68, 99,
+       172, 53, 22, 202, 64, 37, 192, 255, 135, 91, 140, 183, 244, 252,
+       140, 151, 239, 205, 183, 53, 142, 146, 233, 138, 132, 111, 46,
+       120, 212, 25, 19, 107, 193, 86, 82, 233, 80, 101, 68, 246, 162,
+       25, 30, 182, 100, 106, 152, 14, 232, 140, 179, 36, 204, 86, 9,
+       162, 1, 55, 138, 116, 228, 57, 15, 99, 237, 52, 167, 239, 127, 84,
+       72, 218, 70, 115, 97, 176, 96, 88, 174, 30, 173, 201, 186, 117,
+       31, 245, 174, 162, 0, 53, 202, 112, 232, 109, 121, 155, 116, 161,
+       14, 103, 150, 234, 170, 46, 72, 182, 177, 65, 50, 128, 124, 124,
+       90, 193, 241, 176, 40, 237, 189, 101, 48, 200, 113, 67, 59, 169,
+       91, 87, 69, 116, 30, 230, 54, 125, 232, 114, 108, 179, 0, 149,
+       181, 76, 108, 70, 78, 237, 188, 117, 46, 38, 248, 32, 0, 78, 185,
+       90, 189, 79, 248, 149, 179, 171, 217, 61, 142, 142, 123, 12, 176,
+       188, 182, 194, 238, 135, 87, 250, 81, 23, 72, 255, 241, 141, 23,
+       127, 255, 152, 85, 141, 93, 77, 242, 245, 97, 171, 93, 61, 152,
+       163, 252, 21, 236, 221, 87, 202, 191, 55, 85, 253, 126, 209, 68,
+       239, 144, 207, 217, 101, 255, 174, 183, 135, 245, 144, 221, 63,
+       254, 130, 198, 23, 255, 80, 222, 84, 118, 116, 127, 35, 49, 183,
+       251, 21, 227, 229, 207, 58, 63, 243, 139, 127, 130, 56, 112, 167,
+       251, 135, 157, 59, 234, 160, 228, 127, 215, 158, 79, 60, 18, 180,
+       191, 124, 112, 213, 19, 23, 156, 147, 9, 34, 243, 99, 157, 174,
+       200, 144, 208, 165, 251, 60, 86, 90, 229, 118, 34, 91, 112, 17,
+       166, 255, 167, 83, 29, 171, 81, 126, 156, 7, 174, 200, 179, 101,
+       142, 210, 233, 32, 4, 103, 235, 100, 241, 1, 34, 27, 251, 100,
+       157, 185, 82, 79, 89, 113, 86, 188, 146, 240, 108, 230, 41, 22,
+       156, 151, 188, 34, 208, 133, 216, 58, 226, 152, 136, 33, 173, 144,
+       152, 27, 249, 3, 231, 49, 87, 31, 91, 196, 18, 60, 151, 96, 104,
+       237, 59, 187, 16, 51, 159, 51, 215, 219, 215, 26, 107, 154, 8,
+       165, 187, 130, 176, 159, 248, 41, 229, 17, 95, 159, 89, 68, 84,
+       188, 151, 96, 41, 135, 59, 147, 16, 19, 77, 50, 211, 203, 209, 26,
+       238, 152, 64, 33, 187, 130, 184, 155, 248, 43, 229, 57, 91, 191,
+       91, 84, 116, 188, 215, 96, 105, 167, 59, 183, 17, 3, 76, 186, 209,
+       201, 208, 63, 238, 152, 64, 3, 187, 224, 168, 148, 186, 173, 217,
+       16, 175, 223, 31, 128, 56, 174, 184, 96, 207, 201, 51, 234, 17,
+       126, 111, 202, 181, 137, 210, 84, 123, 146, 12, 156, 15, 75, 157,
+       189, 153, 139, 124, 61, 159, 254, 123, 30, 116, 220, 62, 218, 239,
+       167, 71, 254, 145, 151, 72, 255, 241, 77, 127, 127, 198, 158, 84,
+       133, 95, 66, 185, 181, 222, 239, 237, 176, 107, 138, 89, 57, 105,
+       188, 254, 100, 34, 135, 51, 243, 1, 147, 106, 218, 209, 77, 30,
+       126, 234, 216, 74, 135, 187, 213, 63, 93, 33, 162, 15, 31, 56, 56,
+       234, 51, 236, 215, 20, 193, 59, 182, 117, 92, 126, 225, 244, 237,
+       46, 184, 138, 101, 246, 108, 179, 3, 113, 109, 130, 144, 44, 45,
+       12, 198, 57, 104, 11, 249, 45, 223, 248, 26, 82, 209, 69, 108, 47,
+       216, 41, 203, 3, 208, 255, 114, 28, 74, 46, 219, 3, 223, 51, 122,
+       36, 98, 20, 191, 112, 224, 204, 245, 231, 25, 206, 246, 51, 190,
+       253, 213, 231, 244, 227, 166, 200, 83, 233, 234, 137, 111, 167,
+       47, 215, 243, 25, 225, 236, 109, 20, 219, 120, 73, 72, 241, 7,
+       121, 206, 63, 122, 220, 233, 55, 207, 207, 34, 246, 225, 83, 121,
+       202, 170, 29, 175, 114, 221, 177, 84, 109, 225, 100, 110, 237, 22,
+       85, 250, 119, 114, 19, 29, 144, 47, 104, 144, 23, 170, 233, 244,
+       101, 204, 71, 139, 242, 132, 109, 217, 208, 177, 33, 73, 67, 205,
+       116, 199, 111, 116, 69, 72, 250, 70, 51, 81, 181, 116, 88, 232,
+       22, 238, 201, 186, 116, 191, 37, 188, 162, 8, 63, 155, 112, 172,
+       160, 236, 22, 26, 93, 161, 144, 239, 158, 19, 160, 25, 228, 249,
+       104, 129, 201, 59, 235, 1, 34, 111, 74, 119, 89, 18, 91, 123, 81,
+       8, 237, 138, 161, 123, 105, 5, 116, 31, 198, 50, 85, 232, 246,
+       238, 51, 8, 151, 165, 94, 236, 86, 111, 237, 190, 101, 30, 38, 73,
+       37, 176, 111, 189, 90, 221, 3, 171, 144, 222, 236, 141, 174, 163,
+       142, 9, 24, 96, 188, 250, 244, 2, 206, 123, 127, 9, 83, 40, 194,
+       241, 172, 28, 62, 184, 156, 74, 145, 137, 228, 161, 117, 200, 252,
+       137, 228, 237, 207, 57, 176, 122, 158, 24, 124, 49, 203, 147, 87,
+       113, 210, 42, 74, 213, 125, 24, 69, 126, 85, 8, 210, 131, 131, 93,
+       159, 30, 138, 199, 181, 180, 148, 218, 198, 55, 112, 247, 35, 107,
+       96, 119, 122, 194, 101, 237, 51, 47, 49, 34, 116, 155, 121, 57,
+       173, 123, 163, 255, 62, 223, 218, 215, 23, 255, 150, 95, 84, 54,
+       52, 118, 34, 35, 165, 115, 147, 161, 245, 203, 58, 63, 105, 3,
+       125, 163, 57, 80, 165, 255, 146, 157, 171, 250, 147, 213, 158,
+       255, 22, 95, 220, 31, 60, 255, 98, 32, 253, 219, 145, 148, 247,
+       11, 58, 243, 123, 205, 140, 254, 177, 72, 164, 123, 181, 105, 99,
+       68, 84, 70, 207, 112, 112, 232, 247, 66, 83, 85, 181, 53, 120,
+       236, 22, 238, 233, 183, 125, 14, 49, 168, 161, 0, 103, 187, 114,
+       224, 28, 173, 140, 189, 155, 10, 7, 175, 30, 179, 134, 145, 215,
+       97, 10, 67, 83, 70, 104, 46, 120, 233, 79, 63, 233, 231, 87, 85,
+       160, 120, 137, 32, 162, 164, 20, 184, 92, 171, 160, 238, 31, 51,
+       96, 25, 96, 192, 44, 16, 217, 139, 2, 1, 34, 126, 74, 31, 29, 150,
+       27, 110, 81, 8, 82, 138, 67, 149, 173, 151, 204, 124, 61, 159,
+       255, 91, 30, 85, 188, 126, 90, 111, 165, 67, 125, 157, 183, 72,
+       187, 225, 15, 62, 254, 198, 140, 84, 153, 127, 64, 201, 2, 169,
+       220, 137, 99, 197, 102, 5, 202, 2, 161, 131, 65, 64, 104, 170, 42,
+       216, 18, 152, 199, 113, 188, 164, 130, 73, 176, 26, 177, 136, 98,
+       185, 187, 206, 237, 132, 176, 97, 202, 73, 152, 109, 188, 252,
+       116, 34, 140, 51, 119, 5, 147, 43, 210, 209, 13, 28, 42, 250, 88,
+       10, 147, 187, 123, 94, 104, 204, 124, 180, 91, 184, 5, 76, 188,
+       199, 121, 78, 183, 112, 94, 192, 159, 238, 141, 3, 117, 255, 114,
+       109, 170, 156, 63, 183, 120, 93, 103, 201, 125, 200, 125, 221,
+       217, 236, 207, 120, 176, 10, 26, 28, 52, 49, 200, 145, 95, 111,
+       214, 43, 106, 245, 127, 24, 69, 255, 85, 136, 212, 103, 68, 76,
+       207, 149, 14, 104, 164, 162, 246, 210, 194, 163, 225, 225, 145,
+       75, 51, 228, 104, 131, 33, 213, 143, 10, 84, 38, 215, 5, 164, 241,
+       61, 2, 20, 6, 110, 197, 70, 50, 237, 114, 116, 238, 95, 230, 81,
+       43, 191, 105, 126, 156, 23, 171, 168, 241, 37, 204, 86, 43, 226,
+       132, 173, 241, 116, 241, 173, 251, 65, 65, 252, 31, 206, 184, 83,
+       248, 177, 76, 211, 65, 221, 180, 29, 204, 86, 126, 233, 98, 253,
+       30, 46, 156, 165, 252, 219, 187, 82, 165, 181, 111, 108, 69, 124,
+       31, 206, 120, 87, 232, 181, 238, 211, 8, 213, 33, 94, 204, 86,
+       111, 237, 118, 109, 28, 38, 9, 161, 188, 125, 185, 90, 133, 161,
+       86, 105, 237, 100, 46, 237, 63, 84, 238, 119, 118, 211, 49, 177,
+       105, 94, 188, 22, 43, 233, 180, 101, 26, 100, 171, 242, 132, 124,
+       248, 84, 249, 23, 7, 231, 133, 180, 54, 238, 88, 116, 234, 219,
+       198, 81, 44, 191, 238, 124, 196, 61, 175, 173, 145, 45, 202, 48,
+       111, 235, 132, 173, 231, 120, 85, 38, 240, 179, 250, 111, 197,
+       187, 192, 139, 85, 81, 155, 28, 223, 125, 14, 206, 89, 179, 211,
+       131, 118, 186, 241, 85, 16, 202, 107, 149, 31, 183, 242, 37, 241,
+       49, 73, 220, 13, 75, 184, 87, 121, 169, 76, 211, 81, 216, 52, 25,
+       136, 82, 126, 203, 34, 123, 23, 111, 156, 165, 124, 90, 139, 82,
+       176, 163, 4, 173, 247, 228, 102, 237, 55, 24, 255, 82, 86, 209,
+       63, 153, 107, 199, 79, 55, 141, 177, 220, 225, 226, 68, 42, 254,
+       128, 132, 240, 240, 249, 71, 157, 173, 151, 224, 236, 61, 183,
+       186, 219, 70, 213, 244, 254, 94, 123, 133, 103, 113, 157, 183,
+       216, 187, 97, 111, 59, 254, 192, 140, 80, 147, 219, 34, 169, 200,
+       234, 246, 129, 202, 69, 11, 129, 216, 138, 173, 139, 116, 16, 250,
+       171, 23, 209, 90, 10, 192, 253, 188, 156, 142, 104, 52, 138, 179,
+       136, 99, 177, 43, 174, 124, 132, 154, 113, 139, 72, 152, 77, 60,
+       220, 116, 0, 220, 187, 21, 69, 222, 43, 144, 221, 187, 60, 170,
+       250, 73, 14, 179, 223, 107, 136, 146, 220, 77, 16, 96, 111, 91, 3,
+       96, 8, 40, 186, 116, 252, 209, 139, 178, 140, 7, 63, 134, 211, 22,
+       126, 82, 47, 90, 12, 106, 140, 169, 154, 116, 245, 101, 143, 241,
+       50, 29, 38, 118, 79, 62, 25, 48, 141, 174, 36, 55, 12, 224, 188,
+       81, 221, 87, 251, 80, 18, 126, 140, 80, 107, 107, 92, 100, 204,
+       61, 255, 91, 190, 197, 104, 156, 14, 58, 28, 183, 228, 76, 176,
+       223, 109, 141, 35, 117, 159, 51, 125, 129, 182, 63, 159, 88, 125,
+       38, 63, 120, 64, 248, 191, 82, 87, 235, 169, 184, 40, 138, 187,
+       69, 58, 143, 243, 78, 16, 158, 107, 192, 216, 255, 220, 37, 255,
+       227, 209, 198, 143, 71, 74, 158, 132, 106, 42, 45, 134, 174, 163,
+       138, 224, 140, 162, 193, 90, 163, 69, 110, 29, 0, 213, 133, 64,
+       148, 38, 127, 164, 132, 113, 33, 40, 167, 120, 227, 83, 77, 27,
+       162, 200, 91, 242, 113, 206, 72, 200, 253, 173, 219, 104, 146, 87,
+       133, 246, 126, 248, 14, 24, 207, 46, 223, 127, 91, 148, 23, 74,
+       206, 182, 34, 162, 238, 80, 180, 198, 219, 231, 65, 238, 179, 74,
+       126, 237, 183, 199, 140, 215, 14, 232, 144, 38, 235, 128, 45, 247,
+       56, 84, 87, 92, 198, 132, 32, 50, 238, 80, 164, 194, 219, 199, 89,
+       234, 183, 238, 126, 229, 127, 175, 205, 151, 149, 200, 16, 110,
+       235, 132, 45, 247, 57, 21, 23, 22, 231, 133, 6, 114, 169, 80, 44,
+       234, 91, 230, 89, 62, 183, 239, 119, 197, 63, 175, 133, 209, 37,
+       200, 20, 46, 235, 132, 173, 247, 49, 117, 102, 112, 63, 186, 207,
+       197, 159, 200, 139, 85, 161, 15, 28, 221, 127, 11, 236, 209, 211,
+       247, 3, 39, 186, 241, 87, 16, 206, 127, 213, 63, 55, 242, 165, 4,
+       109, 69, 70, 47, 233, 56, 84, 226, 87, 214, 81, 5, 157, 109, 127,
+       140, 22, 174, 233, 244, 125, 12, 5, 42, 225, 132, 109, 251, 80,
+       240, 19, 79, 74, 140, 22, 146, 238, 116, 116, 128, 218, 231, 97,
+       136, 183, 192, 126, 237, 134, 239, 204, 187, 4, 237, 50, 109, 170,
+       128, 61, 190, 120, 141, 162, 170, 234, 21, 69, 249, 184, 71, 218,
+       87, 68, 157, 160, 172, 86, 8, 137, 43, 227, 133, 150, 254, 230,
+       147, 70, 87, 216, 107, 197, 76, 222, 222, 0, 169, 222, 185, 62,
+       139, 176, 206, 238, 181, 66, 130, 183, 136, 68, 74, 230, 69, 107,
+       17, 18, 249, 211, 21, 140, 199, 95, 84, 140, 8, 17, 136, 3, 128,
+       174, 181, 198, 134, 169, 103, 63, 19, 66, 147, 156, 190, 48, 105,
+       227, 63, 59, 149, 16, 216, 131, 193, 157, 54, 218, 194, 132, 4,
+       181, 232, 162, 12, 209, 217, 93, 167, 248, 79, 95, 19, 112, 83,
+       32, 153, 52, 9, 233, 138, 19, 144, 54, 190, 67, 211, 7, 30, 144,
+       35, 209, 200, 240, 138, 42, 37, 210, 74, 213, 165, 118, 71, 19, 1,
+       121, 9, 42, 217, 45, 148, 216, 186, 130, 0, 22, 186, 80, 251, 55,
+       84, 0, 43, 243, 94, 254, 142, 56, 165, 210, 232, 213, 231, 102,
+       71, 65, 1, 120, 11, 34, 171, 40, 144, 248, 138, 130, 176, 30, 186,
+       16, 200, 63, 196, 132, 107, 243, 74, 254, 138, 238, 171, 68, 192,
+       217, 155, 78, 241, 149, 188, 130, 204, 11, 3, 197, 149, 72, 236,
+       207, 252, 126, 27, 64, 158, 190, 216, 133, 245, 50, 172, 218, 4,
+       255, 13, 103, 136, 109, 118, 67, 50, 197, 96, 222, 2, 10, 28, 55,
+       231, 200, 164, 253, 109, 141, 161, 117, 156, 19, 121, 128, 19,
+       182, 173, 124, 118, 59, 252, 61, 64, 53, 223, 209, 246, 207, 248,
+       188, 10, 58, 29, 86, 164, 140, 176, 223, 121, 207, 41, 112, 220,
+       187, 217, 5, 119, 87, 140, 94, 127, 210, 74, 102, 188, 34, 128,
+       31, 230, 181, 134, 210, 163, 41, 143, 179, 91, 102, 245, 173, 199,
+       108, 207, 134, 234, 240, 34, 254, 137, 37, 181, 37, 73, 191, 159,
+       225, 82, 179, 148, 159, 176, 217, 78, 29, 247, 120, 125, 191, 53,
+       151, 115, 149, 231, 245, 4, 60, 234, 107, 94, 172, 226, 255, 247,
+       214, 119, 191, 82, 70, 133, 6, 18, 238, 120, 68, 226, 211, 231,
+       73, 72, 183, 199, 126, 228, 126, 239, 237, 245, 29, 140, 48, 106,
+       235, 132, 111, 191, 120, 149, 57, 94, 107, 174, 54, 147, 78, 112,
+       85, 64, 91, 199, 123, 78, 179, 224, 126, 169, 151, 231, 237, 147,
+       60, 191, 242, 205, 171, 128, 63, 191, 56, 216, 194, 148, 62, 30,
+       81, 244, 48, 39, 253, 79, 103, 17, 46, 190, 38, 220, 161, 35, 170,
+       0, 54, 173, 50, 199, 19, 119, 18, 75, 82, 4, 237, 78, 2, 177, 254,
+       201, 126, 141, 184, 79, 239, 177, 66, 46, 172, 138, 68, 66, 230,
+       29, 107, 17, 130, 249, 147, 209, 12, 28, 26, 114, 140, 8, 9, 140,
+       131, 128, 190, 217, 198, 182, 185, 71, 255, 87, 82, 147, 156, 174,
+       54, 105, 239, 187, 59, 145, 182, 216, 55, 213, 93, 58, 218, 193,
+       149, 12, 181, 238, 130, 8, 230, 217, 253, 181, 184, 71, 94, 23,
+       210, 147, 168, 172, 52, 105, 235, 59, 59, 153, 182, 254, 103, 208,
+       79, 59, 218, 73, 149, 76, 245, 142, 218, 240, 191, 182, 5, 92, 81,
+       4, 171, 127, 135, 25, 174, 159, 74, 94, 160, 213, 253, 0, 78, 207,
+       178, 224, 211, 241, 80, 19, 2, 4, 6, 126, 148, 37, 41, 225, 180,
+       102, 111, 151, 52, 206, 222, 16, 147, 23, 147, 105, 89, 222, 21,
+       190, 250, 148, 97, 46, 233, 141, 166, 196, 168, 209, 244, 115, 7,
+       254, 173, 23, 224, 166, 173, 183, 186, 251, 82, 213, 244, 127, 83,
+       43, 135, 119, 119, 159, 243, 220, 251, 98, 109, 14, 255, 196, 136,
+       209, 131, 249, 2, 57, 210, 240, 249, 232, 48, 23, 171, 169, 56,
+       109, 174, 191, 69, 26, 134, 127, 221, 16, 18, 75, 144, 224, 175,
+       212, 30, 187, 140, 81, 135, 155, 67, 74, 158, 149, 34, 6, 61, 7,
+       174, 186, 218, 230, 188, 130, 193, 106, 231, 245, 126, 141, 192,
+       221, 135, 64, 148, 38, 126, 130, 140, 112, 41, 45, 87, 19, 199,
+       133, 162, 58, 188, 17, 46, 235, 27, 247, 93, 46, 223, 206, 55, 69,
+       125, 149, 149, 208, 165, 192, 148, 38, 123, 134, 172, 231, 169,
+       85, 255, 119, 107, 72, 239, 85, 223, 249, 203, 222, 188, 175, 74,
+       252, 127, 51, 157, 209, 213, 247, 220, 39, 190, 208, 123, 89, 133,
+       191, 87, 247, 246, 119, 230, 121, 108, 8, 207, 85, 159, 200, 203,
+       244, 164, 143, 8, 220, 127, 27, 236, 209, 243, 247, 206, 103, 190,
+       208, 83, 25, 205, 63, 87, 61, 126, 86, 160, 56, 59, 80, 109, 221,
+       241, 71, 223, 57, 52, 24, 186, 157, 100, 189, 200, 186, 194, 16,
+       19, 126, 50, 209, 95, 217, 16, 107, 211, 8, 214, 170, 96, 56, 153,
+       112, 105, 205, 113, 87, 171, 185, 36, 24, 190, 151, 68, 26, 136,
+       59, 206, 16, 3, 122, 242, 64, 223, 217, 16, 123, 194, 8, 198, 187,
+       89, 0, 158, 165, 25, 14, 89, 51, 173, 169, 130, 65, 255, 55, 0,
+       115, 196, 181, 125, 45, 8, 201, 211, 140, 217, 243, 90, 80, 0, 32,
+       1, 43, 24, 171, 12, 169, 44, 139, 248, 56, 166, 56, 210, 97, 183,
+       154, 16, 64, 202, 37, 125, 81, 74, 153, 67, 21, 200, 225, 171,
+       209, 16, 10, 85, 11, 2, 177, 242, 193, 106, 157, 184, 71, 239, 49,
+       114, 231, 172, 158, 68, 70, 230, 159, 251, 17, 210, 121, 151, 209,
+       30, 48, 26, 98, 77, 136, 163, 159, 226, 50, 24, 250, 108, 236,
+       112, 65, 187, 27, 113, 121, 166, 154, 76, 31, 205, 59, 71, 18, 50,
+       94, 202, 226, 159, 208, 90, 107, 192, 0, 199, 143, 88, 97, 34,
+       225, 129, 173, 92, 5, 165, 4, 167, 9, 143, 15, 19, 152, 168, 177,
+       201, 112, 72, 33, 209, 128, 211, 209, 130, 17, 98, 151, 206, 2,
+       160, 76, 45, 241, 68, 102, 77, 54, 84, 86, 230, 18, 19, 21, 49,
+       121, 73, 184, 19, 170, 104, 246, 113, 14, 71, 171, 208, 0, 81,
+       216, 116, 250, 161, 76, 45, 211, 197, 102, 237, 55, 212, 87, 71,
+       16, 144, 41, 18, 111, 201, 2, 51, 175, 241, 252, 123, 239, 69,
+       187, 214, 0, 2, 217, 212, 232, 47, 161, 227, 210, 215, 212, 232,
+       65, 91, 65, 85, 198, 72, 204, 254, 172, 122, 169, 146, 157, 151,
+       182, 190, 195, 30, 92, 139, 235, 143, 14, 251, 212, 2, 18, 210,
+       79, 227, 185, 176, 70, 47, 15, 120, 255, 44, 42, 174, 156, 239,
+       27, 134, 4, 150, 56, 2, 227, 20, 22, 58, 163, 217, 77, 15, 159,
+       13, 159, 169, 83, 181, 116, 95, 183, 112, 95, 126, 20, 249, 53,
+       155, 45, 13, 66, 149, 222, 251, 248, 121, 170, 111, 223, 244, 192,
+       202, 245, 212, 121, 57, 97, 106, 236, 118, 147, 123, 88, 5, 224,
+       126, 130, 27, 223, 247, 112, 126, 188, 23, 252, 203, 179, 181,
+       141, 87, 237, 131, 4, 119, 174, 120, 240, 64, 169, 170, 21, 81,
+       250, 225, 7, 237, 69, 110, 1, 170, 172, 22, 84, 160, 46, 234, 17,
+       22, 184, 180, 65, 71, 117, 18, 67, 194, 4, 207, 222, 34, 187, 122,
+       201, 126, 157, 176, 69, 239, 41, 184, 106, 174, 152, 196, 50, 238,
+       57, 223, 81, 134, 43, 195, 209, 159, 92, 26, 251, 4, 10, 23, 143,
+       162, 152, 240, 219, 245, 253, 248, 87, 223, 91, 116, 19, 172, 189,
+       118, 45, 239, 58, 147, 29, 182, 124, 82, 211, 15, 94, 210, 235,
+       215, 204, 249, 207, 170, 160, 178, 251, 101, 253, 248, 71, 223,
+       27, 113, 27, 174, 157, 112, 61, 233, 187, 23, 17, 54, 126, 10,
+       211, 7, 222, 82, 235, 211, 72, 199, 143, 133, 156, 189, 183, 162,
+       47, 191, 182, 22, 255, 29, 213, 245, 119, 75, 11, 23, 91, 51, 159,
+       241, 216, 57, 107, 109, 143, 127, 228, 136, 241, 133, 249, 35,
+       240, 104, 24, 77, 221, 148, 239, 223, 87, 52, 27, 168, 152, 126,
+       45, 201, 11, 147, 5, 198, 110, 118, 241, 23, 26, 216, 59, 95, 12,
+       223, 206, 205, 86, 61, 189, 162, 98, 157, 63, 60, 254, 148, 245,
+       157, 39, 131, 75, 71, 21, 157, 174, 225, 196, 101, 14, 224, 195,
+       127, 148, 28, 240, 165, 113, 162, 42, 86, 48, 107, 153, 176, 99,
+       185, 54, 113, 185, 14, 142, 134, 29, 174, 185, 198, 131, 116, 95,
+       6, 213, 22, 82, 91, 171, 117, 4, 143, 199, 24, 93, 19, 189, 19,
+       198, 55, 119, 180, 192, 74, 66, 189, 183, 33, 192, 236, 127, 147,
+       193, 105, 153, 16, 47, 225, 231, 142, 0, 34, 18, 37, 186, 95, 32,
+       233, 197, 62, 82, 121, 24, 234, 244, 135, 162, 217, 223, 211, 106,
+       54, 20, 125, 252, 147, 65, 167, 192, 206, 105, 171, 252, 166, 167,
+       55, 113, 74, 184, 155, 180, 41, 236, 81, 7, 171, 29, 162, 25, 190,
+       151, 64, 91, 166, 55, 253, 0, 18, 73, 146, 193, 209, 241, 90, 123,
+       0, 0, 135, 123, 2, 186, 243, 153, 107, 205, 184, 67, 175, 93, 116,
+       167, 172, 143, 230, 78, 166, 57, 183, 149, 150, 88, 146, 209, 78,
+       88, 90, 235, 30, 4, 37, 223, 238, 242, 182, 250, 109, 172, 82,
+       208, 171, 31, 181, 89, 206, 223, 108, 223, 197, 209, 221, 82, 186,
+       103, 154, 241, 147, 209, 66, 123, 146, 31, 15, 3, 220, 221, 60,
+       234, 170, 101, 95, 189, 132, 118, 141, 13, 95, 119, 43, 115, 23,
+       211, 253, 102, 232, 3, 59, 63, 243, 203, 101, 60, 178, 243, 133,
+       115, 4, 190, 189, 55, 186, 205, 191, 184, 158, 255, 2, 237, 244,
+       245, 73, 10, 151, 127, 243, 83, 179, 120, 251, 59, 109, 6, 127,
+       180, 200, 121, 5, 251, 154, 120, 250, 84, 83, 208, 185, 71, 177,
+       196, 244, 167, 40, 159, 39, 172, 174, 187, 151, 145, 228, 175, 52,
+       206, 115, 93, 26, 139, 103, 148, 47, 223, 147, 31, 109, 133, 178,
+       34, 173, 50, 28, 234, 94, 231, 149, 6, 151, 97, 39, 29, 21, 173,
+       225, 220, 101, 94, 228, 171, 235, 132, 61, 240, 1, 249, 191, 141,
+       102, 72, 221, 221, 210, 232, 205, 85, 188, 11, 74, 252, 62, 181,
+       248, 226, 211, 125, 190, 43, 62, 189, 59, 91, 5, 95, 243, 15, 254,
+       198, 251, 203, 102, 12, 77, 84, 214, 232, 197, 84, 228, 7, 106,
+       108, 62, 229, 248, 192, 171, 111, 252, 39, 62, 253, 51, 123, 195,
+       79, 127, 175, 124, 86, 127, 203, 102, 142, 13, 210, 207, 248, 229,
+       84, 214, 135, 105, 204, 190, 213, 120, 196, 189, 239, 221, 131,
+       62, 253, 114, 123, 202, 203, 55, 167, 124, 116, 210, 171, 58, 176,
+       91, 208, 184, 226, 187, 148, 0, 187, 44, 142, 70, 19, 162, 255,
+       195, 209, 118, 79, 134, 224, 28, 16, 30, 235, 5, 5, 47, 223, 220,
+       89, 87, 254, 11, 194, 23, 224, 165, 132, 130, 34, 126, 247, 33,
+       215, 98, 241, 233, 226, 105, 67, 58, 124, 241, 226, 71, 26, 54,
+       51, 37, 122, 45, 201, 110, 239, 95, 151, 235, 248, 197, 128, 125,
+       130, 89, 201, 62, 96, 122, 236, 19, 254, 66, 179, 61, 141, 127,
+       233, 129, 65, 119, 142, 116, 232, 138, 168, 154, 248, 75, 193,
+       176, 71, 187, 23, 224, 59, 44, 159, 102, 24, 171, 187, 131, 145,
+       54, 79, 130, 243, 91, 213, 26, 107, 209, 4, 175, 203, 88, 16, 31,
+       176, 57, 236, 89, 19, 173, 93, 130, 61, 191, 31, 0, 90, 166, 181,
+       253, 17, 11, 13, 147, 149, 211, 241, 90, 83, 138, 0, 39, 91, 81,
+       73, 58, 168, 60, 205, 251, 80, 132, 72, 144, 11, 151, 158, 51, 96,
+       236, 177, 95, 197, 206, 43, 96, 29, 209, 201, 170, 249, 48, 10,
+       33, 91, 3, 186, 174, 153, 107, 213, 184, 71, 143, 93, 84, 183,
+       172, 142, 246, 171, 231, 59, 191, 149, 151, 73, 182, 241, 15, 82,
+       218, 235, 156, 4, 45, 223, 139, 184, 170, 219, 253, 245, 184, 87,
+       223, 95, 84, 23, 172, 158, 246, 173, 239, 59, 179, 157, 179, 94,
+       178, 241, 15, 27, 218, 235, 158, 12, 61, 255, 162, 176, 178, 250,
+       73, 245, 248, 73, 155, 31, 97, 25, 108, 255, 108, 31, 169, 27,
+       147, 145, 54, 118, 154, 211, 31, 222, 90, 107, 210, 76, 167, 198,
+       132, 221, 189, 255, 186, 103, 31, 189, 22, 222, 13, 180, 247, 119,
+       11, 67, 23, 83, 61, 110, 243, 192, 123, 63, 233, 143, 101, 148,
+       184, 251, 133, 113, 166, 177, 229, 146, 221, 253, 176, 75, 203,
+       117, 49, 27, 140, 220, 94, 11, 137, 27, 211, 21, 182, 107, 250,
+       213, 31, 24, 31, 127, 215, 13, 215, 214, 114, 58, 234, 156, 95,
+       208, 152, 70, 139, 69, 220, 167, 44, 142, 55, 70, 238, 187, 147,
+       133, 134, 11, 166, 233, 19, 116, 154, 171, 151, 12, 63, 223, 131,
+       25, 87, 253, 246, 130, 236, 119, 20, 74, 82, 246, 177, 17, 176,
+       225, 110, 62, 22, 137, 241, 156, 85, 143, 36, 170, 186, 128, 61,
+       136, 240, 185, 9, 95, 18, 253, 49, 134, 111, 55, 52, 136, 94, 68,
+       189, 179, 161, 228, 70, 126, 22, 8, 97, 152, 0, 47, 224, 255, 62,
+       128, 10, 176, 41, 169, 98, 58, 183, 252, 109, 213, 152, 27, 139,
+       248, 152, 109, 188, 157, 215, 46, 134, 61, 253, 5, 132, 111, 242,
+       216, 75, 94, 125, 187, 70, 164, 23, 127, 90, 152, 154, 186, 43,
+       228, 17, 71, 171, 93, 161, 57, 174, 159, 98, 91, 167, 51, 253, 1,
+       22, 75, 146, 209, 211, 241, 90, 123, 144, 4, 167, 91, 50, 113,
+       120, 232, 117, 217, 218, 80, 137, 72, 188, 47, 190, 157, 182, 160,
+       238, 185, 215, 65, 207, 43, 114, 221, 179, 217, 170, 187, 87, 14,
+       95, 223, 42, 179, 113, 200, 127, 217, 251, 80, 235, 76, 180, 171,
+       172, 159, 230, 180, 238, 185, 215, 65, 198, 43, 226, 209, 87, 93,
+       138, 187, 87, 142, 79, 223, 252, 91, 60, 242, 173, 157, 87, 152,
+       203, 30, 181, 41, 95, 223, 107, 91, 182, 209, 157, 114, 202, 103,
+       186, 176, 243, 217, 101, 63, 50, 191, 140, 115, 132, 191, 189,
+       255, 186, 66, 23, 185, 22, 254, 29, 244, 246, 117, 137, 65, 87,
+       126, 61, 35, 251, 192, 251, 63, 233, 134, 103, 246, 144, 250, 133,
+       115, 34, 208, 33, 154, 77, 213, 188, 239, 143, 87, 144, 155, 172,
+       206, 126, 66, 205, 27, 187, 133, 198, 15, 122, 209, 23, 22, 218,
+       251, 23, 12, 181, 222, 139, 91, 105, 225, 102, 223, 249, 23, 77,
+       236, 94, 230, 189, 28, 215, 32, 38, 57, 151, 221, 197, 188, 101,
+       202, 102, 217, 174, 128, 47, 188, 93, 253, 250, 178, 178, 86, 203,
+       252, 145, 23, 187, 127, 181, 61, 14, 189, 78, 190, 167, 23, 253,
+       17, 151, 111, 186, 227, 91, 119, 16, 251, 195, 71, 143, 87, 123,
+       149, 102, 222, 205, 221, 222, 229, 133, 84, 213, 143, 106, 252,
+       62, 231, 204, 242, 251, 231, 254, 43, 126, 189, 123, 123, 200,
+       219, 119, 14, 220, 86, 123, 211, 102, 94, 75, 212, 31, 244, 161,
+       76, 215, 167, 104, 254, 190, 246, 236, 247, 253, 199, 205, 139,
+       254, 237, 179, 121, 202, 139, 39, 135, 190, 95, 130, 222, 39, 157,
+       100, 196, 189, 119, 252, 94, 82, 247, 188, 141, 176, 73, 231, 59,
+       19, 133, 225, 220, 54, 255, 69, 50, 250, 128, 20, 148, 181, 249,
+       70, 44, 91, 236, 92, 139, 234, 107, 252, 162, 234, 10, 197, 233,
+       53, 64, 123, 237, 107, 161, 120, 187, 193, 95, 188, 166, 143, 45,
+       229, 120, 97, 128, 98, 51, 179, 196, 61, 119, 152, 91, 11, 232,
+       152, 109, 28, 254, 245, 36, 159, 61, 255, 181, 134, 11, 176, 220,
+       219, 92, 173, 190, 150, 38, 7, 247, 59, 49, 112, 232, 57, 87, 90,
+       89, 15, 236, 252, 237, 14, 223, 191, 52, 222, 153, 223, 241, 143,
+       3, 96, 221, 251, 93, 41, 255, 22, 174, 38, 119, 9, 249, 105, 75,
+       86, 149, 235, 240, 86, 65, 125, 134, 49, 77, 178, 32, 126, 58, 19,
+       222, 195, 184, 60, 63, 110, 13, 160, 224, 127, 139, 80, 248, 2,
+       190, 130, 152, 251, 177, 184, 198, 142, 25, 88, 231, 172, 202,
+       118, 196, 239, 43, 147, 149, 22, 26, 134, 245, 28, 20, 154, 235,
+       156, 4, 59, 159, 34, 164, 249, 200, 117, 253, 249, 79, 91, 111,
+       125, 25, 138, 156, 126, 16, 223, 155, 135, 17, 22, 58, 226, 211,
+       71, 156, 16, 111, 215, 206, 198, 215, 159, 82, 109, 237, 34, 86,
+       89, 24, 45, 92, 87, 247, 223, 95, 155, 251, 38, 149, 253, 239,
+       237, 196, 103, 197, 194, 251, 234, 132, 47, 165, 45, 113, 118,
+       165, 67, 238, 159, 7, 70, 236, 95, 160, 233, 10, 67, 234, 60, 212,
+       248, 237, 74, 226, 120, 43, 216, 255, 185, 164, 135, 62, 113, 58,
+       242, 134, 42, 180, 226, 90, 247, 241, 184, 67, 95, 71, 93, 179,
+       40, 220, 126, 172, 251, 59, 147, 145, 182, 62, 190, 247, 15, 95,
+       154, 235, 215, 76, 255, 214, 69, 49, 168, 7, 139, 114, 179, 136,
+       194, 245, 143, 143, 208, 228, 91, 106, 112, 102, 234, 247, 23, 65,
+       255, 96, 94, 39, 207, 125, 137, 99, 189, 86, 1, 203, 23, 221, 44,
+       134, 172, 113, 236, 8, 250, 66, 244, 242, 164, 98, 238, 101, 126,
+       78, 193, 139, 195, 237, 52, 58, 106, 144, 24, 186, 161, 141, 34,
+       177, 184, 218, 229, 253, 240, 199, 75, 61, 125, 9, 10, 189, 110,
+       20, 221, 27, 151, 16, 150, 58, 186, 241, 31, 93, 16, 111, 211, 78,
+       206, 215, 2, 208, 52, 218, 111, 197, 188, 239, 143, 91, 208, 119,
+       188, 222, 44, 192, 239, 27, 179, 129, 195, 15, 90, 209, 23, 21,
+       218, 171, 29, 12, 173, 219, 2, 120, 186, 222, 123, 196, 185, 71,
+       175, 73, 248, 39, 60, 158, 39, 96, 230, 59, 151, 129, 130, 11,
+       178, 235, 115, 60, 154, 138, 21, 84, 37, 255, 42, 182, 48, 192,
+       125, 245, 211, 127, 139, 125, 188, 63, 174, 188, 86, 164, 141,
+       179, 215, 149, 191, 107, 114, 247, 235, 93, 153, 251, 215, 76,
+       222, 223, 63, 255, 97, 65, 246, 18, 238, 253, 73, 232, 126, 230,
+       25, 12, 213, 229, 126, 204, 23, 254, 197, 176, 45, 204, 62, 72,
+       167, 132, 47, 190, 208, 245, 144, 221, 122, 189, 50, 194, 191,
+       246, 188, 76, 94, 163, 53, 159, 163, 64, 238, 59, 23, 65, 228,
+       185, 4, 111, 240, 229, 42, 131, 100, 18, 37, 219, 60, 206, 46,
+       127, 205, 211, 86, 237, 85, 30, 112, 10, 107, 121, 33, 153, 249,
+       240, 167, 226, 104, 246, 10, 189, 243, 195, 213, 1, 115, 123, 254,
+       130, 186, 91, 115, 72, 103, 245, 217, 118, 137, 76, 188, 171, 10,
+       158, 166, 180, 206, 185, 149, 64, 206, 43, 32, 213, 115, 217, 32,
+       251, 87, 158, 254, 255, 166, 160, 232, 90, 253, 241, 216, 202, 27,
+       87, 117, 187, 40, 237, 94, 156, 223, 155, 167, 145, 62, 126, 238,
+       243, 31, 95, 152, 235, 215, 77, 254, 222, 34, 25, 47, 136, 189,
+       199, 188, 103, 141, 64, 250, 6, 184, 31, 52, 101, 204, 179, 155,
+       193, 209, 171, 83, 253, 41, 24, 138, 210, 29, 10, 245, 59, 39,
+       100, 145, 211, 205, 237, 248, 202, 143, 243, 169, 26, 156, 222,
+       125, 174, 201, 25, 91, 17, 19, 103, 218, 208, 13, 28, 155, 126,
+       152, 89, 91, 166, 63, 89, 96, 225, 55, 159, 250, 146, 93, 224,
+       246, 162, 155, 29, 151, 228, 110, 189, 151, 221, 140, 184, 117,
+       252, 255, 223, 163, 197, 119, 189, 120, 121, 159, 217, 108, 237,
+       54, 18, 123, 184, 101, 112, 214, 162, 91, 31, 146, 97, 126, 221,
+       149, 239, 204, 178, 37, 221, 210, 235, 235, 133, 55, 173, 124,
+       113, 22, 27, 102, 142, 114, 146, 190, 113, 45, 140, 223, 231, 109,
+       206, 167, 197, 126, 185, 135, 231, 212, 145, 4, 204, 50, 96, 170,
+       131, 55, 167, 45, 213, 244, 191, 19, 174, 221, 197, 70, 237, 151,
+       136, 169, 79, 98, 224, 109, 208, 248, 234, 78, 227, 126, 35, 154,
+       127, 185, 148, 135, 63, 89, 122, 250, 6, 182, 133, 214, 247, 196,
+       42, 204, 237, 121, 179, 227, 18, 67, 107, 28, 27, 249, 199, 99,
+       178, 120, 243, 73, 226, 188, 178, 215, 85, 229, 122, 250, 130, 7,
+       236, 212, 243, 236, 137, 174, 142, 190, 147, 0, 66, 244, 99, 93,
+       91, 255, 75, 59, 91, 114, 92, 75, 226, 44, 30, 223, 36, 156, 249,
+       129, 168, 57, 205, 106, 110, 22, 215, 79, 245, 69, 64, 254, 2, 51,
+       45, 50, 32, 122, 250, 21, 238, 201, 186, 61, 189, 251, 237, 164,
+       0, 119, 138, 240, 232, 0, 86, 107, 229, 118, 102, 239, 16, 20,
+       206, 119, 230, 17, 31, 181, 97, 126, 157, 23, 238, 233, 148, 37,
+       78, 101, 168, 170, 128, 37, 179, 100, 241, 169, 87, 106, 109, 118,
+       54, 255, 50, 85, 78, 126, 199, 25, 13, 182, 97, 126, 168, 23, 239,
+       229, 176, 52, 142, 103, 109, 160, 128, 111, 255, 252, 241, 124,
+       124, 236, 98, 139, 119, 95, 216, 131, 244, 173, 11, 91, 93, 75,
+       191, 93, 212, 253, 250, 8, 103, 251, 168, 219, 201, 197, 63, 243,
+       255, 126, 114, 11, 146, 22, 186, 237, 133, 188, 111, 158, 27, 80,
+       118, 172, 218, 44, 192, 231, 27, 187, 129, 215, 12, 18, 213, 21,
+       59, 218, 202, 28, 12, 169, 139, 2, 74, 186, 254, 118, 132, 185,
+       71, 175, 13, 90, 99, 188, 159, 52, 64, 230, 59, 31, 129, 130, 9,
+       130, 227, 85, 60, 58, 138, 4, 80, 33, 139, 59, 104, 115, 241, 119,
+       143, 250, 86, 109, 160, 114, 131, 175, 29, 53, 164, 238, 187, 23,
+       213, 161, 184, 20, 238, 191, 220, 158, 130, 239, 156, 67, 140,
+       203, 60, 250, 244, 98, 60, 252, 50, 249, 251, 54, 187, 141, 191,
+       215, 63, 167, 245, 255, 141, 164, 68, 162, 194, 215, 223, 127,
+       171, 134, 228, 7, 247, 135, 210, 99, 139, 118, 18, 239, 180, 93,
+       72, 87, 246, 217, 12, 190, 164, 126, 73, 23, 239, 229, 180, 109,
+       230, 38, 60, 170, 196, 111, 159, 249, 245, 175, 96, 193, 193, 61,
+       51, 202, 152, 87, 179, 149, 250, 202, 201, 221, 172, 89, 200, 182,
+       218, 139, 118, 237, 242, 14, 92, 133, 182, 191, 253, 88, 164, 191,
+       120, 192, 145, 207, 17, 206, 216, 19, 242, 148, 255, 201, 198,
+       217, 175, 95, 200, 149, 255, 233, 86, 222, 160, 146, 90, 207, 190,
+       47, 253, 26, 180, 188, 254, 22, 250, 181, 195, 86, 236, 17, 30,
+       240, 125, 106, 201, 33, 153, 217, 250, 132, 98, 110, 255, 10, 191,
+       178, 210, 85, 59, 90, 29, 238, 155, 5, 143, 149, 219, 252, 168,
+       175, 168, 174, 17, 57, 64, 204, 227, 249, 198, 215, 107, 58, 59,
+       18, 64, 202, 245, 44, 30, 207, 76, 156, 115, 129, 160, 71, 161,
+       84, 206, 252, 137, 174, 169, 175, 16, 25, 195, 236, 235, 124, 210,
+       182, 123, 123, 119, 82, 0, 138, 253, 44, 28, 143, 109, 28, 170,
+       169, 128, 139, 23, 107, 197, 118, 114, 239, 51, 84, 206, 95, 246,
+       81, 29, 183, 101, 126, 44, 23, 239, 225, 144, 37, 206, 102, 47,
+       170, 128, 47, 251, 116, 241, 43, 147, 67, 73, 245, 149, 234, 127,
+       71, 65, 124, 230, 40, 33, 190, 228, 94, 10, 146, 156, 151, 186,
+       116, 221, 46, 92, 130, 194, 223, 142, 248, 188, 43, 164, 96, 74,
+       213, 181, 90, 95, 83, 77, 237, 15, 8, 232, 126, 180, 221, 138,
+       146, 148, 158, 58, 222, 215, 31, 93, 145, 111, 219, 78, 250, 150,
+       238, 162, 224, 88, 205, 245, 88, 138, 219, 95, 180, 157, 42, 237,
+       95, 158, 205, 202, 231, 148, 190, 102, 234, 211, 95, 95, 209, 255,
+       211, 205, 94, 198, 238, 224, 228, 97, 141, 123, 93, 140, 3, 247,
+       181, 185, 75, 77, 95, 159, 89, 212, 253, 246, 60, 103, 239, 144,
+       91, 219, 213, 255, 247, 191, 222, 86, 251, 75, 146, 164, 37, 0,
+       94, 101, 169, 136, 218, 103, 111, 202, 160, 214, 254, 237, 60,
+       199, 76, 147, 128, 200, 176, 248, 138, 138, 43, 182, 35, 13, 82,
+       217, 103, 236, 61, 198, 254, 103, 141, 72, 154, 71, 40, 158, 52,
+       228, 238, 181, 191, 225, 217, 137, 17, 255, 179, 252, 138, 218,
+       63, 6, 180, 63, 2, 157, 39, 203, 181, 213, 251, 103, 205, 77, 220,
+       35, 168, 92, 54, 36, 236, 35, 159, 149, 222, 169, 32, 253, 107,
+       92, 142, 195, 87, 142, 245, 223, 127, 98, 196, 32, 41, 31, 90,
+       136, 35, 188, 181, 137, 203, 9, 91, 158, 156, 197, 237, 246, 12,
+       71, 203, 160, 154, 219, 197, 183, 227, 183, 74, 70, 126, 142, 114,
+       237, 55, 18, 218, 250, 85, 32, 246, 211, 75, 43, 180, 229, 126,
+       149, 31, 239, 252, 163, 69, 207, 242, 255, 163, 213, 119, 173,
+       248, 1, 39, 180, 241, 232, 252, 253, 216, 219, 15, 121, 184, 41,
+       142, 61, 220, 38, 207, 155, 215, 21, 150, 42, 99, 208, 239, 92,
+       15, 254, 214, 206, 197, 247, 43, 149, 117, 200, 253, 245, 216,
+       255, 143, 89, 184, 251, 140, 255, 252, 101, 207, 155, 151, 17,
+       150, 43, 98, 213, 111, 88, 143, 254, 150, 204, 245, 255, 203, 217,
+       114, 252, 237, 212, 188, 127, 173, 94, 244, 231, 44, 223, 182,
+       231, 238, 179, 191, 195, 198, 47, 178, 249, 119, 121, 238, 139,
+       87, 244, 229, 255, 42, 177, 98, 202, 125, 209, 218, 104, 75, 69,
+       125, 3, 40, 221, 62, 180, 216, 187, 147, 208, 30, 58, 122, 213,
+       27, 88, 128, 107, 87, 142, 126, 238, 62, 142, 82, 233, 31, 15,
+       202, 250, 77, 32, 250, 79, 11, 11, 52, 196, 106, 133, 95, 249,
+       188, 171, 85, 222, 178, 221, 131, 212, 127, 173, 120, 132, 45,
+       242, 121, 235, 102, 92, 251, 216, 73, 77, 117, 166, 93, 95, 158,
+       244, 126, 217, 151, 254, 215, 178, 124, 245, 70, 253, 34, 228,
+       255, 159, 207, 241, 190, 114, 192, 195, 15, 115, 218, 200, 23,
+       179, 149, 251, 74, 221, 207, 140, 95, 216, 159, 243, 14, 70, 207,
+       242, 154, 86, 141, 255, 191, 223, 28, 23, 63, 113, 132, 134, 203,
+       21, 158, 216, 131, 248, 157, 206, 72, 221, 107, 143, 124, 209,
+       211, 227, 193, 99, 218, 224, 49, 65, 205, 191, 127, 127, 58, 245,
+       230, 207, 236, 126, 180, 178, 95, 172, 91, 159, 29, 177, 109, 105,
+       30, 3, 215, 115, 21, 123, 252, 104, 110, 255, 42, 126, 205, 135,
+       180, 243, 218, 7, 18, 233, 88, 167, 143, 201, 239, 229, 175, 52,
+       168, 10, 175, 139, 86, 130, 104, 227, 107, 195, 90, 43, 202, 253,
+       189, 144, 142, 121, 113, 26, 175, 138, 186, 73, 106, 238, 31, 209,
+       203, 64, 197, 132, 199, 2, 107, 200, 55, 68, 120, 160, 139, 235,
+       76, 167, 54, 157, 211, 233, 139, 25, 55, 47, 124, 142, 96, 201,
+       43, 206, 93, 193, 87, 228, 197, 64, 236, 8, 50, 221, 51, 112, 200,
+       248, 31, 74, 75, 43, 98, 189, 243, 153, 132, 59, 114, 154, 116,
+       106, 218, 221, 98, 236, 23, 214, 94, 119, 53, 72, 222, 231, 25,
+       31, 50, 240, 118, 181, 157, 229, 252, 155, 53, 255, 243, 237, 170,
+       193, 63, 134, 184, 91, 140, 181, 60, 103, 32, 15, 119, 184, 116,
+       170, 103, 4, 215, 115, 8, 17, 149, 92, 108, 42, 96, 240, 217, 5,
+       199, 235, 101, 4, 104, 242, 74, 163, 210, 70, 126, 246, 46, 8,
+       252, 68, 253, 182, 243, 147, 111, 139, 117, 75, 234, 229, 111,
+       195, 104, 247, 135, 202, 146, 248, 222, 131, 101, 248, 109, 10,
+       15, 120, 254, 243, 229, 180, 252, 214, 237, 184, 214, 227, 173,
+       223, 247, 110, 238, 125, 223, 223, 198, 245, 164, 232, 246, 249,
+       238, 131, 134, 253, 57, 223, 43, 83, 107, 195, 118, 151, 251, 20,
+       69, 77, 127, 230, 249, 29, 182, 228, 126, 184, 151, 204, 193, 184,
+       117, 222, 102, 77, 162, 128, 127, 142, 112, 253, 191, 64, 226, 90,
+       141, 209, 208, 200, 223, 85, 165, 151, 74, 200, 255, 236, 217,
+       200, 170, 86, 142, 103, 46, 241, 18, 89, 209, 127, 247, 157, 124,
+       70, 159, 113, 128, 218, 203, 85, 158, 216, 131, 188, 149, 10, 76,
+       215, 235, 175, 188, 89, 215, 255, 71, 67, 170, 240, 51, 89, 207,
+       191, 18, 127, 43, 229, 65, 151, 238, 65, 228, 38, 173, 151, 108,
+       219, 94, 118, 16, 59, 222, 106, 101, 70, 63, 157, 146, 248, 165,
+       64, 76, 46, 254, 196, 141, 208, 241, 251, 54, 104, 79, 234, 13,
+       205, 203, 200, 205, 20, 225, 15, 215, 202, 125, 74, 248, 233, 107,
+       227, 75, 39, 222, 240, 149, 152, 203, 60, 125, 59, 114, 130, 104,
+       233, 184, 124, 108, 137, 116, 175, 66, 5, 108, 40, 164, 177, 224,
+       16, 200, 106, 34, 72, 66, 58, 194, 49, 126, 189, 148, 43, 80, 24,
+       218, 138, 239, 248, 132, 83, 45, 61, 80, 152, 211, 182, 164, 29,
+       138, 57, 87, 191, 129, 68, 252, 30, 174, 108, 251, 176, 207, 219,
+       85, 127, 218, 253, 90, 6, 126, 176, 128, 98, 25, 61, 82, 152, 75,
+       125, 169, 13, 202, 105, 94, 158, 153, 128, 236, 53, 158, 35, 219,
+       144, 155, 220, 1, 127, 218, 15, 74, 22, 130, 74, 242, 247, 100,
+       153, 252, 214, 237, 0, 242, 227, 173, 159, 245, 203, 238, 251,
+       255, 215, 198, 247, 132, 224, 182, 248, 222, 131, 15, 157, 105,
+       143, 95, 104, 114, 225, 46, 187, 122, 208, 237, 37, 214, 163, 143,
+       31, 213, 110, 238, 213, 255, 215, 142, 179, 109, 224, 215, 221,
+       139, 199, 167, 191, 117, 71, 155, 69, 107, 205, 118, 82, 235, 120,
+       116, 68, 86, 166, 89, 79, 183, 96, 126, 253, 23, 237, 225, 148,
+       37, 207, 118, 45, 170, 132, 61, 162, 113, 241, 126, 113, 176, 160,
+       203, 85, 151, 252, 130, 186, 156, 42, 76, 255, 107, 143, 108, 209,
+       219, 227, 64, 67, 186, 208, 241, 193, 207, 191, 55, 127, 189, 243,
+       4, 32, 203, 171, 76, 237, 235, 72, 174, 21, 227, 14, 215, 200,
+       121, 72, 122, 141, 106, 211, 3, 183, 219, 113, 213, 161, 139, 12,
+       132, 11, 101, 160, 0, 157, 27, 253, 48, 172, 121, 55, 188, 9, 90,
+       64, 183, 183, 32, 64, 166, 59, 61, 9, 19, 152, 48, 79, 197, 245,
+       58, 128, 0, 0, 129, 43, 100, 8, 23, 156, 77, 225, 128, 64, 140,
+       22, 224, 11, 166, 192, 33, 203, 200, 161, 106, 2, 0, 39, 194, 216,
+       21, 34, 75, 27, 81, 41, 36, 128, 177, 109, 123, 68, 84, 87, 231,
+       113, 81, 224, 252, 74, 115, 117, 181, 165, 120, 252, 18, 234, 233,
+       178, 52, 110, 55, 8, 165, 32, 103, 186, 118, 236, 131, 219, 123,
+       201, 114, 134, 107, 117, 53, 76, 118, 230, 25, 23, 178, 116, 118,
+       188, 23, 236, 241, 156, 37, 94, 110, 172, 162, 192, 53, 128, 100,
+       249, 155, 250, 106, 187, 118, 149, 187, 116, 20, 76, 85, 183, 189,
+       204, 186, 128, 126, 169, 151, 215, 239, 188, 60, 191, 230, 77,
+       186, 192, 47, 143, 57, 217, 237, 113, 223, 164, 207, 119, 205, 88,
+       8, 238, 189, 78, 95, 42, 51, 139, 120, 229, 206, 235, 13, 231,
+       113, 136, 149, 195, 239, 189, 237, 123, 27, 209, 163, 200, 86,
+       255, 100, 136, 252, 197, 157, 1, 114, 214, 172, 138, 52, 204, 238,
+       171, 55, 201, 67, 158, 82, 229, 36, 58, 94, 130, 13, 152, 235,
+       141, 86, 32, 243, 227, 38, 41, 123, 72, 111, 37, 243, 147, 79,
+       223, 92, 112, 254, 157, 127, 203, 152, 54, 175, 211, 215, 220,
+       139, 199, 103, 135, 247, 135, 158, 114, 102, 18, 131, 241, 112,
+       192, 191, 85, 197, 183, 10, 206, 127, 221, 163, 137, 167, 215, 14,
+       199, 62, 241, 147, 83, 210, 235, 183, 23, 238, 86, 142, 225, 242,
+       91, 173, 217, 112, 192, 207, 85, 101, 147, 142, 206, 239, 239,
+       194, 90, 167, 82, 6, 97, 190, 241, 3, 217, 86, 111, 150, 159, 205,
+       214, 134, 207, 236, 246, 180, 34, 222, 175, 219, 170, 24, 155,
+       111, 104, 253, 129, 151, 99, 21, 127, 246, 101, 14, 255, 42, 95,
+       221, 255, 197, 255, 217, 13, 137, 46, 67, 141, 86, 43, 232, 115,
+       84, 160, 242, 198, 177, 1, 145, 224, 106, 172, 6, 172, 173, 188,
+       69, 78, 4, 44, 178, 128, 111, 136, 112, 136, 96, 0, 22, 156, 108,
+       171, 224, 67, 141, 134, 243, 33, 166, 136, 37, 203, 200, 161, 110,
+       1, 0, 35, 66, 200, 20, 50, 218, 26, 81, 40, 112, 138, 184, 196,
+       116, 111, 23, 27, 210, 120, 69, 6, 245, 2, 107, 73, 60, 129, 88,
+       144, 135, 106, 104, 182, 89, 159, 211, 201, 161, 21, 119, 143,
+       124, 130, 86, 72, 126, 233, 46, 106, 250, 66, 109, 181, 243, 3,
+       143, 139, 52, 75, 234, 197, 127, 211, 8, 251, 143, 228, 154, 250,
+       219, 197, 229, 171, 101, 2, 59, 37, 112, 233, 119, 159, 250, 127,
+       77, 160, 254, 202, 59, 13, 20, 180, 126, 185, 23, 189, 204, 186,
+       85, 220, 119, 221, 128, 192, 127, 142, 88, 138, 142, 251, 44, 154,
+       207, 253, 191, 212, 205, 94, 29, 167, 173, 206, 239, 206, 46, 35,
+       206, 86, 215, 17, 62, 241, 119, 81, 174, 171, 115, 95, 141, 215,
+       188, 95, 121, 163, 230, 100, 183, 182, 24, 79, 252, 119, 24, 54,
+       175, 89, 237, 211, 135, 163, 185, 174, 112, 226, 245, 135, 190,
+       128, 201, 91, 252, 251, 247, 159, 209, 247, 213, 108, 207, 183,
+       121, 95, 123, 86, 107, 106, 31, 221, 255, 195, 132, 166, 253, 252,
+       92, 234, 46, 255, 246, 192, 237, 241, 202, 85, 158, 205, 245, 247,
+       151, 224, 126, 183, 115, 31, 26, 83, 105, 111, 92, 107, 35, 211,
+       53, 154, 242, 220, 63, 231, 111, 239, 255, 193, 167, 241, 197, 11,
+       102, 2, 147, 140, 76, 96, 224, 65, 169, 16, 243, 18, 128, 136,
+       100, 75, 232, 173, 42, 161, 8, 115, 194, 192, 20, 48, 218, 15,
+       197, 40, 121, 130, 179, 93, 79, 5, 214, 87, 238, 113, 84, 224,
+       122, 70, 81, 56, 181, 165, 58, 228, 18, 239, 229, 184, 53, 238,
+       36, 14, 167, 128, 109, 190, 249, 156, 147, 24, 111, 253, 18, 192,
+       185, 98, 180, 192, 82, 227, 53, 158, 176, 97, 110, 57, 23, 133,
+       225, 156, 38, 79, 68, 40, 186, 128, 37, 128, 49, 233, 61, 221, 69,
+       5, 245, 11, 71, 188, 81, 226, 234, 78, 83, 113, 153, 181, 24, 204,
+       16, 110, 233, 178, 93, 14, 56, 78, 5, 20, 111, 255, 210, 52, 157,
+       73, 106, 229, 87, 82, 127, 120, 101, 196, 255, 130, 89, 95, 179,
+       100, 126, 252, 21, 238, 200, 178, 53, 142, 243, 237, 167, 129, 39,
+       191, 116, 224, 204, 93, 50, 194, 205, 249, 55, 148, 237, 94, 29,
+       4, 141, 215, 107, 231, 35, 18, 223, 90, 83, 5, 62, 243, 231, 217,
+       142, 169, 18, 223, 141, 119, 206, 237, 216, 246, 190, 97, 159,
+       236, 155, 134, 157, 153, 124, 255, 127, 131, 183, 115, 221, 227,
+       112, 71, 42, 239, 248, 31, 15, 191, 148, 115, 175, 33, 194, 66,
+       150, 243, 228, 4, 232, 69, 141, 187, 115, 83, 140, 186, 116, 75,
+       232, 55, 63, 145, 48, 253, 130, 224, 21, 58, 250, 194, 137, 25,
+       241, 131, 155, 79, 74, 169, 54, 154, 186, 86, 236, 76, 94, 231,
+       173, 136, 179, 64, 110, 41, 143, 213, 230, 185, 4, 238, 242, 101,
+       170, 129, 37, 140, 57, 201, 58, 207, 80, 237, 87, 135, 206, 120,
+       77, 160, 248, 79, 75, 75, 52, 148, 122, 173, 23, 239, 204, 178,
+       85, 221, 178, 253, 131, 208, 127, 174, 122, 132, 206, 237, 146,
+       226, 239, 113, 159, 236, 138, 150, 157, 10, 92, 255, 235, 134,
+       135, 115, 219, 107, 97, 3, 170, 242, 120, 209, 47, 191, 22, 255,
+       175, 97, 150, 207, 252, 246, 180, 34, 94, 189, 91, 151, 25, 211,
+       111, 233, 63, 129, 151, 115, 21, 103, 252, 233, 14, 239, 170, 222,
+       221, 247, 188, 255, 216, 5, 60, 73, 98, 238, 23, 66, 94, 120, 117,
+       132, 255, 3, 107, 107, 61, 84, 122, 228, 23, 234, 72, 179, 13,
+       236, 243, 237, 163, 129, 103, 187, 116, 10, 39, 0, 245, 247, 100,
+       42, 248, 24, 91, 179, 49, 219, 207, 61, 93, 190, 159, 149, 55,
+       157, 135, 116, 221, 192, 135, 222, 219, 182, 239, 239, 67, 133,
+       189, 127, 106, 130, 247, 125, 183, 87, 28, 78, 189, 255, 30, 28,
+       163, 169, 108, 138, 158, 102, 253, 191, 116, 162, 246, 69, 186,
+       177, 239, 221, 220, 247, 189, 222, 197, 243, 244, 38, 238, 151,
+       81, 127, 122, 118, 11, 43, 148, 155, 237, 206, 5, 146, 189, 252,
+       73, 162, 46, 203, 244, 196, 239, 216, 248, 153, 245, 217, 31, 100,
+       13, 78, 71, 184, 225, 216, 162, 8, 83, 241, 49, 115, 160, 196,
+       120, 106, 73, 35, 186, 12, 251, 168, 69, 28, 72, 58, 114, 42, 254,
+       33, 234, 68, 93, 86, 218, 81, 225, 132, 247, 10, 73, 217, 53, 50,
+       120, 180, 215, 251, 140, 163, 180, 202, 115, 105, 131, 141, 103,
+       167, 126, 130, 151, 84, 103, 175, 4, 6, 239, 248, 4, 66, 211, 199,
+       81, 107, 185, 73, 124, 196, 59, 239, 233, 149, 29, 255, 48, 42,
+       235, 132, 61, 251, 112, 112, 18, 139, 238, 164, 54, 131, 191, 226,
+       134, 172, 218, 163, 109, 238, 179, 64, 110, 247, 175, 199, 200,
+       139, 14, 253, 248, 7, 175, 129, 53, 252, 53, 91, 58, 121, 107,
+       252, 83, 195, 23, 71, 150, 132, 200, 171, 47, 151, 33, 80, 110,
+       185, 131, 192, 74, 155, 48, 63, 241, 229, 10, 51, 49, 24, 39, 250,
+       206, 30, 157, 243, 168, 104, 24, 18, 168, 183, 130, 253, 157, 55,
+       65, 219, 135, 87, 253, 17, 49, 77, 211, 160, 201, 243, 126, 215,
+       136, 113, 13, 115, 210, 157, 173, 254, 153, 230, 77, 175, 147,
+       210, 138, 16, 244, 247, 81, 109, 213, 255, 57, 141, 121, 204, 187,
+       255, 233, 190, 223, 92, 136, 112, 165, 122, 2, 144, 244, 216, 252,
+       133, 248, 235, 155, 19, 176, 243, 140, 63, 124, 139, 207, 147, 23,
+       145, 178, 74, 66, 213, 14, 90, 222, 238, 158, 140, 241, 129, 67,
+       56, 254, 244, 126, 150, 89, 18, 187, 217, 48, 169, 188, 159, 246,
+       57, 134, 189, 181, 145, 150, 75, 162, 220, 155, 90, 91, 250, 134,
+       132, 103, 95, 220, 95, 42, 138, 229, 116, 183, 87, 32, 79, 253,
+       247, 30, 55, 170, 233, 236, 146, 158, 226, 249, 47, 49, 226, 243,
+       165, 186, 139, 219, 93, 173, 243, 204, 253, 56, 210, 205, 249,
+       255, 148, 233, 94, 29, 28, 189, 215, 107, 166, 35, 99, 206, 90,
+       83, 1, 190, 242, 231, 209, 142, 41, 150, 95, 141, 242, 182, 222,
+       205, 247, 134, 98, 111, 183, 17, 127, 127, 119, 73, 43, 158, 79,
+       107, 198, 5, 130, 61, 252, 41, 226, 46, 254, 244, 199, 175, 249,
+       244, 95, 8, 150, 247, 85, 228, 118, 244, 183, 116, 251, 126, 118,
+       25, 61, 156, 235, 109, 86, 167, 152, 177, 248, 33, 224, 110, 235,
+       246, 197, 239, 241, 252, 155, 6, 220, 229, 247, 151, 236, 110,
+       183, 123, 251, 91, 86, 239, 121, 93, 143, 163, 195, 53, 147, 179,
+       248, 29, 227, 47, 222, 221, 198, 175, 245, 208, 31, 188, 129, 94,
+       233, 85, 199, 96, 89, 23, 57, 247, 3, 83, 219, 40, 72, 120, 152,
+       7, 248, 26, 183, 8, 208, 83, 201, 163, 69, 51, 138, 124, 130, 167,
+       132, 208, 243, 245, 41, 248, 67, 27, 17, 49, 214, 140, 42, 92,
+       141, 239, 139, 23, 145, 51, 122, 84, 194, 28, 30, 218, 106, 157,
+       200, 203, 133, 66, 8, 254, 244, 118, 132, 249, 7, 187, 153, 176,
+       163, 172, 191, 245, 91, 230, 179, 63, 149, 162, 105, 134, 233,
+       158, 62, 94, 187, 132, 128, 97, 15, 253, 94, 73, 131, 244, 126,
+       199, 215, 89, 111, 188, 126, 26, 54, 135, 252, 109, 142, 150, 174,
+       253, 191, 117, 226, 52, 13, 182, 212, 219, 221, 254, 253, 78, 7,
+       238, 197, 164, 50, 172, 31, 236, 191, 215, 114, 200, 42, 190, 239,
+       127, 86, 190, 184, 144, 241, 165, 192, 14, 63, 247, 199, 135, 244,
+       253, 37, 118, 9, 128, 40, 141, 43, 198, 200, 7, 178, 162, 78, 66,
+       232, 69, 158, 249, 196, 110, 115, 29, 99, 219, 16, 152, 182, 193,
+       62, 249, 123, 88, 4, 198, 224, 237, 88, 75, 85, 152, 204, 139,
+       247, 128, 155, 12, 204, 127, 11, 207, 81, 251, 213, 166, 103, 186,
+       241, 27, 26, 223, 63, 213, 53, 37, 86, 94, 221, 94, 190, 178, 210,
+       62, 246, 148, 24, 222, 227, 77, 247, 161, 193, 103, 247, 191, 226,
+       96, 139, 14, 253, 250, 227, 238, 207, 183, 245, 173, 19, 1, 121,
+       27, 248, 50, 199, 63, 214, 223, 136, 124, 64, 60, 147, 33, 48,
+       166, 59, 22, 64, 67, 137, 50, 125, 225, 156, 33, 42, 24, 16, 3,
+       187, 149, 75, 78, 164, 32, 130, 109, 112, 132, 132, 214, 230, 209,
+       195, 179, 67, 102, 229, 12, 238, 236, 197, 5, 12, 224, 169, 239,
+       144, 44, 184, 41, 0, 194, 180, 133, 154, 137, 236, 21, 143, 187,
+       95, 0, 29, 172, 247, 74, 95, 129, 83, 233, 16, 50, 77, 154, 243,
+       137, 114, 94, 251, 146, 84, 133, 91, 135, 205, 151, 246, 145, 164,
+       79, 167, 51, 19, 138, 16, 240, 115, 41, 111, 217, 243, 57, 158,
+       122, 206, 59, 231, 169, 190, 223, 64, 128, 112, 161, 40, 166, 175,
+       204, 223, 252, 130, 222, 189, 219, 151, 121, 247, 225, 233, 94, 3,
+       223, 111, 165, 247, 246, 248, 78, 255, 110, 31, 207, 197, 221,
+       251, 216, 129, 66, 138, 218, 212, 124, 160, 248, 167, 191, 19,
+       178, 147, 172, 170, 52, 66, 239, 163, 127, 129, 34, 73, 2, 235,
+       220, 62, 126, 139, 132, 208, 105, 9, 35, 16, 245, 252, 124, 143,
+       248, 27, 91, 193, 112, 235, 237, 255, 53, 172, 222, 189, 55, 149,
+       135, 234, 82, 221, 142, 254, 219, 138, 159, 172, 81, 159, 143,
+       223, 42, 138, 237, 253, 183, 213, 237, 94, 157, 183, 173, 142,
+       187, 228, 111, 162, 206, 199, 247, 33, 62, 226, 247, 81, 170, 235,
+       30, 95, 253, 215, 180, 31, 105, 130, 246, 102, 87, 247, 57, 79,
+       255, 247, 18, 54, 167, 89, 237, 215, 134, 162, 249, 190, 113, 234,
+       240, 167, 246, 130, 249, 89, 228, 123, 70, 30, 166, 150, 172, 98,
+       145, 3, 152, 158, 223, 115, 204, 252, 183, 111, 195, 117, 189, 3,
+       176, 193, 235, 200, 128, 50, 251, 147, 132, 111, 53, 103, 198, 18,
+       182, 212, 172, 34, 177, 3, 249, 159, 151, 112, 204, 242, 141, 111,
+       193, 53, 236, 176, 56, 197, 227, 194, 136, 242, 255, 207, 130, 96,
+       181, 39, 239, 252, 112, 66, 123, 221, 95, 181, 169, 118, 53, 189,
+       40, 15, 222, 183, 167, 209, 213, 254, 231, 84, 252, 229, 127, 89,
+       140, 243, 39, 150, 206, 93, 86, 221, 158, 252, 146, 194, 55, 230,
+       172, 21, 206, 34, 124, 247, 33, 114, 230, 119, 185, 210, 80, 201,
+       58, 109, 249, 163, 110, 198, 160, 113, 165, 59, 214, 236, 183,
+       246, 150, 226, 79, 174, 187, 155, 75, 18, 245, 243, 121, 107, 179,
+       255, 53, 243, 106, 220, 171, 127, 169, 182, 223, 197, 164, 115,
+       165, 42, 189, 95, 27, 131, 135, 124, 167, 247, 28, 79, 191, 118,
+       158, 52, 139, 173, 109, 210, 158, 35, 185, 188, 113, 226, 245, 7,
+       190, 144, 203, 89, 213, 113, 183, 86, 87, 160, 228, 38, 69, 119,
+       85, 235, 122, 247, 2, 62, 162, 221, 221, 143, 22, 37, 189, 246,
+       113, 138, 176, 218, 246, 134, 237, 221, 248, 85, 183, 101, 103,
+       194, 198, 79, 239, 97, 73, 230, 145, 154, 89, 76, 191, 37, 126,
+       149, 23, 239, 241, 183, 60, 206, 49, 74, 139, 244, 101, 175, 211,
+       244, 221, 70, 14, 165, 32, 54, 104, 56, 164, 250, 150, 244, 95, 2,
+       179, 123, 247, 197, 124, 238, 237, 213, 5, 12, 210, 235, 235, 132,
+       40, 177, 41, 17, 203, 20, 149, 117, 171, 54, 56, 31, 187, 243, 35,
+       212, 157, 54, 68, 255, 135, 23, 248, 132, 181, 68, 243, 192, 135,
+       251, 91, 22, 138, 100, 137, 84, 167, 173, 192, 151, 244, 57, 238,
+       175, 27, 242, 57, 223, 239, 104, 223, 157, 219, 235, 130, 239,
+       255, 126, 92, 255, 172, 86, 223, 100, 220, 127, 218, 148, 166,
+       159, 204, 191, 214, 161, 190, 175, 26, 151, 121, 247, 225, 104,
+       15, 9, 95, 235, 130, 183, 126, 250, 94, 239, 108, 7, 223, 101,
+       253, 251, 216, 144, 35, 140, 208, 255, 244, 9, 232, 234, 91, 147,
+       240, 198, 237, 106, 61, 141, 255, 235, 23, 161, 163, 122, 90, 223,
+       156, 222, 223, 42, 157, 104, 73, 140, 82, 128, 252, 244, 52, 10,
+       120, 43, 123, 133, 178, 3, 239, 107, 28, 112, 183, 181, 61, 173,
+       128, 233, 133, 221, 154, 254, 223, 215, 38, 160, 97, 15, 124, 107,
+       224, 224, 157, 26, 70, 217, 67, 176, 172, 139, 75, 9, 85, 222,
+       121, 220, 141, 248, 92, 115, 205, 128, 251, 205, 133, 125, 167,
+       190, 218, 2, 90, 8, 94, 237, 50, 160, 184, 19, 44, 1, 255, 130,
+       185, 59, 181, 232, 102, 55, 61, 136, 16, 136, 19, 221, 194, 255,
+       178, 192, 190, 131, 105, 41, 31, 22, 111, 69, 150, 62, 250, 115,
+       117, 230, 95, 247, 89, 44, 151, 175, 55, 4, 150, 62, 181, 240, 61,
+       206, 46, 75, 97, 196, 239, 229, 121, 213, 165, 233, 123, 78, 84,
+       213, 231, 244, 83, 136, 124, 72, 48, 208, 244, 52, 152, 250, 2,
+       74, 199, 186, 168, 47, 63, 12, 36, 104, 67, 154, 102, 173, 213,
+       74, 78, 60, 60, 146, 78, 48, 228, 64, 215, 229, 211, 194, 179,
+       115, 66, 228, 124, 238, 237, 133, 7, 28, 226, 235, 235, 144, 28,
+       177, 120, 16, 181, 102, 21, 251, 172, 23, 198, 232, 196, 190, 177,
+       82, 195, 88, 173, 139, 217, 68, 108, 123, 232, 103, 107, 184, 177,
+       203, 103, 54, 81, 123, 80, 161, 148, 207, 222, 255, 182, 162, 183,
+       231, 30, 31, 251, 179, 100, 107, 171, 73, 123, 115, 15, 242, 114,
+       236, 9, 111, 248, 166, 255, 197, 181, 121, 165, 35, 212, 204, 151,
+       214, 148, 226, 39, 166, 122, 159, 139, 50, 246, 119, 41, 105, 241,
+       246, 44, 146, 122, 253, 40, 103, 249, 166, 255, 69, 128, 113, 245,
+       43, 197, 140, 149, 214, 145, 238, 103, 174, 122, 210, 11, 16, 246,
+       114, 9, 241, 49, 231, 56, 234, 113, 77, 58, 111, 189, 174, 95, 68,
+       128, 115, 131, 32, 166, 207, 204, 151, 244, 162, 206, 174, 26,
+       183, 120, 246, 96, 232, 253, 129, 219, 111, 36, 227, 112, 248,
+       207, 255, 44, 22, 255, 196, 149, 251, 216, 137, 22, 131, 218, 245,
+       244, 10, 254, 237, 255, 135, 179, 195, 239, 107, 60, 64, 251, 227,
+       31, 161, 120, 235, 8, 207, 190, 190, 207, 197, 133, 168, 105, 130,
+       35, 160, 245, 252, 100, 10, 216, 41, 91, 178, 176, 203, 253, 255,
+       84, 59, 223, 241, 55, 173, 137, 98, 214, 201, 158, 218, 223, 190,
+       79, 172, 82, 149, 43, 48, 245, 244, 124, 22, 248, 25, 91, 177,
+       176, 235, 237, 255, 253, 174, 222, 189, 183, 189, 143, 226, 215,
+       200, 142, 222, 223, 190, 143, 172, 80, 151, 167, 22, 87, 44, 226,
+       35, 188, 89, 25, 78, 113, 247, 77, 108, 175, 13, 222, 61, 134, 38,
+       165, 182, 100, 206, 4, 50, 106, 130, 77, 237, 171, 213, 142, 22,
+       87, 191, 102, 43, 188, 81, 29, 202, 115, 247, 205, 108, 161, 137,
+       222, 49, 135, 39, 181, 244, 69, 202, 4, 114, 107, 130, 221, 237,
+       5, 209, 40, 185, 57, 216, 221, 245, 81, 206, 79, 65, 108, 8, 48,
+       157, 100, 48, 217, 186, 19, 24, 19, 58, 114, 181, 79, 157, 144,
+       107, 210, 9, 94, 234, 121, 33, 241, 229, 213, 26, 108, 21, 97,
+       164, 54, 10, 155, 41, 209, 242, 50, 172, 108, 60, 216, 248, 245,
+       136, 254, 233, 37, 49, 103, 174, 218, 8, 14, 24, 57, 203, 174,
+       165, 185, 17, 142, 65, 223, 227, 189, 31, 165, 104, 198, 51, 63,
+       156, 146, 128, 99, 240, 199, 221, 186, 130, 150, 195, 37, 113, 41,
+       237, 69, 73, 52, 155, 106, 166, 87, 33, 122, 204, 227, 8, 148,
+       180, 72, 194, 78, 92, 207, 184, 101, 63, 46, 221, 180, 80, 119,
+       157, 88, 12, 150, 237, 157, 183, 150, 194, 79, 175, 187, 151, 11,
+       19, 229, 227, 125, 203, 179, 239, 33, 243, 114, 220, 155, 127,
+       168, 166, 207, 69, 164, 115, 189, 10, 19, 129, 254, 253, 52, 146,
+       120, 57, 123, 153, 53, 163, 109, 255, 252, 101, 182, 153, 181,
+       173, 134, 96, 15, 221, 202, 251, 203, 198, 55, 164, 97, 5, 19, 86,
+       105, 173, 46, 97, 156, 158, 8, 98, 152, 239, 221, 62, 153, 170,
+       222, 81, 191, 165, 141, 0, 117, 192, 164, 79, 250, 148, 61, 251,
+       21, 249, 195, 52, 183, 53, 163, 60, 172, 31, 251, 211, 34, 92,
+       140, 62, 69, 191, 167, 71, 120, 29, 181, 76, 183, 194, 143, 122,
+       95, 70, 202, 68, 131, 92, 173, 207, 196, 159, 245, 50, 166, 254,
+       18, 150, 124, 246, 237, 98, 171, 133, 91, 98, 134, 239, 116, 122,
+       76, 239, 108, 7, 239, 237, 151, 127, 185, 141, 39, 132, 208, 249,
+       244, 1, 238, 232, 91, 147, 240, 198, 237, 107, 125, 141, 255, 235,
+       23, 185, 177, 98, 94, 220, 190, 222, 223, 124, 157, 248, 105, 140,
+       43, 193, 107, 202, 85, 215, 255, 101, 7, 65, 109, 2, 24, 221, 54,
+       176, 248, 168, 147, 136, 91, 186, 56, 149, 119, 77, 128, 109, 115,
+       14, 244, 226, 89, 177, 250, 101, 48, 158, 121, 21, 105, 9, 78, 96,
+       159, 154, 144, 114, 166, 189, 92, 89, 149, 152, 164, 76, 230, 233,
+       34, 192, 44, 130, 131, 33, 93, 145, 187, 234, 178, 148, 59, 21,
+       237, 73, 95, 96, 157, 150, 168, 112, 166, 61, 61, 153, 147, 153,
+       176, 192, 251, 253, 42, 194, 172, 130, 161, 49, 9, 160, 151, 65,
+       37, 158, 233, 55, 108, 169, 66, 64, 156, 51, 212, 230, 161, 44,
+       50, 24, 17, 216, 145, 196, 13, 254, 126, 64, 138, 0, 65, 169, 253,
+       207, 76, 63, 14, 219, 206, 160, 80, 64, 179, 202, 227, 104, 148,
+       227, 76, 230, 236, 231, 237, 234, 79, 189, 166, 235, 225, 17, 125,
+       171, 88, 12, 38, 207, 204, 158, 212, 98, 207, 189, 90, 247, 25,
+       86, 224, 232, 127, 129, 91, 111, 32, 107, 113, 232, 222, 255, 44,
+       22, 221, 116, 157, 123, 218, 128, 22, 131, 254, 246, 244, 8, 254,
+       233, 255, 23, 179, 131, 239, 107, 60, 65, 251, 195, 31, 163, 122,
+       235, 12, 239, 190, 190, 207, 197, 133, 168, 105, 128, 27, 144,
+       126, 236, 46, 22, 216, 57, 79, 249, 84, 227, 157, 159, 182, 37,
+       190, 189, 181, 141, 132, 248, 167, 221, 203, 251, 251, 198, 23,
+       164, 41, 119, 43, 143, 97, 91, 213, 181, 235, 255, 95, 73, 124,
+       198, 168, 236, 180, 164, 93, 138, 146, 157, 147, 186, 118, 247,
+       13, 28, 146, 202, 87, 142, 244, 252, 57, 33, 105, 69, 82, 83, 203,
+       121, 32, 224, 191, 206, 83, 7, 212, 176, 58, 140, 84, 252, 217,
+       154, 117, 12, 126, 141, 165, 180, 109, 162, 82, 240, 181, 204,
+       159, 183, 131, 102, 23, 167, 51, 247, 234, 17, 86, 54, 43, 255,
+       193, 215, 160, 22, 121, 252, 57, 34, 185, 182, 86, 66, 128, 121,
+       164, 126, 45, 190, 140, 150, 213, 126, 231, 189, 90, 246, 45, 30,
+       250, 100, 75, 33, 25, 226, 130, 163, 117, 112, 120, 127, 109, 7,
+       197, 117, 219, 127, 222, 208, 150, 207, 158, 182, 159, 194, 79,
+       172, 155, 158, 18, 6, 237, 226, 123, 205, 179, 111, 37, 227, 113,
+       200, 138, 127, 168, 182, 127, 197, 168, 115, 41, 9, 35, 128, 244,
+       252, 116, 19, 248, 123, 91, 160, 176, 227, 237, 255, 180, 133,
+       254, 181, 23, 189, 176, 106, 70, 221, 158, 223, 223, 238, 159,
+       172, 105, 141, 91, 48, 247, 244, 62, 158, 88, 24, 123, 232, 118,
+       163, 127, 223, 214, 116, 182, 189, 181, 157, 140, 240, 167, 220,
+       202, 217, 41, 130, 38, 132, 71, 127, 43, 150, 99, 154, 87, 177,
+       168, 207, 95, 65, 88, 231, 40, 204, 190, 236, 127, 139, 147, 157,
+       151, 58, 102, 247, 30, 92, 154, 235, 223, 140, 248, 220, 39, 153,
+       99, 194, 213, 149, 171, 241, 79, 65, 93, 198, 8, 204, 244, 228,
+       124, 186, 18, 223, 215, 186, 60, 244, 63, 28, 138, 234, 31, 143,
+       241, 244, 9, 11, 135, 85, 164, 158, 224, 19, 228, 184, 114, 100,
+       179, 32, 213, 238, 200, 100, 36, 24, 157, 248, 225, 8, 12, 250,
+       247, 0, 200, 232, 80, 173, 253, 232, 129, 35, 117, 77, 71, 148,
+       83, 232, 35, 76, 251, 64, 217, 148, 17, 236, 132, 95, 235, 116,
+       221, 186, 172, 221, 37, 52, 106, 191, 218, 56, 195, 252, 189, 19,
+       232, 173, 165, 143, 222, 251, 2, 28, 148, 180, 212, 43, 135, 87,
+       122, 21, 179, 108, 187, 115, 13, 26, 127, 118, 200, 88, 129, 125,
+       189, 188, 141, 147, 209, 126, 151, 230, 50, 247, 173, 28, 122, 52,
+       75, 59, 253, 206, 128, 22, 61, 254, 121, 98, 253, 7, 85, 100, 200,
+       125, 158, 252, 173, 223, 136, 159, 213, 245, 167, 191, 26, 222,
+       61, 55, 232, 100, 171, 133, 89, 234, 130, 174, 241, 106, 124, 255,
+       109, 7, 255, 109, 155, 127, 221, 241, 38, 134, 240, 245, 244, 3,
+       232, 235, 91, 131, 184, 198, 237, 107, 125, 133, 255, 233, 23,
+       185, 179, 98, 94, 223, 190, 222, 207, 174, 157, 232, 105, 137, 83,
+       128, 254, 244, 52, 26, 216, 40, 123, 133, 182, 163, 239, 255, 245,
+       112, 182, 241, 61, 173, 140, 97, 38, 205, 154, 255, 223, 147, 150,
+       164, 97, 79, 42, 114, 226, 144, 231, 177, 188, 71, 31, 143, 92,
+       255, 40, 170, 255, 140, 255, 171, 147, 149, 134, 218, 6, 226, 22,
+       94, 158, 171, 159, 220, 189, 223, 170, 251, 226, 150, 215, 145,
+       188, 199, 155, 213, 84, 175, 40, 172, 246, 142, 174, 107, 179,
+       213, 214, 90, 166, 225, 62, 84, 156, 235, 135, 92, 255, 207, 139,
+       182, 41, 154, 125, 253, 185, 87, 30, 125, 85, 191, 156, 156, 122,
+       0, 141, 11, 147, 21, 183, 46, 116, 151, 205, 21, 58, 254, 156, 12,
+       157, 223, 137, 148, 188, 209, 236, 45, 173, 159, 94, 243, 6, 28,
+       156, 48, 218, 111, 7, 70, 122, 29, 179, 124, 255, 114, 77, 27, 95,
+       116, 220, 120, 137, 184, 141, 223, 137, 159, 149, 244, 183, 247,
+       20, 94, 220, 183, 248, 118, 171, 237, 125, 226, 134, 230, 247,
+       236, 120, 239, 109, 7, 255, 197, 219, 127, 173, 243, 36, 143, 204,
+       223, 213, 226, 206, 173, 82, 151, 57, 86, 224, 233, 93, 1, 217,
+       111, 33, 163, 113, 232, 219, 255, 44, 22, 221, 69, 221, 122, 216,
+       128, 22, 138, 250, 244, 52, 8, 254, 233, 255, 150, 178, 130, 237,
+       107, 60, 65, 255, 227, 31, 171, 232, 99, 12, 207, 190, 222, 223,
+       197, 149, 168, 105, 8, 162, 130, 234, 154, 127, 209, 184, 77, 159,
+       29, 149, 191, 40, 204, 126, 204, 239, 171, 183, 149, 150, 47, 46,
+       245, 30, 87, 154, 251, 151, 12, 189, 207, 141, 148, 228, 81, 133,
+       47, 237, 159, 86, 115, 70, 20, 217, 33, 90, 111, 5, 70, 59, 28,
+       177, 124, 125, 146, 79, 190, 215, 100, 222, 248, 209, 176, 66,
+       211, 23, 142, 46, 192, 149, 109, 140, 64, 200, 103, 228, 220, 44,
+       69, 204, 19, 43, 97, 211, 43, 83, 221, 176, 50, 218, 90, 28, 10,
+       181, 59, 221, 223, 171, 150, 177, 124, 55, 182, 180, 78, 158, 119,
+       250, 118, 171, 239, 117, 226, 158, 226, 253, 205, 56, 110, 250,
+       39, 247, 211, 138, 127, 173, 115, 214, 238, 156, 182, 155, 194,
+       79, 172, 27, 150, 0, 82, 237, 226, 89, 73, 51, 111, 45, 235, 113,
+       204, 154, 127, 169, 166, 223, 85, 164, 112, 41, 8, 34, 177, 106,
+       154, 95, 241, 184, 69, 143, 85, 149, 179, 44, 206, 126, 76, 238,
+       187, 147, 145, 22, 11, 46, 245, 19, 80, 154, 235, 23, 14, 189,
+       222, 186, 57, 126, 218, 75, 241, 152, 71, 143, 85, 221, 183, 44,
+       222, 126, 228, 238, 187, 151, 145, 30, 11, 50, 241, 19, 89, 154,
+       235, 23, 6, 173, 223, 154, 28, 118, 218, 63, 212, 153, 119, 221,
+       95, 149, 151, 44, 188, 54, 239, 230, 51, 223, 5, 181, 239, 48,
+       238, 123, 123, 90, 219, 151, 12, 125, 95, 11, 177, 32, 17, 189,
+       253, 185, 95, 31, 253, 93, 53, 156, 188, 214, 164, 143, 59, 151,
+       21, 151, 56, 115, 215, 79, 93, 188, 231, 222, 12, 157, 255, 139,
+       151, 41, 153, 186, 229, 57, 59, 30, 125, 21, 247, 156, 247, 242,
+       96, 151, 59, 31, 149, 179, 8, 111, 215, 204, 5, 187, 252, 156,
+       140, 129, 241, 253, 215, 236, 101, 132, 126, 199, 190, 80, 254,
+       190, 46, 211, 32, 219, 35, 89, 198, 236, 239, 249, 114, 237, 42,
+       236, 201, 229, 244, 101, 249, 220, 120, 127, 176, 244, 64, 141,
+       55, 92, 154, 71, 242, 140, 78, 74, 120, 95, 174, 217, 196, 248,
+       63, 157, 101, 251, 210, 27, 95, 197, 126, 251, 255, 90, 6, 32,
+       211, 12, 138, 62, 193, 149, 237, 196, 28, 216, 103, 224, 72, 174,
+       65, 200, 2, 14, 97, 94, 43, 67, 93, 48, 32, 186, 223, 85, 10, 244,
+       91, 25, 213, 23, 169, 179, 143, 148, 167, 140, 65, 74, 132, 223,
+       126, 40, 224, 214, 115, 10, 101, 85, 136, 84, 157, 169, 229, 14,
+       82, 28, 24, 129, 152, 172, 159, 136, 151, 213, 244, 167, 255, 18,
+       222, 125, 118, 120, 116, 43, 137, 89, 234, 134, 163, 245, 122,
+       122, 239, 109, 135, 255, 229, 219, 127, 220, 211, 39, 129, 241,
+       231, 116, 11, 238, 233, 75, 162, 248, 202, 255, 107, 29, 128, 255,
+       251, 23, 175, 201, 50, 92, 255, 188, 222, 143, 160, 157, 250, 65,
+       140, 138, 61, 122, 218, 79, 245, 185, 87, 237, 77, 189, 23, 44,
+       158, 54, 229, 166, 179, 223, 129, 183, 43, 50, 251, 115, 89, 26,
+       139, 87, 68, 237, 223, 234, 158, 102, 156, 109, 94, 217, 119, 185,
+       94, 151, 181, 140, 190, 182, 255, 199, 177, 223, 37, 245, 205, 48,
+       206, 219, 123, 218, 211, 22, 44, 61, 95, 203, 223, 62, 109, 59,
+       212, 29, 63, 165, 76, 222, 164, 189, 151, 162, 244, 70, 51, 189,
+       140, 227, 141, 51, 159, 227, 245, 58, 154, 58, 132, 173, 123, 41,
+       251, 8, 179, 242, 149, 183, 244, 22, 77, 124, 167, 57, 132, 226,
+       192, 108, 234, 134, 87, 215, 186, 108, 191, 124, 5, 54, 224, 89,
+       158, 172, 221, 5, 251, 33, 159, 209, 221, 38, 244, 199, 76, 125,
+       199, 225, 196, 230, 100, 124, 234, 134, 222, 199, 56, 190, 255,
+       47, 77, 167, 234, 59, 191, 213, 253, 156, 223, 138, 159, 149, 244,
+       183, 247, 150, 222, 252, 119, 248, 116, 171, 205, 125, 98, 134,
+       226, 241, 237, 56, 239, 105, 7, 247, 197, 219, 127, 236, 243, 220,
+       222, 156, 150, 149, 254, 103, 190, 122, 222, 23, 118, 126, 102,
+       139, 221, 49, 231, 172, 242, 249, 92, 170, 111, 184, 167, 255,
+       197, 168, 115, 173, 113, 36, 143, 204, 151, 212, 194, 199, 173,
+       90, 183, 57, 214, 224, 232, 125, 129, 217, 110, 32, 35, 113, 248,
+       90, 127, 40, 22, 221, 68, 221, 122, 218, 128, 182, 207, 122, 231,
+       180, 10, 254, 225, 109, 132, 186, 195, 75, 107, 60, 65, 250, 193,
+       31, 243, 248, 161, 13, 238, 186, 254, 143, 199, 101, 170, 248, 7,
+       231, 1, 245, 224, 236, 10, 220, 184, 203, 242, 177, 139, 207, 125,
+       221, 191, 159, 209, 127, 239, 245, 99, 78, 200, 158, 218, 207,
+       190, 215, 253, 66, 5, 230, 176, 181, 248, 109, 53, 184, 219, 139,
+       219, 176, 123, 140, 221, 253, 171, 207, 17, 247, 149, 130, 103,
+       130, 208, 31, 88, 223, 190, 223, 204, 19, 183, 191, 158, 68, 90,
+       91, 179, 90, 248, 23, 86, 245, 255, 106, 74, 175, 157, 127, 192,
+       134, 238, 175, 102, 126, 255, 26, 91, 193, 207, 127, 175, 110,
+       213, 191, 134, 68, 94, 79, 51, 204, 105, 149, 22, 245, 246, 72,
+       97, 190, 141, 127, 128, 166, 174, 124, 230, 79, 222, 22, 122, 193,
+       207, 127, 237, 248, 132, 143, 159, 164, 91, 233, 180, 63, 191,
+       247, 219, 78, 84, 248, 231, 218, 111, 69, 126, 58, 30, 178, 88,
+       255, 243, 111, 62, 223, 200, 154, 213, 176, 189, 135, 128, 25,
+       219, 96, 241, 41, 158, 31, 27, 84, 48, 148, 151, 232, 108, 219,
+       26, 19, 152, 51, 28, 107, 243, 5, 22, 186, 206, 148, 137, 37, 228,
+       62, 135, 32, 171, 189, 243, 146, 105, 87, 45, 153, 51, 74, 88, 58,
+       36, 217, 10, 159, 177, 62, 43, 109, 151, 170, 85, 139, 247, 183,
+       14, 252, 199, 216, 219, 30, 172, 32, 6, 86, 182, 164, 0, 130, 101,
+       183, 19, 161, 67, 196, 230, 109, 106, 105, 137, 17, 45, 240, 227,
+       230, 16, 42, 185, 40, 27, 54, 231, 251, 78, 154, 7, 87, 232, 223,
+       140, 169, 35, 86, 250, 109, 80, 247, 233, 14, 102, 206, 35, 42,
+       123, 123, 14, 37, 63, 49, 243, 36, 67, 175, 39, 68, 79, 216, 22,
+       203, 184, 17, 208, 245, 215, 241, 99, 159, 223, 92, 194, 31, 254,
+       187, 198, 79, 206, 46, 58, 235, 136, 175, 183, 122, 220, 221, 223,
+       138, 150, 149, 124, 55, 182, 180, 206, 158, 118, 248, 118, 171,
+       239, 117, 226, 142, 226, 245, 237, 56, 239, 249, 39, 247, 193,
+       138, 119, 237, 115, 150, 204, 156, 183, 150, 194, 79, 172, 27,
+       150, 2, 22, 109, 226, 121, 201, 179, 239, 37, 195, 105, 205, 155,
+       127, 168, 134, 223, 70, 172, 112, 9, 8, 135, 178, 183, 216, 237,
+       165, 184, 203, 159, 27, 16, 115, 156, 222, 124, 171, 207, 27, 183,
+       145, 147, 79, 130, 209, 15, 26, 223, 238, 156, 12, 33, 151, 130,
+       180, 190, 216, 255, 245, 184, 75, 159, 91, 17, 119, 188, 158, 116,
+       107, 231, 27, 191, 145, 178, 79, 146, 211, 95, 28, 186, 234, 156,
+       76, 173, 223, 34, 185, 55, 216, 125, 212, 184, 87, 175, 93, 252,
+       103, 44, 158, 38, 116, 238, 59, 151, 145, 135, 43, 178, 213, 31,
+       120, 26, 203, 74, 4, 103, 223, 251, 22, 108, 252, 239, 84, 93, 51,
+       57, 94, 214, 191, 29, 63, 150, 191, 239, 181, 247, 165, 253, 86,
+       118, 194, 215, 123, 250, 155, 47, 244, 63, 119, 47, 62, 250, 241,
+       231, 126, 185, 211, 91, 255, 124, 183, 156, 189, 215, 172, 255,
+       95, 151, 149, 135, 250, 240, 194, 79, 223, 62, 167, 207, 236, 79,
+       255, 237, 127, 121, 101, 114, 223, 95, 182, 113, 238, 54, 236,
+       155, 61, 147, 48, 22, 236, 212, 110, 229, 148, 244, 46, 102, 237,
+       37, 176, 110, 245, 78, 113, 190, 82, 228, 107, 141, 87, 87, 216,
+       71, 126, 181, 31, 75, 13, 95, 143, 221, 196, 221, 255, 172, 231,
+       125, 176, 227, 217, 101, 183, 243, 191, 222, 215, 111, 128, 228,
+       154, 205, 61, 218, 136, 203, 87, 189, 31, 74, 200, 126, 142, 201,
+       192, 234, 55, 150, 103, 126, 241, 27, 95, 211, 95, 223, 207, 220,
+       68, 220, 237, 150, 190, 159, 34, 78, 175, 22, 163, 139, 18, 111,
+       235, 57, 65, 115, 231, 41, 163, 120, 203, 143, 191, 184, 231, 223,
+       21, 164, 115, 185, 8, 220, 204, 134, 190, 149, 162, 70, 175, 150,
+       150, 138, 19, 103, 226, 43, 67, 113, 231, 168, 163, 124, 79, 10,
+       175, 248, 230, 207, 31, 176, 123, 173, 10, 119, 85, 78, 138, 218,
+       67, 30, 200, 134, 240, 137, 170, 81, 250, 239, 115, 123, 213, 58,
+       242, 77, 67, 31, 28, 58, 1, 175, 189, 189, 115, 40, 20, 135, 224,
+       213, 249, 236, 41, 184, 200, 159, 19, 17, 218, 140, 234, 125, 143,
+       223, 25, 55, 149, 51, 70, 218, 209, 4, 26, 222, 174, 156, 217,
+       193, 161, 91, 215, 124, 253, 49, 212, 93, 183, 233, 77, 94, 165,
+       253, 127, 158, 246, 166, 247, 189, 204, 207, 136, 55, 237, 227,
+       251, 110, 131, 62, 148, 173, 127, 219, 123, 123, 100, 39, 222, 95,
+       182, 233, 236, 62, 236, 251, 220, 215, 182, 134, 116, 253, 78,
+       205, 232, 180, 174, 226, 249, 37, 147, 110, 183, 79, 125, 171, 6,
+       246, 95, 239, 50, 188, 79, 93, 147, 255, 178, 104, 40, 191, 239,
+       127, 214, 178, 137, 180, 247, 39, 195, 22, 122, 214, 131, 199,
+       220, 248, 141, 142, 159, 231, 87, 247, 182, 172, 183, 123, 211,
+       94, 214, 200, 105, 156, 255, 71, 110, 179, 157, 177, 248, 111,
+       230, 46, 58, 214, 194, 143, 245, 250, 189, 229, 100, 35, 210, 93,
+       212, 201, 20, 209, 210, 193, 16, 209, 216, 124, 109, 89, 168, 18,
+       255, 233, 230, 254, 134, 41, 120, 135, 76, 8, 16, 112, 244, 38,
+       173, 204, 222, 212, 66, 206, 175, 90, 179, 40, 22, 224, 232, 125,
+       129, 217, 111, 32, 163, 113, 232, 222, 127, 40, 30, 205, 125, 157,
+       122, 218, 136, 130, 130, 158, 250, 124, 164, 184, 199, 191, 27,
+       16, 115, 188, 218, 252, 74, 231, 59, 63, 21, 178, 77, 2, 243, 204,
+       31, 58, 202, 156, 72, 169, 139, 219, 57, 124, 252, 111, 181, 252,
+       83, 93, 122, 148, 251, 189, 31, 151, 111, 238, 181, 223, 239, 236,
+       103, 231, 223, 215, 249, 234, 186, 23, 189, 53, 119, 30, 132, 44,
+       171, 221, 231, 235, 216, 7, 93, 93, 151, 92, 231, 58, 196, 89,
+       139, 147, 189, 26, 0, 56, 215, 201, 84, 139, 205, 147, 79, 180,
+       242, 24, 197, 7, 173, 180, 134, 111, 183, 36, 12, 218, 98, 181,
+       55, 56, 64, 248, 50, 31, 233, 90, 153, 33, 31, 225, 165, 190, 192,
+       16, 16, 181, 107, 54, 245, 202, 228, 10, 19, 94, 232, 23, 160,
+       141, 174, 67, 253, 107, 4, 126, 220, 221, 226, 76, 195, 157, 158,
+       186, 198, 141, 61, 45, 251, 56, 22, 139, 64, 254, 228, 37, 62,
+       217, 26, 73, 240, 126, 2, 29, 159, 54, 191, 134, 181, 181, 237,
+       133, 244, 55, 200, 195, 249, 203, 2, 38, 167, 75, 124, 150, 207,
+       220, 150, 150, 194, 14, 174, 26, 150, 0, 194, 109, 226, 121, 193,
+       51, 111, 33, 235, 112, 205, 159, 127, 168, 6, 207, 69, 148, 112,
+       137, 0, 3, 121, 247, 245, 124, 141, 248, 103, 173, 129, 122, 235,
+       188, 159, 116, 128, 206, 59, 119, 209, 147, 250, 210, 237, 12, 24,
+       154, 234, 204, 136, 195, 155, 171, 203, 118, 237, 124, 147, 248,
+       114, 207, 184, 180, 243, 141, 159, 244, 167, 238, 181, 255, 205,
+       228, 47, 197, 245, 150, 249, 138, 147, 23, 140, 105, 143, 219,
+       116, 122, 244, 110, 53, 124, 91, 121, 206, 245, 187, 61, 159, 247,
+       125, 255, 185, 191, 175, 228, 87, 166, 194, 215, 223, 251, 170,
+       38, 245, 35, 247, 31, 20, 243, 233, 246, 63, 251, 94, 93, 105,
+       124, 183, 159, 61, 191, 44, 255, 155, 151, 61, 183, 184, 53, 206,
+       238, 223, 50, 198, 247, 205, 213, 247, 126, 150, 234, 218, 207,
+       240, 154, 67, 155, 79, 189, 191, 40, 252, 126, 220, 237, 159, 183,
+       131, 158, 47, 186, 243, 27, 117, 154, 235, 231, 79, 190, 87, 58,
+       180, 242, 90, 83, 244, 187, 87, 243, 93, 253, 183, 40, 188, 126,
+       188, 175, 187, 151, 147, 182, 155, 184, 243, 91, 93, 154, 235,
+       231, 71, 255, 255, 3, 141, 40, 137, 212, 209, 190, 231, 94, 77,
+       92, 3, 32, 60, 54, 32, 232, 11, 147, 193, 214, 56, 36, 255, 63,
+       13, 190, 227, 85, 24, 253, 207, 39, 235, 114, 94, 124, 131, 206,
+       240, 221, 0, 121, 204, 108, 201, 53, 144, 222, 249, 19, 107, 195,
+       163, 30, 189, 50, 60, 13, 184, 95, 191, 122, 129, 253, 131, 96,
+       138, 236, 51, 75, 184, 23, 254, 149, 239, 67, 65, 219, 141, 93,
+       200, 55, 255, 184, 38, 79, 150, 122, 78, 229, 252, 191, 191, 80,
+       116, 11, 114, 252, 224, 36, 54, 217, 26, 75, 245, 63, 175, 157,
+       159, 214, 174, 150, 29, 181, 93, 135, 244, 175, 208, 202, 217,
+       171, 230, 143, 135, 205, 113, 237, 255, 136, 147, 211, 124, 55,
+       182, 48, 254, 189, 60, 254, 116, 203, 183, 61, 226, 196, 34, 249,
+       126, 248, 47, 253, 7, 101, 241, 235, 119, 142, 241, 2, 235, 86,
+       237, 124, 139, 248, 102, 143, 177, 240, 230, 172, 155, 52, 134,
+       238, 189, 119, 197, 209, 154, 66, 220, 12, 216, 222, 226, 28, 136,
+       99, 137, 210, 232, 114, 236, 108, 1, 248, 120, 221, 144, 246, 251,
+       173, 139, 244, 99, 238, 149, 127, 239, 226, 103, 199, 207, 214,
+       248, 203, 143, 23, 173, 105, 141, 59, 149, 115, 233, 180, 62, 94,
+       63, 93, 75, 255, 247, 223, 61, 190, 101, 223, 147, 159, 173, 188,
+       184, 117, 223, 235, 255, 182, 214, 247, 142, 212, 119, 242, 16,
+       174, 250, 107, 117, 152, 91, 139, 95, 149, 191, 108, 190, 62, 14,
+       239, 147, 255, 145, 158, 15, 58, 211, 83, 119, 218, 251, 151, 15,
+       63, 87, 218, 38, 166, 182, 141, 240, 88, 7, 187, 223, 135, 23,
+       236, 238, 95, 207, 225, 167, 253, 149, 60, 71, 190, 194, 155, 115,
+       218, 155, 166, 100, 61, 94, 124, 113, 99, 44, 95, 67, 195, 252, 4,
+       160, 238, 171, 83, 221, 33, 144, 120, 252, 243, 227, 73, 179, 157,
+       28, 113, 101, 173, 21, 103, 63, 118, 178, 185, 201, 110, 231, 85,
+       86, 73, 224, 65, 176, 230, 2, 123, 25, 54, 243, 104, 196, 49, 200,
+       72, 187, 113, 172, 251, 217, 196, 65, 99, 174, 120, 42, 203, 179,
+       120, 236, 52, 208, 217, 24, 75, 77, 61, 166, 191, 157, 214, 164,
+       158, 153, 181, 221, 143, 40, 167, 213, 202, 253, 170, 230, 7, 134,
+       69, 125, 173, 223, 136, 155, 213, 125, 183, 247, 16, 94, 61, 126,
+       248, 116, 139, 165, 93, 234, 134, 66, 255, 110, 120, 191, 109, 71,
+       231, 233, 187, 127, 220, 247, 38, 173, 204, 222, 244, 2, 207, 175,
+       19, 183, 104, 30, 97, 232, 60, 129, 89, 231, 32, 163, 123, 234,
+       154, 127, 40, 31, 197, 44, 221, 122, 218, 168, 210, 104, 122, 248,
+       108, 9, 120, 72, 255, 134, 243, 154, 175, 203, 117, 72, 255, 157,
+       127, 155, 226, 55, 135, 195, 150, 248, 155, 171, 21, 169, 105,
+       139, 22, 100, 251, 225, 118, 235, 251, 74, 111, 163, 249, 147,
+       143, 207, 117, 48, 255, 185, 95, 189, 170, 183, 132, 218, 151,
+       220, 139, 174, 231, 239, 99, 132, 255, 178, 249, 226, 191, 85,
+       218, 216, 75, 92, 149, 239, 95, 223, 223, 46, 223, 217, 213, 255,
+       158, 102, 238, 209, 219, 217, 175, 255, 183, 143, 87, 119, 166,
+       236, 132, 223, 141, 171, 134, 174, 222, 179, 96, 18, 224, 232, 92,
+       139, 217, 110, 99, 147, 54, 108, 219, 191, 45, 54, 223, 127, 209,
+       121, 208, 134, 182, 142, 148, 151, 205, 161, 164, 239, 26, 191,
+       40, 83, 96, 104, 77, 139, 201, 90, 162, 18, 50, 126, 203, 179, 45,
+       18, 215, 119, 209, 121, 220, 142, 54, 209, 99, 110, 81, 151, 86,
+       248, 197, 200, 248, 107, 114, 221, 181, 116, 252, 248, 151, 231,
+       200, 163, 24, 188, 51, 76, 133, 154, 123, 190, 112, 183, 27, 51,
+       117, 228, 53, 222, 217, 58, 201, 204, 52, 166, 175, 95, 150, 181,
+       166, 177, 149, 237, 141, 232, 54, 221, 195, 217, 171, 178, 47,
+       132, 79, 125, 220, 223, 138, 146, 151, 244, 55, 182, 180, 78, 158,
+       55, 248, 102, 171, 231, 117, 98, 142, 226, 245, 197, 56, 239, 121,
+       103, 231, 197, 170, 119, 253, 127, 214, 237, 213, 158, 158, 66,
+       143, 173, 218, 150, 0, 198, 229, 234, 125, 193, 51, 111, 41, 227,
+       99, 205, 159, 127, 168, 6, 207, 108, 156, 112, 1, 8, 227, 213,
+       119, 236, 236, 10, 252, 55, 237, 66, 250, 251, 175, 61, 148, 247,
+       238, 215, 95, 175, 249, 171, 69, 200, 182, 248, 206, 146, 111,
+       252, 240, 13, 127, 120, 240, 225, 236, 31, 254, 208, 75, 250, 180,
+       235, 141, 61, 215, 46, 239, 213, 255, 223, 220, 99, 239, 224, 214,
+       221, 239, 246, 199, 255, 91, 247, 255, 240, 248, 227, 174, 29,
+       218, 216, 91, 125, 149, 187, 223, 253, 223, 46, 255, 209, 223,
+       255, 158, 99, 237, 224, 223, 217, 175, 254, 151, 255, 83, 247, 42,
+       180, 243, 240, 117, 246, 249, 87, 185, 207, 125, 55, 28, 191, 246,
+       36, 239, 59, 151, 21, 183, 251, 48, 194, 67, 221, 186, 203, 199,
+       204, 247, 215, 218, 92, 174, 190, 41, 116, 29, 7, 179, 222, 150,
+       53, 174, 191, 103, 91, 197, 247, 253, 135, 174, 79, 242, 163, 211,
+       243, 222, 155, 134, 117, 60, 95, 130, 151, 103, 155, 202, 192, 61,
+       61, 132, 21, 71, 183, 108, 103, 168, 197, 102, 19, 187, 160, 114,
+       137, 47, 221, 36, 34, 218, 202, 55, 130, 165, 248, 46, 166, 96,
+       139, 159, 163, 139, 200, 6, 53, 153, 151, 192, 76, 122, 0, 93, 27,
+       147, 181, 146, 2, 93, 215, 76, 4, 139, 252, 149, 207, 53, 208, 58,
+       18, 252, 237, 37, 94, 217, 24, 75, 252, 53, 167, 31, 223, 247, 58,
+       158, 189, 181, 245, 140, 224, 183, 192, 195, 217, 235, 159, 239,
+       165, 79, 247, 218, 152, 61, 253, 45, 84, 93, 55, 157, 95, 150,
+       183, 191, 63, 54, 107, 199, 55, 253, 133, 237, 77, 115, 145, 195,
+       251, 250, 147, 22, 252, 141, 123, 222, 60, 174, 178, 139, 244, 88,
+       67, 187, 223, 134, 185, 15, 190, 71, 27, 165, 247, 253, 145, 62,
+       79, 178, 194, 219, 211, 223, 251, 162, 100, 47, 91, 25, 93, 23,
+       237, 178, 134, 111, 183, 37, 128, 74, 98, 191, 55, 161, 228, 102,
+       119, 28, 200, 97, 152, 17, 47, 225, 230, 46, 128, 42, 240, 161,
+       57, 3, 221, 106, 189, 214, 149, 190, 230, 156, 68, 88, 135, 165,
+       172, 54, 64, 206, 107, 147, 197, 214, 136, 86, 255, 110, 37, 158,
+       203, 29, 28, 189, 222, 123, 144, 255, 228, 53, 86, 217, 24, 75,
+       89, 125, 166, 29, 159, 254, 176, 150, 157, 181, 209, 143, 56, 49,
+       213, 203, 249, 186, 198, 15, 134, 70, 123, 173, 223, 136, 154,
+       215, 245, 23, 247, 18, 95, 252, 62, 114, 100, 171, 33, 93, 234,
+       134, 126, 255, 106, 120, 47, 127, 7, 247, 237, 187, 127, 188, 243,
+       247, 110, 86, 244, 236, 43, 236, 214, 201, 178, 178, 206, 143,
+       139, 117, 139, 238, 237, 127, 227, 173, 119, 196, 232, 182, 248,
+       203, 188, 13, 249, 107, 137, 130, 182, 124, 218, 110, 132, 185,
+       229, 175, 25, 209, 51, 188, 222, 124, 99, 239, 51, 127, 145, 242,
+       79, 202, 245, 223, 24, 250, 234, 20, 0, 161, 171, 24, 157, 19,
+       253, 178, 198, 63, 183, 52, 0, 90, 226, 189, 55, 32, 96, 102, 123,
+       31, 193, 113, 152, 17, 111, 229, 167, 190, 128, 52, 208, 165, 185,
+       57, 219, 99, 206, 85, 215, 231, 112, 213, 204, 254, 102, 96, 221,
+       182, 228, 120, 232, 134, 238, 205, 179, 44, 220, 50, 44, 163, 130,
+       127, 190, 124, 245, 56, 83, 99, 236, 87, 83, 231, 120, 69, 196,
+       252, 134, 67, 205, 178, 52, 120, 236, 134, 234, 205, 179, 52, 172,
+       115, 237, 163, 5, 103, 191, 116, 252, 63, 88, 240, 244, 103, 28,
+       121, 88, 187, 198, 180, 171, 255, 94, 215, 57, 255, 177, 151, 167,
+       172, 102, 108, 201, 214, 223, 203, 147, 55, 172, 103, 211, 43, 82,
+       116, 244, 37, 118, 216, 24, 9, 236, 55, 238, 141, 31, 150, 191,
+       134, 53, 181, 111, 133, 228, 55, 217, 194, 251, 251, 146, 15, 164,
+       89, 125, 157, 223, 171, 147, 150, 244, 167, 244, 148, 95, 94, 119,
+       112, 119, 171, 103, 121, 226, 134, 254, 243, 228, 60, 107, 105, 7,
+       231, 132, 171, 127, 164, 243, 157, 223, 175, 159, 150, 112, 167,
+       188, 244, 222, 158, 247, 245, 102, 171, 103, 113, 226, 142, 238,
+       243, 197, 60, 47, 237, 39, 231, 133, 169, 123, 229, 113, 38, 141,
+       204, 158, 213, 130, 198, 239, 90, 151, 56, 22, 96, 232, 127, 129,
+       89, 231, 32, 35, 121, 234, 14, 127, 40, 6, 221, 125, 221, 122,
+       218, 136, 70, 0, 252, 203, 252, 161, 251, 200, 143, 53, 185, 146,
+       204, 171, 124, 74, 239, 139, 127, 149, 18, 9, 203, 240, 156, 156,
+       186, 253, 148, 139, 225, 129, 2, 60, 243, 255, 116, 173, 250, 83,
+       191, 201, 120, 235, 188, 191, 245, 96, 238, 59, 23, 145, 131, 186,
+       144, 234, 182, 220, 154, 170, 222, 236, 65, 191, 218, 88, 189,
+       252, 45, 68, 92, 63, 157, 90, 144, 119, 191, 63, 48, 251, 231,
+       247, 253, 129, 237, 77, 19, 211, 211, 251, 250, 155, 28, 116, 165,
+       91, 48, 203, 74, 239, 86, 83, 239, 112, 69, 196, 255, 138, 99, 3,
+       178, 116, 122, 236, 6, 238, 76, 178, 101, 236, 246, 237, 130, 1,
+       103, 171, 118, 204, 49, 75, 74, 79, 52, 27, 110, 113, 101, 164,
+       255, 198, 227, 0, 151, 80, 122, 236, 110, 110, 220, 184, 101, 44,
+       166, 172, 164, 16, 109, 170, 120, 12, 107, 144, 248, 224, 117, 92,
+       249, 123, 201, 77, 188, 42, 221, 127, 190, 228, 255, 145, 159,
+       169, 145, 43, 160, 205, 223, 223, 191, 254, 151, 140, 101, 243,
+       139, 119, 121, 106, 60, 245, 91, 30, 79, 77, 92, 181, 61, 157,
+       182, 36, 134, 27, 149, 77, 134, 140, 181, 247, 99, 249, 56, 187,
+       22, 135, 214, 127, 196, 255, 171, 55, 136, 120, 103, 184, 224,
+       218, 15, 132, 209, 230, 203, 103, 49, 98, 108, 106, 247, 65, 190,
+       43, 237, 199, 167, 12, 170, 243, 197, 116, 214, 204, 222, 182,
+       150, 66, 79, 168, 59, 150, 2, 18, 111, 226, 121, 209, 179, 231,
+       32, 227, 104, 69, 138, 127, 184, 166, 207, 69, 165, 113, 45, 0,
+       218, 223, 61, 253, 44, 14, 220, 187, 189, 26, 178, 115, 159, 31,
+       48, 227, 239, 147, 253, 163, 233, 45, 1, 213, 227, 251, 250, 214,
+       28, 168, 161, 27, 222, 60, 191, 176, 169, 228, 24, 210, 187, 223,
+       146, 25, 158, 191, 97, 219, 167, 247, 253, 17, 61, 79, 146, 226,
+       219, 243, 95, 251, 130, 117, 39, 83, 49, 203, 74, 231, 116, 26,
+       106, 112, 101, 132, 255, 194, 227, 3, 146, 100, 122, 172, 14, 238,
+       204, 176, 101, 140, 246, 236, 162, 192, 39, 138, 120, 140, 43,
+       218, 240, 244, 101, 94, 248, 48, 217, 222, 180, 238, 173, 95, 183,
+       173, 254, 177, 159, 173, 229, 101, 36, 205, 214, 219, 255, 190,
+       63, 172, 73, 221, 123, 178, 249, 224, 53, 90, 217, 24, 75, 253,
+       52, 167, 15, 207, 222, 56, 190, 157, 181, 181, 134, 96, 166, 208,
+       203, 223, 187, 247, 199, 164, 79, 87, 189, 159, 140, 158, 213,
+       241, 135, 231, 26, 222, 189, 63, 106, 96, 171, 137, 89, 234, 134,
+       118, 124, 106, 106, 127, 232, 7, 255, 253, 209, 127, 220, 194,
+       159, 15, 85, 233, 180, 171, 232, 114, 45, 0, 250, 210, 159, 10,
+       21, 193, 238, 187, 95, 117, 187, 171, 81, 220, 188, 249, 170, 208,
+       157, 136, 65, 33, 134, 112, 186, 250, 235, 165, 185, 216, 158, 29,
+       85, 48, 156, 215, 105, 76, 183, 25, 179, 91, 2, 69, 58, 241, 205,
+       209, 123, 234, 146, 19, 165, 163, 2, 223, 43, 188, 242, 192, 189,
+       103, 188, 77, 90, 163, 172, 142, 38, 64, 238, 59, 147, 145, 102,
+       154, 2, 255, 109, 38, 190, 203, 20, 16, 181, 219, 106, 19, 125,
+       236, 53, 198, 217, 58, 201, 200, 52, 230, 189, 31, 150, 37, 166,
+       177, 181, 137, 131, 40, 54, 221, 203, 217, 186, 186, 31, 132, 87,
+       123, 36, 143, 205, 151, 212, 106, 231, 175, 90, 215, 57, 22, 241,
+       232, 95, 129, 89, 98, 34, 43, 113, 120, 126, 63, 44, 6, 229, 100,
+       221, 122, 218, 128, 206, 60, 151, 176, 169, 108, 120, 18, 187,
+       155, 147, 116, 159, 191, 97, 235, 167, 119, 253, 17, 49, 79, 146,
+       226, 219, 243, 127, 218, 138, 113, 163, 51, 63, 69, 99, 204, 87,
+       147, 235, 116, 69, 192, 223, 194, 73, 200, 181, 228, 120, 172, 19,
+       239, 205, 179, 36, 206, 51, 44, 139, 128, 47, 191, 112, 228, 115,
+       18, 254, 228, 36, 14, 216, 24, 75, 248, 53, 229, 156, 143, 246,
+       26, 150, 61, 53, 29, 133, 228, 179, 192, 138, 218, 251, 150, 140,
+       160, 75, 85, 220, 207, 223, 150, 150, 66, 15, 191, 218, 214, 10,
+       150, 109, 226, 123, 193, 51, 99, 172, 235, 113, 77, 30, 127, 184,
+       6, 239, 84, 188, 112, 169, 40, 9, 129, 19, 233, 116, 143, 234,
+       208, 108, 9, 127, 68, 223, 99, 152, 228, 126, 44, 94, 108, 129,
+       176, 73, 93, 164, 253, 34, 196, 78, 139, 107, 161, 42, 153, 121,
+       244, 118, 140, 249, 53, 25, 200, 180, 226, 188, 127, 244, 97, 254,
+       179, 23, 169, 195, 42, 112, 205, 255, 219, 174, 232, 63, 168, 97,
+       187, 0, 176, 60, 182, 30, 197, 179, 113, 136, 93, 25, 63, 244,
+       255, 74, 3, 204, 123, 83, 195, 16, 75, 218, 37, 217, 129, 250,
+       169, 0, 11, 151, 219, 173, 159, 136, 155, 213, 125, 167, 247, 18,
+       94, 125, 62, 248, 116, 139, 169, 89, 202, 130, 170, 255, 126, 120,
+       63, 109, 7, 247, 101, 251, 127, 222, 241, 137, 207, 23, 181, 240,
+       138, 45, 55, 60, 136, 90, 80, 189, 162, 160, 225, 166, 47, 34, 8,
+       113, 248, 1, 79, 236, 166, 62, 64, 8, 128, 161, 169, 27, 73, 107,
+       197, 86, 18, 239, 240, 101, 64, 95, 194, 89, 15, 189, 100, 126,
+       200, 23, 239, 205, 176, 45, 236, 118, 13, 162, 132, 39, 183, 112,
+       228, 71, 2, 249, 148, 100, 12, 232, 56, 251, 250, 48, 238, 244,
+       110, 255, 121, 255, 161, 23, 173, 165, 100, 36, 200, 150, 30, 251,
+       188, 157, 169, 65, 245, 130, 48, 171, 183, 6, 233, 89, 81, 150,
+       246, 199, 187, 244, 221, 106, 11, 104, 187, 59, 195, 8, 213, 154,
+       96, 213, 0, 250, 177, 36, 10, 20, 122, 128, 34, 170, 178, 100,
+       201, 121, 85, 134, 215, 23, 187, 244, 205, 106, 10, 55, 187, 11,
+       23, 18, 213, 138, 66, 197, 1, 184, 161, 164, 138, 149, 90, 221,
+       223, 138, 150, 151, 116, 39, 182, 180, 222, 158, 54, 232, 102,
+       171, 231, 113, 226, 142, 238, 241, 69, 60, 239, 249, 103, 239,
+       197, 171, 119, 253, 125, 164, 141, 204, 150, 212, 98, 207, 175,
+       210, 167, 169, 30, 112, 224, 63, 129, 89, 231, 32, 227, 121, 98,
+       90, 127, 40, 135, 197, 61, 221, 123, 250, 128, 150, 237, 204, 182,
+       148, 98, 207, 239, 82, 166, 73, 22, 97, 234, 61, 129, 123, 239,
+       32, 235, 121, 239, 26, 127, 40, 14, 207, 4, 173, 114, 248, 168,
+       214, 237, 214, 158, 154, 34, 78, 172, 63, 162, 203, 18, 101, 226,
+       41, 81, 51, 239, 41, 226, 120, 199, 139, 254, 184, 166, 223, 20,
+       164, 115, 161, 8, 176, 6, 74, 224, 212, 38, 76, 95, 81, 46, 252,
+       23, 3, 9, 54, 89, 125, 140, 7, 164, 172, 182, 1, 206, 242, 200,
+       130, 133, 109, 216, 250, 128, 73, 42, 17, 233, 120, 143, 107, 154,
+       110, 41, 112, 64, 183, 131, 137, 248, 114, 76, 94, 88, 19, 58,
+       193, 117, 196, 191, 50, 32, 24, 145, 67, 169, 144, 57, 157, 187,
+       130, 199, 21, 85, 150, 252, 131, 7, 181, 159, 97, 73, 228, 59, 31,
+       147, 75, 201, 123, 17, 193, 129, 126, 144, 56, 82, 165, 219, 151,
+       198, 50, 186, 7, 243, 148, 239, 95, 83, 81, 251, 207, 252, 62,
+       237, 183, 153, 132, 17, 255, 126, 14, 151, 152, 86, 95, 239, 148,
+       76, 189, 7, 214, 207, 220, 182, 150, 98, 239, 175, 155, 214, 10,
+       22, 101, 226, 127, 65, 51, 99, 32, 227, 113, 77, 154, 255, 168,
+       134, 207, 101, 172, 115, 169, 12, 234, 188, 179, 250, 169, 237,
+       148, 199, 159, 27, 184, 24, 190, 255, 100, 186, 205, 123, 255, 16,
+       51, 79, 218, 243, 219, 223, 94, 123, 218, 88, 143, 155, 212, 204,
+       134, 158, 149, 226, 70, 175, 150, 146, 139, 18, 102, 226, 105, 79,
+       113, 231, 40, 179, 122, 197, 11, 127, 184, 166, 223, 20, 184, 121,
+       160, 14, 157, 4, 239, 85, 199, 114, 237, 91, 116, 243, 87, 146,
+       89, 61, 191, 111, 123, 134, 51, 169, 177, 244, 37, 194, 71, 43,
+       242, 132, 231, 252, 244, 224, 27, 123, 123, 229, 116, 7, 251, 208,
+       77, 104, 120, 102, 31, 223, 181, 96, 126, 189, 23, 237, 201, 178,
+       36, 220, 246, 220, 163, 164, 63, 187, 97, 177, 45, 121, 17, 233,
+       108, 141, 232, 254, 46, 136, 248, 98, 190, 19, 161, 112, 238, 185,
+       31, 216, 195, 186, 66, 241, 157, 156, 174, 200, 24, 185, 99, 161,
+       96, 28, 221, 243, 90, 227, 57, 23, 134, 247, 7, 178, 20, 23, 97,
+       90, 71, 188, 59, 144, 2, 222, 121, 80, 93, 2, 184, 224, 144, 138,
+       4, 250, 3, 30, 160, 95, 214, 175, 139, 11, 94, 5, 204, 158, 160,
+       32, 53, 108, 127, 42, 2, 13, 178, 184, 117, 255, 29, 62, 26, 18,
+       221, 73, 81, 44, 172, 223, 136, 154, 213, 117, 135, 255, 18, 222,
+       253, 62, 248, 102, 171, 165, 89, 234, 134, 234, 123, 98, 120, 175,
+       233, 7, 239, 253, 155, 127, 252, 251, 39, 21, 248, 90, 244, 170,
+       129, 19, 94, 193, 207, 150, 208, 121, 180, 68, 95, 42, 2, 29, 147,
+       168, 84, 206, 76, 62, 18, 80, 221, 202, 249, 48, 3, 203, 58, 142,
+       172, 145, 190, 229, 207, 84, 76, 133, 228, 138, 255, 68, 227, 107,
+       34, 79, 199, 9, 62, 249, 42, 16, 14, 43, 20, 154, 173, 220, 157,
+       223, 138, 146, 213, 244, 55, 247, 148, 94, 222, 54, 112, 118, 171,
+       225, 125, 226, 134, 234, 253, 255, 56, 111, 249, 7, 231, 193, 187,
+       127, 173, 247, 149, 223, 138, 150, 148, 124, 39, 182, 178, 222,
+       190, 54, 118, 102, 171, 99, 113, 226, 12, 226, 245, 253, 60, 111,
+       249, 39, 231, 197, 169, 115, 173, 125, 166, 204, 236, 246, 213,
+       162, 223, 238, 219, 151, 60, 19, 97, 233, 125, 1, 91, 126, 33, 3,
+       112, 238, 158, 191, 105, 30, 221, 125, 213, 123, 214, 170, 201,
+       188, 156, 187, 169, 189, 112, 151, 255, 59, 168, 92, 190, 242, 66,
+       190, 133, 43, 110, 20, 55, 108, 251, 243, 141, 255, 86, 122, 216,
+       64, 139, 15, 148, 205, 132, 159, 157, 225, 134, 239, 22, 146, 137,
+       18, 226, 96, 105, 75, 89, 226, 42, 146, 122, 236, 75, 127, 168,
+       134, 223, 21, 153, 123, 185, 8, 192, 237, 4, 157, 76, 139, 172,
+       231, 126, 162, 226, 82, 164, 162, 0, 213, 105, 238, 106, 136, 112,
+       218, 199, 95, 180, 34, 223, 0, 9, 112, 235, 136, 3, 204, 87, 157,
+       228, 139, 236, 103, 61, 34, 82, 82, 188, 42, 20, 65, 230, 175,
+       123, 9, 112, 220, 67, 223, 180, 62, 222, 0, 12, 80, 161, 136, 64,
+       43, 25, 177, 172, 137, 172, 7, 174, 185, 184, 72, 149, 131, 209,
+       11, 227, 37, 127, 25, 19, 105, 195, 64, 140, 152, 63, 252, 140,
+       192, 131, 137, 59, 0, 192, 189, 127, 240, 120, 74, 23, 67, 88,
+       227, 47, 184, 115, 200, 251, 75, 183, 149, 14, 216, 199, 179, 142,
+       247, 152, 131, 191, 77, 56, 207, 111, 226, 194, 206, 116, 6, 107,
+       216, 155, 5, 77, 199, 65, 227, 189, 212, 124, 76, 19, 238, 194,
+       19, 156, 209, 48, 60, 139, 172, 31, 246, 114, 244, 228, 254, 136,
+       190, 213, 172, 214, 191, 27, 158, 49, 127, 98, 104, 79, 27, 153,
+       235, 197, 131, 124, 110, 90, 47, 126, 199, 245, 255, 249, 123,
+       206, 147, 215, 237, 151, 214, 150, 66, 143, 175, 26, 242, 137,
+       146, 124, 246, 57, 97, 51, 87, 57, 171, 113, 197, 63, 255, 185,
+       46, 207, 60, 164, 114, 161, 40, 34, 121, 123, 232, 108, 196, 253,
+       119, 73, 200, 252, 103, 185, 159, 244, 36, 206, 185, 23, 133, 201,
+       58, 240, 204, 103, 221, 174, 138, 111, 156, 118, 251, 66, 187, 27,
+       225, 236, 141, 253, 119, 173, 185, 184, 104, 190, 31, 192, 16,
+       206, 179, 95, 17, 210, 75, 194, 196, 221, 156, 62, 250, 128, 8,
+       131, 169, 184, 203, 74, 158, 84, 209, 207, 237, 26, 5, 125, 175,
+       237, 170, 62, 145, 58, 235, 135, 195, 86, 42, 14, 253, 234, 145,
+       174, 249, 21, 10, 221, 138, 245, 228, 51, 208, 149, 86, 77, 237,
+       81, 194, 198, 18, 83, 212, 92, 101, 113, 236, 16, 121, 249, 231,
+       244, 134, 185, 104, 199, 76, 37, 184, 244, 100, 166, 236, 133,
+       255, 156, 163, 142, 174, 222, 147, 65, 18, 225, 232, 92, 11, 217,
+       111, 107, 211, 120, 108, 203, 191, 173, 182, 223, 60, 149, 123,
+       209, 140, 163, 78, 125, 223, 108, 151, 231, 242, 221, 2, 116, 82,
+       240, 88, 181, 165, 78, 96, 18, 110, 225, 172, 118, 255, 7, 58,
+       192, 2, 87, 185, 112, 172, 131, 76, 39, 159, 45, 178, 174, 34,
+       221, 66, 210, 242, 232, 76, 183, 239, 200, 96, 58, 207, 237, 229,
+       103, 239, 0, 122, 218, 146, 31, 253, 121, 77, 66, 216, 114, 221,
+       101, 156, 252, 23, 41, 74, 126, 227, 172, 159, 181, 100, 239, 191,
+       183, 133, 198, 186, 226, 207, 39, 126, 158, 138, 7, 204, 245, 223,
+       66, 153, 185, 240, 116, 205, 249, 119, 171, 249, 184, 107, 190,
+       63, 68, 50, 238, 187, 119, 1, 216, 42, 82, 209, 223, 216, 58, 186,
+       85, 136, 135, 123, 194, 164, 85, 181, 76, 171, 232, 35, 47, 179,
+       179, 218, 207, 10, 28, 91, 107, 165, 110, 1, 60, 253, 197, 198,
+       148, 186, 218, 80, 77, 8, 65, 0, 112, 64, 199, 141, 92, 11, 224,
+       68, 61, 161, 226, 82, 66, 34, 4, 94, 248, 204, 106, 128, 8, 247,
+       193, 204, 148, 166, 210, 18, 97, 57, 112, 132, 62, 13, 134, 188,
+       145, 166, 94, 99, 181, 157, 234, 133, 111, 111, 34, 147, 233, 227,
+       245, 148, 60, 201, 19, 173, 186, 243, 220, 195, 171, 100, 168, 26,
+       54, 239, 69, 202, 124, 177, 74, 184, 7, 136, 152, 235, 99, 69,
+       253, 132, 125, 192, 207, 254, 138, 3, 79, 189, 186, 76, 173, 189,
+       183, 255, 124, 108, 152, 228, 104, 227, 85, 180, 251, 48, 83, 37,
+       143, 18, 121, 89, 90, 96, 120, 156, 145, 154, 238, 52, 185, 151,
+       95, 205, 129, 97, 103, 142, 124, 162, 180, 159, 152, 178, 244, 45,
+       183, 247, 18, 31, 61, 127, 100, 107, 233, 25, 253, 219, 135, 146,
+       248, 110, 72, 58, 124, 135, 119, 234, 209, 121, 134, 131, 148,
+       143, 157, 218, 148, 224, 199, 231, 22, 26, 249, 50, 112, 119, 169,
+       105, 249, 242, 6, 210, 122, 108, 42, 111, 105, 134, 247, 197, 209,
+       123, 228, 163, 180, 239, 238, 214, 252, 7, 223, 253, 211, 190,
+       180, 58, 115, 105, 157, 27, 89, 198, 125, 234, 248, 231, 11, 175,
+       122, 139, 229, 180, 197, 249, 242, 131, 166, 175, 132, 151, 221,
+       233, 166, 175, 158, 179, 41, 83, 224, 104, 76, 11, 201, 106, 98,
+       19, 114, 124, 203, 59, 45, 134, 215, 103, 209, 123, 212, 142, 26,
+       27, 98, 132, 115, 209, 186, 103, 173, 196, 94, 163, 44, 142, 230,
+       196, 166, 59, 151, 213, 86, 155, 36, 236, 58, 69, 10, 139, 39, 6,
+       173, 223, 66, 34, 120, 245, 46, 169, 216, 35, 189, 35, 179, 217,
+       255, 43, 28, 88, 199, 133, 125, 5, 182, 60, 195, 211, 150, 254,
+       90, 178, 204, 136, 67, 1, 48, 64, 87, 141, 70, 3, 224, 69, 45, 0,
+       243, 66, 66, 138, 41, 92, 120, 140, 110, 160, 72, 183, 65, 196,
+       148, 162, 210, 66, 97, 26, 240, 132, 197, 205, 183, 222, 149, 100,
+       103, 173, 244, 90, 171, 18, 117, 243, 57, 102, 113, 66, 10, 234,
+       113, 133, 60, 106, 125, 46, 239, 4, 160, 115, 225, 32, 246, 52,
+       236, 245, 142, 35, 223, 186, 146, 178, 151, 219, 209, 109, 93, 43,
+       93, 215, 121, 167, 184, 103, 223, 170, 75, 11, 237, 180, 237, 249,
+       80, 18, 225, 191, 158, 190, 189, 157, 118, 183, 255, 157, 254, 93,
+       238, 232, 70, 82, 201, 103, 110, 28, 190, 107, 218, 191, 239, 255,
+       21, 90, 200, 74, 202, 207, 11, 19, 98, 141, 114, 147, 170, 88, 13,
+       64, 94, 231, 41, 206, 182, 228, 54, 137, 151, 237, 135, 144, 37,
+       205, 22, 44, 170, 130, 47, 142, 41, 213, 114, 65, 211, 225, 69, 2,
+       232, 69, 109, 49, 242, 66, 11, 11, 53, 92, 106, 141, 110, 193, 72,
+       179, 193, 192, 150, 248, 146, 3, 37, 152, 112, 140, 154, 177, 252,
+       225, 63, 214, 217, 9, 203, 117, 52, 147, 207, 223, 94, 170, 150,
+       157, 181, 213, 142, 52, 183, 209, 203, 221, 139, 71, 231, 132, 15,
+       86, 238, 182, 236, 241, 172, 107, 221, 191, 18, 251, 158, 185,
+       209, 109, 218, 43, 29, 215, 253, 177, 184, 108, 239, 146, 238, 19,
+       253, 245, 132, 248, 148, 120, 227, 239, 26, 254, 253, 143, 254,
+       246, 255, 13, 246, 93, 238, 249, 62, 80, 253, 239, 127, 79, 254,
+       239, 218, 255, 255, 253, 135, 122, 88, 89, 250, 11, 147, 76, 103,
+       190, 13, 80, 140, 162, 212, 86, 210, 147, 225, 76, 183, 111, 72,
+       225, 63, 199, 236, 197, 103, 175, 128, 122, 218, 147, 53, 125,
+       113, 76, 235, 18, 248, 248, 36, 156, 88, 24, 189, 89, 118, 121,
+       159, 223, 190, 124, 198, 145, 253, 21, 158, 100, 98, 193, 199,
+       255, 122, 218, 214, 140, 65, 87, 90, 104, 114, 225, 37, 152, 248,
+       129, 109, 16, 242, 130, 137, 11, 21, 221, 106, 141, 127, 221, 206,
+       176, 197, 192, 134, 249, 146, 133, 39, 148, 105, 136, 18, 1, 118,
+       225, 198, 3, 236, 65, 109, 16, 243, 66, 77, 11, 60, 73, 106, 137,
+       63, 179, 72, 178, 69, 192, 150, 248, 194, 7, 37, 138, 240, 140,
+       48, 10, 67, 169, 70, 169, 232, 66, 45, 32, 250, 67, 135, 130, 113,
+       64, 106, 169, 14, 199, 8, 187, 65, 240, 148, 128, 138, 32, 53, 75,
+       113, 136, 184, 203, 110, 226, 213, 22, 82, 228, 65, 5, 238, 3, 11,
+       9, 38, 210, 232, 220, 129, 112, 88, 187, 17, 164, 251, 241, 132,
+       71, 99, 142, 252, 138, 170, 176, 124, 237, 53, 212, 217, 50, 203,
+       197, 52, 37, 191, 159, 22, 48, 134, 177, 181, 193, 135, 172, 50,
+       221, 195, 249, 168, 147, 102, 132, 78, 123, 164, 239, 78, 186,
+       236, 33, 199, 252, 146, 158, 185, 253, 67, 227, 235, 27, 217, 202,
+       70, 230, 106, 103, 10, 58, 248, 131, 229, 189, 209, 251, 234, 131,
+       48, 108, 202, 172, 77, 201, 230, 110, 22, 166, 232, 11, 33, 233,
+       117, 88, 121, 235, 34, 129, 90, 190, 138, 59, 125, 167, 151, 41,
+       241, 122, 122, 138, 17, 108, 83, 137, 78, 173, 232, 70, 109, 18,
+       250, 66, 188, 2, 81, 1, 106, 137, 78, 137, 2, 183, 199, 193, 148,
+       136, 138, 40, 69, 24, 97, 168, 129, 224, 87, 203, 76, 8, 224, 69,
+       108, 49, 250, 82, 145, 130, 96, 114, 104, 140, 106, 136, 66, 159,
+       197, 209, 20, 160, 154, 100, 9, 10, 225, 168, 171, 156, 42, 218,
+       112, 179, 155, 234, 30, 70, 213, 179, 124, 212, 190, 101, 95, 58,
+       147, 45, 226, 175, 44, 255, 82, 15, 42, 209, 22, 140, 53, 117, 41,
+       120, 176, 61, 48, 159, 203, 50, 80, 234, 112, 76, 179, 152, 147,
+       48, 204, 109, 20, 79, 205, 188, 212, 47, 228, 253, 169, 48, 90,
+       184, 90, 157, 60, 72, 238, 230, 69, 82, 83, 196, 69, 60, 246, 3,
+       75, 31, 119, 122, 232, 212, 181, 194, 76, 247, 33, 160, 211, 219,
+       212, 7, 99, 63, 124, 234, 248, 16, 127, 244, 100, 70, 89, 88, 16,
+       238, 85, 63, 31, 31, 51, 41, 158, 181, 21, 39, 169, 247, 184, 140,
+       211, 235, 251, 189, 68, 169, 7, 123, 188, 148, 212, 187, 142, 35,
+       158, 222, 22, 179, 145, 214, 221, 123, 73, 203, 95, 215, 127, 179,
+       57, 70, 95, 178, 236, 199, 255, 244, 189, 249, 168, 16, 238, 255,
+       236, 243, 172, 99, 158, 191, 18, 187, 154, 242, 217, 111, 217,
+       171, 95, 215, 253, 179, 250, 78, 207, 178, 238, 215, 255, 253,
+       159, 249, 156, 25, 163, 59, 235, 85, 102, 145, 248, 83, 95, 100,
+       116, 167, 57, 172, 247, 44, 126, 175, 151, 133, 197, 186, 180,
+       210, 22, 92, 158, 162, 111, 172, 123, 221, 59, 251, 107, 108, 50,
+       210, 155, 112, 69, 204, 220, 231, 57, 157, 182, 36, 126, 185, 151,
+       231, 207, 155, 36, 221, 242, 73, 171, 130, 127, 174, 52, 117, 11,
+       89, 124, 225, 36, 157, 120, 16, 237, 216, 52, 160, 159, 159, 215,
+       170, 166, 57, 223, 93, 198, 32, 38, 208, 198, 217, 35, 238, 118,
+       164, 11, 249, 14, 129, 116, 225, 100, 2, 248, 120, 77, 176, 249,
+       130, 137, 11, 60, 67, 238, 145, 31, 169, 152, 48, 69, 196, 158,
+       217, 138, 197, 55, 170, 97, 128, 90, 128, 240, 230, 87, 220, 248,
+       229, 41, 21, 172, 11, 111, 127, 30, 48, 251, 145, 147, 145, 30,
+       58, 48, 197, 219, 223, 158, 67, 231, 14, 245, 106, 168, 52, 185,
+       230, 116, 102, 89, 82, 16, 239, 117, 63, 21, 63, 2, 56, 159, 157,
+       23, 171, 176, 222, 57, 14, 211, 207, 249, 161, 164, 235, 36, 243,
+       32, 149, 125, 87, 82, 230, 187, 49, 16, 93, 127, 22, 112, 127, 14,
+       33, 93, 114, 23, 138, 176, 248, 121, 109, 79, 143, 240, 192, 229,
+       203, 212, 251, 194, 129, 47, 94, 44, 72, 163, 40, 232, 85, 71,
+       176, 240, 228, 158, 103, 48, 118, 121, 43, 225, 193, 174, 105, 65,
+       35, 234, 137, 4, 130, 213, 124, 226, 138, 230, 154, 75, 209, 184,
+       103, 139, 21, 84, 191, 40, 142, 54, 134, 239, 187, 163, 133, 246,
+       15, 6, 241, 23, 114, 218, 235, 23, 4, 191, 222, 34, 72, 114, 228,
+       118, 136, 248, 80, 201, 128, 120, 203, 173, 11, 117, 10, 238, 177,
+       23, 141, 128, 54, 196, 202, 22, 220, 130, 170, 237, 170, 113, 137,
+       132, 161, 95, 161, 222, 137, 232, 65, 172, 49, 242, 82, 149, 11,
+       120, 66, 106, 135, 107, 153, 18, 184, 65, 196, 220, 128, 170, 64,
+       197, 8, 225, 160, 126, 59, 240, 244, 181, 34, 80, 2, 123, 165,
+       176, 41, 110, 185, 71, 26, 155, 253, 229, 17, 24, 107, 192, 168,
+       155, 247, 85, 59, 195, 113, 94, 3, 112, 16, 115, 206, 71, 250, 50,
+       64, 233, 66, 99, 66, 126, 213, 44, 244, 242, 60, 130, 42, 1, 183,
+       56, 203, 19, 239, 2, 2, 3, 15, 101, 247, 33, 249, 219, 85, 96,
+       221, 230, 167, 234, 234, 42, 72, 178, 178, 196, 50, 131, 127, 112,
+       74, 69, 248, 180, 42, 47, 157, 117, 48, 72, 56, 203, 156, 11, 51,
+       120, 228, 104, 28, 121, 113, 201, 204, 52, 164, 189, 31, 210, 50,
+       134, 49, 215, 45, 197, 41, 162, 200, 194, 217, 42, 168, 14, 164,
+       15, 249, 4, 11, 223, 161, 252, 40, 168, 67, 172, 1, 250, 66, 149,
+       138, 177, 74, 234, 139, 79, 153, 18, 187, 129, 192, 84, 176, 186,
+       64, 133, 72, 97, 128, 60, 165, 144, 224, 245, 83, 86, 233, 83,
+       189, 185, 43, 75, 123, 104, 144, 217, 218, 134, 48, 26, 106, 72,
+       156, 251, 215, 167, 127, 211, 107, 254, 130, 67, 94, 14, 206, 100,
+       180, 110, 246, 141, 74, 222, 70, 52, 130, 183, 228, 224, 96, 30,
+       78, 193, 169, 48, 237, 51, 60, 162, 128, 24, 219, 120, 61, 80, 92,
+       115, 94, 67, 205, 51, 96, 169, 4, 107, 10, 126, 213, 36, 244, 162,
+       60, 243, 2, 65, 183, 186, 111, 19, 172, 0, 10, 99, 34, 103, 251,
+       192, 88, 239, 87, 4, 82, 181, 53, 208, 214, 71, 178, 241, 253,
+       151, 43, 10, 118, 185, 139, 224, 253, 191, 8, 103, 43, 252, 129,
+       69, 248, 20, 122, 213, 215, 221, 154, 186, 96, 14, 188, 118, 91,
+       153, 244, 245, 114, 169, 123, 119, 211, 44, 226, 123, 71, 79, 99,
+       184, 166, 255, 156, 157, 243, 161, 25, 214, 253, 212, 254, 186,
+       34, 30, 190, 19, 147, 153, 242, 253, 255, 201, 91, 127, 223, 189,
+       242, 123, 70, 207, 251, 170, 230, 255, 238, 191, 243, 160, 19,
+       167, 76, 140, 155, 141, 53, 140, 143, 222, 83, 128, 87, 240, 104,
+       55, 235, 201, 66, 58, 159, 167, 108, 95, 179, 36, 31, 222, 24,
+       156, 125, 216, 20, 49, 19, 107, 77, 214, 146, 235, 117, 68, 72,
+       126, 230, 81, 104, 181, 32, 126, 168, 22, 236, 217, 186, 36, 78,
+       126, 44, 162, 192, 109, 170, 240, 185, 99, 16, 245, 252, 108, 148,
+       216, 19, 137, 74, 48, 235, 189, 31, 149, 58, 238, 177, 215, 133,
+       199, 38, 96, 201, 150, 126, 154, 154, 95, 132, 3, 159, 44, 41,
+       248, 96, 252, 195, 83, 24, 67, 173, 124, 8, 91, 249, 85, 58, 152,
+       252, 53, 216, 26, 250, 234, 176, 75, 205, 165, 101, 229, 171, 86,
+       162, 126, 59, 226, 98, 49, 218, 80, 0, 107, 173, 231, 41, 10, 157,
+       71, 248, 160, 189, 245, 17, 142, 216, 129, 128, 219, 249, 17, 211,
+       227, 6, 94, 71, 52, 236, 155, 218, 212, 231, 163, 202, 86, 11,
+       216, 2, 112, 241, 33, 96, 121, 250, 2, 152, 27, 187, 26, 63, 121,
+       132, 167, 104, 209, 91, 240, 162, 95, 219, 122, 234, 118, 144,
+       251, 244, 205, 200, 182, 162, 125, 223, 182, 100, 126, 241, 159,
+       239, 192, 41, 172, 252, 242, 249, 174, 216, 55, 190, 101, 121, 61,
+       83, 75, 231, 54, 7, 79, 244, 69, 224, 246, 230, 83, 5, 185, 164,
+       126, 204, 20, 238, 201, 179, 61, 190, 240, 205, 161, 132, 109,
+       187, 112, 249, 43, 50, 105, 225, 54, 86, 153, 16, 105, 108, 22,
+       166, 157, 30, 151, 160, 150, 21, 149, 253, 135, 144, 37, 212, 70,
+       93, 170, 214, 199, 134, 95, 117, 43, 18, 106, 193, 117, 150, 249,
+       16, 105, 236, 22, 167, 25, 29, 247, 60, 182, 53, 149, 157, 133,
+       145, 36, 200, 66, 93, 170, 150, 135, 132, 87, 253, 184, 76, 110,
+       123, 197, 221, 84, 228, 213, 30, 230, 27, 43, 89, 47, 89, 233,
+       234, 135, 194, 110, 182, 80, 175, 115, 235, 212, 3, 115, 93, 254,
+       202, 90, 3, 74, 236, 2, 52, 120, 73, 36, 5, 239, 135, 105, 174,
+       42, 208, 126, 131, 171, 164, 12, 147, 21, 81, 210, 229, 154, 133,
+       49, 198, 173, 80, 188, 92, 253, 247, 198, 102, 87, 214, 16, 246,
+       54, 18, 57, 63, 33, 107, 111, 241, 19, 194, 104, 246, 113, 42,
+       103, 203, 245, 2, 245, 249, 100, 251, 204, 92, 253, 87, 134, 102,
+       181, 150, 210, 246, 6, 50, 17, 61, 65, 107, 79, 116, 49, 184, 161,
+       244, 179, 42, 79, 139, 247, 4, 165, 249, 116, 122, 175, 77, 129,
+       158, 205, 52, 142, 142, 222, 195, 137, 86, 192, 248, 127, 238,
+       217, 98, 58, 159, 245, 111, 255, 162, 45, 94, 223, 94, 152, 125,
+       248, 212, 23, 201, 202, 184, 86, 167, 170, 212, 22, 1, 82, 195,
+       117, 203, 48, 64, 127, 251, 19, 253, 162, 146, 28, 255, 125, 142,
+       143, 196, 189, 155, 49, 128, 194, 48, 120, 224, 126, 157, 184, 83,
+       171, 89, 176, 171, 156, 158, 212, 33, 174, 145, 95, 149, 150, 41,
+       34, 212, 95, 24, 186, 254, 133, 132, 67, 95, 91, 25, 227, 164,
+       150, 98, 159, 66, 1, 192, 222, 163, 57, 172, 179, 100, 126, 255,
+       149, 199, 141, 155, 180, 232, 240, 100, 143, 128, 175, 255, 53,
+       126, 31, 196, 64, 169, 143, 51, 238, 95, 7, 115, 221, 151, 73, 11,
+       186, 204, 127, 129, 187, 191, 31, 16, 93, 208, 150, 109, 154, 196,
+       191, 223, 185, 212, 148, 92, 57, 248, 67, 229, 87, 210, 49, 70,
+       224, 24, 31, 23, 33, 25, 166, 217, 21, 98, 41, 38, 16, 63, 241,
+       193, 2, 46, 48, 113, 39, 251, 213, 247, 219, 166, 234, 96, 38,
+       252, 250, 202, 57, 238, 117, 242, 233, 114, 55, 87, 110, 226, 113,
+       67, 142, 110, 184, 166, 111, 172, 172, 115, 163, 33, 92, 173, 156,
+       214, 141, 107, 69, 239, 59, 182, 140, 26, 223, 51, 65, 31, 35,
+       246, 109, 186, 104, 75, 203, 122, 249, 135, 223, 61, 162, 112,
+       143, 42, 220, 23, 156, 212, 138, 42, 21, 175, 182, 190, 150, 59,
+       198, 227, 195, 75, 113, 214, 236, 50, 104, 103, 203, 10, 248, 163,
+       119, 31, 162, 120, 173, 11, 29, 97, 107, 227, 52, 88, 123, 208,
+       229, 228, 182, 130, 187, 95, 219, 98, 110, 252, 223, 238, 204,
+       176, 236, 172, 199, 201, 162, 161, 39, 159, 118, 232, 162, 16, 87,
+       225, 109, 15, 248, 99, 13, 59, 176, 90, 158, 27, 52, 91, 238, 145,
+       95, 161, 249, 175, 81, 200, 149, 152, 218, 246, 93, 8, 97, 139, 6,
+       138, 188, 211, 233, 136, 188, 135, 191, 55, 82, 49, 140, 234, 76,
+       74, 195, 127, 43, 145, 22, 216, 203, 224, 15, 22, 222, 67, 128,
+       80, 133, 142, 6, 136, 148, 179, 165, 40, 188, 135, 175, 55, 18,
+       145, 172, 43, 78, 79, 195, 91, 235, 17, 22, 216, 67, 224, 142,
+       210, 222, 67, 134, 92, 149, 142, 62, 76, 126, 250, 197, 126, 252,
+       194, 253, 18, 102, 3, 75, 235, 63, 219, 251, 233, 131, 162, 36,
+       245, 30, 204, 67, 251, 67, 5, 215, 253, 105, 130, 225, 120, 107,
+       64, 80, 221, 163, 80, 112, 236, 228, 8, 146, 149, 215, 52, 60,
+       172, 82, 126, 131, 63, 244, 14, 95, 13, 33, 124, 75, 141, 66, 244,
+       63, 72, 230, 161, 230, 11, 238, 204, 13, 243, 18, 215, 25, 8, 255,
+       136, 111, 197, 23, 255, 213, 180, 29, 224, 94, 75, 255, 244, 239,
+       191, 217, 148, 122, 128, 14, 190, 9, 210, 26, 97, 164, 13, 207,
+       131, 97, 206, 62, 80, 216, 161, 189, 167, 76, 135, 10, 29, 211,
+       231, 234, 201, 49, 6, 60, 82, 63, 104, 101, 227, 37, 219, 90, 80,
+       101, 240, 247, 131, 155, 31, 215, 127, 110, 156, 93, 238, 204,
+       240, 111, 180, 199, 217, 193, 135, 103, 175, 84, 100, 2, 156, 182,
+       148, 101, 244, 177, 103, 173, 77, 90, 21, 172, 188, 54, 4, 164,
+       43, 187, 5, 22, 185, 50, 199, 7, 54, 90, 75, 0, 76, 53, 223, 186,
+       50, 120, 192, 59, 213, 153, 83, 137, 125, 180, 189, 12, 158, 246,
+       61, 134, 177, 213, 21, 135, 11, 48, 212, 211, 89, 26, 251, 94,
+       132, 7, 127, 66, 48, 248, 192, 127, 212, 216, 19, 139, 105, 180,
+       239, 12, 159, 214, 50, 134, 185, 223, 149, 134, 11, 180, 192, 67,
+       88, 154, 251, 135, 132, 7, 223, 98, 48, 19, 172, 124, 79, 216, 67,
+       45, 168, 240, 107, 158, 158, 36, 17, 206, 189, 95, 161, 9, 59,
+       208, 200, 149, 144, 154, 186, 72, 40, 3, 187, 98, 48, 51, 172,
+       108, 77, 184, 107, 169, 168, 208, 73, 190, 158, 100, 82, 204, 53,
+       127, 33, 1, 15, 146, 217, 145, 20, 10, 186, 24, 40, 7, 187, 187,
+       192, 124, 125, 127, 87, 217, 120, 16, 112, 244, 138, 121, 93, 18,
+       33, 76, 148, 179, 237, 170, 254, 115, 157, 71, 235, 248, 145, 119,
+       140, 88, 250, 242, 153, 44, 186, 25, 192, 146, 162, 134, 85, 196,
+       1, 176, 222, 34, 81, 200, 243, 185, 193, 126, 11, 90, 61, 235,
+       227, 154, 91, 17, 1, 44, 90, 93, 85, 85, 204, 154, 70, 71, 185,
+       165, 242, 162, 68, 95, 115, 169, 247, 118, 212, 124, 234, 233, 71,
+       121, 76, 179, 170, 101, 22, 58, 179, 160, 49, 180, 148, 249, 224,
+       134, 98, 87, 171, 83, 119, 189, 51, 91, 127, 72, 43, 123, 215, 21,
+       178, 56, 102, 121, 130, 251, 207, 237, 199, 181, 240, 228, 115,
+       80, 172, 156, 183, 142, 106, 77, 39, 59, 183, 142, 58, 239, 35,
+       64, 83, 35, 247, 125, 129, 120, 219, 201, 234, 221, 166, 255, 49,
+       164, 96, 151, 42, 25, 197, 87, 111, 148, 66, 71, 253, 100, 192,
+       235, 66, 115, 115, 56, 97, 120, 228, 12, 234, 73, 177, 61, 61,
+       241, 170, 167, 20, 57, 178, 240, 40, 25, 133, 7, 175, 148, 134,
+       111, 252, 100, 0, 202, 70, 113, 99, 56, 96, 120, 230, 8, 238, 121,
+       145, 29, 63, 241, 174, 163, 68, 57, 163, 224, 40, 133, 137, 87,
+       251, 246, 194, 170, 196, 62, 0, 83, 194, 245, 194, 185, 96, 114,
+       63, 58, 219, 115, 156, 31, 255, 60, 46, 154, 64, 52, 131, 33, 168,
+       18, 203, 94, 251, 100, 137, 108, 97, 237, 16, 115, 199, 175, 139,
+       52, 192, 110, 237, 47, 207, 196, 184, 15, 253, 182, 250, 210, 1,
+       111, 179, 233, 132, 60, 73, 227, 237, 55, 217, 123, 68, 101, 164,
+       247, 2, 43, 137, 213, 112, 106, 252, 127, 218, 204, 178, 229, 128,
+       247, 249, 134, 1, 103, 159, 116, 170, 34, 146, 103, 209, 117, 158,
+       248, 51, 57, 121, 82, 247, 140, 60, 20, 164, 175, 29, 247, 145,
+       149, 248, 209, 197, 15, 126, 218, 195, 206, 12, 87, 159, 2, 144,
+       165, 213, 53, 221, 248, 51, 159, 121, 82, 247, 172, 60, 20, 163,
+       174, 23, 255, 1, 183, 248, 81, 197, 143, 126, 218, 195, 206, 12,
+       23, 223, 42, 48, 245, 229, 99, 223, 185, 83, 77, 109, 118, 39,
+       172, 30, 6, 60, 238, 189, 151, 145, 133, 250, 112, 196, 71, 89,
+       90, 131, 103, 12, 7, 223, 31, 16, 246, 213, 175, 54, 120, 123,
+       141, 186, 182, 35, 76, 63, 103, 239, 231, 149, 183, 184, 180, 211,
+       1, 200, 91, 219, 223, 135, 131, 228, 105, 135, 151, 107, 231, 68,
+       230, 22, 238, 212, 97, 226, 114, 66, 25, 56, 245, 191, 46, 197,
+       86, 255, 229, 253, 165, 232, 62, 40, 228, 128, 239, 181, 242, 205,
+       63, 36, 103, 195, 228, 59, 234, 192, 108, 115, 83, 210, 25, 8,
+       221, 173, 43, 204, 18, 255, 149, 180, 45, 240, 20, 72, 219, 228,
+       231, 223, 243, 164, 63, 128, 70, 136, 31, 179, 200, 105, 197, 80,
+       209, 19, 72, 216, 62, 229, 120, 136, 154, 189, 143, 135, 77, 212,
+       154, 90, 139, 87, 63, 15, 120, 198, 157, 22, 23, 237, 26, 38, 11,
+       122, 20, 136, 222, 102, 245, 115, 161, 229, 118, 117, 61, 184,
+       169, 133, 1, 159, 169, 228, 171, 132, 170, 225, 33, 49, 134, 226,
+       169, 187, 124, 225, 185, 206, 30, 31, 80, 51, 180, 222, 123, 72,
+       219, 11, 23, 149, 50, 70, 106, 243, 77, 4, 186, 236, 148, 25, 181,
+       203, 208, 142, 156, 181, 156, 98, 209, 47, 83, 191, 146, 58, 231,
+       59, 0, 75, 105, 247, 109, 161, 56, 239, 203, 142, 217, 226, 255,
+       19, 165, 104, 165, 43, 16, 143, 83, 239, 146, 130, 110, 240, 52,
+       0, 90, 194, 117, 99, 56, 64, 114, 238, 6, 238, 57, 152, 13, 127,
+       252, 174, 162, 192, 45, 163, 32, 168, 66, 176, 248, 213, 107, 133,
+       25, 51, 29, 233, 214, 239, 188, 30, 70, 114, 206, 181, 191, 129,
+       140, 222, 243, 205, 95, 94, 218, 242, 4, 12, 5, 95, 11, 50, 119,
+       237, 109, 95, 249, 88, 207, 200, 52, 239, 155, 157, 182, 166, 174,
+       48, 255, 93, 133, 161, 55, 216, 199, 217, 33, 139, 94, 142, 117,
+       247, 107, 48, 234, 80, 121, 213, 153, 87, 139, 93, 149, 189, 44,
+       156, 246, 62, 134, 185, 213, 149, 151, 15, 178, 193, 83, 89, 152,
+       251, 6, 132, 30, 127, 82, 16, 59, 136, 61, 197, 208, 107, 173, 76,
+       176, 13, 14, 158, 38, 88, 236, 177, 223, 33, 132, 47, 48, 221,
+       147, 48, 26, 251, 80, 8, 39, 95, 12, 88, 245, 241, 7, 103, 41,
+       146, 46, 243, 82, 210, 157, 23, 65, 203, 99, 149, 191, 145, 33,
+       212, 83, 160, 197, 194, 250, 68, 172, 81, 37, 51, 221, 221, 21,
+       233, 154, 7, 71, 184, 85, 192, 174, 68, 223, 115, 41, 244, 87,
+       210, 28, 234, 249, 129, 121, 63, 233, 238, 39, 20, 58, 243, 161,
+       49, 178, 18, 220, 189, 58, 43, 144, 110, 158, 183, 178, 247, 199,
+       104, 6, 11, 223, 85, 237, 32, 44, 237, 75, 31, 200, 182, 119, 215,
+       85, 40, 45, 155, 93, 77, 71, 175, 18, 14, 79, 185, 100, 192, 203,
+       70, 115, 99, 153, 119, 114, 228, 108, 238, 233, 145, 157, 45, 240,
+       232, 231, 0, 44, 178, 224, 40, 51, 52, 209, 245, 118, 47, 184, 99,
+       25, 163, 208, 218, 140, 56, 20, 175, 255, 191, 87, 181, 177, 250,
+       209, 206, 140, 94, 218, 242, 205, 172, 83, 149, 162, 162, 110, 26,
+       79, 241, 176, 71, 219, 87, 101, 191, 40, 200, 126, 159, 235, 43,
+       163, 149, 182, 111, 38, 209, 30, 24, 90, 107, 215, 12, 238, 222,
+       234, 152, 117, 219, 45, 220, 216, 19, 139, 93, 53, 57, 172, 157,
+       22, 47, 134, 51, 245, 5, 150, 108, 242, 209, 67, 122, 216, 219,
+       87, 140, 85, 127, 114, 16, 179, 240, 85, 236, 249, 67, 41, 77,
+       242, 31, 14, 31, 54, 88, 238, 181, 151, 145, 140, 191, 176, 192,
+       147, 248, 154, 67, 195, 12, 103, 95, 82, 16, 58, 136, 63, 215,
+       144, 75, 141, 108, 176, 47, 14, 158, 38, 89, 236, 145, 223, 1, 12,
+       15, 48, 221, 147, 80, 26, 251, 16, 12, 39, 95, 66, 48, 58, 136,
+       123, 213, 144, 75, 143, 77, 148, 41, 140, 158, 102, 92, 204, 57,
+       223, 145, 6, 11, 242, 213, 147, 16, 26, 251, 16, 12, 37, 87, 106,
+       74, 231, 117, 101, 242, 252, 23, 113, 95, 118, 151, 11, 44, 22,
+       203, 200, 166, 181, 5, 172, 252, 53, 132, 71, 123, 208, 129, 231,
+       205, 244, 86, 218, 32, 242, 164, 75, 70, 89, 75, 137, 230, 144,
+       139, 13, 191, 119, 91, 230, 181, 253, 165, 196, 71, 150, 200, 211,
+       89, 207, 175, 39, 228, 53, 74, 204, 56, 251, 240, 198, 68, 253,
+       208, 176, 210, 36, 2, 89, 223, 89, 59, 55, 249, 19, 250, 67, 84,
+       186, 202, 95, 137, 175, 45, 167, 243, 110, 178, 34, 143, 36, 154,
+       253, 217, 146, 162, 223, 85, 16, 187, 172, 232, 190, 196, 203,
+       107, 171, 83, 54, 41, 78, 183, 42, 86, 154, 251, 22, 13, 221, 79,
+       16, 133, 62, 175, 146, 134, 191, 125, 4, 13, 219, 3, 245, 111, 58,
+       64, 246, 19, 31, 165, 90, 137, 25, 93, 225, 165, 170, 192, 53, 2,
+       165, 194, 208, 14, 172, 245, 188, 235, 209, 7, 119, 63, 210, 59,
+       195, 40, 22, 75, 233, 183, 109, 145, 56, 253, 195, 166, 212, 243,
+       251, 211, 165, 72, 244, 2, 193, 141, 7, 159, 84, 142, 230, 230,
+       124, 161, 194, 82, 224, 98, 52, 96, 120, 110, 106, 76, 112, 253,
+       69, 111, 60, 46, 146, 64, 32, 136, 240, 172, 3, 134, 220, 245,
+       108, 7, 188, 111, 159, 187, 154, 243, 140, 58, 244, 67, 239, 151,
+       127, 165, 252, 201, 65, 220, 158, 26, 255, 183, 156, 232, 169, 9,
+       66, 168, 243, 252, 118, 74, 248, 107, 59, 160, 112, 33, 62, 159,
+       244, 53, 166, 189, 87, 17, 194, 107, 130, 217, 155, 222, 27, 174,
+       68, 160, 99, 169, 91, 99, 122, 236, 46, 148, 91, 88, 227, 76, 244,
+       162, 25, 223, 254, 118, 126, 189, 253, 236, 206, 35, 230, 193,
+       210, 249, 163, 174, 55, 166, 112, 117, 226, 176, 234, 26, 79, 244,
+       144, 71, 203, 85, 165, 31, 40, 156, 118, 62, 233, 179, 243, 149,
+       150, 111, 182, 241, 27, 16, 154, 123, 215, 4, 255, 94, 10, 144,
+       118, 243, 101, 252, 249, 16, 171, 93, 55, 25, 172, 159, 54, 63,
+       134, 49, 245, 17, 134, 108, 50, 241, 71, 217, 80, 195, 71, 133,
+       71, 127, 114, 16, 58, 184, 15, 212, 209, 67, 13, 77, 246, 31, 14,
+       30, 38, 93, 232, 145, 223, 129, 12, 175, 48, 213, 147, 248, 154,
+       211, 17, 12, 45, 95, 74, 184, 180, 156, 75, 213, 176, 75, 139,
+       253, 132, 15, 172, 220, 70, 142, 172, 61, 251, 17, 6, 75, 178,
+       209, 27, 81, 91, 123, 18, 4, 63, 223, 106, 184, 180, 186, 107,
+       212, 144, 142, 203, 253, 148, 45, 172, 220, 70, 246, 135, 55, 249,
+       17, 134, 75, 251, 241, 91, 81, 95, 251, 150, 4, 47, 95, 11, 72,
+       118, 90, 133, 182, 116, 151, 245, 95, 102, 20, 8, 184, 55, 125,
+       225, 162, 180, 140, 188, 252, 52, 229, 67, 123, 210, 67, 211, 213,
+       232, 78, 6, 58, 191, 178, 44, 233, 185, 2, 142, 191, 23, 161, 156,
+       159, 99, 11, 135, 49, 127, 17, 134, 69, 170, 224, 207, 17, 123,
+       187, 132, 233, 5, 67, 178, 42, 238, 221, 44, 43, 144, 7, 63, 55,
+       246, 183, 195, 8, 150, 75, 203, 14, 237, 16, 46, 253, 195, 144,
+       130, 242, 242, 211, 197, 200, 252, 143, 114, 236, 134, 148, 91,
+       139, 36, 111, 182, 162, 226, 139, 98, 226, 48, 17, 121, 237, 106,
+       229, 108, 223, 157, 127, 185, 38, 223, 20, 97, 40, 162, 14, 244,
+       36, 21, 204, 92, 3, 226, 105, 216, 162, 161, 26, 82, 112, 0, 55,
+       121, 212, 106, 163, 56, 111, 203, 206, 189, 166, 207, 124, 161,
+       40, 114, 160, 35, 147, 246, 237, 108, 22, 216, 57, 143, 25, 242,
+       227, 201, 223, 188, 226, 222, 149, 191, 193, 140, 146, 67, 209,
+       198, 251, 203, 150, 63, 174, 120, 7, 50, 16, 58, 216, 7, 213, 144,
+       67, 13, 77, 180, 51, 142, 30, 38, 221, 232, 145, 223, 145, 14,
+       143, 112, 208, 147, 81, 154, 91, 19, 12, 45, 223, 50, 48, 42, 200,
+       29, 213, 144, 67, 143, 109, 212, 11, 12, 158, 102, 140, 236, 185,
+       219, 145, 14, 11, 112, 208, 147, 81, 154, 251, 18, 12, 61, 215,
+       114, 31, 59, 172, 106, 37, 185, 121, 0, 200, 249, 239, 48, 191,
+       161, 48, 236, 179, 87, 165, 200, 11, 194, 29, 81, 136, 170, 186,
+       57, 170, 54, 251, 80, 32, 183, 220, 13, 231, 1, 74, 246, 176, 198,
+       2, 112, 211, 100, 102, 112, 252, 106, 168, 11, 237, 187, 221, 153,
+       34, 83, 22, 18, 32, 117, 46, 135, 45, 213, 137, 206, 47, 238, 107,
+       94, 162, 232, 82, 228, 226, 117, 37, 123, 207, 74, 189, 118, 83,
+       77, 218, 156, 30, 15, 52, 149, 120, 97, 140, 192, 131, 214, 188,
+       236, 0, 236, 207, 190, 22, 242, 227, 236, 227, 49, 74, 243, 71,
+       111, 189, 114, 79, 131, 211, 252, 62, 255, 141, 148, 240, 97, 136,
+       38, 236, 215, 241, 117, 203, 234, 192, 255, 48, 178, 138, 175,
+       248, 93, 133, 187, 185, 95, 49, 43, 241, 84, 221, 188, 218, 143,
+       118, 141, 184, 83, 140, 61, 233, 106, 226, 22, 215, 91, 240, 65,
+       224, 253, 138, 27, 205, 211, 48, 126, 168, 21, 255, 203, 179, 188,
+       188, 251, 205, 161, 248, 103, 139, 114, 120, 189, 233, 107, 72,
+       86, 135, 107, 244, 64, 192, 124, 198, 49, 197, 177, 48, 126, 168,
+       19, 254, 203, 186, 36, 62, 124, 13, 165, 228, 63, 154, 114, 248,
+       106, 48, 34, 152, 79, 221, 176, 67, 143, 101, 133, 143, 172, 140,
+       102, 140, 232, 185, 203, 21, 22, 43, 242, 208, 23, 81, 26, 123,
+       87, 12, 63, 222, 45, 145, 173, 235, 188, 70, 235, 157, 70, 77, 95,
+       6, 209, 93, 248, 96, 88, 12, 59, 253, 219, 168, 127, 145, 237, 45,
+       175, 196, 181, 138, 244, 240, 246, 72, 147, 254, 197, 228, 110,
+       192, 161, 10, 99, 2, 51, 223, 105, 122, 232, 253, 53, 194, 10,
+       151, 154, 224, 145, 225, 202, 3, 161, 123, 100, 34, 49, 165, 74,
+       33, 212, 15, 97, 105, 53, 225, 235, 24, 23, 1, 50, 16, 56, 140,
+       68, 60, 57, 187, 17, 30, 248, 140, 33, 68, 233, 138, 210, 128,
+       183, 93, 99, 12, 23, 119, 134, 216, 85, 192, 224, 230, 98, 220,
+       181, 228, 126, 232, 146, 103, 173, 167, 60, 190, 50, 108, 1, 58,
+       127, 191, 120, 244, 133, 111, 17, 251, 236, 45, 111, 184, 254, 26,
+       120, 68, 247, 227, 233, 107, 147, 72, 78, 110, 227, 68, 138, 115,
+       228, 136, 103, 44, 24, 243, 193, 161, 164, 207, 200, 155, 220,
+       169, 198, 236, 214, 146, 249, 250, 243, 96, 249, 1, 89, 234, 6,
+       107, 122, 102, 78, 63, 44, 134, 231, 188, 221, 251, 216, 128, 228,
+       184, 177, 218, 153, 205, 147, 202, 139, 61, 169, 9, 166, 223, 108,
+       22, 201, 115, 233, 82, 10, 107, 250, 179, 153, 148, 21, 123, 80,
+       11, 7, 106, 164, 228, 147, 205, 204, 11, 36, 238, 118, 178, 232,
+       66, 192, 243, 104, 71, 121, 204, 106, 170, 80, 119, 202, 82, 60,
+       128, 199, 44, 144, 122, 226, 136, 35, 173, 67, 73, 213, 151, 170,
+       214, 77, 65, 120, 198, 40, 200, 180, 164, 124, 42, 18, 220, 151,
+       186, 52, 253, 44, 28, 142, 234, 223, 158, 250, 188, 246, 178, 62,
+       154, 75, 245, 152, 194, 155, 93, 149, 59, 44, 222, 110, 159, 239,
+       147, 223, 145, 182, 79, 58, 241, 27, 81, 154, 255, 151, 5, 47, 87,
+       10, 2, 98, 154, 101, 241, 216, 70, 143, 85, 180, 147, 172, 142,
+       118, 205, 238, 177, 159, 149, 22, 15, 34, 241, 147, 81, 154, 251,
+       151, 13, 61, 222, 11, 178, 182, 28, 41, 156, 113, 27, 255, 93,
+       118, 53, 46, 216, 102, 95, 165, 33, 236, 21, 134, 237, 179, 209,
+       75, 123, 81, 223, 210, 4, 79, 95, 53, 40, 155, 34, 16, 102, 66,
+       64, 116, 169, 235, 24, 23, 146, 32, 120, 248, 173, 4, 24, 29, 187,
+       129, 0, 153, 164, 50, 64, 224, 3, 42, 0, 114, 182, 45, 46, 88,
+       175, 146, 120, 3, 109, 185, 239, 50, 28, 134, 48, 204, 149, 223,
+       165, 143, 59, 121, 29, 87, 28, 168, 186, 93, 11, 86, 95, 72, 132,
+       58, 122, 113, 232, 113, 66, 251, 31, 109, 16, 62, 215, 40, 84,
+       163, 50, 76, 24, 50, 45, 170, 119, 219, 191, 18, 75, 210, 1, 103,
+       35, 30, 176, 186, 250, 155, 225, 27, 200, 151, 31, 165, 51, 92,
+       223, 106, 88, 247, 153, 159, 146, 58, 7, 10, 243, 219, 199, 187,
+       255, 176, 3, 45, 67, 30, 150, 59, 171, 178, 227, 187, 218, 30, 69,
+       89, 179, 221, 255, 42, 64, 247, 27, 23, 177, 146, 144, 40, 215,
+       201, 165, 171, 204, 180, 75, 165, 243, 134, 154, 234, 152, 218,
+       165, 187, 200, 30, 87, 80, 183, 20, 206, 111, 8, 255, 89, 179,
+       149, 134, 86, 46, 242, 93, 6, 187, 239, 149, 121, 53, 211, 166,
+       237, 230, 222, 188, 35, 206, 236, 91, 178, 153, 242, 241, 232,
+       189, 9, 219, 238, 55, 239, 248, 231, 207, 255, 40, 62, 239, 188,
+       213, 251, 240, 128, 70, 3, 222, 230, 118, 10, 248, 96, 169, 133,
+       242, 199, 236, 235, 61, 74, 250, 237, 111, 213, 16, 195, 130, 200,
+       94, 62, 255, 137, 133, 170, 103, 137, 11, 162, 210, 27, 65, 188,
+       184, 67, 255, 21, 101, 149, 172, 136, 126, 252, 227, 43, 162, 20,
+       150, 252, 182, 241, 6, 120, 82, 75, 210, 4, 239, 204, 184, 197,
+       61, 232, 189, 73, 86, 239, 133, 10, 248, 51, 87, 125, 40, 193,
+       200, 147, 159, 99, 120, 171, 67, 189, 243, 241, 52, 91, 116, 88,
+       244, 107, 240, 73, 23, 254, 45, 192, 86, 70, 141, 10, 194, 42,
+       166, 155, 33, 203, 200, 243, 239, 66, 72, 135, 66, 161, 177, 241,
+       90, 27, 16, 27, 180, 43, 50, 82, 235, 111, 22, 119, 83, 80, 69,
+       77, 255, 102, 82, 29, 183, 108, 124, 152, 151, 227, 137, 182, 97,
+       190, 19, 238, 176, 130, 119, 159, 116, 119, 21, 228, 209, 227,
+       180, 42, 110, 175, 121, 179, 186, 88, 215, 35, 24, 49, 123, 199,
+       14, 58, 57, 248, 73, 102, 188, 158, 215, 68, 196, 248, 195, 40,
+       75, 132, 210, 91, 113, 248, 120, 3, 127, 75, 119, 112, 108, 250,
+       190, 252, 179, 42, 166, 152, 55, 188, 6, 247, 14, 126, 16, 195,
+       158, 132, 233, 13, 105, 121, 202, 6, 65, 28, 100, 119, 33, 194,
+       110, 69, 60, 163, 19, 210, 48, 238, 178, 78, 69, 154, 146, 105,
+       118, 45, 116, 0, 42, 246, 250, 154, 37, 57, 251, 69, 254, 121,
+       179, 192, 202, 237, 126, 34, 16, 188, 247, 34, 234, 108, 50, 91,
+       149, 48, 255, 160, 79, 13, 37, 38, 197, 107, 84, 245, 115, 52,
+       189, 244, 108, 38, 217, 122, 27, 234, 179, 126, 84, 63, 20, 51,
+       157, 213, 117, 163, 169, 227, 217, 202, 89, 190, 253, 150, 73, 96,
+       114, 59, 138, 184, 115, 219, 211, 241, 184, 67, 31, 81, 81, 179,
+       44, 222, 108, 172, 255, 27, 147, 145, 51, 158, 42, 243, 13, 20,
+       154, 235, 151, 12, 181, 183, 60, 37, 121, 107, 182, 235, 214, 73,
+       30, 35, 125, 41, 87, 93, 41, 9, 155, 27, 135, 51, 58, 48, 72, 31,
+       227, 207, 33, 119, 241, 203, 198, 163, 144, 211, 21, 236, 43, 201,
+       20, 109, 140, 0, 129, 104, 174, 83, 8, 129, 130, 49, 207, 97, 74,
+       7, 66, 157, 177, 208, 72, 59, 16, 8, 135, 43, 124, 39, 170, 36,
+       156, 91, 87, 57, 226, 172, 143, 40, 211, 241, 210, 50, 16, 228,
+       108, 56, 220, 99, 230, 14, 251, 197, 37, 125, 96, 106, 214, 98,
+       188, 95, 99, 235, 133, 114, 231, 212, 69, 78, 127, 118, 65, 13,
+       187, 108, 120, 206, 135, 202, 205, 182, 109, 162, 102, 233, 224,
+       129, 127, 223, 244, 247, 255, 242, 104, 3, 21, 221, 115, 144, 113,
+       109, 183, 255, 139, 220, 206, 52, 120, 172, 222, 86, 143, 182,
+       253, 183, 215, 93, 16, 243, 107, 15, 94, 119, 132, 176, 187, 187,
+       114, 224, 187, 200, 30, 91, 81, 51, 220, 223, 104, 72, 247, 25,
+       19, 145, 51, 148, 42, 215, 205, 7, 187, 206, 148, 1, 37, 243, 134,
+       122, 187, 184, 238, 225, 185, 200, 158, 94, 80, 179, 20, 222, 111,
+       11, 255, 89, 19, 211, 38, 71, 138, 240, 93, 0, 235, 239, 149, 57,
+       53, 211, 177, 143, 1, 39, 52, 43, 103, 50, 116, 170, 234, 68, 243,
+       33, 144, 80, 80, 238, 12, 46, 249, 184, 69, 46, 236, 175, 165, 0,
+       40, 234, 64, 40, 20, 47, 198, 119, 146, 171, 102, 6, 54, 163, 107,
+       224, 115, 99, 193, 88, 113, 238, 106, 26, 56, 208, 73, 62, 44,
+       134, 117, 0, 233, 251, 192, 8, 227, 237, 6, 31, 220, 11, 166, 239,
+       190, 18, 193, 82, 192, 224, 60, 83, 233, 206, 106, 238, 126, 79,
+       207, 119, 60, 34, 223, 124, 16, 58, 243, 140, 33, 217, 107, 74,
+       84, 199, 239, 244, 68, 64, 244, 2, 112, 213, 180, 36, 88, 168, 18,
+       234, 193, 187, 60, 253, 119, 12, 132, 104, 119, 154, 242, 224, 51,
+       141, 97, 137, 213, 151, 202, 231, 76, 64, 88, 198, 41, 72, 182,
+       160, 216, 171, 146, 245, 223, 186, 116, 189, 44, 77, 138, 200,
+       125, 14, 248, 220, 66, 159, 106, 142, 178, 224, 31, 55, 5, 69,
+       206, 163, 52, 167, 162, 80, 118, 187, 63, 132, 26, 154, 1, 255,
+       248, 36, 170, 201, 52, 130, 164, 123, 82, 91, 163, 236, 34, 0, 15,
+       148, 33, 140, 206, 160, 53, 166, 161, 116, 118, 245, 61, 203, 201,
+       131, 160, 104, 177, 164, 170, 136, 36, 243, 37, 121, 88, 214, 126,
+       127, 42, 80, 148, 39, 204, 14, 254, 162, 111, 62, 38, 98, 230, 51,
+       173, 0, 68, 173, 35, 197, 67, 231, 114, 147, 113, 200, 237, 15,
+       255, 120, 233, 17, 19, 220, 115, 144, 99, 77, 246, 157, 203, 84,
+       206, 124, 108, 188, 236, 220, 143, 182, 247, 224, 223, 125, 0,
+       211, 235, 133, 70, 119, 132, 78, 131, 183, 74, 171, 38, 206, 62,
+       130, 75, 195, 247, 224, 97, 64, 121, 238, 106, 71, 104, 214, 207,
+       58, 180, 34, 207, 0, 32, 251, 49, 136, 4, 225, 149, 243, 206, 11,
+       164, 237, 246, 51, 227, 66, 213, 115, 72, 75, 121, 94, 106, 250,
+       80, 240, 203, 16, 44, 162, 215, 68, 176, 122, 161, 162, 95, 19,
+       198, 166, 129, 6, 90, 17, 33, 225, 227, 199, 75, 238, 67, 218,
+       244, 229, 181, 246, 29, 209, 153, 128, 154, 251, 205, 197, 171,
+       167, 168, 18, 119, 19, 135, 140, 228, 2, 140, 237, 157, 91, 218,
+       247, 64, 108, 190, 207, 248, 197, 23, 165, 189, 163, 4, 200, 48,
+       50, 254, 134, 157, 124, 240, 85, 221, 207, 214, 174, 238, 2, 111,
+       168, 230, 146, 139, 194, 213, 227, 249, 195, 115, 198, 42, 238,
+       96, 65, 143, 106, 188, 162, 111, 12, 60, 243, 161, 32, 214, 237,
+       199, 254, 190, 34, 78, 236, 27, 163, 153, 242, 117, 235, 185, 64,
+       119, 215, 125, 239, 120, 67, 143, 255, 184, 174, 239, 252, 181,
+       243, 161, 0, 212, 168, 135, 158, 9, 192, 0, 200, 190, 148, 194, 1,
+       102, 226, 104, 70, 241, 98, 232, 16, 14, 71, 154, 113, 153, 34,
+       79, 91, 16, 42, 37, 6, 5, 232, 135, 147, 84, 140, 232, 128, 110,
+       177, 66, 64, 241, 194, 213, 126, 104, 108, 106, 220, 2, 216, 207,
+       97, 12, 60, 139, 64, 136, 11, 33, 172, 19, 217, 46, 140, 12, 213,
+       158, 165, 204, 64, 222, 7, 240, 120, 54, 96, 200, 99, 59, 197,
+       221, 169, 55, 253, 176, 60, 206, 27, 29, 30, 185, 94, 95, 4, 131,
+       164, 129, 54, 12, 73, 185, 227, 131, 93, 78, 102, 72, 254, 245,
+       197, 221, 181, 61, 195, 152, 194, 153, 118, 223, 94, 138, 102,
+       171, 84, 88, 216, 186, 252, 38, 112, 21, 6, 236, 79, 94, 34, 191,
+       190, 162, 98, 226, 119, 188, 129, 76, 41, 167, 97, 211, 237, 122,
+       139, 36, 80, 45, 107, 230, 235, 144, 154, 153, 193, 130, 238, 143,
+       53, 160, 9, 164, 192, 110, 134, 201, 99, 234, 83, 70, 107, 202,
+       179, 184, 16, 21, 127, 80, 15, 12, 142, 244, 106, 154, 176, 242,
+       200, 50, 196, 50, 129, 160, 57, 159, 147, 65, 24, 182, 253, 229,
+       81, 26, 94, 130, 34, 219, 197, 63, 107, 224, 1, 47, 139, 222, 83,
+       230, 142, 157, 22, 124, 85, 135, 141, 215, 247, 72, 235, 126, 206,
+       116, 101, 191, 213, 148, 197, 143, 194, 122, 125, 175, 207, 175,
+       190, 248, 23, 118, 169, 134, 171, 90, 139, 162, 232, 174, 49, 203,
+       195, 231, 192, 72, 64, 104, 140, 106, 87, 6, 153, 79, 53, 156, 32,
+       11, 112, 113, 10, 35, 140, 59, 72, 135, 190, 13, 54, 90, 166, 133,
+       194, 194, 3, 111, 126, 51, 251, 192, 229, 189, 199, 141, 195, 87,
+       169, 145, 243, 218, 19, 48, 127, 56, 12, 214, 44, 138, 182, 9,
+       240, 90, 194, 185, 194, 136, 137, 46, 222, 87, 158, 225, 229, 217,
+       199, 44, 71, 154, 234, 147, 84, 139, 59, 10, 117, 59, 14, 250,
+       126, 58, 118, 105, 148, 92, 213, 177, 142, 164, 25, 47, 207, 66,
+       91, 213, 249, 197, 210, 110, 79, 242, 106, 243, 209, 244, 187, 34,
+       144, 166, 74, 241, 137, 73, 76, 205, 20, 76, 173, 81, 50, 164, 8,
+       115, 48, 93, 255, 88, 198, 48, 234, 109, 106, 251, 147, 35, 251,
+       197, 60, 27, 248, 216, 140, 213, 237, 219, 150, 250, 40, 110, 236,
+       186, 130, 41, 202, 85, 227, 233, 82, 51, 231, 106, 238, 112, 71,
+       142, 110, 184, 166, 79, 44, 164, 243, 163, 32, 64, 34, 147, 37,
+       82, 10, 99, 40, 122, 165, 99, 200, 245, 35, 128, 16, 50, 76, 98,
+       40, 32, 216, 205, 31, 92, 166, 51, 68, 32, 160, 3, 160, 89, 134,
+       204, 37, 18, 2, 110, 43, 116, 162, 107, 210, 209, 34, 128, 114,
+       115, 228, 40, 172, 32, 220, 205, 14, 236, 167, 39, 0, 40, 160, 41,
+       8, 56, 233, 16, 122, 85, 205, 66, 228, 81, 0, 224, 9, 43, 217, 32,
+       144, 216, 168, 134, 98, 110, 42, 88, 189, 251, 205, 5, 121, 115,
+       10, 90, 138, 40, 233, 72, 122, 85, 205, 70, 229, 85, 4, 100, 10,
+       51, 89, 50, 17, 88, 170, 2, 88, 106, 186, 88, 61, 127, 201, 4,
+       105, 115, 138, 218, 138, 218, 226, 226, 128, 27, 22, 58, 252, 51,
+       253, 150, 151, 9, 143, 250, 199, 119, 197, 253, 255, 238, 77, 157,
+       226, 122, 97, 159, 199, 39, 133, 61, 94, 232, 169, 184, 112, 153,
+       233, 85, 143, 202, 53, 164, 25, 134, 185, 66, 26, 129, 155, 233,
+       17, 26, 106, 218, 49, 203, 209, 20, 127, 208, 72, 134, 10, 35,
+       180, 176, 83, 213, 191, 176, 75, 78, 113, 125, 22, 130, 120, 94,
+       44, 157, 10, 18, 21, 151, 186, 124, 215, 15, 92, 18, 102, 217, 78,
+       219, 212, 66, 10, 133, 157, 41, 36, 169, 134, 170, 151, 202, 133,
+       172, 166, 65, 206, 197, 87, 233, 133, 0, 64, 211, 224, 133, 118,
+       218, 138, 128, 117, 37, 124, 81, 208, 30, 188, 10, 64, 20, 41,
+       168, 90, 131, 49, 212, 210, 74, 107, 231, 85, 248, 163, 101, 69,
+       139, 65, 208, 163, 127, 31, 8, 48, 171, 19, 167, 41, 229, 65, 217,
+       38, 235, 218, 96, 176, 164, 0, 17, 23, 85, 63, 73, 212, 81, 248,
+       57, 219, 241, 76, 77, 154, 135, 100, 139, 161, 114, 176, 88, 38,
+       81, 230, 54, 42, 90, 58, 25, 162, 49, 218, 191, 43, 16, 208, 55,
+       221, 21, 169, 56, 14, 136, 239, 250, 223, 187, 56, 46, 226, 3, 8,
+       176, 20, 11, 164, 20, 78, 227, 107, 244, 206, 176, 6, 147, 40, 51,
+       194, 105, 129, 78, 165, 41, 175, 48, 206, 185, 134, 155, 20, 201,
+       40, 117, 248, 95, 83, 165, 172, 168, 76, 15, 153, 43, 125, 153,
+       205, 223, 126, 91, 126, 199, 213, 125, 231, 159, 64, 251, 209,
+       129, 250, 239, 190, 156, 247, 129, 117, 38, 98, 161, 219, 48, 101,
+       171, 216, 30, 111, 85, 146, 212, 199, 201, 12, 93, 88, 3, 26, 35,
+       150, 235, 18, 13, 150, 191, 236, 146, 219, 23, 241, 27, 89, 183,
+       180, 135, 221, 188, 246, 173, 192, 10, 79, 190, 188, 55, 162, 164,
+       103, 249, 69, 133, 185, 50, 234, 169, 222, 94, 18, 200, 116, 1,
+       95, 245, 239, 192, 71, 148, 58, 71, 253, 80, 166, 239, 10, 67, 97,
+       147, 20, 89, 198, 0, 238, 124, 242, 237, 46, 250, 238, 165, 20,
+       99, 251, 210, 4, 230, 97, 237, 76, 108, 81, 156, 200, 202, 242,
+       177, 171, 80, 220, 93, 59, 200, 213, 115, 227, 197, 103, 206, 32,
+       87, 9, 205, 189, 69, 59, 94, 150, 92, 135, 40, 162, 188, 61, 90,
+       57, 5, 37, 143, 137, 207, 111, 10, 64, 215, 151, 237, 55, 28, 1,
+       105, 150, 251, 247, 171, 221, 182, 75, 157, 82, 203, 100, 97, 61,
+       126, 189, 168, 28, 254, 226, 0, 222, 173, 76, 211, 237, 54, 41,
+       218, 173, 167, 4, 247, 223, 36, 109, 43, 168, 30, 149, 27, 212,
+       102, 245, 197, 192, 203, 77, 142, 248, 137, 176, 152, 238, 84,
+       119, 77, 191, 15, 213, 251, 243, 73, 67, 218, 224, 61, 16, 205,
+       190, 133, 123, 22, 52, 50, 18, 25, 188, 87, 207, 17, 72, 27, 141,
+       181, 45, 166, 82, 38, 29, 216, 177, 198, 96, 11, 107, 114, 221,
+       153, 146, 82, 123, 88, 8, 15, 95, 108, 247, 216, 168, 56, 4, 90,
+       152, 35, 236, 185, 237, 223, 79, 202, 82, 214, 213, 237, 246, 203,
+       7, 201, 2, 238, 245, 173, 252, 58, 179, 10, 19, 217, 90, 170, 180,
+       61, 157, 122, 182, 174, 232, 146, 77, 191, 173, 115, 194, 132,
+       117, 253, 85, 205, 141, 144, 170, 235, 245, 45, 146, 8, 188, 25,
+       91, 251, 13, 99, 158, 21, 214, 206, 99, 85, 194, 202, 66, 40, 252,
+       53, 229, 216, 174, 146, 141, 237, 175, 52, 239, 51, 124, 138, 10,
+       63, 236, 120, 124, 164, 237, 209, 151, 212, 169, 230, 236, 250,
+       178, 105, 90, 247, 96, 89, 17, 59, 234, 66, 107, 114, 126, 92,
+       127, 44, 134, 69, 44, 213, 123, 211, 136, 117, 79, 69, 68, 142,
+       26, 79, 184, 65, 166, 186, 234, 67, 96, 159, 51, 94, 196, 108,
+       238, 204, 227, 237, 40, 178, 138, 229, 148, 101, 251, 80, 4, 76,
+       117, 167, 164, 206, 102, 175, 216, 128, 242, 152, 203, 213, 117,
+       73, 11, 124, 85, 123, 235, 65, 67, 155, 40, 245, 128, 239, 188,
+       45, 123, 23, 242, 204, 117, 63, 166, 10, 70, 175, 248, 128, 250,
+       153, 74, 213, 223, 105, 35, 124, 85, 123, 227, 73, 199, 250, 40,
+       245, 128, 239, 188, 33, 123, 37, 243, 56, 1, 118, 239, 69, 118,
+       248, 71, 69, 8, 127, 2, 9, 153, 52, 100, 232, 172, 55, 138, 92,
+       176, 147, 193, 67, 249, 128, 1, 103, 202, 248, 130, 245, 98, 204,
+       69, 104, 30, 79, 152, 98, 250, 176, 236, 83, 96, 221, 59, 28, 196,
+       108, 126, 173, 102, 237, 8, 50, 138, 229, 188, 237, 249, 90, 5,
+       183, 253, 113, 242, 150, 103, 223, 172, 91, 99, 57, 90, 119, 254,
+       93, 48, 147, 223, 53, 250, 127, 36, 29, 119, 233, 158, 133, 124,
+       253, 83, 195, 18, 184, 156, 46, 240, 213, 102, 85, 247, 21, 255,
+       230, 23, 3, 45, 38, 75, 201, 214, 163, 48, 56, 255, 113, 142, 123,
+       251, 212, 71, 195, 92, 244, 218, 144, 134, 222, 85, 18, 43, 187,
+       248, 54, 55, 118, 191, 73, 39, 175, 13, 63, 212, 199, 238, 32,
+       245, 13, 95, 82, 131, 97, 133, 119, 249, 77, 219, 155, 105, 110,
+       99, 166, 150, 252, 148, 45, 81, 94, 131, 25, 29, 151, 104, 166,
+       59, 53, 223, 222, 152, 119, 160, 103, 249, 158, 195, 47, 150, 249,
+       93, 73, 73, 110, 198, 71, 214, 239, 21, 224, 132, 111, 2, 121,
+       155, 55, 96, 106, 180, 51, 202, 192, 176, 53, 232, 119, 105, 134,
+       1, 103, 178, 124, 234, 89, 7, 84, 101, 48, 26, 79, 49, 112, 170,
+       255, 228, 251, 35, 128, 244, 22, 230, 236, 110, 249, 176, 101, 14,
+       164, 239, 101, 144, 46, 246, 72, 41, 214, 237, 245, 247, 143, 98,
+       79, 143, 219, 182, 43, 146, 207, 237, 89, 79, 51, 255, 37, 243,
+       120, 252, 255, 226, 239, 246, 221, 69, 229, 241, 198, 114, 236,
+       52, 158, 240, 237, 242, 209, 7, 216, 159, 118, 20, 210, 249, 110,
+       75, 217, 126, 162, 48, 60, 231, 210, 130, 75, 187, 112, 79, 202,
+       73, 248, 131, 50, 72, 82, 254, 69, 130, 84, 100, 165, 0, 224, 3,
+       106, 186, 37, 209, 232, 161, 131, 227, 108, 187, 16, 236, 179,
+       246, 210, 11, 115, 62, 122, 14, 164, 207, 69, 155, 220, 171, 199,
+       236, 214, 50, 105, 210, 193, 97, 57, 133, 89, 74, 2, 122, 114,
+       176, 78, 59, 44, 134, 135, 52, 244, 251, 208, 160, 167, 205, 197,
+       255, 252, 43, 238, 172, 218, 162, 185, 210, 241, 233, 61, 1, 219,
+       102, 51, 111, 112, 102, 78, 255, 44, 30, 207, 60, 213, 251, 208,
+       128, 57, 14, 65, 101, 52, 91, 103, 62, 84, 226, 238, 132, 251, 33,
+       146, 244, 89, 238, 132, 46, 121, 184, 125, 46, 238, 239, 37, 1,
+       42, 238, 88, 56, 24, 204, 236, 247, 133, 244, 252, 167, 247, 55,
+       38, 23, 105, 41, 22, 11, 41, 226, 105, 142, 126, 252, 89, 255,
+       111, 239, 214, 65, 227, 212, 220, 202, 236, 6, 252, 93, 172, 42,
+       148, 55, 216, 159, 247, 177, 194, 109, 140, 75, 71, 118, 237, 34,
+       112, 228, 195, 2, 70, 179, 118, 217, 198, 248, 196, 3, 62, 133,
+       103, 107, 135, 252, 126, 133, 101, 25, 95, 3, 75, 221, 124, 108,
+       248, 155, 181, 203, 218, 176, 58, 241, 71, 248, 196, 195, 247,
+       215, 244, 102, 131, 99, 115, 242, 228, 141, 252, 213, 232, 25,
+       121, 122, 189, 154, 252, 168, 174, 59, 23, 157, 210, 50, 138, 224,
+       36, 216, 190, 234, 69, 218, 227, 137, 170, 150, 215, 177, 242, 42,
+       52, 183, 29, 231, 114, 245, 15, 46, 132, 205, 215, 87, 134, 52,
+       245, 252, 69, 142, 172, 246, 84, 198, 238, 204, 128, 221, 172, 92,
+       120, 104, 199, 123, 215, 214, 80, 38, 244, 26, 27, 29, 33, 57, 91,
+       218, 195, 106, 96, 55, 112, 162, 119, 203, 116, 61, 119, 217, 198,
+       170, 82, 15, 86, 66, 162, 176, 188, 71, 173, 7, 95, 226, 44, 142,
+       164, 198, 38, 51, 238, 144, 208, 153, 36, 224, 178, 48, 26, 131,
+       7, 86, 173, 13, 89, 178, 175, 21, 26, 70, 49, 56, 118, 236, 215,
+       167, 241, 247, 162, 67, 117, 68, 110, 172, 161, 205, 191, 29, 221,
+       167, 247, 132, 41, 33, 37, 115, 15, 221, 227, 78, 251, 84, 127,
+       252, 195, 85, 13, 133, 249, 247, 250, 230, 103, 74, 147, 238, 215,
+       3, 190, 241, 111, 93, 135, 236, 182, 247, 165, 246, 161, 88, 85,
+       89, 110, 71, 133, 62, 87, 250, 182, 116, 152, 16, 133, 45, 14, 52,
+       126, 200, 225, 126, 117, 90, 4, 26, 99, 134, 91, 176, 107, 189,
+       41, 243, 173, 29, 125, 223, 177, 253, 22, 249, 84, 46, 248, 244,
+       194, 164, 93, 124, 166, 76, 135, 242, 123, 157, 79, 67, 119, 237,
+       90, 44, 28, 249, 72, 158, 188, 85, 165, 50, 180, 191, 126, 59,
+       150, 112, 168, 57, 196, 203, 193, 86, 237, 0, 178, 216, 67, 245,
+       78, 115, 254, 135, 142, 212, 252, 27, 136, 254, 213, 247, 247,
+       168, 52, 183, 55, 31, 114, 247, 44, 41, 128, 141, 167, 95, 133, 0,
+       182, 252, 137, 175, 46, 214, 116, 194, 238, 220, 208, 27, 50, 193,
+       102, 254, 125, 134, 222, 105, 137, 9, 241, 3, 104, 90, 60, 1, 220,
+       145, 23, 227, 106, 163, 26, 205, 179, 250, 138, 155, 21, 58, 240,
+       6, 56, 129, 68, 250, 213, 195, 82, 232, 1, 1, 225, 3, 107, 73, 60,
+       197, 216, 139, 131, 194, 90, 170, 72, 189, 179, 242, 146, 91, 119,
+       15, 252, 130, 239, 223, 89, 158, 246, 244, 143, 188, 26, 71, 61,
+       255, 124, 102, 175, 148, 23, 67, 132, 255, 247, 7, 190, 247, 56,
+       23, 175, 252, 156, 119, 175, 117, 172, 79, 236, 214, 228, 126,
+       247, 190, 80, 158, 60, 58, 123, 125, 147, 43, 121, 250, 150, 234,
+       248, 118, 110, 170, 119, 139, 231, 5, 71, 251, 222, 227, 213, 207,
+       215, 142, 140, 50, 206, 172, 228, 146, 139, 194, 205, 226, 249,
+       199, 115, 199, 106, 238, 105, 1, 143, 234, 184, 226, 207, 28, 191,
+       243, 169, 36, 223, 237, 199, 254, 190, 34, 78, 236, 19, 162, 153,
+       243, 125, 235, 185, 192, 127, 215, 125, 231, 120, 195, 143, 255,
+       184, 239, 239, 156, 164, 247, 161, 0, 89, 146, 174, 28, 59, 62,
+       49, 59, 182, 216, 214, 119, 248, 247, 162, 237, 117, 116, 254, 36,
+       133, 197, 187, 157, 219, 99, 127, 198, 10, 36, 61, 119, 173, 77,
+       237, 214, 164, 118, 207, 142, 90, 254, 61, 18, 216, 244, 223, 43,
+       27, 206, 180, 255, 249, 228, 175, 98, 233, 15, 239, 180, 133, 243,
+       214, 117, 152, 149, 218, 178, 179, 248, 54, 231, 58, 75, 127, 51,
+       127, 127, 42, 240, 179, 91, 149, 18, 54, 220, 8, 231, 250, 199,
+       62, 195, 166, 93, 141, 11, 145, 69, 109, 241, 230, 10, 237, 119,
+       84, 51, 82, 146, 145, 41, 144, 41, 110, 146, 19, 173, 240, 252,
+       101, 76, 100, 170, 254, 4, 101, 216, 241, 168, 41, 176, 165, 157,
+       121, 215, 177, 248, 150, 252, 212, 173, 120, 245, 235, 38, 221,
+       120, 242, 116, 135, 194, 106, 157, 95, 67, 103, 255, 82, 172, 36,
+       255, 204, 223, 252, 86, 180, 190, 71, 183, 249, 150, 127, 16, 122,
+       117, 23, 35, 5, 246, 180, 10, 248, 252, 59, 127, 105, 191, 213, 0,
+       193, 243, 212, 104, 101, 125, 161, 78, 205, 117, 198, 204, 211,
+       226, 185, 90, 208, 248, 125, 175, 217, 192, 82, 111, 189, 103,
+       126, 186, 63, 94, 133, 62, 221, 123, 210, 164, 128, 253, 252, 251,
+       244, 172, 119, 183, 62, 55, 110, 21, 244, 127, 10, 73, 131, 123,
+       49, 2, 114, 216, 59, 63, 111, 255, 244, 66, 152, 81, 205, 251, 55,
+       101, 225, 130, 221, 117, 207, 236, 67, 242, 137, 74, 81, 124, 125,
+       166, 217, 206, 18, 255, 189, 50, 252, 178, 61, 92, 141, 124, 189,
+       127, 240, 244, 212, 239, 218, 182, 186, 2, 78, 236, 177, 130, 169,
+       218, 79, 227, 121, 211, 51, 199, 76, 238, 120, 67, 142, 110, 186,
+       231, 71, 45, 173, 243, 171, 0, 93, 161, 166, 21, 25, 214, 49, 232,
+       182, 212, 198, 0, 254, 246, 234, 246, 245, 126, 248, 92, 14, 193,
+       187, 153, 217, 99, 79, 85, 2, 46, 45, 116, 127, 253, 200, 130,
+       220, 55, 142, 220, 2, 224, 153, 207, 81, 108, 95, 130, 125, 198,
+       211, 255, 223, 67, 221, 238, 122, 15, 143, 252, 157, 255, 218,
+       212, 134, 206, 172, 187, 172, 96, 157, 138, 158, 31, 148, 179,
+       229, 236, 123, 75, 207, 67, 63, 135, 38, 69, 239, 243, 196, 35,
+       254, 189, 149, 121, 189, 67, 239, 253, 167, 6, 197, 55, 206, 156,
+       83, 242, 138, 94, 82, 120, 93, 166, 89, 206, 112, 255, 253, 231,
+       253, 170, 59, 14, 197, 52, 207, 255, 218, 20, 73, 48, 135, 13, 27,
+       127, 33, 24, 62, 232, 71, 100, 252, 246, 194, 252, 48, 236, 234,
+       236, 1, 209, 187, 93, 217, 34, 99, 20, 10, 39, 5, 116, 89, 112,
+       135, 141, 27, 87, 33, 56, 54, 208, 199, 6, 240, 246, 98, 100, 112,
+       124, 106, 224, 33, 193, 187, 93, 217, 35, 71, 4, 42, 35, 37, 112,
+       41, 241, 175, 157, 27, 215, 177, 232, 150, 220, 196, 2, 244, 247,
+       106, 98, 89, 124, 162, 84, 67, 67, 250, 29, 77, 35, 111, 109, 16,
+       42, 37, 250, 245, 118, 156, 230, 168, 63, 22, 216, 138, 186, 177,
+       104, 87, 114, 201, 59, 151, 85, 124, 98, 237, 103, 75, 56, 178,
+       203, 101, 190, 216, 123, 11, 3, 40, 225, 140, 157, 90, 211, 161,
+       205, 150, 252, 252, 171, 240, 212, 234, 2, 121, 236, 226, 112, 70,
+       98, 239, 29, 92, 3, 111, 237, 113, 46, 4, 251, 88, 98, 23, 141,
+       15, 67, 35, 72, 46, 228, 195, 6, 220, 194, 33, 192, 114, 141, 106,
+       227, 65, 215, 179, 80, 145, 32, 139, 8, 8, 19, 37, 96, 32, 101,
+       78, 141, 76, 195, 163, 76, 142, 172, 248, 171, 0, 192, 246, 0, 72,
+       140, 106, 195, 66, 99, 207, 81, 52, 32, 169, 189, 85, 26, 126,
+       200, 153, 208, 151, 221, 29, 206, 33, 168, 246, 240, 195, 2, 242,
+       215, 32, 230, 113, 124, 122, 120, 1, 245, 187, 93, 137, 170, 71,
+       4, 2, 42, 101, 34, 32, 177, 183, 254, 122, 193, 177, 232, 158,
+       156, 248, 34, 244, 247, 105, 66, 89, 123, 107, 80, 2, 99, 170,
+       125, 77, 162, 111, 111, 80, 42, 37, 227, 220, 145, 149, 203, 141,
+       105, 134, 140, 30, 179, 161, 88, 222, 114, 73, 234, 217, 213, 236,
+       114, 27, 103, 219, 18, 169, 214, 71, 126, 216, 123, 133, 2, 124,
+       117, 188, 231, 140, 103, 86, 156, 82, 186, 191, 14, 83, 121, 89,
+       58, 217, 214, 125, 98, 233, 99, 217, 42, 251, 207, 101, 52, 233,
+       123, 88, 3, 32, 163, 252, 188, 106, 193, 177, 72, 142, 188, 253,
+       171, 100, 239, 106, 2, 123, 249, 231, 81, 2, 99, 202, 93, 92, 3,
+       111, 189, 85, 42, 7, 195, 16, 100, 23, 205, 15, 71, 165, 72, 238,
+       226, 195, 2, 212, 151, 33, 225, 96, 29, 123, 235, 65, 213, 155,
+       80, 145, 160, 139, 4, 0, 18, 37, 34, 72, 224, 151, 223, 25, 196,
+       33, 168, 254, 144, 203, 64, 252, 247, 104, 230, 113, 127, 104,
+       216, 67, 193, 171, 253, 137, 186, 79, 76, 2, 35, 37, 32, 98, 99,
+       106, 204, 126, 195, 211, 76, 143, 164, 253, 171, 64, 205, 102, 64,
+       218, 189, 111, 99, 0, 99, 202, 218, 118, 36, 161, 191, 117, 27,
+       118, 195, 65, 121, 151, 204, 43, 238, 33, 8, 127, 161, 67, 64,
+       252, 247, 192, 252, 55, 125, 122, 74, 1, 209, 171, 221, 149, 58,
+       75, 6, 2, 19, 33, 37, 253, 245, 232, 230, 156, 95, 95, 152, 83,
+       240, 141, 10, 211, 125, 89, 51, 89, 220, 125, 251, 249, 102, 253,
+       34, 255, 201, 165, 125, 173, 251, 218, 50, 253, 245, 109, 227,
+       108, 79, 95, 184, 19, 242, 189, 137, 211, 93, 91, 51, 95, 212, 93,
+       254, 235, 70, 253, 30, 239, 207, 229, 188, 45, 187, 82, 242, 61,
+       87, 109, 109, 62, 27, 198, 248, 85, 232, 251, 238, 83, 96, 153,
+       176, 126, 236, 78, 106, 233, 178, 109, 30, 180, 207, 165, 180,
+       125, 187, 80, 37, 61, 71, 110, 237, 92, 11, 199, 120, 84, 232,
+       255, 110, 115, 105, 185, 97, 122, 236, 62, 239, 237, 179, 77, 158,
+       242, 239, 165, 148, 127, 187, 120, 129, 236, 112, 152, 182, 105,
+       12, 84, 216, 179, 190, 37, 25, 31, 211, 75, 155, 133, 221, 229, 3,
+       70, 86, 218, 0, 215, 225, 117, 45, 32, 49, 14, 131, 184, 212, 84,
+       251, 157, 223, 208, 255, 199, 53, 181, 19, 79, 89, 40, 131, 201,
+       16, 135, 48, 122, 237, 91, 157, 107, 219, 69, 119, 115, 140, 220,
+       130, 50, 204, 20, 190, 9, 78, 84, 238, 141, 6, 168, 1, 102, 50,
+       44, 221, 201, 225, 236, 2, 76, 175, 83, 237, 145, 246, 82, 19, 80,
+       88, 108, 14, 50, 228, 210, 245, 5, 86, 84, 127, 17, 166, 246, 3,
+       106, 57, 37, 133, 249, 190, 133, 160, 108, 250, 1, 204, 179, 222,
+       213, 3, 227, 252, 126, 142, 82, 93, 95, 188, 59, 224, 19, 66, 132,
+       192, 216, 163, 44, 183, 161, 64, 230, 115, 191, 192, 1, 137, 2,
+       253, 240, 228, 170, 155, 188, 117, 37, 59, 83, 18, 204, 173, 42,
+       34, 10, 90, 0, 202, 210, 231, 29, 46, 147, 203, 126, 197, 189,
+       231, 173, 151, 133, 200, 208, 99, 250, 132, 173, 245, 57, 89, 118,
+       12, 150, 158, 77, 108, 6, 66, 169, 134, 170, 9, 230, 226, 37, 90,
+       200, 227, 106, 3, 12, 35, 210, 232, 145, 182, 66, 27, 192, 123,
+       109, 14, 118, 9, 150, 228, 13, 100, 218, 3, 137, 137, 187, 2, 108,
+       251, 53, 206, 232, 247, 125, 129, 8, 163, 147, 200, 147, 188, 202,
+       27, 129, 115, 104, 6, 11, 129, 230, 197, 77, 86, 233, 125, 199,
+       237, 31, 2, 105, 185, 242, 166, 104, 52, 250, 137, 193, 57, 183,
+       217, 7, 93, 199, 133, 103, 166, 124, 236, 95, 169, 138, 166, 188,
+       212, 207, 161, 10, 196, 150, 143, 189, 230, 242, 192, 248, 239,
+       189, 199, 221, 11, 188, 227, 184, 101, 175, 232, 12, 38, 185, 92,
+       86, 33, 246, 228, 159, 6, 90, 5, 169, 161, 154, 11, 76, 187, 125,
+       82, 166, 245, 125, 241, 24, 139, 144, 204, 187, 248, 143, 219,
+       133, 3, 169, 6, 186, 22, 41, 172, 5, 119, 93, 119, 17, 111, 212,
+       255, 30, 61, 58, 137, 252, 149, 149, 165, 184, 151, 112, 142, 243,
+       99, 248, 183, 183, 124, 150, 243, 68, 225, 146, 128, 205, 8, 164,
+       109, 170, 176, 161, 2, 142, 130, 104, 74, 168, 77, 106, 209, 82,
+       105, 146, 192, 189, 16, 79, 109, 128, 34, 171, 2, 140, 18, 247,
+       229, 230, 118, 252, 87, 61, 235, 118, 247, 29, 63, 160, 203, 102,
+       213, 151, 184, 177, 252, 17, 192, 94, 235, 246, 196, 175, 240,
+       225, 155, 255, 54, 123, 76, 126, 180, 146, 90, 217, 204, 244, 173,
+       58, 220, 183, 49, 222, 49, 213, 39, 165, 39, 180, 143, 82, 125,
+       33, 155, 79, 172, 118, 87, 157, 22, 115, 104, 99, 248, 127, 88,
+       249, 70, 117, 4, 111, 219, 187, 253, 54, 153, 23, 174, 167, 52,
+       60, 223, 82, 217, 2, 12, 126, 246, 103, 241, 185, 22, 101, 237,
+       70, 119, 220, 83, 21, 74, 241, 119, 91, 61, 147, 201, 126, 181,
+       151, 165, 189, 182, 117, 158, 215, 235, 234, 128, 63, 252, 240,
+       211, 203, 52, 90, 232, 60, 161, 25, 89, 143, 166, 149, 162, 156,
+       223, 227, 197, 214, 25, 157, 163, 235, 7, 10, 223, 178, 217, 139,
+       191, 22, 174, 41, 17, 162, 60, 107, 103, 117, 249, 107, 16, 121,
+       70, 119, 141, 47, 77, 31, 61, 178, 168, 7, 10, 167, 180, 52, 207,
+       135, 217, 0, 3, 79, 143, 70, 245, 155, 22, 91, 161, 226, 102, 109,
+       87, 61, 206, 118, 119, 29, 54, 167, 249, 246, 141, 150, 164, 185,
+       156, 49, 202, 151, 251, 178, 134, 168, 240, 228, 245, 223, 200,
+       88, 251, 63, 208, 91, 128, 143, 84, 141, 130, 141, 207, 115, 192,
+       99, 161, 159, 218, 78, 4, 126, 243, 239, 217, 143, 121, 54, 147,
+       45, 96, 226, 120, 107, 67, 85, 221, 115, 16, 57, 228, 183, 143,
+       186, 157, 86, 52, 62, 188, 215, 67, 139, 190, 180, 239, 215, 29,
+       128, 51, 101, 143, 86, 255, 155, 20, 59, 140, 38, 118, 89, 89, 44,
+       78, 214, 102, 158, 214, 179, 241, 252, 185, 159, 173, 169, 135,
+       115, 222, 211, 169, 170, 136, 27, 140, 37, 113, 156, 190, 248,
+       146, 151, 126, 223, 215, 27, 239, 188, 63, 77, 46, 219, 164, 59,
+       199, 134, 147, 245, 255, 61, 234, 251, 199, 191, 245, 175, 92,
+       237, 127, 238, 158, 124, 158, 237, 116, 223, 191, 91, 95, 180, 54,
+       109, 110, 31, 151, 79, 195, 183, 171, 241, 111, 123, 255, 251,
+       255, 255, 213, 159, 116, 207, 115, 154, 105, 216, 179, 15, 217,
+       255, 196, 143, 148, 28, 2, 173, 203, 83, 134, 42, 235, 155, 219,
+       66, 40, 126, 243, 175, 205, 142, 57, 183, 31, 29, 232, 207, 190,
+       243, 150, 239, 116, 255, 247, 155, 207, 188, 30, 253, 238, 123,
+       166, 59, 227, 246, 139, 245, 103, 190, 226, 127, 87, 127, 185,
+       143, 124, 207, 255, 47, 190, 248, 146, 181, 247, 223, 187, 27,
+       239, 60, 158, 252, 110, 255, 133, 159, 235, 149, 159, 243, 122,
+       56, 254, 233, 223, 191, 245, 158, 124, 141, 113, 44, 225, 18, 168,
+       221, 157, 146, 77, 135, 13, 249, 9, 14, 217, 104, 144, 216, 185,
+       130, 112, 30, 35, 218, 146, 59, 213, 1, 127, 211, 14, 238, 130,
+       226, 189, 53, 244, 237, 197, 148, 230, 139, 250, 152, 107, 52,
+       189, 101, 3, 201, 119, 123, 17, 113, 107, 146, 252, 61, 16, 207,
+       250, 24, 40, 87, 187, 14, 161, 146, 187, 101, 153, 188, 200, 139,
+       152, 53, 2, 173, 203, 251, 143, 187, 107, 147, 203, 70, 64, 138,
+       241, 6, 89, 223, 171, 151, 215, 75, 140, 92, 73, 248, 171, 143,
+       213, 115, 196, 103, 85, 230, 3, 59, 22, 99, 96, 104, 130, 170,
+       208, 30, 9, 113, 241, 247, 225, 130, 83, 179, 31, 252, 126, 122,
+       113, 170, 68, 83, 223, 251, 116, 161, 237, 191, 11, 58, 157, 86,
+       50, 44, 252, 223, 89, 201, 191, 240, 202, 223, 77, 180, 177, 67,
+       10, 86, 251, 148, 251, 191, 180, 238, 193, 181, 227, 154, 182, 80,
+       187, 148, 191, 97, 11, 175, 121, 131, 65, 112, 126, 162, 96, 221,
+       2, 127, 171, 52, 56, 133, 251, 110, 175, 214, 208, 237, 16, 238,
+       230, 233, 19, 188, 10, 40, 234, 92, 147, 235, 195, 151, 219, 82,
+       107, 130, 229, 124, 27, 222, 237, 135, 213, 250, 128, 159, 191,
+       201, 179, 149, 246, 239, 182, 123, 255, 190, 118, 219, 126, 223,
+       201, 63, 239, 180, 211, 255, 248, 185, 226, 232, 159, 191, 228,
+       175, 117, 221, 121, 137, 223, 175, 151, 229, 126, 119, 183, 185,
+       78, 252, 183, 253, 119, 163, 111, 111, 242, 150, 206, 245, 252,
+       62, 239, 103, 115, 246, 129, 43, 255, 237, 251, 236, 222, 92, 158,
+       253, 125, 95, 188, 187, 94, 189, 124, 239, 102, 139, 245, 55, 195,
+       228, 170, 245, 102, 62, 255, 227, 247, 239, 185, 158, 119, 143,
+       117, 236, 254, 232, 146, 221, 115, 223, 254, 91, 238, 188, 30,
+       205, 238, 123, 132, 91, 199, 143, 179, 255, 103, 248, 250, 123,
+       87, 175, 253, 151, 126, 221, 115, 167, 137, 39, 218, 213, 199,
+       239, 97, 213, 64, 209, 18, 80, 220, 60, 37, 216, 42, 19, 239, 251,
+       183, 60, 223, 49, 24, 142, 200, 85, 14, 244, 228, 60, 177, 254,
+       237, 253, 95, 127, 188, 127, 93, 119, 37, 255, 255, 42, 112, 187,
+       215, 245, 120, 250, 225, 59, 253, 235, 255, 165, 205, 243, 142,
+       220, 211, 173, 127, 168, 146, 237, 253, 183, 215, 155, 206, 189,
+       63, 238, 253, 235, 174, 125, 242, 207, 214, 244, 103, 106, 234,
+       255, 87, 231, 187, 130, 127, 223, 247, 40, 189, 24, 123, 89, 217,
+       82, 255, 6, 37, 44, 9, 175, 147, 34, 16, 0, 58, 131, 80, 26, 40,
+       90, 63, 111, 197, 32, 121, 114, 138, 140, 138, 36, 221, 246, 247,
+       229, 14, 94, 188, 251, 186, 250, 107, 235, 255, 53, 54, 217, 246,
+       55, 194, 204, 250, 90, 233, 239, 254, 199, 146, 71, 255, 84, 15,
+       221, 221, 46, 146, 215, 244, 191, 254, 184, 94, 188, 55, 125, 255,
+       235, 227, 125, 210, 159, 226, 247, 103, 58, 255, 251, 67, 230,
+       239, 171, 87, 239, 255, 197, 222, 250, 182, 236, 109, 239, 191,
+       218, 206, 60, 158, 245, 231, 123, 42, 31, 227, 55, 139, 241, 71,
+       62, 226, 125, 151, 111, 185, 156, 123, 197, 115, 199, 157, 85,
+       158, 252, 227, 239, 187, 26, 90, 120, 94, 244, 98, 185, 33, 147,
+       195, 22, 175, 241, 86, 26, 127, 124, 30, 239, 132, 156, 250, 193,
+       177, 56, 151, 105, 197, 118, 99, 95, 127, 17, 238, 92, 174, 115,
+       55, 130, 21, 93, 254, 151, 168, 57, 154, 240, 142, 255, 133, 165,
+       168, 39, 234, 150, 241, 35, 20, 221, 92, 120, 118, 171, 123, 24,
+       235, 116, 126, 80, 55, 164, 36, 221, 118, 22, 168, 161, 223, 120,
+       207, 63, 62, 181, 226, 205, 168, 98, 181, 160, 189, 57, 217, 92,
+       205, 131, 111, 95, 5, 124, 0, 178, 213, 164, 36, 72, 58, 2, 88,
+       51, 42, 114, 63, 45, 156, 0, 122, 80, 8, 84, 236, 109, 120, 188,
+       240, 237, 188, 124, 158, 187, 222, 60, 1, 255, 255, 99, 251, 223,
+       251, 255, 22, 142, 96, 250, 176, 207, 223, 119, 45, 210, 245, 78,
+       251, 6, 192, 244, 222, 119, 174, 250, 200, 91, 153, 177, 227, 236,
+       251, 125, 140, 255, 243, 63, 215, 134, 98, 74, 253, 159, 90, 223,
+       162, 159, 175, 97, 143, 133, 93, 151, 191, 236, 34, 175, 255, 152,
+       218, 88, 68, 245, 99, 185, 43, 215, 111, 50, 239, 97, 194, 26,
+       104, 36, 162, 239, 132, 12, 243, 163, 177, 55, 61, 224, 229, 205,
+       21, 244, 239, 75, 250, 152, 67, 12, 188, 117, 166, 233, 219, 183,
+       199, 205, 115, 154, 192, 187, 216, 207, 174, 15, 126, 240, 191,
+       151, 121, 229, 177, 175, 83, 156, 205, 143, 240, 144, 131, 172,
+       30, 87, 174, 206, 115, 221, 215, 207, 193, 127, 240, 139, 88, 223,
+       183, 29, 124, 149, 94, 30, 121, 165, 161, 171, 87, 158, 205, 143,
+       228, 146, 175, 207, 28, 87, 138, 206, 241, 253, 215, 207, 5, 123,
+       208, 155, 215, 159, 183, 31, 62, 148, 95, 72, 184, 236, 243, 138,
+       192, 49, 134, 162, 61, 150, 163, 185, 159, 66, 66, 109, 215, 253,
+       209, 10, 73, 203, 161, 94, 129, 190, 225, 165, 1, 52, 123, 32,
+       157, 57, 73, 92, 205, 131, 191, 94, 61, 108, 8, 178, 21, 172, 52,
+       24, 26, 2, 88, 18, 56, 121, 63, 109, 140, 52, 126, 82, 136, 196,
+       235, 218, 211, 102, 159, 130, 22, 188, 125, 141, 82, 211, 247,
+       109, 78, 62, 199, 102, 151, 191, 231, 229, 213, 31, 205, 176, 98,
+       222, 134, 45, 148, 189, 93, 141, 253, 57, 235, 164, 201, 111, 252,
+       94, 68, 80, 68, 245, 199, 233, 97, 51, 75, 22, 110, 227, 20, 58,
+       51, 237, 141, 39, 108, 20, 251, 165, 241, 197, 83, 149, 213, 170,
+       4, 44, 157, 158, 184, 18, 70, 212, 211, 201, 239, 55, 93, 62, 90,
+       195, 80, 203, 80, 141, 170, 127, 230, 136, 185, 129, 33, 1, 148,
+       153, 231, 124, 15, 175, 123, 92, 235, 113, 116, 244, 55, 144, 98,
+       23, 95, 22, 173, 241, 248, 185, 79, 44, 190, 59, 164, 12, 168,
+       161, 177, 54, 107, 146, 216, 172, 53, 156, 205, 223, 26, 208, 106,
+       142, 216, 253, 141, 223, 11, 7, 87, 66, 99, 10, 208, 144, 216, 79,
+       62, 212, 123, 249, 133, 112, 132, 177, 236, 93, 39, 199, 107, 81,
+       162, 128, 26, 86, 121, 48, 34, 217, 230, 89, 41, 56, 111, 216,
+       142, 249, 222, 69, 60, 210, 104, 118, 42, 32, 157, 121, 75, 252,
+       205, 135, 191, 94, 45, 108, 8, 178, 52, 140, 32, 24, 26, 2, 88,
+       242, 56, 113, 63, 111, 173, 52, 120, 81, 136, 198, 233, 90, 114,
+       222, 182, 42, 64, 60, 20, 168, 158, 146, 225, 237, 255, 195, 219,
+       166, 117, 253, 131, 68, 69, 130, 232, 210, 243, 126, 155, 4, 116,
+       15, 91, 1, 126, 21, 165, 124, 7, 174, 126, 12, 170, 90, 228, 213,
+       35, 192, 194, 23, 117, 62, 44, 161, 216, 145, 110, 172, 142, 111,
+       160, 12, 234, 33, 185, 131, 73, 6, 158, 21, 134, 174, 113, 180,
+       64, 195, 87, 233, 202, 54, 197, 108, 33, 58, 207, 237, 143, 22,
+       253, 32, 122, 202, 0, 27, 4, 121, 156, 226, 1, 116, 220, 101, 58,
+       232, 41, 91, 180, 181, 138, 233, 233, 180, 141, 122, 228, 35, 170,
+       0, 98, 14, 221, 30, 90, 195, 55, 23, 173, 65, 164, 141, 89, 63,
+       91, 244, 223, 231, 221, 116, 72, 116, 36, 219, 93, 187, 173, 62,
+       8, 22, 127, 231, 176, 60, 188, 102, 203, 36, 132, 95, 255, 249,
+       245, 44, 129, 189, 115, 133, 75, 196, 166, 211, 59, 112, 24, 211,
+       57, 72, 59, 137, 214, 100, 24, 56, 248, 73, 32, 205, 211, 116, 85,
+       224, 88, 214, 170, 102, 42, 172, 209, 172, 44, 253, 151, 158, 191,
+       6, 31, 192, 44, 87, 74, 129, 70, 105, 29, 176, 77, 251, 162, 77,
+       31, 221, 117, 132, 121, 221, 66, 60, 0, 237, 229, 132, 110, 77,
+       27, 117, 255, 247, 25, 83, 63, 27, 58, 89, 196, 125, 60, 24, 242,
+       225, 0, 207, 239, 241, 21, 225, 233, 86, 226, 183, 161, 228, 183,
+       79, 208, 252, 73, 203, 148, 163, 3, 107, 248, 95, 62, 249, 233,
+       179, 133, 78, 118, 238, 193, 155, 90, 207, 7, 103, 126, 116, 198,
+       178, 104, 0, 155, 15, 249, 128, 204, 223, 53, 161, 187, 166, 200,
+       111, 13, 104, 171, 234, 83, 14, 100, 78, 177, 132, 208, 154, 123,
+       81, 31, 221, 142, 118, 247, 114, 106, 51, 172, 90, 216, 171, 13,
+       185, 109, 46, 223, 108, 16, 182, 217, 213, 112, 146, 35, 138, 227,
+       251, 252, 0, 255, 202, 131, 39, 147, 7, 91, 15, 155, 228, 30, 237,
+       157, 148, 94, 86, 230, 209, 68, 187, 111, 86, 70, 55, 127, 197,
+       208, 127, 164, 102, 123, 238, 196, 190, 255, 216, 245, 92, 73,
+       144, 232, 220, 7, 71, 204, 22, 137, 128, 2, 87, 147, 113, 64, 121,
+       204, 43, 90, 11, 35, 217, 18, 253, 132, 39, 60, 184, 59, 112, 2,
+       164, 92, 45, 185, 232, 99, 157, 154, 22, 126, 148, 181, 213, 55,
+       33, 25, 77, 21, 55, 174, 40, 86, 121, 30, 69, 130, 251, 244, 145,
+       241, 4, 243, 168, 205, 113, 127, 252, 205, 199, 191, 86, 0, 116,
+       10, 179, 61, 144, 37, 72, 122, 18, 75, 251, 40, 119, 63, 101, 168,
+       36, 56, 119, 152, 212, 232, 50, 128, 252, 245, 31, 200, 184, 234,
+       187, 145, 162, 147, 110, 255, 76, 82, 255, 255, 179, 145, 26, 126,
+       219, 245, 219, 210, 95, 71, 229, 40, 37, 18, 230, 174, 172, 209,
+       156, 36, 217, 159, 138, 191, 140, 21, 208, 238, 94, 66, 197, 71,
+       121, 157, 178, 77, 251, 51, 109, 15, 255, 253, 148, 96, 222, 66,
+       125, 68, 237, 229, 44, 110, 117, 88, 196, 226, 255, 2, 83, 117,
+       19, 123, 104, 196, 127, 170, 72, 247, 97, 8, 215, 235, 225, 21,
+       97, 251, 116, 226, 213, 209, 29, 228, 136, 78, 71, 184, 168, 184,
+       163, 72, 214, 115, 8, 115, 176, 212, 108, 106, 105, 97, 217, 12,
+       177, 168, 101, 28, 8, 179, 131, 49, 88, 61, 29, 231, 56, 103, 95,
+       59, 5, 234, 159, 8, 255, 55, 0, 99, 212, 247, 125, 170, 57, 203,
+       217, 14, 251, 197, 107, 48, 40, 226, 5, 59, 67, 163, 147, 182,
+       122, 140, 186, 65, 170, 25, 91, 65, 188, 242, 72, 82, 166, 111,
+       122, 133, 18, 73, 130, 97, 213, 52, 62, 168, 128, 66, 131, 137,
+       98, 163, 83, 66, 120, 140, 122, 64, 171, 141, 185, 105, 174, 219,
+       76, 18, 174, 123, 79, 80, 18, 43, 130, 225, 30, 156, 34, 250, 64,
+       131, 67, 131, 69, 91, 223, 135, 170, 34, 191, 148, 40, 93, 219,
+       247, 213, 6, 139, 107, 102, 71, 44, 198, 213, 212, 167, 96, 196,
+       34, 254, 128, 140, 243, 165, 85, 86, 248, 165, 52, 168, 140, 80,
+       172, 171, 187, 130, 105, 214, 247, 69, 91, 133, 117, 125, 244,
+       152, 73, 203, 100, 185, 22, 205, 254, 136, 51, 16, 51, 12, 131,
+       172, 187, 136, 102, 93, 159, 18, 87, 77, 149, 209, 111, 90, 75,
+       221, 87, 33, 148, 158, 88, 219, 33, 239, 227, 254, 69, 176, 208,
+       164, 210, 222, 90, 119, 165, 34, 2, 109, 56, 37, 222, 83, 231,
+       221, 7, 145, 79, 54, 213, 61, 238, 233, 212, 37, 200, 196, 226,
+       235, 132, 46, 179, 37, 113, 204, 171, 172, 251, 136, 4, 221, 191,
+       162, 149, 140, 149, 241, 239, 90, 2, 77, 83, 233, 217, 222, 74,
+       219, 113, 239, 131, 255, 109, 128, 226, 175, 202, 157, 92, 111,
+       229, 36, 22, 235, 56, 100, 202, 211, 70, 211, 28, 177, 227, 126,
+       196, 29, 239, 233, 181, 53, 142, 209, 235, 234, 132, 45, 171, 113,
+       113, 177, 65, 127, 109, 44, 79, 71, 120, 212, 234, 247, 10, 115,
+       81, 187, 115, 88, 228, 94, 106, 105, 231, 105, 28, 243, 171, 225,
+       20, 115, 187, 116, 169, 235, 4, 105, 238, 100, 87, 222, 48, 85,
+       106, 183, 155, 123, 29, 182, 241, 222, 161, 23, 239, 236, 54, 125,
+       191, 119, 255, 168, 144, 55, 239, 80, 123, 111, 23, 235, 102, 245,
+       54, 223, 48, 1, 206, 255, 149, 121, 126, 190, 114, 220, 231, 149,
+       167, 237, 146, 116, 174, 119, 127, 174, 144, 143, 247, 244, 87,
+       104, 191, 60, 122, 175, 189, 16, 166, 203, 63, 44, 57, 174, 45,
+       70, 155, 135, 123, 205, 17, 38, 106, 202, 183, 207, 215, 80, 123,
+       210, 77, 15, 11, 34, 191, 24, 216, 221, 157, 84, 231, 95, 9, 184,
+       13, 162, 137, 36, 148, 200, 186, 130, 17, 26, 43, 80, 253, 63, 20,
+       20, 123, 218, 8, 206, 158, 0, 128, 131, 137, 93, 200, 160, 64, 38,
+       17, 224, 2, 132, 130, 96, 192, 104, 136, 74, 144, 19, 42, 215, 64,
+       12, 164, 154, 72, 152, 0, 35, 128, 165, 76, 103, 222, 84, 198, 67,
+       248, 209, 198, 245, 18, 82, 209, 181, 125, 88, 236, 18, 234, 233,
+       231, 124, 174, 49, 58, 197, 12, 55, 187, 116, 228, 177, 89, 127,
+       237, 52, 198, 235, 240, 84, 104, 246, 2, 83, 93, 181, 101, 120,
+       228, 31, 234, 233, 181, 49, 156, 115, 233, 163, 16, 127, 187, 112,
+       161, 104, 188, 20, 186, 173, 225, 20, 166, 155, 27, 160, 57, 174,
+       219, 64, 219, 193, 59, 205, 2, 46, 110, 202, 181, 139, 211, 86,
+       59, 154, 72, 143, 27, 104, 201, 84, 227, 125, 137, 224, 229, 207,
+       48, 184, 10, 143, 25, 80, 132, 202, 184, 66, 113, 73, 46, 90, 221,
+       188, 208, 143, 127, 94, 10, 91, 136, 212, 158, 218, 190, 218, 6,
+       95, 248, 155, 166, 173, 143, 111, 235, 43, 80, 183, 215, 173, 227,
+       124, 71, 26, 126, 249, 231, 77, 61, 177, 243, 47, 66, 130, 168,
+       19, 185, 114, 136, 168, 102, 188, 1, 66, 211, 172, 154, 48, 192,
+       230, 59, 19, 149, 99, 156, 18, 239, 12, 54, 26, 66, 4, 0, 33, 136,
+       188, 109, 127, 236, 86, 207, 87, 112, 244, 172, 252, 8, 119, 221,
+       32, 49, 252, 252, 70, 106, 104, 179, 120, 61, 243, 233, 33, 17,
+       113, 187, 70, 163, 160, 196, 60, 93, 141, 221, 213, 175, 222, 51,
+       164, 24, 178, 57, 60, 33, 201, 18, 106, 8, 122, 108, 115, 183,
+       107, 219, 84, 89, 89, 24, 216, 42, 164, 176, 189, 121, 248, 239,
+       81, 218, 123, 121, 181, 56, 158, 61, 76, 57, 219, 155, 198, 16,
+       59, 110, 120, 87, 207, 156, 17, 119, 208, 65, 198, 163, 42, 164,
+       41, 105, 157, 255, 217, 91, 95, 63, 189, 16, 138, 29, 124, 44,
+       221, 19, 147, 17, 154, 44, 123, 215, 79, 95, 145, 119, 211, 12,
+       212, 230, 43, 129, 232, 75, 189, 245, 211, 79, 223, 69, 125, 19,
+       42, 253, 62, 36, 216, 10, 147, 16, 30, 40, 122, 151, 79, 93, 144,
+       91, 215, 78, 220, 206, 2, 105, 22, 169, 87, 141, 184, 103, 172, 5,
+       194, 3, 172, 154, 52, 192, 234, 57, 219, 145, 80, 153, 16, 205,
+       29, 48, 154, 3, 5, 0, 173, 138, 184, 76, 22, 254, 93, 199, 86,
+       238, 213, 6, 224, 11, 34, 217, 37, 17, 216, 234, 130, 66, 110,
+       175, 2, 191, 243, 255, 128, 43, 115, 29, 124, 138, 70, 9, 134,
+       149, 137, 40, 32, 134, 174, 179, 138, 1, 196, 162, 65, 74, 225,
+       103, 106, 145, 16, 201, 195, 96, 141, 54, 223, 3, 128, 113, 33, 2,
+       212, 122, 251, 102, 98, 104, 51, 152, 233, 202, 183, 104, 127,
+       245, 201, 58, 54, 244, 124, 106, 160, 103, 171, 104, 209, 171, 97,
+       138, 102, 243, 39, 97, 25, 98, 82, 227, 118, 131, 168, 81, 4, 161,
+       75, 194, 181, 3, 32, 0, 126, 28, 2, 153, 2, 178, 69, 156, 196,
+       197, 154, 0, 175, 138, 57, 136, 78, 58, 177, 184, 239, 249, 149,
+       138, 143, 247, 152, 191, 140, 236, 111, 14, 135, 83, 251, 19, 134,
+       99, 250, 240, 155, 86, 93, 191, 214, 125, 21, 87, 147, 89, 99,
+       198, 118, 210, 235, 112, 220, 192, 87, 226, 121, 220, 183, 229,
+       126, 249, 23, 239, 225, 181, 52, 236, 50, 104, 170, 128, 47, 191,
+       113, 253, 70, 169, 146, 128, 153, 168, 42, 131, 170, 177, 138, 9,
+       132, 162, 64, 82, 161, 247, 106, 208, 18, 73, 211, 98, 189, 180,
+       15, 127, 128, 65, 131, 2, 1, 163, 88, 235, 182, 138, 98, 53, 54,
+       1, 79, 226, 181, 131, 128, 100, 114, 42, 6, 24, 83, 152, 77, 23,
+       236, 197, 182, 192, 188, 130, 153, 168, 165, 181, 29, 90, 220,
+       237, 240, 127, 126, 81, 109, 24, 246, 121, 12, 49, 185, 18, 66,
+       56, 51, 122, 91, 31, 127, 143, 53, 108, 216, 72, 203, 178, 245,
+       89, 93, 101, 160, 14, 70, 53, 96, 168, 162, 108, 215, 51, 129,
+       243, 2, 228, 108, 106, 109, 220, 209, 46, 170, 235, 101, 16, 40,
+       176, 202, 9, 78, 114, 53, 240, 203, 237, 184, 214, 143, 123, 19,
+       255, 140, 159, 77, 143, 167, 145, 255, 147, 131, 69, 27, 208, 157,
+       82, 91, 198, 159, 93, 165, 119, 110, 57, 233, 208, 237, 113, 85,
+       218, 139, 253, 148, 171, 46, 253, 199, 30, 139, 218, 245, 81, 14,
+       67, 234, 160, 91, 85, 5, 191, 150, 253, 94, 119, 244, 255, 26,
+       226, 184, 73, 87, 216, 170, 132, 172, 41, 86, 199, 235, 18, 146,
+       80, 205, 122, 66, 67, 10, 98, 251, 145, 37, 61, 64, 251, 231, 99,
+       252, 82, 254, 124, 122, 67, 19, 248, 22, 174, 103, 59, 83, 119,
+       170, 120, 87, 124, 181, 98, 40, 215, 107, 31, 91, 239, 97, 197,
+       54, 161, 100, 99, 124, 12, 234, 214, 149, 118, 206, 66, 208, 130,
+       207, 2, 115, 249, 53, 99, 88, 236, 185, 251, 40, 231, 188, 170,
+       251, 239, 199, 25, 239, 123, 120, 34, 48, 229, 80, 234, 93, 137,
+       70, 236, 95, 33, 232, 9, 34, 89, 44, 20, 216, 138, 6, 98, 106, 58,
+       72, 191, 179, 220, 20, 127, 113, 26, 218, 138, 80, 229, 16, 160,
+       155, 137, 86, 239, 59, 49, 168, 24, 142, 210, 72, 144, 179, 155,
+       76, 112, 90, 43, 216, 119, 185, 212, 7, 127, 112, 0, 131, 2, 81,
+       221, 31, 175, 178, 134, 23, 182, 228, 192, 234, 100, 254, 51, 160,
+       197, 102, 119, 28, 108, 113, 137, 49, 125, 232, 169, 38, 82, 56,
+       146, 161, 57, 220, 218, 127, 126, 42, 66, 31, 180, 245, 90, 246,
+       224, 127, 87, 161, 115, 102, 245, 124, 226, 233, 69, 47, 109, 241,
+       170, 103, 128, 38, 179, 165, 97, 33, 149, 57, 202, 196, 205, 244,
+       239, 76, 65, 125, 8, 118, 125, 44, 112, 249, 26, 50, 8, 83, 58,
+       122, 23, 127, 143, 54, 72, 81, 10, 233, 170, 131, 133, 43, 154,
+       213, 244, 249, 87, 87, 69, 205, 23, 168, 204, 62, 228, 220, 171,
+       155, 149, 182, 170, 118, 255, 47, 125, 154, 75, 151, 204, 188,
+       124, 164, 226, 57, 106, 120, 201, 99, 216, 230, 13, 125, 56, 18,
+       215, 232, 16, 216, 24, 70, 90, 2, 39, 170, 51, 87, 157, 32, 109,
+       80, 147, 70, 227, 124, 164, 243, 126, 48, 66, 83, 120, 114, 174,
+       117, 56, 91, 255, 136, 49, 83, 124, 37, 42, 40, 246, 233, 30, 123,
+       239, 101, 172, 226, 227, 102, 99, 149, 242, 159, 243, 40, 39, 25,
+       248, 158, 187, 147, 116, 212, 23, 72, 107, 133, 85, 125, 18, 177,
+       197, 185, 36, 201, 139, 123, 246, 8, 1, 161, 35, 222, 42, 222,
+       162, 34, 44, 122, 0, 188, 142, 191, 181, 255, 227, 67, 26, 183,
+       229, 253, 150, 44, 197, 139, 98, 218, 199, 107, 129, 172, 231, 43,
+       83, 38, 2, 99, 193, 102, 0, 235, 96, 73, 0, 249, 227, 81, 188,
+       188, 33, 254, 157, 19, 227, 152, 179, 4, 192, 20, 56, 202, 206,
+       101, 139, 118, 228, 133, 191, 141, 95, 220, 247, 231, 190, 214,
+       255, 108, 84, 224, 224, 223, 215, 17, 110, 160, 94, 243, 120, 239,
+       63, 108, 30, 117, 108, 209, 243, 196, 253, 74, 123, 19, 190, 59,
+       148, 58, 96, 175, 132, 202, 197, 236, 206, 32, 192, 246, 123, 235,
+       197, 86, 139, 146, 253, 187, 117, 138, 139, 20, 38, 45, 158, 130,
+       140, 118, 219, 78, 165, 184, 98, 221, 19, 81, 210, 172, 58, 52,
+       79, 239, 51, 19, 3, 176, 252, 14, 245, 13, 26, 218, 66, 21, 73,
+       129, 134, 57, 253, 21, 101, 61, 223, 86, 166, 198, 224, 174, 8,
+       255, 52, 0, 240, 128, 118, 204, 98, 109, 161, 121, 63, 163, 253,
+       5, 49, 82, 122, 218, 42, 172, 25, 88, 122, 93, 221, 82, 121, 151,
+       12, 117, 8, 35, 209, 35, 16, 88, 184, 134, 88, 122, 42, 82, 63,
+       107, 221, 0, 91, 115, 139, 78, 130, 163, 16, 97, 136, 119, 144,
+       248, 83, 9, 65, 89, 247, 140, 30, 182, 164, 206, 137, 151, 149,
+       151, 158, 116, 194, 22, 92, 154, 202, 31, 132, 123, 221, 41, 77,
+       100, 127, 125, 149, 255, 254, 85, 2, 124, 2, 123, 121, 61, 229,
+       88, 234, 23, 106, 238, 186, 119, 191, 103, 255, 192, 9, 119, 252,
+       112, 174, 2, 145, 183, 159, 236, 164, 188, 71, 142, 27, 91, 115,
+       236, 254, 44, 106, 231, 51, 59, 133, 146, 201, 154, 225, 13, 54,
+       222, 130, 156, 66, 177, 191, 223, 108, 134, 183, 38, 114, 120,
+       132, 168, 202, 210, 227, 239, 74, 147, 219, 226, 229, 253, 247,
+       44, 197, 135, 232, 210, 227, 250, 129, 166, 247, 59, 79, 60, 165,
+       117, 100, 245, 111, 79, 251, 65, 170, 56, 10, 91, 125, 177, 182,
+       185, 214, 21, 106, 121, 179, 41, 158, 59, 223, 101, 52, 99, 250,
+       212, 225, 184, 36, 181, 103, 85, 127, 71, 123, 80, 234, 255, 82,
+       123, 125, 144, 160, 61, 222, 85, 42, 185, 250, 57, 14, 127, 239,
+       37, 4, 227, 234, 118, 233, 62, 223, 106, 211, 183, 119, 183, 244,
+       213, 206, 29, 183, 121, 125, 175, 231, 95, 114, 151, 98, 237, 32,
+       124, 175, 107, 207, 229, 175, 191, 255, 252, 255, 31, 105, 227,
+       164, 194, 54, 111, 208, 169, 224, 203, 199, 93, 230, 115, 248, 54,
+       237, 123, 255, 149, 209, 188, 232, 156, 111, 143, 196, 173, 247,
+       43, 212, 87, 105, 227, 165, 134, 118, 47, 224, 37, 192, 78, 134,
+       93, 166, 243, 110, 118, 237, 59, 255, 205, 211, 189, 232, 153, 44,
+       207, 132, 173, 247, 33, 116, 56, 221, 112, 237, 125, 223, 86, 255,
+       87, 2, 124, 42, 59, 61, 36, 48, 222, 155, 151, 96, 234, 58, 114,
+       191, 103, 223, 0, 55, 119, 220, 198, 171, 109, 237, 164, 170, 253,
+       29, 86, 175, 195, 113, 140, 13, 202, 105, 90, 151, 137, 194, 125,
+       111, 255, 106, 223, 181, 255, 90, 69, 127, 250, 254, 218, 94, 188,
+       201, 106, 238, 85, 151, 79, 248, 65, 0, 252, 10, 123, 217, 48, 48,
+       120, 232, 22, 234, 200, 163, 28, 191, 243, 237, 164, 57, 119, 186,
+       126, 162, 35, 205, 99, 73, 84, 151, 171, 230, 94, 65, 124, 198,
+       48, 200, 180, 100, 120, 170, 18, 220, 195, 186, 52, 255, 44, 12,
+       134, 128, 93, 142, 112, 252, 2, 141, 134, 159, 157, 192, 175, 166,
+       190, 196, 78, 131, 236, 250, 55, 68, 224, 107, 59, 197, 18, 200,
+       11, 253, 44, 54, 142, 10, 28, 6, 49, 220, 87, 121, 231, 132, 194,
+       150, 175, 226, 173, 192, 94, 134, 93, 174, 183, 230, 102, 237, 55,
+       239, 209, 145, 180, 232, 184, 46, 207, 128, 173, 247, 177, 244,
+       18, 247, 235, 169, 182, 67, 187, 253, 30, 109, 89, 227, 85, 236,
+       184, 0, 127, 29, 151, 181, 147, 186, 45, 87, 172, 5, 175, 228,
+       181, 154, 183, 241, 223, 202, 15, 190, 46, 16, 62, 160, 220, 82,
+       211, 211, 253, 138, 178, 227, 230, 225, 191, 199, 229, 141, 15,
+       253, 178, 115, 234, 136, 52, 191, 185, 13, 121, 89, 96, 108, 61,
+       135, 79, 158, 69, 140, 254, 76, 235, 97, 145, 212, 88, 238, 46,
+       238, 137, 178, 117, 175, 178, 254, 132, 16, 122, 255, 112, 124, 3,
+       62, 103, 30, 114, 178, 184, 87, 189, 73, 114, 247, 172, 174, 180,
+       133, 38, 35, 215, 149, 167, 156, 36, 207, 6, 62, 58, 130, 199,
+       132, 39, 253, 2, 216, 185, 153, 226, 197, 185, 7, 142, 127, 88,
+       48, 156, 158, 102, 104, 199, 57, 51, 129, 82, 28, 242, 211, 69,
+       20, 58, 235, 148, 0, 133, 251, 192, 152, 59, 209, 226, 206, 185,
+       18, 62, 59, 82, 243, 149, 159, 224, 120, 231, 29, 55, 16, 144,
+       156, 17, 86, 77, 7, 122, 196, 20, 0, 37, 179, 212, 48, 185, 179,
+       168, 108, 17, 25, 58, 255, 131, 57, 214, 55, 73, 91, 129, 87, 109,
+       17, 10, 69, 251, 0, 209, 163, 125, 61, 128, 113, 135, 115, 35, 81,
+       47, 200, 92, 151, 170, 72, 206, 73, 216, 199, 224, 204, 61, 228,
+       220, 40, 179, 213, 135, 187, 54, 221, 23, 60, 138, 203, 29, 14,
+       57, 220, 37, 89, 249, 127, 186, 8, 31, 188, 30, 192, 124, 232,
+       247, 119, 137, 50, 22, 115, 53, 126, 195, 64, 239, 41, 111, 175,
+       101, 152, 244, 187, 5, 249, 66, 185, 34, 146, 219, 212, 186, 199,
+       171, 77, 152, 173, 172, 222, 110, 134, 166, 27, 251, 213, 150, 11,
+       186, 229, 57, 20, 142, 251, 132, 6, 175, 95, 66, 147, 167, 156,
+       219, 116, 184, 207, 171, 93, 154, 135, 236, 254, 126, 102, 231,
+       83, 251, 149, 150, 73, 191, 225, 31, 52, 158, 207, 132, 70, 181,
+       223, 131, 175, 199, 221, 118, 178, 168, 103, 61, 200, 90, 230, 41,
+       41, 148, 133, 126, 235, 23, 141, 163, 250, 7, 239, 52, 62, 174,
+       130, 47, 196, 58, 189, 18, 122, 118, 146, 39, 216, 120, 69, 173,
+       77, 215, 167, 46, 140, 183, 172, 166, 185, 255, 21, 199, 173, 38,
+       192, 146, 80, 16, 131, 14, 142, 61, 95, 57, 59, 106, 228, 37, 223,
+       89, 113, 129, 204, 87, 174, 171, 159, 178, 36, 76, 184, 151, 136,
+       204, 154, 36, 140, 211, 217, 160, 145, 38, 142, 94, 255, 175, 221,
+       224, 79, 205, 52, 206, 187, 207, 194, 156, 70, 232, 104, 191, 230,
+       89, 70, 187, 238, 229, 33, 95, 251, 46, 126, 207, 158, 95, 246,
+       248, 148, 2, 144, 179, 186, 219, 225, 177, 71, 139, 69, 88, 179,
+       44, 220, 110, 0, 239, 59, 147, 145, 22, 11, 34, 243, 93, 84, 26,
+       235, 149, 14, 167, 255, 41, 0, 227, 205, 87, 199, 161, 74, 70, 77,
+       124, 6, 40, 152, 182, 100, 120, 136, 19, 157, 135, 186, 37, 217,
+       23, 44, 170, 130, 87, 140, 112, 238, 92, 63, 242, 97, 242, 59,
+       183, 208, 127, 164, 123, 238, 15, 236, 197, 160, 54, 253, 206,
+       115, 144, 177, 173, 98, 188, 196, 37, 230, 237, 251, 135, 181, 3,
+       91, 239, 140, 116, 150, 175, 116, 237, 200, 222, 230, 248, 238,
+       183, 230, 126, 101, 63, 239, 197, 155, 54, 236, 54, 62, 174, 128,
+       13, 182, 57, 253, 58, 159, 122, 255, 117, 223, 87, 119, 213, 108,
+       124, 43, 107, 61, 38, 52, 204, 186, 151, 0, 252, 186, 112, 191,
+       99, 223, 0, 147, 115, 142, 212, 251, 165, 30, 206, 23, 142, 47,
+       175, 48, 148, 134, 226, 199, 241, 104, 49, 75, 124, 100, 42, 239,
+       160, 245, 85, 42, 4, 34, 195, 0, 125, 249, 120, 152, 124, 168,
+       142, 180, 11, 19, 20, 107, 150, 167, 195, 155, 103, 232, 66, 154,
+       249, 237, 233, 131, 92, 215, 203, 10, 219, 231, 221, 53, 33, 104,
+       158, 2, 48, 34, 200, 225, 20, 43, 113, 75, 38, 165, 238, 139, 163,
+       1, 74, 16, 122, 142, 207, 24, 10, 152, 69, 2, 206, 197, 176, 49,
+       229, 200, 94, 138, 43, 141, 99, 75, 213, 151, 171, 247, 68, 64,
+       124, 70, 56, 232, 180, 164, 88, 42, 18, 237, 147, 186, 52, 255,
+       44, 60, 138, 96, 95, 142, 240, 252, 35, 129, 98, 205, 125, 199,
+       225, 72, 87, 105, 124, 34, 96, 221, 190, 100, 248, 40, 19, 29,
+       131, 187, 32, 157, 21, 62, 178, 138, 87, 14, 112, 239, 138, 148,
+       181, 155, 237, 249, 165, 43, 159, 23, 73, 20, 236, 113, 12, 141,
+       129, 2, 179, 16, 50, 220, 123, 215, 13, 86, 90, 66, 146, 76, 149,
+       230, 97, 243, 241, 79, 190, 8, 22, 189, 75, 97, 24, 238, 247, 108,
+       140, 118, 22, 95, 78, 97, 211, 40, 253, 191, 172, 52, 37, 254, 60,
+       170, 129, 61, 58, 191, 122, 184, 115, 217, 86, 103, 189, 68, 252,
+       173, 46, 222, 38, 20, 190, 187, 199, 1, 94, 43, 18, 223, 251, 85,
+       8, 123, 83, 12, 175, 223, 2, 159, 58, 185, 242, 227, 185, 103,
+       190, 77, 90, 231, 188, 190, 38, 64, 231, 59, 55, 129, 214, 153,
+       16, 119, 108, 39, 58, 195, 28, 64, 173, 219, 147, 220, 58, 254,
+       37, 141, 93, 246, 157, 14, 86, 22, 190, 223, 58, 97, 164, 51, 31,
+       9, 226, 141, 50, 255, 243, 249, 58, 146, 16, 8, 21, 107, 180, 0,
+       6, 152, 9, 107, 0, 72, 148, 22, 193, 26, 70, 80, 41, 221, 232,
+       160, 234, 50, 40, 199, 83, 20, 145, 2, 83, 23, 16, 9, 38, 130, 40,
+       205, 37, 255, 244, 241, 166, 239, 86, 31, 120, 50, 224, 104, 180,
+       224, 201, 123, 130, 129, 230, 248, 111, 119, 47, 47, 254, 193,
+       213, 88, 245, 175, 117, 115, 63, 230, 116, 70, 103, 248, 98, 232,
+       151, 102, 83, 117, 137, 32, 124, 212, 12, 234, 137, 243, 41, 29,
+       120, 143, 229, 132, 108, 187, 116, 113, 252, 183, 89, 171, 254,
+       107, 82, 217, 95, 97, 61, 250, 71, 217, 202, 240, 22, 28, 215,
+       114, 183, 51, 201, 158, 254, 193, 37, 247, 190, 207, 218, 131, 52,
+       63, 250, 129, 246, 235, 247, 210, 123, 232, 126, 106, 22, 185,
+       247, 52, 59, 236, 22, 123, 176, 186, 132, 170, 126, 77, 37, 167,
+       231, 249, 94, 195, 82, 191, 98, 8, 219, 209, 156, 111, 171, 68,
+       140, 175, 44, 142, 102, 148, 238, 171, 207, 133, 94, 11, 198, 223,
+       58, 84, 142, 251, 23, 4, 175, 223, 99, 139, 236, 153, 223, 144,
+       184, 143, 207, 117, 92, 163, 168, 172, 214, 230, 79, 143, 187,
+       149, 150, 88, 231, 209, 14, 56, 223, 239, 183, 140, 216, 206, 52,
+       164, 232, 42, 158, 113, 146, 200, 86, 67, 189, 179, 227, 216, 254,
+       32, 91, 203, 142, 211, 30, 39, 78, 179, 218, 69, 186, 255, 253,
+       75, 252, 134, 22, 180, 188, 58, 155, 225, 176, 205, 206, 21, 137,
+       51, 108, 216, 106, 8, 187, 19, 203, 177, 54, 103, 31, 87, 217, 7,
+       31, 127, 245, 66, 173, 202, 55, 15, 106, 78, 210, 208, 158, 224,
+       64, 196, 252, 170, 113, 236, 183, 48, 126, 251, 132, 227, 205,
+       187, 174, 61, 58, 173, 169, 169, 117, 187, 110, 221, 163, 110,
+       222, 148, 86, 151, 188, 103, 220, 207, 126, 55, 32, 234, 39, 2,
+       239, 99, 2, 149, 228, 255, 6, 234, 62, 14, 158, 139, 133, 88, 233,
+       207, 114, 75, 254, 148, 54, 203, 248, 71, 143, 237, 146, 11, 46,
+       142, 119, 26, 166, 167, 255, 149, 12, 201, 0, 220, 219, 18, 219,
+       179, 5, 0, 13, 78, 112, 121, 121, 104, 126, 211, 91, 80, 69, 228,
+       252, 139, 19, 29, 55, 112, 206, 184, 23, 226, 200, 34, 113, 220,
+       243, 217, 0, 57, 55, 176, 102, 123, 191, 83, 99, 13, 118, 18, 174,
+       112, 85, 72, 247, 231, 89, 76, 191, 229, 126, 236, 150, 239, 237,
+       178, 36, 206, 54, 104, 163, 128, 127, 191, 120, 213, 224, 139,
+       108, 241, 188, 139, 121, 55, 172, 164, 182, 137, 179, 1, 146, 65,
+       66, 182, 79, 24, 120, 169, 65, 28, 238, 249, 178, 81, 84, 136,
+       220, 42, 218, 20, 234, 182, 135, 114, 93, 103, 177, 199, 199, 179,
+       108, 190, 42, 75, 243, 239, 157, 131, 124, 223, 164, 234, 243, 99,
+       222, 139, 167, 85, 188, 95, 71, 89, 119, 83, 232, 172, 188, 132,
+       169, 57, 51, 225, 92, 31, 221, 63, 166, 87, 245, 211, 148, 209,
+       139, 224, 7, 120, 222, 194, 197, 215, 195, 151, 116, 226, 26, 174,
+       93, 129, 18, 232, 135, 132, 233, 143, 102, 192, 42, 16, 216, 225,
+       234, 67, 78, 35, 154, 189, 144, 148, 3, 63, 81, 63, 110, 134, 34,
+       199, 74, 222, 116, 171, 210, 254, 95, 41, 124, 107, 112, 245, 182,
+       36, 91, 122, 151, 40, 162, 186, 10, 191, 106, 30, 165, 175, 87,
+       154, 92, 139, 171, 143, 64, 81, 245, 59, 238, 247, 95, 42, 60,
+       254, 14, 40, 214, 180, 43, 194, 150, 44, 245, 56, 101, 255, 46,
+       94, 85, 247, 223, 252, 218, 157, 103, 59, 232, 1, 236, 55, 254,
+       27, 80, 235, 245, 255, 209, 44, 215, 56, 95, 236, 118, 189, 157,
+       250, 229, 202, 78, 31, 229, 228, 205, 237, 218, 213, 48, 81, 107,
+       72, 116, 71, 91, 88, 101, 64, 244, 171, 19, 157, 183, 112, 126,
+       152, 23, 106, 201, 163, 52, 92, 83, 137, 33, 140, 125, 178, 118,
+       243, 2, 223, 59, 185, 242, 214, 189, 119, 172, 77, 90, 231, 29,
+       190, 182, 96, 230, 59, 151, 133, 213, 153, 48, 221, 107, 103, 186,
+       194, 28, 0, 165, 219, 17, 141, 107, 173, 150, 130, 111, 51, 100,
+       192, 74, 195, 181, 63, 48, 96, 102, 47, 17, 141, 208, 152, 21, 47,
+       229, 175, 170, 64, 36, 160, 161, 160, 35, 189, 97, 75, 213, 151,
+       239, 247, 87, 73, 124, 70, 48, 81, 180, 164, 88, 170, 18, 92, 211,
+       186, 116, 253, 47, 28, 132, 96, 91, 142, 240, 252, 10, 182, 170,
+       186, 223, 225, 185, 67, 158, 21, 85, 179, 172, 207, 110, 9, 235,
+       59, 163, 145, 22, 79, 146, 211, 93, 21, 154, 235, 149, 12, 189,
+       218, 40, 186, 202, 121, 100, 155, 104, 115, 55, 37, 244, 244, 131,
+       131, 192, 84, 95, 136, 134, 8, 26, 190, 69, 209, 78, 221, 176,
+       228, 111, 136, 126, 189, 43, 235, 2, 153, 109, 149, 108, 87, 143,
+       88, 92, 69, 168, 134, 246, 228, 204, 42, 186, 77, 199, 26, 230,
+       213, 38, 48, 154, 234, 26, 4, 216, 221, 237, 108, 236, 109, 108,
+       51, 202, 142, 82, 242, 180, 170, 17, 40, 215, 59, 75, 196, 118,
+       253, 175, 102, 199, 154, 86, 11, 229, 189, 253, 249, 122, 12, 225,
+       76, 57, 255, 96, 196, 93, 54, 49, 74, 118, 112, 183, 63, 177, 113,
+       198, 191, 53, 142, 233, 220, 96, 235, 231, 251, 242, 128, 48, 240,
+       100, 121, 31, 182, 206, 180, 178, 50, 30, 235, 51, 207, 92, 245,
+       111, 110, 139, 149, 183, 111, 229, 37, 188, 203, 143, 207, 186,
+       247, 125, 143, 174, 228, 43, 93, 1, 142, 144, 251, 176, 168, 104,
+       23, 126, 27, 74, 80, 157, 163, 160, 72, 195, 11, 34, 28, 50, 216,
+       7, 67, 140, 190, 118, 64, 144, 192, 169, 136, 124, 249, 82, 110,
+       95, 193, 82, 232, 131, 4, 169, 43, 34, 221, 96, 16, 216, 249, 239,
+       66, 74, 35, 202, 181, 243, 213, 5, 59, 115, 27, 110, 10, 41, 186,
+       18, 177, 100, 173, 112, 51, 127, 107, 112, 125, 175, 131, 210,
+       212, 207, 42, 6, 28, 159, 188, 192, 215, 206, 213, 50, 224, 142,
+       136, 74, 153, 105, 220, 243, 93, 117, 222, 243, 54, 93, 73, 118,
+       98, 58, 185, 54, 228, 209, 126, 178, 8, 165, 188, 48, 175, 47,
+       126, 16, 67, 78, 140, 84, 111, 7, 251, 147, 65, 229, 159, 110,
+       150, 111, 249, 38, 68, 142, 131, 85, 180, 165, 76, 114, 94, 211,
+       252, 185, 112, 47, 88, 7, 70, 202, 181, 203, 52, 189, 113, 110,
+       173, 22, 67, 215, 105, 68, 228, 251, 167, 87, 120, 58, 0, 122,
+       237, 21, 231, 204, 177, 13, 12, 240, 225, 175, 149, 109, 187, 240,
+       211, 156, 15, 35, 63, 148, 230, 175, 242, 84, 206, 90, 199, 113,
+       236, 179, 0, 189, 111, 3, 207, 176, 189, 44, 63, 121, 38, 43, 192,
+       85, 63, 53, 249, 226, 94, 175, 154, 218, 237, 183, 199, 158, 143,
+       208, 247, 180, 188, 37, 75, 237, 115, 123, 17, 98, 79, 18, 126,
+       61, 38, 190, 138, 149, 88, 183, 251, 114, 216, 143, 168, 94, 202,
+       177, 234, 170, 49, 144, 11, 212, 191, 37, 90, 235, 245, 127, 241,
+       10, 75, 154, 85, 217, 166, 255, 253, 148, 32, 55, 58, 3, 221, 59,
+       152, 244, 198, 189, 247, 188, 76, 94, 231, 60, 223, 182, 96, 238,
+       59, 19, 197, 213, 155, 48, 223, 123, 62, 174, 194, 21, 0, 165,
+       255, 129, 30, 255, 245, 96, 230, 125, 19, 177, 202, 118, 213, 25,
+       191, 5, 123, 199, 253, 21, 172, 169, 212, 176, 74, 199, 251, 242,
+       128, 136, 240, 34, 241, 6, 176, 179, 178, 253, 229, 176, 194, 158,
+       91, 81, 115, 252, 255, 104, 42, 197, 59, 179, 17, 51, 94, 154,
+       243, 77, 22, 218, 234, 156, 73, 145, 179, 171, 166, 224, 153, 215,
+       177, 184, 75, 95, 87, 85, 183, 168, 168, 254, 140, 223, 11, 130,
+       149, 182, 126, 102, 211, 14, 94, 154, 239, 223, 76, 249, 213, 54,
+       191, 83, 142, 250, 143, 70, 252, 159, 224, 24, 238, 119, 224, 172,
+       20, 23, 251, 6, 102, 235, 43, 30, 63, 184, 132, 13, 46, 124, 250,
+       147, 157, 33, 255, 81, 175, 242, 137, 39, 244, 106, 64, 88, 236,
+       231, 64, 153, 80, 6, 75, 70, 79, 195, 138, 92, 63, 44, 36, 36,
+       168, 60, 155, 131, 185, 138, 33, 83, 82, 211, 225, 53, 237, 59,
+       133, 104, 155, 108, 247, 77, 156, 59, 155, 131, 16, 50, 122, 170,
+       215, 63, 86, 20, 107, 231, 86, 167, 238, 42, 207, 74, 114, 240,
+       129, 126, 245, 23, 132, 124, 235, 41, 137, 226, 20, 15, 251, 134,
+       211, 88, 190, 70, 127, 110, 20, 52, 233, 119, 154, 174, 139, 2,
+       211, 123, 200, 114, 192, 185, 125, 173, 12, 245, 227, 44, 207,
+       166, 113, 126, 185, 135, 160, 82, 139, 38, 221, 118, 32, 42, 203,
+       53, 130, 167, 235, 34, 48, 99, 225, 116, 79, 235, 80, 13, 72, 91,
+       74, 17, 29, 56, 32, 126, 152, 23, 233, 129, 176, 17, 206, 69, 156,
+       168, 128, 77, 138, 82, 179, 3, 156, 145, 251, 177, 164, 184, 119,
+       30, 25, 65, 80, 188, 243, 104, 104, 197, 59, 51, 153, 51, 216,
+       154, 247, 205, 150, 254, 202, 152, 0, 161, 171, 129, 184, 147,
+       185, 57, 172, 185, 87, 190, 89, 114, 116, 188, 150, 224, 239, 167,
+       59, 122, 28, 51, 125, 178, 193, 141, 248, 90, 74, 152, 0, 33, 253,
+       171, 135, 117, 218, 207, 87, 205, 253, 213, 90, 213, 82, 104, 236,
+       190, 237, 93, 147, 182, 235, 253, 167, 111, 223, 59, 90, 86, 204,
+       119, 142, 160, 172, 191, 135, 101, 155, 157, 23, 206, 253, 85, 90,
+       243, 210, 249, 108, 62, 229, 93, 211, 190, 251, 255, 230, 127,
+       221, 63, 26, 215, 84, 87, 143, 228, 116, 41, 63, 40, 37, 52, 159,
+       250, 119, 78, 237, 122, 237, 187, 8, 150, 0, 204, 47, 22, 21, 220,
+       184, 69, 158, 236, 221, 186, 177, 76, 142, 219, 153, 94, 234, 251,
+       98, 50, 195, 59, 248, 174, 248, 30, 234, 93, 215, 227, 48, 55,
+       125, 253, 226, 0, 81, 172, 125, 216, 135, 175, 165, 37, 179, 7,
+       227, 68, 219, 151, 161, 160, 78, 37, 182, 38, 253, 66, 228, 213,
+       39, 192, 78, 103, 68, 44, 92, 145, 216, 185, 96, 140, 162, 247,
+       196, 136, 243, 161, 113, 213, 70, 44, 183, 44, 91, 152, 48, 196,
+       254, 147, 251, 215, 76, 155, 235, 143, 69, 252, 227, 236, 229,
+       111, 142, 194, 195, 123, 149, 100, 59, 25, 65, 76, 158, 151, 185,
+       202, 228, 55, 246, 148, 26, 90, 114, 148, 247, 33, 203, 229, 119,
+       123, 225, 49, 89, 202, 37, 237, 163, 111, 204, 128, 121, 165, 163,
+       12, 186, 252, 87, 187, 217, 53, 183, 191, 183, 46, 184, 238, 231,
+       79, 14, 7, 122, 233, 16, 50, 248, 186, 49, 79, 215, 85, 99, 194,
+       224, 13, 123, 1, 174, 150, 243, 176, 142, 40, 183, 126, 25, 82,
+       112, 189, 163, 160, 101, 167, 11, 38, 28, 50, 216, 3, 87, 140,
+       158, 118, 192, 128, 128, 161, 169, 115, 172, 193, 13, 154, 203,
+       75, 27, 51, 225, 218, 255, 147, 100, 214, 112, 87, 238, 125, 156,
+       191, 94, 231, 31, 188, 46, 189, 252, 189, 172, 210, 84, 29, 245,
+       67, 166, 154, 135, 143, 252, 134, 224, 152, 142, 85, 230, 249, 32,
+       54, 103, 90, 239, 195, 11, 190, 61, 120, 13, 45, 252, 109, 178,
+       163, 248, 162, 129, 103, 222, 207, 209, 165, 101, 221, 66, 85, 58,
+       104, 216, 188, 165, 59, 170, 178, 75, 247, 175, 46, 255, 50, 26,
+       80, 139, 23, 142, 245, 237, 92, 127, 255, 99, 178, 122, 55, 245,
+       233, 141, 127, 178, 79, 191, 138, 123, 55, 247, 173, 114, 208,
+       241, 172, 224, 250, 231, 103, 199, 231, 243, 167, 99, 212, 61,
+       255, 68, 246, 106, 119, 67, 249, 234, 127, 42, 30, 189, 161, 59,
+       34, 245, 125, 50, 49, 241, 160, 74, 82, 163, 97, 131, 229, 105,
+       135, 99, 82, 19, 144, 165, 172, 32, 158, 19, 142, 141, 155, 231,
+       228, 232, 204, 66, 198, 119, 237, 17, 144, 41, 195, 192, 136, 52,
+       170, 155, 140, 106, 181, 19, 137, 189, 23, 181, 163, 167, 170,
+       246, 22, 10, 90, 102, 189, 243, 161, 205, 119, 123, 55, 207, 179,
+       216, 17, 191, 108, 195, 251, 192, 42, 85, 9, 185, 2, 152, 191,
+       219, 105, 229, 185, 71, 175, 81, 69, 16, 188, 151, 96, 110, 231,
+       51, 123, 144, 19, 13, 50, 209, 205, 22, 90, 234, 144, 0, 39, 235,
+       95, 221, 100, 168, 191, 3, 95, 190, 7, 85, 156, 239, 207, 109,
+       218, 196, 126, 195, 255, 253, 218, 11, 79, 253, 250, 85, 175, 222,
+       191, 159, 184, 85, 59, 250, 98, 152, 103, 149, 154, 120, 31, 10,
+       212, 239, 40, 204, 191, 132, 254, 185, 151, 231, 206, 39, 14, 223,
+       18, 93, 139, 187, 87, 140, 122, 159, 19, 147, 71, 172, 246, 134,
+       238, 113, 173, 64, 219, 231, 93, 14, 180, 197, 126, 165, 23, 239,
+       209, 155, 21, 221, 188, 122, 202, 194, 45, 134, 177, 85, 252, 88,
+       229, 190, 111, 66, 95, 248, 21, 118, 151, 191, 95, 7, 35, 95, 99,
+       196, 63, 239, 104, 7, 91, 162, 208, 34, 249, 156, 62, 191, 52,
+       114, 95, 62, 194, 167, 22, 50, 186, 240, 51, 224, 143, 199, 77,
+       235, 91, 196, 55, 237, 185, 255, 133, 211, 157, 236, 218, 79, 143,
+       196, 47, 183, 57, 20, 87, 215, 206, 162, 146, 18, 62, 248, 45,
+       240, 143, 199, 77, 235, 127, 199, 119, 197, 185, 247, 212, 209,
+       157, 192, 186, 107, 207, 199, 175, 247, 169, 20, 100, 41, 218,
+       230, 240, 96, 90, 18, 35, 137, 77, 40, 53, 243, 65, 80, 114, 254,
+       21, 216, 26, 26, 192, 10, 254, 165, 160, 169, 160, 226, 38, 3, 9,
+       1, 81, 205, 116, 23, 106, 56, 69, 168, 120, 70, 25, 19, 181, 228,
+       126, 172, 22, 236, 129, 178, 81, 222, 36, 172, 163, 132, 59, 170,
+       96, 161, 52, 215, 91, 200, 250, 151, 94, 255, 7, 13, 220, 234, 83,
+       231, 168, 240, 118, 210, 159, 240, 91, 11, 41, 61, 251, 197, 165,
+       253, 181, 155, 172, 113, 92, 151, 220, 37, 178, 42, 62, 153, 38,
+       189, 63, 239, 93, 103, 139, 82, 55, 197, 237, 180, 148, 145, 141,
+       93, 254, 167, 109, 197, 173, 227, 139, 17, 107, 96, 243, 78, 65,
+       116, 107, 72, 59, 10, 105, 72, 104, 215, 205, 252, 85, 220, 178,
+       138, 3, 22, 186, 195, 23, 62, 144, 42, 3, 247, 102, 188, 110, 80,
+       211, 76, 65, 84, 111, 216, 57, 10, 97, 216, 72, 199, 237, 252,
+       117, 220, 179, 138, 65, 22, 186, 195, 23, 62, 208, 174, 19, 247,
+       102, 180, 137, 142, 198, 53, 129, 250, 105, 166, 54, 151, 78, 148,
+       169, 163, 178, 205, 51, 106, 160, 156, 114, 216, 45, 63, 206, 227,
+       222, 69, 38, 196, 41, 200, 226, 155, 44, 158, 105, 176, 188, 103,
+       155, 118, 208, 183, 40, 174, 54, 67, 206, 183, 187, 197, 228, 75,
+       230, 253, 55, 51, 218, 171, 85, 68, 173, 222, 33, 1, 80, 77, 116,
+       30, 106, 121, 117, 72, 124, 68, 83, 2, 181, 244, 122, 140, 6, 108,
+       193, 176, 53, 95, 52, 172, 35, 4, 123, 162, 106, 165, 64, 169, 0,
+       173, 92, 169, 96, 167, 102, 37, 74, 2, 161, 130, 64, 192, 104, 42,
+       106, 200, 2, 24, 199, 53, 172, 164, 130, 105, 48, 0, 25, 136, 64,
+       144, 30, 217, 93, 204, 161, 67, 238, 17, 198, 16, 156, 147, 96,
+       111, 192, 60, 106, 152, 19, 121, 243, 213, 205, 184, 210, 74, 154,
+       0, 33, 170, 124, 174, 236, 196, 140, 55, 199, 250, 82, 182, 174,
+       10, 83, 105, 89, 35, 89, 214, 235, 170, 104, 115, 253, 62, 123,
+       143, 197, 52, 231, 251, 244, 40, 182, 112, 152, 152, 142, 101,
+       152, 203, 159, 127, 144, 63, 196, 222, 111, 9, 221, 147, 127, 145,
+       166, 71, 218, 210, 155, 30, 219, 255, 153, 73, 9, 159, 2, 234, 74,
+       138, 252, 209, 170, 228, 142, 85, 88, 167, 164, 138, 246, 64, 235,
+       43, 2, 213, 86, 10, 14, 245, 44, 20, 158, 235, 148, 14, 181, 204,
+       193, 201, 99, 221, 71, 198, 111, 113, 213, 192, 198, 2, 113, 213,
+       52, 101, 120, 172, 58, 238, 201, 189, 119, 205, 39, 104, 135, 0,
+       55, 170, 240, 100, 215, 69, 167, 142, 199, 118, 238, 69, 237, 67,
+       195, 86, 93, 254, 61, 239, 120, 229, 58, 239, 181, 151, 188, 200,
+       53, 106, 202, 6, 47, 119, 177, 212, 216, 153, 213, 55, 135, 250,
+       85, 147, 119, 119, 70, 150, 235, 100, 131, 253, 51, 230, 172, 8,
+       127, 252, 125, 173, 207, 227, 84, 3, 162, 244, 204, 94, 173, 220,
+       189, 255, 245, 108, 87, 191, 81, 95, 124, 84, 246, 117, 153, 41,
+       221, 90, 21, 30, 187, 252, 123, 171, 239, 223, 244, 216, 154, 249,
+       208, 251, 45, 249, 173, 95, 237, 196, 247, 191, 210, 219, 84, 20,
+       240, 253, 89, 43, 205, 122, 51, 95, 211, 72, 251, 177, 111, 123,
+       245, 200, 138, 112, 214, 251, 86, 242, 132, 143, 11, 18, 14, 252,
+       3, 182, 137, 231, 100, 98, 221, 206, 245, 197, 232, 231, 204, 67,
+       223, 217, 176, 38, 207, 190, 61, 118, 185, 20, 18, 122, 190, 191,
+       142, 210, 180, 71, 168, 134, 144, 167, 172, 174, 70, 10, 239, 127,
+       235, 131, 196, 207, 166, 224, 226, 119, 94, 155, 5, 116, 175, 219,
+       250, 92, 107, 69, 151, 255, 87, 39, 85, 103, 206, 159, 107, 60,
+       54, 116, 120, 174, 157, 165, 189, 186, 117, 175, 243, 119, 144,
+       211, 231, 94, 244, 94, 50, 79, 106, 174, 23, 210, 130, 224, 4, 4,
+       207, 135, 99, 76, 63, 64, 120, 236, 139, 227, 76, 179, 29, 175,
+       241, 101, 138, 17, 37, 63, 124, 218, 173, 29, 61, 251, 181, 246,
+       79, 183, 81, 206, 189, 20, 186, 119, 179, 125, 221, 226, 23, 30,
+       249, 238, 120, 174, 235, 223, 244, 144, 154, 217, 220, 121, 39,
+       203, 202, 155, 238, 145, 190, 196, 94, 21, 116, 167, 32, 200, 119,
+       72, 235, 107, 130, 215, 198, 62, 78, 241, 78, 15, 158, 235, 93,
+       28, 121, 206, 3, 180, 130, 155, 215, 181, 184, 75, 30, 67, 81,
+       215, 172, 238, 126, 140, 255, 11, 147, 149, 55, 222, 30, 243, 13,
+       22, 154, 106, 157, 76, 185, 212, 0, 0, 159, 249, 47, 205, 177, 67,
+       142, 21, 198, 19, 188, 159, 96, 74, 232, 57, 235, 16, 2, 109, 2,
+       193, 71, 145, 26, 75, 208, 8, 37, 170, 64, 24, 154, 217, 29, 205,
+       145, 3, 206, 21, 230, 8, 182, 145, 98, 110, 192, 52, 106, 24, 19,
+       105, 243, 81, 197, 184, 18, 90, 218, 8, 1, 42, 114, 189, 110, 6,
+       95, 203, 147, 102, 137, 228, 184, 171, 98, 60, 30, 16, 232, 183,
+       219, 225, 92, 171, 116, 237, 51, 22, 136, 59, 69, 14, 86, 94, 217,
+       87, 175, 117, 179, 126, 21, 247, 53, 255, 86, 125, 91, 53, 130,
+       255, 181, 214, 181, 4, 253, 220, 49, 172, 251, 235, 117, 194, 234,
+       252, 188, 127, 60, 101, 89, 234, 223, 227, 83, 221, 71, 224, 237,
+       10, 114, 213, 41, 48, 88, 184, 2, 120, 10, 178, 56, 28, 123, 132,
+       5, 125, 243, 154, 100, 170, 103, 99, 234, 6, 125, 29, 214, 204,
+       75, 228, 188, 13, 98, 232, 223, 178, 152, 236, 192, 95, 206, 99,
+       220, 168, 58, 93, 5, 59, 73, 127, 90, 140, 30, 188, 175, 119, 149,
+       71, 79, 248, 23, 238, 198, 6, 120, 127, 61, 45, 61, 254, 49, 239,
+       185, 209, 59, 191, 123, 223, 205, 132, 171, 116, 116, 114, 162,
+       213, 59, 186, 244, 132, 156, 119, 157, 73, 216, 115, 60, 159, 36,
+       64, 204, 187, 23, 21, 250, 139, 0, 207, 185, 56, 190, 218, 144, 8,
+       176, 27, 35, 235, 202, 156, 110, 145, 186, 232, 207, 156, 84, 167,
+       40, 200, 247, 0, 202, 105, 147, 199, 198, 110, 78, 249, 30, 25,
+       203, 171, 29, 45, 121, 141, 8, 168, 159, 184, 107, 201, 177, 67,
+       142, 29, 224, 49, 172, 159, 96, 10, 170, 49, 235, 16, 2, 105, 2,
+       209, 85, 17, 90, 123, 80, 8, 7, 235, 214, 58, 62, 178, 171, 217,
+       176, 160, 174, 190, 147, 185, 206, 220, 71, 139, 167, 113, 253,
+       83, 116, 109, 11, 244, 216, 83, 127, 255, 132, 45, 13, 67, 222,
+       66, 54, 112, 43, 123, 80, 104, 237, 190, 183, 56, 207, 76, 205,
+       175, 171, 213, 236, 51, 44, 229, 43, 132, 147, 211, 83, 87, 227,
+       37, 15, 7, 221, 112, 126, 100, 14, 74, 87, 120, 228, 202, 182, 34,
+       87, 89, 19, 43, 58, 245, 92, 235, 237, 229, 53, 14, 241, 235, 97,
+       21, 109, 177, 41, 3, 58, 168, 184, 250, 73, 253, 112, 198, 167,
+       23, 172, 9, 46, 155, 98, 24, 169, 155, 243, 144, 14, 47, 146, 179,
+       223, 221, 16, 123, 211, 0, 78, 138, 40, 165, 61, 107, 221, 229,
+       193, 239, 199, 61, 172, 0, 50, 241, 104, 36, 217, 26, 66, 24, 26,
+       43, 122, 21, 107, 221, 133, 127, 211, 74, 246, 234, 181, 103, 106,
+       7, 116, 27, 207, 112, 85, 228, 246, 143, 99, 72, 159, 1, 92, 236,
+       87, 239, 236, 182, 100, 14, 102, 9, 165, 177, 101, 191, 90, 196,
+       163, 176, 131, 154, 77, 181, 168, 74, 95, 91, 193, 95, 140, 216,
+       124, 173, 201, 11, 50, 149, 183, 111, 186, 243, 29, 18, 218, 106,
+       152, 13, 177, 150, 2, 162, 158, 154, 67, 177, 184, 67, 190, 23,
+       81, 183, 172, 138, 102, 9, 239, 59, 131, 145, 22, 94, 2, 209, 148,
+       18, 218, 235, 149, 4, 47, 142, 82, 168, 144, 186, 9, 253, 48, 194,
+       175, 23, 129, 9, 44, 155, 100, 156, 161, 187, 235, 145, 6, 79,
+       138, 241, 155, 86, 154, 123, 146, 4, 15, 14, 167, 34, 237, 65,
+       236, 59, 203, 152, 82, 254, 181, 251, 195, 108, 223, 11, 95, 204,
+       103, 126, 188, 118, 239, 50, 14, 91, 229, 253, 245, 253, 86, 229,
+       173, 167, 232, 171, 252, 59, 203, 25, 86, 117, 157, 255, 195, 105,
+       218, 8, 95, 136, 87, 63, 190, 50, 205, 146, 206, 77, 161, 252,
+       255, 207, 218, 209, 98, 157, 51, 236, 124, 199, 158, 255, 139,
+       200, 152, 107, 188, 255, 117, 0, 143, 51, 87, 33, 193, 43, 26,
+       223, 187, 92, 15, 190, 92, 34, 35, 155, 36, 140, 23, 154, 217,
+       195, 134, 238, 222, 19, 225, 26, 102, 224, 40, 85, 217, 234, 74,
+       82, 122, 203, 74, 63, 56, 6, 95, 91, 144, 89, 181, 142, 35, 97,
+       118, 225, 110, 175, 248, 68, 15, 177, 122, 75, 152, 156, 53, 44,
+       206, 61, 55, 85, 132, 178, 66, 220, 7, 88, 210, 130, 85, 143, 83,
+       143, 159, 148, 229, 125, 19, 79, 79, 56, 23, 230, 71, 135, 123,
+       109, 22, 101, 53, 252, 57, 110, 185, 216, 125, 159, 251, 110, 205,
+       84, 231, 172, 20, 116, 178, 237, 106, 216, 95, 209, 218, 230, 153,
+       68, 144, 139, 40, 142, 54, 1, 234, 227, 151, 193, 110, 43, 38,
+       255, 51, 24, 138, 171, 21, 28, 116, 94, 54, 102, 138, 164, 27,
+       179, 22, 91, 178, 173, 155, 239, 102, 232, 75, 130, 221, 237, 237,
+       149, 206, 195, 136, 10, 186, 69, 173, 183, 161, 126, 58, 3, 10,
+       170, 54, 186, 107, 201, 177, 67, 174, 29, 64, 49, 172, 223, 98,
+       155, 162, 59, 227, 145, 18, 75, 130, 241, 213, 81, 90, 235, 16, 4,
+       39, 203, 214, 31, 156, 183, 170, 106, 20, 142, 172, 246, 142, 181,
+       239, 54, 11, 75, 135, 87, 237, 38, 44, 65, 195, 40, 194, 243, 95,
+       147, 136, 117, 9, 27, 78, 210, 156, 191, 42, 104, 52, 139, 142,
+       63, 131, 57, 204, 254, 74, 74, 131, 85, 239, 3, 6, 69, 203, 19,
+       196, 231, 127, 255, 148, 120, 141, 67, 38, 106, 168, 179, 141,
+       249, 157, 206, 142, 255, 156, 155, 129, 204, 95, 10, 201, 75, 195,
+       213, 6, 98, 234, 176, 207, 85, 159, 255, 213, 127, 151, 210, 182,
+       78, 101, 143, 78, 83, 143, 224, 21, 230, 213, 183, 65, 76, 183,
+       69, 94, 236, 151, 239, 233, 214, 109, 190, 48, 2, 237, 181, 55,
+       191, 116, 244, 199, 69, 127, 196, 236, 33, 159, 171, 137, 186,
+       152, 186, 220, 207, 253, 35, 135, 85, 125, 111, 224, 7, 170, 194,
+       240, 24, 111, 188, 20, 243, 195, 33, 56, 77, 102, 237, 151, 210,
+       236, 103, 197, 128, 250, 2, 75, 41, 52, 65, 106, 164, 23, 161, 92,
+       185, 21, 140, 59, 235, 198, 65, 119, 172, 240, 130, 254, 243, 224,
+       162, 13, 29, 90, 200, 3, 53, 165, 143, 75, 73, 90, 150, 216, 193,
+       197, 247, 206, 39, 220, 177, 147, 209, 129, 127, 119, 31, 222, 70,
+       64, 184, 158, 179, 235, 200, 49, 7, 170, 153, 6, 56, 188, 151, 66,
+       27, 163, 63, 234, 16, 18, 73, 130, 65, 205, 145, 30, 123, 128, 0,
+       143, 139, 74, 48, 168, 184, 237, 116, 16, 75, 138, 157, 136, 41,
+       172, 190, 75, 90, 193, 91, 255, 17, 22, 75, 194, 145, 223, 245,
+       186, 251, 144, 76, 31, 91, 196, 207, 216, 230, 244, 128, 238, 180,
+       233, 8, 184, 98, 237, 107, 185, 82, 106, 227, 15, 235, 202, 35,
+       72, 235, 246, 152, 166, 41, 53, 251, 233, 136, 190, 195, 40, 170,
+       28, 65, 219, 232, 22, 52, 157, 175, 71, 205, 122, 0, 93, 137, 143,
+       231, 206, 3, 111, 151, 248, 197, 171, 253, 53, 47, 60, 194, 52,
+       130, 202, 45, 70, 42, 106, 64, 107, 37, 127, 11, 9, 171, 94, 80,
+       58, 141, 2, 140, 20, 178, 132, 65, 214, 237, 2, 101, 101, 226,
+       107, 128, 66, 249, 178, 146, 253, 213, 176, 199, 235, 29, 136, 40,
+       172, 154, 100, 230, 193, 59, 251, 17, 86, 107, 226, 241, 61, 20,
+       158, 123, 130, 4, 191, 175, 41, 107, 65, 69, 164, 27, 110, 53, 69,
+       168, 122, 228, 243, 33, 209, 164, 94, 238, 4, 110, 201, 184, 197,
+       44, 164, 216, 165, 160, 78, 250, 210, 173, 22, 131, 45, 186, 156,
+       193, 155, 173, 134, 21, 137, 147, 229, 207, 42, 64, 221, 147, 187,
+       183, 94, 9, 107, 181, 251, 71, 138, 221, 20, 14, 181, 82, 154, 1,
+       98, 236, 31, 176, 250, 72, 143, 0, 210, 131, 105, 203, 125, 96,
+       122, 185, 59, 229, 6, 3, 151, 209, 18, 249, 139, 79, 55, 175, 113,
+       6, 31, 254, 241, 55, 243, 86, 94, 188, 123, 218, 93, 244, 111,
+       124, 159, 181, 151, 111, 181, 39, 247, 208, 172, 239, 170, 255,
+       109, 134, 175, 246, 235, 85, 120, 172, 130, 133, 29, 151, 67, 107,
+       82, 164, 206, 10, 99, 96, 2, 4, 89, 230, 104, 168, 44, 123, 253,
+       31, 59, 231, 145, 57, 99, 44, 92, 78, 248, 65, 198, 237, 13, 2,
+       78, 116, 197, 130, 250, 2, 75, 107, 57, 194, 120, 228, 61, 234,
+       72, 179, 17, 136, 179, 233, 199, 5, 39, 250, 120, 2, 11, 159, 43,
+       151, 50, 221, 189, 55, 124, 111, 94, 247, 189, 62, 182, 96, 167,
+       51, 191, 141, 229, 152, 53, 255, 230, 47, 186, 128, 28, 212, 141,
+       125, 70, 178, 182, 186, 171, 160, 185, 137, 174, 29, 131, 189,
+       236, 206, 110, 74, 199, 19, 235, 145, 22, 67, 202, 241, 153, 113,
+       218, 251, 144, 7, 165, 83, 80, 32, 220, 165, 26, 10, 105, 51, 38,
+       165, 134, 136, 215, 3, 82, 82, 34, 133, 109, 61, 8, 216, 197, 12,
+       220, 167, 57, 80, 36, 128, 3, 40, 24, 177, 26, 160, 144, 197, 112,
+       231, 166, 45, 170, 9, 159, 215, 98, 16, 177, 187, 205, 144, 94,
+       139, 144, 21, 251, 197, 39, 109, 160, 2, 167, 202, 246, 64, 198,
+       236, 7, 34, 76, 204, 33, 146, 242, 3, 66, 42, 61, 223, 120, 197,
+       44, 226, 8, 247, 145, 200, 145, 178, 194, 23, 161, 121, 104, 14,
+       67, 128, 19, 192, 97, 166, 104, 98, 173, 11, 90, 64, 141, 226,
+       180, 236, 247, 61, 62, 140, 17, 153, 130, 208, 156, 254, 218, 196,
+       10, 160, 33, 132, 152, 70, 90, 238, 82, 98, 27, 120, 53, 134, 213,
+       163, 109, 199, 171, 81, 126, 185, 135, 226, 104, 135, 32, 206,
+       243, 225, 170, 137, 55, 243, 36, 227, 71, 10, 7, 218, 44, 160,
+       104, 32, 237, 136, 83, 64, 224, 226, 181, 205, 192, 160, 46, 152,
+       17, 133, 3, 204, 140, 186, 210, 72, 136, 131, 113, 36, 252, 235,
+       232, 164, 172, 73, 95, 188, 2, 190, 180, 171, 87, 77, 91, 18, 27,
+       213, 205, 227, 76, 102, 237, 58, 243, 197, 165, 189, 117, 251,
+       158, 75, 86, 128, 158, 186, 43, 224, 153, 0, 172, 23, 131, 49,
+       236, 214, 42, 75, 163, 49, 237, 147, 30, 69, 11, 197, 209, 242,
+       90, 91, 128, 3, 37, 3, 51, 105, 35, 140, 91, 213, 154, 100, 139,
+       68, 232, 11, 44, 222, 38, 180, 248, 169, 211, 197, 71, 11, 50,
+       253, 51, 84, 8, 59, 83, 14, 47, 206, 65, 157, 31, 108, 240, 174,
+       53, 119, 104, 73, 106, 68, 182, 179, 32, 112, 164, 55, 48, 44,
+       209, 169, 18, 13, 225, 174, 34, 72, 72, 64, 163, 187, 30, 158,
+       236, 211, 182, 118, 255, 183, 63, 255, 62, 247, 73, 47, 158, 139,
+       111, 215, 151, 150, 176, 248, 109, 238, 110, 79, 247, 199, 239,
+       245, 236, 219, 14, 250, 236, 87, 176, 153, 191, 188, 191, 255, 94,
+       165, 233, 237, 223, 15, 23, 126, 253, 92, 182, 216, 175, 245, 110,
+       95, 117, 199, 142, 247, 29, 125, 219, 101, 239, 229, 18, 118, 109,
+       190, 48, 226, 222, 130, 125, 55, 155, 115, 54, 215, 29, 236, 169,
+       208, 181, 74, 241, 169, 234, 132, 37, 240, 51, 120, 83, 23, 205,
+       173, 178, 106, 109, 63, 57, 103, 82, 245, 181, 39, 130, 83, 55,
+       95, 29, 172, 225, 216, 53, 79, 164, 238, 58, 132, 172, 240, 129,
+       121, 138, 155, 148, 191, 114, 136, 57, 23, 158, 29, 82, 245, 172,
+       167, 162, 66, 166, 63, 175, 4, 146, 216, 195, 209, 196, 225, 122,
+       131, 156, 140, 137, 217, 240, 229, 109, 103, 146, 107, 71, 191,
+       114, 229, 175, 187, 83, 117, 202, 49, 27, 214, 101, 186, 120, 120,
+       237, 30, 109, 134, 229, 244, 229, 242, 214, 112, 48, 217, 120,
+       233, 86, 205, 247, 254, 6, 37, 124, 138, 55, 159, 32, 0, 126, 155,
+       7, 64, 66, 58, 48, 61, 255, 133, 38, 105, 113, 154, 135, 234, 48,
+       251, 120, 232, 86, 205, 187, 246, 14, 5, 124, 139, 63, 141, 38, 0,
+       254, 155, 131, 192, 66, 58, 48, 253, 119, 205, 2, 105, 117, 152,
+       71, 250, 3, 34, 98, 89, 100, 152, 232, 81, 119, 65, 118, 231, 161,
+       200, 246, 228, 126, 168, 179, 156, 134, 184, 230, 193, 70, 124,
+       146, 200, 111, 140, 120, 140, 133, 2, 159, 251, 164, 172, 105,
+       151, 126, 27, 114, 80, 151, 35, 136, 120, 247, 14, 46, 28, 179,
+       220, 1, 98, 204, 174, 118, 64, 128, 192, 225, 33, 220, 122, 123,
+       116, 82, 194, 51, 96, 176, 132, 99, 177, 127, 215, 33, 81, 54,
+       189, 197, 226, 96, 151, 160, 78, 209, 161, 34, 137, 33, 161, 39,
+       115, 70, 147, 184, 162, 255, 245, 154, 193, 143, 85, 157, 175,
+       142, 236, 126, 8, 135, 51, 251, 21, 150, 43, 190, 208, 219, 84,
+       15, 255, 212, 79, 157, 87, 180, 68, 123, 96, 66, 107, 77, 81, 48,
+       166, 243, 154, 19, 15, 1, 17, 126, 156, 71, 110, 40, 183, 117, 12,
+       243, 233, 32, 20, 101, 153, 102, 160, 48, 65, 98, 201, 70, 169,
+       232, 66, 69, 0, 251, 131, 1, 137, 52, 64, 110, 184, 11, 204, 136,
+       176, 5, 192, 86, 40, 130, 0, 119, 138, 112, 136, 153, 86, 123,
+       233, 162, 123, 191, 119, 60, 70, 117, 183, 93, 62, 170, 33, 183,
+       19, 151, 166, 229, 149, 36, 70, 242, 207, 106, 132, 101, 209, 167,
+       241, 0, 163, 192, 131, 196, 9, 100, 135, 102, 49, 74, 192, 163,
+       128, 72, 64, 104, 10, 106, 24, 22, 56, 71, 49, 140, 132, 22, 101,
+       176, 202, 193, 136, 135, 96, 165, 188, 61, 4, 200, 73, 141, 154,
+       209, 82, 188, 219, 49, 175, 200, 33, 95, 223, 171, 231, 83, 200,
+       129, 88, 138, 154, 20, 45, 49, 161, 156, 221, 58, 250, 155, 197,
+       159, 205, 130, 22, 132, 19, 189, 223, 99, 66, 227, 115, 153, 211,
+       110, 15, 26, 51, 251, 193, 142, 127, 16, 18, 165, 154, 131, 188,
+       155, 248, 58, 231, 57, 95, 62, 27, 0, 80, 188, 151, 96, 120, 167,
+       59, 63, 144, 51, 77, 51, 87, 217, 150, 58, 234, 152, 64, 33, 59,
+       57, 142, 1, 237, 52, 167, 75, 58, 84, 9, 218, 70, 243, 33, 176,
+       228, 88, 174, 30, 44, 153, 186, 81, 31, 229, 239, 162, 0, 58, 202,
+       112, 41, 220, 121, 211, 100, 83, 206, 51, 80, 185, 224, 34, 40,
+       62, 151, 65, 54, 34, 252, 88, 82, 97, 253, 144, 42, 249, 140, 5,
+       34, 106, 51, 7, 59, 133, 92, 119, 85, 71, 254, 225, 112, 237, 194,
+       103, 84, 94, 213, 37, 255, 162, 52, 66, 42, 161, 245, 48, 76, 7,
+       234, 64, 2, 75, 113, 97, 183, 199, 190, 253, 91, 186, 217, 59,
+       186, 207, 253, 30, 176, 236, 254, 215, 98, 7, 115, 254, 81, 167,
+       76, 239, 115, 78, 19, 127, 251, 148, 131, 13, 127, 119, 160, 240,
+       224, 246, 41, 218, 136, 107, 33, 59, 202, 79, 73, 92, 48, 183,
+       149, 117, 121, 18, 32, 137, 209, 154, 220, 11, 126, 197, 131, 67,
+       5, 132, 30, 253, 243, 228, 236, 107, 144, 88, 31, 113, 112, 215,
+       125, 153, 43, 79, 82, 22, 154, 179, 244, 104, 98, 199, 154, 242,
+       160, 244, 217, 84, 227, 61, 5, 122, 229, 198, 34, 127, 115, 53,
+       166, 255, 131, 83, 45, 179, 81, 126, 156, 23, 174, 56, 179, 53,
+       142, 243, 237, 160, 4, 101, 251, 240, 112, 64, 154, 150, 158, 77,
+       169, 144, 239, 158, 31, 192, 121, 166, 240, 96, 207, 201, 43, 234,
+       0, 6, 107, 202, 245, 157, 50, 90, 59, 152, 76, 45, 143, 0, 186,
+       148, 154, 105, 169, 144, 202, 158, 31, 240, 125, 230, 200, 104,
+       207, 201, 43, 234, 0, 6, 111, 202, 245, 156, 18, 83, 123, 216, 12,
+       13, 155, 165, 124, 55, 87, 101, 159, 224, 112, 252, 234, 115, 92,
+       22, 25, 21, 183, 164, 124, 86, 110, 225, 245, 48, 44, 23, 155, 96,
+       2, 74, 57, 66, 181, 98, 161, 208, 171, 116, 137, 234, 141, 75, 33,
+       57, 10, 175, 104, 92, 0, 26, 139, 7, 81, 18, 58, 204, 241, 188,
+       20, 138, 124, 212, 10, 83, 136, 108, 201, 81, 233, 108, 137, 196,
+       238, 207, 48, 184, 74, 139, 25, 116, 129, 202, 153, 7, 97, 90, 42,
+       66, 149, 188, 216, 71, 126, 85, 8, 211, 162, 244, 47, 234, 53,
+       182, 106, 123, 154, 48, 231, 254, 179, 83, 109, 147, 90, 51, 238,
+       44, 164, 60, 240, 165, 10, 202, 167, 241, 133, 229, 249, 116, 80,
+       178, 253, 106, 254, 154, 193, 159, 239, 144, 198, 132, 187, 49,
+       255, 38, 33, 249, 243, 145, 227, 110, 79, 56, 63, 251, 131, 223,
+       59, 53, 88, 180, 122, 165, 77, 103, 79, 92, 150, 199, 112, 81,
+       192, 242, 72, 115, 80, 181, 165, 88, 236, 82, 106, 233, 182, 125,
+       46, 37, 58, 225, 16, 103, 187, 114, 172, 161, 205, 67, 205, 116,
+       150, 238, 252, 85, 64, 248, 70, 113, 80, 180, 229, 88, 170, 22,
+       236, 237, 186, 117, 189, 38, 56, 162, 0, 95, 154, 120, 172, 80,
+       141, 213, 53, 136, 10, 68, 175, 172, 178, 130, 200, 247, 97, 16,
+       83, 3, 102, 104, 46, 104, 201, 207, 12, 168, 178, 69, 20, 32, 240,
+       1, 8, 36, 165, 146, 168, 209, 97, 82, 73, 3, 1, 105, 11, 6, 240,
+       108, 148, 217, 139, 130, 48, 30, 50, 72, 146, 57, 212, 1, 111,
+       209, 106, 230, 134, 185, 107, 42, 8, 92, 149, 206, 220, 66, 72,
+       120, 78, 16, 200, 55, 176, 88, 136, 18, 111, 207, 50, 212, 31, 48,
+       13, 169, 104, 93, 27, 250, 132, 123, 92, 105, 236, 125, 52, 219,
+       22, 192, 104, 252, 15, 57, 30, 183, 113, 204, 165, 21, 237, 173,
+       34, 244, 157, 115, 249, 170, 184, 31, 188, 80, 255, 31, 84, 233,
+       227, 246, 82, 238, 151, 61, 67, 91, 247, 25, 47, 150, 200, 63,
+       199, 149, 175, 189, 152, 37, 238, 166, 207, 254, 128, 175, 215,
+       249, 81, 32, 160, 20, 185, 77, 233, 160, 75, 30, 51, 224, 91, 4,
+       192, 100, 153, 201, 41, 98, 16, 50, 126, 83, 81, 13, 18, 81, 127,
+       217, 8, 74, 138, 156, 94, 185, 247, 180, 110, 87, 150, 84, 206,
+       127, 117, 159, 63, 171, 73, 247, 95, 157, 27, 185, 180, 121, 42,
+       227, 239, 54, 144, 236, 249, 140, 123, 199, 185, 173, 223, 238,
+       196, 189, 191, 186, 219, 20, 52, 244, 127, 218, 123, 167, 87, 127,
+       95, 243, 72, 251, 97, 77, 43, 255, 196, 140, 112, 215, 251, 123,
+       94, 110, 108, 116, 54, 221, 23, 128, 204, 220, 135, 25, 62, 183,
+       113, 204, 165, 149, 189, 173, 138, 117, 140, 99, 233, 170, 144,
+       159, 244, 88, 95, 4, 43, 29, 177, 250, 137, 177, 199, 190, 184,
+       48, 233, 148, 147, 193, 25, 166, 43, 102, 84, 18, 120, 194, 112,
+       44, 144, 63, 234, 192, 0, 131, 137, 223, 213, 229, 197, 164, 22,
+       237, 191, 100, 234, 146, 118, 89, 56, 156, 231, 123, 196, 61, 255,
+       249, 252, 117, 194, 188, 42, 230, 196, 47, 252, 240, 116, 239,
+       221, 113, 242, 228, 180, 222, 244, 217, 10, 188, 90, 120, 125,
+       189, 179, 205, 211, 23, 255, 251, 35, 88, 226, 115, 221, 172, 248,
+       223, 219, 250, 57, 145, 79, 78, 175, 52, 150, 238, 244, 68, 72,
+       218, 198, 241, 72, 183, 225, 124, 226, 30, 239, 237, 186, 85, 237,
+       162, 233, 170, 128, 61, 154, 120, 156, 165, 244, 21, 65, 61, 31,
+       66, 184, 95, 186, 161, 92, 210, 81, 93, 183, 157, 4, 90, 110, 235,
+       100, 89, 31, 47, 216, 5, 116, 90, 171, 90, 164, 35, 200, 240, 90,
+       77, 253, 144, 206, 203, 21, 124, 26, 40, 152, 247, 172, 201, 90,
+       162, 80, 135, 42, 246, 241, 23, 124, 80, 107, 215, 93, 94, 206,
+       231, 104, 224, 90, 93, 244, 242, 194, 203, 80, 116, 10, 40, 216,
+       247, 238, 200, 234, 178, 91, 135, 43, 246, 243, 31, 120, 128, 43,
+       215, 13, 120, 140, 175, 94, 70, 83, 195, 63, 252, 246, 89, 242,
+       63, 255, 72, 40, 223, 143, 63, 197, 162, 182, 165, 245, 29, 220,
+       62, 90, 197, 231, 239, 255, 104, 148, 87, 19, 195, 133, 166, 114,
+       232, 81, 116, 224, 91, 246, 89, 190, 253, 238, 126, 205, 54, 189,
+       149, 209, 165, 192, 24, 40, 171, 132, 173, 231, 177, 53, 155, 147,
+       236, 193, 230, 22, 255, 150, 60, 101, 86, 215, 89, 47, 222, 104,
+       55, 95, 55, 221, 144, 216, 53, 226, 110, 47, 254, 196, 175, 209,
+       145, 249, 35, 222, 119, 77, 82, 147, 174, 246, 117, 0, 122, 226,
+       40, 68, 180, 165, 126, 120, 2, 234, 225, 188, 36, 255, 36, 62,
+       134, 2, 87, 150, 224, 173, 3, 175, 102, 27, 215, 187, 176, 103,
+       220, 65, 122, 119, 40, 168, 182, 164, 170, 43, 130, 21, 182, 185,
+       4, 255, 46, 93, 22, 67, 205, 76, 249, 141, 25, 136, 28, 181, 54,
+       139, 56, 32, 46, 177, 130, 0, 255, 18, 0, 64, 162, 37, 104, 21, 2,
+       249, 67, 157, 205, 227, 90, 81, 36, 8, 1, 8, 2, 161, 134, 152, 71,
+       192, 168, 67, 174, 17, 194, 2, 12, 154, 116, 232, 232, 191, 59,
+       149, 18, 219, 146, 193, 29, 48, 218, 75, 133, 4, 185, 142, 179,
+       110, 238, 24, 93, 180, 222, 198, 153, 86, 244, 151, 40, 206, 183,
+       150, 205, 235, 151, 213, 238, 15, 54, 235, 50, 93, 158, 171, 31,
+       213, 122, 222, 56, 163, 240, 78, 27, 83, 82, 73, 67, 165, 173, 40,
+       43, 214, 206, 180, 88, 216, 194, 82, 94, 43, 110, 185, 59, 221, 5,
+       63, 243, 142, 110, 230, 143, 217, 236, 195, 226, 16, 191, 182, 62,
+       113, 86, 247, 157, 46, 214, 98, 39, 87, 55, 221, 147, 216, 189,
+       226, 110, 45, 254, 192, 173, 149, 137, 253, 66, 148, 190, 26, 83,
+       244, 177, 71, 252, 85, 107, 17, 44, 254, 46, 88, 225, 59, 163, 1,
+       22, 171, 50, 69, 83, 54, 26, 75, 208, 4, 165, 222, 161, 57, 63,
+       80, 108, 237, 241, 87, 207, 25, 112, 24, 178, 153, 116, 59, 136,
+       58, 82, 16, 147, 122, 114, 209, 87, 152, 80, 106, 88, 8, 214, 187,
+       81, 16, 159, 228, 40, 140, 80, 51, 169, 185, 130, 76, 182, 51, 64,
+       83, 132, 181, 125, 8, 8, 73, 211, 64, 211, 242, 122, 210, 8, 0, 3,
+       11, 88, 26, 31, 189, 56, 143, 16, 0, 174, 41, 146, 96, 255, 19,
+       128, 66, 198, 53, 108, 1, 8, 137, 67, 157, 192, 243, 122, 18, 8,
+       0, 1, 3, 2, 128, 167, 219, 236, 165, 168, 71, 94, 17, 83, 83, 160,
+       138, 116, 73, 233, 59, 51, 145, 150, 248, 67, 209, 13, 58, 218,
+       66, 149, 8, 241, 138, 160, 36, 61, 92, 76, 103, 69, 106, 80, 26,
+       252, 24, 146, 53, 1, 61, 89, 154, 68, 42, 41, 230, 113, 14, 193,
+       170, 240, 24, 208, 121, 102, 162, 11, 151, 210, 139, 242, 153,
+       186, 83, 62, 73, 121, 231, 172, 230, 174, 132, 190, 43, 134, 20,
+       151, 152, 4, 211, 44, 20, 46, 202, 223, 142, 169, 149, 55, 77,
+       107, 204, 22, 215, 203, 96, 77, 68, 253, 2, 115, 220, 181, 100,
+       120, 168, 31, 239, 201, 163, 52, 223, 177, 140, 139, 144, 117,
+       187, 117, 100, 0, 129, 58, 26, 81, 204, 177, 71, 252, 69, 99, 17,
+       172, 142, 54, 80, 160, 43, 35, 17, 22, 185, 50, 101, 95, 52, 18,
+       75, 64, 4, 167, 206, 96, 184, 155, 112, 105, 237, 113, 87, 171,
+       25, 40, 8, 190, 151, 68, 26, 132, 59, 91, 16, 19, 107, 146, 65,
+       215, 216, 16, 107, 200, 0, 135, 187, 38, 160, 183, 243, 108, 173,
+       248, 192, 235, 19, 113, 89, 228, 219, 108, 31, 201, 123, 99, 83,
+       22, 118, 202, 241, 7, 218, 80, 107, 192, 137, 66, 134, 32, 12,
+       173, 247, 205, 108, 101, 134, 214, 31, 126, 16, 242, 53, 17, 106,
+       201, 82, 51, 136, 9, 248, 115, 32, 69, 190, 246, 0, 192, 121, 212,
+       234, 38, 144, 33, 154, 237, 221, 144, 107, 207, 117, 181, 27, 8,
+       220, 126, 12, 201, 131, 243, 21, 150, 43, 122, 213, 31, 92, 219,
+       127, 215, 12, 215, 214, 218, 92, 172, 177, 169, 252, 93, 150, 143,
+       254, 158, 53, 174, 191, 71, 207, 197, 119, 253, 85, 189, 77, 243,
+       160, 227, 243, 252, 147, 130, 117, 28, 95, 59, 217, 106, 138, 29,
+       213, 83, 253, 199, 76, 157, 135, 107, 220, 55, 228, 92, 160, 159,
+       255, 207, 43, 62, 157, 187, 93, 133, 223, 63, 142, 124, 92, 11,
+       31, 66, 11, 178, 185, 186, 87, 60, 73, 91, 231, 172, 38, 134, 196,
+       54, 43, 150, 21, 151, 152, 5, 255, 44, 68, 42, 194, 191, 134, 137,
+       157, 218, 79, 103, 164, 54, 194, 111, 116, 165, 132, 214, 163,
+       105, 39, 161, 71, 98, 244, 173, 234, 104, 153, 37, 236, 240, 226,
+       238, 129, 39, 181, 52, 105, 194, 144, 154, 176, 41, 204, 80, 7,
+       171, 25, 163, 25, 190, 151, 64, 90, 164, 183, 253, 0, 19, 13, 146,
+       193, 211, 241, 90, 123, 8, 0, 7, 59, 2, 185, 115, 152, 107, 197,
+       184, 68, 175, 85, 80, 167, 172, 159, 118, 64, 238, 185, 179, 213,
+       151, 26, 146, 209, 23, 24, 154, 234, 21, 4, 37, 223, 38, 160, 182,
+       218, 109, 173, 248, 72, 207, 27, 113, 91, 136, 217, 124, 15, 201,
+       25, 55, 19, 22, 118, 138, 241, 79, 90, 210, 234, 211, 11, 199,
+       135, 252, 201, 116, 242, 237, 157, 94, 192, 171, 16, 165, 9, 127,
+       203, 105, 219, 130, 211, 201, 82, 74, 39, 26, 240, 243, 217, 68,
+       61, 114, 191, 206, 2, 178, 113, 106, 218, 91, 212, 157, 69, 153,
+       77, 245, 183, 40, 222, 62, 36, 238, 187, 151, 129, 238, 15, 54,
+       203, 115, 124, 154, 139, 23, 20, 182, 223, 154, 94, 182, 176, 167,
+       254, 29, 214, 141, 254, 30, 55, 12, 159, 55, 239, 167, 119, 189,
+       21, 229, 205, 50, 224, 243, 123, 94, 147, 134, 92, 157, 95, 62,
+       249, 166, 74, 157, 221, 211, 221, 207, 93, 188, 15, 106, 221, 63,
+       164, 216, 178, 223, 81, 159, 43, 122, 253, 123, 93, 5, 219, 211,
+       30, 220, 95, 89, 29, 115, 197, 53, 238, 111, 50, 173, 130, 110,
+       66, 58, 55, 165, 244, 102, 118, 30, 106, 225, 153, 48, 238, 165,
+       190, 128, 0, 34, 253, 68, 56, 60, 105, 106, 72, 29, 147, 203, 120,
+       196, 140, 189, 2, 120, 217, 183, 96, 120, 160, 91, 234, 72, 163,
+       40, 221, 115, 45, 163, 153, 119, 171, 116, 162, 162, 177, 186,
+       250, 203, 193, 177, 71, 187, 23, 97, 59, 44, 159, 102, 25, 235,
+       187, 195, 144, 50, 111, 146, 241, 87, 209, 90, 107, 80, 0, 167,
+       219, 24, 80, 58, 169, 44, 205, 89, 80, 172, 9, 211, 33, 159, 159,
+       32, 64, 198, 57, 157, 65, 10, 129, 18, 145, 193, 241, 42, 145, 16,
+       11, 37, 43, 3, 176, 190, 218, 109, 213, 184, 76, 223, 93, 85, 19,
+       172, 222, 126, 45, 207, 27, 51, 157, 150, 88, 186, 241, 15, 26,
+       218, 235, 148, 13, 53, 255, 110, 178, 182, 250, 109, 61, 250, 216,
+       203, 27, 181, 88, 72, 223, 125, 63, 205, 81, 247, 82, 150, 103,
+       138, 241, 95, 219, 67, 127, 211, 63, 102, 131, 38, 48, 181, 210,
+       221, 253, 176, 202, 139, 241, 177, 27, 140, 220, 93, 171, 141,
+       147, 219, 17, 19, 107, 218, 244, 31, 88, 27, 127, 199, 77, 87,
+       214, 255, 219, 106, 110, 59, 212, 159, 244, 165, 76, 246, 167,
+       107, 223, 190, 245, 254, 245, 149, 231, 237, 139, 60, 253, 243,
+       249, 170, 203, 127, 151, 46, 127, 92, 32, 230, 229, 31, 18, 120,
+       8, 231, 177, 183, 2, 75, 203, 85, 202, 120, 180, 125, 248, 8, 225,
+       199, 200, 219, 233, 195, 69, 167, 167, 120, 2, 57, 169, 104, 108,
+       126, 153, 91, 88, 71, 128, 124, 138, 59, 207, 243, 176, 58, 168,
+       23, 204, 74, 58, 230, 159, 71, 205, 161, 41, 119, 174, 94, 232,
+       130, 123, 122, 200, 126, 221, 186, 68, 137, 76, 188, 171, 172,
+       158, 166, 32, 238, 49, 215, 193, 198, 43, 34, 213, 55, 89, 42,
+       251, 21, 143, 47, 223, 220, 148, 189, 213, 56, 79, 23, 186, 22,
+       238, 198, 116, 247, 117, 8, 97, 21, 116, 57, 40, 185, 220, 249,
+       31, 233, 166, 101, 52, 24, 232, 4, 113, 42, 177, 40, 218, 237,
+       197, 152, 235, 143, 121, 145, 31, 156, 222, 124, 160, 205, 27,
+       187, 145, 215, 11, 90, 213, 31, 29, 219, 255, 28, 12, 153, 210,
+       203, 94, 252, 253, 169, 54, 93, 150, 173, 126, 158, 245, 157, 31,
+       151, 127, 199, 213, 253, 141, 172, 68, 99, 192, 199, 251, 250,
+       151, 22, 245, 13, 119, 60, 235, 6, 172, 93, 135, 66, 232, 199, 8,
+       240, 79, 99, 217, 33, 144, 248, 232, 134, 210, 78, 187, 10, 189,
+       187, 208, 129, 107, 123, 47, 126, 131, 98, 41, 241, 232, 124, 131,
+       216, 75, 143, 160, 184, 200, 174, 219, 84, 144, 150, 185, 95, 21,
+       2, 43, 198, 217, 138, 92, 137, 190, 22, 174, 67, 12, 35, 225, 43,
+       203, 212, 197, 175, 245, 78, 73, 88, 70, 144, 212, 252, 36, 124,
+       42, 18, 221, 211, 186, 60, 85, 45, 12, 174, 236, 93, 26, 241, 252,
+       2, 166, 130, 154, 123, 177, 184, 70, 142, 5, 88, 231, 172, 202,
+       110, 140, 239, 43, 147, 149, 22, 26, 134, 243, 156, 84, 154, 235,
+       156, 78, 57, 223, 38, 240, 172, 218, 79, 213, 184, 204, 203, 93,
+       21, 31, 12, 220, 126, 175, 239, 25, 243, 209, 147, 99, 186, 241,
+       95, 24, 218, 239, 215, 13, 255, 247, 73, 203, 18, 140, 44, 132,
+       141, 117, 204, 12, 218, 70, 188, 162, 164, 230, 204, 33, 110, 76,
+       193, 41, 195, 249, 180, 60, 106, 152, 24, 58, 169, 45, 38, 177,
+       251, 82, 245, 221, 251, 192, 203, 101, 53, 9, 142, 221, 126, 24,
+       159, 25, 147, 82, 150, 50, 186, 242, 79, 220, 17, 111, 210, 143,
+       199, 215, 151, 82, 110, 135, 34, 18, 190, 212, 44, 198, 211, 231,
+       205, 14, 191, 75, 118, 85, 191, 231, 229, 149, 13, 232, 182, 34,
+       234, 132, 45, 183, 41, 221, 52, 90, 151, 191, 13, 67, 64, 232,
+       199, 158, 243, 103, 98, 235, 45, 219, 248, 228, 166, 226, 72, 243,
+       11, 168, 147, 226, 197, 23, 115, 59, 116, 138, 103, 96, 152, 242,
+       77, 125, 208, 200, 203, 179, 177, 24, 158, 216, 71, 138, 201, 201,
+       91, 17, 15, 103, 218, 226, 155, 220, 159, 63, 200, 121, 91, 134,
+       139, 88, 118, 241, 53, 159, 248, 50, 253, 224, 178, 131, 175, 29,
+       53, 237, 238, 177, 159, 197, 165, 189, 16, 220, 134, 218, 218,
+       130, 14, 140, 89, 29, 219, 90, 124, 245, 39, 158, 248, 178, 237,
+       50, 150, 211, 143, 31, 53, 239, 238, 181, 191, 229, 172, 252, 117,
+       220, 214, 251, 202, 150, 63, 188, 89, 7, 43, 181, 117, 226, 253,
+       253, 216, 183, 143, 125, 188, 109, 172, 61, 214, 36, 207, 19, 223,
+       17, 150, 43, 104, 245, 111, 93, 158, 250, 214, 206, 214, 255, 54,
+       251, 19, 190, 113, 135, 2, 232, 27, 216, 241, 109, 102, 232, 39,
+       17, 220, 233, 6, 99, 127, 235, 138, 189, 184, 178, 5, 58, 88, 59,
+       42, 159, 4, 161, 212, 149, 197, 74, 229, 239, 58, 179, 162, 18,
+       204, 98, 72, 139, 121, 199, 106, 177, 121, 122, 219, 192, 156,
+       130, 223, 101, 141, 104, 233, 136, 78, 168, 208, 145, 221, 9, 233,
+       175, 47, 179, 168, 2, 172, 226, 93, 134, 59, 203, 106, 157, 66,
+       72, 203, 241, 12, 150, 95, 108, 140, 120, 73, 140, 57, 199, 107,
+       105, 84, 215, 235, 245, 84, 73, 126, 66, 113, 93, 186, 96, 120,
+       42, 22, 252, 219, 184, 37, 31, 111, 237, 164, 192, 119, 138, 240,
+       233, 11, 129, 24, 187, 237, 133, 188, 111, 142, 23, 69, 23, 140,
+       202, 122, 64, 207, 11, 59, 133, 86, 14, 90, 209, 77, 125, 154,
+       108, 24, 8, 169, 130, 130, 72, 83, 210, 116, 201, 249, 70, 173,
+       128, 114, 34, 188, 158, 53, 164, 170, 187, 23, 145, 33, 157, 2,
+       238, 52, 28, 154, 130, 132, 136, 109, 169, 214, 66, 252, 253, 46,
+       58, 248, 58, 121, 22, 182, 147, 143, 43, 20, 91, 238, 213, 125,
+       167, 172, 103, 199, 197, 214, 251, 218, 151, 39, 165, 121, 7, 219,
+       123, 250, 230, 103, 148, 255, 116, 233, 204, 20, 175, 61, 159,
+       246, 38, 174, 241, 151, 199, 196, 171, 166, 232, 243, 217, 174,
+       139, 39, 182, 175, 127, 151, 219, 107, 193, 118, 22, 239, 252, 93,
+       66, 86, 230, 89, 76, 191, 165, 126, 200, 23, 239, 229, 180, 61,
+       236, 54, 8, 175, 132, 109, 191, 113, 245, 135, 86, 103, 135, 102,
+       50, 235, 240, 61, 66, 83, 231, 89, 14, 191, 109, 126, 205, 23,
+       239, 165, 148, 45, 236, 4, 42, 234, 128, 45, 151, 49, 245, 251,
+       239, 196, 164, 205, 82, 94, 255, 129, 246, 156, 143, 9, 42, 211,
+       151, 73, 198, 213, 237, 236, 75, 230, 138, 186, 217, 205, 191, 39,
+       252, 250, 206, 78, 171, 208, 137, 221, 153, 234, 171, 239, 149,
+       168, 2, 236, 226, 93, 198, 107, 227, 234, 221, 22, 40, 222, 253,
+       60, 148, 15, 109, 150, 110, 73, 132, 118, 173, 64, 234, 215, 201,
+       66, 224, 99, 5, 184, 11, 107, 107, 62, 20, 248, 235, 207, 211, 90,
+       43, 24, 253, 187, 212, 135, 123, 113, 11, 126, 10, 131, 23, 111,
+       197, 228, 102, 239, 55, 84, 78, 94, 246, 209, 61, 181, 96, 118,
+       118, 23, 236, 241, 184, 53, 206, 103, 46, 226, 128, 45, 248, 245,
+       241, 110, 123, 98, 138, 207, 213, 190, 204, 139, 92, 180, 175, 8,
+       204, 119, 159, 236, 225, 199, 215, 206, 35, 190, 240, 51, 81, 207,
+       191, 95, 31, 254, 215, 255, 61, 245, 68, 139, 119, 95, 216, 65,
+       238, 188, 14, 90, 61, 215, 54, 93, 244, 221, 250, 233, 103, 253,
+       170, 251, 221, 133, 190, 227, 247, 118, 119, 249, 79, 82, 172, 53,
+       144, 78, 101, 49, 0, 250, 195, 47, 139, 48, 208, 250, 237, 5, 231,
+       108, 187, 128, 142, 178, 249, 162, 136, 47, 182, 250, 12, 91, 157,
+       99, 234, 53, 148, 90, 117, 85, 8, 218, 70, 171, 30, 52, 228, 252,
+       177, 159, 225, 253, 139, 81, 191, 179, 253, 170, 202, 63, 14, 112,
+       31, 35, 149, 117, 232, 253, 165, 248, 175, 143, 89, 56, 171, 172,
+       63, 116, 165, 207, 147, 151, 21, 151, 42, 86, 213, 47, 88, 159,
+       254, 222, 204, 209, 159, 189, 89, 105, 193, 102, 91, 255, 244, 89,
+       224, 116, 134, 25, 31, 247, 176, 126, 220, 151, 254, 193, 180, 61,
+       206, 127, 205, 167, 132, 119, 191, 114, 241, 255, 213, 224, 172,
+       205, 117, 215, 255, 195, 214, 156, 15, 75, 236, 127, 167, 217,
+       194, 202, 167, 253, 35, 190, 154, 251, 213, 197, 63, 183, 124,
+       252, 86, 114, 223, 3, 234, 213, 197, 86, 228, 65, 44, 185, 42, 98,
+       27, 44, 20, 232, 242, 207, 226, 94, 43, 88, 189, 187, 196, 132,
+       123, 115, 11, 246, 14, 194, 34, 250, 246, 108, 104, 125, 104, 121,
+       134, 243, 151, 239, 107, 95, 91, 250, 133, 111, 163, 232, 247,
+       199, 194, 212, 186, 250, 137, 37, 224, 111, 3, 254, 255, 242, 212,
+       223, 113, 223, 254, 201, 206, 156, 142, 108, 252, 255, 182, 59,
+       242, 223, 107, 245, 35, 190, 234, 123, 87, 143, 191, 183, 255,
+       255, 127, 111, 221, 232, 158, 221, 85, 223, 252, 155, 206, 188,
+       14, 104, 254, 127, 183, 223, 195, 148, 239, 253, 67, 62, 254, 123,
+       95, 239, 191, 159, 119, 223, 119, 254, 223, 252, 182, 182, 214,
+       223, 188, 91, 206, 180, 239, 127, 108, 159, 129, 191, 227, 149,
+       231, 253, 104, 62, 255, 106, 143, 237, 253, 253, 255, 239, 81,
+       254, 255, 98, 14, 79, 81, 222, 236, 201, 204, 188, 175, 10, 172,
+       247, 150, 232, 192, 199, 231, 204, 35, 44, 248, 51, 89, 133, 191,
+       119, 191, 126, 95, 153, 214, 110, 234, 118, 150, 123, 116, 21, 72,
+       94, 247, 57, 31, 178, 113, 126, 184, 151, 172, 232, 158, 37, 255,
+       247, 239, 186, 193, 63, 130, 56, 91, 183, 63, 203, 70, 244, 127,
+       70, 249, 83, 234, 124, 110, 90, 112, 159, 180, 189, 206, 20, 110,
+       237, 242, 60, 110, 58, 31, 37, 166, 207, 255, 218, 245, 86, 107,
+       250, 241, 246, 137, 255, 212, 109, 132, 242, 163, 143, 139, 117,
+       120, 238, 249, 31, 209, 200, 51, 164, 224, 182, 220, 143, 139,
+       167, 190, 101, 15, 190, 222, 248, 246, 183, 210, 223, 188, 91,
+       222, 53, 247, 255, 127, 159, 137, 95, 251, 149, 227, 249, 108,
+       122, 239, 233, 151, 255, 213, 191, 119, 111, 243, 255, 149, 220,
+       214, 247, 114, 95, 187, 27, 238, 61, 30, 124, 118, 63, 182, 151,
+       215, 181, 43, 113, 71, 56, 222, 187, 223, 109, 191, 142, 228, 175,
+       117, 214, 72, 198, 150, 3, 194, 61, 96, 189, 134, 199, 163, 109,
+       239, 35, 79, 102, 245, 171, 195, 100, 197, 6, 238, 208, 98, 202,
+       3, 39, 245, 45, 88, 189, 126, 251, 165, 207, 127, 247, 80, 0, 238,
+       252, 111, 223, 62, 163, 170, 124, 228, 254, 226, 237, 243, 241,
+       138, 247, 231, 238, 177, 239, 127, 95, 243, 3, 201, 94, 185, 237,
+       157, 236, 199, 237, 17, 242, 6, 172, 202, 62, 193, 234, 139, 126,
+       197, 71, 253, 82, 241, 180, 184, 222, 138, 29, 24, 233, 141, 62,
+       104, 115, 233, 87, 203, 122, 208, 101, 32, 240, 74, 11, 159, 117,
+       244, 122, 221, 23, 251, 154, 178, 157, 240, 183, 253, 131, 229,
+       231, 191, 118, 130, 222, 18, 214, 165, 34, 32, 56, 88, 169, 159,
+       147, 247, 77, 174, 235, 91, 54, 85, 237, 165, 164, 197, 135, 192,
+       210, 99, 122, 135, 166, 229, 45, 87, 56, 249, 56, 234, 29, 221,
+       83, 237, 207, 13, 172, 9, 166, 157, 98, 16, 136, 186, 135, 80, 90,
+       43, 48, 181, 251, 213, 4, 123, 80, 10, 198, 106, 175, 191, 196,
+       87, 241, 63, 238, 251, 31, 234, 124, 245, 104, 232, 159, 36, 29,
+       106, 54, 62, 245, 240, 63, 255, 46, 94, 197, 182, 207, 254, 216,
+       149, 78, 74, 90, 179, 108, 235, 251, 196, 109, 164, 242, 167, 175,
+       138, 119, 72, 234, 237, 111, 211, 0, 179, 193, 224, 212, 181, 170,
+       129, 141, 153, 109, 130, 58, 33, 115, 235, 87, 207, 234, 120, 77,
+       41, 251, 66, 75, 25, 60, 148, 122, 137, 23, 235, 141, 178, 93,
+       255, 183, 221, 130, 192, 127, 143, 120, 134, 141, 223, 120, 187,
+       183, 252, 183, 244, 137, 78, 189, 183, 253, 127, 235, 231, 111,
+       115, 159, 230, 247, 37, 248, 234, 247, 215, 174, 187, 191, 255,
+       173, 243, 142, 223, 236, 183, 181, 254, 223, 191, 219, 223, 28,
+       183, 255, 109, 255, 137, 63, 227, 149, 147, 247, 108, 62, 255,
+       234, 151, 255, 213, 175, 252, 220, 91, 238, 223, 236, 244, 181,
+       242, 223, 190, 219, 222, 28, 191, 249, 111, 255, 145, 155, 243,
+       181, 243, 251, 76, 62, 255, 235, 223, 255, 253, 159, 117, 223,
+       123, 242, 17, 82, 206, 77, 96, 210, 73, 201, 136, 249, 79, 98,
+       216, 37, 82, 232, 181, 134, 99, 13, 35, 210, 200, 19, 176, 128,
+       27, 89, 107, 124, 23, 19, 76, 103, 85, 22, 214, 238, 97, 244, 192,
+       242, 66, 113, 24, 182, 33, 120, 228, 54, 239, 237, 189, 53, 238,
+       52, 42, 234, 128, 109, 168, 121, 132, 3, 64, 119, 93, 34, 210,
+       169, 116, 124, 64, 82, 230, 217, 30, 180, 229, 118, 37, 62, 172,
+       197, 157, 37, 221, 4, 58, 186, 192, 15, 134, 97, 253, 142, 223,
+       101, 155, 243, 35, 175, 255, 29, 94, 153, 247, 72, 44, 189, 133,
+       255, 83, 151, 231, 241, 13, 45, 255, 60, 86, 254, 198, 159, 87,
+       181, 245, 205, 223, 58, 210, 229, 124, 119, 246, 121, 78, 189,
+       126, 26, 54, 175, 253, 237, 210, 158, 174, 253, 47, 56, 234, 255,
+       95, 246, 195, 138, 255, 237, 119, 47, 223, 220, 215, 181, 254,
+       207, 188, 219, 206, 61, 68, 253, 252, 63, 149, 151, 99, 181, 111,
+       241, 104, 62, 253, 43, 223, 253, 242, 223, 119, 203, 213, 199,
+       241, 173, 163, 141, 77, 213, 136, 235, 248, 131, 8, 214, 220, 89,
+       59, 129, 69, 121, 87, 203, 65, 251, 176, 201, 216, 77, 126, 128,
+       123, 147, 102, 188, 87, 99, 236, 23, 66, 94, 120, 69, 132, 254,
+       39, 107, 75, 53, 84, 122, 229, 21, 234, 232, 183, 1, 206, 242,
+       233, 135, 131, 103, 187, 116, 2, 35, 240, 244, 241, 109, 173, 248,
+       28, 143, 57, 49, 249, 140, 31, 92, 138, 206, 17, 247, 213, 151,
+       108, 95, 212, 14, 88, 219, 254, 159, 141, 217, 149, 191, 159, 40,
+       83, 229, 124, 255, 247, 121, 78, 253, 253, 26, 60, 159, 189, 239,
+       218, 151, 78, 253, 62, 124, 226, 246, 125, 54, 163, 207, 255, 239,
+       247, 173, 223, 232, 179, 245, 124, 255, 183, 25, 95, 188, 191,
+       223, 60, 171, 174, 111, 210, 151, 151, 245, 46, 124, 234, 255, 87,
+       190, 209, 239, 255, 252, 115, 237, 223, 232, 178, 245, 244, 191,
+       182, 152, 95, 188, 183, 249, 127, 235, 231, 127, 211, 151, 243,
+       255, 36, 248, 235, 255, 215, 238, 255, 191, 255, 205, 123, 221,
+       223, 248, 210, 215, 252, 255, 182, 249, 222, 61, 54, 124, 127,
+       203, 181, 63, 243, 148, 235, 243, 100, 56, 239, 251, 215, 239,
+       227, 175, 119, 207, 115, 6, 219, 237, 215, 180, 198, 111, 188, 27,
+       221, 23, 231, 121, 111, 223, 139, 55, 235, 181, 210, 255, 248, 62,
+       229, 106, 159, 245, 197, 173, 179, 220, 91, 254, 4, 106, 206, 85,
+       114, 94, 81, 81, 142, 255, 18, 107, 121, 63, 113, 120, 188, 149,
+       170, 188, 167, 245, 202, 115, 237, 160, 145, 167, 255, 124, 38,
+       155, 90, 70, 165, 6, 158, 60, 113, 172, 66, 90, 199, 237, 136, 50,
+       192, 102, 165, 191, 239, 197, 157, 21, 206, 244, 105, 170, 128,
+       46, 166, 57, 93, 78, 174, 172, 191, 186, 177, 150, 171, 214, 191,
+       28, 255, 237, 232, 219, 207, 71, 107, 238, 149, 182, 104, 239,
+       183, 238, 87, 255, 251, 182, 237, 157, 69, 195, 165, 165, 255,
+       137, 228, 77, 175, 151, 147, 1, 16, 252, 247, 72, 111, 193, 127,
+       121, 152, 59, 72, 251, 247, 141, 254, 223, 110, 146, 96, 160, 42,
+       126, 222, 237, 214, 244, 194, 239, 180, 27, 223, 55, 247, 121,
+       111, 143, 219, 119, 227, 165, 242, 243, 248, 58, 239, 104, 191,
+       255, 196, 173, 51, 220, 115, 203, 251, 230, 211, 164, 22, 252,
+       149, 127, 249, 22, 118, 8, 41, 212, 207, 103, 70, 255, 216, 243,
+       220, 139, 226, 46, 123, 246, 198, 143, 148, 249, 29, 16, 134, 21,
+       169, 20, 47, 96, 122, 37, 57, 250, 98, 103, 2, 168, 80, 248, 132,
+       46, 160, 8, 153, 1, 221, 148, 166, 242, 198, 57, 8, 32, 15, 254,
+       39, 106, 66, 213, 118, 254, 81, 193, 142, 245, 75, 80, 25, 53, 51,
+       120, 164, 87, 179, 252, 167, 132, 206, 115, 41, 163, 133, 101,
+       107, 118, 131, 39, 32, 212, 179, 117, 45, 232, 8, 75, 49, 177, 30,
+       206, 42, 94, 139, 235, 137, 30, 149, 23, 114, 91, 212, 140, 154,
+       218, 116, 157, 8, 73, 132, 175, 222, 41, 211, 245, 252, 255, 246,
+       121, 110, 189, 127, 184, 61, 159, 183, 237, 242, 151, 254, 247,
+       54, 120, 234, 119, 93, 166, 227, 219, 223, 239, 255, 119, 41, 130,
+       164, 201, 27, 70, 73, 3, 168, 184, 43, 10, 168, 101, 158, 216,
+       237, 238, 112, 12, 35, 192, 136, 186, 84, 5, 191, 235, 126, 90,
+       14, 60, 103, 106, 224, 228, 67, 237, 113, 192, 168, 191, 98, 17,
+       217, 249, 11, 120, 188, 23, 171, 72, 167, 0, 204, 115, 137, 235,
+       237, 71, 170, 246, 131, 141, 0, 199, 205, 197, 118, 111, 152, 52,
+       66, 87, 198, 89, 103, 185, 239, 120, 204, 51, 238, 177, 212, 189,
+       202, 68, 43, 234, 132, 175, 247, 112, 240, 86, 94, 198, 172, 2,
+       22, 78, 249, 149, 146, 210, 199, 73, 238, 181, 199, 127, 245, 189,
+       231, 205, 215, 141, 200, 178, 99, 207, 132, 63, 182, 56, 20, 198,
+       12, 191, 215, 170, 232, 61, 3, 191, 123, 23, 178, 204, 55, 244,
+       111, 163, 55, 127, 25, 49, 220, 163, 226, 133, 50, 218, 195, 132,
+       225, 133, 100, 70, 188, 172, 154, 171, 240, 21, 142, 190, 95, 140,
+       181, 172, 247, 66, 75, 163, 83, 251, 17, 54, 73, 187, 113, 223,
+       23, 127, 251, 144, 85, 149, 123, 220, 109, 164, 231, 173, 108, 71,
+       136, 235, 186, 155, 8, 215, 120, 89, 42, 129, 68, 125, 123, 73,
+       101, 219, 162, 169, 251, 109, 180, 200, 123, 85, 32, 68, 0, 156,
+       211, 173, 111, 196, 152, 202, 187, 135, 88, 214, 113, 89, 107,
+       201, 68, 120, 26, 27, 101, 219, 192, 205, 154, 223, 125, 128, 121,
+       217, 34, 199, 165, 149, 255, 157, 36, 77, 175, 91, 23, 99, 16,
+       238, 114, 72, 255, 209, 78, 56, 24, 123, 72, 251, 227, 173, 254,
+       223, 78, 130, 112, 240, 46, 164, 239, 204, 191, 188, 139, 254,
+       173, 158, 183, 116, 183, 225, 233, 94, 3, 223, 111, 33, 87, 118,
+       124, 223, 127, 108, 55, 239, 101, 221, 249, 216, 144, 202, 138,
+       222, 188, 124, 128, 248, 7, 191, 21, 176, 151, 172, 170, 118, 75,
+       235, 163, 111, 157, 34, 75, 130, 209, 220, 51, 250, 169, 140, 8,
+       105, 137, 35, 32, 244, 237, 125, 139, 248, 11, 207, 145, 112, 134,
+       173, 155, 116, 136, 206, 153, 55, 149, 131, 248, 211, 209, 142,
+       248, 155, 146, 31, 140, 89, 132, 18, 98, 126, 236, 44, 131, 216,
+       22, 239, 57, 247, 227, 13, 159, 180, 72, 166, 189, 61, 205, 142,
+       185, 133, 213, 146, 248, 154, 131, 21, 134, 97, 7, 207, 223, 40,
+       178, 247, 124, 63, 183, 177, 78, 157, 255, 185, 126, 187, 229,
+       111, 211, 159, 231, 245, 46, 124, 234, 255, 95, 190, 195, 191,
+       255, 189, 119, 167, 222, 221, 151, 228, 22, 239, 182, 25, 255,
+       118, 247, 88, 46, 206, 203, 239, 199, 182, 150, 245, 252, 121,
+       226, 46, 30, 246, 198, 141, 253, 244, 221, 66, 222, 189, 179, 166,
+       98, 181, 182, 63, 127, 90, 247, 196, 46, 206, 75, 167, 87, 167,
+       145, 243, 252, 11, 225, 12, 18, 254, 198, 141, 216, 181, 95, 55,
+       165, 110, 66, 198, 118, 255, 117, 97, 230, 191, 139, 89, 60, 158,
+       51, 127, 151, 87, 175, 252, 179, 52, 204, 127, 15, 215, 197, 101,
+       231, 255, 246, 222, 219, 94, 236, 106, 210, 63, 248, 160, 164,
+       150, 162, 125, 199, 163, 82, 102, 245, 237, 226, 64, 143, 134,
+       239, 250, 227, 239, 133, 53, 176, 47, 19, 66, 182, 189, 211, 168,
+       228, 61, 135, 187, 95, 6, 49, 172, 247, 204, 127, 133, 87, 125,
+       16, 50, 77, 171, 225, 205, 50, 222, 223, 128, 80, 133, 127, 173,
+       95, 187, 146, 228, 126, 183, 247, 89, 79, 126, 254, 30, 52, 175,
+       173, 255, 210, 150, 14, 189, 250, 61, 226, 254, 95, 118, 194, 206,
+       253, 173, 125, 126, 105, 194, 96, 149, 27, 86, 65, 67, 160, 169,
+       11, 10, 9, 87, 148, 120, 236, 196, 112, 76, 59, 208, 136, 186,
+       221, 133, 63, 227, 174, 122, 14, 26, 65, 104, 225, 134, 109, 189,
+       254, 12, 42, 28, 131, 29, 45, 93, 42, 46, 145, 31, 239, 64, 48, 5,
+       208, 247, 77, 254, 181, 39, 250, 149, 170, 253, 93, 253, 229, 172,
+       62, 198, 188, 208, 186, 186, 104, 211, 120, 17, 43, 153, 212, 124,
+       99, 236, 229, 217, 10, 241, 235, 101, 20, 101, 123, 80, 3, 221,
+       80, 148, 229, 172, 43, 197, 136, 207, 186, 179, 108, 211, 112,
+       201, 11, 201, 212, 108, 98, 233, 101, 219, 160, 128, 211, 229, 22,
+       200, 123, 80, 35, 165, 205, 204, 183, 210, 139, 190, 173, 22, 179,
+       117, 151, 241, 107, 26, 11, 95, 235, 35, 247, 118, 252, 95, 63,
+       236, 7, 255, 197, 253, 123, 152, 146, 173, 239, 196, 159, 189,
+       155, 206, 191, 94, 179, 74, 214, 237, 232, 217, 129, 31, 111, 160,
+       45, 244, 252, 207, 255, 44, 55, 205, 77, 206, 252, 216, 136, 66,
+       130, 222, 244, 116, 130, 233, 107, 255, 149, 178, 135, 173, 171,
+       54, 64, 254, 165, 47, 161, 136, 235, 1, 221, 220, 190, 251, 197,
+       13, 168, 105, 0, 43, 96, 246, 229, 125, 139, 216, 24, 207, 161,
+       114, 195, 141, 137, 84, 160, 222, 157, 183, 189, 142, 244, 215,
+       208, 134, 216, 139, 174, 111, 140, 89, 141, 175, 31, 123, 131,
+       228, 126, 191, 247, 88, 111, 126, 252, 156, 52, 183, 253, 223,
+       222, 150, 47, 245, 190, 117, 226, 118, 95, 126, 130, 158, 221,
+       173, 253, 141, 222, 191, 147, 162, 102, 53, 182, 28, 127, 86, 247,
+       212, 54, 162, 107, 103, 87, 182, 19, 241, 220, 105, 98, 236, 39,
+       126, 196, 140, 217, 165, 121, 255, 118, 228, 0, 125, 27, 202, 216,
+       83, 230, 181, 159, 75, 8, 215, 191, 93, 196, 212, 255, 237, 103,
+       253, 154, 50, 89, 133, 191, 255, 189, 90, 212, 120, 33, 194, 229,
+       85, 26, 96, 53, 97, 160, 255, 75, 11, 9, 80, 150, 56, 172, 196,
+       124, 92, 186, 196, 136, 251, 237, 132, 1, 111, 174, 218, 2, 215,
+       118, 214, 52, 146, 34, 190, 216, 184, 146, 146, 231, 77, 106, 205,
+       219, 55, 213, 236, 243, 165, 199, 143, 104, 184, 226, 111, 142,
+       173, 247, 43, 21, 129, 207, 117, 89, 116, 159, 231, 183, 255, 16,
+       98, 68, 171, 65, 149, 181, 34, 98, 74, 76, 226, 232, 52, 125, 36,
+       218, 1, 0, 82, 156, 67, 44, 212, 206, 255, 246, 178, 98, 39, 190,
+       178, 150, 175, 178, 117, 231, 169, 81, 115, 242, 44, 226, 112,
+       101, 42, 47, 249, 166, 119, 77, 160, 243, 164, 43, 220, 237, 158,
+       158, 159, 242, 71, 174, 190, 182, 78, 179, 108, 226, 107, 195, 51,
+       239, 236, 242, 122, 76, 171, 127, 232, 167, 255, 77, 180, 113,
+       189, 106, 25, 1, 249, 237, 86, 36, 107, 28, 100, 1, 78, 2, 29, 23,
+       249, 96, 118, 155, 23, 232, 139, 18, 117, 64, 247, 237, 170, 140,
+       180, 211, 32, 32, 115, 197, 233, 165, 198, 103, 207, 127, 1, 99,
+       91, 195, 85, 47, 56, 96, 127, 149, 55, 173, 217, 144, 61, 192,
+       245, 45, 239, 132, 165, 250, 145, 112, 237, 78, 7, 124, 44, 154,
+       204, 34, 221, 154, 242, 208, 227, 232, 181, 235, 192, 100, 124,
+       111, 237, 229, 102, 141, 130, 251, 99, 152, 84, 185, 89, 36, 173,
+       223, 196, 159, 213, 62, 238, 191, 18, 178, 8, 215, 233, 96, 89,
+       133, 93, 106, 130, 110, 245, 224, 94, 191, 46, 71, 207, 108, 191,
+       255, 216, 156, 35, 128, 212, 181, 85, 15, 232, 72, 91, 181, 176,
+       78, 238, 234, 86, 136, 250, 169, 55, 189, 5, 242, 86, 201, 156,
+       158, 207, 36, 189, 40, 105, 128, 191, 102, 96, 136, 95, 19, 218,
+       216, 211, 254, 149, 191, 74, 204, 255, 143, 95, 192, 215, 247,
+       174, 103, 238, 222, 58, 91, 133, 255, 247, 189, 126, 215, 89, 147,
+       233, 33, 182, 58, 122, 189, 111, 101, 95, 231, 223, 44, 218, 96,
+       55, 70, 61, 45, 149, 152, 189, 84, 110, 109, 109, 196, 239, 230,
+       221, 85, 220, 205, 190, 150, 131, 240, 23, 167, 178, 159, 206, 51,
+       110, 246, 235, 239, 113, 246, 164, 82, 122, 220, 171, 239, 251,
+       39, 127, 71, 130, 117, 172, 107, 45, 253, 141, 159, 157, 215, 135,
+       189, 158, 245, 77, 7, 248, 244, 78, 131, 93, 110, 160, 247, 247,
+       120, 251, 189, 45, 39, 207, 109, 217, 127, 221, 240, 64, 130, 222,
+       180, 116, 66, 233, 105, 255, 149, 178, 135, 237, 234, 126, 65,
+       251, 129, 47, 161, 10, 107, 6, 221, 220, 179, 235, 197, 13, 168,
+       109, 128, 62, 226, 104, 138, 237, 113, 218, 200, 203, 116, 157,
+       175, 74, 204, 255, 142, 219, 201, 215, 247, 142, 35, 238, 241, 26,
+       89, 137, 255, 247, 95, 126, 198, 92, 250, 143, 158, 143, 214, 87,
+       188, 158, 254, 214, 39, 126, 246, 235, 197, 117, 239, 164, 194,
+       237, 200, 187, 253, 233, 39, 239, 205, 170, 55, 45, 123, 126, 150,
+       238, 154, 79, 112, 184, 234, 139, 95, 157, 187, 72, 238, 254, 174,
+       255, 147, 247, 163, 182, 7, 174, 215, 26, 87, 219, 255, 151, 111,
+       61, 215, 142, 182, 58, 19, 115, 253, 177, 210, 223, 93, 85, 53,
+       140, 220, 254, 172, 143, 27, 215, 21, 182, 60, 62, 183, 79, 93,
+       56, 239, 211, 13, 143, 215, 217, 157, 222, 85, 19, 222, 113, 55,
+       120, 237, 126, 54, 62, 51, 2, 246, 35, 38, 132, 8, 53, 248, 49,
+       78, 127, 239, 52, 67, 235, 68, 111, 91, 201, 188, 180, 83, 169,
+       237, 181, 135, 254, 251, 22, 56, 188, 245, 194, 47, 135, 119, 122,
+       25, 179, 109, 186, 115, 109, 30, 127, 250, 202, 92, 129, 251, 45,
+       141, 173, 151, 209, 253, 191, 239, 18, 247, 13, 145, 252, 116, 74,
+       43, 221, 122, 178, 30, 55, 216, 127, 183, 111, 79, 95, 69, 210,
+       127, 133, 252, 187, 32, 96, 237, 55, 150, 248, 24, 79, 160, 125,
+       194, 121, 221, 156, 228, 126, 189, 23, 173, 142, 180, 213, 223,
+       71, 253, 163, 164, 127, 174, 88, 145, 207, 6, 164, 81, 141, 63,
+       236, 19, 127, 187, 150, 84, 200, 33, 221, 175, 237, 70, 250, 28,
+       177, 244, 241, 194, 15, 90, 215, 86, 202, 108, 217, 52, 223, 220,
+       175, 22, 179, 86, 55, 188, 178, 214, 134, 183, 120, 247, 171, 229,
+       117, 242, 187, 102, 245, 77, 58, 175, 123, 127, 71, 71, 170, 247,
+       173, 127, 216, 254, 142, 156, 27, 119, 77, 187, 30, 254, 86, 38,
+       124, 230, 227, 221, 51, 239, 164, 169, 233, 221, 187, 223, 249,
+       39, 255, 157, 42, 100, 45, 123, 38, 176, 106, 154, 79, 245, 153,
+       200, 143, 93, 157, 191, 44, 222, 110, 8, 239, 155, 151, 147, 158,
+       43, 58, 241, 91, 16, 154, 251, 149, 15, 180, 215, 166, 180, 127,
+       218, 95, 245, 187, 224, 157, 95, 181, 55, 40, 222, 62, 47, 239,
+       179, 215, 211, 182, 39, 58, 247, 83, 88, 154, 251, 151, 13, 165,
+       215, 139, 182, 40, 179, 181, 253, 185, 19, 95, 109, 21, 183, 157,
+       157, 210, 164, 135, 59, 159, 21, 183, 156, 118, 151, 79, 93, 184,
+       227, 158, 140, 157, 243, 138, 148, 40, 187, 61, 253, 25, 55, 159,
+       111, 95, 181, 173, 157, 186, 228, 199, 27, 159, 5, 247, 141, 113,
+       151, 195, 221, 184, 243, 30, 12, 157, 127, 249, 151, 173, 37, 180,
+       94, 69, 191, 80, 254, 150, 252, 211, 36, 146, 167, 93, 196, 252,
+       125, 249, 252, 229, 14, 238, 235, 229, 212, 239, 252, 222, 121,
+       237, 254, 237, 148, 77, 93, 77, 186, 83, 254, 148, 142, 235, 101,
+       211, 182, 73, 196, 253, 174, 237, 102, 255, 170, 255, 79, 229,
+       189, 47, 252, 94, 125, 4, 216, 184, 219, 214, 173, 123, 222, 30,
+       55, 68, 22, 149, 131, 105, 72, 117, 24, 3, 88, 34, 20, 26, 115,
+       79, 134, 18, 100, 144, 153, 21, 162, 217, 201, 23, 188, 11, 135,
+       15, 166, 157, 18, 130, 0, 191, 22, 33, 231, 66, 243, 120, 111,
+       104, 141, 55, 61, 177, 226, 94, 16, 48, 24, 37, 44, 45, 159, 173,
+       151, 240, 222, 183, 185, 18, 223, 61, 247, 248, 116, 203, 161,
+       221, 126, 182, 38, 245, 248, 106, 191, 110, 71, 231, 215, 219,
+       254, 156, 243, 51, 128, 209, 229, 87, 15, 234, 104, 91, 169, 248,
+       70, 235, 106, 28, 132, 250, 141, 23, 233, 139, 178, 93, 221, 157,
+       222, 139, 164, 125, 42, 89, 132, 218, 28, 119, 218, 79, 213, 184,
+       96, 157, 95, 181, 55, 44, 222, 62, 111, 239, 179, 223, 131, 183,
+       111, 58, 247, 83, 90, 218, 203, 23, 5, 37, 223, 219, 159, 58, 110,
+       59, 244, 29, 55, 189, 78, 222, 181, 189, 191, 162, 244, 198, 51,
+       157, 140, 239, 141, 115, 223, 227, 255, 58, 155, 26, 196, 173,
+       127, 43, 237, 106, 137, 208, 129, 190, 231, 30, 49, 108, 131, 49,
+       132, 54, 32, 75, 203, 147, 221, 86, 186, 68, 117, 109, 13, 30, 97,
+       85, 156, 187, 232, 157, 223, 173, 191, 179, 86, 151, 189, 150,
+       222, 148, 119, 248, 117, 171, 229, 125, 114, 159, 230, 245, 109,
+       122, 191, 107, 71, 103, 215, 186, 252, 172, 127, 44, 183, 140,
+       159, 220, 223, 135, 185, 154, 253, 125, 118, 252, 228, 202, 7, 89,
+       110, 164, 61, 177, 248, 251, 63, 108, 39, 237, 229, 201, 106, 220,
+       241, 86, 194, 90, 164, 54, 10, 235, 232, 105, 132, 178, 199, 79,
+       107, 54, 65, 250, 229, 15, 231, 200, 163, 5, 205, 248, 252, 239,
+       212, 109, 170, 125, 17, 10, 176, 180, 250, 239, 165, 184, 86, 159,
+       27, 145, 127, 156, 158, 108, 139, 239, 59, 255, 145, 150, 79, 154,
+       241, 31, 27, 250, 251, 156, 77, 169, 211, 139, 151, 61, 233, 61,
+       215, 89, 63, 143, 125, 31, 183, 189, 31, 178, 228, 199, 23, 191,
+       141, 247, 12, 115, 215, 239, 253, 186, 215, 62, 132, 157, 127,
+       253, 247, 236, 101, 173, 87, 95, 191, 81, 254, 148, 255, 91, 109,
+       219, 47, 93, 214, 253, 111, 253, 102, 253, 130, 255, 219, 229,
+       181, 239, 253, 252, 113, 191, 78, 100, 26, 47, 115, 151, 204, 215,
+       94, 181, 183, 107, 76, 215, 239, 239, 193, 238, 227, 174, 103,
+       111, 179, 18, 211, 215, 191, 119, 253, 124, 95, 207, 190, 165,
+       155, 249, 189, 172, 159, 223, 83, 132, 92, 172, 230, 212, 239,
+       197, 98, 250, 28, 179, 76, 255, 243, 47, 94, 223, 122, 154, 213,
+       145, 124, 220, 172, 134, 190, 159, 227, 70, 174, 23, 183, 194, 19,
+       107, 227, 107, 215, 113, 239, 233, 130, 58, 223, 139, 191, 250,
+       230, 213, 21, 162, 241, 172, 10, 212, 206, 133, 190, 153, 226, 70,
+       175, 19, 159, 137, 23, 98, 227, 42, 215, 241, 230, 172, 162, 126,
+       79, 219, 191, 185, 230, 215, 31, 176, 117, 164, 94, 38, 126, 168,
+       187, 126, 227, 147, 218, 30, 167, 76, 151, 148, 221, 99, 8, 95,
+       120, 147, 83, 130, 20, 90, 178, 79, 7, 139, 111, 148, 251, 20,
+       242, 253, 88, 87, 190, 41, 64, 86, 164, 181, 194, 194, 4, 127, 19,
+       33, 219, 198, 228, 232, 74, 109, 79, 27, 171, 242, 250, 69, 26,
+       42, 179, 104, 8, 205, 222, 170, 86, 243, 118, 55, 190, 179, 222,
+       158, 181, 120, 117, 171, 229, 117, 114, 159, 46, 245, 71, 56, 175,
+       123, 127, 103, 199, 170, 245, 188, 119, 221, 254, 143, 158, 159,
+       86, 7, 186, 22, 254, 150, 38, 124, 246, 235, 249, 49, 239, 164,
+       226, 237, 197, 187, 255, 249, 167, 255, 205, 171, 116, 45, 123,
+       75, 26, 250, 252, 103, 60, 248, 86, 57, 75, 84, 255, 140, 191,
+       246, 60, 239, 185, 183, 129, 132, 94, 226, 194, 215, 127, 250,
+       139, 134, 236, 23, 255, 189, 55, 108, 101, 173, 127, 95, 189, 65,
+       254, 188, 189, 219, 125, 219, 175, 31, 212, 221, 110, 253, 99,
+       125, 138, 235, 217, 229, 181, 127, 253, 222, 115, 158, 241, 236,
+       88, 155, 209, 159, 201, 215, 93, 181, 183, 73, 220, 255, 175, 63,
+       219, 213, 243, 246, 101, 62, 209, 123, 89, 143, 255, 247, 53, 239,
+       247, 173, 159, 173, 31, 243, 95, 151, 189, 18, 223, 29, 183, 248,
+       117, 139, 37, 93, 114, 182, 46, 245, 200, 126, 191, 111, 71, 103,
+       247, 186, 254, 156, 247, 219, 215, 117, 237, 53, 214, 125, 191,
+       239, 89, 254, 245, 255, 63, 158, 246, 230, 151, 189, 173, 255, 9,
+       51, 223, 231, 255, 230, 215, 30, 132, 228, 127, 222, 22, 230, 190,
+       175, 112, 144, 202, 219, 95, 151, 183, 74, 236, 127, 207, 235,
+       227, 237, 131, 190, 103, 174, 227, 146, 115, 219, 255, 183, 109,
+       189, 87, 223, 166, 230, 152, 143, 48, 28, 207, 251, 119, 151, 187,
+       74, 232, 222, 223, 227, 199, 253, 149, 190, 71, 175, 195, 154,
+       115, 223, 255, 135, 68, 191, 71, 28, 174, 132, 191, 157, 163, 70,
+       175, 23, 183, 194, 19, 235, 226, 74, 71, 89, 239, 168, 163, 126,
+       206, 219, 191, 169, 230, 223, 55, 178, 121, 156, 10, 135, 105,
+       137, 155, 172, 197, 157, 204, 30, 90, 80, 162, 180, 214, 229, 107,
+       207, 89, 55, 211, 71, 70, 234, 240, 140, 144, 255, 174, 156, 25,
+       161, 156, 54, 115, 91, 204, 26, 7, 23, 248, 2, 172, 152, 47, 114,
+       251, 37, 0, 126, 221, 101, 226, 76, 3, 138, 29, 251, 140, 173,
+       190, 53, 59, 34, 195, 221, 222, 167, 22, 179, 86, 55, 190, 178,
+       222, 150, 119, 120, 119, 171, 245, 117, 242, 189, 230, 253, 71,
+       190, 175, 251, 71, 119, 207, 138, 247, 172, 127, 220, 255, 142,
+       158, 155, 87, 13, 191, 30, 254, 215, 14, 108, 226, 107, 193, 49,
+       239, 164, 163, 105, 221, 187, 125, 249, 163, 255, 213, 42, 116,
+       45, 121, 19, 46, 250, 253, 100, 35, 252, 83, 121, 142, 252, 187,
+       141, 191, 213, 120, 255, 185, 23, 141, 140, 182, 196, 194, 214,
+       223, 250, 171, 135, 244, 99, 135, 24, 223, 109, 191, 54, 209, 190,
+       230, 68, 4, 216, 103, 161, 24, 180, 192, 234, 123, 147, 195, 230,
+       169, 7, 189, 224, 225, 174, 129, 117, 24, 181, 218, 34, 223, 96,
+       94, 124, 129, 174, 244, 223, 12, 120, 231, 168, 200, 182, 4, 78,
+       107, 3, 195, 198, 40, 78, 253, 38, 60, 142, 139, 93, 159, 217,
+       141, 54, 109, 204, 204, 206, 67, 207, 232, 6, 246, 156, 170, 83,
+       108, 255, 34, 89, 212, 95, 250, 77, 67, 111, 58, 120, 6, 173, 189,
+       61, 251, 116, 144, 223, 101, 112, 227, 191, 62, 222, 15, 91, 163,
+       47, 147, 159, 141, 85, 40, 55, 223, 177, 255, 254, 52, 253, 242,
+       231, 221, 143, 37, 231, 223, 193, 96, 45, 190, 172, 23, 241, 254,
+       55, 248, 50, 254, 61, 253, 248, 116, 203, 181, 61, 242, 182, 46,
+       245, 120, 120, 191, 127, 71, 101, 231, 203, 255, 142, 247, 131,
+       169, 86, 213, 109, 137, 233, 103, 141, 17, 242, 22, 172, 138, 116,
+       199, 238, 43, 127, 141, 35, 221, 210, 213, 132, 152, 154, 200, 28,
+       136, 105, 140, 31, 133, 119, 233, 180, 43, 124, 187, 77, 81, 250,
+       195, 223, 61, 188, 229, 255, 151, 31, 173, 189, 185, 85, 221, 191,
+       254, 222, 214, 255, 140, 224, 101, 110, 82, 241, 250, 111, 117,
+       219, 220, 27, 95, 245, 191, 76, 223, 255, 124, 223, 217, 183, 215,
+       159, 71, 186, 241, 83, 251, 248, 255, 215, 157, 36, 215, 126, 120,
+       243, 250, 239, 116, 155, 220, 27, 95, 245, 63, 12, 221, 254, 124,
+       239, 219, 151, 215, 151, 99, 186, 227, 91, 253, 186, 235, 215, 95,
+       167, 215, 158, 176, 127, 250, 191, 213, 184, 213, 159, 93, 149,
+       55, 108, 223, 62, 43, 175, 147, 223, 147, 190, 101, 58, 245, 219,
+       219, 222, 211, 199, 7, 165, 247, 60, 99, 74, 76, 91, 151, 151,
+       120, 132, 140, 252, 42, 115, 213, 163, 52, 124, 252, 215, 227, 72,
+       163, 40, 158, 113, 237, 173, 158, 119, 62, 54, 225, 165, 209, 173,
+       139, 93, 5, 202, 157, 87, 81, 133, 92, 242, 104, 90, 99, 217, 136,
+       90, 47, 239, 102, 255, 147, 101, 56, 129, 60, 88, 154, 216, 148,
+       173, 159, 172, 31, 241, 222, 183, 189, 22, 222, 157, 183, 248,
+       116, 139, 45, 221, 114, 150, 46, 245, 120, 111, 191, 111, 71, 119,
+       215, 210, 254, 140, 247, 221, 222, 175, 150, 145, 86, 23, 188,
+       178, 222, 148, 39, 248, 246, 235, 229, 117, 242, 172, 230, 229,
+       77, 58, 255, 251, 71, 255, 223, 170, 116, 45, 127, 36, 183, 204,
+       158, 220, 87, 199, 188, 150, 255, 125, 22, 240, 228, 74, 1, 89,
+       110, 36, 225, 187, 232, 251, 63, 105, 7, 253, 205, 205, 42, 220,
+       251, 82, 110, 122, 253, 108, 233, 232, 75, 127, 134, 242, 159,
+       175, 139, 119, 72, 251, 173, 63, 131, 202, 183, 197, 210, 214,
+       190, 187, 169, 21, 216, 109, 138, 22, 36, 251, 233, 244, 107, 107,
+       74, 125, 167, 250, 18, 159, 43, 53, 88, 251, 187, 95, 185, 170,
+       179, 5, 222, 181, 158, 155, 133, 181, 209, 101, 162, 183, 114,
+       124, 225, 46, 31, 218, 216, 203, 252, 181, 171, 223, 95, 223, 63,
+       223, 213, 221, 255, 238, 103, 108, 216, 219, 217, 175, 255, 183,
+       191, 87, 119, 222, 52, 166, 182, 143, 240, 24, 67, 187, 223, 145,
+       187, 108, 254, 110, 91, 225, 247, 253, 145, 62, 71, 186, 194, 219,
+       115, 222, 251, 134, 68, 183, 86, 180, 172, 132, 191, 141, 171,
+       134, 175, 222, 179, 66, 26, 231, 232, 92, 203, 153, 110, 104, 19,
+       62, 236, 219, 191, 173, 231, 221, 125, 209, 120, 217, 138, 180,
+       254, 132, 183, 157, 255, 134, 175, 158, 191, 178, 87, 230, 224,
+       75, 143, 249, 110, 224, 19, 62, 124, 219, 191, 168, 198, 95, 55,
+       217, 125, 157, 158, 92, 254, 159, 182, 30, 66, 143, 188, 26, 238,
+       215, 70, 117, 230, 19, 65, 51, 228, 44, 239, 97, 205, 191, 127,
+       185, 167, 255, 149, 189, 112, 37, 120, 134, 121, 152, 186, 202, 5,
+       156, 220, 130, 184, 16, 175, 149, 223, 99, 11, 174, 121, 51, 211,
+       70, 67, 154, 240, 114, 1, 239, 175, 61, 115, 43, 147, 19, 205, 40,
+       189, 30, 193, 159, 230, 140, 76, 88, 131, 181, 44, 50, 64, 202,
+       107, 31, 197, 198, 136, 102, 189, 224, 37, 190, 137, 53, 24, 53,
+       219, 35, 207, 98, 222, 125, 145, 158, 240, 221, 64, 252, 194, 104,
+       204, 183, 228, 222, 106, 147, 111, 198, 171, 46, 189, 34, 60, 130,
+       155, 87, 191, 120, 237, 210, 197, 116, 229, 23, 168, 248, 111,
+       105, 17, 169, 130, 47, 73, 28, 229, 122, 145, 19, 233, 14, 118,
+       84, 223, 187, 216, 202, 67, 103, 143, 225, 14, 173, 159, 173, 150,
+       212, 87, 23, 253, 82, 223, 60, 55, 241, 117, 171, 33, 93, 114,
+       167, 46, 255, 98, 126, 63, 111, 71, 231, 172, 251, 126, 148, 251,
+       154, 181, 55, 242, 189, 231, 185, 119, 157, 89, 179, 119, 188,
+       159, 36, 171, 231, 51, 223, 17, 179, 237, 18, 212, 153, 219, 122,
+       210, 12, 12, 165, 251, 218, 156, 181, 190, 47, 205, 156, 167, 159,
+       123, 146, 91, 188, 191, 36, 75, 231, 115, 255, 129, 225, 77, 18,
+       243, 147, 243, 218, 154, 16, 92, 133, 123, 185, 89, 99, 204, 87,
+       151, 214, 120, 85, 200, 252, 98, 114, 221, 165, 164, 124, 248,
+       134, 238, 237, 163, 52, 159, 115, 108, 129, 10, 123, 191, 112,
+       247, 44, 251, 134, 159, 157, 211, 135, 168, 90, 189, 213, 38, 234,
+       224, 238, 129, 89, 110, 164, 97, 124, 232, 235, 191, 168, 39, 237,
+       253, 211, 46, 92, 203, 214, 170, 252, 235, 252, 73, 235, 200, 207,
+       53, 177, 191, 157, 203, 95, 75, 235, 197, 79, 243, 178, 103, 205,
+       240, 220, 153, 175, 253, 149, 139, 101, 129, 3, 52, 243, 254, 116,
+       173, 185, 67, 191, 9, 249, 114, 188, 222, 180, 32, 238, 59, 31,
+       21, 51, 169, 2, 203, 148, 220, 186, 170, 212, 72, 161, 169, 56,
+       227, 98, 13, 20, 155, 66, 96, 100, 100, 239, 143, 99, 192, 190,
+       208, 120, 236, 78, 238, 76, 178, 197, 12, 246, 45, 161, 17, 103,
+       175, 126, 72, 187, 193, 240, 224, 244, 58, 250, 78, 75, 17, 189,
+       186, 159, 91, 180, 244, 254, 145, 147, 249, 10, 38, 72, 213, 222,
+       217, 139, 119, 183, 143, 233, 164, 213, 191, 163, 86, 218, 108,
+       103, 186, 243, 202, 24, 244, 243, 245, 233, 119, 53, 246, 92, 110,
+       249, 65, 190, 46, 189, 134, 229, 174, 170, 243, 226, 119, 220,
+       232, 142, 158, 143, 210, 71, 168, 18, 222, 198, 130, 110, 230,
+       107, 217, 113, 239, 164, 194, 104, 199, 171, 255, 217, 231, 255,
+       93, 179, 116, 44, 122, 222, 188, 183, 178, 169, 228, 24, 199, 187,
+       251, 129, 25, 140, 255, 64, 155, 167, 183, 253, 145, 59, 79, 154,
+       194, 153, 211, 95, 123, 130, 68, 167, 115, 52, 67, 74, 236, 86,
+       211, 67, 112, 69, 68, 254, 142, 67, 65, 187, 80, 120, 172, 6, 238,
+       76, 179, 116, 175, 246, 236, 128, 1, 117, 155, 118, 196, 179, 65,
+       124, 214, 100, 60, 252, 66, 107, 240, 189, 139, 173, 15, 182, 47,
+       238, 241, 23, 207, 140, 100, 46, 233, 150, 218, 211, 51, 7, 175,
+       69, 196, 188, 223, 164, 159, 183, 155, 150, 253, 146, 158, 149,
+       183, 234, 224, 171, 133, 93, 98, 134, 102, 252, 106, 106, 191,
+       234, 71, 103, 255, 179, 126, 156, 247, 173, 182, 140, 159, 221,
+       255, 225, 187, 222, 255, 119, 22, 248, 228, 94, 137, 17, 110, 160,
+       41, 49, 244, 251, 31, 77, 39, 245, 109, 201, 104, 95, 240, 201,
+       149, 23, 177, 172, 143, 173, 55, 189, 90, 182, 48, 159, 146, 160,
+       239, 231, 55, 127, 45, 113, 237, 98, 220, 172, 251, 122, 210, 28,
+       8, 129, 41, 199, 237, 83, 146, 228, 249, 238, 230, 169, 82, 56,
+       90, 172, 246, 253, 38, 235, 195, 22, 219, 103, 7, 60, 242, 53, 28,
+       142, 171, 140, 91, 131, 172, 220, 204, 174, 158, 145, 210, 22,
+       174, 178, 223, 164, 51, 126, 118, 171, 251, 253, 242, 184, 210,
+       126, 207, 42, 175, 251, 103, 255, 79, 130, 125, 172, 74, 217, 190,
+       142, 156, 159, 119, 77, 187, 30, 238, 222, 30, 237, 230, 178, 197,
+       51, 239, 172, 165, 105, 221, 63, 223, 233, 39, 255, 149, 174, 116,
+       45, 121, 26, 95, 35, 188, 50, 192, 191, 118, 180, 68, 218, 231,
+       189, 175, 33, 64, 238, 123, 19, 197, 64, 139, 0, 255, 224, 231,
+       186, 137, 52, 16, 37, 251, 1, 75, 90, 105, 116, 155, 106, 88, 101,
+       4, 254, 192, 179, 1, 179, 244, 122, 172, 78, 108, 142, 186, 101,
+       29, 182, 253, 34, 72, 126, 138, 106, 132, 173, 156, 172, 151, 245,
+       254, 183, 251, 18, 255, 61, 55, 250, 116, 202, 171, 125, 122, 178,
+       62, 245, 252, 122, 191, 111, 71, 247, 101, 211, 126, 220, 247, 9,
+       207, 18, 213, 50, 158, 108, 55, 125, 10, 126, 96, 191, 163, 160,
+       228, 102, 110, 38, 12, 193, 152, 1, 239, 164, 255, 54, 128, 42,
+       212, 169, 9, 63, 77, 99, 205, 86, 210, 239, 240, 85, 64, 222, 194,
+       81, 72, 181, 228, 120, 232, 19, 239, 201, 179, 53, 236, 118, 44,
+       162, 128, 127, 191, 112, 164, 65, 90, 187, 230, 124, 47, 186, 92,
+       200, 235, 17, 98, 149, 186, 240, 42, 166, 117, 23, 111, 161, 77,
+       136, 104, 77, 143, 122, 172, 156, 43, 1, 161, 221, 223, 174, 150,
+       151, 118, 55, 191, 178, 222, 158, 183, 248, 246, 235, 229, 117,
+       242, 172, 174, 253, 77, 62, 255, 251, 71, 255, 223, 171, 116, 253,
+       127, 214, 172, 199, 190, 156, 162, 71, 172, 54, 179, 195, 18, 98,
+       226, 104, 219, 113, 239, 104, 130, 122, 223, 139, 127, 184, 166,
+       223, 0, 184, 115, 224, 0, 19, 79, 106, 142, 87, 150, 238, 100,
+       132, 200, 218, 199, 105, 238, 183, 224, 122, 233, 147, 239, 204,
+       155, 4, 238, 50, 45, 174, 129, 61, 62, 56, 220, 57, 73, 98, 233,
+       116, 2, 239, 117, 69, 0, 126, 194, 27, 9, 181, 224, 122, 168, 23,
+       237, 200, 186, 5, 204, 118, 205, 162, 4, 111, 186, 120, 168, 208,
+       6, 63, 178, 24, 227, 27, 45, 148, 204, 143, 177, 247, 103, 43, 65,
+       209, 51, 125, 179, 40, 1, 43, 62, 233, 231, 254, 209, 176, 66, 37,
+       122, 8, 147, 172, 187, 238, 1, 48, 156, 134, 29, 21, 167, 245,
+       217, 107, 11, 39, 3, 251, 85, 22, 74, 75, 49, 206, 67, 124, 237,
+       188, 139, 61, 219, 87, 254, 143, 158, 159, 102, 143, 190, 154,
+       254, 159, 38, 116, 230, 171, 101, 113, 239, 44, 162, 237, 197,
+       187, 255, 249, 38, 255, 212, 169, 115, 173, 125, 234, 188, 144,
+       250, 169, 253, 20, 223, 159, 27, 164, 24, 190, 255, 100, 187, 205,
+       123, 255, 16, 55, 79, 218, 243, 155, 219, 87, 123, 218, 72, 143,
+       155, 73, 235, 16, 241, 252, 139, 109, 23, 110, 41, 82, 96, 183,
+       131, 192, 252, 2, 46, 110, 28, 67, 152, 193, 17, 204, 253, 54, 32,
+       24, 128, 137, 169, 90, 158, 14, 190, 159, 180, 20, 167, 152, 83,
+       139, 191, 174, 122, 34, 195, 167, 103, 221, 39, 62, 75, 136, 253,
+       176, 115, 222, 251, 156, 92, 185, 95, 173, 159, 172, 159, 243,
+       127, 151, 191, 18, 223, 61, 63, 248, 117, 203, 37, 93, 114, 151,
+       110, 245, 98, 122, 191, 111, 71, 101, 247, 250, 255, 156, 247, 51,
+       15, 165, 153, 21, 190, 136, 42, 95, 21, 202, 22, 174, 40, 52, 237,
+       228, 163, 136, 149, 191, 201, 117, 253, 153, 114, 218, 82, 144,
+       13, 21, 100, 145, 201, 59, 28, 74, 69, 191, 238, 214, 200, 224,
+       67, 52, 222, 37, 97, 244, 233, 26, 228, 199, 67, 34, 121, 113, 8,
+       39, 40, 17, 48, 37, 235, 213, 223, 175, 22, 176, 118, 55, 190,
+       178, 222, 158, 55, 112, 247, 171, 99, 125, 242, 63, 238, 245, 69,
+       58, 111, 123, 47, 231, 156, 138, 247, 180, 123, 164, 254, 188,
+       255, 220, 167, 135, 190, 210, 191, 124, 119, 224, 233, 77, 9, 217,
+       126, 37, 195, 240, 236, 202, 63, 109, 135, 255, 255, 209, 123,
+       212, 171, 193, 188, 156, 187, 185, 189, 117, 159, 255, 95, 172,
+       28, 190, 250, 66, 26, 133, 107, 110, 16, 183, 109, 250, 243, 207,
+       223, 22, 122, 216, 64, 139, 79, 9, 187, 19, 241, 100, 141, 169,
+       23, 174, 9, 90, 104, 188, 147, 192, 0, 134, 59, 95, 9, 83, 24,
+       194, 209, 205, 152, 58, 168, 8, 136, 131, 169, 178, 159, 108, 187,
+       246, 193, 115, 231, 23, 85, 124, 183, 51, 79, 166, 1, 109, 187,
+       135, 208, 250, 188, 42, 247, 236, 129, 134, 99, 117, 136, 244,
+       250, 214, 172, 151, 214, 159, 98, 79, 169, 91, 250, 155, 18, 124,
+       243, 56, 229, 115, 231, 60, 171, 113, 197, 171, 255, 185, 166,
+       239, 148, 166, 114, 165, 36, 34, 185, 123, 236, 116, 204, 249,
+       119, 137, 73, 120, 102, 190, 159, 52, 32, 206, 187, 23, 129, 211,
+       186, 16, 205, 103, 220, 186, 170, 68, 138, 211, 251, 34, 145, 51,
+       252, 108, 141, 185, 119, 137, 9, 120, 104, 190, 159, 96, 0, 172,
+       59, 87, 1, 211, 41, 18, 209, 197, 156, 58, 170, 24, 8, 131, 187,
+       81, 106, 70, 149, 84, 138, 224, 66, 108, 161, 226, 82, 146, 2, 1,
+       91, 104, 132, 106, 153, 40, 255, 197, 68, 148, 162, 218, 80, 201,
+       9, 81, 40, 112, 64, 206, 141, 94, 10, 224, 68, 108, 33, 226, 66,
+       194, 2, 13, 75, 120, 132, 106, 144, 8, 247, 197, 68, 148, 34, 154,
+       16, 225, 8, 113, 140, 67, 198, 135, 148, 11, 80, 172, 231, 184,
+       210, 130, 249, 204, 182, 100, 239, 227, 103, 251, 161, 229, 79,
+       150, 202, 184, 54, 222, 63, 4, 116, 191, 76, 165, 222, 156, 191,
+       242, 47, 23, 254, 18, 159, 61, 127, 246, 113, 235, 1, 221, 115, 7,
+       102, 250, 70, 90, 63, 236, 135, 127, 172, 152, 123, 130, 219, 198,
+       230, 132, 191, 141, 169, 166, 172, 222, 187, 145, 91, 227, 232,
+       89, 11, 217, 106, 106, 83, 50, 101, 203, 179, 172, 182, 223, 127,
+       217, 123, 153, 134, 180, 254, 141, 151, 156, 233, 135, 173, 94,
+       191, 51, 119, 230, 224, 202, 15, 217, 74, 110, 19, 59, 116, 203,
+       63, 172, 6, 127, 246, 217, 123, 141, 151, 42, 173, 210, 237, 118,
+       136, 236, 71, 60, 1, 122, 130, 173, 170, 52, 192, 234, 47, 19,
+       129, 66, 184, 192, 203, 36, 253, 154, 0, 69, 8, 219, 136, 66, 162,
+       155, 249, 60, 169, 249, 2, 170, 25, 146, 120, 159, 187, 212, 90,
+       199, 17, 127, 21, 19, 45, 194, 193, 132, 188, 58, 248, 140, 8, 3,
+       1, 66, 128, 217, 177, 54, 137, 232, 2, 175, 49, 178, 218, 159,
+       138, 20, 90, 163, 133, 127, 157, 2, 100, 195, 209, 132, 186, 122,
+       244, 204, 136, 67, 0, 213, 205, 183, 222, 157, 98, 231, 189, 242,
+       202, 185, 114, 112, 243, 169, 230, 113, 198, 110, 170, 113, 101,
+       42, 238, 185, 38, 231, 158, 131, 115, 229, 45, 236, 44, 204, 245,
+       172, 42, 204, 155, 154, 179, 147, 217, 211, 105, 81, 11, 9, 214,
+       125, 63, 56, 100, 223, 10, 204, 171, 253, 52, 237, 249, 216, 16,
+       108, 164, 172, 245, 172, 47, 204, 191, 58, 187, 158, 189, 211, 45,
+       216, 11, 149, 86, 125, 61, 184, 124, 203, 2, 204, 191, 253, 244,
+       140, 232, 219, 16, 233, 188, 62, 250, 189, 173, 119, 247, 255, 31,
+       244, 29, 238, 249, 54, 89, 201, 235, 127, 31, 254, 111, 154, 255,
+       251, 255, 87, 122, 218, 88, 234, 203, 132, 140, 221, 243, 230,
+       106, 239, 167, 24, 83, 123, 242, 209, 63, 156, 73, 107, 87, 19,
+       155, 49, 252, 13, 98, 44, 175, 254, 192, 165, 89, 245, 168, 3,
+       183, 250, 221, 116, 188, 185, 87, 125, 73, 126, 179, 188, 158,
+       182, 32, 238, 59, 151, 133, 150, 184, 36, 207, 71, 61, 186, 130,
+       69, 132, 231, 223, 2, 191, 58, 222, 115, 244, 184, 87, 189, 77,
+       124, 39, 44, 158, 166, 100, 238, 59, 147, 133, 151, 152, 48, 207,
+       103, 61, 26, 195, 7, 4, 175, 255, 3, 19, 99, 73, 118, 150, 235,
+       17, 77, 73, 94, 230, 153, 28, 150, 100, 126, 41, 23, 141, 129,
+       152, 101, 207, 70, 44, 170, 192, 47, 134, 113, 245, 67, 96, 85,
+       177, 36, 136, 232, 2, 173, 16, 178, 64, 143, 10, 21, 89, 234, 161,
+       127, 17, 10, 252, 199, 192, 148, 184, 218, 192, 76, 128, 1, 8,
+       114, 1, 83, 225, 6, 10, 232, 65, 109, 16, 243, 66, 3, 10, 60, 89,
+       122, 141, 110, 161, 74, 179, 65, 192, 148, 184, 130, 6, 37, 138,
+       96, 140, 184, 246, 122, 88, 21, 246, 209, 122, 84, 134, 231, 18,
+       83, 221, 46, 97, 89, 152, 130, 56, 104, 231, 112, 142, 91, 171,
+       212, 93, 83, 136, 116, 98, 220, 100, 120, 241, 215, 244, 127, 15,
+       115, 166, 190, 19, 25, 95, 91, 41, 57, 191, 149, 185, 62, 116,
+       177, 210, 247, 201, 135, 101, 231, 209, 244, 98, 18, 129, 83, 225,
+       68, 2, 232, 97, 109, 16, 243, 66, 137, 11, 116, 70, 106, 137, 46,
+       225, 88, 178, 69, 192, 148, 216, 130, 70, 53, 138, 112, 132, 48,
+       8, 79, 161, 86, 169, 232, 66, 44, 0, 248, 66, 165, 2, 49, 73, 106,
+       169, 2, 141, 0, 178, 69, 200, 148, 128, 138, 0, 181, 10, 113, 136,
+       17, 98, 2, 137, 68, 137, 224, 66, 108, 32, 234, 66, 181, 130, 97,
+       64, 104, 136, 74, 140, 2, 179, 197, 65, 148, 0, 138, 8, 97, 8,
+       113, 136, 90, 104, 146, 180, 107, 88, 152, 70, 59, 233, 176, 239,
+       174, 174, 7, 158, 166, 231, 237, 133, 12, 75, 130, 233, 144, 246,
+       94, 59, 202, 116, 11, 31, 188, 94, 254, 228, 69, 112, 242, 194,
+       209, 134, 190, 19, 107, 155, 103, 82, 233, 148, 165, 130, 108,
+       183, 145, 163, 211, 241, 131, 3, 99, 125, 124, 138, 189, 126, 140,
+       186, 172, 39, 70, 248, 150, 186, 177, 127, 87, 99, 203, 155, 221,
+       198, 110, 110, 237, 103, 75, 58, 248, 195, 231, 180, 152, 249,
+       122, 129, 253, 4, 196, 183, 143, 39, 76, 155, 22, 179, 155, 214,
+       209, 99, 73, 139, 89, 199, 110, 190, 60, 70, 223, 138, 238, 195,
+       255, 52, 187, 249, 152, 2, 228, 238, 62, 254, 253, 175, 255, 247,
+       253, 30, 254, 29, 238, 233, 63, 89, 217, 231, 111, 14, 250, 239,
+       250, 255, 243, 255, 215, 56, 64, 89, 242, 91, 3, 160, 235, 133,
+       86, 211, 184, 99, 125, 65, 122, 147, 49, 140, 54, 32, 110, 169,
+       19, 141, 150, 190, 52, 207, 23, 28, 154, 128, 101, 136, 115, 252,
+       131, 1, 244, 240, 44, 141, 120, 19, 173, 152, 48, 97, 143, 159,
+       245, 123, 166, 49, 127, 21, 134, 9, 2, 208, 130, 216, 90, 170, 30,
+       132, 1, 15, 120, 121, 144, 164, 83, 60, 80, 206, 11, 173, 120, 15,
+       47, 171, 67, 154, 174, 253, 165, 80, 14, 122, 146, 168, 219, 199,
+       21, 59, 227, 126, 14, 154, 236, 253, 132, 243, 172, 35, 92, 191,
+       22, 179, 154, 252, 209, 107, 217, 203, 79, 215, 253, 153, 251, 74,
+       203, 178, 238, 223, 255, 252, 174, 248, 152, 24, 98, 153, 122,
+       154, 91, 241, 152, 67, 139, 85, 173, 187, 44, 158, 102, 26, 201,
+       179, 211, 145, 22, 11, 50, 245, 91, 81, 154, 123, 145, 12, 167,
+       222, 2, 0, 91, 225, 118, 137, 248, 64, 141, 129, 112, 195, 173,
+       10, 53, 10, 234, 169, 23, 157, 0, 178, 64, 200, 20, 156, 10, 168,
+       165, 136, 113, 136, 1, 128, 89, 193, 70, 136, 232, 99, 108, 17,
+       242, 66, 181, 3, 240, 66, 106, 137, 27, 137, 66, 60, 198, 213,
+       148, 128, 154, 40, 28, 8, 97, 160, 20, 20, 59, 78, 19, 254, 178,
+       65, 233, 65, 235, 82, 126, 220, 44, 240, 54, 189, 144, 34, 1, 163,
+       56, 79, 51, 164, 2, 3, 97, 99, 231, 246, 9, 253, 155, 118, 48,
+       205, 182, 103, 234, 232, 58, 104, 190, 184, 229, 50, 128, 123, 76,
+       72, 69, 169, 160, 105, 97, 156, 37, 48, 72, 48, 75, 157, 4, 149,
+       125, 215, 82, 196, 187, 184, 132, 121, 63, 82, 240, 119, 12, 35,
+       95, 82, 55, 234, 177, 240, 121, 101, 111, 139, 225, 192, 193, 139,
+       68, 243, 91, 0, 113, 229, 118, 18, 248, 56, 73, 96, 20, 162, 157,
+       31, 156, 224, 54, 149, 159, 173, 132, 48, 37, 205, 215, 249, 170,
+       229, 39, 134, 33, 225, 172, 59, 248, 97, 252, 203, 83, 216, 67,
+       181, 60, 42, 50, 245, 67, 18, 89, 90, 130, 88, 18, 186, 106, 38,
+       111, 141, 37, 117, 243, 137, 78, 171, 232, 122, 248, 101, 94, 136,
+       209, 84, 99, 165, 116, 42, 59, 153, 69, 16, 138, 252, 229, 80, 2,
+       60, 210, 34, 79, 237, 37, 41, 103, 168, 94, 139, 157, 89, 90, 220,
+       199, 244, 182, 208, 220, 72, 116, 70, 56, 254, 37, 105, 226, 123,
+       50, 194, 165, 163, 50, 232, 115, 169, 98, 10, 25, 121, 105, 155,
+       212, 53, 25, 162, 146, 229, 23, 48, 60, 169, 137, 88, 214, 215,
+       104, 81, 244, 187, 29, 83, 121, 18, 216, 58, 249, 129, 46, 186,
+       16, 67, 165, 51, 213, 204, 213, 187, 168, 34, 78, 174, 23, 243,
+       168, 244, 211, 98, 200, 219, 95, 199, 108, 254, 127, 70, 223, 243,
+       172, 190, 223, 76, 184, 241, 160, 4, 231, 255, 212, 255, 184, 38,
+       78, 191, 19, 187, 176, 244, 251, 99, 201, 91, 95, 223, 125, 242,
+       123, 74, 207, 243, 174, 222, 255, 252, 188, 241, 160, 9, 102, 134,
+       173, 177, 168, 35, 76, 143, 134, 63, 153, 255, 193, 108, 90, 75,
+       205, 135, 127, 165, 184, 66, 203, 144, 140, 19, 253, 253, 148,
+       248, 148, 97, 98, 32, 170, 154, 127, 241, 152, 70, 143, 85, 133,
+       187, 44, 142, 110, 14, 201, 179, 235, 17, 22, 79, 170, 241, 155,
+       84, 154, 251, 151, 13, 189, 94, 56, 196, 126, 122, 109, 217, 84,
+       236, 133, 30, 228, 41, 106, 89, 47, 91, 201, 146, 199, 98, 110,
+       231, 74, 181, 243, 243, 84, 19, 82, 92, 254, 202, 75, 17, 120,
+       225, 118, 23, 217, 16, 77, 105, 30, 163, 157, 31, 151, 224, 150,
+       149, 149, 189, 133, 144, 37, 220, 198, 89, 170, 196, 39, 134, 21,
+       117, 242, 25, 231, 198, 222, 210, 206, 97, 129, 192, 214, 162, 57,
+       191, 181, 231, 110, 247, 155, 225, 121, 203, 36, 236, 59, 32, 142,
+       131, 39, 175, 52, 124, 0, 216, 57, 90, 121, 213, 16, 230, 47, 89,
+       252, 96, 60, 151, 164, 245, 196, 155, 158, 216, 67, 10, 98, 117,
+       51, 217, 50, 234, 82, 16, 173, 61, 220, 63, 212, 151, 171, 58, 20,
+       191, 51, 182, 170, 253, 202, 35, 193, 223, 71, 214, 236, 50, 124,
+       75, 203, 234, 250, 246, 87, 63, 170, 252, 136, 27, 103, 233, 140,
+       159, 205, 4, 204, 143, 154, 219, 128, 93, 164, 232, 86, 75, 193,
+       107, 123, 29, 182, 74, 219, 161, 237, 26, 223, 120, 152, 124, 152,
+       94, 17, 205, 3, 169, 20, 135, 235, 254, 20, 128, 218, 70, 85, 195,
+       49, 64, 120, 233, 19, 253, 9, 152, 17, 31, 249, 142, 175, 68, 185,
+       26, 177, 168, 57, 73, 107, 230, 22, 218, 75, 240, 97, 192, 190,
+       138, 123, 21, 179, 48, 122, 228, 95, 238, 201, 163, 60, 172, 243,
+       237, 128, 17, 103, 187, 118, 232, 189, 73, 107, 110, 86, 199, 79,
+       116, 85, 64, 116, 198, 115, 69, 179, 48, 126, 232, 22, 238, 201,
+       178, 60, 63, 118, 141, 165, 0, 125, 187, 112, 240, 65, 48, 27,
+       137, 108, 15, 168, 67, 172, 169, 240, 88, 148, 146, 32, 123, 236,
+       61, 94, 25, 17, 187, 80, 204, 148, 16, 90, 56, 8, 8, 3, 137, 6,
+       137, 150, 145, 237, 8, 188, 143, 175, 17, 2, 145, 172, 234, 76,
+       74, 195, 67, 107, 17, 18, 88, 195, 224, 141, 18, 222, 67, 128, 88,
+       129, 138, 58, 8, 244, 252, 77, 118, 80, 106, 205, 158, 244, 3,
+       106, 123, 55, 219, 233, 241, 175, 128, 76, 99, 3, 200, 195, 251,
+       215, 11, 243, 108, 108, 138, 220, 28, 51, 250, 171, 225, 23, 194,
+       180, 14, 128, 56, 159, 151, 33, 89, 199, 241, 205, 226, 57, 7, 56,
+       126, 209, 197, 35, 60, 178, 113, 39, 115, 2, 148, 63, 155, 81,
+       236, 177, 103, 190, 93, 65, 21, 188, 191, 38, 65, 165, 59, 147, 1,
+       51, 188, 50, 215, 77, 54, 90, 75, 208, 0, 165, 251, 194, 112, 121,
+       208, 110, 149, 217, 87, 137, 121, 176, 251, 156, 159, 116, 57,
+       134, 177, 223, 149, 146, 47, 50, 212, 87, 88, 250, 250, 23, 132,
+       3, 95, 67, 48, 120, 208, 124, 132, 248, 19, 235, 25, 177, 251,
+       188, 159, 84, 43, 174, 177, 95, 149, 130, 47, 210, 192, 71, 24,
+       186, 250, 133, 132, 19, 159, 3, 16, 149, 241, 100, 13, 248, 67,
+       141, 57, 178, 94, 156, 26, 84, 26, 238, 149, 119, 129, 145, 190,
+       80, 192, 149, 152, 218, 194, 77, 8, 97, 139, 253, 29, 85, 76, 202,
+       22, 70, 59, 113, 242, 166, 76, 91, 51, 133, 247, 86, 212, 124,
+       234, 233, 70, 243, 12, 51, 235, 101, 28, 58, 160, 106, 53, 216,
+       175, 148, 247, 173, 42, 125, 167, 187, 191, 158, 120, 239, 35,
+       192, 23, 3, 246, 237, 136, 56, 218, 203, 227, 252, 247, 255, 177,
+       162, 240, 158, 43, 220, 193, 119, 111, 12, 78, 71, 185, 100, 232,
+       227, 66, 115, 81, 137, 247, 120, 196, 108, 234, 105, 161, 121, 13,
+       241, 234, 229, 20, 97, 178, 228, 32, 22, 201, 70, 171, 6, 139,
+       106, 228, 173, 0, 226, 195, 101, 203, 53, 64, 234, 233, 42, 199,
+       78, 177, 10, 225, 146, 168, 134, 0, 37, 146, 97, 136, 54, 105,
+       118, 239, 15, 139, 74, 192, 229, 32, 226, 2, 43, 137, 53, 86, 106,
+       252, 77, 226, 72, 179, 197, 168, 179, 232, 128, 17, 103, 187, 116,
+       42, 127, 105, 103, 99, 79, 25, 74, 64, 229, 48, 243, 10, 91, 153,
+       93, 246, 106, 156, 127, 206, 76, 179, 223, 208, 19, 249, 129, 20,
+       103, 175, 122, 2, 2, 148, 63, 157, 117, 236, 177, 103, 188, 77,
+       75, 21, 188, 190, 36, 64, 164, 59, 51, 1, 19, 152, 18, 199, 5, 54,
+       90, 75, 0, 8, 37, 251, 151, 86, 71, 133, 98, 34, 174, 112, 60,
+       226, 83, 231, 93, 14, 189, 229, 62, 197, 23, 239, 229, 148, 37,
+       206, 20, 42, 234, 128, 45, 247, 33, 245, 35, 1, 244, 213, 203, 22,
+       188, 71, 139, 179, 179, 19, 8, 62, 100, 206, 239, 247, 251, 145,
+       20, 219, 67, 192, 31, 90, 223, 67, 131, 100, 169, 15, 42, 8, 228,
+       253, 77, 118, 216, 7, 129, 131, 214, 19, 40, 61, 16, 174, 204,
+       183, 249, 129, 24, 234, 83, 137, 71, 251, 216, 147, 39, 236, 92,
+       142, 43, 36, 109, 73, 12, 127, 249, 83, 68, 122, 157, 18, 146, 29,
+       182, 105, 73, 16, 91, 45, 176, 181, 117, 29, 71, 9, 113, 213, 87,
+       136, 84, 242, 2, 32, 254, 64, 66, 111, 185, 91, 170, 242, 61, 10,
+       25, 191, 117, 58, 54, 29, 19, 184, 1, 240, 176, 72, 95, 12, 91,
+       172, 239, 224, 39, 178, 63, 18, 70, 136, 15, 179, 194, 74, 197,
+       33, 203, 86, 74, 216, 62, 236, 248, 132, 154, 163, 156, 179, 69,
+       148, 146, 86, 139, 87, 63, 47, 248, 134, 209, 28, 93, 205, 26, 55,
+       72, 54, 53, 170, 222, 118, 211, 51, 129, 245, 69, 180, 124, 168,
+       169, 156, 81, 14, 131, 174, 240, 144, 40, 160, 40, 57, 12, 126,
+       32, 187, 52, 165, 139, 156, 22, 7, 73, 151, 157, 75, 121, 72, 223,
+       27, 19, 17, 162, 20, 89, 183, 205, 198, 159, 100, 150, 223, 21,
+       162, 88, 174, 156, 183, 172, 42, 84, 183, 187, 191, 158, 253, 239,
+       35, 130, 91, 73, 246, 237, 129, 56, 248, 193, 167, 220, 247, 255,
+       209, 142, 104, 157, 11, 2, 144, 154, 181, 116, 140, 184, 51, 188,
+       9, 82, 117, 188, 159, 0, 64, 198, 59, 63, 129, 179, 220, 210, 197,
+       69, 52, 186, 202, 12, 8, 1, 155, 139, 87, 105, 129, 226, 54, 189,
+       63, 120, 78, 87, 244, 221, 22, 155, 253, 86, 5, 150, 173, 245,
+       148, 101, 206, 102, 41, 106, 132, 46, 244, 161, 117, 254, 88, 234,
+       218, 47, 244, 145, 208, 139, 93, 181, 63, 42, 156, 111, 127, 204,
+       179, 189, 87, 143, 39, 186, 241, 83, 81, 216, 251, 215, 29, 124,
+       95, 227, 112, 122, 218, 121, 213, 152, 84, 139, 93, 149, 61, 172,
+       158, 126, 59, 142, 51, 223, 149, 150, 79, 178, 241, 83, 88, 154,
+       251, 158, 133, 183, 127, 217, 149, 62, 184, 179, 6, 53, 119, 188,
+       55, 14, 21, 156, 187, 42, 67, 167, 7, 57, 37, 116, 25, 17, 215,
+       249, 179, 94, 70, 152, 64, 165, 90, 3, 32, 213, 149, 126, 139,
+       168, 35, 28, 161, 210, 82, 148, 56, 20, 43, 239, 141, 91, 141, 21,
+       248, 81, 196, 140, 30, 218, 192, 204, 8, 1, 132, 3, 146, 157, 181,
+       100, 141, 184, 51, 30, 43, 82, 118, 180, 58, 128, 64, 198, 53, 59,
+       129, 181, 156, 83, 197, 12, 62, 250, 194, 28, 8, 1, 155, 114, 16,
+       51, 184, 71, 204, 177, 70, 13, 77, 241, 27, 28, 158, 36, 88, 236,
+       145, 223, 145, 2, 43, 80, 192, 209, 48, 26, 219, 17, 12, 37, 123,
+       43, 208, 126, 90, 231, 244, 84, 135, 221, 95, 117, 49, 42, 250,
+       46, 125, 193, 51, 166, 18, 246, 232, 58, 241, 3, 219, 84, 75, 210,
+       93, 236, 79, 166, 222, 92, 218, 251, 241, 22, 206, 157, 31, 188,
+       191, 104, 206, 175, 93, 239, 147, 139, 146, 54, 7, 10, 247, 50,
+       22, 148, 251, 145, 93, 172, 31, 14, 142, 38, 158, 31, 153, 146,
+       233, 142, 20, 137, 199, 236, 236, 54, 197, 199, 99, 171, 71, 246,
+       41, 14, 189, 168, 118, 75, 123, 87, 47, 149, 197, 158, 151, 38,
+       170, 153, 134, 79, 57, 133, 29, 223, 7, 204, 99, 42, 69, 84, 147,
+       31, 171, 122, 137, 9, 221, 225, 240, 138, 212, 50, 6, 165, 35, 2,
+       32, 85, 213, 118, 139, 168, 67, 47, 168, 240, 98, 172, 10, 148,
+       61, 174, 61, 95, 9, 0, 250, 1, 220, 148, 26, 90, 162, 69, 0, 39,
+       169, 248, 73, 106, 236, 30, 145, 91, 88, 69, 36, 244, 138, 59,
+       201, 247, 96, 122, 176, 31, 250, 202, 35, 228, 159, 211, 237, 161,
+       61, 119, 175, 124, 32, 6, 184, 119, 218, 109, 197, 153, 192, 139,
+       85, 49, 19, 44, 222, 126, 59, 166, 49, 247, 209, 150, 111, 58,
+       241, 19, 216, 90, 251, 215, 5, 7, 87, 98, 88, 127, 250, 71, 196,
+       249, 68, 169, 85, 177, 23, 140, 158, 118, 91, 238, 177, 151, 209,
+       30, 47, 50, 225, 23, 120, 154, 75, 133, 5, 231, 95, 114, 16, 59,
+       154, 11, 197, 145, 65, 141, 93, 177, 27, 142, 158, 38, 89, 236,
+       177, 223, 145, 14, 15, 112, 208, 211, 16, 154, 251, 16, 12, 37,
+       223, 98, 176, 52, 152, 107, 221, 144, 0, 203, 85, 148, 169, 172,
+       220, 70, 38, 134, 49, 251, 145, 134, 75, 210, 209, 15, 113, 27,
+       251, 30, 4, 15, 223, 175, 122, 48, 26, 29, 181, 146, 218, 199,
+       164, 160, 78, 170, 200, 119, 172, 204, 248, 194, 83, 142, 39, 94,
+       185, 2, 80, 1, 59, 91, 157, 74, 140, 126, 237, 245, 228, 235, 65,
+       31, 255, 131, 182, 188, 42, 29, 247, 65, 19, 15, 243, 223, 226,
+       104, 75, 234, 184, 123, 193, 237, 191, 55, 250, 166, 235, 200,
+       184, 19, 94, 25, 221, 16, 233, 207, 88, 160, 8, 238, 212, 105,
+       231, 193, 114, 232, 16, 71, 111, 250, 181, 153, 208, 7, 123, 82,
+       12, 39, 46, 65, 130, 145, 173, 108, 2, 168, 43, 62, 163, 66, 211,
+       181, 163, 112, 64, 111, 13, 43, 141, 96, 154, 195, 91, 76, 166,
+       250, 4, 28, 128, 33, 136, 3, 40, 87, 213, 100, 139, 168, 104, 47,
+       176, 242, 74, 172, 154, 52, 45, 170, 57, 94, 25, 0, 249, 3, 220,
+       156, 154, 219, 38, 92, 40, 17, 172, 45, 129, 245, 79, 253, 86, 70,
+       57, 69, 5, 249, 74, 98, 121, 188, 244, 88, 130, 38, 106, 217, 170,
+       123, 157, 39, 252, 128, 80, 243, 170, 208, 36, 22, 48, 158, 178,
+       130, 97, 184, 77, 158, 241, 151, 183, 92, 254, 110, 10, 191, 27,
+       251, 145, 22, 195, 27, 192, 219, 7, 31, 235, 141, 67, 173, 211,
+       153, 53, 145, 231, 151, 7, 39, 125, 22, 234, 83, 86, 213, 51, 65,
+       164, 125, 127, 20, 186, 249, 216, 217, 10, 237, 207, 191, 32, 170,
+       106, 129, 185, 173, 207, 140, 159, 188, 43, 231, 188, 214, 190,
+       189, 244, 243, 96, 203, 2, 89, 98, 78, 106, 121, 100, 78, 63, 236,
+       134, 231, 52, 220, 251, 216, 128, 232, 188, 17, 250, 25, 237, 18,
+       202, 139, 57, 169, 8, 174, 212, 104, 183, 129, 123, 232, 19, 43,
+       111, 250, 183, 153, 208, 29, 123, 82, 10, 7, 46, 240, 108, 134,
+       180, 91, 75, 38, 104, 182, 162, 130, 90, 100, 227, 97, 19, 121,
+       228, 106, 226, 41, 75, 139, 30, 185, 166, 77, 60, 168, 57, 42,
+       136, 116, 224, 148, 156, 79, 1, 130, 232, 218, 178, 161, 26, 102,
+       224, 108, 19, 217, 204, 106, 34, 112, 111, 218, 95, 153, 6, 87,
+       127, 208, 41, 34, 134, 66, 64, 250, 154, 237, 209, 216, 196, 143,
+       85, 181, 147, 172, 142, 126, 74, 234, 147, 159, 211, 6, 15, 58,
+       241, 147, 80, 218, 251, 149, 29, 173, 94, 34, 56, 42, 154, 79,
+       249, 176, 64, 141, 85, 181, 191, 172, 156, 110, 159, 232, 185,
+       203, 209, 6, 35, 178, 240, 147, 80, 154, 123, 87, 15, 63, 214,
+       168, 104, 147, 60, 104, 232, 71, 86, 241, 138, 96, 96, 54, 147,
+       33, 88, 200, 104, 2, 66, 8, 182, 194, 42, 100, 176, 48, 40, 82,
+       217, 98, 138, 132, 208, 247, 90, 113, 233, 113, 192, 255, 31, 101,
+       56, 94, 215, 44, 124, 163, 18, 66, 16, 50, 103, 42, 119, 91, 254,
+       18, 75, 210, 1, 231, 227, 156, 104, 248, 218, 139, 193, 23, 200,
+       151, 23, 180, 50, 28, 215, 105, 31, 123, 217, 183, 210, 42, 71,
+       42, 240, 219, 209, 87, 63, 179, 209, 36, 227, 154, 149, 44, 169,
+       155, 6, 159, 189, 4, 85, 143, 151, 213, 15, 58, 65, 92, 147, 31,
+       229, 122, 137, 89, 157, 233, 161, 138, 212, 52, 14, 181, 82, 166,
+       239, 134, 254, 188, 35, 206, 173, 94, 186, 219, 90, 231, 232, 189,
+       1, 217, 110, 109, 107, 120, 229, 203, 191, 168, 190, 239, 148,
+       204, 251, 209, 0, 116, 33, 215, 172, 124, 0, 232, 72, 171, 129,
+       243, 139, 103, 201, 124, 82, 122, 165, 107, 209, 10, 163, 198,
+       193, 220, 164, 139, 24, 69, 170, 99, 130, 41, 233, 99, 75, 212,
+       197, 239, 213, 83, 68, 124, 2, 49, 213, 180, 52, 88, 170, 18, 248,
+       211, 186, 116, 191, 109, 12, 132, 40, 119, 138, 246, 236, 226,
+       150, 229, 94, 123, 241, 152, 38, 59, 111, 115, 249, 104, 46, 134,
+       245, 207, 183, 230, 128, 183, 94, 100, 255, 30, 54, 218, 195, 215,
+       4, 206, 253, 134, 226, 178, 154, 239, 149, 184, 200, 203, 29, 53,
+       27, 140, 202, 126, 143, 239, 9, 211, 215, 150, 103, 10, 241, 22,
+       80, 90, 239, 214, 31, 175, 199, 226, 138, 199, 90, 113, 249, 40,
+       2, 127, 95, 115, 240, 104, 76, 174, 252, 199, 179, 166, 144, 183,
+       220, 111, 247, 30, 54, 216, 195, 215, 133, 76, 85, 29, 94, 235,
+       239, 164, 82, 255, 221, 84, 74, 95, 246, 81, 189, 187, 105, 126,
+       94, 23, 234, 253, 178, 45, 34, 102, 45, 246, 128, 189, 251, 240,
+       241, 103, 114, 191, 236, 108, 6, 217, 24, 10, 169, 242, 76, 84,
+       63, 28, 122, 220, 213, 125, 193, 137, 243, 211, 76, 81, 62, 249,
+       146, 201, 49, 114, 51, 26, 151, 44, 171, 150, 231, 155, 187, 6,
+       101, 219, 135, 221, 15, 58, 64, 93, 147, 155, 181, 58, 152, 93,
+       157, 237, 197, 139, 212, 181, 143, 181, 210, 66, 173, 149, 154,
+       187, 200, 20, 175, 186, 87, 128, 221, 164, 230, 64, 159, 135, 99,
+       232, 21, 119, 73, 202, 113, 172, 22, 95, 122, 136, 84, 131, 95,
+       52, 19, 25, 235, 147, 207, 86, 105, 5, 37, 185, 9, 79, 127, 40,
+       144, 190, 145, 199, 51, 24, 163, 24, 28, 251, 199, 5, 117, 241,
+       43, 143, 131, 47, 228, 224, 3, 245, 50, 229, 143, 123, 127, 45,
+       21, 136, 56, 223, 30, 217, 78, 18, 29, 150, 114, 236, 194, 46, 30,
+       151, 231, 207, 86, 218, 214, 5, 243, 167, 131, 224, 6, 175, 244,
+       52, 223, 91, 230, 213, 38, 249, 110, 118, 79, 22, 255, 209, 216,
+       45, 96, 172, 2, 254, 132, 140, 114, 165, 249, 115, 195, 243, 76,
+       67, 84, 79, 61, 97, 4, 106, 202, 43, 166, 164, 244, 118, 222, 164,
+       202, 201, 26, 228, 233, 177, 252, 134, 10, 50, 178, 164, 108, 62,
+       112, 225, 192, 143, 65, 157, 204, 7, 246, 148, 170, 25, 221, 237,
+       46, 95, 216, 247, 242, 11, 103, 235, 144, 83, 216, 221, 191, 183,
+       253, 20, 243, 220, 207, 199, 190, 222, 34, 103, 236, 210, 134,
+       137, 210, 225, 226, 233, 210, 123, 198, 110, 234, 120, 67, 142,
+       127, 184, 166, 239, 12, 181, 115, 240, 32, 214, 237, 207, 190,
+       158, 35, 78, 236, 19, 178, 203, 218, 101, 227, 57, 81, 123, 239,
+       45, 235, 120, 199, 143, 127, 184, 166, 207, 60, 165, 243, 160, 0,
+       80, 2, 207, 53, 16, 34, 35, 40, 118, 165, 195, 192, 83, 33, 0, 80,
+       112, 204, 104, 172, 56, 240, 205, 12, 76, 38, 211, 68, 33, 33,
+       112, 32, 14, 176, 225, 155, 247, 225, 107, 218, 23, 103, 89, 247,
+       140, 199, 248, 204, 95, 155, 147, 149, 19, 22, 105, 211, 13, 86,
+       155, 238, 182, 207, 148, 244, 96, 192, 248, 76, 72, 84, 207, 158,
+       33, 6, 238, 132, 32, 167, 167, 84, 84, 214, 234, 206, 72, 3, 243,
+       105, 115, 173, 150, 25, 115, 242, 100, 120, 96, 222, 250, 76, 72,
+       84, 255, 159, 161, 4, 254, 128, 112, 231, 175, 22, 124, 244, 107,
+       200, 64, 35, 179, 97, 119, 45, 20, 25, 67, 242, 230, 120, 201,
+       172, 49, 99, 189, 141, 254, 189, 239, 50, 46, 72, 253, 223, 88,
+       32, 135, 31, 121, 28, 210, 124, 187, 243, 111, 221, 5, 100, 70,
+       130, 195, 169, 232, 176, 184, 112, 217, 237, 81, 143, 18, 189,
+       164, 25, 182, 21, 74, 27, 129, 27, 201, 16, 58, 110, 219, 19, 203,
+       209, 21, 127, 208, 8, 198, 10, 82, 193, 40, 206, 141, 4, 79, 191,
+       4, 4, 206, 6, 247, 35, 56, 68, 80, 130, 57, 204, 88, 8, 115, 181,
+       241, 182, 218, 88, 26, 138, 149, 120, 214, 214, 194, 136, 61, 130,
+       218, 212, 151, 201, 147, 247, 72, 200, 254, 199, 223, 229, 189,
+       247, 236, 199, 143, 194, 58, 120, 175, 215, 15, 174, 120, 23, 41,
+       146, 236, 85, 118, 26, 227, 56, 80, 236, 55, 102, 121, 41, 150,
+       39, 57, 196, 38, 168, 161, 248, 45, 204, 126, 79, 247, 133, 239,
+       172, 125, 249, 172, 191, 134, 31, 219, 127, 167, 171, 150, 255,
+       75, 60, 242, 224, 194, 167, 17, 110, 224, 114, 54, 216, 171, 63,
+       109, 35, 101, 69, 192, 105, 149, 242, 97, 108, 153, 77, 12, 94,
+       196, 7, 194, 170, 168, 8, 178, 176, 84, 114, 200, 108, 108, 8, 77,
+       107, 224, 8, 37, 189, 180, 49, 80, 120, 82, 172, 158, 135, 37,
+       171, 186, 226, 27, 185, 132, 29, 155, 163, 237, 103, 42, 65, 70,
+       147, 157, 227, 122, 137, 75, 189, 233, 225, 170, 213, 54, 135,
+       165, 115, 244, 237, 196, 39, 144, 114, 70, 184, 84, 230, 207, 158,
+       99, 97, 131, 68, 89, 230, 104, 234, 44, 215, 125, 47, 186, 230,
+       133, 17, 163, 243, 116, 12, 25, 92, 171, 164, 21, 94, 227, 118,
+       84, 206, 182, 54, 190, 52, 162, 228, 120, 228, 206, 169, 185, 175,
+       49, 142, 251, 199, 178, 25, 2, 45, 116, 123, 215, 217, 173, 164,
+       173, 78, 75, 146, 235, 248, 142, 8, 159, 182, 83, 118, 164, 245,
+       125, 95, 201, 81, 186, 224, 217, 249, 207, 52, 128, 53, 3, 118,
+       132, 113, 185, 170, 206, 69, 189, 221, 142, 248, 17, 119, 28, 159,
+       105, 10, 239, 25, 51, 211, 211, 83, 154, 208, 93, 0, 111, 236,
+       145, 122, 165, 243, 89, 76, 81, 230, 85, 226, 75, 48, 57, 101,
+       119, 158, 95, 3, 16, 148, 50, 229, 21, 235, 41, 190, 57, 239, 177,
+       255, 186, 80, 175, 163, 27, 48, 211, 89, 191, 150, 43, 208, 177,
+       102, 237, 196, 158, 34, 188, 190, 39, 38, 162, 243, 253, 193, 65,
+       141, 182, 234, 241, 241, 94, 155, 5, 4, 37, 127, 52, 173, 197, 39,
+       148, 114, 71, 254, 80, 230, 239, 158, 67, 96, 139, 37, 89, 238,
+       32, 110, 125, 250, 125, 46, 170, 230, 197, 21, 227, 251, 246, 100,
+       77, 113, 213, 198, 234, 117, 111, 216, 132, 250, 30, 74, 80, 247,
+       237, 175, 116, 84, 126, 234, 65, 67, 251, 96, 53, 137, 103, 172,
+       10, 251, 161, 49, 219, 100, 4, 149, 37, 59, 172, 95, 120, 106,
+       151, 223, 205, 66, 155, 173, 51, 137, 221, 175, 229, 85, 133, 223,
+       146, 67, 235, 161, 47, 245, 155, 68, 146, 14, 255, 94, 27, 208,
+       153, 103, 173, 77, 222, 163, 172, 222, 182, 102, 238, 179, 253,
+       129, 139, 143, 166, 239, 209, 53, 154, 139, 5, 4, 37, 127, 28,
+       216, 177, 171, 147, 225, 147, 216, 22, 81, 72, 163, 189, 87, 105,
+       72, 119, 89, 147, 209, 11, 16, 91, 177, 201, 197, 171, 238, 176,
+       27, 37, 243, 117, 206, 197, 7, 146, 82, 70, 185, 84, 226, 174,
+       142, 99, 96, 155, 80, 121, 198, 104, 174, 109, 208, 109, 15, 186,
+       230, 133, 21, 239, 178, 80, 12, 156, 231, 53, 231, 168, 67, 111,
+       252, 6, 180, 108, 128, 223, 103, 201, 3, 18, 88, 1, 106, 73, 18,
+       171, 53, 233, 193, 111, 108, 50, 243, 167, 176, 177, 22, 29, 232,
+       109, 239, 83, 90, 15, 108, 121, 127, 22, 156, 38, 20, 236, 153,
+       166, 34, 139, 182, 122, 151, 145, 208, 32, 62, 121, 75, 70, 247,
+       226, 148, 167, 182, 225, 110, 85, 231, 21, 127, 242, 17, 86, 61,
+       32, 91, 201, 86, 55, 4, 56, 255, 83, 167, 235, 254, 212, 86, 192,
+       92, 244, 250, 52, 23, 87, 235, 133, 228, 215, 213, 69, 15, 123,
+       86, 2, 153, 60, 64, 200, 143, 36, 194, 93, 178, 121, 160, 35, 248,
+       130, 3, 249, 91, 244, 131, 121, 7, 108, 103, 48, 58, 78, 48, 113,
+       230, 239, 132, 235, 32, 154, 116, 18, 230, 108, 238, 253, 184,
+       109, 14, 226, 239, 37, 17, 110, 247, 72, 100, 44, 150, 222, 58,
+       235, 122, 52, 143, 223, 87, 119, 177, 143, 189, 98, 75, 203, 94,
+       166, 16, 54, 250, 227, 160, 78, 243, 116, 79, 226, 221, 236, 211,
+       180, 207, 197, 159, 157, 43, 231, 172, 214, 182, 169, 86, 227, 96,
+       41, 133, 121, 226, 74, 106, 121, 100, 94, 191, 172, 134, 199, 52,
+       243, 123, 216, 164, 164, 237, 199, 255, 157, 43, 206, 172, 94,
+       162, 169, 210, 231, 232, 61, 133, 91, 110, 106, 107, 112, 229, 79,
+       191, 168, 190, 207, 52, 212, 251, 209, 128, 205, 205, 234, 74,
+       213, 116, 254, 247, 68, 11, 223, 18, 89, 121, 60, 98, 249, 82, 31,
+       250, 180, 63, 56, 166, 127, 79, 166, 205, 183, 251, 248, 131, 44,
+       191, 148, 243, 245, 144, 116, 151, 147, 159, 50, 118, 72, 235,
+       204, 143, 237, 250, 166, 144, 58, 120, 139, 177, 46, 215, 247,
+       231, 195, 124, 252, 131, 199, 223, 105, 150, 226, 172, 191, 182,
+       184, 214, 29, 247, 244, 119, 171, 35, 55, 114, 27, 110, 241, 68,
+       190, 111, 108, 6, 127, 168, 132, 251, 133, 249, 156, 52, 45, 187,
+       138, 227, 153, 200, 150, 246, 129, 179, 149, 223, 97, 9, 75, 25,
+       19, 243, 34, 71, 123, 30, 201, 1, 235, 229, 181, 57, 53, 242, 88,
+       20, 229, 117, 17, 118, 114, 56, 118, 233, 211, 231, 91, 117, 0,
+       240, 116, 236, 189, 172, 169, 212, 253, 142, 223, 239, 177, 196,
+       43, 165, 116, 115, 223, 205, 168, 210, 214, 246, 191, 255, 90, 91,
+       157, 18, 216, 118, 254, 97, 127, 218, 23, 254, 247, 94, 60, 119,
+       251, 15, 255, 196, 149, 247, 185, 244, 184, 220, 254, 115, 241,
+       250, 116, 55, 56, 47, 111, 61, 94, 63, 2, 25, 163, 102, 133, 0,
+       52, 220, 17, 46, 255, 239, 116, 65, 226, 212, 206, 91, 175, 198,
+       164, 177, 237, 63, 204, 191, 87, 127, 144, 223, 203, 40, 222, 143,
+       221, 194, 183, 63, 238, 102, 91, 146, 174, 90, 221, 252, 159, 252,
+       216, 196, 169, 121, 47, 143, 44, 95, 179, 92, 134, 248, 214, 46,
+       208, 148, 194, 98, 76, 28, 238, 78, 199, 246, 251, 49, 103, 33,
+       163, 145, 8, 26, 92, 251, 173, 237, 172, 87, 165, 126, 223, 188,
+       90, 238, 29, 18, 216, 252, 223, 47, 25, 254, 180, 218, 248, 252,
+       174, 234, 107, 15, 247, 85, 199, 255, 215, 226, 213, 205, 202,
+       190, 158, 112, 70, 236, 242, 150, 137, 23, 99, 226, 43, 83, 121,
+       230, 108, 226, 124, 71, 222, 47, 184, 231, 231, 29, 185, 115, 248,
+       6, 212, 237, 206, 190, 156, 34, 78, 239, 23, 162, 203, 154, 103,
+       227, 57, 209, 123, 239, 61, 238, 120, 215, 143, 63, 250, 239, 239,
+       21, 173, 243, 168, 0, 138, 161, 165, 93, 41, 247, 184, 104, 150,
+       176, 197, 144, 252, 223, 96, 166, 223, 125, 251, 38, 162, 71, 235,
+       157, 79, 91, 77, 63, 22, 173, 12, 226, 175, 92, 164, 159, 205, 61,
+       198, 191, 91, 250, 17, 95, 250, 120, 87, 175, 201, 194, 51, 15,
+       253, 126, 95, 187, 111, 94, 213, 60, 222, 125, 216, 158, 89, 112,
+       46, 143, 143, 55, 53, 94, 38, 235, 222, 55, 92, 150, 226, 238,
+       100, 156, 254, 128, 157, 211, 243, 240, 211, 103, 187, 139, 170,
+       87, 173, 123, 101, 158, 190, 87, 220, 214, 255, 184, 219, 254,
+       102, 0, 120, 244, 159, 119, 21, 118, 112, 90, 241, 232, 186, 111,
+       111, 191, 69, 77, 192, 242, 87, 228, 28, 220, 254, 190, 179, 210,
+       22, 236, 155, 154, 116, 179, 127, 127, 171, 209, 55, 115, 181, 98,
+       118, 201, 11, 191, 234, 231, 117, 211, 182, 246, 173, 3, 183, 189,
+       160, 146, 157, 39, 206, 249, 19, 227, 136, 223, 73, 104, 95, 5,
+       221, 207, 49, 191, 253, 210, 221, 170, 248, 94, 205, 180, 143,
+       127, 250, 84, 206, 142, 172, 185, 172, 36, 157, 159, 22, 159, 92,
+       151, 213, 234, 123, 75, 221, 75, 63, 181, 190, 64, 75, 178, 236,
+       7, 255, 141, 156, 248, 157, 83, 213, 231, 220, 166, 170, 2, 78,
+       232, 248, 178, 169, 137, 71, 98, 203, 19, 51, 199, 76, 238, 108,
+       71, 143, 46, 248, 203, 103, 61, 44, 243, 235, 0, 216, 33, 38, 140,
+       9, 211, 54, 73, 166, 188, 198, 49, 78, 215, 226, 230, 225, 116,
+       254, 66, 78, 67, 171, 211, 243, 99, 35, 159, 18, 31, 165, 103, 65,
+       112, 175, 92, 25, 199, 1, 88, 182, 228, 199, 0, 242, 247, 35, 100,
+       116, 124, 122, 106, 73, 199, 187, 29, 17, 98, 67, 10, 2, 59, 37,
+       118, 40, 99, 110, 13, 122, 219, 179, 92, 22, 228, 92, 171, 225,
+       197, 194, 0, 123, 124, 231, 226, 68, 210, 239, 29, 110, 3, 167,
+       173, 117, 138, 28, 195, 221, 116, 23, 138, 11, 103, 103, 64, 44,
+       98, 203, 14, 94, 150, 33, 244, 96, 140, 234, 234, 105, 151, 243,
+       202, 177, 32, 139, 8, 42, 115, 37, 112, 125, 111, 252, 230, 188,
+       14, 87, 184, 82, 186, 191, 106, 83, 121, 217, 58, 93, 212, 125,
+       106, 232, 99, 201, 42, 250, 175, 101, 188, 237, 251, 210, 35, 89,
+       33, 23, 207, 15, 115, 39, 72, 102, 232, 203, 34, 221, 150, 201,
+       228, 96, 156, 126, 202, 73, 211, 243, 208, 149, 224, 171, 0, 34,
+       83, 37, 34, 228, 102, 106, 238, 126, 203, 151, 76, 142, 164, 241,
+       187, 192, 205, 111, 65, 94, 253, 107, 99, 96, 103, 203, 126, 117,
+       36, 171, 189, 85, 27, 119, 227, 205, 228, 17, 186, 153, 117, 70,
+       168, 115, 250, 137, 72, 207, 210, 73, 246, 209, 209, 252, 242,
+       111, 71, 203, 215, 187, 213, 15, 127, 26, 55, 11, 4, 245, 117,
+       236, 103, 220, 15, 79, 184, 83, 168, 189, 74, 83, 113, 217, 51,
+       93, 204, 125, 250, 232, 99, 249, 42, 251, 139, 229, 244, 101, 251,
+       82, 35, 53, 87, 109, 101, 60, 31, 79, 248, 85, 232, 255, 238, 83,
+       101, 153, 176, 62, 196, 126, 238, 233, 178, 125, 30, 178, 207, 37,
+       180, 125, 187, 82, 49, 61, 87, 79, 237, 54, 11, 199, 120, 85, 232,
+       255, 238, 83, 105, 185, 96, 126, 236, 62, 238, 233, 178, 77, 142,
+       246, 239, 161, 148, 111, 187, 112, 129, 172, 48, 216, 182, 232,
+       76, 116, 89, 34, 158, 101, 29, 21, 215, 75, 26, 141, 221, 225, 2,
+       70, 86, 218, 2, 87, 161, 117, 45, 0, 243, 142, 210, 50, 73, 148,
+       172, 141, 101, 148, 79, 143, 5, 186, 3, 238, 122, 37, 198, 200,
+       211, 175, 1, 8, 41, 83, 241, 145, 180, 90, 19, 145, 91, 141, 14,
+       89, 233, 41, 136, 61, 212, 131, 140, 94, 77, 148, 10, 186, 156,
+       254, 228, 216, 200, 156, 89, 143, 43, 245, 181, 185, 45, 42, 120,
+       85, 30, 93, 109, 100, 25, 150, 142, 201, 108, 176, 65, 136, 133,
+       169, 1, 164, 242, 33, 218, 192, 99, 234, 64, 0, 43, 210, 104, 145,
+       48, 74, 27, 144, 123, 47, 10, 114, 9, 150, 140, 189, 64, 150, 7,
+       139, 141, 186, 2, 238, 250, 37, 210, 200, 231, 236, 65, 24, 43,
+       210, 232, 177, 180, 10, 27, 144, 123, 45, 6, 114, 73, 242, 236,
+       157, 68, 94, 141, 7, 1, 218, 3, 43, 185, 117, 196, 208, 255, 189,
+       209, 94, 11, 193, 163, 179, 252, 142, 27, 183, 254, 252, 14, 199,
+       18, 255, 204, 174, 18, 169, 25, 232, 203, 87, 246, 221, 252, 190,
+       239, 182, 5, 60, 61, 177, 224, 180, 192, 12, 58, 111, 196, 158,
+       226, 161, 117, 75, 146, 237, 193, 164, 54, 237, 151, 120, 255, 94,
+       246, 217, 44, 222, 110, 87, 68, 61, 189, 145, 208, 245, 192, 78,
+       127, 254, 196, 142, 212, 212, 125, 99, 241, 73, 170, 80, 196, 107,
+       93, 3, 73, 89, 207, 48, 151, 122, 80, 92, 137, 19, 220, 83, 26,
+       248, 69, 124, 44, 172, 232, 60, 138, 176, 216, 34, 183, 97, 201,
+       241, 148, 107, 249, 11, 13, 93, 230, 8, 199, 236, 148, 92, 154,
+       131, 252, 211, 26, 248, 213, 46, 60, 128, 238, 31, 134, 182, 245,
+       58, 22, 174, 160, 229, 119, 213, 119, 17, 79, 214, 191, 30, 61,
+       178, 169, 236, 149, 149, 37, 185, 187, 33, 134, 211, 119, 248,
+       199, 231, 236, 190, 251, 246, 41, 146, 166, 213, 236, 82, 64, 17,
+       132, 184, 11, 34, 249, 101, 148, 216, 247, 196, 80, 60, 43, 208,
+       170, 187, 244, 132, 27, 227, 47, 110, 14, 31, 90, 255, 227, 230,
+       70, 125, 23, 45, 255, 119, 246, 25, 63, 206, 235, 111, 223, 183,
+       156, 145, 220, 49, 224, 79, 219, 254, 194, 175, 208, 225, 249,
+       251, 60, 122, 172, 63, 54, 156, 87, 89, 202, 220, 187, 30, 156,
+       54, 173, 206, 181, 213, 37, 188, 47, 164, 142, 243, 121, 58, 191,
+       71, 76, 187, 247, 141, 20, 127, 108, 71, 126, 125, 25, 253, 70,
+       117, 4, 91, 111, 63, 125, 58, 168, 23, 172, 165, 180, 60, 222, 71,
+       219, 67, 4, 127, 246, 102, 244, 41, 20, 109, 173, 228, 110, 221,
+       55, 21, 239, 254, 118, 219, 61, 154, 105, 94, 181, 23, 165, 185,
+       180, 113, 142, 199, 251, 250, 128, 255, 253, 208, 241, 158, 36,
+       120, 248, 7, 241, 91, 33, 153, 198, 13, 10, 253, 79, 51, 117, 86,
+       185, 145, 170, 41, 6, 126, 222, 195, 217, 139, 41, 54, 172, 92,
+       114, 59, 22, 255, 225, 226, 118, 125, 87, 61, 207, 246, 246, 31,
+       55, 183, 253, 238, 157, 151, 188, 185, 158, 49, 192, 211, 251,
+       242, 132, 171, 212, 228, 249, 249, 150, 252, 225, 164, 126, 125,
+       182, 125, 111, 246, 254, 223, 61, 158, 255, 111, 214, 247, 44,
+       189, 252, 117, 198, 214, 251, 112, 212, 239, 220, 220, 125, 153,
+       20, 121, 237, 44, 119, 93, 121, 93, 78, 213, 14, 159, 31, 179,
+       113, 126, 152, 31, 172, 169, 134, 117, 223, 215, 233, 170, 156,
+       54, 168, 116, 113, 191, 158, 236, 243, 247, 255, 127, 247, 27,
+       255, 180, 191, 94, 61, 207, 47, 239, 247, 223, 149, 189, 239, 121,
+       254, 255, 95, 255, 247, 167, 204, 253, 127, 207, 190, 251, 212,
+       247, 116, 255, 255, 27, 207, 188, 127, 252, 255, 250, 173, 191,
+       251, 151, 141, 183, 111, 186, 235, 127, 95, 191, 187, 143, 252,
+       239, 255, 152, 216, 170, 226, 21, 85, 119, 228, 21, 117, 166, 3,
+       59, 159, 106, 32, 233, 218, 139, 210, 79, 63, 184, 163, 251, 197,
+       150, 55, 51, 28, 252, 122, 143, 159, 236, 242, 245, 247, 255, 255,
+       91, 255, 60, 255, 253, 127, 187, 37, 255, 243, 151, 189, 181, 122,
+       60, 255, 255, 223, 255, 230, 158, 252, 141, 255, 77, 159, 253,
+       158, 238, 220, 253, 191, 155, 223, 124, 247, 252, 255, 190, 103,
+       55, 247, 183, 157, 245, 104, 47, 255, 238, 127, 127, 201, 223,
+       252, 237, 251, 36, 13, 245, 91, 253, 249, 131, 206, 79, 132, 120,
+       2, 32, 252, 53, 164, 200, 122, 18, 81, 179, 42, 118, 189, 45, 28,
+       132, 122, 213, 89, 86, 238, 67, 208, 85, 133, 46, 31, 172, 164,
+       205, 114, 18, 230, 204, 12, 190, 231, 6, 68, 250, 111, 197, 177,
+       125, 253, 38, 58, 95, 150, 30, 190, 25, 93, 124, 17, 251, 104,
+       157, 70, 213, 203, 65, 197, 238, 2, 83, 189, 127, 82, 248, 148,
+       161, 48, 27, 163, 179, 130, 123, 237, 133, 95, 225, 104, 244, 66,
+       15, 254, 247, 147, 181, 222, 255, 191, 123, 238, 158, 103, 255,
+       254, 219, 229, 127, 255, 190, 223, 245, 236, 188, 238, 239, 95,
+       255, 210, 142, 245, 133, 125, 111, 223, 228, 222, 253, 126, 126,
+       184, 59, 218, 180, 255, 238, 126, 143, 183, 191, 211, 247, 230,
+       245, 98, 126, 255, 255, 127, 239, 191, 154, 245, 79, 215, 167, 13,
+       53, 219, 221, 245, 130, 234, 222, 65, 120, 66, 176, 124, 53, 165,
+       200, 122, 18, 81, 179, 170, 122, 189, 45, 24, 138, 122, 213, 73,
+       84, 236, 46, 190, 232, 182, 237, 253, 215, 249, 155, 206, 181,
+       191, 239, 253, 235, 175, 255, 243, 223, 150, 244, 111, 234, 234,
+       255, 95, 231, 251, 199, 253, 221, 247, 36, 244, 49, 67, 240, 237,
+       161, 207, 94, 61, 45, 24, 150, 212, 204, 52, 153, 26, 2, 24, 19,
+       56, 120, 85, 45, 156, 21, 110, 192, 10, 135, 229, 245, 156, 189,
+       250, 252, 116, 159, 254, 218, 222, 180, 51, 241, 127, 235, 99,
+       255, 211, 223, 162, 254, 111, 122, 255, 251, 207, 247, 255, 181,
+       241, 231, 219, 132, 180, 251, 236, 254, 102, 255, 250, 154, 206,
+       28, 31, 213, 247, 123, 34, 55, 95, 23, 47, 240, 79, 184, 110, 125,
+       143, 47, 188, 148, 250, 39, 251, 40, 158, 105, 197, 114, 115, 63,
+       119, 16, 239, 124, 190, 121, 55, 134, 180, 95, 254, 151, 168, 185,
+       158, 112, 143, 111, 239, 225, 192, 167, 174, 214, 249, 33, 181,
+       49, 203, 125, 253, 161, 206, 79, 121, 120, 66, 182, 28, 172, 37,
+       201, 26, 2, 17, 39, 56, 121, 181, 45, 24, 16, 118, 80, 72, 213,
+       237, 22, 224, 212, 237, 126, 43, 232, 200, 127, 144, 248, 67, 79,
+       202, 93, 194, 251, 205, 63, 181, 10, 119, 203, 217, 156, 154, 207,
+       46, 125, 123, 97, 128, 50, 57, 148, 197, 143, 39, 148, 111, 203,
+       184, 152, 66, 174, 184, 85, 47, 204, 255, 127, 195, 216, 235, 219,
+       224, 169, 144, 207, 50, 13, 122, 185, 143, 83, 18, 135, 180, 52,
+       6, 8, 126, 27, 233, 146, 253, 196, 42, 148, 200, 183, 103, 109,
+       133, 181, 203, 129, 221, 152, 54, 251, 210, 12, 4, 57, 93, 32,
+       181, 49, 75, 244, 207, 161, 239, 94, 53, 105, 24, 146, 20, 172,
+       36, 145, 26, 2, 24, 179, 56, 125, 85, 45, 28, 17, 102, 80, 10,
+       197, 237, 195, 68, 229, 159, 14, 100, 169, 14, 156, 210, 82, 147,
+       253, 110, 61, 107, 103, 103, 59, 141, 161, 196, 55, 234, 5, 42,
+       218, 128, 181, 245, 49, 124, 64, 100, 220, 247, 116, 46, 235, 30,
+       62, 161, 115, 96, 245, 19, 144, 25, 63, 125, 127, 40, 32, 212, 9,
+       111, 204, 175, 251, 192, 132, 136, 1, 169, 197, 123, 153, 209,
+       234, 4, 44, 157, 126, 184, 82, 100, 212, 210, 193, 239, 183, 79,
+       46, 94, 195, 80, 155, 80, 12, 136, 111, 172, 8, 240, 9, 173, 202,
+       190, 179, 90, 187, 249, 56, 199, 191, 31, 132, 176, 172, 198, 228,
+       220, 167, 59, 234, 144, 50, 77, 162, 243, 159, 214, 26, 123, 146,
+       68, 167, 253, 1, 132, 153, 231, 116, 14, 111, 49, 116, 171, 95,
+       112, 245, 51, 128, 96, 23, 126, 22, 42, 177, 184, 201, 47, 237,
+       175, 99, 128, 0, 171, 129, 161, 22, 35, 148, 136, 172, 11, 156,
+       207, 206, 158, 184, 65, 142, 202, 245, 143, 203, 75, 78, 95, 70,
+       99, 74, 208, 176, 152, 79, 63, 208, 122, 169, 141, 97, 161, 169,
+       65, 140, 157, 192, 174, 195, 57, 134, 26, 178, 25, 220, 98, 201,
+       70, 120, 88, 78, 106, 235, 49, 15, 24, 149, 127, 192, 8, 208, 46,
+       131, 76, 7, 158, 13, 198, 237, 37, 212, 90, 195, 82, 240, 242, 52,
+       111, 200, 36, 58, 171, 237, 199, 118, 207, 33, 58, 218, 0, 16, 48,
+       240, 236, 133, 78, 22, 25, 248, 175, 160, 158, 236, 27, 114, 84,
+       196, 66, 169, 75, 197, 1, 106, 60, 178, 229, 75, 117, 12, 58, 115,
+       68, 216, 25, 33, 129, 29, 93, 126, 89, 180, 95, 255, 253, 85, 90,
+       116, 34, 91, 93, 183, 41, 190, 24, 151, 123, 229, 176, 45, 156,
+       99, 203, 101, 133, 119, 252, 244, 239, 223, 91, 172, 157, 176, 22,
+       111, 157, 54, 254, 86, 229, 209, 70, 211, 107, 116, 76, 61, 222,
+       231, 212, 189, 8, 234, 169, 175, 132, 8, 240, 181, 121, 101, 248,
+       168, 160, 172, 61, 84, 154, 66, 254, 156, 12, 210, 120, 75, 42,
+       217, 196, 108, 55, 143, 103, 251, 16, 219, 215, 229, 61, 208, 121,
+       92, 67, 196, 188, 172, 177, 188, 108, 181, 159, 154, 247, 14, 31,
+       212, 253, 82, 74, 129, 70, 121, 21, 54, 109, 251, 34, 111, 143,
+       255, 117, 128, 104, 213, 218, 246, 224, 158, 242, 155, 228, 88,
+       206, 171, 185, 162, 19, 70, 219, 108, 82, 233, 245, 125, 145, 10,
+       103, 138, 247, 153, 210, 159, 127, 161, 9, 45, 2, 173, 89, 239,
+       221, 164, 94, 127, 157, 84, 94, 86, 166, 91, 125, 183, 104, 87,
+       68, 53, 111, 197, 144, 61, 130, 99, 239, 229, 132, 190, 253, 240,
+       113, 60, 149, 165, 187, 161, 111, 77, 159, 22, 119, 75, 17, 215,
+       119, 40, 91, 209, 215, 61, 55, 56, 208, 89, 48, 237, 227, 253,
+       212, 176, 121, 148, 114, 220, 164, 156, 178, 185, 108, 80, 11,
+       162, 183, 135, 25, 223, 51, 74, 91, 129, 151, 237, 49, 62, 73,
+       219, 0, 233, 243, 127, 87, 162, 64, 143, 66, 80, 181, 29, 230,
+       169, 78, 95, 49, 161, 184, 143, 8, 247, 119, 8, 115, 132, 247,
+       125, 98, 89, 75, 219, 173, 253, 241, 77, 18, 40, 99, 134, 51, 192,
+       188, 172, 177, 188, 165, 223, 191, 146, 191, 12, 29, 212, 239, 82,
+       2, 65, 70, 121, 29, 242, 76, 251, 55, 237, 143, 191, 253, 144, 64,
+       150, 90, 79, 20, 249, 165, 162, 110, 57, 19, 56, 235, 31, 245,
+       221, 63, 219, 122, 183, 23, 61, 189, 149, 208, 181, 66, 207, 239,
+       122, 196, 172, 228, 129, 113, 88, 16, 127, 229, 166, 110, 249, 19,
+       44, 106, 95, 50, 221, 63, 159, 106, 118, 21, 61, 169, 128, 177,
+       49, 192, 211, 239, 250, 133, 165, 224, 101, 99, 60, 84, 126, 237,
+       46, 110, 113, 120, 228, 174, 247, 34, 87, 19, 33, 91, 122, 180,
+       110, 42, 72, 181, 49, 12, 211, 239, 99, 17, 97, 187, 100, 35, 254,
+       4, 98, 238, 61, 61, 222, 112, 137, 42, 153, 58, 255, 121, 60, 227,
+       222, 115, 149, 107, 232, 35, 64, 255, 179, 249, 202, 187, 23, 255,
+       89, 163, 165, 102, 168, 19, 100, 63, 224, 218, 94, 255, 52, 95,
+       194, 104, 223, 41, 153, 72, 82, 31, 164, 244, 127, 34, 14, 31,
+       245, 36, 197, 253, 90, 197, 163, 76, 101, 95, 13, 212, 198, 166,
+       221, 210, 160, 82, 176, 88, 181, 239, 201, 96, 58, 75, 237, 231,
+       119, 239, 35, 58, 215, 27, 31, 125, 120, 236, 66, 184, 157, 186,
+       170, 237, 20, 135, 190, 91, 128, 253, 166, 246, 67, 91, 135, 115,
+       236, 1, 55, 78, 218, 117, 141, 150, 94, 59, 152, 80, 135, 95, 164,
+       56, 185, 209, 252, 239, 209, 202, 94, 249, 52, 24, 146, 157, 69,
+       40, 217, 25, 22, 16, 51, 124, 123, 86, 79, 159, 49, 117, 208, 9,
+       70, 179, 166, 176, 57, 211, 237, 253, 217, 192, 95, 121, 21, 26,
+       146, 157, 116, 40, 205, 24, 23, 27, 159, 124, 122, 240, 79, 27,
+       145, 127, 213, 137, 84, 246, 167, 248, 169, 218, 237, 253, 251,
+       216, 223, 127, 21, 26, 158, 220, 127, 172, 217, 24, 179, 95, 151,
+       118, 254, 176, 15, 89, 217, 127, 214, 29, 84, 246, 64, 113, 199,
+       23, 139, 98, 5, 7, 54, 167, 75, 164, 224, 160, 195, 206, 83, 110,
+       104, 144, 13, 208, 199, 8, 4, 34, 85, 3, 169, 112, 132, 12, 152,
+       92, 126, 252, 118, 195, 121, 112, 180, 6, 247, 163, 127, 223, 33,
+       65, 126, 185, 135, 226, 104, 183, 0, 204, 211, 227, 98, 1, 101,
+       171, 37, 179, 40, 205, 20, 254, 77, 193, 212, 239, 215, 23, 236,
+       3, 98, 249, 44, 5, 217, 50, 130, 0, 74, 43, 90, 189, 99, 219, 80,
+       59, 83, 90, 252, 138, 94, 182, 156, 33, 170, 110, 120, 27, 59,
+       255, 191, 253, 157, 47, 74, 27, 167, 157, 237, 177, 60, 196, 209,
+       64, 222, 195, 125, 247, 232, 224, 143, 19, 13, 180, 16, 105, 249,
+       239, 50, 154, 126, 121, 109, 24, 223, 117, 72, 56, 145, 27, 82,
+       48, 51, 62, 89, 23, 205, 223, 21, 108, 218, 65, 11, 130, 47, 164,
+       160, 89, 253, 113, 209, 75, 91, 119, 85, 26, 136, 24, 222, 172,
+       217, 136, 146, 61, 191, 118, 108, 146, 15, 95, 155, 111, 215, 77,
+       222, 228, 238, 241, 249, 242, 203, 125, 156, 220, 139, 255, 20,
+       175, 44, 253, 79, 154, 183, 219, 247, 145, 135, 67, 186, 226, 95,
+       85, 93, 191, 142, 126, 13, 123, 166, 4, 239, 82, 196, 98, 231,
+       200, 212, 150, 247, 18, 80, 248, 189, 47, 89, 196, 50, 171, 168,
+       231, 62, 202, 65, 26, 195, 4, 197, 121, 116, 228, 174, 107, 104,
+       90, 207, 241, 255, 200, 83, 84, 124, 171, 8, 204, 255, 44, 91,
+       234, 147, 215, 198, 50, 238, 241, 126, 89, 133, 239, 119, 255,
+       126, 198, 86, 173, 19, 160, 209, 141, 96, 231, 59, 161, 168, 9, 6,
+       146, 64, 144, 177, 191, 74, 144, 126, 75, 128, 94, 185, 148, 15,
+       127, 128, 0, 171, 14, 45, 148, 17, 233, 253, 239, 179, 59, 86,
+       121, 125, 24, 223, 61, 104, 48, 217, 26, 18, 24, 19, 58, 89, 151,
+       205, 223, 51, 108, 218, 8, 201, 178, 79, 80, 146, 242, 225, 53,
+       188, 196, 175, 187, 147, 90, 156, 158, 105, 170, 175, 145, 191,
+       151, 135, 87, 154, 192, 151, 221, 222, 238, 142, 87, 169, 131,
+       174, 125, 232, 82, 255, 209, 149, 222, 155, 238, 52, 189, 40, 221,
+       71, 27, 143, 121, 213, 80, 246, 78, 250, 234, 123, 81, 149, 187,
+       135, 220, 222, 255, 170, 126, 107, 82, 237, 219, 213, 230, 147,
+       254, 180, 57, 10, 157, 199, 63, 137, 250, 197, 18, 108, 111, 232,
+       170, 123, 91, 181, 251, 71, 92, 94, 255, 175, 125, 113, 82, 211,
+       249, 70, 228, 105, 178, 105, 72, 106, 84, 205, 181, 191, 250, 130,
+       114, 235, 50, 124, 254, 63, 88, 5, 106, 251, 223, 194, 173, 116,
+       45, 174, 254, 221, 228, 87, 226, 192, 130, 204, 2, 179, 249, 49,
+       106, 200, 238, 57, 203, 8, 235, 242, 40, 227, 175, 206, 9, 129,
+       121, 112, 42, 47, 160, 196, 155, 205, 53, 232, 88, 23, 115, 85,
+       151, 8, 76, 94, 172, 217, 8, 147, 157, 151, 118, 127, 208, 14, 30,
+       155, 238, 159, 13, 250, 214, 39, 167, 104, 138, 93, 181, 154, 200,
+       75, 77, 253, 207, 8, 200, 254, 128, 221, 137, 146, 245, 150, 35,
+       92, 213, 62, 29, 139, 255, 223, 15, 122, 212, 186, 94, 74, 170,
+       87, 134, 90, 64, 149, 4, 241, 167, 109, 207, 39, 193, 254, 185,
+       151, 231, 108, 135, 16, 222, 243, 241, 138, 139, 55, 15, 44, 210,
+       218, 121, 3, 190, 27, 213, 26, 100, 189, 128, 192, 129, 172, 206,
+       33, 208, 230, 249, 203, 195, 110, 139, 26, 255, 179, 245, 138, 27,
+       18, 6, 43, 30, 196, 132, 173, 189, 140, 106, 77, 43, 190, 55, 131,
+       17, 215, 111, 24, 75, 129, 7, 105, 5, 48, 77, 235, 23, 201, 179,
+       94, 85, 128, 104, 149, 114, 57, 181, 48, 35, 133, 159, 71, 59,
+       119, 111, 45, 28, 254, 241, 90, 148, 17, 138, 100, 44, 219, 184,
+       251, 151, 175, 223, 21, 118, 106, 142, 210, 100, 41, 148, 49, 255,
+       117, 173, 225, 123, 87, 73, 125, 86, 254, 241, 56, 228, 89, 10,
+       50, 13, 179, 186, 123, 215, 125, 60, 146, 108, 91, 140, 240, 176,
+       187, 6, 98, 169, 87, 54, 248, 82, 21, 70, 217, 151, 9, 12, 54,
+       137, 126, 141, 151, 165, 173, 182, 53, 202, 18, 105, 154, 199, 63,
+       204, 120, 214, 67, 137, 135, 159, 153, 212, 46, 166, 190, 129,
+       138, 1, 172, 190, 101, 226, 192, 119, 232, 193, 87, 201, 179, 237,
+       169, 119, 222, 91, 128, 20, 173, 14, 67, 177, 150, 159, 252, 132,
+       186, 135, 174, 17, 91, 242, 252, 250, 108, 66, 231, 91, 123, 145,
+       18, 73, 130, 225, 44, 52, 158, 234, 140, 66, 161, 131, 193, 180,
+       158, 213, 164, 46, 172, 159, 254, 179, 2, 84, 213, 34, 88, 107,
+       183, 69, 120, 173, 177, 220, 149, 66, 108, 43, 95, 68, 140, 192,
+       169, 16, 173, 180, 213, 86, 117, 123, 230, 184, 223, 202, 55, 114,
+       104, 249, 157, 165, 27, 118, 178, 42, 165, 229, 62, 223, 46, 95,
+       69, 94, 207, 239, 88, 134, 13, 100, 247, 95, 61, 123, 194, 120,
+       87, 235, 247, 112, 88, 117, 156, 173, 19, 92, 246, 42, 161, 245,
+       47, 255, 107, 62, 113, 212, 198, 245, 252, 37, 37, 53, 128, 128,
+       245, 189, 226, 216, 90, 233, 57, 77, 150, 248, 95, 168, 153, 10,
+       82, 125, 151, 114, 220, 146, 30, 28, 5, 110, 205, 79, 91, 214, 15,
+       221, 244, 246, 183, 55, 158, 191, 23, 210, 29, 163, 249, 125, 187,
+       101, 95, 115, 181, 255, 244, 120, 108, 175, 107, 223, 93, 195,
+       183, 255, 165, 123, 47, 163, 96, 139, 221, 149, 186, 201, 78, 73,
+       89, 207, 168, 200, 126, 132, 220, 11, 147, 149, 150, 58, 94, 213,
+       46, 93, 138, 239, 223, 14, 251, 214, 151, 41, 235, 164, 209, 214,
+       111, 192, 164, 192, 206, 2, 25, 214, 115, 112, 120, 237, 59, 223,
+       157, 155, 180, 106, 123, 45, 143, 0, 165, 55, 179, 244, 159, 105,
+       171, 164, 199, 214, 111, 196, 229, 192, 206, 2, 57, 190, 115, 228,
+       106, 237, 59, 207, 205, 155, 182, 234, 185, 109, 143, 128, 39, 55,
+       48, 236, 6, 153, 183, 217, 236, 165, 188, 239, 142, 25, 88, 243,
+       220, 252, 60, 74, 207, 115, 51, 149, 146, 120, 26, 241, 12, 62,
+       223, 206, 148, 104, 177, 177, 205, 220, 157, 215, 182, 110, 7,
+       182, 248, 242, 39, 16, 254, 118, 131, 43, 39, 119, 124, 42, 241,
+       236, 249, 110, 237, 175, 117, 16, 136, 241, 129, 121, 102, 167,
+       236, 82, 220, 31, 94, 173, 27, 191, 189, 25, 66, 109, 94, 26, 153,
+       198, 125, 28, 62, 107, 233, 54, 59, 31, 149, 255, 128, 234, 222,
+       102, 18, 22, 206, 149, 34, 50, 184, 18, 188, 198, 151, 247, 205,
+       46, 183, 203, 119, 37, 237, 165, 164, 197, 5, 202, 128, 99, 251,
+       131, 173, 229, 61, 85, 215, 105, 227, 166, 211, 212, 239, 228,
+       165, 192, 206, 130, 121, 238, 51, 100, 110, 239, 59, 207, 205,
+       155, 180, 234, 185, 108, 142, 136, 37, 183, 49, 252, 30, 227, 233,
+       169, 54, 67, 139, 253, 6, 101, 217, 227, 85, 7, 184, 32, 127, 157,
+       23, 253, 219, 154, 45, 28, 248, 197, 175, 228, 181, 138, 181, 240,
+       3, 18, 110, 154, 122, 144, 184, 69, 173, 89, 83, 247, 172, 206,
+       190, 232, 230, 51, 247, 149, 135, 158, 6, 197, 22, 58, 250, 203,
+       221, 132, 41, 157, 48, 69, 84, 229, 197, 106, 228, 7, 193, 6, 186,
+       19, 43, 41, 21, 90, 232, 167, 72, 162, 108, 161, 65, 202, 53, 248,
+       146, 3, 101, 89, 248, 130, 42, 176, 179, 250, 67, 229, 184, 195,
+       155, 89, 113, 59, 28, 223, 108, 8, 239, 27, 147, 145, 19, 58, 26,
+       241, 95, 89, 26, 235, 223, 13, 173, 211, 85, 195, 249, 111, 26,
+       11, 79, 188, 6, 224, 120, 202, 119, 69, 153, 98, 54, 92, 117, 238,
+       195, 48, 253, 61, 109, 172, 37, 52, 117, 186, 1, 56, 151, 111, 75,
+       0, 146, 143, 239, 240, 189, 224, 246, 199, 25, 135, 119, 21, 54,
+       237, 95, 254, 241, 181, 148, 110, 248, 200, 15, 196, 105, 177,
+       163, 208, 52, 133, 236, 170, 158, 99, 71, 203, 6, 69, 157, 35,
+       115, 97, 43, 64, 121, 194, 31, 247, 26, 131, 79, 63, 248, 197,
+       165, 93, 181, 75, 244, 98, 139, 22, 103, 133, 118, 54, 168, 51,
+       93, 202, 94, 231, 201, 44, 183, 239, 126, 37, 150, 173, 165, 244,
+       37, 204, 6, 122, 235, 128, 47, 236, 121, 213, 95, 142, 164, 30,
+       181, 182, 222, 169, 91, 190, 149, 23, 232, 104, 159, 237, 221,
+       231, 189, 141, 254, 106, 238, 255, 186, 127, 223, 247, 159, 100,
+       121, 68, 43, 163, 136, 187, 245, 181, 184, 79, 15, 93, 89, 231,
+       168, 232, 126, 132, 221, 11, 147, 149, 150, 58, 78, 241, 14, 85,
+       154, 239, 223, 78, 249, 213, 35, 18, 98, 201, 118, 211, 161, 83,
+       70, 77, 252, 226, 8, 152, 182, 228, 106, 136, 18, 137, 130, 187,
+       37, 209, 22, 12, 162, 170, 87, 140, 116, 237, 43, 130, 98, 204,
+       126, 211, 161, 72, 206, 73, 220, 226, 0, 220, 180, 228, 250, 40,
+       147, 57, 130, 187, 38, 221, 20, 44, 170, 143, 85, 142, 117, 237,
+       10, 133, 180, 157, 191, 235, 165, 175, 31, 23, 74, 48, 236, 113,
+       46, 205, 131, 18, 163, 0, 114, 216, 99, 247, 45, 118, 86, 67, 146,
+       76, 149, 238, 58, 147, 114, 252, 119, 221, 240, 115, 157, 13, 124,
+       43, 46, 253, 38, 4, 190, 187, 151, 0, 142, 185, 50, 157, 83, 223,
+       0, 195, 119, 140, 68, 219, 151, 78, 110, 157, 2, 50, 186, 96, 140,
+       198, 198, 231, 109, 110, 183, 71, 102, 117, 155, 231, 228, 197,
+       37, 206, 22, 35, 203, 128, 37, 245, 57, 212, 8, 143, 116, 255,
+       118, 147, 166, 252, 86, 12, 120, 230, 225, 232, 160, 192, 219,
+       107, 162, 65, 178, 184, 79, 191, 44, 103, 175, 131, 117, 170, 85,
+       137, 116, 115, 61, 101, 52, 78, 83, 56, 96, 232, 242, 110, 83, 21,
+       137, 48, 124, 212, 37, 234, 201, 178, 233, 12, 241, 235, 225, 132,
+       105, 171, 84, 115, 156, 127, 119, 97, 242, 155, 54, 242, 249, 166,
+       114, 238, 15, 173, 161, 145, 63, 253, 134, 115, 245, 253, 36, 238,
+       126, 195, 39, 196, 111, 185, 167, 177, 50, 181, 40, 168, 91, 209,
+       152, 111, 31, 77, 248, 175, 44, 142, 38, 16, 238, 187, 135, 133,
+       62, 11, 82, 223, 187, 84, 154, 251, 81, 4, 46, 223, 98, 169, 236,
+       137, 223, 217, 184, 7, 206, 117, 92, 135, 160, 140, 86, 70, 200,
+       47, 179, 149, 214, 24, 231, 209, 14, 56, 158, 235, 21, 12, 221,
+       222, 180, 252, 169, 168, 207, 69, 213, 223, 18, 118, 128, 27, 22,
+       61, 99, 9, 105, 200, 3, 117, 106, 110, 243, 19, 249, 131, 85, 126,
+       241, 120, 246, 242, 57, 79, 106, 108, 148, 195, 223, 236, 64, 196,
+       248, 163, 115, 108, 179, 48, 220, 251, 4, 227, 204, 170, 100, 61,
+       225, 229, 175, 169, 117, 187, 118, 200, 153, 157, 99, 191, 86,
+       162, 169, 103, 116, 197, 90, 247, 49, 170, 182, 65, 126, 107, 34,
+       133, 228, 250, 53, 47, 108, 46, 254, 128, 37, 72, 53, 206, 66, 10,
+       62, 183, 86, 137, 185, 71, 172, 133, 83, 175, 61, 138, 51, 72,
+       166, 33, 115, 149, 132, 217, 6, 76, 84, 34, 250, 137, 5, 8, 37,
+       203, 98, 88, 123, 226, 118, 203, 121, 69, 44, 236, 115, 171, 23,
+       159, 53, 80, 206, 185, 23, 193, 72, 186, 64, 76, 85, 136, 186,
+       160, 85, 2, 70, 251, 216, 28, 58, 254, 37, 165, 85, 119, 156, 14,
+       215, 28, 190, 255, 42, 97, 229, 51, 159, 2, 226, 15, 18, 255, 211,
+       251, 122, 155, 16, 72, 41, 43, 135, 240, 150, 242, 238, 12, 188,
+       216, 138, 27, 49, 82, 220, 219, 109, 11, 165, 81, 119, 211, 131,
+       69, 138, 240, 93, 18, 127, 238, 201, 51, 11, 163, 2, 176, 187,
+       250, 203, 229, 185, 75, 158, 95, 85, 51, 140, 223, 108, 140, 239,
+       27, 147, 145, 18, 15, 178, 211, 29, 20, 154, 235, 149, 12, 167,
+       243, 40, 178, 66, 233, 116, 185, 232, 83, 79, 37, 118, 231, 137,
+       139, 244, 80, 110, 168, 6, 156, 134, 186, 68, 209, 70, 221, 178,
+       224, 255, 136, 98, 153, 34, 179, 122, 73, 118, 139, 178, 122, 95,
+       1, 120, 238, 96, 201, 180, 68, 126, 56, 3, 40, 130, 186, 7, 157,
+       110, 14, 33, 235, 127, 136, 120, 141, 188, 191, 94, 225, 246, 219,
+       118, 249, 93, 226, 119, 254, 87, 25, 174, 177, 127, 124, 150, 114,
+       241, 181, 13, 190, 126, 203, 101, 245, 127, 185, 218, 145, 35,
+       143, 232, 85, 244, 155, 252, 167, 95, 175, 118, 255, 168, 40, 182,
+       48, 47, 174, 150, 13, 180, 184, 36, 255, 46, 30, 116, 227, 213,
+       204, 217, 205, 39, 107, 170, 1, 244, 143, 235, 22, 90, 237, 118,
+       141, 145, 136, 215, 56, 204, 110, 55, 221, 220, 250, 228, 96, 108,
+       29, 173, 192, 204, 189, 210, 213, 109, 9, 231, 117, 160, 46, 78,
+       182, 48, 179, 102, 64, 219, 53, 145, 251, 5, 214, 125, 110, 249,
+       216, 209, 32, 99, 239, 244, 4, 226, 241, 210, 32, 160, 81, 113,
+       105, 102, 71, 249, 81, 101, 96, 240, 74, 27, 29, 53, 112, 126,
+       189, 23, 233, 201, 182, 81, 206, 85, 168, 32, 0, 117, 138, 114,
+       179, 35, 219, 58, 91, 116, 157, 176, 71, 95, 73, 86, 102, 172,
+       152, 182, 228, 198, 42, 178, 29, 199, 184, 38, 245, 14, 56, 18,
+       195, 30, 140, 217, 205, 189, 75, 110, 164, 30, 66, 223, 248, 196,
+       228, 151, 179, 83, 76, 187, 35, 126, 213, 93, 227, 236, 231, 45,
+       44, 240, 161, 239, 149, 101, 187, 118, 64, 157, 221, 103, 45, 182,
+       66, 207, 240, 100, 228, 222, 167, 91, 121, 179, 69, 122, 228, 93,
+       231, 232, 177, 37, 172, 240, 233, 175, 148, 111, 255, 240, 83,
+       147, 77, 110, 158, 86, 82, 238, 228, 149, 70, 210, 131, 105, 10,
+       55, 65, 106, 233, 19, 239, 108, 159, 52, 253, 115, 40, 202, 129,
+       53, 191, 125, 204, 7, 176, 146, 251, 179, 165, 184, 218, 30, 25,
+       81, 84, 220, 243, 104, 40, 213, 27, 51, 17, 19, 92, 26, 243, 141,
+       150, 91, 238, 152, 75, 129, 163, 1, 170, 27, 179, 100, 173, 120,
+       83, 127, 65, 113, 92, 191, 131, 114, 216, 198, 43, 6, 28, 151,
+       184, 242, 215, 142, 220, 18, 72, 136, 136, 67, 221, 162, 161, 81,
+       89, 211, 209, 182, 239, 31, 37, 97, 155, 72, 231, 108, 148, 123,
+       155, 130, 176, 114, 126, 46, 247, 63, 70, 23, 111, 247, 4, 166,
+       230, 11, 30, 3, 187, 49, 182, 232, 81, 53, 74, 209, 231, 168, 78,
+       183, 205, 220, 169, 151, 141, 175, 150, 84, 223, 134, 126, 186,
+       130, 30, 132, 56, 221, 28, 206, 39, 165, 151, 78, 47, 179, 52,
+       230, 218, 199, 207, 39, 49, 196, 119, 101, 141, 175, 233, 157, 37,
+       174, 232, 230, 175, 132, 38, 244, 181, 121, 24, 170, 145, 173, 51,
+       202, 105, 34, 38, 161, 74, 227, 157, 167, 0, 192, 114, 61, 237,
+       136, 0, 152, 193, 129, 205, 229, 43, 228, 34, 164, 5, 163, 40,
+       112, 81, 233, 116, 79, 233, 82, 32, 0, 112, 66, 23, 23, 0, 32,
+       126, 156, 23, 41, 1, 178, 81, 220, 213, 172, 42, 4, 109, 138, 50,
+       177, 175, 64, 99, 204, 116, 23, 234, 88, 77, 8, 112, 98, 89, 89,
+       181, 164, 126, 152, 23, 239, 193, 182, 4, 206, 52, 56, 163, 132,
+       127, 187, 114, 165, 146, 73, 111, 188, 3, 70, 191, 96, 180, 214,
+       194, 131, 121, 223, 49, 75, 104, 245, 59, 227, 96, 213, 22, 237,
+       241, 34, 202, 1, 53, 49, 53, 250, 174, 178, 174, 184, 79, 241,
+       185, 200, 158, 95, 85, 187, 140, 220, 127, 11, 239, 25, 179, 149,
+       150, 71, 138, 208, 95, 81, 219, 239, 151, 13, 61, 215, 138, 176,
+       187, 219, 107, 228, 185, 66, 158, 91, 85, 49, 188, 215, 104, 109,
+       231, 59, 187, 145, 19, 77, 186, 209, 205, 17, 26, 235, 146, 5, 45,
+       243, 39, 143, 101, 216, 237, 243, 206, 234, 223, 121, 252, 114,
+       200, 108, 180, 237, 205, 194, 190, 255, 189, 98, 111, 253, 62, 26,
+       199, 223, 215, 253, 248, 69, 30, 107, 115, 68, 114, 211, 63, 212,
+       39, 172, 94, 234, 45, 199, 227, 52, 54, 253, 183, 194, 192, 147,
+       44, 248, 112, 4, 175, 175, 39, 183, 39, 105, 65, 217, 151, 129,
+       56, 12, 43, 148, 170, 233, 2, 228, 149, 135, 193, 102, 70, 68,
+       124, 92, 209, 153, 247, 32, 172, 188, 38, 196, 136, 146, 161, 121,
+       154, 183, 254, 116, 186, 251, 57, 175, 191, 213, 126, 189, 111,
+       239, 230, 147, 55, 127, 229, 20, 54, 205, 175, 95, 90, 195, 117,
+       239, 231, 228, 143, 91, 65, 56, 187, 219, 49, 188, 57, 3, 254, 65,
+       103, 20, 188, 146, 98, 108, 163, 43, 122, 28, 147, 220, 178, 193,
+       205, 190, 26, 66, 152, 0, 129, 108, 167, 141, 100, 152, 223, 241,
+       178, 234, 223, 81, 200, 27, 40, 248, 62, 173, 235, 195, 243, 119,
+       183, 107, 126, 245, 63, 26, 219, 111, 223, 77, 249, 198, 222, 223,
+       71, 196, 157, 214, 78, 240, 133, 200, 158, 194, 74, 103, 181, 231,
+       116, 244, 221, 234, 233, 129, 25, 236, 179, 112, 197, 150, 46,
+       255, 188, 53, 30, 156, 134, 237, 179, 90, 70, 187, 55, 162, 142,
+       230, 207, 55, 129, 228, 115, 212, 236, 170, 105, 217, 25, 175,
+       170, 247, 135, 150, 170, 244, 168, 52, 138, 152, 190, 219, 107,
+       245, 185, 66, 190, 25, 69, 16, 188, 151, 104, 110, 231, 59, 187,
+       152, 19, 77, 178, 241, 199, 179, 90, 75, 144, 1, 45, 171, 103,
+       149, 70, 152, 207, 240, 190, 235, 159, 83, 157, 183, 72, 248, 190,
+       239, 251, 195, 187, 231, 151, 35, 30, 245, 26, 122, 207, 223, 159,
+       109, 249, 214, 27, 121, 234, 164, 3, 22, 110, 117, 228, 192, 207,
+       135, 121, 206, 51, 208, 124, 237, 219, 239, 205, 147, 148, 200,
+       243, 109, 143, 0, 47, 182, 59, 220, 94, 185, 106, 166, 19, 54,
+       122, 240, 33, 228, 143, 135, 73, 235, 119, 68, 127, 229, 185, 255,
+       140, 147, 156, 236, 218, 205, 143, 100, 47, 167, 57, 20, 239, 89,
+       70, 222, 105, 87, 110, 248, 157, 208, 167, 218, 72, 215, 165, 247,
+       252, 244, 187, 238, 101, 71, 58, 252, 55, 122, 197, 154, 27, 189,
+       104, 52, 41, 7, 80, 77, 116, 23, 234, 120, 85, 168, 125, 70, 203,
+       2, 181, 228, 122, 172, 6, 238, 141, 178, 101, 222, 38, 220, 163,
+       0, 95, 171, 120, 132, 3, 204, 174, 191, 204, 212, 188, 229, 158,
+       82, 193, 147, 228, 254, 62, 75, 233, 107, 251, 135, 102, 205, 154,
+       249, 37, 99, 218, 51, 29, 120, 185, 222, 56, 159, 72, 237, 50, 19,
+       95, 59, 4, 36, 252, 231, 19, 7, 162, 112, 126, 188, 133, 236, 204,
+       138, 101, 29, 250, 205, 161, 245, 53, 170, 44, 249, 115, 207, 110,
+       8, 212, 211, 94, 231, 237, 69, 190, 7, 34, 40, 182, 80, 234, 162,
+       78, 244, 252, 43, 37, 255, 58, 60, 4, 83, 213, 214, 236, 78, 128,
+       169, 0, 61, 81, 137, 96, 39, 102, 37, 74, 3, 163, 128, 64, 64, 96,
+       42, 42, 0, 70, 24, 215, 21, 165, 160, 130, 41, 48, 8, 220, 136, 0,
+       128, 30, 219, 109, 204, 49, 70, 174, 25, 71, 16, 188, 151, 96,
+       107, 225, 57, 251, 16, 18, 93, 162, 209, 199, 177, 90, 75, 146, 0,
+       45, 170, 96, 172, 175, 212, 157, 103, 205, 175, 82, 167, 142, 26,
+       83, 229, 81, 34, 89, 246, 104, 184, 40, 111, 251, 30, 89, 15, 213,
+       125, 193, 120, 84, 40, 59, 141, 39, 204, 93, 245, 202, 106, 197,
+       64, 204, 2, 58, 48, 52, 229, 72, 162, 26, 237, 29, 43, 118, 189,
+       187, 125, 138, 88, 27, 14, 112, 236, 119, 31, 142, 190, 136, 164,
+       78, 210, 164, 74, 222, 69, 240, 234, 51, 88, 204, 227, 63, 207,
+       157, 131, 18, 232, 241, 63, 234, 152, 152, 119, 184, 82, 45, 156,
+       253, 219, 181, 127, 95, 191, 95, 123, 124, 24, 222, 53, 143, 61,
+       23, 82, 151, 30, 179, 248, 121, 163, 239, 223, 116, 246, 210, 221,
+       196, 121, 151, 40, 142, 179, 170, 242, 184, 198, 188, 210, 82,
+       183, 237, 238, 55, 203, 231, 103, 251, 215, 52, 221, 31, 236, 140,
+       99, 255, 195, 140, 117, 57, 222, 242, 157, 111, 124, 151, 250, 86,
+       183, 253, 71, 170, 151, 98, 60, 54, 81, 121, 246, 221, 161, 252,
+       175, 52, 239, 115, 126, 148, 211, 247, 92, 244, 126, 32, 45, 0,
+       157, 85, 201, 164, 103, 52, 5, 232, 10, 160, 130, 0, 17, 104, 170,
+       66, 128, 50, 58, 84, 93, 37, 32, 154, 41, 16, 8, 199, 138, 162,
+       201, 105, 184, 95, 193, 185, 238, 142, 85, 208, 131, 36, 140, 116,
+       64, 232, 27, 131, 209, 66, 43, 82, 245, 125, 0, 158, 105, 85, 28,
+       181, 250, 38, 226, 168, 186, 205, 133, 188, 205, 139, 29, 177, 23,
+       12, 206, 127, 11, 205, 9, 243, 151, 6, 103, 138, 241, 31, 81, 218,
+       239, 213, 31, 191, 150, 138, 162, 150, 186, 75, 161, 184, 68, 142,
+       23, 81, 147, 172, 202, 106, 11, 239, 25, 163, 145, 22, 79, 146,
+       241, 69, 81, 218, 107, 151, 13, 173, 130, 222, 82, 254, 100, 43,
+       114, 88, 74, 173, 190, 182, 189, 79, 14, 199, 155, 239, 213, 237,
+       179, 140, 103, 227, 192, 146, 211, 123, 159, 235, 117, 47, 87,
+       243, 28, 46, 92, 186, 54, 158, 119, 153, 234, 146, 127, 120, 61,
+       20, 51, 221, 247, 221, 161, 248, 207, 81, 238, 243, 62, 252, 146,
+       13, 116, 178, 59, 116, 235, 233, 38, 124, 75, 215, 236, 83, 228,
+       188, 139, 99, 237, 94, 18, 152, 204, 69, 103, 222, 114, 236, 43,
+       115, 13, 165, 61, 101, 191, 214, 210, 182, 235, 103, 13, 84, 91,
+       207, 232, 81, 68, 244, 175, 99, 76, 159, 37, 88, 232, 67, 239,
+       233, 179, 125, 141, 118, 8, 129, 145, 103, 174, 86, 244, 175, 157,
+       248, 90, 181, 246, 223, 182, 89, 91, 244, 52, 250, 125, 191, 253,
+       221, 242, 148, 14, 253, 110, 120, 238, 107, 255, 246, 218, 214,
+       253, 248, 125, 162, 239, 104, 156, 124, 129, 189, 238, 206, 20,
+       240, 175, 32, 136, 118, 1, 202, 171, 131, 197, 230, 47, 102, 255,
+       116, 24, 142, 187, 85, 28, 245, 206, 163, 249, 17, 222, 109, 157,
+       224, 228, 219, 88, 112, 78, 40, 216, 117, 164, 136, 104, 146, 76,
+       199, 106, 242, 245, 63, 24, 80, 42, 91, 28, 90, 140, 55, 91, 65,
+       9, 158, 3, 142, 253, 71, 224, 184, 239, 67, 72, 151, 132, 122,
+       194, 2, 247, 205, 163, 93, 60, 56, 4, 133, 182, 125, 190, 248, 92,
+       45, 177, 177, 99, 237, 125, 192, 204, 75, 113, 37, 24, 214, 216,
+       92, 175, 153, 10, 114, 25, 31, 114, 250, 145, 141, 217, 21, 126,
+       216, 11, 90, 166, 118, 60, 237, 182, 207, 109, 181, 182, 136, 250,
+       153, 255, 244, 125, 77, 43, 173, 247, 249, 35, 249, 99, 218, 224,
+       125, 3, 239, 186, 205, 123, 151, 251, 121, 55, 138, 164, 24, 159,
+       2, 81, 164, 173, 155, 239, 67, 232, 3, 144, 252, 165, 204, 181,
+       140, 131, 85, 12, 184, 197, 173, 148, 169, 110, 58, 23, 62, 225,
+       169, 162, 188, 73, 223, 205, 2, 245, 157, 171, 183, 237, 91, 2,
+       217, 219, 215, 211, 74, 99, 234, 176, 249, 197, 175, 189, 213,
+       122, 151, 250, 10, 178, 30, 187, 75, 149, 184, 72, 174, 29, 1,
+       181, 172, 199, 104, 139, 164, 27, 235, 145, 18, 75, 130, 241, 197,
+       209, 90, 107, 16, 4, 39, 203, 150, 120, 153, 243, 139, 101, 180,
+       216, 158, 178, 1, 243, 149, 223, 73, 42, 239, 89, 51, 211, 67, 84,
+       218, 160, 205, 130, 223, 190, 185, 121, 133, 147, 190, 70, 101,
+       197, 76, 99, 207, 106, 20, 230, 214, 187, 65, 77, 181, 77, 89,
+       244, 23, 175, 232, 150, 101, 158, 69, 14, 233, 181, 55, 253, 84,
+       240, 240, 73, 6, 156, 9, 71, 4, 100, 212, 130, 160, 10, 70, 208,
+       33, 221, 232, 228, 106, 98, 104, 39, 82, 24, 177, 34, 71, 27, 16,
+       120, 32, 6, 146, 201, 87, 229, 38, 130, 236, 103, 205, 0, 250, 2,
+       175, 40, 52, 67, 234, 167, 55, 193, 72, 185, 4, 205, 160, 186,
+       222, 0, 69, 152, 241, 8, 178, 139, 108, 156, 94, 209, 221, 231,
+       157, 68, 212, 171, 40, 12, 55, 1, 206, 163, 151, 197, 236, 43,
+       102, 255, 50, 58, 216, 155, 53, 156, 244, 206, 16, 163, 202, 37,
+       20, 170, 98, 64, 36, 37, 255, 7, 3, 139, 58, 16, 120, 172, 4, 164,
+       30, 178, 128, 13, 210, 229, 162, 69, 105, 66, 106, 130, 181, 125,
+       125, 78, 206, 115, 199, 216, 82, 230, 60, 42, 115, 117, 199, 49,
+       26, 250, 22, 234, 105, 226, 127, 58, 107, 143, 229, 188, 117, 251,
+       86, 240, 104, 51, 152, 168, 252, 109, 16, 75, 10, 45, 73, 41, 150,
+       255, 74, 88, 213, 159, 223, 17, 22, 26, 194, 17, 223, 197, 58,
+       255, 144, 74, 159, 195, 106, 179, 184, 168, 255, 248, 80, 15, 75,
+       61, 185, 59, 14, 188, 78, 152, 211, 155, 223, 17, 30, 42, 194,
+       209, 159, 213, 28, 255, 148, 76, 159, 71, 129, 121, 145, 217, 44,
+       5, 173, 92, 94, 218, 80, 102, 156, 146, 225, 105, 246, 121, 54,
+       218, 195, 212, 27, 80, 133, 136, 127, 172, 24, 49, 33, 185, 190,
+       78, 105, 170, 92, 195, 91, 248, 23, 244, 148, 171, 81, 71, 97, 1,
+       93, 248, 151, 230, 104, 7, 104, 190, 249, 129, 173, 253, 55, 187,
+       52, 242, 50, 170, 138, 140, 95, 211, 128, 79, 22, 45, 240, 171,
+       32, 168, 246, 0, 120, 142, 162, 133, 14, 250, 135, 55, 24, 6, 152,
+       235, 117, 12, 126, 206, 33, 175, 65, 69, 52, 155, 110, 55, 101,
+       160, 122, 228, 163, 224, 148, 164, 26, 46, 6, 108, 221, 184, 228,
+       13, 38, 252, 165, 128, 78, 234, 218, 140, 146, 37, 66, 232, 29,
+       162, 234, 75, 143, 0, 200, 19, 9, 203, 117, 193, 248, 173, 27,
+       161, 12, 7, 134, 222, 179, 248, 139, 127, 55, 15, 112, 134, 31,
+       246, 253, 63, 247, 86, 127, 184, 123, 219, 95, 199, 109, 252, 223,
+       180, 183, 239, 181, 141, 167, 240, 191, 239, 46, 127, 109, 135,
+       175, 230, 107, 213, 112, 73, 199, 172, 13, 2, 68, 196, 137, 130,
+       242, 2, 2, 162, 37, 223, 104, 228, 44, 227, 72, 231, 17, 200, 145,
+       160, 198, 20, 33, 121, 112, 10, 114, 77, 198, 229, 5, 2, 76, 166,
+       137, 162, 250, 2, 47, 43, 53, 199, 104, 229, 61, 225, 72, 189,
+       145, 200, 179, 248, 206, 4, 37, 120, 112, 10, 224, 241, 17, 138,
+       89, 205, 19, 200, 143, 125, 129, 9, 230, 212, 106, 148, 144, 25,
+       234, 81, 79, 103, 218, 21, 137, 16, 1, 127, 80, 14, 6, 246, 32,
+       161, 232, 168, 244, 197, 89, 79, 11, 13, 253, 9, 18, 159, 78, 16,
+       217, 155, 151, 145, 26, 58, 208, 21, 127, 221, 190, 233, 209, 10,
+       254, 203, 190, 68, 101, 205, 74, 98, 79, 104, 21, 38, 221, 178,
+       81, 103, 169, 69, 126, 152, 151, 226, 104, 6, 105, 223, 83, 226,
+       235, 157, 55, 243, 52, 240, 120, 255, 249, 230, 234, 83, 87, 252,
+       19, 230, 188, 170, 123, 87, 203, 16, 95, 220, 213, 234, 104, 70,
+       233, 58, 243, 197, 165, 189, 55, 251, 214, 123, 66, 162, 158, 190,
+       139, 32, 57, 10, 170, 21, 135, 177, 140, 231, 74, 90, 167, 87,
+       235, 144, 18, 73, 139, 97, 221, 177, 90, 239, 128, 3, 173, 3, 32,
+       177, 26, 104, 240, 205, 83, 127, 38, 13, 236, 41, 151, 215, 96,
+       16, 88, 186, 71, 152, 90, 154, 66, 23, 249, 133, 37, 104, 80, 130,
+       166, 171, 89, 121, 219, 100, 19, 78, 23, 119, 96, 192, 238, 0, 63,
+       55, 1, 240, 34, 244, 88, 72, 73, 153, 177, 45, 243, 229, 4, 2,
+       106, 48, 166, 58, 109, 72, 2, 168, 109, 145, 98, 8, 237, 0, 224,
+       72, 161, 194, 33, 252, 216, 128, 170, 144, 15, 38, 87, 231, 150,
+       246, 146, 72, 152, 13, 120, 132, 98, 169, 98, 72, 95, 209, 176,
+       72, 71, 5, 228, 11, 32, 136, 54, 84, 104, 136, 195, 209, 6, 59,
+       198, 245, 87, 40, 146, 107, 119, 14, 126, 142, 91, 109, 98, 229,
+       163, 50, 126, 182, 33, 162, 158, 130, 41, 47, 145, 246, 38, 247,
+       125, 238, 200, 152, 165, 232, 247, 237, 238, 129, 39, 247, 67, 40,
+       82, 27, 110, 148, 3, 210, 60, 103, 165, 196, 206, 167, 40, 174,
+       166, 103, 102, 247, 189, 199, 204, 139, 182, 236, 178, 113, 202,
+       131, 38, 230, 61, 127, 39, 33, 234, 192, 228, 21, 125, 83, 33,
+       130, 126, 138, 25, 143, 245, 56, 126, 185, 23, 238, 216, 146, 166,
+       192, 82, 141, 227, 136, 37, 241, 232, 160, 86, 66, 150, 186, 11,
+       224, 27, 200, 175, 158, 131, 161, 204, 199, 105, 74, 231, 245,
+       237, 211, 10, 71, 138, 240, 209, 242, 203, 223, 144, 51, 37, 3,
+       208, 217, 31, 186, 139, 196, 20, 197, 174, 81, 162, 21, 182, 215,
+       40, 218, 160, 19, 233, 80, 91, 13, 147, 49, 241, 225, 90, 91, 48,
+       18, 165, 59, 32, 177, 115, 201, 213, 199, 233, 119, 87, 45, 120,
+       2, 56, 157, 52, 36, 124, 155, 19, 153, 82, 186, 112, 215, 109,
+       156, 132, 104, 87, 138, 228, 232, 73, 157, 31, 249, 184, 166, 49,
+       63, 236, 25, 126, 100, 188, 51, 32, 241, 231, 23, 60, 24, 51, 8,
+       19, 95, 233, 255, 126, 204, 154, 64, 169, 59, 148, 102, 127, 124,
+       66, 98, 57, 112, 177, 134, 227, 179, 125, 199, 33, 89, 118, 185,
+       133, 162, 104, 199, 162, 78, 209, 162, 98, 137, 33, 225, 38, 227,
+       194, 183, 236, 95, 186, 185, 191, 159, 190, 254, 95, 245, 237,
+       237, 223, 66, 151, 127, 255, 29, 166, 69, 175, 255, 110, 91, 109,
+       233, 158, 229, 141, 117, 71, 31, 235, 196, 230, 52, 125, 115, 33,
+       194, 94, 238, 25, 63, 247, 38, 55, 221, 55, 172, 209, 154, 180,
+       194, 118, 29, 229, 204, 47, 228, 161, 245, 137, 200, 149, 217, 45,
+       217, 64, 200, 207, 48, 176, 122, 174, 2, 161, 207, 200, 0, 78, 72,
+       107, 37, 71, 241, 132, 240, 130, 62, 30, 141, 89, 12, 132, 108,
+       89, 243, 32, 173, 107, 144, 60, 18, 115, 177, 151, 3, 9, 89, 7,
+       155, 95, 94, 34, 148, 72, 34, 196, 137, 114, 64, 228, 209, 3, 160,
+       4, 77, 66, 203, 196, 169, 238, 196, 101, 0, 251, 130, 129, 9, 53,
+       204, 104, 138, 10, 222, 90, 176, 69, 224, 52, 40, 130, 0, 117,
+       219, 240, 128, 88, 203, 43, 172, 50, 192, 63, 117, 164, 12, 198,
+       129, 45, 135, 34, 80, 230, 59, 141, 196, 72, 137, 160, 45, 241,
+       229, 190, 129, 32, 146, 165, 107, 90, 137, 55, 253, 131, 194, 29,
+       39, 164, 4, 202, 129, 173, 167, 32, 80, 68, 183, 249, 128, 88,
+       137, 224, 191, 225, 231, 218, 145, 50, 4, 165, 122, 156, 93, 122,
+       227, 178, 51, 30, 215, 61, 66, 191, 179, 95, 63, 171, 112, 247,
+       211, 221, 231, 248, 133, 45, 226, 242, 207, 46, 151, 166, 215,
+       165, 19, 222, 77, 22, 186, 41, 225, 31, 204, 135, 150, 136, 163,
+       239, 223, 105, 75, 202, 243, 253, 195, 74, 7, 138, 185, 241, 209,
+       207, 187, 52, 119, 53, 10, 176, 5, 111, 228, 212, 78, 111, 119,
+       53, 164, 250, 146, 19, 45, 48, 81, 120, 148, 23, 238, 120, 179,
+       33, 12, 243, 233, 228, 4, 225, 249, 230, 226, 41, 14, 25, 233, 52,
+       191, 66, 23, 84, 9, 222, 68, 179, 17, 176, 228, 89, 40, 30, 12,
+       139, 188, 81, 31, 164, 255, 176, 64, 154, 136, 88, 40, 238, 109,
+       242, 94, 205, 245, 199, 194, 217, 134, 116, 10, 40, 217, 245, 172,
+       72, 248, 130, 90, 224, 54, 242, 234, 55, 60, 132, 43, 215, 253,
+       126, 172, 128, 26, 149, 221, 44, 141, 160, 66, 207, 58, 176, 96,
+       172, 145, 161, 207, 206, 49, 14, 65, 3, 45, 66, 209, 132, 144,
+       122, 182, 84, 41, 17, 171, 92, 175, 238, 37, 180, 10, 95, 51, 112,
+       165, 254, 159, 83, 45, 18, 82, 55, 230, 109, 189, 188, 248, 229,
+       46, 250, 239, 165, 197, 229, 225, 246, 83, 132, 150, 187, 248,
+       244, 109, 89, 219, 94, 159, 57, 116, 214, 255, 232, 9, 151, 27,
+       23, 56, 178, 100, 42, 82, 201, 159, 119, 236, 144, 233, 165, 163,
+       53, 77, 234, 163, 150, 18, 126, 228, 53, 33, 255, 131, 83, 59, 50,
+       96, 122, 199, 23, 239, 124, 184, 5, 238, 254, 237, 142, 65, 165,
+       243, 248, 8, 33, 76, 119, 77, 44, 78, 199, 112, 69, 130, 246, 66,
+       115, 80, 181, 229, 88, 100, 90, 106, 233, 167, 117, 45, 37, 186,
+       64, 16, 115, 187, 82, 172, 185, 217, 119, 205, 53, 223, 230, 252,
+       92, 72, 114, 66, 51, 16, 180, 229, 120, 96, 26, 106, 225, 189, 53,
+       189, 37, 248, 66, 0, 95, 152, 112, 172, 96, 186, 150, 158, 105,
+       137, 144, 73, 142, 29, 192, 109, 164, 194, 108, 202, 193, 51, 234,
+       16, 22, 43, 202, 177, 12, 180, 90, 123, 152, 14, 47, 155, 2, 178,
+       149, 152, 105, 173, 160, 75, 142, 29, 112, 109, 164, 194, 96, 203,
+       201, 43, 234, 16, 23, 107, 75, 81, 28, 18, 91, 122, 216, 12, 9,
+       159, 220, 223, 252, 246, 183, 126, 87, 188, 21, 206, 190, 55, 255,
+       127, 171, 99, 247, 211, 157, 115, 252, 224, 57, 174, 251, 215, 47,
+       151, 166, 255, 133, 123, 14, 174, 114, 187, 246, 234, 177, 194,
+       28, 29, 89, 179, 140, 141, 170, 73, 239, 27, 135, 17, 18, 248, 8,
+       229, 204, 71, 58, 195, 245, 79, 37, 195, 129, 250, 26, 177, 50,
+       143, 57, 214, 190, 187, 86, 116, 149, 147, 226, 32, 39, 57, 22,
+       24, 226, 220, 0, 118, 204, 133, 59, 224, 8, 128, 9, 137, 5, 254,
+       218, 49, 178, 158, 57, 182, 126, 141, 94, 180, 149, 131, 210, 80,
+       39, 111, 60, 156, 246, 220, 164, 46, 238, 207, 54, 193, 172, 128,
+       137, 73, 197, 218, 253, 87, 36, 72, 237, 176, 233, 242, 55, 226,
+       249, 125, 221, 47, 7, 86, 125, 202, 225, 100, 239, 225, 102, 154,
+       231, 128, 103, 241, 85, 97, 61, 129, 228, 231, 197, 22, 239, 190,
+       65, 49, 126, 2, 155, 41, 22, 110, 75, 198, 55, 220, 216, 248, 117,
+       160, 111, 255, 212, 68, 231, 216, 240, 168, 65, 138, 22, 181, 42,
+       10, 41, 35, 172, 177, 67, 80, 244, 35, 128, 203, 38, 53, 106, 8,
+       32, 201, 3, 77, 132, 178, 122, 64, 0, 160, 1, 40, 32, 22, 253,
+       113, 236, 107, 53, 55, 108, 63, 127, 56, 151, 53, 128, 63, 3, 22,
+       102, 2, 112, 252, 99, 20, 69, 134, 112, 19, 208, 217, 198, 225, 4,
+       155, 253, 243, 238, 104, 53, 183, 238, 31, 55, 48, 214, 117, 136,
+       11, 135, 83, 110, 18, 114, 236, 43, 97, 79, 178, 116, 83, 192,
+       216, 197, 227, 153, 75, 78, 173, 36, 6, 78, 180, 68, 74, 214, 199,
+       241, 10, 179, 65, 124, 228, 62, 239, 237, 189, 85, 237, 244, 171,
+       234, 128, 45, 176, 120, 24, 19, 167, 110, 59, 150, 177, 176, 111,
+       222, 21, 221, 183, 169, 232, 190, 129, 235, 11, 130, 149, 182,
+       169, 15, 213, 42, 77, 26, 203, 221, 76, 249, 207, 230, 240, 61,
+       178, 106, 205, 177, 212, 138, 93, 145, 61, 180, 221, 76, 11, 134,
+       51, 255, 83, 147, 71, 146, 241, 85, 80, 122, 251, 132, 5, 151,
+       243, 136, 177, 51, 249, 101, 205, 177, 87, 222, 25, 112, 80, 188,
+       153, 96, 41, 136, 59, 2, 17, 83, 252, 18, 113, 69, 152, 114, 104,
+       88, 8, 195, 187, 2, 161, 2, 138, 93, 128, 168, 69, 174, 17, 193,
+       2, 132, 138, 100, 66, 232, 169, 107, 209, 22, 155, 130, 209, 29,
+       32, 154, 107, 17, 2, 59, 138, 34, 161, 150, 155, 77, 129, 160, 65,
+       206, 17, 193, 3, 164, 137, 124, 74, 232, 171, 43, 145, 18, 58,
+       218, 241, 29, 16, 218, 107, 145, 11, 249, 130, 140, 244, 189, 247,
+       178, 230, 127, 190, 54, 254, 94, 52, 253, 247, 203, 43, 23, 127,
+       53, 41, 163, 196, 251, 47, 235, 143, 237, 133, 172, 240, 55, 123,
+       182, 149, 104, 218, 237, 245, 220, 235, 155, 127, 157, 159, 10,
+       236, 126, 69, 205, 139, 151, 151, 254, 47, 122, 215, 91, 89, 221,
+       255, 87, 76, 220, 214, 57, 251, 56, 104, 61, 221, 211, 220, 67,
+       108, 60, 46, 154, 220, 214, 164, 156, 120, 148, 92, 143, 42, 246,
+       159, 235, 221, 37, 255, 123, 158, 94, 255, 154, 157, 119, 133, 51,
+       242, 59, 115, 45, 236, 90, 231, 108, 183, 160, 196, 54, 55, 157,
+       160, 33, 153, 41, 223, 184, 116, 43, 198, 38, 134, 37, 127, 185,
+       77, 107, 172, 84, 195, 78, 114, 84, 74, 88, 66, 49, 221, 49, 96,
+       120, 168, 23, 239, 237, 182, 36, 63, 115, 239, 160, 128, 53, 169,
+       112, 202, 0, 177, 27, 112, 104, 237, 177, 71, 170, 25, 104, 24,
+       188, 159, 100, 59, 166, 59, 66, 16, 19, 120, 146, 81, 69, 152, 82,
+       106, 72, 0, 135, 187, 64, 144, 159, 246, 104, 204, 49, 19, 170,
+       25, 3, 120, 180, 147, 64, 122, 160, 55, 127, 0, 19, 77, 146, 65,
+       213, 176, 122, 202, 8, 0, 7, 59, 252, 109, 80, 66, 141, 93, 86,
+       196, 193, 46, 180, 24, 10, 25, 77, 158, 232, 210, 205, 66, 104,
+       39, 200, 178, 243, 217, 4, 59, 115, 95, 206, 6, 168, 9, 189, 95,
+       236, 106, 69, 151, 84, 63, 247, 56, 210, 53, 129, 57, 73, 126, 36,
+       8, 56, 250, 99, 32, 199, 187, 116, 17, 210, 249, 198, 235, 82,
+       185, 188, 94, 171, 193, 149, 173, 206, 253, 157, 40, 244, 253,
+       206, 34, 129, 87, 253, 1, 82, 73, 171, 241, 251, 23, 127, 255, 16,
+       66, 165, 107, 182, 53, 104, 210, 205, 253, 208, 202, 139, 245,
+       157, 27, 10, 220, 127, 40, 141, 155, 215, 21, 159, 43, 122, 210,
+       91, 89, 137, 255, 215, 77, 92, 214, 171, 251, 105, 235, 52, 213,
+       91, 252, 23, 76, 84, 231, 187, 221, 186, 160, 94, 184, 151, 126,
+       207, 152, 124, 191, 234, 221, 165, 248, 62, 143, 92, 253, 230,
+       178, 234, 24, 75, 244, 184, 202, 26, 87, 113, 159, 8, 236, 126,
+       27, 173, 75, 163, 149, 182, 126, 190, 243, 94, 55, 218, 239, 221,
+       69, 63, 215, 2, 225, 66, 139, 79, 129, 184, 68, 174, 17, 193, 131,
+       172, 154, 124, 66, 234, 187, 91, 213, 2, 11, 138, 241, 21, 24,
+       154, 107, 21, 6, 161, 138, 124, 205, 114, 114, 149, 127, 87, 230,
+       113, 47, 190, 10, 75, 57, 31, 181, 89, 214, 196, 234, 120, 235,
+       104, 170, 251, 203, 228, 81, 227, 123, 198, 42, 162, 149, 103,
+       218, 235, 212, 157, 127, 155, 95, 249, 183, 40, 222, 62, 43, 207,
+       155, 151, 129, 246, 79, 114, 211, 51, 120, 222, 219, 23, 84, 182,
+       247, 210, 92, 247, 214, 207, 244, 180, 199, 191, 222, 150, 191,
+       44, 188, 103, 207, 167, 243, 255, 145, 180, 79, 178, 226, 27, 122,
+       94, 155, 135, 92, 53, 95, 139, 223, 103, 77, 114, 154, 191, 180,
+       125, 72, 86, 230, 253, 12, 182, 229, 38, 117, 151, 239, 229, 156,
+       53, 239, 38, 58, 106, 130, 111, 148, 25, 253, 212, 83, 218, 231,
+       226, 66, 127, 244, 49, 138, 119, 243, 85, 199, 169, 89, 54, 253,
+       55, 106, 224, 213, 140, 106, 118, 43, 103, 133, 37, 243, 165, 161,
+       127, 46, 202, 164, 82, 34, 107, 80, 49, 164, 223, 207, 65, 99,
+       147, 90, 126, 236, 5, 238, 140, 147, 141, 8, 82, 45, 169, 132,
+       175, 247, 122, 80, 248, 79, 42, 204, 28, 147, 195, 112, 196, 140,
+       190, 42, 115, 217, 183, 64, 120, 176, 13, 234, 232, 35, 32, 159,
+       243, 237, 163, 153, 87, 43, 124, 35, 162, 185, 123, 216, 75, 229,
+       177, 198, 139, 29, 112, 27, 60, 159, 100, 27, 239, 59, 131, 80,
+       18, 107, 178, 241, 95, 145, 82, 107, 209, 9, 39, 243, 194, 176,
+       155, 250, 107, 236, 48, 65, 171, 25, 161, 25, 188, 215, 104, 90,
+       166, 147, 125, 16, 19, 15, 146, 81, 211, 176, 26, 123, 144, 0,
+       167, 59, 82, 82, 23, 186, 44, 196, 16, 16, 173, 25, 147, 97, 158,
+       223, 40, 74, 230, 49, 125, 83, 2, 1, 19, 241, 209, 240, 42, 210,
+       24, 3, 37, 19, 2, 88, 31, 171, 42, 133, 184, 64, 174, 24, 147,
+       225, 189, 158, 97, 72, 230, 57, 255, 83, 2, 133, 19, 241, 193,
+       208, 10, 218, 20, 3, 37, 19, 102, 225, 98, 138, 237, 161, 250,
+       201, 203, 17, 153, 11, 200, 216, 124, 42, 234, 145, 123, 215, 86,
+       35, 206, 241, 87, 24, 139, 111, 21, 31, 243, 134, 102, 169, 182,
+       202, 237, 57, 250, 200, 203, 17, 185, 10, 140, 216, 125, 42, 202,
+       81, 123, 83, 150, 35, 138, 241, 31, 24, 139, 127, 213, 63, 243,
+       134, 47, 187, 241, 74, 189, 221, 218, 220, 143, 93, 188, 173, 122,
+       221, 222, 164, 159, 83, 223, 85, 223, 41, 58, 241, 123, 93, 37,
+       255, 214, 142, 214, 119, 251, 223, 107, 106, 115, 214, 91, 176,
+       21, 76, 244, 231, 121, 95, 190, 245, 94, 177, 149, 239, 239, 143,
+       124, 255, 115, 121, 168, 200, 63, 134, 110, 125, 88, 98, 198, 228,
+       31, 66, 104, 8, 227, 169, 179, 67, 75, 139, 84, 194, 248, 133,
+       109, 241, 8, 161, 129, 192, 153, 232, 131, 85, 47, 3, 120, 2, 43,
+       167, 232, 78, 245, 176, 254, 95, 83, 5, 125, 175, 40, 200, 254,
+       36, 94, 138, 147, 157, 150, 58, 236, 211, 126, 93, 132, 171, 215,
+       222, 254, 207, 138, 97, 123, 234, 110, 133, 190, 196, 140, 0, 152,
+       163, 189, 222, 45, 0, 238, 49, 223, 199, 194, 35, 2, 241, 247,
+       217, 42, 186, 21, 31, 167, 219, 252, 220, 191, 119, 147, 111, 87,
+       188, 23, 238, 199, 58, 91, 119, 2, 117, 21, 222, 189, 106, 41,
+       212, 249, 62, 251, 239, 117, 212, 34, 251, 132, 115, 175, 145, 56,
+       250, 253, 165, 153, 202, 143, 53, 157, 27, 156, 223, 126, 8, 205,
+       155, 147, 149, 26, 11, 90, 245, 223, 24, 155, 127, 157, 13, 25,
+       146, 172, 243, 106, 66, 84, 193, 243, 248, 66, 44, 245, 42, 16,
+       217, 254, 48, 120, 152, 3, 250, 194, 54, 168, 23, 127, 13, 165,
+       237, 103, 138, 118, 227, 103, 181, 98, 200, 237, 53, 222, 200,
+       203, 92, 157, 42, 76, 220, 255, 38, 223, 209, 223, 247, 214, 35,
+       174, 208, 59, 88, 143, 255, 151, 127, 247, 231, 240, 133, 9, 172,
+       61, 201, 74, 109, 93, 68, 232, 10, 175, 198, 50, 212, 218, 171,
+       12, 97, 95, 43, 101, 159, 176, 244, 2, 123, 52, 14, 252, 108, 189,
+       121, 241, 115, 245, 189, 254, 212, 83, 233, 125, 106, 187, 221,
+       93, 160, 156, 250, 151, 95, 202, 50, 250, 176, 111, 217, 37, 232,
+       247, 223, 210, 179, 47, 185, 117, 194, 253, 221, 250, 213, 143,
+       121, 57, 43, 236, 125, 220, 164, 143, 19, 223, 81, 150, 41, 106,
+       245, 63, 92, 142, 250, 214, 158, 215, 127, 15, 26, 229, 167, 34,
+       34, 171, 152, 44, 64, 91, 231, 221, 110, 155, 106, 118, 69, 63,
+       239, 129, 144, 45, 232, 4, 45, 235, 132, 173, 247, 33, 241, 46,
+       96, 152, 178, 29, 237, 209, 202, 207, 253, 161, 25, 158, 218, 127,
+       10, 201, 129, 219, 17, 14, 103, 250, 240, 217, 157, 159, 127, 208,
+       93, 87, 194, 138, 163, 19, 218, 125, 212, 185, 89, 159, 21, 213,
+       22, 172, 207, 60, 196, 238, 27, 131, 137, 98, 15, 50, 211, 85, 52,
+       154, 75, 23, 12, 165, 232, 195, 92, 94, 240, 101, 248, 252, 102,
+       189, 218, 50, 18, 172, 158, 55, 203, 231, 55, 255, 129, 37, 205,
+       18, 238, 150, 59, 218, 131, 12, 92, 105, 25, 251, 213, 117, 68,
+       47, 86, 95, 61, 81, 238, 182, 26, 91, 53, 158, 183, 22, 212, 253,
+       106, 233, 239, 241, 142, 243, 255, 69, 150, 99, 172, 198, 125,
+       184, 197, 66, 172, 117, 64, 78, 101, 17, 68, 232, 139, 43, 203,
+       50, 209, 122, 168, 133, 226, 109, 186, 68, 143, 242, 249, 128, 9,
+       127, 174, 122, 216, 185, 198, 112, 234, 117, 151, 90, 52, 85, 9,
+       81, 82, 127, 25, 56, 224, 220, 153, 151, 255, 254, 190, 73, 191,
+       246, 253, 162, 192, 55, 143, 248, 3, 34, 149, 117, 227, 253, 249,
+       252, 231, 143, 57, 57, 170, 140, 62, 92, 165, 239, 147, 215, 17,
+       147, 56, 90, 245, 46, 88, 158, 255, 215, 142, 205, 173, 31, 74,
+       111, 197, 102, 54, 235, 216, 76, 78, 94, 198, 217, 77, 191, 105,
+       126, 221, 23, 239, 129, 144, 109, 236, 70, 43, 234, 132, 37, 251,
+       113, 241, 133, 221, 251, 231, 244, 70, 255, 180, 16, 206, 94, 167,
+       113, 127, 187, 96, 54, 127, 21, 239, 225, 176, 56, 110, 101, 173,
+       238, 128, 37, 250, 244, 251, 210, 107, 250, 238, 100, 128, 127,
+       116, 237, 132, 244, 135, 175, 139, 118, 64, 238, 249, 23, 199,
+       202, 47, 134, 232, 246, 216, 142, 139, 39, 158, 229, 137, 250,
+       191, 243, 212, 223, 85, 149, 255, 219, 206, 156, 175, 40, 252,
+       247, 183, 191, 243, 215, 161, 245, 107, 182, 206, 123, 95, 207,
+       191, 183, 124, 127, 223, 191, 218, 252, 188, 119, 214, 217, 184,
+       155, 222, 52, 255, 127, 124, 151, 163, 191, 233, 181, 229, 237,
+       110, 58, 223, 234, 203, 239, 205, 127, 188, 79, 123, 190, 22, 254,
+       244, 55, 118, 217, 123, 27, 238, 156, 190, 76, 127, 183, 175, 159,
+       149, 181, 161, 173, 199, 49, 223, 219, 215, 249, 151, 175, 228,
+       31, 119, 62, 215, 110, 110, 182, 82, 223, 253, 81, 204, 125, 167,
+       107, 125, 190, 160, 223, 210, 149, 162, 252, 176, 45, 143, 106,
+       223, 165, 199, 119, 254, 252, 255, 191, 222, 252, 244, 55, 86,
+       223, 250, 155, 222, 180, 247, 127, 255, 187, 173, 127, 241, 149,
+       167, 237, 101, 58, 255, 235, 223, 239, 183, 191, 253, 15, 119,
+       239, 151, 244, 212, 247, 118, 93, 59, 27, 255, 60, 62, 92, 126,
+       174, 191, 151, 183, 181, 176, 181, 67, 48, 223, 91, 223, 125, 255,
+       143, 100, 207, 119, 71, 223, 229, 135, 178, 22, 174, 183, 120,
+       234, 90, 228, 221, 62, 149, 231, 55, 79, 21, 239, 213, 216, 149,
+       236, 44, 62, 254, 132, 140, 246, 129, 61, 167, 182, 230, 23, 244,
+       55, 239, 190, 95, 234, 127, 245, 104, 232, 159, 36, 159, 110, 54,
+       47, 181, 249, 61, 255, 42, 30, 197, 134, 207, 253, 216, 213, 61,
+       58, 251, 229, 127, 95, 251, 82, 21, 238, 246, 47, 219, 63, 131,
+       190, 254, 252, 223, 180, 237, 251, 241, 138, 247, 255, 166, 163,
+       239, 252, 30, 247, 182, 120, 115, 224, 85, 195, 107, 212, 101,
+       164, 242, 34, 43, 159, 53, 212, 122, 253, 151, 211, 201, 190, 64,
+       234, 183, 220, 134, 226, 103, 187, 118, 174, 75, 255, 244, 180,
+       181, 119, 223, 191, 27, 238, 28, 175, 125, 109, 191, 165, 151,
+       103, 181, 37, 247, 105, 50, 255, 235, 223, 253, 189, 158, 252,
+       221, 123, 7, 147, 233, 11, 178, 210, 179, 57, 94, 77, 95, 230,
+       240, 244, 190, 100, 87, 74, 182, 191, 151, 208, 47, 85, 108, 47,
+       175, 199, 156, 166, 181, 245, 135, 223, 225, 155, 246, 183, 175,
+       246, 29, 78, 153, 246, 200, 110, 189, 165, 127, 195, 151, 239,
+       241, 4, 109, 255, 44, 94, 239, 198, 159, 255, 181, 245, 215, 229,
+       120, 225, 175, 45, 222, 159, 207, 51, 185, 31, 143, 73, 94, 10,
+       175, 211, 125, 247, 222, 100, 223, 242, 175, 217, 143, 255, 253,
+       219, 217, 7, 175, 223, 232, 242, 245, 124, 255, 183, 155, 223,
+       188, 191, 253, 127, 187, 39, 255, 243, 151, 53, 255, 108, 120,
+       239, 239, 223, 255, 255, 191, 252, 221, 255, 239, 223, 232, 244,
+       245, 124, 255, 191, 155, 222, 188, 191, 249, 127, 171, 101, 127,
+       243, 149, 244, 255, 104, 120, 239, 255, 223, 255, 255, 191, 252,
+       157, 127, 143, 255, 237, 247, 182, 212, 255, 188, 155, 220, 63,
+       247, 249, 223, 223, 99, 55, 239, 181, 214, 227, 124, 255, 247,
+       110, 219, 229, 196, 47, 183, 212, 121, 52, 86, 254, 76, 52, 38,
+       87, 216, 81, 14, 253, 102, 82, 121, 191, 121, 220, 220, 21, 234,
+       168, 183, 41, 137, 82, 255, 224, 135, 119, 251, 124, 39, 143, 191,
+       166, 63, 248, 187, 188, 190, 223, 255, 83, 253, 233, 236, 246,
+       203, 151, 111, 239, 149, 182, 237, 175, 191, 46, 83, 253, 239,
+       150, 237, 157, 85, 205, 241, 157, 243, 173, 77, 80, 136, 171, 185,
+       135, 24, 222, 209, 73, 191, 129, 84, 121, 91, 75, 69, 219, 176,
+       201, 153, 95, 127, 130, 57, 155, 34, 75, 176, 149, 255, 29, 253,
+       64, 138, 143, 57, 137, 24, 236, 243, 72, 190, 193, 70, 250, 24,
+       19, 73, 251, 241, 15, 250, 219, 126, 146, 69, 82, 38, 74, 107,
+       118, 250, 236, 160, 253, 196, 139, 21, 249, 155, 172, 207, 124,
+       75, 206, 59, 255, 215, 146, 71, 138, 241, 212, 56, 250, 235, 20,
+       147, 227, 131, 143, 254, 253, 215, 102, 252, 187, 152, 251, 222,
+       23, 118, 252, 254, 223, 171, 183, 111, 183, 151, 167, 116, 187,
+       255, 14, 27, 255, 130, 143, 231, 93, 245, 65, 153, 29, 159, 70,
+       200, 97, 48, 108, 81, 67, 70, 245, 35, 0, 88, 98, 2, 42, 136, 17,
+       152, 95, 117, 196, 162, 250, 64, 152, 3, 129, 48, 223, 159, 222,
+       191, 178, 50, 190, 191, 26, 91, 90, 247, 125, 126, 170, 203, 247,
+       223, 181, 151, 183, 220, 15, 227, 250, 39, 255, 199, 189, 245,
+       169, 27, 151, 97, 212, 163, 141, 61, 232, 73, 111, 49, 185, 27,
+       222, 90, 94, 10, 250, 133, 126, 245, 30, 119, 219, 208, 157, 216,
+       203, 118, 229, 11, 201, 198, 18, 115, 146, 225, 133, 7, 238, 213,
+       5, 41, 186, 70, 137, 9, 121, 8, 232, 139, 15, 195, 201, 177, 17,
+       192, 161, 196, 174, 132, 47, 90, 225, 139, 62, 21, 106, 226, 197,
+       38, 254, 117, 96, 173, 187, 71, 89, 121, 28, 2, 120, 215, 87, 163,
+       220, 163, 24, 204, 123, 79, 238, 197, 237, 114, 246, 131, 63, 68,
+       239, 77, 172, 118, 239, 216, 100, 202, 223, 98, 81, 246, 191, 238,
+       121, 68, 62, 238, 141, 151, 175, 194, 67, 111, 239, 132, 167, 247,
+       120, 245, 87, 1, 197, 133, 6, 70, 171, 32, 24, 234, 146, 198, 80,
+       38, 149, 239, 112, 228, 61, 239, 129, 209, 181, 200, 20, 46, 235,
+       132, 13, 245, 49, 124, 206, 190, 236, 191, 250, 241, 52, 191, 159,
+       255, 84, 179, 237, 239, 202, 91, 7, 123, 239, 145, 54, 77, 206,
+       179, 110, 83, 255, 255, 182, 100, 157, 211, 101, 180, 149, 243,
+       141, 124, 64, 174, 207, 115, 171, 80, 198, 114, 72, 255, 193, 70,
+       234, 24, 55, 72, 219, 241, 15, 251, 87, 127, 146, 73, 216, 6, 68,
+       102, 255, 223, 58, 35, 15, 184, 22, 182, 75, 224, 101, 227, 201,
+       89, 87, 252, 108, 170, 40, 214, 239, 127, 200, 166, 255, 8, 164,
+       241, 36, 40, 66, 226, 213, 190, 124, 140, 248, 12, 190, 21, 241,
+       215, 173, 139, 112, 75, 106, 11, 111, 157, 2, 74, 202, 241, 221,
+       178, 218, 232, 20, 8, 229, 202, 175, 158, 237, 151, 244, 254, 187,
+       178, 122, 255, 127, 246, 252, 126, 223, 235, 239, 95, 183, 31,
+       167, 252, 125, 227, 78, 91, 255, 194, 143, 239, 125, 253, 33, 0,
+       212, 157, 85, 159, 232, 66, 207, 113, 243, 66, 156, 154, 22, 104,
+       234, 173, 62, 149, 6, 248, 66, 213, 157, 152, 219, 17, 21, 8, 65,
+       134, 175, 220, 255, 211, 246, 94, 191, 246, 121, 95, 118, 182, 93,
+       61, 191, 253, 111, 91, 151, 94, 245, 254, 61, 226, 126, 95, 118,
+       192, 206, 253, 173, 253, 13, 159, 189, 183, 179, 254, 61, 183, 60,
+       223, 86, 247, 253, 127, 139, 237, 55, 122, 181, 60, 183, 216, 43,
+       175, 238, 239, 127, 197, 174, 244, 141, 113, 187, 107, 100, 69,
+       15, 83, 221, 123, 65, 244, 180, 175, 11, 45, 215, 167, 78, 196,
+       213, 237, 236, 99, 229, 140, 114, 89, 197, 183, 119, 188, 126,
+       252, 254, 106, 224, 1, 75, 113, 90, 202, 19, 247, 148, 191, 11,
+       140, 223, 158, 127, 204, 229, 158, 174, 86, 238, 130, 30, 93, 149,
+       191, 167, 253, 94, 215, 154, 22, 214, 117, 162, 106, 61, 23, 49,
+       174, 119, 242, 79, 39, 129, 93, 119, 191, 133, 160, 40, 212, 37,
+       202, 212, 230, 122, 131, 167, 244, 134, 49, 136, 150, 254, 247,
+       178, 42, 125, 183, 57, 31, 126, 245, 236, 39, 136, 95, 167, 95,
+       165, 16, 176, 220, 161, 226, 236, 247, 126, 192, 132, 208, 135,
+       233, 212, 158, 255, 222, 210, 34, 7, 184, 50, 166, 238, 246, 113,
+       231, 169, 89, 119, 246, 40, 234, 40, 198, 239, 63, 253, 166, 103,
+       12, 161, 243, 36, 104, 203, 72, 195, 222, 69, 180, 234, 22, 213,
+       130, 86, 70, 104, 233, 181, 236, 104, 226, 179, 204, 225, 190, 22,
+       234, 23, 126, 222, 138, 143, 252, 120, 44, 143, 197, 133, 191,
+       157, 47, 78, 175, 23, 226, 8, 87, 233, 104, 29, 133, 221, 110, 34,
+       167, 245, 220, 95, 191, 46, 86, 221, 22, 186, 126, 216, 28, 19,
+       97, 212, 165, 95, 159, 232, 72, 79, 169, 185, 10, 158, 154, 86, 0,
+       250, 173, 126, 213, 14, 246, 195, 216, 149, 216, 139, 54, 117, 8,
+       97, 142, 190, 123, 100, 220, 15, 83, 223, 232, 147, 246, 148, 175,
+       75, 205, 255, 175, 94, 208, 213, 231, 239, 103, 126, 216, 115, 89,
+       205, 191, 119, 189, 126, 87, 77, 233, 173, 159, 157, 221, 183,
+       173, 142, 244, 13, 3, 254, 244, 74, 166, 217, 126, 248, 95, 95,
+       105, 251, 189, 239, 123, 207, 125, 18, 63, 149, 246, 218, 134,
+       118, 214, 3, 208, 120, 103, 185, 69, 207, 151, 44, 231, 46, 215,
+       166, 179, 233, 132, 116, 207, 182, 239, 155, 243, 218, 11, 35,
+       132, 175, 94, 221, 249, 175, 158, 9, 214, 31, 188, 151, 244, 71,
+       135, 122, 246, 75, 247, 85, 252, 241, 230, 237, 196, 255, 253,
+       235, 107, 207, 15, 10, 183, 44, 126, 126, 80, 226, 218, 79, 116,
+       152, 200, 155, 94, 149, 191, 72, 254, 127, 110, 255, 209, 183,
+       147, 142, 71, 190, 240, 83, 95, 219, 191, 151, 127, 61, 87, 158,
+       182, 50, 114, 59, 253, 153, 218, 223, 95, 21, 53, 142, 220, 126,
+       172, 159, 27, 223, 21, 183, 37, 58, 247, 203, 95, 25, 255, 214,
+       13, 29, 215, 90, 148, 34, 186, 61, 245, 17, 123, 151, 95, 221, 55,
+       174, 255, 46, 228, 197, 147, 157, 5, 191, 11, 58, 183, 211, 119,
+       154, 219, 146, 76, 188, 119, 182, 249, 251, 218, 255, 213, 159,
+       220, 139, 93, 181, 191, 72, 222, 127, 43, 239, 217, 215, 211, 174,
+       103, 186, 243, 123, 88, 143, 255, 215, 31, 180, 247, 221, 221, 37,
+       170, 157, 118, 134, 172, 70, 114, 139, 86, 211, 92, 57, 225, 217,
+       199, 248, 99, 255, 103, 125, 183, 177, 97, 207, 86, 29, 95, 184,
+       52, 252, 98, 112, 106, 61, 59, 86, 216, 83, 174, 181, 106, 75, 73,
+       25, 152, 25, 196, 205, 106, 40, 39, 73, 186, 242, 207, 33, 125,
+       119, 187, 94, 3, 143, 182, 165, 255, 189, 255, 159, 185, 23, 255,
+       95, 247, 249, 253, 202, 165, 221, 126, 181, 46, 181, 244, 235,
+       191, 79, 127, 103, 215, 154, 238, 29, 247, 179, 33, 72, 237, 21,
+       191, 234, 75, 95, 168, 250, 2, 27, 26, 22, 160, 250, 173, 23, 165,
+       143, 180, 65, 223, 151, 252, 131, 148, 117, 42, 88, 132, 198, 216,
+       55, 218, 111, 245, 184, 200, 159, 91, 177, 119, 108, 222, 60, 235,
+       239, 241, 191, 211, 167, 103, 58, 243, 23, 90, 218, 235, 159, 31,
+       37, 247, 122, 150, 118, 126, 57, 244, 29, 55, 185, 79, 255, 181,
+       46, 191, 166, 245, 198, 179, 157, 132, 189, 11, 112, 239, 243,
+       255, 58, 155, 18, 196, 172, 95, 235, 190, 172, 85, 109, 94, 85,
+       55, 81, 238, 22, 189, 58, 61, 214, 183, 205, 214, 253, 44, 237,
+       124, 245, 138, 95, 95, 245, 183, 78, 236, 94, 127, 170, 237, 34,
+       129, 149, 129, 166, 231, 30, 49, 136, 3, 161, 137, 112, 0, 73, 75,
+       3, 209, 118, 171, 80, 53, 105, 5, 158, 113, 81, 28, 246, 138, 173,
+       247, 175, 159, 189, 255, 151, 191, 30, 254, 94, 247, 250, 244,
+       202, 37, 29, 126, 244, 46, 253, 252, 251, 191, 235, 99, 239, 223,
+       26, 254, 157, 119, 210, 7, 124, 164, 22, 14, 201, 105, 105, 132,
+       186, 135, 95, 75, 54, 64, 126, 165, 31, 237, 232, 167, 69, 222,
+       240, 184, 139, 20, 101, 170, 117, 104, 15, 248, 188, 250, 237,
+       165, 184, 204, 143, 63, 145, 63, 156, 222, 125, 10, 207, 91, 255,
+       211, 150, 71, 218, 241, 92, 25, 255, 250, 156, 95, 171, 147, 250,
+       218, 236, 56, 47, 83, 157, 238, 215, 246, 148, 187, 11, 44, 87,
+       175, 207, 213, 253, 199, 236, 111, 111, 178, 211, 211, 223, 191,
+       119, 253, 60, 95, 254, 22, 236, 156, 141, 48, 88, 10, 211, 255,
+       149, 191, 203, 236, 95, 239, 205, 231, 237, 181, 188, 103, 238,
+       128, 154, 243, 223, 255, 183, 109, 92, 71, 211, 170, 164, 144,
+       141, 189, 92, 143, 251, 127, 148, 29, 142, 170, 86, 191, 229, 199,
+       252, 149, 190, 79, 239, 243, 154, 91, 223, 255, 138, 68, 155, 78,
+       244, 222, 157, 190, 216, 230, 22, 190, 146, 223, 224, 125, 98,
+       247, 74, 91, 209, 238, 36, 146, 63, 78, 203, 63, 187, 167, 245,
+       159, 152, 112, 172, 91, 113, 197, 22, 92, 153, 220, 69, 167, 133,
+       17, 174, 0, 106, 99, 46, 213, 96, 162, 104, 44, 121, 11, 50, 221,
+       51, 251, 68, 27, 26, 152, 200, 46, 221, 255, 175, 158, 185, 118,
+       23, 191, 22, 254, 222, 183, 120, 246, 235, 253, 85, 254, 181, 230,
+       237, 198, 191, 191, 235, 99, 255, 135, 10, 247, 172, 127, 2, 62,
+       186, 247, 116, 188, 186, 82, 187, 79, 93, 243, 188, 191, 246, 56,
+       239, 59, 151, 149, 130, 152, 168, 226, 199, 127, 186, 130, 135,
+       207, 59, 223, 251, 61, 126, 116, 167, 254, 92, 119, 169, 206, 190,
+       253, 46, 189, 151, 55, 166, 183, 213, 1, 244, 235, 176, 202, 227,
+       249, 100, 155, 78, 244, 207, 127, 235, 63, 239, 100, 237, 95, 93,
+       55, 217, 238, 54, 253, 27, 61, 215, 63, 143, 244, 253, 45, 253,
+       253, 229, 138, 235, 219, 245, 183, 231, 252, 214, 127, 239, 254,
+       237, 197, 237, 87, 221, 191, 83, 254, 188, 191, 89, 61, 215, 50,
+       223, 212, 247, 174, 253, 126, 245, 130, 127, 95, 245, 191, 255,
+       252, 220, 119, 20, 124, 60, 235, 30, 167, 147, 202, 134, 161, 141,
+       3, 85, 91, 97, 8, 89, 112, 27, 114, 10, 129, 89, 60, 235, 133,
+       143, 117, 188, 123, 20, 146, 254, 30, 164, 190, 175, 112, 153,
+       202, 155, 223, 149, 187, 78, 236, 127, 91, 239, 215, 253, 147,
+       190, 71, 239, 240, 155, 115, 219, 191, 151, 125, 52, 87, 254, 162,
+       238, 184, 143, 112, 88, 203, 187, 255, 149, 187, 14, 238, 94, 91,
+       207, 135, 253, 149, 190, 79, 238, 210, 155, 115, 223, 255, 135,
+       100, 190, 87, 163, 201, 44, 158, 60, 133, 143, 224, 220, 0, 100,
+       3, 240, 200, 55, 1, 204, 107, 19, 207, 102, 41, 10, 255, 96, 9,
+       143, 56, 85, 59, 89, 200, 52, 111, 237, 101, 172, 3, 207, 184, 22,
+       164, 152, 235, 83, 101, 217, 35, 88, 204, 125, 254, 200, 66, 109,
+       24, 232, 143, 237, 180, 181, 251, 84, 240, 18, 133, 117, 225, 180,
+       235, 249, 35, 77, 49, 187, 146, 141, 63, 180, 228, 239, 147, 31,
+       185, 185, 185, 101, 222, 159, 222, 154, 214, 151, 140, 229, 53,
+       158, 208, 117, 248, 143, 213, 157, 237, 159, 95, 144, 55, 77, 222,
+       126, 43, 239, 209, 253, 243, 255, 103, 58, 213, 187, 211, 223,
+       255, 151, 60, 165, 119, 175, 151, 173, 127, 179, 255, 63, 188, 83,
+       255, 157, 181, 249, 253, 222, 37, 223, 118, 183, 110, 245, 200,
+       127, 191, 111, 95, 101, 247, 182, 239, 148, 247, 10, 46, 210, 189,
+       116, 170, 248, 70, 63, 39, 248, 215, 189, 138, 54, 200, 239, 175,
+       143, 141, 0, 158, 192, 202, 212, 191, 58, 128, 156, 204, 101, 217,
+       18, 7, 254, 225, 244, 235, 233, 67, 109, 165, 254, 178, 157, 47,
+       180, 196, 235, 179, 95, 185, 184, 185, 69, 206, 220, 158, 186,
+       209, 149, 200, 101, 161, 222, 180, 167, 184, 175, 240, 145, 203,
+       187, 95, 145, 187, 76, 254, 110, 91, 231, 215, 253, 145, 62, 71,
+       170, 194, 219, 115, 223, 255, 132, 101, 183, 87, 149, 190, 134,
+       23, 153, 255, 151, 255, 22, 255, 147, 127, 230, 244, 75, 7, 189,
+       238, 236, 34, 255, 253, 187, 63, 168, 22, 117, 151, 216, 125, 149,
+       87, 163, 219, 126, 222, 126, 149, 158, 224, 221, 72, 244, 70, 96,
+       200, 183, 1, 220, 105, 19, 111, 229, 171, 30, 189, 34, 56, 1, 154,
+       93, 59, 120, 158, 178, 107, 107, 76, 90, 195, 150, 120, 149, 140,
+       240, 42, 98, 213, 164, 52, 92, 248, 86, 106, 104, 163, 40, 63,
+       115, 12, 161, 187, 113, 187, 118, 253, 215, 222, 175, 118, 176,
+       118, 31, 191, 179, 222, 151, 245, 121, 253, 191, 127, 247, 118,
+       189, 38, 237, 71, 190, 191, 123, 127, 117, 223, 174, 244, 180,
+       127, 85, 125, 167, 151, 156, 102, 71, 252, 86, 234, 223, 110, 117,
+       247, 137, 124, 85, 254, 124, 234, 233, 211, 191, 63, 249, 166,
+       255, 148, 59, 115, 165, 121, 246, 107, 124, 240, 236, 171, 223,
+       216, 203, 182, 180, 175, 159, 15, 213, 11, 239, 241, 95, 251, 232,
+       103, 76, 208, 254, 218, 239, 255, 53, 185, 71, 33, 156, 75, 46,
+       190, 46, 194, 222, 48, 132, 196, 210, 227, 245, 239, 179, 65, 78,
+       241, 63, 199, 232, 135, 6, 173, 240, 227, 234, 137, 52, 191, 53,
+       90, 188, 4, 46, 250, 141, 242, 84, 75, 213, 22, 237, 18, 66, 185,
+       57, 89, 217, 158, 131, 186, 58, 231, 8, 142, 83, 235, 208, 93,
+       243, 73, 252, 130, 218, 156, 183, 190, 139, 100, 153, 194, 155,
+       91, 149, 51, 236, 255, 106, 207, 231, 115, 255, 131, 35, 77, 186,
+       243, 145, 243, 90, 187, 146, 101, 37, 123, 60, 243, 164, 159, 189,
+       155, 150, 188, 150, 188, 223, 167, 234, 224, 202, 133, 93, 238,
+       228, 102, 236, 224, 235, 189, 234, 99, 229, 255, 86, 191, 220, 69,
+       222, 180, 183, 178, 171, 228, 153, 71, 187, 215, 133, 57, 140,
+       255, 106, 159, 231, 179, 253, 145, 51, 79, 186, 194, 153, 211,
+       223, 251, 130, 68, 167, 115, 184, 75, 106, 44, 84, 139, 67, 120,
+       85, 36, 252, 143, 51, 193, 55, 80, 120, 168, 134, 230, 200, 179,
+       116, 31, 243, 173, 161, 57, 119, 158, 118, 248, 134, 239, 27, 204,
+       238, 33, 175, 239, 202, 154, 24, 98, 149, 226, 229, 34, 163, 123,
+       22, 107, 113, 11, 138, 106, 184, 148, 47, 172, 20, 114, 167, 169,
+       184, 67, 99, 204, 85, 211, 239, 121, 85, 68, 246, 70, 97, 73, 181,
+       228, 120, 168, 6, 234, 233, 179, 36, 143, 115, 233, 162, 1, 119,
+       186, 116, 172, 57, 107, 74, 41, 116, 155, 98, 109, 101, 4, 254,
+       206, 163, 0, 179, 176, 122, 168, 70, 108, 78, 186, 101, 29, 246,
+       237, 34, 57, 119, 138, 90, 140, 199, 77, 93, 238, 236, 45, 175,
+       252, 136, 18, 57, 242, 245, 83, 185, 43, 174, 83, 27, 203, 243,
+       69, 10, 117, 100, 152, 238, 104, 28, 219, 129, 161, 140, 188, 164,
+       87, 153, 255, 178, 250, 210, 247, 5, 17, 250, 253, 74, 175, 189,
+       126, 179, 48, 180, 244, 186, 191, 111, 95, 85, 71, 194, 237, 92,
+       246, 28, 240, 147, 243, 162, 103, 31, 152, 54, 40, 83, 98, 215,
+       247, 105, 105, 245, 89, 29, 250, 27, 208, 57, 32, 201, 193, 47,
+       196, 152, 115, 165, 179, 223, 148, 164, 94, 187, 54, 30, 191, 19,
+       222, 158, 179, 232, 253, 223, 229, 213, 246, 189, 174, 252, 78,
+       251, 191, 123, 127, 215, 223, 178, 228, 188, 127, 173, 255, 174,
+       221, 188, 127, 151, 191, 22, 255, 86, 55, 242, 245, 203, 33, 29,
+       126, 245, 60, 247, 252, 251, 63, 107, 103, 117, 221, 210, 124,
+       220, 251, 122, 188, 156, 250, 139, 253, 20, 199, 159, 91, 172, 24,
+       174, 255, 100, 59, 205, 251, 255, 16, 63, 75, 218, 241, 219, 215,
+       94, 123, 218, 72, 143, 155, 108, 190, 135, 158, 217, 227, 71, 168,
+       55, 191, 227, 116, 224, 226, 106, 223, 81, 238, 234, 178, 59, 86,
+       219, 127, 44, 38, 255, 39, 152, 115, 230, 212, 155, 75, 42, 174,
+       20, 130, 187, 112, 132, 204, 210, 167, 121, 206, 179, 64, 252,
+       233, 31, 231, 236, 139, 4, 238, 240, 101, 170, 129, 61, 46, 56,
+       218, 185, 11, 99, 205, 86, 18, 235, 113, 85, 132, 254, 130, 57, 9,
+       180, 100, 120, 168, 6, 237, 232, 186, 101, 206, 118, 237, 162, 0,
+       119, 138, 112, 168, 220, 208, 151, 250, 89, 71, 67, 152, 151, 83,
+       71, 112, 119, 87, 40, 255, 87, 208, 61, 250, 43, 212, 59, 53, 209,
+       194, 225, 12, 50, 179, 4, 115, 92, 130, 229, 227, 139, 97, 91,
+       153, 38, 21, 141, 131, 95, 71, 72, 95, 55, 16, 125, 250, 26, 64,
+       235, 17, 201, 192, 229, 252, 178, 227, 164, 242, 87, 255, 167,
+       158, 152, 103, 23, 190, 87, 239, 222, 39, 112, 246, 175, 117, 117,
+       254, 61, 238, 249, 195, 63, 255, 249, 62, 239, 150, 139, 119, 164,
+       119, 36, 254, 158, 191, 60, 15, 151, 188, 30, 190, 118, 103, 240,
+       233, 203, 9, 29, 124, 103, 51, 163, 244, 219, 63, 104, 166, 245,
+       212, 201, 121, 80, 155, 201, 188, 188, 184, 169, 253, 53, 223,
+       255, 127, 164, 28, 190, 254, 74, 59, 165, 91, 126, 21, 183, 109,
+       186, 243, 223, 223, 87, 126, 216, 64, 131, 95, 150, 231, 5, 147,
+       147, 166, 174, 207, 153, 87, 138, 151, 12, 46, 94, 205, 237, 195,
+       129, 183, 126, 223, 9, 247, 184, 6, 159, 71, 169, 85, 189, 84, 9,
+       187, 19, 232, 116, 141, 185, 119, 173, 9, 120, 104, 188, 147, 32,
+       160, 164, 59, 23, 9, 211, 43, 2, 213, 197, 221, 58, 234, 24, 10,
+       163, 185, 9, 187, 19, 232, 96, 141, 185, 119, 174, 25, 88, 108,
+       188, 147, 224, 224, 134, 59, 95, 9, 19, 8, 130, 209, 205, 157, 58,
+       234, 8, 128, 131, 169, 193, 2, 94, 177, 4, 136, 225, 3, 236, 17,
+       226, 80, 181, 2, 129, 203, 106, 36, 106, 152, 1, 252, 197, 64,
+       148, 162, 242, 64, 140, 0, 73, 168, 165, 222, 140, 191, 186, 47,
+       23, 188, 22, 234, 188, 247, 247, 119, 171, 1, 93, 71, 55, 102,
+       249, 196, 91, 63, 238, 143, 101, 244, 184, 251, 8, 217, 213, 246,
+       157, 159, 174, 107, 167, 184, 30, 255, 147, 255, 230, 228, 203,
+       15, 29, 78, 110, 119, 123, 100, 235, 51, 172, 2, 125, 254, 216,
+       123, 133, 85, 3, 167, 18, 255, 118, 140, 184, 103, 188, 9, 90, 98,
+       172, 155, 160, 192, 230, 59, 23, 5, 210, 184, 0, 205, 36, 253, 58,
+       130, 12, 0, 169, 137, 65, 170, 145, 185, 124, 172, 185, 19, 174,
+       25, 58, 112, 156, 131, 192, 202, 135, 19, 126, 29, 19, 9, 130,
+       209, 204, 181, 58, 236, 156, 0, 3, 169, 90, 242, 131, 180, 3, 84,
+       24, 71, 43, 225, 136, 141, 172, 166, 74, 150, 180, 237, 249, 129,
+       12, 75, 146, 201, 153, 118, 222, 59, 130, 36, 47, 94, 51, 85, 77,
+       175, 94, 102, 159, 103, 4, 69, 216, 199, 48, 60, 36, 64, 108, 183,
+       23, 161, 76, 154, 85, 77, 177, 36, 170, 128, 61, 90, 176, 218,
+       212, 159, 183, 94, 188, 38, 135, 249, 210, 142, 185, 114, 96, 231,
+       173, 103, 117, 246, 108, 170, 249, 103, 171, 110, 56, 174, 231,
+       158, 210, 242, 228, 37, 237, 60, 132, 181, 173, 42, 228, 155, 178,
+       179, 147, 92, 211, 57, 81, 139, 9, 70, 124, 24, 61, 124, 219, 170,
+       206, 251, 245, 20, 206, 249, 216, 18, 149, 219, 157, 246, 170, 7,
+       30, 248, 134, 186, 144, 103, 87, 115, 105, 11, 212, 81, 93, 226,
+       233, 71, 27, 40, 249, 139, 239, 188, 56, 123, 161, 51, 2, 157, 58,
+       251, 118, 132, 184, 119, 172, 9, 90, 99, 188, 158, 52, 224, 230,
+       59, 151, 133, 210, 184, 0, 237, 103, 125, 186, 194, 4, 0, 169,
+       155, 65, 2, 159, 177, 44, 136, 168, 3, 174, 17, 50, 80, 189, 138,
+       208, 91, 162, 33, 127, 25, 2, 109, 131, 208, 132, 152, 122, 136,
+       140, 0, 1, 9, 17, 2, 95, 137, 6, 8, 232, 3, 236, 17, 242, 194,
+       157, 2, 20, 67, 106, 141, 106, 137, 2, 184, 197, 193, 148, 160,
+       154, 4, 37, 8, 97, 32, 1, 32, 8, 137, 86, 9, 224, 67, 108, 17,
+       226, 66, 181, 2, 64, 88, 104, 137, 10, 136, 2, 186, 69, 81, 148,
+       128, 154, 0, 113, 8, 33, 168, 248, 242, 218, 36, 99, 136, 112, 85,
+       163, 37, 117, 141, 47, 143, 74, 146, 170, 189, 225, 192, 78, 63,
+       130, 3, 115, 229, 36, 41, 107, 4, 110, 155, 248, 28, 186, 254,
+       205, 36, 84, 71, 85, 150, 230, 27, 47, 185, 97, 91, 217, 214, 161,
+       32, 40, 103, 144, 138, 243, 243, 212, 27, 227, 120, 252, 138, 237,
+       181, 197, 181, 172, 43, 108, 191, 23, 243, 154, 93, 211, 99, 88,
+       203, 217, 198, 108, 188, 125, 88, 219, 130, 174, 222, 213, 116,
+       142, 248, 216, 0, 233, 173, 132, 247, 172, 47, 108, 191, 55, 187,
+       154, 92, 223, 43, 88, 159, 133, 70, 125, 28, 59, 92, 219, 179,
+       238, 223, 245, 252, 138, 216, 218, 24, 0, 5, 107, 225, 54, 235,
+       169, 103, 60, 1, 91, 146, 181, 30, 48, 96, 110, 59, 19, 141, 18,
+       184, 5, 207, 197, 141, 186, 128, 37, 200, 177, 168, 150, 78, 110,
+       158, 66, 146, 190, 96, 149, 134, 215, 231, 105, 206, 183, 69, 126,
+       233, 131, 231, 228, 151, 44, 238, 50, 34, 202, 131, 53, 183, 45,
+       213, 98, 184, 59, 250, 91, 229, 145, 192, 139, 89, 185, 11, 60,
+       222, 110, 24, 200, 179, 211, 145, 18, 43, 58, 245, 91, 20, 154,
+       123, 209, 7, 39, 210, 161, 227, 120, 45, 116, 141, 224, 55, 112,
+       13, 116, 93, 179, 9, 158, 0, 60, 136, 70, 13, 206, 184, 199, 21,
+       38, 41, 48, 224, 101, 136, 218, 137, 1, 245, 248, 5, 116, 29, 229,
+       55, 108, 193, 126, 108, 183, 48, 214, 34, 14, 226, 86, 13, 195,
+       248, 213, 43, 46, 77, 52, 32, 77, 152, 203, 45, 66, 65, 113, 233,
+       46, 128, 248, 1, 137, 49, 17, 226, 141, 11, 180, 66, 230, 145, 31,
+       129, 128, 12, 0, 213, 134, 248, 154, 230, 20, 130, 209, 133, 2, 0,
+       81, 225, 118, 136, 248, 66, 141, 1, 176, 194, 157, 11, 52, 8, 234,
+       161, 23, 157, 0, 168, 64, 196, 148, 152, 154, 200, 37, 136, 113,
+       136, 1, 0, 89, 193, 100, 137, 168, 67, 46, 17, 112, 210, 157, 131,
+       240, 72, 106, 9, 19, 137, 2, 60, 134, 209, 20, 144, 186, 104, 29,
+       136, 33, 168, 184, 122, 248, 113, 30, 207, 147, 220, 194, 188,
+       180, 43, 51, 141, 71, 18, 108, 112, 196, 88, 34, 237, 112, 30,
+       235, 201, 37, 113, 115, 136, 76, 235, 29, 212, 27, 226, 242, 37,
+       79, 248, 48, 42, 89, 72, 87, 243, 105, 113, 245, 217, 28, 122, 57,
+       210, 8, 44, 249, 201, 47, 100, 184, 115, 161, 33, 229, 229, 197,
+       177, 168, 34, 76, 191, 19, 243, 170, 212, 211, 98, 89, 223, 89,
+       198, 108, 188, 125, 78, 223, 178, 172, 222, 213, 116, 188, 240,
+       192, 28, 231, 237, 213, 247, 232, 37, 78, 191, 19, 187, 184, 92,
+       225, 99, 209, 223, 205, 198, 127, 158, 127, 78, 203, 243, 174,
+       222, 213, 188, 154, 240, 194, 24, 100, 131, 173, 161, 172, 47, 77,
+       27, 2, 191, 147, 217, 215, 111, 90, 74, 213, 7, 125, 53, 152, 64,
+       203, 16, 205, 135, 253, 244, 132, 232, 148, 96, 34, 26, 148, 188,
+       41, 40, 176, 74, 175, 22, 168, 37, 238, 250, 37, 222, 201, 179,
+       235, 1, 4, 99, 83, 217, 145, 242, 90, 27, 216, 124, 47, 142, 176,
+       114, 122, 92, 86, 200, 241, 84, 121, 4, 116, 40, 51, 157, 148, 53,
+       34, 56, 71, 104, 226, 247, 176, 45, 87, 137, 48, 57, 103, 145, 87,
+       171, 199, 146, 135, 136, 222, 244, 171, 200, 142, 93, 195, 183,
+       28, 150, 238, 234, 101, 19, 187, 149, 183, 7, 163, 215, 92, 36,
+       186, 207, 149, 5, 181, 117, 60, 48, 253, 247, 76, 102, 91, 24, 2,
+       223, 119, 50, 113, 119, 72, 43, 92, 84, 117, 226, 9, 225, 187,
+       161, 67, 235, 225, 140, 227, 235, 100, 242, 25, 5, 3, 237, 20,
+       199, 105, 115, 20, 168, 218, 66, 49, 51, 49, 96, 120, 172, 30,
+       168, 105, 152, 17, 30, 249, 166, 171, 128, 57, 8, 49, 40, 34, 162,
+       104, 154, 79, 145, 184, 73, 207, 29, 85, 191, 8, 200, 254, 140,
+       207, 139, 179, 149, 150, 106, 206, 209, 30, 17, 218, 239, 221, 12,
+       251, 199, 102, 28, 123, 222, 123, 224, 19, 192, 132, 4, 201, 161,
+       16, 215, 33, 80, 74, 57, 147, 194, 10, 3, 122, 125, 81, 164, 139,
+       155, 48, 35, 38, 242, 227, 191, 133, 151, 168, 46, 108, 183, 187,
+       243, 170, 221, 234, 34, 68, 223, 197, 230, 232, 4, 189, 200, 219,
+       226, 174, 246, 215, 50, 138, 244, 138, 28, 25, 5, 83, 237, 22, 38,
+       105, 115, 52, 168, 90, 70, 53, 35, 48, 64, 112, 172, 22, 172, 41,
+       152, 17, 30, 225, 239, 170, 128, 57, 160, 32, 40, 1, 32, 31, 144,
+       108, 141, 168, 70, 172, 25, 242, 88, 148, 146, 32, 90, 236, 49,
+       90, 24, 16, 191, 16, 192, 149, 144, 122, 74, 72, 8, 33, 137, 66,
+       168, 148, 147, 108, 136, 168, 140, 174, 17, 2, 1, 172, 138, 68,
+       74, 163, 79, 107, 81, 2, 73, 139, 241, 12, 16, 95, 111, 128, 8, 1,
+       138, 42, 146, 118, 115, 229, 187, 240, 67, 173, 63, 123, 57, 14,
+       25, 60, 157, 171, 19, 247, 35, 22, 177, 2, 213, 71, 211, 80, 199,
+       215, 79, 206, 135, 212, 44, 27, 250, 168, 224, 95, 203, 165, 10,
+       173, 56, 151, 215, 97, 127, 197, 179, 205, 178, 59, 7, 170, 114,
+       243, 245, 2, 127, 176, 115, 166, 35, 254, 223, 57, 122, 169, 244,
+       23, 148, 129, 94, 189, 189, 126, 93, 139, 242, 133, 211, 221, 199,
+       239, 7, 120, 163, 227, 253, 44, 155, 90, 215, 190, 123, 67, 112,
+       125, 250, 108, 133, 249, 84, 137, 25, 145, 249, 156, 159, 124, 43,
+       142, 49, 95, 215, 146, 39, 10, 241, 71, 24, 250, 250, 149, 3, 131,
+       83, 67, 112, 121, 250, 108, 132, 248, 21, 137, 25, 177, 127, 188,
+       159, 92, 11, 142, 51, 95, 211, 146, 97, 210, 241, 5, 24, 186, 250,
+       149, 1, 195, 131, 3, 24, 27, 211, 100, 172, 248, 64, 171, 25, 179,
+       94, 156, 154, 116, 26, 236, 177, 95, 145, 3, 44, 210, 224, 21, 24,
+       186, 234, 141, 9, 97, 131, 67, 0, 19, 152, 108, 141, 176, 68, 172,
+       9, 243, 88, 156, 147, 32, 123, 230, 25, 91, 17, 2, 11, 130, 192,
+       149, 48, 58, 122, 24, 8, 35, 171, 98, 9, 182, 244, 141, 150, 152,
+       7, 139, 185, 186, 19, 140, 154, 68, 206, 200, 247, 251, 145, 28,
+       235, 195, 224, 27, 254, 222, 83, 131, 12, 233, 14, 106, 1, 180,
+       255, 141, 124, 220, 7, 143, 9, 191, 19, 172, 57, 20, 206, 200, 55,
+       255, 1, 28, 169, 195, 193, 135, 251, 216, 155, 147, 92, 220, 14,
+       30, 54, 118, 114, 195, 53, 124, 200, 33, 63, 57, 51, 9, 255, 111,
+       157, 191, 155, 135, 178, 62, 211, 24, 208, 27, 217, 212, 239, 163,
+       215, 46, 151, 178, 209, 97, 206, 79, 193, 85, 253, 135, 84, 29,
+       175, 98, 245, 44, 133, 88, 146, 147, 98, 106, 35, 122, 189, 51,
+       193, 204, 59, 55, 94, 148, 250, 96, 133, 131, 213, 225, 206, 109,
+       51, 185, 107, 111, 88, 82, 183, 0, 246, 132, 54, 125, 8, 89, 156,
+       176, 2, 167, 254, 212, 0, 2, 240, 198, 112, 30, 196, 129, 251, 21,
+       159, 75, 140, 23, 39, 133, 18, 239, 67, 121, 204, 89, 24, 139, 30,
+       10, 148, 89, 182, 141, 214, 151, 118, 178, 31, 20, 44, 88, 191,
+       132, 183, 173, 190, 124, 183, 187, 179, 138, 253, 239, 227, 0,
+       223, 133, 230, 236, 20, 63, 216, 211, 231, 174, 246, 223, 82, 138,
+       196, 154, 24, 70, 49, 121, 250, 108, 172, 248, 0, 139, 25, 17, 91,
+       188, 159, 124, 43, 166, 179, 95, 211, 147, 33, 154, 241, 7, 24,
+       154, 250, 157, 11, 195, 147, 66, 80, 19, 186, 105, 133, 152, 65,
+       172, 9, 241, 88, 156, 159, 32, 88, 236, 49, 95, 17, 2, 11, 82,
+       208, 149, 48, 26, 122, 16, 8, 163, 163, 72, 145, 55, 186, 211,
+       196, 57, 183, 191, 85, 7, 21, 92, 183, 40, 84, 55, 23, 59, 28, 18,
+       9, 58, 215, 249, 230, 94, 78, 146, 2, 165, 114, 34, 32, 212, 169,
+       12, 139, 232, 72, 78, 49, 227, 2, 134, 10, 28, 10, 234, 133, 106,
+       153, 10, 177, 67, 192, 148, 0, 138, 84, 5, 10, 83, 128, 222, 78,
+       222, 165, 34, 58, 62, 240, 172, 174, 83, 231, 77, 106, 163, 203,
+       38, 117, 173, 231, 228, 213, 13, 200, 208, 227, 107, 133, 37, 247,
+       41, 17, 231, 241, 126, 250, 237, 212, 216, 212, 139, 89, 145, 189,
+       156, 222, 124, 59, 134, 19, 215, 87, 214, 3, 186, 241, 83, 88,
+       202, 251, 156, 23, 215, 87, 194, 177, 49, 155, 107, 141, 184, 9,
+       139, 49, 145, 169, 172, 222, 68, 10, 134, 49, 251, 145, 134, 77,
+       210, 209, 15, 16, 27, 251, 20, 0, 3, 159, 38, 152, 245, 218, 235,
+       193, 148, 204, 223, 23, 112, 179, 108, 252, 45, 91, 199, 19, 167,
+       17, 150, 107, 14, 241, 27, 18, 86, 75, 213, 92, 229, 207, 22, 241,
+       48, 162, 155, 197, 21, 221, 135, 53, 129, 191, 156, 223, 106, 0,
+       39, 155, 219, 211, 90, 15, 154, 209, 249, 144, 13, 126, 62, 10,
+       133, 115, 7, 22, 197, 5, 226, 42, 173, 63, 60, 243, 91, 247, 221,
+       46, 158, 111, 55, 7, 54, 45, 181, 212, 229, 64, 12, 42, 126, 196,
+       141, 228, 129, 213, 102, 208, 127, 250, 79, 196, 185, 196, 139,
+       81, 177, 3, 188, 222, 109, 75, 238, 145, 155, 211, 2, 39, 26, 241,
+       149, 24, 218, 107, 21, 27, 167, 251, 118, 81, 51, 186, 79, 205,
+       176, 68, 141, 29, 177, 27, 140, 158, 108, 88, 236, 145, 219, 211,
+       18, 3, 82, 240, 145, 16, 154, 123, 16, 11, 165, 115, 143, 158,
+       237, 23, 224, 112, 191, 183, 56, 127, 95, 244, 252, 54, 142, 255,
+       135, 87, 180, 14, 245, 220, 109, 99, 110, 63, 254, 194, 142, 245,
+       141, 125, 166, 81, 123, 250, 207, 196, 221, 196, 139, 85, 177, 19,
+       12, 222, 110, 91, 234, 147, 159, 211, 78, 39, 58, 240, 147, 144,
+       154, 123, 149, 31, 165, 86, 114, 120, 50, 138, 105, 245, 150, 68,
+       137, 93, 153, 45, 142, 156, 103, 9, 204, 187, 223, 67, 14, 15,
+       210, 241, 147, 16, 26, 187, 16, 31, 167, 223, 167, 13, 1, 138,
+       205, 229, 196, 107, 30, 246, 89, 159, 32, 168, 119, 129, 217, 170,
+       162, 23, 53, 122, 94, 242, 60, 16, 205, 57, 156, 78, 216, 220, 20,
+       248, 255, 122, 210, 233, 179, 204, 254, 23, 97, 56, 215, 215, 45,
+       57, 163, 89, 224, 82, 34, 103, 58, 49, 209, 231, 48, 79, 208, 17,
+       103, 163, 173, 223, 198, 190, 188, 59, 103, 252, 214, 230, 29,
+       252, 211, 229, 187, 135, 93, 70, 238, 110, 245, 97, 63, 63, 238,
+       199, 229, 180, 254, 255, 216, 208, 245, 239, 142, 158, 188, 43,
+       207, 248, 94, 174, 219, 126, 247, 224, 187, 129, 27, 110, 110,
+       111, 241, 229, 139, 63, 184, 166, 239, 148, 220, 251, 217, 1, 254,
+       121, 236, 8, 143, 81, 84, 200, 195, 246, 164, 143, 74, 204, 127,
+       159, 232, 193, 233, 231, 76, 99, 254, 208, 19, 89, 197, 63, 119,
+       127, 126, 86, 255, 253, 187, 74, 171, 85, 31, 216, 203, 220, 156,
+       47, 74, 252, 239, 54, 206, 209, 213, 119, 207, 3, 186, 240, 251,
+       89, 69, 255, 247, 127, 190, 119, 233, 153, 80, 76, 219, 159, 70,
+       233, 201, 32, 185, 12, 10, 112, 172, 180, 152, 130, 194, 98, 113,
+       59, 88, 189, 55, 217, 65, 62, 91, 15, 202, 180, 110, 57, 168, 171,
+       137, 100, 155, 138, 130, 245, 136, 149, 157, 190, 67, 10, 207, 95,
+       249, 209, 30, 66, 218, 160, 205, 85, 143, 255, 140, 119, 7, 210,
+       182, 225, 126, 138, 173, 241, 222, 204, 139, 84, 157, 139, 14,
+       206, 127, 11, 234, 211, 151, 243, 94, 35, 58, 240, 187, 80, 143,
+       127, 149, 127, 253, 214, 103, 241, 252, 26, 203, 217, 176, 196,
+       239, 85, 101, 191, 40, 220, 110, 95, 238, 153, 235, 211, 134, 118,
+       222, 241, 22, 16, 88, 235, 221, 23, 174, 215, 244, 31, 101, 234,
+       188, 70, 207, 189, 140, 216, 187, 231, 211, 13, 181, 67, 78, 197,
+       29, 247, 233, 97, 93, 204, 233, 186, 239, 148, 93, 251, 117, 123,
+       101, 115, 147, 229, 124, 6, 171, 21, 106, 40, 242, 76, 20, 155,
+       17, 178, 220, 29, 127, 93, 195, 183, 209, 2, 117, 172, 170, 212,
+       72, 154, 3, 161, 222, 149, 37, 139, 153, 167, 75, 184, 133, 125,
+       143, 135, 204, 39, 56, 197, 68, 150, 189, 239, 56, 9, 89, 253,
+       185, 242, 202, 214, 50, 143, 180, 118, 205, 253, 134, 28, 136,
+       151, 6, 238, 150, 250, 70, 245, 112, 246, 227, 119, 145, 110, 232,
+       70, 100, 79, 171, 62, 104, 7, 125, 40, 128, 116, 40, 92, 254, 229,
+       120, 238, 175, 80, 222, 236, 139, 214, 156, 171, 78, 221, 127, 7,
+       191, 211, 213, 231, 206, 3, 170, 243, 243, 217, 205, 191, 55, 255,
+       252, 87, 118, 79, 34, 154, 205, 245, 214, 196, 201, 94, 189, 11,
+       42, 206, 127, 159, 233, 227, 195, 215, 78, 35, 170, 240, 179, 80,
+       143, 59, 83, 95, 238, 198, 65, 161, 177, 70, 198, 77, 231, 125,
+       90, 74, 121, 74, 246, 248, 220, 164, 184, 202, 50, 75, 209, 58,
+       188, 99, 61, 12, 30, 42, 69, 106, 209, 173, 55, 113, 35, 99, 194,
+       15, 255, 113, 108, 202, 251, 111, 18, 28, 213, 48, 252, 153, 95,
+       239, 203, 179, 217, 74, 117, 12, 38, 164, 105, 90, 114, 185, 134,
+       226, 206, 90, 233, 217, 120, 200, 143, 92, 117, 231, 8, 206, 255,
+       255, 231, 200, 238, 86, 198, 70, 174, 241, 22, 16, 199, 175, 150,
+       159, 124, 213, 236, 239, 207, 158, 220, 99, 79, 172, 18, 182, 251,
+       254, 241, 226, 169, 209, 91, 238, 46, 234, 121, 215, 207, 127,
+       184, 167, 239, 156, 181, 115, 254, 32, 141, 253, 134, 31, 155,
+       187, 22, 174, 150, 155, 79, 57, 226, 244, 201, 45, 17, 126, 232,
+       54, 54, 196, 235, 63, 105, 35, 69, 86, 194, 125, 148, 119, 135,
+       242, 228, 27, 109, 21, 73, 216, 95, 95, 85, 215, 74, 192, 255,
+       221, 119, 200, 190, 94, 135, 84, 127, 241, 14, 90, 85, 238, 158,
+       189, 120, 117, 86, 131, 140, 190, 173, 92, 84, 168, 33, 126, 199,
+       13, 71, 100, 202, 223, 176, 196, 236, 110, 93, 65, 171, 129, 146,
+       243, 65, 31, 42, 255, 220, 84, 225, 23, 109, 133, 228, 122, 175,
+       26, 74, 238, 95, 246, 80, 12, 150, 98, 127, 198, 54, 175, 161,
+       176, 173, 79, 116, 47, 171, 132, 13, 219, 245, 241, 244, 64, 213,
+       90, 224, 75, 70, 136, 123, 146, 225, 72, 91, 66, 141, 253, 49,
+       220, 36, 122, 107, 102, 75, 48, 18, 250, 69, 30, 211, 177, 98, 36,
+       120, 80, 187, 246, 53, 94, 83, 116, 85, 73, 183, 125, 246, 53,
+       162, 116, 220, 244, 223, 106, 169, 175, 120, 174, 243, 255, 18,
+       90, 10, 31, 180, 127, 218, 151, 36, 170, 45, 15, 89, 57, 133, 116,
+       143, 135, 207, 77, 58, 67, 196, 1, 125, 103, 216, 13, 91, 149,
+       232, 83, 203, 212, 62, 174, 149, 82, 204, 255, 19, 183, 170, 41,
+       54, 183, 60, 34, 203, 253, 253, 39, 9, 139, 7, 87, 203, 67, 113,
+       221, 201, 42, 236, 199, 124, 176, 140, 123, 133, 57, 61, 95, 223,
+       227, 213, 246, 111, 148, 49, 105, 127, 70, 121, 23, 147, 252, 124,
+       238, 151, 218, 129, 180, 57, 238, 103, 239, 164, 192, 107, 215,
+       254, 121, 211, 60, 59, 244, 119, 236, 93, 67, 185, 226, 6, 24, 63,
+       151, 99, 119, 162, 189, 125, 9, 105, 95, 178, 138, 249, 249, 11,
+       58, 32, 96, 7, 126, 210, 148, 58, 254, 59, 240, 153, 109, 189, 79,
+       221, 50, 253, 222, 46, 102, 238, 147, 253, 129, 42, 15, 171, 199,
+       211, 245, 154, 155, 21, 2, 165, 123, 29, 241, 135, 15, 24, 31, 2,
+       188, 6, 249, 74, 97, 114, 240, 136, 36, 16, 124, 232, 116, 31,
+       216, 235, 61, 201, 39, 109, 84, 192, 43, 16, 254, 93, 101, 221,
+       69, 234, 85, 46, 253, 64, 250, 60, 106, 217, 242, 205, 167, 68,
+       92, 126, 234, 197, 66, 235, 8, 55, 201, 103, 173, 10, 251, 233,
+       161, 163, 116, 57, 241, 233, 239, 93, 115, 185, 226, 36, 24, 31,
+       151, 67, 57, 149, 189, 85, 46, 233, 85, 240, 154, 183, 217, 13,
+       54, 34, 240, 130, 244, 188, 213, 63, 235, 165, 228, 199, 212, 69,
+       95, 127, 118, 91, 93, 62, 65, 253, 203, 164, 195, 251, 182, 123,
+       163, 225, 249, 166, 66, 105, 91, 244, 115, 173, 92, 121, 233, 252,
+       111, 87, 222, 21, 111, 248, 93, 31, 61, 7, 56, 157, 219, 86, 38,
+       189, 38, 121, 178, 39, 223, 52, 62, 217, 217, 196, 241, 183, 124,
+       109, 184, 234, 115, 88, 202, 22, 242, 148, 187, 145, 30, 243, 41,
+       79, 217, 151, 243, 47, 70, 125, 178, 218, 195, 235, 253, 189, 249,
+       28, 210, 116, 156, 173, 183, 164, 232, 119, 166, 186, 27, 242, 49,
+       118, 125, 9, 91, 233, 247, 37, 3, 122, 120, 203, 103, 253, 166,
+       119, 66, 192, 121, 244, 43, 172, 222, 249, 251, 213, 100, 247,
+       254, 212, 79, 221, 86, 217, 121, 61, 97, 217, 82, 31, 243, 255,
+       46, 120, 174, 127, 239, 167, 109, 255, 251, 244, 211, 207, 157,
+       239, 222, 242, 47, 191, 184, 184, 198, 28, 144, 253, 119, 187, 39,
+       55, 114, 51, 46, 241, 64, 62, 111, 111, 31, 111, 172, 134, 247,
+       129, 241, 172, 221, 245, 119, 225, 111, 247, 183, 17, 255, 62, 29,
+       234, 61, 3, 155, 141, 118, 135, 2, 113, 252, 121, 170, 111, 223,
+       84, 19, 202, 253, 198, 218, 220, 156, 44, 186, 157, 46, 95, 190,
+       22, 39, 143, 23, 215, 105, 59, 72, 81, 199, 61, 47, 184, 5, 89,
+       191, 240, 103, 234, 213, 188, 125, 152, 82, 245, 223, 140, 190,
+       158, 127, 71, 174, 214, 254, 141, 30, 227, 224, 43, 65, 121, 230,
+       108, 98, 125, 103, 127, 63, 185, 231, 231, 61, 185, 123, 220, 84,
+       124, 81, 233, 119, 48, 126, 114, 24, 55, 233, 87, 229, 211, 61,
+       153, 252, 116, 252, 189, 252, 185, 208, 209, 142, 167, 239, 161,
+       192, 171, 183, 216, 51, 13, 220, 236, 211, 212, 246, 223, 188, 82,
+       218, 149, 18, 208, 126, 219, 105, 121, 254, 23, 187, 253, 218,
+       124, 127, 111, 15, 255, 197, 157, 243, 245, 227, 116, 175, 206,
+       190, 156, 99, 78, 175, 86, 182, 202, 154, 231, 226, 59, 81, 89,
+       238, 108, 170, 125, 211, 223, 63, 186, 231, 237, 21, 172, 251,
+       216, 0, 136, 121, 37, 119, 40, 79, 124, 156, 118, 232, 90, 225,
+       251, 221, 216, 97, 252, 94, 127, 70, 201, 244, 235, 189, 71, 235,
+       97, 192, 118, 159, 20, 251, 47, 220, 164, 159, 173, 61, 199, 175,
+       95, 247, 12, 31, 238, 40, 87, 143, 201, 74, 51, 15, 255, 124, 91,
+       179, 175, 94, 221, 54, 158, 125, 216, 222, 39, 236, 165, 151, 173,
+       253, 214, 172, 219, 251, 17, 25, 238, 248, 95, 175, 153, 110, 116,
+       95, 247, 120, 218, 171, 45, 94, 85, 50, 222, 127, 218, 142, 106,
+       100, 54, 92, 73, 189, 182, 78, 190, 174, 180, 25, 76, 221, 113,
+       185, 217, 57, 255, 35, 34, 71, 138, 223, 115, 93, 57, 187, 82, 93,
+       39, 227, 47, 191, 164, 183, 221, 151, 206, 184, 147, 255, 201,
+       205, 233, 232, 95, 139, 221, 239, 177, 223, 190, 90, 218, 177,
+       175, 95, 221, 252, 142, 126, 216, 220, 29, 157, 140, 183, 180, 39,
+       86, 190, 22, 251, 71, 23, 215, 120, 123, 73, 209, 111, 61, 87,
+       252, 216, 89, 170, 232, 199, 255, 117, 188, 127, 153, 91, 218,
+       127, 39, 78, 59, 147, 22, 92, 183, 174, 210, 125, 74, 219, 228,
+       197, 236, 212, 239, 98, 252, 199, 203, 178, 178, 112, 35, 191, 10,
+       157, 164, 23, 110, 119, 6, 11, 249, 31, 182, 220, 135, 232, 219,
+       239, 193, 204, 233, 68, 220, 28, 235, 118, 213, 211, 223, 178,
+       118, 116, 131, 187, 10, 223, 152, 151, 152, 115, 108, 45, 26, 27,
+       186, 220, 22, 164, 222, 239, 201, 205, 210, 192, 94, 220, 239,
+       226, 204, 208, 239, 31, 78, 195, 233, 149, 55, 191, 28, 209, 20,
+       124, 7, 206, 139, 67, 39, 72, 164, 110, 223, 42, 82, 214, 163,
+       117, 120, 220, 126, 226, 105, 135, 251, 234, 177, 36, 163, 186,
+       34, 123, 164, 118, 93, 49, 87, 78, 239, 115, 54, 72, 119, 232,
+       239, 98, 90, 246, 233, 244, 114, 212, 238, 66, 13, 243, 239, 242,
+       55, 247, 35, 11, 34, 115, 236, 37, 116, 111, 253, 103, 254, 10,
+       71, 248, 83, 172, 189, 106, 83, 97, 201, 18, 27, 196, 109, 106,
+       104, 99, 233, 42, 250, 175, 101, 60, 101, 251, 66, 33, 253, 247,
+       220, 170, 172, 31, 87, 248, 83, 191, 181, 45, 211, 113, 203, 27,
+       93, 204, 108, 126, 238, 102, 203, 23, 250, 203, 101, 125, 250,
+       251, 74, 3, 125, 239, 101, 102, 60, 15, 79, 248, 115, 172, 189,
+       106, 115, 113, 217, 54, 92, 228, 124, 110, 233, 243, 237, 14, 250,
+       206, 165, 180, 103, 187, 82, 97, 61, 71, 109, 109, 60, 31, 79,
+       120, 84, 234, 255, 206, 83, 101, 153, 48, 60, 228, 126, 238, 233,
+       178, 109, 14, 242, 207, 165, 148, 125, 187, 82, 49, 53, 87, 111,
+       109, 54, 14, 79, 120, 84, 232, 255, 238, 83, 105, 153, 96, 126,
+       236, 62, 238, 233, 178, 77, 14, 246, 239, 161, 148, 109, 187, 112,
+       145, 114, 129, 144, 168, 149, 77, 86, 13, 31, 37, 187, 11, 110,
+       248, 104, 192, 216, 147, 172, 1, 30, 43, 91, 147, 177, 244, 5, 63,
+       241, 94, 140, 6, 39, 181, 67, 130, 245, 229, 107, 114, 9, 233, 89,
+       207, 24, 245, 244, 20, 92, 138, 19, 60, 147, 58, 184, 222, 62, 28,
+       129, 238, 191, 207, 82, 244, 203, 176, 255, 65, 162, 86, 185, 159,
+       88, 247, 54, 182, 28, 63, 246, 111, 7, 87, 177, 188, 181, 253,
+       181, 192, 75, 123, 86, 68, 143, 128, 165, 253, 203, 152, 239, 241,
+       164, 116, 249, 158, 125, 127, 22, 213, 188, 61, 214, 106, 135, 87,
+       191, 29, 179, 216, 181, 227, 79, 123, 254, 196, 142, 196, 213,
+       121, 35, 165, 65, 203, 241, 198, 171, 105, 11, 72, 121, 198, 24,
+       214, 252, 244, 92, 10, 19, 252, 211, 154, 120, 221, 45, 28, 142,
+       230, 31, 142, 242, 244, 186, 12, 238, 244, 231, 246, 89, 119, 17,
+       79, 214, 187, 15, 61, 178, 175, 238, 183, 149, 21, 188, 159, 32,
+       160, 211, 251, 88, 195, 231, 204, 190, 235, 143, 222, 253, 243,
+       164, 84, 125, 151, 33, 127, 54, 244, 185, 63, 222, 239, 79, 215,
+       191, 156, 251, 220, 241, 225, 111, 219, 254, 192, 143, 212, 229,
+       249, 32, 180, 248, 79, 125, 124, 215, 95, 75, 5, 125, 10, 34, 249,
+       190, 116, 89, 218, 2, 8, 210, 170, 240, 177, 103, 60, 0, 59, 83,
+       202, 198, 175, 24, 8, 108, 252, 71, 243, 89, 47, 17, 70, 68, 10,
+       61, 29, 19, 45, 42, 185, 145, 137, 41, 60, 54, 157, 211, 235, 216,
+       33, 55, 236, 94, 234, 190, 28, 109, 253, 71, 245, 121, 115, 145,
+       198, 100, 6, 57, 127, 51, 61, 104, 185, 147, 168, 41, 176, 50,
+       221, 87, 203, 193, 33, 51, 229, 84, 242, 189, 20, 125, 253, 199,
+       254, 125, 81, 253, 70, 117, 22, 91, 127, 63, 121, 252, 185, 147,
+       168, 185, 180, 50, 218, 71, 203, 195, 2, 243, 96, 102, 242, 175,
+       24, 255, 227, 161, 118, 125, 23, 117, 207, 246, 20, 155, 63, 150,
+       255, 206, 223, 183, 156, 185, 158, 113, 224, 199, 251, 254, 192,
+       167, 212, 228, 249, 239, 152, 252, 227, 228, 62, 121, 150, 121,
+       127, 246, 191, 223, 61, 158, 253, 111, 215, 183, 29, 189, 252,
+       117, 226, 223, 251, 118, 199, 199, 221, 220, 125, 57, 212, 59,
+       224, 85, 86, 81, 254, 81, 125, 230, 14, 58, 29, 42, 33, 249, 154,
+       147, 160, 235, 191, 48, 133, 251, 201, 144, 103, 43, 24, 116, 250,
+       227, 158, 252, 247, 244, 191, 253, 183, 123, 255, 180, 191, 253,
+       127, 222, 63, 239, 247, 127, 149, 188, 110, 105, 246, 255, 223,
+       255, 242, 135, 236, 228, 251, 3, 156, 247, 245, 244, 111, 254,
+       255, 159, 235, 120, 119, 252, 127, 180, 96, 255, 115, 31, 177,
+       241, 88, 26, 255, 239, 222, 255, 166, 156, 236, 193, 255, 38, 77,
+       53, 219, 157, 237, 129, 238, 204, 148, 176, 2, 226, 124, 53, 175,
+       200, 50, 91, 113, 163, 105, 119, 188, 45, 24, 70, 90, 213, 24, 85,
+       236, 83, 201, 231, 132, 15, 93, 190, 160, 205, 112, 154, 143, 253,
+       140, 247, 230, 166, 101, 122, 79, 197, 33, 183, 241, 144, 56, 75,
+       150, 28, 63, 25, 92, 248, 144, 123, 224, 87, 82, 209, 67, 83, 229,
+       230, 19, 2, 157, 102, 80, 232, 156, 129, 144, 88, 251, 241, 132,
+       91, 225, 144, 87, 227, 8, 124, 114, 239, 159, 244, 254, 237, 159,
+       222, 184, 251, 250, 180, 173, 255, 254, 151, 189, 255, 247, 255,
+       231, 172, 111, 110, 255, 254, 255, 239, 183, 223, 245, 75, 87, 46,
+       186, 254, 246, 236, 223, 223, 248, 155, 222, 180, 175, 255, 253,
+       255, 43, 255, 247, 255, 183, 172, 227, 238, 238, 255, 223, 255,
+       255, 231, 252, 86, 119, 12, 180, 57, 231, 246, 102, 127, 251, 20,
+       238, 125, 51, 253, 119, 66, 33, 55, 94, 23, 42, 177, 218, 185,
+       142, 237, 207, 47, 164, 166, 234, 37, 243, 40, 158, 110, 69, 115,
+       126, 187, 55, 0, 79, 126, 182, 121, 55, 134, 38, 79, 126, 151,
+       172, 177, 156, 117, 143, 111, 239, 160, 193, 231, 236, 214, 249,
+       129, 149, 53, 91, 189, 239, 161, 238, 222, 125, 176, 18, 174, 20,
+       172, 165, 201, 18, 74, 121, 179, 41, 127, 181, 45, 144, 80, 118,
+       82, 72, 5, 236, 83, 191, 144, 164, 13, 37, 150, 103, 207, 170,
+       154, 110, 166, 184, 68, 2, 204, 247, 125, 129, 216, 43, 211, 226,
+       184, 148, 143, 178, 8, 106, 145, 15, 193, 156, 13, 149, 126, 102,
+       171, 55, 248, 107, 214, 126, 245, 52, 146, 98, 103, 103, 126, 173,
+       181, 222, 245, 15, 252, 39, 186, 192, 140, 0, 177, 121, 71, 8,
+       172, 159, 142, 100, 169, 10, 158, 215, 71, 2, 253, 118, 83, 107,
+       99, 119, 59, 159, 144, 192, 247, 224, 77, 47, 250, 128, 133, 97,
+       53, 104, 141, 121, 152, 81, 226, 86, 47, 29, 118, 234, 70, 84,
+       216, 146, 195, 236, 55, 108, 54, 222, 231, 212, 253, 66, 76, 175,
+       55, 164, 10, 240, 137, 185, 168, 174, 21, 213, 21, 42, 35, 55,
+       144, 186, 178, 122, 230, 49, 0, 135, 73, 254, 76, 32, 56, 254,
+       192, 15, 172, 162, 116, 50, 66, 104, 134, 169, 12, 12, 174, 223,
+       132, 118, 105, 154, 116, 150, 78, 2, 121, 115, 51, 107, 97, 246,
+       59, 154, 48, 213, 35, 232, 79, 175, 250, 1, 179, 225, 125, 170,
+       104, 240, 220, 97, 180, 14, 113, 151, 43, 189, 190, 57, 151, 17,
+       66, 26, 201, 214, 109, 24, 26, 248, 209, 0, 207, 255, 52, 85, 232,
+       136, 202, 11, 188, 5, 116, 105, 230, 19, 222, 237, 85, 162, 116,
+       34, 91, 61, 181, 169, 190, 211, 151, 234, 236, 240, 9, 156, 99,
+       219, 101, 135, 119, 248, 226, 171, 95, 120, 237, 101, 151, 86, 95,
+       149, 103, 238, 150, 39, 219, 31, 19, 126, 119, 229, 253, 191, 205,
+       197, 125, 136, 235, 239, 181, 151, 46, 246, 220, 127, 200, 188,
+       189, 177, 190, 232, 49, 183, 210, 255, 10, 51, 255, 253, 66, 2,
+       163, 111, 121, 17, 50, 124, 139, 54, 239, 199, 61, 101, 160, 104,
+       149, 75, 248, 164, 31, 186, 143, 225, 183, 206, 190, 183, 168, 27,
+       85, 251, 97, 90, 233, 219, 235, 147, 58, 103, 218, 51, 249, 195,
+       159, 125, 145, 91, 167, 138, 126, 92, 237, 229, 183, 86, 94, 157,
+       81, 234, 150, 99, 91, 61, 183, 251, 247, 213, 253, 117, 172, 229,
+       57, 142, 251, 255, 229, 151, 167, 253, 116, 123, 236, 94, 92, 113,
+       105, 58, 65, 178, 115, 190, 46, 60, 75, 3, 131, 223, 65, 228, 172,
+       58, 44, 212, 105, 190, 206, 243, 113, 117, 58, 245, 72, 20, 216,
+       17, 250, 229, 182, 104, 113, 23, 120, 173, 54, 50, 159, 59, 66,
+       91, 162, 23, 125, 16, 48, 252, 129, 194, 223, 233, 54, 69, 164,
+       240, 197, 43, 204, 176, 156, 178, 233, 104, 80, 43, 163, 183, 39,
+       57, 78, 183, 74, 91, 129, 151, 237, 16, 62, 79, 203, 64, 223, 243,
+       85, 127, 162, 64, 142, 66, 237, 245, 95, 230, 104, 76, 119, 184,
+       169, 184, 171, 8, 223, 243, 72, 51, 134, 213, 124, 106, 89, 67,
+       218, 101, 247, 248, 101, 62, 8, 179, 2, 35, 126, 76, 222, 236,
+       172, 58, 222, 232, 137, 26, 154, 58, 78, 121, 61, 235, 239, 213,
+       221, 99, 44, 167, 8, 238, 178, 251, 102, 159, 215, 255, 89, 3,
+       216, 19, 222, 165, 34, 106, 120, 83, 44, 163, 238, 51, 95, 59, 35,
+       90, 230, 149, 239, 32, 12, 177, 17, 0, 210, 231, 114, 5, 232, 224,
+       41, 19, 37, 60, 252, 3, 180, 63, 178, 218, 94, 235, 63, 31, 211,
+       120, 95, 40, 153, 74, 66, 61, 181, 240, 125, 46, 78, 79, 53, 116,
+       205, 123, 89, 135, 36, 76, 181, 95, 77, 238, 133, 130, 220, 150,
+       52, 2, 224, 248, 181, 111, 73, 112, 34, 11, 160, 229, 123, 168, 5,
+       58, 213, 26, 209, 121, 84, 164, 45, 112, 177, 83, 109, 205, 241,
+       88, 207, 185, 113, 8, 156, 219, 77, 175, 156, 57, 82, 90, 131,
+       116, 250, 208, 77, 152, 21, 44, 203, 27, 67, 163, 47, 113, 49,
+       195, 237, 205, 245, 221, 207, 248, 49, 10, 152, 217, 125, 47, 136,
+       24, 83, 91, 195, 115, 250, 240, 47, 24, 197, 62, 222, 159, 210,
+       183, 239, 113, 97, 130, 237, 93, 223, 221, 201, 248, 157, 14, 90,
+       220, 255, 167, 140, 192, 215, 127, 197, 99, 254, 224, 55, 88, 141,
+       190, 95, 254, 210, 245, 40, 141, 60, 90, 141, 253, 151, 239, 207,
+       53, 173, 25, 174, 249, 36, 4, 137, 18, 234, 0, 82, 42, 90, 183,
+       111, 215, 17, 127, 82, 74, 205, 130, 194, 188, 133, 177, 137, 125,
+       120, 135, 187, 127, 130, 29, 142, 62, 66, 155, 165, 23, 249, 149,
+       55, 92, 209, 211, 143, 215, 94, 119, 136, 84, 135, 94, 45, 120,
+       189, 115, 125, 191, 97, 216, 127, 189, 53, 12, 158, 145, 65, 188,
+       153, 168, 102, 24, 3, 114, 251, 112, 79, 219, 21, 52, 202, 89, 67,
+       233, 255, 87, 96, 134, 237, 53, 222, 189, 137, 254, 157, 207, 106,
+       108, 223, 135, 221, 229, 213, 231, 237, 35, 252, 234, 178, 88,
+       205, 190, 31, 254, 90, 93, 15, 147, 230, 24, 239, 52, 188, 187,
+       139, 89, 25, 247, 76, 252, 254, 174, 135, 83, 183, 149, 151, 73,
+       46, 241, 14, 90, 223, 239, 223, 228, 217, 215, 96, 201, 184, 255,
+       93, 236, 85, 143, 218, 1, 232, 8, 182, 185, 33, 98, 192, 114, 41,
+       1, 66, 42, 211, 59, 229, 180, 84, 59, 80, 88, 212, 42, 32, 165,
+       22, 48, 209, 203, 116, 103, 59, 177, 104, 9, 46, 185, 100, 148,
+       169, 171, 194, 16, 94, 187, 16, 156, 61, 214, 21, 107, 195, 12,
+       238, 142, 199, 225, 154, 242, 228, 20, 254, 209, 59, 155, 181, 27,
+       157, 251, 124, 26, 255, 219, 23, 159, 78, 86, 138, 226, 222, 217,
+       191, 173, 140, 242, 171, 131, 186, 116, 252, 242, 235, 245, 156,
+       95, 27, 250, 53, 159, 61, 221, 79, 59, 159, 123, 213, 19, 231, 71,
+       186, 138, 107, 211, 93, 187, 207, 92, 143, 219, 186, 38, 230, 18,
+       133, 123, 244, 71, 255, 247, 181, 31, 74, 104, 22, 143, 169, 226,
+       199, 21, 188, 255, 38, 138, 74, 91, 85, 51, 199, 124, 222, 198,
+       210, 76, 31, 190, 25, 214, 88, 96, 188, 130, 195, 1, 239, 222, 33,
+       209, 224, 185, 221, 227, 108, 143, 26, 125, 147, 227, 170, 25, 16,
+       35, 41, 10, 196, 20, 157, 245, 137, 110, 17, 154, 182, 187, 130,
+       88, 214, 55, 65, 107, 129, 87, 121, 16, 57, 68, 211, 2, 205, 162,
+       251, 86, 136, 105, 5, 51, 193, 180, 157, 241, 136, 44, 172, 143,
+       254, 115, 130, 16, 149, 54, 88, 123, 165, 87, 121, 145, 179, 76,
+       211, 81, 221, 3, 254, 116, 136, 64, 139, 24, 37, 232, 141, 81,
+       252, 255, 97, 218, 127, 253, 52, 24, 146, 197, 219, 56, 25, 72,
+       102, 28, 183, 114, 107, 48, 95, 31, 53, 109, 192, 137, 94, 228,
+       182, 222, 120, 234, 238, 50, 94, 255, 17, 238, 156, 191, 73, 111,
+       191, 17, 127, 215, 149, 163, 236, 39, 108, 254, 114, 95, 173, 175,
+       127, 246, 190, 223, 55, 5, 100, 187, 231, 242, 252, 71, 29, 95,
+       91, 247, 13, 46, 182, 175, 239, 139, 151, 135, 181, 186, 37, 228,
+       22, 122, 218, 195, 175, 77, 249, 215, 250, 197, 170, 222, 93, 212,
+       199, 239, 215, 5, 204, 2, 96, 248, 56, 100, 216, 250, 187, 201,
+       122, 43, 242, 191, 241, 117, 142, 27, 19, 24, 244, 238, 39, 130,
+       12, 217, 124, 149, 232, 200, 94, 121, 117, 82, 144, 200, 254, 104,
+       201, 8, 50, 93, 151, 58, 111, 213, 14, 24, 179, 236, 221, 137,
+       120, 132, 31, 201, 236, 215, 143, 80, 191, 188, 70, 53, 14, 2,
+       249, 121, 218, 230, 39, 86, 187, 223, 210, 88, 255, 241, 111, 111,
+       223, 197, 167, 214, 149, 104, 167, 151, 227, 210, 229, 180, 253,
+       218, 217, 91, 29, 250, 8, 252, 255, 173, 191, 91, 23, 159, 183,
+       98, 174, 224, 14, 26, 223, 238, 215, 221, 211, 245, 186, 4, 2,
+       184, 61, 195, 136, 104, 157, 76, 209, 163, 172, 222, 50, 197, 218,
+       169, 159, 231, 108, 135, 66, 223, 144, 112, 138, 139, 22, 12, 53,
+       199, 154, 77, 3, 190, 61, 209, 10, 96, 159, 12, 209, 35, 236, 210,
+       37, 197, 202, 41, 159, 195, 110, 135, 74, 255, 176, 112, 138, 187,
+       22, 14, 53, 110, 194, 233, 23, 190, 57, 208, 146, 166, 190, 21,
+       194, 32, 172, 254, 36, 193, 192, 115, 234, 65, 110, 73, 235, 255,
+       187, 241, 158, 91, 16, 4, 61, 78, 179, 109, 42, 190, 149, 196, 79,
+       230, 180, 192, 206, 0, 48, 247, 51, 112, 232, 234, 27, 221, 105,
+       139, 178, 110, 249, 60, 142, 8, 1, 51, 118, 234, 67, 165, 155,
+       136, 252, 128, 184, 207, 142, 17, 88, 194, 148, 218, 112, 66, 231,
+       59, 123, 145, 18, 9, 130, 215, 44, 52, 175, 236, 156, 0, 177, 169,
+       2, 137, 159, 185, 254, 134, 185, 207, 14, 57, 90, 226, 148, 191,
+       224, 64, 239, 31, 51, 157, 19, 216, 3, 209, 76, 34, 255, 196, 156,
+       40, 161, 169, 198, 237, 191, 246, 168, 110, 28, 172, 161, 186,
+       163, 25, 215, 127, 73, 27, 133, 119, 125, 98, 112, 69, 155, 44,
+       235, 250, 85, 30, 0, 241, 135, 42, 236, 164, 229, 115, 220, 107,
+       67, 138, 90, 183, 169, 153, 83, 236, 77, 58, 153, 222, 97, 48, 58,
+       118, 251, 34, 77, 142, 245, 117, 197, 121, 214, 98, 255, 142, 228,
+       215, 181, 189, 210, 162, 95, 191, 183, 31, 234, 104, 223, 207,
+       217, 102, 189, 23, 174, 252, 111, 255, 154, 95, 223, 83, 215, 109,
+       88, 78, 243, 205, 43, 188, 93, 212, 207, 109, 17, 64, 196, 3, 120,
+       222, 58, 225, 248, 235, 19, 237, 111, 139, 182, 239, 179, 45, 158,
+       137, 53, 4, 176, 238, 21, 237, 73, 233, 150, 195, 79, 247, 6, 224,
+       202, 194, 145, 7, 144, 32, 110, 252, 31, 253, 217, 154, 117, 60,
+       237, 133, 175, 244, 53, 154, 180, 240, 244, 141, 109, 232, 156,
+       67, 71, 171, 4, 180, 137, 163, 211, 119, 0, 81, 88, 132, 29, 250,
+       122, 2, 105, 29, 233, 161, 165, 92, 181, 168, 244, 98, 11, 130,
+       14, 185, 108, 128, 168, 72, 174, 89, 81, 247, 185, 202, 190, 72,
+       238, 9, 55, 149, 151, 22, 7, 213, 68, 43, 186, 200, 29, 129, 185,
+       145, 133, 96, 150, 179, 236, 0, 172, 200, 186, 19, 81, 82, 220,
+       195, 233, 139, 163, 73, 34, 94, 98, 69, 138, 224, 132, 146, 111,
+       12, 128, 179, 41, 129, 179, 22, 106, 200, 126, 51, 176, 66, 92,
+       64, 208, 242, 0, 152, 182, 225, 254, 137, 151, 129, 166, 183, 36,
+       222, 20, 24, 138, 171, 85, 12, 125, 229, 85, 229, 67, 68, 80, 7,
+       239, 232, 103, 160, 171, 74, 81, 199, 56, 100, 56, 204, 26, 238,
+       201, 179, 189, 95, 185, 140, 133, 100, 97, 179, 226, 36, 151, 109,
+       43, 0, 208, 199, 111, 230, 181, 224, 234, 135, 17, 135, 53, 48,
+       61, 237, 19, 238, 249, 191, 52, 110, 249, 142, 143, 64, 105, 179,
+       162, 240, 15, 84, 231, 215, 230, 126, 172, 183, 121, 99, 123, 246,
+       216, 124, 188, 239, 127, 127, 19, 175, 177, 244, 53, 234, 39, 62,
+       222, 130, 207, 244, 245, 245, 7, 92, 237, 151, 230, 54, 188, 150,
+       120, 123, 94, 247, 248, 60, 157, 235, 167, 87, 183, 141, 181, 240,
+       117, 224, 46, 127, 254, 130, 141, 244, 145, 253, 130, 18, 122,
+       201, 126, 147, 184, 91, 94, 0, 208, 230, 32, 200, 180, 192, 126,
+       57, 147, 33, 134, 167, 6, 223, 84, 36, 10, 40, 93, 136, 125, 133,
+       2, 207, 214, 159, 242, 10, 167, 175, 29, 23, 90, 247, 108, 35,
+       164, 71, 39, 71, 35, 64, 112, 216, 13, 127, 108, 54, 116, 130, 30,
+       220, 129, 137, 171, 204, 97, 173, 85, 214, 235, 110, 21, 64, 208,
+       151, 57, 14, 54, 224, 120, 169, 19, 173, 239, 158, 117, 255, 21,
+       126, 154, 136, 63, 132, 112, 252, 50, 155, 41, 184, 91, 199, 152,
+       103, 31, 109, 240, 239, 44, 30, 38, 16, 238, 187, 151, 133, 30,
+       11, 16, 223, 153, 20, 154, 251, 81, 4, 39, 223, 56, 79, 37, 111,
+       189, 143, 207, 189, 69, 44, 248, 129, 251, 109, 17, 36, 88, 246,
+       197, 239, 232, 170, 109, 191, 225, 252, 141, 16, 119, 254, 214,
+       234, 25, 15, 38, 167, 53, 166, 239, 55, 116, 206, 222, 199, 251,
+       106, 178, 100, 124, 38, 28, 173, 252, 184, 101, 175, 224, 239,
+       170, 128, 47, 198, 113, 72, 218, 20, 146, 254, 171, 100, 20, 127,
+       29, 27, 217, 55, 124, 255, 40, 201, 245, 211, 159, 161, 62, 71,
+       18, 251, 243, 243, 90, 27, 154, 124, 173, 19, 161, 58, 99, 203,
+       116, 185, 232, 82, 77, 65, 113, 247, 177, 137, 244, 36, 110, 168,
+       2, 12, 147, 188, 84, 211, 70, 28, 146, 96, 127, 137, 121, 148,
+       157, 223, 83, 240, 198, 159, 110, 246, 117, 226, 114, 254, 31,
+       173, 177, 177, 63, 253, 150, 110, 245, 253, 20, 238, 62, 78, 37,
+       64, 111, 249, 227, 145, 3, 171, 106, 155, 100, 137, 185, 101, 206,
+       93, 91, 163, 164, 140, 246, 96, 226, 43, 51, 5, 214, 184, 166,
+       245, 68, 56, 186, 233, 21, 14, 213, 207, 1, 222, 170, 167, 116,
+       143, 191, 119, 88, 205, 122, 71, 45, 168, 54, 0, 191, 43, 6, 5,
+       228, 184, 36, 255, 108, 63, 62, 192, 93, 10, 209, 221, 140, 89,
+       51, 163, 118, 233, 235, 208, 60, 9, 89, 240, 189, 159, 41, 192,
+       126, 59, 151, 91, 2, 148, 0, 226, 101, 197, 170, 128, 118, 147,
+       135, 243, 213, 95, 65, 14, 146, 143, 143, 188, 28, 194, 74, 206,
+       115, 96, 185, 225, 54, 226, 16, 110, 233, 144, 29, 63, 176, 174,
+       47, 0, 61, 251, 129, 56, 236, 90, 156, 19, 205, 108, 101, 132,
+       248, 62, 183, 28, 94, 1, 75, 155, 41, 198, 236, 90, 105, 103, 251,
+       96, 213, 163, 117, 21, 201, 121, 206, 32, 218, 166, 238, 191, 249,
+       183, 95, 142, 183, 255, 93, 149, 73, 239, 94, 154, 149, 239, 253,
+       151, 190, 221, 175, 247, 106, 119, 253, 237, 183, 213, 174, 83, 7,
+       177, 144, 249, 147, 167, 48, 219, 30, 25, 73, 86, 220, 243, 104,
+       104, 247, 27, 50, 16, 19, 208, 27, 213, 137, 150, 63, 230, 152,
+       73, 169, 131, 174, 122, 160, 184, 207, 225, 185, 202, 154, 247,
+       148, 187, 140, 141, 119, 15, 207, 25, 179, 145, 134, 71, 194, 208,
+       95, 81, 223, 239, 151, 93, 55, 211, 1, 40, 27, 187, 68, 173, 105,
+       64, 127, 81, 97, 20, 189, 134, 118, 120, 226, 43, 18, 28, 19, 184,
+       50, 241, 5, 156, 18, 104, 144, 139, 99, 228, 51, 181, 67, 13, 82,
+       135, 234, 251, 22, 96, 104, 142, 113, 230, 52, 32, 61, 169, 18,
+       172, 167, 186, 29, 95, 57, 14, 5, 100, 121, 170, 35, 156, 226, 55,
+       184, 26, 141, 189, 148, 71, 219, 95, 161, 29, 166, 248, 95, 27,
+       133, 59, 105, 21, 182, 111, 178, 211, 11, 26, 84, 59, 208, 88,
+       199, 206, 139, 20, 67, 191, 97, 180, 120, 83, 29, 66, 81, 215,
+       232, 78, 191, 237, 222, 169, 151, 141, 175, 150, 118, 223, 6, 126,
+       154, 130, 30, 197, 56, 213, 90, 11, 215, 133, 51, 154, 72, 51,
+       173, 165, 207, 228, 174, 7, 128, 196, 38, 164, 237, 12, 17, 153,
+       1, 205, 144, 118, 26, 210, 38, 134, 5, 41, 169, 76, 83, 201, 87,
+       39, 235, 80, 21, 40, 125, 82, 29, 19, 177, 164, 126, 188, 22, 40,
+       97, 182, 81, 206, 21, 136, 32, 0, 127, 234, 106, 169, 143, 15,
+       140, 243, 166, 54, 172, 151, 60, 59, 83, 214, 157, 58, 145, 235,
+       231, 87, 61, 191, 181, 220, 77, 226, 134, 235, 254, 132, 172, 245,
+       185, 5, 167, 203, 231, 221, 238, 155, 174, 226, 222, 54, 114, 242,
+       72, 172, 181, 231, 79, 108, 162, 79, 244, 251, 103, 244, 62, 58,
+       207, 231, 87, 189, 213, 229, 26, 235, 115, 78, 242, 209, 191, 247,
+       229, 200, 252, 226, 57, 231, 229, 180, 126, 251, 150, 194, 193,
+       139, 166, 253, 50, 69, 174, 169, 39, 214, 167, 253, 183, 165, 184,
+       83, 149, 253, 82, 202, 87, 87, 109, 28, 139, 224, 78, 28, 145, 74,
+       128, 28, 62, 124, 254, 163, 139, 223, 16, 107, 178, 205, 206, 198,
+       90, 15, 198, 197, 27, 218, 72, 51, 173, 225, 142, 230, 76, 39,
+       132, 214, 38, 244, 236, 172, 25, 137, 1, 204, 190, 119, 129, 147,
+       46, 230, 40, 61, 194, 170, 173, 178, 172, 237, 153, 135, 154, 95,
+       128, 89, 180, 140, 85, 11, 141, 59, 123, 21, 54, 109, 210, 115,
+       141, 18, 94, 121, 192, 88, 215, 91, 166, 207, 236, 157, 238, 211,
+       190, 235, 222, 23, 80, 178, 193, 232, 188, 235, 207, 121, 162,
+       227, 246, 244, 110, 245, 36, 99, 207, 39, 213, 125, 253, 196, 231,
+       203, 231, 157, 237, 147, 172, 230, 207, 248, 146, 242, 136, 172,
+       247, 231, 206, 101, 250, 231, 245, 111, 231, 253, 62, 56, 207,
+       247, 21, 60, 248, 197, 83, 221, 78, 220, 218, 182, 94, 246, 141,
+       146, 142, 142, 96, 122, 183, 119, 231, 246, 254, 226, 236, 203,
+       55, 238, 50, 62, 197, 147, 189, 240, 120, 28, 10, 168, 186, 219,
+       105, 249, 49, 194, 190, 17, 71, 16, 188, 211, 108, 104, 227, 59,
+       187, 144, 18, 92, 170, 241, 207, 153, 90, 107, 144, 1, 45, 162,
+       42, 198, 97, 202, 120, 197, 75, 189, 7, 77, 249, 193, 233, 71,
+       188, 212, 93, 154, 151, 156, 138, 14, 111, 255, 47, 126, 186, 200,
+       19, 134, 246, 249, 106, 171, 97, 222, 232, 144, 79, 191, 3, 12,
+       252, 224, 169, 199, 220, 116, 78, 250, 167, 204, 218, 10, 231,
+       245, 110, 252, 190, 169, 23, 214, 164, 109, 177, 70, 75, 13, 52,
+       91, 226, 104, 84, 100, 240, 86, 67, 72, 183, 228, 120, 168, 2,
+       238, 173, 183, 101, 158, 34, 201, 131, 1, 125, 173, 120, 196, 227,
+       88, 39, 158, 45, 158, 152, 4, 173, 250, 146, 229, 238, 30, 183,
+       255, 198, 37, 253, 7, 237, 197, 240, 200, 150, 122, 90, 146, 14,
+       60, 25, 95, 31, 219, 98, 202, 207, 21, 222, 248, 71, 28, 212, 135,
+       73, 205, 255, 228, 126, 200, 151, 239, 222, 35, 47, 181, 59, 89,
+       143, 239, 63, 191, 248, 215, 226, 207, 110, 30, 220, 224, 223,
+       166, 205, 87, 186, 27, 96, 108, 62, 83, 201, 227, 75, 197, 230,
+       47, 108, 127, 127, 62, 150, 81, 85, 82, 244, 94, 8, 130, 158, 219,
+       11, 248, 48, 70, 254, 21, 71, 48, 172, 147, 104, 203, 227, 59,
+       234, 16, 22, 221, 2, 241, 79, 241, 82, 67, 146, 1, 45, 131, 96,
+       168, 189, 220, 77, 201, 65, 11, 211, 189, 128, 8, 242, 244, 80,
+       62, 201, 60, 120, 17, 26, 106, 234, 17, 157, 182, 213, 123, 144,
+       40, 86, 106, 47, 163, 33, 203, 77, 133, 201, 248, 23, 93, 117,
+       205, 195, 197, 126, 13, 221, 8, 23, 126, 218, 50, 106, 149, 79,
+       217, 225, 252, 82, 143, 80, 240, 106, 195, 192, 175, 248, 1, 77,
+       159, 7, 23, 216, 197, 161, 103, 152, 216, 95, 194, 63, 140, 202,
+       10, 71, 243, 228, 62, 254, 152, 148, 212, 208, 121, 226, 207, 111,
+       30, 222, 224, 239, 166, 232, 86, 186, 155, 96, 44, 55, 83, 235,
+       231, 107, 231, 244, 111, 174, 111, 117, 42, 86, 137, 85, 117, 247,
+       126, 177, 6, 103, 13, 44, 94, 233, 40, 100, 102, 243, 23, 195, 8,
+       182, 231, 72, 132, 110, 47, 236, 181, 101, 14, 6, 122, 226, 16,
+       85, 172, 116, 228, 157, 220, 188, 215, 181, 61, 125, 183, 95, 191,
+       126, 24, 126, 125, 95, 175, 165, 90, 181, 24, 178, 252, 59, 243,
+       239, 219, 85, 71, 210, 252, 197, 111, 62, 4, 241, 234, 143, 99,
+       87, 200, 17, 46, 185, 59, 75, 125, 93, 56, 217, 211, 149, 163, 56,
+       39, 104, 186, 243, 223, 133, 191, 247, 127, 230, 99, 86, 122, 248,
+       164, 40, 48, 88, 18, 41, 238, 178, 173, 143, 46, 71, 154, 206,
+       245, 253, 135, 140, 71, 199, 192, 146, 247, 123, 191, 237, 241,
+       46, 87, 230, 252, 231, 182, 204, 104, 167, 230, 168, 210, 24, 155,
+       245, 253, 85, 11, 171, 119, 115, 227, 97, 79, 158, 97, 53, 34,
+       207, 168, 69, 121, 247, 250, 162, 101, 103, 77, 108, 75, 193, 104,
+       84, 116, 242, 139, 99, 77, 149, 7, 88, 132, 83, 111, 233, 246,
+       117, 29, 103, 42, 193, 20, 103, 172, 86, 240, 188, 141, 244, 127,
+       229, 59, 220, 175, 91, 63, 117, 58, 203, 41, 157, 185, 91, 218,
+       151, 11, 188, 126, 77, 183, 255, 255, 244, 245, 247, 221, 222,
+       142, 162, 181, 97, 234, 223, 193, 149, 111, 30, 117, 185, 159, 32,
+       12, 60, 1, 201, 155, 131, 177, 122, 43, 88, 213, 125, 0, 158, 127,
+       85, 12, 244, 250, 162, 165, 104, 144, 252, 201, 209, 231, 218,
+       117, 185, 155, 160, 8, 94, 1, 137, 139, 67, 21, 118, 42, 108, 215,
+       124, 24, 153, 127, 85, 12, 214, 206, 45, 186, 168, 51, 165, 189,
+       67, 152, 79, 253, 21, 93, 150, 216, 219, 42, 145, 76, 118, 95,
+       151, 112, 250, 48, 207, 89, 37, 246, 216, 111, 211, 215, 59, 182,
+       160, 12, 19, 23, 154, 239, 23, 237, 216, 239, 8, 40, 246, 132,
+       221, 79, 135, 165, 158, 59, 77, 159, 58, 70, 157, 255, 255, 206,
+       186, 221, 190, 249, 161, 166, 252, 73, 215, 252, 18, 224, 144,
+       175, 215, 253, 72, 2, 24, 216, 215, 115, 123, 82, 216, 170, 249,
+       209, 141, 189, 38, 186, 150, 242, 1, 73, 150, 190, 100, 128, 172,
+       231, 236, 18, 210, 2, 189, 162, 177, 67, 202, 99, 42, 200, 64,
+       171, 2, 233, 100, 178, 222, 8, 68, 152, 161, 136, 214, 242, 16,
+       234, 59, 225, 147, 200, 171, 28, 189, 185, 206, 215, 104, 20, 223,
+       145, 205, 242, 74, 7, 202, 211, 209, 208, 11, 127, 80, 3, 39, 35,
+       88, 179, 152, 169, 186, 170, 88, 29, 54, 109, 75, 173, 223, 231,
+       74, 80, 182, 159, 237, 21, 30, 24, 201, 23, 252, 229, 47, 245,
+       188, 2, 143, 83, 20, 4, 111, 227, 176, 227, 107, 146, 20, 165, 15,
+       178, 215, 103, 41, 73, 87, 246, 29, 178, 58, 208, 105, 62, 233,
+       130, 171, 212, 180, 219, 20, 114, 36, 179, 152, 169, 242, 171,
+       113, 91, 2, 45, 125, 173, 151, 215, 74, 16, 214, 27, 7, 48, 18,
+       26, 200, 20, 220, 133, 43, 253, 176, 138, 135, 211, 36, 51, 250,
+       160, 246, 107, 115, 91, 11, 45, 125, 47, 22, 159, 74, 24, 255,
+       157, 23, 49, 18, 18, 200, 16, 95, 133, 33, 237, 228, 202, 198,
+       211, 116, 51, 248, 96, 246, 107, 115, 91, 35, 173, 125, 43, 18,
+       157, 71, 24, 191, 156, 23, 48, 26, 50, 160, 130, 95, 141, 33, 239,
+       231, 235, 214, 211, 98, 185, 16, 218, 123, 217, 146, 200, 139, 29,
+       184, 169, 46, 220, 71, 148, 134, 251, 207, 81, 6, 11, 154, 241,
+       27, 20, 9, 251, 90, 15, 15, 95, 178, 77, 0, 250, 141, 227, 198,
+       71, 21, 130, 216, 19, 131, 202, 53, 201, 249, 235, 143, 163, 120,
+       39, 67, 190, 176, 244, 158, 59, 53, 89, 248, 142, 252, 236, 24,
+       50, 251, 221, 82, 200, 59, 241, 160, 137, 143, 215, 79, 145, 151,
+       217, 197, 118, 110, 70, 202, 55, 186, 209, 37, 127, 96, 23, 11, 3,
+       182, 6, 237, 205, 136, 98, 77, 91, 21, 246, 159, 147, 65, 39, 49,
+       79, 93, 148, 191, 170, 40, 199, 97, 154, 67, 227, 235, 149, 55,
+       233, 116, 240, 143, 255, 238, 63, 188, 182, 255, 191, 255, 223,
+       94, 183, 121, 253, 214, 163, 183, 239, 245, 159, 247, 244, 191,
+       255, 111, 123, 239, 134, 207, 245, 253, 213, 80, 73, 210, 132, 6,
+       64, 110, 166, 41, 128, 250, 2, 46, 170, 53, 210, 106, 231, 46,
+       193, 72, 187, 148, 232, 176, 180, 142, 1, 5, 122, 113, 8, 248,
+       120, 91, 116, 3, 216, 84, 100, 161, 128, 230, 168, 59, 151, 1,
+       241, 34, 245, 196, 192, 73, 159, 160, 44, 243, 225, 4, 3, 98, 176,
+       38, 58, 97, 88, 200, 169, 84, 184, 66, 18, 68, 64, 104, 79, 163,
+       138, 35, 216, 200, 168, 162, 16, 15, 58, 212, 19, 134, 245, 130,
+       41, 56, 9, 120, 150, 90, 77, 226, 102, 119, 144, 126, 119, 33,
+       128, 94, 130, 41, 47, 145, 112, 50, 255, 21, 204, 200, 152, 148,
+       237, 119, 237, 190, 129, 39, 198, 122, 10, 82, 25, 51, 172, 51,
+       132, 30, 117, 169, 200, 90, 231, 60, 191, 53, 112, 166, 247, 189,
+       197, 196, 139, 132, 236, 179, 124, 10, 138, 38, 166, 39, 95, 82,
+       89, 107, 198, 2, 208, 159, 100, 169, 196, 218, 163, 40, 174, 182,
+       98, 230, 245, 253, 199, 220, 139, 166, 233, 115, 52, 138, 139, 37,
+       6, 180, 95, 170, 76, 99, 76, 109, 114, 205, 107, 81, 14, 248, 34,
+       40, 40, 181, 245, 104, 128, 6, 168, 232, 63, 101, 207, 55, 126,
+       242, 143, 119, 252, 116, 237, 94, 107, 147, 168, 137, 96, 31, 201,
+       170, 156, 129, 137, 204, 199, 105, 90, 196, 213, 237, 242, 8, 7,
+       234, 208, 209, 241, 207, 191, 144, 55, 165, 98, 86, 74, 183, 190,
+       41, 224, 19, 136, 174, 28, 131, 161, 237, 199, 105, 218, 199, 241,
+       237, 210, 10, 71, 171, 241, 145, 243, 203, 95, 144, 51, 37, 98,
+       80, 209, 29, 248, 139, 208, 20, 142, 174, 81, 130, 48, 255, 22,
+       40, 251, 231, 147, 249, 208, 91, 13, 91, 53, 185, 227, 94, 95, 56,
+       16, 173, 58, 168, 149, 117, 201, 244, 199, 225, 125, 76, 9, 249,
+       114, 216, 85, 188, 165, 216, 26, 6, 184, 115, 186, 97, 221, 45,
+       216, 162, 68, 83, 138, 228, 169, 90, 74, 134, 188, 107, 192, 61,
+       166, 161, 134, 134, 161, 44, 167, 35, 90, 102, 245, 237, 198, 64,
+       79, 130, 232, 210, 163, 254, 153, 38, 245, 36, 123, 1, 74, 19,
+       201, 100, 169, 33, 18, 206, 13, 122, 96, 148, 146, 165, 108, 198,
+       40, 46, 24, 131, 56, 34, 208, 4, 188, 50, 194, 144, 201, 5, 101,
+       48, 65, 10, 236, 141, 71, 198, 111, 85, 3, 248, 11, 3, 56, 56, 88,
+       216, 136, 6, 225, 124, 163, 81, 138, 179, 247, 150, 27, 249, 120,
+       252, 130, 219, 223, 51, 150, 179, 86, 159, 247, 25, 206, 30, 239,
+       124, 126, 191, 53, 182, 119, 149, 103, 245, 137, 32, 238, 243,
+       119, 46, 147, 6, 118, 167, 127, 41, 12, 30, 105, 52, 190, 66, 55,
+       69, 9, 238, 68, 179, 3, 178, 112, 192, 166, 14, 28, 175, 184, 113,
+       31, 230, 255, 48, 80, 154, 138, 88, 12, 4, 15, 174, 179, 200, 38,
+       125, 183, 180, 23, 175, 149, 221, 103, 11, 91, 37, 215, 107, 158,
+       48, 208, 27, 96, 205, 163, 254, 68, 128, 209, 167, 242, 214, 205,
+       84, 234, 186, 32, 94, 164, 173, 2, 155, 211, 239, 123, 29, 211,
+       247, 211, 125, 243, 120, 5, 73, 234, 178, 254, 143, 150, 180, 243,
+       169, 1, 34, 150, 96, 169, 54, 147, 184, 59, 94, 104, 88, 231, 169,
+       12, 180, 128, 222, 25, 151, 149, 135, 188, 69, 223, 12, 20, 186,
+       210, 93, 140, 25, 157, 132, 196, 92, 183, 198, 8, 109, 169, 184,
+       146, 115, 147, 247, 67, 57, 83, 51, 193, 23, 235, 96, 116, 12,
+       111, 228, 139, 111, 4, 37, 176, 33, 128, 53, 89, 253, 79, 44, 127,
+       195, 88, 70, 170, 189, 42, 115, 121, 181, 46, 88, 244, 102, 106,
+       137, 35, 111, 56, 83, 143, 97, 57, 119, 251, 84, 161, 171, 148,
+       236, 30, 237, 253, 212, 111, 219, 119, 181, 31, 10, 252, 62, 183,
+       201, 131, 243, 5, 182, 111, 126, 215, 31, 91, 213, 127, 215, 76,
+       222, 198, 22, 205, 78, 167, 86, 2, 106, 224, 121, 128, 90, 130,
+       113, 106, 57, 97, 123, 225, 23, 255, 108, 176, 29, 237, 255, 203,
+       143, 5, 37, 178, 121, 0, 121, 76, 115, 76, 44, 127, 199, 48, 68,
+       202, 250, 74, 243, 120, 181, 228, 88, 228, 126, 107, 205, 161,
+       117, 44, 177, 238, 96, 16, 117, 251, 80, 44, 0, 147, 159, 139, 40,
+       132, 161, 73, 142, 93, 193, 101, 164, 194, 98, 200, 192, 41, 234,
+       81, 23, 11, 203, 49, 136, 48, 26, 90, 24, 11, 165, 215, 139, 219,
+       69, 157, 34, 147, 172, 187, 13, 72, 86, 231, 237, 70, 167, 229,
+       94, 49, 158, 239, 229, 152, 103, 221, 166, 114, 234, 130, 30, 188,
+       41, 253, 117, 1, 235, 76, 156, 86, 203, 89, 70, 232, 223, 2, 83,
+       248, 255, 110, 88, 132, 62, 185, 153, 179, 253, 136, 123, 45, 167,
+       84, 245, 170, 240, 36, 25, 88, 31, 173, 36, 86, 230, 54, 68, 74,
+       90, 66, 115, 24, 177, 224, 120, 228, 62, 111, 205, 188, 85, 173,
+       182, 239, 226, 0, 125, 184, 120, 12, 12, 219, 158, 255, 234, 12,
+       53, 189, 174, 21, 46, 165, 255, 235, 106, 90, 135, 83, 235, 80, 2,
+       105, 155, 113, 237, 135, 119, 13, 216, 242, 141, 155, 220, 151,
+       252, 246, 183, 118, 95, 188, 19, 238, 183, 183, 127, 127, 139,
+       113, 23, 247, 189, 98, 236, 68, 41, 174, 235, 223, 101, 159, 166,
+       247, 4, 123, 139, 76, 71, 93, 37, 150, 174, 230, 221, 74, 246, 70,
+       232, 96, 181, 229, 72, 98, 178, 238, 225, 236, 119, 255, 36, 58,
+       210, 130, 95, 189, 120, 188, 19, 135, 44, 187, 190, 147, 156, 111,
+       196, 93, 221, 183, 233, 104, 190, 1, 206, 3, 207, 165, 254, 169,
+       103, 157, 232, 67, 250, 209, 93, 12, 189, 223, 136, 184, 147, 251,
+       39, 237, 177, 83, 94, 11, 96, 16, 190, 149, 96, 172, 177, 59, 146,
+       24, 19, 188, 18, 243, 133, 213, 18, 98, 90, 9, 161, 187, 73, 130,
+       150, 255, 34, 188, 40, 48, 172, 27, 71, 80, 253, 243, 168, 239,
+       38, 55, 106, 8, 17, 220, 131, 69, 132, 251, 122, 192, 138, 129,
+       41, 33, 16, 195, 30, 155, 13, 193, 161, 69, 174, 21, 195, 70, 228,
+       194, 104, 200, 104, 41, 106, 211, 2, 129, 91, 113, 132, 128, 138,
+       64, 24, 11, 185, 128, 118, 63, 18, 170, 221, 161, 146, 200, 138,
+       13, 153, 111, 6, 216, 108, 208, 200, 139, 207, 83, 30, 35, 202,
+       178, 176, 212, 138, 123, 152, 91, 188, 131, 246, 126, 16, 170,
+       189, 33, 214, 206, 219, 47, 177, 125, 14, 152, 101, 152, 201, 211,
+       207, 83, 46, 39, 202, 178, 178, 212, 20, 63, 216, 91, 190, 7, 174,
+       148, 100, 218, 237, 245, 217, 234, 155, 119, 149, 31, 10, 252,
+       127, 47, 205, 155, 151, 21, 190, 111, 122, 214, 91, 90, 217, 255,
+       223, 77, 84, 214, 26, 189, 168, 185, 150, 227, 187, 235, 30, 85,
+       221, 179, 157, 172, 62, 0, 251, 11, 147, 149, 182, 234, 108, 183,
+       232, 69, 186, 231, 245, 77, 181, 211, 136, 184, 19, 251, 99, 237,
+       177, 198, 62, 27, 96, 48, 188, 215, 104, 156, 179, 59, 147, 16,
+       19, 156, 18, 115, 197, 213, 26, 106, 82, 1, 167, 187, 136, 176,
+       19, 251, 99, 228, 49, 87, 62, 25, 97, 112, 188, 215, 104, 253,
+       162, 59, 131, 16, 19, 216, 146, 81, 197, 241, 26, 106, 138, 0,
+       167, 187, 252, 159, 48, 114, 173, 27, 86, 228, 81, 62, 180, 57,
+       74, 57, 79, 153, 217, 214, 196, 98, 124, 111, 200, 178, 242, 211,
+       85, 63, 211, 127, 222, 11, 44, 218, 254, 119, 181, 154, 87, 181,
+       243, 31, 119, 56, 235, 113, 138, 154, 217, 114, 228, 82, 122, 252,
+       105, 46, 239, 247, 117, 67, 194, 187, 206, 163, 66, 148, 243, 222,
+       203, 244, 188, 71, 139, 223, 152, 175, 44, 254, 119, 206, 239,
+       179, 251, 129, 214, 75, 178, 193, 59, 87, 222, 171, 151, 84, 173,
+       127, 171, 253, 104, 233, 116, 223, 95, 255, 87, 76, 84, 175, 187,
+       93, 182, 161, 94, 56, 151, 109, 239, 188, 116, 159, 102, 89, 165,
+       244, 62, 156, 92, 249, 139, 94, 111, 95, 98, 210, 191, 180, 125,
+       78, 86, 230, 121, 94, 183, 100, 118, 113, 55, 239, 225, 148, 45,
+       255, 102, 63, 106, 128, 127, 183, 97, 253, 163, 183, 68, 73, 245,
+       151, 172, 239, 94, 89, 125, 214, 168, 8, 190, 165, 205, 10, 146,
+       188, 247, 184, 108, 223, 46, 91, 150, 231, 95, 12, 218, 221, 187,
+       249, 120, 96, 55, 221, 218, 247, 95, 105, 52, 170, 191, 157, 214,
+       164, 142, 153, 149, 85, 207, 40, 100, 151, 234, 221, 37, 255, 119,
+       156, 220, 125, 215, 126, 195, 165, 114, 34, 43, 154, 57, 194, 90,
+       231, 93, 39, 145, 68, 119, 205, 21, 255, 169, 148, 157, 234, 180,
+       236, 175, 132, 173, 247, 33, 121, 252, 126, 122, 236, 60, 18, 86,
+       120, 81, 142, 252, 110, 115, 217, 161, 209, 92, 188, 141, 98, 232,
+       167, 128, 142, 242, 237, 161, 185, 63, 187, 126, 19, 198, 146, 23,
+       186, 42, 228, 49, 152, 174, 25, 147, 119, 220, 215, 104, 74, 230,
+       17, 255, 211, 19, 5, 154, 209, 209, 176, 42, 222, 152, 3, 37, 51,
+       126, 236, 232, 246, 197, 89, 86, 237, 83, 138, 181, 11, 107, 121,
+       95, 188, 249, 248, 149, 243, 110, 102, 200, 170, 187, 223, 197,
+       63, 247, 127, 254, 6, 190, 100, 49, 242, 93, 229, 217, 202, 219,
+       247, 177, 27, 14, 221, 125, 141, 201, 137, 151, 21, 43, 103, 122,
+       242, 155, 221, 159, 127, 211, 93, 84, 242, 171, 183, 232, 73, 247,
+       191, 254, 127, 91, 97, 125, 190, 8, 168, 254, 180, 95, 10, 146,
+       28, 182, 58, 252, 215, 46, 93, 133, 239, 223, 206, 218, 213, 67,
+       84, 186, 182, 238, 244, 188, 199, 175, 91, 30, 51, 188, 254, 119,
+       106, 167, 51, 63, 145, 21, 77, 130, 226, 21, 63, 94, 139, 140, 80,
+       169, 159, 63, 249, 120, 224, 183, 217, 218, 183, 79, 97, 188, 171,
+       143, 29, 212, 160, 174, 147, 223, 81, 159, 40, 101, 247, 186, 221,
+       175, 255, 255, 140, 217, 87, 95, 11, 233, 165, 178, 114, 235, 152,
+       44, 196, 95, 230, 221, 71, 211, 98, 118, 213, 63, 255, 129, 144,
+       237, 200, 196, 109, 171, 196, 173, 163, 33, 113, 31, 11, 236, 229,
+       38, 54, 251, 152, 100, 228, 95, 134, 217, 45, 147, 106, 118, 244,
+       55, 255, 129, 144, 61, 232, 199, 237, 235, 132, 167, 255, 113,
+       241, 44, 205, 108, 203, 244, 227, 111, 244, 68, 96, 125, 2, 81, 1,
+       58, 65, 90, 138, 19, 234, 91, 178, 89, 189, 102, 137, 164, 69, 63,
+       219, 248, 130, 107, 144, 184, 244, 125, 127, 88, 59, 27, 239, 181,
+       45, 202, 125, 214, 62, 223, 177, 253, 49, 188, 107, 114, 221, 203,
+       95, 113, 255, 222, 172, 94, 119, 62, 151, 104, 108, 246, 86, 223,
+       185, 16, 197, 125, 167, 83, 109, 190, 32, 255, 213, 149, 231, 252,
+       178, 61, 31, 107, 239, 165, 197, 117, 186, 244, 83, 250, 182, 243,
+       252, 127, 85, 156, 127, 155, 206, 180, 127, 40, 189, 246, 167,
+       239, 177, 215, 165, 236, 111, 178, 223, 27, 94, 255, 191, 87, 172,
+       39, 255, 250, 156, 170, 252, 127, 119, 216, 122, 155, 238, 148,
+       63, 44, 191, 182, 47, 255, 181, 215, 165, 165, 79, 48, 222, 219,
+       95, 251, 191, 63, 172, 127, 223, 122, 149, 241, 196, 243, 118,
+       157, 127, 27, 239, 188, 63, 12, 62, 6, 180, 191, 23, 149, 177,
+       181, 203, 177, 206, 91, 127, 223, 247, 135, 68, 175, 223, 188, 81,
+       125, 228, 35, 70, 93, 121, 16, 238, 22, 162, 93, 117, 211, 43, 62,
+       244, 181, 234, 232, 212, 49, 8, 83, 203, 237, 148, 39, 178, 22,
+       115, 7, 243, 237, 73, 54, 82, 187, 184, 70, 228, 86, 166, 209,
+       220, 190, 96, 54, 92, 55, 253, 211, 144, 45, 85, 110, 44, 175,
+       196, 189, 163, 149, 245, 135, 159, 225, 151, 244, 55, 175, 191,
+       31, 234, 26, 246, 249, 124, 189, 165, 95, 99, 55, 191, 241, 64,
+       109, 255, 44, 94, 239, 134, 157, 255, 145, 245, 143, 151, 243,
+       244, 247, 118, 252, 123, 187, 206, 60, 123, 204, 255, 255, 167,
+       255, 179, 151, 161, 180, 67, 32, 207, 95, 95, 127, 239, 135, 228,
+       231, 247, 107, 223, 241, 244, 245, 62, 125, 191, 155, 207, 60,
+       239, 253, 127, 255, 101, 255, 243, 151, 173, 246, 72, 226, 255,
+       255, 223, 255, 174, 151, 252, 197, 127, 61, 83, 250, 77, 182, 38,
+       214, 88, 65, 232, 255, 103, 83, 57, 181, 112, 252, 212, 181, 242,
+       137, 179, 1, 136, 114, 239, 167, 132, 253, 251, 120, 19, 25, 90,
+       234, 199, 71, 90, 239, 48, 100, 228, 95, 6, 217, 41, 147, 230, 58,
+       116, 187, 235, 145, 184, 181, 168, 71, 111, 226, 1, 175, 191, 125,
+       244, 71, 240, 152, 211, 189, 253, 80, 136, 239, 249, 165, 24, 142,
+       218, 79, 250, 129, 68, 104, 16, 7, 103, 219, 177, 143, 220, 23,
+       127, 154, 1, 75, 22, 234, 253, 115, 82, 243, 217, 176, 231, 251,
+       121, 117, 58, 44, 156, 228, 180, 35, 58, 150, 16, 119, 62, 174,
+       247, 62, 88, 21, 235, 103, 4, 207, 239, 143, 222, 197, 191, 178,
+       54, 158, 191, 26, 250, 89, 247, 237, 238, 155, 193, 215, 255, 181,
+       167, 247, 220, 205, 255, 170, 119, 239, 198, 190, 247, 169, 85,
+       43, 76, 243, 207, 71, 224, 231, 194, 69, 2, 121, 162, 104, 249,
+       181, 228, 122, 234, 50, 202, 1, 178, 111, 235, 20, 62, 144, 138,
+       119, 255, 112, 172, 129, 232, 142, 189, 156, 15, 108, 190, 22,
+       242, 70, 5, 247, 225, 115, 1, 49, 110, 123, 77, 109, 221, 155, 63,
+       233, 39, 221, 81, 40, 40, 25, 26, 100, 126, 239, 93, 88, 35, 75,
+       186, 22, 182, 106, 196, 241, 227, 193, 89, 87, 252, 34, 174, 40,
+       210, 255, 95, 76, 166, 229, 4, 164, 241, 4, 112, 159, 147, 244,
+       247, 177, 158, 127, 189, 55, 221, 22, 245, 255, 127, 218, 109,
+       183, 119, 189, 236, 244, 216, 127, 255, 239, 255, 127, 199, 166,
+       180, 133, 119, 186, 123, 100, 85, 13, 219, 221, 39, 193, 246, 182,
+       159, 42, 12, 23, 159, 200, 164, 253, 133, 236, 239, 245, 200, 23,
+       91, 212, 147, 103, 188, 94, 94, 250, 58, 228, 68, 75, 83, 153, 90,
+       3, 254, 180, 175, 9, 158, 199, 191, 110, 221, 215, 196, 205, 91,
+       246, 128, 83, 89, 245, 191, 39, 244, 126, 223, 202, 22, 198, 214,
+       211, 62, 124, 119, 57, 135, 126, 215, 76, 39, 170, 93, 55, 255,
+       135, 188, 176, 220, 20, 238, 118, 62, 94, 129, 175, 245, 171, 89,
+       142, 158, 222, 151, 242, 54, 126, 247, 59, 23, 126, 247, 108, 99,
+       170, 95, 55, 79, 167, 30, 242, 220, 31, 235, 254, 54, 126, 192,
+       174, 244, 175, 89, 142, 254, 244, 223, 251, 160, 61, 191, 191,
+       159, 126, 245, 236, 247, 204, 79, 39, 123, 239, 16, 178, 92, 171,
+       243, 110, 54, 95, 226, 166, 228, 165, 239, 186, 241, 101, 204,
+       109, 87, 221, 255, 139, 252, 180, 175, 10, 156, 119, 55, 204, 245,
+       215, 229, 236, 107, 114, 220, 59, 89, 205, 191, 87, 60, 118, 255,
+       79, 173, 172, 250, 157, 221, 215, 230, 206, 245, 140, 8, 252, 244,
+       90, 38, 129, 114, 249, 91, 82, 75, 250, 183, 251, 29, 143, 123,
+       146, 26, 151, 106, 190, 144, 165, 218, 57, 244, 89, 216, 159, 93,
+       213, 53, 78, 223, 174, 252, 199, 147, 157, 20, 191, 7, 58, 151,
+       219, 255, 152, 223, 146, 12, 188, 87, 250, 148, 110, 92, 25, 244,
+       88, 114, 177, 95, 252, 53, 40, 254, 46, 245, 237, 147, 253, 128,
+       190, 207, 50, 247, 219, 255, 210, 203, 131, 4, 174, 87, 182, 251,
+       117, 216, 239, 85, 157, 220, 155, 220, 180, 107, 76, 220, 125, 47,
+       223, 209, 223, 247, 234, 99, 106, 209, 59, 88, 207, 190, 87, 60,
+       55, 247, 30, 178, 51, 248, 191, 245, 155, 216, 159, 95, 149, 55,
+       76, 220, 255, 44, 183, 25, 223, 53, 182, 101, 58, 215, 219, 95,
+       27, 255, 150, 13, 5, 119, 133, 229, 140, 187, 156, 39, 77, 191,
+       22, 243, 132, 21, 215, 33, 26, 75, 81, 74, 25, 29, 56, 104, 91,
+       62, 237, 11, 245, 112, 152, 216, 144, 90, 143, 180, 246, 255, 169,
+       191, 154, 57, 95, 242, 71, 177, 221, 253, 222, 173, 151, 125, 249,
+       47, 180, 212, 175, 159, 203, 255, 77, 87, 134, 239, 21, 116, 145,
+       101, 90, 237, 150, 43, 238, 79, 125, 162, 251, 82, 155, 26, 52,
+       97, 250, 143, 31, 163, 60, 181, 81, 254, 240, 252, 170, 148, 101,
+       91, 249, 2, 158, 114, 250, 250, 119, 180, 187, 216, 155, 95, 213,
+       119, 92, 223, 255, 42, 255, 121, 151, 151, 166, 71, 186, 227, 219,
+       93, 187, 238, 159, 245, 39, 215, 250, 150, 127, 94, 57, 244, 88,
+       51, 185, 95, 245, 53, 108, 254, 46, 247, 199, 179, 157, 133, 191,
+       15, 178, 231, 219, 127, 218, 219, 158, 4, 175, 95, 203, 180, 246,
+       126, 249, 54, 92, 63, 95, 243, 95, 177, 253, 255, 222, 116, 215,
+       127, 181, 45, 244, 214, 239, 223, 110, 255, 95, 207, 134, 228,
+       164, 127, 15, 191, 183, 125, 189, 127, 31, 191, 95, 255, 94, 189,
+       255, 253, 214, 165, 151, 126, 255, 44, 245, 249, 171, 191, 107,
+       127, 117, 223, 198, 252, 157, 127, 210, 71, 70, 140, 204, 42, 239,
+       111, 41, 174, 191, 27, 79, 43, 20, 85, 122, 199, 79, 239, 104,
+       167, 65, 222, 181, 186, 234, 148, 101, 251, 225, 40, 79, 233, 144,
+       178, 236, 169, 190, 204, 139, 59, 145, 79, 156, 219, 89, 138, 207,
+       91, 127, 87, 86, 67, 202, 240, 252, 25, 191, 254, 156, 91, 139,
+       131, 122, 61, 235, 245, 101, 255, 253, 55, 139, 254, 62, 47, 46,
+       61, 86, 54, 175, 63, 245, 5, 164, 121, 240, 138, 95, 223, 117,
+       179, 71, 108, 86, 255, 244, 158, 173, 191, 154, 110, 7, 190, 18,
+       239, 227, 125, 115, 102, 11, 81, 81, 238, 108, 35, 173, 223, 249,
+       47, 249, 167, 245, 20, 160, 121, 214, 123, 239, 255, 254, 127,
+       233, 87, 31, 191, 87, 254, 86, 181, 249, 255, 219, 245, 215, 126,
+       245, 14, 253, 222, 255, 191, 111, 255, 245, 143, 142, 244, 140,
+       127, 254, 58, 165, 188, 141, 244, 153, 11, 155, 247, 148, 155,
+       111, 236, 87, 91, 205, 247, 253, 145, 190, 103, 250, 144, 219,
+       115, 223, 191, 151, 109, 22, 86, 194, 150, 126, 211, 254, 251,
+       251, 35, 173, 57, 191, 178, 204, 63, 188, 228, 239, 179, 255, 145,
+       178, 141, 41, 247, 158, 94, 154, 211, 150, 142, 237, 37, 250, 220,
+       189, 248, 141, 69, 221, 158, 143, 254, 148, 63, 159, 191, 83, 171,
+       205, 213, 253, 147, 237, 79, 243, 144, 219, 211, 223, 255, 149,
+       124, 181, 123, 151, 255, 255, 127, 184, 127, 95, 190, 95, 254, 30,
+       245, 123, 253, 223, 37, 151, 127, 125, 111, 245, 193, 175, 191,
+       107, 255, 101, 214, 198, 255, 212, 119, 130, 14, 94, 195, 244,
+       187, 250, 66, 173, 129, 191, 178, 204, 43, 180, 196, 239, 179,
+       223, 153, 50, 153, 64, 238, 222, 31, 154, 193, 142, 203, 109, 169,
+       254, 178, 165, 184, 139, 240, 153, 207, 155, 215, 133, 187, 142,
+       254, 78, 155, 207, 151, 253, 145, 58, 71, 250, 210, 219, 211, 223,
+       255, 150, 68, 183, 119, 151, 190, 175, 62, 186, 239, 23, 237, 22,
+       255, 195, 253, 118, 244, 234, 75, 181, 254, 108, 23, 191, 253,
+       171, 63, 184, 38, 117, 246, 136, 121, 132, 91, 178, 79, 115, 76,
+       122, 131, 134, 232, 149, 8, 240, 234, 114, 217, 165, 49, 220, 184,
+       82, 226, 232, 167, 2, 63, 48, 8, 1, 186, 113, 186, 114, 173, 247,
+       253, 255, 126, 248, 102, 95, 189, 27, 234, 219, 253, 115, 253,
+       157, 123, 215, 255, 53, 231, 237, 214, 255, 255, 123, 62, 125,
+       158, 140, 243, 178, 123, 52, 191, 173, 119, 186, 79, 22, 251, 22,
+       234, 223, 102, 83, 253, 137, 97, 29, 94, 125, 42, 249, 245, 251,
+       63, 235, 175, 101, 212, 124, 250, 148, 51, 206, 111, 249, 240,
+       236, 201, 253, 215, 159, 230, 180, 207, 157, 143, 85, 11, 175,
+       233, 87, 221, 225, 94, 194, 202, 252, 217, 127, 184, 13, 248, 199,
+       249, 222, 184, 189, 186, 139, 116, 153, 202, 155, 87, 133, 59,
+       238, 255, 107, 203, 231, 211, 253, 145, 59, 71, 250, 243, 155,
+       243, 219, 255, 146, 101, 165, 115, 250, 73, 103, 190, 13, 196, 79,
+       160, 133, 4, 192, 131, 125, 199, 49, 197, 74, 240, 187, 207, 72,
+       139, 86, 173, 243, 99, 206, 8, 54, 191, 52, 104, 176, 83, 99, 76,
+       85, 151, 195, 121, 85, 76, 244, 110, 35, 69, 164, 21, 120, 184,
+       134, 104, 232, 187, 100, 157, 51, 200, 160, 26, 115, 140, 116,
+       252, 148, 121, 153, 229, 170, 7, 15, 246, 22, 170, 144, 230, 49,
+       183, 225, 3, 78, 121, 31, 234, 105, 203, 80, 42, 225, 136, 175,
+       176, 25, 249, 33, 185, 176, 33, 72, 41, 86, 203, 67, 113, 85, 100,
+       244, 143, 51, 1, 34, 16, 120, 168, 6, 236, 108, 186, 85, 31, 242,
+       196, 128, 57, 125, 136, 126, 218, 158, 172, 182, 127, 29, 255,
+       144, 232, 215, 179, 71, 17, 74, 253, 126, 175, 177, 117, 249, 51,
+       38, 229, 187, 191, 75, 123, 85, 127, 194, 45, 29, 6, 184, 3, 99,
+       205, 85, 83, 195, 121, 85, 4, 244, 70, 35, 9, 180, 133, 120, 168,
+       6, 232, 232, 186, 101, 157, 115, 168, 128, 0, 119, 136, 116, 232,
+       29, 117, 151, 227, 160, 39, 110, 152, 166, 152, 91, 96, 215, 243,
+       233, 102, 86, 88, 28, 122, 203, 144, 11, 32, 232, 200, 39, 132,
+       170, 243, 161, 161, 206, 132, 180, 126, 141, 183, 88, 170, 223,
+       179, 135, 17, 234, 249, 124, 239, 213, 119, 249, 51, 60, 205, 219,
+       191, 75, 255, 221, 87, 146, 109, 88, 6, 106, 164, 180, 126, 201,
+       182, 92, 171, 91, 179, 207, 17, 232, 251, 94, 253, 213, 255, 185,
+       1, 188, 206, 219, 255, 95, 255, 223, 95, 146, 228, 152, 14, 1,
+       188, 190, 93, 190, 95, 149, 191, 30, 239, 86, 163, 242, 253, 130,
+       33, 151, 126, 255, 44, 244, 253, 107, 31, 107, 47, 117, 213, 212,
+       232, 148, 123, 99, 252, 191, 221, 188, 71, 21, 191, 94, 255, 222,
+       161, 242, 253, 134, 96, 85, 126, 127, 44, 234, 223, 123, 159, 235,
+       63, 253, 214, 150, 184, 20, 123, 250, 185, 156, 250, 139, 253, 17,
+       199, 159, 95, 164, 56, 190, 255, 102, 123, 231, 251, 255, 16, 55,
+       75, 186, 241, 219, 211, 94, 123, 218, 72, 143, 219, 103, 253, 183,
+       92, 184, 103, 159, 190, 95, 253, 222, 168, 248, 247, 181, 117,
+       223, 254, 125, 236, 169, 219, 123, 253, 249, 62, 239, 150, 134,
+       244, 52, 123, 201, 188, 183, 178, 169, 237, 52, 151, 255, 123,
+       168, 29, 190, 191, 64, 59, 161, 91, 127, 17, 179, 109, 154, 243,
+       207, 223, 87, 126, 202, 68, 131, 11, 212, 6, 173, 227, 168, 99,
+       79, 152, 22, 182, 135, 241, 211, 103, 201, 75, 85, 212, 125, 186,
+       40, 68, 73, 16, 204, 131, 233, 244, 180, 251, 20, 112, 169, 67,
+       90, 235, 116, 137, 106, 84, 93, 1, 113, 194, 187, 9, 180, 144, 90,
+       168, 6, 216, 27, 186, 68, 223, 70, 221, 162, 64, 127, 138, 90,
+       136, 9, 163, 18, 234, 116, 137, 105, 84, 108, 9, 121, 72, 191,
+       131, 224, 212, 198, 42, 6, 28, 19, 24, 0, 245, 132, 220, 58, 232,
+       26, 130, 3, 169, 165, 214, 158, 181, 186, 47, 91, 186, 22, 234,
+       214, 255, 247, 115, 139, 1, 31, 70, 127, 60, 169, 197, 219, 30,
+       236, 175, 101, 148, 168, 249, 8, 25, 199, 252, 133, 159, 138, 59,
+       7, 136, 159, 247, 129, 189, 214, 228, 203, 175, 23, 95, 234, 119,
+       243, 71, 255, 115, 188, 18, 77, 126, 156, 255, 135, 116, 244, 240,
+       249, 74, 82, 72, 67, 153, 115, 65, 101, 120, 83, 215, 204, 112,
+       51, 152, 4, 186, 219, 38, 253, 19, 27, 173, 32, 108, 113, 130,
+       230, 48, 125, 150, 181, 84, 184, 54, 135, 251, 82, 191, 251, 252,
+       99, 102, 140, 247, 95, 246, 108, 170, 185, 243, 237, 47, 56, 238,
+       231, 148, 195, 225, 228, 53, 205, 188, 149, 183, 172, 110, 100,
+       55, 251, 251, 147, 92, 223, 57, 208, 187, 129, 102, 124, 24, 53,
+       252, 219, 162, 142, 254, 117, 240, 202, 236, 219, 17, 116, 4, 173,
+       231, 168, 107, 75, 152, 6, 254, 147, 248, 215, 103, 201, 107, 85,
+       212, 125, 186, 41, 68, 235, 16, 205, 131, 237, 180, 180, 251, 20,
+       112, 154, 94, 39, 190, 3, 226, 187, 112, 181, 70, 211, 231, 109,
+       207, 161, 205, 110, 177, 155, 195, 96, 135, 6, 237, 145, 98, 202,
+       139, 39, 247, 37, 241, 73, 42, 154, 187, 104, 172, 184, 16, 174,
+       25, 19, 112, 189, 131, 224, 74, 135, 33, 110, 24, 19, 12, 130,
+       241, 196, 189, 58, 232, 152, 129, 43, 169, 65, 66, 222, 155, 108,
+       136, 168, 4, 238, 17, 115, 208, 189, 130, 240, 203, 98, 0, 106,
+       156, 3, 92, 7, 209, 132, 177, 250, 64, 28, 128, 41, 168, 143, 28,
+       148, 187, 169, 180, 28, 19, 157, 91, 200, 117, 236, 254, 3, 219,
+       205, 35, 183, 149, 191, 198, 82, 235, 132, 243, 218, 138, 154,
+       117, 169, 23, 184, 240, 90, 124, 91, 156, 80, 84, 163, 5, 164, 21,
+       47, 155, 74, 145, 172, 189, 193, 192, 110, 231, 144, 9, 243, 225,
+       16, 59, 107, 148, 110, 154, 225, 172, 149, 247, 172, 173, 108,
+       191, 191, 251, 186, 92, 231, 163, 92, 155, 129, 70, 124, 28, 63,
+       76, 219, 179, 174, 250, 245, 244, 138, 216, 218, 28, 67, 66, 93,
+       251, 44, 136, 168, 4, 172, 17, 17, 192, 156, 138, 252, 75, 166,
+       17, 31, 223, 2, 5, 130, 241, 132, 152, 250, 248, 28, 147, 161,
+       161, 3, 9, 81, 131, 102, 136, 232, 0, 172, 17, 115, 66, 157, 131,
+       112, 75, 106, 129, 27, 217, 2, 40, 70, 224, 132, 144, 154, 72, 68,
+       139, 33, 168, 144, 116, 127, 84, 75, 67, 49, 101, 185, 182, 167,
+       56, 92, 215, 45, 31, 35, 53, 235, 32, 96, 199, 34, 78, 83, 138,
+       81, 2, 64, 48, 39, 123, 228, 163, 141, 161, 172, 47, 77, 31, 2,
+       191, 131, 89, 215, 39, 88, 75, 213, 68, 125, 61, 184, 76, 233, 0,
+       205, 211, 253, 244, 128, 232, 148, 97, 1, 66, 89, 155, 100, 137,
+       232, 68, 236, 17, 113, 210, 157, 131, 208, 72, 106, 137, 2, 217,
+       2, 60, 70, 240, 4, 128, 186, 104, 20, 139, 225, 168, 66, 17, 149,
+       141, 41, 104, 144, 79, 175, 177, 168, 109, 174, 170, 101, 206,
+       192, 39, 234, 1, 21, 41, 67, 208, 144, 50, 90, 27, 216, 100, 43,
+       158, 54, 60, 23, 186, 227, 166, 152, 66, 173, 23, 233, 149, 14,
+       202, 37, 223, 238, 185, 195, 151, 30, 131, 26, 228, 144, 208, 10,
+       74, 203, 87, 43, 150, 231, 118, 35, 152, 250, 240, 185, 204, 154,
+       89, 129, 243, 156, 214, 233, 237, 245, 25, 155, 181, 179, 71, 168,
+       212, 29, 32, 154, 239, 148, 85, 181, 245, 213, 87, 17, 206, 172,
+       4, 79, 184, 91, 170, 145, 110, 211, 208, 221, 103, 151, 197, 124,
+       239, 233, 103, 239, 187, 176, 254, 111, 188, 28, 243, 193, 37,
+       220, 88, 158, 246, 34, 238, 62, 18, 188, 138, 82, 98, 188, 191,
+       33, 107, 166, 117, 189, 67, 37, 205, 16, 234, 211, 227, 122, 131,
+       40, 113, 41, 27, 130, 19, 151, 151, 109, 169, 176, 71, 143, 53,
+       179, 127, 140, 170, 44, 142, 174, 3, 234, 1, 20, 169, 2, 209, 132,
+       50, 90, 83, 16, 12, 137, 143, 134, 19, 23, 178, 235, 173, 176, 65,
+       173, 19, 179, 125, 78, 200, 44, 142, 175, 147, 239, 1, 20, 163, 2,
+       213, 144, 82, 90, 71, 203, 79, 171, 135, 129, 209, 24, 106, 232,
+       157, 62, 253, 78, 57, 113, 100, 21, 218, 236, 113, 150, 27, 22,
+       106, 247, 56, 30, 117, 34, 153, 38, 236, 88, 194, 203, 153, 133,
+       234, 19, 179, 108, 172, 169, 196, 174, 25, 81, 82, 156, 147, 120,
+       203, 238, 43, 30, 95, 19, 52, 138, 241, 5, 152, 58, 104, 136, 27,
+       225, 129, 64, 232, 16, 155, 10, 137, 160, 0, 174, 177, 128, 0,
+       172, 130, 64, 194, 162, 41, 106, 17, 2, 73, 195, 113, 140, 16, 27,
+       120, 24, 0, 9, 136, 52, 20, 221, 126, 162, 103, 83, 88, 51, 147,
+       165, 24, 87, 119, 9, 123, 19, 210, 20, 58, 41, 66, 123, 56, 219,
+       143, 101, 60, 184, 227, 102, 50, 254, 223, 185, 238, 171, 116, 30,
+       188, 137, 222, 188, 237, 126, 255, 111, 54, 149, 211, 221, 99,
+       255, 3, 186, 187, 243, 221, 173, 191, 178, 247, 166, 119, 7, 75,
+       123, 250, 236, 133, 254, 132, 137, 24, 57, 202, 156, 223, 125, 10,
+       142, 211, 23, 215, 210, 35, 10, 240, 5, 24, 174, 250, 20, 147,
+       211, 161, 65, 107, 18, 154, 104, 141, 168, 64, 172, 25, 193, 88,
+       188, 147, 32, 73, 196, 57, 106, 83, 2, 3, 130, 112, 149, 48, 58,
+       122, 24, 11, 161, 161, 194, 169, 151, 146, 109, 164, 184, 130,
+       171, 25, 154, 81, 164, 218, 108, 66, 200, 51, 107, 81, 22, 73,
+       194, 225, 13, 48, 158, 91, 128, 10, 49, 143, 38, 154, 197, 154,
+       202, 65, 188, 205, 31, 119, 177, 255, 12, 46, 109, 25, 239, 147,
+       147, 145, 23, 78, 11, 240, 28, 18, 223, 239, 153, 81, 165, 219,
+       97, 20, 91, 87, 96, 124, 104, 50, 120, 67, 107, 88, 243, 114, 140,
+       122, 85, 22, 120, 40, 189, 152, 245, 14, 6, 191, 240, 64, 136,
+       195, 74, 20, 180, 212, 213, 254, 236, 105, 70, 200, 83, 243, 185,
+       254, 67, 105, 88, 11, 219, 202, 36, 50, 63, 102, 91, 163, 176,
+       218, 69, 60, 253, 251, 208, 16, 203, 173, 135, 183, 189, 232, 108,
+       167, 191, 211, 138, 157, 239, 226, 64, 223, 131, 230, 236, 28, 63,
+       77, 219, 163, 174, 242, 87, 90, 138, 196, 139, 92, 159, 223, 249,
+       114, 178, 188, 95, 182, 89, 222, 29, 253, 255, 125, 223, 161, 151,
+       115, 149, 127, 253, 68, 44, 174, 234, 95, 125, 206, 134, 247, 157,
+       123, 231, 223, 121, 194, 230, 52, 222, 180, 137, 90, 57, 235, 124,
+       253, 253, 114, 135, 211, 149, 231, 246, 35, 170, 227, 35, 92, 174,
+       190, 87, 255, 193, 119, 70, 81, 27, 186, 203, 141, 184, 196, 140,
+       25, 241, 82, 156, 211, 104, 90, 236, 147, 91, 211, 2, 7, 90, 240,
+       149, 48, 26, 106, 144, 27, 163, 163, 216, 191, 150, 250, 185, 189,
+       94, 255, 191, 27, 188, 93, 239, 235, 64, 211, 135, 107, 237, 28,
+       122, 105, 154, 247, 250, 251, 119, 251, 154, 196, 171, 11, 252,
+       158, 169, 126, 179, 119, 87, 186, 147, 238, 156, 189, 123, 125,
+       171, 179, 149, 210, 149, 39, 253, 65, 56, 191, 235, 223, 101, 191,
+       186, 246, 222, 115, 143, 223, 248, 118, 178, 244, 31, 180, 121,
+       206, 28, 245, 249, 127, 223, 53, 151, 115, 149, 127, 255, 68, 172,
+       235, 106, 95, 45, 174, 238, 247, 142, 119, 102, 121, 27, 218, 207,
+       228, 190, 196, 139, 24, 185, 66, 188, 223, 109, 90, 236, 211, 95,
+       211, 66, 35, 26, 241, 181, 24, 142, 78, 17, 91, 163, 179, 34, 210,
+       245, 154, 106, 225, 144, 206, 207, 21, 185, 163, 44, 222, 108, 74,
+       207, 83, 163, 145, 134, 111, 202, 209, 28, 16, 95, 127, 213, 74,
+       165, 155, 239, 158, 232, 94, 179, 116, 31, 184, 211, 206, 28, 253,
+       120, 125, 255, 181, 151, 83, 149, 39, 255, 68, 44, 171, 106, 95,
+       101, 175, 142, 247, 158, 117, 230, 125, 51, 170, 233, 237, 150,
+       196, 141, 24, 153, 41, 172, 222, 109, 26, 206, 51, 219, 83, 66, 3,
+       154, 241, 177, 16, 10, 186, 24, 91, 167, 155, 166, 218, 132, 158,
+       108, 39, 176, 204, 154, 253, 177, 255, 96, 238, 110, 11, 205, 195,
+       179, 215, 134, 71, 74, 241, 28, 18, 253, 190, 157, 29, 216, 223,
+       28, 170, 158, 120, 26, 233, 19, 202, 174, 21, 164, 0, 207, 227,
+       41, 24, 163, 81, 233, 80, 26, 35, 10, 53, 201, 231, 3, 95, 240,
+       81, 39, 34, 221, 254, 206, 158, 190, 123, 71, 252, 222, 246, 215,
+       222, 247, 224, 187, 75, 55, 230, 110, 110, 253, 231, 191, 63, 248,
+       39, 101, 60, 255, 249, 217, 112, 247, 125, 127, 110, 187, 85, 94,
+       249, 203, 218, 157, 175, 94, 253, 127, 55, 135, 211, 213, 99, 253,
+       67, 186, 234, 123, 88, 13, 191, 87, 247, 167, 119, 102, 123, 236,
+       210, 205, 225, 188, 196, 202, 189, 209, 171, 96, 206, 127, 75,
+       200, 255, 179, 211, 150, 66, 207, 241, 29, 16, 219, 251, 149, 27,
+       244, 150, 110, 116, 177, 182, 219, 100, 155, 29, 27, 239, 145, 93,
+       220, 255, 73, 158, 157, 221, 85, 149, 171, 86, 216, 202, 253, 214,
+       189, 190, 130, 119, 135, 243, 246, 245, 127, 238, 239, 96, 223,
+       237, 139, 246, 184, 139, 78, 255, 127, 3, 171, 211, 213, 227, 124,
+       35, 154, 242, 59, 88, 143, 191, 23, 127, 244, 86, 204, 80, 177,
+       182, 172, 68, 191, 56, 216, 234, 145, 117, 220, 127, 89, 107, 215,
+       117, 125, 111, 225, 103, 218, 226, 213, 214, 127, 184, 28, 115,
+       21, 113, 246, 255, 250, 142, 207, 117, 214, 232, 137, 222, 184,
+       43, 110, 252, 111, 22, 249, 243, 197, 227, 252, 39, 58, 251, 187,
+       84, 135, 63, 113, 127, 254, 215, 246, 253, 112, 142, 239, 81, 150,
+       232, 201, 198, 188, 175, 106, 254, 111, 23, 255, 211, 203, 226,
+       108, 35, 190, 251, 186, 84, 143, 63, 95, 127, 174, 86, 240, 135,
+       193, 69, 146, 34, 68, 175, 80, 162, 138, 250, 83, 112, 5, 16, 89,
+       198, 100, 32, 232, 251, 69, 15, 185, 38, 101, 20, 225, 120, 210,
+       8, 103, 103, 230, 6, 205, 29, 78, 233, 239, 212, 140, 141, 74,
+       232, 255, 167, 200, 192, 251, 126, 204, 99, 174, 224, 63, 88, 197,
+       63, 246, 255, 250, 228, 215, 95, 245, 199, 162, 123, 79, 148, 39,
+       250, 159, 236, 255, 103, 137, 246, 23, 246, 124, 110, 233, 212,
+       237, 170, 160, 242, 101, 144, 174, 247, 132, 125, 157, 95, 109,
+       231, 182, 62, 239, 180, 80, 232, 95, 246, 209, 125, 155, 97, 62,
+       78, 53, 239, 241, 240, 109, 174, 102, 235, 231, 192, 111, 251,
+       213, 241, 125, 253, 84, 103, 201, 95, 70, 188, 231, 186, 42, 72,
+       75, 248, 77, 247, 81, 198, 228, 98, 93, 112, 223, 184, 46, 217,
+       69, 47, 123, 119, 202, 134, 181, 85, 51, 234, 244, 190, 94, 212,
+       89, 67, 239, 88, 87, 93, 57, 116, 222, 218, 23, 78, 222, 182, 121,
+       167, 243, 251, 4, 16, 18, 219, 224, 32, 153, 100, 56, 97, 237, 47,
+       94, 207, 123, 170, 44, 24, 159, 19, 81, 57, 145, 159, 85, 58, 40,
+       20, 81, 22, 231, 223, 63, 100, 18, 81, 195, 162, 157, 223, 149,
+       183, 160, 104, 15, 184, 53, 78, 94, 245, 255, 103, 139, 71, 23,
+       91, 125, 111, 121, 212, 235, 43, 168, 246, 45, 132, 174, 247, 129,
+       113, 173, 223, 111, 227, 228, 182, 255, 148, 117, 74, 127, 118,
+       121, 127, 191, 112, 125, 254, 54, 238, 255, 180, 57, 235, 103,
+       239, 167, 128, 239, 251, 240, 249, 157, 244, 158, 211, 170, 55,
+       30, 216, 150, 178, 149, 118, 93, 211, 233, 167, 127, 89, 222, 234,
+       227, 199, 59, 242, 250, 137, 231, 180, 62, 251, 41, 177, 189, 67,
+       192, 39, 145, 90, 71, 184, 116, 100, 102, 132, 203, 100, 155, 212,
+       80, 204, 172, 110, 233, 208, 109, 46, 228, 231, 165, 69, 102, 183,
+       92, 112, 108, 191, 149, 246, 180, 74, 38, 185, 50, 138, 214, 104,
+       246, 243, 137, 197, 21, 118, 237, 42, 49, 192, 202, 47, 236, 167,
+       103, 156, 138, 248, 151, 35, 190, 78, 173, 177, 173, 127, 93, 135,
+       31, 254, 20, 25, 143, 44, 119, 41, 205, 63, 183, 21, 184, 92, 120,
+       146, 207, 211, 255, 247, 144, 124, 212, 119, 173, 158, 189, 251,
+       220, 230, 247, 188, 86, 218, 93, 86, 217, 125, 27, 105, 221, 114,
+       23, 235, 241, 122, 123, 191, 111, 207, 247, 68, 251, 251, 244,
+       243, 134, 190, 220, 183, 186, 171, 60, 168, 191, 255, 51, 245,
+       230, 238, 207, 11, 151, 107, 111, 23, 166, 76, 203, 125, 206, 146,
+       127, 230, 140, 233, 1, 223, 7, 158, 173, 223, 240, 86, 175, 248,
+       122, 202, 84, 198, 252, 119, 189, 101, 55, 119, 55, 238, 241, 64,
+       190, 255, 109, 62, 239, 140, 158, 242, 33, 245, 43, 156, 172, 179,
+       141, 63, 93, 135, 31, 255, 12, 31, 206, 44, 119, 79, 201, 79, 183,
+       21, 190, 88, 121, 178, 239, 223, 223, 119, 146, 125, 213, 126, 13,
+       191, 173, 215, 220, 198, 255, 184, 218, 250, 29, 70, 240, 253, 89,
+       43, 93, 246, 55, 251, 161, 208, 126, 255, 111, 15, 239, 196, 159,
+       226, 85, 115, 117, 141, 206, 167, 156, 75, 71, 188, 118, 230, 142,
+       143, 87, 98, 27, 82, 123, 230, 108, 110, 125, 203, 125, 46, 248,
+       231, 229, 85, 164, 123, 220, 80, 63, 189, 188, 151, 183, 249, 151,
+       164, 91, 251, 29, 59, 238, 248, 95, 175, 179, 106, 181, 87, 55,
+       120, 186, 171, 174, 95, 93, 51, 222, 127, 217, 95, 254, 167, 186,
+       250, 137, 121, 29, 223, 158, 175, 157, 26, 198, 255, 106, 120,
+       217, 247, 127, 17, 28, 75, 234, 146, 251, 127, 127, 255, 146, 94,
+       165, 67, 47, 249, 164, 183, 189, 159, 94, 168, 151, 253, 13, 5,
+       232, 232, 91, 130, 217, 111, 249, 87, 142, 64, 250, 185, 175, 219,
+       205, 255, 142, 111, 88, 214, 206, 231, 165, 243, 173, 12, 109,
+       189, 23, 191, 5, 213, 237, 231, 88, 206, 85, 78, 251, 94, 50, 72,
+       251, 178, 239, 87, 223, 252, 178, 223, 148, 248, 238, 118, 119,
+       10, 107, 103, 54, 252, 61, 238, 218, 253, 200, 206, 141, 209, 215,
+       223, 239, 103, 229, 215, 255, 250, 54, 118, 27, 142, 14, 223, 36,
+       93, 156, 127, 46, 79, 10, 31, 63, 248, 166, 166, 198, 143, 201,
+       199, 59, 65, 124, 220, 235, 238, 232, 215, 239, 62, 119, 3, 161,
+       189, 51, 255, 28, 82, 124, 239, 253, 103, 62, 74, 79, 248, 115,
+       164, 191, 202, 115, 97, 217, 18, 122, 196, 108, 106, 105, 99, 237,
+       46, 248, 239, 101, 52, 103, 187, 70, 96, 61, 87, 111, 109, 52, 10,
+       111, 120, 117, 224, 255, 198, 83, 105, 185, 96, 126, 236, 62, 238,
+       201, 179, 125, 14, 242, 239, 161, 132, 109, 187, 112, 48, 60, 116,
+       144, 178, 9, 253, 80, 218, 39, 175, 105, 9, 143, 31, 75, 152, 153,
+       147, 197, 17, 14, 80, 91, 148, 139, 215, 21, 119, 162, 70, 14, 82,
+       44, 16, 240, 194, 85, 253, 99, 222, 71, 45, 125, 10, 26, 241, 235,
+       36, 89, 154, 163, 24, 2, 50, 120, 242, 95, 157, 5, 110, 210, 219,
+       68, 170, 74, 152, 255, 99, 35, 114, 249, 151, 89, 119, 38, 146,
+       25, 63, 118, 43, 207, 23, 177, 157, 179, 221, 181, 224, 75, 251,
+       222, 67, 207, 196, 165, 254, 33, 114, 232, 59, 208, 135, 235, 220,
+       86, 79, 117, 135, 177, 203, 59, 8, 125, 41, 18, 157, 134, 182, 28,
+       123, 76, 15, 190, 160, 221, 18, 43, 152, 189, 16, 189, 253, 69,
+       246, 253, 83, 245, 206, 244, 22, 26, 127, 55, 105, 236, 176, 19,
+       168, 185, 180, 50, 202, 87, 235, 195, 2, 243, 104, 244, 242, 255,
+       136, 254, 243, 164, 62, 120, 150, 121, 59, 246, 243, 219, 61, 220,
+       123, 239, 215, 119, 157, 188, 252, 197, 224, 223, 251, 246, 193,
+       231, 204, 250, 11, 32, 73, 60, 219, 140, 207, 149, 45, 204, 150,
+       182, 2, 244, 89, 39, 11, 200, 48, 107, 75, 80, 233, 83, 188, 77,
+       19, 87, 81, 81, 58, 221, 170, 89, 197, 106, 166, 20, 149, 94, 53,
+       4, 200, 223, 143, 115, 77, 50, 80, 248, 175, 157, 239, 221, 155,
+       20, 61, 250, 237, 172, 217, 45, 142, 248, 90, 188, 161, 252, 244,
+       252, 11, 220, 232, 154, 151, 180, 187, 247, 237, 94, 11, 255, 245,
+       127, 229, 172, 227, 235, 221, 255, 203, 239, 253, 133, 184, 214,
+       210, 44, 68, 158, 253, 13, 118, 52, 158, 196, 23, 230, 19, 194,
+       249, 41, 203, 73, 84, 171, 34, 0, 229, 91, 145, 71, 191, 83, 21,
+       210, 249, 124, 130, 76, 8, 172, 221, 13, 118, 249, 24, 198, 181,
+       199, 2, 248, 187, 121, 106, 104, 84, 187, 217, 2, 81, 219, 224,
+       79, 111, 251, 5, 183, 43, 125, 42, 152, 29, 245, 85, 163, 94, 95,
+       63, 117, 234, 118, 48, 123, 55, 132, 253, 118, 254, 181, 106, 249,
+       216, 121, 174, 199, 235, 117, 130, 34, 244, 196, 121, 83, 174, 16,
+       164, 52, 173, 134, 119, 29, 171, 154, 94, 166, 186, 64, 128, 221,
+       231, 78, 37, 152, 43, 192, 203, 184, 148, 175, 186, 8, 74, 137,
+       13, 24, 157, 107, 101, 165, 126, 93, 55, 100, 206, 94, 165, 251,
+       61, 146, 98, 6, 126, 253, 131, 221, 216, 247, 171, 227, 249, 224,
+       129, 38, 230, 148, 127, 9, 61, 245, 85, 163, 94, 109, 19, 118,
+       250, 118, 68, 249, 54, 210, 253, 55, 110, 180, 142, 245, 208, 253,
+       40, 110, 235, 55, 128, 42, 244, 201, 253, 137, 124, 158, 181, 195,
+       127, 116, 23, 181, 150, 70, 28, 239, 35, 3, 223, 35, 230, 236, 14,
+       108, 212, 51, 170, 134, 211, 85, 3, 170, 244, 136, 95, 190, 75,
+       212, 252, 167, 19, 222, 109, 29, 170, 178, 2, 111, 43, 53, 129,
+       254, 247, 149, 227, 104, 227, 65, 206, 178, 223, 101, 151, 119,
+       248, 232, 9, 219, 57, 236, 85, 162, 86, 95, 23, 55, 236, 150, 181,
+       114, 63, 210, 115, 38, 230, 125, 206, 233, 220, 229, 74, 243, 105,
+       165, 144, 38, 244, 212, 123, 237, 94, 254, 81, 233, 127, 117, 150,
+       247, 254, 38, 157, 74, 39, 195, 223, 129, 102, 234, 28, 36, 197,
+       35, 178, 70, 223, 85, 19, 138, 245, 78, 95, 88, 254, 217, 243,
+       162, 232, 56, 150, 171, 17, 58, 161, 191, 159, 64, 210, 167, 95,
+       253, 208, 70, 88, 146, 225, 239, 245, 62, 195, 164, 208, 141, 27,
+       116, 76, 222, 236, 190, 27, 222, 237, 201, 2, 176, 10, 79, 107,
+       53, 203, 171, 197, 205, 99, 108, 39, 9, 206, 242, 255, 69, 29,
+       245, 251, 248, 10, 202, 178, 224, 176, 187, 144, 184, 187, 155,
+       93, 16, 183, 173, 207, 126, 195, 167, 19, 253, 149, 246, 77, 154,
+       209, 206, 89, 255, 255, 30, 132, 157, 91, 101, 97, 217, 71, 108,
+       73, 231, 200, 235, 252, 189, 8, 178, 193, 223, 54, 136, 236, 78,
+       78, 75, 103, 234, 96, 23, 24, 5, 58, 65, 251, 70, 228, 103, 150,
+       236, 87, 228, 54, 94, 186, 19, 255, 95, 255, 97, 109, 158, 41, 95,
+       214, 181, 175, 188, 208, 109, 189, 70, 111, 253, 133, 45, 237,
+       220, 85, 218, 0, 151, 164, 33, 50, 44, 71, 36, 11, 210, 112, 143,
+       170, 160, 219, 226, 181, 238, 161, 12, 211, 129, 72, 144, 226,
+       250, 131, 0, 100, 167, 37, 32, 133, 56, 248, 221, 237, 145, 175,
+       95, 53, 12, 24, 166, 252, 104, 40, 137, 27, 170, 17, 22, 42, 122,
+       181, 205, 151, 21, 127, 208, 8, 149, 46, 40, 161, 146, 56, 217,
+       221, 144, 71, 191, 133, 160, 25, 46, 219, 100, 144, 136, 59, 194,
+       16, 22, 171, 82, 151, 31, 214, 16, 123, 210, 12, 238, 138, 183,
+       134, 104, 166, 252, 23, 222, 249, 25, 234, 153, 223, 83, 108, 254,
+       33, 223, 195, 23, 239, 252, 39, 108, 238, 122, 28, 175, 188, 29,
+       255, 216, 85, 190, 180, 188, 243, 107, 39, 156, 90, 155, 187, 49,
+       27, 157, 127, 76, 43, 175, 91, 213, 179, 234, 70, 154, 195, 203,
+       219, 125, 191, 205, 120, 139, 147, 190, 246, 236, 119, 141, 121,
+       148, 207, 223, 223, 181, 189, 203, 237, 94, 139, 137, 195, 229,
+       17, 190, 110, 251, 130, 107, 91, 85, 95, 199, 124, 222, 210, 215,
+       134, 197, 69, 168, 42, 167, 136, 255, 186, 179, 252, 192, 224,
+       205, 239, 49, 68, 108, 62, 161, 101, 207, 202, 8, 50, 103, 150,
+       202, 249, 65, 37, 204, 172, 180, 127, 153, 236, 13, 135, 190, 19,
+       135, 16, 255, 247, 72, 107, 129, 119, 121, 24, 50, 76, 251, 49,
+       201, 243, 95, 121, 130, 81, 133, 42, 173, 99, 33, 203, 236, 141,
+       239, 73, 206, 252, 145, 78, 152, 200, 255, 106, 200, 40, 90, 95,
+       199, 35, 110, 240, 76, 24, 167, 124, 93, 27, 209, 196, 167, 179,
+       230, 208, 239, 55, 185, 235, 203, 221, 28, 118, 12, 252, 246, 175,
+       239, 19, 179, 181, 183, 107, 50, 208, 31, 26, 223, 238, 223, 108,
+       179, 245, 18, 6, 6, 140, 43, 35, 168, 107, 44, 10, 219, 242, 141,
+       130, 164, 77, 242, 37, 63, 161, 40, 135, 7, 204, 144, 114, 250,
+       146, 20, 68, 53, 165, 160, 137, 185, 254, 93, 197, 211, 235, 223,
+       21, 196, 26, 182, 248, 50, 97, 200, 58, 19, 65, 122, 42, 122, 183,
+       249, 183, 154, 123, 16, 8, 244, 238, 17, 221, 93, 237, 50, 130,
+       11, 182, 4, 160, 218, 230, 245, 51, 160, 96, 102, 246, 29, 168,
+       201, 152, 85, 47, 232, 167, 174, 128, 60, 154, 32, 57, 158, 238,
+       164, 55, 141, 249, 212, 143, 223, 183, 150, 27, 107, 232, 95, 139,
+       169, 235, 237, 23, 254, 109, 175, 179, 106, 91, 85, 123, 199, 93,
+       221, 78, 71, 161, 171, 128, 156, 70, 239, 205, 194, 229, 143, 10,
+       208, 246, 122, 96, 88, 206, 57, 249, 219, 11, 190, 64, 249, 4,
+       175, 236, 132, 34, 244, 96, 163, 109, 35, 222, 221, 196, 71, 103,
+       253, 130, 192, 16, 178, 243, 49, 117, 216, 106, 19, 201, 106, 206,
+       242, 175, 249, 190, 158, 10, 0, 16, 246, 234, 108, 252, 241, 115,
+       217, 123, 160, 138, 19, 179, 101, 24, 75, 245, 73, 158, 25, 220,
+       225, 16, 51, 118, 219, 130, 77, 215, 21, 117, 227, 125, 94, 162,
+       44, 168, 225, 123, 117, 219, 225, 184, 86, 113, 117, 24, 219, 101,
+       216, 173, 89, 24, 179, 25, 58, 252, 109, 149, 77, 223, 209, 100,
+       211, 141, 86, 224, 118, 205, 148, 174, 157, 72, 198, 172, 161, 21,
+       186, 3, 106, 104, 13, 214, 233, 199, 108, 243, 92, 41, 25, 237,
+       185, 246, 198, 19, 225, 123, 252, 14, 179, 200, 47, 188, 93, 196,
+       201, 109, 149, 65, 196, 19, 48, 223, 62, 113, 216, 168, 19, 141,
+       111, 207, 114, 223, 115, 122, 154, 75, 17, 8, 246, 238, 196, 22,
+       157, 191, 46, 106, 48, 24, 124, 186, 147, 112, 215, 112, 137, 107,
+       211, 85, 124, 33, 161, 100, 207, 10, 196, 162, 251, 148, 148, 107,
+       21, 1, 15, 130, 165, 171, 53, 166, 235, 152, 103, 77, 219, 70,
+       253, 74, 58, 236, 212, 9, 63, 221, 155, 128, 121, 245, 197, 252,
+       154, 196, 158, 7, 49, 196, 140, 31, 241, 247, 230, 98, 191, 254,
+       24, 158, 124, 243, 93, 127, 233, 137, 63, 91, 151, 227, 240, 214,
+       40, 234, 124, 79, 111, 172, 183, 241, 165, 243, 165, 95, 207, 61,
+       66, 14, 110, 184, 176, 194, 66, 198, 113, 97, 49, 115, 118, 228,
+       34, 110, 229, 212, 93, 15, 100, 163, 101, 0, 45, 248, 32, 184, 34,
+       153, 11, 186, 114, 133, 186, 101, 30, 9, 89, 251, 52, 158, 32, 16,
+       238, 187, 19, 131, 19, 26, 8, 255, 21, 4, 186, 234, 28, 11, 163,
+       155, 27, 132, 37, 159, 53, 246, 75, 59, 85, 73, 223, 210, 235,
+       101, 184, 228, 88, 130, 223, 141, 155, 169, 101, 141, 129, 254,
+       146, 208, 54, 142, 244, 100, 218, 156, 149, 188, 139, 100, 20,
+       239, 31, 27, 192, 59, 140, 191, 32, 203, 205, 219, 191, 131, 63,
+       79, 90, 243, 185, 246, 222, 127, 154, 125, 165, 27, 17, 215, 59,
+       174, 22, 135, 187, 117, 108, 69, 88, 71, 117, 108, 58, 0, 190,
+       107, 19, 45, 129, 185, 52, 111, 249, 173, 42, 0, 125, 10, 33, 219,
+       163, 100, 67, 72, 85, 237, 168, 70, 20, 65, 224, 23, 16, 136, 116,
+       129, 72, 168, 18, 156, 35, 191, 84, 211, 23, 8, 146, 104, 89, 13,
+       122, 152, 161, 32, 3, 9, 93, 167, 168, 74, 150, 96, 224, 22, 48,
+       136, 116, 0, 120, 40, 18, 157, 35, 191, 82, 95, 21, 12, 130, 104,
+       89, 8, 105, 144, 213, 77, 75, 108, 146, 14, 79, 248, 80, 194, 72,
+       142, 115, 97, 57, 97, 52, 236, 16, 238, 105, 214, 60, 47, 241,
+       175, 197, 0, 57, 242, 80, 56, 237, 122, 157, 19, 205, 124, 245,
+       150, 186, 254, 183, 60, 222, 244, 203, 191, 137, 70, 238, 26, 245,
+       102, 251, 96, 71, 195, 117, 53, 202, 117, 206, 251, 51, 148, 204,
+       222, 31, 151, 94, 47, 151, 3, 143, 18, 98, 120, 190, 101, 89, 210,
+       90, 168, 127, 235, 125, 255, 59, 63, 148, 19, 189, 202, 248, 30,
+       141, 93, 90, 211, 246, 186, 126, 214, 61, 2, 126, 178, 61, 211,
+       169, 173, 126, 90, 150, 234, 97, 180, 0, 238, 102, 137, 34, 129,
+       47, 219, 169, 161, 19, 220, 214, 213, 70, 143, 172, 246, 253, 242,
+       118, 198, 89, 169, 181, 205, 111, 108, 50, 76, 225, 252, 20, 238,
+       6, 42, 87, 0, 127, 253, 121, 156, 15, 4, 227, 157, 225, 182, 248,
+       3, 61, 67, 83, 151, 153, 238, 55, 233, 255, 43, 147, 141, 183,
+       148, 116, 203, 6, 127, 218, 130, 159, 196, 248, 212, 71, 212, 148,
+       211, 172, 52, 188, 191, 252, 27, 30, 48, 220, 126, 189, 239, 135,
+       83, 124, 59, 245, 65, 59, 224, 172, 218, 255, 134, 140, 112, 153,
+       53, 54, 52, 165, 83, 149, 253, 113, 146, 87, 127, 117, 29, 194,
+       252, 79, 63, 137, 90, 167, 16, 190, 116, 250, 178, 79, 222, 85,
+       103, 226, 93, 214, 247, 99, 141, 126, 94, 222, 150, 223, 239, 205,
+       150, 174, 15, 112, 106, 63, 115, 225, 227, 122, 165, 228, 75, 63,
+       127, 123, 47, 220, 27, 153, 122, 248, 78, 177, 55, 90, 75, 114,
+       187, 115, 80, 117, 44, 119, 54, 59, 146, 166, 112, 118, 172, 134,
+       224, 172, 156, 37, 126, 118, 233, 32, 193, 41, 131, 106, 207, 134,
+       232, 186, 218, 79, 241, 49, 192, 238, 21, 68, 50, 172, 211, 107,
+       104, 227, 59, 163, 80, 2, 23, 138, 241, 213, 145, 26, 107, 144,
+       17, 45, 162, 7, 90, 246, 213, 38, 58, 184, 210, 126, 178, 90, 230,
+       205, 58, 183, 238, 103, 101, 187, 1, 133, 244, 71, 232, 4, 126,
+       219, 134, 159, 237, 89, 189, 39, 251, 120, 72, 218, 149, 186, 216,
+       79, 125, 252, 78, 8, 26, 254, 32, 111, 137, 82, 254, 151, 42, 127,
+       245, 62, 12, 163, 238, 253, 139, 234, 149, 117, 181, 248, 75, 250,
+       80, 154, 235, 82, 33, 253, 178, 81, 126, 158, 112, 127, 159, 150,
+       176, 31, 42, 237, 215, 126, 173, 163, 237, 189, 130, 238, 164,
+       145, 6, 127, 65, 164, 127, 231, 39, 124, 110, 255, 22, 195, 8,
+       183, 111, 106, 6, 78, 46, 253, 180, 101, 46, 39, 251, 114, 16,
+       113, 217, 229, 101, 6, 18, 254, 211, 226, 240, 185, 83, 237, 213,
+       95, 247, 140, 190, 231, 238, 39, 63, 179, 17, 148, 216, 167, 192,
+       78, 54, 90, 195, 135, 230, 165, 245, 226, 197, 47, 62, 220, 201,
+       167, 175, 200, 87, 168, 25, 112, 109, 62, 83, 201, 67, 99, 39,
+       114, 111, 126, 127, 125, 38, 222, 89, 85, 88, 244, 250, 96, 170,
+       177, 93, 109, 201, 17, 11, 203, 181, 96, 40, 166, 212, 64, 62,
+       192, 60, 98, 17, 2, 122, 226, 17, 13, 144, 17, 123, 80, 8, 86,
+       238, 55, 251, 96, 137, 223, 23, 222, 220, 67, 224, 180, 238, 10,
+       28, 215, 164, 94, 217, 150, 247, 207, 58, 125, 248, 58, 24, 141,
+       182, 255, 63, 218, 157, 118, 135, 192, 201, 200, 55, 78, 187, 7,
+       49, 253, 203, 65, 39, 220, 212, 125, 158, 167, 174, 154, 18, 205,
+       145, 62, 237, 141, 245, 183, 234, 216, 4, 155, 188, 244, 215, 223,
+       189, 116, 255, 255, 187, 126, 18, 110, 253, 108, 175, 167, 127,
+       183, 16, 246, 252, 186, 243, 127, 223, 85, 99, 211, 124, 193, 47,
+       60, 9, 253, 237, 252, 82, 87, 216, 83, 188, 245, 34, 91, 125, 81,
+       58, 89, 220, 181, 250, 24, 114, 105, 136, 219, 239, 229, 181, 247,
+       251, 116, 35, 136, 210, 30, 250, 11, 157, 48, 196, 174, 25, 227,
+       85, 140, 195, 104, 202, 228, 25, 234, 80, 22, 69, 146, 241, 215,
+       177, 82, 107, 16, 17, 173, 131, 176, 48, 109, 77, 44, 75, 193,
+       120, 244, 228, 246, 185, 83, 13, 148, 33, 40, 132, 127, 107, 233,
+       181, 113, 29, 85, 107, 97, 148, 117, 168, 86, 240, 34, 189, 20,
+       160, 221, 167, 176, 127, 14, 57, 185, 106, 20, 29, 96, 1, 205,
+       147, 147, 177, 147, 43, 89, 213, 61, 18, 187, 254, 217, 8, 177,
+       147, 101, 58, 170, 164, 224, 44, 88, 2, 42, 239, 88, 173, 151,
+       142, 83, 24, 222, 191, 247, 149, 140, 18, 208, 64, 214, 181, 186,
+       169, 140, 99, 11, 83, 20, 106, 175, 161, 150, 39, 191, 216, 150,
+       167, 158, 135, 215, 229, 91, 10, 55, 76, 89, 255, 0, 209, 41, 40,
+       233, 134, 47, 132, 164, 251, 181, 224, 66, 251, 178, 128, 123,
+       209, 186, 198, 171, 125, 156, 235, 44, 142, 198, 150, 167, 91,
+       255, 209, 134, 75, 174, 243, 30, 20, 62, 255, 135, 21, 47, 95,
+       182, 241, 137, 228, 116, 75, 78, 248, 18, 160, 144, 238, 87, 245,
+       72, 3, 30, 220, 215, 99, 107, 87, 216, 14, 249, 129, 173, 188, 44,
+       168, 22, 178, 2, 145, 4, 191, 79, 197, 188, 125, 132, 25, 88, 66,
+       180, 63, 40, 67, 236, 51, 179, 193, 67, 10, 83, 245, 21, 162, 218,
+       138, 29, 10, 177, 187, 163, 189, 26, 88, 221, 157, 182, 238, 218,
+       61, 32, 28, 44, 152, 38, 49, 169, 11, 66, 65, 246, 43, 58, 119,
+       123, 24, 16, 111, 89, 9, 203, 143, 252, 110, 88, 232, 139, 105,
+       95, 200, 19, 22, 160, 184, 207, 71, 73, 153, 223, 209, 204, 226,
+       106, 7, 106, 18, 243, 213, 9, 127, 241, 113, 6, 34, 92, 161, 88,
+       161, 242, 171, 123, 89, 55, 237, 77, 173, 87, 199, 74, 80, 54,
+       158, 93, 60, 26, 144, 137, 28, 254, 133, 37, 228, 162, 131, 134,
+       243, 212, 196, 44, 174, 174, 14, 95, 173, 4, 118, 139, 31, 215,
+       107, 26, 83, 247, 197, 125, 39, 124, 5, 91, 23, 240, 227, 239,
+       220, 60, 122, 145, 82, 60, 59, 243, 192, 246, 107, 235, 88, 11,
+       165, 120, 234, 29, 149, 229, 156, 62, 156, 23, 56, 19, 178, 160,
+       202, 29, 140, 33, 236, 231, 235, 70, 241, 103, 116, 227, 69, 118,
+       122, 232, 86, 121, 235, 127, 254, 24, 28, 213, 190, 63, 236, 214,
+       156, 165, 246, 165, 202, 22, 61, 52, 162, 231, 245, 126, 253, 180,
+       79, 8, 187, 141, 115, 86, 239, 21, 194, 156, 59, 239, 102, 11,
+       205, 217, 235, 204, 163, 125, 239, 73, 190, 176, 247, 222, 27,
+       177, 93, 220, 14, 110, 70, 165, 245, 173, 46, 77, 55, 132, 191,
+       154, 149, 195, 39, 80, 75, 201, 70, 125, 44, 120, 220, 115, 128,
+       237, 250, 254, 212, 146, 248, 212, 98, 106, 128, 242, 92, 93, 244,
+       65, 115, 87, 5, 117, 18, 104, 241, 188, 244, 88, 186, 162, 8, 146,
+       186, 246, 215, 31, 126, 208, 75, 211, 140, 124, 164, 89, 144, 28,
+       125, 139, 38, 49, 59, 236, 19, 166, 20, 223, 50, 0, 123, 163, 69,
+       120, 44, 48, 201, 147, 13, 193, 235, 82, 68, 8, 33, 169, 2, 160,
+       211, 85, 73, 50, 139, 101, 125, 45, 45, 116, 36, 211, 23, 172, 21,
+       86, 18, 78, 40, 114, 188, 97, 29, 101, 152, 36, 212, 114, 130,
+       198, 185, 15, 72, 67, 218, 195, 245, 235, 210, 63, 67, 80, 198,
+       40, 135, 245, 236, 127, 139, 147, 222, 131, 22, 62, 243, 22, 30,
+       154, 234, 191, 151, 33, 252, 47, 82, 195, 136, 227, 161, 171, 89,
+       15, 231, 89, 239, 92, 199, 253, 140, 95, 185, 147, 157, 131, 18,
+       60, 210, 92, 20, 143, 238, 159, 238, 177, 241, 94, 202, 157, 252,
+       9, 224, 26, 138, 174, 29, 138, 129, 173, 231, 65, 218, 197, 119,
+       237, 210, 10, 1, 235, 49, 211, 245, 202, 95, 144, 49, 37, 114,
+       235, 123, 98, 10, 93, 149, 88, 78, 207, 84, 252, 143, 40, 138,
+       190, 212, 204, 170, 222, 197, 206, 15, 246, 241, 18, 121, 154,
+       187, 31, 4, 122, 94, 90, 214, 115, 222, 50, 90, 26, 188, 57, 14,
+       242, 231, 110, 110, 172, 213, 246, 213, 140, 160, 229, 137, 36,
+       239, 178, 242, 42, 131, 39, 132, 37, 125, 36, 17, 253, 236, 252,
+       7, 87, 89, 71, 12, 249, 43, 83, 249, 41, 0, 216, 152, 6, 96, 24,
+       34, 75, 24, 99, 237, 33, 28, 241, 170, 212, 147, 90, 74, 167, 190,
+       107, 64, 61, 182, 161, 206, 198, 167, 45, 167, 99, 94, 102, 231,
+       173, 197, 64, 79, 162, 233, 210, 114, 254, 139, 38, 180, 52, 91,
+       68, 141, 140, 179, 136, 36, 111, 178, 166, 31, 175, 21, 213, 103,
+       75, 90, 73, 198, 123, 158, 26, 200, 219, 96, 205, 191, 255, 64,
+       136, 243, 162, 242, 222, 205, 216, 246, 177, 42, 94, 239, 181,
+       130, 191, 155, 111, 107, 59, 83, 243, 247, 93, 227, 120, 71, 9,
+       239, 186, 255, 199, 149, 182, 247, 168, 0, 198, 73, 138, 161, 175,
+       129, 54, 132, 142, 232, 158, 39, 140, 154, 99, 74, 224, 101, 255,
+       215, 68, 1, 139, 224, 248, 49, 143, 159, 140, 127, 153, 3, 129, 4,
+       152, 180, 32, 34, 109, 59, 124, 150, 0, 16, 149, 163, 113, 75, 51,
+       9, 25, 173, 96, 69, 1, 74, 192, 139, 251, 44, 16, 224, 33, 136,
+       53, 89, 241, 76, 44, 127, 195, 24, 71, 228, 252, 42, 243, 248,
+       181, 36, 88, 244, 110, 106, 137, 35, 125, 184, 17, 220, 33, 56,
+       119, 251, 84, 37, 30, 123, 231, 160, 234, 67, 189, 200, 142, 242,
+       17, 163, 13, 207, 247, 142, 110, 249, 179, 211, 195, 85, 142, 224,
+       84, 65, 239, 175, 39, 191, 53, 241, 1, 156, 30, 123, 53, 191, 115,
+       19, 237, 9, 110, 84, 182, 16, 34, 112, 193, 34, 78, 24, 182, 173,
+       49, 63, 231, 255, 48, 80, 152, 200, 216, 15, 71, 147, 172, 11, 56,
+       153, 19, 136, 142, 85, 143, 161, 214, 198, 234, 98, 198, 85, 232,
+       87, 146, 1, 235, 49, 200, 49, 10, 90, 144, 15, 133, 117, 203, 91,
+       69, 189, 98, 16, 60, 51, 13, 88, 86, 231, 189, 14, 179, 227, 102,
+       45, 183, 197, 197, 212, 167, 201, 6, 99, 234, 138, 62, 180, 41,
+       93, 117, 9, 225, 206, 60, 115, 195, 88, 71, 228, 217, 74, 83, 248,
+       245, 100, 88, 248, 22, 107, 137, 34, 238, 184, 49, 124, 129, 56,
+       245, 251, 84, 100, 121, 88, 123, 44, 100, 94, 70, 190, 69, 72,
+       250, 106, 115, 56, 177, 224, 88, 236, 54, 111, 205, 186, 101, 173,
+       178, 109, 32, 16, 125, 186, 88, 13, 252, 205, 252, 246, 242, 42,
+       94, 190, 19, 162, 255, 187, 123, 127, 9, 209, 55, 247, 181, 238,
+       248, 84, 75, 239, 255, 255, 229, 132, 167, 247, 136, 3, 110, 176,
+       228, 210, 205, 253, 145, 234, 143, 247, 157, 27, 10, 252, 126, 15,
+       201, 147, 251, 17, 158, 107, 122, 212, 91, 90, 217, 255, 215, 77,
+       85, 214, 105, 209, 66, 142, 100, 6, 109, 61, 85, 74, 87, 71, 115,
+       65, 186, 68, 120, 128, 55, 45, 201, 190, 85, 223, 116, 62, 242,
+       128, 63, 158, 248, 8, 77, 72, 30, 63, 40, 248, 104, 8, 230, 21,
+       71, 20, 237, 195, 170, 78, 96, 4, 106, 222, 6, 133, 47, 113, 198,
+       243, 210, 65, 154, 131, 45, 4, 171, 94, 103, 93, 45, 240, 172,
+       114, 221, 74, 246, 98, 104, 120, 181, 239, 74, 98, 190, 142, 229,
+       237, 103, 255, 6, 122, 210, 131, 95, 252, 120, 237, 116, 159, 220,
+       118, 236, 25, 86, 164, 89, 183, 57, 173, 231, 105, 76, 19, 223,
+       251, 197, 99, 124, 106, 74, 160, 234, 211, 85, 127, 248, 250, 206,
+       27, 44, 218, 222, 115, 177, 158, 82, 184, 179, 149, 102, 141, 111,
+       233, 75, 146, 151, 112, 229, 82, 122, 252, 91, 45, 239, 255, 5,
+       85, 234, 175, 74, 19, 98, 145, 173, 218, 237, 244, 152, 107, 139,
+       85, 153, 27, 140, 254, 124, 234, 205, 147, 251, 129, 146, 75, 250,
+       209, 31, 95, 218, 255, 149, 76, 181, 246, 98, 177, 186, 222, 251,
+       212, 152, 109, 139, 89, 157, 171, 60, 254, 126, 114, 238, 187,
+       255, 145, 214, 11, 178, 209, 91, 61, 158, 235, 149, 6, 175, 223,
+       147, 135, 108, 57, 188, 151, 156, 239, 220, 85, 149, 151, 225, 8,
+       62, 1, 207, 3, 155, 165, 246, 237, 95, 157, 106, 91, 222, 215, 93,
+       12, 221, 223, 26, 175, 55, 233, 159, 227, 155, 203, 151, 21, 216,
+       179, 141, 175, 32, 4, 239, 27, 139, 145, 58, 169, 0, 255, 233,
+       212, 138, 247, 183, 77, 165, 226, 60, 222, 152, 250, 252, 3, 86,
+       233, 82, 190, 249, 45, 115, 121, 109, 24, 217, 218, 133, 83, 78,
+       115, 72, 40, 250, 199, 245, 63, 217, 123, 254, 139, 43, 254, 121,
+       248, 117, 223, 216, 119, 205, 232, 60, 235, 175, 29, 182, 37, 142,
+       177, 151, 21, 231, 60, 36, 223, 127, 217, 45, 243, 86, 156, 93,
+       95, 171, 78, 109, 77, 102, 150, 255, 186, 77, 78, 126, 162, 249,
+       79, 183, 224, 126, 240, 183, 239, 193, 180, 101, 255, 103, 111,
+       170, 128, 119, 181, 116, 249, 87, 63, 105, 135, 178, 102, 111, 50,
+       56, 224, 95, 230, 221, 39, 147, 96, 54, 253, 21, 255, 145, 144,
+       173, 238, 252, 45, 175, 128, 45, 227, 1, 113, 56, 94, 122, 236,
+       116, 50, 86, 115, 81, 202, 252, 239, 19, 13, 163, 209, 94, 184,
+       134, 42, 233, 178, 68, 142, 242, 237, 160, 169, 127, 248, 122, 19,
+       206, 80, 18, 168, 234, 36, 56, 218, 174, 24, 128, 106, 156, 215,
+       97, 218, 230, 145, 255, 241, 3, 3, 146, 208, 149, 129, 43, 254,
+       152, 81, 41, 49, 182, 100, 189, 242, 29, 253, 216, 202, 223, 243,
+       177, 27, 142, 221, 125, 143, 201, 153, 215, 17, 43, 103, 122, 242,
+       155, 219, 223, 127, 209, 89, 93, 230, 163, 247, 117, 91, 119, 219,
+       164, 239, 89, 122, 112, 254, 40, 28, 188, 181, 255, 26, 150, 97,
+       231, 254, 44, 255, 38, 26, 20, 226, 95, 156, 210, 157, 66, 145,
+       186, 190, 236, 228, 188, 71, 175, 81, 88, 3, 188, 254, 122, 106,
+       231, 27, 59, 145, 23, 11, 146, 193, 253, 55, 222, 11, 156, 88,
+       169, 154, 154, 253, 120, 224, 118, 137, 248, 231, 79, 104, 48,
+       170, 191, 24, 148, 33, 174, 185, 151, 209, 239, 58, 68, 223, 190,
+       217, 175, 231, 127, 140, 201, 31, 28, 25, 238, 231, 167, 22, 123,
+       80, 101, 228, 95, 134, 89, 79, 183, 226, 126, 236, 191, 254, 136,
+       176, 61, 232, 247, 237, 163, 129, 39, 167, 112, 96, 107, 48, 244,
+       238, 61, 159, 217, 25, 75, 253, 181, 173, 206, 29, 150, 60, 158,
+       181, 245, 29, 158, 106, 243, 213, 207, 217, 177, 250, 86, 142, 86,
+       119, 242, 242, 49, 244, 125, 215, 152, 114, 27, 235, 180, 123, 44,
+       29, 182, 41, 207, 181, 215, 133, 172, 111, 160, 223, 147, 94, 218,
+       251, 71, 12, 39, 255, 5, 193, 109, 105, 86, 66, 251, 184, 70, 228,
+       94, 130, 81, 77, 50, 96, 126, 221, 51, 253, 192, 184, 61, 28, 109,
+       41, 165, 196, 117, 170, 116, 224, 58, 204, 91, 238, 101, 67, 111,
+       228, 117, 132, 254, 162, 43, 31, 54, 81, 250, 249, 151, 227, 76,
+       187, 33, 237, 178, 217, 134, 131, 103, 154, 116, 206, 135, 205,
+       229, 151, 180, 54, 239, 174, 31, 227, 91, 210, 249, 108, 157, 101,
+       95, 239, 55, 239, 255, 220, 125, 255, 172, 94, 223, 196, 148, 255,
+       209, 116, 61, 25, 250, 108, 212, 38, 206, 80, 68, 232, 250, 199,
+       83, 233, 53, 192, 92, 236, 23, 110, 137, 178, 17, 136, 115, 237,
+       37, 4, 249, 251, 120, 16, 107, 149, 240, 244, 245, 30, 252, 191,
+       155, 219, 60, 187, 172, 63, 180, 100, 215, 179, 183, 165, 242,
+       104, 34, 223, 111, 222, 223, 174, 150, 252, 209, 255, 235, 87,
+       235, 206, 244, 182, 239, 87, 113, 206, 95, 246, 112, 228, 183,
+       100, 124, 238, 54, 239, 205, 182, 164, 234, 52, 44, 170, 136, 7,
+       255, 240, 253, 199, 204, 197, 191, 242, 242, 110, 190, 23, 211,
+       90, 215, 253, 110, 153, 237, 127, 239, 55, 143, 247, 220, 95, 255,
+       62, 126, 223, 196, 190, 245, 177, 92, 93, 113, 152, 230, 169, 29,
+       86, 152, 235, 250, 173, 12, 159, 210, 75, 26, 129, 197, 236, 82,
+       92, 99, 218, 0, 251, 217, 69, 63, 138, 115, 139, 18, 31, 209, 245,
+       247, 171, 158, 93, 189, 255, 221, 22, 229, 223, 255, 222, 229,
+       182, 117, 189, 255, 222, 200, 255, 245, 235, 251, 239, 214, 38,
+       182, 133, 119, 250, 26, 226, 85, 77, 221, 217, 39, 217, 239, 246,
+       159, 42, 44, 86, 47, 236, 183, 245, 133, 204, 254, 246, 193, 23,
+       122, 216, 147, 71, 12, 86, 95, 170, 58, 232, 21, 103, 249, 248,
+       67, 187, 231, 180, 191, 168, 140, 86, 62, 143, 191, 215, 149, 190,
+       222, 244, 194, 71, 95, 152, 179, 231, 204, 94, 223, 158, 56, 240,
+       224, 43, 119, 153, 91, 31, 254, 148, 191, 14, 156, 119, 44, 175,
+       153, 223, 149, 174, 111, 49, 210, 219, 91, 155, 191, 247, 100, 39,
+       119, 162, 243, 124, 248, 237, 149, 157, 237, 155, 186, 180, 43,
+       236, 223, 253, 171, 223, 177, 247, 181, 194, 99, 106, 216, 27, 26,
+       207, 190, 87, 188, 43, 191, 165, 149, 133, 211, 140, 47, 69, 191,
+       23, 191, 11, 20, 208, 115, 88, 79, 17, 70, 123, 60, 50, 88, 123,
+       16, 109, 26, 213, 116, 152, 216, 208, 120, 107, 160, 246, 255,
+       125, 19, 88, 41, 95, 179, 99, 145, 205, 251, 92, 252, 215, 93,
+       251, 173, 52, 208, 207, 215, 79, 254, 221, 79, 150, 164, 194, 134,
+       106, 148, 126, 252, 125, 244, 217, 123, 185, 91, 252, 61, 124,
+       255, 62, 123, 199, 147, 247, 133, 183, 79, 162, 199, 219, 127,
+       250, 218, 222, 68, 167, 87, 250, 189, 190, 244, 175, 221, 181,
+       119, 185, 223, 182, 63, 44, 188, 102, 11, 174, 51, 253, 1, 246,
+       233, 178, 233, 251, 91, 94, 179, 195, 76, 135, 255, 212, 197, 108,
+       39, 188, 106, 70, 188, 240, 230, 143, 149, 215, 109, 26, 83, 19,
+       70, 109, 103, 124, 229, 221, 46, 235, 227, 101, 21, 36, 243, 214,
+       114, 60, 87, 120, 101, 134, 15, 87, 252, 83, 166, 124, 206, 83,
+       97, 139, 16, 62, 220, 132, 110, 200, 178, 93, 56, 234, 207, 101,
+       52, 127, 251, 202, 176, 254, 60, 174, 176, 141, 253, 153, 67, 155,
+       255, 148, 25, 142, 188, 118, 91, 205, 183, 253, 21, 62, 79, 242,
+       208, 219, 211, 223, 255, 130, 76, 151, 86, 198, 150, 126, 210,
+       124, 168, 184, 33, 185, 27, 63, 178, 204, 254, 188, 115, 239, 51,
+       127, 1, 182, 9, 138, 247, 222, 191, 218, 235, 156, 137, 169, 133,
+       139, 61, 183, 244, 172, 173, 188, 87, 157, 254, 184, 121, 188,
+       191, 113, 139, 175, 63, 95, 13, 225, 233, 162, 200, 171, 217, 126,
+       186, 134, 232, 131, 249, 7, 161, 24, 216, 149, 245, 64, 67, 23,
+       57, 205, 16, 130, 178, 124, 228, 201, 10, 18, 152, 31, 10, 122,
+       215, 139, 157, 148, 127, 154, 8, 184, 134, 33, 12, 79, 109, 4, 42,
+       97, 50, 52, 160, 122, 226, 147, 1, 145, 81, 88, 172, 6, 174, 9,
+       176, 69, 12, 196, 170, 224, 0, 109, 171, 112, 184, 61, 150, 213,
+       229, 54, 15, 78, 187, 22, 170, 218, 110, 95, 117, 128, 96, 55,
+       220, 125, 44, 249, 240, 73, 31, 252, 174, 101, 148, 239, 234, 16,
+       49, 222, 188, 189, 248, 137, 244, 24, 203, 155, 251, 129, 25, 158,
+       255, 72, 107, 205, 243, 253, 145, 62, 79, 250, 211, 219, 243, 223,
+       127, 146, 68, 167, 115, 176, 33, 99, 41, 82, 15, 64, 121, 85, 32,
+       241, 107, 19, 1, 164, 21, 120, 136, 6, 236, 168, 186, 69, 29, 117,
+       136, 32, 112, 121, 136, 114, 178, 90, 189, 181, 250, 235, 237, 20,
+       207, 191, 91, 168, 57, 190, 255, 96, 123, 167, 243, 255, 16, 19,
+       75, 186, 241, 219, 211, 94, 123, 146, 68, 135, 251, 187, 22, 102,
+       172, 84, 38, 207, 121, 149, 70, 215, 151, 80, 207, 51, 77, 88,
+       160, 27, 175, 232, 151, 20, 206, 240, 38, 202, 128, 63, 238, 112,
+       82, 74, 189, 151, 250, 171, 237, 52, 207, 191, 123, 160, 24, 190,
+       255, 96, 251, 167, 115, 251, 17, 51, 73, 154, 243, 153, 210, 94,
+       123, 210, 64, 135, 59, 184, 69, 64, 235, 86, 171, 227, 85, 69, 5,
+       125, 22, 19, 9, 180, 5, 104, 136, 6, 254, 11, 190, 85, 159, 102,
+       201, 160, 64, 127, 139, 208, 160, 247, 172, 132, 155, 139, 249,
+       15, 174, 159, 246, 136, 153, 207, 230, 79, 191, 3, 199, 120, 215,
+       62, 79, 255, 115, 189, 18, 93, 127, 128, 125, 131, 108, 229, 103,
+       98, 74, 252, 31, 238, 216, 106, 200, 185, 76, 82, 64, 221, 188,
+       31, 76, 70, 126, 199, 39, 140, 106, 62, 12, 37, 252, 205, 187,
+       122, 133, 159, 6, 230, 133, 195, 38, 109, 83, 53, 71, 215, 215,
+       73, 47, 186, 79, 124, 135, 63, 173, 184, 215, 5, 200, 20, 34, 218,
+       132, 175, 244, 177, 80, 69, 226, 154, 251, 44, 172, 40, 144, 238,
+       25, 21, 100, 188, 195, 232, 110, 166, 41, 110, 92, 147, 1, 138,
+       241, 204, 221, 58, 200, 152, 131, 169, 161, 1, 66, 159, 187, 36,
+       136, 104, 144, 238, 17, 119, 208, 189, 131, 248, 110, 98, 41, 106,
+       94, 3, 148, 15, 241, 132, 249, 114, 64, 148, 147, 169, 128, 5, 73,
+       95, 187, 238, 136, 232, 132, 236, 17, 83, 208, 157, 131, 248, 203,
+       98, 43, 42, 222, 83, 224, 14, 240, 132, 145, 250, 72, 20, 155,
+       169, 160, 193, 188, 157, 183, 172, 239, 101, 191, 255, 251, 42,
+       92, 246, 182, 94, 59, 129, 70, 124, 28, 183, 124, 251, 51, 173,
+       186, 117, 118, 128, 88, 211, 125, 69, 227, 31, 186, 236, 132, 188,
+       196, 142, 24, 17, 96, 156, 211, 249, 235, 166, 3, 127, 95, 67, 1,
+       138, 241, 132, 153, 110, 236, 28, 211, 169, 161, 5, 73, 72, 187,
+       68, 169, 233, 68, 236, 17, 115, 130, 153, 131, 232, 72, 106, 10,
+       2, 218, 2, 176, 70, 240, 196, 129, 178, 64, 28, 155, 233, 128, 1,
+       9, 157, 159, 232, 156, 161, 6, 174, 149, 66, 16, 180, 166, 66,
+       238, 196, 39, 234, 20, 18, 216, 227, 96, 13, 48, 94, 66, 144, 0,
+       133, 236, 131, 128, 151, 150, 203, 173, 161, 71, 174, 23, 131,
+       153, 204, 166, 108, 206, 162, 3, 106, 5, 22, 5, 50, 83, 133, 18,
+       90, 82, 128, 0, 133, 228, 26, 46, 156, 181, 203, 63, 60, 67, 179,
+       183, 163, 153, 13, 46, 67, 155, 173, 183, 225, 129, 60, 222, 83,
+       224, 215, 195, 216, 35, 163, 100, 143, 154, 196, 184, 188, 179,
+       172, 173, 81, 151, 170, 127, 6, 61, 182, 49, 74, 27, 129, 70, 125,
+       29, 122, 76, 219, 49, 205, 211, 117, 252, 136, 72, 147, 91, 135,
+       128, 158, 144, 202, 161, 185, 207, 174, 19, 129, 145, 204, 214,
+       110, 14, 239, 19, 106, 149, 23, 7, 10, 82, 29, 18, 223, 78, 144,
+       80, 163, 212, 150, 244, 104, 147, 150, 161, 226, 207, 87, 115, 81,
+       215, 145, 141, 121, 73, 121, 10, 19, 159, 50, 244, 157, 242, 77,
+       4, 159, 228, 189, 89, 245, 150, 182, 28, 53, 90, 9, 230, 25, 64,
+       148, 150, 165, 144, 211, 87, 37, 91, 76, 112, 201, 242, 40, 199,
+       122, 60, 131, 227, 202, 27, 146, 33, 36, 250, 210, 182, 218, 225,
+       162, 120, 52, 143, 59, 179, 6, 242, 140, 54, 200, 123, 39, 87,
+       253, 16, 55, 221, 133, 66, 154, 227, 126, 199, 164, 64, 175, 23,
+       210, 254, 228, 147, 162, 32, 189, 159, 47, 119, 22, 247, 141, 47,
+       218, 79, 39, 87, 253, 149, 182, 92, 143, 227, 236, 34, 222, 196,
+       175, 212, 133, 93, 5, 105, 19, 187, 228, 140, 172, 196, 236, 24,
+       121, 66, 156, 195, 233, 202, 232, 34, 10, 222, 82, 48, 138, 240,
+       20, 144, 170, 104, 144, 27, 161, 160, 192, 99, 29, 147, 41, 237,
+       33, 4, 238, 61, 11, 16, 172, 194, 64, 194, 160, 35, 106, 210, 3,
+       13, 138, 113, 133, 16, 26, 105, 16, 3, 137, 8, 128, 153, 158, 155,
+       235, 236, 177, 143, 142, 29, 72, 54, 188, 210, 106, 74, 163, 83,
+       234, 16, 19, 73, 154, 225, 12, 48, 90, 74, 152, 11, 169, 155, 253,
+       65, 219, 78, 172, 9, 199, 216, 102, 178, 191, 64, 83, 225, 249,
+       62, 57, 68, 108, 110, 201, 101, 191, 34, 120, 136, 101, 28, 91,
+       187, 194, 32, 254, 183, 249, 238, 251, 52, 94, 249, 17, 202, 61,
+       125, 95, 255, 237, 51, 159, 215, 149, 99, 248, 67, 170, 174, 123,
+       223, 45, 190, 255, 246, 166, 115, 197, 75, 26, 154, 232, 173, 166,
+       196, 172, 25, 233, 88, 156, 211, 105, 218, 202, 35, 74, 90, 82, 3,
+       202, 112, 180, 144, 10, 104, 24, 91, 171, 129, 117, 129, 155, 101,
+       160, 78, 103, 41, 104, 75, 107, 16, 215, 118, 8, 114, 144, 30,
+       120, 40, 17, 152, 241, 5, 233, 175, 96, 80, 200, 34, 195, 32, 237,
+       244, 213, 127, 140, 47, 198, 155, 82, 243, 185, 223, 83, 121, 89,
+       139, 95, 198, 108, 62, 185, 102, 223, 146, 110, 238, 245, 116,
+       255, 249, 208, 16, 217, 172, 135, 190, 185, 248, 68, 175, 187, 83,
+       170, 153, 239, 246, 66, 219, 131, 231, 120, 20, 63, 77, 255, 179,
+       187, 255, 87, 91, 130, 84, 195, 76, 254, 151, 185, 102, 186, 54,
+       94, 250, 155, 234, 157, 237, 94, 125, 191, 50, 151, 247, 221, 103,
+       252, 67, 40, 191, 251, 223, 109, 190, 159, 247, 22, 119, 231, 207,
+       249, 198, 246, 36, 222, 173, 153, 154, 57, 251, 220, 255, 253, 34,
+       151, 211, 21, 231, 240, 39, 10, 235, 42, 28, 175, 190, 213, 243,
+       195, 33, 199, 207, 123, 226, 236, 37, 190, 236, 137, 154, 57, 74,
+       220, 255, 125, 2, 191, 243, 23, 239, 240, 39, 10, 242, 60, 28,
+       175, 190, 156, 115, 211, 33, 254, 246, 245, 126, 178, 23, 158,
+       188, 155, 202, 157, 253, 127, 125, 191, 37, 151, 115, 149, 167,
+       252, 71, 46, 239, 251, 95, 109, 190, 158, 246, 22, 119, 212, 104,
+       156, 120, 153, 173, 81, 207, 183, 21, 160, 25, 151, 199, 65, 24,
+       129, 177, 104, 80, 42, 69, 218, 50, 251, 199, 21, 93, 240, 48, 38,
+       42, 246, 213, 19, 238, 237, 36, 214, 236, 137, 154, 185, 107, 94,
+       255, 109, 19, 253, 211, 23, 227, 120, 39, 26, 250, 185, 148, 143,
+       190, 209, 123, 225, 51, 230, 255, 185, 138, 236, 225, 158, 205,
+       143, 183, 153, 251, 224, 236, 109, 66, 207, 211, 235, 211, 82,
+       103, 202, 243, 60, 20, 143, 187, 149, 91, 149, 155, 231, 126, 200,
+       87, 236, 20, 239, 152, 59, 186, 53, 244, 89, 251, 221, 190, 31,
+       93, 117, 238, 241, 116, 206, 226, 46, 252, 229, 172, 207, 243, 74,
+       165, 245, 221, 157, 150, 236, 96, 207, 252, 82, 250, 189, 126,
+       115, 103, 219, 37, 89, 194, 38, 238, 121, 102, 239, 191, 248, 134,
+       239, 124, 157, 251, 242, 113, 109, 254, 237, 159, 236, 63, 79,
+       255, 86, 247, 253, 220, 243, 228, 219, 255, 95, 206, 238, 46, 249,
+       102, 255, 63, 236, 119, 117, 188, 158, 255, 246, 244, 246, 213,
+       249, 174, 223, 103, 150, 232, 153, 198, 184, 171, 78, 252, 109,
+       18, 255, 243, 197, 227, 124, 103, 24, 238, 185, 22, 143, 63, 213,
+       127, 119, 86, 246, 245, 234, 142, 223, 115, 150, 236, 155, 230,
+       185, 175, 74, 252, 47, 18, 255, 247, 197, 231, 108, 99, 124, 255,
+       187, 86, 207, 63, 117, 126, 38, 86, 247, 95, 245, 70, 234, 62, 79,
+       188, 105, 250, 191, 236, 122, 118, 157, 247, 23, 247, 253, 126,
+       233, 194, 239, 106, 186, 58, 101, 150, 142, 247, 131, 117, 157,
+       239, 93, 222, 142, 119, 79, 248, 208, 250, 149, 70, 249, 227, 251,
+       39, 127, 226, 92, 238, 233, 71, 238, 236, 250, 203, 239, 188, 63,
+       243, 171, 245, 159, 223, 229, 215, 176, 62, 79, 187, 53, 234, 95,
+       244, 255, 103, 153, 231, 23, 238, 125, 110, 249, 212, 237, 175,
+       168, 254, 109, 148, 174, 247, 128, 117, 173, 205, 251, 119, 244,
+       38, 238, 188, 84, 2, 127, 80, 241, 123, 189, 97, 95, 74, 51, 110,
+       242, 244, 93, 175, 111, 239, 231, 68, 197, 251, 240, 168, 148,
+       237, 178, 243, 183, 235, 118, 231, 253, 163, 123, 24, 207, 251,
+       105, 25, 179, 251, 85, 82, 56, 252, 8, 186, 251, 222, 87, 99, 226,
+       115, 199, 139, 157, 102, 221, 214, 170, 87, 31, 248, 214, 246,
+       181, 86, 93, 115, 235, 47, 127, 196, 126, 238, 237, 71, 47, 186,
+       242, 203, 231, 188, 174, 251, 40, 101, 117, 223, 237, 39, 158, 75,
+       71, 188, 118, 232, 191, 239, 83, 101, 155, 114, 114, 198, 108,
+       111, 217, 235, 253, 46, 249, 231, 101, 212, 173, 251, 244, 115,
+       30, 189, 254, 183, 175, 217, 119, 236, 223, 255, 31, 63, 111, 248,
+       111, 10, 163, 103, 253, 87, 54, 121, 190, 179, 235, 223, 93, 243,
+       182, 127, 157, 95, 134, 63, 222, 175, 170, 63, 182, 216, 191, 234,
+       211, 253, 196, 250, 231, 11, 239, 87, 255, 19, 181, 231, 139, 242,
+       190, 246, 111, 187, 204, 249, 171, 151, 239, 253, 238, 191, 189,
+       217, 87, 237, 159, 252, 29, 47, 110, 248, 91, 130, 147, 111, 253,
+       87, 102, 65, 186, 191, 239, 223, 205, 255, 46, 63, 220, 215, 118,
+       183, 140, 194, 168, 113, 78, 136, 19, 251, 157, 184, 211, 102,
+       200, 255, 93, 212, 252, 242, 63, 67, 235, 147, 186, 211, 239, 253,
+       142, 251, 158, 53, 61, 69, 109, 101, 22, 75, 79, 120, 85, 224,
+       255, 206, 83, 65, 153, 48, 122, 228, 94, 106, 233, 178, 125, 14,
+       246, 239, 161, 148, 111, 187, 82, 32, 45, 240, 249, 115, 229, 93,
+       166, 200, 90, 239, 117, 26, 131, 220, 252, 184, 153, 24, 130, 18,
+       215, 54, 252, 146, 15, 205, 53, 47, 209, 57, 221, 228, 185, 24,
+       188, 253, 133, 244, 241, 87, 117, 202, 246, 18, 26, 63, 48, 107,
+       236, 178, 55, 24, 185, 189, 51, 194, 83, 235, 242, 64, 211, 104,
+       228, 251, 214, 170, 42, 186, 173, 176, 216, 207, 187, 23, 180,
+       191, 14, 202, 126, 13, 171, 131, 199, 149, 62, 47, 142, 247, 218,
+       81, 154, 239, 215, 5, 239, 198, 28, 228, 186, 181, 52, 75, 127,
+       254, 54, 166, 82, 179, 223, 111, 81, 89, 95, 221, 61, 41, 104,
+       214, 203, 142, 204, 199, 255, 173, 164, 248, 5, 162, 64, 88, 154,
+       204, 13, 68, 146, 132, 142, 5, 166, 3, 194, 249, 103, 74, 192,
+       116, 171, 80, 0, 33, 211, 224, 83, 183, 23, 31, 146, 187, 108, 10,
+       121, 217, 17, 174, 29, 84, 70, 109, 195, 200, 136, 74, 191, 214,
+       112, 242, 192, 224, 188, 67, 77, 11, 242, 177, 177, 229, 174, 59,
+       54, 58, 180, 106, 153, 156, 245, 117, 37, 126, 125, 63, 119, 251,
+       126, 112, 123, 55, 132, 245, 87, 222, 181, 8, 185, 216, 113, 171,
+       79, 251, 117, 130, 43, 228, 196, 63, 99, 191, 19, 132, 117, 173,
+       163, 55, 57, 173, 152, 126, 174, 162, 194, 197, 214, 171, 14, 45,
+       179, 171, 208, 207, 188, 20, 10, 250, 10, 76, 137, 29, 216, 156,
+       110, 245, 52, 188, 92, 55, 245, 91, 94, 179, 187, 189, 146, 99,
+       231, 247, 253, 129, 188, 221, 181, 175, 227, 251, 224, 193, 38,
+       196, 156, 123, 154, 190, 14, 191, 178, 162, 188, 167, 62, 31, 90,
+       181, 173, 238, 38, 65, 167, 47, 189, 149, 62, 216, 131, 127, 232,
+       166, 190, 195, 136, 64, 171, 27, 176, 143, 92, 172, 164, 51, 220,
+       39, 13, 170, 186, 99, 111, 43, 48, 147, 234, 227, 236, 161, 124,
+       169, 65, 204, 178, 211, 230, 145, 113, 232, 232, 11, 238, 30, 246,
+       21, 203, 125, 116, 135, 251, 255, 166, 29, 106, 190, 71, 219, 161,
+       102, 232, 20, 52, 205, 179, 226, 79, 219, 85, 19, 130, 116, 206,
+       223, 202, 190, 151, 181, 243, 249, 116, 183, 191, 187, 74, 120,
+       46, 231, 64, 159, 167, 255, 229, 1, 50, 220, 131, 247, 175, 214,
+       85, 67, 162, 196, 140, 47, 74, 178, 211, 176, 43, 160, 56, 159,
+       171, 25, 24, 229, 173, 206, 97, 194, 167, 59, 253, 149, 6, 73,
+       130, 209, 140, 213, 62, 170, 132, 132, 5, 27, 100, 41, 184, 78,
+       188, 124, 147, 1, 202, 133, 191, 0, 242, 249, 71, 2, 216, 118,
+       234, 80, 16, 41, 210, 32, 75, 173, 39, 25, 192, 107, 77, 10, 252,
+       75, 222, 188, 236, 72, 84, 237, 216, 158, 244, 59, 79, 43, 35, 91,
+       235, 197, 36, 99, 108, 103, 130, 10, 250, 227, 103, 61, 253, 249,
+       107, 138, 82, 155, 151, 151, 162, 168, 41, 134, 173, 17, 202, 244,
+       236, 34, 132, 78, 39, 231, 109, 217, 145, 216, 133, 224, 140, 182,
+       222, 66, 136, 81, 161, 44, 108, 176, 57, 98, 201, 93, 211, 73,
+       107, 37, 189, 8, 26, 221, 76, 48, 153, 152, 196, 18, 30, 34, 250,
+       17, 91, 221, 1, 127, 195, 10, 198, 226, 236, 101, 113, 70, 237,
+       105, 231, 204, 234, 226, 184, 8, 154, 252, 221, 178, 152, 202, 74,
+       106, 65, 35, 234, 98, 117, 157, 5, 60, 66, 127, 71, 224, 94, 204,
+       148, 94, 155, 102, 23, 168, 162, 183, 143, 9, 110, 119, 8, 211,
+       161, 119, 233, 98, 56, 67, 219, 111, 249, 167, 77, 23, 162, 115,
+       172, 34, 173, 101, 49, 162, 237, 93, 239, 250, 76, 234, 153, 90,
+       223, 232, 125, 164, 217, 75, 94, 111, 241, 38, 104, 186, 245, 221,
+       175, 188, 86, 127, 209, 224, 157, 174, 148, 177, 173, 55, 88, 202,
+       190, 191, 177, 113, 143, 122, 74, 139, 231, 75, 204, 179, 126, 69,
+       11, 162, 154, 211, 127, 39, 162, 117, 43, 131, 168, 161, 49, 203,
+       221, 205, 80, 207, 207, 113, 173, 24, 150, 217, 108, 228, 201, 10,
+       91, 16, 50, 43, 122, 149, 111, 24, 21, 127, 146, 8, 212, 234, 99,
+       61, 129, 138, 244, 228, 66, 206, 27, 193, 72, 73, 52, 242, 65,
+       112, 209, 234, 18, 20, 3, 26, 208, 171, 61, 60, 133, 170, 156, 91,
+       114, 140, 131, 144, 183, 208, 239, 149, 184, 107, 202, 211, 16,
+       22, 156, 184, 116, 171, 239, 49, 51, 149, 183, 109, 50, 208, 15,
+       26, 223, 238, 221, 8, 49, 220, 1, 80, 143, 155, 134, 174, 172, 7,
+       60, 83, 195, 214, 244, 35, 56, 73, 99, 46, 58, 141, 177, 156, 85,
+       101, 37, 38, 218, 64, 156, 80, 177, 24, 209, 80, 127, 180, 38, 2,
+       125, 48, 160, 206, 214, 167, 119, 119, 162, 67, 118, 229, 125,
+       110, 105, 197, 165, 12, 208, 235, 106, 144, 45, 168, 49, 113, 238,
+       174, 165, 178, 205, 249, 84, 143, 223, 215, 146, 27, 239, 237, 95,
+       139, 137, 235, 233, 17, 126, 111, 251, 179, 255, 83, 221, 123,
+       134, 92, 212, 90, 135, 9, 15, 155, 132, 175, 172, 195, 220, 83,
+       195, 23, 144, 40, 52, 73, 105, 171, 27, 157, 53, 184, 85, 228,
+       133, 50, 218, 64, 157, 73, 177, 144, 163, 169, 4, 95, 77, 156,
+       228, 239, 223, 17, 96, 16, 160, 250, 28, 183, 200, 10, 114, 72,
+       118, 110, 82, 245, 15, 58, 210, 75, 90, 8, 218, 142, 162, 196, 46,
+       248, 77, 253, 209, 70, 221, 22, 212, 18, 34, 216, 52, 105, 201,
+       186, 131, 1, 110, 254, 114, 149, 83, 91, 210, 107, 21, 8, 116,
+       238, 201, 156, 149, 243, 161, 238, 20, 167, 62, 115, 162, 148,
+       159, 55, 64, 207, 135, 86, 232, 16, 59, 220, 243, 162, 138, 243,
+       86, 82, 138, 208, 129, 88, 183, 85, 8, 171, 189, 177, 78, 220, 23,
+       66, 221, 214, 139, 199, 251, 228, 89, 138, 159, 255, 207, 22, 92,
+       178, 178, 213, 142, 237, 62, 223, 184, 148, 38, 201, 11, 186, 242,
+       161, 170, 192, 28, 1, 89, 235, 116, 211, 40, 16, 238, 187, 19,
+       211, 18, 146, 8, 245, 52, 4, 170, 202, 157, 27, 161, 161, 214,
+       156, 148, 190, 139, 228, 20, 239, 159, 59, 224, 49, 204, 186, 36,
+       223, 205, 223, 191, 145, 63, 79, 218, 243, 153, 242, 222, 127,
+       152, 121, 169, 31, 35, 12, 7, 152, 77, 231, 128, 70, 204, 83, 248,
+       27, 144, 152, 53, 13, 201, 171, 18, 157, 45, 191, 82, 244, 17, 26,
+       218, 58, 217, 89, 251, 158, 68, 96, 130, 144, 69, 72, 160, 201,
+       186, 150, 128, 11, 228, 194, 105, 138, 49, 168, 2, 144, 6, 103,
+       142, 66, 157, 4, 143, 45, 128, 112, 47, 130, 3, 0, 235, 185, 197,
+       244, 237, 71, 31, 71, 76, 19, 60, 190, 54, 232, 249, 43, 51, 157,
+       150, 152, 54, 208, 71, 127, 218, 129, 149, 92, 245, 230, 149, 94,
+       94, 211, 226, 58, 253, 247, 189, 22, 127, 182, 93, 123, 175, 123,
+       103, 83, 14, 226, 116, 213, 47, 236, 102, 139, 103, 197, 191, 241,
+       233, 131, 46, 157, 242, 218, 247, 245, 190, 195, 95, 3, 92, 162,
+       40, 188, 245, 100, 239, 219, 147, 147, 150, 187, 60, 243, 127, 95,
+       158, 195, 151, 223, 181, 255, 38, 188, 165, 83, 149, 239, 209,
+       138, 127, 119, 161, 25, 210, 252, 108, 27, 145, 219, 121, 17, 178,
+       233, 59, 112, 73, 30, 85, 118, 208, 89, 212, 114, 97, 132, 253,
+       62, 92, 69, 147, 169, 206, 85, 169, 11, 112, 120, 62, 82, 201,
+       199, 107, 165, 150, 107, 111, 125, 125, 46, 223, 88, 209, 42, 245,
+       106, 164, 230, 115, 218, 237, 201, 117, 197, 249, 23, 176, 56, 6,
+       217, 108, 61, 217, 154, 66, 50, 98, 39, 34, 242, 55, 18, 86, 43,
+       211, 88, 230, 231, 87, 9, 215, 197, 150, 46, 170, 35, 236, 225,
+       11, 198, 221, 46, 21, 230, 54, 55, 122, 61, 149, 185, 21, 206,
+       173, 46, 15, 84, 173, 234, 145, 20, 55, 251, 105, 73, 222, 135,
+       191, 220, 70, 228, 120, 71, 16, 10, 119, 32, 127, 9, 19, 253, 215,
+       58, 125, 116, 124, 13, 175, 236, 253, 27, 227, 221, 53, 173, 232,
+       233, 210, 195, 155, 235, 82, 37, 253, 162, 17, 57, 150, 96, 123,
+       221, 22, 241, 30, 58, 109, 55, 124, 143, 175, 245, 245, 139, 230,
+       128, 133, 214, 126, 127, 166, 40, 181, 148, 252, 22, 119, 183,
+       217, 122, 191, 123, 39, 83, 46, 98, 228, 244, 47, 99, 102, 251,
+       118, 133, 244, 241, 229, 195, 10, 243, 250, 193, 227, 148, 185,
+       215, 174, 213, 94, 151, 140, 174, 126, 76, 103, 59, 179, 149, 151,
+       152, 182, 192, 79, 52, 158, 206, 143, 148, 165, 244, 52, 142, 232,
+       97, 216, 99, 155, 202, 22, 175, 188, 170, 17, 43, 199, 80, 89,
+       221, 6, 176, 28, 58, 205, 54, 90, 135, 165, 253, 241, 235, 110,
+       128, 124, 135, 113, 234, 255, 9, 87, 233, 89, 22, 177, 56, 78,
+       127, 105, 29, 223, 145, 206, 114, 58, 99, 104, 208, 243, 210, 69,
+       127, 242, 249, 230, 99, 28, 110, 167, 190, 148, 99, 87, 206, 22,
+       134, 200, 67, 247, 121, 33, 66, 121, 233, 77, 103, 104, 229, 25,
+       42, 225, 199, 47, 16, 176, 123, 53, 74, 158, 188, 182, 246, 223,
+       189, 182, 255, 255, 187, 123, 18, 110, 251, 108, 203, 167, 255,
+       251, 19, 182, 237, 155, 247, 63, 222, 95, 106, 219, 124, 225, 143,
+       188, 73, 253, 109, 109, 75, 83, 152, 67, 164, 52, 42, 91, 61, 65,
+       34, 94, 220, 165, 122, 72, 182, 225, 136, 79, 201, 101, 53, 119,
+       187, 68, 171, 95, 51, 178, 160, 178, 152, 184, 83, 56, 193, 91,
+       247, 141, 158, 98, 224, 182, 63, 159, 21, 151, 152, 160, 130, 188,
+       197, 46, 227, 172, 4, 175, 211, 156, 107, 167, 165, 158, 71, 79,
+       213, 22, 228, 138, 7, 215, 37, 81, 2, 62, 228, 121, 253, 104, 241,
+       57, 10, 249, 132, 175, 20, 164, 250, 53, 104, 12, 30, 183, 183,
+       164, 106, 241, 22, 252, 31, 187, 53, 255, 57, 27, 11, 139, 103,
+       111, 7, 176, 245, 73, 42, 196, 246, 112, 0, 196, 251, 133, 227,
+       203, 186, 40, 154, 123, 149, 186, 210, 139, 236, 20, 239, 44, 142,
+       215, 132, 174, 105, 211, 213, 199, 14, 190, 243, 30, 85, 139, 171,
+       31, 5, 27, 223, 60, 74, 113, 232, 131, 11, 95, 220, 19, 182, 180,
+       137, 15, 103, 65, 24, 159, 217, 197, 226, 72, 18, 120, 152, 243,
+       199, 101, 61, 243, 241, 6, 98, 212, 196, 129, 164, 142, 10, 79,
+       185, 50, 55, 131, 155, 215, 123, 88, 91, 115, 197, 125, 231, 104,
+       70, 201, 19, 240, 162, 237, 60, 60, 249, 144, 66, 188, 142, 140,
+       191, 173, 123, 86, 175, 23, 119, 244, 185, 239, 44, 10, 75, 201,
+       223, 236, 3, 61, 254, 73, 191, 234, 247, 215, 23, 180, 125, 156,
+       78, 200, 20, 122, 77, 50, 240, 49, 25, 124, 78, 119, 180, 124,
+       211, 171, 97, 114, 16, 143, 42, 224, 5, 37, 95, 86, 169, 34, 133,
+       54, 160, 45, 115, 172, 63, 113, 193, 242, 139, 171, 83, 44, 173,
+       121, 242, 153, 7, 132, 132, 62, 56, 23, 184, 51, 154, 96, 204, 44,
+       220, 35, 196, 231, 136, 199, 241, 127, 244, 96, 10, 93, 221, 82,
+       203, 207, 127, 157, 31, 10, 216, 254, 180, 217, 136, 158, 39, 222,
+       39, 126, 213, 186, 93, 1, 127, 63, 142, 222, 70, 15, 123, 226, 5,
+       103, 28, 173, 80, 104, 236, 114, 231, 9, 136, 215, 142, 174, 109,
+       119, 207, 197, 240, 181, 224, 86, 104, 174, 160, 79, 180, 115,
+       213, 155, 210, 170, 158, 135, 84, 183, 87, 93, 79, 87, 55, 40,
+       220, 190, 236, 117, 10, 182, 143, 199, 180, 180, 227, 83, 127,
+       186, 139, 31, 92, 189, 119, 57, 193, 113, 73, 34, 91, 197, 125,
+       109, 44, 127, 168, 91, 84, 172, 244, 62, 144, 70, 40, 201, 176,
+       101, 29, 55, 206, 32, 84, 115, 138, 196, 53, 106, 106, 227, 158,
+       105, 192, 25, 6, 187, 204, 198, 163, 45, 199, 103, 222, 230, 255,
+       189, 196, 74, 79, 162, 233, 147, 112, 218, 139, 6, 180, 54, 251,
+       71, 154, 244, 209, 54, 58, 169, 152, 127, 241, 83, 246, 205, 32,
+       149, 239, 55, 69, 174, 127, 145, 240, 45, 228, 12, 114, 123, 198,
+       175, 173, 17, 53, 69, 95, 236, 71, 166, 34, 175, 191, 68, 202,
+       158, 230, 209, 104, 217, 67, 95, 70, 44, 255, 193, 240, 237, 42,
+       108, 47, 239, 132, 205, 250, 185, 25, 30, 98, 227, 129, 55, 19,
+       168, 88, 23, 232, 86, 231, 137, 143, 243, 140, 126, 169, 151, 253,
+       137, 208, 5, 200, 142, 85, 175, 165, 167, 189, 61, 245, 216, 153,
+       22, 124, 203, 208, 52, 39, 253, 90, 226, 48, 126, 254, 36, 121,
+       227, 51, 168, 2, 117, 111, 2, 213, 147, 242, 82, 75, 16, 0, 173,
+       15, 86, 109, 40, 10, 152, 233, 31, 136, 142, 36, 140, 137, 215,
+       198, 75, 112, 150, 83, 73, 87, 90, 1, 255, 51, 233, 180, 9, 125,
+       16, 83, 5, 112, 68, 173, 169, 83, 184, 172, 79, 150, 178, 157,
+       175, 28, 211, 231, 73, 30, 73, 214, 109, 216, 26, 74, 251, 98,
+       237, 188, 167, 88, 194, 227, 230, 112, 139, 82, 235, 223, 36, 150,
+       189, 23, 93, 206, 86, 246, 189, 190, 183, 236, 214, 63, 183, 141,
+       165, 156, 117, 202, 70, 127, 186, 128, 30, 220, 53, 125, 143, 122,
+       235, 181, 114, 174, 57, 18, 61, 194, 82, 247, 189, 15, 147, 104,
+       54, 109, 55, 157, 161, 212, 53, 202, 68, 239, 127, 128, 173, 180,
+       35, 241, 43, 201, 96, 138, 205, 149, 238, 237, 27, 102, 77, 143,
+       104, 232, 126, 132, 89, 202, 179, 79, 210, 26, 126, 247, 62, 30,
+       141, 110, 31, 158, 216, 204, 47, 143, 69, 202, 253, 187, 106, 248,
+       77, 12, 93, 199, 74, 76, 190, 197, 88, 162, 134, 126, 190, 178,
+       109, 253, 30, 92, 129, 198, 183, 143, 120, 228, 236, 237, 252,
+       247, 244, 58, 127, 175, 51, 182, 126, 146, 123, 235, 95, 89, 59,
+       255, 55, 234, 122, 222, 139, 255, 126, 239, 245, 197, 175, 243,
+       232, 10, 118, 48, 173, 226, 157, 245, 216, 202, 143, 245, 157, 27,
+       14, 221, 127, 42, 137, 147, 255, 149, 30, 43, 250, 240, 155, 93,
+       155, 255, 215, 15, 85, 118, 18, 159, 23, 216, 155, 243, 16, 227,
+       141, 25, 154, 50, 12, 55, 32, 229, 231, 179, 142, 144, 58, 73, 35,
+       253, 155, 211, 218, 79, 146, 72, 173, 35, 52, 109, 17, 170, 185,
+       105, 22, 232, 0, 164, 168, 141, 231, 102, 107, 0, 223, 251, 4,
+       119, 14, 35, 88, 156, 185, 213, 13, 60, 176, 126, 7, 216, 34, 31,
+       254, 77, 230, 34, 173, 119, 205, 206, 126, 230, 112, 44, 183, 100,
+       94, 50, 38, 40, 177, 186, 103, 202, 102, 62, 224, 130, 221, 232,
+       116, 253, 27, 94, 229, 189, 46, 49, 190, 238, 220, 74, 90, 231,
+       237, 56, 183, 192, 255, 99, 191, 5, 229, 45, 7, 255, 182, 103,
+       250, 131, 93, 125, 57, 31, 153, 248, 24, 249, 131, 181, 16, 223,
+       63, 19, 100, 116, 157, 147, 96, 104, 231, 27, 158, 144, 55, 220,
+       82, 83, 135, 213, 26, 111, 184, 0, 171, 159, 226, 177, 184, 234,
+       221, 196, 155, 201, 139, 81, 153, 27, 28, 223, 126, 82, 207, 155,
+       123, 145, 19, 11, 218, 211, 221, 60, 154, 126, 29, 2, 163, 146,
+       11, 78, 233, 205, 118, 118, 255, 54, 93, 70, 126, 130, 185, 47,
+       183, 100, 126, 181, 151, 140, 192, 188, 101, 223, 103, 239, 186,
+       129, 119, 254, 92, 249, 31, 53, 107, 229, 182, 54, 127, 50, 32,
+       228, 223, 134, 221, 127, 147, 97, 54, 245, 31, 239, 177, 145, 53,
+       206, 255, 237, 175, 192, 167, 231, 49, 113, 54, 96, 188, 242, 13,
+       205, 208, 200, 207, 187, 177, 26, 142, 221, 109, 42, 201, 145,
+       127, 17, 14, 103, 90, 240, 155, 218, 215, 63, 208, 89, 92, 6, 67,
+       161, 154, 138, 221, 196, 249, 75, 139, 81, 169, 18, 188, 251, 124,
+       70, 232, 139, 123, 153, 19, 11, 154, 211, 29, 60, 158, 106, 152,
+       10, 227, 162, 10, 204, 114, 242, 117, 217, 248, 103, 77, 32, 120,
+       106, 173, 153, 52, 133, 238, 187, 151, 129, 198, 58, 0, 253, 254,
+       217, 154, 227, 31, 158, 73, 139, 3, 222, 102, 79, 38, 155, 174,
+       190, 77, 14, 94, 230, 224, 8, 182, 68, 118, 100, 46, 239, 228,
+       184, 101, 255, 38, 46, 226, 130, 127, 155, 121, 13, 188, 221, 105,
+       219, 149, 123, 247, 254, 84, 234, 255, 114, 243, 125, 175, 100,
+       121, 210, 151, 234, 249, 180, 105, 190, 127, 143, 167, 21, 243,
+       251, 212, 243, 188, 9, 103, 231, 151, 114, 111, 64, 197, 196, 255,
+       2, 123, 95, 183, 198, 122, 229, 63, 234, 73, 177, 37, 232, 243,
+       233, 131, 129, 39, 255, 116, 114, 238, 129, 192, 216, 221, 112,
+       202, 207, 19, 21, 221, 187, 8, 238, 254, 220, 89, 138, 163, 144,
+       26, 26, 206, 211, 30, 52, 154, 239, 183, 204, 254, 198, 135, 237,
+       237, 215, 244, 107, 239, 174, 95, 243, 95, 18, 243, 252, 221, 45,
+       123, 110, 55, 75, 251, 252, 111, 255, 45, 30, 223, 196, 237, 251,
+       213, 252, 234, 114, 190, 254, 109, 245, 153, 98, 155, 127, 149,
+       59, 172, 159, 54, 169, 207, 53, 255, 133, 163, 111, 114, 215, 151,
+       95, 218, 251, 6, 141, 47, 223, 194, 188, 252, 252, 125, 148, 153,
+       55, 27, 105, 116, 187, 188, 63, 150, 165, 134, 63, 183, 133, 162,
+       221, 161, 255, 59, 255, 218, 210, 22, 132, 207, 255, 235, 140, 68,
+       158, 239, 241, 252, 231, 159, 83, 85, 191, 40, 234, 190, 223, 107,
+       235, 179, 133, 55, 94, 78, 247, 22, 122, 218, 235, 159, 205, 248,
+       220, 207, 190, 197, 147, 203, 180, 236, 255, 159, 251, 90, 87,
+       104, 235, 86, 207, 109, 239, 179, 159, 247, 94, 223, 243, 62, 30,
+       223, 234, 191, 213, 184, 221, 125, 53, 145, 34, 169, 45, 86, 216,
+       235, 190, 169, 13, 159, 219, 73, 146, 129, 221, 236, 114, 78, 99,
+       218, 0, 251, 217, 5, 62, 200, 119, 131, 67, 95, 243, 116, 229, 46,
+       154, 88, 184, 239, 252, 182, 227, 207, 223, 222, 246, 182, 181,
+       253, 255, 206, 225, 175, 213, 138, 249, 239, 214, 39, 166, 80, 69,
+       98, 158, 236, 154, 253, 249, 153, 7, 159, 127, 157, 191, 172, 188,
+       126, 205, 207, 179, 191, 17, 182, 75, 122, 247, 15, 87, 154, 251,
+       150, 76, 149, 95, 162, 60, 236, 211, 219, 253, 184, 7, 159, 255,
+       151, 191, 140, 158, 86, 137, 239, 179, 223, 145, 182, 76, 112,
+       210, 95, 86, 154, 243, 151, 76, 149, 95, 162, 147, 120, 252, 108,
+       81, 217, 105, 155, 254, 181, 14, 236, 238, 126, 3, 222, 177, 247,
+       165, 197, 99, 250, 208, 219, 217, 203, 191, 29, 168, 95, 211, 66,
+       150, 182, 248, 111, 100, 185, 127, 187, 91, 184, 49, 156, 191, 52,
+       123, 231, 19, 255, 17, 178, 75, 162, 213, 217, 126, 122, 222, 148,
+       68, 167, 251, 231, 165, 133, 83, 201, 127, 101, 139, 159, 243, 3,
+       80, 200, 102, 92, 255, 193, 70, 106, 28, 177, 64, 251, 208, 13,
+       90, 213, 118, 130, 125, 208, 52, 45, 197, 241, 71, 215, 63, 239,
+       253, 86, 230, 111, 6, 89, 101, 185, 164, 61, 94, 34, 110, 241,
+       240, 61, 30, 111, 207, 37, 4, 107, 250, 212, 240, 198, 148, 127,
+       248, 124, 228, 185, 251, 187, 91, 176, 86, 156, 254, 60, 89, 247,
+       17, 127, 177, 179, 79, 178, 215, 221, 190, 251, 238, 156, 136, 33,
+       209, 194, 252, 183, 182, 11, 237, 181, 103, 191, 223, 146, 55,
+       188, 191, 100, 11, 167, 51, 255, 1, 99, 77, 178, 227, 153, 211,
+       94, 187, 136, 92, 165, 123, 71, 255, 141, 151, 240, 38, 175, 183,
+       62, 215, 79, 245, 244, 102, 155, 75, 87, 67, 59, 223, 247, 200,
+       63, 111, 172, 38, 255, 196, 140, 119, 177, 124, 131, 126, 183,
+       177, 173, 141, 61, 87, 191, 251, 146, 116, 188, 191, 225, 107,
+       167, 51, 127, 25, 115, 205, 50, 224, 141, 219, 126, 146, 136, 80,
+       129, 187, 222, 184, 181, 248, 169, 229, 25, 71, 155, 247, 128, 25,
+       140, 191, 96, 91, 197, 55, 249, 17, 51, 79, 250, 208, 153, 211,
+       223, 127, 144, 68, 133, 115, 116, 93, 125, 78, 222, 6, 222, 248,
+       193, 198, 185, 142, 83, 105, 189, 18, 94, 212, 69, 110, 233, 39,
+       125, 174, 115, 142, 133, 28, 125, 187, 118, 112, 216, 78, 191,
+       117, 10, 104, 49, 34, 184, 150, 163, 177, 239, 39, 0, 27, 167,
+       117, 236, 130, 96, 197, 163, 98, 211, 227, 122, 3, 96, 97, 39,
+       107, 90, 185, 181, 250, 139, 237, 16, 207, 175, 81, 168, 25, 174,
+       255, 96, 122, 207, 243, 255, 144, 26, 75, 250, 241, 219, 215, 94,
+       123, 146, 68, 167, 123, 65, 189, 151, 250, 137, 237, 53, 223, 191,
+       123, 170, 28, 190, 246, 72, 58, 161, 83, 250, 16, 51, 73, 186,
+       241, 153, 214, 95, 126, 128, 64, 135, 127, 165, 109, 75, 171, 212,
+       169, 102, 212, 109, 0, 121, 204, 179, 195, 233, 80, 122, 138, 6,
+       222, 95, 52, 28, 114, 164, 148, 162, 104, 244, 211, 195, 160, 180,
+       237, 236, 47, 223, 123, 198, 236, 115, 150, 233, 139, 99, 232, 95,
+       50, 121, 202, 64, 227, 124, 114, 254, 43, 62, 70, 133, 45, 245,
+       255, 222, 206, 204, 190, 189, 182, 168, 120, 20, 159, 219, 191,
+       145, 124, 238, 252, 201, 251, 135, 119, 236, 17, 182, 109, 170,
+       179, 136, 243, 125, 191, 144, 104, 141, 91, 5, 194, 223, 251, 172,
+       136, 105, 152, 238, 21, 67, 192, 149, 195, 249, 106, 227, 9, 46,
+       94, 3, 0, 47, 113, 196, 188, 50, 76, 144, 147, 33, 33, 204, 182,
+       189, 190, 168, 121, 16, 191, 250, 191, 147, 125, 238, 252, 200,
+       219, 135, 119, 236, 17, 182, 109, 171, 51, 216, 243, 125, 255,
+       144, 97, 141, 83, 134, 77, 27, 218, 201, 229, 191, 239, 158, 27,
+       76, 18, 60, 247, 101, 73, 133, 115, 59, 154, 114, 77, 26, 243,
+       105, 30, 94, 106, 144, 89, 161, 170, 207, 236, 228, 151, 138, 160,
+       173, 183, 191, 119, 22, 215, 237, 111, 218, 79, 39, 71, 255, 157,
+       231, 92, 223, 243, 108, 58, 255, 224, 174, 212, 153, 92, 197, 107,
+       23, 155, 232, 173, 34, 148, 238, 25, 75, 64, 164, 210, 105, 74,
+       160, 43, 106, 90, 70, 5, 154, 113, 101, 144, 10, 104, 16, 83, 165,
+       138, 132, 233, 148, 155, 202, 164, 188, 140, 142, 17, 73, 115,
+       172, 210, 104, 110, 39, 91, 42, 210, 22, 92, 139, 241, 76, 32, 30,
+       111, 144, 83, 161, 138, 134, 201, 133, 155, 202, 165, 188, 207,
+       142, 49, 73, 211, 132, 242, 105, 106, 109, 91, 51, 211, 22, 84,
+       139, 241, 13, 0, 223, 102, 144, 83, 161, 134, 111, 237, 253, 126,
+       246, 6, 223, 188, 27, 138, 117, 232, 125, 127, 189, 49, 23, 95,
+       23, 127, 240, 112, 42, 254, 110, 223, 101, 172, 239, 243, 194,
+       161, 165, 207, 27, 130, 228, 44, 239, 236, 200, 26, 185, 90, 212,
+       227, 233, 130, 233, 195, 66, 255, 114, 35, 10, 226, 188, 148, 47,
+       44, 208, 123, 235, 160, 197, 205, 26, 170, 232, 173, 183, 196,
+       236, 30, 169, 24, 148, 194, 105, 82, 203, 99, 74, 90, 115, 7, 138,
+       114, 181, 144, 14, 56, 144, 123, 163, 129, 192, 36, 150, 176, 137,
+       38, 52, 75, 186, 151, 130, 17, 204, 162, 65, 27, 129, 87, 233,
+       177, 32, 199, 147, 72, 137, 146, 95, 15, 128, 96, 39, 10, 229, 60,
+       205, 117, 172, 47, 68, 159, 83, 251, 187, 92, 211, 121, 217, 171,
+       93, 198, 124, 190, 189, 116, 223, 50, 46, 159, 117, 116, 237, 249,
+       200, 17, 216, 172, 151, 186, 185, 233, 92, 239, 191, 19, 168, 25,
+       175, 250, 66, 219, 131, 227, 124, 20, 62, 107, 202, 183, 187, 255,
+       87, 123, 194, 196, 199, 74, 246, 221, 241, 230, 250, 38, 30, 252,
+       27, 170, 153, 249, 95, 127, 189, 49, 151, 215, 21, 103, 248, 67,
+       136, 238, 250, 255, 109, 190, 157, 247, 162, 115, 199, 230, 240,
+       238, 252, 38, 158, 232, 155, 138, 185, 202, 220, 239, 189, 3, 151,
+       115, 95, 231, 224, 103, 8, 239, 56, 30, 239, 188, 157, 243, 163,
+       33, 247, 213, 146, 174, 252, 36, 151, 236, 137, 138, 185, 74, 92,
+       250, 109, 18, 253, 211, 95, 227, 112, 35, 26, 238, 185, 150, 143,
+       62, 216, 123, 163, 163, 198, 253, 26, 154, 251, 229, 191, 232,
+       142, 26, 137, 58, 188, 242, 105, 131, 239, 115, 91, 227, 114, 7,
+       154, 251, 185, 4, 15, 191, 144, 123, 171, 35, 198, 239, 217, 154,
+       234, 225, 190, 238, 142, 182, 153, 155, 236, 238, 109, 131, 207,
+       83, 251, 215, 114, 67, 218, 243, 60, 20, 143, 191, 149, 127, 141,
+       208, 135, 239, 228, 151, 238, 105, 174, 204, 234, 246, 25, 138,
+       193, 104, 223, 47, 59, 207, 115, 207, 212, 114, 174, 224, 124, 10,
+       207, 173, 197, 243, 147, 196, 181, 160, 221, 107, 204, 47, 66,
+       216, 98, 177, 177, 92, 83, 113, 216, 58, 25, 196, 100, 126, 155,
+       102, 219, 18, 216, 139, 101, 124, 249, 171, 194, 160, 231, 111,
+       237, 70, 238, 50, 174, 172, 234, 182, 185, 202, 225, 104, 221, 63,
+       59, 198, 114, 239, 196, 118, 238, 234, 62, 42, 239, 172, 197, 243,
+       219, 132, 37, 239, 173, 95, 152, 47, 78, 190, 150, 251, 220, 204,
+       211, 229, 217, 122, 93, 238, 127, 222, 255, 74, 239, 57, 239, 239,
+       245, 252, 216, 251, 210, 177, 118, 213, 227, 190, 155, 99, 158,
+       237, 27, 234, 185, 171, 110, 252, 45, 17, 253, 247, 213, 227, 108,
+       99, 72, 255, 185, 22, 207, 191, 213, 126, 183, 86, 132, 253, 151,
+       242, 244, 171, 118, 230, 247, 179, 107, 88, 111, 243, 9, 25, 179,
+       250, 70, 18, 112, 250, 26, 46, 191, 215, 85, 99, 224, 241, 226,
+       138, 94, 253, 190, 182, 191, 217, 118, 168, 223, 255, 157, 43,
+       111, 253, 79, 2, 163, 251, 253, 83, 238, 105, 138, 179, 251, 215,
+       77, 123, 166, 127, 157, 91, 253, 119, 221, 162, 170, 39, 95, 216,
+       82, 254, 181, 110, 83, 115, 203, 59, 95, 196, 124, 254, 173, 71,
+       237, 50, 250, 207, 229, 252, 173, 251, 2, 65, 125, 117, 220, 96,
+       158, 15, 79, 248, 83, 178, 189, 238, 83, 113, 201, 58, 95, 220,
+       124, 250, 233, 103, 253, 26, 250, 207, 229, 252, 255, 251, 66, 33,
+       61, 87, 75, 109, 22, 15, 71, 120, 117, 232, 255, 110, 83, 81, 153,
+       112, 120, 236, 126, 234, 201, 179, 109, 14, 242, 239, 161, 148,
+       111, 187, 114, 49, 103, 117, 225, 6, 253, 109, 167, 200, 203, 238,
+       177, 79, 72, 112, 223, 62, 25, 192, 82, 127, 161, 99, 254, 234,
+       60, 30, 69, 62, 207, 127, 210, 245, 184, 24, 63, 254, 67, 245, 48,
+       87, 145, 27, 240, 115, 62, 191, 40, 217, 236, 179, 151, 128, 58,
+       159, 18, 163, 211, 195, 114, 131, 243, 72, 164, 187, 184, 24, 189,
+       255, 47, 252, 80, 87, 253, 11, 240, 114, 62, 59, 32, 153, 232, 51,
+       215, 0, 49, 191, 80, 162, 211, 219, 114, 147, 210, 72, 237, 139,
+       190, 158, 98, 186, 237, 241, 216, 207, 155, 87, 144, 191, 15, 206,
+       126, 25, 235, 139, 135, 149, 62, 47, 26, 247, 219, 81, 158, 239,
+       215, 68, 190, 214, 175, 162, 204, 83, 237, 177, 168, 206, 207,
+       185, 117, 190, 8, 192, 255, 174, 77, 26, 162, 152, 151, 118, 238,
+       240, 14, 25, 213, 239, 223, 141, 216, 149, 75, 182, 62, 148, 49,
+       191, 161, 119, 249, 79, 156, 124, 174, 38, 166, 101, 103, 162, 78,
+       44, 181, 239, 52, 207, 188, 30, 58, 242, 138, 76, 139, 253, 138,
+       158, 6, 189, 243, 162, 60, 231, 63, 27, 90, 245, 236, 238, 34,
+       213, 119, 171, 191, 149, 54, 220, 3, 255, 188, 54, 222, 195, 142,
+       68, 169, 95, 194, 190, 222, 85, 235, 249, 48, 231, 191, 191, 166,
+       57, 44, 186, 70, 63, 167, 119, 238, 16, 54, 77, 162, 247, 14, 214,
+       85, 251, 130, 68, 175, 143, 195, 58, 147, 186, 56, 133, 185, 71,
+       174, 201, 17, 213, 188, 150, 96, 68, 230, 51, 63, 149, 19, 79,
+       146, 243, 217, 144, 154, 170, 24, 0, 161, 57, 198, 60, 150, 181,
+       173, 62, 188, 199, 187, 187, 144, 88, 140, 186, 65, 175, 141, 119,
+       253, 17, 49, 205, 146, 226, 137, 211, 223, 178, 136, 117, 139,
+       159, 97, 145, 145, 130, 237, 237, 118, 185, 75, 121, 75, 73, 94,
+       249, 88, 244, 145, 158, 50, 67, 87, 58, 218, 209, 95, 28, 5, 110,
+       78, 142, 208, 7, 157, 110, 149, 181, 169, 60, 92, 214, 251, 190,
+       144, 21, 143, 170, 67, 203, 239, 229, 236, 23, 172, 103, 226, 162,
+       136, 243, 95, 63, 162, 117, 13, 205, 65, 137, 151, 213, 160, 140,
+       41, 179, 188, 209, 66, 196, 245, 227, 144, 118, 35, 102, 122, 156,
+       19, 216, 151, 99, 204, 62, 86, 64, 136, 160, 33, 56, 101, 99, 233,
+       71, 228, 15, 207, 152, 64, 224, 57, 76, 83, 72, 221, 48, 28, 204,
+       80, 110, 201, 242, 253, 42, 102, 12, 165, 52, 77, 251, 82, 244,
+       252, 228, 120, 118, 157, 125, 151, 237, 120, 166, 165, 24, 203,
+       240, 75, 181, 25, 222, 200, 35, 120, 103, 248, 175, 243, 207, 5,
+       63, 99, 125, 207, 34, 61, 108, 136, 180, 245, 123, 199, 254, 81,
+       226, 244, 10, 215, 121, 19, 173, 89, 202, 150, 47, 121, 242, 124,
+       174, 253, 223, 215, 53, 239, 253, 218, 240, 175, 201, 236, 245,
+       244, 6, 237, 189, 27, 249, 86, 199, 89, 109, 23, 139, 95, 196, 55,
+       237, 177, 250, 95, 237, 110, 123, 237, 132, 175, 252, 216, 240,
+       246, 68, 240, 82, 219, 241, 208, 206, 219, 245, 161, 187, 74, 222,
+       127, 125, 219, 213, 164, 145, 46, 103, 238, 242, 26, 94, 213, 127,
+       215, 5, 78, 70, 65, 128, 135, 153, 132, 204, 169, 135, 172, 81,
+       202, 18, 244, 115, 56, 106, 97, 2, 58, 156, 19, 152, 83, 65, 197,
+       46, 222, 64, 152, 80, 177, 40, 162, 160, 53, 218, 29, 221, 208,
+       205, 207, 51, 165, 24, 138, 25, 108, 175, 137, 16, 218, 48, 50,
+       111, 90, 215, 27, 24, 17, 127, 82, 12, 212, 174, 209, 80, 255,
+       236, 38, 66, 77, 56, 160, 206, 210, 244, 247, 119, 137, 123, 118,
+       244, 125, 238, 233, 199, 167, 10, 208, 235, 226, 136, 36, 160, 32,
+       113, 234, 172, 165, 189, 237, 237, 84, 175, 159, 255, 144, 25,
+       174, 237, 84, 143, 137, 111, 235, 17, 62, 111, 218, 241, 143, 82,
+       95, 123, 146, 92, 212, 94, 5, 128, 143, 153, 132, 201, 161, 195,
+       204, 91, 194, 18, 148, 252, 48, 106, 233, 34, 58, 153, 19, 173, 3,
+       64, 141, 18, 222, 64, 144, 72, 177, 162, 168, 160, 20, 91, 13,
+       157, 176, 173, 206, 17, 160, 16, 166, 216, 12, 203, 201, 2, 234,
+       0, 86, 109, 219, 149, 143, 243, 82, 127, 88, 8, 217, 142, 34, 4,
+       18, 152, 213, 225, 180, 71, 159, 3, 120, 19, 36, 234, 36, 8, 249,
+       59, 2, 144, 54, 59, 16, 215, 53, 150, 158, 107, 209, 88, 237, 142,
+       193, 140, 221, 115, 137, 232, 93, 135, 63, 115, 162, 16, 183, 55,
+       66, 123, 131, 87, 120, 28, 59, 76, 251, 35, 143, 251, 84, 80, 168,
+       80, 133, 124, 181, 20, 204, 251, 212, 55, 94, 254, 21, 118, 213,
+       151, 211, 111, 59, 121, 89, 202, 23, 174, 124, 210, 124, 190, 246,
+       207, 231, 53, 188, 249, 242, 210, 181, 100, 105, 170, 156, 229,
+       95, 206, 87, 102, 201, 27, 147, 220, 127, 113, 217, 138, 31, 246,
+       254, 22, 125, 58, 243, 204, 133, 124, 48, 91, 244, 66, 239, 156,
+       148, 186, 235, 165, 20, 143, 155, 59, 160, 29, 236, 250, 110, 223,
+       199, 219, 250, 16, 54, 79, 218, 243, 159, 250, 95, 126, 154, 84,
+       137, 143, 34, 9, 167, 216, 205, 229, 233, 67, 143, 21, 200, 3,
+       176, 191, 117, 108, 200, 58, 51, 129, 18, 27, 114, 209, 71, 60,
+       218, 11, 145, 73, 244, 238, 2, 201, 250, 216, 215, 149, 184, 198,
+       95, 17, 92, 2, 44, 184, 116, 104, 235, 123, 147, 209, 150, 186,
+       22, 240, 95, 95, 158, 67, 149, 28, 189, 142, 53, 201, 105, 169,
+       150, 195, 203, 252, 70, 96, 216, 66, 19, 21, 145, 32, 122, 204,
+       23, 253, 219, 184, 125, 62, 249, 141, 175, 116, 117, 155, 112,
+       232, 100, 176, 181, 50, 217, 143, 163, 232, 142, 181, 161, 9, 214,
+       125, 73, 26, 145, 87, 107, 81, 18, 105, 91, 53, 93, 6, 95, 116,
+       208, 43, 71, 114, 182, 130, 247, 200, 79, 89, 208, 232, 201, 81,
+       177, 42, 74, 124, 44, 191, 202, 209, 230, 114, 93, 103, 106, 209,
+       27, 218, 69, 127, 211, 47, 102, 134, 83, 9, 147, 128, 149, 134,
+       168, 71, 252, 129, 203, 66, 181, 186, 52, 228, 240, 167, 56, 157,
+       21, 185, 145, 204, 185, 188, 10, 64, 137, 0, 161, 4, 49, 233, 105,
+       161, 214, 135, 175, 229, 70, 224, 88, 207, 17, 13, 113, 0, 124,
+       169, 19, 221, 193, 186, 84, 30, 125, 12, 175, 164, 125, 26, 243,
+       248, 240, 129, 177, 175, 29, 68, 131, 40, 82, 37, 193, 18, 247,
+       245, 24, 70, 88, 84, 105, 105, 56, 107, 219, 31, 249, 166, 75,
+       124, 81, 42, 53, 226, 156, 222, 252, 255, 170, 36, 157, 155, 254,
+       190, 183, 181, 221, 250, 111, 75, 183, 87, 45, 146, 244, 69, 43,
+       66, 234, 235, 127, 141, 216, 240, 165, 83, 19, 225, 163, 145, 147,
+       212, 185, 71, 174, 85, 64, 147, 156, 142, 118, 100, 236, 59, 27,
+       157, 215, 25, 182, 192, 191, 28, 158, 232, 151, 20, 161, 254, 3,
+       169, 234, 147, 119, 212, 186, 194, 95, 209, 92, 131, 44, 156, 119,
+       164, 239, 123, 147, 213, 134, 88, 190, 241, 15, 93, 154, 235, 23,
+       15, 61, 254, 188, 42, 245, 229, 125, 123, 89, 16, 131, 172, 190,
+       34, 75, 13, 209, 150, 78, 180, 229, 58, 104, 246, 97, 138, 79,
+       217, 1, 23, 103, 171, 68, 35, 188, 75, 245, 104, 223, 91, 82, 200,
+       195, 240, 180, 42, 75, 117, 37, 182, 170, 208, 198, 114, 8, 39,
+       107, 152, 27, 217, 5, 127, 243, 191, 78, 166, 83, 245, 19, 161,
+       151, 158, 56, 103, 45, 65, 74, 195, 159, 142, 112, 228, 38, 189,
+       29, 245, 215, 153, 21, 196, 185, 224, 30, 66, 44, 6, 161, 20, 28,
+       69, 149, 190, 159, 75, 70, 173, 23, 146, 138, 64, 231, 117, 9,
+       158, 17, 210, 201, 106, 107, 193, 75, 59, 161, 198, 69, 20, 186,
+       250, 152, 42, 148, 22, 190, 183, 160, 46, 189, 158, 252, 95, 63,
+       53, 223, 107, 11, 75, 167, 67, 109, 39, 176, 229, 11, 98, 232,
+       242, 111, 68, 200, 241, 165, 115, 31, 188, 150, 255, 143, 181,
+       181, 239, 191, 55, 250, 22, 238, 250, 108, 203, 187, 255, 232,
+       145, 54, 255, 155, 247, 155, 223, 95, 110, 219, 100, 169, 143, 47,
+       146, 224, 219, 165, 85, 223, 184, 87, 111, 85, 150, 73, 237, 254,
+       236, 93, 76, 167, 142, 221, 62, 253, 179, 79, 127, 149, 255, 247,
+       175, 92, 244, 118, 42, 88, 160, 122, 11, 89, 64, 25, 188, 180,
+       173, 142, 35, 195, 25, 134, 165, 79, 116, 40, 67, 192, 216, 216,
+       146, 111, 191, 188, 169, 11, 19, 8, 211, 90, 129, 50, 139, 125,
+       246, 45, 37, 126, 231, 29, 23, 170, 16, 54, 25, 23, 108, 194, 152,
+       1, 85, 254, 141, 38, 196, 54, 146, 139, 251, 236, 143, 140, 191,
+       189, 250, 84, 175, 159, 255, 254, 185, 239, 238, 107, 91, 217,
+       247, 238, 16, 126, 252, 107, 179, 255, 247, 245, 81, 146, 252,
+       156, 90, 190, 16, 96, 82, 229, 255, 89, 248, 23, 230, 181, 159,
+       75, 77, 127, 189, 157, 138, 151, 126, 188, 118, 126, 182, 91, 223,
+       213, 255, 247, 205, 94, 214, 61, 9, 115, 73, 211, 219, 226, 97,
+       117, 224, 111, 138, 91, 22, 36, 180, 58, 184, 2, 250, 93, 186, 53,
+       94, 63, 140, 1, 69, 115, 131, 230, 164, 3, 143, 115, 72, 112, 148,
+       234, 119, 105, 72, 124, 196, 43, 136, 182, 245, 38, 171, 6, 108,
+       215, 184, 36, 221, 50, 120, 0, 200, 127, 132, 107, 253, 204, 246,
+       178, 246, 165, 108, 103, 156, 187, 191, 63, 60, 254, 243, 106, 94,
+       177, 70, 125, 26, 114, 93, 170, 163, 185, 246, 119, 238, 128, 122,
+       213, 123, 190, 144, 97, 122, 233, 247, 218, 248, 31, 110, 181,
+       159, 11, 95, 62, 188, 221, 155, 151, 135, 255, 6, 122, 247, 83,
+       95, 145, 255, 247, 143, 86, 215, 82, 202, 147, 252, 91, 192, 60,
+       199, 171, 5, 224, 130, 44, 230, 36, 214, 230, 255, 169, 128, 74,
+       11, 178, 211, 177, 182, 158, 11, 177, 80, 165, 170, 80, 218, 147,
+       124, 75, 68, 52, 199, 251, 3, 224, 16, 172, 182, 36, 126, 229,
+       255, 168, 128, 66, 11, 178, 195, 177, 182, 94, 11, 208, 112, 167,
+       174, 236, 255, 177, 83, 177, 236, 67, 150, 58, 189, 62, 12, 242,
+       247, 201, 126, 217, 126, 108, 88, 58, 88, 232, 34, 237, 252, 183,
+       248, 130, 83, 198, 123, 139, 20, 235, 223, 182, 150, 191, 23, 93,
+       79, 87, 183, 189, 220, 190, 228, 215, 59, 151, 29, 167, 148, 52,
+       235, 98, 127, 186, 128, 134, 204, 189, 125, 255, 216, 188, 228,
+       205, 117, 211, 152, 195, 254, 180, 63, 74, 125, 215, 175, 141,
+       212, 253, 114, 173, 103, 251, 162, 219, 219, 229, 255, 219, 125,
+       92, 119, 111, 176, 240, 214, 141, 112, 88, 73, 203, 247, 173, 31,
+       74, 254, 94, 174, 217, 219, 249, 149, 30, 66, 255, 192, 27, 89,
+       221, 127, 135, 110, 222, 214, 46, 110, 98, 216, 125, 145, 218,
+       198, 159, 103, 212, 171, 40, 204, 183, 228, 233, 184, 135, 21,
+       174, 39, 38, 255, 54, 86, 149, 187, 191, 220, 124, 222, 90, 223,
+       42, 140, 119, 208, 159, 247, 17, 76, 220, 14, 40, 174, 54, 132,
+       254, 243, 151, 225, 237, 11, 176, 239, 243, 117, 142, 171, 23, 52,
+       47, 223, 236, 237, 238, 215, 252, 226, 255, 175, 183, 247, 126,
+       16, 121, 235, 86, 83, 89, 238, 119, 152, 114, 250, 235, 255, 110,
+       191, 247, 45, 207, 240, 230, 250, 126, 96, 240, 226, 141, 213, 94,
+       200, 203, 227, 189, 11, 10, 221, 93, 62, 217, 217, 85, 27, 78,
+       103, 250, 226, 211, 221, 133, 63, 231, 95, 86, 70, 36, 249, 152,
+       103, 216, 77, 99, 248, 2, 169, 60, 77, 115, 119, 72, 20, 28, 222,
+       99, 218, 82, 58, 217, 49, 109, 140, 37, 116, 251, 187, 194, 184,
+       100, 253, 241, 67, 152, 205, 199, 181, 99, 173, 187, 76, 242, 85,
+       204, 20, 29, 222, 109, 218, 74, 58, 249, 97, 111, 156, 37, 244,
+       195, 154, 198, 59, 11, 68, 234, 239, 55, 178, 251, 23, 93, 197,
+       95, 163, 249, 63, 183, 100, 118, 63, 159, 189, 164, 184, 100, 206,
+       103, 253, 170, 129, 167, 214, 125, 237, 9, 31, 243, 69, 246, 2,
+       191, 119, 84, 200, 126, 230, 145, 45, 180, 32, 110, 118, 55, 140,
+       209, 184, 37, 202, 110, 47, 182, 128, 111, 232, 241, 249, 82, 206,
+       70, 189, 98, 226, 53, 231, 182, 78, 78, 161, 108, 183, 162, 84,
+       99, 47, 189, 131, 96, 157, 140, 255, 244, 102, 250, 131, 54, 84,
+       180, 75, 126, 112, 176, 242, 141, 205, 81, 204, 203, 187, 177, 26,
+       14, 221, 109, 62, 201, 209, 253, 81, 10, 103, 218, 162, 147, 220,
+       21, 63, 210, 31, 212, 2, 93, 13, 107, 229, 182, 114, 123, 114,
+       117, 192, 222, 130, 89, 127, 146, 97, 126, 244, 29, 172, 189, 152,
+       53, 206, 251, 237, 171, 193, 175, 231, 125, 112, 59, 95, 123, 150,
+       246, 212, 127, 119, 57, 76, 126, 231, 63, 190, 166, 240, 254, 251,
+       151, 205, 221, 186, 52, 236, 242, 253, 174, 130, 15, 254, 174,
+       253, 126, 64, 177, 250, 93, 237, 83, 202, 219, 121, 169, 8, 142,
+       219, 109, 220, 201, 137, 63, 17, 11, 35, 218, 240, 153, 220, 147,
+       126, 218, 13, 116, 38, 10, 198, 115, 238, 117, 189, 254, 119, 205,
+       3, 121, 67, 45, 201, 60, 132, 254, 171, 151, 129, 196, 186, 16,
+       253, 246, 221, 138, 11, 63, 206, 233, 142, 239, 24, 180, 88, 237,
+       117, 92, 143, 219, 255, 52, 57, 172, 190, 119, 255, 199, 83, 191,
+       18, 230, 79, 186, 240, 27, 91, 85, 191, 146, 220, 77, 95, 175,
+       156, 183, 223, 229, 247, 229, 255, 95, 251, 126, 118, 120, 252,
+       254, 237, 221, 222, 54, 31, 179, 254, 111, 247, 60, 30, 215, 198,
+       223, 253, 240, 253, 252, 52, 220, 102, 240, 110, 87, 184, 50, 170,
+       167, 24, 95, 115, 9, 56, 145, 213, 117, 98, 40, 231, 217, 14, 243,
+       239, 101, 21, 232, 243, 70, 19, 171, 142, 230, 154, 237, 241, 188,
+       239, 223, 123, 212, 187, 40, 168, 246, 239, 203, 139, 183, 129,
+       182, 126, 78, 247, 30, 90, 222, 239, 159, 93, 248, 141, 111, 190,
+       198, 155, 237, 181, 188, 207, 159, 123, 88, 215, 40, 234, 254,
+       207, 237, 107, 243, 149, 183, 91, 158, 243, 62, 94, 223, 235, 159,
+       84, 249, 221, 219, 227, 120, 236, 46, 155, 91, 56, 229, 236, 189,
+       235, 91, 207, 222, 245, 54, 189, 253, 238, 204, 37, 239, 157, 242,
+       217, 161, 253, 39, 166, 92, 65, 70, 184, 190, 146, 255, 237, 185,
+       199, 159, 95, 23, 191, 172, 222, 126, 11, 143, 179, 255, 145, 182,
+       77, 50, 243, 95, 23, 218, 235, 133, 77, 157, 215, 226, 152, 174,
+       154, 253, 253, 185, 198, 159, 95, 20, 187, 172, 254, 110, 75, 207,
+       51, 251, 17, 182, 79, 50, 241, 95, 19, 218, 251, 148, 76, 149,
+       223, 95, 131, 244, 150, 239, 30, 254, 249, 255, 156, 183, 239,
+       207, 107, 159, 214, 126, 229, 239, 255, 220, 99, 79, 204, 254,
+       251, 239, 215, 175, 174, 105, 5, 227, 48, 124, 236, 108, 89, 249,
+       105, 139, 244, 181, 187, 220, 222, 126, 43, 222, 185, 247, 161,
+       148, 103, 242, 209, 215, 217, 203, 191, 21, 168, 71, 243, 66, 156,
+       63, 249, 236, 229, 185, 83, 190, 95, 56, 86, 156, 191, 112, 107,
+       231, 27, 63, 153, 179, 79, 179, 214, 221, 191, 250, 238, 148, 64,
+       37, 251, 130, 156, 159, 246, 171, 237, 181, 23, 191, 219, 150, 48,
+       188, 191, 96, 107, 167, 51, 255, 17, 35, 77, 51, 227, 205, 211,
+       94, 154, 128, 80, 165, 123, 82, 188, 191, 178, 171, 233, 53, 199,
+       175, 247, 142, 59, 140, 191, 98, 74, 163, 51, 251, 17, 18, 73,
+       178, 241, 217, 215, 95, 251, 128, 68, 135, 123, 13, 205, 231, 127,
+       149, 22, 238, 189, 86, 242, 79, 2, 241, 105, 189, 101, 121, 110,
+       50, 239, 244, 240, 61, 175, 111, 111, 197, 68, 247, 254, 240, 172,
+       199, 165, 135, 147, 131, 228, 45, 167, 187, 211, 10, 144, 140,
+       166, 78, 127, 167, 87, 120, 149, 55, 201, 183, 98, 173, 50, 222,
+       194, 128, 84, 163, 124, 74, 185, 189, 250, 169, 237, 21, 207, 175,
+       121, 172, 24, 190, 182, 64, 58, 133, 83, 250, 16, 19, 75, 250,
+       241, 219, 215, 31, 126, 152, 64, 167, 59, 133, 101, 75, 106, 244,
+       169, 111, 152, 108, 0, 105, 192, 151, 195, 249, 80, 50, 8, 6, 126,
+       67, 16, 12, 127, 228, 136, 39, 108, 28, 211, 195, 160, 214, 182,
+       189, 22, 170, 44, 21, 191, 154, 255, 155, 253, 214, 254, 204, 75,
+       135, 87, 109, 17, 177, 79, 235, 98, 217, 178, 127, 254, 200, 112,
+       135, 91, 5, 67, 155, 235, 172, 0, 111, 216, 238, 144, 9, 64, 149,
+       195, 249, 106, 114, 73, 46, 222, 67, 1, 139, 112, 228, 156, 47,
+       44, 24, 243, 161, 33, 202, 172, 148, 211, 141, 252, 180, 143, 155,
+       55, 8, 16, 172, 58, 68, 175, 129, 83, 249, 17, 50, 108, 219, 243,
+       141, 214, 94, 115, 146, 68, 135, 174, 130, 141, 148, 218, 137,
+       165, 164, 167, 223, 19, 8, 16, 172, 250, 108, 239, 129, 99, 42,
+       17, 50, 72, 90, 241, 45, 18, 95, 107, 144, 80, 133, 46, 133, 140,
+       135, 183, 176, 175, 46, 170, 190, 147, 75, 16, 244, 226, 41, 73,
+       145, 99, 120, 63, 48, 205, 11, 111, 168, 150, 95, 68, 128, 113,
+       161, 32, 207, 236, 228, 159, 170, 178, 189, 190, 159, 242, 22,
+       213, 253, 238, 223, 111, 7, 103, 125, 223, 247, 76, 239, 243, 206,
+       122, 255, 236, 158, 245, 153, 69, 133, 207, 155, 134, 252, 40,
+       230, 232, 204, 146, 185, 66, 212, 227, 233, 66, 121, 66, 74, 234,
+       113, 39, 10, 251, 188, 148, 167, 44, 152, 251, 225, 160, 197, 237,
+       27, 10, 232, 173, 38, 204, 236, 26, 104, 64, 148, 242, 105, 114,
+       225, 106, 74, 122, 66, 3, 138, 114, 181, 144, 39, 44, 152, 115,
+       161, 161, 132, 235, 157, 187, 138, 161, 46, 140, 142, 18, 75, 192,
+       213, 211, 105, 74, 71, 91, 42, 210, 82, 212, 207, 113, 172, 128,
+       47, 76, 56, 83, 161, 128, 229, 188, 141, 55, 172, 47, 101, 191,
+       90, 251, 58, 92, 211, 112, 217, 59, 133, 70, 124, 28, 185, 124,
+       251, 34, 237, 155, 245, 116, 200, 248, 208, 120, 198, 173, 129,
+       151, 206, 41, 174, 236, 142, 178, 24, 219, 229, 226, 121, 2, 47,
+       75, 123, 247, 118, 67, 206, 242, 44, 4, 143, 188, 148, 123, 145,
+       128, 245, 111, 205, 118, 140, 11, 199, 248, 82, 186, 176, 124, 83,
+       96, 217, 27, 25, 196, 108, 122, 233, 103, 207, 42, 120, 138, 101,
+       60, 105, 249, 210, 32, 246, 221, 154, 190, 223, 6, 158, 239, 27,
+       170, 184, 10, 92, 122, 45, 18, 255, 215, 23, 227, 105, 103, 24,
+       238, 185, 150, 207, 62, 217, 122, 163, 43, 197, 231, 237, 7, 204,
+       34, 174, 236, 234, 178, 121, 206, 209, 232, 221, 35, 59, 78, 114,
+       239, 228, 114, 206, 106, 44, 42, 207, 44, 237, 243, 211, 132, 246,
+       149, 155, 190, 223, 99, 158, 237, 27, 170, 185, 59, 126, 126, 44,
+       17, 255, 247, 215, 163, 120, 99, 74, 222, 185, 22, 207, 191, 213,
+       122, 167, 35, 228, 141, 199, 86, 220, 34, 78, 168, 209, 130, 171,
+       90, 99, 97, 157, 87, 89, 198, 106, 238, 120, 231, 205, 238, 58,
+       46, 197, 20, 197, 251, 240, 4, 246, 150, 141, 190, 188, 99, 158,
+       235, 27, 174, 185, 187, 106, 124, 44, 16, 221, 215, 245, 163, 120,
+       99, 75, 255, 185, 182, 205, 191, 213, 126, 214, 51, 76, 245, 252,
+       242, 156, 109, 87, 140, 19, 181, 141, 27, 255, 253, 74, 2, 159,
+       211, 249, 83, 58, 99, 219, 179, 251, 223, 85, 127, 132, 219, 246,
+       114 ]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/resized_IMG_3875.JPG b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/resized_IMG_3875.JPG
new file mode 100644
index 00000000..11b3d5b6
Binary files /dev/null and b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/resized_IMG_3875.JPG differ
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvReader.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvReader.cpp
new file mode 100644
index 00000000..1461877e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvReader.cpp
@@ -0,0 +1,79 @@
+#include "CsvReader.h"
+
+/** The default constructor of the CSV reader Class */
+CsvReader::CsvReader(const string &path, char separator){
+    _file.open(path.c_str(), ifstream::in);
+    _separator = separator;
+}
+
+/* Read a plane text file with .ply format */
+void CsvReader::readPLY(vector<Point3f> &list_vertex, vector<vector<int> > &list_triangles)
+{
+    std::string line, tmp_str, n;
+    int num_vertex = 0, num_triangles = 0;
+    int count = 0;
+    bool end_header = false;
+    bool end_vertex = false;
+
+    // Read the whole *.ply file
+    while (getline(_file, line)) {
+    stringstream liness(line);
+
+    // read header
+    if(!end_header)
+    {
+        getline(liness, tmp_str, _separator);
+        if( tmp_str == "element" )
+        {
+            getline(liness, tmp_str, _separator);
+            getline(liness, n);
+            if(tmp_str == "vertex") num_vertex = StringToInt(n);
+            if(tmp_str == "face") num_triangles = StringToInt(n);
+        }
+        if(tmp_str == "end_header") end_header = true;
+    }
+
+    // read file content
+    else if(end_header)
+    {
+         // read vertex and add into 'list_vertex'
+         if(!end_vertex && count < num_vertex)
+         {
+             string x, y, z;
+             getline(liness, x, _separator);
+             getline(liness, y, _separator);
+             getline(liness, z);
+
+             cv::Point3f tmp_p;
+             tmp_p.x = (float)StringToInt(x);
+             tmp_p.y = (float)StringToInt(y);
+             tmp_p.z = (float)StringToInt(z);
+             list_vertex.push_back(tmp_p);
+
+             count++;
+             if(count == num_vertex)
+             {
+                 count = 0;
+                 end_vertex = !end_vertex;
+             }
+         }
+         // read faces and add into 'list_triangles'
+         else if(end_vertex  && count < num_triangles)
+         {
+             string num_pts_per_face, id0, id1, id2;
+             getline(liness, num_pts_per_face, _separator);
+             getline(liness, id0, _separator);
+             getline(liness, id1, _separator);
+             getline(liness, id2);
+
+             std::vector<int> tmp_triangle(3);
+             tmp_triangle[0] = StringToInt(id0);
+             tmp_triangle[1] = StringToInt(id1);
+             tmp_triangle[2] = StringToInt(id2);
+             list_triangles.push_back(tmp_triangle);
+
+             count++;
+      }
+    }
+  }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvReader.h b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvReader.h
new file mode 100644
index 00000000..cf54cb74
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvReader.h
@@ -0,0 +1,40 @@
+#ifndef CSVREADER_H
+#define	CSVREADER_H
+
+#include <iostream>
+#include <fstream>
+#include <opencv2/core/core.hpp>
+#include "Utils.h"
+
+using namespace std;
+using namespace cv;
+
+class CsvReader {
+public:
+    /**
+    * The default constructor of the CSV reader Class.
+    * The default separator is ' ' (empty space)
+    *
+    * @param path - The path of the file to read
+    * @param separator - The separator character between words per line
+    * @return
+    */
+    CsvReader(const string &path, char separator = ' ');
+
+    /**
+    * Read a plane text file with .ply format
+    *
+    * @param list_vertex - The container of the vertices list of the mesh
+    * @param list_triangle - The container of the triangles list of the mesh
+    * @return
+    */
+    void readPLY(vector<Point3f> &list_vertex, vector<vector<int> > &list_triangles);
+
+private:
+    /** The current stream file for the reader */
+    ifstream _file;
+    /** The separator character between words for each line */
+    char _separator;
+};
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvWriter.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvWriter.cpp
new file mode 100644
index 00000000..10d0df47
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvWriter.cpp
@@ -0,0 +1,45 @@
+#include "CsvWriter.h"
+
+CsvWriter::CsvWriter(const string &path, const string &separator){
+    _file.open(path.c_str(), ofstream::out);
+    _isFirstTerm = true;
+    _separator = separator;
+}
+
+CsvWriter::~CsvWriter() {
+    _file.flush();
+    _file.close();
+}
+
+void CsvWriter::writeXYZ(const vector<Point3f> &list_points3d)
+{
+    for(size_t i = 0; i < list_points3d.size(); ++i)
+    {
+        string x = FloatToString(list_points3d[i].x);
+        string y = FloatToString(list_points3d[i].y);
+        string z = FloatToString(list_points3d[i].z);
+
+        _file << x << _separator << y << _separator << z << std::endl;
+    }
+}
+
+void CsvWriter::writeUVXYZ(const vector<Point3f> &list_points3d, const vector<Point2f> &list_points2d, const Mat &descriptors)
+{
+    for(size_t i = 0; i < list_points3d.size(); ++i)
+    {
+        string u = FloatToString(list_points2d[i].x);
+        string v = FloatToString(list_points2d[i].y);
+        string x = FloatToString(list_points3d[i].x);
+        string y = FloatToString(list_points3d[i].y);
+        string z = FloatToString(list_points3d[i].z);
+
+        _file << u << _separator << v << _separator << x << _separator << y << _separator << z;
+
+        for(int j = 0; j < 32; ++j)
+        {
+            string descriptor_str = FloatToString(descriptors.at<float>((int)i,j));
+            _file << _separator << descriptor_str;
+        }
+        _file << std::endl;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvWriter.h b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvWriter.h
new file mode 100644
index 00000000..499fb115
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/CsvWriter.h
@@ -0,0 +1,25 @@
+#ifndef CSVWRITER_H
+#define CSVWRITER_H
+
+#include <iostream>
+#include <fstream>
+#include <opencv2/core.hpp>
+#include "Utils.h"
+
+using namespace std;
+using namespace cv;
+
+class CsvWriter {
+public:
+    CsvWriter(const string &path, const string &separator = " ");
+    ~CsvWriter();
+    void writeXYZ(const vector<Point3f> &list_points3d);
+    void writeUVXYZ(const vector<Point3f> &list_points3d, const vector<Point2f> &list_points2d, const Mat &descriptors);
+
+private:
+    ofstream _file;
+    string _separator;
+    bool _isFirstTerm;
+};
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Mesh.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Mesh.cpp
new file mode 100644
index 00000000..2228b6e9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Mesh.cpp
@@ -0,0 +1,78 @@
+/*
+ * Mesh.cpp
+ *
+ *  Created on: Apr 9, 2014
+ *      Author: edgar
+ */
+
+#include "Mesh.h"
+#include "CsvReader.h"
+
+
+// --------------------------------------------------- //
+//                   TRIANGLE CLASS                    //
+// --------------------------------------------------- //
+
+/**  The custom constructor of the Triangle Class */
+Triangle::Triangle(const cv::Point3f& V0, const cv::Point3f& V1, const cv::Point3f& V2) :
+    v0_(V0), v1_(V1), v2_(V2)
+{
+}
+
+/**  The default destructor of the Class */
+Triangle::~Triangle()
+{
+    // TODO Auto-generated destructor stub
+}
+
+
+// --------------------------------------------------- //
+//                     RAY CLASS                       //
+// --------------------------------------------------- //
+
+/**  The custom constructor of the Ray Class */
+Ray::Ray(const cv::Point3f& P0, const cv::Point3f& P1) :
+    p0_(P0), p1_(P1)
+{
+}
+
+/**  The default destructor of the Class */
+Ray::~Ray()
+{
+    // TODO Auto-generated destructor stub
+}
+
+
+// --------------------------------------------------- //
+//                 OBJECT MESH CLASS                   //
+// --------------------------------------------------- //
+
+/** The default constructor of the ObjectMesh Class */
+Mesh::Mesh() : num_vertices_(0), num_triangles_(0),
+    list_vertex_(0) , list_triangles_(0)
+{
+}
+
+/** The default destructor of the ObjectMesh Class */
+Mesh::~Mesh()
+{
+    // TODO Auto-generated destructor stub
+}
+
+/** Load a CSV with *.ply format **/
+void Mesh::load(const std::string& path)
+{
+    // Create the reader
+    CsvReader csvReader(path);
+
+    // Clear previous data
+    list_vertex_.clear();
+    list_triangles_.clear();
+
+    // Read from .ply file
+    csvReader.readPLY(list_vertex_, list_triangles_);
+
+    // Update mesh attributes
+    num_vertices_ = (int)list_vertex_.size();
+    num_triangles_ = (int)list_triangles_.size();
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Mesh.h b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Mesh.h
new file mode 100644
index 00000000..40f8b7d4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Mesh.h
@@ -0,0 +1,82 @@
+/*
+ * Mesh.h
+ *
+ *  Created on: Apr 9, 2014
+ *      Author: edgar
+ */
+
+#ifndef MESH_H_
+#define MESH_H_
+
+#include <iostream>
+#include <opencv2/core/core.hpp>
+
+
+// --------------------------------------------------- //
+//                 TRIANGLE CLASS                      //
+// --------------------------------------------------- //
+
+class Triangle {
+public:
+
+    explicit Triangle(const cv::Point3f& V0, const cv::Point3f& V1, const cv::Point3f& V2);
+    virtual ~Triangle();
+
+    cv::Point3f getV0() const { return v0_; }
+    cv::Point3f getV1() const { return v1_; }
+    cv::Point3f getV2() const { return v2_; }
+
+private:
+    /** The three vertices that defines the triangle */
+    cv::Point3f v0_, v1_, v2_;
+};
+
+
+// --------------------------------------------------- //
+//                     RAY CLASS                       //
+// --------------------------------------------------- //
+
+class Ray {
+public:
+
+    explicit Ray(const cv::Point3f& P0, const cv::Point3f& P1);
+    virtual ~Ray();
+
+    cv::Point3f getP0() { return p0_; }
+    cv::Point3f getP1() { return p1_; }
+
+private:
+    /** The two points that defines the ray */
+    cv::Point3f p0_, p1_;
+};
+
+
+// --------------------------------------------------- //
+//                OBJECT MESH CLASS                    //
+// --------------------------------------------------- //
+
+class Mesh
+{
+public:
+
+    Mesh();
+    virtual ~Mesh();
+
+    std::vector<std::vector<int> > getTrianglesList() const { return list_triangles_; }
+    cv::Point3f getVertex(int pos) const { return list_vertex_[pos]; }
+    int getNumVertices() const { return num_vertices_; }
+
+    void load(const std::string& path_file);
+
+private:
+    /** The current number of vertices in the mesh */
+    int num_vertices_;
+    /** The current number of triangles in the mesh */
+    int num_triangles_;
+    /* The list of triangles of the mesh */
+    std::vector<cv::Point3f> list_vertex_;
+    /* The list of triangles of the mesh */
+    std::vector<std::vector<int> > list_triangles_;
+};
+
+#endif /* OBJECTMESH_H_ */
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Model.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Model.cpp
new file mode 100644
index 00000000..e2dc2a8a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Model.cpp
@@ -0,0 +1,83 @@
+/*
+ * Model.cpp
+ *
+ *  Created on: Apr 9, 2014
+ *      Author: edgar
+ */
+
+#include "Model.h"
+#include "CsvWriter.h"
+
+Model::Model() : n_correspondences_(0), list_points2d_in_(0), list_points2d_out_(0), list_points3d_in_(0), training_img_path_()
+{
+}
+
+Model::~Model()
+{
+    // TODO Auto-generated destructor stub
+}
+
+void Model::add_correspondence(const cv::Point2f &point2d, const cv::Point3f &point3d)
+{
+    list_points2d_in_.push_back(point2d);
+    list_points3d_in_.push_back(point3d);
+    n_correspondences_++;
+}
+
+void Model::add_outlier(const cv::Point2f &point2d)
+{
+    list_points2d_out_.push_back(point2d);
+}
+
+void Model::add_descriptor(const cv::Mat &descriptor)
+{
+    descriptors_.push_back(descriptor);
+}
+
+void Model::add_keypoint(const cv::KeyPoint &kp)
+{
+    list_keypoints_.push_back(kp);
+}
+
+void Model::set_trainingImagePath(const std::string &path)
+{
+    training_img_path_ = path;
+}
+
+/** Save a YAML file and fill the object mesh */
+void Model::save(const std::string &path)
+{
+    cv::Mat points3dmatrix = cv::Mat(list_points3d_in_);
+    cv::Mat points2dmatrix = cv::Mat(list_points2d_in_);
+
+    cv::FileStorage storage(path, cv::FileStorage::WRITE);
+    storage << "points_3d" << points3dmatrix;
+    storage << "points_2d" << points2dmatrix;
+    storage << "keypoints" << list_keypoints_;
+    storage << "descriptors" << descriptors_;
+    storage << "training_image_path" << training_img_path_;
+
+    storage.release();
+}
+
+/** Load a YAML file using OpenCv functions **/
+void Model::load(const std::string &path)
+{
+    cv::Mat points3d_mat;
+
+    cv::FileStorage storage(path, cv::FileStorage::READ);
+    storage["points_3d"] >> points3d_mat;
+    storage["descriptors"] >> descriptors_;
+    if (!storage["keypoints"].empty())
+    {
+        storage["keypoints"] >> list_keypoints_;
+    }
+    if (!storage["training_image_path"].empty())
+    {
+        storage["training_image_path"] >> training_img_path_;
+    }
+
+    points3d_mat.copyTo(list_points3d_in_);
+
+    storage.release();
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Model.h b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Model.h
new file mode 100644
index 00000000..92f004d4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Model.h
@@ -0,0 +1,55 @@
+/*
+ * Model.h
+ *
+ *  Created on: Apr 9, 2014
+ *      Author: edgar
+ */
+
+#ifndef MODEL_H_
+#define MODEL_H_
+
+#include <iostream>
+#include <opencv2/core/core.hpp>
+#include <opencv2/features2d/features2d.hpp>
+
+class Model
+{
+public:
+    Model();
+    virtual ~Model();
+
+    std::vector<cv::Point2f> get_points2d_in() const { return list_points2d_in_; }
+    std::vector<cv::Point2f> get_points2d_out() const { return list_points2d_out_; }
+    std::vector<cv::Point3f> get_points3d() const { return list_points3d_in_; }
+    std::vector<cv::KeyPoint> get_keypoints() const { return list_keypoints_; }
+    cv::Mat get_descriptors() const { return descriptors_; }
+    int get_numDescriptors() const { return descriptors_.rows; }
+    std::string get_trainingImagePath() const { return training_img_path_; }
+
+    void add_correspondence(const cv::Point2f &point2d, const cv::Point3f &point3d);
+    void add_outlier(const cv::Point2f &point2d);
+    void add_descriptor(const cv::Mat &descriptor);
+    void add_keypoint(const cv::KeyPoint &kp);
+    void set_trainingImagePath(const std::string &path);
+
+    void save(const std::string &path);
+    void load(const std::string &path);
+
+private:
+    /** The current number of correspondences */
+    int n_correspondences_;
+    /** The list of 2D points on the model surface */
+    std::vector<cv::KeyPoint> list_keypoints_;
+    /** The list of 2D points on the model surface */
+    std::vector<cv::Point2f> list_points2d_in_;
+    /** The list of 2D points outside the model surface */
+    std::vector<cv::Point2f> list_points2d_out_;
+    /** The list of 3D points on the model surface */
+    std::vector<cv::Point3f> list_points3d_in_;
+    /** The list of 2D points descriptors */
+    cv::Mat descriptors_;
+    /** Path to the training image */
+    std::string training_img_path_;
+};
+
+#endif /* OBJECTMODEL_H_ */
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/ModelRegistration.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/ModelRegistration.cpp
new file mode 100644
index 00000000..8690a345
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/ModelRegistration.cpp
@@ -0,0 +1,34 @@
+/*
+ * ModelRegistration.cpp
+ *
+ *  Created on: Apr 18, 2014
+ *      Author: edgar
+ */
+
+#include "ModelRegistration.h"
+
+ModelRegistration::ModelRegistration() : n_registrations_(0), max_registrations_(0),
+    list_points2d_(), list_points3d_()
+{
+}
+
+ModelRegistration::~ModelRegistration()
+{
+    // TODO Auto-generated destructor stub
+}
+
+void ModelRegistration::registerPoint(const cv::Point2f &point2d, const cv::Point3f &point3d)
+{
+    // add correspondence at the end of the vector
+    list_points2d_.push_back(point2d);
+    list_points3d_.push_back(point3d);
+    n_registrations_++;
+}
+
+void ModelRegistration::reset()
+{
+    n_registrations_ = 0;
+    max_registrations_ = 0;
+    list_points2d_.clear();
+    list_points3d_.clear();
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/ModelRegistration.h b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/ModelRegistration.h
new file mode 100644
index 00000000..350f56d8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/ModelRegistration.h
@@ -0,0 +1,42 @@
+/*
+ * ModelRegistration.h
+ *
+ *  Created on: Apr 18, 2014
+ *      Author: edgar
+ */
+
+#ifndef MODELREGISTRATION_H_
+#define MODELREGISTRATION_H_
+
+#include <iostream>
+#include <opencv2/core.hpp>
+
+class ModelRegistration
+{
+public:
+    ModelRegistration();
+    virtual ~ModelRegistration();
+
+    void setNumMax(int n) { max_registrations_ = n; }
+
+    std::vector<cv::Point2f> get_points2d() const { return list_points2d_; }
+    std::vector<cv::Point3f> get_points3d() const { return list_points3d_; }
+    int getNumMax() const { return max_registrations_; }
+    int getNumRegist() const { return n_registrations_; }
+
+    bool is_registrable() const { return (n_registrations_ < max_registrations_); }
+    void registerPoint(const cv::Point2f &point2d, const cv::Point3f &point3d);
+    void reset();
+
+private:
+    /** The current number of registered points */
+    int n_registrations_;
+    /** The total number of points to register */
+    int max_registrations_;
+    /** The list of 2D points to register the model */
+    std::vector<cv::Point2f> list_points2d_;
+    /** The list of 3D points to register the model */
+    std::vector<cv::Point3f> list_points3d_;
+};
+
+#endif /* MODELREGISTRATION_H_ */
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/PnPProblem.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/PnPProblem.cpp
new file mode 100644
index 00000000..c99b0eca
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/PnPProblem.cpp
@@ -0,0 +1,307 @@
+/*
+ * PnPProblem.cpp
+ *
+ *  Created on: Mar 28, 2014
+ *      Author: Edgar Riba
+ */
+
+#include <iostream>
+#include <sstream>
+
+#include "PnPProblem.h"
+#include "Mesh.h"
+
+#include <opencv2/calib3d/calib3d.hpp>
+
+/* Functions for Möller-Trumbore intersection algorithm */
+static cv::Point3f CROSS(cv::Point3f v1, cv::Point3f v2)
+{
+    cv::Point3f tmp_p;
+    tmp_p.x =  v1.y*v2.z - v1.z*v2.y;
+    tmp_p.y =  v1.z*v2.x - v1.x*v2.z;
+    tmp_p.z =  v1.x*v2.y - v1.y*v2.x;
+    return tmp_p;
+}
+
+static double DOT(cv::Point3f v1, cv::Point3f v2)
+{
+    return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
+}
+
+static cv::Point3f SUB(cv::Point3f v1, cv::Point3f v2)
+{
+    cv::Point3f tmp_p;
+    tmp_p.x =  v1.x - v2.x;
+    tmp_p.y =  v1.y - v2.y;
+    tmp_p.z =  v1.z - v2.z;
+    return tmp_p;
+}
+
+/* End functions for Möller-Trumbore intersection algorithm */
+
+// Function to get the nearest 3D point to the Ray origin
+static cv::Point3f get_nearest_3D_point(std::vector<cv::Point3f> &points_list, cv::Point3f origin)
+{
+    cv::Point3f p1 = points_list[0];
+    cv::Point3f p2 = points_list[1];
+
+    double d1 = std::sqrt( std::pow(p1.x-origin.x, 2) + std::pow(p1.y-origin.y, 2) + std::pow(p1.z-origin.z, 2) );
+    double d2 = std::sqrt( std::pow(p2.x-origin.x, 2) + std::pow(p2.y-origin.y, 2) + std::pow(p2.z-origin.z, 2) );
+
+    if(d1 < d2)
+    {
+        return p1;
+    }
+    else
+    {
+        return p2;
+    }
+}
+
+// Custom constructor given the intrinsic camera parameters
+
+PnPProblem::PnPProblem(const double params[])
+{
+    A_matrix_ = cv::Mat::zeros(3, 3, CV_64FC1);   // intrinsic camera parameters
+    A_matrix_.at<double>(0, 0) = params[0];       //      [ fx   0  cx ]
+    A_matrix_.at<double>(1, 1) = params[1];       //      [  0  fy  cy ]
+    A_matrix_.at<double>(0, 2) = params[2];       //      [  0   0   1 ]
+    A_matrix_.at<double>(1, 2) = params[3];
+    A_matrix_.at<double>(2, 2) = 1;
+    R_matrix_ = cv::Mat::zeros(3, 3, CV_64FC1);   // rotation matrix
+    t_matrix_ = cv::Mat::zeros(3, 1, CV_64FC1);   // translation matrix
+    P_matrix_ = cv::Mat::zeros(3, 4, CV_64FC1);   // rotation-translation matrix
+
+}
+
+PnPProblem::~PnPProblem()
+{
+    // TODO Auto-generated destructor stub
+}
+
+void PnPProblem::set_P_matrix( const cv::Mat &R_matrix, const cv::Mat &t_matrix)
+{
+    // Rotation-Translation Matrix Definition
+    P_matrix_.at<double>(0,0) = R_matrix.at<double>(0,0);
+    P_matrix_.at<double>(0,1) = R_matrix.at<double>(0,1);
+    P_matrix_.at<double>(0,2) = R_matrix.at<double>(0,2);
+    P_matrix_.at<double>(1,0) = R_matrix.at<double>(1,0);
+    P_matrix_.at<double>(1,1) = R_matrix.at<double>(1,1);
+    P_matrix_.at<double>(1,2) = R_matrix.at<double>(1,2);
+    P_matrix_.at<double>(2,0) = R_matrix.at<double>(2,0);
+    P_matrix_.at<double>(2,1) = R_matrix.at<double>(2,1);
+    P_matrix_.at<double>(2,2) = R_matrix.at<double>(2,2);
+    P_matrix_.at<double>(0,3) = t_matrix.at<double>(0);
+    P_matrix_.at<double>(1,3) = t_matrix.at<double>(1);
+    P_matrix_.at<double>(2,3) = t_matrix.at<double>(2);
+}
+
+// Estimate the pose given a list of 2D/3D correspondences and the method to use
+bool PnPProblem::estimatePose( const std::vector<cv::Point3f> &list_points3d,
+                               const std::vector<cv::Point2f> &list_points2d,
+                               int flags)
+{
+    cv::Mat distCoeffs = cv::Mat::zeros(4, 1, CV_64FC1);
+    cv::Mat rvec = cv::Mat::zeros(3, 1, CV_64FC1);
+    cv::Mat tvec = cv::Mat::zeros(3, 1, CV_64FC1);
+
+    bool useExtrinsicGuess = false;
+
+    // Pose estimation
+    bool correspondence = cv::solvePnP( list_points3d, list_points2d, A_matrix_, distCoeffs, rvec, tvec,
+                                        useExtrinsicGuess, flags);
+
+    // Transforms Rotation Vector to Matrix
+    Rodrigues(rvec, R_matrix_);
+    t_matrix_ = tvec;
+
+    // Set projection matrix
+    this->set_P_matrix(R_matrix_, t_matrix_);
+
+    return correspondence;
+}
+
+// Estimate the pose given a list of 2D/3D correspondences with RANSAC and the method to use
+
+void PnPProblem::estimatePoseRANSAC( const std::vector<cv::Point3f> &list_points3d, // list with model 3D coordinates
+                                     const std::vector<cv::Point2f> &list_points2d,     // list with scene 2D coordinates
+                                     int flags, cv::Mat &inliers, int iterationsCount,  // PnP method; inliers container
+                                     float reprojectionError, double confidence )    // Ransac parameters
+{
+    cv::Mat distCoeffs = cv::Mat::zeros(4, 1, CV_64FC1);  // vector of distortion coefficients
+    cv::Mat rvec = cv::Mat::zeros(3, 1, CV_64FC1);          // output rotation vector
+    cv::Mat tvec = cv::Mat::zeros(3, 1, CV_64FC1);    // output translation vector
+
+    bool useExtrinsicGuess = false;   // if true the function uses the provided rvec and tvec values as
+    // initial approximations of the rotation and translation vectors
+
+    cv::solvePnPRansac( list_points3d, list_points2d, A_matrix_, distCoeffs, rvec, tvec,
+                        useExtrinsicGuess, iterationsCount, reprojectionError, confidence,
+                        inliers, flags );
+
+    Rodrigues(rvec, R_matrix_); // converts Rotation Vector to Matrix
+    t_matrix_ = tvec;           // set translation matrix
+
+    this->set_P_matrix(R_matrix_, t_matrix_); // set rotation-translation matrix
+
+}
+
+// Given the mesh, backproject the 3D points to 2D to verify the pose estimation
+std::vector<cv::Point2f> PnPProblem::verify_points(Mesh *mesh)
+{
+    std::vector<cv::Point2f> verified_points_2d;
+    for( int i = 0; i < mesh->getNumVertices(); i++)
+    {
+        cv::Point3f point3d = mesh->getVertex(i);
+        cv::Point2f point2d = this->backproject3DPoint(point3d);
+        verified_points_2d.push_back(point2d);
+    }
+
+    return verified_points_2d;
+}
+
+// Backproject a 3D point to 2D using the estimated pose parameters
+cv::Point2f PnPProblem::backproject3DPoint(const cv::Point3f &point3d)
+{
+    // 3D point vector [x y z 1]'
+    cv::Mat point3d_vec = cv::Mat(4, 1, CV_64FC1);
+    point3d_vec.at<double>(0) = point3d.x;
+    point3d_vec.at<double>(1) = point3d.y;
+    point3d_vec.at<double>(2) = point3d.z;
+    point3d_vec.at<double>(3) = 1;
+
+    // 2D point vector [u v 1]'
+    cv::Mat point2d_vec = cv::Mat(4, 1, CV_64FC1);
+    point2d_vec = A_matrix_ * P_matrix_ * point3d_vec;
+
+    // Normalization of [u v]'
+    cv::Point2f point2d;
+    point2d.x = (float)(point2d_vec.at<double>(0) / point2d_vec.at<double>(2));
+    point2d.y = (float)(point2d_vec.at<double>(1) / point2d_vec.at<double>(2));
+
+    return point2d;
+}
+
+// Back project a 2D point to 3D and returns if it's on the object surface
+bool PnPProblem::backproject2DPoint(const Mesh *mesh, const cv::Point2f &point2d, cv::Point3f &point3d)
+{
+    // Triangles list of the object mesh
+    std::vector<std::vector<int> > triangles_list = mesh->getTrianglesList();
+
+    double lambda = 8;
+    double u = point2d.x;
+    double v = point2d.y;
+
+    // Point in vector form
+    cv::Mat point2d_vec = cv::Mat::ones(3, 1, CV_64F); // 3x1
+    point2d_vec.at<double>(0) = u * lambda;
+    point2d_vec.at<double>(1) = v * lambda;
+    point2d_vec.at<double>(2) = lambda;
+
+    // Point in camera coordinates
+    cv::Mat X_c = A_matrix_.inv() * point2d_vec ; // 3x1
+
+    // Point in world coordinates
+    cv::Mat X_w = R_matrix_.inv() * ( X_c - t_matrix_ ); // 3x1
+
+    // Center of projection
+    cv::Mat C_op = cv::Mat(R_matrix_.inv()).mul(-1) * t_matrix_; // 3x1
+
+    // Ray direction vector
+    cv::Mat ray = X_w - C_op; // 3x1
+    ray = ray / cv::norm(ray); // 3x1
+
+    // Set up Ray
+    Ray R((cv::Point3f)C_op, (cv::Point3f)ray);
+
+    // A vector to store the intersections found
+    std::vector<cv::Point3f> intersections_list;
+
+    // Loop for all the triangles and check the intersection
+    for (unsigned int i = 0; i < triangles_list.size(); i++)
+    {
+        cv::Point3f V0 = mesh->getVertex(triangles_list[i][0]);
+        cv::Point3f V1 = mesh->getVertex(triangles_list[i][1]);
+        cv::Point3f V2 = mesh->getVertex(triangles_list[i][2]);
+
+        Triangle T(V0, V1, V2);
+
+        double out;
+        if(this->intersect_MollerTrumbore(R, T, &out))
+        {
+            cv::Point3f tmp_pt = R.getP0() + out*R.getP1(); // P = O + t*D
+            intersections_list.push_back(tmp_pt);
+        }
+    }
+
+    // If there are intersection, find the nearest one
+    if (!intersections_list.empty())
+    {
+        point3d = get_nearest_3D_point(intersections_list, R.getP0());
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+// Möller-Trumbore intersection algorithm
+bool PnPProblem::intersect_MollerTrumbore(Ray &Ray, Triangle &Triangle, double *out)
+{
+    const double EPSILON = 0.000001;
+
+    cv::Point3f e1, e2;
+    cv::Point3f P, Q, T;
+    double det, inv_det, u, v;
+    double t;
+
+    cv::Point3f V1 = Triangle.getV0();  // Triangle vertices
+    cv::Point3f V2 = Triangle.getV1();
+    cv::Point3f V3 = Triangle.getV2();
+
+    cv::Point3f O = Ray.getP0(); // Ray origin
+    cv::Point3f D = Ray.getP1(); // Ray direction
+
+    //Find vectors for two edges sharing V1
+    e1 = SUB(V2, V1);
+    e2 = SUB(V3, V1);
+
+    // Begin calculation determinant - also used to calculate U parameter
+    P = CROSS(D, e2);
+
+    // If determinant is near zero, ray lie in plane of triangle
+    det = DOT(e1, P);
+
+    //NOT CULLING
+    if(det > -EPSILON && det < EPSILON) return false;
+    inv_det = 1.f / det;
+
+    //calculate distance from V1 to ray origin
+    T = SUB(O, V1);
+
+    //Calculate u parameter and test bound
+    u = DOT(T, P) * inv_det;
+
+    //The intersection lies outside of the triangle
+    if(u < 0.f || u > 1.f) return false;
+
+    //Prepare to test v parameter
+    Q = CROSS(T, e1);
+
+    //Calculate V parameter and test bound
+    v = DOT(D, Q) * inv_det;
+
+    //The intersection lies outside of the triangle
+    if(v < 0.f || u + v  > 1.f) return false;
+
+    t = DOT(e2, Q) * inv_det;
+
+    if(t > EPSILON) { //ray intersection
+        *out = t;
+        return true;
+    }
+
+    // No hit, no win
+    return false;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/PnPProblem.h b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/PnPProblem.h
new file mode 100644
index 00000000..b0bb31f2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/PnPProblem.h
@@ -0,0 +1,52 @@
+/*
+ * PnPProblem.h
+ *
+ *  Created on: Mar 28, 2014
+ *      Author: Edgar Riba
+ */
+
+#ifndef PNPPROBLEM_H_
+#define PNPPROBLEM_H_
+
+#include <iostream>
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+
+#include "Mesh.h"
+#include "ModelRegistration.h"
+
+class PnPProblem
+{
+public:
+    explicit PnPProblem(const double param[]);  // custom constructor
+    virtual ~PnPProblem();
+
+    bool backproject2DPoint(const Mesh *mesh, const cv::Point2f &point2d, cv::Point3f &point3d);
+    bool intersect_MollerTrumbore(Ray &R, Triangle &T, double *out);
+    std::vector<cv::Point2f> verify_points(Mesh *mesh);
+    cv::Point2f backproject3DPoint(const cv::Point3f &point3d);
+    bool estimatePose(const std::vector<cv::Point3f> &list_points3d, const std::vector<cv::Point2f> &list_points2d, int flags);
+    void estimatePoseRANSAC( const std::vector<cv::Point3f> &list_points3d, const std::vector<cv::Point2f> &list_points2d,
+                             int flags, cv::Mat &inliers,
+                             int iterationsCount, float reprojectionError, double confidence );
+
+    cv::Mat get_A_matrix() const { return A_matrix_; }
+    cv::Mat get_R_matrix() const { return R_matrix_; }
+    cv::Mat get_t_matrix() const { return t_matrix_; }
+    cv::Mat get_P_matrix() const { return P_matrix_; }
+
+    void set_P_matrix( const cv::Mat &R_matrix, const cv::Mat &t_matrix);
+
+private:
+    /** The calibration matrix */
+    cv::Mat A_matrix_;
+    /** The computed rotation matrix */
+    cv::Mat R_matrix_;
+    /** The computed translation matrix */
+    cv::Mat t_matrix_;
+    /** The computed projection matrix */
+    cv::Mat P_matrix_;
+};
+
+#endif /* PNPPROBLEM_H_ */
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/RobustMatcher.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/RobustMatcher.cpp
new file mode 100644
index 00000000..2cded406
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/RobustMatcher.cpp
@@ -0,0 +1,154 @@
+/*
+ * RobustMatcher.cpp
+ *
+ *  Created on: Jun 4, 2014
+ *      Author: eriba
+ */
+
+#include "RobustMatcher.h"
+#include <time.h>
+
+#include <opencv2/features2d/features2d.hpp>
+
+RobustMatcher::~RobustMatcher()
+{
+    // TODO Auto-generated destructor stub
+}
+
+void RobustMatcher::computeKeyPoints( const cv::Mat& image, std::vector<cv::KeyPoint>& keypoints)
+{
+    detector_->detect(image, keypoints);
+}
+
+void RobustMatcher::computeDescriptors( const cv::Mat& image, std::vector<cv::KeyPoint>& keypoints, cv::Mat& descriptors)
+{
+    extractor_->compute(image, keypoints, descriptors);
+}
+
+int RobustMatcher::ratioTest(std::vector<std::vector<cv::DMatch> > &matches)
+{
+    int removed = 0;
+    // for all matches
+    for ( std::vector<std::vector<cv::DMatch> >::iterator
+          matchIterator= matches.begin(); matchIterator!= matches.end(); ++matchIterator)
+    {
+        // if 2 NN has been identified
+        if (matchIterator->size() > 1)
+        {
+            // check distance ratio
+            if ((*matchIterator)[0].distance / (*matchIterator)[1].distance > ratio_)
+            {
+                matchIterator->clear(); // remove match
+                removed++;
+            }
+        }
+        else
+        { // does not have 2 neighbours
+            matchIterator->clear(); // remove match
+            removed++;
+        }
+    }
+    return removed;
+}
+
+void RobustMatcher::symmetryTest( const std::vector<std::vector<cv::DMatch> >& matches1,
+                                  const std::vector<std::vector<cv::DMatch> >& matches2,
+                                  std::vector<cv::DMatch>& symMatches )
+{
+    // for all matches image 1 -> image 2
+    for (std::vector<std::vector<cv::DMatch> >::const_iterator
+         matchIterator1 = matches1.begin(); matchIterator1 != matches1.end(); ++matchIterator1)
+    {
+        // ignore deleted matches
+        if (matchIterator1->empty() || matchIterator1->size() < 2)
+            continue;
+
+        // for all matches image 2 -> image 1
+        for (std::vector<std::vector<cv::DMatch> >::const_iterator
+             matchIterator2 = matches2.begin(); matchIterator2 != matches2.end(); ++matchIterator2)
+        {
+            // ignore deleted matches
+            if (matchIterator2->empty() || matchIterator2->size() < 2)
+                continue;
+
+            // Match symmetry test
+            if ((*matchIterator1)[0].queryIdx == (*matchIterator2)[0].trainIdx &&
+                (*matchIterator2)[0].queryIdx == (*matchIterator1)[0].trainIdx)
+            {
+                // add symmetrical match
+                symMatches.push_back(cv::DMatch((*matchIterator1)[0].queryIdx,
+                                     (*matchIterator1)[0].trainIdx, (*matchIterator1)[0].distance));
+                break; // next match in image 1 -> image 2
+            }
+        }
+    }
+}
+
+void RobustMatcher::robustMatch( const cv::Mat& frame, std::vector<cv::DMatch>& good_matches,
+                                 std::vector<cv::KeyPoint>& keypoints_frame, const cv::Mat& descriptors_model,
+                                 const std::vector<cv::KeyPoint>& keypoints_model)
+{
+    // 1a. Detection of the ORB features
+    this->computeKeyPoints(frame, keypoints_frame);
+
+    // 1b. Extraction of the ORB descriptors
+    cv::Mat descriptors_frame;
+    this->computeDescriptors(frame, keypoints_frame, descriptors_frame);
+
+    // 2. Match the two image descriptors
+    std::vector<std::vector<cv::DMatch> > matches12, matches21;
+
+    // 2a. From image 1 to image 2
+    matcher_->knnMatch(descriptors_frame, descriptors_model, matches12, 2); // return 2 nearest neighbours
+
+    // 2b. From image 2 to image 1
+    matcher_->knnMatch(descriptors_model, descriptors_frame, matches21, 2); // return 2 nearest neighbours
+
+    // 3. Remove matches for which NN ratio is > than threshold
+    // clean image 1 -> image 2 matches
+    ratioTest(matches12);
+    // clean image 2 -> image 1 matches
+    ratioTest(matches21);
+
+    // 4. Remove non-symmetrical matches
+    symmetryTest(matches12, matches21, good_matches);
+
+    if (!training_img_.empty() && !keypoints_model.empty())
+    {
+        cv::drawMatches(frame, keypoints_frame, training_img_, keypoints_model, good_matches, img_matching_);
+    }
+}
+
+void RobustMatcher::fastRobustMatch( const cv::Mat& frame, std::vector<cv::DMatch>& good_matches,
+                                     std::vector<cv::KeyPoint>& keypoints_frame,
+                                     const cv::Mat& descriptors_model,
+                                     const std::vector<cv::KeyPoint>& keypoints_model)
+{
+    good_matches.clear();
+
+    // 1a. Detection of the ORB features
+    this->computeKeyPoints(frame, keypoints_frame);
+
+    // 1b. Extraction of the ORB descriptors
+    cv::Mat descriptors_frame;
+    this->computeDescriptors(frame, keypoints_frame, descriptors_frame);
+
+    // 2. Match the two image descriptors
+    std::vector<std::vector<cv::DMatch> > matches;
+    matcher_->knnMatch(descriptors_frame, descriptors_model, matches, 2);
+
+    // 3. Remove matches for which NN ratio is > than threshold
+    ratioTest(matches);
+
+    // 4. Fill good matches container
+    for ( std::vector<std::vector<cv::DMatch> >::iterator
+          matchIterator= matches.begin(); matchIterator!= matches.end(); ++matchIterator)
+    {
+        if (!matchIterator->empty()) good_matches.push_back((*matchIterator)[0]);
+    }
+
+    if (!training_img_.empty() && !keypoints_model.empty())
+    {
+        cv::drawMatches(frame, keypoints_frame, training_img_, keypoints_model, good_matches, img_matching_);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/RobustMatcher.h b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/RobustMatcher.h
new file mode 100644
index 00000000..152dd7cd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/RobustMatcher.h
@@ -0,0 +1,92 @@
+/*
+ * RobustMatcher.h
+ *
+ *  Created on: Jun 4, 2014
+ *      Author: eriba
+ */
+
+#ifndef ROBUSTMATCHER_H_
+#define ROBUSTMATCHER_H_
+
+#include <iostream>
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/features2d/features2d.hpp>
+
+class RobustMatcher {
+public:
+    RobustMatcher() : detector_(), extractor_(), matcher_(),
+        ratio_(0.8f), training_img_(), img_matching_()
+    {
+        // ORB is the default feature
+        detector_ = cv::ORB::create();
+        extractor_ = cv::ORB::create();
+
+        // BruteFroce matcher with Norm Hamming is the default matcher
+        matcher_ = cv::makePtr<cv::BFMatcher>((int)cv::NORM_HAMMING, false);
+
+    }
+    virtual ~RobustMatcher();
+
+    // Set the feature detector
+    void setFeatureDetector(const cv::Ptr<cv::FeatureDetector>& detect) {  detector_ = detect; }
+
+    // Set the descriptor extractor
+    void setDescriptorExtractor(const cv::Ptr<cv::DescriptorExtractor>& desc) { extractor_ = desc; }
+
+    // Set the matcher
+    void setDescriptorMatcher(const cv::Ptr<cv::DescriptorMatcher>& match) {  matcher_ = match; }
+
+    // Compute the keypoints of an image
+    void computeKeyPoints( const cv::Mat& image, std::vector<cv::KeyPoint>& keypoints);
+
+    // Compute the descriptors of an image given its keypoints
+    void computeDescriptors( const cv::Mat& image, std::vector<cv::KeyPoint>& keypoints, cv::Mat& descriptors);
+
+    cv::Mat getImageMatching() const { return img_matching_; }
+
+    // Set ratio parameter for the ratio test
+    void setRatio( float rat) { ratio_ = rat; }
+
+    void setTrainingImage(const cv::Mat &img) { training_img_ = img; }
+
+    // Clear matches for which NN ratio is > than threshold
+    // return the number of removed points
+    // (corresponding entries being cleared,
+    // i.e. size will be 0)
+    int ratioTest(std::vector<std::vector<cv::DMatch> > &matches);
+
+    // Insert symmetrical matches in symMatches vector
+    void symmetryTest( const std::vector<std::vector<cv::DMatch> >& matches1,
+                       const std::vector<std::vector<cv::DMatch> >& matches2,
+                       std::vector<cv::DMatch>& symMatches );
+
+    // Match feature points using ratio and symmetry test
+    void robustMatch( const cv::Mat& frame, std::vector<cv::DMatch>& good_matches,
+                      std::vector<cv::KeyPoint>& keypoints_frame,
+                      const cv::Mat& descriptors_model,
+                      const std::vector<cv::KeyPoint>& keypoints_model);
+
+    // Match feature points using ratio test
+    void fastRobustMatch( const cv::Mat& frame, std::vector<cv::DMatch>& good_matches,
+                          std::vector<cv::KeyPoint>& keypoints_frame,
+                          const cv::Mat& descriptors_model,
+                          const std::vector<cv::KeyPoint>& keypoints_model);
+
+private:
+    // pointer to the feature point detector object
+    cv::Ptr<cv::FeatureDetector> detector_;
+    // pointer to the feature descriptor extractor object
+    cv::Ptr<cv::DescriptorExtractor> extractor_;
+    // pointer to the matcher object
+    cv::Ptr<cv::DescriptorMatcher> matcher_;
+    // max ratio between 1st and 2nd NN
+    float ratio_;
+    // training image
+    cv::Mat training_img_;
+    // matching image
+    cv::Mat img_matching_;
+};
+
+#endif /* ROBUSTMATCHER_H_ */
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.cpp
new file mode 100644
index 00000000..6b1d5533
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.cpp
@@ -0,0 +1,394 @@
+/*
+ * Utils.cpp
+ *
+ *  Created on: Mar 28, 2014
+ *      Author: Edgar Riba
+ */
+
+#include <iostream>
+
+#include "PnPProblem.h"
+#include "ModelRegistration.h"
+#include "Utils.h"
+
+#include <opencv2/opencv_modules.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/calib3d.hpp>
+#include <opencv2/flann.hpp>
+#if defined (HAVE_OPENCV_XFEATURES2D)
+#include <opencv2/xfeatures2d.hpp>
+#endif
+
+// For text
+const int fontFace = cv::FONT_ITALIC;
+const double fontScale = 0.75;
+const int thickness_font = 2;
+
+// For circles
+const int lineType = 8;
+const int radius = 4;
+
+// Draw a text with the question point
+void drawQuestion(cv::Mat image, cv::Point3f point, cv::Scalar color)
+{
+    std::string x = IntToString((int)point.x);
+    std::string y = IntToString((int)point.y);
+    std::string z = IntToString((int)point.z);
+
+    std::string text = " Where is point (" + x + ","  + y + "," + z + ") ?";
+    cv::putText(image, text, cv::Point(25,50), fontFace, fontScale, color, thickness_font, 8);
+}
+
+// Draw a text with the number of entered points
+void drawText(cv::Mat image, std::string text, cv::Scalar color)
+{
+    cv::putText(image, text, cv::Point(25,50), fontFace, fontScale, color, thickness_font, 8);
+}
+
+// Draw a text with the number of entered points
+void drawText2(cv::Mat image, std::string text, cv::Scalar color)
+{
+    cv::putText(image, text, cv::Point(25,75), fontFace, fontScale, color, thickness_font, 8);
+}
+
+// Draw a text with the frame ratio
+void drawFPS(cv::Mat image, double fps, cv::Scalar color)
+{
+    std::string fps_str = cv::format("%.2f FPS", fps);
+    cv::putText(image, fps_str, cv::Point(500,50), fontFace, fontScale, color, thickness_font, 8);
+}
+
+// Draw a text with the frame ratio
+void drawConfidence(cv::Mat image, double confidence, cv::Scalar color)
+{
+    std::string conf_str = IntToString((int)confidence);
+    std::string text = conf_str + " %";
+    cv::putText(image, text, cv::Point(500,75), fontFace, fontScale, color, thickness_font, 8);
+}
+
+// Draw a text with the number of entered points
+void drawCounter(cv::Mat image, int n, int n_max, cv::Scalar color)
+{
+    std::string n_str = IntToString(n);
+    std::string n_max_str = IntToString(n_max);
+    std::string text = n_str + " of " + n_max_str + " points";
+    cv::putText(image, text, cv::Point(500,50), fontFace, fontScale, color, thickness_font, 8);
+}
+
+// Draw the points and the coordinates
+void drawPoints(cv::Mat image, std::vector<cv::Point2f> &list_points_2d, std::vector<cv::Point3f> &list_points_3d, cv::Scalar color)
+{
+    for (unsigned int i = 0; i < list_points_2d.size(); ++i)
+    {
+        cv::Point2f point_2d = list_points_2d[i];
+        cv::Point3f point_3d = list_points_3d[i];
+
+        // Draw Selected points
+        cv::circle(image, point_2d, radius, color, -1, lineType );
+
+        std::string idx = IntToString(i+1);
+        std::string x = IntToString((int)point_3d.x);
+        std::string y = IntToString((int)point_3d.y);
+        std::string z = IntToString((int)point_3d.z);
+        std::string text = "P" + idx + " (" + x + "," + y + "," + z +")";
+
+        point_2d.x = point_2d.x + 10;
+        point_2d.y = point_2d.y - 10;
+        cv::putText(image, text, point_2d, fontFace, fontScale*0.5, color, thickness_font, 8);
+    }
+}
+
+// Draw only the 2D points
+void draw2DPoints(cv::Mat image, std::vector<cv::Point2f> &list_points, cv::Scalar color)
+{
+    for( size_t i = 0; i < list_points.size(); i++)
+    {
+        cv::Point2f point_2d = list_points[i];
+
+        // Draw Selected points
+        cv::circle(image, point_2d, radius, color, -1, lineType );
+    }
+}
+
+// Draw an arrow into the image
+void drawArrow(cv::Mat image, cv::Point2i p, cv::Point2i q, cv::Scalar color, int arrowMagnitude, int thickness, int line_type, int shift)
+{
+    //Draw the principle line
+    cv::line(image, p, q, color, thickness, line_type, shift);
+    const double PI = CV_PI;
+    //compute the angle alpha
+    double angle = atan2((double)p.y-q.y, (double)p.x-q.x);
+    //compute the coordinates of the first segment
+    p.x = (int) ( q.x +  arrowMagnitude * cos(angle + PI/4));
+    p.y = (int) ( q.y +  arrowMagnitude * sin(angle + PI/4));
+    //Draw the first segment
+    cv::line(image, p, q, color, thickness, line_type, shift);
+    //compute the coordinates of the second segment
+    p.x = (int) ( q.x +  arrowMagnitude * cos(angle - PI/4));
+    p.y = (int) ( q.y +  arrowMagnitude * sin(angle - PI/4));
+    //Draw the second segment
+    cv::line(image, p, q, color, thickness, line_type, shift);
+}
+
+// Draw the 3D coordinate axes
+void draw3DCoordinateAxes(cv::Mat image, const std::vector<cv::Point2f> &list_points2d)
+{
+    cv::Scalar red(0, 0, 255);
+    cv::Scalar green(0,255,0);
+    cv::Scalar blue(255,0,0);
+    cv::Scalar black(0,0,0);
+
+    cv::Point2i origin = list_points2d[0];
+    cv::Point2i pointX = list_points2d[1];
+    cv::Point2i pointY = list_points2d[2];
+    cv::Point2i pointZ = list_points2d[3];
+
+    drawArrow(image, origin, pointX, red, 9, 2);
+    drawArrow(image, origin, pointY, green, 9, 2);
+    drawArrow(image, origin, pointZ, blue, 9, 2);
+    cv::circle(image, origin, radius/2, black, -1, lineType );
+}
+
+// Draw the object mesh
+void drawObjectMesh(cv::Mat image, const Mesh *mesh, PnPProblem *pnpProblem, cv::Scalar color)
+{
+    std::vector<std::vector<int> > list_triangles = mesh->getTrianglesList();
+    for( size_t i = 0; i < list_triangles.size(); i++)
+    {
+        std::vector<int> tmp_triangle = list_triangles.at(i);
+
+        cv::Point3f point_3d_0 = mesh->getVertex(tmp_triangle[0]);
+        cv::Point3f point_3d_1 = mesh->getVertex(tmp_triangle[1]);
+        cv::Point3f point_3d_2 = mesh->getVertex(tmp_triangle[2]);
+
+        cv::Point2f point_2d_0 = pnpProblem->backproject3DPoint(point_3d_0);
+        cv::Point2f point_2d_1 = pnpProblem->backproject3DPoint(point_3d_1);
+        cv::Point2f point_2d_2 = pnpProblem->backproject3DPoint(point_3d_2);
+
+        cv::line(image, point_2d_0, point_2d_1, color, 1);
+        cv::line(image, point_2d_1, point_2d_2, color, 1);
+        cv::line(image, point_2d_2, point_2d_0, color, 1);
+    }
+}
+
+// Computes the norm of the translation error
+double get_translation_error(const cv::Mat &t_true, const cv::Mat &t)
+{
+    return cv::norm( t_true - t );
+}
+
+// Computes the norm of the rotation error
+double get_rotation_error(const cv::Mat &R_true, const cv::Mat &R)
+{
+    cv::Mat error_vec, error_mat;
+    error_mat = -R_true * R.t();
+    cv::Rodrigues(error_mat, error_vec);
+
+    return cv::norm(error_vec);
+}
+
+// Converts a given Rotation Matrix to Euler angles
+// Convention used is Y-Z-X Tait-Bryan angles
+// Reference code implementation:
+// https://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToEuler/index.htm
+cv::Mat rot2euler(const cv::Mat & rotationMatrix)
+{
+    cv::Mat euler(3,1,CV_64F);
+
+    double m00 = rotationMatrix.at<double>(0,0);
+    double m02 = rotationMatrix.at<double>(0,2);
+    double m10 = rotationMatrix.at<double>(1,0);
+    double m11 = rotationMatrix.at<double>(1,1);
+    double m12 = rotationMatrix.at<double>(1,2);
+    double m20 = rotationMatrix.at<double>(2,0);
+    double m22 = rotationMatrix.at<double>(2,2);
+
+    double bank, attitude, heading;
+
+    // Assuming the angles are in radians.
+    if (m10 > 0.998) { // singularity at north pole
+        bank = 0;
+        attitude = CV_PI/2;
+        heading = atan2(m02,m22);
+    }
+    else if (m10 < -0.998) { // singularity at south pole
+        bank = 0;
+        attitude = -CV_PI/2;
+        heading = atan2(m02,m22);
+    }
+    else
+    {
+        bank = atan2(-m12,m11);
+        attitude = asin(m10);
+        heading = atan2(-m20,m00);
+    }
+
+    euler.at<double>(0) = bank;
+    euler.at<double>(1) = attitude;
+    euler.at<double>(2) = heading;
+
+    return euler;
+}
+
+// Converts a given Euler angles to Rotation Matrix
+// Convention used is Y-Z-X Tait-Bryan angles
+// Reference:
+// https://www.euclideanspace.com/maths/geometry/rotations/conversions/eulerToMatrix/index.htm
+cv::Mat euler2rot(const cv::Mat & euler)
+{
+    cv::Mat rotationMatrix(3,3,CV_64F);
+
+    double bank = euler.at<double>(0);
+    double attitude = euler.at<double>(1);
+    double heading = euler.at<double>(2);
+
+    // Assuming the angles are in radians.
+    double ch = cos(heading);
+    double sh = sin(heading);
+    double ca = cos(attitude);
+    double sa = sin(attitude);
+    double cb = cos(bank);
+    double sb = sin(bank);
+
+    double m00, m01, m02, m10, m11, m12, m20, m21, m22;
+
+    m00 = ch * ca;
+    m01 = sh*sb - ch*sa*cb;
+    m02 = ch*sa*sb + sh*cb;
+    m10 = sa;
+    m11 = ca*cb;
+    m12 = -ca*sb;
+    m20 = -sh*ca;
+    m21 = sh*sa*cb + ch*sb;
+    m22 = -sh*sa*sb + ch*cb;
+
+    rotationMatrix.at<double>(0,0) = m00;
+    rotationMatrix.at<double>(0,1) = m01;
+    rotationMatrix.at<double>(0,2) = m02;
+    rotationMatrix.at<double>(1,0) = m10;
+    rotationMatrix.at<double>(1,1) = m11;
+    rotationMatrix.at<double>(1,2) = m12;
+    rotationMatrix.at<double>(2,0) = m20;
+    rotationMatrix.at<double>(2,1) = m21;
+    rotationMatrix.at<double>(2,2) = m22;
+
+    return rotationMatrix;
+}
+
+// Converts a given string to an integer
+int StringToInt ( const std::string &Text )
+{
+    std::istringstream ss(Text);
+    int result;
+    return ss >> result ? result : 0;
+}
+
+// Converts a given float to a string
+std::string FloatToString ( float Number )
+{
+    std::ostringstream ss;
+    ss << Number;
+    return ss.str();
+}
+
+// Converts a given integer to a string
+std::string IntToString ( int Number )
+{
+    std::ostringstream ss;
+    ss << Number;
+    return ss.str();
+}
+
+void createFeatures(const std::string &featureName, int numKeypoints, cv::Ptr<cv::Feature2D> &detector, cv::Ptr<cv::Feature2D> &descriptor)
+{
+    if (featureName == "ORB")
+    {
+        detector = cv::ORB::create(numKeypoints);
+        descriptor = cv::ORB::create(numKeypoints);
+    }
+    else if (featureName == "KAZE")
+    {
+        detector = cv::KAZE::create();
+        descriptor = cv::KAZE::create();
+    }
+    else if (featureName == "AKAZE")
+    {
+        detector = cv::AKAZE::create();
+        descriptor = cv::AKAZE::create();
+    }
+    else if (featureName == "BRISK")
+    {
+        detector = cv::BRISK::create();
+        descriptor = cv::BRISK::create();
+    }
+    else if (featureName == "SIFT")
+    {
+        detector = cv::SIFT::create();
+        descriptor = cv::SIFT::create();
+    }
+    else if (featureName == "SURF")
+    {
+#if defined (OPENCV_ENABLE_NONFREE) && defined (HAVE_OPENCV_XFEATURES2D)
+        detector = cv::xfeatures2d::SURF::create(100, 4, 3, true);   //extended=true
+        descriptor = cv::xfeatures2d::SURF::create(100, 4, 3, true); //extended=true
+#else
+        std::cout << "xfeatures2d module is not available or nonfree is not enabled." << std::endl;
+        std::cout << "Default to ORB." << std::endl;
+        detector = cv::ORB::create(numKeypoints);
+        descriptor = cv::ORB::create(numKeypoints);
+#endif
+    }
+    else if (featureName == "BINBOOST")
+    {
+#if defined (HAVE_OPENCV_XFEATURES2D)
+        detector = cv::KAZE::create();
+        descriptor = cv::xfeatures2d::BoostDesc::create();
+#else
+        std::cout << "xfeatures2d module is not available." << std::endl;
+        std::cout << "Default to ORB." << std::endl;
+        detector = cv::ORB::create(numKeypoints);
+        descriptor = cv::ORB::create(numKeypoints);
+#endif
+    }
+    else if (featureName == "VGG")
+    {
+#if defined (HAVE_OPENCV_XFEATURES2D)
+        detector = cv::KAZE::create();
+        descriptor = cv::xfeatures2d::VGG::create();
+#else
+        std::cout << "xfeatures2d module is not available." << std::endl;
+        std::cout << "Default to ORB." << std::endl;
+        detector = cv::ORB::create(numKeypoints);
+        descriptor = cv::ORB::create(numKeypoints);
+#endif
+    }
+}
+
+cv::Ptr<cv::DescriptorMatcher> createMatcher(const std::string &featureName, bool useFLANN)
+{
+    if (featureName == "ORB" || featureName == "BRISK" || featureName == "AKAZE" || featureName == "BINBOOST")
+    {
+        if (useFLANN)
+        {
+            cv::Ptr<cv::flann::IndexParams> indexParams = cv::makePtr<cv::flann::LshIndexParams>(6, 12, 1); // instantiate LSH index parameters
+            cv::Ptr<cv::flann::SearchParams> searchParams = cv::makePtr<cv::flann::SearchParams>(50);       // instantiate flann search parameters
+            return cv::makePtr<cv::FlannBasedMatcher>(indexParams, searchParams);
+        }
+        else
+        {
+            return cv::DescriptorMatcher::create("BruteForce-Hamming");
+        }
+
+    }
+    else
+    {
+        if (useFLANN)
+        {
+            return cv::DescriptorMatcher::create("FlannBased");
+        }
+        else
+        {
+            return cv::DescriptorMatcher::create("BruteForce");
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.h b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.h
new file mode 100644
index 00000000..18a59855
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.h
@@ -0,0 +1,74 @@
+/*
+ * Utils.h
+ *
+ *  Created on: Mar 28, 2014
+ *      Author: Edgar Riba
+ */
+
+#ifndef UTILS_H_
+#define UTILS_H_
+
+#include <iostream>
+
+#include <opencv2/features2d.hpp>
+#include "PnPProblem.h"
+
+// Draw a text with the question point
+void drawQuestion(cv::Mat image, cv::Point3f point, cv::Scalar color);
+
+// Draw a text with the number of entered points
+void drawText(cv::Mat image, std::string text, cv::Scalar color);
+
+// Draw a text with the number of entered points
+void drawText2(cv::Mat image, std::string text, cv::Scalar color);
+
+// Draw a text with the frame ratio
+void drawFPS(cv::Mat image, double fps, cv::Scalar color);
+
+// Draw a text with the frame ratio
+void drawConfidence(cv::Mat image, double confidence, cv::Scalar color);
+
+// Draw a text with the number of entered points
+void drawCounter(cv::Mat image, int n, int n_max, cv::Scalar color);
+
+// Draw the points and the coordinates
+void drawPoints(cv::Mat image, std::vector<cv::Point2f> &list_points_2d, std::vector<cv::Point3f> &list_points_3d, cv::Scalar color);
+
+// Draw only the 2D points
+void draw2DPoints(cv::Mat image, std::vector<cv::Point2f> &list_points, cv::Scalar color);
+
+// Draw an arrow into the image
+void drawArrow(cv::Mat image, cv::Point2i p, cv::Point2i q, cv::Scalar color, int arrowMagnitude = 9, int thickness=1, int line_type=8, int shift=0);
+
+// Draw the 3D coordinate axes
+void draw3DCoordinateAxes(cv::Mat image, const std::vector<cv::Point2f> &list_points2d);
+
+// Draw the object mesh
+void drawObjectMesh(cv::Mat image, const Mesh *mesh, PnPProblem *pnpProblem, cv::Scalar color);
+
+// Computes the norm of the translation error
+double get_translation_error(const cv::Mat &t_true, const cv::Mat &t);
+
+// Computes the norm of the rotation error
+double get_rotation_error(const cv::Mat &R_true, const cv::Mat &R);
+
+// Converts a given Rotation Matrix to Euler angles
+cv::Mat rot2euler(const cv::Mat & rotationMatrix);
+
+// Converts a given Euler angles to Rotation Matrix
+cv::Mat euler2rot(const cv::Mat & euler);
+
+// Converts a given string to an integer
+int StringToInt ( const std::string &Text );
+
+// Converts a given float to a string
+std::string FloatToString ( float Number );
+
+// Converts a given integer to a string
+std::string IntToString ( int Number );
+
+void createFeatures(const std::string &featureName, int numKeypoints, cv::Ptr<cv::Feature2D> &detector, cv::Ptr<cv::Feature2D> &descriptor);
+
+cv::Ptr<cv::DescriptorMatcher> createMatcher(const std::string &featureName, bool useFLANN);
+
+#endif /* UTILS_H_ */
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_detection.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_detection.cpp
new file mode 100644
index 00000000..6da977a5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_detection.cpp
@@ -0,0 +1,501 @@
+// C++
+#include <iostream>
+// OpenCV
+#include <opencv2/core.hpp>
+#include <opencv2/core/utils/filesystem.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/calib3d.hpp>
+#include <opencv2/video/tracking.hpp>
+// PnP Tutorial
+#include "Mesh.h"
+#include "Model.h"
+#include "PnPProblem.h"
+#include "RobustMatcher.h"
+#include "ModelRegistration.h"
+#include "Utils.h"
+
+/**  GLOBAL VARIABLES  **/
+
+using namespace cv;
+using namespace std;
+
+/**  Functions headers  **/
+void help();
+void initKalmanFilter( KalmanFilter &KF, int nStates, int nMeasurements, int nInputs, double dt);
+void predictKalmanFilter( KalmanFilter &KF, Mat &translation_predicted, Mat &rotation_predicted );
+void updateKalmanFilter( KalmanFilter &KF, Mat &measurements,
+                         Mat &translation_estimated, Mat &rotation_estimated );
+void fillMeasurements( Mat &measurements,
+                       const Mat &translation_measured, const Mat &rotation_measured);
+
+/**  Main program  **/
+int main(int argc, char *argv[])
+{
+    help();
+
+    const String keys =
+            "{help h            |      | print this message                                                 }"
+            "{video v           |      | path to recorded video                                             }"
+            "{model             |      | path to yml model                                                  }"
+            "{mesh              |      | path to ply mesh                                                   }"
+            "{keypoints k       |2000  | number of keypoints to detect                                      }"
+            "{ratio r           |0.7   | threshold for ratio test                                           }"
+            "{iterations it     |500   | RANSAC maximum iterations count                                    }"
+            "{error e           |6.0   | RANSAC reprojection error                                          }"
+            "{confidence c      |0.99  | RANSAC confidence                                                  }"
+            "{inliers in        |30    | minimum inliers for Kalman update                                  }"
+            "{method  pnp       |0     | PnP method: (0) ITERATIVE - (1) EPNP - (2) P3P - (3) DLS - (5) AP3P}"
+            "{fast f            |true  | use of robust fast match                                           }"
+            "{feature           |ORB   | feature name (ORB, KAZE, AKAZE, BRISK, SIFT, SURF, BINBOOST, VGG)  }"
+            "{FLANN             |false | use FLANN library for descriptors matching                         }"
+            "{save              |      | path to the directory where to save the image results              }"
+            "{displayFiltered   |false | display filtered pose (from Kalman filter)                         }"
+            ;
+    CommandLineParser parser(argc, argv, keys);
+
+    string video_read_path = samples::findFile("samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/box.mp4");       // recorded video
+    string yml_read_path = samples::findFile("samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/cookies_ORB.yml"); // 3dpts + descriptors
+    string ply_read_path = samples::findFile("samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/box.ply");         // mesh
+
+    // Intrinsic camera parameters: UVC WEBCAM
+    double f = 55;                           // focal length in mm
+    double sx = 22.3, sy = 14.9;             // sensor size
+    double width = 640, height = 480;        // image size
+
+    double params_WEBCAM[] = { width*f/sx,   // fx
+                               height*f/sy,  // fy
+                               width/2,      // cx
+                               height/2};    // cy
+
+    // Some basic colors
+    Scalar red(0, 0, 255);
+    Scalar green(0,255,0);
+    Scalar blue(255,0,0);
+    Scalar yellow(0,255,255);
+
+    // Robust Matcher parameters
+    int numKeyPoints = 2000;      // number of detected keypoints
+    float ratioTest = 0.70f;      // ratio test
+    bool fast_match = true;       // fastRobustMatch() or robustMatch()
+
+    // RANSAC parameters
+    int iterationsCount = 500;      // number of Ransac iterations.
+    float reprojectionError = 6.0;  // maximum allowed distance to consider it an inlier.
+    double confidence = 0.99;       // ransac successful confidence.
+
+    // Kalman Filter parameters
+    int minInliersKalman = 30;    // Kalman threshold updating
+
+    // PnP parameters
+    int pnpMethod = SOLVEPNP_ITERATIVE;
+    string featureName = "ORB";
+    bool useFLANN = false;
+
+    // Save results
+    string saveDirectory = "";
+    Mat frameSave;
+    int frameCount = 0;
+
+    bool displayFilteredPose = false;
+
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    else
+    {
+        video_read_path = parser.get<string>("video").size() > 0 ? parser.get<string>("video") : video_read_path;
+        yml_read_path = parser.get<string>("model").size() > 0 ? parser.get<string>("model") : yml_read_path;
+        ply_read_path = parser.get<string>("mesh").size() > 0 ? parser.get<string>("mesh") : ply_read_path;
+        numKeyPoints = parser.has("keypoints") ? parser.get<int>("keypoints") : numKeyPoints;
+        ratioTest = parser.has("ratio") ? parser.get<float>("ratio") : ratioTest;
+        fast_match = parser.has("fast") ? parser.get<bool>("fast") : fast_match;
+        iterationsCount = parser.has("iterations") ? parser.get<int>("iterations") : iterationsCount;
+        reprojectionError = parser.has("error") ? parser.get<float>("error") : reprojectionError;
+        confidence = parser.has("confidence") ? parser.get<float>("confidence") : confidence;
+        minInliersKalman = parser.has("inliers") ? parser.get<int>("inliers") : minInliersKalman;
+        pnpMethod = parser.has("method") ? parser.get<int>("method") : pnpMethod;
+        featureName = parser.has("feature") ? parser.get<string>("feature") : featureName;
+        useFLANN = parser.has("FLANN") ? parser.get<bool>("FLANN") : useFLANN;
+        saveDirectory = parser.has("save") ? parser.get<string>("save") : saveDirectory;
+        displayFilteredPose = parser.has("displayFiltered") ? parser.get<bool>("displayFiltered") : displayFilteredPose;
+    }
+
+    std::cout << "Video: " << video_read_path << std::endl;
+    std::cout << "Training data: " << yml_read_path << std::endl;
+    std::cout << "CAD model: " << ply_read_path << std::endl;
+    std::cout << "Ratio test threshold: " << ratioTest << std::endl;
+    std::cout << "Fast match(no symmetry test)?: " << fast_match << std::endl;
+    std::cout << "RANSAC number of iterations: " << iterationsCount << std::endl;
+    std::cout << "RANSAC reprojection error: " << reprojectionError << std::endl;
+    std::cout << "RANSAC confidence threshold: " << confidence << std::endl;
+    std::cout << "Kalman number of inliers: " << minInliersKalman << std::endl;
+    std::cout << "PnP method: " << pnpMethod << std::endl;
+    std::cout << "Feature: " << featureName << std::endl;
+    std::cout << "Number of keypoints for ORB: " << numKeyPoints << std::endl;
+    std::cout << "Use FLANN-based matching? " << useFLANN << std::endl;
+    std::cout << "Save directory: " << saveDirectory << std::endl;
+    std::cout << "Display filtered pose from Kalman filter? " << displayFilteredPose << std::endl;
+
+    PnPProblem pnp_detection(params_WEBCAM);
+    PnPProblem pnp_detection_est(params_WEBCAM);
+
+    Model model;               // instantiate Model object
+    model.load(yml_read_path); // load a 3D textured object model
+
+    Mesh mesh;                 // instantiate Mesh object
+    mesh.load(ply_read_path);  // load an object mesh
+
+    RobustMatcher rmatcher;                                                     // instantiate RobustMatcher
+
+    Ptr<FeatureDetector> detector, descriptor;
+    createFeatures(featureName, numKeyPoints, detector, descriptor);
+    rmatcher.setFeatureDetector(detector);                                      // set feature detector
+    rmatcher.setDescriptorExtractor(descriptor);                                // set descriptor extractor
+    rmatcher.setDescriptorMatcher(createMatcher(featureName, useFLANN));        // set matcher
+    rmatcher.setRatio(ratioTest); // set ratio test parameter
+    if (!model.get_trainingImagePath().empty())
+    {
+        Mat trainingImg = imread(model.get_trainingImagePath());
+        rmatcher.setTrainingImage(trainingImg);
+    }
+
+    KalmanFilter KF;             // instantiate Kalman Filter
+    int nStates = 18;            // the number of states
+    int nMeasurements = 6;       // the number of measured states
+    int nInputs = 0;             // the number of control actions
+    double dt = 0.125;           // time between measurements (1/FPS)
+
+    initKalmanFilter(KF, nStates, nMeasurements, nInputs, dt);    // init function
+    Mat measurements(nMeasurements, 1, CV_64FC1); measurements.setTo(Scalar(0));
+    bool good_measurement = false;
+
+    // Get the MODEL INFO
+    vector<Point3f> list_points3d_model = model.get_points3d();  // list with model 3D coordinates
+    Mat descriptors_model = model.get_descriptors();             // list with descriptors of each 3D coordinate
+    vector<KeyPoint> keypoints_model = model.get_keypoints();
+
+    // Create & Open Window
+    namedWindow("REAL TIME DEMO", WINDOW_KEEPRATIO);
+
+    VideoCapture cap;                           // instantiate VideoCapture
+    cap.open(video_read_path);                  // open a recorded video
+
+    if(!cap.isOpened())   // check if we succeeded
+    {
+        cout << "Could not open the camera device" << endl;
+        return -1;
+    }
+
+    if (!saveDirectory.empty())
+    {
+        if (!cv::utils::fs::exists(saveDirectory))
+        {
+            std::cout << "Create directory: " << saveDirectory << std::endl;
+            cv::utils::fs::createDirectories(saveDirectory);
+        }
+    }
+
+    // Measure elapsed time
+    TickMeter tm;
+
+    Mat frame, frame_vis, frame_matching;
+    while(cap.read(frame) && (char)waitKey(30) != 27) // capture frame until ESC is pressed
+    {
+        tm.reset();
+        tm.start();
+        frame_vis = frame.clone();    // refresh visualisation frame
+
+        // -- Step 1: Robust matching between model descriptors and scene descriptors
+        vector<DMatch> good_matches;       // to obtain the 3D points of the model
+        vector<KeyPoint> keypoints_scene;  // to obtain the 2D points of the scene
+
+        if(fast_match)
+        {
+            rmatcher.fastRobustMatch(frame, good_matches, keypoints_scene, descriptors_model, keypoints_model);
+        }
+        else
+        {
+            rmatcher.robustMatch(frame, good_matches, keypoints_scene, descriptors_model, keypoints_model);
+        }
+
+        frame_matching = rmatcher.getImageMatching();
+        if (!frame_matching.empty())
+        {
+            imshow("Keypoints matching", frame_matching);
+        }
+
+        // -- Step 2: Find out the 2D/3D correspondences
+        vector<Point3f> list_points3d_model_match; // container for the model 3D coordinates found in the scene
+        vector<Point2f> list_points2d_scene_match; // container for the model 2D coordinates found in the scene
+
+        for(unsigned int match_index = 0; match_index < good_matches.size(); ++match_index)
+        {
+            Point3f point3d_model = list_points3d_model[ good_matches[match_index].trainIdx ];  // 3D point from model
+            Point2f point2d_scene = keypoints_scene[ good_matches[match_index].queryIdx ].pt; // 2D point from the scene
+            list_points3d_model_match.push_back(point3d_model);         // add 3D point
+            list_points2d_scene_match.push_back(point2d_scene);         // add 2D point
+        }
+
+        // Draw outliers
+        draw2DPoints(frame_vis, list_points2d_scene_match, red);
+
+        Mat inliers_idx;
+        vector<Point2f> list_points2d_inliers;
+
+        // Instantiate estimated translation and rotation
+        good_measurement = false;
+
+        if(good_matches.size() >= 4) // OpenCV requires solvePnPRANSAC to minimally have 4 set of points
+        {
+            // -- Step 3: Estimate the pose using RANSAC approach
+            pnp_detection.estimatePoseRANSAC( list_points3d_model_match, list_points2d_scene_match,
+                                              pnpMethod, inliers_idx,
+                                              iterationsCount, reprojectionError, confidence );
+
+            // -- Step 4: Catch the inliers keypoints to draw
+            for(int inliers_index = 0; inliers_index < inliers_idx.rows; ++inliers_index)
+            {
+                int n = inliers_idx.at<int>(inliers_index);         // i-inlier
+                Point2f point2d = list_points2d_scene_match[n];     // i-inlier point 2D
+                list_points2d_inliers.push_back(point2d);           // add i-inlier to list
+            }
+
+            // Draw inliers points 2D
+            draw2DPoints(frame_vis, list_points2d_inliers, blue);
+
+            // -- Step 5: Kalman Filter
+
+            // GOOD MEASUREMENT
+            if( inliers_idx.rows >= minInliersKalman )
+            {
+                // Get the measured translation
+                Mat translation_measured = pnp_detection.get_t_matrix();
+
+                // Get the measured rotation
+                Mat rotation_measured = pnp_detection.get_R_matrix();
+
+                // fill the measurements vector
+                fillMeasurements(measurements, translation_measured, rotation_measured);
+                good_measurement = true;
+            }
+
+            // update the Kalman filter with good measurements, otherwise with previous valid measurements
+            Mat translation_estimated(3, 1, CV_64FC1);
+            Mat rotation_estimated(3, 3, CV_64FC1);
+            updateKalmanFilter( KF, measurements,
+                                translation_estimated, rotation_estimated);
+
+            // -- Step 6: Set estimated projection matrix
+            pnp_detection_est.set_P_matrix(rotation_estimated, translation_estimated);
+        }
+
+        // -- Step X: Draw pose and coordinate frame
+        float l = 5;
+        vector<Point2f> pose_points2d;
+        if (!good_measurement || displayFilteredPose)
+        {
+            drawObjectMesh(frame_vis, &mesh, &pnp_detection_est, yellow); // draw estimated pose
+
+            pose_points2d.push_back(pnp_detection_est.backproject3DPoint(Point3f(0,0,0)));  // axis center
+            pose_points2d.push_back(pnp_detection_est.backproject3DPoint(Point3f(l,0,0)));  // axis x
+            pose_points2d.push_back(pnp_detection_est.backproject3DPoint(Point3f(0,l,0)));  // axis y
+            pose_points2d.push_back(pnp_detection_est.backproject3DPoint(Point3f(0,0,l)));  // axis z
+            draw3DCoordinateAxes(frame_vis, pose_points2d);           // draw axes
+        }
+        else
+        {
+            drawObjectMesh(frame_vis, &mesh, &pnp_detection, green);  // draw current pose
+
+            pose_points2d.push_back(pnp_detection.backproject3DPoint(Point3f(0,0,0)));  // axis center
+            pose_points2d.push_back(pnp_detection.backproject3DPoint(Point3f(l,0,0)));  // axis x
+            pose_points2d.push_back(pnp_detection.backproject3DPoint(Point3f(0,l,0)));  // axis y
+            pose_points2d.push_back(pnp_detection.backproject3DPoint(Point3f(0,0,l)));  // axis z
+            draw3DCoordinateAxes(frame_vis, pose_points2d);           // draw axes
+        }
+
+        // FRAME RATE
+        // see how much time has elapsed
+        tm.stop();
+
+        // calculate current FPS
+        double fps = 1.0 / tm.getTimeSec();
+
+        drawFPS(frame_vis, fps, yellow); // frame ratio
+        double detection_ratio = ((double)inliers_idx.rows/(double)good_matches.size())*100;
+        drawConfidence(frame_vis, detection_ratio, yellow);
+
+        // -- Step X: Draw some debugging text
+        // Draw some debug text
+        int inliers_int = inliers_idx.rows;
+        int outliers_int = (int)good_matches.size() - inliers_int;
+        string inliers_str = IntToString(inliers_int);
+        string outliers_str = IntToString(outliers_int);
+        string n = IntToString((int)good_matches.size());
+        string text = "Found " + inliers_str + " of " + n + " matches";
+        string text2 = "Inliers: " + inliers_str + " - Outliers: " + outliers_str;
+
+        drawText(frame_vis, text, green);
+        drawText2(frame_vis, text2, red);
+
+        imshow("REAL TIME DEMO", frame_vis);
+
+        if (!saveDirectory.empty())
+        {
+            const int widthSave = !frame_matching.empty() ? frame_matching.cols : frame_vis.cols;
+            const int heightSave = !frame_matching.empty() ? frame_matching.rows + frame_vis.rows : frame_vis.rows;
+            frameSave = Mat::zeros(heightSave, widthSave, CV_8UC3);
+            if (!frame_matching.empty())
+            {
+                int startX = (int)((widthSave - frame_vis.cols) / 2.0);
+                Mat roi = frameSave(Rect(startX, 0, frame_vis.cols, frame_vis.rows));
+                frame_vis.copyTo(roi);
+
+                roi = frameSave(Rect(0, frame_vis.rows, frame_matching.cols, frame_matching.rows));
+                frame_matching.copyTo(roi);
+            }
+            else
+            {
+                frame_vis.copyTo(frameSave);
+            }
+
+            string saveFilename = cv::format(string(saveDirectory + "/image_%04d.png").c_str(), frameCount);
+            imwrite(saveFilename, frameSave);
+            frameCount++;
+        }
+    }
+
+    // Close and Destroy Window
+    destroyWindow("REAL TIME DEMO");
+
+    cout << "GOODBYE ..." << endl;
+}
+
+/**********************************************************************************************************/
+void help()
+{
+    cout
+            << "--------------------------------------------------------------------------"   << endl
+            << "This program shows how to detect an object given its 3D textured model. You can choose to "
+            << "use a recorded video or the webcam."                                          << endl
+            << "Usage:"                                                                       << endl
+            << "./cpp-tutorial-pnp_detection -help"                                           << endl
+            << "Keys:"                                                                        << endl
+            << "'esc' - to quit."                                                             << endl
+            << "--------------------------------------------------------------------------"   << endl
+            << endl;
+}
+
+/**********************************************************************************************************/
+void initKalmanFilter(KalmanFilter &KF, int nStates, int nMeasurements, int nInputs, double dt)
+{
+    KF.init(nStates, nMeasurements, nInputs, CV_64F);                 // init Kalman Filter
+
+    setIdentity(KF.processNoiseCov, Scalar::all(1e-5));       // set process noise
+    setIdentity(KF.measurementNoiseCov, Scalar::all(1e-2));   // set measurement noise
+    setIdentity(KF.errorCovPost, Scalar::all(1));             // error covariance
+
+    /** DYNAMIC MODEL **/
+
+    //  [1 0 0 dt  0  0 dt2   0   0 0 0 0  0  0  0   0   0   0]
+    //  [0 1 0  0 dt  0   0 dt2   0 0 0 0  0  0  0   0   0   0]
+    //  [0 0 1  0  0 dt   0   0 dt2 0 0 0  0  0  0   0   0   0]
+    //  [0 0 0  1  0  0  dt   0   0 0 0 0  0  0  0   0   0   0]
+    //  [0 0 0  0  1  0   0  dt   0 0 0 0  0  0  0   0   0   0]
+    //  [0 0 0  0  0  1   0   0  dt 0 0 0  0  0  0   0   0   0]
+    //  [0 0 0  0  0  0   1   0   0 0 0 0  0  0  0   0   0   0]
+    //  [0 0 0  0  0  0   0   1   0 0 0 0  0  0  0   0   0   0]
+    //  [0 0 0  0  0  0   0   0   1 0 0 0  0  0  0   0   0   0]
+    //  [0 0 0  0  0  0   0   0   0 1 0 0 dt  0  0 dt2   0   0]
+    //  [0 0 0  0  0  0   0   0   0 0 1 0  0 dt  0   0 dt2   0]
+    //  [0 0 0  0  0  0   0   0   0 0 0 1  0  0 dt   0   0 dt2]
+    //  [0 0 0  0  0  0   0   0   0 0 0 0  1  0  0  dt   0   0]
+    //  [0 0 0  0  0  0   0   0   0 0 0 0  0  1  0   0  dt   0]
+    //  [0 0 0  0  0  0   0   0   0 0 0 0  0  0  1   0   0  dt]
+    //  [0 0 0  0  0  0   0   0   0 0 0 0  0  0  0   1   0   0]
+    //  [0 0 0  0  0  0   0   0   0 0 0 0  0  0  0   0   1   0]
+    //  [0 0 0  0  0  0   0   0   0 0 0 0  0  0  0   0   0   1]
+
+    // position
+    KF.transitionMatrix.at<double>(0,3) = dt;
+    KF.transitionMatrix.at<double>(1,4) = dt;
+    KF.transitionMatrix.at<double>(2,5) = dt;
+    KF.transitionMatrix.at<double>(3,6) = dt;
+    KF.transitionMatrix.at<double>(4,7) = dt;
+    KF.transitionMatrix.at<double>(5,8) = dt;
+    KF.transitionMatrix.at<double>(0,6) = 0.5*pow(dt,2);
+    KF.transitionMatrix.at<double>(1,7) = 0.5*pow(dt,2);
+    KF.transitionMatrix.at<double>(2,8) = 0.5*pow(dt,2);
+
+    // orientation
+    KF.transitionMatrix.at<double>(9,12) = dt;
+    KF.transitionMatrix.at<double>(10,13) = dt;
+    KF.transitionMatrix.at<double>(11,14) = dt;
+    KF.transitionMatrix.at<double>(12,15) = dt;
+    KF.transitionMatrix.at<double>(13,16) = dt;
+    KF.transitionMatrix.at<double>(14,17) = dt;
+    KF.transitionMatrix.at<double>(9,15) = 0.5*pow(dt,2);
+    KF.transitionMatrix.at<double>(10,16) = 0.5*pow(dt,2);
+    KF.transitionMatrix.at<double>(11,17) = 0.5*pow(dt,2);
+
+
+    /** MEASUREMENT MODEL **/
+
+    //  [1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
+    //  [0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
+    //  [0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
+    //  [0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0]
+    //  [0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]
+    //  [0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0]
+
+    KF.measurementMatrix.at<double>(0,0) = 1;  // x
+    KF.measurementMatrix.at<double>(1,1) = 1;  // y
+    KF.measurementMatrix.at<double>(2,2) = 1;  // z
+    KF.measurementMatrix.at<double>(3,9) = 1;  // roll
+    KF.measurementMatrix.at<double>(4,10) = 1; // pitch
+    KF.measurementMatrix.at<double>(5,11) = 1; // yaw
+}
+
+/**********************************************************************************************************/
+void updateKalmanFilter( KalmanFilter &KF, Mat &measurement,
+                         Mat &translation_estimated, Mat &rotation_estimated )
+{
+    // First predict, to update the internal statePre variable
+    Mat prediction = KF.predict();
+
+    // The "correct" phase that is going to use the predicted value and our measurement
+    Mat estimated = KF.correct(measurement);
+
+    // Estimated translation
+    translation_estimated.at<double>(0) = estimated.at<double>(0);
+    translation_estimated.at<double>(1) = estimated.at<double>(1);
+    translation_estimated.at<double>(2) = estimated.at<double>(2);
+
+    // Estimated euler angles
+    Mat eulers_estimated(3, 1, CV_64F);
+    eulers_estimated.at<double>(0) = estimated.at<double>(9);
+    eulers_estimated.at<double>(1) = estimated.at<double>(10);
+    eulers_estimated.at<double>(2) = estimated.at<double>(11);
+
+    // Convert estimated quaternion to rotation matrix
+    rotation_estimated = euler2rot(eulers_estimated);
+}
+
+/**********************************************************************************************************/
+void fillMeasurements( Mat &measurements,
+                       const Mat &translation_measured, const Mat &rotation_measured)
+{
+    // Convert rotation matrix to euler angles
+    Mat measured_eulers(3, 1, CV_64F);
+    measured_eulers = rot2euler(rotation_measured);
+
+    // Set measurement to predict
+    measurements.at<double>(0) = translation_measured.at<double>(0); // x
+    measurements.at<double>(1) = translation_measured.at<double>(1); // y
+    measurements.at<double>(2) = translation_measured.at<double>(2); // z
+    measurements.at<double>(3) = measured_eulers.at<double>(0);      // roll
+    measurements.at<double>(4) = measured_eulers.at<double>(1);      // pitch
+    measurements.at<double>(5) = measured_eulers.at<double>(2);      // yaw
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_registration.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_registration.cpp
new file mode 100644
index 00000000..31ffb2e0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_registration.cpp
@@ -0,0 +1,293 @@
+// C++
+#include <iostream>
+// OpenCV
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/calib3d.hpp>
+#include <opencv2/features2d.hpp>
+// PnP Tutorial
+#include "Mesh.h"
+#include "Model.h"
+#include "PnPProblem.h"
+#include "RobustMatcher.h"
+#include "ModelRegistration.h"
+#include "Utils.h"
+
+using namespace cv;
+using namespace std;
+
+/**  GLOBAL VARIABLES  **/
+
+// Boolean the know if the registration it's done
+bool end_registration = false;
+
+// Intrinsic camera parameters: UVC WEBCAM
+const double f = 45; // focal length in mm
+const double sx = 22.3, sy = 14.9;
+const double width = 2592, height = 1944;
+const double params_CANON[] = { width*f/sx,   // fx
+                                height*f/sy,  // fy
+                                width/2,      // cx
+                                height/2};    // cy
+
+// Setup the points to register in the image
+// In the order of the *.ply file and starting at 1
+const int n = 8;
+const int pts[] = {1, 2, 3, 4, 5, 6, 7, 8}; // 3 -> 4
+
+/*
+ * CREATE MODEL REGISTRATION OBJECT
+ * CREATE OBJECT MESH
+ * CREATE OBJECT MODEL
+ * CREATE PNP OBJECT
+ */
+ModelRegistration registration;
+Model model;
+Mesh mesh;
+PnPProblem pnp_registration(params_CANON);
+
+/**********************************************************************************************************/
+static void help()
+{
+    cout
+            << "--------------------------------------------------------------------------"   << endl
+            << "This program shows how to create your 3D textured model. "                    << endl
+            << "Usage:"                                                                       << endl
+            << "./cpp-tutorial-pnp_registration"                                              << endl
+            << "--------------------------------------------------------------------------"   << endl
+            << endl;
+}
+
+// Mouse events for model registration
+static void onMouseModelRegistration( int event, int x, int y, int, void* )
+{
+    if  ( event == EVENT_LBUTTONUP )
+    {
+        bool is_registrable = registration.is_registrable();
+        if (is_registrable)
+        {
+            int n_regist = registration.getNumRegist();
+            int n_vertex = pts[n_regist];
+
+            Point2f point_2d = Point2f((float)x,(float)y);
+            Point3f point_3d = mesh.getVertex(n_vertex-1);
+
+            registration.registerPoint(point_2d, point_3d);
+            if( registration.getNumRegist() == registration.getNumMax() ) end_registration = true;
+        }
+    }
+}
+
+/**  Main program  **/
+int main(int argc, char *argv[])
+{
+    help();
+
+    const String keys =
+            "{help h        |      | print this message                                                 }"
+            "{image i       |      | path to input image                                                }"
+            "{model         |      | path to output yml model                                           }"
+            "{mesh          |      | path to ply mesh                                                   }"
+            "{keypoints k   |2000  | number of keypoints to detect (only for ORB)                       }"
+            "{feature       |ORB   | feature name (ORB, KAZE, AKAZE, BRISK, SIFT, SURF, BINBOOST, VGG)  }"
+            ;
+    CommandLineParser parser(argc, argv, keys);
+
+    string img_path = samples::findFile("samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/resized_IMG_3875.JPG");  // image to register
+    string ply_read_path = samples::findFile("samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/box.ply");          // object mesh
+    string write_path = samples::findFile("samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/Data/cookies_ORB.yml");     // output file
+    int numKeyPoints = 2000;
+    string featureName = "ORB";
+
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    else
+    {
+        img_path = parser.get<string>("image").size() > 0 ? parser.get<string>("image") : img_path;
+        ply_read_path = parser.get<string>("mesh").size() > 0 ? parser.get<string>("mesh") : ply_read_path;
+        write_path = parser.get<string>("model").size() > 0 ? parser.get<string>("model") : write_path;
+        numKeyPoints = parser.has("keypoints") ? parser.get<int>("keypoints") : numKeyPoints;
+        featureName = parser.has("feature") ? parser.get<string>("feature") : featureName;
+    }
+
+    std::cout << "Input image: " << img_path << std::endl;
+    std::cout << "CAD model: " << ply_read_path << std::endl;
+    std::cout << "Output training file: " << write_path << std::endl;
+    std::cout << "Feature: " << featureName << std::endl;
+    std::cout << "Number of keypoints for ORB: " << numKeyPoints << std::endl;
+
+    // load a mesh given the *.ply file path
+    mesh.load(ply_read_path);
+
+    //Instantiate robust matcher: detector, extractor, matcher
+    RobustMatcher rmatcher;
+    Ptr<Feature2D> detector, descriptor;
+    createFeatures(featureName, numKeyPoints, detector, descriptor);
+    rmatcher.setFeatureDetector(detector);
+    rmatcher.setDescriptorExtractor(descriptor);
+
+
+    /**  GROUND TRUTH OF THE FIRST IMAGE  **/
+
+    // Create & Open Window
+    namedWindow("MODEL REGISTRATION", WINDOW_KEEPRATIO);
+
+    // Set up the mouse events
+    setMouseCallback("MODEL REGISTRATION", onMouseModelRegistration, 0);
+
+    // Open the image to register
+    Mat img_in = imread(img_path, IMREAD_COLOR);
+    Mat img_vis;
+
+    if (img_in.empty()) {
+        cout << "Could not open or find the image" << endl;
+        return -1;
+    }
+
+    // Set the number of points to register
+    int num_registrations = n;
+    registration.setNumMax(num_registrations);
+
+    cout << "Click the box corners ..." << endl;
+    cout << "Waiting ..." << endl;
+
+    // Some basic colors
+    const Scalar red(0, 0, 255);
+    const Scalar green(0,255,0);
+    const Scalar blue(255,0,0);
+    const Scalar yellow(0,255,255);
+
+    // Loop until all the points are registered
+    while ( waitKey(30) < 0 )
+    {
+        // Refresh debug image
+        img_vis = img_in.clone();
+
+        // Current registered points
+        vector<Point2f> list_points2d = registration.get_points2d();
+        vector<Point3f> list_points3d = registration.get_points3d();
+
+        // Draw current registered points
+        drawPoints(img_vis, list_points2d, list_points3d, red);
+
+        // If the registration is not finished, draw which 3D point we have to register.
+        // If the registration is finished, breaks the loop.
+        if (!end_registration)
+        {
+            // Draw debug text
+            int n_regist = registration.getNumRegist();
+            int n_vertex = pts[n_regist];
+            Point3f current_poin3d = mesh.getVertex(n_vertex-1);
+
+            drawQuestion(img_vis, current_poin3d, green);
+            drawCounter(img_vis, registration.getNumRegist(), registration.getNumMax(), red);
+        }
+        else
+        {
+            // Draw debug text
+            drawText(img_vis, "END REGISTRATION", green);
+            drawCounter(img_vis, registration.getNumRegist(), registration.getNumMax(), green);
+            break;
+        }
+
+        // Show the image
+        imshow("MODEL REGISTRATION", img_vis);
+    }
+
+    /** COMPUTE CAMERA POSE **/
+
+    cout << "COMPUTING POSE ..." << endl;
+
+    // The list of registered points
+    vector<Point2f> list_points2d = registration.get_points2d();
+    vector<Point3f> list_points3d = registration.get_points3d();
+
+    // Estimate pose given the registered points
+    bool is_correspondence = pnp_registration.estimatePose(list_points3d, list_points2d, SOLVEPNP_ITERATIVE);
+    if ( is_correspondence )
+    {
+        cout << "Correspondence found" << endl;
+
+        // Compute all the 2D points of the mesh to verify the algorithm and draw it
+        vector<Point2f> list_points2d_mesh = pnp_registration.verify_points(&mesh);
+        draw2DPoints(img_vis, list_points2d_mesh, green);
+    } else {
+        cout << "Correspondence not found" << endl << endl;
+    }
+
+    // Show the image
+    imshow("MODEL REGISTRATION", img_vis);
+
+    // Show image until ESC pressed
+    waitKey(0);
+
+
+    /** COMPUTE 3D of the image Keypoints **/
+
+    // Containers for keypoints and descriptors of the model
+    vector<KeyPoint> keypoints_model;
+    Mat descriptors;
+
+    // Compute keypoints and descriptors
+    rmatcher.computeKeyPoints(img_in, keypoints_model);
+    rmatcher.computeDescriptors(img_in, keypoints_model, descriptors);
+
+    // Check if keypoints are on the surface of the registration image and add to the model
+    for (unsigned int i = 0; i < keypoints_model.size(); ++i) {
+        Point2f point2d(keypoints_model[i].pt);
+        Point3f point3d;
+        bool on_surface = pnp_registration.backproject2DPoint(&mesh, point2d, point3d);
+        if (on_surface)
+        {
+            model.add_correspondence(point2d, point3d);
+            model.add_descriptor(descriptors.row(i));
+            model.add_keypoint(keypoints_model[i]);
+        }
+        else
+        {
+            model.add_outlier(point2d);
+        }
+    }
+
+    model.set_trainingImagePath(img_path);
+    // save the model into a *.yaml file
+    model.save(write_path);
+
+    // Out image
+    img_vis = img_in.clone();
+
+    // The list of the points2d of the model
+    vector<Point2f> list_points_in = model.get_points2d_in();
+    vector<Point2f> list_points_out = model.get_points2d_out();
+
+    // Draw some debug text
+    string num = IntToString((int)list_points_in.size());
+    string text = "There are " + num + " inliers";
+    drawText(img_vis, text, green);
+
+    // Draw some debug text
+    num = IntToString((int)list_points_out.size());
+    text = "There are " + num + " outliers";
+    drawText2(img_vis, text, red);
+
+    // Draw the object mesh
+    drawObjectMesh(img_vis, &mesh, &pnp_registration, blue);
+
+    // Draw found keypoints depending on if are or not on the surface
+    draw2DPoints(img_vis, list_points_in, green);
+    draw2DPoints(img_vis, list_points_out, red);
+
+    // Show the image
+    imshow("MODEL REGISTRATION", img_vis);
+
+    // Wait until ESC pressed
+    waitKey(0);
+
+    // Close and Destroy Window
+    destroyWindow("MODEL REGISTRATION");
+
+    cout << "GOODBYE" << endl;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/compatibility/compatibility_test.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/compatibility/compatibility_test.cpp
new file mode 100644
index 00000000..c556e9e2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/compatibility/compatibility_test.cpp
@@ -0,0 +1,19 @@
+#include <iostream>
+
+#include <opencv2/core.hpp>
+
+#include <opencv2/imgcodecs/legacy/constants_c.h>
+#include <opencv2/videoio/legacy/constants_c.h>
+#include <opencv2/photo/legacy/constants_c.h>
+#include <opencv2/video/legacy/constants_c.h>
+
+using namespace cv;
+
+int main(int /*argc*/, const char** /*argv*/)
+{
+    std::cout
+        << (int)CV_LOAD_IMAGE_GRAYSCALE
+        << (int)CV_CAP_FFMPEG
+        << std::endl;
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/AddingImages/AddingImages.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/AddingImages/AddingImages.cpp
new file mode 100644
index 00000000..83644b62
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/AddingImages/AddingImages.cpp
@@ -0,0 +1,57 @@
+/**
+ * @file AddingImages.cpp
+ * @brief Simple linear blender ( dst = alpha*src1 + beta*src2 )
+ * @author OpenCV team
+ */
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+
+// we're NOT "using namespace std;" here, to avoid collisions between the beta variable and std::beta in c++17
+using std::cin;
+using std::cout;
+using std::endl;
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( void )
+{
+   double alpha = 0.5; double beta; double input;
+
+   Mat src1, src2, dst;
+
+   /// Ask the user enter alpha
+   cout << " Simple Linear Blender " << endl;
+   cout << "-----------------------" << endl;
+   cout << "* Enter alpha [0.0-1.0]: ";
+   cin >> input;
+
+   // We use the alpha provided by the user if it is between 0 and 1
+   if( input >= 0 && input <= 1 )
+     { alpha = input; }
+
+   //![load]
+   /// Read images ( both have to be of the same size and type )
+   src1 = imread( samples::findFile("LinuxLogo.jpg") );
+   src2 = imread( samples::findFile("WindowsLogo.jpg") );
+   //![load]
+
+   if( src1.empty() ) { cout << "Error loading src1" << endl; return EXIT_FAILURE; }
+   if( src2.empty() ) { cout << "Error loading src2" << endl; return EXIT_FAILURE; }
+
+   //![blend_images]
+   beta = ( 1.0 - alpha );
+   addWeighted( src1, alpha, src2, beta, 0.0, dst);
+   //![blend_images]
+
+   //![display]
+   imshow( "Linear Blend", dst );
+   waitKey(0);
+   //![display]
+
+   return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp
new file mode 100644
index 00000000..e9e8096b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp
@@ -0,0 +1,95 @@
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help(char ** argv)
+{
+    cout << endl
+        <<  "This program demonstrated the use of the discrete Fourier transform (DFT). " << endl
+        <<  "The dft of an image is taken and it's power spectrum is displayed."  << endl << endl
+        <<  "Usage:"                                                                      << endl
+        << argv[0] << " [image_name -- default lena.jpg]" << endl << endl;
+}
+
+int main(int argc, char ** argv)
+{
+    help(argv);
+
+    const char* filename = argc >=2 ? argv[1] : "lena.jpg";
+
+    Mat I = imread( samples::findFile( filename ), IMREAD_GRAYSCALE);
+    if( I.empty()){
+        cout << "Error opening image" << endl;
+        return EXIT_FAILURE;
+    }
+
+//! [expand]
+    Mat padded;                            //expand input image to optimal size
+    int m = getOptimalDFTSize( I.rows );
+    int n = getOptimalDFTSize( I.cols ); // on the border add zero values
+    copyMakeBorder(I, padded, 0, m - I.rows, 0, n - I.cols, BORDER_CONSTANT, Scalar::all(0));
+//! [expand]
+
+//! [complex_and_real]
+    Mat planes[] = {Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F)};
+    Mat complexI;
+    merge(planes, 2, complexI);         // Add to the expanded another plane with zeros
+//! [complex_and_real]
+
+//! [dft]
+    dft(complexI, complexI);            // this way the result may fit in the source matrix
+//! [dft]
+
+    // compute the magnitude and switch to logarithmic scale
+    // => log(1 + sqrt(Re(DFT(I))^2 + Im(DFT(I))^2))
+//! [magnitude]
+    split(complexI, planes);                   // planes[0] = Re(DFT(I), planes[1] = Im(DFT(I))
+    magnitude(planes[0], planes[1], planes[0]);// planes[0] = magnitude
+    Mat magI = planes[0];
+//! [magnitude]
+
+//! [log]
+    magI += Scalar::all(1);                    // switch to logarithmic scale
+    log(magI, magI);
+//! [log]
+
+//! [crop_rearrange]
+    // crop the spectrum, if it has an odd number of rows or columns
+    magI = magI(Rect(0, 0, magI.cols & -2, magI.rows & -2));
+
+    // rearrange the quadrants of Fourier image  so that the origin is at the image center
+    int cx = magI.cols/2;
+    int cy = magI.rows/2;
+
+    Mat q0(magI, Rect(0, 0, cx, cy));   // Top-Left - Create a ROI per quadrant
+    Mat q1(magI, Rect(cx, 0, cx, cy));  // Top-Right
+    Mat q2(magI, Rect(0, cy, cx, cy));  // Bottom-Left
+    Mat q3(magI, Rect(cx, cy, cx, cy)); // Bottom-Right
+
+    Mat tmp;                           // swap quadrants (Top-Left with Bottom-Right)
+    q0.copyTo(tmp);
+    q3.copyTo(q0);
+    tmp.copyTo(q3);
+
+    q1.copyTo(tmp);                    // swap quadrant (Top-Right with Bottom-Left)
+    q2.copyTo(q1);
+    tmp.copyTo(q2);
+//! [crop_rearrange]
+
+//! [normalize]
+    normalize(magI, magI, 0, 1, NORM_MINMAX); // Transform the matrix with float values into a
+                                            // viewable image form (float between values 0 and 1).
+//! [normalize]
+
+    imshow("Input Image"       , I   );    // Show the result
+    imshow("spectrum magnitude", magI);
+    waitKey();
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp
new file mode 100644
index 00000000..b17e24ea
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp
@@ -0,0 +1,191 @@
+#include <opencv2/core.hpp>
+#include <iostream>
+#include <string>
+
+using namespace cv;
+using namespace std;
+
+static void help(char** av)
+{
+    cout << endl
+        << av[0] << " shows the usage of the OpenCV serialization functionality."         << endl
+        << "usage: "                                                                      << endl
+        <<  av[0] << " outputfile.yml.gz"                                                 << endl
+        << "The output file may be either XML (xml) or YAML (yml/yaml). You can even compress it by "
+        << "specifying this in its extension like xml.gz yaml.gz etc... "                  << endl
+        << "With FileStorage you can serialize objects in OpenCV by using the << and >> operators" << endl
+        << "For example: - create a class and have it serialized"                         << endl
+        << "             - use it to read and write matrices."                            << endl;
+}
+
+class MyData
+{
+public:
+    MyData() : A(0), X(0), id()
+    {}
+    explicit MyData(int) : A(97), X(CV_PI), id("mydata1234") // explicit to avoid implicit conversion
+    {}
+    //! [inside]
+    void write(FileStorage& fs) const                        //Write serialization for this class
+    {
+        fs << "{" << "A" << A << "X" << X << "id" << id << "}";
+    }
+    void read(const FileNode& node)                          //Read serialization for this class
+    {
+        A = (int)node["A"];
+        X = (double)node["X"];
+        id = (string)node["id"];
+    }
+    //! [inside]
+public:   // Data Members
+    int A;
+    double X;
+    string id;
+};
+
+//These write and read functions must be defined for the serialization in FileStorage to work
+//! [outside]
+static void write(FileStorage& fs, const std::string&, const MyData& x)
+{
+    x.write(fs);
+}
+static void read(const FileNode& node, MyData& x, const MyData& default_value = MyData()){
+    if(node.empty())
+        x = default_value;
+    else
+        x.read(node);
+}
+//! [outside]
+
+// This function will print our custom class to the console
+static ostream& operator<<(ostream& out, const MyData& m)
+{
+    out << "{ id = " << m.id << ", ";
+    out << "X = " << m.X << ", ";
+    out << "A = " << m.A << "}";
+    return out;
+}
+
+int main(int ac, char** av)
+{
+    if (ac != 2)
+    {
+        help(av);
+        return 1;
+    }
+
+    string filename = av[1];
+    { //write
+        //! [iomati]
+        Mat R = Mat_<uchar>::eye(3, 3),
+            T = Mat_<double>::zeros(3, 1);
+        //! [iomati]
+        //! [customIOi]
+        MyData m(1);
+        //! [customIOi]
+
+        //! [open]
+        FileStorage fs(filename, FileStorage::WRITE);
+        // or:
+        // FileStorage fs;
+        // fs.open(filename, FileStorage::WRITE);
+        //! [open]
+
+        //! [writeNum]
+        fs << "iterationNr" << 100;
+        //! [writeNum]
+        //! [writeStr]
+        fs << "strings" << "[";                              // text - string sequence
+        fs << "image1.jpg" << "Awesomeness" << "../data/baboon.jpg";
+        fs << "]";                                           // close sequence
+        //! [writeStr]
+
+        //! [writeMap]
+        fs << "Mapping";                              // text - mapping
+        fs << "{" << "One" << 1;
+        fs <<        "Two" << 2 << "}";
+        //! [writeMap]
+
+        //! [iomatw]
+        fs << "R" << R;                                      // cv::Mat
+        fs << "T" << T;
+        //! [iomatw]
+
+        //! [customIOw]
+        fs << "MyData" << m;                                // your own data structures
+        //! [customIOw]
+
+        //! [close]
+        fs.release();                                       // explicit close
+        //! [close]
+        cout << "Write Done." << endl;
+    }
+
+    {//read
+        cout << endl << "Reading: " << endl;
+        FileStorage fs;
+        fs.open(filename, FileStorage::READ);
+
+        //! [readNum]
+        int itNr;
+        //fs["iterationNr"] >> itNr;
+        itNr = (int) fs["iterationNr"];
+        //! [readNum]
+        cout << itNr;
+        if (!fs.isOpened())
+        {
+            cerr << "Failed to open " << filename << endl;
+            help(av);
+            return 1;
+        }
+
+        //! [readStr]
+        FileNode n = fs["strings"];                         // Read string sequence - Get node
+        if (n.type() != FileNode::SEQ)
+        {
+            cerr << "strings is not a sequence! FAIL" << endl;
+            return 1;
+        }
+
+        FileNodeIterator it = n.begin(), it_end = n.end(); // Go through the node
+        for (; it != it_end; ++it)
+            cout << (string)*it << endl;
+        //! [readStr]
+
+
+        //! [readMap]
+        n = fs["Mapping"];                                // Read mappings from a sequence
+        cout << "Two  " << (int)(n["Two"]) << "; ";
+        cout << "One  " << (int)(n["One"]) << endl << endl;
+        //! [readMap]
+
+
+        MyData m;
+        Mat R, T;
+
+        //! [iomat]
+        fs["R"] >> R;                                      // Read cv::Mat
+        fs["T"] >> T;
+        //! [iomat]
+        //! [customIO]
+        fs["MyData"] >> m;                                 // Read your own structure_
+        //! [customIO]
+
+        cout << endl
+            << "R = " << R << endl;
+        cout << "T = " << T << endl << endl;
+        cout << "MyData = " << endl << m << endl << endl;
+
+        //Show default behavior for non existing nodes
+        //! [nonexist]
+        cout << "Attempt to read NonExisting (should initialize the data structure with its default).";
+        fs["NonExisting"] >> m;
+        cout << endl << "NonExisting = " << endl << m << endl;
+        //! [nonexist]
+    }
+
+    cout << endl
+        << "Tip: Open up " << filename << " with a text editor to see the serialized data." << endl;
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
new file mode 100644
index 00000000..47a55478
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
@@ -0,0 +1,230 @@
+#include <opencv2/core.hpp>
+#include <opencv2/core/utility.hpp>
+#include "opencv2/imgcodecs.hpp"
+#include <opencv2/highgui.hpp>
+#include <iostream>
+#include <sstream>
+
+using namespace std;
+using namespace cv;
+
+static void help()
+{
+    cout
+        << "\n--------------------------------------------------------------------------" << endl
+        << "This program shows how to scan image objects in OpenCV (cv::Mat). As use case"
+        << " we take an input image and divide the native color palette (255) with the "  << endl
+        << "input. Shows C operator[] method, iterators and at function for on-the-fly item address calculation."<< endl
+        << "Usage:"                                                                       << endl
+        << "./how_to_scan_images <imageNameToUse> <divideWith> [G]"                       << endl
+        << "if you add a G parameter the image is processed in gray scale"                << endl
+        << "--------------------------------------------------------------------------"   << endl
+        << endl;
+}
+
+Mat& ScanImageAndReduceC(Mat& I, const uchar* table);
+Mat& ScanImageAndReduceIterator(Mat& I, const uchar* table);
+Mat& ScanImageAndReduceRandomAccess(Mat& I, const uchar * table);
+
+int main( int argc, char* argv[])
+{
+    help();
+    if (argc < 3)
+    {
+        cout << "Not enough parameters" << endl;
+        return -1;
+    }
+
+    Mat I, J;
+    if( argc == 4 && !strcmp(argv[3],"G") )
+        I = imread(argv[1], IMREAD_GRAYSCALE);
+    else
+        I = imread(argv[1], IMREAD_COLOR);
+
+    if (I.empty())
+    {
+        cout << "The image" << argv[1] << " could not be loaded." << endl;
+        return -1;
+    }
+
+    //! [dividewith]
+    int divideWith = 0; // convert our input string to number - C++ style
+    stringstream s;
+    s << argv[2];
+    s >> divideWith;
+    if (!s || !divideWith)
+    {
+        cout << "Invalid number entered for dividing. " << endl;
+        return -1;
+    }
+
+    uchar table[256];
+    for (int i = 0; i < 256; ++i)
+       table[i] = (uchar)(divideWith * (i/divideWith));
+    //! [dividewith]
+
+    const int times = 100;
+    double t;
+
+    t = (double)getTickCount();
+
+    for (int i = 0; i < times; ++i)
+    {
+        cv::Mat clone_i = I.clone();
+        J = ScanImageAndReduceC(clone_i, table);
+    }
+
+    t = 1000*((double)getTickCount() - t)/getTickFrequency();
+    t /= times;
+
+    cout << "Time of reducing with the C operator [] (averaged for "
+         << times << " runs): " << t << " milliseconds."<< endl;
+
+    t = (double)getTickCount();
+
+    for (int i = 0; i < times; ++i)
+    {
+        cv::Mat clone_i = I.clone();
+        J = ScanImageAndReduceIterator(clone_i, table);
+    }
+
+    t = 1000*((double)getTickCount() - t)/getTickFrequency();
+    t /= times;
+
+    cout << "Time of reducing with the iterator (averaged for "
+        << times << " runs): " << t << " milliseconds."<< endl;
+
+    t = (double)getTickCount();
+
+    for (int i = 0; i < times; ++i)
+    {
+        cv::Mat clone_i = I.clone();
+        ScanImageAndReduceRandomAccess(clone_i, table);
+    }
+
+    t = 1000*((double)getTickCount() - t)/getTickFrequency();
+    t /= times;
+
+    cout << "Time of reducing with the on-the-fly address generation - at function (averaged for "
+        << times << " runs): " << t << " milliseconds."<< endl;
+
+    //! [table-init]
+    Mat lookUpTable(1, 256, CV_8U);
+    uchar* p = lookUpTable.ptr();
+    for( int i = 0; i < 256; ++i)
+        p[i] = table[i];
+    //! [table-init]
+
+    t = (double)getTickCount();
+
+    for (int i = 0; i < times; ++i)
+        //! [table-use]
+        LUT(I, lookUpTable, J);
+        //! [table-use]
+
+    t = 1000*((double)getTickCount() - t)/getTickFrequency();
+    t /= times;
+
+    cout << "Time of reducing with the LUT function (averaged for "
+        << times << " runs): " << t << " milliseconds."<< endl;
+    return 0;
+}
+
+//! [scan-c]
+Mat& ScanImageAndReduceC(Mat& I, const uchar* const table)
+{
+    // accept only char type matrices
+    CV_Assert(I.depth() == CV_8U);
+
+    int channels = I.channels();
+
+    int nRows = I.rows;
+    int nCols = I.cols * channels;
+
+    if (I.isContinuous())
+    {
+        nCols *= nRows;
+        nRows = 1;
+    }
+
+    int i,j;
+    uchar* p;
+    for( i = 0; i < nRows; ++i)
+    {
+        p = I.ptr<uchar>(i);
+        for ( j = 0; j < nCols; ++j)
+        {
+            p[j] = table[p[j]];
+        }
+    }
+    return I;
+}
+//! [scan-c]
+
+//! [scan-iterator]
+Mat& ScanImageAndReduceIterator(Mat& I, const uchar* const table)
+{
+    // accept only char type matrices
+    CV_Assert(I.depth() == CV_8U);
+
+    const int channels = I.channels();
+    switch(channels)
+    {
+    case 1:
+        {
+            MatIterator_<uchar> it, end;
+            for( it = I.begin<uchar>(), end = I.end<uchar>(); it != end; ++it)
+                *it = table[*it];
+            break;
+        }
+    case 3:
+        {
+            MatIterator_<Vec3b> it, end;
+            for( it = I.begin<Vec3b>(), end = I.end<Vec3b>(); it != end; ++it)
+            {
+                (*it)[0] = table[(*it)[0]];
+                (*it)[1] = table[(*it)[1]];
+                (*it)[2] = table[(*it)[2]];
+            }
+        }
+    }
+
+    return I;
+}
+//! [scan-iterator]
+
+//! [scan-random]
+Mat& ScanImageAndReduceRandomAccess(Mat& I, const uchar* const table)
+{
+    // accept only char type matrices
+    CV_Assert(I.depth() == CV_8U);
+
+    const int channels = I.channels();
+    switch(channels)
+    {
+    case 1:
+        {
+            for( int i = 0; i < I.rows; ++i)
+                for( int j = 0; j < I.cols; ++j )
+                    I.at<uchar>(i,j) = table[I.at<uchar>(i,j)];
+            break;
+        }
+    case 3:
+        {
+         Mat_<Vec3b> _I = I;
+
+         for( int i = 0; i < I.rows; ++i)
+            for( int j = 0; j < I.cols; ++j )
+               {
+                   _I(i,j)[0] = table[_I(i,j)[0]];
+                   _I(i,j)[1] = table[_I(i,j)[1]];
+                   _I(i,j)[2] = table[_I(i,j)[2]];
+            }
+         I = _I;
+         break;
+        }
+    }
+
+    return I;
+}
+//! [scan-random]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/how_to_use_OpenCV_parallel_for_/how_to_use_OpenCV_parallel_for_.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/how_to_use_OpenCV_parallel_for_/how_to_use_OpenCV_parallel_for_.cpp
new file mode 100644
index 00000000..2dcc1ff1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/how_to_use_OpenCV_parallel_for_/how_to_use_OpenCV_parallel_for_.cpp
@@ -0,0 +1,147 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgcodecs.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace
+{
+//! [mandelbrot-escape-time-algorithm]
+int mandelbrot(const complex<float> &z0, const int max)
+{
+    complex<float> z = z0;
+    for (int t = 0; t < max; t++)
+    {
+        if (z.real()*z.real() + z.imag()*z.imag() > 4.0f) return t;
+        z = z*z + z0;
+    }
+
+    return max;
+}
+//! [mandelbrot-escape-time-algorithm]
+
+//! [mandelbrot-grayscale-value]
+int mandelbrotFormula(const complex<float> &z0, const int maxIter=500) {
+    int value = mandelbrot(z0, maxIter);
+    if(maxIter - value == 0)
+    {
+        return 0;
+    }
+
+    return cvRound(sqrt(value / (float) maxIter) * 255);
+}
+//! [mandelbrot-grayscale-value]
+
+//! [mandelbrot-parallel]
+class ParallelMandelbrot : public ParallelLoopBody
+{
+public:
+    ParallelMandelbrot (Mat &img, const float x1, const float y1, const float scaleX, const float scaleY)
+        : m_img(img), m_x1(x1), m_y1(y1), m_scaleX(scaleX), m_scaleY(scaleY)
+    {
+    }
+
+    virtual void operator ()(const Range& range) const CV_OVERRIDE
+    {
+        for (int r = range.start; r < range.end; r++)
+        {
+            int i = r / m_img.cols;
+            int j = r % m_img.cols;
+
+            float x0 = j / m_scaleX + m_x1;
+            float y0 = i / m_scaleY + m_y1;
+
+            complex<float> z0(x0, y0);
+            uchar value = (uchar) mandelbrotFormula(z0);
+            m_img.ptr<uchar>(i)[j] = value;
+        }
+    }
+
+    ParallelMandelbrot& operator=(const ParallelMandelbrot &) {
+        return *this;
+    };
+
+private:
+    Mat &m_img;
+    float m_x1;
+    float m_y1;
+    float m_scaleX;
+    float m_scaleY;
+};
+//! [mandelbrot-parallel]
+
+//! [mandelbrot-sequential]
+void sequentialMandelbrot(Mat &img, const float x1, const float y1, const float scaleX, const float scaleY)
+{
+    for (int i = 0; i < img.rows; i++)
+    {
+        for (int j = 0; j < img.cols; j++)
+        {
+            float x0 = j / scaleX + x1;
+            float y0 = i / scaleY + y1;
+
+            complex<float> z0(x0, y0);
+            uchar value = (uchar) mandelbrotFormula(z0);
+            img.ptr<uchar>(i)[j] = value;
+        }
+    }
+}
+//! [mandelbrot-sequential]
+}
+
+int main()
+{
+    //! [mandelbrot-transformation]
+    Mat mandelbrotImg(4800, 5400, CV_8U);
+    float x1 = -2.1f, x2 = 0.6f;
+    float y1 = -1.2f, y2 = 1.2f;
+    float scaleX = mandelbrotImg.cols / (x2 - x1);
+    float scaleY = mandelbrotImg.rows / (y2 - y1);
+    //! [mandelbrot-transformation]
+
+    double t1 = (double) getTickCount();
+
+    #ifdef CV_CXX11
+
+    //! [mandelbrot-parallel-call-cxx11]
+    parallel_for_(Range(0, mandelbrotImg.rows*mandelbrotImg.cols), [&](const Range& range){
+        for (int r = range.start; r < range.end; r++)
+        {
+            int i = r / mandelbrotImg.cols;
+            int j = r % mandelbrotImg.cols;
+
+            float x0 = j / scaleX + x1;
+            float y0 = i / scaleY + y1;
+
+            complex<float> z0(x0, y0);
+            uchar value = (uchar) mandelbrotFormula(z0);
+            mandelbrotImg.ptr<uchar>(i)[j] = value;
+        }
+    });
+    //! [mandelbrot-parallel-call-cxx11]
+
+    #else
+
+    //! [mandelbrot-parallel-call]
+    ParallelMandelbrot parallelMandelbrot(mandelbrotImg, x1, y1, scaleX, scaleY);
+    parallel_for_(Range(0, mandelbrotImg.rows*mandelbrotImg.cols), parallelMandelbrot);
+    //! [mandelbrot-parallel-call]
+
+    #endif
+
+    t1 = ((double) getTickCount() - t1) / getTickFrequency();
+    cout << "Parallel Mandelbrot: " << t1 << " s" << endl;
+
+    Mat mandelbrotImgSequential(4800, 5400, CV_8U);
+    double t2 = (double) getTickCount();
+    sequentialMandelbrot(mandelbrotImgSequential, x1, y1, scaleX, scaleY);
+    t2 = ((double) getTickCount() - t2) / getTickFrequency();
+    cout << "Sequential Mandelbrot: " << t2 << " s" << endl;
+    cout << "Speed-up: " << t2/t1 << " X" << endl;
+
+    imwrite("Mandelbrot_parallel.png", mandelbrotImg);
+    imwrite("Mandelbrot_sequential.png", mandelbrotImgSequential);
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/how_to_use_OpenCV_parallel_for_/how_to_use_OpenCV_parallel_for_new.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/how_to_use_OpenCV_parallel_for_/how_to_use_OpenCV_parallel_for_new.cpp
new file mode 100644
index 00000000..cfa9d22b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/how_to_use_OpenCV_parallel_for_/how_to_use_OpenCV_parallel_for_new.cpp
@@ -0,0 +1,332 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace
+{
+//! [convolution-sequential]
+void conv_seq(Mat src, Mat &dst, Mat kernel)
+{
+    //![convolution-make-borders]
+    int rows = src.rows, cols = src.cols;
+    dst = Mat(rows, cols, src.type());
+
+    // Taking care of edge values
+    // Make border = kernel.rows / 2;
+
+    int sz = kernel.rows / 2;
+    copyMakeBorder(src, src, sz, sz, sz, sz, BORDER_REPLICATE);
+    //![convolution-make-borders]
+
+    //! [convolution-kernel-loop]
+    for (int i = 0; i < rows; i++)
+    {
+        uchar *dptr = dst.ptr(i);
+        for (int j = 0; j < cols; j++)
+        {
+            double value = 0;
+
+            for (int k = -sz; k <= sz; k++)
+            {
+                // slightly faster results when we create a ptr due to more efficient memory access.
+                uchar *sptr = src.ptr(i + sz + k);
+                for (int l = -sz; l <= sz; l++)
+                {
+                    value += kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l];
+                }
+            }
+            dptr[j] = saturate_cast<uchar>(value);
+        }
+    }
+    //! [convolution-kernel-loop]
+}
+//! [convolution-sequential]
+
+#ifdef CV_CXX11
+void conv_parallel(Mat src, Mat &dst, Mat kernel)
+{
+    int rows = src.rows, cols = src.cols;
+
+    dst = Mat(rows, cols, CV_8UC1, Scalar(0));
+
+    // Taking care of edge values
+    // Make border = kernel.rows / 2;
+
+    int sz = kernel.rows / 2;
+    copyMakeBorder(src, src, sz, sz, sz, sz, BORDER_REPLICATE);
+
+    //! [convolution-parallel-cxx11]
+    parallel_for_(Range(0, rows * cols), [&](const Range &range)
+                    {
+                        for (int r = range.start; r < range.end; r++)
+                        {
+                            int i = r / cols, j = r % cols;
+
+                            double value = 0;
+                            for (int k = -sz; k <= sz; k++)
+                            {
+                                uchar *sptr = src.ptr(i + sz + k);
+                                for (int l = -sz; l <= sz; l++)
+                                {
+                                    value += kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l];
+                                }
+                            }
+                            dst.ptr(i)[j] = saturate_cast<uchar>(value);
+                        }
+                    });
+    //! [convolution-parallel-cxx11]
+}
+
+void conv_parallel_row_split(Mat src, Mat &dst, Mat kernel)
+{
+    int rows = src.rows, cols = src.cols;
+
+    dst = Mat(rows, cols, CV_8UC1, Scalar(0));
+
+    // Taking care of edge values
+    // Make border = kernel.rows / 2;
+
+    int sz = kernel.rows / 2;
+    copyMakeBorder(src, src, sz, sz, sz, sz, BORDER_REPLICATE);
+
+    //! [convolution-parallel-cxx11-row-split]
+    parallel_for_(Range(0, rows), [&](const Range &range)
+                    {
+                        for (int i = range.start; i < range.end; i++)
+                        {
+
+                            uchar *dptr = dst.ptr(i);
+                            for (int j = 0; j < cols; j++)
+                            {
+                                double value = 0;
+                                for (int k = -sz; k <= sz; k++)
+                                {
+                                    uchar *sptr = src.ptr(i + sz + k);
+                                    for (int l = -sz; l <= sz; l++)
+                                    {
+                                        value += kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l];
+                                    }
+                                }
+                                dptr[j] = saturate_cast<uchar>(value);
+                            }
+                        }
+                    });
+    //! [convolution-parallel-cxx11-row-split]
+}
+#else
+
+//! [convolution-parallel]
+class parallelConvolution : public ParallelLoopBody
+{
+private:
+    Mat m_src, &m_dst;
+    Mat m_kernel;
+    int sz;
+
+public:
+    parallelConvolution(Mat src, Mat &dst, Mat kernel)
+        : m_src(src), m_dst(dst), m_kernel(kernel)
+    {
+        sz = kernel.rows / 2;
+    }
+
+    //! [overload-full]
+    virtual void operator()(const Range &range) const CV_OVERRIDE
+    {
+        for (int r = range.start; r < range.end; r++)
+        {
+            int i = r / m_src.cols, j = r % m_src.cols;
+
+            double value = 0;
+            for (int k = -sz; k <= sz; k++)
+            {
+                uchar *sptr = m_src.ptr(i + sz + k);
+                for (int l = -sz; l <= sz; l++)
+                {
+                    value += m_kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l];
+                }
+            }
+            m_dst.ptr(i)[j] = saturate_cast<uchar>(value);
+        }
+    }
+    //! [overload-full]
+};
+//! [convolution-parallel]
+
+void conv_parallel(Mat src, Mat &dst, Mat kernel)
+{
+    int rows = src.rows, cols = src.cols;
+
+    dst = Mat(rows, cols, CV_8UC1, Scalar(0));
+
+    // Taking care of edge values
+    // Make border = kernel.rows / 2;
+
+    int sz = kernel.rows / 2;
+    copyMakeBorder(src, src, sz, sz, sz, sz, BORDER_REPLICATE);
+
+    //! [convolution-parallel-function]
+    parallelConvolution obj(src, dst, kernel);
+    parallel_for_(Range(0, rows * cols), obj);
+    //! [convolution-parallel-function]
+}
+
+//! [conv-parallel-row-split]
+class parallelConvolutionRowSplit : public ParallelLoopBody
+{
+private:
+    Mat m_src, &m_dst;
+    Mat m_kernel;
+    int sz;
+
+public:
+    parallelConvolutionRowSplit(Mat src, Mat &dst, Mat kernel)
+        : m_src(src), m_dst(dst), m_kernel(kernel)
+    {
+        sz = kernel.rows / 2;
+    }
+
+    //! [overload-row-split]
+    virtual void operator()(const Range &range) const CV_OVERRIDE
+    {
+        for (int i = range.start; i < range.end; i++)
+        {
+
+            uchar *dptr = dst.ptr(i);
+            for (int j = 0; j < cols; j++)
+            {
+                double value = 0;
+                for (int k = -sz; k <= sz; k++)
+                {
+                    uchar *sptr = src.ptr(i + sz + k);
+                    for (int l = -sz; l <= sz; l++)
+                    {
+                        value += kernel.ptr<double>(k + sz)[l + sz] * sptr[j + sz + l];
+                    }
+                }
+                dptr[j] = saturate_cast<uchar>(value);
+            }
+        }
+    }
+    //! [overload-row-split]
+};
+//! [conv-parallel-row-split]
+
+void conv_parallel_row_split(Mat src, Mat &dst, Mat kernel)
+{
+    int rows = src.rows, cols = src.cols;
+
+    dst = Mat(rows, cols, CV_8UC1, Scalar(0));
+
+    // Taking care of edge values
+    // Make border = kernel.rows / 2;
+
+    int sz = kernel.rows / 2;
+    copyMakeBorder(src, src, sz, sz, sz, sz, BORDER_REPLICATE);
+
+    //! [convolution-parallel-function-row]
+    parallelConvolutionRowSplit obj(src, dst, kernel);
+    parallel_for_(Range(0, rows), obj);
+    //! [convolution-parallel-function-row]
+}
+
+#endif
+
+static void help(char *progName)
+{
+    cout << endl
+            << " This program shows how to use the OpenCV parallel_for_ function and \n"
+            << " compares the performance of the sequential and parallel implementations for a \n"
+            << " convolution operation\n"
+            << " Usage:\n "
+            << progName << " [image_path -- default lena.jpg] " << endl
+            << endl;
+}
+}
+
+int main(int argc, char *argv[])
+{
+
+    help(argv[0]);
+    const char *filepath = argc >= 2 ? argv[1] : "../../../../data/lena.jpg";
+
+    Mat src, dst, kernel;
+    src = imread(filepath, IMREAD_GRAYSCALE);
+
+    if (src.empty())
+    {
+        cerr << "Can't open [" << filepath << "]" << endl;
+        return EXIT_FAILURE;
+    }
+    namedWindow("Input", 1);
+    namedWindow("Output1", 1);
+    namedWindow("Output2", 1);
+    namedWindow("Output3", 1);
+    imshow("Input", src);
+
+    kernel = (Mat_<double>(3, 3) << 1, 0, -1,
+              1, 0, -1,
+              1, 0, -1);
+
+    /*
+    Uncomment the kernels you want to use or write your own kernels to test out
+    performance.
+    */
+
+    /*
+    kernel = (Mat_<double>(5, 5) <<   1, 1, 1, 1, 1,
+                                      1, 1, 1, 1, 1,
+                                      1, 1, 1, 1, 1,
+                                      1, 1, 1, 1, 1,
+                                      1, 1, 1, 1, 1);
+    kernel /= 100;
+    */
+
+    /*
+    kernel = (Mat_<double>(3, 3) <<  1,  1,  1,
+                                     0,  0,  0,
+                                    -1, -1, -1);
+
+    */
+
+    double t = (double)getTickCount();
+
+    conv_seq(src, dst, kernel);
+
+    t = ((double)getTickCount() - t) / getTickFrequency();
+    cout << " Sequential implementation: " << t << "s" << endl;
+
+    imshow("Output1", dst);
+    waitKey(0);
+
+    t = (double)getTickCount();
+
+    conv_parallel(src, dst, kernel);
+
+    t = ((double)getTickCount() - t) / getTickFrequency();
+    cout << " Parallel Implementation: " << t << "s" << endl;
+
+    imshow("Output2", dst);
+    waitKey(0);
+
+    t = (double)getTickCount();
+
+    conv_parallel_row_split(src, dst, kernel);
+
+    t = ((double)getTickCount() - t) / getTickFrequency();
+    cout << " Parallel Implementation(Row Split): " << t << "s" << endl
+         << endl;
+
+    imshow("Output3", dst);
+    waitKey(0);
+
+    // imwrite("src.png", src);
+    // imwrite("dst.png", dst);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp
new file mode 100644
index 00000000..0fece804
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp
@@ -0,0 +1,108 @@
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static void help(char* progName)
+{
+    cout << endl
+        <<  "This program shows how to filter images with mask: the write it yourself and the"
+        << "filter2d way. " << endl
+        <<  "Usage:"                                                                        << endl
+        << progName << " [image_path -- default lena.jpg] [G -- grayscale] "        << endl << endl;
+}
+
+
+void Sharpen(const Mat& myImage,Mat& Result);
+
+int main( int argc, char* argv[])
+{
+    help(argv[0]);
+    const char* filename = argc >=2 ? argv[1] : "lena.jpg";
+
+    Mat src, dst0, dst1;
+
+    if (argc >= 3 && !strcmp("G", argv[2]))
+        src = imread( samples::findFile( filename ), IMREAD_GRAYSCALE);
+    else
+        src = imread( samples::findFile( filename ), IMREAD_COLOR);
+
+    if (src.empty())
+    {
+        cerr << "Can't open image ["  << filename << "]" << endl;
+        return EXIT_FAILURE;
+    }
+
+    namedWindow("Input", WINDOW_AUTOSIZE);
+    namedWindow("Output", WINDOW_AUTOSIZE);
+
+    imshow( "Input", src );
+    double t = (double)getTickCount();
+
+    Sharpen( src, dst0 );
+
+    t = ((double)getTickCount() - t)/getTickFrequency();
+    cout << "Hand written function time passed in seconds: " << t << endl;
+
+    imshow( "Output", dst0 );
+    waitKey();
+
+  //![kern]
+    Mat kernel = (Mat_<char>(3,3) <<  0, -1,  0,
+                                   -1,  5, -1,
+                                    0, -1,  0);
+  //![kern]
+
+    t = (double)getTickCount();
+
+  //![filter2D]
+    filter2D( src, dst1, src.depth(), kernel );
+  //![filter2D]
+    t = ((double)getTickCount() - t)/getTickFrequency();
+    cout << "Built-in filter2D time passed in seconds:     " << t << endl;
+
+    imshow( "Output", dst1 );
+
+    waitKey();
+    return EXIT_SUCCESS;
+}
+//! [basic_method]
+void Sharpen(const Mat& myImage,Mat& Result)
+{
+  //! [8_bit]
+    CV_Assert(myImage.depth() == CV_8U);  // accept only uchar images
+  //! [8_bit]
+
+  //! [create_channels]
+    const int nChannels = myImage.channels();
+    Result.create(myImage.size(),myImage.type());
+  //! [create_channels]
+
+  //! [basic_method_loop]
+    for(int j = 1 ; j < myImage.rows-1; ++j)
+    {
+        const uchar* previous = myImage.ptr<uchar>(j - 1);
+        const uchar* current  = myImage.ptr<uchar>(j    );
+        const uchar* next     = myImage.ptr<uchar>(j + 1);
+
+        uchar* output = Result.ptr<uchar>(j);
+
+        for(int i= nChannels;i < nChannels*(myImage.cols-1); ++i)
+        {
+            *output++ = saturate_cast<uchar>(5*current[i]
+                         -current[i-nChannels] - current[i+nChannels] - previous[i] - next[i]);
+        }
+    }
+  //! [basic_method_loop]
+
+  //! [borders]
+    Result.row(0).setTo(Scalar(0));
+    Result.row(Result.rows-1).setTo(Scalar(0));
+    Result.col(0).setTo(Scalar(0));
+    Result.col(Result.cols-1).setTo(Scalar(0));
+  //! [borders]
+}
+//! [basic_method]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/mat_operations/mat_operations.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/mat_operations/mat_operations.cpp
new file mode 100644
index 00000000..a4efe30b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/mat_operations/mat_operations.cpp
@@ -0,0 +1,170 @@
+/*  Snippet code for Operations with images tutorial (not intended to be run but should built successfully) */
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+int main(int,char**)
+{
+    std::string filename = "";
+    // Input/Output
+    {
+        //! [Load an image from a file]
+        Mat img = imread(filename);
+        //! [Load an image from a file]
+        CV_UNUSED(img);
+    }
+    {
+        //! [Load an image from a file in grayscale]
+        Mat img = imread(filename, IMREAD_GRAYSCALE);
+        //! [Load an image from a file in grayscale]
+        CV_UNUSED(img);
+    }
+    {
+        Mat img(4,4,CV_8U);
+        //! [Save image]
+        imwrite(filename, img);
+        //! [Save image]
+    }
+    // Accessing pixel intensity values
+    {
+        Mat img(4,4,CV_8U);
+        int y = 0, x = 0;
+        {
+            //! [Pixel access 1]
+            Scalar intensity = img.at<uchar>(y, x);
+            //! [Pixel access 1]
+            CV_UNUSED(intensity);
+        }
+        {
+            //! [Pixel access 2]
+            Scalar intensity = img.at<uchar>(Point(x, y));
+            //! [Pixel access 2]
+            CV_UNUSED(intensity);
+        }
+        {
+            //! [Pixel access 3]
+            Vec3b intensity = img.at<Vec3b>(y, x);
+            uchar blue = intensity.val[0];
+            uchar green = intensity.val[1];
+            uchar red = intensity.val[2];
+            //! [Pixel access 3]
+            CV_UNUSED(blue);
+            CV_UNUSED(green);
+            CV_UNUSED(red);
+        }
+        {
+            //! [Pixel access 4]
+            Vec3f intensity = img.at<Vec3f>(y, x);
+            float blue = intensity.val[0];
+            float green = intensity.val[1];
+            float red = intensity.val[2];
+            //! [Pixel access 4]
+            CV_UNUSED(blue);
+            CV_UNUSED(green);
+            CV_UNUSED(red);
+        }
+        {
+            //! [Pixel access 5]
+            img.at<uchar>(y, x) = 128;
+            //! [Pixel access 5]
+        }
+        {
+            int i = 0;
+            //! [Mat from points vector]
+            vector<Point2f> points;
+            //... fill the array
+            Mat pointsMat = Mat(points);
+            //! [Mat from points vector]
+
+            //! [Point access]
+            Point2f point = pointsMat.at<Point2f>(i, 0);
+            //! [Point access]
+            CV_UNUSED(point);
+        }
+    }
+    // Memory management and reference counting
+    {
+        //! [Reference counting 1]
+        std::vector<Point3f> points;
+        // .. fill the array
+        Mat pointsMat = Mat(points).reshape(1);
+        //! [Reference counting 1]
+        CV_UNUSED(pointsMat);
+    }
+    {
+        //! [Reference counting 2]
+        Mat img = imread("image.jpg");
+        Mat img1 = img.clone();
+        //! [Reference counting 2]
+        CV_UNUSED(img1);
+    }
+    {
+        //! [Reference counting 3]
+        Mat img = imread("image.jpg");
+        Mat sobelx;
+        Sobel(img, sobelx, CV_32F, 1, 0);
+        //! [Reference counting 3]
+    }
+    // Primitive operations
+    {
+        Mat img;
+        {
+            //! [Set image to black]
+            img = Scalar(0);
+            //! [Set image to black]
+        }
+        {
+            //! [Select ROI]
+            Rect r(10, 10, 100, 100);
+            Mat smallImg = img(r);
+            //! [Select ROI]
+            CV_UNUSED(smallImg);
+        }
+    }
+    {
+        //! [BGR to Gray]
+        Mat img = imread("image.jpg"); // loading a 8UC3 image
+        Mat grey;
+        cvtColor(img, grey, COLOR_BGR2GRAY);
+        //! [BGR to Gray]
+    }
+    {
+        Mat dst, src;
+        //! [Convert to CV_32F]
+        src.convertTo(dst, CV_32F);
+        //! [Convert to CV_32F]
+    }
+    // Visualizing images
+    {
+        //! [imshow 1]
+        Mat img = imread("image.jpg");
+        namedWindow("image", WINDOW_AUTOSIZE);
+        imshow("image", img);
+        waitKey();
+        //! [imshow 1]
+    }
+    {
+        //! [imshow 2]
+        Mat img = imread("image.jpg");
+        Mat grey;
+        cvtColor(img, grey, COLOR_BGR2GRAY);
+        Mat sobelx;
+        Sobel(grey, sobelx, CV_32F, 1, 0);
+        double minVal, maxVal;
+        minMaxLoc(sobelx, &minVal, &maxVal); //find minimum and maximum intensities
+        Mat draw;
+        sobelx.convertTo(draw, CV_8U, 255.0/(maxVal - minVal), -minVal * 255.0/(maxVal - minVal));
+        namedWindow("image", WINDOW_AUTOSIZE);
+        imshow("image", draw);
+        waitKey();
+        //! [imshow 2]
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
new file mode 100644
index 00000000..ac1c2052
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
@@ -0,0 +1,119 @@
+/*  For description look into the help() function. */
+
+#include "opencv2/core.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static void help()
+{
+    cout
+    << "\n---------------------------------------------------------------------------" << endl
+    << "This program shows how to create matrices(cv::Mat) in OpenCV and its serial"
+    << " out capabilities"                                                             << endl
+    << "That is, cv::Mat M(...); M.create and cout << M. "                             << endl
+    << "Shows how output can be formatted to OpenCV, python, numpy, csv and C styles." << endl
+    << "Usage:"                                                                        << endl
+    << "./mat_the_basic_image_container"                                               << endl
+    << "-----------------------------------------------------------------------------" << endl
+    << endl;
+}
+
+int main(int,char**)
+{
+    help();
+    // create by using the constructor
+    //! [constructor]
+    Mat M(2,2, CV_8UC3, Scalar(0,0,255));
+    cout << "M = " << endl << " " << M << endl << endl;
+    //! [constructor]
+
+    // create by using the create function()
+    //! [create]
+    M.create(4,4, CV_8UC(2));
+    cout << "M = "<< endl << " "  << M << endl << endl;
+    //! [create]
+
+    // create multidimensional matrices
+    //! [init]
+    int sz[3] = {2,2,2};
+    Mat L(3,sz, CV_8UC(1), Scalar::all(0));
+    //! [init]
+
+    // Cannot print via operator <<
+
+    // Create using MATLAB style eye, ones or zero matrix
+    //! [matlab]
+    Mat E = Mat::eye(4, 4, CV_64F);
+    cout << "E = " << endl << " " << E << endl << endl;
+    Mat O = Mat::ones(2, 2, CV_32F);
+    cout << "O = " << endl << " " << O << endl << endl;
+    Mat Z = Mat::zeros(3,3, CV_8UC1);
+    cout << "Z = " << endl << " " << Z << endl << endl;
+    //! [matlab]
+
+    // create a 3x3 double-precision identity matrix
+    //! [comma]
+    Mat C = (Mat_<double>(3,3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
+    cout << "C = " << endl << " " << C << endl << endl;
+    //! [comma]
+    // do the same with initializer_list
+#ifdef CV_CXX11
+    //! [list]
+    C = (Mat_<double>({0, -1, 0, -1, 5, -1, 0, -1, 0})).reshape(3);
+    cout << "C = " << endl << " " << C << endl << endl;
+    //! [list]
+#endif
+    //! [clone]
+    Mat RowClone = C.row(1).clone();
+    cout << "RowClone = " << endl << " " << RowClone << endl << endl;
+    //! [clone]
+
+    // Fill a matrix with random values
+    //! [random]
+    Mat R = Mat(3, 2, CV_8UC3);
+    randu(R, Scalar::all(0), Scalar::all(255));
+    //! [random]
+
+    // Demonstrate the output formatting options
+    //! [out-default]
+    cout << "R (default) = " << endl <<        R           << endl << endl;
+    //! [out-default]
+    //! [out-python]
+    cout << "R (python)  = " << endl << format(R, Formatter::FMT_PYTHON) << endl << endl;
+    //! [out-python]
+    //! [out-numpy]
+    cout << "R (numpy)   = " << endl << format(R, Formatter::FMT_NUMPY ) << endl << endl;
+    //! [out-numpy]
+    //! [out-csv]
+    cout << "R (csv)     = " << endl << format(R, Formatter::FMT_CSV   ) << endl << endl;
+    //! [out-csv]
+    //! [out-c]
+    cout << "R (c)       = " << endl << format(R, Formatter::FMT_C     ) << endl << endl;
+    //! [out-c]
+
+    //! [out-point2]
+    Point2f P(5, 1);
+    cout << "Point (2D) = " << P << endl << endl;
+    //! [out-point2]
+
+    //! [out-point3]
+    Point3f P3f(2, 6, 7);
+    cout << "Point (3D) = " << P3f << endl << endl;
+    //! [out-point3]
+
+    //! [out-vector]
+    vector<float> v;
+    v.push_back( (float)CV_PI);   v.push_back(2);    v.push_back(3.01f);
+    cout << "Vector of floats via Mat = " << Mat(v) << endl << endl;
+    //! [out-vector]
+
+    //! [out-vector-points]
+    vector<Point2f> vPoints(20);
+    for (size_t i = 0; i < vPoints.size(); ++i)
+        vPoints[i] = Point2f((float)(i * 5), (float)(i % 7));
+    cout << "A vector of 2D Points = " << vPoints << endl << endl;
+    //! [out-vector-points]
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/parallel_backend/CMakeLists.txt b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/parallel_backend/CMakeLists.txt
new file mode 100644
index 00000000..857d9b76
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/parallel_backend/CMakeLists.txt
@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 3.9)
+
+find_package(OpenCV REQUIRED COMPONENTS opencv_core)
+
+if(NOT OPENCV_EXAMPLES_SKIP_PARALLEL_BACKEND_OPENMP
+    AND NOT OPENCV_EXAMPLES_SKIP_OPENMP
+)
+  find_package(OpenMP)
+  if(OpenMP_FOUND)
+    project(opencv_example_openmp_backend)
+    add_executable(opencv_example_openmp_backend example-openmp.cpp)
+    target_link_libraries(opencv_example_openmp_backend PRIVATE
+        opencv_core
+        OpenMP::OpenMP_CXX
+    )
+  endif()
+endif()
+
+if(NOT OPENCV_EXAMPLES_SKIP_PARALLEL_BACKEND_TBB
+    AND NOT OPENCV_EXAMPLES_SKIP_TBB
+    AND NOT OPENCV_EXAMPLE_SKIP_TBB  # deprecated (to be removed in OpenCV 5.0)
+)
+  find_package(TBB QUIET)
+  if(NOT TBB_FOUND)
+    find_path(TBB_INCLUDE_DIR NAMES "tbb/tbb.h")
+    find_library(TBB_LIBRARY NAMES "tbb")
+  endif()
+  if(TBB_INCLUDE_DIR AND TBB_LIBRARY)
+    project(opencv_example_tbb_backend)
+    add_executable(opencv_example_tbb_backend example-tbb.cpp)
+    target_include_directories(opencv_example_tbb_backend SYSTEM PRIVATE ${TBB_INCLUDE_DIR})
+    target_link_libraries(opencv_example_tbb_backend PRIVATE
+        opencv_core
+        ${TBB_LIBRARY}
+    )
+  endif()
+endif()
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/parallel_backend/example-openmp.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/parallel_backend/example-openmp.cpp
new file mode 100644
index 00000000..aa3f143f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/parallel_backend/example-openmp.cpp
@@ -0,0 +1,44 @@
+#include "opencv2/core.hpp"
+#include <iostream>
+
+#include <chrono>
+#include <thread>
+
+//! [openmp_include]
+#include "opencv2/core/parallel/backend/parallel_for.openmp.hpp"
+//! [openmp_include]
+
+namespace cv { // private.hpp
+CV_EXPORTS const char* currentParallelFramework();
+}
+
+static
+std::string currentParallelFrameworkSafe()
+{
+    const char* framework = cv::currentParallelFramework();
+    if (framework)
+        return framework;
+    return std::string();
+}
+
+using namespace cv;
+int main()
+{
+    std::cout << "OpenCV builtin parallel framework: '" << currentParallelFrameworkSafe() << "' (nthreads=" << getNumThreads() << ")" << std::endl;
+
+    //! [openmp_backend]
+    //omp_set_dynamic(1);
+    cv::parallel::setParallelForBackend(std::make_shared<cv::parallel::openmp::ParallelForBackend>());
+    //! [openmp_backend]
+
+    std::cout << "New parallel backend: '" << currentParallelFrameworkSafe() << "'" << "' (nthreads=" << getNumThreads() << ")" << std::endl;
+
+    parallel_for_(Range(0, 20), [&](const Range range)
+    {
+        std::ostringstream out;
+        out << "Thread " << getThreadNum() << "(opencv=" << utils::getThreadID() << "): range " << range.start << "-" << range.end << std::endl;
+        std::cout << out.str() << std::flush;
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    });
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/parallel_backend/example-tbb.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/parallel_backend/example-tbb.cpp
new file mode 100644
index 00000000..ebf0d260
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/parallel_backend/example-tbb.cpp
@@ -0,0 +1,43 @@
+#include "opencv2/core.hpp"
+#include <iostream>
+
+#include <chrono>
+#include <thread>
+
+//! [tbb_include]
+#include "opencv2/core/parallel/backend/parallel_for.tbb.hpp"
+//! [tbb_include]
+
+namespace cv { // private.hpp
+CV_EXPORTS const char* currentParallelFramework();
+}
+
+static
+std::string currentParallelFrameworkSafe()
+{
+    const char* framework = cv::currentParallelFramework();
+    if (framework)
+        return framework;
+    return std::string();
+}
+
+using namespace cv;
+int main()
+{
+    std::cout << "OpenCV builtin parallel framework: '" << currentParallelFrameworkSafe() << "' (nthreads=" << getNumThreads() << ")" << std::endl;
+
+    //! [tbb_backend]
+    cv::parallel::setParallelForBackend(std::make_shared<cv::parallel::tbb::ParallelForBackend>());
+    //! [tbb_backend]
+
+    std::cout << "New parallel backend: '" << currentParallelFrameworkSafe() << "'" << "' (nthreads=" << getNumThreads() << ")" << std::endl;
+
+    parallel_for_(Range(0, 20), [&](const Range range)
+    {
+        std::ostringstream out;
+        out << "Thread " << getThreadNum() << "(opencv=" << utils::getThreadID() << "): range " << range.start << "-" << range.end << std::endl;
+        std::cout << out.str() << std::flush;
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    });
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/univ_intrin/univ_intrin.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/univ_intrin/univ_intrin.cpp
new file mode 100644
index 00000000..9be4170d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/core/univ_intrin/univ_intrin.cpp
@@ -0,0 +1,230 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/core/simd_intrinsics.hpp>
+
+using namespace std;
+using namespace cv;
+
+const int N = 100005, K = 2000;
+
+namespace
+{
+
+void conv_seq(Mat src, Mat &dst, Mat kernel)
+{
+    int rows = src.rows, cols = src.cols;
+    dst = Mat(rows, cols, CV_8UC1);
+
+    int sz = kernel.rows / 2;
+    copyMakeBorder(src, src, sz, sz, sz, sz, BORDER_REPLICATE);
+    for (int i = 0; i < rows; i++)
+    {
+        uchar *dptr = dst.ptr<uchar>(i);
+        for (int j = 0; j < cols; j++)
+        {
+            float value = 0;
+
+            for (int k = -sz; k <= sz; k++)
+            {
+                // slightly faster results when we create a ptr due to more efficient memory access.
+                uchar *sptr = src.ptr<uchar>(i + sz + k);
+                for (int l = -sz; l <= sz; l++)
+                {
+                    value += kernel.ptr<float>(k + sz)[l + sz] * sptr[j + sz + l];
+                }
+            }
+            dptr[j] = saturate_cast<uchar>(value);
+        }
+    }
+}
+
+//! [convolution-1D-scalar]
+void conv1d(Mat src, Mat &dst, Mat kernel)
+{
+
+    //! [convolution-1D-border]
+    int len = src.cols;
+    dst = Mat(1, len, CV_8UC1);
+
+    int sz = kernel.cols / 2;
+    copyMakeBorder(src, src, 0, 0, sz, sz, BORDER_REPLICATE);
+    //! [convolution-1D-border]
+
+    //! [convolution-1D-scalar-main]
+    for (int i = 0; i < len; i++)
+    {
+        double value = 0;
+        for (int k = -sz; k <= sz; k++)
+            value += src.ptr<uchar>(0)[i + k + sz] * kernel.ptr<float>(0)[k + sz];
+
+        dst.ptr<uchar>(0)[i] = saturate_cast<uchar>(value);
+    }
+    //! [convolution-1D-scalar-main]
+}
+//! [convolution-1D-scalar]
+
+//! [convolution-1D-vector]
+void conv1dsimd(Mat src, Mat kernel, float *ans, int row = 0, int rowk = 0, int len = -1)
+{
+    if (len == -1)
+        len = src.cols;
+
+    //! [convolution-1D-convert]
+    Mat src_32, kernel_32;
+
+    const int alpha = 1;
+    src.convertTo(src_32, CV_32FC1, alpha);
+
+    int ksize = kernel.cols, sz = kernel.cols / 2;
+    copyMakeBorder(src_32, src_32, 0, 0, sz, sz, BORDER_REPLICATE);
+    //! [convolution-1D-convert]
+
+
+    //! [convolution-1D-main]
+    //! [convolution-1D-main-h1]
+    int step = v_float32().nlanes;
+    float *sptr = src_32.ptr<float>(row), *kptr = kernel.ptr<float>(rowk);
+    for (int k = 0; k < ksize; k++)
+    {
+    //! [convolution-1D-main-h1]
+    //! [convolution-1D-main-h2]
+        v_float32 kernel_wide = vx_setall_f32(kptr[k]);
+        int i;
+        for (i = 0; i + step < len; i += step)
+        {
+            v_float32 window = vx_load(sptr + i + k);
+            v_float32 sum = vx_load(ans + i) + kernel_wide * window;
+            v_store(ans + i, sum);
+        }
+    //! [convolution-1D-main-h2]
+
+    //! [convolution-1D-main-h3]
+        for (; i < len; i++)
+        {
+            *(ans + i) += sptr[i + k]*kptr[k];
+        }
+    //! [convolution-1D-main-h3]
+    }
+    //! [convolution-1D-main]
+}
+//! [convolution-1D-vector]
+
+//! [convolution-2D]
+void convolute_simd(Mat src, Mat &dst, Mat kernel)
+{
+    //! [convolution-2D-init]
+    int rows = src.rows, cols = src.cols;
+    int ksize = kernel.rows, sz = ksize / 2;
+    dst = Mat(rows, cols, CV_32FC1);
+
+    copyMakeBorder(src, src, sz, sz, 0, 0, BORDER_REPLICATE);
+
+    int step = v_float32().nlanes;
+    //! [convolution-2D-init]
+
+    //! [convolution-2D-main]
+    for (int i = 0; i < rows; i++)
+    {
+        for (int k = 0; k < ksize; k++)
+        {
+            float ans[N] = {0};
+            conv1dsimd(src, kernel, ans, i + k, k, cols);
+            int j;
+            for (j = 0; j + step < cols; j += step)
+            {
+                v_float32 sum = vx_load(&dst.ptr<float>(i)[j]) + vx_load(&ans[j]);
+                v_store(&dst.ptr<float>(i)[j], sum);
+            }
+
+            for (; j < cols; j++)
+                dst.ptr<float>(i)[j] += ans[j];
+        }
+    }
+    //! [convolution-2D-main]
+
+    //! [convolution-2D-conv]
+    const int alpha = 1;
+    dst.convertTo(dst, CV_8UC1, alpha);
+    //! [convolution-2D-conv]
+}
+//! [convolution-2D]
+
+static void help(char *progName)
+{
+    cout << endl
+            << " This program shows how to use the OpenCV parallel_for_ function and \n"
+            << " compares the performance of the sequential and parallel implementations for a \n"
+            << " convolution operation\n"
+            << " Usage:\n "
+            << progName << " [image_path -- default lena.jpg] " << endl
+            << endl;
+}
+}
+
+int main(int argc, char *argv[])
+{
+
+    //  1-D Convolution  //
+    Mat vsrc(1, N, CV_8UC1), k(1, K, CV_32FC1), vdst;
+    RNG rng(time(0));
+    rng.RNG::fill(vsrc, RNG::UNIFORM, Scalar(0), Scalar(255));
+    rng.RNG::fill(k, RNG::UNIFORM, Scalar(-50), Scalar(50));
+
+    double t = (double)getTickCount();
+    conv1d(vsrc, vdst, k);
+    t = ((double)getTickCount() - t) / getTickFrequency();
+    cout << " Sequential 1-D convolution implementation: " << t << "s" << endl;
+
+    t = (double)getTickCount();
+    float ans[N] = {0};
+    conv1dsimd(vsrc, k, ans);
+    t = ((double)getTickCount() - t) / getTickFrequency();
+    cout << " Vectorized 1-D convolution implementation: " << t << "s" << endl;
+
+    //  2-D Convolution  //
+    help(argv[0]);
+
+    const char *filepath = argc >= 2 ? argv[1] : "../../../../data/lena.jpg";
+
+    Mat src, dst1, dst2, kernel;
+    src = imread(filepath, IMREAD_GRAYSCALE);
+
+    if (src.empty())
+    {
+        cerr << "Can't open [" << filepath << "]" << endl;
+        return EXIT_FAILURE;
+    }
+    namedWindow("Input", 1);
+    namedWindow("Output", 1);
+    imshow("Input", src);
+
+    kernel = (Mat_<float>(3, 3) << 1, 0, -1,
+                                   2, 0, -2,
+                                   1, 0, -1);
+
+    t = (double)getTickCount();
+
+    conv_seq(src, dst1, kernel);
+
+    t = ((double)getTickCount() - t) / getTickFrequency();
+    cout << " Sequential 2-D convolution implementation: " << t << "s" << endl;
+
+    imshow("Output", dst1);
+    waitKey(0);
+
+    t = (double)getTickCount();
+
+    convolute_simd(src, dst2, kernel);
+
+    t = ((double)getTickCount() - t) / getTickFrequency();
+    cout << " Vectorized 2-D convolution implementation: " << t << "s" << endl
+         << endl;
+
+    imshow("Output", dst2);
+    waitKey(0);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp
new file mode 100644
index 00000000..c5978e97
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp
@@ -0,0 +1,98 @@
+#include <opencv2/features2d.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+const float inlier_threshold = 2.5f; // Distance threshold to identify inliers with homography check
+const float nn_match_ratio = 0.8f;   // Nearest neighbor matching ratio
+
+int main(int argc, char* argv[])
+{
+    //! [load]
+    CommandLineParser parser(argc, argv,
+                             "{@img1 | graf1.png | input image 1}"
+                             "{@img2 | graf3.png | input image 2}"
+                             "{@homography | H1to3p.xml | homography matrix}");
+    Mat img1 = imread( samples::findFile( parser.get<String>("@img1") ), IMREAD_GRAYSCALE);
+    Mat img2 = imread( samples::findFile( parser.get<String>("@img2") ), IMREAD_GRAYSCALE);
+
+    Mat homography;
+    FileStorage fs( samples::findFile( parser.get<String>("@homography") ), FileStorage::READ);
+    fs.getFirstTopLevelNode() >> homography;
+    //! [load]
+
+    //! [AKAZE]
+    vector<KeyPoint> kpts1, kpts2;
+    Mat desc1, desc2;
+
+    Ptr<AKAZE> akaze = AKAZE::create();
+    akaze->detectAndCompute(img1, noArray(), kpts1, desc1);
+    akaze->detectAndCompute(img2, noArray(), kpts2, desc2);
+    //! [AKAZE]
+
+    //! [2-nn matching]
+    BFMatcher matcher(NORM_HAMMING);
+    vector< vector<DMatch> > nn_matches;
+    matcher.knnMatch(desc1, desc2, nn_matches, 2);
+    //! [2-nn matching]
+
+    //! [ratio test filtering]
+    vector<KeyPoint> matched1, matched2;
+    for(size_t i = 0; i < nn_matches.size(); i++) {
+        DMatch first = nn_matches[i][0];
+        float dist1 = nn_matches[i][0].distance;
+        float dist2 = nn_matches[i][1].distance;
+
+        if(dist1 < nn_match_ratio * dist2) {
+            matched1.push_back(kpts1[first.queryIdx]);
+            matched2.push_back(kpts2[first.trainIdx]);
+        }
+    }
+    //! [ratio test filtering]
+
+    //! [homography check]
+    vector<DMatch> good_matches;
+    vector<KeyPoint> inliers1, inliers2;
+    for(size_t i = 0; i < matched1.size(); i++) {
+        Mat col = Mat::ones(3, 1, CV_64F);
+        col.at<double>(0) = matched1[i].pt.x;
+        col.at<double>(1) = matched1[i].pt.y;
+
+        col = homography * col;
+        col /= col.at<double>(2);
+        double dist = sqrt( pow(col.at<double>(0) - matched2[i].pt.x, 2) +
+                            pow(col.at<double>(1) - matched2[i].pt.y, 2));
+
+        if(dist < inlier_threshold) {
+            int new_i = static_cast<int>(inliers1.size());
+            inliers1.push_back(matched1[i]);
+            inliers2.push_back(matched2[i]);
+            good_matches.push_back(DMatch(new_i, new_i, 0));
+        }
+    }
+    //! [homography check]
+
+    //! [draw final matches]
+    Mat res;
+    drawMatches(img1, inliers1, img2, inliers2, good_matches, res);
+    imwrite("akaze_result.png", res);
+
+    double inlier_ratio = inliers1.size() / (double) matched1.size();
+    cout << "A-KAZE Matching Results" << endl;
+    cout << "*******************************" << endl;
+    cout << "# Keypoints 1:                        \t" << kpts1.size() << endl;
+    cout << "# Keypoints 2:                        \t" << kpts2.size() << endl;
+    cout << "# Matches:                            \t" << matched1.size() << endl;
+    cout << "# Inliers:                            \t" << inliers1.size() << endl;
+    cout << "# Inliers Ratio:                      \t" << inlier_ratio << endl;
+    cout << endl;
+
+    imshow("result", res);
+    waitKey();
+    //! [draw final matches]
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_tracking/planar_tracking.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_tracking/planar_tracking.cpp
new file mode 100644
index 00000000..83c4daad
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_tracking/planar_tracking.cpp
@@ -0,0 +1,213 @@
+#include <opencv2/features2d.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/calib3d.hpp>
+#include <opencv2/highgui.hpp>      //for imshow
+#include <vector>
+#include <iostream>
+#include <iomanip>
+
+#include "stats.h" // Stats structure definition
+#include "utils.h" // Drawing and printing functions
+
+using namespace std;
+using namespace cv;
+
+const double akaze_thresh = 3e-4; // AKAZE detection threshold set to locate about 1000 keypoints
+const double ransac_thresh = 2.5f; // RANSAC inlier threshold
+const double nn_match_ratio = 0.8f; // Nearest-neighbour matching ratio
+const int bb_min_inliers = 100; // Minimal number of inliers to draw bounding box
+const int stats_update_period = 10; // On-screen statistics are updated every 10 frames
+
+namespace example {
+class Tracker
+{
+public:
+    Tracker(Ptr<Feature2D> _detector, Ptr<DescriptorMatcher> _matcher) :
+        detector(_detector),
+        matcher(_matcher)
+    {}
+
+    void setFirstFrame(const Mat frame, vector<Point2f> bb, string title, Stats& stats);
+    Mat process(const Mat frame, Stats& stats);
+    Ptr<Feature2D> getDetector() {
+        return detector;
+    }
+protected:
+    Ptr<Feature2D> detector;
+    Ptr<DescriptorMatcher> matcher;
+    Mat first_frame, first_desc;
+    vector<KeyPoint> first_kp;
+    vector<Point2f> object_bb;
+};
+
+void Tracker::setFirstFrame(const Mat frame, vector<Point2f> bb, string title, Stats& stats)
+{
+    cv::Point *ptMask = new cv::Point[bb.size()];
+    const Point* ptContain = { &ptMask[0] };
+    int iSize = static_cast<int>(bb.size());
+    for (size_t i=0; i<bb.size(); i++) {
+        ptMask[i].x = static_cast<int>(bb[i].x);
+        ptMask[i].y = static_cast<int>(bb[i].y);
+    }
+    first_frame = frame.clone();
+    cv::Mat matMask = cv::Mat::zeros(frame.size(), CV_8UC1);
+    cv::fillPoly(matMask, &ptContain, &iSize, 1, cv::Scalar::all(255));
+    detector->detectAndCompute(first_frame, matMask, first_kp, first_desc);
+    stats.keypoints = (int)first_kp.size();
+    drawBoundingBox(first_frame, bb);
+    putText(first_frame, title, Point(0, 60), FONT_HERSHEY_PLAIN, 5, Scalar::all(0), 4);
+    object_bb = bb;
+    delete[] ptMask;
+}
+
+Mat Tracker::process(const Mat frame, Stats& stats)
+{
+    TickMeter tm;
+    vector<KeyPoint> kp;
+    Mat desc;
+
+    tm.start();
+    detector->detectAndCompute(frame, noArray(), kp, desc);
+    stats.keypoints = (int)kp.size();
+
+    vector< vector<DMatch> > matches;
+    vector<KeyPoint> matched1, matched2;
+    matcher->knnMatch(first_desc, desc, matches, 2);
+    for(unsigned i = 0; i < matches.size(); i++) {
+        if(matches[i][0].distance < nn_match_ratio * matches[i][1].distance) {
+            matched1.push_back(first_kp[matches[i][0].queryIdx]);
+            matched2.push_back(      kp[matches[i][0].trainIdx]);
+        }
+    }
+    stats.matches = (int)matched1.size();
+
+    Mat inlier_mask, homography;
+    vector<KeyPoint> inliers1, inliers2;
+    vector<DMatch> inlier_matches;
+    if(matched1.size() >= 4) {
+        homography = findHomography(Points(matched1), Points(matched2),
+                                    RANSAC, ransac_thresh, inlier_mask);
+    }
+    tm.stop();
+    stats.fps = 1. / tm.getTimeSec();
+
+    if(matched1.size() < 4 || homography.empty()) {
+        Mat res;
+        hconcat(first_frame, frame, res);
+        stats.inliers = 0;
+        stats.ratio = 0;
+        return res;
+    }
+    for(unsigned i = 0; i < matched1.size(); i++) {
+        if(inlier_mask.at<uchar>(i)) {
+            int new_i = static_cast<int>(inliers1.size());
+            inliers1.push_back(matched1[i]);
+            inliers2.push_back(matched2[i]);
+            inlier_matches.push_back(DMatch(new_i, new_i, 0));
+        }
+    }
+    stats.inliers = (int)inliers1.size();
+    stats.ratio = stats.inliers * 1.0 / stats.matches;
+
+    vector<Point2f> new_bb;
+    perspectiveTransform(object_bb, new_bb, homography);
+    Mat frame_with_bb = frame.clone();
+    if(stats.inliers >= bb_min_inliers) {
+        drawBoundingBox(frame_with_bb, new_bb);
+    }
+    Mat res;
+    drawMatches(first_frame, inliers1, frame_with_bb, inliers2,
+                inlier_matches, res,
+                Scalar(255, 0, 0), Scalar(255, 0, 0));
+    return res;
+}
+}
+
+int main(int argc, char **argv)
+{
+    CommandLineParser parser(argc, argv, "{@input_path |0|input path can be a camera id, like 0,1,2 or a video filename}");
+    parser.printMessage();
+    string input_path = parser.get<string>(0);
+    string video_name = input_path;
+
+    VideoCapture video_in;
+
+    if ( ( isdigit(input_path[0]) && input_path.size() == 1 ) )
+    {
+    int camera_no = input_path[0] - '0';
+        video_in.open( camera_no );
+    }
+    else {
+        video_in.open(video_name);
+    }
+
+    if(!video_in.isOpened()) {
+        cerr << "Couldn't open " << video_name << endl;
+        return 1;
+    }
+
+    Stats stats, akaze_stats, orb_stats;
+    Ptr<AKAZE> akaze = AKAZE::create();
+    akaze->setThreshold(akaze_thresh);
+    Ptr<ORB> orb = ORB::create();
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-Hamming");
+    example::Tracker akaze_tracker(akaze, matcher);
+    example::Tracker orb_tracker(orb, matcher);
+
+    Mat frame;
+    namedWindow(video_name, WINDOW_NORMAL);
+    cout << "\nPress any key to stop the video and select a bounding box" << endl;
+
+    while ( waitKey(1) < 1 )
+    {
+        video_in >> frame;
+        cv::resizeWindow(video_name, frame.size());
+        imshow(video_name, frame);
+    }
+
+    vector<Point2f> bb;
+    cv::Rect uBox = cv::selectROI(video_name, frame);
+    bb.push_back(cv::Point2f(static_cast<float>(uBox.x), static_cast<float>(uBox.y)));
+    bb.push_back(cv::Point2f(static_cast<float>(uBox.x+uBox.width), static_cast<float>(uBox.y)));
+    bb.push_back(cv::Point2f(static_cast<float>(uBox.x+uBox.width), static_cast<float>(uBox.y+uBox.height)));
+    bb.push_back(cv::Point2f(static_cast<float>(uBox.x), static_cast<float>(uBox.y+uBox.height)));
+
+    akaze_tracker.setFirstFrame(frame, bb, "AKAZE", stats);
+    orb_tracker.setFirstFrame(frame, bb, "ORB", stats);
+
+    Stats akaze_draw_stats, orb_draw_stats;
+    Mat akaze_res, orb_res, res_frame;
+    int i = 0;
+    for(;;) {
+        i++;
+        bool update_stats = (i % stats_update_period == 0);
+        video_in >> frame;
+        // stop the program if no more images
+        if(frame.empty()) break;
+
+        akaze_res = akaze_tracker.process(frame, stats);
+        akaze_stats += stats;
+        if(update_stats) {
+            akaze_draw_stats = stats;
+        }
+
+        orb->setMaxFeatures(stats.keypoints);
+        orb_res = orb_tracker.process(frame, stats);
+        orb_stats += stats;
+        if(update_stats) {
+            orb_draw_stats = stats;
+        }
+
+        drawStatistics(akaze_res, akaze_draw_stats);
+        drawStatistics(orb_res, orb_draw_stats);
+        vconcat(akaze_res, orb_res, res_frame);
+        cv::imshow(video_name, res_frame);
+        if(waitKey(1)==27) break; //quit on ESC button
+    }
+    akaze_stats /= i - 1;
+    orb_stats /= i - 1;
+    printStatistics("AKAZE", akaze_stats);
+    printStatistics("ORB", orb_stats);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_tracking/stats.h b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_tracking/stats.h
new file mode 100644
index 00000000..f5e09480
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_tracking/stats.h
@@ -0,0 +1,38 @@
+#ifndef STATS_H
+#define STATS_H
+
+struct Stats
+{
+    int matches;
+    int inliers;
+    double ratio;
+    int keypoints;
+    double fps;
+
+    Stats() : matches(0),
+        inliers(0),
+        ratio(0),
+        keypoints(0),
+        fps(0.)
+    {}
+
+    Stats& operator+=(const Stats& op) {
+        matches += op.matches;
+        inliers += op.inliers;
+        ratio += op.ratio;
+        keypoints += op.keypoints;
+        fps += op.fps;
+        return *this;
+    }
+    Stats& operator/=(int num)
+    {
+        matches /= num;
+        inliers /= num;
+        ratio /= num;
+        keypoints /= num;
+        fps /= num;
+        return *this;
+    }
+};
+
+#endif // STATS_H
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_tracking/utils.h b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_tracking/utils.h
new file mode 100644
index 00000000..b3f3aa56
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/AKAZE_tracking/utils.h
@@ -0,0 +1,62 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <opencv2/core.hpp>
+#include <vector>
+#include "stats.h"
+
+using namespace std;
+using namespace cv;
+
+void drawBoundingBox(Mat image, vector<Point2f> bb);
+void drawStatistics(Mat image, const Stats& stats);
+void printStatistics(string name, Stats stats);
+vector<Point2f> Points(vector<KeyPoint> keypoints);
+Rect2d selectROI(const String &video_name, const Mat &frame);
+
+void drawBoundingBox(Mat image, vector<Point2f> bb)
+{
+    for(unsigned i = 0; i < bb.size() - 1; i++) {
+        line(image, bb[i], bb[i + 1], Scalar(0, 0, 255), 2);
+    }
+    line(image, bb[bb.size() - 1], bb[0], Scalar(0, 0, 255), 2);
+}
+
+void drawStatistics(Mat image, const Stats& stats)
+{
+    static const int font = FONT_HERSHEY_PLAIN;
+    stringstream str1, str2, str3, str4;
+
+    str1 << "Matches: " << stats.matches;
+    str2 << "Inliers: " << stats.inliers;
+    str3 << "Inlier ratio: " << setprecision(2) << stats.ratio;
+    str4 << "FPS: " << std::fixed << setprecision(2) << stats.fps;
+
+    putText(image, str1.str(), Point(0, image.rows - 120), font, 2, Scalar::all(255), 3);
+    putText(image, str2.str(), Point(0, image.rows - 90), font, 2, Scalar::all(255), 3);
+    putText(image, str3.str(), Point(0, image.rows - 60), font, 2, Scalar::all(255), 3);
+    putText(image, str4.str(), Point(0, image.rows - 30), font, 2, Scalar::all(255), 3);
+}
+
+void printStatistics(string name, Stats stats)
+{
+    cout << name << endl;
+    cout << "----------" << endl;
+
+    cout << "Matches " << stats.matches << endl;
+    cout << "Inliers " << stats.inliers << endl;
+    cout << "Inlier ratio " << setprecision(2) << stats.ratio << endl;
+    cout << "Keypoints " << stats.keypoints << endl;
+    cout << "FPS " << std::fixed << setprecision(2) << stats.fps << endl;
+    cout << endl;
+}
+
+vector<Point2f> Points(vector<KeyPoint> keypoints)
+{
+    vector<Point2f> res;
+    for(unsigned i = 0; i < keypoints.size(); i++) {
+        res.push_back(keypoints[i].pt);
+    }
+    return res;
+}
+#endif // UTILS_H
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp
new file mode 100644
index 00000000..acc2faa8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp
@@ -0,0 +1,185 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/calib3d.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace
+{
+enum Pattern { CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
+
+void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners, Pattern patternType = CHESSBOARD)
+{
+    corners.resize(0);
+
+    switch (patternType) {
+    case CHESSBOARD:
+    case CIRCLES_GRID:
+        for( int i = 0; i < boardSize.height; i++ )
+            for( int j = 0; j < boardSize.width; j++ )
+                corners.push_back(Point3f(float(j*squareSize),
+                                          float(i*squareSize), 0));
+        break;
+
+    case ASYMMETRIC_CIRCLES_GRID:
+        for( int i = 0; i < boardSize.height; i++ )
+            for( int j = 0; j < boardSize.width; j++ )
+                corners.push_back(Point3f(float((2*j + i % 2)*squareSize),
+                                          float(i*squareSize), 0));
+        break;
+
+    default:
+        CV_Error(Error::StsBadArg, "Unknown pattern type\n");
+    }
+}
+
+Mat computeHomography(const Mat &R_1to2, const Mat &tvec_1to2, const double d_inv, const Mat &normal)
+{
+    Mat homography = R_1to2 + d_inv * tvec_1to2*normal.t();
+    return homography;
+}
+
+void computeC2MC1(const Mat &R1, const Mat &tvec1, const Mat &R2, const Mat &tvec2,
+                  Mat &R_1to2, Mat &tvec_1to2)
+{
+    //c2Mc1 = c2Mo * oMc1 = c2Mo * c1Mo.inv()
+    R_1to2 = R2 * R1.t();
+    tvec_1to2 = R2 * (-R1.t()*tvec1) + tvec2;
+}
+
+void decomposeHomography(const string &img1Path, const string &img2Path, const Size &patternSize,
+                         const float squareSize, const string &intrinsicsPath)
+{
+    Mat img1 = imread( samples::findFile( img1Path) );
+    Mat img2 = imread( samples::findFile( img2Path) );
+
+    vector<Point2f> corners1, corners2;
+    bool found1 = findChessboardCorners(img1, patternSize, corners1);
+    bool found2 = findChessboardCorners(img2, patternSize, corners2);
+
+    if (!found1 || !found2)
+    {
+        cout << "Error, cannot find the chessboard corners in both images." << endl;
+        return;
+    }
+
+    //! [compute-poses]
+    vector<Point3f> objectPoints;
+    calcChessboardCorners(patternSize, squareSize, objectPoints);
+
+    FileStorage fs( samples::findFile( intrinsicsPath ), FileStorage::READ);
+    Mat cameraMatrix, distCoeffs;
+    fs["camera_matrix"] >> cameraMatrix;
+    fs["distortion_coefficients"] >> distCoeffs;
+
+    Mat rvec1, tvec1;
+    solvePnP(objectPoints, corners1, cameraMatrix, distCoeffs, rvec1, tvec1);
+    Mat rvec2, tvec2;
+    solvePnP(objectPoints, corners2, cameraMatrix, distCoeffs, rvec2, tvec2);
+    //! [compute-poses]
+
+    //! [compute-camera-displacement]
+    Mat R1, R2;
+    Rodrigues(rvec1, R1);
+    Rodrigues(rvec2, R2);
+
+    Mat R_1to2, t_1to2;
+    computeC2MC1(R1, tvec1, R2, tvec2, R_1to2, t_1to2);
+    Mat rvec_1to2;
+    Rodrigues(R_1to2, rvec_1to2);
+    //! [compute-camera-displacement]
+
+    //! [compute-plane-normal-at-camera-pose-1]
+    Mat normal = (Mat_<double>(3,1) << 0, 0, 1);
+    Mat normal1 = R1*normal;
+    //! [compute-plane-normal-at-camera-pose-1]
+
+    //! [compute-plane-distance-to-the-camera-frame-1]
+    Mat origin(3, 1, CV_64F, Scalar(0));
+    Mat origin1 = R1*origin + tvec1;
+    double d_inv1 = 1.0 / normal1.dot(origin1);
+    //! [compute-plane-distance-to-the-camera-frame-1]
+
+    //! [compute-homography-from-camera-displacement]
+    Mat homography_euclidean = computeHomography(R_1to2, t_1to2, d_inv1, normal1);
+    Mat homography = cameraMatrix * homography_euclidean * cameraMatrix.inv();
+
+    homography /= homography.at<double>(2,2);
+    homography_euclidean /= homography_euclidean.at<double>(2,2);
+    //! [compute-homography-from-camera-displacement]
+
+    //! [decompose-homography-from-camera-displacement]
+    vector<Mat> Rs_decomp, ts_decomp, normals_decomp;
+    int solutions = decomposeHomographyMat(homography, cameraMatrix, Rs_decomp, ts_decomp, normals_decomp);
+    cout << "Decompose homography matrix computed from the camera displacement:" << endl << endl;
+    for (int i = 0; i < solutions; i++)
+    {
+      double factor_d1 = 1.0 / d_inv1;
+      Mat rvec_decomp;
+      Rodrigues(Rs_decomp[i], rvec_decomp);
+      cout << "Solution " << i << ":" << endl;
+      cout << "rvec from homography decomposition: " << rvec_decomp.t() << endl;
+      cout << "rvec from camera displacement: " << rvec_1to2.t() << endl;
+      cout << "tvec from homography decomposition: " << ts_decomp[i].t() << " and scaled by d: " << factor_d1 * ts_decomp[i].t() << endl;
+      cout << "tvec from camera displacement: " << t_1to2.t() << endl;
+      cout << "plane normal from homography decomposition: " << normals_decomp[i].t() << endl;
+      cout << "plane normal at camera 1 pose: " << normal1.t() << endl << endl;
+    }
+    //! [decompose-homography-from-camera-displacement]
+
+    //! [estimate homography]
+    Mat H = findHomography(corners1, corners2);
+    //! [estimate homography]
+
+    //! [decompose-homography-estimated-by-findHomography]
+    solutions = decomposeHomographyMat(H, cameraMatrix, Rs_decomp, ts_decomp, normals_decomp);
+    cout << "Decompose homography matrix estimated by findHomography():" << endl << endl;
+    for (int i = 0; i < solutions; i++)
+    {
+      double factor_d1 = 1.0 / d_inv1;
+      Mat rvec_decomp;
+      Rodrigues(Rs_decomp[i], rvec_decomp);
+      cout << "Solution " << i << ":" << endl;
+      cout << "rvec from homography decomposition: " << rvec_decomp.t() << endl;
+      cout << "rvec from camera displacement: " << rvec_1to2.t() << endl;
+      cout << "tvec from homography decomposition: " << ts_decomp[i].t() << " and scaled by d: " << factor_d1 * ts_decomp[i].t() << endl;
+      cout << "tvec from camera displacement: " << t_1to2.t() << endl;
+      cout << "plane normal from homography decomposition: " << normals_decomp[i].t() << endl;
+      cout << "plane normal at camera 1 pose: " << normal1.t() << endl << endl;
+    }
+    //! [decompose-homography-estimated-by-findHomography]
+}
+
+const char* params
+    = "{ help h         |       | print usage }"
+      "{ image1         | left02.jpg | path to the source chessboard image }"
+      "{ image2         | left01.jpg | path to the desired chessboard image }"
+      "{ intrinsics     | left_intrinsics.yml | path to camera intrinsics }"
+      "{ width bw       | 9     | chessboard width }"
+      "{ height bh      | 6     | chessboard height }"
+      "{ square_size    | 0.025 | chessboard square size }";
+}
+
+int main(int argc, char *argv[])
+{
+    CommandLineParser parser(argc, argv, params);
+
+    if ( parser.has("help") )
+    {
+        parser.about( "Code for homography tutorial.\n"
+                      "Example 4: decompose the homography matrix.\n" );
+        parser.printMessage();
+        return 0;
+    }
+
+    Size patternSize(parser.get<int>("width"), parser.get<int>("height"));
+    float squareSize = (float) parser.get<double>("square_size");
+    decomposeHomography(parser.get<String>("image1"),
+                        parser.get<String>("image2"),
+                        patternSize, squareSize,
+                        parser.get<String>("intrinsics"));
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/homography_from_camera_displacement.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/homography_from_camera_displacement.cpp
new file mode 100644
index 00000000..5bcb6dbb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/homography_from_camera_displacement.cpp
@@ -0,0 +1,201 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/calib3d.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace
+{
+enum Pattern { CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
+
+void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners, Pattern patternType = CHESSBOARD)
+{
+    corners.resize(0);
+
+    switch (patternType)
+    {
+    case CHESSBOARD:
+    case CIRCLES_GRID:
+        for( int i = 0; i < boardSize.height; i++ )
+            for( int j = 0; j < boardSize.width; j++ )
+                corners.push_back(Point3f(float(j*squareSize),
+                                          float(i*squareSize), 0));
+        break;
+
+    case ASYMMETRIC_CIRCLES_GRID:
+        for( int i = 0; i < boardSize.height; i++ )
+            for( int j = 0; j < boardSize.width; j++ )
+                corners.push_back(Point3f(float((2*j + i % 2)*squareSize),
+                                          float(i*squareSize), 0));
+        break;
+
+    default:
+        CV_Error(Error::StsBadArg, "Unknown pattern type\n");
+    }
+}
+
+//! [compute-homography]
+Mat computeHomography(const Mat &R_1to2, const Mat &tvec_1to2, const double d_inv, const Mat &normal)
+{
+    Mat homography = R_1to2 + d_inv * tvec_1to2*normal.t();
+    return homography;
+}
+//! [compute-homography]
+
+Mat computeHomography(const Mat &R1, const Mat &tvec1, const Mat &R2, const Mat &tvec2,
+                      const double d_inv, const Mat &normal)
+{
+    Mat homography = R2 * R1.t() + d_inv * (-R2 * R1.t() * tvec1 + tvec2) * normal.t();
+    return homography;
+}
+
+//! [compute-c2Mc1]
+void computeC2MC1(const Mat &R1, const Mat &tvec1, const Mat &R2, const Mat &tvec2,
+                  Mat &R_1to2, Mat &tvec_1to2)
+{
+    //c2Mc1 = c2Mo * oMc1 = c2Mo * c1Mo.inv()
+    R_1to2 = R2 * R1.t();
+    tvec_1to2 = R2 * (-R1.t()*tvec1) + tvec2;
+}
+//! [compute-c2Mc1]
+
+void homographyFromCameraDisplacement(const string &img1Path, const string &img2Path, const Size &patternSize,
+                                      const float squareSize, const string &intrinsicsPath)
+{
+    Mat img1 = imread( samples::findFile( img1Path ) );
+    Mat img2 = imread( samples::findFile( img2Path ) );
+
+    //! [compute-poses]
+    vector<Point2f> corners1, corners2;
+    bool found1 = findChessboardCorners(img1, patternSize, corners1);
+    bool found2 = findChessboardCorners(img2, patternSize, corners2);
+
+    if (!found1 || !found2)
+    {
+        cout << "Error, cannot find the chessboard corners in both images." << endl;
+        return;
+    }
+
+    vector<Point3f> objectPoints;
+    calcChessboardCorners(patternSize, squareSize, objectPoints);
+
+    FileStorage fs( samples::findFile( intrinsicsPath ), FileStorage::READ);
+    Mat cameraMatrix, distCoeffs;
+    fs["camera_matrix"] >> cameraMatrix;
+    fs["distortion_coefficients"] >> distCoeffs;
+
+    Mat rvec1, tvec1;
+    solvePnP(objectPoints, corners1, cameraMatrix, distCoeffs, rvec1, tvec1);
+    Mat rvec2, tvec2;
+    solvePnP(objectPoints, corners2, cameraMatrix, distCoeffs, rvec2, tvec2);
+    //! [compute-poses]
+
+    Mat img1_copy_pose = img1.clone(), img2_copy_pose = img2.clone();
+    Mat img_draw_poses;
+    drawFrameAxes(img1_copy_pose, cameraMatrix, distCoeffs, rvec1, tvec1, 2*squareSize);
+    drawFrameAxes(img2_copy_pose, cameraMatrix, distCoeffs, rvec2, tvec2, 2*squareSize);
+    hconcat(img1_copy_pose, img2_copy_pose, img_draw_poses);
+    imshow("Chessboard poses", img_draw_poses);
+
+    //! [compute-camera-displacement]
+    Mat R1, R2;
+    Rodrigues(rvec1, R1);
+    Rodrigues(rvec2, R2);
+
+    Mat R_1to2, t_1to2;
+    computeC2MC1(R1, tvec1, R2, tvec2, R_1to2, t_1to2);
+    Mat rvec_1to2;
+    Rodrigues(R_1to2, rvec_1to2);
+    //! [compute-camera-displacement]
+
+    //! [compute-plane-normal-at-camera-pose-1]
+    Mat normal = (Mat_<double>(3,1) << 0, 0, 1);
+    Mat normal1 = R1*normal;
+    //! [compute-plane-normal-at-camera-pose-1]
+
+    //! [compute-plane-distance-to-the-camera-frame-1]
+    Mat origin(3, 1, CV_64F, Scalar(0));
+    Mat origin1 = R1*origin + tvec1;
+    double d_inv1 = 1.0 / normal1.dot(origin1);
+    //! [compute-plane-distance-to-the-camera-frame-1]
+
+    //! [compute-homography-from-camera-displacement]
+    Mat homography_euclidean = computeHomography(R_1to2, t_1to2, d_inv1, normal1);
+    Mat homography = cameraMatrix * homography_euclidean * cameraMatrix.inv();
+
+    homography /= homography.at<double>(2,2);
+    homography_euclidean /= homography_euclidean.at<double>(2,2);
+    //! [compute-homography-from-camera-displacement]
+
+    //Same but using absolute camera poses instead of camera displacement, just for check
+    Mat homography_euclidean2 = computeHomography(R1, tvec1, R2, tvec2, d_inv1, normal1);
+    Mat homography2 = cameraMatrix * homography_euclidean2 * cameraMatrix.inv();
+
+    homography_euclidean2 /= homography_euclidean2.at<double>(2,2);
+    homography2 /= homography2.at<double>(2,2);
+
+    cout << "\nEuclidean Homography:\n" << homography_euclidean << endl;
+    cout << "Euclidean Homography 2:\n" << homography_euclidean2 << endl << endl;
+
+    //! [estimate-homography]
+    Mat H = findHomography(corners1, corners2);
+    cout << "\nfindHomography H:\n" << H << endl;
+    //! [estimate-homography]
+
+    cout << "homography from camera displacement:\n" << homography << endl;
+    cout << "homography from absolute camera poses:\n" << homography2 << endl << endl;
+
+    //! [warp-chessboard]
+    Mat img1_warp;
+    warpPerspective(img1, img1_warp, H, img1.size());
+    //! [warp-chessboard]
+
+    Mat img1_warp_custom;
+    warpPerspective(img1, img1_warp_custom, homography, img1.size());
+    imshow("Warped image using homography computed from camera displacement", img1_warp_custom);
+
+    Mat img_draw_compare;
+    hconcat(img1_warp, img1_warp_custom, img_draw_compare);
+    imshow("Warped images comparison", img_draw_compare);
+
+    Mat img1_warp_custom2;
+    warpPerspective(img1, img1_warp_custom2, homography2, img1.size());
+    imshow("Warped image using homography computed from absolute camera poses", img1_warp_custom2);
+
+    waitKey();
+}
+
+const char* params
+    = "{ help h         |       | print usage }"
+      "{ image1         | left02.jpg | path to the source chessboard image }"
+      "{ image2         | left01.jpg | path to the desired chessboard image }"
+      "{ intrinsics     | left_intrinsics.yml | path to camera intrinsics }"
+      "{ width bw       | 9     | chessboard width }"
+      "{ height bh      | 6     | chessboard height }"
+      "{ square_size    | 0.025 | chessboard square size }";
+}
+
+int main(int argc, char *argv[])
+{
+    CommandLineParser parser(argc, argv, params);
+
+    if (parser.has("help"))
+    {
+        parser.about("Code for homography tutorial.\n"
+            "Example 3: homography from the camera displacement.\n");
+        parser.printMessage();
+        return 0;
+    }
+
+    Size patternSize(parser.get<int>("width"), parser.get<int>("height"));
+    float squareSize = (float) parser.get<double>("square_size");
+    homographyFromCameraDisplacement(parser.get<String>("image1"),
+                                     parser.get<String>("image2"),
+                                     patternSize, squareSize,
+                                     parser.get<String>("intrinsics"));
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.cpp
new file mode 100644
index 00000000..3ab29280
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.cpp
@@ -0,0 +1,90 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace
+{
+void basicPanoramaStitching(const string &img1Path, const string &img2Path)
+{
+    Mat img1 = imread( samples::findFile( img1Path ) );
+    Mat img2 = imread( samples::findFile( img2Path ) );
+
+    //! [camera-pose-from-Blender-at-location-1]
+    Mat c1Mo = (Mat_<double>(4,4) << 0.9659258723258972, 0.2588190734386444, 0.0, 1.5529145002365112,
+                                     0.08852133899927139, -0.3303661346435547, -0.9396926164627075, -0.10281121730804443,
+                                     -0.24321036040782928, 0.9076734185218811, -0.342020183801651, 6.130080699920654,
+                                     0, 0, 0, 1);
+    //! [camera-pose-from-Blender-at-location-1]
+
+    //! [camera-pose-from-Blender-at-location-2]
+    Mat c2Mo = (Mat_<double>(4,4) << 0.9659258723258972, -0.2588190734386444, 0.0, -1.5529145002365112,
+                                     -0.08852133899927139, -0.3303661346435547, -0.9396926164627075, -0.10281121730804443,
+                                     0.24321036040782928, 0.9076734185218811, -0.342020183801651, 6.130080699920654,
+                                     0, 0, 0, 1);
+    //! [camera-pose-from-Blender-at-location-2]
+
+    //! [camera-intrinsics-from-Blender]
+    Mat cameraMatrix = (Mat_<double>(3,3) << 700.0, 0.0, 320.0,
+                                             0.0, 700.0, 240.0,
+                                             0, 0, 1);
+    //! [camera-intrinsics-from-Blender]
+
+    //! [extract-rotation]
+    Mat R1 = c1Mo(Range(0,3), Range(0,3));
+    Mat R2 = c2Mo(Range(0,3), Range(0,3));
+    //! [extract-rotation]
+
+    //! [compute-rotation-displacement]
+    //c1Mo * oMc2
+    Mat R_2to1 = R1*R2.t();
+    //! [compute-rotation-displacement]
+
+    //! [compute-homography]
+    Mat H = cameraMatrix * R_2to1 * cameraMatrix.inv();
+    H /= H.at<double>(2,2);
+    cout << "H:\n" << H << endl;
+    //! [compute-homography]
+
+    //! [stitch]
+    Mat img_stitch;
+    warpPerspective(img2, img_stitch, H, Size(img2.cols*2, img2.rows));
+    Mat half = img_stitch(Rect(0, 0, img1.cols, img1.rows));
+    img1.copyTo(half);
+    //! [stitch]
+
+    Mat img_compare;
+    Mat img_space = Mat::zeros(Size(50, img1.rows), CV_8UC3);
+    hconcat(img1, img_space, img_compare);
+    hconcat(img_compare, img2, img_compare);
+    imshow("Compare images", img_compare);
+
+    imshow("Panorama stitching", img_stitch);
+    waitKey();
+}
+
+const char* params
+    = "{ help h   |                      | print usage }"
+      "{ image1   | Blender_Suzanne1.jpg | path to the first Blender image }"
+      "{ image2   | Blender_Suzanne2.jpg | path to the second Blender image }";
+}
+
+int main(int argc, char *argv[])
+{
+    CommandLineParser parser(argc, argv, params);
+
+    if (parser.has("help"))
+    {
+        parser.about( "Code for homography tutorial.\n"
+                      "Example 5: basic panorama stitching from a rotating camera.\n" );
+        parser.printMessage();
+        return 0;
+    }
+
+    basicPanoramaStitching(parser.get<String>("image1"), parser.get<String>("image2"));
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/perspective_correction.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/perspective_correction.cpp
new file mode 100644
index 00000000..9d5bc244
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/perspective_correction.cpp
@@ -0,0 +1,96 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/calib3d.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace
+{
+enum Pattern { CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
+
+Scalar randomColor( RNG& rng )
+{
+  int icolor = (unsigned int) rng;
+  return Scalar( icolor & 255, (icolor >> 8) & 255, (icolor >> 16) & 255 );
+}
+
+void perspectiveCorrection(const string &img1Path, const string &img2Path, const Size &patternSize, RNG &rng)
+{
+    Mat img1 = imread( samples::findFile(img1Path) );
+    Mat img2 = imread( samples::findFile(img2Path) );
+
+    //! [find-corners]
+    vector<Point2f> corners1, corners2;
+    bool found1 = findChessboardCorners(img1, patternSize, corners1);
+    bool found2 = findChessboardCorners(img2, patternSize, corners2);
+    //! [find-corners]
+
+    if (!found1 || !found2)
+    {
+        cout << "Error, cannot find the chessboard corners in both images." << endl;
+        return;
+    }
+
+    //! [estimate-homography]
+    Mat H = findHomography(corners1, corners2);
+    cout << "H:\n" << H << endl;
+    //! [estimate-homography]
+
+    //! [warp-chessboard]
+    Mat img1_warp;
+    warpPerspective(img1, img1_warp, H, img1.size());
+    //! [warp-chessboard]
+
+    Mat img_draw_warp;
+    hconcat(img2, img1_warp, img_draw_warp);
+    imshow("Desired chessboard view / Warped source chessboard view", img_draw_warp);
+
+    //! [compute-transformed-corners]
+    Mat img_draw_matches;
+    hconcat(img1, img2, img_draw_matches);
+    for (size_t i = 0; i < corners1.size(); i++)
+    {
+        Mat pt1 = (Mat_<double>(3,1) << corners1[i].x, corners1[i].y, 1);
+        Mat pt2 = H * pt1;
+        pt2 /= pt2.at<double>(2);
+
+        Point end( (int) (img1.cols + pt2.at<double>(0)), (int) pt2.at<double>(1) );
+        line(img_draw_matches, corners1[i], end, randomColor(rng), 2);
+    }
+
+    imshow("Draw matches", img_draw_matches);
+    waitKey();
+    //! [compute-transformed-corners]
+}
+
+const char* params
+    = "{ help h         |       | print usage }"
+      "{ image1         | left02.jpg | path to the source chessboard image }"
+      "{ image2         | left01.jpg | path to the desired chessboard image }"
+      "{ width bw       | 9     | chessboard width }"
+      "{ height bh      | 6     | chessboard height }";
+}
+
+int main(int argc, char *argv[])
+{
+    cv::RNG rng( 0xFFFFFFFF );
+    CommandLineParser parser(argc, argv, params);
+
+    if (parser.has("help"))
+    {
+        parser.about("Code for homography tutorial.\n"
+            "Example 2: perspective correction.\n");
+        parser.printMessage();
+        return 0;
+    }
+
+    Size patternSize(parser.get<int>("width"), parser.get<int>("height"));
+    perspectiveCorrection(parser.get<String>("image1"),
+                          parser.get<String>("image2"),
+                          patternSize, rng);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/pose_from_homography.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/pose_from_homography.cpp
new file mode 100644
index 00000000..ae86fcfa
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/Homography/pose_from_homography.cpp
@@ -0,0 +1,164 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/calib3d.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace
+{
+enum Pattern { CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
+
+void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners, Pattern patternType = CHESSBOARD)
+{
+    corners.resize(0);
+
+    switch (patternType)
+    {
+    case CHESSBOARD:
+    case CIRCLES_GRID:
+        //! [compute-chessboard-object-points]
+        for( int i = 0; i < boardSize.height; i++ )
+            for( int j = 0; j < boardSize.width; j++ )
+                corners.push_back(Point3f(float(j*squareSize),
+                                          float(i*squareSize), 0));
+        //! [compute-chessboard-object-points]
+        break;
+
+    case ASYMMETRIC_CIRCLES_GRID:
+        for( int i = 0; i < boardSize.height; i++ )
+            for( int j = 0; j < boardSize.width; j++ )
+                corners.push_back(Point3f(float((2*j + i % 2)*squareSize),
+                                          float(i*squareSize), 0));
+        break;
+
+    default:
+        CV_Error(Error::StsBadArg, "Unknown pattern type\n");
+    }
+}
+
+void poseEstimationFromCoplanarPoints(const string &imgPath, const string &intrinsicsPath, const Size &patternSize,
+                                             const float squareSize)
+{
+    Mat img = imread( samples::findFile( imgPath) );
+    Mat img_corners = img.clone(), img_pose = img.clone();
+
+    //! [find-chessboard-corners]
+    vector<Point2f> corners;
+    bool found = findChessboardCorners(img, patternSize, corners);
+    //! [find-chessboard-corners]
+
+    if (!found)
+    {
+        cout << "Cannot find chessboard corners." << endl;
+        return;
+    }
+    drawChessboardCorners(img_corners, patternSize, corners, found);
+    imshow("Chessboard corners detection", img_corners);
+
+    //! [compute-object-points]
+    vector<Point3f> objectPoints;
+    calcChessboardCorners(patternSize, squareSize, objectPoints);
+    vector<Point2f> objectPointsPlanar;
+    for (size_t i = 0; i < objectPoints.size(); i++)
+    {
+        objectPointsPlanar.push_back(Point2f(objectPoints[i].x, objectPoints[i].y));
+    }
+    //! [compute-object-points]
+
+    //! [load-intrinsics]
+    FileStorage fs( samples::findFile( intrinsicsPath ), FileStorage::READ);
+    Mat cameraMatrix, distCoeffs;
+    fs["camera_matrix"] >> cameraMatrix;
+    fs["distortion_coefficients"] >> distCoeffs;
+    //! [load-intrinsics]
+
+    //! [compute-image-points]
+    vector<Point2f> imagePoints;
+    undistortPoints(corners, imagePoints, cameraMatrix, distCoeffs);
+    //! [compute-image-points]
+
+    //! [estimate-homography]
+    Mat H = findHomography(objectPointsPlanar, imagePoints);
+    cout << "H:\n" << H << endl;
+    //! [estimate-homography]
+
+    //! [pose-from-homography]
+    // Normalization to ensure that ||c1|| = 1
+    double norm = sqrt(H.at<double>(0,0)*H.at<double>(0,0) +
+                       H.at<double>(1,0)*H.at<double>(1,0) +
+                       H.at<double>(2,0)*H.at<double>(2,0));
+
+    H /= norm;
+    Mat c1  = H.col(0);
+    Mat c2  = H.col(1);
+    Mat c3 = c1.cross(c2);
+
+    Mat tvec = H.col(2);
+    Mat R(3, 3, CV_64F);
+
+    for (int i = 0; i < 3; i++)
+    {
+        R.at<double>(i,0) = c1.at<double>(i,0);
+        R.at<double>(i,1) = c2.at<double>(i,0);
+        R.at<double>(i,2) = c3.at<double>(i,0);
+    }
+    //! [pose-from-homography]
+
+    //! [polar-decomposition-of-the-rotation-matrix]
+    cout << "R (before polar decomposition):\n" << R << "\ndet(R): " << determinant(R) << endl;
+    Mat_<double> W, U, Vt;
+    SVDecomp(R, W, U, Vt);
+    R = U*Vt;
+    double det = determinant(R);
+    if (det < 0)
+    {
+        Vt.at<double>(2,0) *= -1;
+        Vt.at<double>(2,1) *= -1;
+        Vt.at<double>(2,2) *= -1;
+
+        R = U*Vt;
+    }
+    cout << "R (after polar decomposition):\n" << R << "\ndet(R): " << determinant(R) << endl;
+    //! [polar-decomposition-of-the-rotation-matrix]
+
+    //! [display-pose]
+    Mat rvec;
+    Rodrigues(R, rvec);
+    drawFrameAxes(img_pose, cameraMatrix, distCoeffs, rvec, tvec, 2*squareSize);
+    imshow("Pose from coplanar points", img_pose);
+    waitKey();
+    //! [display-pose]
+}
+
+const char* params
+    = "{ help h         |       | print usage }"
+      "{ image          | left04.jpg | path to a chessboard image }"
+      "{ intrinsics     | left_intrinsics.yml | path to camera intrinsics }"
+      "{ width bw       | 9     | chessboard width }"
+      "{ height bh      | 6     | chessboard height }"
+      "{ square_size    | 0.025 | chessboard square size }";
+}
+
+int main(int argc, char *argv[])
+{
+    CommandLineParser parser(argc, argv, params);
+
+    if (parser.has("help"))
+    {
+        parser.about("Code for homography tutorial.\n"
+            "Example 1: pose from homography with coplanar points.\n");
+        parser.printMessage();
+        return 0;
+    }
+
+    Size patternSize(parser.get<int>("width"), parser.get<int>("height"));
+    float squareSize = (float) parser.get<double>("square_size");
+    poseEstimationFromCoplanarPoints(parser.get<String>("image"),
+                                     parser.get<String>("intrinsics"),
+                                     patternSize, squareSize);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_description/SURF_matching_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_description/SURF_matching_Demo.cpp
new file mode 100644
index 00000000..5c307bb1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_description/SURF_matching_Demo.cpp
@@ -0,0 +1,60 @@
+#include <iostream>
+#include "opencv2/core.hpp"
+#ifdef HAVE_OPENCV_XFEATURES2D
+#include "opencv2/highgui.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+using std::cout;
+using std::endl;
+
+const char* keys =
+    "{ help h |                  | Print help message. }"
+    "{ input1 | box.png          | Path to input image 1. }"
+    "{ input2 | box_in_scene.png | Path to input image 2. }";
+
+int main( int argc, char* argv[] )
+{
+    CommandLineParser parser( argc, argv, keys );
+    Mat img1 = imread( samples::findFile( parser.get<String>("input1") ), IMREAD_GRAYSCALE );
+    Mat img2 = imread( samples::findFile( parser.get<String>("input2") ), IMREAD_GRAYSCALE );
+    if ( img1.empty() || img2.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        parser.printMessage();
+        return -1;
+    }
+
+    //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+    int minHessian = 400;
+    Ptr<SURF> detector = SURF::create( minHessian );
+    std::vector<KeyPoint> keypoints1, keypoints2;
+    Mat descriptors1, descriptors2;
+    detector->detectAndCompute( img1, noArray(), keypoints1, descriptors1 );
+    detector->detectAndCompute( img2, noArray(), keypoints2, descriptors2 );
+
+    //-- Step 2: Matching descriptor vectors with a brute force matcher
+    // Since SURF is a floating-point descriptor NORM_L2 is used
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::BRUTEFORCE);
+    std::vector< DMatch > matches;
+    matcher->match( descriptors1, descriptors2, matches );
+
+    //-- Draw matches
+    Mat img_matches;
+    drawMatches( img1, keypoints1, img2, keypoints2, matches, img_matches );
+
+    //-- Show detected matches
+    imshow("Matches", img_matches );
+
+    waitKey();
+    return 0;
+}
+#else
+int main()
+{
+    std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
+    return 0;
+}
+#endif
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_detection/SURF_detection_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_detection/SURF_detection_Demo.cpp
new file mode 100644
index 00000000..f1256e65
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_detection/SURF_detection_Demo.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+#include "opencv2/core.hpp"
+#ifdef HAVE_OPENCV_XFEATURES2D
+#include "opencv2/highgui.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+using std::cout;
+using std::endl;
+
+int main( int argc, char* argv[] )
+{
+    CommandLineParser parser( argc, argv, "{@input | box.png | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_GRAYSCALE );
+    if ( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+
+    //-- Step 1: Detect the keypoints using SURF Detector
+    int minHessian = 400;
+    Ptr<SURF> detector = SURF::create( minHessian );
+    std::vector<KeyPoint> keypoints;
+    detector->detect( src, keypoints );
+
+    //-- Draw keypoints
+    Mat img_keypoints;
+    drawKeypoints( src, keypoints, img_keypoints );
+
+    //-- Show detected (drawn) keypoints
+    imshow("SURF Keypoints", img_keypoints );
+
+    waitKey();
+    return 0;
+}
+#else
+int main()
+{
+    std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
+    return 0;
+}
+#endif
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_flann_matcher/SURF_FLANN_matching_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_flann_matcher/SURF_FLANN_matching_Demo.cpp
new file mode 100644
index 00000000..e968ab2a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_flann_matcher/SURF_FLANN_matching_Demo.cpp
@@ -0,0 +1,72 @@
+#include <iostream>
+#include "opencv2/core.hpp"
+#ifdef HAVE_OPENCV_XFEATURES2D
+#include "opencv2/highgui.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+using std::cout;
+using std::endl;
+
+const char* keys =
+    "{ help h |                  | Print help message. }"
+    "{ input1 | box.png          | Path to input image 1. }"
+    "{ input2 | box_in_scene.png | Path to input image 2. }";
+
+int main( int argc, char* argv[] )
+{
+    CommandLineParser parser( argc, argv, keys );
+    Mat img1 = imread( samples::findFile( parser.get<String>("input1") ), IMREAD_GRAYSCALE );
+    Mat img2 = imread( samples::findFile( parser.get<String>("input2") ), IMREAD_GRAYSCALE );
+    if ( img1.empty() || img2.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        parser.printMessage();
+        return -1;
+    }
+
+    //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+    int minHessian = 400;
+    Ptr<SURF> detector = SURF::create( minHessian );
+    std::vector<KeyPoint> keypoints1, keypoints2;
+    Mat descriptors1, descriptors2;
+    detector->detectAndCompute( img1, noArray(), keypoints1, descriptors1 );
+    detector->detectAndCompute( img2, noArray(), keypoints2, descriptors2 );
+
+    //-- Step 2: Matching descriptor vectors with a FLANN based matcher
+    // Since SURF is a floating-point descriptor NORM_L2 is used
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
+    std::vector< std::vector<DMatch> > knn_matches;
+    matcher->knnMatch( descriptors1, descriptors2, knn_matches, 2 );
+
+    //-- Filter matches using the Lowe's ratio test
+    const float ratio_thresh = 0.7f;
+    std::vector<DMatch> good_matches;
+    for (size_t i = 0; i < knn_matches.size(); i++)
+    {
+        if (knn_matches[i][0].distance < ratio_thresh * knn_matches[i][1].distance)
+        {
+            good_matches.push_back(knn_matches[i][0]);
+        }
+    }
+
+    //-- Draw matches
+    Mat img_matches;
+    drawMatches( img1, keypoints1, img2, keypoints2, good_matches, img_matches, Scalar::all(-1),
+                 Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
+
+    //-- Show detected matches
+    imshow("Good Matches", img_matches );
+
+    waitKey();
+    return 0;
+}
+#else
+int main()
+{
+    std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
+    return 0;
+}
+#endif
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_homography/SURF_FLANN_matching_homography_Demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_homography/SURF_FLANN_matching_homography_Demo.cpp
new file mode 100644
index 00000000..2aa0bcd9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/features2D/feature_homography/SURF_FLANN_matching_homography_Demo.cpp
@@ -0,0 +1,107 @@
+#include <iostream>
+#include "opencv2/core.hpp"
+#ifdef HAVE_OPENCV_XFEATURES2D
+#include "opencv2/calib3d.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+using namespace cv;
+using namespace cv::xfeatures2d;
+using std::cout;
+using std::endl;
+
+const char* keys =
+        "{ help h |                  | Print help message. }"
+        "{ input1 | box.png          | Path to input image 1. }"
+        "{ input2 | box_in_scene.png | Path to input image 2. }";
+
+int main( int argc, char* argv[] )
+{
+    CommandLineParser parser( argc, argv, keys );
+    Mat img_object = imread( samples::findFile( parser.get<String>("input1") ), IMREAD_GRAYSCALE );
+    Mat img_scene = imread( samples::findFile( parser.get<String>("input2") ), IMREAD_GRAYSCALE );
+    if ( img_object.empty() || img_scene.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        parser.printMessage();
+        return -1;
+    }
+
+    //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+    int minHessian = 400;
+    Ptr<SURF> detector = SURF::create( minHessian );
+    std::vector<KeyPoint> keypoints_object, keypoints_scene;
+    Mat descriptors_object, descriptors_scene;
+    detector->detectAndCompute( img_object, noArray(), keypoints_object, descriptors_object );
+    detector->detectAndCompute( img_scene, noArray(), keypoints_scene, descriptors_scene );
+
+    //-- Step 2: Matching descriptor vectors with a FLANN based matcher
+    // Since SURF is a floating-point descriptor NORM_L2 is used
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
+    std::vector< std::vector<DMatch> > knn_matches;
+    matcher->knnMatch( descriptors_object, descriptors_scene, knn_matches, 2 );
+
+    //-- Filter matches using the Lowe's ratio test
+    const float ratio_thresh = 0.75f;
+    std::vector<DMatch> good_matches;
+    for (size_t i = 0; i < knn_matches.size(); i++)
+    {
+        if (knn_matches[i][0].distance < ratio_thresh * knn_matches[i][1].distance)
+        {
+            good_matches.push_back(knn_matches[i][0]);
+        }
+    }
+
+    //-- Draw matches
+    Mat img_matches;
+    drawMatches( img_object, keypoints_object, img_scene, keypoints_scene, good_matches, img_matches, Scalar::all(-1),
+                 Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
+
+    //-- Localize the object
+    std::vector<Point2f> obj;
+    std::vector<Point2f> scene;
+
+    for( size_t i = 0; i < good_matches.size(); i++ )
+    {
+        //-- Get the keypoints from the good matches
+        obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt );
+        scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt );
+    }
+
+    Mat H = findHomography( obj, scene, RANSAC );
+
+    //-- Get the corners from the image_1 ( the object to be "detected" )
+    std::vector<Point2f> obj_corners(4);
+    obj_corners[0] = Point2f(0, 0);
+    obj_corners[1] = Point2f( (float)img_object.cols, 0 );
+    obj_corners[2] = Point2f( (float)img_object.cols, (float)img_object.rows );
+    obj_corners[3] = Point2f( 0, (float)img_object.rows );
+    std::vector<Point2f> scene_corners(4);
+
+    perspectiveTransform( obj_corners, scene_corners, H);
+
+    //-- Draw lines between the corners (the mapped object in the scene - image_2 )
+    line( img_matches, scene_corners[0] + Point2f((float)img_object.cols, 0),
+          scene_corners[1] + Point2f((float)img_object.cols, 0), Scalar(0, 255, 0), 4 );
+    line( img_matches, scene_corners[1] + Point2f((float)img_object.cols, 0),
+          scene_corners[2] + Point2f((float)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
+    line( img_matches, scene_corners[2] + Point2f((float)img_object.cols, 0),
+          scene_corners[3] + Point2f((float)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
+    line( img_matches, scene_corners[3] + Point2f((float)img_object.cols, 0),
+          scene_corners[0] + Point2f((float)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
+
+    //-- Show detected matches
+    imshow("Good Matches & Object detection", img_matches );
+
+    waitKey();
+    return 0;
+}
+#else
+int main()
+{
+    std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
+    return 0;
+}
+#endif
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp
new file mode 100644
index 00000000..6b4f5769
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp
@@ -0,0 +1,410 @@
+#include "opencv2/opencv_modules.hpp"
+#if defined(HAVE_OPENCV_GAPI)
+
+#include <chrono>
+#include <iomanip>
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+#include "opencv2/gapi.hpp"
+#include "opencv2/gapi/core.hpp"
+#include "opencv2/gapi/imgproc.hpp"
+#include "opencv2/gapi/infer.hpp"
+#include "opencv2/gapi/infer/ie.hpp"
+#include "opencv2/gapi/cpu/gcpukernel.hpp"
+#include "opencv2/gapi/streaming/cap.hpp"
+
+namespace {
+const std::string about =
+    "This is an OpenCV-based version of Security Barrier Camera example";
+const std::string keys =
+    "{ h help |   | print this help message }"
+    "{ input  |   | Path to an input video file }"
+    "{ fdm    |   | IE face detection model IR }"
+    "{ fdw    |   | IE face detection model weights }"
+    "{ fdd    |   | IE face detection device }"
+    "{ agem   |   | IE age/gender recognition model IR }"
+    "{ agew   |   | IE age/gender recognition model weights }"
+    "{ aged   |   | IE age/gender recognition model device }"
+    "{ emom   |   | IE emotions recognition model IR }"
+    "{ emow   |   | IE emotions recognition model weights }"
+    "{ emod   |   | IE emotions recognition model device }"
+    "{ pure   |   | When set, no output is displayed. Useful for benchmarking }"
+    "{ ser    |   | Run serially (no pipelining involved). Useful for benchmarking }";
+
+struct Avg {
+    struct Elapsed {
+        explicit Elapsed(double ms) : ss(ms/1000.), mm(static_cast<int>(ss)/60) {}
+        const double ss;
+        const int    mm;
+    };
+
+    using MS = std::chrono::duration<double, std::ratio<1, 1000>>;
+    using TS = std::chrono::time_point<std::chrono::high_resolution_clock>;
+    TS started;
+
+    void    start() { started = now(); }
+    TS      now() const { return std::chrono::high_resolution_clock::now(); }
+    double  tick() const { return std::chrono::duration_cast<MS>(now() - started).count(); }
+    Elapsed elapsed() const { return Elapsed{tick()}; }
+    double  fps(std::size_t n) const { return static_cast<double>(n) / (tick() / 1000.); }
+};
+std::ostream& operator<<(std::ostream &os, const Avg::Elapsed &e) {
+    os << e.mm << ':' << (e.ss - 60*e.mm);
+    return os;
+}
+} // namespace
+
+namespace custom {
+// Describe networks we use in our program.
+// In G-API, topologies act like "operations". Here we define our
+// topologies as operations which have inputs and outputs.
+
+// Every network requires three parameters to define:
+// 1) Network's TYPE name - this TYPE is then used as a template
+//    parameter to generic functions like cv::gapi::infer<>(),
+//    and is used to define network's configuration (per-backend).
+// 2) Network's SIGNATURE - a std::function<>-like record which defines
+//    networks' input and output parameters (its API)
+// 3) Network's IDENTIFIER - a string defining what the network is.
+//    Must be unique within the pipeline.
+
+// Note: these definitions are neutral to _how_ the networks are
+// executed. The _how_ is defined at graph compilation stage (via parameters),
+// not on the graph construction stage.
+
+//! [G_API_NET]
+// Face detector: takes one Mat, returns another Mat
+G_API_NET(Faces, <cv::GMat(cv::GMat)>, "face-detector");
+
+// Age/Gender recognition - takes one Mat, returns two:
+// one for Age and one for Gender. In G-API, multiple-return-value operations
+// are defined using std::tuple<>.
+using AGInfo = std::tuple<cv::GMat, cv::GMat>;
+G_API_NET(AgeGender, <AGInfo(cv::GMat)>,   "age-gender-recoginition");
+
+// Emotion recognition - takes one Mat, returns another.
+G_API_NET(Emotions, <cv::GMat(cv::GMat)>, "emotions-recognition");
+//! [G_API_NET]
+
+//! [Postproc]
+// SSD Post-processing function - this is not a network but a kernel.
+// The kernel body is declared separately, this is just an interface.
+// This operation takes two Mats (detections and the source image),
+// and returns a vector of ROI (filtered by a default threshold).
+// Threshold (or a class to select) may become a parameter, but since
+// this kernel is custom, it doesn't make a lot of sense.
+G_API_OP(PostProc, <cv::GArray<cv::Rect>(cv::GMat, cv::GMat)>, "custom.fd_postproc") {
+    static cv::GArrayDesc outMeta(const cv::GMatDesc &, const cv::GMatDesc &) {
+        // This function is required for G-API engine to figure out
+        // what the output format is, given the input parameters.
+        // Since the output is an array (with a specific type),
+        // there's nothing to describe.
+        return cv::empty_array_desc();
+    }
+};
+
+// OpenCV-based implementation of the above kernel.
+GAPI_OCV_KERNEL(OCVPostProc, PostProc) {
+    static void run(const cv::Mat &in_ssd_result,
+                    const cv::Mat &in_frame,
+                    std::vector<cv::Rect> &out_faces) {
+        const int MAX_PROPOSALS = 200;
+        const int OBJECT_SIZE   =   7;
+        const cv::Size upscale = in_frame.size();
+        const cv::Rect surface({0,0}, upscale);
+
+        out_faces.clear();
+
+        const float *data = in_ssd_result.ptr<float>();
+        for (int i = 0; i < MAX_PROPOSALS; i++) {
+            const float image_id   = data[i * OBJECT_SIZE + 0]; // batch id
+            const float confidence = data[i * OBJECT_SIZE + 2];
+            const float rc_left    = data[i * OBJECT_SIZE + 3];
+            const float rc_top     = data[i * OBJECT_SIZE + 4];
+            const float rc_right   = data[i * OBJECT_SIZE + 5];
+            const float rc_bottom  = data[i * OBJECT_SIZE + 6];
+
+            if (image_id < 0.f) {  // indicates end of detections
+                break;
+            }
+            if (confidence < 0.5f) { // a hard-coded snapshot
+                continue;
+            }
+
+            // Convert floating-point coordinates to the absolute image
+            // frame coordinates; clip by the source image boundaries.
+            cv::Rect rc;
+            rc.x      = static_cast<int>(rc_left   * upscale.width);
+            rc.y      = static_cast<int>(rc_top    * upscale.height);
+            rc.width  = static_cast<int>(rc_right  * upscale.width)  - rc.x;
+            rc.height = static_cast<int>(rc_bottom * upscale.height) - rc.y;
+            out_faces.push_back(rc & surface);
+        }
+    }
+};
+//! [Postproc]
+
+} // namespace custom
+
+namespace labels {
+const std::string genders[] = {
+    "Female", "Male"
+};
+const std::string emotions[] = {
+    "neutral", "happy", "sad", "surprise", "anger"
+};
+namespace {
+void DrawResults(cv::Mat &frame,
+                 const std::vector<cv::Rect> &faces,
+                 const std::vector<cv::Mat>  &out_ages,
+                 const std::vector<cv::Mat>  &out_genders,
+                 const std::vector<cv::Mat>  &out_emotions) {
+    CV_Assert(faces.size() == out_ages.size());
+    CV_Assert(faces.size() == out_genders.size());
+    CV_Assert(faces.size() == out_emotions.size());
+
+    for (auto it = faces.begin(); it != faces.end(); ++it) {
+        const auto idx = std::distance(faces.begin(), it);
+        const auto &rc = *it;
+
+        const float *ages_data     = out_ages[idx].ptr<float>();
+        const float *genders_data  = out_genders[idx].ptr<float>();
+        const float *emotions_data = out_emotions[idx].ptr<float>();
+        const auto gen_id = std::max_element(genders_data,  genders_data  + 2) - genders_data;
+        const auto emo_id = std::max_element(emotions_data, emotions_data + 5) - emotions_data;
+
+        std::stringstream ss;
+        ss << static_cast<int>(ages_data[0]*100)
+           << ' '
+           << genders[gen_id]
+           << ' '
+           << emotions[emo_id];
+
+        const int ATTRIB_OFFSET = 15;
+        cv::rectangle(frame, rc, {0, 255, 0},  4);
+        cv::putText(frame, ss.str(),
+                    cv::Point(rc.x, rc.y - ATTRIB_OFFSET),
+                    cv::FONT_HERSHEY_COMPLEX_SMALL,
+                    1,
+                    cv::Scalar(0, 0, 255));
+    }
+}
+
+void DrawFPS(cv::Mat &frame, std::size_t n, double fps) {
+    std::ostringstream out;
+    out << "FRAME " << n << ": "
+        << std::fixed << std::setprecision(2) << fps
+        << " FPS (AVG)";
+    cv::putText(frame, out.str(),
+                cv::Point(0, frame.rows),
+                cv::FONT_HERSHEY_SIMPLEX,
+                1,
+                cv::Scalar(0, 255, 0),
+                2);
+}
+} // anonymous namespace
+} // namespace labels
+
+int main(int argc, char *argv[])
+{
+    cv::CommandLineParser cmd(argc, argv, keys);
+    cmd.about(about);
+    if (cmd.has("help")) {
+        cmd.printMessage();
+        return 0;
+    }
+    const std::string input = cmd.get<std::string>("input");
+    const bool no_show = cmd.get<bool>("pure");
+    const bool be_serial = cmd.get<bool>("ser");
+
+    // Express our processing pipeline. Lambda-based constructor
+    // is used to keep all temporary objects in a dedicated scope.
+    //! [GComputation]
+    cv::GComputation pp([]() {
+            // Declare an empty GMat - the beginning of the pipeline.
+            cv::GMat in;
+
+            // Run face detection on the input frame. Result is a single GMat,
+            // internally representing an 1x1x200x7 SSD output.
+            // This is a single-patch version of infer:
+            // - Inference is running on the whole input image;
+            // - Image is converted and resized to the network's expected format
+            //   automatically.
+            cv::GMat detections = cv::gapi::infer<custom::Faces>(in);
+
+            // Parse SSD output to a list of ROI (rectangles) using
+            // a custom kernel. Note: parsing SSD may become a "standard" kernel.
+            cv::GArray<cv::Rect> faces = custom::PostProc::on(detections, in);
+
+            // Now run Age/Gender model on every detected face. This model has two
+            // outputs (for age and gender respectively).
+            // A special ROI-list-oriented form of infer<>() is used here:
+            // - First input argument is the list of rectangles to process,
+            // - Second one is the image where to take ROI from;
+            // - Crop/Resize/Layout conversion happens automatically for every image patch
+            //   from the list
+            // - Inference results are also returned in form of list (GArray<>)
+            // - Since there're two outputs, infer<> return two arrays (via std::tuple).
+            cv::GArray<cv::GMat> ages;
+            cv::GArray<cv::GMat> genders;
+            std::tie(ages, genders) = cv::gapi::infer<custom::AgeGender>(faces, in);
+
+            // Recognize emotions on every face.
+            // ROI-list-oriented infer<>() is used here as well.
+            // Since custom::Emotions network produce a single output, only one
+            // GArray<> is returned here.
+            cv::GArray<cv::GMat> emotions = cv::gapi::infer<custom::Emotions>(faces, in);
+
+            // Return the decoded frame as a result as well.
+            // Input matrix can't be specified as output one, so use copy() here
+            // (this copy will be optimized out in the future).
+            cv::GMat frame = cv::gapi::copy(in);
+
+            // Now specify the computation's boundaries - our pipeline consumes
+            // one images and produces five outputs.
+            return cv::GComputation(cv::GIn(in),
+                                    cv::GOut(frame, faces, ages, genders, emotions));
+        });
+    //! [GComputation]
+
+    // Note: it might be very useful to have dimensions loaded at this point!
+    // After our computation is defined, specify how it should be executed.
+    // Execution is defined by inference backends and kernel backends we use to
+    // compile the pipeline (it is a different step).
+
+    // Declare IE parameters for FaceDetection network. Note here custom::Face
+    // is the type name we specified in GAPI_NETWORK() previously.
+    // cv::gapi::ie::Params<> is a generic configuration description which is
+    // specialized to every particular network we use.
+    //
+    // OpenCV DNN backend will have its own parmater structure with settings
+    // relevant to OpenCV DNN module. Same applies to other possible inference
+    // backends...
+    //! [Param_Cfg]
+    auto det_net = cv::gapi::ie::Params<custom::Faces> {
+        cmd.get<std::string>("fdm"),   // read cmd args: path to topology IR
+        cmd.get<std::string>("fdw"),   // read cmd args: path to weights
+        cmd.get<std::string>("fdd"),   // read cmd args: device specifier
+    };
+
+    auto age_net = cv::gapi::ie::Params<custom::AgeGender> {
+        cmd.get<std::string>("agem"),   // read cmd args: path to topology IR
+        cmd.get<std::string>("agew"),   // read cmd args: path to weights
+        cmd.get<std::string>("aged"),   // read cmd args: device specifier
+    }.cfgOutputLayers({ "age_conv3", "prob" });
+
+    auto emo_net = cv::gapi::ie::Params<custom::Emotions> {
+        cmd.get<std::string>("emom"),   // read cmd args: path to topology IR
+        cmd.get<std::string>("emow"),   // read cmd args: path to weights
+        cmd.get<std::string>("emod"),   // read cmd args: device specifier
+    };
+    //! [Param_Cfg]
+
+    //! [Compile]
+    // Form a kernel package (with a single OpenCV-based implementation of our
+    // post-processing) and a network package (holding our three networks).
+    auto kernels = cv::gapi::kernels<custom::OCVPostProc>();
+    auto networks = cv::gapi::networks(det_net, age_net, emo_net);
+
+    // Compile our pipeline and pass our kernels & networks as
+    // parameters.  This is the place where G-API learns which
+    // networks & kernels we're actually operating with (the graph
+    // description itself known nothing about that).
+    auto cc = pp.compileStreaming(cv::compile_args(kernels, networks));
+    //! [Compile]
+
+    Avg avg;
+    std::size_t frames = 0u;            // Frame counter (not produced by the graph)
+
+    std::cout << "Reading " << input << std::endl;
+    // Duplicate huge portions of the code in if/else branches in the sake of
+    // better documentation snippets
+    if (!be_serial) {
+        //! [Source]
+        auto in_src = cv::gapi::wip::make_src<cv::gapi::wip::GCaptureSource>(input);
+        cc.setSource(cv::gin(in_src));
+        //! [Source]
+
+        avg.start();
+
+        //! [Run]
+        // After data source is specified, start the execution
+        cc.start();
+
+        // Declare data objects we will be receiving from the pipeline.
+        cv::Mat frame;                      // The captured frame itself
+        std::vector<cv::Rect> faces;        // Array of detected faces
+        std::vector<cv::Mat> out_ages;      // Array of inferred ages (one blob per face)
+        std::vector<cv::Mat> out_genders;   // Array of inferred genders (one blob per face)
+        std::vector<cv::Mat> out_emotions;  // Array of classified emotions (one blob per face)
+
+        // Implement different execution policies depending on the display option
+        // for the best performance.
+        while (cc.running()) {
+            auto out_vector = cv::gout(frame, faces, out_ages, out_genders, out_emotions);
+            if (no_show) {
+                // This is purely a video processing. No need to balance
+                // with UI rendering.  Use a blocking pull() to obtain
+                // data. Break the loop if the stream is over.
+                if (!cc.pull(std::move(out_vector)))
+                    break;
+            } else if (!cc.try_pull(std::move(out_vector))) {
+                // Use a non-blocking try_pull() to obtain data.
+                // If there's no data, let UI refresh (and handle keypress)
+                if (cv::waitKey(1) >= 0) break;
+                else continue;
+            }
+            // At this point we have data for sure (obtained in either
+            // blocking or non-blocking way).
+            frames++;
+            labels::DrawResults(frame, faces, out_ages, out_genders, out_emotions);
+            labels::DrawFPS(frame, frames, avg.fps(frames));
+            if (!no_show) cv::imshow("Out", frame);
+        }
+        //! [Run]
+    } else { // (serial flag)
+        //! [Run_Serial]
+        cv::VideoCapture cap(input);
+        cv::Mat in_frame, frame;            // The captured frame itself
+        std::vector<cv::Rect> faces;        // Array of detected faces
+        std::vector<cv::Mat> out_ages;      // Array of inferred ages (one blob per face)
+        std::vector<cv::Mat> out_genders;   // Array of inferred genders (one blob per face)
+        std::vector<cv::Mat> out_emotions;  // Array of classified emotions (one blob per face)
+
+        while (cap.read(in_frame)) {
+            pp.apply(cv::gin(in_frame),
+                     cv::gout(frame, faces, out_ages, out_genders, out_emotions),
+                     cv::compile_args(kernels, networks));
+            labels::DrawResults(frame, faces, out_ages, out_genders, out_emotions);
+            frames++;
+            if (frames == 1u) {
+                // Start timer only after 1st frame processed -- compilation
+                // happens on-the-fly here
+                avg.start();
+            } else {
+                // Measurfe & draw FPS for all other frames
+                labels::DrawFPS(frame, frames, avg.fps(frames-1));
+            }
+            if (!no_show) {
+                cv::imshow("Out", frame);
+                if (cv::waitKey(1) >= 0) break;
+            }
+        }
+        //! [Run_Serial]
+    }
+    std::cout << "Processed " << frames << " frames in " << avg.elapsed()
+              << " (" << avg.fps(frames) << " FPS)" << std::endl;
+    return 0;
+}
+#else
+#include <iostream>
+int main()
+{
+    std::cerr << "This tutorial code requires G-API module "
+                 "with Inference Engine backend to run"
+              << std::endl;
+    return 1;
+}
+#endif  // HAVE_OPECV_GAPI
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp
new file mode 100644
index 00000000..5f672cd5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp
@@ -0,0 +1,253 @@
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/gapi.hpp>
+#include <opencv2/gapi/core.hpp>
+#include <opencv2/gapi/imgproc.hpp>
+
+#include <opencv2/gapi/s11n.hpp>
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/gcommon.hpp>
+
+#include <opencv2/gapi/cpu/gcpukernel.hpp>
+
+#include <opencv2/gapi/fluid/core.hpp>
+#include <opencv2/gapi/fluid/imgproc.hpp>
+
+static void gscalar_example()
+{
+    //! [gscalar_implicit]
+    cv::GMat a;
+    cv::GMat b = a + 1;
+    //! [gscalar_implicit]
+}
+
+static void typed_example()
+{
+    const cv::Size sz(32, 32);
+    cv::Mat
+        in_mat1        (sz, CV_8UC1),
+        in_mat2        (sz, CV_8UC1),
+        out_mat_untyped(sz, CV_8UC1),
+        out_mat_typed1 (sz, CV_8UC1),
+        out_mat_typed2 (sz, CV_8UC1);
+    cv::randu(in_mat1, cv::Scalar::all(0), cv::Scalar::all(255));
+    cv::randu(in_mat2, cv::Scalar::all(0), cv::Scalar::all(255));
+
+    //! [Untyped_Example]
+    // Untyped G-API ///////////////////////////////////////////////////////////
+    cv::GComputation cvtU([]()
+    {
+        cv::GMat in1, in2;
+        cv::GMat out = cv::gapi::add(in1, in2);
+        return cv::GComputation({in1, in2}, {out});
+    });
+    std::vector<cv::Mat> u_ins  = {in_mat1, in_mat2};
+    std::vector<cv::Mat> u_outs = {out_mat_untyped};
+    cvtU.apply(u_ins, u_outs);
+    //! [Untyped_Example]
+
+    //! [Typed_Example]
+    // Typed G-API /////////////////////////////////////////////////////////////
+    cv::GComputationT<cv::GMat (cv::GMat, cv::GMat)> cvtT([](cv::GMat m1, cv::GMat m2)
+    {
+        return m1+m2;
+    });
+    cvtT.apply(in_mat1, in_mat2, out_mat_typed1);
+
+    auto cvtTC =  cvtT.compile(cv::descr_of(in_mat1), cv::descr_of(in_mat2));
+    cvtTC(in_mat1, in_mat2, out_mat_typed2);
+    //! [Typed_Example]
+}
+
+static void bind_serialization_example()
+{
+    // ! [bind after deserialization]
+    cv::GCompiled compd;
+    std::vector<char> bytes;
+    auto graph = cv::gapi::deserialize<cv::GComputation>(bytes);
+    auto meta = cv::gapi::deserialize<cv::GMetaArgs>(bytes);
+
+    compd = graph.compile(std::move(meta), cv::compile_args());
+    auto in_args  = cv::gapi::deserialize<cv::GRunArgs>(bytes);
+    auto out_args = cv::gapi::deserialize<cv::GRunArgs>(bytes);
+    compd(std::move(in_args), cv::gapi::bind(out_args));
+    // ! [bind after deserialization]
+}
+
+static void bind_deserialization_example()
+{
+    // ! [bind before serialization]
+    std::vector<cv::GRunArgP> graph_outs;
+    cv::GRunArgs out_args;
+
+    for (auto &&out : graph_outs) {
+        out_args.emplace_back(cv::gapi::bind(out));
+    }
+    const auto sargsout = cv::gapi::serialize(out_args);
+    // ! [bind before serialization]
+}
+
+struct SimpleCustomType {
+    bool val;
+    bool operator==(const SimpleCustomType& other) const {
+        return val == other.val;
+    }
+};
+
+struct SimpleCustomType2 {
+    int val;
+    std::string name;
+    std::vector<float> vec;
+    std::map<int, uint64_t> mmap;
+    bool operator==(const SimpleCustomType2& other) const {
+        return val == other.val && name == other.name &&
+               vec == other.vec && mmap == other.mmap;
+    }
+};
+
+// ! [S11N usage]
+namespace cv {
+namespace gapi {
+namespace s11n {
+namespace detail {
+template<> struct S11N<SimpleCustomType> {
+    static void serialize(IOStream &os, const SimpleCustomType &p) {
+        os << p.val;
+    }
+    static SimpleCustomType deserialize(IIStream &is) {
+        SimpleCustomType p;
+        is >> p.val;
+        return p;
+    }
+};
+
+template<> struct S11N<SimpleCustomType2> {
+    static void serialize(IOStream &os, const SimpleCustomType2 &p) {
+        os << p.val << p.name << p.vec << p.mmap;
+    }
+    static SimpleCustomType2 deserialize(IIStream &is) {
+        SimpleCustomType2 p;
+        is >> p.val >> p.name >> p.vec >> p.mmap;
+        return p;
+    }
+};
+} // namespace detail
+} // namespace s11n
+} // namespace gapi
+} // namespace cv
+// ! [S11N usage]
+
+namespace cv {
+namespace detail {
+template<> struct CompileArgTag<SimpleCustomType> {
+    static const char* tag() {
+        return "org.opencv.test.simple_custom_type";
+    }
+};
+
+template<> struct CompileArgTag<SimpleCustomType2> {
+    static const char* tag() {
+        return "org.opencv.test.simple_custom_type_2";
+    }
+};
+} // namespace detail
+} // namespace cv
+
+static void s11n_example()
+{
+    SimpleCustomType  customVar1 { false };
+    SimpleCustomType2 customVar2 { 1248, "World", {1280, 720, 640, 480},
+                                   { {5, 32434142342}, {7, 34242432} } };
+
+    std::vector<char> sArgs = cv::gapi::serialize(
+        cv::compile_args(customVar1, customVar2));
+
+    cv::GCompileArgs dArgs = cv::gapi::deserialize<cv::GCompileArgs,
+                                                   SimpleCustomType,
+                                                   SimpleCustomType2>(sArgs);
+
+    SimpleCustomType  dCustomVar1 = cv::gapi::getCompileArg<SimpleCustomType>(dArgs).value();
+    SimpleCustomType2 dCustomVar2 = cv::gapi::getCompileArg<SimpleCustomType2>(dArgs).value();
+
+    (void) dCustomVar1;
+    (void) dCustomVar2;
+}
+
+G_TYPED_KERNEL(IAdd, <cv::GMat(cv::GMat)>, "test.custom.add") {
+    static cv::GMatDesc outMeta(const cv::GMatDesc &in) { return in; }
+};
+G_TYPED_KERNEL(IFilter2D, <cv::GMat(cv::GMat)>, "test.custom.filter2d") {
+    static cv::GMatDesc outMeta(const cv::GMatDesc &in) { return in; }
+};
+G_TYPED_KERNEL(IRGB2YUV, <cv::GMat(cv::GMat)>, "test.custom.add") {
+    static cv::GMatDesc outMeta(const cv::GMatDesc &in) { return in; }
+};
+GAPI_OCV_KERNEL(CustomAdd,      IAdd)      { static void run(cv::Mat, cv::Mat &) {} };
+GAPI_OCV_KERNEL(CustomFilter2D, IFilter2D) { static void run(cv::Mat, cv::Mat &) {} };
+GAPI_OCV_KERNEL(CustomRGB2YUV,  IRGB2YUV)  { static void run(cv::Mat, cv::Mat &) {} };
+
+int main(int argc, char *argv[])
+{
+    if (argc < 3)
+        return -1;
+
+    cv::Mat input = cv::imread(argv[1]);
+    cv::Mat output;
+
+    {
+    //! [graph_def]
+    cv::GMat in;
+    cv::GMat gx = cv::gapi::Sobel(in, CV_32F, 1, 0);
+    cv::GMat gy = cv::gapi::Sobel(in, CV_32F, 0, 1);
+    cv::GMat g  = cv::gapi::sqrt(cv::gapi::mul(gx, gx) + cv::gapi::mul(gy, gy));
+    cv::GMat out = cv::gapi::convertTo(g, CV_8U);
+    //! [graph_def]
+
+    //! [graph_decl_apply]
+    //! [graph_cap_full]
+    cv::GComputation sobelEdge(cv::GIn(in), cv::GOut(out));
+    //! [graph_cap_full]
+    sobelEdge.apply(input, output);
+    //! [graph_decl_apply]
+
+    //! [apply_with_param]
+    cv::GKernelPackage kernels = cv::gapi::combine
+        (cv::gapi::core::fluid::kernels(),
+         cv::gapi::imgproc::fluid::kernels());
+    sobelEdge.apply(input, output, cv::compile_args(kernels));
+    //! [apply_with_param]
+
+    //! [graph_cap_sub]
+    cv::GComputation sobelEdgeSub(cv::GIn(gx, gy), cv::GOut(out));
+    //! [graph_cap_sub]
+    }
+    //! [graph_gen]
+    cv::GComputation sobelEdgeGen([](){
+            cv::GMat in;
+            cv::GMat gx = cv::gapi::Sobel(in, CV_32F, 1, 0);
+            cv::GMat gy = cv::gapi::Sobel(in, CV_32F, 0, 1);
+            cv::GMat g  = cv::gapi::sqrt(cv::gapi::mul(gx, gx) + cv::gapi::mul(gy, gy));
+            cv::GMat out = cv::gapi::convertTo(g, CV_8U);
+            return cv::GComputation(in, out);
+        });
+    //! [graph_gen]
+
+    cv::imwrite(argv[2], output);
+
+    //! [kernels_snippet]
+    cv::GKernelPackage pkg = cv::gapi::kernels
+        < CustomAdd
+        , CustomFilter2D
+        , CustomRGB2YUV
+        >();
+    //! [kernels_snippet]
+
+    // Just call typed example with no input/output - avoid warnings about
+    // unused functions
+    typed_example();
+    gscalar_example();
+    bind_serialization_example();
+    bind_deserialization_example();
+    s11n_example();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/doc_snippets/dynamic_graph_snippets.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/doc_snippets/dynamic_graph_snippets.cpp
new file mode 100644
index 00000000..a6e6a372
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/doc_snippets/dynamic_graph_snippets.cpp
@@ -0,0 +1,68 @@
+#include <opencv2/gapi.hpp>
+#include <opencv2/gapi/cpu/imgproc.hpp>
+#include <opencv2/gapi/imgproc.hpp>
+
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+
+    bool need_first_conversion  = true;
+    bool need_second_conversion = false;
+
+    cv::Size szOut(4, 4);
+    cv::GComputation cc([&](){
+// ! [GIOProtoArgs usage]
+        auto ins = cv::GIn();
+        cv::GMat in1;
+        if (need_first_conversion)
+            ins += cv::GIn(in1);
+
+        cv::GMat in2;
+        if (need_second_conversion)
+            ins += cv::GIn(in2);
+
+        auto outs = cv::GOut();
+        cv::GMat out1 = cv::gapi::resize(in1, szOut);
+        if (need_first_conversion)
+            outs += cv::GOut(out1);
+
+        cv::GMat out2 = cv::gapi::resize(in2, szOut);
+        if (need_second_conversion)
+            outs += cv::GOut(out2);
+// ! [GIOProtoArgs usage]
+        return cv::GComputation(std::move(ins), std::move(outs));
+    });
+
+// ! [GRunArgs usage]
+    auto in_vector = cv::gin();
+
+    cv::Mat in_mat1( 8,  8, CV_8UC3);
+    cv::Mat in_mat2(16, 16, CV_8UC3);
+    cv::randu(in_mat1, cv::Scalar::all(0), cv::Scalar::all(255));
+    cv::randu(in_mat2, cv::Scalar::all(0), cv::Scalar::all(255));
+
+    if (need_first_conversion)
+        in_vector += cv::gin(in_mat1);
+    if (need_second_conversion)
+        in_vector += cv::gin(in_mat2);
+// ! [GRunArgs usage]
+
+// ! [GRunArgsP usage]
+    auto out_vector = cv::gout();
+    cv::Mat out_mat1, out_mat2;
+    if (need_first_conversion)
+        out_vector += cv::gout(out_mat1);
+    if (need_second_conversion)
+        out_vector += cv::gout(out_mat2);
+// ! [GRunArgsP usage]
+
+    auto stream = cc.compileStreaming(cv::compile_args(cv::gapi::imgproc::cpu::kernels()));
+    stream.setSource(std::move(in_vector));
+
+    stream.start();
+    stream.pull(std::move(out_vector));
+    stream.stop();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/doc_snippets/kernel_api_snippets.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/doc_snippets/kernel_api_snippets.cpp
new file mode 100644
index 00000000..a30161d2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/doc_snippets/kernel_api_snippets.cpp
@@ -0,0 +1,157 @@
+// [filter2d_api]
+#include <opencv2/gapi.hpp>
+
+G_TYPED_KERNEL(GFilter2D,
+               <cv::GMat(cv::GMat,int,cv::Mat,cv::Point,double,int,cv::Scalar)>,
+               "org.opencv.imgproc.filters.filter2D")
+{
+    static cv::GMatDesc                 // outMeta's return value type
+    outMeta(cv::GMatDesc    in       ,  // descriptor of input GMat
+            int             ddepth   ,  // depth parameter
+            cv::Mat      /* coeffs */,  // (unused)
+            cv::Point    /* anchor */,  // (unused)
+            double       /* scale  */,  // (unused)
+            int          /* border */,  // (unused)
+            cv::Scalar   /* bvalue */ ) // (unused)
+    {
+        return in.withDepth(ddepth);
+    }
+};
+// [filter2d_api]
+
+cv::GMat filter2D(cv::GMat  ,
+                  int       ,
+                  cv::Mat   ,
+                  cv::Point ,
+                  double    ,
+                  int       ,
+                  cv::Scalar);
+
+// [filter2d_wrap]
+cv::GMat filter2D(cv::GMat   in,
+                  int        ddepth,
+                  cv::Mat    k,
+                  cv::Point  anchor  = cv::Point(-1,-1),
+                  double     scale   = 0.,
+                  int        border  = cv::BORDER_DEFAULT,
+                  cv::Scalar bval    = cv::Scalar(0))
+{
+    return GFilter2D::on(in, ddepth, k, anchor, scale, border, bval);
+}
+// [filter2d_wrap]
+
+// [compound]
+#include <opencv2/gapi/gcompoundkernel.hpp>       // GAPI_COMPOUND_KERNEL()
+
+using PointArray2f = cv::GArray<cv::Point2f>;
+
+G_TYPED_KERNEL(HarrisCorners,
+               <PointArray2f(cv::GMat,int,double,double,int,double)>,
+               "org.opencv.imgproc.harris_corner")
+{
+    static cv::GArrayDesc outMeta(const cv::GMatDesc &,
+                                  int,
+                                  double,
+                                  double,
+                                  int,
+                                  double)
+    {
+        // No special metadata for arrays in G-API (yet)
+        return cv::empty_array_desc();
+    }
+};
+
+// Define Fluid-backend-local kernels which form GoodFeatures
+G_TYPED_KERNEL(HarrisResponse,
+               <cv::GMat(cv::GMat,double,int,double)>,
+               "org.opencv.fluid.harris_response")
+{
+    static cv::GMatDesc outMeta(const cv::GMatDesc &in,
+                                double,
+                                int,
+                                double)
+    {
+        return in.withType(CV_32F, 1);
+    }
+};
+
+G_TYPED_KERNEL(ArrayNMS,
+               <PointArray2f(cv::GMat,int,double)>,
+               "org.opencv.cpu.nms_array")
+{
+    static cv::GArrayDesc outMeta(const cv::GMatDesc &,
+                                  int,
+                                  double)
+    {
+        return cv::empty_array_desc();
+    }
+};
+
+GAPI_COMPOUND_KERNEL(GFluidHarrisCorners, HarrisCorners)
+{
+    static PointArray2f
+    expand(cv::GMat in,
+           int      maxCorners,
+           double   quality,
+           double   minDist,
+           int      blockSize,
+           double   k)
+    {
+        cv::GMat response = HarrisResponse::on(in, quality, blockSize, k);
+        return ArrayNMS::on(response, maxCorners, minDist);
+    }
+};
+
+// Then implement HarrisResponse as Fluid kernel and NMSresponse
+// as a generic (OpenCV) kernel
+// [compound]
+
+// [filter2d_ocv]
+#include <opencv2/gapi/cpu/gcpukernel.hpp>     // GAPI_OCV_KERNEL()
+#include <opencv2/imgproc.hpp>                 // cv::filter2D()
+
+GAPI_OCV_KERNEL(GCPUFilter2D, GFilter2D)
+{
+    static void
+    run(const cv::Mat    &in,       // in - derived from GMat
+        const int         ddepth,   // opaque (passed as-is)
+        const cv::Mat    &k,        // opaque (passed as-is)
+        const cv::Point  &anchor,   // opaque (passed as-is)
+        const double      delta,    // opaque (passed as-is)
+        const int         border,   // opaque (passed as-is)
+        const cv::Scalar &,         // opaque (passed as-is)
+        cv::Mat          &out)      // out - derived from GMat (retval)
+    {
+        cv::filter2D(in, out, ddepth, k, anchor, delta, border);
+    }
+};
+// [filter2d_ocv]
+
+int main(int, char *[])
+{
+    std::cout << "This sample is non-complete. It is used as code snippents in documentation." << std::endl;
+
+cv::Mat conv_kernel_mat;
+
+{
+// [filter2d_on]
+cv::GMat in;
+cv::GMat out = GFilter2D::on(/* GMat    */  in,
+                             /* int     */  -1,
+                             /* Mat     */  conv_kernel_mat,
+                             /* Point   */  cv::Point(-1,-1),
+                             /* double  */  0.,
+                             /* int     */  cv::BORDER_DEFAULT,
+                             /* Scalar  */  cv::Scalar(0));
+// [filter2d_on]
+}
+
+{
+// [filter2d_wrap_call]
+cv::GMat in;
+cv::GMat out = filter2D(in, -1, conv_kernel_mat);
+// [filter2d_wrap_call]
+}
+
+return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp
new file mode 100644
index 00000000..11e61097
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp
@@ -0,0 +1,905 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2018-2019 Intel Corporation
+
+#include "opencv2/opencv_modules.hpp"
+#if defined(HAVE_OPENCV_GAPI)
+
+#include <opencv2/gapi.hpp>
+#include <opencv2/gapi/core.hpp>
+#include <opencv2/gapi/imgproc.hpp>
+#include <opencv2/gapi/fluid/core.hpp>
+#include <opencv2/gapi/infer.hpp>
+#include <opencv2/gapi/infer/ie.hpp>
+#include <opencv2/gapi/cpu/gcpukernel.hpp>
+#include <opencv2/gapi/streaming/cap.hpp>
+
+#include <opencv2/highgui.hpp> // windows
+
+namespace config
+{
+constexpr char       kWinFaceBeautification[] = "FaceBeautificator";
+constexpr char       kWinInput[]              = "Input";
+constexpr char       kParserAbout[]           =
+        "Use this script to run the face beautification algorithm with G-API.";
+constexpr char       kParserOptions[]         =
+"{ help         h ||      print the help message. }"
+
+"{ facepath     f ||      a path to a Face detection model file (.xml).}"
+"{ facedevice     |GPU|   the face detection computation device.}"
+
+"{ landmpath    l ||      a path to a Landmarks detection model file (.xml).}"
+"{ landmdevice    |CPU|   the landmarks detection computation device.}"
+
+"{ input        i ||      a path to an input. Skip to capture from a camera.}"
+"{ boxes        b |false| set true to draw face Boxes in the \"Input\" window.}"
+"{ landmarks    m |false| set true to draw landMarks in the \"Input\" window.}"
+"{ streaming    s |true|  set false to disable stream pipelining.}"
+"{ performance  p |false| set true to disable output displaying.}";
+
+const     cv::Scalar kClrWhite (255, 255, 255);
+const     cv::Scalar kClrGreen (  0, 255,   0);
+const     cv::Scalar kClrYellow(  0, 255, 255);
+
+constexpr float      kConfThresh   = 0.7f;
+
+const     cv::Size   kGKernelSize(5, 5);
+constexpr double     kGSigma       = 0.0;
+constexpr int        kBSize        = 9;
+constexpr double     kBSigmaCol    = 30.0;
+constexpr double     kBSigmaSp     = 30.0;
+constexpr int        kUnshSigma    = 3;
+constexpr float      kUnshStrength = 0.7f;
+constexpr int        kAngDelta     = 1;
+constexpr bool       kClosedLine   = true;
+} // namespace config
+
+namespace
+{
+//! [vec_ROI]
+using VectorROI = std::vector<cv::Rect>;
+//! [vec_ROI]
+using GArrayROI = cv::GArray<cv::Rect>;
+using Contour   = std::vector<cv::Point>;
+using Landmarks = std::vector<cv::Point>;
+
+
+// Wrapper function
+template<typename Tp> inline int toIntRounded(const Tp x)
+{
+    return static_cast<int>(std::lround(x));
+}
+
+//! [toDbl]
+template<typename Tp> inline double toDouble(const Tp x)
+{
+    return static_cast<double>(x);
+}
+//! [toDbl]
+
+struct Avg {
+       struct Elapsed {
+           explicit Elapsed(double ms) : ss(ms / 1000.),
+                                         mm(toIntRounded(ss / 60)) {}
+           const double ss;
+           const int    mm;
+       };
+
+       using MS = std::chrono::duration<double, std::ratio<1, 1000>>;
+       using TS = std::chrono::time_point<std::chrono::high_resolution_clock>;
+       TS started;
+
+       void    start() { started = now(); }
+       TS      now() const { return std::chrono::high_resolution_clock::now(); }
+       double  tick() const { return std::chrono::duration_cast<MS>(now() - started).count(); }
+       Elapsed elapsed() const { return Elapsed{tick()}; }
+       double  fps(std::size_t n) const { return static_cast<double>(n) / (tick() / 1000.); }
+   };
+std::ostream& operator<<(std::ostream &os, const Avg::Elapsed &e) {
+   os << e.mm << ':' << (e.ss - 60*e.mm);
+   return os;
+}
+
+std::string getWeightsPath(const std::string &mdlXMLPath) // mdlXMLPath =
+                                                          // "The/Full/Path.xml"
+{
+    size_t size = mdlXMLPath.size();
+    CV_Assert(mdlXMLPath.substr(size - 4, size)           // The last 4 symbols
+                  == ".xml");                             // must be ".xml"
+    std::string mdlBinPath(mdlXMLPath);
+    return mdlBinPath.replace(size - 3, 3, "bin");        // return
+                                                          // "The/Full/Path.bin"
+}
+} // anonymous namespace
+
+
+
+namespace custom
+{
+using TplPtsFaceElements_Jaw = std::tuple<cv::GArray<Landmarks>,
+                                          cv::GArray<Contour>>;
+
+// Wrapper-functions
+inline int getLineInclinationAngleDegrees(const cv::Point &ptLeft,
+                                          const cv::Point &ptRight);
+inline Contour getForeheadEllipse(const cv::Point &ptJawLeft,
+                                  const cv::Point &ptJawRight,
+                                  const cv::Point &ptJawMiddle);
+inline Contour getEyeEllipse(const cv::Point &ptLeft,
+                             const cv::Point &ptRight);
+inline Contour getPatchedEllipse(const cv::Point &ptLeft,
+                                 const cv::Point &ptRight,
+                                 const cv::Point &ptUp,
+                                 const cv::Point &ptDown);
+
+// Networks
+//! [net_decl]
+G_API_NET(FaceDetector,  <cv::GMat(cv::GMat)>, "face_detector");
+G_API_NET(LandmDetector, <cv::GMat(cv::GMat)>, "landm_detector");
+//! [net_decl]
+
+// Function kernels
+G_TYPED_KERNEL(GBilatFilter, <cv::GMat(cv::GMat,int,double,double)>,
+               "custom.faceb12n.bilateralFilter")
+{
+    static cv::GMatDesc outMeta(cv::GMatDesc in, int,double,double)
+    {
+        return in;
+    }
+};
+
+G_TYPED_KERNEL(GLaplacian, <cv::GMat(cv::GMat,int)>,
+               "custom.faceb12n.Laplacian")
+{
+    static cv::GMatDesc outMeta(cv::GMatDesc in, int)
+    {
+        return in;
+    }
+};
+
+G_TYPED_KERNEL(GFillPolyGContours, <cv::GMat(cv::GMat,cv::GArray<Contour>)>,
+               "custom.faceb12n.fillPolyGContours")
+{
+    static cv::GMatDesc outMeta(cv::GMatDesc in, cv::GArrayDesc)
+    {
+        return in.withType(CV_8U, 1);
+    }
+};
+
+G_TYPED_KERNEL(GPolyLines, <cv::GMat(cv::GMat,cv::GArray<Contour>,bool,
+                                     cv::Scalar)>,
+               "custom.faceb12n.polyLines")
+{
+    static cv::GMatDesc outMeta(cv::GMatDesc in, cv::GArrayDesc,bool,cv::Scalar)
+    {
+        return in;
+    }
+};
+
+G_TYPED_KERNEL(GRectangle, <cv::GMat(cv::GMat,GArrayROI,cv::Scalar)>,
+               "custom.faceb12n.rectangle")
+{
+    static cv::GMatDesc outMeta(cv::GMatDesc in, cv::GArrayDesc,cv::Scalar)
+    {
+        return in;
+    }
+};
+
+G_TYPED_KERNEL(GFacePostProc, <GArrayROI(cv::GMat,cv::GMat,float)>,
+               "custom.faceb12n.faceDetectPostProc")
+{
+    static cv::GArrayDesc outMeta(const cv::GMatDesc&,const cv::GMatDesc&,float)
+    {
+        return cv::empty_array_desc();
+    }
+};
+
+G_TYPED_KERNEL_M(GLandmPostProc, <TplPtsFaceElements_Jaw(cv::GArray<cv::GMat>,
+                                                         GArrayROI)>,
+                 "custom.faceb12n.landmDetectPostProc")
+{
+    static std::tuple<cv::GArrayDesc,cv::GArrayDesc> outMeta(
+                const cv::GArrayDesc&,const cv::GArrayDesc&)
+    {
+        return std::make_tuple(cv::empty_array_desc(), cv::empty_array_desc());
+    }
+};
+
+//! [kern_m_decl]
+using TplFaces_FaceElements  = std::tuple<cv::GArray<Contour>, cv::GArray<Contour>>;
+G_TYPED_KERNEL_M(GGetContours, <TplFaces_FaceElements (cv::GArray<Landmarks>, cv::GArray<Contour>)>,
+                 "custom.faceb12n.getContours")
+{
+    static std::tuple<cv::GArrayDesc,cv::GArrayDesc> outMeta(const cv::GArrayDesc&,const cv::GArrayDesc&)
+    {
+        return std::make_tuple(cv::empty_array_desc(), cv::empty_array_desc());
+    }
+};
+//! [kern_m_decl]
+
+
+// OCV_Kernels
+// This kernel applies Bilateral filter to an input src with default
+//  "cv::bilateralFilter" border argument
+GAPI_OCV_KERNEL(GCPUBilateralFilter, custom::GBilatFilter)
+{
+    static void run(const cv::Mat &src,
+                    const int      diameter,
+                    const double   sigmaColor,
+                    const double   sigmaSpace,
+                          cv::Mat &out)
+    {
+        cv::bilateralFilter(src, out, diameter, sigmaColor, sigmaSpace);
+    }
+};
+
+// This kernel applies Laplace operator to an input src with default
+//  "cv::Laplacian" arguments
+GAPI_OCV_KERNEL(GCPULaplacian, custom::GLaplacian)
+{
+    static void run(const cv::Mat &src,
+                    const int      ddepth,
+                          cv::Mat &out)
+    {
+        cv::Laplacian(src, out, ddepth);
+    }
+};
+
+// This kernel draws given white filled contours "cnts" on a clear Mat "out"
+//  (defined by a Scalar(0)) with standard "cv::fillPoly" arguments.
+//  It should be used to create a mask.
+// The input Mat seems unused inside the function "run", but it is used deeper
+//  in the kernel to define an output size.
+GAPI_OCV_KERNEL(GCPUFillPolyGContours, custom::GFillPolyGContours)
+{
+    static void run(const cv::Mat              &,
+                    const std::vector<Contour> &cnts,
+                          cv::Mat              &out)
+    {
+        out = cv::Scalar(0);
+        cv::fillPoly(out, cnts, config::kClrWhite);
+    }
+};
+
+// This kernel draws given contours on an input src with default "cv::polylines"
+//  arguments
+GAPI_OCV_KERNEL(GCPUPolyLines, custom::GPolyLines)
+{
+    static void run(const cv::Mat              &src,
+                    const std::vector<Contour> &cnts,
+                    const bool                  isClosed,
+                    const cv::Scalar           &color,
+                          cv::Mat              &out)
+    {
+        src.copyTo(out);
+        cv::polylines(out, cnts, isClosed, color);
+    }
+};
+
+// This kernel draws given rectangles on an input src with default
+//  "cv::rectangle" arguments
+GAPI_OCV_KERNEL(GCPURectangle, custom::GRectangle)
+{
+    static void run(const cv::Mat    &src,
+                    const VectorROI  &vctFaceBoxes,
+                    const cv::Scalar &color,
+                          cv::Mat    &out)
+    {
+        src.copyTo(out);
+        for (const cv::Rect &box : vctFaceBoxes)
+        {
+            cv::rectangle(out, box, color);
+        }
+    }
+};
+
+// A face detector outputs a blob with the shape: [1, 1, N, 7], where N is
+//  the number of detected bounding boxes. Structure of an output for every
+//  detected face is the following:
+//  [image_id, label, conf, x_min, y_min, x_max, y_max], all the seven elements
+//  are floating point. For more details please visit:
+// https://github.com/opencv/open_model_zoo/blob/master/intel_models/face-detection-adas-0001
+// This kernel is the face detection output blob parsing that returns a vector
+//  of detected faces' rects:
+//! [fd_pp]
+GAPI_OCV_KERNEL(GCPUFacePostProc, GFacePostProc)
+{
+    static void run(const cv::Mat   &inDetectResult,
+                    const cv::Mat   &inFrame,
+                    const float      faceConfThreshold,
+                          VectorROI &outFaces)
+    {
+        const int kObjectSize  = 7;
+        const int imgCols = inFrame.size().width;
+        const int imgRows = inFrame.size().height;
+        const cv::Rect borders({0, 0}, inFrame.size());
+        outFaces.clear();
+        const int    numOfDetections = inDetectResult.size[2];
+        const float *data            = inDetectResult.ptr<float>();
+        for (int i = 0; i < numOfDetections; i++)
+        {
+            const float faceId         = data[i * kObjectSize + 0];
+            if (faceId < 0.f)  // indicates the end of detections
+            {
+                break;
+            }
+            const float faceConfidence = data[i * kObjectSize + 2];
+            // We can cut detections by the `conf` field
+            //  to avoid mistakes of the detector.
+            if (faceConfidence > faceConfThreshold)
+            {
+                const float left   = data[i * kObjectSize + 3];
+                const float top    = data[i * kObjectSize + 4];
+                const float right  = data[i * kObjectSize + 5];
+                const float bottom = data[i * kObjectSize + 6];
+                // These are normalized coordinates and are between 0 and 1;
+                //  to get the real pixel coordinates we should multiply it by
+                //  the image sizes respectively to the directions:
+                cv::Point tl(toIntRounded(left   * imgCols),
+                             toIntRounded(top    * imgRows));
+                cv::Point br(toIntRounded(right  * imgCols),
+                             toIntRounded(bottom * imgRows));
+                outFaces.push_back(cv::Rect(tl, br) & borders);
+            }
+        }
+    }
+};
+//! [fd_pp]
+
+// This kernel is the facial landmarks detection output Mat parsing for every
+//  detected face; returns a tuple containing a vector of vectors of
+//  face elements' Points and a vector of vectors of jaw's Points:
+// There are 35 landmarks given by the default detector for each face
+//  in a frame; the first 18 of them are face elements (eyes, eyebrows,
+//  a nose, a mouth) and the last 17 - a jaw contour. The detector gives
+//  floating point values for landmarks' normed coordinates relatively
+//  to an input ROI (not the original frame).
+//  For more details please visit:
+// https://github.com/opencv/open_model_zoo/blob/master/intel_models/facial-landmarks-35-adas-0002
+GAPI_OCV_KERNEL(GCPULandmPostProc, GLandmPostProc)
+{
+    static void run(const std::vector<cv::Mat>   &vctDetectResults,
+                    const VectorROI              &vctRects,
+                          std::vector<Landmarks> &vctPtsFaceElems,
+                          std::vector<Contour>   &vctCntJaw)
+    {
+        static constexpr int kNumFaceElems = 18;
+        static constexpr int kNumTotal     = 35;
+        const size_t numFaces = vctRects.size();
+        CV_Assert(vctPtsFaceElems.size() == 0ul);
+        CV_Assert(vctCntJaw.size()       == 0ul);
+        vctPtsFaceElems.reserve(numFaces);
+        vctCntJaw.reserve(numFaces);
+
+        Landmarks ptsFaceElems;
+        Contour   cntJaw;
+        ptsFaceElems.reserve(kNumFaceElems);
+        cntJaw.reserve(kNumTotal - kNumFaceElems);
+
+        for (size_t i = 0; i < numFaces; i++)
+        {
+            const float *data = vctDetectResults[i].ptr<float>();
+            // The face elements points:
+            ptsFaceElems.clear();
+            for (int j = 0; j < kNumFaceElems * 2; j += 2)
+            {
+                cv::Point pt = cv::Point(toIntRounded(data[j]   * vctRects[i].width),
+                                         toIntRounded(data[j+1] * vctRects[i].height)) + vctRects[i].tl();
+                ptsFaceElems.push_back(pt);
+            }
+            vctPtsFaceElems.push_back(ptsFaceElems);
+
+            // The jaw contour points:
+            cntJaw.clear();
+            for(int j = kNumFaceElems * 2; j < kNumTotal * 2; j += 2)
+            {
+                cv::Point pt = cv::Point(toIntRounded(data[j]   * vctRects[i].width),
+                                         toIntRounded(data[j+1] * vctRects[i].height)) + vctRects[i].tl();
+                cntJaw.push_back(pt);
+            }
+            vctCntJaw.push_back(cntJaw);
+        }
+    }
+};
+
+// This kernel is the facial landmarks detection post-processing for every face
+//  detected before; output is a tuple of vectors of detected face contours and
+//  facial elements contours:
+//! [ld_pp_cnts]
+//! [kern_m_impl]
+GAPI_OCV_KERNEL(GCPUGetContours, GGetContours)
+{
+    static void run(const std::vector<Landmarks> &vctPtsFaceElems,  // 18 landmarks of the facial elements
+                    const std::vector<Contour>   &vctCntJaw,        // 17 landmarks of a jaw
+                          std::vector<Contour>   &vctElemsContours,
+                          std::vector<Contour>   &vctFaceContours)
+    {
+//! [kern_m_impl]
+        size_t numFaces = vctCntJaw.size();
+        CV_Assert(numFaces == vctPtsFaceElems.size());
+        CV_Assert(vctElemsContours.size() == 0ul);
+        CV_Assert(vctFaceContours.size()  == 0ul);
+        // vctFaceElemsContours will store all the face elements' contours found
+        //  in an input image, namely 4 elements (two eyes, nose, mouth) for every detected face:
+        vctElemsContours.reserve(numFaces * 4);
+        // vctFaceElemsContours will store all the faces' contours found in an input image:
+        vctFaceContours.reserve(numFaces);
+
+        Contour cntFace, cntLeftEye, cntRightEye, cntNose, cntMouth;
+        cntNose.reserve(4);
+
+        for (size_t i = 0ul; i < numFaces; i++)
+        {
+            // The face elements contours
+
+            // A left eye:
+            // Approximating the lower eye contour by half-ellipse (using eye points) and storing in cntLeftEye:
+            cntLeftEye = getEyeEllipse(vctPtsFaceElems[i][1], vctPtsFaceElems[i][0]);
+            // Pushing the left eyebrow clock-wise:
+            cntLeftEye.insert(cntLeftEye.end(), {vctPtsFaceElems[i][12], vctPtsFaceElems[i][13],
+                                                 vctPtsFaceElems[i][14]});
+
+            // A right eye:
+            // Approximating the lower eye contour by half-ellipse (using eye points) and storing in vctRightEye:
+            cntRightEye = getEyeEllipse(vctPtsFaceElems[i][2], vctPtsFaceElems[i][3]);
+            // Pushing the right eyebrow clock-wise:
+            cntRightEye.insert(cntRightEye.end(), {vctPtsFaceElems[i][15], vctPtsFaceElems[i][16],
+                                                   vctPtsFaceElems[i][17]});
+
+            // A nose:
+            // Storing the nose points clock-wise
+            cntNose.clear();
+            cntNose.insert(cntNose.end(), {vctPtsFaceElems[i][4], vctPtsFaceElems[i][7],
+                                           vctPtsFaceElems[i][5], vctPtsFaceElems[i][6]});
+
+            // A mouth:
+            // Approximating the mouth contour by two half-ellipses (using mouth points) and storing in vctMouth:
+            cntMouth = getPatchedEllipse(vctPtsFaceElems[i][8], vctPtsFaceElems[i][9],
+                                         vctPtsFaceElems[i][10], vctPtsFaceElems[i][11]);
+
+            // Storing all the elements in a vector:
+            vctElemsContours.insert(vctElemsContours.end(), {cntLeftEye, cntRightEye, cntNose, cntMouth});
+
+            // The face contour:
+            // Approximating the forehead contour by half-ellipse (using jaw points) and storing in vctFace:
+            cntFace = getForeheadEllipse(vctCntJaw[i][0], vctCntJaw[i][16], vctCntJaw[i][8]);
+            // The ellipse is drawn clock-wise, but jaw contour points goes vice versa, so it's necessary to push
+            //  cntJaw from the end to the begin using a reverse iterator:
+            std::copy(vctCntJaw[i].crbegin(), vctCntJaw[i].crend(), std::back_inserter(cntFace));
+            // Storing the face contour in another vector:
+            vctFaceContours.push_back(cntFace);
+        }
+    }
+};
+//! [ld_pp_cnts]
+
+// GAPI subgraph functions
+inline cv::GMat unsharpMask(const cv::GMat &src,
+                            const int       sigma,
+                            const float     strength);
+inline cv::GMat mask3C(const cv::GMat &src,
+                       const cv::GMat &mask);
+} // namespace custom
+
+
+// Functions implementation:
+// Returns an angle (in degrees) between a line given by two Points and
+//  the horison. Note that the result depends on the arguments order:
+//! [ld_pp_incl]
+inline int custom::getLineInclinationAngleDegrees(const cv::Point &ptLeft, const cv::Point &ptRight)
+{
+    const cv::Point residual = ptRight - ptLeft;
+    if (residual.y == 0 && residual.x == 0)
+        return 0;
+    else
+        return toIntRounded(atan2(toDouble(residual.y), toDouble(residual.x)) * 180.0 / CV_PI);
+}
+//! [ld_pp_incl]
+
+// Approximates a forehead by half-ellipse using jaw points and some geometry
+//  and then returns points of the contour; "capacity" is used to reserve enough
+//  memory as there will be other points inserted.
+//! [ld_pp_fhd]
+inline Contour custom::getForeheadEllipse(const cv::Point &ptJawLeft,
+                                          const cv::Point &ptJawRight,
+                                          const cv::Point &ptJawLower)
+{
+    Contour cntForehead;
+    // The point amid the top two points of a jaw:
+    const cv::Point ptFaceCenter((ptJawLeft + ptJawRight) / 2);
+    // This will be the center of the ellipse.
+
+    // The angle between the jaw and the vertical:
+    const int angFace = getLineInclinationAngleDegrees(ptJawLeft, ptJawRight);
+    // This will be the inclination of the ellipse
+
+    // Counting the half-axis of the ellipse:
+    const double jawWidth  = cv::norm(ptJawLeft - ptJawRight);
+    // A forehead width equals the jaw width, and we need a half-axis:
+    const int axisX        = toIntRounded(jawWidth / 2.0);
+
+    const double jawHeight = cv::norm(ptFaceCenter - ptJawLower);
+    // According to research, in average a forehead is approximately 2/3 of
+    //  a jaw:
+    const int axisY        = toIntRounded(jawHeight * 2 / 3.0);
+
+    // We need the upper part of an ellipse:
+    static constexpr int kAngForeheadStart = 180;
+    static constexpr int kAngForeheadEnd   = 360;
+    cv::ellipse2Poly(ptFaceCenter, cv::Size(axisX, axisY), angFace, kAngForeheadStart, kAngForeheadEnd,
+                     config::kAngDelta, cntForehead);
+    return cntForehead;
+}
+//! [ld_pp_fhd]
+
+// Approximates the lower eye contour by half-ellipse using eye points and some
+//  geometry and then returns points of the contour.
+//! [ld_pp_eye]
+inline Contour custom::getEyeEllipse(const cv::Point &ptLeft, const cv::Point &ptRight)
+{
+    Contour cntEyeBottom;
+    const cv::Point ptEyeCenter((ptRight + ptLeft) / 2);
+    const int angle = getLineInclinationAngleDegrees(ptLeft, ptRight);
+    const int axisX = toIntRounded(cv::norm(ptRight - ptLeft) / 2.0);
+    // According to research, in average a Y axis of an eye is approximately
+    //  1/3 of an X one.
+    const int axisY = axisX / 3;
+    // We need the lower part of an ellipse:
+    static constexpr int kAngEyeStart = 0;
+    static constexpr int kAngEyeEnd   = 180;
+    cv::ellipse2Poly(ptEyeCenter, cv::Size(axisX, axisY), angle, kAngEyeStart, kAngEyeEnd, config::kAngDelta,
+                     cntEyeBottom);
+    return cntEyeBottom;
+}
+//! [ld_pp_eye]
+
+//This function approximates an object (a mouth) by two half-ellipses using
+//  4 points of the axes' ends and then returns points of the contour:
+inline Contour custom::getPatchedEllipse(const cv::Point &ptLeft,
+                                         const cv::Point &ptRight,
+                                         const cv::Point &ptUp,
+                                         const cv::Point &ptDown)
+{
+    // Shared characteristics for both half-ellipses:
+    const cv::Point ptMouthCenter((ptLeft + ptRight) / 2);
+    const int angMouth = getLineInclinationAngleDegrees(ptLeft, ptRight);
+    const int axisX    = toIntRounded(cv::norm(ptRight - ptLeft) / 2.0);
+
+    // The top half-ellipse:
+    Contour cntMouthTop;
+    const int axisYTop = toIntRounded(cv::norm(ptMouthCenter - ptUp));
+    // We need the upper part of an ellipse:
+    static constexpr int angTopStart = 180;
+    static constexpr int angTopEnd   = 360;
+    cv::ellipse2Poly(ptMouthCenter, cv::Size(axisX, axisYTop), angMouth, angTopStart, angTopEnd, config::kAngDelta, cntMouthTop);
+
+    // The bottom half-ellipse:
+    Contour cntMouth;
+    const int axisYBot = toIntRounded(cv::norm(ptMouthCenter - ptDown));
+    // We need the lower part of an ellipse:
+    static constexpr int angBotStart = 0;
+    static constexpr int angBotEnd   = 180;
+    cv::ellipse2Poly(ptMouthCenter, cv::Size(axisX, axisYBot), angMouth, angBotStart, angBotEnd, config::kAngDelta, cntMouth);
+
+    // Pushing the upper part to vctOut
+    std::copy(cntMouthTop.cbegin(), cntMouthTop.cend(), std::back_inserter(cntMouth));
+    return cntMouth;
+}
+
+//! [unsh]
+inline cv::GMat custom::unsharpMask(const cv::GMat &src,
+                                    const int       sigma,
+                                    const float     strength)
+{
+    cv::GMat blurred   = cv::gapi::medianBlur(src, sigma);
+    cv::GMat laplacian = custom::GLaplacian::on(blurred, CV_8U);
+    return (src - (laplacian * strength));
+}
+//! [unsh]
+
+inline cv::GMat custom::mask3C(const cv::GMat &src,
+                               const cv::GMat &mask)
+{
+    std::tuple<cv::GMat,cv::GMat,cv::GMat> tplIn = cv::gapi::split3(src);
+    cv::GMat masked0 = cv::gapi::mask(std::get<0>(tplIn), mask);
+    cv::GMat masked1 = cv::gapi::mask(std::get<1>(tplIn), mask);
+    cv::GMat masked2 = cv::gapi::mask(std::get<2>(tplIn), mask);
+    return cv::gapi::merge3(masked0, masked1, masked2);
+}
+
+
+int main(int argc, char** argv)
+{
+    cv::namedWindow(config::kWinFaceBeautification, cv::WINDOW_NORMAL);
+    cv::namedWindow(config::kWinInput,              cv::WINDOW_NORMAL);
+
+    cv::CommandLineParser parser(argc, argv, config::kParserOptions);
+    parser.about(config::kParserAbout);
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    // Parsing input arguments
+    const std::string faceXmlPath = parser.get<std::string>("facepath");
+    const std::string faceBinPath = getWeightsPath(faceXmlPath);
+    const std::string faceDevice  = parser.get<std::string>("facedevice");
+
+    const std::string landmXmlPath = parser.get<std::string>("landmpath");
+    const std::string landmBinPath = getWeightsPath(landmXmlPath);
+    const std::string landmDevice  = parser.get<std::string>("landmdevice");
+
+    // Declaring a graph
+    // The version of a pipeline expression with a lambda-based
+    //  constructor is used to keep all temporary objects in a dedicated scope.
+//! [ppl]
+    cv::GComputation pipeline([=]()
+    {
+//! [net_usg_fd]
+        cv::GMat  gimgIn;                                                                           // input
+
+        cv::GMat  faceOut  = cv::gapi::infer<custom::FaceDetector>(gimgIn);
+//! [net_usg_fd]
+        GArrayROI garRects = custom::GFacePostProc::on(faceOut, gimgIn, config::kConfThresh);       // post-proc
+
+//! [net_usg_ld]
+        cv::GArray<cv::GMat> landmOut  = cv::gapi::infer<custom::LandmDetector>(garRects, gimgIn);
+//! [net_usg_ld]
+        cv::GArray<Landmarks> garElems;                                                             // |
+        cv::GArray<Contour>   garJaws;                                                              // |output arrays
+        std::tie(garElems, garJaws)    = custom::GLandmPostProc::on(landmOut, garRects);            // post-proc
+        cv::GArray<Contour> garElsConts;                                                            // face elements
+        cv::GArray<Contour> garFaceConts;                                                           // whole faces
+        std::tie(garElsConts, garFaceConts) = custom::GGetContours::on(garElems, garJaws);          // interpolation
+
+//! [msk_ppline]
+        cv::GMat mskSharp        = custom::GFillPolyGContours::on(gimgIn, garElsConts);             // |
+        cv::GMat mskSharpG       = cv::gapi::gaussianBlur(mskSharp, config::kGKernelSize,           // |
+                                                          config::kGSigma);                         // |
+        cv::GMat mskBlur         = custom::GFillPolyGContours::on(gimgIn, garFaceConts);            // |
+        cv::GMat mskBlurG        = cv::gapi::gaussianBlur(mskBlur, config::kGKernelSize,            // |
+                                                          config::kGSigma);                         // |draw masks
+        // The first argument in mask() is Blur as we want to subtract from                         // |
+        // BlurG the next step:                                                                     // |
+        cv::GMat mskBlurFinal    = mskBlurG - cv::gapi::mask(mskBlurG, mskSharpG);                  // |
+        cv::GMat mskFacesGaussed = mskBlurFinal + mskSharpG;                                        // |
+        cv::GMat mskFacesWhite   = cv::gapi::threshold(mskFacesGaussed, 0, 255, cv::THRESH_BINARY); // |
+        cv::GMat mskNoFaces      = cv::gapi::bitwise_not(mskFacesWhite);                            // |
+//! [msk_ppline]
+
+        cv::GMat gimgBilat       = custom::GBilatFilter::on(gimgIn, config::kBSize,
+                                                            config::kBSigmaCol, config::kBSigmaSp);
+        cv::GMat gimgSharp       = custom::unsharpMask(gimgIn, config::kUnshSigma,
+                                                       config::kUnshStrength);
+        // Applying the masks
+        // Custom function mask3C() should be used instead of just gapi::mask()
+        //  as mask() provides CV_8UC1 source only (and we have CV_8U3C)
+        cv::GMat gimgBilatMasked = custom::mask3C(gimgBilat, mskBlurFinal);
+        cv::GMat gimgSharpMasked = custom::mask3C(gimgSharp, mskSharpG);
+        cv::GMat gimgInMasked    = custom::mask3C(gimgIn,    mskNoFaces);
+        cv::GMat gimgBeautif = gimgBilatMasked + gimgSharpMasked + gimgInMasked;
+        return cv::GComputation(cv::GIn(gimgIn), cv::GOut(gimgBeautif,
+                                                          cv::gapi::copy(gimgIn),
+                                                          garFaceConts,
+                                                          garElsConts,
+                                                          garRects));
+    });
+//! [ppl]
+    // Declaring IE params for networks
+//! [net_param]
+    auto faceParams  = cv::gapi::ie::Params<custom::FaceDetector>
+    {
+        /*std::string*/ faceXmlPath,
+        /*std::string*/ faceBinPath,
+        /*std::string*/ faceDevice
+    };
+    auto landmParams = cv::gapi::ie::Params<custom::LandmDetector>
+    {
+        /*std::string*/ landmXmlPath,
+        /*std::string*/ landmBinPath,
+        /*std::string*/ landmDevice
+    };
+//! [net_param]
+//! [netw]
+    auto networks      = cv::gapi::networks(faceParams, landmParams);
+//! [netw]
+    // Declaring custom and fluid kernels have been used:
+//! [kern_pass_1]
+    auto customKernels = cv::gapi::kernels<custom::GCPUBilateralFilter,
+                                           custom::GCPULaplacian,
+                                           custom::GCPUFillPolyGContours,
+                                           custom::GCPUPolyLines,
+                                           custom::GCPURectangle,
+                                           custom::GCPUFacePostProc,
+                                           custom::GCPULandmPostProc,
+                                           custom::GCPUGetContours>();
+    auto kernels       = cv::gapi::combine(cv::gapi::core::fluid::kernels(),
+                                           customKernels);
+//! [kern_pass_1]
+
+    Avg avg;
+    size_t frames = 0;
+
+    // The flags for drawing/not drawing face boxes or/and landmarks in the
+    //  \"Input\" window:
+    const bool flgBoxes     = parser.get<bool>("boxes");
+    const bool flgLandmarks = parser.get<bool>("landmarks");
+    // The flag to involve stream pipelining:
+    const bool flgStreaming = parser.get<bool>("streaming");
+    // The flag to display the output images or not:
+    const bool flgPerformance = parser.get<bool>("performance");
+    // Now we are ready to compile the pipeline to a stream with specified
+    //  kernels, networks and image format expected to process
+    if (flgStreaming == true)
+    {
+//! [str_comp]
+        cv::GStreamingCompiled stream = pipeline.compileStreaming(cv::compile_args(kernels, networks));
+//! [str_comp]
+        // Setting the source for the stream:
+//! [str_src]
+        if (parser.has("input"))
+        {
+            stream.setSource(cv::gapi::wip::make_src<cv::gapi::wip::GCaptureSource>(parser.get<cv::String>("input")));
+        }
+//! [str_src]
+        else
+        {
+            stream.setSource(cv::gapi::wip::make_src<cv::gapi::wip::GCaptureSource>(0));
+        }
+        // Declaring output variables
+        // Streaming:
+        cv::Mat imgShow;
+        cv::Mat imgBeautif;
+        std::vector<Contour> vctFaceConts, vctElsConts;
+        VectorROI vctRects;
+        if (flgPerformance == true)
+        {
+            auto out_vector = cv::gout(imgBeautif, imgShow, vctFaceConts,
+                                       vctElsConts, vctRects);
+            stream.start();
+            avg.start();
+            while (stream.running())
+            {
+                stream.pull(std::move(out_vector));
+                frames++;
+            }
+        }
+        else // flgPerformance == false
+        {
+//! [str_loop]
+            auto out_vector = cv::gout(imgBeautif, imgShow, vctFaceConts,
+                                       vctElsConts, vctRects);
+            stream.start();
+            avg.start();
+            while (stream.running())
+            {
+                if (!stream.try_pull(std::move(out_vector)))
+                {
+                    // Use a try_pull() to obtain data.
+                    // If there's no data, let UI refresh (and handle keypress)
+                    if (cv::waitKey(1) >= 0) break;
+                    else continue;
+                }
+                frames++;
+                // Drawing face boxes and landmarks if necessary:
+                if (flgLandmarks == true)
+                {
+                    cv::polylines(imgShow, vctFaceConts, config::kClosedLine,
+                                  config::kClrYellow);
+                    cv::polylines(imgShow, vctElsConts, config::kClosedLine,
+                                  config::kClrYellow);
+                }
+                if (flgBoxes == true)
+                    for (auto rect : vctRects)
+                        cv::rectangle(imgShow, rect, config::kClrGreen);
+                cv::imshow(config::kWinInput,              imgShow);
+                cv::imshow(config::kWinFaceBeautification, imgBeautif);
+            }
+//! [str_loop]
+        }
+        std::cout << "Processed " << frames << " frames in " << avg.elapsed()
+                  << " (" << avg.fps(frames) << " FPS)" << std::endl;
+    }
+    else // serial mode:
+    {
+//! [bef_cap]
+#include <opencv2/videoio.hpp>
+        cv::GCompiled cc;
+        cv::VideoCapture cap;
+        if (parser.has("input"))
+        {
+            cap.open(parser.get<cv::String>("input"));
+        }
+//! [bef_cap]
+        else if (!cap.open(0))
+        {
+            std::cout << "No input available" << std::endl;
+            return 1;
+        }
+        if (flgPerformance == true)
+        {
+            while (true)
+            {
+                cv::Mat img;
+                cv::Mat imgShow;
+                cv::Mat imgBeautif;
+                std::vector<Contour> vctFaceConts, vctElsConts;
+                VectorROI vctRects;
+                cap >> img;
+                if (img.empty())
+                {
+                   break;
+                }
+                frames++;
+                if (!cc)
+                {
+                    cc = pipeline.compile(cv::descr_of(img), cv::compile_args(kernels, networks));
+                    avg.start();
+                }
+                cc(cv::gin(img), cv::gout(imgBeautif, imgShow, vctFaceConts,
+                                          vctElsConts, vctRects));
+            }
+        }
+        else // flgPerformance == false
+        {
+//! [bef_loop]
+            while (cv::waitKey(1) < 0)
+            {
+                cv::Mat img;
+                cv::Mat imgShow;
+                cv::Mat imgBeautif;
+                std::vector<Contour> vctFaceConts, vctElsConts;
+                VectorROI vctRects;
+                cap >> img;
+                if (img.empty())
+                {
+                   cv::waitKey();
+                   break;
+                }
+                frames++;
+//! [apply]
+                pipeline.apply(cv::gin(img), cv::gout(imgBeautif, imgShow,
+                                                      vctFaceConts,
+                                                      vctElsConts, vctRects),
+                               cv::compile_args(kernels, networks));
+//! [apply]
+                if (frames == 1)
+                {
+                    // Start timer only after 1st frame processed -- compilation
+                    // happens on-the-fly here
+                    avg.start();
+                }
+                // Drawing face boxes and landmarks if necessary:
+                if (flgLandmarks == true)
+                {
+                    cv::polylines(imgShow, vctFaceConts, config::kClosedLine,
+                                  config::kClrYellow);
+                    cv::polylines(imgShow, vctElsConts, config::kClosedLine,
+                                  config::kClrYellow);
+                }
+                if (flgBoxes == true)
+                    for (auto rect : vctRects)
+                        cv::rectangle(imgShow, rect, config::kClrGreen);
+                cv::imshow(config::kWinInput,              imgShow);
+                cv::imshow(config::kWinFaceBeautification, imgBeautif);
+            }
+        }
+//! [bef_loop]
+        std::cout << "Processed " << frames << " frames in " << avg.elapsed()
+                  << " (" << avg.fps(frames) << " FPS)" << std::endl;
+    }
+    return 0;
+}
+#else
+#include <iostream>
+int main()
+{
+    std::cerr << "This tutorial code requires G-API module "
+                 "with Inference Engine backend to run"
+              << std::endl;
+    return 1;
+}
+#endif  // HAVE_OPECV_GAPI
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi.cpp
new file mode 100644
index 00000000..a6b82e58
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi.cpp
@@ -0,0 +1,107 @@
+/**
+* @brief You will learn how port an existing algorithm to G-API
+* @author Dmitry Matveev, dmitry.matveev@intel.com, based
+*    on sample by Karpushin Vladislav, karpushin@ngs.ru
+*/
+#include "opencv2/opencv_modules.hpp"
+#ifdef HAVE_OPENCV_GAPI
+
+//! [full_sample]
+#include <iostream>
+#include <utility>
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/gapi.hpp"
+#include "opencv2/gapi/core.hpp"
+#include "opencv2/gapi/imgproc.hpp"
+
+//! [calcGST_proto]
+void calcGST(const cv::GMat& inputImg, cv::GMat& imgCoherencyOut, cv::GMat& imgOrientationOut, int w);
+//! [calcGST_proto]
+
+int main()
+{
+    int W = 52;             // window size is WxW
+    double C_Thr = 0.43;    // threshold for coherency
+    int LowThr = 35;        // threshold1 for orientation, it ranges from 0 to 180
+    int HighThr = 57;       // threshold2 for orientation, it ranges from 0 to 180
+
+    cv::Mat imgIn = cv::imread("input.jpg", cv::IMREAD_GRAYSCALE);
+    if (imgIn.empty()) //check whether the image is loaded or not
+    {
+        std::cout << "ERROR : Image cannot be loaded..!!" << std::endl;
+        return -1;
+    }
+
+    //! [main]
+    // Calculate Gradient Structure Tensor and post-process it for output with G-API
+    cv::GMat in;
+    cv::GMat imgCoherency, imgOrientation;
+    calcGST(in, imgCoherency, imgOrientation, W);
+
+    cv::GMat imgCoherencyBin = imgCoherency > C_Thr;
+    cv::GMat imgOrientationBin = cv::gapi::inRange(imgOrientation, LowThr, HighThr);
+    cv::GMat imgBin = imgCoherencyBin & imgOrientationBin;
+    cv::GMat out = cv::gapi::addWeighted(in, 0.5, imgBin, 0.5, 0.0);
+
+    // Normalize extra outputs
+    cv::GMat imgCoherencyNorm = cv::gapi::normalize(imgCoherency, 0, 255, cv::NORM_MINMAX);
+    cv::GMat imgOrientationNorm = cv::gapi::normalize(imgOrientation, 0, 255, cv::NORM_MINMAX);
+
+    // Capture the graph into object segm
+    cv::GComputation segm(cv::GIn(in), cv::GOut(out, imgCoherencyNorm, imgOrientationNorm));
+
+    // Define cv::Mats for output data
+    cv::Mat imgOut, imgOutCoherency, imgOutOrientation;
+
+    // Run the graph
+    segm.apply(cv::gin(imgIn), cv::gout(imgOut, imgOutCoherency, imgOutOrientation));
+
+    cv::imwrite("result.jpg", imgOut);
+    cv::imwrite("Coherency.jpg", imgOutCoherency);
+    cv::imwrite("Orientation.jpg", imgOutOrientation);
+    //! [main]
+
+    return 0;
+}
+//! [calcGST]
+//! [calcGST_header]
+void calcGST(const cv::GMat& inputImg, cv::GMat& imgCoherencyOut, cv::GMat& imgOrientationOut, int w)
+{
+    auto img = cv::gapi::convertTo(inputImg, CV_32F);
+    auto imgDiffX = cv::gapi::Sobel(img, CV_32F, 1, 0, 3);
+    auto imgDiffY = cv::gapi::Sobel(img, CV_32F, 0, 1, 3);
+    auto imgDiffXY = cv::gapi::mul(imgDiffX, imgDiffY);
+    //! [calcGST_header]
+
+    auto imgDiffXX = cv::gapi::mul(imgDiffX, imgDiffX);
+    auto imgDiffYY = cv::gapi::mul(imgDiffY, imgDiffY);
+
+    auto J11 = cv::gapi::boxFilter(imgDiffXX, CV_32F, cv::Size(w, w));
+    auto J22 = cv::gapi::boxFilter(imgDiffYY, CV_32F, cv::Size(w, w));
+    auto J12 = cv::gapi::boxFilter(imgDiffXY, CV_32F, cv::Size(w, w));
+
+    auto tmp1 = J11 + J22;
+    auto tmp2 = J11 - J22;
+    auto tmp22 = cv::gapi::mul(tmp2, tmp2);
+    auto tmp3 = cv::gapi::mul(J12, J12);
+    auto tmp4 = cv::gapi::sqrt(tmp22 + 4.0*tmp3);
+
+    auto lambda1 = tmp1 + tmp4;
+    auto lambda2 = tmp1 - tmp4;
+
+    imgCoherencyOut = (lambda1 - lambda2) / (lambda1 + lambda2);
+    imgOrientationOut = 0.5*cv::gapi::phase(J22 - J11, 2.0*J12, true);
+}
+//! [calcGST]
+
+//! [full_sample]
+
+#else
+#include <iostream>
+int main()
+{
+    std::cerr << "This tutorial code requires G-API module to run" << std::endl;
+}
+#endif  // HAVE_OPECV_GAPI
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi_fluid.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi_fluid.cpp
new file mode 100644
index 00000000..d37ac174
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi_fluid.cpp
@@ -0,0 +1,127 @@
+/**
+* @brief You will learn how port an existing algorithm to G-API
+* @author Dmitry Matveev, dmitry.matveev@intel.com, based
+*    on sample by Karpushin Vladislav, karpushin@ngs.ru
+*/
+#include "opencv2/opencv_modules.hpp"
+#ifdef HAVE_OPENCV_GAPI
+
+//! [full_sample]
+#include <iostream>
+#include <utility>
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/gapi.hpp"
+#include "opencv2/gapi/core.hpp"
+#include "opencv2/gapi/imgproc.hpp"
+//! [fluid_includes]
+#include "opencv2/gapi/fluid/core.hpp"            // Fluid Core kernel library
+#include "opencv2/gapi/fluid/imgproc.hpp"         // Fluid ImgProc kernel library
+//! [fluid_includes]
+#include "opencv2/gapi/fluid/gfluidkernel.hpp"    // Fluid user kernel API
+
+//! [calcGST_proto]
+void calcGST(const cv::GMat& inputImg, cv::GMat& imgCoherencyOut, cv::GMat& imgOrientationOut, int w);
+//! [calcGST_proto]
+
+int main()
+{
+    int W = 52;             // window size is WxW
+    double C_Thr = 0.43;    // threshold for coherency
+    int LowThr = 35;        // threshold1 for orientation, it ranges from 0 to 180
+    int HighThr = 57;       // threshold2 for orientation, it ranges from 0 to 180
+
+    cv::Mat imgIn = cv::imread("input.jpg", cv::IMREAD_GRAYSCALE);
+    if (imgIn.empty()) //check whether the image is loaded or not
+    {
+        std::cout << "ERROR : Image cannot be loaded..!!" << std::endl;
+        return -1;
+    }
+
+    //! [main]
+    // Calculate Gradient Structure Tensor and post-process it for output with G-API
+    cv::GMat in;
+    cv::GMat imgCoherency, imgOrientation;
+    calcGST(in, imgCoherency, imgOrientation, W);
+
+    auto imgCoherencyBin = imgCoherency > C_Thr;
+    auto imgOrientationBin = cv::gapi::inRange(imgOrientation, LowThr, HighThr);
+    auto imgBin = imgCoherencyBin & imgOrientationBin;
+    cv::GMat out = cv::gapi::addWeighted(in, 0.5, imgBin, 0.5, 0.0);
+
+    // Normalize extra outputs
+    cv::GMat imgCoherencyNorm = cv::gapi::normalize(imgCoherency, 0, 255, cv::NORM_MINMAX);
+    cv::GMat imgOrientationNorm = cv::gapi::normalize(imgOrientation, 0, 255, cv::NORM_MINMAX);
+
+    // Capture the graph into object segm
+    cv::GComputation segm(cv::GIn(in), cv::GOut(out, imgCoherencyNorm, imgOrientationNorm));
+
+    // Define cv::Mats for output data
+    cv::Mat imgOut, imgOutCoherency, imgOutOrientation;
+
+    //! [kernel_pkg_proper]
+    //! [kernel_pkg]
+    // Prepare the kernel package and run the graph
+    cv::GKernelPackage fluid_kernels = cv::gapi::combine              // Define a custom kernel package:
+        (cv::gapi::core::fluid::kernels(),                            // ...with Fluid Core kernels
+         cv::gapi::imgproc::fluid::kernels());                        // ...and Fluid ImgProc kernels
+    //! [kernel_pkg]
+    //! [kernel_hotfix]
+    fluid_kernels.remove<cv::gapi::imgproc::GBoxFilter>();            // Remove Fluid Box filter as unsuitable,
+                                                                      // G-API will fall-back to OpenCV there.
+    //! [kernel_hotfix]
+    //! [kernel_pkg_use]
+    segm.apply(cv::gin(imgIn),                                        // Input data vector
+               cv::gout(imgOut, imgOutCoherency, imgOutOrientation),  // Output data vector
+               cv::compile_args(fluid_kernels));                      // Kernel package to use
+    //! [kernel_pkg_use]
+    //! [kernel_pkg_proper]
+
+    cv::imwrite("result.jpg", imgOut);
+    cv::imwrite("Coherency.jpg", imgOutCoherency);
+    cv::imwrite("Orientation.jpg", imgOutOrientation);
+    //! [main]
+
+    return 0;
+}
+//! [calcGST]
+//! [calcGST_header]
+void calcGST(const cv::GMat& inputImg, cv::GMat& imgCoherencyOut, cv::GMat& imgOrientationOut, int w)
+{
+    auto img = cv::gapi::convertTo(inputImg, CV_32F);
+    auto imgDiffX = cv::gapi::Sobel(img, CV_32F, 1, 0, 3);
+    auto imgDiffY = cv::gapi::Sobel(img, CV_32F, 0, 1, 3);
+    auto imgDiffXY = cv::gapi::mul(imgDiffX, imgDiffY);
+    //! [calcGST_header]
+
+    auto imgDiffXX = cv::gapi::mul(imgDiffX, imgDiffX);
+    auto imgDiffYY = cv::gapi::mul(imgDiffY, imgDiffY);
+
+    auto J11 = cv::gapi::boxFilter(imgDiffXX, CV_32F, cv::Size(w, w));
+    auto J22 = cv::gapi::boxFilter(imgDiffYY, CV_32F, cv::Size(w, w));
+    auto J12 = cv::gapi::boxFilter(imgDiffXY, CV_32F, cv::Size(w, w));
+
+    auto tmp1 = J11 + J22;
+    auto tmp2 = J11 - J22;
+    auto tmp22 = cv::gapi::mul(tmp2, tmp2);
+    auto tmp3 = cv::gapi::mul(J12, J12);
+    auto tmp4 = cv::gapi::sqrt(tmp22 + 4.0*tmp3);
+
+    auto lambda1 = tmp1 + tmp4;
+    auto lambda2 = tmp1 - tmp4;
+
+    imgCoherencyOut = (lambda1 - lambda2) / (lambda1 + lambda2);
+    imgOrientationOut = 0.5*cv::gapi::phase(J22 - J11, 2.0*J12, true);
+}
+//! [calcGST]
+
+//! [full_sample]
+
+#else
+#include <iostream>
+int main()
+{
+    std::cerr << "This tutorial code requires G-API module to run" << std::endl;
+}
+#endif  // HAVE_OPECV_GAPI
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/security_barrier_camera/security_barrier_camera.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/security_barrier_camera/security_barrier_camera.cpp
new file mode 100644
index 00000000..db72ab91
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gapi/security_barrier_camera/security_barrier_camera.cpp
@@ -0,0 +1,351 @@
+#include "opencv2/opencv_modules.hpp"
+#include <iostream>
+#if defined(HAVE_OPENCV_GAPI)
+
+#include <chrono>
+#include <iomanip>
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/gapi.hpp"
+#include "opencv2/gapi/core.hpp"
+#include "opencv2/gapi/imgproc.hpp"
+#include "opencv2/gapi/infer.hpp"
+#include "opencv2/gapi/infer/ie.hpp"
+#include "opencv2/gapi/cpu/gcpukernel.hpp"
+#include "opencv2/gapi/streaming/cap.hpp"
+#include "opencv2/highgui.hpp"
+
+const std::string about =
+    "This is an OpenCV-based version of Security Barrier Camera example";
+const std::string keys =
+    "{ h help |   | print this help message }"
+    "{ input  |   | Path to an input video file }"
+    "{ detm   |   | IE vehicle/license plate detection model IR }"
+    "{ detw   |   | IE vehicle/license plate detection model weights }"
+    "{ detd   |   | IE vehicle/license plate detection model device }"
+    "{ vehm   |   | IE vehicle attributes model IR }"
+    "{ vehw   |   | IE vehicle attributes model weights }"
+    "{ vehd   |   | IE vehicle attributes model device }"
+    "{ lprm   |   | IE license plate recognition model IR }"
+    "{ lprw   |   | IE license plate recognition model weights }"
+    "{ lprd   |   | IE license plate recognition model device }"
+    "{ pure   |   | When set, no output is displayed. Useful for benchmarking }"
+    "{ ser    |   | When set, runs a regular (serial) pipeline }";
+
+namespace {
+struct Avg {
+    struct Elapsed {
+        explicit Elapsed(double ms) : ss(ms/1000.), mm(static_cast<int>(ss)/60) {}
+        const double ss;
+        const int    mm;
+    };
+
+    using MS = std::chrono::duration<double, std::ratio<1, 1000>>;
+    using TS = std::chrono::time_point<std::chrono::high_resolution_clock>;
+    TS started;
+
+    void    start() { started = now(); }
+    TS      now() const { return std::chrono::high_resolution_clock::now(); }
+    double  tick() const { return std::chrono::duration_cast<MS>(now() - started).count(); }
+    Elapsed elapsed() const { return Elapsed{tick()}; }
+    double  fps(std::size_t n) const { return static_cast<double>(n) / (tick() / 1000.); }
+};
+std::ostream& operator<<(std::ostream &os, const Avg::Elapsed &e) {
+    os << e.mm << ':' << (e.ss - 60*e.mm);
+    return os;
+}
+} // namespace
+
+
+namespace custom {
+G_API_NET(VehicleLicenseDetector, <cv::GMat(cv::GMat)>, "vehicle-license-plate-detector");
+
+using Attrs = std::tuple<cv::GMat, cv::GMat>;
+G_API_NET(VehicleAttributes,      <Attrs(cv::GMat)>,    "vehicle-attributes");
+G_API_NET(LPR,                    <cv::GMat(cv::GMat)>, "license-plate-recognition");
+
+using GVehiclesPlates = std::tuple< cv::GArray<cv::Rect>
+                                  , cv::GArray<cv::Rect> >;
+G_API_OP_M(ProcessDetections,
+           <GVehiclesPlates(cv::GMat, cv::GMat)>,
+           "custom.security_barrier.detector.postproc") {
+    static std::tuple<cv::GArrayDesc,cv::GArrayDesc>
+    outMeta(const cv::GMatDesc &, const cv::GMatDesc) {
+        // FIXME: Need to get rid of this - literally there's nothing useful
+        return std::make_tuple(cv::empty_array_desc(), cv::empty_array_desc());
+    }
+};
+
+GAPI_OCV_KERNEL(OCVProcessDetections, ProcessDetections) {
+    static void run(const cv::Mat &in_ssd_result,
+                    const cv::Mat &in_frame,
+                    std::vector<cv::Rect> &out_vehicles,
+                    std::vector<cv::Rect> &out_plates) {
+        const int MAX_PROPOSALS = 200;
+        const int OBJECT_SIZE   =   7;
+        const cv::Size upscale = in_frame.size();
+        const cv::Rect surface({0,0}, upscale);
+
+        out_vehicles.clear();
+        out_plates.clear();
+
+        const float *data = in_ssd_result.ptr<float>();
+        for (int i = 0; i < MAX_PROPOSALS; i++) {
+            const float image_id   = data[i * OBJECT_SIZE + 0]; // batch id
+            const float label      = data[i * OBJECT_SIZE + 1];
+            const float confidence = data[i * OBJECT_SIZE + 2];
+            const float rc_left    = data[i * OBJECT_SIZE + 3];
+            const float rc_top     = data[i * OBJECT_SIZE + 4];
+            const float rc_right   = data[i * OBJECT_SIZE + 5];
+            const float rc_bottom  = data[i * OBJECT_SIZE + 6];
+
+            if (image_id < 0.f) {  // indicates end of detections
+                break;
+            }
+            if (confidence < 0.5f) { // fixme: hard-coded snapshot
+                continue;
+            }
+
+            cv::Rect rc;
+            rc.x      = static_cast<int>(rc_left   * upscale.width);
+            rc.y      = static_cast<int>(rc_top    * upscale.height);
+            rc.width  = static_cast<int>(rc_right  * upscale.width)  - rc.x;
+            rc.height = static_cast<int>(rc_bottom * upscale.height) - rc.y;
+
+            using PT = cv::Point;
+            using SZ = cv::Size;
+            switch (static_cast<int>(label)) {
+            case 1: out_vehicles.push_back(rc & surface); break;
+            case 2: out_plates.emplace_back((rc-PT(15,15)+SZ(30,30)) & surface); break;
+            default: CV_Assert(false && "Unknown object class");
+            }
+        }
+    }
+};
+} // namespace custom
+
+namespace labels {
+const std::string colors[] = {
+    "white", "gray", "yellow", "red", "green", "blue", "black"
+};
+const std::string types[] = {
+    "car", "van", "truck", "bus"
+};
+const std::vector<std::string> license_text = {
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
+    "<Anhui>", "<Beijing>", "<Chongqing>", "<Fujian>",
+    "<Gansu>", "<Guangdong>", "<Guangxi>", "<Guizhou>",
+    "<Hainan>", "<Hebei>", "<Heilongjiang>", "<Henan>",
+    "<HongKong>", "<Hubei>", "<Hunan>", "<InnerMongolia>",
+    "<Jiangsu>", "<Jiangxi>", "<Jilin>", "<Liaoning>",
+    "<Macau>", "<Ningxia>", "<Qinghai>", "<Shaanxi>",
+    "<Shandong>", "<Shanghai>", "<Shanxi>", "<Sichuan>",
+    "<Tianjin>", "<Tibet>", "<Xinjiang>", "<Yunnan>",
+    "<Zhejiang>", "<police>",
+    "A", "B", "C", "D", "E", "F", "G", "H", "I", "J",
+    "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
+    "U", "V", "W", "X", "Y", "Z"
+};
+namespace {
+void DrawResults(cv::Mat &frame,
+                 const std::vector<cv::Rect> &vehicles,
+                 const std::vector<cv::Mat>  &out_colors,
+                 const std::vector<cv::Mat>  &out_types,
+                 const std::vector<cv::Rect> &plates,
+                 const std::vector<cv::Mat>  &out_numbers) {
+    CV_Assert(vehicles.size() == out_colors.size());
+    CV_Assert(vehicles.size() == out_types.size());
+    CV_Assert(plates.size()   == out_numbers.size());
+
+    for (auto it = vehicles.begin(); it != vehicles.end(); ++it) {
+        const auto idx = std::distance(vehicles.begin(), it);
+        const auto &rc = *it;
+
+        const float *colors_data = out_colors[idx].ptr<float>();
+        const float *types_data  = out_types [idx].ptr<float>();
+        const auto color_id = std::max_element(colors_data, colors_data + 7) - colors_data;
+        const auto  type_id = std::max_element(types_data,  types_data  + 4) - types_data;
+
+        const int ATTRIB_OFFSET = 25;
+        cv::rectangle(frame, rc, {0, 255, 0},  4);
+        cv::putText(frame, labels::colors[color_id],
+                    cv::Point(rc.x + 5, rc.y + ATTRIB_OFFSET),
+                    cv::FONT_HERSHEY_COMPLEX_SMALL,
+                    1,
+                    cv::Scalar(255, 0, 0));
+        cv::putText(frame, labels::types[type_id],
+                    cv::Point(rc.x + 5, rc.y + ATTRIB_OFFSET * 2),
+                    cv::FONT_HERSHEY_COMPLEX_SMALL,
+                    1,
+                    cv::Scalar(255, 0, 0));
+    }
+
+    for (auto it = plates.begin(); it != plates.end(); ++it) {
+        const int MAX_LICENSE = 88;
+        const int LPR_OFFSET  = 50;
+
+        const auto &rc   = *it;
+        const auto idx   = std::distance(plates.begin(), it);
+
+        std::string result;
+        const auto *lpr_data = out_numbers[idx].ptr<float>();
+        for (int i = 0; i < MAX_LICENSE; i++) {
+            if (lpr_data[i] == -1) break;
+            result += labels::license_text[static_cast<size_t>(lpr_data[i])];
+        }
+
+        const int y_pos = std::max(0, rc.y + rc.height - LPR_OFFSET);
+        cv::rectangle(frame, rc, {0, 0, 255},  4);
+        cv::putText(frame, result,
+                    cv::Point(rc.x, y_pos),
+                    cv::FONT_HERSHEY_COMPLEX_SMALL,
+                    1,
+                    cv::Scalar(0, 0, 255));
+    }
+}
+
+void DrawFPS(cv::Mat &frame, std::size_t n, double fps) {
+    std::ostringstream out;
+    out << "FRAME " << n << ": "
+        << std::fixed << std::setprecision(2) << fps
+        << " FPS (AVG)";
+    cv::putText(frame, out.str(),
+                cv::Point(0, frame.rows),
+                cv::FONT_HERSHEY_SIMPLEX,
+                1,
+                cv::Scalar(0, 0, 0),
+                2);
+}
+} // anonymous namespace
+} // namespace labels
+
+int main(int argc, char *argv[])
+{
+    cv::CommandLineParser cmd(argc, argv, keys);
+    cmd.about(about);
+    if (cmd.has("help")) {
+        cmd.printMessage();
+        return 0;
+    }
+    const std::string input = cmd.get<std::string>("input");
+    const bool no_show = cmd.get<bool>("pure");
+
+    cv::GComputation pp([]() {
+            cv::GMat in;
+            cv::GMat detections          = cv::gapi::infer<custom::VehicleLicenseDetector>(in);
+            cv::GArray<cv::Rect> vehicles;
+            cv::GArray<cv::Rect> plates;
+            std::tie(vehicles, plates)   = custom::ProcessDetections::on(detections, in);
+            cv::GArray<cv::GMat> colors;
+            cv::GArray<cv::GMat> types;
+            std::tie(colors, types)      = cv::gapi::infer<custom::VehicleAttributes>(vehicles, in);
+            cv::GArray<cv::GMat> numbers = cv::gapi::infer<custom::LPR>(plates, in);
+            cv::GMat frame = cv::gapi::copy(in); // pass-through the input frame
+            return cv::GComputation(cv::GIn(in),
+                                    cv::GOut(frame, vehicles, colors, types, plates, numbers));
+        });
+
+    // Note: it might be very useful to have dimensions loaded at this point!
+    auto det_net = cv::gapi::ie::Params<custom::VehicleLicenseDetector> {
+        cmd.get<std::string>("detm"),   // path to topology IR
+        cmd.get<std::string>("detw"),   // path to weights
+        cmd.get<std::string>("detd"),   // device specifier
+    };
+
+    auto attr_net = cv::gapi::ie::Params<custom::VehicleAttributes> {
+        cmd.get<std::string>("vehm"),   // path to topology IR
+        cmd.get<std::string>("vehw"),   // path to weights
+        cmd.get<std::string>("vehd"),   // device specifier
+    }.cfgOutputLayers({ "color", "type" });
+
+    // Fill a special LPR input (seq_ind) with a predefined value
+    // First element is 0.f, the rest 87 are 1.f
+    const std::vector<int> lpr_seq_dims = {88,1};
+    cv::Mat lpr_seq(lpr_seq_dims, CV_32F, cv::Scalar(1.f));
+    lpr_seq.ptr<float>()[0] = 0.f;
+    auto lpr_net = cv::gapi::ie::Params<custom::LPR> {
+        cmd.get<std::string>("lprm"),   // path to topology IR
+        cmd.get<std::string>("lprw"),   // path to weights
+        cmd.get<std::string>("lprd"),   // device specifier
+    }.constInput("seq_ind", lpr_seq);
+
+    auto kernels = cv::gapi::kernels<custom::OCVProcessDetections>();
+    auto networks = cv::gapi::networks(det_net, attr_net, lpr_net);
+
+    Avg avg;
+    cv::Mat frame;
+    std::vector<cv::Rect> vehicles, plates;
+    std::vector<cv::Mat> out_colors;
+    std::vector<cv::Mat> out_types;
+    std::vector<cv::Mat> out_numbers;
+    std::size_t frames = 0u;
+
+    std::cout << "Reading " << input << std::endl;
+
+    if (cmd.get<bool>("ser")) {
+        std::cout << "Going serial..." << std::endl;
+        cv::VideoCapture cap(input);
+
+        auto cc = pp.compile(cv::GMatDesc{CV_8U,3,cv::Size(1920,1080)},
+                             cv::compile_args(kernels, networks));
+
+        avg.start();
+        while (cv::waitKey(1) < 0) {
+            cap >> frame;
+            if (frame.empty()) break;
+
+            cc(cv::gin(frame),
+               cv::gout(frame, vehicles, out_colors, out_types, plates, out_numbers));
+            frames++;
+            labels::DrawResults(frame, vehicles, out_colors, out_types, plates, out_numbers);
+            labels::DrawFPS(frame, frames, avg.fps(frames));
+            if (!no_show) cv::imshow("Out", frame);
+        }
+    } else {
+        std::cout << "Going pipelined..." << std::endl;
+
+        auto cc = pp.compileStreaming(cv::GMatDesc{CV_8U,3,cv::Size(1920,1080)},
+                                      cv::compile_args(kernels, networks));
+
+        cc.setSource(cv::gapi::wip::make_src<cv::gapi::wip::GCaptureSource>(input));
+
+        avg.start();
+        cc.start();
+
+        // Implement different execution policies depending on the display option
+        // for the best performance.
+        while (cc.running()) {
+            auto out_vector = cv::gout(frame, vehicles, out_colors, out_types, plates, out_numbers);
+            if (no_show) {
+                // This is purely a video processing. No need to balance with UI rendering.
+                // Use a blocking pull() to obtain data. Break the loop if the stream is over.
+                if (!cc.pull(std::move(out_vector)))
+                    break;
+            } else if (!cc.try_pull(std::move(out_vector))) {
+                // Use a non-blocking try_pull() to obtain data.
+                // If there's no data, let UI refresh (and handle keypress)
+                if (cv::waitKey(1) >= 0) break;
+                else continue;
+            }
+            // At this point we have data for sure (obtained in either blocking or non-blocking way).
+            frames++;
+            labels::DrawResults(frame, vehicles, out_colors, out_types, plates, out_numbers);
+            labels::DrawFPS(frame, frames, avg.fps(frames));
+            if (!no_show) cv::imshow("Out", frame);
+        }
+        cc.stop();
+    }
+    std::cout << "Processed " << frames << " frames in " << avg.elapsed() << std::endl;
+
+    return 0;
+}
+#else
+int main()
+{
+    std::cerr << "This tutorial code requires G-API module "
+                 "with Inference Engine backend to run"
+              << std::endl;
+    return 1;
+}
+#endif  // HAVE_OPECV_GAPI
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-basics-similarity/gpu-basics-similarity.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-basics-similarity/gpu-basics-similarity.cpp
new file mode 100644
index 00000000..c8079982
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-basics-similarity/gpu-basics-similarity.cpp
@@ -0,0 +1,445 @@
+#include <iostream>                   // Console I/O
+#include <sstream>                    // String to number conversion
+
+#include <opencv2/core.hpp>      // Basic OpenCV structures
+#include <opencv2/core/utility.hpp>
+#include <opencv2/imgproc.hpp>// Image processing methods for the CPU
+#include <opencv2/imgcodecs.hpp>// Read images
+
+// CUDA structures and methods
+#include <opencv2/cudaarithm.hpp>
+#include <opencv2/cudafilters.hpp>
+
+using namespace std;
+using namespace cv;
+
+double getPSNR(const Mat& I1, const Mat& I2);      // CPU versions
+Scalar getMSSIM( const Mat& I1, const Mat& I2);
+
+double getPSNR_CUDA(const Mat& I1, const Mat& I2);  // Basic CUDA versions
+Scalar getMSSIM_CUDA( const Mat& I1, const Mat& I2);
+
+//! [psnr]
+struct BufferPSNR                                     // Optimized CUDA versions
+{   // Data allocations are very expensive on CUDA. Use a buffer to solve: allocate once reuse later.
+    cuda::GpuMat gI1, gI2, gs, t1,t2;
+
+    cuda::GpuMat buf;
+};
+//! [psnr]
+double getPSNR_CUDA_optimized(const Mat& I1, const Mat& I2, BufferPSNR& b);
+
+//! [ssim]
+struct BufferMSSIM                                     // Optimized CUDA versions
+{   // Data allocations are very expensive on CUDA. Use a buffer to solve: allocate once reuse later.
+    cuda::GpuMat gI1, gI2, gs, t1,t2;
+
+    cuda::GpuMat I1_2, I2_2, I1_I2;
+    vector<cuda::GpuMat> vI1, vI2;
+
+    cuda::GpuMat mu1, mu2;
+    cuda::GpuMat mu1_2, mu2_2, mu1_mu2;
+
+    cuda::GpuMat sigma1_2, sigma2_2, sigma12;
+    cuda::GpuMat t3;
+
+    cuda::GpuMat ssim_map;
+
+    cuda::GpuMat buf;
+};
+//! [ssim]
+Scalar getMSSIM_CUDA_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b);
+
+static void help()
+{
+    cout
+        << "\n--------------------------------------------------------------------------" << endl
+        << "This program shows how to port your CPU code to CUDA or write that from scratch." << endl
+        << "You can see the performance improvement for the similarity check methods (PSNR and SSIM)."  << endl
+        << "Usage:"                                                               << endl
+        << "./gpu-basics-similarity referenceImage comparedImage numberOfTimesToRunTest(like 10)." << endl
+        << "--------------------------------------------------------------------------"   << endl
+        << endl;
+}
+
+int main(int, char *argv[])
+{
+    help();
+    Mat I1 = imread(argv[1]);           // Read the two images
+    Mat I2 = imread(argv[2]);
+
+    if (!I1.data || !I2.data)           // Check for success
+    {
+        cout << "Couldn't read the image";
+        return 0;
+    }
+
+    BufferPSNR bufferPSNR;
+    BufferMSSIM bufferMSSIM;
+
+    int TIMES = 10;
+    stringstream sstr(argv[3]);
+    sstr >> TIMES;
+    double time, result = 0;
+
+    //------------------------------- PSNR CPU ----------------------------------------------------
+    time = (double)getTickCount();
+
+    for (int i = 0; i < TIMES; ++i)
+        result = getPSNR(I1,I2);
+
+    time = 1000*((double)getTickCount() - time)/getTickFrequency();
+    time /= TIMES;
+
+    cout << "Time of PSNR CPU (averaged for " << TIMES << " runs): " << time << " milliseconds."
+        << " With result of: " << result << endl;
+
+    //------------------------------- PSNR CUDA ----------------------------------------------------
+    time = (double)getTickCount();
+
+    for (int i = 0; i < TIMES; ++i)
+        result = getPSNR_CUDA(I1,I2);
+
+    time = 1000*((double)getTickCount() - time)/getTickFrequency();
+    time /= TIMES;
+
+    cout << "Time of PSNR CUDA (averaged for " << TIMES << " runs): " << time << " milliseconds."
+        << " With result of: " <<  result << endl;
+
+    //------------------------------- PSNR CUDA Optimized--------------------------------------------
+    time = (double)getTickCount();                                  // Initial call
+    result = getPSNR_CUDA_optimized(I1, I2, bufferPSNR);
+    time = 1000*((double)getTickCount() - time)/getTickFrequency();
+    cout << "Initial call CUDA optimized:              " << time  <<" milliseconds."
+        << " With result of: " << result << endl;
+
+    time = (double)getTickCount();
+    for (int i = 0; i < TIMES; ++i)
+        result = getPSNR_CUDA_optimized(I1, I2, bufferPSNR);
+
+    time = 1000*((double)getTickCount() - time)/getTickFrequency();
+    time /= TIMES;
+
+    cout << "Time of PSNR CUDA OPTIMIZED ( / " << TIMES << " runs): " << time
+        << " milliseconds." << " With result of: " <<  result << endl << endl;
+
+
+    //------------------------------- SSIM CPU -----------------------------------------------------
+    Scalar x;
+    time = (double)getTickCount();
+
+    for (int i = 0; i < TIMES; ++i)
+        x = getMSSIM(I1,I2);
+
+    time = 1000*((double)getTickCount() - time)/getTickFrequency();
+    time /= TIMES;
+
+    cout << "Time of MSSIM CPU (averaged for " << TIMES << " runs): " << time << " milliseconds."
+        << " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl;
+
+    //------------------------------- SSIM CUDA -----------------------------------------------------
+    time = (double)getTickCount();
+
+    for (int i = 0; i < TIMES; ++i)
+        x = getMSSIM_CUDA(I1,I2);
+
+    time = 1000*((double)getTickCount() - time)/getTickFrequency();
+    time /= TIMES;
+
+    cout << "Time of MSSIM CUDA (averaged for " << TIMES << " runs): " << time << " milliseconds."
+        << " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl;
+
+    //------------------------------- SSIM CUDA Optimized--------------------------------------------
+    time = (double)getTickCount();
+    x = getMSSIM_CUDA_optimized(I1,I2, bufferMSSIM);
+    time = 1000*((double)getTickCount() - time)/getTickFrequency();
+    cout << "Time of MSSIM CUDA Initial Call            " << time << " milliseconds."
+        << " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl;
+
+    time = (double)getTickCount();
+
+    for (int i = 0; i < TIMES; ++i)
+        x = getMSSIM_CUDA_optimized(I1,I2, bufferMSSIM);
+
+    time = 1000*((double)getTickCount() - time)/getTickFrequency();
+    time /= TIMES;
+
+    cout << "Time of MSSIM CUDA OPTIMIZED ( / " << TIMES << " runs): " << time << " milliseconds."
+        << " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl << endl;
+    return 0;
+}
+
+//! [getpsnr]
+double getPSNR(const Mat& I1, const Mat& I2)
+{
+    Mat s1;
+    absdiff(I1, I2, s1);       // |I1 - I2|
+    s1.convertTo(s1, CV_32F);  // cannot make a square on 8 bits
+    s1 = s1.mul(s1);           // |I1 - I2|^2
+
+    Scalar s = sum(s1);         // sum elements per channel
+
+    double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels
+
+    if( sse <= 1e-10) // for small values return zero
+        return 0;
+    else
+    {
+        double  mse =sse /(double)(I1.channels() * I1.total());
+        double psnr = 10.0*log10((255*255)/mse);
+        return psnr;
+    }
+}
+//! [getpsnr]
+
+//! [getpsnropt]
+double getPSNR_CUDA_optimized(const Mat& I1, const Mat& I2, BufferPSNR& b)
+{
+    b.gI1.upload(I1);
+    b.gI2.upload(I2);
+
+    b.gI1.convertTo(b.t1, CV_32F);
+    b.gI2.convertTo(b.t2, CV_32F);
+
+    cuda::absdiff(b.t1.reshape(1), b.t2.reshape(1), b.gs);
+    cuda::multiply(b.gs, b.gs, b.gs);
+
+    double sse = cuda::sum(b.gs, b.buf)[0];
+
+    if( sse <= 1e-10) // for small values return zero
+        return 0;
+    else
+    {
+        double mse = sse /(double)(I1.channels() * I1.total());
+        double psnr = 10.0*log10((255*255)/mse);
+        return psnr;
+    }
+}
+//! [getpsnropt]
+
+//! [getpsnrcuda]
+double getPSNR_CUDA(const Mat& I1, const Mat& I2)
+{
+    cuda::GpuMat gI1, gI2, gs, t1,t2;
+
+    gI1.upload(I1);
+    gI2.upload(I2);
+
+    gI1.convertTo(t1, CV_32F);
+    gI2.convertTo(t2, CV_32F);
+
+    cuda::absdiff(t1.reshape(1), t2.reshape(1), gs);
+    cuda::multiply(gs, gs, gs);
+
+    Scalar s = cuda::sum(gs);
+    double sse = s.val[0] + s.val[1] + s.val[2];
+
+    if( sse <= 1e-10) // for small values return zero
+        return 0;
+    else
+    {
+        double  mse =sse /(double)(gI1.channels() * I1.total());
+        double psnr = 10.0*log10((255*255)/mse);
+        return psnr;
+    }
+}
+//! [getpsnrcuda]
+
+//! [getssim]
+Scalar getMSSIM( const Mat& i1, const Mat& i2)
+{
+    const double C1 = 6.5025, C2 = 58.5225;
+    /***************************** INITS **********************************/
+    int d     = CV_32F;
+
+    Mat I1, I2;
+    i1.convertTo(I1, d);           // cannot calculate on one byte large values
+    i2.convertTo(I2, d);
+
+    Mat I2_2   = I2.mul(I2);        // I2^2
+    Mat I1_2   = I1.mul(I1);        // I1^2
+    Mat I1_I2  = I1.mul(I2);        // I1 * I2
+
+    /*************************** END INITS **********************************/
+
+    Mat mu1, mu2;   // PRELIMINARY COMPUTING
+    GaussianBlur(I1, mu1, Size(11, 11), 1.5);
+    GaussianBlur(I2, mu2, Size(11, 11), 1.5);
+
+    Mat mu1_2   =   mu1.mul(mu1);
+    Mat mu2_2   =   mu2.mul(mu2);
+    Mat mu1_mu2 =   mu1.mul(mu2);
+
+    Mat sigma1_2, sigma2_2, sigma12;
+
+    GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
+    sigma1_2 -= mu1_2;
+
+    GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
+    sigma2_2 -= mu2_2;
+
+    GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
+    sigma12 -= mu1_mu2;
+
+    ///////////////////////////////// FORMULA ////////////////////////////////
+    Mat t1, t2, t3;
+
+    t1 = 2 * mu1_mu2 + C1;
+    t2 = 2 * sigma12 + C2;
+    t3 = t1.mul(t2);              // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+
+    t1 = mu1_2 + mu2_2 + C1;
+    t2 = sigma1_2 + sigma2_2 + C2;
+    t1 = t1.mul(t2);               // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+
+    Mat ssim_map;
+    divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;
+
+    Scalar mssim = mean( ssim_map ); // mssim = average of ssim map
+    return mssim;
+}
+//! [getssim]
+
+//! [getssimcuda]
+Scalar getMSSIM_CUDA( const Mat& i1, const Mat& i2)
+{
+    const float C1 = 6.5025f, C2 = 58.5225f;
+    /***************************** INITS **********************************/
+    cuda::GpuMat gI1, gI2, gs1, tmp1,tmp2;
+
+    gI1.upload(i1);
+    gI2.upload(i2);
+
+    gI1.convertTo(tmp1, CV_MAKE_TYPE(CV_32F, gI1.channels()));
+    gI2.convertTo(tmp2, CV_MAKE_TYPE(CV_32F, gI2.channels()));
+
+    vector<cuda::GpuMat> vI1, vI2;
+    cuda::split(tmp1, vI1);
+    cuda::split(tmp2, vI2);
+    Scalar mssim;
+
+    Ptr<cuda::Filter> gauss = cuda::createGaussianFilter(vI2[0].type(), -1, Size(11, 11), 1.5);
+
+    for( int i = 0; i < gI1.channels(); ++i )
+    {
+        cuda::GpuMat I2_2, I1_2, I1_I2;
+
+        cuda::multiply(vI2[i], vI2[i], I2_2);        // I2^2
+        cuda::multiply(vI1[i], vI1[i], I1_2);        // I1^2
+        cuda::multiply(vI1[i], vI2[i], I1_I2);       // I1 * I2
+
+        /*************************** END INITS **********************************/
+        cuda::GpuMat mu1, mu2;   // PRELIMINARY COMPUTING
+        gauss->apply(vI1[i], mu1);
+        gauss->apply(vI2[i], mu2);
+
+        cuda::GpuMat mu1_2, mu2_2, mu1_mu2;
+        cuda::multiply(mu1, mu1, mu1_2);
+        cuda::multiply(mu2, mu2, mu2_2);
+        cuda::multiply(mu1, mu2, mu1_mu2);
+
+        cuda::GpuMat sigma1_2, sigma2_2, sigma12;
+
+        gauss->apply(I1_2, sigma1_2);
+        cuda::subtract(sigma1_2, mu1_2, sigma1_2); // sigma1_2 -= mu1_2;
+
+        gauss->apply(I2_2, sigma2_2);
+        cuda::subtract(sigma2_2, mu2_2, sigma2_2); // sigma2_2 -= mu2_2;
+
+        gauss->apply(I1_I2, sigma12);
+        cuda::subtract(sigma12, mu1_mu2, sigma12); // sigma12 -= mu1_mu2;
+
+        ///////////////////////////////// FORMULA ////////////////////////////////
+        cuda::GpuMat t1, t2, t3;
+
+        mu1_mu2.convertTo(t1, -1, 2, C1); // t1 = 2 * mu1_mu2 + C1;
+        sigma12.convertTo(t2, -1, 2, C2); // t2 = 2 * sigma12 + C2;
+        cuda::multiply(t1, t2, t3);        // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+
+        cuda::addWeighted(mu1_2, 1.0, mu2_2, 1.0, C1, t1);       // t1 = mu1_2 + mu2_2 + C1;
+        cuda::addWeighted(sigma1_2, 1.0, sigma2_2, 1.0, C2, t2); // t2 = sigma1_2 + sigma2_2 + C2;
+        cuda::multiply(t1, t2, t1);                              // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+
+        cuda::GpuMat ssim_map;
+        cuda::divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;
+
+        Scalar s = cuda::sum(ssim_map);
+        mssim.val[i] = s.val[0] / (ssim_map.rows * ssim_map.cols);
+
+    }
+    return mssim;
+}
+//! [getssimcuda]
+
+//! [getssimopt]
+Scalar getMSSIM_CUDA_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b)
+{
+    const float C1 = 6.5025f, C2 = 58.5225f;
+    /***************************** INITS **********************************/
+
+    b.gI1.upload(i1);
+    b.gI2.upload(i2);
+
+    cuda::Stream stream;
+
+    b.gI1.convertTo(b.t1, CV_32F, stream);
+    b.gI2.convertTo(b.t2, CV_32F, stream);
+
+    cuda::split(b.t1, b.vI1, stream);
+    cuda::split(b.t2, b.vI2, stream);
+    Scalar mssim;
+
+    Ptr<cuda::Filter> gauss = cuda::createGaussianFilter(b.vI1[0].type(), -1, Size(11, 11), 1.5);
+
+    for( int i = 0; i < b.gI1.channels(); ++i )
+    {
+        cuda::multiply(b.vI2[i], b.vI2[i], b.I2_2, 1, -1, stream);        // I2^2
+        cuda::multiply(b.vI1[i], b.vI1[i], b.I1_2, 1, -1, stream);        // I1^2
+        cuda::multiply(b.vI1[i], b.vI2[i], b.I1_I2, 1, -1, stream);       // I1 * I2
+
+        gauss->apply(b.vI1[i], b.mu1, stream);
+        gauss->apply(b.vI2[i], b.mu2, stream);
+
+        cuda::multiply(b.mu1, b.mu1, b.mu1_2, 1, -1, stream);
+        cuda::multiply(b.mu2, b.mu2, b.mu2_2, 1, -1, stream);
+        cuda::multiply(b.mu1, b.mu2, b.mu1_mu2, 1, -1, stream);
+
+        gauss->apply(b.I1_2, b.sigma1_2, stream);
+        cuda::subtract(b.sigma1_2, b.mu1_2, b.sigma1_2, cuda::GpuMat(), -1, stream);
+        //b.sigma1_2 -= b.mu1_2;  - This would result in an extra data transfer operation
+
+        gauss->apply(b.I2_2, b.sigma2_2, stream);
+        cuda::subtract(b.sigma2_2, b.mu2_2, b.sigma2_2, cuda::GpuMat(), -1, stream);
+        //b.sigma2_2 -= b.mu2_2;
+
+        gauss->apply(b.I1_I2, b.sigma12, stream);
+        cuda::subtract(b.sigma12, b.mu1_mu2, b.sigma12, cuda::GpuMat(), -1, stream);
+        //b.sigma12 -= b.mu1_mu2;
+
+        //here too it would be an extra data transfer due to call of operator*(Scalar, Mat)
+        cuda::multiply(b.mu1_mu2, 2, b.t1, 1, -1, stream); //b.t1 = 2 * b.mu1_mu2 + C1;
+        cuda::add(b.t1, C1, b.t1, cuda::GpuMat(), -1, stream);
+        cuda::multiply(b.sigma12, 2, b.t2, 1, -1, stream); //b.t2 = 2 * b.sigma12 + C2;
+        cuda::add(b.t2, C2, b.t2, cuda::GpuMat(), -12, stream);
+
+        cuda::multiply(b.t1, b.t2, b.t3, 1, -1, stream);     // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+
+        cuda::add(b.mu1_2, b.mu2_2, b.t1, cuda::GpuMat(), -1, stream);
+        cuda::add(b.t1, C1, b.t1, cuda::GpuMat(), -1, stream);
+
+        cuda::add(b.sigma1_2, b.sigma2_2, b.t2, cuda::GpuMat(), -1, stream);
+        cuda::add(b.t2, C2, b.t2, cuda::GpuMat(), -1, stream);
+
+
+        cuda::multiply(b.t1, b.t2, b.t1, 1, -1, stream);     // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+        cuda::divide(b.t3, b.t1, b.ssim_map, 1, -1, stream);      // ssim_map =  t3./t1;
+
+        stream.waitForCompletion();
+
+        Scalar s = cuda::sum(b.ssim_map, b.buf);
+        mssim.val[i] = s.val[0] / (b.ssim_map.rows * b.ssim_map.cols);
+
+    }
+    return mssim;
+}
+//! [getssimopt]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-thrust-interop/CMakeLists.txt b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-thrust-interop/CMakeLists.txt
new file mode 100644
index 00000000..037d5085
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-thrust-interop/CMakeLists.txt
@@ -0,0 +1,10 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+
+FIND_PACKAGE(CUDA REQUIRED)
+INCLUDE_DIRECTORIES(${CUDA_INCLUDE_DIRS})
+
+FIND_PACKAGE(OpenCV REQUIRED COMPONENTS core)
+INCLUDE_DIRECTORIES(${OpenCV_INCLUDE_DIRS})
+
+CUDA_ADD_EXECUTABLE(opencv_thrust main.cu)
+TARGET_LINK_LIBRARIES(opencv_thrust ${OpenCV_LIBS})
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-thrust-interop/Thrust_interop.hpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-thrust-interop/Thrust_interop.hpp
new file mode 100644
index 00000000..85397206
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-thrust-interop/Thrust_interop.hpp
@@ -0,0 +1,74 @@
+#pragma once
+#include <opencv2/core/cuda.hpp>
+
+#include <thrust/iterator/permutation_iterator.h>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/device_ptr.h>
+
+/*
+    @Brief step_functor is an object to correctly step a thrust iterator according to the stride of a matrix
+*/
+//! [step_functor]
+template<typename T> struct step_functor : public thrust::unary_function<int, int>
+{
+    int columns;
+    int step;
+    int channels;
+    __host__ __device__ step_functor(int columns_, int step_, int channels_ = 1) : columns(columns_), step(step_), channels(channels_)	{	};
+    __host__ step_functor(cv::cuda::GpuMat& mat)
+    {
+        CV_Assert(mat.depth() == cv::DataType<T>::depth);
+        columns = mat.cols;
+        step = mat.step / sizeof(T);
+        channels = mat.channels();
+    }
+    __host__ __device__
+        int operator()(int x) const
+    {
+        int row = x / columns;
+        int idx = (row * step) + (x % columns)*channels;
+        return idx;
+    }
+};
+//! [step_functor]
+//! [begin_itr]
+/*
+    @Brief GpuMatBeginItr returns a thrust compatible iterator to the beginning of a GPU mat's memory.
+    @Param mat is the input matrix
+    @Param channel is the channel of the matrix that the iterator is accessing.  If set to -1, the iterator will access every element in sequential order
+*/
+template<typename T>
+thrust::permutation_iterator<thrust::device_ptr<T>, thrust::transform_iterator<step_functor<T>, thrust::counting_iterator<int>>>  GpuMatBeginItr(cv::cuda::GpuMat mat, int channel = 0)
+{
+    if (channel == -1)
+    {
+        mat = mat.reshape(1);
+        channel = 0;
+    }
+    CV_Assert(mat.depth() == cv::DataType<T>::depth);
+    CV_Assert(channel < mat.channels());
+    return thrust::make_permutation_iterator(thrust::device_pointer_cast(mat.ptr<T>(0) + channel),
+        thrust::make_transform_iterator(thrust::make_counting_iterator(0), step_functor<T>(mat.cols, mat.step / sizeof(T), mat.channels())));
+}
+//! [begin_itr]
+//! [end_itr]
+/*
+@Brief GpuMatEndItr returns a thrust compatible iterator to the end of a GPU mat's memory.
+@Param mat is the input matrix
+@Param channel is the channel of the matrix that the iterator is accessing.  If set to -1, the iterator will access every element in sequential order
+*/
+template<typename T>
+thrust::permutation_iterator<thrust::device_ptr<T>, thrust::transform_iterator<step_functor<T>, thrust::counting_iterator<int>>>  GpuMatEndItr(cv::cuda::GpuMat mat, int channel = 0)
+{
+    if (channel == -1)
+    {
+        mat = mat.reshape(1);
+        channel = 0;
+    }
+    CV_Assert(mat.depth() == cv::DataType<T>::depth);
+    CV_Assert(channel < mat.channels());
+    return thrust::make_permutation_iterator(thrust::device_pointer_cast(mat.ptr<T>(0) + channel),
+        thrust::make_transform_iterator(thrust::make_counting_iterator(mat.rows*mat.cols), step_functor<T>(mat.cols, mat.step / sizeof(T), mat.channels())));
+}
+//! [end_itr]
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-thrust-interop/main.cu b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-thrust-interop/main.cu
new file mode 100644
index 00000000..51f246a3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/gpu/gpu-thrust-interop/main.cu
@@ -0,0 +1,110 @@
+#include "Thrust_interop.hpp"
+#include <opencv2/core/cuda_stream_accessor.hpp>
+
+#include <thrust/transform.h>
+#include <thrust/random.h>
+#include <thrust/sort.h>
+#include <thrust/system/cuda/execution_policy.h>
+//! [prg]
+struct prg
+{
+  float a, b;
+
+  __host__ __device__
+    prg(float _a = 0.f, float _b = 1.f) : a(_a), b(_b) {};
+
+  __host__ __device__
+    float operator()(const unsigned int n) const
+  {
+    thrust::default_random_engine rng;
+    thrust::uniform_real_distribution<float> dist(a, b);
+    rng.discard(n);
+    return dist(rng);
+  }
+};
+//! [prg]
+
+
+//! [pred_greater]
+template<typename T> struct pred_greater
+{
+  T value;
+  __host__ __device__ pred_greater(T value_) : value(value_){}
+  __host__ __device__ bool operator()(const T& val) const
+  {
+    return val > value;
+  }
+};
+//! [pred_greater]
+
+
+int main(void)
+{
+  // Generate a 2 channel row matrix with 100 elements.  Set the first channel to be the element index, and the second to be a randomly
+  // generated value.  Sort by the randomly generated value while maintaining index association.
+  //! [sort]
+  {
+    cv::cuda::GpuMat d_data(1, 100, CV_32SC2);
+    // Thrust compatible begin and end iterators to channel 1 of this matrix
+    auto keyBegin = GpuMatBeginItr<int>(d_data, 1);
+    auto keyEnd = GpuMatEndItr<int>(d_data, 1);
+    // Thrust compatible begin and end iterators to channel 0 of this matrix
+    auto idxBegin = GpuMatBeginItr<int>(d_data, 0);
+    auto idxEnd = GpuMatEndItr<int>(d_data, 0);
+    // Fill the index channel with a sequence of numbers from 0 to 100
+    thrust::sequence(idxBegin, idxEnd);
+    // Fill the key channel with random numbers between 0 and 10.  A counting iterator is used here to give an integer value for each location as an input to prg::operator()
+    thrust::transform(thrust::make_counting_iterator(0), thrust::make_counting_iterator(d_data.cols), keyBegin, prg(0, 10));
+    // Sort the key channel and index channel such that the keys and indecies stay together
+    thrust::sort_by_key(keyBegin, keyEnd, idxBegin);
+
+    cv::Mat h_idx(d_data);
+  }
+  //! [sort]
+
+  // Randomly fill a row matrix with 100 elements between -1 and 1
+  //! [random]
+  {
+    cv::cuda::GpuMat d_value(1, 100, CV_32F);
+    auto valueBegin = GpuMatBeginItr<float>(d_value);
+    auto valueEnd = GpuMatEndItr<float>(d_value);
+    thrust::transform(thrust::make_counting_iterator(0), thrust::make_counting_iterator(d_value.cols), valueBegin, prg(-1, 1));
+
+    cv::Mat h_value(d_value);
+  }
+  //! [random]
+
+  // OpenCV has count non zero, but what if you want to count a specific value?
+  //! [count_value]
+  {
+    cv::cuda::GpuMat d_value(1, 100, CV_32S);
+    d_value.setTo(cv::Scalar(0));
+    d_value.colRange(10, 50).setTo(cv::Scalar(15));
+    auto count = thrust::count(GpuMatBeginItr<int>(d_value), GpuMatEndItr<int>(d_value), 15);
+    std::cout << count << std::endl;
+  }
+  //! [count_value]
+
+  // Randomly fill an array then copy only values greater than 0.  Perform these tasks on a stream.
+  //! [copy_greater]
+  {
+    cv::cuda::GpuMat d_value(1, 100, CV_32F);
+    auto valueBegin = GpuMatBeginItr<float>(d_value);
+    auto valueEnd = GpuMatEndItr<float>(d_value);
+    cv::cuda::Stream stream;
+    //! [random_gen_stream]
+    // Same as the random generation code from before except now the transformation is being performed on a stream
+    thrust::transform(thrust::system::cuda::par.on(cv::cuda::StreamAccessor::getStream(stream)), thrust::make_counting_iterator(0), thrust::make_counting_iterator(d_value.cols), valueBegin, prg(-1, 1));
+    //! [random_gen_stream]
+    // Count the number of values we are going to copy
+    int count = thrust::count_if(thrust::system::cuda::par.on(cv::cuda::StreamAccessor::getStream(stream)), valueBegin, valueEnd, pred_greater<float>(0.0));
+    // Allocate a destination for copied values
+    cv::cuda::GpuMat d_valueGreater(1, count, CV_32F);
+    // Copy values that satisfy the predicate.
+    thrust::copy_if(thrust::system::cuda::par.on(cv::cuda::StreamAccessor::getStream(stream)), valueBegin, valueEnd, GpuMatBeginItr<float>(d_valueGreater), pred_greater<float>(0.0));
+    cv::Mat h_greater(d_valueGreater);
+  }
+  //! [copy_greater]
+
+  return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/imgcodecs/GDAL_IO/gdal-image.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/imgcodecs/GDAL_IO/gdal-image.cpp
new file mode 100644
index 00000000..f1080c0d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/imgcodecs/GDAL_IO/gdal-image.cpp
@@ -0,0 +1,246 @@
+/*
+ * gdal_image.cpp -- Load GIS data into OpenCV Containers using the Geospatial Data Abstraction Library
+*/
+
+// OpenCV Headers
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+// C++ Standard Libraries
+#include <cmath>
+#include <iostream>
+#include <stdexcept>
+#include <vector>
+
+using namespace std;
+
+// define the corner points
+//    Note that GDAL library can natively determine this
+cv::Point2d tl( -122.441017, 37.815664 );
+cv::Point2d tr( -122.370919, 37.815311 );
+cv::Point2d bl( -122.441533, 37.747167 );
+cv::Point2d br( -122.3715,   37.746814 );
+
+// determine dem corners
+cv::Point2d dem_bl( -122.0, 38);
+cv::Point2d dem_tr( -123.0, 37);
+
+// range of the heat map colors
+std::vector<std::pair<cv::Vec3b,double> > color_range;
+
+
+// List of all function prototypes
+cv::Point2d lerp( const cv::Point2d&, const cv::Point2d&, const double& );
+
+cv::Vec3b get_dem_color( const double& );
+
+cv::Point2d world2dem( const cv::Point2d&, const cv::Size&);
+
+cv::Point2d pixel2world( const int&, const int&, const cv::Size& );
+
+void add_color( cv::Vec3b& pix, const uchar& b, const uchar& g, const uchar& r );
+
+
+
+/*
+ * Linear Interpolation
+ * p1 - Point 1
+ * p2 - Point 2
+ * t  - Ratio from Point 1 to Point 2
+*/
+cv::Point2d lerp( cv::Point2d const& p1, cv::Point2d const& p2, const double& t ){
+    return cv::Point2d( ((1-t)*p1.x) + (t*p2.x),
+                        ((1-t)*p1.y) + (t*p2.y));
+}
+
+/*
+ * Interpolate Colors
+*/
+template <typename DATATYPE, int N>
+cv::Vec<DATATYPE,N> lerp( cv::Vec<DATATYPE,N> const& minColor,
+                          cv::Vec<DATATYPE,N> const& maxColor,
+                          double const& t ){
+
+    cv::Vec<DATATYPE,N> output;
+    for( int i=0; i<N; i++ ){
+        output[i] = (uchar)(((1-t)*minColor[i]) + (t * maxColor[i]));
+    }
+    return output;
+}
+
+/*
+ * Compute the dem color
+*/
+cv::Vec3b get_dem_color( const double& elevation ){
+
+    // if the elevation is below the minimum, return the minimum
+    if( elevation < color_range[0].second ){
+        return color_range[0].first;
+    }
+    // if the elevation is above the maximum, return the maximum
+    if( elevation > color_range.back().second ){
+        return color_range.back().first;
+    }
+
+    // otherwise, find the proper starting index
+    int idx=0;
+    double t = 0;
+    for( int x=0; x<(int)(color_range.size()-1); x++ ){
+
+        // if the current elevation is below the next item, then use the current
+        // two colors as our range
+        if( elevation < color_range[x+1].second ){
+            idx=x;
+            t = (color_range[x+1].second - elevation)/
+                (color_range[x+1].second - color_range[x].second);
+
+            break;
+        }
+    }
+
+    // interpolate the color
+    return lerp( color_range[idx].first, color_range[idx+1].first, t);
+}
+
+/*
+ * Given a pixel coordinate and the size of the input image, compute the pixel location
+ * on the DEM image.
+*/
+cv::Point2d world2dem( cv::Point2d const& coordinate, const cv::Size& dem_size   ){
+
+
+    // relate this to the dem points
+    // ASSUMING THAT DEM DATA IS ORTHORECTIFIED
+    double demRatioX = ((dem_tr.x - coordinate.x)/(dem_tr.x - dem_bl.x));
+    double demRatioY = 1-((dem_tr.y - coordinate.y)/(dem_tr.y - dem_bl.y));
+
+    cv::Point2d output;
+    output.x = demRatioX * dem_size.width;
+    output.y = demRatioY * dem_size.height;
+
+    return output;
+}
+
+/*
+ * Convert a pixel coordinate to world coordinates
+*/
+cv::Point2d pixel2world( const int& x, const int& y, const cv::Size& size ){
+
+    // compute the ratio of the pixel location to its dimension
+    double rx = (double)x / size.width;
+    double ry = (double)y / size.height;
+
+    // compute LERP of each coordinate
+    cv::Point2d rightSide = lerp(tr, br, ry);
+    cv::Point2d leftSide  = lerp(tl, bl, ry);
+
+    // compute the actual Lat/Lon coordinate of the interpolated coordinate
+    return lerp( leftSide, rightSide, rx );
+}
+
+/*
+ * Add color to a specific pixel color value
+*/
+void add_color( cv::Vec3b& pix, const uchar& b, const uchar& g, const uchar& r ){
+
+    if( pix[0] + b < 255 && pix[0] + b >= 0 ){ pix[0] += b; }
+    if( pix[1] + g < 255 && pix[1] + g >= 0 ){ pix[1] += g; }
+    if( pix[2] + r < 255 && pix[2] + r >= 0 ){ pix[2] += r; }
+}
+
+
+/*
+ * Main Function
+*/
+int main( int argc, char* argv[] ){
+
+    /*
+     * Check input arguments
+    */
+    if( argc < 3 ){
+        cout << "usage: " << argv[0] << " <image_name> <dem_model_name>" << endl;
+        return -1;
+    }
+
+    // load the image (note that we don't have the projection information.  You will
+    // need to load that yourself or use the full GDAL driver.  The values are pre-defined
+    // at the top of this file
+    //![load1]
+    cv::Mat image = cv::imread(argv[1], cv::IMREAD_LOAD_GDAL | cv::IMREAD_COLOR );
+    //![load1]
+
+    //![load2]
+    // load the dem model
+    cv::Mat dem = cv::imread(argv[2], cv::IMREAD_LOAD_GDAL | cv::IMREAD_ANYDEPTH );
+    //![load2]
+
+    // create our output products
+    cv::Mat output_dem(   image.size(), CV_8UC3 );
+    cv::Mat output_dem_flood(   image.size(), CV_8UC3 );
+
+    // for sanity sake, make sure GDAL Loads it as a signed short
+    if( dem.type() != CV_16SC1 ){ throw std::runtime_error("DEM image type must be CV_16SC1"); }
+
+    // define the color range to create our output DEM heat map
+    //  Pair format ( Color, elevation );  Push from low to high
+    //  Note:  This would be perfect for a configuration file, but is here for a working demo.
+    color_range.push_back( std::pair<cv::Vec3b,double>(cv::Vec3b( 188, 154,  46),   -1));
+    color_range.push_back( std::pair<cv::Vec3b,double>(cv::Vec3b( 110, 220, 110), 0.25));
+    color_range.push_back( std::pair<cv::Vec3b,double>(cv::Vec3b( 150, 250, 230),   20));
+    color_range.push_back( std::pair<cv::Vec3b,double>(cv::Vec3b( 160, 220, 200),   75));
+    color_range.push_back( std::pair<cv::Vec3b,double>(cv::Vec3b( 220, 190, 170),  100));
+    color_range.push_back( std::pair<cv::Vec3b,double>(cv::Vec3b( 250, 180, 140),  200));
+
+    // define a minimum elevation
+    double minElevation = -10;
+
+    // iterate over each pixel in the image, computing the dem point
+    for( int y=0; y<image.rows; y++ ){
+    for( int x=0; x<image.cols; x++ ){
+
+        // convert the pixel coordinate to lat/lon coordinates
+        cv::Point2d coordinate = pixel2world( x, y, image.size() );
+
+        // compute the dem image pixel coordinate from lat/lon
+        cv::Point2d dem_coordinate = world2dem( coordinate, dem.size() );
+
+        // extract the elevation
+        double dz;
+        if( dem_coordinate.x >=    0    && dem_coordinate.y >=    0     &&
+            dem_coordinate.x < dem.cols && dem_coordinate.y < dem.rows ){
+            dz = dem.at<short>(dem_coordinate);
+        }else{
+            dz = minElevation;
+        }
+
+        // write the pixel value to the file
+        output_dem_flood.at<cv::Vec3b>(y,x) = image.at<cv::Vec3b>(y,x);
+
+        // compute the color for the heat map output
+        cv::Vec3b actualColor = get_dem_color(dz);
+        output_dem.at<cv::Vec3b>(y,x) = actualColor;
+
+        // show effect of a 10 meter increase in ocean levels
+        if( dz < 10 ){
+            add_color( output_dem_flood.at<cv::Vec3b>(y,x), 90, 0, 0 );
+        }
+        // show effect of a 50 meter increase in ocean levels
+        else if( dz < 50 ){
+            add_color( output_dem_flood.at<cv::Vec3b>(y,x), 0, 90, 0 );
+        }
+        // show effect of a 100 meter increase in ocean levels
+        else if( dz < 100 ){
+            add_color( output_dem_flood.at<cv::Vec3b>(y,x), 0, 0, 90 );
+        }
+
+    }}
+
+    // print our heat map
+    cv::imwrite( "heat-map.jpg"   ,  output_dem );
+
+    // print the flooding effect image
+    cv::imwrite( "flooded.jpg",  output_dem_flood);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
new file mode 100644
index 00000000..417fc0d4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
@@ -0,0 +1,39 @@
+//! [includes]
+#include <opencv2/core.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/highgui.hpp>
+
+#include <iostream>
+
+using namespace cv;
+//! [includes]
+
+int main()
+{
+    //! [imread]
+    std::string image_path = samples::findFile("starry_night.jpg");
+    Mat img = imread(image_path, IMREAD_COLOR);
+    //! [imread]
+
+    //! [empty]
+    if(img.empty())
+    {
+        std::cout << "Could not read the image: " << image_path << std::endl;
+        return 1;
+    }
+    //! [empty]
+
+    //! [imshow]
+    imshow("Display window", img);
+    int k = waitKey(0); // Wait for a keystroke in the window
+    //! [imshow]
+
+    //! [imsave]
+    if(k == 's')
+    {
+        imwrite("starry_night.png", img);
+    }
+    //! [imsave]
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/introduction/documentation/documentation.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/introduction/documentation/documentation.cpp
new file mode 100644
index 00000000..23d8c02f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/introduction/documentation/documentation.cpp
@@ -0,0 +1,14 @@
+#include <iostream>
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( void )
+{
+    //! [hello_world]
+    std::cout << "Hello World!";
+    //! [hello_world]
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/introduction/windows_visual_studio_opencv/introduction_windows_vs.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/introduction/windows_visual_studio_opencv/introduction_windows_vs.cpp
new file mode 100644
index 00000000..0080e2c7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/introduction/windows_visual_studio_opencv/introduction_windows_vs.cpp
@@ -0,0 +1,31 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+int main( int argc, char** argv )
+{
+    if( argc != 2)
+    {
+     cout <<" Usage: " << argv[0] << " ImageToLoadAndDisplay" << endl;
+     return -1;
+    }
+
+    Mat image;
+    image = imread(argv[1], IMREAD_COLOR); // Read the file
+
+    if( image.empty() ) // Check for invalid input
+    {
+        cout << "Could not open or find the image" << std::endl ;
+        return -1;
+    }
+
+    namedWindow( "Display window", WINDOW_AUTOSIZE ); // Create a window for display.
+    imshow( "Display window", image ); // Show our image inside it.
+
+    waitKey(0); // Wait for a keystroke in the window
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp
new file mode 100644
index 00000000..c0ca6724
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp
@@ -0,0 +1,146 @@
+/**
+ * @file introduction_to_pca.cpp
+ * @brief This program demonstrates how to use OpenCV PCA to extract the orientation of an object
+ * @author OpenCV team
+ */
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+// Function declarations
+void drawAxis(Mat&, Point, Point, Scalar, const float);
+double getOrientation(const vector<Point> &, Mat&);
+
+/**
+ * @function drawAxis
+ */
+void drawAxis(Mat& img, Point p, Point q, Scalar colour, const float scale = 0.2)
+{
+    //! [visualization1]
+    double angle = atan2( (double) p.y - q.y, (double) p.x - q.x ); // angle in radians
+    double hypotenuse = sqrt( (double) (p.y - q.y) * (p.y - q.y) + (p.x - q.x) * (p.x - q.x));
+
+    // Here we lengthen the arrow by a factor of scale
+    q.x = (int) (p.x - scale * hypotenuse * cos(angle));
+    q.y = (int) (p.y - scale * hypotenuse * sin(angle));
+    line(img, p, q, colour, 1, LINE_AA);
+
+    // create the arrow hooks
+    p.x = (int) (q.x + 9 * cos(angle + CV_PI / 4));
+    p.y = (int) (q.y + 9 * sin(angle + CV_PI / 4));
+    line(img, p, q, colour, 1, LINE_AA);
+
+    p.x = (int) (q.x + 9 * cos(angle - CV_PI / 4));
+    p.y = (int) (q.y + 9 * sin(angle - CV_PI / 4));
+    line(img, p, q, colour, 1, LINE_AA);
+    //! [visualization1]
+}
+
+/**
+ * @function getOrientation
+ */
+double getOrientation(const vector<Point> &pts, Mat &img)
+{
+    //! [pca]
+    //Construct a buffer used by the pca analysis
+    int sz = static_cast<int>(pts.size());
+    Mat data_pts = Mat(sz, 2, CV_64F);
+    for (int i = 0; i < data_pts.rows; i++)
+    {
+        data_pts.at<double>(i, 0) = pts[i].x;
+        data_pts.at<double>(i, 1) = pts[i].y;
+    }
+
+    //Perform PCA analysis
+    PCA pca_analysis(data_pts, Mat(), PCA::DATA_AS_ROW);
+
+    //Store the center of the object
+    Point cntr = Point(static_cast<int>(pca_analysis.mean.at<double>(0, 0)),
+                      static_cast<int>(pca_analysis.mean.at<double>(0, 1)));
+
+    //Store the eigenvalues and eigenvectors
+    vector<Point2d> eigen_vecs(2);
+    vector<double> eigen_val(2);
+    for (int i = 0; i < 2; i++)
+    {
+        eigen_vecs[i] = Point2d(pca_analysis.eigenvectors.at<double>(i, 0),
+                                pca_analysis.eigenvectors.at<double>(i, 1));
+
+        eigen_val[i] = pca_analysis.eigenvalues.at<double>(i);
+    }
+    //! [pca]
+
+    //! [visualization]
+    // Draw the principal components
+    circle(img, cntr, 3, Scalar(255, 0, 255), 2);
+    Point p1 = cntr + 0.02 * Point(static_cast<int>(eigen_vecs[0].x * eigen_val[0]), static_cast<int>(eigen_vecs[0].y * eigen_val[0]));
+    Point p2 = cntr - 0.02 * Point(static_cast<int>(eigen_vecs[1].x * eigen_val[1]), static_cast<int>(eigen_vecs[1].y * eigen_val[1]));
+    drawAxis(img, cntr, p1, Scalar(0, 255, 0), 1);
+    drawAxis(img, cntr, p2, Scalar(255, 255, 0), 5);
+
+    double angle = atan2(eigen_vecs[0].y, eigen_vecs[0].x); // orientation in radians
+    //! [visualization]
+
+    return angle;
+}
+
+/**
+ * @function main
+ */
+int main(int argc, char** argv)
+{
+    //! [pre-process]
+    // Load image
+    CommandLineParser parser(argc, argv, "{@input | pca_test1.jpg | input image}");
+    parser.about( "This program demonstrates how to use OpenCV PCA to extract the orientation of an object.\n" );
+    parser.printMessage();
+
+    Mat src = imread( samples::findFile( parser.get<String>("@input") ) );
+
+    // Check if image is loaded successfully
+    if(src.empty())
+    {
+        cout << "Problem loading image!!!" << endl;
+        return EXIT_FAILURE;
+    }
+
+    imshow("src", src);
+
+    // Convert image to grayscale
+    Mat gray;
+    cvtColor(src, gray, COLOR_BGR2GRAY);
+
+    // Convert image to binary
+    Mat bw;
+    threshold(gray, bw, 50, 255, THRESH_BINARY | THRESH_OTSU);
+    //! [pre-process]
+
+    //! [contours]
+    // Find all the contours in the thresholded image
+    vector<vector<Point> > contours;
+    findContours(bw, contours, RETR_LIST, CHAIN_APPROX_NONE);
+
+    for (size_t i = 0; i < contours.size(); i++)
+    {
+        // Calculate the area of each contour
+        double area = contourArea(contours[i]);
+        // Ignore contours that are too small or too large
+        if (area < 1e2 || 1e5 < area) continue;
+
+        // Draw each contour only for visualisation purposes
+        drawContours(src, contours, static_cast<int>(i), Scalar(0, 0, 255), 2);
+        // Find the orientation of each shape
+        getOrientation(contours[i], src);
+    }
+    //! [contours]
+
+    imshow("output", src);
+
+    waitKey();
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ml/introduction_to_svm/introduction_to_svm.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ml/introduction_to_svm/introduction_to_svm.cpp
new file mode 100644
index 00000000..a5bcf98c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ml/introduction_to_svm/introduction_to_svm.cpp
@@ -0,0 +1,81 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/ml.hpp>
+
+using namespace cv;
+using namespace cv::ml;
+
+int main(int, char**)
+{
+    // Set up training data
+    //! [setup1]
+    int labels[4] = {1, -1, -1, -1};
+    float trainingData[4][2] = { {501, 10}, {255, 10}, {501, 255}, {10, 501} };
+    //! [setup1]
+    //! [setup2]
+    Mat trainingDataMat(4, 2, CV_32F, trainingData);
+    Mat labelsMat(4, 1, CV_32SC1, labels);
+    //! [setup2]
+
+    // Train the SVM
+    //! [init]
+    Ptr<SVM> svm = SVM::create();
+    svm->setType(SVM::C_SVC);
+    svm->setKernel(SVM::LINEAR);
+    svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, 100, 1e-6));
+    //! [init]
+    //! [train]
+    svm->train(trainingDataMat, ROW_SAMPLE, labelsMat);
+    //! [train]
+
+    // Data for visual representation
+    int width = 512, height = 512;
+    Mat image = Mat::zeros(height, width, CV_8UC3);
+
+    // Show the decision regions given by the SVM
+    //! [show]
+    Vec3b green(0,255,0), blue(255,0,0);
+    for (int i = 0; i < image.rows; i++)
+    {
+        for (int j = 0; j < image.cols; j++)
+        {
+            Mat sampleMat = (Mat_<float>(1,2) << j,i);
+            float response = svm->predict(sampleMat);
+
+            if (response == 1)
+                image.at<Vec3b>(i,j)  = green;
+            else if (response == -1)
+                image.at<Vec3b>(i,j)  = blue;
+        }
+    }
+    //! [show]
+
+    // Show the training data
+    //! [show_data]
+    int thickness = -1;
+    circle( image, Point(501,  10), 5, Scalar(  0,   0,   0), thickness );
+    circle( image, Point(255,  10), 5, Scalar(255, 255, 255), thickness );
+    circle( image, Point(501, 255), 5, Scalar(255, 255, 255), thickness );
+    circle( image, Point( 10, 501), 5, Scalar(255, 255, 255), thickness );
+    //! [show_data]
+
+    // Show support vectors
+    //! [show_vectors]
+    thickness = 2;
+    Mat sv = svm->getUncompressedSupportVectors();
+
+    for (int i = 0; i < sv.rows; i++)
+    {
+        const float* v = sv.ptr<float>(i);
+        circle(image,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thickness);
+    }
+    //! [show_vectors]
+
+    imwrite("result.png", image);        // save the image
+
+    imshow("SVM Simple Example", image); // show it to the user
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/ml/non_linear_svms/non_linear_svms.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ml/non_linear_svms/non_linear_svms.cpp
new file mode 100644
index 00000000..f8b7a373
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/ml/non_linear_svms/non_linear_svms.cpp
@@ -0,0 +1,144 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include "opencv2/imgcodecs.hpp"
+#include <opencv2/highgui.hpp>
+#include <opencv2/ml.hpp>
+
+using namespace cv;
+using namespace cv::ml;
+using namespace std;
+
+static void help()
+{
+    cout<< "\n--------------------------------------------------------------------------" << endl
+        << "This program shows Support Vector Machines for Non-Linearly Separable Data. " << endl
+        << "--------------------------------------------------------------------------"   << endl
+        << endl;
+}
+
+int main()
+{
+    help();
+
+    const int NTRAINING_SAMPLES = 100;         // Number of training samples per class
+    const float FRAC_LINEAR_SEP = 0.9f;        // Fraction of samples which compose the linear separable part
+
+    // Data for visual representation
+    const int WIDTH = 512, HEIGHT = 512;
+    Mat I = Mat::zeros(HEIGHT, WIDTH, CV_8UC3);
+
+    //--------------------- 1. Set up training data randomly ---------------------------------------
+    Mat trainData(2*NTRAINING_SAMPLES, 2, CV_32F);
+    Mat labels   (2*NTRAINING_SAMPLES, 1, CV_32S);
+
+    RNG rng(100); // Random value generation class
+
+    // Set up the linearly separable part of the training data
+    int nLinearSamples = (int) (FRAC_LINEAR_SEP * NTRAINING_SAMPLES);
+
+    //! [setup1]
+    // Generate random points for the class 1
+    Mat trainClass = trainData.rowRange(0, nLinearSamples);
+    // The x coordinate of the points is in [0, 0.4)
+    Mat c = trainClass.colRange(0, 1);
+    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(0.4 * WIDTH));
+    // The y coordinate of the points is in [0, 1)
+    c = trainClass.colRange(1,2);
+    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
+
+    // Generate random points for the class 2
+    trainClass = trainData.rowRange(2*NTRAINING_SAMPLES-nLinearSamples, 2*NTRAINING_SAMPLES);
+    // The x coordinate of the points is in [0.6, 1]
+    c = trainClass.colRange(0 , 1);
+    rng.fill(c, RNG::UNIFORM, Scalar(0.6*WIDTH), Scalar(WIDTH));
+    // The y coordinate of the points is in [0, 1)
+    c = trainClass.colRange(1,2);
+    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
+    //! [setup1]
+
+    //------------------ Set up the non-linearly separable part of the training data ---------------
+    //! [setup2]
+    // Generate random points for the classes 1 and 2
+    trainClass = trainData.rowRange(nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
+    // The x coordinate of the points is in [0.4, 0.6)
+    c = trainClass.colRange(0,1);
+    rng.fill(c, RNG::UNIFORM, Scalar(0.4*WIDTH), Scalar(0.6*WIDTH));
+    // The y coordinate of the points is in [0, 1)
+    c = trainClass.colRange(1,2);
+    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
+    //! [setup2]
+
+    //------------------------- Set up the labels for the classes ---------------------------------
+    labels.rowRange(                0,   NTRAINING_SAMPLES).setTo(1);  // Class 1
+    labels.rowRange(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES).setTo(2);  // Class 2
+
+    //------------------------ 2. Set up the support vector machines parameters --------------------
+    cout << "Starting training process" << endl;
+    //! [init]
+    Ptr<SVM> svm = SVM::create();
+    svm->setType(SVM::C_SVC);
+    svm->setC(0.1);
+    svm->setKernel(SVM::LINEAR);
+    svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, (int)1e7, 1e-6));
+    //! [init]
+
+    //------------------------ 3. Train the svm ----------------------------------------------------
+    //! [train]
+    svm->train(trainData, ROW_SAMPLE, labels);
+    //! [train]
+    cout << "Finished training process" << endl;
+
+    //------------------------ 4. Show the decision regions ----------------------------------------
+    //! [show]
+    Vec3b green(0,100,0), blue(100,0,0);
+    for (int i = 0; i < I.rows; i++)
+    {
+        for (int j = 0; j < I.cols; j++)
+        {
+            Mat sampleMat = (Mat_<float>(1,2) << j, i);
+            float response = svm->predict(sampleMat);
+
+            if      (response == 1) I.at<Vec3b>(i,j) = green;
+            else if (response == 2) I.at<Vec3b>(i,j) = blue;
+        }
+    }
+    //! [show]
+
+    //----------------------- 5. Show the training data --------------------------------------------
+    //! [show_data]
+    int thick = -1;
+    float px, py;
+    // Class 1
+    for (int i = 0; i < NTRAINING_SAMPLES; i++)
+    {
+        px = trainData.at<float>(i,0);
+        py = trainData.at<float>(i,1);
+        circle(I, Point( (int) px,  (int) py ), 3, Scalar(0, 255, 0), thick);
+    }
+    // Class 2
+    for (int i = NTRAINING_SAMPLES; i <2*NTRAINING_SAMPLES; i++)
+    {
+        px = trainData.at<float>(i,0);
+        py = trainData.at<float>(i,1);
+        circle(I, Point( (int) px, (int) py ), 3, Scalar(255, 0, 0), thick);
+    }
+    //! [show_data]
+
+    //------------------------- 6. Show support vectors --------------------------------------------
+    //! [show_vectors]
+    thick = 2;
+    Mat sv = svm->getUncompressedSupportVectors();
+
+    for (int i = 0; i < sv.rows; i++)
+    {
+        const float* v = sv.ptr<float>(i);
+        circle(I,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick);
+    }
+    //! [show_vectors]
+
+    imwrite("result.png", I);                      // save the Image
+    imshow("SVM for Non-Linear Training Data", I); // show it to the user
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/objectDetection/objectDetection.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/objectDetection/objectDetection.cpp
new file mode 100644
index 00000000..063aeb26
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/objectDetection/objectDetection.cpp
@@ -0,0 +1,107 @@
+#include "opencv2/objdetect.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+/** Function Headers */
+void detectAndDisplay( Mat frame );
+
+/** Global variables */
+CascadeClassifier face_cascade;
+CascadeClassifier eyes_cascade;
+
+/** @function main */
+int main( int argc, const char** argv )
+{
+    CommandLineParser parser(argc, argv,
+                             "{help h||}"
+                             "{face_cascade|data/haarcascades/haarcascade_frontalface_alt.xml|Path to face cascade.}"
+                             "{eyes_cascade|data/haarcascades/haarcascade_eye_tree_eyeglasses.xml|Path to eyes cascade.}"
+                             "{camera|0|Camera device number.}");
+
+    parser.about( "\nThis program demonstrates using the cv::CascadeClassifier class to detect objects (Face + eyes) in a video stream.\n"
+                  "You can use Haar or LBP features.\n\n" );
+    parser.printMessage();
+
+    String face_cascade_name = samples::findFile( parser.get<String>("face_cascade") );
+    String eyes_cascade_name = samples::findFile( parser.get<String>("eyes_cascade") );
+
+    //-- 1. Load the cascades
+    if( !face_cascade.load( face_cascade_name ) )
+    {
+        cout << "--(!)Error loading face cascade\n";
+        return -1;
+    };
+    if( !eyes_cascade.load( eyes_cascade_name ) )
+    {
+        cout << "--(!)Error loading eyes cascade\n";
+        return -1;
+    };
+
+    int camera_device = parser.get<int>("camera");
+    VideoCapture capture;
+    //-- 2. Read the video stream
+    capture.open( camera_device );
+    if ( ! capture.isOpened() )
+    {
+        cout << "--(!)Error opening video capture\n";
+        return -1;
+    }
+
+    Mat frame;
+    while ( capture.read(frame) )
+    {
+        if( frame.empty() )
+        {
+            cout << "--(!) No captured frame -- Break!\n";
+            break;
+        }
+
+        //-- 3. Apply the classifier to the frame
+        detectAndDisplay( frame );
+
+        if( waitKey(10) == 27 )
+        {
+            break; // escape
+        }
+    }
+    return 0;
+}
+
+/** @function detectAndDisplay */
+void detectAndDisplay( Mat frame )
+{
+    Mat frame_gray;
+    cvtColor( frame, frame_gray, COLOR_BGR2GRAY );
+    equalizeHist( frame_gray, frame_gray );
+
+    //-- Detect faces
+    std::vector<Rect> faces;
+    face_cascade.detectMultiScale( frame_gray, faces );
+
+    for ( size_t i = 0; i < faces.size(); i++ )
+    {
+        Point center( faces[i].x + faces[i].width/2, faces[i].y + faces[i].height/2 );
+        ellipse( frame, center, Size( faces[i].width/2, faces[i].height/2 ), 0, 0, 360, Scalar( 255, 0, 255 ), 4 );
+
+        Mat faceROI = frame_gray( faces[i] );
+
+        //-- In each face, detect eyes
+        std::vector<Rect> eyes;
+        eyes_cascade.detectMultiScale( faceROI, eyes );
+
+        for ( size_t j = 0; j < eyes.size(); j++ )
+        {
+            Point eye_center( faces[i].x + eyes[j].x + eyes[j].width/2, faces[i].y + eyes[j].y + eyes[j].height/2 );
+            int radius = cvRound( (eyes[j].width + eyes[j].height)*0.25 );
+            circle( frame, eye_center, radius, Scalar( 255, 0, 0 ), 4 );
+        }
+    }
+
+    //-- Show what you got
+    imshow( "Capture - Face detection", frame );
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/decolorization/decolor.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/decolorization/decolor.cpp
new file mode 100644
index 00000000..3ad42820
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/decolorization/decolor.cpp
@@ -0,0 +1,44 @@
+/*
+* decolor.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to use OpenCV Decolorization Module.
+*
+* Input:
+* Color Image
+*
+* Output:
+* 1) Grayscale image
+* 2) Color boost image
+*
+*/
+
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main( int argc, char *argv[] )
+{
+    CommandLineParser parser( argc, argv, "{@input | HappyFish.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
+    if ( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return EXIT_FAILURE;
+    }
+
+    Mat gray, color_boost;
+    decolor( src, gray, color_boost );
+    imshow( "Source Image", src );
+    imshow( "grayscale", gray );
+    imshow( "color_boost", color_boost );
+    waitKey(0);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/hdr_imaging/hdr_imaging.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/hdr_imaging/hdr_imaging.cpp
new file mode 100644
index 00000000..5e8843bc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/hdr_imaging/hdr_imaging.cpp
@@ -0,0 +1,69 @@
+#include "opencv2/photo.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <vector>
+#include <iostream>
+#include <fstream>
+
+using namespace cv;
+using namespace std;
+
+void loadExposureSeq(String, vector<Mat>&, vector<float>&);
+
+int main(int argc, char**argv)
+{
+    CommandLineParser parser( argc, argv, "{@input | | Input directory that contains images and exposure times. }" );
+
+    //! [Load images and exposure times]
+    vector<Mat> images;
+    vector<float> times;
+    loadExposureSeq(parser.get<String>( "@input" ), images, times);
+    //! [Load images and exposure times]
+
+    //! [Estimate camera response]
+    Mat response;
+    Ptr<CalibrateDebevec> calibrate = createCalibrateDebevec();
+    calibrate->process(images, response, times);
+    //! [Estimate camera response]
+
+    //! [Make HDR image]
+    Mat hdr;
+    Ptr<MergeDebevec> merge_debevec = createMergeDebevec();
+    merge_debevec->process(images, hdr, times, response);
+    //! [Make HDR image]
+
+    //! [Tonemap HDR image]
+    Mat ldr;
+    Ptr<Tonemap> tonemap = createTonemap(2.2f);
+    tonemap->process(hdr, ldr);
+    //! [Tonemap HDR image]
+
+    //! [Perform exposure fusion]
+    Mat fusion;
+    Ptr<MergeMertens> merge_mertens = createMergeMertens();
+    merge_mertens->process(images, fusion);
+    //! [Perform exposure fusion]
+
+    //! [Write results]
+    imwrite("fusion.png", fusion * 255);
+    imwrite("ldr.png", ldr * 255);
+    imwrite("hdr.hdr", hdr);
+    //! [Write results]
+
+    return 0;
+}
+
+void loadExposureSeq(String path, vector<Mat>& images, vector<float>& times)
+{
+    path = path + "/";
+    ifstream list_file((path + "list.txt").c_str());
+    string name;
+    float val;
+    while(list_file >> name >> val) {
+        Mat img = imread(path + name);
+        images.push_back(img);
+        times.push_back(1 / val);
+    }
+    list_file.close();
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp
new file mode 100644
index 00000000..c2d88640
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp
@@ -0,0 +1,88 @@
+/*
+* npr_demo.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to use OpenCV Non-Photorealistic Rendering Module.
+* 1) Edge Preserve Smoothing
+*    -> Using Normalized convolution Filter
+*    -> Using Recursive Filter
+* 2) Detail Enhancement
+* 3) Pencil sketch/Color Pencil Drawing
+* 4) Stylization
+*
+*/
+
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main(int argc, char* argv[])
+{
+    int num,type;
+    CommandLineParser parser(argc, argv, "{@input | lena.jpg | input image}");
+    Mat src = imread( samples::findFile( parser.get<String>("@input") ), IMREAD_COLOR);
+
+    if(src.empty())
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        exit(0);
+    }
+
+    cout << endl;
+    cout << " Edge Preserve Filter" << endl;
+    cout << "----------------------" << endl;
+
+    cout << "Options: " << endl;
+    cout << endl;
+
+    cout << "1) Edge Preserve Smoothing" << endl;
+    cout << "   -> Using Normalized convolution Filter" << endl;
+    cout << "   -> Using Recursive Filter" << endl;
+    cout << "2) Detail Enhancement" << endl;
+    cout << "3) Pencil sketch/Color Pencil Drawing" << endl;
+    cout << "4) Stylization" << endl;
+    cout << endl;
+
+    cout << "Press number 1-4 to choose from above techniques: ";
+
+    cin >> num;
+
+    Mat img;
+
+    if(num == 1)
+    {
+        cout << endl;
+        cout << "Press 1 for Normalized Convolution Filter and 2 for Recursive Filter: ";
+
+        cin >> type;
+
+        edgePreservingFilter(src,img,type);
+        imshow("Edge Preserve Smoothing",img);
+
+    }
+    else if(num == 2)
+    {
+        detailEnhance(src,img);
+        imshow("Detail Enhanced",img);
+    }
+    else if(num == 3)
+    {
+        Mat img1;
+        pencilSketch(src,img1, img, 10 , 0.1f, 0.03f);
+        imshow("Pencil Sketch",img1);
+        imshow("Color Pencil Sketch",img);
+    }
+    else if(num == 4)
+    {
+        stylization(src,img);
+        imshow("Stylization",img);
+    }
+    waitKey(0);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/seamless_cloning/cloning_demo.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/seamless_cloning/cloning_demo.cpp
new file mode 100644
index 00000000..b8417116
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/seamless_cloning/cloning_demo.cpp
@@ -0,0 +1,246 @@
+/*
+* cloning_demo.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to use OpenCV seamless cloning
+* module without GUI.
+*
+* 1- Normal Cloning
+* 2- Mixed Cloning
+* 3- Monochrome Transfer
+* 4- Color Change
+* 5- Illumination change
+* 6- Texture Flattening
+
+* The program takes as input a source and a destination image (for 1-3 methods)
+* and outputs the cloned image.
+*
+* Download test images from opencv_extra folder @github.
+*
+*/
+
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include <iostream>
+#include <stdlib.h>
+
+using namespace std;
+using namespace cv;
+
+int main()
+{
+    cout << endl;
+    cout << "Cloning Module" << endl;
+    cout << "---------------" << endl;
+    cout << "Options: " << endl;
+    cout << endl;
+    cout << "1) Normal Cloning " << endl;
+    cout << "2) Mixed Cloning " << endl;
+    cout << "3) Monochrome Transfer " << endl;
+    cout << "4) Local Color Change " << endl;
+    cout << "5) Local Illumination Change " << endl;
+    cout << "6) Texture Flattening " << endl;
+    cout << endl;
+    cout << "Press number 1-6 to choose from above techniques: ";
+    int num = 1;
+    cin >> num;
+    cout << endl;
+
+    if(num == 1)
+    {
+        string folder =  "cloning/Normal_Cloning/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "destination1.png";
+        string original_path3 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat destination = imread(original_path2, IMREAD_COLOR);
+        Mat mask = imread(original_path3, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(destination.empty())
+        {
+            cout << "Could not load destination image " << original_path2 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path3 << endl;
+            exit(0);
+        }
+
+        Mat result;
+        Point p;
+        p.x = 400;
+        p.y = 100;
+
+        seamlessClone(source, destination, mask, p, result, 1);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    else if(num == 2)
+    {
+        string folder = "cloning/Mixed_Cloning/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "destination1.png";
+        string original_path3 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat destination = imread(original_path2, IMREAD_COLOR);
+        Mat mask = imread(original_path3, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(destination.empty())
+        {
+            cout << "Could not load destination image " << original_path2 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path3 << endl;
+            exit(0);
+        }
+
+        Mat result;
+        Point p;
+        p.x = destination.size().width/2;
+        p.y = destination.size().height/2;
+
+        seamlessClone(source, destination, mask, p, result, 2);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    else if(num == 3)
+    {
+        string folder = "cloning/Monochrome_Transfer/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "destination1.png";
+        string original_path3 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat destination = imread(original_path2, IMREAD_COLOR);
+        Mat mask = imread(original_path3, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(destination.empty())
+        {
+            cout << "Could not load destination image " << original_path2 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path3 << endl;
+            exit(0);
+        }
+
+        Mat result;
+        Point p;
+        p.x = destination.size().width/2;
+        p.y = destination.size().height/2;
+
+        seamlessClone(source, destination, mask, p, result, 3);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    else if(num == 4)
+    {
+        string folder = "cloning/Color_Change/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat mask = imread(original_path2, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path2 << endl;
+            exit(0);
+        }
+
+        Mat result;
+
+        colorChange(source, mask, result, 1.5, .5, .5);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    else if(num == 5)
+    {
+        string folder = "cloning/Illumination_Change/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat mask = imread(original_path2, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path2 << endl;
+            exit(0);
+        }
+
+        Mat result;
+
+        illuminationChange(source, mask, result, 0.2f, 0.4f);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    else if(num == 6)
+    {
+        string folder = "cloning/Texture_Flattening/";
+        string original_path1 = folder + "source1.png";
+        string original_path2 = folder + "mask.png";
+
+        Mat source = imread(original_path1, IMREAD_COLOR);
+        Mat mask = imread(original_path2, IMREAD_COLOR);
+
+        if(source.empty())
+        {
+            cout << "Could not load source image " << original_path1 << endl;
+            exit(0);
+        }
+        if(mask.empty())
+        {
+            cout << "Could not load mask image " << original_path2 << endl;
+            exit(0);
+        }
+
+        Mat result;
+
+        textureFlattening(source, mask, result, 30, 45, 3);
+
+        imshow("Output",result);
+        imwrite(folder + "cloned.png", result);
+    }
+    waitKey(0);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/seamless_cloning/cloning_gui.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/seamless_cloning/cloning_gui.cpp
new file mode 100644
index 00000000..1bde7ee5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/photo/seamless_cloning/cloning_gui.cpp
@@ -0,0 +1,550 @@
+/*
+* cloning.cpp
+*
+* Author:
+* Siddharth Kherada <siddharthkherada27[at]gmail[dot]com>
+*
+* This tutorial demonstrates how to use OpenCV seamless cloning
+* module.
+*
+* 1- Normal Cloning
+* 2- Mixed Cloning
+* 3- Monochrome Transfer
+* 4- Color Change
+* 5- Illumination change
+* 6- Texture Flattening
+
+* The program takes as input a source and a destination image (for 1-3 methods)
+* and outputs the cloned image.
+
+* Step 1:
+* -> In the source image, select the region of interest by left click mouse button. A Polygon ROI will be created by left clicking mouse button.
+* -> To set the Polygon ROI, click the right mouse button or 'd' key.
+* -> To reset the region selected, click the middle mouse button or 'r' key.
+
+* Step 2:
+* -> In the destination image, select the point where you want to place the ROI in the image by left clicking mouse button.
+* -> To get the cloned result, click the right mouse button or 'c' key.
+* -> To quit the program, use 'q' key.
+*
+* Result: The cloned image will be displayed.
+*/
+
+#include <signal.h>
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include <iostream>
+#include <stdlib.h>
+
+// we're NOT "using namespace std;" here, to avoid collisions between the beta variable and std::beta in c++17
+using std::cin;
+using std::cout;
+using std::endl;
+using std::string;
+
+using namespace cv;
+
+Mat img0, img1, img2, res, res1, final, final1, blend;
+
+Point point;
+int drag = 0;
+int destx, desty;
+
+int numpts = 100;
+Point* pts = new Point[100];
+Point* pts2 = new Point[100];
+Point* pts_diff = new Point[100];
+
+int var = 0;
+int flag = 0, flag1 = 0, flag4 = 0;
+
+int minx, miny, maxx, maxy, lenx, leny;
+int minxd, minyd, maxxd, maxyd, lenxd, lenyd;
+
+int channel, num, kernel_size;
+
+float alpha,beta;
+
+float red, green, blue;
+
+float low_t, high_t;
+
+void source(int, int, int, int, void*);
+void destination(int, int, int, int, void*);
+void checkfile(char*);
+
+void source(int event, int x, int y, int, void*)
+{
+
+    if (event == EVENT_LBUTTONDOWN && !drag)
+    {
+        if(flag1 == 0)
+        {
+            if(var==0)
+                img1 = img0.clone();
+            point = Point(x, y);
+            circle(img1,point,2,Scalar(0, 0, 255),-1, 8, 0);
+            pts[var] = point;
+            var++;
+            drag  = 1;
+            if(var>1)
+                line(img1,pts[var-2], point, Scalar(0, 0, 255), 2, 8, 0);
+
+            imshow("Source", img1);
+        }
+    }
+
+    if (event == EVENT_LBUTTONUP && drag)
+    {
+        imshow("Source", img1);
+
+        drag = 0;
+    }
+    if (event == EVENT_RBUTTONDOWN)
+    {
+        flag1 = 1;
+        img1 = img0.clone();
+        for(int i = var; i < numpts ; i++)
+            pts[i] = point;
+
+        if(var!=0)
+        {
+            const Point* pts3[1] = {&pts[0]};
+            polylines( img1, pts3, &numpts,1, 1, Scalar(0,0,0), 2, 8, 0);
+        }
+
+        for(int i=0;i<var;i++)
+        {
+            minx = min(minx,pts[i].x);
+            maxx = max(maxx,pts[i].x);
+            miny = min(miny,pts[i].y);
+            maxy = max(maxy,pts[i].y);
+        }
+        lenx = maxx - minx;
+        leny = maxy - miny;
+
+        int mid_pointx = minx + lenx/2;
+        int mid_pointy = miny + leny/2;
+
+        for(int i=0;i<var;i++)
+        {
+            pts_diff[i].x = pts[i].x - mid_pointx;
+            pts_diff[i].y = pts[i].y - mid_pointy;
+        }
+
+        imshow("Source", img1);
+    }
+
+    if (event == EVENT_RBUTTONUP)
+    {
+        flag = var;
+
+        final = Mat::zeros(img0.size(),CV_8UC3);
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        const Point* pts4[1] = {&pts[0]};
+
+        fillPoly(res1, pts4,&numpts, 1, Scalar(255, 255, 255), 8, 0);
+        bitwise_and(img0, img0, final,res1);
+
+        imshow("Source", img1);
+
+        if(num == 4)
+        {
+            colorChange(img0,res1,blend,red,green,blue);
+            imshow("Color Change Image", blend);
+            waitKey(0);
+
+        }
+        else if(num == 5)
+        {
+            illuminationChange(img0,res1,blend,alpha,beta);
+            imshow("Illum Change Image", blend);
+            waitKey(0);
+        }
+        else if(num == 6)
+        {
+            textureFlattening(img0,res1,blend,low_t,high_t,kernel_size);
+            imshow("Texture Flattened", blend);
+            waitKey(0);
+        }
+
+    }
+    if (event == EVENT_MBUTTONDOWN)
+    {
+        for(int i = 0; i < numpts ; i++)
+        {
+            pts[i].x=0;
+            pts[i].y=0;
+        }
+        var = 0;
+        flag1 = 0;
+        minx = INT_MAX; miny = INT_MAX; maxx = INT_MIN; maxy = INT_MIN;
+        imshow("Source", img0);
+        if(num == 1 || num == 2 || num == 3)
+            imshow("Destination",img2);
+        drag = 0;
+    }
+}
+
+void destination(int event, int x, int y, int, void*)
+{
+
+    Mat im1;
+    minxd = INT_MAX; minyd = INT_MAX; maxxd = INT_MIN; maxyd = INT_MIN;
+    im1 = img2.clone();
+    if (event == EVENT_LBUTTONDOWN)
+    {
+        flag4 = 1;
+        if(flag1 == 1)
+        {
+            point = Point(x, y);
+
+            for(int i=0;i<var;i++)
+            {
+                pts2[i].x = point.x + pts_diff[i].x;
+                pts2[i].y = point.y + pts_diff[i].y;
+            }
+
+            for(int i=var;i<numpts;i++)
+            {
+                pts2[i].x = point.x + pts_diff[0].x;
+                pts2[i].y = point.y + pts_diff[0].y;
+            }
+
+            const Point* pts5[1] = {&pts2[0]};
+            polylines( im1, pts5, &numpts,1, 1, Scalar(0,0,255), 2, 8, 0);
+
+            destx = x;
+            desty = y;
+
+            imshow("Destination", im1);
+        }
+    }
+    if (event == EVENT_RBUTTONUP)
+    {
+        for(int i=0;i<flag;i++)
+        {
+            minxd = min(minxd,pts2[i].x);
+            maxxd = max(maxxd,pts2[i].x);
+            minyd = min(minyd,pts2[i].y);
+            maxyd = max(maxyd,pts2[i].y);
+        }
+
+        if(maxxd > im1.size().width || maxyd > im1.size().height || minxd < 0 || minyd < 0)
+        {
+            cout << "Index out of range" << endl;
+            exit(0);
+        }
+
+        final1 = Mat::zeros(img2.size(),CV_8UC3);
+        res = Mat::zeros(img2.size(),CV_8UC1);
+        for(int i=miny, k=minyd;i<(miny+leny);i++,k++)
+            for(int j=minx,l=minxd ;j<(minx+lenx);j++,l++)
+            {
+                for(int c=0;c<channel;c++)
+                {
+                    final1.at<uchar>(k,l*channel+c) = final.at<uchar>(i,j*channel+c);
+
+                }
+            }
+
+        const Point* pts6[1] = {&pts2[0]};
+        fillPoly(res, pts6, &numpts, 1, Scalar(255, 255, 255), 8, 0);
+
+        if(num == 1 || num == 2 || num == 3)
+        {
+            seamlessClone(img0,img2,res1,point,blend,num);
+            imshow("Cloned Image", blend);
+            imwrite("cloned.png",blend);
+            waitKey(0);
+        }
+
+        for(int i = 0; i < flag ; i++)
+        {
+            pts2[i].x=0;
+            pts2[i].y=0;
+        }
+
+        minxd = INT_MAX; minyd = INT_MAX; maxxd = INT_MIN; maxyd = INT_MIN;
+    }
+
+    im1.release();
+}
+
+int main()
+{
+    cout << endl;
+    cout << "Cloning Module" << endl;
+    cout << "---------------" << endl;
+    cout << "Step 1:" << endl;
+    cout << " -> In the source image, select the region of interest by left click mouse button. A Polygon ROI will be created by left clicking mouse button." << endl;
+    cout << " -> To set the Polygon ROI, click the right mouse button or use 'd' key" << endl;
+    cout << " -> To reset the region selected, click the middle mouse button or use 'r' key." << endl;
+
+    cout << "Step 2:" << endl;
+    cout << " -> In the destination image, select the point where you want to place the ROI in the image by left clicking mouse button." << endl;
+    cout << " -> To get the cloned result, click the right mouse button or use 'c' key." << endl;
+    cout << " -> To quit the program, use 'q' key." << endl;
+    cout << endl;
+    cout << "Options: " << endl;
+    cout << endl;
+    cout << "1) Normal Cloning " << endl;
+    cout << "2) Mixed Cloning " << endl;
+    cout << "3) Monochrome Transfer " << endl;
+    cout << "4) Local Color Change " << endl;
+    cout << "5) Local Illumination Change " << endl;
+    cout << "6) Texture Flattening " << endl;
+
+    cout << endl;
+
+    cout << "Press number 1-6 to choose from above techniques: ";
+    cin >> num;
+    cout << endl;
+
+    minx = INT_MAX; miny = INT_MAX; maxx = INT_MIN; maxy = INT_MIN;
+
+    minxd = INT_MAX; minyd = INT_MAX; maxxd = INT_MIN; maxyd = INT_MIN;
+
+    int flag3 = 0;
+
+    if(num == 1 || num == 2 || num == 3)
+    {
+
+        string src,dest;
+        cout << "Enter Source Image: ";
+        cin >> src;
+
+        cout << "Enter Destination Image: ";
+        cin >> dest;
+
+        img0 = imread(src);
+
+        img2 = imread(dest);
+
+        if(img0.empty())
+        {
+            cout << "Source Image does not exist" << endl;
+            exit(0);
+        }
+        if(img2.empty())
+        {
+            cout << "Destination Image does not exist" << endl;
+            exit(0);
+        }
+
+        channel = img0.channels();
+
+        res = Mat::zeros(img2.size(),CV_8UC1);
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        final = Mat::zeros(img0.size(),CV_8UC3);
+        final1 = Mat::zeros(img2.size(),CV_8UC3);
+        //////////// source image ///////////////////
+
+        namedWindow("Source", 1);
+        setMouseCallback("Source", source, NULL);
+        imshow("Source", img0);
+
+        /////////// destination image ///////////////
+
+        namedWindow("Destination", 1);
+        setMouseCallback("Destination", destination, NULL);
+        imshow("Destination",img2);
+
+    }
+    else if(num == 4)
+    {
+        string src;
+        cout << "Enter Source Image: ";
+        cin >> src;
+
+        cout << "Enter RGB values: " << endl;
+        cout << "Red: ";
+        cin >> red;
+
+        cout << "Green: ";
+        cin >> green;
+
+        cout << "Blue: ";
+        cin >> blue;
+
+        img0 = imread(src);
+
+        if(img0.empty())
+        {
+            cout << "Source Image does not exist" << endl;
+            exit(0);
+        }
+
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        final = Mat::zeros(img0.size(),CV_8UC3);
+
+        //////////// source image ///////////////////
+
+        namedWindow("Source", 1);
+        setMouseCallback("Source", source, NULL);
+        imshow("Source", img0);
+
+    }
+    else if(num == 5)
+    {
+        string src;
+        cout << "Enter Source Image: ";
+        cin >> src;
+
+        cout << "alpha: ";
+        cin >> alpha;
+
+        cout << "beta: ";
+        cin >> beta;
+
+        img0 = imread(src);
+
+        if(img0.empty())
+        {
+            cout << "Source Image does not exist" << endl;
+            exit(0);
+        }
+
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        final = Mat::zeros(img0.size(),CV_8UC3);
+
+        //////////// source image ///////////////////
+
+        namedWindow("Source", 1);
+        setMouseCallback("Source", source, NULL);
+        imshow("Source", img0);
+
+    }
+    else if(num == 6)
+    {
+        string src;
+        cout << "Enter Source Image: ";
+        cin >> src;
+
+        cout << "low_threshold: ";
+        cin >> low_t;
+
+        cout << "high_threshold: ";
+        cin >> high_t;
+
+        cout << "kernel_size: ";
+        cin >> kernel_size;
+
+        img0 = imread(src);
+
+        if(img0.empty())
+        {
+            cout << "Source Image does not exist" << endl;
+            exit(0);
+        }
+
+        res1 = Mat::zeros(img0.size(),CV_8UC1);
+        final = Mat::zeros(img0.size(),CV_8UC3);
+
+        //////////// source image ///////////////////
+
+        namedWindow("Source", 1);
+        setMouseCallback("Source", source, NULL);
+        imshow("Source", img0);
+    }
+    else
+    {
+        cout << "Wrong Option Chosen" << endl;
+        exit(0);
+    }
+
+    for(;;)
+    {
+        char key = (char)waitKey(0);
+
+        if(key == 'd' && flag3 == 0)
+        {
+            flag1 = 1;
+            flag3 = 1;
+            img1 = img0.clone();
+            for(int i = var; i < numpts ; i++)
+                pts[i] = point;
+
+            if(var!=0)
+            {
+                const Point* pts3[1] = {&pts[0]};
+                polylines( img1, pts3, &numpts,1, 1, Scalar(0,0,0), 2, 8, 0);
+            }
+
+            for(int i=0;i<var;i++)
+            {
+                minx = min(minx,pts[i].x);
+                maxx = max(maxx,pts[i].x);
+                miny = min(miny,pts[i].y);
+                maxy = max(maxy,pts[i].y);
+            }
+            lenx = maxx - minx;
+            leny = maxy - miny;
+
+            int mid_pointx = minx + lenx/2;
+            int mid_pointy = miny + leny/2;
+
+            for(int i=0;i<var;i++)
+            {
+                pts_diff[i].x = pts[i].x - mid_pointx;
+                pts_diff[i].y = pts[i].y - mid_pointy;
+            }
+
+            flag = var;
+
+            final = Mat::zeros(img0.size(),CV_8UC3);
+            res1 = Mat::zeros(img0.size(),CV_8UC1);
+            const Point* pts4[1] = {&pts[0]};
+
+            fillPoly(res1, pts4,&numpts, 1, Scalar(255, 255, 255), 8, 0);
+            bitwise_and(img0, img0, final,res1);
+
+            imshow("Source", img1);
+        }
+        else if(key == 'r')
+        {
+            for(int i = 0; i < numpts ; i++)
+            {
+                pts[i].x=0;
+                pts[i].y=0;
+            }
+            var = 0;
+            flag1 = 0;
+            flag3 = 0;
+            flag4 = 0;
+            minx = INT_MAX; miny = INT_MAX; maxx = INT_MIN; maxy = INT_MIN;
+            imshow("Source", img0);
+            if(num == 1 || num == 2 || num == 3)
+                imshow("Destination",img2);
+            drag = 0;
+        }
+        else if ((num == 1 || num == 2 || num == 3) && key == 'c' && flag1 == 1 && flag4 == 1)
+        {
+            seamlessClone(img0,img2,res1,point,blend,num);
+            imshow("Cloned Image", blend);
+            imwrite("cloned.png",blend);
+        }
+        else if (num == 4 && key == 'c' && flag1 == 1)
+        {
+            colorChange(img0,res1,blend,red,green,blue);
+            imshow("Color Change Image", blend);
+            imwrite("cloned.png",blend);
+        }
+        else if (num == 5 && key == 'c' && flag1 == 1)
+        {
+            illuminationChange(img0,res1,blend,alpha,beta);
+            imshow("Illum Change Image", blend);
+            imwrite("cloned.png",blend);
+        }
+        else if (num == 6 && key == 'c' && flag1 == 1)
+        {
+            textureFlattening(img0,res1,blend,low_t,high_t,kernel_size);
+            imshow("Texture Flattened", blend);
+            imwrite("cloned.png",blend);
+        }
+        else if(key == 'q')
+            exit(0);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_mat_checkVector.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_mat_checkVector.cpp
new file mode 100644
index 00000000..512e964d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_mat_checkVector.cpp
@@ -0,0 +1,42 @@
+/**
+ * @brief It demonstrates the usage of cv::Mat::checkVector.
+ */
+
+#include <opencv2/core.hpp>
+
+int main()
+{
+    //! [example-2d]
+    cv::Mat mat(20, 1, CV_32FC2);
+    int n = mat.checkVector(2);
+    CV_Assert(n == 20); // mat has 20 elements
+
+    mat.create(20, 2, CV_32FC1);
+    n = mat.checkVector(1);
+    CV_Assert(n == -1); // mat is neither a column nor a row vector
+
+    n = mat.checkVector(2);
+    CV_Assert(n == 20); // the 2 columns are considered as 1 element
+    //! [example-2d]
+
+    mat.create(1, 5, CV_32FC1);
+    n = mat.checkVector(1);
+    CV_Assert(n == 5); // mat has 5 elements
+
+    n = mat.checkVector(5);
+    CV_Assert(n == 1); // the 5 columns are considered as 1 element
+
+    //! [example-3d]
+    int dims[] = {1, 3, 5}; // 1 plane, every plane has 3 rows and 5 columns
+    mat.create(3, dims, CV_32FC1); // for 3-d mat, it MUST have only 1 channel
+    n = mat.checkVector(5); // the 5 columns are considered as 1 element
+    CV_Assert(n == 3);
+
+    int dims2[] = {3, 1, 5}; // 3 planes, every plane has 1 row and 5 columns
+    mat.create(3, dims2, CV_32FC1);
+    n = mat.checkVector(5); // the 5 columns are considered as 1 element
+    CV_Assert(n == 3);
+    //! [example-3d]
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_merge.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_merge.cpp
new file mode 100644
index 00000000..404a0d3e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_merge.cpp
@@ -0,0 +1,36 @@
+/**
+ * @file core_merge.cpp
+ * @brief It demonstrates the usage of cv::merge.
+ *
+ * It shows how to merge 3 single channel matrices into a 3-channel matrix.
+ *
+ * @author KUANG Fangjun
+ * @date August 2017
+ */
+
+#include <iostream>
+#include <opencv2/core.hpp>
+
+using namespace std;
+using namespace cv;
+
+int main()
+{
+    //! [example]
+    Mat m1 = (Mat_<uchar>(2,2) << 1,4,7,10);
+    Mat m2 = (Mat_<uchar>(2,2) << 2,5,8,11);
+    Mat m3 = (Mat_<uchar>(2,2) << 3,6,9,12);
+
+    Mat channels[3] = {m1, m2, m3};
+    Mat m;
+    merge(channels, 3, m);
+    /*
+    m =
+    [  1,   2,   3,   4,   5,   6;
+       7,   8,   9,  10,  11,  12]
+    m.channels() = 3
+    */
+    //! [example]
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_reduce.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_reduce.cpp
new file mode 100644
index 00000000..b9d89629
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_reduce.cpp
@@ -0,0 +1,98 @@
+/**
+ * @file core_reduce.cpp
+ * @brief It demonstrates the usage of cv::reduce .
+ *
+ * It shows how to compute the row sum, column sum, row average,
+ * column average, row minimum, column minimum, row maximum
+ * and column maximum of a cv::Mat.
+ *
+ * @author KUANG Fangjun
+ * @date August 2017
+ */
+
+#include <iostream>
+#include <opencv2/core.hpp>
+
+using namespace std;
+using namespace cv;
+
+int main()
+{
+    {
+        //! [example]
+        Mat m = (Mat_<uchar>(3,2) << 1,2,3,4,5,6);
+        Mat col_sum, row_sum;
+
+        reduce(m, col_sum, 0, REDUCE_SUM, CV_32F);
+        reduce(m, row_sum, 1, REDUCE_SUM, CV_32F);
+        /*
+        m =
+        [  1,   2;
+           3,   4;
+           5,   6]
+        col_sum =
+        [9, 12]
+        row_sum =
+        [3;
+         7;
+         11]
+         */
+        //! [example]
+
+        Mat col_average, row_average, col_min, col_max, row_min, row_max;
+        reduce(m, col_average, 0, REDUCE_AVG, CV_32F);
+        cout << "col_average =\n" << col_average << endl;
+
+        reduce(m, row_average, 1, REDUCE_AVG, CV_32F);
+        cout << "row_average =\n" << row_average << endl;
+
+        reduce(m, col_min, 0, REDUCE_MIN, CV_8U);
+        cout << "col_min =\n" << col_min << endl;
+
+        reduce(m, row_min, 1, REDUCE_MIN, CV_8U);
+        cout << "row_min =\n" << row_min << endl;
+
+        reduce(m, col_max, 0, REDUCE_MAX, CV_8U);
+        cout << "col_max =\n" << col_max << endl;
+
+        reduce(m, row_max, 1, REDUCE_MAX, CV_8U);
+        cout << "row_max =\n" << row_max << endl;
+
+        /*
+        col_average =
+        [3, 4]
+        row_average =
+        [1.5;
+         3.5;
+         5.5]
+        col_min =
+        [  1,   2]
+        row_min =
+        [  1;
+           3;
+           5]
+        col_max =
+        [  5,   6]
+        row_max =
+        [  2;
+           4;
+           6]
+        */
+    }
+
+    {
+        //! [example2]
+        // two channels
+        char d[] = {1,2,3,4,5,6};
+        Mat m(3, 1, CV_8UC2, d);
+        Mat col_sum_per_channel;
+        reduce(m, col_sum_per_channel, 0, REDUCE_SUM, CV_32F);
+        /*
+        col_sum_per_channel =
+        [9, 12]
+        */
+        //! [example2]
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_split.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_split.cpp
new file mode 100644
index 00000000..4f5be336
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_split.cpp
@@ -0,0 +1,39 @@
+/**
+ * @file core_split.cpp
+ * @brief It demonstrates the usage of cv::split .
+ *
+ * It shows how to split a 3-channel matrix into a 3 single channel matrices.
+ *
+ * @author KUANG Fangjun
+ * @date August 2017
+ */
+
+#include <iostream>
+#include <opencv2/core.hpp>
+
+using namespace std;
+using namespace cv;
+
+int main()
+{
+    //! [example]
+    char d[] = {1,2,3,4,5,6,7,8,9,10,11,12};
+    Mat m(2, 2, CV_8UC3, d);
+    Mat channels[3];
+    split(m, channels);
+
+    /*
+    channels[0] =
+    [  1,   4;
+       7,  10]
+    channels[1] =
+    [  2,   5;
+       8,  11]
+    channels[2] =
+    [  3,   6;
+       9,  12]
+    */
+    //! [example]
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_various.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_various.cpp
new file mode 100644
index 00000000..46399408
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/core_various.cpp
@@ -0,0 +1,84 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/features2d.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main()
+{
+    //! [Algorithm]
+    Ptr<Feature2D> sbd = SimpleBlobDetector::create();
+    FileStorage fs_read("SimpleBlobDetector_params.xml", FileStorage::READ);
+
+    if (fs_read.isOpened()) // if we have file with parameters, read them
+    {
+        sbd->read(fs_read.root());
+        fs_read.release();
+    }
+    else // else modify the parameters and store them; user can later edit the file to use different parameters
+    {
+        fs_read.release();
+        FileStorage fs_write("SimpleBlobDetector_params.xml", FileStorage::WRITE);
+        sbd->write(fs_write);
+        fs_write.release();
+    }
+
+    Mat result, image = imread("../data/detect_blob.png", IMREAD_COLOR);
+    vector<KeyPoint> keypoints;
+    sbd->detect(image, keypoints, Mat());
+
+    drawKeypoints(image, keypoints, result);
+    for (vector<KeyPoint>::iterator k = keypoints.begin(); k != keypoints.end(); ++k)
+        circle(result, k->pt, (int)k->size, Scalar(0, 0, 255), 2);
+
+    imshow("result", result);
+    waitKey(0);
+    //! [Algorithm]
+
+    //! [RotatedRect_demo]
+    Mat test_image(200, 200, CV_8UC3, Scalar(0));
+    RotatedRect rRect = RotatedRect(Point2f(100,100), Size2f(100,50), 30);
+
+    Point2f vertices[4];
+    rRect.points(vertices);
+    for (int i = 0; i < 4; i++)
+        line(test_image, vertices[i], vertices[(i+1)%4], Scalar(0,255,0), 2);
+
+    Rect brect = rRect.boundingRect();
+    rectangle(test_image, brect, Scalar(255,0,0), 2);
+
+    imshow("rectangles", test_image);
+    waitKey(0);
+    //! [RotatedRect_demo]
+
+    {
+        //! [TickMeter_total]
+        TickMeter tm;
+        tm.start();
+        // do something ...
+        tm.stop();
+        cout << "Total time: " << tm.getTimeSec() << endl;
+        //! [TickMeter_total]
+    }
+
+    {
+        const int COUNT = 100;
+        //! [TickMeter_average]
+        TickMeter tm;
+        for (int i = 0; i < COUNT; i++)
+        {
+            tm.start();
+            // do something ...
+            tm.stop();
+        }
+        cout << "Average time per iteration in seconds: " << tm.getAvgTimeSec() << endl;
+        cout << "Average FPS: " << tm.getFPS() << endl;
+        //! [TickMeter_average]
+    }
+
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgcodecs_imwrite.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgcodecs_imwrite.cpp
new file mode 100644
index 00000000..ad9ee6d6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgcodecs_imwrite.cpp
@@ -0,0 +1,54 @@
+#include <opencv2/imgcodecs.hpp>
+
+using namespace cv;
+using namespace std;
+
+static void paintAlphaMat(Mat &mat)
+{
+    CV_Assert(mat.channels() == 4);
+    for (int i = 0; i < mat.rows; ++i)
+    {
+        for (int j = 0; j < mat.cols; ++j)
+        {
+            Vec4b& bgra = mat.at<Vec4b>(i, j);
+            bgra[0] = UCHAR_MAX; // Blue
+            bgra[1] = saturate_cast<uchar>((float (mat.cols - j)) / ((float)mat.cols) * UCHAR_MAX); // Green
+            bgra[2] = saturate_cast<uchar>((float (mat.rows - i)) / ((float)mat.rows) * UCHAR_MAX); // Red
+            bgra[3] = saturate_cast<uchar>(0.5 * (bgra[1] + bgra[2])); // Alpha
+        }
+    }
+}
+
+int main()
+{
+    Mat mat(480, 640, CV_8UC4); // Create a matrix with alpha channel
+    paintAlphaMat(mat);
+
+    vector<int> compression_params;
+    compression_params.push_back(IMWRITE_PNG_COMPRESSION);
+    compression_params.push_back(9);
+
+    bool result = false;
+    try
+    {
+        result = imwrite("alpha.png", mat, compression_params);
+    }
+    catch (const cv::Exception& ex)
+    {
+        fprintf(stderr, "Exception converting image to PNG format: %s\n", ex.what());
+    }
+
+    if (result)
+        printf("Saved PNG file with alpha data.\n");
+    else
+        printf("ERROR: Can't save PNG file.\n");
+
+    vector<Mat> imgs;
+    imgs.push_back(mat);
+    imgs.push_back(~mat);
+    imgs.push_back(mat(Rect(0, 0, mat.cols / 2, mat.rows / 2)));
+    imwrite("test.tiff", imgs);
+    printf("Multiple files saved in test.tiff\n");
+
+    return result ? 0 : 1;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_HoughLinesCircles.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_HoughLinesCircles.cpp
new file mode 100644
index 00000000..289484dc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_HoughLinesCircles.cpp
@@ -0,0 +1,33 @@
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <math.h>
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char** argv)
+{
+    Mat img, gray;
+    if( argc != 2 || !(img=imread(argv[1], 1)).data)
+        return -1;
+    cvtColor(img, gray, COLOR_BGR2GRAY);
+    // smooth it, otherwise a lot of false circles may be detected
+    GaussianBlur( gray, gray, Size(9, 9), 2, 2 );
+    vector<Vec3f> circles;
+    HoughCircles(gray, circles, HOUGH_GRADIENT,
+                 2, gray.rows/4, 200, 100 );
+    for( size_t i = 0; i < circles.size(); i++ )
+    {
+         Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
+         int radius = cvRound(circles[i][2]);
+         // draw the circle center
+         circle( img, center, 3, Scalar(0,255,0), -1, 8, 0 );
+         // draw the circle outline
+         circle( img, center, radius, Scalar(0,0,255), 3, 8, 0 );
+    }
+    namedWindow( "circles", 1 );
+    imshow( "circles", img );
+
+    waitKey(0);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_HoughLinesP.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_HoughLinesP.cpp
new file mode 100644
index 00000000..e19d29ab
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_HoughLinesP.cpp
@@ -0,0 +1,31 @@
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char** argv)
+{
+    Mat src, dst, color_dst;
+    if( argc != 2 || !(src=imread(argv[1], 0)).data)
+        return -1;
+
+    Canny( src, dst, 50, 200, 3 );
+    cvtColor( dst, color_dst, COLOR_GRAY2BGR );
+
+    vector<Vec4i> lines;
+    HoughLinesP( dst, lines, 1, CV_PI/180, 80, 30, 10 );
+    for( size_t i = 0; i < lines.size(); i++ )
+    {
+        line( color_dst, Point(lines[i][0], lines[i][1]),
+        Point( lines[i][2], lines[i][3]), Scalar(0,0,255), 3, 8 );
+    }
+    namedWindow( "Source", 1 );
+    imshow( "Source", src );
+
+    namedWindow( "Detected Lines", 1 );
+    imshow( "Detected Lines", color_dst );
+
+    waitKey(0);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_HoughLinesPointSet.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_HoughLinesPointSet.cpp
new file mode 100644
index 00000000..e5c8ec06
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_HoughLinesPointSet.cpp
@@ -0,0 +1,34 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+
+using namespace cv;
+using namespace std;
+
+int main()
+{
+    Mat lines;
+    vector<Vec3d> line3d;
+    vector<Point2f> point;
+    const static float Points[20][2] = {
+    { 0.0f,   369.0f }, { 10.0f,  364.0f }, { 20.0f,  358.0f }, { 30.0f,  352.0f },
+    { 40.0f,  346.0f }, { 50.0f,  341.0f }, { 60.0f,  335.0f }, { 70.0f,  329.0f },
+    { 80.0f,  323.0f }, { 90.0f,  318.0f }, { 100.0f, 312.0f }, { 110.0f, 306.0f },
+    { 120.0f, 300.0f }, { 130.0f, 295.0f }, { 140.0f, 289.0f }, { 150.0f, 284.0f },
+    { 160.0f, 277.0f }, { 170.0f, 271.0f }, { 180.0f, 266.0f }, { 190.0f, 260.0f }
+    };
+
+    for (int i = 0; i < 20; i++)
+    {
+        point.push_back(Point2f(Points[i][0],Points[i][1]));
+    }
+
+    double rhoMin = 0.0f, rhoMax = 360.0f, rhoStep = 1;
+    double thetaMin = 0.0f, thetaMax = CV_PI / 2.0f, thetaStep = CV_PI / 180.0f;
+
+    HoughLinesPointSet(point, lines, 20, 1,
+                       rhoMin, rhoMax, rhoStep,
+                       thetaMin, thetaMax, thetaStep);
+
+    lines.copyTo(line3d);
+    printf("votes:%d, rho:%.7f, theta:%.7f\n",(int)line3d.at(0).val[0], line3d.at(0).val[1], line3d.at(0).val[2]);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_applyColorMap.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_applyColorMap.cpp
new file mode 100644
index 00000000..280beba6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_applyColorMap.cpp
@@ -0,0 +1,32 @@
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/highgui.hpp>
+using namespace cv;
+
+#include <iostream>
+using namespace std;
+
+int main(int argc, const char *argv[])
+{
+    // We need an input image. (can be grayscale or color)
+    if (argc < 2)
+    {
+        cerr << "We need an image to process here. Please run: colorMap [path_to_image]" << endl;
+        return -1;
+    }
+    Mat img_in = imread(argv[1]);
+    if(img_in.empty())
+    {
+        cerr << "Sample image (" << argv[1] << ") is empty. Please adjust your path, so it points to a valid input image!" << endl;
+        return -1;
+    }
+    // Holds the colormap version of the image:
+    Mat img_color;
+    // Apply the colormap:
+    applyColorMap(img_in, img_color, COLORMAP_JET);
+    // Show the result:
+    imshow("colorMap", img_color);
+    waitKey(0);
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_calcHist.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_calcHist.cpp
new file mode 100644
index 00000000..9d1ca460
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_calcHist.cpp
@@ -0,0 +1,55 @@
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace cv;
+
+int main( int argc, char** argv )
+{
+    Mat src, hsv;
+    if( argc != 2 || !(src=imread(argv[1], 1)).data )
+        return -1;
+
+    cvtColor(src, hsv, COLOR_BGR2HSV);
+
+    // Quantize the hue to 30 levels
+    // and the saturation to 32 levels
+    int hbins = 30, sbins = 32;
+    int histSize[] = {hbins, sbins};
+    // hue varies from 0 to 179, see cvtColor
+    float hranges[] = { 0, 180 };
+    // saturation varies from 0 (black-gray-white) to
+    // 255 (pure spectrum color)
+    float sranges[] = { 0, 256 };
+    const float* ranges[] = { hranges, sranges };
+    MatND hist;
+    // we compute the histogram from the 0-th and 1-st channels
+    int channels[] = {0, 1};
+
+    calcHist( &hsv, 1, channels, Mat(), // do not use mask
+             hist, 2, histSize, ranges,
+             true, // the histogram is uniform
+             false );
+    double maxVal=0;
+    minMaxLoc(hist, 0, &maxVal, 0, 0);
+
+    int scale = 10;
+    Mat histImg = Mat::zeros(sbins*scale, hbins*10, CV_8UC3);
+
+    for( int h = 0; h < hbins; h++ )
+        for( int s = 0; s < sbins; s++ )
+        {
+            float binVal = hist.at<float>(h, s);
+            int intensity = cvRound(binVal*255/maxVal);
+            rectangle( histImg, Point(h*scale, s*scale),
+                        Point( (h+1)*scale - 1, (s+1)*scale - 1),
+                        Scalar::all(intensity),
+                        -1 );
+        }
+
+    namedWindow( "Source", 1 );
+    imshow( "Source", src );
+
+    namedWindow( "H-S Histogram", 1 );
+    imshow( "H-S Histogram", histImg );
+    waitKey();
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_drawContours.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_drawContours.cpp
new file mode 100644
index 00000000..4dfcde66
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_drawContours.cpp
@@ -0,0 +1,39 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+using namespace std;
+
+int main( int argc, char** argv )
+{
+    Mat src;
+    // the first command-line parameter must be a filename of the binary
+    // (black-n-white) image
+    if( argc != 2 || !(src=imread(argv[1], 0)).data)
+        return -1;
+
+    Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);
+
+    src = src > 1;
+    namedWindow( "Source", 1 );
+    imshow( "Source", src );
+
+    vector<vector<Point> > contours;
+    vector<Vec4i> hierarchy;
+
+    findContours( src, contours, hierarchy,
+        RETR_CCOMP, CHAIN_APPROX_SIMPLE );
+
+    // iterate through all the top-level contours,
+    // draw each connected component with its own random color
+    int idx = 0;
+    for( ; idx >= 0; idx = hierarchy[idx][0] )
+    {
+        Scalar color( rand()&255, rand()&255, rand()&255 );
+        drawContours( dst, contours, idx, color, FILLED, 8, hierarchy );
+    }
+
+    namedWindow( "Components", 1 );
+    imshow( "Components", dst );
+    waitKey(0);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_segmentation.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_segmentation.cpp
new file mode 100644
index 00000000..b81ba344
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/snippets/imgproc_segmentation.cpp
@@ -0,0 +1,35 @@
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgproc/segmentation.hpp"
+
+using namespace cv;
+
+static
+void usage_example_intelligent_scissors()
+{
+    Mat image(Size(1920, 1080), CV_8UC3, Scalar::all(128));
+
+    //! [usage_example_intelligent_scissors]
+    segmentation::IntelligentScissorsMB tool;
+    tool.setEdgeFeatureCannyParameters(16, 100)  // using Canny() as edge feature extractor
+        .setGradientMagnitudeMaxLimit(200);
+
+    // calculate image features
+    tool.applyImage(image);
+
+    // calculate map for specified source point
+    Point source_point(200, 100);
+    tool.buildMap(source_point);
+
+    // fast fetching of contours
+    // for specified target point and the pre-calculated map (stored internally)
+    Point target_point(400, 300);
+    std::vector<Point> pts;
+    tool.getContour(target_point, pts);
+    //! [usage_example_intelligent_scissors]
+}
+
+int main()
+{
+    usage_example_intelligent_scissors();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/bg_sub.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/bg_sub.cpp
new file mode 100644
index 00000000..5a5d9eaa
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/bg_sub.cpp
@@ -0,0 +1,87 @@
+/**
+ * @file bg_sub.cpp
+ * @brief Background subtraction tutorial sample code
+ * @author Domenico D. Bloisi
+ */
+
+#include <iostream>
+#include <sstream>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/video.hpp>
+
+using namespace cv;
+using namespace std;
+
+const char* params
+    = "{ help h         |           | Print usage }"
+      "{ input          | vtest.avi | Path to a video or a sequence of image }"
+      "{ algo           | MOG2      | Background subtraction method (KNN, MOG2) }";
+
+int main(int argc, char* argv[])
+{
+    CommandLineParser parser(argc, argv, params);
+    parser.about( "This program shows how to use background subtraction methods provided by "
+                  " OpenCV. You can process both videos and images.\n" );
+    if (parser.has("help"))
+    {
+        //print help information
+        parser.printMessage();
+    }
+
+    //! [create]
+    //create Background Subtractor objects
+    Ptr<BackgroundSubtractor> pBackSub;
+    if (parser.get<String>("algo") == "MOG2")
+        pBackSub = createBackgroundSubtractorMOG2();
+    else
+        pBackSub = createBackgroundSubtractorKNN();
+    //! [create]
+
+    //! [capture]
+    VideoCapture capture( samples::findFile( parser.get<String>("input") ) );
+    if (!capture.isOpened()){
+        //error in opening the video input
+        cerr << "Unable to open: " << parser.get<String>("input") << endl;
+        return 0;
+    }
+    //! [capture]
+
+    Mat frame, fgMask;
+    while (true) {
+        capture >> frame;
+        if (frame.empty())
+            break;
+
+        //! [apply]
+        //update the background model
+        pBackSub->apply(frame, fgMask);
+        //! [apply]
+
+        //! [display_frame_number]
+        //get the frame number and write it on the current frame
+        rectangle(frame, cv::Point(10, 2), cv::Point(100,20),
+                  cv::Scalar(255,255,255), -1);
+        stringstream ss;
+        ss << capture.get(CAP_PROP_POS_FRAMES);
+        string frameNumberString = ss.str();
+        putText(frame, frameNumberString.c_str(), cv::Point(15, 15),
+                FONT_HERSHEY_SIMPLEX, 0.5 , cv::Scalar(0,0,0));
+        //! [display_frame_number]
+
+        //! [show]
+        //show the current frame and the fg masks
+        imshow("Frame", frame);
+        imshow("FG Mask", fgMask);
+        //! [show]
+
+        //get the input from the keyboard
+        int keyboard = waitKey(30);
+        if (keyboard == 'q' || keyboard == 27)
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/meanshift/camshift.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/meanshift/camshift.cpp
new file mode 100644
index 00000000..4f5d7960
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/meanshift/camshift.cpp
@@ -0,0 +1,86 @@
+#include <iostream>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/video.hpp>
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char **argv)
+{
+    const string about =
+        "This sample demonstrates the camshift algorithm.\n"
+        "The example file can be downloaded from:\n"
+        "  https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4";
+    const string keys =
+        "{ h help |      | print this help message }"
+        "{ @image |<none>| path to image file }";
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    string filename = parser.get<string>("@image");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 0;
+    }
+
+    VideoCapture capture(filename);
+    if (!capture.isOpened()){
+        //error in opening the video input
+        cerr << "Unable to open file!" << endl;
+        return 0;
+    }
+
+    Mat frame, roi, hsv_roi, mask;
+    // take first frame of the video
+    capture >> frame;
+
+    // setup initial location of window
+    Rect track_window(300, 200, 100, 50); // simply hardcoded the values
+
+    // set up the ROI for tracking
+    roi = frame(track_window);
+    cvtColor(roi, hsv_roi, COLOR_BGR2HSV);
+    inRange(hsv_roi, Scalar(0, 60, 32), Scalar(180, 255, 255), mask);
+
+    float range_[] = {0, 180};
+    const float* range[] = {range_};
+    Mat roi_hist;
+    int histSize[] = {180};
+    int channels[] = {0};
+    calcHist(&hsv_roi, 1, channels, mask, roi_hist, 1, histSize, range);
+    normalize(roi_hist, roi_hist, 0, 255, NORM_MINMAX);
+
+    // Setup the termination criteria, either 10 iteration or move by at least 1 pt
+    TermCriteria term_crit(TermCriteria::EPS | TermCriteria::COUNT, 10, 1);
+
+    while(true){
+        Mat hsv, dst;
+        capture >> frame;
+        if (frame.empty())
+            break;
+        cvtColor(frame, hsv, COLOR_BGR2HSV);
+        calcBackProject(&hsv, 1, channels, roi_hist, dst, range);
+
+        // apply camshift to get the new location
+        RotatedRect rot_rect = CamShift(dst, track_window, term_crit);
+
+        // Draw it on image
+        Point2f points[4];
+        rot_rect.points(points);
+        for (int i = 0; i < 4; i++)
+            line(frame, points[i], points[(i+1)%4], 255, 2);
+        imshow("img2", frame);
+
+        int keyboard = waitKey(30);
+        if (keyboard == 'q' || keyboard == 27)
+            break;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/meanshift/meanshift.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/meanshift/meanshift.cpp
new file mode 100644
index 00000000..e812cb5d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/meanshift/meanshift.cpp
@@ -0,0 +1,83 @@
+#include <iostream>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/video.hpp>
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char **argv)
+{
+    const string about =
+        "This sample demonstrates the meanshift algorithm.\n"
+        "The example file can be downloaded from:\n"
+        "  https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4";
+    const string keys =
+        "{ h help |      | print this help message }"
+        "{ @image |<none>| path to image file }";
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    string filename = parser.get<string>("@image");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 0;
+    }
+
+    VideoCapture capture(filename);
+    if (!capture.isOpened()){
+        //error in opening the video input
+        cerr << "Unable to open file!" << endl;
+        return 0;
+    }
+
+    Mat frame, roi, hsv_roi, mask;
+    // take first frame of the video
+    capture >> frame;
+
+    // setup initial location of window
+    Rect track_window(300, 200, 100, 50); // simply hardcoded the values
+
+    // set up the ROI for tracking
+    roi = frame(track_window);
+    cvtColor(roi, hsv_roi, COLOR_BGR2HSV);
+    inRange(hsv_roi, Scalar(0, 60, 32), Scalar(180, 255, 255), mask);
+
+    float range_[] = {0, 180};
+    const float* range[] = {range_};
+    Mat roi_hist;
+    int histSize[] = {180};
+    int channels[] = {0};
+    calcHist(&hsv_roi, 1, channels, mask, roi_hist, 1, histSize, range);
+    normalize(roi_hist, roi_hist, 0, 255, NORM_MINMAX);
+
+    // Setup the termination criteria, either 10 iteration or move by at least 1 pt
+    TermCriteria term_crit(TermCriteria::EPS | TermCriteria::COUNT, 10, 1);
+
+    while(true){
+        Mat hsv, dst;
+        capture >> frame;
+        if (frame.empty())
+            break;
+        cvtColor(frame, hsv, COLOR_BGR2HSV);
+        calcBackProject(&hsv, 1, channels, roi_hist, dst, range);
+
+        // apply meanshift to get the new location
+        meanShift(dst, track_window, term_crit);
+
+        // Draw it on image
+        rectangle(frame, track_window, 255, 2);
+        imshow("img2", frame);
+
+        int keyboard = waitKey(30);
+        if (keyboard == 'q' || keyboard == 27)
+            break;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/optical_flow/optical_flow.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/optical_flow/optical_flow.cpp
new file mode 100644
index 00000000..0394c6ab
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/optical_flow/optical_flow.cpp
@@ -0,0 +1,101 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/video.hpp>
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char **argv)
+{
+    const string about =
+        "This sample demonstrates Lucas-Kanade Optical Flow calculation.\n"
+        "The example file can be downloaded from:\n"
+        "  https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4";
+    const string keys =
+        "{ h help |      | print this help message }"
+        "{ @image | vtest.avi | path to image file }";
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    string filename = samples::findFile(parser.get<string>("@image"));
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 0;
+    }
+
+    VideoCapture capture(filename);
+    if (!capture.isOpened()){
+        //error in opening the video input
+        cerr << "Unable to open file!" << endl;
+        return 0;
+    }
+
+    // Create some random colors
+    vector<Scalar> colors;
+    RNG rng;
+    for(int i = 0; i < 100; i++)
+    {
+        int r = rng.uniform(0, 256);
+        int g = rng.uniform(0, 256);
+        int b = rng.uniform(0, 256);
+        colors.push_back(Scalar(r,g,b));
+    }
+
+    Mat old_frame, old_gray;
+    vector<Point2f> p0, p1;
+
+    // Take first frame and find corners in it
+    capture >> old_frame;
+    cvtColor(old_frame, old_gray, COLOR_BGR2GRAY);
+    goodFeaturesToTrack(old_gray, p0, 100, 0.3, 7, Mat(), 7, false, 0.04);
+
+    // Create a mask image for drawing purposes
+    Mat mask = Mat::zeros(old_frame.size(), old_frame.type());
+
+    while(true){
+        Mat frame, frame_gray;
+
+        capture >> frame;
+        if (frame.empty())
+            break;
+        cvtColor(frame, frame_gray, COLOR_BGR2GRAY);
+
+        // calculate optical flow
+        vector<uchar> status;
+        vector<float> err;
+        TermCriteria criteria = TermCriteria((TermCriteria::COUNT) + (TermCriteria::EPS), 10, 0.03);
+        calcOpticalFlowPyrLK(old_gray, frame_gray, p0, p1, status, err, Size(15,15), 2, criteria);
+
+        vector<Point2f> good_new;
+        for(uint i = 0; i < p0.size(); i++)
+        {
+            // Select good points
+            if(status[i] == 1) {
+                good_new.push_back(p1[i]);
+                // draw the tracks
+                line(mask,p1[i], p0[i], colors[i], 2);
+                circle(frame, p1[i], 5, colors[i], -1);
+            }
+        }
+        Mat img;
+        add(frame, mask, img);
+
+        imshow("Frame", img);
+
+        int keyboard = waitKey(30);
+        if (keyboard == 'q' || keyboard == 27)
+            break;
+
+        // Now update the previous frame and previous points
+        old_gray = frame_gray.clone();
+        p0 = good_new;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/optical_flow/optical_flow_dense.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/optical_flow/optical_flow_dense.cpp
new file mode 100644
index 00000000..b4c12c35
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/video/optical_flow/optical_flow_dense.cpp
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/video.hpp>
+
+using namespace cv;
+using namespace std;
+
+int main()
+{
+    VideoCapture capture(samples::findFile("vtest.avi"));
+    if (!capture.isOpened()){
+        //error in opening the video input
+        cerr << "Unable to open file!" << endl;
+        return 0;
+    }
+
+    Mat frame1, prvs;
+    capture >> frame1;
+    cvtColor(frame1, prvs, COLOR_BGR2GRAY);
+
+    while(true){
+        Mat frame2, next;
+        capture >> frame2;
+        if (frame2.empty())
+            break;
+        cvtColor(frame2, next, COLOR_BGR2GRAY);
+
+        Mat flow(prvs.size(), CV_32FC2);
+        calcOpticalFlowFarneback(prvs, next, flow, 0.5, 3, 15, 3, 5, 1.2, 0);
+
+        // visualization
+        Mat flow_parts[2];
+        split(flow, flow_parts);
+        Mat magnitude, angle, magn_norm;
+        cartToPolar(flow_parts[0], flow_parts[1], magnitude, angle, true);
+        normalize(magnitude, magn_norm, 0.0f, 1.0f, NORM_MINMAX);
+        angle *= ((1.f / 360.f) * (180.f / 255.f));
+
+        //build hsv image
+        Mat _hsv[3], hsv, hsv8, bgr;
+        _hsv[0] = angle;
+        _hsv[1] = Mat::ones(angle.size(), CV_32F);
+        _hsv[2] = magn_norm;
+        merge(_hsv, 3, hsv);
+        hsv.convertTo(hsv8, CV_8U, 255.0);
+        cvtColor(hsv8, bgr, COLOR_HSV2BGR);
+
+        imshow("frame2", bgr);
+
+        int keyboard = waitKey(30);
+        if (keyboard == 'q' || keyboard == 27)
+            break;
+
+        prvs = next;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/videoio/orbbec_astra/orbbec_astra.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/videoio/orbbec_astra/orbbec_astra.cpp
new file mode 100644
index 00000000..6bb9f904
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/videoio/orbbec_astra/orbbec_astra.cpp
@@ -0,0 +1,215 @@
+#include <opencv2/videoio/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+
+#include <list>
+#include <iostream>
+
+
+#if !defined(HAVE_THREADS)
+int main()
+{
+    std::cout << "This sample is built without threading support. Sample code is disabled." << std::endl;
+    return 0;
+}
+#else
+
+
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <atomic>
+
+using namespace cv;
+using std::cout;
+using std::cerr;
+using std::endl;
+
+
+// Stores frames along with their timestamps
+struct Frame
+{
+    int64 timestamp;
+    Mat frame;
+};
+
+int main()
+{
+    //! [Open streams]
+    // Open depth stream
+    VideoCapture depthStream(CAP_OPENNI2_ASTRA);
+    // Open color stream
+    VideoCapture colorStream(0, CAP_V4L2);
+    //! [Open streams]
+
+    // Check that stream has opened
+    if (!colorStream.isOpened())
+    {
+        cerr << "ERROR: Unable to open color stream" << endl;
+        return 1;
+    }
+
+    // Check that stream has opened
+    if (!depthStream.isOpened())
+    {
+        cerr << "ERROR: Unable to open depth stream" << endl;
+        return 1;
+    }
+
+    //! [Setup streams]
+    // Set color and depth stream parameters
+    colorStream.set(CAP_PROP_FRAME_WIDTH,  640);
+    colorStream.set(CAP_PROP_FRAME_HEIGHT, 480);
+    depthStream.set(CAP_PROP_FRAME_WIDTH,  640);
+    depthStream.set(CAP_PROP_FRAME_HEIGHT, 480);
+    depthStream.set(CAP_PROP_OPENNI2_MIRROR, 0);
+    //! [Setup streams]
+
+    // Print color stream parameters
+    cout << "Color stream: "
+         << colorStream.get(CAP_PROP_FRAME_WIDTH) << "x" << colorStream.get(CAP_PROP_FRAME_HEIGHT)
+         << " @" << colorStream.get(CAP_PROP_FPS) << " fps" << endl;
+
+    //! [Get properties]
+    // Print depth stream parameters
+    cout << "Depth stream: "
+         << depthStream.get(CAP_PROP_FRAME_WIDTH) << "x" << depthStream.get(CAP_PROP_FRAME_HEIGHT)
+         << " @" << depthStream.get(CAP_PROP_FPS) << " fps" << endl;
+    //! [Get properties]
+
+    //! [Read streams]
+    // Create two lists to store frames
+    std::list<Frame> depthFrames, colorFrames;
+    const std::size_t maxFrames = 64;
+
+    // Synchronization objects
+    std::mutex mtx;
+    std::condition_variable dataReady;
+    std::atomic<bool> isFinish;
+
+    isFinish = false;
+
+    // Start depth reading thread
+    std::thread depthReader([&]
+    {
+        while (!isFinish)
+        {
+            // Grab and decode new frame
+            if (depthStream.grab())
+            {
+                Frame f;
+                f.timestamp = cv::getTickCount();
+                depthStream.retrieve(f.frame, CAP_OPENNI_DEPTH_MAP);
+                if (f.frame.empty())
+                {
+                    cerr << "ERROR: Failed to decode frame from depth stream" << endl;
+                    break;
+                }
+
+                {
+                    std::lock_guard<std::mutex> lk(mtx);
+                    if (depthFrames.size() >= maxFrames)
+                        depthFrames.pop_front();
+                    depthFrames.push_back(f);
+                }
+                dataReady.notify_one();
+            }
+        }
+    });
+
+    // Start color reading thread
+    std::thread colorReader([&]
+    {
+        while (!isFinish)
+        {
+            // Grab and decode new frame
+            if (colorStream.grab())
+            {
+                Frame f;
+                f.timestamp = cv::getTickCount();
+                colorStream.retrieve(f.frame);
+                if (f.frame.empty())
+                {
+                    cerr << "ERROR: Failed to decode frame from color stream" << endl;
+                    break;
+                }
+
+                {
+                    std::lock_guard<std::mutex> lk(mtx);
+                    if (colorFrames.size() >= maxFrames)
+                        colorFrames.pop_front();
+                    colorFrames.push_back(f);
+                }
+                dataReady.notify_one();
+            }
+        }
+    });
+    //! [Read streams]
+
+    //! [Pair frames]
+    // Pair depth and color frames
+    while (!isFinish)
+    {
+        std::unique_lock<std::mutex> lk(mtx);
+        while (!isFinish && (depthFrames.empty() || colorFrames.empty()))
+            dataReady.wait(lk);
+
+        while (!depthFrames.empty() && !colorFrames.empty())
+        {
+            if (!lk.owns_lock())
+                lk.lock();
+
+            // Get a frame from the list
+            Frame depthFrame = depthFrames.front();
+            int64 depthT = depthFrame.timestamp;
+
+            // Get a frame from the list
+            Frame colorFrame = colorFrames.front();
+            int64 colorT = colorFrame.timestamp;
+
+            // Half of frame period is a maximum time diff between frames
+            const int64 maxTdiff = int64(1000000000 / (2 * colorStream.get(CAP_PROP_FPS)));
+            if (depthT + maxTdiff < colorT)
+            {
+                depthFrames.pop_front();
+                continue;
+            }
+            else if (colorT + maxTdiff < depthT)
+            {
+                colorFrames.pop_front();
+                continue;
+            }
+            depthFrames.pop_front();
+            colorFrames.pop_front();
+            lk.unlock();
+
+            //! [Show frames]
+            // Show depth frame
+            Mat d8, dColor;
+            depthFrame.frame.convertTo(d8, CV_8U, 255.0 / 2500);
+            applyColorMap(d8, dColor, COLORMAP_OCEAN);
+            imshow("Depth (colored)", dColor);
+
+            // Show color frame
+            imshow("Color", colorFrame.frame);
+            //! [Show frames]
+
+            // Exit on Esc key press
+            int key = waitKey(1);
+            if (key == 27) // ESC
+            {
+                isFinish = true;
+                break;
+            }
+        }
+    }
+    //! [Pair frames]
+
+    dataReady.notify_one();
+    depthReader.join();
+    colorReader.join();
+
+    return 0;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/videoio/video-input-psnr-ssim/video-input-psnr-ssim.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/videoio/video-input-psnr-ssim/video-input-psnr-ssim.cpp
new file mode 100644
index 00000000..8d567b2f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/videoio/video-input-psnr-ssim/video-input-psnr-ssim.cpp
@@ -0,0 +1,212 @@
+#include <iostream> // for standard I/O
+#include <string>   // for strings
+#include <iomanip>  // for controlling float print precision
+#include <sstream>  // string to number conversion
+
+#include <opencv2/core.hpp>     // Basic OpenCV structures (cv::Mat, Scalar)
+#include <opencv2/imgproc.hpp>  // Gaussian Blur
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>  // OpenCV window I/O
+
+using namespace std;
+using namespace cv;
+
+double getPSNR ( const Mat& I1, const Mat& I2);
+Scalar getMSSIM( const Mat& I1, const Mat& I2);
+
+static void help()
+{
+    cout
+        << "------------------------------------------------------------------------------" << endl
+        << "This program shows how to read a video file with OpenCV. In addition, it "
+        << "tests the similarity of two input videos first with PSNR, and for the frames "
+        << "below a PSNR trigger value, also with MSSIM."                                   << endl
+        << "Usage:"                                                                         << endl
+        << "./video-input-psnr-ssim <referenceVideo> <useCaseTestVideo> <PSNR_Trigger_Value> <Wait_Between_Frames> " << endl
+        << "--------------------------------------------------------------------------"     << endl
+        << endl;
+}
+
+int main(int argc, char *argv[])
+{
+    help();
+
+    if (argc != 5)
+    {
+        cout << "Not enough parameters" << endl;
+        return -1;
+    }
+
+    stringstream conv;
+
+    const string sourceReference = argv[1], sourceCompareWith = argv[2];
+    int psnrTriggerValue, delay;
+    conv << argv[3] << endl << argv[4];       // put in the strings
+    conv >> psnrTriggerValue >> delay;        // take out the numbers
+
+    int frameNum = -1;          // Frame counter
+
+    VideoCapture captRefrnc(sourceReference), captUndTst(sourceCompareWith);
+
+    if (!captRefrnc.isOpened())
+    {
+        cout  << "Could not open reference " << sourceReference << endl;
+        return -1;
+    }
+
+    if (!captUndTst.isOpened())
+    {
+        cout  << "Could not open case test " << sourceCompareWith << endl;
+        return -1;
+    }
+
+    Size refS = Size((int) captRefrnc.get(CAP_PROP_FRAME_WIDTH),
+                     (int) captRefrnc.get(CAP_PROP_FRAME_HEIGHT)),
+         uTSi = Size((int) captUndTst.get(CAP_PROP_FRAME_WIDTH),
+                     (int) captUndTst.get(CAP_PROP_FRAME_HEIGHT));
+
+    if (refS != uTSi)
+    {
+        cout << "Inputs have different size!!! Closing." << endl;
+        return -1;
+    }
+
+    const char* WIN_UT = "Under Test";
+    const char* WIN_RF = "Reference";
+
+    // Windows
+    namedWindow(WIN_RF, WINDOW_AUTOSIZE);
+    namedWindow(WIN_UT, WINDOW_AUTOSIZE);
+    moveWindow(WIN_RF, 400       , 0);         //750,  2 (bernat =0)
+    moveWindow(WIN_UT, refS.width, 0);         //1500, 2
+
+    cout << "Reference frame resolution: Width=" << refS.width << "  Height=" << refS.height
+         << " of nr#: " << captRefrnc.get(CAP_PROP_FRAME_COUNT) << endl;
+
+    cout << "PSNR trigger value " << setiosflags(ios::fixed) << setprecision(3)
+         << psnrTriggerValue << endl;
+
+    Mat frameReference, frameUnderTest;
+    double psnrV;
+    Scalar mssimV;
+
+    for(;;) //Show the image captured in the window and repeat
+    {
+        captRefrnc >> frameReference;
+        captUndTst >> frameUnderTest;
+
+        if (frameReference.empty() || frameUnderTest.empty())
+        {
+            cout << " < < <  Game over!  > > > ";
+            break;
+        }
+
+        ++frameNum;
+        cout << "Frame: " << frameNum << "# ";
+
+        ///////////////////////////////// PSNR ////////////////////////////////////////////////////
+        psnrV = getPSNR(frameReference,frameUnderTest);
+        cout << setiosflags(ios::fixed) << setprecision(3) << psnrV << "dB";
+
+        //////////////////////////////////// MSSIM /////////////////////////////////////////////////
+        if (psnrV < psnrTriggerValue && psnrV)
+        {
+            mssimV = getMSSIM(frameReference, frameUnderTest);
+
+            cout << " MSSIM: "
+                << " R " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[2] * 100 << "%"
+                << " G " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[1] * 100 << "%"
+                << " B " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[0] * 100 << "%";
+        }
+
+        cout << endl;
+
+        ////////////////////////////////// Show Image /////////////////////////////////////////////
+        imshow(WIN_RF, frameReference);
+        imshow(WIN_UT, frameUnderTest);
+
+        char c = (char)waitKey(delay);
+        if (c == 27) break;
+    }
+
+    return 0;
+}
+
+// ![get-psnr]
+double getPSNR(const Mat& I1, const Mat& I2)
+{
+    Mat s1;
+    absdiff(I1, I2, s1);       // |I1 - I2|
+    s1.convertTo(s1, CV_32F);  // cannot make a square on 8 bits
+    s1 = s1.mul(s1);           // |I1 - I2|^2
+
+    Scalar s = sum(s1);        // sum elements per channel
+
+    double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels
+
+    if( sse <= 1e-10) // for small values return zero
+        return 0;
+    else
+    {
+        double mse  = sse / (double)(I1.channels() * I1.total());
+        double psnr = 10.0 * log10((255 * 255) / mse);
+        return psnr;
+    }
+}
+// ![get-psnr]
+
+// ![get-mssim]
+
+Scalar getMSSIM( const Mat& i1, const Mat& i2)
+{
+    const double C1 = 6.5025, C2 = 58.5225;
+    /***************************** INITS **********************************/
+    int d = CV_32F;
+
+    Mat I1, I2;
+    i1.convertTo(I1, d);            // cannot calculate on one byte large values
+    i2.convertTo(I2, d);
+
+    Mat I2_2   = I2.mul(I2);        // I2^2
+    Mat I1_2   = I1.mul(I1);        // I1^2
+    Mat I1_I2  = I1.mul(I2);        // I1 * I2
+
+    /*************************** END INITS **********************************/
+
+    Mat mu1, mu2;                   // PRELIMINARY COMPUTING
+    GaussianBlur(I1, mu1, Size(11, 11), 1.5);
+    GaussianBlur(I2, mu2, Size(11, 11), 1.5);
+
+    Mat mu1_2   =   mu1.mul(mu1);
+    Mat mu2_2   =   mu2.mul(mu2);
+    Mat mu1_mu2 =   mu1.mul(mu2);
+
+    Mat sigma1_2, sigma2_2, sigma12;
+
+    GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
+    sigma1_2 -= mu1_2;
+
+    GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
+    sigma2_2 -= mu2_2;
+
+    GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
+    sigma12 -= mu1_mu2;
+
+    ///////////////////////////////// FORMULA ////////////////////////////////
+    Mat t1, t2, t3;
+
+    t1 = 2 * mu1_mu2 + C1;
+    t2 = 2 * sigma12 + C2;
+    t3 = t1.mul(t2);                 // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+
+    t1 = mu1_2 + mu2_2 + C1;
+    t2 = sigma1_2 + sigma2_2 + C2;
+    t1 = t1.mul(t2);                 // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+
+    Mat ssim_map;
+    divide(t3, t1, ssim_map);        // ssim_map =  t3./t1;
+
+    Scalar mssim = mean(ssim_map);   // mssim = average of ssim map
+    return mssim;
+}
+// ![get-mssim]
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/videoio/video-write/video-write.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/videoio/video-write/video-write.cpp
new file mode 100644
index 00000000..56676fc9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/videoio/video-write/video-write.cpp
@@ -0,0 +1,95 @@
+#include <iostream>	// for standard I/O
+#include <string>   // for strings
+
+#include <opencv2/core.hpp>     // Basic OpenCV structures (cv::Mat)
+#include <opencv2/videoio.hpp>  // Video write
+
+using namespace std;
+using namespace cv;
+
+static void help()
+{
+    cout
+        << "------------------------------------------------------------------------------" << endl
+        << "This program shows how to write video files."                                   << endl
+        << "You can extract the R or G or B color channel of the input video."              << endl
+        << "Usage:"                                                                         << endl
+        << "./video-write <input_video_name> [ R | G | B] [Y | N]"                          << endl
+        << "------------------------------------------------------------------------------" << endl
+        << endl;
+}
+
+int main(int argc, char *argv[])
+{
+    help();
+
+    if (argc != 4)
+    {
+        cout << "Not enough parameters" << endl;
+        return -1;
+    }
+
+    const string source      = argv[1];           // the source file name
+    const bool askOutputType = argv[3][0] =='Y';  // If false it will use the inputs codec type
+
+    VideoCapture inputVideo(source);              // Open input
+    if (!inputVideo.isOpened())
+    {
+        cout  << "Could not open the input video: " << source << endl;
+        return -1;
+    }
+
+    string::size_type pAt = source.find_last_of('.');                  // Find extension point
+    const string NAME = source.substr(0, pAt) + argv[2][0] + ".avi";   // Form the new name with container
+    int ex = static_cast<int>(inputVideo.get(CAP_PROP_FOURCC));     // Get Codec Type- Int form
+
+    // Transform from int to char via Bitwise operators
+    char EXT[] = {(char)(ex & 0XFF) , (char)((ex & 0XFF00) >> 8),(char)((ex & 0XFF0000) >> 16),(char)((ex & 0XFF000000) >> 24), 0};
+
+    Size S = Size((int) inputVideo.get(CAP_PROP_FRAME_WIDTH),    // Acquire input size
+                  (int) inputVideo.get(CAP_PROP_FRAME_HEIGHT));
+
+    VideoWriter outputVideo;                                        // Open the output
+    if (askOutputType)
+        outputVideo.open(NAME, ex=-1, inputVideo.get(CAP_PROP_FPS), S, true);
+    else
+        outputVideo.open(NAME, ex, inputVideo.get(CAP_PROP_FPS), S, true);
+
+    if (!outputVideo.isOpened())
+    {
+        cout  << "Could not open the output video for write: " << source << endl;
+        return -1;
+    }
+
+    cout << "Input frame resolution: Width=" << S.width << "  Height=" << S.height
+         << " of nr#: " << inputVideo.get(CAP_PROP_FRAME_COUNT) << endl;
+    cout << "Input codec type: " << EXT << endl;
+
+    int channel = 2; // Select the channel to save
+    switch(argv[2][0])
+    {
+    case 'R' : channel = 2; break;
+    case 'G' : channel = 1; break;
+    case 'B' : channel = 0; break;
+    }
+    Mat src, res;
+    vector<Mat> spl;
+
+    for(;;) //Show the image captured in the window and repeat
+    {
+        inputVideo >> src;              // read
+        if (src.empty()) break;         // check if at end
+
+        split(src, spl);                // process - extract only the correct channel
+        for (int i =0; i < 3; ++i)
+            if (i != channel)
+                spl[i] = Mat::zeros(S, spl[0].type());
+       merge(spl, res);
+
+       //outputVideo.write(res); //save or
+       outputVideo << res;
+    }
+
+    cout << "Finished writing" << endl;
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/tutorial_code/xfeatures2D/LATCH_match.cpp b/C++/opencv-4.7.0/samples/cpp/tutorial_code/xfeatures2D/LATCH_match.cpp
new file mode 100644
index 00000000..e7889f08
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/tutorial_code/xfeatures2D/LATCH_match.cpp
@@ -0,0 +1,115 @@
+#include <iostream>
+
+#include "opencv2/opencv_modules.hpp"
+
+#ifdef HAVE_OPENCV_XFEATURES2D
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/features2d.hpp>
+#include <opencv2/xfeatures2d.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <vector>
+
+// If you find this code useful, please add a reference to the following paper in your work:
+// Gil Levi and Tal Hassner, "LATCH: Learned Arrangements of Three Patch Codes", arXiv preprint arXiv:1501.03719, 15 Jan. 2015
+
+using namespace std;
+using namespace cv;
+
+const float inlier_threshold = 2.5f; // Distance threshold to identify inliers
+const float nn_match_ratio = 0.8f;   // Nearest neighbor matching ratio
+
+int main(int argc, char* argv[])
+{
+    CommandLineParser parser(argc, argv,
+                             "{@img1 | graf1.png | input image 1}"
+                             "{@img2 | graf3.png | input image 2}"
+                             "{@homography | H1to3p.xml | homography matrix}");
+    Mat img1 = imread( samples::findFile( parser.get<String>("@img1") ), IMREAD_GRAYSCALE);
+    Mat img2 = imread( samples::findFile( parser.get<String>("@img2") ), IMREAD_GRAYSCALE);
+
+    Mat homography;
+    FileStorage fs( samples::findFile( parser.get<String>("@homography") ), FileStorage::READ);
+    fs.getFirstTopLevelNode() >> homography;
+
+    vector<KeyPoint> kpts1, kpts2;
+    Mat desc1, desc2;
+
+    Ptr<cv::ORB> orb_detector = cv::ORB::create(10000);
+
+    Ptr<xfeatures2d::LATCH> latch = xfeatures2d::LATCH::create();
+
+
+    orb_detector->detect(img1, kpts1);
+    latch->compute(img1, kpts1, desc1);
+
+    orb_detector->detect(img2, kpts2);
+    latch->compute(img2, kpts2, desc2);
+
+    BFMatcher matcher(NORM_HAMMING);
+    vector< vector<DMatch> > nn_matches;
+    matcher.knnMatch(desc1, desc2, nn_matches, 2);
+
+    vector<KeyPoint> matched1, matched2, inliers1, inliers2;
+    vector<DMatch> good_matches;
+    for (size_t i = 0; i < nn_matches.size(); i++) {
+        DMatch first = nn_matches[i][0];
+        float dist1 = nn_matches[i][0].distance;
+        float dist2 = nn_matches[i][1].distance;
+
+        if (dist1 < nn_match_ratio * dist2) {
+            matched1.push_back(kpts1[first.queryIdx]);
+            matched2.push_back(kpts2[first.trainIdx]);
+        }
+    }
+
+    for (unsigned i = 0; i < matched1.size(); i++) {
+        Mat col = Mat::ones(3, 1, CV_64F);
+        col.at<double>(0) = matched1[i].pt.x;
+        col.at<double>(1) = matched1[i].pt.y;
+
+        col = homography * col;
+        col /= col.at<double>(2);
+        double dist = sqrt(pow(col.at<double>(0) - matched2[i].pt.x, 2) +
+            pow(col.at<double>(1) - matched2[i].pt.y, 2));
+
+        if (dist < inlier_threshold) {
+            int new_i = static_cast<int>(inliers1.size());
+            inliers1.push_back(matched1[i]);
+            inliers2.push_back(matched2[i]);
+            good_matches.push_back(DMatch(new_i, new_i, 0));
+        }
+    }
+
+    Mat res;
+    drawMatches(img1, inliers1, img2, inliers2, good_matches, res);
+    imwrite("latch_result.png", res);
+
+
+    double inlier_ratio = inliers1.size() * 1.0 / matched1.size();
+    cout << "LATCH Matching Results" << endl;
+    cout << "*******************************" << endl;
+    cout << "# Keypoints 1:                        \t" << kpts1.size() << endl;
+    cout << "# Keypoints 2:                        \t" << kpts2.size() << endl;
+    cout << "# Matches:                            \t" << matched1.size() << endl;
+    cout << "# Inliers:                            \t" << inliers1.size() << endl;
+    cout << "# Inliers Ratio:                      \t" << inlier_ratio << endl;
+    cout << endl;
+
+    imshow("result", res);
+    waitKey();
+
+    return 0;
+}
+
+#else
+
+int main()
+{
+    std::cerr << "OpenCV was built without xfeatures2d module" << std::endl;
+    return 0;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_audio.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_audio.cpp
new file mode 100644
index 00000000..c9f1ec94
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_audio.cpp
@@ -0,0 +1,59 @@
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char** argv)
+{
+    CommandLineParser parser(argc, argv, "{@audio||}");
+    string file = parser.get<string>("@audio");
+
+    if (file.empty())
+    {
+        return 1;
+    }
+
+    Mat frame;
+    vector<vector<Mat>> audioData;
+    VideoCapture cap;
+    vector<int> params {    CAP_PROP_AUDIO_STREAM, 0,
+                            CAP_PROP_VIDEO_STREAM, -1,
+                            CAP_PROP_AUDIO_DATA_DEPTH, CV_16S   };
+
+    cap.open(file, CAP_MSMF, params);
+    if (!cap.isOpened())
+    {
+        cerr << "ERROR! Can't to open file: " + file << endl;
+        return -1;
+    }
+
+    const int audioBaseIndex = (int)cap.get(CAP_PROP_AUDIO_BASE_INDEX);
+    const int numberOfChannels = (int)cap.get(CAP_PROP_AUDIO_TOTAL_CHANNELS);
+    cout << "CAP_PROP_AUDIO_DATA_DEPTH: " << depthToString((int)cap.get(CAP_PROP_AUDIO_DATA_DEPTH)) << endl;
+    cout << "CAP_PROP_AUDIO_SAMPLES_PER_SECOND: " << cap.get(CAP_PROP_AUDIO_SAMPLES_PER_SECOND) << endl;
+    cout << "CAP_PROP_AUDIO_TOTAL_CHANNELS: " << numberOfChannels << endl;
+    cout << "CAP_PROP_AUDIO_TOTAL_STREAMS: " << cap.get(CAP_PROP_AUDIO_TOTAL_STREAMS) << endl;
+
+    int numberOfSamples = 0;
+    audioData.resize(numberOfChannels);
+    for (;;)
+    {
+        if (cap.grab())
+        {
+            for (int nCh = 0; nCh < numberOfChannels; nCh++)
+            {
+                cap.retrieve(frame, audioBaseIndex+nCh);
+                audioData[nCh].push_back(frame);
+                numberOfSamples+=frame.cols;
+            }
+        }
+        else { break; }
+    }
+
+    cout << "Number of samples: " << numberOfSamples << endl;
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_audio_combination.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_audio_combination.cpp
new file mode 100644
index 00000000..7f0deecf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_audio_combination.cpp
@@ -0,0 +1,69 @@
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv, "{@audio||}");
+    string file = parser.get<string>("@audio");
+
+    if (file.empty())
+    {
+        return 1;
+    }
+
+    Mat videoFrame;
+    Mat audioFrame;
+    vector<vector<Mat>> audioData;
+    VideoCapture cap;
+    vector<int> params {    CAP_PROP_AUDIO_STREAM, 0,
+                            CAP_PROP_VIDEO_STREAM, 0,
+                            CAP_PROP_AUDIO_DATA_DEPTH, CV_16S   };
+
+    cap.open(file, CAP_MSMF, params);
+    if (!cap.isOpened())
+    {
+        cerr << "ERROR! Can't to open file: " + file << endl;
+        return -1;
+    }
+
+    const int audioBaseIndex = (int)cap.get(CAP_PROP_AUDIO_BASE_INDEX);
+    const int numberOfChannels = (int)cap.get(CAP_PROP_AUDIO_TOTAL_CHANNELS);
+    cout << "CAP_PROP_AUDIO_DATA_DEPTH: " << depthToString((int)cap.get(CAP_PROP_AUDIO_DATA_DEPTH)) << endl;
+    cout << "CAP_PROP_AUDIO_SAMPLES_PER_SECOND: " << cap.get(CAP_PROP_AUDIO_SAMPLES_PER_SECOND) << endl;
+    cout << "CAP_PROP_AUDIO_TOTAL_CHANNELS: " << cap.get(CAP_PROP_AUDIO_TOTAL_CHANNELS) << endl;
+    cout << "CAP_PROP_AUDIO_TOTAL_STREAMS: " << cap.get(CAP_PROP_AUDIO_TOTAL_STREAMS) << endl;
+
+    int numberOfSamples = 0;
+    int numberOfFrames = 0;
+    audioData.resize(numberOfChannels);
+    for (;;)
+    {
+        if (cap.grab())
+        {
+            cap.retrieve(videoFrame);
+            for (int nCh = 0; nCh < numberOfChannels; nCh++)
+            {
+                cap.retrieve(audioFrame, audioBaseIndex+nCh);
+                if (!audioFrame.empty())
+                    audioData[nCh].push_back(audioFrame);
+                numberOfSamples+=audioFrame.cols;
+            }
+            if (!videoFrame.empty())
+            {
+                numberOfFrames++;
+                imshow("Live", videoFrame);
+                if (waitKey(5) >= 0)
+                    break;
+            }
+        } else { break; }
+    }
+
+    cout << "Number of audio samples: " << numberOfSamples << endl
+         << "Number of video frames: " << numberOfFrames << endl;
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_basic.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_basic.cpp
new file mode 100644
index 00000000..61ccb1f5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_basic.cpp
@@ -0,0 +1,54 @@
+/**
+  @file videocapture_basic.cpp
+  @brief A very basic sample for using VideoCapture and VideoWriter
+  @author PkLab.net
+  @date Aug 24, 2016
+*/
+
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+using namespace std;
+
+int main(int, char**)
+{
+    Mat frame;
+    //--- INITIALIZE VIDEOCAPTURE
+    VideoCapture cap;
+    // open the default camera using default API
+    // cap.open(0);
+    // OR advance usage: select any API backend
+    int deviceID = 0;             // 0 = open default camera
+    int apiID = cv::CAP_ANY;      // 0 = autodetect default API
+    // open selected camera using selected API
+    cap.open(deviceID, apiID);
+    // check if we succeeded
+    if (!cap.isOpened()) {
+        cerr << "ERROR! Unable to open camera\n";
+        return -1;
+    }
+
+    //--- GRAB AND WRITE LOOP
+    cout << "Start grabbing" << endl
+        << "Press any key to terminate" << endl;
+    for (;;)
+    {
+        // wait for a new frame from camera and store it into 'frame'
+        cap.read(frame);
+        // check if we succeeded
+        if (frame.empty()) {
+            cerr << "ERROR! blank frame grabbed\n";
+            break;
+        }
+        // show live and wait for a key with timeout long enough to show images
+        imshow("Live", frame);
+        if (waitKey(5) >= 0)
+            break;
+    }
+    // the camera will be deinitialized automatically in VideoCapture destructor
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_camera.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_camera.cpp
new file mode 100644
index 00000000..ca39b209
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_camera.cpp
@@ -0,0 +1,76 @@
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>  // cv::Canny()
+#include <iostream>
+
+using namespace cv;
+using std::cout; using std::cerr; using std::endl;
+
+int main(int, char**)
+{
+    Mat frame;
+    cout << "Opening camera..." << endl;
+    VideoCapture capture(0); // open the first camera
+    if (!capture.isOpened())
+    {
+        cerr << "ERROR: Can't initialize camera capture" << endl;
+        return 1;
+    }
+
+    cout << "Frame width: " << capture.get(CAP_PROP_FRAME_WIDTH) << endl;
+    cout << "     height: " << capture.get(CAP_PROP_FRAME_HEIGHT) << endl;
+    cout << "Capturing FPS: " << capture.get(CAP_PROP_FPS) << endl;
+
+    cout << endl << "Press 'ESC' to quit, 'space' to toggle frame processing" << endl;
+    cout << endl << "Start grabbing..." << endl;
+
+    size_t nFrames = 0;
+    bool enableProcessing = false;
+    int64 t0 = cv::getTickCount();
+    int64 processingTime = 0;
+    for (;;)
+    {
+        capture >> frame; // read the next frame from camera
+        if (frame.empty())
+        {
+            cerr << "ERROR: Can't grab camera frame." << endl;
+            break;
+        }
+        nFrames++;
+        if (nFrames % 10 == 0)
+        {
+            const int N = 10;
+            int64 t1 = cv::getTickCount();
+            cout << "Frames captured: " << cv::format("%5lld", (long long int)nFrames)
+                 << "    Average FPS: " << cv::format("%9.1f", (double)getTickFrequency() * N / (t1 - t0))
+                 << "    Average time per frame: " << cv::format("%9.2f ms", (double)(t1 - t0) * 1000.0f / (N * getTickFrequency()))
+                 << "    Average processing time: " << cv::format("%9.2f ms", (double)(processingTime) * 1000.0f / (N * getTickFrequency()))
+                 << std::endl;
+            t0 = t1;
+            processingTime = 0;
+        }
+        if (!enableProcessing)
+        {
+            imshow("Frame", frame);
+        }
+        else
+        {
+            int64 tp0 = cv::getTickCount();
+            Mat processed;
+            cv::Canny(frame, processed, 400, 1000, 5);
+            processingTime += cv::getTickCount() - tp0;
+            imshow("Frame", processed);
+        }
+        int key = waitKey(1);
+        if (key == 27/*ESC*/)
+            break;
+        if (key == 32/*SPACE*/)
+        {
+            enableProcessing = !enableProcessing;
+            cout << "Enable frame processing ('space' key): " << enableProcessing << endl;
+        }
+    }
+    std::cout << "Number of captured frames: " << nFrames << endl;
+    return nFrames > 0 ? 0 : 1;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_gphoto2_autofocus.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_gphoto2_autofocus.cpp
new file mode 100644
index 00000000..6e635ee7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_gphoto2_autofocus.cpp
@@ -0,0 +1,438 @@
+/*
+ * Copyright (c) 2015, Piotr Dobrowolski dobrypd[at]gmail[dot]com
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <cstdlib>
+#include <cstdio>
+#include <iostream>
+#include <algorithm>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+using namespace std;
+using namespace cv;
+
+const char * windowOriginal = "Captured preview";
+const int FOCUS_STEP = 1024;
+const int MAX_FOCUS_STEP = 32767;
+const int FOCUS_DIRECTION_INFTY = 1;
+const int DEFAULT_BREAK_LIMIT = 5;
+const int DEFAULT_OUTPUT_FPS = 20;
+const double epsylon = 0.0005; // compression, noise, etc.
+
+struct Args_t
+{
+    string deviceName;
+    string output;
+    int fps;
+    int minimumFocusStep;
+    int breakLimit;
+    bool measure;
+    bool verbose;
+} GlobalArgs;
+
+struct FocusState
+{
+    int step;
+    int direction;
+    int minFocusStep;
+    int lastDirectionChange;
+    int stepToLastMax;
+    double rate;
+    double rateMax;
+};
+
+static ostream & operator<<(ostream & os, FocusState & state)
+{
+    return os << "RATE=" << state.rate << "\tSTEP="
+            << state.step * state.direction << "\tLast change="
+            << state.lastDirectionChange << "\tstepToLastMax="
+            << state.stepToLastMax;
+}
+
+static FocusState createInitialState()
+{
+    FocusState state;
+    state.step = FOCUS_STEP;
+    state.direction = FOCUS_DIRECTION_INFTY;
+    state.minFocusStep = 0;
+    state.lastDirectionChange = 0;
+    state.stepToLastMax = 0;
+    state.rate = 0;
+    state.rateMax = 0;
+    return state;
+}
+
+static void focusDriveEnd(VideoCapture & cap, int direction)
+{
+    while (cap.set(CAP_PROP_ZOOM, (double) MAX_FOCUS_STEP * direction))
+        ;
+}
+
+/**
+ * Minimal focus step depends on lens
+ * and I don't want to make any assumptions about it.
+ */
+static int findMinFocusStep(VideoCapture & cap, unsigned int startWith,
+        int direction)
+{
+    int lStep, rStep;
+    lStep = 0;
+    rStep = startWith;
+
+    focusDriveEnd(cap, direction * FOCUS_DIRECTION_INFTY);
+    while (lStep < rStep)
+    {
+        int mStep = (lStep + rStep) / 2;
+        cap.set(CAP_PROP_ZOOM, direction * FOCUS_DIRECTION_INFTY * FOCUS_STEP);
+        if (cap.set(CAP_PROP_ZOOM, -direction * mStep))
+        {
+            rStep = mStep;
+        }
+        else
+        {
+            lStep = mStep + 1;
+        }
+    }
+    cap.set(CAP_PROP_ZOOM, direction * FOCUS_DIRECTION_INFTY * MAX_FOCUS_STEP);
+    if (GlobalArgs.verbose)
+    {
+        cout << "Found minimal focus step = " << lStep << endl;
+    }
+    return lStep;
+}
+
+/**
+ * Rate frame from 0/blury/ to 1/sharp/.
+ */
+static double rateFrame(Mat & frame)
+{
+    unsigned long int sum = 0;
+    unsigned long int size = frame.cols * frame.rows;
+    Mat edges;
+    cvtColor(frame, edges, COLOR_BGR2GRAY);
+    GaussianBlur(edges, edges, Size(7, 7), 1.5, 1.5);
+    Canny(edges, edges, 0, 30, 3);
+
+    MatIterator_<uchar> it, end;
+    for (it = edges.begin<uchar>(), end = edges.end<uchar>(); it != end; ++it)
+    {
+        sum += *it != 0;
+    }
+
+    return (double) sum / (double) size;
+}
+
+static int correctFocus(bool lastSucceeded, FocusState & state, double rate)
+{
+    if (GlobalArgs.verbose)
+    {
+        cout << "RATE=" << rate << endl;
+    }
+    state.lastDirectionChange++;
+    double rateDelta = rate - state.rate;
+
+    if (rate >= state.rateMax + epsylon)
+    {
+        // Update Max
+        state.stepToLastMax = 0;
+        state.rateMax = rate;
+        // My local minimum is now on the other direction, that's why:
+        state.lastDirectionChange = 0;
+    }
+
+    if (!lastSucceeded)
+    {
+        // Focus at limit or other problem, change the direction.
+        state.direction *= -1;
+        state.lastDirectionChange = 0;
+        state.step /= 2;
+    }
+    else
+    {
+        if (rate < epsylon)
+        { // It's hard to say anything
+            state.step = FOCUS_STEP;
+        }
+        else if (rateDelta < -epsylon)
+        { // Wrong direction ?
+            state.direction *= -1;
+            state.step = static_cast<int>(static_cast<double>(state.step) * 0.75);
+            state.lastDirectionChange = 0;
+        }
+        else if ((rate + epsylon < state.rateMax)
+                && ((state.lastDirectionChange > 3)
+                        || ((state.step < (state.minFocusStep * 1.5))
+                                && state.stepToLastMax > state.step)))
+        { // I've done 3 steps (or I'm finishing) without improvement, go back to max.
+            state.direction = state.stepToLastMax >= 0 ? 1 : -1;
+            state.step = static_cast<int>(static_cast<double>(state.step) * 0.75);
+            int stepToMax = abs(state.stepToLastMax);
+            state.stepToLastMax = 0;
+            state.lastDirectionChange = 0; // Like reset.
+            state.rate = rate;
+            return stepToMax;
+        }
+    }
+    // Update state.
+    state.rate = rate;
+    state.stepToLastMax -= state.direction * state.step;
+    return state.step;
+}
+
+static void showHelp(const char * pName, bool welcomeMsg)
+{
+    cout << "This program demonstrates usage of gPhoto2 VideoCapture.\n\n"
+            "With OpenCV build without gPhoto2 library support it will "
+            "do nothing special, just capture.\n\n"
+            "Simple implementation of autofocus is based on edges detection.\n"
+            "It was tested (this example) only with Nikon DSLR (Nikon D90).\n"
+            "But shall work on all Nikon DSLRs, and with little effort with other devices.\n"
+            "Visit http://www.gphoto.org/proj/libgphoto2/support.php\n"
+            "to find supported devices (need Image Capture at least).\n"
+            "Before run, set your camera autofocus ON.\n\n";
+
+    if (!welcomeMsg)
+    {
+        cout << "usage " << pName << ": [OPTIONS] DEVICE_NAME\n\n"
+                "OPTIONS:\n"
+                "\t-h\t\treturns this help message,\n"
+                "\t-o=<FILENAME>\tsave output video in file (MJPEG only),\n"
+                "\t-f=FPS\t\tframes per second in output video,\n"
+                "\t-m\t\tmeasure exposition\n"
+                "\t\t\t(returns rates from closest focus to INTY\n"
+                "\t\t\tfor every minimum step),\n"
+                "\t-d=<INT>\t\tset minimum focus step,\n"
+                "\t-v\t\tverbose mode.\n\n\n"
+                "DEVICE_NAME\t\tis your digital camera model substring.\n\n\n"
+                "On runtime you can use keys to control:\n";
+    }
+    else
+    {
+        cout << "Actions:\n";
+    }
+
+    cout << "\tk:\t- focus out,\n"
+            "\tj:\t- focus in,\n"
+            "\t,:\t- focus to the closest point,\n"
+            "\t.:\t- focus to infinity,\n"
+            "\tr:\t- reset autofocus state,\n"
+            "\tf:\t- switch autofocus on/off,\n"
+            "\tq:\t- quit.\n";
+}
+
+static bool parseArguments(int argc, char ** argv)
+{
+    cv::CommandLineParser parser(argc, argv, "{h help ||}{o||}{f||}{m||}{d|0|}{v||}{@device|Nikon|}");
+    if (parser.has("help"))
+        return false;
+    GlobalArgs.breakLimit = DEFAULT_BREAK_LIMIT;
+    if (parser.has("o"))
+        GlobalArgs.output = parser.get<string>("o");
+    else
+        GlobalArgs.output = "";
+    if (parser.has("f"))
+        GlobalArgs.fps = parser.get<int>("f");
+    else
+        GlobalArgs.fps = DEFAULT_OUTPUT_FPS;
+    GlobalArgs.measure = parser.has("m");
+    GlobalArgs.verbose = parser.has("v");
+    GlobalArgs.minimumFocusStep = parser.get<int>("d");
+    GlobalArgs.deviceName = parser.get<string>("@device");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return false;
+    }
+    if (GlobalArgs.fps < 0)
+    {
+        cerr << "Invalid fps argument." << endl;
+        return false;
+    }
+    if (GlobalArgs.minimumFocusStep < 0)
+    {
+        cerr << "Invalid minimum focus step argument." << endl;
+        return false;
+    }
+    return true;
+}
+
+int main(int argc, char ** argv)
+{
+    if (!parseArguments(argc, argv))
+    {
+        showHelp(argv[0], false);
+        return -1;
+    }
+    VideoCapture cap(GlobalArgs.deviceName);
+    if (!cap.isOpened())
+    {
+        cout << "Cannot find device " << GlobalArgs.deviceName << endl;
+        showHelp(argv[0], false);
+        return -1;
+    }
+
+    VideoWriter videoWriter;
+    Mat frame;
+    FocusState state = createInitialState();
+    bool focus = true;
+    bool lastSucceeded = true;
+    namedWindow(windowOriginal, 1);
+
+    // Get settings:
+    if (GlobalArgs.verbose)
+    {
+        if ((cap.get(CAP_PROP_GPHOTO2_WIDGET_ENUMERATE) == 0)
+                || (cap.get(CAP_PROP_GPHOTO2_WIDGET_ENUMERATE) == -1))
+        {
+            // Some VideoCapture implementations can return -1, 0.
+            cout << "This is not GPHOTO2 device." << endl;
+            return -2;
+        }
+        cout << "List of camera settings: " << endl
+                << (const char *) (intptr_t) cap.get(CAP_PROP_GPHOTO2_WIDGET_ENUMERATE)
+                << endl;
+        cap.set(CAP_PROP_GPHOTO2_COLLECT_MSGS, true);
+    }
+
+    cap.set(CAP_PROP_GPHOTO2_PREVIEW, true);
+    cap.set(CAP_PROP_VIEWFINDER, true);
+    cap >> frame; // To check PREVIEW output Size.
+    if (!GlobalArgs.output.empty())
+    {
+        Size S = Size((int) cap.get(CAP_PROP_FRAME_WIDTH), (int) cap.get(CAP_PROP_FRAME_HEIGHT));
+        int fourCC = VideoWriter::fourcc('M', 'J', 'P', 'G');
+        videoWriter.open(GlobalArgs.output, fourCC, GlobalArgs.fps, S, true);
+        if (!videoWriter.isOpened())
+        {
+            cerr << "Cannot open output file " << GlobalArgs.output << endl;
+            showHelp(argv[0], false);
+            return -1;
+        }
+    }
+    showHelp(argv[0], true); // welcome msg
+
+    if (GlobalArgs.minimumFocusStep == 0)
+    {
+        state.minFocusStep = findMinFocusStep(cap, FOCUS_STEP / 16, -FOCUS_DIRECTION_INFTY);
+    }
+    else
+    {
+        state.minFocusStep = GlobalArgs.minimumFocusStep;
+    }
+    focusDriveEnd(cap, -FOCUS_DIRECTION_INFTY); // Start with closest
+
+    char key = 0;
+    while (key != 'q' && key != 27 /*ESC*/)
+    {
+        cap >> frame;
+        if (frame.empty())
+        {
+            break;
+        }
+        if (!GlobalArgs.output.empty())
+        {
+            videoWriter << frame;
+        }
+
+        if (focus && !GlobalArgs.measure)
+        {
+            int stepToCorrect = correctFocus(lastSucceeded, state, rateFrame(frame));
+            lastSucceeded = cap.set(CAP_PROP_ZOOM,
+                    max(stepToCorrect, state.minFocusStep) * state.direction);
+            if ((!lastSucceeded) || (stepToCorrect < state.minFocusStep))
+            {
+                if (--GlobalArgs.breakLimit <= 0)
+                {
+                    focus = false;
+                    state.step = state.minFocusStep * 4;
+                    cout << "In focus, you can press 'f' to improve with small step, "
+                            "or 'r' to reset." << endl;
+                }
+            }
+            else
+            {
+                GlobalArgs.breakLimit = DEFAULT_BREAK_LIMIT;
+            }
+        }
+        else if (GlobalArgs.measure)
+        {
+            double rate = rateFrame(frame);
+            if (!cap.set(CAP_PROP_ZOOM, state.minFocusStep))
+            {
+                if (--GlobalArgs.breakLimit <= 0)
+                {
+                    break;
+                }
+            }
+            else
+            {
+                cout << rate << endl;
+            }
+        }
+
+        if ((focus || GlobalArgs.measure) && GlobalArgs.verbose)
+        {
+            cout << "STATE\t" << state << endl;
+            cout << "Output from camera: " << endl
+                    << (const char *) (intptr_t) cap.get(CAP_PROP_GPHOTO2_FLUSH_MSGS) << endl;
+        }
+
+        imshow(windowOriginal, frame);
+        switch (key = static_cast<char>(waitKey(30)))
+        {
+            case 'k': // focus out
+                cap.set(CAP_PROP_ZOOM, 100);
+                break;
+            case 'j': // focus in
+                cap.set(CAP_PROP_ZOOM, -100);
+                break;
+            case ',': // Drive to closest
+                focusDriveEnd(cap, -FOCUS_DIRECTION_INFTY);
+                break;
+            case '.': // Drive to infinity
+                focusDriveEnd(cap, FOCUS_DIRECTION_INFTY);
+                break;
+            case 'r': // reset focus state
+                focus = true;
+                state = createInitialState();
+                break;
+            case 'f': // focus switch on/off
+                focus ^= true;
+                break;
+        }
+    }
+
+    if (GlobalArgs.verbose)
+    {
+        cout << "Captured " << (int) cap.get(CAP_PROP_FRAME_COUNT) << " frames"
+                << endl << "in " << (int) (cap.get(CAP_PROP_POS_MSEC) / 1e2)
+                << " seconds," << endl << "at avg speed "
+                << (cap.get(CAP_PROP_FPS)) << " fps." << endl;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_gstreamer_pipeline.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_gstreamer_pipeline.cpp
new file mode 100644
index 00000000..ed9d6fd3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_gstreamer_pipeline.cpp
@@ -0,0 +1,380 @@
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <string>
+#include <iostream>
+#include <map>
+
+using namespace std;
+using namespace cv;
+
+//================================================================================
+
+template<typename M>
+inline typename M::mapped_type getValue(const M &dict, const typename M::key_type &key, const string & errorMessage)
+{
+    typename M::const_iterator it = dict.find(key);
+    if (it == dict.end())
+    {
+        CV_Error(Error::StsBadArg, errorMessage);
+    }
+    return it->second;
+}
+
+inline map<string, Size> sizeByResolution()
+{
+    map<string, Size> res;
+    res["720p"] = Size(1280, 720);
+    res["1080p"] = Size(1920, 1080);
+    res["4k"] = Size(3840, 2160);
+    return res;
+}
+
+inline map<string, int> fourccByCodec()
+{
+    map<string, int> res;
+    res["h264"] = VideoWriter::fourcc('H','2','6','4');
+    res["h265"] = VideoWriter::fourcc('H','E','V','C');
+    res["mpeg2"] = VideoWriter::fourcc('M','P','E','G');
+    res["mpeg4"] = VideoWriter::fourcc('M','P','4','2');
+    res["mjpeg"] = VideoWriter::fourcc('M','J','P','G');
+    res["vp8"] = VideoWriter::fourcc('V','P','8','0');
+    return res;
+}
+
+inline map<string, string> defaultEncodeElementByCodec()
+{
+    map<string, string> res;
+    res["h264"] = "x264enc";
+    res["h265"] = "x265enc";
+    res["mpeg2"] = "mpeg2enc";
+    res["mjpeg"] = "jpegenc";
+    res["vp8"] = "vp8enc";
+    return res;
+}
+
+inline map<string, string> VAAPIEncodeElementByCodec()
+{
+    map<string, string> res;
+    res["h264"] = "parsebin ! vaapih264enc";
+    res["h265"] = "parsebin ! vaapih265enc";
+    res["mpeg2"] = "parsebin ! vaapimpeg2enc";
+    res["mjpeg"] = "parsebin ! vaapijpegenc";
+    res["vp8"] = "parsebin ! vaapivp8enc";
+    return res;
+}
+
+inline map<string, string> mfxDecodeElementByCodec()
+{
+    map<string, string> res;
+    res["h264"] = "parsebin ! mfxh264dec";
+    res["h265"] = "parsebin ! mfxhevcdec";
+    res["mpeg2"] = "parsebin ! mfxmpeg2dec";
+    res["mjpeg"] = "parsebin ! mfxjpegdec";
+    return res;
+}
+
+inline map<string, string> mfxEncodeElementByCodec()
+{
+    map<string, string> res;
+    res["h264"] = "mfxh264enc";
+    res["h265"] = "mfxhevcenc";
+    res["mpeg2"] = "mfxmpeg2enc";
+    res["mjpeg"] = "mfxjpegenc";
+    return res;
+}
+
+inline map<string, string> libavDecodeElementByCodec()
+{
+    map<string, string> res;
+    res["h264"] = "parsebin ! avdec_h264";
+    res["h265"] = "parsebin ! avdec_h265";
+    res["mpeg2"] = "parsebin ! avdec_mpeg2video";
+    res["mpeg4"] = "parsebin ! avdec_mpeg4";
+    res["mjpeg"] = "parsebin ! avdec_mjpeg";
+    res["vp8"] = "parsebin ! avdec_vp8";
+    return res;
+}
+
+inline map<string, string> libavEncodeElementByCodec()
+{
+    map<string, string> res;
+    res["h264"] = "avenc_h264";
+    res["h265"] = "avenc_h265";
+    res["mpeg2"] = "avenc_mpeg2video";
+    res["mpeg4"] = "avenc_mpeg4";
+    res["mjpeg"] = "avenc_mjpeg";
+    res["vp8"] = "avenc_vp8";
+    return res;
+}
+
+inline map<string, string> demuxPluginByContainer()
+{
+    map<string, string> res;
+    res["avi"] = "avidemux";
+    res["mp4"] = "qtdemux";
+    res["mov"] = "qtdemux";
+    res["mkv"] = "matroskademux";
+    return res;
+}
+
+inline map<string, string> muxPluginByContainer()
+{
+    map<string, string> res;
+    res["avi"] = "avimux";
+    res["mp4"] = "qtmux";
+    res["mov"] = "qtmux";
+    res["mkv"] = "matroskamux";
+    return res;
+}
+
+//================================================================================
+
+inline string containerByName(const string &name)
+{
+    size_t found = name.rfind(".");
+    if (found != string::npos)
+    {
+        return name.substr(found + 1);  // container type
+    }
+    return string();
+}
+
+//================================================================================
+
+inline Ptr<VideoCapture> createCapture(const string &backend, const string &file_name, const string &codec)
+{
+    if (backend == "gst-default")
+    {
+        cout << "Created GStreamer capture ( " << file_name << " )" << endl;
+        return makePtr<VideoCapture>(file_name, CAP_GSTREAMER);
+    }
+    else if (backend.find("gst") == 0)
+    {
+        ostringstream line;
+        line << "filesrc location=\"" << file_name << "\"";
+        line << " ! ";
+        line << getValue(demuxPluginByContainer(), containerByName(file_name), "Invalid container");
+        line << " ! ";
+        if (backend.find("basic") == 4)
+            line << "decodebin";
+        else if (backend.find("vaapi") == 4)
+            line << "vaapidecodebin";
+        else if (backend.find("libav") == 4)
+            line << getValue(libavDecodeElementByCodec(), codec, "Invalid codec");
+        else if (backend.find("mfx") == 4)
+            line << getValue(mfxDecodeElementByCodec(), codec, "Invalid or unsupported codec");
+        else
+            return Ptr<VideoCapture>();
+        line << " ! videoconvert n-threads=" << getNumThreads();
+        line << " ! appsink sync=false";
+        cout << "Created GStreamer capture  ( " << line.str() << " )" << endl;
+        return makePtr<VideoCapture>(line.str(), CAP_GSTREAMER);
+    }
+    else if (backend == "ffmpeg")
+    {
+        cout << "Created FFmpeg capture ( " << file_name << " )" << endl;
+        return makePtr<VideoCapture>(file_name, CAP_FFMPEG);
+    }
+    return Ptr<VideoCapture>();
+}
+
+inline Ptr<VideoCapture> createSynthSource(Size sz, unsigned fps)
+{
+    ostringstream line;
+    line << "videotestsrc pattern=smpte";
+    line << " ! video/x-raw";
+    line << ",width=" << sz.width << ",height=" << sz.height;
+    if (fps > 0)
+        line << ",framerate=" << fps << "/1";
+    line << " ! appsink sync=false";
+    cout << "Created synthetic video source ( " << line.str() << " )" << endl;
+    return makePtr<VideoCapture>(line.str(), CAP_GSTREAMER);
+}
+
+inline Ptr<VideoWriter> createWriter(const string &backend, const string &file_name, const string &codec, Size sz, unsigned fps)
+{
+    if (backend == "gst-default")
+    {
+        cout << "Created GStreamer writer ( " << file_name << ", FPS=" << fps << ", Size=" << sz << ")" << endl;
+        return makePtr<VideoWriter>(file_name, CAP_GSTREAMER, getValue(fourccByCodec(), codec, "Invalid codec"), fps, sz, true);
+    }
+    else if (backend.find("gst") == 0)
+    {
+        ostringstream line;
+        line << "appsrc ! videoconvert n-threads=" << getNumThreads() << " ! ";
+        if (backend.find("basic") == 4)
+            line << getValue(defaultEncodeElementByCodec(), codec, "Invalid codec");
+        else if (backend.find("vaapi") == 4)
+            line << getValue(VAAPIEncodeElementByCodec(), codec, "Invalid codec");
+        else if (backend.find("libav") == 4)
+            line << getValue(libavEncodeElementByCodec(), codec, "Invalid codec");
+        else if (backend.find("mfx") == 4)
+            line << getValue(mfxEncodeElementByCodec(), codec, "Invalid codec");
+        else
+            return Ptr<VideoWriter>();
+        line << " ! ";
+        line << getValue(muxPluginByContainer(), containerByName(file_name), "Invalid container");
+        line << " ! ";
+        line << "filesink location=\"" << file_name << "\"";
+        cout << "Created GStreamer writer ( " << line.str() << " )" << endl;
+        return makePtr<VideoWriter>(line.str(), CAP_GSTREAMER, 0, fps, sz, true);
+    }
+    else if (backend == "ffmpeg")
+    {
+        cout << "Created FFmpeg writer ( " << file_name << ", FPS=" << fps << ", Size=" << sz << " )" << endl;
+        return makePtr<VideoWriter>(file_name, CAP_FFMPEG, getValue(fourccByCodec(), codec, "Invalid codec"), fps, sz, true);
+    }
+    return Ptr<VideoWriter>();
+}
+
+//================================================================================
+
+int main(int argc, char *argv[])
+{
+    const string keys =
+        "{h help usage ? |           | print help messages   }"
+        "{m mode         |decode     | coding mode (supported: encode, decode) }"
+        "{b backend      |default    | video backend (supported: 'gst-default', 'gst-basic', 'gst-vaapi', 'gst-libav', 'gst-mfx', 'ffmpeg') }"
+        "{c codec        |h264       | codec name     (supported: 'h264', 'h265', 'mpeg2', 'mpeg4', 'mjpeg', 'vp8') }"
+        "{f file path    |           | path to file }"
+        "{r resolution   |720p       | video resolution for encoding (supported: '720p', '1080p', '4k') }"
+        "{fps            |30         | fix frame per second for encoding (supported: fps > 0) }"
+        "{fast           |           | fast measure fps }";
+    CommandLineParser cmd_parser(argc, argv, keys);
+    cmd_parser.about("This program measures performance of video encoding and decoding using different backends OpenCV.");
+    if (cmd_parser.has("help"))
+    {
+        cmd_parser.printMessage();
+        return 0;
+    }
+    bool fast_measure = cmd_parser.has("fast");               // fast measure fps
+    unsigned fix_fps      = cmd_parser.get<unsigned>("fps");      // fixed frame per second
+    string backend     = cmd_parser.get<string>("backend");   // video backend
+    string mode         = cmd_parser.get<string>("mode");       // coding mode
+    string codec        = cmd_parser.get<string>("codec");      // codec type
+    string file_name    = cmd_parser.get<string>("file");       // path to videofile
+    string resolution   = cmd_parser.get<string>("resolution"); // video resolution
+    if (!cmd_parser.check())
+    {
+        cmd_parser.printErrors();
+        return -1;
+    }
+    if (mode != "encode" && mode != "decode")
+    {
+        cout << "Unsupported mode: " << mode << endl;
+        return -1;
+    }
+    if (mode == "decode")
+    {
+        file_name = samples::findFile(file_name);
+    }
+    cout << "Mode: " << mode << ", Backend: " << backend << ", File: " << file_name << ", Codec: " << codec << endl;
+
+    TickMeter total;
+    Ptr<VideoCapture> cap;
+    Ptr<VideoWriter> wrt;
+    try
+    {
+        if (mode == "decode")
+        {
+            cap = createCapture(backend, file_name, codec);
+            if (!cap)
+            {
+                cout << "Failed to create video capture" << endl;
+                return -3;
+            }
+            if (!cap->isOpened())
+            {
+                cout << "Capture is not opened" << endl;
+                return -4;
+            }
+        }
+        else if (mode == "encode")
+        {
+            Size sz = getValue(sizeByResolution(), resolution, "Invalid resolution");
+            cout << "FPS: " << fix_fps << ", Frame size: " << sz << endl;
+            cap = createSynthSource(sz, fix_fps);
+            wrt = createWriter(backend, file_name, codec, sz, fix_fps);
+            if (!cap || !wrt)
+            {
+                cout << "Failed to create synthetic video source or video writer" << endl;
+                return -3;
+            }
+            if (!cap->isOpened() || !wrt->isOpened())
+            {
+                cout << "Synthetic video source or video writer is not opened" << endl;
+                return -4;
+            }
+        }
+    }
+    catch (...)
+    {
+        cout << "Unsupported parameters" << endl;
+        return -2;
+    }
+
+    TickMeter tick;
+    Mat frame;
+    Mat element;
+    total.start();
+    while(true)
+    {
+        if (mode == "decode")
+        {
+            tick.start();
+            if (!cap->grab())
+            {
+                cout << "No more frames - break" << endl;
+                break;
+            }
+            if (!cap->retrieve(frame))
+            {
+                cout << "Failed to retrieve frame - break" << endl;
+                break;
+            }
+            if (frame.empty())
+            {
+                cout << "Empty frame received - break" << endl;
+                break;
+            }
+            tick.stop();
+        }
+        else if (mode == "encode")
+        {
+            int limit = 100;
+            while (!cap->grab() && --limit != 0)
+            {
+                cout << "Skipping empty input frame - " << limit << endl;
+            }
+            cap->retrieve(element);
+            tick.start();
+            *wrt << element;
+            tick.stop();
+        }
+
+        if (fast_measure && tick.getCounter() >= 1000)
+        {
+            cout << "Fast mode frame limit reached - break" << endl;
+            break;
+        }
+        if (mode == "encode" && tick.getCounter() >= 1000)
+        {
+            cout << "Encode frame limit reached - break" << endl;
+            break;
+        }
+    }
+    total.stop();
+    if (tick.getCounter() == 0)
+    {
+        cout << "No frames have been processed" << endl;
+        return -10;
+    }
+    else
+    {
+        double res_fps = tick.getCounter() / tick.getTimeSec();
+        cout << tick.getCounter() << " frames in " << tick.getTimeSec() << " sec ~ " << res_fps << " FPS" << " (total time: " << total.getTimeSec() << " sec)" << endl;
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_image_sequence.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_image_sequence.cpp
new file mode 100644
index 00000000..ac99f785
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_image_sequence.cpp
@@ -0,0 +1,60 @@
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help(char** argv)
+{
+    cout << "\nThis sample shows you how to read a sequence of images using the VideoCapture interface.\n"
+         << "Usage: " << argv[0] << " <image_mask> (example mask: example_%02d.jpg)\n"
+         << "Image mask defines the name variation for the input images that have to be read as a sequence. \n"
+         << "Using the mask example_%02d.jpg will read in images labeled as 'example_00.jpg', 'example_01.jpg', etc."
+         << endl;
+}
+
+int main(int argc, char** argv)
+{
+    help(argv);
+    cv::CommandLineParser parser(argc, argv, "{@image| ../data/left%02d.jpg |}");
+    string first_file = parser.get<string>("@image");
+
+    if(first_file.empty())
+    {
+        return 1;
+    }
+
+    VideoCapture sequence(first_file);
+
+    if (!sequence.isOpened())
+    {
+        cerr << "Failed to open the image sequence!\n" << endl;
+        return 1;
+    }
+
+    Mat image;
+    namedWindow("Image sequence | press ESC to close", 1);
+
+    for(;;)
+    {
+        // Read in image from sequence
+        sequence >> image;
+
+        // If no image was retrieved -> end of sequence
+        if(image.empty())
+        {
+            cout << "End of Sequence" << endl;
+            break;
+        }
+
+        imshow("Image sequence | press ESC to close", image);
+
+        if(waitKey(500) == 27)
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_microphone.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_microphone.cpp
new file mode 100644
index 00000000..0c69ec92
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_microphone.cpp
@@ -0,0 +1,57 @@
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+int main(int, char**)
+{
+    Mat frame;
+    vector<Mat> audioData;
+    VideoCapture cap;
+    vector<int> params {    CAP_PROP_AUDIO_STREAM, 0,
+                            CAP_PROP_VIDEO_STREAM, -1   };
+
+    cap.open(0, CAP_MSMF, params);
+    if (!cap.isOpened())
+    {
+        cerr << "ERROR! Can't to open microphone" << endl;
+        return -1;
+    }
+
+    const int audioBaseIndex = (int)cap.get(CAP_PROP_AUDIO_BASE_INDEX);
+    const int numberOfChannels = (int)cap.get(CAP_PROP_AUDIO_TOTAL_CHANNELS);
+    cout << "CAP_PROP_AUDIO_DATA_DEPTH: " << depthToString((int)cap.get(CAP_PROP_AUDIO_DATA_DEPTH)) << endl;
+    cout << "CAP_PROP_AUDIO_SAMPLES_PER_SECOND: " << cap.get(CAP_PROP_AUDIO_SAMPLES_PER_SECOND) << endl;
+    cout << "CAP_PROP_AUDIO_TOTAL_CHANNELS: " << numberOfChannels << endl;
+    cout << "CAP_PROP_AUDIO_TOTAL_STREAMS: " << cap.get(CAP_PROP_AUDIO_TOTAL_STREAMS) << endl;
+
+    const double cvTickFreq = getTickFrequency();
+    int64 sysTimeCurr = getTickCount();
+    int64 sysTimePrev = sysTimeCurr;
+    while ((sysTimeCurr-sysTimePrev)/cvTickFreq < 10)
+    {
+        if (cap.grab())
+        {
+            for (int nCh = 0; nCh < numberOfChannels; nCh++)
+            {
+                cap.retrieve(frame, audioBaseIndex+nCh);
+                audioData.push_back(frame);
+                sysTimeCurr = getTickCount();
+            }
+        }
+        else
+        {
+            cerr << "Grab error" << endl;
+            break;
+        }
+    }
+    int numberOfSamles = 0;
+    for (auto item : audioData)
+        numberOfSamles+=item.cols;
+    cout << "Number of samples: " << numberOfSamles << endl;
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_obsensor.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_obsensor.cpp
new file mode 100644
index 00000000..98eb9f47
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_obsensor.cpp
@@ -0,0 +1,74 @@
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <iostream>
+
+using namespace cv;
+int main()
+{
+    VideoCapture obsensorCapture(0, CAP_OBSENSOR);
+    if(!obsensorCapture.isOpened()){
+        std::cerr << "Failed to open obsensor capture! Index out of range or no response from device";
+        return -1;
+    }
+
+    double fx = obsensorCapture.get(CAP_PROP_OBSENSOR_INTRINSIC_FX);
+    double fy = obsensorCapture.get(CAP_PROP_OBSENSOR_INTRINSIC_FY);
+    double cx = obsensorCapture.get(CAP_PROP_OBSENSOR_INTRINSIC_CX);
+    double cy = obsensorCapture.get(CAP_PROP_OBSENSOR_INTRINSIC_CY);
+    std::cout << "obsensor camera intrinsic params: fx=" << fx << ", fy=" << fy << ", cx=" << cx << ", cy=" << cy << std::endl;
+
+    Mat image;
+    Mat depthMap;
+    Mat adjDepthMap;
+    while (true)
+    {
+        // Grab depth map like this:
+        // obsensorCapture >> depthMap;
+
+        // Another way to grab depth map (and bgr image).
+        if (obsensorCapture.grab())
+        {
+            if (obsensorCapture.retrieve(image, CAP_OBSENSOR_BGR_IMAGE))
+            {
+                imshow("RGB", image);
+            }
+
+            if (obsensorCapture.retrieve(depthMap, CAP_OBSENSOR_DEPTH_MAP))
+            {
+                normalize(depthMap, adjDepthMap, 0, 255, NORM_MINMAX, CV_8UC1);
+                applyColorMap(adjDepthMap, adjDepthMap, COLORMAP_JET);
+                imshow("DEPTH", adjDepthMap);
+            }
+
+            // depth map overlay on bgr image
+            static const float alpha = 0.6f;
+            if (!image.empty() && !depthMap.empty())
+            {
+                normalize(depthMap, adjDepthMap, 0, 255, NORM_MINMAX, CV_8UC1);
+                cv::resize(adjDepthMap, adjDepthMap, cv::Size(image.cols, image.rows));
+                for (int i = 0; i < image.rows; i++)
+                {
+                    for (int j = 0; j < image.cols; j++)
+                    {
+                        cv::Vec3b& outRgb = image.at<cv::Vec3b>(i, j);
+                        uint8_t depthValue = 255 - adjDepthMap.at<uint8_t>(i, j);
+                        if (depthValue != 0 && depthValue != 255)
+                        {
+                            outRgb[0] = (uint8_t)(outRgb[0] * (1.0f - alpha) + depthValue * alpha);
+                            outRgb[1] = (uint8_t)(outRgb[1] * (1.0f - alpha) + depthValue *  alpha);
+                            outRgb[2] = (uint8_t)(outRgb[2] * (1.0f - alpha) + depthValue *  alpha);
+                        }
+                    }
+                }
+                imshow("DepthToColor", image);
+            }
+            image.release();
+            depthMap.release();
+        }
+
+        if (pollKey() >= 0)
+            break;
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_openni.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_openni.cpp
new file mode 100644
index 00000000..5b4b23f1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_openni.cpp
@@ -0,0 +1,282 @@
+#include "opencv2/videoio/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help()
+{
+        cout << "\nThis program demonstrates usage of depth sensors (Kinect, XtionPRO,...).\n"
+                        "The user gets some of the supported output images.\n"
+            "\nAll supported output map types:\n"
+            "1.) Data given from depth generator\n"
+            "   CAP_OPENNI_DEPTH_MAP            - depth values in mm (CV_16UC1)\n"
+            "   CAP_OPENNI_POINT_CLOUD_MAP      - XYZ in meters (CV_32FC3)\n"
+            "   CAP_OPENNI_DISPARITY_MAP        - disparity in pixels (CV_8UC1)\n"
+            "   CAP_OPENNI_DISPARITY_MAP_32F    - disparity in pixels (CV_32FC1)\n"
+            "   CAP_OPENNI_VALID_DEPTH_MASK     - mask of valid pixels (not occluded, not shaded etc.) (CV_8UC1)\n"
+            "2.) Data given from RGB image generator\n"
+            "   CAP_OPENNI_BGR_IMAGE            - color image (CV_8UC3)\n"
+            "   CAP_OPENNI_GRAY_IMAGE           - gray image (CV_8UC1)\n"
+            "2.) Data given from IR image generator\n"
+            "   CAP_OPENNI_IR_IMAGE             - gray image (CV_16UC1)\n"
+         << endl;
+}
+
+static void colorizeDisparity( const Mat& gray, Mat& rgb, double maxDisp=-1.f)
+{
+    CV_Assert( !gray.empty() );
+    CV_Assert( gray.type() == CV_8UC1 );
+
+    if( maxDisp <= 0 )
+    {
+        maxDisp = 0;
+        minMaxLoc( gray, 0, &maxDisp );
+    }
+
+    rgb.create( gray.size(), CV_8UC3 );
+    rgb = Scalar::all(0);
+    if( maxDisp < 1 )
+        return;
+
+    Mat tmp;
+    convertScaleAbs(gray, tmp, 255.f / maxDisp);
+    applyColorMap(tmp, rgb, COLORMAP_JET);
+}
+
+static float getMaxDisparity( VideoCapture& capture )
+{
+    const int minDistance = 400; // mm
+    float b = (float)capture.get( CAP_OPENNI_DEPTH_GENERATOR_BASELINE ); // mm
+    float F = (float)capture.get( CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH ); // pixels
+    return b * F / minDistance;
+}
+
+static void printCommandLineParams()
+{
+    cout << "-cd=       Colorized disparity? (0 or 1; 1 by default) Ignored if disparity map is not selected to show." << endl;
+    cout << "-fmd=      Fixed max disparity? (0 or 1; 0 by default) Ignored if disparity map is not colorized (-cd 0)." << endl;
+    cout << "-mode=     image mode: resolution and fps, supported three values:  0 - CAP_OPENNI_VGA_30HZ, 1 - CAP_OPENNI_SXGA_15HZ," << endl;
+    cout << "          2 - CAP_OPENNI_SXGA_30HZ (0 by default). Ignored if rgb image or gray image are not selected to show." << endl;
+    cout << "-m=        Mask to set which output images are need. It is a string of size 6. Each element of this is '0' or '1' and" << endl;
+    cout << "          determine: is depth map, disparity map, valid pixels mask, rgb image, gray image need or not (correspondently), ir image" << endl ;
+    cout << "          By default -m=010100 i.e. disparity map and rgb image will be shown." << endl ;
+    cout << "-r=        Filename of .oni video file. The data will grabbed from it." << endl ;
+}
+
+static void parseCommandLine( int argc, char* argv[], bool& isColorizeDisp, bool& isFixedMaxDisp, int& imageMode, bool retrievedImageFlags[],
+                       string& filename, bool& isFileReading )
+{
+    filename.clear();
+    cv::CommandLineParser parser(argc, argv, "{h help||}{cd|1|}{fmd|0|}{mode|-1|}{m|010100|}{r||}");
+    if (parser.has("h"))
+    {
+        help();
+        printCommandLineParams();
+        exit(0);
+    }
+    isColorizeDisp = (parser.get<int>("cd") != 0);
+    isFixedMaxDisp = (parser.get<int>("fmd") != 0);
+    imageMode = parser.get<int>("mode");
+    int flags = parser.get<int>("m");
+    isFileReading = parser.has("r");
+    if (isFileReading)
+        filename = parser.get<string>("r");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        help();
+        exit(-1);
+    }
+    if (flags % 1000000 == 0)
+    {
+        cout << "No one output image is selected." << endl;
+        exit(0);
+    }
+    for (int i = 0; i < 6; i++)
+    {
+        retrievedImageFlags[5 - i] = (flags % 10 != 0);
+        flags /= 10;
+    }
+}
+
+/*
+ * To work with Kinect or XtionPRO the user must install OpenNI library and PrimeSensorModule for OpenNI and
+ * configure OpenCV with WITH_OPENNI flag is ON (using CMake).
+ */
+int main( int argc, char* argv[] )
+{
+    bool isColorizeDisp, isFixedMaxDisp;
+    int imageMode;
+    bool retrievedImageFlags[6];
+    string filename;
+    bool isVideoReading;
+    parseCommandLine( argc, argv, isColorizeDisp, isFixedMaxDisp, imageMode, retrievedImageFlags, filename, isVideoReading );
+
+    cout << "Device opening ..." << endl;
+    VideoCapture capture;
+    if( isVideoReading )
+        capture.open( filename );
+    else
+    {
+        capture.open( CAP_OPENNI2 );
+        if( !capture.isOpened() )
+            capture.open( CAP_OPENNI );
+    }
+
+    cout << "done." << endl;
+
+    if( !capture.isOpened() )
+    {
+        cout << "Can not open a capture object." << endl;
+        return -1;
+    }
+
+    if( !isVideoReading && imageMode >= 0 )
+    {
+        bool modeRes=false;
+        switch ( imageMode )
+        {
+            case 0:
+                modeRes = capture.set( CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE, CAP_OPENNI_VGA_30HZ );
+                break;
+            case 1:
+                modeRes = capture.set( CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE, CAP_OPENNI_SXGA_15HZ );
+                break;
+            case 2:
+                modeRes = capture.set( CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE, CAP_OPENNI_SXGA_30HZ );
+                break;
+                //The following modes are only supported by the Xtion Pro Live
+            case 3:
+                modeRes = capture.set( CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE, CAP_OPENNI_QVGA_30HZ );
+                break;
+            case 4:
+                modeRes = capture.set( CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE, CAP_OPENNI_QVGA_60HZ );
+                break;
+            default:
+                CV_Error( Error::StsBadArg, "Unsupported image mode property.\n");
+        }
+        if (!modeRes)
+            cout << "\nThis image mode is not supported by the device, the default value (CV_CAP_OPENNI_SXGA_15HZ) will be used.\n" << endl;
+    }
+
+    // turn on depth, color and IR if needed
+    if (retrievedImageFlags[0] || retrievedImageFlags[1] || retrievedImageFlags[2])
+        capture.set(CAP_OPENNI_DEPTH_GENERATOR_PRESENT, true);
+    else
+        capture.set(CAP_OPENNI_DEPTH_GENERATOR_PRESENT, false);
+    if (retrievedImageFlags[3] || retrievedImageFlags[4])
+        capture.set(CAP_OPENNI_IMAGE_GENERATOR_PRESENT, true);
+    else
+        capture.set(CAP_OPENNI_IMAGE_GENERATOR_PRESENT, false);
+    if (retrievedImageFlags[5])
+        capture.set(CAP_OPENNI_IR_GENERATOR_PRESENT, true);
+    else
+        capture.set(CAP_OPENNI_IR_GENERATOR_PRESENT, false);
+
+    // Print some available device settings.
+    if (capture.get(CAP_OPENNI_DEPTH_GENERATOR_PRESENT))
+    {
+        cout << "\nDepth generator output mode:" << endl <<
+            "FRAME_WIDTH      " << capture.get(CAP_PROP_FRAME_WIDTH) << endl <<
+            "FRAME_HEIGHT     " << capture.get(CAP_PROP_FRAME_HEIGHT) << endl <<
+            "FRAME_MAX_DEPTH  " << capture.get(CAP_PROP_OPENNI_FRAME_MAX_DEPTH) << " mm" << endl <<
+            "FPS              " << capture.get(CAP_PROP_FPS) << endl <<
+            "REGISTRATION     " << capture.get(CAP_PROP_OPENNI_REGISTRATION) << endl;
+    }
+    else
+    {
+        cout << "\nDevice doesn't contain depth generator or it is not selected." << endl;
+    }
+
+    if( capture.get( CAP_OPENNI_IMAGE_GENERATOR_PRESENT ) )
+    {
+        cout <<
+            "\nImage generator output mode:" << endl <<
+            "FRAME_WIDTH   " << capture.get( CAP_OPENNI_IMAGE_GENERATOR+CAP_PROP_FRAME_WIDTH ) << endl <<
+            "FRAME_HEIGHT  " << capture.get( CAP_OPENNI_IMAGE_GENERATOR+CAP_PROP_FRAME_HEIGHT ) << endl <<
+            "FPS           " << capture.get( CAP_OPENNI_IMAGE_GENERATOR+CAP_PROP_FPS ) << endl;
+    }
+    else
+    {
+        cout << "\nDevice doesn't contain image generator or it is not selected." << endl;
+    }
+
+    if( capture.get(CAP_OPENNI_IR_GENERATOR_PRESENT) )
+    {
+        cout <<
+            "\nIR generator output mode:" << endl <<
+            "FRAME_WIDTH   " << capture.get(CAP_OPENNI_IR_GENERATOR + CAP_PROP_FRAME_WIDTH) << endl <<
+            "FRAME_HEIGHT  " << capture.get(CAP_OPENNI_IR_GENERATOR + CAP_PROP_FRAME_HEIGHT) << endl <<
+            "FPS           " << capture.get(CAP_OPENNI_IR_GENERATOR + CAP_PROP_FPS) << endl;
+    }
+    else
+    {
+        cout << "\nDevice doesn't contain IR generator or it is not selected." << endl;
+    }
+
+    for(;;)
+    {
+        Mat depthMap;
+        Mat validDepthMap;
+        Mat disparityMap;
+        Mat bgrImage;
+        Mat grayImage;
+        Mat irImage;
+
+        if( !capture.grab() )
+        {
+            cout << "Can not grab images." << endl;
+            return -1;
+        }
+        else
+        {
+            if( retrievedImageFlags[0] && capture.retrieve( depthMap, CAP_OPENNI_DEPTH_MAP ) )
+            {
+                const float scaleFactor = 0.05f;
+                Mat show; depthMap.convertTo( show, CV_8UC1, scaleFactor );
+                imshow( "depth map", show );
+            }
+
+            if( retrievedImageFlags[1] && capture.retrieve( disparityMap, CAP_OPENNI_DISPARITY_MAP ) )
+            {
+                if( isColorizeDisp )
+                {
+                    Mat colorDisparityMap;
+                    colorizeDisparity( disparityMap, colorDisparityMap, isFixedMaxDisp ? getMaxDisparity(capture) : -1 );
+                    Mat validColorDisparityMap;
+                    colorDisparityMap.copyTo( validColorDisparityMap, disparityMap != 0 );
+                    imshow( "colorized disparity map", validColorDisparityMap );
+                }
+                else
+                {
+                    imshow( "original disparity map", disparityMap );
+                }
+            }
+
+            if( retrievedImageFlags[2] && capture.retrieve( validDepthMap, CAP_OPENNI_VALID_DEPTH_MASK ) )
+                imshow( "valid depth mask", validDepthMap );
+
+            if( retrievedImageFlags[3] && capture.retrieve( bgrImage, CAP_OPENNI_BGR_IMAGE ) )
+                imshow( "rgb image", bgrImage );
+
+            if( retrievedImageFlags[4] && capture.retrieve( grayImage, CAP_OPENNI_GRAY_IMAGE ) )
+                imshow( "gray image", grayImage );
+
+            if( retrievedImageFlags[5] && capture.retrieve( irImage, CAP_OPENNI_IR_IMAGE ) )
+            {
+                Mat ir8;
+                irImage.convertTo(ir8, CV_8U, 256.0 / 3500, 0.0);
+                imshow("IR image", ir8);
+            }
+        }
+
+        if( waitKey( 30 ) >= 0 )
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_realsense.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_realsense.cpp
new file mode 100644
index 00000000..352353eb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_realsense.cpp
@@ -0,0 +1,33 @@
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+using namespace cv;
+using namespace std;
+
+int main()
+{
+   VideoCapture capture(CAP_INTELPERC);
+   for(;;)
+   {
+      Mat depthMap;
+      Mat image;
+      Mat irImage;
+      Mat adjMap;
+
+      capture.grab();
+      capture.retrieve(depthMap,CAP_INTELPERC_DEPTH_MAP);
+      capture.retrieve(image,CAP_INTELPERC_IMAGE);
+      capture.retrieve(irImage,CAP_INTELPERC_IR_MAP);
+
+      normalize(depthMap, adjMap, 0, 255, NORM_MINMAX, CV_8UC1);
+      applyColorMap(adjMap, adjMap, COLORMAP_JET);
+
+      imshow("RGB", image);
+      imshow("IR", irImage);
+      imshow("DEPTH", adjMap);
+      if( waitKey( 30 ) >= 0 )
+         break;
+   }
+   return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videocapture_starter.cpp b/C++/opencv-4.7.0/samples/cpp/videocapture_starter.cpp
new file mode 100644
index 00000000..8e531043
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videocapture_starter.cpp
@@ -0,0 +1,93 @@
+/**
+* @file videocapture_starter.cpp
+* @brief A starter sample for using OpenCV VideoCapture with capture devices, video files or image sequences
+* easy as CV_PI right?
+*
+*  Created on: Nov 23, 2010
+*      Author: Ethan Rublee
+*
+*  Modified on: April 17, 2013
+*      Author: Kevin Hughes
+*/
+
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+using namespace std;
+
+//hide the local functions in an anon namespace
+namespace {
+    void help(char** av) {
+        cout << "The program captures frames from a video file, image sequence (01.jpg, 02.jpg ... 10.jpg) or camera connected to your computer." << endl
+             << "Usage:\n" << av[0] << " <video file, image sequence or device number>" << endl
+             << "q,Q,esc -- quit" << endl
+             << "space   -- save frame" << endl << endl
+             << "\tTo capture from a camera pass the device number. To find the device number, try ls /dev/video*" << endl
+             << "\texample: " << av[0] << " 0" << endl
+             << "\tYou may also pass a video file instead of a device number" << endl
+             << "\texample: " << av[0] << " video.avi" << endl
+             << "\tYou can also pass the path to an image sequence and OpenCV will treat the sequence just like a video." << endl
+             << "\texample: " << av[0] << " right%%02d.jpg" << endl;
+    }
+
+    int process(VideoCapture& capture) {
+        int n = 0;
+        char filename[200];
+        string window_name = "video | q or esc to quit";
+        cout << "press space to save a picture. q or esc to quit" << endl;
+        namedWindow(window_name, WINDOW_KEEPRATIO); //resizable window;
+        Mat frame;
+
+        for (;;) {
+            capture >> frame;
+            if (frame.empty())
+                break;
+
+            imshow(window_name, frame);
+            char key = (char)waitKey(30); //delay N millis, usually long enough to display and capture input
+
+            switch (key) {
+            case 'q':
+            case 'Q':
+            case 27: //escape key
+                return 0;
+            case ' ': //Save an image
+                snprintf(filename,sizeof(filename),"filename%.3d.jpg",n++);
+                imwrite(filename,frame);
+                cout << "Saved " << filename << endl;
+                break;
+            default:
+                break;
+            }
+        }
+        return 0;
+    }
+}
+
+int main(int ac, char** av) {
+    cv::CommandLineParser parser(ac, av, "{help h||}{@input||}");
+    if (parser.has("help"))
+    {
+        help(av);
+        return 0;
+    }
+    std::string arg = parser.get<std::string>("@input");
+    if (arg.empty()) {
+        help(av);
+        return 1;
+    }
+    VideoCapture capture(arg); //try to open string, this will attempt to open it as a video file or image sequence
+    if (!capture.isOpened()) //if this fails, try to open as a video camera, through the use of an integer param
+        capture.open(atoi(arg.c_str()));
+    if (!capture.isOpened()) {
+        cerr << "Failed to open the video device, video file or image sequence!\n" << endl;
+        help(av);
+        return 1;
+    }
+    return process(capture);
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/videowriter_basic.cpp b/C++/opencv-4.7.0/samples/cpp/videowriter_basic.cpp
new file mode 100644
index 00000000..3bfc08a2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/videowriter_basic.cpp
@@ -0,0 +1,67 @@
+/**
+  @file videowriter_basic.cpp
+  @brief A very basic sample for using VideoWriter and VideoCapture
+  @author PkLab.net
+  @date Aug 24, 2016
+*/
+
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+using namespace std;
+
+int main(int, char**)
+{
+    Mat src;
+    // use default camera as video source
+    VideoCapture cap(0);
+    // check if we succeeded
+    if (!cap.isOpened()) {
+        cerr << "ERROR! Unable to open camera\n";
+        return -1;
+    }
+    // get one frame from camera to know frame size and type
+    cap >> src;
+    // check if we succeeded
+    if (src.empty()) {
+        cerr << "ERROR! blank frame grabbed\n";
+        return -1;
+    }
+    bool isColor = (src.type() == CV_8UC3);
+
+    //--- INITIALIZE VIDEOWRITER
+    VideoWriter writer;
+    int codec = VideoWriter::fourcc('M', 'J', 'P', 'G');  // select desired codec (must be available at runtime)
+    double fps = 25.0;                          // framerate of the created video stream
+    string filename = "./live.avi";             // name of the output video file
+    writer.open(filename, codec, fps, src.size(), isColor);
+    // check if we succeeded
+    if (!writer.isOpened()) {
+        cerr << "Could not open the output video file for write\n";
+        return -1;
+    }
+
+    //--- GRAB AND WRITE LOOP
+    cout << "Writing videofile: " << filename << endl
+         << "Press any key to terminate" << endl;
+    for (;;)
+    {
+        // check if we succeeded
+        if (!cap.read(src)) {
+            cerr << "ERROR! blank frame grabbed\n";
+            break;
+        }
+        // encode the frame into the videofile stream
+        writer.write(src);
+        // show live and wait for a key with timeout long enough to show images
+        imshow("Live", src);
+        if (waitKey(5) >= 0)
+            break;
+    }
+    // the videofile will be closed and released automatically in VideoWriter destructor
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/warpPerspective_demo.cpp b/C++/opencv-4.7.0/samples/cpp/warpPerspective_demo.cpp
new file mode 100644
index 00000000..947abd43
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/warpPerspective_demo.cpp
@@ -0,0 +1,186 @@
+/**
+@file warpPerspective_demo.cpp
+@brief a demo program shows how perspective transformation applied on an image
+@based on a sample code http://study.marearts.com/2015/03/image-warping-using-opencv.html
+@modified by Suleyman TURKMEN
+*/
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static void help(char** argv)
+{
+    // print a welcome message, and the OpenCV version
+    cout << "\nThis is a demo program shows how perspective transformation applied on an image, \n"
+         "Using OpenCV version " << CV_VERSION << endl;
+
+    cout << "\nUsage:\n" << argv[0] << " [image_name -- Default right.jpg]\n" << endl;
+
+    cout << "\nHot keys: \n"
+         "\tESC, q - quit the program\n"
+         "\tr - change order of points to rotate transformation\n"
+         "\tc - delete selected points\n"
+         "\ti - change order of points to inverse transformation \n"
+         "\nUse your mouse to select a point and move it to see transformation changes" << endl;
+}
+
+static void onMouse(int event, int x, int y, int, void*);
+Mat warping(Mat image, Size warped_image_size, vector< Point2f> srcPoints, vector< Point2f> dstPoints);
+
+String windowTitle = "Perspective Transformation Demo";
+String labels[4] = { "TL","TR","BR","BL" };
+vector< Point2f> roi_corners;
+vector< Point2f> midpoints(4);
+vector< Point2f> dst_corners(4);
+int roiIndex = 0;
+bool dragging;
+int selected_corner_index = 0;
+bool validation_needed = true;
+
+int main(int argc, char** argv)
+{
+    help(argv);
+    CommandLineParser parser(argc, argv, "{@input| right.jpg |}");
+
+    string filename = samples::findFile(parser.get<string>("@input"));
+    Mat original_image = imread( filename );
+    Mat image;
+
+    float original_image_cols = (float)original_image.cols;
+    float original_image_rows = (float)original_image.rows;
+    roi_corners.push_back(Point2f( (float)(original_image_cols / 1.70), (float)(original_image_rows / 4.20) ));
+    roi_corners.push_back(Point2f( (float)(original_image.cols / 1.15), (float)(original_image.rows / 3.32) ));
+    roi_corners.push_back(Point2f( (float)(original_image.cols / 1.33), (float)(original_image.rows / 1.10) ));
+    roi_corners.push_back(Point2f( (float)(original_image.cols / 1.93), (float)(original_image.rows / 1.36) ));
+
+    namedWindow(windowTitle, WINDOW_NORMAL);
+    namedWindow("Warped Image", WINDOW_AUTOSIZE);
+    moveWindow("Warped Image", 20, 20);
+    moveWindow(windowTitle, 330, 20);
+
+    setMouseCallback(windowTitle, onMouse, 0);
+
+    bool endProgram = false;
+    while (!endProgram)
+    {
+        if ( validation_needed & (roi_corners.size() < 4) )
+        {
+            validation_needed = false;
+            image = original_image.clone();
+
+            for (size_t i = 0; i < roi_corners.size(); ++i)
+            {
+                circle( image, roi_corners[i], 5, Scalar(0, 255, 0), 3 );
+
+                if( i > 0 )
+                {
+                    line(image, roi_corners[i-1], roi_corners[(i)], Scalar(0, 0, 255), 2);
+                    circle(image, roi_corners[i], 5, Scalar(0, 255, 0), 3);
+                    putText(image, labels[i].c_str(), roi_corners[i], FONT_HERSHEY_SIMPLEX, 0.8, Scalar(255, 0, 0), 2);
+                }
+            }
+            imshow( windowTitle, image );
+        }
+
+        if ( validation_needed & ( roi_corners.size() == 4 ))
+        {
+            image = original_image.clone();
+            for ( int i = 0; i < 4; ++i )
+            {
+                line(image, roi_corners[i], roi_corners[(i + 1) % 4], Scalar(0, 0, 255), 2);
+                circle(image, roi_corners[i], 5, Scalar(0, 255, 0), 3);
+                putText(image, labels[i].c_str(), roi_corners[i], FONT_HERSHEY_SIMPLEX, 0.8, Scalar(255, 0, 0), 2);
+            }
+
+            imshow( windowTitle, image );
+
+            midpoints[0] = (roi_corners[0] + roi_corners[1]) / 2;
+            midpoints[1] = (roi_corners[1] + roi_corners[2]) / 2;
+            midpoints[2] = (roi_corners[2] + roi_corners[3]) / 2;
+            midpoints[3] = (roi_corners[3] + roi_corners[0]) / 2;
+
+            dst_corners[0].x = 0;
+            dst_corners[0].y = 0;
+            dst_corners[1].x = (float)norm(midpoints[1] - midpoints[3]);
+            dst_corners[1].y = 0;
+            dst_corners[2].x = dst_corners[1].x;
+            dst_corners[2].y = (float)norm(midpoints[0] - midpoints[2]);
+            dst_corners[3].x = 0;
+            dst_corners[3].y = dst_corners[2].y;
+
+            Size warped_image_size = Size(cvRound(dst_corners[2].x), cvRound(dst_corners[2].y));
+
+            Mat M = getPerspectiveTransform(roi_corners, dst_corners);
+
+            Mat warped_image;
+            warpPerspective(original_image, warped_image, M, warped_image_size); // do perspective transformation
+
+            imshow("Warped Image", warped_image);
+        }
+
+        char c = (char)waitKey( 10 );
+
+        if ((c == 'q') | (c == 'Q') | (c == 27))
+        {
+            endProgram = true;
+        }
+
+        if ((c == 'c') | (c == 'C'))
+        {
+            roi_corners.clear();
+        }
+
+        if ((c == 'r') | (c == 'R'))
+        {
+            roi_corners.push_back(roi_corners[0]);
+            roi_corners.erase(roi_corners.begin());
+        }
+
+        if ((c == 'i') | (c == 'I'))
+        {
+            swap(roi_corners[0], roi_corners[1]);
+            swap(roi_corners[2], roi_corners[3]);
+        }
+    }
+    return 0;
+}
+
+static void onMouse(int event, int x, int y, int, void*)
+{
+    // Action when left button is pressed
+    if (roi_corners.size() == 4)
+    {
+        for (int i = 0; i < 4; ++i)
+        {
+            if ((event == EVENT_LBUTTONDOWN) & ((abs(roi_corners[i].x - x) < 10)) & (abs(roi_corners[i].y - y) < 10))
+            {
+                selected_corner_index = i;
+                dragging = true;
+            }
+        }
+    }
+    else if ( event == EVENT_LBUTTONDOWN )
+    {
+        roi_corners.push_back( Point2f( (float) x, (float) y ) );
+        validation_needed = true;
+    }
+
+    // Action when left button is released
+    if (event == EVENT_LBUTTONUP)
+    {
+        dragging = false;
+    }
+
+    // Action when left button is pressed and mouse has moved over the window
+    if ((event == EVENT_MOUSEMOVE) && dragging)
+    {
+        roi_corners[selected_corner_index].x = (float) x;
+        roi_corners[selected_corner_index].y = (float) y;
+        validation_needed = true;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/cpp/watershed.cpp b/C++/opencv-4.7.0/samples/cpp/watershed.cpp
new file mode 100644
index 00000000..9c48ae0e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/cpp/watershed.cpp
@@ -0,0 +1,144 @@
+#include <opencv2/core/utility.hpp>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <cstdio>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help(char** argv)
+{
+    cout << "\nThis program demonstrates the famous watershed segmentation algorithm in OpenCV: watershed()\n"
+            "Usage:\n" << argv[0] <<" [image_name -- default is fruits.jpg]\n" << endl;
+
+
+    cout << "Hot keys: \n"
+        "\tESC - quit the program\n"
+        "\tr - restore the original image\n"
+        "\tw or SPACE - run watershed segmentation algorithm\n"
+        "\t\t(before running it, *roughly* mark the areas to segment on the image)\n"
+        "\t  (before that, roughly outline several markers on the image)\n";
+}
+Mat markerMask, img;
+Point prevPt(-1, -1);
+
+static void onMouse( int event, int x, int y, int flags, void* )
+{
+    if( x < 0 || x >= img.cols || y < 0 || y >= img.rows )
+        return;
+    if( event == EVENT_LBUTTONUP || !(flags & EVENT_FLAG_LBUTTON) )
+        prevPt = Point(-1,-1);
+    else if( event == EVENT_LBUTTONDOWN )
+        prevPt = Point(x,y);
+    else if( event == EVENT_MOUSEMOVE && (flags & EVENT_FLAG_LBUTTON) )
+    {
+        Point pt(x, y);
+        if( prevPt.x < 0 )
+            prevPt = pt;
+        line( markerMask, prevPt, pt, Scalar::all(255), 5, 8, 0 );
+        line( img, prevPt, pt, Scalar::all(255), 5, 8, 0 );
+        prevPt = pt;
+        imshow("image", img);
+    }
+}
+
+int main( int argc, char** argv )
+{
+    cv::CommandLineParser parser(argc, argv, "{help h | | }{ @input | fruits.jpg | }");
+    if (parser.has("help"))
+    {
+        help(argv);
+        return 0;
+    }
+    string filename = samples::findFile(parser.get<string>("@input"));
+    Mat img0 = imread(filename, 1), imgGray;
+
+    if( img0.empty() )
+    {
+        cout << "Couldn't open image ";
+        help(argv);
+        return 0;
+    }
+    help(argv);
+    namedWindow( "image", 1 );
+
+    img0.copyTo(img);
+    cvtColor(img, markerMask, COLOR_BGR2GRAY);
+    cvtColor(markerMask, imgGray, COLOR_GRAY2BGR);
+    markerMask = Scalar::all(0);
+    imshow( "image", img );
+    setMouseCallback( "image", onMouse, 0 );
+
+    for(;;)
+    {
+        char c = (char)waitKey(0);
+
+        if( c == 27 )
+            break;
+
+        if( c == 'r' )
+        {
+            markerMask = Scalar::all(0);
+            img0.copyTo(img);
+            imshow( "image", img );
+        }
+
+        if( c == 'w' || c == ' ' )
+        {
+            int i, j, compCount = 0;
+            vector<vector<Point> > contours;
+            vector<Vec4i> hierarchy;
+
+            findContours(markerMask, contours, hierarchy, RETR_CCOMP, CHAIN_APPROX_SIMPLE);
+
+            if( contours.empty() )
+                continue;
+            Mat markers(markerMask.size(), CV_32S);
+            markers = Scalar::all(0);
+            int idx = 0;
+            for( ; idx >= 0; idx = hierarchy[idx][0], compCount++ )
+                drawContours(markers, contours, idx, Scalar::all(compCount+1), -1, 8, hierarchy, INT_MAX);
+
+            if( compCount == 0 )
+                continue;
+
+            vector<Vec3b> colorTab;
+            for( i = 0; i < compCount; i++ )
+            {
+                int b = theRNG().uniform(0, 255);
+                int g = theRNG().uniform(0, 255);
+                int r = theRNG().uniform(0, 255);
+
+                colorTab.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
+            }
+
+            double t = (double)getTickCount();
+            watershed( img0, markers );
+            t = (double)getTickCount() - t;
+            printf( "execution time = %gms\n", t*1000./getTickFrequency() );
+
+            Mat wshed(markers.size(), CV_8UC3);
+
+            // paint the watershed image
+            for( i = 0; i < markers.rows; i++ )
+                for( j = 0; j < markers.cols; j++ )
+                {
+                    int index = markers.at<int>(i,j);
+                    if( index == -1 )
+                        wshed.at<Vec3b>(i,j) = Vec3b(255,255,255);
+                    else if( index <= 0 || index > compCount )
+                        wshed.at<Vec3b>(i,j) = Vec3b(0,0,0);
+                    else
+                        wshed.at<Vec3b>(i,j) = colorTab[index - 1];
+                }
+
+            wshed = wshed*0.5 + imgGray*0.5;
+            imshow( "watershed transform", wshed );
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/data/Blender_Suzanne1.jpg b/C++/opencv-4.7.0/samples/data/Blender_Suzanne1.jpg
new file mode 100644
index 00000000..e4f370ea
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/Blender_Suzanne1.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/Blender_Suzanne2.jpg b/C++/opencv-4.7.0/samples/data/Blender_Suzanne2.jpg
new file mode 100644
index 00000000..ff665ebe
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/Blender_Suzanne2.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/H1to3p.xml b/C++/opencv-4.7.0/samples/data/H1to3p.xml
new file mode 100644
index 00000000..d8b70878
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/H1to3p.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<opencv_storage>
+<H13 type_id="opencv-matrix">
+  <rows>3</rows>
+  <cols>3</cols>
+  <dt>d</dt>
+  <data>
+	7.6285898e-01  -2.9922929e-01   2.2567123e+02
+	3.3443473e-01   1.0143901e+00  -7.6999973e+01
+	3.4663091e-04  -1.4364524e-05   1.0000000e+00 </data></H13>
+</opencv_storage>
diff --git a/C++/opencv-4.7.0/samples/data/HappyFish.jpg b/C++/opencv-4.7.0/samples/data/HappyFish.jpg
new file mode 100644
index 00000000..c76288ed
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/HappyFish.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/LinuxLogo.jpg b/C++/opencv-4.7.0/samples/data/LinuxLogo.jpg
new file mode 100644
index 00000000..34cba886
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/LinuxLogo.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/Megamind.avi b/C++/opencv-4.7.0/samples/data/Megamind.avi
new file mode 100644
index 00000000..86351eb0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/Megamind.avi differ
diff --git a/C++/opencv-4.7.0/samples/data/Megamind_bugy.avi b/C++/opencv-4.7.0/samples/data/Megamind_bugy.avi
new file mode 100644
index 00000000..67ab6bec
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/Megamind_bugy.avi differ
diff --git a/C++/opencv-4.7.0/samples/data/WindowsLogo.jpg b/C++/opencv-4.7.0/samples/data/WindowsLogo.jpg
new file mode 100644
index 00000000..04be4492
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/WindowsLogo.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/aero1.jpg b/C++/opencv-4.7.0/samples/data/aero1.jpg
new file mode 100644
index 00000000..a7249e48
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/aero1.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/aero3.jpg b/C++/opencv-4.7.0/samples/data/aero3.jpg
new file mode 100644
index 00000000..3c2a99e2
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/aero3.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/aloeGT.png b/C++/opencv-4.7.0/samples/data/aloeGT.png
new file mode 100644
index 00000000..43e62ebf
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/aloeGT.png differ
diff --git a/C++/opencv-4.7.0/samples/data/aloeL.jpg b/C++/opencv-4.7.0/samples/data/aloeL.jpg
new file mode 100644
index 00000000..4c192768
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/aloeL.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/aloeR.jpg b/C++/opencv-4.7.0/samples/data/aloeR.jpg
new file mode 100644
index 00000000..7ecdf489
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/aloeR.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/alphabet_36.txt b/C++/opencv-4.7.0/samples/data/alphabet_36.txt
new file mode 100644
index 00000000..71043689
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/alphabet_36.txt
@@ -0,0 +1,36 @@
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+a
+b
+c
+d
+e
+f
+g
+h
+i
+j
+k
+l
+m
+n
+o
+p
+q
+r
+s
+t
+u
+v
+w
+x
+y
+z
diff --git a/C++/opencv-4.7.0/samples/data/alphabet_94.txt b/C++/opencv-4.7.0/samples/data/alphabet_94.txt
new file mode 100644
index 00000000..87c6d678
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/alphabet_94.txt
@@ -0,0 +1,94 @@
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+a
+b
+c
+d
+e
+f
+g
+h
+i
+j
+k
+l
+m
+n
+o
+p
+q
+r
+s
+t
+u
+v
+w
+x
+y
+z
+A
+B
+C
+D
+E
+F
+G
+H
+I
+J
+K
+L
+M
+N
+O
+P
+Q
+R
+S
+T
+U
+V
+W
+X
+Y
+Z
+!
+"
+#
+$
+%
+&
+'
+(
+)
+*
++
+,
+-
+.
+/
+:
+;
+<
+=
+>
+?
+@
+[
+\
+]
+^
+_
+`
+{
+|
+}
+~
diff --git a/C++/opencv-4.7.0/samples/data/apple.jpg b/C++/opencv-4.7.0/samples/data/apple.jpg
new file mode 100644
index 00000000..2ff27ee0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/apple.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/baboon.jpg b/C++/opencv-4.7.0/samples/data/baboon.jpg
new file mode 100644
index 00000000..2f98d835
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/baboon.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/basketball1.png b/C++/opencv-4.7.0/samples/data/basketball1.png
new file mode 100644
index 00000000..53b2dbaa
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/basketball1.png differ
diff --git a/C++/opencv-4.7.0/samples/data/basketball2.png b/C++/opencv-4.7.0/samples/data/basketball2.png
new file mode 100644
index 00000000..1d069b96
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/basketball2.png differ
diff --git a/C++/opencv-4.7.0/samples/data/blox.jpg b/C++/opencv-4.7.0/samples/data/blox.jpg
new file mode 100644
index 00000000..b682b2c0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/blox.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/board.jpg b/C++/opencv-4.7.0/samples/data/board.jpg
new file mode 100644
index 00000000..2e10e6fe
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/board.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/box.png b/C++/opencv-4.7.0/samples/data/box.png
new file mode 100644
index 00000000..6f01082f
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/box.png differ
diff --git a/C++/opencv-4.7.0/samples/data/box_in_scene.png b/C++/opencv-4.7.0/samples/data/box_in_scene.png
new file mode 100644
index 00000000..cff246a3
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/box_in_scene.png differ
diff --git a/C++/opencv-4.7.0/samples/data/building.jpg b/C++/opencv-4.7.0/samples/data/building.jpg
new file mode 100644
index 00000000..6056492f
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/building.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/butterfly.jpg b/C++/opencv-4.7.0/samples/data/butterfly.jpg
new file mode 100644
index 00000000..67d60f05
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/butterfly.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/calibration.yml b/C++/opencv-4.7.0/samples/data/calibration.yml
new file mode 100644
index 00000000..8d30f53e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/calibration.yml
@@ -0,0 +1,15 @@
+%YAML:1.0
+images:
+  - left01.jpg
+  - left02.jpg
+  - left03.jpg
+  - left04.jpg
+  - left05.jpg
+  - left06.jpg
+  - left07.jpg
+  - left08.jpg
+  - left09.jpg
+  - left11.jpg
+  - left12.jpg
+  - left13.jpg
+  - left14.jpg
diff --git a/C++/opencv-4.7.0/samples/data/cards.png b/C++/opencv-4.7.0/samples/data/cards.png
new file mode 100644
index 00000000..1e61d874
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/cards.png differ
diff --git a/C++/opencv-4.7.0/samples/data/chessboard.png b/C++/opencv-4.7.0/samples/data/chessboard.png
new file mode 100644
index 00000000..1f9112c3
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/chessboard.png differ
diff --git a/C++/opencv-4.7.0/samples/data/chicky_512.png b/C++/opencv-4.7.0/samples/data/chicky_512.png
new file mode 100644
index 00000000..746f8cc2
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/chicky_512.png differ
diff --git a/C++/opencv-4.7.0/samples/data/data01.xml b/C++/opencv-4.7.0/samples/data/data01.xml
new file mode 100644
index 00000000..d17167cc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/data01.xml
@@ -0,0 +1,58 @@
+<?xml version="1.0"?>
+<opencv_storage>
+<datamat type_id="opencv-matrix">
+  <rows>40</rows>
+  <cols>784</cols>
+  <dt>f</dt>
+  <data>
+    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 149 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 149 149 149 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 149 149 149 149 149 149 149 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 149 149 149 149 149 149 149 149 149 149 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 149 149 149 149 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+</data>
+</datamat>
+<labelsmat type_id="opencv-matrix">
+    <rows>40</rows>
+    <cols>1</cols>
+    <dt>d</dt>
+    <data>
+        0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
+    </data>
+</labelsmat>
+</opencv_storage>
diff --git a/C++/opencv-4.7.0/samples/data/detect_blob.png b/C++/opencv-4.7.0/samples/data/detect_blob.png
new file mode 100644
index 00000000..fe8537ab
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/detect_blob.png differ
diff --git a/C++/opencv-4.7.0/samples/data/digits.png b/C++/opencv-4.7.0/samples/data/digits.png
new file mode 100644
index 00000000..01cdd297
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/digits.png differ
diff --git a/C++/opencv-4.7.0/samples/data/dnn/action_recongnition_kinetics.txt b/C++/opencv-4.7.0/samples/data/dnn/action_recongnition_kinetics.txt
new file mode 100644
index 00000000..cdaafcb1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/dnn/action_recongnition_kinetics.txt
@@ -0,0 +1,400 @@
+abseiling
+air drumming
+answering questions
+applauding
+applying cream
+archery
+arm wrestling
+arranging flowers
+assembling computer
+auctioning
+baby waking up
+baking cookies
+balloon blowing
+bandaging
+barbequing
+bartending
+beatboxing
+bee keeping
+belly dancing
+bench pressing
+bending back
+bending metal
+biking through snow
+blasting sand
+blowing glass
+blowing leaves
+blowing nose
+blowing out candles
+bobsledding
+bookbinding
+bouncing on trampoline
+bowling
+braiding hair
+breading or breadcrumbing
+breakdancing
+brush painting
+brushing hair
+brushing teeth
+building cabinet
+building shed
+bungee jumping
+busking
+canoeing or kayaking
+capoeira
+carrying baby
+cartwheeling
+carving pumpkin
+catching fish
+catching or throwing baseball
+catching or throwing frisbee
+catching or throwing softball
+celebrating
+changing oil
+changing wheel
+checking tires
+cheerleading
+chopping wood
+clapping
+clay pottery making
+clean and jerk
+cleaning floor
+cleaning gutters
+cleaning pool
+cleaning shoes
+cleaning toilet
+cleaning windows
+climbing a rope
+climbing ladder
+climbing tree
+contact juggling
+cooking chicken
+cooking egg
+cooking on campfire
+cooking sausages
+counting money
+country line dancing
+cracking neck
+crawling baby
+crossing river
+crying
+curling hair
+cutting nails
+cutting pineapple
+cutting watermelon
+dancing ballet
+dancing charleston
+dancing gangnam style
+dancing macarena
+deadlifting
+decorating the christmas tree
+digging
+dining
+disc golfing
+diving cliff
+dodgeball
+doing aerobics
+doing laundry
+doing nails
+drawing
+dribbling basketball
+drinking
+drinking beer
+drinking shots
+driving car
+driving tractor
+drop kicking
+drumming fingers
+dunking basketball
+dying hair
+eating burger
+eating cake
+eating carrots
+eating chips
+eating doughnuts
+eating hotdog
+eating ice cream
+eating spaghetti
+eating watermelon
+egg hunting
+exercising arm
+exercising with an exercise ball
+extinguishing fire
+faceplanting
+feeding birds
+feeding fish
+feeding goats
+filling eyebrows
+finger snapping
+fixing hair
+flipping pancake
+flying kite
+folding clothes
+folding napkins
+folding paper
+front raises
+frying vegetables
+garbage collecting
+gargling
+getting a haircut
+getting a tattoo
+giving or receiving award
+golf chipping
+golf driving
+golf putting
+grinding meat
+grooming dog
+grooming horse
+gymnastics tumbling
+hammer throw
+headbanging
+headbutting
+high jump
+high kick
+hitting baseball
+hockey stop
+holding snake
+hopscotch
+hoverboarding
+hugging
+hula hooping
+hurdling
+hurling (sport)
+ice climbing
+ice fishing
+ice skating
+ironing
+javelin throw
+jetskiing
+jogging
+juggling balls
+juggling fire
+juggling soccer ball
+jumping into pool
+jumpstyle dancing
+kicking field goal
+kicking soccer ball
+kissing
+kitesurfing
+knitting
+krumping
+laughing
+laying bricks
+long jump
+lunge
+making a cake
+making a sandwich
+making bed
+making jewelry
+making pizza
+making snowman
+making sushi
+making tea
+marching
+massaging back
+massaging feet
+massaging legs
+massaging person's head
+milking cow
+mopping floor
+motorcycling
+moving furniture
+mowing lawn
+news anchoring
+opening bottle
+opening present
+paragliding
+parasailing
+parkour
+passing American football (in game)
+passing American football (not in game)
+peeling apples
+peeling potatoes
+petting animal (not cat)
+petting cat
+picking fruit
+planting trees
+plastering
+playing accordion
+playing badminton
+playing bagpipes
+playing basketball
+playing bass guitar
+playing cards
+playing cello
+playing chess
+playing clarinet
+playing controller
+playing cricket
+playing cymbals
+playing didgeridoo
+playing drums
+playing flute
+playing guitar
+playing harmonica
+playing harp
+playing ice hockey
+playing keyboard
+playing kickball
+playing monopoly
+playing organ
+playing paintball
+playing piano
+playing poker
+playing recorder
+playing saxophone
+playing squash or racquetball
+playing tennis
+playing trombone
+playing trumpet
+playing ukulele
+playing violin
+playing volleyball
+playing xylophone
+pole vault
+presenting weather forecast
+pull ups
+pumping fist
+pumping gas
+punching bag
+punching person (boxing)
+push up
+pushing car
+pushing cart
+pushing wheelchair
+reading book
+reading newspaper
+recording music
+riding a bike
+riding camel
+riding elephant
+riding mechanical bull
+riding mountain bike
+riding mule
+riding or walking with horse
+riding scooter
+riding unicycle
+ripping paper
+robot dancing
+rock climbing
+rock scissors paper
+roller skating
+running on treadmill
+sailing
+salsa dancing
+sanding floor
+scrambling eggs
+scuba diving
+setting table
+shaking hands
+shaking head
+sharpening knives
+sharpening pencil
+shaving head
+shaving legs
+shearing sheep
+shining shoes
+shooting basketball
+shooting goal (soccer)
+shot put
+shoveling snow
+shredding paper
+shuffling cards
+side kick
+sign language interpreting
+singing
+situp
+skateboarding
+ski jumping
+skiing (not slalom or crosscountry)
+skiing crosscountry
+skiing slalom
+skipping rope
+skydiving
+slacklining
+slapping
+sled dog racing
+smoking
+smoking hookah
+snatch weight lifting
+sneezing
+sniffing
+snorkeling
+snowboarding
+snowkiting
+snowmobiling
+somersaulting
+spinning poi
+spray painting
+spraying
+springboard diving
+squat
+sticking tongue out
+stomping grapes
+stretching arm
+stretching leg
+strumming guitar
+surfing crowd
+surfing water
+sweeping floor
+swimming backstroke
+swimming breast stroke
+swimming butterfly stroke
+swing dancing
+swinging legs
+swinging on something
+sword fighting
+tai chi
+taking a shower
+tango dancing
+tap dancing
+tapping guitar
+tapping pen
+tasting beer
+tasting food
+testifying
+texting
+throwing axe
+throwing ball
+throwing discus
+tickling
+tobogganing
+tossing coin
+tossing salad
+training dog
+trapezing
+trimming or shaving beard
+trimming trees
+triple jump
+tying bow tie
+tying knot (not on a tie)
+tying tie
+unboxing
+unloading truck
+using computer
+using remote controller (not gaming)
+using segway
+vault
+waiting in line
+walking the dog
+washing dishes
+washing feet
+washing hair
+washing hands
+water skiing
+water sliding
+watering plants
+waxing back
+waxing chest
+waxing eyebrows
+waxing legs
+weaving basket
+welding
+whistling
+windsurfing
+wrapping present
+wrestling
+writing
+yawning
+yoga
+zumba
diff --git a/C++/opencv-4.7.0/samples/data/dnn/classification_classes_ILSVRC2012.txt b/C++/opencv-4.7.0/samples/data/dnn/classification_classes_ILSVRC2012.txt
new file mode 100644
index 00000000..a509c007
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/dnn/classification_classes_ILSVRC2012.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/C++/opencv-4.7.0/samples/data/dnn/enet-classes.txt b/C++/opencv-4.7.0/samples/data/dnn/enet-classes.txt
new file mode 100644
index 00000000..1616563a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/dnn/enet-classes.txt
@@ -0,0 +1,20 @@
+Unlabeled
+Road
+Sidewalk
+Building
+Wall
+Fence
+Pole
+TrafficLight
+TrafficSign
+Vegetation
+Terrain
+Sky
+Person
+Rider
+Car
+Truck
+Bus
+Train
+Motorcycle
+Bicycle
diff --git a/C++/opencv-4.7.0/samples/data/dnn/object_detection_classes_coco.txt b/C++/opencv-4.7.0/samples/data/dnn/object_detection_classes_coco.txt
new file mode 100644
index 00000000..10ecf0b4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/dnn/object_detection_classes_coco.txt
@@ -0,0 +1,90 @@
+person
+bicycle
+car
+motorcycle
+airplane
+bus
+train
+truck
+boat
+traffic light
+fire hydrant
+street sign
+stop sign
+parking meter
+bench
+bird
+cat
+dog
+horse
+sheep
+cow
+elephant
+bear
+zebra
+giraffe
+hat
+backpack
+umbrella
+shoe
+eye glasses
+handbag
+tie
+suitcase
+frisbee
+skis
+snowboard
+sports ball
+kite
+baseball bat
+baseball glove
+skateboard
+surfboard
+tennis racket
+bottle
+plate
+wine glass
+cup
+fork
+knife
+spoon
+bowl
+banana
+apple
+sandwich
+orange
+broccoli
+carrot
+hot dog
+pizza
+donut
+cake
+chair
+couch
+potted plant
+bed
+mirror
+dining table
+window
+desk
+toilet
+door
+tv
+laptop
+mouse
+remote
+keyboard
+cell phone
+microwave
+oven
+toaster
+sink
+refrigerator
+blender
+book
+clock
+vase
+scissors
+teddy bear
+hair drier
+toothbrush
diff --git a/C++/opencv-4.7.0/samples/data/dnn/object_detection_classes_pascal_voc.txt b/C++/opencv-4.7.0/samples/data/dnn/object_detection_classes_pascal_voc.txt
new file mode 100644
index 00000000..8420ab35
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/dnn/object_detection_classes_pascal_voc.txt
@@ -0,0 +1,20 @@
+aeroplane
+bicycle
+bird
+boat
+bottle
+bus
+car
+cat
+chair
+cow
+diningtable
+dog
+horse
+motorbike
+person
+pottedplant
+sheep
+sofa
+train
+tvmonitor
diff --git a/C++/opencv-4.7.0/samples/data/dnn/object_detection_classes_yolov4.txt b/C++/opencv-4.7.0/samples/data/dnn/object_detection_classes_yolov4.txt
new file mode 100644
index 00000000..ca76c80b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/dnn/object_detection_classes_yolov4.txt
@@ -0,0 +1,80 @@
+person
+bicycle
+car
+motorbike
+aeroplane
+bus
+train
+truck
+boat
+traffic light
+fire hydrant
+stop sign
+parking meter
+bench
+bird
+cat
+dog
+horse
+sheep
+cow
+elephant
+bear
+zebra
+giraffe
+backpack
+umbrella
+handbag
+tie
+suitcase
+frisbee
+skis
+snowboard
+sports ball
+kite
+baseball bat
+baseball glove
+skateboard
+surfboard
+tennis racket
+bottle
+wine glass
+cup
+fork
+knife
+spoon
+bowl
+banana
+apple
+sandwich
+orange
+broccoli
+carrot
+hot dog
+pizza
+donut
+cake
+chair
+sofa
+pottedplant
+bed
+diningtable
+toilet
+tvmonitor
+laptop
+mouse
+remote
+keyboard
+cell phone
+microwave
+oven
+toaster
+sink
+refrigerator
+book
+clock
+vase
+scissors
+teddy bear
+hair drier
+toothbrush
diff --git a/C++/opencv-4.7.0/samples/data/ela_modified.jpg b/C++/opencv-4.7.0/samples/data/ela_modified.jpg
new file mode 100644
index 00000000..7b4be661
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/ela_modified.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/ela_original.jpg b/C++/opencv-4.7.0/samples/data/ela_original.jpg
new file mode 100644
index 00000000..6790ad47
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/ela_original.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/ellipses.jpg b/C++/opencv-4.7.0/samples/data/ellipses.jpg
new file mode 100644
index 00000000..def6f7b4
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/ellipses.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/essential_mat_data.txt b/C++/opencv-4.7.0/samples/data/essential_mat_data.txt
new file mode 100644
index 00000000..d2c5dc98
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/essential_mat_data.txt
@@ -0,0 +1,5 @@
+leuvenA.jpg
+leuvenB.jpg
+651.4462353114224 0 376.27522319223914
+0 653.7348054191838 280.1106539526218
+0 0 1
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/data/fruits.jpg b/C++/opencv-4.7.0/samples/data/fruits.jpg
new file mode 100644
index 00000000..a89b84a5
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/fruits.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/gradient.png b/C++/opencv-4.7.0/samples/data/gradient.png
new file mode 100644
index 00000000..255e77f9
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/gradient.png differ
diff --git a/C++/opencv-4.7.0/samples/data/graf1.png b/C++/opencv-4.7.0/samples/data/graf1.png
new file mode 100644
index 00000000..67e34731
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/graf1.png differ
diff --git a/C++/opencv-4.7.0/samples/data/graf3.png b/C++/opencv-4.7.0/samples/data/graf3.png
new file mode 100644
index 00000000..3bcc6093
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/graf3.png differ
diff --git a/C++/opencv-4.7.0/samples/data/home.jpg b/C++/opencv-4.7.0/samples/data/home.jpg
new file mode 100644
index 00000000..7528a7d7
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/home.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/imageTextN.png b/C++/opencv-4.7.0/samples/data/imageTextN.png
new file mode 100644
index 00000000..cdb58f65
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/imageTextN.png differ
diff --git a/C++/opencv-4.7.0/samples/data/imageTextR.png b/C++/opencv-4.7.0/samples/data/imageTextR.png
new file mode 100644
index 00000000..7f90abdf
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/imageTextR.png differ
diff --git a/C++/opencv-4.7.0/samples/data/intrinsics.yml b/C++/opencv-4.7.0/samples/data/intrinsics.yml
new file mode 100644
index 00000000..70c61518
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/intrinsics.yml
@@ -0,0 +1,23 @@
+%YAML:1.0
+M1: !!opencv-matrix
+   rows: 3
+   cols: 3
+   dt: d
+   data: [ 5.3480326845051309e+02, 0., 3.3568643204394891e+02, 0.,
+       5.3480326845051309e+02, 2.4066183054066337e+02, 0., 0., 1. ]
+D1: !!opencv-matrix
+   rows: 1
+   cols: 5
+   dt: d
+   data: [ 2.9589439552724328e-01, -1.0354662043042675e+00, 0., 0., 0. ]
+M2: !!opencv-matrix
+   rows: 3
+   cols: 3
+   dt: d
+   data: [ 5.3480326845051309e+02, 0., 3.3455744527912015e+02, 0.,
+       5.3480326845051309e+02, 2.4205324573376600e+02, 0., 0., 1. ]
+D2: !!opencv-matrix
+   rows: 1
+   cols: 5
+   dt: d
+   data: [ -1.6916358306948096e-01, -1.1214173641213163e-01, 0., 0., 0. ]
diff --git a/C++/opencv-4.7.0/samples/data/left.jpg b/C++/opencv-4.7.0/samples/data/left.jpg
new file mode 100644
index 00000000..f4c26303
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left01.jpg b/C++/opencv-4.7.0/samples/data/left01.jpg
new file mode 100644
index 00000000..6ade3200
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left01.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left02.jpg b/C++/opencv-4.7.0/samples/data/left02.jpg
new file mode 100644
index 00000000..457820e9
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left02.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left03.jpg b/C++/opencv-4.7.0/samples/data/left03.jpg
new file mode 100644
index 00000000..7f3990f4
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left03.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left04.jpg b/C++/opencv-4.7.0/samples/data/left04.jpg
new file mode 100644
index 00000000..3144a18f
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left04.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left05.jpg b/C++/opencv-4.7.0/samples/data/left05.jpg
new file mode 100644
index 00000000..7b571318
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left05.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left06.jpg b/C++/opencv-4.7.0/samples/data/left06.jpg
new file mode 100644
index 00000000..1c6a217c
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left06.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left07.jpg b/C++/opencv-4.7.0/samples/data/left07.jpg
new file mode 100644
index 00000000..46acbb9e
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left07.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left08.jpg b/C++/opencv-4.7.0/samples/data/left08.jpg
new file mode 100644
index 00000000..0fe76460
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left08.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left09.jpg b/C++/opencv-4.7.0/samples/data/left09.jpg
new file mode 100644
index 00000000..5d17e957
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left09.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left11.jpg b/C++/opencv-4.7.0/samples/data/left11.jpg
new file mode 100644
index 00000000..7ca2a147
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left11.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left12.jpg b/C++/opencv-4.7.0/samples/data/left12.jpg
new file mode 100644
index 00000000..897955d7
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left12.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left13.jpg b/C++/opencv-4.7.0/samples/data/left13.jpg
new file mode 100644
index 00000000..e2f060f2
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left13.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left14.jpg b/C++/opencv-4.7.0/samples/data/left14.jpg
new file mode 100644
index 00000000..1dec7c68
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/left14.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/left_intrinsics.yml b/C++/opencv-4.7.0/samples/data/left_intrinsics.yml
new file mode 100644
index 00000000..a90a02e9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/left_intrinsics.yml
@@ -0,0 +1,75 @@
+%YAML:1.0
+---
+nframes: 13
+image_width: 640
+image_height: 480
+board_width: 9
+board_height: 6
+square_size: 2.5000000372529030e-02
+aspectRatio: 1.
+flags: 2
+camera_matrix: !!opencv-matrix
+   rows: 3
+   cols: 3
+   dt: d
+   data: [ 5.3591573396163199e+02, 0., 3.4228315473308373e+02, 0.,
+       5.3591573396163199e+02, 2.3557082909788173e+02, 0., 0., 1. ]
+distortion_coefficients: !!opencv-matrix
+   rows: 5
+   cols: 1
+   dt: d
+   data: [ -2.6637260909660682e-01, -3.8588898922304653e-02,
+       1.7831947042852964e-03, -2.8122100441115472e-04,
+       2.3839153080878486e-01 ]
+avg_reprojection_error: 3.9259098975581364e-01
+per_view_reprojection_errors: !!opencv-matrix
+   rows: 13
+   cols: 1
+   dt: f
+   data: [ 1.92965463e-01, 1.18204820e+00, 1.73180386e-01,
+       1.93417311e-01, 1.59574091e-01, 1.79683909e-01, 2.30989486e-01,
+       2.41952404e-01, 2.96267658e-01, 1.67184874e-01, 2.02002615e-01,
+       3.81039530e-01, 1.74401343e-01 ]
+extrinsic_parameters: !!opencv-matrix
+   rows: 13
+   cols: 6
+   dt: d
+   data: [ 1.6866673097722978e-01, 2.7567195383689680e-01,
+       1.3463666677617407e-02, -7.5217911266918208e-02,
+       -1.0895943925991841e-01, 3.9970206949907272e-01,
+       4.1331287656496363e-01, 6.4989015618432178e-01,
+       -1.3371537960145106e+00, -5.8571677080547203e-02,
+       8.2925805670236566e-02, 3.5381014833230601e-01,
+       -2.7703695013795054e-01, 1.8693309320100124e-01,
+       3.5485225341087834e-01, -3.9846501015652937e-02,
+       -1.0041611109510440e-01, 3.1815947023777164e-01,
+       -1.1090615673109079e-01, 2.3965970843402720e-01,
+       -2.1135637810781923e-03, -9.8410654744228568e-02,
+       -6.7330010965873974e-02, 3.3085237266887146e-01,
+       -2.9186914919266310e-01, 4.2838824536930098e-01,
+       1.3127376448141377e+00, 5.8492717894568363e-02,
+       -1.1531702553211766e-01, 3.1718597226747441e-01,
+       4.0775746983982769e-01, 3.0372749654555553e-01,
+       1.6490540383167107e+00, 1.6727077792571535e-01,
+       -6.5571043573575183e-02, 3.3646131272177648e-01,
+       1.7933504280050525e-01, 3.4558984092172601e-01,
+       1.8685292421609112e+00, 1.9533408668697443e-02,
+       -7.1821904367276174e-02, 3.8942937075181105e-01,
+       -9.0969163793927624e-02, 4.7978599772080688e-01,
+       1.7534054022831906e+00, 7.9050417654120575e-02,
+       -8.7941963150599309e-02, 3.1666076957685929e-01,
+       2.0297932232462285e-01, -4.2392077549829726e-01,
+       1.3241327935810543e-01, -6.6346241810532544e-02,
+       -8.1019305580944570e-02, 2.7830224494208888e-01,
+       -4.1905731583840156e-01, -4.9969284527936553e-01,
+       1.3355787183928016e+00, 4.6902734761583582e-02,
+       -1.1100626108196045e-01, 3.3805630488128308e-01,
+       -2.3853178487346252e-01, 3.4785724405059820e-01,
+       1.5307655926865789e+00, 5.0764487316281588e-02,
+       -1.0259706994505384e-01, 3.2220131320183526e-01,
+       4.6395663682204152e-01, -2.8347019688901215e-01,
+       1.2385662249906069e+00, 3.3699309698414767e-02,
+       -9.1617248179872074e-02, 2.9144614839683858e-01,
+       -1.6997848268735108e-01, -4.7116903885245226e-01,
+       1.3459942250907577e+00, 4.5015523494596366e-02,
+       -1.0817857239600029e-01, 3.1243767202759759e-01 ]
diff --git a/C++/opencv-4.7.0/samples/data/lena.jpg b/C++/opencv-4.7.0/samples/data/lena.jpg
new file mode 100644
index 00000000..f06aa74a
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/lena.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/lena_tmpl.jpg b/C++/opencv-4.7.0/samples/data/lena_tmpl.jpg
new file mode 100644
index 00000000..0c9fc20d
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/lena_tmpl.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/letter-recognition.data b/C++/opencv-4.7.0/samples/data/letter-recognition.data
new file mode 100644
index 00000000..4dfa6f01
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/letter-recognition.data
@@ -0,0 +1,20000 @@
+T,2,8,3,5,1,8,13,0,6,6,10,8,0,8,0,8
+I,5,12,3,7,2,10,5,5,4,13,3,9,2,8,4,10
+D,4,11,6,8,6,10,6,2,6,10,3,7,3,7,3,9
+N,7,11,6,6,3,5,9,4,6,4,4,10,6,10,2,8
+G,2,1,3,1,1,8,6,6,6,6,5,9,1,7,5,10
+S,4,11,5,8,3,8,8,6,9,5,6,6,0,8,9,7
+B,4,2,5,4,4,8,7,6,6,7,6,6,2,8,7,10
+A,1,1,3,2,1,8,2,2,2,8,2,8,1,6,2,7
+J,2,2,4,4,2,10,6,2,6,12,4,8,1,6,1,7
+M,11,15,13,9,7,13,2,6,2,12,1,9,8,1,1,8
+X,3,9,5,7,4,8,7,3,8,5,6,8,2,8,6,7
+O,6,13,4,7,4,6,7,6,3,10,7,9,5,9,5,8
+G,4,9,6,7,6,7,8,6,2,6,5,11,4,8,7,8
+M,6,9,8,6,9,7,8,6,5,7,5,8,8,9,8,6
+R,5,9,5,7,6,6,11,7,3,7,3,9,2,7,5,11
+F,6,9,5,4,3,10,6,3,5,10,5,7,3,9,6,9
+O,3,4,4,3,2,8,7,7,5,7,6,8,2,8,3,8
+C,7,10,5,5,2,6,8,6,8,11,7,11,2,8,5,9
+T,6,11,6,8,5,6,11,5,6,11,9,4,3,12,2,4
+J,2,2,3,3,1,10,6,3,6,12,4,9,0,7,1,7
+J,1,3,2,2,1,8,8,2,5,14,5,8,0,7,0,7
+H,4,5,5,4,4,7,7,6,6,7,6,8,3,8,3,8
+S,3,2,3,3,2,8,8,7,5,7,5,7,2,8,9,8
+O,6,11,7,8,5,7,6,9,6,7,5,9,4,8,5,5
+J,3,6,4,4,2,6,6,4,4,14,8,12,1,6,1,6
+C,6,11,7,8,3,7,8,7,11,4,7,14,1,7,4,8
+M,7,11,11,8,9,3,8,4,5,10,11,10,10,9,5,7
+W,12,14,12,8,5,9,10,4,3,5,10,7,10,12,2,6
+H,6,9,8,7,6,8,6,6,7,7,7,9,6,8,4,8
+G,3,6,4,4,2,6,6,5,5,6,6,9,2,8,4,8
+L,2,3,3,4,1,0,1,5,6,0,0,6,0,8,0,8
+L,1,3,3,1,1,6,4,1,7,8,3,10,0,7,2,9
+X,8,12,8,6,4,3,10,4,7,12,11,9,3,7,3,4
+B,5,9,7,7,10,9,8,4,4,6,8,6,6,11,8,7
+M,6,9,9,7,6,5,6,3,5,10,9,9,8,5,2,7
+G,4,7,6,5,3,6,6,6,8,6,5,9,3,10,4,8
+O,4,7,5,5,3,7,7,8,6,7,6,8,3,8,3,8
+P,3,6,4,4,2,4,14,8,1,11,6,3,0,10,4,8
+G,4,9,5,6,6,8,5,4,3,7,5,11,6,8,5,11
+E,3,4,3,6,2,3,8,6,10,7,6,15,0,8,7,8
+X,5,11,8,8,4,8,8,1,8,10,5,7,3,8,4,8
+E,3,7,4,5,4,7,7,5,8,8,8,9,3,9,6,9
+X,4,6,7,4,3,9,7,2,8,11,3,7,3,8,4,9
+G,4,5,5,8,3,7,6,8,8,6,6,10,1,8,6,11
+V,7,9,6,5,2,8,10,4,5,8,10,5,4,12,3,8
+X,4,10,5,7,5,8,7,3,8,5,6,6,3,8,6,8
+W,5,9,6,7,8,7,9,5,3,7,9,8,6,8,3,8
+G,1,3,2,1,1,7,7,5,6,7,5,10,1,9,3,9
+R,8,10,8,6,6,7,7,3,5,8,4,8,6,6,7,7
+S,3,9,4,7,2,7,5,6,10,5,6,10,0,9,9,8
+Y,7,11,9,8,8,9,5,6,4,7,8,8,3,9,8,3
+L,3,6,3,4,1,1,0,6,6,0,1,5,0,8,0,8
+Y,2,4,4,3,2,6,10,1,7,8,11,8,1,11,2,7
+J,4,5,6,6,5,8,10,4,4,7,7,9,3,7,7,5
+S,4,9,5,6,4,7,8,7,7,8,4,7,2,7,9,8
+Q,6,9,7,11,7,8,5,7,5,9,6,9,3,8,6,8
+Q,3,5,5,4,4,9,3,4,3,8,4,9,3,6,4,8
+D,2,6,3,4,2,6,7,10,8,6,6,6,3,8,3,8
+C,6,10,4,5,2,6,9,6,6,11,7,7,2,9,5,9
+L,5,10,6,8,5,9,3,2,6,9,2,9,2,5,3,9
+N,3,3,3,5,2,7,7,13,2,5,6,8,5,8,0,8
+C,2,3,3,1,1,5,9,4,6,11,9,11,1,9,2,8
+E,6,9,4,4,2,7,7,4,7,10,6,10,1,9,7,9
+X,4,9,5,6,5,7,6,3,5,6,6,9,2,8,8,8
+H,3,3,4,1,2,8,7,5,6,7,6,8,5,8,3,7
+L,2,3,2,4,1,0,1,5,6,0,0,6,0,8,0,8
+H,3,5,5,4,3,7,8,3,6,10,6,8,3,8,3,8
+E,2,3,3,2,2,7,7,5,7,7,6,8,2,8,5,10
+Y,5,10,6,7,6,9,6,6,4,7,8,7,6,9,8,3
+H,8,12,8,6,4,9,8,4,5,8,4,5,6,9,5,9
+Q,5,10,5,5,4,9,6,5,6,10,6,7,4,8,9,9
+Q,3,8,5,7,3,8,7,9,6,6,6,9,3,8,5,9
+Q,4,6,6,4,5,8,5,6,4,6,7,10,4,7,5,9
+J,2,8,3,6,1,13,3,8,4,13,3,11,1,6,0,8
+J,4,7,5,5,2,8,9,1,7,14,5,6,0,8,1,8
+D,4,5,5,4,3,7,7,7,7,7,6,5,2,8,3,7
+R,2,6,4,4,3,6,7,5,5,6,5,7,3,7,5,8
+M,4,5,7,4,4,6,6,3,4,9,9,10,7,5,2,8
+A,3,7,5,5,3,12,2,3,2,10,2,9,2,6,3,8
+N,3,5,4,4,2,7,8,5,4,7,7,7,6,9,2,5
+M,6,10,9,7,8,3,7,4,5,10,11,10,7,9,3,7
+P,8,14,7,8,4,5,10,6,3,12,5,4,4,10,4,8
+C,6,12,5,7,4,8,5,4,3,9,9,11,4,9,8,10
+P,6,10,8,8,7,8,5,7,5,7,6,6,3,9,8,9
+N,2,3,3,1,1,5,9,3,3,10,8,8,4,8,0,8
+W,3,4,4,3,2,9,10,3,2,5,9,7,6,11,0,8
+V,3,8,5,6,6,8,7,4,1,8,7,8,5,10,4,7
+V,6,9,9,8,10,8,7,5,5,7,6,8,8,9,9,3
+M,6,7,9,5,7,4,7,3,5,10,10,11,8,6,3,7
+E,4,8,5,6,4,7,7,4,8,11,8,9,2,9,5,7
+N,6,11,8,8,9,5,8,3,4,8,8,9,7,9,5,4
+Y,8,10,8,7,4,3,10,3,7,11,12,6,1,11,3,5
+W,4,8,5,6,3,6,8,4,1,7,8,8,8,9,0,8
+O,6,7,8,6,6,6,6,5,6,8,5,8,3,6,5,6
+N,4,4,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+H,4,8,5,6,5,7,10,8,5,8,5,6,3,6,7,11
+O,4,7,5,5,3,8,7,8,5,10,6,8,3,8,3,8
+N,4,8,5,6,4,7,7,9,4,6,4,6,3,7,3,8
+H,4,9,5,6,2,7,6,15,1,7,7,8,3,8,0,8
+U,7,11,8,9,4,3,9,6,7,11,11,10,3,9,2,6
+Y,2,7,3,5,1,6,10,0,3,7,11,8,1,11,0,8
+S,6,8,7,6,4,6,9,4,8,11,7,6,2,8,5,5
+S,5,9,6,7,5,7,7,7,5,7,6,7,2,8,9,8
+T,2,3,2,2,1,7,11,2,6,7,10,8,1,11,1,7
+C,2,3,3,2,1,4,7,4,6,10,9,13,1,9,2,7
+V,4,10,7,7,2,9,8,5,3,5,14,8,3,9,0,8
+T,5,8,5,6,3,6,12,4,7,12,9,4,2,12,2,4
+K,7,12,6,6,3,7,8,2,7,9,7,8,5,8,3,7
+D,3,8,4,6,4,7,8,7,6,7,7,5,3,8,3,7
+W,2,1,3,1,1,7,8,4,0,7,8,8,6,10,0,8
+I,2,9,3,7,2,8,7,0,7,13,6,9,0,8,1,8
+E,3,8,3,6,2,3,7,6,10,7,6,14,0,8,7,8
+F,6,9,8,7,4,6,12,6,6,13,7,3,2,9,2,5
+I,3,9,4,7,3,7,7,0,7,13,6,8,0,8,1,8
+H,5,10,7,8,8,7,7,6,6,7,6,9,3,8,4,8
+U,4,7,4,5,2,7,5,13,5,7,14,7,3,9,0,8
+C,2,3,3,2,1,6,8,7,7,9,7,12,1,10,3,9
+F,5,9,6,7,7,7,6,6,4,7,7,8,5,10,9,12
+A,3,8,5,6,3,9,2,2,3,8,2,8,2,6,3,7
+Z,3,7,5,5,3,7,8,2,9,11,7,7,1,8,6,7
+X,3,7,5,5,2,10,5,2,8,10,1,7,3,7,3,10
+N,3,3,5,2,2,5,10,3,4,10,8,7,5,8,1,8
+R,6,9,5,4,3,10,6,5,5,10,2,8,6,6,4,9
+B,3,3,3,4,3,7,7,5,5,7,6,6,5,8,5,10
+B,5,9,7,7,7,8,8,3,6,10,5,6,3,7,6,8
+U,5,6,5,4,2,5,8,6,8,9,8,8,3,9,2,5
+J,4,4,6,5,4,8,9,4,5,7,6,9,3,7,8,8
+F,3,7,4,5,2,1,11,4,4,11,11,8,0,8,2,7
+M,6,8,9,6,6,11,6,2,5,9,3,6,9,7,2,9
+H,1,1,2,1,1,7,7,12,1,7,6,8,3,8,0,8
+A,2,1,4,2,1,8,1,2,2,7,2,8,2,5,2,7
+O,5,10,4,5,3,6,6,6,2,9,6,9,5,9,4,8
+E,1,0,1,1,1,4,7,5,8,7,6,13,0,8,6,10
+U,3,3,3,1,1,5,8,5,7,10,9,8,3,10,2,6
+A,3,7,5,5,3,10,4,1,2,8,3,9,2,4,2,7
+X,4,8,5,6,3,5,8,1,8,10,9,9,2,9,3,6
+S,5,8,7,6,4,8,8,4,9,11,3,8,2,6,4,9
+J,1,3,2,2,1,10,7,1,5,11,4,8,0,7,0,7
+K,5,11,8,8,5,6,7,2,7,10,7,10,4,8,4,8
+I,2,6,2,4,1,9,5,0,6,13,5,9,0,8,1,8
+P,7,11,10,8,6,6,11,3,6,13,6,3,0,10,3,8
+T,2,1,2,1,0,8,15,1,4,6,10,8,0,8,0,8
+C,1,1,2,2,1,6,8,6,6,9,7,12,1,9,3,10
+H,4,9,4,7,4,7,8,13,1,7,5,8,3,8,0,8
+A,2,4,4,3,2,10,2,2,2,9,2,9,2,7,3,9
+L,6,11,9,8,11,7,7,3,6,6,7,11,6,11,9,7
+T,3,6,4,4,3,7,12,4,6,7,11,8,2,12,1,7
+A,2,8,4,6,2,12,2,4,3,11,2,10,3,6,3,9
+V,3,9,5,7,3,8,9,4,1,6,12,8,2,10,0,8
+U,5,7,6,5,5,8,8,8,5,6,7,9,4,8,4,5
+I,2,9,2,6,3,7,7,0,7,7,6,8,0,8,2,8
+Z,8,14,8,8,5,8,5,2,9,12,6,9,3,7,6,7
+V,4,7,6,5,6,8,8,4,2,8,7,8,7,11,5,8
+M,5,9,7,6,7,9,7,5,5,6,7,6,10,7,4,6
+L,4,8,6,6,4,6,5,2,8,7,2,8,1,6,3,7
+O,3,3,5,5,2,9,6,9,7,7,5,10,3,8,4,8
+B,4,2,5,4,4,7,7,5,6,7,6,6,2,8,7,10
+A,8,15,7,8,4,8,2,3,2,8,5,12,5,4,5,5
+K,6,9,9,6,7,9,6,1,7,10,3,8,3,7,3,9
+H,3,7,4,5,4,7,7,5,6,7,6,8,3,8,3,8
+T,7,9,7,7,5,6,10,1,8,11,9,5,2,9,3,4
+W,6,5,7,4,4,4,11,2,2,9,9,8,7,11,1,7
+F,3,8,3,5,1,1,12,4,5,12,11,8,0,8,2,6
+A,3,3,5,4,1,7,6,3,0,7,0,8,2,7,1,8
+E,3,8,3,6,3,3,6,5,9,5,4,13,0,8,6,9
+M,4,9,5,7,4,7,7,12,1,7,9,8,8,6,0,8
+B,4,9,5,7,6,7,8,9,6,7,6,6,2,8,8,10
+M,3,7,5,5,6,7,8,6,4,6,6,8,5,8,7,9
+Y,6,9,6,7,4,5,8,0,8,8,9,5,2,11,4,4
+V,4,9,6,7,3,6,12,3,4,7,12,9,3,10,1,8
+S,2,8,3,6,3,8,8,7,6,7,4,6,2,7,8,8
+C,2,1,2,2,1,6,8,7,7,8,7,12,1,9,4,10
+H,4,9,6,6,8,7,7,6,3,7,6,7,8,7,9,9
+U,5,8,5,6,4,8,6,11,4,8,13,7,3,9,0,8
+P,6,10,6,6,4,7,10,5,2,11,5,4,4,11,5,7
+Z,3,8,4,6,2,7,7,4,13,10,6,8,0,8,8,8
+E,3,4,5,2,2,7,7,2,8,11,7,9,2,8,4,8
+N,5,9,7,6,4,4,10,3,4,9,10,9,5,8,1,8
+P,6,10,5,6,3,5,9,6,3,10,5,6,5,9,4,7
+H,4,5,5,4,4,7,7,6,6,7,6,7,3,8,3,6
+T,6,11,6,8,5,6,11,3,7,11,9,5,2,12,2,4
+B,5,5,5,8,4,7,9,10,8,7,5,7,2,8,9,10
+U,5,10,6,7,2,7,4,14,6,7,15,8,3,9,0,8
+S,3,4,4,6,2,8,8,6,9,5,5,5,0,8,9,7
+F,5,6,5,8,2,1,14,5,3,12,9,5,0,8,3,6
+J,3,9,4,7,4,9,6,1,6,11,4,7,0,6,1,6
+R,3,6,4,4,4,6,7,5,5,7,6,7,3,7,4,9
+E,3,2,3,4,3,7,8,5,7,7,5,9,2,8,5,10
+P,6,9,6,4,4,8,9,5,3,10,5,5,5,10,5,6
+I,2,2,1,4,1,7,7,1,7,7,6,8,0,8,3,8
+K,7,10,9,8,9,7,7,5,5,7,6,7,7,6,9,13
+D,4,10,6,7,4,8,6,8,7,4,5,3,3,8,4,8
+B,4,7,6,5,7,9,6,4,4,6,6,7,7,8,6,7
+H,5,10,7,8,6,7,9,8,5,8,5,6,3,7,7,10
+M,7,10,10,7,7,9,6,2,5,9,5,7,8,6,2,8
+P,6,11,7,8,3,4,13,9,2,10,6,4,1,10,4,8
+O,4,8,6,6,4,8,5,8,4,7,5,8,3,8,3,8
+S,2,8,3,6,3,8,7,7,5,7,6,7,2,9,8,8
+K,4,7,6,5,4,3,8,3,7,11,11,12,3,8,3,5
+V,7,10,7,8,3,3,11,4,4,10,12,8,3,10,1,8
+F,7,11,10,8,5,6,11,2,7,14,7,4,1,10,2,7
+Y,3,4,5,6,1,6,10,3,2,9,13,8,1,11,0,8
+D,4,6,6,4,3,11,6,3,8,11,3,6,3,8,3,9
+Z,1,0,1,1,0,7,7,2,10,8,6,8,0,8,6,8
+Q,3,5,3,6,3,7,8,6,3,8,8,9,3,8,5,7
+S,8,14,8,8,4,9,4,4,4,13,5,8,3,10,3,8
+B,5,7,7,5,6,8,6,5,6,9,6,7,3,9,6,10
+K,8,13,9,7,5,6,7,3,6,10,8,10,6,10,4,7
+V,3,10,5,7,2,5,8,5,3,9,14,8,3,10,0,8
+B,4,7,4,5,3,6,7,9,7,7,6,7,2,8,9,10
+Y,2,2,4,4,2,6,10,1,7,7,11,9,1,11,1,8
+O,3,4,4,3,2,7,7,7,5,7,6,8,2,8,3,8
+Z,6,10,8,7,5,8,6,3,10,12,4,9,1,7,6,9
+L,2,3,3,2,1,6,4,1,8,7,2,10,0,7,2,8
+J,1,3,2,2,1,10,6,2,6,12,4,9,0,7,1,7
+Z,1,3,3,2,1,7,8,1,9,11,7,7,1,8,5,7
+A,3,5,5,7,2,7,7,3,1,6,0,8,3,7,1,8
+L,3,5,4,5,3,8,7,4,5,7,6,8,3,8,7,10
+J,2,5,3,3,1,10,7,1,7,12,3,7,0,7,1,7
+Q,5,6,6,8,5,8,7,6,3,7,7,12,3,8,6,8
+N,1,3,2,1,1,7,8,5,3,7,7,7,4,8,1,6
+Z,2,6,3,4,1,7,7,3,13,9,6,8,0,8,8,8
+E,4,9,5,7,3,3,7,6,11,7,6,15,0,8,7,7
+J,4,7,3,10,3,9,7,3,3,11,4,5,3,8,6,9
+D,4,8,5,6,3,5,7,10,10,6,5,6,3,8,4,8
+O,5,10,6,8,5,7,8,9,6,8,8,6,4,8,5,10
+L,3,6,4,4,2,5,4,3,8,3,2,6,1,6,2,5
+V,4,5,5,4,2,4,12,4,4,11,11,6,2,10,1,8
+X,6,10,9,8,6,7,7,0,8,9,6,8,3,8,4,7
+J,5,8,6,6,3,6,6,4,5,14,8,12,1,6,1,7
+N,7,10,10,8,5,7,8,3,5,10,6,7,7,8,1,8
+H,3,5,5,7,4,10,11,3,2,7,8,8,3,10,7,9
+A,2,7,4,5,3,13,3,3,2,10,1,8,2,6,2,8
+P,4,6,5,9,9,8,7,5,0,7,6,7,6,10,6,9
+A,4,9,6,6,2,10,5,3,1,8,1,9,2,7,2,8
+F,4,8,5,6,3,5,10,4,6,11,10,5,2,10,3,5
+X,3,4,6,3,2,7,7,1,9,10,6,8,2,8,3,7
+D,5,11,6,9,4,5,8,11,9,8,7,5,3,8,4,8
+V,3,7,5,5,3,9,11,2,2,4,10,8,2,12,1,8
+P,7,10,6,5,4,10,7,4,4,12,4,5,4,11,5,9
+F,5,9,6,7,6,6,9,4,6,9,9,6,5,9,3,6
+P,6,11,9,8,5,8,10,7,5,10,4,3,3,10,4,8
+Y,4,10,6,8,2,9,11,0,4,6,11,8,0,10,0,8
+W,3,3,4,4,2,5,8,4,1,7,9,8,7,10,0,8
+P,6,9,8,7,5,6,11,7,3,11,5,3,2,10,4,8
+J,5,6,7,7,6,7,8,4,5,7,7,8,4,6,8,6
+E,4,2,4,4,3,8,7,6,10,6,5,9,2,8,6,8
+S,4,8,5,6,3,7,5,6,9,5,6,10,0,9,9,8
+E,3,7,3,5,2,3,8,6,11,7,5,14,0,8,7,8
+B,5,9,7,7,6,7,9,5,6,10,6,6,3,8,7,8
+I,1,9,1,7,1,7,7,0,9,7,6,8,0,8,3,8
+S,6,8,7,6,4,9,6,4,6,10,3,8,2,8,5,10
+S,3,8,4,6,3,8,6,8,6,7,8,9,2,10,9,8
+C,3,7,4,5,2,5,8,6,7,6,8,13,1,8,4,10
+M,8,10,11,8,9,9,6,2,5,9,4,7,11,9,3,8
+P,9,10,7,5,3,6,11,6,2,11,5,5,4,10,4,8
+R,2,4,4,3,3,7,8,4,4,9,5,8,2,6,3,10
+U,3,8,5,6,6,8,7,4,4,6,7,8,7,9,5,6
+U,6,6,6,4,3,4,8,5,8,11,11,9,3,9,2,6
+D,3,8,4,6,2,5,7,10,8,7,7,5,3,8,4,8
+U,2,1,3,1,1,7,5,11,5,7,14,8,3,10,0,8
+J,2,5,3,4,2,10,7,2,6,11,3,7,1,6,2,7
+Z,7,13,7,7,5,6,7,2,9,11,6,8,4,5,8,6
+F,5,11,7,8,6,7,9,3,6,12,7,6,3,9,2,7
+V,1,0,2,1,0,8,9,4,2,7,12,8,2,10,0,8
+M,6,5,8,4,7,6,9,5,3,6,4,8,13,8,5,7
+U,3,6,4,4,1,7,5,13,5,7,13,8,3,9,0,8
+B,3,7,4,5,5,7,7,4,6,6,6,6,2,8,5,10
+L,4,8,6,6,4,6,5,1,9,7,2,10,0,6,3,8
+T,4,10,5,8,3,8,13,0,5,7,10,8,0,8,0,8
+D,8,12,8,6,4,9,4,4,6,12,3,8,5,6,5,10
+T,6,11,6,8,4,6,10,1,10,11,9,5,2,8,4,4
+O,5,8,7,6,4,7,5,8,4,6,4,7,3,9,4,9
+T,1,0,2,1,0,7,14,1,4,7,10,8,0,8,0,8
+U,4,3,5,2,2,5,8,5,7,10,10,9,3,9,2,6
+D,2,4,4,2,2,9,6,4,6,11,4,6,2,8,3,8
+R,4,8,5,5,3,5,11,8,3,7,4,8,3,7,6,11
+G,7,10,7,7,5,5,7,7,6,9,8,10,2,9,5,9
+D,2,1,2,2,1,6,7,8,7,6,6,6,2,8,3,8
+S,3,8,4,6,4,7,7,7,5,7,6,8,2,8,8,8
+S,7,10,9,8,10,9,5,5,4,9,6,9,6,9,12,11
+M,6,10,9,8,8,7,7,2,4,9,7,8,8,6,2,8
+M,4,8,6,6,8,9,6,2,2,8,4,8,7,7,2,5
+D,6,7,8,6,6,5,7,6,7,7,4,7,3,6,5,6
+Z,4,9,6,7,4,8,6,2,9,12,5,9,3,6,8,8
+W,4,9,7,7,5,9,8,4,1,6,9,8,7,11,0,8
+C,2,1,3,2,1,6,8,6,7,7,8,12,1,9,4,10
+K,3,6,4,4,4,6,7,3,7,6,6,9,3,8,6,10
+J,6,9,9,7,5,8,5,7,7,8,6,7,2,6,4,6
+A,6,9,8,8,8,8,7,3,5,7,8,8,6,8,4,5
+D,5,12,5,6,4,8,7,3,6,10,5,7,5,8,7,6
+C,4,8,6,6,4,8,8,8,6,7,6,8,4,7,4,8
+V,3,4,4,3,1,4,12,3,3,10,11,7,2,11,1,8
+S,4,7,4,5,2,9,10,6,9,5,6,6,0,7,8,9
+F,4,9,6,6,4,9,8,1,6,13,5,5,1,10,2,9
+A,5,10,7,8,5,8,3,3,1,7,1,8,5,9,5,8
+B,3,2,4,3,3,8,7,5,6,7,6,6,2,8,6,9
+N,2,3,3,2,2,7,9,5,4,7,6,7,5,9,2,7
+U,6,10,5,6,3,6,6,4,4,6,7,8,5,5,2,8
+S,4,10,5,8,5,7,7,5,8,5,6,8,0,8,9,8
+Q,2,5,3,6,3,8,8,7,2,5,7,10,3,9,5,9
+F,4,8,4,5,1,1,13,5,5,12,11,7,0,8,2,6
+F,4,9,6,6,5,5,10,4,6,10,10,6,2,10,3,6
+X,5,10,8,8,4,8,7,4,10,6,6,8,4,6,8,9
+A,3,7,5,5,3,11,3,2,2,8,2,9,3,4,2,8
+B,4,9,4,6,3,6,7,9,7,7,6,7,2,8,9,10
+O,5,9,6,7,5,7,7,8,7,7,6,7,2,8,3,8
+J,2,6,3,4,1,14,1,6,5,14,2,11,0,7,0,8
+H,4,8,5,5,2,7,5,15,1,7,9,8,3,8,0,8
+M,6,9,7,4,3,6,9,5,5,4,4,10,8,7,2,8
+I,3,7,4,5,2,7,7,0,7,13,6,8,0,8,1,7
+W,6,10,6,8,6,2,10,2,3,10,9,8,7,11,2,6
+N,3,6,4,4,3,6,7,8,5,7,5,7,3,7,3,8
+A,1,3,2,2,1,10,3,2,1,9,2,9,1,6,1,8
+S,2,3,4,1,1,7,8,2,6,10,5,7,1,8,4,8
+P,1,0,1,0,0,5,10,6,1,9,6,5,0,9,2,8
+D,6,9,8,8,8,7,6,5,7,7,5,9,6,5,9,4
+M,7,9,10,7,6,5,6,4,5,11,10,11,11,5,4,8
+T,4,8,5,6,5,8,11,3,6,6,11,8,3,12,1,7
+L,3,6,4,4,2,5,5,1,9,6,2,11,0,8,3,7
+X,3,6,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+G,2,4,3,6,2,7,7,8,6,5,7,9,2,7,5,11
+D,6,10,8,8,5,10,5,4,8,11,3,7,4,6,4,9
+E,3,4,4,6,2,3,8,6,10,7,6,14,0,8,7,7
+N,2,3,2,1,1,6,9,6,3,8,7,8,4,9,1,7
+G,2,4,3,3,2,6,6,6,5,6,6,9,2,8,4,8
+V,7,10,6,8,3,2,11,5,5,12,12,8,2,10,1,8
+A,2,7,4,4,2,7,3,3,2,7,2,8,3,7,2,8
+E,5,9,4,4,2,8,7,4,4,10,5,10,3,8,7,10
+K,4,5,5,8,2,3,6,7,3,7,8,12,3,8,3,10
+M,6,9,9,6,6,5,7,3,5,10,10,9,8,6,3,8
+L,5,11,5,6,3,7,5,3,5,12,7,11,3,8,6,9
+T,5,6,5,4,2,5,12,3,8,12,9,4,1,11,2,4
+G,2,4,4,3,2,7,6,6,6,6,6,10,2,9,4,9
+J,2,4,4,3,1,8,8,2,7,15,5,8,0,7,1,8
+F,5,10,5,7,2,1,14,5,4,12,10,6,0,8,2,5
+W,7,8,7,6,6,6,11,5,2,9,6,6,8,13,4,4
+A,3,6,5,4,3,12,3,2,2,9,2,9,2,6,2,8
+K,6,11,8,8,5,9,5,1,7,10,3,9,5,9,5,11
+P,1,1,2,2,1,5,10,4,4,10,8,4,1,9,3,7
+M,7,6,9,5,9,7,7,5,4,6,5,8,10,8,5,5
+O,2,6,3,4,2,8,7,7,5,7,6,9,2,8,3,8
+S,4,11,5,8,3,6,6,6,9,4,6,9,0,9,9,8
+C,4,6,6,5,5,4,7,3,6,6,6,10,4,10,7,7
+O,1,0,2,1,0,8,7,6,4,7,6,8,2,8,3,8
+Z,2,1,3,2,1,7,7,5,9,6,6,9,1,8,7,8
+X,4,9,6,7,6,9,7,3,6,7,4,5,6,6,9,8
+W,4,4,5,3,3,6,11,5,2,8,7,6,6,11,2,6
+B,4,9,4,6,5,6,6,8,6,6,6,7,2,8,7,9
+C,6,11,6,8,4,4,8,5,6,12,10,11,2,10,3,7
+F,2,4,3,3,2,5,10,3,5,10,9,5,1,10,3,6
+I,1,4,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+B,1,3,2,2,1,8,7,3,5,10,5,7,2,8,3,9
+P,3,4,5,2,2,8,9,3,5,13,4,3,1,10,3,8
+K,11,14,10,8,4,6,8,3,7,9,8,10,6,8,4,6
+U,4,5,5,4,2,5,8,5,8,10,8,8,3,9,3,5
+N,3,8,4,6,2,7,7,14,2,5,6,8,5,8,0,8
+Y,4,11,6,8,1,7,11,2,3,8,12,8,1,11,0,8
+I,3,5,5,6,4,8,8,4,4,7,6,8,3,7,8,8
+Q,8,15,7,8,4,8,5,4,9,11,4,10,3,6,9,9
+Q,4,5,4,7,4,9,7,6,2,8,6,11,3,9,6,8
+Z,1,0,1,0,0,8,7,2,9,8,6,8,0,8,5,8
+F,4,5,5,6,5,7,9,5,4,8,6,7,4,9,8,7
+M,8,10,11,8,8,9,6,2,5,9,6,7,8,6,2,8
+D,4,7,5,5,2,5,7,10,9,7,6,5,3,8,4,8
+N,2,3,3,1,1,8,9,3,4,10,4,6,4,9,1,7
+W,5,10,8,8,5,3,10,3,3,9,10,9,8,11,1,8
+U,4,9,4,6,4,7,5,13,5,7,10,8,3,9,0,8
+G,6,11,8,9,6,6,6,7,5,5,6,12,5,7,5,6
+G,7,11,9,8,11,8,5,4,3,6,5,10,8,7,9,13
+O,5,10,4,5,3,7,7,5,4,7,4,7,5,8,5,8
+U,2,6,3,4,1,8,6,13,5,7,13,8,3,9,0,8
+K,6,10,8,8,8,6,7,5,3,7,5,8,5,7,10,8
+W,4,8,6,6,3,4,8,5,1,7,9,8,8,10,0,8
+K,5,7,7,5,5,5,7,2,6,10,8,11,3,8,3,8
+E,5,11,4,6,2,9,6,4,6,10,5,9,1,10,7,9
+V,3,6,5,4,1,9,8,4,2,5,14,8,3,10,0,8
+R,8,12,8,7,6,9,6,3,5,9,4,8,6,8,6,8
+Z,4,11,5,8,5,9,6,6,10,7,5,6,2,7,8,8
+S,4,10,6,7,4,7,8,3,7,10,5,7,2,6,5,8
+N,3,6,5,4,5,7,8,3,3,8,7,8,5,9,5,4
+X,5,11,8,8,4,5,8,2,8,10,11,9,3,9,4,6
+I,3,6,4,4,2,5,7,3,7,7,6,12,0,8,4,9
+Q,1,2,2,3,1,8,7,4,1,7,8,10,2,9,3,9
+N,10,15,9,8,4,7,9,4,5,3,5,10,6,10,2,7
+C,5,7,5,5,3,6,7,6,8,12,8,12,2,10,4,7
+Q,6,9,5,4,3,10,4,4,7,11,3,10,3,7,7,11
+N,7,10,9,8,7,7,7,8,6,7,5,6,4,8,4,8
+K,6,9,8,8,8,7,7,2,4,7,3,9,7,4,9,10
+S,8,12,8,7,4,5,10,4,5,14,8,6,2,9,3,7
+E,2,3,3,2,1,6,8,2,8,11,8,8,1,8,4,7
+D,4,8,6,6,8,9,7,5,6,7,5,6,5,6,8,7
+X,4,4,5,5,1,7,7,4,4,7,6,8,3,8,4,8
+C,1,0,2,1,0,7,7,6,7,7,6,13,0,8,4,10
+J,5,9,7,7,3,9,5,4,6,15,4,10,1,6,0,7
+B,5,7,7,5,5,7,6,6,7,8,7,6,3,9,8,7
+D,5,9,5,7,5,5,7,9,7,6,5,5,2,8,3,8
+R,7,10,7,5,5,7,6,3,5,8,4,9,6,8,6,7
+Z,2,1,2,1,1,7,7,3,11,8,6,8,0,8,6,8
+T,2,3,4,4,1,8,14,1,6,6,11,8,0,8,0,8
+K,5,9,5,7,2,4,7,9,2,7,6,12,3,8,3,11
+G,5,11,7,8,5,7,6,7,8,7,4,12,2,9,6,8
+B,11,15,10,8,9,9,8,3,6,10,4,6,8,3,9,7
+X,8,11,11,9,7,6,8,1,8,10,8,9,3,8,4,6
+D,6,9,8,7,6,10,6,3,7,11,4,7,4,7,4,9
+V,2,5,4,4,1,6,11,3,4,8,11,8,2,10,1,8
+I,2,11,0,8,1,7,7,5,3,7,6,8,0,8,0,8
+Z,2,5,4,4,2,7,8,2,10,11,6,8,1,8,6,7
+G,2,3,3,2,1,7,6,5,4,6,6,9,2,9,4,9
+J,3,5,4,8,1,13,2,9,5,14,3,12,0,6,0,8
+V,2,5,4,4,2,7,12,2,3,7,11,8,2,10,1,8
+V,8,15,8,8,5,5,8,5,4,8,7,6,6,12,3,8
+J,6,12,5,9,4,10,7,2,4,12,4,6,2,9,7,9
+C,3,6,4,4,1,6,7,6,10,7,6,13,1,8,4,9
+U,2,3,3,1,1,4,8,5,6,11,10,8,3,10,1,6
+A,2,6,4,4,2,12,2,4,3,12,2,10,2,6,3,9
+Y,3,10,5,7,1,10,10,3,2,5,13,8,2,11,0,8
+T,3,7,5,5,3,7,11,1,8,7,11,8,1,10,1,8
+M,5,8,7,6,6,8,7,2,4,9,5,7,7,6,2,8
+V,5,8,5,6,3,4,11,2,3,8,10,7,3,12,1,7
+S,4,8,5,6,3,6,8,4,6,10,9,8,2,9,5,4
+M,5,6,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+Y,3,8,6,5,1,10,10,3,2,5,13,8,2,11,0,8
+Z,9,9,6,12,6,6,9,4,2,12,7,7,3,8,13,6
+M,3,8,4,6,3,8,6,12,1,5,9,8,7,6,0,8
+M,3,7,4,5,4,7,5,10,0,7,8,8,6,5,0,8
+J,3,8,3,6,2,13,3,5,4,13,2,10,0,7,0,8
+K,7,13,7,7,4,8,7,2,6,10,7,9,6,11,4,8
+B,3,3,4,4,3,7,7,6,5,7,6,6,2,8,6,10
+K,4,10,6,8,7,7,7,5,4,7,5,7,4,6,9,14
+Z,5,8,7,6,4,5,10,3,10,11,9,6,1,9,6,5
+F,4,8,4,6,3,1,13,4,4,12,10,6,0,8,1,6
+N,1,1,2,1,1,7,8,5,3,7,7,7,4,8,1,6
+P,7,10,10,8,5,7,14,5,3,13,4,0,0,10,4,7
+C,4,3,5,5,2,6,7,6,10,7,6,13,1,8,4,9
+Z,4,8,6,6,3,9,5,3,10,11,4,9,1,7,6,9
+S,2,3,4,2,1,8,7,2,6,10,6,8,1,9,5,8
+W,4,6,7,4,4,9,11,2,3,5,9,8,7,11,1,8
+P,2,3,4,2,2,7,9,4,4,11,4,4,1,9,3,8
+L,4,8,4,6,1,0,0,6,6,0,1,4,0,8,0,8
+U,3,4,4,6,2,8,5,14,5,7,13,8,3,9,0,8
+J,3,10,4,7,1,13,2,9,4,14,4,12,1,6,0,8
+J,2,4,3,6,1,12,2,9,4,13,6,13,1,6,0,8
+Z,3,5,3,3,2,8,7,5,10,6,6,7,2,8,7,8
+M,4,2,5,4,4,8,6,6,4,7,7,8,8,6,3,6
+U,7,13,6,7,4,8,4,5,5,7,9,8,4,8,3,8
+J,1,3,2,2,1,9,7,2,6,14,5,8,0,7,0,8
+B,5,9,5,7,7,6,7,8,5,7,6,7,2,8,7,9
+B,7,11,9,8,7,10,6,4,7,10,3,7,2,8,6,12
+Q,8,14,8,8,4,9,4,4,7,11,4,10,3,7,8,11
+N,3,4,5,3,2,7,9,2,5,10,6,6,5,9,1,7
+D,3,7,4,5,3,9,7,5,7,10,4,5,3,8,3,8
+B,1,0,1,0,0,7,7,6,4,7,6,7,1,8,5,9
+E,4,6,6,4,4,7,8,2,7,11,7,9,3,8,4,9
+E,3,3,5,2,2,6,8,3,8,11,8,9,2,9,4,7
+N,6,11,8,8,5,7,9,2,5,9,6,7,5,9,1,8
+T,2,4,4,6,1,7,14,0,6,8,11,8,0,8,0,8
+Y,3,3,5,4,1,9,9,3,1,5,13,8,2,10,0,8
+Q,7,9,7,10,8,8,8,6,2,7,7,11,4,10,8,6
+U,9,15,8,8,5,5,5,4,4,7,8,10,7,5,3,9
+H,3,3,4,4,2,7,10,14,2,7,3,8,3,8,0,8
+J,2,10,3,8,1,14,3,7,5,14,1,10,0,7,0,8
+D,1,4,3,3,2,10,6,3,5,10,3,6,2,8,2,9
+G,2,4,2,2,1,6,7,5,5,9,7,10,2,8,4,9
+V,5,9,7,8,9,7,7,5,4,7,6,8,7,9,7,8
+U,2,2,3,3,2,7,9,5,7,7,9,9,3,9,1,8
+U,7,11,9,8,7,5,9,5,7,6,9,10,3,9,1,8
+Z,3,3,4,4,2,7,7,3,14,9,6,8,0,8,8,8
+G,2,3,3,1,1,7,7,5,5,9,6,10,2,9,4,10
+L,4,11,5,8,4,7,4,1,7,8,2,10,1,6,3,8
+D,4,6,5,4,4,9,7,3,6,10,4,6,3,8,2,8
+J,3,10,5,7,5,9,8,3,3,8,4,6,4,8,6,5
+K,3,6,5,4,5,7,6,3,4,6,6,8,7,7,6,9
+A,3,9,5,7,3,12,3,4,3,11,1,9,2,6,3,9
+L,3,4,4,7,1,0,1,6,6,0,0,6,0,8,0,8
+X,4,9,6,7,5,8,5,3,5,6,7,8,3,9,9,9
+Q,5,9,5,5,3,11,5,3,6,9,4,7,3,9,6,11
+F,3,8,3,6,2,2,12,4,3,12,10,6,0,8,2,7
+W,2,3,4,2,2,7,10,2,2,6,9,8,5,11,0,7
+K,6,9,9,6,6,5,7,1,7,10,8,10,3,8,4,7
+P,4,9,4,6,4,4,12,7,1,10,6,4,1,10,3,8
+V,6,9,5,5,2,8,11,4,5,7,10,5,4,10,2,6
+L,7,15,6,8,3,10,2,3,5,13,4,12,2,8,5,10
+A,3,8,5,5,1,6,6,3,1,6,0,8,2,6,1,7
+B,3,3,3,4,3,6,7,9,6,7,6,7,2,8,8,10
+S,6,9,5,5,2,8,4,4,5,9,2,8,3,6,5,8
+I,6,11,4,6,2,10,6,5,5,12,3,6,3,8,5,10
+B,1,0,1,0,1,7,8,6,4,7,6,7,1,8,6,9
+F,4,8,6,6,5,4,10,1,2,10,8,7,5,10,2,4
+I,3,4,4,5,3,7,8,4,5,7,8,7,2,9,8,9
+M,5,8,7,6,7,7,6,5,5,7,7,10,11,6,2,8
+K,2,1,3,2,2,5,7,4,7,7,6,11,3,8,4,9
+C,2,3,2,2,1,6,8,6,7,8,7,12,1,9,3,10
+H,4,7,6,5,4,9,8,3,7,10,4,7,3,8,3,9
+S,3,2,4,4,3,8,7,7,5,7,6,7,2,8,9,8
+B,4,5,5,7,4,7,7,10,7,7,6,8,2,8,9,9
+O,2,3,2,1,1,8,7,6,4,9,6,8,2,8,3,8
+M,9,11,12,8,8,4,6,4,5,10,11,11,11,6,4,8
+I,1,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+W,7,9,10,8,11,6,6,6,5,5,5,8,11,11,9,12
+U,4,6,4,4,1,8,5,12,5,7,15,8,3,9,0,8
+Y,4,5,5,4,2,4,11,2,7,11,10,6,1,11,2,5
+A,3,9,6,7,3,11,2,3,3,10,2,9,2,6,3,8
+P,2,3,4,2,2,7,10,3,4,12,4,3,1,10,2,8
+B,4,7,6,5,5,7,8,5,5,9,6,6,3,7,6,7
+O,4,7,5,5,3,8,6,8,5,10,6,9,3,8,3,8
+Y,5,7,5,5,2,3,10,3,7,11,12,7,2,11,3,5
+I,4,5,6,5,4,8,9,4,5,7,6,9,3,8,8,7
+R,3,9,4,6,3,5,10,9,3,7,4,8,3,7,6,11
+N,6,8,9,6,5,10,8,3,6,10,2,4,5,9,1,7
+B,3,7,3,5,4,6,7,7,5,7,6,7,2,8,7,10
+Q,9,15,8,8,4,9,3,4,7,11,4,10,3,8,8,11
+H,6,11,8,8,6,9,7,6,7,7,6,8,6,8,4,7
+J,2,4,3,3,1,11,6,2,7,11,3,7,0,7,1,8
+W,4,4,5,6,3,7,8,4,1,7,8,8,8,10,0,8
+Y,5,11,6,8,2,3,11,3,8,13,11,5,0,10,2,4
+F,4,9,5,7,3,4,11,3,7,11,10,6,1,10,3,5
+A,4,9,6,6,2,7,4,3,2,7,1,8,3,7,3,8
+X,1,0,2,0,0,7,7,4,4,7,6,8,2,8,3,8
+Z,5,10,7,8,5,7,8,2,9,12,7,8,1,9,6,7
+H,3,7,4,4,2,7,9,14,2,7,3,8,3,8,0,8
+K,6,11,9,8,8,7,6,1,6,10,5,9,7,7,6,9
+J,4,7,5,8,5,8,8,4,5,7,6,8,3,8,9,8
+N,2,4,4,3,2,6,9,2,4,10,7,7,5,8,1,8
+W,5,9,7,7,7,7,5,6,2,7,7,8,7,7,6,12
+U,4,6,5,4,2,6,8,7,9,9,10,8,3,9,1,8
+Y,2,6,4,4,1,9,10,3,2,5,13,8,2,11,0,8
+Q,4,7,4,9,4,7,7,6,3,8,9,10,3,8,6,8
+V,3,3,4,2,1,4,12,4,3,11,11,6,2,11,1,8
+D,6,13,6,7,5,11,5,4,6,10,4,7,5,9,6,10
+V,3,8,4,6,2,7,9,4,2,8,12,8,2,10,0,8
+R,4,8,5,6,3,5,12,8,4,8,3,9,3,7,6,11
+L,1,0,1,1,0,2,2,5,5,1,1,6,0,8,0,8
+V,4,10,7,8,3,8,12,3,4,5,11,8,3,10,1,8
+F,5,10,7,8,5,6,10,2,6,13,7,5,1,10,2,7
+B,5,8,7,7,8,7,8,5,5,8,6,8,7,8,9,6
+R,3,4,4,5,2,6,10,9,4,7,4,8,3,7,5,10
+J,3,6,4,4,3,9,6,6,5,8,6,7,2,8,4,6
+V,3,7,5,5,1,7,8,4,2,7,14,8,3,10,0,8
+Y,9,9,8,13,5,9,10,2,4,5,11,5,4,10,7,8
+M,8,9,11,7,8,10,6,2,5,9,4,7,8,7,2,8
+X,3,2,4,3,2,7,7,3,9,6,6,8,2,8,6,8
+S,3,9,4,7,2,7,7,6,8,5,6,7,0,8,9,7
+K,2,3,4,2,2,8,7,1,6,10,5,8,3,8,2,8
+T,3,7,5,5,3,6,11,1,7,8,11,9,1,11,1,8
+H,3,4,6,3,3,7,8,3,6,10,6,8,3,8,3,7
+L,4,9,4,7,2,0,2,4,6,1,0,8,0,8,0,8
+J,3,8,4,6,2,10,6,2,8,12,3,7,0,6,2,6
+D,2,1,2,1,1,5,7,8,7,6,6,6,2,8,3,8
+B,2,1,3,2,2,8,7,5,5,7,6,6,2,8,5,9
+N,6,9,9,7,5,10,8,3,6,10,2,4,5,9,1,7
+R,6,10,9,8,11,6,7,4,4,6,6,9,8,9,9,7
+M,13,15,13,8,7,3,8,6,6,4,2,13,9,11,2,8
+Z,3,6,4,4,2,7,7,4,14,9,6,8,0,8,8,8
+R,6,9,8,7,9,6,7,4,5,7,6,8,6,9,7,5
+K,5,11,6,8,2,3,7,8,2,7,6,11,4,8,2,11
+W,5,9,8,7,7,7,12,2,2,6,8,8,7,12,1,8
+P,3,6,4,4,2,7,10,4,4,12,5,3,1,10,3,8
+E,3,8,4,6,4,6,7,5,8,7,5,10,3,8,5,9
+E,7,12,5,6,4,8,7,4,4,11,5,9,3,9,8,11
+Y,3,3,4,4,1,10,13,3,3,3,11,9,0,10,0,8
+J,3,10,4,7,3,11,5,2,6,11,2,7,0,7,1,7
+L,3,7,4,5,2,4,5,2,10,3,1,8,0,7,2,5
+I,2,5,1,3,1,7,7,1,7,7,6,8,0,8,3,8
+I,1,4,2,3,1,7,7,0,7,13,6,8,0,8,1,8
+M,6,10,7,6,4,13,2,4,3,12,1,9,5,5,1,9
+V,2,5,4,3,2,7,12,2,2,7,11,9,2,10,1,8
+P,7,10,9,8,6,7,10,4,4,12,5,3,1,10,3,8
+H,5,10,7,8,7,7,7,6,7,7,6,8,6,8,4,8
+R,9,13,7,8,5,8,6,5,5,9,5,9,6,6,7,11
+X,4,9,6,7,5,8,7,3,5,6,7,6,4,11,10,8
+P,2,5,3,7,6,8,7,4,1,7,6,7,5,8,4,8
+V,4,10,5,7,3,7,9,4,2,7,13,8,2,10,0,8
+N,3,6,3,4,3,8,7,11,1,6,6,8,5,9,0,6
+O,3,1,4,3,2,8,7,7,5,7,6,8,2,8,3,8
+G,6,11,7,8,5,5,7,6,6,9,8,10,2,8,5,9
+T,4,5,5,4,2,5,12,3,7,11,10,4,1,11,1,5
+R,8,12,7,6,6,6,7,3,5,7,5,9,6,9,6,6
+W,4,3,5,5,3,8,8,4,1,6,8,8,8,9,0,8
+U,6,9,6,5,3,7,5,5,5,7,8,8,5,7,2,8
+L,6,12,6,6,4,8,3,3,4,12,8,12,3,10,5,11
+S,7,12,7,6,3,10,4,5,4,13,5,8,2,9,2,7
+Q,4,9,5,11,7,9,8,8,2,5,7,10,3,8,6,10
+M,3,1,4,3,3,7,6,6,4,6,7,7,8,6,2,7
+F,2,2,3,3,2,5,10,4,5,10,9,5,1,10,3,6
+V,5,8,5,6,2,2,11,5,4,12,12,8,2,10,1,8
+V,5,7,5,5,2,3,11,4,3,10,12,8,2,10,1,8
+F,4,8,4,6,3,1,13,4,3,12,10,7,0,8,1,6
+M,4,11,6,8,6,6,6,6,5,7,7,10,8,5,2,9
+I,3,8,4,6,2,7,7,0,6,13,6,8,0,8,1,8
+P,3,7,3,4,2,4,12,8,2,10,6,4,1,10,4,8
+U,4,2,5,3,2,6,8,5,8,7,10,9,3,9,1,8
+B,3,4,3,3,3,7,7,5,5,7,6,6,2,8,6,9
+Q,4,10,6,9,6,8,7,8,5,6,4,8,3,8,4,7
+H,5,8,5,6,4,7,8,13,1,7,5,8,3,8,0,8
+X,3,8,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+M,4,7,6,5,6,9,7,5,5,6,7,5,8,6,2,6
+J,3,7,4,5,1,7,7,3,7,15,6,10,0,7,1,7
+V,6,12,5,7,3,7,10,6,4,9,9,5,5,12,3,8
+B,2,3,2,2,2,7,7,5,5,6,6,5,2,8,6,8
+T,5,8,5,6,3,4,13,4,6,12,10,4,1,11,1,5
+U,8,10,9,8,5,4,7,6,8,10,10,9,3,9,2,5
+D,4,7,6,5,4,7,8,5,6,10,6,4,3,8,4,8
+Y,4,9,6,7,2,7,12,1,3,7,11,8,0,10,0,8
+O,2,1,2,2,1,8,7,7,4,7,6,8,2,8,3,8
+O,2,0,2,1,1,7,6,7,5,7,6,8,2,8,3,8
+K,4,4,4,6,2,4,7,8,1,7,6,11,3,8,2,11
+W,8,11,8,6,5,9,8,4,5,6,9,6,11,8,3,6
+A,5,11,7,8,4,8,3,2,3,7,1,8,2,7,3,7
+O,8,12,6,6,4,5,9,6,4,9,8,9,5,10,5,8
+S,5,9,6,8,7,9,7,5,6,7,6,7,6,8,10,12
+T,5,7,5,5,3,6,11,3,7,11,9,5,2,12,3,4
+S,2,7,3,5,3,8,8,7,5,7,5,6,2,8,8,8
+X,3,4,5,3,2,7,7,1,8,10,6,8,2,8,3,7
+T,2,9,4,6,1,5,14,1,6,9,11,7,0,8,0,8
+U,5,9,6,7,5,6,6,8,5,7,6,10,5,8,7,3
+Y,5,6,5,4,3,5,9,1,7,9,10,6,2,11,3,5
+V,3,3,4,2,1,4,12,3,3,10,11,7,2,11,1,7
+D,2,4,4,3,2,9,7,4,6,10,4,6,2,8,3,8
+H,5,10,8,8,7,7,8,7,7,7,5,9,3,8,3,8
+B,4,8,6,6,8,9,7,4,4,6,7,7,7,10,7,6
+S,5,11,6,8,3,7,8,4,8,11,7,7,2,8,5,6
+O,2,2,3,3,2,8,7,7,4,7,6,8,2,8,3,8
+O,6,11,7,9,3,7,8,9,8,7,7,6,3,8,4,8
+J,2,6,2,4,1,12,2,9,3,13,5,13,1,6,0,8
+P,3,4,4,6,6,8,9,4,0,8,7,7,5,9,5,7
+O,3,7,5,5,5,8,6,5,1,7,6,8,7,8,3,8
+I,3,7,4,5,2,7,7,0,7,13,6,8,0,8,1,7
+Z,4,9,6,6,6,7,7,3,8,8,6,9,1,8,11,7
+W,3,6,5,4,7,9,7,4,2,7,6,8,8,11,1,6
+F,2,4,3,5,1,1,13,4,4,12,11,7,0,8,2,6
+H,5,7,8,5,6,8,7,3,6,10,6,8,3,8,3,8
+D,2,4,3,3,2,9,6,3,5,10,4,6,2,8,2,8
+B,2,1,2,2,1,7,7,8,5,6,6,7,2,8,7,10
+K,0,0,1,0,0,4,7,5,3,7,6,10,3,8,2,11
+T,4,10,6,8,3,5,11,1,9,9,12,8,0,10,1,7
+N,3,8,3,6,2,7,7,13,2,5,6,8,5,8,0,8
+F,2,6,2,4,1,1,11,3,6,11,11,9,0,8,1,6
+A,3,8,5,5,2,7,4,3,1,7,1,8,3,7,2,8
+V,8,11,7,8,5,4,11,1,3,8,10,8,5,12,1,7
+F,9,13,7,7,3,4,13,3,5,13,7,3,2,7,5,4
+Y,2,1,3,1,0,7,10,3,1,7,13,8,1,11,0,8
+R,4,7,6,5,4,9,8,3,6,10,3,6,3,6,4,10
+Q,5,9,5,11,7,8,7,6,2,8,7,10,3,8,5,8
+M,6,9,9,7,6,10,5,3,5,9,3,6,8,6,2,9
+P,3,5,3,3,2,4,10,3,5,10,8,4,0,10,3,7
+K,3,7,4,5,3,6,7,4,7,6,6,9,3,8,5,9
+Y,6,6,8,9,8,10,12,6,4,6,7,6,5,10,7,4
+D,4,6,6,6,5,6,7,4,7,6,4,7,3,7,5,6
+R,4,3,5,5,3,6,9,10,5,7,5,8,2,8,5,10
+B,4,7,6,5,5,10,7,3,6,10,4,6,2,8,4,10
+T,4,8,6,6,4,6,7,7,7,8,9,8,3,10,5,9
+W,6,10,8,8,4,7,7,4,2,7,8,8,9,9,0,8
+K,5,9,7,7,8,7,9,5,5,8,5,7,7,6,8,12
+G,10,15,9,8,5,8,4,5,4,9,4,5,4,7,5,8
+P,3,7,3,5,2,4,12,8,2,10,6,4,1,10,3,8
+C,1,0,1,1,0,6,7,6,8,7,6,14,0,8,4,10
+S,5,11,7,8,4,10,6,4,8,11,3,8,2,8,5,11
+J,5,9,6,7,4,7,4,5,4,14,8,14,1,6,1,6
+P,5,11,8,8,6,7,11,7,3,10,5,3,3,11,4,8
+X,3,2,4,4,2,7,7,3,9,6,6,8,2,8,6,8
+L,8,13,8,8,5,9,3,3,3,11,6,11,4,8,7,9
+B,4,5,4,8,4,6,8,10,7,7,5,7,2,8,9,10
+E,3,5,6,4,3,8,7,2,8,11,5,8,2,8,5,10
+H,3,4,4,6,2,7,9,15,2,7,4,8,3,8,0,8
+T,3,4,4,3,2,6,11,3,7,11,9,4,2,11,3,4
+P,2,1,2,1,1,5,11,8,2,9,6,4,1,9,3,8
+S,2,3,4,2,2,6,8,2,6,10,8,8,1,8,5,6
+N,1,0,2,1,1,7,7,11,1,5,6,8,4,8,0,8
+P,5,4,5,6,3,4,12,9,3,10,6,4,1,10,4,8
+D,3,5,5,4,3,9,7,5,7,9,4,5,3,8,3,8
+T,2,7,3,4,1,6,14,0,6,8,11,8,0,8,0,8
+B,2,4,4,2,2,9,7,3,5,11,5,7,2,7,4,9
+Y,3,7,5,5,2,7,10,2,2,7,12,8,1,11,0,8
+J,3,11,4,8,2,15,3,4,5,13,0,8,0,7,0,8
+A,3,9,6,7,4,11,3,2,2,9,2,9,3,4,3,8
+J,3,7,5,5,2,11,6,2,7,14,3,8,0,8,0,8
+S,2,3,3,4,1,9,10,5,9,5,6,5,0,7,8,7
+E,4,8,4,6,2,3,7,6,11,7,6,15,0,8,7,7
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+H,5,9,7,6,7,8,8,6,7,7,6,9,6,8,4,7
+G,4,5,5,8,2,7,6,8,8,6,5,10,2,8,6,11
+Z,2,2,3,3,2,7,8,5,9,6,6,9,1,9,7,8
+Y,4,6,6,4,3,9,10,1,7,3,11,8,1,11,1,9
+H,3,7,4,5,5,7,5,4,4,6,5,8,4,8,5,7
+B,4,8,6,6,7,8,8,7,6,7,5,6,2,7,7,10
+A,4,9,6,7,4,10,3,2,2,8,2,10,4,4,3,8
+B,6,10,6,6,5,10,6,3,5,9,5,8,6,8,7,9
+M,6,10,8,8,7,9,6,6,5,6,7,6,8,6,2,6
+P,4,9,4,6,2,5,10,9,4,9,6,5,2,10,4,8
+W,5,11,8,8,6,4,11,2,3,8,9,9,9,11,2,7
+S,2,4,4,2,1,6,8,2,7,11,7,8,1,8,4,6
+J,3,10,4,8,1,13,2,9,4,14,5,13,1,6,0,8
+N,8,14,9,8,5,7,7,2,4,12,4,8,6,8,0,7
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+P,5,8,7,11,11,8,9,4,1,8,7,6,8,10,6,8
+G,2,3,3,2,1,6,7,5,5,9,7,10,2,8,4,10
+E,6,8,8,6,5,4,9,4,9,11,10,9,2,9,4,5
+Q,6,8,7,10,6,8,7,7,4,8,7,10,3,8,6,8
+R,3,8,4,6,2,5,11,8,4,7,4,9,3,7,6,11
+K,2,3,2,2,2,5,7,4,7,6,6,10,3,8,4,10
+Y,4,5,6,6,6,9,9,6,4,7,7,7,5,11,6,4
+P,4,5,6,6,6,6,9,4,2,8,7,6,6,10,4,6
+G,6,9,6,4,3,7,3,5,2,6,5,4,4,8,5,7
+G,4,7,6,5,6,7,7,6,2,7,6,11,4,9,7,9
+P,7,9,8,7,7,6,7,5,5,7,6,9,5,9,7,10
+L,7,15,7,8,5,9,3,3,4,12,6,11,3,8,6,9
+J,1,2,2,3,1,10,6,2,6,12,4,9,0,7,1,7
+Y,3,10,5,8,2,8,10,1,3,6,12,8,1,11,0,8
+D,6,11,8,8,8,8,8,6,6,9,5,4,6,9,5,10
+M,6,10,9,8,8,8,7,2,4,9,7,8,8,6,2,8
+G,2,1,2,2,1,8,6,6,6,6,5,10,1,7,5,10
+U,4,9,5,6,4,6,9,8,5,3,7,12,4,8,5,6
+I,0,6,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+I,4,11,5,8,3,8,6,0,7,13,6,9,1,7,3,8
+B,6,11,6,8,5,6,6,9,7,6,6,7,2,8,10,10
+Q,1,2,2,3,2,7,7,5,2,8,8,9,2,9,4,9
+J,2,7,3,5,1,13,2,9,4,14,4,12,1,6,0,8
+B,4,11,5,8,4,6,7,9,7,7,6,7,2,8,9,10
+A,3,5,5,5,4,9,8,3,4,6,8,7,4,10,4,5
+S,3,4,5,2,2,8,8,2,7,10,6,7,1,8,5,7
+U,4,4,4,6,2,8,5,14,5,6,13,8,3,9,0,8
+E,2,3,4,2,2,7,7,2,7,11,7,9,2,8,4,8
+R,3,8,3,6,3,6,10,7,4,6,3,10,2,6,5,11
+L,3,6,3,4,1,1,0,6,6,0,1,5,0,8,0,8
+N,3,7,4,5,2,7,7,14,2,5,6,8,5,8,0,8
+B,6,9,9,8,10,7,8,5,5,7,7,8,7,9,9,6
+K,6,9,8,6,9,7,6,3,5,6,6,9,8,6,7,7
+X,5,8,6,7,7,6,8,2,5,7,6,9,4,7,8,7
+P,6,9,5,4,2,5,11,5,3,13,5,4,4,9,3,8
+I,1,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+G,8,14,7,8,5,8,6,4,3,9,6,8,4,9,8,8
+A,3,10,6,8,4,12,2,3,3,10,2,9,2,6,4,8
+K,4,4,6,3,3,8,6,1,7,10,4,9,4,7,4,9
+B,5,10,7,8,7,8,6,7,7,6,7,6,2,8,8,11
+Y,3,8,5,6,3,5,9,1,6,8,12,10,1,11,2,8
+N,2,4,4,3,2,5,10,3,3,10,8,8,5,8,1,7
+Y,2,4,4,6,1,5,10,3,2,8,13,8,2,11,0,8
+O,9,12,6,7,3,8,7,6,5,9,4,7,5,9,5,9
+E,6,11,9,9,7,6,8,2,8,10,7,9,3,8,5,7
+U,6,10,6,8,4,3,9,5,6,11,11,9,3,9,1,7
+U,7,8,8,6,3,4,8,5,8,10,10,9,3,9,2,6
+X,3,5,6,4,3,9,7,1,9,10,4,7,2,8,3,8
+D,1,0,1,0,0,6,7,7,5,7,6,6,2,8,3,8
+D,2,1,3,2,2,8,7,7,7,7,7,4,2,8,3,6
+S,4,5,6,4,3,7,7,2,8,11,5,7,1,8,5,8
+K,4,5,7,4,4,5,7,2,8,10,9,10,3,8,4,6
+I,2,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+F,4,5,5,5,5,7,8,4,5,7,5,7,4,9,8,7
+A,1,1,3,2,1,6,2,2,1,6,2,7,1,6,2,6
+R,3,6,5,4,5,6,7,3,3,7,6,9,5,9,7,5
+P,3,2,4,3,3,6,9,4,4,9,7,4,1,10,4,7
+Y,2,7,4,5,2,8,10,1,6,5,11,8,1,11,1,8
+V,4,9,6,7,3,9,11,2,4,4,11,8,2,10,1,8
+M,5,11,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+K,4,9,6,6,5,6,6,3,7,6,6,9,3,8,5,10
+F,4,8,7,6,7,10,6,1,5,9,6,6,5,10,4,6
+X,7,10,7,6,4,9,6,2,7,11,4,7,4,9,4,9
+H,4,9,6,6,7,7,7,6,6,7,6,9,3,8,3,8
+L,4,9,5,7,1,0,0,6,6,0,1,5,0,8,0,8
+H,6,9,8,6,7,11,6,3,6,10,3,7,3,7,3,10
+J,5,11,7,8,8,10,7,4,4,8,4,5,4,7,6,5
+R,2,3,3,2,2,6,7,5,5,7,6,7,2,7,4,9
+G,1,1,2,1,1,7,7,5,5,6,6,10,2,9,3,9
+F,5,9,8,6,7,4,10,1,4,10,7,6,7,10,3,4
+D,6,9,6,4,3,12,2,4,5,12,2,9,4,7,2,10
+K,9,13,9,7,4,4,9,3,7,10,9,11,5,7,3,6
+L,3,9,5,6,3,5,4,2,8,6,1,10,0,6,3,7
+P,5,4,5,6,3,5,9,10,5,8,5,5,2,10,4,8
+A,2,3,3,2,1,8,2,2,1,6,2,8,2,7,2,7
+I,6,10,8,7,5,7,6,2,8,7,6,8,0,9,4,8
+X,3,7,5,5,2,9,7,1,8,10,4,7,3,8,3,8
+M,3,6,5,4,5,12,5,3,2,9,4,8,5,6,2,6
+R,4,2,4,3,3,7,8,5,5,6,5,6,3,7,4,8
+Y,1,0,1,0,0,7,10,3,1,7,12,8,1,11,0,8
+I,1,3,2,1,0,7,7,1,7,13,6,8,0,8,0,7
+T,5,11,6,8,8,7,8,4,5,6,7,9,7,7,8,7
+F,3,9,4,6,2,1,12,5,4,11,10,7,0,8,3,6
+R,5,10,8,8,5,11,7,3,6,11,1,6,4,5,4,10
+Z,9,11,6,15,6,5,11,3,3,12,8,6,3,9,11,5
+K,4,8,6,6,3,7,7,1,7,10,6,9,3,8,4,8
+R,6,9,6,5,4,9,8,4,6,9,2,6,5,5,5,7
+E,4,8,5,6,3,3,9,6,12,7,5,14,0,8,7,7
+Y,10,12,8,7,5,6,8,4,5,10,7,4,3,9,5,4
+M,6,10,7,8,4,7,7,13,2,8,9,8,9,6,0,8
+G,8,15,7,8,6,8,5,4,3,8,6,8,4,9,8,8
+X,4,6,6,4,2,7,7,2,8,11,6,8,3,8,3,7
+Z,3,10,4,7,3,7,8,3,11,9,6,8,0,8,7,8
+T,3,8,4,5,1,8,15,1,6,6,11,9,0,8,0,8
+A,3,3,5,4,1,9,3,3,2,8,2,9,3,6,2,8
+A,2,4,4,5,1,8,6,3,1,7,0,8,2,6,1,8
+P,3,5,5,4,3,8,9,3,4,12,4,4,2,8,3,8
+H,4,8,4,5,2,7,8,15,1,7,5,8,3,8,0,8
+T,5,10,7,8,7,7,6,7,7,6,8,9,4,9,8,6
+M,7,10,9,8,8,9,6,2,5,9,5,7,9,8,2,8
+K,4,9,6,7,7,6,6,3,4,6,5,9,8,6,8,8
+T,1,1,2,1,0,7,14,1,4,7,11,8,0,8,0,8
+J,2,7,3,5,2,8,7,2,5,11,5,8,3,8,2,6
+I,2,8,3,6,2,9,6,0,7,13,5,9,0,8,1,8
+J,1,5,2,3,1,10,6,2,6,11,3,8,0,7,1,7
+C,4,8,5,6,2,5,9,8,8,13,9,6,2,10,2,6
+Y,3,3,4,2,1,4,11,2,7,11,10,5,1,11,2,5
+L,7,15,7,8,5,9,3,4,4,12,7,11,4,8,7,9
+B,2,4,3,2,2,8,7,3,5,9,6,6,2,8,4,8
+P,6,10,8,8,6,8,10,5,4,11,4,3,1,10,3,8
+Q,4,10,5,9,6,8,7,8,5,6,3,8,3,9,4,8
+D,3,6,4,4,5,9,7,5,4,7,5,7,4,7,6,5
+E,5,11,4,6,3,9,6,3,5,11,4,8,3,9,7,11
+D,5,7,6,6,5,6,7,6,7,7,5,7,4,7,5,5
+P,6,11,8,8,8,7,5,6,5,7,6,9,6,9,8,9
+O,4,7,6,5,4,7,7,8,4,7,6,8,3,8,3,8
+H,4,7,6,5,5,8,6,6,7,7,7,6,3,9,3,7
+N,7,11,10,8,6,12,7,3,5,10,0,3,7,11,2,9
+A,3,6,5,4,2,9,2,2,2,7,1,8,2,7,3,7
+T,4,8,6,6,5,7,7,7,7,5,9,10,4,8,7,6
+C,1,1,2,1,1,6,8,6,6,8,7,12,1,9,3,10
+L,1,3,2,2,1,7,4,2,7,7,2,9,0,7,2,8
+P,2,7,4,5,2,6,11,5,4,10,8,3,1,10,4,6
+P,4,9,5,7,4,5,10,4,5,10,9,4,4,10,4,7
+J,3,5,4,7,1,12,2,9,4,14,5,13,1,6,0,8
+D,3,1,4,2,2,7,7,6,7,6,5,5,2,8,3,7
+I,0,3,0,1,0,7,7,1,7,7,6,8,0,8,2,8
+H,2,3,4,2,2,8,7,3,5,10,6,8,3,8,2,8
+T,9,11,9,8,7,7,10,2,9,11,9,5,4,11,5,5
+Y,7,9,7,7,4,3,10,2,7,11,11,7,1,11,2,5
+C,3,6,4,4,2,6,7,5,6,11,8,12,1,9,3,9
+S,4,5,6,4,6,8,8,4,5,7,7,8,4,9,9,10
+L,5,11,5,8,2,0,0,6,6,0,1,5,0,8,0,8
+N,3,2,4,4,3,7,9,5,5,7,6,6,5,9,2,6
+G,5,7,6,5,4,5,7,6,5,9,7,10,2,9,4,10
+Q,7,9,8,11,9,8,7,6,2,7,7,12,6,9,9,6
+I,1,8,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+V,4,8,6,6,3,7,11,2,3,5,11,9,2,10,1,8
+R,4,9,5,7,4,9,8,4,6,9,3,7,3,7,4,11
+N,1,3,3,1,1,9,8,3,4,10,3,5,4,8,1,8
+C,6,14,5,8,4,7,8,4,3,9,8,10,4,9,9,11
+T,4,7,5,5,4,7,8,7,7,7,8,9,3,10,5,8
+R,4,9,5,7,5,9,7,3,5,9,3,8,3,6,3,11
+Z,3,8,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+B,2,2,3,3,2,7,7,5,5,6,6,6,2,8,5,9
+T,2,2,3,3,2,7,11,2,7,7,11,8,1,11,1,8
+R,1,0,1,0,0,6,8,6,3,7,5,7,2,7,4,11
+J,2,3,4,2,1,9,6,3,5,14,6,10,0,7,0,8
+M,5,10,5,8,4,7,7,12,2,7,9,8,8,6,0,8
+X,9,13,9,7,5,4,9,3,8,12,10,9,4,9,4,5
+S,5,10,6,8,4,9,6,5,8,11,2,8,2,7,5,11
+S,3,6,4,4,2,8,7,5,8,5,6,8,0,8,9,8
+G,2,1,2,1,1,8,6,6,6,6,5,9,1,7,5,10
+B,9,14,7,8,4,9,6,6,6,11,4,9,6,7,7,10
+M,2,0,2,1,1,7,6,10,0,7,8,8,6,6,0,8
+S,3,6,4,4,2,6,5,5,9,5,6,10,0,9,9,8
+M,3,7,4,5,3,7,6,11,1,8,9,8,7,6,0,8
+L,2,6,4,4,1,5,4,1,9,7,1,9,0,7,2,7
+G,3,6,4,4,3,7,6,6,6,6,6,10,2,9,4,8
+C,7,10,5,5,2,6,10,6,7,12,8,8,2,9,5,8
+S,5,8,7,6,4,5,8,4,6,10,9,8,2,8,5,4
+C,4,10,5,8,2,5,7,7,10,7,5,14,1,9,4,9
+R,2,4,3,3,2,7,7,5,5,6,5,6,2,7,4,8
+G,6,11,8,8,9,8,7,6,2,7,6,11,5,8,9,7
+C,2,4,3,3,2,6,8,7,8,8,7,13,1,9,4,10
+I,3,8,4,6,2,7,8,0,8,14,6,6,0,8,1,7
+Y,8,11,8,8,4,2,11,3,6,12,12,7,1,11,2,5
+C,3,6,4,4,4,8,6,5,2,7,7,10,6,9,4,7
+Y,4,11,6,8,3,10,10,1,3,6,12,8,1,11,0,8
+K,4,2,5,3,3,5,7,4,8,7,6,11,3,8,5,9
+I,7,8,8,9,8,7,8,4,6,6,8,7,4,9,10,9
+E,5,9,7,7,6,8,7,6,3,7,6,10,5,9,9,8
+O,2,5,3,4,2,7,7,8,5,7,5,8,2,8,3,8
+M,5,7,7,5,6,4,7,3,4,10,10,10,6,6,2,6
+Q,4,8,5,9,5,8,7,7,2,8,7,12,3,9,6,8
+Z,3,9,4,6,3,7,7,6,11,6,6,8,1,8,8,8
+H,3,8,5,6,6,8,6,4,5,6,6,8,6,7,6,7
+Z,8,8,6,12,5,8,5,5,4,11,6,8,3,9,11,7
+H,4,9,6,7,7,7,7,5,6,7,6,8,3,8,3,8
+O,5,9,6,7,4,7,8,8,6,7,8,8,3,7,4,9
+U,5,9,5,6,4,7,5,14,5,7,11,8,3,9,0,8
+W,6,9,6,7,7,4,9,2,3,9,8,8,7,11,2,7
+L,3,8,3,6,1,0,1,5,6,0,0,6,0,8,0,8
+J,0,0,1,1,0,12,4,5,3,12,4,11,0,7,0,8
+L,5,10,7,8,5,5,5,1,9,6,2,10,3,7,4,5
+O,5,8,7,7,6,7,5,5,5,9,5,10,5,5,7,5
+K,6,11,8,8,7,6,6,4,7,6,6,11,5,7,8,10
+J,4,6,6,7,5,8,9,5,5,7,7,9,3,7,8,6
+K,3,6,4,4,4,7,9,4,4,7,5,8,4,7,6,9
+T,3,7,4,5,2,7,11,3,7,10,9,4,2,11,3,5
+G,4,10,6,8,7,7,9,6,3,5,5,11,5,7,8,7
+M,5,5,6,7,4,7,7,12,2,7,9,8,9,6,0,8
+J,2,10,3,7,1,15,2,6,6,14,0,9,0,7,0,8
+V,3,4,5,2,1,3,13,4,2,11,11,7,2,10,1,7
+T,6,8,6,6,3,6,11,2,9,12,9,4,1,11,3,4
+Y,2,1,4,2,1,6,10,2,7,8,11,8,1,11,2,7
+C,3,3,4,5,1,5,7,6,9,6,6,12,1,8,4,8
+A,3,4,5,6,2,8,5,3,1,7,1,8,2,7,2,8
+R,8,12,6,6,4,10,6,6,5,11,2,8,7,6,5,10
+M,5,9,8,7,7,12,6,2,4,9,2,6,8,6,2,8
+U,9,10,9,8,3,4,9,6,9,13,12,9,3,9,1,7
+Q,6,8,6,9,8,8,7,6,3,8,8,10,3,8,6,8
+X,3,6,5,4,3,8,7,4,9,6,6,8,3,8,6,8
+C,4,7,5,5,5,6,7,4,4,7,7,10,6,9,3,8
+Y,4,10,6,7,1,6,10,3,2,8,13,8,1,11,0,8
+L,3,6,4,4,2,4,4,4,9,2,1,7,0,7,1,6
+M,4,8,7,6,9,9,5,2,2,8,4,8,10,6,2,6
+S,1,0,1,0,0,8,7,3,5,5,6,7,0,8,6,8
+I,2,7,2,5,2,7,7,0,7,7,6,8,0,8,3,8
+J,6,7,4,11,3,6,9,3,4,13,5,5,3,8,6,9
+E,10,15,7,8,5,7,7,4,5,10,6,8,3,9,8,9
+M,5,9,8,7,10,7,6,4,2,7,4,8,13,6,3,7
+L,3,4,3,6,1,0,1,5,6,0,0,7,0,8,0,8
+T,3,8,5,6,3,7,12,4,6,8,11,7,2,12,1,7
+X,5,11,6,8,2,7,7,5,4,7,6,8,3,8,4,8
+X,5,11,6,8,2,7,7,5,4,7,6,8,3,8,4,8
+V,8,11,8,8,3,2,11,6,5,13,12,8,3,10,1,8
+D,2,4,4,2,2,9,6,4,6,10,4,6,2,8,2,9
+X,8,15,8,9,4,8,8,2,8,9,7,8,4,12,4,7
+S,3,2,4,4,3,8,7,7,5,7,7,8,2,9,9,8
+B,1,3,2,1,1,8,7,2,5,10,5,7,1,8,3,9
+E,1,3,3,2,2,6,8,2,7,11,7,9,2,8,4,9
+S,5,11,6,8,3,9,10,6,10,5,6,5,0,7,9,8
+K,5,8,8,6,5,3,8,2,6,10,11,11,3,7,3,5
+P,4,8,6,12,10,8,9,5,0,8,6,7,5,11,6,6
+Z,2,2,3,4,2,7,7,5,9,6,6,8,2,8,7,8
+R,3,5,6,3,4,8,8,3,5,9,4,7,3,6,3,11
+S,2,3,3,2,1,9,7,2,6,10,5,7,1,9,5,9
+F,2,1,3,2,1,5,11,4,5,10,9,5,1,9,3,6
+L,4,8,5,6,3,4,3,5,9,1,1,5,1,6,1,5
+N,5,9,6,7,4,8,6,9,6,4,4,4,5,7,3,7
+N,6,7,8,5,4,10,7,3,6,10,1,4,6,10,2,8
+N,1,0,1,1,0,7,7,10,0,6,6,8,4,8,0,8
+D,4,8,6,6,4,8,7,6,7,10,5,5,3,8,3,8
+M,6,10,7,8,4,8,7,13,2,6,9,8,9,6,0,8
+Y,5,10,7,8,6,8,6,7,5,5,8,8,3,8,10,6
+R,9,13,7,8,5,7,7,5,5,9,5,9,7,5,7,11
+D,6,9,8,8,8,6,8,5,7,5,3,6,5,9,8,5
+E,3,6,3,4,2,3,8,6,10,7,6,15,0,8,7,7
+R,2,0,2,1,1,7,11,8,2,7,5,8,2,7,4,10
+M,4,7,6,5,5,6,6,2,4,9,8,9,7,5,2,7
+I,6,10,8,8,5,9,5,2,6,6,7,6,0,10,4,7
+F,4,9,5,6,3,2,11,5,6,11,10,9,0,8,2,6
+P,5,10,7,8,7,6,9,3,7,9,8,5,4,10,4,7
+S,6,10,7,8,4,6,8,4,8,11,8,7,2,8,5,5
+X,3,5,4,4,4,5,8,2,4,8,7,9,2,7,7,8
+T,2,7,3,4,1,7,14,0,6,7,11,8,0,8,0,8
+R,5,10,5,8,7,6,8,8,4,7,5,7,3,8,6,12
+O,2,3,2,1,1,8,7,6,4,9,6,8,2,8,3,8
+A,4,9,6,7,3,11,2,4,3,10,2,9,3,7,3,8
+P,5,8,8,6,3,7,11,3,7,14,5,2,0,9,3,8
+X,5,8,6,7,6,7,7,2,5,7,6,8,3,10,8,7
+M,3,1,4,2,1,8,7,11,1,7,9,8,7,6,0,8
+U,3,5,5,4,4,8,6,4,4,6,6,8,4,10,1,7
+B,2,6,3,4,3,6,7,7,5,7,6,7,2,8,6,9
+Z,3,8,4,6,3,7,7,6,10,6,6,8,1,8,8,8
+G,5,8,6,6,4,6,7,5,4,9,8,9,2,7,5,9
+P,4,9,5,7,5,5,8,6,4,8,7,9,3,8,7,10
+S,6,10,9,8,11,6,7,3,2,7,5,6,3,8,11,4
+M,7,8,9,7,10,5,8,5,4,6,5,8,13,7,6,9
+E,5,5,5,8,3,3,8,6,12,7,5,15,0,8,7,6
+K,5,11,7,8,7,9,6,1,6,10,3,8,7,7,6,11
+T,3,4,5,6,1,7,15,1,5,7,11,8,0,8,0,8
+A,7,15,5,8,4,10,3,3,2,8,4,11,5,5,4,8
+S,2,6,3,4,3,7,6,7,5,7,7,8,2,9,8,7
+R,4,8,4,6,4,6,8,9,4,7,5,8,2,7,5,11
+D,3,8,4,6,6,10,7,4,5,7,6,6,4,6,9,6
+H,6,10,9,8,8,7,7,3,6,10,6,8,3,8,3,7
+G,5,9,4,4,3,9,3,5,2,9,7,10,4,9,6,8
+E,6,10,8,8,7,9,6,2,7,11,4,9,5,7,6,11
+O,5,10,5,8,5,8,6,8,4,9,5,8,3,8,3,8
+J,6,10,8,8,4,5,9,3,6,15,7,9,2,7,2,7
+C,5,8,7,7,6,5,7,3,4,7,6,11,4,10,7,10
+I,1,3,2,2,0,7,7,1,7,13,6,9,0,8,1,8
+D,4,6,5,5,4,6,6,6,7,7,6,8,4,6,5,5
+F,1,0,1,1,0,3,11,4,3,11,9,7,0,8,2,8
+U,2,3,3,2,1,4,8,4,6,11,10,9,3,9,1,7
+Q,2,3,2,3,2,8,8,5,2,8,7,10,2,9,3,8
+Q,3,7,5,5,4,8,4,7,4,6,5,7,3,8,3,9
+W,6,10,9,7,7,4,11,2,2,8,9,9,7,12,1,8
+R,4,6,5,4,4,6,7,4,6,7,6,6,6,7,4,8
+J,1,3,3,2,1,8,6,3,5,14,6,11,1,7,0,7
+Z,6,10,8,8,5,7,8,3,10,12,8,7,2,8,7,6
+C,4,9,5,8,6,5,7,3,4,7,6,11,4,10,7,10
+Q,2,3,3,3,2,8,7,6,3,6,6,9,2,8,5,9
+Q,2,2,2,2,1,7,8,4,2,8,7,9,2,9,3,9
+T,2,7,4,4,1,8,15,1,5,6,11,8,0,8,0,8
+E,3,5,3,4,3,7,7,5,7,7,6,9,2,8,5,10
+E,3,5,3,3,3,7,7,5,7,7,6,9,2,8,5,10
+P,4,7,5,5,2,6,14,5,3,12,5,1,0,10,3,7
+F,2,3,4,2,1,6,11,2,5,13,6,4,1,10,1,8
+C,4,4,5,6,2,6,6,7,11,8,5,12,1,9,4,9
+S,1,3,3,2,1,7,9,3,7,10,7,6,1,8,4,6
+S,3,6,4,4,3,7,6,7,5,7,7,9,2,9,8,7
+N,3,2,4,4,3,7,8,5,5,7,7,6,5,10,2,5
+T,6,8,6,6,3,7,11,3,8,11,9,4,2,12,3,4
+A,1,3,2,2,1,9,3,2,1,8,2,9,1,6,1,7
+X,3,2,4,3,2,8,7,3,9,6,6,8,2,8,6,8
+W,5,7,7,5,3,4,8,5,1,7,9,8,8,10,0,8
+V,3,6,5,4,5,8,5,5,2,7,7,7,4,9,4,6
+F,3,6,4,4,2,6,11,2,6,14,6,4,1,10,2,8
+D,2,2,3,3,3,7,7,6,6,7,6,5,2,8,3,7
+Q,4,9,5,8,3,9,8,8,6,5,8,9,3,8,5,9
+H,1,1,2,1,1,7,7,12,1,7,6,8,3,8,0,8
+O,4,6,6,5,4,6,6,5,5,8,4,8,3,7,5,6
+V,4,6,4,4,2,5,11,3,4,9,11,7,2,10,1,8
+T,3,8,5,6,1,7,15,1,5,7,11,8,0,8,0,8
+U,3,6,4,4,1,7,4,14,5,7,13,8,3,9,0,8
+Y,2,7,3,5,2,5,10,2,2,8,12,8,1,11,0,8
+G,1,0,2,0,1,8,7,5,5,6,6,9,1,7,5,10
+H,4,7,6,10,7,8,9,5,1,8,6,6,5,11,10,6
+U,2,1,2,1,1,8,5,11,4,6,13,8,3,10,0,8
+I,3,10,4,8,2,7,7,0,8,13,6,8,0,8,1,8
+L,4,10,5,8,3,0,2,4,6,1,0,8,0,8,0,8
+P,4,7,5,5,4,8,9,4,4,11,5,5,3,10,3,7
+L,4,10,6,7,8,7,7,3,5,6,7,10,6,10,7,4
+N,3,7,4,5,2,7,7,14,2,5,6,8,5,8,0,8
+W,7,10,7,8,8,5,10,3,3,9,7,7,8,11,3,6
+F,5,10,5,7,3,0,13,3,3,11,9,6,0,8,2,6
+A,6,14,6,8,4,12,2,3,2,12,4,11,4,4,4,11
+G,5,10,6,8,5,7,7,7,6,6,5,9,2,8,6,11
+Y,4,7,6,5,2,9,11,1,7,3,11,8,1,11,2,9
+L,5,10,7,7,3,6,4,1,10,8,2,11,0,7,3,7
+M,4,1,5,3,3,8,6,6,5,6,7,8,8,5,2,7
+O,2,4,3,2,1,8,7,7,5,7,6,8,2,8,3,8
+G,4,7,5,5,4,6,7,6,4,5,7,9,2,7,4,9
+Y,3,5,4,4,2,4,10,1,8,10,10,6,1,10,3,4
+M,3,3,5,2,3,9,6,3,4,9,5,7,6,5,1,8
+A,3,6,5,4,3,11,2,2,2,9,2,9,2,6,3,8
+P,4,8,4,5,2,3,14,8,1,11,7,3,1,10,4,8
+U,4,8,4,6,3,7,6,12,4,7,12,8,3,9,0,8
+F,2,3,4,2,1,6,10,3,5,13,6,5,1,9,2,7
+A,3,6,5,4,1,7,5,3,1,6,1,8,2,7,2,7
+P,1,3,2,1,1,5,10,3,4,10,8,5,0,9,3,7
+H,3,4,4,5,2,7,9,15,2,7,3,8,3,8,0,8
+A,4,10,7,7,5,7,5,2,3,5,2,6,3,7,4,4
+F,4,9,5,6,2,1,15,5,3,12,9,4,0,8,2,6
+G,2,1,2,1,1,8,6,6,6,6,5,9,1,7,5,10
+X,11,14,10,8,4,8,7,2,10,9,6,8,4,8,4,8
+S,9,15,8,9,4,11,2,2,5,10,2,9,3,7,4,12
+K,5,8,7,6,5,5,7,1,7,10,8,10,3,8,4,7
+D,4,4,5,6,3,5,6,10,9,5,5,5,3,8,4,8
+J,4,5,5,6,4,9,8,5,4,6,5,8,3,8,9,8
+T,7,9,7,7,5,6,12,5,6,11,9,4,3,13,3,4
+P,3,3,5,2,2,7,10,3,4,12,4,3,1,9,3,8
+K,4,8,6,6,5,5,8,1,6,9,7,9,3,8,3,8
+A,2,7,4,5,2,12,2,4,3,11,2,9,2,6,3,9
+A,3,4,6,6,2,9,3,3,3,8,2,9,3,6,3,9
+C,4,7,5,5,3,6,7,6,9,8,4,10,1,10,4,10
+M,2,3,4,2,2,6,6,3,3,9,8,9,5,5,1,8
+V,3,4,4,3,1,4,12,4,3,10,11,7,2,10,1,8
+M,5,8,7,6,8,7,7,7,5,7,5,8,7,9,8,6
+J,2,6,2,4,1,15,3,3,5,12,1,8,0,8,0,8
+O,3,7,4,5,2,7,8,8,7,7,7,8,3,8,4,8
+S,5,10,7,8,5,10,6,4,6,10,3,7,2,8,5,10
+N,3,5,4,7,3,7,7,14,2,5,6,8,6,8,0,8
+L,5,11,6,9,4,4,4,1,9,6,1,10,0,6,3,6
+V,2,5,4,4,2,6,12,2,3,8,11,8,2,10,1,8
+H,3,3,3,4,2,7,8,14,1,7,5,8,3,8,0,8
+Z,3,5,4,7,2,7,7,4,14,10,6,8,0,8,8,8
+J,2,7,3,5,1,13,2,8,4,13,4,12,1,6,0,8
+K,11,15,10,8,4,7,8,3,8,9,7,8,6,8,4,7
+X,6,8,9,6,4,6,8,2,9,10,9,8,3,8,4,7
+C,7,10,7,7,4,6,7,6,8,13,8,12,3,11,5,5
+D,3,6,3,4,3,5,7,8,6,7,7,6,2,8,3,8
+E,4,10,4,8,5,2,8,5,9,7,7,14,0,8,6,9
+M,5,9,8,7,6,5,7,3,4,10,9,9,8,6,3,8
+A,7,13,7,7,4,12,3,6,2,12,2,10,5,3,4,10
+M,6,9,8,6,8,7,7,6,5,6,7,9,8,6,2,8
+C,3,7,4,5,2,5,8,6,7,7,6,12,1,9,4,10
+J,3,10,4,8,1,12,2,10,4,14,4,13,1,6,0,8
+J,2,5,4,3,2,9,5,4,5,14,6,11,1,6,0,7
+L,4,10,4,8,1,0,1,6,6,0,0,6,0,8,0,8
+Q,3,4,4,5,4,8,8,7,2,5,7,9,3,8,5,9
+M,4,3,4,4,3,7,7,12,1,7,9,8,8,6,0,8
+Z,2,3,4,2,2,7,8,2,9,12,6,8,1,9,5,8
+Q,6,7,8,6,6,7,4,4,5,7,4,9,5,5,6,7
+N,5,6,6,6,6,7,7,4,3,7,5,7,6,9,5,5
+V,2,3,3,1,1,4,12,3,2,10,11,7,2,11,1,7
+B,3,6,4,4,3,8,6,6,7,6,6,6,2,8,7,10
+K,5,7,8,5,5,9,5,1,6,9,3,8,4,7,4,10
+Q,6,12,6,6,4,11,4,4,6,12,3,9,3,9,7,12
+A,3,7,5,5,3,11,2,2,2,9,2,9,3,6,3,9
+R,4,8,6,6,4,7,8,6,6,6,5,8,4,6,7,9
+I,1,1,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+M,6,8,9,6,9,10,6,3,3,9,4,7,9,8,3,6
+H,6,11,6,8,3,7,6,15,0,7,7,8,3,8,0,8
+D,4,6,6,4,4,7,7,6,5,7,6,6,4,8,3,7
+D,2,4,4,3,2,8,7,5,6,9,5,5,2,8,3,7
+H,3,4,4,3,3,7,8,5,7,7,6,8,6,8,4,8
+R,3,3,4,5,2,5,11,8,4,7,3,9,3,7,6,11
+Z,4,7,5,5,3,7,8,2,9,11,7,8,1,8,6,7
+Q,4,7,5,6,3,7,6,8,6,6,7,7,3,8,5,9
+B,4,9,5,6,4,6,7,8,7,7,6,7,2,8,9,10
+G,2,4,3,3,2,6,7,5,5,9,7,10,2,8,4,9
+B,1,0,2,1,1,7,8,7,5,7,6,7,1,8,6,8
+C,4,5,5,7,2,5,7,7,10,7,6,13,1,8,4,8
+K,8,15,8,8,5,3,8,4,6,10,11,11,5,11,4,7
+C,8,13,5,8,2,8,6,7,7,12,5,9,2,10,5,9
+W,4,7,5,5,5,7,7,6,2,7,8,8,5,8,3,9
+Q,3,7,4,6,2,8,6,8,6,6,4,8,3,8,4,8
+U,6,10,6,5,3,7,6,5,4,6,7,7,5,6,3,6
+X,5,8,8,6,5,10,6,1,8,10,2,7,4,9,4,10
+D,4,2,5,3,3,7,7,6,7,6,6,5,5,8,3,7
+F,6,7,8,8,8,7,9,4,5,7,7,6,5,9,9,9
+Z,5,9,7,6,5,7,8,2,9,12,6,8,1,9,6,8
+K,7,9,10,7,7,2,9,2,7,10,11,11,5,7,4,4
+S,2,3,3,2,2,8,7,6,4,7,6,8,2,8,9,8
+O,6,11,7,9,5,8,7,9,6,7,5,10,4,8,5,5
+X,10,12,9,7,4,8,7,2,9,9,6,8,4,11,4,8
+N,3,7,4,5,3,7,7,12,1,6,6,8,5,8,0,8
+Q,3,4,4,5,3,7,8,5,2,8,9,10,2,9,5,9
+J,6,11,7,8,3,9,5,3,7,15,4,10,0,6,1,7
+J,3,9,4,6,2,9,5,3,6,14,4,9,0,7,1,7
+H,6,9,8,7,7,7,7,7,5,6,5,7,3,7,7,10
+O,4,6,5,4,2,7,7,8,8,7,6,8,3,8,4,8
+B,4,6,6,4,5,9,8,3,6,7,6,8,6,8,6,9
+P,1,0,2,0,0,5,10,7,2,9,6,5,1,9,3,8
+N,6,10,9,8,6,11,8,3,5,10,1,4,7,11,2,8
+E,2,4,2,3,2,7,7,5,7,7,6,8,2,8,5,10
+I,7,13,6,7,3,12,5,2,6,12,3,6,2,10,4,12
+L,1,3,3,2,1,6,4,1,7,7,2,10,0,7,2,8
+H,4,8,4,5,2,7,7,15,1,7,6,8,3,8,0,8
+H,3,5,5,3,3,8,6,3,5,10,6,9,3,7,3,8
+M,1,0,2,0,1,7,6,9,0,7,8,8,5,6,0,8
+H,6,11,6,6,3,8,8,3,4,9,6,7,6,9,5,9
+X,1,0,1,0,0,8,7,3,5,7,6,8,2,8,3,7
+U,9,10,7,5,3,5,3,5,5,3,7,7,5,8,2,7
+I,5,11,6,8,4,9,6,0,8,13,5,9,0,8,1,9
+X,6,10,9,7,5,7,7,0,8,10,6,8,3,8,3,8
+C,2,6,3,4,2,7,8,8,7,10,6,11,2,11,4,9
+B,2,3,2,2,2,7,7,5,5,7,6,6,2,8,5,9
+D,2,3,3,2,2,7,7,6,7,7,6,4,2,8,3,7
+V,3,2,6,4,2,7,12,2,3,6,11,9,4,12,2,7
+K,4,9,5,6,5,6,5,4,4,6,6,9,3,6,8,10
+K,4,8,6,6,7,7,7,3,4,6,6,8,7,7,7,7
+B,4,11,6,8,8,8,8,6,6,7,6,5,2,8,6,9
+Q,4,9,4,4,2,11,4,4,5,12,3,8,2,7,6,12
+T,6,9,6,7,3,5,11,2,10,12,9,4,0,10,3,4
+H,3,4,6,3,3,8,7,3,6,10,5,8,3,8,3,7
+L,5,11,7,8,5,5,3,6,8,2,2,4,1,6,1,5
+W,4,11,7,8,8,10,11,2,2,5,8,7,9,12,2,8
+R,5,9,7,7,6,7,8,5,7,7,5,6,3,7,5,8
+Y,2,7,4,5,2,5,9,1,6,9,12,9,1,11,2,7
+A,3,3,5,4,1,8,6,3,1,7,1,8,2,7,1,8
+U,8,10,9,8,6,3,9,5,8,10,10,10,3,9,2,6
+Z,3,8,4,6,4,7,8,5,9,7,6,9,1,9,7,7
+D,5,8,7,6,6,8,8,6,6,9,6,4,6,10,5,7
+J,6,11,8,9,3,8,7,3,7,15,5,10,1,6,1,7
+X,4,9,6,7,6,7,8,2,6,7,7,9,4,10,6,7
+S,4,5,6,4,5,8,7,5,5,7,6,8,5,8,9,11
+O,8,15,5,8,3,7,9,6,6,9,6,6,4,10,5,9
+V,3,5,6,4,2,6,13,3,3,8,11,8,3,10,1,8
+C,5,8,7,6,6,6,5,4,4,9,6,12,6,8,4,9
+H,3,5,5,7,4,8,12,3,2,8,8,7,3,10,7,6
+R,2,3,4,2,2,8,7,3,4,9,4,6,2,7,3,9
+M,6,8,9,7,10,6,8,5,3,6,5,8,13,9,5,8
+T,3,10,5,8,5,7,11,4,5,7,11,8,3,12,1,8
+Y,1,1,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+Y,2,4,3,3,1,3,12,3,6,12,10,5,1,11,2,5
+J,2,6,3,4,1,13,2,8,4,14,4,12,0,7,0,8
+F,2,7,3,5,1,1,12,4,4,12,10,7,0,8,2,6
+J,5,9,6,7,3,9,5,4,6,15,5,11,1,6,0,7
+C,5,11,6,9,3,4,9,7,8,13,11,12,2,9,3,7
+G,1,0,2,0,1,8,6,5,5,6,5,9,1,8,5,10
+Q,6,7,8,6,6,7,4,5,6,7,4,8,5,4,6,7
+P,3,8,4,6,2,3,14,8,1,11,7,3,1,10,4,8
+Q,2,2,3,2,2,8,7,6,4,6,5,9,2,9,3,9
+D,4,9,6,7,9,8,8,5,4,7,6,5,6,8,8,5
+V,7,12,6,6,3,9,10,5,4,6,10,6,5,12,3,7
+G,5,9,4,4,3,7,6,3,3,8,6,8,4,9,8,6
+Y,2,1,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+L,3,6,3,4,1,0,1,6,6,0,1,5,0,8,0,8
+N,5,11,5,9,6,7,7,13,1,6,6,8,5,9,0,7
+V,4,6,5,4,3,9,11,3,1,4,10,9,3,11,4,9
+C,2,1,2,2,0,6,7,6,9,7,6,15,0,8,4,10
+I,1,4,2,3,1,7,7,1,8,13,6,8,0,8,1,8
+Y,2,6,3,4,0,6,10,2,2,8,12,8,1,10,0,8
+O,4,7,5,5,3,7,7,8,5,8,7,10,3,8,3,7
+M,6,7,9,6,9,5,9,5,3,6,4,8,13,6,5,8
+E,4,10,5,8,3,3,7,6,11,7,6,15,0,8,7,6
+I,1,5,2,3,1,7,7,0,7,13,6,8,0,8,1,8
+C,5,7,5,5,3,3,8,5,7,11,10,13,2,9,3,7
+E,4,7,6,5,4,5,8,5,8,12,10,9,3,8,5,5
+I,7,12,5,6,2,10,5,6,4,13,3,8,3,8,5,10
+E,2,4,4,3,2,7,7,2,7,11,6,8,2,8,4,9
+X,1,0,1,0,0,8,7,3,4,7,6,8,2,8,4,8
+X,4,2,6,4,3,7,7,3,10,6,6,8,2,8,6,8
+G,3,5,4,4,2,6,7,5,5,9,7,10,2,8,4,9
+E,3,6,4,4,3,7,7,6,9,7,7,9,3,8,6,8
+J,3,7,4,5,2,9,4,5,4,14,6,12,0,6,1,7
+D,3,5,4,4,2,8,7,7,7,6,6,3,2,8,3,7
+S,4,10,5,7,3,6,8,5,8,11,8,7,2,9,5,5
+Z,4,9,6,6,4,8,7,2,9,11,5,9,1,8,6,8
+W,7,10,10,8,14,9,7,5,2,7,7,8,13,10,4,6
+M,4,3,4,5,3,7,7,12,1,7,9,8,8,6,0,8
+L,4,8,5,6,3,3,4,2,8,2,1,8,0,7,1,6
+R,3,9,3,6,4,5,9,8,3,7,5,8,2,7,5,11
+H,4,7,6,5,4,7,8,3,6,10,7,8,3,8,3,8
+D,3,7,3,5,3,6,7,9,7,6,5,6,2,8,3,7
+S,2,4,4,3,2,7,7,2,7,10,6,8,1,9,5,8
+Y,3,10,5,7,1,8,11,1,3,6,12,8,1,11,0,8
+N,3,3,4,4,2,7,7,14,2,5,6,8,6,8,0,8
+Y,4,4,5,6,7,8,8,3,2,7,8,9,4,11,7,7
+R,3,9,4,6,4,6,8,8,4,7,5,8,2,7,5,11
+D,2,4,4,3,2,8,7,4,6,10,5,6,2,8,3,8
+O,3,4,4,6,2,7,6,9,6,6,5,6,3,8,4,8
+G,3,7,4,5,2,7,6,8,7,6,6,8,2,8,6,11
+H,9,15,10,8,7,8,7,3,5,10,4,7,7,6,6,7
+Y,6,10,8,8,7,9,7,7,4,6,9,7,3,9,9,4
+M,7,10,9,8,8,8,6,6,5,6,8,8,9,6,2,7
+P,9,10,7,5,3,6,12,6,4,13,5,3,4,10,4,8
+H,3,4,5,6,4,9,12,3,2,8,8,7,3,10,6,7
+V,6,9,5,4,2,7,10,7,3,9,9,5,5,12,3,9
+B,5,10,7,7,6,8,8,6,8,7,6,6,6,8,6,10
+X,3,8,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+O,3,3,4,2,2,7,8,7,5,7,7,8,2,8,3,8
+K,4,11,5,8,2,3,7,8,2,7,5,11,3,8,2,11
+G,1,0,2,1,1,8,6,6,5,6,5,9,1,8,5,10
+T,3,7,5,5,3,7,11,1,8,7,11,8,1,10,1,8
+K,2,4,3,2,2,5,7,4,6,7,6,11,3,8,4,9
+H,3,7,4,4,2,7,8,14,1,7,6,8,3,8,0,8
+G,3,7,5,5,5,7,9,6,3,6,6,10,3,7,7,8
+B,4,4,5,6,4,6,6,9,7,6,6,7,2,8,9,9
+V,4,9,6,7,2,7,8,4,3,7,14,8,3,9,0,8
+T,4,9,6,8,6,6,8,4,8,8,7,8,3,9,8,7
+N,5,5,6,7,3,7,7,15,2,4,6,8,6,8,0,8
+U,3,3,3,2,1,5,8,5,7,9,8,8,3,9,2,5
+Z,4,6,6,4,3,6,9,3,9,11,8,6,1,9,6,6
+K,1,0,1,0,0,5,8,7,0,7,6,10,3,8,2,11
+H,8,13,8,7,4,10,8,4,6,9,2,5,6,7,4,9
+I,1,3,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+A,2,1,3,2,1,8,2,2,1,7,2,8,2,7,2,7
+H,4,8,6,6,8,7,6,5,3,6,6,8,7,7,9,9
+G,4,8,5,6,2,8,6,8,8,7,5,12,2,8,5,10
+O,8,13,6,8,3,7,7,5,5,8,4,7,5,9,5,8
+E,1,1,2,2,1,4,7,5,8,7,6,13,0,8,6,9
+X,4,8,7,6,4,4,8,2,8,10,12,10,3,8,4,5
+J,4,10,5,7,3,8,6,3,6,14,4,9,0,6,1,7
+O,2,4,3,3,2,7,7,6,4,9,7,7,2,8,3,8
+X,1,1,2,2,1,7,7,3,8,6,6,8,2,8,5,8
+V,4,4,6,7,1,8,8,4,3,7,14,8,3,9,0,8
+C,5,10,5,8,3,6,8,7,7,13,7,9,2,11,3,7
+M,5,5,6,4,4,8,6,6,5,6,7,7,10,6,4,6
+Q,4,6,5,8,5,7,9,5,3,8,9,9,4,10,6,7
+K,3,1,4,2,2,6,7,4,7,7,6,10,3,8,4,9
+W,2,0,2,1,1,7,8,3,0,7,8,8,6,9,0,8
+R,2,3,3,2,2,9,6,3,4,10,4,7,2,7,3,10
+G,3,9,5,6,3,6,7,7,6,5,7,9,2,7,4,9
+S,7,10,8,8,5,7,7,4,6,9,8,9,2,11,5,6
+O,4,6,6,4,3,7,6,8,5,8,5,11,4,8,4,7
+Y,3,10,5,7,3,7,10,2,6,6,12,9,2,11,2,8
+P,5,4,5,6,3,4,13,8,2,10,6,3,1,10,4,8
+T,3,4,3,3,1,5,12,3,6,11,9,5,1,11,1,5
+R,4,6,6,4,4,9,7,4,5,9,3,7,3,7,4,11
+H,6,10,6,6,4,5,8,3,4,10,9,9,6,10,5,8
+E,6,9,8,7,7,8,6,6,2,7,6,9,4,8,8,10
+B,3,7,5,5,3,9,7,4,6,10,5,6,2,8,6,9
+F,3,4,3,3,2,5,11,3,6,11,9,5,1,10,3,6
+N,5,10,5,7,3,7,7,15,2,4,6,8,6,8,0,8
+H,3,4,3,5,2,7,7,14,1,7,6,8,3,8,0,8
+H,5,9,8,7,5,6,8,3,6,10,8,9,3,8,3,7
+L,3,7,4,5,2,6,4,2,8,7,2,10,0,7,2,8
+Q,5,7,7,11,10,9,10,5,0,5,7,10,6,13,6,12
+I,1,3,2,2,0,7,8,1,6,13,6,7,0,8,0,7
+F,3,9,4,6,2,1,13,5,4,12,10,7,0,8,2,6
+D,3,6,5,4,3,9,7,4,5,10,4,5,3,8,2,8
+B,5,9,4,5,3,7,7,5,5,10,6,9,5,7,7,9
+D,2,4,4,3,2,8,7,4,6,9,5,5,2,8,3,7
+A,1,3,2,2,1,10,2,2,1,9,2,9,1,6,2,8
+W,4,8,7,6,5,7,10,2,3,7,9,8,8,11,1,8
+D,7,11,9,8,8,7,8,7,6,8,7,6,7,7,3,7
+D,3,5,4,4,3,7,7,7,6,7,6,5,2,8,3,7
+T,3,6,4,5,4,6,7,3,8,8,7,10,3,7,7,6
+W,5,6,5,4,4,4,10,2,3,9,9,7,7,11,2,6
+E,3,2,3,3,3,7,7,5,7,7,5,9,2,8,5,10
+Z,3,9,5,7,5,8,6,3,7,7,6,8,1,7,11,9
+Y,3,8,5,6,2,5,10,3,2,8,12,8,1,11,0,8
+U,6,9,8,7,10,9,8,4,5,5,8,8,10,7,8,6
+J,6,8,8,9,7,8,9,5,5,7,7,9,4,6,9,6
+E,8,15,6,8,5,8,6,5,5,11,5,10,3,8,7,11
+W,6,5,7,4,3,3,10,3,3,10,10,8,7,10,1,7
+Y,6,8,8,10,10,10,10,6,3,6,7,7,6,11,8,3
+I,1,7,0,5,1,7,7,5,3,7,6,8,0,8,0,8
+J,3,9,4,7,3,10,6,0,8,11,3,6,0,7,1,7
+I,1,4,2,3,0,7,8,0,7,13,6,8,0,8,0,8
+P,8,15,7,8,4,6,9,6,4,13,5,5,4,10,4,8
+N,4,9,6,6,4,8,9,9,6,8,5,5,3,7,3,7
+H,3,9,4,6,2,7,8,15,1,7,4,8,3,8,0,8
+P,11,13,8,7,4,6,12,6,5,14,6,2,4,10,4,8
+Y,6,9,6,7,4,5,9,0,8,8,9,5,1,11,4,5
+E,3,7,3,5,2,3,7,6,11,7,7,15,0,8,6,7
+S,4,6,5,6,6,8,8,5,4,7,7,8,5,11,9,10
+T,4,9,5,7,5,7,11,4,6,7,11,8,2,12,1,7
+M,6,11,7,8,7,8,6,11,1,7,8,8,9,4,1,8
+L,2,6,2,4,0,0,2,5,6,0,0,7,0,8,0,8
+V,2,0,3,1,0,7,9,4,2,7,13,8,2,10,0,8
+B,4,11,6,8,8,7,7,6,5,7,6,6,3,8,6,10
+V,2,3,2,1,1,5,11,2,2,9,10,7,1,11,1,7
+S,4,9,5,7,3,8,6,6,9,5,6,8,0,9,9,8
+Q,6,13,5,7,3,8,4,4,7,10,4,9,3,8,8,10
+S,3,4,5,3,2,8,7,2,7,10,5,8,1,9,5,8
+O,5,9,6,7,5,7,8,8,4,6,7,9,3,7,4,7
+E,1,0,1,1,1,5,7,5,8,7,6,12,0,8,6,9
+A,2,6,4,4,1,8,5,3,1,7,1,8,2,7,2,8
+T,3,3,4,2,1,5,11,3,7,11,9,4,1,10,2,5
+G,2,1,3,2,2,6,7,6,6,6,6,10,2,9,3,9
+R,4,11,6,8,6,6,7,6,6,6,5,8,3,6,6,9
+H,4,7,4,4,2,7,10,14,2,7,3,8,3,8,0,8
+M,8,9,11,7,9,6,8,3,4,9,9,9,9,8,3,8
+D,4,7,6,5,3,9,6,4,8,11,4,6,3,8,3,9
+X,3,7,5,5,4,7,7,3,8,5,6,8,2,8,6,8
+C,6,11,6,8,3,4,8,6,8,12,10,13,1,9,3,7
+S,3,7,4,5,3,8,8,5,7,5,6,8,0,8,8,8
+P,5,10,7,8,6,7,10,5,4,12,5,3,1,10,3,8
+P,4,8,6,6,4,6,9,7,6,9,7,4,2,10,4,6
+J,0,0,1,0,0,11,4,5,3,12,4,10,0,7,0,8
+R,5,11,7,8,6,6,8,5,6,6,5,7,3,6,6,9
+E,7,11,4,6,2,8,7,5,8,10,6,9,2,10,7,9
+J,2,10,3,7,3,8,6,2,4,11,5,10,1,6,2,6
+Q,2,3,3,5,3,8,8,6,1,5,7,10,3,9,5,10
+V,7,12,5,6,3,8,10,5,5,7,10,5,5,12,3,7
+O,2,6,3,4,2,7,7,6,3,7,6,8,3,8,2,8
+G,2,4,3,3,2,6,7,5,4,9,7,10,2,9,4,10
+P,5,7,6,5,5,6,9,6,4,8,7,9,2,9,7,10
+I,0,3,0,2,0,9,7,2,6,7,6,7,0,8,1,7
+G,3,2,5,3,3,7,7,6,6,6,7,9,2,8,4,8
+D,3,4,4,3,2,7,7,7,7,7,6,5,2,8,3,7
+U,6,9,8,6,6,7,8,8,6,5,7,11,4,8,5,6
+D,5,8,7,7,6,6,7,5,7,7,5,7,4,7,6,5
+A,1,0,2,0,0,8,4,2,0,7,2,8,1,6,1,8
+U,1,0,1,0,0,7,7,10,4,7,12,8,3,10,0,8
+V,3,4,5,3,2,8,12,2,3,6,11,9,2,10,1,8
+D,5,9,6,7,3,6,8,11,10,8,7,6,3,8,4,8
+A,3,6,5,4,2,11,2,4,2,10,2,10,2,7,3,8
+U,7,11,6,6,4,6,6,5,5,7,8,9,5,8,3,9
+M,4,7,4,5,3,7,7,12,1,7,9,8,8,6,0,8
+X,7,10,7,5,4,6,9,3,7,11,10,8,4,14,4,6
+P,5,11,7,8,5,8,8,1,6,13,6,5,1,9,3,9
+Z,4,5,6,8,5,11,4,2,5,8,3,6,1,8,6,9
+J,6,8,7,9,7,8,7,4,6,6,6,7,4,9,10,9
+X,7,15,8,8,5,10,5,3,8,11,2,8,4,5,4,9
+G,4,8,5,6,3,7,7,7,7,11,6,11,2,9,4,9
+C,2,2,3,4,2,6,8,7,7,8,8,13,1,9,4,10
+R,4,5,7,4,6,7,7,3,4,7,5,8,6,9,5,7
+B,3,7,5,5,5,7,8,7,6,7,5,7,2,7,6,10
+T,3,5,4,4,3,7,11,3,7,7,11,8,2,11,1,8
+O,3,7,4,5,2,7,6,8,8,7,4,8,3,8,4,8
+G,5,8,7,7,7,7,8,6,3,7,7,9,7,10,8,8
+N,6,12,7,6,3,7,7,2,3,12,5,8,5,8,0,7
+K,3,4,5,3,3,6,8,1,7,10,7,10,3,8,2,7
+N,5,9,7,6,4,7,9,6,5,7,6,7,7,9,3,7
+S,3,4,3,3,2,8,7,7,5,7,6,8,2,9,9,8
+K,4,2,5,3,3,5,7,4,8,7,6,11,3,8,5,9
+A,4,12,7,8,3,7,4,3,2,6,1,8,3,7,3,7
+I,3,10,5,7,2,7,7,0,9,14,6,8,0,8,1,8
+I,1,6,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+J,5,6,6,7,5,8,9,4,5,7,6,8,3,8,8,8
+O,3,4,4,3,2,8,6,7,4,9,5,8,2,8,3,8
+C,3,4,4,6,1,5,6,7,9,6,5,13,1,8,4,9
+L,2,5,4,4,2,7,4,1,8,8,2,10,0,7,2,8
+T,3,7,4,5,2,6,12,2,7,8,11,8,1,11,1,7
+K,5,10,7,7,6,6,7,4,7,6,6,9,7,8,5,9
+P,6,9,8,7,6,5,14,6,2,12,6,2,1,10,3,7
+U,6,7,7,5,4,4,8,5,7,9,8,9,3,9,3,5
+P,4,10,6,7,6,7,6,7,4,7,6,8,3,8,7,10
+T,6,13,5,7,2,6,9,3,7,13,6,6,2,8,4,4
+C,3,2,4,4,2,5,8,7,7,9,8,13,1,9,4,10
+N,2,3,3,2,2,7,9,6,4,8,6,7,4,8,1,7
+H,4,2,5,3,4,7,7,6,6,7,6,8,3,8,3,9
+K,5,11,6,8,2,4,5,9,2,7,7,12,4,7,3,11
+F,4,8,6,9,8,7,9,4,4,8,6,7,4,9,8,8
+C,4,7,5,5,2,7,7,6,7,12,7,11,2,10,3,8
+F,5,11,6,8,6,6,9,4,7,10,9,6,2,9,4,6
+L,4,9,5,4,3,9,4,3,4,12,7,11,3,10,4,10
+Y,4,7,4,5,2,4,9,2,6,10,11,6,1,11,2,5
+S,7,11,9,8,11,8,6,5,3,8,6,8,5,7,11,8
+U,3,8,5,6,3,6,8,8,9,9,9,8,3,9,1,8
+N,1,1,2,2,1,7,7,11,1,5,6,8,4,8,0,8
+Z,4,8,5,6,3,8,6,2,10,11,4,9,2,8,6,9
+O,2,1,3,2,2,8,7,7,4,7,6,8,2,8,3,8
+P,6,9,5,5,2,7,9,5,3,12,4,5,4,9,4,8
+J,3,10,4,8,2,14,3,5,5,13,1,9,0,7,0,8
+O,4,9,6,7,3,8,7,9,8,7,5,8,3,8,4,8
+Z,2,4,4,2,2,7,7,2,9,12,6,8,1,8,5,8
+X,4,4,6,3,3,7,6,1,9,11,7,9,3,7,3,7
+H,5,10,7,8,8,7,7,6,7,7,6,9,3,8,4,8
+X,5,9,6,6,1,7,7,5,4,7,6,8,3,8,4,8
+H,5,6,7,4,5,5,9,3,6,10,9,9,3,9,3,6
+K,3,7,3,5,2,5,7,7,2,6,5,11,3,8,2,11
+D,5,11,6,8,7,10,6,3,6,10,3,6,3,8,3,9
+T,4,9,5,7,4,9,11,3,7,5,11,8,2,12,1,8
+A,4,11,6,8,4,8,3,2,3,6,1,8,2,7,3,7
+H,4,5,5,3,3,7,7,6,6,7,6,8,3,8,3,8
+Q,2,3,3,3,2,8,9,5,2,5,8,10,2,9,5,9
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+P,8,11,7,6,4,8,9,4,4,12,4,4,4,10,5,7
+F,6,10,8,8,9,7,6,6,4,8,7,8,4,10,8,11
+K,1,0,1,0,0,4,6,5,1,7,6,10,2,7,1,10
+H,1,0,2,0,0,7,8,11,1,7,6,8,2,8,0,8
+E,3,6,3,4,2,3,8,6,10,7,5,14,0,8,7,7
+A,2,4,4,3,2,9,2,2,1,8,2,9,2,7,2,8
+C,7,11,8,8,5,4,8,6,7,12,9,11,2,11,3,7
+H,7,12,8,6,5,11,6,3,5,10,4,6,5,9,4,8
+I,1,10,0,8,1,7,7,5,3,7,6,8,0,8,0,8
+J,1,7,2,5,1,9,6,2,7,11,4,8,0,7,1,6
+Y,9,9,7,13,5,7,11,2,3,9,10,5,4,10,6,8
+G,3,5,4,3,2,6,7,5,5,9,7,10,2,8,4,9
+X,5,10,6,7,2,7,7,5,4,7,6,8,3,8,4,8
+T,2,6,4,4,1,8,15,1,5,6,11,8,0,8,0,8
+D,3,7,5,5,4,9,7,3,5,10,4,6,3,8,2,8
+Q,5,8,5,9,5,8,6,7,2,8,7,12,3,8,6,7
+Y,3,8,5,6,1,6,9,3,1,8,13,8,2,11,0,8
+O,4,7,4,5,4,7,8,7,4,9,7,8,3,8,3,8
+B,5,9,7,7,5,8,8,4,7,10,5,5,2,8,6,10
+E,3,5,5,3,2,6,7,1,8,11,6,9,2,8,4,8
+Z,3,3,4,5,2,7,7,4,14,9,6,8,0,8,8,8
+X,7,15,8,8,5,11,7,2,8,11,4,6,3,11,4,9
+G,2,2,4,3,2,6,7,6,6,7,6,10,2,8,4,9
+M,6,10,8,8,10,7,6,7,4,6,5,8,8,8,8,9
+U,4,7,5,5,2,7,4,14,5,7,14,8,3,9,0,8
+X,4,9,7,6,4,7,7,0,8,9,6,8,2,8,3,7
+W,3,2,4,3,3,8,11,2,2,6,8,8,6,11,0,8
+M,2,3,4,2,2,8,6,3,4,9,6,8,6,5,1,7
+T,3,4,4,3,2,5,12,3,7,11,9,4,1,11,2,5
+B,2,3,4,1,2,8,7,2,5,10,5,6,1,8,4,9
+J,1,6,2,4,1,14,2,6,5,13,1,9,0,7,0,8
+I,1,3,2,2,1,7,8,1,7,13,6,7,0,8,1,7
+L,2,6,3,4,2,3,4,3,8,2,1,8,0,7,1,6
+F,3,9,5,6,3,4,11,2,6,11,10,6,1,10,3,5
+L,3,7,4,5,3,5,5,2,8,7,2,9,1,7,3,7
+N,4,9,4,6,4,8,7,12,1,6,6,8,5,9,0,8
+J,3,7,4,5,2,9,6,1,6,11,4,7,0,7,1,7
+E,4,6,6,4,4,6,8,3,7,11,8,9,3,9,4,7
+B,3,5,5,3,3,9,7,3,6,10,5,6,2,8,5,10
+G,1,0,2,0,0,8,6,5,4,6,5,9,1,8,5,10
+Y,3,9,6,6,1,5,11,3,2,10,12,7,1,11,0,8
+H,2,3,4,2,2,6,8,2,5,10,7,8,3,8,2,7
+B,6,11,8,8,7,9,7,4,7,10,4,6,3,8,6,10
+Y,7,9,5,13,4,5,11,2,4,11,10,6,4,11,6,7
+A,3,9,5,6,3,9,3,2,3,7,1,8,2,6,2,7
+R,1,0,2,1,1,6,10,7,2,7,5,8,2,7,4,10
+R,3,4,3,5,2,5,11,7,4,7,3,9,3,7,6,11
+H,7,9,7,4,3,8,8,4,5,8,5,7,6,7,4,8
+A,5,8,8,7,7,8,7,2,5,7,8,8,5,10,3,6
+D,2,6,3,4,3,8,7,5,6,6,5,4,3,8,3,7
+P,4,7,6,5,5,6,7,7,4,7,6,8,3,10,7,9
+A,2,4,3,2,1,8,2,2,2,8,2,8,2,6,2,7
+E,5,9,7,6,5,7,8,1,8,11,6,9,3,8,4,9
+Y,2,3,4,4,0,7,10,2,2,8,12,8,1,11,0,8
+V,6,8,6,6,2,4,12,4,4,10,12,7,3,9,1,8
+Q,6,7,8,11,8,10,12,6,0,4,7,11,6,15,5,8
+F,2,1,2,1,1,5,10,4,4,10,9,5,1,10,2,7
+G,5,8,6,6,6,7,7,6,2,6,6,10,4,8,7,7
+N,3,5,5,3,2,6,9,2,4,10,7,7,5,8,1,8
+Q,3,4,4,5,3,8,8,5,2,8,7,10,2,9,4,8
+X,2,5,4,3,2,7,7,3,9,6,6,8,2,8,6,8
+K,4,5,7,4,4,6,7,2,7,10,7,10,3,8,3,8
+I,1,3,2,1,0,7,7,1,6,13,6,8,0,8,0,8
+V,4,7,5,5,3,9,12,2,3,4,10,9,3,12,2,8
+K,5,9,7,8,8,8,8,2,5,8,3,8,5,4,4,10
+V,7,12,7,7,4,7,8,4,4,7,7,6,6,12,2,9
+L,3,6,5,4,5,8,8,3,5,5,7,9,6,11,6,5
+W,7,10,7,8,7,4,11,2,2,9,8,7,7,12,2,6
+D,5,8,8,6,6,8,8,5,6,10,6,5,5,9,4,10
+U,2,6,4,4,3,6,9,4,5,6,9,9,3,9,0,8
+S,6,11,8,8,5,8,7,3,6,10,5,7,2,8,5,8
+D,1,0,1,0,0,6,7,7,5,7,6,6,2,8,3,8
+V,9,14,7,8,3,7,11,5,6,10,10,5,4,11,3,8
+Z,3,8,5,6,3,6,9,2,9,11,8,7,2,9,6,7
+E,4,7,6,5,3,7,8,3,9,11,7,8,2,8,5,7
+Y,4,10,6,8,2,5,11,1,4,9,11,8,0,10,0,8
+T,2,8,3,6,2,7,13,0,5,7,10,8,0,8,0,8
+M,4,6,6,4,4,10,6,7,5,6,7,4,8,5,2,5
+L,2,1,2,3,1,4,4,5,7,2,2,5,1,7,1,6
+S,2,1,2,2,1,8,7,6,4,8,5,8,2,8,8,8
+J,1,3,3,2,1,8,6,3,6,14,5,10,0,7,0,7
+B,2,2,3,3,2,8,7,5,5,6,6,5,2,8,7,9
+Z,7,10,5,14,5,5,11,3,3,12,8,6,3,8,12,5
+S,4,8,5,6,3,10,7,4,8,11,5,7,2,9,5,9
+A,7,12,6,6,3,9,0,3,2,9,4,12,3,5,4,6
+R,3,6,3,4,3,6,9,7,3,7,5,8,2,7,5,11
+Y,1,1,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+U,5,6,5,4,3,4,8,5,7,9,8,9,3,9,3,5
+Y,5,8,5,6,2,3,13,4,6,13,11,4,1,11,2,5
+Z,5,11,7,8,8,6,7,3,9,7,6,10,1,8,11,5
+X,1,0,1,0,0,7,7,3,4,7,6,8,2,8,3,8
+R,7,12,7,6,5,11,5,3,5,10,3,8,6,8,6,10
+S,4,8,5,6,3,7,7,4,8,11,4,8,2,7,5,8
+Q,4,7,5,6,3,8,5,8,7,7,4,9,3,8,4,8
+D,2,5,4,4,3,8,7,5,6,9,5,5,3,8,4,8
+C,1,3,2,1,1,5,9,4,6,11,8,10,1,9,2,8
+P,6,9,5,4,2,7,9,6,3,13,5,4,4,9,4,7
+G,7,15,6,8,5,8,7,4,4,8,6,7,4,9,9,8
+Z,3,4,5,6,4,9,7,5,6,8,3,7,3,6,6,8
+N,4,8,6,6,4,5,9,2,3,9,8,8,5,8,1,7
+M,5,9,6,7,4,8,7,13,2,6,9,8,8,6,0,8
+A,3,6,4,4,2,8,2,2,2,7,2,8,2,6,3,7
+N,4,7,6,5,4,8,8,5,6,7,6,4,7,9,4,6
+Z,2,4,4,6,3,11,5,3,4,9,3,7,2,7,6,8
+T,4,8,6,6,5,6,8,7,7,8,7,8,3,10,6,9
+I,3,6,4,4,2,7,7,0,7,13,6,8,0,8,1,7
+N,3,3,5,2,2,7,9,3,4,10,6,6,5,9,1,7
+D,4,6,5,5,5,7,7,5,6,7,5,9,4,6,6,5
+X,4,11,6,8,6,6,7,2,7,7,7,10,6,5,8,7
+Z,1,1,2,2,1,7,8,5,8,6,6,9,1,8,7,7
+N,4,8,6,6,5,8,8,5,5,6,6,5,6,10,2,5
+Q,3,4,4,5,3,8,7,6,3,8,8,10,3,8,5,8
+Q,5,7,5,9,5,7,9,4,3,7,9,11,3,9,6,8
+A,1,0,2,1,0,8,4,2,0,7,2,8,2,7,1,8
+G,3,5,4,4,2,5,7,5,5,9,7,10,2,8,4,9
+W,2,4,4,2,2,8,10,2,2,6,9,8,6,11,0,8
+B,5,8,7,6,6,8,6,6,6,9,7,7,3,8,7,8
+Q,3,4,4,5,3,8,8,6,2,5,7,10,3,9,5,10
+O,2,2,3,3,2,7,7,8,4,7,6,8,2,8,3,8
+N,3,7,4,5,3,8,8,6,4,7,6,6,5,9,1,6
+I,2,8,2,6,2,7,7,0,7,7,6,8,0,8,3,8
+N,4,5,5,4,3,7,8,6,5,7,6,6,6,9,2,5
+U,4,5,5,3,2,3,8,4,6,11,11,9,3,9,1,6
+Z,4,7,6,5,5,8,8,5,3,6,4,6,4,8,8,3
+K,4,10,5,8,4,3,6,7,4,7,7,12,3,8,3,11
+C,4,6,4,4,2,3,9,5,8,10,10,12,1,8,3,7
+N,4,5,7,4,3,6,10,3,5,10,8,7,5,8,1,7
+K,3,5,5,4,3,6,7,1,7,10,7,10,3,8,3,8
+C,4,7,5,5,2,4,9,6,8,12,10,12,1,9,3,7
+R,4,6,5,4,3,10,7,3,6,10,3,6,3,7,4,10
+O,6,9,6,7,4,8,6,8,5,10,6,10,3,8,4,6
+Q,1,0,2,1,1,8,7,6,4,6,6,8,2,8,3,8
+I,1,4,2,3,1,7,8,0,6,13,6,8,0,8,0,8
+W,4,10,6,7,4,11,8,5,2,7,9,8,8,10,0,8
+X,2,1,3,2,2,8,7,3,8,6,6,8,2,8,5,8
+T,1,0,2,1,0,7,14,1,4,7,10,8,0,8,0,8
+R,4,6,4,4,2,6,12,8,3,7,3,9,2,7,5,11
+J,3,6,5,4,4,8,8,4,3,8,4,7,4,9,5,4
+K,5,9,8,7,5,8,6,1,7,10,3,9,5,6,6,10
+J,3,9,4,7,1,12,2,9,4,13,7,13,1,6,0,8
+E,3,5,5,4,3,7,7,2,7,11,6,8,2,9,5,8
+A,1,0,2,0,0,7,4,2,0,7,2,8,1,6,1,8
+C,5,7,5,5,3,5,8,6,8,12,9,13,1,9,3,7
+X,3,6,4,4,2,7,7,4,4,7,6,8,2,8,4,8
+L,2,7,3,5,2,5,5,3,8,3,2,7,0,6,2,6
+S,3,5,5,3,2,7,7,3,7,11,5,8,1,8,5,8
+N,2,1,2,2,1,7,7,12,1,5,6,8,5,8,0,8
+F,3,6,4,4,3,5,10,2,6,10,9,6,1,10,3,6
+S,6,9,8,7,5,6,7,4,7,10,10,9,2,9,5,5
+K,3,6,4,4,3,6,7,5,7,7,6,10,3,8,5,9
+O,5,9,6,6,8,7,8,5,1,7,7,8,8,9,6,10
+J,5,10,7,8,5,9,4,5,6,8,5,6,2,8,4,6
+T,3,4,4,2,1,5,11,2,7,11,9,5,1,10,2,5
+H,5,8,7,6,6,4,9,3,5,10,9,9,3,8,3,5
+Z,2,0,2,1,1,7,7,3,11,8,6,8,0,8,7,8
+X,7,15,8,8,5,6,8,2,8,11,7,8,4,9,4,6
+F,3,5,4,7,2,0,14,4,4,12,11,6,0,8,2,6
+D,6,11,8,8,8,10,7,4,6,9,3,6,3,8,3,8
+C,3,10,5,8,4,5,8,7,6,9,8,14,2,9,4,10
+B,3,7,3,5,3,6,8,9,6,6,5,7,2,8,8,9
+C,4,9,6,6,7,7,7,4,3,6,7,10,8,10,6,6
+H,5,10,5,8,5,8,7,13,1,7,7,8,3,8,0,8
+T,3,3,3,2,1,5,12,3,5,11,9,4,2,11,1,5
+J,2,7,3,5,2,9,6,1,6,11,4,8,0,7,1,7
+S,2,3,2,1,1,8,8,6,5,7,5,7,2,8,8,8
+M,3,2,4,3,3,8,6,5,3,7,7,9,9,5,1,8
+H,2,3,4,1,2,8,7,3,6,10,5,7,3,8,2,7
+N,4,7,4,5,3,8,8,12,1,6,6,7,5,8,0,9
+K,3,6,5,4,5,6,7,3,6,6,5,8,3,8,4,9
+A,2,5,4,3,2,10,2,3,2,10,2,9,2,6,2,8
+D,1,1,2,2,1,6,7,8,6,6,6,6,2,8,3,8
+P,4,6,6,4,3,8,10,3,5,13,4,3,1,10,3,9
+I,1,4,3,3,1,7,7,1,7,14,6,8,0,8,1,8
+J,6,11,5,8,4,9,8,2,3,12,5,6,2,9,7,9
+J,2,10,3,8,2,12,3,7,3,12,5,11,1,6,0,8
+F,3,8,3,6,1,1,13,5,3,12,10,6,0,8,2,6
+K,6,7,8,5,5,7,8,2,7,10,5,9,4,7,3,7
+W,4,9,6,6,3,4,8,5,1,7,9,8,8,10,0,8
+V,4,5,7,8,2,7,8,4,3,7,14,8,3,9,0,8
+I,1,1,1,1,0,7,7,2,8,7,6,8,0,8,3,8
+O,2,3,3,2,2,7,7,7,5,7,6,8,2,8,3,8
+P,4,7,6,5,3,7,11,5,4,12,4,1,1,10,3,8
+W,4,4,6,6,3,8,8,4,1,7,8,8,8,9,0,8
+U,4,8,5,6,5,7,6,9,5,7,6,9,4,9,6,4
+O,3,8,4,6,3,7,7,8,4,10,6,8,3,8,3,7
+U,5,9,7,6,4,4,8,7,9,9,10,11,3,9,1,7
+I,3,9,4,6,2,7,8,0,8,14,6,6,0,8,1,7
+X,2,3,3,2,1,7,7,1,8,10,6,8,2,8,2,7
+J,2,8,3,6,2,9,6,3,6,11,4,9,1,6,2,6
+B,4,2,5,4,4,8,7,5,6,6,5,5,2,8,7,10
+Q,2,3,3,4,2,7,9,4,1,7,8,10,2,9,4,8
+G,4,7,4,5,3,7,6,6,6,10,6,12,2,10,4,9
+Q,7,8,7,9,7,8,7,6,2,7,7,11,5,9,7,7
+J,7,11,9,8,6,9,4,5,6,8,5,6,2,7,5,6
+D,8,12,8,6,4,11,3,3,6,10,2,8,4,7,3,12
+U,4,10,6,7,9,10,8,4,4,5,8,8,9,8,8,6
+P,4,10,5,8,4,6,10,6,5,9,7,3,2,10,4,7
+X,4,8,5,6,1,7,7,4,4,7,6,8,3,8,4,8
+B,3,6,4,4,4,8,7,5,6,7,6,6,2,8,6,9
+G,4,8,5,6,3,7,7,8,6,7,6,12,3,8,4,9
+W,3,4,5,6,3,6,8,4,1,7,8,8,8,10,0,8
+G,2,4,3,3,2,6,7,5,5,9,7,10,2,9,4,9
+A,4,9,5,6,4,7,5,3,0,6,1,8,2,7,1,7
+R,4,8,6,6,6,6,7,5,6,7,6,7,3,7,5,9
+B,2,4,3,2,2,10,7,2,6,10,4,6,2,8,4,10
+X,8,11,7,6,3,7,7,2,9,9,7,9,4,11,4,7
+N,3,4,5,3,2,6,9,3,4,11,8,8,5,7,1,8
+K,7,10,10,7,8,8,6,1,7,9,5,9,5,7,5,8
+B,4,8,6,6,6,7,8,6,4,7,5,6,4,7,6,6
+E,3,7,4,5,3,4,9,2,8,10,8,10,2,8,4,5
+E,4,8,4,6,2,3,6,6,11,7,7,15,0,8,7,7
+W,4,6,6,4,5,7,11,2,2,7,8,8,6,11,1,8
+A,3,9,5,7,3,13,3,3,2,11,1,8,2,6,3,9
+U,3,5,4,4,2,6,8,6,7,7,9,9,3,9,1,8
+M,3,4,5,2,3,8,6,6,4,7,7,9,9,5,2,8
+J,5,9,7,7,3,9,6,3,7,15,5,10,1,6,1,7
+C,5,4,6,6,2,6,7,7,11,7,6,14,1,8,4,9
+M,3,6,4,4,4,7,6,6,4,6,7,8,7,5,2,7
+P,4,7,6,5,3,8,9,3,5,13,5,4,1,10,2,8
+I,1,5,1,3,1,7,7,1,7,7,6,8,0,8,3,8
+D,5,10,7,7,6,11,6,2,6,11,3,7,3,8,3,9
+E,5,11,7,8,5,5,9,4,9,11,9,8,3,8,5,5
+S,4,7,5,5,3,10,6,4,8,11,3,8,2,8,5,10
+I,3,8,6,6,5,8,8,4,5,9,6,4,5,10,4,6
+W,8,13,8,7,5,4,8,1,3,8,9,8,9,11,2,5
+C,3,7,4,5,2,3,8,5,8,9,9,13,1,8,3,7
+F,4,9,4,6,2,1,13,5,3,12,10,6,0,8,2,6
+C,3,7,4,5,2,3,9,6,7,11,11,11,1,8,2,6
+Z,4,8,5,6,3,7,7,3,12,9,6,8,0,8,8,8
+F,5,10,7,8,5,8,9,2,6,13,6,5,2,10,2,8
+R,7,11,10,8,11,5,8,3,5,6,5,10,8,9,9,6
+A,5,10,8,8,5,11,3,1,2,8,2,9,4,6,3,8
+V,5,9,5,7,4,3,11,2,3,9,11,8,2,11,1,8
+Z,4,5,5,8,2,7,7,4,14,9,6,8,0,8,8,8
+I,1,3,2,2,1,7,8,0,6,13,6,7,0,8,0,7
+O,10,13,7,8,4,7,7,5,5,8,4,7,5,9,6,8
+D,1,0,1,0,0,6,7,6,4,7,6,6,2,8,2,8
+M,3,4,4,2,3,7,6,6,4,6,7,8,6,6,2,8
+S,6,12,6,6,3,7,8,3,6,13,6,7,2,8,3,7
+E,6,10,9,8,6,4,9,4,9,12,10,9,3,8,5,5
+D,6,11,9,8,8,7,8,6,6,10,7,5,7,9,6,11
+I,2,5,4,4,1,7,7,0,7,13,6,8,0,8,1,8
+Q,5,5,7,8,4,8,9,7,6,6,8,9,3,7,6,10
+M,5,5,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+P,4,7,5,5,3,6,10,7,3,10,5,4,2,10,3,8
+N,6,10,9,8,5,8,8,3,5,10,5,6,6,8,2,7
+F,5,5,5,7,2,1,14,5,4,12,10,6,0,8,2,5
+P,6,10,8,8,5,6,12,5,3,12,5,2,1,11,3,8
+T,5,10,6,8,4,7,9,0,8,11,9,6,1,10,3,4
+U,2,6,3,4,1,8,5,13,5,6,13,8,3,9,0,8
+O,4,10,6,8,3,8,8,9,8,6,7,10,3,8,4,8
+O,5,9,6,6,5,7,7,7,4,9,6,10,4,8,4,7
+S,5,10,7,7,4,9,6,3,7,10,6,9,2,10,5,9
+X,3,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+B,4,10,5,8,6,8,7,7,6,7,6,6,2,8,7,10
+N,3,2,3,3,2,7,8,5,4,7,6,7,4,8,1,7
+X,3,7,5,5,3,8,7,4,9,6,6,8,3,8,7,9
+Q,3,6,4,6,2,8,6,8,6,6,6,8,3,8,4,8
+P,2,1,2,2,1,5,10,4,4,9,7,4,1,10,3,7
+L,5,10,7,8,4,7,3,2,9,7,1,9,1,6,3,7
+W,3,5,5,4,4,9,11,3,2,5,9,7,7,11,1,8
+N,3,7,5,5,3,6,9,6,5,8,7,8,5,8,1,7
+O,4,9,5,6,4,8,7,8,5,7,7,7,3,8,3,8
+V,7,11,9,8,6,5,12,3,2,9,10,7,5,10,6,8
+G,4,8,6,6,3,6,6,6,7,7,5,9,3,10,4,8
+F,3,4,3,5,1,1,14,5,3,12,9,5,0,8,2,6
+L,2,4,4,3,2,6,4,1,8,8,2,11,0,7,2,8
+B,4,5,5,8,4,6,7,10,7,7,6,7,2,8,9,9
+I,1,7,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+X,4,4,5,6,1,7,7,5,4,7,6,8,3,8,4,8
+D,4,8,5,6,8,9,7,5,5,7,6,6,4,7,7,6
+I,1,8,2,6,2,7,7,0,8,7,6,8,0,8,3,8
+D,2,7,4,5,4,7,7,4,6,7,6,6,3,8,2,7
+C,6,11,7,8,4,5,8,8,9,9,9,13,2,9,4,9
+G,4,6,5,4,3,6,7,6,6,9,8,9,2,8,4,9
+V,1,1,2,1,0,7,9,4,2,7,13,8,2,10,0,8
+T,5,5,5,4,2,5,12,3,7,12,9,4,1,11,1,5
+K,5,7,7,5,4,4,8,2,7,10,10,11,3,8,4,6
+C,7,11,7,8,4,5,7,6,8,12,9,14,2,10,4,7
+Z,4,5,5,7,2,7,7,4,15,9,6,8,0,8,8,8
+W,6,10,6,8,7,4,10,3,2,9,7,8,8,12,3,5
+E,4,9,4,7,3,3,8,6,12,7,5,15,0,8,7,7
+B,7,12,6,6,4,8,6,4,5,10,5,8,6,7,7,10
+B,4,7,6,5,4,10,6,3,7,10,4,7,3,8,5,11
+K,2,1,3,3,2,6,7,4,7,7,6,10,3,8,5,9
+M,2,3,4,1,2,8,6,3,4,9,6,7,6,5,1,7
+H,4,4,6,6,5,9,9,3,1,7,7,8,4,9,8,8
+C,6,8,8,7,7,5,7,4,5,7,6,11,4,9,8,9
+V,7,12,7,6,4,9,8,4,5,8,8,5,6,10,3,6
+F,4,10,6,8,3,4,13,6,5,12,10,3,2,10,2,4
+T,3,8,4,6,2,9,13,0,5,6,10,8,0,8,0,8
+Y,5,10,7,8,3,7,10,1,3,7,12,8,1,11,0,8
+F,3,7,3,4,1,2,14,5,2,12,9,4,0,8,3,6
+X,2,3,3,2,2,8,7,3,8,6,6,6,2,8,6,8
+D,5,8,7,6,6,8,7,5,6,9,4,5,3,8,4,9
+R,2,0,2,1,1,6,10,7,2,7,5,7,2,7,4,9
+Y,1,3,2,2,1,6,11,1,7,8,11,9,1,11,2,8
+X,4,8,6,6,4,7,7,3,9,5,6,8,3,8,7,8
+O,4,6,4,4,4,6,9,7,4,9,8,8,3,8,3,7
+C,8,12,5,7,3,5,10,6,8,11,8,8,1,8,6,8
+H,3,3,4,4,2,7,7,14,1,7,6,8,3,8,0,8
+A,3,9,5,7,3,9,3,2,2,8,1,8,2,6,3,7
+X,6,10,9,8,4,5,8,2,9,11,12,10,4,7,4,5
+R,5,8,8,7,8,8,8,3,3,7,5,8,7,8,6,4
+T,5,7,6,6,6,5,8,4,8,9,7,10,3,7,7,5
+C,5,4,6,7,2,7,6,7,11,9,5,13,1,9,4,8
+D,8,14,8,8,4,11,4,3,6,10,2,7,5,7,4,12
+N,1,3,3,2,1,5,9,3,3,10,8,8,4,8,0,7
+A,4,6,6,5,5,8,8,3,5,7,8,7,5,10,4,6
+A,3,8,5,6,3,7,5,3,0,7,1,8,2,7,1,8
+A,3,11,6,8,4,12,2,2,2,9,2,9,2,6,3,8
+B,4,9,6,7,5,8,7,6,6,9,6,6,3,8,7,8
+V,1,0,2,0,0,8,9,3,2,6,12,8,2,10,0,8
+D,5,5,6,7,3,5,7,10,10,6,6,6,3,8,4,8
+X,2,3,3,2,2,7,7,3,9,6,6,8,2,8,5,8
+D,6,11,6,6,3,10,4,3,6,9,3,7,4,7,4,11
+J,2,5,4,4,1,9,6,2,7,14,5,10,1,6,1,7
+H,5,11,5,8,3,7,9,15,2,7,3,8,3,8,0,8
+E,2,3,4,2,2,7,7,2,7,11,7,9,2,8,4,8
+I,3,9,4,6,3,8,7,0,7,13,6,8,0,8,1,8
+U,7,9,6,5,3,4,4,5,5,4,7,8,5,7,2,7
+C,7,10,9,8,6,7,7,8,7,6,7,8,5,6,5,9
+I,7,14,5,8,2,9,7,6,4,13,3,7,3,7,6,11
+T,4,6,5,6,5,5,8,4,7,8,8,9,3,8,7,6
+A,2,4,3,3,1,10,2,3,2,10,2,9,2,6,2,8
+K,8,13,8,8,4,8,7,3,6,9,7,8,6,11,4,7
+W,5,8,8,6,3,7,7,5,2,7,8,8,9,9,0,8
+Q,4,7,5,9,6,8,6,8,2,5,6,9,3,8,5,10
+T,5,10,6,8,4,5,11,1,9,8,11,9,1,10,1,7
+Z,1,0,2,1,0,7,7,2,11,8,6,8,0,8,6,8
+B,5,4,5,6,4,7,9,9,8,7,5,7,2,8,9,9
+P,4,6,6,4,3,7,10,3,4,13,6,3,1,10,3,9
+V,6,11,6,6,3,5,9,4,3,10,8,5,5,12,2,7
+P,2,1,2,1,1,5,11,7,2,9,6,4,1,9,3,8
+H,3,6,4,4,2,7,8,14,1,7,5,8,3,8,0,8
+X,7,10,10,8,6,9,6,1,8,10,3,7,3,8,3,9
+P,4,9,6,6,4,5,10,6,5,10,8,3,1,10,4,6
+C,0,0,1,0,0,6,7,5,7,7,6,14,0,8,3,10
+G,3,4,4,3,2,7,6,6,6,6,6,10,2,9,4,9
+G,3,5,4,4,3,6,7,5,5,9,7,10,2,8,4,10
+X,9,11,8,6,3,7,7,2,9,9,6,8,4,9,4,8
+Z,5,8,6,6,4,7,8,2,10,12,7,6,1,7,6,6
+W,6,11,9,8,7,5,9,5,1,7,9,8,8,11,0,7
+I,2,8,3,6,1,9,7,0,8,14,5,8,0,8,1,8
+Z,2,4,4,3,2,8,7,2,9,12,6,7,1,8,5,8
+C,2,6,3,4,2,6,8,8,8,9,8,13,1,9,4,10
+W,3,7,6,5,4,5,10,2,3,8,9,9,7,11,1,8
+G,4,7,5,5,3,6,7,7,7,10,7,9,2,10,4,9
+X,3,3,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+R,3,7,3,5,2,6,9,9,5,7,5,8,3,8,5,10
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+N,5,9,8,7,5,10,7,3,5,10,2,5,6,9,1,7
+W,8,10,8,5,4,1,9,3,3,11,12,9,8,10,1,6
+K,7,10,10,8,6,4,9,2,7,10,9,10,5,6,4,5
+U,4,7,4,5,3,7,6,12,4,7,12,8,3,9,0,8
+B,8,12,6,6,4,7,7,5,6,10,5,8,6,6,7,10
+H,4,5,6,4,4,7,7,3,6,10,6,8,3,8,3,8
+E,4,7,5,5,4,10,6,2,7,11,4,8,4,9,5,12
+C,3,7,5,5,5,5,7,3,4,7,6,10,5,10,3,8
+Q,3,6,4,8,4,8,11,4,3,5,9,11,2,10,5,8
+P,6,11,8,8,5,5,11,7,4,11,7,2,1,10,4,6
+L,3,7,3,5,1,0,1,5,6,0,0,6,0,8,0,8
+E,0,0,1,0,0,5,7,5,6,7,6,12,0,8,6,10
+K,1,1,2,1,1,6,7,4,7,7,6,11,3,8,4,9
+R,4,4,4,6,3,5,11,8,4,7,2,9,3,7,6,11
+O,1,0,1,0,0,7,6,6,3,7,6,7,2,8,3,8
+K,4,9,6,7,4,5,7,5,7,6,6,10,4,8,5,9
+V,5,6,5,4,2,3,12,4,4,10,12,7,2,10,1,7
+F,5,8,7,6,4,7,9,3,6,13,6,5,2,9,3,7
+T,2,4,3,3,1,7,11,2,7,6,11,8,1,10,1,8
+S,2,6,3,4,2,7,6,5,8,4,6,8,0,9,8,8
+Q,3,7,4,6,3,8,7,7,4,6,6,9,2,8,4,9
+V,2,0,3,1,0,7,9,4,2,7,13,8,2,10,0,8
+U,3,6,4,4,2,7,4,14,5,7,12,8,3,9,0,8
+P,1,0,2,0,0,5,11,6,1,9,6,5,1,9,3,8
+J,1,1,2,3,1,11,6,2,6,12,3,7,0,7,1,8
+S,6,9,7,6,4,8,8,4,10,11,4,7,2,6,5,9
+M,10,15,12,9,6,10,2,3,2,10,3,9,8,1,1,8
+T,3,9,4,7,4,7,11,3,6,7,11,9,2,12,1,8
+U,5,6,6,4,3,3,9,5,7,11,11,9,3,9,2,6
+F,3,7,3,4,1,1,13,5,4,12,10,7,0,8,2,6
+X,3,5,6,3,3,7,7,1,8,10,6,8,2,8,3,8
+L,7,11,6,6,3,10,2,4,4,12,5,13,2,7,5,9
+X,4,6,5,5,5,8,8,2,4,7,6,8,3,8,7,7
+F,7,12,6,6,3,8,8,3,7,12,4,5,2,8,7,7
+J,7,8,4,12,4,7,9,3,4,13,4,5,3,8,7,10
+T,5,9,5,6,3,5,12,3,8,12,9,4,1,11,2,4
+Y,3,9,5,6,2,9,11,1,3,5,11,8,1,10,0,8
+A,3,8,5,5,2,7,5,3,1,6,1,8,2,7,2,7
+F,4,7,6,5,3,5,11,3,5,13,8,5,1,10,2,7
+I,2,9,2,7,3,7,7,0,7,7,6,8,0,8,3,8
+U,3,2,4,4,2,6,8,6,7,6,9,9,3,9,1,7
+I,0,6,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+E,4,5,6,4,5,6,8,4,4,8,7,9,4,11,8,10
+H,8,10,11,8,6,7,8,3,7,10,8,8,6,8,5,7
+M,4,2,6,3,4,8,6,6,5,6,7,8,8,7,3,6
+N,3,6,4,4,2,7,7,14,2,5,6,8,6,8,0,8
+S,3,8,4,6,2,7,6,6,10,5,7,10,0,9,9,8
+L,10,15,8,8,4,9,2,4,5,12,4,13,2,7,6,8
+F,3,5,5,6,4,6,9,3,4,8,7,7,4,10,8,9
+H,5,9,8,7,7,8,8,5,7,7,6,7,6,8,4,7
+W,5,6,7,5,8,6,7,6,5,6,5,8,8,10,8,10
+N,4,7,6,5,3,11,6,4,5,10,1,5,5,9,1,7
+H,7,9,10,7,6,5,8,4,7,10,9,10,3,8,3,6
+I,2,8,4,6,4,10,6,1,4,8,5,5,3,8,5,7
+D,3,5,5,4,3,9,6,4,7,10,4,6,2,8,3,9
+D,4,11,5,8,5,5,7,10,7,6,5,6,3,8,3,8
+Q,4,7,5,7,4,8,7,7,5,6,4,9,2,8,3,8
+J,6,7,8,9,7,8,8,4,6,7,6,7,4,8,8,8
+V,3,8,5,6,3,6,11,2,3,7,11,9,2,10,1,8
+J,2,7,3,5,1,9,6,3,7,12,4,9,0,7,2,6
+C,2,4,3,3,2,6,8,7,7,8,7,13,1,9,4,10
+O,7,11,7,8,5,8,7,8,5,10,6,8,3,8,3,8
+J,7,10,5,8,4,8,10,3,3,13,4,5,2,9,7,9
+F,5,6,6,7,6,7,9,6,6,7,6,9,5,8,8,6
+T,6,10,6,7,5,5,11,3,7,11,10,5,2,12,2,4
+X,3,6,4,4,3,8,7,3,8,6,6,8,2,8,6,8
+G,6,10,7,8,4,6,7,7,8,10,7,10,2,10,5,9
+S,3,9,4,6,3,8,7,8,7,7,7,9,2,10,9,8
+O,2,4,2,3,2,8,7,6,3,9,6,8,2,8,2,8
+E,5,8,7,6,4,7,7,3,8,12,7,9,3,8,5,8
+R,4,4,4,5,2,5,10,8,4,7,4,8,3,7,6,11
+Y,4,7,6,5,3,9,10,1,7,3,11,8,1,11,2,9
+B,3,6,5,4,4,7,8,5,5,9,6,6,3,8,7,8
+T,3,11,4,8,1,5,14,1,6,9,11,7,0,8,0,8
+F,4,8,5,6,4,4,11,6,5,11,10,5,2,9,2,5
+Q,6,9,7,11,8,7,9,5,3,8,10,10,5,8,8,10
+R,5,7,8,6,8,9,7,4,4,8,5,7,8,10,7,5
+E,3,9,4,6,2,3,7,6,11,7,6,15,0,8,7,7
+V,3,5,5,4,2,4,12,3,3,9,11,8,2,11,0,8
+O,4,8,5,6,2,8,6,8,7,7,5,8,3,8,4,8
+W,12,14,12,8,5,2,9,3,2,10,12,8,9,10,1,6
+K,4,2,5,3,3,6,7,4,8,7,6,10,6,8,5,9
+A,3,9,6,6,3,11,3,2,2,9,2,9,3,5,3,8
+U,5,7,6,5,3,4,8,6,8,10,10,9,3,9,2,5
+X,4,10,6,7,6,7,7,2,6,7,6,7,4,7,6,7
+W,6,9,9,7,7,4,10,2,3,8,9,9,10,9,1,8
+M,7,10,10,8,9,11,6,2,5,9,4,6,10,7,2,8
+L,3,8,4,6,1,0,0,6,6,0,1,5,0,8,0,8
+Q,4,9,6,8,3,9,8,8,6,5,8,9,3,8,5,9
+H,6,9,6,4,3,9,6,4,4,9,7,8,6,12,4,9
+N,1,0,1,0,0,7,7,9,0,6,6,8,3,8,0,8
+N,4,8,6,6,3,5,9,3,4,10,9,9,5,8,1,7
+Q,2,2,3,3,2,8,8,6,1,5,6,9,2,9,4,10
+E,5,8,7,6,6,6,8,3,7,11,9,9,3,8,5,6
+K,2,6,3,4,2,3,7,6,2,7,6,10,3,8,2,11
+G,3,6,4,4,4,7,8,5,3,6,6,10,3,8,6,8
+I,2,8,3,6,1,7,7,0,8,14,6,9,0,8,1,8
+C,4,9,6,7,4,5,8,6,6,8,8,15,3,10,4,9
+E,2,4,2,3,2,7,7,5,6,7,6,8,2,8,5,11
+G,2,1,3,2,1,6,7,5,5,6,6,9,2,9,4,8
+B,3,5,5,4,4,9,6,3,6,10,5,7,2,8,5,10
+T,4,10,6,8,4,6,12,3,7,7,12,8,2,12,1,7
+P,2,3,4,2,2,8,8,3,3,12,4,5,1,9,2,8
+J,4,9,6,7,3,6,7,3,5,15,6,10,1,6,1,7
+M,2,3,3,1,2,6,6,6,4,7,7,10,6,5,1,9
+U,4,3,4,2,2,5,8,5,7,10,9,9,3,9,2,6
+L,7,10,9,8,7,6,7,7,7,6,6,8,6,8,5,10
+N,5,7,7,5,3,5,9,3,5,10,9,9,6,7,1,7
+W,5,10,8,8,13,9,7,5,2,7,7,8,10,10,3,5
+I,7,12,5,6,2,10,5,6,4,13,3,9,3,8,4,9
+V,10,15,10,8,5,6,8,4,4,8,8,5,6,12,4,6
+Z,6,9,8,7,4,9,6,3,10,11,4,9,1,7,6,8
+M,5,5,6,8,4,8,7,12,2,6,9,8,9,6,0,8
+E,5,5,5,7,3,3,8,6,12,7,5,15,0,8,7,7
+A,2,2,4,3,2,8,2,2,2,8,2,8,2,6,3,7
+M,4,7,8,5,8,10,6,3,3,9,4,7,10,5,3,6
+D,1,0,2,0,0,6,7,7,6,7,6,6,2,8,3,8
+Z,5,5,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+N,8,11,11,8,6,12,7,3,6,10,0,3,7,11,2,8
+J,2,5,5,3,1,8,6,3,7,15,6,10,1,6,1,7
+Y,6,11,9,8,8,8,4,6,5,8,7,8,6,8,8,3
+X,4,9,6,7,4,8,7,4,9,6,6,6,3,8,7,7
+B,2,3,4,2,2,8,7,3,5,10,5,6,2,8,4,9
+A,3,11,5,8,4,12,3,3,3,10,1,9,2,6,3,8
+T,5,7,6,5,6,6,8,4,6,7,6,10,5,8,5,7
+H,3,2,4,4,3,7,7,5,6,7,6,8,6,8,4,8
+H,4,9,5,6,2,7,6,15,1,7,8,8,3,8,0,8
+H,3,7,3,4,2,7,6,14,1,7,7,8,3,8,0,8
+Y,4,5,5,7,5,10,11,5,4,5,8,8,5,10,9,5
+V,4,6,4,4,2,3,11,4,3,10,12,7,2,10,1,8
+K,5,11,6,8,2,4,6,9,2,7,7,12,4,8,3,11
+X,3,7,5,5,2,9,7,1,8,10,4,7,3,8,3,8
+Q,5,8,6,7,3,9,8,8,6,5,8,9,3,7,5,9
+S,5,8,6,6,4,8,8,4,8,10,4,6,2,7,5,8
+C,4,9,5,6,3,4,8,5,6,12,10,12,2,9,2,7
+B,1,0,2,1,1,7,7,7,5,6,6,7,1,8,7,9
+B,5,11,7,8,7,8,7,7,7,6,6,5,2,8,8,10
+H,5,9,7,6,4,7,6,3,7,10,8,9,3,8,3,7
+X,3,5,5,4,3,7,7,3,9,6,6,8,3,8,6,8
+H,3,7,4,4,2,7,7,14,1,7,6,8,3,8,0,8
+Z,3,8,5,6,3,8,7,2,9,11,5,9,1,8,6,8
+S,7,11,7,6,3,7,6,3,4,13,8,8,3,8,4,7
+M,5,2,6,4,4,9,6,7,4,6,7,5,10,5,3,5
+V,1,0,1,0,0,8,10,3,1,7,12,8,2,11,0,8
+W,4,7,6,5,3,9,8,5,1,7,8,8,8,9,0,8
+F,4,8,6,6,4,7,9,2,6,13,6,5,2,10,2,8
+O,5,9,5,7,4,7,7,8,5,9,7,10,3,8,4,6
+T,4,9,5,7,3,6,11,2,8,8,12,8,1,11,1,7
+O,4,10,5,8,3,9,7,9,7,7,6,10,3,8,4,8
+B,5,7,7,5,5,8,6,6,7,9,7,6,3,8,8,7
+T,4,8,5,6,4,6,7,7,6,8,10,8,3,9,5,9
+X,3,7,4,5,2,7,7,4,4,7,6,7,2,8,4,8
+C,9,12,7,7,5,7,9,4,5,9,8,9,4,9,8,11
+N,6,5,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+X,6,10,9,8,5,7,8,1,8,10,6,8,3,8,4,8
+Q,5,7,6,5,5,8,6,7,4,4,8,10,6,6,7,10
+V,2,1,4,1,1,7,12,3,2,6,11,9,2,11,0,7
+D,2,3,4,2,2,9,6,4,6,10,4,6,2,8,3,8
+K,5,9,8,7,4,4,9,2,7,10,10,11,3,8,3,6
+A,3,11,6,8,2,8,6,3,1,7,0,8,3,7,2,8
+V,3,6,4,4,2,2,11,4,3,11,12,8,2,10,1,8
+H,4,8,5,6,5,8,7,5,6,7,6,8,6,8,3,7
+D,1,0,1,0,0,6,7,7,5,7,6,6,2,8,2,8
+G,3,8,4,6,2,7,6,8,7,6,5,11,1,8,5,11
+J,2,5,3,8,1,12,3,10,4,13,5,13,1,6,0,8
+C,2,5,3,4,2,6,8,7,7,8,8,13,1,9,4,10
+G,5,10,6,8,3,7,6,8,8,6,6,8,2,8,6,11
+K,5,5,5,8,2,3,6,8,3,7,7,11,4,8,3,11
+V,3,9,5,6,1,7,8,4,2,7,14,8,3,9,0,8
+C,3,4,4,3,2,4,8,4,6,11,10,12,1,9,2,7
+M,5,10,6,8,4,8,7,12,2,6,9,8,8,6,0,8
+F,5,8,7,6,7,7,8,1,4,10,6,6,5,10,3,5
+Y,2,3,3,4,0,8,11,1,3,5,11,8,0,10,0,8
+C,3,5,4,3,2,4,8,5,8,11,9,13,1,9,3,7
+Q,6,8,9,12,14,8,5,6,1,6,6,9,10,10,8,14
+H,9,15,8,8,5,6,7,5,4,8,10,9,7,11,5,9
+U,9,11,8,6,4,9,6,6,7,3,9,7,5,9,3,5
+D,5,10,6,8,6,7,7,7,7,7,6,5,3,8,3,7
+H,5,10,7,8,10,8,9,5,3,6,7,7,7,9,9,8
+O,6,10,8,8,10,8,9,6,1,7,7,8,9,8,5,9
+W,3,7,5,5,7,9,5,5,2,7,6,8,5,10,2,5
+S,4,7,6,5,6,8,9,4,4,9,5,7,4,9,10,9
+U,2,3,3,2,1,5,8,4,7,10,8,8,3,9,2,6
+Y,6,11,6,8,3,4,10,2,7,10,11,6,1,11,3,4
+N,3,8,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+N,7,12,6,6,3,5,9,4,5,4,4,11,5,9,2,7
+M,4,2,5,4,4,8,6,6,4,7,7,8,7,5,2,7
+E,2,7,4,5,4,7,8,3,5,5,7,10,3,11,7,8
+I,1,3,2,2,1,7,8,1,7,13,6,8,0,8,1,7
+Z,2,3,2,2,2,7,7,5,9,6,6,8,1,8,6,8
+B,2,4,2,3,2,7,7,5,5,6,6,6,2,8,5,9
+B,7,11,9,8,7,9,6,4,7,10,5,6,3,8,6,10
+G,6,10,8,8,8,6,6,6,3,6,6,10,5,8,8,7
+P,4,9,5,6,2,3,14,7,1,11,6,3,0,10,4,8
+P,3,4,5,6,7,8,5,5,2,7,6,7,6,9,6,9
+U,3,5,5,3,2,7,9,6,7,7,10,9,3,9,1,8
+K,8,10,11,8,5,4,8,4,9,12,12,11,3,8,4,5
+V,6,10,5,5,2,8,10,6,3,7,9,5,6,13,3,7
+C,9,14,7,8,5,7,6,4,4,9,8,11,4,9,9,11
+W,3,8,5,6,5,6,11,2,2,7,8,8,6,11,1,8
+V,4,7,6,5,4,8,11,2,2,6,10,8,4,10,4,9
+C,5,5,6,8,2,6,7,7,10,8,6,15,1,9,4,9
+E,2,3,3,2,1,7,7,2,7,11,7,9,1,8,3,8
+O,4,9,5,7,2,7,7,9,8,7,5,8,3,8,4,8
+O,1,1,2,1,1,7,7,6,4,7,6,8,2,8,2,8
+E,4,7,6,5,4,6,8,3,7,11,8,8,3,8,4,6
+C,2,1,2,1,1,6,7,6,9,7,6,13,0,8,4,9
+O,3,5,4,4,2,8,6,7,4,9,5,8,2,8,3,8
+A,3,8,6,6,4,8,5,2,4,6,2,6,2,6,2,6
+N,4,10,4,7,3,7,7,14,2,4,6,8,6,8,0,8
+Z,3,9,4,7,3,7,8,3,11,8,6,8,0,8,7,7
+A,6,9,6,5,3,13,0,5,1,12,3,11,2,3,2,10
+S,4,5,5,5,6,7,7,5,4,7,7,7,5,8,10,10
+I,3,10,6,8,7,10,6,2,5,8,4,5,3,8,5,7
+F,6,10,8,7,6,6,10,2,6,13,7,6,2,10,2,7
+L,3,7,4,5,2,4,5,1,9,7,2,11,0,8,2,7
+V,7,8,9,7,10,8,7,4,5,7,6,8,8,10,9,4
+G,5,11,6,8,8,8,4,4,3,7,5,11,6,8,6,13
+G,5,9,4,5,2,7,4,4,2,7,4,5,4,7,5,8
+L,5,10,7,8,4,7,3,2,9,7,1,9,1,6,3,7
+P,3,6,4,4,2,5,12,7,3,12,6,3,1,10,4,7
+A,3,8,5,6,3,11,2,3,3,10,2,9,2,6,3,8
+P,3,7,5,10,8,7,12,4,1,9,8,5,4,11,4,8
+C,5,8,6,6,2,6,7,7,10,6,6,15,1,8,4,9
+M,4,2,5,4,4,8,6,6,4,7,7,8,7,5,2,8
+U,2,1,2,2,1,7,9,5,5,6,9,9,3,9,1,8
+Y,5,6,5,4,3,5,9,1,7,9,10,6,1,11,3,5
+D,7,10,9,8,7,7,7,5,6,7,6,7,7,8,3,8
+Y,9,9,7,13,5,7,8,4,3,6,11,5,5,10,6,6
+Y,4,5,5,4,2,4,11,2,7,11,10,6,1,11,2,5
+T,4,9,4,4,2,5,10,2,6,11,8,6,2,9,4,3
+W,4,9,5,6,6,7,6,6,2,7,7,8,6,8,4,8
+B,5,11,8,8,11,9,7,4,4,6,7,7,8,8,8,7
+E,3,5,6,4,3,6,8,2,9,11,8,8,2,8,4,6
+X,3,9,5,7,4,8,7,3,8,5,6,8,3,8,6,8
+S,2,7,3,5,3,8,7,7,5,7,7,8,2,9,8,8
+U,5,5,6,4,3,4,8,5,8,10,8,9,3,9,2,6
+T,4,6,5,4,4,7,7,7,7,7,6,8,3,10,6,8
+U,3,4,4,3,2,5,8,5,7,9,8,8,3,9,2,5
+V,3,8,5,6,2,5,11,3,4,9,12,9,3,10,1,9
+J,4,6,5,4,2,9,7,0,7,13,5,7,0,8,0,8
+B,5,10,5,5,5,7,8,3,5,9,6,7,6,5,7,8
+H,1,0,1,0,0,7,8,10,1,7,6,8,2,8,0,8
+D,6,11,8,8,7,7,7,6,6,7,7,7,7,7,3,7
+S,3,3,4,4,2,7,7,5,8,5,6,8,0,8,8,8
+L,1,4,2,3,1,7,4,1,7,7,2,10,0,7,2,8
+Q,6,8,7,10,6,8,6,7,4,8,7,11,4,9,7,7
+H,3,3,5,2,2,9,6,3,6,10,4,8,3,8,3,9
+M,4,3,5,5,3,7,7,12,1,7,9,8,8,6,0,8
+C,1,0,1,1,0,7,7,5,7,7,6,14,0,8,4,10
+R,3,2,4,4,3,7,8,5,5,6,5,6,3,7,4,8
+G,1,0,2,1,0,8,6,6,4,6,5,9,1,8,5,10
+A,2,6,5,4,3,6,5,1,3,5,2,7,2,6,3,4
+O,4,7,4,5,3,9,6,7,5,10,4,10,3,8,3,8
+I,1,6,3,4,3,9,6,3,4,7,6,5,3,8,5,5
+V,4,8,4,6,2,3,11,4,4,11,12,8,2,10,1,8
+V,1,0,2,1,0,7,9,3,2,7,12,8,2,10,0,8
+A,5,12,5,6,3,14,0,4,2,12,3,11,2,4,2,10
+K,3,2,4,4,3,5,7,3,7,6,6,10,6,8,4,9
+V,3,5,4,3,1,4,12,4,4,11,11,7,2,11,1,8
+C,7,10,7,7,4,4,10,7,8,12,10,9,2,10,3,6
+L,4,6,5,4,3,6,6,7,6,6,6,8,2,8,4,10
+H,2,1,2,1,2,8,8,6,6,7,6,8,3,8,3,8
+U,5,6,6,4,3,4,9,5,7,11,11,9,3,9,2,7
+N,3,5,4,3,3,7,9,5,5,7,6,6,5,9,2,6
+D,4,10,6,8,4,8,7,7,7,10,5,4,3,7,5,9
+Q,3,3,4,4,3,8,7,6,2,8,7,9,2,9,4,8
+X,3,5,5,3,2,8,7,3,9,6,6,9,3,7,7,9
+N,4,11,5,8,5,7,7,13,1,6,6,8,6,9,1,6
+N,1,0,1,0,0,7,7,10,0,5,6,8,4,8,0,8
+L,3,9,5,7,7,7,8,3,5,6,6,10,6,11,7,5
+F,4,11,5,8,4,4,11,4,6,11,10,6,2,10,3,5
+N,5,9,5,5,2,5,8,4,6,4,4,9,4,7,2,8
+I,1,11,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+Y,5,8,5,6,3,5,9,1,8,9,9,5,1,11,3,4
+Z,2,4,4,3,2,7,8,2,9,12,7,7,1,8,5,6
+N,5,11,7,8,6,7,7,8,5,7,5,6,3,7,3,8
+N,4,7,5,5,4,6,7,8,5,7,5,7,3,7,3,8
+P,4,10,4,7,2,4,10,10,3,9,6,4,2,10,4,8
+K,12,15,11,9,5,6,8,3,7,9,9,10,6,10,4,6
+A,1,0,2,1,0,7,4,2,0,7,2,8,2,7,1,8
+K,5,10,6,7,2,4,7,9,2,7,6,12,3,8,3,11
+G,7,11,8,8,5,6,6,7,8,10,7,11,2,10,5,9
+K,4,5,7,4,4,6,7,1,7,10,7,10,3,8,3,8
+A,3,10,6,7,4,11,3,2,2,9,2,9,3,7,3,9
+T,2,1,3,2,1,6,12,2,7,8,11,8,1,10,1,7
+Q,4,9,5,8,3,8,6,9,7,6,5,9,3,8,4,8
+Y,3,4,5,6,1,7,12,2,3,8,12,8,1,10,0,8
+N,3,7,5,5,3,7,9,6,5,7,6,7,5,9,2,6
+L,2,6,2,4,1,0,1,5,6,0,0,7,0,8,0,8
+E,7,13,5,7,3,6,8,6,8,10,6,10,1,8,8,8
+J,1,3,2,5,1,12,3,9,3,13,5,13,1,6,0,8
+Z,2,1,2,2,1,7,7,3,11,9,6,8,0,8,7,8
+G,1,0,1,0,0,8,7,5,4,6,5,9,1,8,4,10
+U,5,9,6,7,6,8,8,8,5,5,7,9,3,8,4,6
+C,3,2,4,4,2,6,8,7,8,9,8,13,1,9,4,10
+G,8,12,6,6,5,8,8,4,3,9,5,6,4,9,9,8
+W,6,10,6,8,6,2,11,2,2,10,9,7,6,11,2,6
+J,4,9,6,6,4,7,6,4,5,8,6,7,5,6,4,6
+L,4,11,6,8,8,7,8,3,5,6,6,10,6,11,7,5
+R,5,10,7,8,6,6,8,5,6,6,5,8,3,6,6,9
+F,2,4,4,3,2,7,9,1,7,13,5,5,1,9,2,8
+Y,6,12,5,6,3,4,9,4,2,10,9,6,3,9,3,4
+Y,3,5,5,4,2,7,10,1,7,7,11,8,1,11,2,8
+H,2,1,3,3,2,6,7,5,6,7,6,8,3,8,3,8
+X,3,6,4,4,3,7,8,3,8,6,6,8,2,8,6,8
+R,5,11,7,8,10,6,7,3,4,6,6,9,7,10,8,6
+P,3,6,5,4,3,5,12,6,3,10,7,2,1,10,3,6
+U,3,3,3,5,1,7,5,13,5,7,14,8,3,9,0,8
+C,2,0,2,1,1,6,7,6,10,7,6,14,0,8,4,9
+R,1,0,2,1,1,6,9,7,3,7,5,8,2,7,4,11
+T,8,15,7,9,3,6,10,3,8,13,6,6,2,8,5,4
+Y,6,8,8,11,12,8,8,4,2,7,8,9,4,12,9,8
+O,4,7,4,5,3,7,7,8,6,9,7,10,3,8,3,7
+J,0,0,1,0,0,12,4,6,3,12,4,11,0,7,0,8
+R,3,4,5,3,3,9,7,3,5,11,3,6,2,7,3,9
+Z,1,3,3,2,1,8,7,2,9,11,6,8,1,8,5,7
+X,3,11,4,8,4,7,7,4,4,7,6,8,3,8,4,8
+U,2,3,3,2,1,5,8,5,6,10,9,9,3,9,2,6
+C,5,11,6,8,5,5,8,8,7,10,8,13,2,11,4,10
+V,5,11,7,8,8,8,5,5,3,8,7,9,9,9,6,11
+C,4,7,5,5,2,6,7,6,10,6,6,12,1,7,4,8
+M,8,10,11,7,7,5,6,4,5,11,10,11,11,5,4,7
+I,1,1,1,1,1,7,7,2,7,7,6,8,0,8,2,8
+U,1,0,2,1,0,8,6,11,4,7,12,8,3,10,0,8
+L,5,11,7,8,9,8,7,3,5,6,7,9,7,10,7,6
+J,1,3,1,2,0,10,6,2,5,11,4,9,0,7,1,7
+F,5,8,7,6,3,4,12,3,6,14,8,4,1,10,1,7
+G,2,4,3,3,2,6,7,5,5,9,7,10,2,9,4,9
+G,4,10,6,8,7,8,6,5,2,6,6,10,7,8,5,10
+A,2,1,3,1,1,7,4,2,0,7,2,8,2,6,2,8
+Q,2,0,2,1,1,8,7,6,4,6,6,9,2,8,3,8
+B,4,8,6,6,6,8,7,6,5,9,7,6,3,8,7,8
+P,1,0,1,0,0,5,10,7,1,9,6,5,1,9,2,8
+C,3,8,4,6,3,5,8,6,6,9,8,14,1,9,3,10
+E,2,4,4,3,2,6,8,2,8,11,7,9,2,8,4,8
+M,10,13,12,7,6,10,2,3,2,10,2,9,8,1,2,8
+L,2,6,2,4,1,0,2,5,6,0,0,7,0,8,0,8
+D,4,11,6,8,7,8,7,5,7,7,6,6,6,8,3,7
+B,2,6,3,4,3,6,7,7,5,7,6,7,2,8,6,9
+E,4,9,6,7,5,5,9,3,7,11,9,9,3,9,4,6
+Q,6,15,6,8,4,7,5,5,8,9,5,8,3,7,9,9
+M,7,6,9,5,9,7,8,5,4,6,5,8,13,7,5,8
+G,4,6,6,6,6,7,7,5,4,7,7,8,7,10,6,8
+U,3,6,5,4,4,8,8,8,5,6,7,9,3,8,4,6
+X,3,7,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+N,8,10,10,9,11,7,7,5,4,7,6,7,8,9,6,5
+W,5,6,5,4,4,3,10,2,3,10,9,8,6,11,2,6
+I,0,1,1,2,1,7,7,1,6,7,6,8,0,8,2,8
+F,5,5,5,7,2,1,15,5,3,12,9,4,0,8,3,6
+E,5,10,5,8,5,2,7,5,9,7,6,14,0,8,6,8
+Y,4,10,6,7,1,8,10,2,2,6,13,8,1,11,0,8
+B,4,8,6,6,5,10,6,3,6,10,4,7,3,8,5,11
+D,4,8,5,6,4,6,7,8,7,6,5,4,3,8,4,8
+O,2,1,2,2,1,8,7,7,5,7,6,8,2,8,3,8
+H,3,3,5,2,2,7,8,3,5,10,7,8,3,8,3,7
+Q,4,5,5,5,2,8,5,8,8,6,4,8,3,8,4,8
+Y,4,8,4,6,2,3,12,4,5,12,12,6,1,11,2,6
+B,3,8,4,6,5,8,7,8,5,7,6,6,3,8,7,10
+O,4,9,5,7,3,6,9,7,5,10,8,7,3,8,3,8
+P,3,4,5,3,3,7,10,6,3,11,4,3,1,10,3,8
+E,1,0,1,0,0,5,8,5,7,7,6,12,0,8,6,10
+O,3,7,4,5,2,8,8,8,6,6,7,9,3,8,4,8
+V,3,8,5,6,1,9,8,4,3,6,14,8,3,9,0,8
+Q,6,9,6,10,8,8,5,7,4,9,5,8,4,8,5,7
+K,4,8,5,6,7,8,7,3,4,6,6,8,6,8,7,5
+T,6,10,6,7,4,6,12,4,7,11,9,4,2,13,4,4
+C,5,9,6,7,3,4,8,6,9,12,9,12,1,9,3,7
+U,4,5,5,3,2,6,8,6,7,7,10,10,3,9,1,8
+N,1,0,2,1,0,7,7,11,0,5,6,8,4,8,0,8
+C,3,2,4,3,2,6,8,7,7,9,8,12,2,10,3,9
+K,7,10,9,8,5,4,8,3,8,11,11,11,4,6,5,5
+H,6,11,8,8,8,6,6,8,4,6,4,8,4,6,8,11
+P,6,10,5,5,3,4,12,6,1,12,6,4,3,10,4,8
+P,1,0,2,0,0,5,11,6,1,9,6,5,1,9,3,8
+U,3,3,4,2,1,5,8,5,7,11,10,8,3,9,2,6
+C,5,9,5,7,4,4,8,5,6,11,9,14,2,9,3,7
+U,5,4,6,3,2,4,8,5,8,10,9,9,3,9,2,6
+E,2,3,2,1,1,7,7,5,7,7,6,8,2,8,5,10
+V,10,15,9,8,5,6,9,4,4,9,8,5,5,12,3,8
+J,2,6,4,4,3,10,5,2,4,7,5,5,3,8,4,6
+Y,5,9,5,6,3,3,10,2,7,11,11,6,1,11,2,5
+B,4,6,5,4,4,8,9,3,5,10,5,5,3,8,5,8
+F,4,9,5,6,2,1,12,5,5,12,10,8,0,8,2,6
+L,8,12,8,6,4,8,4,4,5,12,8,11,3,9,6,9
+S,4,9,6,7,3,9,7,4,8,12,4,7,2,8,5,9
+O,2,6,3,4,3,7,8,7,5,7,9,8,2,9,3,7
+U,6,7,7,5,3,4,10,6,7,12,11,8,3,9,2,7
+R,3,7,4,5,2,5,10,8,3,7,5,8,2,8,6,11
+T,3,6,4,4,3,7,8,7,6,7,7,8,3,10,5,9
+Z,1,3,2,1,1,7,7,5,8,6,6,8,1,8,6,8
+O,5,6,6,9,3,8,7,9,8,7,6,9,3,8,4,8
+G,7,11,9,9,12,8,7,4,3,6,5,9,8,7,9,14
+K,6,9,9,8,9,6,7,2,4,7,4,9,7,5,10,10
+Y,8,10,6,15,5,4,9,3,1,9,10,5,4,10,7,5
+G,6,9,5,4,3,8,3,4,3,7,3,5,4,7,4,9
+H,4,5,7,4,4,7,8,3,6,10,6,8,3,8,3,8
+J,3,9,4,7,1,12,2,10,4,14,5,13,1,6,0,8
+T,3,5,4,4,2,6,10,1,8,11,9,5,1,9,3,4
+W,5,9,7,7,3,8,8,4,2,7,8,8,8,9,0,8
+B,2,4,4,3,3,8,7,2,5,10,5,6,2,8,4,9
+U,3,8,4,6,2,7,5,14,5,7,13,8,3,9,0,8
+F,1,3,3,2,1,5,11,3,4,13,7,5,1,9,1,7
+R,4,10,6,8,6,7,7,4,6,6,5,7,3,7,5,9
+U,3,9,4,7,2,7,5,15,5,7,12,8,3,9,0,8
+M,8,9,12,8,12,7,7,4,4,6,5,8,14,9,6,9
+P,3,4,5,2,2,7,11,4,3,12,4,2,1,9,2,9
+I,2,11,2,8,4,7,7,0,6,7,6,8,0,9,3,8
+J,3,5,5,6,4,8,9,4,5,7,6,8,3,8,8,9
+P,6,9,8,7,7,6,6,8,4,7,6,8,4,9,8,11
+U,4,8,6,6,6,10,6,4,5,6,7,6,5,8,4,6
+I,1,6,0,4,0,7,7,5,3,7,6,8,0,8,0,8
+P,4,7,6,5,3,7,12,4,5,14,5,1,0,10,3,8
+H,3,3,5,2,3,7,7,2,6,10,6,8,3,8,3,7
+V,4,2,6,4,2,7,13,3,4,8,12,8,3,10,2,8
+N,6,9,9,7,5,7,9,2,5,10,6,6,6,9,1,8
+G,6,11,7,8,4,7,6,7,7,11,6,13,3,9,5,8
+W,4,2,6,4,4,9,11,2,2,5,9,7,9,11,2,7
+S,5,11,6,8,6,8,8,5,8,5,5,8,0,8,9,8
+J,1,3,3,2,1,9,4,4,4,13,7,12,1,7,0,7
+B,3,7,4,5,3,6,6,9,7,6,6,7,2,8,9,9
+V,3,10,5,8,2,8,8,4,3,6,14,8,3,9,0,8
+E,4,9,4,6,4,3,6,5,9,6,7,13,0,8,7,9
+Q,5,6,5,8,5,8,4,6,5,10,5,10,4,7,6,7
+G,6,10,8,7,5,7,7,7,6,5,7,9,3,8,4,8
+X,3,6,5,5,5,9,6,2,6,8,6,7,3,10,8,6
+D,3,4,4,3,3,7,7,6,7,7,6,5,2,8,3,7
+G,5,9,6,6,7,9,6,5,2,6,6,10,6,7,5,11
+X,3,5,6,3,2,5,8,2,9,11,10,9,2,9,3,6
+F,6,10,9,7,5,5,12,4,5,13,8,4,2,10,2,6
+W,3,7,5,5,3,11,8,5,1,6,9,8,7,10,0,8
+Q,4,9,5,8,5,8,8,7,4,5,9,9,2,9,4,9
+Z,4,8,5,6,5,7,7,5,10,7,6,8,1,8,7,7
+W,6,9,8,6,7,7,7,6,3,8,8,7,7,9,5,10
+F,2,5,3,4,2,6,9,4,5,10,9,6,2,10,3,6
+Y,6,9,6,4,3,7,7,4,4,9,8,6,4,10,4,4
+I,1,9,0,7,1,7,7,5,3,7,6,8,0,8,0,8
+U,2,3,3,2,1,5,8,4,5,10,8,9,3,10,1,7
+A,4,11,7,8,6,7,5,1,4,5,2,6,5,6,6,6
+U,3,8,4,6,2,7,5,14,5,7,13,8,3,9,0,8
+D,1,3,2,2,1,9,6,4,4,10,3,5,2,8,2,8
+S,6,12,6,6,3,10,4,4,3,12,6,9,3,10,2,8
+U,1,3,2,1,1,9,8,6,5,5,9,7,3,10,0,8
+D,3,9,5,6,4,6,7,9,6,6,6,5,3,8,3,8
+I,2,6,3,4,1,7,7,1,8,14,6,8,0,8,1,8
+O,5,9,4,4,3,6,8,6,4,9,8,9,4,9,4,8
+V,3,7,5,5,1,8,8,4,2,6,14,8,3,10,0,8
+P,5,9,7,7,6,9,8,4,5,11,4,4,2,9,4,8
+T,2,10,4,7,1,7,14,0,6,7,11,8,0,8,0,8
+S,3,7,4,5,3,8,8,7,6,7,6,8,2,8,9,8
+G,3,6,4,4,2,8,6,7,7,6,6,9,1,7,6,11
+O,4,11,5,8,3,7,7,9,7,7,6,8,3,8,4,8
+X,5,9,8,6,4,10,6,2,8,10,2,7,3,8,3,9
+G,5,9,7,7,7,7,9,6,3,5,5,10,4,8,7,8
+U,6,9,6,7,4,5,7,7,8,8,6,9,3,9,3,4
+F,4,9,5,6,2,1,11,5,7,12,11,9,0,8,2,6
+Q,5,8,6,10,6,9,5,7,4,9,5,11,4,8,6,7
+M,1,0,2,0,1,7,6,9,0,7,8,8,6,6,0,8
+B,7,13,7,7,6,10,6,4,5,9,5,8,6,8,8,9
+C,5,8,6,6,2,3,10,5,8,12,11,10,1,8,2,6
+K,7,9,10,8,10,9,7,3,4,9,2,8,8,4,8,12
+R,1,1,2,1,1,6,9,8,4,7,5,8,2,7,4,11
+A,6,11,8,9,8,7,7,8,4,8,5,8,4,8,10,1
+Q,6,7,6,9,7,8,5,7,4,8,6,7,6,8,6,9
+K,4,10,5,7,2,3,8,8,2,7,5,11,3,8,3,10
+I,1,6,1,4,1,7,7,0,7,7,6,9,0,8,3,8
+V,5,6,5,4,3,4,12,1,2,8,10,7,3,11,1,7
+F,2,1,3,2,1,5,11,3,5,11,9,5,1,10,3,6
+O,4,8,5,6,4,7,8,8,5,10,7,8,3,8,3,8
+A,2,7,4,5,3,12,3,2,2,9,2,9,3,7,3,9
+N,6,10,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+C,2,1,2,2,1,6,8,7,7,9,7,12,1,10,4,10
+W,1,0,1,0,0,7,8,3,0,7,8,8,3,9,0,8
+M,5,7,6,5,7,8,8,6,5,7,6,8,7,9,7,6
+Q,5,9,6,11,7,7,9,4,3,8,10,10,4,10,8,8
+C,3,8,4,6,3,5,7,6,7,7,5,11,1,8,4,10
+A,7,9,10,8,8,6,8,2,4,7,7,9,8,6,4,8
+Y,3,5,5,8,1,6,10,2,2,7,13,8,2,11,0,8
+I,1,11,0,8,1,7,7,5,3,7,6,8,0,8,0,8
+B,5,9,7,8,9,7,7,5,4,7,6,8,6,9,8,7
+G,4,7,4,5,2,6,7,6,6,10,8,9,2,9,4,9
+L,4,9,4,5,2,9,3,4,5,12,4,13,2,6,5,9
+I,2,8,3,6,2,8,7,0,7,13,6,8,0,8,1,8
+Y,8,10,7,5,4,8,6,4,6,9,6,5,4,10,4,6
+K,3,6,5,4,5,8,6,4,4,7,6,8,6,7,6,8
+X,5,11,9,9,7,6,8,2,6,7,6,9,6,5,8,7
+V,8,10,7,8,5,3,12,2,3,9,11,8,7,11,2,6
+S,8,11,9,8,6,7,8,3,6,10,5,7,4,6,6,8
+K,3,7,5,5,5,5,6,3,4,6,5,9,5,7,8,7
+A,3,8,5,5,2,7,5,3,1,7,1,8,2,7,2,7
+S,9,13,8,7,4,9,4,4,3,13,8,10,4,9,3,9
+D,2,4,4,3,2,8,7,5,6,9,5,5,2,8,3,7
+Q,6,9,8,7,6,8,4,9,5,7,4,8,3,8,4,8
+N,10,13,9,7,4,4,9,4,7,3,3,11,5,8,2,7
+Z,5,7,7,9,6,10,5,4,4,8,2,6,2,7,7,8
+A,4,9,7,7,4,8,2,2,3,6,1,7,2,7,3,7
+B,4,6,5,4,4,8,7,5,6,9,6,6,2,8,6,9
+U,5,8,5,6,2,7,4,14,5,7,14,8,3,9,0,8
+S,3,5,6,3,2,6,8,2,7,10,7,8,1,9,5,6
+P,3,1,4,2,2,5,10,4,4,10,8,4,1,9,4,7
+C,3,2,4,4,2,6,8,7,7,8,7,13,1,9,4,10
+Q,1,0,2,1,1,8,7,6,4,6,6,9,2,8,3,8
+Q,5,6,7,9,8,8,11,4,3,5,8,11,5,13,7,11
+E,3,8,5,6,4,4,8,5,8,11,10,9,2,9,4,5
+D,2,4,4,3,2,9,6,4,6,10,4,5,2,8,3,8
+G,4,2,5,4,3,7,6,6,6,6,6,9,2,8,4,8
+V,2,1,4,2,1,6,13,3,2,8,11,8,2,10,1,8
+A,4,10,7,7,2,7,5,3,1,7,1,8,3,7,2,8
+A,2,8,4,6,2,12,3,3,2,10,1,9,2,6,2,8
+R,3,2,4,4,3,7,7,5,5,6,5,7,3,6,6,9
+S,3,5,4,4,2,8,7,3,7,10,6,8,1,9,5,8
+Q,5,9,5,4,3,8,5,4,8,10,4,9,3,7,8,10
+Z,6,9,9,7,6,8,6,2,9,11,5,9,3,5,7,8
+C,7,10,8,8,5,3,7,5,7,11,10,14,2,9,3,7
+F,6,12,5,6,3,4,12,3,5,12,7,4,2,7,5,5
+B,4,10,5,8,7,7,8,9,6,7,6,7,2,7,8,10
+R,3,7,3,5,3,5,9,7,3,7,5,8,2,7,4,11
+W,8,10,9,8,6,1,10,3,3,11,11,9,7,10,1,7
+K,6,10,8,7,6,6,6,1,7,10,6,10,4,8,4,8
+P,2,4,4,3,2,8,8,3,5,12,4,4,1,10,2,8
+O,3,6,4,4,3,7,8,7,4,9,7,8,3,8,2,8
+J,5,8,4,6,3,8,7,2,4,11,6,8,2,10,6,11
+A,6,9,5,4,2,11,3,3,1,9,4,11,4,5,4,9
+P,3,7,5,5,3,9,8,2,5,12,4,5,1,10,2,9
+N,10,13,12,8,5,4,9,3,4,13,10,9,6,8,0,7
+M,3,2,5,3,3,9,6,6,4,6,7,6,7,5,2,6
+P,3,7,5,11,8,8,9,5,0,8,6,6,5,11,6,9
+Z,3,7,5,5,3,6,8,2,9,11,7,7,1,9,6,7
+S,4,6,5,4,3,9,8,3,7,10,4,7,2,7,4,9
+X,1,0,1,0,0,8,7,3,4,7,6,8,2,8,4,8
+P,4,8,4,5,2,5,10,9,5,9,6,5,2,10,4,8
+C,6,11,6,8,4,5,8,7,8,12,9,12,2,10,4,6
+P,5,8,7,6,5,9,8,2,6,13,5,5,2,9,3,9
+D,3,7,3,5,2,5,6,10,7,5,4,5,3,8,3,8
+Z,2,4,5,3,2,7,8,2,9,12,7,7,1,8,5,6
+Y,7,6,6,9,4,6,8,4,2,7,10,5,4,10,5,6
+L,1,3,3,1,1,6,4,1,7,7,2,9,0,7,2,8
+K,4,5,5,4,3,5,7,4,8,7,6,10,6,8,5,9
+T,6,9,6,6,4,7,11,3,9,12,9,4,2,12,3,4
+R,2,1,2,1,1,6,10,7,2,7,5,8,2,7,4,10
+T,4,11,5,8,2,5,15,1,6,9,11,7,0,8,0,8
+A,8,14,8,8,6,9,4,5,4,10,6,12,9,2,7,11
+H,5,10,5,7,3,7,5,15,1,7,8,8,3,8,0,8
+Z,5,7,6,5,4,8,5,2,9,11,4,10,2,8,6,10
+G,4,4,6,6,2,8,5,8,9,6,5,10,2,8,5,10
+U,3,1,4,1,1,7,9,5,6,7,10,9,3,10,1,8
+B,4,8,6,6,4,11,6,3,7,11,3,7,2,8,5,11
+L,7,13,6,7,3,7,4,3,6,11,4,13,2,7,6,8
+V,7,9,9,8,10,7,6,5,4,7,6,7,7,10,8,11
+B,2,5,4,3,3,8,7,3,6,9,5,7,2,8,5,10
+Q,1,1,2,2,2,8,7,5,2,5,6,9,2,9,4,10
+G,6,11,7,8,5,6,7,7,7,10,8,10,2,8,5,9
+D,4,8,6,6,5,7,8,8,6,9,7,4,4,9,3,7
+K,7,10,7,5,3,7,6,3,6,9,8,9,6,11,3,7
+Y,4,5,5,7,7,9,6,6,3,7,7,8,7,8,6,4
+W,4,8,6,6,3,6,8,4,1,7,8,8,8,9,0,8
+Y,4,4,5,6,5,9,9,5,3,7,7,7,5,10,6,4
+H,4,4,4,5,2,7,6,15,1,7,8,8,3,8,0,8
+S,7,10,5,5,2,9,2,3,4,9,2,9,3,6,5,10
+Q,8,15,8,8,5,11,4,5,7,12,3,10,3,7,8,12
+D,6,5,6,8,3,5,7,10,10,7,6,5,3,8,4,8
+G,3,8,5,6,4,6,6,6,6,7,5,11,2,10,4,9
+F,4,11,4,8,3,1,11,4,5,11,11,9,0,8,2,6
+U,2,3,3,2,1,5,8,5,6,10,9,8,3,9,2,6
+S,2,5,2,4,2,8,8,7,5,8,5,7,2,8,8,8
+A,3,9,5,7,3,11,3,2,2,9,2,9,3,5,3,8
+C,2,2,3,3,2,6,8,7,8,8,7,13,1,9,4,10
+I,3,9,5,7,3,7,7,0,7,13,6,8,0,8,1,8
+I,1,1,1,2,1,7,7,1,6,7,6,8,0,8,2,8
+H,3,3,5,2,2,7,8,3,6,10,7,7,3,8,3,8
+Y,3,5,5,8,6,7,10,3,3,7,8,9,4,10,9,5
+W,4,8,7,6,9,9,8,5,2,7,7,7,12,10,4,6
+P,3,7,5,11,9,9,8,4,1,8,6,7,7,9,5,6
+F,6,11,6,8,2,1,12,5,6,12,11,8,0,8,2,5
+J,0,0,1,1,0,12,4,6,3,12,5,11,0,7,0,8
+U,2,4,3,3,2,5,8,5,6,10,9,9,3,9,2,6
+H,8,11,12,9,10,6,7,3,7,10,8,9,5,8,5,7
+R,3,5,4,4,3,7,7,4,5,6,5,6,3,7,4,8
+C,3,8,4,6,3,5,7,6,8,5,6,12,1,7,4,10
+R,4,9,6,7,6,6,7,5,6,7,6,6,3,7,5,9
+B,4,8,6,6,8,8,8,4,3,6,7,7,6,11,8,9
+M,6,9,10,7,11,10,5,3,2,9,4,8,11,6,4,7
+O,4,8,5,6,4,7,7,7,6,7,5,8,2,8,3,8
+C,6,11,7,8,5,5,8,7,6,8,8,15,4,9,6,6
+E,3,4,5,3,2,6,8,2,8,11,8,9,2,8,4,7
+Z,1,4,2,3,1,8,7,5,8,6,6,8,1,8,7,7
+M,6,11,8,8,8,8,6,5,5,6,7,8,8,6,2,7
+E,3,7,3,5,2,3,7,6,11,7,7,15,0,8,7,7
+U,4,10,5,8,4,8,6,12,4,7,13,7,3,8,0,9
+R,3,8,3,6,4,5,9,7,3,7,5,8,2,7,5,11
+D,4,11,4,8,3,5,7,11,8,7,6,5,3,8,4,8
+F,5,7,6,5,6,7,8,6,4,8,6,8,3,10,8,11
+C,7,11,8,8,5,5,7,5,7,12,9,13,4,11,5,5
+L,5,10,6,8,4,7,4,2,8,7,1,8,1,6,3,7
+F,5,11,6,8,7,6,9,6,4,8,6,8,3,10,8,11
+S,2,4,4,3,2,9,6,3,7,10,4,8,1,9,5,9
+C,6,9,8,8,8,5,7,3,5,7,6,11,4,11,8,8
+U,4,6,4,4,3,7,5,12,4,7,12,8,3,9,0,8
+P,6,13,6,7,4,8,9,4,3,12,4,4,4,11,5,6
+H,3,6,4,4,2,7,7,14,0,7,6,8,3,8,0,8
+H,3,5,6,3,3,7,7,3,6,10,6,8,3,8,3,7
+H,4,5,5,4,4,8,7,6,6,7,6,8,3,8,3,7
+V,4,7,4,5,2,2,11,3,3,11,11,8,2,11,0,8
+J,4,11,5,8,4,8,5,3,7,12,4,10,1,6,2,6
+Z,2,1,3,3,2,7,7,5,9,6,6,8,1,8,7,8
+M,4,3,5,5,3,7,7,12,1,7,9,8,8,6,0,8
+I,1,1,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+S,7,11,7,6,3,9,5,4,4,13,6,8,2,9,3,8
+J,1,4,2,3,1,10,7,1,7,11,4,7,0,7,1,7
+W,10,15,10,8,5,4,9,2,2,8,10,8,9,12,1,6
+N,6,9,9,7,5,9,8,2,5,10,2,4,7,10,2,7
+I,1,1,1,3,1,7,7,1,6,7,6,8,0,8,2,8
+M,5,6,7,4,6,7,6,5,5,8,6,11,10,5,2,9
+E,3,8,4,6,3,7,8,6,10,6,4,9,3,8,6,8
+G,4,7,5,5,3,7,7,6,7,10,7,11,2,9,4,9
+P,2,3,3,1,1,5,9,4,4,9,8,5,1,9,3,7
+R,5,11,7,8,6,10,7,3,5,10,3,7,3,7,4,10
+Z,2,3,3,2,2,7,7,5,9,6,6,8,1,8,7,8
+O,2,4,3,3,2,7,7,6,4,9,6,8,2,8,2,8
+W,4,8,6,6,6,5,11,2,2,7,8,8,7,11,1,8
+A,2,4,3,3,1,11,3,3,2,11,2,9,2,6,2,9
+J,0,0,1,0,0,12,4,5,3,12,5,11,0,7,0,8
+T,3,5,4,4,3,9,12,4,5,5,11,9,2,12,1,8
+X,2,1,3,3,2,7,7,3,8,6,6,8,2,8,6,8
+J,2,7,3,5,1,14,2,6,5,14,2,11,0,7,0,8
+D,2,2,3,3,2,7,7,6,6,7,6,5,2,8,3,7
+J,2,9,3,6,2,10,6,1,7,11,3,6,0,7,1,7
+X,3,8,5,6,3,8,7,4,8,6,6,8,3,8,6,8
+J,1,7,2,5,2,10,6,1,5,11,4,8,0,6,1,7
+W,4,4,6,3,3,8,11,3,2,6,9,8,8,12,1,7
+A,3,9,5,7,3,11,4,2,2,8,2,9,3,5,3,8
+R,3,5,5,4,3,9,7,3,5,10,4,6,3,7,4,10
+V,6,11,6,8,4,3,11,1,2,9,10,8,4,11,1,7
+T,8,11,7,6,3,7,9,4,8,13,6,8,2,7,4,6
+V,5,8,5,6,2,3,11,3,4,10,11,7,2,10,1,8
+B,1,0,1,0,1,7,7,6,4,6,6,7,1,8,5,9
+G,2,1,3,2,2,7,7,5,5,7,6,10,3,7,4,9
+B,4,9,6,6,5,9,6,4,6,10,5,7,3,7,6,9
+N,5,9,5,7,3,7,7,15,2,4,6,8,6,8,0,8
+K,2,3,3,2,2,6,7,4,7,6,6,10,3,8,4,9
+U,3,6,4,4,1,7,4,13,5,7,13,8,3,9,0,8
+L,3,7,4,5,3,5,4,5,7,2,2,5,1,6,1,5
+O,2,4,3,3,2,8,7,6,3,9,6,8,2,8,2,8
+W,5,5,7,8,4,9,8,4,2,7,8,8,9,9,0,8
+H,4,11,6,8,7,7,7,5,6,7,6,9,6,8,3,8
+B,8,12,6,6,4,9,5,4,5,10,5,9,5,7,7,10
+V,5,8,5,6,3,3,12,3,3,10,11,8,2,10,1,8
+D,4,6,6,4,5,9,6,4,5,10,3,6,3,7,3,8
+Q,3,5,4,8,7,8,7,5,0,6,6,9,7,10,6,12
+G,7,12,6,7,3,10,4,4,4,10,3,6,4,7,5,9
+D,4,7,5,5,3,6,7,10,10,6,5,6,3,8,4,8
+G,6,10,8,8,6,6,6,6,6,5,6,11,2,9,4,8
+L,1,4,2,3,1,6,4,2,7,7,2,9,0,7,2,8
+D,6,9,6,5,3,8,6,5,5,10,4,6,4,7,6,10
+H,1,0,2,0,0,7,7,11,1,7,6,8,3,8,0,8
+V,3,3,5,4,1,8,8,4,2,6,14,8,3,10,0,8
+T,3,9,5,7,3,7,12,3,7,7,12,8,1,12,1,8
+W,4,8,7,6,4,7,10,2,3,7,9,8,8,11,1,8
+I,1,5,3,4,1,7,7,0,7,13,6,8,0,8,1,8
+M,3,6,4,4,4,9,6,6,4,6,7,5,7,5,2,6
+E,3,8,4,6,5,6,7,3,4,6,7,10,4,11,8,7
+U,5,5,6,7,2,7,4,14,6,7,15,8,3,9,0,8
+A,3,5,5,3,2,10,2,2,2,10,2,9,2,6,2,7
+M,11,15,11,8,6,9,11,6,4,4,6,9,10,12,2,7
+M,3,4,5,3,3,8,6,6,4,7,7,8,7,5,2,7
+A,3,9,5,7,3,10,2,2,2,8,1,8,2,7,3,8
+L,4,8,6,7,6,7,6,5,5,7,7,7,3,9,8,11
+R,4,8,5,6,4,7,9,6,5,7,6,8,3,7,6,9
+U,6,11,7,8,6,8,5,13,5,6,12,8,3,9,0,8
+E,0,0,1,0,0,5,7,5,6,7,6,12,0,8,5,11
+E,4,7,6,6,5,5,9,3,5,8,7,9,4,10,7,7
+P,7,15,7,8,5,8,9,4,4,12,5,4,4,11,6,6
+U,3,7,4,5,3,8,5,12,4,7,11,8,3,9,0,8
+N,5,10,7,8,4,3,9,4,4,10,11,10,5,7,1,8
+K,3,7,5,5,5,8,7,4,4,7,6,7,4,6,8,13
+X,5,5,6,8,2,7,7,5,4,7,6,8,3,8,4,8
+O,1,0,1,0,0,7,7,6,3,7,6,8,2,8,3,8
+D,6,5,6,8,3,5,7,10,9,7,6,5,3,8,4,8
+J,3,7,4,5,1,8,6,3,7,15,5,10,0,7,1,7
+E,5,10,7,8,4,5,9,3,9,11,9,9,2,9,5,5
+D,3,6,3,4,2,6,8,10,8,7,7,6,3,8,4,8
+Q,3,3,4,5,3,8,8,7,2,5,7,9,2,9,5,9
+D,9,15,8,8,6,8,6,3,7,10,5,6,6,7,9,6
+O,3,4,4,3,2,7,7,7,4,9,7,9,2,8,3,8
+Z,8,8,6,11,5,7,7,4,3,11,6,8,3,9,11,6
+R,5,6,6,8,4,5,12,8,3,7,3,9,3,7,7,11
+R,4,7,5,5,4,11,7,2,5,11,3,7,3,7,3,11
+E,5,10,5,8,3,3,8,6,12,7,5,15,0,8,7,7
+Y,7,10,7,7,3,2,11,5,6,13,13,7,2,11,2,6
+I,0,7,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+W,4,7,6,5,3,4,8,5,1,7,9,8,8,10,0,8
+K,4,10,6,7,6,6,7,3,7,6,5,8,3,8,5,9
+F,2,6,3,4,3,6,10,3,5,10,9,5,2,10,3,6
+B,5,5,5,7,4,6,7,9,6,7,6,6,2,8,9,10
+D,3,7,4,5,3,6,7,8,6,7,6,4,3,8,3,7
+Q,5,8,6,9,6,8,7,7,4,9,8,9,4,9,7,9
+U,8,10,9,8,4,3,8,6,8,10,10,9,3,9,2,5
+N,7,10,10,7,4,6,8,3,5,10,8,8,6,7,1,7
+C,2,3,2,2,1,4,9,5,6,12,9,10,1,9,2,7
+A,5,9,9,7,6,5,5,2,4,3,2,7,6,7,7,2
+B,2,2,3,3,2,8,7,5,5,6,5,5,2,8,6,9
+C,9,14,6,8,3,7,8,7,7,11,6,7,2,9,6,8
+T,3,5,5,6,1,8,15,1,5,7,11,8,0,8,0,8
+Y,2,4,4,5,1,8,10,2,2,6,12,8,1,11,0,8
+Q,4,6,6,5,6,8,4,4,4,7,4,10,5,6,7,7
+G,6,11,5,6,3,11,4,3,4,10,2,7,4,7,4,9
+G,5,11,7,8,5,6,6,7,7,6,5,10,2,9,4,8
+A,3,8,6,5,2,6,5,3,0,6,1,8,2,7,2,7
+L,4,10,6,8,3,7,4,0,9,9,2,10,0,7,3,8
+L,3,6,4,5,4,8,6,5,5,7,7,9,3,8,7,10
+Y,9,12,8,7,5,6,6,5,4,9,9,6,5,11,4,6
+D,1,1,2,1,1,6,7,8,6,6,6,6,2,8,3,8
+D,5,10,8,8,5,9,8,5,8,10,5,4,4,7,5,9
+A,3,9,5,7,4,9,3,2,2,7,2,8,2,6,3,6
+P,7,15,7,8,5,6,11,3,5,13,6,3,3,9,5,5
+D,4,10,5,7,3,5,7,10,9,6,6,5,3,8,4,8
+O,4,8,5,6,4,8,6,8,4,7,4,8,3,8,3,8
+U,5,6,5,4,4,5,8,5,6,9,7,10,3,9,3,6
+S,4,7,5,5,3,5,9,3,6,10,7,6,3,7,4,5
+E,7,10,9,7,7,5,9,2,8,11,8,9,3,8,5,6
+U,5,8,6,6,5,8,6,8,5,7,6,9,3,8,4,6
+C,5,9,6,7,4,4,8,7,8,7,8,14,2,8,4,10
+P,5,11,6,8,3,5,9,11,6,8,6,5,2,10,4,8
+U,2,0,2,1,0,7,5,11,4,7,13,8,3,10,0,8
+B,3,6,4,4,4,9,6,3,5,10,4,7,2,8,4,10
+D,6,9,8,6,5,10,6,4,7,10,4,6,5,9,5,8
+Y,4,6,6,8,1,7,11,2,3,7,12,8,1,11,0,8
+A,3,7,5,5,3,8,2,2,2,7,1,8,2,7,3,7
+G,7,12,6,6,4,7,6,4,3,9,6,8,4,9,9,8
+O,6,11,7,8,6,7,8,8,7,7,6,6,4,7,5,10
+H,4,3,5,4,4,6,7,6,6,7,6,10,3,8,3,8
+Y,3,6,5,8,1,10,11,2,4,4,12,8,0,10,0,8
+K,3,2,4,4,3,5,7,4,7,7,6,11,3,8,5,9
+B,5,10,5,7,7,6,7,8,5,7,6,7,2,8,7,10
+M,2,3,4,1,2,5,7,4,3,10,10,10,4,7,1,6
+C,3,7,5,6,5,5,8,3,5,7,7,11,3,9,6,10
+Q,4,7,6,6,5,6,4,4,5,6,4,7,3,5,6,6
+S,6,9,8,8,9,8,8,4,5,7,7,7,5,10,10,10
+I,4,10,6,8,4,5,6,2,6,7,7,12,0,9,4,9
+R,7,11,9,8,6,9,8,4,7,9,3,7,3,6,5,11
+D,8,11,8,6,4,9,6,5,6,12,4,8,6,6,6,10
+X,5,9,8,6,4,5,8,2,8,11,11,9,3,9,4,6
+Q,3,5,4,5,3,8,7,7,4,6,6,9,2,8,4,9
+L,3,5,4,4,2,4,4,4,8,2,1,6,0,7,1,6
+R,3,7,5,5,5,8,7,7,5,8,6,7,3,8,5,9
+H,9,13,9,7,5,10,6,4,5,9,5,5,7,10,5,9
+K,4,5,5,7,2,4,7,9,2,7,5,11,4,8,2,11
+I,1,9,2,6,2,7,7,0,6,7,6,8,0,8,2,8
+A,2,6,5,4,3,5,5,2,2,4,2,7,2,6,3,3
+D,4,6,6,4,4,7,7,4,6,7,6,8,6,8,3,7
+G,3,7,4,5,2,8,7,8,7,6,6,9,2,7,5,11
+Y,3,9,5,6,1,8,10,3,2,6,13,8,2,11,0,8
+A,3,9,6,7,4,13,3,3,3,11,1,9,2,6,2,9
+U,7,10,6,5,3,6,6,4,5,4,8,7,5,8,2,6
+I,1,1,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+Q,2,1,2,1,1,8,7,6,4,6,6,8,2,8,3,8
+J,1,3,2,2,0,9,6,3,6,14,6,10,0,7,0,8
+N,6,9,9,8,8,7,9,4,4,7,4,7,9,7,6,6
+A,2,3,3,2,1,10,2,2,1,8,2,9,1,6,1,8
+O,4,5,5,8,2,8,7,9,7,7,5,8,3,8,4,8
+K,4,7,6,5,3,6,6,2,7,10,7,10,3,8,4,8
+M,4,8,5,6,5,7,5,10,0,7,8,8,8,5,2,10
+L,5,11,5,8,3,0,1,5,6,0,0,7,0,8,0,8
+E,5,7,6,6,6,5,7,4,3,7,6,8,5,11,9,8
+G,4,7,5,5,5,9,5,5,2,7,6,10,5,10,3,9
+H,3,5,5,4,3,9,6,3,6,10,4,8,3,8,3,9
+S,4,9,5,6,6,9,7,5,3,8,6,8,4,8,10,9
+T,6,7,6,5,3,7,11,3,7,11,8,4,4,10,4,4
+B,3,6,4,4,3,6,6,8,6,6,6,7,2,8,9,10
+A,2,7,4,5,3,11,3,2,2,9,2,9,2,6,3,8
+W,5,8,7,6,3,5,8,5,1,7,8,8,8,9,0,8
+M,6,9,9,6,10,10,3,3,2,9,4,8,11,5,3,7
+T,5,10,6,7,5,8,11,3,7,6,11,8,2,12,1,8
+O,4,8,6,6,2,6,7,8,8,7,6,7,3,8,4,8
+N,6,9,5,4,2,9,11,5,4,4,6,10,5,11,3,7
+M,4,5,7,3,4,7,6,3,4,9,7,8,7,5,2,8
+U,7,9,7,7,5,3,8,5,7,10,9,9,3,9,2,6
+H,3,5,4,3,3,8,7,6,6,7,6,6,3,8,3,6
+N,6,10,9,7,5,6,10,5,4,8,7,9,7,7,2,8
+J,7,12,5,9,5,8,9,2,4,11,6,7,2,9,8,9
+I,1,4,2,3,1,7,7,0,7,13,6,8,0,8,1,8
+O,3,8,4,6,2,7,8,9,7,7,7,8,3,8,4,8
+B,3,8,5,6,5,9,7,4,5,10,5,7,2,8,5,9
+Q,4,6,6,9,9,9,7,6,1,7,6,9,10,9,5,7
+K,5,11,6,8,2,3,7,8,2,7,6,11,4,8,2,11
+Z,7,9,7,5,4,7,7,2,9,12,6,8,3,7,6,6
+R,2,3,3,2,2,8,8,3,4,9,5,7,2,7,3,9
+B,3,4,5,3,3,7,8,3,5,10,6,6,2,8,5,9
+V,7,9,7,7,4,3,12,2,3,9,11,8,4,12,1,7
+R,6,12,6,7,5,10,6,3,5,10,4,8,6,8,6,10
+Z,2,1,2,2,1,7,7,3,11,9,6,8,0,8,6,8
+F,4,9,6,6,3,6,11,3,6,13,7,4,1,10,2,7
+S,4,8,5,6,2,7,7,6,9,5,6,8,0,8,9,7
+T,2,7,3,4,1,10,14,1,6,4,11,9,0,8,0,8
+B,3,6,5,4,6,8,6,5,4,7,7,8,7,9,7,8
+P,5,6,7,4,3,9,8,4,6,12,4,5,2,9,4,9
+Y,7,10,7,7,3,4,10,2,8,11,11,6,1,10,3,3
+A,5,6,7,5,5,8,8,3,4,7,8,8,5,9,3,6
+V,5,6,5,4,2,3,12,5,4,11,11,7,3,10,1,8
+P,3,9,5,7,5,6,9,4,5,9,8,4,1,10,4,7
+C,7,11,5,6,2,7,7,7,7,12,6,9,2,9,5,9
+H,4,8,6,6,7,8,7,4,3,6,6,7,7,8,7,6
+A,3,4,5,3,2,10,2,2,2,8,2,9,4,5,2,9
+A,3,6,6,4,4,8,5,2,4,7,2,6,2,6,4,6
+L,5,10,5,5,3,8,5,3,5,12,7,11,2,9,6,9
+J,3,8,4,6,2,8,7,1,8,12,5,8,0,6,2,6
+R,8,12,6,6,4,11,5,5,5,11,2,8,6,6,6,10
+T,2,6,3,4,1,7,13,0,5,7,10,8,0,8,0,8
+M,5,10,6,8,4,7,7,12,2,8,9,8,8,6,0,8
+W,7,7,7,5,6,4,11,2,2,10,9,7,7,11,2,6
+Y,5,7,7,10,10,8,8,4,2,7,8,9,4,11,9,8
+O,3,10,5,8,4,8,8,8,6,6,6,11,3,8,4,7
+H,8,10,12,8,7,7,8,3,7,10,5,7,3,8,3,8
+R,4,9,5,7,5,7,7,5,6,6,5,7,3,7,5,8
+B,6,11,7,8,8,8,7,5,5,7,5,7,4,8,6,8
+N,6,8,9,6,5,4,10,3,4,10,10,8,5,8,1,8
+S,2,4,2,2,1,8,8,6,5,7,5,7,2,8,8,8
+J,3,10,5,8,5,8,7,2,5,11,5,9,5,6,3,4
+L,2,7,3,5,1,0,2,3,5,1,0,8,0,8,0,8
+B,9,14,7,8,5,6,8,5,7,10,6,8,6,6,7,9
+A,3,9,5,7,3,11,3,3,4,11,2,9,2,6,3,8
+D,3,7,5,5,4,7,7,7,4,6,5,6,3,8,3,7
+J,7,10,5,8,4,7,10,3,2,12,5,5,2,9,8,9
+X,3,5,6,4,3,6,7,1,9,11,9,9,3,8,3,7
+U,2,0,3,1,1,7,5,11,5,7,14,8,3,10,0,8
+Q,1,0,2,1,0,8,7,7,3,6,6,9,2,8,3,8
+N,2,1,3,2,2,7,8,5,4,7,6,6,4,8,1,6
+Y,4,7,5,5,5,9,6,5,4,7,8,7,3,9,8,4
+Y,7,6,6,9,3,6,12,2,3,10,10,6,4,11,5,7
+M,5,11,8,8,8,9,7,5,5,6,7,5,10,8,3,5
+D,4,8,4,6,2,5,7,10,9,6,6,5,3,8,4,8
+H,4,7,6,9,5,10,11,3,2,7,8,8,3,11,7,10
+C,7,10,8,8,5,5,8,6,7,12,9,12,3,11,4,6
+Q,1,2,2,2,1,8,8,4,2,8,7,9,2,9,3,9
+A,2,3,4,4,2,8,3,1,2,7,2,8,2,6,2,7
+T,2,7,4,5,2,8,12,4,6,6,11,8,2,12,1,8
+J,6,8,8,9,7,8,8,4,7,6,7,7,4,11,11,9
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+F,9,13,8,7,6,7,9,3,5,11,6,6,5,8,8,7
+P,6,9,8,7,7,7,7,5,5,7,6,9,6,8,7,10
+U,4,6,5,4,3,6,7,5,6,8,6,8,3,9,3,6
+X,6,11,8,9,7,8,6,3,5,6,7,8,3,9,9,9
+P,4,5,4,3,3,5,10,5,4,10,8,4,1,10,4,7
+G,3,8,4,6,3,6,6,6,6,7,5,11,3,10,4,8
+W,3,5,5,3,3,5,11,2,2,8,9,9,6,10,0,8
+H,2,3,4,2,2,7,7,2,5,10,5,8,3,7,2,8
+Z,3,8,4,6,2,7,7,3,13,10,6,8,0,8,8,8
+S,2,1,2,2,1,8,8,6,5,8,6,7,2,8,8,8
+S,7,12,7,7,4,10,3,4,3,13,6,10,3,9,3,9
+M,5,10,5,8,4,7,7,12,2,7,9,8,8,6,0,8
+G,4,8,5,6,3,5,6,5,6,6,6,9,2,8,4,7
+R,6,11,6,8,4,5,11,9,3,7,4,8,3,8,6,11
+R,9,11,7,6,4,10,6,6,5,11,2,8,6,6,5,10
+I,1,6,0,4,1,7,7,5,3,7,6,8,0,8,0,8
+U,6,9,8,8,7,7,7,5,4,5,7,8,7,7,2,6
+O,5,5,6,7,3,7,7,9,8,7,5,7,3,8,4,8
+B,9,12,8,7,7,7,8,4,5,9,6,7,8,5,9,7
+N,3,7,5,5,3,4,10,3,3,10,10,9,5,8,1,7
+J,4,9,6,7,3,6,9,2,6,14,6,7,1,7,1,7
+A,3,10,6,7,2,7,3,3,3,7,1,8,3,6,3,7
+P,3,2,4,3,2,5,10,4,5,10,8,3,1,10,4,7
+Y,2,1,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+Y,5,5,7,8,8,8,8,7,3,7,7,8,6,10,6,4
+N,6,7,8,5,4,9,7,3,5,10,2,5,5,9,1,7
+I,1,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+F,5,10,5,6,2,6,10,3,5,13,6,5,2,8,5,6
+B,4,6,7,6,6,7,10,6,6,8,7,8,5,9,7,9
+H,6,11,8,8,7,10,7,3,6,10,3,7,6,8,5,9
+Q,5,9,5,4,3,12,3,3,4,10,3,8,3,9,5,12
+L,4,10,6,8,3,3,4,3,10,2,0,7,0,7,1,5
+E,4,8,5,6,5,7,7,5,8,7,7,9,3,8,6,9
+N,4,11,4,8,5,8,7,12,1,6,6,7,5,8,0,9
+R,4,7,6,5,4,9,7,4,6,9,4,7,3,7,5,11
+G,4,9,5,7,4,5,7,6,5,9,8,10,2,8,4,9
+L,5,12,5,7,3,10,2,3,4,12,4,11,2,8,4,10
+S,8,11,9,9,6,5,8,3,6,10,8,8,3,8,5,5
+Y,7,9,6,5,3,4,7,5,3,9,11,6,4,10,3,4
+E,2,0,2,1,1,5,7,5,8,7,6,12,0,8,7,9
+T,5,7,6,5,5,6,7,7,6,7,6,8,3,9,6,10
+J,2,5,5,4,2,10,5,4,5,14,5,11,1,6,1,7
+F,3,8,3,6,1,1,14,5,3,12,10,5,0,8,2,6
+Z,4,8,5,6,2,7,7,4,14,9,6,8,0,8,8,8
+V,6,9,6,4,2,5,12,5,2,11,7,4,3,11,2,7
+A,2,3,3,1,1,8,2,2,1,7,2,8,2,6,2,7
+I,2,2,1,4,1,7,7,1,8,7,6,8,0,8,3,8
+V,2,7,4,5,2,5,11,3,3,9,11,9,2,11,1,8
+V,2,7,4,5,2,8,11,2,3,5,10,8,2,11,1,8
+B,2,4,3,3,3,7,8,5,5,7,6,6,2,8,6,9
+C,7,9,7,7,4,4,7,5,7,11,9,14,3,10,4,7
+U,7,15,7,8,5,8,5,5,5,6,6,7,5,7,3,6
+Z,2,7,3,5,2,7,7,3,12,8,6,8,0,8,7,8
+R,10,13,8,7,5,7,7,5,5,9,4,9,7,6,7,11
+H,8,11,11,9,7,8,6,3,6,10,5,8,3,8,3,8
+Q,4,5,4,6,4,8,5,6,3,9,6,9,3,8,4,8
+Q,3,5,4,6,3,8,10,5,2,6,9,12,2,10,6,8
+Y,5,8,5,6,3,5,8,0,8,9,9,6,1,10,3,4
+A,5,10,7,8,4,9,2,3,3,8,1,8,2,7,4,8
+B,4,6,5,4,3,8,8,4,6,9,6,5,2,8,7,7
+J,2,4,4,3,1,9,5,3,7,15,6,12,0,7,0,8
+E,2,3,4,1,2,7,7,2,7,11,7,9,1,9,4,8
+K,4,5,5,4,3,4,7,5,8,7,6,13,3,8,5,9
+Q,3,7,4,9,5,8,7,8,3,5,6,9,3,8,6,10
+R,3,8,4,6,4,5,8,7,5,6,4,9,3,6,5,8
+W,8,14,8,8,6,4,8,1,3,8,9,8,10,11,2,6
+G,5,8,7,6,4,6,7,6,6,6,6,9,4,7,4,8
+T,3,5,4,3,2,5,12,3,7,11,9,5,1,11,2,5
+L,2,5,2,3,1,4,3,3,7,2,2,6,0,7,0,6
+G,3,4,4,6,2,7,5,7,7,5,5,10,1,8,6,11
+K,3,6,4,4,1,4,8,8,1,7,6,11,3,8,3,11
+Z,4,9,6,7,6,7,9,3,8,7,6,8,2,10,13,6
+E,4,9,6,7,6,8,9,7,2,6,6,11,4,7,8,9
+S,4,10,6,7,4,9,6,3,7,10,6,8,2,9,4,9
+X,3,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+M,6,11,9,8,10,7,10,6,4,7,7,8,6,8,6,8
+X,3,4,4,3,2,7,7,3,9,6,6,10,2,8,6,7
+C,3,9,4,6,3,5,8,8,7,10,8,12,2,11,4,10
+T,4,10,6,8,8,7,7,4,6,7,7,9,5,9,5,7
+A,2,6,4,4,1,7,5,3,1,6,0,8,2,7,1,7
+B,5,9,7,6,9,8,6,5,4,7,7,8,7,9,7,9
+K,4,7,6,5,4,3,8,2,6,10,9,11,3,8,2,6
+K,3,4,6,2,3,7,7,2,7,10,6,9,4,8,4,7
+T,7,12,6,7,4,9,8,3,7,11,5,6,2,8,6,7
+W,11,14,12,8,7,8,9,3,4,6,9,6,11,8,2,6
+R,3,7,5,5,3,9,8,6,6,8,5,8,3,7,6,10
+M,6,8,9,6,10,6,8,4,3,7,4,8,14,3,4,7
+U,4,9,5,7,4,8,6,13,4,7,11,8,3,9,0,8
+M,1,0,2,0,0,7,6,9,0,7,8,8,5,6,0,8
+F,5,11,5,8,4,1,13,5,4,12,10,6,0,8,2,6
+L,3,7,5,5,3,7,4,1,7,8,2,9,1,6,2,8
+I,1,6,1,4,1,7,7,1,6,7,6,8,0,8,2,8
+D,7,11,9,8,8,6,7,7,5,7,7,6,4,7,4,8
+Y,6,8,6,6,2,2,12,4,6,13,12,6,1,11,1,6
+U,3,4,4,6,2,8,5,14,5,6,13,8,3,9,0,8
+Z,6,10,9,8,7,10,9,6,5,7,6,8,4,9,10,7
+U,7,11,8,8,4,4,8,7,8,10,9,9,3,9,3,5
+D,3,7,4,5,3,10,6,3,7,11,3,6,3,8,3,9
+L,9,14,9,8,5,7,4,4,5,12,8,12,4,9,6,10
+I,1,11,0,8,1,7,7,5,3,7,6,8,0,8,0,8
+O,4,9,5,7,4,7,6,8,4,7,5,9,3,8,3,8
+D,5,11,7,8,7,9,7,4,5,10,4,5,3,8,3,8
+D,2,1,3,3,2,7,7,6,6,7,6,5,2,8,2,7
+N,10,12,8,6,4,9,11,6,5,3,5,10,6,9,2,7
+B,6,9,9,8,11,7,7,5,4,8,6,8,7,9,8,7
+X,1,0,1,0,0,7,7,3,4,7,6,8,2,8,3,8
+Q,2,2,3,2,2,7,9,4,2,7,8,10,2,9,4,9
+P,5,10,6,8,6,5,10,3,7,10,9,6,4,10,4,7
+E,6,10,8,8,7,5,9,4,8,12,10,8,3,8,5,4
+Y,4,7,6,10,9,9,7,6,3,7,7,8,7,10,6,4
+M,4,9,6,7,6,8,6,6,4,7,7,8,8,5,2,7
+M,4,10,5,8,4,7,7,12,2,7,9,8,8,6,0,8
+B,1,0,1,0,0,7,7,6,4,7,6,7,1,8,5,9
+L,4,6,5,6,4,7,7,4,5,7,6,8,2,9,7,10
+N,6,8,8,6,4,10,8,3,6,10,2,4,5,9,1,7
+W,2,1,3,2,2,5,10,3,2,8,9,9,5,11,0,8
+L,3,9,4,6,2,7,4,0,9,9,2,11,0,7,2,8
+V,9,11,7,6,4,9,9,6,5,6,10,5,6,13,3,7
+M,5,10,6,5,3,10,2,1,3,9,3,9,5,4,1,9
+Q,7,12,6,6,4,10,5,4,7,11,4,8,3,8,8,11
+V,4,6,6,6,6,7,6,5,4,6,5,8,7,9,7,9
+C,7,10,7,8,5,5,7,5,7,12,8,13,4,9,5,6
+X,6,13,7,7,4,9,7,2,7,11,4,6,4,10,4,8
+D,2,1,3,2,2,7,7,6,6,7,6,5,2,8,3,7
+P,9,13,8,7,4,8,7,5,5,11,3,6,5,9,4,8
+E,2,5,4,3,2,7,7,2,8,11,7,9,2,9,4,8
+A,7,9,9,8,8,5,8,3,5,7,8,10,8,8,4,8
+L,3,7,5,5,2,6,3,2,8,7,2,10,0,7,2,8
+P,2,5,4,4,2,7,11,4,3,12,4,2,1,10,3,8
+S,3,8,4,6,3,8,7,8,6,8,6,7,2,8,9,8
+I,1,4,1,3,0,8,7,0,7,13,6,8,0,8,0,8
+U,5,9,6,8,7,7,6,4,4,6,7,8,7,8,2,7
+T,7,10,9,7,7,6,7,7,7,8,10,8,3,9,6,8
+S,4,7,4,5,2,7,6,6,9,6,7,11,0,9,9,8
+B,3,7,5,5,6,8,6,5,3,7,6,8,6,10,8,7
+M,6,5,6,8,4,7,7,13,2,7,9,8,9,6,0,8
+F,6,9,9,7,6,7,9,3,6,12,7,6,3,9,3,7
+C,4,8,5,6,3,5,8,6,6,8,8,15,3,10,4,10
+D,2,4,4,3,2,9,6,4,6,10,4,6,2,8,3,8
+X,3,9,5,6,4,7,7,3,8,5,6,8,2,8,6,8
+J,3,8,4,6,3,8,7,1,7,11,5,8,0,6,1,6
+R,2,3,4,2,2,8,7,4,5,9,4,7,2,7,4,10
+E,1,3,2,1,2,7,7,5,6,7,6,8,2,8,5,10
+Q,4,8,5,10,5,10,11,6,2,3,8,12,3,10,6,10
+L,2,5,3,3,1,4,4,4,7,2,2,6,1,7,1,6
+E,4,5,4,4,4,7,7,5,8,7,7,9,2,8,6,9
+Y,7,6,5,9,4,7,11,2,3,8,10,5,3,9,5,7
+L,2,3,2,5,1,0,1,5,6,0,0,7,0,8,0,8
+F,2,4,2,2,1,6,10,4,5,10,9,4,1,10,3,6
+X,4,8,5,6,3,8,7,4,4,7,6,8,3,8,4,8
+T,4,6,4,4,2,5,12,4,5,11,9,4,2,11,1,5
+K,4,10,4,7,2,4,8,9,2,6,3,11,4,8,2,11
+B,5,10,5,8,7,7,8,8,6,8,6,7,2,8,8,9
+E,4,7,6,5,4,9,6,2,8,11,5,9,3,8,5,10
+R,3,5,6,4,4,9,7,3,5,9,4,6,3,7,4,10
+P,3,6,4,9,8,8,9,5,0,8,7,6,5,10,3,7
+X,6,11,7,6,4,7,8,2,7,11,7,7,4,10,4,6
+K,6,10,9,8,6,5,8,2,7,10,8,10,3,8,3,8
+E,4,9,6,6,6,7,7,6,3,7,6,11,4,8,8,9
+Y,3,9,5,6,1,6,12,2,3,9,12,8,1,10,0,8
+E,4,5,4,8,3,3,8,6,11,7,5,14,0,8,7,7
+A,2,4,4,5,2,7,4,3,1,7,1,8,2,7,2,8
+X,4,7,7,5,3,10,6,1,8,10,3,7,2,8,3,9
+A,4,7,5,5,3,8,2,2,2,6,2,8,2,6,3,6
+Z,6,12,6,6,4,6,7,2,9,11,7,8,3,7,6,6
+H,4,3,4,4,2,7,7,14,0,7,6,8,3,8,0,8
+A,4,6,6,5,5,8,8,2,4,7,8,8,5,8,4,6
+Q,6,10,6,5,4,9,6,4,6,10,5,8,3,8,9,9
+O,4,6,4,4,3,9,6,7,5,10,4,10,3,8,4,7
+M,2,1,3,2,2,7,6,6,4,6,7,8,6,5,1,8
+F,4,5,4,8,2,1,12,5,4,11,10,7,0,8,3,6
+A,4,6,5,6,5,7,9,2,4,7,7,9,7,7,3,8
+D,5,11,5,6,4,6,8,5,6,9,6,7,5,10,6,5
+H,5,11,6,8,3,7,9,15,1,7,3,8,3,8,0,8
+O,2,5,3,4,2,7,7,8,5,7,6,8,2,8,3,8
+A,5,7,6,5,6,8,7,7,4,7,6,8,2,8,8,3
+T,7,15,6,8,4,9,7,3,7,12,5,7,3,9,5,6
+L,2,7,4,5,5,7,8,2,4,6,7,10,5,11,6,5
+F,3,8,4,6,2,1,14,5,3,12,10,5,0,8,2,6
+V,4,4,6,6,1,10,8,5,3,5,14,8,3,9,0,8
+P,2,3,4,2,2,7,9,3,4,12,5,4,1,10,2,8
+T,4,7,5,5,2,6,11,2,8,11,9,5,1,11,3,4
+R,5,10,5,5,4,7,7,3,4,7,5,9,5,8,6,7
+J,1,7,2,5,1,13,3,8,4,13,4,12,1,6,0,8
+L,2,3,2,5,1,0,1,5,6,0,0,7,0,8,0,8
+E,5,10,7,8,6,4,9,4,7,12,10,8,3,9,4,5
+Z,4,10,5,7,4,7,7,3,12,9,6,8,0,8,8,8
+V,3,5,6,7,2,6,8,4,3,7,14,8,3,9,0,8
+I,1,10,2,8,2,7,7,0,8,7,6,8,0,8,3,8
+E,3,10,4,7,2,3,7,6,11,7,6,15,0,8,7,7
+K,4,9,5,6,5,6,7,3,6,6,6,9,3,8,5,10
+O,4,9,5,7,4,7,7,8,6,7,6,6,2,8,3,8
+P,2,3,3,2,1,7,10,3,4,12,5,3,0,9,2,8
+N,3,5,3,3,2,7,8,5,5,7,6,6,5,10,2,5
+F,4,7,6,5,4,9,8,2,5,13,5,6,2,9,2,9
+X,4,5,5,7,2,7,7,5,4,7,6,8,3,8,4,8
+E,4,9,4,6,2,3,7,6,11,7,6,15,0,8,7,7
+D,2,5,4,4,3,9,6,4,6,10,4,6,2,8,3,8
+Z,2,8,3,6,3,7,8,3,11,8,6,8,0,8,7,8
+S,4,6,5,4,2,8,8,4,8,11,8,7,2,10,5,6
+V,2,4,4,3,1,7,12,2,2,7,11,9,2,10,1,8
+G,3,5,4,4,2,6,6,5,5,9,7,11,2,9,4,10
+O,3,5,4,3,2,7,7,7,4,9,6,7,2,8,3,7
+P,1,1,2,1,1,5,11,7,2,10,6,4,1,9,3,8
+G,4,6,5,4,3,7,6,5,6,11,6,12,2,10,3,10
+V,6,8,6,6,3,3,12,3,3,9,11,8,3,11,1,7
+E,2,5,4,3,2,7,8,2,8,11,7,9,2,9,4,8
+C,2,1,3,2,1,6,8,7,7,8,7,13,1,9,4,10
+O,2,4,3,3,2,7,7,8,5,7,6,8,2,8,3,8
+G,4,8,5,6,3,6,6,7,6,10,7,12,2,9,4,9
+U,2,0,2,1,0,7,5,10,4,7,12,8,3,10,0,8
+J,4,8,6,6,2,7,6,4,6,15,7,11,1,6,1,7
+C,3,6,5,5,4,5,6,3,4,7,6,11,4,10,7,8
+E,3,5,5,4,3,5,8,3,8,11,9,10,2,8,4,6
+Q,3,6,4,5,3,8,8,6,4,6,9,8,3,8,5,9
+S,4,8,5,6,3,9,7,4,8,11,7,7,2,10,5,8
+I,1,4,2,3,1,7,8,0,7,13,6,8,0,8,1,7
+T,3,10,5,7,1,5,15,1,6,9,11,7,0,8,0,8
+C,5,10,6,8,2,6,7,7,11,6,6,13,1,8,4,8
+X,5,11,8,8,7,7,7,3,8,5,7,10,3,8,6,8
+A,3,9,4,6,3,9,5,2,0,8,1,8,2,6,1,8
+A,4,7,5,5,5,7,7,6,3,7,6,8,2,7,8,3
+W,3,2,5,4,3,7,11,2,2,7,9,8,7,11,0,8
+G,3,3,5,5,2,8,6,7,8,6,5,10,1,8,6,11
+Y,6,11,9,8,5,6,9,1,7,6,12,9,2,11,2,8
+P,3,7,4,5,3,4,12,7,1,10,6,4,1,10,3,8
+G,2,4,3,3,2,6,7,5,5,10,7,10,2,9,4,9
+G,3,2,4,4,2,6,6,5,6,6,6,9,2,9,3,8
+H,4,7,4,5,3,7,7,12,0,7,7,7,3,8,0,8
+O,1,0,1,1,0,7,6,6,3,7,6,8,2,8,3,8
+T,2,5,3,3,2,8,12,3,6,6,11,7,2,11,1,7
+L,2,6,4,4,2,6,4,3,8,6,2,7,1,6,2,7
+X,5,8,8,6,4,6,8,1,8,10,9,9,2,9,3,7
+O,2,3,3,1,1,8,7,7,5,7,6,8,2,8,3,8
+A,4,9,4,4,3,10,3,4,2,10,5,11,5,4,4,10
+G,4,7,4,5,3,6,7,5,5,9,7,12,2,9,4,10
+J,3,9,5,7,5,9,9,3,3,8,4,6,4,8,5,5
+J,3,11,4,8,5,7,7,2,5,11,5,9,4,7,2,6
+T,3,3,4,2,1,5,11,3,7,11,9,5,1,11,2,5
+J,4,8,5,6,3,7,5,5,4,14,8,14,1,6,1,7
+M,6,11,9,8,9,9,7,5,5,6,7,5,11,8,4,6
+M,4,2,5,3,4,9,6,6,4,6,7,6,9,6,3,6
+H,3,6,4,4,2,7,6,14,1,7,7,8,3,8,0,8
+N,2,1,2,1,1,7,7,12,1,5,6,8,5,8,0,8
+D,1,0,1,1,0,5,7,7,5,6,6,6,2,8,3,8
+X,7,13,6,7,3,8,7,2,8,9,6,8,4,8,4,8
+Z,1,0,2,1,0,7,7,2,10,8,6,8,0,8,6,8
+T,3,5,4,7,1,9,14,0,6,5,11,8,0,8,0,8
+B,5,8,8,7,9,8,6,5,5,7,6,7,8,11,9,6
+P,8,15,8,8,5,9,8,4,4,11,4,5,5,11,6,7
+I,1,8,0,6,1,7,7,5,3,7,6,8,0,8,0,8
+Z,3,5,4,4,3,7,7,5,10,6,6,8,2,8,7,8
+G,2,0,2,1,1,8,6,6,5,6,5,9,1,8,5,10
+N,5,11,6,8,6,8,8,13,1,6,6,8,6,8,1,10
+R,3,6,4,4,4,6,10,7,3,7,4,8,2,6,5,11
+Z,3,6,6,4,3,7,7,2,10,12,6,8,1,8,6,8
+J,3,8,5,6,5,9,7,3,3,8,4,5,4,8,6,5
+S,2,4,4,3,2,7,7,2,7,10,5,7,1,8,5,8
+B,2,7,3,5,2,6,6,9,7,6,7,7,2,8,8,10
+Z,5,8,7,6,5,8,7,2,9,12,6,7,1,7,6,7
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+V,5,5,6,4,2,4,12,3,3,10,11,7,2,10,1,8
+I,0,1,1,2,0,7,7,2,6,7,6,8,0,8,2,8
+O,4,8,6,6,3,8,6,8,8,7,5,8,3,8,4,8
+Q,2,5,3,6,4,8,7,8,3,6,6,10,2,9,4,9
+P,7,11,10,9,8,7,11,6,4,11,5,3,2,11,4,8
+I,1,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+N,4,11,5,8,3,7,7,15,2,4,6,8,6,8,0,8
+F,2,7,3,5,2,1,11,3,5,11,11,9,0,8,2,7
+Z,8,10,6,14,5,6,11,3,3,12,7,6,3,9,13,5
+W,4,7,6,5,4,6,11,2,3,7,9,9,8,11,1,8
+I,1,11,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+C,8,15,5,8,3,7,7,8,8,12,7,10,2,9,5,9
+C,3,3,4,4,1,6,7,7,9,7,6,13,1,9,4,9
+E,5,9,7,7,8,8,7,3,5,6,7,9,5,10,8,8
+O,4,5,6,4,4,6,6,5,5,8,4,7,3,7,4,7
+D,5,7,6,6,6,6,7,5,6,6,4,7,4,7,6,5
+V,6,8,6,6,3,3,12,3,3,10,11,8,2,10,1,8
+E,2,1,3,2,2,7,7,5,7,7,6,8,2,8,5,10
+R,3,9,4,7,4,6,9,8,3,7,5,8,2,7,5,11
+Z,2,3,3,2,2,7,7,5,9,6,6,9,1,8,7,8
+J,4,5,6,6,5,8,9,4,5,7,6,8,3,8,8,7
+X,4,9,6,7,6,9,7,2,6,7,5,6,3,8,6,8
+E,3,9,5,7,4,7,7,6,9,6,4,9,2,8,6,9
+E,4,7,5,5,3,7,7,6,10,7,7,9,3,8,6,8
+F,9,14,8,8,6,9,8,3,5,12,4,5,5,7,8,9
+A,1,1,2,1,1,7,3,2,1,6,2,8,1,6,1,7
+T,10,14,8,8,4,7,8,3,10,13,6,6,2,9,5,5
+V,2,3,3,2,1,4,12,3,3,10,11,7,2,11,0,8
+H,4,7,6,5,5,7,7,2,6,10,6,8,3,8,3,8
+Q,6,10,6,5,3,12,3,3,7,11,2,8,2,9,5,13
+Y,6,9,5,4,2,5,9,4,4,11,9,6,4,10,4,4
+F,3,5,5,3,2,6,10,2,6,13,7,5,1,9,2,7
+I,1,3,0,2,0,7,7,1,7,7,6,8,0,8,2,8
+N,2,0,2,1,0,7,7,11,0,5,6,8,4,8,0,8
+U,4,9,4,4,3,6,6,5,4,7,8,8,4,7,3,8
+V,4,6,4,4,2,2,12,3,3,11,11,8,2,11,1,8
+N,6,7,8,5,4,7,9,2,5,10,5,6,5,9,1,7
+H,3,7,4,5,3,8,7,7,6,7,6,7,3,8,4,7
+C,6,12,5,6,4,8,6,4,3,9,8,11,4,9,7,11
+M,6,8,10,6,7,4,7,3,5,11,10,11,9,8,4,7
+R,1,0,1,1,1,6,9,7,3,7,5,8,2,7,4,10
+F,3,3,5,2,2,6,11,2,5,13,7,4,1,9,1,7
+K,8,11,11,8,7,9,7,2,7,10,3,8,3,8,3,9
+Z,5,10,6,8,3,7,7,4,15,9,6,8,0,8,9,8
+Y,1,1,2,2,1,7,11,1,6,7,11,8,1,11,1,8
+Y,5,7,6,9,9,8,8,7,3,7,7,8,9,11,6,4
+W,3,7,5,5,3,6,8,4,1,7,8,8,8,9,0,8
+Q,2,0,2,1,1,8,7,7,5,6,6,9,2,8,3,8
+R,4,6,6,6,6,6,8,4,3,6,5,9,7,6,7,8
+P,6,11,9,8,6,6,12,4,4,13,6,3,1,10,3,8
+S,7,11,8,8,6,5,9,3,7,10,6,6,3,7,5,5
+K,4,8,6,6,4,6,8,4,7,6,5,10,3,8,4,9
+T,10,14,8,8,3,4,12,3,8,12,8,4,2,9,3,3
+D,6,11,6,8,6,5,7,10,7,5,4,6,4,10,5,9
+O,5,10,5,8,4,8,7,8,5,10,6,8,3,8,3,8
+Z,1,0,2,1,0,7,7,3,11,8,6,8,0,8,6,8
+R,6,9,9,8,9,7,7,4,4,7,5,8,8,7,7,9
+A,6,11,8,8,8,8,9,8,5,6,6,8,3,7,8,4
+O,6,7,8,6,6,7,5,4,5,8,5,11,5,6,7,6
+N,3,7,4,5,2,7,7,14,2,5,6,8,6,8,0,8
+S,2,1,3,2,2,8,8,6,5,7,6,7,2,8,9,8
+Z,9,10,6,14,6,6,10,4,2,12,7,6,3,9,14,6
+Z,2,7,3,5,2,7,8,3,11,8,6,8,0,8,7,7
+X,3,8,5,6,4,7,7,3,8,6,6,8,3,8,6,7
+H,5,5,5,7,3,7,8,15,1,7,4,8,3,8,0,8
+G,4,9,6,7,7,7,9,6,3,6,6,10,4,8,7,7
+Y,3,5,4,7,6,7,9,3,2,7,7,8,3,11,7,6
+I,1,4,3,2,1,7,7,1,8,14,6,8,0,8,1,8
+N,8,10,7,6,3,7,10,5,5,4,5,10,6,11,3,7
+P,4,9,4,6,4,5,10,8,2,9,6,5,1,10,3,8
+P,4,7,5,5,5,5,9,6,4,8,7,9,2,9,7,10
+Y,6,9,5,4,3,6,8,3,4,10,8,5,3,10,4,4
+N,3,7,4,5,3,5,9,6,4,8,7,9,5,8,1,7
+L,5,11,6,8,4,10,3,2,7,9,2,9,4,5,5,9
+E,6,8,8,7,8,5,10,4,5,8,7,9,4,10,9,7
+S,5,9,6,7,5,8,8,7,5,7,5,7,2,7,9,8
+B,3,5,4,4,3,8,7,6,6,6,5,6,2,8,6,10
+D,2,3,4,1,2,9,6,4,6,10,4,6,2,8,3,8
+V,4,4,5,3,1,4,12,4,4,11,11,6,2,10,1,8
+A,4,5,7,7,2,7,6,3,0,7,0,8,3,7,1,8
+I,3,9,4,6,2,5,8,0,8,14,7,8,0,8,1,7
+Q,5,6,5,8,5,8,8,5,2,8,8,10,3,9,6,8
+C,2,1,2,1,0,6,7,6,9,7,6,14,0,8,4,10
+R,3,5,5,4,3,8,7,3,5,10,4,6,3,7,3,9
+K,9,12,9,6,5,8,7,3,6,10,7,9,6,12,4,9
+G,3,4,4,3,2,6,6,5,5,7,6,9,3,7,4,8
+H,8,12,7,6,4,9,9,4,7,8,2,5,6,6,4,8
+Y,4,5,5,8,7,10,8,5,3,7,7,7,6,10,8,4
+L,4,9,5,7,3,6,4,4,8,5,2,6,1,6,2,6
+V,3,6,5,4,3,8,11,3,2,5,10,9,3,10,3,10
+J,0,0,1,1,0,12,4,5,3,12,4,11,0,7,0,8
+L,2,5,4,3,2,7,4,1,8,8,2,10,0,7,3,8
+L,3,8,4,6,2,4,3,6,7,1,1,5,1,6,1,6
+E,6,11,8,8,6,4,9,2,8,10,8,9,3,8,5,5
+Y,5,6,6,9,6,10,12,5,4,6,7,7,6,11,8,6
+J,1,2,2,3,1,10,6,3,5,12,4,9,1,6,1,7
+A,2,8,4,5,2,6,5,3,1,6,1,8,2,7,2,7
+K,2,1,2,1,0,5,7,8,1,7,6,11,3,8,2,11
+R,4,7,7,6,6,7,7,3,3,7,5,8,6,8,5,7
+Y,7,9,7,7,3,4,11,2,8,12,11,5,1,10,2,4
+U,4,4,5,3,2,5,8,5,8,10,8,8,3,9,2,5
+C,5,4,6,7,2,5,7,7,11,7,5,12,1,9,4,8
+O,5,8,5,6,4,7,7,8,5,10,7,8,3,8,4,8
+F,5,7,7,8,7,7,10,5,5,8,7,9,5,9,7,5
+P,2,1,3,2,2,5,9,5,4,9,7,4,1,10,3,7
+D,3,6,4,4,3,7,8,8,7,8,7,3,3,8,3,7
+B,2,2,2,3,2,7,7,6,5,7,6,6,2,8,5,10
+X,5,9,8,6,4,6,8,1,8,10,9,9,2,9,3,7
+H,3,5,5,3,3,6,7,6,6,7,6,9,3,8,3,8
+I,2,5,4,4,2,7,7,0,8,13,6,8,0,8,1,8
+U,3,6,3,4,1,7,5,13,5,7,13,8,3,9,0,8
+U,5,5,6,8,2,8,5,14,5,6,15,8,3,9,0,8
+M,4,3,5,4,4,8,6,6,4,6,7,8,9,5,3,6
+R,4,2,4,3,3,7,8,5,5,6,5,6,3,7,4,8
+C,1,3,2,1,1,5,9,4,6,11,9,11,1,9,2,8
+C,4,9,5,6,4,5,8,7,6,9,8,14,2,10,4,10
+B,3,7,5,5,4,7,8,7,6,7,5,6,2,8,7,10
+O,7,9,9,8,6,5,7,6,8,9,7,8,4,5,6,5
+L,2,4,3,3,1,5,4,4,7,2,2,5,1,7,1,6
+G,2,1,4,2,2,7,7,5,5,7,6,9,3,7,4,9
+B,3,5,5,4,5,7,7,4,4,7,6,8,6,9,8,6
+P,6,7,8,9,8,7,9,2,3,7,9,6,6,10,6,4
+F,2,4,3,2,2,5,10,4,5,10,9,5,1,10,3,6
+S,4,4,5,6,3,7,6,5,9,5,6,8,0,9,9,8
+X,3,6,5,4,3,7,7,3,8,6,6,9,3,8,6,8
+F,4,9,6,7,4,5,11,4,6,11,10,5,2,10,3,5
+T,2,3,3,1,1,5,12,3,5,11,9,5,1,10,1,5
+O,6,10,4,5,2,8,7,6,5,9,4,7,5,9,5,9
+V,4,7,6,5,7,7,8,4,1,8,7,8,5,10,5,8
+X,2,2,3,3,2,8,7,3,8,6,6,7,2,8,5,7
+U,5,7,6,5,4,5,7,5,7,9,7,9,3,9,3,6
+N,4,3,4,5,2,7,7,14,2,5,6,8,6,8,0,8
+M,4,9,5,6,5,6,6,6,4,7,7,11,7,5,2,10
+N,4,6,6,4,3,7,8,3,4,10,6,7,5,8,0,7
+R,3,9,5,6,4,6,7,6,6,6,6,6,3,8,6,8
+B,4,6,6,5,6,8,8,5,5,7,6,8,6,8,8,3
+W,4,7,7,5,5,5,11,2,2,8,9,8,7,12,1,8
+Z,1,0,1,1,0,7,7,2,9,9,6,8,0,8,6,8
+P,7,14,7,8,5,8,9,4,4,12,5,4,4,11,6,6
+B,6,8,9,7,9,7,8,5,5,8,6,8,7,7,9,6
+O,3,2,4,3,2,7,7,7,5,7,7,7,2,8,3,7
+Y,4,7,6,5,3,8,10,1,6,4,11,9,2,11,2,8
+D,2,3,3,1,2,9,6,3,6,10,4,6,2,8,2,9
+K,2,6,3,4,1,4,8,8,2,7,4,11,3,8,2,10
+A,5,11,8,8,5,11,2,3,3,9,2,9,5,7,4,9
+C,1,0,2,0,0,7,7,6,8,7,6,13,0,8,4,10
+Z,4,10,5,8,5,8,7,6,10,7,5,7,1,7,8,8
+A,3,6,5,5,4,9,7,3,5,7,8,6,4,10,3,5
+I,5,11,6,9,4,9,5,2,5,6,7,5,1,10,4,7
+H,6,9,6,5,4,8,7,3,4,10,5,7,6,9,5,7
+D,3,2,4,4,3,7,7,7,7,7,6,5,2,8,3,7
+B,3,6,4,4,4,6,7,6,3,6,5,7,2,8,6,6
+B,4,6,6,4,6,9,9,4,4,5,7,7,7,12,6,8
+M,2,0,2,1,1,7,6,10,0,7,8,8,6,6,0,8
+A,1,3,2,1,1,9,3,2,1,8,2,9,1,6,0,8
+L,1,0,1,0,0,2,2,5,4,1,2,6,0,8,0,8
+M,4,7,7,5,7,9,5,2,1,8,4,8,10,5,2,6
+B,6,10,6,8,5,6,6,9,8,6,6,7,2,8,10,10
+F,2,3,3,4,1,1,14,4,3,12,9,5,0,8,2,6
+L,4,3,4,5,1,1,0,6,6,0,1,4,0,8,0,8
+A,3,7,5,5,3,11,2,3,2,10,2,9,2,6,3,8
+Q,2,2,2,3,2,8,8,5,2,7,8,10,2,9,4,8
+Y,3,7,5,5,2,7,10,1,2,7,12,8,1,11,0,8
+X,3,7,5,5,2,6,9,1,8,10,8,8,2,8,3,7
+T,1,1,2,1,0,7,14,1,4,7,10,8,0,8,0,8
+Q,2,4,3,4,3,8,8,6,3,8,7,9,2,9,4,9
+N,6,11,9,9,7,7,7,8,5,7,5,6,3,7,3,8
+D,3,6,5,5,5,7,7,4,6,7,4,8,4,7,6,5
+M,5,6,8,4,4,9,6,3,5,9,5,7,8,6,2,8
+Q,4,6,5,7,4,8,6,6,4,9,6,10,3,8,5,8
+F,3,9,4,7,3,0,11,3,4,11,11,8,0,8,2,7
+V,3,5,6,4,2,6,12,2,3,8,11,8,2,10,1,9
+V,4,9,7,7,2,9,8,5,3,6,14,8,3,9,0,8
+O,4,6,5,4,5,8,5,5,2,7,5,8,8,8,3,9
+E,6,8,8,6,5,7,8,2,10,11,6,9,2,8,4,8
+H,3,7,4,5,3,7,7,12,1,7,6,8,3,8,0,8
+S,2,7,3,5,3,8,7,7,6,7,8,9,2,10,8,8
+I,3,9,5,7,6,10,8,2,5,9,5,4,3,9,6,5
+X,2,7,4,5,2,7,7,4,8,6,6,8,3,8,6,8
+U,2,0,2,1,1,8,5,11,5,7,13,8,3,10,0,8
+X,3,5,4,3,2,7,7,3,9,6,6,7,3,8,6,7
+T,3,5,4,3,2,9,12,3,7,5,11,9,1,11,1,8
+N,2,4,4,3,2,6,8,2,4,10,7,8,4,8,0,8
+Q,4,7,6,6,5,6,4,4,4,5,3,7,3,6,5,6
+A,2,4,4,3,2,9,2,2,2,8,2,9,1,6,1,7
+O,7,12,5,6,3,5,8,6,4,10,7,9,5,10,5,8
+V,7,9,7,7,3,3,11,2,4,9,11,7,5,11,1,6
+R,4,7,5,5,3,6,10,9,4,6,4,8,2,8,5,10
+R,3,7,5,5,4,7,8,5,6,8,5,9,3,6,5,11
+V,8,14,7,8,3,9,10,4,6,6,11,6,4,11,3,6
+F,2,1,2,2,1,5,10,4,5,10,9,5,1,10,3,7
+Y,3,6,5,9,8,8,6,4,1,7,8,9,7,10,8,8
+X,4,6,6,4,3,8,7,2,8,10,5,8,3,8,4,8
+M,5,6,7,5,7,7,9,4,4,7,5,7,9,8,5,5
+Y,2,1,3,1,0,7,10,3,1,7,13,8,1,11,0,8
+X,3,8,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+U,4,6,6,5,5,7,8,4,3,6,6,8,4,7,1,7
+G,6,11,5,6,4,8,5,4,3,9,6,9,4,9,8,8
+S,3,7,4,5,2,7,8,4,8,11,8,8,2,10,5,7
+F,6,10,10,8,9,8,8,1,6,10,6,5,5,10,4,6
+L,2,4,3,2,1,6,4,1,8,7,2,10,0,7,2,8
+S,5,9,8,7,9,7,4,3,3,7,5,7,4,8,11,6
+M,5,8,7,6,5,11,5,2,4,9,3,6,7,6,2,8
+U,4,9,4,7,2,7,5,14,5,7,14,8,3,9,0,8
+A,2,1,3,3,1,7,2,1,2,6,2,7,2,5,2,8
+S,3,7,5,5,6,7,5,3,3,6,5,7,3,8,9,3
+J,4,9,5,7,3,7,9,2,6,14,5,7,0,6,1,7
+X,3,7,4,5,2,7,7,4,4,7,6,8,2,8,4,8
+J,3,7,5,5,4,8,9,4,3,8,5,6,6,9,6,4
+T,4,7,5,5,5,6,8,3,5,7,6,9,5,9,4,8
+E,3,6,4,4,4,8,7,6,3,7,6,10,3,8,7,9
+T,4,7,6,5,6,5,8,4,6,7,6,10,5,8,5,7
+L,6,11,6,6,3,8,4,3,5,12,7,12,3,8,6,9
+F,3,5,5,3,2,6,10,2,6,13,7,5,1,10,2,7
+R,5,9,7,8,8,7,8,3,4,7,5,8,7,8,6,8
+D,3,6,4,4,4,7,7,4,6,7,6,6,3,8,2,7
+M,5,9,6,4,3,7,3,3,2,7,4,10,6,3,2,8
+A,1,3,2,2,1,10,2,3,1,9,2,9,2,6,1,7
+Q,4,9,5,10,7,8,6,8,3,6,5,9,3,8,6,10
+M,4,4,5,6,3,7,7,12,1,7,9,8,8,6,0,8
+W,2,1,4,2,2,7,11,2,2,7,9,8,5,11,0,8
+M,4,4,7,3,4,7,6,3,4,9,8,9,7,5,2,8
+Q,4,6,4,7,4,7,9,5,3,7,9,11,3,9,7,8
+B,3,8,4,6,4,7,7,7,6,7,6,6,2,8,7,9
+U,2,1,2,1,1,8,5,11,5,7,13,8,3,10,0,8
+I,1,5,1,4,1,7,7,1,7,7,6,9,0,8,3,8
+N,6,10,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+I,1,2,1,3,1,7,7,1,7,7,6,8,0,8,3,8
+U,6,11,9,8,5,6,8,6,8,7,9,10,3,9,1,8
+C,6,11,6,8,4,2,9,5,7,11,11,13,1,8,2,7
+W,8,9,8,6,6,2,10,2,3,10,10,9,7,10,2,7
+Z,3,5,5,6,3,10,3,2,6,7,3,6,1,8,7,7
+U,6,8,6,6,3,4,8,6,8,10,10,9,3,9,2,5
+W,3,7,5,5,4,7,10,2,3,6,9,8,7,11,1,8
+U,5,8,6,6,3,4,9,5,7,12,11,9,3,9,2,7
+M,2,1,3,1,2,7,6,6,4,6,7,7,7,6,2,7
+B,5,11,8,8,10,9,5,5,5,7,7,7,7,9,8,9
+W,4,8,6,6,3,9,8,4,1,7,8,8,8,9,0,8
+Z,2,2,3,3,2,7,7,5,9,6,6,8,2,8,7,8
+T,3,1,4,3,2,7,12,4,6,7,11,8,2,11,1,8
+U,2,5,3,4,2,7,8,7,8,8,9,7,3,9,1,8
+T,1,0,2,0,0,7,14,1,4,7,10,8,0,8,0,8
+Z,4,9,5,7,5,8,7,5,9,7,5,7,1,7,7,8
+E,6,10,5,5,3,7,8,4,4,10,6,8,3,9,9,9
+S,2,6,3,4,2,8,8,7,6,7,5,8,2,8,9,8
+X,4,9,5,6,1,7,7,4,4,7,6,8,3,8,4,8
+S,4,8,5,6,3,7,6,6,10,5,6,10,0,9,9,8
+V,5,10,5,7,3,4,11,2,3,9,11,7,2,10,1,8
+A,7,12,7,7,4,12,1,4,1,11,4,12,5,4,4,11
+B,6,10,8,8,9,8,7,5,6,7,6,6,2,8,6,10
+J,4,8,3,12,3,8,7,3,3,11,4,5,3,8,7,10
+Z,2,1,3,2,2,7,7,5,9,6,6,8,1,8,7,8
+L,5,9,6,6,5,6,7,7,5,6,6,9,6,8,5,11
+A,3,11,5,8,4,12,3,2,2,9,2,9,2,6,2,8
+H,5,10,5,8,5,7,8,13,1,7,5,8,3,8,0,8
+S,4,7,5,5,3,8,7,3,6,9,6,7,2,8,5,8
+Y,2,5,4,3,2,7,10,1,7,7,11,8,2,11,2,8
+C,2,2,3,4,2,6,8,8,7,9,8,12,1,10,4,10
+K,4,8,4,6,2,3,6,8,3,7,7,11,4,8,3,10
+C,5,9,6,8,7,6,7,5,5,6,7,12,6,9,8,10
+Y,1,1,3,2,1,8,11,1,6,6,10,8,1,11,1,8
+Y,3,6,5,4,1,6,10,3,2,8,13,8,2,11,0,8
+P,4,8,4,5,2,3,14,7,1,11,7,3,0,10,4,8
+D,3,4,5,3,3,9,6,4,6,10,4,6,2,8,3,8
+Q,1,0,2,1,1,8,7,6,4,6,6,9,2,8,3,8
+T,4,4,4,3,2,5,12,3,7,12,9,4,1,11,1,5
+S,3,9,4,7,2,9,9,6,10,5,5,5,0,7,9,7
+O,3,5,4,4,3,8,7,7,4,9,6,8,2,8,3,7
+V,6,8,6,6,3,3,12,4,4,10,12,7,2,10,1,8
+O,5,11,5,8,6,8,6,8,4,9,4,8,3,8,3,8
+K,3,4,4,3,3,6,7,4,7,7,6,11,3,8,5,10
+F,5,8,7,6,5,7,9,2,5,13,6,5,2,10,2,8
+T,3,7,4,5,3,7,11,1,8,7,11,8,0,10,1,8
+T,3,4,4,3,1,5,12,2,7,11,9,5,0,10,1,5
+P,3,4,5,3,2,7,10,3,4,12,4,2,1,10,2,8
+L,4,10,6,8,4,5,5,1,9,6,2,10,1,7,3,7
+H,5,8,7,6,5,5,8,3,6,10,8,9,3,8,3,6
+C,2,5,3,3,2,6,8,7,7,9,7,12,2,9,4,10
+T,4,10,6,7,5,9,11,3,7,5,11,8,2,12,1,8
+W,4,7,6,5,8,9,6,5,2,7,6,8,10,10,2,7
+D,5,11,7,8,5,8,8,6,7,10,6,4,4,7,5,10
+S,5,10,6,8,4,10,7,4,6,10,3,7,3,9,5,11
+C,1,0,2,1,0,6,7,6,8,7,6,14,0,8,4,10
+F,4,9,5,6,2,1,14,5,3,12,9,4,0,8,3,6
+X,3,6,5,4,4,7,7,3,5,6,6,9,2,8,8,8
+N,4,7,6,5,3,4,9,4,4,10,10,9,5,8,1,7
+C,6,9,8,7,5,7,7,8,6,8,5,11,4,9,4,8
+W,6,9,8,7,4,11,8,5,2,6,9,8,8,9,0,8
+R,6,11,8,8,7,9,7,3,6,10,3,7,3,6,3,11
+Q,1,0,2,1,0,8,7,6,3,6,6,9,2,8,3,8
+H,2,1,3,2,2,7,8,6,6,7,6,9,3,8,3,8
+Y,2,7,3,4,0,7,11,1,3,8,12,8,1,11,0,8
+J,2,3,2,5,1,12,3,9,3,13,5,12,1,6,0,8
+P,6,6,8,8,8,6,11,2,3,8,9,6,5,10,5,6
+M,3,6,4,4,4,7,5,10,0,6,8,8,6,5,0,7
+J,2,3,3,5,1,13,3,8,4,13,4,11,1,6,0,8
+Y,5,10,8,8,5,8,10,1,7,4,11,8,1,11,2,8
+A,1,3,3,2,1,8,3,2,2,7,2,8,2,6,2,7
+S,5,10,6,7,4,6,8,5,8,11,10,7,2,10,5,5
+N,5,4,5,7,3,7,7,15,2,4,6,8,6,8,0,8
+I,2,11,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+I,1,1,1,3,0,7,7,1,8,7,6,8,0,8,3,8
+A,6,11,6,6,4,10,2,4,2,11,5,12,5,4,6,10
+V,5,8,7,6,5,7,12,2,1,7,10,8,5,11,6,8
+C,4,7,5,5,2,4,9,6,8,13,11,10,1,9,2,6
+C,5,8,5,6,3,6,7,5,6,12,8,13,3,9,4,7
+G,3,7,5,5,5,8,9,6,3,6,6,9,4,8,6,7
+W,6,10,6,7,7,4,10,2,3,9,8,8,7,11,2,7
+W,6,8,9,7,11,9,7,5,5,7,5,8,12,10,9,4
+C,3,7,4,5,2,6,8,8,8,9,7,12,1,10,4,9
+Y,4,10,6,8,3,7,10,1,7,7,12,8,1,11,2,8
+L,4,7,5,5,6,6,7,3,6,7,7,11,6,11,6,5
+K,2,1,2,1,1,6,7,4,7,6,6,10,3,8,4,9
+F,1,3,3,2,1,7,9,2,4,13,6,6,1,9,1,8
+S,2,3,2,2,2,8,7,6,5,7,7,8,2,9,8,8
+I,0,0,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+R,5,9,7,7,6,6,8,6,6,6,5,8,3,6,6,9
+Y,3,5,5,8,7,8,7,4,2,6,8,9,4,11,7,8
+W,4,7,6,5,4,7,8,4,0,6,9,8,7,12,0,8
+N,6,7,8,5,3,8,8,3,5,10,5,6,6,9,1,7
+I,1,6,1,4,1,7,7,0,7,7,6,8,0,8,2,8
+X,3,7,4,5,3,8,7,2,5,6,6,7,2,8,8,9
+Z,6,10,8,7,5,6,9,3,10,12,9,7,1,9,6,6
+U,5,10,7,7,5,6,8,8,5,5,6,12,5,9,7,3
+H,4,11,6,8,10,8,9,5,3,6,7,7,8,8,10,8
+U,5,8,5,6,2,7,4,14,5,7,14,8,3,9,0,8
+F,2,7,4,5,2,5,11,2,7,10,9,5,1,10,3,5
+K,4,9,5,7,2,3,7,8,2,7,6,12,3,8,3,11
+V,2,6,4,4,2,9,12,2,3,4,10,9,2,11,1,9
+H,2,3,3,1,2,7,8,6,6,7,6,9,3,8,3,8
+G,2,1,3,1,1,8,6,6,6,6,5,9,1,7,6,10
+Z,2,7,4,5,4,8,8,2,7,7,7,7,0,8,8,9
+L,6,11,8,8,10,7,7,3,6,6,7,11,6,11,7,5
+S,3,4,5,3,2,8,8,2,8,11,5,6,1,9,4,8
+F,4,9,4,7,3,1,12,4,4,11,10,7,0,8,2,7
+Z,2,4,3,2,1,8,7,2,9,11,5,9,1,9,5,8
+P,7,10,7,5,4,7,10,3,6,13,5,4,3,10,5,6
+G,5,11,5,8,5,5,7,5,4,9,9,9,2,8,5,9
+E,6,9,8,7,7,8,5,7,3,8,6,11,5,8,8,10
+U,9,11,9,8,7,4,8,5,8,9,7,9,6,8,4,3
+D,4,5,4,8,3,5,7,11,8,7,7,5,3,8,4,8
+E,5,9,7,6,4,7,7,2,9,11,6,9,2,8,4,8
+I,1,8,2,6,2,7,7,0,7,7,6,8,0,8,2,8
+W,9,12,9,6,5,4,8,2,4,8,10,8,10,10,2,5
+K,1,0,2,1,0,5,8,8,1,7,6,11,3,8,2,11
+R,5,6,7,5,7,6,7,4,3,6,5,9,7,9,6,10
+H,11,13,10,7,5,8,9,4,6,9,5,7,6,8,5,9
+I,2,8,3,6,1,7,7,0,7,13,6,9,0,8,1,8
+C,5,5,6,7,2,5,7,7,11,7,6,12,1,8,4,9
+J,1,1,2,2,1,11,7,1,5,11,4,7,0,7,0,8
+N,3,6,4,4,3,6,9,6,4,7,6,8,5,9,1,7
+P,7,10,6,5,4,6,12,5,3,12,6,3,3,11,5,6
+D,2,5,4,3,3,9,6,3,6,10,4,7,3,7,3,8
+T,3,7,5,5,3,7,12,3,7,8,11,7,2,11,1,7
+F,2,2,3,3,2,5,11,4,5,11,9,5,1,10,3,6
+K,1,0,1,0,0,5,7,7,0,7,6,10,2,8,2,11
+W,8,11,7,6,4,1,9,3,2,11,12,9,7,10,0,6
+H,2,1,3,2,2,6,7,6,5,7,6,8,3,8,3,8
+I,5,8,6,9,6,7,8,5,6,7,7,7,3,9,9,9
+Y,3,9,5,6,1,7,12,1,3,7,12,8,1,10,0,8
+H,3,3,5,2,3,7,7,3,6,10,6,8,3,8,3,7
+F,7,13,6,7,3,7,9,3,6,12,5,5,2,8,6,6
+V,7,11,7,8,4,2,12,2,3,9,11,8,2,10,1,7
+O,4,9,4,7,4,7,8,7,4,9,7,8,3,8,3,7
+C,4,9,5,6,3,5,7,6,8,5,7,12,1,7,4,9
+E,3,9,5,6,5,6,8,3,6,6,7,11,4,11,8,8
+H,8,10,8,5,5,8,8,3,5,10,3,7,6,5,4,7
+E,3,7,4,5,3,3,7,5,9,7,6,14,0,8,6,9
+B,3,7,4,5,3,7,6,9,7,6,7,7,2,9,8,9
+N,8,11,11,8,5,9,7,3,6,10,3,5,6,8,2,7
+P,2,4,4,3,2,7,11,5,2,11,5,3,1,10,2,9
+N,2,3,4,2,1,7,9,3,4,10,7,7,5,8,1,8
+U,4,4,5,3,2,4,8,5,8,10,10,9,3,9,2,6
+O,6,11,7,8,3,8,8,8,9,6,7,9,3,8,4,8
+C,3,4,4,3,2,6,8,7,7,9,8,12,2,10,3,9
+F,2,2,3,3,2,5,10,4,5,10,9,5,1,10,3,6
+Q,2,1,2,1,1,8,7,7,4,6,6,8,2,8,3,8
+F,2,6,3,4,2,4,11,5,5,11,10,6,2,10,2,6
+T,3,10,5,7,1,8,14,0,6,6,11,8,0,8,0,8
+I,0,1,1,2,1,7,7,1,6,7,6,8,0,8,2,8
+R,3,6,5,4,5,7,8,3,4,6,6,9,6,8,7,6
+T,3,8,5,6,3,6,12,4,7,9,12,7,2,12,1,7
+X,3,7,4,5,4,6,6,3,5,6,6,10,2,8,8,7
+A,2,4,4,2,2,11,2,2,1,9,2,9,2,7,2,9
+L,3,9,5,6,6,7,8,3,6,5,7,10,5,12,6,5
+C,5,8,6,6,2,6,6,7,11,8,5,12,1,9,4,8
+R,4,7,6,5,4,10,7,3,7,11,2,6,4,5,3,9
+P,6,6,8,9,8,7,9,3,2,8,8,6,8,11,6,5
+G,4,7,5,5,2,7,6,7,9,6,5,10,1,8,6,11
+X,5,11,7,8,5,4,8,1,8,9,10,10,2,9,3,5
+M,4,10,5,8,4,8,7,12,2,6,9,8,8,6,0,8
+S,5,9,6,7,3,8,7,4,8,11,6,7,2,9,5,8
+L,6,10,7,8,6,6,6,7,6,6,5,8,5,7,4,10
+L,2,5,4,4,2,7,4,1,7,9,2,10,0,7,2,8
+Y,3,10,5,7,1,7,10,1,3,7,12,8,1,11,0,8
+U,3,3,4,2,1,4,8,4,6,11,11,9,3,9,0,7
+F,2,5,4,4,2,6,10,2,6,13,7,6,1,9,2,7
+G,2,3,3,2,2,7,7,5,5,9,7,10,2,8,4,9
+Q,4,7,6,7,3,8,9,8,5,6,7,9,3,8,5,9
+V,8,9,10,8,12,7,6,5,5,7,6,8,7,10,6,9
+H,3,4,6,2,3,9,6,3,5,10,5,7,3,8,3,7
+K,4,9,6,7,8,7,9,3,5,5,6,8,8,9,8,7
+T,2,7,4,5,1,9,14,1,6,5,11,9,0,8,0,8
+L,5,11,4,6,2,5,5,3,7,9,4,12,2,6,5,7
+M,3,5,6,4,4,7,7,2,4,9,7,8,7,5,1,8
+O,4,9,5,7,4,8,7,8,4,7,6,4,4,8,4,8
+H,4,7,4,5,4,7,9,12,1,7,4,8,3,7,0,8
+U,2,0,2,1,0,8,5,11,4,7,13,8,3,10,0,8
+R,4,2,4,3,3,7,8,5,6,6,5,7,3,7,4,8
+B,7,10,9,8,7,9,7,4,7,10,5,6,2,8,6,10
+D,3,6,4,4,3,8,7,4,5,10,5,5,3,8,3,8
+L,3,10,3,8,1,0,1,5,6,0,0,7,0,8,0,8
+V,3,4,4,3,1,4,12,3,3,10,11,7,2,11,1,8
+E,1,0,1,1,1,5,7,5,8,7,6,12,0,8,6,9
+V,4,11,6,8,4,6,11,2,3,7,11,9,2,10,1,9
+U,4,6,5,4,3,6,8,6,7,6,9,9,3,9,1,8
+O,3,6,5,4,3,7,6,8,6,6,4,7,3,8,3,8
+V,10,13,8,7,4,8,10,5,6,6,10,5,5,12,4,7
+D,2,3,3,1,2,7,7,6,6,7,6,5,2,8,3,7
+H,8,10,11,7,8,7,7,2,6,10,6,9,5,7,4,7
+R,5,10,7,8,7,8,8,4,6,8,4,8,4,5,5,11
+J,5,6,3,9,3,8,8,3,3,12,5,5,3,8,6,10
+H,3,3,4,4,2,7,9,14,1,7,4,8,3,8,0,8
+J,6,11,8,8,4,8,9,1,7,14,4,6,2,8,2,7
+H,4,3,4,4,2,7,6,14,1,7,8,8,3,8,0,8
+Q,2,0,2,1,1,8,7,6,4,6,6,9,2,8,3,8
+C,3,7,4,5,3,6,8,7,7,10,8,13,2,10,4,10
+H,3,4,4,6,4,8,7,4,0,7,6,7,3,9,8,5
+S,5,7,6,5,3,8,8,4,9,11,4,7,2,6,5,9
+M,3,7,3,5,3,8,7,11,1,6,9,8,7,6,0,8
+Q,2,2,3,3,2,8,8,5,2,5,7,10,2,9,5,10
+M,7,9,10,7,6,4,6,4,5,11,11,11,9,3,4,6
+C,4,4,5,7,2,7,6,7,10,9,5,13,1,10,4,9
+F,3,8,3,6,1,1,12,4,5,12,11,8,0,8,2,6
+Y,5,9,5,6,3,3,11,3,7,12,11,6,1,10,2,5
+V,6,8,6,6,4,3,12,2,3,9,11,8,4,12,1,7
+X,3,6,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+L,2,5,4,4,2,6,4,1,8,8,2,10,0,7,2,8
+C,2,3,2,2,1,4,8,4,6,11,10,11,1,9,2,7
+T,2,8,4,6,2,6,11,3,7,8,11,7,2,11,1,7
+C,9,13,6,8,3,6,9,7,7,11,7,6,2,9,6,8
+G,5,9,6,7,3,8,6,8,9,6,6,10,1,8,6,10
+K,1,0,1,1,0,5,7,7,1,7,6,11,2,8,2,11
+S,9,14,7,8,4,8,3,4,5,8,1,7,3,6,6,9
+Y,7,9,7,7,4,5,8,2,8,8,10,5,5,11,6,3
+Q,3,3,4,4,3,8,7,6,3,8,6,9,2,9,3,9
+F,2,3,4,2,1,6,10,3,5,13,7,5,1,9,1,7
+W,4,5,4,3,3,3,10,2,2,10,10,8,5,11,1,7
+T,4,11,6,8,6,9,11,3,7,5,12,8,2,12,1,9
+U,2,6,3,4,1,8,6,12,5,7,13,8,3,9,0,8
+I,1,5,1,4,1,7,7,1,7,7,6,8,0,8,2,8
+G,5,10,6,7,3,7,5,8,10,7,5,12,1,9,5,10
+G,3,5,4,7,3,7,7,8,7,7,7,7,2,7,6,11
+L,7,15,6,8,3,8,4,3,6,11,4,12,2,7,6,9
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+R,3,4,5,3,3,8,7,3,5,9,4,7,3,7,4,10
+X,4,9,5,6,1,7,7,5,4,7,6,8,3,8,4,8
+K,2,1,3,2,2,5,7,4,7,7,6,11,3,8,4,9
+T,5,5,5,4,2,5,12,2,7,11,9,4,1,11,2,4
+P,6,9,5,5,3,6,11,6,2,11,5,4,4,10,4,8
+N,11,14,9,8,4,8,11,5,5,3,6,10,6,10,3,7
+K,4,5,7,3,4,7,6,2,7,10,6,10,4,8,4,8
+Q,4,6,6,9,3,7,6,8,6,5,7,8,3,8,5,9
+M,5,7,7,5,6,7,7,3,4,9,8,9,7,5,2,8
+G,6,11,7,9,5,6,7,8,7,6,6,13,3,8,5,7
+J,7,10,4,14,4,7,9,3,4,13,5,5,3,8,7,10
+I,4,7,6,8,5,8,8,5,6,7,7,7,4,8,9,9
+B,3,6,5,4,5,8,8,6,6,7,6,6,2,8,6,9
+S,6,10,8,8,4,9,7,4,8,11,7,8,2,10,5,7
+L,2,3,3,2,1,6,4,2,8,8,2,10,0,7,2,8
+O,3,7,4,5,3,9,5,7,5,10,4,9,3,8,3,8
+I,1,3,2,2,0,7,7,1,7,13,6,8,0,8,0,7
+K,3,2,4,3,2,5,7,4,8,7,6,11,3,8,5,9
+Z,1,1,2,1,0,8,7,2,10,9,6,8,0,8,6,8
+O,6,9,6,7,5,8,6,8,4,9,5,8,4,7,4,9
+G,5,5,6,8,3,7,6,8,8,6,6,10,2,8,6,11
+L,3,7,4,5,3,6,5,7,6,6,6,9,2,8,4,10
+C,3,5,4,4,2,6,7,7,8,8,8,13,1,9,4,10
+X,6,10,7,5,3,5,9,2,8,11,8,8,4,9,3,6
+F,1,1,1,1,0,2,12,4,3,11,9,6,0,8,2,7
+I,8,13,7,7,4,9,7,3,6,12,4,5,3,8,6,11
+Z,2,7,3,5,2,8,6,5,10,7,6,7,1,7,8,8
+Z,7,11,9,8,6,8,7,3,10,12,6,8,2,7,6,8
+I,7,15,6,8,4,9,7,3,6,13,3,5,3,8,6,10
+F,2,7,3,4,1,1,13,5,3,12,10,6,0,8,3,7
+X,4,5,5,7,2,7,7,5,4,7,6,8,3,8,4,8
+G,5,10,6,8,5,5,7,6,6,10,8,11,2,9,4,10
+I,1,3,1,2,1,8,7,1,7,7,6,7,0,8,2,7
+I,3,5,4,6,4,7,8,5,5,6,8,7,3,10,8,8
+K,3,5,5,4,4,6,7,3,3,6,4,9,4,6,7,8
+J,3,5,4,7,1,13,2,8,5,14,3,12,0,6,0,8
+I,1,5,2,3,1,7,7,0,7,13,6,8,0,8,0,8
+P,3,5,5,4,2,7,12,4,3,12,4,1,1,10,3,8
+M,5,9,6,7,4,7,7,12,2,7,9,8,9,6,0,8
+Z,3,9,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+J,5,11,4,8,3,9,7,2,4,12,5,7,2,9,7,9
+O,2,5,3,3,2,8,7,7,4,9,5,8,2,8,3,8
+G,4,8,5,6,2,7,6,7,9,6,6,9,2,8,6,11
+E,3,8,3,6,2,3,7,6,9,7,6,14,0,8,7,8
+L,6,11,6,6,3,6,6,5,5,12,9,11,3,10,6,9
+P,3,6,3,4,2,3,12,6,1,11,7,4,0,9,3,8
+V,4,5,6,3,2,4,13,3,3,10,11,7,3,10,1,7
+V,1,0,2,1,0,7,9,3,2,7,12,8,2,10,0,8
+S,3,5,3,4,2,8,7,7,5,8,5,7,2,9,9,8
+F,3,8,5,6,2,3,13,6,3,13,9,4,2,10,2,5
+L,3,6,4,6,4,8,6,5,5,6,7,8,3,8,8,11
+P,5,8,7,6,6,7,6,6,4,7,6,9,5,8,7,10
+C,4,8,5,6,3,5,8,8,8,8,8,14,1,9,4,9
+V,8,10,8,8,5,3,12,3,3,10,11,8,3,9,2,6
+R,4,7,6,5,6,6,8,3,4,6,6,9,6,10,7,5
+U,5,9,4,5,3,7,7,4,5,7,7,8,5,6,3,7
+T,6,11,6,8,4,3,13,4,6,12,10,4,1,11,1,4
+P,5,6,5,8,3,4,12,9,2,10,6,4,1,10,4,8
+E,4,8,6,6,5,8,6,6,3,7,6,10,4,8,8,9
+V,6,10,6,8,4,2,11,2,3,10,11,8,2,10,1,8
+I,3,10,4,7,2,7,8,0,8,13,6,7,0,8,1,7
+S,3,5,3,4,2,8,7,7,5,8,6,7,2,9,9,8
+O,5,10,5,8,4,8,7,8,5,10,5,8,3,8,3,8
+Q,7,9,8,11,7,8,7,6,3,8,7,11,5,8,8,6
+A,6,12,6,6,3,13,1,5,2,12,2,10,2,3,2,10
+P,3,9,4,7,3,5,11,9,2,10,6,4,1,10,3,7
+H,6,11,6,8,3,7,7,15,0,7,6,8,3,8,0,8
+N,4,6,6,5,5,7,7,4,4,6,5,8,6,8,4,6
+B,6,10,6,8,5,6,6,9,8,6,6,7,2,8,10,10
+W,5,8,8,6,11,7,7,7,2,7,6,8,15,12,4,11
+H,6,8,9,6,7,6,9,3,6,10,8,8,3,8,4,6
+C,1,3,2,2,1,6,8,7,7,8,7,13,1,9,4,10
+O,2,1,2,1,1,8,7,7,6,7,6,8,2,8,3,8
+W,6,9,9,8,11,10,7,5,5,7,5,8,10,11,9,4
+H,3,3,4,2,2,7,8,6,6,7,6,8,3,8,3,7
+T,4,5,5,8,2,9,15,1,6,5,11,9,0,8,0,8
+H,4,6,6,4,5,7,8,5,6,7,5,8,3,8,3,8
+G,4,5,5,8,2,7,6,8,8,6,5,11,2,8,6,11
+Y,7,15,6,8,4,5,8,4,3,10,9,6,4,10,4,4
+Z,5,9,7,7,5,6,9,3,9,12,8,6,3,10,8,6
+D,4,7,5,5,5,7,8,6,6,8,7,5,3,8,3,7
+Z,4,8,5,6,5,8,7,3,8,8,6,7,1,8,10,9
+R,2,4,4,3,2,8,7,3,4,9,4,6,3,7,3,9
+M,6,8,9,6,7,8,7,2,5,9,6,8,9,6,2,8
+J,4,9,4,7,3,8,9,2,3,13,5,5,2,9,7,9
+L,4,8,5,6,4,3,4,4,7,2,0,8,0,6,1,6
+I,1,5,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+R,2,1,2,2,2,6,7,5,5,6,5,6,2,7,4,8
+L,5,9,6,7,5,5,6,5,6,6,5,9,8,7,4,10
+V,3,7,5,5,3,7,12,2,3,6,11,9,2,11,1,8
+J,4,7,5,5,2,8,6,3,7,15,5,10,0,7,1,7
+R,6,9,6,5,5,7,7,3,4,7,5,9,5,8,6,7
+D,4,8,5,6,4,7,7,8,7,7,6,5,3,8,3,7
+X,3,5,4,5,4,6,7,2,5,8,7,10,2,10,7,8
+E,5,9,6,7,6,6,7,6,9,8,7,10,3,8,6,8
+D,6,10,6,5,3,8,6,5,6,12,4,7,5,7,5,9
+L,2,6,3,4,1,0,1,5,6,0,0,6,0,8,0,8
+U,6,7,7,5,3,4,9,5,8,11,11,9,3,9,2,7
+S,5,9,6,7,3,8,7,4,8,11,7,8,2,10,5,8
+Q,6,8,6,9,7,8,9,6,2,6,8,11,3,8,6,8
+K,5,9,8,6,6,6,7,1,6,9,6,9,3,8,3,8
+F,4,5,4,8,2,1,12,5,5,11,11,8,0,8,2,6
+H,3,2,5,3,3,7,7,6,6,7,6,8,3,8,3,8
+G,3,7,4,5,2,8,7,8,8,6,6,11,1,8,5,10
+N,6,9,8,8,8,7,7,5,4,7,5,8,7,9,5,7
+X,4,8,6,6,4,8,8,3,9,5,5,6,3,9,7,8
+V,1,0,2,0,0,7,9,3,1,7,11,8,2,11,0,8
+G,5,9,4,4,3,7,8,4,3,8,6,7,3,10,9,7
+Z,7,15,7,9,5,11,3,4,6,12,3,10,3,7,7,11
+H,2,3,4,1,2,7,8,3,5,10,7,7,3,9,2,7
+Z,7,11,9,8,7,7,7,2,9,12,6,9,2,9,6,8
+F,7,13,6,8,3,6,9,3,6,12,5,5,2,9,6,6
+T,5,9,5,4,2,7,8,2,7,11,7,8,2,9,4,5
+I,4,10,7,8,8,10,8,1,6,9,5,5,3,8,7,6
+X,2,1,2,1,0,8,7,4,4,7,6,8,3,8,4,8
+E,3,4,5,3,2,7,7,2,8,11,7,9,2,8,4,8
+C,6,11,7,8,4,6,7,10,9,10,7,11,2,12,4,9
+T,5,8,6,6,4,4,12,3,6,12,10,5,1,11,1,5
+C,2,2,3,4,2,6,8,7,7,8,8,13,1,9,4,10
+M,4,4,6,3,3,10,6,3,4,9,4,7,7,6,2,8
+G,4,3,5,5,2,8,5,7,9,7,4,11,1,9,5,10
+K,7,9,6,5,3,6,8,3,7,9,8,9,5,8,3,7
+K,4,10,5,7,2,3,6,8,3,7,7,11,4,8,2,11
+E,2,1,3,2,2,7,7,5,7,7,6,8,2,8,5,10
+N,5,9,8,7,5,7,9,2,4,9,5,6,5,9,1,7
+Z,2,4,5,3,2,7,7,2,9,12,6,8,1,8,5,8
+M,4,3,5,5,3,8,7,12,1,6,9,8,8,6,0,8
+I,1,11,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+I,1,7,1,5,2,8,7,0,7,7,6,7,0,8,2,7
+Y,6,9,6,4,3,6,6,4,4,9,9,6,4,10,3,5
+H,4,10,5,7,3,7,7,15,1,7,6,8,3,8,0,8
+F,5,9,4,5,2,7,8,2,7,10,6,6,2,10,5,7
+W,3,3,4,1,2,5,11,3,2,9,8,7,6,11,1,6
+O,4,6,6,6,4,7,5,4,4,8,3,7,3,7,4,8
+B,3,4,4,3,3,7,7,5,5,7,6,6,2,8,6,9
+X,7,13,8,7,5,8,7,2,8,11,4,7,4,9,4,7
+R,4,5,4,8,3,5,11,8,4,7,4,9,3,7,7,11
+O,5,9,6,7,5,8,6,8,4,6,5,5,4,8,4,8
+I,3,7,4,5,2,8,6,2,7,7,6,7,0,9,4,7
+Y,3,7,5,5,4,8,6,6,5,5,8,8,2,8,9,5
+V,2,6,4,4,4,8,7,4,2,8,7,8,5,10,4,7
+L,3,2,3,3,2,4,4,5,7,2,1,6,1,7,1,6
+F,5,9,4,4,2,6,10,3,5,12,6,5,2,8,5,6
+O,3,5,4,7,2,7,7,9,6,7,6,8,3,8,4,8
+V,2,3,4,4,1,7,8,4,2,7,13,8,3,10,0,8
+U,1,0,2,1,0,7,6,10,4,7,12,8,3,10,0,8
+H,5,10,6,8,8,8,8,6,6,7,6,6,6,8,3,8
+T,5,9,5,7,3,5,12,4,6,12,9,4,2,12,2,4
+L,3,3,3,4,1,1,0,6,6,0,1,5,0,8,0,8
+D,8,14,7,8,5,7,6,3,7,10,5,7,6,7,8,5
+Z,4,6,5,4,4,9,9,5,4,7,5,7,3,8,9,5
+B,3,7,5,5,4,9,8,3,5,9,5,6,2,8,5,9
+E,5,7,7,5,5,7,8,1,8,11,6,9,3,8,4,9
+O,3,3,4,2,2,8,7,7,5,7,6,7,2,8,3,7
+F,4,9,4,4,2,6,10,2,5,11,7,5,2,9,5,5
+C,2,3,3,1,1,5,8,4,6,11,9,11,1,9,2,8
+J,5,8,7,6,5,8,6,9,6,7,7,8,4,5,6,3
+C,5,9,6,6,3,5,9,7,8,5,8,14,2,7,5,8
+G,3,5,5,4,5,7,8,5,2,7,7,8,6,11,7,8
+V,3,4,4,3,1,4,12,3,3,10,11,7,2,11,1,8
+J,1,1,1,1,0,12,3,6,4,13,4,11,0,7,0,8
+C,6,9,8,7,8,6,6,4,5,7,6,10,6,9,4,8
+S,4,8,6,6,3,9,6,4,8,11,4,8,2,8,5,10
+T,3,6,4,4,3,6,7,7,6,7,6,7,3,9,5,9
+C,6,8,6,6,3,5,7,6,8,11,8,14,2,10,4,7
+W,2,3,3,1,2,8,11,2,1,6,9,8,5,11,0,8
+B,2,6,3,4,4,6,6,7,5,6,6,7,2,9,7,10
+J,5,9,6,7,5,8,7,6,5,8,7,7,3,6,4,6
+O,5,9,6,7,4,8,6,8,5,10,5,9,3,8,3,8
+O,6,11,5,6,3,5,8,6,4,10,8,9,5,10,4,8
+D,2,3,3,1,1,8,7,4,5,10,4,5,2,8,2,8
+A,1,3,2,1,1,9,3,1,1,8,3,9,1,6,1,8
+D,5,6,7,5,5,6,7,5,7,7,4,7,3,7,5,6
+J,7,9,5,13,4,6,9,3,3,12,6,5,3,8,8,8
+Y,6,9,8,7,7,9,7,6,5,5,9,7,3,8,9,5
+D,4,7,4,5,2,5,6,10,9,5,5,6,3,8,4,8
+N,5,6,7,4,3,6,8,3,5,11,8,8,5,8,1,8
+Y,2,1,3,2,1,9,10,1,6,5,11,7,1,11,2,8
+W,6,9,6,4,3,1,10,3,3,12,11,9,6,11,0,6
+C,4,8,5,6,3,5,7,6,9,6,7,13,1,7,4,9
+L,2,3,3,2,1,7,4,1,8,8,2,10,0,7,2,8
+C,3,5,4,5,4,5,7,3,4,7,6,11,4,9,7,9
+A,3,5,5,3,2,8,2,2,2,8,2,8,2,6,3,7
+F,3,3,4,4,1,1,15,5,3,12,9,4,0,8,2,6
+C,4,6,5,5,5,5,6,3,5,7,6,11,4,10,6,10
+P,3,7,3,5,2,3,14,7,2,12,7,3,0,10,4,8
+Q,9,14,8,8,5,9,3,4,7,11,4,10,3,7,8,11
+E,2,4,4,3,2,7,8,2,7,11,7,8,2,8,4,8
+M,4,3,5,5,3,7,7,12,1,7,9,8,8,6,0,8
+M,4,8,6,6,7,7,8,6,4,7,5,8,6,9,7,7
+G,4,7,5,5,5,8,5,4,3,7,6,10,6,8,4,10
+H,4,7,6,5,5,7,8,5,5,7,6,8,6,7,5,9
+H,5,8,8,6,5,7,7,3,6,10,6,8,3,8,3,7
+I,2,7,3,5,2,7,7,0,7,13,6,8,0,8,1,8
+O,4,5,6,7,3,8,7,9,8,7,6,8,3,8,4,8
+S,7,12,6,7,3,9,3,4,4,9,2,8,3,6,5,9
+Q,2,1,3,2,1,8,6,7,5,6,6,8,3,8,4,8
+B,3,7,3,5,4,7,7,8,5,7,6,7,2,8,7,9
+W,6,9,8,7,8,8,4,7,3,7,6,7,8,7,6,3
+Z,2,7,3,5,3,7,8,5,8,7,6,10,1,9,7,7
+O,4,7,6,5,6,8,10,5,2,7,7,8,7,9,4,9
+S,3,5,5,4,2,7,7,3,7,11,6,8,1,9,5,7
+Q,1,2,2,2,1,8,7,6,2,6,6,9,2,9,3,10
+U,5,10,7,7,7,8,9,7,6,6,8,9,6,7,4,8
+H,2,1,2,2,2,7,8,5,5,7,6,8,3,8,2,8
+T,5,6,5,4,3,4,11,1,7,11,9,6,1,10,2,5
+L,5,11,6,8,4,3,4,3,9,2,0,8,0,7,1,5
+C,4,8,6,6,5,5,6,4,5,8,6,11,6,9,4,8
+C,5,9,5,7,3,5,8,6,8,12,9,12,2,10,3,7
+H,1,0,2,0,0,7,8,11,1,7,5,8,3,8,0,8
+X,3,5,6,3,2,9,6,1,8,11,4,8,2,8,3,9
+H,6,9,9,7,7,8,6,2,6,10,6,9,3,8,4,7
+E,3,7,3,5,2,3,7,6,10,7,6,15,0,8,7,7
+A,2,7,4,5,2,12,4,4,3,11,1,8,2,6,2,8
+F,4,5,5,8,2,1,14,5,4,12,10,5,0,8,2,5
+X,6,9,6,4,3,8,7,2,8,9,6,8,4,9,4,8
+B,8,13,6,7,4,9,6,5,5,11,4,9,6,6,7,10
+V,5,9,8,6,8,7,7,4,2,8,8,8,5,10,4,8
+P,5,9,5,4,3,10,8,4,4,12,4,5,4,10,5,9
+D,5,5,6,7,3,5,8,10,9,7,7,5,3,8,4,8
+S,3,4,5,3,2,9,6,2,7,10,4,7,1,9,5,10
+H,6,7,9,9,8,9,12,3,2,8,7,6,4,11,8,6
+H,4,8,5,5,2,7,5,15,1,7,8,8,3,8,0,8
+H,7,9,10,7,8,10,6,3,6,10,3,8,5,7,5,9
+U,7,10,6,5,4,8,6,4,5,7,7,7,6,7,4,6
+R,5,7,6,5,5,9,9,6,3,7,4,6,5,7,8,8
+N,2,2,3,3,2,7,8,5,4,7,6,6,5,8,1,6
+P,3,4,5,6,6,8,9,5,0,8,6,6,5,9,5,8
+C,3,8,4,6,2,6,7,7,10,6,6,14,1,8,4,9
+B,3,5,5,4,4,9,6,3,6,11,4,7,4,7,5,9
+Z,4,10,6,7,4,8,7,2,10,11,6,8,1,7,6,8
+E,5,9,7,8,7,5,8,4,3,8,6,9,5,11,10,9
+E,6,9,8,7,5,9,7,2,9,11,4,9,2,8,5,10
+W,7,9,7,4,3,6,10,1,3,8,10,7,7,12,1,7
+H,4,9,4,7,4,7,7,13,1,7,6,8,3,8,0,8
+L,5,10,5,5,3,10,3,3,3,11,6,10,3,10,4,10
+O,7,14,5,8,4,5,6,7,4,10,6,9,6,9,5,7
+G,5,9,7,8,8,7,6,6,4,8,7,9,10,8,10,7
+Z,3,5,5,8,3,11,5,3,5,10,2,7,2,7,5,11
+O,4,11,5,8,5,8,7,8,6,7,6,8,3,8,3,8
+S,4,9,5,7,3,9,8,6,9,5,6,8,0,8,9,8
+J,4,9,6,7,4,8,5,3,5,8,6,8,4,6,4,6
+M,5,11,6,8,4,9,7,13,2,6,9,8,8,6,0,8
+H,5,11,5,8,5,7,8,14,1,7,5,8,3,8,0,8
+T,2,3,3,2,1,7,12,2,7,7,11,8,1,11,1,8
+I,1,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+P,3,4,4,6,2,3,14,7,2,11,7,3,0,10,4,8
+X,2,4,3,3,2,8,7,3,8,6,6,6,2,8,5,8
+Y,3,5,5,4,2,4,10,1,8,10,10,5,3,11,5,3
+O,5,10,5,8,5,7,7,8,4,9,6,8,3,8,3,8
+Z,3,5,5,4,2,7,7,2,10,12,6,8,1,8,6,8
+U,5,8,7,7,6,7,7,4,5,6,7,8,7,8,2,7
+X,3,4,4,3,2,8,7,3,9,6,6,6,2,8,6,8
+R,3,6,5,4,5,7,7,3,4,7,6,8,6,9,6,6
+D,3,8,5,6,7,9,8,4,4,7,6,6,4,7,7,6
+L,2,7,3,5,2,4,4,6,7,2,2,5,1,6,1,6
+P,5,5,7,8,8,7,6,4,3,7,7,7,7,11,5,6
+E,3,5,4,4,3,7,8,5,8,7,5,9,2,8,6,9
+G,5,10,6,8,8,9,6,5,2,7,6,10,8,8,5,10
+X,7,10,10,7,5,5,9,2,9,11,12,9,3,9,4,5
+A,2,6,4,4,2,11,3,3,2,10,1,9,2,6,2,8
+U,4,9,5,7,4,7,6,11,4,6,13,8,3,9,0,8
+X,6,11,9,8,5,10,7,1,8,10,2,7,3,8,4,9
+G,3,7,5,5,5,8,5,4,3,7,6,10,6,8,4,10
+V,2,2,4,3,2,7,12,2,3,7,11,9,2,10,1,8
+T,3,7,4,5,3,7,12,3,7,7,11,8,2,11,1,8
+K,5,9,5,5,2,4,8,4,6,9,11,11,5,9,3,6
+F,6,10,8,7,6,7,9,3,6,12,7,6,3,9,2,7
+I,4,7,5,5,3,7,8,2,7,7,6,9,0,8,4,8
+N,8,10,11,7,5,11,7,3,6,11,0,3,6,9,2,8
+U,3,6,4,5,4,6,7,5,4,6,5,9,4,8,1,8
+O,4,11,5,8,5,8,7,8,4,7,6,5,4,8,3,8
+P,5,10,7,8,6,5,10,4,5,11,9,4,1,10,4,7
+U,4,7,4,5,1,8,5,13,5,7,14,8,3,9,0,8
+T,7,10,7,8,5,7,11,4,7,11,8,4,3,12,3,4
+B,8,10,7,5,5,9,7,4,5,9,4,7,6,7,8,9
+F,3,8,5,6,4,4,11,2,6,11,9,6,1,10,3,6
+L,2,6,2,4,1,0,1,5,6,0,0,6,0,8,0,8
+F,2,1,3,3,2,5,11,4,5,11,9,5,1,10,3,6
+D,5,11,7,8,5,8,7,9,8,7,6,2,4,8,5,9
+T,8,10,8,7,6,6,11,4,6,11,9,5,3,12,2,4
+C,3,2,4,3,2,6,8,7,7,9,8,13,1,9,4,10
+S,7,9,9,8,9,10,8,4,7,7,7,8,5,9,9,11
+U,6,10,6,5,4,8,5,5,5,6,8,7,4,9,3,7
+V,8,14,7,8,4,9,10,6,4,7,10,5,6,13,4,7
+U,6,9,8,7,10,9,7,4,5,5,8,7,11,9,6,6
+M,3,1,4,2,1,7,7,11,1,7,9,8,7,6,0,8
+J,5,6,3,9,3,9,7,3,3,11,4,5,3,8,6,9
+J,1,1,2,2,0,10,6,3,5,12,4,9,1,7,1,7
+X,6,9,9,6,4,5,8,2,8,11,11,9,3,9,4,5
+I,1,11,0,8,1,7,7,5,3,7,6,8,0,8,0,8
+D,6,11,8,8,7,7,6,7,5,5,5,6,7,9,3,7
+B,4,6,6,4,7,8,7,5,2,6,7,8,5,10,9,8
+D,3,6,5,6,4,7,7,5,6,7,5,7,4,7,6,5
+E,2,1,2,2,1,4,7,5,8,7,6,13,0,8,7,9
+P,4,10,6,8,6,7,7,8,4,8,6,7,3,9,7,9
+Z,3,5,4,7,2,7,7,4,14,10,6,8,0,8,8,8
+G,3,8,5,6,4,6,6,6,5,5,7,10,2,8,4,9
+L,5,9,5,5,3,7,5,3,6,11,6,11,2,7,6,8
+J,4,11,5,9,3,14,3,5,4,13,2,10,0,7,0,8
+W,5,11,8,8,12,10,8,4,2,6,7,8,11,10,4,5
+I,6,11,7,8,5,7,8,1,8,7,6,8,0,7,4,8
+E,3,2,4,3,3,7,8,5,8,7,6,9,2,8,6,9
+I,1,3,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+Y,4,5,5,4,2,4,10,2,8,11,10,5,3,10,4,3
+C,5,6,5,4,2,5,9,6,8,12,9,10,2,9,3,7
+V,3,8,5,6,1,6,8,4,3,8,13,8,3,10,0,8
+P,4,8,6,6,5,7,5,6,5,7,6,8,3,8,4,8
+R,12,15,9,8,5,9,6,6,5,10,2,8,7,6,6,11
+U,2,0,2,0,0,7,5,10,4,7,13,8,3,10,0,8
+A,1,0,2,0,0,7,4,2,0,7,2,8,1,7,1,8
+M,5,8,7,6,6,4,7,3,4,10,10,10,5,6,2,6
+K,6,8,9,6,4,6,8,2,7,11,6,8,3,8,4,7
+T,3,9,4,6,3,10,10,1,8,5,11,8,1,10,1,8
+Q,4,5,4,6,4,7,8,6,3,9,9,9,3,9,6,7
+X,4,5,5,7,2,7,7,5,4,7,6,8,3,8,4,8
+J,4,9,6,7,2,10,5,4,7,15,3,9,0,7,0,8
+X,2,1,3,1,1,8,7,4,8,6,6,7,2,8,5,8
+F,2,6,4,4,3,5,10,3,5,10,9,6,2,10,3,6
+S,4,10,5,8,3,8,7,6,9,4,6,8,0,8,9,8
+V,8,10,8,8,3,2,11,6,5,13,12,8,3,10,1,8
+X,3,4,5,3,2,9,7,2,8,10,3,7,2,8,3,9
+M,11,13,11,7,6,11,11,7,3,4,7,9,10,13,3,6
+T,7,10,9,8,7,6,7,7,8,7,8,9,4,10,7,7
+S,1,0,1,1,0,8,7,4,6,5,6,7,0,8,7,8
+C,4,8,5,6,2,5,7,7,10,7,5,12,1,9,4,9
+I,4,5,6,5,5,8,8,4,5,7,6,7,4,8,8,9
+P,5,9,5,7,5,4,11,9,2,10,6,4,1,10,3,8
+D,4,8,6,6,5,7,5,8,5,5,5,5,3,9,3,8
+C,5,9,6,6,5,7,8,8,6,6,6,11,4,8,4,8
+T,2,3,2,1,1,5,12,2,5,11,9,5,1,10,1,5
+D,5,7,6,5,5,7,7,4,6,7,7,9,6,7,3,7
+P,5,11,7,8,5,5,12,5,5,11,8,2,1,10,4,6
+G,3,7,5,5,6,7,6,4,3,6,5,10,6,8,6,10
+J,1,3,3,1,1,8,8,2,5,14,5,8,1,7,0,8
+W,4,4,5,3,3,4,11,3,2,9,9,8,6,11,1,7
+Y,4,8,6,6,3,7,10,1,7,5,11,8,1,11,2,8
+U,1,0,2,0,0,7,6,10,4,7,13,8,2,10,0,8
+Y,3,4,5,5,1,6,11,2,2,9,12,8,1,10,0,8
+W,4,2,5,4,3,6,10,2,3,7,9,8,7,11,0,8
+F,6,12,6,7,4,8,8,3,4,10,5,5,3,9,7,8
+U,3,6,3,4,2,8,6,12,4,8,11,8,3,9,0,8
+C,3,7,5,6,5,5,8,3,5,7,6,11,3,9,7,9
+S,5,7,6,5,3,6,9,3,8,11,5,7,2,6,5,8
+W,5,4,6,3,3,5,11,3,2,9,8,7,7,12,2,6
+T,2,7,3,5,1,9,14,0,6,5,11,8,0,8,0,8
+S,5,10,8,7,9,5,10,3,4,8,7,6,3,8,10,1
+W,3,1,3,2,1,8,8,4,0,7,8,8,7,10,0,8
+I,3,7,4,5,1,7,9,0,7,14,6,6,0,9,2,7
+C,3,10,4,8,3,5,7,6,8,7,5,12,1,8,4,10
+Z,2,1,3,3,2,7,8,5,9,6,6,9,1,9,7,8
+A,7,13,6,8,4,8,2,3,2,8,4,12,5,5,4,7
+S,4,9,6,7,4,10,6,5,6,10,2,7,2,7,4,11
+F,6,8,8,6,7,8,7,5,4,7,6,8,5,11,9,11
+I,2,9,3,7,2,7,7,0,7,13,6,8,0,8,1,8
+G,5,10,7,7,8,7,4,5,3,8,6,11,7,7,10,6
+Q,6,7,8,10,8,10,13,5,2,3,8,12,5,15,4,10
+O,5,10,7,8,5,7,8,9,6,7,7,8,3,8,4,7
+V,2,6,3,4,1,7,9,3,1,7,12,8,2,11,0,8
+O,5,11,7,8,5,8,5,9,5,6,6,4,5,7,5,9
+S,5,11,6,8,6,8,7,8,5,7,6,7,2,8,9,8
+D,4,10,5,8,7,7,7,6,6,7,6,5,6,8,3,7
+U,2,3,3,2,1,7,8,6,6,7,9,8,3,10,1,8
+T,5,8,7,6,7,7,8,4,6,7,6,9,5,8,5,7
+U,4,7,5,5,3,7,9,6,7,5,10,9,3,9,1,8
+A,4,9,7,7,5,6,5,2,3,4,1,6,5,7,5,4
+S,4,10,5,8,5,8,8,5,9,5,5,6,1,6,9,6
+J,5,10,7,8,3,8,8,1,8,14,4,6,1,9,1,8
+W,4,8,5,6,3,4,8,5,1,7,8,8,8,10,0,8
+M,4,7,7,5,8,7,7,3,2,7,5,8,8,5,2,7
+E,6,11,4,6,2,6,8,4,6,10,6,9,2,9,8,9
+Y,4,5,5,3,2,4,10,2,8,11,10,5,1,11,3,4
+X,4,6,6,4,3,10,7,1,8,10,2,6,3,8,3,9
+X,3,6,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+K,3,9,4,6,2,3,7,7,2,7,5,11,3,8,2,10
+U,7,10,6,5,3,6,4,5,5,4,8,8,5,10,2,7
+D,1,3,3,2,2,8,7,4,5,9,4,6,2,8,2,8
+M,3,7,4,5,3,7,7,11,1,7,9,8,8,5,0,8
+T,3,3,3,2,1,5,13,4,5,11,8,4,2,11,1,5
+K,5,6,7,4,4,4,7,2,7,10,9,11,3,8,3,6
+O,4,6,6,4,3,7,5,7,5,8,4,10,3,7,3,8
+P,2,3,3,2,1,5,11,3,4,10,8,3,0,9,3,6
+Q,7,8,7,10,6,7,8,6,4,8,9,10,4,8,8,8
+Y,3,8,6,6,3,9,10,1,6,4,11,8,1,11,2,9
+S,4,5,5,7,3,8,8,6,9,5,6,7,0,8,9,8
+X,4,7,6,5,3,5,8,1,8,10,9,9,2,9,3,6
+M,4,4,6,3,4,5,7,3,4,10,10,10,7,7,2,8
+C,3,2,4,4,2,6,8,8,8,9,8,12,2,10,4,9
+J,1,4,2,2,1,8,7,2,5,14,6,9,1,7,0,7
+L,5,11,6,8,2,0,0,7,6,0,1,4,0,8,0,8
+F,4,8,6,6,5,7,8,6,4,8,6,8,3,10,8,10
+X,3,5,5,3,3,8,7,3,10,6,6,8,4,7,7,9
+E,2,6,3,4,2,3,8,5,8,7,6,13,0,8,6,10
+D,3,8,3,6,2,5,7,10,8,7,6,5,3,8,4,8
+W,4,6,6,4,5,7,7,6,2,8,8,8,6,7,4,8
+L,2,4,3,6,1,0,1,5,6,0,0,7,0,8,0,8
+U,4,4,5,3,2,5,8,5,8,10,9,9,3,9,2,6
+H,4,7,6,5,4,8,8,3,6,10,5,7,3,8,3,7
+K,2,3,3,1,1,4,8,2,6,10,10,10,2,8,2,6
+W,9,10,9,5,3,3,10,2,2,10,11,8,8,12,0,7
+W,3,1,5,2,2,8,11,3,2,6,9,8,6,11,1,7
+R,4,7,4,4,2,5,11,8,3,7,4,8,3,7,6,11
+Q,4,6,5,8,3,8,7,8,6,6,8,8,3,7,6,10
+S,4,9,5,7,3,8,8,6,9,5,6,6,0,8,9,7
+U,9,10,9,8,5,4,7,6,9,9,8,9,6,10,4,2
+O,5,11,6,8,6,8,7,9,4,7,6,7,3,8,3,8
+A,3,7,5,5,4,8,5,1,3,7,2,6,2,6,4,5
+N,6,11,6,8,6,7,7,13,1,6,6,8,5,8,0,8
+D,5,9,7,7,5,7,6,8,5,6,5,4,5,8,5,9
+F,5,11,6,8,2,1,15,5,3,12,9,4,0,8,2,5
+T,4,6,4,4,2,6,12,3,6,11,9,4,2,11,2,5
+H,6,10,6,8,6,7,6,13,2,7,8,8,3,9,0,8
+X,3,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+O,2,5,3,4,2,8,7,7,4,9,6,8,2,8,2,8
+Y,6,8,9,12,12,7,9,3,3,7,8,9,7,13,12,5
+C,10,15,6,8,3,7,8,6,7,12,6,7,2,9,5,8
+N,3,3,5,2,2,6,10,3,4,10,8,7,5,8,0,8
+Z,6,7,5,11,4,9,6,4,3,11,6,8,3,9,11,7
+P,4,6,6,4,3,6,13,7,2,11,5,2,1,10,4,7
+V,9,13,8,7,4,6,10,4,4,8,8,5,5,11,3,6
+M,4,10,5,8,6,7,6,10,1,7,8,8,7,5,0,8
+R,4,6,6,4,5,7,7,3,4,6,6,8,6,9,6,6
+B,6,9,8,6,8,7,9,6,5,7,5,6,4,7,6,8
+Z,5,8,7,6,4,7,8,2,10,12,7,9,1,9,6,8
+Y,4,9,4,4,2,7,7,4,4,9,9,5,3,11,3,4
+X,4,6,6,4,3,10,7,1,8,10,2,6,3,8,3,10
+L,2,6,4,4,2,4,5,1,8,6,2,10,0,7,2,7
+L,3,8,4,6,2,0,2,4,6,1,0,7,0,8,0,8
+X,3,10,6,7,6,8,7,2,6,7,6,8,3,8,6,8
+S,4,10,6,8,7,7,6,3,2,7,5,6,3,7,14,4
+S,4,5,6,5,6,8,7,5,5,7,6,7,5,8,9,11
+O,4,8,5,6,4,7,8,8,4,7,7,8,3,8,3,8
+E,4,7,6,5,5,6,8,3,7,11,8,9,3,8,4,7
+Y,1,1,2,1,0,8,9,2,2,7,12,8,1,10,0,8
+O,9,14,6,8,4,4,9,6,5,10,8,9,5,10,5,7
+G,7,10,6,6,4,8,7,4,3,9,5,6,4,9,8,8
+A,3,4,5,3,2,8,2,2,2,8,2,8,2,7,3,7
+D,4,9,5,6,4,8,7,6,6,10,5,5,3,8,3,8
+Y,4,10,6,7,3,7,10,1,8,6,12,8,1,11,2,8
+T,2,6,4,4,2,6,12,3,7,8,11,8,1,11,1,7
+V,3,5,4,3,2,4,12,2,3,9,11,7,3,10,1,7
+G,4,7,5,5,2,7,6,7,9,6,5,10,1,8,6,11
+N,5,9,5,7,3,7,7,15,2,4,6,8,6,8,0,8
+G,6,9,8,7,10,8,7,4,3,6,5,9,8,7,9,13
+E,6,11,8,8,7,10,6,1,8,11,4,8,4,7,5,11
+D,4,5,5,4,4,6,7,5,7,6,4,7,3,8,5,6
+Q,2,1,3,2,1,8,7,7,5,6,6,8,3,8,4,8
+C,5,11,6,8,5,7,8,8,6,5,6,12,4,7,4,7
+W,4,10,6,8,8,7,7,6,3,8,8,7,6,8,4,9
+O,4,6,6,5,4,7,6,4,4,7,3,7,3,7,4,8
+I,3,11,5,8,6,10,6,1,4,9,4,4,3,8,5,8
+W,3,7,5,5,5,7,7,6,2,7,8,8,5,8,3,8
+P,4,7,6,5,4,6,12,5,3,12,5,1,1,10,3,8
+E,2,7,3,5,2,3,7,6,10,7,6,14,0,8,7,8
+V,4,7,4,5,3,3,11,2,2,9,11,8,2,11,1,8
+D,8,13,8,7,4,9,5,4,6,11,3,7,5,6,6,11
+N,2,2,3,3,2,7,8,5,4,7,7,6,5,9,2,5
+H,5,7,7,5,5,6,7,6,7,7,6,8,6,8,3,8
+W,4,9,6,7,3,8,8,4,1,6,8,8,8,10,0,8
+A,5,12,5,6,3,12,2,4,2,11,3,11,4,4,4,11
+N,7,13,7,7,3,6,9,4,5,4,5,11,6,11,2,7
+A,2,1,4,2,1,8,2,2,1,7,2,8,2,6,3,6
+Z,4,8,5,6,5,8,11,6,5,6,5,7,3,9,6,4
+N,5,7,8,5,3,7,8,3,5,10,6,7,6,8,1,7
+Z,2,4,4,3,2,8,6,2,9,11,5,9,1,8,5,9
+V,3,9,5,7,1,7,8,4,2,7,14,8,3,9,0,8
+B,8,13,8,7,7,8,8,4,5,9,5,7,8,4,9,7
+M,3,4,4,3,3,7,6,6,4,7,7,10,6,5,1,9
+R,6,11,9,8,6,9,9,4,7,8,3,8,3,6,5,11
+B,6,11,4,6,3,10,5,6,5,11,3,9,6,7,6,10
+E,1,3,3,1,1,6,7,2,6,10,7,10,1,8,4,9
+K,2,1,3,2,2,7,7,4,6,6,6,9,3,8,5,10
+E,2,3,3,5,2,3,8,6,10,7,6,14,0,8,7,8
+X,4,9,7,6,4,7,7,4,10,6,6,8,3,8,7,8
+Z,3,7,5,5,2,9,5,3,9,11,4,9,2,7,6,9
+A,3,7,5,4,2,8,3,3,3,7,2,8,3,6,3,8
+F,5,7,6,8,7,6,11,4,4,8,7,6,4,9,7,7
+O,4,8,5,6,4,8,7,8,6,7,7,10,3,7,4,7
+M,5,9,6,5,3,14,2,4,3,12,1,9,5,4,0,9
+O,3,5,4,3,3,8,7,7,5,7,6,8,2,8,3,8
+K,4,8,6,6,5,5,6,4,7,6,6,10,3,8,5,10
+Q,3,5,4,6,4,9,8,7,2,4,7,11,3,9,6,10
+I,5,7,6,8,6,7,9,4,5,8,7,7,4,8,9,10
+U,4,5,4,4,2,4,8,5,7,10,9,9,3,9,2,6
+G,5,10,6,7,3,7,5,8,9,6,5,10,1,8,6,11
+X,1,0,2,1,0,7,7,4,5,7,6,8,2,8,4,8
+A,2,5,3,3,2,11,3,2,2,9,2,9,2,6,2,8
+T,1,6,2,4,1,7,13,0,4,7,10,8,0,8,0,8
+J,2,6,4,4,3,9,7,2,3,8,4,6,4,8,6,5
+A,3,5,5,4,2,10,2,2,2,8,2,9,3,5,2,8
+P,1,0,1,0,0,5,11,6,1,9,6,5,0,9,3,8
+K,4,8,4,6,2,3,6,9,2,7,7,11,3,8,2,11
+Y,2,8,3,6,1,9,10,1,3,6,11,8,1,11,0,8
+W,5,11,8,8,4,8,8,5,2,7,8,8,9,9,0,8
+K,4,7,6,5,5,5,7,4,7,6,6,11,3,8,5,9
+W,4,2,6,4,4,8,11,3,2,6,9,8,8,12,1,7
+M,11,11,11,6,5,6,10,5,5,4,4,11,10,12,2,7
+W,8,10,11,9,14,7,7,5,5,6,5,8,11,9,10,9
+F,8,11,6,6,3,9,6,3,8,11,4,6,2,10,5,9
+K,4,7,5,5,5,6,8,5,3,7,5,8,4,6,7,10
+T,4,8,5,6,4,6,11,3,7,8,11,8,2,12,1,7
+U,3,7,5,5,4,8,7,7,5,6,7,9,5,8,3,7
+U,3,8,4,6,3,8,6,12,4,7,11,8,3,9,0,8
+I,1,6,2,4,1,7,7,0,7,14,6,8,0,8,1,8
+D,5,8,5,6,5,6,7,9,8,6,5,6,2,8,3,7
+L,1,0,1,1,0,2,2,5,5,1,1,6,0,8,0,8
+A,4,9,6,7,4,12,2,3,2,10,2,9,2,7,3,8
+I,3,10,4,7,2,7,7,0,8,14,6,8,0,8,1,8
+V,4,6,4,4,2,4,12,1,2,9,10,7,2,11,0,8
+Z,4,8,5,6,5,8,10,5,4,6,5,6,3,8,8,3
+H,4,9,4,6,2,7,8,15,1,7,5,8,3,8,0,8
+C,2,1,2,1,0,6,7,6,9,7,6,14,0,8,4,10
+Y,1,0,2,0,0,7,9,3,1,7,12,8,1,11,0,8
+H,6,10,6,6,3,7,8,3,5,9,5,7,6,7,5,8
+F,1,3,3,2,1,5,11,3,4,12,7,5,1,9,1,7
+A,3,2,5,4,2,10,2,2,2,9,1,8,2,6,3,8
+B,5,7,6,5,6,8,7,4,4,7,5,7,6,8,5,8
+T,7,9,7,7,4,5,10,1,8,11,9,6,0,9,2,4
+G,10,14,8,8,4,11,4,4,5,11,3,8,5,7,5,10
+E,6,9,8,7,6,5,8,3,8,11,9,9,3,9,4,6
+Y,1,0,2,0,0,7,10,1,3,7,12,8,1,11,0,8
+X,9,15,10,9,6,8,8,2,7,11,6,6,5,12,4,8
+Y,3,4,5,6,6,7,8,4,1,6,8,9,4,11,7,7
+V,3,4,5,6,1,9,8,4,3,6,14,8,3,10,0,8
+M,3,8,4,6,3,7,6,11,1,7,9,8,8,6,0,8
+X,3,8,5,6,3,7,7,4,9,6,6,8,3,8,6,8
+H,4,10,6,7,10,8,8,5,2,6,6,7,8,9,10,8
+S,5,5,6,8,4,8,9,6,10,5,6,6,0,7,9,7
+Y,3,6,4,4,2,10,11,2,2,5,12,8,1,11,0,8
+R,4,8,6,6,7,6,7,3,4,6,6,9,7,10,7,5
+G,4,7,5,5,3,6,7,6,7,10,7,11,2,9,4,9
+B,3,2,4,4,4,7,7,5,6,7,6,6,2,8,6,10
+L,3,10,3,8,1,0,1,5,6,0,0,7,0,8,0,8
+T,4,11,5,8,3,7,14,0,5,7,10,8,0,8,0,8
+S,6,12,5,6,2,10,2,1,5,9,1,8,2,8,4,11
+I,1,3,1,2,1,8,7,1,7,7,6,7,0,8,2,7
+R,4,6,6,4,3,10,8,3,7,11,1,6,3,7,3,10
+E,3,9,4,7,4,7,7,7,9,8,8,10,3,8,6,7
+O,7,13,5,7,4,6,6,6,3,10,7,9,5,9,5,8
+Y,7,11,7,8,5,4,9,1,7,9,10,6,2,12,4,3
+X,4,4,6,3,3,5,8,2,9,11,10,9,3,7,3,6
+O,4,8,6,6,5,7,7,8,4,7,5,8,3,8,3,8
+V,3,7,5,5,5,8,5,4,1,7,7,8,5,9,3,7
+H,3,7,4,5,2,7,8,14,1,7,6,8,3,8,0,8
+C,8,12,5,6,2,7,8,7,7,11,7,9,2,9,5,9
+P,7,10,6,5,3,5,11,5,2,12,5,4,4,9,4,8
+R,7,11,10,8,7,11,6,3,6,11,2,6,6,7,5,10
+A,2,1,3,1,0,7,4,2,0,7,2,8,2,7,1,8
+P,2,6,2,4,2,3,13,5,1,11,7,4,0,9,2,7
+R,3,8,3,6,2,6,10,9,4,7,4,8,3,7,5,10
+Y,3,3,4,2,1,4,10,2,7,10,10,5,2,12,3,4
+T,3,8,4,6,1,8,15,1,6,6,11,9,0,8,0,8
+Q,5,10,7,9,3,8,7,8,7,6,7,9,3,8,5,9
+V,3,2,5,3,2,7,12,2,3,7,11,9,2,10,1,8
+J,6,10,9,8,6,9,5,6,5,8,6,7,3,7,4,6
+N,5,9,7,7,4,8,7,3,5,10,5,6,6,8,1,7
+M,4,5,6,4,4,8,6,2,4,9,6,8,7,5,2,8
+V,7,9,7,7,3,3,11,5,5,12,12,7,3,10,1,8
+W,4,4,6,6,3,4,8,5,1,7,8,8,8,9,0,8
+E,1,0,1,1,0,5,7,5,7,7,6,12,0,8,6,10
+M,4,2,5,3,4,8,6,6,4,7,7,9,9,5,2,8
+S,3,5,3,4,2,8,7,7,5,8,5,7,2,8,9,8
+H,5,8,8,6,5,5,9,4,6,10,10,9,4,9,4,6
+J,4,9,6,7,3,7,7,3,6,15,6,11,1,6,1,7
+T,6,9,6,7,2,5,13,3,9,12,9,3,0,10,2,4
+J,3,6,4,4,2,9,4,5,4,14,7,13,1,6,0,7
+B,6,9,8,7,6,9,7,3,7,11,4,6,2,8,6,10
+J,2,8,3,6,1,11,5,2,9,12,2,8,0,7,1,8
+S,2,4,4,3,2,9,6,2,7,11,5,8,1,9,4,9
+K,3,9,4,6,3,4,7,7,3,7,6,12,3,8,3,11
+L,4,9,6,6,3,7,3,2,8,7,2,8,1,6,2,7
+N,4,4,4,6,2,7,7,14,2,4,6,8,6,8,0,8
+F,5,7,7,8,7,7,8,4,6,7,6,6,4,9,9,9
+N,6,10,8,8,6,7,9,5,5,7,6,6,7,7,3,7
+V,1,0,2,1,0,8,9,3,2,7,12,8,2,10,0,8
+U,3,2,4,4,2,8,8,6,7,5,9,8,3,9,1,8
+P,5,7,6,10,11,8,6,6,1,7,6,7,9,8,6,8
+O,3,7,4,5,3,6,8,7,5,9,8,8,3,8,3,8
+I,4,10,5,7,3,7,7,0,7,13,6,8,0,8,1,8
+J,3,7,5,5,2,9,5,5,5,15,6,11,0,6,1,7
+M,3,7,4,5,3,7,7,11,1,7,9,8,8,5,0,8
+P,8,9,7,4,3,6,11,6,2,10,4,5,4,9,4,8
+Q,5,10,6,9,6,8,8,7,4,5,10,9,3,8,5,9
+X,6,9,9,7,5,4,8,2,8,10,12,11,3,8,3,5
+Z,3,8,4,6,3,9,6,5,10,7,5,6,1,7,8,8
+M,1,0,2,0,1,7,6,9,0,7,8,8,6,6,0,8
+G,5,11,6,8,7,7,8,6,2,6,6,10,4,8,7,7
+T,4,5,5,7,2,5,15,1,6,9,11,7,0,8,0,8
+I,6,12,4,7,3,11,3,4,5,12,2,8,3,8,4,10
+I,4,10,5,8,4,6,8,0,7,13,7,8,0,8,1,7
+L,5,10,5,5,3,5,7,3,7,12,8,11,2,8,6,7
+J,2,6,4,4,3,9,7,3,3,8,5,6,4,8,6,5
+J,4,9,6,7,6,9,9,4,3,8,4,6,4,8,5,4
+P,3,3,4,5,2,4,11,9,2,10,6,4,1,10,4,8
+M,5,5,7,4,4,7,6,6,6,6,7,7,9,7,3,6
+I,3,11,4,8,3,9,7,0,7,13,5,8,0,8,1,8
+U,3,1,4,3,2,6,9,5,7,7,10,9,3,9,1,8
+B,2,3,4,2,2,8,8,3,5,10,5,6,3,7,5,8
+U,5,10,6,8,6,9,6,6,6,7,6,8,9,8,4,7
+F,3,8,3,5,1,1,13,4,4,12,11,6,0,8,2,6
+F,5,9,5,5,4,5,12,3,3,11,7,4,4,10,7,5
+L,5,10,7,8,4,7,3,1,9,9,2,11,0,7,3,9
+Q,6,10,8,9,4,8,6,8,8,6,5,8,3,8,5,8
+X,2,0,2,1,0,7,7,6,2,7,6,8,3,8,3,8
+P,2,3,3,2,2,5,9,4,4,9,7,4,1,10,3,7
+Z,2,1,2,2,1,7,7,5,9,6,6,8,1,8,6,8
+B,7,10,9,8,6,11,5,3,7,11,3,7,5,7,7,12
+E,6,9,8,8,8,6,9,4,4,8,7,10,5,11,8,10
+E,3,2,3,3,3,7,7,5,7,7,5,9,2,8,5,10
+F,6,9,8,6,5,6,11,3,5,13,7,4,2,10,2,7
+V,3,6,5,4,1,7,8,4,2,7,13,8,3,10,0,8
+M,4,11,5,8,4,7,7,12,2,7,9,8,8,6,0,8
+F,4,10,7,8,8,9,6,1,5,9,6,6,6,11,5,6
+K,4,10,6,8,6,7,6,5,4,6,6,8,4,6,10,11
+X,1,1,2,1,1,7,7,3,7,6,6,8,2,8,5,8
+Y,5,8,5,6,2,4,10,1,7,10,10,6,1,11,3,3
+L,4,8,5,6,2,5,3,1,9,6,1,10,0,7,2,7
+T,5,8,5,6,3,5,11,2,8,12,10,5,1,10,2,4
+Y,9,13,8,7,4,6,7,5,4,10,9,5,4,10,4,5
+S,8,15,6,9,3,11,3,4,5,11,2,9,4,6,5,11
+G,3,8,4,6,2,8,5,8,9,8,4,12,1,9,5,10
+B,6,10,8,7,6,10,7,3,7,11,3,6,2,8,5,11
+H,4,5,5,4,4,8,7,6,6,7,6,8,3,8,4,7
+J,3,6,5,4,2,7,6,3,6,15,6,11,1,6,0,8
+V,4,5,7,8,2,7,8,4,3,7,14,8,3,9,0,8
+V,3,6,5,4,1,8,8,4,2,6,14,8,3,9,0,8
+Y,4,7,6,5,3,5,9,1,7,8,12,9,1,11,2,7
+Z,3,9,5,7,5,8,6,2,7,8,6,8,1,7,11,10
+Q,2,4,3,5,3,8,7,6,2,8,7,9,2,8,4,9
+F,7,11,6,6,3,7,8,3,6,12,5,6,2,8,6,6
+Y,3,7,5,4,1,7,10,3,2,7,13,8,2,11,0,8
+T,5,6,7,6,6,7,9,5,8,7,7,7,3,11,7,7
+E,4,9,5,7,6,6,7,5,8,7,6,10,3,8,6,9
+Q,3,5,4,6,4,8,7,7,3,8,6,9,2,9,3,8
+Z,3,5,6,4,3,8,7,2,10,12,6,9,1,8,6,8
+U,12,14,10,8,4,6,5,4,7,3,9,6,6,7,2,7
+X,2,3,4,1,2,7,7,4,9,7,6,8,2,8,6,7
+D,8,14,7,8,5,6,7,5,6,9,6,6,5,8,7,4
+I,5,10,4,6,2,9,7,3,6,13,4,5,2,9,4,10
+C,4,9,5,6,3,4,8,6,6,11,10,12,2,10,3,7
+N,6,9,5,5,2,4,8,4,6,4,4,11,5,9,2,7
+R,5,9,8,6,9,8,7,4,4,6,7,8,7,9,8,6
+U,4,5,5,4,2,4,8,5,8,10,9,9,3,9,2,6
+X,3,6,5,4,4,8,6,2,5,6,6,7,2,9,8,9
+L,7,11,9,9,7,9,7,8,6,6,6,7,6,7,9,15
+B,7,11,9,8,9,8,8,4,6,7,6,7,7,7,7,9
+F,3,10,4,8,3,1,12,3,4,12,11,8,0,8,2,6
+G,5,11,6,8,4,6,7,7,7,10,7,11,2,9,4,9
+K,4,5,6,5,5,9,5,2,4,8,4,8,4,6,6,11
+J,3,9,5,7,3,5,7,3,5,15,8,11,1,6,1,7
+X,3,8,5,6,4,8,7,3,8,5,6,8,2,8,6,8
+R,1,0,1,0,0,6,8,7,3,7,5,7,2,7,4,11
+R,2,3,3,2,2,6,8,4,5,7,5,7,2,7,4,9
+R,3,8,5,6,5,8,8,7,4,8,5,7,4,7,6,11
+R,5,9,7,6,6,6,8,5,6,7,5,8,3,7,5,9
+J,1,3,2,2,1,8,6,3,4,14,6,10,1,7,0,7
+Z,4,7,4,5,3,7,7,6,11,6,6,8,1,8,8,8
+A,4,9,7,6,4,8,3,1,2,5,2,8,3,5,3,7
+V,2,1,3,2,1,9,12,2,2,5,10,9,2,11,0,8
+G,6,9,6,7,5,5,6,6,5,9,8,11,2,9,4,10
+K,7,12,7,7,4,11,6,4,6,11,2,6,5,8,4,10
+I,3,6,4,4,2,7,7,0,7,13,6,8,0,8,1,8
+N,6,9,8,7,9,7,7,3,5,8,6,7,6,9,7,5
+X,5,8,7,6,3,8,7,2,8,10,4,7,3,8,4,8
+N,4,4,4,6,2,7,7,14,2,4,6,8,6,8,0,8
+E,5,10,7,8,6,7,7,6,9,7,6,9,6,8,6,9
+J,3,7,5,5,2,8,5,5,5,15,7,12,1,6,1,6
+W,5,11,7,8,4,7,7,5,2,7,8,8,9,9,0,8
+Z,4,8,6,6,3,7,7,2,10,12,6,7,1,7,6,7
+D,7,12,7,6,4,12,2,4,5,12,1,9,4,7,2,11
+J,4,5,6,5,5,8,8,4,6,7,6,8,3,9,8,8
+D,5,8,7,6,5,10,5,2,7,11,3,7,4,7,3,9
+J,4,11,6,9,5,7,7,1,6,11,5,9,1,6,2,5
+Z,1,0,1,1,0,7,7,2,10,9,6,8,0,8,6,8
+W,6,10,8,8,4,4,8,5,2,7,9,8,9,9,0,8
+B,5,11,5,8,7,6,7,8,5,6,6,7,2,8,8,9
+S,4,5,4,4,3,8,8,7,5,7,6,7,2,9,9,8
+L,4,9,4,7,1,0,0,6,6,0,1,5,0,8,0,8
+C,5,11,6,8,3,4,7,7,11,7,7,12,1,7,4,8
+E,4,6,5,5,5,6,8,4,3,8,7,9,4,10,8,11
+J,5,8,3,12,3,9,6,2,4,9,5,6,3,9,5,10
+E,5,9,8,7,5,10,6,2,8,11,4,9,3,8,5,11
+M,7,11,9,8,11,7,8,6,4,7,6,8,8,10,9,11
+W,7,10,7,8,7,4,11,2,2,9,8,7,7,12,2,6
+W,6,8,8,7,10,7,7,5,5,6,5,8,10,8,8,10
+X,5,10,7,8,5,8,7,3,9,5,6,9,5,7,9,8
+W,4,4,5,3,3,4,11,3,2,9,9,7,6,12,1,6
+J,2,7,2,5,1,15,3,3,5,12,1,8,0,8,0,8
+D,2,3,4,2,2,9,6,4,6,10,4,6,2,8,3,8
+R,3,7,4,5,4,8,8,7,2,7,4,6,4,6,8,8
+H,4,7,6,5,5,7,9,7,5,8,5,7,3,7,5,10
+E,2,1,3,3,2,7,7,5,7,7,6,9,2,8,5,10
+C,4,7,5,5,2,4,9,6,8,12,10,11,1,9,3,7
+T,2,3,3,1,1,7,11,2,6,7,11,8,1,10,1,7
+O,4,7,5,5,3,7,6,8,5,7,5,8,3,8,3,8
+M,2,1,3,2,1,7,6,10,1,7,9,8,7,6,0,8
+F,3,11,4,8,2,1,13,5,4,12,10,7,0,8,3,6
+L,3,9,5,7,3,5,5,2,8,6,1,10,0,6,3,7
+S,4,6,5,4,5,8,9,4,4,8,5,6,3,9,9,7
+Y,1,0,2,0,0,8,10,3,1,6,12,8,1,11,0,8
+R,4,5,5,7,3,5,10,9,4,7,4,8,3,7,6,11
+F,2,4,3,2,1,4,11,4,4,13,8,5,1,9,1,7
+Z,5,11,6,8,5,6,8,6,11,7,7,10,1,9,8,8
+Y,3,2,5,4,2,6,10,1,8,8,12,8,1,11,3,7
+J,5,9,7,7,4,6,7,3,6,15,7,11,1,6,2,6
+D,6,11,9,8,8,8,8,5,6,10,6,5,4,8,4,9
+T,2,1,3,2,1,8,12,3,6,7,11,8,2,11,1,8
+M,3,5,4,4,4,8,6,6,4,7,7,8,7,5,2,7
+Q,3,5,4,8,2,8,7,9,5,6,7,9,3,8,5,9
+O,1,0,2,0,0,7,7,6,4,7,6,8,2,8,3,8
+B,4,11,5,8,4,6,8,10,7,7,5,7,2,8,9,9
+D,2,4,4,3,2,9,6,4,6,10,4,6,2,8,3,8
+U,4,9,5,6,4,7,6,12,4,6,12,8,3,9,0,8
+Z,3,9,4,7,5,9,9,3,7,7,7,5,0,9,12,9
+C,4,7,4,5,3,5,8,5,6,11,9,13,2,9,3,7
+N,1,0,2,1,0,7,7,11,0,5,6,8,4,8,0,8
+F,6,11,8,8,8,6,10,6,5,9,6,9,3,10,8,10
+J,5,10,6,8,3,6,9,3,6,15,7,8,2,8,2,8
+C,5,11,6,8,3,5,8,8,8,8,8,14,2,9,4,9
+P,2,3,2,2,1,5,9,3,4,9,8,5,1,9,2,7
+L,7,10,9,7,7,6,6,9,5,6,6,9,3,7,6,13
+I,4,5,6,5,4,8,9,4,6,7,7,8,3,8,8,8
+M,2,0,2,1,1,7,6,10,0,7,8,8,6,6,0,8
+S,4,6,5,4,3,7,8,3,7,10,4,7,2,6,4,8
+W,6,7,6,5,6,7,10,4,2,8,6,6,8,12,4,5
+Z,5,6,4,8,3,8,6,5,5,10,6,7,3,9,9,9
+C,1,3,2,2,1,6,8,6,7,7,8,12,1,9,4,10
+J,5,7,7,8,6,8,9,4,5,7,6,7,3,8,9,8
+F,2,4,3,3,2,7,9,2,5,13,6,6,2,11,2,7
+S,4,7,6,5,3,9,7,4,8,11,3,8,2,8,5,11
+Y,3,5,4,7,6,8,8,3,1,7,7,9,4,11,6,7
+T,3,4,4,2,1,5,13,3,6,12,9,3,1,10,1,5
+T,4,9,4,4,1,6,10,2,7,12,7,5,1,10,3,5
+N,4,2,5,4,3,7,9,5,5,7,6,6,7,8,3,7
+Y,5,6,6,8,9,9,8,6,3,7,7,8,6,10,7,4
+C,3,3,4,2,1,4,8,4,7,10,9,12,1,9,2,7
+G,6,9,5,5,4,8,4,5,2,9,6,9,4,8,7,8
+F,8,15,7,8,5,8,10,3,5,12,5,4,4,9,7,7
+A,3,7,4,5,3,9,4,3,1,8,1,8,2,6,1,8
+Q,3,4,4,5,3,8,7,5,3,8,8,9,3,8,4,9
+U,4,7,6,5,7,7,7,4,4,6,7,8,10,9,5,8
+G,3,4,4,3,2,6,7,5,5,9,7,9,2,9,4,9
+Q,3,4,4,6,2,8,7,8,6,6,7,8,3,8,5,9
+K,5,9,6,5,3,3,9,3,6,9,8,11,4,7,3,6
+C,1,3,2,2,1,6,7,7,6,8,7,13,1,9,3,10
+O,4,5,5,8,3,8,8,9,7,6,7,9,3,8,4,8
+C,5,11,6,9,4,6,8,9,7,10,7,11,2,11,4,9
+W,4,6,6,4,3,9,8,4,1,7,8,8,8,9,0,8
+Z,4,10,5,7,5,7,8,5,9,7,6,9,1,9,7,7
+U,3,1,4,3,2,6,8,6,7,7,9,9,3,9,1,8
+R,3,7,4,5,4,6,9,8,3,7,5,8,2,7,5,11
+C,3,2,4,4,2,6,8,8,8,9,8,12,2,10,4,10
+C,2,1,3,2,1,6,8,7,8,8,8,13,1,9,4,10
+P,6,11,6,8,3,4,13,9,2,10,6,4,1,10,4,8
+N,4,6,7,4,6,7,8,3,4,8,7,7,6,9,5,4
+W,3,3,4,2,2,4,11,3,2,9,9,7,6,11,1,7
+U,6,8,7,6,5,4,8,5,7,9,8,10,5,8,3,4
+K,6,9,9,7,10,7,7,4,4,6,6,9,8,8,8,8
+D,4,8,5,6,4,7,7,5,5,7,6,7,4,8,3,7
+K,1,0,1,0,0,4,6,6,1,7,6,10,3,7,1,10
+M,5,6,8,4,5,7,6,2,5,9,7,8,8,6,2,8
+I,3,11,4,9,2,6,8,0,7,13,7,8,0,8,1,7
+W,4,8,6,6,5,8,8,4,1,6,9,8,7,11,0,8
+Z,3,5,3,3,2,8,7,5,10,6,6,7,2,8,7,8
+B,3,7,3,5,4,6,7,8,5,7,6,7,2,8,7,10
+G,9,14,7,8,5,8,7,5,4,9,5,6,4,9,8,8
+Z,5,5,7,8,3,7,7,4,15,9,6,8,0,8,9,8
+F,4,11,5,8,2,1,11,5,7,12,12,10,0,8,2,6
+T,2,5,3,4,2,7,12,3,6,7,11,8,2,11,1,8
+G,4,3,5,4,3,6,6,5,6,6,6,8,2,8,4,8
+J,3,7,4,5,2,9,6,1,6,13,4,8,0,7,0,8
+A,8,12,8,6,4,11,0,4,3,12,6,14,4,5,5,11
+S,3,10,4,8,5,8,8,8,5,7,5,8,2,8,8,8
+N,5,6,7,4,3,7,8,3,5,10,6,7,5,8,1,7
+J,2,9,3,6,3,11,5,2,6,11,2,7,0,7,1,7
+K,6,11,9,8,8,3,8,1,6,9,9,11,3,8,3,6
+U,4,6,6,6,5,7,6,5,4,6,6,8,4,8,1,7
+S,4,7,6,5,7,6,6,3,2,8,6,7,3,7,11,2
+Y,4,7,6,10,10,7,5,4,3,8,8,9,9,10,8,8
+E,2,1,2,1,2,7,7,5,6,7,6,8,2,8,5,10
+O,5,11,5,8,5,8,7,8,4,9,6,6,4,9,4,8
+V,3,9,5,7,3,7,11,2,3,6,11,9,2,10,1,8
+W,7,10,9,7,6,4,8,5,1,7,9,8,8,10,0,8
+A,3,7,5,5,3,10,2,2,2,9,2,8,2,6,4,8
+I,2,6,4,4,2,7,7,0,8,13,6,8,0,8,1,7
+Z,2,2,2,3,2,7,8,5,9,6,6,9,1,9,7,8
+O,4,7,4,5,3,8,6,6,3,10,5,10,3,8,2,8
+P,4,9,6,7,4,6,10,5,6,10,8,3,1,10,4,7
+X,2,1,4,2,2,7,7,3,9,6,6,8,2,8,5,8
+M,5,10,8,7,10,12,4,3,1,9,4,9,10,6,3,8
+R,1,1,2,1,1,6,9,7,3,7,5,8,2,7,4,11
+M,4,7,7,5,9,8,7,3,3,8,4,7,10,5,2,6
+Z,2,5,3,3,3,8,7,5,9,6,6,7,2,8,7,8
+N,5,5,5,7,3,7,7,15,2,4,6,8,6,8,0,8
+M,5,10,6,8,4,8,7,13,2,6,9,8,8,6,0,8
+L,3,6,4,4,2,5,3,5,8,2,2,4,1,6,1,5
+M,1,0,2,0,1,7,6,9,0,7,8,8,5,6,0,8
+N,4,8,6,6,4,8,6,9,5,4,4,5,4,6,3,8
+W,9,10,8,7,6,5,10,3,3,9,8,7,10,11,4,5
+Y,4,9,5,6,1,7,10,3,2,7,13,8,1,11,0,8
+N,3,6,5,4,3,4,9,3,3,10,10,9,5,8,0,8
+J,3,8,4,6,2,9,5,4,5,15,6,12,1,6,1,7
+L,4,11,6,8,3,4,4,1,10,6,1,11,0,7,3,6
+C,7,11,8,8,4,2,10,5,8,11,11,11,1,8,2,6
+A,4,9,6,7,4,7,5,3,0,6,1,8,2,7,1,7
+F,2,3,2,1,1,5,11,3,5,11,9,5,1,9,3,6
+T,2,7,4,5,1,7,14,0,5,7,10,8,0,8,0,8
+N,2,3,4,2,2,8,9,3,4,10,4,5,5,9,1,7
+I,1,7,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+H,3,2,4,4,3,8,8,6,6,7,6,8,3,8,3,9
+A,3,7,5,6,4,6,8,2,4,7,7,9,5,9,3,7
+R,2,3,3,5,2,6,9,9,4,7,5,7,2,8,5,10
+H,5,8,7,6,7,6,7,6,6,7,6,10,3,8,3,9
+E,4,8,6,6,4,6,8,4,9,11,9,9,2,9,5,5
+Y,3,5,4,3,2,4,10,1,7,10,10,5,2,11,3,4
+L,2,6,3,4,1,0,1,5,6,0,0,6,0,8,0,8
+J,4,7,5,5,2,9,5,3,7,15,4,9,0,7,0,8
+A,1,1,2,1,0,7,4,2,0,7,2,8,2,6,1,8
+U,4,5,5,4,3,4,8,5,7,10,9,9,3,9,2,6
+Y,2,7,4,4,1,9,10,2,3,6,12,8,1,11,0,8
+I,7,12,5,6,2,9,6,5,5,13,3,8,3,7,5,10
+O,6,9,8,8,7,7,5,4,5,9,3,7,4,8,6,9
+T,4,5,5,3,2,6,11,2,8,11,9,4,1,11,3,4
+K,4,8,6,6,4,4,7,6,7,6,6,13,4,7,6,10
+Q,3,6,5,5,3,8,7,7,5,6,6,8,2,8,4,9
+P,2,1,2,1,1,5,11,7,1,9,6,4,1,9,3,8
+P,5,8,8,6,4,6,12,7,2,11,5,2,1,10,4,9
+U,4,4,4,6,2,8,5,14,5,6,13,8,3,9,0,8
+V,5,9,5,6,3,2,11,2,3,10,11,8,2,11,1,8
+O,2,3,2,1,1,8,7,6,4,9,6,8,2,8,3,8
+L,3,2,4,3,2,4,4,5,7,2,2,5,1,6,1,6
+W,6,6,6,4,4,7,11,5,2,8,6,6,7,12,2,6
+I,6,15,4,8,3,11,5,5,4,13,3,8,3,8,5,9
+N,4,4,5,6,2,7,7,15,2,4,6,8,6,8,0,8
+V,6,9,5,4,2,6,11,6,3,11,9,4,4,12,3,9
+K,4,8,6,6,4,5,7,4,8,7,6,10,4,8,5,9
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+I,0,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+H,2,6,3,4,1,7,8,14,1,7,5,8,3,8,0,8
+B,7,9,6,4,5,9,7,3,5,9,4,7,7,5,7,8
+D,8,12,7,6,5,8,6,3,7,10,5,7,6,7,8,6
+A,6,14,6,8,5,11,3,4,2,11,3,11,5,3,4,11
+R,7,10,9,8,11,7,7,3,5,6,6,9,7,9,7,6
+P,3,2,3,3,2,5,11,5,4,10,7,2,1,10,4,6
+L,5,11,7,8,5,9,3,1,8,9,2,10,3,6,5,10
+L,1,0,1,1,0,2,2,5,5,1,1,6,0,8,0,8
+E,2,4,4,3,2,6,7,2,7,11,7,9,2,8,4,8
+M,3,4,4,3,3,8,6,6,4,6,7,8,7,5,2,7
+J,2,6,4,4,1,10,6,2,7,15,4,7,0,7,0,8
+I,4,9,5,7,3,9,6,0,7,13,5,9,0,8,1,8
+H,7,9,10,6,6,6,7,3,7,10,8,9,3,8,3,7
+V,3,8,5,6,1,8,8,4,3,6,14,8,3,10,0,8
+D,3,5,4,3,2,8,7,7,8,6,6,3,2,8,3,7
+D,10,15,9,8,5,7,6,5,6,9,4,5,5,8,6,9
+K,5,6,7,4,5,6,7,1,6,10,6,10,4,8,4,8
+D,5,8,8,6,5,8,8,7,8,10,5,4,3,8,5,8
+L,4,10,5,8,7,8,8,3,5,5,7,9,5,11,9,10
+Y,9,15,8,8,4,7,8,4,4,10,7,5,4,9,5,3
+D,2,1,2,2,1,6,7,9,6,6,6,6,2,8,3,8
+V,6,11,9,8,10,7,5,5,3,8,8,9,9,9,6,8
+X,3,4,6,3,3,6,9,1,8,10,9,8,2,8,3,6
+N,2,3,4,2,1,5,9,3,3,10,8,8,5,8,0,7
+J,1,5,3,4,1,9,6,3,6,14,5,10,0,7,0,7
+P,4,5,6,7,7,6,8,5,3,7,7,6,7,12,6,9
+W,5,9,7,7,7,10,11,2,2,6,8,7,9,13,2,8
+V,4,9,7,7,3,5,12,3,4,8,12,9,2,10,1,8
+F,4,7,6,5,6,7,8,5,4,8,6,9,4,11,9,11
+K,8,10,7,5,3,8,7,3,7,9,7,7,6,10,4,8
+E,3,7,4,5,3,7,7,6,8,7,6,9,3,8,6,8
+T,3,11,5,8,1,6,14,0,6,8,11,8,0,8,0,8
+O,5,9,5,6,4,7,7,8,5,10,6,8,3,8,3,8
+K,7,9,10,7,6,2,8,3,8,11,12,12,5,6,5,3
+R,5,8,7,6,6,8,8,5,5,9,5,8,3,8,5,11
+T,4,8,6,6,5,6,7,6,6,7,9,9,3,10,5,8
+I,2,8,2,6,2,7,7,0,8,7,6,8,0,8,3,8
+D,1,3,2,2,1,9,6,3,4,10,4,6,2,8,2,8
+K,4,4,5,6,2,3,7,8,2,7,6,11,3,8,2,11
+J,1,6,2,4,1,11,3,9,3,13,7,13,1,6,0,8
+U,4,4,5,2,2,4,8,5,7,10,9,9,3,9,2,6
+H,2,4,4,2,2,7,8,3,5,10,6,7,3,8,2,8
+P,7,11,9,8,6,8,9,2,6,14,6,5,3,10,4,9
+K,3,4,6,3,3,6,7,2,7,10,7,10,3,8,3,7
+F,3,7,3,5,2,1,12,4,4,11,10,8,0,8,2,6
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+K,4,8,5,6,2,4,8,9,1,7,6,11,3,8,3,11
+Q,1,0,1,1,0,8,6,7,5,6,6,9,2,7,3,9
+Q,3,4,4,5,3,8,8,6,2,8,7,9,2,9,3,9
+L,4,11,5,8,3,9,2,2,7,9,2,10,1,5,3,9
+I,0,3,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+T,7,13,6,7,4,8,8,3,7,11,5,6,2,8,6,7
+A,4,8,6,6,3,13,3,4,3,11,1,8,2,6,2,9
+G,5,10,6,7,4,6,7,7,7,10,7,11,2,9,5,9
+O,6,9,8,7,5,7,6,8,4,7,5,8,3,8,3,8
+P,2,2,3,3,2,5,10,4,4,9,8,4,1,10,3,7
+N,4,10,6,8,4,8,8,6,5,6,6,6,6,9,2,5
+T,3,1,4,2,1,7,11,2,7,7,11,8,1,10,1,8
+V,5,9,6,7,4,8,11,3,2,5,10,9,5,11,5,8
+H,5,6,7,4,4,10,7,4,6,10,2,7,3,8,3,9
+G,1,0,1,0,0,7,6,6,5,6,5,9,1,7,4,10
+P,4,9,4,7,4,5,10,9,3,9,6,5,1,10,3,8
+D,3,6,5,4,3,9,7,5,7,10,5,4,3,8,3,8
+K,5,6,7,5,6,7,7,2,4,7,3,9,6,4,8,10
+Z,1,0,1,0,0,7,7,2,9,8,6,8,0,8,5,8
+X,4,6,5,4,3,7,8,1,8,10,7,8,3,8,3,7
+K,7,9,9,8,9,10,6,3,5,10,2,8,8,6,7,12
+G,4,7,5,5,5,8,7,6,2,7,6,11,4,8,7,9
+J,4,9,5,7,3,9,6,2,6,14,4,8,0,7,0,8
+Q,9,15,8,8,5,9,4,5,9,11,3,11,3,6,8,11
+M,5,5,8,4,4,10,5,3,5,9,3,7,10,7,3,9
+Q,1,2,2,3,2,8,7,6,2,5,6,10,2,9,4,9
+C,6,9,6,7,3,3,8,5,7,12,10,12,2,9,2,7
+Y,7,11,6,6,3,5,9,4,3,11,10,6,4,10,3,3
+F,3,10,4,7,2,0,13,4,4,12,11,7,0,8,2,6
+U,4,10,4,7,2,7,5,15,5,7,13,8,3,9,0,8
+T,6,9,5,4,2,5,11,3,6,13,7,5,2,8,3,4
+I,6,7,8,8,7,9,8,5,5,7,5,9,3,8,9,7
+F,4,8,4,6,3,2,12,5,6,11,10,8,0,8,2,7
+L,2,3,2,2,1,4,4,4,7,2,2,6,0,7,1,6
+L,3,7,5,6,4,8,5,5,4,6,7,8,3,8,8,11
+G,4,6,6,6,6,8,9,6,3,6,6,9,7,11,6,9
+H,2,4,3,3,3,7,7,5,5,7,6,8,3,8,2,8
+K,8,13,8,7,4,9,7,3,7,9,3,6,5,8,4,8
+C,2,5,3,3,2,6,8,7,8,8,7,13,1,9,4,10
+V,2,7,4,5,1,9,8,4,2,6,13,8,3,10,0,8
+Q,2,2,2,3,2,8,9,5,2,8,8,10,2,9,4,9
+Y,1,0,2,0,0,8,10,3,1,6,12,8,1,11,0,8
+O,2,1,3,2,2,7,8,7,5,7,7,8,2,8,3,8
+Y,8,14,6,8,4,7,8,4,4,9,8,5,4,10,4,4
+X,5,11,7,8,7,8,7,3,5,6,7,6,4,10,11,9
+A,1,0,2,0,0,8,4,2,0,7,2,8,1,6,1,8
+P,6,9,9,7,4,9,9,3,7,14,4,3,2,9,4,9
+L,2,2,3,4,1,3,4,3,8,2,1,7,0,7,1,6
+V,9,12,7,7,3,7,9,6,4,8,9,5,6,13,4,9
+F,2,5,3,4,2,5,11,3,5,11,9,5,1,10,3,6
+E,3,8,5,6,5,7,7,3,6,7,7,10,4,10,8,8
+Z,5,12,6,6,4,9,5,3,8,12,4,9,3,9,5,11
+U,3,3,4,1,1,4,9,5,6,11,10,9,3,10,2,7
+J,2,5,3,4,1,11,6,2,6,11,3,8,1,6,1,7
+F,2,4,4,3,2,6,10,2,6,13,7,5,1,10,1,7
+F,4,6,6,4,5,10,7,1,5,9,5,6,4,10,4,7
+Z,1,3,2,2,1,7,7,5,8,6,6,8,2,8,7,8
+W,3,4,4,3,3,6,10,4,2,8,7,7,6,11,1,6
+J,1,0,1,1,0,12,3,5,3,12,5,11,0,7,0,8
+P,4,9,5,6,3,5,10,10,5,9,6,5,2,10,4,8
+L,0,0,1,0,0,2,2,5,4,1,2,6,0,8,0,8
+C,5,11,6,8,2,5,7,7,10,7,6,14,1,8,4,9
+A,5,8,7,6,6,8,9,7,5,6,6,8,3,7,7,4
+X,6,9,8,8,8,8,7,2,5,7,6,7,4,9,8,8
+Q,6,9,7,11,8,9,10,6,4,3,9,12,4,9,9,14
+A,3,2,6,4,2,10,2,2,2,9,1,8,2,6,2,8
+W,4,4,5,2,3,7,11,3,2,6,9,8,7,11,0,8
+K,4,9,5,6,2,3,8,8,2,7,5,11,4,8,3,10
+F,5,9,7,7,8,10,6,2,4,9,5,6,6,9,5,7
+E,4,8,4,6,3,3,9,6,12,7,5,14,0,8,7,7
+H,7,10,10,8,9,7,8,3,6,10,6,7,3,8,3,8
+G,8,11,7,6,4,7,6,6,5,9,5,6,4,7,5,7
+Y,5,6,6,8,8,9,7,6,3,7,8,8,7,10,6,5
+T,2,3,3,4,1,7,14,0,6,7,11,8,0,8,0,8
+J,2,8,3,6,1,12,2,9,4,14,6,13,1,6,0,8
+T,8,11,8,8,4,4,12,2,8,13,10,5,0,10,2,4
+V,4,10,5,8,3,5,11,3,3,9,12,9,2,10,1,8
+A,5,6,7,5,6,6,6,3,5,7,8,10,8,11,3,8
+V,5,9,4,4,2,9,9,5,4,5,10,6,4,11,3,5
+M,3,7,5,5,5,9,6,6,4,6,7,6,7,5,2,6
+U,5,10,6,8,5,6,8,8,5,5,6,12,5,9,7,3
+D,5,10,7,8,6,6,7,8,7,7,7,5,4,7,4,9
+Q,6,9,6,10,6,8,6,7,4,9,6,10,4,10,7,6
+X,4,6,6,4,3,7,7,1,8,10,7,9,3,8,3,7
+H,3,9,4,7,4,8,9,13,2,7,4,8,3,8,0,8
+V,1,0,2,0,0,8,9,3,1,6,12,8,2,11,0,8
+G,4,6,4,4,3,6,7,5,6,9,8,10,2,9,4,9
+F,3,4,3,6,1,0,11,4,7,12,12,9,0,8,2,6
+H,6,7,9,10,8,7,11,5,1,8,7,5,4,12,10,4
+U,6,10,6,6,4,7,6,5,5,7,8,9,5,8,3,8
+W,4,4,5,2,3,4,11,3,2,10,9,8,6,11,1,6
+H,4,10,4,7,2,7,7,15,1,7,7,8,3,8,0,8
+M,6,10,8,8,7,6,7,3,5,9,9,9,8,6,2,7
+U,10,14,9,8,5,6,6,5,5,6,8,9,7,7,4,9
+E,3,3,3,5,2,3,9,6,11,7,5,14,0,8,7,8
+Z,6,6,5,9,4,7,8,5,3,11,7,7,2,9,9,7
+U,2,5,4,4,3,7,7,4,3,6,7,8,3,8,1,7
+U,3,6,4,4,1,7,5,13,5,7,14,8,3,9,0,8
+Y,3,6,5,4,2,10,11,2,7,3,11,8,1,11,1,9
+T,1,0,1,0,0,7,14,1,4,7,10,8,0,8,0,8
+D,6,11,6,8,4,6,7,11,11,6,5,6,3,8,4,8
+I,1,4,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+M,2,0,3,1,1,7,6,10,0,7,9,8,7,6,0,8
+I,1,8,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+I,3,10,4,8,2,7,7,0,8,13,6,8,0,8,1,7
+E,2,3,3,2,1,6,8,1,7,11,6,9,2,8,3,8
+Q,8,13,8,7,5,12,4,3,6,10,3,7,3,9,6,13
+W,2,0,2,0,1,7,8,4,0,7,8,8,6,9,0,8
+H,7,9,10,7,8,6,8,2,6,10,7,8,5,9,4,8
+I,2,5,3,3,1,7,8,1,8,14,6,7,0,8,1,7
+Q,4,6,5,9,6,8,13,4,3,4,8,12,4,14,7,13
+D,3,6,5,4,3,7,7,8,7,7,6,5,3,8,3,7
+Q,6,10,8,8,7,7,4,8,4,6,7,10,5,7,7,9
+C,3,8,4,6,2,6,8,8,7,10,8,13,2,10,4,10
+V,5,7,5,5,2,3,11,4,3,10,12,7,2,10,1,8
+D,3,6,4,4,3,5,8,8,7,8,7,6,2,8,3,8
+J,4,10,6,7,6,10,8,3,4,8,3,6,4,8,7,7
+N,3,6,4,4,3,7,7,12,1,7,6,8,5,9,0,8
+V,3,3,4,2,1,4,12,3,2,10,11,7,2,11,1,8
+U,5,7,5,5,3,3,9,5,6,11,11,9,3,9,1,6
+S,2,6,3,4,2,8,7,7,7,7,7,9,2,10,9,8
+A,3,7,5,5,3,11,2,3,2,10,2,9,3,7,3,9
+W,7,7,9,6,10,7,7,5,5,7,6,8,9,9,9,8
+F,4,11,6,8,4,5,11,4,6,11,10,5,2,10,3,5
+N,2,1,2,1,1,7,7,11,1,5,6,8,4,8,0,8
+N,2,4,3,3,2,7,8,5,4,7,6,6,4,8,1,6
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+P,4,6,5,4,4,6,7,6,4,7,6,8,2,9,7,10
+T,2,7,3,4,1,7,14,0,6,7,11,8,0,8,0,8
+D,6,9,9,8,8,6,7,5,7,7,4,7,4,6,6,5
+R,5,8,7,6,7,8,6,7,3,8,6,8,6,6,6,11
+E,5,9,5,7,3,3,8,6,11,7,6,15,0,8,7,7
+Z,7,10,9,8,6,7,8,2,9,12,7,7,1,8,6,8
+F,1,0,1,0,0,3,11,4,3,11,9,7,0,8,2,8
+P,4,7,5,5,3,7,10,6,4,11,5,4,1,10,3,8
+T,7,15,6,8,3,6,9,3,8,13,6,6,2,8,5,4
+P,3,10,4,8,4,3,12,7,2,11,8,4,0,10,3,8
+K,3,7,4,5,1,3,7,7,2,7,7,11,3,8,3,10
+E,3,6,4,4,2,5,9,4,8,12,9,8,2,9,5,5
+W,10,11,10,8,8,2,11,2,3,10,11,9,7,10,2,6
+Z,4,9,4,7,2,7,7,4,14,9,6,8,0,8,8,8
+B,4,5,5,8,4,6,9,9,7,8,5,6,2,8,9,10
+R,3,7,4,5,4,7,9,6,5,8,5,9,3,6,5,10
+Y,9,8,7,12,5,8,5,5,5,5,12,6,5,10,4,7
+Z,5,10,6,8,5,7,8,3,12,9,6,8,0,8,8,7
+Z,2,5,4,4,2,7,8,2,10,11,6,7,1,8,6,7
+I,2,10,2,8,3,7,7,0,7,7,6,8,0,8,3,8
+Z,4,8,5,6,5,8,8,3,7,7,6,7,1,9,10,8
+L,2,3,3,2,1,5,4,5,8,3,2,6,1,7,1,6
+E,3,5,3,4,3,7,8,5,8,7,5,9,2,8,6,9
+K,3,9,4,7,2,3,7,7,3,7,7,11,3,8,3,10
+G,3,7,4,5,3,6,6,5,4,6,6,9,2,9,4,8
+P,4,9,6,6,3,9,9,2,6,14,5,4,1,10,3,10
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+P,7,10,7,5,4,8,9,4,3,12,5,4,4,11,5,6
+K,6,11,8,8,5,6,7,2,7,10,7,10,3,8,3,8
+V,4,8,6,6,1,6,8,5,3,8,14,8,3,9,0,8
+T,3,4,3,3,1,5,13,3,5,11,9,3,1,11,1,5
+Q,2,2,3,4,3,8,8,6,2,5,7,9,3,9,5,9
+R,5,8,7,6,5,10,6,3,5,10,3,7,3,7,4,10
+P,6,7,8,10,9,7,9,4,2,7,8,7,6,11,6,5
+N,7,12,7,6,3,8,10,5,4,4,6,9,6,10,3,6
+B,4,9,5,6,5,7,8,7,4,7,5,6,4,7,6,6
+N,3,5,5,4,2,7,8,3,5,10,6,7,5,8,1,7
+R,5,11,6,8,7,6,8,9,5,6,5,8,2,8,8,9
+C,5,5,6,8,2,6,7,7,10,7,6,15,1,8,4,9
+M,4,7,4,5,3,7,7,12,1,7,9,8,8,6,0,8
+H,5,8,8,6,5,6,8,4,7,10,9,9,4,9,4,6
+Q,4,8,5,8,3,8,7,8,6,6,7,8,3,8,5,9
+Q,3,5,5,8,3,7,5,9,6,6,4,8,3,8,4,8
+S,4,7,5,5,4,7,7,5,8,5,6,9,0,9,9,8
+J,4,9,5,7,2,10,6,2,8,14,3,8,0,7,0,8
+R,5,10,5,8,6,6,9,9,4,6,5,7,3,8,5,11
+F,5,8,6,10,8,7,9,5,5,7,6,7,4,9,9,7
+P,1,0,1,0,0,5,11,6,1,9,6,5,0,9,3,8
+I,1,11,0,8,1,7,7,5,3,7,6,8,0,8,0,8
+I,3,11,6,8,7,11,6,1,6,8,4,5,3,8,5,9
+S,2,7,3,5,3,8,8,8,6,8,4,6,2,6,8,8
+Q,5,6,6,8,5,8,6,8,4,5,6,9,3,8,6,10
+V,7,11,6,6,3,9,8,6,4,7,10,7,7,12,3,8
+A,3,8,6,6,3,11,2,2,2,9,2,9,3,7,3,9
+Q,4,5,5,8,3,8,7,8,6,5,6,8,3,8,5,9
+J,0,0,1,1,0,12,4,5,3,12,4,11,0,7,0,8
+U,2,0,2,1,0,8,5,11,4,7,13,8,3,10,0,8
+G,4,7,6,5,5,7,8,5,3,6,6,11,4,8,7,8
+H,4,2,5,4,4,8,7,6,6,7,6,8,3,8,3,9
+K,5,11,7,8,8,5,7,5,4,7,5,8,4,6,10,8
+B,3,4,5,3,3,8,7,2,6,11,5,7,2,8,4,9
+O,6,10,9,8,10,8,7,5,1,7,6,8,9,9,7,11
+B,3,5,5,3,3,8,7,2,6,10,5,7,2,8,4,10
+H,3,6,4,4,3,7,6,12,1,7,7,8,3,8,0,8
+H,5,11,8,8,9,8,8,6,7,7,5,8,3,8,4,7
+J,0,0,1,1,0,12,4,5,3,12,4,11,0,7,0,8
+K,3,6,4,4,3,5,7,4,8,6,6,11,3,8,6,9
+E,3,8,5,6,6,5,7,3,7,8,7,12,4,9,8,8
+R,10,11,8,6,4,10,5,5,5,10,3,8,6,6,6,11
+F,4,9,5,7,4,4,11,4,6,11,10,6,2,10,3,5
+I,4,6,5,7,5,8,9,4,5,8,7,8,4,7,8,7
+B,4,10,6,7,7,8,6,4,4,6,5,7,4,9,5,8
+Q,4,5,5,7,5,9,11,6,2,3,7,12,3,10,5,10
+G,4,9,5,7,2,7,6,8,9,7,5,11,1,8,5,10
+A,5,10,7,8,5,8,4,3,0,7,1,8,2,7,4,8
+B,2,3,3,2,2,8,7,3,5,10,6,7,2,8,4,9
+Y,2,1,3,1,0,7,10,3,1,7,12,8,1,11,0,8
+A,3,5,5,3,2,11,2,2,2,9,2,9,2,6,2,8
+V,8,11,8,6,4,7,10,4,5,8,9,6,5,11,3,7
+Z,6,10,9,7,5,5,10,4,10,11,10,6,1,9,6,5
+W,11,12,10,6,4,4,10,2,3,9,11,8,9,12,1,6
+H,5,6,7,4,4,7,7,3,7,10,7,9,3,8,3,7
+H,4,5,5,4,4,7,7,6,6,7,6,8,3,8,3,7
+G,2,4,3,3,2,6,7,5,5,9,7,10,2,9,4,9
+Z,4,6,5,4,4,9,9,5,4,6,5,7,3,8,8,4
+N,5,11,6,9,3,7,7,15,2,4,6,8,6,8,0,8
+S,5,9,6,6,4,6,7,4,7,10,10,9,2,9,5,5
+B,7,15,7,8,6,10,6,4,5,10,4,7,7,6,8,9
+Q,5,7,6,6,5,9,3,4,4,8,3,10,3,6,6,7
+Z,5,11,7,8,5,7,7,3,13,9,6,8,0,8,8,8
+Q,2,3,2,3,2,8,8,5,1,8,7,9,2,9,4,8
+M,6,10,7,8,7,8,5,11,0,7,9,8,10,5,3,7
+G,7,11,7,8,5,7,6,7,7,10,7,13,3,8,5,7
+Y,4,6,6,8,8,9,6,6,3,7,8,8,6,10,6,4
+A,2,7,4,5,2,8,3,2,2,7,1,8,2,6,2,7
+J,2,6,2,4,1,13,2,7,4,13,4,12,0,7,0,8
+J,2,8,2,6,1,15,3,4,5,12,1,8,0,7,0,8
+E,8,12,5,6,3,8,6,5,7,11,6,9,2,10,8,9
+D,5,11,7,8,8,7,7,4,8,6,6,6,3,8,3,7
+Z,4,7,4,5,3,7,7,5,11,7,6,9,1,8,8,8
+N,2,2,3,4,2,7,8,5,4,7,7,7,5,9,2,6
+O,4,8,5,6,4,7,7,7,4,10,6,8,3,8,3,8
+E,2,1,2,1,1,4,8,5,8,7,6,13,0,8,7,9
+G,2,2,3,3,2,7,6,6,5,6,6,10,2,9,4,9
+O,8,9,5,5,3,7,9,6,5,9,5,6,4,9,5,8
+G,4,7,4,5,3,6,7,6,7,9,8,9,2,10,4,9
+T,7,9,6,5,2,8,8,4,8,13,5,7,2,8,5,6
+Y,5,8,5,6,4,4,9,1,6,9,10,7,3,11,4,4
+G,4,7,6,5,3,5,5,5,7,6,5,9,2,10,4,7
+T,6,8,6,6,4,6,12,4,6,11,9,4,3,12,3,4
+A,1,1,2,1,0,7,4,2,0,6,2,8,2,7,1,8
+O,5,11,6,8,9,8,10,5,2,7,7,8,8,9,5,10
+A,3,9,5,7,4,12,2,3,3,10,2,9,3,8,4,9
+M,2,0,2,1,1,7,6,10,0,7,8,8,6,6,0,8
+O,4,7,4,5,3,7,7,7,5,10,6,8,3,8,3,8
+T,3,4,4,3,2,5,12,3,6,11,9,4,1,11,1,5
+X,3,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+K,6,9,7,4,3,5,8,3,5,9,9,10,5,10,3,6
+D,4,8,6,6,5,8,8,5,6,10,5,4,3,8,4,8
+X,5,9,8,7,7,6,7,3,6,8,8,11,6,6,8,6
+B,6,9,8,7,6,9,6,4,7,9,5,7,3,8,6,10
+F,7,12,6,6,3,6,8,2,7,10,7,6,2,10,5,6
+A,5,11,7,9,5,8,3,3,1,7,2,8,5,8,5,10
+D,4,9,4,4,3,7,8,4,7,10,5,6,4,8,5,6
+C,6,10,6,7,3,4,8,6,8,12,10,12,1,9,3,7
+E,4,7,6,5,5,8,7,6,3,7,6,10,4,8,8,9
+E,3,9,4,7,2,3,8,6,11,7,5,15,0,8,7,7
+B,4,4,5,6,4,6,8,9,7,7,5,7,2,8,9,9
+Y,5,10,5,7,3,3,10,2,8,11,11,6,0,10,2,4
+D,2,5,4,3,3,9,6,4,6,10,4,6,2,8,3,8
+E,4,6,5,4,5,7,9,5,4,6,6,9,4,7,7,7
+N,10,14,12,8,5,12,5,3,4,13,1,6,6,7,0,8
+V,8,10,8,8,4,2,13,5,4,11,12,7,3,9,2,7
+Q,4,8,5,9,5,8,9,6,2,6,8,12,3,10,6,8
+Y,3,7,5,5,2,4,9,1,7,10,12,9,1,10,2,7
+W,12,15,11,8,5,6,10,2,3,7,10,7,10,12,1,6
+U,8,9,9,7,6,4,7,5,8,9,7,9,6,8,4,3
+M,3,1,3,1,1,8,6,11,0,7,9,8,7,6,0,8
+Z,3,7,4,5,2,7,7,4,13,9,6,8,0,8,8,8
+E,3,6,5,4,3,5,9,5,8,11,10,8,3,8,4,4
+W,3,1,4,2,1,7,8,4,0,7,8,8,7,9,0,8
+O,5,9,4,4,2,9,7,5,4,9,4,8,4,9,5,8
+T,5,10,7,7,6,6,7,7,7,7,6,8,4,11,7,8
+X,3,7,5,5,3,5,8,1,7,10,10,9,2,9,3,6
+F,5,9,7,6,4,10,7,2,6,13,4,6,6,9,5,9
+L,1,4,3,3,1,6,5,2,9,7,2,10,0,7,3,7
+M,5,2,7,4,5,8,6,6,5,6,7,7,10,6,3,6
+P,8,9,6,4,3,8,8,5,4,12,3,6,5,9,4,8
+W,6,10,7,5,4,7,8,3,4,6,9,6,9,9,2,6
+E,3,9,4,7,4,6,7,7,9,8,8,10,3,8,6,8
+U,6,8,7,6,3,3,9,5,8,11,11,9,3,9,2,6
+I,3,7,5,5,5,9,7,2,4,8,5,5,3,9,5,6
+H,5,7,8,5,4,8,7,3,6,10,4,7,3,8,3,8
+E,4,11,5,8,5,2,8,5,10,7,5,14,0,8,6,9
+D,4,9,5,7,3,5,7,10,9,6,5,6,3,8,4,8
+Q,1,2,2,3,2,8,7,6,2,6,6,9,2,9,3,10
+R,6,11,6,8,4,5,13,8,4,7,3,9,3,7,7,11
+M,2,1,2,1,1,8,6,10,0,6,9,8,6,6,0,8
+B,5,10,8,8,11,8,7,5,3,6,7,7,7,10,9,9
+M,2,4,3,3,3,8,6,6,4,6,7,6,6,6,2,6
+Y,7,8,7,6,3,2,12,4,6,13,11,5,1,11,1,5
+G,5,9,4,4,3,8,6,5,2,9,6,8,3,10,7,8
+Y,2,3,3,2,1,4,10,2,7,10,10,5,1,11,2,4
+U,4,4,5,3,2,4,8,5,7,11,10,9,3,9,1,7
+O,1,0,2,0,0,7,7,6,4,7,6,8,2,8,3,8
+K,4,7,6,5,4,6,7,1,6,10,7,10,3,8,3,8
+X,2,2,4,3,2,8,7,3,9,6,6,8,3,8,6,8
+X,2,1,3,3,2,7,8,3,8,6,6,7,2,8,6,7
+C,2,1,2,2,1,6,8,7,6,9,7,11,2,10,4,10
+U,6,10,7,7,4,3,8,5,7,10,9,9,3,9,2,6
+X,4,8,7,6,6,8,7,2,6,7,6,7,5,7,7,8
+N,5,5,6,7,3,7,7,15,2,4,6,8,6,8,0,8
+M,4,7,5,5,6,7,7,7,4,6,5,8,6,9,7,8
+D,3,6,5,4,4,7,7,6,6,6,5,5,3,8,3,7
+E,4,7,6,5,4,5,9,2,8,11,7,9,3,9,5,7
+R,4,8,5,6,4,8,8,5,7,6,4,7,3,6,5,8
+A,4,8,6,6,4,9,5,3,0,8,1,8,2,7,1,8
+U,5,10,6,8,4,5,8,7,7,8,10,10,3,9,1,8
+Z,4,4,5,7,2,7,7,4,15,9,6,8,0,8,8,8
+I,2,10,3,7,2,9,7,0,7,13,5,8,0,8,1,8
+H,2,1,3,1,2,6,7,5,6,7,6,8,5,8,3,8
+F,5,7,6,8,7,7,9,4,4,7,6,7,4,9,9,8
+K,5,10,5,8,4,4,7,7,3,7,6,12,3,8,3,11
+R,4,7,4,5,4,6,9,8,3,7,5,8,2,7,5,11
+P,2,3,4,2,2,7,10,3,4,12,4,3,1,10,2,8
+H,8,11,12,8,10,9,6,3,7,10,5,8,6,8,5,8
+Q,6,6,8,6,6,8,3,4,5,7,3,9,5,5,6,8
+G,7,10,6,6,3,7,6,6,5,10,5,7,4,7,5,7
+D,6,7,8,6,8,7,6,5,6,7,5,9,5,6,8,3
+B,6,10,8,8,9,8,6,5,6,9,5,7,4,9,7,10
+F,4,9,4,6,2,1,14,5,3,12,9,4,0,8,3,6
+U,3,7,4,5,3,7,5,12,4,7,11,8,3,9,0,8
+K,3,4,6,3,3,7,7,1,6,10,5,9,4,7,4,8
+R,3,7,4,4,2,5,11,8,3,7,3,9,3,7,5,11
+X,5,9,7,8,8,8,7,2,4,8,6,8,4,10,8,6
+W,3,6,5,4,3,7,10,2,2,7,9,8,6,11,0,8
+N,4,7,6,5,4,7,9,6,5,7,6,6,5,9,1,6
+W,1,0,2,0,1,8,8,4,0,7,8,8,5,10,0,8
+K,5,8,7,6,5,4,7,2,6,10,10,11,3,8,3,6
+E,2,3,4,2,2,7,7,2,7,11,6,9,2,8,4,8
+E,2,3,3,2,2,7,7,5,7,7,6,8,2,8,5,10
+A,3,8,6,6,3,12,2,2,2,10,2,9,2,6,2,8
+R,2,1,3,2,2,7,8,5,5,7,5,6,2,7,4,8
+S,2,3,4,2,1,9,6,3,7,10,4,8,1,8,5,10
+P,6,10,5,5,2,6,10,6,5,14,5,5,3,9,4,8
+F,1,1,2,1,0,3,12,4,3,11,9,6,0,8,2,7
+G,5,7,5,5,4,6,8,5,5,9,8,8,2,8,4,9
+O,4,7,5,5,4,7,7,7,4,8,5,10,4,8,3,7
+X,5,8,7,7,7,9,8,3,5,8,5,6,3,6,8,8
+B,5,11,7,8,8,7,6,8,6,6,6,6,3,8,8,11
+Z,1,0,1,1,0,7,7,2,10,8,6,8,0,8,6,8
+M,3,3,3,4,2,8,6,11,1,6,9,8,7,6,0,8
+N,1,3,3,2,1,6,8,3,3,10,7,8,4,8,0,7
+B,3,2,4,4,3,7,7,5,5,6,6,5,2,8,6,10
+V,4,7,6,6,7,6,7,5,4,7,6,8,6,9,7,10
+J,4,11,5,8,3,11,5,4,7,12,2,9,1,6,2,6
+D,5,10,7,8,7,9,7,6,6,8,5,5,5,9,4,10
+V,5,8,5,6,2,4,12,4,4,10,12,7,3,10,1,8
+G,6,11,6,8,5,5,6,5,5,9,8,11,2,9,4,9
+G,7,14,6,8,5,7,7,5,4,9,5,6,4,9,9,8
+Q,3,6,4,7,4,9,8,7,2,5,7,10,3,9,5,9
+C,4,5,5,5,4,6,8,3,5,6,6,11,4,9,7,9
+F,9,14,8,8,6,7,11,3,4,12,6,4,6,8,9,5
+D,6,11,9,8,8,8,8,5,6,10,6,5,6,9,6,11
+H,6,9,8,7,7,6,7,5,5,7,6,8,6,7,7,11
+M,5,8,8,6,5,3,7,4,5,11,12,11,6,9,3,7
+L,3,2,4,3,2,5,4,5,7,2,2,5,1,7,1,6
+S,5,9,7,8,8,9,8,4,5,7,6,8,5,10,9,11
+P,5,11,5,8,3,5,10,10,4,9,6,5,2,10,4,8
+Y,7,10,6,5,4,7,6,4,4,9,8,5,3,10,4,4
+S,5,7,6,5,4,9,7,4,7,10,3,7,2,7,5,10
+Q,3,5,4,6,4,9,10,6,2,4,7,11,2,9,5,10
+T,2,4,3,5,1,5,14,1,6,9,11,7,0,8,0,8
+Y,4,11,7,8,4,7,10,1,7,6,12,9,1,11,2,8
+M,3,7,4,5,3,8,7,11,1,6,9,8,8,6,0,8
+O,4,8,5,6,2,7,7,8,7,7,6,8,3,8,4,8
+X,4,9,6,7,3,6,8,1,8,10,9,8,3,8,4,7
+N,6,11,8,8,8,5,9,3,4,9,8,9,9,8,7,3
+B,4,8,6,6,6,8,7,4,5,9,5,6,3,8,6,9
+E,2,3,4,2,2,8,6,1,7,11,5,9,2,8,4,10
+H,3,7,4,5,2,7,9,14,2,7,3,8,3,8,0,8
+X,5,9,8,7,4,5,8,2,8,11,11,9,3,9,4,6
+K,4,8,4,6,2,3,7,8,2,7,6,11,4,8,2,11
+O,4,9,5,7,5,8,6,7,3,10,5,9,3,8,3,7
+Y,4,6,6,9,7,9,10,6,3,7,7,7,6,11,6,5
+C,6,10,7,8,4,6,8,7,8,13,8,10,2,11,3,7
+W,6,9,8,6,7,7,7,6,3,5,8,9,11,8,6,4
+U,5,5,6,8,2,8,4,14,6,6,14,8,3,9,0,8
+F,6,10,8,7,8,8,8,6,4,8,6,7,5,11,9,11
+C,1,0,1,1,0,7,7,5,7,7,6,13,0,8,4,10
+O,5,9,6,7,5,8,7,8,7,7,6,8,3,8,4,8
+X,3,7,4,5,2,7,7,4,4,7,6,8,2,8,4,8
+E,4,6,6,4,5,7,9,5,3,6,6,8,4,8,6,7
+U,5,8,8,6,4,7,8,6,9,5,9,8,3,9,1,8
+Q,4,7,5,7,3,8,7,8,6,6,7,9,3,8,5,9
+R,5,11,7,8,6,7,7,4,8,7,6,6,3,8,5,8
+P,6,12,6,7,4,6,10,3,5,13,6,3,3,10,5,6
+S,3,9,4,7,4,8,8,5,7,5,5,6,0,8,8,8
+Z,2,4,5,3,2,7,8,2,9,11,7,6,1,8,5,7
+K,7,12,7,7,4,5,8,3,5,10,9,11,5,9,3,7
+R,6,9,8,7,8,9,5,7,4,7,5,7,6,7,8,9
+P,5,10,8,8,5,8,9,5,5,12,4,3,2,10,4,8
+D,3,5,4,7,2,5,6,11,7,5,5,5,3,8,4,8
+D,7,9,9,8,9,6,7,5,7,6,3,7,5,10,9,5
+Q,2,2,2,2,1,7,8,5,2,7,8,10,2,9,4,8
+L,4,11,6,9,5,8,4,0,8,9,3,10,2,5,3,9
+N,6,10,8,7,5,8,9,2,5,9,4,6,5,9,1,7
+V,3,6,5,4,2,7,12,3,4,8,12,8,3,10,1,8
+A,1,1,2,1,0,7,4,2,0,7,2,8,2,7,1,8
+S,6,10,5,5,2,8,4,5,4,9,3,8,4,6,5,9
+R,6,10,6,8,4,6,10,10,5,7,5,8,3,8,6,10
+D,5,10,7,8,7,7,8,7,5,8,7,7,7,8,3,7
+T,4,10,6,8,5,6,7,8,7,8,8,7,3,10,6,10
+V,4,6,5,5,6,8,7,5,4,7,6,9,6,8,8,4
+E,6,11,8,8,5,4,10,4,9,11,10,9,2,8,5,4
+C,4,10,6,8,4,4,9,5,6,5,7,14,4,8,5,7
+W,6,10,9,8,8,5,12,2,2,8,8,9,9,14,2,8
+V,1,3,2,1,1,6,12,2,3,8,11,8,2,11,0,8
+H,2,7,3,4,2,7,6,14,2,7,8,8,3,8,0,8
+J,2,8,3,6,1,13,3,9,4,13,4,12,1,6,0,8
+B,4,7,4,5,3,6,7,9,7,7,6,7,2,8,8,9
+N,5,8,8,6,3,3,9,4,4,11,11,10,5,8,1,7
+I,0,6,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+L,5,11,5,6,3,7,4,3,5,11,7,12,3,7,6,8
+Z,5,8,7,10,7,11,5,5,4,9,3,8,3,6,6,9
+K,10,12,10,7,4,9,8,4,8,9,1,5,5,6,3,9
+Z,3,6,4,4,3,7,8,5,10,7,7,9,1,9,7,8
+N,6,7,8,5,4,11,7,3,6,10,1,4,5,9,1,7
+I,2,6,3,4,1,7,7,0,7,13,6,8,0,8,1,8
+M,2,0,2,1,1,7,6,10,0,7,8,8,6,6,0,8
+Z,3,7,4,5,2,7,7,4,14,9,6,8,0,8,8,8
+X,10,12,9,6,4,10,6,3,8,10,4,7,4,12,4,9
+O,4,9,3,5,3,6,8,6,4,9,7,9,5,9,4,8
+T,2,4,4,6,1,7,14,0,6,7,11,8,0,8,0,8
+Z,4,7,6,5,3,7,7,2,10,12,6,8,1,9,6,8
+P,5,10,7,8,6,6,6,6,4,7,6,9,5,8,7,10
+M,7,11,8,8,4,7,7,13,2,7,10,8,9,6,0,8
+I,1,10,0,8,1,7,7,5,3,7,6,8,0,8,0,8
+Y,2,3,2,2,1,4,11,3,5,11,10,5,1,11,2,6
+G,6,6,7,8,3,8,5,8,9,6,5,10,2,8,6,11
+N,5,10,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+N,3,5,6,4,3,9,8,3,5,10,3,5,5,9,1,8
+D,5,11,6,8,4,5,7,10,10,6,5,6,3,8,4,8
+D,4,7,4,5,2,5,7,10,8,7,6,5,3,8,4,8
+T,2,9,4,6,1,7,14,0,6,7,11,8,0,8,0,8
+L,2,5,4,3,2,7,3,2,8,8,2,9,1,7,3,8
+G,3,6,4,4,3,6,7,5,5,10,8,10,2,9,4,9
+O,5,8,7,6,8,8,6,5,2,7,5,8,9,9,5,11
+R,5,10,5,7,3,5,10,9,4,7,4,8,3,7,6,11
+S,6,13,5,7,3,10,4,5,5,10,3,10,4,5,4,10
+X,3,1,4,2,2,7,7,3,9,6,6,8,3,8,6,8
+L,1,3,2,1,1,7,3,1,6,9,3,10,0,7,2,9
+W,6,6,6,4,4,2,11,2,2,10,10,8,6,11,1,7
+J,0,0,1,1,0,12,4,5,3,12,4,10,0,7,0,8
+F,3,7,5,5,2,5,12,4,6,12,9,4,1,10,3,4
+F,2,5,3,4,2,5,10,4,5,10,9,5,2,10,3,6
+C,2,4,3,3,1,6,8,7,8,8,7,14,1,9,4,10
+C,2,7,3,5,2,5,8,7,7,8,8,13,2,9,4,10
+U,5,9,5,7,2,7,4,14,5,7,14,8,3,9,0,8
+V,8,11,7,8,4,3,11,3,4,10,12,8,3,10,1,7
+L,2,5,4,4,2,6,4,1,8,8,2,10,0,7,2,8
+X,2,3,3,2,2,7,8,3,8,6,6,7,2,8,5,7
+V,4,6,6,5,6,7,7,4,4,7,6,8,6,10,7,7
+G,7,8,9,7,10,7,6,5,4,7,7,9,8,10,9,7
+D,6,10,6,5,4,9,6,3,7,10,4,7,5,7,8,7
+L,4,9,4,7,2,0,2,4,6,1,0,8,0,8,0,8
+P,1,0,1,1,0,5,10,6,1,9,6,4,1,9,2,8
+X,3,4,5,3,2,9,6,1,8,10,4,7,2,8,3,8
+C,8,12,6,6,2,5,11,5,8,11,8,9,1,7,5,8
+M,6,10,7,8,4,7,7,13,2,7,9,8,9,6,0,8
+Y,3,6,4,4,1,5,11,2,2,8,12,8,1,11,0,8
+R,6,11,9,8,9,6,8,5,6,6,5,8,3,7,5,9
+A,3,8,5,5,2,9,6,3,1,8,0,8,2,7,1,8
+Q,4,3,5,5,4,8,8,6,2,5,7,10,3,9,6,9
+M,3,3,4,1,2,8,6,6,4,6,7,8,6,5,2,7
+U,5,5,6,3,3,4,8,5,8,10,9,9,3,9,2,6
+T,6,9,6,6,5,6,11,4,6,11,9,5,3,12,2,4
+J,2,8,3,6,1,13,2,8,4,13,4,12,1,6,0,8
+M,4,7,6,5,5,9,7,2,4,9,6,7,7,5,2,7
+O,4,11,5,8,3,8,8,9,7,7,8,8,3,8,4,8
+U,5,9,6,7,6,8,6,8,5,7,6,9,3,8,4,6
+E,7,10,9,8,8,7,4,6,4,7,6,9,5,9,9,8
+N,4,5,6,5,5,7,8,5,4,7,5,7,6,9,5,3
+L,3,7,4,5,2,6,4,1,9,8,2,11,0,7,2,8
+Y,4,9,6,7,3,8,10,1,8,5,12,8,1,11,2,8
+Z,5,9,7,7,5,9,6,2,9,11,4,9,3,7,7,9
+W,9,11,9,6,5,5,8,2,4,7,9,7,10,10,2,5
+K,2,3,4,1,1,4,9,2,6,10,9,10,3,8,2,7
+Q,1,0,1,0,0,8,7,6,3,6,6,8,2,8,3,8
+C,2,3,3,4,1,5,8,6,8,7,7,12,1,7,4,9
+R,2,3,2,2,2,6,8,4,4,7,5,7,2,7,3,8
+T,3,4,3,3,1,5,11,3,7,11,9,5,1,11,2,5
+Y,3,5,4,4,2,4,11,2,7,11,10,6,1,11,2,5
+Z,3,5,5,4,2,8,7,2,10,12,5,9,1,8,6,9
+Z,3,4,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+M,4,3,4,4,2,7,7,12,1,7,9,8,8,6,0,8
+I,1,3,2,2,1,7,8,1,7,13,6,8,0,8,1,7
+O,4,10,5,8,5,8,8,8,5,6,8,9,3,8,3,7
+E,2,1,3,2,2,7,7,5,7,7,6,8,2,8,5,10
+Y,5,9,5,4,3,6,6,5,4,9,10,6,3,9,2,5
+E,2,3,4,2,2,7,7,1,8,11,6,9,1,8,4,8
+Q,7,10,6,5,3,10,4,4,7,12,3,11,3,7,7,11
+R,2,2,3,4,3,7,7,5,6,7,6,7,3,7,5,8
+T,7,10,7,8,5,5,11,3,6,11,10,5,2,12,2,4
+E,4,9,6,7,6,7,7,5,8,7,7,9,3,8,5,9
+V,2,0,3,1,0,7,9,4,2,7,13,8,2,10,0,8
+U,3,4,4,3,2,4,8,5,6,11,10,9,3,9,1,7
+T,4,7,5,5,4,7,7,7,6,6,7,9,3,10,6,7
+G,3,6,5,5,5,7,8,5,2,7,7,8,6,11,7,7
+D,3,7,4,5,2,5,7,10,8,7,6,5,3,8,4,8
+W,4,4,5,3,2,4,10,3,2,9,9,7,6,11,1,7
+N,5,5,5,8,3,7,7,15,2,4,6,8,6,8,0,8
+M,4,4,7,3,4,7,5,3,4,10,8,9,7,5,2,8
+R,5,7,7,5,4,8,9,4,6,8,4,8,3,6,5,11
+Y,4,10,7,8,3,4,10,2,8,10,12,9,1,10,2,7
+T,5,7,5,5,3,7,11,3,8,11,9,4,2,12,3,5
+M,8,12,10,7,5,9,4,3,2,10,2,9,10,1,1,8
+R,4,9,4,6,4,6,10,8,3,7,4,8,2,7,5,11
+Y,3,7,4,5,4,9,8,6,4,5,9,7,2,8,7,5
+J,3,6,5,4,1,7,8,2,8,15,6,8,0,7,0,7
+T,2,3,3,2,1,5,12,3,6,11,9,5,1,10,1,5
+P,2,2,3,4,2,5,10,4,4,10,8,4,1,10,3,7
+D,5,5,6,5,5,7,7,4,6,7,4,8,4,7,5,6
+K,4,10,6,8,6,5,7,4,7,6,6,11,3,8,6,9
+V,5,10,7,8,4,9,9,4,2,5,13,8,4,9,1,7
+V,5,10,5,8,3,3,11,5,4,12,12,8,2,10,1,8
+V,5,9,5,6,3,2,11,4,4,11,12,8,2,10,1,7
+P,5,11,6,8,3,4,12,9,2,10,6,4,1,10,4,8
+X,4,7,6,5,3,6,8,1,8,10,8,9,3,8,3,7
+B,7,12,6,6,6,8,8,4,5,9,6,7,6,7,8,7
+C,3,5,5,3,2,4,8,5,7,11,10,12,1,9,2,7
+P,5,8,7,6,5,8,9,5,4,11,4,4,2,10,3,8
+M,7,9,10,7,7,3,7,4,5,10,11,11,10,6,4,7
+S,5,9,7,6,8,7,8,5,3,8,5,8,4,8,10,7
+H,5,11,6,8,3,7,7,15,1,7,7,8,3,8,0,8
+J,2,7,3,5,1,12,2,9,4,13,5,13,1,6,0,8
+N,4,7,5,5,4,8,8,13,1,6,6,7,6,8,1,10
+S,4,8,6,6,4,9,7,3,6,10,5,8,2,9,5,9
+B,4,9,4,7,6,6,8,8,5,7,5,7,2,8,7,10
+R,5,7,6,5,6,8,9,7,3,8,4,6,5,7,7,9
+T,3,5,4,7,1,7,14,0,6,7,11,8,0,8,0,8
+J,2,7,3,5,3,9,7,1,5,10,4,7,0,7,1,6
+I,2,11,2,8,2,8,7,0,8,7,6,7,0,8,3,7
+A,2,4,4,3,2,8,2,2,2,7,2,8,2,6,2,7
+E,4,8,5,6,4,6,8,2,8,11,7,9,2,8,5,7
+S,9,15,8,9,4,11,2,4,5,11,2,10,3,6,5,12
+Y,3,7,4,5,4,9,5,6,5,7,8,8,3,9,7,4
+T,3,9,4,6,2,9,13,0,6,6,10,8,0,8,0,8
+S,1,0,2,0,0,8,8,4,6,5,6,7,0,8,7,8
+V,2,3,4,4,1,8,8,4,2,6,13,8,3,10,0,8
+E,3,5,6,3,3,7,6,2,8,11,6,10,2,8,4,9
+H,3,5,5,6,4,11,5,3,2,8,4,9,4,8,5,11
+O,2,1,3,2,1,7,7,7,6,7,6,8,2,8,3,8
+V,5,6,7,6,7,7,8,6,5,7,6,7,6,9,7,10
+T,3,4,4,3,2,6,10,2,8,11,9,5,1,10,3,4
+Z,6,6,5,9,4,7,8,4,2,11,7,7,3,9,10,6
+C,3,4,4,3,1,5,9,5,7,12,9,11,1,10,3,7
+O,5,10,6,8,5,7,8,8,5,10,8,8,3,8,3,8
+V,2,6,4,4,1,8,8,4,2,6,13,8,3,10,0,8
+P,6,11,8,8,5,7,11,6,4,12,5,2,1,11,4,9
+U,6,11,6,6,3,6,5,4,5,6,8,8,5,7,2,8
+Y,2,3,2,2,1,4,11,2,6,11,10,5,1,10,1,5
+R,4,10,5,7,3,5,10,9,4,7,4,8,3,7,6,11
+V,5,7,7,6,7,8,6,5,5,7,6,8,7,10,6,7
+S,2,7,3,5,2,8,7,7,7,7,7,8,2,9,9,8
+N,7,9,8,4,3,9,6,4,4,13,2,7,6,8,0,7
+B,2,5,4,4,3,8,8,3,5,10,6,6,3,7,5,9
+F,2,3,4,2,2,7,9,2,6,13,6,5,2,9,2,7
+T,3,2,4,3,2,7,12,2,7,7,11,8,1,11,1,7
+B,2,4,3,3,2,8,7,3,5,9,6,6,2,8,5,9
+K,5,8,8,7,7,7,7,2,4,7,3,8,6,4,8,11
+F,6,11,5,6,3,7,9,2,6,11,6,5,2,10,5,6
+T,3,9,5,6,3,7,12,2,8,7,12,8,1,11,1,8
+P,3,5,6,4,3,7,10,4,4,12,4,3,1,10,3,8
+T,5,11,7,8,6,7,11,2,7,7,11,8,2,12,1,8
+O,2,1,2,2,1,8,7,7,4,7,6,8,2,8,3,8
+F,3,5,3,4,2,5,10,4,5,10,9,5,1,10,3,7
+R,3,7,3,5,3,6,10,8,4,7,3,9,2,6,4,10
+J,2,9,4,6,4,10,7,3,3,9,3,6,2,7,7,7
+W,9,13,9,7,5,5,9,2,2,7,10,8,10,12,1,6
+X,4,8,7,6,3,7,7,1,8,10,7,9,3,8,3,7
+T,3,7,4,5,2,6,14,1,5,8,10,7,0,8,0,8
+F,3,11,4,8,3,1,13,4,4,12,10,7,0,8,2,6
+N,8,15,7,8,4,7,9,4,7,4,4,9,5,8,2,8
+C,3,6,4,4,2,4,9,6,7,12,9,10,2,10,3,7
+Z,3,8,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+B,4,8,5,6,4,6,6,8,7,6,6,7,2,8,9,10
+P,6,9,9,7,6,6,13,7,2,12,5,2,1,11,4,8
+R,4,8,6,6,4,8,7,6,6,9,5,7,3,8,5,11
+F,2,4,4,3,2,7,9,2,6,13,6,6,1,9,2,8
+K,6,11,6,8,3,4,9,9,2,7,3,11,4,8,2,11
+O,4,8,5,6,3,7,6,8,5,7,5,8,3,8,3,8
+V,6,10,6,7,4,4,12,1,2,8,10,7,6,12,2,7
+E,4,7,6,5,4,7,8,2,7,11,6,9,3,8,4,9
+D,5,11,6,8,5,9,7,5,7,10,4,5,3,8,3,8
+L,9,15,8,8,4,9,2,4,5,12,4,13,2,7,6,8
+R,4,8,6,6,5,6,8,5,6,6,5,7,3,7,5,8
+W,5,7,5,5,5,5,9,3,3,9,7,7,6,11,3,6
+B,2,3,4,2,2,9,7,2,5,10,5,6,2,8,4,9
+C,6,12,4,6,2,5,10,5,8,11,8,9,2,8,5,8
+L,4,10,4,8,1,0,0,6,6,0,0,5,0,8,0,8
+P,3,5,4,4,3,5,10,4,4,10,8,4,1,10,3,7
+V,5,10,7,9,8,7,7,6,4,7,6,8,7,10,8,11
+Y,4,4,6,6,1,7,10,3,2,7,13,8,2,11,0,8
+S,1,1,2,1,0,8,7,4,7,5,6,7,0,8,7,8
+L,6,14,6,8,4,8,4,3,4,12,8,11,4,9,6,10
+B,6,10,9,7,7,8,7,5,6,9,5,6,3,7,7,10
+R,6,11,6,6,5,7,8,3,6,8,3,8,6,6,6,7
+Z,2,2,3,3,2,7,7,5,9,6,6,8,1,8,7,8
+C,4,9,5,7,4,6,8,6,8,7,6,13,1,8,4,9
+Z,8,14,8,8,5,7,7,2,9,11,7,9,4,7,7,5
+M,7,11,10,8,13,11,5,3,3,9,4,8,11,8,4,8
+H,5,7,7,5,4,5,8,4,6,10,9,9,3,8,3,7
+T,5,10,7,8,6,6,7,7,7,8,9,8,4,9,7,7
+T,8,14,7,8,4,5,11,2,7,12,8,6,3,8,5,3
+G,2,4,3,3,2,6,7,5,5,9,7,10,2,9,4,9
+O,1,0,2,1,0,8,7,7,4,7,6,8,2,8,3,8
+H,3,4,6,3,3,7,7,3,6,10,6,8,3,8,3,7
+P,3,5,4,8,7,8,7,5,1,7,6,7,6,9,5,9
+K,7,9,9,7,7,6,7,1,7,9,6,10,4,8,4,8
+Q,6,8,6,9,6,8,7,7,4,8,7,10,3,8,6,8
+X,4,6,5,5,5,7,9,2,6,8,6,8,3,6,6,7
+Z,4,6,6,9,4,12,3,3,6,10,2,8,1,7,5,11
+L,4,8,5,6,2,3,1,7,9,0,1,3,0,7,1,5
+X,9,13,10,7,5,7,7,2,9,11,5,8,4,7,4,7
+Q,6,11,6,6,4,11,3,4,5,12,3,9,3,9,7,12
+W,4,5,6,3,4,6,11,2,2,7,9,8,8,11,1,8
+J,3,6,4,4,2,6,8,2,5,14,7,9,1,6,0,7
+A,2,3,3,1,1,8,2,2,1,7,2,8,2,7,2,7
+P,1,0,2,0,0,5,11,7,1,9,6,4,1,9,3,8
+M,2,3,4,1,2,5,6,3,4,10,10,10,4,7,1,7
+T,4,11,6,8,2,8,15,1,6,7,11,8,0,8,0,8
+F,3,2,4,3,2,6,10,4,5,10,9,4,2,10,3,6
+Y,9,15,8,8,5,5,7,4,3,9,9,6,4,9,4,4
+J,2,6,2,4,1,13,2,8,4,13,4,12,0,7,0,8
+P,4,8,6,6,4,9,7,2,5,13,4,5,1,10,3,10
+D,5,5,5,7,3,6,7,10,10,7,7,6,3,8,4,8
+M,5,7,7,6,8,5,7,5,4,6,5,8,11,7,5,9
+F,3,4,5,3,2,6,10,3,6,13,7,5,1,10,2,7
+W,3,1,5,3,3,7,11,3,2,6,9,8,7,11,0,8
+U,3,3,4,2,2,6,8,5,7,6,9,9,3,10,1,7
+J,4,8,6,6,2,9,6,2,8,15,4,8,0,7,0,8
+P,5,5,7,7,8,8,7,4,2,7,8,7,7,12,5,7
+Z,5,10,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+C,5,9,6,7,7,5,6,3,4,7,6,11,6,9,3,8
+E,3,2,4,3,3,7,7,5,8,7,5,8,2,8,6,9
+K,4,7,5,5,4,6,6,1,6,10,7,10,3,8,3,8
+U,5,11,7,8,5,4,9,6,7,9,11,10,3,9,1,8
+B,7,11,7,6,5,9,7,3,5,10,5,7,6,7,7,8
+X,3,4,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+Z,4,11,4,9,4,6,8,6,10,7,7,9,2,9,8,8
+O,2,3,3,2,1,7,7,7,4,7,6,8,2,8,2,8
+X,5,5,6,7,2,7,7,5,4,7,6,8,3,8,4,8
+R,5,10,6,8,7,8,5,7,3,8,6,8,6,5,6,10
+Y,2,3,4,4,1,8,10,2,2,6,13,8,2,11,0,8
+I,3,10,4,8,3,7,9,0,7,13,6,7,0,9,2,7
+V,5,11,7,8,9,8,5,5,2,8,7,8,6,8,5,8
+J,5,11,7,8,8,9,7,4,4,8,4,6,4,7,6,4
+C,5,10,5,7,3,3,8,5,7,11,10,13,1,9,3,8
+N,3,5,4,7,3,7,7,14,2,5,6,8,6,8,0,8
+P,3,8,4,5,2,5,10,10,4,8,6,5,2,10,4,8
+O,2,5,3,3,2,7,7,8,4,7,6,8,2,8,3,8
+O,3,7,4,5,3,7,8,7,4,8,7,10,3,8,3,9
+A,2,6,4,4,2,11,3,3,2,10,1,9,2,6,2,8
+R,3,6,4,4,4,7,8,4,6,6,5,7,3,7,5,8
+W,4,2,6,4,4,8,11,2,2,6,9,8,9,13,1,7
+D,4,6,5,4,3,8,8,7,8,9,5,3,3,8,4,6
+T,3,8,4,6,2,8,14,0,5,6,10,8,0,8,0,8
+N,1,0,2,1,1,7,7,11,1,5,6,8,4,8,0,8
+H,4,8,6,10,7,9,10,3,1,8,7,6,3,10,8,7
+D,3,7,5,5,4,8,7,3,5,10,5,6,3,8,3,8
+R,5,9,7,7,6,10,6,3,5,10,3,7,4,6,4,10
+B,7,10,6,6,4,8,5,4,5,10,6,9,5,7,7,10
+A,5,8,8,7,7,7,7,2,5,7,9,10,5,11,3,7
+A,2,1,3,1,1,7,4,2,0,7,1,8,3,6,1,8
+T,4,10,5,8,4,5,12,4,7,9,12,7,2,12,1,7
+O,9,13,6,7,4,5,8,6,4,10,8,9,5,10,5,8
+J,5,8,6,6,3,8,8,1,6,14,5,7,1,6,1,8
+Y,4,4,6,6,6,9,10,5,4,6,7,7,5,10,7,5
+L,6,15,6,8,4,7,5,3,5,11,7,11,3,8,6,9
+Q,4,6,5,7,5,8,5,7,3,6,5,9,3,8,5,9
+B,5,7,7,5,6,7,9,4,6,10,6,6,3,7,6,8
+R,5,8,7,7,7,7,8,3,3,7,5,7,6,8,6,6
+E,4,8,4,6,2,3,6,6,11,7,7,15,0,8,7,7
+M,7,10,10,8,6,10,5,2,5,9,4,7,8,6,2,9
+Q,4,9,5,10,5,7,7,6,3,8,9,10,3,8,7,9
+U,4,5,4,8,2,7,4,15,6,7,12,8,3,9,0,8
+E,6,9,8,8,8,7,9,5,6,6,8,11,8,9,9,8
+N,4,6,6,4,5,4,10,2,4,8,7,9,6,7,4,5
+G,5,8,6,6,3,7,7,7,8,10,6,11,2,10,4,9
+D,2,4,4,3,2,9,7,4,6,10,4,6,2,8,3,8
+U,8,9,9,7,4,3,8,6,8,10,11,10,3,9,2,5
+A,5,11,9,8,7,10,5,1,5,9,1,5,3,7,4,8
+P,4,10,5,8,5,4,10,4,5,11,9,5,1,10,3,7
+L,5,11,6,8,5,3,4,3,8,2,0,8,0,7,1,5
+P,4,11,5,8,3,4,12,9,2,10,6,4,1,10,4,8
+L,2,2,3,4,2,4,4,5,7,2,2,5,1,6,1,6
+B,3,6,5,4,4,7,8,4,5,9,6,5,2,8,6,6
+E,3,4,4,6,2,3,8,6,10,7,6,14,0,8,7,7
+C,3,8,4,6,3,6,8,6,5,9,8,14,1,9,3,11
+H,4,5,6,3,3,8,8,3,6,10,6,8,3,8,3,8
+L,3,7,3,5,1,0,1,6,6,0,1,6,0,8,0,8
+T,5,7,7,6,6,5,8,3,8,7,7,9,3,7,7,5
+O,2,2,3,3,2,7,7,7,4,7,6,8,2,8,3,8
+D,7,11,6,6,5,8,8,4,7,10,5,6,6,6,7,6
+K,4,6,6,4,4,3,8,2,6,10,10,11,3,8,3,6
+B,3,2,4,3,3,7,7,5,6,6,6,6,2,8,7,10
+F,2,1,2,2,1,5,11,3,5,11,9,5,1,10,3,6
+Y,7,8,6,11,5,7,6,5,5,6,11,6,4,11,3,7
+R,8,10,6,6,4,6,8,5,5,9,6,9,7,5,7,11
+Y,7,9,7,7,4,3,10,2,7,11,11,6,1,11,2,5
+K,5,9,7,7,7,6,6,3,7,6,6,9,7,8,5,9
+M,3,3,5,2,3,8,6,6,4,7,7,8,7,5,2,7
+Y,3,8,5,5,1,7,10,3,2,7,13,8,2,11,0,8
+G,3,5,4,7,2,7,7,8,7,5,6,10,2,7,5,11
+K,5,4,5,6,2,4,8,9,1,7,6,11,3,8,3,11
+J,1,3,2,2,1,8,5,4,4,13,7,12,1,7,0,8
+X,4,11,6,8,4,7,7,4,9,6,6,8,3,8,7,7
+W,6,10,6,8,6,1,10,2,3,10,10,9,6,10,1,7
+A,4,9,6,6,2,8,4,3,1,7,1,8,3,7,2,8
+V,9,15,8,8,4,5,10,4,4,9,9,6,4,11,2,8
+H,3,1,4,2,3,7,7,6,6,7,6,8,3,8,4,8
+I,7,14,6,8,4,8,9,3,7,14,4,5,2,8,5,9
+B,3,5,5,4,4,8,8,3,6,10,5,5,3,7,6,9
+D,4,8,6,6,4,8,8,6,7,9,5,4,3,7,4,9
+M,6,11,9,9,10,9,7,5,5,6,7,6,10,9,3,6
+G,3,5,4,4,2,6,7,6,7,7,5,10,2,9,4,9
+H,2,1,3,2,2,8,7,6,5,7,6,8,3,8,3,8
+D,2,3,3,2,2,9,6,4,6,10,5,6,2,8,2,8
+G,3,4,5,7,2,8,7,9,7,5,6,10,2,7,5,10
+M,3,8,4,6,3,7,7,11,1,7,9,8,8,5,0,8
+G,6,11,8,9,9,9,7,5,2,6,6,10,8,8,5,10
+A,2,8,4,6,3,11,3,3,3,10,2,9,2,6,3,8
+O,5,9,6,6,3,7,7,8,8,7,6,8,3,8,4,8
+Y,3,5,4,6,5,8,10,6,4,7,7,6,4,10,6,3
+D,2,5,3,3,3,7,7,6,6,7,6,5,2,8,2,7
+J,6,11,5,8,4,5,13,3,3,13,6,4,2,8,6,6
+C,2,5,3,4,2,6,8,7,7,9,8,13,1,9,4,10
+M,4,10,5,8,6,7,5,11,1,7,9,8,9,5,2,8
+T,3,4,5,6,1,7,15,1,6,7,11,8,0,8,0,8
+L,5,11,7,8,4,7,3,2,8,7,2,8,1,6,3,7
+J,1,6,2,4,1,10,6,1,7,11,3,7,0,7,1,7
+D,4,9,5,6,8,8,10,5,4,8,6,5,6,10,9,6
+Z,5,7,7,5,6,9,5,5,4,7,5,7,3,7,10,5
+R,4,6,5,4,5,8,7,6,3,8,5,7,4,7,7,10
+V,5,10,5,7,4,4,11,1,2,8,10,7,3,10,1,8
+H,5,8,7,6,7,8,7,6,7,7,6,7,3,8,4,7
+K,9,14,9,8,6,3,8,4,6,10,11,12,5,8,4,6
+O,6,11,9,8,11,8,6,6,1,7,6,8,11,8,6,8
+M,7,9,9,7,7,6,6,3,5,10,9,9,10,7,3,8
+R,4,4,5,6,3,5,13,8,4,8,3,9,3,7,7,11
+X,5,10,6,8,4,7,7,4,4,7,6,7,3,8,4,8
+O,9,15,6,9,5,4,8,6,4,10,8,9,5,10,5,8
+L,5,7,6,5,4,6,6,7,7,5,6,10,2,8,4,10
+Z,4,7,6,5,4,9,6,2,8,11,4,10,2,7,6,10
+F,4,7,6,5,4,5,11,3,5,13,7,5,1,10,2,7
+Q,5,5,7,4,5,8,5,5,4,7,4,10,5,6,6,8
+C,8,12,6,6,5,7,7,4,4,9,8,10,4,9,8,10
+G,3,7,4,5,3,6,5,5,6,6,6,9,2,9,3,7
+V,4,5,6,3,2,4,12,3,3,10,11,7,2,10,1,8
+I,6,9,8,7,4,6,7,2,7,7,6,11,0,8,4,8
+C,4,5,6,8,2,6,8,7,10,5,7,13,1,7,4,9
+D,4,8,5,6,4,7,6,7,8,6,5,5,3,8,3,7
+X,5,11,6,8,2,7,7,5,4,7,6,8,3,8,4,8
+E,5,11,5,8,3,3,7,6,11,7,6,14,0,8,8,7
+E,1,1,2,2,1,4,7,5,8,7,6,13,0,8,7,9
+S,4,10,5,7,5,8,9,8,6,7,4,6,2,6,9,8
+V,5,9,7,7,3,9,12,3,4,4,11,9,3,10,1,8
+D,2,6,4,4,3,9,6,4,6,10,4,6,3,8,3,8
+L,4,10,4,8,1,0,1,5,6,0,0,6,0,8,0,8
+D,3,8,5,6,7,9,8,4,5,7,6,6,5,6,8,6
+U,3,5,5,5,4,8,7,4,4,6,7,7,4,8,1,6
+I,2,6,3,4,1,7,7,0,7,13,6,8,0,8,1,8
+V,6,7,8,6,9,8,6,5,5,7,6,8,8,10,7,4
+F,8,14,7,8,5,10,6,3,5,10,4,6,4,8,7,10
+M,5,7,8,5,7,8,7,2,4,9,6,7,7,5,2,7
+I,4,10,6,8,4,7,7,0,8,13,6,8,0,8,1,8
+W,4,5,5,4,3,4,10,3,2,9,9,7,6,11,1,6
+I,4,5,5,6,5,7,10,4,5,8,7,8,4,7,6,6
+H,8,10,8,5,5,8,7,3,5,10,5,7,6,9,4,8
+A,4,10,6,7,2,7,5,3,1,7,0,8,3,7,2,8
+N,6,8,9,7,9,6,7,4,4,6,5,8,8,9,5,8
+P,6,9,9,7,4,7,10,2,7,14,5,3,3,8,4,8
+V,4,5,6,8,2,7,8,4,3,7,14,8,3,9,0,8
+R,7,9,10,8,11,7,7,4,4,7,5,8,7,8,6,6
+R,4,8,5,6,5,8,8,7,5,8,5,7,7,8,6,11
+I,4,11,6,8,3,7,7,0,8,14,6,8,0,8,1,8
+E,3,5,5,4,3,8,7,2,7,11,5,8,2,9,5,10
+F,5,9,5,6,2,1,12,5,6,12,11,9,0,8,2,6
+G,4,5,5,4,3,6,7,5,5,9,8,9,2,8,5,9
+O,5,9,6,7,5,8,6,8,6,7,5,8,3,8,4,7
+A,4,8,6,6,6,8,8,7,4,6,6,8,3,7,7,4
+S,4,8,4,6,4,8,8,5,7,5,5,7,0,8,8,8
+J,2,5,3,8,1,12,3,10,3,13,6,13,1,6,0,8
+E,3,2,3,3,3,7,7,5,7,7,6,9,2,8,5,10
+Q,6,14,5,8,5,9,6,4,6,11,5,7,4,8,9,10
+F,3,8,4,6,3,3,12,4,5,12,10,5,1,10,3,5
+X,4,8,6,6,4,8,7,1,8,10,4,7,3,8,3,8
+X,3,3,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+G,5,9,4,4,3,7,8,3,3,8,6,6,3,9,8,7
+U,3,5,4,3,2,6,8,6,7,7,10,9,3,9,0,8
+Z,2,7,4,5,3,8,7,2,6,7,6,7,0,9,8,8
+U,6,8,7,6,3,3,9,6,7,11,11,9,3,9,1,6
+Q,4,7,5,8,5,8,6,7,5,9,6,9,3,8,5,7
+V,3,5,5,4,2,4,12,3,3,9,11,7,2,10,1,8
+K,3,4,4,3,2,5,7,4,7,7,6,11,3,8,5,9
+U,5,9,7,6,9,7,6,4,4,7,7,8,10,8,6,6
+C,6,10,6,8,4,5,8,6,8,12,9,13,2,9,4,7
+N,4,7,4,5,3,8,7,12,1,6,6,8,5,8,0,9
+H,4,4,6,3,3,7,6,3,6,10,5,9,4,6,4,7
+Y,6,10,6,5,3,6,8,4,3,10,8,5,3,10,4,4
+G,2,1,4,2,2,7,7,6,6,6,6,10,2,9,4,9
+T,4,6,6,6,5,5,8,4,8,8,8,9,3,9,7,6
+B,5,9,8,7,7,9,7,3,7,11,4,7,3,7,5,9
+B,3,5,6,4,4,9,6,3,6,10,5,7,2,8,5,9
+V,5,9,5,7,4,3,11,2,3,9,11,8,3,12,1,7
+Z,4,8,5,6,2,7,7,4,14,9,6,8,0,8,8,8
+X,3,9,5,6,4,7,7,3,8,5,6,8,2,8,6,7
+S,7,11,8,8,6,6,7,3,6,10,7,8,3,7,5,6
+V,7,9,6,7,3,4,11,3,4,9,11,7,3,10,1,7
+R,5,9,6,6,7,8,8,7,3,8,4,6,5,7,8,9
+U,2,1,3,2,1,6,8,6,6,6,9,9,3,9,0,8
+J,4,8,3,12,3,9,7,3,3,11,5,5,3,8,6,10
+Q,5,9,6,11,6,8,6,7,4,9,7,10,3,8,6,8
+V,11,14,8,8,4,9,10,6,5,6,10,6,6,13,3,6
+S,4,6,5,4,3,8,7,3,6,10,6,8,2,9,5,8
+S,3,8,4,6,2,7,7,6,9,5,7,10,0,8,9,8
+C,6,11,5,6,3,7,8,4,3,8,8,10,4,8,7,11
+Q,4,6,6,8,8,9,9,5,0,6,7,10,6,12,5,10
+H,1,0,1,0,0,7,7,10,2,7,6,8,2,8,0,8
+M,5,11,7,8,9,8,9,7,4,7,7,8,8,8,9,5
+V,3,7,4,5,2,8,9,3,1,7,12,8,2,10,0,8
+S,5,11,6,8,5,7,8,3,7,10,4,6,2,6,5,8
+E,4,10,4,8,4,3,8,5,9,7,6,14,0,8,6,8
+G,5,11,5,8,4,5,6,7,6,7,7,11,3,7,5,8
+T,2,1,3,2,0,7,15,1,4,7,11,8,0,8,0,8
+F,4,9,4,6,2,1,14,5,3,12,9,5,0,8,2,6
+J,5,11,7,8,4,8,6,3,6,15,4,9,0,7,0,7
+P,4,9,5,6,4,5,11,8,2,9,5,4,1,10,3,7
+D,3,7,5,5,3,10,6,4,7,10,3,6,3,8,3,9
+L,3,3,4,5,1,1,0,6,6,0,1,5,0,8,0,8
+G,5,10,6,7,5,6,6,6,6,10,7,13,3,9,5,9
+Q,2,2,3,3,2,8,7,6,3,6,6,9,2,9,3,10
+L,5,10,5,8,3,0,1,5,6,0,0,7,0,8,0,8
+T,6,9,6,7,3,4,14,5,6,12,9,3,1,11,2,4
+F,1,3,3,1,1,6,10,3,4,13,7,5,1,9,1,7
+N,5,7,7,5,4,4,10,3,4,10,10,9,5,8,1,8
+X,2,3,4,2,2,8,7,1,7,10,5,8,2,8,2,8
+I,0,3,0,2,0,7,7,1,7,7,6,8,0,8,2,8
+C,4,9,3,4,2,6,8,4,3,9,8,10,3,9,8,9
+L,4,10,6,7,4,8,4,0,8,10,3,10,0,7,3,9
+A,3,7,6,5,3,11,2,3,2,10,2,9,2,6,3,9
+T,2,8,3,5,1,8,13,0,6,6,11,8,0,8,0,8
+N,4,7,6,5,4,5,9,3,4,10,9,8,5,8,1,8
+V,3,1,5,3,1,7,12,2,3,7,11,9,2,10,1,8
+L,2,3,2,2,1,4,3,4,8,2,2,5,0,7,1,6
+H,5,9,8,7,7,5,9,3,6,10,9,9,3,9,4,6
+X,8,12,9,6,5,8,7,2,7,11,4,7,5,10,4,8
+S,4,8,5,6,5,8,6,7,5,6,8,9,3,9,9,8
+Z,3,7,4,5,3,6,8,5,9,7,7,9,1,9,7,7
+Y,5,8,7,11,11,8,8,4,2,7,8,9,4,11,8,8
+Y,2,2,3,3,1,7,10,1,6,7,11,9,1,11,1,8
+K,6,11,9,8,7,7,7,4,7,6,5,8,7,8,5,9
+E,3,3,3,4,2,3,7,6,10,7,6,14,0,8,7,7
+F,3,5,5,3,2,6,12,3,5,13,7,4,1,10,2,6
+K,5,9,7,7,9,8,7,3,4,6,7,8,10,8,8,7
+H,3,7,3,4,2,7,9,14,3,7,3,8,3,8,0,8
+O,3,6,5,4,3,8,8,8,4,7,6,7,3,8,3,8
+R,5,10,8,8,9,6,7,3,4,7,6,9,8,10,8,5
+C,2,5,3,3,2,6,8,7,7,8,8,13,1,9,4,10
+H,7,10,10,8,6,8,7,3,7,10,5,8,3,8,3,8
+X,6,9,8,8,9,6,8,2,5,7,7,10,4,5,8,7
+E,4,10,5,8,7,8,7,3,5,6,7,10,4,9,8,8
+A,3,6,5,8,2,7,5,3,1,7,0,8,3,7,2,8
+Z,3,5,5,4,3,7,8,2,9,12,6,8,1,9,5,7
+Y,5,7,6,5,3,4,9,1,8,10,10,6,1,10,3,4
+A,2,1,4,2,1,7,2,2,1,6,2,8,2,7,2,7
+A,3,9,6,6,4,11,3,1,2,8,2,9,2,6,2,7
+J,2,7,4,5,2,7,8,2,5,14,5,7,0,6,1,7
+C,4,5,5,3,2,4,8,4,8,11,9,12,1,9,3,7
+Q,6,8,6,9,6,7,7,7,4,9,9,9,4,8,7,9
+F,5,8,7,6,4,8,9,3,6,13,5,5,2,9,2,7
+U,5,10,6,8,4,3,9,5,7,11,10,9,3,9,2,7
+S,5,11,6,8,6,8,8,7,5,7,5,7,2,8,9,8
+E,3,9,4,6,4,3,8,5,9,7,7,14,0,8,6,9
+I,1,3,1,1,1,7,7,2,7,7,6,8,0,8,2,8
+E,4,9,6,7,5,7,7,2,7,11,7,9,3,8,4,8
+F,3,5,4,4,3,5,10,3,5,10,9,5,1,10,3,6
+U,3,2,4,4,2,6,8,6,6,7,9,9,3,9,1,8
+O,2,2,3,3,2,7,7,7,4,7,6,8,2,8,3,8
+H,10,12,9,7,5,7,7,5,5,8,9,8,7,11,5,9
+X,2,1,3,2,2,7,7,3,9,6,6,8,2,8,5,8
+Q,3,5,4,6,4,8,7,5,2,8,7,10,3,9,5,8
+L,4,9,5,7,3,3,4,3,9,2,0,7,0,7,1,5
+N,5,9,7,6,4,6,9,6,5,8,7,8,5,8,1,7
+S,4,10,5,8,5,8,9,8,6,7,4,5,2,6,8,8
+T,4,8,5,6,3,7,11,3,8,11,9,4,2,11,3,5
+E,5,9,8,7,8,6,7,3,7,5,6,11,4,10,11,8
+T,2,7,4,5,2,6,12,3,7,8,11,7,1,11,1,7
+J,2,7,2,5,1,12,2,9,4,13,5,12,1,6,0,8
+L,1,3,2,1,0,6,4,1,7,8,2,10,0,7,2,9
+X,5,10,6,7,2,7,7,5,4,7,6,8,3,8,4,8
+O,4,6,5,5,4,8,5,4,4,9,4,10,3,7,5,7
+P,3,5,5,7,6,8,11,3,1,8,8,6,6,10,4,6
+U,4,9,5,7,2,7,5,15,5,7,13,8,3,9,0,8
+U,7,11,9,8,8,7,6,9,6,7,6,9,6,8,7,2
+N,4,6,6,4,3,7,8,3,5,10,6,7,5,8,1,7
+Y,9,12,8,6,5,7,5,4,5,9,9,5,4,10,4,5
+M,4,2,5,4,4,8,6,6,4,6,7,8,8,6,2,7
+P,3,10,4,8,4,4,12,7,2,10,7,4,1,10,3,8
+A,2,3,4,2,1,6,2,2,2,5,2,8,2,6,2,6
+K,3,7,5,5,6,8,6,3,4,6,6,8,6,8,6,8
+S,3,4,5,3,2,9,6,3,8,11,4,7,1,9,4,9
+G,4,7,5,5,2,8,6,7,7,6,6,9,2,8,6,11
+B,4,10,5,7,4,6,8,9,7,7,5,7,2,8,9,9
+U,4,4,5,6,2,7,4,14,5,7,14,8,3,9,0,8
+Q,4,9,6,7,6,8,5,7,4,6,6,8,3,7,5,9
+Z,5,6,4,9,3,6,9,5,3,12,7,7,2,9,10,6
+N,6,9,8,7,4,6,8,3,4,10,8,8,5,8,1,7
+R,5,5,6,8,4,6,9,10,5,6,5,8,3,8,6,11
+V,2,3,3,2,1,7,12,2,2,6,10,9,2,11,0,8
+M,5,9,5,6,6,7,5,11,0,7,8,8,7,5,1,9
+L,3,4,4,6,1,0,0,6,6,0,1,5,0,8,0,8
+N,4,5,4,3,3,7,8,5,5,7,7,6,6,9,3,6
+E,4,9,6,7,5,9,6,2,7,11,5,9,3,7,6,10
+J,4,6,5,4,2,8,6,4,7,15,6,10,1,6,1,7
+V,4,11,5,8,4,6,9,4,1,8,12,8,3,9,1,8
+A,2,7,4,4,1,8,5,3,1,7,0,8,2,7,2,8
+P,1,1,2,1,1,5,11,7,2,10,6,4,1,9,3,8
+Y,9,11,9,8,6,5,8,0,9,8,9,5,4,13,7,3
+L,4,5,5,4,2,4,4,5,8,2,2,5,1,6,1,5
+Q,7,8,7,10,7,8,5,7,5,9,6,9,3,8,6,7
+U,5,11,5,8,4,7,5,12,4,7,13,8,3,9,0,7
+D,4,9,5,7,3,5,7,10,9,6,5,5,3,8,4,8
+B,4,11,5,8,4,6,8,9,8,7,5,7,3,8,9,10
+N,3,6,3,4,3,8,7,11,1,6,6,8,5,9,0,6
+L,4,9,5,8,6,7,6,5,4,7,7,8,2,9,7,10
+U,5,9,5,6,2,8,4,14,6,7,14,8,3,9,0,8
+V,4,10,5,8,3,6,9,4,1,8,12,8,4,9,1,8
+P,6,11,9,8,7,9,8,2,5,13,5,5,3,9,4,9
+E,6,8,8,6,6,7,7,2,8,11,5,9,3,8,4,9
+A,4,8,5,6,3,7,5,2,0,7,1,8,2,7,1,8
+Y,7,9,7,6,3,4,10,2,8,10,11,5,2,13,4,3
+W,5,9,8,6,6,7,10,2,3,7,9,8,8,11,1,8
+K,8,13,8,7,4,9,7,3,7,9,3,6,5,8,4,8
+D,5,9,7,8,7,6,7,6,7,7,6,9,5,5,7,4
+P,0,0,1,0,0,5,10,6,1,9,6,5,1,9,2,8
+C,2,2,3,3,2,6,8,7,7,8,7,13,1,9,4,10
+Y,3,7,5,4,1,8,11,2,2,5,12,8,1,11,0,8
+J,2,5,3,3,1,9,6,3,6,12,4,9,1,6,1,7
+C,6,11,8,9,6,7,7,8,6,6,6,13,6,8,5,7
+Q,5,9,5,10,6,8,6,7,5,9,6,9,3,8,6,8
+D,3,5,5,4,3,9,6,4,7,9,4,6,2,8,3,8
+I,5,12,4,6,2,11,5,3,6,12,3,7,2,9,4,11
+G,4,7,5,5,3,5,8,5,5,9,9,8,2,8,4,9
+M,6,9,8,7,8,7,7,5,5,6,7,8,9,7,3,7
+A,4,9,6,6,2,8,3,3,3,7,2,8,3,6,3,8
+I,2,8,2,6,2,7,7,0,7,7,6,8,0,8,3,8
+G,6,7,8,6,7,7,8,5,3,7,7,8,9,10,9,7
+Q,4,7,5,9,5,9,7,7,3,5,7,10,3,8,7,10
+D,4,8,4,6,4,6,7,9,7,7,7,6,2,8,3,8
+D,3,8,5,6,7,10,8,4,5,7,6,6,4,7,7,4
+D,4,9,6,7,6,7,7,8,6,6,5,5,3,9,4,8
+T,3,3,3,2,1,6,11,2,7,11,9,5,1,10,2,5
+Z,2,5,5,3,2,7,8,2,9,12,6,8,1,9,5,8
+D,3,9,4,6,3,6,7,11,9,7,6,6,3,8,4,8
+M,6,10,9,8,7,10,6,2,5,9,4,7,8,6,2,8
+Z,2,1,3,2,2,7,7,5,8,6,6,9,2,8,7,8
+G,5,8,6,6,3,5,7,6,6,10,8,10,2,8,5,9
+D,3,2,4,3,2,7,7,6,7,6,6,5,2,8,3,7
+K,5,10,7,8,6,10,6,1,6,10,3,8,4,9,4,11
+Z,6,10,8,8,6,8,7,2,9,12,5,8,1,8,6,8
+C,6,10,6,8,4,4,7,6,6,13,10,12,2,11,3,7
+K,6,11,9,8,7,6,6,1,6,9,6,10,5,7,5,8
+O,4,9,5,6,4,8,6,7,3,10,4,8,3,8,3,7
+M,5,5,7,4,5,8,6,6,5,7,7,8,8,6,2,8
+R,4,5,4,6,3,5,11,8,4,7,3,9,3,7,6,11
+U,4,10,6,7,4,5,8,7,7,8,10,10,3,9,1,8
+Q,7,13,6,7,4,10,3,4,7,10,4,9,3,9,6,13
+O,4,9,6,7,4,8,6,9,3,6,5,7,3,8,4,9
+U,3,5,4,3,2,5,8,4,7,10,8,9,3,9,2,6
+H,3,7,5,5,4,6,7,6,4,6,5,8,3,7,6,11
+A,2,3,4,4,1,7,5,3,1,6,1,8,2,7,2,7
+W,5,10,7,8,4,11,8,5,2,6,9,8,8,10,0,8
+F,2,3,4,2,1,5,11,3,5,13,7,4,1,9,1,7
+U,5,5,6,3,2,4,8,5,8,10,10,9,3,9,2,5
+U,1,0,1,0,0,7,6,10,4,7,11,8,3,10,0,8
+J,5,9,6,7,3,7,7,3,6,15,6,10,1,6,1,7
+S,3,3,4,5,2,8,6,5,9,5,6,8,0,9,9,8
+W,2,0,3,1,1,7,8,4,0,7,8,8,7,9,0,8
+Q,2,2,3,2,2,8,8,5,2,8,7,9,2,9,3,8
+A,3,9,5,7,3,13,2,4,4,12,1,9,3,6,3,10
+U,6,7,7,5,4,3,8,5,7,10,9,10,3,9,2,5
+G,3,3,4,5,2,8,7,8,7,6,6,10,2,7,5,11
+Q,4,7,5,6,3,8,7,8,6,6,7,9,3,8,5,9
+B,6,11,8,8,8,9,7,3,6,9,4,6,3,8,5,9
+E,5,8,7,6,4,5,9,4,10,12,10,8,2,8,5,3
+E,5,7,7,5,4,6,7,4,9,12,8,9,2,8,5,7
+M,6,10,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+E,4,9,4,7,2,3,7,6,11,7,7,15,0,8,7,7
+I,4,11,6,8,3,7,7,0,8,14,6,8,0,8,1,8
+D,2,4,4,3,2,9,7,4,6,10,4,6,2,8,3,8
+W,4,5,5,4,3,7,11,3,2,6,9,8,7,11,0,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+F,8,12,7,6,4,9,7,4,7,12,4,6,2,8,8,8
+T,4,5,6,4,5,8,9,5,7,7,7,8,3,10,7,7
+G,7,11,8,8,6,6,6,7,7,9,8,11,2,11,5,9
+H,7,11,8,6,5,6,9,3,5,10,6,8,6,7,5,7
+H,4,10,6,8,7,8,7,5,6,7,6,6,3,8,4,7
+F,5,6,6,7,6,6,12,3,5,9,7,6,4,9,5,6
+N,4,10,5,8,3,7,7,14,2,4,6,8,6,8,0,8
+C,4,7,4,5,2,5,9,6,7,12,9,9,2,10,2,7
+X,4,5,6,3,3,7,7,1,9,10,6,8,2,8,3,7
+P,3,7,4,5,3,5,11,5,4,11,8,4,1,10,4,7
+N,3,8,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+D,4,8,5,6,5,8,8,6,5,9,5,5,3,8,3,7
+U,6,11,8,8,8,9,7,8,5,6,7,9,6,8,4,6
+P,6,6,8,8,9,7,9,3,3,8,8,6,6,11,6,5
+B,0,0,1,0,0,6,7,6,4,7,6,8,1,8,5,10
+X,4,7,7,5,3,5,9,2,8,10,10,8,3,8,4,6
+T,3,5,4,7,1,10,14,1,6,4,11,9,0,8,0,8
+O,3,10,5,8,5,8,6,8,4,6,5,6,3,8,3,7
+Z,4,7,5,5,4,9,9,6,4,7,5,8,3,9,10,7
+T,1,1,2,1,0,7,14,1,5,7,11,8,0,8,0,8
+W,3,4,4,2,2,6,11,3,2,8,7,7,6,11,1,6
+T,7,9,6,4,2,4,12,3,7,13,8,4,2,8,3,4
+T,2,6,3,4,1,7,12,0,5,7,10,8,0,8,0,8
+A,5,11,5,6,4,9,4,5,3,10,6,12,7,4,6,10
+R,5,10,6,8,6,5,8,6,6,6,5,9,4,8,6,10
+R,1,0,1,0,0,6,9,7,3,7,5,8,2,7,3,10
+T,3,2,4,4,3,7,11,3,6,7,11,8,2,11,1,8
+L,1,0,2,1,0,2,1,6,5,0,2,5,0,8,0,8
+T,4,8,5,6,3,7,10,1,8,11,9,5,1,10,3,5
+Y,2,3,3,5,0,7,10,1,3,7,12,8,1,11,0,8
+T,5,11,5,8,3,5,11,2,8,12,10,4,1,11,2,4
+S,2,6,3,4,1,6,5,5,8,5,6,11,0,9,8,8
+N,6,8,8,6,4,9,9,3,5,10,3,5,5,9,1,7
+F,4,7,6,5,5,5,9,2,4,10,8,7,5,10,3,4
+M,3,1,4,3,3,8,6,6,4,7,7,8,7,6,2,7
+H,9,11,12,8,8,5,7,4,7,10,9,10,3,8,4,6
+D,6,9,6,5,3,9,5,4,5,12,3,8,5,7,5,10
+J,4,9,6,6,5,9,8,3,4,8,4,6,4,8,5,4
+O,4,7,5,5,2,8,7,8,7,7,6,9,3,8,4,8
+P,2,4,4,3,2,8,9,3,4,12,4,3,1,10,3,8
+C,3,9,5,7,3,4,8,7,7,9,9,14,2,9,4,9
+B,3,5,5,3,3,9,7,3,6,10,5,6,2,8,5,9
+T,2,1,3,3,1,7,12,3,6,7,11,8,2,11,1,8
+F,4,4,4,6,2,1,13,5,4,12,10,7,0,8,2,6
+J,1,3,2,4,0,14,3,6,4,13,2,10,0,7,0,8
+L,3,7,5,5,3,7,3,2,7,8,2,9,2,5,3,8
+E,3,5,6,3,3,7,7,2,8,11,6,9,2,8,4,8
+S,4,7,5,5,6,8,8,4,3,8,5,7,3,8,10,8
+P,7,12,6,6,3,8,9,7,5,14,4,4,4,10,4,7
+A,2,6,4,4,2,8,2,2,2,7,2,8,2,6,3,6
+F,5,10,7,8,4,5,13,5,4,13,8,3,2,10,2,5
+H,6,9,6,4,3,8,8,4,4,8,6,6,6,10,4,8
+S,5,11,7,8,4,8,9,6,10,5,6,6,0,8,9,7
+B,3,7,4,5,3,6,7,8,6,7,6,6,2,8,9,10
+G,7,11,8,9,5,7,6,7,7,12,6,12,3,11,5,8
+Z,2,6,3,4,1,7,7,3,13,9,6,8,0,8,8,8
+S,2,1,2,2,1,8,7,6,5,7,6,7,2,8,8,8
+W,3,3,5,4,2,9,8,4,1,7,8,8,8,9,0,8
+Z,5,5,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+A,4,11,6,8,5,7,3,1,2,5,2,7,4,6,4,7
+R,7,9,10,8,10,8,8,4,4,8,4,7,8,6,7,6
+U,3,8,4,6,2,8,6,13,5,6,13,8,3,9,0,8
+O,5,9,6,7,3,8,8,9,8,6,8,9,3,8,4,8
+I,5,10,6,8,4,6,8,0,7,13,7,8,0,8,1,7
+Z,3,5,5,7,4,9,4,3,5,7,3,6,3,8,7,6
+V,6,11,5,6,3,9,10,5,4,7,10,5,4,11,3,6
+R,6,10,8,8,6,8,8,5,7,8,3,9,4,5,5,12
+N,7,9,9,8,9,8,7,5,4,7,5,7,7,9,6,5
+C,4,7,5,5,2,6,8,6,10,6,7,12,1,7,4,8
+F,3,8,6,6,6,11,6,1,5,9,5,6,4,10,4,7
+A,3,8,6,6,4,10,5,1,4,8,2,6,2,7,4,8
+X,3,6,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+A,3,5,5,5,4,9,8,2,4,7,7,7,4,8,4,5
+P,3,4,4,5,2,4,13,8,2,11,6,3,1,10,4,8
+W,6,9,6,6,6,3,11,2,3,10,10,8,6,11,2,7
+V,4,10,6,8,4,6,11,2,3,7,11,9,2,10,1,9
+Q,3,5,3,6,4,8,9,5,1,6,7,11,2,9,5,9
+B,5,10,5,8,4,6,8,9,7,7,6,7,2,8,9,10
+C,5,10,6,8,2,6,7,7,11,7,6,14,1,8,4,9
+L,4,8,4,6,2,0,1,5,5,0,1,6,0,8,0,8
+S,5,10,6,7,3,7,7,6,9,5,6,8,0,8,9,7
+V,2,2,4,3,1,7,12,2,3,7,11,9,2,10,1,8
+F,2,4,4,2,1,6,10,2,5,13,7,5,1,9,1,7
+E,4,9,4,6,2,3,8,6,10,7,6,14,0,8,7,7
+T,6,7,6,5,3,7,10,2,10,11,9,4,1,11,4,5
+Q,6,7,8,6,7,8,4,5,5,7,4,10,4,5,7,7
+Z,1,3,3,2,1,7,8,2,9,11,6,8,1,8,5,7
+K,1,0,1,0,0,5,7,7,1,7,6,11,2,8,2,11
+M,3,4,6,3,3,7,6,3,4,9,7,8,7,5,1,8
+E,1,3,2,2,2,7,7,5,6,7,6,8,2,8,5,10
+U,6,9,8,8,7,7,6,5,4,6,7,8,7,8,2,7
+D,3,8,3,6,2,5,7,10,8,6,6,5,3,8,4,8
+E,4,6,4,8,3,3,7,6,11,7,6,15,0,8,7,7
+W,9,11,9,9,7,7,11,4,3,8,6,6,11,13,4,4
+W,5,11,7,8,9,8,7,6,2,7,8,8,6,8,4,8
+H,4,4,5,3,4,6,7,6,6,7,6,10,3,8,3,9
+Q,3,4,4,5,4,8,7,7,3,6,6,9,2,8,5,9
+S,6,10,8,8,4,8,7,4,8,11,5,7,2,8,5,8
+G,3,2,5,4,3,6,6,6,6,6,6,9,2,9,4,9
+Z,4,10,5,7,4,6,8,6,10,7,7,10,1,9,8,8
+A,8,12,6,6,3,10,1,2,2,10,4,12,3,5,4,8
+R,4,9,5,6,3,5,12,8,4,7,3,9,3,7,6,11
+F,6,11,8,8,8,7,6,5,5,7,6,8,6,10,8,12
+Y,0,0,1,0,0,7,10,1,3,7,11,8,1,11,0,8
+L,4,10,6,7,7,6,7,3,6,7,7,11,5,11,6,5
+Z,5,8,6,6,5,9,11,6,6,6,5,9,3,8,8,5
+B,3,7,5,5,5,8,7,5,6,6,6,6,2,8,5,9
+V,3,3,4,2,1,3,12,4,3,11,11,7,2,11,1,8
+E,2,4,4,3,2,7,7,2,7,11,6,8,2,8,5,9
+E,7,13,5,7,4,9,5,4,5,11,4,9,3,9,7,11
+Y,3,4,4,3,1,4,11,2,7,11,10,5,1,11,2,5
+R,8,10,6,5,3,10,5,5,5,10,3,9,6,6,6,10
+P,1,1,2,1,1,5,11,7,1,9,6,4,1,9,3,8
+O,5,8,6,6,8,8,6,5,2,7,6,8,8,9,4,10
+Y,4,5,5,4,2,3,11,3,6,12,11,6,1,11,2,5
+Z,6,10,8,8,4,6,9,3,10,11,9,5,2,8,7,5
+H,3,8,5,6,6,8,7,4,2,6,6,7,6,8,8,7
+Y,7,10,7,8,4,4,10,2,8,10,11,6,2,10,4,3
+T,6,9,6,6,3,7,10,2,9,11,9,4,3,9,4,4
+P,2,4,3,2,2,5,10,4,4,9,8,5,3,10,3,7
+G,2,2,4,3,2,6,6,6,6,7,6,11,2,9,4,9
+W,7,8,7,6,6,4,12,3,2,9,8,7,6,12,2,6
+X,3,2,5,4,3,8,7,3,9,6,6,8,3,8,6,8
+D,5,9,8,6,5,10,6,5,8,10,3,5,3,8,4,9
+K,4,5,5,7,2,4,8,8,2,7,4,11,3,8,2,11
+J,3,9,5,6,3,7,7,3,6,15,5,9,1,7,1,7
+H,5,5,6,7,3,7,6,15,0,7,7,8,3,8,0,8
+T,2,5,4,7,1,5,14,1,6,9,11,7,0,8,0,8
+K,7,9,7,5,4,6,8,2,6,10,4,9,5,6,3,8
+X,4,8,6,6,3,5,8,2,8,10,10,9,3,8,3,6
+P,2,1,2,1,1,5,10,4,4,10,8,4,0,9,3,7
+S,3,6,4,4,3,8,7,7,5,7,6,8,2,8,9,8
+U,6,10,7,8,4,4,8,6,8,10,9,9,3,9,2,5
+S,3,8,4,6,2,8,7,5,9,5,6,7,0,8,9,8
+M,7,8,10,6,7,11,6,2,5,9,3,6,9,8,2,9
+Q,4,7,4,8,5,8,7,6,4,8,7,9,3,8,6,8
+D,6,14,6,8,5,8,6,4,6,9,5,7,5,9,7,6
+C,1,3,2,2,1,5,8,4,5,12,8,10,1,10,2,8
+N,4,2,5,4,3,7,8,5,5,7,7,7,5,9,2,6
+X,5,9,7,7,4,6,8,1,8,10,8,9,3,8,3,6
+P,7,10,9,8,5,9,8,3,7,13,3,3,2,10,4,9
+K,2,3,4,1,2,6,8,1,6,10,6,9,3,8,2,8
+T,3,6,4,4,2,9,11,2,9,5,11,8,1,10,1,8
+D,6,7,8,6,6,5,7,6,8,7,6,7,4,7,5,5
+U,8,10,8,8,5,3,8,5,7,10,10,9,3,9,2,6
+T,3,5,5,3,2,8,12,3,7,6,11,7,2,11,1,7
+I,1,10,2,8,3,7,7,0,7,7,6,8,0,8,3,8
+D,3,9,5,6,5,7,8,7,5,8,7,5,3,8,3,7
+T,2,4,3,5,1,7,14,0,6,7,11,8,0,8,0,8
+M,3,4,5,3,3,9,6,3,4,9,5,7,6,5,1,8
+H,3,8,4,5,2,7,8,15,1,7,5,8,3,8,0,8
+Z,5,11,7,8,5,8,7,2,9,12,6,7,1,7,6,7
+H,8,10,11,8,7,9,7,3,6,10,4,7,3,8,4,8
+I,1,5,3,4,1,7,7,0,8,13,6,8,0,8,1,7
+A,4,10,5,7,4,9,4,3,1,8,2,8,2,7,2,8
+G,3,4,4,3,2,6,7,5,5,9,7,10,2,9,4,9
+L,3,7,4,5,2,5,4,1,9,7,2,10,0,7,2,7
+O,3,5,4,3,2,8,7,8,5,7,7,8,2,8,3,8
+G,6,10,8,8,9,7,7,6,2,7,6,11,7,9,10,7
+W,3,6,4,4,3,9,10,2,2,6,9,8,6,11,1,8
+J,2,9,3,7,2,10,7,0,7,10,4,6,0,7,1,7
+N,10,12,8,6,4,4,8,4,6,3,2,12,6,11,2,7
+F,3,7,3,5,2,1,11,3,4,11,11,8,0,8,1,7
+S,3,2,3,3,2,8,8,6,5,7,6,7,2,8,9,8
+G,4,10,6,7,3,7,5,7,10,5,4,10,1,9,6,11
+H,5,9,7,7,5,9,7,3,6,10,5,7,3,8,3,9
+B,5,9,7,6,7,8,7,4,4,7,6,7,4,8,6,8
+W,5,7,7,5,4,5,8,5,1,8,10,9,8,11,0,8
+U,4,5,5,4,2,4,8,5,7,10,9,9,3,9,2,5
+S,8,15,6,9,3,8,4,4,5,8,2,8,4,6,6,9
+L,5,9,5,5,3,10,4,3,3,12,7,11,3,10,4,10
+W,4,9,6,6,3,6,8,4,2,7,8,8,8,10,0,8
+N,7,9,6,4,3,4,9,4,7,3,3,11,5,9,2,8
+O,2,1,2,2,1,7,7,7,4,7,6,8,2,8,2,7
+O,7,11,9,8,10,7,10,5,3,8,7,7,11,11,7,10
+L,7,14,7,8,4,6,5,4,5,12,9,11,3,9,7,8
+S,3,7,4,5,5,8,8,5,3,8,5,8,4,9,10,6
+B,6,9,9,7,6,10,6,3,7,11,3,7,6,8,7,11
+H,2,6,2,4,1,7,8,14,1,7,5,8,3,8,0,8
+G,3,1,4,2,2,7,7,6,6,6,6,9,2,9,4,9
+L,2,1,3,2,1,4,3,5,6,2,3,4,1,7,0,6
+Q,1,2,2,3,1,8,6,6,3,8,6,9,2,9,3,8
+M,4,5,5,7,4,8,7,12,2,6,9,8,8,6,0,8
+Z,2,4,3,3,1,8,6,2,9,11,5,8,1,8,5,8
+U,5,11,6,8,5,6,9,5,6,6,9,9,3,8,1,8
+V,3,5,4,4,5,8,8,5,4,7,6,8,6,8,7,4
+T,1,0,1,1,0,8,13,1,5,6,10,8,0,8,0,8
+T,4,10,6,7,7,7,8,5,5,6,7,9,6,8,8,6
+K,1,1,2,1,1,6,7,4,7,6,6,10,3,8,4,9
+O,2,4,3,3,2,7,7,7,4,9,6,8,2,8,3,8
+K,6,11,9,8,6,7,6,2,7,10,5,9,4,7,5,9
+U,3,6,5,4,3,6,9,5,7,7,9,9,3,9,1,8
+L,3,7,5,5,2,5,4,2,10,6,1,9,0,7,3,6
+R,10,15,8,8,5,9,7,7,5,10,2,9,7,5,6,10
+M,6,7,9,5,6,9,6,2,5,9,5,7,8,4,2,8
+A,2,2,4,3,2,6,2,2,2,5,2,8,2,6,2,6
+H,12,15,11,8,6,8,7,4,5,9,7,7,7,10,5,9
+J,5,9,6,7,3,10,6,1,7,14,3,7,0,7,0,8
+H,8,13,8,8,5,6,9,4,5,9,8,9,6,8,6,8
+M,7,11,11,8,8,7,6,3,5,9,8,9,8,6,2,8
+F,4,10,4,7,2,1,12,5,5,12,11,8,0,8,2,6
+S,4,8,5,6,4,7,9,7,7,8,4,6,2,7,9,9
+Y,8,7,6,10,4,9,7,6,6,4,10,7,5,10,3,7
+M,5,6,8,4,5,8,6,2,5,9,6,8,7,5,2,8
+O,2,5,3,4,2,8,7,7,4,9,4,8,2,8,2,8
+G,2,1,2,2,1,7,7,6,5,6,6,9,2,9,4,9
+L,1,4,3,3,1,6,5,1,6,8,3,10,1,7,2,9
+G,4,5,5,4,3,6,6,6,6,6,6,9,2,9,4,8
+X,2,3,3,4,1,7,7,4,4,7,6,8,3,8,4,8
+A,2,7,3,5,2,7,4,2,0,7,2,8,1,6,1,8
+S,4,6,5,8,2,8,7,6,9,4,6,7,0,8,9,8
+T,4,8,5,6,4,6,11,3,6,8,11,8,2,12,1,7
+T,9,13,8,7,4,8,6,4,10,13,5,7,2,9,6,6
+X,7,11,10,8,5,10,7,2,9,11,1,6,4,9,4,10
+C,2,4,3,3,1,4,9,4,7,11,9,12,1,9,2,7
+Z,4,6,5,4,3,7,8,2,9,11,8,6,1,8,6,6
+Z,4,11,5,9,6,7,7,5,10,7,5,9,3,10,9,8
+T,2,7,4,4,1,9,14,1,6,5,11,9,0,8,0,8
+V,3,2,5,4,2,6,12,3,4,8,12,8,3,10,1,8
+X,3,4,6,3,2,9,6,2,8,10,3,7,2,7,3,9
+L,3,3,3,5,1,0,1,6,6,0,1,5,0,8,0,8
+R,4,9,4,6,3,6,11,9,3,7,2,9,3,7,5,10
+H,7,11,10,8,8,9,7,3,6,10,4,7,6,8,5,8
+Q,5,8,7,9,7,9,7,7,2,5,8,9,5,9,7,11
+P,8,12,7,6,3,7,9,6,4,13,4,5,4,10,4,8
+J,2,7,4,5,2,7,7,3,5,15,6,9,1,6,1,7
+V,6,11,5,6,3,8,10,5,5,7,10,5,5,12,3,7
+Q,3,3,4,5,4,8,7,6,2,5,7,9,3,9,5,10
+S,4,5,6,4,5,10,8,5,5,6,8,9,4,11,6,10
+Y,3,5,5,7,1,9,10,3,2,6,13,8,2,11,0,8
+L,3,10,4,7,4,3,4,4,7,2,0,8,0,6,1,6
+L,5,11,6,8,4,3,4,4,9,2,0,7,0,7,1,5
+A,5,8,7,7,6,9,7,3,4,7,7,6,5,10,4,6
+X,8,13,8,7,5,7,6,2,8,11,4,8,4,5,4,7
+F,4,11,4,8,2,0,13,5,4,12,11,6,0,8,2,5
+M,4,10,5,8,6,7,5,11,1,7,9,8,8,6,1,9
+I,2,9,3,7,3,8,7,0,7,7,6,8,0,8,3,7
+H,3,4,6,3,3,8,8,3,6,10,6,7,3,8,3,8
+L,6,9,8,8,7,7,7,4,6,7,7,8,3,8,9,10
+E,2,1,3,3,2,7,7,5,7,7,6,9,2,8,5,10
+V,4,10,6,7,2,9,8,4,3,6,14,8,3,10,0,8
+G,4,9,5,6,2,7,6,8,8,6,5,10,2,8,5,11
+P,4,7,6,9,7,6,8,5,2,8,7,6,9,12,7,8
+G,5,9,7,8,8,7,9,5,2,7,7,8,6,11,7,9
+A,3,8,5,6,3,5,4,3,0,5,2,7,2,7,2,7
+S,5,10,6,8,3,8,8,6,10,5,6,6,0,8,9,7
+X,11,15,10,8,5,11,6,3,9,10,4,7,4,11,4,11
+I,2,9,3,6,2,6,8,0,7,14,7,8,0,8,1,7
+D,3,6,5,4,3,7,7,7,8,6,5,4,3,8,3,7
+L,2,2,3,4,2,4,4,4,7,2,1,6,0,7,1,6
+W,4,3,4,2,2,4,11,3,2,9,9,7,6,11,1,6
+A,3,2,6,4,3,8,1,2,2,7,2,8,2,7,3,7
+P,5,9,6,7,5,7,9,5,6,9,8,4,5,10,5,7
+A,4,6,6,6,5,7,8,2,4,7,7,9,5,7,3,7
+K,9,13,9,7,5,10,6,2,6,11,4,7,6,11,3,9
+N,3,7,5,5,3,5,10,6,4,7,7,9,5,9,1,8
+X,4,4,5,6,1,7,7,4,4,7,6,8,3,8,4,8
+T,5,10,7,8,6,7,7,7,6,5,10,10,5,6,9,7
+R,5,10,6,8,4,5,11,8,3,7,4,8,3,8,6,11
+P,6,10,9,8,5,7,12,7,3,11,4,2,2,11,4,8
+L,2,5,4,4,2,7,3,1,8,9,2,10,0,7,2,8
+X,5,9,8,7,5,4,8,1,8,10,11,10,3,9,3,5
+W,7,11,9,8,10,8,7,6,3,6,8,8,6,8,5,7
+P,5,11,8,8,6,8,9,3,5,13,5,4,4,10,4,8
+B,3,7,4,5,3,6,7,8,6,7,6,7,2,8,9,10
+C,2,1,3,2,1,6,7,6,7,8,7,13,1,9,4,10
+M,5,8,8,6,7,7,6,5,5,7,7,11,14,6,2,10
+S,8,13,6,7,3,9,1,2,5,8,2,8,3,7,5,11
+M,7,10,9,8,9,9,7,6,5,6,7,6,11,8,4,5
+H,3,7,5,5,6,8,7,4,3,6,6,7,7,8,8,8
+P,4,10,4,7,4,4,11,8,2,9,6,4,1,10,3,8
+W,6,6,6,4,4,5,11,3,2,9,7,7,7,12,2,6
+Z,3,5,4,7,2,7,7,4,13,10,6,8,0,8,8,8
+H,5,10,7,8,10,9,6,4,4,6,6,7,8,7,7,6
+U,4,9,6,7,4,7,9,5,7,5,9,9,3,9,1,8
+E,5,10,5,7,3,3,8,6,11,7,6,15,0,8,7,7
+Q,2,3,3,4,2,8,7,5,3,8,7,9,2,9,3,8
+O,3,5,4,4,3,8,7,7,4,9,5,8,2,8,2,8
+S,3,7,4,5,3,7,8,3,7,10,5,7,2,7,5,8
+M,4,5,6,4,6,6,8,5,3,6,5,8,9,7,4,8
+N,3,7,4,5,2,7,7,14,2,5,6,8,5,8,0,8
+E,2,3,3,2,2,8,7,1,7,11,5,8,2,8,4,10
+P,1,1,2,2,1,5,9,4,3,9,7,4,1,10,2,7
+H,6,9,9,7,8,6,8,3,6,10,7,8,3,8,3,7
+B,2,3,3,2,2,7,7,5,5,6,5,6,2,8,5,9
+W,6,11,10,8,6,5,10,2,3,8,9,9,8,11,1,8
+I,1,3,2,1,0,7,7,1,6,13,6,8,0,8,0,8
+R,5,11,6,8,4,6,9,10,5,7,5,8,3,8,6,10
+H,6,10,6,8,5,7,6,14,2,7,8,8,3,8,0,8
+W,6,5,8,7,4,4,8,5,2,7,9,8,9,9,0,8
+M,5,11,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+X,1,0,1,0,0,8,7,3,5,7,6,8,2,8,3,7
+H,2,5,4,3,3,7,7,2,5,10,6,8,3,8,2,8
+G,5,5,7,8,3,7,5,7,10,5,5,9,1,9,7,11
+V,3,7,5,5,2,7,12,3,4,6,12,8,2,10,1,8
+V,6,11,6,8,3,2,12,5,4,11,12,8,3,9,1,8
+B,3,5,4,4,4,7,7,5,5,6,6,6,2,8,6,9
+E,3,7,5,5,3,10,6,2,7,11,4,9,2,8,5,12
+W,6,7,6,5,4,6,11,4,2,8,7,6,6,12,2,5
+W,7,7,10,6,10,8,8,5,5,7,5,8,9,8,9,6
+O,5,9,6,6,4,8,6,8,4,7,4,8,3,8,3,8
+Z,3,9,4,6,3,7,7,3,12,9,6,8,0,8,8,8
+Y,6,6,5,9,4,7,7,4,3,6,11,6,4,11,6,6
+Z,1,0,2,1,0,7,7,2,10,8,6,8,0,8,6,8
+W,5,11,8,8,4,4,8,5,2,7,9,8,8,10,0,8
+T,2,6,4,4,1,9,15,1,5,5,11,9,0,8,0,8
+H,3,5,4,4,3,7,7,6,6,7,6,8,3,8,3,8
+D,5,10,7,8,6,7,7,8,5,7,6,5,4,8,3,7
+Z,3,7,5,5,3,8,7,2,9,11,5,10,1,9,6,10
+X,6,11,9,8,6,5,8,1,8,10,10,10,3,8,4,6
+J,1,3,2,2,1,10,6,3,6,12,4,10,0,7,1,8
+V,1,0,2,0,0,8,9,3,2,7,12,8,2,10,0,8
+H,3,7,5,5,6,7,6,5,4,6,6,8,6,8,8,10
+H,6,11,6,8,6,7,8,14,1,7,5,8,3,8,0,8
+R,7,11,9,8,9,8,6,7,5,8,6,8,7,7,6,12
+B,5,9,7,7,5,9,7,4,6,10,5,6,2,8,6,10
+X,5,9,6,8,7,9,8,2,5,8,5,6,4,7,9,8
+J,4,11,6,8,2,9,6,2,7,15,4,9,0,6,1,7
+Q,5,9,6,10,6,8,11,6,2,5,8,12,3,11,7,6
+E,4,5,4,8,3,3,7,6,10,7,6,14,0,8,7,7
+T,3,3,4,2,1,6,11,3,6,11,9,4,2,11,2,5
+U,3,3,4,2,1,6,8,6,7,7,10,9,3,10,1,8
+Q,5,7,7,10,9,9,9,5,0,6,7,10,8,14,5,11
+Q,4,5,4,6,4,8,9,5,1,7,8,11,2,9,5,8
+E,5,12,4,6,3,8,7,4,4,10,6,8,3,9,8,10
+X,5,9,8,7,4,7,8,1,8,10,7,8,3,8,4,7
+P,4,10,6,8,5,4,10,3,6,11,10,6,3,10,3,7
+C,5,10,6,7,4,5,7,6,9,7,6,13,1,8,4,9
+S,1,0,1,0,0,8,7,3,5,5,6,7,0,8,6,8
+Y,4,4,5,6,6,9,8,5,3,7,8,7,6,10,6,4
+O,5,10,7,7,5,7,8,8,5,7,7,9,3,7,4,7
+U,11,14,9,8,4,4,3,5,5,4,7,7,6,6,2,6
+E,5,11,4,6,3,6,9,4,5,10,6,8,3,8,7,9
+D,4,10,6,8,10,9,8,5,5,7,6,6,5,6,7,6
+P,3,4,5,3,2,7,10,3,4,12,4,2,1,10,2,8
+D,5,4,5,6,3,5,8,10,9,7,7,5,3,8,4,8
+X,2,5,3,3,2,7,7,3,9,6,6,8,2,8,6,8
+F,6,11,6,6,4,6,10,3,4,11,6,4,4,10,8,6
+Y,1,0,2,1,0,7,10,3,1,7,13,8,1,11,0,8
+P,9,13,9,7,6,11,6,3,4,12,4,6,5,9,6,9
+J,6,11,8,8,3,8,6,4,6,15,6,11,1,6,1,6
+D,2,3,3,2,2,10,6,3,6,10,3,6,2,8,3,9
+Q,1,2,2,2,1,8,8,5,2,8,7,10,2,9,3,9
+S,7,10,5,5,2,9,3,4,4,9,2,9,3,6,5,10
+T,6,8,6,6,4,7,11,3,8,12,9,4,2,12,3,4
+D,6,9,9,8,8,6,6,5,7,7,6,8,5,6,6,4
+U,2,1,3,2,1,6,8,6,6,6,9,9,3,9,1,7
+N,3,4,5,2,2,9,7,3,4,10,3,5,5,9,1,7
+H,1,0,2,0,0,7,8,11,1,7,6,8,2,8,0,8
+U,3,3,4,2,1,7,9,6,7,7,10,9,3,10,1,8
+W,2,1,2,2,1,7,8,4,0,7,8,8,6,10,0,8
+F,2,3,2,2,1,5,10,3,5,10,9,5,1,10,3,6
+H,5,9,6,7,5,7,8,13,1,7,6,8,3,8,0,8
+R,5,11,7,8,6,8,8,5,6,9,4,8,3,7,5,11
+O,5,9,5,7,5,7,7,7,4,9,7,8,3,8,3,8
+S,7,10,8,8,4,9,7,4,9,11,6,7,2,10,5,8
+Y,10,9,8,13,5,7,9,2,2,7,10,4,4,10,7,7
+W,6,9,8,7,12,10,7,5,2,7,7,8,11,10,3,5
+O,2,4,2,3,1,7,7,6,4,9,6,8,2,8,2,8
+G,3,4,4,6,2,7,8,8,7,5,7,8,2,7,6,11
+T,5,10,5,7,4,4,12,3,5,11,10,5,2,13,2,4
+G,1,0,2,1,0,8,6,6,4,6,5,9,1,8,5,10
+S,3,4,3,3,2,8,6,6,5,7,6,9,2,10,9,8
+E,2,0,2,1,1,5,7,5,8,7,6,12,0,8,7,9
+A,4,10,6,8,3,10,3,2,3,9,1,8,2,7,4,9
+J,1,3,2,2,1,10,6,2,5,12,4,9,0,7,0,7
+N,5,7,7,5,4,7,9,2,5,10,5,6,5,9,1,7
+B,3,2,3,3,3,7,7,5,5,6,6,6,2,8,6,9
+R,4,9,6,6,6,6,7,3,5,6,5,9,6,10,7,5
+G,4,6,5,4,6,8,5,4,3,7,6,10,6,8,4,10
+T,2,5,3,3,1,8,12,2,7,6,11,7,1,11,1,7
+C,5,10,6,8,2,6,6,7,11,9,5,14,1,9,4,8
+E,4,8,6,6,6,7,7,5,8,7,7,9,3,8,6,9
+U,4,8,6,6,5,7,7,8,5,6,6,10,4,8,5,6
+I,4,10,7,8,8,10,6,2,4,8,4,4,3,8,5,7
+P,3,2,4,3,2,5,10,4,4,10,8,4,1,10,3,6
+C,7,10,7,7,5,4,8,5,7,12,9,12,2,10,4,6
+C,7,10,7,8,4,3,8,6,7,12,11,12,2,9,2,7
+P,3,6,5,4,3,6,11,3,5,13,6,4,0,10,2,8
+A,1,1,2,2,1,7,3,2,1,6,2,8,1,6,1,7
+G,3,5,4,7,2,7,6,8,9,8,4,13,1,9,5,10
+H,4,7,5,5,4,8,7,6,6,7,6,9,6,8,3,8
+N,4,5,5,4,3,7,8,5,5,8,7,7,7,9,3,5
+W,6,6,6,4,4,3,11,2,3,10,10,8,7,11,1,7
+W,5,9,7,7,8,8,8,6,3,6,8,8,6,7,4,7
+N,3,2,4,3,3,7,8,5,4,7,6,6,5,9,2,6
+S,5,8,6,6,3,9,7,4,8,11,4,8,2,8,5,9
+F,1,0,1,0,0,4,12,4,2,11,8,6,0,8,2,8
+K,2,3,3,2,1,6,7,2,6,10,7,10,3,8,2,8
+B,4,8,6,6,4,8,8,4,7,10,5,6,2,8,6,10
+Y,2,2,4,3,2,6,10,1,7,8,12,8,2,11,2,7
+E,7,9,9,8,9,7,8,5,5,7,7,10,8,9,10,9
+Z,6,11,8,8,8,10,9,5,4,7,5,7,3,8,9,5
+X,4,8,6,6,4,8,7,3,8,5,6,6,3,8,6,7
+O,5,11,5,9,6,8,7,8,3,9,6,7,3,8,3,8
+V,4,11,5,8,3,5,11,3,4,9,12,9,2,10,1,8
+R,3,6,4,4,3,10,7,3,5,10,3,7,3,7,3,11
+L,3,7,4,5,3,7,4,1,7,8,2,10,0,7,2,8
+V,6,8,6,6,3,3,12,4,4,10,12,7,2,10,1,8
+H,5,8,7,6,8,7,6,5,5,6,6,7,8,7,8,9
+P,2,4,3,3,2,9,8,3,4,12,4,3,1,10,3,9
+L,1,3,2,1,1,6,4,1,7,8,3,10,0,7,2,8
+Q,3,5,3,6,3,8,8,5,2,8,8,11,2,9,5,8
+D,3,2,4,3,3,7,7,7,7,7,6,5,2,8,3,7
+V,3,6,4,4,2,8,9,4,2,7,12,8,2,10,0,8
+H,5,9,6,7,6,7,5,13,2,7,9,8,3,9,0,8
+G,7,13,6,8,5,7,6,4,3,8,6,8,4,9,9,7
+V,2,3,3,1,1,6,12,3,2,8,11,8,2,11,1,8
+P,4,6,6,4,3,7,10,4,4,12,5,3,1,10,2,8
+K,4,5,5,8,2,4,8,8,2,7,4,11,4,8,2,11
+U,6,9,6,7,4,3,8,5,7,10,9,9,3,9,2,6
+U,4,7,6,5,5,9,6,7,5,7,7,8,5,8,4,6
+Y,5,10,6,7,6,9,5,7,5,6,9,7,3,9,9,4
+D,5,11,6,8,6,6,7,9,7,6,5,5,2,8,3,7
+F,5,11,7,8,4,6,11,2,6,13,7,4,1,10,2,7
+I,1,5,2,4,1,7,7,0,7,13,6,8,0,8,1,8
+N,2,1,2,2,1,7,9,5,4,7,6,7,4,8,1,6
+L,5,11,7,9,6,8,4,0,7,9,3,10,1,6,2,9
+N,6,10,9,8,4,3,9,4,4,11,11,10,6,7,1,8
+E,2,6,3,4,2,3,6,6,10,7,6,14,0,8,7,8
+N,5,10,7,5,3,8,7,2,4,12,8,8,5,8,0,8
+M,3,3,5,2,3,7,6,3,4,9,7,8,7,5,1,8
+B,5,7,7,5,5,8,8,4,6,10,5,6,3,8,6,10
+U,5,5,6,8,2,8,4,15,6,7,14,8,3,9,0,8
+B,5,8,7,6,5,10,5,3,7,10,4,7,3,7,6,11
+T,4,4,4,3,2,5,11,2,8,12,9,4,1,10,2,4
+G,6,8,8,7,8,8,6,6,4,7,6,10,10,10,8,9
+N,3,7,5,5,5,7,7,3,4,8,8,8,6,9,4,5
+S,3,9,4,7,4,7,7,7,5,7,7,9,2,9,8,8
+B,11,13,8,7,5,9,6,5,6,11,4,9,6,7,7,11
+O,9,13,6,7,4,5,7,7,4,10,7,8,5,9,5,7
+N,7,10,10,8,10,6,8,3,4,8,8,9,8,10,7,4
+F,4,11,6,8,4,3,11,2,7,11,10,6,1,10,3,5
+J,3,9,5,6,2,7,5,4,5,14,7,12,1,6,1,6
+L,1,4,2,3,1,7,3,1,6,8,2,10,0,7,2,8
+G,2,3,3,2,1,6,7,5,5,9,7,10,1,8,4,10
+P,5,11,6,8,7,6,7,5,4,8,7,8,8,8,6,11
+C,2,6,3,4,2,5,8,6,6,6,7,14,1,8,3,10
+E,3,5,4,3,3,7,7,5,8,6,5,8,2,8,6,9
+U,3,4,4,3,2,4,8,5,6,11,10,9,3,9,1,7
+M,5,9,8,7,6,4,7,3,4,10,10,10,8,6,3,7
+L,4,10,5,7,4,4,4,3,8,2,1,7,0,6,1,6
+A,5,12,5,6,4,11,2,4,2,11,4,11,5,4,5,10
+C,5,9,6,8,7,5,6,4,5,7,6,11,6,10,9,10
+M,5,8,6,6,3,7,7,12,2,7,9,8,8,6,0,8
+L,5,11,8,9,9,7,8,3,6,5,7,11,5,11,9,7
+M,8,10,11,7,9,5,7,3,5,9,9,9,9,7,3,8
+T,5,7,7,6,7,7,8,4,8,8,7,9,3,8,8,6
+F,2,5,4,4,1,5,13,3,5,13,7,3,0,9,2,6
+N,4,8,5,6,4,7,7,13,1,6,6,8,5,8,0,8
+J,5,9,7,7,6,7,7,5,5,8,6,7,6,7,4,7
+P,6,8,8,10,9,6,8,4,2,8,8,6,7,12,7,7
+B,8,14,7,8,6,10,7,3,6,10,4,7,6,6,7,9
+A,3,2,5,4,2,8,2,2,2,8,1,8,2,6,3,7
+G,7,12,6,6,4,8,3,4,3,7,4,4,4,7,5,8
+Z,4,9,4,6,3,7,10,3,11,8,6,7,0,8,7,7
+U,4,4,5,3,2,4,8,5,7,12,10,9,3,9,2,7
+P,9,15,7,8,4,5,11,6,2,11,6,4,5,10,4,7
+Y,4,11,5,8,3,8,11,1,3,7,12,8,1,11,0,8
+A,3,8,6,6,3,12,2,3,2,10,2,9,2,6,3,8
+T,6,11,8,8,7,7,7,7,7,5,9,10,6,7,9,4
+X,3,6,5,4,3,6,8,1,8,10,8,9,2,8,3,6
+S,4,7,4,5,3,7,8,4,7,10,5,7,2,7,4,8
+K,6,10,5,5,3,7,8,3,6,9,9,9,6,11,3,6
+Z,1,1,2,2,1,7,7,4,8,6,6,8,1,8,6,8
+P,5,9,5,6,3,5,12,9,2,9,5,4,1,10,4,8
+E,1,0,1,0,0,5,7,5,7,7,6,12,0,8,6,9
+Y,7,8,7,6,4,5,8,1,7,8,9,5,2,11,3,4
+X,3,3,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+Q,6,11,6,6,4,11,4,4,5,11,4,8,3,9,6,12
+Y,3,5,5,4,2,7,11,1,8,6,11,8,1,11,2,8
+X,3,5,5,4,2,10,7,1,8,11,3,7,2,8,3,9
+Z,7,9,7,5,4,9,4,3,8,12,5,10,3,8,6,8
+O,8,10,6,5,3,8,6,5,5,8,4,8,5,9,5,8
+Y,2,2,4,4,2,7,10,1,7,7,11,8,1,11,2,8
+G,4,8,5,6,2,7,6,7,8,6,6,9,1,8,6,11
+Z,5,9,7,7,6,10,9,6,4,7,5,8,3,8,10,7
+N,4,7,6,5,4,7,9,6,5,7,6,6,6,9,1,6
+W,7,9,7,4,3,5,10,2,2,9,10,8,8,12,0,7
+H,3,3,5,2,2,8,7,3,6,10,4,7,3,7,3,8
+X,2,0,2,1,0,7,7,6,2,7,6,8,3,8,3,8
+V,3,9,5,7,3,8,9,4,1,7,12,8,2,10,0,8
+S,4,9,6,6,7,5,8,3,1,7,6,5,3,8,9,1
+M,8,9,11,6,9,8,6,2,5,9,7,8,8,6,2,8
+Y,4,4,5,3,2,4,10,2,8,10,10,5,3,11,4,3
+S,3,4,4,6,2,9,9,6,10,5,5,5,0,7,9,7
+U,3,7,5,5,4,8,9,8,5,4,7,11,3,7,3,7
+Q,4,9,5,8,3,8,6,9,5,6,6,8,3,8,5,9
+X,4,7,6,5,3,7,8,1,8,10,7,8,2,8,3,7
+H,5,9,6,4,4,4,9,3,4,10,9,9,4,8,4,6
+V,2,1,4,2,1,6,12,2,3,8,11,8,2,11,1,8
+C,4,7,5,5,2,5,9,7,8,8,8,14,1,8,4,9
+L,1,3,2,2,1,7,4,1,7,8,2,9,0,7,2,8
+S,3,9,4,7,2,7,7,6,8,5,6,7,0,8,9,7
+L,2,7,2,5,1,0,1,5,6,0,0,7,0,8,0,8
+P,7,9,9,7,5,7,12,8,3,10,5,3,2,11,5,8
+J,0,0,1,0,0,12,4,5,3,12,4,10,0,7,0,8
+T,3,3,4,2,2,6,11,3,7,11,9,5,1,11,3,4
+T,1,0,2,0,0,7,15,2,4,7,10,8,0,8,0,8
+T,2,3,2,2,1,7,11,2,6,7,10,8,1,11,1,7
+B,4,5,5,4,4,7,7,5,6,7,6,6,2,8,6,10
+L,5,10,6,8,4,5,3,6,9,1,1,4,1,6,1,5
+I,1,4,2,3,1,7,7,0,7,13,6,8,0,8,1,8
+P,1,3,3,2,1,8,7,4,3,11,4,5,1,9,2,9
+I,6,8,8,9,7,7,8,4,7,6,8,7,4,8,11,9
+C,3,8,4,6,2,4,8,7,9,9,9,13,1,9,4,9
+I,3,10,4,8,2,7,7,0,8,14,6,8,0,8,1,8
+L,2,3,3,5,1,0,1,5,6,0,0,7,0,8,0,8
+N,2,1,3,2,2,7,9,6,5,8,7,6,5,9,1,6
+M,4,1,5,2,3,8,6,6,4,7,7,8,8,6,3,6
+X,2,1,2,1,0,7,7,4,4,7,6,8,2,8,4,8
+A,7,11,5,6,3,10,1,3,1,10,4,12,3,4,4,8
+Q,6,10,7,9,4,8,7,8,7,6,7,9,3,8,5,9
+M,4,7,5,5,5,8,7,5,5,6,6,5,8,7,2,6
+Z,3,4,5,6,4,9,7,5,5,9,3,6,2,6,6,7
+V,6,9,4,4,2,8,10,5,4,7,10,5,4,11,3,7
+A,3,11,5,8,3,13,3,4,3,12,1,9,2,6,3,9
+L,3,10,3,7,1,0,1,5,6,0,0,7,0,8,0,8
+Y,3,11,5,8,1,5,10,3,2,9,13,8,1,11,0,8
+Q,4,4,5,6,2,9,8,8,6,5,7,10,3,8,5,9
+C,4,8,6,6,6,7,7,4,4,6,7,10,7,9,5,7
+S,3,4,4,2,2,7,8,2,7,10,7,7,1,8,5,6
+C,3,6,4,4,1,6,7,7,10,8,6,13,1,9,4,9
+N,5,9,6,6,5,7,7,9,5,6,4,5,5,8,5,11
+K,3,6,5,4,4,6,6,3,8,6,6,9,3,8,5,9
+E,9,11,6,6,3,8,7,5,7,10,6,11,2,9,8,8
+S,4,8,6,6,3,9,7,5,8,11,2,8,2,7,5,11
+S,2,4,3,3,2,8,8,7,5,8,5,7,2,8,8,8
+X,6,10,9,7,5,7,8,1,9,10,6,8,3,8,4,7
+K,4,10,4,8,4,3,7,6,3,6,5,11,3,8,2,11
+B,2,3,4,2,2,7,7,3,5,10,6,6,2,8,5,8
+F,5,11,7,8,5,9,8,1,6,13,5,5,2,9,3,9
+M,3,4,5,2,3,9,6,3,4,8,5,7,7,5,1,8
+X,4,7,6,5,3,4,9,2,7,10,11,9,3,9,3,5
+C,3,1,4,3,2,6,8,7,7,8,8,13,1,10,4,10
+E,4,6,5,4,3,6,8,4,8,12,8,9,2,9,4,6
+U,4,5,5,4,2,4,8,5,7,11,10,9,3,9,2,6
+I,6,11,7,8,5,7,7,1,7,7,6,8,0,8,4,8
+T,4,9,4,4,2,4,11,2,6,12,8,5,2,8,4,3
+A,2,4,3,3,2,10,2,2,2,9,2,9,1,6,2,8
+H,2,6,3,4,1,7,9,14,2,7,4,8,3,8,0,8
+P,5,11,8,8,5,6,11,3,6,14,7,4,0,10,3,8
+E,3,5,5,3,3,6,8,2,8,11,8,9,2,9,4,7
+D,7,15,7,9,5,9,6,5,6,12,3,7,5,7,6,10
+I,5,11,7,8,4,9,6,2,7,7,6,6,0,9,4,7
+N,5,10,5,8,5,7,7,12,1,6,6,8,6,7,1,10
+P,2,7,4,5,2,5,11,3,6,11,9,5,0,9,3,6
+T,5,9,5,6,4,5,12,4,6,11,9,4,2,12,2,4
+D,3,9,5,7,8,10,7,5,5,7,5,6,4,6,10,6
+G,4,6,6,5,5,8,10,5,2,7,7,9,6,11,7,10
+C,4,6,5,4,2,4,9,5,7,11,10,12,1,9,3,7
+Y,4,6,6,8,8,9,8,4,2,6,8,9,4,11,7,8
+D,2,1,2,1,1,7,7,6,6,7,6,5,2,8,2,7
+P,2,3,2,2,1,6,10,5,4,9,7,3,1,9,3,6
+X,2,5,4,4,2,7,7,3,9,6,6,8,2,8,6,8
+B,4,7,6,5,4,8,8,4,6,10,5,6,2,8,6,8
+F,2,2,3,3,2,6,10,4,5,10,9,5,2,9,3,6
+Z,2,5,4,4,2,7,8,2,10,12,7,7,1,8,5,6
+P,6,9,9,7,4,5,15,6,2,12,5,1,0,9,4,7
+J,3,9,4,7,3,11,6,3,6,12,2,8,1,6,2,6
+B,3,9,4,7,3,6,7,10,6,7,6,7,2,8,9,10
+C,3,8,4,6,2,5,7,6,8,8,6,12,1,9,4,9
+B,4,9,4,4,3,9,6,3,4,9,5,8,6,8,7,9
+U,3,3,3,5,2,7,6,13,5,7,14,8,3,9,0,8
+O,6,9,7,7,6,7,8,7,5,9,7,9,3,8,4,7
+M,6,9,8,6,8,6,6,6,5,7,7,11,11,5,2,9
+D,3,10,5,8,7,8,9,5,4,8,7,5,4,9,11,6
+D,5,6,6,8,3,5,7,11,9,6,5,5,3,8,4,8
+P,2,3,4,1,1,8,9,3,4,12,4,3,1,9,2,9
+P,3,5,5,4,2,7,10,5,3,11,4,3,1,10,3,8
+Y,5,9,5,7,3,3,11,3,6,11,12,6,1,11,2,6
+F,2,5,3,3,2,5,10,3,5,10,9,6,2,10,3,6
+I,1,6,2,4,1,7,7,0,8,7,6,8,0,8,3,8
+B,3,2,4,4,4,7,7,5,5,7,6,6,2,8,6,10
+F,5,10,6,8,7,6,10,6,4,8,5,9,3,10,8,11
+U,3,7,5,5,4,7,8,8,5,5,6,11,3,8,5,6
+B,3,7,4,5,3,6,5,9,7,6,7,7,2,9,8,9
+A,9,15,9,8,6,11,2,5,2,11,4,11,7,2,5,11
+Z,4,8,6,6,6,8,8,2,8,7,6,7,0,8,9,8
+E,5,11,6,8,7,7,7,6,3,7,6,9,4,8,8,8
+E,1,0,1,1,1,5,7,5,8,7,6,12,0,8,6,9
+A,1,0,2,0,0,7,4,2,0,7,2,8,1,6,1,8
+M,6,7,9,5,5,8,6,2,5,9,6,7,8,6,2,8
+J,5,9,6,7,4,9,4,7,6,8,6,6,2,7,4,6
+T,4,4,4,3,2,6,12,3,7,11,9,4,1,11,2,4
+W,8,10,8,8,6,5,10,3,3,9,8,7,8,11,3,6
+K,4,7,6,5,5,6,6,4,6,6,5,8,7,7,7,9
+M,5,11,7,8,8,9,7,5,4,6,7,5,9,7,3,5
+N,5,8,7,7,7,8,8,5,5,8,5,6,6,10,7,2
+W,3,3,5,5,3,6,8,4,1,7,8,8,8,9,0,8
+D,3,9,5,7,4,8,7,7,7,7,7,4,3,8,3,7
+H,4,6,6,8,6,9,5,3,2,7,5,7,4,8,6,9
+H,3,4,4,3,3,7,7,6,6,7,6,8,3,8,3,8
+M,8,10,11,8,9,12,6,2,5,9,3,6,10,4,2,8
+R,5,9,5,4,4,7,8,3,5,8,4,9,5,7,6,7
+B,6,10,8,8,7,9,7,2,7,10,4,7,4,7,5,10
+O,6,10,7,8,6,8,6,8,4,9,5,6,5,8,4,9
+R,5,11,7,8,7,9,8,3,5,10,4,7,5,5,4,10
+F,5,9,8,7,5,9,8,1,6,13,5,5,3,9,3,9
+U,4,7,6,5,7,8,7,4,4,6,7,8,7,10,5,7
+Z,2,4,4,2,2,7,7,2,9,12,6,8,1,8,5,7
+H,5,11,7,8,10,8,7,4,3,6,6,7,7,8,9,8
+P,4,8,5,6,4,7,9,8,4,8,6,3,3,10,3,6
+H,2,3,4,1,2,7,7,3,5,10,6,8,3,8,3,8
+T,3,7,4,5,2,5,14,1,5,9,10,7,0,8,0,8
+B,1,0,1,0,1,7,8,6,4,7,6,7,1,8,6,9
+O,3,2,4,3,3,8,7,8,5,7,6,8,2,8,3,8
+D,4,8,6,6,8,9,7,4,7,7,6,5,5,5,7,7
+S,2,4,3,3,1,9,7,3,6,10,6,7,1,9,5,8
+C,3,8,4,6,2,6,8,7,10,6,7,12,1,7,4,9
+N,2,0,2,1,0,7,7,11,0,5,6,8,4,8,0,8
+D,2,4,3,3,2,9,6,3,5,10,4,6,3,7,2,8
+A,2,5,4,4,2,8,3,2,2,8,2,8,2,6,2,7
+S,4,8,5,6,4,8,6,7,7,7,8,8,2,10,9,8
+K,3,4,4,5,1,4,7,8,2,7,5,11,4,8,2,11
+W,4,7,5,5,3,5,8,5,1,7,8,8,8,9,0,8
+R,4,6,7,5,7,9,6,4,4,8,5,7,6,9,6,7
+H,4,5,5,7,3,7,7,15,0,7,6,8,3,8,0,8
+U,4,8,6,6,8,9,7,4,5,6,8,8,8,8,6,6
+N,5,9,7,6,5,9,8,6,6,6,5,4,7,11,3,5
+X,5,7,8,5,3,9,6,2,8,11,2,7,3,8,4,9
+O,5,8,6,6,4,8,6,8,5,10,5,8,3,8,3,8
+L,2,4,4,3,1,6,4,1,8,8,2,10,0,7,2,8
+B,3,5,4,4,5,7,7,5,4,7,6,8,6,9,6,9
+E,4,7,6,5,4,10,6,2,8,11,3,9,2,8,5,12
+B,4,9,5,6,4,6,8,9,7,7,6,7,2,8,9,9
+V,4,7,6,6,6,6,9,5,6,8,6,8,6,9,7,6
+N,4,6,5,4,3,7,9,2,4,9,7,7,5,8,1,8
+X,3,6,4,4,2,7,7,4,4,7,6,7,3,8,4,8
+X,2,3,3,2,1,9,7,3,8,6,6,6,2,8,5,8
+B,2,3,4,2,2,8,7,3,5,10,5,7,2,8,4,9
+O,4,7,5,5,3,7,8,8,5,10,6,6,3,8,3,8
+D,3,5,4,4,3,7,7,7,7,6,6,5,2,8,3,7
+S,6,11,7,8,4,8,7,4,8,11,5,7,2,8,5,8
+I,1,4,2,3,1,7,8,0,7,13,6,8,0,8,1,7
+N,5,10,8,8,5,5,10,3,4,9,9,8,5,9,1,7
+S,3,8,5,6,6,6,7,3,2,7,6,6,2,8,10,1
+U,6,11,8,8,5,8,9,4,6,5,8,9,6,9,2,8
+T,3,8,5,6,3,7,12,4,6,7,11,8,2,12,1,8
+G,4,8,5,6,4,7,6,7,7,7,4,11,1,8,5,11
+J,3,9,4,7,4,10,6,2,5,9,4,6,3,7,7,8
+W,3,2,5,3,3,5,11,3,2,8,9,9,7,11,0,8
+S,2,3,3,2,1,7,8,2,7,11,7,8,1,9,4,6
+S,5,11,6,9,5,8,7,8,6,8,6,7,2,8,9,8
+M,4,9,5,6,3,7,7,12,1,7,9,8,8,6,0,8
+I,2,7,3,5,2,6,8,0,7,13,7,8,0,8,1,7
+E,1,0,1,1,0,4,7,5,7,7,6,12,0,8,6,10
+H,4,10,4,7,3,7,6,15,2,7,8,8,3,8,0,8
+Q,4,10,5,9,3,8,7,8,6,6,7,8,3,8,6,9
+T,5,7,5,5,3,7,10,2,7,11,9,5,1,11,3,5
+H,3,5,6,4,4,8,8,3,6,10,6,8,3,8,3,8
+A,3,2,6,4,2,8,2,2,2,6,2,7,3,7,3,7
+Z,3,2,4,4,3,7,7,5,9,6,6,8,1,8,7,8
+R,4,6,6,4,4,10,7,3,6,11,2,7,3,6,3,10
+M,4,5,7,3,4,8,6,3,4,9,6,8,8,6,2,8
+I,2,5,3,4,1,7,7,0,7,13,6,8,0,8,1,8
+C,5,8,5,6,3,5,7,5,6,11,8,13,2,9,4,8
+M,4,4,5,6,3,7,7,12,1,7,9,8,8,6,0,8
+K,3,4,4,3,3,6,7,4,8,7,6,11,3,8,5,10
+R,4,8,6,6,5,9,7,3,5,10,3,7,3,6,4,10
+Y,4,10,5,7,1,7,11,2,3,7,12,8,1,11,0,8
+Q,4,8,5,7,3,8,7,8,6,6,7,8,3,8,5,9
+P,2,4,4,2,2,8,9,4,3,12,4,4,1,10,2,9
+W,8,12,8,6,5,2,9,2,3,9,11,9,8,11,1,5
+J,3,10,4,8,2,14,3,5,4,13,2,10,0,7,0,8
+E,6,10,9,8,7,10,6,2,7,11,5,8,6,8,6,11
+V,6,10,6,8,4,2,11,2,3,9,11,8,3,11,1,7
+F,4,7,5,5,3,5,11,4,6,11,10,5,2,10,3,5
+I,3,8,4,6,2,7,9,0,8,14,6,6,0,9,1,7
+N,4,8,4,6,2,7,7,14,2,4,6,8,6,8,0,8
+K,5,10,7,7,5,5,6,5,8,6,6,12,4,7,6,11
+I,3,10,4,7,3,8,7,0,7,13,6,8,0,8,1,8
+Z,3,4,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+I,1,3,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+Y,6,9,5,5,3,7,7,3,5,9,7,6,3,10,4,5
+V,6,10,6,7,3,3,11,3,4,10,12,8,2,10,1,8
+L,3,7,4,5,2,4,4,3,8,2,1,7,0,7,1,6
+U,3,2,3,4,1,8,5,12,5,6,14,8,3,9,0,8
+C,4,10,5,8,2,5,7,7,10,6,6,13,1,7,4,9
+O,4,9,4,7,4,8,5,7,4,10,5,10,4,8,4,7
+L,6,15,6,8,4,5,7,4,6,12,9,12,3,8,7,7
+B,6,9,8,6,5,10,6,3,8,11,3,7,2,8,5,12
+A,4,7,7,5,4,6,5,2,3,4,2,6,4,6,4,5
+S,6,13,5,7,3,11,2,1,5,10,1,8,2,8,4,12
+J,4,11,6,8,3,8,5,5,6,14,7,12,1,6,1,7
+A,2,8,4,5,2,7,6,3,1,6,0,8,2,7,2,7
+I,1,2,1,3,1,7,7,1,8,7,6,8,0,8,3,8
+T,6,8,6,6,4,5,11,3,7,11,9,5,2,12,2,4
+P,4,7,5,5,3,5,12,5,5,11,9,3,0,9,4,6
+G,5,10,7,8,8,9,6,5,2,6,6,10,8,8,5,10
+J,3,6,4,4,1,10,4,6,5,15,5,12,0,7,1,6
+B,6,13,6,7,6,7,7,4,4,9,7,8,7,6,9,8
+B,2,4,3,3,2,8,7,3,5,9,6,7,2,8,4,9
+I,2,10,2,7,2,7,7,0,8,7,6,8,0,8,3,8
+N,3,8,5,6,4,7,8,6,5,7,6,7,5,9,1,6
+B,5,8,7,6,7,8,7,6,6,9,6,6,5,10,7,9
+X,5,11,7,8,6,7,6,3,9,5,7,10,4,7,8,8
+Z,3,9,4,6,3,7,7,3,12,9,6,8,0,8,7,8
+U,6,10,5,5,4,8,6,4,4,7,7,7,5,7,3,7
+P,3,4,5,3,2,8,9,3,5,13,4,3,2,8,3,7
+R,7,9,6,5,4,7,7,5,5,9,4,9,6,5,7,11
+K,3,3,3,4,1,3,6,7,3,7,7,11,3,8,2,10
+A,2,1,4,3,2,8,2,2,1,7,2,8,2,6,2,7
+N,5,7,6,6,6,8,9,4,4,7,4,7,6,8,5,5
+N,5,9,7,6,4,8,8,7,6,7,6,4,6,9,2,6
+P,4,11,4,8,2,3,14,8,2,12,7,3,0,10,4,8
+Q,3,5,5,5,4,7,4,4,4,5,3,7,3,7,4,8
+P,7,12,6,7,4,7,10,3,5,13,5,3,3,11,5,6
+U,7,8,7,6,5,4,8,5,7,9,8,9,5,9,4,4
+B,8,11,7,6,6,7,8,3,6,9,5,7,8,4,8,7
+M,4,4,5,6,3,7,7,12,1,7,9,8,8,6,0,8
+O,4,8,4,6,4,7,8,7,4,10,7,6,3,9,3,7
+T,1,1,2,1,0,7,14,1,5,7,11,8,0,8,0,8
+A,3,7,5,5,5,8,8,7,4,6,6,8,2,8,6,5
+D,4,10,4,8,3,5,6,10,8,5,4,5,3,8,4,8
+I,1,5,1,4,1,7,7,1,8,7,6,8,0,8,3,8
+S,8,9,10,8,12,7,8,5,5,7,7,7,5,10,11,10
+G,2,3,3,2,1,6,7,5,4,9,7,10,2,9,4,10
+C,6,10,5,5,3,7,8,4,3,9,8,9,4,9,9,11
+A,8,13,7,7,4,11,4,3,2,8,4,10,5,5,4,9
+E,3,5,4,4,3,7,7,5,8,7,6,9,2,8,6,9
+B,6,9,9,7,6,9,7,3,7,10,4,6,4,6,6,9
+R,4,10,6,8,5,7,9,5,6,7,6,9,4,6,6,9
+E,4,7,5,5,4,6,7,3,7,11,8,9,3,8,4,8
+P,4,12,4,8,3,4,11,10,3,9,6,4,2,10,4,8
+K,10,14,9,8,4,8,7,3,7,9,5,7,6,10,4,7
+R,3,8,4,5,2,6,10,9,4,7,4,8,3,7,5,11
+O,3,4,4,3,2,7,7,6,4,9,6,8,2,8,2,8
+Y,5,5,6,7,6,9,11,5,4,6,7,7,5,10,7,5
+O,2,1,2,1,1,8,7,7,5,7,6,8,2,8,3,8
+X,5,10,7,8,4,4,9,2,8,10,12,9,3,9,4,5
+Y,8,10,7,6,4,8,5,3,5,8,7,6,5,9,5,5
+X,4,9,6,7,5,7,7,3,8,5,6,8,3,8,6,7
+R,5,10,7,8,9,6,8,3,4,6,6,9,8,9,9,7
+E,2,3,4,2,2,7,8,2,8,11,6,9,2,9,4,8
+Z,6,9,8,7,5,7,7,2,9,12,6,8,1,9,6,8
+Z,5,10,6,8,4,9,5,3,10,11,3,10,1,8,6,10
+U,4,7,5,5,2,7,3,14,6,7,13,8,3,9,0,8
+G,3,5,4,4,2,7,6,6,5,6,6,9,2,9,4,9
+Z,6,10,9,7,5,7,8,3,10,12,7,6,1,8,6,7
+J,7,13,6,10,4,7,10,2,3,13,6,5,2,9,8,8
+D,9,14,8,8,7,9,6,3,7,10,4,7,6,6,9,7
+Q,8,10,11,9,10,7,4,4,5,6,4,8,5,3,7,7
+E,9,15,6,9,5,7,7,4,4,11,5,9,3,9,8,11
+I,2,7,2,5,1,7,7,0,7,13,6,8,0,8,1,8
+M,3,4,4,3,3,8,6,6,3,7,7,8,7,5,2,7
+W,3,6,5,4,2,10,8,5,1,7,9,8,7,10,0,8
+S,2,3,2,1,1,8,7,6,4,8,6,8,2,8,8,8
+P,2,6,3,4,2,3,14,6,2,12,7,3,0,9,3,8
+C,3,7,4,5,2,5,8,7,8,13,9,10,2,10,3,7
+T,6,7,6,5,3,4,13,4,6,12,9,4,1,11,2,4
+R,3,1,3,2,2,7,8,5,5,6,5,7,2,6,4,8
+H,5,9,7,7,6,5,8,3,6,10,9,9,3,8,3,5
+J,7,11,5,15,4,8,8,3,3,13,4,5,3,8,7,10
+E,3,4,5,3,2,7,8,2,8,11,6,9,2,8,4,8
+P,2,1,2,1,1,5,10,8,3,9,6,5,1,9,3,8
+Y,1,3,2,2,1,6,10,1,5,7,11,9,1,11,1,8
+K,7,11,9,8,10,7,7,5,4,7,6,7,5,5,10,11
+W,4,6,6,4,3,7,8,4,1,7,8,8,8,9,0,8
+U,2,5,4,4,3,7,7,3,3,6,6,9,4,8,1,8
+T,3,3,4,4,2,7,12,3,6,7,11,8,2,11,1,8
+E,3,2,3,3,3,7,7,5,7,7,6,9,2,8,5,10
+V,4,8,6,6,3,7,9,4,2,7,13,8,3,10,0,8
+N,6,9,8,7,5,8,9,2,5,9,5,6,6,9,1,7
+C,5,9,6,6,4,7,7,8,6,6,6,11,4,8,4,9
+N,5,8,8,6,7,6,8,3,4,8,7,9,7,8,5,5
+J,0,0,1,0,0,12,4,5,3,12,5,11,0,7,0,8
+U,4,8,5,6,2,8,5,13,5,6,15,8,3,9,0,8
+K,10,15,10,8,6,5,8,3,6,10,9,10,6,9,4,7
+X,4,6,7,4,4,7,7,1,8,10,6,8,2,8,3,8
+E,5,11,7,8,6,7,8,2,8,11,7,8,3,8,4,8
+A,2,3,3,2,1,9,2,2,1,8,2,10,1,6,2,8
+B,2,1,3,2,2,7,7,5,5,6,6,6,2,8,6,9
+X,5,10,8,8,5,7,7,4,9,6,6,10,3,8,7,8
+V,2,7,4,5,1,9,8,4,2,6,13,8,3,10,0,8
+I,1,9,1,6,1,7,7,0,8,7,6,8,0,8,3,8
+Y,1,0,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+I,3,11,4,8,3,8,6,0,7,13,6,9,0,7,2,8
+K,5,9,7,7,6,9,6,1,6,9,3,8,3,7,4,10
+P,2,7,3,4,1,3,13,8,2,11,7,3,0,10,3,8
+P,7,10,9,8,7,6,8,8,5,8,7,9,3,9,8,9
+G,6,8,6,6,5,6,7,6,5,9,7,10,2,8,5,9
+K,3,5,6,4,3,6,7,1,7,10,7,10,3,8,3,8
+L,2,4,4,3,2,7,4,1,8,8,2,10,0,7,2,8
+M,10,14,11,8,5,13,1,5,3,13,1,9,6,3,1,9
+W,7,9,7,4,3,6,10,2,2,8,10,7,8,12,1,7
+W,2,1,3,2,1,8,8,4,0,7,8,8,6,10,0,8
+U,5,9,6,7,4,4,8,5,7,9,8,9,3,9,2,6
+L,2,6,3,4,2,5,4,3,7,6,2,8,1,6,2,7
+S,8,15,6,8,3,6,3,4,4,6,1,7,3,7,6,7
+X,2,1,2,1,0,7,7,4,4,7,6,8,2,8,4,8
+C,4,8,5,6,6,7,6,3,4,8,6,11,5,9,3,8
+O,3,6,4,4,2,7,8,8,7,7,7,8,3,8,4,8
+E,5,10,8,7,6,6,8,2,8,11,7,9,2,9,4,7
+F,4,7,6,5,5,8,7,6,4,7,6,8,4,10,8,11
+P,11,15,9,8,4,7,9,6,5,13,3,4,5,10,4,8
+J,1,2,2,4,1,11,6,1,6,11,3,7,0,7,1,7
+E,2,4,2,2,2,7,7,5,7,7,5,9,2,8,5,10
+F,4,6,6,4,3,5,12,4,5,13,7,4,2,10,2,6
+E,3,7,5,5,5,7,7,3,6,7,7,10,4,10,7,8
+R,3,5,5,4,3,9,7,4,5,10,4,6,3,7,4,10
+D,3,9,5,7,8,9,6,5,5,7,5,5,4,7,11,6
+V,3,6,5,4,2,7,9,4,2,6,13,8,3,10,0,8
+T,2,5,3,4,2,7,11,2,7,7,11,8,1,11,1,8
+S,2,6,4,4,4,6,6,3,2,7,5,7,2,8,9,3
+J,3,5,5,4,2,10,5,3,6,14,4,10,0,7,0,8
+K,4,5,4,7,2,3,7,7,2,7,5,11,3,8,3,10
+W,5,10,8,8,11,9,8,5,2,6,7,8,11,10,4,5
+H,3,7,5,5,4,8,7,6,6,7,6,6,3,8,3,7
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+W,8,9,8,7,8,7,11,4,3,8,6,6,10,12,4,5
+S,5,11,6,8,6,7,5,8,6,6,8,9,2,11,9,8
+K,4,4,7,3,3,8,7,2,7,10,4,8,5,9,4,9
+L,3,6,3,4,1,0,1,6,6,0,0,6,0,8,0,8
+B,4,8,6,6,5,7,9,5,5,9,6,5,3,7,8,7
+Y,3,9,5,6,1,8,10,2,3,7,12,8,1,11,0,8
+D,6,14,6,8,4,8,6,5,6,8,4,7,4,7,6,9
+B,2,1,3,1,2,7,7,4,5,7,6,6,1,8,5,9
+P,7,13,6,7,4,10,7,4,5,13,3,4,4,10,6,8
+G,3,4,4,3,2,7,6,5,5,9,7,10,2,9,4,9
+L,5,11,6,8,5,5,6,0,9,4,3,8,3,7,2,5
+V,10,14,8,8,5,8,8,7,5,6,10,7,7,13,3,7
+O,5,10,6,8,5,7,7,8,7,6,3,6,3,8,5,9
+W,5,6,7,6,8,6,8,6,5,6,6,8,7,8,8,10
+Q,5,8,7,6,6,8,5,7,4,6,7,7,4,6,7,8
+W,3,3,3,1,2,5,10,3,2,9,8,7,5,11,1,6
+U,6,10,9,8,5,4,9,7,9,9,11,10,3,9,1,7
+M,5,7,7,6,9,7,8,4,3,7,6,7,10,8,5,5
+V,4,10,6,8,4,8,11,2,3,4,10,9,3,11,1,8
+U,3,4,4,3,2,5,8,5,7,9,8,9,3,10,2,5
+F,3,10,3,7,1,0,13,4,4,12,10,6,0,8,2,6
+F,1,3,2,2,1,6,10,2,4,13,7,6,1,9,1,8
+W,3,7,6,5,4,7,11,2,2,6,9,8,7,11,1,8
+M,10,13,10,8,5,10,11,7,4,4,6,9,8,12,3,7
+R,3,7,3,4,2,5,10,8,4,7,4,8,3,7,5,11
+D,4,6,5,4,3,10,5,2,6,11,3,8,3,8,3,9
+D,4,5,5,4,4,8,7,4,6,6,4,8,3,7,5,6
+M,6,7,8,6,8,8,8,4,4,7,6,7,10,8,5,5
+P,5,11,6,8,3,3,14,8,1,11,7,3,1,10,4,8
+T,8,14,7,8,4,8,8,3,7,11,6,7,2,9,5,6
+C,2,3,3,1,1,5,9,4,6,12,8,10,1,9,2,7
+I,3,8,4,6,2,7,7,0,8,14,6,8,0,8,1,8
+L,2,5,3,4,2,6,5,1,8,7,2,10,0,7,3,8
+X,5,7,7,5,3,8,8,1,8,10,4,7,3,8,3,7
+P,3,5,5,4,3,8,9,3,4,12,4,4,3,8,4,8
+I,2,9,3,7,2,7,7,0,8,13,6,8,0,8,1,8
+U,3,3,4,2,1,7,9,6,7,7,10,9,3,10,1,8
+V,7,10,9,8,6,6,12,2,2,7,10,8,7,10,7,8
+W,11,13,11,7,5,10,11,6,3,4,10,7,10,12,1,6
+P,3,2,4,4,3,6,9,4,5,9,7,4,4,10,3,7
+K,5,8,7,6,5,6,7,1,6,10,7,10,3,8,3,8
+P,1,1,2,1,1,5,11,8,2,9,6,4,1,9,3,8
+I,1,1,1,1,0,7,7,2,7,7,6,9,0,8,2,8
+E,4,9,4,7,4,3,7,5,9,7,7,13,0,8,7,9
+Q,1,2,2,2,1,7,8,4,2,7,8,9,2,9,3,8
+O,4,5,5,4,3,7,7,8,5,7,6,8,2,8,3,8
+E,3,7,4,5,4,7,7,4,7,7,6,8,3,8,5,10
+P,5,5,7,8,8,9,8,3,3,5,8,7,6,11,7,5
+E,3,8,5,6,5,6,7,3,6,7,7,11,4,10,9,8
+K,5,9,6,6,6,6,7,4,7,6,6,10,3,8,5,9
+Q,3,3,4,5,4,8,8,6,2,5,7,9,3,8,5,10
+Q,8,14,7,8,4,8,6,4,10,10,3,10,3,6,9,9
+Y,7,10,7,8,4,3,10,2,7,11,11,7,1,11,3,5
+B,3,7,5,5,5,8,7,7,6,6,6,6,2,8,6,9
+Y,2,1,3,1,0,7,10,3,1,7,12,8,1,11,0,8
+B,5,11,6,8,7,7,9,6,5,7,5,6,3,8,6,8
+C,9,13,6,7,3,6,10,6,8,11,8,8,2,8,5,9
+G,4,9,5,7,3,5,7,6,5,10,8,10,2,8,5,9
+H,7,11,9,8,8,8,7,2,6,10,5,8,4,9,4,8
+F,5,11,5,8,4,1,13,4,3,12,10,6,0,8,2,6
+T,5,9,5,6,4,6,12,4,5,11,9,5,3,12,2,4
+V,6,7,8,6,8,8,7,4,4,7,6,8,7,9,8,4
+E,8,10,5,6,3,6,10,5,8,10,7,9,1,8,7,7
+D,5,11,6,8,5,9,7,5,7,10,4,5,3,8,3,8
+I,2,9,5,7,5,10,6,2,4,9,5,5,3,8,5,7
+X,4,10,6,8,4,7,8,3,9,6,5,6,4,10,8,6
+U,5,11,8,8,11,9,6,4,4,6,7,7,11,8,5,7
+R,3,3,3,4,2,5,10,8,3,7,4,8,2,7,6,11
+R,4,9,5,7,4,6,8,5,6,6,5,9,3,6,6,9
+S,1,1,2,2,0,8,8,4,7,5,6,7,0,8,7,8
+B,3,5,5,3,4,9,7,3,6,10,5,6,2,8,5,10
+Z,5,11,8,8,9,8,7,3,8,7,6,7,1,8,10,9
+C,6,6,7,8,3,5,6,7,11,7,5,14,1,9,4,8
+G,4,8,6,6,6,7,9,6,3,6,6,9,4,7,7,7
+L,2,3,4,2,1,7,3,1,6,8,2,10,1,6,3,8
+G,5,8,6,6,4,6,6,6,5,6,6,10,2,9,4,8
+Z,7,11,7,6,4,9,5,3,8,11,4,9,3,6,7,9
+M,4,10,5,8,4,7,7,12,2,7,9,8,8,6,0,8
+L,1,0,1,0,0,2,1,5,4,1,2,5,0,8,0,8
+T,5,10,5,7,3,5,13,3,7,12,9,3,1,11,2,4
+C,3,6,5,4,3,7,7,7,6,8,6,11,3,9,4,8
+R,3,8,5,6,4,6,8,6,6,6,4,8,3,7,5,8
+V,2,1,3,1,0,7,9,4,2,7,13,8,2,10,0,8
+W,10,10,9,8,9,4,11,3,3,9,8,7,8,12,2,6
+Y,3,4,5,5,1,7,11,2,2,9,12,7,1,10,0,8
+X,3,5,4,3,2,7,7,3,9,6,6,8,2,8,6,8
+X,7,9,6,5,3,6,8,2,9,10,9,9,4,8,4,6
+Y,7,11,8,8,6,5,8,1,7,8,9,5,5,12,6,3
+O,3,8,4,6,4,7,7,8,4,7,5,8,3,8,2,7
+C,7,10,7,7,4,3,8,5,7,11,10,13,1,9,3,7
+Z,4,3,4,5,2,7,7,4,14,9,6,8,0,8,8,8
+M,6,11,8,8,11,7,8,6,4,7,6,8,6,9,8,8
+E,3,6,4,4,3,6,7,6,8,6,4,9,3,8,6,9
+Z,4,9,6,7,6,7,8,3,7,7,6,8,1,9,12,5
+E,5,8,7,7,7,5,10,4,6,8,7,10,4,11,7,7
+Q,4,5,6,7,6,9,9,5,0,5,7,10,6,13,5,12
+R,4,9,5,6,3,5,12,8,4,7,2,9,3,7,6,11
+L,4,9,6,6,4,5,5,2,9,4,2,7,3,7,2,5
+O,1,3,2,2,1,8,7,5,3,9,6,8,2,8,2,8
+D,3,5,5,3,3,9,6,4,7,10,4,6,2,8,3,8
+S,4,11,5,8,3,7,7,6,10,5,6,10,0,9,9,8
+H,5,10,6,7,3,7,7,15,0,7,7,8,3,8,0,8
+G,4,8,4,6,3,6,6,6,7,11,7,12,2,10,3,10
+W,1,0,2,0,0,7,8,3,0,7,8,8,5,9,0,8
+R,6,10,9,8,10,8,8,7,3,8,5,6,5,8,7,11
+U,4,9,5,7,3,6,8,7,7,7,10,9,3,9,1,8
+E,1,1,1,2,1,4,7,5,8,7,6,13,0,8,6,9
+M,3,2,5,4,4,9,6,6,4,6,7,6,7,6,2,5
+I,1,3,2,2,0,7,7,0,7,13,6,8,0,8,1,8
+D,4,8,5,6,3,8,7,8,7,7,6,2,3,8,4,8
+Q,6,9,6,11,8,7,8,6,3,8,9,9,5,9,8,8
+O,5,10,6,8,4,8,7,8,5,10,6,8,3,8,3,8
+E,3,8,3,6,2,3,7,6,10,7,6,14,0,8,7,8
+M,4,8,4,6,3,8,7,12,1,6,9,8,8,6,0,8
+P,3,7,4,4,2,4,12,8,2,10,6,4,1,10,4,8
+T,2,7,3,5,1,6,14,0,6,8,11,8,0,8,0,8
+U,3,1,4,1,1,7,8,6,8,7,10,8,3,10,1,8
+W,5,10,8,8,7,4,11,2,2,9,9,9,8,12,2,8
+S,7,11,6,6,3,7,8,3,5,13,7,8,2,8,3,7
+E,2,3,3,2,2,7,7,2,8,11,7,9,1,8,4,8
+M,4,7,6,5,6,7,8,6,4,7,6,8,5,9,7,7
+R,2,4,3,2,2,7,8,4,5,6,5,7,2,6,5,8
+C,4,9,5,6,2,5,7,7,10,6,6,13,1,7,4,9
+G,5,11,7,8,5,5,6,6,7,6,6,8,4,7,4,7
+E,4,7,6,5,5,8,6,5,3,7,6,10,4,8,7,9
+E,2,3,4,2,2,7,7,2,8,11,6,9,2,8,4,8
+X,6,8,9,6,4,6,8,2,9,10,9,9,3,8,4,6
+Q,4,5,6,5,5,7,4,4,5,7,5,8,5,4,7,7
+R,4,5,5,7,3,5,10,9,4,7,4,8,3,7,6,11
+J,2,6,2,4,1,13,4,5,4,13,2,9,0,7,0,8
+O,7,11,10,8,12,8,8,6,2,7,7,8,10,9,7,11
+L,3,5,4,3,2,4,4,4,8,2,1,6,1,7,1,6
+Z,2,4,4,3,2,7,7,2,9,11,6,8,1,8,5,8
+E,5,9,4,4,2,7,8,4,7,10,5,11,1,8,7,8
+X,4,10,5,7,2,7,7,5,4,7,6,8,3,8,4,8
+U,4,7,6,6,6,7,7,5,3,6,7,8,4,7,2,7
+A,1,0,2,0,0,7,3,2,0,7,2,8,2,6,1,8
+R,3,3,3,4,2,6,11,8,3,7,3,9,2,7,5,11
+W,2,0,2,0,1,7,8,4,0,7,8,8,6,9,0,8
+H,6,10,6,5,4,7,8,3,5,10,5,8,6,6,5,7
+N,4,8,6,6,4,7,9,2,4,9,5,6,5,9,1,7
+V,6,11,5,8,3,4,11,2,4,9,11,7,3,9,1,8
+B,5,11,7,8,11,8,9,5,3,6,7,7,7,11,12,9
+L,2,4,4,3,2,7,4,1,8,8,2,10,0,7,2,8
+D,2,0,2,1,1,6,7,8,7,6,6,6,2,8,3,8
+E,3,5,6,3,3,8,7,2,9,11,5,9,3,7,5,8
+A,2,7,4,5,2,11,3,3,2,10,2,9,2,6,2,8
+L,2,5,3,4,2,4,4,4,7,2,1,6,0,7,1,6
+A,3,10,6,8,5,10,4,1,2,8,3,9,4,4,3,7
+C,3,10,5,7,3,4,9,6,6,6,8,14,1,8,4,10
+J,2,3,3,5,1,11,2,10,3,13,8,13,1,6,0,8
+X,5,9,8,6,5,7,7,0,8,10,7,8,2,8,3,7
+H,5,9,6,6,2,7,6,15,1,7,8,8,3,8,0,8
+B,4,9,6,7,5,8,7,5,6,10,6,6,3,8,7,9
+M,4,9,4,7,5,7,5,10,0,7,9,8,7,5,0,8
+N,4,8,4,6,2,7,7,14,2,4,6,8,6,8,0,8
+A,4,8,6,6,5,9,5,2,5,8,1,6,3,4,3,7
+F,5,6,7,7,6,7,9,4,5,8,6,8,4,10,7,6
+B,3,8,3,6,4,6,6,8,6,7,7,7,2,9,6,9
+Z,1,0,2,1,0,7,7,3,10,8,6,8,0,8,6,8
+N,6,10,8,8,6,4,10,2,3,9,9,9,6,7,1,7
+K,1,0,2,1,0,5,7,7,1,7,6,11,3,8,2,11
+K,4,10,5,8,4,3,6,7,4,7,7,12,3,8,3,11
+I,1,4,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+N,8,13,10,7,4,5,9,4,4,13,10,9,6,9,0,9
+Z,2,3,4,2,1,8,6,2,8,11,5,9,1,8,5,8
+O,2,7,3,5,2,7,6,8,7,7,4,8,3,8,4,8
+I,1,7,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+C,3,6,4,4,2,5,8,7,7,8,8,14,1,9,4,10
+M,6,5,8,4,7,7,8,4,4,7,5,8,11,8,5,6
+X,2,6,4,4,3,8,8,3,8,6,6,6,3,8,6,8
+F,3,4,5,3,2,6,10,2,5,13,7,5,1,10,2,7
+I,4,5,6,6,5,7,9,4,5,7,7,8,3,7,8,8
+Y,6,8,8,10,11,9,8,7,3,7,7,8,7,10,6,4
+X,4,6,5,6,5,7,8,2,5,8,6,8,3,6,7,7
+S,3,5,5,4,2,8,8,3,7,10,7,7,1,9,5,7
+R,5,5,5,6,3,5,12,9,4,7,3,9,3,7,6,11
+Z,5,5,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+F,2,3,4,2,1,6,10,3,5,13,7,5,1,9,1,7
+E,5,8,7,6,5,6,8,3,8,11,8,9,3,9,5,7
+E,4,9,6,6,5,7,7,6,9,7,6,10,3,8,6,8
+R,4,9,4,6,5,6,10,8,3,7,4,9,2,7,5,11
+W,5,8,5,6,4,2,10,2,3,10,11,9,6,10,1,7
+F,2,8,3,6,2,2,11,4,5,11,10,8,0,8,2,7
+J,3,8,5,6,5,9,7,3,3,8,4,6,4,8,6,4
+F,6,12,5,6,2,5,11,2,5,11,8,5,2,9,6,2
+A,2,7,4,4,1,5,4,3,2,5,1,7,2,6,2,7
+E,3,2,3,4,3,7,7,6,7,7,6,9,2,8,6,9
+A,2,7,4,4,1,8,4,3,2,7,2,8,3,6,2,8
+B,2,5,3,3,3,7,7,5,5,6,6,6,2,8,6,10
+K,3,5,6,4,3,5,7,2,8,11,9,11,4,7,4,7
+M,6,7,8,5,6,6,7,3,4,9,8,9,8,6,3,8
+J,3,8,4,6,2,8,7,1,7,11,5,7,1,6,2,6
+I,5,10,5,5,3,8,8,3,5,12,5,6,2,10,5,10
+S,3,5,5,4,4,8,9,4,5,7,7,8,4,11,7,10
+L,2,7,4,5,3,9,3,1,5,9,3,9,1,6,2,9
+K,5,10,8,8,9,6,6,3,4,6,5,10,8,6,8,8
+K,5,6,6,8,3,5,9,9,2,7,3,11,4,8,2,11
+Q,7,15,7,8,5,11,4,4,6,12,3,7,3,9,7,12
+C,4,8,5,7,5,5,7,4,4,7,6,11,4,9,8,10
+V,8,10,8,8,4,3,12,3,4,11,12,8,3,9,1,7
+T,6,9,6,6,3,5,12,4,8,12,10,4,2,12,3,4
+Q,7,9,10,8,7,5,4,4,5,4,3,7,4,7,7,6
+Q,4,8,6,7,4,8,7,8,5,6,5,9,2,8,4,9
+P,4,9,6,7,5,7,7,7,4,8,6,8,3,9,7,9
+Y,9,15,8,8,5,8,6,4,5,9,8,5,4,10,4,4
+K,5,7,7,5,5,8,7,1,6,10,5,9,3,8,2,9
+R,3,9,4,6,2,5,10,8,4,7,4,9,3,7,6,11
+J,4,8,6,6,2,6,8,3,7,15,6,9,1,6,1,7
+F,4,6,6,4,5,11,6,1,5,9,5,6,5,9,4,7
+G,2,5,3,3,2,6,7,5,5,9,7,10,2,8,4,9
+D,4,7,5,6,5,7,8,4,6,6,4,7,3,8,5,6
+U,7,11,9,8,5,4,9,7,8,9,11,11,3,9,1,8
+W,5,8,7,6,3,7,8,5,2,7,8,8,9,9,0,8
+E,3,8,5,6,6,7,7,3,5,6,7,10,4,10,8,8
+C,3,8,5,6,3,5,7,6,8,8,5,11,1,9,4,9
+F,2,3,3,2,1,6,10,2,5,13,7,5,1,9,1,7
+D,3,6,4,4,3,8,7,6,7,10,4,6,3,8,3,8
+O,2,0,2,1,1,8,7,7,6,7,6,8,2,8,3,8
+G,6,10,7,8,5,5,7,5,5,9,9,9,2,8,5,8
+M,3,3,4,2,3,7,6,6,4,6,7,8,7,5,2,8
+O,2,4,3,3,2,7,7,7,4,9,6,8,2,8,3,8
+Q,5,6,6,8,6,8,5,6,3,9,5,10,5,7,7,6
+Z,5,5,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+J,2,5,3,4,2,10,6,2,5,12,4,8,1,6,1,6
+X,3,3,5,2,2,6,8,2,8,11,9,9,2,8,3,6
+B,4,6,5,4,4,8,6,3,5,6,5,7,4,9,5,8
+O,4,7,6,5,4,7,9,8,5,6,8,10,3,8,3,8
+R,4,7,5,5,5,8,8,7,3,8,5,7,4,8,6,11
+C,2,3,2,1,1,4,10,5,6,12,9,9,1,9,2,7
+R,2,3,3,2,2,6,8,4,5,7,5,7,2,7,3,8
+R,4,9,6,6,6,7,8,5,5,7,5,7,3,7,5,9
+D,6,9,8,7,5,10,6,3,9,11,4,7,4,6,4,9
+X,6,10,9,8,4,8,7,1,9,10,5,8,3,8,4,8
+L,3,4,3,6,1,0,1,5,6,0,0,7,0,8,0,8
+C,4,6,5,6,5,7,8,5,4,6,7,11,6,9,9,11
+C,4,9,5,7,3,6,8,6,8,7,6,14,1,8,4,9
+F,4,7,6,5,3,8,9,3,6,13,6,5,2,10,3,8
+V,5,9,7,7,3,9,12,3,4,4,11,9,3,10,1,8
+R,3,8,4,6,4,6,10,7,3,7,4,9,2,7,5,11
+Z,9,13,9,7,5,6,8,2,10,12,8,8,4,4,8,4
+C,4,9,5,7,3,4,8,6,7,7,8,15,1,8,4,10
+I,2,6,3,4,1,6,8,1,8,14,7,8,0,8,1,7
+O,2,7,3,5,2,7,7,9,6,7,6,8,3,8,4,8
+L,5,11,7,8,5,6,5,0,9,9,3,11,0,7,3,8
+S,2,0,2,1,1,8,8,4,7,5,6,7,0,8,7,8
+I,4,8,5,6,3,6,6,2,7,7,6,10,0,9,4,8
+T,5,7,6,5,4,5,12,4,5,12,9,4,2,12,1,5
+E,6,10,8,7,7,10,6,2,7,11,4,8,5,6,5,11
+Y,3,4,5,5,1,8,10,3,2,6,13,8,2,11,0,8
+Y,4,5,5,4,2,4,12,3,7,12,10,4,1,11,2,5
+R,5,9,5,7,6,5,10,7,4,7,4,9,2,7,5,11
+S,3,7,5,5,6,7,7,3,2,8,6,7,2,7,12,3
+R,4,8,4,5,3,5,11,8,3,7,3,8,3,7,6,11
+O,4,9,5,7,4,7,7,9,5,7,5,8,3,8,3,8
+I,2,5,4,4,1,7,7,0,8,14,6,9,0,8,1,8
+T,3,8,4,6,2,7,13,0,6,7,10,8,0,8,0,8
+X,4,9,6,6,4,4,8,1,8,10,10,10,2,8,3,5
+C,5,10,4,5,3,8,5,5,3,9,9,11,4,9,7,11
+I,1,4,2,3,1,7,7,0,7,13,6,8,0,8,0,8
+J,3,7,4,5,2,8,6,3,6,15,5,9,0,7,0,7
+R,2,3,4,2,2,8,8,4,4,8,5,7,2,7,4,10
+E,5,10,4,6,2,8,7,5,7,11,6,9,2,10,7,9
+Q,5,9,5,5,3,9,4,4,7,10,4,9,3,8,8,11
+X,3,4,4,3,2,7,7,3,9,6,6,8,3,8,6,8
+O,4,8,5,6,4,7,7,8,4,7,6,8,3,8,3,8
+Q,3,7,4,7,4,8,9,6,4,6,9,9,2,8,5,9
+Y,2,3,3,1,1,4,12,3,5,12,10,5,1,11,1,5
+Q,5,12,5,6,3,10,5,4,7,12,4,9,3,8,8,12
+C,6,11,5,6,4,7,7,4,3,9,8,10,4,9,8,11
+K,7,9,9,6,7,9,5,1,7,10,3,9,8,5,7,10
+A,3,4,5,2,2,9,1,2,1,8,2,8,2,6,3,8
+E,5,10,6,8,7,6,8,6,8,6,5,11,3,8,6,9
+X,8,13,9,7,5,6,8,2,8,11,5,7,4,5,4,6
+M,4,5,7,3,4,8,7,3,4,9,6,7,8,6,2,7
+P,8,14,7,8,5,7,9,4,4,12,5,4,4,9,7,5
+R,4,7,5,5,3,9,8,4,6,9,3,7,3,6,4,11
+K,4,8,6,6,5,8,5,1,6,9,4,10,4,8,4,10
+G,3,6,5,4,2,8,6,7,8,6,5,10,2,8,5,10
+E,5,9,7,6,7,7,8,6,3,7,6,8,5,8,8,8
+T,2,2,3,3,2,7,11,2,7,7,11,8,1,11,1,8
+O,4,8,5,6,3,8,7,8,5,10,6,7,3,8,3,8
+B,1,0,2,1,1,7,7,7,4,7,6,7,1,8,6,8
+J,2,10,3,8,1,13,2,9,4,14,4,12,1,6,0,8
+Z,4,5,5,7,2,7,7,4,15,9,6,8,0,8,8,8
+F,4,7,4,5,1,1,14,5,3,12,9,5,0,8,2,6
+V,6,11,8,8,5,6,11,3,2,7,11,8,4,10,5,9
+H,3,4,4,3,3,7,7,6,6,7,6,8,3,8,3,8
+Q,3,4,4,5,3,7,8,5,2,7,9,10,3,9,5,8
+C,2,4,3,3,1,6,8,7,7,8,8,13,1,9,4,10
+L,3,6,4,4,2,7,3,2,9,7,1,9,0,7,2,8
+M,3,3,5,2,3,5,7,3,4,10,9,10,6,5,2,7
+N,1,1,2,2,1,7,8,5,3,8,7,7,4,8,1,7
+T,3,6,4,4,2,6,11,1,8,8,11,9,1,10,1,8
+O,5,8,6,7,5,6,6,5,5,8,5,7,3,6,5,7
+O,2,5,3,3,2,7,7,7,4,9,6,8,2,8,2,8
+C,3,7,4,5,2,5,8,6,8,12,9,11,1,10,3,7
+E,2,6,2,4,2,3,8,5,9,8,8,13,0,8,6,9
+Q,4,7,6,9,6,9,7,7,2,5,7,10,3,8,6,10
+T,3,9,4,6,1,7,15,0,6,7,11,8,0,8,0,8
+Z,2,3,3,2,1,7,8,2,9,11,6,8,1,8,5,7
+B,2,4,4,3,3,9,7,2,6,11,4,7,4,7,5,9
+J,1,1,1,1,0,12,3,6,4,13,4,11,0,7,0,8
+C,2,4,3,2,1,4,9,5,7,11,9,12,1,9,3,7
+P,4,8,6,6,4,8,8,2,5,13,5,5,1,10,3,9
+X,3,5,5,3,2,10,7,1,9,11,3,7,2,7,3,9
+W,3,1,3,2,1,7,8,4,1,7,8,8,7,10,0,8
+N,4,9,4,6,2,7,7,14,2,4,6,8,6,8,0,8
+B,6,10,9,8,12,8,8,5,3,6,7,7,7,10,11,10
+B,6,9,9,8,10,7,7,5,4,7,6,8,7,9,8,6
+Z,3,6,5,4,3,8,7,2,9,11,6,8,2,8,5,8
+M,6,9,9,8,11,7,7,4,3,6,6,8,10,9,5,5
+H,2,6,3,4,2,7,6,12,2,7,8,8,3,9,0,8
+B,1,0,1,1,1,7,7,7,4,6,6,7,1,8,6,9
+U,6,10,9,8,6,7,8,4,8,4,7,9,6,9,1,8
+I,0,3,1,1,0,7,7,1,6,13,6,8,0,8,0,7
+Q,3,6,4,5,4,8,7,7,5,6,6,7,2,8,4,9
+D,3,7,4,5,4,9,7,4,6,9,4,6,3,8,3,8
+H,6,11,6,8,6,8,5,14,2,7,9,8,3,9,0,8
+U,3,3,4,2,2,5,8,6,7,8,10,10,3,9,1,7
+G,2,4,3,3,2,6,6,5,4,8,7,10,2,8,4,10
+G,8,12,7,6,4,10,3,3,4,10,2,6,4,7,5,11
+R,5,10,8,8,5,9,8,4,6,9,3,7,3,6,5,11
+T,4,7,4,5,3,6,11,5,5,11,8,4,3,12,2,4
+G,3,8,4,6,2,7,6,7,7,6,6,10,1,8,6,11
+A,2,1,4,2,1,8,2,2,1,7,2,8,2,7,2,7
+J,3,7,5,5,4,9,8,3,4,9,4,7,4,8,6,5
+A,4,7,5,5,3,8,4,3,0,6,1,8,2,7,1,7
+Q,4,7,5,5,5,8,7,7,4,6,8,8,4,5,6,9
+H,4,7,6,5,5,6,6,7,4,6,5,8,3,7,6,10
+U,2,3,3,1,1,5,8,4,6,10,8,8,3,10,1,6
+W,5,10,7,7,4,6,8,5,2,7,8,8,9,9,0,8
+Z,2,5,3,3,2,7,7,5,9,6,6,8,2,8,7,8
+K,6,9,9,6,6,5,7,1,7,10,9,11,4,6,4,7
+Y,7,11,7,8,4,3,10,2,7,10,12,6,2,11,3,5
+F,2,7,2,4,1,1,12,4,5,12,11,8,0,8,2,6
+X,4,9,7,7,3,7,7,1,8,10,6,8,3,8,4,7
+K,3,6,4,4,5,7,8,3,4,6,6,8,7,8,6,8
+P,3,8,5,6,3,4,12,4,6,11,9,3,0,9,4,6
+N,3,5,6,3,2,6,9,3,5,10,7,7,5,8,1,8
+C,3,8,4,6,2,5,8,7,7,7,8,14,1,9,4,10
+W,6,11,9,8,4,11,7,5,2,6,9,8,9,9,0,8
+M,6,7,9,5,6,8,6,2,5,9,6,7,8,6,2,7
+T,5,10,6,8,5,4,12,5,5,12,9,4,2,12,1,5
+H,4,7,5,5,4,9,7,7,6,7,6,5,3,8,3,5
+L,3,8,4,6,3,5,4,2,9,3,2,7,3,7,2,5
+Y,9,11,9,8,4,5,9,1,10,10,10,4,2,13,5,3
+N,4,9,5,7,4,8,7,13,1,6,6,8,5,9,0,8
+Z,4,7,6,5,3,7,8,2,9,11,6,8,1,9,6,8
+H,3,7,4,5,4,8,7,6,6,7,6,7,3,8,3,7
+O,4,9,3,5,2,6,7,6,3,10,6,9,5,9,5,7
+P,3,8,3,6,3,3,12,6,1,11,7,4,0,9,3,8
+T,6,10,8,8,7,6,7,7,7,7,9,9,4,10,6,8
+D,6,10,9,8,8,8,8,5,6,10,5,5,4,8,5,10
+K,2,1,2,1,0,5,7,8,1,7,6,11,3,8,2,11
+U,2,1,3,1,1,7,8,6,6,7,9,8,3,10,1,8
+N,5,6,7,4,3,9,7,3,5,10,3,5,5,9,1,7
+D,6,11,6,6,4,10,6,3,6,9,4,7,5,10,6,8
+B,4,4,5,6,4,6,7,9,7,7,6,7,2,8,9,9
+P,5,10,7,7,4,7,11,4,5,13,5,3,1,10,3,8
+L,4,8,5,6,6,8,8,3,5,6,7,9,6,11,6,6
+L,2,3,3,5,1,0,1,5,6,0,0,7,0,8,0,8
+L,1,3,2,1,1,6,5,1,7,8,3,10,0,7,2,8
+V,7,13,7,7,4,8,9,4,4,8,8,5,6,14,2,8
+L,1,4,2,2,1,7,4,1,7,8,2,10,0,7,2,8
+P,5,6,6,8,7,6,9,3,2,8,8,6,5,10,5,5
+J,6,8,4,11,3,9,7,3,3,12,3,5,3,8,6,10
+R,5,5,5,7,3,5,11,9,4,7,3,9,3,7,6,11
+W,6,8,6,6,5,6,10,4,3,9,7,6,7,12,3,6
+Q,6,9,7,10,8,9,9,6,3,4,8,11,5,9,9,13
+T,7,15,6,8,4,6,10,2,6,12,7,6,3,9,5,5
+U,4,4,4,3,2,5,8,5,7,10,9,9,3,9,2,6
+K,3,5,6,4,3,5,8,2,7,10,9,10,3,8,3,7
+Y,1,0,2,0,0,7,10,3,1,7,12,8,1,11,0,8
+T,5,6,6,5,6,7,9,5,8,7,7,8,3,10,7,7
+B,5,11,8,9,9,8,6,5,6,9,5,7,3,8,6,10
+D,9,15,9,8,5,8,6,5,7,12,3,7,6,7,6,10
+S,2,7,3,5,2,8,8,7,6,8,6,8,2,8,9,8
+L,2,7,2,5,1,0,1,5,6,0,0,7,0,8,0,8
+W,1,0,2,0,0,8,8,3,0,6,8,8,5,9,0,8
+G,3,4,4,6,2,7,7,8,7,6,6,9,2,7,6,10
+P,8,15,8,9,5,8,9,4,4,12,5,3,5,10,6,6
+M,5,6,8,4,4,7,6,2,5,9,7,8,8,5,2,8
+O,5,8,6,6,4,8,9,8,4,7,7,8,3,8,3,8
+H,4,7,6,5,8,8,7,4,3,6,6,7,7,8,8,8
+O,2,4,3,3,2,7,7,6,3,9,6,8,2,8,2,8
+H,3,2,4,3,3,8,7,5,6,7,6,8,6,8,4,7
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+L,4,10,5,8,3,3,5,1,9,6,1,11,0,7,3,6
+S,5,11,5,6,3,6,8,4,3,13,8,8,3,10,3,8
+D,3,5,5,3,3,9,6,4,6,10,4,6,2,8,3,8
+X,6,12,6,6,4,7,8,2,7,11,7,7,4,12,3,7
+L,3,8,4,6,1,0,1,6,6,0,0,6,0,8,0,8
+D,2,1,3,1,2,6,7,6,6,7,6,5,2,8,2,7
+Z,9,10,6,14,6,8,4,5,4,12,7,9,3,8,12,7
+B,4,9,6,6,5,6,9,5,6,10,6,5,3,8,7,8
+D,1,1,2,1,1,7,7,6,6,7,6,5,2,8,2,7
+A,3,11,5,8,4,12,2,3,3,10,2,9,2,6,3,8
+X,4,9,7,7,6,8,7,3,6,7,4,6,5,5,8,7
+V,5,10,5,8,3,3,11,4,4,10,11,7,3,10,1,8
+B,5,9,5,7,4,6,7,9,7,7,6,7,2,8,9,9
+X,4,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+M,4,4,7,3,4,6,6,3,4,10,9,10,7,6,2,8
+O,4,3,5,4,2,7,7,8,8,7,6,8,3,8,4,8
+L,1,0,1,0,0,2,2,5,4,1,2,6,0,8,0,8
+K,4,8,6,6,5,3,8,2,6,10,10,11,3,8,3,6
+T,6,11,6,8,5,4,13,6,4,12,9,4,2,12,1,5
+M,3,6,4,4,4,8,5,10,0,6,8,8,6,5,0,7
+H,3,5,6,4,3,9,7,3,6,10,3,7,5,7,4,9
+Y,6,11,6,8,3,3,10,3,7,12,12,7,1,11,3,5
+C,3,4,4,6,2,6,7,7,9,5,6,14,1,7,4,8
+I,4,11,7,8,8,10,7,2,5,9,4,4,4,9,7,5
+U,5,8,7,6,4,5,9,6,7,8,10,10,3,9,1,8
+Z,3,9,5,7,5,8,8,3,7,8,7,7,1,9,10,9
+S,6,9,6,5,3,9,5,4,4,13,6,9,3,10,3,8
+N,5,8,8,6,3,11,6,3,5,10,1,4,5,9,1,7
+B,5,6,7,5,7,8,6,5,4,7,6,8,7,9,8,4
+F,4,7,6,5,2,7,10,2,7,14,5,4,1,10,2,8
+X,4,10,7,7,4,7,8,4,9,6,5,5,4,10,8,6
+C,1,3,2,2,1,6,8,4,6,11,8,12,1,10,3,8
+B,4,9,6,7,7,8,7,6,6,7,6,6,2,8,6,10
+J,2,9,3,7,1,13,3,8,5,14,2,11,0,6,0,8
+C,4,7,5,5,2,5,7,6,7,11,9,13,2,9,4,7
+M,4,9,5,6,5,8,6,11,1,7,8,8,7,5,0,8
+O,5,11,7,8,3,8,8,8,8,6,7,9,3,8,4,8
+W,5,5,8,8,4,5,8,5,2,7,8,8,9,9,0,8
+T,3,9,4,6,1,7,14,0,6,7,11,8,0,8,0,8
+A,3,6,5,4,2,8,4,3,0,7,1,8,2,7,1,8
+W,5,11,8,8,13,8,5,6,3,7,6,8,14,10,4,9
+B,3,3,3,5,3,6,6,9,6,6,6,7,2,8,9,10
+U,6,10,6,6,4,8,6,5,5,6,7,7,5,8,3,7
+A,3,4,5,5,1,8,6,3,1,7,0,8,2,7,1,8
+F,4,7,7,5,6,7,9,1,5,10,6,6,5,10,4,5
+L,3,3,3,5,1,0,1,6,6,0,1,6,0,8,0,8
+X,3,7,5,5,4,8,7,3,6,7,4,6,4,7,6,8
+Z,3,5,5,3,2,7,7,2,9,12,6,8,1,8,6,8
+W,7,10,7,8,5,1,10,2,3,11,11,9,7,10,1,7
+L,4,5,5,5,4,8,7,4,5,7,6,8,3,8,8,11
+N,3,6,5,4,3,7,8,6,5,7,7,6,5,9,1,6
+C,6,9,6,7,3,4,8,6,7,12,10,12,2,10,2,7
+D,6,9,5,4,3,9,5,5,6,12,3,8,5,7,5,10
+C,8,14,6,8,5,9,6,4,3,9,8,11,4,9,8,13
+V,8,10,7,5,3,8,8,7,5,7,10,6,7,12,4,8
+W,5,9,7,7,11,9,7,5,2,7,6,8,10,11,4,8
+X,2,2,3,3,2,7,7,3,9,6,6,10,2,8,6,8
+H,5,6,7,4,4,4,10,3,6,10,10,9,3,8,3,6
+B,5,9,5,4,4,9,7,3,5,9,5,7,6,6,7,9
+H,10,14,9,8,5,7,8,4,5,9,7,8,6,8,5,9
+G,3,7,4,5,2,7,6,7,8,6,5,11,1,8,6,11
+Y,5,10,7,8,3,8,9,3,2,6,12,8,2,11,0,8
+W,4,7,6,5,3,7,8,5,1,7,8,8,8,9,0,8
+T,4,10,6,8,5,7,11,2,7,7,11,8,1,12,1,7
+K,4,7,4,4,1,4,7,8,2,7,5,11,3,8,2,11
+V,3,6,5,4,2,9,9,4,1,6,12,8,2,10,0,8
+K,1,0,1,0,0,5,7,7,0,7,6,10,2,8,2,11
+Y,4,9,4,4,2,6,8,3,4,10,7,5,3,10,4,3
+T,5,10,7,8,5,7,11,1,8,7,11,8,1,11,1,8
+E,2,4,3,3,2,9,7,1,7,11,5,8,2,8,4,10
+D,4,6,5,4,4,10,5,3,6,10,3,7,3,7,3,8
+E,2,3,4,2,2,6,7,2,7,11,6,9,2,8,3,8
+L,2,6,2,4,1,0,2,5,6,0,0,7,0,8,0,8
+C,8,11,8,8,4,3,9,6,8,12,11,11,1,8,3,6
+G,6,9,8,7,8,7,8,6,2,6,5,11,6,8,10,6
+P,1,0,2,0,0,5,11,6,1,9,5,5,0,9,3,8
+Z,4,5,6,7,4,11,5,4,4,9,3,8,2,6,5,9
+N,9,12,11,6,4,5,8,3,4,13,9,9,7,8,0,7
+C,6,10,6,8,3,5,9,7,8,13,9,7,2,11,2,7
+I,4,10,6,8,4,6,9,0,7,13,7,7,0,8,1,7
+E,5,11,7,8,8,8,7,5,3,7,6,8,5,8,9,9
+E,6,11,4,6,2,7,8,5,8,9,5,12,1,8,7,9
+A,2,0,3,1,0,7,4,2,0,7,2,8,2,7,1,8
+A,3,7,5,5,3,11,3,2,2,9,2,9,3,5,2,8
+C,6,10,7,8,4,4,8,6,7,12,10,12,2,10,3,7
+F,3,5,4,4,2,5,10,3,5,10,9,5,1,10,3,6
+M,4,7,6,5,6,7,9,6,3,7,6,8,5,9,5,8
+M,7,8,9,7,10,8,7,5,4,7,6,7,10,9,6,4
+X,4,11,6,8,5,7,7,3,8,5,6,8,3,8,6,7
+K,4,6,6,4,4,5,6,4,7,6,6,10,3,8,5,9
+F,5,9,5,5,3,6,12,3,3,11,6,4,4,10,7,6
+S,4,6,5,4,6,8,10,5,4,8,5,6,4,9,8,7
+B,6,10,8,8,6,9,7,4,7,10,4,6,2,8,6,10
+L,3,7,5,5,2,6,3,2,8,7,2,7,1,6,2,7
+U,8,10,9,8,6,4,8,5,8,9,8,9,6,9,4,3
+B,3,4,5,3,3,8,7,3,5,10,5,7,2,8,4,10
+N,4,9,4,7,2,7,7,14,2,5,6,8,6,8,0,8
+Q,4,5,5,6,5,9,6,7,4,5,6,8,3,8,6,9
+P,2,2,3,3,2,6,9,5,4,9,7,4,1,10,3,7
+W,2,1,4,1,2,8,11,3,1,6,9,8,6,11,0,7
+W,4,8,6,6,7,7,8,5,3,7,9,8,6,8,3,8
+P,4,8,6,6,4,6,10,4,6,10,8,3,1,10,5,7
+M,10,14,12,8,7,9,3,3,2,9,3,10,11,0,2,8
+Y,3,3,4,2,1,5,10,2,7,11,10,4,1,11,2,5
+R,6,8,9,7,9,7,7,3,4,7,5,8,7,9,7,5
+O,5,11,4,6,3,4,9,6,4,9,9,8,3,9,4,8
+O,5,9,5,7,5,8,7,7,4,10,5,8,3,8,3,7
+V,7,11,7,8,4,2,11,4,4,11,12,8,3,10,1,8
+B,5,9,6,7,5,7,9,9,8,7,5,7,2,8,9,10
+L,6,12,5,6,3,10,2,2,5,11,4,11,2,9,4,11
+E,6,9,5,5,3,7,8,4,4,11,6,8,3,9,8,9
+T,3,3,3,2,1,5,12,3,7,11,9,4,1,10,2,5
+X,3,7,4,5,2,7,7,4,4,7,6,8,2,8,4,8
+U,3,7,5,5,3,7,8,6,6,5,9,9,3,9,1,8
+G,3,11,5,8,4,7,7,7,7,8,4,12,2,9,6,10
+I,5,9,6,7,4,7,6,2,7,7,6,9,0,9,4,8
+Q,2,2,2,2,2,8,7,5,3,8,6,8,2,9,2,7
+I,2,11,0,8,2,7,7,5,3,7,6,8,0,8,0,8
+W,6,6,6,4,4,1,12,3,2,11,10,8,6,11,1,7
+C,6,12,4,6,2,7,8,7,6,11,7,7,2,9,5,8
+B,3,5,5,3,3,7,8,3,5,10,6,6,2,8,5,8
+H,5,7,8,9,7,8,5,3,2,7,5,7,4,8,8,8
+X,2,1,3,1,1,7,7,4,9,6,6,9,2,8,5,7
+Q,7,13,6,7,5,10,4,4,6,11,4,8,3,8,8,11
+O,3,7,4,5,3,8,7,8,5,7,6,9,2,8,3,8
+O,1,0,2,0,0,7,7,6,4,7,6,8,2,8,3,8
+I,1,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+R,7,13,7,7,5,10,6,4,5,10,2,7,6,7,6,8
+N,3,7,5,5,4,7,7,8,5,7,5,7,3,7,3,8
+N,5,10,7,7,5,8,8,6,5,6,6,5,6,9,2,6
+C,3,7,4,5,3,5,8,6,6,8,8,14,2,9,4,10
+V,7,13,6,7,3,8,10,6,4,8,10,5,6,13,3,8
+X,7,11,11,8,5,6,8,1,9,10,9,9,3,8,4,6
+Q,4,4,6,6,6,9,11,5,0,5,7,10,5,12,4,10
+E,4,10,6,8,6,7,7,5,8,7,7,10,3,8,6,9
+V,4,11,6,8,3,7,11,3,5,8,12,8,3,10,1,8
+I,1,9,0,6,1,7,7,5,3,7,6,8,0,8,0,8
+U,5,5,6,4,3,4,8,5,8,10,9,9,3,9,2,6
+W,4,8,6,6,5,4,11,2,2,8,9,9,6,11,1,8
+D,6,9,8,8,7,6,7,5,8,7,5,8,5,5,7,4
+C,8,11,5,6,2,7,8,6,7,11,6,9,2,9,5,9
+L,4,8,5,6,3,6,4,3,7,6,1,8,1,6,3,7
+H,4,6,6,4,5,8,8,6,7,7,6,6,6,8,3,8
+N,5,10,6,7,5,9,8,6,5,6,5,4,6,10,3,5
+P,4,7,6,10,10,8,9,5,0,8,7,6,5,11,6,10
+J,2,6,2,4,1,9,7,2,6,11,3,7,0,7,1,6
+E,2,3,4,1,2,7,7,2,7,11,7,9,1,9,4,8
+C,3,8,4,6,2,5,8,8,8,9,8,13,2,10,4,10
+E,4,8,6,6,5,5,8,5,7,11,9,9,3,8,5,5
+K,2,3,2,2,2,5,7,4,7,6,6,10,3,8,4,10
+X,6,10,7,6,4,10,6,3,7,12,2,6,3,8,4,10
+Q,5,6,6,8,3,8,6,8,7,6,6,8,3,8,5,9
+R,6,8,9,7,9,9,6,4,4,8,5,7,7,9,7,6
+T,4,11,6,8,2,8,15,1,6,7,11,8,0,8,0,8
+Y,2,3,4,5,1,8,11,2,3,4,12,8,1,10,0,8
+W,5,10,8,7,7,4,11,2,3,8,9,9,7,11,1,8
+B,4,7,4,5,3,6,7,8,6,7,6,7,2,8,9,10
+A,3,7,6,5,4,12,3,2,2,9,2,8,4,5,2,8
+A,3,7,5,5,3,7,3,2,2,5,2,8,2,6,2,6
+J,5,9,4,7,3,7,11,3,3,13,5,4,2,8,7,8
+J,2,4,4,3,1,8,6,3,6,14,7,11,1,6,1,7
+C,2,3,3,2,1,5,8,5,6,11,9,10,1,10,2,7
+L,4,9,4,4,2,8,5,3,5,12,7,11,2,8,6,8
+J,2,6,4,4,3,9,6,2,4,8,5,6,3,7,5,6
+U,5,9,5,6,4,4,8,5,7,10,9,9,3,9,2,5
+V,3,6,5,4,1,7,8,4,2,7,13,8,3,9,0,8
+N,4,7,4,5,2,7,7,14,2,4,6,8,6,8,0,8
+H,3,8,5,6,6,8,7,4,3,6,6,7,7,8,7,6
+G,6,11,6,8,5,5,6,6,5,10,8,11,2,9,4,10
+G,3,7,5,5,3,7,6,6,6,6,6,10,2,9,4,8
+N,1,0,1,1,1,7,7,10,0,6,6,8,4,8,0,8
+T,4,10,6,8,5,10,11,2,7,5,11,7,1,11,1,8
+U,3,3,4,2,2,7,8,6,7,6,9,9,3,9,1,8
+U,4,5,5,3,2,4,8,5,8,9,8,9,4,11,3,4
+N,3,2,4,3,3,7,8,5,5,7,6,6,6,9,2,5
+U,5,6,5,4,2,4,9,5,7,12,11,9,3,9,1,7
+W,4,5,7,4,4,5,11,3,2,8,9,9,8,11,1,8
+C,3,5,4,4,2,4,8,5,7,12,9,11,1,10,2,7
+U,5,10,7,7,6,8,8,8,5,5,7,9,3,7,4,7
+J,2,5,4,4,2,10,6,2,6,12,4,8,1,6,1,7
+C,4,9,5,7,6,8,6,5,3,7,7,11,5,9,3,8
+O,6,9,8,8,6,6,5,5,5,9,6,10,5,5,7,4
+L,4,9,4,7,1,0,0,6,6,0,0,5,0,8,0,8
+C,6,10,6,8,3,3,9,6,8,12,11,11,1,8,2,6
+B,3,6,5,4,4,9,6,4,6,10,5,7,2,8,5,10
+T,3,8,4,6,2,9,14,0,5,6,10,8,0,8,0,8
+Z,3,7,4,5,2,7,7,4,13,9,6,8,0,8,8,8
+F,4,10,5,8,4,6,10,3,6,10,9,5,2,10,4,6
+Q,2,1,3,2,1,8,6,7,5,6,6,8,3,8,4,9
+P,4,9,6,6,4,7,9,4,4,12,5,3,1,10,3,8
+O,6,10,8,8,6,8,5,9,4,6,5,5,5,7,4,8
+T,4,5,4,3,2,5,11,2,8,11,9,4,1,11,2,4
+D,4,8,6,7,6,7,7,5,6,7,4,8,4,6,7,4
+A,3,10,5,7,3,7,3,2,2,5,2,7,2,6,2,7
+C,6,9,6,6,3,5,7,6,8,11,8,14,2,9,4,6
+E,2,3,3,2,2,7,7,5,7,7,6,9,2,8,5,10
+K,2,1,3,3,2,6,7,4,7,6,6,10,3,8,5,8
+R,6,11,8,8,7,9,8,4,5,9,4,7,3,7,4,11
+Y,3,7,4,5,1,8,11,1,3,6,12,8,1,11,0,8
+T,9,11,7,6,3,5,9,3,9,13,7,5,2,10,3,5
+E,6,11,9,8,8,8,7,7,3,7,6,11,6,8,9,8
+H,4,8,6,6,6,7,8,5,6,7,6,8,3,8,3,8
+R,3,5,5,3,3,9,6,3,5,10,4,7,3,6,4,9
+C,1,0,1,1,0,6,7,6,8,7,6,14,0,8,4,10
+U,4,7,6,6,5,7,7,4,4,6,6,9,4,8,2,9
+U,4,10,4,7,4,7,6,12,4,7,12,8,3,9,0,8
+Z,4,9,5,7,2,7,7,4,14,9,6,8,0,8,8,8
+T,4,5,5,4,3,8,12,3,7,6,11,8,2,11,1,7
+F,5,5,5,7,2,1,13,5,5,12,10,7,0,8,2,6
+C,3,6,4,4,1,3,9,5,7,11,11,10,2,9,2,6
+C,7,13,5,7,2,6,9,6,8,11,8,9,2,8,5,9
+H,3,7,5,5,4,7,7,7,6,7,6,8,3,8,3,8
+W,7,6,9,6,10,7,8,5,5,7,5,8,10,10,9,8
+S,2,1,2,1,1,8,7,4,7,5,6,7,0,8,8,8
+I,7,14,6,8,4,8,8,2,6,13,4,5,2,8,6,9
+L,2,1,2,2,1,5,3,5,7,2,2,4,1,7,1,6
+N,3,5,4,4,3,7,8,5,5,7,7,6,5,9,2,6
+E,3,8,3,6,2,3,6,6,11,7,7,15,0,8,6,7
+U,7,12,6,6,4,9,5,5,6,5,7,7,5,9,3,7
+P,4,6,6,4,3,8,9,5,5,12,4,3,2,9,4,8
+N,4,5,6,4,3,6,10,2,4,10,7,7,5,8,1,8
+C,2,5,3,3,1,4,9,5,6,11,10,11,1,9,2,7
+M,1,0,2,0,0,8,6,10,0,7,8,8,6,6,0,8
+Q,5,9,5,4,3,12,4,3,5,10,3,7,3,9,4,12
+Y,1,1,3,2,1,7,10,1,6,7,11,8,1,11,1,8
+X,6,9,9,6,5,5,8,1,8,10,10,9,3,8,3,6
+N,4,10,4,8,3,7,7,14,2,5,6,8,6,8,0,8
+S,5,9,6,7,5,8,7,7,5,7,6,7,2,8,9,8
+R,4,11,4,8,5,6,8,9,4,7,5,7,3,8,5,11
+R,3,4,4,2,3,7,8,5,5,6,5,6,2,7,4,9
+U,9,11,10,8,4,4,8,6,10,13,11,9,3,9,1,7
+S,4,5,5,5,5,8,8,4,4,7,6,8,5,10,9,11
+Z,9,13,9,7,6,7,6,2,9,12,7,9,4,6,8,6
+H,6,9,6,4,3,7,8,4,4,9,9,9,6,10,5,9
+P,1,0,2,1,0,5,11,7,1,9,6,4,1,9,3,8
+L,3,9,4,6,3,3,5,1,8,3,1,9,0,7,1,6
+V,1,0,2,1,0,8,9,3,2,7,12,8,2,10,0,8
+R,5,9,7,7,6,7,7,6,6,6,5,7,4,8,6,10
+U,5,9,7,8,7,8,6,4,4,6,7,7,4,8,1,7
+R,7,11,9,8,9,9,8,4,5,10,4,7,3,7,5,11
+F,4,7,6,5,3,7,10,3,6,13,6,5,2,9,3,7
+N,3,4,5,3,2,6,9,3,4,10,7,7,5,8,1,8
+B,6,10,8,7,7,7,9,7,5,7,5,5,5,9,7,6
+W,6,9,6,6,5,2,11,2,3,10,10,8,5,11,1,7
+X,5,6,6,6,6,7,6,2,5,8,7,9,3,11,7,8
+Y,3,2,5,4,2,5,10,1,7,9,11,9,1,11,2,7
+M,4,4,5,6,3,8,7,12,1,6,9,8,8,6,0,8
+P,4,8,6,6,3,6,11,5,4,12,5,3,1,10,3,8
+J,2,4,4,3,1,8,6,3,7,14,5,10,0,7,0,8
+X,4,8,6,7,6,9,9,2,6,7,5,6,2,5,7,7
+D,5,10,7,7,5,8,7,7,9,6,5,4,3,8,4,7
+T,5,9,4,4,2,6,10,2,6,12,7,6,2,9,4,4
+V,6,10,8,8,6,8,12,3,2,6,10,9,7,11,7,8
+F,4,10,4,7,2,1,15,5,3,12,9,4,0,8,3,6
+M,4,7,5,5,3,8,7,12,1,6,9,8,8,6,0,8
+R,6,9,9,8,10,5,9,4,4,6,4,10,10,5,9,9
+T,7,9,6,5,2,4,12,3,6,13,8,4,2,8,4,3
+K,5,8,7,6,6,7,7,1,6,10,5,9,3,7,4,8
+H,2,6,4,4,5,9,6,4,3,6,6,7,6,9,7,7
+Q,7,9,7,11,8,8,6,7,3,8,6,11,6,8,8,6
+P,3,7,3,4,2,4,11,9,3,9,6,4,1,10,3,8
+J,4,10,4,7,3,14,3,5,4,13,2,10,0,7,0,8
+L,3,9,5,6,3,8,3,0,8,10,3,11,0,7,2,9
+O,5,9,6,7,6,7,6,8,4,7,5,8,3,9,3,7
+L,1,3,2,2,1,7,4,1,7,8,2,10,0,7,2,8
+S,4,5,5,7,3,7,7,6,9,5,6,8,0,8,9,7
+N,8,11,12,8,7,3,11,3,4,10,11,9,8,7,2,7
+D,3,7,4,5,3,8,7,7,7,9,5,4,3,8,4,7
+N,4,7,7,5,6,7,8,3,5,7,6,7,6,8,7,4
+T,8,13,7,8,3,7,8,3,9,13,5,6,2,9,5,5
+C,4,8,4,6,2,4,8,6,7,11,10,12,2,9,3,7
+T,4,6,5,4,5,7,8,4,5,6,7,9,5,8,5,7
+J,4,6,5,4,2,10,6,2,8,15,4,8,0,8,0,8
+N,4,9,5,7,3,7,7,14,2,4,6,8,6,8,0,8
+S,3,9,4,7,4,8,7,7,5,7,6,7,2,8,8,8
+G,3,4,4,3,2,7,6,7,5,6,6,10,3,8,4,9
+Q,4,7,5,6,3,8,4,8,8,6,4,8,3,8,4,8
+G,4,9,5,7,4,7,6,7,6,6,7,9,2,8,4,8
+R,3,6,5,4,3,10,7,3,6,10,2,7,3,7,3,10
+N,11,13,9,8,5,4,8,5,6,3,2,13,7,11,2,7
+W,5,9,7,7,4,10,8,5,2,6,8,8,9,10,0,8
+V,2,7,4,5,2,6,11,2,3,8,11,8,2,11,1,9
+S,5,7,6,5,4,8,6,3,7,10,7,9,2,10,5,8
+O,5,5,7,4,4,7,6,5,5,9,5,9,3,6,5,6
+V,8,11,7,8,4,3,11,4,4,10,12,8,3,10,1,8
+U,2,3,2,1,1,6,8,5,6,9,8,8,3,10,2,6
+C,4,9,5,7,3,5,8,6,8,12,9,13,2,10,3,7
+O,6,11,6,8,6,7,7,8,4,10,6,9,4,9,5,5
+R,4,6,6,4,5,8,8,7,3,8,4,7,4,6,7,8
+E,5,10,3,5,2,6,9,5,8,9,5,10,1,7,6,8
+U,8,10,8,7,6,4,8,5,8,9,8,10,6,8,4,3
+M,5,8,7,6,7,7,7,6,5,6,7,7,9,8,3,6
+A,2,4,4,5,1,5,5,3,1,5,1,8,2,7,2,7
+H,5,9,8,7,5,9,8,3,6,10,4,7,3,8,3,9
+F,4,6,6,4,2,3,15,4,3,13,8,3,1,10,2,5
+V,4,9,6,7,2,7,12,3,5,8,12,8,3,10,1,8
+I,1,4,2,3,1,7,8,0,7,13,6,8,0,8,1,7
+W,5,9,8,6,5,9,8,4,1,6,9,8,7,11,0,8
+S,4,7,5,5,3,10,7,3,6,9,4,8,2,8,5,11
+N,2,1,3,2,2,6,8,5,4,8,7,7,5,9,1,6
+O,5,10,5,8,4,7,7,8,5,10,7,7,3,8,4,8
+G,5,8,6,6,5,8,7,7,6,6,7,9,2,6,6,10
+Y,6,9,6,4,3,6,7,4,3,10,9,6,3,10,4,4
+D,7,10,9,8,8,7,7,5,7,7,6,7,7,8,3,7
+H,1,0,1,0,0,7,7,10,2,7,6,8,2,8,0,8
+F,6,12,6,6,4,9,7,3,4,10,5,6,3,9,6,9
+Z,4,6,6,4,4,8,7,2,9,12,6,8,1,8,5,8
+N,5,7,7,5,4,8,8,2,5,10,4,6,5,9,1,7
+M,4,6,5,8,4,8,7,12,2,6,9,8,8,6,0,8
+R,4,10,6,8,6,7,7,4,6,7,6,6,6,8,4,8
+W,3,8,5,6,3,11,8,5,1,6,9,8,7,10,0,8
+F,8,15,7,8,6,8,7,3,5,10,5,7,5,7,7,8
+I,2,9,2,7,3,7,7,0,7,7,6,8,0,8,3,8
+V,3,10,6,7,2,8,8,4,3,6,14,8,3,9,0,8
+H,6,10,8,8,7,6,8,3,6,10,8,8,4,8,4,6
+W,10,12,9,6,4,5,9,2,2,7,10,7,9,12,1,6
+P,3,2,4,3,3,5,10,4,5,10,8,4,1,10,4,7
+N,6,10,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+A,5,13,5,7,4,12,2,4,1,11,3,11,4,3,4,11
+A,6,14,6,8,4,11,1,3,3,12,5,13,3,6,5,11
+T,5,7,5,5,3,6,11,2,7,11,9,5,1,11,2,4
+W,3,4,5,3,3,6,11,3,2,7,9,8,7,11,0,8
+P,3,6,5,4,3,8,9,4,4,11,4,4,1,10,3,8
+X,5,8,7,6,5,7,6,3,5,6,6,9,3,8,9,9
+W,5,9,7,7,4,8,8,5,2,7,8,8,9,9,0,8
+Y,3,5,5,3,2,7,10,1,7,7,11,8,1,11,2,8
+M,5,5,6,4,4,7,6,6,5,6,7,9,9,6,2,8
+Y,2,4,4,5,1,7,10,2,2,7,13,8,1,11,0,8
+L,4,9,6,7,3,6,3,2,9,7,1,9,0,6,2,7
+F,3,7,3,4,1,1,13,5,4,12,10,7,0,8,2,6
+J,2,3,3,5,1,12,2,9,4,13,5,13,1,6,0,8
+Y,7,7,7,5,4,3,10,1,8,11,10,6,1,9,2,4
+Q,3,4,4,7,3,7,6,9,6,5,6,7,3,8,5,9
+L,4,11,5,8,3,9,2,1,7,9,2,10,1,6,3,9
+N,1,1,1,1,1,7,7,10,1,5,6,8,4,8,0,8
+C,2,7,3,5,1,5,7,7,9,7,6,14,1,8,4,9
+M,8,10,8,5,4,7,10,5,6,4,5,10,9,8,2,8
+U,4,7,6,5,3,6,8,6,8,7,9,9,3,9,1,8
+X,3,6,6,4,3,7,7,1,9,10,7,9,2,8,3,8
+S,6,8,8,7,8,9,8,5,6,7,6,7,6,10,12,12
+W,6,11,8,8,9,8,6,6,3,6,7,8,8,8,5,5
+F,3,4,3,6,1,1,12,5,5,12,11,8,0,8,2,6
+V,4,6,4,4,2,3,11,4,3,10,11,7,2,10,1,8
+P,3,8,5,6,3,6,10,5,6,10,8,4,1,10,4,7
+C,1,0,2,0,0,7,7,6,8,7,6,13,0,8,4,10
+W,4,8,6,6,7,7,8,5,3,7,8,8,5,8,3,8
+P,2,4,4,3,2,7,9,4,4,12,5,3,1,10,3,8
+M,7,8,10,7,11,8,7,5,5,7,6,7,14,8,7,3
+J,5,7,7,8,6,8,8,4,6,6,7,7,4,9,10,11
+G,4,9,5,7,4,8,7,7,6,6,6,7,2,8,6,11
+T,7,11,7,8,5,5,12,3,6,12,10,5,2,12,1,5
+T,6,10,6,8,4,7,11,4,8,11,9,4,2,12,4,5
+Z,5,11,6,8,5,6,8,6,11,7,7,10,1,9,8,7
+D,7,9,9,8,8,6,7,5,8,7,6,9,6,4,8,3
+D,2,3,4,2,2,9,6,4,6,10,4,6,2,8,2,9
+K,6,9,9,7,7,10,5,1,5,9,3,8,7,6,6,11
+D,4,7,5,5,4,6,7,8,7,7,7,5,3,8,3,7
+W,5,8,8,6,11,8,7,5,2,7,6,8,13,11,3,9
+Q,3,4,4,5,3,7,8,5,2,8,8,10,3,8,5,8
+I,1,9,2,7,2,7,7,0,8,7,6,8,0,8,3,8
+Q,7,14,6,8,5,10,5,4,7,11,4,8,3,7,9,11
+C,2,5,3,4,2,6,8,7,7,8,8,14,1,9,4,10
+T,6,9,5,5,3,7,8,2,7,12,7,8,2,9,4,5
+R,2,2,3,3,2,7,7,5,5,6,5,6,2,7,5,8
+L,2,6,2,4,0,0,2,5,6,0,0,7,0,8,0,8
+Q,2,3,3,4,2,7,8,5,1,7,8,10,2,9,5,8
+X,3,4,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+U,5,5,6,7,2,7,3,15,6,7,13,8,3,9,0,8
+O,4,3,5,5,2,7,8,8,8,7,7,8,3,8,4,8
+J,1,3,2,2,1,11,6,1,6,11,3,7,0,7,0,8
+L,3,6,5,4,2,5,5,1,9,7,2,11,0,7,3,7
+X,3,5,5,4,3,7,7,3,10,6,6,8,3,8,6,8
+F,2,3,3,1,1,5,11,2,5,13,6,4,1,9,1,8
+W,8,8,11,7,12,7,6,5,5,7,5,8,10,9,8,9
+M,6,9,8,7,9,7,9,7,5,7,6,8,10,10,8,6
+Q,2,1,2,1,1,8,6,6,4,6,6,8,2,8,3,8
+K,7,9,7,4,3,7,8,3,7,9,6,8,6,8,3,7
+T,2,3,3,2,1,5,12,3,6,11,9,4,1,10,2,5
+J,1,4,3,3,1,9,6,3,6,14,5,9,0,7,0,8
+F,3,2,4,4,3,5,11,3,6,11,9,5,1,10,3,6
+I,2,6,2,4,1,6,8,0,6,13,7,8,0,8,1,7
+T,3,4,5,6,1,6,15,1,6,8,11,7,0,8,0,8
+A,3,9,6,7,4,10,2,1,2,8,3,9,4,5,3,7
+M,8,11,11,8,8,6,6,3,5,9,8,9,8,6,2,8
+M,4,9,7,6,9,8,6,3,1,7,4,8,10,7,2,6
+O,5,11,6,8,3,7,8,9,8,7,8,8,3,8,4,8
+Y,5,9,6,6,3,2,11,4,5,12,12,7,1,11,2,6
+P,3,9,4,6,2,4,11,9,3,10,6,4,1,10,4,8
+R,4,4,4,6,3,5,11,8,3,7,4,8,3,7,6,11
+O,3,8,4,6,2,7,6,9,7,6,5,7,3,8,4,8
+A,3,7,5,5,3,8,2,2,2,7,2,7,2,6,3,6
+M,3,2,5,3,4,8,6,6,4,7,7,9,9,5,2,8
+R,3,6,4,4,4,8,8,7,2,7,4,7,4,7,7,8
+Z,4,7,5,5,4,9,7,5,3,7,5,7,3,8,9,5
+C,2,5,3,4,2,5,8,7,8,8,8,14,1,9,4,10
+D,1,0,2,1,1,5,7,8,6,7,6,6,2,8,3,8
+P,2,4,4,3,2,8,9,4,3,12,5,4,1,10,2,9
+C,4,10,5,7,3,4,8,6,6,12,10,13,1,10,3,8
+E,5,10,5,8,5,3,8,5,9,7,6,14,0,8,6,8
+M,2,3,4,2,2,8,7,2,4,9,6,8,6,5,1,7
+Z,3,5,5,4,3,7,8,2,9,12,6,8,1,8,5,7
+C,5,10,3,5,2,7,8,7,5,11,6,9,2,9,5,9
+Q,6,9,8,8,7,6,4,5,6,6,5,8,6,1,8,6
+G,3,7,5,5,5,9,7,6,2,6,7,9,5,8,3,8
+Z,3,5,6,4,3,7,8,2,10,12,6,8,1,9,5,7
+S,5,6,7,6,7,8,8,4,5,7,7,8,4,10,9,10
+S,7,15,6,8,3,7,4,5,5,8,2,7,4,6,6,7
+H,6,9,7,4,4,7,8,3,5,10,6,8,6,9,5,8
+Q,4,5,5,7,3,8,9,8,5,5,9,9,3,7,6,10
+K,6,10,8,8,10,8,8,4,5,5,7,9,9,8,9,7
+J,8,12,6,9,5,7,11,3,3,13,5,4,3,9,9,9
+Y,5,7,7,10,10,7,6,4,2,8,8,9,8,11,9,7
+Q,3,9,4,8,3,8,6,9,6,6,5,8,3,8,4,8
+S,4,11,5,8,3,9,8,6,9,5,6,5,0,8,9,7
+J,0,0,1,0,0,12,4,6,3,12,5,11,0,7,0,8
+X,1,0,2,0,0,7,7,3,4,7,6,8,3,8,4,8
+G,1,0,2,1,1,8,7,6,5,6,5,9,1,7,5,10
+W,6,9,8,7,4,6,8,5,2,7,8,8,9,9,0,8
+M,5,7,9,5,10,9,7,3,3,8,4,7,11,6,3,5
+B,2,6,3,4,3,6,6,8,5,6,7,7,2,9,6,10
+M,4,8,6,6,6,8,6,5,5,6,7,8,8,5,2,7
+N,3,6,5,4,5,8,7,4,4,7,5,7,5,10,6,4
+A,4,7,6,5,3,10,1,3,3,9,2,8,3,6,4,9
+W,6,7,6,5,5,3,11,2,2,9,9,8,6,11,2,7
+J,2,4,3,3,1,8,6,3,6,14,5,9,0,7,0,8
+E,2,4,4,3,2,7,8,2,7,11,7,9,2,9,4,8
+Q,4,6,4,7,5,8,8,6,2,7,7,11,3,9,5,8
+P,6,6,8,8,9,6,9,5,3,8,8,6,6,12,5,7
+U,6,9,5,4,3,8,6,5,5,6,6,7,4,7,3,6
+B,3,2,4,3,3,8,7,5,6,7,6,6,5,8,5,10
+N,5,11,7,8,9,9,8,5,4,7,5,5,7,11,9,4
+I,1,8,1,6,2,7,7,0,7,7,6,8,0,8,3,8
+K,3,2,4,4,3,6,7,4,7,6,6,10,3,8,5,9
+D,3,5,5,4,3,9,6,4,6,10,4,6,2,8,3,8
+J,5,11,4,8,3,7,11,3,4,13,4,4,1,7,5,6
+T,8,11,7,6,3,6,9,3,8,13,6,6,2,8,4,5
+N,1,0,2,1,0,7,7,11,0,5,6,8,4,8,0,8
+S,5,10,6,8,4,7,7,3,6,10,6,8,2,8,5,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+N,5,7,7,5,4,10,8,4,6,10,1,4,5,9,1,7
+A,5,7,7,6,6,9,8,3,4,7,7,8,5,6,5,4
+T,3,3,4,2,1,5,11,3,7,11,9,4,1,10,2,5
+H,8,11,12,8,10,9,6,3,6,10,4,8,5,7,5,8
+L,1,0,1,0,0,2,1,6,4,0,3,4,0,8,0,8
+L,3,10,4,7,1,0,1,5,6,0,0,7,0,8,0,8
+Y,5,8,7,12,12,9,7,4,1,6,8,9,6,12,8,9
+L,2,7,4,5,4,7,7,3,4,7,6,10,5,10,6,5
+T,3,10,4,7,3,7,13,0,5,7,10,8,0,8,0,8
+K,4,5,5,7,2,3,7,8,2,7,5,11,4,8,2,11
+Q,3,2,4,4,3,8,8,6,2,5,7,10,3,8,5,10
+F,2,2,3,3,2,5,11,3,5,11,9,5,1,10,3,6
+K,6,8,9,6,4,5,7,3,7,10,9,11,3,8,3,7
+K,3,1,5,3,3,6,7,4,8,7,6,10,6,8,4,9
+I,0,6,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+Y,3,6,5,4,2,10,10,2,6,3,11,8,1,11,2,9
+X,3,8,4,6,3,7,7,4,4,7,6,8,2,8,4,8
+N,4,7,6,5,3,11,7,3,5,10,1,4,5,9,1,7
+D,3,8,5,6,5,7,7,4,6,7,6,5,3,8,3,7
+P,3,9,4,7,4,4,12,7,2,10,7,4,1,10,3,8
+K,7,10,6,5,3,5,8,3,6,9,8,9,5,9,3,7
+T,5,7,7,6,6,7,8,4,8,7,7,8,3,9,8,6
+U,5,8,5,6,2,7,4,13,5,7,15,8,3,9,0,8
+Z,2,4,2,3,2,7,8,5,8,6,6,9,2,8,7,8
+O,3,6,4,4,3,7,7,7,4,7,5,8,3,8,3,8
+H,5,8,6,6,5,7,7,7,6,7,7,8,3,8,3,8
+P,1,3,3,2,1,6,10,3,3,12,6,4,0,9,2,8
+T,5,9,7,7,7,7,8,5,5,6,8,9,7,7,8,7
+O,3,6,4,4,3,7,9,7,4,7,8,7,3,8,2,8
+I,2,5,4,4,2,7,7,0,8,14,6,8,0,8,1,7
+Y,3,6,5,4,2,7,11,1,7,7,11,8,1,11,2,8
+E,7,15,6,8,5,7,7,4,5,10,6,9,3,9,8,10
+G,6,8,8,7,8,7,10,6,2,7,7,8,6,11,7,8
+W,3,7,5,5,3,8,8,4,1,7,8,8,8,10,0,8
+R,3,4,3,3,2,7,8,4,5,6,5,6,3,6,5,8
+W,5,5,6,3,4,4,11,3,2,9,9,7,7,11,1,7
+Q,4,5,5,5,2,9,8,7,6,5,7,9,3,8,5,9
+Y,8,14,7,8,4,5,9,4,3,10,8,5,4,10,4,4
+G,4,7,4,5,3,6,7,6,6,10,7,10,2,9,4,9
+W,4,5,6,3,3,7,11,2,2,7,9,8,8,11,0,8
+R,6,9,9,8,10,7,6,3,4,7,5,8,8,9,6,7
+Y,2,3,3,2,1,8,10,1,6,5,11,9,1,11,1,8
+O,3,7,4,5,3,7,8,7,5,10,8,7,3,8,3,8
+R,4,6,5,4,4,6,8,5,6,7,5,7,3,7,5,8
+E,4,9,4,6,2,3,7,6,11,7,6,15,0,8,7,7
+L,4,9,4,7,3,0,2,4,6,1,0,8,0,8,0,8
+L,4,10,4,8,1,0,1,6,6,0,0,6,0,8,0,8
+F,4,9,6,7,3,4,13,3,4,13,8,4,1,10,2,6
+C,3,6,4,4,2,6,8,8,8,8,8,13,2,10,4,9
+X,3,7,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+F,4,5,5,4,3,5,10,4,6,10,9,5,2,10,3,6
+H,6,11,6,8,3,7,7,15,0,7,6,8,3,8,0,8
+W,3,3,4,2,2,3,10,3,2,10,10,8,5,11,1,6
+C,3,9,4,7,2,5,8,7,9,6,7,13,1,8,4,9
+P,6,9,9,7,5,8,11,8,5,10,4,3,2,10,5,7
+S,4,11,5,8,4,7,7,8,7,8,5,7,2,7,9,8
+K,5,10,8,8,8,5,6,4,7,6,6,12,5,7,7,10
+F,3,7,5,5,5,10,7,1,5,9,5,6,4,10,5,7
+Q,5,5,6,7,6,10,11,6,0,4,7,11,6,14,4,9
+R,6,10,9,9,10,8,8,4,4,7,4,7,7,9,6,4
+S,3,5,6,3,2,7,8,3,7,11,8,7,1,9,4,6
+U,7,8,8,6,3,4,9,6,9,12,11,8,3,9,1,6
+J,6,11,8,8,4,8,6,4,6,15,6,11,1,6,1,7
+F,5,8,7,10,8,7,9,5,5,7,5,7,4,8,9,7
+M,6,10,8,7,6,11,5,3,4,9,3,6,8,6,2,9
+M,5,9,7,6,7,9,7,5,5,6,7,5,8,7,3,5
+B,5,8,7,6,6,10,6,3,6,10,4,7,2,8,5,10
+X,1,0,1,0,0,7,7,3,5,7,6,8,2,8,4,7
+G,5,8,5,6,3,6,7,7,6,10,7,11,2,9,4,9
+H,3,8,4,6,4,7,8,12,1,7,5,8,3,8,0,8
+J,6,10,8,7,4,9,7,2,7,14,4,7,0,7,0,8
+F,2,3,4,2,2,8,9,2,6,13,5,4,1,9,2,8
+L,1,3,3,2,1,6,4,1,7,7,2,9,0,7,2,8
+X,9,13,9,7,5,8,7,2,8,11,4,7,4,9,4,7
+G,6,11,5,6,4,8,7,4,3,9,6,7,4,9,9,8
+I,2,10,2,8,2,8,7,0,9,7,6,7,0,8,3,7
+Z,5,7,7,9,5,11,4,3,4,9,3,8,2,7,6,9
+M,4,7,6,5,5,11,6,3,4,9,3,6,7,6,2,8
+L,4,7,5,5,3,7,4,1,8,8,2,10,0,6,2,8
+E,3,7,3,5,3,3,8,5,8,7,7,13,0,8,6,9
+W,4,4,5,3,3,7,11,3,2,6,9,8,7,11,0,8
+J,6,9,8,7,5,9,4,7,7,8,6,6,2,7,5,6
+W,4,11,7,8,11,8,6,7,3,7,6,8,14,10,5,9
+V,5,6,5,4,2,3,12,3,3,10,11,7,2,11,1,8
+J,2,2,3,3,1,9,6,3,6,12,4,10,1,6,1,6
+N,6,9,9,7,4,6,8,3,5,10,8,8,6,8,1,7
+S,4,4,5,6,3,8,8,6,9,5,6,7,0,8,9,8
+V,2,2,3,3,1,6,12,2,3,8,11,8,2,10,1,9
+A,2,2,4,3,2,7,2,2,2,6,1,8,2,6,2,7
+T,7,11,7,8,5,5,10,0,8,11,9,6,1,9,3,4
+K,6,7,8,5,6,9,6,1,6,10,3,8,7,7,6,10
+E,4,7,5,5,3,7,7,3,8,11,7,9,2,9,5,8
+H,4,7,5,4,2,7,7,14,0,7,6,8,3,8,0,8
+J,5,9,7,7,5,8,7,7,7,8,7,8,3,6,5,5
+A,3,9,6,7,5,7,5,2,3,5,2,6,4,5,5,5
+F,3,7,3,5,1,1,14,5,3,12,9,5,0,8,2,6
+D,2,6,4,4,5,9,8,4,4,7,6,6,3,8,7,4
+F,3,2,4,4,3,5,10,3,5,10,9,5,1,10,3,6
+U,7,11,7,8,4,3,8,5,8,11,10,10,3,9,2,6
+C,6,13,5,8,4,6,8,5,4,9,8,10,4,9,10,8
+E,3,5,4,7,2,3,8,6,11,7,5,15,0,8,7,7
+S,7,10,9,8,6,9,7,3,7,10,4,7,3,9,5,9
+C,1,3,2,2,1,7,8,6,5,9,7,11,2,10,3,10
+C,5,8,5,6,3,4,8,5,7,11,10,13,1,9,3,8
+S,2,2,3,4,2,8,7,7,5,7,7,8,2,9,9,8
+J,3,10,4,7,1,12,2,10,4,14,5,13,1,6,0,8
+K,3,5,5,4,3,6,7,1,7,10,7,10,3,8,2,8
+R,5,11,8,8,7,10,7,3,6,10,3,7,4,5,5,11
+J,1,1,2,1,0,11,6,2,6,12,3,8,0,7,0,8
+L,2,7,2,5,1,0,1,5,6,0,0,7,0,8,0,8
+U,5,8,5,6,4,6,7,6,8,8,6,8,6,10,4,3
+F,0,0,1,0,0,3,11,4,2,11,8,6,0,8,2,8
+R,3,7,5,5,3,8,8,4,6,9,3,8,3,7,4,11
+R,4,9,6,7,4,9,8,3,6,9,3,8,3,6,4,11
+K,4,9,5,7,7,6,7,3,3,6,5,9,6,8,8,7
+O,4,5,6,4,4,7,6,5,5,8,5,8,3,7,5,6
+E,5,8,6,6,6,8,5,6,3,7,7,9,4,8,8,10
+S,2,7,3,5,2,8,8,5,7,5,6,8,0,8,8,8
+L,5,11,4,6,2,10,2,3,4,13,4,11,2,8,5,9
+K,6,11,7,6,4,4,9,3,6,10,10,11,5,8,3,6
+P,3,5,5,4,2,8,9,4,4,11,4,3,1,10,3,8
+K,5,7,7,6,7,7,9,3,5,7,3,9,6,2,7,10
+A,3,8,5,6,3,12,2,3,2,10,2,9,2,6,3,8
+F,3,8,4,6,3,1,12,4,4,12,10,7,0,8,2,7
+J,3,11,4,8,3,8,6,3,6,11,5,10,1,6,2,5
+M,10,9,10,4,4,7,11,5,5,4,5,10,10,12,2,7
+Y,2,3,4,5,1,9,10,3,2,6,13,8,2,11,0,8
+B,3,8,4,6,4,8,8,8,7,7,5,5,2,8,8,9
+F,5,11,8,8,9,5,10,0,4,9,7,6,6,9,5,2
+H,5,10,5,7,3,7,5,15,2,7,9,8,3,8,0,8
+T,1,6,2,4,1,7,13,0,6,7,10,8,0,8,0,8
+E,4,6,6,4,5,7,9,6,3,6,6,9,4,7,7,8
+G,4,7,5,5,3,6,7,7,6,8,7,11,2,7,4,10
+J,3,9,5,7,2,8,7,2,8,15,4,7,0,7,0,8
+D,4,7,4,5,2,6,7,10,9,7,7,6,3,8,4,8
+E,5,8,7,6,5,7,7,2,7,11,6,9,3,7,5,9
+F,4,8,5,6,3,6,10,2,5,13,7,5,2,10,2,8
+K,7,10,9,8,9,8,8,6,5,8,5,6,5,7,8,11
+P,2,7,3,4,2,5,10,9,3,9,6,5,2,10,3,8
+E,5,10,7,8,7,8,7,6,3,7,6,9,4,8,8,10
+Y,3,9,5,7,3,9,10,1,6,4,11,8,2,12,2,8
+G,5,7,6,5,6,7,8,6,2,6,6,9,5,7,7,7
+A,3,7,5,5,3,10,2,2,2,9,1,8,2,6,3,8
+Q,3,6,4,5,2,8,9,7,6,5,8,9,3,8,5,10
+Z,6,10,8,7,6,7,7,2,9,12,6,8,1,8,6,8
+P,6,9,6,4,4,8,8,5,3,10,5,6,5,10,5,6
+H,2,4,4,2,2,7,8,3,6,10,6,8,3,8,2,8
+R,2,1,3,2,2,7,8,4,5,6,5,7,2,6,5,8
+S,1,0,1,0,0,8,7,3,6,5,6,7,0,8,7,8
+J,3,9,4,7,4,8,6,2,5,11,4,9,4,6,2,6
+A,2,8,4,6,2,8,4,3,2,7,1,8,3,7,2,8
+P,3,6,4,9,8,8,8,4,0,8,7,7,5,9,4,7
+L,5,9,7,7,3,6,4,1,9,8,2,10,0,7,2,8
+U,4,9,6,8,6,7,7,4,3,6,6,9,5,6,2,8
+R,2,1,2,2,1,6,9,8,3,7,5,8,2,7,5,11
+V,5,6,6,4,2,4,13,4,4,10,11,6,3,10,1,8
+C,1,0,2,1,0,6,7,6,9,7,6,14,0,8,4,10
+N,5,9,7,7,4,3,9,4,4,11,11,10,5,7,1,8
+D,5,10,6,8,7,8,7,4,8,6,5,6,6,8,3,7
+Q,6,6,7,9,4,8,10,8,6,5,9,9,3,8,6,10
+P,1,3,3,2,1,7,9,4,3,11,5,4,1,9,2,8
+B,3,6,4,4,3,10,6,3,6,10,3,7,2,8,4,11
+X,4,9,6,7,3,10,7,2,8,10,1,7,3,8,4,9
+W,6,11,10,8,7,4,11,2,3,8,9,9,8,11,1,8
+H,7,12,6,6,4,8,8,3,4,9,6,7,6,9,5,9
+K,2,3,4,2,2,4,7,2,6,10,9,11,3,8,2,7
+I,3,10,4,8,2,7,7,0,8,13,6,8,0,8,1,8
+Z,4,9,6,7,6,7,7,3,7,7,6,9,0,8,9,7
+R,5,9,5,7,6,6,9,8,3,7,5,8,3,8,6,12
+A,2,6,4,4,3,7,2,1,2,6,2,7,2,6,3,6
+M,3,1,4,2,1,7,7,11,1,7,9,8,7,6,0,8
+J,1,0,1,1,0,12,3,6,3,13,5,11,0,7,0,8
+H,3,8,4,5,2,7,7,15,1,7,6,8,3,8,0,8
+W,3,7,5,5,4,7,11,2,2,7,8,8,6,11,1,8
+R,5,11,6,8,6,6,7,5,6,7,6,7,6,8,5,8
+V,4,9,6,7,3,4,11,3,4,9,12,9,2,10,1,8
+F,3,5,4,3,2,5,10,3,6,10,9,6,1,10,3,6
+A,3,3,5,5,2,6,3,3,3,6,2,7,3,6,3,7
+X,1,1,2,1,0,7,7,4,4,7,6,8,2,8,4,7
+K,4,6,5,4,3,6,8,2,7,10,7,9,3,8,3,7
+F,3,6,4,4,2,6,11,4,5,12,7,4,2,10,2,6
+C,5,10,6,8,7,5,6,3,4,7,6,11,6,9,4,7
+T,3,6,5,4,3,6,11,3,7,8,11,7,4,11,1,7
+N,7,9,9,7,9,6,8,3,4,8,7,8,8,8,7,4
+R,1,0,2,1,1,6,9,7,3,7,5,8,2,7,4,11
+K,6,9,9,7,6,5,7,2,8,10,8,10,4,7,4,7
+N,7,9,8,4,3,10,6,3,4,13,3,7,6,8,0,8
+Y,5,11,7,8,1,8,11,2,2,7,13,8,1,11,0,8
+M,5,10,6,7,6,8,5,11,0,6,9,8,9,6,2,6
+X,3,5,4,4,2,8,7,3,9,6,6,8,2,8,6,8
+Q,5,5,7,8,9,8,7,5,1,6,6,9,9,12,7,13
+V,4,9,5,7,3,7,11,2,4,7,12,9,3,10,1,8
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+V,2,3,4,4,1,7,8,4,2,7,13,8,3,10,0,8
+B,4,9,6,7,6,9,6,4,5,9,5,7,2,8,5,9
+Y,6,11,9,8,5,6,9,0,8,8,12,9,1,11,2,7
+C,5,10,6,8,2,4,7,7,11,7,6,12,1,8,4,9
+A,2,5,4,4,2,11,2,2,2,9,2,9,2,6,2,8
+K,5,10,8,8,4,3,8,4,7,10,12,12,4,8,4,6
+G,3,8,4,6,2,7,6,8,7,6,6,9,2,7,6,11
+T,2,6,4,4,2,9,11,1,7,5,11,7,1,10,1,8
+H,4,11,5,8,3,7,7,15,1,7,6,8,3,8,0,8
+T,4,6,4,4,2,5,11,2,7,11,9,5,1,10,2,5
+R,3,7,5,5,3,9,7,4,6,10,4,7,3,7,4,10
+Z,4,10,4,8,4,7,8,3,12,9,6,8,0,8,7,7
+E,3,8,4,6,4,6,7,7,9,7,7,11,3,8,6,8
+H,5,8,8,6,6,7,6,3,6,10,7,8,3,8,3,7
+E,4,10,6,8,5,8,7,5,9,7,6,8,3,8,6,9
+X,4,7,7,5,4,9,7,1,8,10,3,7,3,8,3,9
+R,2,1,2,2,2,6,7,4,4,6,5,7,2,7,3,8
+P,3,6,4,4,2,4,12,8,2,10,6,4,1,10,4,8
+A,4,11,6,8,4,12,3,3,3,9,1,9,2,6,3,8
+B,4,9,4,7,3,6,8,9,7,7,6,7,2,8,9,10
+Q,5,7,5,8,5,8,5,7,5,9,5,9,3,8,5,7
+W,3,9,5,6,5,7,11,2,2,6,8,8,7,11,0,8
+G,3,5,4,4,2,6,7,5,6,9,7,11,2,9,4,10
+N,3,3,3,5,2,7,7,13,2,5,6,8,5,8,0,8
+W,6,10,8,8,9,7,9,6,4,7,9,7,7,7,5,10
+Q,2,1,3,2,1,8,6,7,5,6,6,8,3,8,4,8
+P,7,11,9,8,8,6,7,7,4,8,7,8,2,10,7,9
+Q,6,9,7,11,7,7,10,5,3,6,9,12,3,9,7,8
+D,3,2,4,3,3,7,7,6,6,6,6,5,5,8,3,7
+L,5,10,7,8,9,7,7,3,5,7,7,10,6,11,6,6
+L,2,7,4,5,2,9,4,1,6,9,3,10,0,6,2,10
+I,5,10,6,8,4,7,8,1,7,7,6,8,0,8,4,8
+V,3,9,5,7,1,9,8,4,3,6,14,8,3,10,0,8
+E,3,5,5,4,3,6,8,2,8,11,8,9,2,8,4,8
+D,4,9,6,7,5,7,7,7,8,6,5,4,3,8,3,7
+O,4,8,5,6,2,7,8,8,8,7,7,8,3,8,4,8
+J,6,8,4,11,3,6,10,3,4,13,5,5,3,8,7,8
+D,2,5,4,4,3,10,6,3,6,10,3,6,2,8,3,8
+M,5,10,7,6,4,13,2,5,2,12,1,9,6,3,1,8
+E,5,10,7,8,7,7,8,7,9,7,6,11,3,8,6,8
+G,3,4,4,3,2,6,7,5,5,9,7,10,2,9,4,10
+A,2,3,4,1,1,10,2,3,1,9,2,9,1,6,1,8
+R,3,6,4,4,3,10,6,3,6,10,3,7,3,7,3,10
+Q,4,9,5,8,5,8,8,7,5,6,8,9,3,8,5,10
+D,3,6,4,4,3,9,7,4,5,10,4,5,3,8,2,8
+I,3,11,4,9,2,7,8,0,8,13,6,7,0,8,1,7
+A,3,9,5,7,3,12,3,4,3,10,1,9,2,7,3,9
+L,3,6,3,4,1,0,1,6,6,0,1,5,0,8,0,8
+K,4,5,5,4,4,5,7,4,7,6,6,11,3,8,5,9
+V,7,10,7,8,3,2,11,6,5,13,12,7,3,9,1,8
+T,3,5,4,4,2,5,12,3,6,11,10,5,1,11,1,5
+P,4,6,4,8,3,5,9,10,5,8,6,5,2,10,4,8
+P,1,1,1,1,0,5,11,7,2,9,6,4,1,9,3,8
+R,1,0,1,0,0,6,9,6,3,7,5,8,2,6,3,10
+X,4,10,6,8,4,7,7,4,9,6,6,8,3,8,7,7
+F,4,9,4,7,3,1,13,4,4,12,10,7,0,8,2,6
+Q,1,2,2,3,1,7,8,4,1,7,8,10,2,9,3,8
+F,4,6,5,7,6,7,9,5,4,8,6,7,4,10,9,7
+T,5,10,7,7,6,6,7,7,7,7,10,9,4,6,8,7
+Q,4,5,6,4,4,7,4,4,5,7,4,9,4,5,6,7
+O,2,4,3,2,2,8,7,6,4,9,6,8,2,8,2,8
+O,5,8,6,6,5,8,7,7,4,10,6,7,3,8,3,8
+J,2,7,3,5,2,9,6,2,6,11,4,8,1,6,1,6
+O,7,11,5,6,3,7,9,6,5,9,5,6,4,9,5,8
+L,1,0,1,0,0,3,1,6,4,1,3,4,0,8,0,8
+C,2,4,3,3,1,4,8,4,6,11,9,12,1,9,2,8
+E,4,8,6,6,7,6,7,3,6,6,7,11,3,10,8,7
+M,9,14,11,8,7,5,4,4,3,7,4,10,10,1,2,8
+R,5,7,7,5,4,9,7,4,6,10,3,7,4,5,5,10
+I,3,10,4,8,2,6,9,0,8,13,7,7,0,8,1,7
+J,2,4,3,3,1,11,6,1,6,11,3,7,0,7,0,7
+R,3,7,3,5,3,6,10,7,3,7,4,8,2,7,5,11
+Z,2,4,4,3,2,7,7,2,9,11,6,9,1,9,6,7
+Y,3,5,5,6,1,9,12,2,3,5,12,8,1,10,0,8
+T,2,1,2,1,0,8,15,1,4,6,10,8,0,8,0,8
+T,5,7,6,5,4,6,10,1,8,11,9,5,1,10,3,4
+R,4,7,5,5,5,8,6,6,3,8,5,7,4,7,7,10
+I,1,8,1,6,1,7,7,0,8,7,6,8,0,8,3,8
+T,5,8,7,6,7,8,8,6,7,8,6,8,5,7,5,6
+I,0,0,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+Z,4,8,4,6,4,8,7,5,9,7,5,7,2,8,8,8
+Y,3,4,5,6,1,7,10,2,2,7,13,8,1,11,0,8
+U,6,10,8,8,5,5,8,6,8,7,10,10,3,9,1,8
+C,5,10,6,8,4,4,9,6,7,7,8,15,1,8,4,10
+T,3,9,4,6,1,6,15,1,6,8,11,7,0,8,0,8
+K,5,7,8,5,4,7,8,2,7,10,6,8,3,8,3,7
+Q,4,7,4,9,4,8,5,8,5,9,6,9,3,7,5,8
+Y,3,8,5,5,1,9,11,3,2,5,12,8,1,11,0,8
+H,2,4,3,3,2,7,7,6,5,7,6,9,3,8,3,8
+J,2,6,3,4,3,9,6,2,5,11,4,9,1,6,1,6
+K,4,7,5,5,6,7,9,5,4,8,5,8,4,6,6,10
+O,4,8,5,6,3,7,7,7,5,10,7,8,3,8,3,8
+Q,2,2,3,2,2,7,8,4,2,8,7,9,2,9,4,8
+B,2,3,3,1,2,7,7,4,5,7,6,6,1,8,5,9
+M,4,7,6,5,5,7,6,6,5,7,7,9,8,5,2,9
+Y,3,6,4,4,0,8,10,3,2,6,13,8,1,11,0,8
+Y,3,7,5,4,1,7,10,2,2,6,13,8,1,11,0,8
+T,2,3,3,2,1,6,11,2,6,11,9,5,1,11,2,5
+V,3,10,5,7,4,7,11,2,3,5,11,9,2,11,1,8
+S,4,8,5,6,3,7,8,4,8,11,7,7,2,8,5,6
+B,5,9,7,6,10,8,6,5,3,7,7,8,6,9,8,9
+S,2,2,3,3,2,7,7,6,5,8,6,8,2,9,9,8
+M,4,5,8,4,4,9,6,3,5,9,5,7,8,7,2,8
+Y,2,0,2,0,0,7,10,3,1,7,12,8,1,11,0,8
+N,2,1,3,1,2,7,8,6,4,7,6,6,5,9,2,6
+D,4,8,6,6,4,8,7,5,7,11,5,5,3,8,3,8
+M,3,4,6,3,3,5,6,4,4,10,10,11,8,7,3,8
+Z,4,9,6,7,4,7,9,2,9,11,7,6,1,7,6,6
+R,3,8,5,6,6,8,8,3,4,6,6,8,6,10,7,6
+V,7,11,7,8,3,4,11,3,4,9,11,7,3,10,1,8
+S,4,6,6,4,6,9,6,4,3,9,6,9,4,8,10,10
+Z,1,4,2,3,2,7,7,5,8,6,6,9,2,8,7,8
+G,4,6,4,4,2,6,7,6,6,10,8,10,2,9,4,9
+J,5,7,7,5,4,9,5,5,6,8,6,6,2,7,4,6
+L,2,2,3,3,2,4,4,4,7,2,1,6,1,7,1,6
+Z,3,6,4,4,2,7,7,3,14,9,6,8,0,8,8,8
+R,7,10,9,8,8,9,8,3,6,9,3,8,3,6,4,11
+J,2,11,3,8,2,13,3,6,4,13,2,10,0,7,0,8
+N,4,5,7,4,3,6,9,2,5,10,7,7,5,8,1,8
+X,1,1,2,1,1,8,7,3,8,7,6,8,2,8,5,8
+L,4,9,6,7,7,7,7,3,6,8,7,10,7,10,7,5
+H,7,11,9,9,9,6,7,7,4,6,5,7,3,7,7,10
+O,4,9,3,4,2,6,7,6,3,9,6,8,4,10,4,7
+M,6,10,9,8,9,7,6,5,5,7,7,11,14,6,2,9
+V,2,3,4,5,1,8,8,4,2,6,13,8,3,10,0,8
+Y,8,11,8,8,4,2,11,4,5,13,13,8,1,11,2,6
+Q,6,6,8,9,4,8,6,8,8,6,5,8,3,8,4,8
+M,4,8,6,6,5,10,6,6,4,6,7,5,7,5,2,5
+Q,3,6,5,8,7,9,7,5,1,6,6,9,7,9,4,9
+A,3,6,5,4,2,10,3,2,2,8,3,10,2,6,2,7
+U,5,7,7,5,5,8,7,8,5,6,7,9,3,8,4,6
+B,4,7,6,5,5,7,8,5,5,9,7,6,3,7,6,7
+S,7,15,5,8,3,10,3,4,4,10,3,10,4,6,5,11
+B,6,10,8,7,8,8,8,4,6,10,6,6,5,7,7,9
+K,4,7,7,5,4,3,8,3,7,11,11,11,3,8,3,5
+R,4,8,7,7,8,7,8,3,4,7,4,8,6,8,5,6
+W,5,8,7,6,4,3,11,3,3,9,10,10,7,11,1,8
+H,4,7,5,5,5,6,7,5,7,7,6,10,6,8,3,9
+H,2,1,2,1,1,7,7,12,1,7,6,8,3,8,0,8
+X,4,11,5,8,2,7,7,5,4,7,6,8,3,8,4,8
+C,2,4,3,3,1,4,8,4,7,10,9,13,1,8,2,7
+I,5,8,7,6,3,9,4,3,6,6,7,4,1,10,4,7
+G,3,3,4,4,2,7,6,7,8,6,5,10,1,8,6,11
+X,2,3,3,4,1,7,7,4,4,7,6,8,3,8,4,8
+Y,4,7,6,9,7,10,9,5,2,6,7,8,7,11,7,5
+M,5,10,8,8,6,12,6,2,4,9,3,6,8,6,2,8
+X,10,14,9,8,5,7,7,2,10,9,6,8,4,6,4,8
+M,5,7,7,6,9,5,8,5,3,6,5,8,11,7,6,8
+C,4,8,4,6,3,4,8,6,6,12,10,12,2,9,3,8
+U,8,10,9,8,4,3,9,6,8,12,11,9,3,9,1,7
+R,5,11,7,8,7,9,8,4,5,9,4,7,3,7,4,11
+I,0,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+O,4,4,5,7,2,7,8,8,8,6,8,9,3,8,4,8
+B,2,1,3,2,2,8,7,5,6,7,6,5,2,8,6,9
+E,4,6,6,4,4,6,8,2,9,11,7,10,2,9,4,8
+N,5,10,5,8,3,7,7,15,2,4,6,8,6,8,0,8
+M,4,5,8,4,4,7,6,3,4,9,7,8,7,5,2,8
+F,1,3,2,1,1,6,10,3,4,13,7,5,1,9,1,8
+R,3,6,4,4,2,5,10,8,2,7,4,8,2,7,6,11
+D,4,10,4,7,3,6,7,11,9,6,5,6,3,8,4,8
+U,4,7,5,5,2,7,5,12,5,7,15,8,3,9,0,8
+V,3,11,5,8,4,7,11,2,3,6,11,9,2,10,1,8
+U,5,9,5,6,4,8,5,12,4,7,12,8,3,9,0,8
+I,0,1,1,2,0,7,7,2,6,7,6,8,0,8,2,8
+V,5,11,8,8,9,7,6,4,2,7,8,8,5,9,4,7
+D,4,7,4,5,2,5,7,10,8,6,5,5,3,8,4,8
+V,4,7,5,5,3,9,12,2,3,3,10,9,3,11,2,8
+O,6,10,4,5,3,6,9,7,4,9,7,10,5,10,5,7
+E,3,6,4,4,3,5,8,3,7,11,8,9,2,8,5,7
+Z,8,8,5,12,5,10,3,4,5,12,5,9,3,8,9,11
+S,6,10,7,8,4,8,7,5,9,11,4,7,2,7,5,9
+C,4,7,5,5,3,8,7,8,6,6,7,10,3,8,3,9
+W,7,11,7,8,6,3,10,2,3,10,10,8,8,10,2,6
+J,2,6,4,4,2,9,5,4,5,14,4,10,0,7,0,8
+T,3,3,4,2,1,5,11,2,7,11,9,5,1,10,2,5
+N,8,15,10,9,5,4,9,4,4,13,11,9,6,9,0,9
+X,4,9,6,6,4,3,9,2,8,11,12,10,3,8,4,4
+R,4,9,6,6,5,9,7,5,5,9,4,7,3,7,4,11
+K,6,11,9,8,6,2,9,3,7,11,12,12,3,8,4,5
+A,3,7,6,5,4,5,5,3,3,3,2,6,4,6,4,4
+S,4,9,5,7,5,7,7,7,5,7,6,7,2,8,8,8
+Z,2,1,2,1,1,7,7,5,8,6,6,8,1,8,6,8
+G,6,6,8,6,7,7,9,5,3,7,7,8,8,11,8,7
+K,5,10,6,7,2,3,8,8,2,7,5,11,4,8,3,10
+G,4,5,5,4,3,6,6,6,6,6,6,10,2,9,4,8
+W,3,6,5,4,6,10,7,4,2,7,6,8,5,10,1,5
+G,7,11,8,8,7,5,5,6,6,6,5,11,4,10,4,9
+T,4,5,5,4,2,6,11,2,8,11,9,5,1,10,3,4
+B,4,8,6,6,8,8,8,4,3,6,7,7,6,11,8,8
+X,4,7,5,6,5,6,7,2,4,7,7,10,3,10,7,8
+M,4,7,8,5,8,10,4,2,1,9,4,9,8,6,2,6
+V,4,9,6,7,1,6,8,5,3,8,14,8,3,9,0,8
+T,7,8,7,6,5,7,10,3,7,10,9,5,4,11,5,5
+A,6,10,8,8,8,7,7,8,4,7,6,8,4,8,11,2
+P,6,6,6,8,3,4,13,8,2,10,6,3,1,10,4,8
+L,3,6,3,4,1,1,0,6,6,0,1,5,0,8,0,8
+O,7,11,8,8,7,8,7,8,5,9,5,7,5,8,5,10
+T,4,11,6,8,5,9,11,1,8,6,11,8,1,11,1,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+J,4,8,5,6,2,7,6,4,6,15,6,11,1,6,1,7
+K,4,7,4,4,2,4,9,8,2,7,4,11,4,8,3,10
+Y,4,7,4,5,1,3,12,4,5,13,11,5,1,11,1,6
+E,6,9,8,7,6,9,6,1,8,11,4,9,4,8,5,10
+C,4,9,5,7,3,4,8,6,8,12,10,12,1,9,3,7
+W,9,10,8,7,8,4,11,3,2,9,8,7,7,12,3,6
+L,4,10,4,7,1,0,1,5,6,0,0,6,0,8,0,8
+P,9,15,8,8,4,6,10,6,5,14,5,4,4,10,4,8
+G,4,8,5,6,3,7,7,7,7,10,7,12,2,9,4,9
+X,4,9,5,6,3,7,7,4,4,7,6,7,3,8,4,8
+I,3,10,5,7,6,9,6,3,4,8,5,5,6,7,5,5
+F,3,6,6,4,5,5,9,2,3,10,8,7,5,9,3,4
+W,3,2,5,4,3,7,10,2,2,6,9,8,7,11,0,7
+D,5,9,5,4,3,7,7,4,6,10,6,7,5,9,6,5
+F,4,11,5,8,4,3,11,3,7,11,10,6,1,10,3,5
+I,0,3,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+J,4,6,2,9,2,12,5,2,4,9,5,7,2,9,4,11
+B,5,10,8,7,8,9,6,4,6,9,5,7,2,8,6,10
+W,5,10,8,7,6,5,8,4,1,7,9,8,7,11,0,8
+U,3,9,4,6,3,7,6,13,4,6,10,8,3,9,0,8
+F,10,15,9,8,6,6,9,3,5,10,6,7,5,7,9,6
+A,4,9,6,7,5,8,2,1,2,6,2,7,5,6,6,7
+Z,1,3,2,1,1,8,7,5,8,6,6,8,1,8,6,8
+X,6,11,10,8,5,10,7,2,9,11,1,6,4,9,4,10
+N,7,13,8,7,4,4,9,4,4,13,11,10,5,9,0,8
+U,4,8,6,7,5,8,8,5,4,5,7,8,7,8,2,7
+N,4,8,6,6,4,4,10,3,4,10,10,9,5,8,1,8
+Z,3,7,5,5,3,7,8,2,9,11,8,6,1,8,6,5
+D,5,10,6,7,3,6,7,10,10,6,5,6,3,8,4,8
+C,1,0,2,1,0,6,7,6,8,7,6,14,0,8,4,10
+Q,2,3,3,4,2,8,8,5,2,8,8,10,2,9,4,8
+M,4,9,5,7,6,7,6,10,1,7,8,8,8,5,0,8
+T,3,4,4,5,1,7,15,1,5,7,11,8,0,8,0,8
+Q,4,6,5,7,5,9,9,7,2,4,7,11,3,9,5,10
+T,8,10,8,8,5,5,11,2,7,11,10,5,2,12,2,4
+G,3,4,4,3,2,7,6,6,6,6,6,10,2,9,4,9
+O,5,8,6,6,5,8,7,7,4,9,6,7,3,7,4,9
+C,4,7,4,5,2,3,8,5,7,11,11,12,1,8,2,7
+B,6,11,8,8,7,9,7,4,6,10,5,6,3,8,6,10
+C,5,6,6,5,5,5,6,3,6,7,7,11,5,11,7,8
+Q,4,7,6,5,4,8,4,7,4,6,6,11,3,8,5,9
+U,4,5,5,4,2,5,8,5,8,9,7,8,3,9,3,5
+W,11,15,11,8,5,2,9,3,2,9,11,9,9,12,0,6
+O,2,4,3,2,2,7,7,7,5,9,6,8,2,8,3,8
+K,3,4,5,3,3,9,7,2,7,10,3,8,3,8,3,9
+C,2,5,3,4,2,6,8,7,8,9,8,13,1,10,4,10
+S,5,10,7,7,4,8,7,4,9,11,5,7,2,8,5,8
+A,3,6,5,4,3,8,5,3,0,7,1,8,2,6,1,8
+J,4,9,6,7,3,5,9,2,6,15,7,8,1,7,1,7
+N,2,4,4,3,2,7,9,2,4,10,6,6,5,8,1,7
+E,2,7,4,5,3,7,7,5,8,6,5,8,3,8,6,9
+T,5,12,5,6,3,7,9,2,6,11,6,6,2,9,5,5
+A,2,8,4,5,2,9,5,3,1,8,1,8,2,7,2,8
+T,2,8,3,5,1,9,14,1,6,5,11,9,0,8,0,8
+O,4,6,4,4,3,7,7,7,5,10,7,9,3,8,3,8
+V,1,0,2,0,0,8,9,3,1,6,12,8,2,11,0,8
+E,3,7,3,5,2,3,8,6,10,7,6,14,0,8,7,8
+F,4,7,6,5,3,7,10,3,6,13,5,4,2,10,2,7
+F,5,12,6,8,2,1,13,5,4,12,10,7,0,8,3,6
+Q,8,12,7,6,4,12,3,3,7,11,2,9,3,8,5,14
+H,6,7,8,5,5,7,7,3,7,10,7,9,3,8,3,7
+Q,3,3,4,5,3,8,8,6,2,5,7,9,3,8,5,9
+O,7,11,9,8,6,8,7,9,5,7,6,6,4,8,5,10
+Z,6,11,8,8,7,10,5,5,5,8,5,7,4,7,10,5
+L,3,3,3,5,1,0,1,6,6,0,0,6,0,8,0,8
+Y,6,8,6,6,3,2,11,3,6,12,12,6,1,11,2,5
+C,3,5,4,4,2,6,8,7,7,9,8,12,2,10,4,10
+J,2,7,2,5,1,13,4,5,4,13,2,9,0,7,0,8
+Z,3,8,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+L,2,2,3,3,1,4,4,3,7,2,1,7,0,7,1,6
+U,3,7,4,5,3,7,6,11,4,7,12,8,3,9,0,8
+R,3,8,4,5,2,5,10,9,4,7,4,8,3,7,6,11
+C,5,8,5,6,3,4,8,6,7,12,10,11,1,9,2,7
+I,2,9,2,7,3,7,7,0,7,7,6,8,0,8,3,8
+S,3,2,3,3,2,8,7,6,5,7,6,8,2,9,9,8
+R,4,5,5,4,4,7,8,5,6,7,5,6,6,7,4,8
+X,6,10,9,8,4,8,8,1,9,10,4,7,3,9,4,8
+F,3,5,5,4,2,7,9,2,6,13,6,6,3,8,3,7
+U,7,10,8,8,4,3,9,6,7,12,11,9,3,9,2,7
+K,2,3,3,2,2,5,7,4,7,7,6,11,3,8,4,9
+R,4,11,6,8,8,7,7,3,4,7,6,8,6,8,7,5
+E,3,9,4,7,4,6,7,7,8,7,6,11,3,8,6,8
+Y,9,10,9,8,5,3,10,3,6,12,12,7,2,11,2,5
+D,3,5,5,4,3,9,7,5,7,9,5,5,3,7,4,8
+G,4,10,5,8,5,5,6,6,4,8,7,12,4,8,6,7
+R,5,11,7,8,6,7,8,5,7,6,5,8,4,6,7,9
+P,4,6,6,8,8,10,8,3,3,6,8,7,6,10,6,4
+D,3,6,5,4,6,9,8,4,4,7,6,6,4,8,8,5
+T,3,5,4,4,2,6,11,2,7,11,9,5,1,11,3,4
+I,7,14,5,8,3,10,5,6,5,13,3,7,3,8,5,10
+Z,5,7,6,5,5,9,6,5,4,7,5,7,3,8,10,6
+H,5,10,8,8,7,7,8,2,6,10,7,8,3,8,3,7
+T,2,1,2,2,0,7,14,1,5,7,11,8,0,8,0,8
+H,6,9,9,6,7,10,6,3,6,10,3,7,5,6,4,9
+I,5,10,6,8,3,9,6,2,7,7,6,5,0,8,4,7
+J,3,6,5,7,4,8,8,4,5,7,7,7,3,9,9,11
+D,6,12,6,6,4,10,3,4,4,11,2,8,4,6,4,10
+I,1,1,1,2,1,8,7,1,7,7,6,7,0,8,2,7
+P,5,9,7,6,5,9,8,2,5,13,5,5,2,9,3,9
+A,5,7,7,6,6,5,8,3,5,7,8,11,7,9,3,8
+A,6,9,9,8,8,7,8,2,4,7,7,8,6,5,5,6
+V,4,7,5,5,2,6,11,3,2,8,11,8,2,9,3,8
+D,5,11,7,8,6,6,7,8,7,6,6,5,3,9,4,9
+Q,2,2,3,3,2,8,8,5,1,5,7,9,2,9,5,10
+B,2,6,3,4,2,6,7,9,6,7,6,7,2,8,8,10
+J,8,10,5,14,4,7,8,3,4,11,6,5,3,8,8,9
+E,2,2,3,4,3,7,7,6,7,7,6,9,2,8,6,10
+V,1,0,2,0,0,7,9,3,2,7,12,8,2,10,0,8
+T,2,10,4,7,1,10,14,1,6,4,11,9,0,8,0,8
+F,5,7,7,5,3,5,12,2,6,13,7,4,1,10,2,7
+R,4,9,5,6,3,5,12,8,3,7,3,9,3,7,6,11
+R,1,0,2,1,1,6,9,7,2,7,5,8,2,7,4,10
+L,8,13,7,7,3,6,4,3,7,10,4,13,3,5,6,8
+O,5,8,7,6,4,8,5,8,5,6,4,5,4,8,4,8
+I,3,10,4,7,3,9,5,0,7,13,5,9,0,7,2,9
+Y,5,7,5,5,2,3,11,3,6,12,11,5,0,10,2,5
+Z,2,1,2,2,1,7,7,3,12,8,6,8,0,8,7,8
+F,2,4,3,3,1,6,10,3,5,13,7,5,1,9,2,7
+D,3,9,4,6,7,9,8,5,4,7,6,6,4,7,7,5
+Q,5,8,6,9,7,8,5,8,4,6,5,9,3,7,6,10
+G,3,7,4,5,3,6,6,6,5,10,7,13,2,9,4,10
+L,2,7,3,5,1,0,1,4,5,1,1,7,0,8,0,8
+T,2,3,3,2,1,9,12,3,6,6,11,9,2,11,1,8
+R,2,1,3,2,2,7,7,5,5,6,5,6,5,7,3,8
+I,1,8,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+I,1,6,1,4,2,7,7,0,7,7,6,8,0,8,3,8
+R,3,5,5,4,5,8,8,4,4,8,4,7,6,7,5,4
+H,4,8,6,6,6,7,7,6,6,7,6,9,3,8,3,8
+O,2,3,3,2,1,8,7,7,4,7,6,8,2,8,2,8
+X,10,15,11,8,6,7,8,2,8,11,8,8,5,12,4,7
+W,4,6,6,4,3,8,8,4,1,7,9,8,7,10,0,8
+S,6,9,8,7,5,7,7,3,7,10,8,9,2,10,5,6
+F,2,6,3,4,2,1,11,3,4,11,10,8,0,8,2,7
+E,5,11,7,8,7,10,6,2,7,11,4,8,4,8,6,12
+P,6,5,6,7,3,4,13,9,2,10,6,4,1,10,4,8
+K,3,3,5,2,2,7,7,2,7,10,5,10,3,8,3,8
+A,6,9,6,5,3,12,3,5,2,12,3,10,5,3,3,10
+Q,3,3,4,4,3,8,8,6,2,5,7,10,3,9,6,10
+S,4,4,5,7,3,7,5,6,10,5,6,10,0,9,9,8
+F,5,9,4,5,3,8,10,3,4,11,5,4,3,10,7,7
+G,6,11,8,9,9,7,9,6,3,6,6,9,6,7,8,7
+U,3,5,4,3,2,5,8,5,7,10,9,9,3,9,2,6
+R,9,15,9,8,7,7,8,3,5,8,4,9,7,7,7,6
+X,3,8,5,6,5,9,7,2,5,7,5,6,3,9,6,8
+X,6,9,9,7,5,6,8,1,8,10,9,9,3,9,3,6
+H,5,10,8,8,7,7,7,3,6,10,7,9,3,8,3,8
+L,3,6,4,4,3,6,7,9,5,6,6,9,3,8,5,11
+D,6,9,5,5,4,7,7,4,6,10,5,7,5,9,6,6
+H,6,8,9,6,5,7,7,3,7,10,6,8,3,8,3,8
+V,5,9,6,7,4,8,11,3,2,5,10,9,2,10,3,9
+E,6,11,9,9,6,10,6,2,9,11,4,9,3,8,5,11
+F,5,9,7,7,4,6,10,2,5,13,7,5,1,10,2,7
+O,5,8,7,6,5,7,8,8,5,6,7,11,4,8,4,8
+V,3,9,5,7,3,7,9,4,2,7,13,8,2,10,0,8
+K,2,5,3,3,2,7,7,4,6,6,6,9,3,8,5,10
+P,2,2,3,3,2,6,11,5,4,10,7,2,1,10,4,6
+V,1,1,2,1,0,7,9,4,2,7,13,8,2,10,0,8
+V,4,11,6,8,5,8,11,2,3,4,10,9,4,12,2,8
+J,2,8,3,6,2,9,6,3,6,12,4,9,1,6,2,6
+I,1,4,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+K,5,9,6,7,4,4,7,7,3,7,7,12,3,8,3,11
+R,4,10,6,8,6,8,8,4,6,8,3,8,4,5,5,12
+P,4,7,6,5,4,9,8,2,6,13,5,6,1,10,3,9
+Y,2,3,4,2,1,8,11,1,6,6,11,9,1,11,1,8
+E,4,10,6,8,6,7,7,5,8,7,7,9,3,8,6,9
+K,4,7,5,5,5,5,7,5,3,7,5,9,3,5,9,8
+S,4,6,6,6,6,8,8,5,5,7,7,8,4,10,8,9
+H,4,8,6,6,4,10,5,3,6,10,2,7,3,8,3,10
+K,3,4,6,3,3,6,7,1,7,10,7,10,3,8,3,7
+Y,2,5,4,7,6,9,8,4,1,6,7,9,3,11,7,7
+S,3,5,4,4,2,8,7,3,7,10,7,7,1,9,5,8
+B,3,6,4,4,5,7,7,6,5,7,6,6,2,8,6,10
+T,4,5,5,3,2,6,11,2,8,11,9,5,3,9,3,4
+O,2,1,3,2,2,7,7,7,5,7,6,8,2,8,3,8
+A,2,2,4,3,2,8,2,2,2,8,1,8,2,6,2,7
+F,2,1,3,2,1,5,11,3,5,11,9,5,1,9,3,6
+H,6,9,9,7,7,8,6,2,6,10,5,8,4,7,4,8
+W,9,10,9,7,6,3,11,2,3,9,9,8,8,11,2,6
+L,5,11,5,8,2,0,0,6,6,0,1,5,0,8,0,8
+T,2,5,4,7,1,8,14,0,6,6,11,8,0,8,0,8
+H,4,4,5,6,2,7,6,15,1,7,7,8,3,8,0,8
+Y,1,1,2,1,0,8,9,2,2,7,12,8,1,10,0,8
+S,2,3,3,4,2,8,7,5,8,4,6,8,0,8,8,8
+S,4,7,5,5,3,7,7,4,8,11,5,7,2,8,5,8
+Q,4,5,5,6,4,8,7,5,2,8,8,10,2,9,5,7
+V,2,1,4,1,1,9,12,2,2,5,10,9,2,10,1,8
+W,5,5,7,7,4,9,8,5,2,7,8,8,9,9,0,8
+T,2,6,4,4,2,5,13,0,5,9,10,7,0,8,0,8
+D,2,1,2,1,1,6,7,8,7,6,6,6,2,8,3,8
+A,4,9,7,7,3,12,2,4,2,11,1,9,3,7,3,9
+F,6,9,8,7,3,4,14,3,5,13,7,2,1,10,2,6
+D,5,10,8,8,11,9,9,5,5,7,6,6,5,8,11,6
+J,3,6,5,4,2,7,7,3,5,15,6,9,1,6,1,7
+S,3,1,3,2,2,8,7,6,5,7,7,8,2,9,9,8
+L,5,5,5,7,1,0,0,7,6,0,1,4,0,8,0,8
+E,3,3,4,5,2,3,7,6,10,7,6,14,0,8,7,7
+M,4,8,5,6,3,7,7,12,1,7,9,8,8,6,0,8
+L,1,3,2,2,1,7,4,2,7,7,2,9,0,7,2,8
+A,3,7,5,5,3,8,2,2,2,7,2,7,2,6,3,7
+R,5,10,6,8,7,6,7,5,6,6,4,8,3,6,5,8
+S,4,9,5,6,5,8,7,5,8,5,5,8,0,8,8,7
+E,1,3,3,2,1,7,7,2,6,11,7,9,2,9,4,9
+O,5,8,6,6,4,7,9,8,5,6,7,9,3,8,3,7
+R,3,7,5,5,3,10,7,3,6,10,3,7,3,7,3,10
+O,1,0,1,1,0,7,7,7,5,7,6,8,2,8,3,8
+F,4,6,6,4,2,8,10,2,6,13,5,3,2,10,2,8
+A,4,9,6,7,5,7,5,2,4,5,1,6,3,6,4,5
+R,3,10,4,7,5,6,9,8,4,7,6,8,2,7,5,11
+T,5,8,6,6,3,4,13,4,6,12,10,4,2,11,2,4
+W,5,6,7,4,4,5,11,3,2,9,8,7,9,13,2,5
+N,5,10,7,7,5,7,8,6,6,6,6,6,6,8,1,6
+S,5,5,6,7,3,8,8,6,9,5,6,7,0,8,9,7
+A,6,11,5,6,3,8,4,3,3,7,4,11,5,6,4,7
+Y,2,6,4,4,2,8,9,1,6,5,11,8,1,11,1,8
+V,5,10,8,7,5,7,12,2,3,5,10,9,4,12,2,7
+B,1,0,2,1,1,7,8,7,5,7,6,7,1,8,6,8
+N,5,10,8,8,5,5,9,5,5,8,8,9,7,9,2,5
+R,6,10,8,7,6,8,9,4,6,8,4,8,3,6,6,11
+Y,3,5,5,7,7,9,6,4,1,6,7,8,6,10,8,9
+W,1,0,2,1,1,8,8,4,0,7,8,8,6,10,0,8
+B,3,8,3,6,4,7,6,8,5,7,6,7,2,9,7,9
+C,2,1,3,3,1,6,8,7,7,8,8,13,1,10,4,10
+Y,5,9,8,7,4,5,9,1,7,9,12,9,1,11,2,7
+I,6,15,4,8,3,12,4,3,6,11,2,7,3,8,3,12
+D,5,10,6,7,6,8,9,5,5,11,6,5,5,8,5,9
+A,3,4,5,3,2,10,1,3,2,9,2,9,3,6,2,8
+A,3,7,5,5,3,12,3,2,2,9,2,9,2,5,2,8
+X,2,7,3,4,1,7,7,4,4,7,6,8,3,8,4,8
+R,3,6,4,4,3,6,8,8,4,6,5,7,2,7,5,11
+G,1,0,2,0,0,8,7,5,5,6,5,9,1,8,5,10
+Z,4,10,5,7,4,7,8,3,12,9,6,8,0,8,8,7
+X,2,2,4,3,2,8,7,3,9,6,6,9,3,8,6,8
+J,6,7,8,9,7,8,10,4,5,7,7,8,5,6,9,7
+A,5,9,5,5,3,12,2,5,1,12,3,10,3,3,2,10
+Q,2,2,3,3,2,8,7,7,3,6,5,9,2,9,3,9
+F,6,9,8,7,5,8,9,1,7,14,5,5,2,9,3,9
+A,4,7,6,6,5,8,8,2,4,7,7,8,5,7,4,5
+M,5,10,6,8,4,7,7,12,2,8,9,8,8,6,0,8
+Y,6,9,6,6,3,3,10,3,7,11,11,6,1,11,3,5
+M,5,2,6,4,4,8,6,7,5,7,7,8,8,6,2,7
+O,5,9,5,6,5,8,8,7,4,9,6,6,4,8,4,8
+V,2,4,3,3,1,3,12,4,3,11,11,7,2,11,1,7
+T,2,1,3,3,1,6,12,3,6,8,11,7,1,11,1,7
+B,3,5,4,7,3,6,8,9,7,7,5,7,2,8,9,10
+P,4,7,5,5,3,8,9,3,5,13,4,3,1,10,3,9
+H,4,5,6,4,4,7,7,3,6,10,6,8,3,8,3,7
+N,1,0,2,0,0,7,7,11,0,5,6,8,4,8,0,8
+B,8,15,7,8,6,10,6,3,5,10,4,7,7,6,8,9
+B,4,9,4,4,3,10,6,3,4,9,4,8,6,7,7,10
+T,2,4,2,3,1,7,11,2,6,7,11,8,1,11,1,7
+P,2,1,2,1,1,5,11,8,2,9,6,4,1,9,3,8
+R,3,4,4,2,2,7,8,5,5,7,5,7,2,6,4,8
+K,2,3,4,1,2,6,8,2,6,10,7,10,3,8,2,8
+E,3,5,5,4,3,6,7,2,8,11,7,9,2,8,4,8
+J,1,1,2,2,1,10,6,3,5,12,5,9,1,7,1,7
+M,7,6,10,6,10,7,8,4,4,7,5,7,11,8,5,5
+M,5,10,7,8,8,6,6,6,5,7,7,11,11,5,2,9
+S,3,7,4,5,3,8,7,7,7,8,6,7,2,8,9,8
+Y,7,8,6,6,3,3,10,3,7,11,12,6,2,11,3,5
+P,6,10,5,5,3,6,9,6,3,10,5,6,4,9,4,7
+J,5,9,6,7,3,9,5,4,6,15,4,10,0,7,1,7
+T,3,6,4,4,2,6,12,2,7,11,9,4,1,11,2,5
+D,1,0,1,1,1,6,7,8,5,6,6,6,2,8,3,8
+J,3,7,5,5,2,8,5,4,6,14,7,12,1,6,0,7
+V,3,7,5,5,1,7,8,4,3,7,13,8,3,9,0,8
+J,3,11,4,8,4,10,7,0,7,11,3,6,0,7,1,7
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+Z,3,7,5,5,2,9,6,3,9,11,3,9,1,7,6,9
+M,3,3,6,2,3,8,5,3,4,10,7,9,7,5,2,8
+Y,7,8,6,12,4,5,8,4,1,8,10,5,4,10,6,5
+A,3,8,5,6,3,8,3,2,2,7,1,8,2,6,3,7
+R,4,9,5,6,5,9,7,4,5,9,4,8,3,7,4,11
+W,6,5,9,8,4,11,8,5,2,6,9,8,9,9,0,8
+G,10,15,9,8,5,7,6,6,6,10,6,7,5,8,6,6
+I,1,4,0,2,0,7,7,1,7,7,6,8,0,8,2,8
+T,2,2,3,3,2,7,12,3,6,7,11,8,2,11,1,7
+B,7,14,5,8,4,7,6,4,5,10,6,9,5,7,7,9
+J,0,0,1,0,0,12,4,6,3,12,5,11,0,7,0,8
+U,3,6,4,4,2,7,4,14,5,7,13,8,3,9,0,8
+P,7,10,6,5,4,7,10,4,4,12,5,3,4,10,5,6
+H,3,3,5,2,3,7,8,2,6,10,7,7,4,10,3,7
+I,1,2,1,3,1,7,7,1,7,7,6,9,0,8,3,8
+S,2,6,3,4,2,7,6,5,8,4,6,8,0,9,8,8
+Y,5,6,5,4,2,3,11,3,7,12,12,6,2,11,2,5
+B,2,7,3,5,3,6,7,7,5,6,6,7,2,8,7,9
+M,5,8,8,6,6,8,6,6,5,6,7,8,8,6,2,7
+E,3,6,3,4,2,3,8,6,10,7,6,14,0,8,7,8
+G,3,7,4,5,2,7,7,8,7,5,6,10,2,7,5,10
+B,4,9,5,7,6,7,7,9,5,7,5,6,2,8,8,10
+V,5,10,5,5,3,10,9,4,5,8,8,5,3,10,2,8
+Y,5,6,5,4,2,3,12,4,5,12,11,5,1,11,1,5
+U,4,9,5,6,2,7,4,15,6,7,13,8,3,9,0,8
+D,4,4,4,6,2,5,7,10,8,6,6,5,3,8,4,8
+V,2,1,3,2,1,7,12,2,2,7,11,8,2,10,1,8
+A,2,4,4,6,2,7,5,3,1,7,1,8,2,7,2,8
+L,4,9,6,7,4,9,4,1,7,9,2,10,3,6,4,9
+O,3,7,4,5,3,6,7,7,4,7,6,10,4,8,3,8
+Z,6,10,8,8,6,8,7,2,9,12,5,8,1,7,6,8
+C,5,9,6,6,3,3,8,5,7,11,10,14,1,8,3,7
+E,3,7,3,5,2,3,6,6,10,7,7,14,0,8,7,8
+G,6,10,7,8,5,6,6,6,6,11,6,12,4,9,5,8
+J,4,6,6,7,5,7,8,4,6,6,8,7,3,9,9,10
+O,1,1,2,1,1,8,7,7,5,7,6,8,2,8,3,8
+J,5,9,6,7,3,9,7,2,6,15,4,8,0,7,1,7
+X,4,7,6,5,5,6,7,2,6,7,6,9,4,5,7,9
+U,4,7,6,5,8,8,8,4,4,6,7,8,7,8,5,8
+J,2,4,3,3,1,9,7,2,6,14,4,8,0,7,0,8
+V,4,11,6,8,2,7,8,4,3,7,14,8,3,9,0,8
+O,5,10,6,8,5,8,8,8,4,7,7,6,5,7,4,9
+R,4,8,6,6,4,8,8,4,6,9,3,8,3,6,4,11
+R,4,6,6,4,3,9,7,5,6,9,4,7,3,7,4,11
+O,5,11,6,8,5,8,7,9,6,6,7,9,3,8,3,8
+D,5,11,7,8,6,7,8,8,7,7,7,4,4,7,5,9
+R,3,6,4,4,3,6,7,5,5,6,5,7,3,7,5,9
+F,5,8,7,6,5,7,9,3,5,13,7,6,2,10,2,7
+K,6,7,8,5,4,6,7,2,7,10,6,10,4,7,4,8
+U,4,6,5,5,5,7,6,5,4,6,7,8,4,8,1,7
+E,2,4,3,3,2,8,7,6,8,7,7,8,2,8,6,8
+G,4,6,5,4,3,7,6,6,6,10,6,11,2,10,4,10
+F,4,6,5,4,3,6,11,3,5,13,6,4,2,10,2,7
+P,4,8,4,6,2,4,12,8,2,10,6,3,1,10,4,8
+K,4,7,6,5,4,6,7,5,7,6,5,10,3,8,5,9
+P,3,5,5,3,2,8,9,4,4,12,4,3,1,10,3,8
+Y,4,9,5,6,5,9,4,7,5,8,8,7,5,8,5,5
+P,5,8,7,6,5,8,10,5,4,11,4,3,1,10,3,8
+K,3,6,5,5,4,8,7,2,4,9,3,8,4,6,4,10
+D,3,4,4,3,3,7,7,7,7,6,6,5,2,8,3,7
+M,6,10,7,8,4,8,7,13,2,6,9,8,9,6,0,8
+A,3,4,6,6,2,7,6,3,0,7,0,8,2,7,1,8
+Q,4,9,5,8,5,8,8,7,4,6,8,9,2,8,4,9
+G,5,9,6,7,5,5,6,6,7,6,5,11,2,10,4,8
+B,4,8,5,6,6,8,8,6,6,7,6,6,5,8,5,10
+R,2,3,4,2,2,8,7,4,4,9,4,6,2,7,3,9
+J,3,6,4,4,2,8,7,3,5,14,6,10,1,6,1,7
+U,7,13,7,7,3,6,5,5,6,3,9,8,5,9,2,7
+T,5,5,5,4,3,6,11,2,8,11,9,4,3,10,4,4
+W,3,1,5,2,2,7,11,3,2,7,9,8,6,11,0,8
+Y,1,0,2,0,0,7,9,3,1,7,12,8,1,11,0,8
+A,3,7,4,5,2,9,3,3,3,9,1,8,2,6,2,7
+F,4,10,5,8,6,5,9,4,6,9,10,7,2,9,3,6
+C,6,9,7,7,8,5,6,4,5,7,6,11,6,9,4,8
+O,2,0,2,1,0,7,7,6,5,7,6,8,2,8,3,8
+F,3,5,5,3,2,6,11,2,6,14,7,4,1,9,2,7
+T,7,13,6,7,4,9,7,2,7,10,5,8,3,8,5,8
+P,4,9,4,6,2,4,11,9,3,9,6,4,1,10,4,8
+C,3,7,4,5,2,4,9,6,7,12,10,11,1,10,2,7
+X,7,10,10,8,6,7,8,0,8,9,6,8,3,8,3,7
+T,7,10,6,5,3,5,11,2,7,12,7,5,2,8,4,4
+M,4,4,6,3,3,6,6,3,4,10,9,10,8,4,3,8
+K,5,10,8,8,6,4,9,1,6,10,9,10,3,8,3,6
+G,3,6,4,4,2,6,8,5,5,9,7,10,2,8,4,9
+Z,1,4,2,2,1,7,8,5,8,6,6,9,1,8,7,7
+V,6,7,6,5,2,3,12,5,4,12,12,7,3,10,1,8
+M,3,4,4,2,3,8,6,6,4,7,7,9,9,5,1,8
+O,3,6,3,4,3,7,8,7,4,9,7,10,3,8,2,9
+O,6,8,8,6,9,7,9,5,2,7,6,7,10,10,6,9
+H,4,5,6,4,4,7,8,3,6,10,7,7,5,9,4,8
+M,7,10,12,8,15,10,6,3,3,9,4,7,12,6,5,5
+B,5,10,6,8,7,9,8,3,5,7,6,7,7,7,6,9
+V,5,6,5,4,2,4,11,2,3,9,11,7,2,10,1,7
+R,2,1,2,2,2,6,8,4,5,6,5,7,2,7,4,8
+E,2,4,4,3,2,6,8,3,9,11,8,9,2,8,4,6
+G,5,11,6,8,6,8,8,8,6,5,7,9,3,5,7,11
+W,6,10,8,8,9,8,7,6,3,7,8,8,10,6,6,11
+C,2,5,3,4,2,6,8,7,7,9,8,13,1,9,4,10
+Q,2,1,2,1,1,8,7,7,4,6,6,8,2,8,3,8
+A,4,9,7,6,3,12,2,4,3,11,1,9,3,7,3,9
+V,5,8,5,6,2,3,11,3,4,10,12,7,2,10,1,8
+Z,2,4,5,3,2,7,8,2,9,11,7,7,1,8,5,6
+F,4,9,6,7,4,4,11,3,7,11,10,5,1,10,3,5
+L,6,9,8,7,6,6,6,8,6,6,6,9,6,7,5,11
+X,4,10,7,8,4,9,7,0,8,9,5,7,2,8,3,8
+V,2,3,4,4,1,9,8,4,2,6,13,8,3,10,0,8
+M,5,11,8,8,12,9,5,2,1,8,4,8,11,7,3,6
+J,2,3,2,5,1,13,3,8,4,13,4,12,1,6,0,8
+B,3,7,5,5,5,7,8,6,4,7,5,6,2,8,5,7
+O,2,4,3,3,2,7,8,6,4,9,6,8,2,8,2,7
+Y,6,9,6,6,4,5,9,1,7,8,9,5,2,11,3,4
+U,4,8,6,6,7,7,6,4,3,7,7,8,10,8,5,7
+U,6,9,6,7,4,3,8,5,7,11,10,9,3,9,2,6
+Y,3,5,5,7,6,8,8,3,2,7,8,9,3,11,7,6
+K,4,9,6,6,7,5,6,4,5,7,5,9,7,7,8,10
+A,4,5,6,7,2,7,4,3,1,7,1,8,3,7,2,8
+E,2,3,4,2,2,7,7,2,7,11,6,9,2,8,4,8
+K,5,9,7,7,4,3,8,3,7,11,10,12,3,8,4,6
+D,3,6,4,4,3,7,9,6,5,10,6,4,3,8,3,6
+M,3,5,6,3,4,5,6,3,4,10,9,10,7,6,2,8
+C,2,4,3,3,1,6,8,7,8,7,8,13,1,8,4,10
+U,4,9,5,7,2,7,5,14,5,7,14,7,3,9,0,8
+X,6,8,8,6,6,7,6,3,5,7,6,11,4,6,10,8
+F,3,9,3,6,2,1,14,4,3,12,10,5,0,8,1,6
+V,4,4,5,3,2,4,12,3,3,10,11,7,2,10,0,8
+Y,5,6,5,4,2,5,9,2,8,10,10,5,2,10,4,3
+K,6,10,9,8,5,3,7,3,7,10,11,12,4,7,4,7
+M,5,5,6,8,4,8,7,12,2,6,9,8,8,6,0,8
+V,4,9,6,7,8,7,5,5,2,8,7,8,8,8,5,8
+V,4,11,6,8,4,8,9,4,1,6,12,8,4,9,2,7
+W,3,3,4,1,2,4,10,3,2,9,9,7,5,10,1,6
+N,4,10,4,7,5,7,7,12,1,6,6,8,5,8,0,8
+V,6,11,9,8,11,8,5,5,3,8,7,8,6,9,5,9
+L,4,6,6,4,4,6,6,7,6,6,6,9,2,8,5,10
+G,2,1,2,2,1,7,7,6,5,6,6,10,2,9,4,9
+U,5,11,7,8,5,6,9,5,7,6,9,9,3,9,1,8
+X,4,9,5,6,1,7,7,5,4,7,6,8,3,8,4,8
+U,4,9,4,7,2,7,4,15,6,7,13,8,3,9,0,8
+X,8,12,9,6,5,6,9,2,8,11,8,8,4,9,4,5
+E,5,10,8,8,9,7,8,3,6,6,7,11,4,11,8,7
+J,3,6,5,4,2,10,5,3,6,14,3,9,0,7,0,8
+A,2,2,4,3,1,6,2,2,2,5,2,8,2,6,2,6
+M,4,2,5,4,4,8,6,6,4,6,7,8,8,6,2,7
+R,5,11,7,8,5,11,7,3,7,11,1,6,6,7,4,10
+G,2,3,3,2,1,7,6,5,5,7,6,9,2,9,4,9
+A,2,5,4,4,2,11,3,3,2,10,2,9,2,6,2,8
+H,5,7,7,5,5,8,7,3,6,10,6,9,3,8,3,8
+H,4,8,6,10,7,8,4,4,2,7,4,6,5,7,8,8
+L,3,8,5,6,4,4,4,4,7,2,1,6,1,6,1,6
+B,5,9,7,7,7,8,7,5,5,9,6,6,3,9,6,9
+K,7,9,10,7,6,5,8,2,7,10,8,10,3,8,4,7
+Z,7,12,7,6,4,10,3,4,7,12,4,10,3,8,6,10
+B,6,11,8,8,11,8,6,5,4,7,7,7,9,11,11,10
+S,5,6,6,5,6,9,8,4,5,7,6,8,5,10,8,11
+Q,2,2,3,2,2,8,7,6,3,6,6,10,2,9,3,10
+F,4,7,6,5,3,5,11,4,5,13,7,4,2,10,2,7
+X,4,8,6,6,4,7,8,3,9,5,6,7,4,9,7,7
+I,2,7,3,5,2,7,7,0,6,13,6,8,0,8,1,8
+B,4,8,6,6,8,8,7,5,3,7,7,7,6,10,8,9
+H,7,11,9,8,10,8,8,6,7,7,6,6,6,8,4,7
+E,2,5,3,4,3,7,7,5,7,7,6,9,2,8,5,10
+F,3,7,4,5,3,6,10,3,5,10,9,6,2,10,3,6
+T,5,7,5,5,3,6,11,3,7,11,9,4,2,12,2,4
+O,3,8,4,6,3,7,8,7,5,9,8,8,3,8,3,8
+T,3,8,4,6,2,9,13,0,6,6,10,8,0,8,0,8
+M,6,9,9,7,7,8,7,2,4,9,7,8,8,7,2,8
+N,2,3,4,2,1,7,8,3,4,10,6,6,5,8,0,7
+E,2,3,4,2,2,7,7,2,7,11,7,9,2,8,4,8
+F,2,1,2,2,1,5,10,3,5,10,9,5,1,10,2,7
+B,3,7,3,5,3,6,8,9,7,7,5,7,2,8,8,9
+E,3,6,3,4,3,3,8,5,9,7,6,14,0,8,6,9
+R,5,7,7,5,4,9,8,4,6,9,4,7,3,7,5,11
+O,3,6,4,4,2,7,8,8,7,6,7,8,3,8,4,8
+Y,4,5,5,4,2,4,11,3,6,12,11,5,1,11,2,5
+A,4,9,6,7,4,8,2,1,2,6,2,8,2,7,3,6
+N,2,4,4,2,2,8,8,2,4,10,4,6,5,10,1,7
+U,3,3,3,1,1,5,8,5,7,10,9,8,3,10,2,6
+N,7,10,10,8,6,9,9,2,5,10,4,5,7,9,2,8
+H,6,7,9,5,4,9,6,3,6,10,3,7,6,8,5,9
+W,2,4,4,3,2,7,11,2,2,7,9,8,6,11,0,8
+J,2,6,3,4,3,9,9,4,3,8,4,6,4,8,5,4
+M,4,4,6,3,3,7,6,3,4,10,8,9,9,5,3,9
+I,1,4,2,2,0,7,8,0,7,13,6,8,0,8,0,8
+T,2,3,3,2,1,6,11,2,7,11,9,5,1,10,2,5
+Y,2,7,4,5,2,7,10,1,6,6,11,8,1,11,1,8
+Q,4,6,5,8,5,7,9,5,2,6,9,11,3,9,6,7
+O,2,1,3,2,2,7,7,7,5,7,6,8,2,8,3,8
+M,7,8,10,7,11,8,8,5,4,7,6,7,11,10,6,3
+J,5,11,4,8,4,6,11,2,3,12,6,5,2,9,8,8
+H,4,10,6,7,6,6,7,5,5,7,5,8,6,6,6,11
+A,2,3,4,2,1,10,2,3,2,10,2,10,2,6,2,8
+C,5,9,6,6,4,6,7,6,9,5,6,12,1,7,4,9
+E,1,0,2,1,1,5,7,5,7,7,6,12,0,8,7,9
+O,3,5,4,3,2,8,6,6,4,9,5,8,2,8,3,8
+X,4,7,7,5,3,7,8,1,8,10,8,8,3,8,3,7
+J,1,3,2,1,1,11,6,2,5,11,4,8,0,7,1,8
+V,7,9,10,8,11,7,6,5,5,7,6,8,7,10,8,8
+G,4,9,5,7,4,5,7,5,4,9,8,9,2,8,5,9
+P,2,7,3,5,2,4,12,8,2,10,6,4,1,10,3,8
+T,8,13,7,7,3,6,9,3,8,13,6,6,2,8,5,4
+U,2,1,3,2,2,7,9,5,6,7,9,9,3,9,1,8
+T,3,11,5,8,2,7,14,0,6,7,11,8,0,8,0,8
+T,7,10,6,5,2,5,10,3,8,13,7,5,2,8,4,4
+X,6,10,9,8,7,8,8,3,6,7,7,8,7,13,9,9
+K,4,10,6,7,6,5,7,5,7,6,6,12,3,8,6,9
+G,2,3,3,2,2,6,7,5,5,9,7,10,2,9,4,9
+V,3,7,5,5,1,7,8,4,2,7,14,8,3,10,0,8
+E,5,9,7,7,8,7,6,3,6,7,7,11,4,9,8,7
+G,2,5,3,4,2,6,7,5,5,9,7,10,2,9,4,9
+H,4,4,5,5,2,7,7,15,0,7,6,8,3,8,0,8
+N,5,6,7,4,4,11,7,3,5,10,1,4,5,9,1,7
+N,4,7,6,5,5,6,7,3,3,8,8,8,6,9,5,4
+O,5,10,6,7,4,7,7,8,5,10,6,9,3,9,4,6
+K,2,4,4,3,2,5,8,2,7,10,8,10,3,8,3,6
+Z,6,9,8,7,5,7,7,2,9,12,6,8,1,8,6,7
+L,1,3,2,1,1,6,4,1,8,8,3,10,0,7,2,8
+G,2,3,3,2,2,6,6,5,6,7,5,10,2,9,4,9
+C,6,12,5,6,4,7,9,4,5,8,7,9,4,8,8,10
+R,4,5,5,3,3,7,7,5,6,7,5,6,5,7,4,8
+Q,4,6,5,8,5,8,9,5,2,6,8,11,3,9,6,8
+P,8,12,7,6,4,9,8,4,6,13,4,4,3,10,6,7
+G,3,9,4,6,2,7,7,8,7,5,6,11,2,7,5,10
+B,4,9,4,6,3,6,7,9,7,7,6,7,2,8,9,10
+I,4,11,6,8,4,7,9,0,8,13,6,6,1,9,2,7
+A,4,7,6,5,3,9,3,2,2,8,1,8,2,6,3,7
+F,1,3,2,2,1,5,11,4,4,11,8,4,1,9,3,6
+A,3,5,6,4,2,7,1,2,2,6,2,7,4,6,4,7
+G,2,1,2,1,1,8,6,6,6,6,5,9,1,7,5,10
+B,3,3,4,4,3,6,8,8,7,7,5,7,2,8,8,9
+A,2,3,3,1,1,7,2,2,1,6,2,7,1,6,1,7
+B,3,5,3,4,3,7,7,5,5,6,6,6,2,8,6,10
+Q,4,8,6,7,3,8,6,8,7,6,5,8,3,8,4,8
+R,6,8,9,7,9,7,8,3,4,7,5,8,7,7,6,7
+X,9,13,8,8,4,6,7,3,9,9,9,9,4,8,4,6
+C,4,9,6,7,6,5,7,4,4,7,6,9,6,9,5,7
+W,7,8,7,6,5,4,11,3,3,9,9,7,7,11,2,6
+W,6,9,8,7,4,5,7,5,2,7,8,8,9,9,0,8
+Y,4,6,4,4,2,3,10,3,6,11,11,6,2,11,2,5
+G,3,2,5,3,3,7,6,6,6,6,6,10,2,9,4,9
+O,2,5,3,3,2,7,7,7,4,9,6,8,2,8,3,8
+I,1,4,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+E,2,3,2,1,2,7,7,5,6,7,6,8,2,8,5,10
+F,4,8,7,6,7,8,8,1,4,9,7,7,6,11,4,6
+Y,3,10,5,7,1,7,12,1,4,7,12,8,0,10,0,8
+Q,5,8,5,9,6,7,10,4,3,6,9,11,3,9,6,8
+O,5,9,7,8,6,6,6,5,5,7,4,7,4,8,6,7
+K,4,5,7,4,4,8,7,1,7,10,5,8,3,8,4,8
+Q,2,6,3,5,2,8,8,8,5,6,7,8,3,7,5,9
+L,4,8,5,7,5,8,5,4,4,6,7,7,3,8,8,11
+T,5,9,7,6,8,6,7,3,6,7,6,10,5,9,5,7
+W,4,7,6,5,4,5,11,2,3,8,9,9,7,11,1,8
+D,7,13,7,7,4,9,5,4,6,10,3,7,5,6,5,11
+Z,5,7,6,5,5,9,11,5,4,6,5,7,3,8,8,5
+R,3,4,5,3,3,8,7,3,5,10,4,7,2,7,4,10
+Y,4,8,6,6,3,5,10,2,8,10,12,9,1,11,2,7
+I,8,14,5,8,3,10,4,4,7,11,2,7,3,7,5,11
+Z,5,9,7,7,5,8,6,2,9,12,5,8,1,7,6,8
+N,5,7,7,5,4,10,8,3,5,10,2,4,5,9,1,7
+V,5,7,5,5,3,3,11,2,3,9,11,8,3,12,1,7
+L,4,11,6,8,4,7,4,2,7,8,2,9,2,5,3,7
+Q,5,10,6,8,6,8,4,8,4,7,5,9,4,9,4,7
+Y,3,4,5,3,2,9,11,1,7,5,11,7,1,11,2,8
+L,4,8,6,6,3,5,4,1,10,7,2,11,0,7,3,7
+B,9,15,6,8,4,9,5,6,6,10,3,9,6,6,7,11
+U,3,3,4,4,2,6,9,5,7,7,9,9,3,9,1,8
+R,5,7,7,5,5,9,7,3,5,10,3,7,3,6,4,10
+P,3,6,4,4,2,9,9,3,5,13,4,3,1,10,3,9
+O,4,6,5,4,3,8,7,8,4,7,6,5,3,8,3,7
+T,7,12,6,7,4,6,10,2,6,12,7,6,2,9,4,4
+Z,5,9,6,7,4,8,6,6,11,7,5,6,1,7,8,8
+P,2,4,3,2,1,5,11,4,4,10,8,3,1,9,3,6
+N,6,8,9,6,4,8,8,3,5,10,5,6,6,9,2,7
+T,3,10,4,8,3,9,13,0,5,6,10,8,0,8,0,8
+Z,5,9,5,4,3,5,8,2,8,11,9,9,3,9,5,5
+N,4,8,7,6,3,4,10,4,4,10,11,10,5,7,1,7
+Z,4,7,6,5,5,9,9,5,4,6,5,7,3,9,9,4
+G,3,7,4,5,3,6,7,7,6,8,7,11,2,8,4,9
+O,4,5,6,7,3,9,8,9,8,6,7,10,3,8,4,8
+Q,3,6,4,6,2,7,6,8,5,6,7,7,3,8,5,9
+A,1,1,2,1,1,7,4,2,1,7,1,8,2,6,1,7
+Z,4,9,4,7,2,7,7,4,14,9,6,8,0,8,8,8
+D,3,4,5,3,3,7,7,5,6,10,6,6,3,8,3,9
+A,2,4,4,3,1,8,2,2,2,7,2,8,2,6,2,7
+N,4,7,6,5,4,7,9,5,5,7,6,6,6,10,2,5
+W,4,10,6,8,7,7,7,6,2,7,8,7,10,7,5,9
+A,4,10,6,8,4,13,2,4,3,11,1,9,3,7,4,10
+N,8,11,12,8,6,7,9,2,5,9,6,6,6,9,1,8
+N,5,8,7,6,4,4,9,4,4,10,9,9,5,7,1,7
+H,4,8,5,6,7,8,8,5,3,7,6,6,7,9,8,8
+U,6,7,7,5,3,4,9,6,7,12,11,8,3,9,2,6
+Y,7,7,6,10,4,7,9,2,2,7,10,5,4,10,6,6
+G,7,15,6,8,4,9,3,3,3,7,3,5,4,7,4,9
+Q,1,0,2,1,0,8,7,6,3,6,6,9,2,8,3,8
+G,4,6,6,4,5,7,8,5,4,6,6,8,4,7,7,7
+H,2,3,3,2,2,7,7,5,6,7,6,8,3,8,3,8
+C,4,6,4,4,2,3,9,5,8,11,10,11,1,8,3,7
+E,1,0,1,0,0,5,7,5,7,7,6,11,0,8,6,10
+B,4,11,5,8,4,6,6,10,7,6,6,7,2,8,9,10
+S,4,7,5,5,2,8,7,4,8,11,6,7,2,8,5,8
+Z,5,11,7,9,5,8,6,6,11,7,5,6,2,7,8,8
+Y,2,3,2,2,1,4,11,3,6,11,10,4,1,11,2,5
+G,4,9,6,7,7,9,6,5,2,7,6,10,8,8,4,11
+D,6,10,8,8,6,7,7,7,8,7,7,4,3,8,3,7
+B,5,9,8,8,9,7,8,5,4,7,6,8,7,9,8,6
+G,5,11,6,8,5,5,5,6,7,7,5,12,2,10,4,9
+O,4,10,5,8,3,7,6,9,8,6,4,7,3,8,4,8
+Q,5,7,6,9,6,9,10,6,3,4,8,12,3,10,8,12
+K,2,3,3,1,1,6,7,1,6,10,7,10,3,8,2,8
+Y,4,6,4,4,2,3,11,5,5,12,12,6,2,11,1,6
+F,5,7,6,8,7,7,9,5,5,7,6,8,4,8,8,7
+S,4,6,5,4,2,6,8,4,8,11,5,7,2,6,5,8
+G,4,7,5,5,4,6,6,6,5,9,7,12,3,8,4,9
+L,2,1,3,2,1,4,4,4,8,2,1,6,0,7,1,6
+V,5,10,5,8,3,3,11,4,4,10,12,8,2,10,1,8
+D,4,7,5,5,4,7,8,8,4,8,6,4,3,8,3,7
+H,7,10,9,8,6,10,5,3,6,10,2,7,5,7,5,9
+P,4,8,6,6,4,5,13,6,2,12,6,2,0,10,3,7
+T,6,11,5,6,2,5,10,2,7,13,7,5,2,8,4,4
+P,2,7,3,4,2,4,12,8,2,10,6,4,1,10,3,8
+H,6,7,9,5,5,8,7,3,7,10,4,7,5,6,4,8
+E,6,9,8,7,7,10,6,2,7,11,4,8,4,6,6,11
+J,2,9,3,6,1,11,3,10,3,12,7,13,1,6,0,8
+B,2,1,2,2,1,7,7,8,5,6,6,7,2,8,7,10
+Y,4,11,6,8,1,6,10,2,2,7,13,8,1,11,0,8
+E,4,11,4,8,5,3,9,5,10,7,6,14,0,8,6,8
+E,4,6,5,4,4,10,6,2,6,11,4,9,2,8,4,12
+E,4,9,6,6,5,7,7,2,7,11,7,9,3,8,4,8
+X,1,0,1,0,0,7,7,4,4,7,6,8,2,8,3,8
+U,5,10,6,7,6,8,8,8,5,6,7,10,3,8,4,6
+E,3,4,3,3,3,7,8,6,8,7,5,9,2,8,6,9
+V,5,10,7,8,5,5,12,3,2,9,10,8,5,10,6,8
+G,3,7,4,5,2,8,7,7,7,6,6,10,2,7,5,11
+I,1,5,1,4,1,7,7,1,7,7,6,8,0,8,2,8
+U,6,8,7,6,5,4,8,5,7,9,7,9,4,8,3,4
+D,4,9,6,7,5,7,7,9,4,8,7,4,4,8,4,8
+Y,4,5,6,7,1,7,12,2,3,7,12,8,1,10,0,8
+P,5,8,7,11,10,9,8,4,3,6,8,7,6,10,6,4
+T,3,9,4,7,4,6,11,4,6,8,11,7,2,12,1,7
+S,5,8,7,6,4,6,8,3,7,10,6,7,3,7,5,6
+Y,6,8,6,6,3,4,10,2,8,11,11,5,1,10,3,4
+J,2,7,2,5,1,11,3,9,3,13,7,13,1,6,0,8
+E,3,8,4,6,2,3,6,6,11,7,7,14,0,8,7,7
+T,6,14,6,8,4,9,7,3,7,12,5,6,2,8,6,6
+X,3,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+F,2,3,2,1,1,5,10,4,5,10,9,6,1,9,3,7
+K,4,8,4,6,2,4,7,8,2,7,7,11,3,8,3,11
+D,4,9,4,4,2,9,6,5,5,11,4,7,5,7,5,11
+A,4,9,7,7,4,12,3,2,2,9,2,9,2,6,2,8
+O,5,6,7,5,5,6,6,6,5,7,5,6,3,6,5,6
+H,4,7,6,5,4,11,6,4,6,10,2,6,3,8,3,9
+X,3,7,4,5,3,7,6,3,5,6,6,9,2,9,8,8
+B,4,10,4,8,4,6,6,9,6,6,6,7,2,8,9,11
+X,2,1,3,2,1,8,7,3,8,6,6,8,2,8,5,8
+P,2,4,3,3,1,5,11,4,4,10,8,3,0,10,3,6
+W,8,15,8,8,6,1,7,2,3,9,10,9,9,10,1,5
+U,4,4,5,6,2,7,3,14,6,7,13,8,3,9,0,8
+J,2,6,3,4,3,10,7,3,3,9,4,7,2,8,7,8
+W,3,8,5,6,8,7,5,6,2,7,6,8,8,12,3,10
+P,9,14,7,8,4,7,9,6,4,13,4,4,5,10,4,8
+P,3,1,3,2,2,6,9,5,4,9,7,4,1,9,3,7
+Q,6,8,8,7,6,7,4,4,5,6,4,8,4,5,6,7
+D,5,9,6,6,5,9,7,4,5,10,5,6,3,8,3,8
+J,4,8,6,6,2,8,5,5,5,14,8,13,1,6,1,7
+H,6,9,8,7,8,8,8,5,7,7,6,9,6,8,4,8
+S,3,4,3,3,2,8,8,6,5,7,6,7,2,8,9,8
+N,2,0,2,1,1,7,7,12,1,5,6,8,5,8,0,8
+Z,2,4,3,6,2,7,7,3,13,10,6,8,0,8,8,8
+D,4,6,6,4,5,8,7,5,6,9,4,5,3,8,3,8
+N,1,1,2,1,1,7,7,11,1,5,6,8,4,8,0,8
+J,6,13,5,10,4,7,11,3,3,13,5,4,2,9,8,9
+X,3,9,5,6,4,8,8,3,8,6,6,6,3,9,6,7
+J,2,5,3,7,1,12,3,9,4,13,5,12,1,6,0,8
+D,3,4,5,3,3,9,6,4,6,10,4,6,2,8,3,8
+E,3,4,3,6,2,3,7,6,10,7,6,14,0,8,7,8
+T,2,5,3,3,2,7,12,3,5,7,11,8,2,11,1,8
+S,3,2,3,3,2,8,8,7,5,7,5,7,2,8,9,8
+W,3,3,4,2,2,6,11,3,2,8,8,7,5,11,1,6
+M,2,1,3,2,2,6,6,6,4,7,7,10,6,5,2,9
+W,3,2,5,3,3,8,11,2,2,6,9,8,6,11,1,7
+D,5,8,7,6,6,8,8,6,6,9,5,4,5,8,4,9
+C,4,8,5,6,4,7,7,8,5,8,6,12,4,9,4,8
+E,2,3,4,2,2,6,9,2,8,11,7,8,2,8,4,7
+I,1,3,2,1,0,7,8,1,7,13,6,7,0,8,0,7
+E,4,8,5,6,6,6,7,5,7,7,6,10,3,8,5,9
+R,2,4,4,2,2,8,7,3,5,10,4,7,2,7,3,10
+U,3,4,4,3,2,6,8,6,7,7,9,9,3,9,1,8
+A,3,5,6,6,2,6,5,3,1,6,0,8,2,7,2,7
+A,4,9,6,6,2,6,3,3,3,6,2,7,3,6,3,7
+J,2,1,3,3,1,10,6,2,6,12,4,8,0,7,0,7
+O,5,9,7,7,5,7,5,9,5,8,5,11,4,8,4,8
+D,5,6,6,5,5,6,7,5,7,6,4,7,3,7,5,6
+K,3,5,4,3,3,5,7,4,7,7,6,10,6,8,4,9
+S,3,9,4,7,2,8,7,6,9,4,6,7,0,8,9,8
+Z,4,9,4,7,4,7,8,3,12,9,6,8,0,8,7,7
+U,9,11,10,8,7,4,8,5,9,9,7,9,8,10,6,1
+D,5,8,6,6,4,10,6,3,8,11,4,6,3,8,3,9
+Z,2,5,4,4,2,7,7,2,9,11,6,8,1,8,5,8
+K,5,10,7,7,9,8,8,3,4,6,6,9,10,10,7,7
+X,2,2,4,3,2,8,7,3,9,6,6,8,2,8,6,8
+O,6,11,7,8,7,7,8,8,4,9,8,8,3,8,3,8
+S,3,2,3,3,2,8,7,6,5,7,6,8,2,8,9,8
+F,2,3,2,1,1,5,10,4,4,10,9,5,1,9,3,6
+L,1,3,3,2,1,7,4,1,7,8,2,10,0,7,2,8
+M,4,6,5,4,4,8,6,6,5,7,7,8,7,5,2,8
+V,6,9,8,8,9,8,7,5,5,7,6,8,8,8,10,3
+X,3,7,4,5,2,7,7,4,4,7,6,8,3,8,4,8
+T,2,1,3,2,1,6,12,3,6,8,11,7,2,11,1,7
+H,5,8,7,6,4,7,8,3,6,10,7,8,3,8,3,7
+W,5,10,7,8,7,10,11,2,2,5,8,8,8,13,2,7
+Q,6,10,8,7,7,8,3,8,4,6,6,9,3,8,4,9
+I,2,6,3,4,1,7,7,0,8,14,6,8,0,8,1,8
+G,4,9,5,7,3,8,8,8,8,5,7,9,2,7,6,11
+P,4,7,5,5,3,6,11,8,2,10,5,3,1,10,4,7
+U,3,8,5,6,3,4,9,7,7,8,10,10,3,9,1,8
+P,4,10,5,8,5,7,9,6,6,9,7,3,2,10,4,7
+B,1,3,3,2,2,8,7,3,5,9,6,7,2,8,4,8
+U,3,3,4,1,1,5,8,4,6,10,9,9,3,10,1,6
+I,2,5,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+F,5,9,7,7,4,6,10,2,6,13,7,5,1,10,2,7
+Y,3,4,5,3,2,4,10,2,8,11,10,5,2,11,3,3
+F,3,5,4,4,3,4,11,3,6,11,9,6,1,10,3,6
+M,6,10,8,8,7,11,5,2,5,9,3,6,8,6,2,9
+J,2,1,3,3,1,9,6,2,6,12,4,9,1,7,1,7
+K,6,9,8,6,8,6,9,5,4,8,5,8,4,7,8,10
+Z,4,9,4,6,3,6,8,6,10,7,7,10,1,9,8,8
+U,5,11,5,6,3,6,5,5,4,7,9,10,5,6,2,9
+N,3,6,4,4,2,7,7,14,2,5,6,8,6,8,0,8
+V,4,7,6,6,6,7,8,6,4,7,6,8,6,9,7,7
+B,4,7,5,5,4,6,7,9,6,7,5,7,2,8,9,9
+J,4,6,3,8,2,9,7,3,4,10,5,5,2,9,5,9
+F,5,11,6,8,5,4,10,4,6,11,10,6,2,10,3,5
+A,1,3,2,1,1,7,2,2,1,7,2,8,1,6,1,7
+Z,3,6,5,4,4,6,7,3,7,7,6,9,0,8,8,7
+F,4,8,5,6,5,7,9,6,3,8,6,9,4,11,8,11
+M,6,10,9,8,8,11,6,2,4,9,4,6,9,6,2,8
+B,4,7,5,5,4,8,6,7,7,6,7,5,2,9,8,9
+C,3,7,4,5,2,5,9,6,7,12,9,9,2,10,3,7
+B,7,10,9,8,8,8,7,5,6,10,6,6,3,9,7,10
+V,6,9,6,7,3,1,12,4,4,12,12,8,2,10,1,7
+G,5,7,7,5,6,7,7,5,2,7,6,11,5,8,8,8
+Q,5,6,5,8,5,8,9,5,2,8,9,10,3,9,6,8
+K,4,5,6,3,3,4,8,2,7,10,9,11,3,8,3,7
+K,5,8,7,6,5,3,9,2,6,10,11,11,3,8,3,6
+V,5,11,8,8,2,6,8,5,3,8,14,8,3,9,0,8
+K,6,8,8,6,6,8,6,1,6,10,4,9,5,7,5,11
+Q,6,10,8,7,7,8,5,8,5,7,6,5,5,7,8,8
+O,7,13,5,7,4,6,6,5,5,6,4,8,5,7,5,7
+D,3,3,4,2,2,7,7,6,7,7,6,5,2,8,3,7
+K,3,3,5,2,2,6,8,2,7,10,7,9,3,8,2,7
+L,2,3,2,4,1,0,2,5,6,0,0,7,0,8,0,8
+D,3,6,4,4,4,7,7,6,6,6,6,5,3,8,3,7
+V,3,10,5,8,2,7,8,4,3,7,14,8,3,9,0,8
+B,4,6,6,6,7,7,8,5,5,8,6,9,6,9,8,8
+V,4,8,6,6,1,7,8,4,3,7,14,8,3,9,0,8
+V,2,1,4,2,1,7,12,3,3,7,11,8,2,10,1,8
+T,10,15,9,8,5,6,10,3,7,12,7,6,3,9,6,5
+L,1,3,2,1,1,6,4,0,6,8,3,10,0,7,1,8
+S,6,9,7,6,4,8,7,4,8,11,6,8,2,9,5,8
+Z,4,8,6,6,3,7,8,2,10,12,6,8,1,9,6,8
+K,4,6,4,4,1,4,7,9,1,7,6,11,3,8,2,11
+S,5,12,5,6,3,8,6,4,5,13,6,8,2,9,3,7
+L,2,7,3,5,3,4,4,4,6,3,1,7,1,6,1,6
+G,4,6,6,4,5,7,9,6,3,6,6,10,4,7,7,7
+M,5,4,6,6,3,7,7,12,2,7,9,8,9,6,0,8
+A,6,13,5,7,3,8,1,2,2,9,4,12,3,5,4,6
+C,1,1,2,2,1,6,8,6,7,8,8,12,1,9,4,10
+E,3,6,5,4,3,10,6,2,7,11,4,9,2,8,5,12
+U,8,10,9,8,5,3,9,5,7,10,10,9,3,9,2,6
+P,3,1,4,3,2,5,10,3,5,9,8,4,3,10,3,7
+J,2,8,2,6,1,14,3,5,4,13,3,9,0,7,0,8
+A,2,7,5,5,4,8,5,2,3,7,2,6,2,5,3,7
+G,5,11,6,8,5,5,6,6,6,6,6,11,2,9,4,8
+T,3,3,4,4,2,7,12,3,6,7,11,8,2,11,1,8
+K,5,9,6,7,4,6,7,4,8,7,6,9,3,8,5,9
+B,1,3,3,1,2,8,7,2,5,10,5,7,1,8,4,9
+J,2,10,3,8,1,11,3,10,3,13,7,13,1,6,0,8
+X,4,8,6,7,6,9,8,2,5,7,5,6,3,8,7,8
+D,3,8,4,6,4,8,8,6,5,9,6,4,3,8,3,6
+Z,2,2,3,3,2,7,7,5,9,6,6,8,1,8,7,8
+S,6,9,7,6,4,6,7,4,7,11,9,9,3,9,5,4
+U,5,10,6,8,3,7,4,15,6,7,14,8,3,9,0,8
+O,4,7,5,5,2,7,8,8,8,7,7,7,3,8,4,8
+K,4,5,7,4,4,6,7,1,7,10,6,9,3,8,3,7
+X,4,10,5,7,2,7,7,5,4,7,6,8,3,8,4,8
+B,3,5,5,3,3,8,7,2,6,10,5,7,2,8,4,10
+U,5,9,7,6,4,6,8,6,7,7,10,10,3,9,1,8
+B,4,9,6,6,8,9,6,4,4,7,7,8,8,8,8,7
+P,2,3,3,2,2,5,10,3,4,10,8,4,1,9,3,7
+B,7,15,7,8,8,6,8,3,6,9,6,7,8,5,8,6
+S,5,9,6,7,3,7,5,6,10,5,6,10,0,9,9,8
+O,7,12,5,7,3,8,7,6,5,9,4,7,5,9,5,8
+W,3,3,4,2,2,9,11,3,2,5,9,8,6,11,0,8
+W,4,3,6,5,3,5,8,5,1,7,8,8,8,9,0,8
+M,8,10,12,7,9,10,6,2,5,9,4,6,13,8,3,9
+H,5,8,7,6,6,8,8,7,7,7,6,7,3,8,4,7
+V,4,11,6,8,4,5,11,2,3,8,11,9,2,10,1,8
+P,7,11,8,8,7,6,9,8,6,8,7,9,3,10,8,9
+T,7,9,6,4,2,6,9,3,8,13,6,7,2,8,5,5
+S,3,7,5,5,7,8,9,4,4,7,6,7,2,7,8,1
+O,5,10,5,8,4,8,6,8,5,10,4,8,3,8,3,8
+V,2,6,4,4,1,8,8,4,2,6,13,8,3,10,0,8
+O,4,7,5,5,3,8,6,7,4,10,5,9,3,8,3,7
+K,4,3,4,5,1,4,8,9,1,7,6,11,3,8,2,11
+Z,2,3,2,1,1,7,7,5,8,6,6,8,1,8,6,8
+R,4,5,7,4,6,5,9,4,3,6,4,9,8,5,7,9
+G,1,0,2,0,0,8,6,5,5,6,6,9,1,7,5,10
+F,3,3,3,4,1,1,14,5,3,12,9,5,0,8,2,6
+M,2,1,2,2,1,7,6,10,0,7,8,8,6,6,0,8
+K,5,9,6,7,6,5,6,5,7,6,6,13,5,7,8,9
+T,3,6,4,4,3,6,11,3,5,11,8,5,3,12,2,5
+S,5,5,6,8,3,7,6,6,9,5,6,10,0,9,9,8
+H,2,4,4,3,3,7,7,3,5,10,6,8,3,8,3,8
+F,3,3,3,4,1,1,11,5,7,11,11,9,0,8,2,6
+Y,2,3,3,1,1,4,10,2,7,11,10,5,0,10,2,4
+T,6,9,5,4,3,7,9,2,6,12,7,6,2,9,4,6
+N,3,9,4,6,2,7,7,14,2,5,6,8,5,8,0,8
+G,5,11,7,8,5,5,6,6,7,6,5,9,4,9,4,7
+P,2,4,4,3,2,8,8,2,5,13,4,4,1,10,2,9
+P,8,9,6,5,3,7,10,6,5,14,5,4,4,10,4,7
+B,3,8,5,6,4,8,7,7,6,7,6,6,2,8,8,10
+W,5,11,8,8,7,10,8,5,1,6,10,7,9,13,1,5
+Z,3,7,5,5,4,7,7,2,7,7,6,8,0,9,9,7
+S,6,8,7,6,4,7,8,4,8,11,8,7,2,9,5,6
+F,6,10,9,8,4,4,14,3,4,13,7,3,1,10,2,6
+J,2,6,2,4,1,9,7,0,8,11,5,6,0,7,1,7
+O,7,11,9,8,11,8,9,6,2,7,7,8,9,9,6,12
+Q,7,8,7,9,6,8,7,6,3,8,8,11,3,8,6,8
+Y,7,9,7,6,5,5,9,1,8,10,10,6,3,11,5,3
+K,6,8,8,6,4,7,8,1,7,10,5,8,3,8,3,8
+Z,2,7,3,5,1,7,7,3,13,9,6,8,0,8,8,8
+G,5,11,6,8,3,8,7,8,8,6,6,9,2,7,5,10
+B,11,14,8,8,5,9,6,5,6,11,4,9,6,6,7,10
+M,5,10,6,8,6,7,6,6,5,7,7,9,8,5,2,9
+H,3,9,4,6,4,7,7,12,1,7,6,8,3,8,0,8
+A,1,3,2,1,1,11,3,3,2,10,2,9,1,6,1,8
+A,5,8,6,6,6,8,9,7,4,6,6,8,3,7,7,5
+W,7,9,9,8,11,9,8,6,5,7,5,8,11,10,9,4
+L,2,5,3,4,2,4,4,4,7,2,1,6,0,7,1,6
+T,5,10,6,8,6,6,6,7,7,7,6,8,4,11,7,7
+P,3,4,5,3,2,6,11,5,2,12,5,2,1,10,3,9
+J,0,0,1,1,0,12,4,5,3,12,4,11,0,7,0,8
+Y,8,11,8,8,4,4,9,1,9,10,10,5,2,9,4,3
+N,4,7,6,5,4,4,9,3,3,9,9,9,6,7,1,7
+E,3,5,5,3,2,7,7,2,8,11,5,9,2,8,4,9
+W,5,9,5,4,4,9,8,3,3,6,8,6,9,10,2,6
+Z,2,4,4,3,2,8,7,2,9,12,5,9,1,8,5,9
+V,6,9,6,7,3,2,11,3,3,10,11,8,2,10,1,8
+W,4,8,6,6,9,9,7,5,1,7,6,8,10,11,2,7
+U,8,10,8,8,7,5,7,5,8,8,6,9,8,8,6,1
+L,6,10,5,5,3,9,2,3,3,11,8,11,3,10,4,10
+A,3,11,6,8,4,12,3,3,3,10,1,9,2,6,3,8
+I,2,10,3,8,4,7,7,0,7,7,6,8,0,8,3,8
+V,5,11,8,8,9,8,8,4,2,7,8,8,8,10,6,8
+O,6,10,8,8,10,8,8,6,2,7,7,8,10,9,5,8
+W,5,10,7,8,9,8,8,5,3,7,9,8,6,8,3,7
+M,3,3,5,1,2,5,7,4,4,10,10,10,6,6,2,8
+B,4,10,5,7,7,8,8,6,6,7,6,6,6,8,6,10
+N,7,12,8,6,4,12,4,5,3,13,0,7,5,7,0,7
+P,4,8,5,6,4,5,11,4,6,11,9,4,4,10,4,7
+S,3,7,4,5,3,8,8,5,7,5,5,5,0,7,8,8
+F,4,9,6,7,4,2,12,3,6,12,11,6,1,10,2,5
+Q,4,6,6,9,3,8,7,9,6,6,6,9,3,8,5,9
+A,2,4,3,3,1,8,2,2,1,7,2,8,2,7,2,7
+B,7,11,9,8,9,9,7,4,6,9,5,6,3,8,6,9
+E,5,9,6,7,7,7,7,4,8,7,6,8,6,8,6,10
+H,5,9,8,7,5,7,7,3,6,10,6,8,3,8,3,7
+W,3,3,3,2,2,5,10,3,2,9,8,7,5,11,1,6
+B,3,9,4,6,5,8,7,6,6,7,6,5,2,8,7,9
+V,7,8,6,6,4,3,11,1,3,9,10,8,4,9,1,8
+Q,5,7,6,9,6,7,10,5,2,5,8,12,3,10,6,8
+Q,5,6,6,8,5,8,7,6,3,8,8,11,3,9,6,7
+G,5,9,5,7,4,5,7,6,6,10,8,9,2,9,5,9
+B,3,6,4,4,4,8,7,3,4,7,6,7,3,8,5,8
+F,1,3,3,1,1,8,10,2,5,13,5,4,1,9,1,8
+E,2,6,3,4,3,6,7,6,8,6,5,10,2,8,5,9
+U,5,9,6,7,4,3,8,5,6,9,8,10,3,9,2,5
+A,4,8,6,6,6,8,9,7,5,6,6,8,3,7,7,4
+Z,4,8,5,6,2,7,7,4,14,9,6,8,0,8,8,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+F,4,11,4,8,2,1,14,5,3,12,10,5,0,8,3,6
+T,4,8,5,6,3,6,11,3,7,9,11,7,5,12,1,7
+N,4,4,4,6,2,7,7,14,2,4,6,8,6,8,0,8
+V,4,9,5,7,2,5,9,5,2,8,13,8,3,10,0,8
+N,3,4,5,3,2,7,9,3,4,10,6,6,5,9,0,7
+Y,7,9,7,7,5,6,8,1,8,8,9,5,4,11,6,4
+N,4,8,5,6,2,7,7,14,2,4,6,8,6,8,0,8
+L,4,9,4,4,2,10,4,3,3,11,6,10,3,10,4,10
+S,4,11,5,8,5,8,8,8,6,7,4,6,2,7,8,8
+V,4,10,6,8,3,7,9,4,2,6,13,8,3,10,0,8
+K,4,5,4,8,2,3,7,8,2,7,5,11,4,8,2,11
+L,2,6,4,4,2,9,4,1,7,10,3,10,0,7,2,10
+B,5,10,5,8,4,6,8,10,7,7,5,7,2,8,9,10
+U,4,6,6,4,3,5,8,7,8,9,10,10,3,9,1,8
+O,4,9,6,7,8,8,8,5,1,7,7,8,8,9,4,9
+E,7,10,5,5,3,8,6,4,7,10,6,9,2,10,8,8
+J,0,0,1,1,0,12,4,5,3,12,4,11,0,7,0,8
+M,8,10,8,5,4,5,9,5,5,4,4,11,9,11,2,7
+G,3,9,4,7,2,7,6,8,8,6,5,10,2,8,6,11
+B,4,2,4,3,4,7,7,5,6,6,6,6,2,8,6,9
+S,3,7,4,5,3,8,8,5,7,5,6,8,0,8,8,8
+C,5,8,6,6,3,4,8,5,7,11,10,12,2,9,3,7
+K,4,4,4,6,2,3,7,8,2,7,6,11,4,8,2,11
+T,9,15,8,8,3,7,8,3,9,13,5,6,2,8,5,5
+A,2,4,4,3,2,8,2,2,2,7,2,8,2,6,2,7
+W,4,5,5,3,3,4,10,2,2,10,9,8,6,11,1,7
+Y,6,7,6,5,3,2,11,4,5,12,12,7,2,11,2,6
+O,3,8,5,6,2,7,8,8,7,7,7,8,3,8,4,8
+O,4,9,5,6,2,8,8,9,7,6,7,9,3,8,4,8
+X,2,2,4,3,2,8,7,3,9,6,6,8,2,8,6,8
+H,2,2,3,3,2,8,7,6,6,7,6,7,3,8,3,7
+X,2,3,4,2,1,6,8,1,8,10,8,9,2,8,3,7
+X,2,3,3,1,1,8,7,2,8,10,5,7,2,8,3,8
+H,2,1,2,2,2,7,7,6,5,7,6,8,3,8,3,8
+B,6,11,8,8,12,8,7,5,4,7,7,7,8,10,10,10
+R,3,7,5,5,5,6,7,3,3,6,6,9,5,9,7,5
+V,2,2,4,3,1,7,12,2,3,6,11,9,2,11,1,8
+E,4,10,5,8,5,7,7,6,9,7,6,10,3,8,6,8
+Y,3,5,4,8,6,9,10,3,3,6,8,9,3,12,6,6
+W,10,10,9,5,4,5,9,3,2,7,10,8,10,11,1,6
+W,9,12,9,6,5,4,7,2,4,7,10,8,10,10,2,5
+O,6,9,8,8,7,7,5,4,5,9,4,8,3,7,5,6
+D,4,4,5,6,3,5,7,10,9,7,6,5,3,8,4,8
+N,2,4,4,3,2,7,8,3,4,10,6,7,5,8,1,7
+W,4,3,4,2,2,4,10,2,2,9,9,7,5,11,1,6
+V,3,7,4,5,2,8,9,3,1,6,12,8,2,10,0,8
+O,5,10,6,8,5,8,6,9,4,7,5,8,3,8,3,8
+W,5,11,8,8,4,6,8,5,2,7,8,8,9,9,0,8
+S,4,5,6,5,6,8,7,5,5,7,6,7,5,8,9,10
+B,5,11,5,8,5,7,9,10,7,8,5,6,2,8,10,11
+X,6,11,9,8,4,4,9,3,9,11,12,10,3,9,4,5
+Q,4,5,5,7,4,9,9,6,3,4,8,11,3,9,6,10
+Q,3,6,4,5,2,8,5,8,7,7,4,8,3,8,4,8
+B,2,0,2,1,1,7,7,7,5,7,6,7,1,8,7,8
+H,9,13,8,7,5,5,8,5,4,9,10,10,7,11,5,9
+C,3,5,4,3,1,4,9,5,7,12,10,11,1,9,2,7
+J,7,11,6,8,4,8,9,3,3,13,4,5,2,9,8,9
+E,2,1,2,2,1,4,7,5,8,7,6,13,0,8,7,9
+Q,5,8,6,8,3,8,7,8,6,6,6,8,3,8,5,9
+J,5,6,4,9,3,10,5,2,6,9,5,7,3,8,4,11
+W,6,10,9,8,8,6,12,2,2,7,8,8,7,12,1,8
+U,3,7,4,5,1,8,5,13,5,7,13,8,3,9,0,8
+F,5,11,6,8,5,4,10,5,6,11,11,6,2,10,3,5
+G,3,7,4,5,2,7,6,8,9,8,4,12,1,9,5,10
+D,7,10,6,6,4,8,5,5,5,11,4,7,5,6,6,10
+N,5,10,7,7,8,7,8,3,5,7,6,7,7,8,8,2
+G,6,11,6,6,3,7,7,6,5,9,6,6,4,7,5,6
+A,3,8,4,6,3,6,4,2,0,6,2,8,2,6,1,7
+H,6,8,9,6,5,10,7,4,6,11,2,6,4,9,4,10
+O,2,3,3,2,2,8,7,6,4,9,5,8,2,8,2,8
+X,4,9,5,4,3,9,6,2,7,11,3,7,3,8,4,9
+P,6,11,6,8,3,4,14,8,1,11,6,3,1,10,4,8
+A,3,5,6,3,2,9,2,2,2,8,2,10,3,7,2,8
+B,4,9,4,7,6,7,9,8,6,7,5,7,2,7,7,10
+R,3,5,5,3,3,8,8,4,5,9,5,6,3,7,4,9
+C,5,11,7,8,8,6,7,4,4,6,7,10,7,8,7,7
+Z,5,9,7,7,5,9,11,6,5,6,5,8,3,8,10,7
+B,5,10,7,8,8,8,7,5,7,7,6,5,2,8,6,10
+M,6,4,6,7,4,7,7,13,2,7,9,8,9,6,0,8
+G,3,5,4,4,2,6,6,5,5,9,7,10,2,8,4,10
+X,2,2,4,4,2,7,7,3,9,6,6,8,2,8,6,8
+M,6,11,9,8,12,10,5,3,2,9,4,8,11,8,4,6
+Z,1,0,2,1,0,7,7,3,11,8,6,8,0,8,6,8
+R,10,14,8,8,5,8,8,6,5,9,4,9,7,5,6,11
+M,7,11,9,8,10,7,10,7,5,7,7,9,8,10,7,12
+H,6,10,8,8,11,8,9,5,3,6,7,7,8,7,11,9
+W,7,8,7,6,5,2,12,2,2,10,10,8,6,11,1,7
+N,4,6,6,4,4,8,8,6,6,6,5,4,6,10,3,5
+V,3,4,4,3,1,5,12,3,3,9,11,7,2,10,1,8
+J,1,2,2,3,1,10,6,2,6,12,4,8,1,6,1,7
+T,4,11,6,9,6,9,11,3,6,6,11,8,2,12,1,8
+N,6,9,8,7,5,6,10,2,4,9,8,8,5,8,1,8
+B,4,6,5,4,5,8,7,4,5,7,5,7,3,8,6,8
+V,3,9,5,7,1,10,8,4,3,5,14,8,3,10,0,8
+C,3,8,4,6,1,6,7,7,9,8,6,13,1,9,4,9
+A,2,1,3,2,1,9,3,2,2,8,2,8,2,6,2,8
+F,10,15,9,8,6,9,7,2,7,10,6,8,4,7,7,8
+O,5,8,6,6,4,7,6,8,5,7,5,7,3,9,3,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+L,2,6,3,4,2,4,5,1,9,3,2,8,0,7,2,5
+E,4,6,6,4,3,7,8,1,9,11,6,8,2,8,4,8
+A,4,9,6,6,2,7,4,3,1,6,1,8,3,7,2,7
+O,6,8,8,6,9,7,6,5,2,7,5,7,11,9,7,11
+Z,7,13,7,7,4,8,5,2,8,11,5,9,3,9,5,9
+E,4,11,4,8,3,3,8,6,10,7,6,15,0,8,7,7
+G,5,10,6,8,4,7,6,7,7,11,6,12,3,10,5,8
+Y,3,8,5,5,1,8,12,2,3,6,12,8,1,10,0,8
+M,6,6,8,5,8,8,9,4,5,6,6,6,9,6,6,4
+J,5,9,4,12,4,7,8,3,3,13,5,5,3,8,7,10
+G,1,3,2,1,1,7,7,5,4,9,7,9,2,8,3,10
+E,4,9,6,6,4,5,8,4,8,11,9,9,2,9,5,6
+O,5,7,6,6,5,8,4,4,4,9,3,8,3,7,5,7
+S,7,10,8,7,4,8,8,5,10,11,2,8,2,5,5,10
+J,2,2,4,4,2,10,6,2,6,12,3,8,1,6,1,7
+C,5,7,5,5,2,5,9,6,8,12,9,10,2,10,3,7
+D,4,6,6,4,4,9,7,4,6,10,4,5,3,8,3,8
+W,4,7,6,5,3,4,8,5,1,7,9,8,8,9,0,8
+G,7,11,7,8,6,6,6,6,6,10,6,14,5,8,6,7
+U,5,8,5,6,3,3,10,5,6,13,12,9,3,9,1,7
+A,2,7,3,4,1,7,6,3,1,7,0,8,2,7,1,8
+Y,5,11,7,8,4,7,10,2,7,6,12,8,2,11,2,8
+T,3,8,4,5,1,10,15,1,6,4,11,9,0,8,0,8
+S,4,9,5,6,4,9,8,5,9,6,6,5,0,7,8,8
+S,1,0,2,1,1,8,7,4,7,5,6,7,0,8,7,8
+P,4,7,6,10,9,8,9,4,0,8,7,6,5,11,5,7
+I,1,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+H,4,9,4,7,4,7,9,13,2,7,4,8,3,8,0,8
+X,3,2,5,3,2,8,7,3,9,6,6,8,3,8,6,8
+K,5,7,8,5,5,7,6,1,7,10,6,10,4,7,4,9
+M,5,9,6,5,3,11,3,2,2,10,3,9,7,2,1,9
+M,2,1,3,1,2,8,6,6,4,7,7,8,6,5,1,7
+M,1,0,2,0,0,8,6,9,0,7,8,8,5,6,0,8
+N,5,10,7,7,5,6,9,6,5,7,7,8,6,9,2,6
+P,5,10,7,7,6,7,7,8,4,7,6,7,3,9,8,9
+W,3,3,4,2,2,5,10,3,2,9,9,7,5,11,1,7
+N,6,8,9,6,4,7,9,3,5,10,7,7,6,8,1,8
+J,5,10,7,8,7,9,10,4,4,9,4,6,4,8,6,4
+Y,6,11,9,8,5,9,10,0,8,4,11,7,1,10,2,9
+Z,3,9,4,7,3,7,8,3,12,8,6,8,0,8,7,7
+Y,6,8,7,10,8,10,12,5,4,6,7,7,5,11,8,5
+X,7,10,8,6,4,5,9,3,7,12,9,8,4,9,3,6
+D,6,9,8,7,5,9,6,4,7,10,5,6,3,8,3,9
+L,4,11,4,8,3,0,2,4,6,1,0,8,0,8,0,8
+Z,3,8,4,6,4,8,6,2,7,8,6,8,0,9,8,8
+W,4,4,5,3,3,5,11,3,2,9,8,7,6,11,2,6
+I,0,3,1,2,0,7,7,1,6,13,6,8,0,8,0,7
+B,2,0,2,1,1,7,8,7,5,7,5,7,1,8,7,8
+D,4,5,6,4,4,5,7,6,7,7,6,8,4,7,5,5
+M,4,5,5,8,4,8,7,12,2,6,9,8,8,6,0,8
+L,3,8,4,6,3,5,5,2,8,6,2,10,0,7,3,7
+O,5,10,4,5,3,6,7,6,3,9,7,9,5,10,5,8
+L,4,11,6,8,4,6,5,1,9,7,2,10,0,7,3,8
+E,4,8,4,6,2,3,7,6,11,7,7,14,0,8,7,7
+T,5,11,5,8,3,7,10,2,9,11,9,4,1,11,3,5
+A,2,3,3,2,1,10,2,3,1,10,2,9,2,6,2,8
+V,7,12,6,6,3,8,10,5,4,7,10,5,5,12,3,7
+V,3,2,6,4,2,7,12,2,3,7,11,9,3,10,1,8
+N,3,4,5,3,2,7,9,3,5,10,7,7,5,8,1,8
+B,8,13,7,8,7,9,7,4,5,9,5,7,7,6,9,8
+P,4,5,5,4,3,5,10,4,5,10,8,3,1,10,4,6
+Z,2,4,4,3,1,7,8,2,9,11,6,8,1,8,5,7
+K,1,0,1,0,0,5,7,7,0,7,6,10,2,8,2,11
+X,4,10,7,8,5,12,6,2,7,10,1,6,2,7,3,10
+S,4,7,5,5,3,6,8,3,6,10,8,8,2,8,5,5
+O,4,9,5,7,4,7,7,8,5,7,6,8,3,8,3,8
+G,2,4,3,3,2,6,8,5,5,9,8,9,2,8,4,9
+A,3,9,5,7,4,9,3,1,2,7,2,8,2,6,4,7
+P,5,5,6,7,3,4,12,9,2,10,6,4,1,10,4,8
+O,9,13,6,7,4,6,5,6,4,10,6,10,6,8,5,7
+B,5,10,7,7,8,8,7,6,6,6,6,6,2,8,6,10
+R,6,9,6,4,4,6,8,3,5,7,4,10,5,8,6,7
+W,5,8,7,6,5,4,11,2,3,8,9,9,8,10,1,8
+L,3,9,5,7,2,7,3,2,8,7,2,9,1,6,2,8
+L,3,6,4,4,2,5,5,1,9,6,2,10,0,7,2,7
+C,3,6,4,5,4,5,6,3,5,7,6,11,4,10,6,9
+P,3,5,5,3,2,8,9,3,4,12,4,3,1,10,3,8
+D,3,3,3,5,2,5,7,10,7,7,6,5,3,8,3,8
+A,3,11,5,8,2,9,6,3,1,8,0,8,2,7,2,8
+N,3,6,5,4,3,5,9,6,4,8,7,9,5,9,1,7
+T,4,5,5,5,5,7,8,4,7,7,6,9,3,7,7,6
+Y,3,5,5,8,7,10,10,4,2,4,8,9,4,13,6,8
+I,1,7,2,5,2,7,7,0,7,7,6,8,0,8,2,8
+V,5,10,5,8,3,3,11,3,4,10,12,8,2,10,1,8
+U,3,2,4,4,2,7,8,6,6,6,9,9,3,9,1,8
+C,4,8,4,6,2,5,7,6,7,11,9,14,1,9,3,8
+R,8,12,8,6,6,7,8,3,6,9,3,8,6,6,6,6
+C,3,5,4,4,1,3,9,5,7,12,10,11,1,9,2,7
+P,3,5,4,8,6,8,9,3,1,8,7,6,4,10,5,8
+E,4,8,4,6,4,3,8,5,9,7,6,14,0,8,6,8
+Q,2,1,3,2,1,8,6,7,5,6,6,8,3,8,4,8
+V,2,1,4,3,1,7,12,2,3,7,11,9,2,10,1,8
+T,3,6,4,4,3,8,11,2,6,6,11,8,2,11,1,8
+E,4,6,6,4,6,7,8,3,5,6,7,11,3,10,7,8
+M,6,11,9,8,12,9,7,3,3,8,4,7,12,5,4,5
+V,8,12,6,6,3,8,11,4,5,5,10,6,4,10,3,5
+R,4,7,5,5,4,10,7,3,6,10,3,7,3,7,3,10
+J,1,5,3,4,1,9,6,2,6,14,5,10,0,7,0,7
+Z,1,1,2,3,1,8,7,5,8,6,6,7,1,8,7,8
+B,6,12,6,7,5,9,7,3,5,9,5,7,6,7,8,9
+R,4,8,6,6,5,9,7,4,5,9,3,8,3,7,4,11
+V,2,1,4,3,1,5,12,3,3,9,11,8,2,10,1,8
+K,1,1,1,1,0,4,7,6,3,7,6,11,3,8,2,11
+A,3,3,5,5,2,7,5,3,1,6,1,8,2,7,2,7
+M,4,4,6,3,4,5,6,4,4,10,10,10,6,5,2,7
+Y,2,0,2,0,0,7,10,3,1,7,12,8,1,11,0,8
+X,7,10,9,8,8,8,6,3,5,6,7,7,4,10,11,8
+A,3,9,5,6,2,9,6,3,1,8,0,8,2,7,1,8
+R,4,7,4,5,4,6,10,7,3,7,4,9,2,7,5,11
+J,3,7,4,5,2,10,7,1,6,13,3,7,0,8,0,8
+A,4,10,7,8,4,13,2,4,4,12,1,9,3,7,4,10
+F,1,0,1,0,0,3,12,4,2,11,9,6,0,8,2,7
+Y,2,2,4,4,2,7,10,1,7,7,11,8,1,11,2,8
+X,4,3,5,5,1,7,7,5,4,7,6,8,3,8,4,8
+K,3,6,4,4,4,6,7,3,6,6,5,9,3,8,4,9
+D,3,7,4,5,4,7,7,7,7,7,7,5,3,8,3,7
+Y,5,7,6,5,5,8,5,6,5,5,8,8,3,9,9,6
+F,3,4,4,6,2,1,12,5,6,11,11,9,0,8,2,6
+X,5,8,7,6,3,7,8,1,8,10,6,8,3,8,4,7
+L,5,9,7,7,5,8,4,1,8,9,2,10,1,6,3,9
+W,8,11,8,8,9,6,10,4,3,9,6,6,11,10,4,5
+A,5,8,9,6,6,7,5,2,4,6,1,6,5,7,5,6
+X,3,6,4,4,3,8,5,2,5,6,7,8,2,9,8,9
+W,6,9,8,7,4,10,8,5,2,6,8,8,9,9,0,8
+A,2,3,3,2,1,8,2,2,1,8,2,8,2,6,3,8
+I,1,3,2,2,1,7,8,1,7,13,6,8,0,8,1,7
+U,4,9,6,7,8,8,6,4,4,6,7,8,8,9,5,6
+L,2,2,3,4,2,5,4,5,7,2,2,5,1,6,1,6
+X,4,6,7,4,3,5,9,3,8,11,12,9,3,9,4,5
+D,1,0,1,1,1,6,7,8,5,6,6,6,2,8,2,8
+T,3,4,3,3,2,5,11,2,7,11,9,5,1,11,2,5
+A,2,4,4,3,1,6,3,2,2,5,2,8,2,6,2,6
+D,5,11,7,9,11,9,8,5,5,7,6,6,5,7,12,6
+E,2,3,4,2,2,7,7,2,8,11,6,8,1,8,4,8
+W,4,5,5,3,3,3,10,2,2,10,10,8,6,11,1,7
+X,3,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+C,2,1,2,1,0,6,7,6,9,7,6,14,0,8,4,10
+G,2,4,4,3,2,6,7,6,6,6,6,10,2,8,4,9
+H,6,8,8,6,6,10,6,3,6,10,3,7,6,7,5,11
+A,4,9,7,7,5,10,3,1,2,8,3,9,4,5,3,7
+J,1,1,2,2,1,10,6,2,6,12,4,8,1,7,1,7
+F,6,10,8,7,4,6,11,2,6,14,6,3,1,10,2,7
+Y,2,3,2,1,1,5,10,2,6,10,9,6,1,11,2,5
+U,6,9,8,7,5,4,9,6,7,7,10,11,3,9,1,8
+W,5,4,6,3,3,5,11,3,2,9,8,7,7,12,1,6
+Z,4,9,5,7,3,7,7,3,12,9,6,8,0,8,8,8
+E,5,11,7,8,5,7,7,2,9,11,6,9,3,8,5,8
+B,5,10,7,7,6,9,6,4,7,9,5,7,2,8,6,10
+V,6,9,8,8,10,7,6,5,5,7,6,8,7,10,8,9
+B,4,3,5,5,3,6,9,8,7,7,6,6,2,8,9,10
+V,7,13,7,7,4,9,8,4,4,8,8,5,6,13,3,7
+L,4,4,4,6,1,0,0,6,6,0,1,5,0,8,0,8
+K,4,9,4,6,2,3,7,7,2,7,6,11,3,8,3,10
+U,5,8,5,6,2,7,4,14,6,7,14,8,3,9,0,8
+P,1,3,3,1,1,7,10,3,3,12,5,4,1,9,2,8
+N,3,7,3,5,2,7,7,13,2,5,6,8,5,8,0,8
+D,4,8,5,6,5,7,7,5,7,7,6,5,6,8,3,7
+Q,3,7,4,6,2,10,9,8,6,4,8,10,3,8,5,9
+M,3,3,5,1,2,9,6,3,4,9,5,8,7,5,1,8
+Y,3,4,5,6,1,7,10,1,3,7,12,8,1,11,0,8
+Z,4,9,6,7,7,8,7,2,8,7,6,8,0,8,9,8
+Z,1,3,3,2,1,7,8,2,9,11,6,8,1,8,5,7
+Q,6,12,5,7,3,7,6,4,9,10,5,9,3,7,9,8
+B,4,7,5,5,4,8,6,4,6,9,5,6,2,8,6,10
+L,3,7,5,6,4,6,8,4,6,7,6,9,2,8,8,9
+P,2,6,2,4,2,4,11,8,1,10,6,4,1,10,3,8
+H,3,3,6,2,3,8,7,3,6,10,5,8,3,8,3,8
+K,1,1,1,1,0,4,6,6,2,7,6,10,3,8,2,10
+A,9,13,7,7,4,8,2,3,2,8,4,12,5,4,5,6
+G,2,3,3,5,2,8,8,8,6,5,7,9,2,7,5,11
+I,3,9,5,6,2,7,9,0,8,14,6,5,0,9,2,7
+Y,5,8,5,6,2,3,11,2,7,12,11,6,1,10,2,5
+V,2,8,4,6,1,8,8,4,2,7,13,8,3,10,0,8
+O,2,4,2,2,1,7,7,6,4,9,6,8,2,8,2,7
+J,2,7,3,5,2,8,7,1,6,11,5,8,1,6,1,6
+A,3,7,5,4,2,7,5,3,0,6,1,8,2,7,2,7
+M,6,9,7,4,4,5,9,4,5,5,4,10,8,9,2,8
+W,6,10,8,8,9,7,8,6,3,7,8,8,6,8,4,8
+C,3,7,4,5,2,6,6,6,10,8,5,12,1,9,4,8
+F,3,7,3,5,2,1,12,4,5,12,11,7,0,8,1,6
+K,4,6,6,6,5,6,7,2,4,6,4,9,4,5,8,8
+C,4,5,5,5,5,5,8,3,4,7,6,11,4,10,7,9
+T,5,8,7,6,7,7,8,4,7,8,6,9,5,8,5,6
+P,6,8,8,6,4,9,8,4,7,12,4,5,4,8,5,8
+B,3,8,3,6,4,6,7,8,5,7,6,7,2,8,7,8
+U,2,1,3,2,1,7,8,6,6,7,9,9,3,10,0,9
+X,2,5,4,4,2,8,7,3,9,6,6,8,2,8,6,9
+D,4,9,4,4,2,13,3,3,4,12,1,8,3,7,1,10
+T,6,10,5,5,2,5,9,2,7,12,7,5,2,10,4,4
+K,4,8,4,6,3,3,6,6,3,7,7,11,3,8,3,11
+P,5,7,7,5,4,7,11,4,5,13,5,3,1,10,3,8
+P,2,4,4,3,2,7,9,4,3,12,5,3,1,10,2,8
+L,4,9,6,7,3,8,4,1,8,9,2,10,0,6,2,9
+B,2,4,4,3,3,8,7,3,5,10,6,6,2,8,5,8
+N,5,5,7,5,6,8,6,5,5,8,5,7,7,9,5,4
+F,2,7,3,4,1,1,12,5,4,11,10,7,0,8,3,7
+A,2,3,3,2,1,11,2,2,1,9,2,9,1,6,2,8
+E,7,15,5,8,3,7,8,5,8,10,6,10,1,9,7,8
+P,4,6,5,4,3,7,11,5,3,12,5,2,1,10,3,8
+J,5,10,7,8,3,10,6,2,8,14,3,8,0,7,0,8
+P,5,11,6,8,6,6,6,6,4,8,6,9,5,9,7,10
+X,2,3,3,4,1,7,7,4,4,7,6,8,3,8,4,8
+S,6,8,8,6,8,8,6,4,3,9,5,8,5,9,11,10
+P,4,9,6,7,5,8,9,3,4,12,5,4,2,9,3,8
+F,5,11,7,8,5,4,11,5,4,13,9,5,2,10,2,5
+B,5,11,7,8,7,8,7,7,7,7,6,5,3,8,8,10
+Z,4,8,6,6,4,7,9,2,9,11,7,6,1,8,6,6
+P,3,5,3,4,2,6,9,5,4,9,7,4,1,10,3,7
+X,5,8,8,6,4,6,8,1,8,10,9,9,3,8,3,7
+E,5,10,5,7,3,3,7,6,11,7,6,14,0,8,8,7
+R,4,6,6,4,4,6,8,5,6,7,5,7,3,7,5,8
+E,5,11,7,9,9,7,7,3,5,6,7,10,5,9,8,8
+O,7,10,9,7,11,7,8,5,2,7,6,8,12,11,9,12
+X,6,10,9,8,5,8,7,0,8,10,5,8,3,8,3,8
+C,3,5,4,4,2,3,9,4,7,11,10,12,1,9,2,6
+K,4,7,4,5,3,3,8,7,2,7,6,11,3,8,2,11
+P,5,7,7,5,3,7,11,3,6,14,5,2,0,10,3,8
+N,6,9,9,6,5,7,9,2,5,10,6,6,6,9,1,7
+C,4,8,4,6,2,4,9,6,7,12,10,12,2,9,3,7
+B,6,11,8,8,8,8,7,7,7,7,6,6,3,8,8,11
+N,7,11,9,8,7,7,9,6,6,7,6,6,6,9,2,6
+X,3,7,5,5,4,8,6,3,5,6,7,8,2,9,8,9
+I,7,10,9,8,5,6,8,2,8,7,6,10,0,7,4,8
+N,4,7,4,5,2,7,7,14,2,5,6,8,6,8,0,8
+V,5,11,7,8,9,7,9,4,2,8,8,8,5,9,7,6
+M,6,9,7,4,3,4,8,5,5,4,2,11,8,9,2,8
+K,4,7,6,5,4,7,6,1,6,9,5,9,3,8,3,8
+P,4,2,5,4,3,5,10,5,4,10,8,4,1,10,3,7
+G,3,7,4,5,3,7,6,6,6,6,5,9,2,9,6,11
+W,4,6,6,4,5,7,7,6,3,8,7,7,6,8,4,10
+O,6,10,6,7,6,8,7,8,4,8,5,6,5,8,5,9
+V,2,0,3,1,0,7,9,4,2,7,13,8,2,10,0,8
+B,7,11,10,8,7,10,6,3,7,10,4,7,2,8,7,11
+A,2,3,4,4,1,9,5,3,1,8,1,8,2,7,2,8
+G,7,10,9,8,9,7,5,6,3,7,6,10,5,8,7,8
+U,5,4,5,6,2,7,4,14,5,7,14,8,3,9,0,8
+T,5,8,5,6,3,7,10,2,9,11,9,5,1,11,3,4
+P,4,8,4,5,2,3,14,7,1,11,6,3,0,10,4,8
+J,3,8,4,6,1,11,3,11,3,12,9,14,1,6,0,8
+F,7,10,9,8,9,7,8,6,4,8,6,7,4,11,8,11
+E,3,8,3,6,3,3,7,5,8,7,6,13,0,8,6,9
+O,5,10,7,8,8,8,10,6,3,8,7,6,10,10,6,10
+K,4,5,6,4,3,4,8,2,7,10,10,11,3,8,3,6
+M,4,6,5,4,4,6,6,6,5,6,8,10,7,5,2,9
+F,4,7,5,5,4,5,9,5,7,10,10,6,2,9,3,5
+Z,6,10,8,8,5,8,6,2,9,12,4,11,3,7,8,9
+F,2,3,4,1,1,6,10,3,5,13,7,5,1,9,1,7
+G,3,7,4,5,3,8,7,7,5,6,7,9,2,7,5,11
+V,5,9,8,6,8,8,7,4,2,7,8,8,5,10,4,8
+H,2,3,3,2,2,9,7,6,6,7,6,6,3,9,2,7
+J,6,9,9,7,6,8,5,3,6,8,6,8,4,7,4,7
+O,5,5,7,8,3,8,5,8,9,7,4,8,3,8,4,8
+D,8,12,8,6,5,7,5,4,7,8,4,6,5,7,6,9
+J,1,2,2,3,1,10,6,1,7,12,3,8,0,7,1,8
+T,4,11,5,8,4,6,11,1,8,8,11,8,1,11,1,7
+A,1,0,2,1,0,7,4,2,0,7,2,8,2,7,1,8
+S,4,7,6,5,3,8,7,4,8,11,5,7,2,8,5,8
+L,5,10,5,7,2,0,1,5,6,0,0,7,0,8,0,8
+J,4,8,5,6,3,8,4,6,3,14,8,14,1,6,1,6
+G,4,7,6,5,3,6,7,5,5,6,6,8,3,8,4,8
+P,3,3,4,4,2,4,13,8,1,11,6,3,1,10,4,8
+S,1,0,2,1,1,8,7,4,6,5,6,7,0,8,7,8
+D,2,5,4,4,3,9,6,4,6,10,4,6,2,8,3,8
+R,2,5,4,3,3,9,7,4,5,9,4,7,3,7,4,9
+T,2,4,3,2,2,7,12,3,6,7,11,8,2,11,1,8
+O,1,3,2,2,1,8,7,7,4,7,6,8,2,8,2,8
+Q,4,6,5,5,4,8,7,7,5,6,7,8,2,8,4,9
+L,3,7,4,5,1,0,0,6,6,0,1,5,0,8,0,8
+P,2,3,4,2,1,7,9,4,3,11,4,4,1,9,2,8
+W,6,10,6,5,4,2,9,2,3,10,11,9,8,10,1,6
+D,3,8,5,6,5,7,7,6,5,6,5,5,3,8,2,7
+P,3,4,4,3,2,5,10,4,4,10,8,4,1,10,4,7
+H,3,4,4,3,3,7,7,6,6,7,6,8,3,8,3,8
+R,3,5,5,4,3,9,7,4,5,9,4,6,3,7,4,10
+U,9,10,9,8,7,5,7,5,8,8,5,9,7,9,6,2
+T,5,8,6,7,6,6,8,4,8,7,7,8,3,10,7,7
+I,0,6,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+W,4,4,6,3,3,8,11,2,2,6,9,8,7,11,0,7
+L,4,7,5,5,3,7,4,1,8,8,2,10,0,7,2,8
+P,4,6,5,4,3,5,11,5,5,11,8,3,0,10,4,6
+N,3,3,5,2,2,7,9,3,4,10,6,6,5,8,1,7
+O,3,4,4,3,2,7,7,7,4,9,7,8,2,8,3,8
+A,4,9,6,8,6,7,8,2,6,7,8,9,5,11,3,7
+A,2,4,4,3,2,11,2,3,1,9,2,9,2,6,2,9
+G,4,10,6,7,4,7,7,7,6,5,7,8,2,7,4,8
+D,4,7,4,5,4,6,7,9,7,6,4,6,2,8,3,8
+Z,3,8,4,6,4,6,8,5,9,7,7,10,2,9,7,7
+F,4,5,6,6,5,7,9,4,5,8,6,7,4,9,8,7
+Q,8,13,7,7,5,9,5,4,7,11,5,8,4,8,10,11
+C,4,11,6,8,2,6,6,7,10,8,6,14,1,9,4,9
+H,3,4,4,3,3,8,7,6,6,7,6,7,3,8,3,6
+H,4,7,6,9,7,8,10,4,1,8,6,6,4,10,9,5
+L,3,8,5,6,3,7,4,0,7,8,3,10,0,7,2,8
+T,4,5,6,8,2,7,15,1,6,7,11,8,0,8,0,8
+D,3,6,5,4,3,10,6,4,7,11,3,6,3,8,3,9
+X,3,3,5,2,2,8,7,1,8,11,5,8,2,8,3,8
+Y,2,5,4,4,2,6,10,1,7,8,11,9,1,11,2,7
+K,6,9,8,6,5,5,9,2,7,10,8,10,3,8,3,7
+P,5,8,6,10,8,9,9,2,3,6,9,6,9,11,7,5
+I,2,8,2,6,3,7,7,0,7,7,6,8,0,8,3,8
+Y,3,5,5,4,2,7,10,1,7,7,11,8,1,11,2,8
+R,4,8,5,6,6,8,6,6,3,8,6,8,4,7,6,11
+W,7,8,9,7,10,6,9,6,7,7,7,8,8,9,8,10
+L,6,15,6,8,3,7,3,3,5,12,4,13,2,7,6,8
+J,3,8,4,6,2,8,5,4,8,13,5,12,1,6,1,7
+D,5,10,7,7,5,9,7,5,7,10,4,5,3,8,3,8
+H,3,7,3,5,2,7,7,14,1,7,7,8,3,8,0,8
+P,6,7,8,9,9,6,8,4,3,9,8,6,6,11,6,6
+V,6,8,5,6,3,4,11,3,4,9,11,7,2,10,1,8
+B,5,11,6,8,8,8,7,4,6,7,6,6,6,8,6,10
+E,5,7,7,6,7,7,6,6,4,7,6,9,8,10,10,10
+Y,1,0,2,0,0,8,10,3,1,6,12,8,1,11,0,8
+O,4,6,5,4,6,8,6,6,2,7,6,8,7,9,3,8
+R,1,0,2,0,1,6,10,7,2,7,5,8,2,7,4,9
+G,5,5,6,8,3,7,6,8,8,6,5,10,2,8,6,11
+T,2,10,4,7,1,6,14,0,6,8,11,8,0,8,0,8
+P,5,9,5,6,3,4,12,9,2,10,6,4,1,10,4,8
+K,4,6,6,4,3,3,9,3,6,10,11,11,3,8,3,6
+D,6,11,7,8,4,6,7,11,11,6,5,6,3,8,4,8
+I,1,6,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+C,3,2,4,4,2,6,8,7,8,9,8,13,1,9,4,10
+O,4,9,5,7,2,7,7,9,7,7,6,8,3,8,4,8
+F,4,7,6,5,3,5,12,3,6,14,7,4,1,10,1,7
+U,9,15,8,8,6,8,6,5,5,7,7,6,7,5,5,4
+H,5,9,5,4,3,5,9,3,6,9,8,9,5,7,3,7
+Y,4,9,5,7,2,8,11,0,4,6,11,8,0,10,0,8
+K,2,3,3,2,2,5,7,4,7,7,6,11,3,8,4,10
+M,2,6,3,4,2,7,6,11,1,7,9,8,7,5,0,8
+Y,3,5,4,4,2,4,11,2,7,11,10,6,1,11,2,5
+K,7,14,7,8,5,7,7,2,6,10,5,8,6,7,4,7
+X,7,13,8,7,4,7,8,2,8,11,6,8,4,8,4,7
+G,4,8,5,6,3,7,6,7,7,8,5,12,3,10,5,8
+Y,7,10,7,7,3,2,12,5,5,12,12,6,2,11,2,6
+T,6,15,6,8,4,6,10,2,6,12,7,6,2,8,5,4
+F,4,5,4,8,2,1,14,5,4,12,10,6,0,8,2,6
+L,2,4,3,3,1,8,3,1,7,9,2,10,0,7,2,9
+K,11,14,10,8,4,6,8,3,8,9,7,8,5,8,4,7
+P,6,10,8,8,6,8,9,3,5,13,5,3,1,10,3,9
+K,6,8,8,6,7,8,7,1,6,9,4,8,4,8,4,8
+N,2,4,2,2,2,7,8,5,4,7,6,7,4,8,1,6
+Q,4,7,5,9,5,8,6,6,2,8,6,11,3,9,6,9
+B,3,6,5,4,4,10,5,3,5,10,4,7,2,8,4,10
+T,4,6,6,4,5,7,8,4,5,6,7,9,5,9,5,7
+T,5,11,7,8,6,6,7,7,7,6,10,10,5,5,9,6
+Q,5,8,6,8,5,8,7,8,6,5,5,8,3,10,5,10
+B,4,4,4,6,4,7,5,9,7,6,7,7,2,8,9,10
+I,7,14,6,8,4,10,7,2,5,11,5,6,2,9,5,12
+D,1,0,2,1,1,6,7,8,6,6,6,6,2,8,3,8
+U,3,3,3,4,2,7,4,14,5,7,12,8,3,9,0,8
+M,6,10,8,7,9,7,6,7,5,6,5,8,9,8,9,11
+J,6,9,4,13,4,7,9,3,3,13,4,5,3,8,6,9
+Q,2,3,2,4,2,7,7,5,2,8,8,9,2,9,4,8
+T,5,8,7,7,6,5,8,4,9,8,7,9,3,9,7,6
+Y,5,7,5,5,3,6,9,1,8,9,9,5,1,9,4,4
+D,3,4,5,3,2,10,6,3,7,10,3,6,2,8,3,9
+V,3,4,4,3,1,4,12,3,3,9,11,7,2,11,0,8
+N,10,13,9,7,4,9,11,5,5,3,6,11,6,10,3,6
+J,1,1,1,1,0,13,3,6,4,12,4,11,0,7,0,8
+W,6,9,9,7,7,7,12,2,2,7,8,8,7,12,1,8
+J,1,0,1,0,0,12,4,6,3,13,5,11,0,7,0,8
+B,2,3,4,2,2,8,7,3,5,10,6,6,2,8,4,9
+N,6,9,9,8,9,7,9,5,4,7,4,7,7,7,6,5
+H,2,6,3,4,2,7,6,12,2,7,8,8,3,9,0,8
+C,5,8,5,6,2,4,9,6,8,12,9,12,1,9,3,7
+U,4,8,5,6,3,7,5,13,4,7,12,8,3,9,0,8
+X,3,3,5,2,2,9,6,2,8,10,3,7,2,7,3,8
+U,3,3,4,2,1,7,8,6,8,8,10,7,3,9,1,8
+I,4,7,5,5,3,9,5,2,6,6,7,5,0,9,4,7
+N,6,9,8,7,5,6,9,6,5,7,7,7,8,8,3,7
+S,3,10,4,8,2,8,6,6,9,5,6,10,0,9,9,8
+P,3,9,5,6,4,6,9,3,6,10,9,4,4,10,4,7
+E,5,9,7,8,8,5,9,4,4,8,7,9,5,11,9,11
+Q,5,9,7,7,6,8,5,8,4,6,7,9,4,6,7,9
+K,7,10,10,8,7,5,6,1,7,9,8,11,3,8,3,8
+N,3,5,6,4,3,7,9,2,5,10,6,6,5,9,1,7
+K,5,10,7,8,7,6,6,3,7,6,6,8,7,8,5,9
+Q,3,4,4,5,3,8,8,7,3,5,7,10,3,9,5,10
+D,5,9,5,6,5,5,7,8,6,5,4,6,3,8,4,9
+L,3,4,3,7,1,0,1,5,6,0,0,7,0,8,0,8
+K,3,2,4,4,3,6,7,4,7,6,6,11,3,8,5,10
+N,3,8,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+R,2,1,2,2,2,6,8,4,5,6,5,7,2,7,4,9
+S,4,8,6,6,7,8,8,5,3,8,5,7,4,8,10,7
+H,6,10,8,7,5,9,6,3,6,10,4,8,4,7,4,8
+B,3,5,5,4,3,10,6,2,6,10,4,7,2,8,4,10
+L,2,4,3,3,1,6,4,1,8,8,2,10,0,7,2,8
+Z,2,5,3,4,2,7,7,5,9,6,6,8,2,8,7,8
+M,5,5,8,4,5,8,6,3,5,9,7,8,9,6,2,8
+O,7,9,9,8,8,8,4,4,5,10,4,10,5,7,7,6
+B,3,4,4,3,3,7,7,4,6,6,6,6,5,8,6,10
+I,5,7,6,5,3,7,6,2,7,7,6,8,0,9,4,8
+L,5,10,7,8,3,5,3,2,10,6,1,10,0,7,3,6
+Q,3,5,4,6,4,9,10,6,2,4,8,11,3,10,5,10
+P,6,11,9,8,5,6,12,5,4,12,5,2,1,10,3,9
+M,6,8,8,6,6,11,6,2,4,9,3,6,8,6,2,8
+R,2,5,4,4,3,7,8,5,5,8,6,7,3,7,5,10
+P,2,3,3,2,1,7,10,4,4,12,5,3,1,10,2,8
+W,4,8,5,6,4,5,8,4,1,7,9,8,6,11,0,8
+E,2,3,3,5,2,3,6,6,10,7,7,14,0,8,7,8
+T,6,10,6,7,4,4,13,4,6,12,10,4,2,12,2,4
+R,2,1,2,1,1,6,10,8,2,7,5,8,2,7,4,10
+D,6,9,8,6,7,9,7,5,6,9,4,6,3,8,3,8
+K,6,9,9,8,8,8,6,2,4,7,4,9,7,4,9,12
+D,3,7,3,5,3,5,7,8,6,6,5,7,2,8,3,8
+U,4,10,4,8,4,7,6,13,4,7,12,8,3,9,0,8
+Q,5,7,5,9,6,7,10,4,3,7,10,10,3,10,6,7
+X,5,6,6,6,6,7,8,2,5,7,6,8,3,7,7,8
+L,4,10,6,7,8,7,8,3,6,5,6,10,5,11,8,8
+I,5,9,7,6,4,7,6,2,7,7,6,9,0,9,4,8
+F,3,6,4,4,3,5,11,4,4,12,8,5,2,10,2,6
+W,4,8,6,6,8,10,9,5,2,6,7,7,8,9,4,5
+Z,2,1,3,2,2,7,7,5,9,6,6,8,2,8,7,8
+N,2,1,2,1,1,7,9,5,3,7,6,7,4,8,1,7
+E,7,10,5,5,2,7,7,4,7,10,6,11,1,9,7,9
+H,5,7,8,5,6,5,9,3,6,10,9,9,3,9,3,6
+M,5,7,7,5,6,7,6,6,5,7,7,11,10,6,2,9
+P,4,8,6,6,4,9,8,2,6,13,5,6,1,10,2,9
+E,3,3,4,5,2,3,8,6,11,7,5,14,0,8,7,7
+V,2,8,4,6,1,9,8,4,3,5,13,8,3,10,0,8
+W,4,6,6,4,3,9,8,4,1,7,8,8,8,9,0,8
+V,4,4,6,7,1,9,8,4,3,6,14,8,3,9,0,8
+Y,7,9,7,6,3,3,12,5,5,13,11,5,1,11,2,6
+S,1,0,2,1,0,8,7,4,7,5,6,8,0,8,7,8
+U,2,0,3,1,1,7,5,11,5,7,14,8,3,10,0,8
+X,8,12,7,6,4,6,7,2,8,9,6,9,4,5,4,7
+O,5,10,6,7,5,7,7,8,4,9,6,8,3,8,3,8
+F,3,3,3,5,1,1,14,5,3,12,10,5,0,8,2,6
+V,5,7,5,5,2,3,11,3,3,10,11,8,3,10,1,7
+Q,7,8,7,10,7,7,8,6,3,7,9,11,4,8,7,8
+M,6,9,8,5,4,9,3,3,2,9,3,9,8,2,1,9
+A,1,0,2,0,0,7,4,2,0,7,2,8,1,7,1,8
+N,5,11,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+Z,5,10,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+M,9,12,11,7,5,13,2,5,2,12,1,9,7,3,1,9
+H,11,13,10,8,5,8,8,4,5,9,6,7,6,9,5,9
+X,4,9,5,6,1,7,7,5,4,7,6,8,3,8,4,8
+A,2,4,4,2,1,11,2,3,2,9,2,9,1,6,2,8
+G,3,5,4,4,2,6,7,6,6,10,7,11,2,9,4,9
+F,2,1,2,3,2,5,10,4,5,10,9,6,1,10,3,7
+H,3,4,6,3,3,9,7,3,6,10,3,7,4,6,4,8
+M,5,9,6,4,3,12,3,4,2,11,2,9,6,3,1,9
+T,7,12,6,6,3,5,11,2,6,11,8,6,2,9,5,3
+W,10,15,10,9,7,5,8,2,4,7,9,7,11,10,2,5
+E,3,6,4,4,3,7,8,7,10,5,4,9,3,8,6,7
+J,3,7,4,5,4,10,5,2,5,8,5,5,3,7,5,7
+G,5,9,6,7,8,8,8,5,2,6,6,9,7,9,6,13
+H,4,4,7,3,3,8,7,3,6,10,5,8,3,8,3,8
+L,7,13,6,7,3,5,5,3,8,10,4,13,2,5,6,7
+Y,2,3,4,4,1,9,10,3,2,5,13,8,2,11,0,8
+H,1,0,2,0,0,7,7,11,1,7,6,8,2,8,0,8
+P,4,5,4,8,2,3,12,9,2,10,6,3,1,10,4,8
+Z,5,8,7,6,5,9,8,6,4,7,5,8,3,8,10,7
+T,3,4,4,6,1,7,15,1,6,7,11,8,0,8,0,8
+D,5,9,5,4,3,12,3,3,5,12,1,8,4,7,2,11
+U,1,0,2,0,0,7,6,10,4,7,12,8,2,10,0,8
+G,5,11,6,8,8,8,7,5,2,6,6,10,7,8,6,12
+E,5,10,8,7,6,6,8,3,8,11,8,9,3,8,5,6
+H,8,10,8,5,5,5,9,3,4,10,7,9,5,7,3,6
+F,2,3,2,2,1,6,10,4,5,10,9,5,1,10,3,6
+J,1,4,2,3,1,10,6,2,5,12,4,9,1,6,1,7
+A,6,11,6,6,4,11,2,4,2,11,4,12,5,3,5,11
+L,4,6,5,5,4,7,5,5,5,7,6,7,3,8,8,11
+Y,2,8,4,5,1,6,11,2,3,9,12,8,1,10,0,8
+G,5,9,4,5,3,7,7,3,2,8,6,7,4,10,8,7
+M,2,3,3,1,2,6,6,7,4,7,7,10,7,5,2,9
+K,2,4,4,3,3,6,7,1,6,10,7,10,3,8,2,8
+S,4,8,5,6,3,7,7,5,9,5,6,8,0,8,9,8
+E,0,0,1,0,0,5,7,5,7,7,6,12,0,8,6,10
+G,4,9,5,6,4,6,7,6,5,9,7,11,2,9,4,10
+T,2,4,3,5,1,5,14,1,6,9,11,7,0,8,0,8
+V,8,10,7,6,3,8,10,5,5,5,10,7,4,11,3,5
+K,3,7,5,5,3,6,7,5,7,6,6,10,3,8,5,9
+Z,3,8,4,6,3,8,7,6,10,6,6,8,1,8,8,7
+D,7,10,7,5,4,8,4,4,6,8,4,7,4,6,6,10
+Q,2,3,3,4,3,8,8,5,2,8,8,9,2,9,5,8
+H,3,4,5,3,3,6,9,3,6,10,8,8,3,8,3,7
+V,5,11,7,8,5,9,11,3,2,5,10,8,5,10,5,7
+G,2,3,3,1,1,7,7,6,5,7,6,9,2,9,4,10
+T,8,10,8,8,6,7,10,2,8,11,9,5,3,10,5,4
+J,7,11,9,9,5,7,8,3,6,15,6,10,1,6,1,6
+Q,2,3,3,4,3,8,7,6,3,8,6,9,2,9,3,9
+Y,2,4,3,3,1,6,10,1,7,8,11,8,1,11,2,7
+I,2,9,3,7,3,7,7,0,7,7,6,8,0,8,3,8
+A,3,8,5,6,5,8,8,6,4,6,6,8,5,7,6,4
+T,8,15,7,8,3,6,9,3,8,13,6,6,2,8,5,5
+Q,3,5,4,6,4,8,7,7,2,5,5,10,3,9,4,10
+N,6,10,8,8,7,6,7,9,5,6,4,6,5,7,4,10
+W,4,9,6,7,5,10,10,3,3,5,9,7,7,11,1,8
+U,6,9,6,6,4,4,8,5,7,11,10,9,3,9,2,6
+R,3,1,4,2,2,7,8,5,5,7,5,6,2,7,4,8
+H,4,9,5,7,5,8,8,6,6,7,6,9,3,8,3,8
+E,4,9,6,7,6,8,7,6,3,7,6,10,4,8,7,9
+Y,2,1,3,1,0,7,11,3,1,7,12,8,1,11,0,8
+N,2,4,3,3,2,7,8,5,4,7,7,7,4,8,1,6
+N,4,8,6,6,3,7,8,3,4,10,6,7,5,8,1,7
+S,5,10,8,7,10,7,5,3,2,7,5,7,3,7,11,3
+G,5,5,6,8,3,6,6,8,9,6,6,9,1,8,6,11
+O,5,7,7,6,5,7,6,5,6,9,5,9,4,7,5,6
+F,3,5,5,6,4,7,10,4,4,8,7,7,3,9,6,5
+M,5,11,7,8,9,6,6,5,5,7,7,11,11,6,2,9
+K,3,4,6,3,3,7,8,2,7,10,4,8,5,7,4,7
+S,6,12,6,7,3,8,6,3,4,13,6,8,2,9,3,8
+C,2,3,3,2,1,5,8,5,6,12,9,10,1,10,2,7
+F,9,15,8,8,6,7,11,3,5,12,6,3,5,9,9,6
+N,4,10,5,7,3,7,7,14,2,4,6,8,6,8,0,8
+T,5,9,5,7,4,5,11,2,7,11,10,5,1,12,2,4
+K,4,7,6,5,6,8,8,5,5,8,5,7,7,6,6,11
+R,4,7,6,5,5,7,7,4,6,7,6,6,3,7,5,9
+N,4,3,4,4,3,7,8,5,5,7,6,6,6,9,3,6
+K,8,12,8,7,4,9,7,3,7,9,2,5,5,7,4,8
+W,2,0,2,1,1,7,8,3,0,7,8,8,6,10,0,8
+M,5,10,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+F,4,6,6,4,6,7,7,5,3,7,6,9,3,9,8,11
+H,5,9,7,7,6,7,7,7,7,7,6,8,3,8,4,8
+Z,4,10,4,8,4,7,8,3,12,9,6,8,0,8,7,7
+Z,4,10,5,8,3,7,7,4,15,9,6,8,0,8,8,8
+H,3,6,5,4,4,5,9,3,5,10,9,9,3,8,3,6
+L,4,10,5,8,4,6,4,4,9,2,2,5,1,6,2,5
+S,2,7,3,5,3,8,7,5,7,5,6,6,0,8,8,8
+N,3,7,4,5,4,9,8,6,5,6,5,4,5,9,2,5
+A,2,1,4,2,2,7,2,2,2,7,2,8,2,7,3,7
+P,3,5,5,4,2,7,10,4,4,13,5,2,1,10,2,8
+C,5,8,6,6,4,7,8,8,6,5,7,12,5,8,4,8
+A,3,4,5,3,2,10,2,2,1,9,2,9,2,6,2,8
+P,4,5,5,4,3,5,10,4,5,10,8,3,1,10,3,7
+N,2,4,4,3,2,7,9,2,4,10,6,6,5,9,0,7
+J,3,9,4,7,3,9,6,2,5,11,4,9,1,6,2,5
+O,5,10,6,7,4,8,7,8,5,10,6,8,3,8,3,7
+H,2,3,3,2,2,6,7,7,5,7,6,10,3,8,3,9
+P,3,9,4,6,2,4,12,9,2,10,6,4,1,10,4,8
+G,3,7,4,5,3,6,6,5,5,6,6,10,2,9,4,8
+J,1,3,2,1,0,9,5,3,5,14,6,11,0,7,0,8
+K,4,8,6,6,4,8,6,1,7,10,4,9,4,7,5,10
+P,2,6,3,4,1,4,13,8,2,11,6,3,1,10,3,8
+L,2,3,3,2,1,4,4,4,7,2,2,6,0,7,1,6
+G,3,4,4,3,2,6,7,5,5,10,7,10,2,9,4,9
+Z,4,6,5,4,3,6,9,3,8,11,9,6,2,9,6,5
+Z,4,7,5,5,5,7,6,2,7,7,6,9,1,7,10,8
+L,3,10,4,7,1,0,1,5,6,0,0,7,0,8,0,8
+R,2,4,4,2,2,8,8,4,4,9,5,7,2,7,3,10
+D,2,4,3,3,2,9,7,4,5,10,4,5,2,8,2,8
+Z,2,4,4,3,2,8,7,2,9,11,5,9,1,8,5,8
+Q,3,4,4,5,3,8,8,6,2,5,7,10,3,9,5,10
+A,3,5,5,8,2,7,6,3,1,7,0,8,3,7,1,8
+F,2,3,3,4,1,1,11,5,6,11,10,9,0,8,3,7
+L,4,9,5,6,2,7,4,0,9,9,2,10,0,7,2,8
+N,4,6,4,4,2,7,7,14,1,5,6,8,6,8,0,8
+Y,5,8,5,6,2,3,10,2,7,11,11,6,1,11,2,4
+T,2,4,3,2,1,5,11,2,7,11,9,5,1,10,2,5
+O,3,7,3,5,2,8,7,7,5,9,5,8,3,8,3,8
+G,6,10,7,8,3,8,7,8,8,6,6,9,2,7,6,11
+G,6,8,6,6,5,6,7,6,6,9,7,11,2,9,4,9
+E,6,10,9,8,7,7,7,2,8,11,7,9,3,9,4,8
+Z,2,5,4,4,2,7,7,2,9,11,6,8,1,8,5,8
+K,6,9,9,7,5,9,6,2,7,10,3,8,4,7,5,10
+T,3,5,4,4,2,5,13,4,6,12,9,3,1,11,2,4
+C,4,9,5,7,2,6,6,7,10,8,5,13,1,10,4,9
+F,4,7,5,8,6,6,9,4,4,7,7,6,4,9,9,8
+D,6,10,6,6,5,9,6,3,6,10,4,7,5,7,8,7
+N,3,9,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+Q,3,6,4,4,2,9,7,7,6,6,6,10,3,8,5,9
+E,7,10,9,7,6,6,8,4,9,12,9,9,3,8,5,6
+H,3,5,6,4,3,7,7,2,6,10,5,8,6,8,4,7
+M,3,4,4,3,3,7,6,6,4,6,7,8,7,5,2,7
+F,4,8,6,6,3,5,11,5,5,13,8,5,2,9,2,6
+Z,3,8,4,6,4,6,7,3,7,8,6,9,0,9,9,7
+D,6,11,6,6,4,5,9,5,7,10,7,6,5,8,6,5
+W,10,11,10,8,7,4,10,3,3,9,8,7,8,11,2,6
+E,3,8,4,6,3,6,8,8,10,5,4,10,2,8,6,7
+G,3,8,5,6,3,7,6,7,6,6,5,10,1,8,5,11
+Y,5,5,7,7,8,9,7,6,3,7,7,8,6,10,6,5
+Q,4,7,6,5,5,8,6,7,4,7,7,7,5,7,6,7
+J,2,3,3,5,1,14,1,7,5,14,2,11,0,7,0,8
+F,3,8,5,6,4,6,10,3,6,10,9,5,5,10,3,6
+H,2,1,3,3,3,7,7,5,5,7,6,8,3,8,2,8
+C,6,11,7,8,4,2,8,5,9,10,10,14,1,7,3,7
+F,2,0,2,1,0,3,13,5,2,11,8,5,0,8,2,7
+O,4,8,5,6,4,8,7,7,4,7,6,6,4,8,3,8
+Z,2,7,3,5,2,6,8,5,9,7,7,10,2,9,8,7
+B,5,9,8,6,5,9,8,4,7,9,4,5,3,7,7,10
+P,4,7,6,10,9,7,12,4,0,9,7,6,5,10,6,8
+A,2,8,4,5,1,8,6,3,1,7,0,8,2,7,1,8
+Z,4,8,5,6,2,7,7,4,14,9,6,8,0,8,8,8
+Y,4,7,6,11,9,8,9,3,2,6,8,9,6,13,10,6
+O,3,4,4,3,2,7,7,7,5,9,6,8,2,8,3,8
+T,2,8,4,6,2,8,11,2,9,6,11,7,1,11,1,7
+Y,4,5,5,4,2,4,11,2,7,11,10,5,1,11,3,4
+F,9,13,8,7,5,9,7,3,5,11,4,5,4,9,7,9
+S,5,7,6,5,3,9,6,4,8,11,4,8,2,8,5,11
+J,3,6,5,4,2,10,6,1,7,14,3,7,0,8,0,8
+K,2,3,4,1,2,4,8,2,6,10,9,10,2,8,2,7
+H,1,0,1,0,0,7,7,10,2,7,6,8,2,8,0,8
+K,3,7,4,5,2,3,6,7,3,7,7,12,3,8,3,11
+W,3,2,4,3,3,5,11,2,2,8,9,9,6,11,0,8
+W,3,1,5,2,3,8,11,3,2,6,9,8,7,11,0,7
+I,7,13,6,8,4,8,9,3,6,14,5,5,2,7,6,8
+R,8,15,8,8,7,5,8,2,5,7,3,9,6,6,6,5
+I,1,5,2,4,1,7,8,0,7,13,6,7,0,8,1,7
+Q,3,5,4,5,3,8,6,7,6,7,3,9,2,8,3,8
+Q,3,7,4,6,2,8,7,8,6,6,5,9,3,8,4,8
+V,5,11,8,8,2,8,8,5,3,6,14,8,3,9,0,8
+Y,3,8,5,6,1,9,10,3,2,5,13,8,1,11,0,8
+F,3,5,5,4,2,7,9,1,6,13,5,5,1,10,2,8
+V,4,8,6,6,3,6,12,2,4,6,11,9,2,10,1,8
+W,5,8,7,6,7,8,7,6,2,6,8,8,7,8,5,4
+L,3,8,5,6,3,8,4,1,8,9,3,10,0,7,2,9
+W,8,8,8,6,5,3,11,2,3,10,10,8,7,10,2,6
+A,3,10,5,7,2,8,6,3,1,7,0,8,3,7,1,8
+T,7,10,6,5,2,4,12,3,6,13,8,4,2,9,3,4
+U,3,4,4,3,2,6,8,6,7,7,10,9,3,9,0,8
+H,6,11,8,8,7,7,7,7,7,7,6,8,3,8,4,7
+J,5,8,7,9,7,8,9,4,5,7,7,8,5,7,10,10
+F,2,4,2,3,1,6,10,4,5,10,9,5,1,9,3,7
+W,6,7,6,5,4,3,10,3,3,10,10,8,7,10,2,7
+U,4,9,4,7,2,8,5,14,5,6,14,8,3,9,0,8
+P,5,9,5,6,2,4,15,8,1,12,6,2,0,9,4,8
+L,4,7,5,5,3,6,4,5,9,2,2,4,1,6,2,5
+S,5,10,4,5,2,9,3,1,5,8,1,7,2,7,4,10
+M,5,5,7,4,7,9,8,4,4,7,6,7,8,6,6,5
+G,4,9,5,6,3,6,7,7,6,10,7,11,2,9,4,9
+O,3,7,5,5,2,7,7,8,8,7,6,7,3,8,4,8
+S,5,11,6,8,5,9,6,4,6,10,3,7,2,8,5,10
+V,2,3,3,2,1,4,12,3,3,10,11,7,2,11,0,8
+Q,5,5,7,8,10,7,5,6,2,6,6,8,11,10,9,13
+Q,2,2,3,3,2,8,7,7,3,6,6,10,2,9,3,9
+K,3,5,5,4,3,6,6,1,7,10,8,11,3,7,3,8
+M,3,6,3,4,3,8,6,9,0,6,8,8,6,5,0,8
+P,4,9,6,7,4,7,10,4,5,12,5,3,1,10,4,8
+U,2,3,2,1,1,7,9,5,5,6,9,9,3,10,1,8
+E,8,12,5,6,3,7,6,5,7,10,6,9,2,10,8,9
+F,2,7,2,5,2,1,11,3,4,11,11,8,0,8,1,7
+X,4,9,6,7,5,8,7,3,5,6,6,7,3,9,9,9
+U,5,5,5,7,2,7,5,14,5,7,15,8,3,9,0,8
+K,3,5,6,4,3,7,7,2,7,10,5,9,6,8,5,8
+L,3,9,5,7,3,7,5,1,7,8,2,10,0,6,2,8
+Q,5,9,6,11,6,9,7,8,3,5,6,11,5,8,8,8
+I,1,2,1,3,1,7,7,1,7,7,6,9,0,8,3,8
+W,6,9,8,7,8,8,6,6,2,6,7,8,6,8,5,6
+M,7,8,10,6,6,4,7,4,5,11,11,11,9,6,4,7
+Y,3,5,4,4,2,4,10,2,7,11,10,6,1,11,2,5
+K,5,9,5,5,3,3,9,4,5,10,10,11,4,9,3,6
+H,5,11,7,8,10,8,6,4,4,6,6,7,8,6,8,6
+N,1,3,2,2,1,7,8,5,4,7,6,6,4,9,1,5
+Y,1,0,2,0,0,7,9,2,1,6,12,8,1,10,0,8
+B,3,2,4,3,3,8,7,5,6,7,6,6,2,8,6,10
+C,3,10,4,8,3,5,7,6,7,7,6,13,1,8,4,10
+N,3,6,4,4,3,7,7,6,6,7,6,8,3,7,3,8
+D,4,7,5,5,3,9,7,4,7,11,5,5,3,8,3,8
+E,2,7,3,5,2,3,8,6,11,7,5,15,0,8,6,8
+V,1,0,2,0,0,7,9,3,2,7,12,8,2,10,0,8
+T,2,8,4,5,1,9,15,1,6,5,11,9,0,8,0,8
+Q,6,8,6,9,7,8,7,7,2,8,7,10,3,8,6,7
+U,6,7,7,5,4,4,8,5,7,9,8,9,3,9,3,5
+B,3,6,5,4,6,9,7,4,3,6,7,7,7,9,7,7
+Y,1,1,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+E,3,5,5,3,3,6,9,2,9,11,8,8,2,8,4,6
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+K,4,7,5,5,4,5,7,6,7,6,6,13,3,8,5,10
+O,4,7,4,5,3,7,7,8,5,10,6,8,3,8,3,7
+T,2,1,3,2,1,7,12,3,6,7,11,8,2,11,1,8
+M,3,6,4,4,4,8,6,6,4,7,7,8,7,5,2,7
+A,4,9,6,6,4,10,2,1,2,8,3,9,5,5,3,7
+H,3,6,3,4,1,7,8,14,1,7,5,8,3,8,0,8
+F,3,5,5,3,2,6,10,3,6,13,7,5,1,10,2,7
+W,8,11,8,8,6,4,10,2,3,10,9,8,8,11,2,6
+D,3,7,3,5,2,5,7,10,8,7,6,5,3,8,4,8
+X,4,8,5,5,1,7,7,4,4,7,6,8,3,8,4,8
+J,3,9,5,7,6,9,8,3,3,8,4,6,4,8,6,4
+K,7,11,7,6,4,7,7,3,6,10,6,9,6,10,3,8
+U,10,13,9,7,4,6,4,5,5,4,8,7,6,7,2,7
+H,5,9,8,7,5,7,7,6,7,7,6,5,6,8,4,7
+B,4,8,4,6,4,6,9,9,7,7,5,7,2,8,9,10
+R,4,11,6,8,8,7,7,3,4,7,6,8,7,10,8,6
+E,1,1,1,1,1,4,7,5,8,7,6,13,0,8,6,9
+P,5,8,7,6,6,8,9,6,4,10,4,4,3,11,4,9
+W,10,11,10,8,7,5,11,3,3,9,8,7,8,11,3,5
+N,4,5,5,8,3,7,7,14,2,4,6,8,6,8,0,8
+T,6,10,6,5,3,7,9,2,7,12,6,6,2,9,4,6
+B,4,8,6,6,5,9,7,4,6,10,5,6,2,8,6,10
+O,5,8,6,6,4,7,8,7,5,10,7,8,3,8,3,8
+A,3,8,5,6,3,12,3,2,2,10,2,9,2,6,2,8
+Y,5,9,7,6,6,9,5,7,5,6,9,7,3,9,9,4
+L,3,7,4,5,3,5,5,2,8,3,2,7,0,7,1,5
+H,3,4,5,3,3,7,7,3,6,10,6,8,3,8,3,8
+Q,2,2,2,4,2,8,7,7,3,6,6,9,2,8,5,10
+D,4,6,5,4,4,9,6,4,6,9,4,6,3,8,3,8
+L,4,10,5,8,3,5,3,6,8,1,2,4,1,6,1,5
+R,6,11,9,8,8,9,8,4,6,9,3,7,3,6,4,11
+P,2,3,3,1,1,8,9,3,3,12,4,4,1,9,2,9
+L,3,8,4,6,3,7,3,4,6,6,2,7,1,6,2,7
+P,5,11,7,8,6,6,10,6,5,10,8,3,1,10,4,7
+M,4,10,6,7,6,8,6,5,5,7,7,8,11,5,2,8
+Q,5,9,5,11,6,8,7,7,3,8,8,10,3,8,6,8
+L,4,9,6,6,3,5,4,3,9,6,1,7,1,6,3,6
+F,3,5,5,3,2,6,11,3,5,13,7,4,1,10,1,7
+Z,4,10,4,7,5,6,8,5,9,8,7,10,1,9,7,8
+V,6,8,8,6,5,6,11,3,2,8,11,8,4,9,5,9
+K,4,5,5,4,3,6,7,4,7,6,6,10,3,8,5,9
+U,3,6,3,4,1,8,5,13,5,6,13,8,3,9,0,8
+J,2,8,3,6,1,13,2,8,4,14,4,12,1,6,0,8
+V,4,6,4,4,2,3,11,2,3,9,10,8,2,11,0,8
+N,2,2,3,3,2,7,8,5,4,7,7,7,4,9,1,6
+J,5,12,4,9,4,7,10,3,2,13,5,5,2,8,7,10
+Q,5,10,6,9,6,8,8,7,5,5,8,9,3,8,5,8
+D,3,9,4,6,4,7,7,6,7,6,5,6,3,8,3,7
+P,3,4,5,3,2,7,9,4,4,12,4,3,1,10,3,8
+N,3,5,4,7,3,7,7,14,2,5,6,8,6,8,0,8
+G,5,10,6,8,6,7,6,7,8,6,4,10,2,9,6,11
+C,2,1,2,1,0,6,7,6,9,7,6,14,0,8,4,10
+V,1,0,2,1,0,8,9,3,2,7,12,8,2,10,0,8
+F,3,7,5,5,3,6,10,5,6,10,10,5,2,9,3,5
+U,7,9,7,7,4,2,8,5,7,11,11,10,3,9,2,6
+H,7,11,10,8,7,7,8,3,7,10,6,7,3,8,3,8
+A,5,10,9,8,7,11,5,1,5,9,1,5,3,7,5,9
+I,1,4,2,3,1,7,7,0,6,13,6,8,0,8,0,8
+Z,2,5,4,3,2,7,8,2,9,11,7,7,1,8,5,7
+G,4,8,5,6,2,7,6,7,8,6,6,9,1,8,6,11
+U,4,5,5,8,2,7,5,14,5,7,14,8,3,9,0,8
+X,3,4,5,2,2,7,8,1,8,10,7,8,2,8,3,7
+V,5,9,5,4,3,10,7,4,5,7,9,5,4,11,2,7
+L,7,12,7,6,4,6,6,4,6,12,9,11,3,8,7,8
+H,7,11,9,8,8,7,6,5,5,6,5,7,9,6,7,10
+D,5,9,7,7,6,10,6,3,7,10,3,6,5,7,4,9
+H,6,10,7,5,4,7,8,3,5,10,7,8,6,9,5,7
+E,4,9,3,4,2,10,5,3,4,11,4,9,2,8,6,12
+Y,2,3,3,2,1,4,10,2,7,10,10,6,1,11,2,4
+J,4,8,5,6,2,8,5,4,6,15,6,11,1,6,0,7
+R,6,9,8,6,7,8,6,6,4,8,5,7,4,7,7,11
+M,7,12,8,6,5,7,3,3,2,8,4,10,8,2,2,8
+S,3,7,4,5,2,9,7,4,8,11,4,8,2,8,5,9
+J,4,6,5,4,2,8,6,4,6,15,7,12,1,6,1,7
+Z,2,6,4,4,3,7,7,2,7,7,6,8,0,8,8,8
+E,4,11,4,8,4,2,8,5,9,7,6,14,0,8,6,8
+G,5,11,6,8,4,6,7,7,7,11,7,11,2,10,4,9
+V,3,9,5,7,1,7,8,4,2,7,14,8,3,9,0,8
+U,4,5,5,4,3,6,9,5,7,7,10,9,3,9,1,8
+J,3,9,4,7,1,13,2,9,4,14,5,13,1,6,0,8
+S,2,6,4,4,4,6,9,3,2,7,7,6,2,8,8,1
+H,3,2,4,3,3,7,8,6,6,7,6,8,3,8,3,7
+D,3,8,3,6,2,6,7,11,8,6,6,6,3,8,3,8
+D,6,10,5,5,4,8,7,4,7,10,5,7,5,9,6,6
+I,3,6,4,4,2,7,7,0,7,13,6,8,0,8,1,7
+X,5,7,8,5,4,7,7,1,8,10,6,8,2,8,3,8
+U,4,7,4,5,2,7,4,14,5,7,13,8,3,9,0,8
+H,5,9,5,6,2,7,7,15,0,7,6,8,3,8,0,8
+X,4,6,5,5,5,9,7,2,5,8,6,6,2,8,7,7
+E,3,8,5,6,3,5,8,4,8,11,9,9,2,8,5,6
+O,4,7,6,5,4,8,9,8,4,7,7,7,3,8,3,8
+U,4,4,5,3,2,4,9,5,7,11,10,9,3,9,2,7
+S,2,7,3,5,3,7,8,7,6,7,5,6,2,8,8,8
+Y,7,10,7,8,3,4,10,3,8,11,11,5,1,11,3,4
+J,3,7,4,5,2,9,6,4,7,15,5,10,0,7,1,7
+X,2,7,3,5,3,7,7,3,7,6,7,10,2,8,6,8
+M,4,4,7,3,4,7,7,3,4,9,8,9,9,7,2,9
+Q,2,0,2,1,1,9,7,6,4,6,6,9,2,8,3,8
+U,10,15,9,8,6,7,6,5,5,6,7,8,5,5,3,7
+C,9,13,6,7,3,8,7,7,7,11,5,8,2,9,5,9
+Z,7,10,9,8,5,7,8,2,10,12,6,8,1,9,6,8
+C,3,6,4,4,1,5,8,6,10,6,7,12,1,7,4,8
+T,2,7,3,4,1,5,14,1,6,9,11,7,0,8,0,8
+Q,3,6,4,5,2,8,6,8,7,6,5,8,3,8,4,8
+K,6,9,8,6,8,8,8,5,5,7,6,6,8,7,8,13
+W,6,6,6,4,4,3,11,2,3,10,10,8,7,11,2,6
+M,3,4,4,3,3,8,6,6,4,6,7,8,7,6,2,7
+F,5,11,7,8,6,9,8,1,6,13,5,5,3,8,3,9
+H,4,10,4,7,2,7,6,15,1,7,8,8,3,8,0,8
+V,6,11,4,6,2,7,10,6,3,8,10,5,5,12,3,8
+V,2,0,3,1,0,7,9,4,2,7,13,8,2,10,0,8
+X,4,8,6,6,3,5,8,2,8,10,11,9,3,8,4,6
+Q,6,7,8,10,10,8,9,5,2,5,7,9,8,15,8,14
+W,3,6,4,4,4,8,7,6,2,6,7,8,5,9,4,6
+Q,4,6,4,7,4,8,5,6,4,9,5,8,3,8,3,8
+C,4,10,5,8,3,5,8,8,8,9,8,13,2,9,4,10
+I,3,8,4,6,2,7,8,0,8,14,6,7,0,8,1,7
+Z,6,11,8,9,5,7,8,3,11,12,7,8,2,9,7,8
+N,1,1,2,2,1,7,7,11,1,5,6,8,4,8,0,8
+I,1,1,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+M,4,4,4,6,3,8,7,12,1,6,9,8,8,6,0,8
+R,1,0,2,1,1,6,10,7,2,7,5,8,2,7,4,10
+W,7,8,7,6,5,6,11,5,3,8,6,6,10,13,3,4
+M,5,9,6,6,6,7,6,6,5,7,7,10,8,5,2,8
+R,8,15,6,8,5,7,5,6,5,8,6,9,6,6,8,10
+D,4,8,4,6,2,5,7,11,8,7,6,5,3,8,4,8
+Y,4,6,6,4,3,4,11,2,7,11,10,5,1,11,3,5
+C,3,7,4,5,2,3,9,5,8,11,11,11,1,8,3,7
+S,7,11,10,8,12,8,9,5,4,8,5,7,7,8,13,9
+P,4,6,4,8,2,3,13,8,2,11,7,3,1,10,4,8
+O,3,5,4,4,3,8,7,7,5,9,6,8,2,8,3,8
+F,5,11,7,8,4,7,10,2,7,14,5,4,1,10,2,8
+E,3,7,5,5,3,4,9,3,7,11,9,9,2,9,4,6
+T,4,5,5,5,5,7,9,4,7,7,8,8,3,10,6,7
+Q,6,8,6,9,7,8,8,6,2,7,8,11,3,8,6,8
+C,5,7,6,6,5,4,8,3,6,7,6,10,3,9,7,8
+W,4,4,5,3,3,3,11,3,2,10,10,8,6,11,1,7
+O,2,3,3,2,2,8,7,7,4,9,6,9,2,8,3,8
+H,5,9,6,6,6,7,7,5,5,7,5,8,6,6,6,11
+P,12,14,10,8,4,8,9,6,5,14,3,4,5,10,5,8
+Y,6,9,6,7,4,5,9,1,7,9,9,6,3,10,5,4
+L,4,9,6,7,4,7,4,1,8,8,2,10,0,7,3,8
+X,2,3,3,2,1,7,7,3,9,6,6,8,2,8,5,7
+G,5,6,7,5,7,7,8,6,3,7,7,8,6,11,7,8
+O,6,9,8,6,9,8,9,5,2,7,7,8,9,9,6,12
+H,8,14,8,8,6,10,7,5,5,11,1,6,7,4,5,7
+V,9,15,8,9,4,9,10,6,4,6,10,6,6,13,3,6
+K,2,3,3,2,2,5,7,4,7,7,6,10,3,8,4,10
+U,3,5,4,4,2,6,8,5,6,6,8,9,6,10,0,7
+I,2,7,3,5,1,7,6,0,8,14,7,10,0,8,1,8
+Y,5,6,5,4,2,3,10,2,7,11,11,6,1,11,2,4
+R,3,6,4,4,4,8,7,7,3,8,5,7,4,7,7,8
+R,4,9,4,7,3,6,8,9,5,6,6,7,3,8,6,11
+O,8,12,6,6,3,7,8,6,5,9,5,7,4,9,5,9
+S,6,11,7,8,7,9,8,5,8,5,5,6,1,6,10,6
+L,6,12,6,7,3,7,4,3,6,11,4,13,3,6,6,8
+N,3,5,4,3,3,7,8,5,5,7,7,6,5,9,2,6
+E,7,11,10,8,6,8,7,2,9,11,6,9,5,7,6,8
+H,2,4,3,2,2,6,7,5,6,7,6,8,3,8,3,8
+A,2,7,4,5,2,11,2,3,3,10,2,9,2,6,2,8
+P,10,13,9,8,6,9,8,4,5,13,4,4,5,10,6,7
+M,6,9,7,4,3,8,10,4,5,5,5,8,8,8,2,7
+F,3,7,4,5,1,1,12,5,5,12,11,8,0,8,2,6
+O,3,6,4,4,3,7,8,6,4,9,7,8,3,8,3,8
+Y,3,5,5,7,1,9,10,2,2,5,12,8,1,11,0,8
+S,2,2,2,3,2,8,8,7,5,8,5,7,2,8,8,8
+V,4,5,5,4,2,4,12,2,3,9,11,7,3,10,1,7
+R,4,8,6,6,7,9,9,3,5,5,7,8,7,10,7,7
+N,6,11,8,6,3,8,7,2,4,13,6,8,6,8,0,8
+Q,3,4,4,4,3,7,8,5,3,8,8,9,3,8,5,8
+R,4,9,4,4,3,9,7,3,5,9,3,8,5,7,5,8
+Y,6,8,8,11,11,7,10,4,2,7,8,9,6,13,9,8
+K,5,9,7,6,5,4,7,2,7,10,10,12,3,8,3,6
+U,3,2,4,3,2,6,8,5,7,7,10,9,3,9,1,8
+F,6,10,7,8,7,6,10,6,5,9,6,8,2,10,8,10
+A,2,3,3,2,1,10,2,2,1,9,2,9,1,6,2,8
+Q,5,6,6,8,3,9,9,8,7,5,8,10,3,8,5,10
+N,2,1,3,3,2,7,8,5,4,8,7,8,4,8,1,7
+U,4,8,6,6,5,8,8,8,5,6,7,9,3,8,4,6
+M,2,3,4,2,3,7,6,3,3,9,7,8,6,5,1,8
+U,3,7,5,6,5,8,7,3,3,6,6,8,4,8,2,8
+T,2,10,4,7,1,7,14,0,6,7,11,8,0,8,0,8
+A,4,9,4,4,2,10,2,4,2,11,5,12,4,4,5,10
+R,9,13,7,8,5,8,7,5,5,9,4,9,7,5,7,11
+K,3,4,4,7,2,3,7,7,3,7,7,11,3,8,3,10
+Q,7,8,7,10,8,8,9,5,2,7,9,11,3,8,6,8
+Y,2,5,4,4,2,8,11,1,7,6,11,8,1,11,2,9
+X,3,1,4,2,2,8,7,4,9,6,6,8,3,8,6,8
+Y,5,9,5,7,3,4,9,1,7,9,10,6,1,10,3,4
+Q,5,11,5,6,4,7,7,4,8,11,5,8,3,7,9,10
+D,5,9,6,7,6,8,8,7,6,8,7,3,5,8,4,9
+T,6,7,6,5,4,6,12,5,6,10,9,4,3,13,3,4
+V,4,10,6,8,3,5,11,3,5,10,12,9,3,10,1,8
+T,2,8,4,5,1,8,15,1,6,6,11,8,0,8,0,8
+G,2,6,3,4,2,8,8,6,5,6,7,9,2,7,5,11
+A,6,10,6,5,3,12,3,6,2,12,2,10,4,3,3,10
+W,2,3,3,1,2,10,11,3,2,5,9,7,5,10,0,8
+I,1,4,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+U,4,6,6,4,4,7,8,8,6,6,6,10,3,8,5,6
+E,4,8,6,6,5,7,7,2,7,11,7,9,3,8,5,8
+T,5,9,7,7,8,7,8,4,6,7,6,9,6,8,6,6
+I,1,7,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+Y,7,11,8,8,4,5,9,1,9,10,10,5,3,10,5,3
+A,5,10,7,8,4,10,3,2,3,8,1,7,2,7,3,8
+Z,5,11,7,9,4,8,7,2,10,11,5,9,2,8,6,8
+Z,5,5,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+Z,5,8,7,10,6,11,4,3,5,9,2,7,2,7,6,9
+T,3,3,3,2,1,5,12,2,7,11,9,5,1,10,1,5
+Y,2,1,2,1,0,7,10,3,1,7,12,8,1,11,0,8
+N,3,5,5,4,2,7,8,2,4,10,6,6,5,9,0,7
+Q,4,3,5,5,4,8,7,7,3,5,6,9,3,8,5,8
+U,4,9,5,7,3,8,8,7,7,6,10,8,3,9,1,8
+H,3,7,3,4,2,7,8,14,1,7,5,8,3,8,0,8
+E,4,9,6,8,7,6,8,4,3,8,7,9,5,11,8,11
+S,4,8,5,6,3,9,6,5,9,11,3,8,2,7,5,10
+P,4,6,6,4,3,7,10,5,3,11,4,3,1,10,3,9
+M,5,6,7,6,8,7,7,4,4,7,6,8,10,7,5,5
+O,7,10,7,8,5,7,7,8,6,9,7,10,4,7,5,5
+K,3,2,4,4,2,6,7,4,8,6,6,11,3,8,6,9
+Z,5,11,7,8,4,7,7,2,10,12,5,9,1,9,7,8
+T,5,7,5,5,3,5,12,2,7,12,9,4,1,11,2,4
+C,4,9,5,6,3,5,8,7,7,8,8,14,2,9,4,10
+D,6,11,7,8,4,5,7,10,10,7,6,5,3,8,4,8
+I,4,8,6,9,6,8,9,4,5,7,7,8,3,7,8,7
+A,3,2,5,3,2,6,2,2,1,5,2,8,2,7,3,5
+Z,4,10,6,7,4,9,5,3,10,11,4,9,1,7,6,9
+I,3,8,5,6,3,8,6,2,7,7,6,7,0,9,4,7
+M,4,2,5,3,4,8,6,6,4,7,7,8,7,5,2,8
+M,5,10,8,7,11,9,6,2,2,8,4,8,10,5,3,6
+Z,1,0,1,0,0,8,7,2,9,8,6,8,0,8,5,8
+Y,3,5,5,4,2,8,11,1,7,5,11,9,1,11,2,9
+I,1,6,0,4,1,7,7,5,3,7,6,8,0,8,0,8
+Y,3,10,6,7,4,7,10,0,7,6,11,8,1,10,1,8
+Y,7,11,7,8,4,6,8,2,8,8,10,5,5,11,6,3
+N,2,6,2,4,2,7,7,11,1,6,6,8,4,8,0,8
+L,1,0,1,1,0,2,1,5,5,0,2,5,0,8,0,8
+Y,6,7,6,5,3,3,10,2,7,10,11,6,1,11,2,5
+D,4,9,6,6,5,7,8,7,5,8,7,6,3,8,3,7
+K,7,9,10,7,7,7,7,1,6,10,5,9,3,8,4,9
+Y,7,8,9,10,11,9,8,6,3,7,7,8,6,10,7,4
+Q,4,7,6,5,5,8,4,7,4,6,7,10,4,7,6,9
+I,3,4,4,5,3,9,9,5,4,6,6,10,3,7,7,5
+J,4,5,6,6,5,8,8,4,6,6,7,7,3,10,8,10
+R,4,11,6,8,6,8,8,4,6,9,4,8,3,6,5,11
+I,3,7,4,5,2,6,8,0,7,13,7,8,0,8,1,7
+K,2,1,3,2,2,6,7,4,7,7,6,11,3,8,4,9
+Y,4,10,7,8,4,4,9,1,8,10,12,10,1,11,2,7
+T,3,3,4,2,2,8,12,3,6,6,11,8,2,11,1,7
+W,6,9,8,7,9,7,9,6,4,7,9,8,7,7,5,10
+C,4,7,5,5,2,6,8,7,11,6,6,13,1,7,4,8
+X,4,7,5,5,3,7,7,4,9,6,6,10,3,8,6,8
+X,4,7,6,5,4,9,8,3,6,7,7,7,6,11,7,7
+S,4,9,5,6,4,8,7,5,7,5,6,8,0,8,8,8
+F,4,4,4,6,2,1,15,5,3,12,9,4,0,8,2,6
+B,2,1,2,1,2,7,7,7,5,6,6,7,1,8,7,8
+V,1,1,2,2,1,6,12,3,2,9,11,8,2,11,1,8
+V,3,10,5,7,2,9,8,4,3,6,14,8,3,10,0,8
+P,6,10,9,8,5,7,10,2,7,14,6,4,0,10,2,9
+A,4,9,6,6,2,7,7,3,0,7,0,8,3,7,1,8
+X,4,9,6,6,4,8,7,0,7,9,5,7,2,8,3,8
+G,4,7,4,5,3,6,6,6,5,10,7,13,2,9,4,10
+A,3,5,5,3,2,6,2,2,2,5,2,8,2,6,3,6
+T,2,2,3,3,2,6,12,3,6,8,11,8,2,11,1,7
+A,3,10,5,8,4,6,3,1,2,5,2,8,2,5,3,6
+M,6,6,8,4,5,10,6,2,5,9,4,7,8,6,2,8
+Q,3,4,4,5,3,7,8,5,3,7,9,10,3,8,5,8
+R,3,3,4,4,2,5,11,7,3,7,4,8,3,7,6,11
+X,3,1,4,2,2,8,7,3,9,6,6,9,2,8,6,8
+O,4,9,5,7,5,7,7,8,4,7,6,8,3,8,3,8
+J,3,8,5,6,4,9,8,3,3,8,4,6,4,9,6,4
+T,2,3,2,2,1,9,11,3,5,6,10,8,2,11,1,8
+F,2,7,3,5,2,1,12,3,4,11,10,8,0,8,2,7
+Y,4,10,7,7,1,7,10,2,2,7,13,8,2,11,0,8
+W,6,8,6,6,4,3,10,3,3,11,10,8,7,10,2,7
+D,3,2,4,4,3,7,7,7,6,6,6,5,2,8,3,7
+Q,5,11,7,8,7,8,4,8,5,6,6,6,5,7,7,10
+Z,6,7,5,11,4,7,7,5,3,11,7,7,3,9,11,6
+I,2,2,1,4,1,7,7,1,7,7,6,8,0,8,3,8
+S,1,0,2,1,0,8,7,4,6,5,6,7,0,8,7,8
+K,3,6,5,5,5,6,8,3,3,7,4,9,4,6,6,9
+L,2,4,3,3,1,7,4,1,8,8,2,10,0,7,2,8
+A,2,2,4,3,1,7,3,2,2,6,1,8,2,6,2,7
+H,5,6,6,8,3,7,8,15,0,7,5,8,3,8,0,8
+V,2,4,4,2,1,9,12,2,3,5,11,9,2,11,1,8
+O,3,3,4,4,2,7,8,8,6,7,7,8,3,8,4,8
+P,4,9,4,7,4,4,12,7,1,11,7,4,1,10,3,8
+O,3,3,4,4,2,8,7,8,8,7,6,8,3,8,4,8
+G,5,5,6,7,3,7,4,7,9,5,5,9,1,9,7,11
+W,5,7,5,5,4,4,11,2,2,9,8,7,6,11,2,6
+C,5,9,6,7,2,6,8,7,11,6,7,13,1,7,4,8
+X,3,8,4,5,1,8,7,4,4,7,6,8,3,8,4,8
+G,2,6,3,4,2,7,6,6,6,6,5,10,1,8,5,11
+S,5,9,5,5,2,5,9,4,4,13,9,7,2,9,3,7
+V,4,7,4,5,3,4,12,2,2,9,11,8,3,11,1,7
+R,3,5,5,4,3,9,7,4,5,10,3,7,5,6,4,9
+A,4,9,7,7,5,11,3,1,2,8,3,9,6,5,3,8
+U,3,3,4,1,1,5,8,4,6,10,9,9,3,10,1,6
+S,5,7,6,5,3,8,7,3,8,11,6,8,2,10,5,8
+T,2,7,3,5,2,9,12,0,5,6,10,8,0,8,0,8
+B,3,5,5,4,3,8,8,3,5,10,5,6,3,7,5,9
+D,3,8,5,6,4,7,7,7,7,7,7,5,3,8,3,7
+U,5,8,6,6,4,4,8,5,7,9,7,9,4,8,4,4
+D,5,11,7,8,8,7,7,6,6,6,6,5,6,8,3,7
+B,4,9,4,4,4,8,7,3,4,9,6,8,5,7,6,8
+X,3,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+F,6,8,7,9,8,6,9,4,4,7,7,6,5,9,9,8
+Z,4,8,5,6,5,8,8,3,8,7,7,7,0,8,11,8
+B,9,11,6,6,4,8,6,5,6,11,4,9,6,7,6,10
+E,4,11,6,8,5,8,7,2,8,11,6,8,2,8,5,9
+V,2,3,3,2,1,4,12,3,2,9,11,7,2,11,0,7
+Y,1,1,3,2,1,8,11,1,5,5,11,9,1,11,1,8
+Y,5,8,5,6,3,3,10,1,7,11,11,6,1,10,3,4
+C,3,6,5,4,4,7,7,4,3,7,7,10,5,10,3,8
+B,3,1,3,2,3,7,7,5,5,7,6,6,2,8,6,10
+J,3,10,4,7,1,14,1,7,5,14,1,10,0,7,0,8
+X,3,5,4,4,2,7,7,3,9,6,6,8,2,8,6,8
+D,6,10,8,8,8,7,7,5,7,7,6,5,6,8,3,7
+W,6,9,6,7,5,4,10,3,3,9,8,7,7,11,2,5
+K,2,3,4,2,2,6,7,1,6,10,7,10,3,8,2,8
+R,5,5,6,7,3,6,11,9,4,7,3,8,3,7,6,11
+U,3,8,5,6,2,5,8,7,8,10,10,9,3,9,1,8
+Z,2,4,2,3,2,8,7,5,9,6,6,7,1,8,7,8
+N,2,1,2,2,1,7,8,5,4,7,6,6,5,9,1,5
+J,6,7,7,8,6,9,9,5,5,6,6,10,3,7,8,5
+K,2,3,3,1,1,5,7,1,6,10,8,10,3,8,2,6
+T,3,11,4,8,1,6,14,0,6,8,11,8,0,8,0,8
+F,3,3,3,4,1,1,12,4,4,12,10,7,0,8,2,6
+D,4,9,6,7,6,9,7,6,6,9,4,6,3,8,3,9
+G,3,7,4,5,2,8,8,8,7,5,7,9,2,7,5,10
+J,4,10,5,7,2,8,7,2,7,15,5,8,0,7,1,7
+B,1,3,3,2,2,8,7,2,5,10,5,7,2,8,3,9
+P,2,3,4,2,1,7,11,4,3,11,4,2,0,9,3,8
+W,6,10,9,8,7,5,8,4,1,7,9,8,7,11,0,8
+N,6,10,5,5,3,5,9,4,5,3,3,12,6,11,2,7
+U,2,3,3,1,1,5,8,5,6,10,9,9,3,10,1,6
+C,3,6,4,4,2,6,8,7,7,9,8,12,2,10,4,10
+S,5,8,6,6,3,5,9,3,9,11,6,7,2,7,5,6
+H,3,3,4,4,2,7,7,14,1,7,7,8,3,8,0,8
+A,6,10,9,8,9,8,7,7,4,7,6,9,6,8,7,4
+K,4,5,7,4,4,3,8,2,7,10,10,11,3,8,3,6
+Z,4,10,5,8,2,7,7,4,14,10,6,8,0,8,8,8
+T,6,9,7,7,8,5,8,4,7,7,6,10,5,7,5,7
+P,3,6,4,4,2,4,13,8,1,10,6,3,1,10,4,8
+O,4,8,6,6,4,7,7,8,5,7,5,8,3,8,3,8
+S,8,15,8,8,4,9,5,5,5,13,5,9,2,8,3,7
+X,6,10,9,8,8,8,7,3,7,7,7,8,6,13,8,8
+A,5,11,7,9,5,10,2,2,3,9,1,7,3,7,4,8
+I,1,4,1,3,1,7,7,1,7,7,6,8,0,8,2,8
+D,5,4,5,7,3,5,6,10,9,5,4,5,3,8,4,8
+P,2,1,2,1,1,5,11,7,2,9,6,4,1,9,3,8
+F,4,9,4,6,2,1,13,5,4,12,11,6,0,8,2,6
+E,4,8,6,6,4,9,6,2,7,11,5,9,3,7,6,10
+H,4,3,4,4,2,7,8,14,0,7,6,8,3,8,0,8
+T,4,5,5,4,3,5,12,4,6,11,9,4,2,11,1,5
+M,1,0,2,0,0,7,6,9,0,7,8,8,5,6,0,8
+G,3,6,4,4,2,6,6,5,7,7,5,10,2,10,4,8
+V,2,8,4,6,1,8,8,4,2,7,13,8,3,9,0,8
+D,5,10,5,8,3,5,7,10,9,7,6,5,3,8,4,8
+T,5,11,7,8,7,8,11,3,6,6,11,8,3,12,1,8
+D,5,10,6,8,3,5,7,10,9,7,6,5,3,8,4,8
+H,7,13,7,8,6,7,7,3,4,10,5,8,6,9,5,8
+W,6,7,9,6,10,7,8,5,5,7,5,8,10,10,8,8
+Z,5,10,7,8,4,7,7,3,11,12,7,8,2,8,7,7
+F,4,7,6,5,4,8,8,2,6,13,5,6,2,10,2,8
+B,2,3,4,2,2,8,8,3,5,10,5,6,2,8,5,9
+R,3,7,5,5,4,6,8,5,6,6,5,7,3,7,5,9
+Z,1,0,1,1,0,7,7,2,10,8,6,8,0,8,6,8
+U,6,10,6,5,4,7,5,6,5,6,8,8,5,10,3,9
+N,10,15,9,8,4,7,10,5,5,4,5,11,6,11,3,7
+B,1,3,2,2,1,7,7,4,4,6,6,5,2,8,5,9
+I,0,7,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+A,4,7,6,5,2,8,3,3,3,9,1,8,2,7,3,7
+K,5,7,8,5,4,3,7,2,7,10,11,12,3,8,4,5
+Z,3,7,4,5,3,6,8,5,10,7,7,10,2,9,8,8
+R,5,11,7,8,8,6,7,5,6,6,5,7,3,7,5,8
+R,4,2,5,4,4,7,8,4,6,7,5,7,3,7,4,8
+F,4,6,5,4,3,7,10,4,5,13,7,5,2,9,2,7
+I,4,10,5,8,2,7,9,0,8,14,6,6,0,10,2,7
+A,7,11,9,8,9,7,6,8,4,7,5,8,5,8,11,2
+I,1,3,1,2,0,7,8,0,6,12,6,8,0,8,0,7
+J,2,6,2,4,2,8,7,0,6,10,5,7,0,7,1,7
+K,5,9,5,4,3,9,7,2,6,10,4,7,5,9,3,9
+U,2,1,3,2,1,5,8,6,6,8,10,10,3,9,1,7
+T,1,0,1,0,0,7,13,1,4,7,10,8,0,8,0,8
+Y,1,3,2,2,1,5,10,2,7,10,9,5,1,11,2,4
+W,2,1,2,2,1,7,8,4,0,7,8,8,6,10,0,8
+J,4,7,6,5,4,8,6,5,5,8,7,7,3,7,4,6
+U,4,2,5,4,2,6,8,5,8,6,9,9,3,9,1,7
+N,8,15,10,8,5,5,9,3,4,13,10,9,6,9,0,8
+J,1,3,2,2,1,11,6,2,6,12,3,8,0,7,0,8
+U,1,0,2,1,0,8,6,11,4,7,12,8,3,10,0,8
+W,4,4,6,6,3,4,8,5,1,7,8,8,8,9,0,8
+F,4,7,7,5,6,8,7,1,4,10,7,7,6,9,3,6
+K,5,9,8,6,6,7,7,1,6,10,5,9,3,7,3,8
+U,7,14,6,8,5,8,6,4,5,7,7,8,6,5,4,6
+P,4,11,5,8,6,6,9,6,4,9,8,4,1,10,3,7
+A,3,6,5,4,2,8,2,2,2,7,1,8,2,6,3,7
+J,4,10,6,8,6,9,8,4,4,9,3,7,4,8,7,5
+W,6,6,6,4,5,4,11,2,2,9,8,7,7,12,2,6
+T,5,6,6,5,6,8,9,5,7,7,7,8,3,10,7,7
+M,4,6,7,4,4,6,6,3,4,9,9,9,9,6,3,9
+P,3,9,4,6,2,5,9,10,5,8,6,5,2,9,4,8
+Z,4,9,5,7,5,9,9,6,4,7,5,8,4,9,10,6
+L,3,7,4,5,3,5,5,4,7,3,2,6,4,6,1,6
+M,5,11,7,8,9,7,6,7,4,7,5,8,6,10,7,8
+I,2,8,2,6,2,7,7,0,8,7,6,8,0,8,3,8
+B,3,6,5,4,6,8,7,4,3,6,7,8,6,10,7,7
+M,3,7,5,5,5,10,6,6,4,6,7,5,7,5,1,5
+M,6,8,9,7,10,8,7,4,5,7,6,7,12,8,6,4
+C,2,5,3,3,1,4,8,5,7,11,9,13,1,9,2,7
+G,5,11,7,8,6,6,6,6,7,6,6,9,4,9,4,8
+Z,5,5,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+O,4,7,5,5,2,8,6,8,8,7,5,8,3,8,4,8
+Z,3,4,4,6,2,7,7,4,13,10,6,8,0,8,8,8
+U,5,8,7,6,6,7,8,8,5,5,7,10,4,9,4,5
+M,9,13,11,7,6,13,2,6,2,12,1,9,7,2,1,8
+M,5,5,6,8,4,7,7,12,2,7,9,8,8,6,0,8
+U,5,11,5,8,4,8,5,12,4,7,13,8,3,9,0,8
+U,7,8,8,6,4,4,8,6,8,9,9,10,3,9,3,5
+X,3,3,5,2,2,9,7,2,8,11,4,7,2,8,3,8
+Z,3,6,4,4,1,7,7,3,13,9,6,8,0,8,8,8
+V,2,3,2,1,1,5,12,3,2,9,10,7,2,11,1,8
+U,6,11,9,8,12,8,8,4,4,6,7,8,10,6,8,8
+C,4,7,5,5,2,6,6,6,10,7,6,13,1,9,4,9
+N,5,7,6,5,4,8,8,6,6,6,5,3,8,9,5,7
+H,4,2,5,4,3,9,7,6,6,7,6,8,6,8,3,7
+W,6,8,6,6,4,2,10,3,3,11,11,9,7,10,1,6
+J,6,7,4,10,3,10,6,3,4,11,3,5,3,8,7,10
+Y,8,7,6,11,5,9,7,5,5,4,12,5,4,11,5,7
+R,3,7,4,5,2,5,11,8,4,7,3,9,3,7,6,11
+Q,4,7,6,8,6,8,5,8,4,6,5,9,4,9,6,8
+O,3,6,4,4,2,7,7,7,4,9,6,8,3,8,3,8
+S,7,15,5,8,3,10,2,2,5,10,1,9,3,7,4,9
+V,4,5,6,4,2,4,12,3,3,10,11,7,2,10,1,8
+A,3,8,5,6,3,6,4,3,0,6,2,7,2,7,2,7
+A,4,7,7,5,5,7,6,2,4,6,1,6,3,5,3,7
+F,5,7,6,5,6,7,10,5,4,8,6,8,2,9,7,11
+S,4,10,6,8,7,8,8,5,3,8,5,7,4,9,11,8
+T,4,6,6,4,5,5,8,4,5,6,7,8,5,10,4,8
+I,1,3,2,2,1,7,7,1,6,13,6,8,0,8,0,8
+J,1,1,2,2,1,10,7,2,5,11,4,8,0,7,0,7
+W,6,7,6,5,4,4,11,3,3,9,9,7,7,11,2,6
+N,1,0,2,1,0,7,7,11,0,5,6,8,4,8,0,8
+N,5,10,5,8,3,7,7,15,2,4,6,8,6,8,0,8
+O,5,9,6,7,8,8,9,5,2,7,7,8,8,9,4,8
+V,5,9,4,4,2,7,10,4,4,8,9,6,3,10,2,7
+X,5,8,8,6,4,8,8,1,8,11,4,7,4,9,4,8
+L,3,11,5,8,3,4,4,4,8,2,0,6,0,6,1,5
+L,2,6,3,4,1,0,1,5,6,0,0,6,0,8,0,8
+B,6,11,8,8,8,9,6,4,5,7,6,7,4,8,6,10
+H,3,3,5,2,2,7,8,3,6,10,7,8,3,8,3,8
+O,5,8,6,6,5,6,8,7,4,9,8,8,3,8,3,8
+T,6,8,6,6,3,5,12,2,8,12,9,4,1,11,2,4
+V,3,4,5,3,2,6,12,2,3,7,11,8,2,10,1,8
+F,6,11,9,8,9,7,7,6,4,8,6,8,5,12,10,12
+Q,2,3,3,4,3,9,8,6,1,5,7,10,2,10,5,10
+N,6,5,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+R,7,13,7,7,6,8,7,3,5,9,4,8,6,6,7,6
+N,3,7,3,5,2,7,7,13,2,5,6,8,5,8,0,8
+F,4,7,6,5,6,8,8,1,4,10,6,6,5,10,4,5
+E,4,9,5,7,3,3,7,6,11,7,6,15,0,8,7,7
+T,3,3,4,2,1,5,13,3,7,12,9,3,1,10,1,5
+N,5,6,6,6,6,6,7,5,3,6,5,8,7,9,4,8
+R,6,12,6,6,5,5,9,2,5,7,5,10,4,7,6,7
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+U,4,7,6,6,5,7,7,4,4,6,6,9,4,9,1,8
+P,3,7,3,5,3,5,10,8,3,9,6,5,1,10,3,8
+F,5,7,7,5,3,5,13,5,5,13,7,3,2,10,2,6
+Q,5,5,5,6,5,8,7,6,2,8,6,11,3,9,6,8
+Z,2,3,3,4,1,7,7,3,13,9,6,8,0,8,7,8
+S,5,11,5,6,2,8,7,4,3,13,7,8,3,10,3,8
+N,4,8,4,6,2,7,7,14,2,4,6,8,6,8,0,8
+W,1,0,2,0,1,7,8,3,0,7,8,8,5,10,0,8
+M,9,12,11,6,6,6,3,3,2,7,4,11,10,1,2,8
+Q,2,3,3,4,2,7,8,5,2,7,8,10,2,9,4,8
+D,4,8,5,6,4,7,7,7,7,7,6,4,3,8,3,7
+B,1,3,3,2,2,8,7,3,5,10,5,7,2,8,4,9
+Q,5,11,5,6,3,10,4,4,7,11,3,9,3,7,8,11
+W,7,8,7,6,5,4,11,3,3,9,9,7,7,11,2,6
+Q,2,2,3,3,2,7,9,4,1,8,8,10,2,9,4,8
+N,7,10,10,7,6,4,9,3,4,10,10,9,8,7,2,7
+E,4,9,5,6,4,7,7,3,8,11,7,9,3,8,5,8
+M,5,8,8,6,9,8,6,3,2,8,4,8,12,5,2,7
+Q,3,7,4,6,2,8,7,8,5,6,7,8,3,8,5,9
+J,1,4,2,2,1,9,6,3,5,12,5,9,1,7,1,7
+U,6,6,6,4,4,5,8,5,7,8,6,9,5,9,5,3
+L,8,13,8,7,5,8,4,3,5,11,6,11,3,7,7,8
+H,5,9,7,7,6,6,6,6,4,6,5,8,6,7,6,10
+R,3,2,4,4,3,6,7,5,5,6,5,7,3,7,4,8
+X,6,10,9,8,4,5,9,2,9,10,10,9,3,8,4,6
+B,2,1,3,2,2,7,8,8,5,7,6,7,2,8,8,9
+V,6,10,6,8,3,4,11,2,4,9,11,7,3,9,1,7
+X,3,5,4,5,4,7,6,2,5,7,6,9,2,11,7,8
+R,4,9,6,7,8,8,9,3,5,5,7,8,5,9,8,7
+T,3,9,5,6,4,8,11,2,7,6,11,7,2,12,1,7
+S,3,8,4,6,4,8,7,7,5,7,7,9,2,9,8,8
+O,5,10,7,8,3,8,7,9,8,7,6,9,3,8,4,8
+K,6,9,9,7,5,9,6,2,7,10,3,9,7,7,6,9
+U,4,9,6,8,6,7,7,5,4,6,7,8,6,8,1,7
+L,2,5,4,4,2,7,4,1,8,8,2,10,0,7,2,8
+U,5,9,8,7,10,8,6,4,4,6,7,8,11,9,6,8
+Z,5,6,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+X,5,7,6,6,6,6,7,2,5,7,7,10,3,8,7,8
+I,4,9,3,5,2,6,10,2,5,13,6,4,1,9,4,8
+T,4,6,4,4,2,6,11,2,9,11,9,4,0,10,3,5
+P,5,5,6,7,8,8,6,4,3,6,7,7,6,9,4,5
+M,5,6,8,4,4,5,7,3,5,10,10,10,8,5,2,7
+Y,3,5,5,7,7,8,4,4,3,7,8,8,5,9,5,8
+W,3,1,3,2,1,8,8,4,0,7,8,8,7,10,0,8
+Z,3,2,3,3,2,7,8,5,10,6,6,9,1,8,7,8
+J,6,7,8,9,7,7,8,4,7,6,7,7,3,10,9,9
+D,2,1,2,1,1,7,7,6,6,7,6,5,2,8,2,7
+K,3,7,3,4,1,3,7,7,2,7,5,11,3,8,2,11
+O,5,9,7,8,5,6,6,6,5,8,5,8,4,6,5,6
+X,3,7,5,5,2,10,5,2,8,10,1,7,3,7,3,10
+C,6,11,4,6,2,6,8,7,6,11,7,7,2,9,5,8
+G,5,9,6,7,5,7,7,8,5,5,7,9,3,6,5,9
+B,3,4,5,3,3,8,7,3,5,10,5,7,2,8,4,9
+B,2,3,2,2,2,7,7,5,5,7,6,6,2,8,5,9
+W,5,7,7,5,3,8,8,5,1,7,8,8,8,9,0,8
+I,2,8,3,6,2,8,7,0,7,13,6,9,0,8,1,8
+C,1,0,2,1,0,7,7,6,8,7,6,13,0,8,4,10
+X,6,10,8,8,7,7,7,3,6,6,6,8,6,7,13,10
+X,4,11,6,8,5,7,7,3,8,5,6,8,2,8,6,8
+M,3,3,4,4,2,7,6,11,1,8,9,8,7,6,0,8
+P,3,6,4,9,8,7,6,6,1,7,6,7,4,10,7,11
+M,6,10,8,8,8,6,6,6,5,7,8,11,8,6,2,9
+F,4,8,6,6,4,9,8,1,6,13,5,5,2,9,3,9
+M,6,7,8,5,6,8,6,2,5,9,8,8,8,4,2,7
+S,2,3,4,2,2,8,8,2,7,10,5,7,1,9,4,8
+P,3,5,5,3,2,7,11,4,3,12,5,2,1,10,2,8
+C,3,6,4,4,2,6,7,6,7,6,7,12,1,8,4,10
+Q,3,4,4,5,3,8,7,7,2,5,7,9,2,9,5,10
+O,2,3,3,1,1,8,7,7,5,7,6,8,2,8,3,8
+G,2,1,3,2,1,8,6,6,6,6,5,9,1,7,6,10
+C,2,4,3,6,1,5,7,7,9,8,6,14,1,9,4,9
+A,4,11,8,8,6,9,5,1,4,7,2,6,3,8,6,6
+Z,3,7,5,5,3,8,7,2,9,11,5,7,1,7,6,8
+V,4,5,6,4,6,7,7,5,4,7,6,8,6,9,7,7
+E,4,7,6,6,6,6,8,3,3,8,7,8,5,12,9,9
+T,1,0,2,0,0,7,14,1,4,7,10,8,0,8,0,8
+N,5,8,6,6,5,7,6,9,5,5,4,5,5,7,4,10
+E,5,9,8,6,5,10,6,2,9,11,4,8,2,8,5,11
+A,4,9,6,7,4,8,2,2,3,7,1,8,2,7,3,6
+R,4,6,5,4,3,9,7,4,5,10,3,7,3,7,4,10
+U,2,1,3,1,1,6,9,6,6,7,10,9,3,10,1,8
+E,4,10,4,7,4,3,8,5,9,7,6,14,0,8,6,8
+V,7,10,7,8,4,2,12,2,3,10,11,8,2,10,1,8
+B,5,10,6,8,8,8,8,6,6,7,6,6,6,8,6,10
+Z,4,6,6,4,4,7,8,2,8,12,7,8,1,9,6,7
+K,4,7,6,5,3,6,7,2,7,10,7,10,3,8,3,8
+D,4,9,5,6,5,7,7,6,6,7,6,5,3,8,3,7
+X,3,5,5,4,4,9,8,2,6,8,5,6,2,6,7,7
+P,5,5,7,6,7,7,8,4,3,8,8,6,6,11,5,5
+H,7,9,10,7,8,8,7,2,6,10,6,8,3,8,3,7
+C,4,8,5,6,6,6,7,4,4,6,7,10,6,10,4,8
+D,5,11,7,8,7,9,7,4,5,9,4,6,3,8,3,8
+Q,5,7,6,9,7,9,7,7,2,5,6,10,3,9,6,9
+Y,6,10,6,7,3,4,10,1,8,10,10,5,2,12,4,3
+R,5,9,6,7,5,7,9,4,6,6,4,8,4,5,6,9
+G,3,7,4,5,2,7,8,8,7,6,7,8,2,7,6,11
+R,4,7,5,5,4,7,8,5,7,7,4,6,6,7,5,8
+F,2,4,4,3,2,6,11,2,6,13,6,4,1,10,1,7
+Q,5,9,5,5,3,10,5,4,6,12,3,8,3,8,7,11
+F,4,10,4,7,2,0,13,4,4,12,11,7,0,8,2,6
+Q,7,9,7,11,7,8,6,7,5,9,8,9,5,9,8,9
+T,2,3,3,2,1,5,12,3,6,11,9,4,1,10,2,5
+C,3,8,4,6,2,6,8,7,9,5,7,12,1,7,4,9
+N,4,10,6,7,4,7,9,6,5,7,6,7,6,8,2,6
+J,1,2,2,3,1,10,6,2,6,12,4,8,0,7,1,7
+O,2,1,3,2,1,7,7,7,6,7,6,8,2,8,3,8
+Z,2,5,3,4,3,8,7,5,9,6,6,7,2,8,7,8
+M,3,7,4,5,4,8,5,11,1,6,8,8,6,5,0,7
+V,1,0,2,0,0,8,9,3,1,6,12,8,2,11,0,8
+X,3,6,5,4,3,7,7,1,7,10,6,8,3,8,3,7
+H,4,8,4,5,2,7,5,15,1,7,8,8,3,8,0,8
+Z,3,7,5,5,3,7,8,2,9,11,6,9,1,9,6,8
+G,5,9,5,6,3,6,7,6,7,10,8,10,2,9,4,9
+V,4,5,6,4,5,7,8,5,5,7,6,8,6,9,7,6
+U,4,10,6,8,10,9,8,4,4,6,7,8,9,7,8,8
+F,0,0,1,0,0,3,12,4,2,11,9,6,0,8,2,8
+X,4,5,6,4,3,7,7,1,9,10,6,8,2,8,3,7
+A,5,11,8,8,6,6,3,2,3,4,2,7,5,5,5,5
+Y,2,1,2,1,0,8,10,3,1,6,13,8,1,11,0,8
+U,2,3,3,2,1,5,8,5,6,11,9,9,3,9,1,6
+O,2,4,3,3,2,8,6,6,3,9,5,8,2,8,2,8
+O,5,11,6,8,6,7,6,7,4,10,6,10,5,8,4,6
+C,4,8,5,6,3,4,8,5,6,9,8,14,3,7,4,8
+C,5,10,6,8,4,4,8,7,9,8,9,13,1,8,4,9
+W,5,10,7,8,8,8,9,6,4,5,9,9,7,8,4,5
+J,4,7,5,5,2,7,7,3,6,15,5,9,0,7,0,7
+T,3,10,5,7,1,7,15,0,6,7,11,8,0,8,0,8
+A,4,10,7,8,5,11,2,2,2,9,2,9,4,5,4,8
+H,4,7,5,5,5,7,7,6,6,7,6,8,6,8,3,8
+Q,3,4,4,5,3,8,8,6,2,5,7,9,3,9,5,10
+M,5,6,7,4,5,10,6,2,4,9,4,7,7,6,2,8
+O,3,4,4,6,2,7,7,9,7,7,6,8,3,8,4,8
+B,3,1,3,2,3,7,7,5,5,7,6,6,2,8,6,9
+I,2,9,5,7,5,10,7,2,5,9,4,5,3,8,6,5
+Q,7,9,10,8,8,5,4,4,5,4,4,7,4,8,6,6
+D,4,8,5,6,4,7,8,7,8,8,7,5,3,8,3,7
+M,4,7,5,5,3,7,7,12,1,7,9,8,8,6,0,8
+N,5,7,7,5,3,7,9,2,4,10,6,6,5,9,1,7
+O,4,11,5,8,5,8,7,8,4,7,7,7,3,7,3,8
+U,3,2,5,3,2,6,8,6,8,7,10,9,3,9,1,8
+N,3,5,5,4,3,7,9,2,4,10,6,6,5,9,1,7
+H,4,9,5,7,5,8,7,6,6,7,6,6,6,8,3,6
+A,2,2,4,3,2,8,2,1,1,7,2,8,2,7,3,7
+A,2,4,4,2,2,10,2,2,2,9,2,8,2,6,2,8
+N,9,12,7,7,3,9,11,5,6,3,5,9,5,8,2,7
+N,3,4,5,3,2,7,9,3,4,10,6,6,5,9,0,7
+X,2,2,3,3,2,8,7,3,8,6,6,8,2,8,6,8
+G,5,5,6,7,3,8,6,8,9,6,5,11,1,8,6,11
+G,3,3,4,5,2,7,8,8,7,6,7,8,2,7,6,11
+H,4,8,4,5,2,7,5,15,1,7,8,8,3,8,0,8
+B,4,5,4,3,4,7,7,6,6,7,6,6,2,8,6,10
+J,3,8,3,6,2,14,3,4,4,13,1,8,0,7,0,8
+H,4,5,6,7,6,7,8,4,1,8,6,6,4,10,8,5
+C,4,5,5,4,2,4,8,5,7,11,10,12,1,9,3,7
+N,5,10,5,8,3,7,7,15,2,4,6,8,6,8,0,8
+S,3,6,4,4,3,8,6,6,5,7,7,10,2,10,8,8
+K,3,7,4,5,3,5,7,5,7,6,5,10,3,8,4,9
+Y,6,11,6,8,2,3,12,5,6,13,12,6,2,11,2,6
+X,4,9,7,7,3,7,7,1,9,10,6,8,3,8,4,7
+Y,2,4,3,2,1,4,11,2,7,11,10,5,1,11,2,5
+O,2,5,3,4,2,8,7,7,4,9,6,8,2,8,2,8
+Z,4,4,6,6,3,12,4,4,4,11,2,9,2,7,4,11
+C,2,4,3,3,1,6,8,7,7,9,7,12,1,10,4,10
+R,3,5,6,4,4,8,7,3,5,10,4,6,3,7,4,10
+Q,6,9,8,8,7,7,4,5,6,7,4,9,5,5,7,7
+Y,2,5,4,4,2,6,10,1,6,8,11,8,1,11,2,7
+A,2,4,3,3,1,11,3,3,2,11,2,9,1,6,2,9
+U,7,10,7,7,5,3,8,5,7,10,9,9,3,9,2,6
+C,3,7,4,5,1,6,8,6,9,5,6,14,1,7,4,9
+M,5,5,6,4,5,8,6,6,5,7,7,8,9,6,3,7
+B,7,11,9,8,7,10,6,4,7,10,4,7,3,8,6,11
+N,2,3,3,5,2,7,7,13,1,5,6,8,5,8,0,8
+F,2,4,4,3,1,6,12,3,5,13,7,4,1,9,2,6
+C,2,4,3,3,1,4,8,5,7,11,9,12,1,9,2,7
+G,2,4,3,3,2,6,7,5,4,9,8,10,2,9,4,9
+J,1,3,2,4,1,13,3,7,4,13,4,11,1,6,0,8
+A,5,11,5,6,4,10,3,4,2,10,5,11,5,3,5,10
+U,7,10,8,8,5,3,8,5,7,10,10,10,3,9,2,6
+C,5,10,3,5,2,5,9,6,6,11,8,8,2,9,5,8
+S,4,7,6,6,7,8,7,5,4,7,7,7,5,9,10,12
+I,0,3,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+S,3,8,4,6,3,8,8,8,8,7,4,7,2,6,9,8
+H,2,2,3,3,3,8,8,6,6,7,6,7,3,8,3,7
+B,3,5,4,3,4,7,7,5,5,6,6,6,2,8,6,10
+Z,1,0,2,1,0,7,7,2,10,8,6,8,0,8,6,8
+F,5,8,7,6,4,7,10,2,6,13,6,5,2,10,2,8
+D,5,9,7,7,6,10,7,5,6,9,3,6,3,8,3,8
+F,2,3,2,1,1,6,10,4,5,10,9,4,1,10,3,6
+K,3,4,5,3,2,7,6,1,6,10,6,10,3,8,3,8
+W,6,8,8,7,9,8,8,5,6,7,6,8,9,8,8,7
+T,0,0,1,0,0,7,13,1,4,7,10,8,0,8,0,8
+E,3,11,5,8,5,7,7,6,8,6,5,9,3,8,6,9
+L,2,3,2,2,1,4,3,5,7,2,2,5,0,7,1,6
+I,3,7,4,5,2,7,7,0,7,13,6,8,0,8,1,8
+V,6,11,6,8,3,3,12,5,4,11,12,7,3,9,1,8
+P,4,5,5,7,6,8,9,3,2,7,8,6,5,11,5,4
+H,4,6,6,4,4,7,7,3,6,10,7,8,3,9,3,7
+O,2,4,3,3,2,7,7,7,5,7,6,8,2,8,3,8
+N,5,9,8,7,4,9,7,3,5,10,3,5,6,9,1,7
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+Y,1,0,2,0,0,7,9,2,2,6,12,8,1,10,0,8
+I,1,2,1,3,1,7,7,1,7,7,6,8,0,8,3,8
+R,1,0,2,1,1,6,9,7,3,7,5,7,2,7,4,10
+J,3,10,4,7,2,10,6,0,8,11,3,6,0,7,1,7
+N,10,15,9,8,4,8,10,5,4,4,6,10,6,11,3,6
+Y,4,7,6,9,9,9,6,6,3,7,7,8,7,9,6,5
+B,1,1,2,1,1,7,7,7,5,7,6,7,1,8,6,8
+S,5,5,6,4,6,9,8,4,5,7,7,8,5,10,9,11
+H,1,0,1,0,0,7,7,10,1,7,6,8,2,8,0,8
+G,2,4,2,2,1,6,7,5,5,9,7,10,2,8,4,9
+G,6,9,5,4,3,10,6,4,6,11,3,8,4,7,5,9
+C,8,11,5,6,2,7,9,6,7,12,7,8,2,9,5,9
+N,2,1,2,1,1,7,7,12,1,5,6,8,5,8,0,8
+T,4,11,5,8,3,7,14,0,5,7,10,8,0,8,0,8
+K,4,5,7,3,3,6,8,2,8,10,8,10,4,7,3,6
+F,6,11,9,8,9,5,8,2,4,10,9,8,6,11,6,6
+X,2,3,3,2,2,8,7,3,9,6,6,8,2,8,5,8
+F,3,7,5,5,3,5,10,4,6,11,10,5,2,9,3,5
+O,6,8,8,7,6,8,4,3,4,9,3,8,4,7,5,8
+W,1,0,2,0,0,7,8,3,0,7,8,8,5,9,0,8
+Y,5,9,8,6,4,8,10,1,7,5,11,8,2,12,3,8
+J,2,6,3,4,1,10,7,1,6,12,3,7,0,7,0,7
+U,12,15,10,8,4,5,3,5,5,4,7,7,5,8,2,6
+V,3,5,4,3,1,3,12,4,3,11,11,7,2,10,1,8
+Z,7,10,9,8,5,7,8,3,10,12,7,7,1,8,6,7
+T,4,9,6,8,6,7,9,4,7,7,8,8,3,12,10,7
+E,6,11,4,6,2,7,8,5,7,8,4,12,1,7,7,8
+J,2,9,3,7,1,15,2,6,5,14,1,9,0,7,0,8
+W,10,10,10,8,6,2,10,2,3,10,11,9,8,10,1,7
+D,4,10,5,7,3,6,7,11,9,7,6,6,3,8,4,8
+M,6,9,7,4,4,10,10,6,3,5,7,9,10,13,2,6
+S,3,8,4,6,3,7,8,8,7,8,5,7,2,7,9,8
+T,3,5,4,4,4,6,8,4,7,7,7,9,3,10,6,7
+V,4,10,6,8,4,8,11,2,3,4,10,9,3,11,2,8
+O,7,10,7,8,5,8,6,8,6,10,5,9,5,9,6,5
+D,5,11,7,9,6,9,7,5,7,10,5,5,3,8,3,8
+B,2,5,4,4,3,8,8,3,5,10,6,6,3,7,6,9
+Q,2,4,3,4,3,8,8,6,3,8,6,9,2,9,4,9
+L,3,7,4,5,1,0,0,6,6,0,1,5,0,8,0,8
+S,2,1,2,2,1,8,7,4,7,5,6,7,0,8,8,8
+U,3,2,4,3,2,8,9,5,7,5,9,8,3,9,1,8
+L,3,7,3,5,1,1,1,5,5,0,1,6,0,8,0,8
+J,2,3,3,2,1,8,6,3,6,14,6,10,0,7,0,8
+Y,4,6,7,8,1,6,10,3,2,8,13,8,1,11,0,8
+E,4,7,5,5,4,9,6,2,6,11,5,8,3,8,4,11
+W,3,7,5,5,3,10,8,4,1,7,8,8,8,9,0,8
+H,6,11,9,8,7,9,7,3,6,10,5,8,3,8,3,8
+H,2,1,3,2,2,7,8,6,6,7,6,8,3,8,3,8
+G,4,8,5,6,3,8,6,6,7,11,6,11,2,10,4,9
+M,3,6,4,4,2,8,7,11,1,7,9,8,7,5,0,8
+M,15,15,15,8,8,3,9,6,6,3,2,13,10,12,2,8
+Z,3,8,4,6,3,7,7,5,9,7,6,8,2,8,7,8
+D,2,4,4,2,2,8,7,4,6,10,5,6,2,8,3,8
+Q,5,10,7,9,3,8,5,9,8,6,4,8,3,8,4,8
+O,1,0,1,0,0,7,7,6,3,7,6,8,2,8,3,8
+B,5,10,8,8,12,8,8,5,3,7,7,7,8,11,12,9
+C,4,8,5,6,3,4,9,6,7,7,8,14,1,8,4,10
+I,4,7,5,5,3,8,4,2,6,7,7,7,1,10,4,7
+N,7,11,8,6,3,9,7,2,4,13,5,8,6,8,0,8
+Y,9,10,7,14,5,9,11,2,3,7,10,5,4,10,6,9
+G,3,4,4,3,2,7,6,6,5,6,6,9,2,9,4,9
+Q,4,9,4,5,3,10,5,4,6,11,4,8,3,8,8,12
+F,2,3,3,2,1,7,9,2,5,13,6,5,1,9,1,8
+V,7,13,6,7,3,7,11,5,5,8,11,5,4,11,4,8
+F,4,6,4,8,2,0,14,4,4,12,10,6,0,8,2,6
+X,2,1,2,1,0,7,7,4,4,7,6,8,2,8,4,8
+Y,1,0,2,1,0,7,9,1,2,6,12,8,1,10,0,8
+P,7,11,10,8,6,9,8,4,6,12,3,3,2,10,4,9
+L,3,9,4,7,2,0,2,4,6,1,0,8,0,8,0,8
+U,9,12,8,7,5,7,6,5,5,6,7,8,6,8,3,7
+N,11,13,9,7,4,5,9,5,6,3,3,12,6,12,2,7
+Y,3,8,4,6,2,8,10,1,3,7,12,8,1,11,0,8
+A,2,8,4,6,2,12,2,4,3,11,2,10,2,6,4,9
+Y,2,9,4,6,1,8,10,2,3,6,12,8,1,10,0,8
+H,3,3,3,4,1,7,9,14,1,7,4,8,3,8,0,8
+U,5,9,6,6,6,8,6,8,5,7,6,9,3,8,4,5
+S,3,5,4,7,2,9,9,6,10,5,6,5,0,7,9,7
+N,3,3,5,1,1,8,8,3,5,11,5,6,5,9,0,6
+Q,5,7,7,6,6,7,4,5,5,6,5,9,5,4,7,7
+Q,3,3,4,4,3,8,8,6,2,5,7,10,2,9,5,9
+I,1,1,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+H,3,5,6,4,3,9,6,3,6,10,3,7,4,7,4,9
+O,6,12,4,6,3,7,8,5,4,8,4,7,5,8,5,8
+T,2,3,3,2,1,6,11,2,7,10,9,5,1,10,2,5
+D,6,11,8,8,8,8,7,7,6,8,5,4,8,11,7,10
+W,5,10,7,8,4,6,8,4,2,7,8,8,9,9,0,8
+R,6,10,5,5,3,7,6,5,4,9,5,9,6,5,6,11
+Z,2,4,5,3,2,7,7,2,9,12,6,8,1,8,5,8
+U,2,6,2,4,1,7,6,12,4,7,13,8,3,9,0,8
+E,1,0,2,1,1,5,7,5,8,7,6,12,0,8,6,9
+H,5,10,7,7,9,8,7,4,3,6,7,8,8,8,8,8
+K,2,3,4,2,2,6,8,2,6,10,6,9,3,8,2,8
+G,1,3,2,1,1,6,7,5,4,9,7,10,2,8,4,9
+A,2,4,3,3,1,11,3,2,2,9,2,9,1,6,2,8
+Y,6,11,6,8,4,3,9,1,7,10,10,6,1,11,3,4
+N,3,8,4,6,3,8,8,6,5,6,6,5,6,9,2,5
+E,4,7,6,6,7,7,6,4,3,7,6,9,6,11,8,12
+I,5,13,4,7,2,9,7,5,4,12,3,6,3,8,5,10
+X,1,0,1,0,0,7,7,3,5,7,6,8,2,8,4,8
+N,7,9,6,5,3,8,10,5,4,4,6,10,6,11,3,7
+H,5,5,6,6,3,7,5,15,1,7,8,8,3,8,0,8
+E,3,5,5,3,3,7,8,2,8,11,7,9,2,9,4,8
+H,4,7,6,5,4,8,7,6,7,7,6,5,6,8,3,7
+D,5,10,5,5,4,9,6,3,6,10,4,7,5,8,7,7
+M,4,7,5,5,3,6,7,12,1,8,9,8,8,6,0,8
+J,1,3,2,2,1,11,6,2,5,11,4,8,0,7,0,7
+A,3,9,6,7,4,12,3,2,2,9,2,9,2,6,2,8
+C,8,14,6,8,3,6,9,6,9,11,8,10,2,8,5,8
+K,5,8,6,6,6,5,7,5,7,6,6,13,3,8,6,9
+C,4,9,5,6,3,6,7,6,8,6,5,12,1,8,4,9
+I,1,6,2,4,1,9,7,0,7,13,5,8,0,8,1,8
+Q,4,7,5,8,5,9,9,6,2,4,7,11,3,9,5,10
+H,4,8,5,6,4,7,8,6,6,7,6,7,3,8,3,7
+A,9,13,8,8,4,10,0,3,2,10,4,12,3,5,4,8
+M,1,0,2,0,1,7,6,9,0,7,8,8,5,6,0,8
+M,1,0,2,0,0,7,6,9,0,7,8,8,5,6,0,8
+Z,9,15,9,8,6,8,5,2,9,12,6,10,3,8,6,8
+H,4,10,5,7,3,7,8,15,1,7,5,8,3,8,0,8
+Q,3,6,4,8,4,7,9,5,3,8,9,10,3,8,6,8
+U,3,3,4,2,2,5,8,5,7,10,8,9,3,10,2,5
+C,4,7,4,5,3,4,7,5,6,11,9,14,1,9,3,9
+I,1,9,0,7,1,7,7,5,3,7,6,8,0,8,0,8
+X,1,3,2,1,1,8,7,3,8,7,6,8,2,8,5,8
+S,3,9,4,7,3,8,8,5,8,5,5,6,0,8,8,8
+T,5,10,7,8,7,9,11,4,6,5,11,8,3,12,1,8
+F,4,5,4,7,2,1,12,5,6,12,11,8,0,8,2,5
+A,2,9,4,6,2,7,4,3,2,6,1,8,2,7,2,8
+R,4,8,5,6,3,6,10,9,4,7,4,8,3,8,5,10
+G,4,7,5,5,3,6,7,6,7,10,7,11,2,9,4,9
+Y,6,6,5,8,4,9,8,4,4,5,11,5,4,11,5,6
+S,8,15,8,8,4,7,7,4,3,13,8,9,3,10,3,8
+R,4,9,6,7,8,7,9,3,5,5,6,9,5,8,8,7
+F,2,3,2,2,1,5,11,4,4,11,9,5,1,9,3,7
+L,2,7,4,5,5,8,8,3,4,6,6,9,5,11,6,5
+W,4,7,6,5,4,7,11,2,2,6,9,8,8,11,1,8
+W,5,9,5,4,3,6,9,1,3,8,9,7,7,12,1,6
+P,2,6,3,4,1,4,11,8,2,10,6,4,1,10,3,8
+H,5,9,6,7,7,7,7,6,6,7,6,8,3,8,3,8
+K,3,7,4,5,3,3,7,6,3,7,6,11,3,8,3,11
+L,2,7,3,5,1,0,1,5,6,0,0,7,0,8,0,8
+S,4,7,6,5,6,8,6,4,3,8,6,8,4,8,10,10
+D,5,9,7,6,6,9,7,3,6,11,5,6,4,7,4,8
+E,4,7,5,5,3,6,8,3,8,11,7,8,2,8,4,7
+S,2,6,3,4,2,8,8,7,5,7,5,6,2,8,8,8
+L,4,7,5,5,4,7,6,8,6,5,6,8,3,7,5,11
+Z,4,8,6,6,4,8,6,2,9,11,4,10,2,7,7,10
+Y,5,9,5,4,2,5,8,3,3,10,9,6,4,9,3,4
+M,3,7,4,5,4,7,6,5,4,7,7,11,6,5,1,10
+W,4,8,6,6,6,10,12,2,2,5,8,8,6,11,0,8
+D,3,8,4,6,2,5,6,10,8,5,5,5,3,8,4,8
+A,3,3,5,5,2,6,4,3,1,6,1,8,3,7,2,7
+Q,3,3,4,4,3,8,8,7,3,5,7,10,2,9,5,10
+Y,6,10,8,8,8,8,5,6,5,8,7,8,6,9,7,3
+X,3,5,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+V,4,7,6,5,6,8,5,4,2,7,7,8,7,8,5,8
+Y,3,3,5,4,1,8,11,2,2,5,12,8,1,10,0,8
+Q,5,9,6,8,3,8,5,9,7,5,4,8,3,8,4,8
+E,4,11,4,8,3,3,8,6,11,7,5,14,0,8,7,7
+U,5,4,5,7,2,7,4,15,6,7,14,8,3,9,0,8
+H,6,10,8,8,7,10,6,2,6,10,3,7,4,8,4,10
+G,3,4,4,3,2,6,7,5,5,9,8,9,2,9,4,9
+O,3,7,4,5,2,8,6,9,6,7,5,8,3,8,4,8
+N,4,9,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+V,1,0,2,0,0,8,9,3,1,6,12,8,2,11,0,8
+U,8,10,9,8,5,4,8,6,9,10,9,9,3,9,3,5
+I,3,8,4,6,2,5,9,0,7,13,7,7,0,8,1,7
+F,7,8,8,9,9,6,9,4,5,7,7,6,5,8,11,8
+V,3,4,4,3,1,5,12,2,2,9,11,7,3,12,1,7
+Y,4,8,6,6,5,9,5,7,5,6,9,7,3,9,9,4
+H,6,10,9,8,7,6,7,5,5,6,5,8,3,7,7,10
+L,4,11,5,8,4,7,4,0,7,9,3,10,1,6,3,8
+H,4,4,5,6,2,7,8,15,1,7,5,8,3,8,0,8
+X,4,4,5,6,1,7,7,5,4,7,6,8,3,8,4,8
+B,2,6,4,4,3,7,7,7,6,7,6,6,2,8,7,9
+X,11,13,10,8,5,6,8,2,9,9,7,9,5,7,5,7
+H,4,4,6,3,3,9,7,3,6,10,3,7,3,7,3,9
+A,3,9,4,6,3,7,4,3,1,6,2,8,2,7,3,8
+N,5,8,6,6,4,6,9,6,5,8,7,9,6,9,1,7
+P,4,11,6,8,6,6,10,4,5,10,9,4,4,10,4,7
+Z,1,1,2,1,0,8,7,2,10,9,6,8,0,8,6,8
+V,4,7,6,5,6,7,6,4,2,8,8,8,5,10,4,7
+O,5,8,5,6,4,7,9,7,4,10,8,6,4,9,4,9
+J,2,5,4,3,1,9,6,3,6,14,5,10,1,6,1,7
+Q,4,5,5,6,5,8,4,7,4,6,5,8,3,8,4,9
+J,2,4,4,3,1,8,6,3,6,14,6,11,1,6,1,7
+Z,4,7,6,5,3,7,8,2,10,12,6,8,1,9,6,8
+M,6,9,8,7,8,8,7,2,4,9,7,8,8,6,2,8
+B,5,11,6,8,5,6,8,9,8,7,5,7,2,8,9,10
+U,3,6,5,4,3,7,9,6,6,5,9,9,3,9,1,8
+X,3,7,4,5,2,7,7,4,4,7,6,8,2,8,4,8
+L,4,11,4,8,3,0,2,4,6,1,0,7,0,8,0,8
+D,3,8,4,6,4,6,7,9,6,7,7,5,3,8,3,8
+Y,3,7,5,5,2,7,11,1,3,8,11,8,1,10,0,8
+B,4,8,6,7,7,8,7,5,5,7,6,8,6,9,8,4
+L,4,10,4,5,2,10,3,2,5,12,3,11,2,9,4,10
+S,4,4,4,6,2,8,8,5,9,5,6,6,0,8,9,7
+R,5,10,6,7,7,8,7,7,4,8,5,7,4,7,7,10
+O,3,8,5,6,3,7,8,9,5,7,7,6,3,8,3,8
+L,4,8,6,7,5,7,7,4,5,6,7,9,4,8,8,8
+Q,3,6,4,5,3,8,8,7,5,6,6,9,2,8,4,8
+Y,5,8,5,6,3,6,9,1,8,8,9,4,1,11,4,5
+Y,4,5,5,4,2,4,10,1,8,10,10,5,4,11,4,3
+B,1,0,1,0,1,7,8,6,4,7,6,7,1,8,6,9
+F,4,7,5,5,3,4,12,2,5,13,7,5,1,10,1,7
+L,6,12,6,6,4,9,4,3,4,12,7,11,3,10,5,11
+I,0,3,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+J,4,10,5,8,2,6,8,2,7,15,7,9,1,6,1,7
+R,2,3,4,2,2,8,8,3,5,10,4,7,2,7,3,9
+F,5,9,8,6,4,6,11,3,6,14,6,4,2,10,2,7
+X,4,7,6,5,3,5,8,1,8,10,10,9,2,9,3,6
+D,5,11,6,8,7,9,8,6,5,9,5,4,5,8,4,10
+G,4,6,5,4,3,7,7,8,7,6,6,11,2,9,4,9
+B,4,7,4,5,3,6,7,8,6,7,6,7,2,8,9,10
+T,7,9,7,7,5,5,12,4,6,11,9,4,2,12,2,4
+G,3,4,4,3,2,6,7,5,5,9,7,10,2,8,4,9
+X,4,11,5,8,2,7,7,4,4,7,6,8,3,8,4,8
+I,2,8,5,6,5,9,6,3,5,8,5,5,5,8,5,5
+P,5,10,5,7,3,5,9,10,5,8,6,5,2,9,4,8
+G,5,7,6,5,3,7,6,7,7,10,6,11,2,10,4,9
+D,4,10,5,8,6,7,7,6,6,6,5,5,3,8,3,7
+A,4,11,6,8,3,9,3,3,3,8,1,9,3,6,3,9
+J,3,6,2,9,2,9,8,3,3,12,4,5,2,8,5,10
+K,6,10,8,8,9,6,5,5,4,6,6,8,4,5,9,10
+E,4,7,6,5,6,8,8,3,5,5,7,10,5,12,8,9
+Z,6,9,8,7,4,8,6,3,11,12,5,10,1,8,6,8
+G,4,9,5,6,7,8,7,5,2,6,6,8,8,8,7,12
+T,3,5,4,3,2,5,12,2,8,11,9,4,1,10,2,5
+E,3,7,4,5,4,8,7,2,6,11,6,8,3,8,4,10
+M,3,4,6,3,3,7,6,3,4,9,7,8,7,5,1,8
+V,4,9,6,7,7,7,8,3,2,7,8,8,8,9,6,7
+O,2,1,2,1,1,7,7,6,4,7,5,8,2,8,2,7
+Y,7,10,7,8,4,2,10,2,6,10,12,7,2,11,2,6
+D,4,7,5,5,8,9,8,4,5,7,6,6,4,6,8,7
+V,4,5,5,3,2,4,12,2,3,9,11,7,4,10,1,7
+D,5,10,6,8,6,6,8,9,8,7,6,5,2,8,3,7
+S,3,5,5,3,2,8,7,3,8,11,5,7,1,9,4,8
+P,4,7,5,5,2,7,10,3,5,14,5,3,0,10,3,8
+K,2,1,2,2,0,4,7,8,1,7,6,11,3,8,2,11
+I,3,9,5,7,5,12,5,1,6,8,4,5,1,8,5,10
+I,6,14,6,8,3,8,7,2,5,13,4,5,2,8,6,10
+H,5,6,8,4,4,6,7,3,6,10,8,10,3,8,3,7
+O,2,3,3,2,1,8,7,6,4,9,6,8,2,8,2,8
+G,5,11,6,8,4,6,6,7,8,11,6,13,2,9,4,8
+O,3,9,4,7,4,7,7,8,4,7,6,9,3,8,3,8
+P,2,1,2,2,1,5,11,4,3,10,8,3,0,9,3,7
+Z,2,2,3,3,2,7,7,5,9,6,6,8,2,8,7,8
+E,5,8,7,7,7,7,9,5,5,7,7,10,5,9,9,10
+Q,3,7,4,5,4,8,5,7,3,6,7,8,3,7,6,9
+V,7,9,9,8,10,7,8,5,6,8,6,8,7,7,8,8
+X,4,5,5,4,3,8,7,3,9,6,6,8,2,8,6,9
+P,4,5,4,7,2,3,13,8,1,11,6,3,1,10,4,8
+E,3,6,4,4,4,8,7,6,2,7,6,11,3,8,7,10
+F,4,6,6,7,7,8,9,5,5,7,5,8,5,8,8,6
+L,3,7,3,5,1,0,0,6,6,0,1,5,0,8,0,8
+W,7,9,8,5,4,7,8,3,4,6,9,6,9,11,3,5
+I,1,1,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+E,3,7,5,5,5,5,7,3,6,7,6,12,2,10,8,6
+Y,4,8,5,6,2,5,10,2,2,8,12,8,2,11,0,8
+O,3,7,4,5,3,7,7,8,5,7,7,8,3,8,3,8
+X,5,8,8,6,4,5,8,2,8,11,10,10,3,8,3,6
+V,3,8,5,6,1,6,8,4,3,7,14,8,3,10,0,8
+W,4,7,6,5,9,8,7,5,2,7,7,8,10,10,3,8
+R,3,7,5,5,3,8,8,5,5,8,5,7,3,7,5,10
+J,2,3,4,2,1,9,6,3,5,14,6,10,0,7,0,8
+Y,6,8,6,6,3,4,10,1,8,11,10,6,2,11,4,3
+O,6,10,7,8,7,8,7,9,4,7,6,8,3,8,3,7
+P,2,1,2,3,2,5,9,4,4,9,8,5,1,10,3,7
+H,1,0,2,1,0,7,7,11,1,7,6,8,3,8,0,8
+U,9,10,9,8,4,3,8,6,8,12,11,10,3,9,2,6
+T,1,6,2,4,1,7,13,0,4,7,10,8,0,8,0,8
+Q,3,5,3,6,3,8,8,5,3,8,8,10,3,9,6,8
+R,3,4,5,3,3,8,8,3,5,9,4,7,2,6,4,10
+N,3,8,4,6,4,7,7,12,1,6,6,8,5,8,0,8
+U,5,6,6,6,6,8,6,5,4,6,6,8,4,8,1,7
+O,2,1,3,2,1,7,7,7,6,7,6,8,2,8,3,8
+E,2,4,4,3,2,6,8,2,8,11,7,9,2,8,4,8
+P,7,11,7,6,4,8,9,5,3,11,5,4,4,11,6,5
+L,4,8,6,6,7,8,7,3,5,7,7,9,7,9,6,6
+S,7,10,8,8,6,7,8,3,6,10,5,7,2,8,5,8
+Y,2,3,4,4,0,7,10,1,3,7,12,8,1,11,0,8
+W,6,10,8,8,9,7,7,6,2,7,8,8,6,8,4,8
+Y,1,1,3,2,1,5,10,1,6,9,11,9,1,11,2,8
+Y,3,5,5,7,1,7,10,1,3,7,12,8,1,11,0,8
+E,2,4,3,3,2,7,7,2,7,11,7,9,2,8,4,8
+F,4,10,6,7,3,4,13,4,4,13,8,3,1,10,2,5
+D,5,9,5,4,3,8,6,4,6,8,5,7,5,9,5,7
+E,2,3,2,2,2,7,7,5,7,7,6,9,2,8,5,10
+K,2,3,4,2,2,6,7,2,6,10,8,11,3,8,2,8
+F,2,4,3,3,2,5,10,4,5,10,9,5,1,10,3,6
+Z,4,4,5,6,2,7,7,4,15,9,6,8,0,8,8,8
+B,5,8,7,6,5,9,8,3,7,10,4,5,2,8,6,10
+T,4,10,6,8,8,8,7,5,6,7,6,8,7,6,7,7
+H,6,6,6,8,3,7,8,15,0,7,5,8,3,8,0,8
+H,3,8,4,6,4,7,7,13,1,7,6,8,3,8,0,8
+U,5,8,5,6,2,4,9,5,7,12,11,8,3,9,1,6
+P,7,8,9,10,11,8,10,2,4,7,9,6,6,9,7,5
+Y,4,4,6,6,7,9,4,5,3,7,7,8,5,9,4,8
+R,6,9,6,4,4,8,7,3,5,9,4,8,6,7,6,8
+J,3,11,4,9,4,10,7,1,7,11,3,7,0,7,1,7
+M,6,8,8,7,9,7,9,4,3,7,5,8,12,8,5,7
+J,3,8,5,6,2,7,8,1,6,14,5,8,1,7,0,7
+V,4,5,5,3,2,4,12,2,3,9,11,7,4,11,1,7
+B,1,3,3,2,2,8,8,2,5,10,6,6,2,8,4,8
+A,3,11,5,8,4,8,5,3,0,7,1,8,2,7,3,8
+B,3,7,5,5,7,9,8,4,3,6,7,7,5,11,7,7
+W,5,4,7,7,4,8,8,4,2,7,8,8,9,9,0,8
+U,3,2,4,3,2,6,8,6,7,7,9,9,3,9,1,8
+K,2,1,3,1,2,6,7,4,8,7,6,10,3,8,5,8
+E,3,8,5,6,5,7,7,4,8,7,7,8,3,8,5,10
+I,1,4,2,3,1,7,7,0,7,13,6,8,0,8,1,8
+K,6,11,9,8,5,8,8,2,7,10,4,8,3,8,3,9
+A,4,10,7,8,5,12,3,2,2,9,2,9,2,6,2,8
+K,4,11,6,8,5,5,6,5,8,6,7,12,3,8,6,10
+U,4,5,5,7,2,7,5,14,5,7,14,8,3,9,0,8
+R,3,5,6,4,3,9,8,4,6,9,5,6,3,7,4,9
+E,3,9,4,6,4,7,7,6,9,7,7,9,3,8,6,9
+Y,6,7,6,5,4,5,9,1,8,9,9,5,2,9,4,4
+L,4,11,6,8,4,5,3,3,9,6,1,8,1,6,3,6
+R,5,5,6,8,4,5,10,9,3,7,5,8,3,8,6,11
+J,4,11,5,8,2,8,6,3,7,15,5,9,1,6,1,7
+V,2,7,4,5,2,7,11,2,3,6,11,9,2,10,1,8
+F,1,0,1,0,0,3,12,4,2,11,8,6,0,8,2,7
+K,2,4,4,3,2,7,7,2,6,10,5,9,4,7,2,8
+K,2,1,3,2,2,6,7,4,7,7,6,10,3,8,5,9
+M,5,8,7,6,6,8,6,6,5,7,7,8,8,5,2,8
+X,4,8,5,6,3,7,7,4,4,7,6,8,3,8,4,8
+Z,2,6,4,4,2,8,7,2,9,11,5,9,1,8,5,8
+H,7,10,10,7,8,7,8,2,6,10,7,8,5,9,4,8
+N,3,8,4,6,4,7,7,12,1,6,6,8,5,8,0,8
+U,9,13,8,7,4,7,5,6,7,3,9,7,5,9,3,6
+L,5,10,6,8,3,2,2,5,8,1,0,6,0,7,1,6
+U,6,6,6,4,3,3,9,5,7,10,10,10,3,9,2,6
+R,4,3,4,4,2,6,9,8,4,6,5,8,2,8,5,10
+B,5,9,8,8,10,7,7,5,4,7,6,8,7,10,9,5
+K,4,8,6,6,3,4,8,3,7,11,11,11,3,8,4,5
+U,4,7,5,5,2,7,4,13,5,7,15,8,3,9,0,8
+F,5,10,7,8,5,6,11,1,6,13,7,5,1,10,2,7
+F,2,5,4,4,2,4,12,4,4,13,8,5,1,10,1,7
+O,2,0,2,1,1,7,6,7,5,7,6,8,2,8,3,8
+L,6,8,7,7,6,8,6,4,5,7,7,8,3,8,8,10
+L,1,0,1,0,0,2,1,6,4,0,3,4,0,8,0,8
+W,6,9,6,6,6,5,10,3,3,9,7,7,6,11,2,7
+W,9,10,9,7,6,2,10,2,4,11,11,9,7,10,1,7
+Y,6,9,8,6,6,8,8,6,5,5,8,8,3,8,9,6
+L,3,5,5,5,4,8,5,5,5,7,7,8,2,8,8,11
+O,5,9,6,6,5,7,7,8,4,7,6,9,3,8,4,7
+G,7,10,5,5,4,7,6,3,2,8,6,8,4,9,9,8
+E,4,11,4,8,3,3,7,6,10,7,6,14,0,8,8,7
+F,3,8,6,6,6,8,7,1,4,10,6,7,5,9,4,5
+G,3,4,4,3,2,6,7,4,4,9,7,9,2,8,5,10
+P,2,4,4,3,2,7,9,4,3,11,4,4,1,10,2,8
+C,3,5,5,3,2,4,8,5,7,12,9,11,1,9,3,7
+V,6,9,5,7,4,3,11,2,2,9,10,8,3,11,1,7
+M,4,10,5,8,6,7,6,10,0,7,8,8,7,5,0,8
+V,2,3,3,2,1,7,12,2,2,7,11,8,2,10,1,8
+R,4,8,5,6,5,8,5,7,4,7,6,8,4,7,6,10
+B,4,7,6,5,4,9,6,4,6,10,5,6,2,8,6,10
+K,5,9,7,7,8,7,7,3,4,6,6,9,7,7,8,7
+H,7,11,7,6,5,7,7,3,4,9,8,8,7,10,6,8
+A,2,7,4,5,2,12,3,4,3,12,2,9,2,6,3,9
+G,6,11,8,8,5,5,7,5,5,5,7,7,3,6,4,7
+L,4,9,6,7,3,4,2,8,7,1,2,3,1,6,1,6
+R,2,6,2,4,2,5,10,7,3,7,4,9,2,6,5,11
+T,3,10,4,7,1,7,14,0,6,7,11,8,0,8,0,8
+C,2,1,3,2,1,7,8,7,6,9,7,11,1,9,3,10
+Y,6,9,6,7,4,3,9,1,6,10,11,7,1,11,3,5
+M,5,8,8,6,5,10,5,3,5,9,4,7,8,6,2,9
+K,2,1,2,2,1,6,7,4,8,7,6,11,3,8,5,9
+F,3,6,4,4,2,5,11,1,5,13,7,5,1,10,1,7
+C,1,1,2,1,0,6,7,6,9,7,6,15,0,8,4,10
+Q,1,0,1,0,0,8,7,6,2,6,6,9,2,8,2,8
+Q,7,13,6,7,5,11,4,4,6,11,4,8,4,8,8,11
+M,4,5,4,7,4,7,7,12,2,7,9,8,8,5,0,8
+F,8,12,7,6,4,8,8,2,5,10,5,6,3,8,7,8
+O,4,3,5,4,2,7,8,8,8,7,7,7,3,8,4,8
+X,4,8,6,6,3,9,7,1,8,10,3,7,2,8,3,8
+Z,3,7,5,5,2,8,7,2,10,11,5,9,1,8,6,9
+H,3,4,4,6,2,7,6,15,2,7,8,8,3,8,0,8
+C,6,9,5,4,3,8,7,4,3,9,8,10,4,8,7,11
+G,7,10,7,8,5,6,6,7,7,10,7,11,2,9,5,9
+W,5,7,7,5,3,7,8,4,1,6,8,8,8,9,0,8
+N,4,6,6,4,3,10,7,3,5,10,2,5,5,9,1,8
+G,4,10,6,8,3,7,6,8,8,6,6,9,2,8,6,11
+L,2,7,2,5,1,0,2,5,6,0,0,7,0,8,0,8
+X,4,8,5,6,4,7,7,3,8,5,6,8,3,8,6,8
+O,5,10,6,8,5,7,7,8,6,7,6,8,3,7,4,8
+L,2,0,2,1,0,2,0,6,4,0,3,4,0,8,0,8
+I,0,7,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+Q,3,3,4,5,4,8,7,7,3,6,5,9,3,8,5,9
+L,1,3,2,1,1,6,5,1,7,8,3,10,0,7,2,8
+U,5,11,7,9,5,6,8,5,7,6,8,9,3,9,1,8
+M,5,11,6,9,8,7,10,6,3,7,6,8,8,10,7,8
+P,9,13,9,7,6,8,9,4,4,12,4,4,5,10,6,6
+H,3,7,4,4,2,7,6,14,1,7,7,8,3,8,0,8
+A,1,0,2,0,0,8,3,2,0,7,2,8,2,6,1,8
+X,7,10,10,8,6,4,9,2,8,10,11,10,3,9,3,5
+A,2,4,4,3,2,7,2,2,1,6,2,8,2,7,3,6
+X,7,10,10,8,5,6,7,1,9,10,8,9,3,8,4,7
+B,4,9,5,7,4,6,8,9,7,7,5,7,2,8,9,10
+G,10,14,8,8,5,8,8,5,4,9,6,6,4,9,9,8
+H,4,6,6,4,6,8,8,4,3,6,6,7,7,9,7,8
+W,8,9,8,6,7,3,10,2,3,10,9,8,7,11,2,6
+P,8,11,8,6,5,9,8,4,4,12,4,4,5,10,6,7
+F,2,3,3,2,1,8,9,2,6,13,5,4,1,9,1,8
+L,2,0,2,1,0,2,1,6,5,0,2,4,0,8,0,8
+P,2,6,3,4,2,5,10,9,4,9,6,5,2,9,3,8
+B,4,11,4,8,4,6,7,10,7,7,6,7,2,8,9,10
+B,5,9,7,7,6,8,8,4,7,10,5,6,2,8,6,10
+Z,7,10,9,7,6,7,8,2,9,12,6,8,1,8,6,8
+C,2,3,2,2,1,5,8,5,6,11,9,11,1,9,3,8
+R,1,0,2,1,1,6,10,7,2,7,5,8,2,7,4,9
+I,1,3,2,2,0,7,7,1,7,13,6,8,0,8,1,8
+V,3,7,5,5,2,8,9,4,2,6,13,8,3,10,0,8
+H,7,10,7,5,5,6,8,4,5,9,9,9,7,11,6,7
+Z,2,1,3,2,2,7,7,5,9,6,6,8,1,8,7,8
+J,1,4,3,3,1,8,6,3,4,14,6,11,1,7,0,7
+U,2,3,3,2,1,7,8,6,6,7,9,8,3,10,1,8
+J,4,9,6,7,3,7,6,4,6,15,7,11,1,6,1,7
+L,4,9,4,7,2,0,1,4,6,1,0,7,0,8,0,8
+E,6,10,4,5,3,7,9,5,5,10,6,9,3,8,6,10
+U,3,5,4,3,2,4,8,5,7,10,9,9,3,9,2,6
+T,4,6,4,4,2,5,12,3,6,12,9,5,2,11,1,5
+M,8,11,12,8,8,5,7,3,5,10,10,10,12,6,4,8
+I,4,10,5,8,3,8,6,0,8,13,6,9,1,6,3,8
+A,3,3,5,4,2,8,2,2,2,6,2,8,2,7,2,7
+V,7,11,6,6,3,7,10,6,4,10,9,5,5,12,4,9
+J,2,5,4,4,2,8,6,3,5,14,6,11,1,6,1,7
+S,4,5,5,5,5,9,8,4,6,6,8,9,4,11,7,10
+T,3,10,5,7,2,9,13,0,6,6,10,8,0,8,0,8
+K,8,12,7,6,3,6,8,2,7,9,6,8,5,7,3,7
+Z,5,10,6,8,4,8,7,6,12,7,6,7,1,8,8,8
+T,7,9,8,8,9,7,9,5,8,7,7,8,5,10,11,7
+R,5,10,7,7,6,6,7,5,6,6,5,7,3,7,5,8
+W,4,9,6,7,5,9,10,2,2,5,9,7,8,12,1,7
+F,6,12,5,7,4,7,10,3,5,11,6,4,3,10,7,6
+L,4,9,4,7,1,0,1,6,6,0,0,6,0,8,0,8
+L,2,1,3,2,1,4,4,3,8,2,1,7,0,7,1,6
+H,6,10,9,8,7,9,7,7,7,7,6,5,3,8,3,6
+Y,4,11,5,8,2,6,10,1,3,7,12,8,1,11,0,8
+M,4,8,6,6,7,7,6,5,5,7,7,10,10,5,2,8
+M,7,9,10,7,8,6,7,3,5,9,8,9,10,7,3,8
+B,3,7,5,5,4,8,8,6,6,7,6,5,2,8,7,10
+I,3,9,4,7,2,7,9,0,8,14,6,5,0,9,2,7
+N,6,9,8,5,3,8,7,3,4,13,4,8,5,8,0,7
+Y,4,6,4,4,2,5,9,2,8,9,10,5,1,11,4,4
+K,5,9,6,7,2,4,7,9,2,7,6,12,4,8,3,11
+B,6,9,8,6,6,11,5,2,7,11,3,7,4,7,5,11
+T,2,4,3,3,1,5,13,3,6,11,9,4,1,11,1,5
+F,4,7,6,5,2,6,11,2,6,13,7,4,1,10,2,7
+Q,6,7,8,6,6,7,4,4,5,7,4,8,4,5,6,7
+A,7,11,7,6,4,10,1,4,2,11,6,14,4,5,5,11
+X,4,9,7,7,5,8,8,3,9,5,6,5,5,9,8,8
+D,6,9,6,4,3,8,5,4,5,9,4,7,4,7,5,10
+B,5,11,7,8,6,9,8,4,7,10,4,6,2,8,6,10
+L,4,9,5,8,5,8,7,3,6,6,7,9,3,8,7,8
+E,5,12,4,6,3,7,7,4,5,10,6,8,3,9,8,9
+B,2,7,3,5,2,6,7,9,6,7,6,7,2,8,8,9
+S,5,8,6,6,4,9,8,4,8,10,2,7,2,7,4,10
+R,2,4,4,3,2,8,7,3,4,9,4,7,2,7,3,10
+T,5,7,5,5,3,7,10,2,8,11,9,4,1,11,3,5
+R,2,4,3,3,3,7,8,5,5,7,5,7,2,6,4,8
+X,4,9,6,7,5,8,8,3,8,5,6,5,4,10,8,7
+B,1,3,3,2,2,8,7,2,4,10,5,7,2,8,3,9
+F,1,1,1,1,0,3,12,4,3,11,9,6,0,8,2,7
+P,5,4,6,6,7,8,8,3,3,6,8,7,5,10,5,5
+K,6,7,8,5,4,4,8,3,7,11,10,11,3,8,3,6
+B,5,8,7,6,5,10,6,3,7,10,4,7,2,8,5,11
+Q,5,11,5,6,4,9,5,4,7,11,4,8,3,8,8,11
+O,3,7,4,5,3,8,7,6,4,9,5,8,3,8,3,8
+K,4,5,4,7,2,3,8,8,2,7,4,11,4,8,3,10
+U,5,9,4,4,2,7,6,4,5,4,8,7,5,8,2,7
+K,5,10,7,7,6,10,6,1,6,10,3,8,6,8,5,12
+K,7,9,10,7,6,9,6,2,7,10,3,8,7,8,6,10
+G,2,1,3,1,1,6,7,5,5,6,6,9,2,9,4,8
+O,9,14,6,8,4,7,6,5,6,8,3,8,6,8,6,8
+U,5,10,7,8,4,6,9,6,7,7,10,10,3,9,1,8
+B,4,6,7,5,6,6,9,5,6,8,7,8,6,9,7,7
+X,4,9,7,6,4,11,6,1,8,10,1,6,2,8,3,10
+U,2,7,3,5,2,7,5,12,4,7,11,8,3,9,0,8
+L,5,10,6,8,3,4,4,2,11,3,1,8,0,7,2,5
+Y,3,6,5,4,2,7,10,2,7,6,12,9,2,11,2,8
+H,5,9,7,7,6,6,8,3,6,10,8,8,3,9,3,7
+J,2,8,3,6,2,8,7,2,6,11,5,9,1,6,2,5
+I,2,6,2,4,1,7,8,0,8,14,6,8,0,8,1,7
+H,4,7,5,5,4,8,8,6,7,6,5,9,3,8,3,8
+B,8,14,6,8,5,7,8,5,6,10,5,8,6,6,8,11
+T,4,9,6,7,3,6,12,3,8,8,12,8,1,11,1,7
+R,8,12,8,6,6,7,7,3,5,8,4,8,7,8,7,8
+D,3,4,4,3,2,7,7,6,7,7,6,5,2,8,3,7
+M,4,7,5,5,3,8,7,12,1,7,9,8,8,6,0,8
+X,2,1,2,1,0,8,7,4,4,7,6,8,3,8,4,8
+N,3,5,5,3,2,6,8,2,4,11,7,7,5,8,0,7
+E,5,10,4,5,2,6,9,5,7,10,7,9,1,9,7,8
+W,7,10,7,5,3,3,9,2,1,9,10,8,8,12,1,6
+A,3,11,6,8,4,11,4,2,3,9,2,9,3,7,3,8
+C,5,9,7,6,4,7,7,8,7,7,6,9,4,8,4,9
+I,2,8,2,6,2,7,7,0,7,7,6,8,0,8,3,8
+V,5,6,5,4,3,3,11,2,3,10,11,8,2,11,1,8
+X,7,9,8,8,9,8,8,2,5,7,6,7,4,7,8,8
+A,5,9,6,7,4,7,4,3,1,7,2,8,3,8,3,8
+X,3,4,5,3,2,10,7,2,8,11,3,7,2,8,3,9
+E,7,11,5,6,3,6,9,6,8,10,7,8,1,9,7,8
+B,2,6,3,4,3,7,6,8,5,6,7,7,2,9,7,9
+X,8,15,8,8,5,4,9,3,8,11,11,9,4,9,3,5
+T,5,7,7,6,7,7,8,4,8,7,7,8,3,9,8,7
+S,3,4,4,6,2,8,7,6,9,4,6,7,0,8,9,8
+S,2,4,4,3,2,8,7,2,6,10,5,7,1,9,5,8
+E,1,3,3,2,1,6,8,2,7,11,7,9,1,8,4,9
+B,5,9,7,6,6,7,8,6,6,9,7,5,3,7,8,7
+S,6,12,5,6,3,7,3,3,5,7,2,7,3,6,5,8
+M,4,5,7,3,4,9,6,3,5,9,4,7,10,6,2,8
+J,4,10,6,8,3,8,6,3,7,15,6,10,1,6,1,7
+S,6,11,6,6,3,6,8,5,3,13,9,8,3,10,3,8
+C,5,5,6,8,2,6,7,7,11,6,6,14,1,8,4,9
+P,8,11,7,6,4,6,11,4,5,13,6,3,4,9,6,5
+F,4,7,6,5,5,7,9,6,5,8,6,8,3,10,8,10
+W,4,5,7,4,4,7,11,3,2,6,9,8,8,11,1,8
+L,4,11,6,8,9,7,7,3,5,7,7,10,7,11,8,5
+K,2,1,2,2,1,5,7,8,1,7,6,11,3,8,2,11
+L,3,9,4,6,2,0,2,4,6,1,0,8,0,8,0,8
+U,4,6,5,4,4,8,6,7,5,7,6,9,3,8,4,6
+S,7,11,10,8,11,9,3,4,4,9,6,10,6,6,11,11
+X,4,8,6,6,4,8,8,3,8,6,5,6,4,9,7,8
+N,4,5,5,4,3,7,9,5,5,7,7,7,5,9,2,6
+P,4,7,4,4,2,4,12,8,2,10,6,4,1,10,4,8
+T,3,7,5,5,4,6,7,7,6,7,10,9,3,9,4,8
+T,2,6,3,4,2,7,12,2,7,7,11,8,1,11,1,8
+U,3,5,4,4,3,8,6,4,3,5,7,7,3,9,1,7
+B,8,11,6,6,4,9,6,6,6,11,4,9,6,6,6,10
+M,5,11,6,9,4,7,7,12,2,7,9,8,9,6,0,8
+J,5,11,7,9,4,9,7,2,6,14,3,7,0,7,0,7
+W,4,9,6,7,10,8,6,6,2,7,6,8,8,11,3,9
+Q,5,10,7,9,4,8,5,9,8,5,4,8,3,8,4,8
+W,6,9,9,7,6,8,8,4,1,7,9,8,7,11,0,8
+J,2,9,3,7,1,12,2,10,4,13,6,13,1,6,0,8
+D,5,10,5,5,4,7,7,4,6,8,5,7,5,10,6,6
+O,1,3,2,1,1,8,7,5,3,9,6,8,2,8,2,8
+Q,1,0,2,1,1,8,7,6,4,6,6,9,2,8,3,8
+H,7,10,7,5,3,8,7,4,4,9,7,7,6,10,5,9
+R,2,3,2,2,2,6,8,4,5,7,6,7,2,7,3,9
+T,5,9,6,6,5,6,7,7,7,7,8,8,3,11,6,9
+U,6,6,6,8,3,7,4,15,5,7,14,8,3,9,0,8
+K,3,2,4,4,3,5,7,4,7,6,6,10,3,8,5,9
+L,6,10,5,5,2,6,5,3,7,10,4,13,2,6,6,8
+G,5,9,6,7,3,6,7,7,7,10,8,10,2,9,4,9
+X,2,6,3,4,2,7,7,4,4,7,6,7,2,8,4,8
+Y,2,4,3,3,1,4,11,2,7,11,10,5,1,11,2,5
+I,3,11,3,8,4,7,7,0,8,7,6,8,0,8,3,8
+N,4,7,6,5,3,7,8,3,4,10,6,7,5,8,1,7
+Y,4,7,6,10,10,8,5,4,2,8,8,9,5,9,6,8
+M,2,1,3,1,2,6,6,6,4,7,7,10,6,5,2,9
+E,2,1,3,2,2,7,8,5,7,7,6,9,2,8,5,10
+M,4,4,6,3,3,7,6,3,4,9,7,8,7,5,2,8
+A,3,5,5,4,2,6,3,2,2,5,2,7,3,4,3,8
+R,5,9,7,7,4,10,7,3,6,11,2,6,3,7,4,10
+H,9,12,9,7,6,10,6,4,5,11,2,7,6,7,5,8
+I,1,6,0,8,1,7,7,4,4,7,6,8,0,8,0,8
+A,2,4,3,3,1,11,3,3,2,11,2,9,2,6,2,9
+Z,4,9,5,6,5,7,7,5,9,7,6,8,1,8,7,8
+S,4,9,5,6,5,7,6,7,6,6,8,10,2,11,9,7
+C,4,7,4,5,3,4,8,5,6,9,8,14,2,7,3,8
+R,6,11,9,8,7,9,8,4,7,9,3,8,4,5,4,11
+D,7,13,6,7,4,10,4,4,5,12,2,8,5,6,4,9
+L,4,10,4,8,1,0,1,6,6,0,0,6,0,8,0,8
+V,3,7,5,5,1,7,8,4,2,7,14,8,3,10,0,8
+P,8,9,6,4,3,9,7,5,5,13,3,5,5,9,4,8
+G,2,6,3,4,2,7,6,6,6,7,3,10,1,8,4,10
+H,5,10,5,7,3,7,10,15,2,7,3,8,3,8,0,8
+U,7,11,7,8,5,4,8,5,8,10,9,9,3,9,2,6
+Z,3,5,4,7,2,7,7,4,13,10,6,8,0,8,8,8
+S,5,11,6,9,6,8,7,8,5,7,6,7,2,8,9,8
+I,4,11,5,8,3,7,7,0,8,14,6,8,0,8,1,8
+C,6,11,8,8,6,7,6,9,6,8,6,11,4,9,4,8
+C,4,9,5,7,2,5,7,7,10,7,6,14,1,8,4,9
+X,3,6,5,4,3,8,7,4,9,6,6,6,3,8,6,7
+N,6,11,9,9,5,12,7,4,5,10,0,4,6,8,2,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+O,3,5,4,3,3,7,7,7,5,9,6,8,2,8,3,8
+O,4,6,5,5,4,7,6,4,4,6,3,6,2,7,4,7
+L,2,6,3,4,2,4,3,8,7,1,2,4,1,6,1,6
+V,4,5,5,3,2,4,13,4,3,11,11,6,3,10,1,8
+G,5,9,4,4,2,11,3,2,3,9,2,6,4,7,3,10
+B,3,6,5,5,5,6,8,6,4,7,6,8,6,9,7,8
+N,2,2,3,3,2,7,8,6,4,7,6,7,4,9,2,6
+S,6,13,6,7,3,7,6,3,4,13,7,9,3,9,3,8
+Z,4,6,6,4,4,9,9,5,4,7,5,7,3,8,9,5
+B,3,5,5,3,4,8,7,3,6,9,6,6,2,8,5,9
+I,2,7,3,5,3,9,6,1,4,8,5,5,3,8,5,7
+S,1,0,1,0,0,8,7,3,6,5,6,7,0,8,7,8
+D,7,11,7,6,4,10,4,5,6,12,3,9,5,6,5,10
+O,6,9,7,7,5,7,8,8,6,10,7,9,3,8,3,8
+E,1,0,1,1,1,5,8,5,8,7,6,12,0,8,6,9
+P,3,5,6,4,3,8,10,3,4,12,4,3,1,10,3,8
+U,6,9,7,7,4,4,8,6,8,10,10,9,3,9,2,5
+X,5,5,6,8,2,7,7,5,4,7,6,8,3,8,4,8
+A,3,8,5,6,3,12,2,3,2,11,2,9,2,6,3,9
+Q,5,8,5,9,7,8,7,7,3,8,6,9,3,9,6,7
+Q,2,0,2,1,1,8,7,7,4,6,6,8,2,8,3,8
+G,8,13,7,7,4,7,3,6,2,6,5,4,4,7,5,7
+L,5,9,7,7,4,5,4,2,9,6,2,8,1,6,3,6
+K,6,9,5,4,2,8,8,3,7,8,4,7,5,7,3,7
+X,4,4,6,3,3,7,7,1,8,11,7,9,2,8,3,8
+J,2,8,2,6,1,15,4,3,5,12,1,7,0,8,0,8
+E,2,2,3,3,2,7,8,5,7,7,6,9,2,8,5,10
+W,8,11,8,6,5,5,8,2,4,8,9,7,10,10,2,5
+P,4,9,6,7,3,6,13,5,2,12,5,1,1,10,3,8
+G,6,11,6,8,5,6,6,6,6,10,6,13,4,9,6,8
+N,4,5,5,4,5,7,8,4,3,6,5,8,6,8,4,7
+P,11,15,8,8,4,8,9,7,5,14,4,4,4,10,4,8
+X,3,4,5,3,2,9,6,1,8,10,4,8,2,8,3,9
+Q,4,5,5,6,4,7,9,5,3,7,9,11,3,9,6,8
+I,1,4,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+J,2,4,3,7,1,12,3,9,4,13,5,12,1,6,0,8
+B,5,4,5,6,4,6,7,9,7,7,6,7,2,8,9,10
+D,4,11,4,8,3,5,6,11,8,5,4,5,3,8,4,8
+B,6,11,8,8,8,7,8,6,4,7,5,6,5,7,7,8
+Z,2,1,2,1,1,7,7,5,8,6,6,8,1,8,6,8
+D,2,4,3,3,2,9,6,3,5,10,4,5,2,8,3,8
+B,5,11,7,8,8,8,8,8,6,7,5,5,4,6,9,12
+F,4,7,5,5,5,7,9,5,4,8,6,8,3,10,8,10
+C,3,5,4,4,2,4,8,5,7,11,9,12,1,9,3,7
+N,4,9,5,7,5,7,7,13,1,7,6,8,5,8,0,7
+G,8,10,6,5,3,8,5,4,4,9,4,6,4,7,5,8
+R,7,11,6,6,4,8,8,5,5,9,4,9,7,5,6,11
+W,4,8,6,6,5,6,10,2,2,7,9,8,7,10,1,8
+B,2,6,4,4,3,8,8,5,7,7,6,6,2,8,6,9
+I,1,9,2,7,3,8,7,0,7,7,6,7,0,8,2,7
+X,6,8,7,7,8,6,7,2,5,8,7,10,4,10,8,6
+C,2,2,3,4,2,6,8,7,7,8,8,14,1,9,4,10
+E,2,2,3,3,3,7,7,5,7,7,7,9,2,8,5,10
+X,4,4,6,3,3,6,7,1,8,10,8,8,2,8,3,7
+U,3,6,4,4,1,7,5,13,5,7,14,8,3,9,0,8
+L,1,3,3,2,1,6,5,2,9,7,2,10,0,7,2,8
+M,4,8,4,6,3,8,7,12,1,6,9,8,8,6,0,8
+R,2,6,4,4,4,8,7,3,4,7,6,8,6,8,6,7
+F,4,7,6,5,4,6,10,2,5,13,7,5,2,10,2,7
+Y,4,8,7,6,3,7,10,1,8,6,12,9,3,9,2,8
+G,4,10,5,8,3,7,6,8,8,6,5,10,2,8,6,11
+T,2,3,3,4,1,10,14,1,6,4,11,9,0,8,0,8
+I,1,7,0,5,0,7,7,5,3,7,6,8,0,8,0,8
+X,2,3,4,1,2,6,7,2,8,11,8,8,2,8,3,7
+T,2,8,3,6,1,7,13,0,6,7,11,8,0,8,0,8
+I,4,9,5,7,3,7,8,0,7,13,6,7,0,8,1,7
+T,7,13,6,8,4,7,8,2,7,12,6,7,3,8,5,5
+V,5,9,5,7,2,3,12,4,4,10,12,7,3,10,1,8
+D,6,9,6,5,3,8,6,5,6,10,4,6,4,7,6,10
+U,3,7,4,5,4,8,6,7,5,7,6,8,3,8,4,5
+N,3,6,3,4,3,7,7,11,1,6,6,7,5,9,0,8
+T,4,11,6,8,5,7,11,3,6,7,11,8,2,12,1,8
+D,2,4,3,3,2,9,7,4,5,9,4,5,2,8,2,8
+O,5,9,7,6,4,7,7,9,4,7,6,8,3,8,3,7
+K,8,10,8,5,5,8,7,4,6,11,2,8,6,5,4,8
+W,3,8,5,6,4,6,10,2,3,7,9,8,7,11,0,8
+Q,4,7,5,6,2,8,8,7,6,5,8,9,3,7,5,10
+W,3,4,5,3,3,7,11,2,2,6,9,8,6,11,0,8
+N,8,12,9,6,4,10,5,3,4,13,2,7,5,7,0,7
+C,2,1,2,1,1,6,7,6,10,7,6,14,0,8,4,9
+X,3,6,5,4,3,7,7,1,8,10,6,8,2,8,3,7
+B,3,10,4,8,6,6,7,8,5,7,6,7,2,8,7,9
+I,4,9,4,4,2,8,8,2,4,12,5,6,1,10,5,11
+K,5,10,8,8,9,6,6,4,4,6,5,9,8,7,8,8
+L,4,8,5,6,3,4,5,1,9,7,2,11,0,7,3,7
+V,3,9,4,7,3,9,9,3,1,6,12,8,3,10,1,8
+M,4,4,5,2,3,8,6,6,4,6,7,8,8,6,2,7
+V,5,10,5,8,4,3,11,2,3,9,11,8,2,11,1,8
+T,7,9,8,8,8,6,8,3,9,8,7,9,3,8,8,6
+C,2,5,3,3,1,4,8,4,7,11,9,12,1,9,2,7
+L,2,5,3,3,1,3,4,3,8,2,1,7,0,7,1,6
+G,4,5,5,4,3,7,6,6,6,6,6,10,2,9,4,8
+Z,7,7,5,11,4,7,8,5,3,11,7,7,2,9,10,6
+S,5,7,6,5,3,8,8,4,9,11,3,8,2,6,4,10
+V,5,9,5,7,3,4,12,1,2,8,10,7,3,10,1,7
+X,5,6,6,5,6,6,7,2,5,8,7,10,3,8,7,8
+Y,6,11,10,8,5,6,10,2,8,6,12,9,5,10,4,7
+V,3,7,5,5,3,8,12,2,3,5,10,9,4,12,3,7
+M,5,11,6,8,4,8,7,12,2,6,9,8,9,6,0,8
+T,3,11,5,8,1,8,15,0,6,7,11,8,0,8,0,8
+C,4,7,5,5,4,7,7,8,5,6,7,13,4,7,4,8
+B,5,10,7,8,7,9,7,3,5,9,5,6,2,8,5,9
+M,4,4,6,3,4,6,6,3,4,10,9,9,7,6,2,9
+N,6,9,8,6,6,6,7,8,6,7,5,7,3,8,3,9
+M,5,5,6,4,4,8,6,6,5,7,7,8,8,6,2,7
+N,7,9,10,6,5,4,10,3,4,10,9,9,7,7,2,7
+L,7,15,7,8,4,7,5,4,5,12,9,11,3,9,6,9
+J,5,6,6,7,5,7,7,4,7,7,6,7,3,8,8,8
+Z,3,7,4,5,2,7,7,4,13,9,6,8,0,8,8,8
+G,2,1,2,1,1,8,6,6,6,6,5,9,1,7,5,10
+E,7,10,5,5,4,7,8,4,4,10,5,9,3,8,9,11
+O,3,6,4,4,2,7,7,7,5,10,6,9,3,8,3,8
+Q,8,12,7,7,4,8,5,4,9,10,5,9,3,7,9,10
+V,7,10,6,6,3,9,9,6,4,6,10,6,6,12,3,8
+O,5,5,6,7,3,7,7,9,8,7,6,8,3,8,4,8
+Q,5,7,6,7,5,8,8,7,4,6,6,10,3,8,4,8
+P,9,11,7,6,3,8,9,6,4,12,3,5,5,10,4,8
+N,4,8,5,6,4,7,7,12,1,6,6,8,5,8,0,8
+Q,5,7,6,8,6,9,8,6,2,4,8,10,3,9,7,10
+P,6,9,5,4,2,6,10,5,3,11,5,5,5,9,4,8
+W,3,2,5,3,3,5,11,3,2,8,9,9,8,13,1,8
+B,4,7,5,5,4,9,7,5,8,7,6,5,2,8,6,9
+X,7,10,8,5,4,6,8,2,8,11,6,9,4,7,4,6
+O,4,7,5,5,3,7,7,7,6,7,6,7,2,8,3,8
+U,5,11,5,8,2,8,5,14,5,6,14,8,3,9,0,8
+L,4,10,5,7,3,5,3,7,7,2,2,4,1,6,1,5
+Y,2,6,3,4,0,9,10,2,2,6,12,8,1,11,0,8
+J,5,11,6,8,3,8,9,1,7,14,5,6,0,9,1,8
+H,7,9,10,6,8,11,6,3,7,10,2,6,5,7,4,10
+H,1,0,1,0,0,7,8,10,1,7,5,8,2,8,0,8
+I,2,4,3,3,1,7,6,0,7,13,7,10,0,8,1,8
+V,7,10,7,8,4,4,11,2,4,8,11,7,5,11,1,7
+S,6,9,5,5,2,8,3,4,4,7,2,7,3,6,5,8
+B,4,2,4,3,4,8,7,5,6,7,6,6,5,8,6,10
+P,3,6,5,8,7,8,9,5,0,8,7,6,5,10,5,8
+U,4,7,4,5,3,7,5,13,5,7,11,8,3,9,0,8
+V,3,6,5,4,2,7,12,2,3,6,11,8,2,10,1,8
+V,5,8,5,6,2,2,11,6,4,13,12,8,2,10,1,7
+V,5,10,5,8,3,3,11,2,3,9,11,8,3,11,1,7
+A,3,8,5,6,3,12,3,3,2,11,1,9,2,6,2,9
+Z,6,9,8,7,6,9,9,5,4,6,5,7,3,9,10,5
+D,7,14,7,8,4,10,4,5,5,13,3,10,5,7,4,9
+Z,5,7,4,10,4,6,9,5,3,12,7,6,3,9,10,6
+M,5,6,7,5,8,7,7,4,4,7,6,8,10,8,5,6
+O,7,10,5,5,3,7,8,5,5,9,5,6,4,9,5,8
+H,4,7,6,5,4,10,5,4,6,10,2,7,3,8,3,9
+X,5,6,7,8,2,7,7,5,4,7,6,8,3,8,4,8
+Y,7,9,8,6,5,5,9,1,8,9,10,5,3,11,4,4
+W,2,1,4,2,2,9,11,3,2,5,9,8,5,11,0,8
+N,4,6,5,4,3,8,7,8,6,7,4,5,3,7,3,7
+K,7,9,10,7,5,5,9,2,8,10,9,10,3,8,4,5
+T,3,10,4,7,1,7,14,0,6,7,11,8,0,8,0,8
+V,2,7,4,5,2,9,9,3,1,5,12,8,2,11,0,8
+Y,4,6,4,4,2,4,9,3,6,10,11,6,2,11,2,5
+Q,5,10,6,9,6,8,7,7,5,6,6,9,3,8,5,8
+V,4,6,4,4,2,3,12,4,3,10,11,7,2,10,1,8
+P,2,1,3,1,1,5,9,4,4,9,7,4,1,9,3,7
+F,4,7,6,5,3,6,10,1,6,13,7,5,1,10,2,7
+N,4,8,6,6,5,6,8,9,5,8,6,6,4,8,3,9
+A,4,9,6,7,4,12,3,3,2,10,1,9,2,7,3,8
+Q,6,11,6,6,4,9,5,4,6,10,5,8,3,9,8,10
+X,2,3,4,2,1,7,7,1,8,10,6,8,2,8,3,8
+Z,7,10,9,8,8,9,8,5,4,7,5,7,4,8,9,4
+P,6,10,6,7,3,5,10,10,6,8,5,5,2,10,4,8
+S,7,11,9,8,5,9,6,3,8,11,5,8,2,10,6,9
+S,6,11,6,6,3,6,8,5,3,13,9,8,3,10,3,8
+N,4,5,5,8,3,7,7,14,2,4,6,8,6,8,0,8
+B,4,6,5,4,4,8,8,4,6,10,5,6,3,8,6,10
+S,7,15,5,8,3,8,3,4,4,9,2,8,4,6,5,9
+K,7,11,10,9,7,6,7,2,7,10,7,10,4,8,4,7
+C,2,4,2,2,1,4,8,5,7,11,9,12,1,9,3,8
+C,4,8,5,6,3,5,8,7,8,9,8,14,1,9,4,9
+C,2,3,3,2,1,4,8,3,6,11,9,12,1,9,2,7
+J,4,10,5,8,3,11,4,5,5,15,3,9,0,7,0,8
+I,4,10,5,8,2,7,6,0,9,14,6,9,0,8,1,8
+C,4,8,5,6,2,6,7,7,10,8,6,13,1,9,4,8
+A,2,7,4,5,2,9,3,2,2,8,1,8,2,6,3,8
+C,6,8,7,6,4,5,8,6,7,12,8,10,3,12,3,6
+P,3,7,3,4,2,4,10,9,3,9,6,5,2,10,3,8
+J,3,4,4,5,3,8,8,4,5,7,6,8,3,8,8,9
+L,5,10,6,7,5,4,4,4,8,2,1,6,1,6,1,5
+K,4,7,6,5,4,4,7,2,6,10,9,11,3,8,3,8
+X,2,3,4,2,2,9,7,2,8,11,3,7,2,7,2,8
+G,1,3,2,2,1,6,7,5,5,9,7,10,2,8,4,10
+U,4,7,6,5,7,8,8,4,4,6,8,8,8,9,5,7
+F,3,7,4,4,1,2,12,5,6,12,10,8,0,8,2,6
+P,4,9,4,6,2,5,11,10,3,10,6,4,1,10,4,8
+V,3,7,5,5,2,9,9,4,1,6,12,8,3,9,1,7
+J,2,7,3,5,2,11,7,0,7,10,3,6,0,8,1,7
+I,3,8,4,6,2,6,8,0,8,14,7,8,0,8,1,7
+N,5,10,5,7,5,7,7,13,1,6,6,8,6,9,1,6
+Q,7,9,7,10,8,8,9,7,2,7,7,11,4,10,8,6
+U,5,11,6,8,2,8,5,14,5,6,14,9,3,9,0,8
+V,4,10,6,7,3,5,9,5,2,8,13,8,3,10,0,8
+G,2,7,3,5,2,7,7,7,5,6,6,9,2,8,5,11
+S,4,6,5,5,5,8,8,4,5,7,7,8,5,9,8,11
+S,6,11,9,8,12,7,5,3,3,8,5,8,4,8,15,8
+F,6,10,5,5,4,8,10,3,5,11,5,4,3,10,7,7
+X,5,10,7,8,4,7,7,1,8,10,6,8,3,8,4,7
+T,6,8,6,6,4,4,13,5,5,11,9,4,2,12,1,5
+T,6,10,6,8,4,5,12,4,6,12,9,4,2,12,2,4
+F,7,14,6,8,3,8,8,3,6,12,4,5,2,8,7,7
+U,3,7,5,5,2,7,8,6,7,6,10,9,3,9,1,7
+A,5,9,7,7,5,8,3,1,2,6,2,7,3,5,4,7
+U,3,7,3,5,1,7,6,13,5,8,13,8,3,9,0,8
+T,4,10,5,7,4,8,10,0,8,6,11,8,0,10,1,8
+R,4,4,4,5,3,5,12,8,4,7,3,9,3,7,6,11
+Q,6,12,6,6,4,10,5,4,6,11,4,8,3,8,8,11
+J,3,6,4,4,1,7,6,3,6,14,7,11,1,6,1,7
+Z,2,6,3,4,1,7,7,3,13,9,6,8,0,8,7,8
+X,4,8,5,7,6,7,8,1,5,7,6,7,3,5,8,7
+B,9,15,9,8,8,8,7,4,5,9,5,7,8,4,10,7
+P,6,7,8,9,10,9,9,3,3,6,9,6,6,10,7,4
+S,3,5,3,3,2,8,7,7,5,8,6,8,2,9,9,8
+I,1,6,0,4,0,7,7,5,3,7,6,8,0,8,0,8
+B,4,9,5,6,6,7,7,6,6,6,6,6,2,8,6,9
+U,7,8,7,6,3,3,10,6,7,13,12,9,3,9,1,7
+H,3,6,4,4,5,9,8,4,3,6,6,7,6,9,6,6
+W,6,7,6,5,5,5,11,3,2,9,8,7,6,12,2,6
+N,9,10,8,5,3,6,10,4,5,4,5,11,6,11,2,7
+C,4,5,6,7,2,5,6,6,11,7,5,12,1,9,4,8
+D,7,13,6,7,5,6,7,5,6,8,5,7,5,10,6,5
+U,6,10,8,8,5,6,9,5,7,6,9,10,6,10,1,7
+Y,5,6,4,9,3,7,8,3,2,7,10,5,4,10,5,6
+Q,4,8,5,9,6,7,8,6,3,8,9,9,4,10,6,7
+H,2,1,2,1,2,8,8,5,5,7,6,8,3,8,2,7
+X,3,8,5,6,4,7,7,3,8,5,6,10,3,7,6,8
+T,5,10,5,7,3,6,11,3,7,11,9,4,2,12,3,4
+N,2,1,3,2,2,7,8,5,4,7,7,6,5,9,2,6
+N,6,8,8,6,4,4,10,4,4,11,11,10,5,8,1,7
+K,12,15,11,8,5,4,8,4,7,10,10,11,6,9,3,6
+L,5,8,6,7,5,8,6,5,5,7,7,9,3,9,8,8
+M,7,9,10,7,7,8,6,3,5,9,7,8,8,5,2,8
+E,1,1,2,2,1,4,7,5,8,7,6,13,0,8,6,9
+K,4,5,7,3,4,3,8,3,7,11,10,11,3,8,3,6
+D,4,7,4,5,2,5,8,10,9,8,7,6,3,8,4,8
+N,6,10,8,7,5,6,10,2,4,9,7,7,5,9,1,8
+B,7,10,9,8,8,10,6,3,7,10,3,7,5,7,6,11
+J,1,3,2,2,1,11,6,1,6,11,3,7,0,7,0,8
+I,0,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+Y,8,10,6,14,5,9,8,4,3,5,11,5,5,10,7,7
+O,7,9,9,8,7,8,4,4,5,9,4,9,4,6,5,7
+C,3,4,4,3,2,6,8,8,8,8,7,12,2,9,4,10
+D,5,11,5,8,3,5,7,11,9,6,6,5,3,8,4,8
+L,2,5,4,4,2,7,4,1,8,8,2,10,0,7,2,8
+A,3,4,5,3,2,10,2,2,1,8,2,9,4,5,2,9
+V,3,4,4,3,2,5,12,2,2,9,10,7,2,11,1,8
+F,2,4,3,3,1,6,10,2,5,13,7,5,1,10,1,7
+X,3,5,5,5,4,8,8,2,5,8,6,8,3,8,7,8
+P,5,8,7,6,4,5,13,6,3,13,6,1,0,10,4,8
+L,3,7,3,5,1,0,1,6,6,0,0,6,0,8,0,8
+R,4,10,5,8,3,5,10,9,3,7,5,8,3,8,6,11
+R,1,0,1,0,0,6,9,7,3,7,4,8,2,6,4,10
+X,2,1,2,1,0,7,7,4,4,7,6,8,3,8,4,8
+G,9,13,8,8,4,8,3,4,3,8,4,5,4,7,5,9
+Q,1,2,2,3,2,8,8,5,2,8,6,8,2,9,2,8
+Z,2,5,4,4,2,7,8,2,9,11,6,8,1,8,6,8
+K,5,9,7,7,5,9,7,2,7,10,3,8,4,9,4,10
+T,5,8,6,7,5,5,7,3,8,8,7,10,3,4,8,5
+J,1,4,3,3,1,9,5,3,6,14,5,10,0,7,0,8
+U,3,8,5,6,3,4,10,7,6,10,10,9,3,9,1,8
+R,2,4,2,3,2,7,7,5,5,6,5,7,2,7,4,8
+Q,3,4,4,5,3,8,8,6,2,5,7,10,3,9,6,10
+O,4,5,6,8,3,6,6,9,8,6,5,6,3,8,4,8
+N,3,4,6,3,2,8,9,3,5,10,4,5,5,9,1,7
+F,5,10,5,7,2,1,12,5,5,12,11,8,0,8,2,5
+M,8,8,11,7,12,8,8,4,4,7,6,7,12,7,8,3
+V,2,7,4,5,2,7,11,3,4,7,11,8,2,10,1,8
+S,3,8,4,6,3,7,7,7,5,7,6,8,2,8,8,7
+C,4,6,5,4,2,4,8,6,9,10,10,12,1,8,3,7
+U,3,6,3,4,1,7,5,13,5,7,13,8,3,9,0,8
+M,6,7,9,6,10,7,6,4,4,7,6,8,12,9,5,5
+A,3,8,5,6,5,8,8,6,4,6,6,8,3,7,6,4
+N,3,5,5,3,2,6,9,2,4,10,7,7,5,8,1,8
+M,5,8,6,6,7,7,9,6,4,6,6,8,9,9,8,10
+S,3,7,4,5,3,7,7,5,7,5,6,10,0,9,8,7
+H,6,11,6,8,3,7,5,15,1,7,9,8,3,8,0,8
+V,4,7,4,5,2,2,12,3,3,11,11,8,2,10,1,8
+M,7,11,8,8,7,7,5,12,1,8,8,8,10,5,2,10
+R,7,13,7,7,6,5,9,3,5,7,4,9,6,7,6,6
+G,3,7,4,5,3,7,7,7,6,7,5,11,1,8,4,10
+O,2,3,3,2,1,8,7,6,4,9,6,9,2,8,3,8
+J,3,7,5,8,5,9,8,4,4,7,6,9,3,7,8,6
+F,4,9,6,7,7,7,9,1,5,9,6,5,3,9,4,3
+D,2,3,2,1,1,7,7,6,6,7,6,5,2,8,2,7
+X,2,3,4,2,2,7,7,3,9,6,6,8,2,8,5,8
+T,2,4,3,2,1,8,11,2,7,6,11,8,1,10,1,8
+M,5,7,5,5,4,7,5,11,0,8,8,8,8,5,1,10
+Q,6,10,8,7,7,8,5,7,4,5,7,10,6,6,8,9
+K,2,6,3,4,1,3,7,7,3,7,7,11,3,8,2,10
+M,5,7,7,6,7,5,8,5,3,6,5,8,9,7,5,7
+E,2,5,4,3,2,6,7,1,8,11,6,9,2,8,4,8
+F,4,8,5,6,5,7,9,6,4,8,5,8,3,11,9,10
+U,10,12,8,6,4,6,5,5,6,3,8,7,5,9,2,6
+H,6,8,9,6,5,8,7,3,6,10,5,7,3,8,3,7
+P,1,1,2,1,0,5,11,7,2,9,6,4,1,9,3,8
+L,9,13,7,7,4,9,2,4,4,12,5,13,2,7,6,9
+F,3,7,4,5,4,6,9,2,6,9,9,6,1,10,4,7
+M,6,11,8,6,5,10,3,4,2,10,2,9,9,1,1,8
+K,6,10,9,8,8,10,5,2,6,9,2,7,8,6,7,12
+W,3,4,4,3,2,5,10,3,2,9,8,7,6,11,1,6
+R,5,4,5,7,3,5,10,9,3,7,5,8,3,8,6,11
+J,1,3,2,2,1,11,6,2,6,11,3,7,0,7,0,8
+G,6,9,6,6,4,6,7,6,6,9,7,12,2,9,4,9
+Z,4,9,5,7,4,9,6,6,10,7,5,6,1,7,8,8
+O,3,2,4,3,3,7,7,7,5,7,6,8,2,8,3,8
+H,2,3,3,2,2,7,8,5,6,7,6,8,3,8,2,8
+W,6,8,6,6,4,5,11,3,3,9,8,7,7,11,2,6
+G,5,9,7,7,5,5,6,7,7,7,5,13,4,9,5,8
+T,3,2,4,4,2,7,12,3,6,7,11,8,2,11,1,7
+M,1,0,2,1,1,7,6,9,0,7,8,8,6,6,0,8
+K,2,3,4,1,2,4,8,2,6,10,10,11,2,8,2,6
+X,3,7,4,5,2,7,7,4,4,7,6,8,3,8,4,8
+P,10,15,8,8,4,7,9,6,3,11,4,5,5,9,4,7
+P,4,6,5,4,3,9,7,2,5,13,4,5,1,10,3,9
+Z,2,3,2,2,2,7,7,5,8,6,6,8,1,8,6,8
+J,2,2,3,4,1,10,6,2,7,12,4,9,1,6,1,7
+N,5,9,7,7,8,9,7,4,4,7,6,6,7,12,7,6
+G,3,4,4,3,2,6,7,5,5,9,7,10,2,8,4,10
+F,6,11,9,8,5,8,9,4,7,13,6,6,5,7,4,6
+M,7,10,10,8,7,5,6,3,5,9,9,9,8,5,2,8
+K,5,10,6,8,2,4,6,9,2,7,7,11,4,7,3,11
+Y,7,9,8,6,4,4,9,1,7,10,11,6,2,11,4,3
+T,5,10,5,5,2,5,11,2,7,12,8,5,2,9,4,3
+N,5,8,7,6,4,7,8,3,4,10,6,7,5,8,1,7
+X,5,11,8,8,4,11,5,2,8,10,0,7,3,8,4,10
+Y,8,6,6,9,4,7,8,4,3,6,11,5,4,11,6,6
+B,4,10,5,8,6,8,6,7,6,6,6,6,2,8,7,9
+V,5,7,7,5,7,6,7,4,2,9,7,8,7,10,5,7
+D,4,9,6,6,8,8,9,5,4,8,7,6,7,10,10,5
+Z,6,10,8,7,5,7,8,3,10,12,7,8,1,9,6,7
+H,5,5,7,7,6,7,5,4,2,7,5,6,5,8,8,8
+L,5,9,7,7,4,5,3,3,9,6,1,9,1,6,3,7
+P,4,9,5,6,2,4,14,8,1,11,6,3,1,10,4,8
+M,4,6,5,8,4,7,7,12,2,7,9,8,9,6,0,8
+X,2,2,3,3,2,8,7,3,8,6,6,8,2,8,5,9
+D,3,7,4,5,3,6,8,9,7,7,6,5,2,8,3,7
+I,2,5,3,4,1,7,7,0,8,13,6,8,0,8,1,8
+V,5,9,5,7,3,4,11,2,4,9,11,7,3,10,1,8
+U,3,8,4,6,2,7,5,14,5,7,13,8,3,9,0,8
+O,3,5,4,3,3,8,7,7,5,9,6,7,2,8,3,8
+H,4,8,4,5,2,7,7,15,1,7,6,8,3,8,0,8
+Y,8,10,8,7,3,4,10,2,8,11,11,5,1,11,3,3
+M,5,7,6,5,7,7,9,6,5,7,6,8,8,8,5,7
+X,6,9,8,8,9,7,7,2,5,7,6,8,4,8,8,8
+D,2,3,3,2,2,9,6,4,5,9,4,5,2,8,2,8
+F,5,11,5,8,2,1,13,5,4,12,11,7,0,8,2,5
+V,1,3,3,2,1,6,11,3,3,8,11,8,2,11,1,8
+J,2,6,3,4,1,12,2,9,4,13,5,13,1,6,0,8
+Y,3,9,4,7,2,6,10,1,3,8,12,8,1,11,0,8
+P,2,7,4,5,3,4,11,5,4,11,8,4,1,10,3,7
+P,7,14,7,8,5,8,9,4,4,12,5,4,4,11,6,6
+H,4,5,6,8,5,9,9,3,1,7,6,7,3,10,8,7
+Q,4,6,4,7,5,8,5,7,4,9,6,8,3,8,4,8
+V,6,11,6,8,3,4,11,3,4,9,11,7,2,10,1,8
+T,4,7,4,5,2,5,11,1,8,11,9,5,0,10,2,4
+K,7,11,10,8,6,4,9,2,8,10,10,10,3,8,4,6
+A,2,1,3,2,1,8,2,2,1,7,2,8,2,7,2,7
+H,7,9,10,7,8,6,8,2,6,10,8,8,4,10,4,7
+L,4,11,4,8,1,0,1,5,6,0,0,7,0,8,0,8
+G,2,3,4,2,2,7,7,6,5,6,6,9,2,9,4,9
+X,3,3,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+M,5,5,7,4,5,8,6,6,5,7,7,8,9,6,3,7
+V,6,9,8,7,9,7,5,5,3,8,7,9,8,9,6,9
+W,1,0,2,0,1,7,8,3,0,7,8,8,5,10,0,8
+Q,3,4,4,5,3,8,7,6,3,8,7,9,2,9,4,9
+O,2,1,2,2,1,8,7,7,5,7,6,8,2,8,3,8
+R,9,13,9,7,6,10,6,4,5,10,2,7,6,7,6,9
+V,5,7,5,5,2,2,11,4,3,11,12,8,2,10,0,8
+N,9,10,7,5,3,9,13,6,5,3,6,10,5,8,2,8
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+N,4,7,7,5,6,7,8,3,4,8,7,8,7,10,5,4
+M,7,11,10,8,11,7,7,5,5,6,7,9,8,6,2,8
+A,5,6,7,5,5,8,8,3,5,7,8,8,5,9,4,6
+B,4,9,6,6,6,8,7,4,5,9,6,6,3,9,5,8
+U,3,6,4,4,4,8,8,6,5,6,7,9,3,8,3,7
+K,2,4,3,3,2,5,7,4,6,6,6,11,3,8,4,10
+Q,1,0,2,1,0,8,7,6,3,6,6,9,2,8,3,8
+F,7,10,6,5,3,5,11,3,4,11,7,4,2,8,6,4
+Q,5,6,7,9,10,9,5,6,2,7,6,8,8,9,4,8
+B,1,0,2,0,1,7,8,6,4,7,6,7,1,8,6,8
+O,4,9,5,7,4,7,6,9,5,7,5,8,3,8,3,8
+S,3,8,4,6,3,8,8,7,7,8,5,6,2,8,9,8
+J,4,6,5,7,4,9,8,5,6,7,5,8,3,9,8,9
+Y,7,11,7,8,4,3,10,2,7,10,12,6,1,11,2,5
+F,5,10,6,8,7,7,6,6,4,8,6,8,6,10,7,11
+Z,5,7,4,10,4,9,5,5,5,11,5,7,3,9,8,10
+T,6,11,6,8,4,5,12,2,8,12,9,4,1,11,2,4
+P,4,6,6,4,4,8,5,7,5,6,5,7,3,8,4,9
+F,4,9,5,7,4,5,11,2,7,11,9,5,1,10,3,5
+Y,4,5,5,3,2,4,11,2,7,11,10,5,1,11,2,5
+F,2,1,3,2,2,6,10,4,5,10,9,5,1,9,3,7
+I,7,14,5,8,3,9,6,6,5,13,3,7,3,8,5,11
+L,3,6,4,4,2,9,3,2,6,9,2,10,1,5,3,9
+M,5,10,6,8,6,8,6,11,1,6,8,8,9,5,2,5
+K,5,11,6,8,5,4,6,7,3,7,7,12,4,8,3,11
+P,1,3,3,2,1,7,8,4,3,11,5,4,1,9,2,8
+Q,4,8,4,9,6,7,10,5,3,6,10,11,3,9,6,8
+Y,7,7,6,10,4,9,7,6,6,4,11,7,5,10,3,7
+V,7,10,7,8,4,4,11,2,4,9,11,7,4,9,1,7
+K,4,7,6,5,4,5,7,5,8,7,6,12,3,8,5,10
+V,4,8,6,6,3,7,11,3,4,6,12,9,2,10,1,8
+B,3,5,4,4,4,7,7,5,6,6,6,6,2,8,7,10
+E,4,10,6,8,8,7,7,3,5,6,7,10,5,10,8,8
+D,5,11,7,8,7,9,8,5,5,10,5,4,4,8,5,9
+M,4,4,8,3,4,7,6,3,4,9,8,9,8,6,2,8
+Y,4,10,6,7,1,7,12,2,3,8,12,8,1,10,0,8
+K,3,7,5,6,5,6,8,3,4,7,4,9,5,3,4,9
+K,3,1,4,1,2,6,7,4,7,7,6,11,2,8,4,10
+L,6,9,5,4,2,6,5,3,7,10,4,12,2,6,6,8
+Q,5,9,6,11,7,8,6,8,4,5,6,9,3,8,6,10
+G,2,0,2,1,1,8,6,5,5,6,5,9,1,8,5,10
+L,1,0,2,1,0,2,1,5,5,0,2,5,0,8,0,8
+Q,3,7,4,6,2,7,5,9,6,5,5,7,3,8,4,8
+M,5,6,6,8,4,8,7,13,2,6,9,8,9,6,0,8
+F,1,3,2,2,1,5,10,4,4,10,8,5,1,9,3,7
+G,5,10,6,7,5,7,7,7,7,6,5,10,1,7,5,11
+J,1,3,2,1,1,10,7,2,4,11,5,9,1,7,0,7
+D,5,8,8,6,6,10,7,4,6,10,3,5,3,8,3,8
+K,5,11,7,8,7,5,6,3,7,6,6,9,4,8,6,9
+V,2,6,4,4,2,7,11,3,3,7,11,8,2,10,1,8
+O,8,11,6,6,3,8,5,4,6,8,3,8,5,7,5,8
+O,4,6,5,4,3,8,7,7,5,10,6,8,3,8,3,8
+W,4,11,7,8,7,4,10,2,3,8,9,9,8,10,1,8
+O,4,6,4,4,3,8,7,7,6,9,5,7,3,8,3,8
+R,3,4,5,3,3,8,8,3,5,9,5,7,3,6,4,10
+O,3,5,4,3,2,8,7,7,4,9,6,8,2,8,3,8
+I,3,9,4,7,3,8,6,0,7,13,6,9,0,7,2,7
+C,4,7,5,5,3,5,8,7,7,8,8,14,1,10,4,10
+J,1,3,2,4,1,11,4,9,3,12,8,13,1,6,0,8
+A,4,10,5,8,4,6,5,3,1,6,1,8,2,7,2,7
+O,4,6,5,4,3,7,8,8,6,8,8,6,3,8,4,8
+D,4,7,6,6,5,5,7,7,7,7,6,7,4,6,5,6
+W,5,10,7,7,6,4,9,5,1,7,9,8,8,10,0,8
+H,1,0,2,0,0,7,8,11,1,7,6,8,2,8,0,8
+Y,2,1,2,1,0,7,9,2,2,6,12,8,1,10,0,8
+U,4,9,5,7,4,5,8,6,7,8,9,10,3,9,1,8
+F,1,0,1,0,0,3,11,4,3,11,9,7,0,8,2,8
+S,3,5,4,3,2,8,8,2,7,10,5,6,1,9,5,8
+G,7,10,8,8,5,5,7,6,6,9,8,9,2,9,5,9
+B,5,11,5,8,4,6,6,10,7,6,7,7,2,8,9,10
+B,6,10,8,7,6,11,5,3,7,11,3,7,3,8,6,12
+M,1,0,2,0,1,8,6,9,0,6,8,8,5,6,0,8
+O,5,9,6,7,5,8,8,8,4,7,7,8,3,8,3,7
+L,3,7,4,5,2,7,4,2,8,7,2,8,1,6,3,8
+M,4,7,6,5,5,7,7,2,4,9,7,9,7,6,2,8
+T,2,1,3,1,0,7,15,1,4,7,11,8,0,8,0,8
+X,8,13,9,7,5,6,8,2,8,11,7,9,4,8,4,6
+B,2,6,4,4,5,8,8,4,2,6,7,7,6,11,7,7
+G,4,7,6,5,7,8,6,4,2,7,6,9,6,8,7,13
+B,5,10,5,5,4,7,8,3,4,9,6,7,6,7,8,6
+H,7,13,8,7,6,8,8,3,5,10,4,8,6,6,5,8
+S,4,6,6,4,5,9,4,4,4,9,6,9,4,7,9,10
+C,7,11,7,8,4,5,8,6,8,12,8,13,3,10,4,6
+U,6,10,5,5,3,5,5,5,5,4,7,8,5,9,2,7
+X,5,8,8,6,4,9,7,1,8,10,4,7,3,9,4,9
+Q,3,6,4,5,2,8,7,8,6,6,5,9,3,8,4,8
+N,10,15,11,8,5,7,7,2,4,13,7,8,6,8,0,7
+E,4,7,5,5,4,8,7,2,7,11,6,8,3,9,4,9
+Z,3,9,4,6,2,7,7,4,13,10,6,8,0,8,8,8
+V,6,9,6,6,3,3,12,3,3,10,11,8,2,10,1,7
+Q,3,6,3,7,4,8,8,6,1,8,7,10,2,9,5,8
+G,6,8,8,7,9,8,7,6,3,7,7,8,7,11,7,9
+D,2,4,4,3,2,9,6,4,6,10,4,6,2,8,3,8
+L,3,9,4,7,1,0,1,6,6,0,0,6,0,8,0,8
+J,3,10,5,8,1,14,1,8,5,14,3,11,0,7,0,8
+I,0,8,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+W,5,9,8,6,7,8,11,2,2,6,8,8,8,14,1,7
+Q,2,3,3,4,3,8,9,5,1,5,7,10,2,9,5,10
+U,9,13,8,8,5,8,5,4,6,6,7,6,6,8,4,6
+O,5,9,5,7,4,7,7,8,5,10,6,7,3,8,4,8
+I,0,7,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+L,2,5,3,3,1,6,4,1,8,7,2,10,0,7,2,8
+X,4,5,7,4,3,6,8,1,9,10,8,8,2,8,3,7
+T,3,5,4,4,2,6,11,2,7,11,9,5,1,11,3,4
+L,5,11,7,8,5,10,4,1,8,10,2,10,0,6,3,10
+A,7,15,7,8,5,10,2,5,2,11,5,12,6,3,6,10
+K,8,15,9,9,6,6,8,3,6,10,9,10,6,11,4,8
+N,4,11,6,8,5,6,9,6,5,7,7,8,6,9,1,7
+E,3,8,5,6,5,7,8,5,8,6,5,9,3,8,5,9
+E,4,8,5,6,3,3,7,6,11,7,7,14,0,8,7,7
+B,4,6,5,4,5,8,6,7,6,6,6,5,3,9,7,9
+N,5,8,8,6,8,8,6,4,4,7,6,7,7,11,7,4
+A,3,8,5,6,3,9,3,1,2,7,2,8,2,6,2,7
+B,4,8,5,6,5,8,8,6,7,7,6,6,2,8,7,10
+W,5,8,8,6,3,4,8,5,2,7,9,8,8,9,0,8
+H,6,11,9,8,9,7,7,6,7,7,6,8,6,8,4,8
+V,2,2,4,3,2,7,12,2,2,6,11,9,2,11,0,7
+B,4,7,6,5,5,10,6,2,5,10,4,7,3,7,5,11
+Y,7,6,6,9,4,9,6,5,5,5,12,6,4,11,4,6
+W,3,6,5,4,7,9,7,5,1,7,6,8,7,10,2,7
+T,6,11,8,8,9,5,8,3,7,7,6,10,5,8,7,8
+G,2,1,3,2,1,7,7,6,5,6,6,10,2,8,4,10
+G,4,6,6,4,5,7,8,5,3,6,6,8,5,7,7,7
+Z,5,7,6,5,3,8,7,2,9,12,5,10,2,9,6,9
+V,4,10,6,8,2,8,8,4,3,6,14,8,3,9,0,8
+P,5,9,5,7,5,5,10,8,3,8,5,5,1,9,6,6
+A,4,11,5,8,4,8,5,3,0,7,1,8,2,6,3,8
+K,4,8,6,6,4,9,7,2,6,10,2,7,4,7,3,10
+B,7,12,6,6,6,8,7,4,5,9,6,8,6,8,8,8
+W,5,5,6,3,4,4,11,3,2,9,9,7,7,12,1,6
+T,2,3,3,5,1,9,14,0,6,5,11,8,0,8,0,8
+Q,2,3,3,4,2,7,8,4,2,8,9,10,2,9,4,8
+Q,4,6,4,8,4,7,9,4,4,8,10,11,3,9,6,8
+O,3,6,4,4,3,7,8,8,7,7,8,7,2,8,4,8
+J,2,8,2,6,1,14,3,5,4,13,3,10,0,7,0,8
+M,11,11,11,6,5,4,9,5,6,4,2,12,9,11,2,8
+S,2,1,2,2,1,8,7,4,7,5,6,7,0,8,8,8
+D,3,4,4,7,2,5,7,11,8,6,5,5,3,8,4,8
+R,4,7,4,5,2,6,10,9,4,7,4,8,3,7,6,11
+P,1,0,1,0,0,5,10,7,2,9,6,5,1,9,3,8
+U,2,1,2,1,0,8,6,11,4,7,12,8,3,10,0,8
+L,0,0,1,0,0,2,2,5,4,1,2,6,0,8,0,8
+Y,3,5,6,4,2,7,11,1,7,7,11,8,2,11,2,8
+H,5,10,7,8,7,8,8,7,6,7,6,7,3,8,3,7
+F,4,9,6,7,4,3,12,5,4,12,9,5,2,10,2,5
+N,3,4,5,3,2,7,9,2,5,10,6,6,5,9,1,7
+X,4,9,6,6,5,7,7,3,9,5,7,9,5,7,8,8
+R,4,11,5,8,3,6,9,11,5,7,5,8,3,8,5,10
+B,2,4,3,2,2,8,8,3,5,10,6,6,2,8,5,9
+L,3,7,4,5,2,0,1,4,5,1,1,7,0,8,0,8
+V,8,10,7,7,3,3,12,4,4,10,12,8,3,10,1,8
+D,1,0,2,1,1,6,7,8,6,6,6,6,2,8,3,8
+Z,5,8,7,10,7,10,5,4,4,8,3,6,3,5,8,8
+V,5,5,6,4,2,4,12,3,3,10,11,7,3,10,1,7
+A,5,9,7,8,6,6,8,2,4,7,7,9,8,7,4,8
+Q,2,2,2,3,1,7,8,5,1,7,8,10,2,9,4,8
+U,3,8,4,6,2,7,5,14,5,7,13,8,3,9,0,8
+Y,3,5,4,7,7,7,5,4,2,7,7,9,5,10,4,8
+L,2,5,3,4,1,4,3,4,7,2,2,5,0,7,0,6
+V,3,2,5,3,1,6,12,3,4,8,11,8,2,10,1,8
+R,5,10,5,8,6,6,8,9,5,6,5,7,2,8,5,11
+S,4,9,5,7,4,8,8,8,7,8,4,7,2,7,9,8
+Q,6,7,8,6,6,7,4,4,5,7,4,9,5,4,7,7
+A,4,8,6,6,3,9,2,2,2,7,1,8,2,7,3,7
+E,1,3,3,1,1,6,8,2,7,11,8,9,1,8,3,8
+P,6,10,6,7,3,4,14,8,1,11,6,3,1,10,4,8
+W,10,10,10,8,7,2,11,2,3,10,10,8,7,11,2,7
+S,3,4,4,6,2,8,7,6,9,5,6,8,0,8,9,8
+G,2,1,3,2,1,6,6,5,5,6,6,9,2,9,4,8
+U,3,4,3,3,2,5,8,5,7,10,9,8,3,9,2,6
+Q,5,5,6,7,3,8,7,8,6,6,6,9,3,8,5,9
+W,6,9,6,7,6,3,12,2,2,10,9,8,6,11,2,7
+L,4,9,5,7,3,3,3,7,8,1,0,5,1,6,1,6
+R,4,9,6,6,4,9,7,4,6,9,4,7,3,7,5,10
+C,4,7,5,5,5,5,7,3,5,7,6,10,5,10,3,8
+D,4,7,5,5,2,5,7,10,9,7,7,6,3,8,4,8
+M,4,9,6,7,7,7,7,5,5,6,7,8,8,7,3,7
+U,2,1,3,2,1,7,8,6,7,7,10,8,3,9,1,8
+H,5,7,6,5,5,7,10,8,6,8,6,7,3,7,3,9
+Q,4,10,5,9,5,8,7,7,5,6,8,8,3,7,6,11
+D,2,4,3,3,2,8,7,4,5,9,4,5,2,8,2,8
+J,4,8,5,6,3,7,7,3,6,15,6,9,1,6,1,7
+C,4,9,5,7,3,6,8,9,8,9,8,12,2,10,4,9
+O,4,8,5,6,5,7,8,8,5,7,8,8,3,8,3,8
+B,3,5,5,3,3,9,6,2,6,10,4,7,4,7,6,9
+Z,5,11,7,8,4,7,7,2,10,12,5,9,1,9,6,8
+T,6,11,6,6,3,6,10,2,7,12,7,6,2,9,5,4
+O,4,10,5,7,2,7,7,9,7,7,7,8,3,8,4,8
+I,1,3,2,2,1,7,7,1,7,13,6,8,0,8,1,8
+U,1,0,1,0,0,7,7,9,3,7,12,8,2,10,0,8
+I,1,9,1,7,2,8,7,0,8,7,6,7,0,8,3,7
+V,3,8,5,6,1,7,8,4,3,7,14,8,3,10,0,8
+U,2,3,3,2,1,8,8,5,6,6,9,8,3,10,1,8
+J,2,6,4,4,1,7,8,2,6,15,6,9,0,7,1,7
+B,4,6,6,4,5,8,8,6,4,6,5,6,4,8,6,5
+Y,4,5,6,7,1,7,10,2,2,7,13,8,2,11,0,8
+Y,8,11,8,8,4,3,11,2,9,12,11,5,0,10,2,4
+O,6,10,4,5,3,6,8,4,4,7,4,7,4,8,5,8
+X,3,10,4,7,2,7,7,4,4,7,6,8,3,8,4,8
+L,3,7,4,5,2,6,3,1,8,8,2,11,0,7,2,8
+Y,2,2,4,3,1,6,10,1,7,8,11,8,1,11,2,7
+W,4,8,6,6,6,7,6,6,2,7,7,8,6,8,4,10
+O,4,7,5,5,4,8,8,7,4,7,7,6,4,9,3,7
+H,3,6,4,4,3,7,6,12,1,7,8,8,3,9,0,8
+X,4,7,4,4,1,7,7,5,4,7,6,8,3,8,4,8
+T,2,3,3,1,1,6,12,3,6,11,9,5,1,11,2,5
+R,4,8,6,6,6,8,6,7,3,7,5,7,4,6,7,8
+W,5,8,8,6,3,9,8,5,2,7,8,8,9,9,0,8
+M,5,10,7,8,8,9,7,6,5,6,7,5,8,7,3,5
+P,2,3,4,1,1,7,9,4,3,11,4,4,1,9,2,8
+B,4,6,4,4,3,6,7,8,6,7,6,6,2,8,9,10
+T,4,7,4,5,3,4,12,5,4,11,9,5,2,12,1,5
+O,4,8,5,6,3,7,5,8,5,6,4,7,3,8,3,8
+K,8,13,8,7,5,9,6,3,6,10,1,7,6,5,4,8
+R,3,7,3,4,2,5,11,8,4,7,3,9,3,7,5,11
+P,5,6,6,4,5,7,6,6,4,7,6,8,3,8,7,10
+I,3,9,4,6,2,6,8,0,8,14,7,8,0,8,1,7
+F,5,9,4,5,2,7,9,3,5,12,6,5,2,8,6,6
+E,5,9,4,4,2,8,7,5,4,10,5,10,3,8,7,10
+E,5,8,6,6,5,8,7,6,3,7,6,10,4,8,8,9
+R,3,7,5,5,4,10,7,3,5,10,3,7,3,7,3,10
+N,4,2,4,3,3,7,8,5,5,7,7,6,6,9,3,6
+K,3,7,4,4,1,4,8,7,2,7,5,11,3,8,3,10
+R,4,6,6,4,6,8,8,4,4,6,7,8,6,10,7,6
+N,4,9,6,7,4,7,8,6,5,7,7,7,6,9,2,6
+B,2,1,2,1,1,7,7,7,5,6,5,7,1,8,7,10
+M,5,7,7,5,4,6,6,3,5,10,9,9,7,5,2,8
+L,4,10,5,8,3,4,4,1,9,6,1,10,0,7,2,7
+W,8,14,8,8,6,3,8,1,4,9,10,8,9,11,2,5
+O,2,3,2,2,1,8,7,6,3,9,6,8,2,8,3,8
+V,4,7,5,5,6,8,6,4,1,7,8,8,7,9,4,7
+S,4,9,6,7,7,8,6,5,4,8,6,9,5,7,13,9
+P,4,9,6,7,4,6,10,3,7,10,9,4,1,10,5,7
+J,2,8,3,6,1,11,3,10,3,13,7,13,1,6,0,8
+S,4,7,5,5,4,8,7,5,7,5,6,8,0,9,9,8
+T,3,6,5,6,4,6,7,3,8,8,6,9,3,7,7,6
+X,0,0,1,0,0,7,7,3,5,7,6,8,2,8,3,8
+M,2,1,2,2,1,7,6,10,0,7,8,8,6,6,0,8
+W,8,10,8,8,7,2,12,2,2,10,9,8,6,12,2,6
+E,1,0,1,1,1,5,7,5,7,7,6,12,0,8,6,9
+T,2,10,4,7,1,7,14,0,6,7,11,8,0,8,0,8
+R,1,0,1,0,0,6,8,6,3,7,5,7,2,7,3,10
+H,4,8,5,6,5,6,7,5,4,7,5,8,3,7,6,11
+T,3,6,4,4,2,10,11,2,8,5,11,9,1,11,1,9
+U,2,3,3,2,1,4,8,4,5,11,10,9,3,9,1,6
+D,7,12,6,6,4,10,4,3,6,10,2,7,4,7,4,12
+N,8,12,7,6,3,5,9,4,6,4,4,11,5,10,2,7
+V,3,7,5,5,2,8,9,4,1,6,12,8,2,10,0,8
+D,4,8,6,6,5,10,6,4,6,9,3,6,3,9,3,8
+Z,4,9,6,6,4,7,7,2,10,12,6,10,1,9,6,8
+E,3,2,4,4,3,7,7,6,8,7,7,9,2,8,6,9
+X,4,9,6,7,5,7,7,3,8,5,6,8,3,8,6,7
+A,5,7,8,6,6,9,7,3,5,6,8,6,4,10,4,5
+L,3,8,4,6,2,0,2,4,6,1,0,7,0,8,0,8
+G,5,7,6,5,3,6,7,6,6,10,8,8,2,9,5,9
+R,6,10,8,8,7,8,8,6,6,6,5,7,3,6,6,9
+A,4,11,7,9,4,11,3,2,3,9,2,9,5,5,3,9
+Y,6,9,8,7,6,8,7,6,5,5,9,8,3,9,8,5
+M,4,1,5,3,3,9,6,6,4,6,7,6,8,6,2,5
+T,4,9,5,6,3,5,13,6,4,11,9,4,3,12,2,4
+A,3,9,6,6,2,8,4,3,2,7,1,8,3,7,3,8
+R,3,6,5,4,4,9,7,3,5,10,3,7,3,7,3,10
+B,4,9,6,6,7,8,6,6,6,6,6,5,2,8,6,10
+M,5,6,6,8,4,8,7,12,2,6,9,8,8,6,0,8
+D,3,10,5,8,8,9,8,4,5,7,6,6,4,7,8,5
+F,3,4,4,6,1,1,13,5,3,12,10,6,0,8,2,6
+M,5,6,7,4,5,12,5,3,4,9,2,6,7,6,2,8
+C,4,9,5,6,3,6,9,7,8,13,8,7,2,11,3,7
+F,10,13,8,8,4,8,8,4,7,13,4,6,2,7,7,8
+R,4,8,7,7,8,9,8,4,4,7,4,7,6,7,6,4
+V,3,7,5,5,2,6,9,4,2,8,13,8,2,10,0,8
+X,5,9,7,7,3,7,8,1,9,10,6,8,3,8,4,7
+Z,4,9,6,7,4,8,5,2,9,11,4,10,2,7,7,9
+S,3,5,4,3,2,8,7,2,7,10,6,8,1,9,5,8
+Z,3,4,4,6,2,7,7,3,13,10,6,8,0,8,8,8
+E,4,10,6,7,5,10,6,1,7,11,4,8,3,8,4,11
+H,4,8,4,6,2,7,9,15,1,7,4,8,3,8,0,8
+E,1,1,1,1,1,4,7,5,8,7,6,13,0,8,6,9
+O,7,11,9,8,12,8,5,6,2,7,6,8,11,10,8,14
+S,1,0,1,0,0,8,7,4,6,5,6,7,0,8,7,8
+W,8,8,8,6,5,4,11,3,3,9,9,7,8,11,2,6
+R,3,6,4,4,4,6,8,8,4,7,6,8,2,7,5,11
+N,5,10,6,7,3,7,7,15,2,4,6,8,6,8,0,8
+C,1,1,2,1,0,6,7,6,9,7,6,14,0,8,4,10
+Q,4,10,6,8,6,8,6,7,4,5,7,11,6,7,8,8
+W,3,7,5,5,4,5,10,2,2,8,9,9,7,11,1,8
+Q,4,9,4,4,2,8,5,4,7,8,6,8,3,9,8,11
+B,7,11,9,8,8,10,6,3,6,10,3,7,5,7,6,11
+I,4,7,5,5,3,8,8,2,8,7,6,7,0,8,4,7
+G,6,9,5,4,3,7,8,6,6,10,5,6,4,7,5,7
+Q,5,8,5,10,7,8,8,6,2,7,8,11,3,9,6,8
+A,2,3,4,4,1,10,5,3,1,8,1,8,2,7,2,8
+I,9,14,6,8,3,10,4,5,5,13,3,8,3,7,5,10
+Z,4,9,5,7,2,7,7,4,15,9,6,8,0,8,8,8
+C,5,9,6,7,4,3,8,6,7,12,10,13,1,9,3,7
+V,2,7,4,5,2,8,11,2,2,5,10,8,2,11,0,9
+K,7,15,8,8,5,9,6,3,6,11,2,7,5,7,4,9
+K,4,9,5,7,4,3,7,7,3,7,6,11,3,8,3,11
+C,4,6,6,4,3,8,6,7,7,7,6,8,4,10,4,8
+G,3,9,5,6,4,6,6,6,6,6,6,9,2,9,4,8
+M,6,10,8,8,9,7,10,6,4,7,7,8,6,8,6,8
+F,4,9,6,6,3,3,12,5,4,13,9,5,1,10,2,5
+U,5,10,8,8,10,8,5,4,5,6,7,6,10,6,6,5
+U,2,3,2,1,1,7,8,6,7,8,9,7,3,10,1,8
+S,6,11,7,8,5,9,7,3,6,10,4,7,2,9,5,9
+J,4,7,5,5,2,5,9,3,5,15,8,10,1,6,1,7
+F,4,8,5,6,5,4,10,2,5,10,10,6,1,10,3,6
+T,4,6,4,4,3,6,11,3,7,11,9,4,2,12,3,5
+Q,6,10,5,5,4,9,6,4,6,11,5,7,4,7,9,10
+B,2,4,3,3,2,8,7,3,5,9,6,6,3,8,5,9
+R,4,9,5,6,4,9,8,6,6,8,5,7,3,8,5,10
+U,5,5,6,4,2,3,9,5,7,11,11,9,3,9,1,6
+W,8,10,8,8,6,2,11,2,3,10,10,8,7,11,1,7
+V,10,14,9,8,5,8,9,4,6,8,9,5,6,12,4,8
+A,3,6,6,8,2,9,4,3,2,8,1,8,3,7,2,8
+F,3,7,5,5,4,4,10,5,5,11,10,6,2,10,3,6
+U,5,8,6,6,3,7,8,6,8,5,9,9,3,9,1,8
+E,1,3,3,1,1,6,7,2,6,11,6,9,2,8,3,9
+F,3,4,4,3,2,5,11,4,6,11,9,5,1,10,3,6
+D,3,5,4,4,3,7,7,6,6,7,6,5,5,8,3,7
+Q,2,2,3,3,2,8,7,6,2,6,6,9,2,9,4,9
+F,5,9,5,5,2,8,8,2,7,11,6,6,2,10,5,8
+M,7,11,10,8,10,8,7,5,5,6,7,7,11,8,4,6
+I,2,10,2,8,3,7,7,0,7,7,6,8,0,8,3,8
+U,3,7,5,6,5,7,7,4,4,6,6,9,4,8,1,8
+P,4,9,5,6,5,6,9,7,4,9,7,4,2,10,4,7
+H,6,8,9,6,6,10,6,3,6,10,3,8,4,8,5,10
+U,4,7,6,5,4,8,8,8,5,6,7,10,3,8,4,6
+G,4,4,6,7,3,8,8,8,8,6,7,8,2,7,6,10
+W,2,0,3,1,1,7,8,4,0,7,8,8,7,9,0,8
+X,3,6,4,4,1,7,7,6,2,7,6,8,3,8,4,8
+C,4,7,6,5,3,7,7,7,6,7,6,8,4,9,4,8
+N,5,10,6,8,6,7,7,13,1,6,6,8,6,9,0,6
+W,8,11,8,8,9,4,10,2,3,9,8,7,9,13,3,5
+W,3,7,5,5,7,8,9,5,1,7,7,8,7,9,2,8
+P,5,6,7,8,8,8,6,4,3,7,7,7,7,12,6,7
+P,1,0,1,0,0,5,10,6,1,9,6,5,0,9,2,8
+K,3,4,4,3,3,5,7,4,7,7,6,11,3,8,5,9
+B,8,15,6,8,5,8,6,5,6,10,5,9,6,7,8,10
+C,3,2,4,3,2,6,8,8,7,8,7,12,2,9,4,10
+F,5,11,7,8,5,6,11,2,5,13,7,4,2,10,2,7
+J,4,5,5,6,4,8,9,4,4,7,6,8,3,7,7,7
+V,4,9,6,6,3,4,11,3,4,9,12,9,3,10,1,8
+O,4,8,4,6,3,8,5,8,5,9,4,8,3,8,3,8
+N,4,5,4,7,3,7,7,14,2,5,6,8,6,8,0,8
+W,6,10,8,8,9,7,9,6,4,9,9,7,8,8,5,12
+L,4,8,5,6,4,8,5,8,6,5,7,8,3,6,6,11
+O,2,4,3,3,2,7,7,6,3,9,6,8,2,8,2,8
+R,3,4,5,2,3,8,8,3,5,9,5,7,3,6,4,10
+R,5,8,8,7,8,8,7,3,3,7,5,8,7,9,6,5
+P,4,10,6,7,4,8,9,2,6,13,6,5,1,10,3,9
+D,5,10,6,8,6,6,8,9,7,7,7,5,3,6,5,9
+A,3,10,5,8,4,11,3,2,2,9,2,9,3,5,3,8
+A,3,8,6,6,4,11,2,2,2,9,2,9,3,5,3,8
+O,6,10,7,8,3,6,6,9,9,6,5,6,3,8,4,8
+V,4,10,7,7,2,7,8,4,3,7,14,8,3,9,0,8
+K,5,7,8,5,5,4,9,2,6,10,9,10,3,8,3,6
+O,2,3,3,2,1,8,7,6,3,9,6,8,2,8,2,8
+D,3,6,5,4,6,9,8,4,5,7,6,6,4,8,8,5
+I,1,3,2,2,1,7,8,1,7,13,6,8,0,8,1,7
+O,2,1,3,3,2,7,7,7,5,7,6,8,2,8,3,8
+P,3,2,4,4,3,6,9,5,5,9,7,3,1,10,4,6
+E,5,9,8,7,5,6,8,4,9,12,9,9,3,8,5,6
+O,4,9,5,7,3,8,6,9,8,7,4,9,3,8,4,8
+B,3,3,4,4,3,6,8,8,7,7,5,7,2,8,9,10
+M,4,7,5,5,3,7,7,12,1,7,9,8,8,6,0,8
+G,5,10,6,7,7,7,5,6,3,7,6,11,4,8,7,7
+C,7,10,8,8,4,2,9,5,9,11,11,13,1,7,3,6
+G,4,8,6,6,6,7,9,6,4,6,6,8,5,7,7,7
+N,1,0,1,0,0,7,7,10,0,5,6,8,4,8,0,8
+O,4,7,5,5,3,8,8,8,5,7,7,6,3,8,4,8
+V,2,3,4,5,1,9,8,4,2,6,13,8,3,10,0,8
+P,2,5,4,3,2,7,9,4,4,12,5,3,1,10,2,8
+T,7,12,6,7,3,6,10,3,6,12,8,6,2,9,4,5
+Y,4,5,6,8,9,7,5,4,3,8,8,9,5,10,6,10
+P,2,4,4,3,2,7,9,4,3,11,4,4,1,10,3,8
+F,4,7,6,5,3,8,9,3,6,13,5,5,2,10,3,8
+G,7,10,7,8,4,7,6,7,8,11,5,12,3,9,5,8
+Q,2,2,3,3,2,8,8,7,3,5,6,10,2,9,5,10
+O,3,7,4,5,3,9,6,7,5,10,4,9,3,8,3,8
+N,3,2,4,3,2,7,8,5,5,8,7,6,6,10,3,5
+R,7,11,9,8,6,9,7,5,7,8,4,6,3,7,6,11
+N,2,3,4,2,2,7,8,2,4,10,6,7,5,8,0,7
+I,1,3,2,2,0,7,7,1,7,13,6,8,0,8,1,8
+P,2,1,2,1,1,5,11,8,2,9,6,4,1,9,3,8
+W,5,5,8,7,4,11,8,5,2,6,9,8,8,9,0,8
+L,2,3,2,2,1,4,4,4,7,2,2,6,0,7,1,6
+S,4,5,5,4,5,8,8,4,4,7,7,8,5,10,9,10
+D,3,5,6,4,4,9,7,4,7,10,4,6,2,8,3,8
+Y,3,4,4,3,2,5,10,2,7,10,10,5,1,11,3,5
+Z,5,10,6,8,7,8,9,3,7,8,6,8,2,10,13,7
+M,3,3,5,2,3,8,6,6,4,7,7,8,7,5,2,7
+E,3,7,5,5,5,5,6,4,6,7,6,12,2,10,8,6
+N,6,11,8,8,9,6,7,3,4,8,8,9,8,9,7,5
+G,3,3,4,5,2,7,7,7,6,6,6,7,2,7,6,11
+N,5,9,7,6,6,7,7,6,6,7,5,8,6,7,3,7
+V,4,8,4,6,3,4,11,1,2,9,10,7,2,11,1,7
+Y,1,1,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+D,6,11,8,8,7,10,6,4,6,9,3,6,3,8,3,9
+C,4,10,5,7,2,5,7,7,10,7,6,14,1,8,4,9
+H,4,7,4,5,2,7,7,14,0,7,6,8,3,8,0,8
+L,4,7,5,5,2,5,4,2,9,6,2,9,1,6,2,7
+S,3,4,4,3,2,9,6,3,7,10,5,8,1,9,5,9
+Q,5,6,6,8,6,8,5,8,4,6,6,8,3,9,7,11
+F,6,11,8,8,5,8,9,3,6,13,5,4,2,9,3,7
+S,3,5,5,4,2,7,7,3,8,11,5,7,1,8,4,8
+Y,3,5,5,4,2,8,11,1,7,5,11,9,2,12,3,8
+K,2,3,2,1,2,6,7,4,6,6,6,10,3,8,4,9
+G,2,1,4,3,2,7,7,6,6,6,7,9,2,8,4,9
+L,6,11,8,8,5,7,5,0,8,9,3,11,2,6,4,7
+J,6,10,9,7,5,8,5,7,7,8,6,7,2,7,5,6
+R,3,9,4,6,3,5,11,8,4,7,4,9,3,7,6,11
+P,6,11,6,8,6,5,11,9,3,9,5,4,1,10,3,8
+N,7,10,10,8,5,9,9,3,6,10,3,4,6,9,1,7
+R,8,12,8,6,6,8,7,3,5,9,3,8,6,7,6,7
+A,1,3,2,2,1,10,3,2,1,9,2,9,1,6,1,8
+M,4,8,6,6,7,9,7,5,5,6,7,6,8,7,2,6
+Z,4,10,5,7,4,6,8,6,10,7,7,10,1,9,8,8
+R,6,9,6,4,4,5,8,3,5,7,4,10,4,7,5,7
+D,4,6,5,4,7,8,8,5,5,7,6,6,6,6,7,6
+A,2,7,4,4,2,7,4,3,2,6,1,8,3,6,2,7
+X,10,15,9,9,4,6,8,3,9,9,9,9,4,10,4,6
+I,1,3,1,1,0,8,7,1,7,13,6,8,0,8,0,8
+G,5,7,7,6,7,6,10,5,3,7,7,7,9,13,8,7
+Z,5,8,7,6,4,7,8,2,10,12,7,8,1,9,6,7
+O,5,6,7,5,5,7,5,4,4,9,4,9,3,7,6,6
+J,4,6,6,7,5,7,8,4,5,7,7,7,3,9,9,10
+V,4,11,6,8,4,6,11,2,3,6,11,9,2,10,1,8
+N,2,3,2,1,1,7,8,5,4,7,6,7,4,9,1,6
+A,3,5,5,4,2,9,2,1,2,8,2,9,2,6,2,8
+R,5,7,7,5,4,10,7,3,6,10,2,6,3,6,4,10
+H,3,6,5,4,4,7,8,3,6,10,5,8,3,8,3,9
+I,3,7,4,5,2,9,6,0,7,13,5,9,0,8,1,8
+V,2,1,3,1,1,9,12,3,2,5,11,8,2,11,0,8
+Q,2,2,3,3,2,8,6,6,3,6,6,9,2,9,4,9
+D,9,15,9,8,5,10,4,4,6,12,2,8,5,6,5,10
+P,1,1,1,1,0,5,11,7,1,10,6,4,1,9,3,8
+W,6,7,6,5,4,3,10,2,3,10,10,8,6,11,2,6
+S,5,8,6,6,3,6,8,4,8,11,6,7,2,8,5,6
+L,1,3,2,2,1,7,4,1,6,8,3,10,0,7,1,9
+A,5,8,8,7,7,7,8,2,4,7,8,9,8,6,4,8
+W,6,7,6,5,4,5,10,3,3,9,8,7,7,12,2,5
+L,3,5,4,3,2,4,4,4,8,2,1,5,1,7,1,6
+F,5,10,9,8,9,7,9,1,5,9,6,5,6,9,5,2
+D,3,5,5,3,3,7,7,6,7,7,6,5,2,8,3,7
+O,4,9,3,4,2,6,9,5,3,8,5,6,4,9,5,8
+R,1,3,2,1,1,8,8,4,4,9,5,7,2,6,4,9
+L,2,6,4,4,2,9,4,1,8,10,3,10,0,7,2,10
+U,4,8,5,6,3,5,8,6,7,9,7,9,3,9,3,5
+P,3,7,3,5,3,5,11,8,2,9,7,5,1,10,3,8
+U,11,15,10,9,5,9,7,6,6,2,10,6,6,7,3,6
+E,3,5,6,4,3,7,8,2,8,11,7,9,2,8,4,8
+Z,5,10,7,8,5,8,6,2,9,11,5,10,2,7,7,8
+L,3,7,4,5,5,7,8,3,5,5,7,10,4,11,5,6
+O,4,9,4,7,3,8,7,8,5,10,5,9,3,8,4,7
+S,3,9,4,7,4,7,7,5,7,5,6,8,1,8,9,7
+V,5,10,5,7,3,3,11,3,4,10,12,8,2,10,1,8
+T,7,10,6,5,3,8,9,2,7,11,7,7,2,9,4,6
+W,8,11,8,8,6,3,10,2,3,9,9,8,8,11,2,5
+L,4,10,5,8,3,5,4,3,8,5,1,7,1,6,3,6
+Y,5,7,7,11,10,10,9,4,2,5,8,9,4,11,10,12
+P,3,3,4,4,2,5,11,9,3,9,6,5,1,10,4,8
+C,2,6,3,4,2,6,8,8,8,8,8,14,1,9,4,9
+N,3,2,4,3,2,7,8,5,4,7,7,6,5,9,2,5
+Y,2,4,4,6,1,7,10,1,3,7,12,8,1,11,0,8
+K,9,14,8,8,4,8,8,3,7,9,7,7,6,10,4,7
+I,2,5,3,3,1,7,7,0,7,13,6,8,0,8,1,7
+A,3,9,5,6,4,8,2,1,2,6,2,7,3,6,4,7
+F,5,8,7,6,3,5,12,7,5,13,7,3,2,9,2,5
+V,10,14,9,8,5,9,7,4,5,6,8,6,7,12,3,8
+F,3,8,5,6,3,8,8,2,5,13,5,6,2,10,2,9
+H,3,8,5,6,7,8,6,4,3,7,6,7,6,7,8,9
+X,2,3,4,1,1,5,9,2,8,10,9,8,2,8,3,6
+A,2,1,3,1,0,7,4,2,0,7,1,8,2,6,1,7
+R,4,8,6,6,6,7,9,5,6,8,4,9,4,5,5,10
+P,5,9,6,6,3,5,12,9,2,10,6,4,1,10,4,8
+K,6,11,8,8,10,7,7,4,4,6,6,9,8,8,8,8
+C,3,9,4,7,3,5,8,9,8,9,8,11,2,10,4,10
+G,4,9,4,4,3,7,7,3,2,8,5,7,3,10,8,7
+X,2,7,3,4,1,7,7,4,4,7,6,8,3,8,4,8
+Q,6,11,5,6,3,10,4,5,6,12,3,10,3,7,7,12
+V,4,10,6,7,2,7,8,4,3,7,14,8,3,9,0,8
+J,5,9,6,10,6,8,8,4,6,6,7,7,3,9,9,8
+Z,3,4,5,3,2,8,6,2,9,12,5,9,1,8,5,9
+C,5,10,6,7,4,7,7,8,7,6,6,9,4,8,4,8
+R,4,9,6,7,7,6,8,5,6,7,5,7,3,7,5,9
+C,4,7,5,5,2,5,8,6,8,12,9,11,2,10,3,7
+W,7,11,10,9,15,8,8,6,2,7,7,8,14,10,5,8
+O,2,5,3,4,2,8,7,7,4,9,6,8,2,8,3,8
+Z,1,0,1,1,0,7,7,2,10,9,6,8,0,8,6,8
+A,3,8,5,6,2,11,2,4,3,11,2,10,2,6,3,8
+F,5,8,6,10,7,7,9,5,5,8,6,8,4,10,7,5
+V,10,14,8,8,4,8,10,6,5,6,10,5,6,13,4,7
+L,4,9,6,7,4,6,5,0,8,8,2,11,0,7,2,8
+N,6,11,8,8,7,7,7,8,5,7,6,7,6,7,3,9
+N,4,7,4,5,2,7,7,14,2,5,6,8,6,8,0,8
+T,3,4,4,3,1,5,13,3,6,12,9,4,1,11,1,5
+X,4,10,7,8,7,7,7,2,6,7,6,8,4,8,7,7
+X,6,10,7,5,3,5,8,2,7,11,8,8,4,9,3,6
+W,5,10,7,7,7,7,7,6,2,7,8,8,6,8,4,10
+N,7,11,6,6,3,8,11,5,6,4,5,9,5,8,2,7
+C,3,4,4,3,1,4,8,5,7,11,9,12,1,9,2,7
+K,3,5,5,3,3,6,7,4,7,7,6,11,3,8,5,9
+M,3,4,5,3,3,5,6,3,4,9,9,10,7,5,2,8
+F,3,4,5,3,2,8,9,2,7,13,5,5,2,9,3,8
+J,1,6,2,4,1,12,3,8,3,13,6,12,1,6,0,8
+W,6,10,9,8,6,10,8,5,1,5,9,7,10,12,2,5
+G,4,8,5,6,3,7,6,6,7,11,6,12,2,10,4,9
+P,3,1,4,2,2,5,10,4,4,10,8,4,1,10,3,7
+M,2,0,2,1,1,7,6,10,0,7,8,8,6,6,0,8
+B,8,11,6,6,4,9,7,6,7,10,4,8,6,6,6,10
+R,6,11,6,8,4,6,10,10,4,7,4,8,3,7,6,10
+D,3,4,5,3,3,10,6,3,7,10,3,6,2,8,3,9
+Z,4,8,6,6,6,7,8,2,7,7,6,7,1,9,9,8
+X,4,5,5,7,2,7,7,5,4,7,6,8,3,8,4,8
+T,5,8,6,6,7,5,7,3,6,7,6,9,5,8,5,7
+G,2,4,3,3,2,6,7,5,5,9,7,10,2,8,4,10
+R,3,6,3,4,2,6,9,9,4,7,4,7,2,7,5,10
+J,3,8,5,6,2,10,6,2,7,14,4,8,0,7,0,8
+R,4,9,6,7,4,10,7,3,6,11,2,7,3,6,3,9
+C,4,8,5,6,3,5,7,6,8,7,6,12,1,8,4,9
+G,5,9,6,6,4,7,6,7,7,7,5,12,2,8,5,10
+E,2,6,3,4,2,3,7,5,9,7,6,14,0,8,6,9
+B,4,7,6,6,7,8,6,5,4,7,6,8,6,9,7,7
+X,4,5,6,4,3,7,7,1,9,10,6,8,2,8,3,7
+L,4,8,5,7,5,8,7,5,6,7,6,8,3,8,8,11
+D,2,4,4,2,2,9,7,4,6,10,4,5,2,8,3,8
+B,4,9,4,6,6,6,8,8,6,7,5,7,2,7,7,9
+L,6,10,8,8,7,6,6,6,6,6,5,8,6,7,4,10
+Z,3,7,4,5,3,7,7,3,11,8,6,8,0,8,7,8
+I,2,6,3,4,2,8,6,0,7,13,6,9,0,7,2,8
+I,1,1,0,2,0,7,7,1,7,7,6,8,0,8,2,8
+B,4,10,5,8,4,6,6,10,7,6,7,7,2,8,9,9
+J,3,10,5,8,4,12,6,2,7,11,2,6,0,7,1,8
+E,7,10,9,8,7,4,9,4,8,12,10,9,3,8,5,4
+M,2,1,3,2,2,8,6,6,3,6,7,7,6,5,1,7
+J,3,9,4,6,2,14,3,5,5,13,2,9,0,7,0,8
+I,1,5,2,3,1,7,7,0,7,13,6,8,0,8,1,7
+V,2,3,3,1,1,7,12,3,3,8,11,8,2,10,1,8
+N,3,4,3,3,2,7,8,5,4,7,6,6,5,9,2,6
+Y,4,7,6,5,5,8,5,6,4,6,9,8,3,8,8,4
+B,3,6,3,4,3,6,8,9,6,7,6,7,2,8,8,10
+U,1,0,2,0,0,7,6,10,4,7,12,8,2,10,0,8
+Y,3,4,5,5,1,6,10,3,1,8,13,8,1,11,0,8
+J,3,10,5,7,2,7,8,2,7,15,5,8,0,6,1,7
+F,6,9,8,7,7,7,9,5,5,8,6,7,6,10,8,11
+A,2,1,4,3,2,8,1,2,2,8,2,8,3,6,3,7
+P,2,4,3,3,2,5,10,4,4,10,8,3,1,10,3,6
+N,7,9,9,5,3,8,6,3,4,13,6,8,6,8,0,8
+O,3,6,5,4,3,8,8,8,4,7,6,5,3,8,3,7
+V,3,6,4,4,2,7,11,3,2,7,10,9,2,10,3,8
+G,3,4,4,3,2,6,6,6,6,6,6,10,2,9,3,9
+G,4,5,5,4,3,6,6,6,7,6,6,11,2,9,4,9
+N,5,9,7,7,5,7,9,6,5,7,6,7,6,9,2,6
+P,1,1,2,1,1,5,11,7,2,10,6,4,1,9,3,8
+W,5,9,6,4,4,7,9,2,3,7,8,6,8,11,2,7
+W,6,9,6,6,4,4,10,2,3,9,9,8,7,11,2,6
+K,7,11,10,8,6,4,8,3,7,11,10,12,4,8,4,6
+C,9,13,6,7,3,6,9,6,7,12,7,7,2,9,5,9
+Y,5,9,7,6,4,10,10,1,7,3,11,7,1,11,2,9
+N,2,2,3,3,2,7,8,5,4,7,6,6,5,9,2,5
+J,1,7,2,5,1,13,3,7,4,13,3,11,0,6,0,8
+S,3,5,3,3,2,8,7,7,5,7,6,7,2,9,9,8
+C,4,10,5,8,2,5,7,7,10,7,6,13,1,8,4,9
+H,4,5,7,4,4,7,7,3,6,10,6,8,3,8,3,7
+C,4,4,5,6,2,6,7,7,11,6,6,13,1,7,4,9
+L,1,0,2,1,0,2,1,6,5,0,2,5,0,8,0,8
+V,4,8,6,7,7,8,7,4,4,7,6,8,7,7,9,5
+T,5,11,6,8,5,9,12,4,6,6,11,8,3,12,1,8
+J,4,6,5,7,5,8,8,5,7,7,5,8,3,9,9,8
+H,1,0,2,0,0,7,6,11,1,7,7,8,2,8,0,8
+V,1,0,2,1,0,7,9,3,2,7,12,8,2,10,0,8
+S,6,9,7,6,3,9,6,4,8,11,3,8,2,8,5,11
+D,6,10,8,7,7,7,7,5,6,7,7,8,7,7,3,8
+B,2,3,3,2,2,8,7,2,5,11,5,7,2,8,2,9
+C,3,3,4,4,1,5,8,6,9,6,7,11,1,7,4,9
+M,2,1,2,1,1,8,6,10,0,6,9,8,6,6,0,8
+S,3,7,4,5,2,7,6,6,9,5,7,10,0,9,9,8
+F,5,7,6,8,7,7,9,5,5,8,6,7,4,9,9,7
+R,3,7,5,5,5,6,7,5,6,6,5,8,3,6,4,8
+W,6,7,6,5,6,7,10,4,3,8,6,6,9,11,4,6
+I,1,7,2,5,1,7,7,0,8,7,6,8,0,8,3,8
+X,4,10,6,8,6,7,7,2,6,7,6,8,3,9,6,8
+N,6,9,9,7,5,7,9,2,5,9,6,7,6,8,1,7
+W,4,7,6,5,6,7,7,6,2,7,8,8,6,8,4,8
+S,1,0,2,1,1,8,7,4,7,5,6,7,0,8,7,8
+P,4,7,5,5,4,6,9,6,5,9,7,4,2,10,3,7
+N,5,10,6,8,6,7,7,6,7,7,6,8,6,8,3,7
+M,1,0,2,0,1,7,6,9,0,7,8,8,6,6,0,8
+F,5,9,7,7,3,5,13,4,5,13,7,3,1,10,2,6
+Q,5,6,7,8,8,10,9,6,0,5,7,10,7,13,5,11
+X,4,2,5,4,3,7,7,3,9,6,6,7,2,8,6,7
+S,5,8,6,6,4,7,8,3,7,10,5,7,2,8,5,8
+V,2,1,3,2,1,7,12,2,2,7,11,8,2,11,0,8
+D,5,12,5,6,4,6,8,4,6,10,6,6,5,9,6,6
+U,5,7,5,5,2,4,9,5,7,11,11,9,3,9,1,6
+S,1,3,3,2,1,8,7,3,7,11,4,8,1,8,4,9
+Z,7,10,9,8,6,6,9,3,10,12,8,7,1,9,6,6
+D,6,10,6,8,3,5,8,10,10,8,7,6,3,8,4,8
+B,4,7,6,6,7,8,6,5,5,7,6,8,8,9,7,6
+Q,5,9,4,4,2,10,4,4,6,10,4,8,3,9,7,13
+Y,2,3,4,4,0,7,10,2,2,7,13,8,1,11,0,8
+D,4,7,5,5,4,7,7,6,8,7,6,5,3,8,3,7
+O,4,9,6,7,7,8,8,5,1,7,7,9,8,9,4,9
+D,2,3,3,2,2,9,6,4,6,10,4,6,2,8,2,9
+B,5,9,5,4,4,7,8,3,4,9,6,7,6,7,8,5
+Q,1,0,2,1,1,8,7,6,4,6,6,9,2,8,3,8
+H,6,7,8,5,4,7,6,3,7,10,7,9,3,8,3,7
+P,4,10,5,7,3,5,10,10,3,9,6,4,2,10,4,8
+T,2,1,2,2,1,8,11,3,5,7,10,7,2,11,1,7
+B,8,15,8,8,7,11,5,4,5,10,4,8,7,6,8,10
+D,5,9,5,7,5,5,7,9,7,6,4,5,3,9,4,9
+G,6,9,6,6,4,6,7,6,7,10,8,9,3,8,5,9
+E,5,10,3,5,2,6,8,5,7,10,6,10,1,9,7,9
+Z,7,8,5,11,4,7,6,6,5,10,7,7,3,9,9,7
+O,2,7,3,5,3,7,7,7,4,7,5,8,3,8,2,8
+X,6,11,9,8,6,4,9,1,8,10,11,10,3,9,3,5
+U,5,9,8,7,10,8,6,4,4,6,7,8,10,9,5,8
+M,4,2,5,3,4,6,6,6,5,7,7,10,8,6,2,8
+Y,3,5,5,3,2,4,11,3,6,12,10,5,1,11,2,5
+N,3,4,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+P,4,7,6,5,3,5,12,6,3,12,5,2,1,10,3,8
+W,4,10,7,8,6,7,10,2,3,6,9,8,8,11,1,8
+R,6,9,8,6,9,7,8,3,5,5,6,9,6,9,7,6
+N,4,8,6,6,3,4,9,4,4,10,10,9,5,8,1,7
+Z,5,10,5,5,3,11,4,3,7,11,4,9,2,9,4,11
+O,4,9,5,7,4,8,7,8,5,10,6,7,3,8,3,8
+A,4,10,6,8,4,9,2,2,3,8,2,8,3,6,4,7
+U,8,12,7,7,3,5,4,5,5,4,7,8,6,8,2,7
+N,5,11,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+E,3,7,4,5,2,3,7,6,10,7,6,14,0,8,7,7
+R,4,8,4,6,4,5,10,7,3,7,4,9,2,7,5,11
+L,6,11,8,8,6,5,4,2,8,6,1,9,1,6,3,7
+N,7,10,10,8,5,4,10,4,4,11,11,10,6,8,1,7
+D,4,9,6,6,5,6,7,8,7,7,7,5,3,8,3,8
+D,4,8,4,6,4,6,7,9,7,6,5,6,2,8,3,8
+L,2,7,2,5,1,0,1,5,6,0,0,7,0,8,0,8
+E,4,5,5,4,5,6,7,4,3,7,7,9,4,11,8,11
+C,4,10,5,8,3,6,7,10,8,10,8,11,2,12,4,9
+W,6,11,9,9,4,9,7,5,2,7,8,8,9,9,0,8
+U,3,7,4,5,3,8,5,11,4,8,12,7,3,9,0,8
+M,13,14,13,8,6,5,9,5,7,4,3,11,9,9,2,8
+C,5,12,4,7,4,9,6,4,2,9,8,11,4,9,7,13
+C,4,10,6,8,7,6,6,4,3,8,7,11,6,9,3,8
+R,6,11,8,8,8,7,9,6,5,8,6,8,5,8,7,12
+C,4,9,5,7,6,5,6,3,4,7,6,9,6,9,6,7
+M,7,9,10,7,12,10,7,4,5,9,4,6,10,6,5,5
+K,6,9,5,4,2,6,8,3,6,9,9,10,5,10,3,6
+C,3,4,4,3,1,5,9,5,7,11,9,12,1,9,3,7
+T,5,7,5,5,2,4,12,3,7,12,10,4,1,10,1,5
+O,5,5,7,8,3,7,5,9,9,6,4,7,3,8,4,8
+A,2,9,4,6,3,11,2,1,2,9,3,9,2,6,3,8
+R,4,10,6,7,6,8,8,5,5,9,5,7,4,7,5,10
+M,4,5,7,3,4,9,6,3,5,9,4,7,9,7,2,8
+A,4,10,7,7,2,5,5,3,1,5,1,7,3,7,2,7
+D,3,7,4,5,2,6,6,10,9,5,5,6,3,8,4,8
+Q,4,6,5,8,5,8,5,8,5,6,5,9,3,8,5,9
+O,3,5,4,3,2,8,7,7,4,9,6,8,2,8,3,8
+C,2,4,2,3,1,6,8,6,7,8,8,13,1,10,3,10
+M,7,7,10,6,11,9,7,5,5,7,6,7,11,9,7,3
+B,8,12,6,6,4,9,6,5,6,11,4,9,6,7,7,10
+I,5,10,7,8,4,8,4,2,6,7,7,7,1,10,4,7
+N,3,3,4,4,2,7,7,14,2,5,6,8,6,8,0,8
+F,3,11,4,8,2,0,11,4,6,11,11,9,0,8,2,6
+O,6,10,7,8,6,8,5,9,5,5,5,5,5,8,5,8
+O,6,9,6,7,4,7,8,8,5,10,7,8,3,8,3,8
+C,5,11,7,8,8,7,6,4,4,8,7,11,6,9,3,8
+X,2,3,3,4,1,7,7,4,4,7,6,8,3,8,4,8
+X,9,14,9,8,5,3,10,3,8,12,11,9,4,8,3,5
+T,6,8,6,6,4,6,11,4,6,11,9,5,3,12,2,4
+F,2,4,3,3,2,5,10,4,5,10,9,5,1,9,3,6
+C,5,11,6,8,4,5,7,6,9,8,4,11,1,10,5,10
+F,6,10,6,5,4,8,10,3,5,11,5,4,4,9,7,7
+C,4,6,5,4,3,4,8,5,7,9,9,14,1,8,3,8
+X,4,7,5,5,4,8,6,2,5,6,7,7,2,9,7,9
+T,4,11,6,8,2,7,15,1,6,8,11,7,0,8,0,8
+D,4,6,5,4,3,8,8,6,7,9,6,4,3,8,4,8
+E,3,6,4,4,2,4,8,6,10,7,5,13,0,8,7,8
+W,7,11,10,9,7,10,11,3,3,5,9,7,10,13,1,7
+A,3,2,5,3,2,6,2,2,2,5,2,8,2,6,2,6
+K,4,10,5,8,2,3,7,7,3,7,7,11,4,8,3,10
+N,3,6,4,4,3,7,9,6,4,7,6,7,5,9,1,7
+C,5,8,6,6,3,7,6,6,8,13,7,12,2,10,4,7
+Q,5,5,5,7,4,7,8,5,4,8,9,9,3,9,7,8
+S,4,9,6,7,8,7,6,3,2,7,5,7,3,7,12,2
+Q,4,10,5,9,3,8,6,9,7,5,5,8,3,8,4,8
+G,6,10,5,5,3,8,7,5,6,10,4,7,4,7,5,8
+Y,4,5,6,7,1,8,10,2,2,6,13,8,1,11,0,8
+Q,4,6,4,8,5,8,8,6,2,8,8,10,3,9,5,8
+I,6,10,7,8,4,8,4,1,6,7,7,8,1,10,4,8
+U,5,8,5,6,2,4,9,6,7,11,10,8,3,9,1,7
+V,7,15,6,8,3,7,11,5,5,9,10,5,5,12,4,8
+Y,2,1,3,2,1,7,10,1,7,7,11,8,1,11,1,8
+A,5,9,6,7,7,8,8,8,4,6,6,8,3,8,8,4
+B,3,4,4,3,3,8,7,5,6,7,6,6,2,8,6,10
+D,4,9,6,6,5,7,7,7,7,6,6,5,3,8,3,7
+H,3,5,5,3,3,8,6,2,6,10,5,8,3,7,3,8
+N,2,4,3,2,2,7,8,5,4,7,6,6,4,8,1,6
+V,7,8,7,6,4,4,12,1,2,9,10,7,6,11,2,7
+I,5,9,7,6,4,6,6,3,7,7,6,12,0,8,4,9
+S,5,11,6,8,4,6,8,4,8,11,7,7,2,9,5,6
+F,2,3,4,2,1,6,10,2,5,13,7,5,1,9,1,7
+P,6,9,5,5,2,7,8,5,3,12,4,5,5,9,4,8
+F,1,0,1,0,0,3,11,4,3,11,9,7,0,8,2,8
+Y,8,10,8,8,4,3,10,3,7,12,12,7,1,11,2,5
+W,7,10,10,8,7,5,8,4,1,7,9,8,8,10,0,7
+Z,6,10,8,7,6,7,7,2,9,12,6,9,1,9,6,8
+E,2,3,3,2,2,7,7,1,7,10,5,9,1,8,4,9
+P,2,5,4,3,2,8,9,4,4,11,4,3,1,10,2,8
+O,3,6,4,4,2,8,7,7,4,10,5,8,3,8,3,7
+O,4,8,4,6,4,7,7,7,4,10,6,8,3,8,3,6
+L,2,4,2,3,1,3,4,3,7,3,1,7,0,7,1,6
+R,1,0,2,1,1,6,9,7,3,7,5,7,2,7,4,10
+A,3,5,6,6,2,8,3,3,2,7,1,8,3,6,3,8
+L,4,10,4,8,1,0,1,5,6,0,0,6,0,8,0,8
+R,4,10,5,7,3,5,11,8,4,7,3,9,3,7,6,11
+J,5,9,6,6,2,9,4,3,9,15,4,11,0,7,0,8
+Y,6,11,8,8,8,8,4,6,5,8,7,8,9,7,6,5
+S,3,7,4,5,3,8,8,7,5,7,5,6,2,8,8,8
+Y,8,10,8,8,4,5,8,2,9,9,10,4,5,11,7,3
+D,1,1,2,2,1,6,7,8,6,6,6,6,2,8,3,8
+X,7,14,7,8,4,6,8,2,7,11,7,8,4,9,4,7
+R,4,9,6,7,5,8,8,6,6,8,5,7,3,8,6,10
+Q,2,4,3,5,2,8,8,6,2,7,8,10,2,9,5,9
+Z,2,3,3,2,2,7,8,5,9,6,6,9,1,8,7,8
+C,5,9,6,7,4,5,7,6,9,6,6,10,1,6,5,10
+T,2,6,3,4,1,6,14,0,5,8,10,7,0,8,0,8
+B,3,5,5,3,3,9,6,3,6,10,4,7,4,7,6,9
+A,6,9,8,8,7,7,7,2,4,7,8,10,8,7,4,8
+W,4,5,6,5,7,7,7,5,5,6,6,8,9,9,8,8
+C,3,8,4,6,2,6,8,8,7,9,8,14,2,9,4,10
+S,2,2,3,3,2,8,7,7,5,8,6,7,2,9,9,8
+C,5,7,7,6,6,5,7,4,4,7,6,11,4,9,7,9
+V,2,6,3,4,1,7,9,4,2,7,13,8,3,10,0,8
+Y,6,11,6,8,3,3,10,3,6,12,12,7,1,11,2,6
+N,2,3,3,1,1,7,9,5,5,8,7,6,5,9,1,6
+D,2,5,4,3,3,9,6,4,6,10,4,6,2,8,3,8
+Z,5,9,7,7,4,8,7,2,10,12,5,9,1,8,6,9
+Y,2,5,4,4,2,7,10,1,7,7,11,8,1,11,2,8
+O,2,6,3,4,2,8,7,8,5,7,7,9,3,8,3,8
+C,2,1,3,2,1,6,7,6,10,7,6,14,0,8,4,9
+H,2,4,4,2,2,9,7,3,5,10,4,7,3,8,2,9
+Z,6,7,4,10,4,8,6,4,4,11,6,7,2,10,9,8
+S,4,2,4,4,3,8,7,7,5,7,6,8,2,9,9,8
+T,3,5,4,4,2,6,12,2,7,8,11,7,1,11,1,7
+H,2,3,4,2,2,7,7,3,5,10,6,8,3,8,2,7
+V,3,2,5,3,2,7,12,2,3,6,11,9,3,11,1,7
+A,2,6,4,4,2,8,4,2,1,7,2,8,2,6,2,8
+J,1,3,2,2,0,9,6,2,5,14,6,10,0,7,0,7
+F,5,10,5,5,3,7,8,3,4,10,6,7,4,8,7,6
+P,6,9,8,7,6,8,9,4,4,12,5,4,1,10,3,8
+W,3,8,5,6,5,9,11,2,2,5,8,8,6,11,1,8
+U,4,4,5,3,2,4,8,5,7,11,10,9,3,9,1,7
+B,7,10,9,8,9,9,7,4,6,10,5,6,2,8,5,10
+V,4,4,6,7,1,8,8,4,3,6,14,8,3,9,0,8
+Q,2,4,3,4,3,8,8,6,3,8,6,9,2,9,4,9
+R,4,8,5,6,3,6,13,8,4,7,2,9,3,7,6,10
+F,5,9,6,7,6,6,10,6,5,8,5,8,3,10,8,10
+N,6,10,9,8,5,10,8,3,6,10,2,4,5,9,1,7
+L,3,7,5,5,2,3,3,6,8,1,0,6,0,7,1,6
+D,4,8,6,6,5,7,6,8,6,5,5,4,4,8,4,8
+A,5,11,8,9,5,12,3,3,3,10,1,9,3,7,4,9
+S,3,5,6,3,2,7,8,2,7,11,6,6,1,9,4,6
+N,2,3,4,2,2,6,8,3,3,10,7,8,4,8,0,7
+J,3,4,4,6,1,11,2,10,3,13,8,14,1,6,0,8
+Y,5,9,4,4,2,6,8,3,4,10,8,5,3,9,4,4
+X,4,10,7,7,4,9,7,0,8,9,5,7,2,8,3,8
+G,6,5,7,8,3,7,5,8,10,7,5,12,1,8,6,11
+W,4,2,6,4,4,8,11,2,2,6,9,8,7,11,1,8
+P,2,1,3,2,2,6,9,4,4,9,8,5,1,10,3,7
+H,2,4,3,3,2,6,7,5,6,7,6,8,6,8,3,8
+A,1,3,3,2,1,6,3,2,2,5,2,8,1,6,1,7
+O,4,6,4,4,3,8,6,8,6,9,4,7,3,8,3,8
+L,3,9,4,6,3,6,5,0,8,8,3,11,0,8,2,8
+O,6,8,8,7,6,7,5,5,5,8,4,7,3,7,5,7
+V,4,6,4,4,2,3,12,4,3,11,11,7,2,10,1,7
+M,5,6,8,4,5,7,6,2,5,9,7,8,8,6,2,8
+F,5,9,7,6,4,8,9,2,6,14,5,5,2,9,3,8
+Q,7,8,10,7,8,6,4,4,6,5,4,7,5,3,7,6
+Q,3,5,4,6,3,8,6,6,4,9,6,9,3,9,4,8
+L,4,9,5,8,5,6,8,4,6,7,6,9,3,9,9,10
+G,4,6,4,4,3,6,7,5,5,9,8,11,2,8,4,10
+C,5,6,6,5,5,5,8,3,5,7,6,10,3,10,8,7
+M,2,3,4,2,2,6,7,3,4,9,9,9,5,5,1,7
+D,4,8,6,6,8,9,9,4,4,8,7,5,4,9,8,6
+M,3,3,4,2,3,6,6,6,4,7,7,10,7,5,2,9
+H,5,10,8,8,10,7,6,6,4,7,5,8,9,6,10,10
+J,6,8,8,6,5,8,8,6,6,8,7,7,4,6,4,6
+L,3,6,4,5,4,9,7,4,6,6,6,9,2,8,7,10
+X,2,6,3,4,2,7,7,4,4,7,6,7,2,8,4,7
+G,7,10,7,8,5,6,8,6,6,10,8,9,3,7,6,9
+U,6,9,6,6,4,3,9,5,6,10,10,10,3,9,2,7
+Z,5,8,6,6,4,7,8,2,9,11,7,8,1,9,6,7
+L,2,5,3,4,2,7,4,1,7,8,2,9,0,7,2,8
+M,2,0,2,1,1,7,6,10,0,7,8,8,6,6,0,8
+D,3,9,4,7,4,6,7,10,7,7,7,6,3,8,3,8
+S,4,9,4,4,2,7,4,2,4,7,2,7,2,7,5,8
+X,5,6,6,8,2,7,7,5,4,7,6,8,3,8,4,8
+F,5,9,6,6,6,5,9,4,6,10,10,6,2,9,3,6
+S,4,9,4,4,2,7,4,4,4,8,2,8,3,7,5,8
+H,2,3,4,2,2,7,7,3,6,10,6,8,3,8,2,7
+Z,4,8,5,6,2,7,7,4,15,9,6,8,0,8,8,8
+P,8,13,7,7,3,6,10,5,3,13,5,4,4,10,4,8
+T,5,6,6,5,5,6,7,3,8,7,6,10,3,6,7,6
+A,1,3,2,2,1,10,2,2,1,9,2,9,1,6,2,8
+C,5,9,4,5,1,6,8,6,7,11,7,9,2,9,5,9
+S,3,3,4,4,2,8,9,5,9,5,6,6,0,8,9,7
+V,5,10,7,8,4,7,12,2,3,6,11,9,4,10,3,7
+T,5,8,5,6,3,4,13,5,5,12,9,4,2,12,1,5
+U,9,14,8,8,4,7,6,4,5,4,8,5,7,5,3,6
+C,2,1,2,2,1,6,8,7,7,8,7,13,1,8,4,10
+I,4,9,5,7,3,9,6,0,7,13,5,8,0,8,1,8
+I,0,3,1,2,1,7,7,1,6,7,6,8,0,8,2,8
+Y,7,11,7,8,5,5,8,0,8,9,9,5,4,10,7,4
+J,0,0,1,1,0,12,4,4,3,12,4,10,0,7,0,8
+P,9,14,9,8,6,9,7,4,5,13,4,4,5,9,7,8
+W,3,1,3,2,1,7,8,4,1,7,8,8,7,10,0,8
+W,5,7,5,5,4,4,10,3,2,9,8,7,6,11,2,6
+B,2,1,3,2,2,7,7,4,5,6,6,5,2,8,5,9
+P,6,12,5,6,4,9,8,4,4,12,4,4,4,11,5,7
+W,4,6,5,4,2,11,8,5,1,6,9,8,8,10,0,8
+U,5,10,8,8,10,8,8,4,5,6,6,8,9,5,8,10
+X,3,7,5,5,4,7,7,2,6,7,5,8,3,6,5,8
+R,5,9,5,4,4,8,7,3,4,9,4,8,5,8,6,8
+X,3,7,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+Q,5,8,6,7,6,7,4,5,4,7,4,9,5,4,7,6
+G,8,15,6,8,5,9,5,5,3,9,6,9,5,9,8,8
+Y,2,7,4,4,1,10,10,3,2,5,13,8,2,11,0,8
+J,2,7,2,5,2,9,6,1,6,11,4,8,0,7,1,6
+A,5,13,5,7,4,11,2,4,2,11,4,11,5,3,4,10
+M,3,3,4,2,3,8,6,7,4,7,7,8,7,5,1,8
+E,6,9,8,7,7,8,8,7,3,6,6,11,6,8,9,8
+L,4,8,5,7,5,8,6,4,5,6,7,8,3,9,7,9
+H,6,11,8,8,8,6,8,8,4,7,5,7,3,7,7,10
+K,4,5,6,4,3,6,8,2,7,10,6,9,4,9,3,7
+V,3,3,4,2,1,4,13,3,2,10,11,7,2,11,1,8
+M,5,10,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+I,3,11,5,8,6,9,6,3,4,8,5,5,5,8,5,5
+W,2,0,2,1,1,7,8,3,0,7,8,8,6,9,0,8
+S,5,8,7,6,8,8,6,5,3,8,5,8,4,9,10,9
+L,4,8,5,7,5,7,6,4,5,7,7,8,4,9,9,11
+Y,2,1,3,1,0,8,11,3,1,6,12,8,1,11,0,8
+O,5,10,4,5,3,5,8,7,3,10,7,8,5,9,5,7
+B,5,10,7,7,7,11,6,2,6,10,3,7,4,7,6,11
+U,5,5,6,4,3,5,8,5,8,10,8,9,3,9,3,5
+C,4,7,5,5,3,7,7,8,6,7,6,10,3,8,3,9
+O,4,10,5,7,4,7,7,8,5,6,4,7,3,9,4,9
+Y,1,0,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+O,6,9,6,7,4,6,8,8,5,10,8,7,4,8,4,9
+X,6,9,6,4,3,10,7,2,8,9,4,7,4,10,4,9
+G,4,8,6,6,6,7,7,6,3,6,6,9,4,8,7,8
+W,6,9,8,7,6,8,8,4,1,7,9,8,8,10,0,8
+I,2,11,2,8,2,7,7,0,9,7,6,8,0,8,3,8
+L,3,3,4,4,1,1,0,6,6,0,1,5,0,8,0,8
+K,6,9,9,7,5,3,9,3,7,11,12,12,4,7,4,5
+P,5,9,7,6,5,7,12,7,2,11,5,3,2,12,4,8
+I,1,10,0,7,1,7,7,5,3,7,6,8,0,8,0,8
+A,2,4,4,2,2,11,2,3,2,10,2,10,2,6,2,9
+T,4,11,6,8,4,6,14,0,5,8,10,8,0,8,0,8
+I,2,8,3,6,2,7,7,0,7,12,6,8,0,8,1,8
+P,5,11,6,8,6,4,12,8,2,10,7,4,1,10,3,8
+Q,4,9,5,11,6,8,7,8,4,5,6,9,3,8,6,10
+L,5,9,7,8,6,7,7,4,5,7,7,8,3,8,8,9
+V,7,9,7,5,3,6,10,4,3,8,8,5,5,12,3,9
+N,5,6,7,4,3,5,9,3,5,11,9,9,5,8,1,7
+U,4,9,6,7,9,9,6,4,4,6,7,7,9,8,5,7
+G,2,3,2,2,1,6,7,5,4,9,7,9,2,9,4,9
+M,3,3,4,2,3,9,6,6,4,6,7,6,7,6,2,6
+W,3,6,5,4,2,6,8,4,1,7,8,8,8,9,0,8
+G,5,11,4,6,3,7,7,4,3,9,6,7,3,10,8,7
+K,3,2,3,4,1,3,7,7,2,7,7,11,3,8,3,10
+N,3,2,4,3,2,7,8,5,4,7,6,7,5,9,2,6
+K,5,7,7,5,4,8,7,2,7,10,3,8,4,9,4,9
+R,6,10,8,8,6,7,9,5,8,5,4,10,5,4,7,9
+I,1,6,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+R,3,7,5,5,4,9,7,4,5,10,4,7,3,7,4,11
+P,4,7,5,5,4,6,10,6,5,10,8,3,1,10,4,6
+N,3,6,4,4,2,7,7,14,2,5,6,8,6,8,0,8
+X,4,9,5,6,3,8,7,4,9,6,6,6,3,8,6,7
+H,7,10,10,7,9,9,7,3,6,10,4,7,3,8,3,9
+U,9,10,9,8,5,5,7,6,9,9,8,9,5,11,5,2
+J,2,2,4,4,2,11,6,2,7,12,3,7,0,7,1,8
+X,4,9,4,7,3,7,7,4,4,7,6,8,3,8,4,8
+W,4,9,6,7,4,6,8,4,2,7,8,8,8,10,0,8
+K,3,7,3,5,1,3,7,7,3,7,6,11,4,8,2,11
+K,3,7,4,4,1,4,8,7,2,7,5,11,3,8,3,10
+R,4,11,5,8,3,6,11,10,4,7,3,9,3,7,5,11
+B,4,8,5,6,5,7,7,6,4,6,5,6,3,8,6,6
+N,5,7,7,5,4,7,9,2,4,10,5,6,5,9,1,7
+B,3,6,4,4,4,8,8,6,6,7,6,6,2,8,6,9
+V,6,10,8,7,5,6,11,3,2,8,11,8,3,10,4,8
+R,7,12,6,7,5,6,8,5,5,9,5,10,7,5,7,11
+P,3,8,3,5,2,3,14,7,2,12,7,3,0,10,3,8
+B,4,5,4,8,4,6,9,10,7,7,5,7,2,8,9,10
+T,6,8,6,6,3,5,12,3,8,12,9,4,1,11,2,4
+B,3,5,5,4,3,9,7,2,6,11,4,7,4,6,5,9
+Q,6,10,6,5,3,10,4,4,7,10,4,9,3,8,6,13
+Q,2,1,2,2,1,8,6,7,4,6,6,8,3,8,3,8
+S,1,0,1,0,0,8,7,4,6,5,6,8,0,8,7,8
+T,4,8,6,6,6,7,7,4,7,7,6,8,5,7,5,6
+F,3,8,4,6,3,4,10,3,6,10,10,6,1,10,3,6
+Y,1,3,3,2,1,7,10,1,6,7,11,8,1,11,1,8
+W,7,11,10,8,7,7,11,2,3,6,9,8,12,11,2,7
+G,4,10,5,7,3,7,7,8,7,6,6,8,2,7,6,11
+M,2,3,3,2,2,8,7,5,4,6,7,8,5,6,1,7
+W,6,8,8,6,7,8,6,6,2,7,7,8,6,8,4,7
+R,2,6,3,4,2,6,9,9,4,7,5,8,2,7,5,11
+D,5,7,6,5,4,7,8,7,5,8,6,5,4,9,3,7
+K,8,10,11,8,6,8,6,2,8,10,4,9,4,7,5,9
+B,1,3,3,1,1,9,7,2,5,10,4,7,1,8,2,9
+O,3,7,4,5,3,7,8,8,4,7,6,8,3,8,3,8
+K,3,4,4,2,2,5,7,4,7,7,6,11,3,8,4,9
+G,2,1,2,2,1,8,6,6,6,6,5,10,1,7,5,10
+X,4,11,5,8,2,7,7,4,4,7,6,8,3,8,4,8
+C,3,7,4,5,2,7,7,7,10,10,6,13,1,10,4,9
+G,3,6,4,4,3,5,7,6,5,9,7,11,2,8,4,10
+O,2,1,3,2,2,7,7,7,5,7,5,8,2,8,3,8
+I,9,14,6,8,3,11,4,5,5,12,3,8,3,7,5,10
+P,2,3,3,2,1,7,10,4,3,12,5,3,1,10,2,8
+O,2,3,3,2,1,7,7,7,5,7,6,8,2,8,3,7
+Y,6,8,9,11,11,8,11,3,4,6,8,9,5,13,11,8
+F,5,9,7,7,5,6,9,6,8,10,10,5,2,9,4,5
+G,5,7,6,5,4,5,7,5,6,9,8,9,2,9,5,9
+K,3,3,5,2,2,6,8,2,6,10,6,9,3,9,3,7
+Q,2,2,3,3,2,8,7,6,2,5,6,9,2,9,4,9
+R,13,15,10,8,6,8,7,5,6,10,3,8,7,6,6,11
+B,5,10,6,8,7,9,7,3,5,7,6,8,7,8,6,9
+B,4,11,5,8,4,6,6,9,7,6,6,6,3,8,10,11
+V,4,7,4,5,2,4,11,3,3,9,11,7,2,10,1,8
+A,5,11,8,8,4,8,2,2,3,6,2,7,5,7,6,8
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+W,6,5,7,4,4,6,10,4,3,8,7,7,9,11,3,5
+N,5,9,8,7,4,10,6,3,5,10,2,5,6,9,1,7
+M,5,10,7,8,7,8,6,5,5,6,8,7,8,6,2,7
+O,2,0,2,1,1,8,7,7,6,7,6,8,2,8,3,8
+X,5,9,8,7,4,8,7,1,8,10,5,8,3,8,4,8
+O,2,2,3,3,2,7,7,8,4,7,7,8,2,8,3,8
+P,3,7,4,5,3,4,12,4,5,11,9,3,0,10,4,7
+W,5,6,5,4,4,2,11,2,3,10,10,8,5,11,1,7
+G,4,9,5,6,3,6,7,7,7,10,8,9,2,9,4,9
+Z,1,1,2,2,1,7,7,5,8,6,6,8,2,8,6,8
+O,4,8,5,6,3,6,9,7,5,10,8,7,3,8,3,8
+S,3,8,4,6,2,8,7,5,8,5,6,6,0,8,8,8
+C,3,7,4,5,2,5,8,7,7,8,8,14,1,9,4,10
+M,3,4,5,2,3,9,6,3,4,9,4,6,8,6,2,8
+G,4,9,5,7,4,5,7,5,4,9,9,9,2,7,5,9
+U,7,13,7,7,4,8,5,4,4,6,7,7,5,7,3,7
+Q,5,9,6,8,5,8,7,7,5,6,8,8,3,8,5,10
+G,5,8,6,6,4,7,6,7,8,7,5,11,3,11,5,8
+T,3,8,5,6,4,6,11,2,7,8,11,8,2,12,1,7
+E,3,6,3,4,2,3,8,6,10,7,5,14,0,8,7,8
+R,5,9,6,6,3,6,13,9,3,7,2,9,3,7,5,10
+W,2,0,3,1,1,7,8,4,0,7,8,8,7,9,0,8
+Y,7,10,6,5,3,8,6,3,5,9,8,6,4,10,4,5
+V,5,10,7,7,8,8,7,5,2,8,7,8,5,10,5,8
+X,2,1,2,1,0,8,7,4,4,7,6,8,3,8,4,8
+Z,6,7,8,9,8,9,8,6,5,9,3,6,3,5,8,7
+U,3,4,3,6,2,7,5,13,5,7,13,8,3,9,0,8
+B,4,10,6,8,8,8,7,6,6,6,6,6,3,9,6,10
+C,7,10,8,8,8,6,6,3,5,8,6,12,6,9,5,10
+G,6,13,6,7,3,7,6,5,4,9,5,5,4,8,5,7
+G,4,9,4,4,3,8,6,4,2,9,6,8,3,9,7,7
+R,2,3,2,2,2,6,7,4,4,6,5,7,2,7,4,9
+Y,1,0,2,0,0,7,9,3,1,7,13,8,1,11,0,8
+S,6,10,7,7,4,10,5,4,8,11,4,8,2,9,5,10
+X,7,11,10,9,5,7,7,1,9,10,6,8,3,8,4,7
+Z,1,0,1,0,0,7,7,2,9,8,6,8,0,8,6,8
+P,7,12,6,7,3,9,7,5,4,12,3,6,5,9,4,8
+M,3,5,6,4,4,5,6,3,4,10,10,10,6,5,2,7
+S,6,8,7,6,4,9,6,4,8,11,4,8,2,8,5,11
+H,7,10,10,8,8,6,8,3,6,10,8,8,4,9,4,7
+Z,6,11,8,9,8,10,7,5,4,7,5,7,4,8,10,5
+C,8,13,5,7,3,6,10,6,9,11,8,10,2,8,5,9
+W,9,9,9,7,8,4,11,2,2,9,8,7,7,12,2,6
+M,2,1,3,3,3,7,6,7,3,7,7,10,6,5,1,9
+C,3,7,4,5,2,5,8,7,7,9,8,13,1,10,4,10
+D,5,9,8,6,5,9,7,5,8,10,4,5,3,8,3,8
+C,3,6,5,4,1,6,8,6,10,7,7,12,1,7,4,9
+D,4,6,6,4,4,7,6,7,5,5,5,5,3,8,3,8
+R,3,6,5,4,3,9,8,3,6,9,3,8,3,6,4,10
+Z,3,2,4,3,2,7,7,5,9,6,6,8,1,8,7,8
+G,5,11,7,8,8,7,6,7,3,7,6,10,5,8,8,8
+H,3,8,5,6,7,8,9,5,3,7,7,7,9,8,9,8
+W,6,9,6,4,3,3,9,2,2,9,11,8,7,11,0,7
+T,4,11,5,8,2,7,15,1,6,8,11,8,0,8,0,8
+R,8,13,6,8,4,10,6,6,4,10,2,9,7,5,6,10
+J,1,6,2,4,1,14,2,5,5,13,1,9,0,7,0,8
+O,5,10,7,7,8,8,9,6,2,6,7,9,11,13,5,9
+U,6,11,8,8,12,8,7,4,4,6,7,8,8,8,6,7
+S,3,5,4,4,2,8,6,3,7,11,5,9,1,9,5,9
+K,5,9,8,7,9,7,10,4,4,5,6,9,8,8,7,8
+N,3,5,4,3,3,7,8,5,4,7,7,7,5,9,2,6
+A,6,10,8,8,8,7,8,8,4,6,5,9,3,7,8,5
+K,4,7,5,5,2,4,8,9,1,7,6,11,3,8,2,11
+G,3,5,4,4,3,6,7,5,4,9,8,9,3,7,5,10
+D,1,3,2,2,1,8,7,5,5,9,5,6,2,8,3,8
+W,1,0,2,0,0,8,8,3,0,7,8,8,4,10,0,8
+J,5,10,4,8,3,10,6,2,4,12,5,7,2,10,5,11
+N,3,5,5,3,2,7,8,2,4,10,6,6,5,8,0,7
+F,5,11,5,6,4,8,8,2,4,10,5,6,4,9,7,7
+C,4,9,3,4,2,7,10,4,4,8,8,8,3,9,8,11
+F,5,9,7,7,8,10,7,1,5,9,4,5,4,10,5,8
+E,3,4,3,6,2,3,7,6,10,7,6,14,0,8,7,8
+E,5,9,7,7,6,9,6,2,7,11,4,9,3,8,5,11
+M,3,6,4,4,3,7,5,10,1,7,8,8,7,5,0,9
+U,10,11,10,8,4,3,9,6,9,12,12,9,3,9,1,7
+C,6,10,7,8,5,3,7,4,7,10,8,15,4,9,5,6
+F,5,11,6,8,7,7,8,5,4,8,6,8,9,10,7,12
+U,5,10,7,7,6,7,8,4,7,4,7,9,6,10,1,8
+E,5,8,7,6,4,10,6,2,8,11,4,8,3,8,5,11
+C,4,10,5,8,2,5,7,7,10,7,5,13,1,9,4,8
+B,5,11,5,8,4,6,8,10,7,7,5,7,3,8,9,10
+G,1,0,2,1,0,8,7,6,5,6,5,9,1,7,5,10
+K,5,9,5,6,2,5,9,9,2,7,3,11,4,8,2,11
+W,4,9,7,7,6,7,8,4,1,7,9,8,7,11,0,8
+S,3,6,4,4,3,8,8,5,8,5,6,6,0,7,8,7
+W,2,1,2,1,1,8,8,4,0,7,8,8,6,10,0,8
+Y,6,6,5,9,3,7,11,1,3,9,10,5,4,10,6,8
+S,3,9,4,7,3,8,7,5,8,5,6,7,0,8,8,8
+U,3,6,4,6,4,8,7,4,3,6,6,8,4,8,1,7
+K,5,9,8,8,7,8,6,2,3,8,3,8,6,5,8,12
+V,3,8,5,6,1,8,8,4,3,6,14,8,3,10,0,8
+V,2,7,4,5,2,7,9,3,1,8,12,8,2,11,0,8
+M,4,6,5,4,2,8,7,12,1,6,9,8,8,6,0,8
+G,4,7,5,5,3,5,8,6,6,9,8,9,2,7,4,9
+U,3,6,5,5,4,7,7,4,4,6,6,8,4,8,1,7
+Q,4,7,5,9,5,9,7,8,3,5,7,10,3,8,6,10
+O,5,9,4,4,2,9,7,5,4,9,4,8,4,9,5,9
+X,4,5,5,4,4,7,7,2,4,7,6,8,2,9,7,7
+X,3,4,4,3,2,7,7,3,9,6,6,9,2,8,5,8
+P,5,4,5,6,2,4,13,8,1,10,6,3,1,10,4,8
+X,3,4,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+I,2,11,3,8,4,8,7,0,7,7,6,8,0,8,3,7
+A,3,7,5,6,4,7,8,2,4,7,8,9,5,8,3,6
+W,5,6,5,4,4,4,10,3,2,9,9,7,6,11,2,6
+U,5,8,5,6,3,3,8,5,7,10,10,10,3,9,2,6
+V,4,5,5,3,2,4,12,4,4,11,11,7,2,10,1,8
+D,6,10,9,8,7,10,6,2,7,11,4,7,5,6,4,10
+T,4,2,5,4,3,9,12,3,7,5,11,9,2,11,1,8
+D,4,8,4,6,4,5,7,9,7,5,4,6,2,8,3,8
+D,3,8,4,6,2,5,7,10,8,7,6,5,3,8,4,8
+D,4,6,4,4,3,5,7,9,7,7,6,6,2,8,3,8
+U,7,8,7,6,3,3,10,6,8,13,12,8,3,9,1,7
+I,7,11,9,8,6,10,5,2,7,7,7,4,0,9,4,7
+N,9,15,7,8,4,6,9,4,5,4,5,11,6,11,2,7
+V,6,11,6,6,3,7,7,4,4,7,7,6,6,12,2,8
+V,4,5,6,4,2,4,12,3,3,10,11,7,3,10,1,7
+S,5,10,4,6,2,7,3,4,4,8,2,7,3,7,5,8
+Q,2,2,3,3,2,8,8,6,2,5,7,9,2,9,5,10
+C,4,8,5,6,3,3,8,5,7,10,10,13,1,8,3,7
+P,3,8,5,6,4,7,5,5,4,7,6,9,3,9,6,11
+Z,2,7,3,5,2,6,8,5,10,6,7,9,1,9,8,8
+Y,2,4,4,3,2,6,10,1,7,8,11,8,1,11,2,8
+K,9,13,9,7,4,6,7,3,7,9,9,10,6,10,3,6
+Y,4,5,5,7,7,9,8,6,3,7,7,7,6,10,6,4
+J,7,11,9,8,6,8,4,4,6,8,6,7,5,6,5,7
+B,5,11,7,9,8,8,7,5,4,7,5,7,4,8,6,8
+O,3,2,4,3,2,7,6,7,5,7,5,7,2,8,3,7
+K,5,7,7,6,6,6,7,3,4,6,4,9,5,5,9,7
+K,2,3,4,2,2,7,8,2,6,10,6,8,3,8,2,8
+V,4,10,6,8,2,7,8,4,3,7,14,8,3,9,0,8
+P,4,6,5,4,4,7,9,3,6,8,8,4,1,10,4,7
+R,6,11,9,8,6,8,8,5,6,8,5,7,4,8,6,12
+P,4,7,5,5,4,6,9,6,5,9,7,4,2,10,4,7
+Z,4,7,6,5,3,6,9,3,9,12,9,7,1,9,6,5
+E,4,10,3,5,2,8,7,5,4,11,5,10,3,8,7,11
+Q,7,9,7,10,7,7,9,5,3,7,10,11,3,8,7,7
+Q,2,5,3,6,4,9,10,6,3,3,8,11,2,9,5,10
+X,2,7,3,4,1,7,7,4,4,7,6,8,3,8,4,8
+U,7,9,7,7,4,4,8,6,8,10,10,9,3,9,2,5
+N,5,8,8,6,4,4,10,4,4,10,11,9,6,8,1,7
+T,5,5,6,5,5,6,8,4,8,8,7,9,3,8,7,5
+S,3,6,4,4,3,8,8,5,7,6,6,7,0,8,8,8
+T,5,7,6,5,6,6,8,4,5,6,7,9,6,8,5,8
+G,9,14,7,8,5,9,5,5,3,9,6,8,4,9,8,8
+G,5,10,5,8,4,5,7,6,6,10,8,10,2,8,5,9
+I,2,8,3,6,1,7,7,0,8,14,6,8,0,8,1,7
+C,2,4,3,3,1,5,9,5,6,12,9,10,1,10,2,7
+D,5,7,6,5,5,10,6,3,6,11,4,7,3,8,3,9
+J,3,7,4,5,2,8,7,1,6,14,4,7,0,7,0,7
+L,3,8,3,6,1,0,1,5,6,0,0,7,0,8,0,8
+R,7,13,6,7,5,8,6,3,5,8,5,9,6,9,6,7
+V,2,3,3,2,1,4,12,3,2,10,11,7,2,11,0,8
+M,11,12,11,7,6,6,9,5,4,4,4,11,11,14,3,8
+T,3,10,5,7,1,7,15,1,6,7,11,8,0,8,0,8
+U,6,10,8,7,5,4,8,7,8,9,11,11,3,9,1,8
+M,4,6,7,4,6,12,3,3,1,10,4,9,8,6,2,8
+J,3,10,4,8,4,8,6,2,4,11,5,10,1,6,2,6
+O,4,5,5,4,3,8,7,8,5,7,6,8,2,8,3,8
+Y,5,7,5,5,3,6,8,1,7,8,9,5,2,12,4,4
+B,6,9,5,4,4,9,7,3,5,10,5,7,6,6,7,9
+T,3,4,4,3,1,6,11,2,8,11,9,5,1,10,2,5
+Q,6,7,6,9,6,8,7,6,3,9,8,10,3,8,6,8
+O,7,8,9,7,6,5,7,6,6,8,5,6,3,7,5,7
+E,8,13,6,8,5,7,7,4,4,10,6,9,3,9,8,11
+I,3,8,5,6,3,7,7,0,7,13,6,8,0,8,1,8
+Z,3,9,4,6,2,7,7,4,13,10,6,8,0,8,8,8
+O,2,0,2,1,1,7,7,6,6,7,6,8,2,8,3,8
+V,2,8,4,6,1,9,8,4,2,6,13,8,3,10,0,8
+R,9,14,9,8,7,5,8,2,6,8,4,10,7,5,7,5
+M,5,11,6,9,4,8,7,12,2,6,9,8,9,6,0,8
+N,5,9,7,6,4,9,7,3,5,10,4,6,5,9,1,7
+S,6,11,6,6,3,6,9,3,5,13,8,7,2,9,3,7
+S,2,1,3,2,2,8,7,6,4,7,7,8,2,9,9,8
+D,4,5,5,4,4,7,7,7,7,7,6,5,2,8,3,7
+S,4,6,5,4,3,6,9,3,7,10,7,7,2,7,4,5
+M,6,9,8,8,10,8,7,4,3,7,6,7,10,8,6,5
+J,0,0,1,0,0,12,4,4,3,11,4,11,0,7,0,8
+D,4,8,6,6,4,7,8,7,6,10,6,5,3,8,4,8
+T,4,6,4,4,2,5,12,3,6,11,9,4,2,11,2,5
+R,6,11,6,8,7,5,10,8,3,7,4,8,2,7,5,11
+E,3,4,5,3,2,8,7,1,8,11,5,8,2,8,4,10
+O,9,13,6,7,4,5,6,7,4,9,7,9,5,9,5,8
+C,4,9,5,7,6,5,7,4,5,7,6,9,6,10,5,7
+G,2,1,3,2,2,7,7,5,5,6,6,9,2,9,4,9
+T,4,9,4,4,2,5,11,2,6,11,8,5,2,8,3,5
+A,3,9,6,7,4,11,3,1,2,8,3,9,4,5,3,8
+J,6,9,5,7,3,8,9,2,3,13,4,5,2,9,7,8
+B,9,11,7,6,4,10,4,5,6,11,3,9,5,7,6,11
+T,2,1,3,1,1,7,11,3,5,7,10,8,2,11,1,8
+W,5,6,5,4,4,5,11,3,2,9,8,7,6,12,2,7
+D,9,15,8,8,6,8,6,3,7,10,5,7,6,8,8,5
+E,4,8,4,6,2,3,6,6,11,7,7,14,0,8,7,7
+V,3,3,4,2,1,3,12,4,3,11,11,7,2,11,1,8
+H,10,13,11,8,7,9,6,4,5,11,3,7,6,7,5,7
+V,9,13,7,7,4,9,10,5,5,6,10,6,5,12,3,6
+M,9,13,10,8,6,11,11,7,3,4,7,9,9,13,3,6
+D,2,2,3,3,2,7,7,6,6,7,6,5,2,8,3,7
+C,5,9,6,6,3,5,8,8,9,9,8,12,2,10,4,9
+D,5,10,5,8,6,6,8,9,7,6,5,6,2,8,3,7
+R,9,13,7,7,4,9,5,5,6,9,4,9,6,6,7,11
+U,3,4,4,2,2,5,8,5,7,10,8,9,3,9,2,6
+G,7,9,7,7,5,5,7,6,6,10,8,11,2,9,4,10
+F,2,3,2,2,1,5,10,4,5,10,9,6,1,10,3,7
+K,5,8,8,7,7,9,6,2,4,9,3,8,4,6,7,11
+W,8,10,8,5,3,6,10,2,2,8,10,7,8,12,1,7
+B,5,8,7,6,9,8,8,5,3,7,7,7,6,10,9,9
+S,5,9,7,8,8,8,7,5,6,7,6,8,6,8,10,13
+P,6,11,5,6,3,8,7,5,3,12,3,6,5,9,4,8
+J,2,5,4,4,1,9,7,2,7,14,4,8,0,7,0,7
+L,2,1,2,1,0,2,1,6,5,0,2,5,0,8,0,8
+K,5,10,5,5,3,5,8,3,6,9,8,9,5,7,3,8
+K,5,8,7,6,4,5,8,2,7,10,9,10,3,8,3,7
+S,4,9,6,7,4,7,8,3,7,10,5,7,2,7,4,8
+L,3,6,4,4,2,5,3,1,8,8,2,10,0,7,2,7
+W,7,9,7,7,6,2,11,2,3,10,10,8,6,11,2,7
+Q,7,15,6,8,5,11,4,4,6,10,5,7,3,9,7,12
+E,4,9,6,8,7,6,9,5,5,7,7,11,6,10,9,10
+Z,3,8,5,6,3,7,9,2,9,11,7,7,1,9,6,6
+K,3,7,5,5,5,5,7,4,7,6,5,10,3,8,4,9
+K,3,3,5,2,2,7,6,2,7,10,6,10,4,7,3,8
+W,6,10,6,7,6,3,10,2,3,10,10,8,6,11,2,6
+B,3,7,3,5,3,6,8,8,6,7,5,7,2,8,9,10
+J,2,7,2,5,1,13,2,8,4,13,4,12,1,6,0,8
+H,5,6,8,4,5,8,7,3,6,10,5,8,4,9,4,8
+S,6,10,8,8,11,7,7,3,2,7,6,7,3,8,12,2
+V,3,3,5,5,1,7,8,4,3,7,13,8,3,9,0,8
+N,3,6,5,4,3,6,9,6,4,8,7,8,5,8,1,7
+B,6,9,8,7,8,8,7,5,6,9,6,6,4,10,6,9
+A,3,7,5,5,2,12,3,4,3,11,2,10,2,6,3,9
+H,3,5,5,4,3,7,7,3,6,10,6,8,3,8,3,8
+X,6,12,7,7,4,8,7,2,7,11,4,6,4,8,4,7
+N,6,11,8,8,5,10,8,3,5,9,3,5,6,9,1,7
+V,7,10,7,7,3,4,11,2,4,9,11,7,4,10,1,7
+Z,2,5,5,3,2,7,8,2,9,12,6,8,1,9,5,8
+S,1,0,2,1,0,8,8,4,7,5,6,7,0,8,7,8
+V,3,8,5,6,1,6,8,4,3,8,14,8,3,10,0,8
+Y,4,7,6,5,3,10,10,1,6,2,10,8,1,11,1,9
+C,1,3,2,1,1,4,8,4,6,10,9,12,1,8,2,8
+L,2,5,3,4,2,7,4,1,8,8,2,10,0,7,2,8
+Q,4,5,5,6,4,7,10,4,4,7,10,11,3,9,6,7
+X,7,10,7,5,3,5,8,3,8,10,11,11,4,11,4,5
+S,7,10,7,5,3,7,8,4,3,13,8,7,3,9,4,8
+R,10,15,8,8,5,7,7,5,5,9,5,9,7,5,7,11
+F,6,9,8,7,6,5,11,6,5,12,8,5,3,9,2,5
+M,1,0,2,0,0,7,6,9,0,7,8,8,5,6,0,8
+K,6,10,9,7,5,4,8,2,7,10,10,11,3,8,4,6
+J,5,10,4,7,3,7,11,3,3,13,5,4,2,7,6,8
+T,3,5,4,4,2,5,12,2,7,11,9,4,1,11,2,5
+C,6,8,7,7,7,6,7,5,5,6,6,11,7,10,9,8
+W,9,11,8,8,7,5,10,4,3,9,8,7,9,11,3,5
+H,4,8,5,6,5,7,6,13,2,7,7,8,3,8,0,8
+E,4,9,6,6,6,6,8,6,8,6,5,10,3,8,6,9
+W,1,0,2,1,1,7,8,3,0,7,8,8,5,10,0,8
+H,2,1,3,2,2,9,7,6,5,7,6,6,3,8,3,7
+U,6,11,8,9,5,5,8,6,7,7,9,10,3,9,1,8
+Z,1,0,2,0,0,7,7,2,10,8,6,8,0,8,6,8
+O,2,1,3,2,2,8,7,7,5,7,6,8,2,8,3,8
+F,2,3,4,1,1,6,10,3,5,13,7,5,1,9,1,7
+T,5,6,7,5,5,5,7,3,8,7,6,10,3,7,7,5
+I,1,6,2,4,1,7,7,1,8,7,6,8,0,8,3,8
+A,2,2,4,4,2,8,2,2,2,8,2,8,2,6,3,7
+J,1,1,2,1,1,10,6,2,6,12,4,8,0,7,1,7
+U,4,8,5,6,3,6,9,6,6,5,9,10,3,9,1,8
+R,5,10,6,7,6,6,9,8,4,7,5,8,2,7,5,11
+T,4,10,6,7,2,7,15,1,6,7,11,8,0,8,0,8
+J,6,7,8,9,8,8,8,4,6,6,6,7,5,9,11,11
+U,3,4,4,3,2,5,8,5,7,10,9,8,3,9,2,6
+C,5,8,6,6,4,6,8,6,9,6,6,13,1,8,4,9
+T,9,13,8,7,3,8,7,4,9,13,5,7,2,9,6,6
+V,2,6,4,4,1,8,8,4,2,6,13,8,3,10,0,8
+Q,6,7,8,6,6,8,3,4,5,7,3,9,4,5,5,7
+Q,4,5,5,6,5,8,8,6,1,7,6,11,3,9,6,8
+Q,1,0,2,1,0,8,7,6,3,6,6,9,2,8,3,8
+K,5,10,5,7,2,4,8,9,2,7,6,11,4,8,2,11
+C,7,12,5,6,4,7,6,4,3,9,8,11,4,9,8,11
+A,3,11,5,8,3,13,4,5,3,12,1,8,2,6,4,9
+Z,3,8,4,6,3,8,7,3,12,9,6,8,0,8,7,7
+U,6,10,6,7,5,4,8,5,7,9,7,9,7,9,5,3
+D,5,11,6,8,5,11,6,3,7,11,2,6,3,8,3,9
+M,5,8,7,6,6,8,7,2,4,9,7,8,7,6,2,8
+Y,5,10,8,8,4,7,10,2,7,6,12,9,2,11,2,8
+Z,2,7,3,5,3,6,8,5,10,7,6,10,1,9,8,7
+H,4,7,6,10,6,8,12,5,2,9,7,5,4,11,8,4
+B,4,7,5,5,6,8,7,6,6,6,6,6,2,8,6,9
+D,2,3,3,1,2,8,6,4,6,10,4,6,2,8,2,8
+R,5,11,6,8,3,5,10,9,4,7,4,8,3,7,6,11
+R,2,1,2,1,1,6,9,8,4,7,5,8,2,7,4,11
+U,7,9,7,6,5,4,8,5,8,9,6,9,7,9,6,2
+N,5,8,7,6,4,9,7,6,6,6,6,4,6,9,2,5
+K,6,9,8,7,6,9,5,1,6,10,4,9,5,6,5,10
+N,6,11,8,8,6,8,7,9,5,6,4,4,4,8,4,9
+S,4,10,5,7,3,8,8,6,9,4,6,7,0,8,9,7
+E,3,6,3,4,3,4,7,5,8,7,6,13,0,8,6,9
+F,5,11,5,8,4,1,13,4,4,12,10,7,0,8,2,6
+T,6,9,8,6,6,6,7,7,7,8,10,8,5,7,7,9
+K,8,14,8,8,5,10,6,3,6,11,2,6,5,8,4,9
+K,4,9,4,6,2,3,7,7,2,7,5,11,3,8,3,10
+E,3,7,3,5,2,3,7,6,10,7,6,14,0,8,7,7
+I,2,7,4,5,3,10,5,1,5,7,5,5,2,8,4,7
+L,6,11,9,8,11,7,8,3,6,5,7,10,6,12,10,6
+A,5,10,9,7,6,7,5,2,4,5,1,6,5,7,5,5
+W,11,15,12,9,8,7,8,3,4,7,9,7,12,9,3,5
+A,4,9,6,6,3,11,2,3,3,10,2,9,2,6,3,8
+Q,2,4,3,5,3,8,9,6,1,5,8,10,2,9,5,10
+D,3,1,4,3,2,7,7,7,7,7,6,5,2,8,3,7
+C,4,4,5,7,2,5,7,7,10,7,6,14,1,8,4,9
+G,4,5,5,4,3,6,7,6,6,9,7,10,2,9,4,9
+V,3,8,5,6,3,6,11,2,4,8,11,8,2,10,1,9
+T,5,6,6,5,5,6,8,4,8,8,7,9,3,8,6,6
+A,3,8,5,5,2,7,4,3,1,7,1,8,3,7,2,8
+O,5,8,7,6,8,7,9,5,2,7,6,7,10,9,6,10
+O,3,5,4,3,2,8,7,7,5,9,5,8,2,8,3,8
+D,4,9,5,7,3,5,7,10,8,7,6,5,3,8,4,8
+M,7,8,9,6,6,10,5,3,5,9,3,6,10,6,2,9
+U,3,7,5,5,4,9,6,7,5,7,6,8,3,8,4,5
+R,1,0,2,0,1,6,9,7,3,7,5,8,2,7,4,10
+W,4,7,6,5,3,5,8,5,1,7,8,8,8,9,0,8
+H,3,5,5,7,4,11,6,3,1,8,6,9,3,8,8,12
+F,4,5,5,7,2,1,14,5,4,12,10,5,0,8,2,5
+G,3,5,4,4,2,6,7,5,5,9,7,10,2,8,4,10
+T,3,11,5,8,1,7,14,0,6,7,11,8,0,8,0,8
+L,2,5,3,4,1,5,5,1,9,7,2,11,0,7,2,8
+Y,4,9,7,7,3,6,10,2,8,7,12,8,1,11,2,8
+Q,4,4,6,6,3,7,7,7,6,5,7,7,3,8,5,9
+L,4,9,6,6,3,7,3,1,8,8,2,10,2,5,4,7
+R,1,3,3,1,1,9,7,3,4,10,3,7,2,7,2,10
+T,5,9,6,7,7,6,8,3,6,7,6,10,5,8,5,7
+B,4,9,4,7,4,6,7,9,7,7,6,7,2,8,9,10
+R,3,2,4,3,3,6,7,4,6,6,5,7,3,7,5,8
+E,3,4,3,6,2,3,8,6,11,7,5,15,0,8,7,7
+D,6,10,8,8,7,7,7,7,5,7,6,6,4,8,3,7
+B,3,4,4,6,3,6,6,9,7,6,7,7,2,8,9,10
+N,7,11,10,8,12,8,7,4,5,7,6,6,8,10,10,5
+V,2,3,3,2,1,7,12,2,2,7,11,8,2,11,1,8
+G,7,12,6,6,4,6,7,7,5,9,7,6,4,8,5,6
+S,3,2,3,3,2,8,8,7,5,8,5,7,2,8,8,8
+D,5,9,7,6,4,10,6,3,8,11,4,6,4,6,4,8
+F,3,3,3,4,1,1,13,4,4,12,11,7,0,8,2,6
+S,4,8,5,6,4,7,7,5,7,5,6,9,0,9,8,8
+M,4,8,7,6,8,11,5,3,2,9,4,8,8,6,3,7
+I,2,7,3,5,2,7,7,0,7,13,6,8,0,8,1,8
+L,3,9,5,7,3,8,4,0,9,9,3,11,0,7,3,9
+C,9,12,6,7,3,8,8,6,8,12,6,8,2,9,5,9
+V,3,2,5,3,2,9,12,3,3,5,11,9,2,10,1,9
+A,3,9,5,6,3,6,3,2,3,5,2,8,2,6,3,6
+Q,4,6,6,8,6,8,7,7,2,5,6,10,3,8,5,10
+D,4,8,6,6,4,9,6,5,7,10,3,5,3,8,3,8
+U,4,5,4,7,2,7,5,15,5,7,13,8,3,9,0,8
+J,0,0,1,0,0,12,4,6,3,12,5,11,0,7,0,8
+H,6,8,9,6,7,5,8,3,7,10,9,9,4,9,4,6
+O,2,3,2,2,1,7,7,7,4,7,6,8,2,8,2,7
+Y,3,6,5,8,1,7,10,1,3,7,12,8,1,11,0,8
+K,8,10,11,8,6,8,6,2,7,10,4,9,4,8,4,9
+G,8,12,7,6,5,7,6,3,3,8,5,7,4,9,9,7
+C,3,6,4,4,1,5,8,6,10,6,7,11,1,7,4,8
+N,4,4,4,3,2,7,9,5,4,7,6,7,5,9,2,7
+X,6,8,8,6,6,7,7,2,5,6,6,7,3,9,10,9
+P,5,11,6,8,3,4,11,10,3,9,6,4,2,10,4,8
+T,3,7,5,5,3,8,12,3,7,7,11,8,2,11,1,8
+W,4,2,6,4,4,7,11,2,2,6,9,8,7,11,1,8
+N,5,4,5,6,2,7,7,15,2,4,6,8,6,8,0,8
+B,3,7,3,5,3,6,7,9,6,7,6,7,2,8,8,10
+A,7,10,9,8,9,8,6,7,4,7,6,9,6,8,8,3
+B,5,6,7,6,8,8,7,5,4,7,6,8,7,9,8,4
+B,2,7,3,5,2,6,7,8,6,7,6,7,2,8,8,10
+J,2,5,4,4,1,9,6,2,6,14,5,9,1,6,1,7
+B,3,5,5,3,3,10,6,3,6,10,4,7,2,8,4,11
+X,7,10,10,8,5,10,7,2,8,11,2,7,3,8,4,9
+F,2,3,2,2,1,5,10,3,4,10,9,5,1,9,2,7
+H,1,0,1,1,0,7,7,11,1,7,6,8,3,8,0,8
+C,5,10,6,8,2,6,7,7,10,6,6,15,1,8,4,9
+Y,5,11,6,8,3,7,10,1,3,7,12,8,1,11,0,8
+E,3,4,5,3,3,6,7,2,8,11,7,9,2,8,4,8
+K,7,13,8,7,5,7,8,2,6,10,4,8,5,5,4,7
+H,6,9,8,7,5,5,7,3,7,10,9,10,3,8,4,6
+B,3,1,3,2,2,7,7,5,5,6,6,6,2,8,6,9
+A,3,5,5,4,4,7,8,3,4,7,8,8,5,10,3,6
+R,2,3,4,2,2,9,7,2,5,10,3,6,2,7,3,9
+P,4,6,6,9,9,8,6,5,1,7,6,7,8,8,6,7
+Z,6,9,8,6,6,9,10,6,5,6,5,6,3,9,9,4
+W,8,9,8,5,3,3,11,2,3,11,11,8,7,11,0,7
+T,3,5,5,7,1,6,15,1,6,8,11,7,0,8,0,8
+Z,4,7,5,5,3,7,7,6,11,6,6,8,2,8,8,8
+K,4,10,6,7,8,9,7,3,4,5,6,8,7,9,7,6
+P,3,7,5,5,3,6,12,4,5,13,6,2,0,9,3,8
+X,5,8,8,6,4,6,8,1,8,10,8,8,3,8,4,7
+C,6,10,6,7,4,6,8,7,8,13,8,10,2,11,3,7
+U,3,1,4,2,2,6,9,5,6,7,9,9,3,9,1,8
+N,4,10,5,8,5,8,7,12,1,6,6,8,5,8,0,9
+X,2,4,4,3,2,10,7,1,8,10,3,7,2,7,3,8
+S,4,10,4,8,4,9,8,5,9,5,5,5,1,6,9,7
+F,2,1,2,2,1,6,10,4,5,10,9,5,1,10,3,6
+U,5,9,6,7,4,8,5,13,5,8,12,8,3,9,0,8
+P,2,3,2,1,1,6,10,5,4,9,7,4,1,9,3,7
+X,4,5,5,7,2,7,7,4,4,7,6,8,3,8,4,8
+Q,3,5,4,6,3,7,8,5,2,7,9,11,3,9,5,7
+K,3,3,5,2,2,8,6,2,6,10,5,10,3,8,3,9
+B,10,14,9,8,8,8,7,4,5,9,6,7,8,7,10,8
+D,3,7,5,5,7,9,9,4,4,7,6,5,4,9,8,6
+G,7,8,9,7,9,7,8,5,3,7,7,8,10,10,10,7
+B,3,6,4,4,4,6,8,7,4,7,5,6,2,8,6,6
+T,3,3,4,2,1,5,11,3,7,11,9,4,1,10,2,5
+Z,2,4,4,3,2,8,6,2,9,12,5,9,1,8,5,9
+C,4,8,5,6,2,6,9,7,10,5,7,12,1,6,4,8
+V,2,7,4,5,1,9,8,4,2,5,13,8,3,10,0,8
+G,5,10,7,8,6,6,6,7,6,6,5,12,3,10,5,7
+M,5,8,7,6,8,8,7,6,5,6,7,8,8,6,2,7
+B,4,11,5,8,4,6,7,9,7,7,6,7,2,8,9,10
+N,5,9,7,7,6,6,7,7,6,7,5,8,6,7,3,7
+W,10,10,9,8,9,5,11,4,3,8,7,7,10,12,4,5
+N,2,3,2,1,1,7,8,6,4,7,6,7,4,8,1,7
+A,4,4,6,6,2,6,7,3,0,6,0,8,2,7,1,7
+R,4,9,6,7,6,8,7,7,3,8,5,7,4,7,7,10
+U,4,4,4,3,2,4,8,5,7,11,10,9,3,9,2,6
+R,2,3,3,2,2,7,7,5,4,9,5,7,2,7,3,10
+E,2,2,3,4,3,7,7,6,7,7,6,9,2,8,6,10
+M,5,10,7,5,4,12,2,2,2,10,3,9,5,4,1,9
+I,1,7,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+A,5,7,7,5,7,7,8,8,4,7,5,8,4,8,9,4
+W,4,7,6,5,3,6,8,5,1,7,8,8,8,9,0,8
+J,4,10,5,8,3,8,7,2,6,14,5,9,1,7,1,7
+L,2,3,3,2,1,7,4,2,7,8,2,10,0,7,2,8
+O,4,5,5,7,3,7,8,9,8,7,8,8,3,8,4,8
+I,1,5,1,4,1,7,7,1,7,7,6,8,0,8,2,8
+K,1,0,1,0,0,5,7,7,1,7,6,11,2,8,2,11
+M,5,8,8,6,5,5,7,3,4,10,9,10,8,6,3,8
+N,10,13,9,7,4,7,10,5,5,3,5,11,6,11,3,6
+A,3,8,5,6,3,10,4,2,2,8,2,10,2,6,3,8
+G,4,6,5,4,5,9,8,6,2,5,7,9,6,10,3,8
+N,5,5,7,4,6,7,9,4,4,6,4,8,7,7,5,7
+F,4,8,4,6,3,1,13,4,3,12,10,7,0,8,2,6
+V,1,0,2,1,0,8,9,3,2,7,12,8,2,11,0,8
+G,4,5,5,4,3,6,7,5,6,9,7,10,2,8,4,9
+C,5,7,7,6,6,5,6,4,5,7,6,11,4,10,7,10
+Y,10,9,8,12,5,7,9,3,2,7,11,5,4,10,7,6
+Y,6,11,8,8,8,9,3,7,5,8,8,7,3,10,5,3
+W,4,4,5,3,3,4,11,3,2,9,9,7,6,11,1,7
+J,2,11,3,8,1,14,2,7,5,14,1,10,0,7,0,8
+F,4,6,6,4,3,8,10,2,6,14,5,4,2,10,2,8
+Q,5,7,6,6,5,7,4,4,5,6,3,7,3,7,5,7
+Y,4,9,6,7,3,5,11,2,3,8,12,8,1,11,0,8
+K,5,8,7,6,8,7,6,3,4,6,6,8,8,6,7,7
+H,4,6,5,4,4,7,9,6,5,7,4,6,3,7,7,10
+N,7,10,9,8,10,6,8,3,4,8,7,8,8,10,7,4
+B,3,9,3,7,5,7,8,8,6,7,5,7,2,7,8,9
+O,4,10,5,7,4,7,6,8,5,7,5,8,3,8,3,8
+V,3,6,5,4,2,8,9,4,2,6,13,8,3,10,0,8
+U,8,9,8,7,5,3,8,5,8,10,9,9,3,9,2,6
+F,5,7,6,5,6,7,8,6,4,8,6,8,3,10,8,10
+N,8,10,11,8,5,9,7,3,6,10,4,6,7,9,2,7
+X,2,1,4,3,2,7,8,3,9,6,6,7,2,8,6,7
+E,4,10,6,7,7,7,7,3,6,7,7,10,4,9,8,8
+L,2,3,2,5,1,0,1,5,6,0,0,7,0,8,0,8
+A,5,10,7,7,8,8,5,8,4,8,6,8,3,9,8,3
+H,2,1,3,3,2,8,7,6,6,7,6,8,3,8,3,7
+O,1,1,2,1,1,8,7,7,4,7,6,8,2,8,3,8
+F,4,11,6,8,4,9,9,2,6,13,4,4,2,10,3,9
+N,5,9,6,7,3,7,7,15,2,4,6,8,6,8,0,8
+S,2,1,2,2,2,8,8,6,4,7,5,7,2,8,8,8
+I,4,11,3,6,2,10,7,6,3,13,4,8,2,8,4,9
+L,3,7,5,5,2,4,2,7,7,1,2,4,1,6,0,6
+J,1,7,2,5,1,13,3,8,4,14,3,11,0,6,0,8
+A,4,7,6,6,5,8,8,2,4,7,7,8,5,7,4,6
+Q,6,9,8,8,8,5,4,4,6,5,4,7,4,5,6,6
+N,4,7,6,5,6,9,6,4,5,7,5,6,7,11,6,5
+W,8,8,8,6,5,2,10,2,3,11,11,9,7,10,1,7
+N,3,7,5,5,5,5,8,4,3,9,10,10,5,8,4,5
+J,5,10,6,8,5,8,6,4,5,8,6,7,3,7,4,6
+S,1,0,1,0,0,7,7,3,5,5,6,8,0,8,7,8
+D,4,8,6,6,8,9,8,5,4,7,6,6,4,8,8,6
+Y,2,4,3,3,1,6,10,1,6,8,11,8,1,11,2,7
+O,2,1,3,1,1,8,7,7,5,7,6,9,2,8,3,8
+Q,5,6,6,8,6,9,8,7,2,4,7,11,3,9,5,10
+P,4,7,6,11,11,8,6,5,1,7,6,7,7,9,7,10
+E,3,8,4,6,5,6,6,3,5,7,7,10,4,10,8,9
+E,4,7,6,5,4,9,6,2,8,11,5,8,4,7,6,10
+G,3,9,4,7,2,7,7,8,7,5,6,9,2,7,6,11
+D,4,11,6,8,5,9,7,5,7,10,5,5,3,8,3,8
+R,6,9,9,7,7,9,7,4,6,10,3,7,3,6,4,11
+V,4,8,4,6,2,3,11,3,3,10,11,8,2,10,1,7
+X,5,7,6,5,5,7,8,3,6,6,6,8,4,8,10,8
+M,6,9,8,8,10,6,8,4,3,7,5,8,10,8,5,6
+W,8,12,9,7,5,1,8,2,3,9,11,9,9,9,1,6
+E,5,10,7,8,5,10,6,2,8,11,4,8,2,8,5,11
+T,3,8,5,6,3,6,12,2,8,8,12,8,1,11,1,7
+O,3,5,4,3,2,7,7,8,5,7,6,8,2,8,3,8
+V,3,4,5,3,2,4,12,3,3,9,11,7,2,11,1,8
+E,3,7,5,5,3,9,6,2,7,11,5,8,2,9,5,11
+D,7,11,9,8,8,8,8,5,6,10,5,5,6,8,6,11
+J,2,9,3,6,2,14,3,4,4,13,1,8,0,7,0,8
+J,1,0,1,1,0,12,3,6,3,12,5,11,0,7,0,8
+S,3,9,4,7,4,8,7,7,5,7,5,6,2,8,8,8
+T,2,5,4,6,1,5,14,1,6,9,11,7,0,8,0,8
+F,5,9,7,6,7,9,7,1,5,9,5,5,5,10,4,6
+E,4,9,5,7,3,3,6,6,12,7,7,15,0,8,7,7
+U,6,10,6,8,3,4,9,5,8,11,11,8,3,9,2,6
+M,15,15,15,8,7,9,11,6,4,4,6,10,11,13,2,6
+N,2,1,2,2,1,7,9,5,4,7,6,7,4,8,1,6
+J,4,5,6,6,5,7,7,4,6,6,6,7,3,9,8,9
+H,2,3,4,1,2,5,8,3,5,10,9,9,3,8,2,6
+Z,4,7,5,5,5,8,8,2,7,7,6,8,0,9,9,9
+X,7,11,8,6,4,8,8,2,8,11,6,7,4,12,4,8
+B,5,9,8,7,7,10,6,3,6,10,4,6,2,8,5,10
+S,4,10,5,8,5,7,6,8,6,7,8,10,2,10,8,7
+A,4,9,5,6,5,7,6,7,4,7,6,9,2,8,8,4
+P,1,0,1,0,0,5,10,6,1,9,6,5,1,9,2,8
+O,5,11,6,8,9,9,9,6,2,6,7,9,12,12,6,7
+Q,2,1,2,1,1,8,7,6,4,6,6,8,2,8,3,8
+P,1,1,2,1,1,5,11,8,2,9,6,4,1,9,3,8
+R,4,7,6,5,4,10,7,3,6,11,2,6,3,7,4,10
+J,4,8,3,11,3,8,8,3,3,12,5,5,3,8,6,10
+W,3,6,5,4,5,8,9,5,4,5,9,9,5,8,2,7
+T,6,8,7,6,4,7,10,1,8,11,9,5,2,10,4,4
+E,4,5,5,5,5,7,9,5,5,7,8,11,5,9,7,9
+Z,4,9,4,7,4,7,8,3,12,8,6,8,0,8,7,7
+G,4,5,6,4,5,7,8,5,3,7,7,8,7,11,7,8
+I,4,5,5,6,4,8,9,5,5,7,6,8,3,8,9,8
+W,10,13,10,8,5,5,9,2,2,7,10,7,9,12,1,6
+D,7,13,7,7,4,10,4,3,6,10,2,7,5,7,4,12
+M,3,3,5,2,3,7,6,3,4,9,7,9,7,5,1,8
+B,3,6,4,4,4,8,7,4,5,9,5,6,2,8,5,9
+V,3,4,4,3,1,4,12,2,3,9,11,7,2,10,1,7
+H,4,7,5,5,5,7,7,5,6,7,6,10,6,8,3,8
+L,2,4,4,3,2,6,4,1,8,8,2,11,0,7,2,8
+X,2,3,3,1,1,9,6,2,7,10,4,8,2,8,3,9
+R,6,8,8,6,7,9,8,3,7,9,3,8,4,5,4,11
+M,2,3,3,2,2,7,6,6,3,7,7,8,5,5,1,8
+I,1,5,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+T,5,8,6,7,6,6,9,5,7,8,8,8,4,13,9,6
+N,5,8,7,6,5,7,6,10,5,6,4,5,4,7,4,9
+A,4,5,6,4,4,8,8,3,4,6,7,7,5,8,4,5
+Q,6,9,5,4,3,11,3,4,5,11,3,10,3,8,5,13
+D,4,11,5,8,3,6,7,11,9,7,6,6,3,8,4,8
+A,3,10,5,8,4,12,3,2,2,9,2,8,2,6,2,8
+B,1,0,1,1,1,7,7,7,4,6,6,7,1,8,6,9
+U,5,5,6,3,3,4,8,5,8,10,9,9,3,9,2,6
+M,5,8,5,6,3,7,7,12,2,7,9,8,8,6,0,8
+R,2,4,4,3,2,9,7,3,5,10,4,7,2,7,3,10
+S,3,1,3,3,2,8,7,7,5,7,6,8,2,10,9,8
+P,5,7,7,5,4,6,11,7,2,11,5,3,1,10,3,8
+G,7,13,6,7,4,10,6,5,6,11,4,8,5,7,5,9
+F,5,8,7,6,7,7,8,6,4,8,6,8,4,10,8,11
+F,7,11,6,6,3,7,8,2,8,11,6,6,2,10,5,6
+K,9,13,8,7,4,7,7,3,7,9,9,9,6,11,3,7
+W,5,7,5,5,5,6,10,4,2,9,7,7,6,11,2,6
+P,4,9,5,6,2,4,12,9,2,10,6,4,1,10,4,8
+I,1,11,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+V,6,8,6,6,2,3,12,5,4,12,12,7,3,10,1,8
+E,6,10,9,8,6,6,8,4,9,11,9,9,2,9,5,6
+W,4,4,6,3,3,7,11,3,2,6,9,8,8,11,1,8
+F,1,0,1,0,0,3,11,4,2,11,8,6,0,8,2,8
+U,9,15,7,8,4,8,6,4,6,3,9,5,6,6,2,6
+X,3,3,5,2,2,9,7,2,8,11,4,7,2,7,3,8
+Q,4,9,5,11,5,9,8,8,2,4,7,11,4,9,6,9
+I,1,8,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+P,4,5,4,7,2,4,12,9,2,10,6,4,1,10,4,8
+R,9,11,7,6,4,8,7,5,5,10,4,9,6,5,6,11
+I,1,8,0,6,1,7,7,5,3,7,6,8,0,8,0,8
+P,2,1,3,2,2,6,9,5,5,9,7,4,1,9,4,7
+G,4,6,5,4,6,8,6,4,2,6,6,9,6,8,6,11
+Z,8,14,8,8,5,11,4,5,8,12,3,10,4,4,8,12
+K,2,1,3,2,2,5,7,4,7,7,6,11,3,8,4,10
+C,6,12,4,6,2,7,7,7,6,11,6,8,2,9,5,9
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+S,5,8,6,6,3,9,6,4,8,11,4,8,2,8,5,11
+W,7,11,10,8,15,10,5,5,2,7,6,7,12,10,3,4
+K,2,6,4,4,4,7,7,3,5,6,5,8,3,8,3,9
+R,3,5,5,4,3,9,7,4,5,9,4,7,3,7,4,10
+K,4,7,5,5,5,5,6,4,6,6,6,11,3,8,5,10
+C,6,10,7,8,3,4,9,6,8,12,10,11,2,9,3,6
+B,2,5,4,4,3,8,7,3,5,10,5,6,2,8,4,9
+U,9,11,10,8,7,5,7,5,9,9,6,9,8,9,6,1
+P,4,6,6,9,9,7,8,6,0,8,6,7,6,10,6,11
+Y,3,4,4,3,1,4,11,2,7,11,10,5,1,11,2,5
+H,3,4,5,6,4,7,4,5,2,6,4,6,4,6,7,7
+Z,3,10,4,8,4,7,8,3,12,9,6,8,0,8,7,7
+K,5,8,5,6,2,4,7,8,1,7,6,12,4,8,3,11
+U,5,10,8,7,10,9,7,4,4,6,7,8,8,8,6,7
+Z,3,7,5,5,4,8,8,3,7,7,6,8,1,8,10,9
+J,0,0,1,0,0,11,4,5,3,12,4,10,0,7,0,8
+J,4,7,5,5,4,7,6,4,5,8,6,7,5,6,4,6
+K,5,11,6,8,3,4,8,9,2,7,4,11,4,8,2,11
+Y,3,4,4,2,2,4,11,2,7,11,10,5,1,10,2,4
+L,4,7,5,5,3,7,4,2,8,7,2,8,1,6,3,8
+N,1,0,2,1,0,7,7,11,0,5,6,8,4,8,0,8
+M,3,2,5,3,3,7,6,6,5,6,7,7,8,6,2,7
+H,5,7,7,9,6,10,10,3,2,7,7,8,3,10,8,9
+L,4,9,4,7,2,0,2,4,6,1,0,7,0,8,0,8
+W,4,8,6,6,3,8,8,4,1,7,8,8,8,9,0,8
+W,5,10,8,8,13,9,5,5,2,7,6,8,11,10,4,8
+G,4,9,3,4,2,8,6,5,2,9,6,8,3,10,7,7
+R,4,7,5,5,5,8,6,7,3,7,5,7,4,6,6,9
+W,3,1,5,3,3,7,11,2,2,7,9,8,7,11,0,8
+Q,5,10,7,8,6,8,4,8,5,6,4,8,3,8,3,8
+D,5,11,7,8,6,6,7,8,7,5,4,5,3,9,4,9
+H,5,11,6,8,6,6,7,7,6,7,6,11,3,8,3,9
+F,3,8,4,6,4,6,9,3,6,10,9,5,2,10,3,6
+V,4,11,6,8,2,7,8,4,3,7,14,8,3,9,0,8
+O,6,11,4,6,3,6,7,6,3,9,7,9,5,10,5,8
+C,2,4,3,3,1,6,8,7,7,9,8,13,1,10,4,10
+F,4,10,6,8,6,4,10,3,5,10,10,6,2,10,3,6
+C,1,3,2,1,1,6,8,6,6,8,7,13,1,9,3,10
+V,4,7,4,5,2,3,12,4,3,11,11,7,3,10,1,7
+U,7,9,7,6,4,5,7,7,9,8,7,9,5,11,5,2
+V,3,8,5,6,3,5,11,3,4,8,12,9,2,10,1,8
+Y,3,7,5,5,2,10,11,2,2,5,12,8,1,11,0,8
+X,1,0,1,0,0,7,7,3,4,7,6,8,2,8,4,8
+F,6,9,8,6,5,10,8,2,6,13,4,5,3,9,3,9
+N,2,4,3,3,2,7,8,5,4,7,6,6,5,9,2,6
+R,4,9,5,6,4,10,6,4,5,10,3,7,3,7,4,11
+B,3,6,5,4,4,8,7,6,6,7,6,5,2,8,7,10
+H,4,8,6,6,6,7,8,6,6,7,6,10,6,8,3,8
+V,3,4,5,3,1,7,12,3,3,7,11,8,2,10,1,8
+I,3,7,5,5,4,12,5,1,6,8,4,5,2,8,4,8
+J,5,8,7,10,7,8,8,4,5,7,6,8,4,6,9,8
+Q,7,11,6,6,3,8,5,4,9,10,4,9,3,6,9,9
+W,1,0,2,1,1,7,8,3,0,7,8,8,5,10,0,8
+E,4,10,4,7,4,3,8,5,9,7,6,13,0,8,7,9
+Z,3,7,5,5,4,9,11,6,4,6,5,7,2,8,6,4
+B,2,4,4,3,3,8,7,3,5,10,6,7,2,8,4,9
+G,6,10,6,7,5,5,7,6,5,9,8,11,2,9,4,9
+W,6,6,8,8,4,11,8,5,2,6,9,8,8,9,0,8
+D,6,9,8,8,9,7,7,4,7,7,5,8,4,7,7,5
+P,8,10,7,5,3,7,10,5,3,12,4,4,4,9,4,8
+Z,7,11,9,8,6,8,6,2,9,12,5,10,2,8,7,9
+R,4,8,5,6,4,10,6,3,6,10,3,7,3,7,4,11
+T,7,11,6,6,2,5,10,3,8,13,7,5,2,9,4,3
+M,5,7,7,5,4,11,6,3,5,9,2,6,8,6,2,9
+E,8,11,5,6,3,7,9,5,8,10,6,10,1,8,7,9
+F,4,6,5,8,2,0,15,5,4,13,10,5,0,8,2,5
+Y,8,7,6,11,5,9,8,5,5,4,11,6,4,11,5,7
+Y,2,2,3,3,1,7,10,1,7,7,11,8,1,11,2,8
+H,3,7,4,5,2,7,6,14,2,7,8,8,3,8,0,8
+W,4,7,6,5,5,7,11,1,2,7,8,8,6,12,1,8
+L,4,6,5,4,4,6,6,8,6,6,6,9,2,8,4,10
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+G,6,9,6,7,5,6,6,6,5,9,6,12,4,8,6,7
+H,5,9,7,7,6,8,8,7,6,7,5,6,3,8,3,6
+G,3,6,4,4,4,7,7,5,2,7,6,10,4,9,7,7
+P,4,9,5,6,2,3,12,8,1,10,6,3,1,10,4,8
+I,6,11,4,6,2,9,6,6,5,13,5,9,2,8,4,9
+G,5,9,5,7,4,6,6,7,6,8,7,12,3,7,5,8
+P,5,9,5,5,3,5,12,4,2,12,6,3,2,10,5,6
+Z,3,9,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+R,4,8,6,6,5,7,8,6,6,7,5,7,3,7,5,8
+N,2,1,3,2,2,7,8,5,5,7,7,6,5,9,1,5
+J,0,0,1,1,0,12,4,5,3,12,4,10,0,7,0,8
+U,6,7,6,5,4,3,9,5,7,10,9,9,3,9,2,6
+U,4,7,5,5,3,4,8,5,7,10,9,9,3,9,2,6
+J,3,6,5,4,1,8,5,4,7,15,7,13,0,7,1,7
+H,3,4,5,3,3,7,7,3,6,10,6,8,3,8,3,8
+S,4,6,5,4,3,9,7,4,8,11,5,8,2,8,5,9
+N,4,8,6,6,5,6,7,7,6,7,5,7,3,7,3,8
+X,4,8,5,6,4,8,7,3,8,5,6,7,3,9,7,7
+Y,4,7,4,5,2,3,10,3,6,11,12,7,2,11,2,6
+C,5,9,5,7,4,4,8,5,7,11,9,14,2,9,3,7
+A,3,6,4,4,2,10,2,2,3,8,2,8,2,6,2,8
+B,5,8,7,6,6,10,6,3,6,10,4,7,4,7,5,10
+M,3,6,4,4,4,8,5,10,0,6,8,8,6,5,0,8
+V,5,11,8,8,2,6,8,5,3,8,14,8,3,9,0,8
+D,4,5,5,4,4,7,7,7,7,7,6,5,2,8,3,7
+K,4,6,6,4,6,7,6,5,4,6,6,8,6,6,7,12
+B,2,3,3,2,2,8,7,3,5,10,5,7,2,8,4,10
+Y,3,6,4,4,2,8,10,2,6,5,12,8,2,11,2,8
+A,1,3,3,2,1,11,2,3,2,10,2,9,1,6,2,8
+S,3,4,4,7,2,8,7,6,8,4,6,8,0,8,9,7
+E,4,4,4,6,3,3,8,6,12,7,5,14,0,8,7,7
+C,3,4,4,3,1,5,9,5,7,12,9,10,1,10,3,7
+D,5,5,5,8,3,5,7,11,9,7,6,5,3,8,4,8
+E,3,4,5,3,2,6,8,2,9,11,7,8,2,8,4,6
+M,2,1,2,1,1,7,7,10,0,7,8,8,6,6,0,8
+S,3,2,4,3,3,8,7,7,5,7,6,8,3,9,9,8
+Z,4,8,5,6,4,9,9,6,4,7,5,8,3,8,10,7
+O,6,11,6,8,6,7,6,7,4,10,5,10,5,7,4,7
+S,6,10,8,9,9,9,8,4,5,7,7,8,5,10,9,11
+X,5,8,7,6,3,9,6,2,8,11,2,7,3,9,4,9
+W,3,4,4,3,3,7,11,2,2,7,9,8,6,11,1,8
+V,3,8,5,6,1,5,8,4,3,8,14,8,3,9,0,8
+Y,3,7,5,5,3,7,10,1,5,5,11,9,2,11,1,8
+C,4,7,6,5,4,7,8,8,6,5,7,13,4,7,4,8
+E,3,5,5,3,2,8,7,2,8,11,5,8,2,8,5,10
+W,4,6,6,4,8,9,7,5,2,7,6,8,9,11,2,7
+A,2,5,4,3,2,7,3,1,2,6,2,8,3,5,2,8
+M,7,9,9,6,8,8,7,2,5,9,6,8,8,6,2,8
+O,2,6,3,4,2,7,8,7,5,7,7,7,3,8,3,7
+Q,3,6,4,7,4,9,7,7,3,5,6,10,3,8,6,10
+L,2,5,3,4,2,4,4,5,7,2,2,6,1,6,1,6
+F,3,5,3,3,2,6,10,4,5,10,9,5,2,10,3,6
+P,4,9,4,6,2,3,13,8,2,11,7,3,1,10,4,8
+G,4,7,6,5,4,6,6,5,5,6,6,7,3,7,4,7
+Z,7,10,9,8,6,6,9,3,9,12,8,6,3,10,7,6
+F,1,0,1,1,0,3,12,4,2,11,9,6,0,8,2,7
+O,3,4,4,3,2,7,7,7,4,9,6,8,2,8,3,8
+U,9,12,8,6,3,5,4,5,5,4,8,7,6,7,2,7
+J,3,8,5,6,3,12,4,4,5,14,2,9,0,7,0,8
+X,4,6,6,6,5,6,7,2,5,7,7,9,3,9,8,8
+V,8,11,7,8,5,2,11,2,3,10,11,8,2,10,1,8
+U,5,5,6,4,3,4,8,5,8,10,9,9,3,9,2,5
+J,1,7,2,5,1,11,3,9,3,12,6,13,1,6,0,8
+T,3,6,5,8,1,5,14,1,6,9,11,7,0,8,0,8
+S,4,11,5,8,4,7,8,8,8,8,4,6,2,6,9,8
+R,4,5,6,4,4,8,8,4,5,9,5,7,3,6,4,10
+W,2,3,4,2,2,9,11,3,2,5,9,7,6,10,0,8
+D,5,11,7,8,6,11,6,2,7,11,3,7,4,7,4,9
+Q,2,1,2,2,1,9,6,7,4,6,6,9,3,8,3,8
+N,4,5,6,4,5,8,8,5,4,8,6,7,6,9,6,3
+L,1,3,2,2,1,7,4,1,7,7,2,10,0,7,2,8
+M,5,5,6,4,4,8,6,6,5,6,7,7,10,6,4,6
+L,3,8,3,6,1,0,1,5,6,0,0,7,0,8,0,8
+C,2,5,3,3,1,5,9,5,7,12,9,11,1,10,2,7
+B,4,10,5,7,5,8,7,6,7,6,6,6,2,8,7,10
+Y,2,7,4,4,1,6,10,2,2,7,12,8,1,11,0,8
+Z,2,6,3,4,3,8,7,5,9,7,7,7,1,8,7,8
+J,2,7,2,5,1,13,2,7,5,14,2,11,0,7,0,8
+A,3,4,5,6,2,5,4,3,2,5,1,7,3,7,2,7
+Q,2,3,3,4,2,8,7,5,2,8,7,9,2,9,3,9
+B,3,4,4,6,3,6,9,9,8,7,5,7,2,8,9,10
+Q,2,2,3,3,2,7,9,4,1,7,8,10,2,9,4,8
+G,3,9,5,6,2,7,6,8,7,6,6,8,2,7,6,11
+A,4,5,6,8,2,7,4,3,2,7,1,8,3,6,3,8
+J,2,3,3,4,1,14,2,6,5,13,2,10,0,8,0,8
+S,2,5,4,3,2,8,7,3,7,11,5,7,1,9,4,8
+T,5,6,5,4,2,6,10,2,9,11,9,4,1,10,3,4
+O,5,11,7,8,6,7,7,8,5,6,7,11,6,7,5,7
+A,2,4,4,3,2,11,2,2,2,9,2,9,2,6,2,8
+R,4,8,5,6,4,8,9,4,6,8,4,9,3,6,5,11
+G,6,9,7,7,8,8,6,4,2,6,6,10,7,7,7,13
+R,2,3,4,2,2,8,7,4,5,9,4,7,2,7,4,10
+B,2,5,4,4,3,7,7,3,5,10,6,6,2,8,5,8
+K,4,8,6,6,4,9,5,2,7,10,3,9,4,7,5,11
+J,4,7,6,5,2,5,9,3,6,15,7,9,1,6,1,7
+Y,3,7,5,5,2,8,10,2,6,4,11,9,2,12,2,7
+I,3,9,4,6,3,6,8,0,7,13,7,8,0,8,1,7
+W,9,12,8,6,4,1,8,4,2,11,12,9,7,10,0,7
+O,5,5,7,4,4,8,5,4,5,8,4,8,3,8,4,8
+I,7,8,9,9,8,7,8,4,5,7,7,7,4,7,10,10
+K,3,4,5,3,3,4,9,2,7,10,10,10,3,8,3,6
+D,2,5,4,4,3,9,6,4,6,10,4,6,2,8,3,8
+X,3,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+D,5,7,7,6,6,6,7,5,7,7,6,9,4,5,6,5
+K,3,9,4,6,2,4,8,8,2,7,4,11,4,8,2,10
+G,6,8,8,7,9,7,9,6,2,7,7,8,7,11,7,7
+Q,5,7,6,9,6,10,11,6,3,3,8,12,3,10,7,10
+P,4,8,6,6,5,6,8,6,5,9,7,4,2,10,4,7
+A,8,15,6,8,4,8,3,3,2,7,4,11,5,5,4,7
+Q,3,5,3,6,3,8,8,5,2,8,8,10,3,8,5,8
+C,2,2,3,4,2,6,8,7,8,8,8,13,1,9,4,10
+I,1,1,1,3,1,7,7,1,6,7,6,8,0,8,2,8
+U,5,9,5,7,2,7,4,15,6,7,13,8,3,9,0,8
+O,4,9,5,6,4,8,7,8,5,9,5,8,3,8,3,8
+D,2,1,3,1,2,7,7,6,7,7,6,5,2,8,3,7
+N,7,11,6,6,3,9,11,5,4,4,6,10,6,10,2,6
+Y,2,3,4,5,1,8,10,2,3,6,12,8,1,11,0,8
+Z,3,8,4,6,2,7,7,4,13,9,6,8,0,8,8,8
+L,2,5,4,3,2,7,4,1,8,8,2,10,0,7,2,8
+V,4,9,7,6,3,6,12,3,4,8,12,8,3,10,1,8
+A,2,6,3,4,2,9,4,2,0,8,2,8,2,6,1,8
+N,6,10,9,8,4,8,8,3,5,10,4,6,6,9,1,6
+G,4,7,5,5,3,6,7,7,7,10,7,11,2,9,4,9
+A,2,1,4,1,1,8,4,2,0,7,2,8,2,6,2,8
+D,6,9,8,7,5,9,7,5,8,11,5,5,3,8,4,9
+U,5,9,7,8,6,7,7,4,4,6,5,8,8,7,2,8
+M,4,3,5,5,3,7,7,12,1,7,9,8,8,6,0,8
+J,2,6,3,4,1,13,2,8,4,13,4,13,1,6,0,8
+D,5,10,8,8,6,10,6,3,7,11,4,7,4,7,3,9
+X,2,4,4,2,2,7,7,1,8,10,6,8,2,8,3,7
+U,3,7,5,5,3,8,8,6,7,5,9,8,3,9,1,8
+X,5,11,6,6,4,6,9,2,6,10,10,8,4,14,4,6
+M,4,6,4,4,2,8,7,12,1,6,9,8,8,6,0,8
+L,3,6,4,4,2,6,4,3,7,6,2,8,1,6,2,7
+F,6,9,8,7,5,9,8,1,8,14,5,6,5,8,5,9
+G,4,11,5,8,3,7,6,9,8,6,6,11,2,8,5,11
+U,5,10,7,7,5,7,9,4,6,5,8,10,6,10,1,7
+C,8,15,6,8,5,5,10,4,5,9,7,8,3,9,9,9
+Q,3,6,5,6,4,8,8,6,4,5,8,9,3,8,5,9
+I,1,4,2,3,1,7,8,0,7,13,6,8,0,8,1,7
+F,2,8,3,5,1,1,11,4,6,11,11,9,0,8,2,6
+K,6,9,6,5,4,5,8,3,5,10,9,11,5,9,3,6
+D,4,8,6,6,4,7,9,7,7,11,6,4,4,8,5,9
+R,3,2,4,3,3,7,8,4,6,6,5,7,3,5,5,8
+O,7,10,5,5,3,5,7,6,4,10,7,9,5,10,5,7
+A,3,9,5,7,3,12,3,3,3,10,1,9,2,6,2,8
+U,5,10,7,8,6,8,7,7,6,7,7,9,6,8,4,7
+V,2,2,3,3,1,5,12,3,3,9,11,9,2,10,1,8
+B,1,1,2,1,1,7,7,7,5,6,6,7,1,8,7,9
+O,1,0,2,1,0,8,7,7,4,7,6,8,2,8,3,8
+P,4,8,6,12,11,8,8,5,0,8,7,7,6,10,5,8
+Y,8,8,7,11,5,9,9,3,3,5,11,5,4,10,7,8
+C,4,9,4,5,3,6,8,4,3,9,9,10,3,9,8,9
+P,2,5,4,4,2,7,10,4,4,12,5,3,1,10,2,8
+T,5,10,7,7,8,6,8,4,6,7,6,9,5,8,5,6
+T,6,8,6,6,3,4,12,3,8,12,10,4,1,10,2,5
+M,7,9,9,6,8,6,7,2,4,9,8,9,8,6,2,8
+D,2,4,3,2,2,7,7,6,6,7,7,5,2,8,2,7
+C,3,7,4,5,1,6,8,7,10,5,7,13,1,7,4,9
+S,6,11,8,8,10,9,8,5,4,9,5,7,5,10,13,8
+N,6,11,8,8,5,7,8,2,5,10,6,7,5,8,1,7
+X,5,7,8,5,4,11,5,2,8,10,1,7,2,7,3,10
+U,4,4,5,3,2,4,8,5,7,11,10,9,3,9,2,6
+L,4,7,6,6,5,7,7,4,5,7,6,7,3,9,8,11
+A,1,0,2,0,0,8,4,2,0,7,2,8,2,7,1,8
+J,4,8,3,11,3,6,9,3,3,13,5,6,3,8,6,9
+J,5,10,6,8,4,9,4,6,5,15,5,12,1,6,1,6
+I,3,11,4,8,2,7,7,0,8,13,6,8,0,8,1,8
+Q,7,8,9,12,11,9,9,7,0,6,7,10,9,14,6,7
+N,8,15,10,8,5,6,8,2,4,13,8,9,6,8,0,7
+B,3,6,5,4,3,9,7,4,6,10,5,7,2,8,5,10
+M,2,3,4,2,2,7,6,3,4,9,7,8,6,5,1,8
+M,1,0,2,0,1,7,6,9,0,7,8,8,5,6,0,8
+L,5,11,6,8,6,6,6,6,5,6,5,8,5,7,4,10
+W,9,12,9,7,6,8,8,4,4,6,9,6,11,8,3,6
+Y,3,2,5,4,2,6,10,1,8,8,11,8,1,11,2,8
+C,1,3,2,2,1,6,8,7,7,8,7,13,1,9,4,10
+P,4,8,6,11,10,8,9,4,0,8,7,6,8,10,6,8
+X,3,6,5,4,3,7,7,4,9,6,6,6,3,8,6,7
+Y,4,10,6,7,4,4,8,2,7,10,13,10,2,11,2,6
+G,2,4,3,2,2,6,7,5,6,9,7,10,1,8,4,9
+W,4,4,6,3,3,9,11,3,2,5,9,7,7,11,1,8
+U,5,10,8,8,4,5,9,7,8,8,10,10,3,9,1,8
+V,8,11,8,8,4,4,12,2,4,8,11,7,6,10,1,7
+S,1,0,2,1,1,8,7,4,7,5,6,7,0,8,7,8
+H,4,5,8,4,4,5,8,3,6,10,8,8,3,8,3,6
+H,4,10,4,7,2,7,7,15,1,7,6,8,3,8,0,8
+Q,7,9,7,11,8,7,9,5,2,7,9,11,4,8,8,9
+K,10,14,9,8,4,8,7,3,7,9,5,7,6,9,4,7
+S,2,6,3,4,2,8,7,7,6,8,7,9,2,9,9,8
+M,3,1,4,2,3,8,6,6,4,6,7,8,7,5,2,8
+R,9,10,7,6,4,7,8,5,5,9,4,9,7,5,6,11
+S,5,8,6,6,3,7,7,4,8,11,5,8,2,8,5,8
+Z,4,7,5,5,3,7,7,2,9,11,6,7,2,8,6,7
+T,3,8,4,6,4,6,11,3,6,8,11,8,2,12,1,7
+L,3,5,4,8,1,0,1,5,6,0,0,7,0,8,0,8
+C,2,4,3,3,1,4,9,5,6,11,9,11,1,9,2,8
+Y,3,5,5,4,2,6,10,1,8,8,12,8,1,11,2,7
+N,3,2,4,4,3,7,8,5,5,7,7,6,5,9,2,5
+T,7,9,6,5,2,7,8,3,8,13,6,7,2,8,5,5
+Y,6,8,6,6,4,3,9,2,6,10,11,7,2,11,2,5
+J,5,9,6,7,4,9,5,5,5,8,6,6,2,7,4,6
+U,5,10,6,8,5,6,9,5,7,6,9,9,3,9,1,8
+I,1,11,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+S,4,8,5,6,6,8,5,4,4,8,6,10,4,8,8,10
+K,6,9,7,4,4,10,6,4,5,11,2,7,5,7,3,9
+F,2,2,3,3,2,5,10,4,5,11,9,5,1,10,3,6
+F,3,8,3,5,1,1,11,5,6,11,10,9,0,8,3,6
+F,4,5,6,5,5,7,9,4,4,8,7,6,4,9,8,8
+X,6,9,8,7,7,7,6,3,5,6,6,10,4,6,11,9
+F,3,6,4,4,4,7,8,4,6,8,8,6,5,9,3,7
+Y,2,7,4,5,2,10,10,3,1,6,12,8,2,11,0,8
+G,2,4,3,3,2,6,7,6,6,6,6,11,2,9,4,9
+L,3,6,4,6,4,8,6,5,4,7,7,8,3,8,7,10
+Q,6,7,9,6,6,8,4,4,5,7,3,8,3,6,5,7
+J,5,7,4,10,3,8,8,3,3,12,4,5,2,8,7,9
+L,6,11,7,8,7,6,6,9,5,6,6,8,3,7,5,12
+A,6,9,9,8,8,8,7,3,5,7,7,7,5,8,4,5
+G,4,4,5,6,2,7,6,7,8,6,6,9,2,8,6,11
+N,5,8,7,6,4,10,8,2,5,10,2,5,5,9,1,7
+K,6,7,8,5,4,4,8,3,6,10,10,11,4,7,3,6
+U,9,15,8,8,6,7,6,5,5,6,7,8,5,6,3,7
+Z,4,9,5,7,2,7,7,4,14,9,6,8,0,8,8,8
+W,3,4,4,3,2,3,11,2,2,10,10,8,5,10,1,8
+Y,3,9,5,6,2,7,11,0,4,7,11,8,0,10,0,8
+F,3,6,4,4,3,5,10,3,6,10,9,5,2,10,3,6
+V,7,10,7,8,4,2,11,3,4,11,12,8,2,10,1,8
+L,3,8,4,6,4,5,5,3,8,3,2,7,1,6,2,5
+X,5,11,8,8,6,8,7,3,9,5,6,8,3,8,7,8
+D,4,11,6,8,6,9,7,4,5,10,4,5,3,8,3,8
+S,4,9,5,7,4,7,8,8,7,8,5,6,2,8,9,8
+Y,3,8,4,6,2,5,10,1,3,8,12,8,1,11,0,8
+S,3,7,4,5,3,7,8,7,7,8,5,6,2,8,9,8
+N,5,9,7,6,5,8,8,6,6,6,6,4,8,10,5,6
+W,2,0,3,1,1,7,8,4,0,7,8,8,7,9,0,8
+F,5,8,7,6,3,7,10,3,6,14,6,4,2,10,3,7
+U,5,11,5,8,5,8,6,13,4,7,12,8,3,9,0,8
+C,5,11,5,8,4,4,7,5,6,11,9,14,2,10,4,7
+Z,5,10,6,8,6,8,7,5,10,7,6,7,1,8,7,8
+T,3,9,5,6,3,8,14,1,5,7,10,8,0,8,0,8
+Q,4,10,6,9,3,8,6,9,6,6,6,8,3,8,5,9
+P,8,12,7,6,3,7,10,6,5,14,5,4,4,10,4,8
+L,3,6,4,4,2,5,3,3,9,5,2,8,1,6,2,6
+W,5,9,7,6,5,11,11,3,2,5,9,7,9,12,2,7
+R,3,6,5,5,5,7,8,3,3,7,5,8,6,8,5,7
+T,4,8,6,6,4,9,11,2,7,6,11,8,1,11,1,8
+S,2,3,3,2,1,8,8,2,6,10,6,7,1,8,5,8
+O,4,8,4,6,4,8,7,7,3,9,6,9,3,8,2,8
+T,4,9,6,7,4,6,11,1,9,8,11,8,0,10,1,7
+B,2,6,3,4,2,6,8,9,6,7,5,7,2,8,8,9
+D,4,9,6,7,4,9,7,4,7,11,5,6,3,7,3,8
+F,2,3,4,1,1,5,12,4,4,13,7,4,1,9,1,7
+U,4,5,5,4,3,5,8,6,8,10,8,9,3,9,3,6
+O,5,11,6,8,3,8,7,9,8,7,6,8,3,8,4,8
+Y,5,10,7,7,4,7,10,2,7,6,12,9,2,11,2,8
+Z,3,4,4,6,3,11,5,3,4,9,3,7,1,7,6,9
+N,5,8,7,6,5,8,9,6,5,7,6,5,7,8,3,8
+T,3,5,4,6,1,5,14,1,6,9,11,7,0,8,0,8
+I,3,8,5,6,5,10,7,2,6,9,4,5,3,8,5,7
+A,4,9,6,8,6,7,8,2,4,7,7,8,8,6,4,7
+O,5,10,6,8,5,7,6,7,4,9,6,10,5,8,4,7
+X,2,4,4,3,2,7,8,1,8,10,6,8,2,8,3,7
+B,3,7,5,5,5,8,8,4,5,7,5,6,4,8,5,8
+I,1,8,2,6,2,7,7,0,7,7,6,8,0,8,2,8
+Z,4,7,4,5,4,7,8,5,9,7,7,9,1,9,7,8
+V,6,7,5,5,3,3,11,2,3,9,11,8,3,11,1,7
+E,2,1,2,2,2,7,7,5,6,7,6,8,2,8,5,10
+J,4,5,6,6,5,8,8,4,6,7,6,8,3,10,8,8
+Q,3,8,5,9,5,9,9,6,3,4,8,11,3,9,7,10
+G,4,5,6,4,5,8,9,5,3,7,7,10,6,10,6,9
+A,4,9,7,7,5,7,2,1,2,5,2,7,4,6,5,7
+R,5,11,5,8,6,5,10,8,3,7,4,8,2,7,6,11
+E,3,7,4,5,3,3,7,5,8,7,6,13,0,8,7,9
+G,5,8,6,7,7,7,9,5,2,7,7,8,6,11,7,8
+G,3,7,4,5,2,8,7,8,7,6,6,9,2,7,6,11
+T,5,10,6,8,4,6,12,2,9,8,12,8,1,11,1,7
+D,5,11,7,8,11,10,8,5,6,7,5,6,5,5,10,5
+H,2,6,2,4,2,7,8,12,1,7,5,8,3,8,0,8
+P,7,10,9,8,7,6,11,5,4,12,5,3,1,10,4,9
+G,5,10,6,8,4,6,6,8,7,8,5,13,2,9,5,9
+G,4,7,5,5,3,6,6,6,7,6,5,9,2,10,4,7
+W,4,8,6,6,4,5,8,5,1,8,10,8,6,11,0,8
+K,4,9,6,6,5,5,7,1,6,9,7,10,3,8,3,8
+M,5,2,6,4,4,8,6,6,4,7,7,8,8,6,2,7
+A,1,0,2,1,0,7,4,2,0,7,2,8,2,7,1,8
+G,2,3,3,1,2,7,7,6,6,6,6,9,2,9,4,9
+S,3,7,4,5,3,9,8,5,8,5,5,5,0,7,8,8
+T,6,10,5,6,2,5,11,2,7,12,7,5,2,9,4,4
+S,2,4,3,3,2,8,7,7,5,7,7,8,2,9,9,8
+R,4,10,4,8,5,5,10,7,4,7,4,9,2,7,5,11
+J,5,10,7,8,5,9,4,4,6,8,5,6,2,8,4,6
+T,5,7,6,5,6,7,8,5,5,6,8,9,6,9,6,5
+G,3,6,4,4,2,7,7,7,7,7,5,12,2,9,4,9
+I,4,9,5,6,3,8,6,1,6,7,6,7,0,9,4,7
+Q,6,7,8,11,8,10,14,5,1,3,8,12,5,15,5,10
+I,3,10,4,8,2,6,8,0,8,13,7,8,0,8,1,7
+U,4,7,6,6,5,7,6,4,4,6,6,8,7,8,1,8
+E,5,8,7,6,7,7,7,3,6,7,7,11,4,10,8,9
+S,3,7,4,5,2,7,7,5,8,5,6,8,0,8,9,8
+E,2,5,3,4,3,7,7,5,7,7,7,9,2,8,5,10
+C,3,4,4,3,2,6,8,7,8,8,8,13,1,9,4,10
+P,3,6,4,4,2,4,14,8,1,11,6,3,0,10,4,8
+C,6,12,5,6,4,6,8,4,4,10,8,9,4,9,9,9
+E,2,6,3,4,3,7,7,4,7,7,5,8,3,8,5,10
+P,4,7,5,5,3,9,8,3,5,12,4,4,2,9,3,9
+M,4,4,4,6,3,8,7,12,1,6,9,8,8,6,0,8
+I,7,13,5,7,3,9,7,6,4,13,4,9,3,8,5,10
+R,3,8,4,5,2,6,10,9,4,7,4,8,3,7,5,11
+H,3,1,4,2,3,7,7,6,6,7,6,8,3,8,3,8
+N,5,8,8,6,4,7,8,3,5,10,6,7,5,8,1,7
+W,4,5,6,7,4,8,8,4,2,7,8,8,9,9,0,8
+L,5,9,5,7,2,0,1,5,6,0,1,6,0,8,0,8
+J,4,7,6,5,3,7,5,5,4,14,9,14,1,6,1,7
+S,2,3,3,2,1,8,7,2,7,10,5,8,1,8,4,8
+M,7,11,9,8,9,9,7,2,4,9,6,7,8,6,2,8
+C,6,11,6,8,3,4,8,6,8,12,10,12,2,9,3,7
+L,1,3,2,2,1,7,4,2,7,7,2,9,0,7,2,8
+D,3,8,4,6,2,5,7,10,8,6,5,5,3,8,4,8
+P,10,15,9,8,6,7,10,4,6,13,5,3,4,9,7,5
+U,2,6,3,4,1,7,5,14,5,7,12,8,3,9,0,8
+T,4,5,6,4,5,7,9,4,8,7,7,8,3,10,7,7
+D,6,10,8,7,5,8,7,4,7,11,5,6,3,8,3,8
+F,3,6,5,4,3,7,9,3,5,12,6,5,2,9,2,7
+E,3,7,3,5,2,3,6,6,11,7,7,15,0,8,7,7
+B,2,3,3,1,2,8,7,2,5,10,5,6,2,8,4,9
+H,7,9,10,6,8,8,7,3,6,10,5,8,3,8,3,8
+M,4,8,4,6,3,7,7,12,1,7,9,8,8,6,0,8
+K,3,7,5,5,5,6,6,3,4,6,6,9,5,8,7,9
+D,4,8,4,6,2,5,6,10,8,5,4,5,3,8,4,8
+K,4,10,6,8,7,5,5,5,3,6,6,9,3,5,8,9
+L,4,9,5,7,4,3,3,5,7,1,0,7,0,6,0,6
+W,5,5,7,8,4,7,8,5,2,7,8,8,9,9,0,8
+B,3,9,5,7,5,8,7,4,7,6,6,5,6,8,5,9
+V,3,3,4,2,1,4,12,3,3,10,11,7,2,11,1,8
+D,3,4,5,3,3,7,7,5,6,10,5,6,3,7,4,9
+K,3,6,5,5,4,11,5,3,3,10,3,8,4,6,6,12
+Q,1,0,1,1,0,8,7,7,3,6,6,9,2,8,3,8
+Y,4,8,6,6,6,8,7,5,4,7,8,8,6,8,7,4
+L,8,15,8,9,5,7,4,3,4,12,7,11,4,7,7,8
+S,2,4,3,3,2,8,7,3,7,10,5,8,1,9,4,8
+V,1,3,2,2,1,7,12,3,3,8,11,8,2,11,1,8
+Z,3,5,6,4,3,7,7,2,10,12,6,8,1,8,5,7
+C,7,13,5,8,4,7,9,4,4,9,7,9,3,9,8,11
+A,5,11,8,8,5,8,2,2,3,6,1,7,3,7,4,7
+R,2,4,4,3,2,8,7,3,5,10,4,7,2,7,3,10
+B,4,5,4,8,4,6,7,9,7,7,6,7,2,8,9,10
+V,4,5,5,4,2,4,12,3,3,10,11,7,2,10,1,8
+Y,5,8,5,6,2,4,11,3,8,12,11,4,1,10,2,4
+M,5,5,5,7,4,8,7,12,2,7,9,8,8,6,0,8
+M,6,9,7,4,4,7,3,3,2,8,4,10,7,3,1,9
+Y,5,10,8,8,3,6,10,1,9,9,12,8,1,11,2,7
+U,2,4,3,2,1,7,8,6,6,7,9,8,3,9,1,8
+Z,4,8,6,6,4,8,6,2,9,11,4,10,2,7,7,9
+F,7,11,10,8,7,7,9,3,6,12,7,6,2,9,2,7
+A,4,9,5,7,4,7,5,3,0,7,1,8,2,7,1,8
+U,4,9,5,7,2,8,5,14,5,6,14,8,3,9,0,8
+F,5,11,5,8,2,1,13,5,4,12,10,6,0,8,2,5
+W,7,10,7,5,4,5,8,1,3,8,10,8,9,11,2,6
+S,4,7,5,5,3,9,7,5,9,11,3,7,2,6,5,11
+Y,5,9,8,6,4,6,9,1,7,7,12,9,1,11,2,8
+A,2,4,4,6,2,8,3,3,3,7,1,8,3,6,3,8
+K,6,10,8,8,6,6,8,5,7,6,5,10,4,8,5,9
+I,4,6,6,7,5,9,8,5,6,7,6,8,3,9,8,8
+T,6,11,8,9,6,6,7,8,7,8,9,7,3,9,6,10
+M,10,12,10,7,5,11,12,6,4,4,7,9,8,12,2,7
+U,8,12,7,6,4,5,6,5,4,7,7,10,7,8,4,10
+X,2,1,3,3,2,8,7,3,9,6,6,6,2,8,5,8
+P,8,9,6,4,3,8,8,5,4,11,4,6,5,9,4,8
+B,4,8,5,6,5,10,6,3,6,10,4,7,3,8,4,11
+E,4,6,6,4,3,6,8,2,9,11,8,9,2,8,4,7
+H,3,3,4,4,2,7,8,14,1,7,5,8,3,8,0,8
+V,1,1,2,1,0,7,9,4,2,7,13,8,2,10,0,8
+I,0,6,0,4,0,7,7,5,3,7,6,8,0,8,0,8
+D,5,10,7,7,5,11,6,3,8,12,3,7,6,8,4,9
+W,5,7,5,5,4,6,10,5,2,9,6,6,6,12,2,5
+X,5,9,5,5,2,11,6,3,7,9,3,7,3,9,4,10
+Q,4,4,5,5,3,9,10,7,6,5,8,9,3,8,5,9
+E,6,11,8,8,9,6,6,3,6,8,7,12,5,9,9,8
+Y,3,4,5,6,1,8,10,2,2,6,13,8,2,11,0,8
+T,1,0,1,0,0,7,13,1,4,7,10,8,0,8,0,8
+M,5,10,7,5,4,12,3,5,2,11,1,10,7,2,1,8
+L,5,10,7,8,5,5,4,1,8,7,2,11,0,7,3,7
+C,5,9,6,7,4,5,7,6,9,7,6,13,1,8,4,9
+L,1,0,1,0,0,2,2,5,4,1,3,5,0,8,0,8
+P,5,11,7,8,6,7,7,7,5,8,7,8,2,9,7,9
+B,5,9,8,7,6,11,6,2,7,11,3,7,4,6,6,12
+B,4,8,6,6,5,8,7,5,6,9,6,6,2,8,7,8
+F,5,6,6,7,7,7,9,5,6,8,5,7,5,8,10,5
+T,3,10,5,7,1,7,15,0,6,7,11,8,0,8,0,8
+Z,2,2,3,3,2,7,7,5,9,6,6,8,1,8,7,8
+K,4,8,5,6,4,6,7,4,7,6,5,8,7,8,5,9
+K,5,6,7,6,6,10,6,3,4,10,3,8,5,6,6,12
+M,4,7,6,5,8,11,7,3,4,8,4,7,5,5,2,6
+Z,6,7,4,11,4,8,7,4,3,11,6,7,3,9,10,6
+G,5,9,7,8,8,8,6,6,4,7,6,9,10,10,9,9
+E,3,9,4,7,2,3,8,6,10,7,6,15,0,8,7,7
+G,5,9,5,6,3,6,7,7,7,10,7,10,2,9,4,9
+C,5,9,7,8,8,5,6,4,5,7,6,11,5,11,8,11
+F,5,7,7,5,4,8,9,2,6,14,5,4,3,8,3,7
+W,8,9,11,8,12,7,8,5,6,7,6,8,10,7,9,6
+S,5,12,4,6,2,9,3,4,4,9,2,8,3,6,4,8
+W,5,8,7,6,5,8,8,4,1,7,9,8,7,11,0,8
+N,5,9,8,6,4,11,6,4,5,10,1,4,5,8,1,7
+E,5,9,5,6,3,3,8,6,11,7,6,14,0,8,8,7
+M,5,10,8,8,7,8,6,6,5,6,8,8,8,6,2,7
+M,5,6,8,4,4,7,6,3,5,9,7,8,7,5,2,8
+T,1,0,2,0,0,7,14,2,3,7,10,8,0,8,0,8
+A,3,7,5,5,3,10,3,2,2,8,2,10,3,5,2,8
+V,1,1,2,2,1,7,12,2,2,7,11,8,2,11,0,8
+L,3,6,4,4,2,5,3,6,9,2,2,4,1,6,1,5
+G,5,9,7,8,8,8,8,6,3,7,6,9,8,11,9,11
+I,3,9,4,7,3,7,7,0,6,13,6,8,0,8,1,8
+X,5,7,7,5,6,8,6,2,5,6,7,7,3,10,10,8
+I,3,11,4,8,2,7,7,0,8,14,6,8,0,8,1,8
+J,2,7,2,5,1,12,3,9,4,13,4,12,1,6,0,8
+K,4,3,4,5,1,4,7,8,1,7,6,11,3,8,3,11
+X,5,10,7,7,6,8,7,3,5,6,7,6,4,10,11,8
+S,3,4,5,3,2,8,6,3,7,10,4,8,1,8,4,10
+L,1,0,1,0,0,2,1,6,4,0,3,4,0,8,0,8
+Y,2,1,4,2,1,7,11,1,7,7,11,8,1,11,2,8
+X,5,11,8,8,5,11,7,1,8,10,2,6,4,9,4,11
+Q,3,6,4,8,4,8,8,5,2,8,8,10,3,9,5,8
+R,5,5,6,8,3,6,11,9,4,7,3,8,3,7,6,11
+E,4,4,4,6,3,3,8,6,11,7,5,14,0,8,7,7
+N,4,4,5,6,2,7,7,14,2,4,6,8,6,8,0,8
+B,3,6,5,4,5,9,7,4,3,6,7,7,5,10,7,7
+G,5,9,7,6,8,8,8,5,2,6,6,9,7,8,6,11
+K,4,4,6,3,3,6,7,2,7,10,7,10,3,8,3,7
+E,3,8,5,6,4,7,7,5,8,7,6,9,6,8,6,9
+O,5,7,7,6,5,7,5,5,5,9,5,9,3,6,5,6
+Z,5,9,6,7,4,6,8,3,10,12,7,8,1,9,6,7
+L,6,10,6,5,3,7,5,4,4,12,9,12,3,9,6,9
+G,3,7,5,5,5,9,7,5,2,7,6,10,5,9,4,10
+P,4,5,5,7,6,9,7,4,3,6,7,8,6,11,5,4
+Y,4,7,4,5,2,4,10,2,9,11,10,5,0,10,3,4
+S,5,10,8,8,9,6,7,3,2,8,6,6,3,8,11,2
+Y,5,10,6,8,6,8,7,6,5,5,9,8,3,9,10,7
+M,7,8,10,6,6,9,6,2,5,9,6,8,8,6,2,8
+J,2,5,3,3,1,10,6,2,6,12,4,8,1,6,1,7
+I,1,5,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+U,8,13,8,7,5,7,6,5,5,7,8,8,5,7,3,8
+H,4,6,6,4,3,7,7,3,6,10,6,8,3,8,3,7
+E,2,4,4,3,2,7,7,2,8,11,6,9,2,8,4,8
+N,4,9,5,7,3,7,7,15,2,4,6,8,6,8,0,8
+D,2,3,3,2,2,9,6,3,5,10,4,6,2,8,2,8
+I,4,7,5,5,3,8,6,2,7,7,6,7,0,9,4,7
+B,6,10,9,8,9,8,7,6,6,9,7,6,6,10,9,10
+J,5,9,3,12,3,10,7,2,3,11,3,5,3,8,6,9
+E,4,7,5,5,4,7,7,5,9,7,7,9,3,8,6,8
+J,5,9,7,7,4,8,7,3,6,15,5,8,0,6,1,7
+M,3,1,4,3,3,8,6,6,4,6,7,8,7,5,2,7
+O,2,3,3,1,1,8,7,7,5,7,6,8,2,8,3,8
+U,8,11,7,6,4,7,5,5,4,6,8,8,5,6,3,8
+W,7,7,7,5,4,2,10,3,3,11,11,8,7,10,2,6
+O,3,6,4,4,2,7,7,7,5,7,5,9,3,8,3,7
+S,2,8,3,6,3,7,7,5,7,5,6,7,0,8,8,8
+F,4,7,5,5,5,6,9,2,6,10,9,6,5,10,3,7
+N,6,10,5,6,3,7,9,4,5,4,5,10,5,10,2,7
+H,3,5,5,3,3,7,8,6,7,7,5,8,3,8,3,8
+T,5,10,5,5,2,6,9,2,7,12,7,5,2,10,3,5
+G,3,2,5,4,3,7,6,6,6,6,6,10,2,9,4,9
+Y,3,7,4,5,1,7,10,2,2,7,13,8,1,11,0,8
+Z,1,0,2,1,0,7,7,2,10,9,6,8,0,8,6,8
+L,2,4,3,3,1,7,4,1,7,9,3,10,0,6,3,8
+O,4,7,5,5,4,7,9,8,4,7,8,8,3,8,3,8
+Z,5,10,7,8,4,7,7,3,11,11,6,8,1,8,7,8
+E,6,9,8,6,6,8,7,1,8,11,5,8,3,8,5,10
+O,3,6,4,4,2,7,7,7,5,10,6,8,3,8,3,8
+H,3,6,3,4,3,8,8,12,1,7,5,8,3,8,0,8
+Q,5,8,6,9,7,8,7,6,3,8,8,10,3,9,5,8
+H,6,11,8,8,9,6,8,6,7,7,6,10,6,8,4,8
+S,4,8,5,6,4,7,7,5,8,5,6,10,1,10,9,9
+Y,4,6,5,8,6,10,12,5,4,6,7,7,5,10,8,5
+A,3,8,5,5,2,10,5,3,1,8,1,9,2,7,2,9
+G,2,0,2,1,1,8,6,6,6,6,5,9,1,7,5,10
+C,4,7,5,5,2,6,9,7,7,13,8,7,2,11,2,6
+N,3,5,5,3,2,5,9,3,4,10,8,8,5,8,0,7
+S,5,6,6,8,3,8,7,6,9,4,6,8,0,8,9,8
+O,6,10,7,8,5,8,7,8,6,10,5,9,4,9,5,6
+Z,3,5,4,8,3,12,4,3,5,10,2,7,2,7,5,12
+R,4,10,6,7,5,7,8,6,5,8,5,9,3,6,6,11
+D,4,9,5,7,6,7,8,6,6,8,7,5,3,8,3,7
+I,4,5,5,6,4,8,9,4,4,7,6,8,3,7,8,7
+Q,5,8,6,9,6,8,7,6,3,9,8,10,3,8,6,8
+O,6,8,8,6,5,7,7,8,4,7,6,8,3,8,3,7
+P,6,11,6,8,3,4,13,8,1,10,6,3,1,10,4,8
+D,2,2,3,3,2,8,7,6,7,6,6,4,2,8,3,6
+L,2,6,4,4,2,6,4,2,10,7,1,10,0,7,3,7
+N,6,9,8,8,9,7,8,4,4,7,5,7,7,9,6,7
+D,2,3,4,1,2,10,6,3,6,10,3,6,2,8,2,9
+G,3,7,4,5,3,7,6,7,7,7,4,11,1,8,5,11
+N,3,7,3,5,3,8,8,12,1,6,6,8,5,9,0,8
+I,1,1,0,2,0,7,7,1,7,7,6,8,0,8,2,8
+X,4,6,5,8,2,7,7,5,4,7,6,8,3,8,4,8
+B,5,5,5,8,4,6,8,9,7,7,5,7,2,8,9,10
+C,2,3,2,2,1,4,8,4,7,10,9,12,1,8,2,7
+I,0,0,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+P,4,8,6,6,4,4,12,6,4,11,8,3,0,10,4,7
+Y,2,2,4,3,2,7,11,1,7,7,11,8,1,11,2,8
+S,4,10,4,8,2,8,7,6,9,4,6,6,0,8,9,8
+G,3,6,4,4,2,6,7,6,6,10,7,10,2,10,4,9
+L,2,4,4,3,2,6,4,1,9,7,2,10,0,7,2,8
+B,2,6,3,4,2,7,7,9,6,7,6,7,2,8,8,9
+C,5,10,6,8,5,5,7,8,7,11,8,13,3,12,5,8
+X,2,7,3,4,1,7,7,4,4,7,6,8,3,8,4,8
+A,4,11,6,8,2,8,5,3,1,7,0,8,3,7,2,8
+W,7,8,7,6,7,4,10,2,3,9,8,8,7,12,2,6
+W,7,10,7,7,6,4,10,2,3,9,9,8,7,11,2,6
+M,5,11,8,8,11,10,7,3,4,8,4,7,12,6,7,4
+S,6,11,7,8,4,7,8,4,8,11,8,7,2,10,5,6
+D,2,3,3,2,2,7,7,6,6,7,6,6,5,8,2,7
+Y,8,11,7,6,4,8,6,4,6,9,6,5,3,10,6,5
+Q,2,2,3,4,2,8,9,5,2,5,8,10,2,9,5,9
+B,6,9,8,7,7,7,8,6,5,6,5,6,4,9,7,6
+F,6,11,8,8,6,6,10,1,6,13,7,6,2,10,2,7
+R,3,5,5,4,3,9,7,3,5,10,4,6,3,7,4,9
+J,4,9,4,7,2,8,9,2,4,13,4,5,1,8,6,8
+W,7,7,10,6,10,8,7,5,5,7,5,8,10,9,8,7
+N,5,7,7,5,6,6,8,3,4,8,7,9,6,9,5,5
+U,5,11,7,8,10,9,6,4,4,6,7,7,8,7,6,5
+N,4,6,7,4,3,9,9,2,5,11,3,5,6,9,2,7
+V,4,10,6,7,3,7,9,3,2,6,12,8,3,10,0,8
+D,4,7,5,5,4,8,8,4,5,10,6,4,3,8,3,7
+A,3,6,5,4,2,11,3,2,2,9,2,9,2,6,3,9
+H,2,1,3,2,2,7,7,6,6,7,6,9,3,9,3,8
+F,2,3,3,2,1,6,11,3,5,12,7,4,1,9,1,7
+A,3,9,5,6,4,12,2,2,2,10,2,9,2,6,3,8
+O,4,10,6,8,4,8,6,9,5,7,5,8,3,8,3,8
+I,2,7,3,5,2,7,9,0,6,13,6,7,0,8,1,7
+D,2,4,4,3,2,8,7,4,6,10,4,6,2,8,3,8
+Y,5,6,6,4,3,3,10,2,7,11,11,6,1,10,2,4
+H,6,9,6,4,3,5,9,4,6,9,7,9,5,7,3,7
+K,5,9,7,6,5,9,6,1,6,10,4,8,3,8,4,10
+K,7,11,10,8,6,8,6,2,7,10,4,9,5,6,5,8
+I,0,6,0,4,0,7,7,5,3,7,6,8,0,8,0,8
+L,3,6,4,4,3,9,4,1,6,9,2,9,1,6,2,9
+D,5,10,5,5,3,12,4,3,5,11,2,7,4,7,3,12
+Q,7,10,9,8,8,8,3,8,4,6,6,8,4,8,6,9
+N,2,0,2,1,1,7,7,12,1,5,6,8,5,8,0,8
+Q,6,9,6,11,6,7,7,8,5,9,8,8,4,9,7,9
+L,3,7,5,5,2,6,4,1,9,8,2,11,0,8,2,8
+O,3,1,4,2,2,7,8,7,5,7,7,8,2,8,3,8
+F,2,3,2,1,1,5,11,4,4,10,8,5,1,9,3,7
+Y,1,1,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+K,2,1,2,1,0,5,7,8,1,7,6,11,3,8,2,11
+I,1,9,2,6,3,8,7,0,7,7,6,7,0,8,2,7
+I,1,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+G,2,4,3,3,2,6,7,5,5,9,7,10,2,9,4,10
+H,3,3,5,1,2,6,7,3,6,10,9,9,3,8,3,6
+Q,2,5,3,7,4,8,6,7,3,7,5,11,2,9,4,10
+U,4,8,6,6,3,4,8,7,7,9,11,11,3,9,0,8
+D,2,6,4,4,3,7,7,5,6,7,6,5,3,8,3,7
+D,5,11,7,8,11,8,8,5,5,7,6,6,7,8,8,6
+M,3,6,5,4,5,7,7,6,4,7,5,8,5,9,6,8
+X,3,1,4,3,2,7,8,3,9,6,6,7,3,9,6,6
+M,5,9,7,6,7,7,7,2,4,9,8,9,7,6,2,8
+B,4,9,5,7,5,8,6,7,7,6,6,6,2,8,7,10
+R,3,8,4,5,2,5,11,8,3,7,3,8,3,7,6,11
+S,2,6,3,4,3,8,7,7,6,7,8,9,2,10,8,8
+A,4,10,7,7,2,8,7,3,0,7,0,8,3,7,2,8
+J,3,8,4,6,2,13,3,6,4,13,3,11,0,7,0,8
+D,4,9,4,7,3,6,7,11,9,6,5,6,3,8,4,8
+Y,3,10,5,7,3,7,10,1,7,6,12,8,1,11,2,8
+G,3,8,5,6,2,7,5,7,8,6,5,10,1,8,6,11
+K,5,7,7,5,4,3,9,3,6,10,11,11,3,8,3,6
+Z,3,8,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+P,3,7,5,5,2,6,11,4,4,13,5,2,0,10,3,9
+R,5,8,7,6,6,9,7,4,5,10,4,6,3,7,4,10
+F,4,5,5,6,5,7,9,4,4,7,6,7,4,9,8,8
+G,4,8,5,6,2,8,7,8,8,6,6,9,2,7,6,11
+Q,5,7,6,8,5,9,8,7,2,4,7,10,3,8,6,10
+E,4,7,6,5,5,8,5,6,3,7,6,9,4,8,8,10
+T,8,11,7,6,3,5,10,3,9,13,7,5,2,9,3,4
+M,5,11,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+B,9,15,7,9,5,7,7,5,5,10,6,8,6,6,9,10
+Q,2,2,3,3,2,8,8,6,2,5,6,9,2,9,5,10
+E,5,9,4,4,2,7,8,4,7,9,6,9,1,9,7,9
+Z,3,6,4,4,2,7,7,4,14,9,6,8,0,8,8,8
+W,5,10,7,8,8,7,9,6,4,8,8,7,10,9,4,10
+X,3,4,5,3,2,8,7,4,9,6,6,9,4,7,7,9
+O,9,15,7,8,4,8,6,5,6,8,3,8,6,9,5,8
+W,7,7,7,5,5,4,11,3,3,9,9,7,7,11,2,6
+Z,7,11,9,8,5,8,6,3,10,12,4,10,2,9,6,10
+Y,10,10,8,14,6,9,6,5,5,4,12,6,5,10,6,7
+M,6,10,9,7,7,10,6,2,5,9,3,6,9,8,2,9
+X,3,9,5,7,4,7,7,3,8,5,7,9,3,8,6,8
+N,3,7,5,5,4,7,9,6,4,7,6,7,6,8,3,8
+H,2,3,4,1,2,8,8,3,5,10,5,7,3,8,3,7
+N,5,9,5,7,3,7,7,15,2,4,6,8,6,8,0,8
+X,5,11,6,8,4,8,7,4,4,7,6,8,3,8,4,8
+A,5,11,7,8,7,8,5,7,4,8,6,8,6,8,7,4
+P,3,4,3,3,2,5,10,4,4,10,8,4,1,10,3,7
+F,2,1,2,3,2,5,10,4,5,10,9,6,1,10,3,7
+G,3,2,4,4,3,6,7,6,6,7,6,10,3,7,4,9
+P,1,1,2,1,1,5,10,8,3,9,6,5,1,9,3,8
+T,2,6,3,4,2,7,12,3,7,7,11,8,1,11,1,7
+Y,7,9,7,7,4,4,9,2,7,10,11,6,2,12,3,4
+R,3,3,3,4,2,5,10,8,4,7,4,8,2,7,5,11
+N,3,8,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+S,4,10,5,8,5,7,7,5,8,5,6,8,0,8,9,7
+P,4,8,6,6,3,6,11,3,6,14,7,3,0,9,2,8
+F,4,10,6,7,4,4,12,4,4,13,8,5,2,10,2,6
+S,4,5,5,7,3,8,8,6,10,5,6,7,0,8,9,7
+I,7,11,6,6,3,8,8,3,6,13,4,5,2,8,6,10
+V,4,4,5,3,2,4,12,3,3,10,11,7,2,10,1,8
+T,4,11,6,8,2,7,15,1,6,7,11,8,0,8,0,8
+Z,5,11,7,8,3,7,7,4,15,9,6,8,0,8,9,8
+R,4,10,4,7,5,5,10,7,3,7,4,9,2,6,5,11
+G,3,8,4,6,3,8,8,7,5,6,6,9,2,7,5,11
+F,4,7,4,5,2,1,12,4,4,12,11,7,0,8,1,6
+B,2,4,3,2,2,9,7,3,5,10,5,7,2,8,4,9
+F,5,10,5,8,4,1,12,4,4,12,10,7,0,8,2,6
+G,5,6,5,4,3,6,7,6,5,10,8,10,2,9,4,9
+P,2,3,4,2,2,7,9,3,4,12,5,4,1,10,2,8
+G,4,7,5,5,3,7,6,7,7,11,6,11,2,10,4,9
+Q,4,6,6,4,5,8,5,7,4,7,6,6,5,7,6,9
+O,4,7,5,5,3,7,8,7,6,9,8,8,3,8,3,8
+Z,3,7,4,5,3,6,7,5,9,7,7,9,1,9,7,8
+X,5,7,8,5,4,7,7,1,8,10,7,9,3,8,3,8
+S,2,3,4,2,1,7,8,3,7,10,7,7,1,8,5,6
+O,3,6,4,4,3,8,8,7,4,7,7,7,3,8,2,8
+T,2,4,3,3,2,7,12,3,6,7,11,9,2,11,1,8
+S,3,8,4,6,3,9,7,7,6,7,6,8,2,9,9,8
+O,2,4,3,3,2,8,7,6,3,9,5,8,2,8,2,8
+P,6,10,9,8,7,8,9,5,4,11,4,4,2,10,3,8
+B,5,11,7,8,9,8,8,6,6,7,6,6,2,8,6,9
+Q,4,5,4,6,4,8,8,5,3,8,9,9,3,10,5,7
+T,2,4,3,2,1,6,11,2,7,11,9,5,1,10,2,5
+Q,8,12,7,6,4,10,3,5,7,12,3,11,3,7,8,11
+Y,4,6,6,4,5,9,5,7,5,6,9,7,3,9,8,5
+Q,8,9,11,8,9,6,4,4,6,5,4,7,4,6,6,7
+L,3,5,3,3,2,4,3,5,6,2,2,5,1,6,0,6
+V,5,10,7,8,9,8,5,6,3,7,7,8,8,7,4,7
+X,5,5,6,8,2,7,7,5,4,7,6,8,3,8,4,8
+E,4,8,5,6,5,8,7,6,3,6,6,10,3,8,7,9
+W,5,10,7,8,7,6,11,2,2,7,8,9,7,12,1,8
+B,4,7,6,5,5,9,7,4,5,9,5,6,2,8,5,9
+P,4,8,6,6,4,5,13,7,2,12,6,2,1,10,3,8
+J,7,13,6,10,4,8,9,2,3,12,5,5,2,9,8,9
+U,5,8,5,6,3,3,8,5,7,9,9,9,3,9,2,5
+X,4,8,5,5,1,7,7,4,4,7,6,8,3,8,4,8
+B,6,11,9,8,9,8,8,4,6,10,5,6,5,6,7,10
+C,6,11,7,8,3,5,7,7,11,7,6,12,1,9,4,8
+R,5,10,7,8,7,6,8,5,6,6,5,8,3,6,5,8
+O,4,9,5,7,5,8,9,8,4,7,8,7,4,7,4,9
+V,5,6,5,4,2,4,12,5,4,11,11,6,3,10,1,8
+P,7,11,10,8,6,9,9,4,6,12,3,3,2,10,4,9
+R,1,0,2,1,1,6,9,7,3,7,5,8,2,7,4,11
+I,2,5,3,4,1,7,7,0,8,13,6,8,0,8,1,8
+P,2,3,4,2,2,7,10,5,3,10,4,3,1,10,3,8
+A,5,10,7,7,4,9,5,3,0,8,1,8,2,7,1,8
+B,7,10,9,7,7,9,6,4,7,9,5,6,2,8,7,10
+C,5,10,6,8,3,3,8,5,8,11,11,13,1,8,3,7
+W,6,5,8,8,4,5,8,5,2,7,8,8,9,9,0,8
+Q,9,13,8,7,5,8,6,4,10,11,4,10,3,7,9,9
+Z,4,6,6,4,3,6,9,2,8,11,8,6,1,8,6,5
+I,1,9,0,6,1,7,7,5,3,7,6,8,0,8,0,8
+G,1,3,2,1,1,7,7,5,5,10,7,10,2,9,3,10
+T,2,1,2,2,1,8,11,4,5,6,10,7,2,11,1,7
+I,2,5,3,3,1,7,8,1,7,14,6,7,0,8,1,7
+C,6,9,6,6,4,7,8,6,8,13,7,10,3,11,4,6
+I,6,11,8,8,5,10,5,2,6,6,7,4,0,10,4,7
+N,5,10,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+V,4,8,4,6,2,4,11,4,4,10,11,7,3,10,1,8
+K,5,5,6,7,2,4,8,8,2,7,4,11,3,8,2,11
+Q,5,9,5,5,3,9,6,4,6,10,5,7,3,8,9,9
+M,5,9,6,7,6,7,5,11,1,7,9,8,9,5,2,9
+P,4,8,4,5,2,4,15,8,1,12,6,2,0,9,4,8
+V,3,5,4,3,1,4,12,3,3,10,11,7,2,11,1,8
+F,4,7,4,5,2,1,12,4,4,12,10,7,0,8,2,6
+O,5,9,6,6,3,8,6,8,8,7,5,9,3,8,4,8
+Q,4,5,5,4,4,8,4,4,5,7,4,8,4,6,4,8
+K,3,6,5,4,3,3,9,2,6,10,11,11,3,8,2,6
+R,7,9,6,4,3,8,7,5,5,9,4,9,6,5,6,11
+F,2,4,3,3,1,6,10,2,5,13,7,5,1,9,1,7
+X,3,5,6,3,3,8,6,1,8,10,5,8,2,8,3,8
+P,4,11,5,8,4,5,10,8,4,9,7,3,2,10,4,7
+M,5,6,8,5,8,9,8,5,4,7,6,7,11,9,7,5
+E,1,1,1,1,1,4,7,5,8,7,6,13,0,8,6,9
+K,5,10,6,8,5,3,8,7,3,7,5,11,3,8,3,11
+W,4,7,6,5,3,7,8,4,1,7,8,8,8,9,0,8
+P,6,9,8,7,5,6,14,6,1,11,5,2,1,11,4,7
+W,5,8,7,6,6,7,11,2,2,7,8,8,7,12,1,8
+Q,4,5,4,6,4,8,5,6,5,9,6,9,3,8,5,8
+Z,6,10,8,8,5,8,6,3,9,12,4,9,3,6,8,9
+B,1,0,1,0,0,7,7,6,4,7,6,7,1,8,5,9
+Q,3,6,4,8,4,8,6,8,4,5,6,9,3,8,6,10
+D,6,14,6,8,4,11,4,2,6,9,3,7,5,7,4,12
+E,4,7,4,5,3,3,7,5,10,7,6,14,0,8,6,8
+J,4,9,6,7,4,8,6,6,6,8,6,8,3,7,4,6
+Q,5,7,7,10,10,8,6,5,1,6,6,9,8,9,6,12
+O,4,8,5,6,4,7,7,8,4,7,6,10,3,8,3,8
+A,4,8,6,6,4,11,3,2,2,9,2,9,4,4,3,8
+G,5,10,7,8,5,6,6,7,6,6,6,10,2,8,5,8
+U,4,3,4,5,1,7,5,12,5,7,15,8,3,9,0,8
+U,6,11,6,8,4,3,8,5,7,11,11,9,3,9,2,6
+X,4,5,7,3,3,6,8,1,9,11,8,9,3,8,3,7
+W,6,8,9,7,11,9,6,5,5,8,6,8,11,12,8,6
+C,5,6,6,5,5,6,7,4,5,7,6,11,5,10,8,11
+I,2,6,3,4,2,7,7,0,7,13,6,8,0,8,1,8
+O,4,9,5,7,5,8,6,7,4,9,4,8,3,8,2,8
+X,3,4,6,3,2,7,7,1,9,11,6,8,2,8,3,8
+V,4,10,6,8,3,8,9,4,2,6,13,8,3,10,0,8
+W,4,5,6,8,4,7,7,4,2,7,8,8,9,9,0,8
+A,3,5,6,3,2,8,2,2,2,6,1,8,2,6,2,7
+E,3,4,3,3,3,7,7,5,8,7,6,8,2,8,6,9
+P,2,4,4,2,2,8,10,4,3,11,4,3,1,10,3,8
+L,3,3,3,5,1,0,1,6,6,0,1,5,0,8,0,8
+O,2,2,3,4,2,7,7,8,4,7,6,8,2,8,3,8
+P,4,10,6,8,5,6,9,6,5,9,7,3,2,10,4,6
+B,5,8,7,6,6,9,7,3,5,10,5,6,2,8,5,9
+I,4,10,6,8,7,10,8,2,6,9,4,4,4,8,7,4
+E,4,10,5,7,5,6,7,6,9,6,4,10,3,8,6,9
+V,5,11,8,8,5,8,12,2,3,4,10,9,4,12,2,8
+K,5,7,7,6,5,9,5,2,4,8,4,9,5,8,7,11
+S,6,10,8,8,9,8,9,5,4,8,5,6,4,9,11,8
+D,6,11,6,8,4,5,7,10,10,7,6,6,3,8,4,8
+B,4,11,5,8,7,6,8,9,6,7,5,7,2,7,8,10
+N,9,13,8,7,4,6,10,4,5,4,5,10,6,10,2,7
+C,2,3,3,2,1,6,8,7,7,8,7,12,1,9,4,10
+W,5,11,8,8,8,7,11,2,2,6,8,8,7,12,1,8
+A,2,6,4,4,3,8,3,2,1,7,2,8,1,7,2,8
+A,3,9,5,6,3,10,3,2,2,8,2,10,3,5,3,7
+N,3,4,4,7,2,7,7,14,2,5,6,8,6,8,0,8
+Z,4,5,5,8,2,7,7,4,14,10,6,8,0,8,8,8
+H,4,6,5,4,5,7,7,5,6,7,6,7,6,8,3,8
+A,2,8,4,5,2,7,5,3,1,6,0,8,2,7,2,7
+G,3,4,4,3,2,6,7,5,4,9,7,9,2,8,4,9
+U,3,8,4,6,2,7,5,14,5,7,13,8,3,9,0,8
+W,4,7,6,5,5,10,11,2,2,5,9,8,6,12,1,8
+M,2,3,4,2,2,6,6,4,3,9,9,10,5,6,1,7
+V,3,6,5,4,1,8,8,4,2,7,14,8,3,9,0,8
+Q,5,10,5,6,3,9,6,4,7,11,4,8,3,8,8,11
+W,6,7,6,5,4,3,11,2,2,9,9,8,6,11,1,7
+N,4,9,6,7,4,6,9,6,5,7,7,8,6,9,2,6
+D,3,4,4,3,3,7,7,6,7,7,6,5,2,8,3,7
+A,3,5,6,4,2,9,2,2,2,8,1,8,2,6,2,7
+R,2,6,3,4,3,5,10,7,4,7,4,9,2,6,5,11
+L,3,9,4,7,3,7,4,2,8,7,1,8,1,6,2,7
+U,3,3,4,2,2,6,8,5,7,10,8,8,3,10,3,6
+N,5,11,8,8,6,7,9,6,5,6,6,7,6,9,1,7
+D,4,8,5,6,4,7,7,7,7,7,6,4,3,8,3,7
+H,2,3,4,2,2,7,8,3,5,10,7,8,3,8,2,7
+V,2,6,4,4,1,6,8,4,2,8,13,8,3,10,0,8
+H,8,10,8,5,5,8,6,3,5,10,6,7,7,11,5,8
+F,4,9,6,7,4,5,11,4,6,11,10,5,2,10,3,5
+N,5,10,6,7,5,7,9,6,4,6,6,6,6,9,2,7
+Q,3,3,4,4,3,8,7,6,3,8,6,9,2,9,3,7
+L,3,7,4,5,3,9,3,1,6,9,2,9,1,6,2,9
+O,6,10,7,8,5,8,6,8,6,9,4,8,3,8,3,8
+D,2,3,3,2,2,7,7,5,5,10,5,6,3,8,3,9
+D,5,10,7,7,4,9,7,6,8,11,5,5,3,8,4,8
+F,5,7,7,5,3,6,10,3,6,13,7,4,2,10,2,7
+W,9,10,9,8,9,6,10,3,3,8,7,6,11,11,4,5
+Q,1,0,2,1,1,8,7,6,4,6,6,9,2,8,3,8
+E,5,11,5,8,3,3,8,6,12,7,6,15,0,8,7,6
+S,4,8,5,6,4,6,8,3,6,10,7,8,2,8,5,6
+W,13,13,12,7,5,1,9,5,3,12,13,9,8,9,0,7
+U,3,3,4,1,1,5,8,5,6,10,9,9,3,10,2,6
+D,2,7,4,5,4,7,7,6,5,7,6,4,3,8,2,7
+P,3,8,4,6,3,5,10,5,5,10,8,4,1,10,4,7
+A,2,4,4,3,1,12,3,3,2,10,1,9,1,6,2,9
+C,3,5,4,3,2,5,8,5,7,12,9,11,1,10,2,7
+Y,2,2,4,3,2,8,10,1,7,5,11,8,1,11,2,8
+L,1,3,2,2,1,6,5,2,8,7,3,9,0,7,2,8
+I,3,8,4,6,2,7,7,0,8,14,6,8,0,8,1,7
+A,2,5,4,3,2,8,2,2,2,8,2,8,2,6,2,7
+F,5,7,7,5,3,9,8,2,7,14,4,4,2,9,3,9
+R,6,10,8,8,6,10,7,3,6,10,2,6,5,6,5,10
+G,3,5,4,4,2,6,6,6,5,9,7,11,2,9,4,10
+Y,2,1,3,1,0,7,10,3,1,7,13,8,1,11,0,8
+N,5,4,5,6,2,7,7,15,2,4,6,8,6,8,0,8
+R,3,6,5,4,4,6,8,5,5,6,4,8,3,6,4,8
+C,2,1,3,2,1,6,7,6,10,7,6,14,0,8,4,9
+Y,7,11,8,8,6,5,8,1,8,8,9,5,5,11,7,4
+I,2,7,3,5,2,7,9,0,6,13,6,7,0,8,1,7
+F,6,11,8,8,6,9,8,2,6,12,4,6,5,8,4,9
+N,5,9,7,7,4,5,9,3,4,10,8,8,5,8,1,7
+F,7,12,6,6,3,7,8,2,7,11,6,6,2,9,6,5
+Q,6,6,7,9,4,8,6,8,7,5,7,8,3,8,5,9
+V,3,4,4,3,2,5,12,3,3,9,11,7,2,11,1,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+I,4,11,5,8,4,7,7,0,7,13,6,8,0,8,1,8
+K,4,9,5,7,2,3,6,8,3,7,7,12,4,8,3,10
+Z,3,11,4,8,2,7,7,4,14,10,6,8,0,8,8,8
+M,3,3,4,2,2,7,6,6,4,6,7,8,6,5,2,8
+D,6,11,8,8,7,7,7,7,8,7,6,5,6,8,4,7
+Q,4,5,5,7,3,8,6,9,7,6,6,9,3,8,4,8
+V,5,11,7,8,4,4,11,3,4,10,12,9,2,10,1,8
+L,3,7,4,5,2,4,3,5,8,1,1,5,0,7,1,5
+Q,3,3,4,4,3,8,8,6,2,5,7,9,3,9,5,9
+K,5,9,8,7,5,2,8,2,7,11,12,12,3,8,3,5
+W,8,9,10,8,13,6,8,6,5,6,6,8,10,10,9,9
+T,5,7,5,5,3,6,11,3,7,11,9,5,2,11,2,4
+J,3,9,4,7,2,10,6,1,9,12,3,6,0,7,1,7
+L,3,9,3,7,1,0,1,5,6,0,0,7,0,8,0,8
+J,2,10,3,7,1,13,3,8,4,14,3,11,1,6,0,8
+O,3,6,5,4,5,8,7,5,1,7,6,8,8,8,4,9
+P,2,1,3,2,2,5,10,4,4,9,7,4,1,9,3,7
+R,5,9,8,7,5,10,7,3,7,10,3,6,3,6,4,11
+F,4,9,4,6,2,1,13,5,4,12,11,7,0,8,2,6
+B,4,9,6,6,6,6,8,7,4,7,5,6,4,8,5,6
+J,4,11,5,8,3,10,6,1,7,13,3,7,0,7,0,8
+F,3,5,3,3,2,5,12,5,6,11,9,3,1,10,3,5
+D,4,9,6,6,9,9,9,4,5,7,6,6,5,8,9,5
+M,4,2,5,4,4,9,6,6,4,6,7,6,8,6,2,6
+E,3,7,4,5,4,8,7,4,7,7,6,8,6,9,5,10
+H,4,7,6,5,4,9,7,7,6,7,6,5,3,8,3,6
+Y,5,7,8,10,11,8,9,4,2,6,8,9,4,11,8,8
+S,3,7,4,5,4,8,7,7,5,7,6,8,2,8,8,8
+M,2,3,4,2,3,7,6,3,4,9,7,8,6,5,1,8
+C,4,6,5,5,4,6,7,4,4,7,6,11,4,9,8,10
+D,3,5,5,4,3,9,6,4,6,10,4,5,2,8,3,8
+B,3,5,4,4,3,7,7,5,5,6,6,6,2,8,6,10
+X,2,2,3,3,2,8,7,3,8,6,6,8,2,8,6,8
+A,2,2,4,3,2,7,2,2,2,6,2,8,2,7,3,7
+X,4,5,8,4,3,8,7,1,9,11,4,7,3,8,3,8
+N,3,4,5,3,2,9,8,3,5,10,3,5,4,9,1,7
+G,3,5,5,4,3,6,6,6,6,6,6,9,2,8,4,8
+X,2,5,4,4,2,7,7,3,9,6,6,8,2,8,6,8
+Y,2,4,4,6,4,8,11,3,3,5,8,9,2,11,5,6
+P,5,11,7,8,4,7,10,5,5,12,5,3,1,10,3,8
+F,3,5,5,6,5,7,9,4,4,7,6,7,4,9,8,9
+X,3,9,6,7,5,7,6,2,6,7,5,8,3,6,7,7
+C,2,1,2,2,1,6,7,6,10,7,6,14,0,8,4,9
+J,5,10,6,8,5,8,5,8,5,8,7,8,2,7,4,6
+U,4,9,6,8,7,7,6,5,4,6,6,8,4,8,1,7
+E,4,7,5,5,5,8,4,6,3,8,7,10,4,9,7,9
+U,7,11,6,6,3,7,6,4,6,4,8,6,6,7,3,6
+U,2,3,3,2,1,5,8,5,6,9,8,8,3,9,2,6
+Q,3,3,4,4,3,8,7,6,2,5,7,9,3,8,5,9
+H,2,3,3,1,2,8,8,3,5,10,6,8,3,8,2,8
+Z,2,5,5,3,2,7,8,2,9,12,6,8,1,9,5,7
+F,2,3,3,1,1,5,10,4,5,10,9,5,1,9,3,6
+W,7,8,7,6,4,2,10,3,4,11,11,9,7,10,1,7
+J,2,6,3,4,2,8,6,3,6,12,5,9,1,6,1,6
+B,5,9,7,6,6,10,6,2,6,11,3,8,3,8,4,12
+G,2,3,3,2,1,7,7,5,6,10,6,10,2,9,3,9
+Z,4,9,5,7,2,7,7,4,15,9,6,8,0,8,8,8
+C,4,9,5,7,3,4,7,5,6,11,9,14,2,8,3,8
+O,4,9,5,7,2,8,7,9,8,7,6,9,3,8,4,8
+O,4,8,5,6,3,7,7,8,5,10,7,8,3,8,3,8
+E,6,9,8,7,5,7,7,3,9,11,8,9,2,8,4,8
+G,3,2,4,3,2,7,6,6,6,6,6,10,2,9,4,9
+I,1,3,1,2,0,7,7,2,6,7,6,8,0,8,2,8
+P,4,7,6,5,4,8,9,4,4,12,4,3,1,10,3,8
+S,2,3,2,2,1,8,8,6,5,7,6,7,2,8,8,8
+F,4,7,6,5,4,8,8,2,6,13,5,5,2,10,3,9
+U,5,5,6,4,3,4,8,5,8,11,11,9,3,9,2,7
+O,5,9,5,7,5,7,7,8,4,9,6,8,3,8,3,8
+S,7,11,7,6,3,8,5,4,4,13,7,9,3,9,3,8
+C,2,7,3,5,1,6,8,7,8,5,6,13,1,7,4,9
+S,2,3,3,2,1,8,7,2,7,10,6,8,1,8,4,8
+T,4,6,6,8,2,6,15,1,6,9,11,7,0,8,0,8
+B,7,10,9,8,9,7,7,5,5,7,5,7,4,8,7,8
+Q,5,7,6,9,6,9,7,7,2,5,7,10,3,8,6,10
+V,5,10,5,7,3,2,11,3,3,11,11,8,2,11,1,8
+F,7,10,6,5,3,7,8,2,7,11,6,6,2,9,5,6
+V,7,13,5,7,3,7,10,6,4,9,9,4,5,12,3,8
+W,4,9,6,6,6,11,10,2,3,5,9,7,7,10,1,8
+E,3,4,4,6,2,3,8,6,10,7,6,14,0,8,7,7
+G,2,3,3,1,1,7,7,5,5,9,7,9,2,8,4,10
+L,2,5,3,4,2,4,4,4,8,2,1,7,0,7,1,6
+Q,4,5,5,5,4,7,4,5,5,7,5,9,4,5,6,7
+E,3,8,4,6,4,8,7,5,9,6,4,8,2,8,6,9
+U,1,0,1,0,0,7,6,10,4,7,12,8,3,10,0,8
+R,4,7,6,5,6,7,7,3,4,7,6,8,6,9,6,5
+P,4,7,5,5,4,5,11,8,3,10,7,3,2,11,3,7
+P,3,5,5,8,7,8,11,5,0,8,6,6,4,10,6,8
+K,3,2,4,3,3,5,7,4,7,7,6,10,6,8,4,9
+N,4,5,5,7,3,7,7,15,2,4,6,8,6,8,0,8
+F,6,9,5,4,2,8,8,3,6,12,5,6,2,8,6,7
+A,2,1,3,1,1,7,4,2,0,7,2,8,2,6,2,8
+A,3,2,5,3,2,8,2,2,2,7,2,8,2,7,2,7
+J,3,11,4,8,2,10,6,1,8,11,3,6,0,7,1,7
+L,2,3,3,2,1,7,4,2,7,8,2,10,0,7,2,8
+G,4,7,6,5,3,6,6,6,7,6,6,10,3,7,4,8
+O,6,9,6,7,6,8,6,7,4,9,4,8,3,9,3,7
+O,3,9,4,6,3,7,7,9,5,7,6,8,3,8,3,7
+E,3,2,3,3,3,7,7,5,7,7,5,9,2,8,5,10
+K,3,2,4,4,3,5,7,4,8,7,6,11,3,8,5,9
+F,3,8,3,5,1,0,13,4,4,12,11,7,0,8,2,6
+E,5,9,7,7,7,6,7,3,6,8,7,11,5,10,9,9
+G,6,10,8,7,9,8,8,5,3,6,6,7,9,8,9,14
+U,3,4,4,3,2,4,8,5,6,11,10,9,3,9,1,6
+K,6,9,8,7,7,5,6,4,7,6,6,12,5,7,7,10
+U,6,10,8,7,4,4,9,7,8,9,11,10,3,9,1,8
+M,5,9,5,6,6,7,6,10,1,7,8,8,8,4,0,8
+O,6,11,9,8,6,8,8,9,5,7,7,5,5,8,4,9
+S,5,10,6,7,3,8,7,5,9,5,6,8,1,8,9,8
+X,3,5,5,3,2,8,7,1,8,10,5,7,3,8,3,7
+J,2,4,4,3,1,9,5,3,5,13,6,11,1,7,0,7
+V,6,8,6,6,4,4,11,1,3,8,10,8,4,11,1,7
+E,4,8,6,6,6,7,7,3,6,7,7,10,4,9,8,8
+I,0,6,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+L,2,3,2,1,1,4,4,4,6,2,2,5,1,7,1,6
+D,4,6,5,4,4,10,6,3,6,11,4,6,3,8,2,9
+Y,2,4,3,3,1,3,11,3,5,12,10,6,1,10,1,6
+A,1,1,2,1,0,7,4,3,0,7,1,8,2,7,1,8
+K,6,10,8,8,6,6,7,1,7,10,6,10,3,8,4,8
+X,3,5,5,3,2,7,7,1,8,10,6,8,2,8,3,8
+Y,2,3,2,2,1,3,11,3,5,11,10,5,1,11,1,6
+U,3,7,4,5,1,7,5,13,5,7,14,8,3,9,0,8
+A,2,4,4,6,2,7,3,3,3,7,1,8,3,6,3,8
+J,1,1,2,3,1,9,6,3,5,12,5,10,1,6,2,6
+X,3,4,6,3,3,7,7,1,9,10,7,8,3,8,3,7
+Y,7,9,6,13,5,5,7,5,3,7,11,6,4,10,5,6
+Z,5,9,6,7,3,7,7,4,15,9,6,8,0,8,8,8
+U,7,11,9,8,7,6,9,4,7,5,8,10,6,10,1,8
+T,5,10,6,8,5,6,10,1,8,11,9,6,1,10,3,4
+I,3,9,6,7,6,10,5,2,4,9,5,5,3,8,5,7
+A,2,7,4,5,2,11,2,3,3,10,2,9,2,6,3,8
+M,3,1,4,3,3,8,6,6,4,7,7,8,7,5,1,7
+C,2,1,3,2,1,6,8,7,7,8,7,13,1,10,4,10
+K,4,10,5,8,6,6,6,3,7,6,5,8,7,8,5,9
+J,1,2,2,4,1,10,6,2,5,12,4,9,1,6,1,7
+V,2,6,3,4,1,7,9,4,2,7,13,8,3,10,0,8
+B,4,7,5,5,5,8,6,6,7,6,6,6,2,8,7,10
+X,2,1,2,1,0,8,7,4,4,7,6,8,3,8,4,8
+J,2,2,3,4,1,10,6,2,7,12,3,8,1,6,1,7
+U,3,7,3,5,2,8,6,12,4,7,11,8,3,9,0,8
+E,2,1,3,2,2,7,7,5,7,7,5,9,2,8,5,10
+M,4,7,7,5,5,4,8,3,4,10,10,10,5,9,2,6
+M,3,4,5,3,3,7,6,3,4,9,7,8,7,5,1,8
+F,6,10,8,7,5,6,10,1,6,13,7,5,1,10,2,7
+V,5,7,5,5,3,4,12,1,2,8,10,7,3,12,1,8
+Q,3,4,4,5,3,8,7,6,2,8,7,10,3,8,5,8
+K,4,2,5,3,3,5,7,4,7,7,6,11,3,8,5,9
+B,2,1,2,1,1,7,7,7,5,6,5,7,1,8,7,10
+T,7,11,7,9,5,5,12,4,7,12,9,4,2,12,2,4
+A,3,7,4,5,3,8,3,2,2,7,2,8,2,6,3,7
+I,1,6,0,8,1,7,7,4,4,7,6,8,0,8,0,8
+C,1,0,1,1,0,6,7,6,7,7,6,13,0,8,4,10
+V,2,7,4,5,3,9,12,2,3,4,10,9,2,11,1,9
+Y,1,1,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+Z,2,7,3,5,3,7,7,5,9,7,6,8,1,8,7,8
+Q,2,3,3,4,3,8,8,5,2,5,8,10,2,9,5,9
+B,6,9,5,4,3,10,6,6,5,11,4,9,5,7,6,11
+X,2,4,4,3,2,7,7,3,9,6,6,8,2,8,5,8
+D,2,0,2,1,1,5,7,8,6,6,6,6,2,8,3,8
+W,7,11,8,6,5,4,7,2,3,8,10,8,10,10,2,5
+X,4,6,6,4,5,8,6,3,5,6,7,8,3,9,8,9
+V,3,2,5,4,2,7,12,2,3,7,11,9,2,10,1,8
+Z,6,10,8,7,6,10,6,5,4,8,5,7,3,7,11,7
+V,4,7,6,6,7,7,8,5,5,7,6,8,6,9,7,8
+W,6,5,7,4,4,4,11,2,2,9,9,8,7,11,1,6
+B,4,3,4,5,3,6,7,8,6,7,6,6,2,8,9,10
+N,4,7,6,5,5,6,8,3,4,8,7,7,5,9,5,3
+M,3,6,6,4,6,9,4,2,2,8,4,8,8,6,2,7
+F,5,11,6,8,5,5,11,7,6,11,10,5,2,9,2,5
+C,2,4,3,2,1,5,9,4,7,11,9,11,1,9,2,7
+G,5,10,5,7,4,6,6,6,5,10,7,13,2,9,5,9
+C,5,10,6,8,3,5,8,6,8,12,9,12,2,9,3,7
+Z,4,8,5,6,3,6,8,6,11,7,7,10,1,9,8,8
+A,4,5,6,4,4,8,7,3,5,7,8,8,5,9,3,6
+Z,3,7,4,5,2,7,8,3,12,8,6,8,0,8,7,7
+S,5,5,6,8,3,8,8,6,9,5,6,7,0,8,9,7
+L,2,4,2,3,1,4,4,4,8,2,1,6,0,7,1,6
+T,6,11,5,6,2,4,11,3,7,13,8,6,2,7,3,3
+D,8,15,7,8,5,6,7,4,7,9,6,7,5,9,7,5
+G,4,6,5,4,3,6,8,6,6,10,8,9,2,8,4,9
+J,0,0,1,0,0,12,4,4,3,12,4,10,0,7,0,8
+Z,1,3,2,2,1,7,7,5,8,6,6,8,1,8,7,8
+Z,3,8,4,6,4,6,8,3,8,7,6,9,0,8,9,7
+I,5,9,4,4,2,9,7,6,4,13,5,8,3,8,5,10
+C,3,5,4,3,2,4,8,5,7,11,9,12,1,9,3,7
+B,6,11,6,8,5,6,6,9,7,6,6,7,2,8,10,10
+N,1,0,1,1,0,7,7,9,0,6,6,8,4,8,0,8
+V,3,10,5,7,2,6,8,4,3,8,14,8,3,10,0,8
+J,5,8,6,6,2,8,4,5,6,15,7,13,1,6,1,6
+D,2,5,4,4,3,9,6,4,6,10,4,6,2,8,3,8
+E,6,9,8,7,7,8,8,6,3,6,6,10,4,8,8,9
+J,1,2,2,3,1,10,6,2,6,12,4,9,0,7,1,8
+T,2,7,4,4,1,8,14,1,6,6,11,8,0,8,0,8
+V,4,10,6,8,2,8,8,4,3,6,14,8,3,9,0,8
+F,3,9,3,6,1,1,12,5,5,11,10,8,0,8,3,6
+F,8,14,7,8,3,6,9,2,7,10,7,6,2,10,5,6
+C,5,9,5,7,3,4,10,7,8,13,10,8,2,10,2,6
+W,4,11,6,8,4,11,8,5,2,6,9,8,8,10,0,8
+U,10,14,9,8,4,6,4,4,6,4,7,6,6,5,2,7
+J,2,2,4,4,2,10,6,2,7,12,4,9,1,6,1,7
+I,1,3,2,2,1,7,8,1,7,13,6,8,0,8,1,7
+W,4,8,6,6,6,8,10,2,3,6,8,8,7,11,1,8
+B,2,3,2,2,2,7,8,5,5,7,6,6,2,8,5,9
+Y,2,2,4,3,1,7,11,1,7,7,11,8,1,11,2,8
+N,6,10,8,8,6,7,8,6,6,6,6,4,9,10,5,6
+Z,2,7,3,5,2,7,7,3,11,8,6,8,0,8,7,8
+S,4,6,4,8,3,8,8,6,9,4,5,5,0,8,9,7
+S,2,6,3,4,3,8,8,7,5,7,5,8,2,8,8,8
+F,6,13,6,7,3,7,9,2,6,12,5,5,2,9,6,6
+Y,3,3,5,4,1,5,10,3,2,8,13,8,2,11,0,8
+J,0,0,1,1,0,12,4,5,3,12,4,11,0,7,0,8
+Z,4,7,5,5,4,9,8,5,3,7,5,7,3,7,8,4
+W,6,8,6,6,7,7,10,4,3,9,6,6,8,10,4,5
+C,5,7,6,5,6,6,6,4,3,7,6,11,5,9,3,9
+W,5,11,8,8,8,4,12,2,2,8,9,9,7,13,2,8
+T,1,3,2,2,1,6,11,3,4,8,10,7,2,11,0,7
+R,3,8,4,6,4,6,10,7,4,7,4,9,2,6,5,11
+E,3,7,3,5,2,3,7,6,9,7,6,14,0,8,7,8
+B,4,9,6,6,6,8,7,5,6,9,6,6,3,9,7,8
+Z,2,2,3,3,2,7,7,5,9,6,6,8,2,8,7,8
+S,5,8,7,6,9,7,10,3,4,8,7,7,3,7,8,2
+R,3,6,4,4,3,9,7,3,5,10,4,7,3,7,3,10
+M,3,4,4,3,3,7,6,6,4,6,7,9,6,5,2,8
+E,2,3,3,1,1,5,8,2,7,11,8,10,1,8,3,7
+B,2,4,2,3,2,7,7,5,5,6,6,6,2,8,5,9
+H,3,5,4,3,3,9,7,6,6,7,6,8,3,8,3,7
+W,6,11,9,8,8,7,9,5,1,7,9,8,9,10,1,7
+J,6,7,4,10,3,6,10,3,3,13,6,5,3,8,7,9
+J,4,10,6,7,5,6,8,3,4,8,7,7,6,7,4,7
+N,6,8,9,6,4,8,8,2,6,10,5,6,6,9,1,7
+F,2,6,2,4,1,1,11,4,7,12,12,9,0,8,2,6
+D,3,8,5,6,4,10,6,3,6,11,4,7,3,8,2,9
+X,3,3,4,4,1,7,7,6,2,7,6,8,3,8,4,8
+W,7,9,7,5,3,3,9,3,2,8,11,9,10,11,0,7
+R,4,10,6,8,6,7,7,6,6,7,6,7,3,7,5,9
+W,7,11,10,8,15,10,8,5,3,7,7,8,13,10,4,6
+D,3,5,5,4,3,9,6,4,7,10,4,6,2,8,3,8
+V,3,4,4,3,1,5,12,2,3,9,11,7,2,11,1,8
+K,6,10,8,8,7,5,5,4,8,6,7,12,4,8,7,9
+O,10,15,7,8,4,7,7,5,5,8,4,7,5,9,6,8
+L,4,8,5,6,3,7,4,1,7,8,2,10,1,6,3,8
+O,4,7,5,5,3,7,8,8,5,7,7,9,3,8,3,8
+U,3,7,3,5,2,7,5,13,5,7,13,8,3,9,0,8
+O,5,6,6,6,5,6,7,6,7,9,7,9,4,7,5,5
+J,2,6,3,4,1,8,7,3,6,15,5,9,1,6,1,7
+N,3,3,4,5,2,7,7,14,2,5,6,8,6,8,0,8
+O,7,11,5,6,3,6,7,5,4,7,4,7,5,8,5,7
+N,6,11,9,8,6,11,8,2,5,10,2,4,7,10,2,8
+P,2,7,3,4,1,4,11,8,3,10,6,4,1,10,3,8
+J,3,8,4,6,2,9,6,2,8,15,4,8,0,7,0,7
+A,1,1,3,2,1,7,2,2,1,7,2,8,1,6,2,7
+C,7,10,8,8,4,6,8,7,8,13,8,9,2,11,3,7
+X,4,10,5,7,2,7,7,4,4,7,6,8,3,8,4,8
+L,2,5,3,3,2,5,4,5,6,2,2,5,1,6,1,6
+I,1,8,1,6,1,7,7,0,8,7,6,8,0,8,3,8
+E,3,6,4,4,2,4,6,6,10,7,7,13,0,8,8,8
+M,7,9,10,6,6,10,5,2,6,9,4,7,8,6,2,8
+X,4,5,8,4,3,7,7,1,9,10,6,8,2,8,3,7
+D,5,9,6,7,5,10,6,4,7,10,3,5,3,8,3,9
+D,6,12,6,6,5,9,6,3,6,10,4,7,5,8,8,7
+J,5,11,4,8,3,8,8,2,4,12,4,5,2,9,7,8
+T,2,1,3,1,0,7,15,2,4,7,10,8,0,8,0,8
+U,3,7,3,5,1,7,5,13,5,7,13,8,3,9,0,8
+K,3,7,5,5,5,6,6,3,4,7,6,9,5,7,7,9
+K,5,11,5,8,2,4,7,9,2,7,4,11,4,8,2,11
+P,2,4,4,3,2,7,9,3,4,12,5,4,1,9,3,8
+B,5,8,6,6,5,9,8,7,8,7,5,5,2,8,8,9
+K,5,8,6,6,6,5,6,4,6,6,6,10,3,8,5,10
+E,2,2,3,3,2,7,7,5,7,7,6,9,2,8,5,10
+A,3,8,5,6,3,12,3,2,2,9,2,9,3,7,3,9
+Y,4,10,6,8,6,9,5,6,4,7,8,8,6,8,8,3
+S,6,10,7,8,4,7,7,4,8,11,7,8,2,9,5,8
+H,2,2,3,3,3,6,7,5,6,7,6,8,3,8,3,8
+Y,3,4,4,2,2,4,10,2,7,10,10,5,2,11,3,4
+Z,3,8,5,6,3,8,7,2,9,11,6,8,2,8,6,8
+E,4,11,5,8,5,3,7,5,9,7,7,14,0,8,6,9
+Z,7,10,5,14,5,7,10,3,3,11,7,7,3,8,14,7
+M,6,5,7,8,4,8,7,13,2,6,9,8,9,6,0,8
+P,1,1,2,1,1,5,11,7,1,10,6,4,1,9,3,8
+T,6,8,6,6,3,4,14,5,7,12,9,3,1,11,2,4
+W,5,4,6,3,3,4,11,3,2,9,9,7,7,11,1,6
+U,5,10,6,8,3,7,4,15,6,7,14,8,3,9,0,8
+U,7,11,6,6,3,7,6,5,6,3,9,7,5,8,3,6
+E,4,10,6,7,6,7,7,5,3,7,6,8,5,8,8,9
+W,7,7,7,5,6,5,10,3,3,9,7,7,8,10,3,5
+K,3,8,4,6,3,4,8,7,3,6,4,11,3,8,2,11
+Z,5,7,7,5,3,7,7,2,10,12,7,7,1,7,6,7
+I,4,7,6,8,6,9,8,5,5,7,5,7,3,8,9,8
+W,8,10,8,8,8,6,11,3,3,9,7,7,10,12,4,5
+P,6,7,8,10,10,8,7,4,3,7,7,7,7,12,6,6
+F,3,6,6,4,3,6,10,2,6,13,6,4,1,10,2,7
+F,4,4,4,6,2,1,14,5,3,12,9,5,0,8,2,6
+R,5,8,8,7,9,8,7,4,4,8,5,7,7,8,6,5
+H,4,8,5,6,5,8,7,5,6,7,6,6,3,8,3,7
+Q,4,8,5,9,6,8,8,5,2,7,9,10,3,9,5,7
+W,10,15,11,8,7,7,8,2,4,6,9,6,11,9,3,5
+J,1,6,2,4,1,14,2,6,5,13,2,10,0,7,0,8
+R,6,11,6,8,4,5,12,9,3,7,3,9,3,7,6,11
+D,4,8,6,6,4,6,7,8,7,6,5,4,3,8,4,9
+C,7,10,7,7,4,4,10,7,8,12,10,8,2,10,3,7
+A,3,9,5,6,2,6,6,3,1,6,0,8,2,7,1,7
+Z,3,9,4,6,2,7,7,4,14,10,6,8,0,8,8,8
+B,3,6,3,4,3,6,6,8,6,6,6,7,2,8,8,9
+O,2,3,3,2,2,7,7,6,4,9,6,8,2,8,2,8
+B,1,0,2,1,1,7,7,7,5,6,6,7,1,8,7,9
+K,4,7,6,6,5,8,6,2,3,8,4,8,4,6,7,11
+S,3,5,3,4,3,8,6,7,5,7,7,9,2,10,9,8
+D,2,3,3,2,2,9,6,3,5,10,4,7,2,8,2,8
+V,5,9,6,7,4,7,11,3,2,6,11,8,3,10,3,9
+F,3,5,4,8,2,0,12,4,6,12,12,9,0,8,2,6
+O,4,9,5,6,3,9,7,9,8,7,5,10,3,8,4,8
+P,5,10,8,8,5,7,10,5,5,12,5,3,1,10,4,8
+K,3,4,6,3,3,6,7,2,7,10,7,10,3,8,3,7
+M,4,9,6,6,7,7,8,6,4,7,6,8,6,9,7,6
+W,8,9,8,6,6,2,12,2,2,10,10,8,7,11,1,7
+H,3,7,4,4,2,7,8,14,1,7,5,8,3,8,0,8
+L,3,6,5,4,3,6,4,1,8,8,2,11,0,7,2,8
+N,2,4,4,3,2,7,8,3,4,10,6,7,5,9,0,7
+T,4,8,4,6,3,6,12,4,6,11,9,4,2,12,2,4
+L,2,7,3,5,2,8,4,3,7,7,2,8,1,6,2,8
+W,7,11,10,8,4,9,7,5,2,6,8,8,9,9,0,8
+E,6,10,9,7,7,6,8,1,8,11,6,9,3,8,4,8
+H,2,4,4,3,2,7,7,3,5,10,6,8,3,8,2,8
+J,5,11,7,8,4,10,6,1,7,14,3,7,0,7,1,8
+W,5,8,5,6,5,5,10,3,3,9,7,7,7,11,2,5
+T,2,8,3,5,1,7,14,0,6,7,11,8,0,8,0,8
+U,6,11,8,8,8,8,6,8,5,7,6,9,6,8,5,6
+E,5,10,3,5,2,7,8,5,6,10,6,9,1,9,7,8
+G,2,5,3,4,2,6,7,5,5,9,7,10,2,9,4,10
+S,1,3,2,2,1,8,8,6,5,7,6,7,2,8,8,8
+U,8,15,7,9,4,4,4,5,5,4,7,8,5,9,2,8
+K,6,10,6,5,3,7,7,3,6,10,8,9,6,11,3,7
+A,2,3,3,2,1,10,2,2,1,9,2,9,1,6,2,8
+F,5,11,7,8,6,6,10,2,5,13,7,5,2,10,2,7
+O,5,9,6,7,4,7,7,9,5,7,7,8,3,8,3,8
+M,4,8,6,6,7,7,8,6,4,6,6,8,6,9,7,10
+Z,7,10,7,6,4,8,6,2,8,12,6,9,3,8,6,7
+H,5,9,5,6,2,7,8,15,0,7,5,8,3,8,0,8
+Q,9,14,8,8,4,9,3,4,7,11,3,10,3,8,8,11
+S,2,4,3,3,1,9,6,2,7,10,5,8,1,9,5,9
+B,4,8,4,6,5,6,8,8,6,7,5,7,2,8,7,9
+W,4,6,5,4,4,7,6,7,2,7,7,8,6,8,5,10
+X,7,10,10,8,5,5,8,2,9,11,10,9,3,8,4,6
+F,3,8,3,5,1,1,13,5,4,12,10,7,0,8,2,6
+G,5,10,6,7,8,8,8,5,2,6,6,8,7,8,7,13
+M,7,13,8,8,5,6,3,3,2,8,4,10,7,2,2,8
+Q,4,7,4,9,4,8,8,6,2,8,8,10,3,9,6,7
+K,4,8,6,6,4,3,8,2,7,10,11,12,3,8,3,5
+M,6,10,7,5,4,9,3,2,2,9,4,9,8,2,2,9
+S,4,9,5,6,3,8,8,5,9,5,6,7,0,8,9,7
+Z,6,9,8,7,5,8,6,2,9,12,5,10,3,7,7,9
+M,3,3,4,2,2,9,6,6,4,6,7,6,6,5,2,6
+G,3,8,5,6,2,7,7,8,7,6,6,8,2,7,6,11
+M,5,6,8,4,5,9,6,3,5,9,5,7,8,6,2,8
+M,5,8,6,6,5,8,5,11,0,7,9,8,9,6,2,7
+L,3,9,4,7,3,6,4,1,8,8,2,10,0,7,2,8
+P,5,7,7,5,3,6,14,5,2,12,4,1,0,10,3,8
+Y,4,8,6,12,11,9,7,4,2,6,7,9,5,11,8,9
+H,3,6,4,4,5,7,8,4,2,7,6,7,7,9,7,8
+X,4,11,6,8,6,8,8,2,6,7,7,8,5,11,8,8
+O,3,7,4,5,3,7,7,8,5,6,5,6,3,8,3,8
+G,3,4,4,3,2,6,7,5,5,9,7,10,2,9,4,9
+A,1,0,2,0,0,7,4,2,0,7,2,8,2,7,1,8
+W,4,9,7,6,5,8,10,2,3,6,9,8,7,11,1,8
+O,2,3,3,2,2,7,8,6,4,9,6,8,2,8,2,8
+D,5,9,6,7,5,9,7,4,7,11,5,6,3,7,4,8
+H,6,9,9,7,7,7,7,3,6,10,7,8,3,8,3,8
+W,5,9,6,4,3,5,8,2,3,7,9,8,9,11,2,6
+H,3,5,4,7,2,7,8,15,1,7,5,8,3,8,0,8
+Y,3,4,5,5,1,6,10,3,2,9,13,8,1,11,0,8
+K,4,7,4,5,2,4,7,8,1,7,6,11,3,8,2,11
+E,6,11,6,8,4,3,7,6,11,7,6,14,0,8,8,7
+S,5,11,6,8,4,8,7,5,9,11,3,7,2,6,5,9
+S,3,6,4,4,3,5,9,2,6,10,7,7,2,7,4,4
+H,5,8,7,6,6,8,6,7,7,7,7,7,3,8,3,8
+T,3,5,4,4,3,6,8,3,7,8,7,8,3,9,7,6
+J,1,6,2,4,0,13,3,7,4,13,3,11,0,7,0,8
+Y,6,8,6,6,3,4,10,3,7,11,11,6,1,11,3,4
+N,2,1,3,2,1,7,7,13,1,5,6,8,5,8,0,8
+P,2,3,2,2,1,5,11,5,3,10,7,3,0,9,3,6
+W,3,1,4,3,3,10,11,3,2,5,9,7,6,11,0,8
+Z,6,11,8,8,5,9,6,3,10,12,4,8,2,7,6,8
+X,3,1,4,2,2,7,7,4,9,6,6,8,3,8,6,8
+I,3,7,4,5,2,9,6,0,7,13,5,8,0,8,1,8
+T,4,5,5,3,2,5,11,2,9,12,9,5,0,10,2,4
+I,1,3,2,2,1,7,7,1,7,13,6,8,0,8,1,8
+A,1,0,2,0,0,8,4,2,0,7,2,8,2,7,1,8
+D,6,10,6,6,3,11,3,4,5,12,2,8,5,7,4,10
+M,3,3,5,2,2,8,6,2,4,9,6,8,7,6,2,8
+N,4,4,4,6,2,7,7,14,2,4,6,8,6,8,0,8
+F,4,8,6,6,7,9,7,1,5,9,5,5,3,10,4,6
+T,1,0,2,1,0,7,14,1,4,7,10,8,0,8,0,8
+T,4,10,5,8,5,7,11,3,7,7,11,8,2,12,1,8
+X,3,7,4,5,2,8,7,4,4,7,6,8,2,8,4,8
+R,3,9,4,6,3,5,11,8,4,7,3,9,3,7,6,11
+Z,2,3,4,2,2,7,8,2,9,12,7,7,1,8,5,7
+Z,4,9,5,7,4,7,8,3,13,8,6,8,0,8,8,7
+G,2,2,3,3,2,7,6,6,6,7,6,10,2,9,4,9
+A,1,3,2,1,1,6,2,1,1,6,2,8,1,6,1,7
+C,1,0,1,1,0,6,7,6,8,7,6,14,0,8,4,10
+E,6,9,8,8,9,7,7,5,4,8,7,9,8,11,10,12
+R,5,9,7,7,4,10,7,3,7,10,2,7,3,6,4,11
+S,5,11,6,8,3,8,8,6,10,5,6,6,0,8,9,7
+V,3,7,4,5,3,6,12,2,2,8,10,8,4,11,4,8
+Z,1,0,2,0,0,7,7,3,10,8,6,8,0,8,6,8
+Y,8,13,6,8,4,6,8,4,4,10,7,5,3,10,4,4
+G,4,6,4,4,2,6,7,6,7,10,7,10,2,10,4,9
+I,1,3,2,2,0,7,7,1,7,13,6,8,0,8,0,7
+T,2,3,3,2,1,5,12,3,6,11,9,4,1,10,2,5
+Y,6,10,6,8,4,4,9,1,8,10,10,6,1,10,3,4
+Y,1,1,2,1,0,8,10,3,1,6,12,8,1,11,0,8
+V,6,9,8,8,9,7,8,6,5,7,6,7,6,11,8,11
+L,5,9,5,4,3,7,5,3,5,12,7,11,3,8,6,8
+H,5,7,7,5,5,7,7,3,6,10,5,8,3,8,3,8
+W,4,7,6,5,3,4,8,5,1,7,9,8,8,10,0,8
+V,4,8,6,6,3,9,12,3,3,4,11,9,3,9,2,8
+C,2,4,3,3,1,6,8,7,7,8,8,13,1,10,4,10
+O,2,0,2,1,0,7,7,6,5,7,6,8,2,8,3,8
+A,4,5,6,8,2,8,4,3,2,7,1,8,3,7,2,8
+G,4,2,5,4,3,6,6,6,6,6,6,10,2,9,4,8
+D,3,3,4,2,2,7,7,6,6,7,6,5,5,8,3,7
+E,4,11,4,8,3,3,6,6,12,7,7,15,0,8,7,7
+O,4,4,6,7,3,8,6,9,8,7,5,9,3,8,4,8
+J,3,10,4,8,3,14,3,5,4,13,2,9,0,7,0,8
+I,1,5,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+G,1,0,1,0,0,8,6,5,4,6,6,9,1,8,5,10
+T,5,6,5,4,3,4,12,2,7,12,10,5,1,10,1,5
+I,2,10,3,8,4,7,7,0,7,7,6,8,0,8,3,8
+R,2,4,3,2,2,8,8,4,5,9,5,7,2,7,4,10
+Y,3,5,4,4,2,4,10,2,7,11,10,6,1,11,3,5
+O,4,6,4,4,3,8,6,7,4,9,5,8,3,8,3,8
+P,6,10,8,8,6,7,10,4,4,13,6,3,1,10,3,8
+Y,6,7,8,10,10,9,9,4,2,4,8,9,5,13,10,10
+W,4,3,5,2,3,4,11,3,2,9,9,7,6,11,1,7
+G,2,5,3,4,2,6,7,6,6,10,7,11,2,9,4,9
+W,5,7,5,5,4,3,11,2,2,10,9,7,5,11,1,7
+X,3,7,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+T,2,10,4,7,1,8,14,0,6,6,11,8,0,8,0,8
+G,2,5,4,3,2,7,7,6,6,6,6,10,2,8,4,9
+D,10,15,10,8,5,8,6,5,6,10,3,6,6,6,6,10
+K,5,10,7,8,8,6,8,5,3,7,5,8,4,7,7,11
+N,9,13,7,7,3,5,9,4,6,3,4,11,6,10,2,7
+J,1,3,2,2,1,10,6,2,6,12,4,8,0,7,1,7
+E,3,8,3,6,2,3,7,6,10,7,6,14,0,8,7,8
+C,7,14,5,8,4,6,9,4,4,9,8,9,4,9,9,10
+O,5,10,7,8,3,7,6,9,8,6,5,6,3,8,4,8
+E,4,11,5,8,7,7,7,5,7,7,5,9,6,8,6,10
+X,5,7,7,6,7,9,7,2,4,7,6,6,3,10,7,8
+C,9,15,7,8,5,8,7,5,3,8,8,10,4,9,8,13
+Z,4,6,6,4,3,7,8,2,8,11,7,8,1,9,5,7
+S,5,10,5,5,2,7,7,3,4,13,7,9,2,9,3,8
+O,1,0,1,0,0,8,7,6,4,7,6,8,2,8,2,8
+D,4,8,5,6,4,7,7,7,8,6,5,5,3,8,3,7
+Q,2,4,3,5,3,8,7,6,2,8,7,9,2,9,4,8
+K,6,9,9,7,4,3,8,4,8,12,12,12,3,8,4,5
+J,2,8,3,6,2,9,6,2,7,12,3,8,1,6,1,6
+U,2,3,3,2,1,8,8,5,6,5,9,8,3,10,0,8
+V,4,9,6,6,4,8,10,2,1,6,10,8,3,10,3,9
+C,6,11,8,8,9,5,6,3,5,8,6,12,6,9,3,9
+K,4,11,6,8,6,5,6,4,7,6,6,11,3,8,6,9
+Z,6,10,8,8,5,8,7,2,10,12,5,8,1,7,6,7
+T,5,8,7,6,6,7,7,7,7,6,7,9,3,10,6,7
+S,5,10,6,8,3,8,8,6,9,5,6,7,0,8,9,8
+T,3,11,5,8,1,9,15,0,6,6,11,8,0,8,0,8
+V,5,7,5,5,3,3,12,2,2,9,10,8,3,10,1,7
+T,4,8,5,6,3,7,12,3,7,7,11,8,2,12,1,7
+R,4,7,5,5,5,7,7,4,6,6,5,7,3,7,4,8
+P,4,8,5,6,4,7,10,4,4,12,5,3,1,10,2,8
+R,4,9,5,7,4,10,7,3,7,10,2,7,3,6,3,11
+I,2,11,2,8,4,7,7,0,7,7,6,8,0,8,2,8
+Y,2,3,3,1,1,8,11,1,6,5,11,9,1,11,1,8
+G,4,9,5,6,3,6,7,7,6,9,7,12,2,8,4,10
+H,8,11,11,8,9,9,6,3,7,10,4,8,6,8,5,8
+T,4,5,5,3,2,7,12,3,7,7,11,8,2,11,1,8
+E,4,8,5,6,4,5,8,3,7,11,8,9,3,8,4,7
+P,3,5,5,3,2,7,10,5,3,11,5,3,1,10,2,8
+Q,2,2,3,4,2,8,7,6,2,6,6,9,2,9,5,9
+T,3,1,4,3,2,7,12,3,6,7,11,8,2,11,1,7
+D,8,15,7,8,5,6,7,4,7,8,5,7,6,9,7,5
+M,7,12,8,7,4,12,2,4,3,12,1,8,6,3,1,9
+K,6,11,9,8,5,3,7,3,8,11,11,12,3,8,4,6
+L,5,9,7,7,5,6,4,2,7,7,2,9,1,6,3,8
+G,3,6,4,4,3,6,7,6,5,9,7,10,2,9,4,10
+U,5,6,6,4,2,4,8,5,8,11,11,9,3,9,1,6
+D,4,6,4,4,3,6,7,8,7,8,8,7,2,9,3,8
+Q,2,3,3,3,2,8,8,5,2,5,7,10,2,9,5,9
+V,2,6,4,4,2,8,11,2,3,5,11,9,2,10,0,8
+K,2,1,2,2,1,5,7,8,1,7,6,11,3,8,2,11
+P,4,9,6,6,4,5,13,5,3,13,6,2,0,10,2,8
+H,6,8,8,6,5,10,6,4,6,10,2,7,4,7,4,9
+S,4,4,4,6,2,8,9,6,9,5,5,5,0,7,9,8
+S,7,15,7,8,4,5,9,3,5,13,8,7,3,7,4,7
+H,2,1,3,1,2,7,8,6,6,7,6,10,3,8,3,9
+C,3,6,4,4,2,6,7,6,7,7,6,12,1,8,4,10
+H,1,0,1,0,0,7,8,10,2,7,5,8,2,8,0,8
+Y,2,3,3,1,1,4,11,2,6,11,10,5,0,10,1,5
+A,5,9,7,7,5,8,2,2,2,6,2,7,3,8,4,7
+T,6,9,8,7,6,6,7,7,7,7,7,8,4,10,6,9
+Q,2,4,3,5,3,8,7,6,2,8,7,9,2,9,4,8
+H,4,5,5,6,5,8,4,3,2,7,4,7,3,7,5,8
+I,4,8,5,6,3,9,5,2,7,7,7,5,0,9,4,7
+X,3,5,5,4,2,7,8,1,8,10,8,8,2,8,3,7
+V,1,0,2,0,0,8,9,3,1,6,12,8,2,11,0,8
+W,4,6,6,4,4,10,11,3,2,4,9,7,7,11,0,7
+K,4,6,6,4,3,7,6,2,7,10,5,10,4,7,4,9
+U,2,0,2,1,0,8,5,11,4,6,13,8,3,10,0,8
+U,3,5,4,4,2,6,8,6,7,7,9,9,3,9,1,8
+D,4,11,6,8,5,7,7,8,7,7,6,4,3,8,3,7
+A,2,2,4,3,2,7,2,1,2,6,2,8,2,6,2,7
+V,4,7,5,5,2,6,11,3,4,8,12,8,2,10,1,9
+A,5,10,8,8,6,6,5,2,4,4,2,7,6,7,6,4
+K,9,12,10,7,5,7,7,3,6,10,9,9,6,12,4,8
+U,3,2,4,3,2,7,8,6,8,8,10,8,3,9,1,8
+U,7,12,6,6,3,9,6,6,6,3,9,8,5,10,3,6
+V,4,9,6,7,3,8,11,3,4,5,11,8,3,10,1,8
+T,2,7,4,4,1,10,15,1,5,4,11,9,0,8,0,8
+T,3,2,4,3,2,6,12,3,7,8,11,7,2,11,1,7
+W,5,9,7,7,4,6,8,5,2,7,8,8,9,10,0,8
+V,4,6,4,4,2,2,11,4,3,12,11,8,2,11,1,7
+D,4,7,5,5,4,7,7,7,8,6,5,5,3,8,3,7
+H,3,6,5,4,4,6,7,7,6,7,6,11,3,8,3,10
+D,5,11,6,8,6,7,7,5,6,6,5,8,7,9,3,7
+M,7,9,11,7,6,9,6,2,5,9,5,7,11,7,2,8
+U,6,9,8,7,6,6,7,8,6,6,6,11,6,8,8,3
+X,4,7,6,5,3,7,8,1,8,10,7,8,2,8,3,7
+K,4,6,6,4,3,3,8,3,7,11,11,11,3,8,3,6
+B,3,8,5,6,4,8,7,7,6,7,6,5,2,8,8,9
+O,4,9,5,6,4,7,7,8,6,7,6,8,2,8,3,8
+T,2,5,3,4,2,7,12,3,6,7,11,8,2,11,1,8
+E,6,10,8,8,8,7,7,5,3,7,6,9,5,8,9,8
+W,12,12,11,7,5,6,11,2,3,7,11,7,9,12,1,7
+G,5,10,5,8,4,5,6,6,5,9,8,12,2,9,4,10
+A,2,0,3,1,0,8,4,2,0,7,2,8,2,6,1,8
+R,4,4,4,6,2,5,9,9,4,7,5,8,3,8,5,10
+M,4,8,4,6,5,8,5,10,0,6,9,8,7,5,1,6
+D,5,10,6,8,3,5,7,10,10,7,7,6,3,8,4,8
+U,2,3,3,2,1,5,8,5,6,10,9,8,3,9,1,6
+Q,4,7,6,10,8,8,11,4,2,5,8,11,5,14,8,13
+R,4,8,6,6,5,10,7,2,6,11,2,7,4,7,3,10
+W,2,1,3,2,2,10,11,3,2,5,9,7,5,11,0,8
+A,6,13,6,8,4,12,2,5,1,12,2,10,3,2,3,10
+T,5,6,5,4,3,6,11,3,6,11,9,5,2,12,2,4
+C,5,7,5,5,3,5,7,5,7,11,9,14,2,9,3,8
+P,4,7,5,5,3,5,13,5,4,13,6,2,0,9,2,7
+Z,5,9,5,4,3,6,8,2,8,11,8,9,3,9,5,5
+W,2,1,2,2,1,7,8,4,0,7,8,8,6,10,0,8
+P,4,9,4,6,4,3,14,6,1,12,7,3,0,9,3,8
+F,1,3,2,2,1,5,10,3,5,10,9,6,1,10,2,7
+O,4,10,6,8,4,7,6,9,5,7,4,8,3,8,3,8
+Z,2,4,4,6,2,11,4,3,4,10,3,9,2,7,5,9
+M,3,6,6,4,7,6,5,3,1,6,5,8,7,7,2,8
+F,5,11,5,8,2,0,13,5,4,13,11,7,0,8,2,5
+I,1,11,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+A,3,7,5,5,3,12,3,2,2,9,1,8,2,6,2,7
+I,2,5,1,4,1,7,7,1,7,7,6,8,0,8,3,8
+C,4,8,5,6,2,5,8,6,8,11,9,13,1,9,3,7
+G,2,1,3,2,2,7,7,5,5,6,6,10,2,9,3,9
+E,1,0,1,0,1,5,7,5,7,7,6,12,0,8,6,9
+V,4,9,5,7,3,7,10,3,2,6,11,8,2,10,3,9
+B,1,1,2,2,1,7,7,7,5,6,6,7,2,8,7,9
+I,1,5,2,4,1,7,7,0,7,13,6,8,0,8,1,8
+I,6,8,7,10,7,8,9,4,5,7,7,8,3,7,9,7
+Z,3,9,4,6,2,7,7,4,14,10,6,8,0,8,8,8
+R,6,11,5,6,3,9,7,6,4,10,3,8,6,6,5,10
+V,6,10,8,8,5,7,11,3,2,5,10,9,3,11,4,8
+W,4,3,6,5,3,7,8,4,1,7,8,8,8,9,0,8
+K,4,6,6,4,3,9,6,2,6,10,3,8,4,8,4,11
+E,5,9,7,8,8,5,6,3,3,7,6,8,5,11,10,9
+I,4,11,5,8,3,7,7,0,8,14,6,8,0,8,1,8
+L,4,10,6,7,8,8,8,3,5,5,7,10,6,12,8,8
+G,5,8,7,7,8,8,9,5,3,7,6,8,7,11,8,9
+S,4,8,5,6,3,8,7,3,7,10,4,7,2,8,5,9
+N,3,5,5,3,2,8,8,2,5,10,4,6,5,8,1,7
+M,5,9,7,4,4,6,4,3,2,8,4,10,7,3,1,8
+T,1,1,2,1,0,8,14,1,5,6,10,8,0,8,0,8
+Y,3,2,5,3,2,7,10,1,7,7,11,8,1,11,2,8
+S,2,4,3,2,1,8,8,2,7,10,5,7,1,8,4,8
+M,2,3,4,2,2,7,7,3,3,9,8,8,5,5,1,7
+T,2,7,4,5,2,7,13,0,5,7,10,8,0,8,0,8
+Y,2,1,4,2,1,7,11,1,7,7,11,8,1,11,2,8
+E,4,9,4,6,3,3,7,6,11,7,6,15,0,8,7,7
+T,6,9,7,8,7,5,8,4,8,8,8,9,3,9,8,7
+V,6,8,5,6,3,4,12,1,2,8,10,7,4,12,1,8
+G,2,0,2,1,1,8,6,6,6,6,5,9,1,7,5,10
+E,3,2,4,3,3,7,7,5,7,7,5,9,2,8,6,10
+M,7,9,10,6,8,5,7,3,5,9,9,9,10,6,3,8
+F,4,8,4,6,3,1,13,4,3,12,10,6,0,8,2,6
+G,5,10,6,8,5,6,6,6,5,9,7,12,3,8,5,9
+R,4,5,5,7,3,5,12,8,4,7,2,9,3,7,6,11
+W,4,4,5,3,3,5,11,4,2,9,8,7,6,12,2,6
+K,6,10,8,7,6,6,7,1,6,10,7,10,3,8,4,8
+T,5,9,6,7,4,6,9,0,8,10,9,5,0,9,3,4
+Y,1,1,2,1,0,7,10,2,2,7,12,8,1,11,0,8
+P,6,10,7,8,7,6,8,6,4,8,7,8,5,9,7,10
+S,2,2,2,3,2,8,7,7,5,7,6,8,2,9,8,8
+W,4,4,5,3,3,6,11,3,2,7,9,8,7,11,1,8
+X,3,7,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+R,4,3,4,4,2,6,13,8,3,7,2,9,2,6,5,10
+F,3,2,3,4,2,5,11,3,6,11,9,5,1,10,3,6
+D,1,0,2,1,0,6,7,7,6,6,6,6,2,8,3,8
+C,2,7,3,5,1,5,7,7,8,7,6,14,1,8,4,9
+F,3,4,3,5,1,1,12,5,5,11,10,8,0,8,3,6
+X,4,7,5,6,5,7,8,2,5,7,6,7,3,5,7,8
+T,2,5,3,3,2,8,12,3,6,6,11,8,2,11,1,8
+K,3,6,3,4,1,3,7,7,3,7,6,11,4,8,2,11
+Z,5,6,4,8,3,11,4,3,5,11,4,8,3,9,7,10
+G,6,9,7,7,8,9,6,5,3,7,6,10,8,8,6,10
+I,1,5,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+T,5,6,5,4,2,4,14,5,5,12,9,3,1,11,1,5
+L,4,11,5,8,3,6,4,0,9,8,2,11,0,7,2,8
+M,6,5,9,4,8,9,7,5,5,7,6,8,12,9,6,4
+S,9,15,7,8,4,9,5,5,6,9,2,9,4,5,5,9
+G,3,4,5,6,2,7,5,7,8,6,5,11,1,8,6,11
+X,9,15,8,8,4,9,7,2,9,9,5,7,4,11,4,9
+Y,2,1,4,2,1,8,11,1,7,5,11,9,1,11,2,8
+X,6,9,7,8,8,8,6,1,6,7,6,8,4,13,9,8
+I,4,9,4,4,2,8,8,2,5,13,5,5,2,9,4,9
+D,2,5,3,3,2,7,7,6,6,7,6,4,2,8,3,7
+A,3,7,5,5,3,11,2,3,2,10,2,9,2,6,3,9
+S,4,9,5,6,3,8,7,5,9,5,6,7,0,8,9,8
+N,4,9,4,6,4,8,7,12,1,6,6,7,6,8,0,9
+X,3,6,6,4,4,9,8,3,6,7,7,7,5,11,6,7
+P,4,8,6,11,10,7,9,6,0,8,6,6,7,12,8,9
+B,3,6,4,4,3,11,6,3,6,11,3,7,2,8,4,11
+V,3,4,5,6,1,8,8,4,3,7,14,8,3,9,0,8
+G,4,8,5,6,2,7,7,7,8,6,6,8,2,7,6,11
+R,5,9,7,7,7,8,6,7,3,8,6,7,6,6,7,10
+D,4,7,5,5,4,7,7,5,5,7,6,8,4,9,3,7
+J,2,4,4,3,1,8,6,3,6,14,6,10,0,7,0,7
+H,2,2,3,3,2,6,7,6,6,7,6,10,3,8,3,9
+K,6,9,9,6,6,2,8,3,8,11,12,12,4,7,4,4
+D,3,4,4,3,2,7,7,6,7,7,6,5,2,8,3,7
+B,3,5,4,7,3,6,7,9,6,7,6,7,2,8,9,10
+C,2,7,3,5,2,5,8,7,8,6,7,14,1,8,4,9
+D,4,7,4,5,4,6,7,9,7,6,5,6,2,8,3,8
+A,2,6,4,4,2,7,4,2,0,6,2,8,2,6,1,7
+O,5,9,6,6,5,7,8,8,4,7,8,8,3,7,3,8
+E,3,7,4,5,3,6,7,6,8,7,7,10,2,8,6,9
+W,5,5,7,4,4,7,11,3,2,6,9,8,8,11,0,8
+R,2,4,3,3,2,7,8,5,4,6,5,6,2,7,4,8
+V,3,5,5,4,2,9,12,3,3,5,11,9,3,10,2,9
+P,2,3,3,2,1,6,10,5,4,9,7,3,1,10,4,6
+X,4,9,5,6,1,7,7,5,4,7,6,8,3,8,4,8
+H,3,3,4,4,2,7,9,14,1,7,3,8,3,8,0,8
+J,3,6,4,4,2,6,7,3,5,14,7,11,1,6,1,7
+B,8,15,6,8,4,9,6,6,5,10,4,9,6,6,7,11
+X,2,3,3,2,1,7,7,3,9,6,6,8,2,8,5,7
+V,8,10,7,7,4,3,12,3,3,10,11,8,3,10,1,7
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+N,3,6,3,4,3,8,8,12,1,6,6,8,5,8,0,8
+S,8,13,8,7,4,8,6,4,3,13,8,9,3,10,3,9
+A,3,11,6,8,2,6,6,3,1,6,0,8,2,7,2,7
+D,9,14,8,8,6,8,5,4,7,10,5,7,6,9,7,8
+U,2,0,2,1,1,8,5,11,4,6,13,8,3,10,0,8
+F,1,3,3,2,1,5,10,2,5,13,7,5,1,9,1,8
+K,3,4,5,3,2,5,7,2,7,10,9,11,3,8,3,7
+G,3,7,4,5,5,8,7,4,1,7,6,9,6,8,6,12
+Q,3,7,4,6,2,9,8,8,5,5,8,9,3,8,5,9
+P,5,10,6,7,3,4,12,9,2,10,6,4,1,10,4,8
+S,7,15,6,9,3,7,4,4,4,7,2,7,3,6,6,8
+I,3,10,5,8,3,8,6,0,7,13,6,9,1,7,2,8
+Y,3,5,4,4,2,4,11,2,7,11,10,6,1,11,2,5
+P,7,11,10,8,7,7,11,5,4,12,5,2,1,10,3,8
+J,1,4,3,3,1,9,4,4,5,14,5,12,0,7,0,8
+E,4,5,5,4,4,6,8,4,4,8,7,10,4,10,8,11
+E,4,10,6,8,7,8,7,4,7,7,7,7,6,8,5,10
+H,3,5,6,4,4,9,6,3,6,10,4,7,3,8,3,8
+M,7,8,10,7,11,8,8,4,3,6,6,7,12,7,6,7
+U,2,0,2,1,0,7,5,11,4,7,13,8,3,10,0,8
+B,1,3,2,2,2,7,7,5,5,7,6,6,2,8,4,10
+X,3,6,5,4,4,7,8,3,5,6,6,9,3,8,8,8
+W,7,9,7,6,5,4,10,3,3,9,8,7,7,11,2,6
+R,5,5,7,4,6,7,7,4,3,8,5,8,7,8,6,6
+V,4,4,5,3,2,4,12,3,3,9,11,7,2,10,1,8
+G,3,3,4,2,2,7,7,5,6,6,6,9,2,9,4,8
+K,4,4,4,6,2,3,6,8,2,7,6,11,4,8,2,11
+E,2,4,3,3,2,7,7,5,7,7,7,9,2,8,5,9
+Z,6,8,8,10,7,11,6,4,5,9,3,7,3,6,6,8
+R,4,6,6,6,7,6,8,3,3,7,5,9,6,8,5,8
+Q,4,7,5,9,6,8,6,8,3,5,6,9,3,8,6,9
+P,2,6,3,4,3,5,10,7,2,9,6,5,1,10,2,8
+G,5,9,6,7,4,6,7,6,6,10,7,10,2,9,5,9
+E,3,6,3,4,3,3,7,5,9,7,6,13,0,8,6,9
+Q,4,8,6,10,7,8,8,8,2,5,6,11,3,8,6,10
+Y,5,7,7,9,8,10,10,5,3,6,7,8,6,11,8,5
+X,4,10,5,7,1,7,7,5,4,7,6,8,3,8,4,8
+B,1,1,1,1,1,7,7,7,5,6,6,7,1,8,6,9
+E,3,5,6,3,3,7,8,2,9,12,6,8,2,8,5,8
+L,3,4,4,7,1,0,1,6,6,0,0,6,0,8,0,8
+D,4,10,4,7,5,6,7,9,7,5,3,7,2,7,3,8
+E,5,10,7,8,6,9,7,2,7,11,5,8,3,8,5,10
+V,2,6,4,4,2,7,12,3,3,6,11,8,2,10,1,8
+W,6,5,7,4,4,3,11,2,3,10,10,8,7,11,1,7
+U,4,7,5,5,4,5,8,5,6,9,7,9,3,9,3,6
+G,5,11,7,9,3,7,6,8,9,6,6,10,1,8,6,11
+Y,2,2,4,3,1,6,10,1,6,8,11,9,1,11,2,8
+M,3,1,4,2,3,7,6,6,5,6,7,7,8,6,2,7
+M,6,10,9,8,7,7,7,2,5,9,8,8,9,7,3,8
+U,2,1,3,2,1,8,8,6,6,5,9,8,3,9,1,8
+E,4,9,6,6,6,7,7,4,7,7,6,9,6,8,5,10
+A,4,5,6,4,4,9,8,3,4,6,7,7,4,9,4,6
+P,3,9,4,6,3,4,11,8,2,10,6,4,1,10,3,8
+S,5,9,6,7,4,7,8,3,7,10,4,6,2,6,5,8
+U,4,6,5,4,2,4,8,5,6,10,9,9,3,9,2,7
+A,3,8,5,5,2,8,6,3,1,7,0,8,2,7,1,8
+X,3,4,4,3,2,7,7,3,9,6,6,9,2,8,5,8
+R,4,9,5,6,5,9,7,3,6,9,3,8,3,6,4,11
+W,3,6,5,4,2,4,8,5,1,7,8,8,8,10,0,8
+F,2,3,3,2,1,5,12,3,4,13,7,3,1,9,1,7
+J,1,3,3,2,1,8,6,3,6,14,5,10,0,7,0,7
+J,1,1,2,2,1,10,7,2,5,11,4,8,0,7,0,7
+A,2,7,4,4,1,8,4,3,1,7,1,8,2,6,2,8
+R,3,6,5,4,3,9,8,4,6,10,2,7,3,6,4,11
+X,4,8,5,6,3,7,7,4,9,6,6,8,3,8,6,8
+K,4,8,5,6,4,5,6,4,8,7,7,12,3,8,6,9
+E,4,8,6,6,4,6,8,4,8,11,9,9,2,9,5,6
+H,4,5,6,8,6,7,5,5,2,6,4,6,5,7,8,8
+U,8,10,9,8,6,3,8,5,8,9,8,10,6,9,4,3
+X,5,9,8,7,4,8,8,1,9,10,5,7,3,8,4,8
+T,6,9,8,8,9,7,8,4,9,7,6,8,3,8,8,6
+Q,4,5,5,6,5,8,5,6,3,9,6,11,3,8,5,8
+A,3,7,5,5,3,11,2,3,3,10,2,10,2,6,2,8
+Z,4,10,5,8,4,6,8,6,10,7,7,10,1,9,8,8
+V,9,13,7,7,3,7,11,5,6,8,10,5,4,11,4,7
+C,3,4,4,3,2,4,9,5,8,11,9,11,1,9,3,7
+D,3,9,5,7,5,8,7,6,6,7,6,4,3,8,3,7
+Z,3,8,4,6,3,7,8,3,11,8,6,8,0,8,7,7
+B,7,13,6,8,4,9,5,5,5,11,4,9,6,7,7,11
+Y,5,11,7,8,7,8,7,5,4,7,7,8,6,8,8,3
+C,6,10,6,8,3,3,8,5,8,10,10,14,1,7,3,7
+D,8,14,8,8,5,9,5,4,6,10,3,7,5,6,5,10
+E,5,9,7,7,5,9,6,2,8,11,5,9,3,7,5,10
+B,3,9,5,6,5,8,7,6,6,7,6,5,2,8,6,9
+R,4,9,5,7,3,6,10,9,4,7,5,8,3,8,6,11
+O,1,3,2,1,1,8,7,6,4,9,6,8,2,8,2,8
+J,4,11,5,8,4,6,7,3,5,15,7,11,1,6,1,6
+P,3,7,5,5,4,5,10,4,4,10,8,4,1,10,3,7
+R,2,1,3,2,1,6,10,8,2,7,5,8,2,7,5,10
+I,1,5,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+L,4,8,6,6,3,10,3,2,8,9,2,9,1,6,3,9
+E,3,2,3,4,3,7,7,6,7,7,6,9,2,8,6,9
+Y,1,3,2,1,1,8,10,1,6,5,10,8,1,11,1,8
+A,9,15,7,8,4,8,2,3,2,8,4,12,5,5,5,7
+Q,3,6,5,4,4,8,5,7,4,7,7,6,3,6,5,8
+Z,1,3,2,2,1,7,7,4,7,6,6,8,1,8,6,8
+B,5,10,7,8,7,7,7,8,7,6,6,6,2,8,8,10
+F,1,0,1,0,0,3,12,4,2,11,8,6,0,8,2,7
+C,6,12,4,6,2,6,9,6,8,11,8,10,2,8,5,9
+M,3,6,5,4,4,11,5,3,4,9,3,6,7,6,2,8
+W,3,3,4,1,2,5,11,3,2,9,9,7,6,11,1,6
+O,5,10,6,8,6,8,6,7,3,10,4,8,4,9,4,6
+N,5,8,5,6,4,8,7,13,1,6,6,7,6,8,1,10
+B,4,7,6,6,7,8,8,5,5,7,6,8,7,7,9,6
+Q,5,8,6,12,10,8,10,4,2,6,8,10,7,14,9,14
+U,5,10,5,7,2,7,4,15,6,7,13,8,3,9,0,8
+Y,5,8,6,6,3,4,10,2,8,11,11,6,1,11,3,4
+E,4,10,5,8,7,7,8,3,6,5,7,10,5,10,10,11
+C,5,10,6,8,2,6,7,7,10,6,6,15,1,8,4,9
+I,2,7,3,5,1,7,8,0,7,13,6,7,0,8,1,7
+U,5,8,6,6,3,4,8,6,8,9,8,9,4,10,4,3
+N,4,5,5,4,3,7,9,5,5,7,7,6,5,9,2,5
+E,5,8,7,6,4,4,9,3,9,11,9,10,2,8,4,5
+S,2,3,3,2,1,7,7,2,7,10,5,8,1,8,4,8
+K,1,0,1,0,0,4,6,5,1,7,6,10,2,7,1,10
+U,5,9,5,6,2,7,4,14,5,7,14,8,3,9,0,8
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+S,4,6,6,4,6,8,6,4,4,8,6,9,4,8,10,8
+L,2,6,3,4,1,3,3,6,8,1,1,5,0,7,1,6
+E,1,3,3,2,1,6,7,2,7,11,7,9,1,8,3,8
+Z,5,9,6,7,5,8,7,5,10,7,6,8,1,8,7,8
+L,4,4,4,6,1,0,0,6,6,0,1,5,0,8,0,8
+X,4,4,5,6,1,7,7,4,4,7,6,8,3,8,4,8
+Q,7,12,7,6,4,9,4,4,8,11,4,10,3,7,8,11
+J,2,9,2,6,2,14,4,4,4,12,1,8,0,7,0,8
+R,2,3,3,1,2,8,8,3,5,9,5,7,2,7,4,10
+A,2,3,3,2,1,10,2,2,1,8,2,9,2,5,1,9
+C,4,8,5,6,2,5,9,7,8,12,9,11,1,10,3,7
+H,8,10,11,7,7,6,7,3,7,10,8,9,3,8,3,7
+Q,2,2,3,3,2,7,9,4,2,7,8,10,2,9,4,8
+Y,5,9,5,6,3,3,10,2,6,10,12,7,2,11,2,5
+Z,1,0,2,1,0,7,7,3,11,8,6,8,0,8,6,8
+O,3,4,4,2,2,7,7,7,5,7,5,8,2,8,3,8
+V,6,9,6,7,4,3,12,2,3,9,11,8,2,10,1,8
+W,4,10,7,8,6,7,8,4,1,7,9,8,7,11,0,8
+Y,3,5,6,7,1,6,11,2,3,9,12,8,1,10,0,8
+I,3,8,4,6,2,7,7,0,9,14,6,8,0,8,1,8
+G,3,4,4,3,2,6,6,6,6,9,7,11,2,9,4,10
+L,2,3,2,2,1,4,5,2,7,3,2,8,0,7,1,6
+E,7,12,5,6,4,8,7,4,4,10,5,9,3,9,8,11
+Y,3,8,6,6,3,7,9,1,6,6,11,8,2,11,2,8
+U,8,11,8,8,4,3,9,5,7,11,12,10,3,9,2,6
+H,4,9,6,6,5,6,7,7,6,7,6,11,3,8,3,9
+G,3,2,4,4,3,6,6,6,6,6,6,10,2,9,4,9
+S,4,4,5,6,2,7,6,5,9,5,6,10,0,8,9,8
+Y,4,6,6,8,6,10,11,5,4,6,7,7,5,10,7,4
+Z,6,10,8,8,5,7,8,2,9,12,7,6,2,8,6,7
+B,5,11,7,8,7,9,6,3,7,10,4,8,3,7,5,10
+M,4,6,5,4,2,8,7,12,1,7,9,8,8,6,0,8
+N,4,7,6,5,3,9,7,3,4,10,5,6,5,8,1,7
+Y,3,4,5,5,1,8,12,2,3,6,12,8,1,10,0,8
+L,4,9,5,7,3,3,3,6,8,1,0,6,0,6,1,6
+R,4,10,5,8,3,5,9,10,5,7,5,8,3,8,6,10
+E,1,0,2,1,1,5,7,5,8,7,6,12,0,8,6,9
+A,6,9,6,4,3,11,0,4,1,11,5,13,4,5,4,11
+F,4,10,6,7,5,3,11,3,5,11,10,7,1,10,3,6
+K,8,11,11,8,9,8,6,1,6,9,5,9,7,7,6,9
+J,3,10,4,8,5,10,6,2,4,9,4,6,3,7,6,8
+Y,5,6,7,8,1,6,11,3,2,9,12,8,1,11,0,8
+L,4,8,6,6,4,7,4,1,8,8,2,9,1,6,3,8
+F,5,7,7,5,6,7,8,5,5,7,6,8,4,11,9,10
+O,5,10,7,8,5,8,7,9,4,7,6,7,3,8,4,9
+F,2,3,4,2,1,6,10,3,5,13,6,5,1,9,1,7
+B,1,0,1,1,1,7,7,7,4,6,6,7,1,8,6,9
+K,3,5,4,4,3,5,7,4,7,6,6,11,3,8,5,9
+M,6,9,8,8,11,7,7,4,4,6,6,8,11,8,5,5
+G,3,9,5,6,4,7,6,7,5,6,6,8,2,7,5,11
+O,4,6,4,4,3,6,8,7,4,10,8,8,3,8,2,7
+L,2,5,4,4,2,6,4,1,8,8,2,10,0,7,2,8
+A,3,6,4,4,3,8,2,2,2,7,2,8,2,6,2,7
+P,3,6,5,9,7,7,11,5,0,9,7,5,4,11,5,8
+F,2,4,4,3,1,5,11,3,4,13,7,4,1,9,1,7
+V,5,7,5,5,2,4,11,3,3,9,11,7,3,10,1,7
+A,4,9,6,7,6,8,7,8,4,7,6,8,3,8,8,4
+T,5,11,5,6,2,5,11,2,7,12,8,5,2,9,3,4
+B,5,10,6,7,6,9,6,3,5,7,6,7,7,8,6,9
+W,4,3,5,2,2,5,11,3,2,9,9,7,6,11,1,6
+G,1,3,2,2,1,7,6,5,4,7,6,10,2,9,3,9
+V,3,6,5,4,1,8,8,4,2,6,14,8,3,10,0,8
+U,6,10,5,5,3,7,5,4,5,3,8,6,5,7,2,7
+C,4,8,5,6,3,6,7,6,7,12,8,11,2,10,4,7
+H,3,3,5,2,2,8,6,3,6,10,5,8,3,8,3,8
+T,4,10,6,7,4,9,11,2,8,5,12,8,1,11,1,9
+E,5,7,7,5,4,10,6,2,8,11,4,8,2,8,5,12
+O,6,10,8,8,10,8,7,6,1,7,6,8,9,10,6,11
+R,4,8,6,6,7,5,6,4,4,7,6,9,8,11,7,6
+N,6,11,8,8,5,9,7,3,5,10,4,6,6,8,1,7
+N,11,14,9,8,4,10,12,6,4,4,6,10,5,11,2,5
+S,5,8,7,7,9,7,8,5,5,7,7,7,5,10,10,11
+F,3,8,4,6,2,1,14,5,3,12,9,5,0,8,2,6
+Z,3,7,4,5,3,7,7,3,12,8,6,8,0,8,7,8
+N,7,9,8,4,3,5,9,3,4,13,9,9,5,8,0,8
+J,2,4,4,3,1,9,6,2,6,14,5,10,0,7,0,7
+W,3,4,4,3,2,7,11,2,2,6,9,8,6,11,0,8
+L,4,10,4,7,2,0,2,4,6,1,0,8,0,8,0,8
+C,9,14,7,8,5,8,6,5,3,9,8,10,6,8,9,10
+U,3,4,4,3,2,5,8,5,7,10,9,9,3,9,2,6
+K,6,10,8,8,8,6,9,6,5,8,5,8,4,7,6,11
+Z,4,11,6,8,7,8,7,3,9,7,6,7,1,7,11,9
+D,4,4,5,6,3,5,6,10,9,5,5,5,3,8,4,8
+H,5,10,7,8,7,6,8,5,5,7,6,7,6,7,6,11
+V,2,8,4,6,1,9,8,4,2,6,13,8,3,10,0,8
+R,4,4,5,6,3,6,9,10,5,6,5,8,3,8,5,10
+L,4,11,5,8,3,6,4,3,8,6,1,8,1,6,3,7
+A,3,6,5,4,3,8,2,2,2,7,2,8,2,6,2,7
+M,4,7,5,5,3,8,7,12,1,6,9,8,8,6,0,8
+H,3,3,4,2,2,7,7,6,6,7,6,8,3,8,3,8
+A,2,1,4,2,1,7,2,2,2,6,2,8,2,6,2,7
+R,4,8,6,6,4,9,7,3,6,10,3,6,3,7,4,10
+C,3,5,4,3,2,6,8,7,8,8,8,13,1,9,4,10
+B,3,2,4,4,4,7,7,5,5,6,6,6,2,8,6,9
+U,3,6,4,4,3,7,5,12,4,7,11,8,3,9,0,8
+D,6,7,8,6,6,6,7,5,6,4,3,6,3,8,5,6
+H,3,8,4,6,3,8,7,13,1,7,6,8,3,8,0,8
+U,3,3,4,2,2,5,8,5,7,10,9,9,3,9,2,6
+D,4,9,6,6,6,8,8,5,5,10,5,5,3,8,3,8
+L,3,6,3,4,2,0,2,4,5,1,1,7,0,8,0,8
+D,5,4,5,6,3,5,7,10,9,7,6,5,3,8,4,8
+G,7,9,9,8,10,7,8,6,3,7,7,8,9,11,8,9
+E,3,8,4,6,5,6,7,3,6,8,7,10,4,10,8,10
+B,6,10,9,7,7,11,6,2,7,11,3,8,4,7,5,12
+F,4,8,5,6,3,7,10,4,5,13,7,5,2,9,2,7
+U,4,4,5,3,2,4,8,5,8,10,9,9,3,9,2,5
+U,9,11,10,8,5,3,9,6,8,11,11,9,3,9,2,6
+I,4,11,5,8,3,8,6,0,7,13,6,9,2,7,3,8
+O,4,7,4,5,3,8,7,8,5,10,6,8,3,8,3,8
+D,4,6,6,4,4,8,8,5,5,9,5,4,4,8,4,8
+N,4,9,6,7,4,7,8,6,5,7,6,6,6,9,2,5
+E,2,6,4,4,3,7,8,6,8,6,5,9,2,8,6,9
+I,4,8,5,6,3,7,6,2,7,7,7,8,3,8,4,8
+N,4,8,6,6,5,7,6,8,5,6,4,7,3,7,3,8
+X,4,10,6,8,6,6,7,3,6,7,7,11,5,6,7,7
+F,8,11,7,6,5,7,12,3,4,12,6,3,4,10,8,5
+G,4,8,5,6,2,8,6,8,8,6,6,9,2,7,6,10
+Y,10,9,8,13,5,8,9,3,3,6,11,5,4,10,7,7
+X,4,8,6,6,3,7,8,0,7,9,7,8,2,8,3,7
+Q,4,7,5,9,6,10,10,6,3,3,8,12,3,9,7,10
+T,2,3,3,4,1,8,14,0,6,6,11,8,0,8,0,8
+B,4,6,5,4,4,9,7,3,6,10,4,6,2,8,5,10
+B,2,1,2,2,2,7,8,8,5,7,6,7,2,8,8,9
+G,5,10,7,7,6,6,6,7,5,5,6,10,2,8,4,8
+V,3,7,5,5,1,8,8,4,2,7,14,8,3,10,0,8
+P,7,9,6,4,3,5,12,6,1,11,5,4,4,10,4,8
+Y,4,4,6,6,6,10,9,5,3,7,7,7,5,10,6,5
+N,4,10,6,7,5,6,10,5,3,7,7,9,5,9,1,8
+V,3,8,5,6,6,6,6,5,2,8,8,9,5,9,5,8
+X,5,8,6,7,7,6,8,2,5,8,7,10,2,8,7,8
+A,4,6,7,8,2,8,6,3,1,7,0,8,3,7,2,8
+F,5,11,5,8,4,1,12,4,4,11,10,8,0,8,2,6
+S,4,10,5,8,4,8,7,8,6,8,5,7,2,8,9,8
+X,4,5,5,7,1,7,7,5,4,7,6,8,3,8,4,8
+U,3,8,5,6,8,7,6,4,3,7,7,8,7,10,5,6
+B,4,9,6,6,6,7,8,6,4,6,4,6,4,8,6,7
+K,8,15,8,8,6,6,7,2,6,10,4,9,5,5,3,7
+B,5,9,8,7,6,8,7,5,6,9,5,6,3,8,7,10
+V,3,3,4,2,1,5,13,4,3,10,11,6,2,10,1,8
+S,4,7,6,5,3,9,7,5,8,11,2,8,2,6,4,11
+M,5,7,8,5,6,3,7,4,5,11,11,10,5,8,2,6
+V,3,4,5,6,1,7,8,4,3,7,14,8,3,9,0,8
+Q,2,2,3,3,2,8,6,6,3,6,6,9,2,9,3,8
+B,5,9,8,8,9,7,8,5,4,8,6,8,7,9,8,8
+B,4,10,4,8,4,6,6,10,7,6,6,7,2,8,9,10
+F,3,4,5,3,2,6,10,2,6,13,6,5,1,9,3,7
+B,8,9,6,5,3,9,7,6,6,10,4,9,6,6,6,10
+N,1,0,2,1,0,7,7,11,0,5,6,8,4,8,0,8
+B,1,3,2,2,2,8,6,2,4,10,5,7,2,8,2,9
+S,7,11,7,6,3,8,6,4,4,13,6,9,3,8,3,8
+U,8,10,8,8,5,4,8,5,9,11,10,9,3,9,2,6
+Z,2,4,4,3,1,7,8,2,9,11,7,7,1,8,5,6
+K,4,9,5,7,4,3,8,7,3,7,5,11,3,8,2,11
+E,3,3,4,5,2,3,7,6,11,7,6,15,0,8,7,7
+E,6,9,8,8,10,6,7,4,3,7,6,9,7,11,11,12
+P,5,10,7,8,4,10,7,4,6,12,3,4,2,9,3,9
+Y,2,3,3,2,1,6,10,1,6,8,11,8,1,11,2,8
+O,6,10,8,8,5,8,10,9,6,8,8,5,5,8,5,9
+C,6,11,7,8,9,7,5,4,4,8,7,11,6,10,5,8
+G,4,10,5,7,4,5,6,6,5,9,8,11,2,9,4,10
+F,6,9,8,10,8,6,10,4,4,9,7,6,5,8,9,8
+A,4,11,7,8,5,12,2,2,2,10,2,9,2,6,3,8
+O,4,6,4,4,3,7,7,7,4,10,7,8,3,8,3,8
+Q,6,8,6,9,7,7,8,6,3,8,8,10,3,9,6,7
+Q,2,1,3,2,1,8,6,7,5,6,6,8,3,8,4,8
+I,1,3,0,2,0,7,7,1,7,7,6,8,0,8,2,8
+Y,3,5,4,3,2,4,11,2,7,11,10,6,1,11,2,5
+N,5,7,7,5,3,7,7,3,4,10,7,8,5,8,0,7
+W,3,4,5,3,3,9,11,3,2,5,9,7,6,10,0,8
+I,6,10,5,6,3,7,10,3,4,12,5,4,2,9,6,9
+A,6,9,5,4,2,11,3,3,1,9,3,10,4,5,4,10
+C,4,9,6,7,4,7,8,8,6,6,6,9,4,7,4,8
+Q,6,12,5,7,4,12,4,4,5,11,2,7,4,9,5,13
+A,1,1,2,1,0,7,4,2,0,7,2,8,2,7,1,8
+U,4,8,5,6,3,4,9,5,6,9,8,9,3,9,2,6
+W,5,5,7,7,4,8,8,5,2,7,8,8,9,9,0,8
+K,2,3,3,2,2,6,7,1,6,10,7,10,3,8,1,8
+M,4,9,5,6,3,7,7,12,1,7,9,8,8,6,0,8
+X,2,4,4,3,2,10,6,2,8,10,3,7,2,8,3,9
+O,5,9,6,7,4,8,7,8,5,7,6,8,3,8,3,8
+W,3,4,4,3,3,4,10,4,2,9,8,7,5,11,1,6
+E,2,5,4,3,2,6,8,2,7,11,7,9,2,8,4,8
+E,2,3,2,2,1,7,7,5,7,7,5,8,2,8,5,10
+F,2,4,3,3,2,5,10,4,5,10,9,5,2,9,3,6
+Y,3,8,5,5,1,6,12,2,3,9,12,7,1,10,0,8
+V,8,13,7,7,4,5,10,4,5,9,9,5,4,10,2,8
+J,4,10,4,8,3,15,3,3,5,12,0,7,0,8,0,8
+X,3,3,5,2,2,5,9,2,7,10,9,8,2,8,3,6
+W,5,7,7,6,9,7,6,4,5,7,5,8,9,9,7,8
+X,2,3,3,2,2,7,7,3,9,6,6,8,2,8,6,8
+D,5,10,5,6,4,6,8,4,6,9,6,6,5,9,6,5
+G,5,11,6,8,5,6,6,6,6,10,6,13,3,8,4,9
+T,8,12,8,7,4,7,8,2,7,12,7,7,3,9,5,6
+B,2,3,3,1,2,7,7,4,5,7,6,6,1,8,5,9
+N,6,7,8,5,4,4,11,3,4,10,10,9,5,8,1,8
+Q,5,13,5,8,4,8,6,5,7,11,5,7,3,8,9,9
+A,6,10,5,5,3,12,5,4,1,8,3,9,5,6,4,10
+F,8,10,7,5,3,6,10,3,7,11,7,6,2,9,5,6
+I,2,8,3,6,2,7,7,0,6,12,6,8,0,8,1,8
+B,3,3,3,4,3,7,7,9,6,7,6,7,2,8,9,10
+Q,2,3,3,3,2,9,10,5,2,5,7,10,3,9,5,10
+J,0,0,1,0,0,12,4,4,3,11,4,10,0,7,0,8
+Y,9,14,8,8,5,4,9,4,3,11,10,6,4,11,4,5
+C,4,7,6,5,6,6,6,4,4,8,6,11,6,9,3,9
+X,5,10,8,8,7,8,6,3,6,7,4,6,6,7,9,6
+G,4,7,6,5,4,6,6,6,5,6,6,11,2,9,4,9
+K,4,9,5,6,2,3,7,8,2,7,6,11,4,8,2,11
+C,4,9,5,6,2,6,8,7,11,5,6,13,1,7,4,9
+F,1,0,2,0,0,3,12,5,2,11,8,6,0,8,2,7
+S,5,11,7,9,5,8,7,3,6,10,7,8,2,8,5,8
+R,5,9,5,4,4,9,7,4,6,10,2,6,5,5,5,6
+R,4,11,4,8,3,6,9,10,5,7,6,8,3,8,6,11
+K,3,9,4,6,2,3,7,7,2,7,6,11,3,8,3,10
+R,2,6,2,4,2,6,8,8,4,7,5,7,2,7,4,10
+E,4,8,6,6,6,8,10,6,4,6,6,9,4,6,7,9
+N,5,9,7,6,7,6,8,3,4,8,7,8,6,9,5,4
+Z,3,7,4,5,2,7,8,2,10,11,7,8,1,9,6,7
+D,4,5,5,4,4,7,7,7,7,7,6,5,2,8,3,7
+P,2,4,3,2,2,5,10,4,4,10,8,4,1,10,3,7
+E,5,6,6,6,6,7,8,5,4,8,7,10,6,10,8,11
+Z,4,9,5,7,2,7,7,4,15,9,6,8,0,8,8,8
+R,3,8,3,6,3,6,9,8,3,7,5,8,2,7,5,11
+X,2,1,2,1,0,7,7,4,4,7,6,8,2,8,4,8
+N,8,13,10,8,5,5,8,2,4,12,7,9,6,8,0,7
+S,3,10,4,8,2,9,8,6,10,5,5,5,0,7,9,7
+W,7,11,7,8,8,4,10,2,3,9,8,7,7,11,2,6
+Q,4,6,5,7,5,9,7,7,3,5,7,9,3,9,6,9
+Y,2,2,3,3,1,7,10,1,7,7,11,8,1,11,2,8
+C,2,4,3,2,1,4,9,4,7,12,10,10,1,9,2,7
+J,2,8,2,6,1,12,3,9,4,13,4,12,1,6,0,8
+M,3,7,4,5,5,8,7,6,3,7,5,8,5,9,5,8
+L,3,8,4,6,2,9,3,1,7,9,2,10,0,7,3,9
+U,5,10,5,7,2,8,5,13,5,6,15,8,3,9,0,8
+S,4,5,5,7,3,9,9,6,10,5,5,5,0,7,9,8
+A,3,5,5,8,2,7,6,3,1,6,0,8,2,7,1,8
+F,8,10,7,6,5,6,12,3,4,11,6,3,4,10,7,6
+G,6,10,8,8,5,6,6,7,8,6,5,10,2,9,4,8
+B,5,8,8,6,5,9,7,4,7,10,5,6,2,8,6,10
+U,6,10,6,8,4,4,8,5,7,10,9,9,3,9,2,6
+D,6,9,8,6,6,7,7,8,5,7,6,5,4,8,4,7
+F,8,13,7,7,4,5,9,2,7,11,7,6,2,10,5,5
+H,4,5,6,7,5,9,10,3,2,8,7,7,3,10,8,6
+P,6,9,8,7,4,9,9,3,6,14,4,3,1,10,3,9
+E,7,9,5,5,2,7,7,5,7,10,6,9,1,9,7,9
+H,3,6,4,4,2,7,7,14,1,7,6,8,3,8,0,8
+L,5,9,5,7,1,0,0,7,6,0,1,4,0,8,0,8
+X,4,8,6,6,4,9,6,1,8,10,3,7,3,9,4,9
+D,2,3,3,2,2,7,7,6,6,7,6,5,2,8,3,7
+Z,5,10,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+F,3,2,4,4,3,4,11,3,6,11,10,5,1,10,3,6
+X,7,11,6,6,3,5,8,3,9,10,9,10,4,7,4,5
+O,4,7,4,5,3,7,7,7,4,9,7,10,3,8,3,9
+T,6,11,5,6,2,5,10,3,7,13,7,5,2,8,4,4
+W,10,10,10,5,4,8,10,4,2,5,10,7,10,12,2,6
+G,1,0,2,0,1,8,7,5,5,6,6,9,1,8,5,10
+Z,3,10,4,8,5,6,8,5,9,7,7,9,2,9,7,8
+L,1,3,2,2,1,7,4,2,7,7,2,9,0,7,2,8
+I,5,8,6,6,4,7,6,2,7,7,6,8,0,9,4,8
+Q,6,7,6,9,7,8,5,6,3,9,5,11,5,7,7,5
+M,8,10,8,6,5,4,9,5,4,4,3,12,9,10,2,8
+Z,1,4,2,3,2,8,7,5,8,6,6,7,2,8,7,8
+O,9,14,6,8,5,5,7,7,4,10,7,10,5,10,5,8
+B,4,6,5,4,4,7,9,5,6,10,6,6,2,8,6,8
+J,1,3,2,2,1,10,6,2,6,12,4,8,0,7,1,7
+J,2,7,3,5,1,14,2,6,5,14,2,11,0,7,0,8
+C,5,10,6,7,3,5,9,7,8,6,8,14,1,7,4,9
+U,3,7,3,5,3,7,7,11,4,7,11,8,3,9,0,8
+B,4,2,4,4,4,7,7,5,5,6,6,6,2,8,7,11
+N,6,11,9,8,5,3,10,3,4,10,11,10,5,7,1,7
+X,3,6,4,4,2,7,7,4,4,7,6,8,3,8,4,8
+J,2,7,2,5,1,14,2,6,5,14,1,10,0,7,0,8
+N,4,4,5,6,2,7,7,14,2,4,6,8,6,8,0,8
+F,3,7,4,5,3,8,9,2,6,13,5,5,1,10,2,9
+R,4,10,5,7,3,5,11,8,4,7,4,8,3,7,7,11
+W,1,0,2,1,1,7,8,4,0,7,8,8,5,10,0,8
+K,6,8,9,6,4,3,9,3,7,11,11,11,4,7,3,6
+F,3,6,5,4,3,5,10,2,6,10,9,6,4,10,3,6
+T,5,11,7,9,5,7,12,3,7,8,12,8,2,12,1,7
+L,6,14,6,8,4,10,3,4,3,12,6,10,4,9,6,9
+H,3,7,6,5,3,4,8,3,6,10,10,9,3,8,3,6
+P,3,3,5,2,2,7,10,3,4,12,4,3,1,10,3,8
+G,9,13,7,7,5,9,6,5,4,9,5,7,3,9,8,9
+F,4,9,6,6,5,8,8,2,6,12,5,6,3,8,3,8
+B,2,3,3,2,2,7,7,5,5,7,6,6,2,8,5,9
+O,5,9,6,6,5,7,8,7,6,7,6,6,2,8,3,8
+N,10,15,12,8,5,10,6,4,4,13,2,7,7,7,0,6
+C,4,10,5,8,4,6,7,6,8,5,7,12,1,7,4,9
+P,2,4,4,3,2,8,9,3,4,12,4,4,4,10,4,8
+F,5,9,7,6,7,7,6,6,4,7,6,8,4,10,8,11
+K,3,9,4,6,2,3,7,7,2,7,7,11,4,8,3,10
+G,3,8,4,6,2,7,6,7,8,6,6,8,1,8,6,11
+A,2,4,4,3,2,8,2,2,1,7,2,8,2,7,3,6
+X,7,11,7,6,3,4,8,3,9,9,11,10,4,11,4,5
+O,1,0,1,0,0,7,7,6,4,7,6,8,2,8,3,8
+Q,5,8,6,9,6,8,6,7,3,9,7,10,3,8,6,7
+N,5,5,6,4,5,7,9,5,4,7,4,8,6,9,4,6
+J,4,11,5,8,3,7,8,2,6,14,5,8,1,8,1,8
+C,7,11,7,8,5,6,6,6,7,13,8,13,4,9,4,6
+S,4,8,6,6,8,8,8,3,3,7,6,7,3,7,13,4
+G,6,11,7,8,6,6,6,6,5,5,6,10,2,9,4,8
+T,4,8,5,6,4,6,11,2,7,11,9,5,2,11,3,4
+J,4,10,6,7,3,7,6,3,5,15,7,11,1,6,1,7
+K,5,6,7,4,5,6,7,1,6,10,7,10,3,8,3,8
+Q,4,7,4,9,4,7,7,6,3,8,8,10,3,9,6,8
+B,5,10,5,8,4,6,9,9,8,7,5,7,2,8,9,10
+D,5,9,5,4,3,8,7,3,6,10,5,7,5,8,7,6
+U,6,7,6,5,3,3,8,5,7,10,10,9,3,9,2,6
+S,3,7,4,5,2,7,5,6,9,4,6,9,0,9,9,8
+X,3,9,4,7,3,7,7,4,4,7,6,8,2,8,4,8
+W,5,7,5,5,4,6,10,4,3,8,7,6,6,12,3,6
+Z,9,10,7,14,6,8,7,4,2,12,6,8,3,9,13,6
+D,2,3,4,2,2,9,7,4,6,10,4,6,2,8,3,8
+H,2,1,3,2,2,6,8,6,5,7,6,8,3,8,3,8
+K,1,1,2,1,0,4,6,6,2,7,6,11,3,8,2,10
+P,2,5,4,3,2,7,10,3,4,12,5,3,1,10,2,8
+U,6,10,6,8,3,7,3,15,6,7,13,8,3,9,0,8
+W,7,8,9,7,11,7,8,5,5,6,5,8,10,10,9,7
+Q,4,7,6,7,3,9,6,8,7,7,5,10,3,8,4,8
+G,3,9,4,7,2,7,6,8,7,6,6,10,2,7,5,10
+I,6,10,6,6,3,8,8,3,5,13,4,5,2,9,5,11
+I,1,6,3,4,3,8,7,2,4,8,5,5,3,9,4,5
+Y,5,7,5,5,2,3,10,2,7,11,11,6,1,11,2,5
+G,5,10,6,7,4,6,7,7,7,9,8,11,2,8,5,9
+K,2,4,4,3,2,7,7,1,7,10,5,9,3,8,3,8
+A,2,1,4,2,1,9,2,2,1,8,2,8,2,6,2,7
+C,4,9,4,4,3,7,7,4,3,9,8,10,3,9,8,10
+W,9,11,9,6,5,1,10,3,4,11,12,9,8,11,1,5
+Q,5,10,7,9,4,9,9,8,6,5,9,9,3,7,5,9
+X,4,7,6,5,5,7,8,2,6,7,6,8,4,8,5,8
+K,4,5,5,4,5,8,7,2,4,8,3,8,4,4,3,9
+G,4,8,6,7,6,7,8,5,3,7,6,9,6,11,8,10
+I,1,2,1,3,1,7,7,1,7,7,6,8,0,8,2,8
+T,3,4,3,3,1,5,12,3,6,11,9,4,1,11,2,5
+X,5,5,6,7,2,7,7,5,4,7,6,8,3,8,4,8
+J,2,8,3,6,2,12,3,7,3,13,5,11,1,6,0,8
+Z,4,9,6,6,4,7,8,2,10,12,7,8,1,9,6,8
+O,6,10,8,8,5,7,7,8,4,6,6,11,5,8,5,6
+E,3,8,4,6,2,3,7,6,11,7,6,15,0,8,7,7
+N,4,7,6,5,4,12,7,3,5,10,0,4,5,9,1,7
+K,8,12,7,7,3,7,7,3,6,9,6,8,6,8,4,7
+Z,4,8,6,6,6,8,8,3,8,7,7,7,1,8,9,8
+C,3,4,5,7,2,5,8,7,10,6,7,12,1,7,4,8
+O,4,4,6,6,2,8,7,8,8,7,6,9,3,8,4,8
+Y,3,5,5,8,6,7,11,3,3,7,8,9,3,11,7,5
+R,6,10,9,7,8,9,8,6,6,8,5,7,5,9,6,12
+T,4,6,5,4,2,5,11,2,8,11,9,5,1,11,2,4
+Y,3,9,4,7,2,6,11,0,4,8,11,8,0,10,0,8
+W,8,11,8,8,7,6,10,4,3,8,7,6,11,12,4,4
+C,2,4,3,3,1,4,8,4,7,10,9,13,1,8,2,7
+G,6,10,8,8,8,9,8,6,3,5,7,10,9,8,5,9
+P,3,7,4,4,2,4,13,8,1,11,6,3,1,10,4,8
+D,6,10,8,8,6,7,7,5,6,7,6,8,7,7,3,8
+C,5,5,6,7,2,5,7,6,11,7,6,14,1,8,4,9
+V,3,8,5,6,2,6,9,4,1,8,12,8,2,10,0,8
+J,3,10,4,8,3,13,3,7,4,13,3,10,1,6,0,8
+M,5,9,8,6,10,7,7,3,2,7,4,8,15,6,3,7
+M,7,9,10,7,8,12,5,3,5,9,2,5,10,5,2,8
+A,2,4,4,3,2,11,2,2,2,9,2,9,2,6,1,8
+I,2,9,2,7,2,7,7,0,8,7,6,8,0,8,3,8
+K,2,3,4,2,2,6,7,2,6,10,7,10,3,8,2,8
+A,3,8,5,6,3,10,3,2,3,9,1,8,2,6,2,8
+Q,5,5,6,8,3,8,6,8,8,5,5,8,3,8,4,8
+Y,2,3,4,4,2,7,10,1,7,7,11,8,1,11,2,8
+X,1,0,2,0,0,7,7,4,4,7,6,8,2,8,4,8
+O,2,1,2,2,1,7,7,7,4,7,6,8,2,8,3,8
+C,5,11,6,8,2,5,7,7,11,7,6,13,1,9,4,8
+P,6,9,8,6,4,9,9,4,6,13,4,2,1,10,4,9
+Z,3,4,5,3,2,7,8,2,9,11,6,8,1,9,5,8
+L,3,5,4,4,3,7,8,4,6,7,6,8,2,8,7,10
+E,3,6,4,5,4,5,8,4,3,7,6,9,4,10,8,11
+K,5,4,5,6,2,4,9,8,2,7,4,11,4,8,3,10
+V,4,8,6,6,7,8,5,5,2,8,8,8,7,9,4,8
+D,4,10,6,7,4,11,6,3,7,11,3,7,4,7,4,9
+Q,4,5,5,7,3,8,7,8,6,6,7,9,3,8,5,9
+I,1,7,2,5,1,7,7,0,7,13,6,8,0,8,1,8
+W,12,14,12,8,5,1,10,4,2,11,12,9,8,10,0,7
+H,4,8,5,6,4,7,8,8,4,7,5,6,3,6,7,9
+N,5,10,5,8,3,7,7,15,2,4,6,8,6,8,0,8
+I,3,6,4,4,2,6,9,0,6,13,7,7,0,8,1,7
+I,1,6,3,4,3,10,6,1,4,8,5,5,3,8,5,6
+R,5,11,5,8,6,6,8,9,5,7,6,8,3,8,5,12
+K,5,9,5,4,3,6,7,2,5,10,6,9,5,8,3,7
+A,1,0,2,0,0,8,3,2,0,7,2,8,2,6,1,8
+Z,3,5,5,8,4,12,4,2,5,9,3,7,1,8,5,10
+V,6,10,5,8,3,4,11,2,4,9,11,7,3,9,1,8
+Z,2,5,4,4,2,7,7,2,10,11,6,8,1,8,6,7
+H,3,6,4,4,4,7,7,5,6,7,6,9,3,8,3,8
+C,3,6,4,4,1,5,7,7,10,6,6,13,1,8,4,8
+M,3,6,5,4,5,10,5,2,2,8,4,8,5,7,2,6
+B,3,7,5,5,5,7,8,7,5,7,6,6,2,8,6,9
+R,5,9,7,7,8,5,8,4,5,6,5,9,7,6,10,7
+N,6,9,5,4,2,6,9,4,5,4,4,10,5,10,2,8
+T,4,5,5,4,2,5,12,3,8,11,9,4,1,11,2,4
+K,7,12,7,6,3,5,8,3,7,9,9,10,6,8,3,7
+F,4,11,7,8,8,9,7,1,5,9,5,5,5,10,6,5
+O,5,10,7,8,3,8,7,8,8,7,6,9,3,8,4,8
+A,2,1,3,1,1,7,4,2,0,7,2,8,2,7,1,7
+L,1,0,2,1,0,2,1,6,5,0,2,4,0,8,0,8
+K,4,8,6,6,4,6,7,2,6,10,7,10,3,8,3,8
+D,3,4,4,3,3,6,7,6,6,7,6,5,2,8,3,7
+O,6,11,6,8,7,8,6,8,4,9,4,8,3,8,3,8
+M,2,1,3,2,1,8,6,10,1,6,9,8,7,5,0,8
+P,4,10,5,8,4,4,12,6,5,12,9,3,1,10,4,6
+I,6,7,8,8,7,8,8,4,5,6,6,7,3,8,10,10
+B,4,8,6,6,5,7,7,6,6,9,6,6,3,8,7,8
+V,2,1,4,2,1,5,12,3,3,9,11,8,2,11,1,8
+K,2,3,3,1,2,6,7,4,7,7,6,11,3,8,4,9
+D,3,2,4,3,2,8,7,7,7,7,6,4,2,8,3,7
+R,3,6,5,4,5,7,8,3,4,6,6,9,6,9,7,6
+U,2,0,2,0,0,7,5,10,4,7,13,8,3,10,0,8
+R,4,5,6,4,3,9,7,2,6,10,3,6,2,7,3,10
+H,4,5,5,3,4,7,8,6,6,7,6,8,3,8,3,7
+A,4,9,6,6,5,10,3,1,2,7,3,9,5,5,3,7
+B,2,4,3,2,2,8,8,3,5,10,5,6,2,8,5,9
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+V,4,4,5,3,2,5,12,2,3,8,10,7,2,10,1,8
+U,2,3,3,1,1,6,9,5,6,6,9,9,3,10,1,7
+H,4,9,5,6,2,7,9,15,2,7,3,8,3,8,0,8
+V,6,7,6,5,3,4,12,3,3,9,11,7,3,9,1,7
+A,2,4,4,3,2,7,2,2,2,7,2,8,2,6,3,7
+F,3,5,5,4,2,7,9,2,6,13,6,5,4,10,3,7
+Z,3,6,4,4,3,6,8,5,10,7,7,10,1,9,7,8
+M,3,5,6,4,4,9,6,2,4,9,4,6,8,5,2,8
+S,5,10,6,7,4,7,8,3,7,10,7,7,3,7,5,6
+E,3,6,4,4,4,8,7,5,3,7,6,9,4,8,7,9
+L,5,9,5,5,3,7,5,3,5,12,7,11,3,8,6,9
+Q,3,9,5,8,3,8,7,8,5,6,6,9,3,8,5,9
+V,3,8,5,6,2,5,11,3,4,10,12,8,3,10,1,8
+B,4,10,6,7,5,11,6,3,8,10,3,7,2,8,5,12
+M,3,4,5,3,3,8,6,3,4,9,6,8,6,5,2,8
+F,4,7,6,5,3,7,10,3,5,13,6,5,2,10,2,7
+W,4,9,6,7,9,8,7,5,1,7,6,8,10,11,3,9
+S,3,7,4,5,3,8,7,7,6,7,7,8,2,9,9,8
+N,5,7,8,5,4,11,7,3,5,11,0,4,5,9,1,7
+J,2,8,3,6,1,12,2,9,4,13,5,13,1,6,0,8
+E,6,14,5,8,4,8,7,4,4,11,5,9,3,9,8,11
+J,4,9,4,7,3,9,8,2,3,12,5,6,2,9,6,9
+X,3,6,4,4,2,7,7,4,4,7,6,8,3,8,4,8
+W,3,3,4,1,2,3,11,3,2,10,10,8,5,11,0,7
+Y,5,10,8,7,4,8,10,1,8,5,12,8,1,11,2,8
+J,1,5,2,3,1,10,6,3,5,12,4,9,1,6,1,7
+S,3,9,4,7,2,8,8,6,9,5,5,5,0,7,9,8
+A,4,9,6,7,5,8,2,3,1,7,2,8,5,8,6,7
+V,9,13,9,7,4,6,10,4,3,8,8,5,5,12,3,9
+O,5,11,6,8,3,7,7,9,8,7,6,8,3,8,4,8
+H,5,9,6,7,6,6,8,7,5,7,5,7,3,7,7,10
+L,3,8,4,6,2,7,3,0,9,9,2,11,0,7,2,8
+P,4,6,4,8,3,4,11,10,3,10,6,4,1,10,4,8
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+Q,4,7,5,9,5,9,10,7,1,3,7,12,3,10,5,11
+Q,8,9,10,8,9,8,4,4,4,8,4,11,6,6,8,7
+D,5,10,5,5,3,7,7,4,6,9,6,6,5,9,7,5
+V,4,9,5,7,4,9,11,2,3,4,10,8,3,10,2,8
+N,4,10,4,8,5,8,7,12,1,6,6,7,6,8,1,10
+K,4,11,4,8,2,4,7,8,2,6,4,11,4,8,2,11
+S,4,8,4,6,2,7,6,5,9,5,6,9,0,8,9,8
+H,4,7,6,5,5,7,8,5,6,8,6,8,6,7,5,9
+I,4,8,5,6,3,7,6,2,6,7,6,8,0,9,4,8
+Q,4,7,6,9,6,9,8,6,3,4,8,10,4,8,7,11
+J,2,6,3,4,1,9,7,1,6,14,4,8,0,7,0,8
+R,4,5,5,4,3,8,7,5,6,6,5,6,3,7,6,9
+R,2,1,3,1,2,7,7,4,5,6,5,7,2,6,4,8
+I,2,6,3,4,1,7,7,0,7,13,6,8,0,8,1,8
+Q,4,7,5,9,5,7,10,3,4,7,10,11,3,9,7,7
+R,2,1,3,2,2,7,8,4,5,7,5,6,5,6,4,8
+R,4,7,6,5,5,8,7,7,6,8,6,8,3,8,6,11
+Y,2,3,2,2,1,5,10,1,6,10,9,6,1,11,2,5
+T,5,7,5,5,3,6,11,2,6,11,9,5,2,11,2,5
+V,3,8,5,6,1,6,8,4,3,8,14,8,3,10,0,8
+D,4,8,4,6,4,5,7,9,6,6,5,5,2,8,3,8
+W,3,1,5,1,2,6,11,3,2,7,9,9,6,11,0,8
+M,5,9,7,6,6,4,7,3,4,10,10,10,7,5,2,7
+X,3,6,5,4,3,8,7,4,9,6,6,8,3,8,6,8
+M,5,11,9,8,12,7,5,3,2,7,5,8,14,6,4,7
+I,6,10,5,6,3,10,6,4,6,14,3,6,2,9,4,11
+Z,5,8,7,6,6,9,9,5,4,7,5,7,3,8,9,5
+R,7,11,9,8,9,8,9,7,4,8,5,6,5,8,8,12
+C,2,3,3,4,1,5,7,6,8,7,6,13,1,8,4,9
+E,5,10,4,5,3,9,6,3,4,11,5,9,3,9,8,12
+G,7,14,6,8,5,7,6,3,3,8,6,9,4,9,9,7
+R,4,7,6,5,6,8,8,7,3,8,5,6,4,7,7,9
+Y,7,9,8,7,4,2,10,3,7,12,12,7,1,11,2,5
+N,4,7,6,5,3,8,7,7,6,6,6,4,6,9,2,5
+H,2,1,3,3,2,8,7,6,6,7,6,8,3,8,3,7
+N,2,2,3,3,2,7,8,5,5,7,6,6,5,9,2,5
+N,4,7,6,5,4,11,7,3,5,10,1,4,5,9,1,7
+A,4,11,6,8,3,7,4,3,2,6,1,8,3,6,3,8
+E,3,9,5,6,4,7,7,6,9,8,8,9,3,8,6,8
+E,4,9,5,7,6,6,7,5,8,7,6,10,3,8,6,9
+T,5,10,5,8,4,6,11,4,6,11,9,5,4,11,4,4
+T,6,13,6,7,4,7,9,2,7,12,6,6,2,9,5,5
+S,10,15,8,8,4,9,3,4,5,10,2,9,4,5,6,10
+T,6,8,8,7,7,6,8,6,6,7,8,7,4,11,9,8
+O,5,10,5,8,4,7,7,8,5,9,8,8,3,8,3,8
+D,4,7,6,5,4,9,7,5,7,10,4,5,3,8,3,8
+Y,4,9,6,6,4,10,10,1,7,3,11,8,1,11,2,9
+G,6,10,8,8,8,7,9,6,3,6,5,10,5,7,8,7
+I,1,8,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+P,5,11,5,6,3,9,9,4,3,12,5,4,4,11,5,6
+K,5,4,5,6,2,4,8,8,2,7,5,11,4,8,2,11
+B,5,10,7,8,6,9,7,7,6,6,6,5,3,9,9,11
+V,3,4,5,6,1,8,8,4,3,7,14,8,3,10,0,8
+N,6,11,9,8,6,7,9,2,4,9,6,7,6,8,1,8
+A,4,10,7,8,5,11,3,1,2,8,2,9,6,4,3,8
+X,2,6,4,4,2,7,7,4,8,6,6,10,3,8,6,8
+E,3,8,4,6,2,3,6,6,11,7,7,15,0,8,7,7
+O,4,9,4,7,4,7,7,7,3,9,7,8,3,8,3,7
+X,4,9,6,7,4,9,7,0,8,9,4,8,2,8,3,8
+X,5,9,6,5,3,9,7,2,7,11,5,7,4,11,3,8
+M,7,8,9,7,10,8,8,4,4,7,6,7,10,9,6,3
+K,2,3,4,1,2,4,9,2,6,10,9,10,3,8,2,6
+U,4,5,5,3,2,6,8,6,8,7,10,9,3,9,1,8
+F,2,3,4,2,1,5,11,2,5,13,7,5,1,9,1,7
+B,1,1,2,2,1,7,7,8,5,7,6,7,2,8,7,9
+F,4,11,5,8,5,5,10,3,5,10,10,6,2,10,3,6
+G,4,9,6,7,6,7,7,6,2,7,6,11,4,8,8,8
+M,5,9,5,6,3,7,7,12,2,8,9,8,8,6,0,8
+R,3,6,5,4,5,5,7,3,4,7,6,9,5,10,7,5
+Y,4,5,5,7,7,9,8,5,3,6,8,8,7,11,7,4
+V,3,3,4,1,1,5,13,3,2,9,11,7,2,11,1,8
+W,3,4,4,3,3,5,11,2,2,8,9,9,6,11,0,8
+H,4,7,6,5,7,8,8,4,3,6,7,7,7,9,7,7
+K,4,8,6,6,4,5,6,1,7,10,9,11,4,7,4,7
+L,4,8,5,6,3,3,5,2,9,3,1,9,0,7,1,5
+E,3,7,4,5,4,8,7,4,8,7,7,8,2,8,6,10
+S,3,1,3,3,2,8,7,6,5,7,6,8,2,9,9,8
+B,6,10,6,8,5,6,5,9,7,6,7,6,2,8,10,10
+F,4,8,4,6,3,1,11,4,6,11,10,9,0,8,2,7
+H,6,7,8,5,6,10,6,3,6,10,3,7,4,7,4,9
+X,3,8,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+N,5,10,7,7,4,10,7,3,5,10,2,5,6,9,1,7
+L,6,11,6,6,4,8,4,3,4,12,7,11,3,9,6,9
+T,2,7,3,5,2,9,12,0,5,6,10,8,0,8,0,8
+E,5,8,7,6,5,4,9,2,8,10,8,9,3,9,4,6
+W,2,0,2,1,1,7,8,3,0,7,8,8,6,10,0,8
+S,3,4,4,3,2,6,8,3,7,10,8,8,1,8,5,5
+V,3,8,5,6,1,8,8,4,3,6,14,8,3,10,0,8
+Z,7,7,5,10,5,9,4,4,3,11,6,9,3,9,11,8
+T,4,7,6,5,6,7,7,4,5,7,6,9,5,8,5,7
+P,5,11,7,8,6,8,9,5,4,12,5,4,2,10,3,8
+O,2,4,3,3,2,8,7,6,4,9,5,8,2,8,2,8
+M,5,8,6,6,3,8,7,12,2,6,9,8,9,6,0,8
+B,3,8,5,6,5,7,7,6,6,6,6,6,2,8,6,9
+C,4,8,5,6,3,6,8,8,8,9,8,13,2,10,4,9
+E,4,5,5,8,3,3,8,6,12,7,5,15,0,8,7,7
+Y,4,6,4,4,2,4,10,2,7,11,11,6,1,10,2,4
+L,4,9,6,7,3,6,3,1,9,8,2,11,0,7,2,8
+X,4,9,5,4,2,6,8,1,7,11,6,8,3,7,4,6
+V,3,5,4,3,1,4,12,4,3,10,11,7,3,10,1,8
+V,1,0,2,0,0,8,9,3,2,6,12,8,2,10,0,8
+U,4,4,5,3,2,4,9,5,7,11,10,9,3,9,2,7
+J,3,8,4,6,3,10,7,0,7,11,3,6,0,7,1,7
+L,3,8,4,6,1,0,1,6,6,0,0,6,0,8,0,8
+Q,2,2,3,3,2,8,8,5,2,7,8,10,2,9,4,9
+D,1,0,1,0,0,6,7,7,5,7,6,6,2,8,3,8
+D,2,3,3,2,2,9,7,4,6,10,4,6,2,8,2,8
+X,5,9,8,7,5,3,8,1,8,10,11,10,2,9,3,5
+P,4,8,5,5,2,4,14,8,1,11,6,3,1,10,4,8
+J,2,5,4,4,2,7,7,3,6,15,7,10,1,6,1,7
+W,9,10,9,5,4,6,11,2,3,8,10,7,8,12,1,7
+O,4,9,5,6,4,7,7,8,6,7,3,8,3,8,3,8
+U,4,8,6,6,4,5,9,5,6,7,9,10,3,9,1,8
+Y,5,8,5,6,3,3,10,2,7,11,11,6,1,11,2,5
+E,7,11,10,8,8,7,7,2,8,11,7,9,3,8,5,8
+O,5,11,6,8,4,7,8,8,5,10,8,7,4,7,5,9
+N,10,13,12,7,5,3,11,6,3,14,12,9,6,9,0,8
+D,4,11,6,8,5,8,7,6,8,7,6,5,6,8,3,7
+U,4,7,6,5,3,6,9,6,8,8,10,9,3,9,1,8
+I,1,11,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+B,5,10,6,7,6,8,7,6,7,7,6,5,2,8,7,10
+X,4,6,5,8,2,7,7,4,4,7,6,8,3,8,4,8
+F,4,10,4,8,3,1,13,4,4,12,10,6,0,8,2,6
+C,5,8,5,6,4,6,7,6,6,12,8,11,2,11,4,7
+D,3,8,5,6,4,8,8,4,5,9,5,4,3,8,3,7
+X,5,9,6,8,7,7,8,1,5,7,6,8,3,6,8,8
+F,3,5,4,4,2,5,10,4,6,10,9,6,1,10,4,6
+X,3,1,4,3,2,7,7,3,9,6,6,8,2,8,6,8
+L,2,7,3,5,2,5,5,2,8,3,2,7,0,7,1,6
+Y,4,10,6,8,3,6,10,2,2,7,12,8,1,11,0,8
+C,7,9,5,5,2,7,9,6,7,12,7,8,1,8,6,9
+U,7,9,8,6,4,4,8,6,8,10,10,9,3,9,2,5
+R,4,9,6,7,4,10,7,3,5,11,2,6,3,7,4,10
+F,2,7,4,5,3,5,10,2,6,10,9,6,1,10,3,7
+N,8,14,9,8,4,4,10,6,4,14,12,9,6,9,0,9
+Z,6,9,8,7,6,6,9,2,9,11,8,7,3,11,7,7
+L,5,7,7,5,5,6,6,8,6,5,6,9,2,8,4,10
+K,6,11,9,8,7,2,9,2,7,10,12,12,5,6,4,4
+K,4,9,5,7,5,5,6,3,6,6,6,10,3,8,5,10
+X,3,6,4,5,4,7,8,2,5,8,6,8,2,7,6,7
+S,4,7,5,5,3,7,7,4,8,11,8,8,2,10,5,6
+M,5,9,6,7,6,8,6,6,5,6,7,8,8,6,2,7
+K,5,11,7,8,9,7,6,3,5,6,6,8,7,7,7,7
+V,3,5,5,7,2,8,8,4,3,7,14,8,3,9,0,8
+J,2,10,3,8,2,9,6,2,6,11,3,8,1,6,2,6
+E,4,7,5,5,3,7,8,2,8,11,6,8,2,8,5,8
+Z,3,5,5,4,3,8,7,2,9,12,6,9,1,8,5,7
+F,3,9,5,7,3,4,11,3,6,11,10,5,1,10,2,5
+C,6,10,9,7,6,7,8,8,6,5,6,13,5,8,4,7
+I,2,2,1,3,1,7,7,1,7,7,6,8,0,8,3,8
+L,1,0,2,1,0,2,1,6,4,0,3,4,0,8,0,8
+W,10,12,10,7,5,2,8,3,3,10,11,9,9,10,1,6
+N,2,5,4,4,2,7,9,2,4,10,6,7,5,8,1,7
+Y,3,4,4,3,2,4,10,1,7,10,10,6,2,10,3,3
+U,3,6,4,4,1,8,5,13,5,7,14,8,3,9,0,8
+Z,2,5,2,4,2,7,7,5,8,6,6,8,2,8,7,8
+K,3,4,5,3,2,8,6,1,6,10,5,9,3,8,3,9
+W,7,8,7,6,6,5,11,3,3,9,7,7,8,11,3,5
+B,3,6,4,4,4,8,7,5,5,9,6,6,2,8,4,7
+S,6,9,8,7,11,7,6,4,2,8,5,8,3,8,13,4
+L,1,0,1,0,0,2,2,5,4,1,2,6,0,8,0,8
+L,3,10,5,8,4,7,4,2,7,7,2,9,1,6,3,8
+P,4,8,6,6,4,8,8,2,6,13,5,5,2,9,3,9
+N,2,4,4,3,2,8,8,2,4,10,5,6,4,9,1,6
+B,5,9,8,8,9,7,7,5,4,7,6,8,7,10,9,11
+T,2,3,3,2,1,7,11,3,6,7,11,8,2,11,1,8
+Z,1,4,3,3,1,7,7,2,9,11,6,8,1,8,5,8
+L,3,4,3,6,1,0,1,6,6,0,0,6,0,8,0,8
+I,1,4,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+S,4,7,5,5,3,6,8,3,6,10,7,8,2,8,4,6
+V,8,10,7,7,3,3,12,4,4,10,12,8,3,10,1,8
+B,1,3,3,2,2,8,6,2,5,10,5,7,2,8,3,9
+R,5,8,7,6,7,8,8,7,4,8,5,6,4,7,7,11
+T,3,7,4,5,2,5,13,3,6,12,9,4,1,11,2,4
+H,3,2,5,3,3,7,7,6,6,7,6,8,3,8,3,8
+Y,3,6,4,4,2,4,10,1,6,9,10,5,1,11,3,4
+A,2,3,3,2,1,9,2,1,1,8,2,9,1,6,1,8
+K,6,9,9,7,6,2,8,3,7,11,12,12,4,7,4,5
+D,5,8,7,6,5,10,6,3,6,11,4,6,3,8,3,9
+I,1,8,0,6,1,7,7,5,3,7,6,8,0,8,0,8
+F,3,9,5,7,4,4,11,6,5,11,10,5,2,10,3,5
+Q,5,9,5,4,3,8,5,4,7,10,5,9,3,8,9,10
+X,5,8,7,6,5,8,5,3,5,7,7,9,4,8,10,9
+B,3,6,4,4,4,6,6,7,5,6,6,7,2,9,7,10
+M,10,14,10,8,5,9,11,6,5,4,6,9,10,11,2,7
+X,5,11,8,8,7,7,7,3,8,5,7,10,3,8,6,8
+L,4,7,5,5,4,6,8,8,5,7,5,10,3,7,4,11
+Q,3,4,4,6,2,8,8,8,6,6,6,9,3,8,4,9
+J,1,3,2,2,1,8,6,3,5,14,6,10,1,7,0,7
+T,3,8,4,6,3,5,11,2,7,8,11,8,2,11,1,7
+P,2,3,4,2,2,7,9,3,4,12,5,4,1,9,3,8
+V,9,15,8,8,4,6,11,6,4,10,10,4,5,12,3,9
+W,5,11,8,8,7,10,10,3,3,5,9,7,8,10,1,8
+R,3,8,4,6,4,5,11,7,3,8,4,9,2,6,5,11
+G,5,11,5,8,5,5,7,6,4,9,9,10,2,8,4,10
+E,4,7,5,5,4,6,7,7,9,8,8,10,3,8,6,8
+S,4,9,5,7,3,9,7,4,8,11,6,7,2,10,5,8
+C,6,8,6,6,3,4,9,6,9,13,10,10,1,9,3,7
+L,3,9,5,7,3,6,5,0,8,9,3,11,0,7,3,8
+Y,3,7,5,5,2,7,11,1,8,6,12,8,1,11,2,8
+Y,4,6,4,4,2,2,11,3,5,11,12,7,2,11,2,5
+O,3,6,4,4,2,7,6,8,5,7,5,9,3,8,3,8
+Z,4,10,5,7,4,7,8,3,12,9,6,8,0,8,8,7
+G,8,9,10,8,11,7,8,6,3,7,7,9,9,10,9,9
+X,4,9,6,7,4,8,7,4,9,6,7,9,4,7,8,9
+N,6,10,8,7,5,11,8,3,6,10,0,3,5,9,1,7
+Y,1,3,2,2,1,8,10,1,6,5,10,8,1,11,1,8
+R,4,8,5,6,4,8,7,5,6,8,5,8,3,6,6,11
+F,1,0,1,0,0,3,11,4,2,11,8,6,0,8,2,8
+W,3,1,4,2,2,8,11,2,2,6,9,8,6,11,0,7
+A,3,5,6,4,2,8,2,2,2,7,1,8,2,7,2,7
+P,2,1,2,2,1,5,9,3,4,9,8,4,1,9,3,7
+C,1,0,2,1,0,6,7,6,9,7,6,14,0,8,4,10
+D,2,0,2,1,1,6,7,8,7,7,6,6,2,8,3,8
+I,1,4,1,3,1,7,7,1,7,7,6,9,0,8,2,8
+K,4,4,4,6,2,4,8,8,2,7,5,11,3,8,2,11
+D,4,11,4,8,3,5,8,10,8,8,8,5,3,8,4,8
+T,7,10,7,8,4,7,10,2,10,11,9,4,3,9,5,5
+F,6,13,6,8,5,7,9,3,4,10,6,6,4,9,7,7
+L,2,2,3,3,2,4,4,5,7,2,2,6,1,7,1,6
+A,2,7,4,4,1,8,6,3,0,7,0,8,2,7,1,8
+N,5,9,7,6,4,7,8,6,6,7,7,6,6,10,2,5
+T,8,11,8,8,6,6,10,1,9,11,9,5,3,9,4,4
+Q,3,5,5,6,5,10,11,6,3,3,8,12,3,10,5,10
+Q,4,7,5,8,5,8,11,5,1,5,8,12,2,10,5,8
+K,2,1,2,1,0,4,7,6,2,7,6,11,3,8,2,10
+Y,3,4,5,5,1,7,10,2,2,8,12,8,1,11,0,8
+Z,3,6,4,4,2,8,7,2,9,11,5,8,2,8,6,8
+J,4,6,5,4,2,11,5,2,7,14,3,8,0,8,0,8
+U,3,1,4,2,1,7,8,6,8,7,10,8,3,10,1,8
+R,6,8,8,6,5,10,8,4,7,10,1,7,3,6,4,11
+N,5,7,8,5,3,7,8,3,5,10,7,7,5,7,1,8
+Y,5,6,5,4,2,3,12,5,5,13,11,6,1,11,1,6
+K,11,15,10,8,5,4,8,5,8,9,12,12,6,11,3,6
+K,6,9,9,7,6,3,8,3,8,11,12,12,4,7,4,4
+N,5,8,7,6,3,10,7,3,5,10,2,5,5,8,1,7
+Y,1,0,2,0,0,7,9,2,2,6,12,8,1,10,0,8
+E,2,4,3,2,2,6,8,2,7,11,7,9,2,8,4,8
+W,9,12,9,7,4,6,10,1,3,7,10,7,8,12,1,6
+W,6,9,6,4,4,5,8,2,3,8,9,7,9,10,2,5
+G,3,10,4,7,2,7,6,8,8,6,6,11,2,8,5,11
+U,4,3,5,5,2,7,4,14,5,7,14,8,3,9,0,8
+Y,5,6,6,8,9,8,6,7,4,7,7,8,10,9,4,5
+S,7,10,8,8,5,9,8,3,7,10,3,6,3,8,5,9
+A,4,10,5,5,4,9,5,5,2,10,6,11,6,5,5,10
+Z,3,9,4,7,2,7,7,4,13,10,6,8,0,8,8,8
+Z,5,10,7,8,5,7,8,2,9,11,7,7,1,8,6,7
+M,4,7,7,5,7,9,6,2,2,8,4,7,7,5,2,6
+Q,3,5,4,7,4,8,5,6,3,9,5,11,3,8,4,8
+M,5,10,8,8,6,6,6,3,4,9,9,9,8,5,2,7
+F,1,0,1,1,0,3,12,4,2,11,9,6,0,8,2,7
+V,6,9,6,6,4,3,11,2,3,9,10,8,3,12,1,7
+J,2,9,3,6,1,12,3,10,3,13,6,13,1,6,0,8
+Y,5,8,7,6,4,9,10,1,7,3,11,8,2,12,2,9
+N,5,9,6,7,4,7,9,5,5,7,6,7,6,9,2,6
+K,4,9,6,7,7,6,6,3,4,6,6,9,8,7,8,7
+O,4,9,4,6,3,8,6,8,5,9,4,7,3,8,3,8
+J,3,10,4,8,1,13,1,9,5,14,2,12,0,7,0,8
+M,4,5,7,3,4,8,7,3,4,9,6,7,8,6,2,7
+B,5,8,7,6,10,8,8,4,3,6,7,7,7,11,9,9
+W,7,10,7,8,6,4,10,3,2,9,8,7,7,12,2,5
+N,8,12,7,6,3,7,10,4,6,3,5,9,5,9,2,7
+H,3,1,4,2,3,7,7,6,6,7,6,8,5,8,4,8
+G,4,10,6,7,8,7,5,4,3,7,5,10,8,7,8,13
+Z,5,11,6,9,3,7,7,4,15,9,6,8,0,8,8,8
+T,1,0,1,0,0,8,14,2,4,6,10,8,0,8,0,8
+T,3,4,4,3,1,5,13,3,6,11,9,4,1,11,1,5
+R,3,5,6,4,4,7,8,5,4,8,5,8,3,6,4,11
+J,1,7,2,5,1,11,3,10,3,12,7,13,1,6,0,8
+B,3,7,5,5,4,8,8,3,6,10,5,6,2,8,4,10
+M,8,9,12,8,12,8,9,4,4,7,6,7,12,7,7,3
+H,5,11,5,8,3,7,6,15,1,7,8,8,3,8,0,8
+O,5,7,7,6,5,6,6,6,7,9,6,8,3,6,5,6
+L,5,4,5,7,1,0,0,6,6,0,1,5,0,8,0,8
+H,3,7,5,5,3,6,7,3,6,10,8,9,3,9,2,6
+I,1,4,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+G,5,10,6,8,3,8,6,8,9,6,5,11,2,8,6,10
+F,5,12,5,7,4,10,8,3,5,11,4,5,3,7,7,9
+A,4,8,6,7,7,10,8,3,4,6,7,6,5,9,5,5
+V,3,8,4,6,2,7,9,4,2,7,12,8,2,10,0,8
+C,6,11,6,8,4,5,7,7,8,12,9,14,2,10,4,7
+B,4,2,4,4,4,7,7,5,5,6,6,6,2,8,6,9
+N,3,6,4,4,3,7,9,6,4,7,6,6,5,9,1,6
+G,5,9,6,7,4,7,6,7,8,11,6,11,2,11,4,9
+M,5,9,6,6,6,8,5,11,0,6,9,8,7,5,0,7
+X,5,10,6,8,4,7,7,4,4,7,6,8,3,8,4,8
+W,4,10,6,8,4,8,8,4,2,7,8,8,8,9,0,8
+K,2,7,4,5,3,5,6,3,6,6,6,10,3,8,5,9
+P,3,3,4,5,2,4,12,9,2,10,6,4,1,10,4,8
+H,4,2,5,4,4,8,7,6,7,7,6,8,3,8,4,8
+Q,3,8,4,9,5,9,7,8,3,5,6,9,3,8,6,10
+Q,4,8,5,10,6,8,6,8,5,5,6,8,4,9,7,11
+X,4,9,6,6,4,7,6,3,8,5,6,9,3,8,7,8
+V,1,1,3,2,1,6,12,2,2,8,11,8,2,10,0,8
+B,7,10,5,6,4,6,7,5,5,10,6,8,5,7,8,9
+D,4,6,5,5,5,6,7,5,6,7,4,7,4,7,6,5
+R,2,2,3,3,2,7,8,4,5,7,5,7,2,7,5,8
+C,7,13,5,7,4,7,7,4,3,9,8,11,4,9,9,11
+O,5,5,7,8,3,7,8,9,8,8,7,6,3,8,4,8
+S,3,4,5,3,2,9,7,3,7,10,4,7,1,9,5,10
+Q,4,8,5,10,6,8,5,7,4,9,5,8,3,8,4,7
+P,6,6,8,8,9,6,7,5,3,8,7,6,7,13,6,9
+G,2,3,3,4,2,7,8,8,7,5,7,9,2,7,5,11
+S,6,9,5,5,2,10,2,2,4,10,2,9,2,7,3,10
+O,8,15,6,8,4,5,7,6,3,10,7,9,5,9,5,8
+B,3,1,4,3,3,8,8,5,6,7,5,5,2,8,6,8
+H,6,9,9,6,5,8,7,3,6,10,5,8,3,8,3,7
+D,5,10,6,8,6,5,7,9,7,7,6,6,2,8,3,8
+B,1,0,1,1,1,7,7,6,4,6,6,7,1,8,6,9
+Z,5,9,6,7,3,7,7,4,15,9,6,8,0,8,8,8
+S,7,15,6,8,3,9,5,4,4,13,6,9,2,9,3,8
+Z,5,5,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+R,8,10,8,5,5,8,9,3,6,9,2,6,7,4,6,6
+N,2,0,2,1,1,7,7,12,1,5,6,8,5,8,0,8
+G,5,10,6,8,3,7,6,8,8,6,6,9,2,7,6,10
+D,8,13,8,7,4,11,3,5,5,13,2,11,5,7,4,9
+H,5,6,7,4,4,5,8,4,6,10,8,9,3,8,3,7
+H,3,8,4,6,3,8,7,13,1,7,7,8,3,8,0,8
+S,9,15,7,8,4,7,5,5,6,8,2,8,4,6,6,8
+Z,3,7,4,5,4,9,9,5,3,7,5,7,3,8,9,4
+Q,4,6,5,8,4,7,8,5,2,8,9,10,3,9,6,8
+X,3,8,4,6,3,7,7,4,4,7,6,8,3,8,4,8
+I,1,8,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+W,3,9,5,6,3,4,8,5,1,7,8,8,8,10,0,8
+I,2,7,4,5,4,10,7,2,4,8,5,5,3,9,5,7
+J,2,7,3,5,1,12,2,9,4,13,5,13,1,6,0,8
+S,7,10,9,8,12,8,6,5,4,8,6,8,7,8,15,10
+F,3,6,3,4,1,2,13,5,3,11,9,6,0,8,3,6
+Q,5,6,6,8,6,7,10,4,2,7,9,11,3,9,5,8
+Y,1,3,3,1,1,7,11,1,6,7,11,8,1,11,1,8
+K,1,0,1,0,0,4,6,5,2,7,6,11,2,8,2,10
+O,3,9,4,7,4,7,6,8,4,7,5,11,3,8,3,9
+H,4,4,4,6,2,7,10,15,2,7,3,8,3,8,0,8
+B,1,0,2,1,1,7,7,7,4,7,6,7,1,8,6,8
+Q,3,7,5,5,4,7,4,7,4,7,5,10,2,8,3,9
+Z,5,10,6,8,6,9,6,5,9,8,5,7,1,7,7,8
+P,8,12,8,6,5,9,8,4,5,13,4,4,4,10,6,8
+W,5,9,8,7,7,6,11,2,2,7,8,8,8,11,1,8
+J,1,4,3,3,1,9,6,2,6,14,4,8,0,7,0,8
+V,3,3,4,2,1,4,13,3,2,10,11,7,2,11,1,8
+T,2,3,3,2,1,5,12,2,7,11,9,4,1,10,2,5
+L,7,13,6,7,3,8,3,3,5,11,4,13,2,7,6,8
+F,4,8,6,6,3,7,10,4,6,13,7,5,2,9,2,7
+O,5,7,6,5,4,7,10,8,5,5,8,11,5,9,4,7
+N,5,8,7,6,4,7,8,6,5,7,6,5,7,11,3,5
+V,4,10,6,8,3,6,11,3,4,7,12,9,2,10,1,9
+K,5,9,7,7,7,6,9,5,4,7,4,8,4,7,7,9
+X,4,8,6,6,5,7,6,2,6,7,7,9,5,9,7,7
+X,2,6,4,4,2,7,8,3,8,6,6,6,3,8,7,7
+Y,5,9,5,6,3,3,10,2,7,11,11,6,0,10,2,4
+A,7,12,6,7,3,12,2,3,1,10,4,11,4,4,4,9
+K,4,7,4,5,2,4,6,8,2,7,7,11,3,8,3,11
+P,4,5,4,8,2,3,13,8,2,11,7,3,1,10,4,8
+Z,5,9,5,4,3,6,7,2,8,11,8,9,3,8,5,5
+J,2,4,3,6,1,14,2,7,5,14,2,11,0,7,0,8
+X,3,7,4,5,2,7,7,4,4,7,6,8,3,8,4,8
+W,7,12,7,7,4,1,9,2,3,9,11,9,8,10,1,6
+S,4,9,4,6,4,8,8,5,8,5,5,6,0,7,9,7
+W,6,6,7,4,4,6,11,4,2,8,7,6,9,12,2,5
+Q,4,6,5,8,5,7,10,4,3,6,9,11,3,8,6,8
+P,4,7,5,5,3,6,11,4,4,13,6,3,1,10,3,9
+S,1,0,1,1,0,8,7,4,6,5,6,8,0,8,7,8
+X,4,6,7,4,3,5,8,2,8,11,10,9,3,8,3,6
+C,4,8,5,6,3,8,7,7,6,6,7,9,4,8,3,9
+W,10,11,10,8,6,2,11,2,3,10,11,9,8,10,2,6
+W,5,11,8,8,4,10,8,5,2,7,9,8,9,9,0,8
+D,5,3,6,4,4,7,7,7,7,7,6,4,3,8,3,7
+X,9,15,10,9,6,8,7,2,8,11,5,7,5,9,4,7
+D,4,9,6,6,8,9,8,4,5,7,7,6,4,9,8,5
+D,6,11,6,6,3,11,3,4,5,12,2,8,5,7,3,10
+U,3,3,4,2,2,7,8,5,6,6,9,9,5,10,0,7
+A,4,7,5,5,3,7,5,3,0,7,1,8,2,7,1,8
+O,1,3,2,1,1,8,7,6,4,9,5,8,2,8,2,8
+Q,3,7,4,7,3,7,6,8,5,5,6,8,3,8,5,9
+T,4,5,4,4,2,6,11,2,7,11,9,4,1,11,2,4
+A,3,2,5,3,2,8,2,2,2,6,1,8,2,6,2,7
+T,6,8,6,6,4,6,11,4,5,11,9,5,3,12,2,4
+Z,7,8,5,11,5,7,7,5,3,11,7,8,3,9,11,6
+C,2,3,3,4,1,6,7,7,9,9,6,13,1,9,4,9
+Y,7,8,7,6,4,3,11,2,7,12,11,6,0,10,2,5
+H,5,10,5,7,3,7,6,15,1,7,7,8,3,8,0,8
+T,2,7,3,4,1,7,14,0,6,7,11,8,0,8,0,8
+T,1,0,2,0,0,8,14,2,4,6,10,8,0,8,0,8
+A,3,5,4,4,3,8,8,2,4,7,8,8,4,9,3,6
+H,1,1,2,1,1,7,7,11,1,7,6,8,3,8,0,8
+F,7,11,6,6,3,6,10,2,6,11,7,5,2,9,6,5
+O,3,5,4,4,3,8,7,7,4,9,5,8,2,8,2,8
+Z,6,7,5,11,4,7,8,4,2,11,7,7,3,9,11,6
+G,6,9,8,6,7,7,8,5,3,6,6,9,5,7,7,7
+O,7,9,5,5,3,6,8,5,4,8,4,6,5,9,5,7
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+E,7,10,9,8,9,8,7,6,2,7,6,10,5,8,8,10
+Z,5,9,6,5,3,10,3,4,6,12,4,10,3,8,7,10
+P,2,4,4,2,2,7,10,4,3,12,5,3,1,10,2,8
+H,7,11,10,8,8,5,9,3,6,10,9,8,6,11,5,6
+V,4,9,6,7,1,8,8,5,3,6,14,8,3,9,0,8
+J,4,7,5,5,3,7,5,5,4,14,8,13,1,6,1,6
+D,5,10,6,7,5,5,7,9,7,6,5,4,3,8,5,10
+G,2,1,2,1,1,8,6,6,6,6,5,9,1,7,5,10
+N,3,4,5,3,2,8,8,3,5,10,4,6,5,9,1,6
+A,4,9,6,6,5,6,5,3,3,4,1,6,4,5,4,6
+Y,5,6,6,4,2,4,10,2,7,10,11,5,2,11,3,4
+M,8,9,11,8,13,8,7,5,5,7,6,7,13,9,8,2
+U,4,5,5,4,2,5,8,5,8,10,8,9,3,9,2,6
+T,3,11,5,8,1,9,15,0,6,6,11,8,0,8,0,8
+N,6,11,7,8,6,8,7,13,1,6,6,7,7,7,1,10
+A,3,10,6,7,2,7,3,3,3,7,1,8,3,6,3,7
+N,4,9,5,6,4,7,8,6,5,7,6,6,6,9,1,6
+Y,2,3,3,2,1,8,10,1,6,6,11,8,1,11,2,7
+L,6,12,5,7,4,5,6,3,6,12,8,12,3,7,7,8
+T,5,9,6,6,5,6,7,7,7,8,9,8,3,9,6,9
+N,4,7,5,5,4,7,6,7,5,6,4,7,3,7,3,7
+O,5,10,6,8,5,7,8,8,6,7,8,8,2,8,3,8
+W,6,7,6,5,5,3,11,2,2,10,10,8,6,11,2,7
+B,3,6,4,4,4,7,7,5,4,6,5,7,3,8,5,7
+R,5,5,5,8,3,5,10,10,4,7,5,8,3,7,6,11
+J,2,9,3,7,1,14,2,7,5,14,2,10,0,7,0,8
+S,6,8,7,6,4,7,8,3,8,10,5,6,2,6,5,8
+F,2,1,3,2,2,5,10,4,5,11,9,5,1,10,3,6
+I,4,10,5,7,3,7,7,0,7,13,6,8,0,8,1,8
+L,4,9,6,6,7,6,7,3,6,7,7,11,6,11,6,5
+S,6,11,6,6,3,9,6,4,3,13,7,9,3,10,3,8
+L,3,8,5,6,6,6,7,3,6,8,7,11,6,10,5,6
+Y,8,13,7,7,4,7,7,5,3,10,8,5,4,9,5,4
+E,4,8,6,6,5,7,8,6,9,6,4,9,3,8,6,8
+D,4,8,6,6,5,7,7,7,6,6,6,4,3,8,3,7
+A,2,4,4,3,2,11,2,3,2,11,2,10,2,6,2,9
+T,5,7,5,5,3,7,11,4,7,11,8,4,3,12,3,5
+Y,4,9,7,7,3,7,11,1,8,6,12,8,1,11,2,8
+C,6,10,5,5,3,7,8,4,3,9,8,10,4,9,8,10
+V,6,7,5,5,2,4,12,4,4,11,11,7,3,10,1,8
+D,5,5,6,8,3,5,7,10,10,7,6,6,3,8,4,8
+W,5,5,7,5,7,7,8,5,5,7,5,8,9,8,8,6
+C,4,7,5,5,5,5,7,3,5,8,6,11,6,9,4,9
+U,5,8,7,6,6,8,8,8,5,6,7,9,3,8,4,6
+Q,5,10,6,9,3,8,7,8,6,6,7,8,3,8,5,9
+V,3,6,5,4,2,7,12,2,3,6,11,9,2,10,1,8
+T,2,9,4,6,1,9,14,0,6,5,11,8,0,8,0,8
+Z,2,4,3,3,2,8,7,5,9,6,6,7,1,8,7,8
+Z,10,15,10,9,7,8,6,3,9,12,6,9,4,5,8,7
+T,7,9,7,7,4,4,13,5,6,12,9,3,2,12,2,4
+N,11,15,14,8,5,10,5,4,4,14,1,7,6,6,0,7
+S,4,8,5,6,3,6,8,4,7,10,8,7,2,8,5,5
+N,2,4,2,2,2,7,8,5,4,7,6,6,5,9,1,5
+F,3,7,4,5,3,3,11,3,5,11,10,6,1,10,2,6
+I,1,3,2,2,0,7,8,1,6,13,6,8,0,8,0,8
+X,2,3,3,1,1,8,7,3,8,6,6,8,2,8,5,8
+Q,3,5,3,6,3,9,6,6,3,8,6,11,3,9,5,8
+E,4,9,6,7,5,9,7,2,7,11,5,8,3,7,6,10
+T,6,7,6,5,4,6,10,1,10,11,9,5,0,10,3,4
+U,4,8,5,6,2,7,3,15,6,7,13,8,3,9,0,8
+V,4,6,5,4,2,7,11,3,3,8,11,8,3,10,3,8
+A,3,7,5,4,2,7,4,3,1,6,1,8,3,6,2,7
+V,3,6,3,4,2,4,11,1,3,9,10,7,2,11,0,8
+Z,4,8,6,6,5,9,10,6,5,7,5,8,3,9,10,7
+Q,4,8,5,6,5,8,5,7,3,6,7,8,3,7,6,9
+U,1,0,2,1,0,7,5,10,4,7,12,8,3,10,0,8
+A,2,3,3,1,1,11,2,3,1,9,2,9,1,6,2,8
+G,4,8,5,6,4,5,8,5,5,8,8,9,2,7,4,10
+D,6,10,6,5,4,7,7,4,7,10,5,6,5,9,7,5
+Y,6,9,5,4,3,6,8,4,5,10,7,5,3,9,4,4
+O,4,9,6,6,7,8,7,5,1,7,6,8,8,8,5,10
+M,4,4,7,3,3,7,7,3,5,9,7,8,9,7,2,7
+K,3,5,4,4,3,5,6,4,7,7,7,11,3,9,5,10
+V,3,7,4,5,3,7,11,1,2,6,10,8,3,12,1,8
+R,2,4,4,3,2,8,7,4,5,8,5,7,2,7,4,11
+R,4,9,6,6,5,9,8,3,6,9,3,8,3,6,4,11
+L,2,4,2,3,1,5,4,5,7,2,2,4,1,7,1,6
+A,3,4,5,3,2,8,2,2,2,7,2,8,2,6,3,6
+Q,5,5,7,4,5,7,5,5,5,7,5,9,5,4,7,7
+P,4,8,5,6,4,3,13,6,2,11,8,4,0,9,3,8
+H,7,11,10,8,9,8,7,3,6,10,4,7,4,9,4,9
+I,2,9,2,7,2,8,7,0,9,7,6,7,0,8,3,7
+J,5,10,6,8,4,8,7,3,6,14,5,9,1,6,1,7
+F,8,14,7,8,3,5,10,3,5,12,6,5,2,8,6,4
+K,1,0,1,0,0,4,6,6,2,7,6,11,3,7,2,10
+Q,5,9,6,8,3,8,7,8,6,6,7,9,3,8,5,9
+C,4,9,5,7,4,6,7,6,8,5,8,11,1,7,4,9
+T,3,4,4,2,2,5,12,3,6,11,9,4,2,11,2,5
+B,6,9,8,7,8,8,7,5,5,9,5,6,4,8,7,11
+J,3,9,4,7,1,12,2,9,4,14,5,13,1,6,0,8
+K,3,5,5,3,3,6,7,1,6,10,7,10,3,8,3,8
+X,3,4,4,3,2,8,7,3,9,6,6,8,2,8,6,8
+N,3,3,4,5,2,7,7,14,2,5,6,8,5,8,0,8
+W,3,1,4,2,2,5,11,3,2,8,9,9,6,11,0,8
+H,3,4,4,2,3,8,7,6,6,7,6,8,6,8,4,7
+Z,2,4,4,3,2,7,8,2,9,11,7,7,1,8,5,6
+W,7,9,7,4,4,5,8,2,4,8,10,8,10,10,2,6
+I,8,14,7,8,4,7,9,3,7,14,5,4,3,7,6,8
+W,5,9,7,7,6,5,11,2,2,7,8,9,7,12,1,8
+Y,5,9,6,7,2,9,11,2,2,6,12,8,1,11,0,8
+N,3,7,5,5,3,7,8,6,4,7,6,7,5,9,1,6
+S,3,5,5,4,2,8,7,2,8,11,6,7,1,9,4,8
+W,4,9,6,7,6,7,5,6,2,7,7,8,6,8,4,8
+Y,3,4,4,3,2,4,10,2,7,10,10,6,2,11,4,3
+S,5,9,5,4,2,8,7,4,3,13,7,7,3,10,3,7
+E,5,6,5,8,3,3,7,6,11,7,6,15,0,8,7,7
+X,4,10,5,7,2,7,7,5,4,7,6,8,3,8,4,8
+V,6,7,6,5,3,4,11,1,3,8,10,8,5,11,2,7
+M,3,7,5,5,5,7,9,6,3,7,7,9,5,9,5,10
+L,2,0,2,1,0,2,0,6,4,0,3,4,0,8,0,8
+J,2,4,3,7,1,14,2,6,5,14,1,10,0,7,0,8
+H,5,5,6,6,3,7,6,15,0,7,8,8,3,8,0,8
+P,5,8,7,6,5,9,7,2,5,13,4,6,2,9,3,9
+S,1,3,3,2,1,8,7,3,7,10,7,8,1,9,5,8
+C,5,9,5,7,3,3,8,5,8,11,10,13,1,9,3,7
+T,2,1,2,2,1,7,11,1,6,7,10,8,1,10,1,8
+D,4,7,4,5,4,5,7,8,7,6,5,6,2,8,3,8
+Q,5,11,4,6,3,11,4,3,6,9,4,8,3,9,6,13
+D,2,5,4,4,3,9,7,5,6,10,4,6,2,8,3,8
+A,1,1,2,1,0,8,4,2,0,7,1,8,2,7,1,8
+V,6,9,6,4,2,6,9,4,2,9,7,5,5,12,2,7
+R,4,4,4,6,3,6,9,9,4,7,5,8,3,8,5,10
+O,3,3,4,5,2,7,7,9,6,7,7,7,3,8,4,8
+S,3,10,4,7,4,8,7,7,5,7,7,8,2,8,8,8
+E,3,5,4,5,4,5,9,4,4,8,7,8,4,11,7,7
+P,5,8,7,6,4,9,8,3,7,13,4,5,4,10,5,10
+V,9,12,7,7,3,7,11,6,4,10,10,4,5,12,3,9
+N,5,11,5,8,5,7,7,13,1,6,6,8,6,9,1,6
+G,7,11,7,8,6,6,6,6,6,10,7,12,2,9,4,10
+H,3,8,4,5,2,7,9,15,2,7,3,8,3,8,0,8
+G,2,3,2,2,1,7,6,6,5,7,6,9,2,9,4,9
+Y,3,9,5,7,2,7,10,1,3,7,12,8,1,11,0,8
+K,6,8,9,7,7,10,4,2,3,10,3,8,6,6,7,13
+Q,5,9,5,11,7,8,7,7,3,8,7,9,3,8,6,8
+O,6,12,4,6,3,6,7,7,3,10,7,9,5,10,5,7
+A,6,8,8,7,7,6,7,3,5,7,8,10,8,11,4,7
+L,5,11,7,8,5,7,4,1,8,8,2,10,0,6,3,8
+E,2,3,4,2,2,7,8,2,7,11,7,8,2,8,3,8
+F,5,11,5,8,2,1,15,5,3,12,8,3,0,8,3,6
+W,3,2,5,3,3,8,11,3,2,6,9,8,7,11,0,8
+Z,2,7,3,5,1,7,7,3,13,9,6,8,0,8,8,8
+E,4,11,6,8,6,8,7,5,9,6,5,9,3,8,6,9
+E,7,10,9,8,7,7,7,2,8,11,7,9,3,8,5,8
+R,3,5,5,4,4,8,7,4,5,9,4,7,3,7,4,10
+A,3,5,5,8,2,8,5,3,1,7,0,8,2,7,2,8
+W,4,2,6,3,3,7,11,3,2,7,9,8,8,10,1,8
+V,5,6,5,4,3,2,12,3,3,10,11,8,2,11,1,7
+S,5,10,6,8,3,10,6,4,8,11,3,8,2,8,5,11
+U,6,10,8,8,5,5,8,6,8,7,10,10,3,9,1,8
+B,4,9,4,7,5,6,8,8,6,7,5,7,2,8,7,9
+J,1,2,2,3,1,11,6,2,5,11,3,8,0,7,1,7
+X,1,1,2,1,0,8,7,3,4,7,6,8,2,8,4,8
+W,8,11,8,6,5,8,8,4,4,6,9,6,10,10,3,6
+X,4,8,5,6,3,7,7,4,4,7,6,7,3,8,4,8
+B,5,9,5,5,5,8,8,3,5,9,5,6,6,4,6,8
+L,4,9,5,7,2,2,4,2,9,2,0,8,0,7,1,5
+O,3,4,4,3,2,7,7,7,4,9,6,8,3,8,3,8
+W,5,10,8,8,8,8,11,2,3,6,8,8,8,10,1,8
+E,5,5,5,8,3,3,8,6,12,7,6,15,0,8,7,6
+R,1,1,2,1,1,6,9,8,4,7,5,8,2,7,4,11
+M,5,10,5,8,4,8,7,12,2,6,9,8,8,6,0,8
+D,5,10,7,7,7,9,7,4,6,9,4,6,3,8,3,8
+U,7,9,8,7,5,6,6,6,9,8,6,8,4,8,4,3
+F,8,12,7,6,3,5,10,2,5,12,6,4,2,9,6,4
+H,3,6,4,4,3,7,8,12,1,7,4,8,3,8,0,8
+C,6,9,6,7,3,5,8,7,8,13,9,9,2,11,3,6
+C,2,1,3,2,1,6,8,7,7,9,7,12,1,10,3,9
+O,2,1,2,1,1,8,7,6,5,7,6,8,2,8,3,8
+A,4,11,6,8,4,12,2,3,3,11,1,9,3,7,3,9
+A,6,11,8,8,8,8,7,6,5,6,6,9,6,8,7,3
+W,8,9,8,7,6,5,10,3,3,9,7,7,10,12,3,4
+N,4,4,5,6,2,7,7,14,2,4,6,8,6,8,0,8
+F,3,9,5,6,4,4,10,4,5,11,10,6,2,10,2,6
+J,2,8,3,6,1,9,5,4,7,12,4,11,1,6,1,7
+G,4,8,5,6,3,6,6,7,7,10,7,11,2,11,4,9
+H,3,7,4,5,4,6,6,7,6,6,7,9,3,9,3,8
+S,4,7,5,5,3,8,7,3,6,10,6,8,2,8,4,8
+U,2,0,2,0,0,7,5,10,4,7,13,8,3,10,0,8
+O,5,10,6,8,4,7,7,8,5,10,6,8,3,8,3,8
+N,4,5,5,4,3,7,8,5,5,7,7,6,6,9,2,5
+H,5,4,5,6,2,7,7,15,0,7,6,8,3,8,0,8
+V,3,6,4,4,2,9,11,3,3,4,11,9,2,10,1,8
+T,7,10,6,5,2,4,12,3,7,12,8,4,2,8,3,3
+U,6,10,8,8,11,7,6,4,5,7,7,8,11,9,7,10
+B,2,5,4,3,3,9,7,2,5,10,5,6,2,8,4,9
+R,4,6,6,4,4,9,8,4,6,9,3,7,3,6,4,11
+S,4,10,5,8,5,7,7,7,5,7,7,9,2,8,8,7
+F,3,4,5,3,2,4,12,4,4,13,8,4,1,10,1,7
+M,6,10,7,5,4,13,2,5,2,12,1,9,6,3,1,8
+H,3,3,4,4,2,7,5,14,1,7,9,8,3,9,0,8
+B,2,0,2,1,1,7,8,7,5,7,6,7,1,8,7,8
+K,3,5,5,3,3,5,7,2,7,10,9,11,3,8,3,7
+E,6,12,4,6,2,7,9,6,7,9,6,10,1,9,8,9
+J,4,11,5,8,3,8,9,0,7,14,5,6,1,9,1,8
+A,3,8,5,6,4,11,3,1,2,8,3,9,3,5,2,8
+R,4,4,5,6,3,6,10,9,3,7,5,8,3,8,6,11
+S,5,9,5,5,2,5,9,2,5,13,8,8,2,8,2,6
+K,3,6,4,4,1,4,7,8,1,7,6,11,3,8,2,11
+W,4,4,5,3,3,4,10,2,2,9,9,7,6,11,1,7
+J,6,10,8,8,4,5,9,3,6,15,7,9,2,7,2,6
+U,3,7,5,5,3,8,8,5,7,4,8,8,3,9,0,7
+Z,3,8,4,6,2,7,7,4,13,10,6,8,0,8,8,8
+F,5,9,4,4,2,5,11,3,4,12,7,4,1,8,5,4
+L,3,4,3,3,2,4,3,4,6,2,2,6,0,7,0,6
+L,3,10,4,8,2,0,2,3,6,1,0,8,0,8,0,8
+D,4,6,5,4,4,7,7,6,5,6,5,6,3,8,3,7
+U,6,10,6,8,3,8,4,15,6,7,15,8,3,9,0,8
+S,6,9,5,4,2,11,2,3,4,11,2,10,3,7,3,11
+U,3,2,4,4,2,6,8,5,6,6,8,9,6,10,1,7
+L,3,8,3,6,1,0,1,5,6,0,0,6,0,8,0,8
+K,7,11,6,6,3,7,8,3,6,9,7,8,6,9,3,7
+Q,2,2,3,3,2,7,9,4,2,7,8,10,2,9,4,8
+T,2,7,3,4,1,7,14,0,6,7,11,8,0,8,0,8
+U,2,4,3,3,1,4,8,5,6,11,9,9,3,9,1,7
+H,3,3,5,2,2,7,8,3,6,10,6,7,3,8,3,8
+Y,3,5,4,3,2,4,10,1,7,10,10,6,1,11,3,4
+I,2,5,1,4,1,7,7,1,7,7,6,8,0,8,3,8
+V,3,5,5,8,2,7,8,4,3,7,14,8,3,9,0,8
+I,2,9,3,7,2,7,7,0,8,13,6,8,0,8,1,8
+E,3,3,3,4,2,3,8,6,9,7,6,14,0,8,7,8
+Q,1,2,2,3,1,8,7,5,2,8,7,9,2,9,3,9
+K,5,8,7,6,5,7,7,1,6,10,5,9,3,8,3,9
+C,5,10,5,8,3,4,10,7,8,12,10,9,2,9,2,6
+W,2,1,3,1,1,7,8,4,0,7,8,8,7,9,0,8
+Z,2,2,3,3,2,7,8,5,9,6,7,9,1,9,7,8
+M,6,6,9,6,9,9,8,5,4,7,6,7,11,9,6,3
+N,4,9,5,6,2,7,7,15,2,4,6,8,6,8,0,8
+G,2,5,3,3,2,7,7,7,6,6,6,10,2,8,4,9
+F,5,8,7,6,4,6,10,2,5,13,7,5,2,10,2,7
+Y,4,5,5,7,6,9,9,6,3,6,8,8,5,10,6,4
+K,4,5,7,4,3,6,6,2,7,10,8,11,4,7,4,7
+E,2,3,3,2,2,7,7,2,7,11,7,8,2,9,4,8
+F,2,4,3,3,2,5,10,4,6,10,9,6,1,10,3,6
+G,2,3,2,2,1,7,6,6,5,6,6,9,2,9,4,9
+P,7,10,10,8,6,8,10,7,5,9,4,3,3,10,5,9
+H,3,3,3,5,2,7,9,14,3,7,3,8,3,8,0,8
+Z,3,7,4,5,3,6,8,5,9,7,7,10,1,9,7,8
+O,3,9,4,6,3,7,7,8,6,7,8,8,2,8,3,8
+B,4,8,5,6,5,7,8,5,4,7,5,7,3,8,6,8
+M,3,4,5,3,3,10,6,3,4,9,4,7,6,5,1,8
+L,3,10,4,7,1,0,1,5,6,0,0,7,0,8,0,8
+W,6,7,6,5,4,7,11,4,2,8,7,6,7,12,3,6
+M,12,12,12,6,6,8,10,6,4,5,5,10,11,13,2,7
+L,5,9,7,7,5,5,5,1,8,7,2,11,2,9,3,7
+E,4,10,5,8,3,3,9,6,12,7,5,14,0,8,8,7
+U,4,7,5,5,2,8,4,14,5,6,14,8,3,9,0,8
+X,7,9,6,4,3,8,7,2,8,9,7,8,4,12,3,7
+Q,1,2,2,2,1,8,8,5,2,8,7,9,2,9,3,9
+M,5,10,8,7,7,9,6,2,4,8,5,7,7,6,2,8
+B,4,9,6,6,8,9,7,4,3,6,7,7,6,10,7,6
+U,4,10,6,8,10,7,7,4,4,7,6,8,11,7,8,8
+P,10,13,8,7,4,8,8,6,4,13,3,5,5,9,4,8
+V,6,10,6,8,3,2,11,4,4,11,12,8,2,10,1,8
+X,3,4,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+C,4,11,5,8,3,6,8,9,8,10,8,11,2,12,4,9
+B,5,7,8,6,9,9,6,4,4,7,6,8,7,9,8,7
+N,5,9,8,7,8,7,8,4,5,7,6,7,6,8,7,5
+Y,2,3,4,4,1,9,10,2,2,6,12,8,2,11,0,8
+X,1,3,2,1,1,8,7,4,8,7,6,8,2,8,5,8
+X,4,8,6,6,6,7,7,3,5,6,5,10,2,7,8,8
+G,7,11,6,6,3,9,4,4,3,8,3,5,4,7,4,9
+C,4,7,5,6,5,6,7,4,4,7,6,10,4,10,7,11
+C,2,5,3,3,2,6,8,7,8,8,7,13,1,9,4,10
+V,3,10,5,7,2,7,8,4,3,7,14,8,3,9,0,8
+Q,3,4,4,6,2,7,7,7,6,6,7,7,3,7,6,9
+D,3,2,4,4,3,7,7,7,6,6,6,5,2,8,3,7
+I,7,14,6,8,4,8,7,2,5,11,6,6,2,9,6,11
+U,4,4,4,6,2,7,5,14,5,7,13,8,3,9,0,8
+B,4,6,4,8,4,6,7,10,7,7,6,7,3,8,9,10
+U,7,11,8,8,5,3,8,5,7,10,9,9,3,9,2,6
+E,5,8,7,6,5,7,7,2,7,11,6,9,3,8,4,9
+C,4,7,5,5,3,6,7,6,8,7,6,11,1,9,4,9
+V,6,9,4,5,3,8,9,6,3,7,9,6,6,12,3,8
+A,2,6,3,4,2,11,3,3,3,11,2,10,2,6,3,8
+W,4,10,7,7,5,5,10,2,3,7,9,9,8,11,1,8
+J,3,10,4,7,2,13,3,7,4,13,4,11,1,6,0,8
+N,11,13,9,7,4,5,9,5,6,3,3,12,6,11,2,7
+S,2,4,4,2,2,8,8,2,7,11,6,7,1,8,5,8
+O,3,7,4,5,3,8,8,8,6,7,5,8,2,8,3,7
+F,4,7,5,5,2,5,12,4,6,12,9,3,1,10,3,4
+M,5,3,5,5,3,7,7,12,1,7,9,8,8,6,0,8
+D,4,8,4,6,3,6,7,10,10,7,6,6,3,8,4,8
+X,6,11,8,8,8,7,6,3,5,6,6,9,4,7,11,10
+P,7,10,10,8,5,6,13,7,2,11,5,2,1,11,4,8
+W,7,7,7,5,6,4,10,2,3,10,9,8,7,11,2,6
+J,2,6,2,4,1,13,2,8,4,13,4,12,1,6,0,8
+S,4,6,5,4,5,9,7,4,3,9,5,8,4,8,10,10
+A,2,7,4,5,3,10,3,1,2,7,3,9,1,5,1,7
+M,5,8,8,6,5,3,7,4,5,11,12,11,5,8,2,7
+H,1,1,2,1,1,7,8,11,1,7,5,8,3,8,0,8
+T,2,7,4,4,1,9,15,1,5,6,11,9,0,8,0,8
+N,2,2,3,3,2,7,8,5,4,7,6,7,4,8,1,7
+L,3,8,4,6,1,0,1,6,6,0,0,6,0,8,0,8
+G,5,10,7,8,6,8,7,7,6,6,7,7,2,7,8,13
+L,2,3,3,2,1,7,4,1,8,8,2,10,0,7,2,8
+D,5,10,7,7,5,10,6,4,7,11,3,6,4,6,4,8
+L,3,2,3,3,2,4,4,3,8,2,1,7,0,7,1,6
+U,5,7,6,5,3,4,8,5,7,9,8,9,3,9,2,5
+T,2,6,3,4,2,7,13,0,5,7,10,8,0,8,0,8
+P,4,10,5,8,4,5,11,3,7,11,9,4,0,10,4,7
+Z,5,9,7,6,4,6,9,3,10,11,9,5,2,8,6,5
+X,4,7,6,5,3,11,6,2,8,10,0,6,3,7,3,10
+L,2,5,4,3,2,6,4,1,8,8,2,10,0,7,2,8
+E,3,7,4,5,3,7,7,6,10,6,5,9,2,8,6,8
+A,3,8,5,6,3,12,2,3,2,10,2,9,2,6,2,8
+W,5,11,7,8,9,8,7,6,3,5,8,8,9,8,6,2
+P,5,9,7,7,4,9,7,3,6,13,4,5,5,10,5,10
+W,3,3,5,5,3,5,8,5,1,7,8,8,8,10,0,8
+W,8,8,11,7,11,6,8,6,6,6,6,7,10,9,9,9
+J,2,7,2,5,1,11,7,1,7,11,3,6,0,7,1,7
+F,4,8,6,6,3,4,12,4,5,13,8,4,2,10,2,6
+Y,6,11,6,8,3,3,10,2,7,11,12,6,2,11,3,5
+F,4,8,5,6,5,7,9,6,3,8,6,8,3,10,7,11
+T,3,5,4,4,2,5,12,3,7,11,9,4,1,11,2,5
+N,3,7,4,5,2,7,7,14,2,5,6,8,5,8,0,8
+I,3,10,4,8,3,7,7,0,7,13,6,8,0,8,1,8
+M,6,7,9,5,6,5,7,3,4,10,10,10,10,6,4,8
+L,3,8,5,6,3,3,5,1,8,3,1,9,0,7,1,6
+Q,4,8,6,7,3,8,7,7,6,6,7,8,3,8,5,9
+V,4,11,6,9,4,7,11,2,4,6,11,9,3,9,2,8
+M,6,8,8,7,10,8,7,4,4,7,6,7,11,8,5,5
+Y,3,4,4,6,1,6,12,2,3,9,12,8,0,10,0,8
+Q,4,9,6,8,3,8,5,9,7,6,4,8,3,8,4,8
+A,3,3,5,4,2,6,3,3,2,6,2,8,3,6,3,7
+F,7,12,6,6,4,6,10,3,4,10,7,5,4,9,8,6
+R,4,8,6,6,4,10,8,3,7,10,1,7,3,6,4,10
+X,6,9,9,7,5,7,7,0,8,10,6,8,3,8,3,7
+X,4,6,7,4,3,9,7,1,8,10,4,7,3,8,3,8
+B,2,3,3,2,2,10,6,2,6,10,4,7,2,8,4,10
+N,3,6,3,4,2,7,7,13,1,5,6,8,5,8,0,8
+F,2,3,2,2,1,5,10,3,5,10,9,5,1,10,3,6
+I,5,12,5,7,3,9,8,3,6,13,4,5,2,8,5,10
+Y,5,6,5,4,3,4,9,1,7,10,10,6,1,10,2,4
+A,8,15,6,8,4,9,3,3,2,8,4,11,6,4,5,8
+Z,4,7,6,5,3,7,7,2,9,12,6,9,1,9,6,8
+F,6,10,5,5,4,10,8,4,6,11,3,4,2,9,6,9
+G,2,4,3,2,1,7,8,5,6,9,7,10,2,9,4,10
+L,3,9,5,7,3,8,4,2,7,8,2,8,1,6,2,9
+T,5,5,5,4,2,5,11,3,7,12,9,4,1,11,2,4
+J,6,11,8,8,6,7,7,7,6,8,7,8,3,7,4,6
+F,3,5,5,4,2,4,11,4,6,13,9,6,1,9,2,6
+S,3,9,4,7,2,7,6,6,9,4,6,10,0,9,9,8
+V,3,2,5,3,2,7,12,2,3,7,11,8,3,10,1,8
+E,6,13,5,7,4,7,8,4,4,11,5,9,3,9,8,11
+P,4,11,5,8,3,5,10,11,5,9,6,5,2,10,4,8
+R,5,11,7,8,5,8,9,5,6,8,5,8,3,7,6,11
+K,3,3,3,4,1,3,7,8,3,7,6,11,4,8,2,11
+A,4,7,5,5,3,8,2,2,2,7,2,8,2,7,3,6
+L,1,0,2,1,0,2,1,6,4,0,2,5,0,8,0,8
+R,2,1,3,2,2,6,7,4,5,6,5,7,5,7,3,8
+P,6,9,8,6,7,6,8,7,4,8,7,9,2,9,7,9
+N,4,8,5,6,2,7,7,15,2,4,6,8,6,8,0,8
+E,5,9,4,4,2,8,7,3,4,10,5,9,3,9,8,11
+K,5,7,8,5,5,3,8,2,7,10,11,11,3,7,3,5
+E,3,7,5,5,4,7,8,5,8,6,5,9,3,8,6,9
+I,4,7,5,8,5,8,9,4,4,7,7,9,4,7,7,6
+D,5,11,7,8,7,7,7,5,7,7,7,5,6,8,3,7
+V,3,9,5,6,3,7,9,3,1,7,12,8,3,9,1,8
+X,2,1,2,1,0,8,7,4,4,7,6,8,3,8,4,8
+X,4,11,5,8,4,7,7,4,4,7,6,7,2,8,4,8
+W,3,3,4,2,2,4,11,3,2,9,9,7,6,11,1,7
+O,5,9,6,7,3,9,9,9,9,5,8,10,3,8,4,8
+B,5,8,7,6,6,7,9,5,6,10,6,5,3,7,7,8
+T,8,12,7,7,2,5,11,3,7,13,7,4,2,8,4,4
+I,3,11,3,8,4,8,7,0,7,7,6,8,0,8,3,8
+H,3,4,5,2,2,7,7,3,6,10,6,8,3,8,3,8
+B,4,8,6,6,5,8,9,4,6,10,5,5,2,8,6,9
+V,3,3,4,2,1,5,12,2,2,9,11,7,3,12,1,7
+P,4,8,5,6,2,4,13,8,1,11,6,3,1,10,4,8
+S,5,10,6,8,3,9,8,6,9,5,6,5,0,8,9,7
+M,9,9,13,8,14,6,6,5,4,6,5,8,15,11,7,9
+G,1,0,1,1,0,7,7,6,5,6,5,9,1,7,5,10
+P,3,7,5,5,3,6,10,3,6,10,8,4,4,10,4,7
+N,4,7,5,5,4,7,7,7,5,8,6,6,3,7,3,8
+J,2,11,3,8,2,11,6,1,8,11,2,6,0,7,1,7
+D,5,9,5,5,3,5,8,4,6,9,6,6,4,10,6,5
+L,4,11,6,9,3,3,4,2,10,2,0,8,0,7,1,5
+P,8,13,7,7,5,10,7,4,5,12,4,5,4,11,5,8
+M,7,11,11,8,8,4,7,4,5,10,11,11,9,7,4,8
+V,7,9,7,7,3,3,11,4,4,10,12,7,3,10,1,7
+N,6,5,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+S,2,1,3,2,2,8,8,6,5,7,5,7,2,8,8,8
+I,5,6,7,7,6,7,9,4,5,7,7,7,3,8,8,8
+E,6,14,5,8,4,8,8,4,5,11,5,9,3,9,8,11
+F,3,3,3,4,1,1,12,5,4,11,10,7,0,8,3,7
+F,5,10,8,7,6,9,8,2,6,12,4,5,4,8,4,9
+W,8,8,8,6,6,3,11,2,3,10,9,8,7,11,2,6
+K,7,10,6,5,3,9,8,3,6,9,4,6,5,8,4,7
+S,3,7,4,5,5,8,8,5,3,8,5,8,3,8,10,7
+A,2,3,4,2,1,8,2,2,2,7,2,8,2,6,2,7
+Y,4,8,6,6,6,9,4,7,4,7,9,7,3,9,8,4
+Y,3,4,4,2,2,4,11,2,7,11,10,5,1,11,2,5
+H,4,9,5,6,2,7,6,15,1,7,7,8,3,8,0,8
+D,5,11,6,8,7,8,7,5,5,10,5,5,3,8,3,8
+O,6,10,5,5,3,7,5,6,3,10,6,10,5,9,5,8
+M,5,2,6,3,4,7,6,7,5,7,8,10,8,5,2,9
+H,4,9,6,6,8,7,6,5,3,6,6,8,7,7,8,8
+U,2,3,3,2,1,6,9,5,5,7,9,9,3,10,1,8
+W,1,0,1,0,0,8,8,3,0,7,8,8,3,9,0,8
+N,5,5,5,8,3,7,7,15,2,4,6,8,6,8,0,8
+F,5,10,6,7,6,5,10,3,6,10,10,6,2,10,3,6
+R,4,7,4,5,4,6,8,8,4,6,5,7,2,7,5,11
+V,5,9,7,7,3,5,9,4,1,9,13,8,5,10,2,9
+A,3,8,5,6,3,6,5,3,0,6,1,8,2,6,1,7
+A,3,2,5,4,2,8,2,2,2,7,1,8,2,6,2,7
+R,4,8,6,6,5,7,8,5,6,7,5,7,3,7,5,8
+T,2,0,2,0,0,7,15,2,3,7,10,8,0,8,0,8
+F,4,6,4,8,2,1,14,5,3,12,9,5,0,8,3,6
+T,3,4,4,3,2,7,12,3,5,7,11,8,2,11,1,8
+I,4,10,5,8,3,7,7,0,8,14,6,8,0,8,1,8
+N,4,6,4,4,2,7,7,14,2,5,6,8,6,8,0,8
+X,3,7,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+M,3,7,4,5,3,7,7,11,1,7,9,8,8,6,0,8
+E,4,11,4,8,3,3,7,6,11,7,6,15,0,8,7,7
+N,4,7,4,5,2,7,7,14,2,5,6,8,6,8,0,8
+U,6,8,7,6,4,4,8,5,7,9,8,9,3,9,2,5
+F,3,9,4,7,4,5,10,1,7,10,9,7,1,10,3,6
+V,4,5,5,4,2,4,13,4,4,10,11,7,3,10,1,8
+J,4,10,5,7,3,9,7,2,6,14,4,8,0,7,1,7
+E,4,9,6,7,4,4,10,5,8,11,10,9,2,8,5,3
+M,6,11,9,8,11,7,8,6,4,7,6,8,6,9,9,8
+R,5,9,8,6,5,11,6,3,6,11,1,6,4,5,4,10
+L,5,10,6,8,5,3,4,5,7,2,0,7,1,6,1,6
+V,6,9,6,6,3,3,11,4,4,10,12,8,2,10,1,8
+R,1,0,2,0,1,6,10,7,2,7,5,8,2,7,4,9
+L,2,5,3,4,2,4,4,4,7,2,1,6,0,7,1,6
+C,4,10,5,7,3,6,8,7,7,13,8,8,2,11,3,7
+F,3,7,4,5,2,1,13,4,3,12,10,6,0,8,2,6
+F,2,3,3,1,1,7,9,2,5,13,6,5,1,9,1,8
+Q,3,6,4,8,4,9,7,7,3,5,7,10,3,9,5,10
+P,2,3,2,1,1,5,10,3,4,10,8,4,0,9,3,7
+V,5,11,7,8,2,8,8,5,3,6,14,8,3,9,0,8
+G,2,0,2,1,1,8,6,6,5,6,5,9,1,8,5,10
+I,1,5,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+W,7,12,7,6,5,4,8,1,3,8,9,8,9,10,2,5
+A,7,10,9,8,8,7,7,7,4,7,6,9,4,8,11,1
+M,5,6,7,4,5,11,6,3,4,9,2,6,7,6,2,8
+C,5,9,4,5,3,7,6,4,4,9,9,11,4,10,9,10
+Z,2,5,4,3,2,7,7,2,9,11,6,8,1,8,5,8
+P,3,8,5,6,4,7,8,5,6,8,7,4,2,10,4,7
+I,5,9,4,5,2,8,8,3,6,13,4,6,1,7,4,9
+P,6,10,8,7,7,7,8,7,4,8,7,9,3,9,8,9
+J,2,10,3,7,1,12,3,10,4,13,5,13,1,6,0,8
+L,3,9,5,7,4,5,5,1,8,4,2,8,3,7,2,6
+C,4,7,5,5,3,3,8,5,7,10,9,14,1,8,3,8
+S,5,8,6,6,4,9,7,4,6,10,3,6,2,7,5,10
+V,3,3,4,2,1,4,12,3,3,9,11,7,2,11,1,8
+L,3,9,3,6,1,0,1,5,6,0,0,7,0,8,0,8
+V,6,11,6,6,3,5,10,4,3,10,8,5,4,11,2,8
+S,4,10,4,5,2,9,3,3,4,9,2,9,3,6,4,9
+F,3,7,4,4,1,2,12,5,5,12,10,8,0,8,2,6
+N,4,9,5,7,5,7,7,13,1,7,6,8,5,8,0,7
+Y,3,4,4,3,2,4,11,2,7,11,10,5,1,11,2,5
+B,3,5,5,3,4,9,7,3,5,10,5,7,2,8,5,9
+W,6,11,9,8,14,9,7,5,2,7,6,8,14,11,3,6
+J,5,10,4,8,3,9,8,2,3,11,6,7,2,10,6,12
+L,2,2,3,3,2,4,4,4,7,2,1,6,1,7,1,6
+U,4,9,6,7,3,7,9,6,7,6,10,9,3,9,1,8
+Z,3,9,4,7,4,8,6,5,9,7,6,6,2,7,7,8
+Q,6,10,8,7,7,8,6,8,4,7,7,7,6,6,8,8
+G,4,5,5,8,2,7,6,8,9,6,5,11,1,8,6,11
+Y,5,10,7,8,4,4,9,1,8,11,12,9,1,11,2,6
+L,3,6,4,4,2,7,3,2,7,7,2,8,1,6,2,7
+J,6,8,4,12,3,10,6,3,4,11,3,5,3,8,7,10
+W,9,10,9,7,9,4,10,2,3,9,8,8,8,11,2,6
+P,2,3,4,2,2,7,10,4,3,11,5,3,1,9,2,8
+R,3,7,5,5,3,10,7,4,6,10,2,7,3,7,4,10
+S,4,6,5,4,3,8,7,3,7,10,6,8,2,8,4,8
+B,6,9,8,7,7,8,8,5,5,7,5,6,4,8,6,7
+P,3,5,6,4,3,7,10,4,4,12,5,3,1,10,3,8
+Z,1,0,1,1,0,7,7,2,10,8,6,8,0,8,6,8
+S,4,8,5,6,3,8,8,6,9,5,6,7,0,8,9,7
+D,3,6,3,4,2,5,8,10,8,8,7,5,3,8,3,8
+B,2,3,3,1,2,8,7,2,5,10,5,7,1,8,4,9
+W,5,9,7,7,7,8,5,7,2,6,7,8,7,7,5,3
+Q,3,6,4,6,2,7,7,7,5,6,7,8,3,7,5,9
+E,3,10,4,7,5,7,7,6,8,8,8,9,3,8,6,9
+W,4,7,6,5,3,9,8,5,1,7,8,8,8,9,0,8
+A,3,11,6,8,2,9,5,3,1,8,1,8,3,7,2,8
+F,3,9,5,7,4,6,10,2,6,10,9,5,1,10,3,6
+T,6,14,5,8,3,6,10,2,6,11,7,6,2,9,5,4
+K,4,6,5,8,2,3,7,8,2,7,5,12,3,8,3,10
+A,3,5,5,3,2,8,2,2,2,7,1,8,2,6,2,7
+K,6,9,9,6,5,5,7,2,8,10,9,11,4,7,4,7
+P,10,15,9,8,6,8,9,4,4,12,4,3,5,10,6,6
+P,3,5,5,4,2,7,10,4,4,12,5,3,1,10,2,8
+R,2,4,4,3,3,8,7,5,4,8,5,7,3,7,4,11
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+Z,4,9,6,6,5,9,10,5,4,6,5,7,3,9,9,4
+J,3,7,5,5,2,7,4,5,4,14,9,14,1,6,1,6
+O,7,11,7,8,7,7,8,8,4,10,7,7,5,8,5,10
+J,4,8,5,6,2,9,6,2,8,15,4,8,0,7,0,8
+T,3,6,4,4,3,6,11,4,5,10,8,5,3,12,2,5
+W,5,7,5,5,5,4,9,2,3,9,8,8,6,11,2,6
+R,5,9,8,8,9,9,7,4,4,8,5,7,9,9,7,5
+P,5,10,5,5,3,9,8,3,5,13,4,4,3,10,6,7
+F,4,10,6,8,4,6,10,3,6,13,7,5,2,10,2,7
+N,7,9,6,5,2,5,9,4,6,3,3,10,5,9,2,7
+J,3,7,4,5,3,8,7,1,6,11,5,8,0,7,1,6
+N,7,10,9,9,9,8,9,4,4,7,4,7,9,6,7,6
+S,3,4,4,6,2,9,8,6,9,5,5,6,0,8,9,7
+A,4,8,7,6,5,9,5,2,5,10,2,6,2,6,3,8
+S,7,13,6,7,3,9,2,2,5,8,1,8,3,7,5,10
+U,7,11,6,6,4,8,6,5,5,6,7,8,5,7,3,7
+A,1,3,2,2,1,9,2,2,1,8,2,8,1,6,1,8
+O,7,10,5,5,3,9,6,5,6,9,3,8,5,8,5,8
+W,5,5,6,3,4,4,11,3,2,9,9,8,7,11,1,7
+Q,4,5,5,7,3,9,9,8,6,5,8,9,3,7,6,10
+K,8,12,9,6,5,10,5,4,6,11,2,7,5,8,4,10
+H,6,7,8,9,7,9,8,3,1,8,6,8,4,9,9,9
+V,2,1,4,2,1,8,12,3,3,5,11,9,2,10,1,8
+C,2,1,3,2,1,6,7,6,9,7,6,14,0,8,4,9
+O,6,10,6,7,4,9,6,8,6,10,3,8,4,8,4,6
+I,1,7,1,5,1,8,7,0,8,7,6,7,0,8,3,7
+I,7,12,5,7,3,10,5,4,5,12,3,7,3,8,5,10
+T,2,2,3,3,2,6,11,3,6,8,11,8,2,11,1,7
+Z,4,5,5,7,4,11,5,4,5,10,3,9,2,6,6,10
+R,4,7,5,5,3,6,9,9,5,6,5,8,2,8,5,10
+I,2,11,2,9,2,7,7,0,8,7,6,8,0,8,3,8
+O,7,10,7,7,6,8,6,7,5,10,5,11,5,7,5,6
+S,4,5,5,4,5,8,7,4,5,7,6,8,5,8,8,11
+L,4,4,4,6,1,0,0,6,6,0,1,5,0,8,0,8
+D,4,8,5,6,4,8,7,6,7,10,4,5,3,8,3,8
+E,5,11,7,8,6,6,8,4,7,11,9,8,3,8,4,6
+Z,4,6,5,4,3,9,6,2,9,11,4,9,1,7,6,10
+L,8,14,6,8,4,5,5,3,8,10,4,13,3,6,6,7
+K,4,6,6,4,4,8,6,1,6,10,5,9,4,7,5,8
+E,4,6,6,4,4,6,8,2,8,11,7,9,2,9,4,8
+K,4,5,5,3,3,5,7,4,7,6,6,11,3,8,5,9
+C,4,7,5,6,6,6,5,4,5,7,5,11,5,10,7,11
+Z,1,3,2,2,1,7,7,5,8,6,6,8,1,8,7,8
+W,4,4,6,6,3,11,8,5,1,6,8,8,8,9,0,8
+M,11,15,10,8,6,8,11,5,5,4,5,9,9,9,2,7
+H,2,1,2,2,2,8,7,6,5,7,6,7,3,8,3,6
+E,2,7,4,5,3,6,7,7,9,8,8,9,2,9,6,8
+D,4,2,5,4,4,7,7,7,7,6,6,5,2,8,3,7
+X,5,8,7,6,3,9,7,2,8,10,4,7,3,8,4,8
+T,5,10,7,8,6,7,11,3,7,7,11,8,2,12,1,8
+D,3,5,5,3,3,10,6,3,6,10,3,6,2,8,2,8
+Q,3,5,3,6,3,8,6,6,4,9,6,9,2,9,4,8
+Q,5,8,6,7,3,8,8,8,7,5,7,9,3,7,5,10
+O,2,3,3,2,2,8,7,6,4,9,5,8,2,8,2,8
+W,6,8,6,6,5,4,10,3,3,9,8,7,7,11,2,6
+E,4,11,6,8,5,7,7,2,8,11,6,10,3,7,5,8
+X,9,14,10,8,5,3,9,4,8,12,11,9,4,8,3,5
+B,4,8,4,6,3,6,7,9,7,7,6,7,2,8,9,10
+U,8,11,9,8,6,4,8,6,8,9,7,9,7,9,6,1
+M,4,7,4,5,3,8,7,12,1,6,9,8,8,6,0,8
+R,2,3,4,2,2,8,8,3,5,9,4,7,2,6,3,10
+P,3,5,5,4,3,7,10,4,4,12,4,3,1,10,3,8
+H,4,11,5,9,5,7,7,13,1,7,6,8,3,8,0,8
+V,4,6,5,6,6,7,8,5,5,7,6,8,6,8,6,6
+Z,2,5,3,4,2,7,7,5,9,6,6,8,2,8,7,8
+F,1,1,2,1,0,2,12,4,3,11,9,6,0,8,2,7
+C,7,10,8,8,5,4,8,6,7,12,10,12,2,11,3,7
+R,3,4,3,3,3,7,7,5,5,6,5,7,3,7,4,8
+D,4,6,6,6,5,6,7,5,6,6,5,7,4,7,5,5
+V,3,7,5,5,1,5,8,5,3,9,14,8,3,10,0,8
+Y,6,8,6,6,3,4,10,3,7,11,11,5,1,11,3,4
+O,3,9,4,7,4,7,6,8,5,6,4,8,3,8,3,7
+P,9,14,7,8,3,8,8,7,4,14,3,5,5,10,4,8
+I,2,6,3,4,2,7,7,0,8,13,6,8,0,8,1,8
+Q,6,9,7,11,9,8,4,8,4,6,5,7,5,8,7,11
+E,6,13,5,7,4,6,8,5,5,10,6,9,3,8,8,11
+K,6,11,9,9,6,8,7,2,7,10,4,8,4,7,4,8
+F,3,5,5,4,2,6,11,2,6,14,7,4,1,10,2,7
+G,3,4,4,3,2,6,7,5,5,9,7,10,2,9,4,9
+A,4,10,6,7,2,9,4,3,2,8,1,8,3,7,3,8
+R,1,0,1,1,0,6,8,7,3,7,5,8,2,7,4,11
+L,5,11,5,6,3,6,6,3,6,11,6,11,3,7,6,8
+O,5,10,6,7,5,8,6,8,7,8,4,10,4,9,5,6
+U,3,6,5,4,2,7,9,6,7,5,10,9,3,9,1,8
+P,2,4,2,2,1,5,10,4,4,10,8,4,1,10,3,7
+J,2,4,2,6,1,11,3,10,3,13,7,13,1,6,0,8
+X,4,11,7,8,6,8,8,2,6,7,6,6,6,10,9,8
+N,3,5,5,3,2,5,9,2,4,11,8,8,5,8,0,7
+M,6,10,9,7,6,11,6,2,5,9,3,6,9,8,2,9
+Z,4,9,5,7,5,7,8,5,9,7,7,8,1,8,7,8
+X,3,5,5,4,2,9,6,1,8,10,4,8,2,8,3,9
+M,4,7,5,5,4,9,6,6,5,6,8,6,8,5,2,7
+C,3,9,4,7,3,6,8,8,7,10,7,12,2,10,4,10
+T,2,5,3,4,2,7,12,3,6,7,11,8,2,11,1,8
+A,2,4,4,3,2,10,2,2,2,9,2,9,2,6,2,8
+Z,3,6,5,4,5,7,8,2,7,7,6,8,0,8,8,8
+F,3,7,4,5,3,4,10,3,5,10,10,6,1,10,3,6
+Z,8,12,8,6,5,10,3,4,7,12,3,11,3,6,7,11
+S,3,7,5,5,6,6,6,3,1,7,5,6,2,8,10,3
+O,5,7,6,5,7,8,7,5,1,7,6,8,8,8,5,10
+P,1,3,3,1,1,7,9,4,3,11,5,4,1,9,2,8
+E,3,4,3,7,2,3,7,6,10,7,6,15,0,8,7,7
+L,8,14,7,8,3,8,3,3,5,12,4,13,3,7,6,8
+I,7,15,5,8,3,10,5,6,4,13,3,7,3,8,5,10
+Y,6,6,5,9,3,7,9,2,2,7,10,5,4,10,5,6
+D,2,4,3,3,2,9,6,4,5,10,4,5,2,8,2,8
+K,7,10,10,8,8,4,8,1,7,10,8,10,3,8,4,7
+W,4,5,5,4,4,4,10,3,2,9,8,7,6,11,1,7
+M,5,9,8,7,8,8,7,6,5,6,7,8,8,6,2,8
+S,6,10,6,5,3,11,3,4,3,12,5,9,2,10,2,9
+Z,3,3,4,5,2,7,7,4,14,9,6,8,0,8,8,8
+V,3,7,5,5,2,7,12,3,4,6,11,9,2,10,1,8
+F,4,9,6,6,5,7,9,3,6,12,6,6,3,9,3,7
+I,5,11,4,6,2,10,6,2,5,11,4,6,2,9,4,11
+Z,3,7,5,5,5,8,8,6,3,6,4,6,3,9,8,3
+I,3,5,5,6,4,8,7,4,6,6,6,7,3,9,8,9
+C,6,11,8,8,9,8,6,5,3,8,7,11,10,8,6,5
+G,2,1,2,2,1,7,7,6,5,6,6,10,2,9,4,9
+Q,7,8,9,12,13,8,10,5,1,5,7,10,7,14,8,13
+D,5,10,6,7,3,5,7,10,9,7,6,5,3,8,4,8
+X,3,6,5,4,3,8,7,3,8,6,6,8,2,8,6,8
+R,9,11,7,6,4,8,7,5,5,10,3,8,6,6,6,11
+I,1,8,2,6,2,7,7,0,7,7,6,8,0,8,2,8
+T,7,11,7,8,6,6,12,5,5,11,8,4,3,12,2,4
+V,5,9,5,7,2,2,11,5,4,12,12,8,2,10,1,8
+N,2,4,3,3,2,6,8,5,4,7,7,7,5,9,1,6
+Y,8,10,8,8,4,2,12,5,5,13,12,6,1,11,2,5
+T,4,11,5,8,3,9,14,0,5,6,10,8,0,8,0,8
+U,3,4,4,3,2,7,8,5,6,5,9,9,5,10,1,7
+X,3,3,5,2,2,7,8,1,8,10,7,8,2,8,3,7
+I,1,8,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+M,6,10,8,8,9,8,7,5,5,6,7,7,11,7,4,6
+N,3,8,4,6,2,7,7,14,2,5,6,8,5,8,0,8
+N,5,9,8,7,5,4,10,3,3,9,9,9,6,7,2,7
+C,7,11,9,8,6,7,7,8,6,6,7,11,4,7,4,9
+B,4,10,6,8,7,8,7,4,7,6,6,6,6,8,6,10
+P,2,6,2,4,2,5,11,8,2,10,6,4,1,10,3,8
+O,4,9,6,7,4,7,7,8,4,7,6,11,3,8,4,7
+I,1,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+K,6,9,9,7,5,3,9,3,7,11,11,11,3,8,3,5
+T,6,9,7,8,7,6,8,4,9,8,8,8,3,10,8,7
+P,6,11,6,8,3,4,13,9,2,10,6,3,1,10,4,8
+G,4,9,5,7,3,6,7,7,8,9,8,10,2,10,4,9
+U,12,15,10,8,5,5,3,4,5,4,7,6,6,6,2,7
+K,4,8,6,6,5,4,7,1,6,10,9,11,3,8,3,6
+D,5,8,6,6,5,7,8,4,7,7,6,8,7,8,3,7
+E,4,9,6,7,4,5,8,3,9,10,8,10,2,8,4,6
+I,6,15,4,8,3,11,5,4,5,12,2,7,3,8,5,10
+V,4,6,4,4,2,3,12,4,3,11,11,7,2,10,1,7
+V,5,9,7,7,5,8,11,3,2,5,10,9,5,10,5,8
+U,4,9,6,7,3,6,8,6,7,7,10,9,3,9,1,8
+D,4,8,5,6,4,7,7,7,7,7,6,4,3,8,3,7
+U,7,9,8,7,3,3,10,6,7,13,11,8,3,9,1,7
+O,5,10,7,8,3,9,6,9,8,7,5,10,3,8,4,8
+P,3,5,5,3,3,8,10,3,4,12,4,2,1,10,3,8
+D,4,10,5,8,5,7,7,6,7,7,7,5,6,8,3,7
+J,3,11,5,8,5,8,7,1,6,11,5,9,1,6,1,6
+G,4,5,5,8,3,8,7,8,7,6,7,8,2,7,6,11
+O,5,5,6,7,3,8,7,8,8,6,7,9,3,8,4,8
+Z,3,4,5,6,4,10,7,5,5,8,3,7,3,6,6,7
+C,5,7,6,5,6,5,6,4,4,7,7,9,5,10,4,8
+H,7,10,9,8,6,10,6,3,6,10,3,7,5,6,5,9
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+D,3,3,3,5,2,5,7,10,7,7,6,5,3,8,3,8
+H,6,8,9,10,9,7,5,4,3,6,4,7,7,7,10,9
+A,5,10,5,5,3,11,2,4,1,11,4,11,4,3,4,10
+D,3,4,4,3,2,7,7,7,7,7,6,5,2,8,3,7
+H,3,6,4,4,4,8,7,6,6,7,6,8,3,8,3,8
+R,4,9,5,6,5,7,8,5,5,8,5,8,3,6,6,9
+O,2,1,3,2,2,7,7,7,4,7,6,8,2,8,2,8
+O,7,10,7,8,5,7,7,8,6,10,7,9,3,8,4,7
+E,4,9,4,6,3,3,7,6,11,7,6,15,0,8,7,7
+F,4,11,5,8,2,1,12,5,4,11,10,7,0,8,3,6
+T,2,0,2,1,0,8,15,2,4,6,10,8,0,8,0,8
+B,4,6,5,4,5,7,6,6,7,6,6,6,2,9,6,10
+G,2,5,3,3,2,6,7,6,6,6,6,11,2,9,4,9
+F,3,3,3,4,1,1,14,5,3,12,10,5,0,8,2,6
+Q,9,15,8,8,6,12,4,3,6,10,4,7,4,9,6,12
+A,6,9,5,5,3,8,3,3,2,7,4,12,5,5,4,7
+B,4,9,4,7,3,6,7,9,7,7,6,7,2,8,9,10
+Q,3,3,4,4,3,8,8,6,3,5,7,10,3,8,5,9
+T,1,1,2,1,0,7,14,1,4,7,10,8,0,8,0,8
+A,3,7,5,5,3,6,3,2,2,4,2,7,2,5,2,6
+M,4,10,5,8,6,8,5,11,1,6,8,8,8,5,1,5
+V,4,6,5,4,6,8,6,4,2,8,7,9,7,9,4,8
+E,4,7,5,5,5,7,7,5,8,6,5,9,3,8,6,9
+H,7,11,10,8,9,9,7,3,6,10,4,7,5,6,4,9
+Q,2,4,3,5,2,8,7,5,2,8,7,9,2,10,3,9
+G,5,9,4,5,3,7,9,4,3,8,6,5,3,10,9,7
+H,2,3,4,2,2,6,9,3,6,10,7,8,3,8,3,8
+H,4,6,4,4,2,7,5,14,1,7,9,8,3,9,0,8
+M,6,9,9,6,7,9,6,2,5,9,5,7,8,6,2,8
+O,6,10,8,8,9,7,8,6,2,7,6,7,10,9,6,10
+J,2,3,3,5,1,11,2,10,3,13,8,14,1,6,0,8
+Z,5,10,6,7,3,7,7,4,15,9,6,8,0,8,8,8
+F,4,8,6,6,4,6,10,3,7,10,9,5,2,10,4,5
+B,5,10,7,8,7,8,7,7,6,6,6,5,2,8,7,9
+T,6,10,6,6,2,6,9,3,8,13,6,5,2,9,4,5
+T,3,7,4,4,1,8,15,1,5,6,11,9,0,8,0,8
+O,4,8,4,6,3,7,7,8,5,9,7,10,3,8,3,7
+I,5,10,6,8,4,6,6,2,7,7,6,10,0,9,4,8
+D,3,6,3,4,2,6,8,9,8,8,7,6,3,8,3,8
+D,4,6,5,4,4,8,7,5,5,10,5,5,3,8,3,8
+Q,2,3,3,3,2,8,8,6,2,5,7,10,2,9,5,10
+W,6,10,6,7,6,3,11,2,2,10,9,8,6,11,2,7
+A,4,9,6,7,6,8,9,8,5,6,5,8,3,6,7,5
+I,2,8,3,6,2,6,8,0,6,13,7,7,0,8,1,7
+M,4,5,5,8,4,7,7,12,2,7,9,8,8,6,0,8
+L,4,9,6,6,6,5,7,3,6,8,7,11,7,11,6,7
+O,4,8,5,6,4,8,7,8,5,7,7,9,3,8,3,8
+I,4,8,5,6,3,9,8,2,8,7,6,5,0,8,4,7
+Q,4,8,5,9,5,8,7,7,3,8,7,10,3,9,6,8
+G,4,6,4,4,2,6,7,6,6,9,8,10,2,8,4,9
+Q,2,3,3,4,2,8,8,5,2,8,8,10,2,9,4,8
+C,4,11,5,8,2,5,7,7,10,7,7,13,1,8,4,9
+H,2,4,3,3,2,8,8,6,6,7,5,7,3,8,3,7
+R,1,0,1,0,0,6,10,6,1,7,5,8,1,7,4,10
+Z,2,5,3,4,2,7,8,5,9,6,6,9,2,9,7,8
+A,3,6,6,4,3,7,5,2,3,6,2,6,2,6,3,5
+D,3,6,4,4,4,7,7,4,7,7,6,6,3,8,3,7
+Y,3,10,5,7,1,7,10,2,2,7,13,8,1,11,0,8
+A,7,11,5,6,3,10,0,2,2,10,4,12,3,4,3,8
+P,6,11,8,9,6,8,9,3,5,13,5,3,1,10,3,8
+Z,2,4,4,3,2,7,8,2,9,11,6,8,1,9,5,8
+O,3,5,4,3,2,7,7,7,5,9,7,8,2,8,3,8
+I,2,10,2,7,2,7,7,0,8,7,6,8,0,8,3,8
+R,4,8,6,6,6,7,7,3,7,7,6,6,6,8,4,9
+J,3,8,4,6,3,9,6,2,6,12,3,8,1,6,2,6
+F,3,7,5,5,3,9,9,2,6,13,5,4,1,10,3,9
+X,4,10,5,8,3,7,7,4,4,7,6,8,3,8,4,8
+E,2,5,4,3,2,6,7,2,8,11,7,9,2,8,4,8
+L,2,5,3,4,1,7,3,1,7,8,2,10,0,7,2,8
+S,3,6,4,4,2,7,7,5,8,5,6,9,0,9,9,8
+H,3,2,5,4,4,8,7,6,6,7,6,7,3,8,3,7
+E,5,10,7,9,8,7,7,5,3,7,7,9,6,10,10,12
+E,4,5,5,8,3,3,7,6,11,7,6,15,0,8,7,7
+U,3,7,4,5,3,6,8,6,6,6,9,9,3,9,0,8
+I,0,3,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+B,3,2,4,3,4,7,7,5,5,7,6,6,2,8,6,9
+T,2,3,3,4,1,8,13,0,6,6,11,8,0,8,0,8
+B,2,4,4,3,3,9,7,2,6,11,5,6,2,8,4,9
+Q,4,7,6,7,3,8,8,7,6,5,7,8,3,8,5,9
+Y,4,8,6,6,2,4,10,2,8,10,13,9,1,11,2,7
+H,5,9,7,7,9,8,9,5,3,7,6,6,9,8,9,7
+L,1,4,3,3,1,7,3,1,7,8,2,10,0,7,2,8
+B,2,3,2,1,2,7,7,5,5,7,6,6,1,8,5,9
+R,4,6,6,4,5,8,7,7,3,8,5,7,4,7,7,10
+Q,2,4,3,5,3,8,9,6,2,5,8,10,3,9,5,10
+X,2,3,3,2,1,8,7,3,8,6,6,8,2,8,5,8
+M,3,6,4,4,2,7,7,11,1,7,9,8,8,6,0,8
+I,4,6,6,7,5,8,8,5,6,7,6,8,3,8,8,7
+O,4,6,5,4,6,7,9,5,2,7,7,8,8,9,4,9
+B,6,10,5,6,3,8,6,4,5,10,5,8,6,7,7,10
+V,5,9,7,8,9,7,6,5,4,6,5,8,7,10,7,9
+Z,2,4,3,3,2,8,7,5,9,6,6,7,2,8,7,8
+K,6,10,8,8,6,5,6,1,7,10,8,10,3,8,4,8
+M,4,8,6,6,6,7,7,2,4,9,7,8,7,6,2,8
+L,3,5,4,4,3,8,9,4,5,6,6,9,3,8,7,10
+R,5,8,7,6,5,8,7,6,6,8,6,8,3,8,6,11
+G,2,1,3,2,2,7,6,6,5,6,6,10,2,9,4,9
+X,4,9,6,7,4,7,7,4,9,6,6,8,3,8,7,8
+N,5,9,8,7,5,7,9,2,4,10,5,6,5,9,1,7
+P,1,3,3,1,1,7,9,4,3,11,5,4,1,9,2,8
+L,6,9,5,4,2,8,3,3,4,11,4,13,2,6,6,8
+Z,4,6,6,8,4,11,4,3,5,10,2,8,2,7,5,11
+Z,5,8,7,6,5,8,7,2,9,11,5,8,1,7,6,8
+S,3,7,4,5,3,8,7,7,6,8,6,8,2,8,9,8
+F,3,4,5,3,2,7,9,2,6,13,6,5,1,9,2,7
+Y,3,2,5,3,2,5,10,1,7,9,12,9,1,11,2,7
+L,3,7,3,5,1,0,1,6,6,0,0,6,0,8,0,8
+E,5,11,7,8,6,7,7,2,7,11,7,9,3,8,4,8
+L,3,6,5,4,5,7,8,3,5,6,7,10,5,11,5,6
+X,3,7,5,5,3,4,8,1,7,10,11,9,2,9,3,5
+Q,7,12,6,6,5,11,4,4,6,10,4,7,3,9,7,12
+S,8,13,6,8,3,9,3,4,5,9,2,9,4,6,5,9
+D,7,11,9,8,7,7,7,5,6,7,6,8,7,8,3,7
+Z,5,9,6,7,3,7,7,4,15,9,6,8,0,8,8,8
+Q,4,6,4,8,5,8,10,5,1,5,8,11,2,10,5,10
+M,7,11,11,8,15,9,7,3,3,8,5,7,12,4,5,5
+M,3,6,4,4,2,8,6,12,1,5,9,8,7,6,0,8
+F,4,7,5,5,3,6,10,3,5,13,7,5,2,10,2,8
+E,2,3,2,4,1,3,8,6,10,7,5,15,0,8,6,8
+W,3,6,4,4,4,8,7,6,2,6,8,9,5,8,3,7
+W,4,2,6,3,3,7,11,2,2,6,9,8,7,11,0,8
+B,3,7,5,6,6,7,7,5,4,7,6,8,6,9,7,7
+A,2,9,4,6,2,6,5,3,1,6,0,8,2,7,2,7
+V,6,9,6,7,3,4,11,3,4,9,11,7,2,10,1,8
+L,4,9,5,7,4,7,4,1,7,8,2,9,1,6,2,8
+T,4,6,5,4,2,6,12,3,7,12,9,4,2,11,2,4
+Z,1,3,3,2,1,7,7,2,9,11,6,8,1,8,5,7
+J,4,7,6,8,5,9,9,5,4,6,6,9,3,7,8,6
+P,4,10,6,7,4,5,11,7,4,10,7,3,1,10,4,7
+M,4,1,5,2,3,7,6,7,4,7,7,10,7,6,2,8
+T,4,9,6,7,4,8,10,1,8,6,11,7,0,10,1,7
+G,4,10,5,7,4,7,7,7,6,6,5,8,1,7,6,11
+E,4,6,6,4,4,10,6,1,7,11,4,8,3,8,4,11
+G,3,7,4,5,3,7,7,7,6,6,5,9,1,8,5,11
+G,3,9,4,6,4,7,6,7,6,6,5,8,1,7,6,11
+V,4,8,6,6,7,7,7,4,1,8,7,9,7,10,4,7
+F,2,1,3,2,2,6,9,3,5,10,9,5,4,10,3,7
+K,4,6,6,4,5,8,8,5,4,7,6,7,7,6,6,11
+I,3,11,4,8,2,6,8,0,8,13,7,8,0,8,1,7
+Q,2,2,3,3,2,8,8,5,2,7,7,10,2,9,4,9
+U,6,10,5,5,3,4,4,4,5,4,7,7,4,6,2,8
+X,4,5,5,5,5,9,7,2,4,8,5,7,3,8,7,8
+G,3,5,5,5,4,7,10,5,2,7,7,8,6,11,7,8
+K,8,10,11,8,8,7,7,1,7,10,5,9,5,7,4,7
+J,1,3,2,1,0,8,7,2,4,14,6,9,0,7,0,7
+R,3,8,5,6,4,6,7,5,6,6,5,7,3,7,5,8
+A,4,11,6,8,2,7,6,3,1,7,0,8,3,7,1,8
+G,5,8,7,7,7,7,10,5,2,7,7,8,6,11,6,8
+Y,8,8,7,12,5,6,5,6,5,6,11,7,5,10,4,7
+G,2,5,3,3,2,6,7,5,5,10,7,10,2,9,4,9
+M,5,11,5,8,7,7,5,11,1,8,8,8,9,5,2,10
+D,4,11,6,8,7,8,7,5,6,7,7,4,3,8,3,6
+Y,9,8,8,12,5,10,11,1,4,7,10,5,4,10,5,10
+L,4,9,5,7,4,4,5,3,9,3,1,9,0,7,2,6
+A,4,10,7,7,2,7,7,3,0,6,0,8,2,7,2,8
+R,3,7,4,5,2,6,12,8,4,7,2,9,3,7,5,10
+Y,5,7,6,5,5,8,5,7,6,5,8,8,3,9,9,5
+S,4,8,5,6,2,8,7,5,8,5,6,8,0,8,9,8
+C,5,8,7,6,4,7,8,8,6,4,7,13,5,8,4,8
+B,2,0,2,1,1,7,8,7,5,7,6,7,1,8,7,8
+B,3,5,4,4,4,8,7,5,6,7,6,6,5,8,5,9
+F,4,9,5,6,5,6,10,6,4,8,6,8,2,10,7,10
+R,6,9,8,7,6,10,7,3,6,11,3,7,5,6,5,10
+H,4,6,6,8,6,8,12,4,2,8,7,6,3,11,7,5
+D,2,4,4,3,3,9,6,4,6,10,4,6,2,8,3,8
+S,6,9,7,6,4,9,7,4,8,11,5,8,2,8,5,9
+A,3,5,5,4,2,7,2,1,2,6,2,8,3,5,3,7
+R,2,7,3,4,2,5,10,8,4,7,4,9,3,7,5,11
+P,3,2,4,4,2,5,10,4,4,10,8,4,1,10,3,6
+D,4,8,4,6,2,5,8,10,8,8,7,5,3,8,4,8
+T,8,10,8,8,4,6,13,5,6,12,8,2,2,12,2,4
+L,2,3,2,2,1,4,3,4,6,2,2,5,0,7,0,6
+D,5,10,5,6,4,9,6,3,5,8,5,7,6,9,5,8
+Y,6,9,6,7,3,4,9,2,8,10,11,6,2,10,4,3
+F,3,5,5,4,2,5,10,2,6,13,7,5,1,9,2,7
+Y,2,5,4,4,2,7,10,1,6,7,11,8,1,11,2,8
+F,4,4,4,6,2,1,14,5,3,12,9,5,0,8,3,6
+G,5,8,6,6,5,7,7,7,5,4,7,9,3,6,5,8
+U,5,7,5,5,2,4,8,6,8,9,9,9,3,9,2,4
+Q,4,7,5,6,2,8,7,8,6,6,7,8,3,8,5,9
+B,8,12,7,6,6,8,7,5,5,9,7,8,7,8,9,7
+Q,2,3,3,4,3,8,7,7,3,6,7,9,2,8,5,9
+Z,3,7,5,5,3,8,7,2,9,11,5,8,1,7,6,8
+T,3,7,5,5,5,7,8,4,5,7,7,9,5,9,5,7
+S,3,9,4,6,2,8,9,6,10,5,5,5,0,7,9,7
+U,6,8,7,6,3,4,8,7,8,9,9,9,3,9,3,5
+D,4,8,4,6,3,6,7,10,9,7,6,6,3,8,4,8
+X,3,8,5,6,4,7,7,3,8,6,7,10,3,7,7,8
+R,4,9,6,7,6,7,9,5,6,8,4,8,3,6,5,11
+U,6,10,7,7,5,3,8,5,7,9,8,10,5,8,3,4
+D,4,9,5,7,5,5,7,9,6,6,6,6,2,8,3,8
+C,6,8,6,6,3,5,8,6,8,13,9,9,2,11,2,7
+H,4,9,4,7,4,7,8,13,1,7,5,8,3,8,0,8
+I,1,4,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+L,4,9,5,7,4,9,4,1,7,9,2,10,1,6,3,9
+Y,3,4,5,6,6,9,7,5,3,7,7,7,6,9,6,4
+X,4,8,7,6,4,6,7,1,8,10,8,9,3,8,3,7
+L,3,8,3,6,1,0,1,6,6,0,0,6,0,8,0,8
+I,2,8,5,6,5,11,6,1,6,9,4,5,1,7,5,8
+G,4,5,5,4,3,7,7,6,7,9,6,11,2,10,5,9
+T,8,11,9,8,6,7,9,2,9,10,9,5,2,9,5,5
+E,3,5,5,4,3,5,8,3,9,11,8,10,2,8,4,7
+R,2,0,2,1,1,6,10,7,2,7,5,8,2,7,4,10
+M,4,7,5,5,4,8,6,10,0,6,8,8,7,5,0,8
+T,6,10,8,7,9,8,8,5,6,6,7,9,8,7,9,5
+X,4,8,6,6,3,7,7,1,8,10,6,8,3,8,4,7
+I,3,7,4,5,2,7,9,0,7,13,6,6,0,9,2,7
+C,4,7,5,5,3,5,8,7,7,8,8,14,2,9,4,10
+U,5,8,6,6,2,7,4,13,6,8,15,8,3,9,0,8
+M,7,9,10,6,7,5,6,3,5,9,10,10,8,5,2,7
+O,3,1,4,3,2,7,7,7,5,7,6,8,2,8,3,8
+J,2,9,2,6,2,13,4,5,4,13,2,9,0,7,0,8
+W,3,4,4,3,3,6,10,4,2,8,7,7,6,12,1,6
+A,2,7,4,5,2,8,4,2,1,7,1,8,2,6,1,8
+C,1,0,1,0,0,7,7,5,7,7,6,13,0,8,4,10
+I,2,7,3,5,2,8,6,0,7,13,6,9,0,8,1,8
+D,8,15,7,8,6,10,5,4,7,10,4,7,6,7,9,8
+O,2,3,3,2,2,7,7,6,4,9,6,8,2,8,2,8
+U,6,10,9,8,11,9,7,4,5,6,7,7,9,7,6,6
+A,4,11,7,8,4,12,4,3,3,9,1,9,3,8,3,9
+N,2,5,4,3,2,7,8,2,4,10,5,6,5,9,0,7
+J,2,8,3,6,2,14,4,4,4,13,2,9,0,7,0,8
+G,4,5,5,8,2,8,6,9,8,6,6,12,2,8,5,10
+V,4,11,6,8,8,7,5,5,2,8,7,8,6,9,5,8
+A,3,11,5,8,4,11,4,2,3,9,2,9,3,7,3,7
+D,4,10,6,8,5,8,7,7,7,9,4,5,3,8,4,9
+D,3,8,4,6,2,5,7,10,8,6,5,5,3,8,4,8
+L,3,8,4,6,3,8,4,1,7,9,2,10,1,6,3,9
+A,6,11,6,6,4,12,3,5,2,11,3,10,6,4,4,10
+Q,3,7,4,6,2,8,6,9,6,6,4,8,3,8,4,8
+D,2,5,3,3,2,9,6,3,5,10,4,7,3,7,2,8
+R,4,7,7,6,7,7,7,3,3,7,5,8,6,8,6,6
+E,3,6,4,4,4,6,7,5,7,7,6,9,3,8,5,10
+O,3,3,5,5,2,8,6,8,8,7,4,8,3,8,4,8
+W,3,2,5,3,3,8,11,3,2,6,9,8,7,11,1,7
+T,2,1,3,1,0,8,15,2,4,6,10,8,0,8,0,8
+Z,3,6,4,4,3,8,7,5,10,7,5,8,2,9,8,8
+S,6,8,7,6,4,7,8,4,8,10,7,7,2,9,5,7
+G,2,5,3,3,2,6,7,5,5,9,7,10,2,9,4,9
+R,4,4,5,6,3,5,12,8,4,7,3,9,3,7,6,11
+H,1,1,2,1,1,7,8,11,1,7,5,8,3,8,0,8
+E,5,9,7,7,7,8,10,7,4,6,6,11,5,8,8,9
+Y,4,6,6,4,5,8,5,6,5,8,7,8,5,8,4,6
+E,3,7,3,5,3,3,8,4,8,7,6,13,0,8,6,9
+K,6,9,9,6,5,9,6,2,7,10,3,8,6,8,6,10
+B,4,4,4,6,3,6,7,9,7,7,6,7,2,8,9,10
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+K,4,5,6,4,3,4,8,2,8,10,10,11,4,7,3,6
+D,3,6,4,4,6,8,8,5,4,7,6,6,3,7,8,5
+I,2,11,2,8,4,7,7,0,7,7,6,8,0,8,3,8
+H,3,7,4,5,3,7,7,13,1,7,7,8,3,8,0,8
+L,3,6,5,4,3,6,4,0,8,8,3,11,0,8,2,8
+E,3,10,4,8,2,3,8,6,11,7,5,15,0,8,7,7
+W,5,11,8,8,8,5,11,2,2,7,8,8,7,12,1,8
+S,3,5,5,4,2,8,7,3,8,11,5,7,1,9,5,8
+N,2,6,3,4,3,7,7,11,1,6,6,8,5,9,0,8
+V,5,10,5,7,3,3,11,3,4,10,12,8,2,10,1,8
+W,5,4,7,6,3,6,8,5,1,7,8,8,9,9,0,8
+W,4,6,7,4,4,7,9,4,0,7,9,8,7,12,0,8
+Z,6,8,8,10,7,11,5,4,5,8,2,6,2,7,7,8
+B,8,12,7,6,6,8,8,4,5,9,5,7,7,5,8,7
+L,2,7,3,5,2,5,5,2,8,3,2,7,0,7,1,5
+L,2,5,3,3,1,7,4,1,6,8,2,10,1,6,2,8
+B,4,7,7,6,7,8,8,4,4,7,6,8,6,8,8,5
+F,1,0,1,0,0,3,12,4,2,11,9,6,0,8,2,7
+I,2,10,5,8,5,10,7,2,5,9,5,5,3,8,6,7
+G,9,13,8,7,4,11,3,3,4,10,2,6,4,7,4,11
+F,6,10,9,7,9,8,6,1,6,9,7,7,6,10,4,7
+B,4,6,4,4,3,6,6,8,7,6,6,7,2,8,9,10
+G,3,4,4,3,2,6,6,6,6,6,6,11,2,9,4,9
+U,4,5,5,4,2,6,8,6,8,6,10,9,3,9,1,7
+P,4,6,6,9,8,6,6,5,3,7,6,6,9,13,6,10
+W,9,10,9,7,6,6,10,5,3,8,6,6,11,12,4,4
+A,3,8,5,6,3,11,2,2,2,9,2,9,2,6,3,7
+P,5,9,7,7,5,7,11,6,3,11,5,2,2,11,3,8
+T,8,11,8,8,4,5,14,7,4,11,8,3,2,12,1,4
+U,5,7,5,5,2,4,9,5,7,12,11,8,3,9,1,7
+J,1,6,2,4,2,9,7,0,6,10,5,7,0,7,0,7
+F,6,10,9,7,5,4,12,5,5,13,8,4,2,10,2,5
+O,5,7,6,5,7,8,7,5,2,7,6,8,8,9,4,9
+P,6,11,9,8,7,8,9,4,5,12,5,3,4,10,4,7
+O,6,10,7,8,3,7,10,9,9,8,8,6,3,8,4,8
+A,2,1,3,1,0,7,4,2,0,7,2,8,2,7,1,8
+R,7,13,7,8,5,10,5,2,5,9,4,8,6,8,6,9
+N,4,10,4,8,3,7,7,14,2,5,6,8,6,8,0,8
+R,12,14,9,8,5,9,7,6,5,10,2,8,7,5,6,10
+T,2,7,4,4,1,7,15,1,5,7,11,8,0,8,0,8
+O,2,0,2,1,1,8,7,7,5,7,6,8,2,8,3,8
+M,5,6,8,4,4,9,5,3,5,9,4,7,8,6,2,8
+V,1,0,2,1,0,7,9,3,2,7,12,8,2,10,0,8
+U,1,0,2,0,0,7,5,10,4,7,13,8,3,10,0,8
+T,3,4,4,3,2,5,11,2,7,11,9,5,1,11,2,5
+N,1,0,2,1,0,7,7,11,0,5,6,8,4,8,0,8
+Y,5,8,5,6,2,3,11,3,7,13,11,6,1,10,2,5
+G,2,3,3,1,1,7,7,5,5,9,6,9,2,9,4,10
+K,2,3,4,2,2,5,8,2,7,10,8,9,3,8,2,7
+I,3,9,4,7,2,7,7,0,8,14,6,8,0,8,1,8
+L,2,1,3,3,1,5,2,6,7,1,3,2,1,7,1,5
+R,4,9,6,7,6,9,7,4,5,10,4,7,3,6,4,10
+V,7,9,7,5,3,6,9,5,3,8,7,5,5,12,3,9
+I,3,7,4,5,1,8,5,0,8,14,6,10,0,7,1,8
+K,6,11,6,8,3,4,8,9,2,7,5,11,4,8,2,11
+Q,5,5,7,5,5,7,4,4,5,7,3,8,4,5,4,8
+P,4,8,5,6,2,4,11,9,4,9,6,5,2,10,4,8
+T,5,10,5,7,4,5,11,2,8,11,10,5,1,11,3,4
+W,5,10,8,7,12,7,7,6,2,7,7,8,13,12,4,10
+B,5,8,7,6,6,9,6,4,6,10,5,7,2,8,5,10
+U,3,2,5,3,2,7,8,5,7,5,9,9,5,10,1,7
+A,6,14,5,8,4,9,4,3,2,8,4,11,6,6,4,8
+Q,5,6,6,9,7,10,13,4,2,4,8,12,4,14,5,10
+E,5,11,5,8,6,3,7,5,9,7,7,14,0,8,6,8
+L,3,9,5,6,3,8,3,3,6,8,2,8,1,6,2,8
+M,14,14,14,8,7,7,10,5,5,4,4,11,11,13,2,7
+U,4,9,4,6,2,7,5,14,5,7,14,8,3,9,0,8
+I,2,6,4,4,3,10,7,2,4,8,5,5,3,9,5,7
+D,3,5,5,4,3,9,6,4,6,10,4,6,2,8,3,8
+H,9,15,8,8,5,11,7,4,5,9,3,4,6,8,4,8
+D,3,8,5,6,5,8,7,7,6,8,4,5,4,9,4,8
+P,3,9,4,6,2,4,11,9,3,9,6,4,1,10,4,8
+H,9,12,8,6,4,6,6,6,4,9,11,10,7,11,5,9
+Q,4,10,6,9,3,8,7,8,6,6,7,9,3,7,5,9
+G,2,3,3,2,1,7,7,6,6,6,6,10,2,9,4,9
+Z,2,3,4,2,2,8,7,2,9,12,6,8,1,8,5,8
+Z,3,6,4,4,2,7,7,3,14,9,6,8,0,8,8,8
+Z,4,11,5,8,2,7,7,4,14,10,6,8,0,8,8,8
+J,5,10,7,8,4,6,8,3,6,15,7,10,3,7,3,7
+N,9,12,8,6,3,7,10,5,6,3,4,10,5,9,2,7
+X,4,5,6,3,3,7,7,1,9,10,6,8,2,8,3,7
+Z,4,6,6,8,4,12,4,3,5,11,2,8,2,7,5,12
+Y,5,8,5,6,3,3,10,3,6,12,12,7,1,11,2,5
+Z,3,10,4,8,2,7,7,4,14,10,6,8,0,8,8,8
+N,5,10,6,7,4,6,8,6,5,7,7,9,6,8,2,6
+C,2,3,2,1,1,5,8,5,6,11,9,11,1,9,3,8
+B,4,7,6,5,6,9,6,4,6,10,5,7,2,8,5,10
+O,1,3,2,2,1,8,7,6,3,9,6,8,2,8,2,8
+P,3,6,4,4,3,4,10,4,5,10,9,4,1,10,3,7
+C,3,3,4,5,2,6,6,7,9,9,5,13,1,9,4,8
+M,4,8,5,6,5,8,6,6,4,6,7,8,8,5,2,7
+A,4,10,6,8,4,7,5,3,1,7,1,8,2,7,2,8
+A,3,9,5,6,3,10,3,2,2,8,3,10,2,6,3,7
+D,5,9,6,7,6,9,7,3,5,11,5,5,3,8,3,8
+M,3,4,5,3,3,7,6,3,4,9,7,8,7,5,1,8
+T,4,11,5,8,5,7,11,4,6,7,11,8,3,12,1,8
+N,8,14,9,8,4,4,9,3,4,13,11,10,6,8,0,8
+S,5,6,6,4,3,6,7,4,7,10,10,9,2,10,4,5
+P,3,2,4,3,2,5,10,4,4,10,8,3,1,10,3,6
+P,4,11,5,8,3,3,13,8,2,11,6,3,1,10,4,8
+H,6,8,8,6,5,10,6,3,7,10,3,7,4,9,4,10
+I,4,9,4,5,2,8,8,2,5,13,5,5,1,9,5,10
+S,7,11,9,8,11,8,8,5,3,8,5,8,6,8,13,8
+N,4,5,6,3,2,7,8,2,5,10,6,6,5,8,1,7
+Z,4,8,6,6,3,7,7,2,10,12,5,9,2,10,6,9
+Y,1,1,2,1,1,9,11,1,6,6,11,7,1,11,1,8
+L,1,3,3,1,1,7,4,1,7,8,2,10,0,7,2,9
+O,8,12,5,6,3,8,7,6,5,9,4,7,5,9,5,8
+W,4,7,6,5,3,6,8,4,1,7,8,8,8,10,0,8
+A,7,10,10,9,8,6,8,3,6,7,8,10,6,8,4,8
+U,6,10,8,8,8,8,7,9,5,6,6,9,3,8,5,5
+G,7,9,10,8,11,7,7,6,3,7,7,8,8,10,9,9
+N,2,1,3,3,2,7,9,5,4,7,6,6,4,8,1,6
+N,4,8,5,6,4,7,7,7,5,7,5,6,3,7,3,8
+W,3,2,5,3,3,8,11,2,2,7,9,8,6,11,0,7
+C,4,6,4,4,2,5,9,6,8,12,10,11,1,9,2,7
+G,3,5,4,4,2,6,7,5,5,9,7,10,2,9,4,10
+Q,3,6,4,7,4,9,5,6,3,9,5,11,3,9,5,9
+D,4,8,6,7,5,5,6,6,7,8,6,8,4,5,6,5
+H,2,1,3,2,2,7,7,5,5,7,6,8,3,8,2,8
+J,2,5,4,4,2,8,6,3,5,14,6,10,1,6,0,7
+B,2,1,2,1,1,7,7,7,5,6,5,7,1,8,7,10
+O,2,3,3,2,2,8,7,6,4,9,5,8,2,8,2,8
+A,3,7,5,5,3,12,3,3,2,10,1,9,2,6,2,8
+C,4,6,6,4,5,7,6,4,4,8,7,11,5,9,3,8
+F,3,5,3,4,2,6,10,4,5,10,9,4,2,10,2,6
+O,3,5,4,4,3,7,7,7,5,9,6,8,2,8,3,8
+J,2,10,3,7,2,12,3,6,3,12,5,11,1,6,0,8
+M,5,8,9,6,10,8,6,3,2,8,4,8,14,6,3,7
+F,6,10,8,7,8,7,6,6,4,7,6,8,5,10,8,12
+K,11,13,10,8,4,8,8,3,8,9,4,6,5,7,4,7
+F,3,8,4,5,1,1,12,5,5,12,10,8,0,8,2,6
+P,3,4,5,3,2,7,10,4,4,12,5,3,1,10,3,8
+L,4,9,6,7,7,7,7,3,5,6,7,11,6,11,6,5
+T,5,7,5,5,2,5,11,2,9,12,9,4,0,10,2,4
+S,4,7,6,5,3,8,8,3,7,10,5,6,2,8,5,8
+A,3,8,5,6,3,11,3,2,2,8,2,9,2,5,2,8
+C,8,12,5,7,2,6,8,7,8,10,7,12,2,9,5,9
+Q,4,8,5,7,3,8,6,9,7,6,4,8,3,8,4,8
+R,5,7,6,5,5,8,7,6,3,8,5,6,4,7,7,8
+Q,1,0,2,1,1,8,7,6,3,6,6,9,2,8,3,8
+D,4,8,6,6,5,10,6,2,6,11,3,7,3,8,3,10
+K,1,0,2,1,0,5,7,7,1,7,6,11,2,8,2,11
+K,8,15,8,8,4,6,8,3,7,9,7,9,6,9,3,7
+L,3,6,5,4,2,6,4,2,9,7,2,10,0,7,3,8
+L,3,11,5,8,2,2,2,5,10,0,0,6,0,7,1,5
+F,2,3,4,2,1,4,12,4,4,13,8,5,1,9,1,6
+U,5,6,5,4,2,4,8,6,8,9,9,9,3,9,3,5
+A,6,11,8,9,9,8,7,8,3,7,6,8,3,8,9,3
+G,3,7,4,5,2,8,7,8,7,6,6,9,2,7,5,11
+M,5,10,8,8,6,8,6,2,4,9,6,8,8,6,2,8
+O,3,7,4,5,3,7,7,7,3,9,6,9,3,8,3,8
+T,1,0,2,0,0,7,14,2,4,7,10,8,0,8,0,8
+U,4,5,5,4,2,5,8,6,8,8,10,10,3,9,1,7
+Y,4,11,6,8,2,9,10,1,3,6,12,8,1,11,0,8
+S,3,6,6,4,3,9,7,4,8,11,3,7,1,8,5,10
+U,3,8,5,6,3,4,8,7,7,9,10,11,3,9,0,8
+H,5,9,5,5,4,7,8,3,4,10,6,8,6,8,4,8
+M,4,7,6,5,6,6,6,5,5,7,7,11,10,5,2,9
+P,3,5,4,3,2,6,9,5,4,9,7,3,1,10,4,6
+W,5,5,8,4,8,7,7,5,5,6,6,8,8,10,7,10
+W,3,3,4,4,2,7,8,4,1,7,8,8,8,10,0,8
+U,2,0,2,0,0,7,5,10,4,7,13,8,3,10,0,8
+N,4,3,4,5,2,7,7,14,2,5,6,8,6,8,0,8
+O,4,11,5,8,3,8,8,9,8,6,8,8,3,8,4,8
+L,3,8,5,6,6,7,7,3,5,7,6,10,6,11,6,5
+R,1,0,1,0,0,6,8,6,3,7,5,7,2,7,4,11
+M,6,10,9,8,7,6,6,7,6,7,8,11,9,6,2,9
+S,2,7,3,5,3,8,7,7,5,7,5,7,2,8,8,7
+T,1,0,2,1,0,7,14,1,4,7,10,8,0,8,0,8
+D,10,15,9,8,6,9,5,4,7,9,5,7,6,10,6,8
+J,3,11,4,8,1,14,2,8,5,14,2,11,0,6,0,8
+L,5,10,5,8,3,0,1,5,6,0,0,6,0,8,0,8
+Y,3,4,5,6,4,9,10,7,4,7,7,6,4,10,5,5
+I,1,8,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+A,3,9,5,6,4,8,2,1,2,7,2,7,2,7,3,6
+R,7,9,10,8,11,7,7,4,4,7,5,7,7,9,7,5
+D,4,10,6,8,5,7,7,9,7,7,6,5,3,8,4,8
+A,4,11,6,8,4,12,2,4,3,11,1,9,3,7,3,9
+A,3,7,5,5,3,11,2,2,2,8,3,9,3,5,3,8
+T,5,10,7,8,8,5,8,4,7,7,6,9,5,8,5,6
+H,5,10,6,7,3,7,7,15,0,7,6,8,3,8,0,8
+B,3,5,4,3,3,7,7,5,5,6,6,6,2,8,6,10
+C,3,8,4,6,2,5,8,7,8,7,8,14,1,8,4,10
+P,2,4,3,3,2,6,10,5,4,9,7,2,1,10,4,6
+N,4,5,4,3,3,7,8,5,5,7,6,6,5,10,2,5
+J,2,8,3,6,2,10,7,0,7,11,3,6,0,7,1,7
+S,6,12,6,7,3,7,7,3,5,14,7,8,2,9,3,8
+U,5,10,5,7,2,7,4,15,6,7,14,8,3,9,0,8
+K,4,4,5,3,3,6,7,4,7,7,6,11,3,8,5,9
+Y,5,7,6,5,3,5,9,2,9,9,10,4,1,11,4,4
+W,5,7,5,5,4,3,11,2,2,10,8,7,5,11,2,6
+G,3,7,4,5,3,6,6,6,5,9,7,13,2,9,4,10
+R,2,3,3,2,2,8,7,3,5,9,4,7,2,7,4,10
+H,4,5,4,7,2,7,7,15,1,7,6,8,3,8,0,8
+W,10,10,10,8,7,6,10,5,3,8,6,6,10,12,4,4
+O,4,10,6,8,4,8,6,9,5,7,4,8,3,8,3,7
+B,3,4,4,3,3,7,7,5,6,7,6,6,2,8,6,9
+W,7,11,9,8,7,10,8,5,1,6,10,7,10,12,2,5
+A,4,8,6,6,3,9,3,2,3,8,1,8,2,6,3,7
+L,2,5,3,3,1,6,4,1,8,7,2,10,0,7,2,8
+Q,4,7,5,9,6,8,6,6,4,9,6,9,2,9,4,8
+F,2,4,2,3,2,6,10,4,5,10,9,5,2,9,3,6
+V,5,11,8,8,5,8,12,2,3,4,10,9,6,11,5,8
+O,8,11,8,9,8,8,6,8,4,9,5,8,3,9,3,8
+Y,8,9,8,7,5,5,8,1,8,8,9,5,4,11,6,4
+S,5,7,6,5,4,7,7,3,7,10,8,8,2,9,5,6
+C,3,6,4,6,4,4,8,3,5,7,6,11,3,10,7,7
+I,2,11,2,8,3,7,7,0,7,7,6,8,0,8,3,8
+A,3,10,5,8,3,13,4,5,3,12,0,8,2,6,3,9
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+O,4,6,6,6,4,8,4,4,4,9,3,9,3,7,4,9
+J,2,4,4,3,1,8,7,2,6,14,5,8,2,8,1,8
+Z,3,8,4,6,2,7,7,4,13,9,6,8,0,8,8,8
+S,4,8,5,6,4,8,7,7,7,7,6,8,2,9,9,8
+R,2,4,4,2,2,8,8,3,5,10,4,7,2,6,3,10
+S,3,6,5,4,5,9,7,4,3,8,5,8,4,8,10,9
+L,2,6,3,4,2,8,3,3,6,7,2,7,1,6,2,8
+Q,6,10,6,5,4,9,6,4,7,11,4,9,3,7,8,11
+Q,2,2,3,4,2,8,7,7,3,6,5,9,2,9,3,9
+V,3,8,5,6,2,9,9,4,1,6,12,8,2,10,0,8
+R,3,5,4,6,3,6,11,9,4,7,2,9,3,7,5,11
+O,5,8,7,6,8,8,7,5,1,7,6,8,9,9,6,11
+R,3,4,5,3,3,8,7,3,5,9,4,7,2,7,4,10
+F,7,13,7,7,5,8,10,3,5,11,5,4,4,9,8,7
+N,4,4,5,7,3,7,7,15,2,4,6,8,6,8,0,8
+J,3,11,4,8,3,9,6,2,7,12,3,8,1,6,2,6
+P,4,8,5,6,2,4,15,8,1,12,6,2,0,9,4,8
+B,4,7,4,5,3,6,8,9,8,7,5,7,2,8,9,9
+E,5,10,4,5,3,7,10,5,5,10,5,9,3,8,6,10
+S,3,7,4,5,2,8,7,5,8,5,6,8,0,8,9,8
+N,4,7,6,5,6,7,8,4,4,7,6,7,5,9,5,4
+L,3,11,5,8,3,4,3,5,8,1,0,6,0,6,1,5
+I,5,8,6,9,6,8,9,5,6,6,6,7,3,9,9,8
+C,7,10,7,8,5,3,8,5,7,10,10,14,3,9,4,6
+D,2,5,4,4,3,8,7,5,6,9,5,5,2,8,3,8
+D,3,4,5,3,3,9,6,4,6,10,4,5,2,8,3,8
+R,3,6,4,4,4,8,6,7,3,8,6,7,4,6,7,8
+S,4,8,6,6,4,7,8,3,7,10,4,7,2,7,4,8
+N,5,6,7,4,4,4,10,3,3,9,9,8,5,8,1,7
+N,4,9,6,7,4,9,7,6,5,6,6,4,5,8,2,5
+O,5,10,7,7,8,9,7,6,1,7,7,9,10,9,4,6
+C,3,6,4,4,2,3,9,5,7,11,11,11,1,8,2,7
+I,4,9,4,4,2,7,10,2,5,13,5,4,1,8,5,8
+X,5,9,7,8,8,7,8,2,5,8,6,8,4,6,8,9
+R,6,9,8,7,8,8,8,6,5,8,6,7,7,8,6,12
+J,8,13,6,10,5,11,5,2,5,12,4,8,2,9,6,13
+Z,5,9,7,7,4,7,8,2,10,12,6,9,2,10,6,8
+Z,1,3,2,2,1,7,7,5,8,6,6,8,1,8,7,8
+R,2,1,3,2,2,7,8,4,5,6,5,7,2,6,4,8
+M,5,9,6,7,6,7,5,11,1,7,9,8,9,5,2,8
+C,4,10,5,8,2,6,8,7,10,4,6,13,1,7,4,8
+N,2,1,3,3,2,7,8,5,4,7,6,7,4,8,1,7
+B,4,8,6,6,5,8,7,5,6,9,5,6,3,8,7,9
+Z,6,9,8,7,5,9,5,3,9,11,3,11,3,6,7,9
+N,6,10,9,8,6,5,10,2,4,9,9,8,7,7,2,7
+I,5,10,6,8,4,7,7,0,8,13,6,8,0,8,1,8
+I,1,7,0,5,1,7,7,5,3,7,6,8,0,8,0,8
+O,4,7,6,5,6,9,6,5,1,7,6,9,10,9,4,8
+D,5,11,8,9,12,9,9,5,5,7,6,6,5,8,9,6
+P,7,11,10,8,5,8,11,7,3,11,4,2,2,11,4,9
+N,5,8,7,6,4,7,8,3,5,10,6,7,5,8,1,7
+Q,2,4,3,5,3,8,7,7,3,6,6,9,3,8,5,10
+I,2,7,5,5,4,11,6,1,5,8,4,5,3,8,5,9
+D,5,9,7,7,7,9,6,4,6,9,3,6,3,8,3,8
+P,5,8,5,6,2,4,13,8,1,11,6,3,1,10,4,8
+C,2,1,3,2,1,6,7,6,10,7,6,14,0,8,4,9
+J,5,10,7,8,3,6,7,3,7,15,8,11,1,6,1,7
+K,3,2,4,3,2,5,7,4,7,6,6,11,3,8,5,9
+T,1,0,1,0,0,8,13,1,4,6,10,8,0,8,0,8
+M,6,5,7,8,4,8,7,13,2,7,9,8,9,6,0,8
+K,9,13,10,7,6,4,9,4,6,10,10,11,5,8,4,6
+G,4,9,4,6,3,6,7,7,6,10,8,10,2,9,4,9
+D,2,6,4,4,5,10,7,4,5,7,5,6,3,6,6,5
+J,1,4,2,3,1,10,6,2,5,11,4,9,1,7,1,7
+F,1,3,3,1,1,5,10,2,5,13,7,5,1,9,1,7
+H,6,7,8,5,5,5,9,3,6,10,9,9,4,9,4,7
+Q,3,5,4,6,3,8,7,7,5,8,7,8,2,9,4,9
+X,9,14,10,8,5,5,9,3,8,11,9,8,4,9,4,6
+U,7,9,8,7,5,4,8,5,8,10,9,9,3,9,2,6
+E,5,9,7,6,6,8,7,7,2,7,6,11,5,8,8,9
+K,1,1,2,1,0,4,6,6,2,7,6,11,3,8,2,10
+R,4,11,6,9,5,7,8,5,7,6,5,7,4,5,7,9
+R,4,7,5,5,4,7,8,6,6,6,5,8,3,6,6,9
+R,4,8,6,6,5,9,8,4,6,8,3,8,4,5,5,11
+R,2,4,4,3,2,9,7,2,6,10,3,6,2,7,3,10
+V,3,8,6,6,1,6,8,4,3,7,14,8,3,9,0,8
+X,3,8,4,6,3,7,7,3,8,6,6,10,3,8,6,8
+F,4,9,6,7,7,6,8,1,4,10,8,7,6,11,4,5
+B,3,7,4,5,5,9,6,5,4,7,7,8,6,9,7,7
+L,3,6,5,4,3,6,4,2,6,7,2,9,1,7,3,7
+U,4,2,5,3,2,6,9,6,7,7,10,9,3,9,1,8
+O,3,6,4,4,3,8,7,7,5,7,6,8,2,8,3,8
+Y,4,8,5,6,2,6,10,2,2,7,12,8,2,11,0,8
+Z,2,3,4,2,1,7,7,2,9,11,6,8,1,8,5,7
+P,6,8,8,6,5,7,11,7,3,9,5,3,3,11,4,8
+U,3,4,4,6,2,8,5,13,5,6,14,8,3,9,0,8
+C,6,9,4,4,2,7,9,6,6,11,7,8,2,9,5,9
+L,2,6,3,4,2,4,5,1,8,6,2,10,0,7,3,6
+R,3,5,4,6,3,6,11,10,4,7,3,9,3,7,5,10
+P,4,8,5,6,5,6,9,6,5,9,7,4,2,10,3,7
+R,4,11,5,8,3,6,10,10,4,7,4,8,3,7,5,11
+C,1,0,2,0,0,7,7,5,7,7,6,13,0,8,4,10
+Q,2,1,2,2,1,8,7,7,4,6,6,8,3,8,3,8
+R,2,1,2,2,2,7,8,5,5,6,5,7,2,7,4,8
+E,6,9,8,7,5,7,7,2,9,11,5,9,3,8,5,8
+E,3,7,4,5,4,7,8,6,9,6,4,9,3,8,6,8
+A,2,5,4,4,2,10,2,2,2,9,2,9,2,6,2,8
+L,3,7,4,5,2,7,4,2,6,7,2,8,1,6,2,8
+F,5,6,6,7,6,7,10,5,6,8,6,8,4,8,7,6
+E,2,3,4,2,2,5,8,2,8,11,8,9,2,8,4,6
+V,1,1,2,1,0,8,9,4,2,7,13,8,2,10,0,8
+E,2,6,3,4,3,6,7,6,8,7,6,10,3,8,6,8
+U,4,10,4,7,2,7,6,14,5,7,13,8,3,9,0,8
+A,3,8,6,5,2,8,5,3,1,7,1,8,2,7,2,8
+A,4,11,7,8,6,10,3,1,2,8,3,9,5,5,3,7
+Y,3,5,4,6,5,9,9,5,3,6,7,8,5,10,7,6
+N,2,3,4,2,1,5,10,3,3,10,8,8,4,8,0,8
+U,4,5,4,7,2,7,5,14,5,7,14,8,3,9,0,8
+G,4,8,5,6,3,6,7,6,6,10,8,10,2,9,4,9
+L,2,8,3,6,2,3,5,2,8,3,0,9,0,7,1,6
+O,5,11,6,9,6,7,7,8,3,10,6,8,3,8,3,8
+L,3,7,4,5,2,7,4,1,7,8,2,9,1,6,2,8
+Y,5,10,8,8,4,10,11,2,8,3,11,8,1,11,2,9
+K,3,4,4,6,2,3,7,7,2,7,5,11,3,8,3,10
+G,7,14,5,8,4,8,6,4,3,9,5,9,4,9,8,8
+F,3,9,4,7,4,5,10,3,5,10,9,6,2,10,3,6
+P,4,5,5,8,2,3,13,8,2,11,7,3,1,10,4,8
+U,3,4,4,3,2,6,9,6,6,7,9,9,3,9,1,9
+M,4,11,5,8,7,7,6,10,1,7,8,8,8,4,0,8
+L,3,10,3,8,2,0,2,3,6,1,0,8,0,8,0,8
+F,3,6,5,4,2,6,10,2,6,13,7,5,1,10,2,7
+W,4,3,6,4,2,4,8,5,1,7,9,8,8,10,0,8
+Z,4,10,5,8,3,7,7,4,15,9,6,8,0,8,8,8
+U,7,11,9,8,5,6,10,6,8,7,10,9,3,9,1,8
+H,3,7,5,5,4,8,7,6,6,7,6,9,6,8,3,8
+V,6,9,5,7,2,2,12,5,4,11,12,7,3,10,1,8
+E,4,10,3,5,2,9,6,5,4,11,4,10,3,8,8,13
+O,5,10,6,8,6,8,8,8,4,7,7,6,5,7,4,9
+Q,1,0,2,1,1,8,7,6,3,6,6,9,2,8,3,8
+J,2,6,3,4,1,14,2,5,5,13,2,10,0,8,0,8
+R,3,6,4,4,3,8,8,5,6,7,5,6,3,7,5,8
+E,4,7,6,5,4,7,7,2,7,11,6,9,3,8,4,9
+W,6,9,6,5,4,3,9,2,3,9,10,8,8,11,1,5
+T,2,9,3,6,1,7,14,0,6,7,11,8,0,8,0,8
+B,2,3,3,2,2,8,7,3,5,10,5,6,2,8,3,9
+G,2,0,2,1,1,8,6,6,5,6,5,9,2,8,5,10
+S,4,9,6,6,4,7,6,3,7,9,9,9,2,10,4,6
+B,4,7,6,5,6,9,6,4,6,9,5,6,2,8,6,9
+S,4,9,6,7,4,9,8,4,7,10,4,6,2,8,5,9
+M,2,1,3,2,1,7,6,10,1,7,9,8,7,6,0,8
+D,3,7,5,5,7,10,8,4,5,7,6,6,4,7,7,5
+P,4,11,6,8,5,6,8,5,6,9,8,4,2,10,4,7
+V,4,10,6,7,4,8,9,4,2,6,13,8,2,10,0,8
+E,1,3,3,2,1,7,7,2,6,11,6,9,2,9,4,10
+Z,2,4,4,3,2,7,8,2,9,11,6,8,1,8,5,7
+Q,3,4,4,7,2,7,6,8,6,5,5,8,3,8,4,8
+F,4,8,4,5,2,1,12,5,5,12,10,8,0,8,2,6
+Q,2,3,3,4,3,8,7,7,3,6,6,9,3,8,4,9
+O,3,4,4,3,2,7,7,6,4,9,6,8,2,8,3,7
+L,4,10,5,8,4,6,4,1,7,8,2,10,0,6,3,8
+L,4,10,5,7,3,7,4,0,9,9,2,11,0,7,3,8
+J,2,7,3,5,1,14,3,4,5,12,1,8,0,7,0,8
+A,3,6,5,4,3,8,3,2,2,6,2,7,2,6,2,6
+M,5,9,6,4,4,6,4,2,2,8,4,10,7,3,1,9
+H,7,11,10,8,7,4,9,4,6,10,9,9,3,8,4,7
+Q,4,10,5,9,5,8,7,8,5,6,7,8,3,8,4,9
+H,4,9,5,7,4,7,8,13,1,7,5,8,3,8,0,8
+V,5,11,7,8,4,7,9,4,1,7,13,8,5,9,2,9
+L,3,8,4,6,3,4,4,4,7,2,1,7,1,6,1,6
+M,5,11,7,8,9,8,7,6,5,6,7,8,8,6,2,8
+X,6,10,8,8,7,7,6,3,5,6,6,8,3,9,10,9
+Z,5,8,7,6,4,6,9,3,10,11,9,5,1,8,6,5
+I,3,9,4,7,3,7,8,0,7,13,6,8,0,8,1,8
+R,2,4,4,3,2,8,7,4,5,9,5,7,2,7,4,10
+O,7,10,7,8,6,8,7,7,4,9,5,6,5,9,5,10
+U,5,9,7,8,7,7,7,4,4,6,6,9,4,8,2,9
+J,2,3,2,4,1,10,3,10,3,12,8,13,1,6,0,8
+D,6,9,6,4,3,10,4,6,5,13,4,11,5,6,4,8
+K,5,7,7,5,5,4,7,2,7,10,9,11,4,7,4,6
+R,3,5,5,3,3,8,7,5,4,8,5,7,3,7,4,11
+G,5,11,4,6,3,7,9,4,4,9,6,5,3,9,8,7
+O,6,11,7,8,5,7,7,9,6,7,5,8,3,8,4,8
+A,1,0,2,0,0,7,4,2,0,7,2,8,2,7,1,8
+F,2,4,3,3,2,5,10,4,5,10,9,5,1,10,3,6
+U,5,9,6,6,4,3,9,5,7,10,10,9,3,9,2,6
+B,3,8,5,6,4,9,6,4,6,10,5,6,2,8,6,9
+F,5,9,6,7,6,6,10,5,4,9,6,8,5,9,7,11
+Q,4,8,4,9,5,8,8,6,2,6,8,11,3,9,6,7
+Q,3,8,4,7,4,8,7,8,5,6,5,8,2,9,4,8
+T,3,4,3,2,1,6,11,2,7,11,9,5,2,9,3,4
+S,4,8,5,6,2,7,6,6,9,5,6,10,0,9,9,8
+C,2,1,3,2,1,6,7,6,10,7,6,14,0,8,4,9
+Q,7,12,6,7,3,8,4,4,7,11,4,10,3,7,8,11
+L,4,10,5,8,3,0,2,4,6,1,0,8,0,8,0,8
+F,4,9,6,6,6,11,6,2,5,10,5,6,5,9,4,7
+P,4,6,5,8,8,8,9,5,0,8,7,6,5,10,5,9
+C,4,6,5,4,2,5,8,5,7,12,9,12,2,10,3,8
+V,2,6,4,4,2,6,11,3,3,8,11,8,2,11,1,9
+Q,7,9,7,11,9,8,7,6,2,8,7,11,5,9,8,6
+T,1,6,2,4,1,7,13,0,5,7,10,8,0,8,0,8
+N,5,10,5,8,3,7,7,15,2,4,6,8,6,8,0,8
+Z,4,11,6,8,7,8,7,2,8,7,6,7,1,7,11,7
+S,2,1,2,2,1,8,8,6,4,8,5,7,2,8,8,8
+G,5,10,5,7,4,6,7,7,6,10,8,11,2,9,4,9
+M,9,14,11,8,7,6,4,3,2,8,4,10,10,1,1,8
+R,6,9,6,4,4,5,8,3,5,7,4,10,5,7,6,6
+T,4,7,4,5,3,5,11,3,6,11,9,5,2,11,2,5
+D,5,11,5,8,3,6,7,11,10,6,5,6,3,8,4,8
+X,3,4,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+M,2,3,3,4,2,8,6,11,1,6,9,8,7,5,0,8
+R,4,9,6,6,6,7,7,4,6,7,5,7,3,7,5,8
+P,3,5,5,4,3,8,8,4,4,12,4,4,2,9,3,8
+F,8,13,7,7,3,6,9,3,6,12,5,5,2,8,6,6
+Q,2,2,3,3,2,8,7,7,3,6,6,9,2,9,3,9
+J,1,4,2,3,1,10,6,2,6,12,4,9,0,7,1,7
+Y,3,5,5,7,5,9,10,5,4,7,7,7,5,11,6,5
+I,2,9,2,7,2,7,7,0,8,7,6,8,0,8,3,8
+S,3,8,4,6,3,8,8,7,5,7,6,7,2,8,8,8
+B,4,9,6,6,7,9,6,4,4,6,7,7,7,9,8,6
+Y,3,7,5,5,2,8,10,1,2,6,12,8,1,11,0,8
+I,4,10,5,8,3,5,9,0,7,13,7,6,2,9,3,6
+W,5,9,8,7,4,7,7,5,2,6,8,8,9,9,0,8
+I,5,12,4,6,3,10,6,3,5,13,3,6,2,8,5,10
+B,6,9,9,8,10,7,7,5,4,8,6,8,7,9,9,6
+T,3,8,5,6,2,7,14,1,5,7,10,8,0,8,0,8
+Y,2,9,4,6,1,7,10,1,3,7,12,8,1,11,0,8
+Z,5,8,7,6,4,7,8,2,10,12,6,7,2,8,6,8
+L,6,12,5,7,3,10,2,4,4,13,4,12,2,7,6,9
+Y,2,3,2,1,1,5,10,2,7,10,9,4,1,11,2,5
+M,3,4,5,3,3,8,5,3,3,9,6,8,7,5,1,8
+I,5,15,5,8,3,10,6,2,5,11,4,6,2,9,5,12
+R,2,2,3,3,2,6,7,4,5,7,6,7,5,7,3,8
+U,4,8,6,6,4,5,9,5,6,7,9,9,3,9,1,8
+D,6,12,5,7,4,7,6,4,6,9,5,6,5,9,7,6
+Y,8,11,6,15,5,4,11,2,4,11,10,6,4,10,6,6
+E,5,9,7,6,5,7,8,1,8,11,6,9,2,8,4,9
+L,1,0,1,0,0,2,2,5,4,1,2,6,0,8,0,8
+A,5,11,7,8,5,7,4,3,0,7,1,8,3,8,3,7
+C,4,6,5,4,5,6,6,4,4,7,6,11,5,9,3,8
+O,3,9,5,7,4,7,8,8,6,7,9,7,3,8,4,9
+U,2,6,3,4,1,7,5,13,5,7,12,8,3,9,0,8
+A,3,5,5,5,4,8,8,2,4,7,7,8,5,9,4,7
+E,3,5,6,3,3,5,8,2,9,11,7,9,2,8,4,8
+L,3,6,3,4,1,1,0,6,6,0,1,5,0,8,0,8
+P,4,7,6,11,10,8,10,4,0,9,7,6,7,10,5,8
+K,4,8,6,7,5,9,6,2,3,8,3,8,5,7,6,11
+R,4,9,6,7,6,9,7,4,5,10,4,7,3,7,4,11
+I,5,11,4,6,2,8,8,2,5,13,4,5,2,9,5,9
+K,3,3,5,2,2,6,7,1,7,10,7,10,3,8,2,8
+P,11,15,9,8,4,6,10,6,3,11,4,4,5,10,4,7
+W,7,11,7,6,4,4,8,2,2,8,10,8,9,11,1,6
+Y,5,9,5,5,3,6,7,4,5,9,7,5,3,10,5,4
+C,5,9,4,4,3,7,10,3,4,9,7,9,3,8,6,10
+K,5,10,8,7,5,6,7,3,8,7,6,8,4,8,5,8
+P,4,11,5,8,4,5,11,4,6,11,9,4,0,10,4,7
+R,4,8,5,6,5,8,8,6,5,8,6,7,3,7,5,9
+M,3,7,4,5,3,8,6,11,1,6,9,8,7,6,0,8
+F,1,0,1,0,0,3,11,4,3,11,9,7,0,8,2,8
+J,3,9,4,7,1,11,2,11,3,13,8,14,1,6,0,8
+F,4,8,4,6,3,1,12,4,4,12,10,7,0,8,2,6
+K,5,8,7,7,6,8,5,2,4,8,4,8,4,8,7,11
+U,3,3,4,5,2,8,4,14,5,7,12,8,3,9,0,8
+J,1,3,2,2,1,10,6,2,5,12,4,9,0,7,1,7
+R,5,11,6,8,7,5,9,8,3,7,5,8,2,7,5,11
+Q,5,8,6,10,7,7,10,4,2,6,9,11,3,9,6,8
+W,4,6,6,4,3,6,8,4,1,7,8,8,8,9,0,8
+K,7,11,9,8,5,6,7,2,7,10,7,10,4,8,4,8
+R,6,10,5,6,3,7,7,5,4,9,4,9,6,5,6,11
+M,7,9,9,5,4,12,2,5,2,11,1,9,7,2,1,8
+Q,7,14,7,8,5,12,4,4,6,12,3,9,4,8,7,12
+J,5,10,3,14,4,10,7,2,4,10,5,6,3,8,6,10
+X,4,9,7,7,5,7,7,3,9,5,6,10,3,8,6,8
+G,3,5,4,4,2,6,7,6,6,10,7,10,2,9,4,10
+N,3,7,5,5,3,5,9,6,4,7,7,9,5,9,1,7
+M,2,1,3,3,3,8,6,6,4,7,7,8,6,5,2,8
+Y,3,8,5,6,2,7,10,0,3,7,11,8,1,10,0,8
+N,5,9,6,4,3,2,11,3,3,12,11,9,4,9,0,8
+M,8,9,11,7,8,10,6,2,5,9,3,6,10,8,3,9
+K,5,7,7,6,6,10,5,3,3,10,3,8,5,7,6,12
+Y,4,10,6,8,6,9,3,7,5,7,8,8,3,10,5,4
+X,7,13,8,7,5,9,6,3,8,11,3,7,4,8,4,8
+F,4,9,6,6,4,6,10,1,6,13,7,6,1,10,2,8
+Z,2,1,2,2,2,8,7,5,8,6,6,7,1,8,6,8
+E,3,8,3,6,2,2,8,6,10,7,6,15,0,8,6,7
+S,4,8,5,6,4,8,6,7,7,7,8,9,2,10,9,8
+T,3,6,4,8,1,10,14,0,6,5,11,9,0,8,0,8
+V,3,5,5,3,2,7,12,3,3,7,11,9,2,10,1,8
+G,2,0,2,1,1,8,7,6,5,6,6,9,1,7,5,10
+M,5,10,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+L,2,4,3,3,1,7,4,1,8,8,2,10,0,7,2,8
+M,8,9,11,8,13,8,7,4,4,7,6,7,11,8,6,4
+D,9,13,8,8,6,7,6,4,7,10,5,7,6,8,8,5
+B,3,5,3,4,3,7,7,5,5,6,6,6,2,8,6,10
+V,7,11,7,8,5,2,12,2,3,9,11,8,3,9,2,6
+S,7,10,8,7,4,8,7,4,9,11,4,8,2,8,5,9
+U,6,11,9,8,5,8,8,5,9,4,10,8,4,7,2,7
+N,5,9,7,6,5,6,8,7,7,7,6,7,3,7,3,8
+H,2,0,2,0,0,7,8,11,1,7,5,8,3,8,0,8
+A,2,4,4,3,2,9,2,2,2,9,2,8,2,6,3,8
+S,4,9,5,6,5,8,8,7,5,7,5,7,2,7,8,7
+X,5,7,7,6,7,8,7,2,5,7,6,8,3,9,8,8
+J,3,10,4,8,1,11,2,11,3,12,8,14,1,6,0,8
+I,5,9,3,4,1,10,6,5,4,13,3,7,2,8,5,10
+B,4,7,4,5,5,6,7,8,5,7,6,7,2,8,7,9
+L,4,5,5,4,4,8,6,4,5,7,7,8,2,8,7,10
+U,5,5,6,4,3,4,8,5,8,10,9,9,3,9,2,5
+F,5,10,7,8,4,5,11,4,7,11,10,5,2,10,3,5
+V,4,7,6,5,6,7,7,4,2,8,7,8,7,10,5,7
+A,5,11,8,8,5,12,2,3,3,10,1,9,3,7,4,8
+N,4,6,4,4,2,7,7,14,2,5,6,8,6,8,0,8
+C,5,9,6,6,3,5,8,8,9,9,8,13,2,10,4,9
+J,2,5,4,3,2,11,6,2,7,12,3,7,0,7,1,8
+U,3,3,3,4,1,7,6,13,5,7,13,8,3,9,0,8
+D,6,12,6,6,4,6,8,5,7,9,6,6,5,9,7,5
+U,6,11,6,6,4,8,5,5,5,6,8,8,4,9,3,8
+A,4,11,7,8,4,11,2,2,3,9,2,9,5,6,3,9
+A,2,6,3,4,2,9,5,2,0,8,2,8,2,6,1,8
+I,4,11,5,8,3,7,7,0,9,14,6,8,0,8,1,8
+E,4,10,4,8,4,3,9,5,10,7,6,14,0,8,6,8
+E,5,10,7,7,6,10,6,1,7,11,4,8,4,8,5,11
+L,3,7,4,5,2,5,2,7,8,1,2,2,1,6,1,5
+Y,2,8,4,5,1,9,10,2,3,6,12,8,1,11,0,8
+M,4,4,5,3,3,6,6,6,5,7,7,10,7,6,2,8
+K,3,7,5,5,6,6,8,4,4,6,5,9,5,7,7,7
+K,4,7,5,5,4,7,6,1,6,10,5,10,3,8,4,9
+U,5,8,6,6,3,3,9,6,7,12,11,9,3,9,1,7
+J,1,3,2,2,1,10,7,1,5,11,4,8,0,7,0,7
+F,2,6,3,4,2,1,10,3,5,11,11,9,0,8,2,7
+X,3,4,4,3,2,7,7,3,9,6,6,9,2,8,6,8
+J,4,10,4,8,3,15,3,3,5,12,0,7,0,8,0,8
+P,6,12,5,7,4,6,11,5,2,11,6,3,3,12,5,5
+F,6,9,9,7,8,7,7,5,4,7,6,8,5,11,9,11
+A,6,10,7,7,7,8,8,6,5,6,5,8,5,7,7,5
+D,4,5,5,8,3,5,7,10,8,7,6,5,3,8,4,8
+Q,3,7,4,5,2,8,7,8,6,6,8,9,3,7,5,10
+V,3,4,5,7,1,8,8,4,3,6,14,8,3,9,0,8
+O,2,3,3,2,2,8,7,6,4,9,6,8,2,8,2,8
+P,4,7,5,5,4,5,10,3,6,10,9,5,4,10,3,7
+A,2,3,4,5,1,8,6,3,1,7,0,8,2,7,1,8
+U,7,12,6,6,3,9,7,6,6,3,10,7,5,9,2,6
+D,2,5,4,3,3,9,6,4,6,10,4,6,2,8,3,8
+E,3,2,4,3,3,7,7,5,8,7,6,9,2,8,6,9
+G,1,3,2,1,1,7,7,4,5,9,7,10,1,9,3,10
+G,4,7,4,5,3,7,6,6,6,10,7,11,2,10,4,10
+Z,3,9,4,7,2,7,7,4,14,9,6,8,0,8,8,8
+W,5,5,8,7,4,7,7,5,2,7,8,8,9,9,0,8
+Q,4,9,5,8,5,8,8,8,5,6,6,9,3,8,4,9
+Y,4,10,6,8,4,5,9,0,7,8,12,9,1,11,2,7
+U,3,6,4,4,1,8,4,13,5,7,13,8,3,9,0,8
+N,4,5,6,4,3,7,9,2,5,10,6,6,5,9,1,7
+Y,5,4,6,6,6,9,10,5,3,6,7,7,5,11,7,4
+S,2,4,4,2,1,10,7,2,7,10,5,8,1,9,5,10
+A,2,4,4,3,2,10,2,2,2,9,2,9,2,6,2,8
+Y,5,10,5,7,2,3,11,4,6,12,12,6,1,11,2,6
+M,5,10,7,8,10,8,8,7,4,7,6,8,8,9,9,4
+G,1,0,2,1,1,8,6,6,5,6,5,9,1,8,5,10
+A,5,11,8,8,5,9,3,2,3,8,1,8,2,7,3,7
+U,5,9,6,8,7,7,7,4,4,6,6,8,5,7,2,7
+I,1,3,1,2,0,7,7,1,7,13,6,8,0,8,0,8
+X,2,3,4,1,1,6,8,2,8,11,8,8,2,8,3,7
+D,4,8,5,6,3,9,7,4,7,11,4,5,3,8,3,8
+D,2,3,3,2,2,7,7,6,6,7,6,6,2,8,3,7
+A,5,9,6,7,4,9,4,3,1,8,1,9,2,7,3,8
+F,4,8,4,5,1,1,11,5,7,11,11,9,0,8,2,6
+D,5,8,6,6,5,8,8,5,6,10,5,4,4,9,4,9
+V,3,9,5,7,2,8,8,4,3,6,14,8,3,10,0,8
+D,9,14,8,8,6,9,5,4,6,10,4,7,6,8,9,7
+A,7,11,6,6,3,11,2,3,1,9,4,11,4,4,4,9
+U,6,10,7,8,4,3,9,5,7,11,10,9,3,9,2,6
+Q,5,9,7,11,7,8,6,8,4,5,6,10,3,8,6,10
+M,5,7,8,5,6,9,7,2,4,9,5,7,7,6,2,8
+O,4,10,5,8,5,8,6,8,4,7,4,8,3,8,3,8
+X,6,9,9,7,5,5,8,1,8,10,10,9,4,7,4,6
+B,6,10,9,8,7,9,6,4,7,9,5,7,3,8,7,10
+H,3,7,4,4,2,7,6,14,1,7,7,8,3,8,0,8
+C,3,4,4,6,1,5,7,6,9,7,6,14,1,9,4,9
+K,3,4,5,3,2,5,7,2,7,10,8,10,3,8,3,7
+X,4,4,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+W,4,9,6,7,10,9,7,5,2,7,6,8,13,10,3,6
+L,3,11,5,8,3,5,3,6,7,2,2,4,1,6,1,5
+V,4,8,4,6,2,3,11,3,3,10,11,7,2,10,1,7
+S,5,8,7,6,8,6,7,3,2,8,6,6,3,8,11,1
+I,1,11,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+G,3,6,4,4,2,7,6,6,6,6,6,10,2,9,4,8
+W,3,4,4,3,3,6,10,5,2,9,7,6,5,11,2,6
+T,6,10,5,8,2,4,13,3,7,12,10,4,0,10,1,5
+O,2,3,3,2,1,7,7,7,4,7,6,8,2,8,2,8
+V,5,9,5,6,3,2,12,4,3,11,12,8,3,10,1,7
+M,6,12,7,6,5,7,3,2,2,8,4,10,8,1,2,8
+Z,4,6,6,8,4,13,4,3,7,10,2,7,2,7,5,12
+P,4,10,5,7,3,5,10,10,4,9,6,5,2,10,4,8
+A,3,8,5,6,2,7,6,3,1,7,0,8,2,7,1,8
+S,7,10,9,8,11,8,8,5,3,9,5,7,5,8,12,8
+P,5,9,7,6,6,5,10,5,5,10,8,3,1,10,3,7
+E,3,8,3,6,2,3,7,6,10,7,6,14,0,8,7,8
+P,5,10,6,7,5,5,11,5,5,11,9,3,1,10,4,7
+O,1,0,1,0,0,8,7,6,4,7,6,8,2,8,2,8
+J,1,4,2,3,1,9,6,2,6,12,4,9,1,7,1,7
+M,3,4,6,3,3,7,6,3,4,9,8,9,7,5,2,9
+M,6,10,8,8,9,8,7,7,5,6,5,8,10,8,10,12
+G,4,8,6,6,4,7,7,7,6,6,6,9,2,8,4,8
+T,2,1,2,1,0,8,15,2,4,6,10,8,0,8,0,8
+E,3,7,3,5,2,3,7,6,10,7,6,14,0,8,7,8
+U,3,6,4,4,1,7,5,13,5,7,13,8,3,9,0,8
+J,3,7,4,5,2,8,6,2,6,14,5,9,0,7,0,7
+W,5,7,7,6,9,6,8,6,5,6,6,8,8,9,8,8
+S,3,4,4,6,2,8,7,6,9,4,6,7,0,8,9,8
+M,9,12,12,7,5,10,2,3,2,10,2,9,8,1,1,8
+Z,2,1,2,2,1,7,7,3,12,8,6,8,0,8,7,8
+V,3,8,6,6,1,7,8,4,3,7,14,8,3,9,0,8
+X,4,7,6,5,3,7,8,1,8,10,7,8,2,8,3,8
+Y,3,6,5,9,8,9,7,4,1,6,7,9,4,11,7,8
+Y,3,6,5,4,1,8,10,2,2,7,13,8,2,11,0,8
+H,6,8,9,10,9,7,4,4,2,6,4,6,8,6,11,7
+O,4,7,5,5,3,7,6,8,4,8,5,10,3,8,3,8
+C,6,10,7,7,4,5,7,6,8,11,9,14,2,9,4,5
+S,5,7,6,5,4,9,6,3,7,10,6,9,2,10,5,9
+Q,4,10,4,5,3,10,6,4,7,11,3,9,3,6,7,11
+V,4,6,4,4,2,3,12,5,4,11,12,7,3,10,1,8
+K,8,15,8,8,4,7,6,3,6,9,9,10,6,12,3,7
+G,6,11,7,8,6,6,7,7,5,8,7,11,5,7,6,6
+N,6,9,8,7,5,7,9,6,5,7,6,6,7,8,3,8
+C,3,4,4,3,2,4,8,4,7,10,10,13,1,9,2,7
+Q,6,8,6,10,6,8,6,7,4,9,6,10,4,9,7,6
+A,1,0,2,1,0,8,4,2,0,7,2,8,1,7,1,8
+U,4,5,5,4,2,4,8,5,7,11,10,9,3,9,2,6
+X,9,12,8,6,4,7,7,2,9,9,7,9,4,9,4,7
+I,1,4,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+O,3,8,4,6,3,8,7,8,6,7,5,9,3,8,3,7
+P,5,11,5,8,3,4,10,10,4,9,6,4,2,10,4,8
+L,4,10,5,7,7,7,7,3,5,7,7,10,6,10,6,6
+A,2,3,3,2,1,10,2,2,1,9,2,9,1,6,1,8
+D,1,0,1,0,0,6,7,6,5,7,6,6,2,8,2,8
+S,2,4,4,2,2,8,8,2,7,10,4,7,1,8,4,8
+U,5,9,7,6,6,8,8,8,5,6,7,9,3,8,4,5
+F,6,11,8,8,4,4,14,4,5,13,7,2,1,10,2,5
+Q,4,5,5,7,3,8,6,8,6,6,5,8,3,8,4,8
+E,3,7,3,5,2,3,8,6,10,7,6,14,0,8,7,8
+B,6,10,8,8,7,7,8,6,4,6,4,5,5,8,7,7
+B,1,0,2,1,1,7,7,7,5,6,6,7,1,8,7,9
+P,4,6,5,4,4,7,5,6,5,7,6,9,5,7,4,8
+B,1,0,1,0,1,7,7,6,4,7,6,7,1,8,6,9
+B,3,4,4,6,3,6,8,9,7,7,6,7,2,8,9,9
+Y,2,6,4,4,1,9,11,1,7,4,11,8,1,10,1,8
+Y,6,8,6,6,4,4,9,1,8,10,10,6,0,10,3,4
+R,5,10,6,7,3,5,11,9,4,7,4,8,3,7,6,11
+Y,6,7,8,9,8,10,10,5,3,6,7,8,6,11,8,4
+P,2,3,3,2,1,7,9,4,3,11,4,3,1,10,2,8
+G,6,10,8,7,5,6,6,6,6,6,6,8,4,7,4,8
+V,3,6,4,4,3,8,11,2,2,6,10,9,2,10,2,9
+K,4,5,7,3,4,6,8,1,7,10,7,10,3,8,3,7
+D,4,8,6,6,5,7,7,7,6,6,5,5,3,8,3,7
+Z,3,6,4,4,3,7,7,3,12,8,6,8,0,8,7,8
+N,9,10,8,6,3,5,8,5,7,3,3,11,6,10,3,7
+W,7,8,7,6,5,3,11,2,2,10,9,8,6,12,2,6
+V,7,8,9,7,10,8,7,4,5,7,6,8,7,10,8,5
+M,1,0,2,1,1,8,6,9,0,7,8,8,6,6,0,8
+S,4,9,5,6,3,9,9,6,10,5,5,5,0,7,9,7
+C,2,4,3,3,2,6,8,7,7,8,8,13,1,10,4,10
+K,2,4,3,2,2,5,7,4,7,7,7,11,3,9,5,10
+M,5,5,8,4,4,6,6,3,4,10,9,10,10,5,3,9
+L,6,9,5,5,2,7,4,3,5,10,4,12,2,7,6,7
+T,3,6,5,8,1,6,14,0,6,8,11,8,0,8,0,8
+N,8,11,11,8,5,6,9,3,5,10,8,8,6,8,1,7
+R,4,9,6,7,6,9,8,4,5,9,4,7,3,7,3,11
+G,6,10,7,8,9,8,6,4,4,6,5,9,7,7,8,13
+X,5,9,8,6,4,4,9,3,8,11,12,9,3,9,4,5
+O,4,7,6,5,6,8,7,5,2,7,6,8,8,9,4,7
+S,4,6,5,4,3,6,8,3,8,11,6,7,2,7,5,7
+R,4,10,5,8,5,5,10,8,3,7,4,9,2,7,5,11
+U,5,9,7,7,8,10,6,5,5,6,7,6,10,6,6,5
+J,2,5,3,7,1,13,2,9,4,14,4,12,1,6,0,8
+G,4,7,6,5,5,7,7,6,3,7,6,10,4,8,7,7
+E,2,3,4,1,2,6,8,2,7,11,7,8,1,8,3,7
+S,5,9,6,7,3,6,9,4,9,11,6,7,2,6,5,7
+W,3,3,4,1,2,5,11,3,2,9,8,7,5,11,1,6
+P,2,4,2,2,1,6,10,5,4,9,7,4,1,10,3,7
+G,2,3,4,2,2,7,6,6,5,6,6,9,2,9,4,9
+Q,2,4,3,5,3,8,7,6,3,8,6,9,2,9,4,9
+B,2,4,4,2,3,9,7,2,6,11,5,7,4,7,5,9
+B,4,10,6,8,6,9,7,3,5,10,4,6,2,8,5,9
+Q,1,1,2,1,1,8,7,6,4,6,6,8,2,8,3,8
+L,4,11,6,9,4,5,4,6,7,2,2,5,1,6,1,5
+G,4,9,5,7,4,5,6,6,5,9,7,12,2,8,4,10
+E,4,9,5,7,4,4,8,4,8,11,10,10,2,8,4,5
+E,6,9,8,7,5,9,7,2,10,11,4,9,2,8,5,9
+X,5,11,7,9,6,8,7,3,5,6,7,7,4,10,11,9
+Q,3,4,4,5,3,7,8,5,2,7,9,10,3,9,4,9
+N,10,13,8,7,4,7,10,4,7,3,4,9,5,7,2,7
+K,4,7,4,5,3,4,7,7,3,7,6,11,3,8,2,11
+O,3,3,4,5,2,8,7,9,7,7,5,9,3,8,4,8
+T,4,9,4,6,2,4,12,2,8,12,10,5,0,10,2,5
+P,1,3,3,2,1,7,9,3,4,12,5,4,1,9,2,9
+V,4,5,6,4,5,7,8,5,5,8,6,8,6,9,6,9
+E,4,5,5,7,3,3,7,6,11,7,7,15,0,8,7,7
+U,4,8,4,6,2,8,5,13,5,6,14,8,3,9,0,8
+Z,4,8,6,6,3,8,6,3,10,12,4,10,1,8,6,9
+D,7,10,9,8,8,7,8,6,6,8,7,6,7,8,3,7
+D,2,5,4,3,3,9,7,5,6,9,5,5,2,8,3,8
+N,5,7,6,6,7,7,8,5,3,7,5,7,8,7,5,7
+Q,1,2,2,3,2,8,7,6,3,5,6,9,2,9,3,9
+A,6,10,9,8,9,8,8,8,4,6,6,8,3,8,8,4
+J,2,8,3,6,3,7,7,1,6,11,5,9,1,6,1,6
+Z,5,8,7,10,6,11,5,3,5,9,2,7,2,7,6,9
+V,4,4,6,7,1,9,8,5,3,6,14,8,3,9,0,8
+S,3,5,5,4,2,9,7,3,8,11,3,6,1,9,4,10
+F,4,11,6,8,4,2,13,4,4,12,9,5,1,10,2,5
+D,4,7,6,5,4,8,7,4,7,11,5,7,3,7,4,8
+T,2,3,3,4,1,8,14,0,6,6,11,8,0,8,0,8
+K,2,3,4,2,2,6,8,1,6,10,6,8,3,8,2,7
+Y,3,3,5,4,1,7,11,2,2,7,12,8,1,11,0,8
+V,4,6,5,4,6,7,7,4,2,8,7,9,7,10,3,8
+X,3,8,5,6,3,7,8,4,9,6,6,7,3,9,7,7
+I,1,1,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+A,3,9,6,7,5,8,5,0,4,6,3,7,2,7,4,5
+Z,2,4,4,3,2,8,6,2,9,11,5,9,1,8,6,9
+J,2,4,3,3,1,9,5,4,6,14,6,12,0,7,0,8
+Q,5,11,7,8,7,8,4,7,4,5,7,11,6,6,8,8
+E,4,7,6,5,4,9,6,1,7,11,4,8,3,8,4,11
+F,2,3,3,1,1,6,11,3,5,13,6,4,1,9,1,7
+Q,4,7,4,9,4,8,8,6,3,8,9,11,3,9,6,7
+X,3,3,5,2,2,10,6,2,8,11,3,7,2,8,3,9
+F,3,6,3,4,2,1,13,3,3,12,10,6,0,8,2,7
+J,5,9,7,6,4,7,8,2,6,14,5,7,1,8,1,7
+F,3,3,4,4,1,1,15,5,3,12,9,4,0,8,2,6
+P,4,8,6,6,5,4,11,4,5,11,9,5,0,10,3,7
+L,4,9,4,6,1,0,0,6,6,0,1,5,0,8,0,8
+R,4,6,6,4,6,8,6,7,3,7,5,7,4,7,7,7
+G,8,14,7,8,4,8,4,5,3,8,4,5,4,7,5,8
+E,4,7,5,5,3,7,7,2,9,11,6,9,2,8,5,8
+C,2,1,3,2,1,6,8,7,7,8,8,13,1,9,4,10
+U,4,10,6,7,9,9,6,4,3,6,7,7,9,8,5,6
+N,6,9,8,4,3,8,7,3,4,13,5,8,6,8,0,8
+V,6,9,8,8,10,7,7,5,4,7,6,8,7,9,7,10
+I,5,6,6,4,3,7,6,2,7,7,6,9,0,9,4,8
+N,5,9,7,6,4,9,7,3,5,10,4,6,5,8,1,7
+H,5,8,8,6,6,5,8,3,6,10,8,8,4,8,4,6
+E,0,0,1,0,0,5,7,5,6,7,6,12,0,8,6,10
+Y,1,0,2,0,0,7,10,3,1,7,12,8,1,11,0,8
+G,5,9,7,7,5,6,7,7,5,5,6,11,4,8,4,8
+E,2,4,4,3,2,7,8,2,8,11,7,9,2,8,4,8
+N,5,4,5,6,2,7,7,15,2,4,6,8,6,8,0,8
+B,1,3,2,1,1,8,7,3,4,10,5,7,1,8,3,9
+G,4,7,5,5,3,7,6,7,7,7,5,11,2,9,4,8
+L,4,9,4,6,2,0,2,4,6,1,0,7,0,8,0,8
+E,4,7,6,5,5,8,9,7,3,6,6,11,4,7,7,10
+G,6,8,8,7,9,7,6,6,4,7,7,9,10,8,9,9
+M,4,10,6,8,6,7,6,6,5,7,7,9,8,5,2,8
+D,2,4,4,3,3,9,7,4,6,10,4,6,2,8,3,8
+Y,6,7,6,5,2,3,12,5,5,13,12,6,2,11,2,6
+R,5,5,5,6,3,5,12,8,3,7,2,9,3,7,6,11
+P,4,7,6,10,9,8,11,5,0,9,7,6,4,10,5,8
+D,3,9,5,7,5,8,7,5,7,7,6,5,3,8,3,7
+E,4,9,4,7,3,3,6,6,12,7,7,15,0,8,7,7
+W,4,5,6,4,3,7,11,2,3,7,9,8,7,11,1,8
+D,4,2,5,4,3,7,7,7,7,6,6,5,2,8,3,7
+Q,8,13,7,7,4,7,5,4,8,10,5,9,3,7,9,9
+R,4,7,5,5,5,7,8,5,6,6,4,8,3,6,5,9
+G,4,6,4,4,3,6,7,5,5,9,7,10,2,9,4,10
+Y,3,7,4,5,2,8,10,2,2,6,12,8,2,11,0,8
+R,5,8,7,6,7,7,10,3,5,5,6,9,6,7,7,7
+D,2,0,2,1,1,6,7,8,6,7,6,6,2,8,3,8
+J,4,11,5,8,5,9,6,2,5,11,4,9,1,6,2,5
+C,4,7,5,5,3,6,7,6,8,5,6,13,1,6,5,9
+I,3,7,4,5,1,6,8,1,8,14,7,8,0,8,1,7
+T,6,10,8,8,6,6,7,7,8,7,6,8,5,11,8,8
+C,1,0,1,0,0,7,7,5,7,7,6,14,0,8,4,10
+N,3,4,5,3,2,7,8,2,5,10,6,6,5,9,0,7
+M,5,5,6,4,4,8,6,6,5,6,7,8,10,6,4,6
+B,2,3,2,2,2,7,8,5,5,7,5,6,2,8,5,9
+H,3,7,5,5,4,7,7,5,6,7,6,9,6,8,3,7
+R,4,7,4,5,2,6,10,9,4,7,5,8,2,8,5,10
+Q,6,9,9,8,7,7,4,4,4,7,4,9,5,4,7,7
+A,3,6,5,4,1,9,4,3,1,7,1,8,3,6,2,8
+G,3,8,4,6,3,8,8,7,5,6,7,8,2,7,5,11
+Q,5,12,5,7,4,11,4,4,6,12,3,9,3,8,7,12
+H,3,3,4,4,2,7,8,14,1,7,5,8,3,8,0,8
+K,4,11,4,8,2,4,8,8,2,6,3,11,4,8,2,11
+G,4,10,5,8,3,7,5,8,9,8,4,13,1,9,5,10
+A,4,6,5,4,5,7,6,7,4,7,6,9,2,9,8,4
+A,4,9,6,7,4,10,3,2,2,8,2,10,5,5,3,8
+J,3,11,4,8,3,14,4,4,5,13,1,8,0,7,0,8
+K,4,6,5,4,5,6,5,4,4,6,6,9,3,6,7,11
+W,5,7,5,5,5,4,10,2,3,9,8,8,6,11,2,6
+N,2,1,2,3,2,7,8,5,4,7,6,7,4,8,1,6
+H,4,7,4,4,2,7,5,14,1,7,8,8,3,8,0,8
+L,5,10,4,5,2,9,3,4,4,12,4,13,2,6,6,9
+B,6,9,6,4,5,8,8,4,4,9,6,7,6,7,8,6
+E,5,11,5,8,3,3,8,6,11,7,6,15,0,8,7,7
+Y,5,8,5,6,3,5,9,1,7,9,9,5,1,11,3,5
+J,3,9,5,7,2,8,6,3,6,15,5,9,1,6,1,6
+N,1,0,1,0,0,7,7,10,0,6,6,8,4,8,0,8
+L,6,8,7,7,6,8,7,4,6,7,6,8,3,8,8,11
+S,3,6,5,4,6,6,9,3,3,8,7,6,3,8,9,1
+Q,5,9,6,8,6,8,7,7,5,6,7,8,3,8,4,9
+D,5,11,5,6,4,10,5,3,5,10,4,7,5,8,7,7
+E,6,10,8,8,5,5,9,2,10,10,8,9,3,8,5,5
+L,2,7,4,5,2,7,4,2,7,7,2,8,1,6,2,8
+G,6,10,7,8,5,6,6,6,5,9,6,12,4,8,5,8
+P,4,6,4,8,3,5,9,11,5,8,6,5,2,10,4,8
+K,3,6,4,4,2,3,7,6,3,7,6,11,3,8,3,11
+W,3,2,4,3,3,6,11,2,2,7,9,9,6,11,1,8
+O,3,9,5,6,4,8,8,8,4,7,8,8,3,8,3,8
+W,4,7,7,5,4,4,10,3,3,9,10,9,8,11,1,8
+A,4,9,3,4,2,11,5,4,1,8,4,9,4,6,4,9
+H,2,6,3,4,1,7,7,14,1,7,6,8,3,8,0,8
+T,2,8,4,6,3,7,12,3,6,7,11,8,2,12,1,8
+I,1,1,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+F,3,8,5,6,3,4,11,6,5,11,10,5,2,9,2,5
+I,1,9,1,6,2,7,7,0,7,7,6,8,0,8,3,8
+D,1,3,3,2,1,9,7,4,5,10,4,5,2,8,2,8
+T,5,6,5,4,3,5,10,1,8,11,9,5,1,9,3,4
+P,4,8,6,6,6,6,7,6,4,8,6,8,5,8,6,10
+Z,5,11,6,8,6,7,8,5,9,7,7,9,1,9,7,7
+I,0,4,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+D,4,9,6,7,6,9,7,4,6,10,5,5,3,8,3,8
+F,3,5,5,3,2,5,12,3,5,13,7,4,1,10,1,6
+G,5,7,6,5,3,8,6,6,7,11,6,12,2,10,4,8
+T,6,14,6,8,4,9,7,3,7,11,4,6,2,8,6,6
+C,5,9,6,6,3,4,8,6,8,12,10,12,2,9,3,7
+B,2,1,3,2,2,7,7,5,5,7,6,6,2,8,5,9
+H,2,6,4,4,5,9,6,3,3,6,6,7,5,9,6,7
+N,10,14,9,8,4,8,10,5,5,4,5,10,6,10,3,7
+E,1,3,3,2,1,6,7,2,7,10,7,9,2,8,4,9
+R,5,11,8,8,5,10,7,3,7,11,2,6,3,7,4,10
+U,5,7,6,5,5,8,7,8,5,6,7,9,3,8,4,6
+L,1,3,2,2,1,5,4,4,6,3,3,5,1,7,1,6
+P,3,8,3,6,3,5,9,8,3,9,6,5,2,10,3,8
+C,4,8,4,6,3,6,8,6,7,12,8,12,2,10,3,8
+N,3,2,4,3,2,7,8,5,4,8,7,7,5,8,3,6
+F,2,4,4,2,2,6,10,3,5,13,6,5,1,9,1,7
+I,0,6,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+Z,3,7,4,5,2,7,7,3,12,8,6,8,0,8,7,8
+F,3,4,4,6,2,1,12,5,6,12,11,9,0,8,2,6
+D,3,8,4,6,2,6,7,10,8,6,6,6,3,8,4,8
+G,3,7,4,5,3,7,7,7,6,6,6,9,1,8,5,11
+B,3,7,4,5,4,7,7,8,5,7,6,7,2,8,7,9
+S,4,11,4,8,4,8,6,7,7,7,8,9,2,10,10,7
+T,6,10,5,7,3,6,11,1,9,11,9,4,0,10,3,4
+Q,4,9,5,8,3,9,8,8,5,5,8,9,3,7,5,10
+V,3,10,5,8,2,8,8,4,3,6,14,8,3,9,0,8
+E,4,8,5,6,5,6,8,7,9,6,4,10,3,8,6,8
+A,6,7,8,6,6,7,7,3,6,7,8,9,5,10,3,6
+W,2,0,3,1,1,7,8,4,0,7,8,8,7,9,0,8
+K,7,11,9,8,9,8,7,5,5,7,6,7,7,6,9,14
+Y,4,7,6,9,7,9,10,7,4,7,7,6,5,11,6,3
+K,5,8,7,6,8,6,9,4,5,6,5,9,8,7,7,10
+L,5,10,5,5,2,7,4,3,6,11,4,13,2,6,6,8
+Q,2,0,2,1,1,8,7,6,4,6,6,8,2,8,3,8
+B,4,4,4,7,4,6,8,9,7,7,6,7,2,8,9,10
+S,4,7,5,5,3,8,8,3,7,10,3,6,2,6,5,9
+F,2,2,3,4,2,6,9,3,5,10,9,5,4,10,3,8
+S,3,7,4,5,3,8,7,7,7,7,7,8,2,9,9,8
+Q,6,9,7,11,7,9,5,7,4,9,5,11,4,8,6,6
+L,2,1,2,2,1,4,4,4,7,2,1,6,0,7,1,6
+T,5,10,7,8,4,5,12,3,8,8,12,8,1,12,1,7
+P,6,10,8,8,5,7,10,5,4,12,5,3,1,10,3,8
+A,2,6,4,4,2,8,3,2,2,7,1,8,2,7,3,7
+K,3,5,5,4,3,5,7,1,7,10,8,11,3,8,3,8
+F,2,3,3,2,1,6,10,3,5,13,6,4,1,9,1,8
+D,2,3,3,2,2,7,7,6,6,6,6,4,2,8,3,7
+Q,4,4,6,6,6,9,10,5,0,5,7,10,6,13,4,10
+L,3,6,4,4,2,4,3,7,6,1,2,4,1,6,1,6
+G,6,11,7,8,6,8,7,7,6,6,5,9,2,7,5,11
+C,5,9,7,7,5,7,7,8,6,7,6,13,6,8,5,7
+N,5,9,7,7,4,7,9,6,5,7,7,7,6,8,2,7
+K,5,7,7,5,5,7,6,1,6,10,5,9,3,7,3,9
+I,0,8,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+P,5,10,7,7,6,7,10,5,3,11,5,3,1,10,3,8
+R,3,3,3,4,2,6,9,9,4,7,5,7,3,7,5,11
+O,6,10,6,7,4,9,6,8,6,9,4,7,3,8,4,8
+X,2,3,3,1,1,6,8,2,8,10,8,9,2,8,2,7
+V,4,10,6,8,3,8,12,3,4,5,11,9,3,10,1,7
+H,6,11,8,8,8,7,8,6,8,8,6,8,9,7,4,8
+A,3,5,6,4,2,10,2,2,2,8,2,9,4,6,2,9
+R,2,4,4,3,2,9,7,3,5,10,4,6,2,7,3,9
+Y,4,11,6,8,3,6,10,1,7,7,12,9,1,11,2,8
+K,3,6,5,4,5,6,7,4,4,7,6,8,4,6,8,13
+S,9,14,9,8,4,7,6,4,3,13,9,9,3,10,3,9
+X,5,10,7,8,4,9,6,1,8,10,3,7,3,8,4,8
+E,4,11,5,8,7,5,7,6,8,6,5,11,3,8,5,9
+T,3,4,4,3,1,5,13,3,6,11,9,4,1,11,1,5
+D,3,6,5,4,3,9,7,4,5,11,5,6,3,8,2,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+I,2,9,2,7,2,7,7,0,8,7,6,9,0,8,3,8
+W,4,2,6,4,4,5,11,3,2,8,9,9,10,13,1,8
+X,1,1,2,2,1,8,7,3,8,6,6,8,2,8,6,8
+B,4,8,6,6,6,9,6,4,6,10,4,7,3,8,5,10
+I,4,9,6,6,3,9,8,2,8,7,6,6,0,8,4,7
+H,2,3,3,2,2,7,7,5,5,7,6,8,3,8,2,8
+F,4,6,6,4,3,6,11,4,5,12,7,5,2,9,2,6
+S,4,4,5,6,3,8,6,5,9,5,6,8,0,8,9,8
+J,4,8,5,6,2,10,6,2,8,14,3,8,0,7,0,8
+M,8,11,11,8,7,12,5,3,6,10,2,6,10,9,2,9
+N,5,6,7,4,6,5,9,3,4,8,7,9,6,8,4,4
+A,4,9,7,7,4,9,3,2,3,6,1,7,2,6,2,7
+R,2,4,4,3,2,9,8,3,5,10,3,6,2,6,3,10
+J,3,6,5,4,2,7,9,1,6,14,5,6,0,7,0,7
+S,5,10,8,8,10,7,6,3,2,7,5,7,3,8,15,5
+N,3,5,3,4,2,7,9,5,4,7,6,7,5,8,2,7
+K,4,4,4,5,2,3,7,8,2,7,5,11,4,8,2,11
+P,4,7,6,5,3,8,10,3,6,13,4,2,1,10,3,9
+J,5,9,4,6,3,9,8,2,3,12,4,5,2,9,6,9
+N,2,7,3,5,3,7,7,11,1,6,6,8,5,8,0,8
+W,8,11,8,9,8,4,11,2,2,9,8,7,7,12,2,6
+W,1,0,2,1,1,7,8,4,0,7,8,8,5,10,0,8
+G,6,11,8,8,5,6,6,6,7,6,6,8,3,8,4,7
+G,3,4,4,6,2,7,6,8,7,6,6,9,2,7,5,11
+V,6,7,6,5,2,3,11,4,4,10,12,7,2,10,1,7
+N,4,9,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+E,3,7,5,6,5,7,6,5,3,7,6,10,5,10,6,11
+P,4,10,6,8,6,6,10,5,5,10,8,3,1,10,4,6
+H,3,4,5,6,5,8,11,4,2,8,7,6,4,11,8,4
+J,1,3,2,1,0,9,7,2,6,14,5,9,0,7,0,7
+X,2,6,4,4,3,8,8,2,5,7,5,7,3,8,5,7
+L,5,10,5,8,2,0,0,6,6,0,1,5,0,8,0,8
+G,3,5,4,3,2,6,6,6,5,8,7,11,2,8,4,10
+V,3,5,6,4,2,7,12,2,3,6,11,9,4,12,2,7
+Q,3,8,5,7,4,8,7,7,5,6,6,9,3,8,4,10
+Z,3,7,4,5,3,7,7,3,12,8,6,8,0,8,8,7
+D,8,13,7,7,6,9,6,4,6,10,4,7,6,7,9,7
+H,3,7,3,5,3,8,6,12,2,7,8,8,3,9,0,8
+K,3,3,3,4,1,3,6,7,2,7,6,11,3,8,2,11
+T,3,7,4,5,2,4,13,4,6,12,9,4,1,11,1,5
+U,7,8,8,6,3,2,10,6,7,12,12,9,3,9,1,7
+Q,7,15,6,8,5,11,5,4,6,11,4,7,3,9,7,13
+W,6,10,10,8,8,7,11,2,2,6,8,8,8,12,1,8
+E,4,7,6,5,4,7,7,3,8,11,7,9,2,9,5,8
+R,3,6,3,4,2,5,11,7,4,7,3,9,2,7,6,11
+F,3,7,5,5,2,3,12,4,4,13,9,5,1,10,2,6
+K,5,9,7,7,5,6,7,5,7,6,6,10,4,8,5,9
+H,4,8,5,6,4,7,7,13,1,7,6,8,3,8,0,8
+H,4,7,7,5,5,5,9,3,5,10,9,8,3,8,3,5
+W,3,4,4,2,2,5,11,2,2,9,8,7,6,11,1,6
+L,4,8,6,6,7,7,7,3,5,7,7,10,6,10,6,6
+S,8,14,8,8,4,8,6,4,4,13,7,8,3,10,4,8
+R,4,9,6,6,5,9,7,6,3,8,5,6,4,7,7,9
+F,5,10,6,8,4,4,11,4,6,11,10,5,2,10,2,5
+U,8,9,9,7,5,3,9,5,8,10,10,10,3,9,2,6
+X,4,6,6,4,3,7,7,1,8,10,7,9,2,8,3,7
+P,2,1,2,1,1,5,11,8,1,9,5,4,1,9,3,8
+K,3,6,4,4,3,6,7,4,7,6,6,10,3,8,5,9
+U,3,5,4,4,2,6,8,6,7,7,10,9,3,9,1,8
+P,3,6,5,4,3,5,11,4,5,11,8,3,1,10,4,7
+K,7,10,10,8,7,4,7,2,7,10,10,11,3,8,3,6
+W,4,6,6,4,4,10,11,3,2,5,9,7,6,11,1,8
+W,5,10,7,8,6,8,8,4,1,7,9,8,8,11,0,8
+M,2,0,3,1,1,8,6,10,0,7,9,8,7,6,0,8
+U,4,8,5,6,2,7,4,14,5,7,14,8,3,9,0,8
+M,4,6,6,4,5,6,6,3,4,10,8,9,7,5,2,7
+J,5,8,6,6,3,7,6,3,6,15,6,10,1,6,0,7
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+C,7,10,9,8,6,6,8,8,6,5,6,13,6,8,5,6
+U,4,7,6,6,6,7,6,4,4,6,6,8,7,7,1,7
+P,6,10,6,5,4,7,10,4,3,12,5,3,4,11,5,7
+B,4,10,6,8,7,7,8,5,5,9,7,6,4,8,7,8
+N,6,9,8,7,7,6,7,8,6,7,5,6,3,8,3,8
+U,5,10,7,8,5,5,9,6,8,8,10,9,3,9,1,8
+Z,4,8,5,6,4,8,6,2,9,11,5,9,1,8,5,9
+H,7,8,10,10,9,6,4,5,3,6,3,6,6,5,11,7
+A,2,8,4,6,2,7,6,3,1,6,0,8,2,7,1,7
+Q,6,6,8,9,9,9,11,4,1,5,8,11,6,14,7,13
+W,9,12,9,6,5,2,10,3,3,10,11,9,7,10,1,6
+B,4,6,5,4,4,9,7,3,6,9,5,6,2,8,5,8
+B,8,12,6,6,4,10,5,5,5,11,3,9,6,7,6,10
+W,4,3,5,2,2,4,11,3,2,10,9,7,6,11,1,7
+A,4,5,6,4,5,7,8,3,5,7,8,9,7,10,3,7
+X,1,3,2,1,1,7,7,3,7,6,6,9,2,8,5,8
+W,2,3,3,2,2,9,10,3,2,5,9,7,5,11,0,7
+O,10,14,6,8,4,6,6,7,4,10,6,10,5,9,5,8
+V,5,6,5,4,2,2,12,5,4,12,11,7,2,10,1,7
+V,3,7,5,5,1,9,8,4,2,6,14,8,3,10,0,8
+U,3,7,4,5,2,7,5,12,4,6,12,8,3,9,0,8
+G,3,5,4,4,2,6,7,6,6,10,7,10,2,9,4,9
+O,4,5,5,4,4,7,6,5,5,9,5,10,4,6,5,6
+A,2,7,4,4,1,7,6,3,1,6,0,8,2,6,1,8
+Z,8,7,6,11,5,4,13,4,2,12,8,5,2,8,8,6
+I,7,10,9,8,5,9,5,3,7,6,7,4,0,9,4,7
+Y,8,11,8,8,5,3,10,2,7,11,11,6,1,11,3,4
+L,4,9,4,4,3,8,5,3,5,11,5,10,3,5,6,8
+G,3,6,4,4,2,6,7,5,5,5,7,8,2,8,4,8
+R,7,10,7,5,5,6,8,3,4,7,4,10,6,8,6,7
+V,4,9,6,7,4,5,11,3,2,9,10,7,4,10,6,8
+Y,4,8,6,6,3,7,9,1,7,6,12,9,2,11,2,8
+L,3,7,4,5,3,4,4,4,8,2,1,7,4,6,1,6
+P,3,8,3,6,2,5,9,10,5,8,6,5,2,9,4,8
+L,2,1,2,2,1,4,4,5,6,2,2,6,1,7,1,6
+I,4,7,6,5,3,8,8,2,8,7,6,7,0,8,4,7
+O,5,8,5,6,5,8,7,7,4,9,5,8,3,8,3,8
+O,1,3,2,2,1,8,6,6,3,9,5,7,2,8,2,7
+K,4,8,4,5,2,4,7,8,2,7,6,11,4,8,2,11
+Z,6,11,8,8,5,6,9,3,11,11,9,6,2,8,6,5
+Q,7,10,9,8,8,8,5,8,4,6,7,8,4,6,7,8
+D,3,9,5,7,8,9,8,5,4,7,6,6,4,7,8,6
+M,7,10,10,8,6,5,7,3,5,10,10,10,8,5,3,7
+J,2,11,3,8,3,7,7,1,6,11,5,9,1,6,2,5
+N,3,7,5,5,3,6,9,3,4,10,8,8,5,8,1,7
+A,4,11,6,8,3,5,4,3,3,5,1,7,3,6,3,7
+H,5,8,7,6,6,7,7,5,5,7,6,8,9,7,5,10
+K,5,7,7,6,6,6,7,3,4,6,4,9,6,5,9,8
+E,5,7,7,5,5,8,6,1,8,11,4,9,3,8,5,10
+G,2,4,4,3,2,7,7,6,6,6,6,10,2,9,4,9
+K,3,5,4,4,3,5,7,4,7,7,6,11,3,8,5,10
+E,4,9,4,7,4,3,8,5,9,7,6,14,0,8,6,9
+Y,4,6,6,9,9,8,4,5,3,7,8,8,7,8,5,8
+D,4,8,5,6,7,9,8,4,5,7,6,6,4,7,7,4
+L,2,2,3,3,1,4,3,5,6,2,2,5,1,7,0,6
+W,6,9,6,6,5,4,10,2,3,9,8,7,7,11,2,6
+J,2,2,3,4,2,10,6,2,5,12,4,8,1,6,1,6
+T,2,3,3,2,1,7,12,3,6,7,11,8,1,11,1,8
+Y,3,7,6,5,2,9,10,2,7,3,12,8,2,11,2,9
+F,3,5,5,4,2,4,12,4,4,13,8,5,1,10,1,7
+X,4,7,5,5,1,7,7,6,2,7,6,8,3,8,4,8
+J,0,0,1,0,0,12,4,5,3,12,5,11,0,7,0,8
+T,7,9,7,7,5,6,11,4,6,11,9,4,2,12,2,4
+Q,2,2,3,3,2,8,7,6,2,6,6,9,2,9,3,10
+J,2,4,3,3,1,10,6,2,6,12,3,8,0,7,0,7
+L,1,0,1,1,0,1,1,5,5,0,1,6,0,8,0,8
+N,3,7,4,5,3,7,8,5,4,7,6,6,5,9,1,6
+H,4,5,7,4,4,6,7,3,7,11,9,9,5,8,5,6
+Z,3,6,5,4,3,8,7,2,10,11,5,9,1,8,6,9
+Q,2,1,3,2,1,8,7,7,5,6,6,8,3,8,4,8
+N,4,10,6,7,5,7,8,10,5,8,5,5,4,8,4,10
+U,6,7,6,5,3,4,8,6,8,10,10,9,3,9,2,5
+L,8,11,7,6,3,11,1,3,4,12,3,11,2,9,4,10
+G,4,6,5,4,5,9,9,5,2,6,7,8,6,9,4,9
+P,5,9,7,7,7,5,9,6,4,8,7,9,5,9,7,10
+Q,4,6,6,9,3,8,9,7,6,6,9,9,4,7,6,10
+L,4,8,6,6,3,7,4,1,8,8,2,10,0,6,3,8
+R,4,7,4,5,4,5,10,7,3,7,4,9,2,7,5,11
+O,4,7,6,5,4,7,6,8,5,7,4,8,3,8,3,8
+M,3,7,5,5,5,8,7,5,4,6,7,8,7,6,2,7
+F,1,0,1,0,0,3,12,4,3,11,9,6,0,8,2,8
+M,6,8,8,6,8,7,8,7,5,6,6,8,7,9,8,11
+Q,4,9,4,4,3,11,4,4,5,12,3,9,3,8,7,13
+E,5,11,6,8,7,6,7,5,8,7,6,10,3,8,6,9
+Q,4,5,5,8,7,9,7,5,0,6,6,10,7,10,4,9
+G,2,4,3,2,2,6,7,5,5,9,7,10,2,8,4,10
+L,5,9,6,6,4,4,5,2,8,6,2,10,0,7,3,6
+H,8,10,11,8,9,8,7,2,6,10,5,8,3,8,3,8
+A,2,2,4,3,2,8,3,2,3,8,1,8,2,6,2,7
+D,3,1,4,2,2,7,7,6,6,7,6,5,2,8,3,7
+S,4,6,6,4,7,7,7,3,2,8,6,7,2,8,12,3
+U,2,3,3,2,1,5,8,5,6,10,9,8,3,9,2,6
+B,10,13,7,8,5,10,5,5,6,11,3,9,6,7,7,11
+J,4,11,6,8,4,10,5,4,5,14,4,10,0,7,1,6
+X,7,10,10,8,6,4,8,2,8,10,11,10,3,9,3,5
+G,2,2,4,4,2,7,6,6,5,6,6,9,2,9,4,9
+Z,4,11,6,8,4,7,8,2,10,11,8,6,2,7,6,6
+D,5,9,7,7,6,7,7,5,6,7,6,8,7,7,3,7
+M,2,0,2,1,1,7,6,10,0,7,8,8,6,6,0,8
+Q,4,5,4,6,4,8,6,7,4,9,8,9,3,9,6,8
+V,4,11,6,8,3,7,9,4,2,7,13,8,2,10,0,8
+P,4,8,5,6,3,8,8,1,6,13,5,5,1,10,2,9
+X,5,10,6,8,4,7,7,4,4,7,6,8,3,8,4,8
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+I,7,12,5,6,3,11,4,5,5,13,3,8,3,7,4,9
+L,4,3,4,5,1,1,0,6,6,0,1,4,0,8,0,8
+N,3,6,4,4,2,7,7,14,2,5,6,8,6,8,0,8
+H,5,6,7,4,5,9,6,3,6,10,4,7,3,8,3,9
+R,4,7,6,5,5,8,9,6,5,8,5,8,4,7,5,11
+G,5,12,4,6,4,7,6,4,2,8,6,8,4,9,9,7
+A,4,11,6,8,4,7,5,3,0,6,1,8,2,7,1,8
+O,5,10,6,8,5,7,7,9,4,7,6,9,3,8,4,6
+S,6,12,5,6,3,8,3,2,5,8,1,7,3,7,5,8
+O,5,9,7,7,5,8,6,8,4,6,4,7,3,9,4,9
+R,5,9,5,7,5,6,8,8,4,6,5,7,3,8,6,13
+B,4,11,4,8,6,6,6,9,6,7,7,7,2,9,7,10
+K,5,9,8,7,9,8,6,3,5,6,6,8,8,6,9,5
+S,4,7,4,5,2,7,6,5,9,5,6,9,0,9,9,8
+O,3,8,4,6,3,8,8,7,5,7,6,9,2,8,3,8
+I,1,10,0,8,1,7,7,5,3,7,6,8,0,8,0,8
+K,4,9,6,8,7,8,5,2,3,8,4,8,5,6,7,11
+O,3,7,4,5,2,7,9,9,7,8,8,7,3,8,4,8
+E,3,6,5,6,5,6,9,4,4,7,7,11,4,9,7,10
+E,5,11,7,9,6,5,7,7,9,7,6,12,3,8,6,8
+A,5,11,8,8,4,10,2,2,3,9,1,8,3,7,4,8
+Q,6,11,6,6,4,10,5,4,6,10,4,8,3,9,7,12
+A,4,10,6,8,5,12,3,2,2,9,2,8,2,6,2,8
+P,4,9,6,7,4,7,10,4,4,12,5,3,1,10,3,8
+N,4,6,5,4,3,7,8,6,5,7,6,6,5,9,1,6
+K,3,4,5,3,2,4,9,2,7,10,9,11,3,8,3,6
+X,6,11,9,9,6,7,7,0,8,9,6,8,3,8,3,7
+C,4,9,6,8,6,6,7,4,4,7,6,10,5,9,9,11
+D,4,7,6,5,5,8,8,6,5,9,5,4,5,8,5,9
+D,2,4,4,2,2,9,6,3,6,11,4,6,2,8,3,8
+A,5,11,7,8,7,8,7,7,4,7,6,9,3,8,8,3
+E,5,11,7,8,8,8,5,7,3,8,6,11,5,8,8,10
+H,3,5,5,7,5,9,10,3,1,8,6,7,3,10,8,7
+H,3,7,4,5,4,8,7,5,6,7,6,9,3,8,3,8
+S,1,3,2,2,1,8,6,6,5,7,7,9,2,10,8,7
+V,5,10,5,5,3,6,9,4,3,9,7,5,5,12,2,8
+Y,8,10,8,7,5,2,11,2,7,12,12,7,0,10,1,5
+E,1,3,2,1,1,5,8,2,7,10,8,9,1,8,3,7
+Y,1,0,1,0,0,7,10,2,2,7,12,8,1,11,0,8
+Y,1,0,2,0,0,7,10,1,3,7,12,8,1,11,0,8
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+T,3,9,5,6,1,7,15,1,6,7,11,8,0,8,0,8
+Q,1,0,1,1,0,8,7,6,3,6,6,9,2,8,2,8
+A,2,4,4,6,2,7,3,3,3,7,1,8,3,6,3,8
+U,4,7,4,5,3,7,5,13,4,7,11,8,3,9,0,8
+S,2,6,3,4,3,8,8,7,6,7,4,6,2,6,8,8
+U,4,6,5,4,3,6,8,6,8,7,10,9,3,9,1,8
+C,3,6,4,4,1,6,7,6,10,7,6,13,1,8,4,9
+X,4,11,6,8,4,7,8,3,9,6,5,6,4,10,8,6
+Z,4,6,5,4,3,8,6,2,10,12,5,10,1,9,6,9
+D,3,4,5,3,3,8,7,4,6,9,5,6,2,8,3,8
+G,2,0,2,1,1,8,6,6,5,6,5,9,1,8,5,10
+D,2,4,4,3,2,9,6,4,6,11,4,6,2,8,3,8
+A,3,4,5,3,2,10,2,2,2,9,2,9,2,6,2,8
+U,4,7,5,5,4,9,7,7,5,7,6,8,3,8,4,6
+O,6,10,7,8,6,7,7,8,4,7,6,8,3,8,3,8
+C,5,8,6,6,6,5,6,3,5,8,6,12,6,9,4,9
+B,2,4,4,3,3,8,7,3,6,10,5,6,2,8,4,10
+K,6,12,6,6,4,7,7,3,6,10,3,8,5,5,3,8
+J,5,10,6,7,7,9,6,3,4,7,5,5,5,6,6,5
+Z,4,8,4,6,4,9,7,5,9,7,5,6,1,7,7,8
+W,4,5,6,7,4,7,8,5,2,6,8,8,8,9,0,8
+J,2,8,3,6,2,10,6,1,7,11,3,7,0,7,1,7
+X,5,10,7,8,6,8,5,3,5,6,7,7,3,10,9,9
+E,2,6,3,4,2,3,8,5,9,7,6,14,0,8,6,9
+H,5,11,6,8,3,7,5,15,2,7,9,8,3,8,0,8
+M,4,1,5,3,3,9,6,6,4,6,7,5,8,6,2,6
+R,4,8,6,6,8,7,7,3,5,7,6,8,6,9,7,5
+D,3,6,4,4,3,7,7,6,5,7,7,6,3,8,3,7
+U,4,7,6,5,7,8,7,4,3,6,7,8,7,9,5,7
+N,3,7,4,5,2,7,7,14,2,5,6,8,5,8,0,8
+X,5,5,6,7,2,7,7,5,4,7,6,8,3,8,4,8
+S,2,3,4,2,1,9,7,3,7,11,4,8,1,8,4,10
+H,4,8,6,6,6,7,7,5,6,7,6,8,3,8,3,7
+P,3,6,5,4,4,6,9,5,4,9,7,4,1,10,3,7
+G,1,3,2,1,1,7,7,4,4,9,7,10,2,8,4,10
+J,4,8,3,6,2,9,6,2,4,11,6,8,2,10,6,11
+J,1,7,2,5,1,14,2,6,5,13,1,10,0,7,0,8
+C,4,8,6,6,5,6,6,3,4,8,6,11,6,9,3,9
+R,3,5,5,4,5,7,8,3,3,7,5,8,6,8,5,7
+Y,6,9,8,6,7,8,4,6,5,8,7,8,8,9,4,6
+K,5,10,8,7,5,3,8,2,7,10,11,12,4,7,4,5
+N,3,9,4,6,2,7,7,14,2,5,6,8,5,8,0,8
+Z,4,6,6,4,4,9,10,5,5,6,5,7,3,8,6,5
+P,2,3,2,2,1,4,11,3,4,10,8,4,0,9,3,6
+L,5,7,6,5,5,7,8,7,6,6,5,8,6,7,4,10
+Z,4,8,6,6,4,7,8,2,9,11,6,8,1,8,6,8
+X,3,5,4,3,2,8,7,3,9,6,7,9,3,7,7,9
+Z,4,4,5,6,2,7,7,4,14,9,6,8,0,8,8,8
+W,3,3,4,5,3,10,8,4,1,6,8,8,7,10,0,8
+P,5,10,8,8,6,8,10,4,5,13,5,3,1,10,3,8
+D,1,0,2,1,1,6,7,8,6,7,6,6,2,8,3,8
+K,3,5,5,4,3,8,7,2,7,10,4,9,5,10,4,9
+L,2,5,4,4,2,7,4,1,8,8,2,10,0,7,2,8
+K,4,7,6,5,3,8,6,2,7,10,3,9,3,8,4,10
+C,1,0,1,1,0,6,7,6,8,7,6,14,0,8,4,10
+Z,2,5,3,3,2,7,8,5,9,6,6,9,2,8,7,8
+Y,4,7,6,5,2,5,10,2,8,10,12,8,1,11,2,7
+E,2,5,4,3,2,7,7,1,8,10,6,9,2,8,4,8
+I,6,14,5,8,3,7,9,2,6,14,5,6,1,8,5,8
+A,2,7,4,5,2,10,3,2,2,9,2,9,2,6,2,8
+M,6,10,8,7,9,7,10,6,4,7,7,9,8,10,7,11
+A,3,11,6,8,3,11,2,3,3,10,1,9,3,7,3,8
+V,7,10,9,8,5,6,11,3,3,7,11,8,3,10,4,8
+P,3,8,4,6,4,6,9,6,4,9,7,4,2,10,3,7
+N,8,12,9,7,4,8,6,2,4,13,5,8,6,8,0,7
+S,5,10,6,8,4,8,7,5,8,11,3,8,2,7,5,9
+Z,4,9,6,7,5,9,11,6,5,6,5,7,3,9,8,5
+Q,5,10,6,9,5,8,8,7,4,5,8,9,3,8,5,10
+U,4,9,5,7,2,8,5,13,5,6,14,8,3,9,0,8
+M,4,5,7,4,4,8,7,2,4,9,6,8,7,5,2,7
+D,4,4,5,6,3,5,7,10,9,6,6,5,3,8,4,8
+Z,1,1,2,3,1,7,8,5,8,6,6,9,1,9,7,8
+Y,1,0,2,0,0,7,10,3,1,7,12,8,1,11,0,8
+D,1,0,2,1,1,6,7,8,6,7,6,6,2,8,3,8
+J,1,4,2,3,1,10,6,2,6,12,4,8,0,7,1,7
+V,5,7,5,5,2,3,12,5,4,12,12,7,2,10,1,8
+U,4,9,6,6,9,8,7,4,3,6,7,8,7,10,5,7
+J,2,10,3,8,1,12,3,10,3,13,7,13,1,6,0,8
+N,5,11,8,8,9,6,7,3,4,8,8,9,7,10,7,6
+G,6,9,6,6,4,5,7,6,6,9,8,10,2,8,5,9
+O,4,8,6,6,5,8,7,8,4,7,6,7,3,8,3,7
+D,5,11,6,8,3,5,7,11,9,7,7,5,3,8,4,8
+D,2,1,2,1,1,7,7,6,6,7,6,5,2,8,2,7
+M,6,9,7,7,6,8,5,11,0,7,9,8,12,4,4,8
+N,7,8,9,7,8,7,8,5,5,7,5,7,6,9,5,4
+Q,3,6,4,5,3,8,7,7,5,6,4,9,2,8,4,9
+I,4,11,5,8,3,7,7,0,7,13,6,8,0,8,1,8
+P,5,10,7,8,6,7,11,6,3,11,5,3,2,11,3,9
+V,3,9,5,7,1,6,8,4,3,7,14,8,3,9,0,8
+E,3,7,4,5,2,3,8,6,11,7,6,15,0,8,7,7
+F,2,8,3,5,1,1,13,4,3,12,10,5,0,8,3,7
+J,4,7,5,5,2,7,7,3,6,15,6,10,1,6,1,7
+S,3,10,4,8,4,8,6,8,5,7,7,9,2,9,8,8
+S,5,6,6,6,6,8,9,4,5,7,7,8,4,10,9,10
+B,2,3,4,2,2,8,7,3,5,10,5,6,2,8,4,9
+P,5,9,6,7,6,7,5,7,4,7,6,8,3,8,7,10
+Q,1,0,2,1,0,8,7,6,3,6,6,9,2,8,3,8
+B,3,8,5,6,4,7,8,5,6,9,7,5,2,8,7,6
+K,4,9,6,8,6,9,6,2,4,9,3,8,5,6,7,11
+G,5,7,7,6,6,8,10,5,3,6,7,10,8,11,7,8
+E,5,5,5,7,3,3,7,6,12,7,6,15,0,8,7,6
+Y,2,4,4,3,1,7,11,1,7,7,11,8,1,11,2,8
+O,1,3,2,1,1,8,7,6,4,7,6,8,2,8,2,8
+K,6,8,9,6,5,7,5,2,8,10,4,10,5,5,5,9
+N,8,11,11,8,7,4,11,3,4,10,10,8,6,8,1,7
+X,5,10,6,7,2,7,7,5,4,7,6,8,3,8,4,8
+J,6,11,7,8,3,9,5,4,7,15,4,11,1,6,1,7
+A,3,7,5,5,3,12,2,2,2,10,2,9,2,6,3,8
+Z,4,7,5,5,3,8,6,2,10,11,5,10,2,8,6,9
+R,2,1,2,2,2,6,8,4,5,6,5,7,2,6,4,9
+E,2,1,2,1,1,4,7,5,8,7,6,13,0,8,7,9
+D,4,7,5,5,4,10,6,3,6,11,4,7,3,8,3,9
+X,7,15,8,8,5,11,7,2,7,11,3,5,3,11,4,9
+O,5,9,5,7,4,7,7,8,5,10,7,8,3,8,3,8
+A,2,6,4,4,2,12,3,4,2,11,1,8,2,6,2,9
+F,4,8,4,6,2,1,11,5,7,12,11,9,0,8,2,6
+S,7,13,5,7,3,8,2,1,5,7,2,7,3,7,4,10
+N,1,1,2,2,1,7,7,11,1,5,6,8,4,8,0,8
+F,6,10,6,6,4,10,7,3,5,11,4,5,3,9,6,9
+Y,2,1,4,3,2,8,11,1,7,5,11,8,1,11,2,8
+K,7,10,11,8,7,2,8,3,7,11,12,12,4,7,4,4
+W,3,6,5,4,4,7,11,2,2,7,8,8,6,11,1,8
+U,4,5,5,3,2,6,8,5,8,6,10,9,3,9,1,7
+A,3,8,6,6,3,11,2,2,3,9,2,9,3,5,3,8
+V,11,14,9,8,4,8,9,6,5,7,10,5,7,13,3,8
+U,4,8,5,7,6,7,7,5,3,6,7,8,4,8,1,7
+X,2,3,3,2,1,7,8,1,7,10,7,8,2,8,2,7
+K,5,10,6,7,2,4,8,8,2,7,4,11,4,8,2,11
+Y,9,10,7,14,6,6,6,6,4,6,12,6,5,10,6,5
+T,8,13,7,7,4,6,10,3,7,12,7,6,3,9,5,4
+S,5,9,6,6,4,7,7,4,7,10,9,9,2,10,5,6
+Q,5,8,6,7,3,8,9,8,6,5,8,9,3,7,6,10
+Q,5,6,5,8,6,8,6,6,3,9,6,9,3,8,5,8
+L,5,5,5,8,1,0,0,6,6,0,1,5,0,8,0,8
+A,3,3,5,5,2,9,4,3,1,8,1,8,2,7,2,8
+R,3,7,5,5,5,5,8,3,4,6,5,9,4,7,6,5
+F,6,7,8,8,8,7,9,4,4,7,6,7,4,9,9,8
+P,4,8,6,6,5,6,9,7,4,9,7,4,2,10,3,7
+X,3,5,4,4,4,8,8,2,5,8,6,7,2,7,6,7
+O,1,0,2,0,0,7,6,6,4,7,6,8,2,8,3,8
+W,7,7,7,5,5,6,10,4,3,8,7,7,9,13,3,4
+P,8,9,6,4,3,8,7,5,4,11,3,6,5,8,4,8
+U,5,8,6,6,5,8,8,8,5,6,7,9,3,7,4,6
+V,7,10,9,8,6,9,10,4,2,4,10,9,6,10,5,10
+S,4,10,4,7,2,8,7,6,9,5,6,7,0,8,9,8
+O,1,3,2,2,1,8,7,6,3,8,6,8,2,8,2,8
+O,3,5,4,4,3,7,7,8,5,7,6,8,2,8,3,8
+R,3,3,4,2,2,7,8,5,5,7,5,7,2,7,4,8
+S,4,9,4,7,3,8,7,8,7,8,6,8,2,9,9,8
+Q,4,6,5,5,4,5,4,4,5,5,4,7,4,4,6,6
+H,3,5,4,4,4,7,8,6,6,7,6,8,3,8,3,8
+Z,5,9,6,7,7,8,7,3,8,8,6,8,1,7,12,9
+F,3,6,3,4,1,1,13,5,4,12,10,7,0,8,2,6
+P,5,9,7,6,4,9,8,4,6,12,4,4,2,9,4,9
+N,2,3,2,2,1,6,8,5,4,8,7,7,4,8,1,6
+T,7,9,7,7,4,5,11,2,8,11,10,5,1,11,2,4
+F,5,7,7,5,3,7,9,2,7,14,5,5,2,8,3,8
+M,5,9,7,7,6,7,6,3,4,10,8,9,11,5,3,9
+S,3,7,4,5,2,7,6,5,9,5,6,10,0,9,9,8
+S,3,5,5,3,2,8,6,2,7,10,7,9,2,9,5,8
+S,7,10,8,7,5,8,7,3,6,10,5,7,2,8,5,9
+X,4,10,5,7,2,7,7,5,4,7,6,8,3,8,4,8
+D,2,3,2,2,2,7,7,6,6,7,6,5,2,8,2,7
+L,1,0,1,0,0,2,2,5,4,1,2,5,0,8,0,8
+I,1,6,2,4,1,7,7,0,7,13,6,9,0,8,1,8
+Z,2,6,3,4,1,7,7,3,13,9,6,8,0,8,8,8
+Q,4,9,5,8,5,8,6,8,6,5,4,7,2,8,4,8
+F,3,8,3,5,1,0,13,4,4,13,11,7,0,8,1,6
+A,3,8,5,6,2,8,5,3,1,7,0,8,2,7,2,8
+E,2,4,2,2,2,7,7,5,8,6,5,8,2,8,6,9
+Y,3,8,5,6,1,4,10,3,2,9,13,8,2,11,0,8
+S,4,3,5,5,2,8,10,6,10,5,5,5,0,7,8,9
+J,5,9,6,7,3,9,7,2,6,14,3,7,0,7,0,8
+X,4,10,7,7,4,9,7,0,8,9,4,7,3,8,3,8
+C,1,0,2,1,0,6,7,6,8,7,6,14,0,8,4,10
+L,5,5,5,8,1,0,0,6,6,0,1,4,0,8,0,8
+T,3,4,4,2,1,5,11,2,7,11,9,4,1,10,2,5
+R,5,10,6,8,6,5,8,6,6,6,4,10,4,6,6,10
+L,2,2,2,4,1,0,1,5,6,0,0,6,0,8,0,8
+Y,7,9,7,7,3,3,10,4,7,12,12,6,2,11,2,6
+E,3,7,4,5,2,3,7,6,11,7,6,15,0,8,7,7
+J,4,5,6,5,5,8,9,4,5,7,6,8,3,7,8,8
+E,5,9,7,7,7,7,7,3,7,7,7,11,5,10,8,9
+P,5,10,7,8,7,6,9,6,5,9,7,4,2,10,4,7
+T,2,3,3,1,1,5,12,3,5,11,9,5,1,10,1,5
+S,4,9,5,6,3,6,9,5,8,11,8,7,2,9,5,5
+V,5,5,6,4,2,5,12,2,3,8,11,7,3,10,1,7
+J,4,11,4,8,3,14,3,5,5,13,1,9,0,7,0,8
+H,8,13,8,7,4,11,7,4,5,9,4,5,6,9,4,8
+C,2,1,3,2,1,6,8,7,8,8,7,13,1,9,4,10
+U,6,8,6,6,4,4,8,5,7,10,8,9,3,9,2,5
+F,3,4,5,3,2,6,10,2,6,13,6,4,1,10,3,7
+F,4,3,4,4,3,5,11,3,6,11,9,5,1,10,3,6
+R,4,7,6,5,4,10,7,4,6,10,3,6,3,7,4,10
+X,7,15,7,8,4,10,7,2,8,9,4,7,4,10,4,10
+E,4,7,6,5,3,4,9,3,9,11,9,10,2,8,4,5
+K,4,9,4,7,2,3,7,7,3,7,7,12,3,8,3,10
+O,5,12,4,6,3,6,6,6,3,10,6,9,5,9,5,7
+L,3,5,4,4,3,6,8,4,5,6,6,9,2,8,7,9
+K,4,4,6,3,3,5,8,2,7,10,8,9,3,8,2,7
+Y,6,7,6,5,3,5,9,1,9,10,10,5,1,10,4,3
+L,3,6,3,4,1,1,0,6,6,0,1,5,0,8,0,8
+K,3,8,5,6,4,5,6,4,7,7,7,11,3,8,5,9
+T,2,3,3,2,1,5,12,3,6,11,9,5,1,11,2,5
+J,3,6,5,4,2,9,7,1,6,14,4,6,0,8,0,8
+I,7,14,6,8,4,10,6,4,6,14,3,6,2,8,6,10
+A,5,11,7,8,3,9,3,3,3,7,2,9,3,7,3,9
+F,3,5,6,4,2,6,12,3,5,13,7,3,1,10,2,6
+U,7,10,8,8,5,5,7,6,8,9,7,9,5,11,5,3
+P,4,4,5,6,5,9,10,2,3,7,9,5,4,10,5,5
+J,2,4,4,3,1,9,6,3,6,14,5,10,0,7,0,8
+A,1,1,2,1,0,7,4,3,0,7,1,8,2,7,1,8
+R,2,3,4,1,2,9,7,4,5,9,4,7,2,6,4,10
+G,4,11,5,8,4,7,7,7,6,6,5,9,2,7,5,11
+K,5,10,7,8,7,7,7,3,7,6,6,7,7,8,6,10
+T,5,7,6,5,5,6,7,7,7,7,8,8,3,10,5,9
+O,1,0,2,1,0,7,7,6,5,7,6,8,2,8,3,8
+P,3,4,5,2,2,8,10,4,3,11,4,3,1,10,2,8
+G,3,4,4,3,2,6,7,5,5,9,7,10,2,9,4,9
+R,4,10,4,7,3,5,11,9,4,7,3,9,3,7,6,11
+L,3,8,4,6,2,2,4,3,9,2,0,8,0,7,1,6
+U,5,10,6,8,2,7,4,15,6,7,14,8,3,9,0,8
+M,6,9,9,6,7,9,6,2,5,9,5,7,8,6,2,8
+N,4,5,5,5,5,7,8,4,3,6,4,8,6,8,4,7
+R,3,6,4,4,4,8,6,6,3,7,5,7,4,6,6,7
+D,3,1,4,2,2,7,7,6,7,7,6,5,2,8,3,7
+E,5,7,6,5,5,8,9,6,3,6,6,10,4,8,7,9
+J,1,3,3,2,1,7,7,3,5,14,6,9,1,7,1,7
+Z,3,5,4,7,2,7,7,4,14,10,6,8,0,8,8,8
+D,1,3,3,2,1,9,6,4,6,10,4,6,2,8,2,8
+N,6,10,8,8,5,7,8,6,6,7,7,6,6,9,2,6
+S,5,10,7,7,8,9,5,5,4,8,6,9,5,7,12,8
+B,2,1,3,3,2,7,7,5,5,6,6,6,2,8,5,9
+H,5,8,8,6,5,10,7,4,6,10,3,6,3,8,3,8
+I,1,5,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+A,3,2,5,3,2,8,2,2,2,7,1,8,2,6,2,7
+U,4,5,5,3,2,6,8,6,7,7,10,9,3,9,0,8
+P,7,11,9,8,8,6,8,7,4,8,7,9,3,9,7,9
+I,3,9,4,6,3,7,7,0,7,13,6,8,0,8,1,8
+G,1,3,2,2,1,7,6,5,4,7,6,10,2,9,3,9
+O,3,2,5,4,3,8,7,8,5,7,6,8,2,8,3,8
+W,6,8,6,6,6,4,9,2,3,9,8,8,7,11,2,6
+B,4,8,4,6,5,6,7,8,6,6,6,7,2,8,7,9
+A,2,8,4,6,3,13,3,4,2,11,1,8,2,6,3,9
+W,6,5,9,8,4,8,7,5,2,7,8,8,9,9,0,8
+U,6,10,6,8,5,8,5,12,4,7,13,8,3,8,0,7
+Q,4,6,5,7,5,10,10,6,3,4,8,11,3,10,6,9
+I,2,10,3,8,2,9,6,0,7,13,5,8,0,8,1,8
+F,6,9,8,6,5,9,8,2,7,13,4,5,4,9,4,9
+P,2,1,3,2,1,6,10,5,4,10,7,3,1,9,4,6
+E,6,11,8,9,7,9,6,1,8,11,4,9,4,7,6,10
+M,4,4,6,3,4,8,6,2,4,9,6,8,7,5,2,8
+C,6,10,8,7,5,7,7,8,7,7,6,11,4,8,4,9
+V,2,1,4,2,1,7,12,2,2,6,11,9,4,11,2,7
+D,4,8,6,6,8,9,8,4,5,7,6,6,4,6,7,5
+J,2,8,2,6,1,15,3,5,5,13,0,8,0,7,0,8
+L,2,1,2,2,1,4,4,4,8,3,2,6,0,7,1,6
+J,1,1,2,3,1,10,6,3,5,11,4,9,1,7,1,7
+F,4,10,4,7,2,1,13,5,3,12,9,6,0,8,3,6
+Q,3,6,4,8,4,8,6,7,5,9,6,7,3,8,5,7
+G,3,6,4,4,2,6,7,6,5,10,8,11,2,9,4,10
+S,7,10,8,8,4,8,7,4,8,11,6,7,2,9,5,8
+Z,4,10,5,8,3,7,7,4,15,9,6,8,0,8,8,8
+O,3,1,4,3,2,7,7,7,4,7,6,7,2,8,3,7
+I,4,8,6,9,6,9,8,6,7,7,4,7,3,10,9,9
+O,3,5,4,3,3,7,7,7,4,9,5,8,2,8,3,7
+Q,2,3,3,4,2,8,8,4,2,7,8,10,2,9,4,8
+U,5,11,8,8,6,7,8,4,7,4,7,9,6,9,1,8
+M,7,9,11,6,8,4,7,3,5,11,10,11,10,9,5,7
+M,5,8,8,6,7,9,7,2,4,9,5,7,7,7,2,8
+X,4,8,5,6,1,7,7,5,4,7,6,8,3,8,4,8
+V,9,11,7,6,3,7,11,6,5,8,10,4,5,12,3,9
+V,3,7,4,5,2,5,11,3,4,9,12,8,2,10,1,8
+D,4,7,5,5,5,7,7,5,7,7,6,6,6,8,3,7
+F,7,10,6,6,4,9,7,3,5,11,5,6,4,9,6,9
+X,1,0,2,0,0,7,7,4,4,7,6,8,2,8,4,8
+L,4,8,6,6,6,7,7,3,5,7,7,9,6,10,6,6
+K,4,8,4,5,2,3,8,8,2,7,5,11,4,8,3,10
+J,2,1,3,2,1,10,6,2,7,11,4,8,1,7,1,7
+H,8,11,12,8,7,9,7,3,6,10,4,7,3,8,3,8
+D,2,3,3,2,2,9,6,4,6,10,4,6,2,8,2,9
+C,3,6,4,4,2,5,9,6,7,12,9,11,2,10,3,7
+C,5,9,6,7,4,4,7,5,7,10,8,14,3,8,4,7
+P,3,6,3,4,2,4,12,7,1,10,6,4,1,10,3,8
+P,5,5,6,7,7,8,7,4,3,7,7,7,6,10,5,6
+L,2,0,2,1,0,2,0,6,4,0,3,4,0,8,0,8
+B,1,1,2,1,2,7,7,4,5,7,6,6,1,8,4,9
+L,4,8,6,6,3,5,4,3,10,5,1,7,1,6,3,5
+S,3,10,4,7,2,7,7,6,9,4,6,8,0,8,9,7
+O,3,5,4,4,3,8,7,7,4,9,6,8,3,8,3,8
+D,2,4,4,3,2,10,6,3,7,10,3,6,2,8,3,9
+L,3,7,4,5,2,3,4,3,9,2,1,7,0,7,1,5
+I,4,11,5,8,2,9,5,0,8,14,5,10,0,8,1,9
+H,7,9,6,4,3,11,7,4,5,8,3,5,5,9,4,8
+Y,3,9,5,6,1,7,10,2,3,7,13,8,1,11,0,8
+J,1,1,2,2,1,10,6,2,5,11,4,8,1,7,1,7
+U,2,4,3,3,1,7,8,7,7,8,10,7,3,9,1,8
+D,2,1,2,2,1,6,7,8,7,6,6,6,2,8,3,8
+H,3,7,4,5,5,7,8,6,6,7,5,8,3,8,3,7
+K,6,11,6,8,5,3,6,7,4,7,8,12,3,8,3,11
+J,2,7,4,5,1,7,6,4,6,15,7,12,1,6,0,7
+R,2,1,3,2,1,6,10,8,2,7,5,8,2,7,5,10
+N,4,7,6,5,4,6,7,6,7,7,5,9,6,7,3,7
+A,4,11,7,8,3,7,4,3,2,7,1,8,3,6,3,8
+K,8,13,7,7,4,10,7,3,7,9,3,6,6,8,4,8
+A,3,9,5,7,4,12,3,2,2,10,2,9,2,6,3,7
+N,2,3,4,2,1,9,7,3,4,10,3,6,5,9,0,7
+U,5,11,6,8,5,7,5,13,5,7,12,8,3,9,0,8
+B,4,6,4,4,3,7,6,9,7,7,7,7,2,8,8,9
+R,2,1,2,2,2,7,7,5,5,6,5,7,2,7,4,8
+G,1,3,2,2,1,7,7,4,4,9,7,10,2,8,3,10
+N,5,10,6,8,6,7,7,13,1,6,6,8,5,8,0,8
+W,8,9,8,7,7,5,11,3,3,9,8,7,7,12,3,6
+L,3,7,5,5,4,7,6,7,5,6,6,8,3,8,4,10
+L,4,7,4,5,2,1,1,5,5,1,1,6,0,8,0,8
+U,3,2,4,4,1,7,5,12,5,7,14,7,3,9,0,8
+I,3,8,4,6,2,7,7,0,8,14,6,8,0,8,1,8
+Y,7,10,8,8,4,3,11,2,8,11,11,5,1,11,3,4
+P,4,3,4,4,2,4,14,7,1,11,6,3,1,10,4,8
+I,4,11,7,9,8,10,8,2,6,9,4,5,4,7,8,4
+U,8,11,8,8,6,3,8,5,8,10,8,10,5,10,4,4
+U,4,4,5,3,2,4,8,5,8,10,9,9,3,9,2,6
+G,6,11,8,8,9,8,4,5,4,7,5,11,7,9,6,13
+L,4,9,6,7,4,4,4,3,8,2,1,8,0,6,1,6
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+W,8,9,12,8,13,7,7,5,5,6,5,8,10,9,9,8
+K,5,8,8,7,7,10,7,4,4,10,2,8,5,5,4,10
+N,4,7,4,5,2,7,7,14,2,4,6,8,6,8,0,8
+L,3,8,4,6,2,7,3,1,8,9,2,11,0,7,2,9
+W,8,9,8,6,6,5,11,3,3,9,8,7,8,11,3,6
+E,6,10,8,8,5,5,8,4,9,12,9,9,3,8,5,6
+D,1,3,3,2,1,8,7,5,6,9,5,5,2,8,3,8
+J,6,13,5,10,4,7,10,2,3,13,5,5,2,8,7,8
+Y,1,3,2,1,1,7,10,1,5,7,11,8,1,11,1,8
+B,5,11,6,8,8,8,7,5,6,7,6,5,3,8,6,9
+B,2,3,4,2,2,8,7,3,5,10,5,6,2,8,4,9
+B,6,9,5,5,5,8,8,3,5,9,5,7,6,5,7,7
+D,1,0,1,1,0,6,7,8,5,7,6,6,2,8,2,8
+S,6,9,7,6,4,9,6,3,8,10,6,8,2,10,5,8
+T,5,10,7,8,6,8,11,2,7,6,11,8,1,12,1,8
+H,5,10,5,7,3,7,7,15,1,7,6,8,3,8,0,8
+A,3,8,5,6,5,8,7,7,4,7,6,9,5,7,7,4
+V,4,9,6,7,3,6,11,2,4,7,12,9,3,10,1,8
+A,4,8,6,7,6,9,8,3,4,6,7,7,5,8,5,5
+Z,3,6,5,9,4,11,3,2,6,8,2,6,1,8,6,9
+A,4,10,5,7,4,7,5,3,0,7,1,8,2,7,3,8
+R,4,10,5,7,3,5,12,9,4,7,2,9,3,7,6,11
+W,8,9,8,7,6,2,12,2,3,10,10,8,7,11,2,7
+T,3,4,4,3,2,6,10,2,7,11,9,5,2,10,3,4
+L,3,10,3,8,1,0,1,5,6,0,0,7,0,8,0,8
+C,2,5,3,3,2,6,8,7,7,8,7,13,1,9,4,10
+U,5,7,5,5,3,4,8,5,7,10,9,9,3,9,2,6
+Y,2,7,4,4,1,8,11,1,3,6,12,8,1,10,0,8
+E,1,0,1,0,1,5,8,5,7,7,6,12,0,8,6,9
+R,2,6,4,4,3,8,7,3,5,9,4,7,3,7,4,10
+C,5,9,5,7,3,4,8,6,8,12,10,12,1,9,3,7
+L,3,8,5,6,3,6,4,1,8,8,2,10,0,7,2,8
+K,4,10,6,8,7,6,6,5,3,7,6,9,4,5,10,8
+M,4,5,5,3,4,8,6,6,4,7,7,8,8,5,2,7
+N,2,5,3,4,2,7,8,5,4,7,6,7,4,8,1,7
+J,6,8,8,9,7,9,8,5,6,7,5,8,4,8,9,7
+P,1,3,3,2,1,6,10,6,2,10,5,4,1,9,3,7
+J,1,8,2,6,2,9,6,3,5,11,4,9,1,6,1,6
+G,5,9,4,4,3,8,6,4,2,9,6,8,3,9,8,8
+H,5,8,7,6,7,7,7,6,6,7,6,8,3,8,3,7
+B,2,1,3,1,2,7,7,5,5,7,6,6,1,8,5,9
+I,3,7,4,5,2,8,6,0,7,13,6,9,0,7,2,8
+D,1,0,1,1,1,6,7,8,6,7,6,6,2,8,3,8
+O,4,4,5,6,2,8,8,9,8,5,8,10,3,8,4,8
+B,4,5,4,7,4,6,7,10,7,7,6,7,2,8,8,9
+M,6,8,9,6,5,10,6,3,5,9,4,6,8,6,2,8
+T,2,1,3,2,1,7,12,2,6,7,11,8,1,11,1,8
+V,3,7,4,5,2,7,12,3,4,7,11,8,2,10,1,8
+Z,7,14,7,8,4,10,4,3,8,12,4,10,3,9,4,11
+S,4,9,3,4,2,7,3,1,5,6,2,7,2,8,5,9
+Q,6,8,6,10,8,8,5,7,3,9,6,9,3,8,5,8
+Y,4,10,7,7,1,7,10,3,2,7,13,8,2,11,0,8
+E,6,10,8,8,6,4,10,4,8,11,10,8,3,8,4,4
+G,3,3,4,5,2,7,7,8,7,6,5,11,2,8,5,10
+Q,5,8,5,10,6,8,7,6,3,8,9,11,3,8,6,8
+F,3,7,3,4,1,1,11,5,6,11,10,9,0,8,2,6
+H,4,5,4,7,3,7,8,15,1,7,5,8,3,8,0,8
+V,2,4,4,3,1,7,12,2,3,6,11,9,2,10,1,8
+M,14,15,14,8,7,6,10,5,5,4,4,11,11,13,2,8
+L,5,9,6,7,5,6,6,8,5,6,5,9,3,7,5,11
+U,3,5,4,3,2,6,8,6,7,6,9,9,3,9,1,7
+S,2,8,3,6,3,7,7,7,5,7,6,8,2,9,8,8
+Z,4,10,5,8,2,7,7,4,15,9,6,8,0,8,8,8
+U,5,7,5,5,3,4,8,6,7,9,9,9,3,9,2,5
+W,5,10,7,8,4,5,8,5,2,7,8,8,8,9,0,8
+H,1,0,1,0,0,7,7,10,1,7,6,8,2,8,0,8
+T,4,10,5,8,3,7,13,0,6,7,10,8,0,8,0,8
+N,5,10,6,8,6,7,7,6,6,7,6,8,6,7,3,8
+G,6,8,8,7,8,7,10,6,2,7,7,8,6,11,7,8
+T,3,4,4,3,2,7,12,4,6,7,11,8,2,11,1,7
+D,5,6,6,6,5,5,7,6,7,6,5,6,4,7,5,6
+D,3,2,4,3,2,7,7,6,7,7,6,5,2,8,3,7
+R,4,10,5,7,6,6,7,5,6,6,4,8,3,6,5,9
+E,3,7,4,5,4,8,8,4,7,7,5,8,3,8,5,10
+J,5,9,6,7,3,8,4,5,6,15,7,14,1,6,1,7
+Q,3,5,4,6,4,8,8,5,2,7,7,12,2,9,5,9
+K,4,5,5,4,4,5,7,4,7,6,6,10,3,8,5,8
+N,6,11,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+X,8,12,8,6,4,10,6,3,9,9,2,5,4,6,4,10
+H,3,3,5,1,2,9,6,3,5,10,4,8,3,8,2,9
+A,5,9,7,7,4,8,5,3,0,6,1,8,2,7,1,8
+L,4,9,5,6,4,5,5,1,8,7,2,10,1,7,3,7
+I,2,7,2,5,1,7,7,0,7,13,6,8,0,8,1,8
+H,6,8,8,6,7,6,8,7,6,8,5,7,6,7,5,10
+G,5,8,5,6,4,7,6,6,7,10,7,11,2,10,4,9
+R,5,5,6,7,3,6,11,9,3,7,3,8,3,7,6,11
+X,4,10,6,8,6,6,7,2,6,7,7,9,3,7,6,8
+D,4,8,4,6,4,5,7,9,7,7,7,6,2,8,3,8
+R,3,10,4,7,3,6,9,11,5,7,5,8,3,8,5,10
+F,5,8,8,6,4,6,10,3,6,13,7,4,2,10,2,7
+C,3,6,5,5,4,6,6,4,5,7,6,11,4,10,7,10
+O,2,4,3,3,2,7,7,7,4,7,5,8,2,8,3,8
+V,2,6,4,4,2,9,11,3,4,4,11,8,2,10,1,8
+M,7,10,9,8,9,8,7,6,5,6,7,8,8,6,2,7
+R,4,7,5,5,3,11,7,3,6,11,2,6,3,7,3,10
+O,4,8,6,6,5,7,7,8,4,7,7,9,3,8,3,7
+H,1,0,2,1,0,7,7,11,1,7,6,8,3,8,0,8
+W,6,6,6,4,4,2,11,2,2,10,10,8,5,11,1,7
+Q,3,4,4,5,3,8,8,5,1,8,8,10,2,9,4,8
+Y,3,5,4,7,7,8,5,4,2,7,7,9,5,10,4,7
+Q,1,3,2,4,2,7,7,5,2,8,8,10,2,9,4,9
+H,5,10,8,8,7,8,6,7,7,7,7,5,3,8,4,6
+A,3,9,5,6,3,10,3,2,2,8,2,10,3,5,3,7
+S,4,8,5,6,4,8,8,7,5,7,6,8,2,8,8,8
+P,6,11,5,6,3,5,11,5,4,13,6,4,3,9,4,8
+K,8,12,7,6,4,9,8,3,7,9,4,6,6,9,4,8
+Y,2,2,4,4,2,6,10,1,7,8,11,8,1,11,2,7
+B,8,10,7,6,6,7,9,4,5,9,6,7,6,6,7,6
+W,4,9,6,7,3,5,8,5,1,7,8,8,8,9,0,8
+O,4,9,5,7,2,7,6,9,7,6,5,7,3,8,4,8
+G,5,11,7,8,4,6,6,8,8,8,5,13,3,11,5,8
+I,1,10,2,8,2,7,7,0,8,7,6,8,0,8,3,8
+P,8,11,6,6,3,7,10,5,3,12,4,4,5,10,4,8
+Q,2,5,3,6,3,8,6,7,3,5,6,9,2,9,5,10
+A,4,9,3,4,2,13,3,4,1,10,3,10,3,5,3,10
+O,4,7,5,5,4,7,7,8,6,7,6,6,3,8,4,8
+Q,10,15,9,9,5,7,5,4,9,10,4,10,4,6,9,9
+I,1,3,2,1,0,7,7,1,7,13,6,8,0,8,1,8
+L,1,0,1,1,0,2,1,5,5,0,2,5,0,8,0,8
+W,6,5,8,5,8,9,8,5,5,7,5,8,9,9,8,6
+V,5,9,7,7,4,7,12,2,3,5,10,9,4,12,2,7
+N,3,3,4,2,2,7,8,6,4,7,7,6,5,9,2,6
+G,5,11,7,8,8,7,7,6,2,7,6,11,7,9,10,6
+N,6,9,8,7,9,8,7,4,4,7,6,6,7,10,7,5
+I,3,7,5,5,2,8,6,2,7,7,6,7,0,9,4,7
+F,5,11,7,8,5,5,11,2,8,10,9,5,4,10,4,6
+R,8,11,7,6,5,10,6,3,5,9,4,8,6,8,6,9
+V,2,1,3,1,0,7,9,4,2,7,13,8,2,10,0,8
+R,5,11,7,8,5,8,9,4,6,8,4,9,4,6,6,11
+H,4,9,4,7,4,7,7,13,1,7,6,8,3,8,0,8
+Q,6,10,8,8,7,8,3,8,5,6,5,9,4,9,4,7
+R,3,6,3,4,3,6,9,8,4,7,5,8,2,7,4,11
+P,3,7,4,5,3,6,10,6,5,10,8,4,1,10,4,7
+Y,4,6,6,8,7,9,9,6,3,7,7,8,6,11,7,4
+F,5,7,7,5,4,6,11,5,6,12,8,5,2,9,2,6
+Z,5,9,5,4,3,8,6,2,8,11,6,9,3,7,6,7
+O,7,13,5,7,3,9,7,7,5,9,4,8,5,9,5,9
+W,5,8,8,6,5,7,8,4,1,7,9,8,7,11,0,8
+C,4,9,5,7,4,4,8,6,7,9,9,15,1,9,4,10
+R,2,4,4,3,3,8,8,3,5,10,4,7,3,6,3,9
+Y,4,6,4,4,1,3,11,3,7,11,11,5,1,11,2,4
+I,1,4,1,3,1,7,7,1,8,7,6,9,0,8,3,8
+V,7,10,7,8,3,3,11,4,4,10,12,8,2,10,1,8
+Q,4,6,5,8,4,8,7,6,3,8,7,10,3,8,6,8
+G,4,6,4,4,3,7,6,6,5,9,6,13,2,8,4,10
+W,4,10,6,8,4,10,8,5,2,7,8,8,8,9,0,8
+Q,2,1,3,2,1,8,6,7,5,6,6,8,3,8,4,8
+G,9,14,8,8,5,7,4,6,3,8,5,4,4,8,6,6
+S,4,8,6,6,7,6,9,3,3,8,7,6,3,8,11,1
+S,3,4,3,2,2,8,8,6,5,7,6,7,2,8,9,8
+D,5,6,6,6,5,6,6,5,7,7,6,8,4,6,6,5
+W,8,12,8,6,4,1,9,3,2,11,12,9,7,10,0,6
+A,3,1,5,3,2,8,2,2,2,7,1,8,2,7,2,7
+C,4,6,5,4,3,6,7,5,6,11,8,13,2,10,3,9
+Q,1,2,2,3,1,8,8,5,1,5,7,9,2,9,4,9
+R,5,10,7,7,6,7,8,5,7,7,5,6,6,6,5,9
+L,3,2,4,4,2,4,4,4,7,2,1,6,0,7,1,6
+D,5,10,6,7,5,7,7,8,8,6,5,5,3,9,4,8
+P,8,12,7,6,4,8,9,3,4,12,5,4,3,10,6,6
+U,4,7,5,5,5,8,7,8,5,6,7,9,3,8,4,6
+Z,2,4,4,3,2,7,7,2,9,12,6,8,1,8,5,7
+S,4,9,4,7,2,8,7,6,9,4,6,8,0,8,9,7
+D,4,7,5,5,2,5,8,9,9,7,6,6,3,8,4,8
+S,4,9,6,7,7,5,9,3,3,8,7,5,4,8,12,0
+C,9,13,7,7,5,7,9,4,4,9,8,9,3,9,8,11
+R,3,4,4,3,2,7,7,5,5,6,5,6,2,7,4,8
+A,1,0,2,0,0,7,3,2,0,7,2,8,2,6,1,8
+U,5,6,5,4,2,4,9,6,7,10,10,9,3,9,2,5
+H,3,6,4,4,3,7,8,7,5,8,5,7,3,7,5,11
+J,2,6,3,4,2,10,5,3,5,12,3,8,0,7,2,7
+Y,3,8,5,6,1,9,12,2,3,4,12,9,0,10,0,8
+E,4,5,6,4,3,7,7,2,8,11,7,9,2,8,4,8
+J,3,9,5,7,3,9,5,3,6,15,4,10,0,7,1,7
+M,5,6,5,8,4,7,7,12,2,7,9,8,8,6,0,8
+S,6,12,6,6,3,8,7,4,3,13,8,8,3,10,3,8
+U,4,6,4,4,1,7,5,13,5,7,15,8,3,9,0,8
+L,2,7,3,5,2,4,4,4,7,2,1,6,1,6,1,6
+R,6,11,9,8,7,7,8,5,7,7,5,6,3,6,6,9
+D,4,7,6,6,6,7,8,5,6,6,4,7,4,7,7,5
+X,5,9,8,7,4,8,7,1,8,10,4,7,3,8,4,8
+V,2,3,4,4,1,5,8,4,2,8,13,8,3,10,0,8
+H,2,2,3,3,2,8,7,6,6,7,6,8,6,8,3,7
+R,3,5,6,4,5,8,7,3,4,8,5,7,6,9,5,5
+M,3,6,3,4,2,8,6,11,1,6,9,8,7,6,0,8
+L,3,7,4,5,2,6,3,1,8,8,2,11,0,7,2,8
+H,2,4,4,3,3,7,7,3,5,10,6,8,3,8,2,7
+Z,6,9,8,7,8,9,8,4,4,6,4,6,4,8,10,4
+F,2,4,2,2,1,5,10,4,4,10,9,5,1,10,3,7
+G,2,1,3,2,1,8,6,6,6,6,5,9,1,7,5,10
+M,4,5,5,3,4,8,6,6,4,6,7,7,8,6,3,6
+Y,7,6,6,9,4,7,10,2,3,7,10,4,4,10,6,7
+O,4,8,5,6,2,7,7,8,8,7,6,7,3,8,4,8
+E,6,11,4,6,3,6,9,4,5,10,6,8,3,8,7,8
+D,3,5,4,3,3,7,7,7,7,6,6,5,2,8,3,7
+O,3,5,4,4,3,7,7,8,5,7,6,8,2,8,3,8
+C,6,11,6,8,3,5,8,7,8,13,10,11,2,10,3,7
+X,4,8,6,6,3,6,8,1,8,10,8,9,3,8,3,7
+L,7,13,6,8,3,10,2,4,4,13,4,13,2,8,6,9
+T,3,1,4,3,2,7,12,4,6,7,11,8,2,11,1,8
+B,6,9,8,7,6,10,6,3,7,10,3,7,6,8,7,11
+M,1,0,2,0,0,7,6,9,0,7,8,8,5,6,0,8
+U,4,6,5,4,4,7,8,8,6,5,7,11,3,8,4,7
+S,6,8,8,7,9,8,7,4,5,7,7,8,5,10,9,11
+J,3,5,5,4,2,9,5,3,6,14,5,10,0,7,0,7
+Q,5,9,6,8,3,7,5,9,8,5,4,7,3,8,4,8
+T,3,7,5,5,3,6,12,3,7,8,11,8,1,11,1,7
+Y,6,8,6,6,3,5,9,0,8,10,9,6,0,10,3,4
+M,4,6,7,4,8,6,5,4,2,6,4,8,12,6,3,7
+Q,6,10,8,8,7,8,4,8,4,6,6,8,4,7,6,9
+S,3,9,4,7,4,8,6,8,5,7,7,9,2,9,8,7
+J,2,8,3,6,1,11,3,10,3,12,8,13,1,6,0,8
+A,2,3,4,2,2,9,1,2,1,8,2,10,2,6,2,7
+H,6,11,8,8,8,7,8,7,6,8,6,7,7,8,5,9
+M,5,10,5,7,4,7,7,12,2,7,9,8,8,6,0,8
+Y,5,11,6,8,7,9,5,6,5,7,8,7,3,9,8,3
+C,4,7,5,5,2,5,8,7,8,7,8,14,1,8,4,9
+J,2,6,3,4,1,15,3,3,5,12,1,8,0,8,0,8
+K,5,8,8,7,7,6,8,3,4,6,3,9,8,3,10,9
+Y,5,9,5,6,2,3,11,3,6,12,11,5,1,11,2,5
+M,5,10,6,8,4,7,7,12,2,7,9,8,8,6,0,8
+X,3,8,5,6,3,8,7,4,9,6,6,6,3,8,7,7
+J,6,9,4,12,4,11,6,2,4,10,4,6,3,9,6,10
+H,4,4,5,5,2,7,10,15,2,7,2,8,3,8,0,8
+H,3,4,5,3,3,5,9,3,5,10,8,8,3,9,3,7
+G,4,6,5,4,2,7,6,6,7,11,6,12,2,9,4,9
+R,5,6,7,6,7,5,7,4,4,6,5,9,7,9,6,9
+J,1,4,2,2,1,8,6,3,6,14,6,10,1,7,1,7
+V,3,5,4,4,1,4,12,3,3,10,11,7,2,10,1,8
+X,7,9,8,5,4,8,7,3,8,12,4,7,4,9,4,8
+F,2,7,3,4,1,1,11,4,6,11,11,10,0,8,2,6
+S,2,3,3,2,2,8,7,6,4,7,7,8,2,9,9,8
+R,4,9,4,6,3,5,11,8,4,7,4,9,3,7,6,11
+Y,3,7,5,5,2,7,10,2,2,7,12,8,1,11,0,8
+Y,4,5,5,3,2,4,10,2,8,10,10,5,3,11,4,3
+N,9,14,8,8,4,10,11,6,6,3,6,9,5,10,3,6
+Z,4,9,6,7,4,9,5,2,9,11,4,10,1,8,6,10
+L,4,9,6,8,5,8,7,4,5,7,6,8,3,8,8,11
+W,4,8,6,6,4,7,10,2,3,7,9,8,8,11,1,8
+N,2,1,2,1,1,7,7,11,1,5,6,8,4,8,0,8
+H,7,9,10,7,7,9,7,3,7,10,4,7,5,8,5,9
+J,0,0,1,0,0,12,4,6,3,12,4,11,0,7,0,8
+N,6,8,8,7,9,8,6,5,5,7,6,7,8,11,7,3
+I,7,13,5,8,3,10,4,5,4,13,3,9,3,8,4,9
+C,1,0,2,0,0,7,7,6,8,7,6,13,0,8,4,10
+O,3,7,4,5,3,7,7,8,5,7,6,8,3,8,3,8
+U,5,10,6,7,2,7,4,14,5,7,14,8,3,9,0,8
+R,8,14,6,8,5,8,7,5,5,9,4,9,7,5,6,11
+E,2,3,3,5,2,3,7,6,10,7,6,14,0,8,7,8
+B,10,15,10,8,8,9,7,4,5,9,5,7,7,5,9,8
+U,5,7,5,5,3,3,9,5,6,10,10,9,3,9,2,7
+D,1,0,2,1,1,6,7,8,6,7,6,6,2,8,3,8
+R,1,0,2,0,1,6,10,7,2,7,5,8,2,7,4,9
+N,8,10,10,5,3,4,10,5,4,14,11,9,5,9,0,8
+C,2,3,3,2,1,4,8,4,6,10,9,12,1,9,2,8
+E,3,10,4,8,2,2,8,6,11,7,6,15,0,8,7,7
+D,5,10,8,7,7,9,7,3,6,11,5,6,3,8,3,8
+G,5,10,4,5,3,9,5,4,3,9,4,5,4,7,5,8
+K,3,7,4,5,2,3,8,7,2,7,5,11,3,8,3,11
+Y,9,8,7,12,5,8,6,6,6,4,11,7,5,9,3,8
+X,3,8,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+Z,4,8,6,6,6,8,8,3,7,7,7,7,1,9,10,8
+X,4,6,5,4,4,7,6,3,5,6,6,9,2,8,8,8
+F,3,5,3,3,2,5,11,3,6,11,9,5,1,10,3,6
+N,4,11,5,8,5,8,7,13,1,6,6,7,6,8,1,10
+K,3,6,5,4,3,6,7,1,7,10,7,10,3,8,3,8
+R,4,3,5,5,3,5,11,8,3,7,4,8,2,7,6,11
+O,4,8,6,6,4,7,8,8,6,7,7,8,2,8,3,8
+V,5,9,5,6,3,3,10,3,4,10,12,8,3,10,1,7
+J,3,7,5,5,2,8,4,6,4,14,8,14,1,6,1,7
+M,2,1,2,1,1,7,6,10,0,7,8,8,6,6,0,8
+P,7,11,9,8,7,9,7,2,6,11,4,6,4,8,4,9
+Y,7,9,7,7,2,3,12,6,6,14,11,5,2,11,2,6
+D,5,11,7,8,11,8,8,6,4,7,6,6,7,8,9,6
+S,4,9,5,7,4,10,7,4,6,10,3,7,2,8,5,10
+X,4,10,5,7,1,7,7,5,4,7,6,8,3,8,4,8
+S,4,7,5,5,2,6,9,4,7,10,7,7,2,8,5,5
+Y,8,11,8,8,5,3,11,2,6,11,11,6,1,11,2,5
+Q,5,9,6,8,5,8,8,8,5,6,6,10,3,8,4,9
+T,5,6,6,4,3,5,11,3,7,11,9,5,2,11,2,4
+A,3,9,4,7,3,6,4,2,1,6,1,8,2,6,2,7
+R,4,5,4,3,3,7,7,5,6,7,5,6,5,7,4,7
+U,2,6,4,4,2,7,9,6,6,6,10,9,3,9,1,7
+I,4,9,4,5,2,6,11,3,4,13,6,4,1,9,5,8
+D,1,0,1,0,0,5,7,7,5,6,6,6,2,8,2,8
+E,2,3,4,2,2,7,7,2,7,11,7,9,2,8,4,8
+V,6,8,8,6,5,6,12,3,2,8,10,8,6,11,6,8
+D,5,11,5,6,4,8,6,3,5,9,5,7,5,9,5,8
+G,6,6,8,6,7,7,10,5,3,7,7,8,6,11,7,8
+D,9,15,8,8,6,8,6,3,7,10,5,7,6,8,9,6
+K,5,9,5,4,3,10,7,2,5,10,5,7,5,10,3,9
+T,6,11,6,8,4,4,12,3,7,12,10,4,1,11,2,4
+K,4,11,4,8,2,3,7,8,2,7,5,11,3,8,3,10
+Z,3,6,5,4,4,8,8,2,7,7,6,7,0,8,8,9
+N,5,11,6,8,6,8,8,13,1,6,6,8,6,8,1,10
+N,6,8,8,7,8,7,8,4,4,7,5,6,7,8,7,2
+M,2,4,4,3,3,10,6,3,4,9,4,6,6,5,2,8
+O,6,11,6,9,5,8,6,8,5,10,5,9,4,9,5,6
+T,3,6,5,5,5,6,9,3,7,8,7,9,3,8,7,5
+A,3,6,5,8,2,7,6,3,1,7,0,8,3,7,1,8
+R,3,2,4,3,3,7,7,5,5,6,5,6,3,7,4,8
+A,3,8,5,6,3,8,3,2,2,6,1,8,2,6,2,7
+J,3,4,4,6,1,11,2,11,3,12,9,14,1,6,0,8
+D,4,4,5,6,3,5,7,9,9,6,5,5,3,8,4,8
+B,4,10,5,7,7,8,7,6,5,7,6,6,6,8,6,10
+J,4,4,5,5,4,7,9,4,5,7,7,8,3,7,6,6
+V,3,7,5,5,2,9,9,4,1,6,13,8,2,10,0,8
+B,5,8,7,6,7,7,7,5,4,7,5,7,4,9,6,7
+I,1,9,0,6,1,7,7,5,3,7,6,8,0,8,0,8
+U,5,8,6,6,3,5,8,7,9,10,11,9,3,9,1,7
+M,4,8,5,6,5,8,5,11,1,6,9,8,8,5,1,6
+W,6,9,8,7,4,4,8,5,2,7,9,8,9,9,0,8
+C,5,11,6,8,4,3,8,6,6,12,10,13,2,9,3,7
+N,6,10,8,8,4,7,8,2,5,10,7,8,5,8,1,8
+R,5,10,8,9,9,6,9,3,3,7,5,9,8,6,7,9
+D,6,10,8,8,6,9,6,5,8,10,3,6,3,8,4,8
+B,2,1,2,1,1,7,7,7,5,6,6,7,1,8,7,8
+Z,2,1,3,2,1,7,7,5,9,6,6,8,1,8,7,8
+T,7,10,7,8,6,6,11,3,6,11,9,5,2,12,2,4
+T,5,9,7,8,8,7,7,4,8,7,6,9,5,4,11,5
+T,9,12,8,6,3,4,12,3,8,13,8,4,2,8,4,3
+W,7,10,7,7,6,5,10,4,3,9,7,7,9,13,3,4
+U,3,8,5,6,2,6,9,7,7,8,10,9,3,9,1,7
+F,2,2,3,3,2,5,11,3,5,11,9,5,1,10,3,6
+H,2,3,3,2,2,7,7,6,5,7,6,8,3,8,2,7
+U,4,8,4,6,3,7,6,11,4,7,13,8,3,9,0,8
+Z,2,1,3,2,2,7,7,5,9,6,6,8,2,8,7,8
+Z,5,9,6,7,5,7,7,5,10,7,6,8,1,8,7,8
+M,4,6,5,4,3,8,7,12,1,6,9,8,8,6,0,8
+D,6,10,8,7,5,9,7,5,8,10,3,5,3,8,4,8
+C,6,11,8,9,6,7,8,8,6,4,7,12,5,6,4,8
+C,3,5,4,7,2,5,7,7,10,7,5,14,1,8,4,9
+G,6,10,8,8,8,7,10,6,3,5,6,10,4,7,7,7
+B,3,5,3,3,3,7,7,5,5,6,6,6,2,8,6,10
+E,4,7,6,5,4,9,7,2,7,11,5,8,3,9,4,11
+F,4,7,6,5,3,6,10,1,6,13,7,5,1,10,2,8
+G,4,9,6,6,2,7,6,7,9,7,5,11,1,8,5,10
+O,5,10,7,8,5,7,6,9,4,7,5,9,3,9,4,6
+M,5,5,8,3,4,10,6,3,5,9,5,7,10,6,2,8
+R,5,7,7,5,4,9,8,4,7,9,3,7,3,6,4,11
+M,6,10,10,8,13,9,6,3,2,8,4,8,11,7,3,7
+M,4,5,7,3,4,5,7,3,4,10,10,10,9,7,3,8
+V,1,3,3,1,1,7,12,2,2,7,10,8,2,10,1,8
+Y,7,9,8,7,4,3,10,2,7,10,12,7,2,11,2,6
+T,7,12,6,6,4,5,11,2,7,12,7,5,2,9,5,4
+V,2,0,3,1,0,8,9,4,2,6,13,8,2,10,0,8
+W,5,6,5,4,4,4,10,3,2,9,9,7,7,11,2,6
+G,4,9,5,7,6,9,5,5,2,7,6,10,7,8,5,10
+T,4,8,5,6,4,6,7,8,6,6,6,8,4,9,6,10
+C,2,7,3,5,1,5,7,6,8,6,6,12,1,7,4,9
+D,2,3,4,2,2,8,7,5,6,9,5,5,2,8,3,7
+P,4,9,4,4,3,8,9,3,3,11,5,5,4,11,5,7
+V,3,8,5,6,2,6,11,2,4,8,12,8,2,10,1,8
+L,4,8,5,6,3,2,4,2,8,2,0,9,0,7,1,6
+P,5,5,5,7,3,4,13,9,2,10,6,3,1,10,4,8
+S,5,10,7,8,5,7,7,4,7,10,9,9,3,9,5,6
+P,6,12,6,6,4,6,10,3,4,12,6,4,3,11,5,6
+G,4,8,5,6,4,8,7,7,6,6,6,9,2,7,5,11
+G,5,10,6,7,3,8,7,8,8,6,7,9,2,7,5,10
+V,3,7,4,5,2,5,11,3,3,9,11,8,2,11,1,8
+L,3,2,4,4,2,4,4,5,8,2,1,6,0,7,1,6
+Y,7,9,7,7,3,5,9,1,9,9,10,5,1,11,4,3
+L,4,10,6,8,4,7,4,1,7,8,2,10,1,6,3,8
+X,2,3,3,2,2,7,7,3,8,6,6,8,2,8,5,8
+K,6,9,9,7,9,6,8,5,4,7,5,8,4,6,10,9
+A,6,8,8,7,7,8,7,4,6,7,9,6,5,11,4,5
+Q,5,8,5,9,7,8,6,7,4,9,7,8,4,9,5,7
+X,5,10,8,8,5,7,7,4,10,6,6,8,3,8,7,8
+E,2,5,4,3,2,7,7,2,8,11,7,9,2,9,4,8
+G,4,8,6,6,3,8,8,8,8,6,7,8,2,7,6,11
+F,4,8,5,6,5,6,9,5,4,8,6,8,5,10,6,12
+R,2,3,2,2,2,7,7,4,5,6,5,6,2,7,4,8
+S,5,10,6,8,8,8,8,5,3,8,5,7,5,9,12,8
+K,6,11,8,8,5,4,7,2,7,10,9,11,4,7,4,6
+B,6,9,8,6,7,9,7,4,6,9,5,6,3,7,6,10
+R,2,3,3,2,2,9,7,3,4,10,4,7,2,7,3,10
+L,4,10,5,8,4,7,4,2,8,7,2,8,1,6,3,8
+V,6,11,8,9,4,8,9,5,2,6,13,8,3,10,0,8
+R,6,9,9,8,10,9,7,4,4,8,4,7,8,10,7,4
+I,1,1,1,3,1,8,7,1,7,7,6,7,0,8,2,7
+M,3,3,4,2,2,9,6,7,3,6,7,6,6,6,1,5
+P,1,1,2,1,1,5,11,8,2,9,6,4,1,9,3,8
+D,3,7,4,5,4,8,8,6,5,9,6,4,3,8,3,6
+D,5,11,8,8,7,10,6,3,6,11,4,7,4,8,4,9
+O,2,3,3,2,1,8,7,6,4,9,6,8,2,8,2,8
+V,3,11,5,8,2,9,8,4,3,6,14,8,3,10,0,8
+X,2,2,4,4,2,7,7,3,9,6,6,8,2,8,6,7
+T,8,12,7,6,4,5,11,2,7,12,7,5,2,7,4,4
+J,3,10,4,8,4,9,6,2,5,11,4,9,1,6,2,6
+F,2,4,4,3,1,5,12,3,5,13,7,3,1,10,1,6
+I,0,0,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+L,4,11,5,8,3,3,3,5,9,1,0,7,0,7,1,6
+E,2,5,4,3,2,6,8,2,8,11,7,9,2,8,4,8
+R,3,1,3,2,2,7,8,5,5,7,5,7,2,6,4,8
+S,3,6,5,4,5,6,5,3,2,6,5,6,2,8,7,4
+R,3,6,5,4,3,10,7,3,5,11,2,6,3,7,2,10
+V,2,3,3,2,1,5,12,4,3,10,11,7,2,10,0,8
+P,4,8,6,6,5,6,7,5,4,7,6,9,5,8,6,10
+L,2,8,4,6,3,7,4,1,6,8,2,9,1,6,2,8
+F,4,9,5,7,5,6,8,6,4,8,6,8,3,11,8,10
+N,3,7,4,5,3,9,8,6,4,6,5,5,5,9,2,6
+X,3,4,5,3,2,10,7,2,8,10,3,7,2,7,3,9
+Q,3,5,4,6,4,8,7,7,3,5,7,10,3,8,5,10
+A,4,9,6,6,2,7,6,3,1,7,0,8,3,7,2,8
+N,6,10,9,8,9,6,8,3,5,8,7,7,9,8,8,4
+X,7,11,8,6,4,7,8,2,8,11,7,8,5,11,4,7
+R,5,10,7,8,6,7,8,6,5,8,5,9,4,6,6,12
+Y,5,6,4,9,3,9,9,2,3,6,10,5,3,10,5,8
+M,4,6,7,4,5,4,7,3,4,11,10,10,5,7,2,6
+S,3,7,4,5,2,8,7,5,9,5,6,8,0,8,9,7
+J,2,4,4,3,1,8,6,3,6,14,6,10,0,7,0,7
+B,4,8,5,6,6,6,7,8,5,7,6,7,2,8,7,9
+N,7,9,9,7,4,7,8,3,5,10,7,7,6,9,1,7
+Q,7,12,7,6,4,11,3,4,5,12,3,9,3,9,7,12
+Y,2,4,3,3,1,4,10,2,6,10,10,6,1,11,2,5
+Z,3,7,4,5,3,7,7,3,11,9,6,8,0,8,7,8
+C,3,6,4,4,2,6,8,8,8,9,8,13,2,10,4,9
+C,3,2,4,4,2,6,8,7,8,8,8,14,1,9,4,10
+W,2,0,2,0,1,7,8,4,0,7,8,8,6,9,0,8
+R,1,0,2,1,1,6,9,7,3,7,5,7,2,7,4,10
+P,4,6,6,4,4,9,7,2,6,13,5,6,1,10,3,10
+P,5,8,6,6,5,4,11,4,5,11,9,4,0,10,4,7
+D,5,8,6,6,4,8,8,7,7,10,5,4,3,8,4,8
+B,4,8,5,6,5,8,8,4,4,7,5,7,4,8,5,7
+Q,4,6,5,8,5,7,8,5,3,7,9,11,3,8,6,8
+B,4,7,5,5,5,7,7,7,6,7,6,7,2,8,6,10
+S,1,3,3,2,1,8,8,2,6,10,6,8,1,8,5,8
+O,6,12,4,6,3,6,8,5,5,9,5,6,5,9,5,8
+H,5,11,7,8,7,6,6,6,5,6,5,8,6,6,7,10
+I,1,4,2,3,1,7,7,0,7,13,6,8,0,8,1,8
+I,5,8,6,6,3,7,5,2,7,7,7,9,1,10,4,8
+G,2,1,2,2,1,8,6,6,6,6,5,10,1,7,5,10
+W,3,3,5,5,3,7,8,4,1,7,8,8,8,10,0,8
+A,1,1,2,1,0,7,4,2,0,7,2,8,2,7,1,8
+J,2,6,2,4,1,15,4,3,5,12,1,7,0,8,0,8
+Q,5,7,7,10,11,8,6,5,2,6,6,8,11,12,10,15
+L,1,4,2,3,1,7,4,1,7,7,2,10,0,7,2,8
+I,0,6,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+D,7,11,10,8,6,8,7,7,8,9,5,4,4,8,6,11
+N,8,15,10,8,5,12,5,2,5,12,3,7,5,6,0,8
+I,1,3,1,4,1,7,7,0,7,7,6,8,0,8,2,8
+U,3,5,4,3,2,5,8,5,7,10,9,9,3,9,2,6
+I,1,5,2,4,1,7,7,0,7,13,6,8,0,8,1,7
+D,5,9,8,6,6,9,8,4,6,11,5,5,4,7,4,9
+E,3,6,5,4,4,8,7,5,2,7,6,9,4,8,7,10
+G,6,8,8,7,8,7,8,5,3,7,7,9,7,11,7,8
+V,4,7,5,5,2,9,12,2,3,4,11,9,3,12,1,7
+S,3,5,3,4,2,8,7,7,5,7,6,7,2,8,9,8
+R,3,6,5,4,4,8,9,4,5,8,4,8,3,5,4,11
+E,2,3,3,1,1,6,8,2,7,11,7,8,1,8,4,8
+M,5,9,5,6,6,8,5,11,0,6,8,8,8,6,1,6
+Y,6,7,6,5,3,4,9,1,8,10,10,6,1,10,3,4
+I,3,7,4,5,2,7,7,0,8,14,6,8,0,8,1,8
+E,5,10,7,8,5,10,7,2,9,11,3,8,3,8,5,12
+Q,5,7,6,9,6,8,5,8,4,6,5,9,4,8,6,9
+Z,1,3,2,2,1,7,7,5,8,6,6,8,2,8,6,8
+S,2,6,3,4,2,9,9,5,9,5,5,5,0,7,8,8
+W,7,11,7,8,7,2,10,2,3,10,10,8,7,11,1,7
+G,5,11,4,6,3,8,7,5,3,9,6,7,3,9,8,8
+T,5,7,6,5,3,4,13,4,5,12,9,4,2,12,2,5
+Q,5,9,7,11,7,8,7,8,4,5,6,10,3,8,7,10
+X,4,6,5,5,5,6,8,2,4,8,7,9,2,8,7,8
+A,3,7,5,5,3,11,3,2,2,9,1,9,3,5,2,8
+A,2,6,4,4,2,10,3,1,2,8,3,9,2,6,2,8
+W,4,5,6,8,4,4,8,5,2,7,8,8,8,10,0,8
+A,2,5,4,4,2,7,2,2,2,6,2,8,2,7,2,7
+Y,3,8,5,6,2,5,10,1,3,8,11,8,1,11,0,8
+L,4,9,5,6,4,6,4,4,8,3,2,5,4,6,2,5
+Z,6,7,4,11,4,8,5,4,4,11,6,8,3,9,10,8
+B,2,1,3,1,2,7,7,5,5,7,6,6,1,8,5,9
+X,4,5,7,4,3,9,6,1,9,10,4,7,2,8,3,8
+E,3,8,4,6,4,6,7,6,8,7,6,10,3,8,6,8
+J,2,10,3,8,1,12,3,10,3,13,6,13,1,6,0,8
+G,4,8,6,6,6,8,5,4,3,7,5,11,6,8,4,11
+X,5,10,6,8,4,7,7,4,4,7,6,7,3,8,4,8
+G,4,9,5,7,6,7,7,6,2,7,6,11,4,9,8,7
+Q,4,5,5,7,3,9,7,8,6,6,6,10,3,8,5,9
+Q,4,5,5,7,3,9,8,8,6,5,8,10,3,8,5,9
+Y,8,13,6,7,4,9,7,5,6,9,5,4,4,10,6,5
+U,4,9,4,6,2,8,5,14,5,6,14,8,3,9,0,8
+I,6,12,6,7,4,9,8,2,5,11,5,6,3,9,6,11
+A,2,7,4,5,3,11,2,2,2,9,2,9,2,6,2,7
+W,8,8,8,6,5,3,10,3,4,11,10,8,8,10,2,6
+Z,4,4,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+O,5,10,6,7,3,8,8,9,8,7,7,8,3,8,4,8
+X,4,8,6,6,3,9,7,1,8,10,2,7,3,8,4,9
+T,4,10,6,7,2,8,15,1,6,7,11,8,0,8,0,8
+O,8,14,5,8,4,6,6,6,3,9,7,9,5,9,5,8
+H,2,0,2,0,0,7,8,11,1,7,5,8,3,8,0,8
+V,6,11,9,8,5,7,11,3,2,6,11,9,3,10,3,9
+E,2,3,3,5,2,3,7,6,10,7,6,15,0,8,7,8
+K,1,0,1,0,0,4,6,6,2,7,6,11,3,7,2,10
+O,6,10,7,8,3,7,9,9,9,7,8,8,3,8,4,8
+W,4,3,5,5,3,8,8,5,1,7,8,8,8,9,0,8
+D,4,10,6,8,4,9,7,5,7,9,4,4,3,8,4,8
+P,6,10,5,5,3,6,10,6,2,11,5,5,4,10,4,8
+F,4,9,5,6,4,5,10,5,6,11,10,5,2,9,2,5
+M,1,0,2,0,1,7,6,9,0,7,8,8,5,6,0,8
+Y,3,3,4,2,1,4,11,2,7,11,10,5,1,11,2,5
+J,2,9,3,6,2,9,6,2,7,12,4,8,0,6,2,6
+Q,3,6,4,5,2,9,6,9,6,7,5,9,3,8,4,8
+M,8,9,11,7,7,6,7,3,5,9,9,9,8,6,2,8
+K,5,9,6,7,7,7,9,5,4,7,5,7,5,7,8,11
+T,4,9,5,7,3,5,14,1,6,9,10,7,0,8,0,8
+Y,3,6,4,4,1,8,11,2,2,5,12,8,1,11,0,8
+J,3,5,4,6,4,9,9,5,6,7,5,8,3,10,8,9
+J,3,11,4,8,3,9,6,3,7,12,4,9,1,6,2,6
+A,6,12,6,6,5,9,4,5,3,10,5,12,7,3,6,11
+F,9,13,7,7,4,6,11,3,5,13,6,4,2,8,6,6
+W,5,9,7,7,11,10,7,5,2,7,7,8,13,10,3,6
+N,5,10,5,8,6,7,7,13,1,6,6,8,5,9,0,7
+W,7,7,7,5,4,3,11,3,3,10,10,8,7,10,2,6
+G,7,9,7,7,5,6,7,6,6,10,8,11,2,9,4,10
+S,2,7,3,5,3,8,7,7,5,7,6,8,2,8,8,8
+D,3,1,4,3,3,7,7,6,7,7,6,5,2,8,3,7
+G,7,9,6,5,3,10,5,4,5,11,3,7,4,7,5,9
+H,6,7,9,5,6,9,7,3,6,10,4,7,5,7,4,9
+P,4,9,6,7,5,7,10,4,4,12,5,3,1,10,3,8
+M,3,3,5,2,3,7,6,3,4,9,8,9,6,5,2,9
+C,5,11,6,8,5,5,7,6,9,8,5,13,1,9,4,9
+G,6,9,8,7,8,7,10,6,3,5,5,11,5,7,8,7
+R,4,2,5,3,4,6,7,5,6,6,5,7,3,7,4,8
+H,4,5,7,4,4,8,8,3,6,10,6,8,3,8,3,8
+S,3,4,4,3,2,6,8,3,7,11,7,8,1,9,4,5
+W,4,9,6,7,3,8,8,5,2,6,8,8,8,10,0,8
+W,6,9,6,7,5,2,10,2,3,10,11,9,6,10,1,7
+M,3,2,4,3,3,8,6,5,4,7,7,8,7,5,2,7
+A,2,6,3,4,2,12,4,3,2,10,1,9,2,6,1,8
+N,6,11,7,9,3,7,7,15,2,4,6,8,6,8,0,8
+W,6,9,6,7,7,4,9,2,3,9,8,8,7,11,2,6
+Y,6,9,8,7,7,9,8,6,4,5,9,7,3,8,10,5
+H,8,13,8,7,6,9,6,4,5,11,3,7,7,8,5,8
+Z,5,6,4,9,4,9,4,4,3,11,6,9,2,10,8,8
+X,3,5,6,4,3,8,7,1,9,10,4,8,2,8,3,8
+C,4,7,5,5,3,7,9,8,6,5,6,12,4,8,3,8
+A,2,5,4,4,2,5,3,2,2,5,2,8,2,6,2,6
+N,3,7,5,5,5,7,8,3,4,8,7,8,6,9,5,4
+J,1,3,3,2,1,8,6,3,6,14,6,10,0,7,0,8
+D,4,6,5,5,5,7,8,4,7,6,4,8,4,8,5,5
+D,4,8,6,6,5,7,8,6,5,10,6,5,5,9,5,10
+E,4,8,4,6,4,3,6,5,9,7,7,14,0,8,6,9
+B,4,7,6,5,5,8,6,5,6,9,6,7,3,8,7,9
+U,4,8,5,6,3,6,9,5,6,7,9,9,3,9,1,8
+K,7,9,10,7,6,6,8,2,7,10,7,9,3,8,3,7
+P,1,0,2,1,0,5,11,7,1,9,6,4,1,9,3,8
+D,4,10,6,8,7,8,7,5,7,6,5,6,6,8,3,7
+H,2,1,3,2,2,8,8,6,5,7,6,8,3,8,3,8
+C,9,14,6,8,3,5,11,6,9,12,8,7,2,8,6,8
+P,3,6,4,4,3,5,11,7,3,10,7,2,1,10,3,6
+C,4,7,5,5,5,5,7,4,4,7,6,10,6,9,5,9
+U,7,10,7,8,4,4,8,6,8,10,10,9,3,9,2,5
+V,2,3,3,2,1,4,12,3,2,10,11,7,2,11,1,8
+N,6,7,8,6,7,7,8,5,4,7,5,7,7,9,6,3
+D,2,1,2,2,1,6,7,9,6,6,6,6,2,8,3,8
+M,5,11,6,8,4,8,7,12,2,6,9,8,8,6,0,8
+W,4,4,5,2,3,4,11,3,2,9,9,7,6,11,1,6
+H,7,11,9,8,6,7,7,6,7,7,6,6,6,8,4,7
+N,5,11,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+S,4,5,6,3,3,8,7,2,8,10,5,7,1,8,5,8
+I,5,12,4,6,2,12,4,3,5,12,2,7,2,8,2,11
+L,4,11,6,8,3,4,4,3,9,5,1,9,1,6,3,6
+Q,2,3,3,4,3,8,9,6,1,5,8,10,3,9,5,10
+O,3,5,4,3,3,8,7,7,5,7,6,8,2,8,3,8
+F,4,8,4,6,3,1,11,3,4,11,11,8,0,8,2,7
+M,11,15,11,8,6,7,10,4,5,4,5,10,10,11,2,7
+S,3,6,4,4,2,8,7,5,8,5,6,8,0,8,9,8
+M,6,8,8,6,8,8,9,6,4,7,7,8,6,9,6,7
+U,4,6,5,4,3,5,9,5,6,6,9,10,3,9,1,7
+L,5,12,5,6,3,9,3,3,5,11,4,11,2,8,5,9
+M,5,8,7,6,6,9,7,6,5,6,7,4,10,7,4,5
+L,1,0,1,1,0,1,1,5,5,0,1,6,0,8,0,8
+I,1,3,1,2,0,7,7,1,7,7,6,9,0,8,2,8
+U,6,8,7,6,3,3,9,6,8,12,12,9,3,9,1,7
+I,1,2,1,4,1,7,7,1,7,7,6,8,0,8,2,8
+X,5,11,7,8,4,5,8,2,8,10,11,10,3,8,4,5
+A,4,10,6,7,2,5,4,3,2,5,1,7,3,7,3,7
+M,7,7,10,5,7,5,7,3,5,10,10,10,11,8,4,8
+J,3,9,4,7,1,12,2,10,4,13,6,13,1,6,0,8
+M,4,8,5,6,5,7,6,6,5,7,7,10,7,5,2,8
+A,4,7,5,5,5,7,7,7,4,6,6,9,2,8,7,4
+M,4,7,7,5,4,4,6,4,4,11,11,11,6,6,2,7
+I,1,5,2,4,1,7,7,0,7,13,6,8,0,8,1,8
+P,4,9,6,7,4,10,7,3,5,12,4,5,3,8,4,9
+C,3,6,4,4,1,6,7,6,9,6,6,13,1,7,4,8
+Y,3,5,4,4,2,4,10,2,7,11,11,6,1,11,2,5
+Y,6,9,6,4,3,7,6,4,4,9,9,5,3,10,4,4
+O,4,4,6,6,3,6,8,9,8,7,6,6,3,8,4,8
+Z,6,9,6,4,4,9,5,4,8,11,4,9,3,6,6,9
+R,4,5,4,6,3,6,10,10,4,7,4,8,3,7,5,10
+L,2,4,4,3,2,7,3,2,7,8,2,10,0,7,2,8
+N,1,0,2,1,0,7,7,11,0,5,6,8,4,8,0,8
+P,3,7,5,5,3,7,10,3,5,13,5,3,1,10,3,9
+Q,3,6,4,4,3,8,5,7,4,6,6,8,3,8,3,8
+H,5,9,7,6,6,4,9,3,6,10,10,9,4,9,4,5
+J,8,12,6,9,4,10,6,2,5,12,5,7,2,10,6,12
+Z,7,14,7,8,5,6,7,2,9,12,7,8,4,6,7,6
+S,4,6,5,5,5,10,7,5,5,7,6,9,4,8,8,11
+H,8,10,8,5,4,9,8,4,5,8,3,5,6,7,4,8
+Z,3,9,4,6,3,7,7,6,11,6,6,8,1,8,8,8
+W,10,10,10,5,4,2,10,4,2,11,12,8,8,10,0,7
+D,3,8,5,6,4,10,6,3,6,10,3,5,3,8,3,8
+Y,6,8,8,11,12,8,9,4,2,7,8,9,4,11,9,8
+S,3,6,4,4,4,8,10,5,4,8,5,6,3,9,7,7
+F,5,10,8,8,8,10,6,2,5,9,5,6,5,9,4,7
+I,2,2,1,3,1,7,7,1,8,7,6,8,0,8,3,8
+U,6,10,9,8,12,8,8,4,4,6,7,8,10,5,9,8
+C,5,11,4,6,3,5,9,4,4,9,7,9,3,9,8,8
+F,1,1,2,2,1,6,10,4,4,10,8,5,1,9,3,7
+C,3,7,4,5,2,5,8,6,7,11,8,13,1,9,3,8
+I,2,9,2,7,2,7,7,0,9,7,6,8,0,8,3,8
+U,8,9,9,7,5,5,6,6,9,8,6,8,5,9,5,2
+K,5,5,5,8,2,4,6,9,2,7,7,11,4,7,3,11
+X,5,9,6,6,5,7,6,3,5,6,6,9,3,7,10,9
+C,4,7,5,5,2,5,8,7,10,6,7,11,1,7,4,8
+X,3,1,4,2,2,8,7,3,9,6,6,8,3,8,6,8
+F,1,3,3,2,1,8,9,2,5,13,5,5,1,9,2,9
+M,10,13,12,8,6,10,2,2,2,9,3,9,7,2,1,9
+W,2,1,4,3,2,9,10,3,2,6,9,7,5,11,0,8
+I,2,7,3,5,1,8,6,0,7,13,6,9,0,8,1,8
+H,2,1,3,2,2,7,7,6,6,7,6,8,3,8,4,8
+S,4,4,5,6,3,7,5,6,9,6,6,11,0,9,9,8
+F,4,8,6,9,7,7,8,4,4,7,6,7,5,9,10,8
+Q,6,9,6,5,4,12,4,3,5,10,3,8,3,9,6,12
+W,6,11,6,6,4,4,9,1,3,9,9,8,8,12,1,6
+R,4,3,4,4,2,5,11,8,3,7,4,8,2,7,6,11
+I,1,9,0,6,1,7,7,5,3,7,6,8,0,8,0,8
+X,4,9,6,6,5,7,7,3,9,5,6,8,3,8,6,8
+P,4,6,6,4,4,9,7,3,5,11,4,5,2,9,4,9
+D,1,0,1,1,0,5,7,7,5,6,6,6,2,8,2,8
+Z,2,4,4,3,2,7,8,2,9,11,7,7,1,8,6,6
+B,2,3,3,2,2,8,7,2,5,10,5,7,2,8,3,9
+B,2,5,4,3,3,9,7,2,6,10,5,6,2,8,5,9
+Y,4,6,5,8,7,10,9,5,3,6,7,8,6,11,7,5
+A,4,9,6,6,2,8,4,3,2,7,1,8,3,6,3,8
+F,2,1,2,2,1,6,10,5,5,10,9,5,1,9,3,6
+M,3,7,4,5,4,9,6,5,4,6,7,6,7,5,2,6
+C,7,14,5,8,5,6,6,4,4,10,9,12,4,9,9,8
+N,6,9,9,7,4,7,8,3,5,10,6,7,6,9,1,7
+P,6,8,8,6,5,5,14,6,2,12,6,2,1,10,3,7
+O,4,2,5,4,3,8,7,8,5,7,6,8,2,8,3,8
+O,4,8,5,6,4,7,8,7,4,10,7,9,3,8,3,7
+B,5,8,7,6,6,10,6,3,6,10,4,7,3,8,5,10
+G,6,8,8,6,7,7,10,6,5,6,6,8,5,6,7,7
+S,3,10,4,7,4,8,6,8,6,7,8,10,2,10,9,7
+Z,6,10,6,5,3,9,5,2,8,11,5,9,2,9,5,9
+H,8,11,11,8,6,10,6,4,7,11,1,7,6,8,5,10
+Q,4,7,5,8,5,9,7,7,3,5,7,10,3,8,6,10
+L,3,7,4,5,3,9,3,1,7,9,2,10,0,6,2,10
+Z,4,6,5,4,3,9,5,3,8,11,4,9,2,7,6,10
+Q,3,3,4,5,3,8,7,7,3,5,6,9,3,8,5,9
+Q,2,5,3,6,3,9,10,6,1,3,7,11,2,10,5,11
+Y,6,8,6,6,4,4,9,1,8,11,10,6,1,10,2,4
+F,1,0,1,0,0,3,12,4,2,11,8,5,0,8,2,7
+M,3,7,4,5,4,8,6,5,4,7,7,8,7,5,2,7
+U,2,1,3,1,1,7,5,11,5,7,14,8,3,10,0,8
+F,3,4,3,5,1,1,12,5,4,11,10,7,0,8,3,6
+H,4,9,6,6,7,7,8,6,7,7,5,8,3,8,3,8
+F,4,10,6,8,5,7,9,3,5,12,7,6,2,9,2,7
+V,6,8,6,6,3,3,12,4,4,10,12,7,2,10,1,8
+X,3,4,5,3,2,7,8,1,8,10,7,8,2,8,3,7
+I,1,3,0,2,0,7,7,1,7,7,6,8,0,8,2,8
+E,5,9,4,4,2,9,6,4,4,11,4,10,3,8,6,11
+E,6,9,8,8,9,7,7,5,4,7,7,10,9,12,11,12
+E,4,8,6,6,4,5,8,5,8,11,10,9,3,8,5,5
+I,4,6,6,4,3,6,7,3,8,7,6,11,0,8,4,8
+X,3,9,4,7,3,8,7,4,4,7,6,9,2,8,4,8
+H,5,7,7,5,5,7,7,2,6,10,6,8,3,8,3,7
+U,2,1,3,2,1,7,9,5,6,7,10,9,3,9,0,8
+H,8,10,11,8,9,5,8,3,7,10,10,9,7,11,6,6
+S,5,8,7,6,8,8,5,4,4,9,6,10,4,8,9,9
+O,4,10,5,8,3,8,7,9,7,7,6,8,3,8,4,8
+Q,6,7,6,9,5,7,10,5,3,7,10,11,4,10,7,8
+Z,6,11,7,8,6,7,8,3,13,9,6,8,0,8,8,7
+N,3,5,4,4,3,7,8,5,5,7,7,6,5,9,2,6
+Z,1,0,2,1,0,7,7,2,10,8,6,8,0,8,6,8
+I,0,8,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+Q,5,11,5,6,4,11,5,4,6,10,4,7,4,9,6,12
+U,9,12,8,7,3,6,5,4,6,3,8,6,6,7,2,7
+T,6,8,6,6,3,5,14,5,6,12,9,2,2,12,2,4
+C,4,9,5,6,2,6,8,7,10,4,6,14,1,7,4,9
+I,1,5,2,3,1,7,7,0,7,13,6,8,0,8,1,8
+Z,7,8,5,11,5,8,5,5,5,11,7,8,3,9,10,7
+I,1,5,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+C,3,5,4,3,2,6,7,7,7,8,7,14,2,9,4,10
+Y,9,10,8,8,4,3,10,4,7,13,12,6,2,11,3,6
+V,7,9,5,4,3,9,7,6,4,7,9,7,7,12,3,7
+R,5,11,6,8,4,6,9,10,5,6,5,8,3,8,6,11
+Q,4,8,6,6,5,8,4,8,5,6,6,8,3,8,3,8
+C,2,1,2,2,1,6,8,6,7,8,7,13,1,9,3,10
+M,9,10,13,8,10,3,8,4,5,10,11,11,12,8,6,6
+Q,5,12,5,6,4,10,5,4,6,11,4,8,3,8,8,11
+Y,3,3,4,1,1,4,10,2,7,10,10,5,1,10,3,4
+T,3,5,5,4,4,6,8,5,6,8,8,8,3,10,6,7
+E,5,11,5,8,3,3,8,6,12,7,6,15,0,8,7,6
+U,4,7,5,5,4,6,8,8,5,5,6,11,4,9,5,5
+Z,4,7,6,5,3,7,7,2,10,11,6,8,1,8,6,8
+R,5,9,6,7,6,7,7,4,6,6,5,7,3,7,5,9
+W,6,11,8,8,4,5,8,5,2,7,8,8,9,9,0,8
+I,5,7,7,8,6,9,8,5,5,6,5,8,3,8,9,7
+W,2,3,3,1,2,5,10,4,2,9,8,7,5,10,1,6
+F,3,7,6,5,5,8,8,1,4,9,6,6,3,10,4,4
+K,3,5,5,4,3,5,8,1,6,10,8,10,3,8,3,8
+G,4,8,4,6,3,7,7,6,7,11,6,10,2,10,4,9
+Y,3,8,6,6,3,5,9,2,6,8,12,10,2,11,2,7
+N,2,1,2,2,1,7,8,6,4,7,6,7,4,8,1,7
+R,6,10,8,7,8,8,8,7,5,7,5,8,5,9,7,12
+B,5,8,8,6,6,11,5,2,6,10,3,7,5,7,6,12
+R,2,4,4,3,2,8,8,3,5,9,4,7,2,6,3,10
+Z,1,3,2,1,1,8,7,1,8,11,6,8,1,8,5,8
+K,6,11,8,8,6,4,7,2,7,10,10,12,3,8,4,7
+F,3,5,5,3,2,7,9,2,6,13,6,5,4,9,3,7
+N,3,2,4,4,3,7,9,5,4,7,7,7,5,9,2,6
+L,2,0,2,1,0,2,1,6,5,0,2,4,0,8,0,8
+P,2,1,2,2,1,5,11,5,3,10,7,3,0,9,3,6
+G,4,4,5,7,2,7,7,8,8,6,6,11,1,8,5,11
+Z,4,11,6,8,7,8,7,2,8,7,6,8,0,8,9,8
+Q,1,0,1,0,0,8,7,6,2,6,6,9,2,8,2,8
+X,1,1,2,1,0,7,7,4,4,7,6,8,2,8,4,7
+Y,1,0,2,1,0,7,9,1,2,6,12,8,1,10,0,8
+F,4,6,6,4,3,7,9,3,6,13,6,5,2,9,2,7
+S,5,9,8,7,9,5,7,3,2,7,6,5,3,8,9,2
+P,12,13,9,8,4,7,9,6,4,12,3,4,5,10,5,8
+Z,4,10,5,8,2,7,7,4,14,10,6,8,0,8,8,8
+N,6,10,8,5,3,12,4,5,3,13,1,7,5,7,0,8
+Z,8,12,8,6,5,8,5,2,8,12,6,10,3,7,7,8
+K,4,9,6,6,6,7,6,5,4,6,6,7,7,6,8,12
+I,1,3,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+H,5,9,6,6,3,7,10,15,2,7,3,8,3,8,0,8
+I,0,4,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+D,7,12,7,7,5,9,6,4,7,10,5,7,6,8,8,6
+O,3,7,5,5,6,8,6,5,2,7,6,8,8,9,5,10
+J,2,8,3,6,2,14,4,4,4,13,2,8,0,7,0,8
+D,2,3,2,2,1,7,7,6,6,7,6,4,2,8,3,6
+T,3,7,5,5,3,6,11,4,6,8,11,8,2,12,1,7
+V,3,9,5,6,1,7,8,4,3,7,14,8,3,9,0,8
+B,4,10,5,8,7,6,8,8,5,7,5,7,2,8,7,9
+J,2,8,3,6,1,13,3,8,4,14,3,11,0,7,0,8
+P,5,10,7,7,4,8,9,2,7,14,5,4,3,9,4,9
+O,6,10,7,7,5,8,6,8,6,10,6,9,4,8,5,5
+G,6,11,6,8,4,6,7,7,6,9,8,11,3,7,6,8
+Y,3,7,5,5,4,8,6,5,4,6,8,7,2,8,8,4
+C,2,4,3,3,1,6,8,7,7,8,8,13,1,10,4,10
+Y,7,11,8,8,5,3,9,2,7,9,11,7,2,11,3,5
+Y,5,7,7,11,10,8,11,3,3,6,8,9,4,11,11,7
+G,5,11,6,8,9,7,5,4,4,7,5,11,7,8,9,14
+I,1,3,0,2,0,7,7,1,7,7,6,8,0,8,2,8
+E,3,2,3,4,3,7,7,5,8,7,6,8,2,8,6,9
+T,2,4,2,2,1,8,12,3,5,6,10,8,2,11,1,8
+C,4,9,5,7,2,5,7,7,10,7,7,12,1,8,4,8
+H,11,14,10,8,5,8,7,4,5,9,6,7,7,10,5,9
+K,4,10,6,8,7,7,7,5,4,7,6,7,7,6,8,13
+Z,3,8,4,6,2,7,7,4,13,9,6,8,0,8,8,8
+U,8,13,8,7,5,6,6,4,5,6,7,8,5,6,3,7
+A,3,5,5,4,2,10,2,2,2,9,2,9,2,6,2,8
+K,4,9,6,7,6,5,6,4,7,6,6,10,3,8,6,10
+Q,3,6,4,5,3,9,8,7,4,5,7,10,2,8,4,9
+M,3,6,4,4,2,8,6,11,1,6,9,8,7,6,0,8
+F,6,10,8,7,4,5,13,2,6,13,6,2,1,10,2,6
+H,4,5,5,4,4,7,7,6,6,7,6,8,3,8,3,7
+Y,3,8,5,6,2,8,10,2,2,6,12,8,1,11,0,8
+S,1,3,2,2,1,8,7,6,5,7,6,7,2,8,8,8
+Y,3,9,5,6,1,7,10,3,2,7,13,8,2,11,0,8
+K,4,8,6,6,5,8,5,1,6,10,4,9,3,8,4,10
+Y,3,9,5,6,1,7,11,1,3,7,12,8,1,10,0,8
+J,3,6,5,4,2,7,4,5,3,13,9,14,1,6,1,6
+W,5,11,7,8,4,7,7,5,2,7,8,8,9,9,0,8
+O,4,7,6,6,4,8,4,3,4,9,3,8,3,7,4,9
+N,11,15,9,8,4,7,10,5,5,4,5,11,6,11,2,6
+Q,7,12,7,6,5,9,6,4,7,11,5,8,4,8,9,10
+E,4,10,4,7,3,3,8,6,11,7,5,15,0,8,7,7
+P,3,4,5,6,5,8,9,3,2,7,8,6,5,10,5,5
+K,6,8,8,6,4,3,9,3,7,11,11,11,4,7,4,5
+Q,7,15,6,8,4,10,4,4,7,10,4,8,3,9,7,13
+P,5,8,7,11,12,7,11,5,0,9,7,6,5,10,6,8
+Z,3,8,4,6,3,9,6,5,10,7,5,6,1,7,8,8
+S,6,10,7,8,4,8,7,4,8,11,6,7,2,8,5,8
+P,3,7,3,4,2,3,13,7,2,11,6,3,1,10,4,8
+U,4,4,4,6,2,7,5,13,5,7,14,8,3,9,0,8
+Z,3,2,4,4,2,7,7,5,10,6,6,8,1,8,7,8
+O,4,7,6,6,4,8,5,3,4,8,3,7,3,7,5,9
+D,3,7,5,5,4,8,8,5,5,9,6,4,3,8,3,7
+Q,4,6,4,8,5,8,5,6,4,9,5,9,3,8,5,7
+R,4,8,4,5,2,5,12,8,4,7,3,9,3,7,6,11
+A,3,5,6,4,3,11,1,2,2,9,2,9,3,7,3,9
+A,2,2,4,4,2,8,2,2,2,8,2,8,2,6,3,7
+G,3,4,4,2,2,6,7,5,5,10,7,9,2,9,4,9
+N,5,10,6,8,6,6,7,8,5,7,5,6,3,7,3,8
+E,7,10,9,8,6,7,8,2,10,11,6,9,2,8,5,8
+V,3,1,5,3,1,7,12,3,3,6,11,9,2,10,1,8
+Y,5,7,7,11,10,8,9,3,2,5,8,10,6,13,9,9
+C,5,10,4,5,3,8,7,4,2,8,8,10,3,9,7,13
+R,4,6,4,8,3,5,12,9,4,7,2,9,3,7,6,11
+F,2,3,3,1,1,7,9,2,5,13,6,5,1,9,2,8
+O,5,11,6,8,6,7,8,7,3,10,8,8,4,7,5,10
+D,3,8,4,6,4,5,7,9,6,7,6,5,3,8,3,9
+H,4,7,5,5,4,6,7,6,4,6,5,8,3,7,6,10
+C,4,9,4,4,3,7,8,4,3,9,8,10,3,9,8,11
+V,2,3,3,2,1,8,12,2,2,5,10,9,2,11,0,8
+O,2,0,2,1,0,7,7,6,5,7,6,8,2,8,3,8
+X,3,4,5,3,2,7,7,1,8,10,6,8,2,8,3,8
+M,8,10,12,8,9,10,6,2,5,9,5,7,8,7,2,8
+L,1,4,3,2,1,6,4,1,7,8,2,11,0,7,2,9
+E,4,7,6,5,3,8,7,2,9,11,5,8,2,8,5,10
+O,4,8,6,6,2,8,5,8,8,7,4,9,3,8,4,8
+Z,3,3,4,5,2,7,7,4,13,9,6,8,0,8,8,8
+X,4,5,6,4,3,7,7,1,9,10,6,8,2,8,3,7
+F,5,10,7,7,4,7,10,3,6,13,7,5,2,10,2,7
+D,3,4,4,3,3,7,7,7,6,7,6,4,2,8,3,7
+J,2,8,2,6,1,13,3,8,4,13,3,11,1,6,0,8
+V,4,6,5,4,2,4,12,3,3,10,11,7,2,10,1,8
+N,4,6,4,4,2,7,7,14,1,5,6,8,6,8,0,8
+P,5,10,7,8,6,5,11,7,4,10,7,2,2,11,4,7
+L,2,6,4,4,2,6,4,1,9,8,2,11,0,7,2,8
+N,4,7,6,5,3,11,6,4,5,10,1,5,5,9,1,7
+M,7,6,7,8,4,8,7,13,2,6,9,8,9,6,0,8
+J,3,11,4,8,2,9,4,5,8,12,4,12,1,6,2,6
+Z,2,6,3,4,1,7,7,3,13,9,6,8,0,8,8,8
+V,6,9,5,7,3,3,11,3,4,10,12,8,2,10,1,8
+X,3,2,4,3,2,7,7,3,9,6,6,8,3,8,6,7
+C,4,10,6,8,5,8,6,9,6,8,6,11,4,9,4,8
+M,6,5,8,4,7,9,8,5,4,7,6,7,9,8,5,3
+Z,2,2,3,4,2,8,7,5,9,6,6,8,1,8,7,8
+G,5,7,6,5,6,7,6,5,3,7,6,9,5,8,7,7
+I,4,11,5,8,3,9,6,0,8,14,5,8,0,8,1,8
+G,5,9,7,7,4,6,7,7,7,6,6,12,3,9,5,7
+E,4,10,4,7,4,3,7,5,9,7,7,13,0,8,7,9
+D,3,2,5,3,3,7,7,6,7,7,6,5,2,8,3,7
+B,5,7,7,5,6,8,6,6,6,9,7,7,3,8,7,9
+R,6,9,8,7,8,8,6,7,3,8,5,7,4,6,7,10
+U,4,5,5,4,2,4,8,5,7,10,9,8,3,9,2,6
+D,2,4,4,3,2,9,6,4,6,10,5,6,2,8,2,9
+S,1,3,3,2,1,7,8,3,7,10,7,8,1,8,4,6
+A,5,11,4,6,3,10,2,3,1,9,4,11,3,4,4,8
+K,6,9,8,6,7,9,6,1,6,10,3,8,6,7,5,9
+L,1,0,1,1,0,2,1,5,5,0,2,5,0,8,0,8
+F,3,2,4,3,2,5,11,4,6,11,9,5,1,10,3,6
+C,3,4,4,6,2,6,7,7,9,8,5,13,1,9,4,9
+T,2,5,4,4,3,7,8,4,7,7,7,8,3,9,6,7
+Q,3,7,4,6,2,8,8,8,5,5,8,9,3,7,6,10
+M,3,2,4,3,4,8,6,6,4,7,7,8,7,6,2,7
+M,11,14,11,8,6,9,11,6,4,4,6,9,11,12,3,7
+C,3,4,4,3,2,4,7,5,7,10,8,13,1,9,3,8
+O,3,5,4,4,3,7,7,7,4,9,5,7,2,8,3,7
+B,5,10,7,8,7,8,8,4,5,7,6,7,7,7,6,9
+U,5,8,5,6,2,7,4,14,6,7,14,8,3,9,0,8
+O,4,7,6,5,4,7,5,8,5,8,5,11,3,8,4,8
+O,4,6,6,5,4,7,5,5,4,8,4,7,3,7,4,8
+C,5,10,6,7,4,5,7,7,10,7,6,11,2,8,5,11
+K,6,10,9,7,7,4,8,2,7,10,10,11,4,7,4,6
+E,3,2,4,4,3,7,7,5,8,7,5,9,2,8,6,10
+C,3,7,4,5,2,3,7,5,6,9,8,14,1,8,3,9
+H,3,6,5,4,6,9,7,4,4,6,6,8,7,8,6,7
+A,4,9,6,6,2,6,4,3,1,6,1,8,3,7,2,7
+R,4,7,4,4,2,5,10,8,3,7,4,8,3,7,6,11
+E,3,6,4,4,4,7,7,5,8,7,7,9,3,8,6,9
+S,6,9,7,7,5,7,8,3,7,10,7,8,2,8,5,6
+E,2,7,3,5,3,3,8,5,9,7,6,13,0,8,6,9
+B,5,9,8,8,9,7,7,5,4,7,6,8,7,9,9,6
+S,7,12,7,7,3,7,7,5,3,13,9,10,3,10,3,8
+Z,2,5,4,4,2,7,8,2,9,11,7,7,1,8,5,7
+H,6,11,9,9,8,10,6,3,6,10,3,7,6,8,5,10
+V,8,11,8,8,5,3,12,2,3,9,10,7,5,11,2,6
+K,5,8,8,6,4,4,8,3,7,10,10,11,4,8,4,6
+O,3,7,5,5,3,8,6,7,4,7,5,8,3,8,3,7
+K,4,9,6,7,8,7,7,3,4,6,6,8,7,8,8,7
+A,9,15,7,8,4,8,1,2,2,9,4,12,4,5,5,6
+M,7,10,9,8,11,8,6,6,5,7,5,8,6,9,8,8
+S,4,6,5,4,2,8,7,3,8,11,6,7,2,8,5,8
+X,2,3,3,4,1,7,7,4,4,7,6,8,2,8,4,8
+C,2,6,3,4,1,4,7,7,9,7,6,11,1,9,4,9
+E,4,9,4,7,3,3,7,6,10,7,6,14,0,8,8,7
+B,4,9,4,7,3,6,6,9,7,6,6,7,2,8,9,10
+W,2,1,3,2,2,8,10,2,2,6,9,8,5,11,0,8
+K,4,10,6,8,6,7,7,5,4,7,5,8,4,7,9,10
+Z,4,9,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+C,6,10,6,8,4,4,9,7,7,13,10,8,2,10,2,7
+A,3,4,6,6,2,7,5,3,1,7,0,8,2,7,2,8
+K,2,3,4,2,2,5,9,1,6,10,8,9,3,8,2,8
+P,4,7,6,5,4,7,10,2,6,13,6,4,0,10,3,9
+E,5,9,7,7,8,6,7,3,6,7,7,11,4,10,8,7
+V,6,12,6,7,3,5,11,4,3,10,8,5,4,11,2,8
+V,4,8,5,6,3,7,9,4,1,7,13,8,2,10,0,8
+S,3,9,4,7,2,7,6,6,10,5,7,10,0,9,9,8
+S,4,10,5,8,4,7,7,5,8,5,6,9,0,8,8,8
+X,4,8,7,6,3,8,6,1,8,10,4,8,3,8,3,8
+K,3,4,4,6,2,3,7,8,3,7,6,11,4,8,2,11
+I,1,4,2,3,1,7,8,0,7,13,6,8,0,8,1,7
+P,3,4,3,5,2,4,11,8,3,10,6,4,1,10,3,8
+L,3,7,4,5,2,8,4,1,7,9,3,9,1,6,2,9
+L,3,8,5,6,6,7,7,3,5,6,7,10,6,11,6,6
+F,5,10,5,6,4,7,10,2,5,11,6,5,4,10,7,7
+R,2,1,2,1,1,6,9,8,3,7,5,7,2,7,4,10
+H,4,4,6,3,3,8,7,3,6,10,6,8,3,8,3,8
+B,2,3,2,1,2,7,8,5,5,7,5,6,1,8,5,9
+Q,2,4,3,5,3,7,8,5,1,7,8,10,2,9,4,8
+Y,2,5,4,4,2,6,10,1,7,7,11,9,1,11,2,9
+V,4,7,6,6,6,6,8,5,5,8,6,8,6,9,8,7
+H,4,8,4,5,2,7,8,15,1,7,5,8,3,8,0,8
+I,1,9,0,6,0,7,7,4,4,7,6,8,0,8,0,8
+N,2,3,2,2,2,7,9,6,3,7,6,8,4,8,1,7
+N,1,0,2,1,1,7,7,11,1,5,6,8,4,8,0,8
+U,4,9,6,6,3,4,9,7,7,10,11,9,3,9,1,8
+U,4,7,5,5,2,7,3,14,6,7,13,8,3,9,0,8
+F,2,3,3,1,1,6,12,3,4,13,7,3,1,9,1,7
+J,1,1,2,2,1,10,6,3,5,12,4,10,1,7,1,7
+L,6,11,8,9,6,10,3,1,7,10,2,10,3,6,4,10
+P,3,4,3,6,2,3,14,8,2,12,7,3,0,10,4,8
+W,11,11,10,6,4,6,11,2,3,7,10,6,8,12,1,7
+W,9,10,13,9,15,8,7,5,5,7,6,8,12,10,10,4
+P,2,4,4,3,2,6,10,3,4,12,5,3,1,10,2,8
+I,0,7,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+T,6,9,5,4,2,5,10,2,7,13,7,5,2,8,4,4
+Z,5,8,7,6,4,8,7,2,10,12,6,7,1,7,6,7
+F,4,8,6,6,4,6,10,2,5,13,7,5,2,10,2,7
+I,2,2,2,4,2,7,7,1,8,7,6,8,0,8,3,8
+H,6,10,7,6,5,8,7,3,5,10,7,7,7,11,5,8
+S,3,6,5,4,5,8,7,4,3,8,5,8,4,9,10,10
+N,8,12,10,6,4,3,11,6,3,14,12,9,6,10,0,8
+E,6,11,4,6,3,7,8,4,4,10,5,9,3,9,7,10
+U,5,10,5,7,4,7,5,13,5,7,12,8,3,9,0,8
+K,1,0,2,1,0,5,7,7,1,7,6,11,3,8,2,11
+O,2,0,2,1,0,7,7,6,5,7,6,8,2,8,3,8
+X,4,9,5,6,1,7,7,5,4,7,6,8,3,8,4,8
+V,2,1,3,3,1,7,12,2,2,7,11,8,2,10,1,8
+X,1,0,1,0,0,7,7,3,5,7,6,8,2,8,4,8
+R,3,7,4,5,4,6,8,8,4,7,5,7,2,7,4,11
+A,6,8,8,6,7,6,7,7,5,7,5,9,4,8,11,3
+L,2,4,3,3,1,4,4,4,7,2,2,6,0,7,1,6
+J,1,1,2,2,0,10,6,2,5,12,4,9,0,7,1,7
+F,4,9,7,7,7,5,8,2,4,10,8,7,8,10,4,4
+C,3,9,4,7,2,5,7,7,9,6,6,13,1,7,4,8
+C,6,9,8,8,8,5,9,4,6,6,6,11,4,11,8,9
+X,6,11,8,8,7,8,6,3,6,6,7,7,4,8,10,10
+R,5,7,7,5,4,10,6,2,6,11,2,7,3,6,3,10
+M,7,8,9,7,10,7,9,4,4,7,6,7,10,7,6,5
+E,2,0,2,1,1,5,8,5,8,7,6,12,0,8,7,9
+W,6,9,6,4,3,2,8,2,3,9,11,9,7,9,1,6
+Y,9,14,8,8,4,6,8,4,4,10,9,5,5,10,5,4
+G,4,6,5,4,3,5,9,5,5,10,8,7,2,8,5,9
+P,6,11,9,8,7,8,10,4,4,12,5,3,1,10,3,8
+B,5,9,6,7,5,6,8,9,8,7,5,7,2,8,9,9
+V,4,8,6,6,3,5,11,3,4,8,12,9,2,10,1,8
+L,4,8,5,6,2,4,5,2,9,5,1,9,1,7,3,6
+V,3,7,5,5,5,7,7,4,2,8,8,8,5,10,4,8
+L,3,10,5,8,3,9,3,1,8,10,2,10,0,6,3,10
+X,4,3,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+N,5,8,7,6,5,7,9,5,5,7,6,6,7,8,3,7
+Y,7,10,7,8,4,5,9,2,9,10,11,5,4,9,6,3
+X,5,7,7,5,3,7,7,1,8,10,5,8,3,8,3,7
+J,3,5,4,8,2,11,3,11,3,12,8,13,1,6,0,8
+E,1,3,3,2,1,6,7,2,7,11,7,9,1,8,4,9
+C,5,7,5,5,3,6,8,6,8,12,8,12,2,10,3,7
+L,3,10,5,7,3,6,4,1,8,7,1,9,0,6,2,8
+R,4,10,5,8,3,5,9,9,4,7,6,8,3,8,6,11
+F,5,7,7,5,3,7,10,2,7,14,5,4,2,9,4,7
+D,4,7,4,5,2,5,8,10,9,8,7,5,3,8,4,8
+K,5,11,5,8,5,3,7,7,3,7,6,11,3,8,3,11
+R,2,1,3,3,2,6,7,4,5,6,5,7,2,6,4,8
+T,2,6,3,4,2,8,12,2,8,5,11,9,1,11,1,8
+Q,5,7,6,9,7,9,8,7,2,5,7,10,3,8,6,10
+F,5,11,7,8,5,7,9,1,6,13,6,5,1,10,2,8
+T,3,4,4,2,1,5,12,2,7,11,9,4,1,10,2,5
+X,3,7,4,4,1,7,7,5,4,7,6,8,3,8,4,8
+U,6,10,7,8,4,4,8,6,8,9,9,9,3,10,2,5
+B,4,7,6,5,4,7,8,6,5,9,6,6,3,8,6,8
+P,3,9,4,6,2,5,10,10,3,9,6,4,2,10,4,8
+E,3,8,3,6,2,3,7,6,11,7,6,15,0,8,6,7
+H,5,9,7,7,7,7,7,5,7,7,6,7,6,8,4,7
+H,5,4,6,6,2,7,7,15,0,7,6,8,3,8,0,8
+S,5,5,6,7,3,7,6,6,10,5,6,10,0,9,9,8
+U,7,9,7,7,4,4,7,6,8,9,9,9,3,9,3,5
+K,4,11,4,8,2,3,7,8,2,6,5,11,4,8,2,11
+K,1,0,1,0,0,4,6,5,2,7,6,10,2,7,1,10
+R,3,8,4,5,2,6,10,9,4,7,4,8,3,7,5,11
+P,6,11,8,8,5,7,12,8,3,11,4,2,1,10,5,7
+M,6,7,9,6,9,6,8,5,3,6,5,8,12,8,5,8
+Y,5,6,7,9,10,8,4,5,3,7,8,9,8,8,6,8
+H,4,7,5,5,4,6,6,6,4,6,5,8,2,7,6,9
+X,6,11,9,8,5,8,6,1,9,10,4,8,3,8,4,8
+P,8,11,6,6,3,9,7,6,4,13,3,6,5,9,4,8
+B,4,9,6,6,6,8,8,4,5,10,5,6,3,8,5,10
+I,1,7,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+U,3,4,4,3,2,4,8,5,7,9,8,9,3,10,2,5
+I,2,9,3,7,4,7,7,0,7,7,6,8,0,8,3,8
+Z,5,5,6,8,3,7,7,4,15,9,6,8,0,8,9,8
+Z,4,5,5,8,2,7,7,4,14,10,6,8,0,8,8,8
+K,2,3,4,2,2,6,7,2,6,10,7,10,3,8,2,7
+H,3,7,4,5,4,7,7,7,6,7,7,8,3,8,3,7
+B,5,7,8,6,8,7,7,5,4,7,6,8,6,9,8,6
+G,4,4,5,6,2,8,5,7,9,8,4,12,1,9,5,10
+B,2,4,4,2,2,9,7,2,5,10,5,6,2,8,4,9
+Z,2,7,3,5,1,7,7,3,12,9,6,8,0,8,8,8
+L,5,11,6,8,5,4,4,4,8,2,1,6,1,6,1,5
+X,6,12,6,6,3,10,6,3,8,9,2,6,4,6,4,10
+T,2,7,3,5,2,6,13,0,5,8,10,8,0,8,0,8
+C,4,4,6,7,2,5,7,7,10,7,6,12,1,9,4,9
+B,3,6,5,5,5,6,9,6,6,8,7,7,5,9,7,8
+L,2,8,3,6,1,0,1,5,6,0,0,7,0,8,0,8
+U,6,10,9,8,11,8,5,4,4,7,7,7,11,8,6,10
+V,2,6,4,4,2,8,12,2,2,5,10,9,2,11,0,9
+O,6,10,8,8,5,7,7,9,4,7,6,8,3,8,4,8
+K,2,1,2,2,2,5,7,4,6,7,6,10,3,8,3,10
+Z,2,4,3,3,2,7,7,5,9,6,6,8,2,8,7,8
+N,5,10,5,8,5,7,7,13,1,6,6,8,6,9,0,6
+R,2,0,2,1,1,6,10,8,2,7,5,8,2,7,4,10
+T,4,9,6,7,5,6,11,2,7,8,11,8,1,12,1,8
+P,3,8,5,6,4,6,9,3,6,9,8,5,4,10,4,7
+S,1,3,3,2,1,8,7,3,6,10,6,7,1,8,5,8
+A,5,9,5,5,3,10,2,4,2,11,5,12,5,3,5,10
+Y,2,1,3,3,1,8,11,1,7,6,11,7,1,11,2,7
+A,4,11,7,8,2,7,5,3,1,6,1,8,3,7,2,7
+D,6,12,6,6,5,8,6,3,6,10,5,7,5,8,8,6
+R,4,8,6,6,7,5,6,3,4,7,5,9,6,10,7,5
+U,5,7,7,5,8,7,7,4,4,7,7,8,10,9,6,8
+L,3,3,3,5,1,0,1,6,6,0,0,6,0,8,0,8
+H,5,7,8,5,6,9,7,3,7,10,3,7,5,8,4,9
+L,2,7,2,5,1,0,1,5,6,0,0,7,0,8,0,8
+T,6,7,6,5,4,7,10,2,7,11,9,5,3,11,4,4
+V,3,8,4,6,3,7,11,2,3,6,11,9,2,10,1,9
+X,3,4,5,3,2,7,8,4,9,6,6,7,4,9,7,7
+D,4,8,4,6,3,5,8,10,9,8,7,6,3,8,4,8
+M,2,1,3,2,2,8,6,6,3,7,7,9,6,5,1,8
+D,4,6,5,4,4,9,7,4,6,10,4,5,3,8,3,8
+D,4,11,6,8,7,9,7,4,5,10,4,6,4,7,3,8
+H,3,3,5,2,2,5,9,3,5,10,9,8,3,9,3,6
+R,4,9,6,7,5,10,7,3,6,10,3,7,3,6,4,10
+U,2,3,3,2,1,4,8,4,6,11,10,9,3,9,1,7
+K,3,5,5,4,3,5,7,4,8,7,6,11,3,8,5,9
+X,8,11,8,6,4,4,10,4,8,11,10,9,4,9,3,5
+C,4,7,4,5,2,4,7,6,7,9,8,15,1,8,3,8
+J,2,8,3,6,2,14,4,4,4,12,2,9,0,7,0,8
+D,3,7,4,5,4,10,6,3,6,10,4,7,3,8,3,9
+N,1,0,1,1,0,7,7,10,0,5,6,8,4,8,0,8
+U,4,5,5,4,2,3,8,4,6,11,11,9,3,9,1,6
+S,4,9,4,5,2,7,8,4,3,13,8,8,2,10,3,8
+C,2,1,2,2,1,7,8,7,6,8,7,11,2,9,3,10
+Q,4,8,5,9,5,8,6,7,4,9,7,9,3,9,6,9
+Q,5,8,7,9,6,8,5,8,5,6,6,9,3,8,6,10
+B,5,9,5,7,7,6,7,8,6,6,6,7,2,8,7,10
+Q,4,9,5,10,5,9,8,8,2,5,7,11,4,9,6,8
+K,3,1,4,2,3,6,7,4,7,7,6,10,6,8,4,9
+I,2,7,3,5,1,9,6,0,7,13,5,8,0,8,1,8
+M,3,3,4,5,3,7,7,12,1,8,9,8,8,6,0,8
+O,3,6,4,4,3,7,7,7,5,7,6,8,2,8,3,7
+F,3,7,5,5,3,9,8,2,6,13,4,5,2,10,3,9
+B,4,8,6,6,4,8,8,4,7,10,5,6,2,8,6,10
+Q,2,4,3,5,3,8,7,6,3,8,6,9,2,9,3,9
+T,2,6,3,4,1,7,12,0,5,7,10,8,0,8,0,8
+D,1,0,2,0,0,6,7,7,6,7,6,6,2,8,3,8
+F,3,7,3,5,1,1,11,4,6,11,11,9,0,8,2,6
+W,7,9,7,7,6,5,10,3,2,9,7,7,9,13,3,4
+S,4,7,5,5,6,9,4,5,3,8,6,9,3,8,10,11
+X,5,11,8,8,6,7,8,3,9,5,5,7,4,9,8,7
+M,5,9,7,6,7,7,7,5,5,6,7,9,8,6,2,8
+E,3,6,5,4,4,6,7,3,7,11,8,9,3,8,4,8
+P,9,14,8,8,4,9,8,7,5,13,3,5,5,10,4,8
+W,4,7,6,5,4,10,8,4,1,7,9,8,7,10,0,8
+B,1,1,2,1,1,7,7,7,5,6,6,7,1,8,6,8
+B,2,5,4,4,3,8,7,3,5,10,5,7,2,8,4,10
+D,7,12,6,6,4,8,5,4,6,8,4,7,5,6,6,10
+P,8,12,6,7,3,8,8,5,4,12,4,6,5,9,4,8
+J,3,5,4,8,1,11,2,11,3,13,7,14,1,6,0,8
+U,5,5,6,7,2,8,4,14,6,6,15,8,3,9,0,8
+M,4,5,6,3,4,8,6,6,5,6,7,8,9,6,3,7
+B,5,9,7,7,10,9,9,5,4,7,8,6,6,10,10,10
+P,3,5,5,7,7,8,10,4,0,8,7,6,7,10,4,7
+V,3,5,4,4,2,5,12,2,3,8,11,7,2,11,1,8
+H,6,7,9,5,6,10,6,3,6,10,3,7,3,7,3,9
+B,5,11,7,9,8,8,7,5,6,6,6,5,3,8,6,10
+A,2,5,4,4,3,9,8,3,4,6,7,8,4,8,4,6
+T,4,7,5,5,1,4,14,4,7,12,9,3,0,10,1,5
+G,1,0,2,1,0,8,6,6,5,6,5,9,1,7,5,10
+S,5,11,6,8,3,7,6,6,9,4,6,9,0,9,9,8
+Y,4,6,6,8,1,8,12,2,3,7,12,8,1,10,0,8
+V,4,5,5,4,2,4,12,3,3,10,11,7,2,10,1,8
+S,5,8,6,6,4,8,8,4,7,10,3,7,2,6,5,9
+H,9,15,8,8,5,6,8,4,6,9,8,9,6,8,6,10
+O,6,9,6,7,5,7,7,7,5,10,6,10,5,8,4,6
+U,10,14,9,8,5,6,6,5,5,6,8,9,7,7,4,10
+N,3,7,5,5,4,7,6,6,5,7,5,9,4,8,3,7
+N,3,3,4,5,2,7,7,14,2,5,6,8,5,8,0,8
+P,4,10,6,7,4,6,9,7,5,9,7,3,2,10,4,7
+T,5,10,5,7,3,4,14,5,5,12,9,3,1,11,1,5
+J,2,3,4,4,2,10,6,2,6,12,4,9,1,6,1,7
+Q,4,6,5,8,4,8,7,6,3,8,8,10,3,8,6,8
+J,5,10,5,8,4,9,8,2,4,11,6,7,2,10,6,12
+K,8,11,11,8,6,8,6,2,8,11,4,8,4,8,5,10
+X,4,9,6,7,4,7,7,4,9,6,7,11,4,6,8,9
+I,4,11,5,8,3,7,7,0,8,14,6,8,0,8,1,8
+Z,5,8,7,6,6,9,7,5,4,7,5,7,4,8,10,5
+Q,5,5,7,8,3,8,8,7,7,6,8,9,3,7,6,9
+T,6,10,5,5,3,7,9,2,7,12,7,6,2,9,4,6
+D,5,10,7,8,10,9,8,5,5,7,6,6,4,7,7,5
+E,3,5,4,4,3,7,7,5,7,7,6,9,2,8,6,10
+A,3,8,5,5,2,9,6,3,1,7,0,8,2,7,1,8
+D,4,7,6,5,4,8,7,6,7,10,5,5,3,8,3,8
+D,5,9,5,5,3,10,5,4,5,11,3,7,4,7,4,10
+Q,5,9,7,7,6,8,3,8,4,6,6,7,3,8,3,8
+D,3,3,3,4,2,5,7,9,8,6,5,5,3,8,4,8
+I,1,2,1,3,1,7,7,1,8,7,6,8,0,8,3,8
+S,2,4,3,3,1,7,8,3,7,10,7,7,1,9,5,7
+L,4,10,6,9,5,8,6,4,4,6,7,8,3,9,8,10
+I,1,1,1,1,0,7,7,2,6,7,6,8,0,8,2,8
+Q,2,3,3,4,2,8,9,6,1,5,7,10,2,10,5,10
+O,4,4,5,6,2,8,9,8,8,6,8,9,3,8,4,8
+F,3,2,4,4,2,5,10,4,6,11,9,5,1,10,3,6
+R,4,8,5,6,3,6,9,9,4,6,5,8,3,8,6,11
+P,5,10,7,8,7,6,9,5,5,9,7,3,2,10,4,6
+J,6,10,7,8,3,9,3,6,6,15,7,15,1,6,1,7
+Q,1,0,1,1,0,8,7,6,2,6,6,8,2,8,2,8
+J,2,8,3,6,1,11,3,10,3,12,8,13,1,6,0,8
+L,2,5,4,3,2,7,3,1,7,8,2,10,0,7,2,8
+Z,4,7,6,10,6,10,5,4,4,8,3,7,2,6,7,8
+D,5,10,5,8,5,6,7,9,8,6,4,6,3,8,3,8
+X,8,12,9,7,5,6,8,2,8,11,7,8,5,8,4,6
+N,5,11,5,8,3,7,7,15,2,4,6,8,6,8,0,8
+Q,4,11,6,9,3,9,8,9,6,5,7,10,3,8,5,9
+G,6,10,8,7,6,6,6,6,6,6,6,10,4,8,5,9
+A,3,8,4,6,3,8,3,2,2,7,1,8,2,6,2,7
+P,1,0,2,0,0,5,11,6,1,9,6,5,1,9,3,8
+T,5,9,5,7,3,6,11,2,8,11,9,4,1,11,3,4
+N,4,9,6,6,4,7,9,2,5,9,5,6,5,8,1,7
+Q,3,6,4,7,4,9,9,7,2,4,7,11,3,10,5,10
+Q,3,7,4,9,5,8,5,8,4,6,5,8,3,7,5,9
+P,8,10,7,5,3,7,9,5,4,12,4,5,4,9,4,8
+I,1,5,1,3,1,7,7,1,8,7,6,8,0,8,3,8
+C,5,4,6,7,2,6,9,7,11,5,7,12,1,6,4,8
+M,8,10,10,6,5,9,3,3,2,9,3,10,8,1,2,9
+P,4,11,6,9,6,7,9,5,5,9,8,3,2,10,4,6
+N,10,13,11,7,5,7,7,3,5,13,9,9,6,8,0,8
+L,1,3,2,1,1,6,4,1,7,7,2,9,0,7,2,8
+I,1,5,2,4,1,7,9,0,7,13,6,6,0,8,1,7
+I,2,6,4,4,3,11,6,1,5,9,4,5,1,8,5,9
+P,2,1,3,1,1,5,11,8,2,9,5,4,1,9,3,8
+N,11,13,9,7,4,6,9,4,7,3,4,11,6,10,2,7
+V,4,8,6,7,7,8,8,5,4,7,6,8,7,7,10,4
+Q,4,8,5,6,5,8,4,7,4,6,6,11,2,8,3,9
+S,5,9,4,5,2,9,3,2,5,8,1,7,3,7,4,10
+Q,3,7,4,9,5,9,8,7,2,4,8,11,3,9,6,10
+C,4,8,5,6,5,5,7,4,5,7,7,9,7,9,5,9
+Z,3,8,4,6,2,7,7,4,13,9,6,8,0,8,8,8
+Q,3,5,5,7,5,8,12,3,3,5,8,11,3,13,4,9
+W,5,5,8,8,4,9,7,5,2,6,8,8,9,9,0,8
+G,6,10,6,8,4,6,7,6,7,10,8,11,2,9,5,9
+X,3,6,5,5,4,5,8,2,5,8,6,9,3,6,7,8
+C,4,4,5,6,2,6,6,7,10,9,6,14,1,9,4,8
+P,4,9,4,4,3,9,8,4,3,11,5,5,4,11,5,7
+X,5,11,9,8,8,9,6,3,6,7,5,5,6,10,8,9
+D,6,9,5,5,4,6,7,5,6,9,6,7,5,9,6,5
+G,3,8,5,6,4,8,7,7,5,6,6,9,2,7,5,11
+G,3,4,4,2,2,6,7,5,6,6,6,9,2,8,3,8
+H,2,4,4,2,2,7,7,3,5,10,6,8,3,8,2,7
+J,4,8,6,6,3,8,4,5,4,14,6,13,1,6,0,7
+P,4,10,5,8,5,6,9,6,5,9,7,4,5,10,4,7
+D,4,6,6,5,5,6,8,5,7,6,5,7,4,7,5,5
+G,2,0,2,1,1,8,7,6,5,6,6,9,1,7,5,10
+Z,2,5,3,3,2,7,7,5,9,6,6,8,2,8,7,8
+T,5,8,5,6,4,5,12,4,5,12,9,5,2,12,1,5
+W,4,6,4,4,4,3,10,2,2,10,9,7,5,11,2,6
+T,7,12,6,6,2,5,11,3,7,12,8,4,2,9,4,3
+I,1,6,0,4,1,7,7,5,3,7,6,8,0,8,0,8
+C,3,6,5,4,4,6,6,3,4,8,6,11,5,9,3,8
+Q,2,2,2,3,2,8,8,5,3,8,7,8,2,9,2,7
+M,1,0,1,0,1,8,6,8,0,6,8,8,5,7,0,8
+T,2,8,3,6,2,6,12,0,6,8,10,8,0,8,0,8
+A,6,10,6,5,4,12,3,6,2,12,2,10,5,3,3,10
+B,3,6,4,4,3,6,6,8,6,6,6,7,2,8,9,10
+X,6,9,9,7,5,7,7,0,8,10,7,9,2,8,3,7
+O,7,11,9,8,6,7,7,9,5,6,7,11,5,8,5,7
+W,6,7,6,5,5,6,11,4,2,8,7,6,9,12,4,5
+F,6,9,9,7,4,7,10,2,8,14,6,3,1,10,3,8
+E,0,0,1,1,0,5,7,5,7,7,6,12,0,8,6,10
+Q,4,6,4,8,5,8,6,6,2,8,6,10,3,8,5,9
+X,5,10,8,7,6,7,8,2,6,7,6,7,6,9,8,7
+S,2,2,2,3,2,8,7,6,5,8,6,7,2,8,8,8
+V,7,10,7,6,3,6,9,4,3,9,8,5,5,12,2,8
+R,3,6,4,4,3,7,7,4,5,7,6,6,3,7,4,9
+S,4,9,4,7,4,7,7,5,8,5,6,10,1,10,9,9
+F,6,8,8,10,9,7,9,5,5,8,6,7,4,9,8,8
+E,5,11,7,8,7,6,7,7,10,6,4,11,3,8,6,8
+J,2,6,3,4,2,10,6,1,8,12,3,7,0,7,0,8
+M,5,7,8,5,5,8,6,2,5,9,6,8,8,6,2,8
+H,4,8,4,5,2,7,9,15,1,7,4,8,3,8,0,8
+N,8,11,11,8,5,7,8,3,5,10,6,7,7,7,2,7
+H,4,8,4,6,4,7,7,12,1,7,6,8,3,8,0,8
+F,3,6,4,4,3,5,10,3,4,12,8,6,2,10,1,7
+F,5,8,7,6,3,7,10,2,7,14,5,4,1,10,2,8
+Z,3,7,4,5,2,7,7,3,12,8,6,8,0,8,7,7
+I,5,9,6,6,4,5,7,3,7,7,6,12,0,8,4,9
+G,5,7,5,5,3,6,7,6,6,9,7,10,2,8,4,9
+J,1,6,2,4,1,12,3,9,3,13,6,12,1,6,0,8
+G,3,8,4,6,4,8,7,7,5,6,6,8,2,8,5,11
+G,4,8,5,6,6,8,7,4,2,6,6,8,7,8,7,11
+B,1,0,2,0,1,7,7,6,4,6,6,7,1,8,6,8
+M,6,10,9,8,8,8,7,2,4,9,7,8,8,6,2,8
+Z,5,9,6,4,3,10,3,3,7,12,4,10,2,9,4,11
+R,3,8,4,6,4,5,10,7,3,7,3,9,2,6,4,11
+I,1,8,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+Q,3,4,4,5,3,8,8,7,2,5,7,10,3,9,5,10
+W,4,6,6,4,2,5,8,4,1,7,9,8,8,9,0,8
+Z,7,11,7,6,4,8,6,2,8,11,6,9,3,9,5,8
+F,3,3,4,4,1,2,12,5,5,12,10,8,0,8,2,6
+A,3,4,5,3,2,10,1,3,2,10,2,10,2,6,3,8
+S,4,11,5,8,5,8,7,8,5,7,6,8,2,8,8,8
+W,9,10,9,5,4,3,10,3,2,10,11,8,9,12,1,6
+W,4,6,5,4,4,4,10,3,2,9,8,7,6,11,1,7
+I,1,2,1,4,1,7,7,1,7,7,6,9,0,8,3,8
+W,8,12,8,6,6,9,9,4,4,6,9,6,10,9,3,6
+S,4,9,5,6,3,10,6,3,6,10,4,8,2,9,5,10
+E,4,8,6,6,4,7,7,3,8,11,7,9,3,8,5,8
+A,3,7,5,5,2,9,3,3,3,7,2,8,3,6,3,8
+Z,4,11,5,8,6,6,8,5,8,8,8,9,1,10,7,8
+S,5,9,5,5,2,10,5,4,4,13,5,8,2,9,2,8
+B,2,3,3,2,2,8,8,5,6,7,5,5,2,8,7,8
+I,1,4,2,2,1,7,7,1,7,13,6,8,0,8,1,8
+U,3,5,4,3,2,5,8,5,7,10,9,9,3,9,2,6
+Q,6,9,7,11,7,8,7,7,4,9,7,9,3,8,6,8
+J,3,11,4,9,3,9,7,2,7,11,3,7,1,6,2,6
+Y,2,6,4,4,1,7,9,2,2,7,12,8,2,11,0,8
+H,3,6,4,4,5,9,9,4,3,6,7,7,6,9,5,6
+P,5,9,6,6,3,5,10,10,5,8,5,5,2,10,4,8
+S,5,11,7,8,7,8,7,7,5,6,6,8,3,8,9,7
+N,5,8,7,6,4,6,9,2,4,9,8,8,6,7,2,7
+I,4,7,6,8,6,8,9,4,5,7,7,9,3,6,8,7
+G,4,5,5,3,3,7,6,6,7,7,6,10,2,9,3,8
+D,5,9,7,6,6,8,7,5,6,10,6,5,3,8,4,9
+W,3,4,5,3,3,9,11,3,2,5,9,8,6,11,1,8
+A,5,10,5,5,3,11,4,4,2,11,3,10,6,4,4,10
+Y,9,13,8,7,5,8,7,4,6,9,5,5,4,9,6,5
+E,2,5,4,3,2,6,8,2,7,11,7,9,2,8,4,8
+Z,4,10,5,7,4,7,8,6,11,7,6,9,1,9,8,7
+V,4,8,6,6,7,7,7,4,1,8,7,9,7,10,4,8
+O,4,8,4,6,4,6,8,7,4,9,8,8,3,8,2,7
+E,3,7,4,5,5,6,8,3,5,6,7,11,4,11,8,8
+R,3,10,4,7,3,6,9,10,5,7,5,8,3,8,5,11
+Q,4,6,5,7,5,9,9,6,2,4,7,11,3,9,6,10
+F,4,9,5,6,3,8,9,2,6,14,5,4,2,10,3,8
+V,4,7,4,5,2,3,12,5,4,12,11,7,3,10,1,8
+G,7,10,7,7,5,7,6,7,8,11,6,11,2,11,5,9
+G,5,6,6,6,7,7,9,6,2,7,7,7,9,12,9,7
+K,5,7,8,5,4,7,6,2,7,10,5,10,4,7,5,9
+U,4,5,5,4,3,6,9,5,7,6,10,9,3,9,1,8
+K,6,10,8,7,6,8,7,1,7,10,4,8,4,7,4,8
+Z,8,15,8,8,6,7,7,2,9,12,7,8,6,5,8,5
+I,2,4,3,3,1,7,7,0,7,13,6,8,0,8,1,7
+C,4,7,4,5,2,4,8,6,8,10,9,14,1,8,3,8
+P,5,8,7,10,10,7,8,4,3,7,7,7,6,11,5,6
+R,4,9,6,6,4,9,7,4,6,9,4,7,3,7,5,10
+O,3,3,4,4,2,7,7,8,6,7,6,8,3,8,4,8
+B,4,8,6,6,8,8,7,5,3,7,7,7,6,10,8,9
+K,2,1,3,2,2,5,7,4,6,6,6,10,3,8,4,9
+O,2,4,3,2,2,7,7,7,5,7,6,8,2,8,3,8
+V,4,11,6,8,2,7,8,4,3,7,14,8,3,9,0,8
+A,2,3,4,2,2,7,2,1,2,7,2,8,2,7,2,7
+H,3,4,3,5,2,7,9,14,3,7,3,8,3,8,0,8
+G,5,10,6,7,5,6,5,6,7,6,6,10,3,9,4,7
+F,3,6,4,4,4,6,9,5,4,8,6,8,2,9,7,12
+B,2,2,3,3,2,7,7,5,5,6,6,6,2,8,6,10
+P,4,7,5,5,3,10,7,3,5,12,4,5,2,9,3,9
+S,8,14,8,8,4,11,4,3,3,12,6,9,3,10,3,9
+G,3,7,4,5,2,6,6,6,6,10,8,11,2,10,4,9
+E,4,9,4,7,4,2,7,5,8,7,6,14,0,8,6,9
+S,4,7,5,5,2,8,7,5,9,5,6,8,0,8,9,8
+U,5,10,5,8,4,7,5,14,5,7,11,8,3,9,0,8
+X,7,11,11,8,5,7,7,1,9,10,6,8,3,8,4,7
+I,2,10,2,8,2,7,7,0,8,7,6,8,0,8,3,8
+T,8,11,8,8,5,7,11,4,8,12,9,4,2,12,4,4
+X,3,9,5,7,4,8,7,3,8,6,7,8,3,8,7,9
+D,3,10,5,8,9,9,9,4,4,7,6,6,4,8,7,5
+E,3,8,5,6,5,7,7,3,5,6,7,10,4,10,8,8
+W,4,6,6,4,2,7,8,4,1,7,8,8,8,9,0,8
+U,5,6,5,4,2,4,9,5,7,12,11,8,3,9,1,6
+D,5,4,5,6,3,5,7,10,9,6,6,5,3,8,4,8
+T,2,3,3,1,1,5,11,1,7,11,9,5,0,9,2,5
+S,3,6,5,5,5,9,8,5,5,7,6,8,5,8,9,11
+Y,6,11,6,8,3,2,11,4,5,12,12,7,2,11,2,6
+N,2,1,2,2,1,7,7,11,1,5,6,8,4,8,0,8
+S,6,9,5,4,2,11,2,2,5,10,2,9,2,8,3,11
+H,4,11,5,8,3,7,7,15,1,7,7,8,3,8,0,8
+S,4,7,5,5,5,9,6,4,3,8,5,8,3,9,9,9
+G,4,11,5,9,3,8,8,9,7,5,7,9,2,7,5,11
+G,4,6,6,4,3,6,6,5,7,6,5,9,3,9,4,8
+S,10,15,10,8,5,8,6,4,6,13,6,8,4,7,4,8
+H,6,11,6,8,6,7,9,14,2,7,4,8,3,8,0,8
+C,3,10,4,8,3,5,8,7,8,7,8,14,1,8,4,10
+A,2,1,3,1,1,7,4,2,0,7,2,8,3,6,1,8
+Q,6,11,5,6,3,10,3,4,6,10,3,9,3,8,6,13
+I,2,7,3,5,1,7,5,0,7,14,7,10,0,7,1,8
+A,2,4,4,3,2,7,2,2,2,5,2,8,2,5,2,7
+Q,3,5,5,4,3,6,4,4,4,5,4,7,3,5,5,7
+N,7,10,9,8,10,6,8,3,4,8,7,8,8,10,7,4
+H,5,6,8,8,6,9,11,4,2,8,7,6,3,10,8,6
+K,7,12,7,7,5,8,7,2,6,10,4,8,5,8,4,8
+Y,3,8,5,6,3,10,10,1,6,3,11,8,1,11,2,9
+Q,6,9,8,8,7,5,4,4,4,4,3,7,4,8,6,5
+V,4,9,6,7,3,6,12,3,4,8,12,8,3,10,1,9
+S,7,11,5,6,3,7,3,2,5,7,2,7,3,7,5,9
+B,5,7,7,5,5,10,6,3,7,11,3,6,4,6,6,11
+U,2,0,2,1,0,8,5,11,4,7,13,8,3,10,0,8
+K,8,10,8,6,3,4,7,5,7,9,12,12,6,11,3,6
+F,6,9,9,7,9,6,8,1,5,10,8,7,8,9,4,6
+G,6,10,7,7,5,5,7,6,5,9,8,11,2,8,4,10
+Q,3,4,4,5,3,8,8,6,2,8,6,9,2,9,3,8
+F,4,7,5,8,6,7,9,5,4,8,6,7,4,9,8,7
+H,8,14,7,8,4,8,8,4,6,8,5,6,6,8,5,8
+I,3,10,4,8,3,6,8,0,7,13,7,8,0,8,1,7
+F,7,10,9,8,6,9,8,2,6,13,5,5,5,9,4,9
+L,1,0,1,1,0,1,1,5,5,0,1,6,0,8,0,8
+P,4,4,6,6,6,9,11,2,3,7,9,6,4,10,5,5
+Z,3,10,4,8,5,8,7,5,9,7,5,7,1,7,7,8
+P,5,8,6,10,9,8,9,3,2,6,8,7,6,10,6,4
+M,3,5,5,3,4,7,6,3,4,9,7,8,7,6,1,8
+V,8,11,7,8,5,3,11,1,3,8,10,7,6,11,2,7
+Y,4,5,5,4,2,4,12,3,6,12,10,4,1,11,2,5
+X,3,4,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+V,1,0,2,1,0,8,9,3,2,6,12,8,2,10,0,8
+J,2,5,4,4,2,10,6,2,6,12,4,9,1,6,1,7
+O,2,3,2,2,1,7,7,6,3,8,6,8,2,8,2,7
+M,5,6,7,4,5,9,6,2,4,9,6,7,7,6,2,7
+V,5,5,6,4,2,4,12,3,3,10,11,7,2,10,1,8
+Q,5,8,7,7,5,7,4,4,4,5,3,8,3,7,5,8
+N,3,7,4,5,2,7,7,14,2,5,6,8,5,8,0,8
+L,4,7,5,5,3,7,4,1,7,8,2,9,1,6,2,8
+X,7,13,7,7,4,7,7,2,9,9,5,8,4,7,4,8
+E,6,11,9,8,5,5,9,3,11,11,8,8,2,8,5,5
+A,4,10,7,7,6,10,5,2,5,10,2,5,3,6,6,8
+L,2,7,4,5,2,6,4,3,8,6,1,7,1,6,2,7
+Z,2,3,4,2,1,7,7,2,9,11,6,8,1,8,5,7
+O,3,9,4,6,4,7,7,8,6,7,7,8,2,8,3,7
+Y,7,13,6,7,4,8,7,4,6,9,6,5,3,9,5,5
+K,5,9,7,7,5,6,7,5,8,6,5,10,3,8,5,9
+C,2,4,3,3,1,4,8,4,6,11,9,11,1,9,3,7
+X,4,8,4,6,3,7,7,4,4,7,6,8,3,8,4,8
+M,5,7,7,6,8,6,8,5,3,6,5,8,10,8,5,7
+C,3,7,4,5,2,4,8,7,7,7,8,14,1,8,4,10
+J,2,6,2,4,1,11,3,10,3,12,8,13,1,6,0,8
+H,4,9,5,7,4,7,7,13,1,7,6,8,3,8,0,8
+S,5,8,7,6,3,5,9,3,9,11,7,6,2,7,5,5
+H,3,6,5,4,4,6,7,5,5,7,5,8,3,7,6,12
+F,4,8,5,6,5,7,9,3,6,9,9,6,5,10,3,7
+T,9,12,7,7,3,7,8,4,9,13,6,8,2,7,5,6
+B,6,9,5,5,3,7,8,5,6,10,5,9,6,6,6,9
+U,6,10,7,8,4,5,7,6,8,9,7,9,4,9,3,3
+N,7,9,9,8,10,8,7,6,5,7,6,7,9,9,8,0
+K,5,6,5,9,2,3,6,8,2,7,7,12,3,8,3,11
+D,3,4,4,6,2,5,7,10,8,7,6,5,3,8,4,8
+B,5,10,5,8,4,7,8,9,7,7,5,6,2,8,9,10
+R,4,9,4,7,5,6,9,8,3,7,4,8,2,7,5,11
+Q,5,9,6,8,3,9,6,9,8,7,4,9,3,8,4,8
+N,3,7,4,5,3,7,8,6,5,7,6,7,5,8,1,6
+V,4,10,7,8,2,7,8,4,3,7,14,8,3,9,0,8
+C,0,0,1,0,0,6,7,5,6,7,6,13,0,8,3,10
+W,8,8,10,7,12,7,7,5,5,6,6,8,10,9,9,8
+M,1,1,2,1,1,8,6,10,0,6,8,8,6,6,0,8
+G,1,3,2,1,1,7,7,5,5,6,6,9,2,8,3,9
+T,3,11,4,8,1,6,14,0,6,8,11,8,0,8,0,8
+I,2,5,3,3,1,7,7,0,7,13,6,8,0,8,1,7
+C,5,9,7,7,8,7,5,4,3,7,7,11,8,9,4,7
+U,4,3,4,4,1,7,5,13,5,7,14,8,3,9,0,8
+H,8,11,11,8,7,7,6,3,7,10,5,8,5,6,5,7
+D,4,6,4,4,2,5,8,9,8,8,7,5,3,8,4,8
+L,4,8,6,6,4,8,4,1,8,9,3,10,1,6,3,9
+D,2,3,4,2,2,9,6,4,6,10,4,6,2,8,3,8
+X,1,0,1,0,0,8,7,3,5,7,6,8,2,8,3,7
+U,5,9,4,4,2,6,6,4,5,4,8,7,5,8,2,6
+D,4,4,5,6,3,6,8,10,9,8,7,6,3,8,4,8
+P,2,7,3,4,1,3,13,8,2,11,7,3,0,9,3,8
+B,3,4,5,3,4,7,8,3,5,10,6,6,2,8,5,8
+M,4,8,4,6,5,8,6,10,1,6,8,8,7,5,0,7
+F,5,9,7,7,4,4,11,1,5,13,7,5,1,10,1,7
+G,4,11,5,8,5,7,7,8,6,5,7,9,2,7,6,10
+X,5,10,7,8,4,10,7,1,8,10,2,6,3,9,4,10
+I,4,10,5,8,2,7,7,0,9,14,6,8,0,8,1,8
+B,3,6,5,4,4,7,9,4,5,9,6,6,2,8,5,6
+Z,2,5,4,6,4,9,6,5,4,7,3,6,2,7,7,6
+J,3,8,5,6,2,8,5,4,5,14,7,12,1,6,0,7
+D,3,8,5,6,4,8,7,7,6,6,5,3,3,8,3,6
+U,3,8,5,6,7,8,5,4,3,7,7,8,7,8,4,7
+H,3,2,4,4,3,8,7,6,6,7,6,8,3,8,3,8
+E,2,7,2,5,3,3,6,4,8,6,6,13,0,8,6,10
+Z,2,1,2,2,1,7,7,3,12,8,6,8,0,8,7,8
+T,2,4,3,5,1,7,14,0,6,7,11,8,0,8,0,8
+Q,2,2,2,3,2,7,8,4,2,8,8,9,2,9,4,8
+K,6,11,7,6,4,11,7,2,6,10,3,6,5,10,3,10
+R,4,8,6,6,4,10,7,4,7,10,1,7,3,6,4,11
+G,4,7,4,5,3,5,7,5,4,8,7,11,2,8,4,10
+S,3,4,3,3,2,8,8,6,5,7,6,7,2,8,9,8
+Z,4,5,6,7,5,11,5,3,5,9,3,7,2,7,6,9
+Q,1,0,1,0,0,8,8,6,3,6,6,9,2,8,3,8
+U,5,10,6,8,2,7,5,13,6,8,15,8,3,9,0,8
+K,6,9,8,7,6,6,6,1,7,10,7,10,3,8,4,8
+V,2,3,3,2,1,5,12,2,2,8,10,7,2,11,0,8
+C,3,4,4,3,1,4,8,5,7,11,9,12,1,9,2,7
+A,5,10,7,8,5,7,3,2,3,4,2,7,2,6,2,6
+Q,5,6,8,6,6,8,4,4,4,7,4,10,6,6,7,7
+T,6,13,5,7,3,8,7,3,7,11,5,7,2,9,5,6
+J,1,2,2,3,1,10,6,2,6,12,4,8,1,6,1,7
+R,2,3,4,2,2,8,7,3,4,9,4,7,2,7,3,10
+R,4,8,5,6,3,6,10,9,4,7,5,8,3,8,6,11
+C,3,7,4,5,2,7,7,7,10,8,6,14,1,9,4,9
+I,3,8,4,6,2,7,7,0,7,13,6,8,0,8,1,8
+Z,4,9,6,6,3,7,8,2,10,11,7,9,1,9,6,8
+K,3,4,5,3,2,6,6,1,7,10,7,10,3,7,3,8
+F,5,11,6,8,6,5,10,5,6,10,10,6,2,9,3,5
+P,3,5,3,4,2,5,10,5,4,10,8,4,1,10,3,7
+B,6,9,8,6,8,7,8,5,5,7,5,7,4,9,6,7
+L,4,11,5,8,4,7,4,1,7,8,2,10,1,5,3,8
+P,2,7,3,4,1,4,12,8,2,10,6,3,1,10,3,8
+F,5,8,6,6,6,7,8,6,4,8,6,8,3,11,8,11
+X,5,10,8,8,6,10,7,3,7,7,6,6,6,12,8,9
+R,2,4,4,3,2,8,7,3,5,10,4,7,2,7,3,10
+U,4,5,5,4,2,4,8,5,7,11,10,9,3,9,2,7
+K,3,5,4,3,3,5,7,4,7,6,6,11,3,8,4,10
+D,1,0,1,0,0,6,7,6,4,7,6,6,2,8,2,8
+V,5,10,7,7,4,5,10,3,2,9,11,7,4,9,5,8
+B,3,9,4,7,3,6,6,9,7,6,7,7,2,8,9,10
+X,1,1,2,1,0,8,7,3,4,7,6,8,2,8,4,8
+P,6,6,6,8,3,5,10,10,6,8,6,5,2,10,4,8
+R,4,7,4,4,2,6,11,8,3,7,4,8,3,7,6,11
+U,3,9,4,7,2,7,6,14,5,8,13,7,3,9,0,8
+W,7,8,7,6,6,2,10,2,3,10,10,8,7,11,2,7
+R,3,4,5,3,3,8,7,4,5,9,4,7,2,7,4,10
+A,5,10,7,8,8,8,7,8,4,6,6,8,3,8,8,3
+Q,5,9,5,4,3,10,5,4,6,11,4,8,3,8,7,11
+B,6,6,6,8,5,6,6,9,7,6,6,7,3,8,10,10
+E,2,5,3,4,3,7,7,6,7,7,6,9,2,8,6,10
+L,5,6,6,6,5,8,9,3,6,6,6,9,3,9,7,9
+N,5,8,8,6,4,10,7,3,5,10,2,4,5,9,1,7
+D,3,7,5,5,6,8,8,5,4,7,6,6,6,8,7,6
+J,2,5,5,3,2,9,5,4,5,14,6,12,1,6,0,7
+T,1,1,2,2,1,7,12,3,6,7,10,9,1,11,1,8
+F,3,3,4,4,1,2,13,5,4,12,10,6,0,8,2,6
+E,3,6,4,4,3,8,7,2,6,11,6,9,3,8,4,10
+I,0,7,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+D,3,3,4,2,2,7,7,6,7,7,6,5,2,8,3,7
+U,5,10,8,8,11,9,6,4,4,7,7,7,8,8,5,7
+T,2,3,3,2,1,6,11,4,5,8,10,7,2,11,1,7
+F,3,8,3,5,1,1,13,5,3,12,10,6,0,8,2,6
+K,7,10,10,7,7,4,8,1,7,9,8,11,3,8,3,6
+T,5,10,7,8,8,8,8,5,6,6,7,9,7,7,8,3
+S,4,11,5,8,5,7,7,6,8,5,6,11,1,11,10,9
+M,3,7,4,5,3,7,7,11,1,7,9,8,8,5,0,8
+H,9,15,9,8,7,4,10,3,5,10,8,10,5,8,4,6
+Z,4,5,6,7,5,10,5,3,5,7,3,6,3,7,6,7
+Y,2,7,4,5,2,7,10,2,2,7,11,8,1,11,0,8
+N,3,4,5,3,2,6,9,2,4,10,7,7,5,8,1,8
+K,4,10,6,8,6,5,6,3,7,6,6,10,4,7,7,11
+J,5,7,6,5,4,8,6,8,6,7,7,8,2,7,4,6
+M,7,9,10,7,6,8,6,2,5,9,6,8,10,8,3,8
+G,4,9,6,7,6,7,5,6,3,8,6,11,4,8,7,8
+Z,4,7,4,5,2,7,7,4,14,9,6,8,0,8,8,8
+I,2,8,3,6,2,7,7,0,8,13,6,8,0,8,1,7
+U,9,11,10,8,4,3,9,6,9,12,12,9,3,9,2,7
+J,3,7,5,5,5,10,8,3,4,8,4,6,4,8,6,5
+I,2,6,2,4,1,5,8,0,7,13,7,8,0,8,1,7
+T,2,3,3,2,1,5,11,3,6,11,9,5,1,11,1,5
+R,5,9,7,7,5,10,6,3,6,10,3,7,4,6,5,10
+K,3,3,4,5,1,3,7,7,2,7,6,11,3,8,2,10
+D,7,10,7,5,3,10,4,4,5,11,3,8,5,7,5,11
+F,1,0,1,0,0,3,11,4,3,11,9,7,0,8,2,8
+Q,3,4,4,5,4,8,7,6,3,8,8,9,3,8,4,8
+R,2,3,3,1,2,8,8,3,5,9,4,7,2,6,3,10
+G,3,4,4,2,2,6,7,5,5,9,7,10,2,8,4,9
+H,3,7,5,5,6,9,8,4,3,6,7,8,7,8,7,7
+L,9,15,7,8,4,7,4,3,6,11,3,12,2,7,6,7
+L,7,13,7,7,4,8,4,3,4,11,8,12,3,10,5,10
+U,4,8,6,6,7,9,6,5,5,6,7,6,6,8,5,6
+I,1,8,2,6,2,7,7,0,7,7,6,8,0,8,2,8
+D,4,11,6,8,4,8,8,8,8,8,7,2,3,7,4,8
+P,4,6,6,9,8,6,13,5,1,10,8,5,4,11,4,9
+Z,6,7,5,10,4,8,5,5,4,11,6,7,3,9,10,7
+J,4,8,3,12,3,8,7,3,3,11,4,5,3,8,6,10
+W,6,8,6,6,4,2,10,2,3,11,11,9,6,10,2,6
+N,5,9,8,7,4,3,10,3,4,10,10,9,5,8,1,7
+G,9,15,8,8,5,10,3,3,3,9,3,6,4,7,5,9
+D,3,7,4,5,4,6,7,9,7,8,8,6,2,9,3,8
+O,2,4,3,2,2,8,7,7,4,7,6,8,2,8,2,8
+U,4,5,5,4,3,6,8,6,7,7,9,10,3,9,1,8
+G,6,11,7,8,6,7,7,8,7,6,5,10,2,7,5,11
+R,1,1,2,1,1,6,9,7,3,7,5,8,2,7,4,10
+G,2,1,3,2,2,7,6,6,5,6,6,9,2,9,4,9
+X,8,13,7,7,4,8,8,2,9,9,6,7,4,10,4,8
+M,3,6,4,4,4,7,5,10,0,7,8,8,6,5,0,8
+U,4,2,5,3,2,7,8,6,8,7,10,9,3,9,1,8
+E,1,3,3,2,1,7,7,2,6,11,6,9,1,8,4,9
+M,4,7,6,5,4,6,6,7,5,7,8,11,8,5,2,9
+A,3,9,5,7,4,6,4,3,1,6,1,8,2,6,2,7
+G,4,9,5,7,4,5,7,6,5,10,8,11,2,9,4,10
+P,5,8,7,6,6,8,5,7,5,7,6,6,4,8,6,10
+F,3,5,6,4,2,6,11,2,6,13,7,4,1,10,2,7
+I,1,6,0,4,1,7,7,5,3,7,6,8,0,8,0,8
+R,3,2,4,3,3,7,7,5,5,6,5,6,3,7,4,8
+K,5,9,5,6,2,4,7,9,2,7,5,11,4,8,2,11
+W,5,8,8,6,5,9,11,2,3,5,9,7,10,13,1,6
+S,3,3,4,4,2,7,6,5,9,5,6,9,0,9,9,8
+C,4,10,5,8,3,5,8,7,8,7,8,15,1,8,4,9
+N,7,11,9,6,4,5,8,2,4,12,7,9,6,8,0,7
+P,5,6,5,8,3,3,14,8,1,11,7,2,0,10,4,8
+P,5,9,7,7,4,9,8,3,5,12,4,4,2,9,4,8
+N,4,9,6,7,7,9,7,4,4,7,6,6,5,10,6,5
+Y,8,8,7,12,5,5,5,7,4,6,12,6,5,10,4,8
+J,6,9,8,7,5,9,4,7,6,8,6,5,2,7,4,6
+M,7,7,10,6,10,6,9,5,3,7,5,8,12,5,6,8
+A,6,9,9,8,8,8,8,3,5,7,7,8,5,8,4,5
+S,9,15,7,8,4,9,2,2,5,8,1,8,3,7,5,10
+Z,8,13,9,7,6,5,9,2,9,12,8,8,6,5,8,2
+O,3,7,5,5,3,7,7,8,5,6,5,6,3,8,3,8
+R,3,8,4,6,2,5,11,8,4,7,3,9,3,7,6,11
+I,1,7,0,5,1,7,7,5,3,7,6,8,0,8,0,8
+U,1,0,2,0,0,7,6,10,4,7,13,8,2,10,0,8
+K,10,12,9,6,4,5,9,3,8,9,7,9,6,6,3,6
+E,5,10,7,7,7,8,9,6,3,6,6,9,4,7,7,9
+F,5,11,5,8,4,1,12,4,5,12,11,8,0,8,1,6
+J,2,2,3,3,1,10,6,2,6,12,4,9,0,7,1,7
+Z,4,6,6,4,3,6,9,3,9,11,9,6,1,9,6,5
+I,3,6,5,7,4,8,8,4,5,7,6,8,3,8,8,8
+U,1,0,1,0,0,8,7,9,3,7,11,8,2,10,0,8
+Q,9,14,8,8,5,7,5,4,9,10,4,9,3,7,9,9
+V,8,10,8,8,5,3,12,2,3,9,11,8,4,12,2,7
+E,6,11,8,8,6,8,7,3,9,12,6,9,2,9,5,8
+L,5,5,6,8,2,0,0,7,6,0,1,4,0,8,0,8
+B,3,7,4,5,4,6,7,8,5,7,6,7,2,8,7,9
+O,6,11,6,8,5,8,6,8,5,10,5,8,3,8,3,7
+X,5,10,7,7,6,7,6,3,5,6,6,8,3,9,9,9
+X,6,11,6,6,3,11,7,3,8,10,3,6,4,11,4,10
+J,4,11,5,9,3,7,8,2,7,15,5,8,1,6,1,7
+N,5,6,8,4,4,8,8,2,5,10,4,6,5,9,1,7
+K,6,10,8,8,5,6,6,2,7,10,6,10,4,8,4,8
+U,7,15,6,8,5,7,6,4,5,7,7,8,5,7,3,7
+A,3,3,5,4,1,7,5,3,0,7,1,8,2,7,2,8
+Z,3,10,4,8,4,7,7,6,10,6,6,8,1,8,8,8
+A,5,10,5,6,3,10,2,4,2,11,6,13,5,4,5,10
+O,4,8,4,6,4,8,7,8,3,10,6,8,3,8,3,8
+P,7,8,9,10,11,8,8,3,3,7,8,7,7,11,7,7
+A,1,1,2,1,0,7,4,2,0,7,2,8,2,7,1,8
+G,4,11,6,8,6,7,6,7,5,4,7,9,3,6,5,9
+M,6,9,8,7,6,8,6,2,5,9,6,8,8,6,2,8
+V,5,6,5,4,2,3,12,3,3,10,11,8,2,11,1,8
+J,3,7,4,5,4,9,8,3,4,9,4,7,4,8,6,5
+A,3,8,4,6,3,11,3,2,2,9,1,8,2,6,3,8
+F,5,11,5,8,2,1,11,5,7,11,11,9,0,8,2,6
+J,4,9,6,7,6,9,8,4,4,8,5,6,4,8,6,4
+U,5,7,5,5,2,4,9,5,8,12,10,8,3,9,1,6
+G,6,10,7,8,6,7,7,8,7,6,6,9,2,7,5,11
+D,3,7,4,5,3,8,7,6,6,10,4,5,3,8,3,7
+H,4,4,6,6,4,9,8,3,1,7,6,8,4,9,9,7
+I,4,9,5,7,3,9,6,0,7,13,5,8,0,8,1,8
+E,3,5,6,3,3,7,7,2,8,12,7,9,2,9,4,8
+K,4,6,6,5,5,8,7,2,3,8,3,8,4,5,6,10
+L,4,9,5,7,3,4,4,5,10,2,0,6,0,6,2,5
+L,1,0,2,1,0,2,1,6,5,0,2,4,0,8,0,8
+P,5,5,6,7,7,8,8,3,2,7,8,7,5,10,5,5
+X,4,11,6,8,4,8,7,4,9,6,6,6,3,8,7,7
+M,3,4,4,3,3,8,6,6,4,6,7,8,7,6,2,8
+L,3,6,3,4,1,1,0,6,6,0,1,5,0,8,0,8
+T,4,5,5,3,2,6,11,2,8,11,9,5,4,10,4,4
+S,6,11,6,6,3,9,5,4,4,13,6,9,3,10,3,8
+N,6,11,8,8,5,7,9,6,5,7,7,8,6,9,1,7
+E,5,9,7,7,5,10,6,2,9,11,4,8,2,8,5,12
+C,5,7,6,5,6,8,4,6,3,8,6,11,8,8,4,7
+Q,9,14,8,8,5,7,4,4,8,9,5,9,3,8,9,9
+Y,5,8,7,12,11,8,8,4,2,7,8,9,4,11,8,8
+G,2,2,3,4,2,7,6,6,5,6,6,9,2,9,4,9
+M,4,9,5,7,6,7,5,10,1,7,8,8,6,5,0,8
+D,3,2,4,3,3,7,7,6,7,6,6,5,2,8,3,7
+K,2,3,4,2,2,5,8,2,6,10,8,10,3,8,2,8
+W,2,3,4,2,2,8,11,3,1,6,8,8,6,12,0,7
+P,3,3,3,2,2,5,10,4,4,10,8,4,1,10,3,7
+H,5,10,8,8,5,8,8,3,7,10,6,7,3,8,3,8
+C,5,9,6,7,2,6,7,7,12,7,6,15,1,8,4,9
+S,6,9,7,6,4,8,7,4,8,11,6,8,2,9,5,8
+Q,1,2,2,3,1,7,8,4,1,7,8,10,1,9,3,8
+I,2,8,3,6,2,7,7,0,7,13,6,8,0,8,1,8
+L,3,7,5,5,5,7,8,3,4,6,6,9,5,11,7,5
+I,3,9,4,6,2,7,7,0,8,14,6,9,0,8,1,8
+F,5,7,6,9,7,7,9,5,5,8,6,8,3,9,7,6
+A,4,10,7,7,3,12,3,4,3,11,1,9,2,7,3,9
+N,2,4,4,3,2,7,9,2,4,10,6,7,5,9,0,7
+J,2,7,4,5,3,10,6,2,5,8,4,5,3,8,6,7
+L,3,6,5,5,4,7,8,3,5,7,6,8,3,9,7,11
+U,7,13,6,7,5,9,6,5,6,6,7,6,5,8,4,6
+O,3,6,4,4,3,7,8,6,4,10,7,6,3,9,3,8
+P,8,11,6,6,3,8,7,5,4,11,4,6,5,8,4,8
+N,4,5,6,5,5,7,8,5,3,6,5,8,6,8,4,7
+P,7,11,9,8,5,6,11,4,6,14,6,2,0,10,3,9
+W,4,5,7,4,4,7,11,2,2,6,9,8,7,11,0,8
+O,4,9,5,7,4,7,7,8,5,10,6,7,3,8,3,8
+F,3,2,4,3,2,5,10,4,6,11,9,5,1,10,3,6
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+R,3,7,4,5,4,7,8,5,6,6,5,7,3,7,5,8
+D,2,4,4,3,2,9,6,3,5,10,4,6,3,7,3,8
+W,3,8,5,6,4,5,10,2,3,8,9,9,7,11,1,7
+M,5,9,8,7,8,5,7,3,4,9,9,9,7,5,2,7
+P,10,13,8,8,4,7,10,6,3,12,4,4,5,10,4,8
+T,2,9,3,6,1,9,14,0,6,6,11,8,0,8,0,8
+P,4,8,5,6,3,7,10,2,7,14,6,4,0,10,2,9
+A,2,4,3,3,1,10,2,2,1,8,2,9,1,6,1,8
+Y,3,5,5,8,6,7,10,3,2,7,8,9,3,11,8,5
+F,3,7,4,5,3,5,11,4,6,11,10,4,2,10,2,5
+P,9,14,9,8,6,10,8,4,4,12,4,4,5,10,5,8
+G,4,8,6,6,5,7,6,6,4,7,7,9,5,9,7,8
+U,3,7,4,5,1,7,5,13,5,7,13,8,3,9,0,8
+S,3,5,5,4,2,8,7,3,7,10,6,7,1,9,5,8
+Y,2,6,4,4,1,6,10,3,2,7,13,8,2,11,0,8
+P,6,10,6,8,6,4,11,8,3,9,6,5,1,10,3,8
+U,7,11,6,6,4,6,5,5,4,7,9,10,6,7,3,10
+A,3,10,5,7,2,6,6,3,1,6,0,8,2,7,1,7
+H,4,2,5,4,4,7,8,6,6,7,6,8,3,8,3,8
+R,2,4,3,3,2,8,7,4,5,9,4,7,2,7,3,10
+R,3,4,5,2,3,9,8,3,5,9,4,6,2,6,4,10
+X,6,10,9,8,5,3,9,2,8,11,12,10,3,9,3,5
+J,1,3,2,5,1,11,3,9,3,13,7,13,1,6,0,8
+S,2,3,4,2,2,8,8,2,6,10,6,7,1,9,5,8
+N,3,8,3,6,3,7,7,12,1,6,6,8,5,8,0,8
+Y,5,6,8,9,10,8,8,4,2,7,8,9,6,12,8,8
+A,3,5,5,3,2,11,2,3,2,10,2,9,2,6,2,8
+D,8,14,7,8,6,7,7,4,7,10,6,7,6,7,8,4
+U,6,10,9,7,6,6,7,7,6,6,6,12,6,8,8,2
+L,4,8,5,7,4,6,7,4,6,7,6,8,3,9,8,10
+F,3,7,4,4,1,2,13,5,3,12,9,6,0,8,2,6
+G,4,7,4,5,2,7,6,6,6,11,6,12,2,10,4,10
+F,2,3,4,2,1,6,10,2,5,13,6,4,1,9,1,7
+V,7,10,7,7,3,3,11,3,4,9,11,8,4,12,1,7
+P,4,7,4,5,2,4,12,8,2,10,6,4,1,10,4,8
+S,5,10,6,7,4,6,8,3,6,10,7,7,3,7,5,6
+F,3,1,3,2,2,5,10,4,5,11,9,5,1,10,3,6
+T,3,5,4,4,2,6,12,3,6,7,11,9,2,11,1,8
+C,2,4,3,3,1,4,9,5,7,11,9,12,1,9,2,7
+K,3,3,4,5,2,3,6,7,3,7,7,12,3,8,3,10
+G,3,3,4,4,2,7,8,7,6,6,6,7,2,7,6,11
+H,5,10,8,8,5,8,5,3,6,9,5,8,4,7,4,8
+W,2,0,2,1,1,7,8,4,0,7,8,8,6,10,0,8
+O,6,10,7,8,7,7,8,9,4,7,7,8,3,7,3,7
+V,4,8,6,6,3,6,12,3,3,6,12,9,3,10,1,8
+L,3,5,4,4,2,4,4,4,8,2,1,7,0,7,1,6
+I,2,6,3,4,2,7,7,0,6,13,6,8,0,8,1,8
+B,1,3,3,2,2,7,8,2,4,10,6,6,2,8,4,8
+J,6,10,7,8,3,10,6,2,9,15,3,8,0,7,0,8
+V,7,12,6,6,4,8,9,3,3,8,8,5,5,12,2,8
+V,3,10,5,8,2,7,8,4,3,7,14,8,3,10,0,8
+B,4,7,6,5,4,9,7,3,7,10,4,7,2,8,5,11
+P,4,7,6,5,3,9,8,3,5,13,4,4,1,10,3,9
+T,2,7,3,4,1,7,13,0,6,7,11,8,0,8,0,8
+B,3,8,5,6,5,8,8,5,4,7,5,5,3,8,6,5
+Y,8,11,7,6,4,7,8,4,6,10,6,4,4,10,5,5
+Z,7,11,9,8,6,6,9,3,10,12,8,6,1,8,6,6
+G,2,3,2,1,1,7,7,5,5,7,6,9,2,9,4,9
+D,2,4,4,3,2,9,6,3,6,10,4,6,3,7,3,8
+F,2,1,2,2,1,5,10,4,5,10,9,6,1,9,3,7
+T,3,3,4,2,1,7,12,2,7,7,11,8,1,11,1,7
+T,3,6,4,4,3,6,12,4,6,8,11,8,2,12,1,8
+P,6,11,8,8,6,6,13,6,3,12,6,2,1,11,3,8
+B,1,0,2,0,1,7,8,6,4,7,6,7,1,8,6,8
+N,5,11,7,8,6,7,6,8,5,6,4,7,4,8,3,7
+S,5,8,6,6,3,7,8,4,9,11,4,7,2,6,4,8
+B,5,10,7,8,6,10,6,3,6,10,4,7,3,7,5,11
+S,5,9,8,6,9,6,7,3,2,8,6,6,3,8,11,1
+C,2,5,3,4,2,6,9,7,8,9,8,13,1,10,4,10
+R,4,9,5,6,7,7,8,3,4,7,6,8,6,9,7,5
+O,3,7,4,5,3,8,7,7,3,9,6,8,3,8,3,8
+R,5,9,8,6,9,7,7,3,4,6,6,9,6,9,7,6
+N,5,9,8,7,5,6,9,5,5,7,7,7,6,9,1,6
+G,4,9,5,7,3,8,8,8,8,6,7,8,2,7,6,11
+W,1,0,2,0,0,7,8,4,0,7,8,8,5,9,0,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+H,4,7,6,5,4,4,9,4,5,10,10,9,3,8,3,5
+Z,4,7,6,5,4,7,9,2,9,11,8,5,1,8,6,5
+G,7,10,7,8,6,5,7,6,5,8,8,11,2,7,5,10
+U,6,9,6,6,3,4,9,5,7,13,11,9,3,9,1,7
+Z,1,0,1,1,0,7,7,2,9,9,6,8,0,8,6,8
+R,4,7,6,5,6,8,6,6,3,8,6,8,4,7,7,10
+D,4,7,6,5,5,7,7,5,6,7,6,8,6,8,3,7
+B,3,3,4,4,3,6,6,8,7,6,6,7,2,8,9,10
+Z,6,9,5,12,5,5,11,3,3,12,8,6,3,8,11,6
+U,5,9,5,6,4,7,5,14,5,7,11,8,3,9,0,8
+T,8,11,8,9,7,6,11,2,8,11,9,5,4,10,4,4
+H,1,0,1,0,0,7,7,10,2,7,6,8,2,8,0,8
+O,6,10,4,5,3,6,8,6,5,9,7,9,5,10,5,8
+E,2,3,4,2,2,6,8,2,8,11,8,9,2,9,4,7
+Y,6,9,6,6,3,2,11,4,6,13,12,6,1,11,2,5
+M,4,2,5,3,3,8,6,6,4,6,7,8,7,6,2,6
+E,5,5,5,8,3,3,8,6,12,7,6,15,0,8,7,6
+A,2,3,4,2,1,11,2,3,1,9,2,9,1,6,2,8
+J,2,8,2,6,1,14,3,6,5,14,0,9,0,7,0,8
+F,5,8,7,6,7,7,9,1,4,10,7,6,5,10,3,5
+X,4,9,5,6,1,7,7,4,4,7,6,8,3,8,4,8
+H,3,8,4,6,3,7,7,12,1,7,6,8,3,8,0,8
+A,1,3,2,2,1,12,2,3,1,11,2,9,2,6,2,8
+X,4,7,5,6,6,9,8,2,5,8,5,6,2,6,7,8
+K,2,1,2,2,2,5,7,3,6,7,6,10,3,8,4,10
+U,4,9,6,6,7,10,7,5,4,6,7,7,7,9,5,5
+T,4,7,4,5,2,6,11,4,5,11,9,4,2,12,2,5
+Z,3,8,4,6,4,9,6,5,9,7,5,6,1,7,7,8
+V,4,4,5,3,2,5,12,2,3,9,11,7,4,11,1,7
+I,1,4,2,3,1,7,7,0,7,13,6,8,0,8,1,8
+F,5,8,8,6,7,7,9,1,4,10,6,6,5,11,3,5
+S,3,4,3,3,2,8,7,7,5,7,6,8,2,8,9,8
+B,3,7,4,5,4,8,7,6,6,7,6,5,2,8,7,9
+J,1,3,2,5,1,15,3,5,5,13,0,9,0,7,0,8
+C,2,1,2,1,1,6,8,6,7,8,8,12,1,9,3,10
+T,3,6,5,8,2,5,15,1,6,9,11,7,0,8,0,8
+M,5,8,7,6,5,8,6,6,6,6,7,6,9,7,3,6
+O,4,9,5,6,3,7,5,9,8,6,4,7,3,8,4,8
+N,3,5,5,3,2,9,7,3,5,10,3,5,5,9,1,7
+N,3,5,6,4,3,7,9,2,5,10,6,6,5,9,1,7
+N,4,6,5,4,3,7,8,6,6,7,7,6,6,9,2,6
+U,5,7,5,5,2,4,8,6,7,9,10,9,3,9,2,5
+P,9,12,7,7,3,6,10,6,4,13,6,4,4,10,4,8
+L,4,8,6,6,4,8,4,1,6,9,2,9,1,6,3,9
+W,4,9,6,7,3,9,8,4,1,7,8,8,8,9,0,8
+L,3,4,3,3,1,4,4,4,8,2,1,6,0,7,1,6
+M,7,8,10,6,7,12,6,3,5,9,2,5,9,6,2,8
+N,2,5,3,3,2,7,8,5,4,7,6,6,5,9,1,6
+O,4,10,5,8,5,8,7,7,4,9,5,6,3,8,3,7
+W,5,7,5,5,5,5,10,3,2,9,8,7,6,11,2,6
+L,1,3,2,1,1,7,5,1,7,8,3,10,0,7,2,9
+F,1,0,1,0,0,3,12,4,2,11,8,6,0,8,2,7
+U,6,7,6,5,3,3,9,6,7,11,11,9,3,9,1,6
+Y,5,10,8,7,4,8,10,1,7,4,11,9,2,12,3,8
+J,1,4,3,3,1,9,6,2,6,14,4,9,0,7,0,7
+Q,7,9,8,11,7,8,5,7,5,9,6,9,3,7,6,8
+K,5,9,7,7,6,5,7,1,6,9,8,10,3,8,3,8
+L,5,10,7,7,4,5,4,3,8,6,2,8,1,6,3,6
+H,8,12,7,6,4,7,8,5,4,9,10,9,7,11,5,9
+R,4,7,6,5,4,7,8,5,7,7,4,7,3,6,5,8
+H,8,11,12,8,10,10,6,3,7,10,3,7,5,7,5,10
+S,6,10,8,8,5,8,8,3,6,10,4,7,2,7,5,9
+L,2,6,2,4,1,0,1,5,6,0,0,7,0,8,0,8
+W,2,0,2,1,1,8,8,4,0,7,8,8,6,9,0,8
+F,1,0,1,0,0,3,11,4,3,11,9,7,0,8,2,8
+T,4,10,6,8,4,9,14,0,5,6,10,8,0,8,0,8
+I,0,8,0,5,0,7,7,4,4,7,6,8,0,8,0,8
+Y,5,6,7,9,9,8,10,4,3,6,8,9,5,13,8,8
+U,4,4,4,3,2,4,8,5,7,10,9,9,3,9,2,6
+K,3,5,5,3,2,5,8,1,7,10,8,10,3,8,3,7
+G,5,10,6,8,6,6,5,7,6,7,5,11,3,10,4,9
+K,5,8,7,7,7,7,7,2,4,8,4,8,6,4,9,11
+B,2,7,3,5,4,6,7,7,5,7,6,7,2,8,6,9
+R,2,0,2,1,1,6,10,7,2,7,5,8,2,7,4,10
+T,6,9,6,7,4,6,11,3,7,11,9,5,1,12,2,4
+F,5,10,7,8,6,4,10,2,6,11,10,6,1,10,3,6
+N,6,9,9,6,5,7,9,2,5,10,5,6,6,9,1,7
+U,5,9,7,8,7,7,6,4,4,6,7,8,4,8,1,8
+U,2,4,3,3,1,7,8,6,6,7,9,8,3,9,1,8
+A,3,4,5,3,2,10,2,3,1,9,2,9,2,6,2,8
+L,3,7,4,5,2,3,4,3,8,2,1,7,0,7,1,5
+V,2,2,4,4,1,8,9,4,2,7,13,8,3,10,0,8
+S,8,13,7,7,3,6,2,3,4,6,2,6,3,7,6,7
+R,5,8,8,6,6,10,7,3,6,10,2,7,5,7,5,10
+M,6,11,9,8,7,7,6,6,6,6,7,7,10,8,3,6
+F,4,8,4,6,3,1,12,3,4,11,10,7,0,8,2,6
+V,5,11,7,9,4,9,9,4,2,5,13,8,3,10,0,8
+I,4,8,5,6,3,8,9,1,7,7,6,7,0,7,4,7
+J,9,14,7,11,6,9,9,2,4,12,4,5,2,9,8,9
+Y,4,11,6,8,1,8,10,3,2,6,13,8,2,11,0,8
+W,2,3,3,1,2,5,10,4,2,9,8,7,5,11,1,6
+Z,1,3,3,2,1,8,7,2,9,11,6,9,1,8,5,7
+Z,7,9,5,13,5,7,8,5,3,11,7,7,3,9,11,6
+R,3,5,5,3,3,8,7,4,5,9,4,7,3,7,3,11
+C,3,4,4,2,1,5,8,5,7,10,8,13,1,9,3,8
+X,3,4,5,3,2,5,8,2,8,10,10,9,3,8,3,5
+R,2,3,3,2,2,7,8,5,5,6,5,7,2,6,5,8
+E,4,8,5,6,6,8,7,4,7,7,5,8,6,8,6,10
+J,1,4,2,3,1,10,6,2,6,12,4,9,0,7,1,7
+M,6,9,7,4,3,12,2,3,2,10,3,9,6,4,1,9
+T,6,10,8,8,9,6,7,4,6,7,7,10,7,7,7,6
+E,4,8,5,6,5,7,7,5,8,6,5,9,3,8,6,9
+Q,4,5,6,7,6,9,12,4,2,4,8,12,4,13,5,12
+N,3,4,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+G,3,1,4,2,2,7,7,5,6,7,6,9,3,7,4,8
+F,2,6,3,4,1,1,13,4,3,12,10,6,0,8,2,6
+K,3,8,4,6,2,3,7,8,3,7,6,11,4,8,3,11
+J,2,7,3,5,1,12,2,9,4,14,5,13,1,6,0,8
+C,3,7,4,5,1,5,7,6,9,6,6,14,1,8,4,9
+W,5,9,7,7,5,7,8,4,1,7,9,8,8,10,0,8
+Y,3,5,5,7,1,7,10,1,3,7,12,8,1,11,0,8
+Q,4,7,5,6,3,9,7,8,6,6,6,10,3,8,5,9
+G,6,8,6,6,4,7,6,6,7,10,6,12,2,10,4,9
+M,14,15,14,8,7,10,11,7,4,4,6,10,10,13,3,6
+D,4,9,6,7,4,9,6,5,7,9,3,6,3,8,3,8
+A,3,8,5,6,3,11,3,3,2,10,2,9,2,7,3,9
+J,2,7,4,5,1,9,6,3,6,15,4,9,0,7,1,7
+M,5,7,7,6,8,5,8,5,4,6,5,9,11,9,4,8
+F,5,9,7,6,4,5,12,2,6,13,7,4,1,10,2,7
+K,4,8,6,6,6,7,7,4,4,7,5,7,4,6,9,10
+M,2,1,3,2,2,7,6,6,4,6,7,7,7,6,2,7
+S,7,9,9,8,9,10,7,4,7,7,6,8,5,9,8,12
+D,7,10,9,8,6,11,5,3,8,11,3,6,4,6,4,9
+E,3,10,5,8,5,7,7,5,8,7,7,10,3,8,6,9
+C,4,9,6,7,6,6,6,3,4,8,7,11,6,9,3,9
+I,5,13,4,8,2,9,6,5,4,12,4,7,3,8,5,10
+T,3,5,4,4,3,9,12,3,6,6,11,8,2,11,1,8
+Z,1,3,2,2,1,8,7,5,8,6,6,7,1,8,7,8
+M,4,9,5,6,5,7,6,10,1,7,8,8,8,4,1,7
+T,10,14,8,8,3,4,12,3,8,12,8,4,2,9,3,4
+Q,2,3,2,3,2,8,8,5,2,5,7,10,2,9,5,9
+H,5,11,8,8,7,8,7,3,6,10,5,8,3,9,4,8
+E,2,4,3,3,2,7,7,5,7,7,6,9,2,8,5,10
+V,4,5,5,4,5,7,7,5,4,6,5,7,6,9,6,11
+Z,1,3,2,2,1,7,7,1,8,11,6,8,1,8,5,8
+W,12,13,12,7,5,2,10,3,3,10,12,8,9,10,0,7
+V,3,2,5,4,2,7,12,2,3,7,11,9,2,10,1,8
+F,4,6,4,8,2,0,12,4,5,12,11,8,0,8,2,6
+T,4,10,5,7,3,5,14,1,5,9,10,7,0,8,0,8
+R,4,9,6,6,5,6,8,6,6,6,4,9,3,6,6,9
+G,5,8,6,6,4,6,6,7,6,6,6,11,2,8,4,9
+L,3,7,3,5,2,0,2,4,5,1,1,7,0,8,0,8
+Y,8,11,8,8,5,3,11,3,7,12,11,6,1,11,2,5
+A,3,6,5,4,1,9,4,3,1,8,1,8,3,6,2,8
+N,1,0,2,1,1,7,7,11,1,5,6,8,4,8,0,8
+M,8,10,12,8,9,4,8,3,5,10,10,10,13,8,5,8
+P,3,6,4,4,2,7,11,7,3,11,5,3,1,10,4,7
+V,8,12,6,7,3,8,10,5,5,8,10,5,5,12,3,7
+V,5,10,5,8,4,3,11,2,3,9,11,8,3,10,1,7
+G,7,10,9,8,9,9,4,6,3,8,5,10,11,6,5,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+F,3,7,4,5,3,7,9,2,5,13,6,5,2,10,2,8
+A,1,0,2,1,0,7,4,2,0,7,2,8,2,7,1,8
+Z,4,5,5,8,2,7,7,4,14,9,6,8,0,8,8,8
+V,8,10,8,8,3,4,12,5,5,12,12,7,3,9,2,8
+O,1,1,2,2,1,7,7,6,4,7,6,8,2,8,2,8
+S,7,13,6,7,3,10,3,3,5,10,1,9,3,6,5,10
+Z,4,10,6,7,6,8,8,2,8,7,7,7,1,8,10,8
+X,3,7,5,5,4,7,7,3,8,5,6,9,3,7,7,9
+G,6,10,6,8,5,7,6,6,5,10,7,13,4,8,6,7
+O,4,7,4,5,4,8,7,7,4,9,5,8,3,8,3,8
+N,3,4,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+O,5,8,5,6,4,7,9,7,4,10,7,6,4,9,4,8
+L,4,9,6,8,6,7,6,5,4,7,7,8,3,8,8,10
+Z,3,8,4,6,3,7,8,3,12,8,6,8,0,8,7,7
+I,5,9,4,4,2,7,10,2,5,13,5,4,1,9,5,8
+P,8,12,7,6,4,9,8,4,5,13,4,4,4,10,6,7
+G,3,5,4,3,2,6,7,5,5,9,7,10,2,9,4,9
+P,4,10,5,7,2,3,13,8,2,11,7,3,1,10,4,8
+O,4,8,6,7,5,8,4,5,5,9,4,10,4,7,5,7
+Y,4,10,6,7,1,9,10,3,2,6,13,8,2,11,0,8
+Y,6,11,5,6,3,7,8,4,5,10,7,5,3,9,4,4
+O,1,3,2,2,1,8,6,6,3,9,6,8,2,8,2,8
+E,5,7,6,6,7,7,8,5,4,7,7,10,7,10,9,10
+X,3,7,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+T,2,3,3,2,1,6,12,2,6,11,9,4,1,10,2,5
+S,7,10,6,5,3,7,3,4,4,7,2,7,3,6,5,8
+I,2,6,3,4,2,7,8,0,7,13,6,8,0,8,1,8
+C,4,8,5,6,3,5,8,7,7,8,8,14,2,9,4,10
+O,6,10,7,7,6,7,7,7,4,9,6,10,5,8,5,6
+F,3,6,5,4,4,8,8,1,4,9,6,6,5,10,4,5
+Y,5,8,5,6,2,3,11,2,7,12,11,6,0,10,2,5
+A,3,7,5,4,2,7,4,3,1,7,1,8,2,7,2,8
+E,3,7,3,5,3,3,6,5,9,7,7,13,0,8,7,9
+E,3,5,5,4,3,8,7,2,8,11,5,8,2,8,4,10
+C,3,7,4,5,1,6,7,7,9,7,6,13,1,8,4,9
+O,3,6,4,4,3,7,8,7,5,8,8,6,3,8,3,8
+J,4,10,5,7,5,10,6,3,4,9,3,6,3,7,6,7
+X,5,10,6,7,1,7,7,5,4,7,6,8,3,8,4,8
+T,3,3,4,2,1,5,11,2,7,11,9,5,1,10,2,5
+D,4,9,6,7,4,9,7,5,7,10,4,5,3,8,3,8
+X,4,6,5,5,5,7,8,2,4,7,6,8,2,7,7,7
+Z,2,3,4,2,1,7,7,2,9,11,6,8,1,8,5,7
+P,3,6,4,4,3,3,13,5,1,11,7,4,0,9,3,8
+P,2,4,3,3,1,7,9,3,4,12,5,3,1,10,2,8
+Y,5,8,5,6,3,3,10,2,7,11,11,6,1,11,2,5
+A,2,6,3,4,2,11,3,2,2,9,2,9,2,6,2,8
+P,3,7,3,4,2,4,12,8,2,10,6,4,1,10,4,8
+U,6,10,9,8,12,8,6,4,4,7,7,8,11,9,6,8
+P,4,5,6,7,6,8,10,2,3,8,9,6,5,10,5,5
+G,2,3,3,2,2,7,7,5,5,6,6,9,2,9,4,9
+C,3,4,4,3,1,4,8,5,8,11,9,12,1,9,3,7
+E,2,1,2,2,1,4,7,5,8,7,6,13,0,8,7,9
+W,12,13,11,7,5,8,11,3,3,5,10,7,8,12,1,6
+R,10,15,10,8,8,6,8,3,6,8,4,9,8,4,7,6
+U,4,6,5,4,2,4,9,5,6,12,11,9,3,9,1,7
+V,5,11,8,8,4,7,12,3,4,6,12,9,3,10,1,8
+N,6,8,8,7,8,7,7,5,4,7,5,8,8,8,6,6
+I,5,12,5,6,3,6,11,3,5,13,6,4,1,8,5,8
+Q,6,7,8,10,11,9,7,6,1,6,6,9,9,11,6,9
+M,5,9,8,7,7,10,6,2,4,9,5,7,7,6,2,8
+V,7,11,6,6,3,9,9,6,4,6,10,6,6,13,3,6
+X,2,3,3,2,1,7,7,3,8,6,6,8,2,8,5,8
+C,6,8,6,6,3,3,8,4,7,10,10,13,1,7,3,7
+A,5,12,6,6,3,13,1,4,1,12,3,11,2,3,3,11
+R,8,15,8,8,6,8,6,3,5,9,4,8,6,8,6,7
+G,4,6,5,4,3,6,7,6,6,10,7,11,2,9,4,10
+L,3,6,4,4,2,5,5,1,9,7,2,11,0,8,3,7
+B,4,3,5,5,4,6,7,9,7,7,6,7,2,8,9,9
+W,3,4,5,3,3,7,11,2,2,7,9,8,7,11,1,8
+V,9,13,9,7,4,6,10,4,3,8,8,5,5,12,3,8
+X,6,10,6,6,3,7,7,2,7,11,6,8,4,9,4,7
+A,3,10,5,8,4,12,3,1,2,9,2,9,3,6,2,8
+Z,5,11,7,8,4,7,7,2,11,11,6,8,1,8,6,7
+R,5,10,6,8,7,8,6,6,4,8,6,8,7,7,6,11
+B,2,1,3,2,2,8,7,5,5,7,6,5,2,8,6,9
+C,4,7,6,5,3,7,7,8,6,6,6,10,3,8,4,9
+V,3,3,4,2,1,4,12,3,3,9,11,7,2,10,0,8
+E,4,7,5,5,4,6,8,7,9,6,4,10,2,8,6,8
+R,3,8,5,6,4,8,7,5,7,7,6,6,3,8,5,8
+V,3,5,5,3,2,4,12,3,3,9,11,7,2,11,1,8
+V,5,9,5,7,3,3,11,2,3,10,11,8,2,11,1,8
+N,5,10,7,8,6,6,8,8,6,8,6,7,3,7,3,8
+P,4,8,6,11,10,9,6,6,2,7,6,7,7,9,8,11
+P,7,11,9,8,5,6,12,3,6,14,6,2,0,10,3,9
+H,5,6,7,4,4,8,8,3,6,10,5,7,3,8,3,8
+F,3,7,4,5,3,5,10,4,5,10,10,6,2,10,3,6
+A,5,11,9,8,7,8,4,1,4,6,2,6,5,8,6,6
+U,3,7,3,5,2,7,5,14,5,7,12,8,3,9,0,8
+Z,2,2,3,4,2,8,7,5,9,6,6,8,1,8,7,8
+W,4,2,6,3,3,9,11,3,2,5,9,8,8,11,2,8
+Z,4,9,5,7,4,7,7,3,12,9,6,8,0,8,8,8
+S,5,11,7,8,9,6,5,3,2,6,5,6,5,8,15,3
+B,5,6,6,8,5,6,6,9,8,6,7,7,3,8,10,10
+F,4,9,4,4,3,7,9,2,4,11,6,5,3,10,6,6
+B,5,9,7,7,5,9,7,4,6,10,5,6,2,8,6,10
+E,4,7,6,5,5,10,6,1,7,11,4,8,3,8,5,11
+C,5,10,6,8,2,5,7,7,11,7,6,14,1,8,4,9
+K,2,4,4,3,2,6,7,2,6,10,7,10,3,8,2,8
+I,1,4,2,2,1,7,7,1,7,13,6,8,0,8,1,8
+Z,8,12,8,7,5,8,6,2,9,12,6,9,3,7,7,7
+J,1,1,2,2,1,11,6,2,5,11,4,8,0,7,1,7
+P,6,11,5,6,3,5,11,5,3,13,6,4,4,10,4,8
+P,9,11,7,6,4,6,10,6,3,11,5,5,5,9,4,8
+C,2,4,3,2,1,6,8,7,8,8,8,13,1,9,4,10
+S,7,11,9,8,5,7,8,4,9,11,5,7,2,7,5,8
+R,2,3,3,2,2,9,6,4,5,9,4,7,2,7,4,10
+Z,4,8,5,6,4,8,6,2,9,11,5,9,2,8,6,9
+N,6,7,8,5,3,5,9,3,5,11,9,9,6,8,1,8
+B,3,7,4,5,4,6,6,8,6,6,7,7,2,9,7,9
+G,4,4,5,6,3,7,6,8,7,6,6,7,2,8,6,11
+K,6,10,8,8,8,6,7,4,7,6,6,10,3,8,6,10
+A,4,9,6,7,4,12,2,3,3,10,2,9,2,6,4,8
+U,3,3,3,5,1,8,5,13,5,6,13,8,3,9,0,8
+E,3,7,4,5,4,7,7,5,8,6,5,10,2,8,5,9
+X,2,7,4,5,4,7,6,2,6,7,5,8,3,7,5,9
+K,3,6,4,4,1,3,6,7,3,7,7,11,3,8,2,10
+X,4,9,6,6,4,7,7,3,8,5,6,7,3,9,7,6
+T,3,4,4,3,1,5,11,2,7,11,9,4,1,10,2,5
+N,5,8,7,6,7,6,8,3,4,8,7,9,6,9,5,5
+V,6,11,6,8,4,3,11,3,4,9,11,8,3,11,1,7
+U,3,5,4,3,2,7,9,6,7,7,9,9,3,9,1,8
+U,4,11,6,8,4,8,8,6,7,4,8,9,6,10,1,8
+Z,3,5,5,7,4,9,5,4,4,7,3,6,2,8,7,6
+S,5,10,6,7,3,9,6,5,8,11,3,7,2,8,5,11
+V,4,6,4,4,2,1,11,5,3,12,12,8,2,10,1,7
+N,3,6,4,4,3,8,8,6,5,6,6,5,5,9,2,5
+I,1,3,1,1,0,8,7,1,7,13,6,8,0,8,0,8
+G,4,9,4,6,3,6,7,6,5,10,8,10,2,9,4,9
+V,2,3,4,5,1,7,8,4,2,7,13,8,3,10,0,8
+Z,10,10,7,14,6,7,8,4,2,11,7,7,3,8,13,5
+B,4,10,4,8,4,6,7,9,6,7,6,7,2,8,9,10
+Z,3,5,4,4,3,7,7,5,9,6,6,8,1,8,7,8
+C,2,1,2,2,1,6,7,6,9,7,6,14,0,8,4,9
+H,5,10,6,7,3,7,6,15,1,7,8,8,3,8,0,8
+C,3,8,4,6,2,5,8,7,7,8,8,14,2,10,4,10
+X,3,8,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+F,1,0,2,1,0,3,12,5,2,11,8,6,0,8,2,7
+X,4,5,7,4,3,5,8,2,9,11,10,9,3,7,4,5
+L,5,8,6,6,5,6,6,6,6,6,5,8,5,8,4,9
+I,3,8,4,6,2,6,9,0,7,13,7,7,0,8,1,7
+S,3,5,4,3,3,8,8,7,5,7,6,8,2,8,9,8
+E,5,4,5,6,3,3,7,6,11,7,6,15,0,8,7,7
+W,3,8,5,6,9,7,7,6,1,7,6,8,8,12,2,11
+R,2,1,2,2,2,6,7,4,4,6,5,6,2,7,3,8
+L,4,7,5,5,2,8,3,2,8,9,2,9,1,6,3,9
+Y,6,9,8,7,7,9,3,7,5,7,9,7,3,8,8,3
+X,3,9,4,7,3,7,7,4,4,7,6,8,3,8,4,8
+U,9,14,8,8,5,6,5,5,5,6,8,9,6,8,4,9
+O,7,14,5,8,4,5,8,7,4,10,8,9,5,10,5,8
+X,4,10,7,8,4,10,6,2,8,10,1,7,3,8,4,9
+A,3,10,5,7,2,7,5,3,1,6,0,8,3,7,2,7
+A,4,10,7,8,5,7,3,1,2,5,2,8,4,5,4,6
+N,3,9,4,7,4,7,7,12,1,6,6,8,5,8,0,7
+P,7,9,9,7,5,8,11,7,4,11,4,3,2,10,4,8
+E,4,9,6,7,5,6,8,3,7,11,8,8,3,8,5,6
+K,3,6,5,4,3,5,6,6,7,7,7,12,3,8,5,11
+Q,4,7,5,6,2,8,8,8,6,5,8,9,3,8,5,10
+G,7,10,6,5,4,8,4,4,3,8,6,10,4,9,6,7
+K,6,10,8,8,5,5,8,2,7,10,8,11,3,8,3,7
+B,4,8,6,6,5,10,6,2,6,10,3,7,4,8,5,11
+H,7,9,10,7,7,6,8,3,7,10,9,9,8,9,6,6
+D,3,8,5,6,3,11,6,3,7,11,3,6,3,8,3,9
+A,2,7,4,5,3,11,3,2,2,9,2,9,1,6,2,8
+T,2,3,3,2,2,8,11,3,6,6,10,8,2,11,1,8
+I,1,6,2,4,1,7,7,1,8,7,6,8,0,8,3,8
+B,3,5,4,4,3,8,7,6,6,6,6,5,2,8,7,8
+O,6,11,7,8,5,7,7,8,5,10,6,8,3,8,3,8
+Z,4,9,5,7,5,8,8,3,8,7,7,7,1,8,11,7
+Q,3,3,4,4,3,7,8,5,3,8,8,10,3,9,5,8
+K,9,15,9,8,6,2,9,3,6,9,9,12,4,7,3,6
+N,6,10,9,7,5,10,7,3,5,10,3,5,6,9,1,7
+X,3,4,5,3,2,7,7,4,9,6,6,8,2,8,6,8
+U,8,14,7,8,5,7,6,5,5,6,7,8,5,7,3,7
+T,6,11,6,8,5,4,12,3,6,12,10,5,2,12,2,4
+X,3,6,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+D,4,6,6,4,4,9,7,3,6,11,4,6,3,8,3,8
+P,6,9,8,7,4,7,10,5,4,12,5,3,1,10,3,9
+N,4,5,6,4,3,7,8,2,5,10,6,6,5,9,1,7
+K,8,14,8,8,4,7,7,3,6,9,9,9,6,11,4,7
+W,8,8,11,7,12,7,7,5,5,6,5,8,10,9,9,8
+Z,2,5,4,3,2,8,7,2,9,11,6,8,1,7,6,7
+H,3,5,5,4,3,7,8,5,7,7,6,8,6,8,3,8
+G,2,3,3,2,1,7,7,6,6,7,5,10,2,9,4,9
+K,4,9,4,6,2,3,8,7,2,7,5,11,3,8,3,10
+W,4,9,7,7,5,9,10,2,3,6,9,8,7,11,1,8
+U,2,1,2,1,1,7,8,6,5,7,9,9,3,10,0,8
+E,5,9,5,7,3,3,7,6,11,7,6,14,0,8,8,7
+T,3,3,3,2,1,5,11,2,6,11,9,5,1,10,2,5
+Z,1,3,3,2,1,8,7,1,9,11,6,8,1,8,5,7
+R,4,10,5,7,3,5,11,9,4,7,3,9,3,7,6,11
+S,7,10,9,8,5,7,8,4,9,11,5,6,2,6,5,8
+L,5,11,7,8,4,6,4,0,9,8,2,11,0,7,2,8
+X,5,8,7,6,5,8,6,3,5,6,7,8,2,9,8,9
+C,6,11,7,8,5,5,7,7,9,8,6,13,2,11,5,8
+M,5,9,8,7,11,8,6,3,2,8,4,8,13,6,3,7
+Z,4,8,5,6,5,9,6,5,9,7,5,7,1,7,7,8
+J,5,7,7,9,6,9,8,5,5,6,5,8,3,8,9,7
+A,3,6,5,5,4,9,7,4,5,6,8,5,4,10,4,5
+F,5,11,7,8,7,5,9,4,6,10,10,6,2,9,3,6
+X,3,5,4,4,3,8,7,3,9,6,6,8,2,8,6,8
+C,4,9,5,7,4,5,7,8,7,10,8,13,2,11,4,10
+E,9,14,7,8,5,7,9,5,5,10,6,10,3,8,7,10
+H,3,6,5,4,4,5,9,3,6,10,8,8,3,8,3,6
+S,4,6,5,4,3,8,7,3,7,10,6,8,2,9,4,8
+I,1,4,1,3,1,7,7,1,7,7,6,8,0,8,2,8
+X,5,11,6,6,3,4,9,3,7,11,10,9,4,10,3,5
+O,7,15,5,8,4,6,7,7,4,9,7,9,5,10,5,8
+Q,5,10,7,8,4,8,9,8,7,5,9,9,3,7,6,10
+F,2,3,4,2,1,6,11,3,5,13,7,4,1,9,1,7
+S,3,4,3,2,2,8,8,6,5,7,6,7,2,8,9,8
+E,7,11,10,8,6,9,7,2,9,12,4,8,5,7,7,10
+W,4,6,6,4,5,8,7,6,3,6,8,8,6,8,3,7
+Y,4,11,7,8,1,9,10,3,2,6,13,8,2,11,0,8
+O,7,11,8,8,6,8,6,8,6,10,4,8,4,9,5,6
+W,4,3,6,4,2,11,8,5,1,6,9,8,8,10,0,8
+Z,6,7,5,10,4,8,5,5,5,11,6,7,3,9,9,8
+N,2,3,4,1,1,5,9,3,4,11,8,8,5,8,0,7
+V,4,8,4,6,3,4,11,2,2,9,10,8,3,12,1,8
+N,9,13,8,7,4,5,9,4,6,3,4,11,6,10,2,7
+P,9,10,7,5,3,7,9,7,5,14,4,4,4,10,4,8
+K,1,0,1,0,0,4,6,6,2,7,6,11,3,7,2,10
+F,5,10,8,8,5,6,10,3,6,13,7,5,2,9,3,7
+R,5,9,5,4,3,8,8,3,5,9,2,6,5,6,5,7
+D,4,7,6,5,4,9,7,4,6,10,5,5,3,8,3,8
+Z,3,3,4,4,3,7,7,5,10,6,6,8,2,8,7,8
+E,4,9,6,7,7,7,8,3,6,5,7,10,5,11,7,8
+V,3,11,5,8,4,8,11,2,3,5,10,8,3,12,1,8
+I,5,7,6,8,6,8,10,4,5,6,7,9,3,6,8,6
+L,3,3,4,5,1,0,0,6,6,0,1,5,0,8,0,8
+G,2,1,3,2,2,7,7,5,4,7,6,9,3,6,4,9
+G,4,5,5,8,2,7,6,8,9,6,5,11,1,8,6,11
+F,3,6,5,4,4,7,10,1,4,9,6,6,4,9,2,5
+U,5,5,6,7,2,7,4,14,6,7,15,8,3,9,0,8
+D,5,8,5,6,4,6,7,9,8,7,7,6,2,8,3,8
+W,8,9,8,4,3,7,10,3,2,7,10,7,9,12,1,6
+D,5,5,6,8,3,5,7,10,9,7,6,5,3,8,4,8
+I,2,2,1,3,1,7,7,1,8,7,6,8,0,8,3,8
+L,2,2,3,3,1,4,4,4,7,2,1,6,0,7,1,6
+T,5,8,7,7,7,6,7,3,8,7,6,9,4,6,9,4
+M,8,11,10,8,13,7,7,7,4,7,5,8,7,11,9,8
+D,4,11,4,8,3,5,7,11,8,7,6,5,3,8,4,8
+F,6,9,8,7,4,5,11,1,6,13,7,4,1,10,2,7
+D,2,4,4,3,2,8,7,4,6,10,5,6,2,8,2,8
+Z,2,4,4,3,2,7,8,2,9,12,6,8,1,8,5,7
+F,3,4,5,3,2,5,11,3,5,13,7,5,1,9,1,7
+H,4,9,6,6,5,7,6,7,7,7,7,9,3,8,3,9
+Q,3,5,4,6,2,8,8,7,5,5,8,9,3,8,5,9
+X,2,2,4,3,2,8,7,3,9,6,6,8,2,8,6,8
+A,4,8,6,7,6,7,8,2,4,7,8,8,5,8,5,6
+G,4,6,6,4,5,7,7,5,3,6,6,10,4,8,7,8
+V,9,13,7,7,4,7,8,7,4,8,9,6,7,13,3,9
+Y,7,8,5,12,4,10,10,1,4,7,10,5,3,9,5,10
+M,4,7,5,5,5,8,6,6,4,7,7,8,8,5,2,7
+G,3,9,5,6,4,6,6,6,6,7,5,12,2,9,4,9
+V,1,0,2,1,0,7,9,3,2,7,12,8,2,10,0,8
+A,2,1,4,2,1,8,2,2,2,8,1,8,2,6,2,7
+A,3,5,5,4,2,11,2,2,2,9,2,9,2,6,2,8
+O,4,9,6,6,4,7,6,8,5,7,4,8,3,8,3,8
+I,1,5,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+M,4,4,5,3,3,7,6,6,5,6,7,7,8,6,3,7
+W,4,7,6,5,5,7,9,6,4,8,8,7,6,8,3,8
+W,5,7,7,5,3,6,8,5,1,7,8,8,8,9,0,8
+X,3,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+L,4,10,6,8,3,5,4,1,9,7,2,11,0,7,3,7
+U,6,9,8,8,8,7,6,4,5,6,6,8,7,9,2,8
+I,2,9,3,7,2,9,7,0,7,13,5,8,0,8,1,8
+I,1,3,1,2,0,7,7,1,8,7,6,8,0,8,3,8
+Q,3,8,4,7,2,8,7,8,5,6,7,8,3,8,5,9
+U,4,4,5,3,2,4,7,5,8,10,8,9,4,11,3,4
+G,3,6,4,4,4,7,8,5,3,6,6,9,3,7,6,8
+L,4,9,5,8,5,7,6,5,5,7,7,8,3,9,8,11
+A,2,7,3,5,2,12,3,2,2,10,2,9,2,6,2,8
+I,1,5,2,3,1,7,7,0,7,13,6,8,0,8,1,8
+U,2,3,3,2,1,5,8,5,6,10,9,9,3,10,2,6
+B,5,9,7,7,6,9,7,3,7,10,4,6,2,8,5,10
+I,0,7,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+O,6,11,6,8,5,8,7,8,5,10,5,8,4,9,4,6
+C,5,11,6,8,3,6,7,7,11,5,6,14,1,7,4,8
+G,4,9,5,7,3,8,7,8,7,6,6,9,2,7,6,10
+D,4,8,6,6,4,6,8,7,7,11,7,5,3,8,4,8
+C,4,8,5,6,3,5,8,7,8,8,8,14,2,9,4,9
+M,4,7,6,5,4,4,7,4,5,10,11,10,6,5,2,6
+S,4,11,5,8,4,8,8,8,7,8,4,7,2,7,9,8
+R,3,4,4,2,3,7,7,5,5,7,5,7,2,7,4,8
+Q,5,6,7,9,10,8,9,5,2,6,7,9,9,14,10,14
+B,7,11,10,8,7,11,6,3,8,11,3,7,3,8,5,12
+O,1,0,2,0,0,7,7,6,4,7,6,8,2,8,3,8
+U,5,8,5,6,4,8,6,12,4,7,12,8,3,9,0,8
+I,3,8,4,6,2,7,7,0,7,13,6,8,0,8,1,7
+M,8,12,9,6,5,3,8,5,6,4,2,11,8,8,2,8
+K,5,6,7,4,3,9,7,2,7,11,3,7,3,8,3,9
+C,1,0,1,1,0,6,7,6,7,7,6,13,0,8,4,10
+W,2,0,3,1,1,8,8,4,0,7,8,8,6,10,0,8
+A,3,9,5,6,3,12,2,4,2,11,2,9,3,7,3,9
+J,2,6,3,4,2,7,7,3,5,14,6,10,1,6,0,7
+E,7,10,5,5,2,7,8,5,7,10,6,8,1,9,7,8
+H,5,9,8,7,8,7,7,6,6,7,6,8,3,8,3,8
+S,2,3,3,1,1,7,9,3,7,11,7,7,1,9,4,6
+T,4,7,5,5,4,8,10,3,6,10,8,5,2,12,3,5
+P,12,13,9,8,4,7,9,6,4,11,4,5,5,9,5,8
+T,2,3,3,2,1,7,12,3,5,7,10,8,2,11,1,8
+F,3,9,4,6,1,1,14,5,3,12,10,5,0,8,2,6
+O,2,2,3,4,2,7,7,7,4,7,6,8,2,8,3,8
+N,5,11,5,8,5,7,7,13,1,6,6,8,6,8,1,9
+Q,4,8,5,8,3,8,6,9,7,7,4,9,3,8,4,8
+E,4,7,5,6,5,6,7,4,4,7,7,9,4,11,8,11
+V,8,11,7,8,4,4,11,3,4,9,11,7,2,10,1,8
+D,4,11,5,8,5,8,7,6,7,7,6,5,6,8,3,7
+T,5,10,5,5,3,7,9,2,6,11,6,7,2,9,4,6
+P,4,9,6,6,4,7,11,7,3,11,5,3,2,10,4,8
+J,5,10,7,8,3,7,7,3,6,15,6,10,3,8,2,8
+T,3,4,4,3,1,5,11,2,7,11,9,5,1,10,2,5
+I,2,9,2,6,2,7,7,0,8,7,6,8,0,8,3,8
+B,3,5,5,4,5,7,8,4,4,7,6,8,6,9,7,8
+R,5,8,7,6,7,7,6,3,5,7,6,8,6,9,6,7
+T,3,10,5,7,1,10,15,1,6,4,11,9,0,8,0,8
+K,3,8,5,6,3,5,7,5,7,6,6,11,3,8,5,9
+C,4,8,5,6,3,6,8,7,8,8,8,14,2,10,4,9
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+I,0,6,0,4,0,7,7,5,3,7,6,8,0,8,0,8
+F,4,10,4,8,3,1,13,4,3,12,10,6,0,8,2,6
+I,4,10,6,8,7,8,9,3,5,9,5,4,6,9,7,2
+W,3,2,5,4,3,7,10,2,2,7,9,8,7,11,0,8
+S,4,10,5,7,4,7,7,5,8,4,6,10,1,10,9,9
+U,3,5,4,4,2,7,8,5,6,5,9,9,5,10,1,7
+V,5,9,7,7,4,7,12,2,3,5,11,9,4,10,2,7
+Y,1,1,2,1,1,7,10,1,5,7,11,8,1,11,1,8
+L,5,10,8,8,9,7,7,3,6,6,7,11,6,12,6,6
+I,0,0,0,0,0,7,7,4,4,7,6,8,0,8,0,8
+E,4,9,5,7,4,4,9,3,8,10,8,10,2,8,4,6
+M,3,4,4,3,3,7,6,6,4,6,7,8,7,5,2,8
+G,4,9,5,7,2,8,6,8,8,6,6,12,2,8,5,10
+E,6,9,8,7,8,8,10,6,3,6,6,9,5,7,7,9
+D,3,6,5,4,6,9,9,4,4,7,6,6,3,8,7,5
+H,5,10,8,8,8,7,7,5,7,7,6,8,6,8,4,8
+Y,3,8,5,5,1,8,10,2,3,7,12,8,1,11,0,8
+B,4,6,6,4,3,10,7,3,8,11,3,6,2,8,5,10
+G,6,9,7,7,4,6,7,7,8,10,7,11,2,9,4,9
+N,4,9,5,4,2,7,8,3,3,12,9,9,5,9,0,8
+P,4,7,4,5,2,4,14,8,1,11,6,3,0,10,4,8
+L,5,9,7,8,6,7,8,3,6,6,7,9,3,8,8,8
+T,4,7,5,5,4,7,7,7,6,7,8,8,3,10,5,9
+U,6,11,6,8,3,8,4,14,6,6,15,8,3,9,0,8
+K,4,5,5,4,3,5,6,4,8,7,7,11,3,8,5,10
+K,5,11,6,8,5,4,8,8,3,6,3,11,3,8,2,11
+I,0,7,0,4,0,7,7,4,4,7,6,8,0,8,0,8
+B,2,5,3,4,3,7,7,5,5,6,6,6,2,8,5,9
+J,5,11,7,8,8,8,6,4,4,8,5,5,6,6,6,3
+S,4,10,5,8,2,7,7,6,9,4,6,8,0,8,9,8
+Q,3,5,4,6,4,7,8,5,2,7,8,11,2,9,5,8
+L,4,10,5,7,3,0,2,4,6,1,0,8,0,8,0,8
+K,6,10,6,5,4,9,6,3,6,11,2,8,5,6,4,9
+Z,1,3,2,2,1,7,7,1,8,11,6,9,1,9,5,8
+K,5,5,5,8,2,4,6,8,2,7,7,12,3,8,3,11
+L,3,6,4,4,2,6,5,1,9,7,2,10,0,7,3,8
+S,2,3,4,1,1,8,8,2,7,10,6,7,1,9,4,8
+H,1,0,1,0,0,7,8,10,1,7,6,8,2,8,0,8
+N,4,8,5,6,5,6,6,7,5,6,5,7,3,7,3,8
+H,9,11,12,8,8,7,7,3,6,10,7,9,3,8,4,8
+K,4,9,6,7,7,7,6,5,5,6,5,7,7,6,8,14
+C,4,9,6,7,2,6,6,7,11,9,5,13,1,10,4,9
+S,2,3,3,1,1,8,8,2,7,10,6,7,1,9,4,8
+S,4,7,6,5,7,7,8,3,3,8,6,7,3,7,12,2
+H,1,1,2,1,1,7,7,11,1,7,6,8,3,8,0,8
+Z,9,10,6,14,6,6,9,5,2,12,8,7,3,8,12,5
+B,3,7,4,5,4,8,8,6,6,7,5,6,2,8,6,9
+Q,5,8,6,7,3,9,7,9,7,6,6,10,3,8,5,9
+D,3,6,4,4,3,8,7,5,7,10,5,6,3,8,3,9
+G,7,12,6,6,4,7,8,4,3,9,5,6,3,9,10,7
+D,3,6,4,4,4,8,7,5,8,7,7,5,3,8,3,7
+S,5,11,6,8,4,8,7,3,6,10,7,9,2,10,5,8
+U,4,9,6,6,5,8,8,8,5,6,7,9,3,8,4,6
+E,4,9,3,4,2,8,7,3,4,10,5,8,3,9,8,11
+B,1,3,3,2,2,9,6,3,5,10,5,7,2,8,4,9
+I,3,7,4,5,2,6,8,0,7,13,7,8,0,8,1,7
+Z,2,4,3,2,2,7,7,5,9,6,6,8,2,8,7,8
+C,3,7,4,5,2,5,8,7,8,7,8,14,1,8,4,10
+H,6,8,9,6,5,5,8,4,7,10,10,10,5,10,4,6
+O,3,6,4,4,2,9,9,8,7,5,8,10,3,8,4,8
+Z,2,3,4,2,1,7,7,2,9,12,6,9,1,9,5,7
+F,6,11,6,6,4,10,7,2,5,10,5,6,4,8,6,9
+X,4,8,4,6,3,7,7,4,4,7,6,8,3,8,4,8
+W,7,9,8,4,4,4,8,2,3,8,10,8,9,11,2,5
+Z,5,7,4,11,4,7,8,4,2,12,7,7,3,9,11,5
+A,4,9,6,8,6,10,7,4,6,6,9,5,5,11,4,4
+A,4,11,7,8,4,12,2,3,3,10,2,9,3,7,4,9
+N,3,5,6,4,3,6,9,2,4,10,7,7,5,8,1,8
+C,5,5,6,8,3,5,7,7,11,7,6,12,1,8,4,9
+R,4,7,5,5,4,8,9,6,6,8,5,8,3,7,6,11
+R,5,5,5,8,3,6,10,10,4,7,5,8,3,8,6,11
+U,7,11,10,8,8,8,7,8,6,6,7,9,4,9,5,6
+G,5,4,6,6,3,8,8,8,8,6,7,8,2,7,6,11
+B,4,8,5,6,5,10,7,3,6,10,4,6,2,8,4,10
+M,2,3,3,2,2,8,6,6,4,7,8,8,6,5,2,8
+R,2,4,4,3,3,8,7,4,5,8,5,7,3,7,4,11
+X,10,13,9,7,4,6,7,2,9,9,7,9,4,6,4,6
+N,4,7,6,5,4,8,8,6,5,7,6,5,5,9,2,6
+H,3,2,5,3,3,8,7,6,6,7,6,7,3,8,3,7
+W,5,9,8,6,3,4,8,5,2,7,9,8,8,9,0,8
+E,4,9,4,6,4,3,9,5,10,7,6,14,0,8,6,8
+L,3,7,5,5,3,4,3,8,6,1,3,3,1,6,0,6
+I,7,13,6,8,3,10,7,2,5,11,5,6,2,10,5,11
+X,4,6,6,4,4,7,7,2,6,7,5,8,3,6,6,8
+E,4,6,5,4,5,7,7,3,6,7,7,11,4,9,7,8
+L,2,5,4,3,2,6,4,1,8,8,2,10,0,7,2,8
+B,2,1,2,2,2,7,7,4,4,6,6,6,2,8,4,10
+K,4,7,6,6,6,10,6,2,3,9,3,8,5,6,6,13
+R,2,4,3,3,2,10,6,3,5,10,3,7,2,7,3,10
+O,4,11,5,8,4,7,7,9,5,7,6,8,3,8,3,8
+C,7,10,5,6,2,5,10,5,8,11,8,9,2,8,5,8
+D,5,8,6,6,5,8,7,6,9,7,6,5,6,8,3,7
+V,2,7,4,5,2,9,11,3,3,3,11,9,2,10,1,8
+Z,1,0,2,1,0,7,7,2,10,8,6,8,0,8,6,8
+Q,4,8,5,9,5,8,7,7,4,9,6,9,3,8,6,8
+L,7,13,7,7,5,9,3,4,3,11,6,10,4,8,7,9
+L,5,10,7,8,3,8,3,2,8,9,2,9,1,6,3,8
+O,4,5,6,7,3,9,6,9,8,8,4,9,3,8,4,8
+N,6,11,8,8,5,7,8,6,6,7,7,5,7,10,3,4
+U,1,0,2,1,0,7,5,10,4,7,12,8,3,10,0,8
+D,6,11,6,6,4,6,8,4,7,10,6,7,5,8,6,5
+A,2,6,4,4,2,8,3,2,2,7,1,8,2,6,2,6
+L,4,10,6,7,4,9,3,2,7,8,2,9,3,4,4,9
+Z,3,5,6,4,3,7,7,2,10,12,6,8,1,8,6,8
+E,2,1,2,3,2,7,7,6,6,7,6,8,2,8,5,10
+E,2,4,2,3,2,7,7,5,7,7,6,8,2,8,5,10
+N,1,0,2,1,1,7,7,11,1,5,6,8,4,8,0,8
+W,4,9,6,6,3,7,8,4,1,6,8,8,8,9,0,8
+B,5,9,6,7,6,8,8,6,7,7,6,6,6,8,7,11
+Q,5,9,7,11,8,9,8,8,3,5,6,10,3,9,6,10
+V,4,9,6,7,2,8,8,5,3,6,14,8,3,9,0,8
+G,4,8,5,6,4,8,7,8,6,6,7,9,2,7,5,10
+X,6,9,10,7,4,8,8,1,9,10,5,7,3,8,4,8
+J,6,9,8,10,7,7,8,4,6,7,7,7,4,8,10,10
+R,3,2,4,4,3,7,7,5,5,6,5,6,3,7,4,8
+E,3,6,5,4,3,5,8,3,8,11,8,9,2,8,4,7
+M,7,13,8,7,5,9,3,2,2,9,4,9,6,2,1,9
+W,6,9,6,5,3,2,10,2,3,10,11,9,6,11,1,6
+K,8,11,11,8,7,5,7,2,7,10,8,11,3,8,3,7
+C,3,6,5,4,1,6,6,6,10,7,5,13,1,9,4,9
+D,2,5,4,3,3,9,6,3,5,10,4,6,3,7,3,8
+I,1,2,1,3,1,7,7,1,7,7,6,8,0,8,2,8
+J,3,5,5,4,2,8,6,3,7,15,5,10,1,6,1,7
+T,5,7,6,5,4,7,9,1,9,10,9,5,0,9,3,5
+J,3,6,4,4,1,8,6,5,6,15,7,12,1,6,1,7
+L,3,11,5,8,4,3,5,2,8,3,1,9,0,7,1,6
+F,7,10,6,5,4,8,9,3,4,11,6,5,3,9,6,7
+Z,2,4,5,3,2,8,7,2,9,12,6,8,1,8,5,8
+E,3,7,5,5,3,8,7,2,9,11,5,8,2,8,5,9
+V,9,14,8,8,5,6,9,4,4,8,8,5,5,13,3,7
+E,4,11,6,8,5,10,6,2,7,11,4,9,3,7,6,12
+X,6,8,8,7,8,8,8,2,5,8,6,8,4,8,8,8
+D,3,5,4,4,3,7,7,7,7,6,6,5,2,8,3,7
+K,7,9,10,6,7,9,7,1,6,10,3,8,6,7,5,10
+B,2,5,4,4,3,9,7,2,6,11,5,7,4,7,5,9
+K,4,8,6,6,6,6,8,5,4,7,5,8,4,6,9,9
+I,5,12,5,6,3,9,8,2,5,12,4,5,2,10,5,11
+L,6,10,8,8,9,6,7,3,6,7,7,11,6,12,6,7
+X,5,5,6,8,2,7,7,5,4,7,6,8,3,8,4,8
+Q,8,13,7,7,6,9,6,4,7,10,6,7,4,8,10,9
+W,8,9,8,6,5,1,10,2,3,10,11,9,7,10,1,7
+G,5,11,6,8,3,7,6,8,9,5,5,10,1,8,6,11
+P,3,7,3,4,2,4,12,8,2,10,6,4,1,10,3,8
+D,3,5,4,4,3,7,7,7,6,6,6,5,2,8,3,7
+G,4,4,5,6,2,7,5,7,8,6,5,11,1,8,6,11
+U,4,6,5,4,4,7,8,7,5,5,7,11,4,9,5,5
+Z,4,6,5,4,3,7,7,2,9,11,6,8,1,9,6,8
+U,3,7,3,5,2,8,6,10,4,7,12,9,3,9,0,8
+M,4,6,6,4,4,11,7,2,4,9,3,6,7,6,2,8
+A,2,1,3,1,1,7,4,2,0,7,2,8,3,6,1,8
+V,5,11,8,8,5,7,12,2,3,5,10,9,4,11,2,7
+K,5,9,8,6,4,3,8,3,8,12,12,12,3,8,4,5
+A,1,0,2,0,0,7,4,2,0,7,2,8,2,6,1,8
+W,5,8,7,6,3,10,8,5,1,7,8,8,8,9,0,8
+R,3,8,5,6,4,8,7,4,5,9,3,8,3,7,4,11
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+D,5,9,6,7,7,7,7,7,6,7,6,4,3,8,3,8
+W,4,5,6,4,6,8,7,4,4,6,5,8,9,8,6,9
+E,5,9,6,8,7,6,8,4,4,8,7,9,5,10,9,11
+G,5,11,7,8,9,8,7,5,2,6,6,10,7,8,6,12
+O,4,10,6,7,3,8,7,9,8,7,6,8,3,8,4,8
+C,4,7,5,5,2,6,7,6,7,12,8,13,2,10,3,8
+J,5,8,6,6,3,7,6,3,5,15,7,11,1,6,1,7
+O,4,4,5,6,2,7,7,8,8,6,5,7,3,8,4,8
+I,3,10,6,8,6,9,6,2,4,8,5,5,5,8,5,6
+A,5,9,8,6,6,9,5,2,5,8,1,6,3,7,4,7
+S,2,3,2,1,1,8,8,6,4,7,6,7,2,8,8,8
+P,7,12,6,6,4,8,9,4,4,12,5,4,4,10,6,6
+V,2,3,3,2,1,5,12,2,2,8,10,7,2,11,0,8
+V,4,11,6,8,4,6,11,2,3,6,11,9,2,10,1,8
+T,7,13,6,7,4,7,8,2,7,11,6,7,3,8,5,5
+M,6,8,9,7,10,9,8,5,4,7,6,7,13,10,7,5
+G,3,8,4,6,3,6,6,5,4,5,6,9,2,8,4,8
+D,5,10,8,8,5,9,6,3,7,11,4,6,3,8,3,9
+O,7,10,5,6,3,10,5,6,5,9,3,8,5,9,5,9
+T,1,0,2,1,0,7,14,1,4,7,10,8,0,8,0,8
+B,3,5,5,4,3,9,7,2,6,11,5,7,2,8,4,10
+L,2,6,2,4,1,0,1,5,6,0,0,6,0,8,0,8
+C,4,8,5,6,2,6,8,6,10,6,6,13,1,8,4,8
+X,6,11,9,8,5,7,7,1,9,10,6,8,3,8,4,7
+Y,2,6,4,4,0,9,10,2,2,6,12,8,1,11,0,8
+P,3,7,4,5,3,4,12,6,4,12,8,3,1,10,3,6
+B,5,11,5,6,5,8,7,3,4,9,6,7,6,7,8,7
+K,2,6,3,4,1,3,7,7,2,7,6,11,3,8,2,11
+Y,4,11,6,8,3,6,11,2,3,8,12,8,1,11,0,8
+Q,2,3,3,4,2,7,9,5,2,7,9,10,2,9,5,8
+P,7,13,6,7,4,9,8,4,5,13,4,4,4,10,6,6
+U,2,3,3,2,1,6,8,5,7,9,7,8,3,9,3,6
+R,4,8,6,6,5,6,8,5,6,7,5,7,6,7,5,8
+S,7,11,8,9,6,9,7,3,6,10,5,8,3,10,6,9
+X,5,10,7,8,6,8,7,3,5,6,7,6,4,10,10,9
+B,4,10,6,8,7,8,8,4,5,10,5,6,3,8,5,10
+A,5,11,8,8,4,10,2,2,3,9,1,8,2,7,3,7
+P,3,2,3,4,3,6,9,4,4,9,8,4,4,10,3,7
+K,4,2,5,3,3,5,7,4,8,7,6,11,3,8,5,9
+K,3,4,5,3,3,9,6,2,6,10,4,9,4,7,4,9
+A,2,4,4,5,2,8,6,3,1,7,0,8,2,7,2,8
+Y,4,11,6,8,4,7,9,2,6,6,12,9,2,11,2,8
+Q,7,9,7,11,8,7,10,4,4,7,10,11,5,11,10,9
+E,4,11,5,8,6,7,7,5,8,7,6,9,3,8,6,9
+W,5,8,5,6,4,1,10,3,3,11,11,9,5,11,1,7
+J,5,10,7,7,3,6,8,3,6,15,7,10,1,6,1,6
+C,7,9,7,7,3,3,8,4,9,10,10,13,1,7,3,7
+U,4,6,4,4,2,7,4,14,5,7,13,8,3,9,0,8
+H,3,4,5,2,2,7,6,3,5,10,6,9,3,7,3,8
+F,3,6,5,4,2,6,11,2,5,13,7,4,1,10,2,8
+S,5,10,6,8,5,7,7,5,8,5,6,11,1,10,10,9
+M,5,9,6,7,4,8,7,13,2,6,9,8,8,6,0,8
+G,7,10,7,8,5,5,7,6,6,9,7,12,2,9,4,10
+C,4,9,6,6,2,7,8,7,10,5,6,13,1,7,4,9
+W,4,7,6,5,3,5,8,4,1,7,9,8,8,9,0,8
+R,6,10,8,7,8,8,5,6,4,8,6,8,7,6,6,11
+R,5,8,7,6,6,6,7,6,6,6,5,7,3,8,5,8
+D,2,1,3,3,2,7,7,6,6,6,5,5,2,8,3,7
+T,3,9,4,6,1,8,15,1,6,6,11,8,0,8,0,8
+E,6,11,9,8,6,6,7,2,9,11,6,9,2,8,5,8
+O,5,6,7,5,4,7,5,4,5,9,5,8,3,6,5,7
+D,3,4,4,2,2,7,7,7,7,7,6,5,2,8,3,7
+R,4,6,5,4,4,7,7,5,7,7,6,6,3,7,5,8
+A,4,9,6,7,6,7,8,8,4,6,6,9,3,7,8,5
+M,4,5,7,4,4,6,6,3,4,9,9,10,7,5,2,8
+G,3,5,4,4,2,6,6,5,5,9,7,11,2,8,4,10
+X,3,10,5,7,4,7,7,3,8,6,6,8,3,8,7,7
+G,3,7,4,5,3,6,6,5,4,6,6,9,2,8,3,8
+Y,2,7,4,5,1,8,11,0,3,6,11,8,0,10,0,8
+N,8,11,11,8,5,7,8,3,5,10,6,7,7,9,2,7
+P,2,3,3,2,2,6,10,6,2,11,5,4,1,9,2,9
+D,5,10,5,5,3,9,5,4,5,12,3,8,5,7,5,10
+L,5,10,7,8,5,7,4,1,8,8,2,10,0,6,3,8
+G,5,5,6,7,3,7,7,8,7,6,6,7,2,7,7,11
+A,2,7,4,5,3,12,4,3,2,9,2,9,2,6,2,8
+Q,3,3,4,4,3,8,7,6,2,8,7,10,2,8,4,9
+N,3,4,4,6,2,7,7,14,2,5,6,8,6,8,0,8
+A,3,2,5,4,2,8,2,2,2,7,2,8,2,7,2,7
+C,2,3,2,2,1,4,8,4,6,11,9,11,1,9,2,7
+Z,2,3,2,1,1,8,7,5,8,6,6,7,1,8,6,8
+A,4,8,7,6,5,6,5,2,3,4,2,6,2,6,3,4
+I,3,9,5,6,3,7,7,0,7,13,6,9,0,8,1,8
+Y,3,5,4,4,2,5,9,1,8,10,9,5,2,10,4,4
+O,3,5,5,4,3,6,6,6,5,9,5,8,3,6,4,7
+S,4,9,4,4,2,8,3,3,4,8,2,8,3,6,5,8
+K,7,11,10,8,8,10,6,1,6,10,3,8,6,8,6,11
+D,2,1,3,2,2,7,7,6,6,7,6,5,2,8,2,7
+H,4,7,4,5,4,7,8,12,1,7,4,8,3,8,0,8
+K,2,6,3,4,1,3,7,7,3,7,7,11,3,8,2,10
+H,1,0,1,0,0,7,8,10,1,7,6,8,2,8,0,8
+Q,2,3,3,5,3,8,7,7,3,6,6,9,3,8,5,10
+S,5,9,7,6,3,8,8,4,8,11,6,7,2,8,5,7
+N,3,1,3,3,2,7,9,5,4,7,6,7,4,8,1,7
+X,5,6,7,4,3,7,8,1,8,10,6,8,3,8,3,7
+O,5,9,7,7,5,7,7,9,4,7,6,8,3,8,3,8
+A,1,0,2,0,0,7,4,2,0,7,2,8,2,7,1,8
+C,4,9,5,6,2,6,6,7,10,9,5,14,1,10,4,9
+X,4,10,7,8,6,6,8,2,6,7,6,10,4,6,7,7
+Q,5,10,7,8,7,8,5,8,3,6,7,8,4,7,7,8
+O,5,10,4,6,3,6,7,6,3,9,7,9,5,9,5,8
+S,4,6,5,4,3,7,7,3,7,10,5,7,2,8,5,8
+E,4,6,6,6,6,6,8,4,4,8,7,9,4,11,8,10
+I,1,6,2,4,2,7,7,1,8,7,6,9,0,8,3,8
+L,4,6,5,5,4,8,5,5,6,6,7,8,3,8,6,9
+X,5,9,8,7,6,6,8,3,6,7,7,11,5,6,8,6
+D,4,9,5,7,5,10,6,4,5,10,3,6,3,7,3,8
+C,5,10,6,8,2,6,7,7,10,7,6,15,1,8,4,9
+N,8,10,9,6,4,8,6,3,4,13,4,8,6,8,0,7
+Y,2,7,4,5,1,9,10,1,3,6,12,8,1,11,0,8
+T,5,7,5,5,3,7,10,1,10,11,9,5,1,9,4,4
+T,5,6,7,6,6,8,10,5,8,7,6,8,3,10,7,7
+M,5,11,9,8,12,10,6,3,3,8,4,7,11,6,5,4
+J,7,11,6,8,4,10,6,2,5,11,6,8,2,9,7,12
+J,2,5,3,3,1,10,5,2,6,14,4,9,0,7,0,8
+G,4,8,4,6,3,7,7,6,6,10,7,11,2,9,4,9
+I,2,8,3,6,1,7,7,0,7,13,6,8,0,8,1,8
+J,6,10,9,7,6,8,6,4,6,8,6,7,3,6,4,7
+E,4,10,6,8,4,7,7,3,8,11,7,9,3,8,5,8
+R,4,8,5,6,4,6,8,5,5,6,5,8,3,7,5,9
+X,4,9,7,7,5,8,7,3,8,5,6,8,2,8,6,8
+X,5,10,8,7,5,4,7,1,8,10,10,10,4,7,4,5
+Q,2,0,2,1,1,8,7,7,4,6,6,9,2,8,3,8
+K,2,7,3,4,1,4,8,8,2,6,4,11,3,8,2,10
+C,3,7,4,5,2,6,8,9,8,9,7,10,2,11,4,9
+N,5,6,7,6,6,6,9,4,3,6,5,9,8,7,5,9
+J,1,3,2,1,0,8,6,3,5,14,7,11,1,7,0,7
+U,4,8,5,6,5,8,8,7,6,5,8,9,6,8,3,7
+Q,2,3,3,4,2,8,8,5,2,7,8,10,2,9,4,8
+Z,4,6,5,4,3,6,9,3,9,11,8,6,1,8,6,6
+A,5,11,8,8,5,10,1,2,3,8,2,8,4,8,4,9
+N,6,5,6,8,3,7,7,15,2,4,6,8,6,8,0,8
+V,3,7,4,5,2,9,9,4,2,5,13,8,2,10,0,8
+S,3,2,3,3,2,8,8,7,5,8,5,7,2,8,8,8
+T,2,3,3,1,1,5,12,2,7,11,9,4,0,9,1,5
+X,4,6,6,4,3,7,7,1,8,10,8,8,3,8,3,7
+Y,5,10,7,7,4,4,10,2,8,11,12,9,3,9,2,6
+Q,6,14,6,8,4,10,3,4,7,11,3,8,3,9,6,13
+Q,4,9,5,8,3,8,9,8,6,6,9,9,3,7,6,10
+B,4,8,5,6,5,7,6,5,4,6,5,7,4,9,6,7
+L,9,14,8,8,4,10,2,4,4,13,5,13,2,7,6,9
+J,4,9,4,7,3,7,10,2,3,13,5,5,2,8,7,9
+P,6,9,8,7,7,6,7,7,5,8,7,8,3,9,7,9
+F,3,7,6,5,6,10,7,1,5,9,5,6,4,10,5,7
+S,5,8,6,6,7,8,9,5,4,8,5,6,4,10,9,7
+L,3,5,4,4,3,8,5,5,5,7,7,7,4,9,6,10
+D,2,4,4,3,2,8,7,4,6,10,4,5,2,8,2,8
+O,5,8,7,6,8,8,10,5,3,7,7,8,7,9,4,9
+B,2,3,3,1,2,7,8,5,5,7,6,6,1,8,5,9
+C,5,8,7,7,7,5,7,4,5,7,7,11,4,9,7,9
+D,6,9,8,7,5,10,6,4,9,11,3,6,3,8,3,9
+J,4,8,5,6,3,9,7,2,6,14,3,7,0,7,0,8
+T,2,4,3,3,2,7,12,3,6,7,11,8,2,11,1,8
+Y,3,3,4,2,1,4,11,2,7,11,10,5,1,11,2,5
+V,2,3,3,2,1,4,12,3,2,10,11,7,2,11,0,8
+V,4,11,6,8,9,7,6,5,2,8,7,9,8,10,4,9
+K,3,8,4,6,3,3,7,6,2,6,5,10,3,8,2,11
+C,3,9,4,7,2,5,7,7,10,7,6,13,1,9,4,9
+B,5,8,6,6,6,8,8,7,6,7,6,5,3,7,7,9
+Z,2,2,3,3,2,8,7,5,9,6,6,7,2,8,7,8
+W,8,8,8,6,5,4,11,3,3,9,9,7,8,11,2,6
+T,4,5,5,4,2,6,11,2,8,11,9,5,1,11,3,4
+Y,2,4,3,3,1,4,12,3,6,12,10,5,1,10,1,5
+A,2,6,4,4,2,11,3,2,2,9,2,9,2,6,2,8
+W,6,10,9,8,14,9,7,5,2,7,6,8,11,11,4,8
+J,5,10,7,8,4,10,2,6,5,15,5,13,0,7,0,7
+N,5,9,6,5,3,2,10,5,3,13,12,9,4,9,0,8
+R,2,3,2,1,1,7,7,4,5,6,5,7,2,7,4,8
+J,1,0,1,1,0,12,3,5,3,12,5,11,0,7,0,8
+Y,4,11,6,8,1,10,10,2,2,6,13,8,1,11,0,8
+X,4,9,5,7,3,7,7,4,4,7,6,7,3,8,4,8
+B,4,8,5,6,4,6,7,9,7,7,6,7,2,8,9,9
+W,2,3,4,2,2,7,11,2,2,7,9,8,5,11,0,8
+V,8,10,8,7,3,3,11,5,5,12,12,7,3,10,1,8
+M,7,9,10,7,6,4,7,3,5,10,10,10,8,5,2,7
+M,9,9,12,8,13,8,8,4,4,7,6,7,12,9,7,3
+D,4,8,6,6,8,9,8,5,6,7,6,6,4,7,8,8
+G,6,10,6,7,5,5,7,6,5,9,7,12,2,9,5,8
+O,3,7,3,5,2,8,7,8,5,9,4,6,3,8,3,8
+W,3,2,4,3,3,5,10,2,2,8,9,9,6,11,0,8
+B,3,2,4,3,3,8,7,5,6,7,6,6,2,8,6,10
+U,5,10,6,8,4,6,8,6,7,6,10,9,3,9,1,7
+A,6,11,11,8,8,7,5,2,5,5,1,6,6,8,6,6
+A,3,8,5,6,3,12,3,3,2,11,2,9,2,6,2,9
+Y,3,8,5,6,2,8,10,1,7,5,12,8,1,11,2,8
+H,4,7,5,5,4,8,6,13,1,7,7,8,3,8,0,8
+M,4,8,6,6,5,8,6,2,4,9,6,8,7,6,2,8
+N,5,7,6,6,6,8,6,5,4,7,5,8,7,9,6,3
+Q,3,6,4,5,3,8,7,7,5,6,7,9,2,8,4,9
+Z,5,11,7,8,4,9,6,3,10,12,4,8,1,7,6,9
+L,5,9,7,7,7,6,6,3,7,8,7,11,7,10,6,7
+R,4,8,5,6,6,7,7,7,3,8,5,7,4,7,7,10
+P,2,3,3,2,1,7,9,3,4,13,5,4,0,9,2,9
+V,4,9,6,7,1,7,8,4,3,7,14,8,3,9,0,8
+C,7,12,5,7,4,7,7,4,3,9,9,11,4,10,9,11
+Q,5,7,6,6,5,8,4,3,5,7,3,8,4,8,4,8
+L,2,1,2,3,1,4,4,4,6,2,2,6,0,7,1,6
+B,11,13,8,7,5,7,8,5,7,10,5,8,6,6,8,11
+S,5,8,6,7,7,8,8,4,5,7,7,8,5,10,10,9
+Y,8,15,7,8,4,6,8,5,3,10,9,5,4,10,4,4
+K,2,4,3,3,2,5,7,4,7,6,6,11,3,8,5,9
+B,3,7,3,5,4,6,6,8,5,6,7,7,2,9,7,10
+B,9,12,8,7,7,10,7,4,6,10,3,6,7,4,8,8
+K,4,6,6,4,4,7,6,1,6,10,6,9,3,8,3,8
+K,6,11,8,8,10,7,7,4,5,6,6,9,8,9,8,7
+N,8,12,10,7,4,12,4,3,3,13,1,7,5,7,0,8
+M,5,7,7,5,5,8,7,2,4,9,7,8,7,6,2,8
+S,5,7,7,6,8,7,8,5,5,7,7,7,5,9,11,12
+E,5,9,7,6,6,8,8,6,3,6,6,10,5,8,9,8
+U,6,13,6,7,5,6,6,5,5,7,8,8,5,8,3,9
+M,6,12,8,7,5,13,2,5,2,11,1,9,7,2,1,8
+D,5,10,6,8,7,7,7,6,6,7,6,5,3,8,3,7
+R,6,11,7,8,4,6,10,9,4,7,5,8,3,8,6,11
+I,1,6,0,4,0,7,7,5,3,7,6,8,0,8,0,8
+O,5,8,5,6,5,8,6,7,3,9,5,7,3,8,3,7
+M,5,10,7,8,9,7,9,6,5,7,6,8,7,9,6,10
+R,1,1,2,1,1,6,9,7,3,7,5,8,2,7,4,11
+T,2,1,2,1,0,8,15,1,4,6,10,8,0,8,0,8
+E,4,8,6,6,6,6,8,6,8,6,4,11,3,8,6,9
+H,5,5,6,7,3,7,7,15,0,7,6,8,3,8,0,8
+W,4,3,4,1,2,3,11,3,2,10,10,8,6,11,1,7
+U,3,2,4,4,2,6,8,5,7,6,9,9,3,9,1,7
+A,4,10,7,8,4,14,3,4,3,12,0,8,2,6,2,9
+L,5,9,6,8,5,8,8,3,6,6,6,9,3,8,7,9
+T,3,6,3,4,2,5,12,4,5,11,9,5,2,12,1,5
+V,8,11,8,8,5,3,12,2,3,9,11,8,6,11,3,6
+T,2,1,3,2,2,7,12,3,6,7,10,8,2,11,1,8
+T,7,10,7,8,6,6,11,4,6,11,9,5,3,12,2,4
+J,2,5,4,4,2,9,7,2,6,14,5,9,1,6,1,8
+E,3,5,4,4,3,7,7,6,8,7,6,9,2,8,6,9
+N,5,4,5,7,3,7,7,15,2,4,6,8,6,8,0,8
+B,6,9,8,6,7,9,8,3,6,10,5,5,3,7,5,9
+R,5,10,7,8,7,7,8,5,6,7,5,6,6,7,5,8
+H,4,5,4,8,3,7,8,15,1,7,5,8,3,8,0,8
+F,4,8,4,5,1,1,15,5,3,13,10,5,0,8,2,5
+F,7,10,9,8,4,6,11,3,6,14,6,3,2,10,2,7
+P,4,9,4,4,3,8,8,3,4,12,5,4,3,11,5,7
+P,3,6,3,4,2,4,12,7,1,10,6,4,1,10,3,8
+N,7,9,6,4,2,7,10,4,5,4,5,10,5,9,2,7
+Z,2,6,3,4,2,7,7,3,12,8,6,8,0,8,7,8
+F,1,0,1,1,0,3,12,4,3,11,9,6,0,8,2,7
+B,1,0,1,0,0,7,7,6,4,7,6,7,1,8,5,9
+U,1,0,1,0,0,7,6,10,4,7,12,8,3,10,0,8
+H,3,5,4,4,4,9,7,6,6,7,6,6,3,8,3,7
+D,3,8,4,6,2,6,7,10,9,6,6,6,3,8,4,8
+P,3,8,3,6,3,5,11,8,2,9,5,4,1,9,3,7
+M,5,8,5,6,5,8,5,11,0,7,8,8,7,5,0,8
+O,3,6,5,4,5,8,6,5,2,7,6,8,7,9,3,9
+D,5,8,6,7,6,6,7,5,6,7,5,9,5,4,8,4
+B,8,12,6,6,4,8,6,5,5,11,5,9,6,6,7,11
+N,4,2,5,4,3,7,8,5,6,7,6,5,6,9,2,6
+T,2,7,4,5,2,6,11,2,8,8,11,8,1,10,1,7
+D,1,4,3,2,2,9,6,3,5,10,5,6,2,8,2,8
+E,2,1,2,2,2,7,7,5,7,6,5,8,2,8,6,10
+G,4,7,5,5,3,5,7,5,5,9,8,10,2,8,4,9
+Y,3,10,5,7,1,7,10,2,2,7,13,8,2,11,0,8
+H,3,4,4,6,4,11,5,2,2,8,5,9,3,8,5,11
+E,4,9,3,5,3,8,6,3,5,10,5,8,3,9,8,11
+J,4,10,6,8,5,7,8,4,5,8,7,7,3,7,4,6
+X,4,7,5,5,4,8,7,3,8,6,5,6,3,9,6,8
+M,6,9,9,7,11,6,5,4,2,6,4,9,14,6,4,6
+C,3,4,5,7,2,5,7,7,10,7,6,12,1,9,4,9
+G,5,11,6,8,5,5,7,6,5,8,7,12,4,7,5,8
+I,2,10,2,8,3,7,7,0,8,7,6,8,0,8,3,8
+W,4,8,7,6,6,7,11,2,2,6,8,8,7,12,1,8
+W,3,8,5,6,4,9,10,2,2,6,8,8,7,11,1,8
+L,4,8,5,7,5,8,5,5,5,7,7,8,3,8,7,11
+T,3,4,4,2,1,5,13,3,6,12,9,3,1,10,1,5
+Z,3,8,4,6,3,7,8,3,11,8,6,8,0,8,7,7
+E,3,4,4,6,2,3,8,6,11,7,5,15,0,8,7,7
+P,5,11,5,8,4,3,13,7,1,11,6,3,0,10,3,8
+I,0,1,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+S,7,11,8,8,4,7,8,4,8,11,7,8,2,9,6,6
+D,6,11,6,8,4,5,7,10,10,7,6,6,3,8,4,8
+H,4,7,6,5,4,6,8,3,6,10,8,9,3,8,3,7
+H,7,10,10,8,6,10,6,3,6,10,3,7,5,7,5,9
+U,4,9,6,6,5,6,8,8,5,6,5,12,5,8,7,4
+N,2,2,3,3,2,7,9,5,4,7,6,6,4,9,1,6
+O,2,4,3,2,2,7,7,7,4,9,6,8,2,8,3,8
+D,5,9,6,6,5,5,8,9,7,7,7,6,2,8,3,8
+M,4,6,5,4,4,7,5,11,0,7,9,8,8,6,1,8
+Z,4,5,6,7,4,11,4,4,4,10,3,9,2,7,5,10
+E,5,7,7,5,4,6,8,2,9,11,6,9,2,8,4,8
+Q,4,5,5,6,4,8,8,5,2,8,8,10,3,9,5,7
+N,5,8,7,6,5,8,8,6,6,6,5,3,8,10,5,8
+T,5,10,7,7,8,6,7,3,6,7,7,10,5,8,5,6
+R,2,3,3,2,2,8,8,3,5,9,4,7,2,7,3,10
+R,6,10,8,8,6,7,9,5,7,5,4,9,4,4,7,8
+C,7,9,8,8,8,5,7,4,5,7,6,11,5,9,8,9
+L,5,11,6,9,5,4,3,8,7,1,2,4,1,6,1,6
+G,4,7,6,5,3,7,6,7,8,8,5,12,2,10,4,8
+N,4,8,6,7,6,6,8,5,3,6,5,9,8,7,5,9
+N,4,8,5,6,4,7,7,13,1,6,6,8,5,8,0,8
+G,4,8,4,6,3,6,7,6,5,9,8,10,2,7,4,9
+C,6,10,8,8,5,8,7,8,7,7,6,9,4,8,4,9
+D,5,8,6,6,6,10,6,5,6,9,3,6,3,8,3,8
+R,9,15,9,8,7,9,7,4,6,9,2,7,6,5,7,7
+B,4,10,4,8,6,7,6,9,6,6,7,7,2,9,8,10
+W,7,9,9,7,6,7,8,4,1,7,9,8,8,10,0,8
+F,3,2,4,3,2,6,10,4,6,10,8,5,4,9,3,7
+D,2,4,3,3,2,8,7,5,6,9,5,5,2,8,3,7
+L,4,11,6,8,3,4,4,4,9,2,0,6,0,7,1,5
+R,2,0,2,1,1,6,10,7,2,7,5,8,2,7,4,10
+W,5,11,7,8,4,5,8,5,2,7,8,8,8,10,0,8
+B,4,9,4,7,4,7,7,10,7,7,6,7,2,8,9,9
+A,4,7,6,5,6,8,5,7,4,8,6,8,5,9,7,4
+W,4,9,7,6,5,7,8,4,1,7,9,8,7,11,0,8
+C,5,10,6,8,4,5,8,9,9,9,9,12,2,10,4,9
+Y,3,6,4,4,2,3,11,2,7,11,10,6,1,11,2,5
+A,4,10,7,8,5,12,3,2,2,9,2,8,2,6,2,8
+M,6,11,10,8,14,8,7,3,3,8,4,7,12,4,4,6
+Z,4,8,5,6,4,7,8,2,9,11,7,8,1,9,6,7
+Y,5,7,5,5,3,3,10,2,7,11,11,7,1,11,2,5
+H,4,2,5,4,4,9,7,6,6,7,6,6,3,8,3,7
+R,4,9,6,7,6,6,7,3,4,7,6,8,6,10,7,5
+S,3,9,4,7,2,7,6,6,9,4,6,9,0,9,9,8
+B,2,0,2,1,1,7,7,7,5,7,6,7,1,8,7,8
+F,5,5,5,8,2,1,14,5,3,12,10,5,0,8,2,5
+T,8,11,8,8,7,6,11,3,7,11,9,5,5,11,4,3
+H,5,9,8,7,8,8,7,5,7,7,6,9,6,8,4,8
+C,2,3,3,2,1,5,9,5,7,12,9,10,1,10,2,7
+D,5,11,5,8,3,5,8,11,9,7,7,5,3,8,4,8
+T,3,5,4,4,2,7,12,2,8,7,11,8,1,11,1,7
+A,1,0,2,0,0,8,3,2,0,7,2,8,2,6,1,8
+I,1,1,1,3,1,7,7,1,7,7,6,8,0,8,2,8
+A,4,9,6,7,4,13,2,4,2,11,1,8,3,7,3,9
+H,7,9,7,4,4,7,8,3,5,11,7,8,6,9,4,8
+T,6,8,7,6,8,6,8,4,6,8,6,9,5,8,5,7
+T,5,10,7,8,6,6,7,7,7,6,8,9,4,10,7,6
+F,4,10,4,7,2,1,11,5,6,11,11,9,0,8,2,6
+Q,2,5,3,6,3,8,8,7,2,4,6,10,3,9,5,9
+U,5,9,5,5,3,8,6,4,5,6,7,8,4,8,3,7
+O,6,5,7,8,3,7,6,8,9,6,5,7,3,8,4,8
+M,3,4,5,3,3,8,6,2,4,8,5,7,8,7,2,8
+V,4,10,6,8,4,7,11,1,3,6,10,9,3,11,1,8
+R,3,4,4,6,3,5,11,8,4,7,2,9,3,7,6,11
+S,2,1,2,2,1,8,7,6,5,7,7,8,2,9,8,8
+R,7,11,9,8,7,9,8,6,6,8,5,7,4,8,6,12
+K,8,10,8,5,3,10,7,4,7,8,1,5,5,7,4,9
+R,5,9,8,6,8,6,6,3,4,7,5,8,7,10,7,6
+W,6,8,6,6,5,4,10,2,3,9,9,8,7,11,2,6
+X,7,10,9,8,8,7,6,3,5,6,6,10,5,5,12,10
+A,3,10,5,7,4,11,3,2,2,9,2,10,3,7,3,8
+Y,3,7,4,5,2,7,10,1,7,6,12,8,1,11,2,8
+P,5,7,6,9,8,7,8,4,3,7,7,7,7,12,6,7
+U,4,6,5,4,4,7,7,8,6,7,6,10,3,9,5,5
+S,3,4,4,7,2,9,8,6,9,4,6,7,0,7,9,8
+P,1,0,1,0,0,5,11,6,1,9,6,5,0,9,2,8
+U,3,2,4,4,2,5,8,6,6,8,10,10,3,9,0,8
+D,7,11,7,6,4,10,4,6,6,13,4,10,5,7,5,9
+Y,7,7,9,10,9,10,12,6,4,6,7,6,5,10,8,5
+H,3,4,5,3,3,8,7,3,6,10,4,8,3,7,3,8
+G,3,4,4,7,2,6,5,8,8,6,5,10,1,8,6,11
+V,5,7,7,6,7,6,9,6,6,8,7,8,5,9,6,11
+G,2,0,2,1,1,8,6,6,5,6,5,9,1,8,5,10
+X,9,12,8,6,4,7,7,2,9,9,5,8,4,5,4,8
+R,7,10,9,8,7,8,8,5,6,9,5,7,4,7,6,12
+U,4,10,5,8,2,7,5,14,5,7,15,8,3,9,0,8
+C,5,10,7,8,8,7,5,4,4,8,6,11,7,9,4,8
+O,5,9,6,7,3,7,7,9,8,7,6,8,3,8,4,8
+V,9,12,8,7,4,5,10,4,4,10,8,5,4,11,2,8
+M,3,7,4,5,3,7,7,11,1,7,9,8,8,5,0,8
+W,6,5,7,4,4,5,11,4,2,9,8,7,7,11,2,6
+R,5,11,6,8,4,6,9,10,6,6,5,8,3,8,6,10
+V,4,9,6,7,2,7,8,4,3,7,14,8,3,9,0,8
+M,4,4,5,6,3,7,7,12,1,7,9,8,8,6,0,8
+Y,2,1,4,2,1,7,11,1,7,7,11,8,1,11,2,8
+V,5,7,5,5,3,3,11,2,3,10,11,8,2,11,1,8
+C,6,9,7,7,3,3,9,5,8,10,10,12,1,8,3,7
+F,0,0,1,0,0,3,12,4,2,11,9,6,0,8,2,8
+T,4,5,5,4,3,6,11,2,8,11,9,5,3,10,4,4
+Z,3,7,4,5,4,6,6,3,7,7,6,10,1,7,10,7
+W,3,7,5,5,5,7,11,2,2,6,8,8,6,11,1,8
+E,4,9,6,6,5,8,7,1,7,11,5,9,3,8,5,10
+X,4,6,6,4,4,9,8,3,5,7,7,7,4,11,6,7
+X,3,3,5,2,2,5,8,2,8,11,9,9,2,9,3,6
+S,5,10,6,7,4,6,8,3,6,10,8,7,2,8,5,5
+F,6,9,8,7,4,3,13,4,5,13,9,4,1,10,2,6
+X,3,4,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+B,4,8,6,6,6,8,7,4,5,7,6,7,4,8,6,9
+T,5,7,5,5,2,5,12,2,8,12,9,4,1,10,2,4
+G,3,6,3,4,2,7,7,6,6,10,7,11,2,9,4,10
+T,2,6,3,4,2,9,11,3,7,5,11,8,2,11,1,8
+J,2,5,4,3,1,7,7,3,6,14,6,10,1,6,1,7
+M,5,5,7,4,6,9,8,4,5,6,6,7,8,6,6,5
+Y,5,8,6,6,6,9,6,5,4,7,9,7,3,8,8,4
+E,6,9,8,8,8,5,8,4,4,8,7,9,4,10,9,10
+Q,6,11,8,8,8,8,6,8,3,6,8,9,5,5,8,9
+K,7,12,6,7,3,9,7,3,6,9,6,7,6,10,4,7
+Z,4,8,6,6,4,8,7,2,9,12,6,7,1,7,6,8
+U,4,7,5,5,2,4,8,5,6,11,11,10,3,9,1,7
+W,10,11,10,8,7,1,11,3,3,11,11,9,8,10,1,7
+N,4,8,6,6,6,7,9,3,4,7,6,7,6,8,6,4
+F,4,10,4,7,2,1,14,5,4,13,10,5,0,8,2,5
+Q,3,5,4,5,2,8,8,7,5,6,7,8,3,8,5,9
+D,8,11,8,6,4,10,3,6,5,13,4,11,5,7,5,9
+N,4,6,5,4,3,11,7,4,5,10,1,4,5,9,1,7
+P,7,11,10,8,7,9,7,3,6,12,4,5,5,9,5,9
+C,3,6,4,4,1,5,6,6,9,7,5,11,1,9,4,8
+K,6,11,6,8,3,4,8,8,2,7,4,11,4,8,2,11
+Q,1,2,2,3,2,8,8,5,2,8,7,9,2,9,3,9
+O,4,7,5,5,6,9,7,6,1,7,7,9,7,9,3,9
+T,4,6,5,4,5,7,8,4,6,7,6,8,5,7,5,6
+Z,3,10,4,7,3,7,8,3,11,9,6,8,0,8,7,8
+G,3,3,4,5,2,7,8,8,7,6,7,8,2,7,5,10
+Q,5,9,6,11,6,8,7,6,3,8,8,11,3,8,6,8
+X,4,9,6,7,5,8,6,3,5,6,7,7,2,8,9,9
+Q,3,3,4,5,4,8,7,7,3,5,7,9,3,8,5,10
+L,3,2,4,4,1,5,2,7,8,1,3,2,1,6,1,5
+I,3,9,5,6,5,9,5,3,5,7,6,5,6,6,5,6
+U,9,13,8,7,5,8,5,5,5,6,9,8,5,9,3,8
+U,3,1,4,2,2,6,8,6,7,7,9,9,3,9,1,8
+B,4,8,5,6,6,8,7,7,6,7,6,5,2,8,7,9
+D,4,8,6,6,4,9,6,3,7,11,4,6,3,9,4,9
+S,3,5,5,4,2,8,7,3,7,10,6,7,1,9,5,8
+Z,1,0,1,0,0,8,7,2,9,8,6,8,0,8,5,8
+R,6,11,6,8,4,5,13,8,3,7,2,9,3,7,6,11
+B,5,11,7,8,8,7,8,6,4,6,4,6,5,7,7,7
+U,5,8,5,6,3,3,8,4,6,10,10,9,3,9,1,7
+Q,6,7,6,8,5,7,7,7,5,9,9,9,4,8,7,9
+G,6,10,7,8,5,6,7,7,7,5,7,10,2,7,4,8
+Y,4,10,7,7,3,7,10,1,8,7,12,8,1,11,2,8
+N,2,3,3,1,1,8,8,2,4,11,5,6,4,8,0,7
+Z,4,6,6,4,3,8,6,2,9,11,5,9,1,8,5,9
+N,3,8,4,6,4,7,7,12,1,6,6,8,5,8,0,8
+R,3,8,5,6,3,9,8,4,6,9,3,8,3,6,4,11
+B,2,3,3,2,2,8,7,2,5,10,5,6,2,8,4,9
+I,3,9,4,6,3,7,7,0,7,13,6,8,0,8,1,8
+E,1,1,1,1,1,4,8,5,7,7,6,12,0,8,6,10
+X,2,3,3,2,1,5,8,2,7,10,10,9,2,9,2,6
+F,7,13,6,7,4,8,9,2,5,11,5,4,3,10,7,7
+N,4,7,6,5,3,5,9,3,4,10,8,8,5,9,1,7
+T,9,15,8,8,5,8,8,3,9,12,5,6,3,7,6,6
+U,9,10,9,8,7,5,7,5,9,8,6,9,8,9,6,1
+I,4,9,5,7,3,7,8,2,8,7,6,8,0,7,4,8
+P,4,5,5,6,6,6,8,5,2,7,7,6,6,11,5,7
+H,3,5,4,3,3,7,7,6,6,7,6,8,3,8,4,8
+F,3,6,5,4,4,6,8,6,3,8,6,9,3,10,8,11
+S,4,5,5,7,3,7,6,6,9,5,6,10,0,9,9,8
+A,4,9,7,7,5,8,5,2,4,6,1,5,3,5,4,5
+X,6,9,9,7,4,10,5,2,8,11,1,7,3,8,4,9
+X,2,8,4,6,3,7,7,4,8,6,6,8,3,8,6,8
+A,4,9,6,7,6,8,6,6,4,7,6,9,5,8,7,3
+M,5,9,7,7,8,8,7,6,4,6,7,8,8,6,2,7
+R,4,6,5,4,3,8,9,5,6,8,5,8,3,7,5,10
+L,3,7,4,5,2,5,4,4,9,3,2,6,1,6,2,5
+G,2,4,3,3,2,6,7,5,5,9,7,10,2,8,4,9
+U,9,11,9,8,6,3,8,5,8,11,10,10,3,9,2,6
+U,5,7,5,5,3,4,8,6,6,9,8,9,3,9,3,5
+R,5,11,7,8,5,9,8,4,6,10,3,7,3,7,4,11
+M,6,10,7,8,4,7,7,13,2,7,9,8,9,6,0,8
+J,3,5,5,4,2,9,6,3,6,14,5,10,1,6,0,7
+C,5,9,6,7,3,5,8,7,8,7,8,14,2,9,4,9
+C,1,0,2,0,0,7,7,6,8,7,6,13,0,8,4,10
+O,4,8,5,6,3,8,7,8,4,7,6,6,3,8,3,7
+H,4,6,5,4,3,10,6,4,6,10,3,7,3,8,3,10
+N,6,9,5,5,3,8,11,5,4,4,6,10,6,11,2,6
+C,6,9,7,7,7,6,7,3,4,6,7,10,7,8,6,7
+G,5,7,6,6,7,7,9,5,2,7,7,8,6,11,7,8
+L,5,11,6,8,5,8,4,0,8,9,2,11,2,5,4,9
+I,1,10,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+Q,4,6,6,5,4,7,4,3,4,5,3,7,3,6,4,7
+H,4,2,5,4,4,8,7,6,7,7,6,8,6,8,4,7
+E,3,1,3,3,2,7,7,5,8,7,7,8,2,8,6,9
+V,3,4,4,3,1,4,12,3,3,10,11,7,2,11,1,8
+Y,4,5,6,7,8,7,8,3,2,8,8,9,4,11,8,5
+H,5,5,5,7,3,7,7,15,1,7,7,8,3,8,0,8
+V,6,8,5,6,3,3,12,3,3,10,11,8,2,11,1,8
+J,5,9,6,7,4,10,4,6,5,8,6,5,2,8,4,6
+U,4,4,5,3,2,4,8,5,7,10,9,9,3,9,2,5
+C,3,5,5,4,4,6,7,4,4,6,6,11,4,10,7,11
+V,3,9,5,7,2,7,11,3,4,9,12,8,3,10,1,9
+I,4,7,6,8,6,8,8,5,6,7,5,8,3,9,8,9
+T,1,0,2,0,0,7,14,2,3,7,10,8,0,8,0,8
+F,3,5,5,3,2,6,12,4,5,13,6,2,1,10,2,6
+V,9,14,8,8,5,6,8,4,4,8,8,5,6,12,3,8
+S,1,0,1,1,0,8,7,4,6,5,6,7,0,8,7,8
+W,6,5,8,5,9,8,7,5,5,7,5,8,9,9,7,9
+W,6,9,8,7,7,8,4,6,2,7,6,7,7,7,6,5
+J,2,8,2,6,1,14,3,4,5,12,1,9,0,7,0,8
+T,1,0,2,0,0,7,15,2,4,7,10,8,0,8,0,8
+I,0,0,0,1,0,7,7,4,4,7,6,8,0,8,0,8
+R,6,11,9,8,8,10,7,3,6,10,3,6,3,7,4,10
+I,1,3,2,2,1,7,7,1,7,13,6,8,0,8,1,8
+S,3,3,4,4,2,8,8,6,8,5,6,7,0,8,9,7
+W,5,8,5,6,4,7,10,4,2,8,6,6,6,11,2,6
+F,2,1,3,2,2,5,11,3,5,11,9,5,1,10,3,6
+C,2,0,2,1,0,6,7,6,9,7,6,14,0,8,4,10
+F,3,5,5,4,2,7,10,1,6,13,6,5,3,8,3,7
+U,4,9,5,7,2,7,5,13,5,7,14,8,3,9,0,8
+J,3,9,4,7,1,11,2,11,3,12,9,14,1,6,0,8
+T,3,4,4,6,1,6,15,1,6,8,11,7,0,8,0,8
+N,5,9,7,7,5,4,9,3,4,9,10,9,6,7,1,8
+X,3,8,5,6,3,5,8,2,8,10,10,9,3,9,3,6
+J,5,9,6,6,2,8,3,6,4,14,9,15,1,6,1,6
+O,3,8,4,6,2,7,6,8,7,7,4,8,3,8,4,8
+J,2,4,4,3,1,9,4,4,5,14,6,12,0,7,0,8
+Z,4,5,6,7,4,11,4,4,5,10,3,9,2,7,6,10
+N,7,9,10,7,5,10,8,3,6,11,1,3,5,9,1,7
+P,2,4,4,3,2,7,8,3,4,12,5,4,1,10,2,8
+S,1,3,3,2,1,7,7,3,7,10,5,8,1,8,4,8
+H,4,4,6,3,3,7,7,3,6,10,7,8,5,9,4,8
+T,1,0,2,0,0,7,14,2,3,7,10,8,0,8,0,8
+Y,2,3,4,5,1,7,10,1,3,7,12,8,1,11,0,8
+X,6,10,10,8,5,9,6,1,8,10,3,7,3,8,4,9
+P,4,4,4,6,2,4,12,8,2,10,6,4,1,10,4,8
+A,4,7,5,5,5,7,6,8,4,7,5,8,4,8,10,2
+P,4,6,6,4,3,6,11,5,3,11,5,3,1,10,3,8
+F,2,5,4,4,2,8,9,2,6,13,5,5,1,9,2,8
+Z,1,1,2,2,0,7,7,2,11,9,6,8,0,8,6,8
+C,4,5,5,4,2,4,9,5,8,12,10,12,1,8,2,7
+H,6,7,9,5,5,9,6,3,7,10,5,8,3,8,3,8
+M,10,11,10,6,5,7,11,5,5,4,4,10,9,10,2,7
+N,4,5,5,8,3,7,7,14,2,4,6,8,6,8,0,8
+R,2,6,3,4,3,5,10,7,3,7,4,9,2,6,4,11
+X,4,9,5,6,1,7,7,5,4,7,6,8,3,8,4,8
+W,4,7,7,5,5,9,12,2,2,6,8,8,8,13,1,7
+P,4,9,6,6,3,4,13,5,4,13,6,2,0,9,4,7
+P,6,6,6,8,3,3,14,8,1,11,6,3,1,10,4,8
+S,6,10,8,7,5,8,8,3,7,10,5,7,2,8,5,8
+F,3,8,3,6,2,1,11,3,4,11,11,9,0,8,2,7
+Z,3,5,5,4,3,7,8,2,9,12,6,8,1,8,5,7
+M,6,10,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+K,7,13,7,8,4,6,7,3,6,9,9,10,6,10,3,7
+I,6,8,7,6,4,5,6,3,7,7,6,12,0,9,4,8
+V,3,5,4,3,1,4,12,3,3,10,11,7,2,10,1,8
+J,6,10,5,7,3,7,10,2,3,12,5,5,2,8,7,9
+R,4,8,7,7,7,6,8,4,3,6,5,9,8,7,6,9
+U,5,4,6,7,2,7,4,14,6,7,15,8,3,9,0,8
+Z,5,10,5,5,3,5,8,2,9,11,8,8,3,6,6,5
+W,4,2,5,3,3,5,11,3,2,8,9,9,7,10,1,8
+W,7,7,7,5,4,4,10,3,3,10,9,8,7,11,2,6
+Q,4,7,6,5,5,8,5,7,4,6,7,9,3,7,6,9
+P,6,9,5,4,2,5,12,5,1,12,6,4,4,10,3,8
+M,3,1,4,3,3,6,6,6,4,7,7,10,7,5,2,9
+E,3,5,5,4,5,7,6,4,3,7,6,9,5,10,7,12
+U,5,7,5,5,3,4,8,5,7,9,8,9,4,8,3,4
+G,4,7,4,5,2,6,7,6,5,9,8,10,2,8,4,9
+Z,4,10,6,8,4,6,9,2,9,11,8,7,2,10,7,6
+L,5,8,7,7,6,7,7,4,5,6,7,9,3,9,8,7
+F,3,5,5,3,2,6,12,3,5,13,7,3,1,10,2,6
+M,2,3,3,1,2,8,7,6,3,6,7,8,6,5,1,7
+J,4,11,5,8,3,9,7,2,7,15,4,8,0,6,1,7
+D,2,6,3,4,2,5,7,10,7,7,6,5,3,8,3,8
+X,4,9,6,7,4,8,7,4,9,6,7,8,4,6,8,9
+U,3,5,4,4,4,8,6,5,4,6,6,8,3,9,1,7
+V,4,6,6,5,6,7,7,5,4,7,6,8,6,9,7,8
+Q,4,9,5,11,7,8,6,8,4,5,6,7,4,8,6,10
+J,2,7,4,5,4,8,8,3,3,8,5,6,4,8,5,4
+S,2,7,3,5,2,6,7,5,8,6,7,11,0,9,8,7
+B,2,3,4,2,2,9,7,2,5,11,5,7,2,8,4,9
+N,4,7,4,5,2,7,7,14,2,5,6,8,6,8,0,8
+F,2,5,4,4,2,5,12,3,5,13,7,4,1,9,2,6
+Z,4,7,6,9,4,11,4,2,6,9,2,6,1,8,6,9
+S,5,9,6,6,4,6,8,4,6,10,9,8,2,8,5,5
+P,2,1,2,1,1,5,11,7,2,9,6,4,1,9,3,8
+H,4,5,7,4,4,8,6,3,6,10,5,8,5,7,4,8
+O,3,4,4,3,2,8,7,7,4,9,6,8,2,8,3,8
+H,5,7,8,5,5,7,7,3,6,10,7,8,3,9,3,7
+Q,5,10,6,9,5,8,8,8,5,5,8,10,4,7,6,8
+L,5,10,7,8,5,8,4,1,7,9,2,9,1,6,3,9
+X,4,6,7,4,3,7,7,2,8,10,7,9,3,8,3,7
+F,4,8,6,6,4,4,11,2,6,11,10,6,1,10,3,6
+Q,2,6,3,5,3,7,7,8,6,5,4,6,2,8,3,7
+L,1,0,1,0,0,2,1,6,4,0,3,4,0,8,0,8
+P,5,10,7,8,6,8,10,7,4,10,4,3,3,11,4,8
+Z,2,4,4,3,1,8,6,2,10,11,5,9,1,8,6,9
+J,0,0,1,0,0,12,4,4,3,11,4,11,0,7,0,8
+D,1,1,2,1,1,6,7,8,6,6,6,6,2,8,3,8
+K,4,6,6,4,4,7,8,4,8,7,5,7,3,8,5,8
+T,3,9,5,6,1,5,15,1,6,9,11,7,0,8,0,8
+C,6,9,7,7,7,8,5,6,3,7,8,11,8,9,5,4
+U,2,3,3,2,1,6,8,6,6,7,9,9,3,9,0,8
+Z,4,4,4,6,2,7,7,4,14,9,6,8,0,8,8,8
+F,6,11,10,8,10,6,10,1,5,10,7,5,6,10,5,2
+M,4,4,5,3,4,9,6,6,4,6,7,5,9,5,3,6
+Y,1,0,1,0,0,8,10,1,3,6,11,8,1,11,0,8
+Q,4,8,5,10,7,8,6,8,3,6,5,9,3,9,5,10
+O,7,10,7,8,7,7,8,8,4,10,7,8,3,8,3,8
+X,7,9,7,5,3,8,7,2,8,9,6,8,4,10,4,8
+B,3,7,4,5,4,9,7,3,5,7,6,7,3,9,4,8
+O,9,13,6,7,4,6,6,7,4,10,7,9,5,9,5,8
+U,4,11,5,8,4,7,6,12,4,7,12,8,3,9,0,8
+U,5,11,6,8,5,6,9,5,6,6,9,10,5,11,1,8
+Y,6,11,9,8,5,7,10,1,8,6,12,9,4,10,3,7
+B,1,3,2,2,1,8,7,3,5,10,5,7,2,8,4,9
+D,5,11,7,8,5,11,5,4,7,10,2,6,3,8,3,9
+Q,4,9,6,8,5,8,9,7,4,6,9,9,3,8,7,10
+Y,3,5,6,7,1,9,10,3,2,6,13,8,2,11,0,8
+G,2,6,3,4,2,7,7,7,6,6,6,8,2,7,6,11
+E,4,8,6,7,7,5,8,4,4,8,7,9,5,11,9,11
+N,3,4,5,3,2,7,9,2,4,10,6,7,5,8,0,7
+V,4,8,6,6,3,8,12,2,3,5,11,9,5,11,3,6
+U,1,0,2,1,0,8,6,11,4,7,12,8,3,10,0,8
+K,5,9,7,7,6,10,6,1,6,10,3,8,4,9,4,11
+V,3,8,5,6,2,7,11,3,4,6,12,8,3,10,1,8
+L,8,13,8,8,5,7,4,3,5,11,6,12,4,6,7,8
+F,4,10,4,7,2,1,13,5,3,12,10,6,0,8,3,6
+Z,2,1,2,1,1,7,7,3,11,8,6,8,0,8,6,8
+I,2,7,3,5,1,6,8,1,8,14,7,7,0,8,1,7
+D,6,8,8,6,5,7,9,8,6,9,7,5,5,9,4,9
+X,3,7,4,5,2,7,7,4,4,7,6,8,2,8,4,8
+X,3,6,5,4,3,8,7,3,8,5,6,8,2,8,6,8
+G,2,1,4,3,2,6,7,6,6,6,6,10,2,8,3,9
+Y,5,10,7,8,3,8,10,3,2,6,12,8,2,11,0,8
+E,2,1,2,3,2,7,7,5,6,7,6,9,2,8,5,10
+D,3,7,5,5,6,9,8,4,4,7,6,5,4,9,7,5
+X,3,7,4,4,1,7,7,4,4,7,6,8,3,8,4,8
+N,6,7,8,6,8,8,8,5,5,8,5,6,6,9,7,3
+P,3,6,5,9,7,8,13,3,1,9,8,6,4,11,2,7
+F,5,9,8,7,8,10,7,1,5,9,5,5,6,10,5,8
+F,4,7,6,5,6,6,9,1,4,10,7,7,5,10,3,4
+R,1,3,2,1,1,7,8,4,4,7,5,6,2,7,3,8
+P,5,9,6,6,6,7,9,4,6,8,7,4,5,10,4,7
+A,1,0,2,0,0,7,4,2,0,7,2,8,2,7,1,8
+X,3,5,4,3,2,7,7,3,9,6,6,8,3,8,6,7
+A,7,14,7,8,6,10,3,5,2,10,5,12,7,1,6,11
+L,3,9,3,7,2,0,2,3,6,1,0,8,0,8,0,8
+Y,4,11,6,8,3,10,10,1,3,6,12,8,1,11,0,8
+P,5,10,7,8,6,6,9,2,7,9,8,4,4,10,4,7
+W,1,0,2,0,0,7,8,3,0,7,8,8,5,9,0,8
+B,4,3,4,5,3,6,9,8,7,7,5,6,2,8,9,9
+Y,4,5,5,3,2,4,11,2,7,12,10,5,1,11,2,4
+K,5,9,7,6,6,5,7,1,6,9,8,10,4,7,3,8
+I,4,11,3,6,2,10,5,4,4,12,3,7,3,8,5,10
+S,4,8,5,6,4,8,7,5,8,5,6,7,0,8,8,8
+I,1,5,0,8,0,7,7,4,4,7,6,8,0,8,0,8
+J,2,11,3,8,3,10,7,1,6,11,3,7,1,6,2,6
+X,3,1,5,3,2,8,7,4,9,6,6,8,2,8,6,8
+H,11,14,11,8,8,6,9,3,5,10,5,9,7,6,5,6
+G,7,11,7,8,6,6,6,6,6,10,7,12,2,10,4,10
+Y,5,7,5,5,2,2,12,4,5,13,11,6,1,11,1,6
+Y,1,0,2,0,0,8,10,3,1,6,12,8,1,11,0,8
+N,9,15,8,8,4,8,10,5,4,5,6,10,7,12,2,6
+D,5,9,6,7,5,7,7,8,8,6,5,4,4,9,4,9
+Q,5,5,7,8,9,8,8,5,1,6,6,10,7,13,7,13
+T,4,10,5,8,4,7,12,5,6,7,11,8,3,12,1,7
+Q,2,6,3,4,2,8,8,8,5,5,8,9,3,8,5,10
+O,6,9,8,8,7,6,6,5,4,6,3,6,4,9,7,7
+A,10,14,8,8,4,11,1,3,0,10,4,11,3,4,4,10
+O,3,4,4,6,2,7,7,9,6,7,6,8,3,8,4,8
+E,5,11,7,8,5,7,7,1,9,10,6,9,2,8,5,8
+C,4,6,5,4,5,7,6,4,3,7,7,11,5,9,3,9
+A,7,11,7,6,5,10,3,5,2,10,5,11,7,2,6,10
+C,4,11,5,8,4,5,8,8,6,10,8,13,3,12,5,8
+F,5,7,6,5,6,8,6,5,4,7,6,8,6,9,6,10
+A,3,8,5,6,4,11,2,2,2,9,2,9,3,6,3,8
+F,3,9,4,6,1,1,13,5,4,12,10,6,0,8,2,6
+D,4,8,5,6,4,10,5,2,6,11,4,7,3,7,3,9
+L,1,0,2,1,0,2,1,6,4,0,2,5,0,8,0,8
+F,4,7,5,5,3,6,10,4,5,12,7,5,2,9,2,6
+U,5,9,5,6,2,7,4,14,6,7,14,8,3,9,0,8
+P,5,9,8,7,4,7,9,6,5,11,5,4,2,10,4,8
+C,3,8,4,6,3,5,8,8,7,10,8,13,2,10,4,9
+Q,5,9,5,4,3,11,3,3,6,11,3,9,3,8,6,13
+J,3,7,5,5,3,8,6,4,5,8,6,7,2,7,4,6
+K,4,8,6,6,6,7,8,5,4,7,6,7,7,7,6,11
+P,8,10,6,5,3,6,11,5,3,12,4,4,4,10,4,8
+V,5,11,8,8,4,6,11,2,4,8,12,9,3,10,2,8
+G,3,2,4,4,3,7,7,6,6,7,6,10,3,8,4,9
+E,1,1,1,2,1,4,8,5,8,7,6,13,0,8,6,9
+T,2,6,3,4,2,6,12,3,6,8,11,8,2,11,1,7
+N,4,6,6,6,6,6,9,5,3,6,4,8,7,8,4,9
+Z,4,11,6,8,4,6,9,3,10,11,9,6,1,9,6,6
+U,5,9,5,4,3,7,6,4,5,6,7,8,5,6,3,7
+Y,3,9,5,6,1,6,10,2,2,8,12,8,1,11,0,8
+Z,6,10,9,8,7,9,9,5,4,7,5,7,3,9,10,5
+Y,2,4,3,2,1,4,11,2,6,11,10,5,1,11,2,5
+H,9,12,9,6,4,7,8,5,4,9,10,9,7,10,5,9
+B,5,10,8,8,6,9,7,3,7,10,4,6,2,8,6,11
+Z,4,8,5,6,2,7,7,4,15,9,6,8,0,8,8,8
+J,5,10,6,7,2,8,6,3,7,15,5,9,0,6,1,7
+Z,5,8,7,6,4,8,7,2,9,12,5,8,2,8,6,8
+X,4,4,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+R,2,3,3,2,2,6,7,4,5,6,5,6,5,7,3,8
+T,5,7,6,5,6,7,8,4,6,7,7,9,5,8,6,5
+B,3,6,4,4,4,7,7,4,6,7,6,6,2,8,5,10
+T,8,11,8,8,6,7,11,4,8,11,9,4,6,12,6,5
+Z,4,7,6,5,4,6,9,2,9,11,8,6,1,8,6,6
+Z,5,6,4,9,4,6,11,3,3,12,7,6,2,7,9,3
+Z,2,0,2,1,1,7,7,3,11,8,6,8,0,8,7,8
+H,2,6,4,4,5,7,9,5,2,7,6,7,5,6,6,6
+B,6,11,6,8,7,7,8,9,6,6,5,7,2,8,8,9
+J,4,11,6,8,4,9,6,3,6,14,4,9,0,6,1,7
+R,3,3,4,4,2,5,10,8,4,7,4,8,2,7,6,11
+O,4,8,6,7,5,7,6,5,5,9,5,8,3,6,5,6
+F,3,8,3,6,2,1,11,3,5,11,11,9,0,8,2,7
+M,2,0,2,0,1,7,6,10,0,7,9,8,6,6,0,8
+L,4,7,5,5,6,7,7,3,5,6,7,11,6,11,6,5
+N,3,6,5,4,3,8,9,3,4,10,5,6,5,8,1,7
+T,3,4,4,6,1,8,15,1,6,6,11,9,0,8,0,8
+L,6,13,5,8,3,8,3,3,5,12,4,12,2,7,6,8
+O,5,8,7,7,5,7,5,4,5,8,4,8,3,7,4,7
+M,7,7,9,5,7,5,7,3,5,10,9,10,9,5,4,8
+N,1,0,1,1,0,7,7,10,0,5,6,8,4,8,0,8
+H,3,4,5,3,3,6,8,3,5,10,9,9,3,7,3,6
+V,1,1,2,1,0,7,9,4,2,7,13,8,2,10,0,8
+A,4,8,5,6,4,8,3,1,2,6,2,8,2,6,2,6
+C,2,5,3,3,1,4,8,5,6,11,9,12,1,9,2,7
+W,12,14,12,8,7,4,8,2,4,8,10,8,10,11,2,5
+P,4,7,6,5,3,7,10,3,6,14,5,2,0,10,3,9
+B,3,1,3,2,3,7,7,5,6,7,6,6,4,8,5,10
+Y,1,1,3,1,1,8,11,1,6,6,11,8,1,11,1,8
+O,6,10,6,8,5,7,7,8,5,10,6,8,3,8,3,8
+T,3,9,4,6,3,10,11,3,7,4,12,8,2,12,1,8
+I,1,5,1,4,1,7,7,1,8,7,6,8,0,8,3,8
+F,3,6,4,4,4,6,8,5,4,7,5,9,3,10,8,10
+W,5,7,6,5,6,7,8,6,3,8,8,7,7,9,4,9
+K,6,8,8,6,4,8,7,2,7,10,3,8,4,7,4,9
+Q,4,7,5,6,2,8,6,8,6,6,6,8,3,8,4,8
+E,5,10,7,8,6,7,8,2,7,11,6,9,3,8,4,9
+O,4,8,6,6,4,8,7,8,4,7,7,8,3,8,3,8
+G,3,4,4,6,2,8,8,8,7,6,7,8,2,7,6,11
+H,5,9,7,6,5,7,6,7,5,5,4,9,3,7,6,9
+P,6,7,8,9,10,9,9,3,2,6,8,7,6,10,6,4
+O,2,2,3,3,2,8,7,7,4,7,6,9,2,8,3,8
+R,3,8,5,6,4,10,7,3,6,10,3,7,3,7,2,10
+O,1,0,1,0,0,7,7,7,4,7,6,8,2,8,3,8
+R,5,9,7,6,7,9,7,6,3,8,5,6,5,6,8,10
+W,4,8,6,6,3,7,8,4,1,7,8,8,8,9,0,8
+X,3,4,4,5,1,7,7,4,4,7,6,8,3,8,4,8
+N,3,5,5,4,2,6,8,3,4,10,7,8,5,8,1,8
+A,5,10,7,8,4,8,2,2,3,6,2,7,5,7,5,8
+X,1,0,1,0,0,7,7,3,5,7,6,8,2,8,4,7
+I,2,7,4,5,4,10,6,2,5,8,5,5,3,8,5,6
+K,3,8,4,6,3,3,8,6,3,6,4,11,3,8,3,11
+Z,4,6,6,4,4,9,11,6,5,6,5,9,3,8,9,6
+T,2,3,4,4,1,9,15,1,5,5,11,9,0,8,0,8
+E,3,9,3,7,2,2,7,6,10,7,7,15,0,8,7,7
+N,7,12,8,6,4,5,9,5,4,13,11,9,6,9,0,9
+B,8,15,8,8,8,7,8,5,5,9,7,8,8,5,10,7
+C,2,3,2,2,1,6,8,6,7,8,7,13,1,9,3,10
+R,3,6,5,5,6,6,8,3,3,6,5,9,6,7,5,9
+I,6,12,4,6,2,11,3,4,6,11,2,7,3,8,3,12
+X,4,11,5,8,4,7,7,4,4,7,6,8,2,8,4,8
+E,3,8,3,6,4,3,7,5,9,7,7,14,0,8,6,9
+T,4,7,4,5,3,6,11,4,5,11,9,5,2,12,2,5
+X,3,7,5,6,5,9,7,2,4,8,6,6,3,9,7,7
+D,5,11,5,8,3,6,7,11,10,7,6,6,3,8,4,8
+W,8,9,12,8,13,7,7,5,5,7,5,8,10,9,9,7
+X,5,11,8,8,4,10,7,2,9,11,1,6,3,8,4,9
+H,3,2,4,3,3,6,7,6,6,7,6,8,6,8,3,8
+V,1,0,2,0,0,8,9,3,1,6,12,8,2,11,0,8
+H,5,9,6,5,4,8,7,3,5,10,4,8,5,7,4,7
+O,5,10,6,8,9,7,8,5,1,7,6,7,11,11,9,12
+R,3,7,4,5,2,5,10,8,4,7,4,8,3,7,6,11
+X,3,10,4,7,1,7,7,4,4,7,6,8,3,8,4,8
+O,3,6,4,4,3,7,7,7,4,6,5,7,3,8,3,7
+D,5,8,7,6,5,7,7,8,5,7,7,4,4,8,4,8
+F,3,8,3,5,1,1,13,4,3,12,10,6,0,8,2,6
+A,3,7,6,5,3,12,3,3,3,11,1,8,2,6,2,9
+P,3,6,6,4,3,9,8,3,5,12,4,4,1,10,3,9
+E,4,10,4,7,3,3,6,6,11,7,7,15,0,8,7,7
+O,4,3,5,4,2,8,7,8,7,6,6,9,3,8,4,8
+L,3,2,4,4,2,4,4,4,8,2,1,7,0,7,1,6
+O,5,9,6,7,3,7,6,9,8,7,5,8,3,8,4,8
+T,2,1,3,2,1,7,12,3,6,7,11,8,2,11,1,8
+J,2,4,4,3,1,8,8,1,6,14,5,7,0,7,0,8
+Q,5,7,6,9,6,8,7,6,3,8,7,9,3,9,6,9
+D,5,9,6,6,6,7,7,8,6,6,5,4,4,8,4,8
+C,4,8,6,6,4,5,7,6,8,6,6,13,1,7,4,9
+E,3,4,3,3,3,7,7,5,8,7,6,9,2,8,6,9
+N,4,5,7,4,3,7,9,3,5,11,6,6,6,8,1,7
+K,3,4,4,2,2,5,7,4,7,7,6,10,6,8,4,9
+Q,3,5,5,4,3,10,4,3,4,9,3,8,3,7,3,9
+L,2,5,4,3,2,7,3,1,7,9,2,10,0,7,2,9
+I,4,12,3,6,2,11,5,4,4,12,3,7,3,8,5,10
+T,2,5,4,6,1,7,14,0,6,7,11,8,0,8,0,8
+Y,1,0,2,0,0,7,10,3,1,7,12,8,1,11,0,8
+E,4,10,6,8,6,6,8,6,9,6,4,10,2,8,6,9
+U,9,11,9,8,4,3,10,6,8,13,12,9,3,9,1,6
+E,3,4,4,6,2,3,6,6,11,7,7,15,0,8,7,7
+J,1,1,1,1,0,12,3,6,4,13,4,11,0,7,0,8
+B,4,9,4,7,6,6,8,8,5,7,5,7,2,8,7,9
+F,0,0,1,0,0,3,11,4,2,11,8,6,0,8,2,8
+N,5,4,5,6,2,7,7,15,2,4,6,8,6,8,0,8
+P,4,9,6,7,5,5,10,3,6,10,9,5,1,10,4,7
+T,2,4,3,3,1,4,11,2,7,11,10,5,0,10,1,5
+D,3,4,5,3,3,8,7,6,6,9,5,6,3,8,4,9
+P,3,1,3,2,2,5,10,4,4,10,8,4,0,9,4,7
+Q,4,9,6,8,3,8,7,9,6,6,6,9,3,8,5,9
+S,9,15,9,8,4,8,4,5,6,13,6,10,3,8,3,8
+E,5,7,7,5,5,7,8,2,8,11,7,8,3,8,5,8
+S,1,1,2,2,0,8,7,4,7,4,6,7,0,8,7,8
+S,7,10,8,8,4,6,9,4,9,11,7,6,2,7,5,4
+S,4,8,5,6,4,7,7,5,7,5,6,9,0,8,8,8
+X,2,3,4,2,1,9,6,2,8,10,3,7,2,8,2,8
+J,3,9,5,7,3,7,6,3,6,15,6,11,1,6,1,7
+F,4,9,6,6,4,5,10,2,8,10,9,6,4,10,4,6
+H,1,0,1,0,0,7,8,10,1,7,5,8,2,8,0,8
+G,4,8,6,6,4,6,6,6,6,7,5,11,3,10,4,9
+H,5,5,5,7,3,7,8,15,1,7,5,8,3,8,0,8
+S,5,5,6,8,3,8,7,6,9,4,6,8,0,8,9,8
+T,7,9,7,7,3,5,12,3,10,12,10,3,1,11,3,4
+B,6,10,8,8,7,7,7,6,6,9,7,6,3,8,8,9
+M,9,13,11,8,6,10,2,2,3,9,3,9,7,2,1,9
+N,6,11,7,8,6,7,7,13,1,6,6,8,6,8,0,8
+C,4,11,5,8,4,5,8,8,7,10,9,13,2,10,4,10
+T,4,5,5,4,2,5,12,3,7,11,10,4,1,11,2,4
+Y,6,8,6,6,3,4,10,2,8,9,10,5,2,12,4,3
+F,1,0,1,0,0,3,12,4,2,11,8,6,0,8,2,7
+R,3,4,4,3,3,7,8,4,5,6,5,7,2,6,4,8
+N,3,7,4,5,2,7,7,14,2,5,6,8,5,8,0,8
+G,2,1,2,1,1,8,6,6,5,6,5,9,1,7,5,10
+Q,6,11,6,6,4,10,5,4,6,11,4,8,3,8,8,11
+J,2,7,2,5,1,11,3,10,3,12,7,13,1,6,0,8
+N,7,10,9,8,6,6,9,2,4,9,8,8,7,7,2,7
+P,5,11,5,8,6,5,10,9,4,8,6,5,2,10,3,8
+C,4,6,5,4,5,5,7,4,5,7,6,9,5,11,3,8
+U,8,13,7,7,5,8,6,5,4,5,6,7,5,6,3,5
+K,4,7,6,6,5,9,5,2,3,8,4,9,4,7,6,12
+V,4,11,7,8,3,7,12,3,4,6,12,9,3,10,1,8
+Q,7,12,6,7,4,9,4,4,7,10,4,9,3,8,8,11
+E,5,12,4,6,3,6,9,4,4,10,6,9,3,8,7,9
+F,3,2,4,3,2,6,10,4,5,10,9,5,2,9,3,6
+J,2,4,4,3,1,8,6,3,6,14,6,10,0,7,0,7
+Y,5,9,7,7,6,9,5,7,5,7,9,8,3,9,8,4
+Z,2,1,2,1,1,8,7,5,9,6,6,8,1,8,6,8
+G,7,13,6,7,3,9,6,5,6,11,4,8,5,7,5,8
+I,3,9,5,6,6,10,6,2,5,8,5,5,3,8,5,7
+Y,3,8,4,5,1,8,10,2,3,5,12,8,1,10,0,8
+B,2,5,4,3,3,8,8,3,5,10,5,6,3,7,5,9
+O,1,0,1,0,0,8,7,6,4,7,6,8,2,8,2,8
+B,6,9,8,6,7,10,6,3,6,10,3,7,4,7,5,12
+G,3,4,4,6,2,7,6,8,7,6,6,10,1,7,6,11
+A,3,8,5,5,2,6,4,3,1,6,1,8,2,7,2,7
+H,3,7,5,5,5,6,7,6,6,7,6,10,3,8,3,9
+Z,3,9,4,7,2,7,7,4,14,10,6,8,0,8,8,8
+I,1,3,1,2,1,7,7,1,7,7,6,8,0,8,2,8
+Y,6,9,8,7,8,9,7,6,4,6,8,8,3,9,8,4
+Q,4,6,4,7,4,7,11,4,3,6,10,11,3,10,6,8
+H,6,11,8,8,9,6,7,6,7,7,7,10,6,8,4,9
+M,11,12,11,6,5,7,10,5,4,4,5,11,11,13,2,7
+Y,1,0,2,0,0,7,10,3,1,7,12,8,1,11,0,8
+S,3,5,4,3,3,8,7,7,5,7,7,8,2,8,9,8
+O,1,3,2,1,1,7,7,5,3,9,6,8,2,8,2,8
+L,4,8,6,6,7,8,7,3,5,6,7,9,6,10,7,5
+P,4,8,5,6,4,4,11,4,6,11,9,5,0,10,3,7
+A,4,8,6,6,4,8,3,2,2,6,2,7,2,6,2,7
+U,3,8,5,7,5,7,7,4,3,6,6,8,6,8,1,8
+R,8,14,8,8,6,8,8,3,5,9,4,8,6,6,7,7
+A,3,6,5,4,3,8,6,2,4,8,2,5,2,6,2,7
+U,3,6,4,4,3,8,8,8,5,6,7,9,3,8,4,6
+N,5,10,7,8,5,7,8,5,5,7,7,7,6,7,3,7
+U,2,2,3,3,1,7,8,7,7,8,10,7,3,9,1,8
+U,3,3,3,1,1,6,8,5,7,8,7,8,3,10,2,5
+B,4,4,5,7,4,6,6,9,7,6,6,7,2,8,9,10
+O,6,10,7,8,6,7,8,7,4,10,7,7,5,9,4,9
+H,7,9,10,7,6,9,6,3,6,10,5,7,3,8,3,8
+J,1,1,1,1,0,12,4,6,4,13,4,10,0,7,0,8
+J,2,9,3,7,1,14,3,6,5,14,1,9,0,7,0,8
+I,2,5,0,7,0,7,7,4,4,7,6,8,0,8,0,8
+G,3,3,4,5,2,7,8,8,7,6,7,7,2,7,6,11
+P,3,5,4,4,2,6,10,6,4,9,7,2,1,10,4,6
+H,4,7,6,5,4,7,7,3,6,10,5,9,3,8,3,9
+G,5,11,7,8,6,7,6,7,8,6,5,8,2,10,8,12
+U,6,8,8,6,6,8,8,8,5,5,7,10,3,8,4,6
+U,6,11,6,6,4,6,5,6,5,6,9,9,5,9,3,10
+W,8,12,8,6,4,2,9,2,2,10,11,9,8,10,0,7
+Q,3,5,4,6,3,8,7,7,2,5,7,10,3,8,6,9
+E,2,6,2,4,2,3,6,6,10,7,7,14,0,8,7,8
+P,6,9,8,6,5,9,8,5,6,12,4,4,5,9,5,7
+M,3,3,4,2,2,8,6,6,3,6,7,8,6,6,1,7
+J,3,8,4,6,2,10,6,1,6,13,3,7,0,7,0,8
+T,5,10,6,8,7,8,7,4,7,7,6,9,5,7,5,7
+L,1,4,3,3,1,6,4,1,7,8,2,10,0,7,2,8
+S,4,11,5,8,4,8,7,8,7,8,5,7,2,8,9,8
+N,4,7,6,5,4,7,9,6,6,7,6,6,6,8,1,6
+P,3,6,4,4,2,5,11,9,3,9,6,5,1,10,4,8
+D,3,3,3,4,2,5,7,10,8,7,6,6,3,8,4,8
+X,6,10,9,7,4,8,6,1,9,10,4,8,3,8,4,8
+M,3,3,5,2,2,5,6,4,3,10,10,10,6,5,2,7
+A,4,11,6,8,5,7,4,2,1,7,1,8,2,7,2,7
+T,7,10,7,8,4,6,12,4,8,12,9,3,2,12,3,4
+L,4,8,5,6,3,7,3,2,8,7,2,8,1,6,2,7
+W,6,12,7,6,5,8,8,3,3,6,9,7,10,10,3,6
+P,4,6,5,9,8,8,9,4,0,8,7,6,5,10,5,7
+Q,4,9,5,8,3,7,6,8,6,6,7,7,3,8,6,9
+T,5,7,5,5,3,6,11,3,6,11,9,5,3,11,3,4
+L,3,6,4,4,2,4,5,2,8,3,2,7,0,7,1,6
+E,3,4,5,3,2,7,7,2,8,11,6,9,2,8,4,9
+W,4,7,6,5,3,8,8,4,1,7,8,8,8,9,0,8
+C,10,14,8,8,6,7,8,4,4,9,8,10,4,9,9,11
+K,7,9,8,5,4,5,8,4,6,10,11,11,6,12,4,7
+M,3,6,4,4,2,8,6,11,1,6,9,8,7,6,0,8
+T,5,9,7,7,6,7,6,7,7,6,7,9,4,11,6,8
+E,3,6,5,6,5,6,8,4,3,7,7,10,4,10,7,12
+T,6,8,6,6,3,4,12,2,9,12,9,5,0,10,2,4
+P,2,4,3,3,2,5,10,4,4,10,8,5,0,10,3,7
+V,4,9,6,7,7,8,6,4,2,8,7,8,8,9,4,7
+J,1,1,2,1,0,11,6,2,6,12,3,8,0,7,0,8
+E,3,4,4,3,3,7,7,5,8,7,6,8,2,8,6,9
+C,4,6,5,4,5,7,7,4,3,6,8,10,5,11,3,8
+R,5,8,7,6,7,8,8,7,3,7,4,6,5,7,7,8
+T,3,10,5,7,3,9,12,3,7,5,12,8,2,12,1,8
+U,4,5,5,4,3,6,8,5,7,7,10,10,3,9,1,8
+W,6,7,8,6,10,7,7,5,5,7,5,8,10,8,8,8
+T,4,10,5,7,3,8,14,1,5,6,10,9,0,8,0,8
+X,4,10,6,8,4,7,7,4,9,6,6,8,3,8,7,7
+R,3,5,5,4,5,7,8,3,3,7,5,8,6,8,4,8
+Y,1,1,3,2,1,6,10,1,6,8,11,8,1,11,2,8
+K,5,9,5,4,2,7,7,3,6,9,8,9,6,11,3,7
+M,8,9,11,8,12,7,9,4,4,7,5,8,12,6,6,7
+Z,5,10,6,8,3,7,7,4,15,9,6,8,0,8,8,8
+V,5,8,5,6,2,2,12,5,4,12,12,7,3,10,1,8
+G,4,4,5,6,3,7,5,7,8,6,5,8,2,8,6,11
+L,3,7,5,5,2,6,3,3,8,6,2,8,1,6,3,7
+A,3,11,5,8,4,12,3,3,3,10,2,9,2,7,3,9
+Q,6,11,6,6,3,7,6,4,8,9,5,9,3,7,9,10
+X,9,14,8,8,4,9,6,3,8,9,4,7,5,8,5,9
+G,2,4,3,3,2,7,7,5,5,6,6,9,2,8,4,9
+A,2,2,4,4,2,8,2,1,2,7,2,8,2,7,3,7
+A,3,7,4,5,2,7,4,2,0,6,2,8,2,7,1,7
+O,3,6,4,4,3,8,8,7,4,7,7,8,3,8,2,8
+I,1,5,1,4,1,8,7,1,7,7,6,7,0,8,3,7
+L,3,5,5,4,2,7,4,1,8,8,2,10,0,7,2,8
+X,3,7,5,5,3,8,8,3,8,6,6,7,3,8,6,8
+M,5,10,6,8,4,7,7,12,2,7,9,8,9,6,0,8
+Z,2,5,3,4,2,7,7,5,9,6,6,8,1,8,7,8
+J,3,7,5,5,4,10,5,2,6,8,5,5,3,7,5,7
+V,5,11,8,8,10,8,5,5,2,8,8,8,6,9,4,8
+V,5,9,4,4,2,9,10,4,4,6,10,6,4,11,3,7
+L,3,7,4,5,2,4,4,3,10,2,1,7,0,7,2,5
+H,5,7,8,5,6,5,9,3,6,10,8,8,3,8,3,6
+C,5,4,6,6,2,6,7,7,11,8,6,13,1,9,4,8
+X,3,5,5,3,2,5,9,2,8,11,10,9,2,9,3,6
+Y,5,7,5,5,2,3,10,2,7,11,11,6,1,11,2,5
+D,4,8,6,6,4,7,8,7,7,10,6,5,3,8,4,7
+U,9,11,9,8,6,3,8,5,8,10,9,10,3,9,2,6
+I,5,12,5,6,3,6,11,3,5,13,6,4,1,8,5,8
+Q,1,1,2,1,1,8,7,6,3,6,6,8,2,8,3,8
+J,2,5,3,3,1,10,6,2,6,12,4,9,1,6,1,7
+G,4,9,6,6,6,7,7,6,3,7,6,9,5,7,7,7
+U,4,4,5,3,2,5,8,5,7,10,9,8,3,9,2,5
+X,7,11,11,8,7,4,8,2,9,10,11,9,5,8,5,4
+P,4,6,5,4,4,8,5,6,5,7,6,7,2,9,7,9
+T,2,3,3,2,1,5,12,3,7,11,9,5,1,10,2,5
+T,5,11,6,8,8,6,8,4,5,6,6,9,6,7,6,7
+Y,4,10,6,7,1,9,11,3,2,5,13,8,1,11,0,8
+G,5,10,6,7,4,6,7,7,7,10,7,11,2,10,4,9
+K,7,14,8,8,5,9,6,3,5,11,3,7,5,7,4,8
+S,4,8,5,6,6,9,9,5,4,8,4,6,4,9,9,7
+N,4,10,6,8,5,8,8,6,5,7,6,6,6,9,2,6
+M,4,3,4,5,3,7,7,12,1,7,9,8,8,6,0,8
+G,2,3,3,2,1,7,7,5,5,10,7,10,2,9,4,10
+L,2,3,2,2,1,5,4,5,6,2,2,5,1,7,1,6
+X,3,9,4,6,1,7,7,4,4,7,6,8,3,8,4,8
+L,3,4,3,6,1,0,1,5,6,0,0,7,0,8,0,8
+V,6,11,6,6,3,7,9,3,4,8,9,6,5,9,3,6
+P,4,9,6,6,4,7,9,3,4,12,5,4,2,9,3,8
+K,3,1,5,3,3,6,7,4,8,7,6,11,3,8,5,9
+W,4,10,6,8,7,8,7,6,2,7,8,8,9,7,4,9
+Q,2,0,2,1,1,8,7,6,3,6,6,9,2,8,3,8
+Q,2,2,3,3,2,8,8,6,1,5,6,9,2,9,5,10
+Q,4,8,6,7,5,8,8,7,5,6,7,9,3,8,4,9
+S,3,6,5,4,5,6,7,3,2,8,6,6,2,7,10,1
+H,3,8,5,6,4,8,8,7,7,7,5,7,3,8,3,7
+W,2,3,4,2,2,7,10,2,2,7,9,8,6,11,0,8
+O,10,14,7,8,4,6,8,5,4,7,4,6,5,9,5,7
+Y,6,9,5,5,2,5,9,3,3,10,9,5,3,10,3,4
+L,1,0,1,0,0,2,2,5,4,1,2,6,0,8,0,8
+T,6,8,6,6,3,4,12,3,7,12,10,5,1,11,1,5
+G,2,3,2,2,1,6,8,5,4,9,8,9,2,8,4,9
+E,5,10,4,5,3,7,8,4,3,10,5,9,4,9,7,10
+J,6,7,8,8,7,8,8,5,7,7,5,8,4,10,10,8
+Q,4,3,5,5,2,8,9,7,6,6,8,9,3,8,5,9
+N,7,14,9,8,5,3,9,4,4,13,12,10,6,9,0,8
+T,4,5,4,4,2,6,11,2,7,11,9,4,1,11,2,4
+M,5,8,7,6,7,8,6,6,5,7,7,10,11,6,2,9
+O,4,5,5,4,3,7,7,8,5,7,6,8,2,8,3,8
+A,6,10,7,6,3,12,0,4,1,11,4,12,4,4,3,11
+T,2,9,4,7,2,7,13,0,5,7,10,8,0,8,0,8
+N,3,5,6,3,2,7,9,2,5,10,6,6,5,8,1,7
+F,4,10,4,7,3,1,12,4,4,11,10,8,0,8,2,6
+P,2,5,3,7,5,8,6,5,1,7,6,7,6,8,5,9
+U,3,7,5,5,3,4,8,6,6,7,9,10,3,9,1,8
+H,5,7,8,5,5,9,7,3,6,10,4,7,5,8,4,9
+O,6,9,4,4,2,8,7,5,5,8,4,7,4,9,5,8
+S,2,8,3,6,2,8,8,6,9,5,6,7,0,8,9,8
+J,5,9,6,7,3,6,8,2,6,15,6,8,2,8,2,8
+O,4,5,5,4,4,8,4,4,4,9,4,10,3,6,6,6
+B,4,8,6,6,5,7,8,6,6,10,6,6,3,8,7,8
+F,3,8,5,6,3,6,11,4,6,11,9,4,2,10,3,5
+E,3,9,3,6,2,3,6,6,10,7,7,14,0,8,7,8
+F,3,6,5,4,3,5,10,4,6,10,9,5,2,9,3,5
+A,2,3,3,1,1,6,2,2,1,5,2,8,1,6,1,7
+Q,3,5,4,6,4,8,9,4,2,5,8,11,2,10,5,8
+C,6,9,6,7,4,4,7,5,7,10,9,14,4,9,5,5
+S,4,9,6,6,7,9,4,4,4,9,6,9,4,7,10,9
+F,7,10,9,8,7,9,7,2,6,12,4,6,5,9,4,9
+C,5,10,7,9,8,5,6,4,4,7,6,11,5,11,8,10
+V,4,7,6,5,6,8,6,4,2,7,8,8,7,9,4,6
+T,4,4,5,3,2,5,12,2,8,11,9,4,0,10,2,4
+N,5,9,5,4,2,9,11,5,3,5,6,9,5,11,2,6
+E,1,0,1,0,0,5,8,5,7,7,6,12,0,8,6,10
+L,3,8,3,6,2,0,2,4,6,1,0,8,0,8,0,8
+A,3,9,5,6,2,6,5,3,1,6,1,8,2,7,2,7
+K,5,11,5,8,5,3,8,7,3,6,4,11,3,8,2,11
+M,6,9,10,7,12,7,5,3,2,7,5,8,15,7,4,6
+R,2,3,3,2,2,7,7,5,5,7,5,6,2,7,4,8
+S,6,12,6,7,3,6,8,3,6,13,7,7,2,9,3,7
+Y,3,9,5,6,3,7,9,1,6,6,11,8,2,11,2,7
+V,7,10,5,5,2,6,11,5,4,11,9,4,4,11,3,10
+S,2,0,2,1,1,8,7,4,6,5,6,8,0,8,7,8
+M,5,6,8,4,5,9,6,2,4,9,5,7,8,6,2,8
+O,9,15,6,8,5,5,7,7,4,10,7,10,5,9,5,8
+L,3,7,3,5,1,0,1,6,6,0,0,6,0,8,0,8
+D,6,9,8,8,8,7,6,5,7,7,5,9,6,5,10,3
+P,2,1,3,2,1,4,10,3,5,10,8,5,0,9,3,7
+W,3,8,5,6,5,11,11,2,2,5,8,7,7,12,1,7
+O,4,3,5,4,2,7,6,8,8,6,5,7,3,8,4,8
+E,4,9,5,6,3,5,9,2,10,10,8,9,2,8,5,5
+J,2,11,3,8,2,15,4,4,5,13,1,8,0,7,0,8
+T,5,8,7,7,7,7,9,4,8,7,7,8,3,10,8,6
+D,2,2,3,3,2,7,7,7,6,6,6,4,2,8,3,7
+C,7,10,8,8,4,4,8,6,9,12,9,13,2,9,3,7
+T,6,9,6,7,5,6,11,3,7,11,9,5,2,12,2,4
+S,2,3,4,2,1,8,7,2,6,10,6,8,1,9,5,8
+A,4,9,6,6,2,9,5,3,1,8,1,8,2,7,2,8
diff --git a/C++/opencv-4.7.0/samples/data/leuvenA.jpg b/C++/opencv-4.7.0/samples/data/leuvenA.jpg
new file mode 100644
index 00000000..cded3755
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/leuvenA.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/leuvenB.jpg b/C++/opencv-4.7.0/samples/data/leuvenB.jpg
new file mode 100644
index 00000000..4f281729
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/leuvenB.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/licenseplate_motion.jpg b/C++/opencv-4.7.0/samples/data/licenseplate_motion.jpg
new file mode 100644
index 00000000..9723ea14
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/licenseplate_motion.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/mask.png b/C++/opencv-4.7.0/samples/data/mask.png
new file mode 100644
index 00000000..0666232d
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/mask.png differ
diff --git a/C++/opencv-4.7.0/samples/data/messi5.jpg b/C++/opencv-4.7.0/samples/data/messi5.jpg
new file mode 100644
index 00000000..cd437610
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/messi5.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/ml.png b/C++/opencv-4.7.0/samples/data/ml.png
new file mode 100644
index 00000000..6420b44b
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/ml.png differ
diff --git a/C++/opencv-4.7.0/samples/data/notes.png b/C++/opencv-4.7.0/samples/data/notes.png
new file mode 100644
index 00000000..1535bbbb
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/notes.png differ
diff --git a/C++/opencv-4.7.0/samples/data/opencv-logo-white.png b/C++/opencv-4.7.0/samples/data/opencv-logo-white.png
new file mode 100644
index 00000000..a683e356
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/opencv-logo-white.png differ
diff --git a/C++/opencv-4.7.0/samples/data/opencv-logo.png b/C++/opencv-4.7.0/samples/data/opencv-logo.png
new file mode 100644
index 00000000..995bdc0f
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/opencv-logo.png differ
diff --git a/C++/opencv-4.7.0/samples/data/orange.jpg b/C++/opencv-4.7.0/samples/data/orange.jpg
new file mode 100644
index 00000000..773a846d
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/orange.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/pca_test1.jpg b/C++/opencv-4.7.0/samples/data/pca_test1.jpg
new file mode 100644
index 00000000..688f82f3
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/pca_test1.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/pic1.png b/C++/opencv-4.7.0/samples/data/pic1.png
new file mode 100644
index 00000000..3e48aa4b
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/pic1.png differ
diff --git a/C++/opencv-4.7.0/samples/data/pic2.png b/C++/opencv-4.7.0/samples/data/pic2.png
new file mode 100644
index 00000000..068213f7
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/pic2.png differ
diff --git a/C++/opencv-4.7.0/samples/data/pic3.png b/C++/opencv-4.7.0/samples/data/pic3.png
new file mode 100644
index 00000000..fe214f00
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/pic3.png differ
diff --git a/C++/opencv-4.7.0/samples/data/pic4.png b/C++/opencv-4.7.0/samples/data/pic4.png
new file mode 100644
index 00000000..57b7a0d0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/pic4.png differ
diff --git a/C++/opencv-4.7.0/samples/data/pic5.png b/C++/opencv-4.7.0/samples/data/pic5.png
new file mode 100644
index 00000000..2e6bfa7c
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/pic5.png differ
diff --git a/C++/opencv-4.7.0/samples/data/pic6.png b/C++/opencv-4.7.0/samples/data/pic6.png
new file mode 100644
index 00000000..5cd6ab06
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/pic6.png differ
diff --git a/C++/opencv-4.7.0/samples/data/right.jpg b/C++/opencv-4.7.0/samples/data/right.jpg
new file mode 100644
index 00000000..4a4bc534
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right01.jpg b/C++/opencv-4.7.0/samples/data/right01.jpg
new file mode 100644
index 00000000..4d6071b8
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right01.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right02.jpg b/C++/opencv-4.7.0/samples/data/right02.jpg
new file mode 100644
index 00000000..6c0fab09
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right02.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right03.jpg b/C++/opencv-4.7.0/samples/data/right03.jpg
new file mode 100644
index 00000000..75027611
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right03.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right04.jpg b/C++/opencv-4.7.0/samples/data/right04.jpg
new file mode 100644
index 00000000..958973bc
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right04.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right05.jpg b/C++/opencv-4.7.0/samples/data/right05.jpg
new file mode 100644
index 00000000..926c8258
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right05.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right06.jpg b/C++/opencv-4.7.0/samples/data/right06.jpg
new file mode 100644
index 00000000..69a7994f
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right06.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right07.jpg b/C++/opencv-4.7.0/samples/data/right07.jpg
new file mode 100644
index 00000000..9aff92bd
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right07.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right08.jpg b/C++/opencv-4.7.0/samples/data/right08.jpg
new file mode 100644
index 00000000..abb794a1
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right08.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right09.jpg b/C++/opencv-4.7.0/samples/data/right09.jpg
new file mode 100644
index 00000000..a6dd6f99
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right09.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right11.jpg b/C++/opencv-4.7.0/samples/data/right11.jpg
new file mode 100644
index 00000000..29b99bec
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right11.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right12.jpg b/C++/opencv-4.7.0/samples/data/right12.jpg
new file mode 100644
index 00000000..35b2d07f
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right12.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right13.jpg b/C++/opencv-4.7.0/samples/data/right13.jpg
new file mode 100644
index 00000000..d504a46b
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right13.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/right14.jpg b/C++/opencv-4.7.0/samples/data/right14.jpg
new file mode 100644
index 00000000..2decf1e7
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/right14.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/rubberwhale1.png b/C++/opencv-4.7.0/samples/data/rubberwhale1.png
new file mode 100644
index 00000000..e2b08dba
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/rubberwhale1.png differ
diff --git a/C++/opencv-4.7.0/samples/data/rubberwhale2.png b/C++/opencv-4.7.0/samples/data/rubberwhale2.png
new file mode 100644
index 00000000..f365370a
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/rubberwhale2.png differ
diff --git a/C++/opencv-4.7.0/samples/data/smarties.png b/C++/opencv-4.7.0/samples/data/smarties.png
new file mode 100644
index 00000000..90bf22dd
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/smarties.png differ
diff --git a/C++/opencv-4.7.0/samples/data/squirrel_cls.jpg b/C++/opencv-4.7.0/samples/data/squirrel_cls.jpg
new file mode 100644
index 00000000..289b13bb
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/squirrel_cls.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/starry_night.jpg b/C++/opencv-4.7.0/samples/data/starry_night.jpg
new file mode 100644
index 00000000..824e0e5a
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/starry_night.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/stereo_calib.xml b/C++/opencv-4.7.0/samples/data/stereo_calib.xml
new file mode 100644
index 00000000..0772302c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/data/stereo_calib.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0"?>
+<opencv_storage>
+<imagelist>
+"left01.jpg"
+"right01.jpg"
+"left02.jpg"
+"right02.jpg"
+"left03.jpg"
+"right03.jpg"
+"left04.jpg"
+"right04.jpg"
+"left05.jpg"
+"right05.jpg"
+"left06.jpg"
+"right06.jpg"
+"left07.jpg"
+"right07.jpg"
+"left08.jpg"
+"right08.jpg"
+"left09.jpg"
+"right09.jpg"
+"left11.jpg"
+"right11.jpg"
+"left12.jpg"
+"right12.jpg"
+"left13.jpg"
+"right13.jpg"
+"left14.jpg"
+"right14.jpg"
+</imagelist>
+</opencv_storage>
diff --git a/C++/opencv-4.7.0/samples/data/stuff.jpg b/C++/opencv-4.7.0/samples/data/stuff.jpg
new file mode 100644
index 00000000..720d3413
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/stuff.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/sudoku.png b/C++/opencv-4.7.0/samples/data/sudoku.png
new file mode 100644
index 00000000..763e518e
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/sudoku.png differ
diff --git a/C++/opencv-4.7.0/samples/data/templ.png b/C++/opencv-4.7.0/samples/data/templ.png
new file mode 100644
index 00000000..31f6995c
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/templ.png differ
diff --git a/C++/opencv-4.7.0/samples/data/text_defocus.jpg b/C++/opencv-4.7.0/samples/data/text_defocus.jpg
new file mode 100644
index 00000000..42c37e05
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/text_defocus.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/text_motion.jpg b/C++/opencv-4.7.0/samples/data/text_motion.jpg
new file mode 100644
index 00000000..781f095c
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/text_motion.jpg differ
diff --git a/C++/opencv-4.7.0/samples/data/tmpl.png b/C++/opencv-4.7.0/samples/data/tmpl.png
new file mode 100644
index 00000000..999ac704
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/tmpl.png differ
diff --git a/C++/opencv-4.7.0/samples/data/tree.avi b/C++/opencv-4.7.0/samples/data/tree.avi
new file mode 100644
index 00000000..ded3608a
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/tree.avi differ
diff --git a/C++/opencv-4.7.0/samples/data/vtest.avi b/C++/opencv-4.7.0/samples/data/vtest.avi
new file mode 100644
index 00000000..965ab12b
Binary files /dev/null and b/C++/opencv-4.7.0/samples/data/vtest.avi differ
diff --git a/C++/opencv-4.7.0/samples/directx/CMakeLists.txt b/C++/opencv-4.7.0/samples/directx/CMakeLists.txt
new file mode 100644
index 00000000..c74c7d4b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/directx/CMakeLists.txt
@@ -0,0 +1,34 @@
+ocv_install_example_src(directx *.cpp *.hpp CMakeLists.txt)
+
+set(OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS
+    opencv_core
+    opencv_imgproc
+    opencv_imgcodecs
+    opencv_videoio
+    opencv_highgui)
+ocv_check_dependencies(${OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS})
+
+if(NOT BUILD_EXAMPLES OR NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+project("directx_samples")
+ocv_include_modules_recurse(${tgt} ${OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS})
+file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+foreach(sample_filename ${all_samples})
+  ocv_define_sample(tgt ${sample_filename} directx)
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS})
+  ocv_target_link_libraries(${tgt} PRIVATE "gdi32")
+  if(sample_filename STREQUAL "d3d9_interop.cpp")
+    ocv_target_link_libraries(${tgt} PRIVATE d3d9)
+  endif()
+  if(sample_filename STREQUAL "d3d9ex_interop.cpp")
+    ocv_target_link_libraries(${tgt} PRIVATE d3d9)
+  endif()
+  if(sample_filename STREQUAL "d3d10_interop.cpp")
+    ocv_target_link_libraries(${tgt} PRIVATE d3d10)
+  endif()
+  if(sample_filename STREQUAL "d3d11_interop.cpp")
+    ocv_target_link_libraries(${tgt} PRIVATE d3d11)
+  endif()
+endforeach()
diff --git a/C++/opencv-4.7.0/samples/directx/d3d10_interop.cpp b/C++/opencv-4.7.0/samples/directx/d3d10_interop.cpp
new file mode 100644
index 00000000..442a3f0c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/directx/d3d10_interop.cpp
@@ -0,0 +1,300 @@
+/*
+// A sample program demonstrating interoperability of OpenCV cv::UMat with Direct X surface
+// At first, the data obtained from video file or camera and placed onto Direct X surface,
+// following mapping of this Direct X surface to OpenCV cv::UMat and call cv::Blur function.
+// The result is mapped back to Direct X surface and rendered through Direct X API.
+*/
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <d3d10.h>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/directx.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+
+#include "d3dsample.hpp"
+
+
+class D3D10WinApp : public D3DSample
+{
+public:
+    D3D10WinApp(int width, int height, std::string& window_name, cv::VideoCapture& cap) :
+        D3DSample(width, height, window_name, cap) {}
+
+    ~D3D10WinApp() {}
+
+
+    int create(void)
+    {
+        // base initialization
+        D3DSample::create();
+
+        // initialize DirectX
+        HRESULT r;
+
+        DXGI_SWAP_CHAIN_DESC scd;
+
+        ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));
+
+        scd.BufferCount       = 1;                               // one back buffer
+        scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;      // use 32-bit color
+        scd.BufferDesc.Width  = m_width;                         // set the back buffer width
+        scd.BufferDesc.Height = m_height;                        // set the back buffer height
+        scd.BufferUsage       = DXGI_USAGE_RENDER_TARGET_OUTPUT; // how swap chain is to be used
+        scd.OutputWindow      = m_hWnd;                          // the window to be used
+        scd.SampleDesc.Count  = 1;                               // how many multisamples
+        scd.Windowed          = TRUE;                            // windowed/full-screen mode
+        scd.SwapEffect        = DXGI_SWAP_EFFECT_DISCARD;
+        scd.Flags             = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; // allow full-screen switching
+
+        r = ::D3D10CreateDeviceAndSwapChain(
+                NULL,
+                D3D10_DRIVER_TYPE_HARDWARE,
+                NULL,
+                0,
+                D3D10_SDK_VERSION,
+                &scd,
+                &m_pD3D10SwapChain,
+                &m_pD3D10Dev);
+        if (FAILED(r))
+        {
+            return EXIT_FAILURE;
+        }
+
+        r = m_pD3D10SwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&m_pBackBuffer);
+        if (FAILED(r))
+        {
+            return EXIT_FAILURE;
+        }
+
+        r = m_pD3D10Dev->CreateRenderTargetView(m_pBackBuffer, NULL, &m_pRenderTarget);
+        if (FAILED(r))
+        {
+            return EXIT_FAILURE;
+        }
+
+        m_pD3D10Dev->OMSetRenderTargets(1, &m_pRenderTarget, NULL);
+
+        D3D10_VIEWPORT viewport;
+        ZeroMemory(&viewport, sizeof(D3D10_VIEWPORT));
+
+        viewport.Width    = m_width;
+        viewport.Height   = m_height;
+        viewport.MinDepth = 0.0f;
+        viewport.MaxDepth = 0.0f;
+
+        m_pD3D10Dev->RSSetViewports(1, &viewport);
+
+        D3D10_TEXTURE2D_DESC desc = { 0 };
+
+        desc.Width            = m_width;
+        desc.Height           = m_height;
+        desc.MipLevels        = 1;
+        desc.ArraySize        = 1;
+        desc.Format           = DXGI_FORMAT_R8G8B8A8_UNORM;
+        desc.SampleDesc.Count = 1;
+        desc.BindFlags        = D3D10_BIND_SHADER_RESOURCE;
+        desc.Usage            = D3D10_USAGE_DYNAMIC;
+        desc.CPUAccessFlags   = D3D10_CPU_ACCESS_WRITE;
+
+        r = m_pD3D10Dev->CreateTexture2D(&desc, NULL, &m_pSurface);
+        if (FAILED(r))
+        {
+            std::cerr << "Can't create texture with input image" << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        // initialize OpenCL context of OpenCV lib from DirectX
+        if (cv::ocl::haveOpenCL())
+        {
+            m_oclCtx = cv::directx::ocl::initializeContextFromD3D10Device(m_pD3D10Dev);
+        }
+
+        m_oclDevName = cv::ocl::useOpenCL() ?
+            cv::ocl::Context::getDefault().device(0).name() :
+            "No OpenCL device";
+
+        return EXIT_SUCCESS;
+    } // create()
+
+
+    // get media data on DX surface for further processing
+    int get_surface(ID3D10Texture2D** ppSurface)
+    {
+        HRESULT r;
+
+        if (!m_cap.read(m_frame_bgr))
+            return EXIT_FAILURE;
+
+        cv::cvtColor(m_frame_bgr, m_frame_rgba, cv::COLOR_BGR2RGBA);
+
+        UINT subResource = ::D3D10CalcSubresource(0, 0, 1);
+
+        D3D10_MAPPED_TEXTURE2D mappedTex;
+        r = m_pSurface->Map(subResource, D3D10_MAP_WRITE_DISCARD, 0, &mappedTex);
+        if (FAILED(r))
+        {
+            return r;
+        }
+
+        cv::Mat m(m_height, m_width, CV_8UC4, mappedTex.pData, (int)mappedTex.RowPitch);
+        // copy video frame data to surface
+        m_frame_rgba.copyTo(m);
+
+        m_pSurface->Unmap(subResource);
+
+        *ppSurface = m_pSurface;
+
+        return EXIT_SUCCESS;
+    } // get_surface()
+
+
+    // process and render media data
+    int render()
+    {
+        try
+        {
+            if (m_shutdown)
+                return EXIT_SUCCESS;
+
+            // capture user input once
+            MODE mode = (m_mode == MODE_GPU_NV12) ? MODE_GPU_RGBA : m_mode;
+
+            HRESULT r;
+            ID3D10Texture2D* pSurface;
+
+            r = get_surface(&pSurface);
+            if (FAILED(r))
+            {
+                return EXIT_FAILURE;
+            }
+
+            m_timer.reset();
+            m_timer.start();
+
+            switch (mode)
+            {
+                case MODE_CPU:
+                {
+                    // process video frame on CPU
+                    UINT subResource = ::D3D10CalcSubresource(0, 0, 1);
+
+                    D3D10_MAPPED_TEXTURE2D mappedTex;
+                    r = pSurface->Map(subResource, D3D10_MAP_WRITE_DISCARD, 0, &mappedTex);
+                    if (FAILED(r))
+                    {
+                        return r;
+                    }
+
+                    cv::Mat m(m_height, m_width, CV_8UC4, mappedTex.pData, (int)mappedTex.RowPitch);
+
+                    if (m_demo_processing)
+                    {
+                        // blur D3D10 surface with OpenCV on CPU
+                        cv::blur(m, m, cv::Size(15, 15));
+                    }
+
+                    m_timer.stop();
+
+                    cv::String strMode = cv::format("mode: %s", m_modeStr[MODE_CPU].c_str());
+                    cv::String strProcessing = m_demo_processing ? "blur frame" : "copy frame";
+                    cv::String strTime = cv::format("time: %4.3f msec", m_timer.getTimeMilli());
+                    cv::String strDevName = cv::format("OpenCL device: %s", m_oclDevName.c_str());
+
+                    cv::putText(m, strMode, cv::Point(0, 20), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                    cv::putText(m, strProcessing, cv::Point(0, 40), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                    cv::putText(m, strTime, cv::Point(0, 60), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                    cv::putText(m, strDevName, cv::Point(0, 80), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+
+                    pSurface->Unmap(subResource);
+
+                    break;
+                }
+
+                case MODE_GPU_RGBA:
+                {
+                    // process video frame on GPU
+                    cv::UMat u;
+
+                    cv::directx::convertFromD3D10Texture2D(pSurface, u);
+
+                    if (m_demo_processing)
+                    {
+                        // blur D3D10 surface with OpenCV on GPU with OpenCL
+                        cv::blur(u, u, cv::Size(15, 15));
+                    }
+
+                    m_timer.stop();
+
+                    cv::String strMode = cv::format("mode: %s", m_modeStr[MODE_GPU_RGBA].c_str());
+                    cv::String strProcessing = m_demo_processing ? "blur frame" : "copy frame";
+                    cv::String strTime = cv::format("time: %4.3f msec", m_timer.getTimeMilli());
+                    cv::String strDevName = cv::format("OpenCL device: %s", m_oclDevName.c_str());
+
+                    cv::putText(u, strMode, cv::Point(0, 20), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                    cv::putText(u, strProcessing, cv::Point(0, 40), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                    cv::putText(u, strTime, cv::Point(0, 60), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                    cv::putText(u, strDevName, cv::Point(0, 80), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+
+                    cv::directx::convertToD3D10Texture2D(u, pSurface);
+
+                    break;
+                }
+
+            } // switch
+
+            // traditional DX render pipeline:
+            //   BitBlt surface to backBuffer and flip backBuffer to frontBuffer
+            m_pD3D10Dev->CopyResource(m_pBackBuffer, pSurface);
+
+            // present the back buffer contents to the display
+            // switch the back buffer and the front buffer
+            r = m_pD3D10SwapChain->Present(0, 0);
+            if (FAILED(r))
+            {
+                return EXIT_FAILURE;
+            }
+        } // try
+
+        catch (const cv::Exception& e)
+        {
+            std::cerr << "Exception: " << e.what() << std::endl;
+            return 10;
+        }
+
+        return EXIT_SUCCESS;
+    } // render()
+
+
+    int cleanup(void)
+    {
+        SAFE_RELEASE(m_pSurface);
+        SAFE_RELEASE(m_pBackBuffer);
+        SAFE_RELEASE(m_pD3D10SwapChain);
+        SAFE_RELEASE(m_pRenderTarget);
+        SAFE_RELEASE(m_pD3D10Dev);
+        D3DSample::cleanup();
+        return EXIT_SUCCESS;
+    } // cleanup()
+
+private:
+    ID3D10Device*           m_pD3D10Dev;
+    IDXGISwapChain*         m_pD3D10SwapChain;
+    ID3D10Texture2D*        m_pBackBuffer;
+    ID3D10Texture2D*        m_pSurface;
+    ID3D10RenderTargetView* m_pRenderTarget;
+    cv::ocl::Context        m_oclCtx;
+    cv::String              m_oclPlatformName;
+    cv::String              m_oclDevName;
+};
+
+
+// main func
+int main(int argc, char** argv)
+{
+    std::string title = "D3D10 interop sample";
+    return d3d_app<D3D10WinApp>(argc, argv, title);
+}
diff --git a/C++/opencv-4.7.0/samples/directx/d3d11_interop.cpp b/C++/opencv-4.7.0/samples/directx/d3d11_interop.cpp
new file mode 100644
index 00000000..6c55a0c4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/directx/d3d11_interop.cpp
@@ -0,0 +1,488 @@
+/*
+// A sample program demonstrating interoperability of OpenCV cv::UMat with Direct X surface
+// At first, the data obtained from video file or camera and placed onto Direct X surface,
+// following mapping of this Direct X surface to OpenCV cv::UMat and call cv::Blur function.
+// The result is mapped back to Direct X surface and rendered through Direct X API.
+*/
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <d3d11.h>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/directx.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+
+#include "d3dsample.hpp"
+
+
+class D3D11WinApp : public D3DSample
+{
+public:
+    D3D11WinApp(int width, int height, std::string& window_name, cv::VideoCapture& cap)
+    : D3DSample(width, height, window_name, cap),
+      m_nv12_available(false)
+    {}
+
+    ~D3D11WinApp() {}
+
+
+    int create(void)
+    {
+        // base initialization
+        D3DSample::create();
+
+        // initialize DirectX
+        HRESULT r;
+
+        DXGI_SWAP_CHAIN_DESC scd;
+
+        ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));
+
+        scd.BufferCount       = 1;                               // one back buffer
+        scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;      // use 32-bit color
+        scd.BufferDesc.Width  = m_width;                         // set the back buffer width
+        scd.BufferDesc.Height = m_height;                        // set the back buffer height
+        scd.BufferUsage       = DXGI_USAGE_RENDER_TARGET_OUTPUT; // how swap chain is to be used
+        scd.OutputWindow      = m_hWnd;                          // the window to be used
+        scd.SampleDesc.Count  = 1;                               // how many multisamples
+        scd.Windowed          = TRUE;                            // windowed/full-screen mode
+        scd.SwapEffect        = DXGI_SWAP_EFFECT_DISCARD;
+        scd.Flags             = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; // allow full-screen switching
+
+        r = ::D3D11CreateDeviceAndSwapChain(
+            NULL,
+            D3D_DRIVER_TYPE_HARDWARE,
+            NULL,
+            0,
+            NULL,
+            0,
+            D3D11_SDK_VERSION,
+            &scd,
+            &m_pD3D11SwapChain,
+            &m_pD3D11Dev,
+            NULL,
+            &m_pD3D11Ctx);
+        if (FAILED(r))
+        {
+            throw std::runtime_error("D3D11CreateDeviceAndSwapChain() failed!");
+        }
+
+#if defined(_WIN32_WINNT_WIN8) && _WIN32_WINNT >= _WIN32_WINNT_WIN8
+        UINT fmt = 0;
+        r = m_pD3D11Dev->CheckFormatSupport(DXGI_FORMAT_NV12, &fmt);
+        if (SUCCEEDED(r))
+        {
+            m_nv12_available = true;
+        }
+#endif
+
+        r = m_pD3D11SwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&m_pBackBuffer);
+        if (FAILED(r))
+        {
+            throw std::runtime_error("GetBuffer() failed!");
+        }
+
+        r = m_pD3D11Dev->CreateRenderTargetView(m_pBackBuffer, NULL, &m_pRenderTarget);
+        if (FAILED(r))
+        {
+            throw std::runtime_error("CreateRenderTargetView() failed!");
+        }
+
+        m_pD3D11Ctx->OMSetRenderTargets(1, &m_pRenderTarget, NULL);
+
+        D3D11_VIEWPORT viewport;
+        ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));
+
+        viewport.Width    = (float)m_width;
+        viewport.Height   = (float)m_height;
+        viewport.MinDepth = 0.0f;
+        viewport.MaxDepth = 0.0f;
+
+        m_pD3D11Ctx->RSSetViewports(1, &viewport);
+
+        m_pSurfaceRGBA = 0;
+        m_pSurfaceNV12 = 0;
+        m_pSurfaceNV12_cpu_copy = 0;
+
+        D3D11_TEXTURE2D_DESC desc_rgba;
+
+        desc_rgba.Width              = m_width;
+        desc_rgba.Height             = m_height;
+        desc_rgba.MipLevels          = 1;
+        desc_rgba.ArraySize          = 1;
+        desc_rgba.Format             = DXGI_FORMAT_R8G8B8A8_UNORM;
+        desc_rgba.SampleDesc.Count   = 1;
+        desc_rgba.SampleDesc.Quality = 0;
+        desc_rgba.BindFlags          = D3D11_BIND_SHADER_RESOURCE;
+        desc_rgba.Usage              = D3D11_USAGE_DYNAMIC;
+        desc_rgba.CPUAccessFlags     = D3D11_CPU_ACCESS_WRITE;
+        desc_rgba.MiscFlags          = 0;
+
+        r = m_pD3D11Dev->CreateTexture2D(&desc_rgba, 0, &m_pSurfaceRGBA);
+        if (FAILED(r))
+        {
+            throw std::runtime_error("Can't create DX texture");
+        }
+
+#if defined(_WIN32_WINNT_WIN8) && _WIN32_WINNT >= _WIN32_WINNT_WIN8
+        if(m_nv12_available)
+        {
+            D3D11_TEXTURE2D_DESC desc_nv12;
+
+            desc_nv12.Width              = m_width;
+            desc_nv12.Height             = m_height;
+            desc_nv12.MipLevels          = 1;
+            desc_nv12.ArraySize          = 1;
+            desc_nv12.Format             = DXGI_FORMAT_NV12;
+            desc_nv12.SampleDesc.Count   = 1;
+            desc_nv12.SampleDesc.Quality = 0;
+            desc_nv12.BindFlags          = D3D11_BIND_SHADER_RESOURCE;
+            desc_nv12.Usage              = D3D11_USAGE_DEFAULT;
+            desc_nv12.CPUAccessFlags     = 0;
+            desc_nv12.MiscFlags          = D3D11_RESOURCE_MISC_SHARED;
+
+            r = m_pD3D11Dev->CreateTexture2D(&desc_nv12, 0, &m_pSurfaceNV12);
+            if (FAILED(r))
+            {
+                throw std::runtime_error("Can't create DX NV12 texture");
+            }
+
+            D3D11_TEXTURE2D_DESC desc_nv12_cpu_copy;
+
+            desc_nv12_cpu_copy.Width              = m_width;
+            desc_nv12_cpu_copy.Height             = m_height;
+            desc_nv12_cpu_copy.MipLevels          = 1;
+            desc_nv12_cpu_copy.ArraySize          = 1;
+            desc_nv12_cpu_copy.Format             = DXGI_FORMAT_NV12;
+            desc_nv12_cpu_copy.SampleDesc.Count   = 1;
+            desc_nv12_cpu_copy.SampleDesc.Quality = 0;
+            desc_nv12_cpu_copy.BindFlags          = 0;
+            desc_nv12_cpu_copy.Usage              = D3D11_USAGE_STAGING;
+            desc_nv12_cpu_copy.CPUAccessFlags     = /*D3D11_CPU_ACCESS_WRITE | */D3D11_CPU_ACCESS_READ;
+            desc_nv12_cpu_copy.MiscFlags          = 0;
+
+            r = m_pD3D11Dev->CreateTexture2D(&desc_nv12_cpu_copy, 0, &m_pSurfaceNV12_cpu_copy);
+            if (FAILED(r))
+            {
+                throw std::runtime_error("Can't create DX NV12 texture");
+            }
+        }
+#endif
+
+        // initialize OpenCL context of OpenCV lib from DirectX
+        if (cv::ocl::haveOpenCL())
+        {
+            m_oclCtx = cv::directx::ocl::initializeContextFromD3D11Device(m_pD3D11Dev);
+        }
+
+        m_oclDevName = cv::ocl::useOpenCL() ?
+            cv::ocl::Context::getDefault().device(0).name() :
+            "No OpenCL device";
+
+        return EXIT_SUCCESS;
+    } // create()
+
+
+    // get media data on DX surface for further processing
+    int get_surface(ID3D11Texture2D** ppSurface, bool use_nv12)
+    {
+        HRESULT r;
+
+        if (!m_cap.read(m_frame_bgr))
+            return EXIT_FAILURE;
+
+        if (use_nv12)
+        {
+            cv::cvtColor(m_frame_bgr, m_frame_i420, cv::COLOR_BGR2YUV_I420);
+
+            convert_I420_to_NV12(m_frame_i420, m_frame_nv12, m_width, m_height);
+
+            m_pD3D11Ctx->UpdateSubresource(m_pSurfaceNV12, 0, 0, m_frame_nv12.data, (UINT)m_frame_nv12.step[0], (UINT)m_frame_nv12.total());
+        }
+        else
+        {
+            cv::cvtColor(m_frame_bgr, m_frame_rgba, cv::COLOR_BGR2RGBA);
+
+            // process video frame on CPU
+            UINT subResource = ::D3D11CalcSubresource(0, 0, 1);
+
+            D3D11_MAPPED_SUBRESOURCE mappedTex;
+            r = m_pD3D11Ctx->Map(m_pSurfaceRGBA, subResource, D3D11_MAP_WRITE_DISCARD, 0, &mappedTex);
+            if (FAILED(r))
+            {
+                throw std::runtime_error("surface mapping failed!");
+            }
+
+            cv::Mat m(m_height, m_width, CV_8UC4, mappedTex.pData, mappedTex.RowPitch);
+            m_frame_rgba.copyTo(m);
+
+            m_pD3D11Ctx->Unmap(m_pSurfaceRGBA, subResource);
+        }
+
+        *ppSurface = use_nv12 ? m_pSurfaceNV12 : m_pSurfaceRGBA;
+
+        return EXIT_SUCCESS;
+    } // get_surface()
+
+
+    // process and render media data
+    int render()
+    {
+        try
+        {
+            if (m_shutdown)
+                return EXIT_SUCCESS;
+
+            // capture user input once
+            MODE mode = (m_mode == MODE_GPU_NV12 && !m_nv12_available) ? MODE_GPU_RGBA : m_mode;
+
+            HRESULT r;
+            ID3D11Texture2D* pSurface = 0;
+
+            r = get_surface(&pSurface, mode == MODE_GPU_NV12);
+            if (FAILED(r))
+            {
+                throw std::runtime_error("get_surface() failed!");
+            }
+
+            m_timer.reset();
+            m_timer.start();
+
+            switch (mode)
+            {
+            case MODE_CPU:
+            {
+                // process video frame on CPU
+                UINT subResource = ::D3D11CalcSubresource(0, 0, 1);
+
+                D3D11_MAPPED_SUBRESOURCE mappedTex;
+                r = m_pD3D11Ctx->Map(pSurface, subResource, D3D11_MAP_WRITE_DISCARD, 0, &mappedTex);
+                if (FAILED(r))
+                {
+                    throw std::runtime_error("surface mapping failed!");
+                }
+
+                cv::Mat m(m_height, m_width, CV_8UC4, mappedTex.pData, (int)mappedTex.RowPitch);
+
+                if (m_demo_processing)
+                {
+                    // blur data from D3D11 surface with OpenCV on CPU
+                    cv::blur(m, m, cv::Size(15, 15));
+                }
+
+                m_timer.stop();
+
+                cv::String strMode = cv::format("mode: %s", m_modeStr[MODE_CPU].c_str());
+                cv::String strProcessing = m_demo_processing ? "blur frame" : "copy frame";
+                cv::String strTime = cv::format("time: %4.3f msec", m_timer.getTimeMilli());
+                cv::String strDevName = cv::format("OpenCL device: %s", m_oclDevName.c_str());
+
+                cv::putText(m, strMode, cv::Point(0, 20), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                cv::putText(m, strProcessing, cv::Point(0, 40), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                cv::putText(m, strTime, cv::Point(0, 60), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                cv::putText(m, strDevName, cv::Point(0, 80), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+
+                m_pD3D11Ctx->Unmap(pSurface, subResource);
+
+                break;
+            }
+
+            case MODE_GPU_RGBA:
+            case MODE_GPU_NV12:
+            {
+                // process video frame on GPU
+                cv::UMat u;
+
+                cv::directx::convertFromD3D11Texture2D(pSurface, u);
+
+                if (m_demo_processing)
+                {
+                    // blur data from D3D11 surface with OpenCV on GPU with OpenCL
+                    cv::blur(u, u, cv::Size(15, 15));
+                }
+
+                m_timer.stop();
+
+                cv::String strMode = cv::format("mode: %s", m_modeStr[mode].c_str());
+                cv::String strProcessing = m_demo_processing ? "blur frame" : "copy frame";
+                cv::String strTime = cv::format("time: %4.3f msec", m_timer.getTimeMilli());
+                cv::String strDevName = cv::format("OpenCL device: %s", m_oclDevName.c_str());
+
+                cv::putText(u, strMode, cv::Point(0, 20), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                cv::putText(u, strProcessing, cv::Point(0, 40), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                cv::putText(u, strTime, cv::Point(0, 60), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+                cv::putText(u, strDevName, cv::Point(0, 80), cv::FONT_HERSHEY_SIMPLEX, 0.8, cv::Scalar(0, 0, 200), 2);
+
+                cv::directx::convertToD3D11Texture2D(u, pSurface);
+
+                if (mode == MODE_GPU_NV12)
+                {
+                    // just for rendering, we need to convert NV12 to RGBA.
+                    m_pD3D11Ctx->CopyResource(m_pSurfaceNV12_cpu_copy, m_pSurfaceNV12);
+
+                    // process video frame on CPU
+                    {
+                        UINT subResource = ::D3D11CalcSubresource(0, 0, 1);
+
+                        D3D11_MAPPED_SUBRESOURCE mappedTex;
+                        r = m_pD3D11Ctx->Map(m_pSurfaceNV12_cpu_copy, subResource, D3D11_MAP_READ, 0, &mappedTex);
+                        if (FAILED(r))
+                        {
+                            throw std::runtime_error("surface mapping failed!");
+                        }
+
+                        cv::Mat frame_nv12(m_height + (m_height / 2), m_width, CV_8UC1, mappedTex.pData, mappedTex.RowPitch);
+                        cv::cvtColor(frame_nv12, m_frame_rgba, cv::COLOR_YUV2RGBA_NV12);
+
+                        m_pD3D11Ctx->Unmap(m_pSurfaceNV12_cpu_copy, subResource);
+                    }
+
+                    {
+                        UINT subResource = ::D3D11CalcSubresource(0, 0, 1);
+
+                        D3D11_MAPPED_SUBRESOURCE mappedTex;
+                        r = m_pD3D11Ctx->Map(m_pSurfaceRGBA, subResource, D3D11_MAP_WRITE_DISCARD, 0, &mappedTex);
+                        if (FAILED(r))
+                        {
+                            throw std::runtime_error("surface mapping failed!");
+                        }
+
+                        cv::Mat m(m_height, m_width, CV_8UC4, mappedTex.pData, mappedTex.RowPitch);
+                        m_frame_rgba.copyTo(m);
+
+                        m_pD3D11Ctx->Unmap(m_pSurfaceRGBA, subResource);
+                    }
+
+                    pSurface = m_pSurfaceRGBA;
+                }
+
+                break;
+            }
+
+            } // switch
+
+            // traditional DX render pipeline:
+            //   BitBlt surface to backBuffer and flip backBuffer to frontBuffer
+            m_pD3D11Ctx->CopyResource(m_pBackBuffer, pSurface);
+
+            // present the back buffer contents to the display
+            // switch the back buffer and the front buffer
+            r = m_pD3D11SwapChain->Present(0, 0);
+            if (FAILED(r))
+            {
+                throw std::runtime_error("switch betweem fronat and back buffers failed!");
+            }
+        } // try
+
+        catch (const cv::Exception& e)
+        {
+            std::cerr << "Exception: " << e.what() << std::endl;
+            cleanup();
+            return 10;
+        }
+
+        catch (const std::exception& e)
+        {
+            std::cerr << "Exception: " << e.what() << std::endl;
+            cleanup();
+            return 11;
+        }
+
+        return EXIT_SUCCESS;
+    } // render()
+
+
+    int cleanup(void)
+    {
+        SAFE_RELEASE(m_pSurfaceRGBA);
+        SAFE_RELEASE(m_pSurfaceNV12);
+        SAFE_RELEASE(m_pSurfaceNV12_cpu_copy);
+        SAFE_RELEASE(m_pBackBuffer);
+        SAFE_RELEASE(m_pD3D11SwapChain);
+        SAFE_RELEASE(m_pRenderTarget);
+        SAFE_RELEASE(m_pD3D11Dev);
+        SAFE_RELEASE(m_pD3D11Ctx);
+        D3DSample::cleanup();
+        return EXIT_SUCCESS;
+    } // cleanup()
+
+protected:
+    void convert_I420_to_NV12(cv::Mat& i420, cv::Mat& nv12, int width, int height)
+    {
+        nv12.create(i420.rows, i420.cols, CV_8UC1);
+
+        unsigned char* pSrcY = i420.data;
+        unsigned char* pDstY = nv12.data;
+        size_t srcStep = i420.step[0];
+        size_t dstStep = nv12.step[0];
+
+        {
+            unsigned char* src;
+            unsigned char* dst;
+
+            // copy Y plane
+            for (int i = 0; i < height; i++)
+            {
+                src = pSrcY + i*srcStep;
+                dst = pDstY + i*dstStep;
+
+                for (int j = 0; j < width; j++)
+                {
+                    dst[j] = src[j];
+                }
+            }
+        }
+
+        {
+            // copy U/V planes to UV plane
+            unsigned char* pSrcU;
+            unsigned char* pSrcV;
+            unsigned char* pDstUV;
+
+            size_t uv_offset = height * dstStep;
+
+            for (int i = 0; i < height / 2; i++)
+            {
+                pSrcU = pSrcY + height*width + i*(width / 2);
+                pSrcV = pSrcY + height*width + (height / 2) * (width / 2) + i*(width / 2);
+
+                pDstUV = pDstY + uv_offset + i*dstStep;
+
+                for (int j = 0; j < width / 2; j++)
+                {
+                    pDstUV[j*2 + 0] = pSrcU[j];
+                    pDstUV[j*2 + 1] = pSrcV[j];
+                }
+            }
+        }
+
+        return;
+    }
+
+private:
+    ID3D11Device*           m_pD3D11Dev;
+    IDXGISwapChain*         m_pD3D11SwapChain;
+    ID3D11DeviceContext*    m_pD3D11Ctx;
+    ID3D11Texture2D*        m_pBackBuffer;
+    ID3D11Texture2D*        m_pSurfaceRGBA;
+    ID3D11Texture2D*        m_pSurfaceNV12;
+    ID3D11Texture2D*        m_pSurfaceNV12_cpu_copy;
+    ID3D11RenderTargetView* m_pRenderTarget;
+    cv::ocl::Context        m_oclCtx;
+    cv::String              m_oclPlatformName;
+    cv::String              m_oclDevName;
+    bool                    m_nv12_available;
+    cv::Mat                 m_frame_i420;
+    cv::Mat                 m_frame_nv12;
+};
+
+
+// main func
+int main(int argc, char** argv)
+{
+    std::string title = "D3D11 interop sample";
+    return d3d_app<D3D11WinApp>(argc, argv, title);
+}
diff --git a/C++/opencv-4.7.0/samples/directx/d3d9_interop.cpp b/C++/opencv-4.7.0/samples/directx/d3d9_interop.cpp
new file mode 100644
index 00000000..8c308721
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/directx/d3d9_interop.cpp
@@ -0,0 +1,313 @@
+/*
+// A sample program demonstrating interoperability of OpenCV cv::UMat with Direct X surface
+// At first, the data obtained from video file or camera and placed onto Direct X surface,
+// following mapping of this Direct X surface to OpenCV cv::UMat and call cv::Blur function.
+// The result is mapped back to Direct X surface and rendered through Direct X API.
+*/
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <d3d9.h>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/directx.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+
+#include "d3dsample.hpp"
+
+
+
+class D3D9WinApp : public D3DSample
+{
+public:
+    D3D9WinApp(int width, int height, std::string& window_name, cv::VideoCapture& cap) :
+        D3DSample(width, height, window_name, cap) {}
+
+    ~D3D9WinApp() {}
+
+    int create(void)
+    {
+        // base initialization
+        D3DSample::create();
+
+        // initialize DirectX
+        HRESULT r;
+
+        m_pD3D9 = ::Direct3DCreate9(D3D_SDK_VERSION);
+        if (NULL == m_pD3D9)
+        {
+            return EXIT_FAILURE;
+        }
+
+        DWORD flags = D3DCREATE_HARDWARE_VERTEXPROCESSING |
+                      D3DCREATE_PUREDEVICE |
+                      D3DCREATE_NOWINDOWCHANGES |
+                      D3DCREATE_MULTITHREADED |
+                      D3DCREATE_FPU_PRESERVE;
+
+        D3DPRESENT_PARAMETERS d3dpp;
+        ::ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
+
+        d3dpp.Windowed                   = true;
+        d3dpp.Flags                      = 0;
+        d3dpp.BackBufferCount            = 0;
+        d3dpp.BackBufferFormat           = D3DFMT_A8R8G8B8;
+        d3dpp.BackBufferHeight           = m_height;
+        d3dpp.BackBufferWidth            = m_width;
+        d3dpp.MultiSampleType            = D3DMULTISAMPLE_NONE;
+        d3dpp.SwapEffect                 = D3DSWAPEFFECT_DISCARD;
+        d3dpp.hDeviceWindow              = m_hWnd;
+        d3dpp.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;
+        d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
+
+        r = m_pD3D9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hWnd, flags, &d3dpp, &m_pD3D9Dev);
+        if (FAILED(r))
+        {
+            return EXIT_FAILURE;
+        }
+
+        r = m_pD3D9Dev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &m_pBackBuffer);
+        if (FAILED(r))
+        {
+            return EXIT_FAILURE;
+        }
+
+        r = m_pD3D9Dev->CreateOffscreenPlainSurface(m_width, m_height, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pSurface, NULL);
+        if (FAILED(r))
+        {
+            std::cerr << "Can't create surface for result" << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        // initialize OpenCL context of OpenCV lib from DirectX
+        if (cv::ocl::haveOpenCL())
+        {
+            m_oclCtx = cv::directx::ocl::initializeContextFromDirect3DDevice9(m_pD3D9Dev);
+        }
+
+        m_oclDevName = cv::ocl::useOpenCL() ?
+            cv::ocl::Context::getDefault().device(0).name() :
+            "No OpenCL device";
+
+        return EXIT_SUCCESS;
+    } // create()
+
+
+    // get media data on DX surface for further processing
+    int get_surface(LPDIRECT3DSURFACE9* ppSurface)
+    {
+        HRESULT r;
+
+        if (!m_cap.read(m_frame_bgr))
+            return EXIT_FAILURE;
+
+        cv::cvtColor(m_frame_bgr, m_frame_rgba, cv::COLOR_BGR2BGRA);
+
+        D3DLOCKED_RECT memDesc = { 0, NULL };
+        RECT rc = { 0, 0, m_width, m_height };
+
+        r = m_pSurface->LockRect(&memDesc, &rc, 0);
+        if (FAILED(r))
+        {
+            return r;
+        }
+
+        cv::Mat m(m_height, m_width, CV_8UC4, memDesc.pBits, memDesc.Pitch);
+        // copy video frame data to surface
+        m_frame_rgba.copyTo(m);
+
+        r = m_pSurface->UnlockRect();
+        if (FAILED(r))
+        {
+            return r;
+        }
+
+        *ppSurface = m_pSurface;
+
+        return EXIT_SUCCESS;
+    } // get_surface()
+
+
+    // process and render media data
+    int render()
+    {
+        try
+        {
+            if (m_shutdown)
+                return EXIT_SUCCESS;
+
+            // capture user input once
+            MODE mode = (m_mode == MODE_GPU_NV12) ? MODE_GPU_RGBA : m_mode;
+
+            HRESULT r;
+            LPDIRECT3DSURFACE9 pSurface;
+
+            r = get_surface(&pSurface);
+            if (FAILED(r))
+            {
+                return EXIT_FAILURE;
+            }
+
+            m_timer.reset();
+            m_timer.start();
+
+            switch (mode)
+            {
+                case MODE_CPU:
+                {
+                    // process video frame on CPU
+                    D3DLOCKED_RECT memDesc = { 0, NULL };
+                    RECT rc = { 0, 0, m_width, m_height };
+
+                    r = pSurface->LockRect(&memDesc, &rc, 0);
+                    if (FAILED(r))
+                    {
+                        return EXIT_FAILURE;
+                    }
+
+                    cv::Mat m(m_height, m_width, CV_8UC4, memDesc.pBits, memDesc.Pitch);
+
+                    if (m_demo_processing)
+                    {
+                        // blur D3D9 surface with OpenCV on CPU
+                        cv::blur(m, m, cv::Size(15, 15));
+                    }
+
+                    r = pSurface->UnlockRect();
+                    if (FAILED(r))
+                    {
+                        return EXIT_FAILURE;
+                    }
+
+                    break;
+                }
+
+                case MODE_GPU_RGBA:
+                {
+                    // process video frame on GPU
+                    cv::UMat u;
+
+                    cv::directx::convertFromDirect3DSurface9(pSurface, u);
+
+                    if (m_demo_processing)
+                    {
+                        // blur D3D9 surface with OpenCV on GPU with OpenCL
+                        cv::blur(u, u, cv::Size(15, 15));
+                    }
+
+                    cv::directx::convertToDirect3DSurface9(u, pSurface);
+
+                    break;
+                }
+
+            } // switch
+
+            m_timer.stop();
+
+            print_info(pSurface, mode, m_timer.getTimeMilli(), m_oclDevName);
+
+            // traditional DX render pipeline:
+            //   BitBlt surface to backBuffer and flip backBuffer to frontBuffer
+            r = m_pD3D9Dev->StretchRect(pSurface, NULL, m_pBackBuffer, NULL, D3DTEXF_NONE);
+            if (FAILED(r))
+            {
+                return EXIT_FAILURE;
+            }
+
+            // present the back buffer contents to the display
+            r = m_pD3D9Dev->Present(NULL, NULL, NULL, NULL);
+            if (FAILED(r))
+            {
+                return EXIT_FAILURE;
+            }
+        }  // try
+
+        catch (const cv::Exception& e)
+        {
+            std::cerr << "Exception: " << e.what() << std::endl;
+            return 10;
+        }
+
+        return EXIT_SUCCESS;
+    } // render()
+
+
+    void print_info(LPDIRECT3DSURFACE9 pSurface, int mode, double time, cv::String oclDevName)
+    {
+        HDC hDC;
+
+        HRESULT r = pSurface->GetDC(&hDC);
+        if (FAILED(r))
+        {
+            return;
+        }
+
+        HFONT hFont = (HFONT)::GetStockObject(SYSTEM_FONT);
+
+        HFONT hOldFont = (HFONT)::SelectObject(hDC, hFont);
+
+        if (hOldFont)
+        {
+            TEXTMETRIC tm;
+            ::GetTextMetrics(hDC, &tm);
+
+            char buf[256];
+            int  y = 0;
+
+            buf[0] = 0;
+            snprintf(buf, sizeof(buf), "mode: %s", m_modeStr[mode].c_str());
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            y += tm.tmHeight;
+            buf[0] = 0;
+            snprintf(buf, sizeof(buf), m_demo_processing ? "blur frame" : "copy frame");
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            y += tm.tmHeight;
+            buf[0] = 0;
+            snprintf(buf, sizeof(buf), "time: %4.1f msec", time);
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            y += tm.tmHeight;
+            buf[0] = 0;
+            snprintf(buf, sizeof(buf), "OpenCL device: %s", oclDevName.c_str());
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            ::SelectObject(hDC, hOldFont);
+        }
+
+        r = pSurface->ReleaseDC(hDC);
+
+        return;
+    } // print_info()
+
+
+    int cleanup(void)
+    {
+        SAFE_RELEASE(m_pSurface);
+        SAFE_RELEASE(m_pBackBuffer);
+        SAFE_RELEASE(m_pD3D9Dev);
+        SAFE_RELEASE(m_pD3D9);
+        D3DSample::cleanup();
+        return EXIT_SUCCESS;
+    } // cleanup()
+
+private:
+    LPDIRECT3D9        m_pD3D9;
+    LPDIRECT3DDEVICE9  m_pD3D9Dev;
+    LPDIRECT3DSURFACE9 m_pBackBuffer;
+    LPDIRECT3DSURFACE9 m_pSurface;
+    cv::ocl::Context   m_oclCtx;
+    cv::String         m_oclPlatformName;
+    cv::String         m_oclDevName;
+};
+
+
+// main func
+int main(int argc, char** argv)
+{
+    std::string title = "D3D9 interop sample";
+    return d3d_app<D3D9WinApp>(argc, argv, title);
+}
diff --git a/C++/opencv-4.7.0/samples/directx/d3d9ex_interop.cpp b/C++/opencv-4.7.0/samples/directx/d3d9ex_interop.cpp
new file mode 100644
index 00000000..39dda84b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/directx/d3d9ex_interop.cpp
@@ -0,0 +1,314 @@
+/*
+// A sample program demonstrating interoperability of OpenCV cv::UMat with Direct X surface
+// At first, the data obtained from video file or camera and placed onto Direct X surface,
+// following mapping of this Direct X surface to OpenCV cv::UMat and call cv::Blur function.
+// The result is mapped back to Direct X surface and rendered through Direct X API.
+*/
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <d3d9.h>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/directx.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+
+#include "d3dsample.hpp"
+
+
+
+class D3D9ExWinApp : public D3DSample
+{
+public:
+    D3D9ExWinApp(int width, int height, std::string& window_name, cv::VideoCapture& cap) :
+        D3DSample(width, height, window_name, cap) {}
+
+    ~D3D9ExWinApp() {}
+
+    int create(void)
+    {
+        // base initialization
+        D3DSample::create();
+
+        // initialize DirectX
+        HRESULT r;
+
+        r = ::Direct3DCreate9Ex(D3D_SDK_VERSION, &m_pD3D9Ex);
+        if (FAILED(r))
+        {
+            return EXIT_FAILURE;
+        }
+
+        DWORD flags = D3DCREATE_HARDWARE_VERTEXPROCESSING |
+                      D3DCREATE_PUREDEVICE |
+                      D3DCREATE_NOWINDOWCHANGES |
+                      D3DCREATE_MULTITHREADED |
+                      D3DCREATE_FPU_PRESERVE;
+
+        D3DPRESENT_PARAMETERS d3dpp;
+        ::ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
+
+        d3dpp.Windowed                   = true;
+        d3dpp.Flags                      = 0;
+        d3dpp.BackBufferCount            = 0;
+        d3dpp.BackBufferFormat           = D3DFMT_A8R8G8B8;
+        d3dpp.BackBufferHeight           = m_height;
+        d3dpp.BackBufferWidth            = m_width;
+        d3dpp.MultiSampleType            = D3DMULTISAMPLE_NONE;
+        d3dpp.SwapEffect                 = D3DSWAPEFFECT_DISCARD;
+        d3dpp.hDeviceWindow              = m_hWnd;
+        d3dpp.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;
+        d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
+
+        r = m_pD3D9Ex->CreateDeviceEx(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hWnd, flags, &d3dpp, NULL, &m_pD3D9DevEx);
+        if (FAILED(r))
+        {
+            return EXIT_FAILURE;
+        }
+
+        r = m_pD3D9DevEx->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &m_pBackBuffer);
+        if (FAILED(r))
+        {
+            return EXIT_FAILURE;
+        }
+
+        r = m_pD3D9DevEx->CreateOffscreenPlainSurface(m_width, m_height, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pSurface, NULL);
+        if (FAILED(r))
+        {
+            std::cerr << "Can't create surface for result" << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        // initialize OpenCL context of OpenCV lib from DirectX
+        if (cv::ocl::haveOpenCL())
+        {
+            m_oclCtx = cv::directx::ocl::initializeContextFromDirect3DDevice9(m_pD3D9DevEx);
+        }
+
+        m_oclDevName = cv::ocl::useOpenCL() ?
+            cv::ocl::Context::getDefault().device(0).name() :
+            "No OpenCL device";
+
+        return EXIT_SUCCESS;
+    } // create()
+
+
+    // get media data on DX surface for further processing
+    int get_surface(LPDIRECT3DSURFACE9* ppSurface)
+    {
+        HRESULT r;
+
+        if (!m_cap.read(m_frame_bgr))
+            return EXIT_FAILURE;
+
+        cv::cvtColor(m_frame_bgr, m_frame_rgba, cv::COLOR_BGR2BGRA);
+
+        D3DLOCKED_RECT memDesc = { 0, NULL };
+        RECT rc = { 0, 0, m_width, m_height };
+
+        r = m_pSurface->LockRect(&memDesc, &rc, 0);
+        if (FAILED(r))
+        {
+            return r;
+        }
+
+        cv::Mat m(m_height, m_width, CV_8UC4, memDesc.pBits, memDesc.Pitch);
+        // copy video frame data to surface
+        m_frame_rgba.copyTo(m);
+
+        r = m_pSurface->UnlockRect();
+        if (FAILED(r))
+        {
+            return r;
+        }
+
+        *ppSurface = m_pSurface;
+
+        return EXIT_SUCCESS;
+    } // get_surface()
+
+
+    // process and render media data
+    int render()
+    {
+        try
+        {
+            if (m_shutdown)
+                return EXIT_SUCCESS;
+
+            // capture user input once
+            MODE mode = m_mode == MODE_GPU_NV12 ? MODE_GPU_RGBA : m_mode;
+
+            HRESULT r;
+            LPDIRECT3DSURFACE9 pSurface;
+
+            r = get_surface(&pSurface);
+            if (FAILED(r))
+            {
+                return EXIT_FAILURE;
+            }
+
+            m_timer.reset();
+            m_timer.start();
+
+            switch (mode)
+            {
+                case MODE_CPU:
+                {
+                    // process video frame on CPU
+                    D3DLOCKED_RECT memDesc = { 0, NULL };
+                    RECT rc = { 0, 0, m_width, m_height };
+
+                    r = pSurface->LockRect(&memDesc, &rc, 0);
+                    if (FAILED(r))
+                    {
+                        return EXIT_FAILURE;
+                    }
+
+                    cv::Mat m(m_height, m_width, CV_8UC4, memDesc.pBits, memDesc.Pitch);
+
+                    if (m_demo_processing)
+                    {
+                        // blur D3D9 surface with OpenCV on CPU
+                        cv::blur(m, m, cv::Size(15, 15));
+                    }
+
+                    r = pSurface->UnlockRect();
+                    if (FAILED(r))
+                    {
+                        return EXIT_FAILURE;
+                    }
+
+                    break;
+                }
+
+                case MODE_GPU_RGBA:
+                {
+                    // process video frame on GPU
+                    cv::UMat u;
+
+                    cv::directx::convertFromDirect3DSurface9(pSurface, u);
+
+                    if (m_demo_processing)
+                    {
+                        // blur D3D9 surface with OpenCV on GPU with OpenCL
+                        cv::blur(u, u, cv::Size(15, 15));
+                    }
+
+                    cv::directx::convertToDirect3DSurface9(u, pSurface);
+
+                    break;
+                }
+
+            } // switch
+
+            m_timer.stop();
+
+            print_info(pSurface, m_mode, m_timer.getTimeMilli(), m_oclDevName);
+
+            // traditional DX render pipeline:
+            //   BitBlt surface to backBuffer and flip backBuffer to frontBuffer
+            r = m_pD3D9DevEx->StretchRect(pSurface, NULL, m_pBackBuffer, NULL, D3DTEXF_NONE);
+            if (FAILED(r))
+            {
+                return EXIT_FAILURE;
+            }
+
+            // present the back buffer contents to the display
+            r = m_pD3D9DevEx->Present(NULL, NULL, NULL, NULL);
+            if (FAILED(r))
+            {
+                return EXIT_FAILURE;
+            }
+
+        } // try
+
+        catch (const cv::Exception& e)
+        {
+            std::cerr << "Exception: " << e.what() << std::endl;
+            return 10;
+        }
+
+        return EXIT_SUCCESS;
+    } // render()
+
+
+    void print_info(LPDIRECT3DSURFACE9 pSurface, int mode, double time, cv::String oclDevName)
+    {
+        HDC hDC;
+
+        HRESULT r = pSurface->GetDC(&hDC);
+        if (FAILED(r))
+        {
+            return;
+        }
+
+        HFONT hFont = (HFONT)::GetStockObject(SYSTEM_FONT);
+
+        HFONT hOldFont = (HFONT)::SelectObject(hDC, hFont);
+
+        if (hOldFont)
+        {
+            TEXTMETRIC tm;
+            ::GetTextMetrics(hDC, &tm);
+
+            char buf[256];
+            int  y = 0;
+
+            buf[0] = 0;
+            snprintf(buf, sizeof(buf), "mode: %s", m_modeStr[mode].c_str());
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            y += tm.tmHeight;
+            buf[0] = 0;
+            snprintf(buf, sizeof(buf), m_demo_processing ? "blur frame" : "copy frame");
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            y += tm.tmHeight;
+            buf[0] = 0;
+            snprintf(buf, sizeof(buf), "time: %4.1f msec", time);
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            y += tm.tmHeight;
+            buf[0] = 0;
+            snprintf(buf, sizeof(buf), "OpenCL device: %s", oclDevName.c_str());
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            ::SelectObject(hDC, hOldFont);
+        }
+
+        r = pSurface->ReleaseDC(hDC);
+
+        return;
+    } // print_info()
+
+
+    int cleanup(void)
+    {
+        SAFE_RELEASE(m_pSurface);
+        SAFE_RELEASE(m_pBackBuffer);
+        SAFE_RELEASE(m_pD3D9DevEx);
+        SAFE_RELEASE(m_pD3D9Ex);
+        D3DSample::cleanup();
+        return EXIT_SUCCESS;
+    } // cleanup()
+
+private:
+    LPDIRECT3D9EX        m_pD3D9Ex;
+    LPDIRECT3DDEVICE9EX  m_pD3D9DevEx;
+    LPDIRECT3DSURFACE9   m_pBackBuffer;
+    LPDIRECT3DSURFACE9   m_pSurface;
+    cv::ocl::Context     m_oclCtx;
+    cv::String           m_oclPlatformName;
+    cv::String           m_oclDevName;
+};
+
+
+// main func
+int main(int argc, char** argv)
+{
+    std::string title = "D3D9Ex interop sample";
+    return d3d_app<D3D9ExWinApp>(argc, argv, title);
+}
diff --git a/C++/opencv-4.7.0/samples/directx/d3dsample.hpp b/C++/opencv-4.7.0/samples/directx/d3dsample.hpp
new file mode 100644
index 00000000..b78af8ef
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/directx/d3dsample.hpp
@@ -0,0 +1,172 @@
+/*
+// Sample demonstrating interoperability of OpenCV UMat with Direct X surface
+// Base class for Direct X application
+*/
+#include <string>
+#include <iostream>
+#include <queue>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/directx.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+
+#include "winapp.hpp"
+
+#define SAFE_RELEASE(p) if (p) { p->Release(); p = NULL; }
+
+
+class D3DSample : public WinApp
+{
+public:
+    enum MODE
+    {
+        MODE_CPU,
+        MODE_GPU_RGBA,
+        MODE_GPU_NV12
+    };
+
+    D3DSample(int width, int height, std::string& window_name, cv::VideoCapture& cap) :
+        WinApp(width, height, window_name)
+    {
+        m_shutdown          = false;
+        m_mode              = MODE_CPU;
+        m_modeStr[0]        = cv::String("Processing on CPU");
+        m_modeStr[1]        = cv::String("Processing on GPU RGBA");
+        m_modeStr[2]        = cv::String("Processing on GPU NV12");
+        m_demo_processing   = false;
+        m_cap               = cap;
+    }
+
+    ~D3DSample() {}
+
+    virtual int create() { return WinApp::create(); }
+    virtual int render() = 0;
+    virtual int cleanup()
+    {
+        m_shutdown = true;
+        return WinApp::cleanup();
+    }
+
+protected:
+    virtual LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+    {
+        switch (message)
+        {
+        case WM_CHAR:
+            if (wParam == '1')
+            {
+                m_mode = MODE_CPU;
+                return EXIT_SUCCESS;
+            }
+            if (wParam == '2')
+            {
+                m_mode = MODE_GPU_RGBA;
+                return EXIT_SUCCESS;
+            }
+            if (wParam == '3')
+            {
+                m_mode = MODE_GPU_NV12;
+                return EXIT_SUCCESS;
+            }
+            else if (wParam == VK_SPACE)
+            {
+                m_demo_processing = !m_demo_processing;
+                return EXIT_SUCCESS;
+            }
+            else if (wParam == VK_ESCAPE)
+            {
+                return cleanup();
+            }
+            break;
+
+        case WM_CLOSE:
+            return cleanup();
+
+        case WM_DESTROY:
+            ::PostQuitMessage(0);
+            return EXIT_SUCCESS;
+        }
+
+        return ::DefWindowProc(hWnd, message, wParam, lParam);
+    }
+
+    // do render at idle
+    virtual int idle() { return render(); }
+
+protected:
+    bool               m_shutdown;
+    bool               m_demo_processing;
+    MODE               m_mode;
+    cv::String         m_modeStr[3];
+    cv::VideoCapture   m_cap;
+    cv::Mat            m_frame_bgr;
+    cv::Mat            m_frame_rgba;
+    cv::TickMeter      m_timer;
+};
+
+
+static const char* keys =
+{
+    "{c camera | 0     | camera id  }"
+    "{f file   |       | movie file name  }"
+};
+
+
+template <typename TApp>
+int d3d_app(int argc, char** argv, std::string& title)
+{
+    cv::CommandLineParser parser(argc, argv, keys);
+    std::string file = parser.get<std::string>("file");
+    int    camera_id = parser.get<int>("camera");
+
+    parser.about(
+        "\nA sample program demonstrating interoperability of DirectX and OpenCL with OpenCV.\n\n"
+        "Hot keys: \n"
+        "  SPACE - turn processing on/off\n"
+        "    1   - process DX surface through OpenCV on CPU\n"
+        "    2   - process DX RGBA surface through OpenCV on GPU (via OpenCL)\n"
+        "    3   - process DX NV12 surface through OpenCV on GPU (via OpenCL)\n"
+        "   ESC  - exit\n\n");
+
+    parser.printMessage();
+
+    cv::VideoCapture cap;
+
+    if (file.empty())
+        cap.open(camera_id);
+    else
+        cap.open(file.c_str());
+
+    if (!cap.isOpened())
+    {
+        printf("can not open camera or video file\n");
+        return EXIT_FAILURE;
+    }
+
+    int width  = (int)cap.get(cv::CAP_PROP_FRAME_WIDTH);
+    int height = (int)cap.get(cv::CAP_PROP_FRAME_HEIGHT);
+
+    std::string wndname = title;
+
+    TApp app(width, height, wndname, cap);
+
+    try
+    {
+        app.create();
+        return app.run();
+    }
+
+    catch (const cv::Exception& e)
+    {
+        std::cerr << "Exception: " << e.what() << std::endl;
+        return 10;
+    }
+
+    catch (...)
+    {
+        std::cerr << "FATAL ERROR: Unknown exception" << std::endl;
+        return 11;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/directx/winapp.hpp b/C++/opencv-4.7.0/samples/directx/winapp.hpp
new file mode 100644
index 00000000..bb9041f0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/directx/winapp.hpp
@@ -0,0 +1,132 @@
+/*
+// Sample demonstrating interoperability of OpenCV UMat with Direct X surface
+// Base class for Windows application
+*/
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <string>
+
+
+#define WINCLASS "WinAppWnd"
+
+class WinApp
+{
+public:
+    WinApp(int width, int height, std::string& window_name)
+    {
+        m_width       = width;
+        m_height      = height;
+        m_window_name = window_name;
+        m_hInstance   = ::GetModuleHandle(NULL);
+        m_hWnd        = 0;
+    }
+
+    virtual ~WinApp() {}
+
+
+    virtual int create()
+    {
+        WNDCLASSEX wcex;
+
+        wcex.cbSize        = sizeof(WNDCLASSEX);
+        wcex.style         = CS_HREDRAW | CS_VREDRAW;
+        wcex.lpfnWndProc   = &WinApp::StaticWndProc;
+        wcex.cbClsExtra    = 0;
+        wcex.cbWndExtra    = 0;
+        wcex.hInstance     = m_hInstance;
+        wcex.hIcon         = LoadIcon(0, IDI_APPLICATION);
+        wcex.hCursor       = LoadCursor(0, IDC_ARROW);
+        wcex.hbrBackground = 0;
+        wcex.lpszMenuName  = 0L;
+        wcex.lpszClassName = WINCLASS;
+        wcex.hIconSm       = 0;
+
+        ATOM wc = ::RegisterClassEx(&wcex);
+        if (!wc)
+            return -1;
+
+        RECT rc = { 0, 0, m_width, m_height };
+        if(!::AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, false))
+            return -1;
+
+        m_hWnd = ::CreateWindow(
+                     (LPCTSTR)wc, m_window_name.c_str(),
+                     WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
+                     rc.right - rc.left, rc.bottom - rc.top,
+                     NULL, NULL, m_hInstance, (void*)this);
+
+        if (!m_hWnd)
+            return -1;
+
+        ::ShowWindow(m_hWnd, SW_SHOW);
+        ::UpdateWindow(m_hWnd);
+        ::SetFocus(m_hWnd);
+
+        return 0;
+    } // create()
+
+
+    int run()
+    {
+        MSG msg;
+
+        ::ZeroMemory(&msg, sizeof(msg));
+
+        while (msg.message != WM_QUIT)
+        {
+            if (::PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
+            {
+                ::TranslateMessage(&msg);
+                ::DispatchMessage(&msg);
+            }
+            else
+            {
+                idle();
+            }
+        }
+
+        return static_cast<int>(msg.wParam);
+    } // run()
+
+
+    virtual int cleanup()
+    {
+        ::DestroyWindow(m_hWnd);
+        ::UnregisterClass(WINCLASS, m_hInstance);
+        return 0;
+    } // cleanup()
+
+protected:
+    // dispatch message handling to method of class
+    static LRESULT CALLBACK StaticWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+    {
+        WinApp* pWnd;
+
+        if (message == WM_NCCREATE)
+        {
+            LPCREATESTRUCT pCreateStruct = reinterpret_cast<LPCREATESTRUCT>(lParam);
+            pWnd = static_cast<WinApp*>(pCreateStruct->lpCreateParams);
+            ::SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(pWnd));
+        }
+
+        pWnd = GetObjectFromWindow(hWnd);
+
+        if (pWnd)
+            return pWnd->WndProc(hWnd, message, wParam, lParam);
+        else
+            return ::DefWindowProc(hWnd, message, wParam, lParam);
+    } // StaticWndProc()
+
+    inline static WinApp* GetObjectFromWindow(HWND hWnd) { return (WinApp*)::GetWindowLongPtr(hWnd, GWLP_USERDATA); }
+
+    // actual wnd message handling
+    virtual LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) = 0;
+    // idle processing
+    virtual int idle() = 0;
+
+    HINSTANCE   m_hInstance;
+    HWND        m_hWnd;
+    int         m_width;
+    int         m_height;
+    std::string m_window_name;
+};
diff --git a/C++/opencv-4.7.0/samples/dnn/CMakeLists.txt b/C++/opencv-4.7.0/samples/dnn/CMakeLists.txt
new file mode 100644
index 00000000..9a1aeed3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/CMakeLists.txt
@@ -0,0 +1,24 @@
+ocv_install_example_src(dnn *.cpp *.hpp CMakeLists.txt)
+
+set(OPENCV_DNN_SAMPLES_REQUIRED_DEPS
+  opencv_core
+  opencv_imgproc
+  opencv_dnn
+  opencv_objdetect
+  opencv_video
+  opencv_imgcodecs
+  opencv_videoio
+  opencv_highgui)
+ocv_check_dependencies(${OPENCV_DNN_SAMPLES_REQUIRED_DEPS})
+
+if(NOT BUILD_EXAMPLES OR NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+project(dnn_samples)
+ocv_include_modules_recurse(${OPENCV_DNN_SAMPLES_REQUIRED_DEPS})
+file(GLOB_RECURSE dnn_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+foreach(sample_filename ${dnn_samples})
+  ocv_define_sample(tgt ${sample_filename} dnn)
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_DNN_SAMPLES_REQUIRED_DEPS})
+endforeach()
diff --git a/C++/opencv-4.7.0/samples/dnn/README.md b/C++/opencv-4.7.0/samples/dnn/README.md
new file mode 100644
index 00000000..b31da10b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/README.md
@@ -0,0 +1,84 @@
+# OpenCV deep learning module samples
+
+## Model Zoo
+
+Check [a wiki](https://github.com/opencv/opencv/wiki/Deep-Learning-in-OpenCV) for a list of tested models.
+
+If OpenCV is built with [Intel's Inference Engine support](https://github.com/opencv/opencv/wiki/Intel%27s-Deep-Learning-Inference-Engine-backend) you can use [Intel's pre-trained](https://github.com/opencv/open_model_zoo) models.
+
+There are different preprocessing parameters such mean subtraction or scale factors for different models.
+You may check the most popular models and their parameters at [models.yml](https://github.com/opencv/opencv/blob/4.x/samples/dnn/models.yml) configuration file. It might be also used for aliasing samples parameters. In example,
+
+```bash
+python object_detection.py opencv_fd --model /path/to/caffemodel --config /path/to/prototxt
+```
+
+Check `-h` option to know which values are used by default:
+
+```bash
+python object_detection.py opencv_fd -h
+```
+
+### Sample models
+
+You can download sample models using ```download_models.py```. For example, the following command will download network weights for OpenCV Face Detector model and store them in FaceDetector folder:
+
+```bash
+python download_models.py --save_dir FaceDetector opencv_fd
+```
+
+You can use default configuration files adopted for OpenCV from [here](https://github.com/opencv/opencv_extra/tree/4.x/testdata/dnn).
+
+You also can use the script to download necessary files from your code. Assume you have the following code inside ```your_script.py```:
+
+```python
+from download_models import downloadFile
+
+filepath1 = downloadFile("https://drive.google.com/uc?export=download&id=0B3gersZ2cHIxRm5PMWRoTkdHdHc", None, filename="MobileNetSSD_deploy.caffemodel", save_dir="save_dir_1")
+filepath2 = downloadFile("https://drive.google.com/uc?export=download&id=0B3gersZ2cHIxRm5PMWRoTkdHdHc", "994d30a8afaa9e754d17d2373b2d62a7dfbaaf7a", filename="MobileNetSSD_deploy.caffemodel")
+print(filepath1)
+print(filepath2)
+# Your code
+```
+
+By running the following commands, you will get **MobileNetSSD_deploy.caffemodel** file:
+```bash
+export OPENCV_DOWNLOAD_DATA_PATH=download_folder
+python your_script.py
+```
+
+**Note** that you can provide a directory using **save_dir** parameter or via **OPENCV_SAVE_DIR** environment variable.
+
+#### Face detection
+[An origin model](https://github.com/opencv/opencv/tree/4.x/samples/dnn/face_detector)
+with single precision floating point weights has been quantized using [TensorFlow framework](https://www.tensorflow.org/).
+To achieve the best accuracy run the model on BGR images resized to `300x300` applying mean subtraction
+of values `(104, 177, 123)` for each blue, green and red channels correspondingly.
+
+The following are accuracy metrics obtained using [COCO object detection evaluation
+tool](http://cocodataset.org/#detections-eval) on [FDDB dataset](http://vis-www.cs.umass.edu/fddb/)
+(see [script](https://github.com/opencv/opencv/blob/4.x/modules/dnn/misc/face_detector_accuracy.py))
+applying resize to `300x300` and keeping an origin images' sizes.
+```
+AP - Average Precision                            | FP32/FP16 | UINT8          | FP32/FP16 | UINT8          |
+AR - Average Recall                               | 300x300   | 300x300        | any size  | any size       |
+--------------------------------------------------|-----------|----------------|-----------|----------------|
+AP @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] | 0.408     | 0.408          | 0.378     | 0.328 (-0.050) |
+AP @[ IoU=0.50      | area=   all | maxDets=100 ] | 0.849     | 0.849          | 0.797     | 0.790 (-0.007) |
+AP @[ IoU=0.75      | area=   all | maxDets=100 ] | 0.251     | 0.251          | 0.208     | 0.140 (-0.068) |
+AP @[ IoU=0.50:0.95 | area= small | maxDets=100 ] | 0.050     | 0.051 (+0.001) | 0.107     | 0.070 (-0.037) |
+AP @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] | 0.381     | 0.379 (-0.002) | 0.380     | 0.368 (-0.012) |
+AP @[ IoU=0.50:0.95 | area= large | maxDets=100 ] | 0.455     | 0.455          | 0.412     | 0.337 (-0.075) |
+AR @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] | 0.299     | 0.299          | 0.279     | 0.246 (-0.033) |
+AR @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] | 0.482     | 0.482          | 0.476     | 0.436 (-0.040) |
+AR @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] | 0.496     | 0.496          | 0.491     | 0.451 (-0.040) |
+AR @[ IoU=0.50:0.95 | area= small | maxDets=100 ] | 0.189     | 0.193 (+0.004) | 0.284     | 0.232 (-0.052) |
+AR @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] | 0.481     | 0.480 (-0.001) | 0.470     | 0.458 (-0.012) |
+AR @[ IoU=0.50:0.95 | area= large | maxDets=100 ] | 0.528     | 0.528          | 0.520     | 0.462 (-0.058) |
+```
+
+## References
+* [Models downloading script](https://github.com/opencv/opencv/samples/dnn/download_models.py)
+* [Configuration files adopted for OpenCV](https://github.com/opencv/opencv_extra/tree/4.x/testdata/dnn)
+* [How to import models from TensorFlow Object Detection API](https://github.com/opencv/opencv/wiki/TensorFlow-Object-Detection-API)
+* [Names of classes from different datasets](https://github.com/opencv/opencv/tree/4.x/samples/data/dnn)
diff --git a/C++/opencv-4.7.0/samples/dnn/action_recognition.py b/C++/opencv-4.7.0/samples/dnn/action_recognition.py
new file mode 100644
index 00000000..f2f37303
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/action_recognition.py
@@ -0,0 +1,82 @@
+import os
+import numpy as np
+import cv2 as cv
+import argparse
+from common import findFile
+
+parser = argparse.ArgumentParser(description='Use this script to run action recognition using 3D ResNet34',
+                                 formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+parser.add_argument('--input', '-i', help='Path to input video file. Skip this argument to capture frames from a camera.')
+parser.add_argument('--model', required=True, help='Path to model.')
+parser.add_argument('--classes', default=findFile('action_recongnition_kinetics.txt'), help='Path to classes list.')
+
+# To get net download original repository https://github.com/kenshohara/video-classification-3d-cnn-pytorch
+# For correct ONNX export modify file: video-classification-3d-cnn-pytorch/models/resnet.py
+# change
+# - def downsample_basic_block(x, planes, stride):
+# -     out = F.avg_pool3d(x, kernel_size=1, stride=stride)
+# -     zero_pads = torch.Tensor(out.size(0), planes - out.size(1),
+# -                              out.size(2), out.size(3),
+# -                              out.size(4)).zero_()
+# -     if isinstance(out.data, torch.cuda.FloatTensor):
+# -         zero_pads = zero_pads.cuda()
+# -
+# -     out = Variable(torch.cat([out.data, zero_pads], dim=1))
+# -     return out
+
+# To
+# + def downsample_basic_block(x, planes, stride):
+# +     out = F.avg_pool3d(x, kernel_size=1, stride=stride)
+# +     out = F.pad(out, (0, 0, 0, 0, 0, 0, 0, int(planes - out.size(1)), 0, 0), "constant", 0)
+# +     return out
+
+# To ONNX export use torch.onnx.export(model, inputs, model_name)
+
+def get_class_names(path):
+    class_names = []
+    with open(path) as f:
+        for row in f:
+            class_names.append(row[:-1])
+    return class_names
+
+def classify_video(video_path, net_path):
+    SAMPLE_DURATION = 16
+    SAMPLE_SIZE = 112
+    mean = (114.7748, 107.7354, 99.4750)
+    class_names = get_class_names(args.classes)
+
+    net = cv.dnn.readNet(net_path)
+    net.setPreferableBackend(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE)
+    net.setPreferableTarget(cv.dnn.DNN_TARGET_CPU)
+
+    winName = 'Deep learning image classification in OpenCV'
+    cv.namedWindow(winName, cv.WINDOW_AUTOSIZE)
+    cap = cv.VideoCapture(video_path)
+    while cv.waitKey(1) < 0:
+        frames = []
+        for _ in range(SAMPLE_DURATION):
+            hasFrame, frame = cap.read()
+            if not hasFrame:
+                exit(0)
+            frames.append(frame)
+
+        inputs = cv.dnn.blobFromImages(frames, 1, (SAMPLE_SIZE, SAMPLE_SIZE), mean, True, crop=True)
+        inputs = np.transpose(inputs, (1, 0, 2, 3))
+        inputs = np.expand_dims(inputs, axis=0)
+        net.setInput(inputs)
+        outputs = net.forward()
+        class_pred = np.argmax(outputs)
+        label = class_names[class_pred]
+
+        for frame in frames:
+            labelSize, baseLine = cv.getTextSize(label, cv.FONT_HERSHEY_SIMPLEX, 0.5, 1)
+            cv.rectangle(frame, (0, 10 - labelSize[1]),
+                                (labelSize[0], 10 + baseLine), (255, 255, 255), cv.FILLED)
+            cv.putText(frame, label, (0, 10), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))
+            cv.imshow(winName, frame)
+        if cv.waitKey(1) & 0xFF == ord('q'):
+            break
+
+if __name__ == "__main__":
+    args, _ = parser.parse_known_args()
+    classify_video(args.input if args.input else 0, args.model)
diff --git a/C++/opencv-4.7.0/samples/dnn/classification.cpp b/C++/opencv-4.7.0/samples/dnn/classification.cpp
new file mode 100644
index 00000000..51893666
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/classification.cpp
@@ -0,0 +1,210 @@
+#include <fstream>
+#include <sstream>
+#include <iostream>
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+#include "common.hpp"
+
+std::string keys =
+    "{ help  h          | | Print help message. }"
+    "{ @alias           | | An alias name of model to extract preprocessing parameters from models.yml file. }"
+    "{ zoo              | models.yml | An optional path to file with preprocessing parameters }"
+    "{ input i          | | Path to input image or video file. Skip this argument to capture frames from a camera.}"
+    "{ initial_width    | 0 | Preprocess input image by initial resizing to a specific width.}"
+    "{ initial_height   | 0 | Preprocess input image by initial resizing to a specific height.}"
+    "{ std              | 0.0 0.0 0.0 | Preprocess input image by dividing on a standard deviation.}"
+    "{ crop             | false | Preprocess input image by center cropping.}"
+    "{ framework f      | | Optional name of an origin framework of the model. Detect it automatically if it does not set. }"
+    "{ needSoftmax      | false | Use Softmax to post-process the output of the net.}"
+    "{ classes          | | Optional path to a text file with names of classes. }"
+    "{ backend          | 0 | Choose one of computation backends: "
+                            "0: automatically (by default), "
+                            "1: Halide language (http://halide-lang.org/), "
+                            "2: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                            "3: OpenCV implementation, "
+                            "4: VKCOM, "
+                            "5: CUDA, "
+                            "6: WebNN }"
+    "{ target           | 0 | Choose one of target computation devices: "
+                            "0: CPU target (by default), "
+                            "1: OpenCL, "
+                            "2: OpenCL fp16 (half-float precision), "
+                            "3: VPU, "
+                            "4: Vulkan, "
+                            "6: CUDA, "
+                            "7: CUDA fp16 (half-float preprocess) }";
+
+using namespace cv;
+using namespace dnn;
+
+std::vector<std::string> classes;
+
+int main(int argc, char** argv)
+{
+    CommandLineParser parser(argc, argv, keys);
+
+    const std::string modelName = parser.get<String>("@alias");
+    const std::string zooFile = parser.get<String>("zoo");
+
+    keys += genPreprocArguments(modelName, zooFile);
+
+    parser = CommandLineParser(argc, argv, keys);
+    parser.about("Use this script to run classification deep learning networks using OpenCV.");
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    int rszWidth = parser.get<int>("initial_width");
+    int rszHeight = parser.get<int>("initial_height");
+    float scale = parser.get<float>("scale");
+    Scalar mean = parser.get<Scalar>("mean");
+    Scalar std = parser.get<Scalar>("std");
+    bool swapRB = parser.get<bool>("rgb");
+    bool crop = parser.get<bool>("crop");
+    int inpWidth = parser.get<int>("width");
+    int inpHeight = parser.get<int>("height");
+    String model = findFile(parser.get<String>("model"));
+    String config = findFile(parser.get<String>("config"));
+    String framework = parser.get<String>("framework");
+    int backendId = parser.get<int>("backend");
+    int targetId = parser.get<int>("target");
+    bool needSoftmax = parser.get<bool>("needSoftmax");
+    std::cout<<"mean: "<<mean<<std::endl;
+    std::cout<<"std: "<<std<<std::endl;
+
+    // Open file with classes names.
+    if (parser.has("classes"))
+    {
+        std::string file = parser.get<String>("classes");
+        std::ifstream ifs(file.c_str());
+        if (!ifs.is_open())
+            CV_Error(Error::StsError, "File " + file + " not found");
+        std::string line;
+        while (std::getline(ifs, line))
+        {
+            classes.push_back(line);
+        }
+    }
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+    CV_Assert(!model.empty());
+
+    //! [Read and initialize network]
+    Net net = readNet(model, config, framework);
+    net.setPreferableBackend(backendId);
+    net.setPreferableTarget(targetId);
+    //! [Read and initialize network]
+
+    // Create a window
+    static const std::string kWinName = "Deep learning image classification in OpenCV";
+    namedWindow(kWinName, WINDOW_NORMAL);
+
+    //! [Open a video file or an image file or a camera stream]
+    VideoCapture cap;
+    if (parser.has("input"))
+        cap.open(parser.get<String>("input"));
+    else
+        cap.open(0);
+    //! [Open a video file or an image file or a camera stream]
+
+    // Process frames.
+    Mat frame, blob;
+    while (waitKey(1) < 0)
+    {
+        cap >> frame;
+        if (frame.empty())
+        {
+            waitKey();
+            break;
+        }
+
+        if (rszWidth != 0 && rszHeight != 0)
+        {
+            resize(frame, frame, Size(rszWidth, rszHeight));
+        }
+
+        //! [Create a 4D blob from a frame]
+        blobFromImage(frame, blob, scale, Size(inpWidth, inpHeight), mean, swapRB, crop);
+
+        // Check std values.
+        if (std.val[0] != 0.0 && std.val[1] != 0.0 && std.val[2] != 0.0)
+        {
+            // Divide blob by std.
+            divide(blob, std, blob);
+        }
+        //! [Create a 4D blob from a frame]
+
+        //! [Set input blob]
+        net.setInput(blob);
+        //! [Set input blob]
+        //! [Make forward pass]
+        // double t_sum = 0.0;
+        // double t;
+        int classId;
+        double confidence;
+        cv::TickMeter timeRecorder;
+        timeRecorder.reset();
+        Mat prob = net.forward();
+        double t1;
+        timeRecorder.start();
+        prob = net.forward();
+        timeRecorder.stop();
+        t1 = timeRecorder.getTimeMilli();
+
+        timeRecorder.reset();
+        for(int i = 0; i < 200; i++) {
+            //! [Make forward pass]
+            timeRecorder.start();
+            prob = net.forward();
+            timeRecorder.stop();
+
+            //! [Get a class with a highest score]
+            Point classIdPoint;
+            minMaxLoc(prob.reshape(1, 1), 0, &confidence, 0, &classIdPoint);
+            classId = classIdPoint.x;
+            //! [Get a class with a highest score]
+
+            // Put efficiency information.
+            // std::vector<double> layersTimes;
+            // double freq = getTickFrequency() / 1000;
+            // t = net.getPerfProfile(layersTimes) / freq;
+            // t_sum += t;
+        }
+        if (needSoftmax == true)
+        {
+            float maxProb = 0.0;
+            float sum = 0.0;
+            Mat softmaxProb;
+
+            maxProb = *std::max_element(prob.begin<float>(), prob.end<float>());
+            cv::exp(prob-maxProb, softmaxProb);
+            sum = (float)cv::sum(softmaxProb)[0];
+            softmaxProb /= sum;
+            Point classIdPoint;
+            minMaxLoc(softmaxProb.reshape(1, 1), 0, &confidence, 0, &classIdPoint);
+            classId = classIdPoint.x;
+        }
+        std::string label = format("Inference time of 1 round: %.2f ms", t1);
+        std::string label2 = format("Average time of 200 rounds: %.2f ms", timeRecorder.getTimeMilli()/200);
+        putText(frame, label, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+        putText(frame, label2, Point(0, 35), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+
+        // Print predicted class.
+        label = format("%s: %.4f", (classes.empty() ? format("Class #%d", classId).c_str() :
+                                                      classes[classId].c_str()),
+                                   confidence);
+        putText(frame, label, Point(0, 55), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+
+        imshow(kWinName, frame);
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/classification.py b/C++/opencv-4.7.0/samples/dnn/classification.py
new file mode 100644
index 00000000..be639e8d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/classification.py
@@ -0,0 +1,117 @@
+import argparse
+
+import cv2 as cv
+import numpy as np
+from common import *
+
+
+def get_args_parser(func_args):
+    backends = (cv.dnn.DNN_BACKEND_DEFAULT, cv.dnn.DNN_BACKEND_HALIDE, cv.dnn.DNN_BACKEND_INFERENCE_ENGINE,
+                cv.dnn.DNN_BACKEND_OPENCV, cv.dnn.DNN_BACKEND_VKCOM, cv.dnn.DNN_BACKEND_CUDA)
+    targets = (cv.dnn.DNN_TARGET_CPU, cv.dnn.DNN_TARGET_OPENCL, cv.dnn.DNN_TARGET_OPENCL_FP16, cv.dnn.DNN_TARGET_MYRIAD,
+               cv.dnn.DNN_TARGET_HDDL, cv.dnn.DNN_TARGET_VULKAN, cv.dnn.DNN_TARGET_CUDA, cv.dnn.DNN_TARGET_CUDA_FP16)
+
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument('--zoo', default=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models.yml'),
+                        help='An optional path to file with preprocessing parameters.')
+    parser.add_argument('--input',
+                        help='Path to input image or video file. Skip this argument to capture frames from a camera.')
+    parser.add_argument('--framework', choices=['caffe', 'tensorflow', 'torch', 'darknet'],
+                        help='Optional name of an origin framework of the model. '
+                             'Detect it automatically if it does not set.')
+    parser.add_argument('--std', nargs='*', type=float,
+                        help='Preprocess input image by dividing on a standard deviation.')
+    parser.add_argument('--crop', type=bool, default=False,
+                        help='Preprocess input image by dividing on a standard deviation.')
+    parser.add_argument('--initial_width', type=int,
+                        help='Preprocess input image by initial resizing to a specific width.')
+    parser.add_argument('--initial_height', type=int,
+                        help='Preprocess input image by initial resizing to a specific height.')
+    parser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,
+                        help="Choose one of computation backends: "
+                             "%d: automatically (by default), "
+                             "%d: Halide language (http://halide-lang.org/), "
+                             "%d: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                             "%d: OpenCV implementation, "
+                             "%d: VKCOM, "
+                             "%d: CUDA" % backends)
+    parser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,
+                        help='Choose one of target computation devices: '
+                             '%d: CPU target (by default), '
+                             '%d: OpenCL, '
+                             '%d: OpenCL fp16 (half-float precision), '
+                             '%d: NCS2 VPU, '
+                             '%d: HDDL VPU, '
+                             '%d: Vulkan, '
+                             '%d: CUDA, '
+                             '%d: CUDA fp16 (half-float preprocess)'% targets)
+
+    args, _ = parser.parse_known_args()
+    add_preproc_args(args.zoo, parser, 'classification')
+    parser = argparse.ArgumentParser(parents=[parser],
+                                     description='Use this script to run classification deep learning networks using OpenCV.',
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    return parser.parse_args(func_args)
+
+
+def main(func_args=None):
+    args = get_args_parser(func_args)
+    args.model = findFile(args.model)
+    args.config = findFile(args.config)
+    args.classes = findFile(args.classes)
+
+    # Load names of classes
+    classes = None
+    if args.classes:
+        with open(args.classes, 'rt') as f:
+            classes = f.read().rstrip('\n').split('\n')
+
+    # Load a network
+    net = cv.dnn.readNet(args.model, args.config, args.framework)
+    net.setPreferableBackend(args.backend)
+    net.setPreferableTarget(args.target)
+
+    winName = 'Deep learning image classification in OpenCV'
+    cv.namedWindow(winName, cv.WINDOW_NORMAL)
+
+    cap = cv.VideoCapture(args.input if args.input else 0)
+    while cv.waitKey(1) < 0:
+        hasFrame, frame = cap.read()
+        if not hasFrame:
+            cv.waitKey()
+            break
+
+        # Create a 4D blob from a frame.
+        inpWidth = args.width if args.width else frame.shape[1]
+        inpHeight = args.height if args.height else frame.shape[0]
+
+        if args.initial_width and args.initial_height:
+            frame = cv.resize(frame, (args.initial_width, args.initial_height))
+
+        blob = cv.dnn.blobFromImage(frame, args.scale, (inpWidth, inpHeight), args.mean, args.rgb, crop=args.crop)
+        if args.std:
+            blob[0] /= np.asarray(args.std, dtype=np.float32).reshape(3, 1, 1)
+
+        # Run a model
+        net.setInput(blob)
+        out = net.forward()
+
+        # Get a class with a highest score.
+        out = out.flatten()
+        classId = np.argmax(out)
+        confidence = out[classId]
+
+        # Put efficiency information.
+        t, _ = net.getPerfProfile()
+        label = 'Inference time: %.2f ms' % (t * 1000.0 / cv.getTickFrequency())
+        cv.putText(frame, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
+
+        # Print predicted class.
+        label = '%s: %.4f' % (classes[classId] if classes else 'Class #%d' % classId, confidence)
+        cv.putText(frame, label, (0, 40), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
+
+        cv.imshow(winName, frame)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/dnn/colorization.cpp b/C++/opencv-4.7.0/samples/dnn/colorization.cpp
new file mode 100644
index 00000000..6d751590
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/colorization.cpp
@@ -0,0 +1,128 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace cv::dnn;
+using namespace std;
+
+// the 313 ab cluster centers from pts_in_hull.npy (already transposed)
+static float hull_pts[] = {
+    -90., -90., -90., -90., -90., -80., -80., -80., -80., -80., -80., -80., -80., -70., -70., -70., -70., -70., -70., -70., -70.,
+    -70., -70., -60., -60., -60., -60., -60., -60., -60., -60., -60., -60., -60., -60., -50., -50., -50., -50., -50., -50., -50., -50.,
+    -50., -50., -50., -50., -50., -50., -40., -40., -40., -40., -40., -40., -40., -40., -40., -40., -40., -40., -40., -40., -40., -30.,
+    -30., -30., -30., -30., -30., -30., -30., -30., -30., -30., -30., -30., -30., -30., -30., -20., -20., -20., -20., -20., -20., -20.,
+    -20., -20., -20., -20., -20., -20., -20., -20., -20., -10., -10., -10., -10., -10., -10., -10., -10., -10., -10., -10., -10., -10.,
+    -10., -10., -10., -10., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 10., 10., 10., 10., 10., 10., 10.,
+    10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 20., 20., 20., 20., 20., 20., 20., 20., 20., 20., 20., 20., 20., 20., 20.,
+    20., 20., 20., 30., 30., 30., 30., 30., 30., 30., 30., 30., 30., 30., 30., 30., 30., 30., 30., 30., 30., 30., 40., 40., 40., 40.,
+    40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 40., 50., 50., 50., 50., 50., 50., 50., 50., 50., 50.,
+    50., 50., 50., 50., 50., 50., 50., 50., 50., 60., 60., 60., 60., 60., 60., 60., 60., 60., 60., 60., 60., 60., 60., 60., 60., 60.,
+    60., 60., 60., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 70., 80., 80., 80.,
+    80., 80., 80., 80., 80., 80., 80., 80., 80., 80., 80., 80., 80., 80., 80., 80., 90., 90., 90., 90., 90., 90., 90., 90., 90., 90.,
+    90., 90., 90., 90., 90., 90., 90., 90., 90., 100., 100., 100., 100., 100., 100., 100., 100., 100., 100., 50., 60., 70., 80., 90.,
+    20., 30., 40., 50., 60., 70., 80., 90., 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., -20., -10., 0., 10., 20., 30., 40., 50.,
+    60., 70., 80., 90., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100., -40., -30., -20., -10., 0., 10., 20.,
+    30., 40., 50., 60., 70., 80., 90., 100., -50., -40., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100., -50.,
+    -40., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100., -60., -50., -40., -30., -20., -10., 0., 10., 20.,
+    30., 40., 50., 60., 70., 80., 90., 100., -70., -60., -50., -40., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., 80., 90.,
+    100., -80., -70., -60., -50., -40., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., -80., -70., -60., -50.,
+    -40., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., -90., -80., -70., -60., -50., -40., -30., -20., -10.,
+    0., 10., 20., 30., 40., 50., 60., 70., 80., 90., -100., -90., -80., -70., -60., -50., -40., -30., -20., -10., 0., 10., 20., 30.,
+    40., 50., 60., 70., 80., 90., -100., -90., -80., -70., -60., -50., -40., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70.,
+    80., -110., -100., -90., -80., -70., -60., -50., -40., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., 80., -110., -100.,
+    -90., -80., -70., -60., -50., -40., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., 80., -110., -100., -90., -80., -70.,
+    -60., -50., -40., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., -110., -100., -90., -80., -70., -60., -50., -40., -30.,
+    -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., -90., -80., -70., -60., -50., -40., -30., -20., -10., 0.
+};
+
+int main(int argc, char **argv)
+{
+    const string about =
+        "This sample demonstrates recoloring grayscale images with dnn.\n"
+        "This program is based on:\n"
+        "  http://richzhang.github.io/colorization\n"
+        "  https://github.com/richzhang/colorization\n"
+        "Download caffemodel and prototxt files:\n"
+        "  http://eecs.berkeley.edu/~rich.zhang/projects/2016_colorization/files/demo_v2/colorization_release_v2.caffemodel\n"
+        "  https://raw.githubusercontent.com/richzhang/colorization/caffe/models/colorization_deploy_v2.prototxt\n";
+    const string keys =
+        "{ h help |                                    | print this help message }"
+        "{ proto  | colorization_deploy_v2.prototxt    | model configuration }"
+        "{ model  | colorization_release_v2.caffemodel | model weights }"
+        "{ image  | space_shuttle.jpg                  | path to image file }"
+        "{ opencl |                                    | enable OpenCL }";
+    CommandLineParser parser(argc, argv, keys);
+    parser.about(about);
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    string modelTxt = samples::findFile(parser.get<string>("proto"));
+    string modelBin = samples::findFile(parser.get<string>("model"));
+    string imageFile = samples::findFile(parser.get<string>("image"));
+    bool useOpenCL = parser.has("opencl");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+
+    Mat img = imread(imageFile);
+    if (img.empty())
+    {
+        cout << "Can't read image from file: " << imageFile << endl;
+        return 2;
+    }
+
+    // fixed input size for the pretrained network
+    const int W_in = 224;
+    const int H_in = 224;
+    Net net = dnn::readNetFromCaffe(modelTxt, modelBin);
+    if (useOpenCL)
+        net.setPreferableTarget(DNN_TARGET_OPENCL);
+
+    // setup additional layers:
+    int sz[] = {2, 313, 1, 1};
+    const Mat pts_in_hull(4, sz, CV_32F, hull_pts);
+    Ptr<dnn::Layer> class8_ab = net.getLayer("class8_ab");
+    class8_ab->blobs.push_back(pts_in_hull);
+    Ptr<dnn::Layer> conv8_313_rh = net.getLayer("conv8_313_rh");
+    conv8_313_rh->blobs.push_back(Mat(1, 313, CV_32F, Scalar(2.606)));
+
+    // extract L channel and subtract mean
+    Mat lab, L, input;
+    img.convertTo(img, CV_32F, 1.0/255);
+    cvtColor(img, lab, COLOR_BGR2Lab);
+    extractChannel(lab, L, 0);
+    resize(L, input, Size(W_in, H_in));
+    input -= 50;
+
+    // run the L channel through the network
+    Mat inputBlob = blobFromImage(input);
+    net.setInput(inputBlob);
+    Mat result = net.forward();
+
+    // retrieve the calculated a,b channels from the network output
+    Size siz(result.size[2], result.size[3]);
+    Mat a = Mat(siz, CV_32F, result.ptr(0,0));
+    Mat b = Mat(siz, CV_32F, result.ptr(0,1));
+    resize(a, a, img.size());
+    resize(b, b, img.size());
+
+    // merge, and convert back to BGR
+    Mat color, chn[] = {L, a, b};
+    merge(chn, 3, lab);
+    cvtColor(lab, color, COLOR_Lab2BGR);
+
+    imshow("color", color);
+    imshow("original", img);
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/colorization.py b/C++/opencv-4.7.0/samples/dnn/colorization.py
new file mode 100644
index 00000000..5bdef979
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/colorization.py
@@ -0,0 +1,69 @@
+# Script is based on https://github.com/richzhang/colorization/blob/master/colorization/colorize.py
+# To download the caffemodel and the prototxt, see: https://github.com/richzhang/colorization/tree/caffe/colorization/models
+# To download pts_in_hull.npy, see: https://github.com/richzhang/colorization/tree/caffe/colorization/resources/pts_in_hull.npy
+import numpy as np
+import argparse
+import cv2 as cv
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='iColor: deep interactive colorization')
+    parser.add_argument('--input', help='Path to image or video. Skip to capture frames from camera')
+    parser.add_argument('--prototxt', help='Path to colorization_deploy_v2.prototxt', required=True)
+    parser.add_argument('--caffemodel', help='Path to colorization_release_v2.caffemodel', required=True)
+    parser.add_argument('--kernel', help='Path to pts_in_hull.npy', required=True)
+
+    args = parser.parse_args()
+    return args
+
+if __name__ == '__main__':
+    W_in = 224
+    H_in = 224
+    imshowSize = (640, 480)
+
+    args = parse_args()
+
+    # Select desired model
+    net = cv.dnn.readNetFromCaffe(args.prototxt, args.caffemodel)
+
+    pts_in_hull = np.load(args.kernel) # load cluster centers
+
+    # populate cluster centers as 1x1 convolution kernel
+    pts_in_hull = pts_in_hull.transpose().reshape(2, 313, 1, 1)
+    net.getLayer(net.getLayerId('class8_ab')).blobs = [pts_in_hull.astype(np.float32)]
+    net.getLayer(net.getLayerId('conv8_313_rh')).blobs = [np.full([1, 313], 2.606, np.float32)]
+
+    if args.input:
+        cap = cv.VideoCapture(args.input)
+    else:
+        cap = cv.VideoCapture(0)
+
+    while cv.waitKey(1) < 0:
+        hasFrame, frame = cap.read()
+        if not hasFrame:
+            cv.waitKey()
+            break
+
+        img_rgb = (frame[:,:,[2, 1, 0]] * 1.0 / 255).astype(np.float32)
+
+        img_lab = cv.cvtColor(img_rgb, cv.COLOR_RGB2Lab)
+        img_l = img_lab[:,:,0] # pull out L channel
+        (H_orig,W_orig) = img_rgb.shape[:2] # original image size
+
+        # resize image to network input size
+        img_rs = cv.resize(img_rgb, (W_in, H_in)) # resize image to network input size
+        img_lab_rs = cv.cvtColor(img_rs, cv.COLOR_RGB2Lab)
+        img_l_rs = img_lab_rs[:,:,0]
+        img_l_rs -= 50 # subtract 50 for mean-centering
+
+        net.setInput(cv.dnn.blobFromImage(img_l_rs))
+        ab_dec = net.forward()[0,:,:,:].transpose((1,2,0)) # this is our result
+
+        (H_out,W_out) = ab_dec.shape[:2]
+        ab_dec_us = cv.resize(ab_dec, (W_orig, H_orig))
+        img_lab_out = np.concatenate((img_l[:,:,np.newaxis],ab_dec_us),axis=2) # concatenate with original image L
+        img_bgr_out = np.clip(cv.cvtColor(img_lab_out, cv.COLOR_Lab2BGR), 0, 1)
+
+        frame = cv.resize(frame, imshowSize)
+        cv.imshow('origin', frame)
+        cv.imshow('gray', cv.cvtColor(frame, cv.COLOR_RGB2GRAY))
+        cv.imshow('colorized', cv.resize(img_bgr_out, imshowSize))
diff --git a/C++/opencv-4.7.0/samples/dnn/common.hpp b/C++/opencv-4.7.0/samples/dnn/common.hpp
new file mode 100644
index 00000000..e88a206c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/common.hpp
@@ -0,0 +1,95 @@
+#include <opencv2/core/utils/filesystem.hpp>
+
+using namespace cv;
+
+std::string genArgument(const std::string& argName, const std::string& help,
+                        const std::string& modelName, const std::string& zooFile,
+                        char key = ' ', std::string defaultVal = "");
+
+std::string genPreprocArguments(const std::string& modelName, const std::string& zooFile);
+
+std::string findFile(const std::string& filename);
+
+std::string genArgument(const std::string& argName, const std::string& help,
+                        const std::string& modelName, const std::string& zooFile,
+                        char key, std::string defaultVal)
+{
+    if (!modelName.empty())
+    {
+        FileStorage fs(zooFile, FileStorage::READ);
+        if (fs.isOpened())
+        {
+            FileNode node = fs[modelName];
+            if (!node.empty())
+            {
+                FileNode value = node[argName];
+                if (!value.empty())
+                {
+                    if (value.isReal())
+                        defaultVal = format("%f", (float)value);
+                    else if (value.isString())
+                        defaultVal = (std::string)value;
+                    else if (value.isInt())
+                        defaultVal = format("%d", (int)value);
+                    else if (value.isSeq())
+                    {
+                        for (size_t i = 0; i < value.size(); ++i)
+                        {
+                            FileNode v = value[(int)i];
+                            if (v.isInt())
+                                defaultVal += format("%d ", (int)v);
+                            else if (v.isReal())
+                                defaultVal += format("%f ", (float)v);
+                            else
+                              CV_Error(Error::StsNotImplemented, "Unexpected value format");
+                        }
+                    }
+                    else
+                        CV_Error(Error::StsNotImplemented, "Unexpected field format");
+                }
+            }
+        }
+    }
+    return "{ " + argName + " " + key + " | " + defaultVal + " | " + help + " }";
+}
+
+std::string findFile(const std::string& filename)
+{
+    if (filename.empty() || utils::fs::exists(filename))
+        return filename;
+
+    const char* extraPaths[] = {getenv("OPENCV_DNN_TEST_DATA_PATH"),
+                                getenv("OPENCV_TEST_DATA_PATH")};
+    for (int i = 0; i < 2; ++i)
+    {
+        if (extraPaths[i] == NULL)
+            continue;
+        std::string absPath = utils::fs::join(extraPaths[i], utils::fs::join("dnn", filename));
+        if (utils::fs::exists(absPath))
+            return absPath;
+    }
+    CV_Error(Error::StsObjectNotFound, "File " + filename + " not found! "
+             "Please specify a path to /opencv_extra/testdata in OPENCV_DNN_TEST_DATA_PATH "
+             "environment variable or pass a full path to model.");
+}
+
+std::string genPreprocArguments(const std::string& modelName, const std::string& zooFile)
+{
+    return genArgument("model", "Path to a binary file of model contains trained weights. "
+                                "It could be a file with extensions .caffemodel (Caffe), "
+                                ".pb (TensorFlow), .t7 or .net (Torch), .weights (Darknet), .bin (OpenVINO).",
+                       modelName, zooFile, 'm') +
+           genArgument("config", "Path to a text file of model contains network configuration. "
+                                 "It could be a file with extensions .prototxt (Caffe), .pbtxt (TensorFlow), .cfg (Darknet), .xml (OpenVINO).",
+                       modelName, zooFile, 'c') +
+           genArgument("mean", "Preprocess input image by subtracting mean values. Mean values should be in BGR order and delimited by spaces.",
+                       modelName, zooFile) +
+           genArgument("scale", "Preprocess input image by multiplying on a scale factor.",
+                       modelName, zooFile, ' ', "1.0") +
+           genArgument("width", "Preprocess input image by resizing to a specific width.",
+                       modelName, zooFile, ' ', "-1") +
+           genArgument("height", "Preprocess input image by resizing to a specific height.",
+                       modelName, zooFile, ' ', "-1") +
+           genArgument("rgb", "Indicate that model works with RGB input images instead BGR ones.",
+                       modelName, zooFile);
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/common.py b/C++/opencv-4.7.0/samples/dnn/common.py
new file mode 100644
index 00000000..db9283b5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/common.py
@@ -0,0 +1,112 @@
+import sys
+import os
+import cv2 as cv
+
+
+def add_argument(zoo, parser, name, help, required=False, default=None, type=None, action=None, nargs=None):
+    if len(sys.argv) <= 1:
+        return
+
+    modelName = sys.argv[1]
+
+    if os.path.isfile(zoo):
+        fs = cv.FileStorage(zoo, cv.FILE_STORAGE_READ)
+        node = fs.getNode(modelName)
+        if not node.empty():
+            value = node.getNode(name)
+            if not value.empty():
+                if value.isReal():
+                    default = value.real()
+                elif value.isString():
+                    default = value.string()
+                elif value.isInt():
+                    default = int(value.real())
+                elif value.isSeq():
+                    default = []
+                    for i in range(value.size()):
+                        v = value.at(i)
+                        if v.isInt():
+                            default.append(int(v.real()))
+                        elif v.isReal():
+                            default.append(v.real())
+                        else:
+                            print('Unexpected value format')
+                            exit(0)
+                else:
+                    print('Unexpected field format')
+                    exit(0)
+                required = False
+
+    if action == 'store_true':
+        default = 1 if default == 'true' else (0 if default == 'false' else default)
+        assert(default is None or default == 0 or default == 1)
+        parser.add_argument('--' + name, required=required, help=help, default=bool(default),
+                            action=action)
+    else:
+        parser.add_argument('--' + name, required=required, help=help, default=default,
+                            action=action, nargs=nargs, type=type)
+
+
+def add_preproc_args(zoo, parser, sample):
+    aliases = []
+    if os.path.isfile(zoo):
+        fs = cv.FileStorage(zoo, cv.FILE_STORAGE_READ)
+        root = fs.root()
+        for name in root.keys():
+            model = root.getNode(name)
+            if model.getNode('sample').string() == sample:
+                aliases.append(name)
+
+    parser.add_argument('alias', nargs='?', choices=aliases,
+                        help='An alias name of model to extract preprocessing parameters from models.yml file.')
+    add_argument(zoo, parser, 'model', required=True,
+                 help='Path to a binary file of model contains trained weights. '
+                      'It could be a file with extensions .caffemodel (Caffe), '
+                      '.pb (TensorFlow), .t7 or .net (Torch), .weights (Darknet), .bin (OpenVINO)')
+    add_argument(zoo, parser, 'config',
+                 help='Path to a text file of model contains network configuration. '
+                      'It could be a file with extensions .prototxt (Caffe), .pbtxt or .config (TensorFlow), .cfg (Darknet), .xml (OpenVINO)')
+    add_argument(zoo, parser, 'mean', nargs='+', type=float, default=[0, 0, 0],
+                 help='Preprocess input image by subtracting mean values. '
+                      'Mean values should be in BGR order.')
+    add_argument(zoo, parser, 'scale', type=float, default=1.0,
+                 help='Preprocess input image by multiplying on a scale factor.')
+    add_argument(zoo, parser, 'width', type=int,
+                 help='Preprocess input image by resizing to a specific width.')
+    add_argument(zoo, parser, 'height', type=int,
+                 help='Preprocess input image by resizing to a specific height.')
+    add_argument(zoo, parser, 'rgb', action='store_true',
+                 help='Indicate that model works with RGB input images instead BGR ones.')
+    add_argument(zoo, parser, 'classes',
+                 help='Optional path to a text file with names of classes to label detected objects.')
+
+
+def findFile(filename):
+    if filename:
+        if os.path.exists(filename):
+            return filename
+
+        fpath = cv.samples.findFile(filename, False)
+        if fpath:
+            return fpath
+
+        samplesDataDir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                      '..',
+                                      'data',
+                                      'dnn')
+        if os.path.exists(os.path.join(samplesDataDir, filename)):
+            return os.path.join(samplesDataDir, filename)
+
+        for path in ['OPENCV_DNN_TEST_DATA_PATH', 'OPENCV_TEST_DATA_PATH']:
+            try:
+                extraPath = os.environ[path]
+                absPath = os.path.join(extraPath, 'dnn', filename)
+                if os.path.exists(absPath):
+                    return absPath
+            except KeyError:
+                pass
+
+        print('File ' + filename + ' not found! Please specify a path to '
+              '/opencv_extra/testdata in OPENCV_DNN_TEST_DATA_PATH environment '
+              'variable or pass a full path to model.')
+        exit(0)
diff --git a/C++/opencv-4.7.0/samples/dnn/custom_layers.hpp b/C++/opencv-4.7.0/samples/dnn/custom_layers.hpp
new file mode 100644
index 00000000..f471106a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/custom_layers.hpp
@@ -0,0 +1,283 @@
+#ifndef __OPENCV_SAMPLES_DNN_CUSTOM_LAYERS__
+#define __OPENCV_SAMPLES_DNN_CUSTOM_LAYERS__
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/dnn/shape_utils.hpp>    // getPlane
+
+//! [InterpLayer]
+class InterpLayer : public cv::dnn::Layer
+{
+public:
+    InterpLayer(const cv::dnn::LayerParams &params) : Layer(params)
+    {
+        outWidth = params.get<int>("width", 0);
+        outHeight = params.get<int>("height", 0);
+    }
+
+    static cv::Ptr<cv::dnn::Layer> create(cv::dnn::LayerParams& params)
+    {
+        return cv::Ptr<cv::dnn::Layer>(new InterpLayer(params));
+    }
+
+    virtual bool getMemoryShapes(const std::vector<std::vector<int> > &inputs,
+                                 const int requiredOutputs,
+                                 std::vector<std::vector<int> > &outputs,
+                                 std::vector<std::vector<int> > &internals) const CV_OVERRIDE
+    {
+        CV_UNUSED(requiredOutputs); CV_UNUSED(internals);
+        std::vector<int> outShape(4);
+        outShape[0] = inputs[0][0];  // batch size
+        outShape[1] = inputs[0][1];  // number of channels
+        outShape[2] = outHeight;
+        outShape[3] = outWidth;
+        outputs.assign(1, outShape);
+        return false;
+    }
+
+    // Implementation of this custom layer is based on https://github.com/cdmh/deeplab-public/blob/master/src/caffe/layers/interp_layer.cpp
+    virtual void forward(cv::InputArrayOfArrays inputs_arr,
+                         cv::OutputArrayOfArrays outputs_arr,
+                         cv::OutputArrayOfArrays internals_arr) CV_OVERRIDE
+    {
+        if (inputs_arr.depth() == CV_16S)
+        {
+            // In case of DNN_TARGET_OPENCL_FP16 target the following method
+            // converts data from FP16 to FP32 and calls this forward again.
+            forward_fallback(inputs_arr, outputs_arr, internals_arr);
+            return;
+        }
+
+        std::vector<cv::Mat> inputs, outputs;
+        inputs_arr.getMatVector(inputs);
+        outputs_arr.getMatVector(outputs);
+
+        cv::Mat& inp = inputs[0];
+        cv::Mat& out = outputs[0];
+        const float* inpData = (float*)inp.data;
+        float* outData = (float*)out.data;
+
+        const int batchSize = inp.size[0];
+        const int numChannels = inp.size[1];
+        const int inpHeight = inp.size[2];
+        const int inpWidth = inp.size[3];
+
+        const float rheight = (outHeight > 1) ? static_cast<float>(inpHeight - 1) / (outHeight - 1) : 0.f;
+        const float rwidth = (outWidth > 1) ? static_cast<float>(inpWidth - 1) / (outWidth - 1) : 0.f;
+        for (int h2 = 0; h2 < outHeight; ++h2)
+        {
+            const float h1r = rheight * h2;
+            const int h1 = static_cast<int>(h1r);
+            const int h1p = (h1 < inpHeight - 1) ? 1 : 0;
+            const float h1lambda = h1r - h1;
+            const float h0lambda = 1.f - h1lambda;
+            for (int w2 = 0; w2 < outWidth; ++w2)
+            {
+                const float w1r = rwidth * w2;
+                const int w1 = static_cast<int>(w1r);
+                const int w1p = (w1 < inpWidth - 1) ? 1 : 0;
+                const float w1lambda = w1r - w1;
+                const float w0lambda = 1.f - w1lambda;
+                const float* pos1 = inpData + h1 * inpWidth + w1;
+                float* pos2 = outData + h2 * outWidth + w2;
+                for (int c = 0; c < batchSize * numChannels; ++c)
+                {
+                    pos2[0] =
+                      h0lambda * (w0lambda * pos1[0] + w1lambda * pos1[w1p]) +
+                      h1lambda * (w0lambda * pos1[h1p * inpWidth] + w1lambda * pos1[h1p * inpWidth + w1p]);
+                    pos1 += inpWidth * inpHeight;
+                    pos2 += outWidth * outHeight;
+                }
+            }
+        }
+    }
+
+private:
+    int outWidth, outHeight;
+};
+//! [InterpLayer]
+
+//! [ResizeBilinearLayer]
+class ResizeBilinearLayer CV_FINAL : public cv::dnn::Layer
+{
+public:
+    ResizeBilinearLayer(const cv::dnn::LayerParams &params) : Layer(params)
+    {
+        CV_Assert(!params.get<bool>("align_corners", false));
+        CV_Assert(!blobs.empty());
+
+        for (size_t i = 0; i < blobs.size(); ++i)
+            CV_Assert(blobs[i].type() == CV_32SC1);
+
+        // There are two cases of input blob: a single blob which contains output
+        // shape and two blobs with scaling factors.
+        if (blobs.size() == 1)
+        {
+            CV_Assert(blobs[0].total() == 2);
+            outHeight = blobs[0].at<int>(0, 0);
+            outWidth = blobs[0].at<int>(0, 1);
+            factorHeight = factorWidth = 0;
+        }
+        else
+        {
+            CV_Assert(blobs.size() == 2); CV_Assert(blobs[0].total() == 1); CV_Assert(blobs[1].total() == 1);
+            factorHeight = blobs[0].at<int>(0, 0);
+            factorWidth = blobs[1].at<int>(0, 0);
+            outHeight = outWidth = 0;
+        }
+    }
+
+    static cv::Ptr<cv::dnn::Layer> create(cv::dnn::LayerParams& params)
+    {
+        return cv::Ptr<cv::dnn::Layer>(new ResizeBilinearLayer(params));
+    }
+
+    virtual bool getMemoryShapes(const std::vector<std::vector<int> > &inputs,
+                                 const int,
+                                 std::vector<std::vector<int> > &outputs,
+                                 std::vector<std::vector<int> > &) const CV_OVERRIDE
+    {
+        std::vector<int> outShape(4);
+        outShape[0] = inputs[0][0];  // batch size
+        outShape[1] = inputs[0][1];  // number of channels
+        outShape[2] = outHeight != 0 ? outHeight : (inputs[0][2] * factorHeight);
+        outShape[3] = outWidth != 0 ? outWidth : (inputs[0][3] * factorWidth);
+        outputs.assign(1, outShape);
+        return false;
+    }
+
+    virtual void finalize(cv::InputArrayOfArrays, cv::OutputArrayOfArrays outputs_arr) CV_OVERRIDE
+    {
+        std::vector<cv::Mat> outputs;
+        outputs_arr.getMatVector(outputs);
+        if (!outWidth && !outHeight)
+        {
+            outHeight = outputs[0].size[2];
+            outWidth = outputs[0].size[3];
+        }
+    }
+
+    // This implementation is based on a reference implementation from
+    // https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/lite/kernels/internal/reference/reference_ops.h
+    virtual void forward(cv::InputArrayOfArrays inputs_arr,
+                         cv::OutputArrayOfArrays outputs_arr,
+                         cv::OutputArrayOfArrays internals_arr) CV_OVERRIDE
+    {
+        if (inputs_arr.depth() == CV_16S)
+        {
+            // In case of DNN_TARGET_OPENCL_FP16 target the following method
+            // converts data from FP16 to FP32 and calls this forward again.
+            forward_fallback(inputs_arr, outputs_arr, internals_arr);
+            return;
+        }
+
+        std::vector<cv::Mat> inputs, outputs;
+        inputs_arr.getMatVector(inputs);
+        outputs_arr.getMatVector(outputs);
+
+        cv::Mat& inp = inputs[0];
+        cv::Mat& out = outputs[0];
+        const float* inpData = (float*)inp.data;
+        float* outData = (float*)out.data;
+
+        const int batchSize = inp.size[0];
+        const int numChannels = inp.size[1];
+        const int inpHeight = inp.size[2];
+        const int inpWidth = inp.size[3];
+
+        float heightScale = static_cast<float>(inpHeight) / outHeight;
+        float widthScale = static_cast<float>(inpWidth) / outWidth;
+        for (int b = 0; b < batchSize; ++b)
+        {
+            for (int y = 0; y < outHeight; ++y)
+            {
+                float input_y = y * heightScale;
+                int y0 = static_cast<int>(std::floor(input_y));
+                int y1 = std::min(y0 + 1, inpHeight - 1);
+                for (int x = 0; x < outWidth; ++x)
+                {
+                    float input_x = x * widthScale;
+                    int x0 = static_cast<int>(std::floor(input_x));
+                    int x1 = std::min(x0 + 1, inpWidth - 1);
+                    for (int c = 0; c < numChannels; ++c)
+                    {
+                        float interpolation =
+                            inpData[offset(inp.size, c, x0, y0, b)] * (1 - (input_y - y0)) * (1 - (input_x - x0)) +
+                            inpData[offset(inp.size, c, x0, y1, b)] * (input_y - y0) * (1 - (input_x - x0)) +
+                            inpData[offset(inp.size, c, x1, y0, b)] * (1 - (input_y - y0)) * (input_x - x0) +
+                            inpData[offset(inp.size, c, x1, y1, b)] * (input_y - y0) * (input_x - x0);
+                        outData[offset(out.size, c, x, y, b)] = interpolation;
+                    }
+                }
+            }
+        }
+    }
+
+private:
+    static inline int offset(const cv::MatSize& size, int c, int x, int y, int b)
+    {
+        return x + size[3] * (y + size[2] * (c + size[1] * b));
+    }
+
+    int outWidth, outHeight, factorWidth, factorHeight;
+};
+//! [ResizeBilinearLayer]
+
+//
+// The following code is used only to generate tutorials documentation.
+//
+
+//! [A custom layer interface]
+class MyLayer : public cv::dnn::Layer
+{
+public:
+    //! [MyLayer::MyLayer]
+    MyLayer(const cv::dnn::LayerParams &params);
+    //! [MyLayer::MyLayer]
+
+    //! [MyLayer::create]
+    static cv::Ptr<cv::dnn::Layer> create(cv::dnn::LayerParams& params);
+    //! [MyLayer::create]
+
+    //! [MyLayer::getMemoryShapes]
+    virtual bool getMemoryShapes(const std::vector<std::vector<int> > &inputs,
+                                 const int requiredOutputs,
+                                 std::vector<std::vector<int> > &outputs,
+                                 std::vector<std::vector<int> > &internals) const CV_OVERRIDE;
+    //! [MyLayer::getMemoryShapes]
+
+    //! [MyLayer::forward]
+    virtual void forward(cv::InputArrayOfArrays inputs,
+                         cv::OutputArrayOfArrays outputs,
+                         cv::OutputArrayOfArrays internals) CV_OVERRIDE;
+    //! [MyLayer::forward]
+
+    //! [MyLayer::finalize]
+    virtual void finalize(cv::InputArrayOfArrays inputs,
+                          cv::OutputArrayOfArrays outputs) CV_OVERRIDE;
+    //! [MyLayer::finalize]
+};
+//! [A custom layer interface]
+
+//! [Register a custom layer]
+#include <opencv2/dnn/layer.details.hpp>  // CV_DNN_REGISTER_LAYER_CLASS
+
+static inline void loadNet()
+{
+    CV_DNN_REGISTER_LAYER_CLASS(Interp, InterpLayer);
+    // ...
+    //! [Register a custom layer]
+
+    //! [Register InterpLayer]
+    CV_DNN_REGISTER_LAYER_CLASS(Interp, InterpLayer);
+    cv::dnn::Net caffeNet = cv::dnn::readNet("/path/to/config.prototxt", "/path/to/weights.caffemodel");
+    //! [Register InterpLayer]
+
+    //! [Register ResizeBilinearLayer]
+    CV_DNN_REGISTER_LAYER_CLASS(ResizeBilinear, ResizeBilinearLayer);
+    cv::dnn::Net tfNet = cv::dnn::readNet("/path/to/graph.pb");
+    //! [Register ResizeBilinearLayer]
+
+    if (false) loadNet();  // To prevent unused function warning.
+}
+
+#endif  // __OPENCV_SAMPLES_DNN_CUSTOM_LAYERS__
diff --git a/C++/opencv-4.7.0/samples/dnn/dasiamrpn_tracker.cpp b/C++/opencv-4.7.0/samples/dnn/dasiamrpn_tracker.cpp
new file mode 100644
index 00000000..f6e307c6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dasiamrpn_tracker.cpp
@@ -0,0 +1,189 @@
+// DaSiamRPN tracker.
+// Original paper: https://arxiv.org/abs/1808.06048
+// Link to original repo: https://github.com/foolwood/DaSiamRPN
+// Links to onnx models:
+// - network:     https://www.dropbox.com/s/rr1lk9355vzolqv/dasiamrpn_model.onnx?dl=0
+// - kernel_r1:   https://www.dropbox.com/s/999cqx5zrfi7w4p/dasiamrpn_kernel_r1.onnx?dl=0
+// - kernel_cls1: https://www.dropbox.com/s/qvmtszx5h339a0w/dasiamrpn_kernel_cls1.onnx?dl=0
+
+#include <iostream>
+#include <cmath>
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/video.hpp>
+
+using namespace cv;
+using namespace cv::dnn;
+
+const char *keys =
+        "{ help     h  |   | Print help message }"
+        "{ input    i  |   | Full path to input video folder, the specific camera index. (empty for camera 0) }"
+        "{ net         | dasiamrpn_model.onnx | Path to onnx model of net}"
+        "{ kernel_cls1 | dasiamrpn_kernel_cls1.onnx | Path to onnx model of kernel_r1 }"
+        "{ kernel_r1   | dasiamrpn_kernel_r1.onnx | Path to onnx model of kernel_cls1 }"
+        "{ backend     | 0 | Choose one of computation backends: "
+                            "0: automatically (by default), "
+                            "1: Halide language (http://halide-lang.org/), "
+                            "2: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                            "3: OpenCV implementation, "
+                            "4: VKCOM, "
+                            "5: CUDA },"
+        "{ target      | 0 | Choose one of target computation devices: "
+                            "0: CPU target (by default), "
+                            "1: OpenCL, "
+                            "2: OpenCL fp16 (half-float precision), "
+                            "3: VPU, "
+                            "4: Vulkan, "
+                            "6: CUDA, "
+                            "7: CUDA fp16 (half-float preprocess) }"
+;
+
+static
+int run(int argc, char** argv)
+{
+    // Parse command line arguments.
+    CommandLineParser parser(argc, argv, keys);
+
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    std::string inputName = parser.get<String>("input");
+    std::string net = parser.get<String>("net");
+    std::string kernel_cls1 = parser.get<String>("kernel_cls1");
+    std::string kernel_r1 = parser.get<String>("kernel_r1");
+    int backend = parser.get<int>("backend");
+    int target = parser.get<int>("target");
+
+    Ptr<TrackerDaSiamRPN> tracker;
+    try
+    {
+        TrackerDaSiamRPN::Params params;
+        params.model = samples::findFile(net);
+        params.kernel_cls1 = samples::findFile(kernel_cls1);
+        params.kernel_r1 = samples::findFile(kernel_r1);
+        params.backend = backend;
+        params.target = target;
+        tracker = TrackerDaSiamRPN::create(params);
+    }
+    catch (const cv::Exception& ee)
+    {
+        std::cerr << "Exception: " << ee.what() << std::endl;
+        std::cout << "Can't load the network by using the following files:" << std::endl;
+        std::cout << "siamRPN : " << net << std::endl;
+        std::cout << "siamKernelCL1 : " << kernel_cls1 << std::endl;
+        std::cout << "siamKernelR1 : " << kernel_r1 << std::endl;
+        return 2;
+    }
+
+    const std::string winName = "DaSiamRPN";
+    namedWindow(winName, WINDOW_AUTOSIZE);
+
+    // Open a video file or an image file or a camera stream.
+    VideoCapture cap;
+
+    if (inputName.empty() || (isdigit(inputName[0]) && inputName.size() == 1))
+    {
+        int c = inputName.empty() ? 0 : inputName[0] - '0';
+        std::cout << "Trying to open camera #" << c << " ..." << std::endl;
+        if (!cap.open(c))
+        {
+            std::cout << "Capture from camera #" << c << " didn't work. Specify -i=<video> parameter to read from video file" << std::endl;
+            return 2;
+        }
+    }
+    else if (inputName.size())
+    {
+        inputName = samples::findFileOrKeep(inputName);
+        if (!cap.open(inputName))
+        {
+            std::cout << "Could not open: " << inputName << std::endl;
+            return 2;
+        }
+    }
+
+    // Read the first image.
+    Mat image;
+    cap >> image;
+    if (image.empty())
+    {
+        std::cerr << "Can't capture frame!" << std::endl;
+        return 2;
+    }
+
+    Mat image_select = image.clone();
+    putText(image_select, "Select initial bounding box you want to track.", Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+    putText(image_select, "And Press the ENTER key.", Point(0, 35), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+
+    Rect selectRect = selectROI(winName, image_select);
+    std::cout << "ROI=" << selectRect << std::endl;
+
+    tracker->init(image, selectRect);
+
+    TickMeter tickMeter;
+
+    for (int count = 0; ; ++count)
+    {
+        cap >> image;
+        if (image.empty())
+        {
+            std::cerr << "Can't capture frame " << count << ". End of video stream?" << std::endl;
+            break;
+        }
+
+        Rect rect;
+
+        tickMeter.start();
+        bool ok = tracker->update(image, rect);
+        tickMeter.stop();
+
+        float score = tracker->getTrackingScore();
+
+        std::cout << "frame " << count <<
+            ": predicted score=" << score <<
+            "  rect=" << rect <<
+            "  time=" << tickMeter.getTimeMilli() << "ms" <<
+            std::endl;
+
+        Mat render_image = image.clone();
+
+        if (ok)
+        {
+            rectangle(render_image, rect, Scalar(0, 255, 0), 2);
+
+            std::string timeLabel = format("Inference time: %.2f ms", tickMeter.getTimeMilli());
+            std::string scoreLabel = format("Score: %f", score);
+            putText(render_image, timeLabel, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+            putText(render_image, scoreLabel, Point(0, 35), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+        }
+
+        imshow(winName, render_image);
+
+        tickMeter.reset();
+
+        int c = waitKey(1);
+        if (c == 27 /*ESC*/)
+            break;
+    }
+
+    std::cout << "Exit" << std::endl;
+    return 0;
+}
+
+
+int main(int argc, char **argv)
+{
+    try
+    {
+        return run(argc, argv);
+    }
+    catch (const std::exception& e)
+    {
+        std::cerr << "FATAL: C++ exception: " << e.what() << std::endl;
+        return 1;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/abstract_model.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/abstract_model.py
new file mode 100644
index 00000000..c968c53d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/abstract_model.py
@@ -0,0 +1,23 @@
+from abc import ABC, ABCMeta, abstractmethod
+
+
+class AbstractModel(ABC):
+
+    @abstractmethod
+    def get_prepared_models(self):
+        pass
+
+
+class Framework(object):
+    in_blob_name = ''
+    out_blob_name = ''
+
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def get_name(self):
+        pass
+
+    @abstractmethod
+    def get_output(self, input_blob):
+        pass
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/evaluation/classification/cls_accuracy_evaluator.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/evaluation/classification/cls_accuracy_evaluator.py
new file mode 100644
index 00000000..5028f924
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/evaluation/classification/cls_accuracy_evaluator.py
@@ -0,0 +1,96 @@
+import sys
+import time
+
+import numpy as np
+
+from ...utils import get_final_summary_info
+
+
+class ClsAccEvaluation:
+    log = sys.stdout
+    img_classes = {}
+    batch_size = 0
+
+    def __init__(self, log_path, img_classes_file, batch_size):
+        self.log = open(log_path, 'w')
+        self.img_classes = self.read_classes(img_classes_file)
+        self.batch_size = batch_size
+
+        # collect the accuracies for both models
+        self.general_quality_metric = []
+        self.general_inference_time = []
+
+    @staticmethod
+    def read_classes(img_classes_file):
+        result = {}
+        with open(img_classes_file) as file:
+            for l in file.readlines():
+                result[l.split()[0]] = int(l.split()[1])
+        return result
+
+    def get_correct_answers(self, img_list, net_output_blob):
+        correct_answers = 0
+        for i in range(len(img_list)):
+            indexes = np.argsort(net_output_blob[i])[-5:]
+            correct_index = self.img_classes[img_list[i]]
+            if correct_index in indexes:
+                correct_answers += 1
+        return correct_answers
+
+    def process(self, frameworks, data_fetcher):
+        sorted_imgs_names = sorted(self.img_classes.keys())
+        correct_answers = [0] * len(frameworks)
+        samples_handled = 0
+        blobs_l1_diff = [0] * len(frameworks)
+        blobs_l1_diff_count = [0] * len(frameworks)
+        blobs_l_inf_diff = [sys.float_info.min] * len(frameworks)
+        inference_time = [0.0] * len(frameworks)
+
+        for x in range(0, len(sorted_imgs_names), self.batch_size):
+            sublist = sorted_imgs_names[x:x + self.batch_size]
+            batch = data_fetcher.get_batch(sublist)
+
+            samples_handled += len(sublist)
+            fw_accuracy = []
+            fw_time = []
+            frameworks_out = []
+            for i in range(len(frameworks)):
+                start = time.time()
+                out = frameworks[i].get_output(batch)
+                end = time.time()
+                correct_answers[i] += self.get_correct_answers(sublist, out)
+                fw_accuracy.append(100 * correct_answers[i] / float(samples_handled))
+                frameworks_out.append(out)
+                inference_time[i] += end - start
+                fw_time.append(inference_time[i] / samples_handled * 1000)
+                print(samples_handled, 'Accuracy for', frameworks[i].get_name() + ':', fw_accuracy[i], file=self.log)
+                print("Inference time, ms ", frameworks[i].get_name(), fw_time[i], file=self.log)
+
+                self.general_quality_metric.append(fw_accuracy)
+                self.general_inference_time.append(fw_time)
+
+            for i in range(1, len(frameworks)):
+                log_str = frameworks[0].get_name() + " vs " + frameworks[i].get_name() + ':'
+                diff = np.abs(frameworks_out[0] - frameworks_out[i])
+                l1_diff = np.sum(diff) / diff.size
+                print(samples_handled, "L1 difference", log_str, l1_diff, file=self.log)
+                blobs_l1_diff[i] += l1_diff
+                blobs_l1_diff_count[i] += 1
+                if np.max(diff) > blobs_l_inf_diff[i]:
+                    blobs_l_inf_diff[i] = np.max(diff)
+                print(samples_handled, "L_INF difference", log_str, blobs_l_inf_diff[i], file=self.log)
+
+            self.log.flush()
+
+        for i in range(1, len(blobs_l1_diff)):
+            log_str = frameworks[0].get_name() + " vs " + frameworks[i].get_name() + ':'
+            print('Final l1 diff', log_str, blobs_l1_diff[i] / blobs_l1_diff_count[i], file=self.log)
+
+        print(
+            get_final_summary_info(
+                self.general_quality_metric,
+                self.general_inference_time,
+                "accuracy"
+            ),
+            file=self.log
+        )
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/evaluation/classification/cls_data_fetcher.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/evaluation/classification/cls_data_fetcher.py
new file mode 100644
index 00000000..805f5406
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/evaluation/classification/cls_data_fetcher.py
@@ -0,0 +1,87 @@
+import os
+from abc import ABCMeta, abstractmethod
+
+import cv2
+import numpy as np
+
+from ...img_utils import read_rgb_img, get_pytorch_preprocess
+from ...test.configs.default_preprocess_config import PYTORCH_RSZ_HEIGHT, PYTORCH_RSZ_WIDTH
+
+
+class DataFetch(object):
+    imgs_dir = ''
+    frame_size = 0
+    bgr_to_rgb = False
+
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def preprocess(self, img):
+        pass
+
+    @staticmethod
+    def reshape_img(img):
+        img = img[:, :, 0:3].transpose(2, 0, 1)
+        return np.expand_dims(img, 0)
+
+    def center_crop(self, img):
+        cols = img.shape[1]
+        rows = img.shape[0]
+
+        y1 = round((rows - self.frame_size) / 2)
+        y2 = round(y1 + self.frame_size)
+        x1 = round((cols - self.frame_size) / 2)
+        x2 = round(x1 + self.frame_size)
+        return img[y1:y2, x1:x2]
+
+    def initial_preprocess(self, img):
+        min_dim = min(img.shape[-3], img.shape[-2])
+        resize_ratio = self.frame_size / float(min_dim)
+
+        img = cv2.resize(img, (0, 0), fx=resize_ratio, fy=resize_ratio)
+        img = self.center_crop(img)
+        return img
+
+    def get_preprocessed_img(self, img_path):
+        image_data = read_rgb_img(img_path, self.bgr_to_rgb)
+        image_data = self.preprocess(image_data)
+        return self.reshape_img(image_data)
+
+    def get_batch(self, img_names):
+        assert type(img_names) is list
+        batch = np.zeros((len(img_names), 3, self.frame_size, self.frame_size)).astype(np.float32)
+
+        for i in range(len(img_names)):
+            img_name = img_names[i]
+            img_file = os.path.join(self.imgs_dir, img_name)
+            assert os.path.exists(img_file)
+
+            batch[i] = self.get_preprocessed_img(img_file)
+        return batch
+
+
+class PyTorchPreprocessedFetch(DataFetch):
+    def __init__(self, pytorch_cls_config, preprocess_input=None):
+        self.imgs_dir = pytorch_cls_config.img_root_dir
+        self.frame_size = pytorch_cls_config.frame_size
+        self.bgr_to_rgb = pytorch_cls_config.bgr_to_rgb
+        self.preprocess_input = preprocess_input
+
+    def preprocess(self, img):
+        img = cv2.resize(img, (PYTORCH_RSZ_WIDTH, PYTORCH_RSZ_HEIGHT))
+        img = self.center_crop(img)
+        if self.preprocess_input:
+            return self.presprocess_input(img)
+        return get_pytorch_preprocess(img)
+
+
+class TFPreprocessedFetch(DataFetch):
+    def __init__(self, tf_cls_config, preprocess_input):
+        self.imgs_dir = tf_cls_config.img_root_dir
+        self.frame_size = tf_cls_config.frame_size
+        self.bgr_to_rgb = tf_cls_config.bgr_to_rgb
+        self.preprocess_input = preprocess_input
+
+    def preprocess(self, img):
+        img = self.initial_preprocess(img)
+        return self.preprocess_input(img)
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/img_utils.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/img_utils.py
new file mode 100644
index 00000000..3e17ec87
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/img_utils.py
@@ -0,0 +1,19 @@
+import cv2
+import numpy as np
+
+from .test.configs.default_preprocess_config import BASE_IMG_SCALE_FACTOR
+
+
+def read_rgb_img(img_file, is_bgr_to_rgb=True):
+    img = cv2.imread(img_file, cv2.IMREAD_COLOR)
+    if is_bgr_to_rgb:
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    return img
+
+
+def get_pytorch_preprocess(img):
+    img = img.astype(np.float32)
+    img *= BASE_IMG_SCALE_FACTOR
+    img -= [0.485, 0.456, 0.406]
+    img /= [0.229, 0.224, 0.225]
+    return img
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/cls_model_test_pipeline.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/cls_model_test_pipeline.py
new file mode 100644
index 00000000..757d5130
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/cls_model_test_pipeline.py
@@ -0,0 +1,60 @@
+from .configs.test_config import TestClsConfig, TestClsModuleConfig
+from .model_test_pipeline import ModelTestPipeline
+from ..evaluation.classification.cls_accuracy_evaluator import ClsAccEvaluation
+from ..utils import get_test_module
+
+
+class ClsModelTestPipeline(ModelTestPipeline):
+    def __init__(
+            self,
+            network_model,
+            model_processor,
+            dnn_model_processor,
+            data_fetcher,
+            img_processor=None,
+            cls_args_parser=None,
+            default_input_blob_preproc=None
+    ):
+        super(ClsModelTestPipeline, self).__init__(
+            network_model,
+            model_processor,
+            dnn_model_processor
+        )
+
+        if cls_args_parser:
+            self._parser = cls_args_parser
+
+        self.test_config = TestClsConfig()
+
+        parser_args = self._parser.parse_args()
+
+        if parser_args.test:
+            self._test_module_config = TestClsModuleConfig()
+            self._test_module = get_test_module(
+                self._test_module_config.test_module_name,
+                self._test_module_config.test_module_path
+            )
+
+            if parser_args.default_img_preprocess:
+                self._default_input_blob_preproc = default_input_blob_preproc
+        if parser_args.evaluate:
+            self._data_fetcher = data_fetcher(self.test_config, img_processor)
+
+    def _configure_test_module_params(self):
+        self._test_module_param_list.extend((
+            '--crop', self._test_module_config.crop,
+            '--std', *self._test_module_config.std
+        ))
+
+        if self._test_module_config.rsz_height and self._test_module_config.rsz_width:
+            self._test_module_param_list.extend((
+                '--initial_height', self._test_module_config.rsz_height,
+                '--initial_width', self._test_module_config.rsz_width,
+            ))
+
+    def _configure_acc_eval(self, log_path):
+        self._accuracy_evaluator = ClsAccEvaluation(
+            log_path,
+            self.test_config.img_cls_file,
+            self.test_config.batch_size
+        )
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/configs/default_preprocess_config.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/configs/default_preprocess_config.py
new file mode 100644
index 00000000..e7ade915
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/configs/default_preprocess_config.py
@@ -0,0 +1,37 @@
+BASE_IMG_SCALE_FACTOR = 1 / 255.0
+PYTORCH_RSZ_HEIGHT = 256
+PYTORCH_RSZ_WIDTH = 256
+
+pytorch_resize_input_blob = {
+    "mean": ["123.675", "116.28", "103.53"],
+    "scale": str(BASE_IMG_SCALE_FACTOR),
+    "std": ["0.229", "0.224", "0.225"],
+    "crop": "True",
+    "rgb": True,
+    "rsz_height": str(PYTORCH_RSZ_HEIGHT),
+    "rsz_width": str(PYTORCH_RSZ_WIDTH)
+}
+
+pytorch_input_blob = {
+    "mean": ["123.675", "116.28", "103.53"],
+    "scale": str(BASE_IMG_SCALE_FACTOR),
+    "std": ["0.229", "0.224", "0.225"],
+    "crop": "True",
+    "rgb": True
+}
+
+tf_input_blob = {
+    "scale": str(1 / 127.5),
+    "mean": ["127.5", "127.5", "127.5"],
+    "std": [],
+    "crop": "True",
+    "rgb": True
+}
+
+tf_model_blob_caffe_mode = {
+    "mean": ["103.939", "116.779", "123.68"],
+    "scale": "1.0",
+    "std": [],
+    "crop": "True",
+    "rgb": False
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/configs/test_config.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/configs/test_config.py
new file mode 100644
index 00000000..55680918
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/configs/test_config.py
@@ -0,0 +1,40 @@
+import os
+from dataclasses import dataclass, field
+from typing import List
+
+
+@dataclass
+class CommonConfig:
+    output_data_root_dir: str = "dnn_model_runner/dnn_conversion"
+    logs_dir: str = os.path.join(output_data_root_dir, "logs")
+    log_file_path: str = os.path.join(logs_dir, "{}_log.txt")
+
+
+@dataclass
+class TestClsConfig:
+    batch_size: int = 1
+    frame_size: int = 224
+    img_root_dir: str = "./ILSVRC2012_img_val"
+    # location of image-class matching
+    img_cls_file: str = "./val.txt"
+    bgr_to_rgb: bool = True
+
+
+@dataclass
+class TestClsModuleConfig:
+    cls_test_data_dir: str = "../data"
+    test_module_name: str = "classification"
+    test_module_path: str = "classification.py"
+    input_img: str = os.path.join(cls_test_data_dir, "squirrel_cls.jpg")
+    model: str = ""
+
+    frame_height: str = str(TestClsConfig.frame_size)
+    frame_width: str = str(TestClsConfig.frame_size)
+    scale: str = "1.0"
+    mean: List[str] = field(default_factory=lambda: ["0.0", "0.0", "0.0"])
+    std: List[str] = field(default_factory=list)
+    crop: str = "False"
+    rgb: str = "True"
+    rsz_height: str = ""
+    rsz_width: str = ""
+    classes: str = os.path.join(cls_test_data_dir, "dnn", "classification_classes_ILSVRC2012.txt")
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/model_test_pipeline.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/model_test_pipeline.py
new file mode 100644
index 00000000..38b9c38e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/test/model_test_pipeline.py
@@ -0,0 +1,126 @@
+import os
+
+import numpy as np
+
+from .configs.test_config import CommonConfig
+from ..utils import create_parser, plot_acc
+
+
+class ModelTestPipeline:
+    def __init__(
+            self,
+            network_model,
+            model_processor,
+            dnn_model_processor
+    ):
+        self._net_model = network_model
+        self._model_processor = model_processor
+        self._dnn_model_processor = dnn_model_processor
+
+        self._parser = create_parser()
+
+        self._test_module = None
+        self._test_module_config = None
+        self._test_module_param_list = None
+
+        self.test_config = None
+        self._data_fetcher = None
+
+        self._default_input_blob_preproc = None
+        self._accuracy_evaluator = None
+
+    def init_test_pipeline(self):
+        cmd_args = self._parser.parse_args()
+        model_dict = self._net_model.get_prepared_models()
+
+        model_names = list(model_dict.keys())
+        print(
+            "The model {} was successfully obtained and converted to OpenCV {}".format(model_names[0], model_names[1])
+        )
+
+        if cmd_args.test:
+            if not self._test_module_config.model:
+                self._test_module_config.model = self._net_model.model_path["full_path"]
+
+            if cmd_args.default_img_preprocess:
+                self._test_module_config.scale = self._default_input_blob_preproc["scale"]
+                self._test_module_config.mean = self._default_input_blob_preproc["mean"]
+                self._test_module_config.std = self._default_input_blob_preproc["std"]
+                self._test_module_config.crop = self._default_input_blob_preproc["crop"]
+
+                if "rsz_height" in self._default_input_blob_preproc and "rsz_width" in self._default_input_blob_preproc:
+                    self._test_module_config.rsz_height = self._default_input_blob_preproc["rsz_height"]
+                    self._test_module_config.rsz_width = self._default_input_blob_preproc["rsz_width"]
+
+                self._test_module_param_list = [
+                    '--model', self._test_module_config.model,
+                    '--input', self._test_module_config.input_img,
+                    '--width', self._test_module_config.frame_width,
+                    '--height', self._test_module_config.frame_height,
+                    '--scale', self._test_module_config.scale,
+                    '--mean', *self._test_module_config.mean,
+                    '--std', *self._test_module_config.std,
+                    '--classes', self._test_module_config.classes,
+                ]
+
+                if self._default_input_blob_preproc["rgb"]:
+                    self._test_module_param_list.append('--rgb')
+
+                self._configure_test_module_params()
+
+            self._test_module.main(
+                self._test_module_param_list
+            )
+
+        if cmd_args.evaluate:
+            original_model_name = model_names[0]
+            dnn_model_name = model_names[1]
+
+            self.run_test_pipeline(
+                [
+                    self._model_processor(model_dict[original_model_name], original_model_name),
+                    self._dnn_model_processor(model_dict[dnn_model_name], dnn_model_name)
+                ],
+                original_model_name.replace(" ", "_")
+            )
+
+    def run_test_pipeline(
+            self,
+            models_list,
+            formatted_exp_name,
+            is_plot_acc=True
+    ):
+        log_path, logs_dir = self._configure_eval_log(formatted_exp_name)
+
+        print(
+            "===== Running evaluation of the model with the following params:\n"
+            "\t* val data location: {}\n"
+            "\t* log file location: {}\n".format(
+                self.test_config.img_root_dir,
+                log_path
+            )
+        )
+
+        os.makedirs(logs_dir, exist_ok=True)
+
+        self._configure_acc_eval(log_path)
+        self._accuracy_evaluator.process(models_list, self._data_fetcher)
+
+        if is_plot_acc:
+            plot_acc(
+                np.array(self._accuracy_evaluator.general_inference_time),
+                formatted_exp_name
+            )
+
+        print("===== End of the evaluation pipeline =====")
+
+    def _configure_acc_eval(self, log_path):
+        pass
+
+    def _configure_test_module_params(self):
+        pass
+
+    @staticmethod
+    def _configure_eval_log(formatted_exp_name):
+        common_test_config = CommonConfig()
+        return common_test_config.log_file_path.format(formatted_exp_name), common_test_config.logs_dir
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/utils.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/utils.py
new file mode 100644
index 00000000..cf24dd38
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/common/utils.py
@@ -0,0 +1,153 @@
+import argparse
+import importlib.util
+import os
+import random
+
+import matplotlib.pyplot as plt
+import numpy as np
+import tensorflow as tf
+import torch
+
+from .test.configs.test_config import CommonConfig
+
+SEED_VAL = 42
+DNN_LIB = "DNN"
+# common path for model savings
+MODEL_PATH_ROOT = os.path.join(CommonConfig().output_data_root_dir, "{}/models")
+
+
+def get_full_model_path(lib_name, model_full_name):
+    model_path = MODEL_PATH_ROOT.format(lib_name)
+    return {
+        "path": model_path,
+        "full_path": os.path.join(model_path, model_full_name)
+    }
+
+
+def plot_acc(data_list, experiment_name):
+    plt.figure(figsize=[8, 6])
+    plt.plot(data_list[:, 0], "r", linewidth=2.5, label="Original Model")
+    plt.plot(data_list[:, 1], "b", linewidth=2.5, label="Converted DNN Model")
+    plt.xlabel("Iterations ", fontsize=15)
+    plt.ylabel("Time (ms)", fontsize=15)
+    plt.title(experiment_name, fontsize=15)
+    plt.legend()
+    full_path_to_fig = os.path.join(CommonConfig().output_data_root_dir, experiment_name + ".png")
+    plt.savefig(full_path_to_fig, bbox_inches="tight")
+
+
+def get_final_summary_info(general_quality_metric, general_inference_time, metric_name):
+    general_quality_metric = np.array(general_quality_metric)
+    general_inference_time = np.array(general_inference_time)
+    summary_line = "===== End of processing. General results:\n"
+    "\t* mean {} for the original model: {}\t"
+    "\t* mean time (min) for the original model inferences: {}\n"
+    "\t* mean {} for the DNN model: {}\t"
+    "\t* mean time (min) for the DNN model inferences: {}\n".format(
+        metric_name, np.mean(general_quality_metric[:, 0]),
+        np.mean(general_inference_time[:, 0]) / 60000,
+        metric_name, np.mean(general_quality_metric[:, 1]),
+        np.mean(general_inference_time[:, 1]) / 60000,
+    )
+    return summary_line
+
+
+def set_common_reproducibility():
+    random.seed(SEED_VAL)
+    np.random.seed(SEED_VAL)
+
+
+def set_pytorch_env():
+    set_common_reproducibility()
+    torch.manual_seed(SEED_VAL)
+    torch.set_printoptions(precision=10)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(SEED_VAL)
+        torch.backends.cudnn_benchmark_enabled = False
+        torch.backends.cudnn.deterministic = True
+
+
+def set_tf_env(is_use_gpu=True):
+    set_common_reproducibility()
+    tf.random.set_seed(SEED_VAL)
+    os.environ["TF_DETERMINISTIC_OPS"] = "1"
+
+    if tf.config.list_physical_devices("GPU") and is_use_gpu:
+        gpu_devices = tf.config.list_physical_devices("GPU")
+        tf.config.experimental.set_visible_devices(gpu_devices[0], "GPU")
+        tf.config.experimental.set_memory_growth(gpu_devices[0], True)
+        os.environ["TF_USE_CUDNN"] = "1"
+    else:
+        os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
+
+def str_bool(input_val):
+    if input_val.lower() in ('yes', 'true', 't', 'y', '1'):
+        return True
+    elif input_val.lower() in ('no', 'false', 'f', 'n', '0'):
+        return False
+    else:
+        raise argparse.ArgumentTypeError('Boolean value was expected')
+
+
+def get_formatted_model_list(model_list):
+    note_line = 'Please, choose the model from the below list:\n'
+    spaces_to_set = ' ' * (len(note_line) - 2)
+    return note_line + ''.join([spaces_to_set, '{} \n'] * len(model_list)).format(*model_list)
+
+
+def model_str(model_list):
+    def type_model_list(input_val):
+        if input_val.lower() in model_list:
+            return input_val.lower()
+        else:
+            raise argparse.ArgumentTypeError(
+                'The model is currently unavailable for test.\n' +
+                get_formatted_model_list(model_list)
+            )
+
+    return type_model_list
+
+
+def get_test_module(test_module_name, test_module_path):
+    module_spec = importlib.util.spec_from_file_location(test_module_name, test_module_path)
+    test_module = importlib.util.module_from_spec(module_spec)
+    module_spec.loader.exec_module(test_module)
+    module_spec.loader.exec_module(test_module)
+    return test_module
+
+
+def create_parser():
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument(
+        "--test",
+        type=str_bool,
+        help="Define whether you'd like to run the model with OpenCV for testing.",
+        default=False
+    ),
+    parser.add_argument(
+        "--default_img_preprocess",
+        type=str_bool,
+        help="Define whether you'd like to preprocess the input image with defined"
+             " PyTorch or TF functions for model test with OpenCV.",
+        default=False
+    ),
+    parser.add_argument(
+        "--evaluate",
+        type=str_bool,
+        help="Define whether you'd like to run evaluation of the models (ex.: TF vs OpenCV networks).",
+        default=True
+    )
+    return parser
+
+
+def create_extended_parser(model_list):
+    parser = create_parser()
+    parser.add_argument(
+        "--model_name",
+        type=model_str(model_list=model_list),
+        help="\nDefine the model name to test.\n" +
+             get_formatted_model_list(model_list),
+        required=True
+    )
+    return parser
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/README.md b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/README.md
new file mode 100644
index 00000000..1b1a2876
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/README.md
@@ -0,0 +1,78 @@
+# Run PaddlePaddle model using OpenCV
+
+These two demonstrations show how to inference PaddlePaddle model using OpenCV.
+
+## Environment Setup
+
+```shell
+pip install paddlepaddle-gpu
+pip install paddlehub
+pip install paddle2onnx
+```
+
+## 1. Run PaddlePaddle ResNet50 using OpenCV
+
+### Run PaddlePaddle model demo
+
+Run the code sample as follows:
+
+```shell
+python paddle_resnet50.py
+```
+
+There are three parts to the process:
+
+1. Export PaddlePaddle ResNet50 model to onnx format.
+2. Use `cv2.dnn.readNetFromONNX` to load the model file.
+3. Preprocess image file and do the inference.
+
+## 2. Run PaddleSeg Portrait Segmentation using OpenCV
+
+### Convert to ONNX Model
+
+#### 1. Get Paddle Inference model
+
+For more details, please refer to [PaddleSeg](https://github.com/PaddlePaddle/PaddleSeg/blob/release/2.1/contrib/HumanSeg/README.md).
+
+```shell
+wget https://x2paddle.bj.bcebos.com/inference/models/humanseg_hrnet18_small_v1.zip
+unzip humanseg_hrnet18_small_v1.zip
+```
+
+Notes:
+
+* The exported model must have a fixed input shape, as dynamic is not supported at this moment.
+
+#### 2. Convert to ONNX model using paddle2onnx
+
+To convert the model, use the following command:
+
+```
+paddle2onnx --model_dir humanseg_hrnet18_small_v1 \
+            --model_filename model.pdmodel \
+            --params_filename model.pdiparams \
+            --opset_version 11 \
+            --save_file humanseg_hrnet18_tiny.onnx
+```
+
+The converted model can be found in the current directory by the name `humanseg_hrnet18_tiny.onnx` .
+
+### Run PaddleSeg Portrait Segmentation demo
+
+Run the code sample as follows:
+
+```shell
+python paddle_humanseg.py
+```
+
+There are three parts to the process:
+
+1. Use `cv2.dnn.readNetFromONNX` to load the model file.
+2. Preprocess image file and do inference.
+3. Postprocess image file and visualize.
+
+The resulting file can be found at `data/result_test_human.jpg` .
+
+### Portrait segmentation visualization
+
+<img src="../../../../data/messi5.jpg" width="50%" height="50%"><img src="./data/result_test_human.jpg" width="50%" height="50%">
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/data/cat.jpg b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/data/cat.jpg
new file mode 100644
index 00000000..89253641
Binary files /dev/null and b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/data/cat.jpg differ
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/data/labels.txt b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/data/labels.txt
new file mode 100644
index 00000000..52baabc6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/data/labels.txt
@@ -0,0 +1,1000 @@
+tench
+goldfish
+great white shark
+tiger shark
+hammerhead
+electric ray
+stingray
+cock
+hen
+ostrich
+brambling
+goldfinch
+house finch
+junco
+indigo bunting
+robin
+bulbul
+jay
+magpie
+chickadee
+water ouzel
+kite
+bald eagle
+vulture
+great grey owl
+European fire salamander
+common newt
+eft
+spotted salamander
+axolotl
+bullfrog
+tree frog
+tailed frog
+loggerhead
+leatherback turtle
+mud turtle
+terrapin
+box turtle
+banded gecko
+common iguana
+American chameleon
+whiptail
+agama
+frilled lizard
+alligator lizard
+Gila monster
+green lizard
+African chameleon
+Komodo dragon
+African crocodile
+American alligator
+triceratops
+thunder snake
+ringneck snake
+hognose snake
+green snake
+king snake
+garter snake
+water snake
+vine snake
+night snake
+boa constrictor
+rock python
+Indian cobra
+green mamba
+sea snake
+horned viper
+diamondback
+sidewinder
+trilobite
+harvestman
+scorpion
+black and gold garden spider
+barn spider
+garden spider
+black widow
+tarantula
+wolf spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse
+prairie chicken
+peacock
+quail
+partridge
+African grey
+macaw
+sulphur-crested cockatoo
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser
+goose
+black swan
+tusker
+echidna
+platypus
+wallaby
+koala
+wombat
+jellyfish
+sea anemone
+brain coral
+flatworm
+nematode
+conch
+snail
+slug
+sea slug
+chiton
+chambered nautilus
+Dungeness crab
+rock crab
+fiddler crab
+king crab
+American lobster
+spiny lobster
+crayfish
+hermit crab
+isopod
+white stork
+black stork
+spoonbill
+flamingo
+little blue heron
+American egret
+bittern
+crane
+limpkin
+European gallinule
+American coot
+bustard
+ruddy turnstone
+red-backed sandpiper
+redshank
+dowitcher
+oystercatcher
+pelican
+king penguin
+albatross
+grey whale
+killer whale
+dugong
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog
+Pekinese
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound
+basset
+beagle
+bloodhound
+bluetick
+black-and-tan coonhound
+Walker hound
+English foxhound
+redbone
+borzoi
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound
+Norwegian elkhound
+otterhound
+Saluki
+Scottish deerhound
+Weimaraner
+Staffordshire bullterrier
+American Staffordshire terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier
+Airedale
+cairn
+Australian terrier
+Dandie Dinmont
+Boston bull
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier
+Tibetan terrier
+silky terrier
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla
+English setter
+Irish setter
+Gordon setter
+Brittany spaniel
+clumber
+English springer
+Welsh springer spaniel
+cocker spaniel
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog
+Shetland sheepdog
+collie
+Border collie
+Bouvier des Flandres
+Rottweiler
+German shepherd
+Doberman
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard
+Eskimo dog
+malamute
+Siberian husky
+dalmatian
+affenpinscher
+basenji
+pug
+Leonberg
+Newfoundland
+Great Pyrenees
+Samoyed
+Pomeranian
+chow
+keeshond
+Brabancon griffon
+Pembroke
+Cardigan
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf
+white wolf
+red wolf
+coyote
+dingo
+dhole
+African hunting dog
+hyena
+red fox
+kit fox
+Arctic fox
+grey fox
+tabby
+tiger cat
+Persian cat
+Siamese cat
+Egyptian cat
+cougar
+lynx
+leopard
+snow leopard
+jaguar
+lion
+tiger
+cheetah
+brown bear
+American black bear
+ice bear
+sloth bear
+mongoose
+meerkat
+tiger beetle
+ladybug
+ground beetle
+long-horned beetle
+leaf beetle
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant
+grasshopper
+cricket
+walking stick
+cockroach
+mantis
+cicada
+leafhopper
+lacewing
+dragonfly
+damselfly
+admiral
+ringlet
+monarch
+cabbage butterfly
+sulphur butterfly
+lycaenid
+starfish
+sea urchin
+sea cucumber
+wood rabbit
+hare
+Angora
+hamster
+porcupine
+fox squirrel
+marmot
+beaver
+guinea pig
+sorrel
+zebra
+hog
+wild boar
+warthog
+hippopotamus
+ox
+water buffalo
+bison
+ram
+bighorn
+ibex
+hartebeest
+impala
+gazelle
+Arabian camel
+llama
+weasel
+mink
+polecat
+black-footed ferret
+otter
+skunk
+badger
+armadillo
+three-toed sloth
+orangutan
+gorilla
+chimpanzee
+gibbon
+siamang
+guenon
+patas
+baboon
+macaque
+langur
+colobus
+proboscis monkey
+marmoset
+capuchin
+howler monkey
+titi
+spider monkey
+squirrel monkey
+Madagascar cat
+indri
+Indian elephant
+African elephant
+lesser panda
+giant panda
+barracouta
+eel
+coho
+rock beauty
+anemone fish
+sturgeon
+gar
+lionfish
+puffer
+abacus
+abaya
+academic gown
+accordion
+acoustic guitar
+aircraft carrier
+airliner
+airship
+altar
+ambulance
+amphibian
+analog clock
+apiary
+apron
+ashcan
+assault rifle
+backpack
+bakery
+balance beam
+balloon
+ballpoint
+Band Aid
+banjo
+bannister
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel
+barrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap
+bath towel
+bathtub
+beach wagon
+beacon
+beaker
+bearskin
+beer bottle
+beer glass
+bell cote
+bib
+bicycle-built-for-two
+bikini
+binder
+binoculars
+birdhouse
+boathouse
+bobsled
+bolo tie
+bonnet
+bookcase
+bookshop
+bottlecap
+bow
+bow tie
+brass
+brassiere
+breakwater
+breastplate
+broom
+bucket
+buckle
+bulletproof vest
+bullet train
+butcher shop
+cab
+caldron
+candle
+cannon
+canoe
+can opener
+cardigan
+car mirror
+carousel
+carpenters kit
+carton
+car wheel
+cash machine
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello
+cellular telephone
+chain
+chainlink fence
+chain mail
+chain saw
+chest
+chiffonier
+chime
+china cabinet
+Christmas stocking
+church
+cinema
+cleaver
+cliff dwelling
+cloak
+clog
+cocktail shaker
+coffee mug
+coffeepot
+coil
+combination lock
+computer keyboard
+confectionery
+container ship
+convertible
+corkscrew
+cornet
+cowboy boot
+cowboy hat
+cradle
+crane
+crash helmet
+crate
+crib
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam
+desk
+desktop computer
+dial telephone
+diaper
+digital clock
+digital watch
+dining table
+dishrag
+dishwasher
+disk brake
+dock
+dogsled
+dome
+doormat
+drilling platform
+drum
+drumstick
+dumbbell
+Dutch oven
+electric fan
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa
+file
+fireboat
+fire engine
+fire screen
+flagpole
+flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn
+frying pan
+fur coat
+garbage truck
+gasmask
+gas pump
+goblet
+go-kart
+golf ball
+golfcart
+gondola
+gong
+gown
+grand piano
+greenhouse
+grille
+grocery store
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower
+hand-held computer
+handkerchief
+hard disc
+harmonica
+harp
+harvester
+hatchet
+holster
+home theater
+honeycomb
+hook
+hoopskirt
+horizontal bar
+horse cart
+hourglass
+iPod
+iron
+jack-o-lantern
+jean
+jeep
+jersey
+jigsaw puzzle
+jinrikisha
+joystick
+kimono
+knee pad
+knot
+lab coat
+ladle
+lampshade
+laptop
+lawn mower
+lens cap
+letter opener
+library
+lifeboat
+lighter
+limousine
+liner
+lipstick
+Loafer
+lotion
+loudspeaker
+loupe
+lumbermill
+magnetic compass
+mailbag
+mailbox
+maillot
+maillot
+manhole cover
+maraca
+marimba
+mask
+matchstick
+maypole
+maze
+measuring cup
+medicine chest
+megalith
+microphone
+microwave
+military uniform
+milk can
+minibus
+miniskirt
+minivan
+missile
+mitten
+mixing bowl
+mobile home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter
+mountain bike
+mountain tent
+mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook
+obelisk
+oboe
+ocarina
+odometer
+oil filter
+organ
+oscilloscope
+overskirt
+oxcart
+oxygen mask
+packet
+paddle
+paddlewheel
+padlock
+paintbrush
+pajama
+palace
+panpipe
+paper towel
+parachute
+parallel bars
+park bench
+parking meter
+passenger car
+patio
+pay-phone
+pedestal
+pencil box
+pencil sharpener
+perfume
+Petri dish
+photocopier
+pick
+pickelhaube
+picket fence
+pickup
+pier
+piggy bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate
+pitcher
+plane
+planetarium
+plastic bag
+plate rack
+plow
+plunger
+Polaroid camera
+pole
+police van
+poncho
+pool table
+pop bottle
+pot
+potters wheel
+power drill
+prayer rug
+printer
+prison
+projectile
+projector
+puck
+punching bag
+purse
+quill
+quilt
+racer
+racket
+radiator
+radio
+radio telescope
+rain barrel
+recreational vehicle
+reel
+reflex camera
+refrigerator
+remote control
+restaurant
+revolver
+rifle
+rocking chair
+rotisserie
+rubber eraser
+rugby ball
+rule
+running shoe
+safe
+safety pin
+saltshaker
+sandal
+sarong
+sax
+scabbard
+scale
+school bus
+schooner
+scoreboard
+screen
+screw
+screwdriver
+seat belt
+sewing machine
+shield
+shoe shop
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule
+sliding door
+slot
+snorkel
+snowmobile
+snowplow
+soap dispenser
+soccer ball
+sock
+solar dish
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web
+spindle
+sports car
+spotlight
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch
+stove
+strainer
+streetcar
+stretcher
+studio couch
+stupa
+submarine
+suit
+sundial
+sunglass
+sunglasses
+sunscreen
+suspension bridge
+swab
+sweatshirt
+swimming trunks
+swing
+switch
+syringe
+table lamp
+tank
+tape player
+teapot
+teddy
+television
+tennis ball
+thatch
+theater curtain
+thimble
+thresher
+throne
+tile roof
+toaster
+tobacco shop
+toilet seat
+torch
+totem pole
+tow truck
+toyshop
+tractor
+trailer truck
+tray
+trench coat
+tricycle
+trimaran
+tripod
+triumphal arch
+trolleybus
+trombone
+tub
+turnstile
+typewriter keyboard
+umbrella
+unicycle
+upright
+vacuum
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin
+volleyball
+waffle iron
+wall clock
+wallet
+wardrobe
+warplane
+washbasin
+washer
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool
+worm fence
+wreck
+yawl
+yurt
+web site
+comic book
+crossword puzzle
+street sign
+traffic light
+book jacket
+menu
+plate
+guacamole
+consomme
+hot pot
+trifle
+ice cream
+ice lolly
+French loaf
+bagel
+pretzel
+cheeseburger
+hotdog
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini
+spaghetti squash
+acorn squash
+butternut squash
+cucumber
+artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple
+banana
+jackfruit
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce
+dough
+meat loaf
+pizza
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff
+coral reef
+geyser
+lakeside
+promontory
+sandbar
+seashore
+valley
+volcano
+ballplayer
+groom
+scuba diver
+rapeseed
+daisy
+yellow ladys slipper
+corn
+acorn
+hip
+buckeye
+coral fungus
+agaric
+gyromitra
+stinkhorn
+earthstar
+hen-of-the-woods
+bolete
+ear
+toilet tissue
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/data/result_test_human.jpg b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/data/result_test_human.jpg
new file mode 100644
index 00000000..652b03f3
Binary files /dev/null and b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/data/result_test_human.jpg differ
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/paddle_humanseg.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/paddle_humanseg.py
new file mode 100644
index 00000000..e2ef62ea
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/paddle_humanseg.py
@@ -0,0 +1,112 @@
+import os
+import paddlehub.vision.transforms as T
+import numpy as np
+import cv2 as cv
+
+
+def get_color_map_list(num_classes):
+    """
+    Returns the color map for visualizing the segmentation mask,
+    which can support arbitrary number of classes.
+
+    Args:
+        num_classes (int): Number of classes.
+
+    Returns:
+        (list). The color map.
+    """
+
+    num_classes += 1
+    color_map = num_classes * [0, 0, 0]
+    for i in range(0, num_classes):
+        j = 0
+        lab = i
+        while lab:
+            color_map[i * 3] |= (((lab >> 0) & 1) << (7 - j))
+            color_map[i * 3 + 1] |= (((lab >> 1) & 1) << (7 - j))
+            color_map[i * 3 + 2] |= (((lab >> 2) & 1) << (7 - j))
+            j += 1
+            lab >>= 3
+    color_map = color_map[3:]
+    return color_map
+
+
+def visualize(image, result, save_dir=None, weight=0.6):
+    """
+    Convert predict result to color image, and save added image.
+
+    Args:
+        image (str): The path of origin image.
+        result (np.ndarray): The predict result of image.
+        save_dir (str): The directory for saving visual image. Default: None.
+        weight (float): The image weight of visual image, and the result weight is (1 - weight). Default: 0.6
+
+    Returns:
+        vis_result (np.ndarray): If `save_dir` is None, return the visualized result.
+    """
+
+    color_map = get_color_map_list(256)
+    color_map = [color_map[i:i + 3] for i in range(0, len(color_map), 3)]
+    color_map = np.array(color_map).astype("uint8")
+    # Use OpenCV LUT for color mapping
+    c1 = cv.LUT(result, color_map[:, 0])
+    c2 = cv.LUT(result, color_map[:, 1])
+    c3 = cv.LUT(result, color_map[:, 2])
+    pseudo_img = np.dstack((c1, c2, c3))
+
+    im = cv.imread(image)
+    vis_result = cv.addWeighted(im, weight, pseudo_img, 1 - weight, 0)
+
+    if save_dir is not None:
+        if not os.path.exists(save_dir):
+            os.makedirs(save_dir)
+        image_name = os.path.split(image)[-1]
+        out_path = os.path.join(save_dir, image_name)
+        cv.imwrite(out_path, vis_result)
+    else:
+        return vis_result
+
+
+def preprocess(image_path):
+    ''' preprocess input image file to np.ndarray
+
+    Args:
+        image_path(str): Path of input image file
+
+    Returns:
+        ProcessedImage(numpy.ndarray): A numpy.ndarray
+                variable which shape is (1, 3, 192, 192)
+    '''
+    transforms = T.Compose([
+        T.Resize((192, 192)),
+        T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+    ],
+        to_rgb=True)
+    return np.expand_dims(transforms(image_path), axis=0)
+
+
+if __name__ == '__main__':
+    img_path = "../../../../data/messi5.jpg"
+    # load PPSeg Model use cv.dnn
+    net = cv.dnn.readNetFromONNX('humanseg_hrnet18_tiny.onnx')
+    # read and preprocess image file
+    im = preprocess(img_path)
+    # inference
+    net.setInput(im)
+    result = net.forward(['save_infer_model/scale_0.tmp_1'])
+    # post process
+    image = cv.imread(img_path)
+    r, c, _ = image.shape
+    result = np.argmax(result[0], axis=1).astype(np.uint8)
+    result = cv.resize(result[0, :, :],
+                       dsize=(c, r),
+                       interpolation=cv.INTER_NEAREST)
+
+    print("grid_image.shape is: ", result.shape)
+    folder_path = "data"
+    if not os.path.exists(folder_path):
+        os.makedirs(folder_path)
+    file_path = os.path.join(folder_path, '%s.jpg' % "result_test_human")
+    result_color = visualize(img_path, result)
+    cv.imwrite(file_path, result_color)
+    print('%s saved' % file_path)
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/paddle_resnet50.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/paddle_resnet50.py
new file mode 100644
index 00000000..90c0d26e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/paddlepaddle/paddle_resnet50.py
@@ -0,0 +1,61 @@
+import paddle
+import paddlehub as hub
+import paddlehub.vision.transforms as T
+import cv2 as cv
+import numpy as np
+
+
+def preprocess(image_path):
+    ''' preprocess input image file to np.ndarray
+
+    Args:
+        image_path(str): Path of input image file
+
+    Returns:
+        ProcessedImage(numpy.ndarray): A numpy.ndarray
+                variable which shape is (1, 3, 224, 224)
+    '''
+    transforms = T.Compose([
+        T.Resize((256, 256)),
+        T.CenterCrop(224),
+        T.Normalize(mean=[0.485, 0.456, 0.406],
+                    std=[0.229, 0.224, 0.225])],
+        to_rgb=True)
+    return np.expand_dims(transforms(image_path), axis=0)
+
+
+def export_onnx_resnet50(save_path):
+    ''' export PaddlePaddle model to ONNX format
+
+    Args:
+        save_path(str): Path to save exported ONNX model
+
+    Returns:
+        None
+    '''
+    model = hub.Module(name="resnet50_vd_imagenet_ssld")
+    input_spec = paddle.static.InputSpec(
+        [1, 3, 224, 224], "float32", "image")
+    paddle.onnx.export(model, save_path,
+                       input_spec=[input_spec],
+                       opset_version=10)
+
+
+if __name__ == '__main__':
+    save_path = './resnet50'
+    image_file = './data/cat.jpg'
+    labels = open('./data/labels.txt').read().strip().split('\n')
+    model = export_onnx_resnet50(save_path)
+
+    # load resnet50 use cv.dnn
+    net = cv.dnn.readNetFromONNX(save_path + '.onnx')
+    # read and preprocess image file
+    im = preprocess(image_file)
+    # inference
+    net.setInput(im)
+    result = net.forward(['save_infer_model/scale_0.tmp_0'])
+    # post process
+    class_id = np.argmax(result[0])
+    label = labels[class_id]
+    print("Image: {}".format(image_file))
+    print("Predict Category: {}".format(label))
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/classification/py_to_py_cls.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/classification/py_to_py_cls.py
new file mode 100644
index 00000000..abbd7389
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/classification/py_to_py_cls.py
@@ -0,0 +1,71 @@
+from torchvision import models
+
+from ..pytorch_model import (
+    PyTorchModelPreparer,
+    PyTorchModelProcessor,
+    PyTorchDnnModelProcessor
+)
+from ...common.evaluation.classification.cls_data_fetcher import PyTorchPreprocessedFetch
+from ...common.test.cls_model_test_pipeline import ClsModelTestPipeline
+from ...common.test.configs.default_preprocess_config import pytorch_resize_input_blob
+from ...common.test.configs.test_config import TestClsConfig
+from ...common.utils import set_pytorch_env, create_extended_parser
+
+model_dict = {
+    "alexnet": models.alexnet,
+
+    "vgg11": models.vgg11,
+    "vgg13": models.vgg13,
+    "vgg16": models.vgg16,
+    "vgg19": models.vgg19,
+
+    "resnet18": models.resnet18,
+    "resnet34": models.resnet34,
+    "resnet50": models.resnet50,
+    "resnet101": models.resnet101,
+    "resnet152": models.resnet152,
+
+    "squeezenet1_0": models.squeezenet1_0,
+    "squeezenet1_1": models.squeezenet1_1,
+
+    "resnext50_32x4d": models.resnext50_32x4d,
+    "resnext101_32x8d": models.resnext101_32x8d,
+
+    "wide_resnet50_2": models.wide_resnet50_2,
+    "wide_resnet101_2": models.wide_resnet101_2
+}
+
+
+class PyTorchClsModel(PyTorchModelPreparer):
+    def __init__(self, height, width, model_name, original_model):
+        super(PyTorchClsModel, self).__init__(height, width, model_name, original_model)
+
+
+def main():
+    set_pytorch_env()
+
+    parser = create_extended_parser(list(model_dict.keys()))
+    cmd_args = parser.parse_args()
+    model_name = cmd_args.model_name
+
+    cls_model = PyTorchClsModel(
+        height=TestClsConfig().frame_size,
+        width=TestClsConfig().frame_size,
+        model_name=model_name,
+        original_model=model_dict[model_name](pretrained=True)
+    )
+
+    pytorch_cls_pipeline = ClsModelTestPipeline(
+        network_model=cls_model,
+        model_processor=PyTorchModelProcessor,
+        dnn_model_processor=PyTorchDnnModelProcessor,
+        data_fetcher=PyTorchPreprocessedFetch,
+        cls_args_parser=parser,
+        default_input_blob_preproc=pytorch_resize_input_blob
+    )
+
+    pytorch_cls_pipeline.init_test_pipeline()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/classification/py_to_py_resnet50.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/classification/py_to_py_resnet50.py
new file mode 100644
index 00000000..3a228bf1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/classification/py_to_py_resnet50.py
@@ -0,0 +1,139 @@
+import os
+
+import cv2
+import numpy as np
+import torch
+import torch.onnx
+from torch.autograd import Variable
+from torchvision import models
+
+
+def get_pytorch_onnx_model(original_model):
+    # define the directory for further converted model save
+    onnx_model_path = "models"
+    # define the name of further converted model
+    onnx_model_name = "resnet50.onnx"
+
+    # create directory for further converted model
+    os.makedirs(onnx_model_path, exist_ok=True)
+
+    # get full path to the converted model
+    full_model_path = os.path.join(onnx_model_path, onnx_model_name)
+
+    # generate model input
+    generated_input = Variable(
+        torch.randn(1, 3, 224, 224)
+    )
+
+    # model export into ONNX format
+    torch.onnx.export(
+        original_model,
+        generated_input,
+        full_model_path,
+        verbose=True,
+        input_names=["input"],
+        output_names=["output"],
+        opset_version=11
+    )
+
+    return full_model_path
+
+
+def get_preprocessed_img(img_path):
+    # read the image
+    input_img = cv2.imread(img_path, cv2.IMREAD_COLOR)
+    input_img = input_img.astype(np.float32)
+
+    input_img = cv2.resize(input_img, (256, 256))
+
+    # define preprocess parameters
+    mean = np.array([0.485, 0.456, 0.406]) * 255.0
+    scale = 1 / 255.0
+    std = [0.229, 0.224, 0.225]
+
+    # prepare input blob to fit the model input:
+    # 1. subtract mean
+    # 2. scale to set pixel values from 0 to 1
+    input_blob = cv2.dnn.blobFromImage(
+        image=input_img,
+        scalefactor=scale,
+        size=(224, 224),  # img target size
+        mean=mean,
+        swapRB=True,  # BGR -> RGB
+        crop=True  # center crop
+    )
+    # 3. divide by std
+    input_blob[0] /= np.asarray(std, dtype=np.float32).reshape(3, 1, 1)
+    return input_blob
+
+
+def get_imagenet_labels(labels_path):
+    with open(labels_path) as f:
+        imagenet_labels = [line.strip() for line in f.readlines()]
+    return imagenet_labels
+
+
+def get_opencv_dnn_prediction(opencv_net, preproc_img, imagenet_labels):
+    # set OpenCV DNN input
+    opencv_net.setInput(preproc_img)
+
+    # OpenCV DNN inference
+    out = opencv_net.forward()
+    print("OpenCV DNN prediction: \n")
+    print("* shape: ", out.shape)
+
+    # get the predicted class ID
+    imagenet_class_id = np.argmax(out)
+
+    # get confidence
+    confidence = out[0][imagenet_class_id]
+    print("* class ID: {}, label: {}".format(imagenet_class_id, imagenet_labels[imagenet_class_id]))
+    print("* confidence: {:.4f}".format(confidence))
+
+
+def get_pytorch_dnn_prediction(original_net, preproc_img, imagenet_labels):
+    original_net.eval()
+    preproc_img = torch.FloatTensor(preproc_img)
+
+    # inference
+    with torch.no_grad():
+        out = original_net(preproc_img)
+
+    print("\nPyTorch model prediction: \n")
+    print("* shape: ", out.shape)
+
+    # get the predicted class ID
+    imagenet_class_id = torch.argmax(out, axis=1).item()
+    print("* class ID: {}, label: {}".format(imagenet_class_id, imagenet_labels[imagenet_class_id]))
+
+    # get confidence
+    confidence = out[0][imagenet_class_id]
+    print("* confidence: {:.4f}".format(confidence.item()))
+
+
+def main():
+    # initialize PyTorch ResNet-50 model
+    original_model = models.resnet50(pretrained=True)
+
+    # get the path to the converted into ONNX PyTorch model
+    full_model_path = get_pytorch_onnx_model(original_model)
+
+    # read converted .onnx model with OpenCV API
+    opencv_net = cv2.dnn.readNetFromONNX(full_model_path)
+    print("OpenCV model was successfully read. Layer IDs: \n", opencv_net.getLayerNames())
+
+    # get preprocessed image
+    input_img = get_preprocessed_img("../data/squirrel_cls.jpg")
+
+    # get ImageNet labels
+    imagenet_labels = get_imagenet_labels("../data/dnn/classification_classes_ILSVRC2012.txt")
+
+    # obtain OpenCV DNN predictions
+    get_opencv_dnn_prediction(opencv_net, input_img, imagenet_labels)
+
+    # obtain original PyTorch ResNet50 predictions
+    get_pytorch_dnn_prediction(original_model, input_img, imagenet_labels)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/classification/py_to_py_resnet50_onnx.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/classification/py_to_py_resnet50_onnx.py
new file mode 100644
index 00000000..969c3599
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/classification/py_to_py_resnet50_onnx.py
@@ -0,0 +1,50 @@
+import os
+
+import torch
+import torch.onnx
+from torch.autograd import Variable
+from torchvision import models
+
+
+def get_pytorch_onnx_model(original_model):
+    # define the directory for further converted model save
+    onnx_model_path = "models"
+    # define the name of further converted model
+    onnx_model_name = "resnet50.onnx"
+
+    # create directory for further converted model
+    os.makedirs(onnx_model_path, exist_ok=True)
+
+    # get full path to the converted model
+    full_model_path = os.path.join(onnx_model_path, onnx_model_name)
+
+    # generate model input
+    generated_input = Variable(
+        torch.randn(1, 3, 224, 224)
+    )
+
+    # model export into ONNX format
+    torch.onnx.export(
+        original_model,
+        generated_input,
+        full_model_path,
+        verbose=True,
+        input_names=["input"],
+        output_names=["output"],
+        opset_version=11
+    )
+
+    return full_model_path
+
+
+def main():
+    # initialize PyTorch ResNet-50 model
+    original_model = models.resnet50(pretrained=True)
+
+    # get the path to the converted into ONNX PyTorch model
+    full_model_path = get_pytorch_onnx_model(original_model)
+    print("PyTorch ResNet-50 model was successfully converted: ", full_model_path)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/pytorch_model.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/pytorch_model.py
new file mode 100644
index 00000000..cb32004c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/pytorch/pytorch_model.py
@@ -0,0 +1,98 @@
+import os
+
+import cv2
+import torch.onnx
+from torch.autograd import Variable
+
+from ..common.abstract_model import AbstractModel, Framework
+from ..common.utils import DNN_LIB, get_full_model_path
+
+CURRENT_LIB = "PyTorch"
+MODEL_FORMAT = ".onnx"
+
+
+class PyTorchModelPreparer(AbstractModel):
+
+    def __init__(
+            self,
+            height,
+            width,
+            model_name="default",
+            original_model=object,
+            batch_size=1,
+            default_input_name="input",
+            default_output_name="output"
+    ):
+        self._height = height
+        self._width = width
+        self._model_name = model_name
+        self._original_model = original_model
+        self._batch_size = batch_size
+        self._default_input_name = default_input_name
+        self._default_output_name = default_output_name
+
+        self.model_path = self._set_model_path()
+        self._dnn_model = self._set_dnn_model()
+
+    def _set_dnn_model(self):
+        generated_input = Variable(torch.randn(
+            self._batch_size, 3, self._height, self._width)
+        )
+        os.makedirs(self.model_path["path"], exist_ok=True)
+        torch.onnx.export(
+            self._original_model,
+            generated_input,
+            self.model_path["full_path"],
+            verbose=True,
+            input_names=[self._default_input_name],
+            output_names=[self._default_output_name],
+            opset_version=11
+        )
+
+        return cv2.dnn.readNetFromONNX(self.model_path["full_path"])
+
+    def _set_model_path(self):
+        model_to_save = self._model_name + MODEL_FORMAT
+        return get_full_model_path(CURRENT_LIB.lower(), model_to_save)
+
+    def get_prepared_models(self):
+        return {
+            CURRENT_LIB + " " + self._model_name: self._original_model,
+            DNN_LIB + " " + self._model_name: self._dnn_model
+        }
+
+
+class PyTorchModelProcessor(Framework):
+    def __init__(self, prepared_model, model_name):
+        self._prepared_model = prepared_model
+        self._name = model_name
+
+    def get_output(self, input_blob):
+        tensor = torch.FloatTensor(input_blob)
+        self._prepared_model.eval()
+
+        with torch.no_grad():
+            model_out = self._prepared_model(tensor)
+
+        # segmentation case
+        if len(model_out) == 2:
+            model_out = model_out['out']
+
+        out = model_out.detach().numpy()
+        return out
+
+    def get_name(self):
+        return self._name
+
+
+class PyTorchDnnModelProcessor(Framework):
+    def __init__(self, prepared_dnn_model, model_name):
+        self._prepared_dnn_model = prepared_dnn_model
+        self._name = model_name
+
+    def get_output(self, input_blob):
+        self._prepared_dnn_model.setInput(input_blob, '')
+        return self._prepared_dnn_model.forward()
+
+    def get_name(self):
+        return self._name
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/requirements.txt b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/requirements.txt
new file mode 100644
index 00000000..6887c2ab
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/requirements.txt
@@ -0,0 +1,15 @@
+# Python 3.7.5
+onnx>=1.7.0
+numpy>=1.19.1
+
+torch>=1.5.1
+torchvision>=0.6.1
+
+tensorflow>=2.1.0
+tensorflow-gpu>=2.1.0
+
+paddlepaddle>=2.0.0
+paddlepaddle-gpu>=2.0.0
+paddlehub>=2.1.0
+paddle2onnx>=0.5.1
+paddleseg>=2.0.0
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/classification/py_to_py_cls.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/classification/py_to_py_cls.py
new file mode 100644
index 00000000..0eabe876
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/classification/py_to_py_cls.py
@@ -0,0 +1,104 @@
+from tensorflow.keras.applications import (
+    VGG16, vgg16,
+    VGG19, vgg19,
+
+    ResNet50, resnet,
+    ResNet101,
+    ResNet152,
+
+    DenseNet121, densenet,
+    DenseNet169,
+    DenseNet201,
+
+    InceptionResNetV2, inception_resnet_v2,
+    InceptionV3, inception_v3,
+
+    MobileNet, mobilenet,
+    MobileNetV2, mobilenet_v2,
+
+    NASNetLarge, nasnet,
+    NASNetMobile,
+
+    Xception, xception
+)
+
+from ..tf_model import TFModelPreparer
+from ..tf_model import (
+    TFModelProcessor,
+    TFDnnModelProcessor
+)
+from ...common.evaluation.classification.cls_data_fetcher import TFPreprocessedFetch
+from ...common.test.cls_model_test_pipeline import ClsModelTestPipeline
+from ...common.test.configs.default_preprocess_config import (
+    tf_input_blob,
+    pytorch_input_blob,
+    tf_model_blob_caffe_mode
+)
+from ...common.utils import set_tf_env, create_extended_parser
+
+model_dict = {
+    "vgg16": [VGG16, vgg16, tf_model_blob_caffe_mode],
+    "vgg19": [VGG19, vgg19, tf_model_blob_caffe_mode],
+
+    "resnet50": [ResNet50, resnet, tf_model_blob_caffe_mode],
+    "resnet101": [ResNet101, resnet, tf_model_blob_caffe_mode],
+    "resnet152": [ResNet152, resnet, tf_model_blob_caffe_mode],
+
+    "densenet121": [DenseNet121, densenet, pytorch_input_blob],
+    "densenet169": [DenseNet169, densenet, pytorch_input_blob],
+    "densenet201": [DenseNet201, densenet, pytorch_input_blob],
+
+    "inceptionresnetv2": [InceptionResNetV2, inception_resnet_v2, tf_input_blob],
+    "inceptionv3": [InceptionV3, inception_v3, tf_input_blob],
+
+    "mobilenet": [MobileNet, mobilenet, tf_input_blob],
+    "mobilenetv2": [MobileNetV2, mobilenet_v2, tf_input_blob],
+
+    "nasnetlarge": [NASNetLarge, nasnet, tf_input_blob],
+    "nasnetmobile": [NASNetMobile, nasnet, tf_input_blob],
+
+    "xception": [Xception, xception, tf_input_blob]
+}
+
+CNN_CLASS_ID = 0
+CNN_UTILS_ID = 1
+DEFAULT_BLOB_PARAMS_ID = 2
+
+
+class TFClsModel(TFModelPreparer):
+    def __init__(self, model_name, original_model):
+        super(TFClsModel, self).__init__(model_name, original_model)
+
+
+def main():
+    set_tf_env()
+
+    parser = create_extended_parser(list(model_dict.keys()))
+    cmd_args = parser.parse_args()
+
+    model_name = cmd_args.model_name
+    model_name_val = model_dict[model_name]
+
+    cls_model = TFClsModel(
+        model_name=model_name,
+        original_model=model_name_val[CNN_CLASS_ID](
+            include_top=True,
+            weights="imagenet"
+        )
+    )
+
+    tf_cls_pipeline = ClsModelTestPipeline(
+        network_model=cls_model,
+        model_processor=TFModelProcessor,
+        dnn_model_processor=TFDnnModelProcessor,
+        data_fetcher=TFPreprocessedFetch,
+        img_processor=model_name_val[CNN_UTILS_ID].preprocess_input,
+        cls_args_parser=parser,
+        default_input_blob_preproc=model_name_val[DEFAULT_BLOB_PARAMS_ID]
+    )
+
+    tf_cls_pipeline.init_test_pipeline()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/classification/py_to_py_mobilenet.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/classification/py_to_py_mobilenet.py
new file mode 100644
index 00000000..ebc6cfe5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/classification/py_to_py_mobilenet.py
@@ -0,0 +1,142 @@
+import os
+
+import cv2
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.applications import MobileNet
+from tensorflow.python.framework.convert_to_constants import convert_variables_to_constants_v2
+
+from ...common.utils import set_tf_env
+
+
+def get_tf_model_proto(tf_model):
+    # define the directory for .pb model
+    pb_model_path = "models"
+
+    # define the name of .pb model
+    pb_model_name = "mobilenet.pb"
+
+    # create directory for further converted model
+    os.makedirs(pb_model_path, exist_ok=True)
+
+    # get model TF graph
+    tf_model_graph = tf.function(lambda x: tf_model(x))
+
+    # get concrete function
+    tf_model_graph = tf_model_graph.get_concrete_function(
+        tf.TensorSpec(tf_model.inputs[0].shape, tf_model.inputs[0].dtype))
+
+    # obtain frozen concrete function
+    frozen_tf_func = convert_variables_to_constants_v2(tf_model_graph)
+    # get frozen graph
+    frozen_tf_func.graph.as_graph_def()
+
+    # save full tf model
+    tf.io.write_graph(graph_or_graph_def=frozen_tf_func.graph,
+                      logdir=pb_model_path,
+                      name=pb_model_name,
+                      as_text=False)
+
+    return os.path.join(pb_model_path, pb_model_name)
+
+
+def get_preprocessed_img(img_path):
+    # read the image
+    input_img = cv2.imread(img_path, cv2.IMREAD_COLOR)
+    input_img = input_img.astype(np.float32)
+
+    # define preprocess parameters
+    mean = np.array([1.0, 1.0, 1.0]) * 127.5
+    scale = 1 / 127.5
+
+    # prepare input blob to fit the model input:
+    # 1. subtract mean
+    # 2. scale to set pixel values from 0 to 1
+    input_blob = cv2.dnn.blobFromImage(
+        image=input_img,
+        scalefactor=scale,
+        size=(224, 224),  # img target size
+        mean=mean,
+        swapRB=True,  # BGR -> RGB
+        crop=True  # center crop
+    )
+    print("Input blob shape: {}\n".format(input_blob.shape))
+
+    return input_blob
+
+
+def get_imagenet_labels(labels_path):
+    with open(labels_path) as f:
+        imagenet_labels = [line.strip() for line in f.readlines()]
+    return imagenet_labels
+
+
+def get_opencv_dnn_prediction(opencv_net, preproc_img, imagenet_labels):
+    # set OpenCV DNN input
+    opencv_net.setInput(preproc_img)
+
+    # OpenCV DNN inference
+    out = opencv_net.forward()
+    print("OpenCV DNN prediction: \n")
+    print("* shape: ", out.shape)
+
+    # get the predicted class ID
+    imagenet_class_id = np.argmax(out)
+
+    # get confidence
+    confidence = out[0][imagenet_class_id]
+    print("* class ID: {}, label: {}".format(imagenet_class_id, imagenet_labels[imagenet_class_id]))
+    print("* confidence: {:.4f}\n".format(confidence))
+
+
+def get_tf_dnn_prediction(original_net, preproc_img, imagenet_labels):
+    # inference
+    preproc_img = preproc_img.transpose(0, 2, 3, 1)
+    print("TF input blob shape: {}\n".format(preproc_img.shape))
+
+    out = original_net(preproc_img)
+
+    print("\nTensorFlow model prediction: \n")
+    print("* shape: ", out.shape)
+
+    # get the predicted class ID
+    imagenet_class_id = np.argmax(out)
+    print("* class ID: {}, label: {}".format(imagenet_class_id, imagenet_labels[imagenet_class_id]))
+
+    # get confidence
+    confidence = out[0][imagenet_class_id]
+    print("* confidence: {:.4f}".format(confidence))
+
+
+def main():
+    # configure TF launching
+    set_tf_env()
+
+    # initialize TF MobileNet model
+    original_tf_model = MobileNet(
+        include_top=True,
+        weights="imagenet"
+    )
+
+    # get TF frozen graph path
+    full_pb_path = get_tf_model_proto(original_tf_model)
+
+    # read frozen graph with OpenCV API
+    opencv_net = cv2.dnn.readNetFromTensorflow(full_pb_path)
+    print("OpenCV model was successfully read. Model layers: \n", opencv_net.getLayerNames())
+
+    # get preprocessed image
+    input_img = get_preprocessed_img("../data/squirrel_cls.jpg")
+
+    # get ImageNet labels
+    imagenet_labels = get_imagenet_labels("../data/dnn/classification_classes_ILSVRC2012.txt")
+
+    # obtain OpenCV DNN predictions
+    get_opencv_dnn_prediction(opencv_net, input_img, imagenet_labels)
+
+    # obtain TF model predictions
+    get_tf_dnn_prediction(original_tf_model, input_img, imagenet_labels)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/detection/py_to_py_ssd_mobilenet.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/detection/py_to_py_ssd_mobilenet.py
new file mode 100644
index 00000000..2468d151
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/detection/py_to_py_ssd_mobilenet.py
@@ -0,0 +1,45 @@
+import os
+import tarfile
+import urllib
+
+DETECTION_MODELS_URL = 'http://download.tensorflow.org/models/object_detection/'
+
+
+def extract_tf_frozen_graph(model_name, extracted_model_path):
+    # define model archive name
+    tf_model_tar = model_name + '.tar.gz'
+    # define link to retrieve model archive
+    model_link = DETECTION_MODELS_URL + tf_model_tar
+
+    tf_frozen_graph_name = 'frozen_inference_graph'
+
+    try:
+        urllib.request.urlretrieve(model_link, tf_model_tar)
+    except Exception:
+        print("TF {} was not retrieved: {}".format(model_name, model_link))
+        return
+
+    print("TF {} was retrieved.".format(model_name))
+
+    tf_model_tar = tarfile.open(tf_model_tar)
+    frozen_graph_path = ""
+
+    for model_tar_elem in tf_model_tar.getmembers():
+        if tf_frozen_graph_name in os.path.basename(model_tar_elem.name):
+            tf_model_tar.extract(model_tar_elem, extracted_model_path)
+            frozen_graph_path = os.path.join(extracted_model_path, model_tar_elem.name)
+            break
+    tf_model_tar.close()
+
+    return frozen_graph_path
+
+
+def main():
+    tf_model_name = 'ssd_mobilenet_v1_coco_2017_11_17'
+    graph_extraction_dir = "./"
+    frozen_graph_path = extract_tf_frozen_graph(tf_model_name, graph_extraction_dir)
+    print("Frozen graph path for {}: {}".format(tf_model_name, frozen_graph_path))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/tf_model.py b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/tf_model.py
new file mode 100644
index 00000000..2411821e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/dnn_model_runner/dnn_conversion/tf/tf_model.py
@@ -0,0 +1,112 @@
+import cv2
+import tensorflow as tf
+from tensorflow.python.framework.convert_to_constants import convert_variables_to_constants_v2
+
+from ..common.abstract_model import AbstractModel, Framework
+from ..common.utils import DNN_LIB, get_full_model_path
+
+CURRENT_LIB = "TF"
+MODEL_FORMAT = ".pb"
+
+
+class TFModelPreparer(AbstractModel):
+    """ Class for the preparation of the TF models: original and converted OpenCV Net.
+
+    Args:
+        model_name: TF model name
+        original_model: TF configured model object or session
+        is_ready_graph: indicates whether ready .pb file already exists
+        tf_model_graph_path: path to the existing frozen TF graph
+    """
+
+    def __init__(
+            self,
+            model_name="default",
+            original_model=None,
+            is_ready_graph=False,
+            tf_model_graph_path=""
+    ):
+        self._model_name = model_name
+        self._original_model = original_model
+        self._model_to_save = ""
+
+        self._is_ready_to_transfer_graph = is_ready_graph
+        self.model_path = self._set_model_path(tf_model_graph_path)
+        self._dnn_model = self._set_dnn_model()
+
+    def _set_dnn_model(self):
+        if not self._is_ready_to_transfer_graph:
+            # get model TF graph
+            tf_model_graph = tf.function(lambda x: self._original_model(x))
+
+            tf_model_graph = tf_model_graph.get_concrete_function(
+                tf.TensorSpec(self._original_model.inputs[0].shape, self._original_model.inputs[0].dtype))
+
+            # obtain frozen concrete function
+            frozen_tf_func = convert_variables_to_constants_v2(tf_model_graph)
+            frozen_tf_func.graph.as_graph_def()
+
+            # save full TF model
+            tf.io.write_graph(graph_or_graph_def=frozen_tf_func.graph,
+                              logdir=self.model_path["path"],
+                              name=self._model_to_save,
+                              as_text=False)
+
+        return cv2.dnn.readNetFromTensorflow(self.model_path["full_path"])
+
+    def _set_model_path(self, tf_pb_file_path):
+        """ Method for setting model paths.
+
+        Args:
+            tf_pb_file_path: path to the existing TF .pb
+
+        Returns:
+            dictionary, where full_path key means saved model path and its full name.
+        """
+        model_paths_dict = {
+            "path": "",
+            "full_path": tf_pb_file_path
+        }
+
+        if not self._is_ready_to_transfer_graph:
+            self._model_to_save = self._model_name + MODEL_FORMAT
+            model_paths_dict = get_full_model_path(CURRENT_LIB.lower(), self._model_to_save)
+
+        return model_paths_dict
+
+    def get_prepared_models(self):
+        original_lib_name = CURRENT_LIB + " " + self._model_name
+        configured_model_dict = {
+            original_lib_name: self._original_model,
+            DNN_LIB + " " + self._model_name: self._dnn_model
+        }
+        return configured_model_dict
+
+
+class TFModelProcessor(Framework):
+    def __init__(self, prepared_model, model_name):
+        self._prepared_model = prepared_model
+        self._name = model_name
+
+    def get_output(self, input_blob):
+        assert len(input_blob.shape) == 4
+        batch_tf = input_blob.transpose(0, 2, 3, 1)
+        out = self._prepared_model(batch_tf)
+        return out
+
+    def get_name(self):
+        return CURRENT_LIB
+
+
+class TFDnnModelProcessor(Framework):
+    def __init__(self, prepared_dnn_model, model_name):
+        self._prepared_dnn_model = prepared_dnn_model
+        self._name = model_name
+
+    def get_output(self, input_blob):
+        self._prepared_dnn_model.setInput(input_blob)
+        ret_val = self._prepared_dnn_model.forward()
+        return ret_val
+
+    def get_name(self):
+        return DNN_LIB
diff --git a/C++/opencv-4.7.0/samples/dnn/download_models.py b/C++/opencv-4.7.0/samples/dnn/download_models.py
new file mode 100644
index 00000000..4d947651
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/download_models.py
@@ -0,0 +1,364 @@
+'''
+Helper module to download extra data from Internet
+'''
+from __future__ import print_function
+import os
+import cv2
+import sys
+import yaml
+import argparse
+import tarfile
+import platform
+import tempfile
+import hashlib
+import requests
+import shutil
+from pathlib import Path
+from datetime import datetime
+if sys.version_info[0] < 3:
+    from urllib2 import urlopen
+else:
+    from urllib.request import urlopen
+import xml.etree.ElementTree as ET
+
+__all__ = ["downloadFile"]
+
+class HashMismatchException(Exception):
+    def __init__(self, expected, actual):
+        Exception.__init__(self)
+        self.expected = expected
+        self.actual = actual
+    def __str__(self):
+        return 'Hash mismatch: expected {} vs actual of {}'.format(self.expected, self.actual)
+
+def getHashsumFromFile(filepath):
+    sha = hashlib.sha1()
+    if os.path.exists(filepath):
+        print('  there is already a file with the same name')
+        with open(filepath, 'rb') as f:
+            while True:
+                buf = f.read(10*1024*1024)
+                if not buf:
+                    break
+                sha.update(buf)
+    hashsum = sha.hexdigest()
+    return hashsum
+
+def checkHashsum(expected_sha, filepath, silent=True):
+    print('  expected SHA1: {}'.format(expected_sha))
+    actual_sha = getHashsumFromFile(filepath)
+    print('  actual SHA1:{}'.format(actual_sha))
+    hashes_matched = expected_sha == actual_sha
+    if not hashes_matched and not silent:
+        raise HashMismatchException(expected_sha, actual_sha)
+    return hashes_matched
+
+def isArchive(filepath):
+    return tarfile.is_tarfile(filepath)
+
+class DownloadInstance:
+    def __init__(self, **kwargs):
+        self.name = kwargs.pop('name')
+        self.filename = kwargs.pop('filename')
+        self.loader = kwargs.pop('loader', None)
+        self.save_dir = kwargs.pop('save_dir')
+        self.sha = kwargs.pop('sha', None)
+
+    def __str__(self):
+        return 'DownloadInstance <{}>'.format(self.name)
+
+    def get(self):
+        print("  Working on " + self.name)
+        print("  Getting file " + self.filename)
+        if self.sha is None:
+            print('  No expected hashsum provided, loading file')
+        else:
+            filepath = os.path.join(self.save_dir, self.sha, self.filename)
+            if checkHashsum(self.sha, filepath):
+                print('  hash match - file already exists, skipping')
+                return filepath
+            else:
+                print('  hash didn\'t match, loading file')
+
+        if not os.path.exists(self.save_dir):
+            print('  creating directory: ' + self.save_dir)
+            os.makedirs(self.save_dir)
+
+
+        print('  hash check failed - loading')
+        assert self.loader
+        try:
+            self.loader.load(self.filename, self.sha, self.save_dir)
+            print(' done')
+            print(' file {}'.format(self.filename))
+            if self.sha is None:
+                download_path = os.path.join(self.save_dir, self.filename)
+                self.sha = getHashsumFromFile(download_path)
+                new_dir = os.path.join(self.save_dir, self.sha)
+
+                if not os.path.exists(new_dir):
+                    os.makedirs(new_dir)
+                filepath = os.path.join(new_dir, self.filename)
+                if not (os.path.exists(filepath)):
+                    shutil.move(download_path, new_dir)
+                print('  No expected hashsum provided, actual SHA is {}'.format(self.sha))
+            else:
+                checkHashsum(self.sha, filepath, silent=False)
+        except Exception as e:
+            print("  There was some problem with loading file {} for {}".format(self.filename, self.name))
+            print("  Exception: {}".format(e))
+            return
+
+        print("  Finished " + self.name)
+        return filepath
+
+class Loader(object):
+    MB = 1024*1024
+    BUFSIZE = 10*MB
+    def __init__(self, download_name, download_sha, archive_member = None):
+        self.download_name = download_name
+        self.download_sha = download_sha
+        self.archive_member = archive_member
+
+    def load(self, requested_file, sha, save_dir):
+        if self.download_sha is None:
+            download_dir = save_dir
+        else:
+            # create a new folder in save_dir to avoid possible name conflicts
+            download_dir = os.path.join(save_dir, self.download_sha)
+        if not os.path.exists(download_dir):
+            os.makedirs(download_dir)
+        download_path = os.path.join(download_dir, self.download_name)
+        print("  Preparing to download file " + self.download_name)
+        if checkHashsum(self.download_sha, download_path):
+            print('  hash match - file already exists, no need to download')
+        else:
+            filesize = self.download(download_path)
+            print('  Downloaded {} with size {} Mb'.format(self.download_name, filesize/self.MB))
+            if self.download_sha is not None:
+                checkHashsum(self.download_sha, download_path, silent=False)
+        if self.download_name == requested_file:
+            return
+        else:
+            if isArchive(download_path):
+                if sha is not None:
+                    extract_dir = os.path.join(save_dir, sha)
+                else:
+                    extract_dir = save_dir
+                if not os.path.exists(extract_dir):
+                    os.makedirs(extract_dir)
+                self.extract(requested_file, download_path, extract_dir)
+            else:
+                raise Exception("Downloaded file has different name")
+
+    def download(self, filepath):
+        print("Warning: download is not implemented, this is a base class")
+        return 0
+
+    def extract(self, requested_file, archive_path, save_dir):
+        filepath = os.path.join(save_dir, requested_file)
+        try:
+            with tarfile.open(archive_path) as f:
+                if self.archive_member is None:
+                    pathDict = dict((os.path.split(elem)[1], os.path.split(elem)[0]) for elem in f.getnames())
+                    self.archive_member = pathDict[requested_file]
+                assert self.archive_member in f.getnames()
+                self.save(filepath, f.extractfile(self.archive_member))
+        except Exception as e:
+            print('  catch {}'.format(e))
+
+    def save(self, filepath, r):
+        with open(filepath, 'wb') as f:
+            print('  progress ', end="")
+            sys.stdout.flush()
+            while True:
+                buf = r.read(self.BUFSIZE)
+                if not buf:
+                    break
+                f.write(buf)
+                print('>', end="")
+                sys.stdout.flush()
+
+class URLLoader(Loader):
+    def __init__(self, download_name, download_sha, url, archive_member = None):
+        super(URLLoader, self).__init__(download_name, download_sha, archive_member)
+        self.download_name = download_name
+        self.download_sha = download_sha
+        self.url = url
+
+    def download(self, filepath):
+        r = urlopen(self.url, timeout=60)
+        self.printRequest(r)
+        self.save(filepath, r)
+        return os.path.getsize(filepath)
+
+    def printRequest(self, r):
+        def getMB(r):
+            d = dict(r.info())
+            for c in ['content-length', 'Content-Length']:
+                if c in d:
+                    return int(d[c]) / self.MB
+            return '<unknown>'
+        print('  {} {} [{} Mb]'.format(r.getcode(), r.msg, getMB(r)))
+
+class GDriveLoader(Loader):
+    BUFSIZE = 1024 * 1024
+    PROGRESS_SIZE = 10 * 1024 * 1024
+    def __init__(self, download_name, download_sha, gid, archive_member = None):
+        super(GDriveLoader, self).__init__(download_name, download_sha, archive_member)
+        self.download_name = download_name
+        self.download_sha = download_sha
+        self.gid = gid
+
+    def download(self, filepath):
+        session = requests.Session()  # re-use cookies
+
+        URL = "https://docs.google.com/uc?export=download"
+        response = session.get(URL, params = { 'id' : self.gid }, stream = True)
+
+        def get_confirm_token(response):  # in case of large files
+            for key, value in response.cookies.items():
+                if key.startswith('download_warning'):
+                    return value
+            return None
+        token = get_confirm_token(response)
+
+        if token:
+            params = { 'id' : self.gid, 'confirm' : token }
+            response = session.get(URL, params = params, stream = True)
+
+        sz = 0
+        progress_sz = self.PROGRESS_SIZE
+        with open(filepath, "wb") as f:
+            for chunk in response.iter_content(self.BUFSIZE):
+                if not chunk:
+                    continue  # keep-alive
+
+                f.write(chunk)
+                sz += len(chunk)
+                if sz >= progress_sz:
+                    progress_sz += self.PROGRESS_SIZE
+                    print('>', end='')
+                    sys.stdout.flush()
+        print('')
+        return sz
+
+def produceDownloadInstance(instance_name, filename, sha, url, save_dir, download_name=None, download_sha=None, archive_member=None):
+    spec_param = url
+    loader = URLLoader
+    if download_name is None:
+        download_name = filename
+    if download_sha is None:
+        download_sha = sha
+    if "drive.google.com" in url:
+        token = ""
+        token_part = url.rsplit('/', 1)[-1]
+        if "&id=" not in token_part:
+            token_part = url.rsplit('/', 1)[-2]
+        for param in token_part.split("&"):
+            if param.startswith("id="):
+                token = param[3:]
+        if token:
+            loader = GDriveLoader
+            spec_param = token
+        else:
+            print("Warning: possibly wrong Google Drive link")
+    return DownloadInstance(
+        name=instance_name,
+        filename=filename,
+        sha=sha,
+        save_dir=save_dir,
+        loader=loader(download_name, download_sha, spec_param, archive_member)
+    )
+
+def getSaveDir():
+    env_path = os.environ.get("OPENCV_DOWNLOAD_DATA_PATH", None)
+    if env_path:
+        save_dir = env_path
+    else:
+        # TODO reuse binding function cv2.utils.fs.getCacheDirectory when issue #19011 is fixed
+        if platform.system() == "Darwin":
+            #On Apple devices
+            temp_env = os.environ.get("TMPDIR", None)
+            if temp_env is None or not os.path.isdir(temp_env):
+                temp_dir = Path("/tmp")
+                print("Using world accessible cache directory. This may be not secure: ", temp_dir)
+            else:
+                temp_dir = temp_env
+        elif platform.system() == "Windows":
+            temp_dir = tempfile.gettempdir()
+        else:
+            xdg_cache_env = os.environ.get("XDG_CACHE_HOME", None)
+            if (xdg_cache_env and xdg_cache_env[0] and os.path.isdir(xdg_cache_env)):
+                temp_dir = xdg_cache_env
+            else:
+                home_env = os.environ.get("HOME", None)
+                if (home_env and home_env[0] and os.path.isdir(home_env)):
+                    home_path = os.path.join(home_env, ".cache/")
+                    if os.path.isdir(home_path):
+                        temp_dir = home_path
+                else:
+                    temp_dir = tempfile.gettempdir()
+                    print("Using world accessible cache directory. This may be not secure: ", temp_dir)
+
+        save_dir = os.path.join(temp_dir, "downloads")
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    return save_dir
+
+def downloadFile(url, sha=None, save_dir=None, filename=None):
+    if save_dir is None:
+        save_dir = getSaveDir()
+    if filename is None:
+        filename = "download_" + datetime.now().__str__()
+    name = filename
+    return produceDownloadInstance(name, filename, sha, url, save_dir).get()
+
+def parseMetalinkFile(metalink_filepath, save_dir):
+    NS = {'ml': 'urn:ietf:params:xml:ns:metalink'}
+    models = []
+    for file_elem in ET.parse(metalink_filepath).getroot().findall('ml:file', NS):
+        url = file_elem.find('ml:url', NS).text
+        fname = file_elem.attrib['name']
+        name = file_elem.find('ml:identity', NS).text
+        hash_sum = file_elem.find('ml:hash', NS).text
+        models.append(produceDownloadInstance(name, fname, hash_sum, url, save_dir))
+    return models
+
+def parseYAMLFile(yaml_filepath, save_dir):
+    models = []
+    with open(yaml_filepath, 'r') as stream:
+        data_loaded = yaml.safe_load(stream)
+        for name, params in data_loaded.items():
+            load_info = params.get("load_info", None)
+            if load_info:
+                fname = os.path.basename(params.get("model"))
+                hash_sum = load_info.get("sha1")
+                url = load_info.get("url")
+                download_sha = load_info.get("download_sha")
+                download_name = load_info.get("download_name")
+                archive_member = load_info.get("member")
+                models.append(produceDownloadInstance(name, fname, hash_sum, url, save_dir,
+                    download_name=download_name, download_sha=download_sha, archive_member=archive_member))
+
+    return models
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='This is a utility script for downloading DNN models for samples.')
+
+    parser.add_argument('--save_dir', action="store", default=os.getcwd(),
+                        help='Path to the directory to store downloaded files')
+    parser.add_argument('model_name', type=str, default="", nargs='?', action="store",
+                        help='name of the model to download')
+    args = parser.parse_args()
+    models = []
+    save_dir = args.save_dir
+    selected_model_name = args.model_name
+    models.extend(parseMetalinkFile('face_detector/weights.meta4', save_dir))
+    models.extend(parseYAMLFile('models.yml', save_dir))
+    for m in models:
+        print(m)
+        if selected_model_name and not m.name.startswith(selected_model_name):
+            continue
+        print('Model: ' + selected_model_name)
+        m.get()
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/dnn/edge_detection.py b/C++/opencv-4.7.0/samples/dnn/edge_detection.py
new file mode 100644
index 00000000..e3eeff2e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/edge_detection.py
@@ -0,0 +1,69 @@
+import cv2 as cv
+import argparse
+
+parser = argparse.ArgumentParser(
+        description='This sample shows how to define custom OpenCV deep learning layers in Python. '
+                    'Holistically-Nested Edge Detection (https://arxiv.org/abs/1504.06375) neural network '
+                    'is used as an example model. Find a pre-trained model at https://github.com/s9xie/hed.')
+parser.add_argument('--input', help='Path to image or video. Skip to capture frames from camera')
+parser.add_argument('--prototxt', help='Path to deploy.prototxt', required=True)
+parser.add_argument('--caffemodel', help='Path to hed_pretrained_bsds.caffemodel', required=True)
+parser.add_argument('--width', help='Resize input image to a specific width', default=500, type=int)
+parser.add_argument('--height', help='Resize input image to a specific height', default=500, type=int)
+args = parser.parse_args()
+
+#! [CropLayer]
+class CropLayer(object):
+    def __init__(self, params, blobs):
+        self.xstart = 0
+        self.xend = 0
+        self.ystart = 0
+        self.yend = 0
+
+    # Our layer receives two inputs. We need to crop the first input blob
+    # to match a shape of the second one (keeping batch size and number of channels)
+    def getMemoryShapes(self, inputs):
+        inputShape, targetShape = inputs[0], inputs[1]
+        batchSize, numChannels = inputShape[0], inputShape[1]
+        height, width = targetShape[2], targetShape[3]
+
+        self.ystart = (inputShape[2] - targetShape[2]) // 2
+        self.xstart = (inputShape[3] - targetShape[3]) // 2
+        self.yend = self.ystart + height
+        self.xend = self.xstart + width
+
+        return [[batchSize, numChannels, height, width]]
+
+    def forward(self, inputs):
+        return [inputs[0][:,:,self.ystart:self.yend,self.xstart:self.xend]]
+#! [CropLayer]
+
+#! [Register]
+cv.dnn_registerLayer('Crop', CropLayer)
+#! [Register]
+
+# Load the model.
+net = cv.dnn.readNet(cv.samples.findFile(args.prototxt), cv.samples.findFile(args.caffemodel))
+
+kWinName = 'Holistically-Nested Edge Detection'
+cv.namedWindow('Input', cv.WINDOW_NORMAL)
+cv.namedWindow(kWinName, cv.WINDOW_NORMAL)
+
+cap = cv.VideoCapture(args.input if args.input else 0)
+while cv.waitKey(1) < 0:
+    hasFrame, frame = cap.read()
+    if not hasFrame:
+        cv.waitKey()
+        break
+
+    cv.imshow('Input', frame)
+
+    inp = cv.dnn.blobFromImage(frame, scalefactor=1.0, size=(args.width, args.height),
+                               mean=(104.00698793, 116.66876762, 122.67891434),
+                               swapRB=False, crop=False)
+    net.setInput(inp)
+
+    out = net.forward()
+    out = out[0, 0]
+    out = cv.resize(out, (frame.shape[1], frame.shape[0]))
+    cv.imshow(kWinName, out)
diff --git a/C++/opencv-4.7.0/samples/dnn/face_detect.cpp b/C++/opencv-4.7.0/samples/dnn/face_detect.cpp
new file mode 100644
index 00000000..d1e63149
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/face_detect.cpp
@@ -0,0 +1,282 @@
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/objdetect.hpp>
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static
+void visualize(Mat& input, int frame, Mat& faces, double fps, int thickness = 2)
+{
+    std::string fpsString = cv::format("FPS : %.2f", (float)fps);
+    if (frame >= 0)
+        cout << "Frame " << frame << ", ";
+    cout << "FPS: " << fpsString << endl;
+    for (int i = 0; i < faces.rows; i++)
+    {
+        // Print results
+        cout << "Face " << i
+             << ", top-left coordinates: (" << faces.at<float>(i, 0) << ", " << faces.at<float>(i, 1) << "), "
+             << "box width: " << faces.at<float>(i, 2)  << ", box height: " << faces.at<float>(i, 3) << ", "
+             << "score: " << cv::format("%.2f", faces.at<float>(i, 14))
+             << endl;
+
+        // Draw bounding box
+        rectangle(input, Rect2i(int(faces.at<float>(i, 0)), int(faces.at<float>(i, 1)), int(faces.at<float>(i, 2)), int(faces.at<float>(i, 3))), Scalar(0, 255, 0), thickness);
+        // Draw landmarks
+        circle(input, Point2i(int(faces.at<float>(i, 4)), int(faces.at<float>(i, 5))), 2, Scalar(255, 0, 0), thickness);
+        circle(input, Point2i(int(faces.at<float>(i, 6)), int(faces.at<float>(i, 7))), 2, Scalar(0, 0, 255), thickness);
+        circle(input, Point2i(int(faces.at<float>(i, 8)), int(faces.at<float>(i, 9))), 2, Scalar(0, 255, 0), thickness);
+        circle(input, Point2i(int(faces.at<float>(i, 10)), int(faces.at<float>(i, 11))), 2, Scalar(255, 0, 255), thickness);
+        circle(input, Point2i(int(faces.at<float>(i, 12)), int(faces.at<float>(i, 13))), 2, Scalar(0, 255, 255), thickness);
+    }
+    putText(input, fpsString, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0), 2);
+}
+
+int main(int argc, char** argv)
+{
+    CommandLineParser parser(argc, argv,
+        "{help  h           |            | Print this message}"
+        "{image1 i1         |            | Path to the input image1. Omit for detecting through VideoCapture}"
+        "{image2 i2         |            | Path to the input image2. When image1 and image2 parameters given then the program try to find a face on both images and runs face recognition algorithm}"
+        "{video v           | 0          | Path to the input video}"
+        "{scale sc          | 1.0        | Scale factor used to resize input video frames}"
+        "{fd_model fd       | face_detection_yunet_2021dec.onnx| Path to the model. Download yunet.onnx in https://github.com/opencv/opencv_zoo/tree/master/models/face_detection_yunet}"
+        "{fr_model fr       | face_recognition_sface_2021dec.onnx | Path to the face recognition model. Download the model at https://github.com/opencv/opencv_zoo/tree/master/models/face_recognition_sface}"
+        "{score_threshold   | 0.9        | Filter out faces of score < score_threshold}"
+        "{nms_threshold     | 0.3        | Suppress bounding boxes of iou >= nms_threshold}"
+        "{top_k             | 5000       | Keep top_k bounding boxes before NMS}"
+        "{save s            | false      | Set true to save results. This flag is invalid when using camera}"
+    );
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    String fd_modelPath = parser.get<String>("fd_model");
+    String fr_modelPath = parser.get<String>("fr_model");
+
+    float scoreThreshold = parser.get<float>("score_threshold");
+    float nmsThreshold = parser.get<float>("nms_threshold");
+    int topK = parser.get<int>("top_k");
+
+    bool save = parser.get<bool>("save");
+    float scale = parser.get<float>("scale");
+
+    double cosine_similar_thresh = 0.363;
+    double l2norm_similar_thresh = 1.128;
+
+    //! [initialize_FaceDetectorYN]
+    // Initialize FaceDetectorYN
+    Ptr<FaceDetectorYN> detector = FaceDetectorYN::create(fd_modelPath, "", Size(320, 320), scoreThreshold, nmsThreshold, topK);
+    //! [initialize_FaceDetectorYN]
+
+    TickMeter tm;
+
+    // If input is an image
+    if (parser.has("image1"))
+    {
+        String input1 = parser.get<String>("image1");
+        Mat image1 = imread(samples::findFile(input1));
+        if (image1.empty())
+        {
+            std::cerr << "Cannot read image: " << input1 << std::endl;
+            return 2;
+        }
+
+        int imageWidth = int(image1.cols * scale);
+        int imageHeight = int(image1.rows * scale);
+        resize(image1, image1, Size(imageWidth, imageHeight));
+        tm.start();
+
+        //! [inference]
+        // Set input size before inference
+        detector->setInputSize(image1.size());
+
+        Mat faces1;
+        detector->detect(image1, faces1);
+        if (faces1.rows < 1)
+        {
+            std::cerr << "Cannot find a face in " << input1 << std::endl;
+            return 1;
+        }
+        //! [inference]
+
+        tm.stop();
+        // Draw results on the input image
+        visualize(image1, -1, faces1, tm.getFPS());
+
+        // Save results if save is true
+        if (save)
+        {
+            cout << "Saving result.jpg...\n";
+            imwrite("result.jpg", image1);
+        }
+
+        // Visualize results
+        imshow("image1", image1);
+        pollKey();  // handle UI events to show content
+
+        if (parser.has("image2"))
+        {
+            String input2 = parser.get<String>("image2");
+            Mat image2 = imread(samples::findFile(input2));
+            if (image2.empty())
+            {
+                std::cerr << "Cannot read image2: " << input2 << std::endl;
+                return 2;
+            }
+
+            tm.reset();
+            tm.start();
+            detector->setInputSize(image2.size());
+
+            Mat faces2;
+            detector->detect(image2, faces2);
+            if (faces2.rows < 1)
+            {
+                std::cerr << "Cannot find a face in " << input2 << std::endl;
+                return 1;
+            }
+            tm.stop();
+            visualize(image2, -1, faces2, tm.getFPS());
+            if (save)
+            {
+                cout << "Saving result2.jpg...\n";
+                imwrite("result2.jpg", image2);
+            }
+            imshow("image2", image2);
+            pollKey();
+
+            //! [initialize_FaceRecognizerSF]
+            // Initialize FaceRecognizerSF
+            Ptr<FaceRecognizerSF> faceRecognizer = FaceRecognizerSF::create(fr_modelPath, "");
+            //! [initialize_FaceRecognizerSF]
+
+
+            //! [facerecognizer]
+            // Aligning and cropping facial image through the first face of faces detected.
+            Mat aligned_face1, aligned_face2;
+            faceRecognizer->alignCrop(image1, faces1.row(0), aligned_face1);
+            faceRecognizer->alignCrop(image2, faces2.row(0), aligned_face2);
+
+            // Run feature extraction with given aligned_face
+            Mat feature1, feature2;
+            faceRecognizer->feature(aligned_face1, feature1);
+            feature1 = feature1.clone();
+            faceRecognizer->feature(aligned_face2, feature2);
+            feature2 = feature2.clone();
+            //! [facerecognizer]
+
+            //! [match]
+            double cos_score = faceRecognizer->match(feature1, feature2, FaceRecognizerSF::DisType::FR_COSINE);
+            double L2_score = faceRecognizer->match(feature1, feature2, FaceRecognizerSF::DisType::FR_NORM_L2);
+            //! [match]
+
+            if (cos_score >= cosine_similar_thresh)
+            {
+                std::cout << "They have the same identity;";
+            }
+            else
+            {
+                std::cout << "They have different identities;";
+            }
+            std::cout << " Cosine Similarity: " << cos_score << ", threshold: " << cosine_similar_thresh << ". (higher value means higher similarity, max 1.0)\n";
+
+            if (L2_score <= l2norm_similar_thresh)
+            {
+                std::cout << "They have the same identity;";
+            }
+            else
+            {
+                std::cout << "They have different identities.";
+            }
+            std::cout << " NormL2 Distance: " << L2_score << ", threshold: " << l2norm_similar_thresh << ". (lower value means higher similarity, min 0.0)\n";
+        }
+        cout << "Press any key to exit..." << endl;
+        waitKey(0);
+    }
+    else
+    {
+        int frameWidth, frameHeight;
+        VideoCapture capture;
+        std::string video = parser.get<string>("video");
+        if (video.size() == 1 && isdigit(video[0]))
+            capture.open(parser.get<int>("video"));
+        else
+            capture.open(samples::findFileOrKeep(video));  // keep GStreamer pipelines
+        if (capture.isOpened())
+        {
+            frameWidth = int(capture.get(CAP_PROP_FRAME_WIDTH) * scale);
+            frameHeight = int(capture.get(CAP_PROP_FRAME_HEIGHT) * scale);
+            cout << "Video " << video
+                << ": width=" << frameWidth
+                << ", height=" << frameHeight
+                << endl;
+        }
+        else
+        {
+            cout << "Could not initialize video capturing: " << video << "\n";
+            return 1;
+        }
+
+        detector->setInputSize(Size(frameWidth, frameHeight));
+
+        cout << "Press 'SPACE' to save frame, any other key to exit..." << endl;
+        int nFrame = 0;
+        for (;;)
+        {
+            // Get frame
+            Mat frame;
+            if (!capture.read(frame))
+            {
+                cerr << "Can't grab frame! Stop\n";
+                break;
+            }
+
+            resize(frame, frame, Size(frameWidth, frameHeight));
+
+            // Inference
+            Mat faces;
+            tm.start();
+            detector->detect(frame, faces);
+            tm.stop();
+
+            Mat result = frame.clone();
+            // Draw results on the input image
+            visualize(result, nFrame, faces, tm.getFPS());
+
+            // Visualize results
+            imshow("Live", result);
+
+            int key = waitKey(1);
+            bool saveFrame = save;
+            if (key == ' ')
+            {
+                saveFrame = true;
+                key = 0;  // handled
+            }
+
+            if (saveFrame)
+            {
+                std::string frame_name = cv::format("frame_%05d.png", nFrame);
+                std::string result_name = cv::format("result_%05d.jpg", nFrame);
+                cout << "Saving '" << frame_name << "' and '" << result_name << "' ...\n";
+                imwrite(frame_name, frame);
+                imwrite(result_name, result);
+            }
+
+            ++nFrame;
+
+            if (key > 0)
+                break;
+        }
+        cout << "Processed " << nFrame << " frames" << endl;
+    }
+    cout << "Done." << endl;
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/face_detect.py b/C++/opencv-4.7.0/samples/dnn/face_detect.py
new file mode 100644
index 00000000..9cf38b5d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/face_detect.py
@@ -0,0 +1,159 @@
+import argparse
+
+import numpy as np
+import cv2 as cv
+
+def str2bool(v):
+    if v.lower() in ['on', 'yes', 'true', 'y', 't']:
+        return True
+    elif v.lower() in ['off', 'no', 'false', 'n', 'f']:
+        return False
+    else:
+        raise NotImplementedError
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--image1', '-i1', type=str, help='Path to the input image1. Omit for detecting on default camera.')
+parser.add_argument('--image2', '-i2', type=str, help='Path to the input image2. When image1 and image2 parameters given then the program try to find a face on both images and runs face recognition algorithm.')
+parser.add_argument('--video', '-v', type=str, help='Path to the input video.')
+parser.add_argument('--scale', '-sc', type=float, default=1.0, help='Scale factor used to resize input video frames.')
+parser.add_argument('--face_detection_model', '-fd', type=str, default='face_detection_yunet_2021dec.onnx', help='Path to the face detection model. Download the model at https://github.com/opencv/opencv_zoo/tree/master/models/face_detection_yunet')
+parser.add_argument('--face_recognition_model', '-fr', type=str, default='face_recognition_sface_2021dec.onnx', help='Path to the face recognition model. Download the model at https://github.com/opencv/opencv_zoo/tree/master/models/face_recognition_sface')
+parser.add_argument('--score_threshold', type=float, default=0.9, help='Filtering out faces of score < score_threshold.')
+parser.add_argument('--nms_threshold', type=float, default=0.3, help='Suppress bounding boxes of iou >= nms_threshold.')
+parser.add_argument('--top_k', type=int, default=5000, help='Keep top_k bounding boxes before NMS.')
+parser.add_argument('--save', '-s', type=str2bool, default=False, help='Set true to save results. This flag is invalid when using camera.')
+args = parser.parse_args()
+
+def visualize(input, faces, fps, thickness=2):
+    if faces[1] is not None:
+        for idx, face in enumerate(faces[1]):
+            print('Face {}, top-left coordinates: ({:.0f}, {:.0f}), box width: {:.0f}, box height {:.0f}, score: {:.2f}'.format(idx, face[0], face[1], face[2], face[3], face[-1]))
+
+            coords = face[:-1].astype(np.int32)
+            cv.rectangle(input, (coords[0], coords[1]), (coords[0]+coords[2], coords[1]+coords[3]), (0, 255, 0), thickness)
+            cv.circle(input, (coords[4], coords[5]), 2, (255, 0, 0), thickness)
+            cv.circle(input, (coords[6], coords[7]), 2, (0, 0, 255), thickness)
+            cv.circle(input, (coords[8], coords[9]), 2, (0, 255, 0), thickness)
+            cv.circle(input, (coords[10], coords[11]), 2, (255, 0, 255), thickness)
+            cv.circle(input, (coords[12], coords[13]), 2, (0, 255, 255), thickness)
+    cv.putText(input, 'FPS: {:.2f}'.format(fps), (1, 16), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+
+if __name__ == '__main__':
+
+    ## [initialize_FaceDetectorYN]
+    detector = cv.FaceDetectorYN.create(
+        args.face_detection_model,
+        "",
+        (320, 320),
+        args.score_threshold,
+        args.nms_threshold,
+        args.top_k
+    )
+    ## [initialize_FaceDetectorYN]
+
+    tm = cv.TickMeter()
+
+    # If input is an image
+    if args.image1 is not None:
+        img1 = cv.imread(cv.samples.findFile(args.image1))
+        img1Width = int(img1.shape[1]*args.scale)
+        img1Height = int(img1.shape[0]*args.scale)
+
+        img1 = cv.resize(img1, (img1Width, img1Height))
+        tm.start()
+
+        ## [inference]
+        # Set input size before inference
+        detector.setInputSize((img1Width, img1Height))
+
+        faces1 = detector.detect(img1)
+        ## [inference]
+
+        tm.stop()
+        assert faces1[1] is not None, 'Cannot find a face in {}'.format(args.image1)
+
+        # Draw results on the input image
+        visualize(img1, faces1, tm.getFPS())
+
+        # Save results if save is true
+        if args.save:
+            print('Results saved to result.jpg\n')
+            cv.imwrite('result.jpg', img1)
+
+        # Visualize results in a new window
+        cv.imshow("image1", img1)
+
+        if args.image2 is not None:
+            img2 = cv.imread(cv.samples.findFile(args.image2))
+
+            tm.reset()
+            tm.start()
+            detector.setInputSize((img2.shape[1], img2.shape[0]))
+            faces2 = detector.detect(img2)
+            tm.stop()
+            assert faces2[1] is not None, 'Cannot find a face in {}'.format(args.image2)
+            visualize(img2, faces2, tm.getFPS())
+            cv.imshow("image2", img2)
+
+            ## [initialize_FaceRecognizerSF]
+            recognizer = cv.FaceRecognizerSF.create(
+            args.face_recognition_model,"")
+            ## [initialize_FaceRecognizerSF]
+
+            ## [facerecognizer]
+            # Align faces
+            face1_align = recognizer.alignCrop(img1, faces1[1][0])
+            face2_align = recognizer.alignCrop(img2, faces2[1][0])
+
+            # Extract features
+            face1_feature = recognizer.feature(face1_align)
+            face2_feature = recognizer.feature(face2_align)
+            ## [facerecognizer]
+
+            cosine_similarity_threshold = 0.363
+            l2_similarity_threshold = 1.128
+
+            ## [match]
+            cosine_score = recognizer.match(face1_feature, face2_feature, cv.FaceRecognizerSF_FR_COSINE)
+            l2_score = recognizer.match(face1_feature, face2_feature, cv.FaceRecognizerSF_FR_NORM_L2)
+            ## [match]
+
+            msg = 'different identities'
+            if cosine_score >= cosine_similarity_threshold:
+                msg = 'the same identity'
+            print('They have {}. Cosine Similarity: {}, threshold: {} (higher value means higher similarity, max 1.0).'.format(msg, cosine_score, cosine_similarity_threshold))
+
+            msg = 'different identities'
+            if l2_score <= l2_similarity_threshold:
+                msg = 'the same identity'
+            print('They have {}. NormL2 Distance: {}, threshold: {} (lower value means higher similarity, min 0.0).'.format(msg, l2_score, l2_similarity_threshold))
+        cv.waitKey(0)
+    else: # Omit input to call default camera
+        if args.video is not None:
+            deviceId = args.video
+        else:
+            deviceId = 0
+        cap = cv.VideoCapture(deviceId)
+        frameWidth = int(cap.get(cv.CAP_PROP_FRAME_WIDTH)*args.scale)
+        frameHeight = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT)*args.scale)
+        detector.setInputSize([frameWidth, frameHeight])
+
+        while cv.waitKey(1) < 0:
+            hasFrame, frame = cap.read()
+            if not hasFrame:
+                print('No frames grabbed!')
+                break
+
+            frame = cv.resize(frame, (frameWidth, frameHeight))
+
+            # Inference
+            tm.start()
+            faces = detector.detect(frame) # faces is a tuple
+            tm.stop()
+
+            # Draw results on the input image
+            visualize(frame, faces, tm.getFPS())
+
+            # Visualize results
+            cv.imshow('Live', frame)
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/dnn/face_detector/deploy.prototxt b/C++/opencv-4.7.0/samples/dnn/face_detector/deploy.prototxt
new file mode 100644
index 00000000..a1285156
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/face_detector/deploy.prototxt
@@ -0,0 +1,1790 @@
+input: "data"
+input_shape {
+  dim: 1
+  dim: 3
+  dim: 300
+  dim: 300
+}
+
+layer {
+  name: "data_bn"
+  type: "BatchNorm"
+  bottom: "data"
+  top: "data_bn"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "data_scale"
+  type: "Scale"
+  bottom: "data_bn"
+  top: "data_bn"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "conv1_h"
+  type: "Convolution"
+  bottom: "data_bn"
+  top: "conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    pad: 3
+    kernel_size: 7
+    stride: 2
+    weight_filler {
+      type: "msra"
+      variance_norm: FAN_OUT
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "conv1_bn_h"
+  type: "BatchNorm"
+  bottom: "conv1_h"
+  top: "conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "conv1_scale_h"
+  type: "Scale"
+  bottom: "conv1_h"
+  top: "conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "conv1_relu"
+  type: "ReLU"
+  bottom: "conv1_h"
+  top: "conv1_h"
+}
+layer {
+  name: "conv1_pool"
+  type: "Pooling"
+  bottom: "conv1_h"
+  top: "conv1_pool"
+  pooling_param {
+    kernel_size: 3
+    stride: 2
+  }
+}
+layer {
+  name: "layer_64_1_conv1_h"
+  type: "Convolution"
+  bottom: "conv1_pool"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_64_1_bn2_h"
+  type: "BatchNorm"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_64_1_scale2_h"
+  type: "Scale"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_64_1_relu2"
+  type: "ReLU"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+}
+layer {
+  name: "layer_64_1_conv2_h"
+  type: "Convolution"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv2_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_64_1_sum"
+  type: "Eltwise"
+  bottom: "layer_64_1_conv2_h"
+  bottom: "conv1_pool"
+  top: "layer_64_1_sum"
+}
+layer {
+  name: "layer_128_1_bn1_h"
+  type: "BatchNorm"
+  bottom: "layer_64_1_sum"
+  top: "layer_128_1_bn1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_128_1_scale1_h"
+  type: "Scale"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_bn1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_128_1_relu1"
+  type: "ReLU"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_bn1_h"
+}
+layer {
+  name: "layer_128_1_conv1_h"
+  type: "Convolution"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_bn2"
+  type: "BatchNorm"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_128_1_scale2"
+  type: "Scale"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_128_1_relu2"
+  type: "ReLU"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+}
+layer {
+  name: "layer_128_1_conv2"
+  type: "Convolution"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv2"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_conv_expand_h"
+  type: "Convolution"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_conv_expand_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_sum"
+  type: "Eltwise"
+  bottom: "layer_128_1_conv2"
+  bottom: "layer_128_1_conv_expand_h"
+  top: "layer_128_1_sum"
+}
+layer {
+  name: "layer_256_1_bn1"
+  type: "BatchNorm"
+  bottom: "layer_128_1_sum"
+  top: "layer_256_1_bn1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_256_1_scale1"
+  type: "Scale"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_bn1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_256_1_relu1"
+  type: "ReLU"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_bn1"
+}
+layer {
+  name: "layer_256_1_conv1"
+  type: "Convolution"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_bn2"
+  type: "BatchNorm"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_256_1_scale2"
+  type: "Scale"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_256_1_relu2"
+  type: "ReLU"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+}
+layer {
+  name: "layer_256_1_conv2"
+  type: "Convolution"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv2"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_conv_expand"
+  type: "Convolution"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_conv_expand"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_sum"
+  type: "Eltwise"
+  bottom: "layer_256_1_conv2"
+  bottom: "layer_256_1_conv_expand"
+  top: "layer_256_1_sum"
+}
+layer {
+  name: "layer_512_1_bn1"
+  type: "BatchNorm"
+  bottom: "layer_256_1_sum"
+  top: "layer_512_1_bn1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_512_1_scale1"
+  type: "Scale"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_bn1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_512_1_relu1"
+  type: "ReLU"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_bn1"
+}
+layer {
+  name: "layer_512_1_conv1_h"
+  type: "Convolution"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1 # 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_bn2_h"
+  type: "BatchNorm"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_512_1_scale2_h"
+  type: "Scale"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_512_1_relu2"
+  type: "ReLU"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+}
+layer {
+  name: "layer_512_1_conv2_h"
+  type: "Convolution"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv2_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 2 # 1
+    kernel_size: 3
+    stride: 1
+    dilation: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_conv_expand_h"
+  type: "Convolution"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_conv_expand_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 1 # 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_sum"
+  type: "Eltwise"
+  bottom: "layer_512_1_conv2_h"
+  bottom: "layer_512_1_conv_expand_h"
+  top: "layer_512_1_sum"
+}
+layer {
+  name: "last_bn_h"
+  type: "BatchNorm"
+  bottom: "layer_512_1_sum"
+  top: "layer_512_1_sum"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "last_scale_h"
+  type: "Scale"
+  bottom: "layer_512_1_sum"
+  top: "layer_512_1_sum"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "last_relu"
+  type: "ReLU"
+  bottom: "layer_512_1_sum"
+  top: "fc7"
+}
+
+layer {
+  name: "conv6_1_h"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "conv6_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_1_relu"
+  type: "ReLU"
+  bottom: "conv6_1_h"
+  top: "conv6_1_h"
+}
+layer {
+  name: "conv6_2_h"
+  type: "Convolution"
+  bottom: "conv6_1_h"
+  top: "conv6_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_relu"
+  type: "ReLU"
+  bottom: "conv6_2_h"
+  top: "conv6_2_h"
+}
+layer {
+  name: "conv7_1_h"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv7_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_1_relu"
+  type: "ReLU"
+  bottom: "conv7_1_h"
+  top: "conv7_1_h"
+}
+layer {
+  name: "conv7_2_h"
+  type: "Convolution"
+  bottom: "conv7_1_h"
+  top: "conv7_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_relu"
+  type: "ReLU"
+  bottom: "conv7_2_h"
+  top: "conv7_2_h"
+}
+layer {
+  name: "conv8_1_h"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv8_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_1_relu"
+  type: "ReLU"
+  bottom: "conv8_1_h"
+  top: "conv8_1_h"
+}
+layer {
+  name: "conv8_2_h"
+  type: "Convolution"
+  bottom: "conv8_1_h"
+  top: "conv8_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_relu"
+  type: "ReLU"
+  bottom: "conv8_2_h"
+  top: "conv8_2_h"
+}
+layer {
+  name: "conv9_1_h"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv9_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_1_relu"
+  type: "ReLU"
+  bottom: "conv9_1_h"
+  top: "conv9_1_h"
+}
+layer {
+  name: "conv9_2_h"
+  type: "Convolution"
+  bottom: "conv9_1_h"
+  top: "conv9_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_2_relu"
+  type: "ReLU"
+  bottom: "conv9_2_h"
+  top: "conv9_2_h"
+}
+layer {
+  name: "conv4_3_norm"
+  type: "Normalize"
+  bottom: "layer_256_1_bn1"
+  top: "conv4_3_norm"
+  norm_param {
+    across_spatial: false
+    scale_filler {
+      type: "constant"
+      value: 20
+    }
+    channel_shared: false
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc"
+  type: "Convolution"
+  bottom: "conv4_3_norm"
+  top: "conv4_3_norm_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv4_3_norm_mbox_loc"
+  top: "conv4_3_norm_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv4_3_norm_mbox_loc_perm"
+  top: "conv4_3_norm_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf"
+  type: "Convolution"
+  bottom: "conv4_3_norm"
+  top: "conv4_3_norm_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv4_3_norm_mbox_conf"
+  top: "conv4_3_norm_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv4_3_norm_mbox_conf_perm"
+  top: "conv4_3_norm_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv4_3_norm"
+  bottom: "data"
+  top: "conv4_3_norm_mbox_priorbox"
+  prior_box_param {
+    min_size: 30.0
+    max_size: 60.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 8
+    offset: 0.5
+  }
+}
+layer {
+  name: "fc7_mbox_loc"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "fc7_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "fc7_mbox_loc_perm"
+  type: "Permute"
+  bottom: "fc7_mbox_loc"
+  top: "fc7_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "fc7_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "fc7_mbox_loc_perm"
+  top: "fc7_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "fc7_mbox_conf"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "fc7_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "fc7_mbox_conf_perm"
+  type: "Permute"
+  bottom: "fc7_mbox_conf"
+  top: "fc7_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "fc7_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "fc7_mbox_conf_perm"
+  top: "fc7_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "fc7_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "fc7"
+  bottom: "data"
+  top: "fc7_mbox_priorbox"
+  prior_box_param {
+    min_size: 60.0
+    max_size: 111.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 16
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv6_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv6_2_mbox_loc"
+  top: "conv6_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv6_2_mbox_loc_perm"
+  top: "conv6_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv6_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv6_2_mbox_conf"
+  top: "conv6_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv6_2_mbox_conf_perm"
+  top: "conv6_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv6_2_h"
+  bottom: "data"
+  top: "conv6_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 111.0
+    max_size: 162.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 32
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv7_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv7_2_mbox_loc"
+  top: "conv7_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv7_2_mbox_loc_perm"
+  top: "conv7_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv7_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv7_2_mbox_conf"
+  top: "conv7_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv7_2_mbox_conf_perm"
+  top: "conv7_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv7_2_h"
+  bottom: "data"
+  top: "conv7_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 162.0
+    max_size: 213.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 64
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv8_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv8_2_mbox_loc"
+  top: "conv8_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv8_2_mbox_loc_perm"
+  top: "conv8_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv8_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv8_2_mbox_conf"
+  top: "conv8_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv8_2_mbox_conf_perm"
+  top: "conv8_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv8_2_h"
+  bottom: "data"
+  top: "conv8_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 213.0
+    max_size: 264.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 100
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv9_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv9_2_h"
+  top: "conv9_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv9_2_mbox_loc"
+  top: "conv9_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv9_2_mbox_loc_perm"
+  top: "conv9_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv9_2_h"
+  top: "conv9_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv9_2_mbox_conf"
+  top: "conv9_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv9_2_mbox_conf_perm"
+  top: "conv9_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv9_2_h"
+  bottom: "data"
+  top: "conv9_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 264.0
+    max_size: 315.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 300
+    offset: 0.5
+  }
+}
+layer {
+  name: "mbox_loc"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_loc_flat"
+  bottom: "fc7_mbox_loc_flat"
+  bottom: "conv6_2_mbox_loc_flat"
+  bottom: "conv7_2_mbox_loc_flat"
+  bottom: "conv8_2_mbox_loc_flat"
+  bottom: "conv9_2_mbox_loc_flat"
+  top: "mbox_loc"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "mbox_conf"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_conf_flat"
+  bottom: "fc7_mbox_conf_flat"
+  bottom: "conv6_2_mbox_conf_flat"
+  bottom: "conv7_2_mbox_conf_flat"
+  bottom: "conv8_2_mbox_conf_flat"
+  bottom: "conv9_2_mbox_conf_flat"
+  top: "mbox_conf"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "mbox_priorbox"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_priorbox"
+  bottom: "fc7_mbox_priorbox"
+  bottom: "conv6_2_mbox_priorbox"
+  bottom: "conv7_2_mbox_priorbox"
+  bottom: "conv8_2_mbox_priorbox"
+  bottom: "conv9_2_mbox_priorbox"
+  top: "mbox_priorbox"
+  concat_param {
+    axis: 2
+  }
+}
+
+layer {
+  name: "mbox_conf_reshape"
+  type: "Reshape"
+  bottom: "mbox_conf"
+  top: "mbox_conf_reshape"
+  reshape_param {
+    shape {
+      dim: 0
+      dim: -1
+      dim: 2
+    }
+  }
+}
+layer {
+  name: "mbox_conf_softmax"
+  type: "Softmax"
+  bottom: "mbox_conf_reshape"
+  top: "mbox_conf_softmax"
+  softmax_param {
+    axis: 2
+  }
+}
+layer {
+  name: "mbox_conf_flatten"
+  type: "Flatten"
+  bottom: "mbox_conf_softmax"
+  top: "mbox_conf_flatten"
+  flatten_param {
+    axis: 1
+  }
+}
+
+layer {
+  name: "detection_out"
+  type: "DetectionOutput"
+  bottom: "mbox_loc"
+  bottom: "mbox_conf_flatten"
+  bottom: "mbox_priorbox"
+  top: "detection_out"
+  include {
+    phase: TEST
+  }
+  detection_output_param {
+    num_classes: 2
+    share_location: true
+    background_label_id: 0
+    nms_param {
+      nms_threshold: 0.45
+      top_k: 400
+    }
+    code_type: CENTER_SIZE
+    keep_top_k: 200
+    confidence_threshold: 0.01
+    clip: 1
+  }
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/face_detector/deploy_lowres.prototxt b/C++/opencv-4.7.0/samples/dnn/face_detector/deploy_lowres.prototxt
new file mode 100644
index 00000000..5a1520d8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/face_detector/deploy_lowres.prototxt
@@ -0,0 +1,1790 @@
+# This file is based on deploy.prototxt but might be used for input resolution less than 300x300
+input: "data"
+input_shape {
+  dim: 1
+  dim: 3
+  dim: 300
+  dim: 300
+}
+
+layer {
+  name: "data_bn"
+  type: "BatchNorm"
+  bottom: "data"
+  top: "data_bn"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "data_scale"
+  type: "Scale"
+  bottom: "data_bn"
+  top: "data_bn"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "conv1_h"
+  type: "Convolution"
+  bottom: "data_bn"
+  top: "conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    pad: 3
+    kernel_size: 7
+    stride: 2
+    weight_filler {
+      type: "msra"
+      variance_norm: FAN_OUT
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "conv1_bn_h"
+  type: "BatchNorm"
+  bottom: "conv1_h"
+  top: "conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "conv1_scale_h"
+  type: "Scale"
+  bottom: "conv1_h"
+  top: "conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "conv1_relu"
+  type: "ReLU"
+  bottom: "conv1_h"
+  top: "conv1_h"
+}
+layer {
+  name: "conv1_pool"
+  type: "Pooling"
+  bottom: "conv1_h"
+  top: "conv1_pool"
+  pooling_param {
+    kernel_size: 3
+    stride: 2
+  }
+}
+layer {
+  name: "layer_64_1_conv1_h"
+  type: "Convolution"
+  bottom: "conv1_pool"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_64_1_bn2_h"
+  type: "BatchNorm"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_64_1_scale2_h"
+  type: "Scale"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_64_1_relu2"
+  type: "ReLU"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+}
+layer {
+  name: "layer_64_1_conv2_h"
+  type: "Convolution"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv2_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_64_1_sum"
+  type: "Eltwise"
+  bottom: "layer_64_1_conv2_h"
+  bottom: "conv1_pool"
+  top: "layer_64_1_sum"
+}
+layer {
+  name: "layer_128_1_bn1_h"
+  type: "BatchNorm"
+  bottom: "layer_64_1_sum"
+  top: "layer_128_1_bn1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_128_1_scale1_h"
+  type: "Scale"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_bn1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_128_1_relu1"
+  type: "ReLU"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_bn1_h"
+}
+layer {
+  name: "layer_128_1_conv1_h"
+  type: "Convolution"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_bn2"
+  type: "BatchNorm"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_128_1_scale2"
+  type: "Scale"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_128_1_relu2"
+  type: "ReLU"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+}
+layer {
+  name: "layer_128_1_conv2"
+  type: "Convolution"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv2"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_conv_expand_h"
+  type: "Convolution"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_conv_expand_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_sum"
+  type: "Eltwise"
+  bottom: "layer_128_1_conv2"
+  bottom: "layer_128_1_conv_expand_h"
+  top: "layer_128_1_sum"
+}
+layer {
+  name: "layer_256_1_bn1"
+  type: "BatchNorm"
+  bottom: "layer_128_1_sum"
+  top: "layer_256_1_bn1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_256_1_scale1"
+  type: "Scale"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_bn1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_256_1_relu1"
+  type: "ReLU"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_bn1"
+}
+layer {
+  name: "layer_256_1_conv1"
+  type: "Convolution"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_bn2"
+  type: "BatchNorm"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_256_1_scale2"
+  type: "Scale"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_256_1_relu2"
+  type: "ReLU"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+}
+layer {
+  name: "layer_256_1_conv2"
+  type: "Convolution"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv2"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_conv_expand"
+  type: "Convolution"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_conv_expand"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_sum"
+  type: "Eltwise"
+  bottom: "layer_256_1_conv2"
+  bottom: "layer_256_1_conv_expand"
+  top: "layer_256_1_sum"
+}
+layer {
+  name: "layer_512_1_bn1"
+  type: "BatchNorm"
+  bottom: "layer_256_1_sum"
+  top: "layer_512_1_bn1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_512_1_scale1"
+  type: "Scale"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_bn1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_512_1_relu1"
+  type: "ReLU"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_bn1"
+}
+layer {
+  name: "layer_512_1_conv1_h"
+  type: "Convolution"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1 # 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_bn2_h"
+  type: "BatchNorm"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_512_1_scale2_h"
+  type: "Scale"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_512_1_relu2"
+  type: "ReLU"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+}
+layer {
+  name: "layer_512_1_conv2_h"
+  type: "Convolution"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv2_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 2 # 1
+    kernel_size: 3
+    stride: 1
+    dilation: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_conv_expand_h"
+  type: "Convolution"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_conv_expand_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 1 # 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_sum"
+  type: "Eltwise"
+  bottom: "layer_512_1_conv2_h"
+  bottom: "layer_512_1_conv_expand_h"
+  top: "layer_512_1_sum"
+}
+layer {
+  name: "last_bn_h"
+  type: "BatchNorm"
+  bottom: "layer_512_1_sum"
+  top: "layer_512_1_sum"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "last_scale_h"
+  type: "Scale"
+  bottom: "layer_512_1_sum"
+  top: "layer_512_1_sum"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "last_relu"
+  type: "ReLU"
+  bottom: "layer_512_1_sum"
+  top: "fc7"
+}
+
+layer {
+  name: "conv6_1_h"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "conv6_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_1_relu"
+  type: "ReLU"
+  bottom: "conv6_1_h"
+  top: "conv6_1_h"
+}
+layer {
+  name: "conv6_2_h"
+  type: "Convolution"
+  bottom: "conv6_1_h"
+  top: "conv6_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_relu"
+  type: "ReLU"
+  bottom: "conv6_2_h"
+  top: "conv6_2_h"
+}
+layer {
+  name: "conv7_1_h"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv7_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_1_relu"
+  type: "ReLU"
+  bottom: "conv7_1_h"
+  top: "conv7_1_h"
+}
+layer {
+  name: "conv7_2_h"
+  type: "Convolution"
+  bottom: "conv7_1_h"
+  top: "conv7_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_relu"
+  type: "ReLU"
+  bottom: "conv7_2_h"
+  top: "conv7_2_h"
+}
+layer {
+  name: "conv8_1_h"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv8_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_1_relu"
+  type: "ReLU"
+  bottom: "conv8_1_h"
+  top: "conv8_1_h"
+}
+layer {
+  name: "conv8_2_h"
+  type: "Convolution"
+  bottom: "conv8_1_h"
+  top: "conv8_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_relu"
+  type: "ReLU"
+  bottom: "conv8_2_h"
+  top: "conv8_2_h"
+}
+# layer {
+#   name: "conv9_1_h"
+#   type: "Convolution"
+#   bottom: "conv8_2_h"
+#   top: "conv9_1_h"
+#   param {
+#     lr_mult: 1
+#     decay_mult: 1
+#   }
+#   param {
+#     lr_mult: 2
+#     decay_mult: 0
+#   }
+#   convolution_param {
+#     num_output: 64
+#     pad: 0
+#     kernel_size: 1
+#     stride: 1
+#     weight_filler {
+#       type: "xavier"
+#     }
+#     bias_filler {
+#       type: "constant"
+#       value: 0
+#     }
+#   }
+# }
+# layer {
+#   name: "conv9_1_relu"
+#   type: "ReLU"
+#   bottom: "conv9_1_h"
+#   top: "conv9_1_h"
+# }
+# layer {
+#   name: "conv9_2_h"
+#   type: "Convolution"
+#   bottom: "conv9_1_h"
+#   top: "conv9_2_h"
+#   param {
+#     lr_mult: 1
+#     decay_mult: 1
+#   }
+#   param {
+#     lr_mult: 2
+#     decay_mult: 0
+#   }
+#   convolution_param {
+#     num_output: 128
+#     pad: 0
+#     kernel_size: 3
+#     stride: 1
+#     weight_filler {
+#       type: "xavier"
+#     }
+#     bias_filler {
+#       type: "constant"
+#       value: 0
+#     }
+#   }
+# }
+# layer {
+#   name: "conv9_2_relu"
+#   type: "ReLU"
+#   bottom: "conv9_2_h"
+#   top: "conv9_2_h"
+# }
+layer {
+  name: "conv4_3_norm"
+  type: "Normalize"
+  bottom: "layer_256_1_bn1"
+  top: "conv4_3_norm"
+  norm_param {
+    across_spatial: false
+    scale_filler {
+      type: "constant"
+      value: 20
+    }
+    channel_shared: false
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc"
+  type: "Convolution"
+  bottom: "conv4_3_norm"
+  top: "conv4_3_norm_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv4_3_norm_mbox_loc"
+  top: "conv4_3_norm_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv4_3_norm_mbox_loc_perm"
+  top: "conv4_3_norm_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf"
+  type: "Convolution"
+  bottom: "conv4_3_norm"
+  top: "conv4_3_norm_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv4_3_norm_mbox_conf"
+  top: "conv4_3_norm_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv4_3_norm_mbox_conf_perm"
+  top: "conv4_3_norm_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv4_3_norm"
+  bottom: "data"
+  top: "conv4_3_norm_mbox_priorbox"
+  prior_box_param {
+    min_size: 30.0
+    max_size: 60.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 8
+    offset: 0.5
+  }
+}
+layer {
+  name: "fc7_mbox_loc"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "fc7_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "fc7_mbox_loc_perm"
+  type: "Permute"
+  bottom: "fc7_mbox_loc"
+  top: "fc7_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "fc7_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "fc7_mbox_loc_perm"
+  top: "fc7_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "fc7_mbox_conf"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "fc7_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "fc7_mbox_conf_perm"
+  type: "Permute"
+  bottom: "fc7_mbox_conf"
+  top: "fc7_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "fc7_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "fc7_mbox_conf_perm"
+  top: "fc7_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "fc7_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "fc7"
+  bottom: "data"
+  top: "fc7_mbox_priorbox"
+  prior_box_param {
+    min_size: 60.0
+    max_size: 111.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 16
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv6_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv6_2_mbox_loc"
+  top: "conv6_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv6_2_mbox_loc_perm"
+  top: "conv6_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv6_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv6_2_mbox_conf"
+  top: "conv6_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv6_2_mbox_conf_perm"
+  top: "conv6_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv6_2_h"
+  bottom: "data"
+  top: "conv6_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 111.0
+    max_size: 162.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 32
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv7_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv7_2_mbox_loc"
+  top: "conv7_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv7_2_mbox_loc_perm"
+  top: "conv7_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv7_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv7_2_mbox_conf"
+  top: "conv7_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv7_2_mbox_conf_perm"
+  top: "conv7_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv7_2_h"
+  bottom: "data"
+  top: "conv7_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 162.0
+    max_size: 213.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 64
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv8_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv8_2_mbox_loc"
+  top: "conv8_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv8_2_mbox_loc_perm"
+  top: "conv8_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv8_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv8_2_mbox_conf"
+  top: "conv8_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv8_2_mbox_conf_perm"
+  top: "conv8_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv8_2_h"
+  bottom: "data"
+  top: "conv8_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 213.0
+    max_size: 264.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 100
+    offset: 0.5
+  }
+}
+# layer {
+#   name: "conv9_2_mbox_loc"
+#   type: "Convolution"
+#   bottom: "conv9_2_h"
+#   top: "conv9_2_mbox_loc"
+#   param {
+#     lr_mult: 1
+#     decay_mult: 1
+#   }
+#   param {
+#     lr_mult: 2
+#     decay_mult: 0
+#   }
+#   convolution_param {
+#     num_output: 16
+#     pad: 1
+#     kernel_size: 3
+#     stride: 1
+#     weight_filler {
+#       type: "xavier"
+#     }
+#     bias_filler {
+#       type: "constant"
+#       value: 0
+#     }
+#   }
+# }
+# layer {
+#   name: "conv9_2_mbox_loc_perm"
+#   type: "Permute"
+#   bottom: "conv9_2_mbox_loc"
+#   top: "conv9_2_mbox_loc_perm"
+#   permute_param {
+#     order: 0
+#     order: 2
+#     order: 3
+#     order: 1
+#   }
+# }
+# layer {
+#   name: "conv9_2_mbox_loc_flat"
+#   type: "Flatten"
+#   bottom: "conv9_2_mbox_loc_perm"
+#   top: "conv9_2_mbox_loc_flat"
+#   flatten_param {
+#     axis: 1
+#   }
+# }
+# layer {
+#   name: "conv9_2_mbox_conf"
+#   type: "Convolution"
+#   bottom: "conv9_2_h"
+#   top: "conv9_2_mbox_conf"
+#   param {
+#     lr_mult: 1
+#     decay_mult: 1
+#   }
+#   param {
+#     lr_mult: 2
+#     decay_mult: 0
+#   }
+#   convolution_param {
+#     num_output: 8 # 84
+#     pad: 1
+#     kernel_size: 3
+#     stride: 1
+#     weight_filler {
+#       type: "xavier"
+#     }
+#     bias_filler {
+#       type: "constant"
+#       value: 0
+#     }
+#   }
+# }
+# layer {
+#   name: "conv9_2_mbox_conf_perm"
+#   type: "Permute"
+#   bottom: "conv9_2_mbox_conf"
+#   top: "conv9_2_mbox_conf_perm"
+#   permute_param {
+#     order: 0
+#     order: 2
+#     order: 3
+#     order: 1
+#   }
+# }
+# layer {
+#   name: "conv9_2_mbox_conf_flat"
+#   type: "Flatten"
+#   bottom: "conv9_2_mbox_conf_perm"
+#   top: "conv9_2_mbox_conf_flat"
+#   flatten_param {
+#     axis: 1
+#   }
+# }
+# layer {
+#   name: "conv9_2_mbox_priorbox"
+#   type: "PriorBox"
+#   bottom: "conv9_2_h"
+#   bottom: "data"
+#   top: "conv9_2_mbox_priorbox"
+#   prior_box_param {
+#     min_size: 264.0
+#     max_size: 315.0
+#     aspect_ratio: 2
+#     flip: true
+#     clip: false
+#     variance: 0.1
+#     variance: 0.1
+#     variance: 0.2
+#     variance: 0.2
+#     step: 300
+#     offset: 0.5
+#   }
+# }
+layer {
+  name: "mbox_loc"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_loc_flat"
+  bottom: "fc7_mbox_loc_flat"
+  bottom: "conv6_2_mbox_loc_flat"
+  bottom: "conv7_2_mbox_loc_flat"
+  bottom: "conv8_2_mbox_loc_flat"
+  # bottom: "conv9_2_mbox_loc_flat"
+  top: "mbox_loc"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "mbox_conf"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_conf_flat"
+  bottom: "fc7_mbox_conf_flat"
+  bottom: "conv6_2_mbox_conf_flat"
+  bottom: "conv7_2_mbox_conf_flat"
+  bottom: "conv8_2_mbox_conf_flat"
+  # bottom: "conv9_2_mbox_conf_flat"
+  top: "mbox_conf"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "mbox_priorbox"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_priorbox"
+  bottom: "fc7_mbox_priorbox"
+  bottom: "conv6_2_mbox_priorbox"
+  bottom: "conv7_2_mbox_priorbox"
+  bottom: "conv8_2_mbox_priorbox"
+  # bottom: "conv9_2_mbox_priorbox"
+  top: "mbox_priorbox"
+  concat_param {
+    axis: 2
+  }
+}
+
+layer {
+  name: "mbox_conf_reshape"
+  type: "Reshape"
+  bottom: "mbox_conf"
+  top: "mbox_conf_reshape"
+  reshape_param {
+    shape {
+      dim: 0
+      dim: -1
+      dim: 2
+    }
+  }
+}
+layer {
+  name: "mbox_conf_softmax"
+  type: "Softmax"
+  bottom: "mbox_conf_reshape"
+  top: "mbox_conf_softmax"
+  softmax_param {
+    axis: 2
+  }
+}
+layer {
+  name: "mbox_conf_flatten"
+  type: "Flatten"
+  bottom: "mbox_conf_softmax"
+  top: "mbox_conf_flatten"
+  flatten_param {
+    axis: 1
+  }
+}
+
+layer {
+  name: "detection_out"
+  type: "DetectionOutput"
+  bottom: "mbox_loc"
+  bottom: "mbox_conf_flatten"
+  bottom: "mbox_priorbox"
+  top: "detection_out"
+  include {
+    phase: TEST
+  }
+  detection_output_param {
+    num_classes: 2
+    share_location: true
+    background_label_id: 0
+    nms_param {
+      nms_threshold: 0.45
+      top_k: 400
+    }
+    code_type: CENTER_SIZE
+    keep_top_k: 200
+    confidence_threshold: 0.01
+  }
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/face_detector/how_to_train_face_detector.txt b/C++/opencv-4.7.0/samples/dnn/face_detector/how_to_train_face_detector.txt
new file mode 100644
index 00000000..3f6b1ba4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/face_detector/how_to_train_face_detector.txt
@@ -0,0 +1,79 @@
+This is a brief description of training process which has been used to get res10_300x300_ssd_iter_140000.caffemodel.
+The model was created with SSD framework using ResNet-10 like architecture as a backbone. Channels count in ResNet-10 convolution layers was significantly dropped (2x- or 4x- fewer channels).
+The model was trained in Caffe framework on some huge and available online dataset.
+
+1. Prepare training tools
+You need to use "ssd" branch from this repository https://github.com/weiliu89/caffe/tree/ssd . Checkout this branch and built it (see instructions in repo's README)
+
+2. Prepare training data.
+The data preparation pipeline can be represented as:
+
+(a)Download original face detection dataset -> (b)Convert annotation to the PASCAL VOC format -> (c)Create LMDB database with images + annotations for training
+
+a) Find some datasets with face bounding boxes annotation. For some reasons I can't provide links here, but you easily find them on your own. Also study the data. It may contain small or low quality faces which can spoil training process. Often there are special flags about object quality in annotation. Remove such faces from annotation (smaller when 16 along at least one side, or blurred, of highly-occluded, or something else).
+
+b) The downloaded dataset will have some format of annotation. It may be one single file for all images, or separate file for each image or something else. But to train SSD in Caffe you need to convert annotation to PASCAL VOC format.
+PASCAL VOC annotation consist of .xml file for each image. In this xml file all face bounding boxes should be listed as:
+
+<annotation>
+  <size>
+    <width>300</width>
+    <height>300</height>
+  </size>
+  <object>
+    <name>face</name>
+    <difficult>0</difficult>
+    <bndbox>
+      <xmin>100</xmin>
+      <ymin>100</ymin>
+      <xmax>200</xmax>
+      <ymax>200</ymax>
+    </bndbox>
+  </object>
+  <object>
+    <name>face</name>
+    <difficult>0</difficult>
+    <bndbox>
+      <xmin>0</xmin>
+      <ymin>0</ymin>
+      <xmax>100</xmax>
+      <ymax>100</ymax>
+    </bndbox>
+  </object>
+</annotation>
+
+So, convert your dataset's annotation to the format above.
+Also, you should create labelmap.prototxt file with the following content:
+item {
+  name: "none_of_the_above"
+  label: 0
+  display_name: "background"
+}
+item {
+  name: "face"
+  label: 1
+  display_name: "face"
+}
+
+You need this file to establish correspondence between name of class and digital label of class.
+
+For next step we also need file there all our image-annotation file names pairs are listed. This file should contain similar lines:
+images_val/0.jpg annotations_val/0.jpg.xml
+
+c) To create LMDB you need to use create_data.sh tool from caffe/data/VOC0712 Caffe's source code directory.
+This script calls create_annoset.py inside, so check out what you need to pass as script's arguments
+
+You need to prepare 2 LMDB databases: one for training images, one for validation images.
+
+3. Train your detector
+For training you need to have 3 files: train.prototxt, test.prototxt and solver.prototxt. You can find these files in the same directory as for this readme.
+Also you need to edit train.prototxt and test.prototxt to replace paths for your LMDB databases to actual databases you've created in step 2.
+
+Now all is done for launch training process.
+Execute next lines in Terminal:
+mkdir -p snapshot
+mkdir -p log
+/path_for_caffe_build_dir/tools/caffe train -solver="solver.prototxt" -gpu 0  2>&1 | tee -a log/log.log
+
+And wait. It will take about 8 hours to finish the process.
+After it you can use your .caffemodel from snapshot/ subdirectory in resnet_face_ssd_python.py sample.
diff --git a/C++/opencv-4.7.0/samples/dnn/face_detector/opencv_face_detector.pbtxt b/C++/opencv-4.7.0/samples/dnn/face_detector/opencv_face_detector.pbtxt
new file mode 100644
index 00000000..60daa5e6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/face_detector/opencv_face_detector.pbtxt
@@ -0,0 +1,2368 @@
+node {
+  name: "data"
+  op: "Placeholder"
+  attr {
+    key: "dtype"
+    value {
+      type: DT_FLOAT
+    }
+  }
+}
+node {
+  name: "data_bn/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "data:0"
+  input: "data_bn/gamma"
+  input: "data_bn/beta"
+  input: "data_bn/mean"
+  input: "data_bn/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "data_scale/Mul"
+  op: "Mul"
+  input: "data_bn/FusedBatchNorm"
+  input: "data_scale/mul"
+}
+node {
+  name: "data_scale/BiasAdd"
+  op: "BiasAdd"
+  input: "data_scale/Mul"
+  input: "data_scale/add"
+}
+node {
+  name: "SpaceToBatchND/block_shape"
+  op: "Const"
+  attr {
+    key: "value"
+    value {
+      tensor {
+        dtype: DT_INT32
+        tensor_shape {
+          dim {
+            size: 2
+          }
+        }
+        int_val: 1
+        int_val: 1
+      }
+    }
+  }
+}
+node {
+  name: "SpaceToBatchND/paddings"
+  op: "Const"
+  attr {
+    key: "value"
+    value {
+      tensor {
+        dtype: DT_INT32
+        tensor_shape {
+          dim {
+            size: 2
+          }
+          dim {
+            size: 2
+          }
+        }
+        int_val: 3
+        int_val: 3
+        int_val: 3
+        int_val: 3
+      }
+    }
+  }
+}
+node {
+  name: "Pad"
+  op: "SpaceToBatchND"
+  input: "data_scale/BiasAdd"
+  input: "SpaceToBatchND/block_shape"
+  input: "SpaceToBatchND/paddings"
+}
+node {
+  name: "conv1_h/Conv2D"
+  op: "Conv2D"
+  input: "Pad"
+  input: "conv1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "VALID"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv1_h/Conv2D"
+  input: "conv1_h/bias"
+}
+node {
+  name: "BatchToSpaceND"
+  op: "BatchToSpaceND"
+  input: "conv1_h/BiasAdd"
+}
+node {
+  name: "conv1_bn_h/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "BatchToSpaceND"
+  input: "conv1_bn_h/gamma"
+  input: "conv1_bn_h/beta"
+  input: "conv1_bn_h/mean"
+  input: "conv1_bn_h/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "conv1_scale_h/Mul"
+  op: "Mul"
+  input: "conv1_bn_h/FusedBatchNorm"
+  input: "conv1_scale_h/mul"
+}
+node {
+  name: "conv1_scale_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv1_scale_h/Mul"
+  input: "conv1_scale_h/add"
+}
+node {
+  name: "Relu"
+  op: "Relu"
+  input: "conv1_scale_h/BiasAdd"
+}
+node {
+  name: "conv1_pool/MaxPool"
+  op: "MaxPool"
+  input: "Relu"
+  attr {
+    key: "ksize"
+    value {
+      list {
+        i: 1
+        i: 3
+        i: 3
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_64_1_conv1_h/Conv2D"
+  op: "Conv2D"
+  input: "conv1_pool/MaxPool"
+  input: "layer_64_1_conv1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_64_1_bn2_h/FusedBatchNorm"
+  op: "BiasAdd"
+  input: "layer_64_1_conv1_h/Conv2D"
+  input: "layer_64_1_conv1_h/Conv2D_bn_offset"
+}
+node {
+  name: "layer_64_1_scale2_h/Mul"
+  op: "Mul"
+  input: "layer_64_1_bn2_h/FusedBatchNorm"
+  input: "layer_64_1_scale2_h/mul"
+}
+node {
+  name: "layer_64_1_scale2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_64_1_scale2_h/Mul"
+  input: "layer_64_1_scale2_h/add"
+}
+node {
+  name: "Relu_1"
+  op: "Relu"
+  input: "layer_64_1_scale2_h/BiasAdd"
+}
+node {
+  name: "layer_64_1_conv2_h/Conv2D"
+  op: "Conv2D"
+  input: "Relu_1"
+  input: "layer_64_1_conv2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "add"
+  op: "Add"
+  input: "layer_64_1_conv2_h/Conv2D"
+  input: "conv1_pool/MaxPool"
+}
+node {
+  name: "layer_128_1_bn1_h/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "add"
+  input: "layer_128_1_bn1_h/gamma"
+  input: "layer_128_1_bn1_h/beta"
+  input: "layer_128_1_bn1_h/mean"
+  input: "layer_128_1_bn1_h/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "layer_128_1_scale1_h/Mul"
+  op: "Mul"
+  input: "layer_128_1_bn1_h/FusedBatchNorm"
+  input: "layer_128_1_scale1_h/mul"
+}
+node {
+  name: "layer_128_1_scale1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_128_1_scale1_h/Mul"
+  input: "layer_128_1_scale1_h/add"
+}
+node {
+  name: "Relu_2"
+  op: "Relu"
+  input: "layer_128_1_scale1_h/BiasAdd"
+}
+node {
+  name: "layer_128_1_conv_expand_h/Conv2D"
+  op: "Conv2D"
+  input: "Relu_2"
+  input: "layer_128_1_conv_expand_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_128_1_conv1_h/Conv2D"
+  op: "Conv2D"
+  input: "Relu_2"
+  input: "layer_128_1_conv1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_128_1_bn2/FusedBatchNorm"
+  op: "BiasAdd"
+  input: "layer_128_1_conv1_h/Conv2D"
+  input: "layer_128_1_conv1_h/Conv2D_bn_offset"
+}
+node {
+  name: "layer_128_1_scale2/Mul"
+  op: "Mul"
+  input: "layer_128_1_bn2/FusedBatchNorm"
+  input: "layer_128_1_scale2/mul"
+}
+node {
+  name: "layer_128_1_scale2/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_128_1_scale2/Mul"
+  input: "layer_128_1_scale2/add"
+}
+node {
+  name: "Relu_3"
+  op: "Relu"
+  input: "layer_128_1_scale2/BiasAdd"
+}
+node {
+  name: "layer_128_1_conv2/Conv2D"
+  op: "Conv2D"
+  input: "Relu_3"
+  input: "layer_128_1_conv2/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "add_1"
+  op: "Add"
+  input: "layer_128_1_conv2/Conv2D"
+  input: "layer_128_1_conv_expand_h/Conv2D"
+}
+node {
+  name: "layer_256_1_bn1/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "add_1"
+  input: "layer_256_1_bn1/gamma"
+  input: "layer_256_1_bn1/beta"
+  input: "layer_256_1_bn1/mean"
+  input: "layer_256_1_bn1/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "layer_256_1_scale1/Mul"
+  op: "Mul"
+  input: "layer_256_1_bn1/FusedBatchNorm"
+  input: "layer_256_1_scale1/mul"
+}
+node {
+  name: "layer_256_1_scale1/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_256_1_scale1/Mul"
+  input: "layer_256_1_scale1/add"
+}
+node {
+  name: "Relu_4"
+  op: "Relu"
+  input: "layer_256_1_scale1/BiasAdd"
+}
+node {
+  name: "SpaceToBatchND_1/paddings"
+  op: "Const"
+  attr {
+    key: "value"
+    value {
+      tensor {
+        dtype: DT_INT32
+        tensor_shape {
+          dim {
+            size: 2
+          }
+          dim {
+            size: 2
+          }
+        }
+        int_val: 1
+        int_val: 1
+        int_val: 1
+        int_val: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_256_1_conv_expand/Conv2D"
+  op: "Conv2D"
+  input: "Relu_4"
+  input: "layer_256_1_conv_expand/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv4_3_norm/l2_normalize"
+  op: "L2Normalize"
+  input: "Relu_4:0"
+  input: "conv4_3_norm/l2_normalize/Sum/reduction_indices"
+}
+node {
+  name: "conv4_3_norm/mul_1"
+  op: "Mul"
+  input: "conv4_3_norm/l2_normalize"
+  input: "conv4_3_norm/mul"
+}
+node {
+  name: "conv4_3_norm_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "conv4_3_norm/mul_1"
+  input: "conv4_3_norm_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv4_3_norm_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "conv4_3_norm_mbox_loc/Conv2D"
+  input: "conv4_3_norm_mbox_loc/bias"
+}
+node {
+  name: "flatten/Reshape"
+  op: "Flatten"
+  input: "conv4_3_norm_mbox_loc/BiasAdd"
+}
+node {
+  name: "conv4_3_norm_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "conv4_3_norm/mul_1"
+  input: "conv4_3_norm_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv4_3_norm_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "conv4_3_norm_mbox_conf/Conv2D"
+  input: "conv4_3_norm_mbox_conf/bias"
+}
+node {
+  name: "flatten_6/Reshape"
+  op: "Flatten"
+  input: "conv4_3_norm_mbox_conf/BiasAdd"
+}
+node {
+  name: "Pad_1"
+  op: "SpaceToBatchND"
+  input: "Relu_4"
+  input: "SpaceToBatchND/block_shape"
+  input: "SpaceToBatchND_1/paddings"
+}
+node {
+  name: "layer_256_1_conv1/Conv2D"
+  op: "Conv2D"
+  input: "Pad_1"
+  input: "layer_256_1_conv1/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "VALID"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_256_1_bn2/FusedBatchNorm"
+  op: "BiasAdd"
+  input: "layer_256_1_conv1/Conv2D"
+  input: "layer_256_1_conv1/Conv2D_bn_offset"
+}
+node {
+  name: "BatchToSpaceND_1"
+  op: "BatchToSpaceND"
+  input: "layer_256_1_bn2/FusedBatchNorm"
+}
+node {
+  name: "layer_256_1_scale2/Mul"
+  op: "Mul"
+  input: "BatchToSpaceND_1"
+  input: "layer_256_1_scale2/mul"
+}
+node {
+  name: "layer_256_1_scale2/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_256_1_scale2/Mul"
+  input: "layer_256_1_scale2/add"
+}
+node {
+  name: "Relu_5"
+  op: "Relu"
+  input: "layer_256_1_scale2/BiasAdd"
+}
+node {
+  name: "layer_256_1_conv2/Conv2D"
+  op: "Conv2D"
+  input: "Relu_5"
+  input: "layer_256_1_conv2/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "add_2"
+  op: "Add"
+  input: "layer_256_1_conv2/Conv2D"
+  input: "layer_256_1_conv_expand/Conv2D"
+}
+node {
+  name: "layer_512_1_bn1/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "add_2"
+  input: "layer_512_1_bn1/gamma"
+  input: "layer_512_1_bn1/beta"
+  input: "layer_512_1_bn1/mean"
+  input: "layer_512_1_bn1/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "layer_512_1_scale1/Mul"
+  op: "Mul"
+  input: "layer_512_1_bn1/FusedBatchNorm"
+  input: "layer_512_1_scale1/mul"
+}
+node {
+  name: "layer_512_1_scale1/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_512_1_scale1/Mul"
+  input: "layer_512_1_scale1/add"
+}
+node {
+  name: "Relu_6"
+  op: "Relu"
+  input: "layer_512_1_scale1/BiasAdd"
+}
+node {
+  name: "layer_512_1_conv_expand_h/Conv2D"
+  op: "Conv2D"
+  input: "Relu_6"
+  input: "layer_512_1_conv_expand_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_512_1_conv1_h/Conv2D"
+  op: "Conv2D"
+  input: "Relu_6"
+  input: "layer_512_1_conv1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_512_1_bn2_h/FusedBatchNorm"
+  op: "BiasAdd"
+  input: "layer_512_1_conv1_h/Conv2D"
+  input: "layer_512_1_conv1_h/Conv2D_bn_offset"
+}
+node {
+  name: "layer_512_1_scale2_h/Mul"
+  op: "Mul"
+  input: "layer_512_1_bn2_h/FusedBatchNorm"
+  input: "layer_512_1_scale2_h/mul"
+}
+node {
+  name: "layer_512_1_scale2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "layer_512_1_scale2_h/Mul"
+  input: "layer_512_1_scale2_h/add"
+}
+node {
+  name: "Relu_7"
+  op: "Relu"
+  input: "layer_512_1_scale2_h/BiasAdd"
+}
+node {
+  name: "layer_512_1_conv2_h/convolution/SpaceToBatchND"
+  op: "SpaceToBatchND"
+  input: "Relu_7"
+  input: "layer_512_1_conv2_h/convolution/SpaceToBatchND/block_shape"
+  input: "layer_512_1_conv2_h/convolution/SpaceToBatchND/paddings"
+}
+node {
+  name: "layer_512_1_conv2_h/convolution"
+  op: "Conv2D"
+  input: "layer_512_1_conv2_h/convolution/SpaceToBatchND"
+  input: "layer_512_1_conv2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "VALID"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "layer_512_1_conv2_h/convolution/BatchToSpaceND"
+  op: "BatchToSpaceND"
+  input: "layer_512_1_conv2_h/convolution"
+  input: "layer_512_1_conv2_h/convolution/BatchToSpaceND/block_shape"
+  input: "layer_512_1_conv2_h/convolution/BatchToSpaceND/crops"
+}
+node {
+  name: "add_3"
+  op: "Add"
+  input: "layer_512_1_conv2_h/convolution/BatchToSpaceND"
+  input: "layer_512_1_conv_expand_h/Conv2D"
+}
+node {
+  name: "last_bn_h/FusedBatchNorm"
+  op: "FusedBatchNorm"
+  input: "add_3"
+  input: "last_bn_h/gamma"
+  input: "last_bn_h/beta"
+  input: "last_bn_h/mean"
+  input: "last_bn_h/std"
+  attr {
+    key: "epsilon"
+    value {
+      f: 1.00099996416e-05
+    }
+  }
+}
+node {
+  name: "last_scale_h/Mul"
+  op: "Mul"
+  input: "last_bn_h/FusedBatchNorm"
+  input: "last_scale_h/mul"
+}
+node {
+  name: "last_scale_h/BiasAdd"
+  op: "BiasAdd"
+  input: "last_scale_h/Mul"
+  input: "last_scale_h/add"
+}
+node {
+  name: "last_relu"
+  op: "Relu"
+  input: "last_scale_h/BiasAdd"
+}
+node {
+  name: "conv6_1_h/Conv2D"
+  op: "Conv2D"
+  input: "last_relu"
+  input: "conv6_1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv6_1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv6_1_h/Conv2D"
+  input: "conv6_1_h/bias"
+}
+node {
+  name: "conv6_1_h/Relu"
+  op: "Relu"
+  input: "conv6_1_h/BiasAdd"
+}
+node {
+  name: "conv6_2_h/Conv2D"
+  op: "Conv2D"
+  input: "conv6_1_h/Relu"
+  input: "conv6_2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv6_2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv6_2_h/Conv2D"
+  input: "conv6_2_h/bias"
+}
+node {
+  name: "conv6_2_h/Relu"
+  op: "Relu"
+  input: "conv6_2_h/BiasAdd"
+}
+node {
+  name: "conv7_1_h/Conv2D"
+  op: "Conv2D"
+  input: "conv6_2_h/Relu"
+  input: "conv7_1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv7_1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv7_1_h/Conv2D"
+  input: "conv7_1_h/bias"
+}
+node {
+  name: "conv7_1_h/Relu"
+  op: "Relu"
+  input: "conv7_1_h/BiasAdd"
+}
+node {
+  name: "Pad_2"
+  op: "SpaceToBatchND"
+  input: "conv7_1_h/Relu"
+  input: "SpaceToBatchND/block_shape"
+  input: "SpaceToBatchND_1/paddings"
+}
+node {
+  name: "conv7_2_h/Conv2D"
+  op: "Conv2D"
+  input: "Pad_2"
+  input: "conv7_2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "VALID"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 2
+        i: 2
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv7_2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv7_2_h/Conv2D"
+  input: "conv7_2_h/bias"
+}
+node {
+  name: "BatchToSpaceND_2"
+  op: "BatchToSpaceND"
+  input: "conv7_2_h/BiasAdd"
+}
+node {
+  name: "conv7_2_h/Relu"
+  op: "Relu"
+  input: "BatchToSpaceND_2"
+}
+node {
+  name: "conv8_1_h/Conv2D"
+  op: "Conv2D"
+  input: "conv7_2_h/Relu"
+  input: "conv8_1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv8_1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv8_1_h/Conv2D"
+  input: "conv8_1_h/bias"
+}
+node {
+  name: "conv8_1_h/Relu"
+  op: "Relu"
+  input: "conv8_1_h/BiasAdd"
+}
+node {
+  name: "conv8_2_h/Conv2D"
+  op: "Conv2D"
+  input: "conv8_1_h/Relu"
+  input: "conv8_2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "VALID"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv8_2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv8_2_h/Conv2D"
+  input: "conv8_2_h/bias"
+}
+node {
+  name: "conv8_2_h/Relu"
+  op: "Relu"
+  input: "conv8_2_h/BiasAdd"
+}
+node {
+  name: "conv9_1_h/Conv2D"
+  op: "Conv2D"
+  input: "conv8_2_h/Relu"
+  input: "conv9_1_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv9_1_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv9_1_h/Conv2D"
+  input: "conv9_1_h/bias"
+}
+node {
+  name: "conv9_1_h/Relu"
+  op: "Relu"
+  input: "conv9_1_h/BiasAdd"
+}
+node {
+  name: "conv9_2_h/Conv2D"
+  op: "Conv2D"
+  input: "conv9_1_h/Relu"
+  input: "conv9_2_h/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "VALID"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv9_2_h/BiasAdd"
+  op: "BiasAdd"
+  input: "conv9_2_h/Conv2D"
+  input: "conv9_2_h/bias"
+}
+node {
+  name: "conv9_2_h/Relu"
+  op: "Relu"
+  input: "conv9_2_h/BiasAdd"
+}
+node {
+  name: "conv9_2_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "conv9_2_h/Relu"
+  input: "conv9_2_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv9_2_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "conv9_2_mbox_loc/Conv2D"
+  input: "conv9_2_mbox_loc/bias"
+}
+node {
+  name: "flatten_5/Reshape"
+  op: "Flatten"
+  input: "conv9_2_mbox_loc/BiasAdd"
+}
+node {
+  name: "conv9_2_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "conv9_2_h/Relu"
+  input: "conv9_2_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv9_2_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "conv9_2_mbox_conf/Conv2D"
+  input: "conv9_2_mbox_conf/bias"
+}
+node {
+  name: "flatten_11/Reshape"
+  op: "Flatten"
+  input: "conv9_2_mbox_conf/BiasAdd"
+}
+node {
+  name: "conv8_2_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "conv8_2_h/Relu"
+  input: "conv8_2_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv8_2_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "conv8_2_mbox_loc/Conv2D"
+  input: "conv8_2_mbox_loc/bias"
+}
+node {
+  name: "flatten_4/Reshape"
+  op: "Flatten"
+  input: "conv8_2_mbox_loc/BiasAdd"
+}
+node {
+  name: "conv8_2_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "conv8_2_h/Relu"
+  input: "conv8_2_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv8_2_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "conv8_2_mbox_conf/Conv2D"
+  input: "conv8_2_mbox_conf/bias"
+}
+node {
+  name: "flatten_10/Reshape"
+  op: "Flatten"
+  input: "conv8_2_mbox_conf/BiasAdd"
+}
+node {
+  name: "conv7_2_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "conv7_2_h/Relu"
+  input: "conv7_2_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv7_2_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "conv7_2_mbox_loc/Conv2D"
+  input: "conv7_2_mbox_loc/bias"
+}
+node {
+  name: "flatten_3/Reshape"
+  op: "Flatten"
+  input: "conv7_2_mbox_loc/BiasAdd"
+}
+node {
+  name: "conv7_2_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "conv7_2_h/Relu"
+  input: "conv7_2_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv7_2_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "conv7_2_mbox_conf/Conv2D"
+  input: "conv7_2_mbox_conf/bias"
+}
+node {
+  name: "flatten_9/Reshape"
+  op: "Flatten"
+  input: "conv7_2_mbox_conf/BiasAdd"
+}
+node {
+  name: "conv6_2_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "conv6_2_h/Relu"
+  input: "conv6_2_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv6_2_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "conv6_2_mbox_loc/Conv2D"
+  input: "conv6_2_mbox_loc/bias"
+}
+node {
+  name: "flatten_2/Reshape"
+  op: "Flatten"
+  input: "conv6_2_mbox_loc/BiasAdd"
+}
+node {
+  name: "conv6_2_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "conv6_2_h/Relu"
+  input: "conv6_2_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "conv6_2_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "conv6_2_mbox_conf/Conv2D"
+  input: "conv6_2_mbox_conf/bias"
+}
+node {
+  name: "flatten_8/Reshape"
+  op: "Flatten"
+  input: "conv6_2_mbox_conf/BiasAdd"
+}
+node {
+  name: "fc7_mbox_loc/Conv2D"
+  op: "Conv2D"
+  input: "last_relu"
+  input: "fc7_mbox_loc/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "fc7_mbox_loc/BiasAdd"
+  op: "BiasAdd"
+  input: "fc7_mbox_loc/Conv2D"
+  input: "fc7_mbox_loc/bias"
+}
+node {
+  name: "flatten_1/Reshape"
+  op: "Flatten"
+  input: "fc7_mbox_loc/BiasAdd"
+}
+node {
+  name: "mbox_loc"
+  op: "ConcatV2"
+  input: "flatten/Reshape"
+  input: "flatten_1/Reshape"
+  input: "flatten_2/Reshape"
+  input: "flatten_3/Reshape"
+  input: "flatten_4/Reshape"
+  input: "flatten_5/Reshape"
+  input: "mbox_loc/axis"
+}
+node {
+  name: "fc7_mbox_conf/Conv2D"
+  op: "Conv2D"
+  input: "last_relu"
+  input: "fc7_mbox_conf/weights"
+  attr {
+    key: "dilations"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+  attr {
+    key: "padding"
+    value {
+      s: "SAME"
+    }
+  }
+  attr {
+    key: "strides"
+    value {
+      list {
+        i: 1
+        i: 1
+        i: 1
+        i: 1
+      }
+    }
+  }
+}
+node {
+  name: "fc7_mbox_conf/BiasAdd"
+  op: "BiasAdd"
+  input: "fc7_mbox_conf/Conv2D"
+  input: "fc7_mbox_conf/bias"
+}
+node {
+  name: "flatten_7/Reshape"
+  op: "Flatten"
+  input: "fc7_mbox_conf/BiasAdd"
+}
+node {
+  name: "mbox_conf"
+  op: "ConcatV2"
+  input: "flatten_6/Reshape"
+  input: "flatten_7/Reshape"
+  input: "flatten_8/Reshape"
+  input: "flatten_9/Reshape"
+  input: "flatten_10/Reshape"
+  input: "flatten_11/Reshape"
+  input: "mbox_conf/axis"
+}
+node {
+  name: "mbox_conf_reshape"
+  op: "Reshape"
+  input: "mbox_conf"
+  input: "reshape_before_softmax"
+}
+node {
+  name: "mbox_conf_softmax"
+  op: "Softmax"
+  input: "mbox_conf_reshape"
+  attr {
+    key: "axis"
+    value {
+      i: 2
+    }
+  }
+}
+node {
+  name: "mbox_conf_flatten"
+  op: "Flatten"
+  input: "mbox_conf_softmax"
+}
+node {
+  name: "PriorBox_0"
+  op: "PriorBox"
+  input: "conv4_3_norm/mul_1"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 1
+          }
+        }
+        float_val: 2.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 60
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 30
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 8.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "PriorBox_1"
+  op: "PriorBox"
+  input: "last_relu"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 2
+          }
+        }
+        float_val: 2.0
+        float_val: 3.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 111
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 60
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 16.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "PriorBox_2"
+  op: "PriorBox"
+  input: "conv6_2_h/Relu"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 2
+          }
+        }
+        float_val: 2.0
+        float_val: 3.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 162
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 111
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 32.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "PriorBox_3"
+  op: "PriorBox"
+  input: "conv7_2_h/Relu"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 2
+          }
+        }
+        float_val: 2.0
+        float_val: 3.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 213
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 162
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 64.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "PriorBox_4"
+  op: "PriorBox"
+  input: "conv8_2_h/Relu"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 1
+          }
+        }
+        float_val: 2.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 264
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 213
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 100.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "PriorBox_5"
+  op: "PriorBox"
+  input: "conv9_2_h/Relu"
+  input: "data"
+  attr {
+    key: "aspect_ratio"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 1
+          }
+        }
+        float_val: 2.0
+      }
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: false
+    }
+  }
+  attr {
+    key: "flip"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "max_size"
+    value {
+      i: 315
+    }
+  }
+  attr {
+    key: "min_size"
+    value {
+      i: 264
+    }
+  }
+  attr {
+    key: "offset"
+    value {
+      f: 0.5
+    }
+  }
+  attr {
+    key: "step"
+    value {
+      f: 300.0
+    }
+  }
+  attr {
+    key: "variance"
+    value {
+      tensor {
+        dtype: DT_FLOAT
+        tensor_shape {
+          dim {
+            size: 4
+          }
+        }
+        float_val: 0.10000000149
+        float_val: 0.10000000149
+        float_val: 0.20000000298
+        float_val: 0.20000000298
+      }
+    }
+  }
+}
+node {
+  name: "mbox_priorbox"
+  op: "ConcatV2"
+  input: "PriorBox_0"
+  input: "PriorBox_1"
+  input: "PriorBox_2"
+  input: "PriorBox_3"
+  input: "PriorBox_4"
+  input: "PriorBox_5"
+  input: "mbox_loc/axis"
+}
+node {
+  name: "detection_out"
+  op: "DetectionOutput"
+  input: "mbox_loc"
+  input: "mbox_conf_flatten"
+  input: "mbox_priorbox"
+  attr {
+    key: "background_label_id"
+    value {
+      i: 0
+    }
+  }
+  attr {
+    key: "code_type"
+    value {
+      s: "CENTER_SIZE"
+    }
+  }
+  attr {
+    key: "confidence_threshold"
+    value {
+      f: 0.00999999977648
+    }
+  }
+  attr {
+    key: "keep_top_k"
+    value {
+      i: 200
+    }
+  }
+  attr {
+    key: "nms_threshold"
+    value {
+      f: 0.449999988079
+    }
+  }
+  attr {
+    key: "num_classes"
+    value {
+      i: 2
+    }
+  }
+  attr {
+    key: "share_location"
+    value {
+      b: true
+    }
+  }
+  attr {
+    key: "top_k"
+    value {
+      i: 400
+    }
+  }
+  attr {
+    key: "clip"
+    value {
+      b: true
+    }
+  }
+}
+node {
+  name: "reshape_before_softmax"
+  op: "Const"
+  attr {
+    key: "value"
+    value {
+      tensor {
+        dtype: DT_INT32
+        tensor_shape {
+          dim {
+            size: 3
+          }
+        }
+        int_val: 0
+        int_val: -1
+        int_val: 2
+      }
+    }
+  }
+}
+library {
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/face_detector/solver.prototxt b/C++/opencv-4.7.0/samples/dnn/face_detector/solver.prototxt
new file mode 100644
index 00000000..04bbc2ab
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/face_detector/solver.prototxt
@@ -0,0 +1,28 @@
+train_net: "train.prototxt"
+test_net: "test.prototxt"
+
+test_iter: 2312
+test_interval: 5000
+test_initialization: true
+
+base_lr: 0.01
+display: 10
+lr_policy: "multistep"
+max_iter: 140000
+stepvalue: 80000
+stepvalue: 120000
+gamma: 0.1
+momentum: 0.9
+weight_decay: 0.0005
+average_loss: 500
+iter_size: 1
+type: "SGD"
+
+solver_mode: GPU
+random_seed: 0
+debug_info: false
+snapshot: 1000
+snapshot_prefix: "snapshot/res10_300x300_ssd"
+
+eval_type: "detection"
+ap_version: "11point"
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/dnn/face_detector/test.prototxt b/C++/opencv-4.7.0/samples/dnn/face_detector/test.prototxt
new file mode 100644
index 00000000..b441698e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/face_detector/test.prototxt
@@ -0,0 +1,1831 @@
+layer {
+  name: "data"
+  type: "AnnotatedData"
+  top: "data"
+  top: "label"
+  include {
+    phase: TEST
+  }
+  transform_param {
+    mean_value: 104
+    mean_value: 117
+    mean_value: 123
+    resize_param {
+      prob: 1
+      resize_mode: WARP
+      height: 300
+      width: 300
+      interp_mode: LINEAR
+    }
+    emit_constraint {
+      emit_type: CENTER
+    }
+  }
+  data_param {
+    source: "val_lmdb/"
+    batch_size: 1
+    backend: LMDB
+  }
+  annotated_data_param {
+    label_map_file: "labelmap.prototxt"
+  }
+}
+
+layer {
+  name: "data_bn"
+  type: "BatchNorm"
+  bottom: "data"
+  top: "data_bn"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "data_scale"
+  type: "Scale"
+  bottom: "data_bn"
+  top: "data_bn"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "conv1_h"
+  type: "Convolution"
+  bottom: "data_bn"
+  top: "conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    pad: 3
+    kernel_size: 7
+    stride: 2
+    weight_filler {
+      type: "msra"
+      variance_norm: FAN_OUT
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "conv1_bn_h"
+  type: "BatchNorm"
+  bottom: "conv1_h"
+  top: "conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "conv1_scale_h"
+  type: "Scale"
+  bottom: "conv1_h"
+  top: "conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "conv1_relu"
+  type: "ReLU"
+  bottom: "conv1_h"
+  top: "conv1_h"
+}
+layer {
+  name: "conv1_pool"
+  type: "Pooling"
+  bottom: "conv1_h"
+  top: "conv1_pool"
+  pooling_param {
+    kernel_size: 3
+    stride: 2
+  }
+}
+layer {
+  name: "layer_64_1_conv1_h"
+  type: "Convolution"
+  bottom: "conv1_pool"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_64_1_bn2_h"
+  type: "BatchNorm"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_64_1_scale2_h"
+  type: "Scale"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_64_1_relu2"
+  type: "ReLU"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+}
+layer {
+  name: "layer_64_1_conv2_h"
+  type: "Convolution"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv2_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_64_1_sum"
+  type: "Eltwise"
+  bottom: "layer_64_1_conv2_h"
+  bottom: "conv1_pool"
+  top: "layer_64_1_sum"
+}
+layer {
+  name: "layer_128_1_bn1_h"
+  type: "BatchNorm"
+  bottom: "layer_64_1_sum"
+  top: "layer_128_1_bn1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_128_1_scale1_h"
+  type: "Scale"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_bn1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_128_1_relu1"
+  type: "ReLU"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_bn1_h"
+}
+layer {
+  name: "layer_128_1_conv1_h"
+  type: "Convolution"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_bn2"
+  type: "BatchNorm"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_128_1_scale2"
+  type: "Scale"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_128_1_relu2"
+  type: "ReLU"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+}
+layer {
+  name: "layer_128_1_conv2"
+  type: "Convolution"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv2"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_conv_expand_h"
+  type: "Convolution"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_conv_expand_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_sum"
+  type: "Eltwise"
+  bottom: "layer_128_1_conv2"
+  bottom: "layer_128_1_conv_expand_h"
+  top: "layer_128_1_sum"
+}
+layer {
+  name: "layer_256_1_bn1"
+  type: "BatchNorm"
+  bottom: "layer_128_1_sum"
+  top: "layer_256_1_bn1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_256_1_scale1"
+  type: "Scale"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_bn1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_256_1_relu1"
+  type: "ReLU"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_bn1"
+}
+layer {
+  name: "layer_256_1_conv1"
+  type: "Convolution"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_bn2"
+  type: "BatchNorm"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_256_1_scale2"
+  type: "Scale"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_256_1_relu2"
+  type: "ReLU"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+}
+layer {
+  name: "layer_256_1_conv2"
+  type: "Convolution"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv2"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_conv_expand"
+  type: "Convolution"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_conv_expand"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_sum"
+  type: "Eltwise"
+  bottom: "layer_256_1_conv2"
+  bottom: "layer_256_1_conv_expand"
+  top: "layer_256_1_sum"
+}
+layer {
+  name: "layer_512_1_bn1"
+  type: "BatchNorm"
+  bottom: "layer_256_1_sum"
+  top: "layer_512_1_bn1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_512_1_scale1"
+  type: "Scale"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_bn1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_512_1_relu1"
+  type: "ReLU"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_bn1"
+}
+layer {
+  name: "layer_512_1_conv1_h"
+  type: "Convolution"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1 # 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_bn2_h"
+  type: "BatchNorm"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_512_1_scale2_h"
+  type: "Scale"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_512_1_relu2"
+  type: "ReLU"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+}
+layer {
+  name: "layer_512_1_conv2_h"
+  type: "Convolution"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv2_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 2 # 1
+    kernel_size: 3
+    stride: 1
+    dilation: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_conv_expand_h"
+  type: "Convolution"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_conv_expand_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 1 # 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_sum"
+  type: "Eltwise"
+  bottom: "layer_512_1_conv2_h"
+  bottom: "layer_512_1_conv_expand_h"
+  top: "layer_512_1_sum"
+}
+layer {
+  name: "last_bn_h"
+  type: "BatchNorm"
+  bottom: "layer_512_1_sum"
+  top: "layer_512_1_sum"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "last_scale_h"
+  type: "Scale"
+  bottom: "layer_512_1_sum"
+  top: "layer_512_1_sum"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "last_relu"
+  type: "ReLU"
+  bottom: "layer_512_1_sum"
+  top: "fc7"
+}
+
+layer {
+  name: "conv6_1_h"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "conv6_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_1_relu"
+  type: "ReLU"
+  bottom: "conv6_1_h"
+  top: "conv6_1_h"
+}
+layer {
+  name: "conv6_2_h"
+  type: "Convolution"
+  bottom: "conv6_1_h"
+  top: "conv6_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_relu"
+  type: "ReLU"
+  bottom: "conv6_2_h"
+  top: "conv6_2_h"
+}
+layer {
+  name: "conv7_1_h"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv7_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_1_relu"
+  type: "ReLU"
+  bottom: "conv7_1_h"
+  top: "conv7_1_h"
+}
+layer {
+  name: "conv7_2_h"
+  type: "Convolution"
+  bottom: "conv7_1_h"
+  top: "conv7_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_relu"
+  type: "ReLU"
+  bottom: "conv7_2_h"
+  top: "conv7_2_h"
+}
+layer {
+  name: "conv8_1_h"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv8_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_1_relu"
+  type: "ReLU"
+  bottom: "conv8_1_h"
+  top: "conv8_1_h"
+}
+layer {
+  name: "conv8_2_h"
+  type: "Convolution"
+  bottom: "conv8_1_h"
+  top: "conv8_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_relu"
+  type: "ReLU"
+  bottom: "conv8_2_h"
+  top: "conv8_2_h"
+}
+layer {
+  name: "conv9_1_h"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv9_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_1_relu"
+  type: "ReLU"
+  bottom: "conv9_1_h"
+  top: "conv9_1_h"
+}
+layer {
+  name: "conv9_2_h"
+  type: "Convolution"
+  bottom: "conv9_1_h"
+  top: "conv9_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_2_relu"
+  type: "ReLU"
+  bottom: "conv9_2_h"
+  top: "conv9_2_h"
+}
+layer {
+  name: "conv4_3_norm"
+  type: "Normalize"
+  bottom: "layer_256_1_bn1"
+  top: "conv4_3_norm"
+  norm_param {
+    across_spatial: false
+    scale_filler {
+      type: "constant"
+      value: 20
+    }
+    channel_shared: false
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc"
+  type: "Convolution"
+  bottom: "conv4_3_norm"
+  top: "conv4_3_norm_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv4_3_norm_mbox_loc"
+  top: "conv4_3_norm_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv4_3_norm_mbox_loc_perm"
+  top: "conv4_3_norm_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf"
+  type: "Convolution"
+  bottom: "conv4_3_norm"
+  top: "conv4_3_norm_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv4_3_norm_mbox_conf"
+  top: "conv4_3_norm_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv4_3_norm_mbox_conf_perm"
+  top: "conv4_3_norm_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv4_3_norm"
+  bottom: "data"
+  top: "conv4_3_norm_mbox_priorbox"
+  prior_box_param {
+    min_size: 30.0
+    max_size: 60.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 8
+    offset: 0.5
+  }
+}
+layer {
+  name: "fc7_mbox_loc"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "fc7_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "fc7_mbox_loc_perm"
+  type: "Permute"
+  bottom: "fc7_mbox_loc"
+  top: "fc7_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "fc7_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "fc7_mbox_loc_perm"
+  top: "fc7_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "fc7_mbox_conf"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "fc7_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "fc7_mbox_conf_perm"
+  type: "Permute"
+  bottom: "fc7_mbox_conf"
+  top: "fc7_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "fc7_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "fc7_mbox_conf_perm"
+  top: "fc7_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "fc7_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "fc7"
+  bottom: "data"
+  top: "fc7_mbox_priorbox"
+  prior_box_param {
+    min_size: 60.0
+    max_size: 111.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 16
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv6_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv6_2_mbox_loc"
+  top: "conv6_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv6_2_mbox_loc_perm"
+  top: "conv6_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv6_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv6_2_mbox_conf"
+  top: "conv6_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv6_2_mbox_conf_perm"
+  top: "conv6_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv6_2_h"
+  bottom: "data"
+  top: "conv6_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 111.0
+    max_size: 162.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 32
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv7_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv7_2_mbox_loc"
+  top: "conv7_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv7_2_mbox_loc_perm"
+  top: "conv7_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv7_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv7_2_mbox_conf"
+  top: "conv7_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv7_2_mbox_conf_perm"
+  top: "conv7_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv7_2_h"
+  bottom: "data"
+  top: "conv7_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 162.0
+    max_size: 213.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 64
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv8_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv8_2_mbox_loc"
+  top: "conv8_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv8_2_mbox_loc_perm"
+  top: "conv8_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv8_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv8_2_mbox_conf"
+  top: "conv8_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv8_2_mbox_conf_perm"
+  top: "conv8_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv8_2_h"
+  bottom: "data"
+  top: "conv8_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 213.0
+    max_size: 264.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 100
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv9_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv9_2_h"
+  top: "conv9_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv9_2_mbox_loc"
+  top: "conv9_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv9_2_mbox_loc_perm"
+  top: "conv9_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv9_2_h"
+  top: "conv9_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv9_2_mbox_conf"
+  top: "conv9_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv9_2_mbox_conf_perm"
+  top: "conv9_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv9_2_h"
+  bottom: "data"
+  top: "conv9_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 264.0
+    max_size: 315.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 300
+    offset: 0.5
+  }
+}
+layer {
+  name: "mbox_loc"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_loc_flat"
+  bottom: "fc7_mbox_loc_flat"
+  bottom: "conv6_2_mbox_loc_flat"
+  bottom: "conv7_2_mbox_loc_flat"
+  bottom: "conv8_2_mbox_loc_flat"
+  bottom: "conv9_2_mbox_loc_flat"
+  top: "mbox_loc"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "mbox_conf"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_conf_flat"
+  bottom: "fc7_mbox_conf_flat"
+  bottom: "conv6_2_mbox_conf_flat"
+  bottom: "conv7_2_mbox_conf_flat"
+  bottom: "conv8_2_mbox_conf_flat"
+  bottom: "conv9_2_mbox_conf_flat"
+  top: "mbox_conf"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "mbox_priorbox"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_priorbox"
+  bottom: "fc7_mbox_priorbox"
+  bottom: "conv6_2_mbox_priorbox"
+  bottom: "conv7_2_mbox_priorbox"
+  bottom: "conv8_2_mbox_priorbox"
+  bottom: "conv9_2_mbox_priorbox"
+  top: "mbox_priorbox"
+  concat_param {
+    axis: 2
+  }
+}
+
+layer {
+  name: "mbox_conf_reshape"
+  type: "Reshape"
+  bottom: "mbox_conf"
+  top: "mbox_conf_reshape"
+  reshape_param {
+    shape {
+      dim: 0
+      dim: -1
+      dim: 2
+    }
+  }
+}
+layer {
+  name: "mbox_conf_softmax"
+  type: "Softmax"
+  bottom: "mbox_conf_reshape"
+  top: "mbox_conf_softmax"
+  softmax_param {
+    axis: 2
+  }
+}
+layer {
+  name: "mbox_conf_flatten"
+  type: "Flatten"
+  bottom: "mbox_conf_softmax"
+  top: "mbox_conf_flatten"
+  flatten_param {
+    axis: 1
+  }
+}
+
+layer {
+  name: "detection_out"
+  type: "DetectionOutput"
+  bottom: "mbox_loc"
+  bottom: "mbox_conf_flatten"
+  bottom: "mbox_priorbox"
+  top: "detection_out"
+  include {
+    phase: TEST
+  }
+  detection_output_param {
+    num_classes: 2
+    share_location: true
+    background_label_id: 0
+    nms_param {
+      nms_threshold: 0.45
+      top_k: 400
+    }
+    code_type: CENTER_SIZE
+    keep_top_k: 200
+    confidence_threshold: 0.01
+    clip: 1
+  }
+}
+layer {
+  name: "detection_eval"
+  type: "DetectionEvaluate"
+  bottom: "detection_out"
+  bottom: "label"
+  top: "detection_eval"
+  include {
+    phase: TEST
+  }
+  detection_evaluate_param {
+    num_classes: 2
+    background_label_id: 0
+    overlap_threshold: 0.5
+    evaluate_difficult_gt: false
+  }
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/face_detector/train.prototxt b/C++/opencv-4.7.0/samples/dnn/face_detector/train.prototxt
new file mode 100644
index 00000000..0bba9cb3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/face_detector/train.prototxt
@@ -0,0 +1,1898 @@
+layer {
+  name: "data"
+  type: "AnnotatedData"
+  top: "data"
+  top: "label"
+  include {
+    phase: TRAIN
+  }
+  transform_param {
+    mirror: true
+    mean_value: 104
+    mean_value: 117
+    mean_value: 123
+    resize_param {
+      prob: 1
+      resize_mode: WARP
+      height: 300
+      width: 300
+      interp_mode: LINEAR
+      interp_mode: AREA
+      interp_mode: NEAREST
+      interp_mode: CUBIC
+      interp_mode: LANCZOS4
+    }
+    emit_constraint {
+      emit_type: CENTER
+    }
+    distort_param {
+      brightness_prob: 0.5
+      brightness_delta: 32
+      contrast_prob: 0.5
+      contrast_lower: 0.5
+      contrast_upper: 1.5
+      hue_prob: 0.5
+      hue_delta: 18
+      saturation_prob: 0.5
+      saturation_lower: 0.5
+      saturation_upper: 1.5
+      random_order_prob: 0.0
+    }
+    expand_param {
+      prob: 0.5
+      max_expand_ratio: 4.0
+    }
+  }
+  data_param {
+    source: "train_lmdb/"
+    batch_size: 16
+    backend: LMDB
+  }
+  annotated_data_param {
+    batch_sampler {
+      max_sample: 1
+      max_trials: 1
+    }
+    batch_sampler {
+      sampler {
+        min_scale: 0.3
+        max_scale: 1.0
+        min_aspect_ratio: 0.5
+        max_aspect_ratio: 2.0
+      }
+      sample_constraint {
+        min_jaccard_overlap: 0.1
+      }
+      max_sample: 1
+      max_trials: 50
+    }
+    batch_sampler {
+      sampler {
+        min_scale: 0.3
+        max_scale: 1.0
+        min_aspect_ratio: 0.5
+        max_aspect_ratio: 2.0
+      }
+      sample_constraint {
+        min_jaccard_overlap: 0.3
+      }
+      max_sample: 1
+      max_trials: 50
+    }
+    batch_sampler {
+      sampler {
+        min_scale: 0.3
+        max_scale: 1.0
+        min_aspect_ratio: 0.5
+        max_aspect_ratio: 2.0
+      }
+      sample_constraint {
+        min_jaccard_overlap: 0.5
+      }
+      max_sample: 1
+      max_trials: 50
+    }
+    batch_sampler {
+      sampler {
+        min_scale: 0.3
+        max_scale: 1.0
+        min_aspect_ratio: 0.5
+        max_aspect_ratio: 2.0
+      }
+      sample_constraint {
+        min_jaccard_overlap: 0.7
+      }
+      max_sample: 1
+      max_trials: 50
+    }
+    batch_sampler {
+      sampler {
+        min_scale: 0.3
+        max_scale: 1.0
+        min_aspect_ratio: 0.5
+        max_aspect_ratio: 2.0
+      }
+      sample_constraint {
+        min_jaccard_overlap: 0.9
+      }
+      max_sample: 1
+      max_trials: 50
+    }
+    batch_sampler {
+      sampler {
+        min_scale: 0.3
+        max_scale: 1.0
+        min_aspect_ratio: 0.5
+        max_aspect_ratio: 2.0
+      }
+      sample_constraint {
+        max_jaccard_overlap: 1.0
+      }
+      max_sample: 1
+      max_trials: 50
+    }
+  }
+}
+
+layer {
+  name: "data_bn"
+  type: "BatchNorm"
+  bottom: "data"
+  top: "data_bn"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "data_scale"
+  type: "Scale"
+  bottom: "data_bn"
+  top: "data_bn"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "conv1_h"
+  type: "Convolution"
+  bottom: "data_bn"
+  top: "conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    pad: 3
+    kernel_size: 7
+    stride: 2
+    weight_filler {
+      type: "msra"
+      variance_norm: FAN_OUT
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "conv1_bn_h"
+  type: "BatchNorm"
+  bottom: "conv1_h"
+  top: "conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "conv1_scale_h"
+  type: "Scale"
+  bottom: "conv1_h"
+  top: "conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "conv1_relu"
+  type: "ReLU"
+  bottom: "conv1_h"
+  top: "conv1_h"
+}
+layer {
+  name: "conv1_pool"
+  type: "Pooling"
+  bottom: "conv1_h"
+  top: "conv1_pool"
+  pooling_param {
+    kernel_size: 3
+    stride: 2
+  }
+}
+layer {
+  name: "layer_64_1_conv1_h"
+  type: "Convolution"
+  bottom: "conv1_pool"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_64_1_bn2_h"
+  type: "BatchNorm"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_64_1_scale2_h"
+  type: "Scale"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_64_1_relu2"
+  type: "ReLU"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv1_h"
+}
+layer {
+  name: "layer_64_1_conv2_h"
+  type: "Convolution"
+  bottom: "layer_64_1_conv1_h"
+  top: "layer_64_1_conv2_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 32
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_64_1_sum"
+  type: "Eltwise"
+  bottom: "layer_64_1_conv2_h"
+  bottom: "conv1_pool"
+  top: "layer_64_1_sum"
+}
+layer {
+  name: "layer_128_1_bn1_h"
+  type: "BatchNorm"
+  bottom: "layer_64_1_sum"
+  top: "layer_128_1_bn1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_128_1_scale1_h"
+  type: "Scale"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_bn1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_128_1_relu1"
+  type: "ReLU"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_bn1_h"
+}
+layer {
+  name: "layer_128_1_conv1_h"
+  type: "Convolution"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_bn2"
+  type: "BatchNorm"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_128_1_scale2"
+  type: "Scale"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_128_1_relu2"
+  type: "ReLU"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv1_h"
+}
+layer {
+  name: "layer_128_1_conv2"
+  type: "Convolution"
+  bottom: "layer_128_1_conv1_h"
+  top: "layer_128_1_conv2"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_conv_expand_h"
+  type: "Convolution"
+  bottom: "layer_128_1_bn1_h"
+  top: "layer_128_1_conv_expand_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_128_1_sum"
+  type: "Eltwise"
+  bottom: "layer_128_1_conv2"
+  bottom: "layer_128_1_conv_expand_h"
+  top: "layer_128_1_sum"
+}
+layer {
+  name: "layer_256_1_bn1"
+  type: "BatchNorm"
+  bottom: "layer_128_1_sum"
+  top: "layer_256_1_bn1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_256_1_scale1"
+  type: "Scale"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_bn1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_256_1_relu1"
+  type: "ReLU"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_bn1"
+}
+layer {
+  name: "layer_256_1_conv1"
+  type: "Convolution"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_bn2"
+  type: "BatchNorm"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_256_1_scale2"
+  type: "Scale"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_256_1_relu2"
+  type: "ReLU"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv1"
+}
+layer {
+  name: "layer_256_1_conv2"
+  type: "Convolution"
+  bottom: "layer_256_1_conv1"
+  top: "layer_256_1_conv2"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_conv_expand"
+  type: "Convolution"
+  bottom: "layer_256_1_bn1"
+  top: "layer_256_1_conv_expand"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_256_1_sum"
+  type: "Eltwise"
+  bottom: "layer_256_1_conv2"
+  bottom: "layer_256_1_conv_expand"
+  top: "layer_256_1_sum"
+}
+layer {
+  name: "layer_512_1_bn1"
+  type: "BatchNorm"
+  bottom: "layer_256_1_sum"
+  top: "layer_512_1_bn1"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_512_1_scale1"
+  type: "Scale"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_bn1"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_512_1_relu1"
+  type: "ReLU"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_bn1"
+}
+layer {
+  name: "layer_512_1_conv1_h"
+  type: "Convolution"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 128
+    bias_term: false
+    pad: 1
+    kernel_size: 3
+    stride: 1 # 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_bn2_h"
+  type: "BatchNorm"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "layer_512_1_scale2_h"
+  type: "Scale"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "layer_512_1_relu2"
+  type: "ReLU"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv1_h"
+}
+layer {
+  name: "layer_512_1_conv2_h"
+  type: "Convolution"
+  bottom: "layer_512_1_conv1_h"
+  top: "layer_512_1_conv2_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 2 # 1
+    kernel_size: 3
+    stride: 1
+    dilation: 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_conv_expand_h"
+  type: "Convolution"
+  bottom: "layer_512_1_bn1"
+  top: "layer_512_1_conv_expand_h"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  convolution_param {
+    num_output: 256
+    bias_term: false
+    pad: 0
+    kernel_size: 1
+    stride: 1 # 2
+    weight_filler {
+      type: "msra"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0.0
+    }
+  }
+}
+layer {
+  name: "layer_512_1_sum"
+  type: "Eltwise"
+  bottom: "layer_512_1_conv2_h"
+  bottom: "layer_512_1_conv_expand_h"
+  top: "layer_512_1_sum"
+}
+layer {
+  name: "last_bn_h"
+  type: "BatchNorm"
+  bottom: "layer_512_1_sum"
+  top: "layer_512_1_sum"
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+  param {
+    lr_mult: 0.0
+  }
+}
+layer {
+  name: "last_scale_h"
+  type: "Scale"
+  bottom: "layer_512_1_sum"
+  top: "layer_512_1_sum"
+  param {
+    lr_mult: 1.0
+    decay_mult: 1.0
+  }
+  param {
+    lr_mult: 2.0
+    decay_mult: 1.0
+  }
+  scale_param {
+    bias_term: true
+  }
+}
+layer {
+  name: "last_relu"
+  type: "ReLU"
+  bottom: "layer_512_1_sum"
+  top: "fc7"
+}
+
+layer {
+  name: "conv6_1_h"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "conv6_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_1_relu"
+  type: "ReLU"
+  bottom: "conv6_1_h"
+  top: "conv6_1_h"
+}
+layer {
+  name: "conv6_2_h"
+  type: "Convolution"
+  bottom: "conv6_1_h"
+  top: "conv6_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_relu"
+  type: "ReLU"
+  bottom: "conv6_2_h"
+  top: "conv6_2_h"
+}
+layer {
+  name: "conv7_1_h"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv7_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_1_relu"
+  type: "ReLU"
+  bottom: "conv7_1_h"
+  top: "conv7_1_h"
+}
+layer {
+  name: "conv7_2_h"
+  type: "Convolution"
+  bottom: "conv7_1_h"
+  top: "conv7_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+    stride: 2
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_relu"
+  type: "ReLU"
+  bottom: "conv7_2_h"
+  top: "conv7_2_h"
+}
+layer {
+  name: "conv8_1_h"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv8_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_1_relu"
+  type: "ReLU"
+  bottom: "conv8_1_h"
+  top: "conv8_1_h"
+}
+layer {
+  name: "conv8_2_h"
+  type: "Convolution"
+  bottom: "conv8_1_h"
+  top: "conv8_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_relu"
+  type: "ReLU"
+  bottom: "conv8_2_h"
+  top: "conv8_2_h"
+}
+layer {
+  name: "conv9_1_h"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv9_1_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_1_relu"
+  type: "ReLU"
+  bottom: "conv9_1_h"
+  top: "conv9_1_h"
+}
+layer {
+  name: "conv9_2_h"
+  type: "Convolution"
+  bottom: "conv9_1_h"
+  top: "conv9_2_h"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 0
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_2_relu"
+  type: "ReLU"
+  bottom: "conv9_2_h"
+  top: "conv9_2_h"
+}
+layer {
+  name: "conv4_3_norm"
+  type: "Normalize"
+  bottom: "layer_256_1_bn1"
+  top: "conv4_3_norm"
+  norm_param {
+    across_spatial: false
+    scale_filler {
+      type: "constant"
+      value: 20
+    }
+    channel_shared: false
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc"
+  type: "Convolution"
+  bottom: "conv4_3_norm"
+  top: "conv4_3_norm_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv4_3_norm_mbox_loc"
+  top: "conv4_3_norm_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv4_3_norm_mbox_loc_perm"
+  top: "conv4_3_norm_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf"
+  type: "Convolution"
+  bottom: "conv4_3_norm"
+  top: "conv4_3_norm_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv4_3_norm_mbox_conf"
+  top: "conv4_3_norm_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv4_3_norm_mbox_conf_perm"
+  top: "conv4_3_norm_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv4_3_norm_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv4_3_norm"
+  bottom: "data"
+  top: "conv4_3_norm_mbox_priorbox"
+  prior_box_param {
+    min_size: 30.0
+    max_size: 60.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 8
+    offset: 0.5
+  }
+}
+layer {
+  name: "fc7_mbox_loc"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "fc7_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "fc7_mbox_loc_perm"
+  type: "Permute"
+  bottom: "fc7_mbox_loc"
+  top: "fc7_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "fc7_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "fc7_mbox_loc_perm"
+  top: "fc7_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "fc7_mbox_conf"
+  type: "Convolution"
+  bottom: "fc7"
+  top: "fc7_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "fc7_mbox_conf_perm"
+  type: "Permute"
+  bottom: "fc7_mbox_conf"
+  top: "fc7_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "fc7_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "fc7_mbox_conf_perm"
+  top: "fc7_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "fc7_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "fc7"
+  bottom: "data"
+  top: "fc7_mbox_priorbox"
+  prior_box_param {
+    min_size: 60.0
+    max_size: 111.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 16
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv6_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv6_2_mbox_loc"
+  top: "conv6_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv6_2_mbox_loc_perm"
+  top: "conv6_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv6_2_h"
+  top: "conv6_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv6_2_mbox_conf"
+  top: "conv6_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv6_2_mbox_conf_perm"
+  top: "conv6_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv6_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv6_2_h"
+  bottom: "data"
+  top: "conv6_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 111.0
+    max_size: 162.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 32
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv7_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 24
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv7_2_mbox_loc"
+  top: "conv7_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv7_2_mbox_loc_perm"
+  top: "conv7_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv7_2_h"
+  top: "conv7_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 12 # 126
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv7_2_mbox_conf"
+  top: "conv7_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv7_2_mbox_conf_perm"
+  top: "conv7_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv7_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv7_2_h"
+  bottom: "data"
+  top: "conv7_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 162.0
+    max_size: 213.0
+    aspect_ratio: 2
+    aspect_ratio: 3
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 64
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv8_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv8_2_mbox_loc"
+  top: "conv8_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv8_2_mbox_loc_perm"
+  top: "conv8_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv8_2_h"
+  top: "conv8_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv8_2_mbox_conf"
+  top: "conv8_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv8_2_mbox_conf_perm"
+  top: "conv8_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv8_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv8_2_h"
+  bottom: "data"
+  top: "conv8_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 213.0
+    max_size: 264.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 100
+    offset: 0.5
+  }
+}
+layer {
+  name: "conv9_2_mbox_loc"
+  type: "Convolution"
+  bottom: "conv9_2_h"
+  top: "conv9_2_mbox_loc"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 16
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_2_mbox_loc_perm"
+  type: "Permute"
+  bottom: "conv9_2_mbox_loc"
+  top: "conv9_2_mbox_loc_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_loc_flat"
+  type: "Flatten"
+  bottom: "conv9_2_mbox_loc_perm"
+  top: "conv9_2_mbox_loc_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_conf"
+  type: "Convolution"
+  bottom: "conv9_2_h"
+  top: "conv9_2_mbox_conf"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 8 # 84
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "conv9_2_mbox_conf_perm"
+  type: "Permute"
+  bottom: "conv9_2_mbox_conf"
+  top: "conv9_2_mbox_conf_perm"
+  permute_param {
+    order: 0
+    order: 2
+    order: 3
+    order: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_conf_flat"
+  type: "Flatten"
+  bottom: "conv9_2_mbox_conf_perm"
+  top: "conv9_2_mbox_conf_flat"
+  flatten_param {
+    axis: 1
+  }
+}
+layer {
+  name: "conv9_2_mbox_priorbox"
+  type: "PriorBox"
+  bottom: "conv9_2_h"
+  bottom: "data"
+  top: "conv9_2_mbox_priorbox"
+  prior_box_param {
+    min_size: 264.0
+    max_size: 315.0
+    aspect_ratio: 2
+    flip: true
+    clip: false
+    variance: 0.1
+    variance: 0.1
+    variance: 0.2
+    variance: 0.2
+    step: 300
+    offset: 0.5
+  }
+}
+layer {
+  name: "mbox_loc"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_loc_flat"
+  bottom: "fc7_mbox_loc_flat"
+  bottom: "conv6_2_mbox_loc_flat"
+  bottom: "conv7_2_mbox_loc_flat"
+  bottom: "conv8_2_mbox_loc_flat"
+  bottom: "conv9_2_mbox_loc_flat"
+  top: "mbox_loc"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "mbox_conf"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_conf_flat"
+  bottom: "fc7_mbox_conf_flat"
+  bottom: "conv6_2_mbox_conf_flat"
+  bottom: "conv7_2_mbox_conf_flat"
+  bottom: "conv8_2_mbox_conf_flat"
+  bottom: "conv9_2_mbox_conf_flat"
+  top: "mbox_conf"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "mbox_priorbox"
+  type: "Concat"
+  bottom: "conv4_3_norm_mbox_priorbox"
+  bottom: "fc7_mbox_priorbox"
+  bottom: "conv6_2_mbox_priorbox"
+  bottom: "conv7_2_mbox_priorbox"
+  bottom: "conv8_2_mbox_priorbox"
+  bottom: "conv9_2_mbox_priorbox"
+  top: "mbox_priorbox"
+  concat_param {
+    axis: 2
+  }
+}
+
+layer {
+  name: "mbox_loss"
+  type: "MultiBoxLoss"
+  bottom: "mbox_loc"
+  bottom: "mbox_conf"
+  bottom: "mbox_priorbox"
+  bottom: "label"
+  top: "mbox_loss"
+  include {
+    phase: TRAIN
+  }
+  propagate_down: true
+  propagate_down: true
+  propagate_down: false
+  propagate_down: false
+  loss_param {
+    normalization: VALID
+  }
+  multibox_loss_param {
+    loc_loss_type: SMOOTH_L1
+    conf_loss_type: SOFTMAX
+    loc_weight: 1.0
+    num_classes: 2 # 21
+    share_location: true
+    match_type: PER_PREDICTION
+    overlap_threshold: 0.5
+    use_prior_for_matching: true
+    background_label_id: 0
+    use_difficult_gt: true
+    neg_pos_ratio: 3.0
+    neg_overlap: 0.5
+    code_type: CENTER_SIZE
+    ignore_cross_boundary_bbox: false
+    mining_type: MAX_NEGATIVE
+  }
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/face_detector/weights.meta4 b/C++/opencv-4.7.0/samples/dnn/face_detector/weights.meta4
new file mode 100644
index 00000000..ba75e12d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/face_detector/weights.meta4
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<metalink xmlns="urn:ietf:params:xml:ns:metalink">
+    <file name="res10_300x300_ssd_iter_140000_fp16.caffemodel">
+        <identity>opencv_face_detector_fp16</identity>
+        <hash type="sha-1">31fc22bfdd907567a04bb45b7cfad29966caddc1</hash>
+        <url>https://raw.githubusercontent.com/opencv/opencv_3rdparty/dnn_samples_face_detector_20180205_fp16/res10_300x300_ssd_iter_140000_fp16.caffemodel</url>
+    </file>
+    <file name="opencv_face_detector_uint8.pb">
+        <identity>opencv_face_detector_uint8</identity>
+        <hash type="sha-1">4f2fdf6f231d759d7bbdb94353c5a68690f3d2ae</hash>
+        <url>https://raw.githubusercontent.com/opencv/opencv_3rdparty/dnn_samples_face_detector_20180220_uint8/opencv_face_detector_uint8.pb</url>
+    </file>
+</metalink>
diff --git a/C++/opencv-4.7.0/samples/dnn/fast_neural_style.py b/C++/opencv-4.7.0/samples/dnn/fast_neural_style.py
new file mode 100644
index 00000000..912c2f08
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/fast_neural_style.py
@@ -0,0 +1,53 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(
+        description='This script is used to run style transfer models from '
+                    'https://github.com/jcjohnson/fast-neural-style using OpenCV')
+parser.add_argument('--input', help='Path to image or video. Skip to capture frames from camera')
+parser.add_argument('--model', help='Path to .t7 model')
+parser.add_argument('--width', default=-1, type=int, help='Resize input to specific width.')
+parser.add_argument('--height', default=-1, type=int, help='Resize input to specific height.')
+parser.add_argument('--median_filter', default=0, type=int, help='Kernel size of postprocessing blurring.')
+args = parser.parse_args()
+
+net = cv.dnn.readNetFromTorch(cv.samples.findFile(args.model))
+net.setPreferableBackend(cv.dnn.DNN_BACKEND_OPENCV)
+
+if args.input:
+    cap = cv.VideoCapture(args.input)
+else:
+    cap = cv.VideoCapture(0)
+
+cv.namedWindow('Styled image', cv.WINDOW_NORMAL)
+while cv.waitKey(1) < 0:
+    hasFrame, frame = cap.read()
+    if not hasFrame:
+        cv.waitKey()
+        break
+
+    inWidth = args.width if args.width != -1 else frame.shape[1]
+    inHeight = args.height if args.height != -1 else frame.shape[0]
+    inp = cv.dnn.blobFromImage(frame, 1.0, (inWidth, inHeight),
+                              (103.939, 116.779, 123.68), swapRB=False, crop=False)
+
+    net.setInput(inp)
+    out = net.forward()
+
+    out = out.reshape(3, out.shape[2], out.shape[3])
+    out[0] += 103.939
+    out[1] += 116.779
+    out[2] += 123.68
+    out /= 255
+    out = out.transpose(1, 2, 0)
+
+    t, _ = net.getPerfProfile()
+    freq = cv.getTickFrequency() / 1000
+    print(t / freq, 'ms')
+
+    if args.median_filter:
+        out = cv.medianBlur(out, args.median_filter)
+
+    cv.imshow('Styled image', out)
diff --git a/C++/opencv-4.7.0/samples/dnn/human_parsing.cpp b/C++/opencv-4.7.0/samples/dnn/human_parsing.cpp
new file mode 100644
index 00000000..0c00c028
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/human_parsing.cpp
@@ -0,0 +1,109 @@
+//
+// this sample demonstrates parsing (segmenting) human body parts from an image using opencv's dnn,
+// based on https://github.com/Engineering-Course/LIP_JPPNet
+//
+// get the pretrained model from: https://www.dropbox.com/s/qag9vzambhhkvxr/lip_jppnet_384.pb?dl=0
+//
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+using namespace cv;
+
+
+static Mat parse_human(const Mat &image, const std::string &model, int backend=dnn::DNN_BACKEND_DEFAULT, int target=dnn::DNN_TARGET_CPU) {
+    // this network expects an image and a flipped copy as input
+    Mat flipped;
+    flip(image, flipped, 1);
+    std::vector<Mat> batch;
+    batch.push_back(image);
+    batch.push_back(flipped);
+    Mat blob = dnn::blobFromImages(batch, 1.0, Size(), Scalar(104.00698793, 116.66876762, 122.67891434));
+
+    dnn::Net net = dnn::readNet(model);
+    net.setPreferableBackend(backend);
+    net.setPreferableTarget(target);
+    net.setInput(blob);
+    Mat out = net.forward();
+    // expected output: [2, 20, 384, 384], (2 lists(orig, flipped) of 20 body part heatmaps 384x384)
+
+    // LIP classes:
+    // 0 Background, 1 Hat, 2 Hair, 3 Glove, 4 Sunglasses, 5 UpperClothes, 6 Dress, 7 Coat, 8 Socks, 9 Pants
+    // 10 Jumpsuits, 11 Scarf, 12 Skirt, 13 Face, 14 LeftArm, 15 RightArm, 16 LeftLeg, 17 RightLeg, 18 LeftShoe. 19 RightShoe
+    Vec3b colors[] = {
+        Vec3b(0, 0, 0), Vec3b(128, 0, 0), Vec3b(255, 0, 0), Vec3b(0, 85, 0), Vec3b(170, 0, 51), Vec3b(255, 85, 0),
+        Vec3b(0, 0, 85), Vec3b(0, 119, 221), Vec3b(85, 85, 0), Vec3b(0, 85, 85), Vec3b(85, 51, 0), Vec3b(52, 86, 128),
+        Vec3b(0, 128, 0), Vec3b(0, 0, 255), Vec3b(51, 170, 221), Vec3b(0, 255, 255), Vec3b(85, 255, 170),
+        Vec3b(170, 255, 85), Vec3b(255, 255, 0), Vec3b(255, 170, 0)
+    };
+
+    Mat segm(image.size(), CV_8UC3, Scalar(0,0,0));
+    Mat maxval(image.size(), CV_32F, Scalar(0));
+
+    // iterate over body part heatmaps (LIP classes)
+    for (int i=0; i<out.size[1]; i++) {
+        // resize heatmaps to original image size
+        // "head" is  the original image result, "tail" the flipped copy
+        Mat head, h(out.size[2], out.size[3], CV_32F, out.ptr<float>(0,i));
+        resize(h, head, image.size());
+
+        // we have to swap the last 3 pairs in the "tail" list
+        static int tail_order[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,15,14,17,16,19,18};
+        Mat tail, t(out.size[2], out.size[3], CV_32F, out.ptr<float>(1,tail_order[i]));
+        resize(t, tail, image.size());
+        flip(tail, tail, 1);
+
+        // mix original and flipped result
+        Mat avg = (head + tail) * 0.5;
+
+        // write color if prob value > maxval
+        Mat cmask;
+        compare(avg, maxval, cmask, CMP_GT);
+        segm.setTo(colors[i], cmask);
+
+        // keep largest values for next iteration
+        max(avg, maxval, maxval);
+    }
+    cvtColor(segm, segm, COLOR_RGB2BGR);
+    return segm;
+}
+
+int main(int argc, char**argv)
+{
+    CommandLineParser parser(argc,argv,
+        "{help    h |                 | show help screen / args}"
+        "{image   i |                 | person image to process }"
+        "{model   m |lip_jppnet_384.pb| network model}"
+        "{backend b | 0               | Choose one of computation backends: "
+                                         "0: automatically (by default), "
+                                         "1: Halide language (http://halide-lang.org/), "
+                                         "2: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                                         "3: OpenCV implementation, "
+                                         "4: VKCOM, "
+                                         "5: CUDA }"
+        "{target  t | 0               | Choose one of target computation devices: "
+                                         "0: CPU target (by default), "
+                                         "1: OpenCL, "
+                                         "2: OpenCL fp16 (half-float precision), "
+                                         "3: VPU, "
+                                         "4: Vulkan, "
+                                         "6: CUDA, "
+                                         "7: CUDA fp16 (half-float preprocess) }"
+    );
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    std::string model = parser.get<std::string>("model");
+    std::string image = parser.get<std::string>("image");
+    int backend = parser.get<int>("backend");
+    int target = parser.get<int>("target");
+
+    Mat input = imread(image);
+    Mat segm = parse_human(input, model, backend, target);
+
+    imshow("human parsing", segm);
+    waitKey();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/human_parsing.py b/C++/opencv-4.7.0/samples/dnn/human_parsing.py
new file mode 100644
index 00000000..237f764b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/human_parsing.py
@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+'''
+You can download the converted pb model from https://www.dropbox.com/s/qag9vzambhhkvxr/lip_jppnet_384.pb?dl=0
+or convert the model yourself.
+
+Follow these steps if you want to convert the original model yourself:
+    To get original .meta pre-trained model download https://drive.google.com/file/d/1BFVXgeln-bek8TCbRjN6utPAgRE0LJZg/view
+    For correct convert .meta to .pb model download original repository https://github.com/Engineering-Course/LIP_JPPNet
+    Change script evaluate_parsing_JPPNet-s2.py for human parsing
+    1. Remove preprocessing to create image_batch_origin:
+        with tf.name_scope("create_inputs"):
+        ...
+    Add
+        image_batch_origin = tf.placeholder(tf.float32, shape=(2, None, None, 3), name='input')
+
+    2. Create input
+        image = cv2.imread(path/to/image)
+        image_rev = np.flip(image, axis=1)
+        input = np.stack([image, image_rev], axis=0)
+
+    3. Hardcode image_h and image_w shapes to determine output shapes.
+       We use default INPUT_SIZE = (384, 384) from evaluate_parsing_JPPNet-s2.py.
+        parsing_out1 = tf.reduce_mean(tf.stack([tf.image.resize_images(parsing_out1_100, INPUT_SIZE),
+                                                tf.image.resize_images(parsing_out1_075, INPUT_SIZE),
+                                                tf.image.resize_images(parsing_out1_125, INPUT_SIZE)]), axis=0)
+       Do similarly with parsing_out2, parsing_out3
+    4. Remove postprocessing. Last net operation:
+        raw_output = tf.reduce_mean(tf.stack([parsing_out1, parsing_out2, parsing_out3]), axis=0)
+       Change:
+        parsing_ = sess.run(raw_output, feed_dict={'input:0': input})
+
+    5. To save model after sess.run(...) add:
+        input_graph_def = tf.get_default_graph().as_graph_def()
+        output_node = "Mean_3"
+        output_graph_def = tf.graph_util.convert_variables_to_constants(sess, input_graph_def, output_node)
+
+        output_graph = "LIP_JPPNet.pb"
+        with tf.gfile.GFile(output_graph, "wb") as f:
+            f.write(output_graph_def.SerializeToString())'
+'''
+
+import argparse
+import os.path
+import numpy as np
+import cv2 as cv
+
+
+backends = (cv.dnn.DNN_BACKEND_DEFAULT, cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_BACKEND_OPENCV,
+            cv.dnn.DNN_BACKEND_VKCOM, cv.dnn.DNN_BACKEND_CUDA)
+targets = (cv.dnn.DNN_TARGET_CPU, cv.dnn.DNN_TARGET_OPENCL, cv.dnn.DNN_TARGET_OPENCL_FP16, cv.dnn.DNN_TARGET_MYRIAD,
+           cv.dnn.DNN_TARGET_HDDL, cv.dnn.DNN_TARGET_VULKAN, cv.dnn.DNN_TARGET_CUDA, cv.dnn.DNN_TARGET_CUDA_FP16)
+
+
+def preprocess(image):
+    """
+    Create 4-dimensional blob from image and flip image
+    :param image: input image
+    """
+    image_rev = np.flip(image, axis=1)
+    input = cv.dnn.blobFromImages([image, image_rev], mean=(104.00698793, 116.66876762, 122.67891434))
+    return input
+
+
+def run_net(input, model_path, backend, target):
+    """
+    Read network and infer model
+    :param model_path: path to JPPNet model
+    :param backend: computation backend
+    :param target: computation device
+    """
+    net = cv.dnn.readNet(model_path)
+    net.setPreferableBackend(backend)
+    net.setPreferableTarget(target)
+    net.setInput(input)
+    out = net.forward()
+    return out
+
+
+def postprocess(out, input_shape):
+    """
+    Create a grayscale human segmentation
+    :param out: network output
+    :param input_shape: input image width and height
+    """
+    # LIP classes
+    # 0 Background
+    # 1 Hat
+    # 2 Hair
+    # 3 Glove
+    # 4 Sunglasses
+    # 5 UpperClothes
+    # 6 Dress
+    # 7 Coat
+    # 8 Socks
+    # 9 Pants
+    # 10 Jumpsuits
+    # 11 Scarf
+    # 12 Skirt
+    # 13 Face
+    # 14 LeftArm
+    # 15 RightArm
+    # 16 LeftLeg
+    # 17 RightLeg
+    # 18 LeftShoe
+    # 19 RightShoe
+    head_output, tail_output = np.split(out, indices_or_sections=[1], axis=0)
+    head_output = head_output.squeeze(0)
+    tail_output = tail_output.squeeze(0)
+
+    head_output = np.stack([cv.resize(img, dsize=input_shape) for img in head_output[:, ...]])
+    tail_output = np.stack([cv.resize(img, dsize=input_shape) for img in tail_output[:, ...]])
+
+    tail_list = np.split(tail_output, indices_or_sections=list(range(1, 20)), axis=0)
+    tail_list = [arr.squeeze(0) for arr in tail_list]
+    tail_list_rev = [tail_list[i] for i in range(14)]
+    tail_list_rev.extend([tail_list[15], tail_list[14], tail_list[17], tail_list[16], tail_list[19], tail_list[18]])
+    tail_output_rev = np.stack(tail_list_rev, axis=0)
+    tail_output_rev = np.flip(tail_output_rev, axis=2)
+    raw_output_all = np.mean(np.stack([head_output, tail_output_rev], axis=0), axis=0, keepdims=True)
+    raw_output_all = np.argmax(raw_output_all, axis=1)
+    raw_output_all = raw_output_all.transpose(1, 2, 0)
+    return raw_output_all
+
+
+def decode_labels(gray_image):
+    """
+    Colorize image according to labels
+    :param gray_image: grayscale human segmentation result
+    """
+    height, width, _ = gray_image.shape
+    colors = [(0, 0, 0), (128, 0, 0), (255, 0, 0), (0, 85, 0), (170, 0, 51), (255, 85, 0),
+              (0, 0, 85), (0, 119, 221), (85, 85, 0), (0, 85, 85), (85, 51, 0), (52, 86, 128),
+              (0, 128, 0), (0, 0, 255), (51, 170, 221), (0, 255, 255),(85, 255, 170),
+              (170, 255, 85), (255, 255, 0), (255, 170, 0)]
+
+    segm = np.stack([colors[idx] for idx in gray_image.flatten()])
+    segm = segm.reshape(height, width, 3).astype(np.uint8)
+    segm = cv.cvtColor(segm, cv.COLOR_BGR2RGB)
+    return segm
+
+
+def parse_human(image, model_path, backend=cv.dnn.DNN_BACKEND_OPENCV, target=cv.dnn.DNN_TARGET_CPU):
+    """
+    Prepare input for execution, run net and postprocess output to parse human.
+    :param image: input image
+    :param model_path: path to JPPNet model
+    :param backend: name of computation backend
+    :param target: name of computation target
+    """
+    input = preprocess(image)
+    input_h, input_w = input.shape[2:]
+    output = run_net(input, model_path, backend, target)
+    grayscale_out = postprocess(output, (input_w, input_h))
+    segmentation = decode_labels(grayscale_out)
+    return segmentation
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Use this script to run human parsing using JPPNet',
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('--input', '-i', required=True, help='Path to input image.')
+    parser.add_argument('--model', '-m', default='lip_jppnet_384.pb', help='Path to pb model.')
+    parser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,
+                        help="Choose one of computation backends: "
+                             "%d: automatically (by default), "
+                             "%d: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                             "%d: OpenCV implementation, "
+                             "%d: VKCOM, "
+                             "%d: CUDA"% backends)
+    parser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,
+                        help='Choose one of target computation devices: '
+                             '%d: CPU target (by default), '
+                             '%d: OpenCL, '
+                             '%d: OpenCL fp16 (half-float precision), '
+                             '%d: NCS2 VPU, '
+                             '%d: HDDL VPU, '
+                             '%d: Vulkan, '
+                             '%d: CUDA, '
+                             '%d: CUDA fp16 (half-float preprocess)' % targets)
+    args, _ = parser.parse_known_args()
+
+    if not os.path.isfile(args.model):
+        raise OSError("Model not exist")
+
+    image = cv.imread(args.input)
+    output = parse_human(image, args.model, args.backend, args.target)
+    winName = 'Deep learning human parsing in OpenCV'
+    cv.namedWindow(winName, cv.WINDOW_AUTOSIZE)
+    cv.imshow(winName, output)
+    cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/dnn/js_face_recognition.html b/C++/opencv-4.7.0/samples/dnn/js_face_recognition.html
new file mode 100644
index 00000000..d94ead1e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/js_face_recognition.html
@@ -0,0 +1,205 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+  <script async src="../../opencv.js" type="text/javascript"></script>
+  <script src="../../utils.js" type="text/javascript"></script>
+
+<script type='text/javascript'>
+var netDet = undefined, netRecogn = undefined;
+var persons = {};
+
+//! [Run face detection model]
+function detectFaces(img) {
+  var blob = cv.blobFromImage(img, 1, {width: 192, height: 144}, [104, 117, 123, 0], false, false);
+  netDet.setInput(blob);
+  var out = netDet.forward();
+
+  var faces = [];
+  for (var i = 0, n = out.data32F.length; i < n; i += 7) {
+    var confidence = out.data32F[i + 2];
+    var left = out.data32F[i + 3] * img.cols;
+    var top = out.data32F[i + 4] * img.rows;
+    var right = out.data32F[i + 5] * img.cols;
+    var bottom = out.data32F[i + 6] * img.rows;
+    left = Math.min(Math.max(0, left), img.cols - 1);
+    right = Math.min(Math.max(0, right), img.cols - 1);
+    bottom = Math.min(Math.max(0, bottom), img.rows - 1);
+    top = Math.min(Math.max(0, top), img.rows - 1);
+
+    if (confidence > 0.5 && left < right && top < bottom) {
+      faces.push({x: left, y: top, width: right - left, height: bottom - top})
+    }
+  }
+  blob.delete();
+  out.delete();
+  return faces;
+};
+//! [Run face detection model]
+
+//! [Get 128 floating points feature vector]
+function face2vec(face) {
+  var blob = cv.blobFromImage(face, 1.0 / 255, {width: 96, height: 96}, [0, 0, 0, 0], true, false)
+  netRecogn.setInput(blob);
+  var vec = netRecogn.forward();
+  blob.delete();
+  return vec;
+};
+//! [Get 128 floating points feature vector]
+
+//! [Recognize]
+function recognize(face) {
+  var vec = face2vec(face);
+
+  var bestMatchName = 'unknown';
+  var bestMatchScore = 0.5;  // Actually, the minimum is -1 but we use it as a threshold.
+  for (name in persons) {
+    var personVec = persons[name];
+    var score = vec.dot(personVec);
+    if (score > bestMatchScore) {
+      bestMatchScore = score;
+      bestMatchName = name;
+    }
+  }
+  vec.delete();
+  return bestMatchName;
+};
+//! [Recognize]
+
+function loadModels(callback) {
+  var utils = new Utils('');
+  var proto = 'https://raw.githubusercontent.com/opencv/opencv/4.x/samples/dnn/face_detector/deploy_lowres.prototxt';
+  var weights = 'https://raw.githubusercontent.com/opencv/opencv_3rdparty/dnn_samples_face_detector_20180205_fp16/res10_300x300_ssd_iter_140000_fp16.caffemodel';
+  var recognModel = 'https://raw.githubusercontent.com/pyannote/pyannote-data/master/openface.nn4.small2.v1.t7';
+  utils.createFileFromUrl('face_detector.prototxt', proto, () => {
+    document.getElementById('status').innerHTML = 'Downloading face_detector.caffemodel';
+    utils.createFileFromUrl('face_detector.caffemodel', weights, () => {
+      document.getElementById('status').innerHTML = 'Downloading OpenFace model';
+      utils.createFileFromUrl('face_recognition.t7', recognModel, () => {
+        document.getElementById('status').innerHTML = '';
+        netDet = cv.readNetFromCaffe('face_detector.prototxt', 'face_detector.caffemodel');
+        netRecogn = cv.readNetFromTorch('face_recognition.t7');
+        callback();
+      });
+    });
+  });
+};
+
+function main() {
+  // Create a camera object.
+  var output = document.getElementById('output');
+  var camera = document.createElement("video");
+  camera.setAttribute("width", output.width);
+  camera.setAttribute("height", output.height);
+
+  // Get a permission from user to use a camera.
+  navigator.mediaDevices.getUserMedia({video: true, audio: false})
+    .then(function(stream) {
+      camera.srcObject = stream;
+      camera.onloadedmetadata = function(e) {
+        camera.play();
+      };
+  });
+
+  //! [Open a camera stream]
+  var cap = new cv.VideoCapture(camera);
+  var frame = new cv.Mat(camera.height, camera.width, cv.CV_8UC4);
+  var frameBGR = new cv.Mat(camera.height, camera.width, cv.CV_8UC3);
+  //! [Open a camera stream]
+
+  //! [Add a person]
+  document.getElementById('addPersonButton').onclick = function() {
+    var rects = detectFaces(frameBGR);
+    if (rects.length > 0) {
+      var face = frameBGR.roi(rects[0]);
+
+      var name = prompt('Say your name:');
+      var cell = document.getElementById("targetNames").insertCell(0);
+      cell.innerHTML = name;
+
+      persons[name] = face2vec(face).clone();
+
+      var canvas = document.createElement("canvas");
+      canvas.setAttribute("width", 96);
+      canvas.setAttribute("height", 96);
+      var cell = document.getElementById("targetImgs").insertCell(0);
+      cell.appendChild(canvas);
+
+      var faceResized = new cv.Mat(canvas.height, canvas.width, cv.CV_8UC3);
+      cv.resize(face, faceResized, {width: canvas.width, height: canvas.height});
+      cv.cvtColor(faceResized, faceResized, cv.COLOR_BGR2RGB);
+      cv.imshow(canvas, faceResized);
+      faceResized.delete();
+    }
+  };
+  //! [Add a person]
+
+  //! [Define frames processing]
+  var isRunning = false;
+  const FPS = 30;  // Target number of frames processed per second.
+  function captureFrame() {
+    var begin = Date.now();
+    cap.read(frame);  // Read a frame from camera
+    cv.cvtColor(frame, frameBGR, cv.COLOR_RGBA2BGR);
+
+    var faces = detectFaces(frameBGR);
+    faces.forEach(function(rect) {
+      cv.rectangle(frame, {x: rect.x, y: rect.y}, {x: rect.x + rect.width, y: rect.y + rect.height}, [0, 255, 0, 255]);
+
+      var face = frameBGR.roi(rect);
+      var name = recognize(face);
+      cv.putText(frame, name, {x: rect.x, y: rect.y}, cv.FONT_HERSHEY_SIMPLEX, 1.0, [0, 255, 0, 255]);
+    });
+
+    cv.imshow(output, frame);
+
+    // Loop this function.
+    if (isRunning) {
+      var delay = 1000 / FPS - (Date.now() - begin);
+      setTimeout(captureFrame, delay);
+    }
+  };
+  //! [Define frames processing]
+
+  document.getElementById('startStopButton').onclick = function toggle() {
+    if (isRunning) {
+      isRunning = false;
+      document.getElementById('startStopButton').innerHTML = 'Start';
+      document.getElementById('addPersonButton').disabled = true;
+    } else {
+      function run() {
+        isRunning = true;
+        captureFrame();
+        document.getElementById('startStopButton').innerHTML = 'Stop';
+        document.getElementById('startStopButton').disabled = false;
+        document.getElementById('addPersonButton').disabled = false;
+      }
+      if (netDet == undefined || netRecogn == undefined) {
+        document.getElementById('startStopButton').disabled = true;
+        loadModels(run);  // Load models and run a pipeline;
+      } else {
+        run();
+      }
+    }
+  };
+
+  document.getElementById('startStopButton').disabled = false;
+};
+</script>
+
+</head>
+
+<body onload="cv['onRuntimeInitialized']=()=>{ main() }">
+  <button id="startStopButton" type="button" disabled="true">Start</button>
+  <div id="status"></div>
+  <canvas id="output" width=640 height=480 style="max-width: 100%"></canvas>
+
+  <table>
+    <tr id="targetImgs"></tr>
+    <tr id="targetNames"></tr>
+  </table>
+  <button id="addPersonButton" type="button" disabled="true">Add a person</button>
+</body>
+
+</html>
diff --git a/C++/opencv-4.7.0/samples/dnn/mask_rcnn.py b/C++/opencv-4.7.0/samples/dnn/mask_rcnn.py
new file mode 100644
index 00000000..352dfd19
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/mask_rcnn.py
@@ -0,0 +1,143 @@
+import cv2 as cv
+import argparse
+import numpy as np
+
+parser = argparse.ArgumentParser(description=
+        'Use this script to run Mask-RCNN object detection and semantic '
+        'segmentation network from TensorFlow Object Detection API.')
+parser.add_argument('--input', help='Path to input image or video file. Skip this argument to capture frames from a camera.')
+parser.add_argument('--model', required=True, help='Path to a .pb file with weights.')
+parser.add_argument('--config', required=True, help='Path to a .pxtxt file contains network configuration.')
+parser.add_argument('--classes', help='Optional path to a text file with names of classes.')
+parser.add_argument('--colors', help='Optional path to a text file with colors for an every class. '
+                                     'An every color is represented with three values from 0 to 255 in BGR channels order.')
+parser.add_argument('--width', type=int, default=800,
+                    help='Preprocess input image by resizing to a specific width.')
+parser.add_argument('--height', type=int, default=800,
+                    help='Preprocess input image by resizing to a specific height.')
+parser.add_argument('--thr', type=float, default=0.5, help='Confidence threshold')
+args = parser.parse_args()
+
+np.random.seed(324)
+
+# Load names of classes
+classes = None
+if args.classes:
+    with open(args.classes, 'rt') as f:
+        classes = f.read().rstrip('\n').split('\n')
+
+# Load colors
+colors = None
+if args.colors:
+    with open(args.colors, 'rt') as f:
+        colors = [np.array(color.split(' '), np.uint8) for color in f.read().rstrip('\n').split('\n')]
+
+legend = None
+def showLegend(classes):
+    global legend
+    if not classes is None and legend is None:
+        blockHeight = 30
+        assert(len(classes) == len(colors))
+
+        legend = np.zeros((blockHeight * len(colors), 200, 3), np.uint8)
+        for i in range(len(classes)):
+            block = legend[i * blockHeight:(i + 1) * blockHeight]
+            block[:,:] = colors[i]
+            cv.putText(block, classes[i], (0, blockHeight//2), cv.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255))
+
+        cv.namedWindow('Legend', cv.WINDOW_NORMAL)
+        cv.imshow('Legend', legend)
+        classes = None
+
+
+def drawBox(frame, classId, conf, left, top, right, bottom):
+    # Draw a bounding box.
+    cv.rectangle(frame, (left, top), (right, bottom), (0, 255, 0))
+
+    label = '%.2f' % conf
+
+    # Print a label of class.
+    if classes:
+        assert(classId < len(classes))
+        label = '%s: %s' % (classes[classId], label)
+
+    labelSize, baseLine = cv.getTextSize(label, cv.FONT_HERSHEY_SIMPLEX, 0.5, 1)
+    top = max(top, labelSize[1])
+    cv.rectangle(frame, (left, top - labelSize[1]), (left + labelSize[0], top + baseLine), (255, 255, 255), cv.FILLED)
+    cv.putText(frame, label, (left, top), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))
+
+
+# Load a network
+net = cv.dnn.readNet(cv.samples.findFile(args.model), cv.samples.findFile(args.config))
+net.setPreferableBackend(cv.dnn.DNN_BACKEND_OPENCV)
+
+winName = 'Mask-RCNN in OpenCV'
+cv.namedWindow(winName, cv.WINDOW_NORMAL)
+
+cap = cv.VideoCapture(cv.samples.findFileOrKeep(args.input) if args.input else 0)
+legend = None
+while cv.waitKey(1) < 0:
+    hasFrame, frame = cap.read()
+    if not hasFrame:
+        cv.waitKey()
+        break
+
+    frameH = frame.shape[0]
+    frameW = frame.shape[1]
+
+    # Create a 4D blob from a frame.
+    blob = cv.dnn.blobFromImage(frame, size=(args.width, args.height), swapRB=True, crop=False)
+
+    # Run a model
+    net.setInput(blob)
+
+    boxes, masks = net.forward(['detection_out_final', 'detection_masks'])
+
+    numClasses = masks.shape[1]
+    numDetections = boxes.shape[2]
+
+    # Draw segmentation
+    if not colors:
+        # Generate colors
+        colors = [np.array([0, 0, 0], np.uint8)]
+        for i in range(1, numClasses + 1):
+            colors.append((colors[i - 1] + np.random.randint(0, 256, [3], np.uint8)) / 2)
+        del colors[0]
+
+    boxesToDraw = []
+    for i in range(numDetections):
+        box = boxes[0, 0, i]
+        mask = masks[i]
+        score = box[2]
+        if score > args.thr:
+            classId = int(box[1])
+            left = int(frameW * box[3])
+            top = int(frameH * box[4])
+            right = int(frameW * box[5])
+            bottom = int(frameH * box[6])
+
+            left = max(0, min(left, frameW - 1))
+            top = max(0, min(top, frameH - 1))
+            right = max(0, min(right, frameW - 1))
+            bottom = max(0, min(bottom, frameH - 1))
+
+            boxesToDraw.append([frame, classId, score, left, top, right, bottom])
+
+            classMask = mask[classId]
+            classMask = cv.resize(classMask, (right - left + 1, bottom - top + 1))
+            mask = (classMask > 0.5)
+
+            roi = frame[top:bottom+1, left:right+1][mask]
+            frame[top:bottom+1, left:right+1][mask] = (0.7 * colors[classId] + 0.3 * roi).astype(np.uint8)
+
+    for box in boxesToDraw:
+        drawBox(*box)
+
+    # Put efficiency information.
+    t, _ = net.getPerfProfile()
+    label = 'Inference time: %.2f ms' % (t * 1000.0 / cv.getTickFrequency())
+    cv.putText(frame, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
+
+    showLegend(classes)
+
+    cv.imshow(winName, frame)
diff --git a/C++/opencv-4.7.0/samples/dnn/mobilenet_ssd_accuracy.py b/C++/opencv-4.7.0/samples/dnn/mobilenet_ssd_accuracy.py
new file mode 100644
index 00000000..23fb06b9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/mobilenet_ssd_accuracy.py
@@ -0,0 +1,133 @@
+from __future__ import print_function
+# Script to evaluate MobileNet-SSD object detection model trained in TensorFlow
+# using both TensorFlow and OpenCV. Example:
+#
+# python mobilenet_ssd_accuracy.py \
+#   --weights=frozen_inference_graph.pb \
+#   --prototxt=ssd_mobilenet_v1_coco.pbtxt \
+#   --images=val2017 \
+#   --annotations=annotations/instances_val2017.json
+#
+# Tested on COCO 2017 object detection dataset, http://cocodataset.org/#download
+import os
+import cv2 as cv
+import json
+import argparse
+
+parser = argparse.ArgumentParser(
+    description='Evaluate MobileNet-SSD model using both TensorFlow and OpenCV. '
+                'COCO evaluation framework is required: http://cocodataset.org')
+parser.add_argument('--weights', required=True,
+                    help='Path to frozen_inference_graph.pb of MobileNet-SSD model. '
+                         'Download it from http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v1_coco_11_06_2017.tar.gz')
+parser.add_argument('--prototxt', help='Path to ssd_mobilenet_v1_coco.pbtxt from opencv_extra.', required=True)
+parser.add_argument('--images', help='Path to COCO validation images directory.', required=True)
+parser.add_argument('--annotations', help='Path to COCO annotations file.', required=True)
+args = parser.parse_args()
+
+### Get OpenCV predictions #####################################################
+net = cv.dnn.readNetFromTensorflow(cv.samples.findFile(args.weights), cv.samples.findFile(args.prototxt))
+net.setPreferableBackend(cv.dnn.DNN_BACKEND_OPENCV)
+
+detections = []
+for imgName in os.listdir(args.images):
+    inp = cv.imread(cv.samples.findFile(os.path.join(args.images, imgName)))
+    rows = inp.shape[0]
+    cols = inp.shape[1]
+    inp = cv.resize(inp, (300, 300))
+
+    net.setInput(cv.dnn.blobFromImage(inp, 1.0/127.5, (300, 300), (127.5, 127.5, 127.5), True))
+    out = net.forward()
+
+    for i in range(out.shape[2]):
+        score = float(out[0, 0, i, 2])
+        # Confidence threshold is in prototxt.
+        classId = int(out[0, 0, i, 1])
+
+        x = out[0, 0, i, 3] * cols
+        y = out[0, 0, i, 4] * rows
+        w = out[0, 0, i, 5] * cols - x
+        h = out[0, 0, i, 6] * rows - y
+        detections.append({
+          "image_id": int(imgName.rstrip('0')[:imgName.rfind('.')]),
+          "category_id": classId,
+          "bbox": [x, y, w, h],
+          "score": score
+        })
+
+with open('cv_result.json', 'wt') as f:
+    json.dump(detections, f)
+
+### Get TensorFlow predictions #################################################
+import tensorflow as tf
+
+with tf.gfile.FastGFile(args.weights) as f:
+    # Load the model
+    graph_def = tf.GraphDef()
+    graph_def.ParseFromString(f.read())
+
+with tf.Session() as sess:
+    # Restore session
+    sess.graph.as_default()
+    tf.import_graph_def(graph_def, name='')
+
+    detections = []
+    for imgName in os.listdir(args.images):
+        inp = cv.imread(os.path.join(args.images, imgName))
+        rows = inp.shape[0]
+        cols = inp.shape[1]
+        inp = cv.resize(inp, (300, 300))
+        inp = inp[:, :, [2, 1, 0]]  # BGR2RGB
+        out = sess.run([sess.graph.get_tensor_by_name('num_detections:0'),
+                        sess.graph.get_tensor_by_name('detection_scores:0'),
+                        sess.graph.get_tensor_by_name('detection_boxes:0'),
+                        sess.graph.get_tensor_by_name('detection_classes:0')],
+                       feed_dict={'image_tensor:0': inp.reshape(1, inp.shape[0], inp.shape[1], 3)})
+        num_detections = int(out[0][0])
+        for i in range(num_detections):
+            classId = int(out[3][0][i])
+            score = float(out[1][0][i])
+            bbox = [float(v) for v in out[2][0][i]]
+            if score > 0.01:
+                x = bbox[1] * cols
+                y = bbox[0] * rows
+                w = bbox[3] * cols - x
+                h = bbox[2] * rows - y
+                detections.append({
+                  "image_id": int(imgName.rstrip('0')[:imgName.rfind('.')]),
+                  "category_id": classId,
+                  "bbox": [x, y, w, h],
+                  "score": score
+                })
+
+with open('tf_result.json', 'wt') as f:
+    json.dump(detections, f)
+
+### Evaluation part ############################################################
+
+# %matplotlib inline
+import matplotlib.pyplot as plt
+from pycocotools.coco import COCO
+from pycocotools.cocoeval import COCOeval
+import numpy as np
+import skimage.io as io
+import pylab
+pylab.rcParams['figure.figsize'] = (10.0, 8.0)
+
+annType = ['segm','bbox','keypoints']
+annType = annType[1]      #specify type here
+prefix = 'person_keypoints' if annType=='keypoints' else 'instances'
+print('Running demo for *%s* results.'%(annType))
+
+#initialize COCO ground truth api
+cocoGt=COCO(args.annotations)
+
+#initialize COCO detections api
+for resFile in ['tf_result.json', 'cv_result.json']:
+    print(resFile)
+    cocoDt=cocoGt.loadRes(resFile)
+
+    cocoEval = COCOeval(cocoGt,cocoDt,annType)
+    cocoEval.evaluate()
+    cocoEval.accumulate()
+    cocoEval.summarize()
diff --git a/C++/opencv-4.7.0/samples/dnn/models.yml b/C++/opencv-4.7.0/samples/dnn/models.yml
new file mode 100644
index 00000000..f6e9f0e4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/models.yml
@@ -0,0 +1,166 @@
+%YAML 1.0
+---
+################################################################################
+# Object detection models.
+################################################################################
+
+# OpenCV's face detection network
+opencv_fd:
+  load_info:
+    url: "https://github.com/opencv/opencv_3rdparty/raw/dnn_samples_face_detector_20170830/res10_300x300_ssd_iter_140000.caffemodel"
+    sha1: "15aa726b4d46d9f023526d85537db81cbc8dd566"
+  model: "opencv_face_detector.caffemodel"
+  config: "opencv_face_detector.prototxt"
+  mean: [104, 177, 123]
+  scale: 1.0
+  width: 300
+  height: 300
+  rgb: false
+  sample: "object_detection"
+
+# YOLO4 object detection family from Darknet (https://github.com/AlexeyAB/darknet)
+# YOLO object detection family from Darknet (https://pjreddie.com/darknet/yolo/)
+# Might be used for all YOLOv2, TinyYolov2, YOLOv3, YOLOv4 and TinyYolov4
+yolo:
+  load_info:
+    url: "https://github.com/AlexeyAB/darknet/releases/download/darknet_yolo_v3_optimal/yolov4.weights"
+    sha1: "0143deb6c46fcc7f74dd35bf3c14edc3784e99ee"
+  model: "yolov4.weights"
+  config: "yolov4.cfg"
+  mean: [0, 0, 0]
+  scale: 0.00392
+  width: 416
+  height: 416
+  rgb: true
+  classes: "object_detection_classes_yolov4.txt"
+  sample: "object_detection"
+
+tiny-yolo-voc:
+  load_info:
+    url: "https://pjreddie.com/media/files/yolov2-tiny-voc.weights"
+    sha1: "24b4bd049fc4fa5f5e95f684a8967e65c625dff9"
+  model: "tiny-yolo-voc.weights"
+  config: "tiny-yolo-voc.cfg"
+  mean: [0, 0, 0]
+  scale: 0.00392
+  width: 416
+  height: 416
+  rgb: true
+  classes: "object_detection_classes_pascal_voc.txt"
+  sample: "object_detection"
+
+# Caffe implementation of SSD model from https://github.com/chuanqi305/MobileNet-SSD
+ssd_caffe:
+  load_info:
+    url: "https://drive.google.com/uc?export=download&id=0B3gersZ2cHIxRm5PMWRoTkdHdHc"
+    sha1: "994d30a8afaa9e754d17d2373b2d62a7dfbaaf7a"
+  model: "MobileNetSSD_deploy.caffemodel"
+  config: "MobileNetSSD_deploy.prototxt"
+  mean: [127.5, 127.5, 127.5]
+  scale: 0.007843
+  width: 300
+  height: 300
+  rgb: false
+  classes: "object_detection_classes_pascal_voc.txt"
+  sample: "object_detection"
+
+# TensorFlow implementation of SSD model from https://github.com/tensorflow/models/tree/master/research/object_detection
+ssd_tf:
+  load_info:
+    url: "http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v1_coco_2017_11_17.tar.gz"
+    sha1: "9e4bcdd98f4c6572747679e4ce570de4f03a70e2"
+    download_sha: "6157ddb6da55db2da89dd561eceb7f944928e317"
+    download_name: "ssd_mobilenet_v1_coco_2017_11_17.tar.gz"
+    member: "ssd_mobilenet_v1_coco_2017_11_17/frozen_inference_graph.pb"
+  model: "ssd_mobilenet_v1_coco_2017_11_17.pb"
+  config: "ssd_mobilenet_v1_coco_2017_11_17.pbtxt"
+  mean: [0, 0, 0]
+  scale: 1.0
+  width: 300
+  height: 300
+  rgb: true
+  classes: "object_detection_classes_coco.txt"
+  sample: "object_detection"
+
+# TensorFlow implementation of Faster-RCNN model from https://github.com/tensorflow/models/tree/master/research/object_detection
+faster_rcnn_tf:
+  load_info:
+    url: "http://download.tensorflow.org/models/object_detection/faster_rcnn_inception_v2_coco_2018_01_28.tar.gz"
+    sha1: "f2e4bf386b9bb3e25ddfcbbd382c20f417e444f3"
+    download_sha: "c710f25e5c6a3ce85fe793d5bf266d581ab1c230"
+    download_name: "faster_rcnn_inception_v2_coco_2018_01_28.tar.gz"
+    member: "faster_rcnn_inception_v2_coco_2018_01_28/frozen_inference_graph.pb"
+  model: "faster_rcnn_inception_v2_coco_2018_01_28.pb"
+  config: "faster_rcnn_inception_v2_coco_2018_01_28.pbtxt"
+  mean: [0, 0, 0]
+  scale: 1.0
+  width: 800
+  height: 600
+  rgb: true
+  sample: "object_detection"
+
+################################################################################
+# Image classification models.
+################################################################################
+
+# SqueezeNet v1.1 from https://github.com/DeepScale/SqueezeNet
+squeezenet:
+  load_info:
+    url: "https://raw.githubusercontent.com/DeepScale/SqueezeNet/b5c3f1a23713c8b3fd7b801d229f6b04c64374a5/SqueezeNet_v1.1/squeezenet_v1.1.caffemodel"
+    sha1: "3397f026368a45ae236403ccc81cfcbe8ebe1bd0"
+  model: "squeezenet_v1.1.caffemodel"
+  config: "squeezenet_v1.1.prototxt"
+  mean: [0, 0, 0]
+  scale: 1.0
+  width: 227
+  height: 227
+  rgb: false
+  classes: "classification_classes_ILSVRC2012.txt"
+  sample: "classification"
+
+# Googlenet from https://github.com/BVLC/caffe/tree/master/models/bvlc_googlenet
+googlenet:
+  load_info:
+    url: "http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel"
+    sha1: "405fc5acd08a3bb12de8ee5e23a96bec22f08204"
+  model: "bvlc_googlenet.caffemodel"
+  config: "bvlc_googlenet.prototxt"
+  mean: [104, 117, 123]
+  scale: 1.0
+  width: 224
+  height: 224
+  rgb: false
+  classes: "classification_classes_ILSVRC2012.txt"
+  sample: "classification"
+
+################################################################################
+# Semantic segmentation models.
+################################################################################
+
+# ENet road scene segmentation network from https://github.com/e-lab/ENet-training
+# Works fine for different input sizes.
+enet:
+  load_info:
+    url: "https://www.dropbox.com/s/tdde0mawbi5dugq/Enet-model-best.net?dl=1"
+    sha1: "b4123a73bf464b9ebe9cfc4ab9c2d5c72b161315"
+  model: "Enet-model-best.net"
+  mean: [0, 0, 0]
+  scale: 0.00392
+  width: 512
+  height: 256
+  rgb: true
+  classes: "enet-classes.txt"
+  sample: "segmentation"
+
+fcn8s:
+  load_info:
+    url: "http://dl.caffe.berkeleyvision.org/fcn8s-heavy-pascal.caffemodel"
+    sha1: "c449ea74dd7d83751d1357d6a8c323fcf4038962"
+  model: "fcn8s-heavy-pascal.caffemodel"
+  config: "fcn8s-heavy-pascal.prototxt"
+  mean: [0, 0, 0]
+  scale: 1.0
+  width: 500
+  height: 500
+  rgb: false
+  sample: "segmentation"
diff --git a/C++/opencv-4.7.0/samples/dnn/nanotrack_tracker.cpp b/C++/opencv-4.7.0/samples/dnn/nanotrack_tracker.cpp
new file mode 100644
index 00000000..e98e301f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/nanotrack_tracker.cpp
@@ -0,0 +1,183 @@
+// NanoTrack
+// Link to original inference code: https://github.com/HonglinChu/NanoTrack
+// Link to original training repo: https://github.com/HonglinChu/SiamTrackers/tree/master/NanoTrack
+// backBone model: https://github.com/HonglinChu/SiamTrackers/blob/master/NanoTrack/models/onnx/nanotrack_backbone_sim.onnx
+// headNeck model: https://github.com/HonglinChu/SiamTrackers/blob/master/NanoTrack/models/onnx/nanotrack_head_sim.onnx
+
+#include <iostream>
+#include <cmath>
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/video.hpp>
+
+using namespace cv;
+using namespace cv::dnn;
+
+const char *keys =
+        "{ help     h  |   | Print help message }"
+        "{ input    i  |   | Full path to input video folder, the specific camera index. (empty for camera 0) }"
+        "{ backbone    | backbone.onnx | Path to onnx model of backbone.onnx}"
+        "{ headneck    | headneck.onnx | Path to onnx model of headneck.onnx }"
+        "{ backend     | 0 | Choose one of computation backends: "
+                            "0: automatically (by default), "
+                            "1: Halide language (http://halide-lang.org/), "
+                            "2: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                            "3: OpenCV implementation, "
+                            "4: VKCOM, "
+                            "5: CUDA },"
+        "{ target      | 0 | Choose one of target computation devices: "
+                            "0: CPU target (by default), "
+                            "1: OpenCL, "
+                            "2: OpenCL fp16 (half-float precision), "
+                            "3: VPU, "
+                            "4: Vulkan, "
+                            "6: CUDA, "
+                            "7: CUDA fp16 (half-float preprocess) }"
+;
+
+static
+int run(int argc, char** argv)
+{
+    // Parse command line arguments.
+    CommandLineParser parser(argc, argv, keys);
+
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    std::string inputName = parser.get<String>("input");
+    std::string backbone = parser.get<String>("backbone");
+    std::string headneck = parser.get<String>("headneck");
+    int backend = parser.get<int>("backend");
+    int target = parser.get<int>("target");
+
+    Ptr<TrackerNano> tracker;
+    try
+    {
+        TrackerNano::Params params;
+        params.backbone = samples::findFile(backbone);
+        params.neckhead = samples::findFile(headneck);
+        params.backend = backend;
+        params.target = target;
+        tracker = TrackerNano::create(params);
+    }
+    catch (const cv::Exception& ee)
+    {
+        std::cerr << "Exception: " << ee.what() << std::endl;
+        std::cout << "Can't load the network by using the following files:" << std::endl;
+        std::cout << "backbone : " << backbone << std::endl;
+        std::cout << "headneck : " << headneck << std::endl;
+        return 2;
+    }
+
+    const std::string winName = "NanoTrack";
+    namedWindow(winName, WINDOW_AUTOSIZE);
+
+    // Open a video file or an image file or a camera stream.
+    VideoCapture cap;
+
+    if (inputName.empty() || (isdigit(inputName[0]) && inputName.size() == 1))
+    {
+        int c = inputName.empty() ? 0 : inputName[0] - '0';
+        std::cout << "Trying to open camera #" << c << " ..." << std::endl;
+        if (!cap.open(c))
+        {
+            std::cout << "Capture from camera #" << c << " didn't work. Specify -i=<video> parameter to read from video file" << std::endl;
+            return 2;
+        }
+    }
+    else if (inputName.size())
+    {
+        inputName = samples::findFileOrKeep(inputName);
+        if (!cap.open(inputName))
+        {
+            std::cout << "Could not open: " << inputName << std::endl;
+            return 2;
+        }
+    }
+
+    // Read the first image.
+    Mat image;
+    cap >> image;
+    if (image.empty())
+    {
+        std::cerr << "Can't capture frame!" << std::endl;
+        return 2;
+    }
+
+    Mat image_select = image.clone();
+    putText(image_select, "Select initial bounding box you want to track.", Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+    putText(image_select, "And Press the ENTER key.", Point(0, 35), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+
+    Rect selectRect = selectROI(winName, image_select);
+    std::cout << "ROI=" << selectRect << std::endl;
+
+    tracker->init(image, selectRect);
+
+    TickMeter tickMeter;
+
+    for (int count = 0; ; ++count)
+    {
+        cap >> image;
+        if (image.empty())
+        {
+            std::cerr << "Can't capture frame " << count << ". End of video stream?" << std::endl;
+            break;
+        }
+
+        Rect rect;
+
+        tickMeter.start();
+        bool ok = tracker->update(image, rect);
+        tickMeter.stop();
+
+        float score = tracker->getTrackingScore();
+
+        std::cout << "frame " << count <<
+            ": predicted score=" << score <<
+            "  rect=" << rect <<
+            "  time=" << tickMeter.getTimeMilli() << "ms" <<
+            std::endl;
+
+        Mat render_image = image.clone();
+
+        if (ok)
+        {
+            rectangle(render_image, rect, Scalar(0, 255, 0), 2);
+
+            std::string timeLabel = format("Inference time: %.2f ms", tickMeter.getTimeMilli());
+            std::string scoreLabel = format("Score: %f", score);
+            putText(render_image, timeLabel, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+            putText(render_image, scoreLabel, Point(0, 35), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+        }
+
+        imshow(winName, render_image);
+
+        tickMeter.reset();
+
+        int c = waitKey(1);
+        if (c == 27 /*ESC*/)
+            break;
+    }
+
+    std::cout << "Exit" << std::endl;
+    return 0;
+}
+
+
+int main(int argc, char **argv)
+{
+    try
+    {
+        return run(argc, argv);
+    }
+    catch (const std::exception& e)
+    {
+        std::cerr << "FATAL: C++ exception: " << e.what() << std::endl;
+        return 1;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/object_detection.cpp b/C++/opencv-4.7.0/samples/dnn/object_detection.cpp
new file mode 100644
index 00000000..6fc8b2ab
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/object_detection.cpp
@@ -0,0 +1,480 @@
+#include <fstream>
+#include <sstream>
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+#if defined(CV_CXX11) && defined(HAVE_THREADS)
+#define USE_THREADS 1
+#endif
+
+#ifdef USE_THREADS
+#include <mutex>
+#include <thread>
+#include <queue>
+#endif
+
+#include "common.hpp"
+
+std::string keys =
+    "{ help  h     | | Print help message. }"
+    "{ @alias      | | An alias name of model to extract preprocessing parameters from models.yml file. }"
+    "{ zoo         | models.yml | An optional path to file with preprocessing parameters }"
+    "{ device      |  0 | camera device number. }"
+    "{ input i     | | Path to input image or video file. Skip this argument to capture frames from a camera. }"
+    "{ framework f | | Optional name of an origin framework of the model. Detect it automatically if it does not set. }"
+    "{ classes     | | Optional path to a text file with names of classes to label detected objects. }"
+    "{ thr         | .5 | Confidence threshold. }"
+    "{ nms         | .4 | Non-maximum suppression threshold. }"
+    "{ backend     |  0 | Choose one of computation backends: "
+                         "0: automatically (by default), "
+                         "1: Halide language (http://halide-lang.org/), "
+                         "2: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                         "3: OpenCV implementation, "
+                         "4: VKCOM, "
+                         "5: CUDA }"
+    "{ target      | 0 | Choose one of target computation devices: "
+                         "0: CPU target (by default), "
+                         "1: OpenCL, "
+                         "2: OpenCL fp16 (half-float precision), "
+                         "3: VPU, "
+                         "4: Vulkan, "
+                         "6: CUDA, "
+                         "7: CUDA fp16 (half-float preprocess) }"
+    "{ async       | 0 | Number of asynchronous forwards at the same time. "
+                        "Choose 0 for synchronous mode }";
+
+using namespace cv;
+using namespace dnn;
+
+float confThreshold, nmsThreshold;
+std::vector<std::string> classes;
+
+inline void preprocess(const Mat& frame, Net& net, Size inpSize, float scale,
+                       const Scalar& mean, bool swapRB);
+
+void postprocess(Mat& frame, const std::vector<Mat>& out, Net& net, int backend);
+
+void drawPred(int classId, float conf, int left, int top, int right, int bottom, Mat& frame);
+
+void callback(int pos, void* userdata);
+
+#ifdef USE_THREADS
+template <typename T>
+class QueueFPS : public std::queue<T>
+{
+public:
+    QueueFPS() : counter(0) {}
+
+    void push(const T& entry)
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+
+        std::queue<T>::push(entry);
+        counter += 1;
+        if (counter == 1)
+        {
+            // Start counting from a second frame (warmup).
+            tm.reset();
+            tm.start();
+        }
+    }
+
+    T get()
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        T entry = this->front();
+        this->pop();
+        return entry;
+    }
+
+    float getFPS()
+    {
+        tm.stop();
+        double fps = counter / tm.getTimeSec();
+        tm.start();
+        return static_cast<float>(fps);
+    }
+
+    void clear()
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        while (!this->empty())
+            this->pop();
+    }
+
+    unsigned int counter;
+
+private:
+    TickMeter tm;
+    std::mutex mutex;
+};
+#endif  // USE_THREADS
+
+int main(int argc, char** argv)
+{
+    CommandLineParser parser(argc, argv, keys);
+
+    const std::string modelName = parser.get<String>("@alias");
+    const std::string zooFile = parser.get<String>("zoo");
+
+    keys += genPreprocArguments(modelName, zooFile);
+
+    parser = CommandLineParser(argc, argv, keys);
+    parser.about("Use this script to run object detection deep learning networks using OpenCV.");
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    confThreshold = parser.get<float>("thr");
+    nmsThreshold = parser.get<float>("nms");
+    float scale = parser.get<float>("scale");
+    Scalar mean = parser.get<Scalar>("mean");
+    bool swapRB = parser.get<bool>("rgb");
+    int inpWidth = parser.get<int>("width");
+    int inpHeight = parser.get<int>("height");
+    size_t asyncNumReq = parser.get<int>("async");
+    CV_Assert(parser.has("model"));
+    std::string modelPath = findFile(parser.get<String>("model"));
+    std::string configPath = findFile(parser.get<String>("config"));
+
+    // Open file with classes names.
+    if (parser.has("classes"))
+    {
+        std::string file = parser.get<String>("classes");
+        std::ifstream ifs(file.c_str());
+        if (!ifs.is_open())
+            CV_Error(Error::StsError, "File " + file + " not found");
+        std::string line;
+        while (std::getline(ifs, line))
+        {
+            classes.push_back(line);
+        }
+    }
+
+    // Load a model.
+    Net net = readNet(modelPath, configPath, parser.get<String>("framework"));
+    int backend = parser.get<int>("backend");
+    net.setPreferableBackend(backend);
+    net.setPreferableTarget(parser.get<int>("target"));
+    std::vector<String> outNames = net.getUnconnectedOutLayersNames();
+
+    // Create a window
+    static const std::string kWinName = "Deep learning object detection in OpenCV";
+    namedWindow(kWinName, WINDOW_NORMAL);
+    int initialConf = (int)(confThreshold * 100);
+    createTrackbar("Confidence threshold, %", kWinName, &initialConf, 99, callback);
+
+    // Open a video file or an image file or a camera stream.
+    VideoCapture cap;
+    if (parser.has("input"))
+        cap.open(parser.get<String>("input"));
+    else
+        cap.open(parser.get<int>("device"));
+
+#ifdef USE_THREADS
+    bool process = true;
+
+    // Frames capturing thread
+    QueueFPS<Mat> framesQueue;
+    std::thread framesThread([&](){
+        Mat frame;
+        while (process)
+        {
+            cap >> frame;
+            if (!frame.empty())
+                framesQueue.push(frame.clone());
+            else
+                break;
+        }
+    });
+
+    // Frames processing thread
+    QueueFPS<Mat> processedFramesQueue;
+    QueueFPS<std::vector<Mat> > predictionsQueue;
+    std::thread processingThread([&](){
+        std::queue<AsyncArray> futureOutputs;
+        Mat blob;
+        while (process)
+        {
+            // Get a next frame
+            Mat frame;
+            {
+                if (!framesQueue.empty())
+                {
+                    frame = framesQueue.get();
+                    if (asyncNumReq)
+                    {
+                        if (futureOutputs.size() == asyncNumReq)
+                            frame = Mat();
+                    }
+                    else
+                        framesQueue.clear();  // Skip the rest of frames
+                }
+            }
+
+            // Process the frame
+            if (!frame.empty())
+            {
+                preprocess(frame, net, Size(inpWidth, inpHeight), scale, mean, swapRB);
+                processedFramesQueue.push(frame);
+
+                if (asyncNumReq)
+                {
+                    futureOutputs.push(net.forwardAsync());
+                }
+                else
+                {
+                    std::vector<Mat> outs;
+                    net.forward(outs, outNames);
+                    predictionsQueue.push(outs);
+                }
+            }
+
+            while (!futureOutputs.empty() &&
+                   futureOutputs.front().wait_for(std::chrono::seconds(0)))
+            {
+                AsyncArray async_out = futureOutputs.front();
+                futureOutputs.pop();
+                Mat out;
+                async_out.get(out);
+                predictionsQueue.push({out});
+            }
+        }
+    });
+
+    // Postprocessing and rendering loop
+    while (waitKey(1) < 0)
+    {
+        if (predictionsQueue.empty())
+            continue;
+
+        std::vector<Mat> outs = predictionsQueue.get();
+        Mat frame = processedFramesQueue.get();
+
+        postprocess(frame, outs, net, backend);
+
+        if (predictionsQueue.counter > 1)
+        {
+            std::string label = format("Camera: %.2f FPS", framesQueue.getFPS());
+            putText(frame, label, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+
+            label = format("Network: %.2f FPS", predictionsQueue.getFPS());
+            putText(frame, label, Point(0, 30), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+
+            label = format("Skipped frames: %d", framesQueue.counter - predictionsQueue.counter);
+            putText(frame, label, Point(0, 45), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+        }
+        imshow(kWinName, frame);
+    }
+
+    process = false;
+    framesThread.join();
+    processingThread.join();
+
+#else  // USE_THREADS
+    if (asyncNumReq)
+        CV_Error(Error::StsNotImplemented, "Asynchronous forward is supported only with Inference Engine backend.");
+
+    // Process frames.
+    Mat frame, blob;
+    while (waitKey(1) < 0)
+    {
+        cap >> frame;
+        if (frame.empty())
+        {
+            waitKey();
+            break;
+        }
+
+        preprocess(frame, net, Size(inpWidth, inpHeight), scale, mean, swapRB);
+
+        std::vector<Mat> outs;
+        net.forward(outs, outNames);
+
+        postprocess(frame, outs, net, backend);
+
+        // Put efficiency information.
+        std::vector<double> layersTimes;
+        double freq = getTickFrequency() / 1000;
+        double t = net.getPerfProfile(layersTimes) / freq;
+        std::string label = format("Inference time: %.2f ms", t);
+        putText(frame, label, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+
+        imshow(kWinName, frame);
+    }
+#endif  // USE_THREADS
+    return 0;
+}
+
+inline void preprocess(const Mat& frame, Net& net, Size inpSize, float scale,
+                       const Scalar& mean, bool swapRB)
+{
+    static Mat blob;
+    // Create a 4D blob from a frame.
+    if (inpSize.width <= 0) inpSize.width = frame.cols;
+    if (inpSize.height <= 0) inpSize.height = frame.rows;
+    blobFromImage(frame, blob, 1.0, inpSize, Scalar(), swapRB, false, CV_8U);
+
+    // Run a model.
+    net.setInput(blob, "", scale, mean);
+    if (net.getLayer(0)->outputNameToIndex("im_info") != -1)  // Faster-RCNN or R-FCN
+    {
+        resize(frame, frame, inpSize);
+        Mat imInfo = (Mat_<float>(1, 3) << inpSize.height, inpSize.width, 1.6f);
+        net.setInput(imInfo, "im_info");
+    }
+}
+
+void postprocess(Mat& frame, const std::vector<Mat>& outs, Net& net, int backend)
+{
+    static std::vector<int> outLayers = net.getUnconnectedOutLayers();
+    static std::string outLayerType = net.getLayer(outLayers[0])->type;
+
+    std::vector<int> classIds;
+    std::vector<float> confidences;
+    std::vector<Rect> boxes;
+    if (outLayerType == "DetectionOutput")
+    {
+        // Network produces output blob with a shape 1x1xNx7 where N is a number of
+        // detections and an every detection is a vector of values
+        // [batchId, classId, confidence, left, top, right, bottom]
+        CV_Assert(outs.size() > 0);
+        for (size_t k = 0; k < outs.size(); k++)
+        {
+            float* data = (float*)outs[k].data;
+            for (size_t i = 0; i < outs[k].total(); i += 7)
+            {
+                float confidence = data[i + 2];
+                if (confidence > confThreshold)
+                {
+                    int left   = (int)data[i + 3];
+                    int top    = (int)data[i + 4];
+                    int right  = (int)data[i + 5];
+                    int bottom = (int)data[i + 6];
+                    int width  = right - left + 1;
+                    int height = bottom - top + 1;
+                    if (width <= 2 || height <= 2)
+                    {
+                        left   = (int)(data[i + 3] * frame.cols);
+                        top    = (int)(data[i + 4] * frame.rows);
+                        right  = (int)(data[i + 5] * frame.cols);
+                        bottom = (int)(data[i + 6] * frame.rows);
+                        width  = right - left + 1;
+                        height = bottom - top + 1;
+                    }
+                    classIds.push_back((int)(data[i + 1]) - 1);  // Skip 0th background class id.
+                    boxes.push_back(Rect(left, top, width, height));
+                    confidences.push_back(confidence);
+                }
+            }
+        }
+    }
+    else if (outLayerType == "Region")
+    {
+        for (size_t i = 0; i < outs.size(); ++i)
+        {
+            // Network produces output blob with a shape NxC where N is a number of
+            // detected objects and C is a number of classes + 4 where the first 4
+            // numbers are [center_x, center_y, width, height]
+            float* data = (float*)outs[i].data;
+            for (int j = 0; j < outs[i].rows; ++j, data += outs[i].cols)
+            {
+                Mat scores = outs[i].row(j).colRange(5, outs[i].cols);
+                Point classIdPoint;
+                double confidence;
+                minMaxLoc(scores, 0, &confidence, 0, &classIdPoint);
+                if (confidence > confThreshold)
+                {
+                    int centerX = (int)(data[0] * frame.cols);
+                    int centerY = (int)(data[1] * frame.rows);
+                    int width = (int)(data[2] * frame.cols);
+                    int height = (int)(data[3] * frame.rows);
+                    int left = centerX - width / 2;
+                    int top = centerY - height / 2;
+
+                    classIds.push_back(classIdPoint.x);
+                    confidences.push_back((float)confidence);
+                    boxes.push_back(Rect(left, top, width, height));
+                }
+            }
+        }
+    }
+    else
+        CV_Error(Error::StsNotImplemented, "Unknown output layer type: " + outLayerType);
+
+    // NMS is used inside Region layer only on DNN_BACKEND_OPENCV for another backends we need NMS in sample
+    // or NMS is required if number of outputs > 1
+    if (outLayers.size() > 1 || (outLayerType == "Region" && backend != DNN_BACKEND_OPENCV))
+    {
+        std::map<int, std::vector<size_t> > class2indices;
+        for (size_t i = 0; i < classIds.size(); i++)
+        {
+            if (confidences[i] >= confThreshold)
+            {
+                class2indices[classIds[i]].push_back(i);
+            }
+        }
+        std::vector<Rect> nmsBoxes;
+        std::vector<float> nmsConfidences;
+        std::vector<int> nmsClassIds;
+        for (std::map<int, std::vector<size_t> >::iterator it = class2indices.begin(); it != class2indices.end(); ++it)
+        {
+            std::vector<Rect> localBoxes;
+            std::vector<float> localConfidences;
+            std::vector<size_t> classIndices = it->second;
+            for (size_t i = 0; i < classIndices.size(); i++)
+            {
+                localBoxes.push_back(boxes[classIndices[i]]);
+                localConfidences.push_back(confidences[classIndices[i]]);
+            }
+            std::vector<int> nmsIndices;
+            NMSBoxes(localBoxes, localConfidences, confThreshold, nmsThreshold, nmsIndices);
+            for (size_t i = 0; i < nmsIndices.size(); i++)
+            {
+                size_t idx = nmsIndices[i];
+                nmsBoxes.push_back(localBoxes[idx]);
+                nmsConfidences.push_back(localConfidences[idx]);
+                nmsClassIds.push_back(it->first);
+            }
+        }
+        boxes = nmsBoxes;
+        classIds = nmsClassIds;
+        confidences = nmsConfidences;
+    }
+
+    for (size_t idx = 0; idx < boxes.size(); ++idx)
+    {
+        Rect box = boxes[idx];
+        drawPred(classIds[idx], confidences[idx], box.x, box.y,
+                 box.x + box.width, box.y + box.height, frame);
+    }
+}
+
+void drawPred(int classId, float conf, int left, int top, int right, int bottom, Mat& frame)
+{
+    rectangle(frame, Point(left, top), Point(right, bottom), Scalar(0, 255, 0));
+
+    std::string label = format("%.2f", conf);
+    if (!classes.empty())
+    {
+        CV_Assert(classId < (int)classes.size());
+        label = classes[classId] + ": " + label;
+    }
+
+    int baseLine;
+    Size labelSize = getTextSize(label, FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
+
+    top = max(top, labelSize.height);
+    rectangle(frame, Point(left, top - labelSize.height),
+              Point(left + labelSize.width, top + baseLine), Scalar::all(255), FILLED);
+    putText(frame, label, Point(left, top), FONT_HERSHEY_SIMPLEX, 0.5, Scalar());
+}
+
+void callback(int pos, void*)
+{
+    confThreshold = pos * 0.01f;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/object_detection.py b/C++/opencv-4.7.0/samples/dnn/object_detection.py
new file mode 100644
index 00000000..0ca55861
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/object_detection.py
@@ -0,0 +1,329 @@
+import cv2 as cv
+import argparse
+import numpy as np
+import sys
+import time
+from threading import Thread
+if sys.version_info[0] == 2:
+    import Queue as queue
+else:
+    import queue
+
+from common import *
+from tf_text_graph_common import readTextMessage
+from tf_text_graph_ssd import createSSDGraph
+from tf_text_graph_faster_rcnn import createFasterRCNNGraph
+
+backends = (cv.dnn.DNN_BACKEND_DEFAULT, cv.dnn.DNN_BACKEND_HALIDE, cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_BACKEND_OPENCV,
+            cv.dnn.DNN_BACKEND_VKCOM, cv.dnn.DNN_BACKEND_CUDA)
+targets = (cv.dnn.DNN_TARGET_CPU, cv.dnn.DNN_TARGET_OPENCL, cv.dnn.DNN_TARGET_OPENCL_FP16, cv.dnn.DNN_TARGET_MYRIAD, cv.dnn.DNN_TARGET_HDDL,
+           cv.dnn.DNN_TARGET_VULKAN, cv.dnn.DNN_TARGET_CUDA, cv.dnn.DNN_TARGET_CUDA_FP16)
+
+parser = argparse.ArgumentParser(add_help=False)
+parser.add_argument('--zoo', default=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models.yml'),
+                    help='An optional path to file with preprocessing parameters.')
+parser.add_argument('--input', help='Path to input image or video file. Skip this argument to capture frames from a camera.')
+parser.add_argument('--out_tf_graph', default='graph.pbtxt',
+                    help='For models from TensorFlow Object Detection API, you may '
+                         'pass a .config file which was used for training through --config '
+                         'argument. This way an additional .pbtxt file with TensorFlow graph will be created.')
+parser.add_argument('--framework', choices=['caffe', 'tensorflow', 'torch', 'darknet', 'dldt'],
+                    help='Optional name of an origin framework of the model. '
+                         'Detect it automatically if it does not set.')
+parser.add_argument('--thr', type=float, default=0.5, help='Confidence threshold')
+parser.add_argument('--nms', type=float, default=0.4, help='Non-maximum suppression threshold')
+parser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,
+                    help="Choose one of computation backends: "
+                         "%d: automatically (by default), "
+                         "%d: Halide language (http://halide-lang.org/), "
+                         "%d: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                         "%d: OpenCV implementation, "
+                         "%d: VKCOM, "
+                         "%d: CUDA" % backends)
+parser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,
+                    help='Choose one of target computation devices: '
+                         '%d: CPU target (by default), '
+                         '%d: OpenCL, '
+                         '%d: OpenCL fp16 (half-float precision), '
+                         '%d: NCS2 VPU, '
+                         '%d: HDDL VPU, '
+                         '%d: Vulkan, '
+                         '%d: CUDA, '
+                         '%d: CUDA fp16 (half-float preprocess)' % targets)
+parser.add_argument('--async', type=int, default=0,
+                    dest='asyncN',
+                    help='Number of asynchronous forwards at the same time. '
+                         'Choose 0 for synchronous mode')
+args, _ = parser.parse_known_args()
+add_preproc_args(args.zoo, parser, 'object_detection')
+parser = argparse.ArgumentParser(parents=[parser],
+                                 description='Use this script to run object detection deep learning networks using OpenCV.',
+                                 formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+args = parser.parse_args()
+
+args.model = findFile(args.model)
+args.config = findFile(args.config)
+args.classes = findFile(args.classes)
+
+# If config specified, try to load it as TensorFlow Object Detection API's pipeline.
+config = readTextMessage(args.config)
+if 'model' in config:
+    print('TensorFlow Object Detection API config detected')
+    if 'ssd' in config['model'][0]:
+        print('Preparing text graph representation for SSD model: ' + args.out_tf_graph)
+        createSSDGraph(args.model, args.config, args.out_tf_graph)
+        args.config = args.out_tf_graph
+    elif 'faster_rcnn' in config['model'][0]:
+        print('Preparing text graph representation for Faster-RCNN model: ' + args.out_tf_graph)
+        createFasterRCNNGraph(args.model, args.config, args.out_tf_graph)
+        args.config = args.out_tf_graph
+
+
+# Load names of classes
+classes = None
+if args.classes:
+    with open(args.classes, 'rt') as f:
+        classes = f.read().rstrip('\n').split('\n')
+
+# Load a network
+net = cv.dnn.readNet(cv.samples.findFile(args.model), cv.samples.findFile(args.config), args.framework)
+net.setPreferableBackend(args.backend)
+net.setPreferableTarget(args.target)
+outNames = net.getUnconnectedOutLayersNames()
+
+confThreshold = args.thr
+nmsThreshold = args.nms
+
+def postprocess(frame, outs):
+    frameHeight = frame.shape[0]
+    frameWidth = frame.shape[1]
+
+    def drawPred(classId, conf, left, top, right, bottom):
+        # Draw a bounding box.
+        cv.rectangle(frame, (left, top), (right, bottom), (0, 255, 0))
+
+        label = '%.2f' % conf
+
+        # Print a label of class.
+        if classes:
+            assert(classId < len(classes))
+            label = '%s: %s' % (classes[classId], label)
+
+        labelSize, baseLine = cv.getTextSize(label, cv.FONT_HERSHEY_SIMPLEX, 0.5, 1)
+        top = max(top, labelSize[1])
+        cv.rectangle(frame, (left, top - labelSize[1]), (left + labelSize[0], top + baseLine), (255, 255, 255), cv.FILLED)
+        cv.putText(frame, label, (left, top), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))
+
+    layerNames = net.getLayerNames()
+    lastLayerId = net.getLayerId(layerNames[-1])
+    lastLayer = net.getLayer(lastLayerId)
+
+    classIds = []
+    confidences = []
+    boxes = []
+    if lastLayer.type == 'DetectionOutput':
+        # Network produces output blob with a shape 1x1xNx7 where N is a number of
+        # detections and an every detection is a vector of values
+        # [batchId, classId, confidence, left, top, right, bottom]
+        for out in outs:
+            for detection in out[0, 0]:
+                confidence = detection[2]
+                if confidence > confThreshold:
+                    left = int(detection[3])
+                    top = int(detection[4])
+                    right = int(detection[5])
+                    bottom = int(detection[6])
+                    width = right - left + 1
+                    height = bottom - top + 1
+                    if width <= 2 or height <= 2:
+                        left = int(detection[3] * frameWidth)
+                        top = int(detection[4] * frameHeight)
+                        right = int(detection[5] * frameWidth)
+                        bottom = int(detection[6] * frameHeight)
+                        width = right - left + 1
+                        height = bottom - top + 1
+                    classIds.append(int(detection[1]) - 1)  # Skip background label
+                    confidences.append(float(confidence))
+                    boxes.append([left, top, width, height])
+    elif lastLayer.type == 'Region':
+        # Network produces output blob with a shape NxC where N is a number of
+        # detected objects and C is a number of classes + 4 where the first 4
+        # numbers are [center_x, center_y, width, height]
+        for out in outs:
+            for detection in out:
+                scores = detection[5:]
+                classId = np.argmax(scores)
+                confidence = scores[classId]
+                if confidence > confThreshold:
+                    center_x = int(detection[0] * frameWidth)
+                    center_y = int(detection[1] * frameHeight)
+                    width = int(detection[2] * frameWidth)
+                    height = int(detection[3] * frameHeight)
+                    left = int(center_x - width / 2)
+                    top = int(center_y - height / 2)
+                    classIds.append(classId)
+                    confidences.append(float(confidence))
+                    boxes.append([left, top, width, height])
+    else:
+        print('Unknown output layer type: ' + lastLayer.type)
+        exit()
+
+    # NMS is used inside Region layer only on DNN_BACKEND_OPENCV for another backends we need NMS in sample
+    # or NMS is required if number of outputs > 1
+    if len(outNames) > 1 or lastLayer.type == 'Region' and args.backend != cv.dnn.DNN_BACKEND_OPENCV:
+        indices = []
+        classIds = np.array(classIds)
+        boxes = np.array(boxes)
+        confidences = np.array(confidences)
+        unique_classes = set(classIds)
+        for cl in unique_classes:
+            class_indices = np.where(classIds == cl)[0]
+            conf = confidences[class_indices]
+            box  = boxes[class_indices].tolist()
+            nms_indices = cv.dnn.NMSBoxes(box, conf, confThreshold, nmsThreshold)
+            nms_indices = nms_indices[:, 0] if len(nms_indices) else []
+            indices.extend(class_indices[nms_indices])
+    else:
+        indices = np.arange(0, len(classIds))
+
+    for i in indices:
+        box = boxes[i]
+        left = box[0]
+        top = box[1]
+        width = box[2]
+        height = box[3]
+        drawPred(classIds[i], confidences[i], left, top, left + width, top + height)
+
+# Process inputs
+winName = 'Deep learning object detection in OpenCV'
+cv.namedWindow(winName, cv.WINDOW_NORMAL)
+
+def callback(pos):
+    global confThreshold
+    confThreshold = pos / 100.0
+
+cv.createTrackbar('Confidence threshold, %', winName, int(confThreshold * 100), 99, callback)
+
+cap = cv.VideoCapture(cv.samples.findFileOrKeep(args.input) if args.input else 0)
+
+class QueueFPS(queue.Queue):
+    def __init__(self):
+        queue.Queue.__init__(self)
+        self.startTime = 0
+        self.counter = 0
+
+    def put(self, v):
+        queue.Queue.put(self, v)
+        self.counter += 1
+        if self.counter == 1:
+            self.startTime = time.time()
+
+    def getFPS(self):
+        return self.counter / (time.time() - self.startTime)
+
+
+process = True
+
+#
+# Frames capturing thread
+#
+framesQueue = QueueFPS()
+def framesThreadBody():
+    global framesQueue, process
+
+    while process:
+        hasFrame, frame = cap.read()
+        if not hasFrame:
+            break
+        framesQueue.put(frame)
+
+
+#
+# Frames processing thread
+#
+processedFramesQueue = queue.Queue()
+predictionsQueue = QueueFPS()
+def processingThreadBody():
+    global processedFramesQueue, predictionsQueue, args, process
+
+    futureOutputs = []
+    while process:
+        # Get a next frame
+        frame = None
+        try:
+            frame = framesQueue.get_nowait()
+
+            if args.asyncN:
+                if len(futureOutputs) == args.asyncN:
+                    frame = None  # Skip the frame
+            else:
+                framesQueue.queue.clear()  # Skip the rest of frames
+        except queue.Empty:
+            pass
+
+
+        if not frame is None:
+            frameHeight = frame.shape[0]
+            frameWidth = frame.shape[1]
+
+            # Create a 4D blob from a frame.
+            inpWidth = args.width if args.width else frameWidth
+            inpHeight = args.height if args.height else frameHeight
+            blob = cv.dnn.blobFromImage(frame, size=(inpWidth, inpHeight), swapRB=args.rgb, ddepth=cv.CV_8U)
+            processedFramesQueue.put(frame)
+
+            # Run a model
+            net.setInput(blob, scalefactor=args.scale, mean=args.mean)
+            if net.getLayer(0).outputNameToIndex('im_info') != -1:  # Faster-RCNN or R-FCN
+                frame = cv.resize(frame, (inpWidth, inpHeight))
+                net.setInput(np.array([[inpHeight, inpWidth, 1.6]], dtype=np.float32), 'im_info')
+
+            if args.asyncN:
+                futureOutputs.append(net.forwardAsync())
+            else:
+                outs = net.forward(outNames)
+                predictionsQueue.put(np.copy(outs))
+
+        while futureOutputs and futureOutputs[0].wait_for(0):
+            out = futureOutputs[0].get()
+            predictionsQueue.put(np.copy([out]))
+
+            del futureOutputs[0]
+
+
+framesThread = Thread(target=framesThreadBody)
+framesThread.start()
+
+processingThread = Thread(target=processingThreadBody)
+processingThread.start()
+
+#
+# Postprocessing and rendering loop
+#
+while cv.waitKey(1) < 0:
+    try:
+        # Request prediction first because they put after frames
+        outs = predictionsQueue.get_nowait()
+        frame = processedFramesQueue.get_nowait()
+
+        postprocess(frame, outs)
+
+        # Put efficiency information.
+        if predictionsQueue.counter > 1:
+            label = 'Camera: %.2f FPS' % (framesQueue.getFPS())
+            cv.putText(frame, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
+
+            label = 'Network: %.2f FPS' % (predictionsQueue.getFPS())
+            cv.putText(frame, label, (0, 30), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
+
+            label = 'Skipped frames: %d' % (framesQueue.counter - predictionsQueue.counter)
+            cv.putText(frame, label, (0, 45), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
+
+        cv.imshow(winName, frame)
+    except queue.Empty:
+        pass
+
+
+process = False
+framesThread.join()
+processingThread.join()
diff --git a/C++/opencv-4.7.0/samples/dnn/openpose.cpp b/C++/opencv-4.7.0/samples/dnn/openpose.cpp
new file mode 100644
index 00000000..ced597a1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/openpose.cpp
@@ -0,0 +1,157 @@
+//
+//  this sample demonstrates the use of pretrained openpose networks with opencv's dnn module.
+//
+//  it can be used for body pose detection, using either the COCO model(18 parts):
+//  http://posefs1.perception.cs.cmu.edu/OpenPose/models/pose/coco/pose_iter_440000.caffemodel
+//  https://raw.githubusercontent.com/opencv/opencv_extra/4.x/testdata/dnn/openpose_pose_coco.prototxt
+//
+//  or the MPI model(16 parts):
+//  http://posefs1.perception.cs.cmu.edu/OpenPose/models/pose/mpi/pose_iter_160000.caffemodel
+//  https://raw.githubusercontent.com/opencv/opencv_extra/4.x/testdata/dnn/openpose_pose_mpi_faster_4_stages.prototxt
+//
+//  (to simplify this sample, the body models are restricted to a single person.)
+//
+//
+//  you can also try the hand pose model:
+//  http://posefs1.perception.cs.cmu.edu/OpenPose/models/hand/pose_iter_102000.caffemodel
+//  https://raw.githubusercontent.com/CMU-Perceptual-Computing-Lab/openpose/master/models/hand/pose_deploy.prototxt
+//
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+using namespace cv;
+using namespace cv::dnn;
+
+#include <iostream>
+using namespace std;
+
+
+// connection table, in the format [model_id][pair_id][from/to]
+// please look at the nice explanation at the bottom of:
+// https://github.com/CMU-Perceptual-Computing-Lab/openpose/blob/master/doc/output.md
+//
+const int POSE_PAIRS[3][20][2] = {
+{   // COCO body
+    {1,2}, {1,5}, {2,3},
+    {3,4}, {5,6}, {6,7},
+    {1,8}, {8,9}, {9,10},
+    {1,11}, {11,12}, {12,13},
+    {1,0}, {0,14},
+    {14,16}, {0,15}, {15,17}
+},
+{   // MPI body
+    {0,1}, {1,2}, {2,3},
+    {3,4}, {1,5}, {5,6},
+    {6,7}, {1,14}, {14,8}, {8,9},
+    {9,10}, {14,11}, {11,12}, {12,13}
+},
+{   // hand
+    {0,1}, {1,2}, {2,3}, {3,4},         // thumb
+    {0,5}, {5,6}, {6,7}, {7,8},         // pinkie
+    {0,9}, {9,10}, {10,11}, {11,12},    // middle
+    {0,13}, {13,14}, {14,15}, {15,16},  // ring
+    {0,17}, {17,18}, {18,19}, {19,20}   // small
+}};
+
+int main(int argc, char **argv)
+{
+    CommandLineParser parser(argc, argv,
+        "{ h help           | false     | print this help message }"
+        "{ p proto          |           | (required) model configuration, e.g. hand/pose.prototxt }"
+        "{ m model          |           | (required) model weights, e.g. hand/pose_iter_102000.caffemodel }"
+        "{ i image          |           | (required) path to image file (containing a single person, or hand) }"
+        "{ d dataset        |           | specify what kind of model was trained. It could be (COCO, MPI, HAND) depends on dataset. }"
+        "{ width            |  368      | Preprocess input image by resizing to a specific width. }"
+        "{ height           |  368      | Preprocess input image by resizing to a specific height. }"
+        "{ t threshold      |  0.1      | threshold or confidence value for the heatmap }"
+        "{ s scale          |  0.003922 | scale for blob }"
+    );
+
+    String modelTxt = samples::findFile(parser.get<string>("proto"));
+    String modelBin = samples::findFile(parser.get<string>("model"));
+    String imageFile = samples::findFile(parser.get<String>("image"));
+    String dataset = parser.get<String>("dataset");
+    int W_in = parser.get<int>("width");
+    int H_in = parser.get<int>("height");
+    float thresh = parser.get<float>("threshold");
+    float scale  = parser.get<float>("scale");
+
+    if (parser.get<bool>("help") || modelTxt.empty() || modelBin.empty() || imageFile.empty())
+    {
+        cout << "A sample app to demonstrate human or hand pose detection with a pretrained OpenPose dnn." << endl;
+        parser.printMessage();
+        return 0;
+    }
+
+    int midx, npairs, nparts;
+         if (!dataset.compare("COCO")) {  midx = 0; npairs = 17; nparts = 18; }
+    else if (!dataset.compare("MPI"))  {  midx = 1; npairs = 14; nparts = 16; }
+    else if (!dataset.compare("HAND")) {  midx = 2; npairs = 20; nparts = 22; }
+    else
+    {
+        std::cerr << "Can't interpret dataset parameter: " << dataset << std::endl;
+        exit(-1);
+    }
+
+    // read the network model
+    Net net = readNet(modelBin, modelTxt);
+    // and the image
+    Mat img = imread(imageFile);
+    if (img.empty())
+    {
+        std::cerr << "Can't read image from the file: " << imageFile << std::endl;
+        exit(-1);
+    }
+
+    // send it through the network
+    Mat inputBlob = blobFromImage(img, scale, Size(W_in, H_in), Scalar(0, 0, 0), false, false);
+    net.setInput(inputBlob);
+    Mat result = net.forward();
+    // the result is an array of "heatmaps", the probability of a body part being in location x,y
+
+    int H = result.size[2];
+    int W = result.size[3];
+
+    // find the position of the body parts
+    vector<Point> points(22);
+    for (int n=0; n<nparts; n++)
+    {
+        // Slice heatmap of corresponding body's part.
+        Mat heatMap(H, W, CV_32F, result.ptr(0,n));
+        // 1 maximum per heatmap
+        Point p(-1,-1),pm;
+        double conf;
+        minMaxLoc(heatMap, 0, &conf, 0, &pm);
+        if (conf > thresh)
+            p = pm;
+        points[n] = p;
+    }
+
+    // connect body parts and draw it !
+    float SX = float(img.cols) / W;
+    float SY = float(img.rows) / H;
+    for (int n=0; n<npairs; n++)
+    {
+        // lookup 2 connected body/hand parts
+        Point2f a = points[POSE_PAIRS[midx][n][0]];
+        Point2f b = points[POSE_PAIRS[midx][n][1]];
+
+        // we did not find enough confidence before
+        if (a.x<=0 || a.y<=0 || b.x<=0 || b.y<=0)
+            continue;
+
+        // scale to image size
+        a.x*=SX; a.y*=SY;
+        b.x*=SX; b.y*=SY;
+
+        line(img, a, b, Scalar(0,200,0), 2);
+        circle(img, a, 3, Scalar(0,0,200), -1);
+        circle(img, b, 3, Scalar(0,0,200), -1);
+    }
+
+    imshow("OpenPose", img);
+    waitKey();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/openpose.py b/C++/opencv-4.7.0/samples/dnn/openpose.py
new file mode 100644
index 00000000..191d23ed
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/openpose.py
@@ -0,0 +1,122 @@
+# To use Inference Engine backend, specify location of plugins:
+# source /opt/intel/computer_vision_sdk/bin/setupvars.sh
+import cv2 as cv
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(
+        description='This script is used to demonstrate OpenPose human pose estimation network '
+                    'from https://github.com/CMU-Perceptual-Computing-Lab/openpose project using OpenCV. '
+                    'The sample and model are simplified and could be used for a single person on the frame.')
+parser.add_argument('--input', help='Path to image or video. Skip to capture frames from camera')
+parser.add_argument('--proto', help='Path to .prototxt')
+parser.add_argument('--model', help='Path to .caffemodel')
+parser.add_argument('--dataset', help='Specify what kind of model was trained. '
+                                      'It could be (COCO, MPI, HAND) depends on dataset.')
+parser.add_argument('--thr', default=0.1, type=float, help='Threshold value for pose parts heat map')
+parser.add_argument('--width', default=368, type=int, help='Resize input to specific width.')
+parser.add_argument('--height', default=368, type=int, help='Resize input to specific height.')
+parser.add_argument('--scale', default=0.003922, type=float, help='Scale for blob.')
+
+args = parser.parse_args()
+
+if args.dataset == 'COCO':
+    BODY_PARTS = { "Nose": 0, "Neck": 1, "RShoulder": 2, "RElbow": 3, "RWrist": 4,
+                   "LShoulder": 5, "LElbow": 6, "LWrist": 7, "RHip": 8, "RKnee": 9,
+                   "RAnkle": 10, "LHip": 11, "LKnee": 12, "LAnkle": 13, "REye": 14,
+                   "LEye": 15, "REar": 16, "LEar": 17, "Background": 18 }
+
+    POSE_PAIRS = [ ["Neck", "RShoulder"], ["Neck", "LShoulder"], ["RShoulder", "RElbow"],
+                   ["RElbow", "RWrist"], ["LShoulder", "LElbow"], ["LElbow", "LWrist"],
+                   ["Neck", "RHip"], ["RHip", "RKnee"], ["RKnee", "RAnkle"], ["Neck", "LHip"],
+                   ["LHip", "LKnee"], ["LKnee", "LAnkle"], ["Neck", "Nose"], ["Nose", "REye"],
+                   ["REye", "REar"], ["Nose", "LEye"], ["LEye", "LEar"] ]
+elif args.dataset == 'MPI':
+    BODY_PARTS = { "Head": 0, "Neck": 1, "RShoulder": 2, "RElbow": 3, "RWrist": 4,
+                   "LShoulder": 5, "LElbow": 6, "LWrist": 7, "RHip": 8, "RKnee": 9,
+                   "RAnkle": 10, "LHip": 11, "LKnee": 12, "LAnkle": 13, "Chest": 14,
+                   "Background": 15 }
+
+    POSE_PAIRS = [ ["Head", "Neck"], ["Neck", "RShoulder"], ["RShoulder", "RElbow"],
+                   ["RElbow", "RWrist"], ["Neck", "LShoulder"], ["LShoulder", "LElbow"],
+                   ["LElbow", "LWrist"], ["Neck", "Chest"], ["Chest", "RHip"], ["RHip", "RKnee"],
+                   ["RKnee", "RAnkle"], ["Chest", "LHip"], ["LHip", "LKnee"], ["LKnee", "LAnkle"] ]
+elif args.dataset == 'HAND':
+    BODY_PARTS = { "Wrist": 0,
+                   "ThumbMetacarpal": 1, "ThumbProximal": 2, "ThumbMiddle": 3, "ThumbDistal": 4,
+                   "IndexFingerMetacarpal": 5, "IndexFingerProximal": 6, "IndexFingerMiddle": 7, "IndexFingerDistal": 8,
+                   "MiddleFingerMetacarpal": 9, "MiddleFingerProximal": 10, "MiddleFingerMiddle": 11, "MiddleFingerDistal": 12,
+                   "RingFingerMetacarpal": 13, "RingFingerProximal": 14, "RingFingerMiddle": 15, "RingFingerDistal": 16,
+                   "LittleFingerMetacarpal": 17, "LittleFingerProximal": 18, "LittleFingerMiddle": 19, "LittleFingerDistal": 20,
+                 }
+
+    POSE_PAIRS = [ ["Wrist", "ThumbMetacarpal"], ["ThumbMetacarpal", "ThumbProximal"],
+                   ["ThumbProximal", "ThumbMiddle"], ["ThumbMiddle", "ThumbDistal"],
+                   ["Wrist", "IndexFingerMetacarpal"], ["IndexFingerMetacarpal", "IndexFingerProximal"],
+                   ["IndexFingerProximal", "IndexFingerMiddle"], ["IndexFingerMiddle", "IndexFingerDistal"],
+                   ["Wrist", "MiddleFingerMetacarpal"], ["MiddleFingerMetacarpal", "MiddleFingerProximal"],
+                   ["MiddleFingerProximal", "MiddleFingerMiddle"], ["MiddleFingerMiddle", "MiddleFingerDistal"],
+                   ["Wrist", "RingFingerMetacarpal"], ["RingFingerMetacarpal", "RingFingerProximal"],
+                   ["RingFingerProximal", "RingFingerMiddle"], ["RingFingerMiddle", "RingFingerDistal"],
+                   ["Wrist", "LittleFingerMetacarpal"], ["LittleFingerMetacarpal", "LittleFingerProximal"],
+                   ["LittleFingerProximal", "LittleFingerMiddle"], ["LittleFingerMiddle", "LittleFingerDistal"] ]
+else:
+    raise(Exception("you need to specify either 'COCO', 'MPI', or 'Hand' in args.dataset"))
+
+inWidth = args.width
+inHeight = args.height
+inScale = args.scale
+
+net = cv.dnn.readNet(cv.samples.findFile(args.proto), cv.samples.findFile(args.model))
+
+cap = cv.VideoCapture(args.input if args.input else 0)
+
+while cv.waitKey(1) < 0:
+    hasFrame, frame = cap.read()
+    if not hasFrame:
+        cv.waitKey()
+        break
+
+    frameWidth = frame.shape[1]
+    frameHeight = frame.shape[0]
+    inp = cv.dnn.blobFromImage(frame, inScale, (inWidth, inHeight),
+                              (0, 0, 0), swapRB=False, crop=False)
+    net.setInput(inp)
+    out = net.forward()
+
+    assert(len(BODY_PARTS) <= out.shape[1])
+
+    points = []
+    for i in range(len(BODY_PARTS)):
+        # Slice heatmap of corresponding body's part.
+        heatMap = out[0, i, :, :]
+
+        # Originally, we try to find all the local maximums. To simplify a sample
+        # we just find a global one. However only a single pose at the same time
+        # could be detected this way.
+        _, conf, _, point = cv.minMaxLoc(heatMap)
+        x = (frameWidth * point[0]) / out.shape[3]
+        y = (frameHeight * point[1]) / out.shape[2]
+
+        # Add a point if it's confidence is higher than threshold.
+        points.append((int(x), int(y)) if conf > args.thr else None)
+
+    for pair in POSE_PAIRS:
+        partFrom = pair[0]
+        partTo = pair[1]
+        assert(partFrom in BODY_PARTS)
+        assert(partTo in BODY_PARTS)
+
+        idFrom = BODY_PARTS[partFrom]
+        idTo = BODY_PARTS[partTo]
+
+        if points[idFrom] and points[idTo]:
+            cv.line(frame, points[idFrom], points[idTo], (0, 255, 0), 3)
+            cv.ellipse(frame, points[idFrom], (3, 3), 0, 0, 360, (0, 0, 255), cv.FILLED)
+            cv.ellipse(frame, points[idTo], (3, 3), 0, 0, 360, (0, 0, 255), cv.FILLED)
+
+    t, _ = net.getPerfProfile()
+    freq = cv.getTickFrequency() / 1000
+    cv.putText(frame, '%.2fms' % (t / freq), (10, 20), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0))
+
+    cv.imshow('OpenPose using OpenCV', frame)
diff --git a/C++/opencv-4.7.0/samples/dnn/optical_flow.py b/C++/opencv-4.7.0/samples/dnn/optical_flow.py
new file mode 100644
index 00000000..da2a5808
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/optical_flow.py
@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+'''
+This sample using FlowNet v2 model to calculate optical flow.
+Original paper: https://arxiv.org/abs/1612.01925.
+Original repo:  https://github.com/lmb-freiburg/flownet2.
+
+Download the converted .caffemodel model from https://drive.google.com/open?id=16qvE9VNmU39NttpZwZs81Ga8VYQJDaWZ
+and .prototxt from https://drive.google.com/file/d/1RyNIUsan1ZOh2hpYIH36A-jofAvJlT6a/view?usp=sharing.
+Otherwise download original model from https://lmb.informatik.uni-freiburg.de/resources/binaries/flownet2/flownet2-models.tar.gz,
+convert .h5 model to .caffemodel and modify original .prototxt using .prototxt from link above.
+'''
+
+import argparse
+import os.path
+import numpy as np
+import cv2 as cv
+
+
+class OpticalFlow(object):
+    def __init__(self, proto, model, height, width):
+        self.net = cv.dnn.readNetFromCaffe(proto, model)
+        self.net.setPreferableBackend(cv.dnn.DNN_BACKEND_OPENCV)
+        self.height = height
+        self.width = width
+
+    def compute_flow(self, first_img, second_img):
+        inp0 = cv.dnn.blobFromImage(first_img, size=(self.width, self.height))
+        inp1 = cv.dnn.blobFromImage(second_img, size=(self.width, self.height))
+        self.net.setInput(inp0, "img0")
+        self.net.setInput(inp1, "img1")
+        flow = self.net.forward()
+        output = self.motion_to_color(flow)
+        return output
+
+    def motion_to_color(self, flow):
+        arr = np.arange(0, 255, dtype=np.uint8)
+        colormap = cv.applyColorMap(arr, cv.COLORMAP_HSV)
+        colormap = colormap.squeeze(1)
+
+        flow = flow.squeeze(0)
+        fx, fy = flow[0, ...], flow[1, ...]
+        rad = np.sqrt(fx**2 + fy**2)
+        maxrad = rad.max() if rad.max() != 0 else 1
+
+        ncols = arr.size
+        rad = rad[..., np.newaxis] / maxrad
+        a = np.arctan2(-fy / maxrad, -fx / maxrad) / np.pi
+        fk = (a + 1) / 2.0 * (ncols - 1)
+        k0 = fk.astype(np.int)
+        k1 = (k0 + 1) % ncols
+        f = fk[..., np.newaxis] - k0[..., np.newaxis]
+
+        col0 = colormap[k0] / 255.0
+        col1 = colormap[k1] / 255.0
+        col = (1 - f) * col0 + f * col1
+        col = np.where(rad <= 1, 1 - rad * (1 - col), col * 0.75)
+        output = (255.0 * col).astype(np.uint8)
+        return output
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Use this script to calculate optical flow using FlowNetv2',
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('-input', '-i', required=True, help='Path to input video file. Skip this argument to capture frames from a camera.')
+    parser.add_argument('--height', default=320, type=int, help='Input height')
+    parser.add_argument('--width', default=448, type=int, help='Input width')
+    parser.add_argument('--proto', '-p', default='FlowNet2_deploy_anysize.prototxt', help='Path to prototxt.')
+    parser.add_argument('--model', '-m', default='FlowNet2_weights.caffemodel', help='Path to caffemodel.')
+    args, _ = parser.parse_known_args()
+
+    if not os.path.isfile(args.model) or not os.path.isfile(args.proto):
+        raise OSError("Prototxt or caffemodel not exist")
+
+    winName = 'Calculation optical flow in OpenCV'
+    cv.namedWindow(winName, cv.WINDOW_NORMAL)
+    cap = cv.VideoCapture(args.input if args.input else 0)
+    hasFrame, first_frame = cap.read()
+
+    divisor = 64.
+    var = {}
+    var['ADAPTED_WIDTH'] = int(np.ceil(args.width/divisor) * divisor)
+    var['ADAPTED_HEIGHT'] = int(np.ceil(args.height/divisor) * divisor)
+    var['SCALE_WIDTH'] = args.width / float(var['ADAPTED_WIDTH'])
+    var['SCALE_HEIGHT'] = args.height / float(var['ADAPTED_HEIGHT'])
+
+    config = ''
+    proto = open(args.proto).readlines()
+    for line in proto:
+        for key, value in var.items():
+            tag = "$%s$" % key
+            line = line.replace(tag, str(value))
+        config += line
+
+    caffemodel = open(args.model, 'rb').read()
+
+    opt_flow = OpticalFlow(bytearray(config.encode()), caffemodel, var['ADAPTED_HEIGHT'], var['ADAPTED_WIDTH'])
+    while cv.waitKey(1) < 0:
+        hasFrame, second_frame = cap.read()
+        if not hasFrame:
+            break
+        flow = opt_flow.compute_flow(first_frame, second_frame)
+        first_frame = second_frame
+        cv.imshow(winName, flow)
diff --git a/C++/opencv-4.7.0/samples/dnn/person_reid.cpp b/C++/opencv-4.7.0/samples/dnn/person_reid.cpp
new file mode 100644
index 00000000..f0c22e96
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/person_reid.cpp
@@ -0,0 +1,242 @@
+//
+// You can download a baseline ReID model and sample input from:
+// https://github.com/ReID-Team/ReID_extra_testdata
+//
+// Authors of samples and Youtu ReID baseline:
+//         Xing Sun <winfredsun@tencent.com>
+//         Feng Zheng <zhengf@sustech.edu.cn>
+//         Xinyang Jiang <sevjiang@tencent.com>
+//         Fufu Yu <fufuyu@tencent.com>
+//         Enwei Zhang <miyozhang@tencent.com>
+//
+// Copyright (C) 2020-2021, Tencent.
+// Copyright (C) 2020-2021, SUSTech.
+//
+#include <iostream>
+#include <fstream>
+
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/dnn.hpp>
+
+using namespace cv;
+using namespace cv::dnn;
+
+const char* keys =
+"{help    h  |                 | show help message}"
+"{model   m  |                 | network model}"
+"{query_list q |               | list of query images}"
+"{gallery_list g |             | list of gallery images}"
+"{batch_size | 32              | batch size of each inference}"
+"{resize_h   | 256             | resize input to specific height.}"
+"{resize_w   | 128             | resize input to specific width.}"
+"{topk k     | 5               | number of gallery images showed in visualization}"
+"{output_dir |                 | path for visualization(it should be existed)}"
+"{backend b  | 0               | choose one of computation backends: "
+"0: automatically (by default), "
+"1: Halide language (http://halide-lang.org/), "
+"2: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+"3: OpenCV implementation, "
+"4: VKCOM, "
+"5: CUDA }"
+"{target  t  | 0                | choose one of target computation devices: "
+"0: CPU target (by default), "
+"1: OpenCL, "
+"2: OpenCL fp16 (half-float precision), "
+"4: Vulkan, "
+"6: CUDA, "
+"7: CUDA fp16 (half-float preprocess) }";
+
+namespace cv{
+namespace reid{
+
+static Mat preprocess(const Mat& img)
+{
+    const double mean[3] = {0.485, 0.456, 0.406};
+    const double std[3] = {0.229, 0.224, 0.225};
+    Mat ret = Mat(img.rows, img.cols, CV_32FC3);
+    for (int y = 0; y < ret.rows; y ++)
+    {
+        for (int x = 0; x < ret.cols; x++)
+        {
+            for (int c = 0; c < 3; c++)
+            {
+                ret.at<Vec3f>(y,x)[c] = (float)((img.at<Vec3b>(y,x)[c] / 255.0 - mean[2 - c]) / std[2 - c]);
+            }
+        }
+    }
+    return ret;
+}
+
+static std::vector<float> normalization(const std::vector<float>& feature)
+{
+    std::vector<float> ret;
+    float sum = 0.0;
+    for(int i = 0; i < (int)feature.size(); i++)
+    {
+        sum += feature[i] * feature[i];
+    }
+    sum = sqrt(sum);
+    for(int i = 0; i < (int)feature.size(); i++)
+    {
+        ret.push_back(feature[i] / sum);
+    }
+    return ret;
+}
+
+static void extractFeatures(const std::vector<std::string>& imglist, Net* net, const int& batch_size, const int& resize_h, const int& resize_w, std::vector<std::vector<float>>& features)
+{
+    for(int st = 0; st < (int)imglist.size(); st += batch_size)
+    {
+        std::vector<Mat> batch;
+        for(int delta = 0; delta < batch_size && st + delta < (int)imglist.size(); delta++)
+        {
+            Mat img = imread(imglist[st + delta]);
+            batch.push_back(preprocess(img));
+        }
+        Mat blob = dnn::blobFromImages(batch, 1.0, Size(resize_w, resize_h), Scalar(0.0,0.0,0.0), true, false, CV_32F);
+        net->setInput(blob);
+        Mat out = net->forward();
+        for(int i = 0; i < (int)out.size().height; i++)
+        {
+            std::vector<float> temp_feature;
+            for(int j = 0; j < (int)out.size().width; j++)
+            {
+                temp_feature.push_back(out.at<float>(i,j));
+            }
+            features.push_back(normalization(temp_feature));
+        }
+    }
+    return ;
+}
+
+static void getNames(const std::string& ImageList, std::vector<std::string>& result)
+{
+    std::ifstream img_in(ImageList);
+    std::string img_name;
+    while(img_in >> img_name)
+    {
+        result.push_back(img_name);
+    }
+    return ;
+}
+
+static float similarity(const std::vector<float>& feature1, const std::vector<float>& feature2)
+{
+    float result = 0.0;
+    for(int i = 0; i < (int)feature1.size(); i++)
+    {
+        result += feature1[i] * feature2[i];
+    }
+    return result;
+}
+
+static void getTopK(const std::vector<std::vector<float>>& queryFeatures, const std::vector<std::vector<float>>& galleryFeatures, const int& topk, std::vector<std::vector<int>>& result)
+{
+    for(int i = 0; i < (int)queryFeatures.size(); i++)
+    {
+        std::vector<float> similarityList;
+        std::vector<int> index;
+        for(int j = 0; j < (int)galleryFeatures.size(); j++)
+        {
+            similarityList.push_back(similarity(queryFeatures[i], galleryFeatures[j]));
+            index.push_back(j);
+        }
+        sort(index.begin(), index.end(), [&](int x,int y){return similarityList[x] > similarityList[y];});
+        std::vector<int> topk_result;
+        for(int j = 0; j < min(topk, (int)index.size()); j++)
+        {
+            topk_result.push_back(index[j]);
+        }
+        result.push_back(topk_result);
+    }
+    return ;
+}
+
+static void addBorder(const Mat& img, const Scalar& color, Mat& result)
+{
+    const int bordersize = 5;
+    copyMakeBorder(img, result, bordersize, bordersize, bordersize, bordersize, cv::BORDER_CONSTANT, color);
+    return ;
+}
+
+static void drawRankList(const std::string& queryName, const std::vector<std::string>& galleryImageNames, const std::vector<int>& topk_index, const int& resize_h, const int& resize_w, Mat& result)
+{
+    const Size outputSize = Size(resize_w, resize_h);
+    Mat q_img = imread(queryName), temp_img;
+    resize(q_img, temp_img, outputSize);
+    addBorder(temp_img, Scalar(0,0,0), q_img);
+    putText(q_img, "Query", Point(10, 30), FONT_HERSHEY_COMPLEX, 1.0, Scalar(0,255,0), 2);
+    std::vector<Mat> Images;
+    Images.push_back(q_img);
+    for(int i = 0; i < (int)topk_index.size(); i++)
+    {
+        Mat g_img = imread(galleryImageNames[topk_index[i]]);
+        resize(g_img, temp_img, outputSize);
+        addBorder(temp_img, Scalar(255,255,255), g_img);
+        putText(g_img, "G" + std::to_string(i), Point(10, 30), FONT_HERSHEY_COMPLEX, 1.0, Scalar(0,255,0), 2);
+        Images.push_back(g_img);
+    }
+    hconcat(Images, result);
+    return ;
+}
+
+static void visualization(const std::vector<std::vector<int>>& topk, const std::vector<std::string>& queryImageNames, const std::vector<std::string>& galleryImageNames, const std::string& output_dir, const int& resize_h, const int& resize_w)
+{
+    for(int i = 0; i < (int)queryImageNames.size(); i++)
+    {
+        Mat img;
+        drawRankList(queryImageNames[i], galleryImageNames, topk[i], resize_h, resize_w, img);
+        std::string output_path = output_dir + "/" + queryImageNames[i].substr(queryImageNames[i].rfind("/")+1);
+        imwrite(output_path, img);
+    }
+    return ;
+}
+
+};
+};
+
+int main(int argc, char** argv)
+{
+    // Parse command line arguments.
+    CommandLineParser parser(argc, argv, keys);
+
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    parser = CommandLineParser(argc, argv, keys);
+    parser.about("Use this script to run ReID networks using OpenCV.");
+
+    const std::string modelPath = parser.get<String>("model");
+    const std::string queryImageList = parser.get<String>("query_list");
+    const std::string galleryImageList = parser.get<String>("gallery_list");
+    const int backend = parser.get<int>("backend");
+    const int target = parser.get<int>("target");
+    const int batch_size = parser.get<int>("batch_size");
+    const int resize_h = parser.get<int>("resize_h");
+    const int resize_w = parser.get<int>("resize_w");
+    const int topk = parser.get<int>("topk");
+    const std::string output_dir= parser.get<String>("output_dir");
+
+    std::vector<std::string> queryImageNames;
+    reid::getNames(queryImageList, queryImageNames);
+    std::vector<std::string> galleryImageNames;
+    reid::getNames(galleryImageList, galleryImageNames);
+
+    dnn::Net net = dnn::readNet(modelPath);
+    net.setPreferableBackend(backend);
+    net.setPreferableTarget(target);
+
+    std::vector<std::vector<float>> queryFeatures;
+    reid::extractFeatures(queryImageNames, &net, batch_size, resize_h, resize_w, queryFeatures);
+    std::vector<std::vector<float>> galleryFeatures;
+    reid::extractFeatures(galleryImageNames, &net, batch_size, resize_h, resize_w, galleryFeatures);
+
+    std::vector<std::vector<int>> topkResult;
+    reid::getTopK(queryFeatures, galleryFeatures, topk, topkResult);
+    reid::visualization(topkResult, queryImageNames, galleryImageNames, output_dir, resize_h, resize_w);
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/person_reid.py b/C++/opencv-4.7.0/samples/dnn/person_reid.py
new file mode 100644
index 00000000..08f04faa
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/person_reid.py
@@ -0,0 +1,240 @@
+#!/usr/bin/env python
+'''
+You can download a baseline ReID model and sample input from:
+https://github.com/ReID-Team/ReID_extra_testdata
+
+Authors of samples and Youtu ReID baseline:
+        Xing Sun <winfredsun@tencent.com>
+        Feng Zheng <zhengf@sustech.edu.cn>
+        Xinyang Jiang <sevjiang@tencent.com>
+        Fufu Yu <fufuyu@tencent.com>
+        Enwei Zhang <miyozhang@tencent.com>
+
+Copyright (C) 2020-2021, Tencent.
+Copyright (C) 2020-2021, SUSTech.
+'''
+import argparse
+import os.path
+import numpy as np
+import cv2 as cv
+
+backends = (cv.dnn.DNN_BACKEND_DEFAULT,
+    cv.dnn.DNN_BACKEND_INFERENCE_ENGINE,
+    cv.dnn.DNN_BACKEND_OPENCV,
+    cv.dnn.DNN_BACKEND_VKCOM,
+    cv.dnn.DNN_BACKEND_CUDA)
+
+targets = (cv.dnn.DNN_TARGET_CPU,
+    cv.dnn.DNN_TARGET_OPENCL,
+    cv.dnn.DNN_TARGET_OPENCL_FP16,
+    cv.dnn.DNN_TARGET_MYRIAD,
+    cv.dnn.DNN_TARGET_HDDL,
+    cv.dnn.DNN_TARGET_VULKAN,
+    cv.dnn.DNN_TARGET_CUDA,
+    cv.dnn.DNN_TARGET_CUDA_FP16)
+
+MEAN = (0.485, 0.456, 0.406)
+STD = (0.229, 0.224, 0.225)
+
+def preprocess(images, height, width):
+    """
+    Create 4-dimensional blob from image
+    :param image: input image
+    :param height: the height of the resized input image
+    :param width: the width of the resized input image
+    """
+    img_list = []
+    for image in images:
+        image = cv.resize(image, (width, height))
+        img_list.append(image[:, :, ::-1])
+
+    images = np.array(img_list)
+    images = (images / 255.0 - MEAN) / STD
+
+    input = cv.dnn.blobFromImages(images.astype(np.float32), ddepth = cv.CV_32F)
+    return input
+
+def extract_feature(img_dir, model_path, batch_size = 32, resize_h = 384, resize_w = 128, backend=cv.dnn.DNN_BACKEND_OPENCV, target=cv.dnn.DNN_TARGET_CPU):
+    """
+    Extract features from images in a target directory
+    :param img_dir: the input image directory
+    :param model_path: path to ReID model
+    :param batch_size: the batch size for each network inference iteration
+    :param resize_h: the height of the input image
+    :param resize_w: the width of the input image
+    :param backend: name of computation backend
+    :param target: name of computation target
+    """
+    feat_list = []
+    path_list = os.listdir(img_dir)
+    path_list = [os.path.join(img_dir, img_name) for img_name in path_list]
+    count = 0
+
+    for i in range(0, len(path_list), batch_size):
+        print('Feature Extraction for images in', img_dir, 'Batch:', count, '/', len(path_list))
+        batch = path_list[i : min(i + batch_size, len(path_list))]
+        imgs = read_data(batch)
+        inputs = preprocess(imgs, resize_h, resize_w)
+
+        feat = run_net(inputs, model_path, backend, target)
+
+        feat_list.append(feat)
+        count += batch_size
+
+    feats = np.concatenate(feat_list, axis = 0)
+    return feats, path_list
+
+def run_net(inputs, model_path, backend=cv.dnn.DNN_BACKEND_OPENCV, target=cv.dnn.DNN_TARGET_CPU):
+    """
+    Forword propagation for a batch of images.
+    :param inputs: input batch of images
+    :param model_path: path to ReID model
+    :param backend: name of computation backend
+    :param target: name of computation target
+    """
+    net = cv.dnn.readNet(model_path)
+    net.setPreferableBackend(backend)
+    net.setPreferableTarget(target)
+    net.setInput(inputs)
+    out = net.forward()
+    out = np.reshape(out, (out.shape[0], out.shape[1]))
+    return out
+
+def read_data(path_list):
+    """
+    Read all images from a directory into a list
+    :param path_list: the list of image path
+    """
+    img_list = []
+    for img_path in path_list:
+        img = cv.imread(img_path)
+        if img is None:
+            continue
+        img_list.append(img)
+    return img_list
+
+def normalize(nparray, order=2, axis=0):
+    """
+    Normalize a N-D numpy array along the specified axis.
+    :param nparry: the array of vectors to be normalized
+    :param order: order of the norm
+    :param axis: the axis of x along which to compute the vector norms
+    """
+    norm = np.linalg.norm(nparray, ord=order, axis=axis, keepdims=True)
+    return nparray / (norm + np.finfo(np.float32).eps)
+
+def similarity(array1, array2):
+    """
+    Compute the euclidean or cosine distance of all pairs.
+    :param  array1: numpy array with shape [m1, n]
+    :param  array2: numpy array with shape [m2, n]
+    Returns:
+      numpy array with shape [m1, m2]
+    """
+    array1 = normalize(array1, axis=1)
+    array2 = normalize(array2, axis=1)
+    dist = np.matmul(array1, array2.T)
+    return dist
+
+def topk(query_feat, gallery_feat, topk = 5):
+    """
+    Return the index of top K gallery images most similar to the query images
+    :param query_feat: array of feature vectors of query images
+    :param gallery_feat: array of feature vectors of gallery images
+    :param topk: number of gallery images to return
+    """
+    sim = similarity(query_feat, gallery_feat)
+    index = np.argsort(-sim, axis = 1)
+    return [i[0:int(topk)] for i in index]
+
+def drawRankList(query_name, gallery_list, output_size = (128, 384)):
+    """
+    Draw the rank list
+    :param query_name: path of the query image
+    :param gallery_name: path of the gallery image
+    "param output_size: the output size of each image in the rank list
+    """
+    def addBorder(im, color):
+        bordersize = 5
+        border = cv.copyMakeBorder(
+            im,
+            top = bordersize,
+            bottom = bordersize,
+            left = bordersize,
+            right = bordersize,
+            borderType = cv.BORDER_CONSTANT,
+            value = color
+        )
+        return border
+    query_img = cv.imread(query_name)
+    query_img = cv.resize(query_img, output_size)
+    query_img = addBorder(query_img, [0, 0, 0])
+    cv.putText(query_img, 'Query', (10, 30), cv.FONT_HERSHEY_COMPLEX, 1., (0,255,0), 2)
+
+    gallery_img_list = []
+    for i, gallery_name in enumerate(gallery_list):
+        gallery_img = cv.imread(gallery_name)
+        gallery_img = cv.resize(gallery_img, output_size)
+        gallery_img = addBorder(gallery_img, [255, 255, 255])
+        cv.putText(gallery_img, 'G%02d'%i, (10, 30), cv.FONT_HERSHEY_COMPLEX, 1., (0,255,0), 2)
+        gallery_img_list.append(gallery_img)
+    ret = np.concatenate([query_img] + gallery_img_list, axis = 1)
+    return ret
+
+
+def visualization(topk_idx, query_names, gallery_names, output_dir = 'vis'):
+    """
+    Visualize the retrieval results with the person ReID model
+    :param topk_idx: the index of ranked gallery images for each query image
+    :param query_names: the list of paths of query images
+    :param gallery_names: the list of paths of gallery images
+    :param output_dir: the path to save the visualize results
+    """
+    if not os.path.exists(output_dir):
+        os.mkdir(output_dir)
+    for i, idx in enumerate(topk_idx):
+        query_name = query_names[i]
+        topk_names = [gallery_names[j] for j in idx]
+        vis_img = drawRankList(query_name, topk_names)
+        output_path = os.path.join(output_dir, '%03d_%s'%(i, os.path.basename(query_name)))
+        cv.imwrite(output_path, vis_img)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Use this script to run human parsing using JPPNet',
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('--query_dir', '-q', required=True, help='Path to query image.')
+    parser.add_argument('--gallery_dir', '-g', required=True, help='Path to gallery directory.')
+    parser.add_argument('--resize_h', default = 256, help='The height of the input for model inference.')
+    parser.add_argument('--resize_w', default = 128, help='The width of the input for model inference')
+    parser.add_argument('--model', '-m', default='reid.onnx', help='Path to pb model.')
+    parser.add_argument('--visualization_dir', default='vis', help='Path for the visualization results')
+    parser.add_argument('--topk', default=10, help='Number of images visualized in the rank list')
+    parser.add_argument('--batchsize', default=32, help='The batch size of each inference')
+    parser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,
+                        help="Choose one of computation backends: "
+                             "%d: automatically (by default), "
+                             "%d: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                             "%d: OpenCV implementation, "
+                             "%d: VKCOM, "
+                             "%d: CUDA backend"% backends)
+    parser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,
+                        help='Choose one of target computation devices: '
+                             '%d: CPU target (by default), '
+                             '%d: OpenCL, '
+                             '%d: OpenCL fp16 (half-float precision), '
+                             '%d: NCS2 VPU, '
+                             '%d: HDDL VPU, '
+                             '%d: Vulkan, '
+                             '%d: CUDA, '
+                             '%d: CUDA FP16'
+                             % targets)
+    args, _ = parser.parse_known_args()
+
+    if not os.path.isfile(args.model):
+        raise OSError("Model not exist")
+
+    query_feat, query_names = extract_feature(args.query_dir, args.model, args.batchsize, args.resize_h, args.resize_w, args.backend, args.target)
+    gallery_feat, gallery_names = extract_feature(args.gallery_dir, args.model, args.batchsize, args.resize_h, args.resize_w, args.backend, args.target)
+
+    topk_idx = topk(query_feat, gallery_feat, args.topk)
+    visualization(topk_idx, query_names, gallery_names, output_dir = args.visualization_dir)
diff --git a/C++/opencv-4.7.0/samples/dnn/results/audrybt1.jpg b/C++/opencv-4.7.0/samples/dnn/results/audrybt1.jpg
new file mode 100644
index 00000000..5829f823
Binary files /dev/null and b/C++/opencv-4.7.0/samples/dnn/results/audrybt1.jpg differ
diff --git a/C++/opencv-4.7.0/samples/dnn/scene_text_detection.cpp b/C++/opencv-4.7.0/samples/dnn/scene_text_detection.cpp
new file mode 100644
index 00000000..15652993
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/scene_text_detection.cpp
@@ -0,0 +1,165 @@
+#include <iostream>
+#include <fstream>
+
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/dnn/dnn.hpp>
+
+using namespace cv;
+using namespace cv::dnn;
+
+std::string keys =
+        "{ help  h                          | | Print help message. }"
+        "{ inputImage i                     | | Path to an input image. Skip this argument to capture frames from a camera. }"
+        "{ modelPath mp                     | | Path to a binary .onnx file contains trained DB detector model. "
+            "Download links are provided in doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown}"
+        "{ inputHeight ih                    |736| image height of the model input. It should be multiple by 32.}"
+        "{ inputWidth iw                     |736| image width of the model input. It should be multiple by 32.}"
+        "{ binaryThreshold bt               |0.3| Confidence threshold of the binary map. }"
+        "{ polygonThreshold pt              |0.5| Confidence threshold of polygons. }"
+        "{ maxCandidate max                 |200| Max candidates of polygons. }"
+        "{ unclipRatio ratio                |2.0| unclip ratio. }"
+        "{ evaluate e                       |false| false: predict with input images; true: evaluate on benchmarks. }"
+        "{ evalDataPath edp                  | | Path to benchmarks for evaluation. "
+            "Download links are provided in doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown}";
+
+static
+void split(const std::string& s, char delimiter, std::vector<std::string>& elems)
+{
+    elems.clear();
+    size_t prev_pos = 0;
+    size_t pos = 0;
+    while ((pos = s.find(delimiter, prev_pos)) != std::string::npos)
+    {
+        elems.emplace_back(s.substr(prev_pos, pos - prev_pos));
+        prev_pos = pos + 1;
+    }
+    if (prev_pos < s.size())
+        elems.emplace_back(s.substr(prev_pos, s.size() - prev_pos));
+}
+
+int main(int argc, char** argv)
+{
+    // Parse arguments
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("Use this script to run the official PyTorch implementation (https://github.com/MhLiao/DB) of "
+                 "Real-time Scene Text Detection with Differentiable Binarization (https://arxiv.org/abs/1911.08947)\n"
+                 "The current version of this script is a variant of the original network without deformable convolution");
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    float binThresh = parser.get<float>("binaryThreshold");
+    float polyThresh = parser.get<float>("polygonThreshold");
+    uint maxCandidates = parser.get<uint>("maxCandidate");
+    String modelPath = parser.get<String>("modelPath");
+    double unclipRatio = parser.get<double>("unclipRatio");
+    int height = parser.get<int>("inputHeight");
+    int width = parser.get<int>("inputWidth");
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+
+    // Load the network
+    CV_Assert(!modelPath.empty());
+    TextDetectionModel_DB detector(modelPath);
+    detector.setBinaryThreshold(binThresh)
+            .setPolygonThreshold(polyThresh)
+            .setUnclipRatio(unclipRatio)
+            .setMaxCandidates(maxCandidates);
+
+    double scale = 1.0 / 255.0;
+    Size inputSize = Size(width, height);
+    Scalar mean = Scalar(122.67891434, 116.66876762, 104.00698793);
+    detector.setInputParams(scale, inputSize, mean);
+
+    // Create a window
+    static const std::string winName = "TextDetectionModel";
+
+    if (parser.get<bool>("evaluate")) {
+        // for evaluation
+        String evalDataPath = parser.get<String>("evalDataPath");
+        CV_Assert(!evalDataPath.empty());
+        String testListPath = evalDataPath + "/test_list.txt";
+        std::ifstream testList;
+        testList.open(testListPath);
+        CV_Assert(testList.is_open());
+
+        // Create a window for showing groundtruth
+        static const std::string winNameGT = "GT";
+
+        String testImgPath;
+        while (std::getline(testList, testImgPath)) {
+            String imgPath = evalDataPath + "/test_images/" + testImgPath;
+            std::cout << "Image Path: " << imgPath << std::endl;
+
+            Mat frame = imread(samples::findFile(imgPath), IMREAD_COLOR);
+            CV_Assert(!frame.empty());
+            Mat src = frame.clone();
+
+            // Inference
+            std::vector<std::vector<Point>> results;
+            detector.detect(frame, results);
+
+            polylines(frame, results, true, Scalar(0, 255, 0), 2);
+            imshow(winName, frame);
+
+            // load groundtruth
+            String imgName = testImgPath.substr(0, testImgPath.length() - 4);
+            String gtPath = evalDataPath + "/test_gts/" + imgName + ".txt";
+            // std::cout << gtPath << std::endl;
+            std::ifstream gtFile;
+            gtFile.open(gtPath);
+            CV_Assert(gtFile.is_open());
+
+            std::vector<std::vector<Point>> gts;
+            String gtLine;
+            while (std::getline(gtFile, gtLine)) {
+                size_t splitLoc = gtLine.find_last_of(',');
+                String text = gtLine.substr(splitLoc+1);
+                if ( text == "###\r" || text == "1") {
+                    // ignore difficult instances
+                    continue;
+                }
+                gtLine = gtLine.substr(0, splitLoc);
+
+                std::vector<std::string> v;
+                split(gtLine, ',', v);
+
+                std::vector<int> loc;
+                std::vector<Point> pts;
+                for (auto && s : v) {
+                    loc.push_back(atoi(s.c_str()));
+                }
+                for (size_t i = 0; i < loc.size() / 2; i++) {
+                    pts.push_back(Point(loc[2 * i], loc[2 * i + 1]));
+                }
+                gts.push_back(pts);
+            }
+            polylines(src, gts, true, Scalar(0, 255, 0), 2);
+            imshow(winNameGT, src);
+
+            waitKey();
+        }
+    } else {
+        // Open an image file
+        CV_Assert(parser.has("inputImage"));
+        Mat frame = imread(samples::findFile(parser.get<String>("inputImage")));
+        CV_Assert(!frame.empty());
+
+        // Detect
+        std::vector<std::vector<Point>> results;
+        detector.detect(frame, results);
+
+        polylines(frame, results, true, Scalar(0, 255, 0), 2);
+        imshow(winName, frame);
+        waitKey();
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/scene_text_recognition.cpp b/C++/opencv-4.7.0/samples/dnn/scene_text_recognition.cpp
new file mode 100644
index 00000000..29b14441
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/scene_text_recognition.cpp
@@ -0,0 +1,144 @@
+#include <iostream>
+#include <fstream>
+
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/dnn/dnn.hpp>
+
+using namespace cv;
+using namespace cv::dnn;
+
+String keys =
+        "{ help  h                          | | Print help message. }"
+        "{ inputImage i                     | | Path to an input image. Skip this argument to capture frames from a camera. }"
+        "{ modelPath mp                     | | Path to a binary .onnx file contains trained CRNN text recognition model. "
+            "Download links are provided in doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown}"
+        "{ RGBInput rgb                     |0| 0: imread with flags=IMREAD_GRAYSCALE; 1: imread with flags=IMREAD_COLOR. }"
+        "{ evaluate e                       |false| false: predict with input images; true: evaluate on benchmarks. }"
+        "{ evalDataPath edp                 | | Path to benchmarks for evaluation. "
+            "Download links are provided in doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown}"
+        "{ vocabularyPath vp                | alphabet_36.txt | Path to recognition vocabulary. "
+            "Download links are provided in doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown}";
+
+String convertForEval(String &input);
+
+int main(int argc, char** argv)
+{
+    // Parse arguments
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("Use this script to run the PyTorch implementation of "
+                 "An End-to-End Trainable Neural Network for Image-based SequenceRecognition and Its Application to Scene Text Recognition "
+                 "(https://arxiv.org/abs/1507.05717)");
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    String modelPath = parser.get<String>("modelPath");
+    String vocPath = parser.get<String>("vocabularyPath");
+    int imreadRGB = parser.get<int>("RGBInput");
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+
+    // Load the network
+    CV_Assert(!modelPath.empty());
+    TextRecognitionModel recognizer(modelPath);
+
+    // Load vocabulary
+    CV_Assert(!vocPath.empty());
+    std::ifstream vocFile;
+    vocFile.open(samples::findFile(vocPath));
+    CV_Assert(vocFile.is_open());
+    String vocLine;
+    std::vector<String> vocabulary;
+    while (std::getline(vocFile, vocLine)) {
+        vocabulary.push_back(vocLine);
+    }
+    recognizer.setVocabulary(vocabulary);
+    recognizer.setDecodeType("CTC-greedy");
+
+    // Set parameters
+    double scale = 1.0 / 127.5;
+    Scalar mean = Scalar(127.5, 127.5, 127.5);
+    Size inputSize = Size(100, 32);
+    recognizer.setInputParams(scale, inputSize, mean);
+
+    if (parser.get<bool>("evaluate"))
+    {
+        // For evaluation
+        String evalDataPath = parser.get<String>("evalDataPath");
+        CV_Assert(!evalDataPath.empty());
+        String gtPath = evalDataPath + "/test_gts.txt";
+        std::ifstream evalGts;
+        evalGts.open(gtPath);
+        CV_Assert(evalGts.is_open());
+
+        String gtLine;
+        int cntRight=0, cntAll=0;
+        TickMeter timer;
+        timer.reset();
+
+        while (std::getline(evalGts, gtLine)) {
+            size_t splitLoc = gtLine.find_first_of(' ');
+            String imgPath = evalDataPath + '/' + gtLine.substr(0, splitLoc);
+            String gt = gtLine.substr(splitLoc+1);
+
+            // Inference
+            Mat frame = imread(samples::findFile(imgPath), imreadRGB);
+            CV_Assert(!frame.empty());
+            timer.start();
+            std::string recognitionResult = recognizer.recognize(frame);
+            timer.stop();
+
+            if (gt == convertForEval(recognitionResult))
+                cntRight++;
+
+            cntAll++;
+        }
+        std::cout << "Accuracy(%): " << (double)(cntRight) / (double)(cntAll) << std::endl;
+        std::cout << "Average Inference Time(ms): " << timer.getTimeMilli() / (double)(cntAll) << std::endl;
+    }
+    else
+    {
+        // Create a window
+        static const std::string winName = "Input Cropped Image";
+
+        // Open an image file
+        CV_Assert(parser.has("inputImage"));
+        Mat frame = imread(samples::findFile(parser.get<String>("inputImage")), imreadRGB);
+        CV_Assert(!frame.empty());
+
+        // Recognition
+        std::string recognitionResult = recognizer.recognize(frame);
+
+        imshow(winName, frame);
+        std::cout << "Predition: '" << recognitionResult << "'" << std::endl;
+        waitKey();
+    }
+
+    return 0;
+}
+
+// Convert the predictions to lower case, and remove other characters.
+// Only for Evaluation
+String convertForEval(String & input)
+{
+    String output;
+    for (uint i = 0; i < input.length(); i++){
+        char ch = input[i];
+        if ((int)ch >= 97 && (int)ch <= 122) {
+            output.push_back(ch);
+        } else if ((int)ch >= 65 && (int)ch <= 90) {
+            output.push_back((char)(ch + 32));
+        } else {
+            continue;
+        }
+    }
+
+    return output;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/scene_text_spotting.cpp b/C++/opencv-4.7.0/samples/dnn/scene_text_spotting.cpp
new file mode 100644
index 00000000..548289d0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/scene_text_spotting.cpp
@@ -0,0 +1,169 @@
+#include <iostream>
+#include <fstream>
+
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/dnn/dnn.hpp>
+
+using namespace cv;
+using namespace cv::dnn;
+
+std::string keys =
+        "{ help  h                          | | Print help message. }"
+        "{ inputImage i                     | | Path to an input image. Skip this argument to capture frames from a camera. }"
+        "{ detModelPath dmp                 | | Path to a binary .onnx model for detection. "
+            "Download links are provided in doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown}"
+        "{ recModelPath rmp                 | | Path to a binary .onnx model for recognition. "
+            "Download links are provided in doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown}"
+        "{ inputHeight ih                   |736| image height of the model input. It should be multiple by 32.}"
+        "{ inputWidth iw                    |736| image width of the model input. It should be multiple by 32.}"
+        "{ RGBInput rgb                     |0| 0: imread with flags=IMREAD_GRAYSCALE; 1: imread with flags=IMREAD_COLOR. }"
+        "{ binaryThreshold bt               |0.3| Confidence threshold of the binary map. }"
+        "{ polygonThreshold pt              |0.5| Confidence threshold of polygons. }"
+        "{ maxCandidate max                 |200| Max candidates of polygons. }"
+        "{ unclipRatio ratio                |2.0| unclip ratio. }"
+        "{ vocabularyPath vp                | alphabet_36.txt | Path to benchmarks for evaluation. "
+            "Download links are provided in doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown}";
+
+void fourPointsTransform(const Mat& frame, const Point2f vertices[], Mat& result);
+bool sortPts(const Point& p1, const Point& p2);
+
+int main(int argc, char** argv)
+{
+    // Parse arguments
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("Use this script to run an end-to-end inference sample of textDetectionModel and textRecognitionModel APIs\n"
+                 "Use -h for more information");
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    float binThresh = parser.get<float>("binaryThreshold");
+    float polyThresh = parser.get<float>("polygonThreshold");
+    uint maxCandidates = parser.get<uint>("maxCandidate");
+    String detModelPath = parser.get<String>("detModelPath");
+    String recModelPath = parser.get<String>("recModelPath");
+    String vocPath = parser.get<String>("vocabularyPath");
+    double unclipRatio = parser.get<double>("unclipRatio");
+    int height = parser.get<int>("inputHeight");
+    int width = parser.get<int>("inputWidth");
+    int imreadRGB = parser.get<int>("RGBInput");
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+
+    // Load networks
+    CV_Assert(!detModelPath.empty());
+    TextDetectionModel_DB detector(detModelPath);
+    detector.setBinaryThreshold(binThresh)
+            .setPolygonThreshold(polyThresh)
+            .setUnclipRatio(unclipRatio)
+            .setMaxCandidates(maxCandidates);
+
+    CV_Assert(!recModelPath.empty());
+    TextRecognitionModel recognizer(recModelPath);
+
+    // Load vocabulary
+    CV_Assert(!vocPath.empty());
+    std::ifstream vocFile;
+    vocFile.open(samples::findFile(vocPath));
+    CV_Assert(vocFile.is_open());
+    String vocLine;
+    std::vector<String> vocabulary;
+    while (std::getline(vocFile, vocLine)) {
+        vocabulary.push_back(vocLine);
+    }
+    recognizer.setVocabulary(vocabulary);
+    recognizer.setDecodeType("CTC-greedy");
+
+    // Parameters for Detection
+    double detScale = 1.0 / 255.0;
+    Size detInputSize = Size(width, height);
+    Scalar detMean = Scalar(122.67891434, 116.66876762, 104.00698793);
+    detector.setInputParams(detScale, detInputSize, detMean);
+
+    // Parameters for Recognition
+    double recScale = 1.0 / 127.5;
+    Scalar recMean = Scalar(127.5);
+    Size recInputSize = Size(100, 32);
+    recognizer.setInputParams(recScale, recInputSize, recMean);
+
+    // Create a window
+    static const std::string winName = "Text_Spotting";
+
+    // Input data
+    Mat frame = imread(samples::findFile(parser.get<String>("inputImage")));
+    std::cout << frame.size << std::endl;
+
+    // Inference
+    std::vector< std::vector<Point> > detResults;
+    detector.detect(frame, detResults);
+
+    if (detResults.size() > 0) {
+        // Text Recognition
+        Mat recInput;
+        if (!imreadRGB) {
+            cvtColor(frame, recInput, cv::COLOR_BGR2GRAY);
+        } else {
+            recInput = frame;
+        }
+        std::vector< std::vector<Point> > contours;
+        for (uint i = 0; i < detResults.size(); i++)
+        {
+            const auto& quadrangle = detResults[i];
+            CV_CheckEQ(quadrangle.size(), (size_t)4, "");
+
+            contours.emplace_back(quadrangle);
+
+            std::vector<Point2f> quadrangle_2f;
+            for (int j = 0; j < 4; j++)
+                quadrangle_2f.emplace_back(quadrangle[j]);
+
+            // Transform and Crop
+            Mat cropped;
+            fourPointsTransform(recInput, &quadrangle_2f[0], cropped);
+
+            std::string recognitionResult = recognizer.recognize(cropped);
+            std::cout << i << ": '" << recognitionResult << "'" << std::endl;
+
+            putText(frame, recognitionResult, quadrangle[3], FONT_HERSHEY_SIMPLEX, 1, Scalar(0, 0, 255), 2);
+        }
+        polylines(frame, contours, true, Scalar(0, 255, 0), 2);
+    } else {
+        std::cout << "No Text Detected." << std::endl;
+    }
+    imshow(winName, frame);
+    waitKey();
+
+    return 0;
+}
+
+void fourPointsTransform(const Mat& frame, const Point2f vertices[], Mat& result)
+{
+    const Size outputSize = Size(100, 32);
+
+    Point2f targetVertices[4] = {
+        Point(0, outputSize.height - 1),
+        Point(0, 0),
+        Point(outputSize.width - 1, 0),
+        Point(outputSize.width - 1, outputSize.height - 1)
+    };
+    Mat rotationMatrix = getPerspectiveTransform(vertices, targetVertices);
+
+    warpPerspective(frame, result, rotationMatrix, outputSize);
+
+#if 0
+    imshow("roi", result);
+    waitKey();
+#endif
+}
+
+bool sortPts(const Point& p1, const Point& p2)
+{
+    return p1.x < p2.x;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/segmentation.cpp b/C++/opencv-4.7.0/samples/dnn/segmentation.cpp
new file mode 100644
index 00000000..777badf5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/segmentation.cpp
@@ -0,0 +1,252 @@
+#include <fstream>
+#include <sstream>
+
+#include <opencv2/dnn.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+
+#include "common.hpp"
+
+std::string keys =
+    "{ help  h     | | Print help message. }"
+    "{ @alias      | | An alias name of model to extract preprocessing parameters from models.yml file. }"
+    "{ zoo         | models.yml | An optional path to file with preprocessing parameters }"
+    "{ device      |  0 | camera device number. }"
+    "{ input i     | | Path to input image or video file. Skip this argument to capture frames from a camera. }"
+    "{ framework f | | Optional name of an origin framework of the model. Detect it automatically if it does not set. }"
+    "{ classes     | | Optional path to a text file with names of classes. }"
+    "{ colors      | | Optional path to a text file with colors for an every class. "
+                      "An every color is represented with three values from 0 to 255 in BGR channels order. }"
+    "{ backend     | 0 | Choose one of computation backends: "
+                        "0: automatically (by default), "
+                        "1: Halide language (http://halide-lang.org/), "
+                        "2: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                        "3: OpenCV implementation, "
+                        "4: VKCOM, "
+                        "5: CUDA }"
+    "{ target      | 0 | Choose one of target computation devices: "
+                        "0: CPU target (by default), "
+                        "1: OpenCL, "
+                        "2: OpenCL fp16 (half-float precision), "
+                        "3: VPU, "
+                        "4: Vulkan, "
+                        "6: CUDA, "
+                        "7: CUDA fp16 (half-float preprocess) }";
+
+using namespace cv;
+using namespace dnn;
+
+std::vector<std::string> classes;
+std::vector<Vec3b> colors;
+
+void showLegend();
+
+void colorizeSegmentation(const Mat &score, Mat &segm);
+
+int main(int argc, char** argv)
+{
+    CommandLineParser parser(argc, argv, keys);
+
+    const std::string modelName = parser.get<String>("@alias");
+    const std::string zooFile = parser.get<String>("zoo");
+
+    keys += genPreprocArguments(modelName, zooFile);
+
+    parser = CommandLineParser(argc, argv, keys);
+    parser.about("Use this script to run semantic segmentation deep learning networks using OpenCV.");
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    float scale = parser.get<float>("scale");
+    Scalar mean = parser.get<Scalar>("mean");
+    bool swapRB = parser.get<bool>("rgb");
+    int inpWidth = parser.get<int>("width");
+    int inpHeight = parser.get<int>("height");
+    String model = findFile(parser.get<String>("model"));
+    String config = findFile(parser.get<String>("config"));
+    String framework = parser.get<String>("framework");
+    int backendId = parser.get<int>("backend");
+    int targetId = parser.get<int>("target");
+
+    // Open file with classes names.
+    if (parser.has("classes"))
+    {
+        std::string file = parser.get<String>("classes");
+        std::ifstream ifs(file.c_str());
+        if (!ifs.is_open())
+            CV_Error(Error::StsError, "File " + file + " not found");
+        std::string line;
+        while (std::getline(ifs, line))
+        {
+            classes.push_back(line);
+        }
+    }
+
+    // Open file with colors.
+    if (parser.has("colors"))
+    {
+        std::string file = parser.get<String>("colors");
+        std::ifstream ifs(file.c_str());
+        if (!ifs.is_open())
+            CV_Error(Error::StsError, "File " + file + " not found");
+        std::string line;
+        while (std::getline(ifs, line))
+        {
+            std::istringstream colorStr(line.c_str());
+
+            Vec3b color;
+            for (int i = 0; i < 3 && !colorStr.eof(); ++i)
+                colorStr >> color[i];
+            colors.push_back(color);
+        }
+    }
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+
+    CV_Assert(!model.empty());
+    //! [Read and initialize network]
+    Net net = readNet(model, config, framework);
+    net.setPreferableBackend(backendId);
+    net.setPreferableTarget(targetId);
+    //! [Read and initialize network]
+
+    // Create a window
+    static const std::string kWinName = "Deep learning semantic segmentation in OpenCV";
+    namedWindow(kWinName, WINDOW_NORMAL);
+
+    //! [Open a video file or an image file or a camera stream]
+    VideoCapture cap;
+    if (parser.has("input"))
+        cap.open(parser.get<String>("input"));
+    else
+        cap.open(parser.get<int>("device"));
+    //! [Open a video file or an image file or a camera stream]
+
+    // Process frames.
+    Mat frame, blob;
+    while (waitKey(1) < 0)
+    {
+        cap >> frame;
+        if (frame.empty())
+        {
+            waitKey();
+            break;
+        }
+
+        //! [Create a 4D blob from a frame]
+        blobFromImage(frame, blob, scale, Size(inpWidth, inpHeight), mean, swapRB, false);
+        //! [Create a 4D blob from a frame]
+
+        //! [Set input blob]
+        net.setInput(blob);
+        //! [Set input blob]
+        //! [Make forward pass]
+        Mat score = net.forward();
+        //! [Make forward pass]
+
+        Mat segm;
+        colorizeSegmentation(score, segm);
+
+        resize(segm, segm, frame.size(), 0, 0, INTER_NEAREST);
+        addWeighted(frame, 0.1, segm, 0.9, 0.0, frame);
+
+        // Put efficiency information.
+        std::vector<double> layersTimes;
+        double freq = getTickFrequency() / 1000;
+        double t = net.getPerfProfile(layersTimes) / freq;
+        std::string label = format("Inference time: %.2f ms", t);
+        putText(frame, label, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0));
+
+        imshow(kWinName, frame);
+        if (!classes.empty())
+            showLegend();
+    }
+    return 0;
+}
+
+void colorizeSegmentation(const Mat &score, Mat &segm)
+{
+    const int rows = score.size[2];
+    const int cols = score.size[3];
+    const int chns = score.size[1];
+
+    if (colors.empty())
+    {
+        // Generate colors.
+        colors.push_back(Vec3b());
+        for (int i = 1; i < chns; ++i)
+        {
+            Vec3b color;
+            for (int j = 0; j < 3; ++j)
+                color[j] = (colors[i - 1][j] + rand() % 256) / 2;
+            colors.push_back(color);
+        }
+    }
+    else if (chns != (int)colors.size())
+    {
+        CV_Error(Error::StsError, format("Number of output classes does not match "
+                                         "number of colors (%d != %zu)", chns, colors.size()));
+    }
+
+    Mat maxCl = Mat::zeros(rows, cols, CV_8UC1);
+    Mat maxVal(rows, cols, CV_32FC1, score.data);
+    for (int ch = 1; ch < chns; ch++)
+    {
+        for (int row = 0; row < rows; row++)
+        {
+            const float *ptrScore = score.ptr<float>(0, ch, row);
+            uint8_t *ptrMaxCl = maxCl.ptr<uint8_t>(row);
+            float *ptrMaxVal = maxVal.ptr<float>(row);
+            for (int col = 0; col < cols; col++)
+            {
+                if (ptrScore[col] > ptrMaxVal[col])
+                {
+                    ptrMaxVal[col] = ptrScore[col];
+                    ptrMaxCl[col] = (uchar)ch;
+                }
+            }
+        }
+    }
+
+    segm.create(rows, cols, CV_8UC3);
+    for (int row = 0; row < rows; row++)
+    {
+        const uchar *ptrMaxCl = maxCl.ptr<uchar>(row);
+        Vec3b *ptrSegm = segm.ptr<Vec3b>(row);
+        for (int col = 0; col < cols; col++)
+        {
+            ptrSegm[col] = colors[ptrMaxCl[col]];
+        }
+    }
+}
+
+void showLegend()
+{
+    static const int kBlockHeight = 30;
+    static Mat legend;
+    if (legend.empty())
+    {
+        const int numClasses = (int)classes.size();
+        if ((int)colors.size() != numClasses)
+        {
+            CV_Error(Error::StsError, format("Number of output classes does not match "
+                                             "number of labels (%zu != %zu)", colors.size(), classes.size()));
+        }
+        legend.create(kBlockHeight * numClasses, 200, CV_8UC3);
+        for (int i = 0; i < numClasses; i++)
+        {
+            Mat block = legend.rowRange(i * kBlockHeight, (i + 1) * kBlockHeight);
+            block.setTo(colors[i]);
+            putText(block, classes[i], Point(0, kBlockHeight / 2), FONT_HERSHEY_SIMPLEX, 0.5, Vec3b(255, 255, 255));
+        }
+        namedWindow("Legend", WINDOW_NORMAL);
+        imshow("Legend", legend);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/segmentation.py b/C++/opencv-4.7.0/samples/dnn/segmentation.py
new file mode 100644
index 00000000..09f3f8dd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/segmentation.py
@@ -0,0 +1,135 @@
+import cv2 as cv
+import argparse
+import numpy as np
+import sys
+
+from common import *
+
+backends = (cv.dnn.DNN_BACKEND_DEFAULT, cv.dnn.DNN_BACKEND_HALIDE, cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_BACKEND_OPENCV,
+            cv.dnn.DNN_BACKEND_VKCOM, cv.dnn.DNN_BACKEND_CUDA)
+targets = (cv.dnn.DNN_TARGET_CPU, cv.dnn.DNN_TARGET_OPENCL, cv.dnn.DNN_TARGET_OPENCL_FP16, cv.dnn.DNN_TARGET_MYRIAD, cv.dnn.DNN_TARGET_HDDL,
+           cv.dnn.DNN_TARGET_VULKAN, cv.dnn.DNN_TARGET_CUDA, cv.dnn.DNN_TARGET_CUDA_FP16)
+
+parser = argparse.ArgumentParser(add_help=False)
+parser.add_argument('--zoo', default=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models.yml'),
+                    help='An optional path to file with preprocessing parameters.')
+parser.add_argument('--input', help='Path to input image or video file. Skip this argument to capture frames from a camera.')
+parser.add_argument('--framework', choices=['caffe', 'tensorflow', 'torch', 'darknet'],
+                    help='Optional name of an origin framework of the model. '
+                         'Detect it automatically if it does not set.')
+parser.add_argument('--colors', help='Optional path to a text file with colors for an every class. '
+                                     'An every color is represented with three values from 0 to 255 in BGR channels order.')
+parser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,
+                    help="Choose one of computation backends: "
+                         "%d: automatically (by default), "
+                         "%d: Halide language (http://halide-lang.org/), "
+                         "%d: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                         "%d: OpenCV implementation, "
+                         "%d: VKCOM, "
+                         "%d: CUDA"% backends)
+parser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,
+                    help='Choose one of target computation devices: '
+                         '%d: CPU target (by default), '
+                         '%d: OpenCL, '
+                         '%d: OpenCL fp16 (half-float precision), '
+                         '%d: NCS2 VPU, '
+                         '%d: HDDL VPU, '
+                         '%d: Vulkan, '
+                         '%d: CUDA, '
+                         '%d: CUDA fp16 (half-float preprocess)'% targets)
+args, _ = parser.parse_known_args()
+add_preproc_args(args.zoo, parser, 'segmentation')
+parser = argparse.ArgumentParser(parents=[parser],
+                                 description='Use this script to run semantic segmentation deep learning networks using OpenCV.',
+                                 formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+args = parser.parse_args()
+
+args.model = findFile(args.model)
+args.config = findFile(args.config)
+args.classes = findFile(args.classes)
+
+np.random.seed(324)
+
+# Load names of classes
+classes = None
+if args.classes:
+    with open(args.classes, 'rt') as f:
+        classes = f.read().rstrip('\n').split('\n')
+
+# Load colors
+colors = None
+if args.colors:
+    with open(args.colors, 'rt') as f:
+        colors = [np.array(color.split(' '), np.uint8) for color in f.read().rstrip('\n').split('\n')]
+
+legend = None
+def showLegend(classes):
+    global legend
+    if not classes is None and legend is None:
+        blockHeight = 30
+        assert(len(classes) == len(colors))
+
+        legend = np.zeros((blockHeight * len(colors), 200, 3), np.uint8)
+        for i in range(len(classes)):
+            block = legend[i * blockHeight:(i + 1) * blockHeight]
+            block[:,:] = colors[i]
+            cv.putText(block, classes[i], (0, blockHeight//2), cv.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255))
+
+        cv.namedWindow('Legend', cv.WINDOW_NORMAL)
+        cv.imshow('Legend', legend)
+        classes = None
+
+# Load a network
+net = cv.dnn.readNet(args.model, args.config, args.framework)
+net.setPreferableBackend(args.backend)
+net.setPreferableTarget(args.target)
+
+winName = 'Deep learning semantic segmentation in OpenCV'
+cv.namedWindow(winName, cv.WINDOW_NORMAL)
+
+cap = cv.VideoCapture(args.input if args.input else 0)
+legend = None
+while cv.waitKey(1) < 0:
+    hasFrame, frame = cap.read()
+    if not hasFrame:
+        cv.waitKey()
+        break
+
+    frameHeight = frame.shape[0]
+    frameWidth = frame.shape[1]
+
+    # Create a 4D blob from a frame.
+    inpWidth = args.width if args.width else frameWidth
+    inpHeight = args.height if args.height else frameHeight
+    blob = cv.dnn.blobFromImage(frame, args.scale, (inpWidth, inpHeight), args.mean, args.rgb, crop=False)
+
+    # Run a model
+    net.setInput(blob)
+    score = net.forward()
+
+    numClasses = score.shape[1]
+    height = score.shape[2]
+    width = score.shape[3]
+
+    # Draw segmentation
+    if not colors:
+        # Generate colors
+        colors = [np.array([0, 0, 0], np.uint8)]
+        for i in range(1, numClasses):
+            colors.append((colors[i - 1] + np.random.randint(0, 256, [3], np.uint8)) / 2)
+
+    classIds = np.argmax(score[0], axis=0)
+    segm = np.stack([colors[idx] for idx in classIds.flatten()])
+    segm = segm.reshape(height, width, 3)
+
+    segm = cv.resize(segm, (frameWidth, frameHeight), interpolation=cv.INTER_NEAREST)
+    frame = (0.1 * frame + 0.9 * segm).astype(np.uint8)
+
+    # Put efficiency information.
+    t, _ = net.getPerfProfile()
+    label = 'Inference time: %.2f ms' % (t * 1000.0 / cv.getTickFrequency())
+    cv.putText(frame, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
+
+    showLegend(classes)
+
+    cv.imshow(winName, frame)
diff --git a/C++/opencv-4.7.0/samples/dnn/shrink_tf_graph_weights.py b/C++/opencv-4.7.0/samples/dnn/shrink_tf_graph_weights.py
new file mode 100644
index 00000000..799d6c75
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/shrink_tf_graph_weights.py
@@ -0,0 +1,62 @@
+# This file is part of OpenCV project.
+# It is subject to the license terms in the LICENSE file found in the top-level directory
+# of this distribution and at http://opencv.org/license.html.
+#
+# Copyright (C) 2017, Intel Corporation, all rights reserved.
+# Third party copyrights are property of their respective owners.
+import tensorflow as tf
+import struct
+import argparse
+import numpy as np
+
+parser = argparse.ArgumentParser(description='Convert weights of a frozen TensorFlow graph to fp16.')
+parser.add_argument('--input', required=True, help='Path to frozen graph.')
+parser.add_argument('--output', required=True, help='Path to output graph.')
+parser.add_argument('--ops', default=['Conv2D', 'MatMul'], nargs='+',
+                    help='List of ops which weights are converted.')
+args = parser.parse_args()
+
+DT_FLOAT = 1
+DT_HALF = 19
+
+# For the frozen graphs, an every node that uses weights connected to Const nodes
+# through an Identity node. Usually they're called in the same way with '/read' suffix.
+# We'll replace all of them to Cast nodes.
+
+# Load the model
+with tf.gfile.FastGFile(args.input) as f:
+    graph_def = tf.GraphDef()
+    graph_def.ParseFromString(f.read())
+
+# Set of all inputs from desired nodes.
+inputs = []
+for node in graph_def.node:
+    if node.op in args.ops:
+        inputs += node.input
+
+weightsNodes = []
+for node in graph_def.node:
+    # From the whole inputs we need to keep only an Identity nodes.
+    if node.name in inputs and node.op == 'Identity' and node.attr['T'].type == DT_FLOAT:
+        weightsNodes.append(node.input[0])
+
+        # Replace Identity to Cast.
+        node.op = 'Cast'
+        node.attr['DstT'].type = DT_FLOAT
+        node.attr['SrcT'].type = DT_HALF
+        del node.attr['T']
+        del node.attr['_class']
+
+# Convert weights to halfs.
+for node in graph_def.node:
+    if node.name in weightsNodes:
+        node.attr['dtype'].type = DT_HALF
+        node.attr['value'].tensor.dtype = DT_HALF
+
+        floats = node.attr['value'].tensor.tensor_content
+
+        floats = struct.unpack('f' * (len(floats) / 4), floats)
+        halfs = np.array(floats).astype(np.float16).view(np.uint16)
+        node.attr['value'].tensor.tensor_content = struct.pack('H' * len(halfs), *halfs)
+
+tf.train.write_graph(graph_def, "", args.output, as_text=False)
diff --git a/C++/opencv-4.7.0/samples/dnn/siamrpnpp.py b/C++/opencv-4.7.0/samples/dnn/siamrpnpp.py
new file mode 100644
index 00000000..0247242c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/siamrpnpp.py
@@ -0,0 +1,404 @@
+import argparse
+import cv2 as cv
+import numpy as np
+import os
+
+"""
+Link to original paper : https://arxiv.org/abs/1812.11703
+Link to original repo  : https://github.com/STVIR/pysot
+
+You can download the pre-trained weights of the Tracker Model from https://drive.google.com/file/d/11bwgPFVkps9AH2NOD1zBDdpF_tQghAB-/view?usp=sharing
+You can download the target net (target branch of SiamRPN++) from https://drive.google.com/file/d/1dw_Ne3UMcCnFsaD6xkZepwE4GEpqq7U_/view?usp=sharing
+You can download the search net (search branch of SiamRPN++) from https://drive.google.com/file/d/1Lt4oE43ZSucJvze3Y-Z87CVDreO-Afwl/view?usp=sharing
+You can download the head model (RPN Head) from https://drive.google.com/file/d/1zT1yu12mtj3JQEkkfKFJWiZ71fJ-dQTi/view?usp=sharing
+"""
+
+class ModelBuilder():
+    """ This class generates the SiamRPN++ Tracker Model by using Imported ONNX Nets
+    """
+    def __init__(self, target_net, search_net, rpn_head):
+        super(ModelBuilder, self).__init__()
+        # Build the target branch
+        self.target_net = target_net
+        # Build the search branch
+        self.search_net = search_net
+        # Build RPN_Head
+        self.rpn_head = rpn_head
+
+    def template(self, z):
+        """ Takes the template of size (1, 1, 127, 127) as an input to generate kernel
+        """
+        self.target_net.setInput(z)
+        outNames = self.target_net.getUnconnectedOutLayersNames()
+        self.zfs_1, self.zfs_2, self.zfs_3 = self.target_net.forward(outNames)
+
+    def track(self, x):
+        """ Takes the search of size (1, 1, 255, 255) as an input to generate classification score and bounding box regression
+        """
+        self.search_net.setInput(x)
+        outNames = self.search_net.getUnconnectedOutLayersNames()
+        xfs_1, xfs_2, xfs_3 = self.search_net.forward(outNames)
+        self.rpn_head.setInput(np.stack([self.zfs_1, self.zfs_2, self.zfs_3]), 'input_1')
+        self.rpn_head.setInput(np.stack([xfs_1, xfs_2, xfs_3]), 'input_2')
+        outNames = self.rpn_head.getUnconnectedOutLayersNames()
+        cls, loc = self.rpn_head.forward(outNames)
+        return {'cls': cls, 'loc': loc}
+
+class Anchors:
+    """ This class generate anchors.
+    """
+    def __init__(self, stride, ratios, scales, image_center=0, size=0):
+        self.stride = stride
+        self.ratios = ratios
+        self.scales = scales
+        self.image_center = image_center
+        self.size = size
+        self.anchor_num = len(self.scales) * len(self.ratios)
+        self.anchors = self.generate_anchors()
+
+    def generate_anchors(self):
+        """
+        generate anchors based on predefined configuration
+        """
+        anchors = np.zeros((self.anchor_num, 4), dtype=np.float32)
+        size = self.stride**2
+        count = 0
+        for r in self.ratios:
+            ws = int(np.sqrt(size * 1. / r))
+            hs = int(ws * r)
+
+            for s in self.scales:
+                w = ws * s
+                h = hs * s
+                anchors[count][:] = [-w * 0.5, -h * 0.5, w * 0.5, h * 0.5][:]
+                count += 1
+        return anchors
+
+class SiamRPNTracker:
+    def __init__(self, model):
+        super(SiamRPNTracker, self).__init__()
+        self.anchor_stride = 8
+        self.anchor_ratios = [0.33, 0.5, 1, 2, 3]
+        self.anchor_scales = [8]
+        self.track_base_size = 8
+        self.track_context_amount = 0.5
+        self.track_exemplar_size = 127
+        self.track_instance_size = 255
+        self.track_lr = 0.4
+        self.track_penalty_k = 0.04
+        self.track_window_influence = 0.44
+        self.score_size = (self.track_instance_size - self.track_exemplar_size) // \
+                          self.anchor_stride + 1 + self.track_base_size
+        self.anchor_num = len(self.anchor_ratios) * len(self.anchor_scales)
+        hanning = np.hanning(self.score_size)
+        window = np.outer(hanning, hanning)
+        self.window = np.tile(window.flatten(), self.anchor_num)
+        self.anchors = self.generate_anchor(self.score_size)
+        self.model = model
+
+    def get_subwindow(self, im, pos, model_sz, original_sz, avg_chans):
+        """
+        Args:
+            im:         bgr based input image frame
+            pos:        position of the center of the frame
+            model_sz:   exemplar / target image size
+            s_z:        original / search image size
+            avg_chans:  channel average
+        Return:
+            im_patch:   sub_windows for the given image input
+        """
+        if isinstance(pos, float):
+            pos = [pos, pos]
+        sz = original_sz
+        im_h, im_w, im_d = im.shape
+        c = (original_sz + 1) / 2
+        cx, cy = pos
+        context_xmin = np.floor(cx - c + 0.5)
+        context_xmax = context_xmin + sz - 1
+        context_ymin = np.floor(cy - c + 0.5)
+        context_ymax = context_ymin + sz - 1
+        left_pad = int(max(0., -context_xmin))
+        top_pad = int(max(0., -context_ymin))
+        right_pad = int(max(0., context_xmax - im_w + 1))
+        bottom_pad = int(max(0., context_ymax - im_h + 1))
+        context_xmin += left_pad
+        context_xmax += left_pad
+        context_ymin += top_pad
+        context_ymax += top_pad
+
+        if any([top_pad, bottom_pad, left_pad, right_pad]):
+            size = (im_h + top_pad + bottom_pad, im_w + left_pad + right_pad, im_d)
+            te_im = np.zeros(size, np.uint8)
+            te_im[top_pad:top_pad + im_h, left_pad:left_pad + im_w, :] = im
+            if top_pad:
+                te_im[0:top_pad, left_pad:left_pad + im_w, :] = avg_chans
+            if bottom_pad:
+                te_im[im_h + top_pad:, left_pad:left_pad + im_w, :] = avg_chans
+            if left_pad:
+                te_im[:, 0:left_pad, :] = avg_chans
+            if right_pad:
+                te_im[:, im_w + left_pad:, :] = avg_chans
+            im_patch = te_im[int(context_ymin):int(context_ymax + 1),
+                       int(context_xmin):int(context_xmax + 1), :]
+        else:
+            im_patch = im[int(context_ymin):int(context_ymax + 1),
+                       int(context_xmin):int(context_xmax + 1), :]
+
+        if not np.array_equal(model_sz, original_sz):
+            im_patch = cv.resize(im_patch, (model_sz, model_sz))
+        im_patch = im_patch.transpose(2, 0, 1)
+        im_patch = im_patch[np.newaxis, :, :, :]
+        im_patch = im_patch.astype(np.float32)
+        return im_patch
+
+    def generate_anchor(self, score_size):
+        """
+        Args:
+            im:         bgr based input image frame
+            pos:        position of the center of the frame
+            model_sz:   exemplar / target image size
+            s_z:        original / search image size
+            avg_chans:  channel average
+        Return:
+            anchor:     anchors for pre-determined values of stride, ratio, and scale
+        """
+        anchors = Anchors(self.anchor_stride, self.anchor_ratios, self.anchor_scales)
+        anchor = anchors.anchors
+        x1, y1, x2, y2 = anchor[:, 0], anchor[:, 1], anchor[:, 2], anchor[:, 3]
+        anchor = np.stack([(x1 + x2) * 0.5, (y1 + y2) * 0.5, x2 - x1, y2 - y1], 1)
+        total_stride = anchors.stride
+        anchor_num = anchors.anchor_num
+        anchor = np.tile(anchor, score_size * score_size).reshape((-1, 4))
+        ori = - (score_size // 2) * total_stride
+        xx, yy = np.meshgrid([ori + total_stride * dx for dx in range(score_size)],
+                             [ori + total_stride * dy for dy in range(score_size)])
+        xx, yy = np.tile(xx.flatten(), (anchor_num, 1)).flatten(), \
+                 np.tile(yy.flatten(), (anchor_num, 1)).flatten()
+        anchor[:, 0], anchor[:, 1] = xx.astype(np.float32), yy.astype(np.float32)
+        return anchor
+
+    def _convert_bbox(self, delta, anchor):
+        """
+        Args:
+            delta:      localisation
+            anchor:     anchor of pre-determined anchor size
+        Return:
+            delta:      prediction of bounding box
+        """
+        delta_transpose = np.transpose(delta, (1, 2, 3, 0))
+        delta_contig = np.ascontiguousarray(delta_transpose)
+        delta = delta_contig.reshape(4, -1)
+        delta[0, :] = delta[0, :] * anchor[:, 2] + anchor[:, 0]
+        delta[1, :] = delta[1, :] * anchor[:, 3] + anchor[:, 1]
+        delta[2, :] = np.exp(delta[2, :]) * anchor[:, 2]
+        delta[3, :] = np.exp(delta[3, :]) * anchor[:, 3]
+        return delta
+
+    def _softmax(self, x):
+        """
+        Softmax in the direction of the depth of the layer
+        """
+        x = x.astype(dtype=np.float32)
+        x_max = x.max(axis=1)[:, np.newaxis]
+        e_x = np.exp(x-x_max)
+        div = np.sum(e_x, axis=1)[:, np.newaxis]
+        y = e_x / div
+        return y
+
+    def _convert_score(self, score):
+        """
+        Args:
+            cls:        score
+        Return:
+            cls:        score for cls
+        """
+        score_transpose = np.transpose(score, (1, 2, 3, 0))
+        score_con = np.ascontiguousarray(score_transpose)
+        score_view = score_con.reshape(2, -1)
+        score = np.transpose(score_view, (1, 0))
+        score = self._softmax(score)
+        return score[:,1]
+
+    def _bbox_clip(self, cx, cy, width, height, boundary):
+        """
+        Adjusting the bounding box
+        """
+        bbox_h, bbox_w = boundary
+        cx = max(0, min(cx, bbox_w))
+        cy = max(0, min(cy, bbox_h))
+        width = max(10, min(width, bbox_w))
+        height = max(10, min(height, bbox_h))
+        return cx, cy, width, height
+
+    def init(self, img, bbox):
+        """
+        Args:
+            img(np.ndarray):    bgr based input image frame
+            bbox: (x, y, w, h): bounding box
+        """
+        x, y, w, h = bbox
+        self.center_pos = np.array([x + (w - 1) / 2, y + (h - 1) / 2])
+        self.h = h
+        self.w = w
+        w_z = self.w + self.track_context_amount * np.add(h, w)
+        h_z = self.h + self.track_context_amount * np.add(h, w)
+        s_z = round(np.sqrt(w_z * h_z))
+        self.channel_average = np.mean(img, axis=(0, 1))
+        z_crop = self.get_subwindow(img, self.center_pos, self.track_exemplar_size, s_z, self.channel_average)
+        self.model.template(z_crop)
+
+    def track(self, img):
+        """
+        Args:
+            img(np.ndarray): BGR image
+        Return:
+            bbox(list):[x, y, width, height]
+        """
+        w_z = self.w + self.track_context_amount * np.add(self.w, self.h)
+        h_z = self.h + self.track_context_amount * np.add(self.w, self.h)
+        s_z = np.sqrt(w_z * h_z)
+        scale_z = self.track_exemplar_size / s_z
+        s_x = s_z * (self.track_instance_size / self.track_exemplar_size)
+        x_crop = self.get_subwindow(img, self.center_pos, self.track_instance_size, round(s_x), self.channel_average)
+        outputs = self.model.track(x_crop)
+        score = self._convert_score(outputs['cls'])
+        pred_bbox = self._convert_bbox(outputs['loc'], self.anchors)
+
+        def change(r):
+            return np.maximum(r, 1. / r)
+
+        def sz(w, h):
+            pad = (w + h) * 0.5
+            return np.sqrt((w + pad) * (h + pad))
+
+        # scale penalty
+        s_c = change(sz(pred_bbox[2, :], pred_bbox[3, :]) /
+                     (sz(self.w * scale_z, self.h * scale_z)))
+
+        # aspect ratio penalty
+        r_c = change((self.w / self.h) /
+                     (pred_bbox[2, :] / pred_bbox[3, :]))
+        penalty = np.exp(-(r_c * s_c - 1) * self.track_penalty_k)
+        pscore = penalty * score
+
+        # window penalty
+        pscore = pscore * (1 - self.track_window_influence) + \
+                 self.window * self.track_window_influence
+        best_idx = np.argmax(pscore)
+        bbox = pred_bbox[:, best_idx] / scale_z
+        lr = penalty[best_idx] * score[best_idx] * self.track_lr
+
+        cpx, cpy = self.center_pos
+        x,y,w,h = bbox
+        cx = x + cpx
+        cy = y + cpy
+
+        # smooth bbox
+        width = self.w * (1 - lr) + w * lr
+        height = self.h * (1 - lr) + h * lr
+
+        # clip boundary
+        cx, cy, width, height = self._bbox_clip(cx, cy, width, height, img.shape[:2])
+
+        # update state
+        self.center_pos = np.array([cx, cy])
+        self.w = width
+        self.h = height
+        bbox = [cx - width / 2, cy - height / 2, width, height]
+        best_score = score[best_idx]
+        return {'bbox': bbox, 'best_score': best_score}
+
+def get_frames(video_name):
+    """
+    Args:
+        Path to input video frame
+    Return:
+        Frame
+    """
+    cap = cv.VideoCapture(video_name if video_name else 0)
+    while True:
+        ret, frame = cap.read()
+        if ret:
+            yield frame
+        else:
+            break
+
+def main():
+    """ Sample SiamRPN Tracker
+    """
+    # Computation backends supported by layers
+    backends = (cv.dnn.DNN_BACKEND_DEFAULT, cv.dnn.DNN_BACKEND_HALIDE, cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_BACKEND_OPENCV,
+                cv.dnn.DNN_BACKEND_VKCOM, cv.dnn.DNN_BACKEND_CUDA)
+    # Target Devices for computation
+    targets = (cv.dnn.DNN_TARGET_CPU, cv.dnn.DNN_TARGET_OPENCL, cv.dnn.DNN_TARGET_OPENCL_FP16, cv.dnn.DNN_TARGET_MYRIAD,
+               cv.dnn.DNN_TARGET_VULKAN, cv.dnn.DNN_TARGET_CUDA, cv.dnn.DNN_TARGET_CUDA_FP16)
+
+    parser = argparse.ArgumentParser(description='Use this script to run SiamRPN++ Visual Tracker',
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('--input_video', type=str, help='Path to input video file. Skip this argument to capture frames from a camera.')
+    parser.add_argument('--target_net', type=str, default='target_net.onnx', help='Path to part of SiamRPN++ ran on target frame.')
+    parser.add_argument('--search_net', type=str, default='search_net.onnx', help='Path to part of SiamRPN++ ran on search frame.')
+    parser.add_argument('--rpn_head', type=str, default='rpn_head.onnx', help='Path to RPN Head ONNX model.')
+    parser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,
+                        help="Select a computation backend: "
+                        "%d: automatically (by default), "
+                        "%d: Halide, "
+                        "%d: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                        "%d: OpenCV Implementation, "
+                        "%d: VKCOM, "
+                        "%d: CUDA" % backends)
+    parser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,
+                        help='Select a target device: '
+                        '%d: CPU target (by default), '
+                        '%d: OpenCL, '
+                        '%d: OpenCL FP16, '
+                        '%d: Myriad, '
+                        '%d: Vulkan, '
+                        '%d: CUDA, '
+                        '%d: CUDA fp16 (half-float preprocess)' % targets)
+    args, _ = parser.parse_known_args()
+
+    if args.input_video and not os.path.isfile(args.input_video):
+        raise OSError("Input video file does not exist")
+    if not os.path.isfile(args.target_net):
+        raise OSError("Target Net does not exist")
+    if not os.path.isfile(args.search_net):
+        raise OSError("Search Net does not exist")
+    if not os.path.isfile(args.rpn_head):
+        raise OSError("RPN Head Net does not exist")
+
+    #Load the Networks
+    target_net = cv.dnn.readNetFromONNX(args.target_net)
+    target_net.setPreferableBackend(args.backend)
+    target_net.setPreferableTarget(args.target)
+    search_net = cv.dnn.readNetFromONNX(args.search_net)
+    search_net.setPreferableBackend(args.backend)
+    search_net.setPreferableTarget(args.target)
+    rpn_head = cv.dnn.readNetFromONNX(args.rpn_head)
+    rpn_head.setPreferableBackend(args.backend)
+    rpn_head.setPreferableTarget(args.target)
+    model = ModelBuilder(target_net, search_net, rpn_head)
+    tracker = SiamRPNTracker(model)
+
+    first_frame = True
+    cv.namedWindow('SiamRPN++ Tracker', cv.WINDOW_AUTOSIZE)
+    for frame in get_frames(args.input_video):
+        if first_frame:
+            try:
+                init_rect = cv.selectROI('SiamRPN++ Tracker', frame, False, False)
+            except:
+                exit()
+            tracker.init(frame, init_rect)
+            first_frame = False
+        else:
+            outputs = tracker.track(frame)
+            bbox = list(map(int, outputs['bbox']))
+            x,y,w,h = bbox
+            cv.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 3)
+        cv.imshow('SiamRPN++ Tracker', frame)
+        key = cv.waitKey(1)
+        if key == ord("q"):
+            break
+
+if __name__ == '__main__':
+    main()
diff --git a/C++/opencv-4.7.0/samples/dnn/speech_recognition.cpp b/C++/opencv-4.7.0/samples/dnn/speech_recognition.cpp
new file mode 100644
index 00000000..ff461c50
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/speech_recognition.cpp
@@ -0,0 +1,587 @@
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/dnn.hpp>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <unordered_map>
+#include <cmath>
+#include <random>
+#include <numeric>
+using namespace cv;
+using namespace std;
+
+class FilterbankFeatures {
+
+//     Initializes pre-processing class. Default values are the values used by the Jasper
+//     architecture for pre-processing. For more details, refer to the paper here:
+//     https://arxiv.org/abs/1904.03288
+
+private:
+    int sample_rate = 16000;
+    double window_size = 0.02;
+    double window_stride = 0.01;
+    int win_length = static_cast<int>(sample_rate * window_size); // Number of samples in window
+    int hop_length = static_cast<int>(sample_rate * window_stride); // Number of steps to advance between frames
+    int n_fft = 512; // Size of window for STFT
+
+    // Parameters for filterbanks calculation
+    int n_filt = 64;
+    double lowfreq = 0.;
+    double highfreq = sample_rate / 2;
+
+public:
+    // Mel filterbanks preparation
+    double hz_to_mel(double frequencies)
+    {
+        //Converts frequencies from hz to mel scale
+        // Fill in the linear scale
+        double f_min = 0.0;
+        double f_sp = 200.0 / 3;
+        double mels = (frequencies - f_min) / f_sp;
+        // Fill in the log-scale part
+        double min_log_hz = 1000.0;  // beginning of log region (Hz)
+        double min_log_mel = (min_log_hz - f_min) / f_sp;  // same (Mels)
+        double logstep = std::log(6.4) / 27.0;  // step size for log region
+
+        if (frequencies >= min_log_hz)
+        {
+            mels = min_log_mel + std::log(frequencies / min_log_hz) / logstep;
+        }
+        return mels;
+    }
+
+    vector<double> mel_to_hz(vector<double>& mels)
+    {
+        // Converts frequencies from mel to hz scale
+
+        // Fill in the linear scale
+        double f_min = 0.0;
+        double f_sp = 200.0 / 3;
+        vector<double> freqs;
+        for (size_t i = 0; i < mels.size(); i++)
+        {
+            freqs.push_back(f_min + f_sp * mels[i]);
+        }
+
+        // And now the nonlinear scale
+        double min_log_hz = 1000.0;  // beginning of log region (Hz)
+        double min_log_mel = (min_log_hz - f_min) / f_sp;  // same (Mels)
+        double logstep = std::log(6.4) / 27.0;  // step size for log region
+
+        for(size_t i = 0; i < mels.size(); i++)
+        {
+            if (mels[i] >= min_log_mel)
+            {
+                freqs[i] = min_log_hz * exp(logstep * (mels[i] - min_log_mel));
+            }
+        }
+        return freqs;
+    }
+
+    vector<double> mel_frequencies(int n_mels, double fmin, double fmax)
+    {
+        // Calculates n mel frequencies between 2 frequencies
+        double min_mel = hz_to_mel(fmin);
+        double max_mel = hz_to_mel(fmax);
+
+        vector<double> mels;
+        double step = (max_mel - min_mel) / (n_mels - 1);
+        for(double i = min_mel; i < max_mel; i += step)
+        {
+            mels.push_back(i);
+        }
+        mels.push_back(max_mel);
+
+        vector<double> res = mel_to_hz(mels);
+        return res;
+    }
+
+    vector<vector<double>> mel(int n_mels, double fmin, double fmax)
+    {
+        //  Generates mel filterbank matrix
+
+        double num = 1 + n_fft / 2;
+        vector<vector<double>> weights(n_mels, vector<double>(static_cast<int>(num), 0.));
+
+        // Center freqs of each FFT bin
+        vector<double> fftfreqs;
+        double step = (sample_rate / 2) / (num - 1);
+        for(double i = 0; i <= sample_rate / 2; i += step)
+        {
+            fftfreqs.push_back(i);
+        }
+        // 'Center freqs' of mel bands - uniformly spaced between limits
+        vector<double> mel_f = mel_frequencies(n_mels + 2, fmin, fmax);
+
+        vector<double> fdiff;
+        for(size_t i = 1; i < mel_f.size(); ++i)
+        {
+            fdiff.push_back(mel_f[i]- mel_f[i - 1]);
+        }
+
+        vector<vector<double>> ramps(mel_f.size(), vector<double>(fftfreqs.size()));
+        for (size_t i = 0; i < mel_f.size(); ++i)
+        {
+            for (size_t j = 0; j < fftfreqs.size(); ++j)
+            {
+                ramps[i][j] = mel_f[i] - fftfreqs[j];
+            }
+        }
+
+        double lower, upper, enorm;
+        for (int i = 0; i < n_mels; ++i)
+        {
+            // using Slaney-style mel which is scaled to be approx constant energy per channel
+            enorm = 2./(mel_f[i + 2] - mel_f[i]);
+
+            for (int j = 0; j < static_cast<int>(num); ++j)
+            {
+                // lower and upper slopes for all bins
+                lower = (-1) * ramps[i][j] / fdiff[i];
+                upper = ramps[i + 2][j] / fdiff[i + 1];
+
+                weights[i][j] = max(0., min(lower, upper)) * enorm;
+            }
+        }
+        return weights;
+    }
+
+    // STFT preparation
+    vector<double> pad_window_center(vector<double>&data, int size)
+    {
+        // Pad the window out to n_fft size
+        int n = static_cast<int>(data.size());
+        int lpad = static_cast<int>((size - n) / 2);
+        vector<double> pad_array;
+
+        for(int i = 0; i < lpad; ++i)
+        {
+            pad_array.push_back(0.);
+        }
+
+        for(size_t i = 0; i < data.size(); ++i)
+        {
+            pad_array.push_back(data[i]);
+        }
+
+        for(int i = 0; i < lpad; ++i)
+        {
+            pad_array.push_back(0.);
+        }
+        return pad_array;
+    }
+
+    vector<vector<double>> frame(vector<double>& x)
+    {
+        // Slices a data array into overlapping frames.
+        int n_frames = static_cast<int>(1 + (x.size() - n_fft) / hop_length);
+        vector<vector<double>> new_x(n_fft, vector<double>(n_frames));
+
+        for (int i = 0; i < n_fft; ++i)
+        {
+            for (int j = 0; j < n_frames; ++j)
+            {
+                new_x[i][j] = x[i + j * hop_length];
+            }
+        }
+        return new_x;
+    }
+
+    vector<double> hanning()
+    {
+        // https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows
+        vector<double> window_tensor;
+        for (int j = 1 - win_length; j < win_length; j+=2)
+        {
+            window_tensor.push_back(1 - (0.5 * (1 - cos(CV_PI * j / (win_length - 1)))));
+        }
+        return window_tensor;
+    }
+
+    vector<vector<double>> stft_power(vector<double>& y)
+    {
+        // Short Time Fourier Transform. The STFT represents a signal in the time-frequency
+        // domain by computing discrete Fourier transforms (DFT) over short overlapping windows.
+        // https://en.wikipedia.org/wiki/Short-time_Fourier_transform
+
+        // Pad the time series so that frames are centered
+        vector<double> new_y;
+        int num = int(n_fft / 2);
+
+        for (int i = 0; i < num; ++i)
+        {
+            new_y.push_back(y[num - i]);
+        }
+        for (size_t i = 0; i < y.size(); ++i)
+        {
+            new_y.push_back(y[i]);
+        }
+        for (size_t i = y.size() - 2; i >= y.size() - num - 1; --i)
+        {
+            new_y.push_back(y[i]);
+        }
+
+        // Compute a window function
+        vector<double> window_tensor = hanning();
+
+        // Pad the window out to n_fft size
+        vector<double> fft_window = pad_window_center(window_tensor, n_fft);
+
+        // Window the time series
+        vector<vector<double>> y_frames = frame(new_y);
+
+        // Multiply on fft_window
+        for (size_t i = 0; i < y_frames.size(); ++i)
+        {
+            for (size_t j = 0; j < y_frames[0].size(); ++j)
+            {
+                y_frames[i][j] *= fft_window[i];
+            }
+        }
+
+        // Transpose frames for computing stft
+        vector<vector<double>> y_frames_transpose(y_frames[0].size(), vector<double>(y_frames.size()));
+        for (size_t i = 0; i < y_frames[0].size(); ++i)
+        {
+            for (size_t j = 0; j < y_frames.size(); ++j)
+            {
+                y_frames_transpose[i][j] = y_frames[j][i];
+            }
+        }
+
+        // Short Time Fourier Transform
+        // and get power of spectrum
+        vector<vector<double>> spectrum_power(y_frames_transpose[0].size() / 2 + 1 );
+        for (size_t i = 0; i < y_frames_transpose.size(); ++i)
+        {
+            Mat dstMat;
+            dft(y_frames_transpose[i], dstMat, DFT_COMPLEX_OUTPUT);
+
+            // we need only the first part of the spectrum, the second part is symmetrical
+            for (int j = 0; j < static_cast<int>(y_frames_transpose[0].size()) / 2 + 1; ++j)
+            {
+                double power_re = dstMat.at<double>(2 * j) * dstMat.at<double>(2 * j);
+                double power_im = dstMat.at<double>(2 * j + 1) * dstMat.at<double>(2 * j + 1);
+                spectrum_power[j].push_back(power_re + power_im);
+            }
+        }
+        return spectrum_power;
+    }
+
+    Mat calculate_features(vector<double>& x)
+    {
+        // Calculates filterbank features matrix.
+
+        // Do preemphasis
+        std::default_random_engine generator;
+        std::normal_distribution<double> normal_distr(0, 1);
+        double dither = 1e-5;
+        for(size_t i = 0; i < x.size(); ++i)
+        {
+            x[i] += dither * static_cast<double>(normal_distr(generator));
+        }
+        double preemph = 0.97;
+        for (size_t i =  x.size() - 1; i > 0; --i)
+        {
+            x[i] -= preemph * x[i-1];
+        }
+
+        // Calculate Short Time Fourier Transform and get power of spectrum
+        auto spectrum_power = stft_power(x);
+
+        vector<vector<double>> filterbanks = mel(n_filt, lowfreq, highfreq);
+
+        // Calculate log of multiplication of filterbanks matrix on spectrum_power matrix
+        vector<vector<double>> x_stft(filterbanks.size(), vector<double>(spectrum_power[0].size(), 0));
+
+        for (size_t i = 0; i < filterbanks.size(); ++i)
+        {
+            for (size_t j = 0; j < filterbanks[0].size(); ++j)
+            {
+                for (size_t k = 0; k < spectrum_power[0].size(); ++k)
+                {
+                    x_stft[i][k] += filterbanks[i][j] * spectrum_power[j][k];
+                }
+            }
+            for (size_t k = 0; k < spectrum_power[0].size(); ++k)
+            {
+                x_stft[i][k] = std::log(x_stft[i][k] + 1e-20);
+            }
+        }
+
+        // normalize data
+        auto elments_num = x_stft[0].size();
+        for(size_t i = 0; i < x_stft.size(); ++i)
+        {
+            double x_mean = std::accumulate(x_stft[i].begin(), x_stft[i].end(), 0.) / elments_num; // arithmetic mean
+            double x_std = 0; // standard deviation
+            for(size_t j = 0; j < elments_num; ++j)
+            {
+                double subtract = x_stft[i][j] - x_mean;
+                x_std += subtract * subtract;
+            }
+            x_std /= elments_num;
+            x_std = sqrt(x_std) + 1e-10; // make sure x_std is not zero
+
+            for(size_t j = 0; j < elments_num; ++j)
+            {
+                x_stft[i][j] = (x_stft[i][j] - x_mean) / x_std; // standard score
+            }
+        }
+
+        Mat calculate_features(static_cast<int>(x_stft.size()), static_cast<int>(x_stft[0].size()), CV_32F);
+        for(int i = 0; i < calculate_features.size[0]; ++i)
+        {
+            for(int j = 0; j < calculate_features.size[1]; ++j)
+            {
+                calculate_features.at<float>(i, j) = static_cast<float>(x_stft[i][j]);
+            }
+        }
+        return calculate_features;
+    }
+};
+
+class Decoder {
+    // Used for decoding the output of jasper model
+private:
+    unordered_map<int, char> labels_map = fillMap();
+    int blank_id = 28;
+
+public:
+    unordered_map<int, char> fillMap()
+    {
+        vector<char> labels={' ','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p'
+                                ,'q','r','s','t','u','v','w','x','y','z','\''};
+        unordered_map<int, char> map;
+        for(int i = 0; i < static_cast<int>(labels.size()); ++i)
+        {
+            map[i] = labels[i];
+        }
+        return map;
+    }
+
+    string decode(Mat& x)
+    {
+        // Takes output of Jasper model and performs ctc decoding algorithm to
+        // remove duplicates and special symbol. Returns prediction
+
+        vector<int> prediction;
+        for(int i = 0; i < x.size[1]; ++i)
+        {
+            double maxEl = -1e10;
+            int ind = 0;
+            for(int j = 0; j < x.size[2]; ++j)
+            {
+                if (maxEl <= x.at<float>(0, i, j))
+                {
+                    maxEl = x.at<float>(0, i, j);
+                    ind = j;
+                }
+            }
+            prediction.push_back(ind);
+        }
+        // CTC decoding procedure
+        vector<double> decoded_prediction = {};
+        int previous = blank_id;
+
+        for(int i = 0; i < static_cast<int>(prediction.size()); ++i)
+        {
+            if (( prediction[i] != previous || previous == blank_id) &&  prediction[i] != blank_id)
+            {
+                decoded_prediction.push_back(prediction[i]);
+            }
+            previous = prediction[i];
+        }
+
+        string hypotheses = {};
+        for(size_t i = 0; i < decoded_prediction.size(); ++i)
+        {
+            auto it = labels_map.find(static_cast<char>(decoded_prediction[i]));
+            if (it != labels_map.end())
+                hypotheses.push_back(it->second);
+        }
+        return hypotheses;
+    }
+
+};
+
+static string predict(Mat& features, dnn::Net net, Decoder decoder)
+{
+    // Passes the features through the Jasper model and decodes the output to english transcripts.
+
+    // expand 2d features matrix to 3d
+    vector<int> sizes = {1, static_cast<int>(features.size[0]),
+                              static_cast<int>(features.size[1])};
+    features = features.reshape(0, sizes);
+
+    // make prediction
+    net.setInput(features);
+    Mat output = net.forward();
+
+    // decode output to transcript
+    auto prediction = decoder.decode(output);
+    return prediction;
+}
+
+static int readAudioFile(vector<double>& inputAudio, string file, int audioStream)
+{
+    VideoCapture cap;
+    int samplingRate = 16000;
+    vector<int> params {    CAP_PROP_AUDIO_STREAM, audioStream,
+                            CAP_PROP_VIDEO_STREAM, -1,
+                            CAP_PROP_AUDIO_DATA_DEPTH, CV_32F,
+                            CAP_PROP_AUDIO_SAMPLES_PER_SECOND, samplingRate
+                            };
+    cap.open(file, CAP_ANY, params);
+    if (!cap.isOpened())
+    {
+        cerr << "Error : Can't read audio file: '" << file << "' with audioStream = " << audioStream << endl;
+        return -1;
+    }
+    const int audioBaseIndex = (int)cap.get(CAP_PROP_AUDIO_BASE_INDEX);
+    vector<double> frameVec;
+    Mat frame;
+    for (;;)
+    {
+        if (cap.grab())
+        {
+            cap.retrieve(frame, audioBaseIndex);
+            frameVec = frame;
+            inputAudio.insert(inputAudio.end(), frameVec.begin(), frameVec.end());
+        }
+        else
+        {
+            break;
+        }
+    }
+    return samplingRate;
+}
+
+static int readAudioMicrophone(vector<double>& inputAudio, int microTime)
+{
+    VideoCapture cap;
+    int samplingRate = 16000;
+    vector<int> params {    CAP_PROP_AUDIO_STREAM, 0,
+                            CAP_PROP_VIDEO_STREAM, -1,
+                            CAP_PROP_AUDIO_DATA_DEPTH, CV_32F,
+                            CAP_PROP_AUDIO_SAMPLES_PER_SECOND, samplingRate
+                            };
+    cap.open(0, CAP_ANY, params);
+    if (!cap.isOpened())
+    {
+        cerr << "Error: Can't open microphone" << endl;
+        return -1;
+    }
+
+    const int audioBaseIndex = (int)cap.get(CAP_PROP_AUDIO_BASE_INDEX);
+    vector<double> frameVec;
+    Mat frame;
+    if (microTime <= 0)
+    {
+        cerr << "Error: Duration of audio chunk must be > 0" << endl;
+        return -1;
+    }
+    size_t sizeOfData = static_cast<size_t>(microTime * samplingRate);
+    while (inputAudio.size() < sizeOfData)
+    {
+        if (cap.grab())
+        {
+            cap.retrieve(frame, audioBaseIndex);
+            frameVec = frame;
+            inputAudio.insert(inputAudio.end(), frameVec.begin(), frameVec.end());
+        }
+        else
+        {
+            cerr << "Error: Grab error" << endl;
+            break;
+        }
+    }
+    return samplingRate;
+}
+
+int main(int argc, char** argv)
+{
+    const String keys =
+        "{help h usage ?     |                          | This script runs Jasper Speech recognition model }"
+        "{input_file i       |                          | Path to input audio file. If not specified, microphone input will be used }"
+        "{audio_duration t   | 15                       | Duration of audio chunk to be captured from microphone }"
+        "{audio_stream a     | 0                        | CAP_PROP_AUDIO_STREAM value     }"
+        "{show_spectrogram s | false                    | Show a spectrogram of the input audio: true / false / 1 / 0 }"
+        "{model m            | jasper.onnx              | Path to the onnx file of Jasper. You can download the converted onnx model "
+                                                          "from https://drive.google.com/drive/folders/1wLtxyao4ItAg8tt4Sb63zt6qXzhcQoR6?usp=sharing}"
+        "{backend b          | dnn::DNN_BACKEND_DEFAULT | Select a computation backend: "
+                                                          "dnn::DNN_BACKEND_DEFAULT, "
+                                                          "dnn::DNN_BACKEND_INFERENCE_ENGINE, "
+                                                          "dnn::DNN_BACKEND_OPENCV }"
+        "{target t           | dnn::DNN_TARGET_CPU      | Select a target device: "
+                                                          "dnn::DNN_TARGET_CPU, "
+                                                          "dnn::DNN_TARGET_OPENCL, "
+                                                          "dnn::DNN_TARGET_OPENCL_FP16 }"
+        ;
+    CommandLineParser parser(argc, argv, keys);
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    // Load Network
+    dnn::Net net = dnn::readNetFromONNX(parser.get<std::string>("model"));
+    net.setPreferableBackend(parser.get<int>("backend"));
+    net.setPreferableTarget(parser.get<int>("target"));
+
+    // Get audio
+    vector<double>inputAudio = {};
+    int samplingRate = 0;
+    if (parser.has("input_file"))
+    {
+        string audio = samples::findFile(parser.get<std::string>("input_file"));
+        samplingRate = readAudioFile(inputAudio, audio, parser.get<int>("audio_stream"));
+    }
+    else
+    {
+        samplingRate = readAudioMicrophone(inputAudio, parser.get<int>("audio_duration"));
+    }
+
+    if ((inputAudio.size() == 0) || samplingRate <= 0)
+    {
+        cerr << "Error: problems with audio reading, check input arguments" << endl;
+        return -1;
+    }
+
+    if (inputAudio.size() / samplingRate < 6)
+    {
+        cout << "Warning: For predictable network performance duration of audio must exceed 6 sec."
+                " Audio will be extended with zero samples" << endl;
+        for(int i = static_cast<int>(inputAudio.size()) - 1; i < samplingRate * 6; ++i)
+        {
+            inputAudio.push_back(0);
+        }
+    }
+
+    // Calculate features
+    FilterbankFeatures filter;
+    auto calculated_features = filter.calculate_features(inputAudio);
+
+    // Show spectogram if required
+    if (parser.get<bool>("show_spectrogram") == true)
+    {
+        Mat spectogram;
+        normalize(calculated_features, spectogram, 0, 255, NORM_MINMAX, CV_8U);
+        applyColorMap(spectogram, spectogram, COLORMAP_INFERNO);
+        imshow("spectogram", spectogram);
+        waitKey(0);
+    }
+
+    Decoder decoder;
+    string prediction = predict(calculated_features, net, decoder);
+    for( auto &transcript: prediction)
+    {
+        cout << transcript;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/speech_recognition.py b/C++/opencv-4.7.0/samples/dnn/speech_recognition.py
new file mode 100644
index 00000000..da2ce115
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/speech_recognition.py
@@ -0,0 +1,567 @@
+import numpy as np
+import cv2 as cv
+import argparse
+import os
+
+'''
+ You can download the converted onnx model from https://drive.google.com/drive/folders/1wLtxyao4ItAg8tt4Sb63zt6qXzhcQoR6?usp=sharing
+ or convert the model yourself.
+
+ You can get the original pre-trained Jasper model from NVIDIA : https://ngc.nvidia.com/catalog/models/nvidia:jasper_pyt_onnx_fp16_amp/files
+    Download and unzip : `$ wget --content-disposition https://api.ngc.nvidia.com/v2/models/nvidia/jasper_pyt_onnx_fp16_amp/versions/20.10.0/zip -O jasper_pyt_onnx_fp16_amp_20.10.0.zip && unzip -o ./jasper_pyt_onnx_fp16_amp_20.10.0.zip && unzip -o ./jasper_pyt_onnx_fp16_amp.zip`
+
+ you can get the script to convert the model here : https://gist.github.com/spazewalker/507f1529e19aea7e8417f6e935851a01
+
+ You can convert the model using the following steps:
+     1. Import onnx and load the original model
+        ```
+        import onnx
+        model = onnx.load("./jasper-onnx/1/model.onnx")
+        ```
+
+     3. Change data type of input layer
+        ```
+        inp = model.graph.input[0]
+        model.graph.input.remove(inp)
+        inp.type.tensor_type.elem_type = 1
+        model.graph.input.insert(0,inp)
+        ```
+
+     4. Change the data type of output layer
+        ```
+        out = model.graph.output[0]
+        model.graph.output.remove(out)
+        out.type.tensor_type.elem_type = 1
+        model.graph.output.insert(0,out)
+        ```
+
+     5. Change the data type of every initializer and cast it's values from FP16 to FP32
+        ```
+        for i,init in enumerate(model.graph.initializer):
+            model.graph.initializer.remove(init)
+            init.data_type = 1
+            init.raw_data = np.frombuffer(init.raw_data, count=np.product(init.dims), dtype=np.float16).astype(np.float32).tobytes()
+            model.graph.initializer.insert(i,init)
+        ```
+
+     6. Add an additional reshape node to handle the inconsistent input from python and c++ of openCV.
+        see https://github.com/opencv/opencv/issues/19091
+        Make & insert a new node with 'Reshape' operation & required initializer
+        ```
+            tensor = numpy_helper.from_array(np.array([0,64,-1]),name='shape_reshape')
+            model.graph.initializer.insert(0,tensor)
+            node = onnx.helper.make_node(op_type='Reshape',inputs=['input__0','shape_reshape'], outputs=['input_reshaped'], name='reshape__0')
+            model.graph.node.insert(0,node)
+            model.graph.node[1].input[0] = 'input_reshaped'
+        ```
+
+     7. Finally save the model
+        ```
+        with open('jasper_dynamic_input_float.onnx','wb') as f:
+            onnx.save_model(model,f)
+        ```
+
+    Original Repo : https://github.com/NVIDIA/DeepLearningExamples/tree/master/PyTorch/SpeechRecognition/Jasper
+ '''
+
+class FilterbankFeatures:
+    def __init__(self,
+                 sample_rate=16000, window_size=0.02, window_stride=0.01,
+                 n_fft=512, preemph=0.97, n_filt=64, lowfreq=0,
+                 highfreq=None, log=True, dither=1e-5):
+        '''
+            Initializes pre-processing class. Default values are the values used by the Jasper
+            architecture for pre-processing. For more details, refer to the paper here:
+            https://arxiv.org/abs/1904.03288
+        '''
+        self.win_length = int(sample_rate * window_size) # frame size
+        self.hop_length = int(sample_rate * window_stride) # stride
+        self.n_fft = n_fft or 2 ** np.ceil(np.log2(self.win_length))
+        self.log = log
+        self.dither = dither
+        self.n_filt = n_filt
+        self.preemph = preemph
+        highfreq = highfreq or sample_rate / 2
+        self.window_tensor = np.hanning(self.win_length)
+
+        self.filterbanks = self.mel(sample_rate, self.n_fft, n_mels=n_filt, fmin=lowfreq, fmax=highfreq)
+        self.filterbanks.dtype=np.float32
+        self.filterbanks = np.expand_dims(self.filterbanks,0)
+
+    def normalize_batch(self, x, seq_len):
+        '''
+            Normalizes the features.
+        '''
+        x_mean = np.zeros((seq_len.shape[0], x.shape[1]), dtype=x.dtype)
+        x_std = np.zeros((seq_len.shape[0], x.shape[1]), dtype=x.dtype)
+        for i in range(x.shape[0]):
+            x_mean[i, :] = np.mean(x[i, :, :seq_len[i]],axis=1)
+            x_std[i, :] = np.std(x[i, :, :seq_len[i]],axis=1)
+        # make sure x_std is not zero
+        x_std += 1e-10
+        return (x - np.expand_dims(x_mean,2)) / np.expand_dims(x_std,2)
+
+    def calculate_features(self, x, seq_len):
+        '''
+            Calculates filterbank features.
+            args:
+                x : mono channel audio
+                seq_len : length of the audio sample
+            returns:
+                x : filterbank features
+        '''
+        dtype = x.dtype
+
+        seq_len = np.ceil(seq_len / self.hop_length)
+        seq_len = np.array(seq_len,dtype=np.int32)
+
+        # dither
+        if self.dither > 0:
+            x += self.dither * np.random.randn(*x.shape)
+
+        # do preemphasis
+        if self.preemph is not None:
+            x = np.concatenate(
+                (np.expand_dims(x[0],-1), x[1:] - self.preemph * x[:-1]), axis=0)
+
+        # Short Time Fourier Transform
+        x  = self.stft(x, n_fft=self.n_fft, hop_length=self.hop_length,
+                  win_length=self.win_length,
+                  fft_window=self.window_tensor)
+
+        # get power spectrum
+        x = (x**2).sum(-1)
+
+        # dot with filterbank energies
+        x = np.matmul(np.array(self.filterbanks,dtype=x.dtype), x)
+
+        # log features if required
+        if self.log:
+            x = np.log(x + 1e-20)
+
+        # normalize if required
+        x = self.normalize_batch(x, seq_len).astype(dtype)
+        return x
+
+    # Mel Frequency calculation
+    def hz_to_mel(self, frequencies):
+        '''
+            Converts frequencies from hz to mel scale. Input can be a number or a vector.
+        '''
+        frequencies = np.asanyarray(frequencies)
+
+        f_min = 0.0
+        f_sp = 200.0 / 3
+
+        mels = (frequencies - f_min) / f_sp
+
+        # Fill in the log-scale part
+        min_log_hz = 1000.0  # beginning of log region (Hz)
+        min_log_mel = (min_log_hz - f_min) / f_sp  # same (Mels)
+        logstep = np.log(6.4) / 27.0  # step size for log region
+
+        if frequencies.ndim:
+            # If we have array data, vectorize
+            log_t = frequencies >= min_log_hz
+            mels[log_t] = min_log_mel + np.log(frequencies[log_t] / min_log_hz) / logstep
+        elif frequencies >= min_log_hz:
+            # If we have scalar data, directly
+            mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep
+        return mels
+
+    def mel_to_hz(self, mels):
+        '''
+            Converts frequencies from mel to hz scale. Input can be a number or a vector.
+        '''
+        mels = np.asanyarray(mels)
+
+        # Fill in the linear scale
+        f_min = 0.0
+        f_sp = 200.0 / 3
+        freqs = f_min + f_sp * mels
+
+        # And now the nonlinear scale
+        min_log_hz = 1000.0  # beginning of log region (Hz)
+        min_log_mel = (min_log_hz - f_min) / f_sp  # same (Mels)
+        logstep = np.log(6.4) / 27.0  # step size for log region
+
+        if mels.ndim:
+            # If we have vector data, vectorize
+            log_t = mels >= min_log_mel
+            freqs[log_t] = min_log_hz * np.exp(logstep * (mels[log_t] - min_log_mel))
+        elif mels >= min_log_mel:
+            # If we have scalar data, check directly
+            freqs = min_log_hz * np.exp(logstep * (mels - min_log_mel))
+
+        return freqs
+
+    def mel_frequencies(self, n_mels=128, fmin=0.0, fmax=11025.0):
+        '''
+            Calculates n mel frequencies between 2 frequencies
+            args:
+                n_mels : number of bands
+                fmin : min frequency
+                fmax : max frequency
+            returns:
+                mels : vector of mel frequencies
+        '''
+        # 'Center freqs' of mel bands - uniformly spaced between limits
+        min_mel = self.hz_to_mel(fmin)
+        max_mel = self.hz_to_mel(fmax)
+
+        mels = np.linspace(min_mel, max_mel, n_mels)
+
+        return self.mel_to_hz(mels)
+
+    def mel(self, sr, n_fft, n_mels=128, fmin=0.0, fmax=None, dtype=np.float32):
+        '''
+            Generates mel filterbank
+            args:
+                sr : Sampling rate
+                n_fft : number of FFT components
+                n_mels : number of Mel bands to generate
+                fmin : lowest frequency (in Hz)
+                fmax : highest frequency (in Hz). sr/2.0 if None
+                dtype : the data type of the output basis.
+            returns:
+                mels : Mel transform matrix
+        '''
+        # default Max freq = half of sampling rate
+        if fmax is None:
+            fmax = float(sr) / 2
+
+        # Initialize the weights
+        n_mels = int(n_mels)
+        weights = np.zeros((n_mels, int(1 + n_fft // 2)), dtype=dtype)
+
+        # Center freqs of each FFT bin
+        fftfreqs = np.linspace(0, float(sr) / 2, int(1 + n_fft // 2), endpoint=True)
+
+        # 'Center freqs' of mel bands - uniformly spaced between limits
+        mel_f = self.mel_frequencies(n_mels + 2, fmin=fmin, fmax=fmax)
+
+        fdiff = np.diff(mel_f)
+        ramps = np.subtract.outer(mel_f, fftfreqs)
+
+        for i in range(n_mels):
+            # lower and upper slopes for all bins
+            lower = -ramps[i] / fdiff[i]
+            upper = ramps[i + 2] / fdiff[i + 1]
+
+            # .. then intersect them with each other and zero
+            weights[i] = np.maximum(0, np.minimum(lower, upper))
+
+        # Using Slaney-style mel which is scaled to be approx constant energy per channel
+        enorm = 2.0 / (mel_f[2 : n_mels + 2] - mel_f[:n_mels])
+        weights *= enorm[:, np.newaxis]
+        return weights
+
+    # STFT preparation
+    def pad_window_center(self, data, size, axis=-1, **kwargs):
+        '''
+            Centers the data and pads.
+            args:
+                data : Vector to be padded and centered
+                size : Length to pad data
+                axis : Axis along which to pad and center the data
+                kwargs : arguments passed to np.pad
+            return : centered and padded data
+        '''
+        kwargs.setdefault("mode", "constant")
+        n = data.shape[axis]
+        lpad = int((size - n) // 2)
+        lengths = [(0, 0)] * data.ndim
+        lengths[axis] = (lpad, int(size - n - lpad))
+        if lpad < 0:
+            raise Exception(
+                ("Target size ({:d}) must be at least input size ({:d})").format(size, n)
+            )
+        return np.pad(data, lengths, **kwargs)
+
+    def frame(self, x, frame_length, hop_length):
+        '''
+            Slices a data array into (overlapping) frames.
+            args:
+                x : array to frame
+                frame_length : length of frame
+                hop_length : Number of steps to advance between frames
+            return : A framed view of `x`
+        '''
+        if x.shape[-1] < frame_length:
+            raise Exception(
+                "Input is too short (n={:d})"
+                " for frame_length={:d}".format(x.shape[-1], frame_length)
+            )
+        x = np.asfortranarray(x)
+        n_frames = 1 + (x.shape[-1] - frame_length) // hop_length
+        strides = np.asarray(x.strides)
+        new_stride = np.prod(strides[strides > 0] // x.itemsize) * x.itemsize
+        shape = list(x.shape)[:-1] + [frame_length, n_frames]
+        strides = list(strides) + [hop_length * new_stride]
+        return np.lib.stride_tricks.as_strided(x, shape=shape, strides=strides)
+
+    def dtype_r2c(self, d, default=np.complex64):
+        '''
+            Find the complex numpy dtype corresponding to a real dtype.
+            args:
+                d : The real-valued dtype to convert to complex.
+                default : The default complex target type, if `d` does not match a known dtype
+            return : The complex dtype
+        '''
+        mapping = {
+            np.dtype(np.float32): np.complex64,
+            np.dtype(np.float64): np.complex128,
+        }
+        dt = np.dtype(d)
+        if dt.kind == "c":
+            return dt
+        return np.dtype(mapping.get(dt, default))
+
+    def stft(self, y, n_fft, hop_length=None, win_length=None, fft_window=None, pad_mode='reflect', return_complex=False):
+        '''
+            Short Time Fourier Transform. The STFT represents a signal in the time-frequency
+            domain by computing discrete Fourier transforms (DFT) over short overlapping windows.
+            args:
+                y : input signal
+                n_fft : length of the windowed signal after padding with zeros.
+                hop_length : number of audio samples between adjacent STFT columns.
+                win_length : Each frame of audio is windowed by window of length win_length and
+                    then padded with zeros to match n_fft
+                fft_window : a vector or array of length `n_fft` having values computed by a
+                    window function
+                pad_mode : mode while padding the signal
+                return_complex : returns array with complex data type if `True`
+            return : Matrix of short-term Fourier transform coefficients.
+        '''
+        if win_length is None:
+            win_length = n_fft
+        if hop_length is None:
+            hop_length = int(win_length // 4)
+        if y.ndim!=1:
+            raise Exception(f'Invalid input shape. Only Mono Channeled audio supported. Input must have shape (Audio,). Got {y.shape}')
+
+        # Pad the window out to n_fft size
+        fft_window = self.pad_window_center(fft_window, n_fft)
+
+        # Reshape so that the window can be broadcast
+        fft_window = fft_window.reshape((-1, 1))
+
+        # Pad the time series so that frames are centered
+        y = np.pad(y, int(n_fft // 2), mode=pad_mode)
+
+        # Window the time series.
+        y_frames = self.frame(y, frame_length=n_fft, hop_length=hop_length)
+
+        # Convert data type to complex
+        dtype = self.dtype_r2c(y.dtype)
+
+        # Pre-allocate the STFT matrix
+        stft_matrix = np.empty( (int(1 + n_fft // 2), y_frames.shape[-1]), dtype=dtype, order="F")
+
+        stft_matrix = np.fft.rfft( fft_window * y_frames, axis=0)
+        return stft_matrix if return_complex==True else np.stack((stft_matrix.real,stft_matrix.imag),axis=-1)
+
+class Decoder:
+    '''
+        Used for decoding the output of jasper model.
+    '''
+    def __init__(self):
+        labels=[' ','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',"'"]
+        self.labels_map = {i: label for i,label in enumerate(labels)}
+        self.blank_id = 28
+
+    def decode(self,x):
+        """
+            Takes output of Jasper model and performs ctc decoding algorithm to
+            remove duplicates and special symbol. Returns prediction
+        """
+        x = np.argmax(x,axis=-1)
+        hypotheses = []
+        prediction = x.tolist()
+        # CTC decoding procedure
+        decoded_prediction = []
+        previous = self.blank_id
+        for p in prediction:
+            if (p != previous or previous == self.blank_id) and p != self.blank_id:
+                decoded_prediction.append(p)
+            previous = p
+        hypothesis = ''.join([self.labels_map[c] for c in decoded_prediction])
+        hypotheses.append(hypothesis)
+        return hypotheses
+
+def predict(features, net, decoder):
+    '''
+        Passes the features through the Jasper model and decodes the output to english transcripts.
+        args:
+            features : input features, calculated using FilterbankFeatures class
+            net : Jasper model dnn.net object
+            decoder : Decoder object
+        return : Predicted text
+    '''
+    # make prediction
+    net.setInput(features)
+    output = net.forward()
+
+    # decode output to transcript
+    prediction = decoder.decode(output.squeeze(0))
+    return prediction[0]
+
+def readAudioFile(file, audioStream):
+    cap = cv.VideoCapture(file)
+    samplingRate = 16000
+    params = np.asarray([cv.CAP_PROP_AUDIO_STREAM, audioStream,
+              cv.CAP_PROP_VIDEO_STREAM, -1,
+              cv.CAP_PROP_AUDIO_DATA_DEPTH, cv.CV_32F,
+              cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND, samplingRate
+              ])
+    cap.open(file, cv.CAP_ANY, params)
+    if cap.isOpened() is False:
+        print("Error : Can't read audio file:", file, "with audioStream = ", audioStream)
+        return
+    audioBaseIndex = int (cap.get(cv.CAP_PROP_AUDIO_BASE_INDEX))
+    inputAudio = []
+    while(1):
+        if (cap.grab()):
+            frame = np.asarray([])
+            frame = cap.retrieve(frame, audioBaseIndex)
+            for i in range(len(frame[1][0])):
+                inputAudio.append(frame[1][0][i])
+        else:
+            break
+    inputAudio = np.asarray(inputAudio, dtype=np.float64)
+    return inputAudio, samplingRate
+
+def readAudioMicrophone(microTime):
+    cap = cv.VideoCapture()
+    samplingRate = 16000
+    params = np.asarray([cv.CAP_PROP_AUDIO_STREAM, 0,
+              cv.CAP_PROP_VIDEO_STREAM, -1,
+              cv.CAP_PROP_AUDIO_DATA_DEPTH, cv.CV_32F,
+              cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND, samplingRate
+              ])
+    cap.open(0, cv.CAP_ANY, params)
+    if cap.isOpened() is False:
+        print("Error: Can't open microphone")
+        print("Error: problems with audio reading, check input arguments")
+        return
+    audioBaseIndex = int(cap.get(cv.CAP_PROP_AUDIO_BASE_INDEX))
+    cvTickFreq = cv.getTickFrequency()
+    sysTimeCurr = cv.getTickCount()
+    sysTimePrev = sysTimeCurr
+    inputAudio = []
+    while ((sysTimeCurr - sysTimePrev) / cvTickFreq < microTime):
+        if (cap.grab()):
+            frame = np.asarray([])
+            frame = cap.retrieve(frame, audioBaseIndex)
+            for i in range(len(frame[1][0])):
+                inputAudio.append(frame[1][0][i])
+            sysTimeCurr = cv.getTickCount()
+        else:
+            print("Error: Grab error")
+            break
+    inputAudio = np.asarray(inputAudio, dtype=np.float64)
+    print("Number of samples: ", len(inputAudio))
+    return inputAudio, samplingRate
+
+if __name__ == '__main__':
+
+    # Computation backends supported by layers
+    backends = (cv.dnn.DNN_BACKEND_DEFAULT, cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_BACKEND_OPENCV)
+    # Target Devices for computation
+    targets = (cv.dnn.DNN_TARGET_CPU, cv.dnn.DNN_TARGET_OPENCL, cv.dnn.DNN_TARGET_OPENCL_FP16)
+
+    parser = argparse.ArgumentParser(description='This script runs Jasper Speech recognition model',
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('--input_type', type=str, required=True, help='file or microphone')
+    parser.add_argument('--micro_time', type=int, default=15, help='Duration of microphone work in seconds. Must be more than 6 sec')
+    parser.add_argument('--input_audio', type=str, help='Path to input audio file. OR Path to a txt file with relative path to multiple audio files in different lines')
+    parser.add_argument('--audio_stream', type=int, default=0, help='CAP_PROP_AUDIO_STREAM value')
+    parser.add_argument('--show_spectrogram', action='store_true', help='Whether to show a spectrogram of the input audio.')
+    parser.add_argument('--model', type=str, default='jasper.onnx', help='Path to the onnx file of Jasper. default="jasper.onnx"')
+    parser.add_argument('--output', type=str, help='Path to file where recognized audio transcript must be saved. Leave this to print on console.')
+    parser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,
+                        help='Select a computation backend: '
+                        "%d: automatically (by default) "
+                        "%d: OpenVINO Inference Engine "
+                        "%d: OpenCV Implementation " % backends)
+    parser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,
+                        help='Select a target device: '
+                        "%d: CPU target (by default) "
+                        "%d: OpenCL "
+                        "%d: OpenCL FP16 " % targets)
+
+    args, _ = parser.parse_known_args()
+
+    if args.input_audio and not os.path.isfile(args.input_audio):
+        raise OSError("Input audio file does not exist")
+    if not os.path.isfile(args.model):
+        raise OSError("Jasper model file does not exist")
+
+    features = []
+    if args.input_type == "file":
+        if args.input_audio.endswith('.txt'):
+            with open(args.input_audio) as f:
+                content = f.readlines()
+                content = [x.strip() for x in content]
+                audio_file_paths = content
+            for audio_file_path in audio_file_paths:
+                if not os.path.isfile(audio_file_path):
+                    raise OSError("Audio file({audio_file_path}) does not exist")
+        else:
+            audio_file_paths = [args.input_audio]
+        audio_file_paths = [os.path.abspath(x) for x in audio_file_paths]
+
+        # Read audio Files
+        for audio_file_path in audio_file_paths:
+            audio = readAudioFile(audio_file_path, args.audio_stream)
+            if audio is None:
+                raise Exception(f"Can't read {args.input_audio}. Try a different format")
+            features.append(audio[0])
+    elif args.input_type == "microphone":
+        # Read audio from microphone
+        audio = readAudioMicrophone(args.micro_time)
+        if audio is None:
+            raise Exception(f"Can't open microphone. Try a different format")
+        features.append(audio[0])
+    else:
+        raise Exception(f"input_type {args.input_type} doesn't exist. Please enter 'file' or 'microphone'")
+
+    # Get Filterbank Features
+    feature_extractor = FilterbankFeatures()
+    for i in range(len(features)):
+        X = features[i]
+        seq_len = np.array([X.shape[0]], dtype=np.int32)
+        features[i] = feature_extractor.calculate_features(x=X, seq_len=seq_len)
+
+    # Load Network
+    net = cv.dnn.readNetFromONNX(args.model)
+    net.setPreferableBackend(args.backend)
+    net.setPreferableTarget(args.target)
+
+    # Show spectogram if required
+    if args.show_spectrogram and not args.input_audio.endswith('.txt'):
+        img = cv.normalize(src=features[0][0], dst=None, alpha=0, beta=255, norm_type=cv.NORM_MINMAX, dtype=cv.CV_8U)
+        img = cv.applyColorMap(img, cv.COLORMAP_JET)
+        cv.imshow('spectogram', img)
+        cv.waitKey(0)
+
+    # Initialize decoder
+    decoder = Decoder()
+
+    # Make prediction
+    prediction = []
+    print("Predicting...")
+    for feature in features:
+        print(f"\rAudio file {len(prediction)+1}/{len(features)}", end='')
+        prediction.append(predict(feature, net, decoder))
+    print("")
+
+    # save transcript if required
+    if args.output:
+        with open(args.output,'w') as f:
+            for pred in prediction:
+                f.write(pred+'\n')
+        print("Transcript was written to {}".format(args.output))
+    else:
+        print(prediction)
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/dnn/text_detection.cpp b/C++/opencv-4.7.0/samples/dnn/text_detection.cpp
new file mode 100644
index 00000000..76989dcd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/text_detection.cpp
@@ -0,0 +1,177 @@
+/*
+    Text detection model: https://github.com/argman/EAST
+    Download link: https://www.dropbox.com/s/r2ingd0l3zt8hxs/frozen_east_text_detection.tar.gz?dl=1
+
+    Text recognition models can be downloaded directly here:
+    Download link: https://drive.google.com/drive/folders/1cTbQ3nuZG-EKWak6emD_s8_hHXWz7lAr?usp=sharing
+    and doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown
+
+    How to convert from pb to onnx:
+    Using classes from here: https://github.com/meijieru/crnn.pytorch/blob/master/models/crnn.py
+    import torch
+    from models.crnn import CRNN
+    model = CRNN(32, 1, 37, 256)
+    model.load_state_dict(torch.load('crnn.pth'))
+    dummy_input = torch.randn(1, 1, 32, 100)
+    torch.onnx.export(model, dummy_input, "crnn.onnx", verbose=True)
+
+    For more information, please refer to doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown and doc/tutorials/dnn/dnn_OCR/dnn_OCR.markdown
+*/
+#include <iostream>
+#include <fstream>
+
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/dnn.hpp>
+
+using namespace cv;
+using namespace cv::dnn;
+
+const char* keys =
+    "{ help  h              | | Print help message. }"
+    "{ input i              | | Path to input image or video file. Skip this argument to capture frames from a camera.}"
+    "{ detModel dmp         | | Path to a binary .pb file contains trained detector network.}"
+    "{ width                | 320 | Preprocess input image by resizing to a specific width. It should be multiple by 32. }"
+    "{ height               | 320 | Preprocess input image by resizing to a specific height. It should be multiple by 32. }"
+    "{ thr                  | 0.5 | Confidence threshold. }"
+    "{ nms                  | 0.4 | Non-maximum suppression threshold. }"
+    "{ recModel rmp         | | Path to a binary .onnx file contains trained CRNN text recognition model. "
+        "Download links are provided in doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown}"
+    "{ RGBInput rgb         |0| 0: imread with flags=IMREAD_GRAYSCALE; 1: imread with flags=IMREAD_COLOR. }"
+    "{ vocabularyPath vp    | alphabet_36.txt | Path to benchmarks for evaluation. "
+        "Download links are provided in doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown}";
+
+void fourPointsTransform(const Mat& frame, const Point2f vertices[], Mat& result);
+
+int main(int argc, char** argv)
+{
+    // Parse command line arguments.
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("Use this script to run TensorFlow implementation (https://github.com/argman/EAST) of "
+                 "EAST: An Efficient and Accurate Scene Text Detector (https://arxiv.org/abs/1704.03155v2)");
+    if (argc == 1 || parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    float confThreshold = parser.get<float>("thr");
+    float nmsThreshold = parser.get<float>("nms");
+    int width = parser.get<int>("width");
+    int height = parser.get<int>("height");
+    int imreadRGB = parser.get<int>("RGBInput");
+    String detModelPath = parser.get<String>("detModel");
+    String recModelPath = parser.get<String>("recModel");
+    String vocPath = parser.get<String>("vocabularyPath");
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+
+    // Load networks.
+    CV_Assert(!detModelPath.empty() && !recModelPath.empty());
+    TextDetectionModel_EAST detector(detModelPath);
+    detector.setConfidenceThreshold(confThreshold)
+            .setNMSThreshold(nmsThreshold);
+
+    TextRecognitionModel recognizer(recModelPath);
+
+    // Load vocabulary
+    CV_Assert(!vocPath.empty());
+    std::ifstream vocFile;
+    vocFile.open(samples::findFile(vocPath));
+    CV_Assert(vocFile.is_open());
+    String vocLine;
+    std::vector<String> vocabulary;
+    while (std::getline(vocFile, vocLine)) {
+        vocabulary.push_back(vocLine);
+    }
+    recognizer.setVocabulary(vocabulary);
+    recognizer.setDecodeType("CTC-greedy");
+
+    // Parameters for Recognition
+    double recScale = 1.0 / 127.5;
+    Scalar recMean = Scalar(127.5, 127.5, 127.5);
+    Size recInputSize = Size(100, 32);
+    recognizer.setInputParams(recScale, recInputSize, recMean);
+
+    // Parameters for Detection
+    double detScale = 1.0;
+    Size detInputSize = Size(width, height);
+    Scalar detMean = Scalar(123.68, 116.78, 103.94);
+    bool swapRB = true;
+    detector.setInputParams(detScale, detInputSize, detMean, swapRB);
+
+    // Open a video file or an image file or a camera stream.
+    VideoCapture cap;
+    bool openSuccess = parser.has("input") ? cap.open(parser.get<String>("input")) : cap.open(0);
+    CV_Assert(openSuccess);
+
+    static const std::string kWinName = "EAST: An Efficient and Accurate Scene Text Detector";
+
+    Mat frame;
+    while (waitKey(1) < 0)
+    {
+        cap >> frame;
+        if (frame.empty())
+        {
+            waitKey();
+            break;
+        }
+
+        std::cout << frame.size << std::endl;
+
+        // Detection
+        std::vector< std::vector<Point> > detResults;
+        detector.detect(frame, detResults);
+
+        if (detResults.size() > 0) {
+            // Text Recognition
+            Mat recInput;
+            if (!imreadRGB) {
+                cvtColor(frame, recInput, cv::COLOR_BGR2GRAY);
+            } else {
+                recInput = frame;
+            }
+            std::vector< std::vector<Point> > contours;
+            for (uint i = 0; i < detResults.size(); i++)
+            {
+                const auto& quadrangle = detResults[i];
+                CV_CheckEQ(quadrangle.size(), (size_t)4, "");
+
+                contours.emplace_back(quadrangle);
+
+                std::vector<Point2f> quadrangle_2f;
+                for (int j = 0; j < 4; j++)
+                    quadrangle_2f.emplace_back(quadrangle[j]);
+
+                Mat cropped;
+                fourPointsTransform(recInput, &quadrangle_2f[0], cropped);
+
+                std::string recognitionResult = recognizer.recognize(cropped);
+                std::cout << i << ": '" << recognitionResult << "'" << std::endl;
+
+                putText(frame, recognitionResult, quadrangle[3], FONT_HERSHEY_SIMPLEX, 1.5, Scalar(0, 0, 255), 2);
+            }
+            polylines(frame, contours, true, Scalar(0, 255, 0), 2);
+        }
+        imshow(kWinName, frame);
+    }
+    return 0;
+}
+
+void fourPointsTransform(const Mat& frame, const Point2f vertices[], Mat& result)
+{
+    const Size outputSize = Size(100, 32);
+
+    Point2f targetVertices[4] = {
+        Point(0, outputSize.height - 1),
+        Point(0, 0), Point(outputSize.width - 1, 0),
+        Point(outputSize.width - 1, outputSize.height - 1)
+    };
+    Mat rotationMatrix = getPerspectiveTransform(vertices, targetVertices);
+
+    warpPerspective(frame, result, rotationMatrix, outputSize);
+}
diff --git a/C++/opencv-4.7.0/samples/dnn/text_detection.py b/C++/opencv-4.7.0/samples/dnn/text_detection.py
new file mode 100644
index 00000000..db0ea197
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/text_detection.py
@@ -0,0 +1,239 @@
+'''
+    Text detection model: https://github.com/argman/EAST
+    Download link: https://www.dropbox.com/s/r2ingd0l3zt8hxs/frozen_east_text_detection.tar.gz?dl=1
+
+    CRNN Text recognition model taken from here: https://github.com/meijieru/crnn.pytorch
+    How to convert from pb to onnx:
+    Using classes from here: https://github.com/meijieru/crnn.pytorch/blob/master/models/crnn.py
+
+    More converted onnx text recognition models can be downloaded directly here:
+    Download link: https://drive.google.com/drive/folders/1cTbQ3nuZG-EKWak6emD_s8_hHXWz7lAr?usp=sharing
+    And these models taken from here:https://github.com/clovaai/deep-text-recognition-benchmark
+
+    import torch
+    from models.crnn import CRNN
+
+    model = CRNN(32, 1, 37, 256)
+    model.load_state_dict(torch.load('crnn.pth'))
+    dummy_input = torch.randn(1, 1, 32, 100)
+    torch.onnx.export(model, dummy_input, "crnn.onnx", verbose=True)
+'''
+
+
+# Import required modules
+import numpy as np
+import cv2 as cv
+import math
+import argparse
+
+############ Add argument parser for command line arguments ############
+parser = argparse.ArgumentParser(
+    description="Use this script to run TensorFlow implementation (https://github.com/argman/EAST) of "
+                "EAST: An Efficient and Accurate Scene Text Detector (https://arxiv.org/abs/1704.03155v2)"
+                "The OCR model can be obtained from converting the pretrained CRNN model to .onnx format from the github repository https://github.com/meijieru/crnn.pytorch"
+                "Or you can download trained OCR model directly from https://drive.google.com/drive/folders/1cTbQ3nuZG-EKWak6emD_s8_hHXWz7lAr?usp=sharing")
+parser.add_argument('--input',
+                    help='Path to input image or video file. Skip this argument to capture frames from a camera.')
+parser.add_argument('--model', '-m', required=True,
+                    help='Path to a binary .pb file contains trained detector network.')
+parser.add_argument('--ocr', default="crnn.onnx",
+                    help="Path to a binary .pb or .onnx file contains trained recognition network", )
+parser.add_argument('--width', type=int, default=320,
+                    help='Preprocess input image by resizing to a specific width. It should be multiple by 32.')
+parser.add_argument('--height', type=int, default=320,
+                    help='Preprocess input image by resizing to a specific height. It should be multiple by 32.')
+parser.add_argument('--thr', type=float, default=0.5,
+                    help='Confidence threshold.')
+parser.add_argument('--nms', type=float, default=0.4,
+                    help='Non-maximum suppression threshold.')
+args = parser.parse_args()
+
+
+############ Utility functions ############
+
+def fourPointsTransform(frame, vertices):
+    vertices = np.asarray(vertices)
+    outputSize = (100, 32)
+    targetVertices = np.array([
+        [0, outputSize[1] - 1],
+        [0, 0],
+        [outputSize[0] - 1, 0],
+        [outputSize[0] - 1, outputSize[1] - 1]], dtype="float32")
+
+    rotationMatrix = cv.getPerspectiveTransform(vertices, targetVertices)
+    result = cv.warpPerspective(frame, rotationMatrix, outputSize)
+    return result
+
+
+def decodeText(scores):
+    text = ""
+    alphabet = "0123456789abcdefghijklmnopqrstuvwxyz"
+    for i in range(scores.shape[0]):
+        c = np.argmax(scores[i][0])
+        if c != 0:
+            text += alphabet[c - 1]
+        else:
+            text += '-'
+
+    # adjacent same letters as well as background text must be removed to get the final output
+    char_list = []
+    for i in range(len(text)):
+        if text[i] != '-' and (not (i > 0 and text[i] == text[i - 1])):
+            char_list.append(text[i])
+    return ''.join(char_list)
+
+
+def decodeBoundingBoxes(scores, geometry, scoreThresh):
+    detections = []
+    confidences = []
+
+    ############ CHECK DIMENSIONS AND SHAPES OF geometry AND scores ############
+    assert len(scores.shape) == 4, "Incorrect dimensions of scores"
+    assert len(geometry.shape) == 4, "Incorrect dimensions of geometry"
+    assert scores.shape[0] == 1, "Invalid dimensions of scores"
+    assert geometry.shape[0] == 1, "Invalid dimensions of geometry"
+    assert scores.shape[1] == 1, "Invalid dimensions of scores"
+    assert geometry.shape[1] == 5, "Invalid dimensions of geometry"
+    assert scores.shape[2] == geometry.shape[2], "Invalid dimensions of scores and geometry"
+    assert scores.shape[3] == geometry.shape[3], "Invalid dimensions of scores and geometry"
+    height = scores.shape[2]
+    width = scores.shape[3]
+    for y in range(0, height):
+
+        # Extract data from scores
+        scoresData = scores[0][0][y]
+        x0_data = geometry[0][0][y]
+        x1_data = geometry[0][1][y]
+        x2_data = geometry[0][2][y]
+        x3_data = geometry[0][3][y]
+        anglesData = geometry[0][4][y]
+        for x in range(0, width):
+            score = scoresData[x]
+
+            # If score is lower than threshold score, move to next x
+            if (score < scoreThresh):
+                continue
+
+            # Calculate offset
+            offsetX = x * 4.0
+            offsetY = y * 4.0
+            angle = anglesData[x]
+
+            # Calculate cos and sin of angle
+            cosA = math.cos(angle)
+            sinA = math.sin(angle)
+            h = x0_data[x] + x2_data[x]
+            w = x1_data[x] + x3_data[x]
+
+            # Calculate offset
+            offset = ([offsetX + cosA * x1_data[x] + sinA * x2_data[x], offsetY - sinA * x1_data[x] + cosA * x2_data[x]])
+
+            # Find points for rectangle
+            p1 = (-sinA * h + offset[0], -cosA * h + offset[1])
+            p3 = (-cosA * w + offset[0], sinA * w + offset[1])
+            center = (0.5 * (p1[0] + p3[0]), 0.5 * (p1[1] + p3[1]))
+            detections.append((center, (w, h), -1 * angle * 180.0 / math.pi))
+            confidences.append(float(score))
+
+    # Return detections and confidences
+    return [detections, confidences]
+
+
+def main():
+    # Read and store arguments
+    confThreshold = args.thr
+    nmsThreshold = args.nms
+    inpWidth = args.width
+    inpHeight = args.height
+    modelDetector = args.model
+    modelRecognition = args.ocr
+
+    # Load network
+    detector = cv.dnn.readNet(modelDetector)
+    recognizer = cv.dnn.readNet(modelRecognition)
+
+    # Create a new named window
+    kWinName = "EAST: An Efficient and Accurate Scene Text Detector"
+    cv.namedWindow(kWinName, cv.WINDOW_NORMAL)
+    outNames = []
+    outNames.append("feature_fusion/Conv_7/Sigmoid")
+    outNames.append("feature_fusion/concat_3")
+
+    # Open a video file or an image file or a camera stream
+    cap = cv.VideoCapture(args.input if args.input else 0)
+
+    tickmeter = cv.TickMeter()
+    while cv.waitKey(1) < 0:
+        # Read frame
+        hasFrame, frame = cap.read()
+        if not hasFrame:
+            cv.waitKey()
+            break
+
+        # Get frame height and width
+        height_ = frame.shape[0]
+        width_ = frame.shape[1]
+        rW = width_ / float(inpWidth)
+        rH = height_ / float(inpHeight)
+
+        # Create a 4D blob from frame.
+        blob = cv.dnn.blobFromImage(frame, 1.0, (inpWidth, inpHeight), (123.68, 116.78, 103.94), True, False)
+
+        # Run the detection model
+        detector.setInput(blob)
+
+        tickmeter.start()
+        outs = detector.forward(outNames)
+        tickmeter.stop()
+
+        # Get scores and geometry
+        scores = outs[0]
+        geometry = outs[1]
+        [boxes, confidences] = decodeBoundingBoxes(scores, geometry, confThreshold)
+
+        # Apply NMS
+        indices = cv.dnn.NMSBoxesRotated(boxes, confidences, confThreshold, nmsThreshold)
+        for i in indices:
+            # get 4 corners of the rotated rect
+            vertices = cv.boxPoints(boxes[i])
+            # scale the bounding box coordinates based on the respective ratios
+            for j in range(4):
+                vertices[j][0] *= rW
+                vertices[j][1] *= rH
+
+
+            # get cropped image using perspective transform
+            if modelRecognition:
+                cropped = fourPointsTransform(frame, vertices)
+                cropped = cv.cvtColor(cropped, cv.COLOR_BGR2GRAY)
+
+                # Create a 4D blob from cropped image
+                blob = cv.dnn.blobFromImage(cropped, size=(100, 32), mean=127.5, scalefactor=1 / 127.5)
+                recognizer.setInput(blob)
+
+                # Run the recognition model
+                tickmeter.start()
+                result = recognizer.forward()
+                tickmeter.stop()
+
+                # decode the result into text
+                wordRecognized = decodeText(result)
+                cv.putText(frame, wordRecognized, (int(vertices[1][0]), int(vertices[1][1])), cv.FONT_HERSHEY_SIMPLEX,
+                           0.5, (255, 0, 0))
+
+            for j in range(4):
+                p1 = (int(vertices[j][0]), int(vertices[j][1]))
+                p2 = (int(vertices[(j + 1) % 4][0]), int(vertices[(j + 1) % 4][1]))
+                cv.line(frame, p1, p2, (0, 255, 0), 1)
+
+        # Put efficiency information
+        label = 'Inference time: %.2f ms' % (tickmeter.getTimeMilli())
+        cv.putText(frame, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
+
+        # Display the frame
+        cv.imshow(kWinName, frame)
+        tickmeter.reset()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/dnn/tf_text_graph_common.py b/C++/opencv-4.7.0/samples/dnn/tf_text_graph_common.py
new file mode 100644
index 00000000..c82053b4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/tf_text_graph_common.py
@@ -0,0 +1,333 @@
+def tokenize(s):
+    tokens = []
+    token = ""
+    isString = False
+    isComment = False
+    for symbol in s:
+        isComment = (isComment and symbol != '\n') or (not isString and symbol == '#')
+        if isComment:
+            continue
+
+        if symbol == ' ' or symbol == '\t' or symbol == '\r' or symbol == '\'' or \
+           symbol == '\n' or symbol == ':' or symbol == '\"' or symbol == ';' or \
+           symbol == ',':
+
+            if (symbol == '\"' or symbol == '\'') and isString:
+                tokens.append(token)
+                token = ""
+            else:
+                if isString:
+                    token += symbol
+                elif token:
+                    tokens.append(token)
+                    token = ""
+            isString = (symbol == '\"' or symbol == '\'') ^ isString
+
+        elif symbol == '{' or symbol == '}' or symbol == '[' or symbol == ']':
+            if token:
+                tokens.append(token)
+                token = ""
+            tokens.append(symbol)
+        else:
+            token += symbol
+    if token:
+        tokens.append(token)
+    return tokens
+
+
+def parseMessage(tokens, idx):
+    msg = {}
+    assert(tokens[idx] == '{')
+
+    isArray = False
+    while True:
+        if not isArray:
+            idx += 1
+            if idx < len(tokens):
+                fieldName = tokens[idx]
+            else:
+                return None
+            if fieldName == '}':
+                break
+
+        idx += 1
+        fieldValue = tokens[idx]
+
+        if fieldValue == '{':
+            embeddedMsg, idx = parseMessage(tokens, idx)
+            if fieldName in msg:
+                msg[fieldName].append(embeddedMsg)
+            else:
+                msg[fieldName] = [embeddedMsg]
+        elif fieldValue == '[':
+            isArray = True
+        elif fieldValue == ']':
+            isArray = False
+        else:
+            if fieldName in msg:
+                msg[fieldName].append(fieldValue)
+            else:
+                msg[fieldName] = [fieldValue]
+    return msg, idx
+
+
+def readTextMessage(filePath):
+    if not filePath:
+        return {}
+    with open(filePath, 'rt') as f:
+        content = f.read()
+
+    tokens = tokenize('{' + content + '}')
+    msg = parseMessage(tokens, 0)
+    return msg[0] if msg else {}
+
+
+def listToTensor(values):
+    if all([isinstance(v, float) for v in values]):
+        dtype = 'DT_FLOAT'
+        field = 'float_val'
+    elif all([isinstance(v, int) for v in values]):
+        dtype = 'DT_INT32'
+        field = 'int_val'
+    else:
+        raise Exception('Wrong values types')
+
+    msg = {
+        'tensor': {
+            'dtype': dtype,
+            'tensor_shape': {
+                'dim': {
+                    'size': len(values)
+                }
+            }
+        }
+    }
+    msg['tensor'][field] = values
+    return msg
+
+
+def addConstNode(name, values, graph_def):
+    node = NodeDef()
+    node.name = name
+    node.op = 'Const'
+    node.addAttr('value', values)
+    graph_def.node.extend([node])
+
+
+def addSlice(inp, out, begins, sizes, graph_def):
+    beginsNode = NodeDef()
+    beginsNode.name = out + '/begins'
+    beginsNode.op = 'Const'
+    beginsNode.addAttr('value', begins)
+    graph_def.node.extend([beginsNode])
+
+    sizesNode = NodeDef()
+    sizesNode.name = out + '/sizes'
+    sizesNode.op = 'Const'
+    sizesNode.addAttr('value', sizes)
+    graph_def.node.extend([sizesNode])
+
+    sliced = NodeDef()
+    sliced.name = out
+    sliced.op = 'Slice'
+    sliced.input.append(inp)
+    sliced.input.append(beginsNode.name)
+    sliced.input.append(sizesNode.name)
+    graph_def.node.extend([sliced])
+
+
+def addReshape(inp, out, shape, graph_def):
+    shapeNode = NodeDef()
+    shapeNode.name = out + '/shape'
+    shapeNode.op = 'Const'
+    shapeNode.addAttr('value', shape)
+    graph_def.node.extend([shapeNode])
+
+    reshape = NodeDef()
+    reshape.name = out
+    reshape.op = 'Reshape'
+    reshape.input.append(inp)
+    reshape.input.append(shapeNode.name)
+    graph_def.node.extend([reshape])
+
+
+def addSoftMax(inp, out, graph_def):
+    softmax = NodeDef()
+    softmax.name = out
+    softmax.op = 'Softmax'
+    softmax.addAttr('axis', -1)
+    softmax.input.append(inp)
+    graph_def.node.extend([softmax])
+
+
+def addFlatten(inp, out, graph_def):
+    flatten = NodeDef()
+    flatten.name = out
+    flatten.op = 'Flatten'
+    flatten.input.append(inp)
+    graph_def.node.extend([flatten])
+
+
+class NodeDef:
+    def __init__(self):
+        self.input = []
+        self.name = ""
+        self.op = ""
+        self.attr = {}
+
+    def addAttr(self, key, value):
+        assert(not key in self.attr)
+        if isinstance(value, bool):
+            self.attr[key] = {'b': value}
+        elif isinstance(value, int):
+            self.attr[key] = {'i': value}
+        elif isinstance(value, float):
+            self.attr[key] = {'f': value}
+        elif isinstance(value, str):
+            self.attr[key] = {'s': value}
+        elif isinstance(value, list):
+            self.attr[key] = listToTensor(value)
+        else:
+            raise Exception('Unknown type of attribute ' + key)
+
+    def Clear(self):
+        self.input = []
+        self.name = ""
+        self.op = ""
+        self.attr = {}
+
+
+class GraphDef:
+    def __init__(self):
+        self.node = []
+
+    def save(self, filePath):
+        with open(filePath, 'wt') as f:
+
+            def printAttr(d, indent):
+                indent = ' ' * indent
+                for key, value in sorted(d.items(), key=lambda x:x[0].lower()):
+                    value = value if isinstance(value, list) else [value]
+                    for v in value:
+                        if isinstance(v, dict):
+                            f.write(indent + key + ' {\n')
+                            printAttr(v, len(indent) + 2)
+                            f.write(indent + '}\n')
+                        else:
+                            isString = False
+                            if isinstance(v, str) and not v.startswith('DT_'):
+                                try:
+                                    float(v)
+                                except:
+                                    isString = True
+
+                            if isinstance(v, bool):
+                                printed = 'true' if v else 'false'
+                            elif v == 'true' or v == 'false':
+                                printed = 'true' if v == 'true' else 'false'
+                            elif isString:
+                                printed = '\"%s\"' % v
+                            else:
+                                printed = str(v)
+                            f.write(indent + key + ': ' + printed + '\n')
+
+            for node in self.node:
+                f.write('node {\n')
+                f.write('  name: \"%s\"\n' % node.name)
+                f.write('  op: \"%s\"\n' % node.op)
+                for inp in node.input:
+                    f.write('  input: \"%s\"\n' % inp)
+                for key, value in sorted(node.attr.items(), key=lambda x:x[0].lower()):
+                    f.write('  attr {\n')
+                    f.write('    key: \"%s\"\n' % key)
+                    f.write('    value {\n')
+                    printAttr(value, 6)
+                    f.write('    }\n')
+                    f.write('  }\n')
+                f.write('}\n')
+
+
+def parseTextGraph(filePath):
+    msg = readTextMessage(filePath)
+
+    graph = GraphDef()
+    for node in msg['node']:
+        graphNode = NodeDef()
+        graphNode.name = node['name'][0]
+        graphNode.op = node['op'][0]
+        graphNode.input = node['input'] if 'input' in node else []
+
+        if 'attr' in node:
+            for attr in node['attr']:
+                graphNode.attr[attr['key'][0]] = attr['value'][0]
+
+        graph.node.append(graphNode)
+    return graph
+
+
+# Removes Identity nodes
+def removeIdentity(graph_def):
+    identities = {}
+    for node in graph_def.node:
+        if node.op == 'Identity' or node.op == 'IdentityN':
+            inp = node.input[0]
+            if inp in identities:
+                identities[node.name] = identities[inp]
+            else:
+                identities[node.name] = inp
+            graph_def.node.remove(node)
+
+    for node in graph_def.node:
+        for i in range(len(node.input)):
+            if node.input[i] in identities:
+                node.input[i] = identities[node.input[i]]
+
+
+def removeUnusedNodesAndAttrs(to_remove, graph_def):
+    unusedAttrs = ['T', 'Tshape', 'N', 'Tidx', 'Tdim', 'use_cudnn_on_gpu',
+                   'Index', 'Tperm', 'is_training', 'Tpaddings']
+
+    removedNodes = []
+
+    for i in reversed(range(len(graph_def.node))):
+        op = graph_def.node[i].op
+        name = graph_def.node[i].name
+
+        if to_remove(name, op):
+            if op != 'Const':
+                removedNodes.append(name)
+
+            del graph_def.node[i]
+        else:
+            for attr in unusedAttrs:
+                if attr in graph_def.node[i].attr:
+                    del graph_def.node[i].attr[attr]
+
+    # Remove references to removed nodes except Const nodes.
+    for node in graph_def.node:
+        for i in reversed(range(len(node.input))):
+            if node.input[i] in removedNodes:
+                del node.input[i]
+
+
+def writeTextGraph(modelPath, outputPath, outNodes):
+    try:
+        import cv2 as cv
+
+        cv.dnn.writeTextGraph(modelPath, outputPath)
+    except:
+        import tensorflow as tf
+        from tensorflow.tools.graph_transforms import TransformGraph
+
+        with tf.gfile.FastGFile(modelPath, 'rb') as f:
+            graph_def = tf.GraphDef()
+            graph_def.ParseFromString(f.read())
+
+            graph_def = TransformGraph(graph_def, ['image_tensor'], outNodes, ['sort_by_execution_order'])
+
+            for node in graph_def.node:
+                if node.op == 'Const':
+                    if 'value' in node.attr and node.attr['value'].tensor.tensor_content:
+                        node.attr['value'].tensor.tensor_content = b''
+
+        tf.train.write_graph(graph_def, "", outputPath, as_text=True)
diff --git a/C++/opencv-4.7.0/samples/dnn/tf_text_graph_efficientdet.py b/C++/opencv-4.7.0/samples/dnn/tf_text_graph_efficientdet.py
new file mode 100644
index 00000000..855691b2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/tf_text_graph_efficientdet.py
@@ -0,0 +1,236 @@
+# This file is a part of OpenCV project.
+# It is a subject to the license terms in the LICENSE file found in the top-level directory
+# of this distribution and at http://opencv.org/license.html.
+#
+# Copyright (C) 2020, Intel Corporation, all rights reserved.
+# Third party copyrights are property of their respective owners.
+#
+# Use this script to get the text graph representation (.pbtxt) of EfficientDet
+# deep learning network trained in https://github.com/google/automl.
+# Then you can import it with a binary frozen graph (.pb) using readNetFromTensorflow() function.
+# See details and examples on the following wiki page: https://github.com/opencv/opencv/wiki/TensorFlow-Object-Detection-API
+import argparse
+import re
+from math import sqrt
+from tf_text_graph_common import *
+
+
+class AnchorGenerator:
+    def __init__(self, min_level, aspect_ratios, num_scales, anchor_scale):
+        self.min_level = min_level
+        self.aspect_ratios = aspect_ratios
+        self.anchor_scale = anchor_scale
+        self.scales = [2**(float(s) / num_scales) for s in range(num_scales)]
+
+    def get(self, layer_id):
+        widths = []
+        heights = []
+        for s in self.scales:
+            for a in self.aspect_ratios:
+                base_anchor_size = 2**(self.min_level + layer_id) * self.anchor_scale
+                heights.append(base_anchor_size * s * a[1])
+                widths.append(base_anchor_size * s * a[0])
+        return widths, heights
+
+
+def createGraph(modelPath, outputPath, min_level, aspect_ratios, num_scales,
+                anchor_scale, num_classes, image_width, image_height):
+    print('Min level: %d' % min_level)
+    print('Anchor scale: %f' % anchor_scale)
+    print('Num scales: %d' % num_scales)
+    print('Aspect ratios: %s' % str(aspect_ratios))
+    print('Number of classes: %d' % num_classes)
+    print('Input image size: %dx%d' % (image_width, image_height))
+
+    # Read the graph.
+    _inpNames = ['image_arrays']
+    outNames = ['detections']
+
+    writeTextGraph(modelPath, outputPath, outNames)
+    graph_def = parseTextGraph(outputPath)
+
+    def getUnconnectedNodes():
+        unconnected = []
+        for node in graph_def.node:
+            if node.op == 'Const':
+                continue
+            unconnected.append(node.name)
+            for inp in node.input:
+                if inp in unconnected:
+                    unconnected.remove(inp)
+        return unconnected
+
+
+    nodesToKeep = ['truediv']  # Keep preprocessing nodes
+
+    removeIdentity(graph_def)
+
+    scopesToKeep = ('image_arrays', 'efficientnet', 'resample_p6', 'resample_p7',
+                    'fpn_cells', 'class_net', 'box_net', 'Reshape', 'concat')
+
+    addConstNode('scale_w', [2.0], graph_def)
+    addConstNode('scale_h', [2.0], graph_def)
+    nodesToKeep += ['scale_w', 'scale_h']
+
+    for node in graph_def.node:
+        if re.match('efficientnet-(.*)/blocks_\d+/se/mul_1', node.name):
+            node.input[0], node.input[1] = node.input[1], node.input[0]
+
+        if re.match('fpn_cells/cell_\d+/fnode\d+/resample(.*)/nearest_upsampling/Reshape_1$', node.name):
+            node.op = 'ResizeNearestNeighbor'
+            node.input[1] = 'scale_w'
+            node.input.append('scale_h')
+
+            for inpNode in graph_def.node:
+                if inpNode.name == node.name[:node.name.rfind('_')]:
+                    node.input[0] = inpNode.input[0]
+
+        if re.match('box_net/box-predict(_\d)*/separable_conv2d$', node.name):
+            node.addAttr('loc_pred_transposed', True)
+
+        # Replace RealDiv to Mul with inversed scale for compatibility
+        if node.op == 'RealDiv':
+            for inpNode in graph_def.node:
+                if inpNode.name != node.input[1] or not 'value' in inpNode.attr:
+                    continue
+
+                tensor = inpNode.attr['value']['tensor'][0]
+                if not 'float_val' in tensor:
+                    continue
+                scale = float(inpNode.attr['value']['tensor'][0]['float_val'][0])
+
+                addConstNode(inpNode.name + '/inv', [1.0 / scale], graph_def)
+                nodesToKeep.append(inpNode.name + '/inv')
+                node.input[1] = inpNode.name + '/inv'
+                node.op = 'Mul'
+                break
+
+
+    def to_remove(name, op):
+        if name in nodesToKeep:
+            return False
+        return op == 'Const' or not name.startswith(scopesToKeep)
+
+    removeUnusedNodesAndAttrs(to_remove, graph_def)
+
+    # Attach unconnected preprocessing
+    assert(graph_def.node[1].name == 'truediv' and graph_def.node[1].op == 'RealDiv')
+    graph_def.node[1].input.insert(0, 'image_arrays')
+    graph_def.node[2].input.insert(0, 'truediv')
+
+    priors_generator = AnchorGenerator(min_level, aspect_ratios, num_scales, anchor_scale)
+    priorBoxes = []
+    for i in range(5):
+        inpName = ''
+        for node in graph_def.node:
+            if node.name == 'Reshape_%d' % (i * 2 + 1):
+                inpName = node.input[0]
+                break
+
+        priorBox = NodeDef()
+        priorBox.name = 'PriorBox_%d' % i
+        priorBox.op = 'PriorBox'
+        priorBox.input.append(inpName)
+        priorBox.input.append(graph_def.node[0].name)  # image_tensor
+
+        priorBox.addAttr('flip', False)
+        priorBox.addAttr('clip', False)
+
+        widths, heights = priors_generator.get(i)
+
+        priorBox.addAttr('width', widths)
+        priorBox.addAttr('height', heights)
+        priorBox.addAttr('variance', [1.0, 1.0, 1.0, 1.0])
+
+        graph_def.node.extend([priorBox])
+        priorBoxes.append(priorBox.name)
+
+    addConstNode('concat/axis_flatten', [-1], graph_def)
+
+    def addConcatNode(name, inputs, axisNodeName):
+        concat = NodeDef()
+        concat.name = name
+        concat.op = 'ConcatV2'
+        for inp in inputs:
+            concat.input.append(inp)
+        concat.input.append(axisNodeName)
+        graph_def.node.extend([concat])
+
+    addConcatNode('PriorBox/concat', priorBoxes, 'concat/axis_flatten')
+
+    sigmoid = NodeDef()
+    sigmoid.name = 'concat/sigmoid'
+    sigmoid.op = 'Sigmoid'
+    sigmoid.input.append('concat')
+    graph_def.node.extend([sigmoid])
+
+    addFlatten(sigmoid.name, sigmoid.name + '/Flatten', graph_def)
+    addFlatten('concat_1', 'concat_1/Flatten', graph_def)
+
+    detectionOut = NodeDef()
+    detectionOut.name = 'detection_out'
+    detectionOut.op = 'DetectionOutput'
+
+    detectionOut.input.append('concat_1/Flatten')
+    detectionOut.input.append(sigmoid.name + '/Flatten')
+    detectionOut.input.append('PriorBox/concat')
+
+    detectionOut.addAttr('num_classes', num_classes)
+    detectionOut.addAttr('share_location', True)
+    detectionOut.addAttr('background_label_id', num_classes + 1)
+    detectionOut.addAttr('nms_threshold', 0.6)
+    detectionOut.addAttr('confidence_threshold', 0.2)
+    detectionOut.addAttr('top_k', 100)
+    detectionOut.addAttr('keep_top_k', 100)
+    detectionOut.addAttr('code_type', "CENTER_SIZE")
+    graph_def.node.extend([detectionOut])
+
+    graph_def.node[0].attr['shape'] =  {
+            'shape': {
+                'dim': [
+                    {'size': -1},
+                    {'size': image_height},
+                    {'size': image_width},
+                    {'size': 3}
+                ]
+            }
+        }
+
+    while True:
+        unconnectedNodes = getUnconnectedNodes()
+        unconnectedNodes.remove(detectionOut.name)
+        if not unconnectedNodes:
+            break
+
+        for name in unconnectedNodes:
+            for i in range(len(graph_def.node)):
+                if graph_def.node[i].name == name:
+                    del graph_def.node[i]
+                    break
+
+    # Save as text
+    graph_def.save(outputPath)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Run this script to get a text graph of '
+                                                 'SSD model from TensorFlow Object Detection API. '
+                                                 'Then pass it with .pb file to cv::dnn::readNetFromTensorflow function.')
+    parser.add_argument('--input', required=True, help='Path to frozen TensorFlow graph.')
+    parser.add_argument('--output', required=True, help='Path to output text graph.')
+    parser.add_argument('--min_level', default=3, type=int, help='Parameter from training config')
+    parser.add_argument('--num_scales', default=3, type=int, help='Parameter from training config')
+    parser.add_argument('--anchor_scale', default=4.0, type=float, help='Parameter from training config')
+    parser.add_argument('--aspect_ratios', default=[1.0, 1.0, 1.4, 0.7, 0.7, 1.4],
+                        nargs='+', type=float, help='Parameter from training config')
+    parser.add_argument('--num_classes', default=90, type=int, help='Number of classes to detect')
+    parser.add_argument('--width', default=512, type=int, help='Network input width')
+    parser.add_argument('--height', default=512, type=int, help='Network input height')
+    args = parser.parse_args()
+
+    ar = args.aspect_ratios
+    assert(len(ar) % 2 == 0)
+    ar = list(zip(ar[::2], ar[1::2]))
+
+    createGraph(args.input, args.output, args.min_level, ar, args.num_scales,
+                args.anchor_scale, args.num_classes, args.width, args.height)
diff --git a/C++/opencv-4.7.0/samples/dnn/tf_text_graph_faster_rcnn.py b/C++/opencv-4.7.0/samples/dnn/tf_text_graph_faster_rcnn.py
new file mode 100644
index 00000000..8a88c732
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/tf_text_graph_faster_rcnn.py
@@ -0,0 +1,299 @@
+import argparse
+import numpy as np
+from tf_text_graph_common import *
+
+
+def createFasterRCNNGraph(modelPath, configPath, outputPath):
+    scopesToKeep = ('FirstStageFeatureExtractor', 'Conv',
+                    'FirstStageBoxPredictor/BoxEncodingPredictor',
+                    'FirstStageBoxPredictor/ClassPredictor',
+                    'CropAndResize',
+                    'MaxPool2D',
+                    'SecondStageFeatureExtractor',
+                    'SecondStageBoxPredictor',
+                    'Preprocessor/sub',
+                    'Preprocessor/mul',
+                    'image_tensor')
+
+    scopesToIgnore = ('FirstStageFeatureExtractor/Assert',
+                      'FirstStageFeatureExtractor/Shape',
+                      'FirstStageFeatureExtractor/strided_slice',
+                      'FirstStageFeatureExtractor/GreaterEqual',
+                      'FirstStageFeatureExtractor/LogicalAnd')
+
+    # Load a config file.
+    config = readTextMessage(configPath)
+    config = config['model'][0]['faster_rcnn'][0]
+    num_classes = int(config['num_classes'][0])
+
+    grid_anchor_generator = config['first_stage_anchor_generator'][0]['grid_anchor_generator'][0]
+    scales = [float(s) for s in grid_anchor_generator['scales']]
+    aspect_ratios = [float(ar) for ar in grid_anchor_generator['aspect_ratios']]
+    width_stride = float(grid_anchor_generator['width_stride'][0])
+    height_stride = float(grid_anchor_generator['height_stride'][0])
+
+    feature_extractor = config['feature_extractor'][0]
+    if 'type' in feature_extractor and feature_extractor['type'][0] == 'faster_rcnn_nas':
+        features_stride = 16.0
+    else:
+        features_stride = float(feature_extractor['first_stage_features_stride'][0])
+
+    first_stage_nms_iou_threshold = float(config['first_stage_nms_iou_threshold'][0])
+    first_stage_max_proposals = int(config['first_stage_max_proposals'][0])
+
+    print('Number of classes: %d' % num_classes)
+    print('Scales:            %s' % str(scales))
+    print('Aspect ratios:     %s' % str(aspect_ratios))
+    print('Width stride:      %f' % width_stride)
+    print('Height stride:     %f' % height_stride)
+    print('Features stride:   %f' % features_stride)
+
+    # Read the graph.
+    writeTextGraph(modelPath, outputPath, ['num_detections', 'detection_scores', 'detection_boxes', 'detection_classes'])
+    graph_def = parseTextGraph(outputPath)
+
+    removeIdentity(graph_def)
+
+    nodesToKeep = []
+    def to_remove(name, op):
+        if name in nodesToKeep:
+            return False
+        return op == 'Const' or name.startswith(scopesToIgnore) or not name.startswith(scopesToKeep) or \
+               (name.startswith('CropAndResize') and op != 'CropAndResize')
+
+    # Fuse atrous convolutions (with dilations).
+    nodesMap = {node.name: node for node in graph_def.node}
+    for node in reversed(graph_def.node):
+        if node.op == 'BatchToSpaceND':
+            del node.input[2]
+            conv = nodesMap[node.input[0]]
+            spaceToBatchND = nodesMap[conv.input[0]]
+
+            # Extract paddings
+            stridedSlice = nodesMap[spaceToBatchND.input[2]]
+            assert(stridedSlice.op == 'StridedSlice')
+            pack = nodesMap[stridedSlice.input[0]]
+            assert(pack.op == 'Pack')
+
+            padNodeH = nodesMap[nodesMap[pack.input[0]].input[0]]
+            padNodeW = nodesMap[nodesMap[pack.input[1]].input[0]]
+            padH = int(padNodeH.attr['value']['tensor'][0]['int_val'][0])
+            padW = int(padNodeW.attr['value']['tensor'][0]['int_val'][0])
+
+            paddingsNode = NodeDef()
+            paddingsNode.name = conv.name + '/paddings'
+            paddingsNode.op = 'Const'
+            paddingsNode.addAttr('value', [padH, padH, padW, padW])
+            graph_def.node.insert(graph_def.node.index(spaceToBatchND), paddingsNode)
+            nodesToKeep.append(paddingsNode.name)
+
+            spaceToBatchND.input[2] = paddingsNode.name
+
+
+    removeUnusedNodesAndAttrs(to_remove, graph_def)
+
+
+    # Connect input node to the first layer
+    assert(graph_def.node[0].op == 'Placeholder')
+    graph_def.node[1].input.insert(0, graph_def.node[0].name)
+
+    # Temporarily remove top nodes.
+    topNodes = []
+    while True:
+        node = graph_def.node.pop()
+        topNodes.append(node)
+        if node.op == 'CropAndResize':
+            break
+
+    addReshape('FirstStageBoxPredictor/ClassPredictor/BiasAdd',
+               'FirstStageBoxPredictor/ClassPredictor/reshape_1', [0, -1, 2], graph_def)
+
+    addSoftMax('FirstStageBoxPredictor/ClassPredictor/reshape_1',
+               'FirstStageBoxPredictor/ClassPredictor/softmax', graph_def)  # Compare with Reshape_4
+
+    addFlatten('FirstStageBoxPredictor/ClassPredictor/softmax',
+               'FirstStageBoxPredictor/ClassPredictor/softmax/flatten', graph_def)
+
+    # Compare with FirstStageBoxPredictor/BoxEncodingPredictor/BiasAdd
+    addFlatten('FirstStageBoxPredictor/BoxEncodingPredictor/BiasAdd',
+               'FirstStageBoxPredictor/BoxEncodingPredictor/flatten', graph_def)
+
+    proposals = NodeDef()
+    proposals.name = 'proposals'  # Compare with ClipToWindow/Gather/Gather (NOTE: normalized)
+    proposals.op = 'PriorBox'
+    proposals.input.append('FirstStageBoxPredictor/BoxEncodingPredictor/BiasAdd')
+    proposals.input.append(graph_def.node[0].name)  # image_tensor
+
+    proposals.addAttr('flip', False)
+    proposals.addAttr('clip', True)
+    proposals.addAttr('step', features_stride)
+    proposals.addAttr('offset', 0.0)
+    proposals.addAttr('variance', [0.1, 0.1, 0.2, 0.2])
+
+    widths = []
+    heights = []
+    for a in aspect_ratios:
+        for s in scales:
+            ar = np.sqrt(a)
+            heights.append((height_stride**2) * s / ar)
+            widths.append((width_stride**2) * s * ar)
+
+    proposals.addAttr('width', widths)
+    proposals.addAttr('height', heights)
+
+    graph_def.node.extend([proposals])
+
+    # Compare with Reshape_5
+    detectionOut = NodeDef()
+    detectionOut.name = 'detection_out'
+    detectionOut.op = 'DetectionOutput'
+
+    detectionOut.input.append('FirstStageBoxPredictor/BoxEncodingPredictor/flatten')
+    detectionOut.input.append('FirstStageBoxPredictor/ClassPredictor/softmax/flatten')
+    detectionOut.input.append('proposals')
+
+    detectionOut.addAttr('num_classes', 2)
+    detectionOut.addAttr('share_location', True)
+    detectionOut.addAttr('background_label_id', 0)
+    detectionOut.addAttr('nms_threshold', first_stage_nms_iou_threshold)
+    detectionOut.addAttr('top_k', 6000)
+    detectionOut.addAttr('code_type', "CENTER_SIZE")
+    detectionOut.addAttr('keep_top_k', first_stage_max_proposals)
+    detectionOut.addAttr('clip', False)
+
+    graph_def.node.extend([detectionOut])
+
+    addConstNode('clip_by_value/lower', [0.0], graph_def)
+    addConstNode('clip_by_value/upper', [1.0], graph_def)
+
+    clipByValueNode = NodeDef()
+    clipByValueNode.name = 'detection_out/clip_by_value'
+    clipByValueNode.op = 'ClipByValue'
+    clipByValueNode.input.append('detection_out')
+    clipByValueNode.input.append('clip_by_value/lower')
+    clipByValueNode.input.append('clip_by_value/upper')
+    graph_def.node.extend([clipByValueNode])
+
+    # Save as text.
+    for node in reversed(topNodes):
+        graph_def.node.extend([node])
+
+    addSoftMax('SecondStageBoxPredictor/Reshape_1', 'SecondStageBoxPredictor/Reshape_1/softmax', graph_def)
+
+    addSlice('SecondStageBoxPredictor/Reshape_1/softmax',
+             'SecondStageBoxPredictor/Reshape_1/slice',
+             [0, 0, 1], [-1, -1, -1], graph_def)
+
+    addReshape('SecondStageBoxPredictor/Reshape_1/slice',
+              'SecondStageBoxPredictor/Reshape_1/Reshape', [1, -1], graph_def)
+
+    # Replace Flatten subgraph onto a single node.
+    cropAndResizeNodeName = ''
+    for i in reversed(range(len(graph_def.node))):
+        if graph_def.node[i].op == 'CropAndResize':
+            graph_def.node[i].input.insert(1, 'detection_out/clip_by_value')
+            cropAndResizeNodeName = graph_def.node[i].name
+
+        if graph_def.node[i].name == 'SecondStageBoxPredictor/Reshape':
+            addConstNode('SecondStageBoxPredictor/Reshape/shape2', [1, -1, 4], graph_def)
+
+            graph_def.node[i].input.pop()
+            graph_def.node[i].input.append('SecondStageBoxPredictor/Reshape/shape2')
+
+        if graph_def.node[i].name in ['SecondStageBoxPredictor/Flatten/flatten/Shape',
+                                      'SecondStageBoxPredictor/Flatten/flatten/strided_slice',
+                                      'SecondStageBoxPredictor/Flatten/flatten/Reshape/shape',
+                                      'SecondStageBoxPredictor/Flatten_1/flatten/Shape',
+                                      'SecondStageBoxPredictor/Flatten_1/flatten/strided_slice',
+                                      'SecondStageBoxPredictor/Flatten_1/flatten/Reshape/shape']:
+            del graph_def.node[i]
+
+    for node in graph_def.node:
+        if node.name == 'SecondStageBoxPredictor/Flatten/flatten/Reshape' or \
+           node.name == 'SecondStageBoxPredictor/Flatten_1/flatten/Reshape':
+            node.op = 'Flatten'
+            node.input.pop()
+
+        if node.name in ['FirstStageBoxPredictor/BoxEncodingPredictor/Conv2D',
+                         'SecondStageBoxPredictor/BoxEncodingPredictor/MatMul']:
+            node.addAttr('loc_pred_transposed', True)
+
+        if node.name.startswith('MaxPool2D'):
+            assert(node.op == 'MaxPool')
+            assert(cropAndResizeNodeName)
+            node.input = [cropAndResizeNodeName]
+
+    ################################################################################
+    ### Postprocessing
+    ################################################################################
+    addSlice('detection_out/clip_by_value', 'detection_out/slice', [0, 0, 0, 3], [-1, -1, -1, 4], graph_def)
+
+    variance = NodeDef()
+    variance.name = 'proposals/variance'
+    variance.op = 'Const'
+    variance.addAttr('value', [0.1, 0.1, 0.2, 0.2])
+    graph_def.node.extend([variance])
+
+    varianceEncoder = NodeDef()
+    varianceEncoder.name = 'variance_encoded'
+    varianceEncoder.op = 'Mul'
+    varianceEncoder.input.append('SecondStageBoxPredictor/Reshape')
+    varianceEncoder.input.append(variance.name)
+    varianceEncoder.addAttr('axis', 2)
+    graph_def.node.extend([varianceEncoder])
+
+    addReshape('detection_out/slice', 'detection_out/slice/reshape', [1, 1, -1], graph_def)
+    addFlatten('variance_encoded', 'variance_encoded/flatten', graph_def)
+
+    detectionOut = NodeDef()
+    detectionOut.name = 'detection_out_final'
+    detectionOut.op = 'DetectionOutput'
+
+    detectionOut.input.append('variance_encoded/flatten')
+    detectionOut.input.append('SecondStageBoxPredictor/Reshape_1/Reshape')
+    detectionOut.input.append('detection_out/slice/reshape')
+
+    detectionOut.addAttr('num_classes', num_classes)
+    detectionOut.addAttr('share_location', False)
+    detectionOut.addAttr('background_label_id', num_classes + 1)
+    detectionOut.addAttr('nms_threshold', 0.6)
+    detectionOut.addAttr('code_type', "CENTER_SIZE")
+    detectionOut.addAttr('keep_top_k', 100)
+    detectionOut.addAttr('clip', True)
+    detectionOut.addAttr('variance_encoded_in_target', True)
+    graph_def.node.extend([detectionOut])
+
+    def getUnconnectedNodes():
+        unconnected = [node.name for node in graph_def.node]
+        for node in graph_def.node:
+            for inp in node.input:
+                if inp in unconnected:
+                    unconnected.remove(inp)
+        return unconnected
+
+    while True:
+        unconnectedNodes = getUnconnectedNodes()
+        unconnectedNodes.remove(detectionOut.name)
+        if not unconnectedNodes:
+            break
+
+        for name in unconnectedNodes:
+            for i in range(len(graph_def.node)):
+                if graph_def.node[i].name == name:
+                    del graph_def.node[i]
+                    break
+
+    # Save as text.
+    graph_def.save(outputPath)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Run this script to get a text graph of '
+                                                 'Faster-RCNN model from TensorFlow Object Detection API. '
+                                                 'Then pass it with .pb file to cv::dnn::readNetFromTensorflow function.')
+    parser.add_argument('--input', required=True, help='Path to frozen TensorFlow graph.')
+    parser.add_argument('--output', required=True, help='Path to output text graph.')
+    parser.add_argument('--config', required=True, help='Path to a *.config file is used for training.')
+    args = parser.parse_args()
+
+    createFasterRCNNGraph(args.input, args.config, args.output)
diff --git a/C++/opencv-4.7.0/samples/dnn/tf_text_graph_mask_rcnn.py b/C++/opencv-4.7.0/samples/dnn/tf_text_graph_mask_rcnn.py
new file mode 100644
index 00000000..24d8790d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/tf_text_graph_mask_rcnn.py
@@ -0,0 +1,297 @@
+import argparse
+import numpy as np
+from tf_text_graph_common import *
+
+parser = argparse.ArgumentParser(description='Run this script to get a text graph of '
+                                             'Mask-RCNN model from TensorFlow Object Detection API. '
+                                             'Then pass it with .pb file to cv::dnn::readNetFromTensorflow function.')
+parser.add_argument('--input', required=True, help='Path to frozen TensorFlow graph.')
+parser.add_argument('--output', required=True, help='Path to output text graph.')
+parser.add_argument('--config', required=True, help='Path to a *.config file is used for training.')
+args = parser.parse_args()
+
+scopesToKeep = ('FirstStageFeatureExtractor', 'Conv',
+                'FirstStageBoxPredictor/BoxEncodingPredictor',
+                'FirstStageBoxPredictor/ClassPredictor',
+                'CropAndResize',
+                'MaxPool2D',
+                'SecondStageFeatureExtractor',
+                'SecondStageBoxPredictor',
+                'Preprocessor/sub',
+                'Preprocessor/mul',
+                'image_tensor')
+
+scopesToIgnore = ('FirstStageFeatureExtractor/Assert',
+                  'FirstStageFeatureExtractor/Shape',
+                  'FirstStageFeatureExtractor/strided_slice',
+                  'FirstStageFeatureExtractor/GreaterEqual',
+                  'FirstStageFeatureExtractor/LogicalAnd',
+                  'Conv/required_space_to_batch_paddings')
+
+# Load a config file.
+config = readTextMessage(args.config)
+config = config['model'][0]['faster_rcnn'][0]
+num_classes = int(config['num_classes'][0])
+
+grid_anchor_generator = config['first_stage_anchor_generator'][0]['grid_anchor_generator'][0]
+scales = [float(s) for s in grid_anchor_generator['scales']]
+aspect_ratios = [float(ar) for ar in grid_anchor_generator['aspect_ratios']]
+width_stride = float(grid_anchor_generator['width_stride'][0])
+height_stride = float(grid_anchor_generator['height_stride'][0])
+features_stride = float(config['feature_extractor'][0]['first_stage_features_stride'][0])
+first_stage_nms_iou_threshold = float(config['first_stage_nms_iou_threshold'][0])
+first_stage_max_proposals = int(config['first_stage_max_proposals'][0])
+
+print('Number of classes: %d' % num_classes)
+print('Scales:            %s' % str(scales))
+print('Aspect ratios:     %s' % str(aspect_ratios))
+print('Width stride:      %f' % width_stride)
+print('Height stride:     %f' % height_stride)
+print('Features stride:   %f' % features_stride)
+
+# Read the graph.
+writeTextGraph(args.input, args.output, ['num_detections', 'detection_scores', 'detection_boxes', 'detection_classes', 'detection_masks'])
+graph_def = parseTextGraph(args.output)
+
+removeIdentity(graph_def)
+
+nodesToKeep = []
+def to_remove(name, op):
+    if name in nodesToKeep:
+        return False
+    return op == 'Const' or name.startswith(scopesToIgnore) or not name.startswith(scopesToKeep) or \
+           (name.startswith('CropAndResize') and op != 'CropAndResize')
+
+# Fuse atrous convolutions (with dilations).
+nodesMap = {node.name: node for node in graph_def.node}
+for node in reversed(graph_def.node):
+    if node.op == 'BatchToSpaceND':
+        del node.input[2]
+        conv = nodesMap[node.input[0]]
+        spaceToBatchND = nodesMap[conv.input[0]]
+
+        paddingsNode = NodeDef()
+        paddingsNode.name = conv.name + '/paddings'
+        paddingsNode.op = 'Const'
+        paddingsNode.addAttr('value', [2, 2, 2, 2])
+        graph_def.node.insert(graph_def.node.index(spaceToBatchND), paddingsNode)
+        nodesToKeep.append(paddingsNode.name)
+
+        spaceToBatchND.input[2] = paddingsNode.name
+
+removeUnusedNodesAndAttrs(to_remove, graph_def)
+
+
+# Connect input node to the first layer
+assert(graph_def.node[0].op == 'Placeholder')
+graph_def.node[1].input.insert(0, graph_def.node[0].name)
+
+# Temporarily remove top nodes.
+topNodes = []
+numCropAndResize = 0
+while True:
+    node = graph_def.node.pop()
+    topNodes.append(node)
+    if node.op == 'CropAndResize':
+        numCropAndResize += 1
+        if numCropAndResize == 2:
+            break
+
+addReshape('FirstStageBoxPredictor/ClassPredictor/BiasAdd',
+           'FirstStageBoxPredictor/ClassPredictor/reshape_1', [0, -1, 2], graph_def)
+
+addSoftMax('FirstStageBoxPredictor/ClassPredictor/reshape_1',
+           'FirstStageBoxPredictor/ClassPredictor/softmax', graph_def)  # Compare with Reshape_4
+
+addFlatten('FirstStageBoxPredictor/ClassPredictor/softmax',
+           'FirstStageBoxPredictor/ClassPredictor/softmax/flatten', graph_def)
+
+# Compare with FirstStageBoxPredictor/BoxEncodingPredictor/BiasAdd
+addFlatten('FirstStageBoxPredictor/BoxEncodingPredictor/BiasAdd',
+           'FirstStageBoxPredictor/BoxEncodingPredictor/flatten', graph_def)
+
+proposals = NodeDef()
+proposals.name = 'proposals'  # Compare with ClipToWindow/Gather/Gather (NOTE: normalized)
+proposals.op = 'PriorBox'
+proposals.input.append('FirstStageBoxPredictor/BoxEncodingPredictor/BiasAdd')
+proposals.input.append(graph_def.node[0].name)  # image_tensor
+
+proposals.addAttr('flip', False)
+proposals.addAttr('clip', True)
+proposals.addAttr('step', features_stride)
+proposals.addAttr('offset', 0.0)
+proposals.addAttr('variance', [0.1, 0.1, 0.2, 0.2])
+
+widths = []
+heights = []
+for a in aspect_ratios:
+    for s in scales:
+        ar = np.sqrt(a)
+        heights.append((height_stride**2) * s / ar)
+        widths.append((width_stride**2) * s * ar)
+
+proposals.addAttr('width', widths)
+proposals.addAttr('height', heights)
+
+graph_def.node.extend([proposals])
+
+# Compare with Reshape_5
+detectionOut = NodeDef()
+detectionOut.name = 'detection_out'
+detectionOut.op = 'DetectionOutput'
+
+detectionOut.input.append('FirstStageBoxPredictor/BoxEncodingPredictor/flatten')
+detectionOut.input.append('FirstStageBoxPredictor/ClassPredictor/softmax/flatten')
+detectionOut.input.append('proposals')
+
+detectionOut.addAttr('num_classes', 2)
+detectionOut.addAttr('share_location', True)
+detectionOut.addAttr('background_label_id', 0)
+detectionOut.addAttr('nms_threshold', first_stage_nms_iou_threshold)
+detectionOut.addAttr('top_k', 6000)
+detectionOut.addAttr('code_type', "CENTER_SIZE")
+detectionOut.addAttr('keep_top_k', first_stage_max_proposals)
+detectionOut.addAttr('clip', True)
+
+graph_def.node.extend([detectionOut])
+
+# Save as text.
+cropAndResizeNodesNames = []
+for node in reversed(topNodes):
+    if node.op != 'CropAndResize':
+        graph_def.node.extend([node])
+        topNodes.pop()
+    else:
+        cropAndResizeNodesNames.append(node.name)
+        if numCropAndResize == 1:
+            break
+        else:
+            graph_def.node.extend([node])
+            topNodes.pop()
+            numCropAndResize -= 1
+
+addSoftMax('SecondStageBoxPredictor/Reshape_1', 'SecondStageBoxPredictor/Reshape_1/softmax', graph_def)
+
+addSlice('SecondStageBoxPredictor/Reshape_1/softmax',
+         'SecondStageBoxPredictor/Reshape_1/slice',
+         [0, 0, 1], [-1, -1, -1], graph_def)
+
+addReshape('SecondStageBoxPredictor/Reshape_1/slice',
+          'SecondStageBoxPredictor/Reshape_1/Reshape', [1, -1], graph_def)
+
+# Replace Flatten subgraph onto a single node.
+for i in reversed(range(len(graph_def.node))):
+    if graph_def.node[i].op == 'CropAndResize':
+        graph_def.node[i].input.insert(1, 'detection_out')
+
+    if graph_def.node[i].name == 'SecondStageBoxPredictor/Reshape':
+        addConstNode('SecondStageBoxPredictor/Reshape/shape2', [1, -1, 4], graph_def)
+
+        graph_def.node[i].input.pop()
+        graph_def.node[i].input.append('SecondStageBoxPredictor/Reshape/shape2')
+
+    if graph_def.node[i].name in ['SecondStageBoxPredictor/Flatten/flatten/Shape',
+                                  'SecondStageBoxPredictor/Flatten/flatten/strided_slice',
+                                  'SecondStageBoxPredictor/Flatten/flatten/Reshape/shape',
+                                  'SecondStageBoxPredictor/Flatten_1/flatten/Shape',
+                                  'SecondStageBoxPredictor/Flatten_1/flatten/strided_slice',
+                                  'SecondStageBoxPredictor/Flatten_1/flatten/Reshape/shape']:
+        del graph_def.node[i]
+
+for node in graph_def.node:
+    if node.name == 'SecondStageBoxPredictor/Flatten/flatten/Reshape' or \
+       node.name == 'SecondStageBoxPredictor/Flatten_1/flatten/Reshape':
+        node.op = 'Flatten'
+        node.input.pop()
+
+    if node.name in ['FirstStageBoxPredictor/BoxEncodingPredictor/Conv2D',
+                     'SecondStageBoxPredictor/BoxEncodingPredictor/MatMul']:
+        node.addAttr('loc_pred_transposed', True)
+
+    if node.name.startswith('MaxPool2D'):
+        assert(node.op == 'MaxPool')
+        assert(len(cropAndResizeNodesNames) == 2)
+        node.input = [cropAndResizeNodesNames[0]]
+        del cropAndResizeNodesNames[0]
+
+################################################################################
+### Postprocessing
+################################################################################
+addSlice('detection_out', 'detection_out/slice', [0, 0, 0, 3], [-1, -1, -1, 4], graph_def)
+
+variance = NodeDef()
+variance.name = 'proposals/variance'
+variance.op = 'Const'
+variance.addAttr('value', [0.1, 0.1, 0.2, 0.2])
+graph_def.node.extend([variance])
+
+varianceEncoder = NodeDef()
+varianceEncoder.name = 'variance_encoded'
+varianceEncoder.op = 'Mul'
+varianceEncoder.input.append('SecondStageBoxPredictor/Reshape')
+varianceEncoder.input.append(variance.name)
+varianceEncoder.addAttr('axis', 2)
+graph_def.node.extend([varianceEncoder])
+
+addReshape('detection_out/slice', 'detection_out/slice/reshape', [1, 1, -1], graph_def)
+addFlatten('variance_encoded', 'variance_encoded/flatten', graph_def)
+
+detectionOut = NodeDef()
+detectionOut.name = 'detection_out_final'
+detectionOut.op = 'DetectionOutput'
+
+detectionOut.input.append('variance_encoded/flatten')
+detectionOut.input.append('SecondStageBoxPredictor/Reshape_1/Reshape')
+detectionOut.input.append('detection_out/slice/reshape')
+
+detectionOut.addAttr('num_classes', num_classes)
+detectionOut.addAttr('share_location', False)
+detectionOut.addAttr('background_label_id', num_classes + 1)
+detectionOut.addAttr('nms_threshold', 0.6)
+detectionOut.addAttr('code_type', "CENTER_SIZE")
+detectionOut.addAttr('keep_top_k',100)
+detectionOut.addAttr('clip', True)
+detectionOut.addAttr('variance_encoded_in_target', True)
+detectionOut.addAttr('confidence_threshold', 0.3)
+detectionOut.addAttr('group_by_classes', False)
+graph_def.node.extend([detectionOut])
+
+for node in reversed(topNodes):
+    graph_def.node.extend([node])
+
+    if node.name.startswith('MaxPool2D'):
+        assert(node.op == 'MaxPool')
+        assert(len(cropAndResizeNodesNames) == 1)
+        node.input = [cropAndResizeNodesNames[0]]
+
+for i in reversed(range(len(graph_def.node))):
+    if graph_def.node[i].op == 'CropAndResize':
+        graph_def.node[i].input.insert(1, 'detection_out_final')
+        break
+
+graph_def.node[-1].name = 'detection_masks'
+graph_def.node[-1].op = 'Sigmoid'
+graph_def.node[-1].input.pop()
+
+def getUnconnectedNodes():
+    unconnected = [node.name for node in graph_def.node]
+    for node in graph_def.node:
+        for inp in node.input:
+            if inp in unconnected:
+                unconnected.remove(inp)
+    return unconnected
+
+while True:
+    unconnectedNodes = getUnconnectedNodes()
+    unconnectedNodes.remove(graph_def.node[-1].name)
+    if not unconnectedNodes:
+        break
+
+    for name in unconnectedNodes:
+        for i in range(len(graph_def.node)):
+            if graph_def.node[i].name == name:
+                del graph_def.node[i]
+                break
+
+# Save as text.
+graph_def.save(args.output)
diff --git a/C++/opencv-4.7.0/samples/dnn/tf_text_graph_ssd.py b/C++/opencv-4.7.0/samples/dnn/tf_text_graph_ssd.py
new file mode 100644
index 00000000..d27fd0d3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/tf_text_graph_ssd.py
@@ -0,0 +1,413 @@
+# This file is a part of OpenCV project.
+# It is a subject to the license terms in the LICENSE file found in the top-level directory
+# of this distribution and at http://opencv.org/license.html.
+#
+# Copyright (C) 2018, Intel Corporation, all rights reserved.
+# Third party copyrights are property of their respective owners.
+#
+# Use this script to get the text graph representation (.pbtxt) of SSD-based
+# deep learning network trained in TensorFlow Object Detection API.
+# Then you can import it with a binary frozen graph (.pb) using readNetFromTensorflow() function.
+# See details and examples on the following wiki page: https://github.com/opencv/opencv/wiki/TensorFlow-Object-Detection-API
+import argparse
+import re
+from math import sqrt
+from tf_text_graph_common import *
+
+class SSDAnchorGenerator:
+    def __init__(self, min_scale, max_scale, num_layers, aspect_ratios,
+                 reduce_boxes_in_lowest_layer, image_width, image_height):
+        self.min_scale = min_scale
+        self.aspect_ratios = aspect_ratios
+        self.reduce_boxes_in_lowest_layer = reduce_boxes_in_lowest_layer
+        self.image_width = image_width
+        self.image_height = image_height
+        self.scales =  [min_scale + (max_scale - min_scale) * i / (num_layers - 1)
+                            for i in range(num_layers)] + [1.0]
+
+    def get(self, layer_id):
+        if layer_id == 0 and self.reduce_boxes_in_lowest_layer:
+            widths = [0.1, self.min_scale * sqrt(2.0), self.min_scale * sqrt(0.5)]
+            heights = [0.1, self.min_scale / sqrt(2.0), self.min_scale / sqrt(0.5)]
+        else:
+            widths = [self.scales[layer_id] * sqrt(ar) for ar in self.aspect_ratios]
+            heights = [self.scales[layer_id] / sqrt(ar) for ar in self.aspect_ratios]
+
+            widths += [sqrt(self.scales[layer_id] * self.scales[layer_id + 1])]
+            heights += [sqrt(self.scales[layer_id] * self.scales[layer_id + 1])]
+        min_size = min(self.image_width, self.image_height)
+        widths = [w * min_size for w in widths]
+        heights = [h * min_size for h in heights]
+        return widths, heights
+
+
+class MultiscaleAnchorGenerator:
+    def __init__(self, min_level, aspect_ratios, scales_per_octave, anchor_scale):
+        self.min_level = min_level
+        self.aspect_ratios = aspect_ratios
+        self.anchor_scale = anchor_scale
+        self.scales = [2**(float(s) / scales_per_octave) for s in range(scales_per_octave)]
+
+    def get(self, layer_id):
+        widths = []
+        heights = []
+        for a in self.aspect_ratios:
+            for s in self.scales:
+                base_anchor_size = 2**(self.min_level + layer_id) * self.anchor_scale
+                ar = sqrt(a)
+                heights.append(base_anchor_size * s / ar)
+                widths.append(base_anchor_size * s * ar)
+        return widths, heights
+
+
+def createSSDGraph(modelPath, configPath, outputPath):
+    # Nodes that should be kept.
+    keepOps = ['Conv2D', 'BiasAdd', 'Add', 'AddV2', 'Relu', 'Relu6', 'Placeholder', 'FusedBatchNorm',
+               'DepthwiseConv2dNative', 'ConcatV2', 'Mul', 'MaxPool', 'AvgPool', 'Identity',
+               'Sub', 'ResizeNearestNeighbor', 'Pad', 'FusedBatchNormV3', 'Mean']
+
+    # Node with which prefixes should be removed
+    prefixesToRemove = ('MultipleGridAnchorGenerator/', 'Concatenate/', 'Postprocessor/', 'Preprocessor/map')
+
+    # Load a config file.
+    config = readTextMessage(configPath)
+    config = config['model'][0]['ssd'][0]
+    num_classes = int(config['num_classes'][0])
+
+    fixed_shape_resizer = config['image_resizer'][0]['fixed_shape_resizer'][0]
+    image_width = int(fixed_shape_resizer['width'][0])
+    image_height = int(fixed_shape_resizer['height'][0])
+
+    box_predictor = 'convolutional' if 'convolutional_box_predictor' in config['box_predictor'][0] else 'weight_shared_convolutional'
+
+    anchor_generator = config['anchor_generator'][0]
+    if 'ssd_anchor_generator' in anchor_generator:
+        ssd_anchor_generator = anchor_generator['ssd_anchor_generator'][0]
+        min_scale = float(ssd_anchor_generator['min_scale'][0])
+        max_scale = float(ssd_anchor_generator['max_scale'][0])
+        num_layers = int(ssd_anchor_generator['num_layers'][0])
+        aspect_ratios = [float(ar) for ar in ssd_anchor_generator['aspect_ratios']]
+        reduce_boxes_in_lowest_layer = True
+        if 'reduce_boxes_in_lowest_layer' in ssd_anchor_generator:
+            reduce_boxes_in_lowest_layer = ssd_anchor_generator['reduce_boxes_in_lowest_layer'][0] == 'true'
+        priors_generator = SSDAnchorGenerator(min_scale, max_scale, num_layers,
+                                              aspect_ratios, reduce_boxes_in_lowest_layer,
+                                              image_width, image_height)
+
+
+        print('Scale: [%f-%f]' % (min_scale, max_scale))
+        print('Aspect ratios: %s' % str(aspect_ratios))
+        print('Reduce boxes in the lowest layer: %s' % str(reduce_boxes_in_lowest_layer))
+    elif 'multiscale_anchor_generator' in anchor_generator:
+        multiscale_anchor_generator = anchor_generator['multiscale_anchor_generator'][0]
+        min_level = int(multiscale_anchor_generator['min_level'][0])
+        max_level = int(multiscale_anchor_generator['max_level'][0])
+        anchor_scale = float(multiscale_anchor_generator['anchor_scale'][0])
+        aspect_ratios = [float(ar) for ar in multiscale_anchor_generator['aspect_ratios']]
+        scales_per_octave = int(multiscale_anchor_generator['scales_per_octave'][0])
+        num_layers = max_level - min_level + 1
+        priors_generator = MultiscaleAnchorGenerator(min_level, aspect_ratios,
+                                                     scales_per_octave, anchor_scale)
+        print('Levels: [%d-%d]' % (min_level, max_level))
+        print('Anchor scale: %f' % anchor_scale)
+        print('Scales per octave: %d' % scales_per_octave)
+        print('Aspect ratios: %s' % str(aspect_ratios))
+    else:
+        print('Unknown anchor_generator')
+        exit(0)
+
+    print('Number of classes: %d' % num_classes)
+    print('Number of layers: %d' % num_layers)
+    print('box predictor: %s' % box_predictor)
+    print('Input image size: %dx%d' % (image_width, image_height))
+
+    # Read the graph.
+    outNames = ['num_detections', 'detection_scores', 'detection_boxes', 'detection_classes']
+
+    writeTextGraph(modelPath, outputPath, outNames)
+    graph_def = parseTextGraph(outputPath)
+
+    def getUnconnectedNodes():
+        unconnected = []
+        for node in graph_def.node:
+            unconnected.append(node.name)
+            for inp in node.input:
+                if inp in unconnected:
+                    unconnected.remove(inp)
+        return unconnected
+
+
+    def fuse_nodes(nodesToKeep):
+        # Detect unfused batch normalization nodes and fuse them.
+        # Add_0 <-- moving_variance, add_y
+        # Rsqrt <-- Add_0
+        # Mul_0 <-- Rsqrt, gamma
+        # Mul_1 <-- input, Mul_0
+        # Mul_2 <-- moving_mean, Mul_0
+        # Sub_0 <-- beta, Mul_2
+        # Add_1 <-- Mul_1, Sub_0
+        nodesMap = {node.name: node for node in graph_def.node}
+        subgraphBatchNorm = ['Add',
+            ['Mul', 'input', ['Mul', ['Rsqrt', ['Add', 'moving_variance', 'add_y']], 'gamma']],
+            ['Sub', 'beta', ['Mul', 'moving_mean', 'Mul_0']]]
+        subgraphBatchNormV2 = ['AddV2',
+            ['Mul', 'input', ['Mul', ['Rsqrt', ['AddV2', 'moving_variance', 'add_y']], 'gamma']],
+            ['Sub', 'beta', ['Mul', 'moving_mean', 'Mul_0']]]
+        # Detect unfused nearest neighbor resize.
+        subgraphResizeNN = ['Reshape',
+            ['Mul', ['Reshape', 'input', ['Pack', 'shape_1', 'shape_2', 'shape_3', 'shape_4', 'shape_5']],
+                    'ones'],
+            ['Pack', ['StridedSlice', ['Shape', 'input'], 'stack', 'stack_1', 'stack_2'],
+                     'out_height', 'out_width', 'out_channels']]
+        def checkSubgraph(node, targetNode, inputs, fusedNodes):
+            op = targetNode[0]
+            if node.op == op and (len(node.input) >= len(targetNode) - 1):
+                fusedNodes.append(node)
+                for i, inpOp in enumerate(targetNode[1:]):
+                    if isinstance(inpOp, list):
+                        if not node.input[i] in nodesMap or \
+                           not checkSubgraph(nodesMap[node.input[i]], inpOp, inputs, fusedNodes):
+                            return False
+                    else:
+                        inputs[inpOp] = node.input[i]
+
+                return True
+            else:
+                return False
+
+        nodesToRemove = []
+        for node in graph_def.node:
+            inputs = {}
+            fusedNodes = []
+            if checkSubgraph(node, subgraphBatchNorm, inputs, fusedNodes) or \
+               checkSubgraph(node, subgraphBatchNormV2, inputs, fusedNodes):
+                name = node.name
+                node.Clear()
+                node.name = name
+                node.op = 'FusedBatchNorm'
+                node.input.append(inputs['input'])
+                node.input.append(inputs['gamma'])
+                node.input.append(inputs['beta'])
+                node.input.append(inputs['moving_mean'])
+                node.input.append(inputs['moving_variance'])
+                node.addAttr('epsilon', 0.001)
+                nodesToRemove += fusedNodes[1:]
+
+            inputs = {}
+            fusedNodes = []
+            if checkSubgraph(node, subgraphResizeNN, inputs, fusedNodes):
+                name = node.name
+                node.Clear()
+                node.name = name
+                node.op = 'ResizeNearestNeighbor'
+                node.input.append(inputs['input'])
+                node.input.append(name + '/output_shape')
+
+                out_height_node = nodesMap[inputs['out_height']]
+                out_width_node = nodesMap[inputs['out_width']]
+                out_height = int(out_height_node.attr['value']['tensor'][0]['int_val'][0])
+                out_width = int(out_width_node.attr['value']['tensor'][0]['int_val'][0])
+
+                shapeNode = NodeDef()
+                shapeNode.name = name + '/output_shape'
+                shapeNode.op = 'Const'
+                shapeNode.addAttr('value', [out_height, out_width])
+                graph_def.node.insert(graph_def.node.index(node), shapeNode)
+                nodesToKeep.append(shapeNode.name)
+
+                nodesToRemove += fusedNodes[1:]
+        for node in nodesToRemove:
+            graph_def.node.remove(node)
+
+    nodesToKeep = []
+    fuse_nodes(nodesToKeep)
+
+    removeIdentity(graph_def)
+
+    def to_remove(name, op):
+        return (not name in nodesToKeep) and \
+               (op == 'Const' or (not op in keepOps) or name.startswith(prefixesToRemove))
+
+    removeUnusedNodesAndAttrs(to_remove, graph_def)
+
+
+    # Connect input node to the first layer
+    assert(graph_def.node[0].op == 'Placeholder')
+    try:
+        input_shape = graph_def.node[0].attr['shape']['shape'][0]['dim']
+        input_shape[1]['size'] = image_height
+        input_shape[2]['size'] = image_width
+    except:
+        print("Input shapes are undefined")
+    # assert(graph_def.node[1].op == 'Conv2D')
+    weights = graph_def.node[1].input[-1]
+    for i in range(len(graph_def.node[1].input)):
+        graph_def.node[1].input.pop()
+    graph_def.node[1].input.append(graph_def.node[0].name)
+    graph_def.node[1].input.append(weights)
+
+    # check and correct the case when preprocessing block is after input
+    preproc_id = "Preprocessor/"
+    if graph_def.node[2].name.startswith(preproc_id) and \
+        graph_def.node[2].input[0].startswith(preproc_id):
+
+        if not any(preproc_id in inp for inp in graph_def.node[3].input):
+            graph_def.node[3].input.insert(0, graph_def.node[2].name)
+
+
+    # Create SSD postprocessing head ###############################################
+
+    # Concatenate predictions of classes, predictions of bounding boxes and proposals.
+    def addConcatNode(name, inputs, axisNodeName):
+        concat = NodeDef()
+        concat.name = name
+        concat.op = 'ConcatV2'
+        for inp in inputs:
+            concat.input.append(inp)
+        concat.input.append(axisNodeName)
+        graph_def.node.extend([concat])
+
+    addConstNode('concat/axis_flatten', [-1], graph_def)
+    addConstNode('PriorBox/concat/axis', [-2], graph_def)
+
+    for label in ['ClassPredictor', 'BoxEncodingPredictor' if box_predictor == 'convolutional' else 'BoxPredictor']:
+        concatInputs = []
+        for i in range(num_layers):
+            # Flatten predictions
+            flatten = NodeDef()
+            if box_predictor == 'convolutional':
+                inpName = 'BoxPredictor_%d/%s/BiasAdd' % (i, label)
+            else:
+                if i == 0:
+                    inpName = 'WeightSharedConvolutionalBoxPredictor/%s/BiasAdd' % label
+                else:
+                    inpName = 'WeightSharedConvolutionalBoxPredictor_%d/%s/BiasAdd' % (i, label)
+            flatten.input.append(inpName)
+            flatten.name = inpName + '/Flatten'
+            flatten.op = 'Flatten'
+
+            concatInputs.append(flatten.name)
+            graph_def.node.extend([flatten])
+        addConcatNode('%s/concat' % label, concatInputs, 'concat/axis_flatten')
+
+    num_matched_layers = 0
+    for node in graph_def.node:
+        if re.match('BoxPredictor_\d/BoxEncodingPredictor/convolution', node.name) or \
+           re.match('BoxPredictor_\d/BoxEncodingPredictor/Conv2D', node.name) or \
+           re.match('WeightSharedConvolutionalBoxPredictor(_\d)*/BoxPredictor/Conv2D', node.name):
+            node.addAttr('loc_pred_transposed', True)
+            num_matched_layers += 1
+    assert(num_matched_layers == num_layers)
+
+    # Add layers that generate anchors (bounding boxes proposals).
+    priorBoxes = []
+    boxCoder = config['box_coder'][0]
+    fasterRcnnBoxCoder = boxCoder['faster_rcnn_box_coder'][0]
+    boxCoderVariance = [1.0/float(fasterRcnnBoxCoder['x_scale'][0]), 1.0/float(fasterRcnnBoxCoder['y_scale'][0]), 1.0/float(fasterRcnnBoxCoder['width_scale'][0]), 1.0/float(fasterRcnnBoxCoder['height_scale'][0])]
+    for i in range(num_layers):
+        priorBox = NodeDef()
+        priorBox.name = 'PriorBox_%d' % i
+        priorBox.op = 'PriorBox'
+        if box_predictor == 'convolutional':
+            priorBox.input.append('BoxPredictor_%d/BoxEncodingPredictor/BiasAdd' % i)
+        else:
+            if i == 0:
+                priorBox.input.append('WeightSharedConvolutionalBoxPredictor/BoxPredictor/Conv2D')
+            else:
+                priorBox.input.append('WeightSharedConvolutionalBoxPredictor_%d/BoxPredictor/BiasAdd' % i)
+        priorBox.input.append(graph_def.node[0].name)  # image_tensor
+
+        priorBox.addAttr('flip', False)
+        priorBox.addAttr('clip', False)
+
+        widths, heights = priors_generator.get(i)
+
+        priorBox.addAttr('width', widths)
+        priorBox.addAttr('height', heights)
+        priorBox.addAttr('variance', boxCoderVariance)
+
+        graph_def.node.extend([priorBox])
+        priorBoxes.append(priorBox.name)
+
+    # Compare this layer's output with Postprocessor/Reshape
+    addConcatNode('PriorBox/concat', priorBoxes, 'concat/axis_flatten')
+
+    # Sigmoid for classes predictions and DetectionOutput layer
+    addReshape('ClassPredictor/concat', 'ClassPredictor/concat3d', [0, -1, num_classes + 1], graph_def)
+
+    sigmoid = NodeDef()
+    sigmoid.name = 'ClassPredictor/concat/sigmoid'
+    sigmoid.op = 'Sigmoid'
+    sigmoid.input.append('ClassPredictor/concat3d')
+    graph_def.node.extend([sigmoid])
+
+    addFlatten(sigmoid.name, sigmoid.name + '/Flatten', graph_def)
+
+    detectionOut = NodeDef()
+    detectionOut.name = 'detection_out'
+    detectionOut.op = 'DetectionOutput'
+
+    if box_predictor == 'convolutional':
+        detectionOut.input.append('BoxEncodingPredictor/concat')
+    else:
+        detectionOut.input.append('BoxPredictor/concat')
+    detectionOut.input.append(sigmoid.name + '/Flatten')
+    detectionOut.input.append('PriorBox/concat')
+
+    detectionOut.addAttr('num_classes', num_classes + 1)
+    detectionOut.addAttr('share_location', True)
+    detectionOut.addAttr('background_label_id', 0)
+
+    postProcessing = config['post_processing'][0]
+    batchNMS = postProcessing['batch_non_max_suppression'][0]
+
+    if 'iou_threshold' in batchNMS:
+        detectionOut.addAttr('nms_threshold', float(batchNMS['iou_threshold'][0]))
+    else:
+        detectionOut.addAttr('nms_threshold', 0.6)
+
+    if 'score_threshold' in batchNMS:
+        detectionOut.addAttr('confidence_threshold', float(batchNMS['score_threshold'][0]))
+    else:
+        detectionOut.addAttr('confidence_threshold', 0.01)
+
+    if 'max_detections_per_class' in batchNMS:
+        detectionOut.addAttr('top_k', int(batchNMS['max_detections_per_class'][0]))
+    else:
+        detectionOut.addAttr('top_k', 100)
+
+    if 'max_total_detections' in batchNMS:
+        detectionOut.addAttr('keep_top_k', int(batchNMS['max_total_detections'][0]))
+    else:
+        detectionOut.addAttr('keep_top_k', 100)
+
+    detectionOut.addAttr('code_type', "CENTER_SIZE")
+
+    graph_def.node.extend([detectionOut])
+
+    while True:
+        unconnectedNodes = getUnconnectedNodes()
+        unconnectedNodes.remove(detectionOut.name)
+        if not unconnectedNodes:
+            break
+
+        for name in unconnectedNodes:
+            for i in range(len(graph_def.node)):
+                if graph_def.node[i].name == name:
+                    del graph_def.node[i]
+                    break
+
+    # Save as text.
+    graph_def.save(outputPath)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Run this script to get a text graph of '
+                                                 'SSD model from TensorFlow Object Detection API. '
+                                                 'Then pass it with .pb file to cv::dnn::readNetFromTensorflow function.')
+    parser.add_argument('--input', required=True, help='Path to frozen TensorFlow graph.')
+    parser.add_argument('--output', required=True, help='Path to output text graph.')
+    parser.add_argument('--config', required=True, help='Path to a *.config file is used for training.')
+    args = parser.parse_args()
+
+    createSSDGraph(args.input, args.config, args.output)
diff --git a/C++/opencv-4.7.0/samples/dnn/virtual_try_on.py b/C++/opencv-4.7.0/samples/dnn/virtual_try_on.py
new file mode 100644
index 00000000..e46f7ece
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/dnn/virtual_try_on.py
@@ -0,0 +1,472 @@
+#!/usr/bin/env python3
+'''
+You can download the Geometric Matching Module model from https://www.dropbox.com/s/tyhc73xa051grjp/cp_vton_gmm.onnx?dl=0
+You can download the Try-On Module model from https://www.dropbox.com/s/q2x97ve2h53j66k/cp_vton_tom.onnx?dl=0
+You can download the cloth segmentation model from https://www.dropbox.com/s/qag9vzambhhkvxr/lip_jppnet_384.pb?dl=0
+You can find the OpenPose proto in opencv_extra/testdata/dnn/openpose_pose_coco.prototxt
+and get .caffemodel using opencv_extra/testdata/dnn/download_models.py
+'''
+
+import argparse
+import os.path
+import numpy as np
+import cv2 as cv
+
+from numpy import linalg
+from common import findFile
+from human_parsing import parse_human
+
+backends = (cv.dnn.DNN_BACKEND_DEFAULT, cv.dnn.DNN_BACKEND_HALIDE, cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_BACKEND_OPENCV,
+            cv.dnn.DNN_BACKEND_VKCOM, cv.dnn.DNN_BACKEND_CUDA)
+targets = (cv.dnn.DNN_TARGET_CPU, cv.dnn.DNN_TARGET_OPENCL, cv.dnn.DNN_TARGET_OPENCL_FP16, cv.dnn.DNN_TARGET_MYRIAD, cv.dnn.DNN_TARGET_HDDL,
+           cv.dnn.DNN_TARGET_VULKAN, cv.dnn.DNN_TARGET_CUDA, cv.dnn.DNN_TARGET_CUDA_FP16)
+
+parser = argparse.ArgumentParser(description='Use this script to run virtial try-on using CP-VTON',
+                                 formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+parser.add_argument('--input_image', '-i', required=True, help='Path to image with person.')
+parser.add_argument('--input_cloth', '-c', required=True, help='Path to target cloth image')
+parser.add_argument('--gmm_model', '-gmm', default='cp_vton_gmm.onnx', help='Path to Geometric Matching Module .onnx model.')
+parser.add_argument('--tom_model', '-tom', default='cp_vton_tom.onnx', help='Path to Try-On Module .onnx model.')
+parser.add_argument('--segmentation_model', default='lip_jppnet_384.pb', help='Path to cloth segmentation .pb model.')
+parser.add_argument('--openpose_proto', default='openpose_pose_coco.prototxt', help='Path to OpenPose .prototxt model was trained on COCO dataset.')
+parser.add_argument('--openpose_model', default='openpose_pose_coco.caffemodel', help='Path to OpenPose .caffemodel model was trained on COCO dataset.')
+parser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,
+                    help="Choose one of computation backends: "
+                            "%d: automatically (by default), "
+                            "%d: Halide language (http://halide-lang.org/), "
+                            "%d: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), "
+                            "%d: OpenCV implementation, "
+                            "%d: VKCOM, "
+                            "%d: CUDA" % backends)
+parser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,
+                    help='Choose one of target computation devices: '
+                            '%d: CPU target (by default), '
+                            '%d: OpenCL, '
+                            '%d: OpenCL fp16 (half-float precision), '
+                            '%d: NCS2 VPU, '
+                            '%d: HDDL VPU, '
+                            '%d: Vulkan, '
+                            '%d: CUDA, '
+                            '%d: CUDA fp16 (half-float preprocess)'% targets)
+args, _ = parser.parse_known_args()
+
+
+def get_pose_map(image, proto_path, model_path, backend, target, height=256, width=192):
+    radius = 5
+    inp = cv.dnn.blobFromImage(image, 1.0 / 255, (width, height))
+
+    net = cv.dnn.readNet(proto_path, model_path)
+    net.setPreferableBackend(backend)
+    net.setPreferableTarget(target)
+    net.setInput(inp)
+    out = net.forward()
+
+    threshold = 0.1
+    _, out_c, out_h, out_w = out.shape
+    pose_map = np.zeros((height, width, out_c - 1))
+    # last label: Background
+    for i in range(0, out.shape[1] - 1):
+        heatMap = out[0, i, :, :]
+        keypoint = np.full((height, width), -1)
+        _, conf, _, point = cv.minMaxLoc(heatMap)
+        x = width * point[0] // out_w
+        y = height * point[1] // out_h
+        if conf > threshold and x > 0 and y > 0:
+            keypoint[y - radius:y + radius, x - radius:x + radius] = 1
+        pose_map[:, :, i] = keypoint
+
+    pose_map = pose_map.transpose(2, 0, 1)
+    return pose_map
+
+
+class BilinearFilter(object):
+    """
+    PIL bilinear resize implementation
+    image = image.resize((image_width // 16, image_height // 16), Image.BILINEAR)
+    """
+    def _precompute_coeffs(self, inSize, outSize):
+        filterscale = max(1.0, inSize / outSize)
+        ksize = int(np.ceil(filterscale)) * 2 + 1
+
+        kk = np.zeros(shape=(outSize * ksize, ), dtype=np.float32)
+        bounds = np.empty(shape=(outSize * 2, ), dtype=np.int32)
+
+        centers = (np.arange(outSize) + 0.5) * filterscale + 0.5
+        bounds[::2] = np.where(centers - filterscale < 0, 0, centers - filterscale)
+        bounds[1::2] = np.where(centers + filterscale > inSize, inSize, centers + filterscale) - bounds[::2]
+        xmins = bounds[::2] - centers + 1
+
+        points = np.array([np.arange(row) + xmins[i] for i, row in enumerate(bounds[1::2])]) / filterscale
+        for xx in range(0, outSize):
+            point = points[xx]
+            bilinear = np.where(point < 1.0, 1.0 - abs(point), 0.0)
+            ww = np.sum(bilinear)
+            kk[xx * ksize : xx * ksize + bilinear.size] = np.where(ww == 0.0, bilinear, bilinear / ww)
+        return bounds, kk, ksize
+
+    def _resample_horizontal(self, out, img, ksize, bounds, kk):
+        for yy in range(0, out.shape[0]):
+            for xx in range(0, out.shape[1]):
+                xmin = bounds[xx * 2 + 0]
+                xmax = bounds[xx * 2 + 1]
+                k = kk[xx * ksize : xx * ksize + xmax]
+                out[yy, xx] = np.round(np.sum(img[yy, xmin : xmin + xmax] * k))
+
+    def _resample_vertical(self, out, img, ksize, bounds, kk):
+        for yy in range(0, out.shape[0]):
+            ymin = bounds[yy * 2 + 0]
+            ymax = bounds[yy * 2 + 1]
+            k = kk[yy * ksize: yy * ksize + ymax]
+            out[yy] = np.round(np.sum(img[ymin : ymin + ymax, 0:out.shape[1]] * k[:, np.newaxis], axis=0))
+
+    def imaging_resample(self, img, xsize, ysize):
+        height, width = img.shape[0:2]
+        bounds_horiz, kk_horiz, ksize_horiz = self._precompute_coeffs(width, xsize)
+        bounds_vert, kk_vert, ksize_vert    = self._precompute_coeffs(height, ysize)
+
+        out_hor = np.empty((img.shape[0], xsize), dtype=np.uint8)
+        self._resample_horizontal(out_hor, img, ksize_horiz, bounds_horiz, kk_horiz)
+        out = np.empty((ysize, xsize), dtype=np.uint8)
+        self._resample_vertical(out, out_hor, ksize_vert, bounds_vert, kk_vert)
+        return out
+
+
+class CpVton(object):
+    def __init__(self, gmm_model, tom_model, backend, target):
+        super(CpVton, self).__init__()
+        self.gmm_net = cv.dnn.readNet(gmm_model)
+        self.tom_net = cv.dnn.readNet(tom_model)
+        self.gmm_net.setPreferableBackend(backend)
+        self.gmm_net.setPreferableTarget(target)
+        self.tom_net.setPreferableBackend(backend)
+        self.tom_net.setPreferableTarget(target)
+
+    def prepare_agnostic(self, segm_image, input_image, pose_map, height=256, width=192):
+        palette = {
+            'Background'   : (0, 0, 0),
+            'Hat'          : (128, 0, 0),
+            'Hair'         : (255, 0, 0),
+            'Glove'        : (0, 85, 0),
+            'Sunglasses'   : (170, 0, 51),
+            'UpperClothes' : (255, 85, 0),
+            'Dress'        : (0, 0, 85),
+            'Coat'         : (0, 119, 221),
+            'Socks'        : (85, 85, 0),
+            'Pants'        : (0, 85, 85),
+            'Jumpsuits'    : (85, 51, 0),
+            'Scarf'        : (52, 86, 128),
+            'Skirt'        : (0, 128, 0),
+            'Face'         : (0, 0, 255),
+            'Left-arm'     : (51, 170, 221),
+            'Right-arm'    : (0, 255, 255),
+            'Left-leg'     : (85, 255, 170),
+            'Right-leg'    : (170, 255, 85),
+            'Left-shoe'    : (255, 255, 0),
+            'Right-shoe'   : (255, 170, 0)
+        }
+        color2label = {val: key for key, val in palette.items()}
+        head_labels = ['Hat', 'Hair', 'Sunglasses', 'Face', 'Pants', 'Skirt']
+
+        segm_image = cv.cvtColor(segm_image, cv.COLOR_BGR2RGB)
+        phead = np.zeros((1, height, width), dtype=np.float32)
+        pose_shape = np.zeros((height, width), dtype=np.uint8)
+        for r in range(height):
+            for c in range(width):
+                pixel = tuple(segm_image[r, c])
+                if tuple(pixel) in color2label:
+                    if color2label[pixel] in head_labels:
+                        phead[0, r, c] = 1
+                    if color2label[pixel] != 'Background':
+                        pose_shape[r, c] = 255
+
+        input_image = cv.dnn.blobFromImage(input_image, 1.0 / 127.5, (width, height), mean=(127.5, 127.5, 127.5), swapRB=True)
+        input_image = input_image.squeeze(0)
+
+        img_head = input_image * phead - (1 - phead)
+
+        downsample = BilinearFilter()
+        down = downsample.imaging_resample(pose_shape, width // 16, height // 16)
+        res_shape = cv.resize(down, (width, height), cv.INTER_LINEAR)
+
+        res_shape = cv.dnn.blobFromImage(res_shape, 1.0 / 127.5, mean=(127.5, 127.5, 127.5), swapRB=True)
+        res_shape = res_shape.squeeze(0)
+
+        agnostic = np.concatenate((res_shape, img_head, pose_map), axis=0)
+        agnostic = np.expand_dims(agnostic, axis=0)
+        return agnostic.astype(np.float32)
+
+    def get_warped_cloth(self, cloth_img, agnostic, height=256, width=192):
+        cloth = cv.dnn.blobFromImage(cloth_img, 1.0 / 127.5, (width, height), mean=(127.5, 127.5, 127.5), swapRB=True)
+
+        self.gmm_net.setInput(agnostic, "input.1")
+        self.gmm_net.setInput(cloth, "input.18")
+        theta = self.gmm_net.forward()
+
+        grid = self._generate_grid(theta)
+        warped_cloth = self._bilinear_sampler(cloth, grid).astype(np.float32)
+        return warped_cloth
+
+    def get_tryon(self, agnostic, warp_cloth):
+        inp = np.concatenate([agnostic, warp_cloth], axis=1)
+        self.tom_net.setInput(inp)
+        out = self.tom_net.forward()
+
+        p_rendered, m_composite = np.split(out, [3], axis=1)
+        p_rendered = np.tanh(p_rendered)
+        m_composite = 1 / (1 + np.exp(-m_composite))
+
+        p_tryon = warp_cloth * m_composite + p_rendered * (1 - m_composite)
+        rgb_p_tryon = cv.cvtColor(p_tryon.squeeze(0).transpose(1, 2, 0), cv.COLOR_BGR2RGB)
+        rgb_p_tryon = (rgb_p_tryon + 1) / 2
+        return rgb_p_tryon
+
+    def _compute_L_inverse(self, X, Y):
+        N = X.shape[0]
+
+        Xmat = np.tile(X, (1, N))
+        Ymat = np.tile(Y, (1, N))
+        P_dist_squared = np.power(Xmat - Xmat.transpose(1, 0), 2) + np.power(Ymat - Ymat.transpose(1, 0), 2)
+
+        P_dist_squared[P_dist_squared == 0] = 1
+        K = np.multiply(P_dist_squared, np.log(P_dist_squared))
+
+        O = np.ones([N, 1], dtype=np.float32)
+        Z = np.zeros([3, 3], dtype=np.float32)
+        P = np.concatenate([O, X, Y], axis=1)
+        first = np.concatenate((K, P), axis=1)
+        second = np.concatenate((P.transpose(1, 0), Z), axis=1)
+        L = np.concatenate((first, second), axis=0)
+        Li = linalg.inv(L)
+        return Li
+
+    def _prepare_to_transform(self, out_h=256, out_w=192, grid_size=5):
+        grid_X, grid_Y = np.meshgrid(np.linspace(-1, 1, out_w), np.linspace(-1, 1, out_h))
+        grid_X = np.expand_dims(np.expand_dims(grid_X, axis=0), axis=3)
+        grid_Y = np.expand_dims(np.expand_dims(grid_Y, axis=0), axis=3)
+
+        axis_coords = np.linspace(-1, 1, grid_size)
+        N = grid_size ** 2
+        P_Y, P_X = np.meshgrid(axis_coords, axis_coords)
+
+        P_X = np.reshape(P_X,(-1, 1))
+        P_Y = np.reshape(P_Y,(-1, 1))
+
+        P_X = np.expand_dims(np.expand_dims(np.expand_dims(P_X, axis=2), axis=3), axis=4).transpose(4, 1, 2, 3, 0)
+        P_Y = np.expand_dims(np.expand_dims(np.expand_dims(P_Y, axis=2), axis=3), axis=4).transpose(4, 1, 2, 3, 0)
+        return grid_X, grid_Y, N, P_X, P_Y
+
+    def _expand_torch(self, X, shape):
+        if len(X.shape) != len(shape):
+            return X.flatten().reshape(shape)
+        else:
+            axis = [1 if src == dst else dst for src, dst in zip(X.shape, shape)]
+            return np.tile(X, axis)
+
+    def _apply_transformation(self, theta, points, N, P_X, P_Y):
+        if len(theta.shape) == 2:
+            theta = np.expand_dims(np.expand_dims(theta, axis=2), axis=3)
+
+        batch_size = theta.shape[0]
+
+        P_X_base = np.copy(P_X)
+        P_Y_base = np.copy(P_Y)
+
+        Li = self._compute_L_inverse(np.reshape(P_X, (N, -1)), np.reshape(P_Y, (N, -1)))
+        Li = np.expand_dims(Li, axis=0)
+
+        # split theta into point coordinates
+        Q_X = np.squeeze(theta[:, :N, :, :], axis=3)
+        Q_Y = np.squeeze(theta[:, N:, :, :], axis=3)
+
+        Q_X += self._expand_torch(P_X_base, Q_X.shape)
+        Q_Y += self._expand_torch(P_Y_base, Q_Y.shape)
+
+        points_b = points.shape[0]
+        points_h = points.shape[1]
+        points_w = points.shape[2]
+
+        P_X = self._expand_torch(P_X, (1, points_h, points_w, 1, N))
+        P_Y = self._expand_torch(P_Y, (1, points_h, points_w, 1, N))
+
+        W_X = self._expand_torch(Li[:,:N,:N], (batch_size, N, N)) @ Q_X
+        W_Y = self._expand_torch(Li[:,:N,:N], (batch_size, N, N)) @ Q_Y
+
+        W_X = np.expand_dims(np.expand_dims(W_X, axis=3), axis=4).transpose(0, 4, 2, 3, 1)
+        W_X = np.repeat(W_X, points_h, axis=1)
+        W_X = np.repeat(W_X, points_w, axis=2)
+
+        W_Y = np.expand_dims(np.expand_dims(W_Y, axis=3), axis=4).transpose(0, 4, 2, 3, 1)
+        W_Y = np.repeat(W_Y, points_h, axis=1)
+        W_Y = np.repeat(W_Y, points_w, axis=2)
+
+        A_X = self._expand_torch(Li[:, N:, :N], (batch_size, 3, N)) @ Q_X
+        A_Y = self._expand_torch(Li[:, N:, :N], (batch_size, 3, N)) @ Q_Y
+
+        A_X = np.expand_dims(np.expand_dims(A_X, axis=3), axis=4).transpose(0, 4, 2, 3, 1)
+        A_X = np.repeat(A_X, points_h, axis=1)
+        A_X = np.repeat(A_X, points_w, axis=2)
+
+        A_Y = np.expand_dims(np.expand_dims(A_Y, axis=3), axis=4).transpose(0, 4, 2, 3, 1)
+        A_Y = np.repeat(A_Y, points_h, axis=1)
+        A_Y = np.repeat(A_Y, points_w, axis=2)
+
+        points_X_for_summation = np.expand_dims(np.expand_dims(points[:, :, :, 0], axis=3), axis=4)
+        points_X_for_summation = self._expand_torch(points_X_for_summation, points[:, :, :, 0].shape + (1, N))
+
+        points_Y_for_summation = np.expand_dims(np.expand_dims(points[:, :, :, 1], axis=3), axis=4)
+        points_Y_for_summation = self._expand_torch(points_Y_for_summation, points[:, :, :, 0].shape + (1, N))
+
+        if points_b == 1:
+            delta_X = points_X_for_summation - P_X
+            delta_Y = points_Y_for_summation - P_Y
+        else:
+            delta_X = points_X_for_summation - self._expand_torch(P_X, points_X_for_summation.shape)
+            delta_Y = points_Y_for_summation - self._expand_torch(P_Y, points_Y_for_summation.shape)
+
+        dist_squared = np.power(delta_X, 2) + np.power(delta_Y, 2)
+        dist_squared[dist_squared == 0] = 1
+        U = np.multiply(dist_squared, np.log(dist_squared))
+
+        points_X_batch = np.expand_dims(points[:,:,:,0], axis=3)
+        points_Y_batch = np.expand_dims(points[:,:,:,1], axis=3)
+
+        if points_b == 1:
+            points_X_batch = self._expand_torch(points_X_batch, (batch_size, ) + points_X_batch.shape[1:])
+            points_Y_batch = self._expand_torch(points_Y_batch, (batch_size, ) + points_Y_batch.shape[1:])
+
+        points_X_prime = A_X[:,:,:,:,0]+ \
+                        np.multiply(A_X[:,:,:,:,1], points_X_batch) + \
+                        np.multiply(A_X[:,:,:,:,2], points_Y_batch) + \
+                        np.sum(np.multiply(W_X, self._expand_torch(U, W_X.shape)), 4)
+
+        points_Y_prime = A_Y[:,:,:,:,0]+ \
+                        np.multiply(A_Y[:,:,:,:,1], points_X_batch) + \
+                        np.multiply(A_Y[:,:,:,:,2], points_Y_batch) + \
+                        np.sum(np.multiply(W_Y, self._expand_torch(U, W_Y.shape)), 4)
+
+        return np.concatenate((points_X_prime, points_Y_prime), 3)
+
+    def _generate_grid(self, theta):
+        grid_X, grid_Y, N, P_X, P_Y = self._prepare_to_transform()
+        warped_grid = self._apply_transformation(theta, np.concatenate((grid_X, grid_Y), axis=3), N, P_X, P_Y)
+        return warped_grid
+
+    def _bilinear_sampler(self, img, grid):
+        x, y = grid[:,:,:,0], grid[:,:,:,1]
+
+        H = img.shape[2]
+        W = img.shape[3]
+        max_y = H - 1
+        max_x = W - 1
+
+        # rescale x and y to [0, W-1/H-1]
+        x = 0.5 * (x + 1.0) * (max_x - 1)
+        y = 0.5 * (y + 1.0) * (max_y - 1)
+
+        # grab 4 nearest corner points for each (x_i, y_i)
+        x0 = np.floor(x).astype(int)
+        x1 = x0 + 1
+        y0 = np.floor(y).astype(int)
+        y1 = y0 + 1
+
+        # calculate deltas
+        wa = (x1 - x) * (y1 - y)
+        wb = (x1 - x) * (y  - y0)
+        wc = (x - x0) * (y1 - y)
+        wd = (x - x0) * (y  - y0)
+
+        # clip to range [0, H-1/W-1] to not violate img boundaries
+        x0 = np.clip(x0, 0, max_x)
+        x1 = np.clip(x1, 0, max_x)
+        y0 = np.clip(y0, 0, max_y)
+        y1 = np.clip(y1, 0, max_y)
+
+        # get pixel value at corner coords
+        img = img.reshape(-1, H, W)
+        Ia = img[:, y0, x0].swapaxes(0, 1)
+        Ib = img[:, y1, x0].swapaxes(0, 1)
+        Ic = img[:, y0, x1].swapaxes(0, 1)
+        Id = img[:, y1, x1].swapaxes(0, 1)
+
+        wa = np.expand_dims(wa, axis=0)
+        wb = np.expand_dims(wb, axis=0)
+        wc = np.expand_dims(wc, axis=0)
+        wd = np.expand_dims(wd, axis=0)
+
+        # compute output
+        out = wa*Ia + wb*Ib + wc*Ic + wd*Id
+        return out
+
+
+class CorrelationLayer(object):
+    def __init__(self, params, blobs):
+        super(CorrelationLayer, self).__init__()
+
+    def getMemoryShapes(self, inputs):
+        fetureAShape = inputs[0]
+        b, _, h, w = fetureAShape
+        return [[b, h * w, h, w]]
+
+    def forward(self, inputs):
+        feature_A, feature_B = inputs
+        b, c, h, w = feature_A.shape
+        feature_A = feature_A.transpose(0, 1, 3, 2)
+        feature_A = np.reshape(feature_A, (b, c, h * w))
+        feature_B = np.reshape(feature_B, (b, c, h * w))
+        feature_B = feature_B.transpose(0, 2, 1)
+        feature_mul = feature_B @ feature_A
+        feature_mul= np.reshape(feature_mul, (b, h, w, h * w))
+        feature_mul = feature_mul.transpose(0, 1, 3, 2)
+        correlation_tensor = feature_mul.transpose(0, 2, 1, 3)
+        correlation_tensor = np.ascontiguousarray(correlation_tensor)
+        return [correlation_tensor]
+
+
+if __name__ == "__main__":
+    if not os.path.isfile(args.gmm_model):
+        raise OSError("GMM model not exist")
+    if not os.path.isfile(args.tom_model):
+        raise OSError("TOM model not exist")
+    if not os.path.isfile(args.segmentation_model):
+        raise OSError("Segmentation model not exist")
+    if not os.path.isfile(findFile(args.openpose_proto)):
+        raise OSError("OpenPose proto not exist")
+    if not os.path.isfile(findFile(args.openpose_model)):
+        raise OSError("OpenPose model not exist")
+
+    person_img = cv.imread(args.input_image)
+    ratio = 256 / 192
+    inp_h, inp_w, _ = person_img.shape
+    current_ratio = inp_h / inp_w
+    if current_ratio > ratio:
+        center_h = inp_h // 2
+        out_h = inp_w * ratio
+        start = int(center_h - out_h // 2)
+        end = int(center_h + out_h // 2)
+        person_img = person_img[start:end, ...]
+    else:
+        center_w = inp_w // 2
+        out_w = inp_h / ratio
+        start = int(center_w - out_w // 2)
+        end = int(center_w + out_w // 2)
+        person_img = person_img[:, start:end, :]
+
+    cloth_img = cv.imread(args.input_cloth)
+    pose = get_pose_map(person_img, findFile(args.openpose_proto),
+                        findFile(args.openpose_model), args.backend, args.target)
+    segm_image = parse_human(person_img, args.segmentation_model)
+    segm_image = cv.resize(segm_image, (192, 256), cv.INTER_LINEAR)
+
+    cv.dnn_registerLayer('Correlation', CorrelationLayer)
+
+    model = CpVton(args.gmm_model, args.tom_model, args.backend, args.target)
+    agnostic = model.prepare_agnostic(segm_image, person_img, pose)
+    warped_cloth = model.get_warped_cloth(cloth_img, agnostic)
+    output = model.get_tryon(agnostic, warped_cloth)
+
+    cv.dnn_unregisterLayer('Correlation')
+
+    winName = 'Virtual Try-On'
+    cv.namedWindow(winName, cv.WINDOW_AUTOSIZE)
+    cv.imshow(winName, output)
+    cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/gdb/gdbinit b/C++/opencv-4.7.0/samples/gdb/gdbinit
new file mode 100644
index 00000000..228e8f70
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gdb/gdbinit
@@ -0,0 +1,23 @@
+set auto-load local-gdbinit on
+set print elements 0
+add-auto-load-safe-path /
+
+python
+# Update GDB's Python paths with the `sys.path` values of the local
+#  Python installation, whether that is brew'ed Python, a virtualenv,
+#  or another system python.
+
+# Convert GDB to interpret in Python
+
+import os, subprocess, sys
+
+# Execute a Python using the user's shell and pull out the sys.path (for site-packages)
+paths = subprocess.check_output('/usr/bin/python3 -c "import os,sys;print(os.linesep.join(sys.path).strip())"',shell=True).decode("utf-8").split()
+
+# Extend GDB's Python's search path
+sys.path.extend(paths)
+
+end
+
+
+source /your/path/to/mat_pretty_printer.py
diff --git a/C++/opencv-4.7.0/samples/gdb/mat_pretty_printer.py b/C++/opencv-4.7.0/samples/gdb/mat_pretty_printer.py
new file mode 100644
index 00000000..54afd5e1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gdb/mat_pretty_printer.py
@@ -0,0 +1,222 @@
+import gdb
+import numpy as np
+from enum import Enum
+
+np.set_printoptions(suppress=True)  # prevent numpy exponential notation on print, default False
+# np.set_printoptions(threshold=sys.maxsize)
+
+
+def conv(obj, t):
+    return gdb.parse_and_eval(f'({t})({obj})')
+
+
+def booli(obj):
+    return conv(str(obj).lower(), 'bool')
+
+
+def stri(obj):
+    s = f'"{obj}"'
+    return conv(s.translate(s.maketrans('\n', ' ')), 'char*')
+
+
+class MagicValues(Enum):
+    MAGIC_VAL = 0x42FF0000
+    AUTO_STEP = 0
+    CONTINUOUS_FLAG = 1 << 14
+    SUBMATRIX_FLAG = 1 << 15
+
+
+class MagicMasks(Enum):
+    MAGIC_MASK = 0xFFFF0000
+    TYPE_MASK = 0x00000FFF
+    DEPTH_MASK = 7
+
+
+class Depth(Enum):
+    CV_8U = 0
+    CV_8S = 1
+    CV_16U = 2
+    CV_16S = 3
+    CV_32S = 4
+    CV_32F = 5
+    CV_64F = 6
+    CV_16F = 7
+
+
+def create_enum(n):
+    def make_type(depth, cn):
+        return depth.value + ((cn - 1) << 3)
+    defs = [(f'{depth.name}C{i}', make_type(depth, i)) for depth in Depth for i in range(1, n + 1)]
+    return Enum('Type', defs)
+
+
+Type = create_enum(512)
+
+
+class Flags:
+    def depth(self):
+        return Depth(self.flags & MagicMasks.DEPTH_MASK.value)
+
+    def dtype(self):
+        depth = self.depth()
+        ret = None
+
+        if depth == Depth.CV_8U:
+            ret = (np.uint8, 'uint8_t')
+        elif depth == Depth.CV_8S:
+            ret = (np.int8, 'int8_t')
+        elif depth == Depth.CV_16U:
+            ret = (np.uint16, 'uint16_t')
+        elif depth == Depth.CV_16S:
+            ret = (np.int16, 'int16_t')
+        elif depth == Depth.CV_32S:
+            ret = (np.int32, 'int32_t')
+        elif depth == Depth.CV_32F:
+            ret = (np.float32, 'float')
+        elif depth == Depth.CV_64F:
+            ret = (np.float64, 'double')
+        elif depth == Depth.CV_16F:
+            ret = (np.float16, 'float16')
+
+        return ret
+
+    def type(self):
+        return Type(self.flags & MagicMasks.TYPE_MASK.value)
+
+    def channels(self):
+        return ((self.flags & (511 << 3)) >> 3) + 1
+
+    def is_continuous(self):
+        return (self.flags & MagicValues.CONTINUOUS_FLAG.value) != 0
+
+    def is_submatrix(self):
+        return (self.flags & MagicValues.SUBMATRIX_FLAG.value) != 0
+
+    def __init__(self, flags):
+        self.flags = flags
+
+    def __iter__(self):
+        return iter({
+                        'type': stri(self.type().name),
+                        'is_continuous': booli(self.is_continuous()),
+                        'is_submatrix': booli(self.is_submatrix())
+                    }.items())
+
+
+class Size:
+    def __init__(self, ptr):
+        self.ptr = ptr
+
+    def dims(self):
+        return int((self.ptr - 1).dereference())
+
+    def to_numpy(self):
+        return np.array([int(self.ptr[i]) for i in range(self.dims())], dtype=np.int64)
+
+    def __iter__(self):
+        return iter({'size': stri(self.to_numpy())}.items())
+
+
+class Mat:
+    def __init__(self, m, size, flags):
+        (dtype, ctype) = flags.dtype()
+        elsize = np.dtype(dtype).itemsize
+
+        shape = size.to_numpy()
+        steps = np.asarray([int(m['step']['p'][i]) for i in range(len(shape))], dtype=np.int64)
+
+        ptr = m['data']
+        # either we are default-constructed or sizes are zero
+        if int(ptr) == 0 or np.prod(shape * steps) == 0:
+            self.mat = np.array([])
+            self.view = self.mat
+            return
+
+        # we don't want to show excess brackets
+        if flags.channels() != 1:
+            shape = np.append(shape, flags.channels())
+            steps = np.append(steps, elsize)
+
+        # get the length of contiguous array from data to the last element of the matrix
+        length = 1 + np.sum((shape - 1) * steps) // elsize
+
+        if dtype != np.float16:
+            # read all elements into self.mat
+            ctype = gdb.lookup_type(ctype)
+            ptr = ptr.cast(ctype.array(length - 1).pointer()).dereference()
+            self.mat = np.array([ptr[i] for i in range(length)], dtype=dtype)
+        else:
+            # read as uint16_t and then reinterpret the bytes as float16
+            u16 = gdb.lookup_type('uint16_t')
+            ptr = ptr.cast(u16.array(length - 1).pointer()).dereference()
+            self.mat = np.array([ptr[i] for i in range(length)], dtype=np.uint16)
+            self.mat = self.mat.view(np.float16)
+
+        # numpy will do the heavy lifting of strided access
+        self.view = np.lib.stride_tricks.as_strided(self.mat, shape=shape, strides=steps)
+
+    def __iter__(self):
+        return iter({'data': stri(self.view)}.items())
+
+
+class MatPrinter:
+    """Print a cv::Mat"""
+
+    def __init__(self, mat):
+        self.mat = mat
+
+    def views(self):
+        m = self.mat
+
+        flags = Flags(int(m['flags']))
+        size = Size(m['size']['p'])
+        data = Mat(m, size, flags)
+
+        for x in [flags, size, data]:
+            for k, v in x:
+                yield 'view_' + k, v
+
+    def real(self):
+        m = self.mat
+
+        for field in m.type.fields():
+            k = field.name
+            v = m[k]
+            yield k, v
+
+        # TODO: add an enum in interface.h with all cv::Mat element types and use that instead
+        # yield 'test', gdb.parse_and_eval(f'(cv::MatTypes)0')
+
+    def children(self):  # TODO: hide real members under new child somehow
+        yield from self.views()
+        yield from self.real()
+
+
+def get_type(val):
+    # Get the type.
+    vtype = val.type
+
+    # If it points to a reference, get the reference.
+    if vtype.code == gdb.TYPE_CODE_REF:
+        vtype = vtype.target()
+
+    # Get the unqualified type, stripped of typedefs.
+    vtype = vtype.unqualified().strip_typedefs()
+
+    # Get the type name.
+    typename = vtype.tag
+
+    return typename
+
+
+def mat_printer(val):
+    typename = get_type(val)
+
+    if typename is None:
+        return None
+
+    if str(typename) == 'cv::Mat':
+        return MatPrinter(val)
+
+
+gdb.pretty_printers.append(mat_printer)
diff --git a/C++/opencv-4.7.0/samples/gpu/CMakeLists.txt b/C++/opencv-4.7.0/samples/gpu/CMakeLists.txt
new file mode 100644
index 00000000..eeab50a9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/CMakeLists.txt
@@ -0,0 +1,61 @@
+ocv_install_example_src(gpu *.cpp *.hpp CMakeLists.txt)
+
+set(OPENCV_CUDA_SAMPLES_REQUIRED_DEPS
+  opencv_core
+  opencv_flann
+  opencv_imgproc
+  opencv_imgcodecs
+  opencv_videoio
+  opencv_highgui
+  opencv_ml
+  opencv_video
+  opencv_objdetect
+  opencv_features2d
+  opencv_calib3d
+  opencv_superres
+  opencv_cudaarithm
+  opencv_cudafilters
+  opencv_cudawarping
+  opencv_cudaimgproc
+  opencv_cudafeatures2d
+  opencv_cudaoptflow
+  opencv_cudabgsegm
+  opencv_cudastereo
+  opencv_cudaobjdetect)
+ocv_check_dependencies(${OPENCV_CUDA_SAMPLES_REQUIRED_DEPS})
+
+if(NOT BUILD_EXAMPLES OR NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+project(gpu_samples)
+if(HAVE_CUDA OR CUDA_FOUND)
+  add_definitions(-DHAVE_CUDA=1)
+endif()
+if(COMMAND ocv_warnings_disable)
+  ocv_warnings_disable(CMAKE_CXX_FLAGS -Wsuggest-override -Winconsistent-missing-override)
+endif()
+ocv_include_modules_recurse(${OPENCV_CUDA_SAMPLES_REQUIRED_DEPS})
+if(HAVE_opencv_xfeatures2d)
+  ocv_include_modules_recurse(opencv_xfeatures2d)
+endif()
+if(HAVE_opencv_cudacodec)
+  ocv_include_modules_recurse(opencv_cudacodec)
+endif()
+if(HAVE_CUDA)
+  ocv_include_directories(${CUDA_INCLUDE_DIRS})
+endif()
+if((CV_GCC OR CV_CLANG) AND NOT ENABLE_NOISY_WARNINGS)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function")
+endif()
+file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+foreach(sample_filename ${all_samples})
+  ocv_define_sample(tgt ${sample_filename} gpu)
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_CUDA_SAMPLES_REQUIRED_DEPS})
+  if(HAVE_opencv_xfeatures2d)
+    ocv_target_link_libraries(${tgt} PRIVATE opencv_xfeatures2d)
+  endif()
+  if(HAVE_opencv_cudacodec)
+    ocv_target_link_libraries(${tgt} PRIVATE opencv_cudacodec)
+  endif()
+endforeach()
diff --git a/C++/opencv-4.7.0/samples/gpu/alpha_comp.cpp b/C++/opencv-4.7.0/samples/gpu/alpha_comp.cpp
new file mode 100644
index 00000000..3f7966de
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/alpha_comp.cpp
@@ -0,0 +1,68 @@
+#include <iostream>
+
+#include "opencv2/core/opengl.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/cudaimgproc.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::cuda;
+
+int main()
+{
+    cout << "This program demonstrates using alphaComp" << endl;
+    cout << "Press SPACE to change compositing operation" << endl;
+    cout << "Press ESC to exit" << endl;
+
+    namedWindow("First Image", WINDOW_NORMAL);
+    namedWindow("Second Image", WINDOW_NORMAL);
+    namedWindow("Result", WINDOW_OPENGL);
+
+    setGlDevice();
+
+    Mat src1(640, 480, CV_8UC4, Scalar::all(0));
+    Mat src2(640, 480, CV_8UC4, Scalar::all(0));
+
+    rectangle(src1, Rect(50, 50, 200, 200), Scalar(0, 0, 255, 128), 30);
+    rectangle(src2, Rect(100, 100, 200, 200), Scalar(255, 0, 0, 128), 30);
+
+    GpuMat d_src1(src1);
+    GpuMat d_src2(src2);
+
+    GpuMat d_res;
+
+    imshow("First Image", src1);
+    imshow("Second Image", src2);
+
+    int alpha_op = ALPHA_OVER;
+
+    const char* op_names[] =
+    {
+        "ALPHA_OVER", "ALPHA_IN", "ALPHA_OUT", "ALPHA_ATOP", "ALPHA_XOR", "ALPHA_PLUS", "ALPHA_OVER_PREMUL", "ALPHA_IN_PREMUL", "ALPHA_OUT_PREMUL",
+        "ALPHA_ATOP_PREMUL", "ALPHA_XOR_PREMUL", "ALPHA_PLUS_PREMUL", "ALPHA_PREMUL"
+    };
+
+    for(;;)
+    {
+        cout << op_names[alpha_op] << endl;
+
+        alphaComp(d_src1, d_src2, d_res, alpha_op);
+
+        imshow("Result", d_res);
+
+        char key = static_cast<char>(waitKey());
+
+        if (key == 27)
+            break;
+
+        if (key == 32)
+        {
+            ++alpha_op;
+
+            if (alpha_op > ALPHA_PREMUL)
+                alpha_op = ALPHA_OVER;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/bgfg_segm.cpp b/C++/opencv-4.7.0/samples/gpu/bgfg_segm.cpp
new file mode 100644
index 00000000..a3c56f8b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/bgfg_segm.cpp
@@ -0,0 +1,143 @@
+#include <iostream>
+#include <string>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/cudabgsegm.hpp"
+#include "opencv2/video.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::cuda;
+
+enum Method
+{
+    MOG,
+    MOG2,
+};
+
+int main(int argc, const char** argv)
+{
+    cv::CommandLineParser cmd(argc, argv,
+        "{ c camera |                    | use camera }"
+        "{ f file   | ../data/vtest.avi  | input video file }"
+        "{ m method | mog                | method (mog, mog2) }"
+        "{ h help   |                    | print help message }");
+
+    if (cmd.has("help") || !cmd.check())
+    {
+        cmd.printMessage();
+        cmd.printErrors();
+        return 0;
+    }
+
+    bool useCamera = cmd.has("camera");
+    string file = cmd.get<string>("file");
+    string method = cmd.get<string>("method");
+
+    if (method != "mog"
+        && method != "mog2")
+    {
+        cerr << "Incorrect method" << endl;
+        return -1;
+    }
+
+    Method m = method == "mog" ? MOG :
+               method == "mog2" ? MOG2 :
+                                  (Method)-1;
+    CV_Assert(m != (Method)-1);
+
+    VideoCapture cap;
+
+    if (useCamera)
+        cap.open(0);
+    else
+        cap.open(file);
+
+    if (!cap.isOpened())
+    {
+        cerr << "can not open camera or video file" << endl;
+        return -1;
+    }
+
+    Mat frame;
+    cap >> frame;
+
+    GpuMat d_frame(frame);
+
+    Ptr<BackgroundSubtractor> mog = cuda::createBackgroundSubtractorMOG();
+    Ptr<BackgroundSubtractor> mog2 = cuda::createBackgroundSubtractorMOG2();
+
+    GpuMat d_fgmask;
+    GpuMat d_fgimg;
+    GpuMat d_bgimg;
+
+    Mat fgmask;
+    Mat fgimg;
+    Mat bgimg;
+
+    switch (m)
+    {
+    case MOG:
+        mog->apply(d_frame, d_fgmask, 0.01);
+        break;
+
+    case MOG2:
+        mog2->apply(d_frame, d_fgmask);
+        break;
+    }
+
+    namedWindow("image", WINDOW_NORMAL);
+    namedWindow("foreground mask", WINDOW_NORMAL);
+    namedWindow("foreground image", WINDOW_NORMAL);
+    namedWindow("mean background image", WINDOW_NORMAL);
+
+    for(;;)
+    {
+        cap >> frame;
+        if (frame.empty())
+            break;
+        d_frame.upload(frame);
+
+        int64 start = cv::getTickCount();
+
+        //update the model
+        switch (m)
+        {
+        case MOG:
+            mog->apply(d_frame, d_fgmask, 0.01);
+            mog->getBackgroundImage(d_bgimg);
+            break;
+
+        case MOG2:
+            mog2->apply(d_frame, d_fgmask);
+            mog2->getBackgroundImage(d_bgimg);
+            break;
+        }
+
+        double fps = cv::getTickFrequency() / (cv::getTickCount() - start);
+        std::cout << "FPS : " << fps << std::endl;
+
+        d_fgimg.create(d_frame.size(), d_frame.type());
+        d_fgimg.setTo(Scalar::all(0));
+        d_frame.copyTo(d_fgimg, d_fgmask);
+
+        d_fgmask.download(fgmask);
+        d_fgimg.download(fgimg);
+        if (!d_bgimg.empty())
+            d_bgimg.download(bgimg);
+
+        imshow("image", frame);
+        imshow("foreground mask", fgmask);
+        imshow("foreground image", fgimg);
+        if (!bgimg.empty())
+            imshow("mean background image", bgimg);
+
+        char key = (char)waitKey(30);
+        if (key == 27)
+            break;
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/cascadeclassifier.cpp b/C++/opencv-4.7.0/samples/gpu/cascadeclassifier.cpp
new file mode 100644
index 00000000..0f0b8f5e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/cascadeclassifier.cpp
@@ -0,0 +1,316 @@
+// WARNING: this sample is under construction! Use it on your own risk.
+#if defined _MSC_VER && _MSC_VER >= 1400
+#pragma warning(disable : 4100)
+#endif
+
+
+#include <iostream>
+#include <iomanip>
+#include "opencv2/objdetect.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/cudaobjdetect.hpp"
+#include "opencv2/cudaimgproc.hpp"
+#include "opencv2/cudawarping.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::cuda;
+
+
+static void help()
+{
+    cout << "Usage: ./cascadeclassifier \n\t--cascade <cascade_file>\n\t(<image>|--video <video>|--camera <camera_id>)\n"
+            "Using OpenCV version " << CV_VERSION << endl << endl;
+}
+
+
+static void convertAndResize(const Mat& src, Mat& gray, Mat& resized, double scale)
+{
+    if (src.channels() == 3)
+    {
+        cv::cvtColor( src, gray, COLOR_BGR2GRAY );
+    }
+    else
+    {
+        gray = src;
+    }
+
+    Size sz(cvRound(gray.cols * scale), cvRound(gray.rows * scale));
+
+    if (scale != 1)
+    {
+        cv::resize(gray, resized, sz);
+    }
+    else
+    {
+        resized = gray;
+    }
+}
+
+static void convertAndResize(const GpuMat& src, GpuMat& gray, GpuMat& resized, double scale)
+{
+    if (src.channels() == 3)
+    {
+        cv::cuda::cvtColor( src, gray, COLOR_BGR2GRAY );
+    }
+    else
+    {
+        gray = src;
+    }
+
+    Size sz(cvRound(gray.cols * scale), cvRound(gray.rows * scale));
+
+    if (scale != 1)
+    {
+        cv::cuda::resize(gray, resized, sz);
+    }
+    else
+    {
+        resized = gray;
+    }
+}
+
+
+static void matPrint(Mat &img, int lineOffsY, Scalar fontColor, const string &ss)
+{
+    int fontFace = FONT_HERSHEY_DUPLEX;
+    double fontScale = 0.8;
+    int fontThickness = 2;
+    Size fontSize = cv::getTextSize("T[]", fontFace, fontScale, fontThickness, 0);
+
+    Point org;
+    org.x = 1;
+    org.y = 3 * fontSize.height * (lineOffsY + 1) / 2;
+    putText(img, ss, org, fontFace, fontScale, Scalar(0,0,0), 5*fontThickness/2, 16);
+    putText(img, ss, org, fontFace, fontScale, fontColor, fontThickness, 16);
+}
+
+
+static void displayState(Mat &canvas, bool bHelp, bool bGpu, bool bLargestFace, bool bFilter, double fps)
+{
+    Scalar fontColorRed = Scalar(255,0,0);
+    Scalar fontColorNV  = Scalar(118,185,0);
+
+    ostringstream ss;
+    ss << "FPS = " << setprecision(1) << fixed << fps;
+    matPrint(canvas, 0, fontColorRed, ss.str());
+    ss.str("");
+    ss << "[" << canvas.cols << "x" << canvas.rows << "], " <<
+        (bGpu ? "GPU, " : "CPU, ") <<
+        (bLargestFace ? "OneFace, " : "MultiFace, ") <<
+        (bFilter ? "Filter:ON" : "Filter:OFF");
+    matPrint(canvas, 1, fontColorRed, ss.str());
+
+    // by Anatoly. MacOS fix. ostringstream(const string&) is a private
+    // matPrint(canvas, 2, fontColorNV, ostringstream("Space - switch GPU / CPU"));
+    if (bHelp)
+    {
+        matPrint(canvas, 2, fontColorNV, "Space - switch GPU / CPU");
+        matPrint(canvas, 3, fontColorNV, "M - switch OneFace / MultiFace");
+        matPrint(canvas, 4, fontColorNV, "F - toggle rectangles Filter");
+        matPrint(canvas, 5, fontColorNV, "H - toggle hotkeys help");
+        matPrint(canvas, 6, fontColorNV, "1/Q - increase/decrease scale");
+    }
+    else
+    {
+        matPrint(canvas, 2, fontColorNV, "H - toggle hotkeys help");
+    }
+}
+
+
+int main(int argc, const char *argv[])
+{
+    if (argc == 1)
+    {
+        help();
+        return -1;
+    }
+
+    if (getCudaEnabledDeviceCount() == 0)
+    {
+        return cerr << "No GPU found or the library is compiled without CUDA support" << endl, -1;
+    }
+
+    cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());
+
+    string cascadeName;
+    string inputName;
+    bool isInputImage = false;
+    bool isInputVideo = false;
+    bool isInputCamera = false;
+
+    for (int i = 1; i < argc; ++i)
+    {
+        if (string(argv[i]) == "--cascade")
+            cascadeName = argv[++i];
+        else if (string(argv[i]) == "--video")
+        {
+            inputName = argv[++i];
+            isInputVideo = true;
+        }
+        else if (string(argv[i]) == "--camera")
+        {
+            inputName = argv[++i];
+            isInputCamera = true;
+        }
+        else if (string(argv[i]) == "--help")
+        {
+            help();
+            return -1;
+        }
+        else if (!isInputImage)
+        {
+            inputName = argv[i];
+            isInputImage = true;
+        }
+        else
+        {
+            cout << "Unknown key: " << argv[i] << endl;
+            return -1;
+        }
+    }
+
+    Ptr<cuda::CascadeClassifier> cascade_gpu = cuda::CascadeClassifier::create(cascadeName);
+
+    cv::CascadeClassifier cascade_cpu;
+    if (!cascade_cpu.load(cascadeName))
+    {
+        return cerr << "ERROR: Could not load cascade classifier \"" << cascadeName << "\"" << endl, help(), -1;
+    }
+
+    VideoCapture capture;
+    Mat image;
+
+    if (isInputImage)
+    {
+        image = imread(inputName);
+        CV_Assert(!image.empty());
+    }
+    else if (isInputVideo)
+    {
+        capture.open(inputName);
+        CV_Assert(capture.isOpened());
+    }
+    else
+    {
+        capture.open(atoi(inputName.c_str()));
+        CV_Assert(capture.isOpened());
+    }
+
+    namedWindow("result", 1);
+
+    Mat frame, frame_cpu, gray_cpu, resized_cpu, frameDisp;
+    vector<Rect> faces;
+
+    GpuMat frame_gpu, gray_gpu, resized_gpu, facesBuf_gpu;
+
+    /* parameters */
+    bool useGPU = true;
+    double scaleFactor = 1.0;
+    bool findLargestObject = false;
+    bool filterRects = true;
+    bool helpScreen = false;
+
+    for (;;)
+    {
+        if (isInputCamera || isInputVideo)
+        {
+            capture >> frame;
+            if (frame.empty())
+            {
+                break;
+            }
+        }
+
+        (image.empty() ? frame : image).copyTo(frame_cpu);
+        frame_gpu.upload(image.empty() ? frame : image);
+
+        convertAndResize(frame_gpu, gray_gpu, resized_gpu, scaleFactor);
+        convertAndResize(frame_cpu, gray_cpu, resized_cpu, scaleFactor);
+
+        TickMeter tm;
+        tm.start();
+
+        if (useGPU)
+        {
+            cascade_gpu->setFindLargestObject(findLargestObject);
+            cascade_gpu->setScaleFactor(1.2);
+            cascade_gpu->setMinNeighbors((filterRects || findLargestObject) ? 4 : 0);
+
+            cascade_gpu->detectMultiScale(resized_gpu, facesBuf_gpu);
+            cascade_gpu->convert(facesBuf_gpu, faces);
+        }
+        else
+        {
+            Size minSize = cascade_gpu->getClassifierSize();
+            cascade_cpu.detectMultiScale(resized_cpu, faces, 1.2,
+                                         (filterRects || findLargestObject) ? 4 : 0,
+                                         (findLargestObject ? CASCADE_FIND_BIGGEST_OBJECT : 0)
+                                            | CASCADE_SCALE_IMAGE,
+                                         minSize);
+        }
+
+        for (size_t i = 0; i < faces.size(); ++i)
+        {
+            rectangle(resized_cpu, faces[i], Scalar(255));
+        }
+
+        tm.stop();
+        double detectionTime = tm.getTimeMilli();
+        double fps = 1000 / detectionTime;
+
+        //print detections to console
+        cout << setfill(' ') << setprecision(2);
+        cout << setw(6) << fixed << fps << " FPS, " << faces.size() << " det";
+        if ((filterRects || findLargestObject) && !faces.empty())
+        {
+            for (size_t i = 0; i < faces.size(); ++i)
+            {
+                cout << ", [" << setw(4) << faces[i].x
+                     << ", " << setw(4) << faces[i].y
+                     << ", " << setw(4) << faces[i].width
+                     << ", " << setw(4) << faces[i].height << "]";
+            }
+        }
+        cout << endl;
+
+        cv::cvtColor(resized_cpu, frameDisp, COLOR_GRAY2BGR);
+        displayState(frameDisp, helpScreen, useGPU, findLargestObject, filterRects, fps);
+        imshow("result", frameDisp);
+
+        char key = (char)waitKey(5);
+        if (key == 27)
+        {
+            break;
+        }
+
+        switch (key)
+        {
+        case ' ':
+            useGPU = !useGPU;
+            break;
+        case 'm':
+        case 'M':
+            findLargestObject = !findLargestObject;
+            break;
+        case 'f':
+        case 'F':
+            filterRects = !filterRects;
+            break;
+        case '1':
+            scaleFactor *= 1.05;
+            break;
+        case 'q':
+        case 'Q':
+            scaleFactor /= 1.05;
+            break;
+        case 'h':
+        case 'H':
+            helpScreen = !helpScreen;
+            break;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/farneback_optical_flow.cpp b/C++/opencv-4.7.0/samples/gpu/farneback_optical_flow.cpp
new file mode 100644
index 00000000..b3d67b67
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/farneback_optical_flow.cpp
@@ -0,0 +1,140 @@
+#include <iostream>
+#include <vector>
+#include <sstream>
+#include <cmath>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/video.hpp"
+#include "opencv2/cudaoptflow.hpp"
+#include "opencv2/cudaarithm.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::cuda;
+
+template <typename T>
+inline T mapVal(T x, T a, T b, T c, T d)
+{
+    x = ::max(::min(x, b), a);
+    return c + (d-c) * (x-a) / (b-a);
+}
+
+static void colorizeFlow(const Mat &u, const Mat &v, Mat &dst)
+{
+    double uMin, uMax;
+    cv::minMaxLoc(u, &uMin, &uMax, 0, 0);
+    double vMin, vMax;
+    cv::minMaxLoc(v, &vMin, &vMax, 0, 0);
+    uMin = ::abs(uMin); uMax = ::abs(uMax);
+    vMin = ::abs(vMin); vMax = ::abs(vMax);
+    float dMax = static_cast<float>(::max(::max(uMin, uMax), ::max(vMin, vMax)));
+
+    dst.create(u.size(), CV_8UC3);
+    for (int y = 0; y < u.rows; ++y)
+    {
+        for (int x = 0; x < u.cols; ++x)
+        {
+            dst.at<uchar>(y,3*x) = 0;
+            dst.at<uchar>(y,3*x+1) = (uchar)mapVal(-v.at<float>(y,x), -dMax, dMax, 0.f, 255.f);
+            dst.at<uchar>(y,3*x+2) = (uchar)mapVal(u.at<float>(y,x), -dMax, dMax, 0.f, 255.f);
+        }
+    }
+}
+
+int main(int argc, char **argv)
+{
+    CommandLineParser cmd(argc, argv,
+            "{ l left  | ../data/basketball1.png | specify left image }"
+            "{ r right | ../data/basketball2.png | specify right image }"
+            "{ h help  | | print help message }");
+
+    cmd.about("Farneback's optical flow sample.");
+    if (cmd.has("help") || !cmd.check())
+    {
+        cmd.printMessage();
+        cmd.printErrors();
+        return 0;
+    }
+
+
+    string pathL = cmd.get<string>("left");
+    string pathR = cmd.get<string>("right");
+    if (pathL.empty()) cout << "Specify left image path\n";
+    if (pathR.empty()) cout << "Specify right image path\n";
+    if (pathL.empty() || pathR.empty()) return -1;
+
+    Mat frameL = imread(pathL, IMREAD_GRAYSCALE);
+    Mat frameR = imread(pathR, IMREAD_GRAYSCALE);
+    if (frameL.empty()) cout << "Can't open '" << pathL << "'\n";
+    if (frameR.empty()) cout << "Can't open '" << pathR << "'\n";
+    if (frameL.empty() || frameR.empty()) return -1;
+
+    GpuMat d_frameL(frameL), d_frameR(frameR);
+    GpuMat d_flow;
+    Ptr<cuda::FarnebackOpticalFlow> d_calc = cuda::FarnebackOpticalFlow::create();
+    Mat flowxy, flowx, flowy, image;
+
+    bool running = true, gpuMode = true;
+    int64 t, t0=0, t1=1, tc0, tc1;
+
+    cout << "Use 'm' for CPU/GPU toggling\n";
+
+    while (running)
+    {
+        t = getTickCount();
+
+        if (gpuMode)
+        {
+            tc0 = getTickCount();
+            d_calc->calc(d_frameL, d_frameR, d_flow);
+            tc1 = getTickCount();
+
+            GpuMat planes[2];
+            cuda::split(d_flow, planes);
+
+            planes[0].download(flowx);
+            planes[1].download(flowy);
+        }
+        else
+        {
+            tc0 = getTickCount();
+            calcOpticalFlowFarneback(
+                        frameL, frameR, flowxy, d_calc->getPyrScale(), d_calc->getNumLevels(), d_calc->getWinSize(),
+                        d_calc->getNumIters(), d_calc->getPolyN(), d_calc->getPolySigma(), d_calc->getFlags());
+            tc1 = getTickCount();
+
+            Mat planes[] = {flowx, flowy};
+            split(flowxy, planes);
+            flowx = planes[0]; flowy = planes[1];
+        }
+
+        colorizeFlow(flowx, flowy, image);
+
+        stringstream s;
+        s << "mode: " << (gpuMode?"GPU":"CPU");
+        putText(image, s.str(), Point(5, 25), FONT_HERSHEY_SIMPLEX, 1., Scalar(255,0,255), 2);
+
+        s.str("");
+        s << "opt. flow FPS: " << cvRound((getTickFrequency()/(tc1-tc0)));
+        putText(image, s.str(), Point(5, 65), FONT_HERSHEY_SIMPLEX, 1., Scalar(255,0,255), 2);
+
+        s.str("");
+        s << "total FPS: " << cvRound((getTickFrequency()/(t1-t0)));
+        putText(image, s.str(), Point(5, 105), FONT_HERSHEY_SIMPLEX, 1., Scalar(255,0,255), 2);
+
+        imshow("flow", image);
+
+        char ch = (char)waitKey(3);
+        if (ch == 27)
+            running = false;
+        else if (ch == 'm' || ch == 'M')
+            gpuMode = !gpuMode;
+
+        t0 = t;
+        t1 = getTickCount();
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/generalized_hough.cpp b/C++/opencv-4.7.0/samples/gpu/generalized_hough.cpp
new file mode 100644
index 00000000..a607769c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/generalized_hough.cpp
@@ -0,0 +1,182 @@
+#include <vector>
+#include <iostream>
+#include <string>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/cudaimgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace std;
+using namespace cv;
+
+static Mat loadImage(const string& name)
+{
+    Mat image = imread(name, IMREAD_GRAYSCALE);
+    if (image.empty())
+    {
+        cerr << "Can't load image - " << name << endl;
+        exit(-1);
+    }
+    return image;
+}
+
+int main(int argc, const char* argv[])
+{
+    CommandLineParser cmd(argc, argv,
+        "{ image i        | ../data/pic1.png  | input image }"
+        "{ template t     | templ.png | template image }"
+        "{ full           |           | estimate scale and rotation }"
+        "{ gpu            |           | use gpu version }"
+        "{ minDist        | 100       | minimum distance between the centers of the detected objects }"
+        "{ levels         | 360       | R-Table levels }"
+        "{ votesThreshold | 30        | the accumulator threshold for the template centers at the detection stage. The smaller it is, the more false positions may be detected }"
+        "{ angleThresh    | 10000     | angle votes threshold }"
+        "{ scaleThresh    | 1000      | scale votes threshold }"
+        "{ posThresh      | 100       | position votes threshold }"
+        "{ dp             | 2         | inverse ratio of the accumulator resolution to the image resolution }"
+        "{ minScale       | 0.5       | minimal scale to detect }"
+        "{ maxScale       | 2         | maximal scale to detect }"
+        "{ scaleStep      | 0.05      | scale step }"
+        "{ minAngle       | 0         | minimal rotation angle to detect in degrees }"
+        "{ maxAngle       | 360       | maximal rotation angle to detect in degrees }"
+        "{ angleStep      | 1         | angle step in degrees }"
+        "{ maxBufSize     | 1000      | maximal size of inner buffers }"
+        "{ help h ?       |           | print help message }"
+    );
+
+    cmd.about("This program demonstrates arbitrary object finding with the Generalized Hough transform.");
+
+    if (cmd.has("help"))
+    {
+        cmd.printMessage();
+        return 0;
+    }
+
+    const string templName = cmd.get<string>("template");
+    const string imageName = cmd.get<string>("image");
+    const bool full = cmd.has("full");
+    const bool useGpu = cmd.has("gpu");
+    const double minDist = cmd.get<double>("minDist");
+    const int levels = cmd.get<int>("levels");
+    const int votesThreshold = cmd.get<int>("votesThreshold");
+    const int angleThresh = cmd.get<int>("angleThresh");
+    const int scaleThresh = cmd.get<int>("scaleThresh");
+    const int posThresh = cmd.get<int>("posThresh");
+    const double dp = cmd.get<double>("dp");
+    const double minScale = cmd.get<double>("minScale");
+    const double maxScale = cmd.get<double>("maxScale");
+    const double scaleStep = cmd.get<double>("scaleStep");
+    const double minAngle = cmd.get<double>("minAngle");
+    const double maxAngle = cmd.get<double>("maxAngle");
+    const double angleStep = cmd.get<double>("angleStep");
+    const int maxBufSize = cmd.get<int>("maxBufSize");
+
+    if (!cmd.check())
+    {
+        cmd.printErrors();
+        return -1;
+    }
+
+    Mat templ = loadImage(templName);
+    Mat image = loadImage(imageName);
+
+    Ptr<GeneralizedHough> alg;
+
+    if (!full)
+    {
+        Ptr<GeneralizedHoughBallard> ballard = useGpu ? cuda::createGeneralizedHoughBallard() : createGeneralizedHoughBallard();
+
+        ballard->setMinDist(minDist);
+        ballard->setLevels(levels);
+        ballard->setDp(dp);
+        ballard->setMaxBufferSize(maxBufSize);
+        ballard->setVotesThreshold(votesThreshold);
+
+        alg = ballard;
+    }
+    else
+    {
+        Ptr<GeneralizedHoughGuil> guil = useGpu ? cuda::createGeneralizedHoughGuil() : createGeneralizedHoughGuil();
+
+        guil->setMinDist(minDist);
+        guil->setLevels(levels);
+        guil->setDp(dp);
+        guil->setMaxBufferSize(maxBufSize);
+
+        guil->setMinAngle(minAngle);
+        guil->setMaxAngle(maxAngle);
+        guil->setAngleStep(angleStep);
+        guil->setAngleThresh(angleThresh);
+
+        guil->setMinScale(minScale);
+        guil->setMaxScale(maxScale);
+        guil->setScaleStep(scaleStep);
+        guil->setScaleThresh(scaleThresh);
+
+        guil->setPosThresh(posThresh);
+
+        alg = guil;
+    }
+
+    vector<Vec4f> position;
+    TickMeter tm;
+
+    if (useGpu)
+    {
+        cuda::GpuMat d_templ(templ);
+        cuda::GpuMat d_image(image);
+        cuda::GpuMat d_position;
+
+        alg->setTemplate(d_templ);
+
+        tm.start();
+
+        alg->detect(d_image, d_position);
+        d_position.download(position);
+
+        tm.stop();
+    }
+    else
+    {
+        alg->setTemplate(templ);
+
+        tm.start();
+
+        alg->detect(image, position);
+
+        tm.stop();
+    }
+
+    cout << "Found : " << position.size() << " objects" << endl;
+    cout << "Detection time : " << tm.getTimeMilli() << " ms" << endl;
+
+    Mat out;
+    cv::cvtColor(image, out, COLOR_GRAY2BGR);
+
+    for (size_t i = 0; i < position.size(); ++i)
+    {
+        Point2f pos(position[i][0], position[i][1]);
+        float scale = position[i][2];
+        float angle = position[i][3];
+
+        RotatedRect rect;
+        rect.center = pos;
+        rect.size = Size2f(templ.cols * scale, templ.rows * scale);
+        rect.angle = angle;
+
+        Point2f pts[4];
+        rect.points(pts);
+
+        line(out, pts[0], pts[1], Scalar(0, 0, 255), 3);
+        line(out, pts[1], pts[2], Scalar(0, 0, 255), 3);
+        line(out, pts[2], pts[3], Scalar(0, 0, 255), 3);
+        line(out, pts[3], pts[0], Scalar(0, 0, 255), 3);
+    }
+
+    imshow("out", out);
+    waitKey();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/hog.cpp b/C++/opencv-4.7.0/samples/gpu/hog.cpp
new file mode 100644
index 00000000..b50ce729
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/hog.cpp
@@ -0,0 +1,552 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+#include <opencv2/core/utility.hpp>
+#include "opencv2/cudaobjdetect.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/objdetect.hpp"
+#include "opencv2/imgproc.hpp"
+
+using namespace std;
+using namespace cv;
+
+bool help_showed = false;
+
+class Args
+{
+public:
+    Args();
+    static Args read(int argc, char** argv);
+
+    string src;
+    bool src_is_folder;
+    bool src_is_video;
+    bool src_is_camera;
+    int camera_id;
+
+    bool svm_load;
+    string svm;
+
+    bool write_video;
+    string dst_video;
+    double dst_video_fps;
+
+    bool make_gray;
+
+    bool resize_src;
+    int width, height;
+
+    double scale;
+    int nlevels;
+    int gr_threshold;
+
+    double hit_threshold;
+    bool hit_threshold_auto;
+
+    int win_width;
+    int win_stride_width, win_stride_height;
+    int block_width;
+    int block_stride_width, block_stride_height;
+    int cell_width;
+    int nbins;
+
+    bool gamma_corr;
+};
+
+
+class App
+{
+public:
+    App(const Args& s);
+    void run();
+
+    void handleKey(char key);
+
+    void hogWorkBegin();
+    void hogWorkEnd();
+    string hogWorkFps() const;
+
+    void workBegin();
+    void workEnd();
+    string workFps() const;
+
+    string message() const;
+
+private:
+    App operator=(App&);
+
+    Args args;
+    bool running;
+
+    bool use_gpu;
+    bool make_gray;
+    double scale;
+    int gr_threshold;
+    int nlevels;
+    double hit_threshold;
+    bool gamma_corr;
+
+    int64 hog_work_begin;
+    double hog_work_fps;
+
+    int64 work_begin;
+    double work_fps;
+};
+
+static void printHelp()
+{
+    cout << "Histogram of Oriented Gradients descriptor and detector sample.\n"
+         << "\nUsage: hog\n"
+         << "  (<image>|--video <vide>|--camera <camera_id>) # frames source\n"
+         << "  or"
+         << "  (--folder <folder_path>) # load images from folder\n"
+         << "  [--svm <file> # load svm file"
+         << "  [--make_gray <true/false>] # convert image to gray one or not\n"
+         << "  [--resize_src <true/false>] # do resize of the source image or not\n"
+         << "  [--width <int>] # resized image width\n"
+         << "  [--height <int>] # resized image height\n"
+         << "  [--hit_threshold <double>] # classifying plane distance threshold (0.0 usually)\n"
+         << "  [--scale <double>] # HOG window scale factor\n"
+         << "  [--nlevels <int>] # max number of HOG window scales\n"
+         << "  [--win_width <int>] # width of the window\n"
+         << "  [--win_stride_width <int>] # distance by OX axis between neighbour wins\n"
+         << "  [--win_stride_height <int>] # distance by OY axis between neighbour wins\n"
+         << "  [--block_width <int>] # width of the block\n"
+         << "  [--block_stride_width <int>] # distance by 0X axis between neighbour blocks\n"
+         << "  [--block_stride_height <int>] # distance by 0Y axis between neighbour blocks\n"
+         << "  [--cell_width <int>] # width of the cell\n"
+         << "  [--nbins <int>] # number of bins\n"
+         << "  [--gr_threshold <int>] # merging similar rects constant\n"
+         << "  [--gamma_correct <int>] # do gamma correction or not\n"
+         << "  [--write_video <bool>] # write video or not\n"
+         << "  [--dst_video <path>] # output video path\n"
+         << "  [--dst_video_fps <double>] # output video fps\n";
+    help_showed = true;
+}
+
+int main(int argc, char** argv)
+{
+    try
+    {
+        Args args;
+        if (argc < 2)
+        {
+            printHelp();
+            args.camera_id = 0;
+            args.src_is_camera = true;
+        }
+        else
+        {
+            args = Args::read(argc, argv);
+            if (help_showed)
+                return -1;
+        }
+        App app(args);
+        app.run();
+    }
+    catch (const Exception& e) { return cout << "error: "  << e.what() << endl, 1; }
+    catch (const exception& e) { return cout << "error: "  << e.what() << endl, 1; }
+    catch(...) { return cout << "unknown exception" << endl, 1; }
+    return 0;
+}
+
+
+Args::Args()
+{
+    src_is_video = false;
+    src_is_camera = false;
+    src_is_folder = false;
+    svm_load = false;
+    camera_id = 0;
+
+    write_video = false;
+    dst_video_fps = 24.;
+
+    make_gray = false;
+
+    resize_src = false;
+    width = 640;
+    height = 480;
+
+    scale = 1.05;
+    nlevels = 13;
+    gr_threshold = 8;
+    hit_threshold = 1.4;
+    hit_threshold_auto = true;
+
+    win_width = 48;
+    win_stride_width = 8;
+    win_stride_height = 8;
+    block_width = 16;
+    block_stride_width = 8;
+    block_stride_height = 8;
+    cell_width = 8;
+    nbins = 9;
+
+    gamma_corr = true;
+}
+
+
+Args Args::read(int argc, char** argv)
+{
+    Args args;
+    for (int i = 1; i < argc; i++)
+    {
+        if (string(argv[i]) == "--make_gray") args.make_gray = (string(argv[++i]) == "true");
+        else if (string(argv[i]) == "--resize_src") args.resize_src = (string(argv[++i]) == "true");
+        else if (string(argv[i]) == "--width") args.width = atoi(argv[++i]);
+        else if (string(argv[i]) == "--height") args.height = atoi(argv[++i]);
+        else if (string(argv[i]) == "--hit_threshold")
+        {
+            args.hit_threshold = atof(argv[++i]);
+            args.hit_threshold_auto = false;
+        }
+        else if (string(argv[i]) == "--scale") args.scale = atof(argv[++i]);
+        else if (string(argv[i]) == "--nlevels") args.nlevels = atoi(argv[++i]);
+        else if (string(argv[i]) == "--win_width") args.win_width = atoi(argv[++i]);
+        else if (string(argv[i]) == "--win_stride_width") args.win_stride_width = atoi(argv[++i]);
+        else if (string(argv[i]) == "--win_stride_height") args.win_stride_height = atoi(argv[++i]);
+        else if (string(argv[i]) == "--block_width") args.block_width = atoi(argv[++i]);
+        else if (string(argv[i]) == "--block_stride_width") args.block_stride_width = atoi(argv[++i]);
+        else if (string(argv[i]) == "--block_stride_height") args.block_stride_height = atoi(argv[++i]);
+        else if (string(argv[i]) == "--cell_width") args.cell_width = atoi(argv[++i]);
+        else if (string(argv[i]) == "--nbins") args.nbins = atoi(argv[++i]);
+        else if (string(argv[i]) == "--gr_threshold") args.gr_threshold = atoi(argv[++i]);
+        else if (string(argv[i]) == "--gamma_correct") args.gamma_corr = (string(argv[++i]) == "true");
+        else if (string(argv[i]) == "--write_video") args.write_video = (string(argv[++i]) == "true");
+        else if (string(argv[i]) == "--dst_video") args.dst_video = argv[++i];
+        else if (string(argv[i]) == "--dst_video_fps") args.dst_video_fps = atof(argv[++i]);
+        else if (string(argv[i]) == "--help") printHelp();
+        else if (string(argv[i]) == "--video") { args.src = argv[++i]; args.src_is_video = true; }
+        else if (string(argv[i]) == "--camera") { args.camera_id = atoi(argv[++i]); args.src_is_camera = true; }
+        else if (string(argv[i]) == "--folder") { args.src = argv[++i]; args.src_is_folder = true;}
+        else if (string(argv[i]) == "--svm") { args.svm = argv[++i]; args.svm_load = true;}
+        else if (args.src.empty()) args.src = argv[i];
+        else throw runtime_error((string("unknown key: ") + argv[i]));
+    }
+    return args;
+}
+
+
+App::App(const Args& s)
+{
+    cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());
+
+    args = s;
+    cout << "\nControls:\n"
+         << "\tESC - exit\n"
+         << "\tm - change mode GPU <-> CPU\n"
+         << "\tg - convert image to gray or not\n"
+         << "\t1/q - increase/decrease HOG scale\n"
+         << "\t2/w - increase/decrease levels count\n"
+         << "\t3/e - increase/decrease HOG group threshold\n"
+         << "\t4/r - increase/decrease hit threshold\n"
+         << endl;
+
+    use_gpu = true;
+    make_gray = args.make_gray;
+    scale = args.scale;
+    gr_threshold = args.gr_threshold;
+    nlevels = args.nlevels;
+
+    if (args.hit_threshold_auto)
+        args.hit_threshold = args.win_width == 48 ? 1.4 : 0.;
+    hit_threshold = args.hit_threshold;
+
+    gamma_corr = args.gamma_corr;
+
+    cout << "Scale: " << scale << endl;
+    if (args.resize_src)
+        cout << "Resized source: (" << args.width << ", " << args.height << ")\n";
+    cout << "Group threshold: " << gr_threshold << endl;
+    cout << "Levels number: " << nlevels << endl;
+    cout << "Win size: (" << args.win_width << ", " << args.win_width*2 << ")\n";
+    cout << "Win stride: (" << args.win_stride_width << ", " << args.win_stride_height << ")\n";
+    cout << "Block size: (" << args.block_width << ", " << args.block_width << ")\n";
+    cout << "Block stride: (" << args.block_stride_width << ", " << args.block_stride_height << ")\n";
+    cout << "Cell size: (" << args.cell_width << ", " << args.cell_width << ")\n";
+    cout << "Bins number: " << args.nbins << endl;
+    cout << "Hit threshold: " << hit_threshold << endl;
+    cout << "Gamma correction: " << gamma_corr << endl;
+    cout << endl;
+}
+
+
+void App::run()
+{
+    running = true;
+    cv::VideoWriter video_writer;
+
+    Size win_stride(args.win_stride_width, args.win_stride_height);
+    Size win_size(args.win_width, args.win_width * 2);
+    Size block_size(args.block_width, args.block_width);
+    Size block_stride(args.block_stride_width, args.block_stride_height);
+    Size cell_size(args.cell_width, args.cell_width);
+
+    cv::Ptr<cv::cuda::HOG> gpu_hog = cv::cuda::HOG::create(win_size, block_size, block_stride, cell_size, args.nbins);
+    cv::HOGDescriptor cpu_hog(win_size, block_size, block_stride, cell_size, args.nbins);
+
+    if(args.svm_load) {
+        std::vector<float> svm_model;
+        const std::string model_file_name = args.svm;
+        FileStorage ifs(model_file_name, FileStorage::READ);
+        if (ifs.isOpened()) {
+            ifs["svm_detector"] >> svm_model;
+        } else {
+            const std::string what =
+                    "could not load model for hog classifier from file: "
+                    + model_file_name;
+            throw std::runtime_error(what);
+        }
+
+        // check if the variables are initialized
+        if (svm_model.empty()) {
+            const std::string what =
+                    "HoG classifier: svm model could not be loaded from file"
+                    + model_file_name;
+            throw std::runtime_error(what);
+        }
+
+        gpu_hog->setSVMDetector(svm_model);
+        cpu_hog.setSVMDetector(svm_model);
+    } else {
+        // Create HOG descriptors and detectors here
+        Mat detector = gpu_hog->getDefaultPeopleDetector();
+
+        gpu_hog->setSVMDetector(detector);
+        cpu_hog.setSVMDetector(detector);
+    }
+
+    cout << "gpusvmDescriptorSize : " << gpu_hog->getDescriptorSize()
+         << endl;
+    cout << "cpusvmDescriptorSize : " << cpu_hog.getDescriptorSize()
+         << endl;
+
+    while (running)
+    {
+        VideoCapture vc;
+        Mat frame;
+        vector<String> filenames;
+
+        unsigned int count = 1;
+
+        if (args.src_is_video)
+        {
+            vc.open(args.src.c_str());
+            if (!vc.isOpened())
+                throw runtime_error(string("can't open video file: " + args.src));
+            vc >> frame;
+        }
+        else if (args.src_is_folder) {
+            String folder = args.src;
+            cout << folder << endl;
+            glob(folder, filenames);
+            frame = imread(filenames[count]);	// 0 --> .gitignore
+            if (!frame.data)
+                cerr << "Problem loading image from folder!!!" << endl;
+        }
+        else if (args.src_is_camera)
+        {
+            vc.open(args.camera_id);
+            if (!vc.isOpened())
+            {
+                stringstream msg;
+                msg << "can't open camera: " << args.camera_id;
+                throw runtime_error(msg.str());
+            }
+            vc >> frame;
+        }
+        else
+        {
+            frame = imread(args.src);
+            if (frame.empty())
+                throw runtime_error(string("can't open image file: " + args.src));
+        }
+
+        Mat img_aux, img, img_to_show;
+        cuda::GpuMat gpu_img;
+
+        // Iterate over all frames
+        while (running && !frame.empty())
+        {
+            workBegin();
+
+            // Change format of the image
+            if (make_gray) cvtColor(frame, img_aux, COLOR_BGR2GRAY);
+            else if (use_gpu) cvtColor(frame, img_aux, COLOR_BGR2BGRA);
+            else frame.copyTo(img_aux);
+
+            // Resize image
+            if (args.resize_src) resize(img_aux, img, Size(args.width, args.height));
+            else img = img_aux;
+            img_to_show = img;
+
+            vector<Rect> found;
+
+            // Perform HOG classification
+            hogWorkBegin();
+            if (use_gpu)
+            {
+                gpu_img.upload(img);
+                gpu_hog->setNumLevels(nlevels);
+                gpu_hog->setHitThreshold(hit_threshold);
+                gpu_hog->setWinStride(win_stride);
+                gpu_hog->setScaleFactor(scale);
+                gpu_hog->setGroupThreshold(gr_threshold);
+                gpu_hog->detectMultiScale(gpu_img, found);
+            }
+            else
+            {
+                cpu_hog.nlevels = nlevels;
+                cpu_hog.detectMultiScale(img, found, hit_threshold, win_stride,
+                                         Size(0, 0), scale, gr_threshold);
+            }
+            hogWorkEnd();
+
+            // Draw positive classified windows
+            for (size_t i = 0; i < found.size(); i++)
+            {
+                Rect r = found[i];
+                rectangle(img_to_show, r.tl(), r.br(), Scalar(0, 255, 0), 3);
+            }
+
+            if (use_gpu)
+                putText(img_to_show, "Mode: GPU", Point(5, 25), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+            else
+                putText(img_to_show, "Mode: CPU", Point(5, 25), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+            putText(img_to_show, "FPS HOG: " + hogWorkFps(), Point(5, 65), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+            putText(img_to_show, "FPS total: " + workFps(), Point(5, 105), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+            imshow("opencv_gpu_hog", img_to_show);
+
+            if (args.src_is_video || args.src_is_camera) vc >> frame;
+            if (args.src_is_folder) {
+                count++;
+                if (count < filenames.size()) {
+                    frame = imread(filenames[count]);
+                } else {
+                    Mat empty;
+                    frame = empty;
+                }
+            }
+
+            workEnd();
+
+            if (args.write_video)
+            {
+                if (!video_writer.isOpened())
+                {
+                    video_writer.open(args.dst_video, VideoWriter::fourcc('x','v','i','d'), args.dst_video_fps,
+                                      img_to_show.size(), true);
+                    if (!video_writer.isOpened())
+                        throw std::runtime_error("can't create video writer");
+                }
+
+                if (make_gray) cvtColor(img_to_show, img, COLOR_GRAY2BGR);
+                else cvtColor(img_to_show, img, COLOR_BGRA2BGR);
+
+                video_writer << img;
+            }
+
+            handleKey((char)waitKey(3));
+        }
+    }
+}
+
+
+void App::handleKey(char key)
+{
+    switch (key)
+    {
+    case 27:
+        running = false;
+        break;
+    case 'm':
+    case 'M':
+        use_gpu = !use_gpu;
+        cout << "Switched to " << (use_gpu ? "CUDA" : "CPU") << " mode\n";
+        break;
+    case 'g':
+    case 'G':
+        make_gray = !make_gray;
+        cout << "Convert image to gray: " << (make_gray ? "YES" : "NO") << endl;
+        break;
+    case '1':
+        scale *= 1.05;
+        cout << "Scale: " << scale << endl;
+        break;
+    case 'q':
+    case 'Q':
+        scale /= 1.05;
+        cout << "Scale: " << scale << endl;
+        break;
+    case '2':
+        nlevels++;
+        cout << "Levels number: " << nlevels << endl;
+        break;
+    case 'w':
+    case 'W':
+        nlevels = max(nlevels - 1, 1);
+        cout << "Levels number: " << nlevels << endl;
+        break;
+    case '3':
+        gr_threshold++;
+        cout << "Group threshold: " << gr_threshold << endl;
+        break;
+    case 'e':
+    case 'E':
+        gr_threshold = max(0, gr_threshold - 1);
+        cout << "Group threshold: " << gr_threshold << endl;
+        break;
+    case '4':
+        hit_threshold+=0.25;
+        cout << "Hit threshold: " << hit_threshold << endl;
+        break;
+    case 'r':
+    case 'R':
+        hit_threshold = max(0.0, hit_threshold - 0.25);
+        cout << "Hit threshold: " << hit_threshold << endl;
+        break;
+    case 'c':
+    case 'C':
+        gamma_corr = !gamma_corr;
+        cout << "Gamma correction: " << gamma_corr << endl;
+        break;
+    }
+}
+
+
+inline void App::hogWorkBegin() { hog_work_begin = getTickCount(); }
+
+inline void App::hogWorkEnd()
+{
+    int64 delta = getTickCount() - hog_work_begin;
+    double freq = getTickFrequency();
+    hog_work_fps = freq / delta;
+}
+
+inline string App::hogWorkFps() const
+{
+    stringstream ss;
+    ss << hog_work_fps;
+    return ss.str();
+}
+
+
+inline void App::workBegin() { work_begin = getTickCount(); }
+
+inline void App::workEnd()
+{
+    int64 delta = getTickCount() - work_begin;
+    double freq = getTickFrequency();
+    work_fps = freq / delta;
+}
+
+inline string App::workFps() const
+{
+    stringstream ss;
+    ss << work_fps;
+    return ss.str();
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/houghlines.cpp b/C++/opencv-4.7.0/samples/gpu/houghlines.cpp
new file mode 100644
index 00000000..040ef289
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/houghlines.cpp
@@ -0,0 +1,90 @@
+#include <cmath>
+#include <iostream>
+
+#include "opencv2/core.hpp"
+#include <opencv2/core/utility.hpp>
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/cudaimgproc.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::cuda;
+
+static void help()
+{
+    cout << "This program demonstrates line finding with the Hough transform." << endl;
+    cout << "Usage:" << endl;
+    cout << "./gpu-example-houghlines <image_name>, Default is ../data/pic1.png\n" << endl;
+}
+
+int main(int argc, const char* argv[])
+{
+    const string filename = argc >= 2 ? argv[1] : "../data/pic1.png";
+
+    Mat src = imread(filename, IMREAD_GRAYSCALE);
+    if (src.empty())
+    {
+        help();
+        cout << "can not open " << filename << endl;
+        return -1;
+    }
+
+    Mat mask;
+    cv::Canny(src, mask, 100, 200, 3);
+
+    Mat dst_cpu;
+    cv::cvtColor(mask, dst_cpu, COLOR_GRAY2BGR);
+    Mat dst_gpu = dst_cpu.clone();
+
+    vector<Vec4i> lines_cpu;
+    {
+        const int64 start = getTickCount();
+
+        cv::HoughLinesP(mask, lines_cpu, 1, CV_PI / 180, 50, 60, 5);
+
+        const double timeSec = (getTickCount() - start) / getTickFrequency();
+        cout << "CPU Time : " << timeSec * 1000 << " ms" << endl;
+        cout << "CPU Found : " << lines_cpu.size() << endl;
+    }
+
+    for (size_t i = 0; i < lines_cpu.size(); ++i)
+    {
+        Vec4i l = lines_cpu[i];
+        line(dst_cpu, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 3, LINE_AA);
+    }
+
+    GpuMat d_src(mask);
+    GpuMat d_lines;
+    {
+        const int64 start = getTickCount();
+
+        Ptr<cuda::HoughSegmentDetector> hough = cuda::createHoughSegmentDetector(1.0f, (float) (CV_PI / 180.0f), 50, 5);
+
+        hough->detect(d_src, d_lines);
+
+        const double timeSec = (getTickCount() - start) / getTickFrequency();
+        cout << "GPU Time : " << timeSec * 1000 << " ms" << endl;
+        cout << "GPU Found : " << d_lines.cols << endl;
+    }
+    vector<Vec4i> lines_gpu;
+    if (!d_lines.empty())
+    {
+        lines_gpu.resize(d_lines.cols);
+        Mat h_lines(1, d_lines.cols, CV_32SC4, &lines_gpu[0]);
+        d_lines.download(h_lines);
+    }
+
+    for (size_t i = 0; i < lines_gpu.size(); ++i)
+    {
+        Vec4i l = lines_gpu[i];
+        line(dst_gpu, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 3, LINE_AA);
+    }
+
+    imshow("source", src);
+    imshow("detected lines [CPU]", dst_cpu);
+    imshow("detected lines [GPU]", dst_gpu);
+    waitKey();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/morphology.cpp b/C++/opencv-4.7.0/samples/gpu/morphology.cpp
new file mode 100644
index 00000000..b5e50caa
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/morphology.cpp
@@ -0,0 +1,186 @@
+#include <iostream>
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/cudafilters.hpp"
+#include "opencv2/cudaimgproc.hpp"
+
+using namespace std;
+using namespace cv;
+
+class App
+{
+public:
+    App(int argc, const char* argv[]);
+
+    int run();
+
+private:
+    void help();
+
+    void OpenClose();
+    void ErodeDilate();
+
+    static void OpenCloseCallback(int, void*);
+    static void ErodeDilateCallback(int, void*);
+
+    cuda::GpuMat src, dst;
+
+    int element_shape;
+
+    int max_iters;
+    int open_close_pos;
+    int erode_dilate_pos;
+};
+
+App::App(int argc, const char* argv[])
+{
+    element_shape = MORPH_RECT;
+    open_close_pos = erode_dilate_pos = max_iters = 10;
+
+    if (argc == 2 && String(argv[1]) == "--help")
+    {
+        help();
+        exit(0);
+    }
+
+    String filename = argc == 2 ? argv[1] : "../data/baboon.jpg";
+
+    Mat img = imread(filename);
+    if (img.empty())
+    {
+        cerr << "Can't open image " << filename.c_str() << endl;
+        exit(-1);
+    }
+
+    src.upload(img);
+    if (src.channels() == 3)
+    {
+        // gpu support only 4th channel images
+        cuda::GpuMat src4ch;
+        cuda::cvtColor(src, src4ch, COLOR_BGR2BGRA);
+        src = src4ch;
+    }
+
+    help();
+
+    cuda::printShortCudaDeviceInfo(cuda::getDevice());
+}
+
+int App::run()
+{
+    // create windows for output images
+    namedWindow("Open/Close");
+    namedWindow("Erode/Dilate");
+
+    createTrackbar("iterations", "Open/Close", &open_close_pos, max_iters * 2 + 1, OpenCloseCallback, this);
+    createTrackbar("iterations", "Erode/Dilate", &erode_dilate_pos, max_iters * 2 + 1, ErodeDilateCallback, this);
+
+    for(;;)
+    {
+        OpenClose();
+        ErodeDilate();
+
+        char c = (char) waitKey();
+
+        switch (c)
+        {
+        case 27:
+            return 0;
+            break;
+
+        case 'e':
+            element_shape = MORPH_ELLIPSE;
+            break;
+
+        case 'r':
+            element_shape = MORPH_RECT;
+            break;
+
+        case 'c':
+            element_shape = MORPH_CROSS;
+            break;
+
+        case ' ':
+            element_shape = (element_shape + 1) % 3;
+            break;
+        }
+    }
+}
+
+void App::help()
+{
+    cout << "Show off image morphology: erosion, dialation, open and close \n";
+    cout << "Call: \n";
+    cout << "   gpu-example-morphology [image] \n";
+    cout << "This program also shows use of rect, ellipse and cross kernels \n" << endl;
+
+    cout << "Hot keys: \n";
+    cout << "\tESC - quit the program \n";
+    cout << "\tr - use rectangle structuring element \n";
+    cout << "\te - use elliptic structuring element \n";
+    cout << "\tc - use cross-shaped structuring element \n";
+    cout << "\tSPACE - loop through all the options \n" << endl;
+}
+
+void App::OpenClose()
+{
+    int n = open_close_pos - max_iters;
+    int an = n > 0 ? n : -n;
+
+    Mat element = getStructuringElement(element_shape, Size(an*2+1, an*2+1), Point(an, an));
+
+    if (n < 0)
+    {
+        Ptr<cuda::Filter> openFilter = cuda::createMorphologyFilter(MORPH_OPEN, src.type(), element);
+        openFilter->apply(src, dst);
+    }
+    else
+    {
+        Ptr<cuda::Filter> closeFilter = cuda::createMorphologyFilter(MORPH_CLOSE, src.type(), element);
+        closeFilter->apply(src, dst);
+    }
+
+    Mat h_dst(dst);
+    imshow("Open/Close", h_dst);
+}
+
+void App::ErodeDilate()
+{
+    int n = erode_dilate_pos - max_iters;
+    int an = n > 0 ? n : -n;
+
+    Mat element = getStructuringElement(element_shape, Size(an*2+1, an*2+1), Point(an, an));
+
+    if (n < 0)
+    {
+        Ptr<cuda::Filter> erodeFilter = cuda::createMorphologyFilter(MORPH_ERODE, src.type(), element);
+        erodeFilter->apply(src, dst);
+    }
+    else
+    {
+        Ptr<cuda::Filter> dilateFilter = cuda::createMorphologyFilter(MORPH_DILATE, src.type(), element);
+        dilateFilter->apply(src, dst);
+    }
+
+    Mat h_dst(dst);
+    imshow("Erode/Dilate", h_dst);
+}
+
+void App::OpenCloseCallback(int, void* data)
+{
+    App* thiz = (App*) data;
+    thiz->OpenClose();
+}
+
+void App::ErodeDilateCallback(int, void* data)
+{
+    App* thiz = (App*) data;
+    thiz->ErodeDilate();
+}
+
+int main(int argc, const char* argv[])
+{
+    App app(argc, argv);
+    return app.run();
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/multi.cpp b/C++/opencv-4.7.0/samples/gpu/multi.cpp
new file mode 100644
index 00000000..c3ef9b96
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/multi.cpp
@@ -0,0 +1,95 @@
+/* This sample demonstrates the way you can perform independent tasks
+   on the different GPUs */
+
+// Disable some warnings which are caused with CUDA headers
+#if defined(_MSC_VER)
+#pragma warning(disable: 4201 4408 4100)
+#endif
+
+#include <iostream>
+#include "opencv2/core.hpp"
+#include "opencv2/cudaarithm.hpp"
+
+#if !defined(HAVE_CUDA)
+
+int main()
+{
+    std::cout << "CUDA support is required (OpenCV CMake parameter 'WITH_CUDA' must be true)." << std::endl;
+    return 0;
+}
+
+#else
+
+using namespace std;
+using namespace cv;
+using namespace cv::cuda;
+
+struct Worker : public cv::ParallelLoopBody
+{
+    void operator()(const Range& r) const CV_OVERRIDE
+    {
+        for (int i = r.start; i < r.end; ++i) { this->operator()(i); }
+    }
+    void operator()(int device_id) const;
+};
+
+int main()
+{
+    int num_devices = getCudaEnabledDeviceCount();
+    if (num_devices < 2)
+    {
+        std::cout << "Two or more GPUs are required\n";
+        return -1;
+    }
+    for (int i = 0; i < num_devices; ++i)
+    {
+        cv::cuda::printShortCudaDeviceInfo(i);
+
+        DeviceInfo dev_info(i);
+        if (!dev_info.isCompatible())
+        {
+            std::cout << "CUDA module isn't built for GPU #" << i << " ("
+                 << dev_info.name() << ", CC " << dev_info.majorVersion()
+                 << dev_info.minorVersion() << "\n";
+            return -1;
+        }
+    }
+
+    // Execute calculation in two threads using two GPUs
+    cv::Range devices(0, 2);
+    cv::parallel_for_(devices, Worker(), devices.size());
+
+    return 0;
+}
+
+
+void Worker::operator()(int device_id) const
+{
+    setDevice(device_id);
+
+    Mat src(1000, 1000, CV_32F);
+    Mat dst;
+
+    RNG rng(0);
+    rng.fill(src, RNG::UNIFORM, 0, 1);
+
+    // CPU works
+    cv::transpose(src, dst);
+
+    // GPU works
+    GpuMat d_src(src);
+    GpuMat d_dst;
+    cuda::transpose(d_src, d_dst);
+
+    // Check results
+    bool passed = cv::norm(dst - Mat(d_dst), NORM_INF) < 1e-3;
+    std::cout << "GPU #" << device_id << " (" << DeviceInfo().name() << "): "
+        << (passed ? "passed" : "FAILED") << endl;
+
+    // Deallocate data here, otherwise deallocation will be performed
+    // after context is extracted from the stack
+    d_src.release();
+    d_dst.release();
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/gpu/pyrlk_optical_flow.cpp b/C++/opencv-4.7.0/samples/gpu/pyrlk_optical_flow.cpp
new file mode 100644
index 00000000..fa6b3763
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/pyrlk_optical_flow.cpp
@@ -0,0 +1,331 @@
+#include <iostream>
+#include <vector>
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/video.hpp>
+#include <opencv2/cudaoptflow.hpp>
+#include <opencv2/cudaimgproc.hpp>
+#include <opencv2/cudaarithm.hpp>
+
+using namespace std;
+using namespace cv;
+using namespace cv::cuda;
+
+static void download(const GpuMat& d_mat, vector<Point2f>& vec)
+{
+    vec.resize(d_mat.cols);
+    Mat mat(1, d_mat.cols, CV_32FC2, (void*)&vec[0]);
+    d_mat.download(mat);
+}
+
+static void download(const GpuMat& d_mat, vector<uchar>& vec)
+{
+    vec.resize(d_mat.cols);
+    Mat mat(1, d_mat.cols, CV_8UC1, (void*)&vec[0]);
+    d_mat.download(mat);
+}
+
+static void drawArrows(Mat& frame, const vector<Point2f>& prevPts, const vector<Point2f>& nextPts, const vector<uchar>& status, Scalar line_color = Scalar(0, 0, 255))
+{
+    for (size_t i = 0; i < prevPts.size(); ++i)
+    {
+        if (status[i])
+        {
+            int line_thickness = 1;
+
+            Point p = prevPts[i];
+            Point q = nextPts[i];
+
+            double angle = atan2((double) p.y - q.y, (double) p.x - q.x);
+
+            double hypotenuse = sqrt( (double)(p.y - q.y)*(p.y - q.y) + (double)(p.x - q.x)*(p.x - q.x) );
+
+            if (hypotenuse < 1.0)
+                continue;
+
+            // Here we lengthen the arrow by a factor of three.
+            q.x = (int) (p.x - 3 * hypotenuse * cos(angle));
+            q.y = (int) (p.y - 3 * hypotenuse * sin(angle));
+
+            // Now we draw the main line of the arrow.
+            line(frame, p, q, line_color, line_thickness);
+
+            // Now draw the tips of the arrow. I do some scaling so that the
+            // tips look proportional to the main line of the arrow.
+
+            p.x = (int) (q.x + 9 * cos(angle + CV_PI / 4));
+            p.y = (int) (q.y + 9 * sin(angle + CV_PI / 4));
+            line(frame, p, q, line_color, line_thickness);
+
+            p.x = (int) (q.x + 9 * cos(angle - CV_PI / 4));
+            p.y = (int) (q.y + 9 * sin(angle - CV_PI / 4));
+            line(frame, p, q, line_color, line_thickness);
+        }
+    }
+}
+
+inline bool isFlowCorrect(Point2f u)
+{
+    return !cvIsNaN(u.x) && !cvIsNaN(u.y) && fabs(u.x) < 1e9 && fabs(u.y) < 1e9;
+}
+
+static Vec3b computeColor(float fx, float fy)
+{
+    static bool first = true;
+
+    // relative lengths of color transitions:
+    // these are chosen based on perceptual similarity
+    // (e.g. one can distinguish more shades between red and yellow
+    //  than between yellow and green)
+    const int RY = 15;
+    const int YG = 6;
+    const int GC = 4;
+    const int CB = 11;
+    const int BM = 13;
+    const int MR = 6;
+    const int NCOLS = RY + YG + GC + CB + BM + MR;
+    static Vec3i colorWheel[NCOLS];
+
+    if (first)
+    {
+        int k = 0;
+
+        for (int i = 0; i < RY; ++i, ++k)
+            colorWheel[k] = Vec3i(255, 255 * i / RY, 0);
+
+        for (int i = 0; i < YG; ++i, ++k)
+            colorWheel[k] = Vec3i(255 - 255 * i / YG, 255, 0);
+
+        for (int i = 0; i < GC; ++i, ++k)
+            colorWheel[k] = Vec3i(0, 255, 255 * i / GC);
+
+        for (int i = 0; i < CB; ++i, ++k)
+            colorWheel[k] = Vec3i(0, 255 - 255 * i / CB, 255);
+
+        for (int i = 0; i < BM; ++i, ++k)
+            colorWheel[k] = Vec3i(255 * i / BM, 0, 255);
+
+        for (int i = 0; i < MR; ++i, ++k)
+            colorWheel[k] = Vec3i(255, 0, 255 - 255 * i / MR);
+
+        first = false;
+    }
+
+    const float rad = sqrt(fx * fx + fy * fy);
+    const float a = atan2(-fy, -fx) / (float)CV_PI;
+
+    const float fk = (a + 1.0f) / 2.0f * (NCOLS - 1);
+    const int k0 = static_cast<int>(fk);
+    const int k1 = (k0 + 1) % NCOLS;
+    const float f = fk - k0;
+
+    Vec3b pix;
+
+    for (int b = 0; b < 3; b++)
+    {
+        const float col0 = colorWheel[k0][b] / 255.0f;
+        const float col1 = colorWheel[k1][b] / 255.0f;
+
+        float col = (1 - f) * col0 + f * col1;
+
+        if (rad <= 1)
+            col = 1 - rad * (1 - col); // increase saturation with radius
+        else
+            col *= .75; // out of range
+
+        pix[2 - b] = static_cast<uchar>(255.0 * col);
+    }
+
+    return pix;
+}
+
+static void drawOpticalFlow(const Mat_<float>& flowx, const Mat_<float>& flowy, Mat& dst, float maxmotion = -1)
+{
+    dst.create(flowx.size(), CV_8UC3);
+    dst.setTo(Scalar::all(0));
+
+    // determine motion range:
+    float maxrad = maxmotion;
+
+    if (maxmotion <= 0)
+    {
+        maxrad = 1;
+        for (int y = 0; y < flowx.rows; ++y)
+        {
+            for (int x = 0; x < flowx.cols; ++x)
+            {
+                Point2f u(flowx(y, x), flowy(y, x));
+
+                if (!isFlowCorrect(u))
+                    continue;
+
+                maxrad = max(maxrad, sqrt(u.x * u.x + u.y * u.y));
+            }
+        }
+    }
+
+    for (int y = 0; y < flowx.rows; ++y)
+    {
+        for (int x = 0; x < flowx.cols; ++x)
+        {
+            Point2f u(flowx(y, x), flowy(y, x));
+
+            if (isFlowCorrect(u))
+                dst.at<Vec3b>(y, x) = computeColor(u.x / maxrad, u.y / maxrad);
+        }
+    }
+}
+
+static void showFlow(const char* name, const GpuMat& d_flow)
+{
+    GpuMat planes[2];
+    cuda::split(d_flow, planes);
+
+    Mat flowx(planes[0]);
+    Mat flowy(planes[1]);
+
+    Mat out;
+    drawOpticalFlow(flowx, flowy, out, 10);
+
+    imshow(name, out);
+}
+
+template <typename T> inline T clamp (T x, T a, T b)
+{
+    return ((x) > (a) ? ((x) < (b) ? (x) : (b)) : (a));
+}
+
+template <typename T> inline T mapValue(T x, T a, T b, T c, T d)
+{
+    x = clamp(x, a, b);
+    return c + (d - c) * (x - a) / (b - a);
+}
+
+int main(int argc, const char* argv[])
+{
+    const char* keys =
+        "{ h             help   |        | print help message }"
+        "{ l             left   | ../data/pic1.png       | specify left image }"
+        "{ r             right  | ../data/pic2.png       | specify right image }"
+        "{ flow                 | sparse | specify flow type [PyrLK] }"
+        "{ gray                 |        | use grayscale sources [PyrLK Sparse] }"
+        "{ win_size             | 21     | specify windows size [PyrLK] }"
+        "{ max_level            | 3      | specify max level [PyrLK] }"
+        "{ iters                | 30     | specify iterations count [PyrLK] }"
+        "{ points               | 4000   | specify points count [GoodFeatureToTrack] }"
+        "{ min_dist             | 0      | specify minimal distance between points [GoodFeatureToTrack] }";
+
+    CommandLineParser cmd(argc, argv, keys);
+
+    if (cmd.has("help") || !cmd.check())
+    {
+        cmd.printMessage();
+        cmd.printErrors();
+        return 0;
+    }
+
+    string fname0 = cmd.get<string>("left");
+    string fname1 = cmd.get<string>("right");
+
+    if (fname0.empty() || fname1.empty())
+    {
+        cerr << "Missing input file names" << endl;
+        return -1;
+    }
+
+    string flow_type = cmd.get<string>("flow");
+    bool is_sparse = true;
+    if (flow_type == "sparse")
+    {
+        is_sparse = true;
+    }
+    else if (flow_type == "dense")
+    {
+        is_sparse = false;
+    }
+    else
+    {
+        cerr << "please specify 'sparse' or 'dense' as flow type" << endl;
+        return -1;
+    }
+
+    bool useGray = cmd.has("gray");
+    int winSize = cmd.get<int>("win_size");
+    int maxLevel = cmd.get<int>("max_level");
+    int iters = cmd.get<int>("iters");
+    int points = cmd.get<int>("points");
+    double minDist = cmd.get<double>("min_dist");
+
+    Mat frame0 = imread(fname0);
+    Mat frame1 = imread(fname1);
+
+    if (frame0.empty() || frame1.empty())
+    {
+        cout << "Can't load input images" << endl;
+        return -1;
+    }
+
+    cout << "Image size : " << frame0.cols << " x " << frame0.rows << endl;
+    cout << "Points count : " << points << endl;
+
+    cout << endl;
+
+    Mat frame0Gray;
+    cv::cvtColor(frame0, frame0Gray, COLOR_BGR2GRAY);
+    Mat frame1Gray;
+    cv::cvtColor(frame1, frame1Gray, COLOR_BGR2GRAY);
+
+    // goodFeaturesToTrack
+    GpuMat d_frame0Gray(frame0Gray);
+    GpuMat d_prevPts;
+
+    Ptr<cuda::CornersDetector> detector = cuda::createGoodFeaturesToTrackDetector(d_frame0Gray.type(), points, 0.01, minDist);
+    detector->detect(d_frame0Gray, d_prevPts);
+
+    GpuMat d_frame0(frame0);
+    GpuMat d_frame1(frame1);
+    GpuMat d_frame1Gray(frame1Gray);
+    GpuMat d_nextPts;
+    GpuMat d_status;
+    GpuMat d_flow(frame0.size(), CV_32FC2);
+
+    if (is_sparse)
+    {
+        // Sparse
+        Ptr<cuda::SparsePyrLKOpticalFlow> d_pyrLK_sparse = cuda::SparsePyrLKOpticalFlow::create(
+            Size(winSize, winSize), maxLevel, iters);
+        d_pyrLK_sparse->calc(useGray ? d_frame0Gray : d_frame0, useGray ? d_frame1Gray : d_frame1, d_prevPts, d_nextPts, d_status);
+
+        // Draw arrows
+        vector<Point2f> prevPts(d_prevPts.cols);
+        download(d_prevPts, prevPts);
+
+        vector<Point2f> nextPts(d_nextPts.cols);
+        download(d_nextPts, nextPts);
+
+        vector<uchar> status(d_status.cols);
+        download(d_status, status);
+
+        namedWindow("PyrLK [Sparse]", WINDOW_NORMAL);
+        drawArrows(frame0, prevPts, nextPts, status, Scalar(255, 0, 0));
+        imshow("PyrLK [Sparse]", frame0);
+    }
+    else
+    {
+        // Dense
+        Ptr<cuda::DensePyrLKOpticalFlow> d_pyrLK_dense = cuda::DensePyrLKOpticalFlow::create(
+            Size(winSize, winSize), maxLevel, iters);
+        d_pyrLK_dense->calc(d_frame0Gray, d_frame1Gray, d_flow);
+
+        // Draw flows
+        namedWindow("PyrLK [Dense] Flow Field", WINDOW_NORMAL);
+        showFlow("PyrLK [Dense] Flow Field", d_flow);
+    }
+
+    waitKey(0);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/gpu/stereo_match.cpp b/C++/opencv-4.7.0/samples/gpu/stereo_match.cpp
new file mode 100644
index 00000000..6a79a46b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/stereo_match.cpp
@@ -0,0 +1,382 @@
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+#include <opencv2/core/utility.hpp>
+#include "opencv2/cudastereo.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+using namespace cv;
+using namespace std;
+
+bool help_showed = false;
+
+struct Params
+{
+    Params();
+    static Params read(int argc, char** argv);
+
+    string left;
+    string right;
+
+    string method_str() const
+    {
+        switch (method)
+        {
+        case BM: return "BM";
+        case BP: return "BP";
+        case CSBP: return "CSBP";
+        }
+        return "";
+    }
+    enum {BM, BP, CSBP} method;
+    int ndisp; // Max disparity + 1
+};
+
+
+struct App
+{
+    App(const Params& p);
+    void run();
+    void handleKey(char key);
+    void printParams() const;
+
+    void workBegin() { work_begin = getTickCount(); }
+    void workEnd()
+    {
+        int64 d = getTickCount() - work_begin;
+        double f = getTickFrequency();
+        work_fps = f / d;
+    }
+
+    string text() const
+    {
+        stringstream ss;
+        ss << "(" << p.method_str() << ") FPS: " << setiosflags(ios::left)
+            << setprecision(4) << work_fps;
+        return ss.str();
+    }
+private:
+    Params p;
+    bool running;
+
+    Mat left_src, right_src;
+    Mat left, right;
+    cuda::GpuMat d_left, d_right;
+
+    Ptr<cuda::StereoBM> bm;
+    Ptr<cuda::StereoBeliefPropagation> bp;
+    Ptr<cuda::StereoConstantSpaceBP> csbp;
+
+    int64 work_begin;
+    double work_fps;
+};
+
+static void printHelp()
+{
+    cout << "Usage: stereo_match\n"
+        << "\t--left <left_view> --right <right_view> # must be rectified\n"
+        << "\t--method <stereo_match_method> # BM | BP | CSBP\n"
+        << "\t--ndisp <number> # number of disparity levels\n";
+    help_showed = true;
+}
+
+int main(int argc, char** argv)
+{
+    try
+    {
+        if (argc < 2)
+        {
+            printHelp();
+            return 1;
+        }
+        Params args = Params::read(argc, argv);
+        if (help_showed)
+            return -1;
+        App app(args);
+        app.run();
+    }
+    catch (const exception& e)
+    {
+        cout << "error: " << e.what() << endl;
+    }
+    return 0;
+}
+
+
+Params::Params()
+{
+    method = BM;
+    ndisp = 64;
+}
+
+
+Params Params::read(int argc, char** argv)
+{
+    Params p;
+
+    for (int i = 1; i < argc; i++)
+    {
+        if (string(argv[i]) == "--left") p.left = argv[++i];
+        else if (string(argv[i]) == "--right") p.right = argv[++i];
+        else if (string(argv[i]) == "--method")
+        {
+            if (string(argv[i + 1]) == "BM") p.method = BM;
+            else if (string(argv[i + 1]) == "BP") p.method = BP;
+            else if (string(argv[i + 1]) == "CSBP") p.method = CSBP;
+            else throw runtime_error("unknown stereo match method: " + string(argv[i + 1]));
+            i++;
+        }
+        else if (string(argv[i]) == "--ndisp") p.ndisp = atoi(argv[++i]);
+        else if (string(argv[i]) == "--help") printHelp();
+        else throw runtime_error("unknown key: " + string(argv[i]));
+    }
+
+    return p;
+}
+
+
+App::App(const Params& params)
+    : p(params), running(false)
+{
+    cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());
+
+    cout << "stereo_match_gpu sample\n";
+    cout << "\nControls:\n"
+        << "\tesc - exit\n"
+        << "\tp - print current parameters\n"
+        << "\tg - convert source images into gray\n"
+        << "\tm - change stereo match method\n"
+        << "\ts - change Sobel prefiltering flag (for BM only)\n"
+        << "\t1/q - increase/decrease maximum disparity\n"
+        << "\t2/w - increase/decrease window size (for BM only)\n"
+        << "\t3/e - increase/decrease iteration count (for BP and CSBP only)\n"
+        << "\t4/r - increase/decrease level count (for BP and CSBP only)\n";
+}
+
+
+void App::run()
+{
+    // Load images
+    left_src = imread(p.left);
+    right_src = imread(p.right);
+    if (left_src.empty()) throw runtime_error("can't open file \"" + p.left + "\"");
+    if (right_src.empty()) throw runtime_error("can't open file \"" + p.right + "\"");
+    cvtColor(left_src, left, COLOR_BGR2GRAY);
+    cvtColor(right_src, right, COLOR_BGR2GRAY);
+    d_left.upload(left);
+    d_right.upload(right);
+
+    imshow("left", left);
+    imshow("right", right);
+
+    // Set common parameters
+    bm = cuda::createStereoBM(p.ndisp);
+    bp = cuda::createStereoBeliefPropagation(p.ndisp);
+    csbp = cv::cuda::createStereoConstantSpaceBP(p.ndisp);
+
+    // Prepare disparity map of specified type
+    Mat disp(left.size(), CV_8U);
+    cuda::GpuMat d_disp(left.size(), CV_8U);
+
+    cout << endl;
+    printParams();
+
+    running = true;
+    while (running)
+    {
+        workBegin();
+        switch (p.method)
+        {
+        case Params::BM:
+            if (d_left.channels() > 1 || d_right.channels() > 1)
+            {
+                cout << "BM doesn't support color images\n";
+                cvtColor(left_src, left, COLOR_BGR2GRAY);
+                cvtColor(right_src, right, COLOR_BGR2GRAY);
+                cout << "image_channels: " << left.channels() << endl;
+                d_left.upload(left);
+                d_right.upload(right);
+                imshow("left", left);
+                imshow("right", right);
+            }
+            bm->compute(d_left, d_right, d_disp);
+            break;
+        case Params::BP: bp->compute(d_left, d_right, d_disp); break;
+        case Params::CSBP: csbp->compute(d_left, d_right, d_disp); break;
+        }
+        workEnd();
+
+        // Show results
+        d_disp.download(disp);
+        putText(disp, text(), Point(5, 25), FONT_HERSHEY_SIMPLEX, 1.0, Scalar::all(255));
+        imshow("disparity", (Mat_<uchar>)disp);
+
+        handleKey((char)waitKey(3));
+    }
+}
+
+
+void App::printParams() const
+{
+    cout << "--- Parameters ---\n";
+    cout << "image_size: (" << left.cols << ", " << left.rows << ")\n";
+    cout << "image_channels: " << left.channels() << endl;
+    cout << "method: " << p.method_str() << endl
+        << "ndisp: " << p.ndisp << endl;
+    switch (p.method)
+    {
+    case Params::BM:
+        cout << "win_size: " << bm->getBlockSize() << endl;
+        cout << "prefilter_sobel: " << bm->getPreFilterType() << endl;
+        break;
+    case Params::BP:
+        cout << "iter_count: " << bp->getNumIters() << endl;
+        cout << "level_count: " << bp->getNumLevels() << endl;
+        break;
+    case Params::CSBP:
+        cout << "iter_count: " << csbp->getNumIters() << endl;
+        cout << "level_count: " << csbp->getNumLevels() << endl;
+        break;
+    }
+    cout << endl;
+}
+
+
+void App::handleKey(char key)
+{
+    switch (key)
+    {
+    case 27:
+        running = false;
+        break;
+    case 'p': case 'P':
+        printParams();
+        break;
+    case 'g': case 'G':
+        if (left.channels() == 1 && p.method != Params::BM)
+        {
+            left = left_src;
+            right = right_src;
+        }
+        else
+        {
+            cvtColor(left_src, left, COLOR_BGR2GRAY);
+            cvtColor(right_src, right, COLOR_BGR2GRAY);
+        }
+        d_left.upload(left);
+        d_right.upload(right);
+        cout << "image_channels: " << left.channels() << endl;
+        imshow("left", left);
+        imshow("right", right);
+        break;
+    case 'm': case 'M':
+        switch (p.method)
+        {
+        case Params::BM:
+            p.method = Params::BP;
+            break;
+        case Params::BP:
+            p.method = Params::CSBP;
+            break;
+        case Params::CSBP:
+            p.method = Params::BM;
+            break;
+        }
+        cout << "method: " << p.method_str() << endl;
+        break;
+    case 's': case 'S':
+        if (p.method == Params::BM)
+        {
+            switch (bm->getPreFilterType())
+            {
+            case 0:
+                bm->setPreFilterType(cv::StereoBM::PREFILTER_XSOBEL);
+                break;
+            case cv::StereoBM::PREFILTER_XSOBEL:
+                bm->setPreFilterType(0);
+                break;
+            }
+            cout << "prefilter_sobel: " << bm->getPreFilterType() << endl;
+        }
+        break;
+    case '1':
+        p.ndisp = p.ndisp == 1 ? 8 : p.ndisp + 8;
+        cout << "ndisp: " << p.ndisp << endl;
+        bm->setNumDisparities(p.ndisp);
+        bp->setNumDisparities(p.ndisp);
+        csbp->setNumDisparities(p.ndisp);
+        break;
+    case 'q': case 'Q':
+        p.ndisp = max(p.ndisp - 8, 1);
+        cout << "ndisp: " << p.ndisp << endl;
+        bm->setNumDisparities(p.ndisp);
+        bp->setNumDisparities(p.ndisp);
+        csbp->setNumDisparities(p.ndisp);
+        break;
+    case '2':
+        if (p.method == Params::BM)
+        {
+            bm->setBlockSize(min(bm->getBlockSize() + 1, 51));
+            cout << "win_size: " << bm->getBlockSize() << endl;
+        }
+        break;
+    case 'w': case 'W':
+        if (p.method == Params::BM)
+        {
+            bm->setBlockSize(max(bm->getBlockSize() - 1, 2));
+            cout << "win_size: " << bm->getBlockSize() << endl;
+        }
+        break;
+    case '3':
+        if (p.method == Params::BP)
+        {
+            bp->setNumIters(bp->getNumIters() + 1);
+            cout << "iter_count: " << bp->getNumIters() << endl;
+        }
+        else if (p.method == Params::CSBP)
+        {
+            csbp->setNumIters(csbp->getNumIters() + 1);
+            cout << "iter_count: " << csbp->getNumIters() << endl;
+        }
+        break;
+    case 'e': case 'E':
+        if (p.method == Params::BP)
+        {
+            bp->setNumIters(max(bp->getNumIters() - 1, 1));
+            cout << "iter_count: " << bp->getNumIters() << endl;
+        }
+        else if (p.method == Params::CSBP)
+        {
+            csbp->setNumIters(max(csbp->getNumIters() - 1, 1));
+            cout << "iter_count: " << csbp->getNumIters() << endl;
+        }
+        break;
+    case '4':
+        if (p.method == Params::BP)
+        {
+            bp->setNumLevels(bp->getNumLevels() + 1);
+            cout << "level_count: " << bp->getNumLevels() << endl;
+        }
+        else if (p.method == Params::CSBP)
+        {
+            csbp->setNumLevels(csbp->getNumLevels() + 1);
+            cout << "level_count: " << csbp->getNumLevels() << endl;
+        }
+        break;
+    case 'r': case 'R':
+        if (p.method == Params::BP)
+        {
+            bp->setNumLevels(max(bp->getNumLevels() - 1, 1));
+            cout << "level_count: " << bp->getNumLevels() << endl;
+        }
+        else if (p.method == Params::CSBP)
+        {
+            csbp->setNumLevels(max(csbp->getNumLevels() - 1, 1));
+            cout << "level_count: " << csbp->getNumLevels() << endl;
+        }
+        break;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/stereo_multi.cpp b/C++/opencv-4.7.0/samples/gpu/stereo_multi.cpp
new file mode 100644
index 00000000..c132d7ff
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/stereo_multi.cpp
@@ -0,0 +1,498 @@
+// This sample demonstrates working on one piece of data using two GPUs.
+// It splits input into two parts and processes them separately on different GPUs.
+
+#ifdef _WIN32
+    #define NOMINMAX
+    #include <windows.h>
+#else
+    #include <pthread.h>
+    #include <unistd.h>
+#endif
+
+#include <iostream>
+#include <iomanip>
+
+#include "opencv2/core.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/cudastereo.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::cuda;
+
+///////////////////////////////////////////////////////////
+// Thread
+// OS-specific wrappers for multi-threading
+
+#ifdef _WIN32
+class Thread
+{
+    struct UserData
+    {
+        void (*func)(void* userData);
+        void* param;
+    };
+
+    static DWORD WINAPI WinThreadFunction(LPVOID lpParam)
+    {
+        UserData* userData = static_cast<UserData*>(lpParam);
+
+        userData->func(userData->param);
+
+        return 0;
+    }
+
+    UserData userData_;
+    HANDLE thread_;
+    DWORD threadId_;
+
+public:
+    Thread(void (*func)(void* userData), void* userData)
+    {
+        userData_.func = func;
+        userData_.param = userData;
+
+        thread_ = CreateThread(
+            NULL,                   // default security attributes
+            0,                      // use default stack size
+            WinThreadFunction,      // thread function name
+            &userData_,             // argument to thread function
+            0,                      // use default creation flags
+            &threadId_);            // returns the thread identifier
+    }
+
+    ~Thread()
+    {
+        CloseHandle(thread_);
+    }
+
+    void wait()
+    {
+        WaitForSingleObject(thread_, INFINITE);
+    }
+};
+#else
+class Thread
+{
+    struct UserData
+    {
+        void (*func)(void* userData);
+        void* param;
+    };
+
+    static void* PThreadFunction(void* lpParam)
+    {
+        UserData* userData = static_cast<UserData*>(lpParam);
+
+        userData->func(userData->param);
+
+        return 0;
+    }
+
+    pthread_t thread_;
+    UserData userData_;
+
+public:
+    Thread(void (*func)(void* userData), void* userData)
+    {
+        userData_.func = func;
+        userData_.param = userData;
+
+        pthread_create(&thread_, NULL, PThreadFunction, &userData_);
+    }
+
+    ~Thread()
+    {
+        pthread_detach(thread_);
+    }
+
+    void wait()
+    {
+        pthread_join(thread_, NULL);
+    }
+};
+#endif
+
+///////////////////////////////////////////////////////////
+// StereoSingleGpu
+// Run Stereo algorithm on single GPU
+
+class StereoSingleGpu
+{
+public:
+    explicit StereoSingleGpu(int deviceId = 0);
+    ~StereoSingleGpu();
+
+    void compute(const Mat& leftFrame, const Mat& rightFrame, Mat& disparity);
+
+private:
+    int deviceId_;
+    GpuMat d_leftFrame;
+    GpuMat d_rightFrame;
+    GpuMat d_disparity;
+    Ptr<cuda::StereoBM> d_alg;
+};
+
+StereoSingleGpu::StereoSingleGpu(int deviceId) : deviceId_(deviceId)
+{
+    cuda::setDevice(deviceId_);
+    d_alg = cuda::createStereoBM(256);
+}
+
+StereoSingleGpu::~StereoSingleGpu()
+{
+    cuda::setDevice(deviceId_);
+    d_leftFrame.release();
+    d_rightFrame.release();
+    d_disparity.release();
+    d_alg.release();
+}
+
+void StereoSingleGpu::compute(const Mat& leftFrame, const Mat& rightFrame, Mat& disparity)
+{
+    cuda::setDevice(deviceId_);
+    d_leftFrame.upload(leftFrame);
+    d_rightFrame.upload(rightFrame);
+    d_alg->compute(d_leftFrame, d_rightFrame, d_disparity);
+    d_disparity.download(disparity);
+}
+
+///////////////////////////////////////////////////////////
+// StereoMultiGpuThread
+// Run Stereo algorithm on two GPUs using different host threads
+
+class StereoMultiGpuThread
+{
+public:
+    StereoMultiGpuThread();
+    ~StereoMultiGpuThread();
+
+    void compute(const Mat& leftFrame, const Mat& rightFrame, Mat& disparity);
+
+private:
+    GpuMat d_leftFrames[2];
+    GpuMat d_rightFrames[2];
+    GpuMat d_disparities[2];
+    Ptr<cuda::StereoBM> d_algs[2];
+
+    struct StereoLaunchData
+    {
+        int deviceId;
+        Mat leftFrame;
+        Mat rightFrame;
+        Mat disparity;
+        GpuMat* d_leftFrame;
+        GpuMat* d_rightFrame;
+        GpuMat* d_disparity;
+        Ptr<cuda::StereoBM> d_alg;
+    };
+
+    static void launchGpuStereoAlg(void* userData);
+};
+
+StereoMultiGpuThread::StereoMultiGpuThread()
+{
+    cuda::setDevice(0);
+    d_algs[0] = cuda::createStereoBM(256);
+
+    cuda::setDevice(1);
+    d_algs[1] = cuda::createStereoBM(256);
+}
+
+StereoMultiGpuThread::~StereoMultiGpuThread()
+{
+    cuda::setDevice(0);
+    d_leftFrames[0].release();
+    d_rightFrames[0].release();
+    d_disparities[0].release();
+    d_algs[0].release();
+
+    cuda::setDevice(1);
+    d_leftFrames[1].release();
+    d_rightFrames[1].release();
+    d_disparities[1].release();
+    d_algs[1].release();
+}
+
+void StereoMultiGpuThread::compute(const Mat& leftFrame, const Mat& rightFrame, Mat& disparity)
+{
+    disparity.create(leftFrame.size(), CV_8UC1);
+
+    // Split input data onto two parts for each GPUs.
+    // We add small border for each part,
+    // because original algorithm doesn't calculate disparity on image borders.
+    // With such padding we will get output in the middle of final result.
+
+    StereoLaunchData launchDatas[2];
+
+    launchDatas[0].deviceId = 0;
+    launchDatas[0].leftFrame = leftFrame.rowRange(0, leftFrame.rows / 2 + 32);
+    launchDatas[0].rightFrame = rightFrame.rowRange(0, rightFrame.rows / 2 + 32);
+    launchDatas[0].disparity = disparity.rowRange(0, leftFrame.rows / 2);
+    launchDatas[0].d_leftFrame = &d_leftFrames[0];
+    launchDatas[0].d_rightFrame = &d_rightFrames[0];
+    launchDatas[0].d_disparity = &d_disparities[0];
+    launchDatas[0].d_alg = d_algs[0];
+
+    launchDatas[1].deviceId = 1;
+    launchDatas[1].leftFrame = leftFrame.rowRange(leftFrame.rows / 2 - 32, leftFrame.rows);
+    launchDatas[1].rightFrame = rightFrame.rowRange(leftFrame.rows / 2 - 32, leftFrame.rows);
+    launchDatas[1].disparity = disparity.rowRange(leftFrame.rows / 2, leftFrame.rows);
+    launchDatas[1].d_leftFrame = &d_leftFrames[1];
+    launchDatas[1].d_rightFrame = &d_rightFrames[1];
+    launchDatas[1].d_disparity = &d_disparities[1];
+    launchDatas[1].d_alg = d_algs[1];
+
+    Thread thread0(launchGpuStereoAlg, &launchDatas[0]);
+    Thread thread1(launchGpuStereoAlg, &launchDatas[1]);
+
+    thread0.wait();
+    thread1.wait();
+}
+
+void StereoMultiGpuThread::launchGpuStereoAlg(void* userData)
+{
+    StereoLaunchData* data = static_cast<StereoLaunchData*>(userData);
+
+    cuda::setDevice(data->deviceId);
+    data->d_leftFrame->upload(data->leftFrame);
+    data->d_rightFrame->upload(data->rightFrame);
+    data->d_alg->compute(*data->d_leftFrame, *data->d_rightFrame, *data->d_disparity);
+
+    if (data->deviceId == 0)
+        data->d_disparity->rowRange(0, data->d_disparity->rows - 32).download(data->disparity);
+    else
+        data->d_disparity->rowRange(32, data->d_disparity->rows).download(data->disparity);
+}
+
+///////////////////////////////////////////////////////////
+// StereoMultiGpuStream
+// Run Stereo algorithm on two GPUs from single host thread using async API
+
+class StereoMultiGpuStream
+{
+public:
+    StereoMultiGpuStream();
+    ~StereoMultiGpuStream();
+
+    void compute(const HostMem& leftFrame, const HostMem& rightFrame, HostMem& disparity);
+
+private:
+    GpuMat d_leftFrames[2];
+    GpuMat d_rightFrames[2];
+    GpuMat d_disparities[2];
+    Ptr<cuda::StereoBM> d_algs[2];
+    Ptr<Stream> streams[2];
+};
+
+StereoMultiGpuStream::StereoMultiGpuStream()
+{
+    cuda::setDevice(0);
+    d_algs[0] = cuda::createStereoBM(256);
+    streams[0] = makePtr<Stream>();
+
+    cuda::setDevice(1);
+    d_algs[1] = cuda::createStereoBM(256);
+    streams[1] = makePtr<Stream>();
+}
+
+StereoMultiGpuStream::~StereoMultiGpuStream()
+{
+    cuda::setDevice(0);
+    d_leftFrames[0].release();
+    d_rightFrames[0].release();
+    d_disparities[0].release();
+    d_algs[0].release();
+    streams[0].release();
+
+    cuda::setDevice(1);
+    d_leftFrames[1].release();
+    d_rightFrames[1].release();
+    d_disparities[1].release();
+    d_algs[1].release();
+    streams[1].release();
+}
+
+void StereoMultiGpuStream::compute(const HostMem& leftFrame, const HostMem& rightFrame, HostMem& disparity)
+{
+    disparity.create(leftFrame.size(), CV_8UC1);
+
+    // Split input data onto two parts for each GPUs.
+    // We add small border for each part,
+    // because original algorithm doesn't calculate disparity on image borders.
+    // With such padding we will get output in the middle of final result.
+
+    Mat leftFrameHdr = leftFrame.createMatHeader();
+    Mat rightFrameHdr = rightFrame.createMatHeader();
+    Mat disparityHdr = disparity.createMatHeader();
+    Mat disparityPart0 = disparityHdr.rowRange(0, leftFrame.rows / 2);
+    Mat disparityPart1 = disparityHdr.rowRange(leftFrame.rows / 2, leftFrame.rows);
+
+    cuda::setDevice(0);
+    d_leftFrames[0].upload(leftFrameHdr.rowRange(0, leftFrame.rows / 2 + 32), *streams[0]);
+    d_rightFrames[0].upload(rightFrameHdr.rowRange(0, leftFrame.rows / 2 + 32), *streams[0]);
+    d_algs[0]->compute(d_leftFrames[0], d_rightFrames[0], d_disparities[0], *streams[0]);
+    d_disparities[0].rowRange(0, leftFrame.rows / 2).download(disparityPart0, *streams[0]);
+
+    cuda::setDevice(1);
+    d_leftFrames[1].upload(leftFrameHdr.rowRange(leftFrame.rows / 2 - 32, leftFrame.rows), *streams[1]);
+    d_rightFrames[1].upload(rightFrameHdr.rowRange(leftFrame.rows / 2 - 32, leftFrame.rows), *streams[1]);
+    d_algs[1]->compute(d_leftFrames[1], d_rightFrames[1], d_disparities[1], *streams[1]);
+    d_disparities[1].rowRange(32, d_disparities[1].rows).download(disparityPart1, *streams[1]);
+
+    cuda::setDevice(0);
+    streams[0]->waitForCompletion();
+
+    cuda::setDevice(1);
+    streams[1]->waitForCompletion();
+}
+
+///////////////////////////////////////////////////////////
+// main
+
+int main(int argc, char** argv)
+{
+    if (argc != 3)
+    {
+        cerr << "Usage: stereo_multi <left_video> <right_video>" << endl;
+        return -1;
+    }
+
+    const int numDevices = getCudaEnabledDeviceCount();
+    if (numDevices != 2)
+    {
+        cerr << "Two GPUs are required" << endl;
+        return -1;
+    }
+
+    for (int i = 0; i < numDevices; ++i)
+    {
+        DeviceInfo devInfo(i);
+        if (!devInfo.isCompatible())
+        {
+            cerr << "CUDA module wasn't built for GPU #" << i << " ("
+                 << devInfo.name() << ", CC " << devInfo.majorVersion()
+                 << devInfo.minorVersion() << endl;
+            return -1;
+        }
+
+        printShortCudaDeviceInfo(i);
+    }
+
+    VideoCapture leftVideo(argv[1]);
+    VideoCapture rightVideo(argv[2]);
+
+    if (!leftVideo.isOpened())
+    {
+         cerr << "Can't open " << argv[1] << " video file" << endl;
+         return -1;
+    }
+
+    if (!rightVideo.isOpened())
+    {
+         cerr << "Can't open " << argv[2] << " video file" << endl;
+         return -1;
+    }
+
+    cout << endl;
+    cout << "This sample demonstrates working on one piece of data using two GPUs." << endl;
+    cout << "It splits input into two parts and processes them separately on different GPUs." << endl;
+    cout << endl;
+
+    Mat leftFrame, rightFrame;
+    HostMem leftGrayFrame, rightGrayFrame;
+
+    StereoSingleGpu gpu0Alg(0);
+    StereoSingleGpu gpu1Alg(1);
+    StereoMultiGpuThread multiThreadAlg;
+    StereoMultiGpuStream multiStreamAlg;
+
+    Mat disparityGpu0;
+    Mat disparityGpu1;
+    Mat disparityMultiThread;
+    HostMem disparityMultiStream;
+
+    Mat disparityGpu0Show;
+    Mat disparityGpu1Show;
+    Mat disparityMultiThreadShow;
+    Mat disparityMultiStreamShow;
+
+    TickMeter tm;
+
+    cout << "-------------------------------------------------------------------" << endl;
+    cout << "| Frame | GPU 0 ms | GPU 1 ms | Multi Thread ms | Multi Stream ms |" << endl;
+    cout << "-------------------------------------------------------------------" << endl;
+
+    for (int i = 0;; ++i)
+    {
+        leftVideo >> leftFrame;
+        rightVideo >> rightFrame;
+
+        if (leftFrame.empty() || rightFrame.empty())
+            break;
+
+        if (leftFrame.size() != rightFrame.size())
+        {
+            cerr << "Frames have different sizes" << endl;
+            return -1;
+        }
+
+        leftGrayFrame.create(leftFrame.size(), CV_8UC1);
+        rightGrayFrame.create(leftFrame.size(), CV_8UC1);
+
+        cvtColor(leftFrame, leftGrayFrame.createMatHeader(), COLOR_BGR2GRAY);
+        cvtColor(rightFrame, rightGrayFrame.createMatHeader(), COLOR_BGR2GRAY);
+
+        tm.reset(); tm.start();
+        gpu0Alg.compute(leftGrayFrame.createMatHeader(), rightGrayFrame.createMatHeader(),
+                        disparityGpu0);
+        tm.stop();
+
+        const double gpu0Time = tm.getTimeMilli();
+
+        tm.reset(); tm.start();
+        gpu1Alg.compute(leftGrayFrame.createMatHeader(), rightGrayFrame.createMatHeader(),
+                        disparityGpu1);
+        tm.stop();
+
+        const double gpu1Time = tm.getTimeMilli();
+
+        tm.reset(); tm.start();
+        multiThreadAlg.compute(leftGrayFrame.createMatHeader(), rightGrayFrame.createMatHeader(),
+                               disparityMultiThread);
+        tm.stop();
+
+        const double multiThreadTime = tm.getTimeMilli();
+
+        tm.reset(); tm.start();
+        multiStreamAlg.compute(leftGrayFrame, rightGrayFrame, disparityMultiStream);
+        tm.stop();
+
+        const double multiStreamTime = tm.getTimeMilli();
+
+        cout << "| " << setw(5) << i << " | "
+             << setw(8) << setprecision(1) << fixed << gpu0Time << " | "
+             << setw(8) << setprecision(1) << fixed << gpu1Time << " | "
+             << setw(15) << setprecision(1) << fixed << multiThreadTime << " | "
+             << setw(15) << setprecision(1) << fixed << multiStreamTime << " |" << endl;
+
+        resize(disparityGpu0, disparityGpu0Show, Size(1024, 768), 0, 0, INTER_AREA);
+        resize(disparityGpu1, disparityGpu1Show, Size(1024, 768), 0, 0, INTER_AREA);
+        resize(disparityMultiThread, disparityMultiThreadShow, Size(1024, 768), 0, 0, INTER_AREA);
+        resize(disparityMultiStream.createMatHeader(), disparityMultiStreamShow, Size(1024, 768), 0, 0, INTER_AREA);
+
+        imshow("disparityGpu0", disparityGpu0Show);
+        imshow("disparityGpu1", disparityGpu1Show);
+        imshow("disparityMultiThread", disparityMultiThreadShow);
+        imshow("disparityMultiStream", disparityMultiStreamShow);
+
+        const int key = waitKey(30) & 0xff;
+        if (key == 27)
+            break;
+    }
+
+    cout << "-------------------------------------------------------------------" << endl;
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/super_resolution.cpp b/C++/opencv-4.7.0/samples/gpu/super_resolution.cpp
new file mode 100644
index 00000000..a05b9012
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/super_resolution.cpp
@@ -0,0 +1,161 @@
+#include <iostream>
+#include <iomanip>
+#include <string>
+#include <ctype.h>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/superres.hpp"
+#include "opencv2/superres/optical_flow.hpp"
+#include "opencv2/opencv_modules.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::superres;
+
+#define MEASURE_TIME(op) \
+    { \
+        TickMeter tm; \
+        tm.start(); \
+        op; \
+        tm.stop(); \
+        cout << tm.getTimeSec() << " sec" << endl; \
+    }
+
+static Ptr<cv::superres::DenseOpticalFlowExt> createOptFlow(const string& name, bool useGpu)
+{
+    if (name == "farneback")
+    {
+        if (useGpu)
+            return cv::superres::createOptFlow_Farneback_CUDA();
+        else
+            return cv::superres::createOptFlow_Farneback();
+    }
+    /*else if (name == "simple")
+        return createOptFlow_Simple();*/
+    else if (name == "tvl1")
+    {
+        if (useGpu)
+            return cv::superres::createOptFlow_DualTVL1_CUDA();
+        else
+            return cv::superres::createOptFlow_DualTVL1();
+    }
+    else if (name == "brox")
+        return cv::superres::createOptFlow_Brox_CUDA();
+    else if (name == "pyrlk")
+        return cv::superres::createOptFlow_PyrLK_CUDA();
+    else
+        cerr << "Incorrect Optical Flow algorithm - " << name << endl;
+
+    return Ptr<cv::superres::DenseOpticalFlowExt>();
+}
+
+int main(int argc, const char* argv[])
+{
+    CommandLineParser cmd(argc, argv,
+        "{ v video      |           | Input video (mandatory)}"
+        "{ o output     |           | Output video }"
+        "{ s scale      | 4         | Scale factor }"
+        "{ i iterations | 180       | Iteration count }"
+        "{ t temporal   | 4         | Radius of the temporal search area }"
+        "{ f flow       | farneback | Optical flow algorithm (farneback, tvl1, brox, pyrlk) }"
+        "{ g gpu        | false     | CPU as default device, cuda for CUDA }"
+        "{ h help       | false     | Print help message }"
+    );
+
+    const string inputVideoName = cmd.get<string>("video");
+    if (cmd.get<bool>("help") || inputVideoName.empty())
+    {
+        cout << "This sample demonstrates Super Resolution algorithms for video sequence" << endl;
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+
+    const string outputVideoName = cmd.get<string>("output");
+    const int scale = cmd.get<int>("scale");
+    const int iterations = cmd.get<int>("iterations");
+    const int temporalAreaRadius = cmd.get<int>("temporal");
+    const string optFlow = cmd.get<string>("flow");
+    string gpuOption = cmd.get<string>("gpu");
+
+    std::transform(gpuOption.begin(), gpuOption.end(), gpuOption.begin(), ::tolower);
+
+    bool useCuda = gpuOption.compare("cuda") == 0;
+    Ptr<SuperResolution> superRes;
+
+    if (useCuda)
+        superRes = createSuperResolution_BTVL1_CUDA();
+    else
+        superRes = createSuperResolution_BTVL1();
+
+    Ptr<cv::superres::DenseOpticalFlowExt> of = createOptFlow(optFlow, useCuda);
+
+    if (of.empty())
+        return EXIT_FAILURE;
+    superRes->setOpticalFlow(of);
+
+    superRes->setScale(scale);
+    superRes->setIterations(iterations);
+    superRes->setTemporalAreaRadius(temporalAreaRadius);
+
+    Ptr<FrameSource> frameSource;
+    if (useCuda)
+    {
+        // Try to use gpu Video Decoding
+        try
+        {
+            frameSource = createFrameSource_Video_CUDA(inputVideoName);
+            Mat frame;
+            frameSource->nextFrame(frame);
+        }
+        catch (const cv::Exception&)
+        {
+            frameSource.release();
+        }
+    }
+    if (!frameSource)
+        frameSource = createFrameSource_Video(inputVideoName);
+
+    // skip first frame, it is usually corrupted
+    {
+        Mat frame;
+        frameSource->nextFrame(frame);
+        cout << "Input           : " << inputVideoName << " " << frame.size() << endl;
+        cout << "Scale factor    : " << scale << endl;
+        cout << "Iterations      : " << iterations << endl;
+        cout << "Temporal radius : " << temporalAreaRadius << endl;
+        cout << "Optical Flow    : " << optFlow << endl;
+        cout << "Mode            : " << (useCuda ? "CUDA" : "CPU") << endl;
+    }
+
+    superRes->setInput(frameSource);
+
+    VideoWriter writer;
+
+    for (int i = 0;; ++i)
+    {
+        cout << '[' << setw(3) << i << "] : " << flush;
+        Mat result;
+
+        MEASURE_TIME(superRes->nextFrame(result));
+
+        if (result.empty())
+            break;
+
+        imshow("Super Resolution", result);
+
+        if (waitKey(1000) > 0)
+            break;
+
+        if (!outputVideoName.empty())
+        {
+            if (!writer.isOpened())
+                writer.open(outputVideoName, VideoWriter::fourcc('X', 'V', 'I', 'D'), 25.0, result.size());
+            writer << result;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/gpu/surf_keypoint_matcher.cpp b/C++/opencv-4.7.0/samples/gpu/surf_keypoint_matcher.cpp
new file mode 100644
index 00000000..32880259
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/surf_keypoint_matcher.cpp
@@ -0,0 +1,96 @@
+#include <iostream>
+
+#include "opencv2/opencv_modules.hpp"
+
+#ifdef HAVE_OPENCV_XFEATURES2D
+
+#include "opencv2/core.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/cudafeatures2d.hpp"
+#include "opencv2/xfeatures2d/cuda.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::cuda;
+
+static void help()
+{
+    cout << "\nThis program demonstrates using SURF_CUDA features detector, descriptor extractor and BruteForceMatcher_CUDA" << endl;
+    cout << "\nUsage:\n\tsurf_keypoint_matcher --left <image1> --right <image2>" << endl;
+}
+
+int main(int argc, char* argv[])
+{
+    if (argc != 5)
+    {
+        help();
+        return -1;
+    }
+
+    GpuMat img1, img2;
+    for (int i = 1; i < argc; ++i)
+    {
+        if (string(argv[i]) == "--left")
+        {
+            img1.upload(imread(argv[++i], IMREAD_GRAYSCALE));
+            CV_Assert(!img1.empty());
+        }
+        else if (string(argv[i]) == "--right")
+        {
+            img2.upload(imread(argv[++i], IMREAD_GRAYSCALE));
+            CV_Assert(!img2.empty());
+        }
+        else if (string(argv[i]) == "--help")
+        {
+            help();
+            return -1;
+        }
+    }
+
+    cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());
+
+    SURF_CUDA surf;
+
+    // detecting keypoints & computing descriptors
+    GpuMat keypoints1GPU, keypoints2GPU;
+    GpuMat descriptors1GPU, descriptors2GPU;
+    surf(img1, GpuMat(), keypoints1GPU, descriptors1GPU);
+    surf(img2, GpuMat(), keypoints2GPU, descriptors2GPU);
+
+    cout << "FOUND " << keypoints1GPU.cols << " keypoints on first image" << endl;
+    cout << "FOUND " << keypoints2GPU.cols << " keypoints on second image" << endl;
+
+    // matching descriptors
+    Ptr<cv::cuda::DescriptorMatcher> matcher = cv::cuda::DescriptorMatcher::createBFMatcher(surf.defaultNorm());
+    vector<DMatch> matches;
+    matcher->match(descriptors1GPU, descriptors2GPU, matches);
+
+    // downloading results
+    vector<KeyPoint> keypoints1, keypoints2;
+    vector<float> descriptors1, descriptors2;
+    surf.downloadKeypoints(keypoints1GPU, keypoints1);
+    surf.downloadKeypoints(keypoints2GPU, keypoints2);
+    surf.downloadDescriptors(descriptors1GPU, descriptors1);
+    surf.downloadDescriptors(descriptors2GPU, descriptors2);
+
+    // drawing the results
+    Mat img_matches;
+    drawMatches(Mat(img1), keypoints1, Mat(img2), keypoints2, matches, img_matches);
+
+    namedWindow("matches", 0);
+    imshow("matches", img_matches);
+    waitKey(0);
+
+    return 0;
+}
+
+#else
+
+int main()
+{
+    std::cerr << "OpenCV was built without xfeatures2d module" << std::endl;
+    return 0;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/gpu/video_reader.cpp b/C++/opencv-4.7.0/samples/gpu/video_reader.cpp
new file mode 100644
index 00000000..e8a738f9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/video_reader.cpp
@@ -0,0 +1,71 @@
+#include <iostream>
+
+#include "opencv2/opencv_modules.hpp"
+
+#if defined(HAVE_OPENCV_CUDACODEC)
+
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <numeric>
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/opengl.hpp>
+#include <opencv2/cudacodec.hpp>
+#include <opencv2/highgui.hpp>
+
+int main(int argc, const char* argv[])
+{
+    if (argc != 2)
+        return -1;
+
+    const std::string fname(argv[1]);
+
+    cv::namedWindow("CPU", cv::WINDOW_NORMAL);
+#if defined(HAVE_OPENGL)
+    cv::namedWindow("GPU", cv::WINDOW_OPENGL);
+    cv::cuda::setGlDevice();
+#else
+    cv::namedWindow("GPU", cv::WINDOW_NORMAL);
+#endif
+
+    cv::TickMeter tm;
+    cv::Mat frame;
+    cv::VideoCapture reader(fname);
+    for (;;)
+    {
+        if (!reader.read(frame))
+            break;
+        cv::imshow("CPU", frame);
+        if (cv::waitKey(3) > 0)
+            break;
+    }
+
+    cv::cuda::GpuMat d_frame;
+    cv::Ptr<cv::cudacodec::VideoReader> d_reader = cv::cudacodec::createVideoReader(fname);
+    for (;;)
+    {
+        if (!d_reader->nextFrame(d_frame))
+            break;
+#if defined(HAVE_OPENGL)
+        cv::imshow("GPU", cv::ogl::Texture2D(d_frame));
+#else
+        d_frame.download(frame);
+        cv::imshow("GPU", frame);
+#endif
+        if (cv::waitKey(3) > 0)
+            break;
+    }
+
+    return 0;
+}
+
+#else
+
+int main()
+{
+    std::cout << "OpenCV was built without CUDA Video decoding support\n" << std::endl;
+    return 0;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/gpu/video_writer.cpp b/C++/opencv-4.7.0/samples/gpu/video_writer.cpp
new file mode 100644
index 00000000..02b17700
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/gpu/video_writer.cpp
@@ -0,0 +1,87 @@
+#include <iostream>
+
+#include "opencv2/opencv_modules.hpp"
+
+#if defined(HAVE_OPENCV_CUDACODEC)
+
+#include <vector>
+#include <numeric>
+
+#include "opencv2/core.hpp"
+#include "opencv2/cudacodec.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+int main(int argc, const char* argv[])
+{
+    if (argc != 2)
+    {
+        std::cerr << "Usage : video_writer <input video file>" << std::endl;
+        return -1;
+    }
+
+    constexpr double fps = 25.0;
+
+    cv::VideoCapture reader(argv[1]);
+
+    if (!reader.isOpened())
+    {
+        std::cerr << "Can't open input video file" << std::endl;
+        return -1;
+    }
+
+    cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());
+
+    cv::VideoWriter writer;
+    cv::Ptr<cv::cudacodec::VideoWriter> d_writer;
+
+    cv::Mat frame;
+    cv::cuda::GpuMat d_frame;
+    cv::cuda::Stream stream;
+
+    for (int i = 1;; ++i)
+    {
+        std::cout << "Read " << i << " frame" << std::endl;
+        reader >> frame;
+        if (frame.empty())
+        {
+            std::cout << "Stop" << std::endl;
+            break;
+        }
+
+        if (!writer.isOpened())
+        {
+            std::cout << "Frame Size : " << frame.cols << "x" << frame.rows << std::endl;
+            std::cout << "Open CPU Writer" << std::endl;
+            const String outputFilename = "output_cpu.avi";
+            if (!writer.open(outputFilename, cv::VideoWriter::fourcc('X', 'V', 'I', 'D'), fps, frame.size()))
+                return -1;
+            std::cout << "Writing to " << outputFilename << std::endl;
+        }
+
+        if (d_writer.empty())
+        {
+            std::cout << "Open CUDA Writer" << std::endl;
+            const cv::String outputFilename = "output_gpu.h264";
+            d_writer = cv::cudacodec::createVideoWriter(outputFilename, frame.size(), cv::cudacodec::Codec::H264, fps, cv::cudacodec::ColorFormat::BGR, 0, stream);
+            std::cout << "Writing to " << outputFilename << std::endl;
+        }
+
+        d_frame.upload(frame, stream);
+        std::cout << "Write " << i << " frame" << std::endl;
+        writer.write(frame);
+        d_writer->write(d_frame);
+    }
+
+    return 0;
+}
+
+#else
+
+int main()
+{
+    std::cout << "OpenCV was built without CUDA Video encoding support\n" << std::endl;
+    return 0;
+}
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/hal/README.md b/C++/opencv-4.7.0/samples/hal/README.md
new file mode 100644
index 00000000..8e052833
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/hal/README.md
@@ -0,0 +1,33 @@
+Custom HAL samples
+==================
+
+Samples in this folder are intended to demonstrate functionality replacement mechanism in the OpenCV library.
+
+The __c_hal__ is the example of pure C replacement library with all functions returning error. It can be used to verify error handling in the function switching code.
+
+The __slow_hal__ contains naive C++ implementations of the element-wise logical array operations (and, or, xor, not) making them twice slower than the default.
+
+Build custom HAL replacement library
+------------------------------------
+
+1. Create folder for build (for example `<home-dir>/my-hal-build`)
+2. Go to the created folder and run cmake: `cmake <opencv-src>/samples/hal/slow_hal`
+3. Run make
+
+After build you will find static library in the build folder: `libslow_hal.a`
+
+Build OpenCV with HAL replacement
+---------------------------------
+
+1. Create folder for build (for example `<home-dir>/my-opencv-build`)
+2. Go to the created folder and run cmake:
+    ```
+    cmake \
+        -DOpenCV_HAL_DIR="<home-dir>/my-hal-build/" \
+        <opencv-src>
+    ```
+3. Run make (or `make opencv_perf_core` to build the demonstration test executable only)
+4. After build you can run the tests and verify that some functions works slower:
+    ```
+    ./bin/opencv_perf_core --gtest_filter=*bitwise_and*
+    ```
diff --git a/C++/opencv-4.7.0/samples/hal/c_hal/CMakeLists.txt b/C++/opencv-4.7.0/samples/hal/c_hal/CMakeLists.txt
new file mode 100644
index 00000000..8cf78aa5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/hal/c_hal/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 2.8.12.2 FATAL_ERROR)
+
+set(PROJECT_NAME "c_hal")
+set(HAL_LIB_NAME "c_hal")
+
+add_library(${HAL_LIB_NAME} impl.c)
+set_target_properties(${HAL_LIB_NAME} PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+set(OPENCV_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../..")
+target_include_directories(${HAL_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${OPENCV_SRC_DIR}/modules/core/include)
+
+set(OpenCV_HAL_FOUND TRUE)
+set(OpenCV_HAL_VERSION 0.0.1)
+set(OpenCV_HAL_LIBRARIES ${CMAKE_CURRENT_BINARY_DIR}/lib${HAL_LIB_NAME}.a)
+set(OpenCV_HAL_HEADERS "impl.h")
+set(OpenCV_HAL_INCLUDE_DIRS ${CMAKE_CURRENT_LIST_DIR})
+
+configure_file("impl.h" "${CMAKE_BINARY_DIR}/impl.h" COPYONLY)
+configure_file("config.cmake" "${CMAKE_BINARY_DIR}/OpenCV_HALConfig.cmake")
diff --git a/C++/opencv-4.7.0/samples/hal/c_hal/config.cmake b/C++/opencv-4.7.0/samples/hal/c_hal/config.cmake
new file mode 100644
index 00000000..d57b7efd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/hal/c_hal/config.cmake
@@ -0,0 +1,5 @@
+set(OpenCV_HAL_FOUND @OpenCV_HAL_FOUND@)
+set(OpenCV_HAL_VERSION @OpenCV_HAL_VERSION@)
+set(OpenCV_HAL_LIBRARIES @OpenCV_HAL_LIBRARIES@)
+set(OpenCV_HAL_HEADERS @OpenCV_HAL_HEADERS@)
+set(OpenCV_HAL_INCLUDE_DIRS @OpenCV_HAL_INCLUDE_DIRS@)
diff --git a/C++/opencv-4.7.0/samples/hal/c_hal/impl.c b/C++/opencv-4.7.0/samples/hal/c_hal/impl.c
new file mode 100644
index 00000000..7bf34ae3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/hal/c_hal/impl.c
@@ -0,0 +1,371 @@
+#include "impl.h"
+
+int wrong_add8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_add8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_add16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_add16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_add32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_add32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_add64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_sub8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_sub8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_sub16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_sub16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_sub32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_sub32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_sub64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_max8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_max8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_max16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_max16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_max32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_max32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_max64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_min8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_min8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_min16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_min16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_min32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_min32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_min64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_absdiff8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_absdiff8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_absdiff16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_absdiff16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_absdiff32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_absdiff32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_absdiff64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_and8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_or8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_xor8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_not8u(const uchar* src1, size_t sz1, uchar* dst, size_t sz, int w, int h)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_cmp8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_cmp8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_cmp16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_cmp16s(const short* src1, size_t sz1, const short* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_cmp32s(const int* src1, size_t sz1, const int* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_cmp32f(const float* src1, size_t sz1, const float* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_cmp64f(const double* src1, size_t sz1, const double* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_mul8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_mul8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_mul16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_mul16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_mul32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_mul32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_mul64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_div8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_div8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_div16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_div16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_div32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_div32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_div64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_recip8u(const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_recip8s(const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_recip16u(const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_recip16s(const short* src2, size_t sz2, short* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_recip32s(const int* src2, size_t sz2, int* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_recip32f(const float* src2, size_t sz2, float* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_recip64f(const double* src2, size_t sz2, double* dst, size_t sz, int w, int h, double scale)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_addWeighted8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, const double* scales)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_addWeighted8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h, const double* scales)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_addWeighted16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h, const double* scales)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_addWeighted16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h, const double* scales)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_addWeighted32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h, const double* scales)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_addWeighted32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h, const double* scales)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
+
+int wrong_addWeighted64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h, const double* scales)
+{
+    return CV_HAL_ERROR_UNKNOWN; // to test how OpenCV handles errors from external HAL
+}
diff --git a/C++/opencv-4.7.0/samples/hal/c_hal/impl.h b/C++/opencv-4.7.0/samples/hal/c_hal/impl.h
new file mode 100644
index 00000000..91d7e82b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/hal/c_hal/impl.h
@@ -0,0 +1,245 @@
+#ifndef _wrong_H_INCLUDED_
+#define _wrong_H_INCLUDED_
+
+#include "opencv2/core/hal/interface.h"
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+
+int wrong_add8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h);
+int wrong_add8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h);
+int wrong_add16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h);
+int wrong_add16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h);
+int wrong_add32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h);
+int wrong_add32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h);
+int wrong_add64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h);
+int wrong_sub8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h);
+int wrong_sub8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h);
+int wrong_sub16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h);
+int wrong_sub16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h);
+int wrong_sub32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h);
+int wrong_sub32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h);
+int wrong_sub64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h);
+int wrong_max8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h);
+int wrong_max8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h);
+int wrong_max16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h);
+int wrong_max16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h);
+int wrong_max32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h);
+int wrong_max32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h);
+int wrong_max64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h);
+int wrong_min8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h);
+int wrong_min8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h);
+int wrong_min16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h);
+int wrong_min16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h);
+int wrong_min32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h);
+int wrong_min32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h);
+int wrong_min64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h);
+int wrong_absdiff8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h);
+int wrong_absdiff8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h);
+int wrong_absdiff16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h);
+int wrong_absdiff16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h);
+int wrong_absdiff32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h);
+int wrong_absdiff32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h);
+int wrong_absdiff64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h);
+int wrong_and8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h);
+int wrong_or8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h);
+int wrong_xor8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h);
+int wrong_not8u(const uchar* src1, size_t sz1, uchar* dst, size_t sz, int w, int h);
+
+#undef cv_hal_add8u
+#define cv_hal_add8u wrong_add8u
+#undef cv_hal_add8s
+#define cv_hal_add8s wrong_add8s
+#undef cv_hal_add16u
+#define cv_hal_add16u wrong_add16u
+#undef cv_hal_add16s
+#define cv_hal_add16s wrong_add16s
+#undef cv_hal_add32s
+#define cv_hal_add32s wrong_add32s
+#undef cv_hal_add32f
+#define cv_hal_add32f wrong_add32f
+#undef cv_hal_add64f
+#define cv_hal_add64f wrong_add64f
+#undef cv_hal_sub8u
+#define cv_hal_sub8u wrong_sub8u
+#undef cv_hal_sub8s
+#define cv_hal_sub8s wrong_sub8s
+#undef cv_hal_sub16u
+#define cv_hal_sub16u wrong_sub16u
+#undef cv_hal_sub16s
+#define cv_hal_sub16s wrong_sub16s
+#undef cv_hal_sub32s
+#define cv_hal_sub32s wrong_sub32s
+#undef cv_hal_sub32f
+#define cv_hal_sub32f wrong_sub32f
+#undef cv_hal_sub64f
+#define cv_hal_sub64f wrong_sub64f
+#undef cv_hal_max8u
+#define cv_hal_max8u wrong_max8u
+#undef cv_hal_max8s
+#define cv_hal_max8s wrong_max8s
+#undef cv_hal_max16u
+#define cv_hal_max16u wrong_max16u
+#undef cv_hal_max16s
+#define cv_hal_max16s wrong_max16s
+#undef cv_hal_max32s
+#define cv_hal_max32s wrong_max32s
+#undef cv_hal_max32f
+#define cv_hal_max32f wrong_max32f
+#undef cv_hal_max64f
+#define cv_hal_max64f wrong_max64f
+#undef cv_hal_min8u
+#define cv_hal_min8u wrong_min8u
+#undef cv_hal_min8s
+#define cv_hal_min8s wrong_min8s
+#undef cv_hal_min16u
+#define cv_hal_min16u wrong_min16u
+#undef cv_hal_min16s
+#define cv_hal_min16s wrong_min16s
+#undef cv_hal_min32s
+#define cv_hal_min32s wrong_min32s
+#undef cv_hal_min32f
+#define cv_hal_min32f wrong_min32f
+#undef cv_hal_min64f
+#define cv_hal_min64f wrong_min64f
+#undef cv_hal_absdiff8u
+#define cv_hal_absdiff8u wrong_absdiff8u
+#undef cv_hal_absdiff8s
+#define cv_hal_absdiff8s wrong_absdiff8s
+#undef cv_hal_absdiff16u
+#define cv_hal_absdiff16u wrong_absdiff16u
+#undef cv_hal_absdiff16s
+#define cv_hal_absdiff16s wrong_absdiff16s
+#undef cv_hal_absdiff32s
+#define cv_hal_absdiff32s wrong_absdiff32s
+#undef cv_hal_absdiff32f
+#define cv_hal_absdiff32f wrong_absdiff32f
+#undef cv_hal_absdiff64f
+#define cv_hal_absdiff64f wrong_absdiff64f
+#undef cv_hal_and8u
+#define cv_hal_and8u wrong_and8u
+#undef cv_hal_or8u
+#define cv_hal_or8u wrong_or8u
+#undef cv_hal_xor8u
+#define cv_hal_xor8u wrong_xor8u
+#undef cv_hal_not8u
+#define cv_hal_not8u wrong_not8u
+
+int wrong_cmp8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op);
+int wrong_cmp8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op);
+int wrong_cmp16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op);
+int wrong_cmp16s(const short* src1, size_t sz1, const short* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op);
+int wrong_cmp32s(const int* src1, size_t sz1, const int* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op);
+int wrong_cmp32f(const float* src1, size_t sz1, const float* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op);
+int wrong_cmp64f(const double* src1, size_t sz1, const double* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, int op);
+
+#undef cv_hal_cmp8u
+#define cv_hal_cmp8u wrong_cmp8u
+#undef cv_hal_cmp8s
+#define cv_hal_cmp8s wrong_cmp8s
+#undef cv_hal_cmp16u
+#define cv_hal_cmp16u wrong_cmp16u
+#undef cv_hal_cmp16s
+#define cv_hal_cmp16s wrong_cmp16s
+#undef cv_hal_cmp32s
+#define cv_hal_cmp32s wrong_cmp32s
+#undef cv_hal_cmp32f
+#define cv_hal_cmp32f wrong_cmp32f
+#undef cv_hal_cmp64f
+#define cv_hal_cmp64f wrong_cmp64f
+
+int wrong_mul8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, double scale);
+int wrong_mul8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h, double scale);
+int wrong_mul16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h, double scale);
+int wrong_mul16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h, double scale);
+int wrong_mul32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h, double scale);
+int wrong_mul32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h, double scale);
+int wrong_mul64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h, double scale);
+int wrong_div8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, double scale);
+int wrong_div8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h, double scale);
+int wrong_div16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h, double scale);
+int wrong_div16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h, double scale);
+int wrong_div32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h, double scale);
+int wrong_div32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h, double scale);
+int wrong_div64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h, double scale);
+int wrong_recip8u(const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, double scale);
+int wrong_recip8s(const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h, double scale);
+int wrong_recip16u(const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h, double scale);
+int wrong_recip16s(const short* src2, size_t sz2, short* dst, size_t sz, int w, int h, double scale);
+int wrong_recip32s(const int* src2, size_t sz2, int* dst, size_t sz, int w, int h, double scale);
+int wrong_recip32f(const float* src2, size_t sz2, float* dst, size_t sz, int w, int h, double scale);
+int wrong_recip64f(const double* src2, size_t sz2, double* dst, size_t sz, int w, int h, double scale);
+
+#undef cv_hal_mul8u
+#define cv_hal_mul8u wrong_mul8u
+#undef cv_hal_mul8s
+#define cv_hal_mul8s wrong_mul8s
+#undef cv_hal_mul16u
+#define cv_hal_mul16u wrong_mul16u
+#undef cv_hal_mul16s
+#define cv_hal_mul16s wrong_mul16s
+#undef cv_hal_mul32s
+#define cv_hal_mul32s wrong_mul32s
+#undef cv_hal_mul32f
+#define cv_hal_mul32f wrong_mul32f
+#undef cv_hal_mul64f
+#define cv_hal_mul64f wrong_mul64f
+#undef cv_hal_div8u
+#define cv_hal_div8u wrong_div8u
+#undef cv_hal_div8s
+#define cv_hal_div8s wrong_div8s
+#undef cv_hal_div16u
+#define cv_hal_div16u wrong_div16u
+#undef cv_hal_div16s
+#define cv_hal_div16s wrong_div16s
+#undef cv_hal_div32s
+#define cv_hal_div32s wrong_div32s
+#undef cv_hal_div32f
+#define cv_hal_div32f wrong_div32f
+#undef cv_hal_div64f
+#define cv_hal_div64f wrong_div64f
+#undef cv_hal_recip8u
+#define cv_hal_recip8u wrong_recip8u
+#undef cv_hal_recip8s
+#define cv_hal_recip8s wrong_recip8s
+#undef cv_hal_recip16u
+#define cv_hal_recip16u wrong_recip16u
+#undef cv_hal_recip16s
+#define cv_hal_recip16s wrong_recip16s
+#undef cv_hal_recip32s
+#define cv_hal_recip32s wrong_recip32s
+#undef cv_hal_recip32f
+#define cv_hal_recip32f wrong_recip32f
+#undef cv_hal_recip64f
+#define cv_hal_recip64f wrong_recip64f
+
+int wrong_addWeighted8u(const uchar* src1, size_t sz1, const uchar* src2, size_t sz2, uchar* dst, size_t sz, int w, int h, const double* scales);
+int wrong_addWeighted8s(const schar* src1, size_t sz1, const schar* src2, size_t sz2, schar* dst, size_t sz, int w, int h, const double* scales);
+int wrong_addWeighted16u(const ushort* src1, size_t sz1, const ushort* src2, size_t sz2, ushort* dst, size_t sz, int w, int h, const double* scales);
+int wrong_addWeighted16s(const short* src1, size_t sz1, const short* src2, size_t sz2, short* dst, size_t sz, int w, int h, const double* scales);
+int wrong_addWeighted32s(const int* src1, size_t sz1, const int* src2, size_t sz2, int* dst, size_t sz, int w, int h, const double* scales);
+int wrong_addWeighted32f(const float* src1, size_t sz1, const float* src2, size_t sz2, float* dst, size_t sz, int w, int h, const double* scales);
+int wrong_addWeighted64f(const double* src1, size_t sz1, const double* src2, size_t sz2, double* dst, size_t sz, int w, int h, const double* scales);
+
+#undef cv_hal_addWeighted8u
+#define cv_hal_addWeighted8u wrong_addWeighted8u
+#undef cv_hal_addWeighted8s
+#define cv_hal_addWeighted8s wrong_addWeighted8s
+#undef cv_hal_addWeighted16u
+#define cv_hal_addWeighted16u wrong_addWeighted16u
+#undef cv_hal_addWeighted16s
+#define cv_hal_addWeighted16s wrong_addWeighted16s
+#undef cv_hal_addWeighted32s
+#define cv_hal_addWeighted32s wrong_addWeighted32s
+#undef cv_hal_addWeighted32f
+#define cv_hal_addWeighted32f wrong_addWeighted32f
+#undef cv_hal_addWeighted64f
+#define cv_hal_addWeighted64f wrong_addWeighted64f
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/hal/slow_hal/CMakeLists.txt b/C++/opencv-4.7.0/samples/hal/slow_hal/CMakeLists.txt
new file mode 100644
index 00000000..1ffa4670
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/hal/slow_hal/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 2.8.12.2 FATAL_ERROR)
+
+set(PROJECT_NAME "slow_hal")
+set(HAL_LIB_NAME "slow_hal")
+
+add_library(${HAL_LIB_NAME} impl.cpp)
+set_target_properties(${HAL_LIB_NAME} PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+set(OPENCV_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../..")
+target_include_directories(${HAL_LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${OPENCV_SRC_DIR}/modules/core/include)
+
+set(OpenCV_HAL_FOUND TRUE)
+set(OpenCV_HAL_VERSION 0.0.1)
+set(OpenCV_HAL_LIBRARIES ${CMAKE_CURRENT_BINARY_DIR}/lib${HAL_LIB_NAME}.a)
+set(OpenCV_HAL_HEADERS "impl.hpp")
+set(OpenCV_HAL_INCLUDE_DIRS ${CMAKE_CURRENT_LIST_DIR})
+
+configure_file("impl.hpp" "${CMAKE_BINARY_DIR}/impl.hpp" COPYONLY)
+configure_file("config.cmake" "${CMAKE_BINARY_DIR}/OpenCV_HALConfig.cmake")
diff --git a/C++/opencv-4.7.0/samples/hal/slow_hal/config.cmake b/C++/opencv-4.7.0/samples/hal/slow_hal/config.cmake
new file mode 100644
index 00000000..d57b7efd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/hal/slow_hal/config.cmake
@@ -0,0 +1,5 @@
+set(OpenCV_HAL_FOUND @OpenCV_HAL_FOUND@)
+set(OpenCV_HAL_VERSION @OpenCV_HAL_VERSION@)
+set(OpenCV_HAL_LIBRARIES @OpenCV_HAL_LIBRARIES@)
+set(OpenCV_HAL_HEADERS @OpenCV_HAL_HEADERS@)
+set(OpenCV_HAL_INCLUDE_DIRS @OpenCV_HAL_INCLUDE_DIRS@)
diff --git a/C++/opencv-4.7.0/samples/hal/slow_hal/impl.cpp b/C++/opencv-4.7.0/samples/hal/slow_hal/impl.cpp
new file mode 100644
index 00000000..cebec50d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/hal/slow_hal/impl.cpp
@@ -0,0 +1,33 @@
+#include "impl.hpp"
+
+int slow_and8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, int width, int height)
+{
+    for(; height--; src1 = src1 + step1, src2 = src2 + step2, dst = dst + step)
+        for(int x = 0 ; x < width; x++ )
+            dst[x] = src1[x] & src2[x];
+    return CV_HAL_ERROR_OK;
+}
+
+int slow_or8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, int width, int height)
+{
+    for(; height--; src1 = src1 + step1, src2 = src2 + step2, dst = dst + step)
+        for(int x = 0 ; x < width; x++ )
+            dst[x] = src1[x] | src2[x];
+    return CV_HAL_ERROR_OK;
+}
+
+int slow_xor8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, int width, int height)
+{
+    for(; height--; src1 = src1 + step1, src2 = src2 + step2, dst = dst + step)
+        for(int x = 0 ; x < width; x++ )
+            dst[x] = src1[x] ^ src2[x];
+    return CV_HAL_ERROR_OK;
+}
+
+int slow_not8u(const uchar* src1, size_t step1, uchar* dst, size_t step, int width, int height)
+{
+    for(; height--; src1 = src1 + step1, dst = dst + step)
+        for(int x = 0 ; x < width; x++ )
+            dst[x] = ~src1[x];
+    return CV_HAL_ERROR_OK;
+}
diff --git a/C++/opencv-4.7.0/samples/hal/slow_hal/impl.hpp b/C++/opencv-4.7.0/samples/hal/slow_hal/impl.hpp
new file mode 100644
index 00000000..5cbef5e3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/hal/slow_hal/impl.hpp
@@ -0,0 +1,20 @@
+#ifndef _SIMPLE_HPP_INCLUDED_
+#define _SIMPLE_HPP_INCLUDED_
+
+#include "opencv2/core/hal/interface.h"
+
+int slow_and8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, int width, int height);
+int slow_or8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, int width, int height);
+int slow_xor8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, int width, int height);
+int slow_not8u(const uchar* src1, size_t step1, uchar* dst, size_t step, int width, int height);
+
+#undef cv_hal_and8u
+#define cv_hal_and8u slow_and8u
+#undef cv_hal_or8u
+#define cv_hal_or8u slow_or8u
+#undef cv_hal_xor8u
+#define cv_hal_xor8u slow_xor8u
+#undef cv_hal_not8u
+#define cv_hal_not8u slow_not8u
+
+#endif
diff --git a/C++/opencv-4.7.0/samples/install/linux_install_a.sh b/C++/opencv-4.7.0/samples/install/linux_install_a.sh
new file mode 100644
index 00000000..7588a505
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/install/linux_install_a.sh
@@ -0,0 +1,58 @@
+#!/bin/bash
+# This file contains documentation snippets for Linux installation tutorial
+if [ "$1" = "--check" ] ; then
+sudo()
+{
+    command $@
+}
+fi
+
+sudo apt update
+
+# [gcc]
+sudo apt install -y g++
+# [gcc]
+
+# [make]
+sudo apt install -y make
+# [make]
+
+# [cmake]
+sudo apt install -y cmake
+# [cmake]
+
+# [wget]
+sudo apt install -y wget unzip
+# [wget]
+
+# [download]
+wget -O opencv.zip https://github.com/opencv/opencv/archive/4.x.zip
+unzip opencv.zip
+mv opencv-4.x opencv
+# [download]
+
+# [prepare]
+mkdir -p build && cd build
+# [prepare]
+
+# [configure]
+cmake ../opencv
+# [configure]
+
+# [build]
+make -j4
+# [build]
+
+# [check]
+ls bin
+ls lib
+# [check]
+
+# [check cmake]
+ls OpenCVConfig*.cmake
+ls OpenCVModules.cmake
+# [check cmake]
+
+# [install]
+sudo make install
+# [install]
diff --git a/C++/opencv-4.7.0/samples/install/linux_install_b.sh b/C++/opencv-4.7.0/samples/install/linux_install_b.sh
new file mode 100644
index 00000000..d85b9405
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/install/linux_install_b.sh
@@ -0,0 +1,47 @@
+#!/bin/bash
+# This file contains documentation snippets for Linux installation tutorial
+if [ "$1" = "--check" ] ; then
+sudo()
+{
+    command $@
+}
+fi
+
+sudo apt update
+
+# [clang]
+sudo apt install -y clang
+# [clang]
+
+# [ninja]
+sudo apt install -y ninja-build
+# [ninja]
+
+# [cmake]
+sudo apt install -y cmake
+# [cmake]
+
+# [git]
+sudo apt install -y git
+# [git]
+
+# [download]
+git clone https://github.com/opencv/opencv.git
+git -C opencv checkout 4.x
+# [download]
+
+# [prepare]
+mkdir -p build && cd build
+# [prepare]
+
+# [configure]
+cmake -GNinja ../opencv
+# [configure]
+
+# [build]
+ninja
+# [build]
+
+# [install]
+sudo ninja install
+# [install]
diff --git a/C++/opencv-4.7.0/samples/install/linux_quick_install.sh b/C++/opencv-4.7.0/samples/install/linux_quick_install.sh
new file mode 100644
index 00000000..c48161ce
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/install/linux_quick_install.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+# This file contains documentation snippets for Linux installation tutorial
+if [ "$1" = "--check" ] ; then
+sudo()
+{
+    command $@
+}
+fi
+
+# [body]
+# Install minimal prerequisites (Ubuntu 18.04 as reference)
+sudo apt update && sudo apt install -y cmake g++ wget unzip
+
+# Download and unpack sources
+wget -O opencv.zip https://github.com/opencv/opencv/archive/4.x.zip
+unzip opencv.zip
+
+# Create build directory
+mkdir -p build && cd build
+
+# Configure
+cmake  ../opencv-4.x
+
+# Build
+cmake --build .
+# [body]
diff --git a/C++/opencv-4.7.0/samples/install/linux_quick_install_contrib.sh b/C++/opencv-4.7.0/samples/install/linux_quick_install_contrib.sh
new file mode 100644
index 00000000..e497c085
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/install/linux_quick_install_contrib.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+# This file contains documentation snippets for Linux installation tutorial
+if [ "$1" = "--check" ] ; then
+sudo()
+{
+    command $@
+}
+fi
+
+# [body]
+# Install minimal prerequisites (Ubuntu 18.04 as reference)
+sudo apt update && sudo apt install -y cmake g++ wget unzip
+
+# Download and unpack sources
+wget -O opencv.zip https://github.com/opencv/opencv/archive/4.x.zip
+wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/4.x.zip
+unzip opencv.zip
+unzip opencv_contrib.zip
+
+# Create build directory and switch into it
+mkdir -p build && cd build
+
+# Configure
+cmake -DOPENCV_EXTRA_MODULES_PATH=../opencv_contrib-4.x/modules ../opencv-4.x
+
+# Build
+cmake --build .
+# [body]
diff --git a/C++/opencv-4.7.0/samples/install/linux_verify.sh b/C++/opencv-4.7.0/samples/install/linux_verify.sh
new file mode 100644
index 00000000..394e3f5a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/install/linux_verify.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+# This script verifies that all shell snippets in the
+# Linux installation tutorial work (in Ubuntu 18 container)
+set -e
+set -x
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )"
+
+docker pull ubuntu:18.04
+
+for f in $(cd "${SCRIPT_DIR}" && ls -1 linux_*install*.sh) ; do
+    echo "Checking $f..."
+    docker run -it \
+        --volume "${SCRIPT_DIR}":/install:ro \
+        ubuntu:18.04 \
+        /bin/bash -ex /install/$f --check
+
+done
diff --git a/C++/opencv-4.7.0/samples/java/ant/build.xml b/C++/opencv-4.7.0/samples/java/ant/build.xml
new file mode 100644
index 00000000..d817aa63
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/ant/build.xml
@@ -0,0 +1,49 @@
+<project name="SimpleSample" basedir="." default="rebuild-run">
+
+    <property name="src.dir"     value="src"/>
+
+    <property name="lib.dir"     value="${ocvJarDir}"/>
+    <path id="classpath">
+        <fileset dir="${lib.dir}" includes="**/*.jar"/>
+    </path>
+
+    <property name="build.dir"   value="build"/>
+    <property name="classes.dir" value="${build.dir}/classes"/>
+    <property name="jar.dir"     value="${build.dir}/jar"/>
+
+    <property name="main-class"  value="${ant.project.name}"/>
+
+
+    <target name="clean">
+        <delete dir="${build.dir}"/>
+    </target>
+
+    <target name="compile">
+        <mkdir dir="${classes.dir}"/>
+        <javac includeantruntime="false" srcdir="${src.dir}" destdir="${classes.dir}" classpathref="classpath"/>
+    </target>
+
+    <target name="jar" depends="compile">
+        <mkdir dir="${jar.dir}"/>
+        <jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}">
+            <manifest>
+                <attribute name="Main-Class" value="${main-class}"/>
+            </manifest>
+        </jar>
+    </target>
+
+    <target name="run" depends="jar">
+        <java fork="true" classname="${main-class}">
+            <sysproperty key="java.library.path" path="${ocvLibDir}"/>
+            <classpath>
+                <path refid="classpath"/>
+                <path location="${jar.dir}/${ant.project.name}.jar"/>
+            </classpath>
+        </java>
+    </target>
+
+    <target name="rebuild" depends="clean,jar"/>
+
+    <target name="rebuild-run" depends="clean,run"/>
+
+</project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/java/ant/src/SimpleSample.java b/C++/opencv-4.7.0/samples/java/ant/src/SimpleSample.java
new file mode 100644
index 00000000..a0375c56
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/ant/src/SimpleSample.java
@@ -0,0 +1,21 @@
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.CvType;
+import org.opencv.core.Scalar;
+
+class SimpleSample {
+
+  static{ System.loadLibrary(Core.NATIVE_LIBRARY_NAME); }
+
+  public static void main(String[] args) {
+    System.out.println("Welcome to OpenCV " + Core.VERSION);
+    Mat m = new Mat(5, 10, CvType.CV_8UC1, new Scalar(0));
+    System.out.println("OpenCV Mat: " + m);
+    Mat mr1 = m.row(1);
+    mr1.setTo(new Scalar(1));
+    Mat mc5 = m.col(5);
+    mc5.setTo(new Scalar(5));
+    System.out.println("OpenCV Mat data:\n" + m.dump());
+  }
+
+}
diff --git a/C++/opencv-4.7.0/samples/java/clojure/simple-sample/project.clj b/C++/opencv-4.7.0/samples/java/clojure/simple-sample/project.clj
new file mode 100644
index 00000000..e15ce271
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/clojure/simple-sample/project.clj
@@ -0,0 +1,14 @@
+(defproject simple-sample "0.1.0-SNAPSHOT"
+  :pom-addition [:developers [:developer {:id "magomimmo"}
+                              [:name "Mimmo Cosenza"]
+                              [:url "https://github.com/magomimmoo"]]]
+
+  :description "A simple project to start REPLing with OpenCV"
+  :url "http://example.com/FIXME"
+  :license {:name "Apache 2.0 License"
+            :url "https://www.apache.org/licenses/LICENSE-2.0"}
+  :dependencies [[org.clojure/clojure "1.5.1"]
+                 [opencv/opencv "2.4.7"]
+                 [opencv/opencv-native "2.4.7"]]
+  :main simple-sample.core
+  :injections [(clojure.lang.RT/loadLibrary org.opencv.core.Core/NATIVE_LIBRARY_NAME)])
diff --git a/C++/opencv-4.7.0/samples/java/clojure/simple-sample/resources/images/lena.png b/C++/opencv-4.7.0/samples/java/clojure/simple-sample/resources/images/lena.png
new file mode 100644
index 00000000..68342fae
Binary files /dev/null and b/C++/opencv-4.7.0/samples/java/clojure/simple-sample/resources/images/lena.png differ
diff --git a/C++/opencv-4.7.0/samples/java/clojure/simple-sample/src/simple_sample/core.clj b/C++/opencv-4.7.0/samples/java/clojure/simple-sample/src/simple_sample/core.clj
new file mode 100644
index 00000000..fa25727b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/clojure/simple-sample/src/simple_sample/core.clj
@@ -0,0 +1,16 @@
+;;; to run this code from the terminal: "$ lein run". It will save a
+;;; blurred image version of resources/images/lena.png as
+;;; resources/images/blurred.png
+
+(ns simple-sample.core
+  (:import [org.opencv.core Point Rect Mat CvType Size Scalar]
+           org.opencv.imgcodecs.Imgcodecs
+           org.opencv.imgproc.Imgproc))
+
+(defn -main [& args]
+  (let [lena (Imgcodecs/imread "resources/images/lena.png")
+        blurred (Mat. 512 512 CvType/CV_8UC3)]
+    (print "Blurring...")
+    (Imgproc/GaussianBlur lena blurred (Size. 5 5) 3 3)
+    (Imgcodecs/imwrite "resources/images/blurred.png" blurred)
+    (println "done!")))
diff --git a/C++/opencv-4.7.0/samples/java/clojure/simple-sample/test/simple_sample/core_test.clj b/C++/opencv-4.7.0/samples/java/clojure/simple-sample/test/simple_sample/core_test.clj
new file mode 100644
index 00000000..d84585e0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/clojure/simple-sample/test/simple_sample/core_test.clj
@@ -0,0 +1,7 @@
+(ns simple-sample.core-test
+  (:require [clojure.test :refer :all]
+            [simple-sample.core :refer :all]))
+
+(deftest a-test
+  (testing "FIXME, I fail."
+    (is (= 0 1))))
diff --git a/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/.classpath b/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/.classpath
new file mode 100644
index 00000000..645263d8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/opencv-2.4.4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/.project b/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/.project
new file mode 100644
index 00000000..b1df1de5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>HelloCV</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/.settings/org.eclipse.jdt.core.prefs b/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 00000000..7341ab16
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.7
diff --git a/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/src/Main.java b/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/src/Main.java
new file mode 100644
index 00000000..44f2bb02
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/eclipse/HelloCV/src/Main.java
@@ -0,0 +1,14 @@
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+
+public class Main {
+
+    public static void main(String[] args) {
+        System.out.println("Welcome to OpenCV " + Core.VERSION);
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        Mat m  = Mat.eye(3, 3, CvType.CV_8UC1);
+        System.out.println("m = " + m.dump());
+    }
+
+}
diff --git a/C++/opencv-4.7.0/samples/java/opencv_version.java b/C++/opencv-4.7.0/samples/java/opencv_version.java
new file mode 100644
index 00000000..93e3da0c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/opencv_version.java
@@ -0,0 +1,23 @@
+import org.opencv.core.Core;
+
+class opencv_version {
+
+  static { System.loadLibrary(Core.NATIVE_LIBRARY_NAME); }
+
+  public static void main(String[] args) {
+
+    if ((1==args.length) && (0==args[0].compareTo("--build"))) {
+
+        System.out.println(Core.getBuildInformation());
+    } else
+    if ((1==args.length) && (0==args[0].compareTo("--help"))) {
+
+        System.out.println("\t--build\n\t\tprint complete build info");
+        System.out.println("\t--help\n\t\tprint this help");
+    } else {
+
+        System.out.println("Welcome to OpenCV " + Core.VERSION);
+    }
+  }
+
+}
diff --git a/C++/opencv-4.7.0/samples/java/sbt/README b/C++/opencv-4.7.0/samples/java/sbt/README
new file mode 100644
index 00000000..263ff547
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/sbt/README
@@ -0,0 +1,13 @@
+A demo of the Java wrapper for OpenCV with two examples:
+1) feature detection and matching and
+2) face detection.
+The examples are coded in Scala and Java.
+Anyone familiar with Java should be able to read the Scala examples.
+Please feel free to contribute code examples in Scala or Java, or any JVM language.
+
+To run the examples:
+1) Install OpenCV and copy the OpenCV jar to lib/.
+   This jar must match the native libraries installed in your system.
+   If this isn't the case, you may get a java.lang.UnsatisfiedLinkError at runtime.
+2) Go to the root directory and type "sbt/sbt run".
+   This should generate images in your current directory.
diff --git a/C++/opencv-4.7.0/samples/java/sbt/lib/copy_opencv_jar_here b/C++/opencv-4.7.0/samples/java/sbt/lib/copy_opencv_jar_here
new file mode 100644
index 00000000..e69de29b
diff --git a/C++/opencv-4.7.0/samples/java/sbt/project/build.scala b/C++/opencv-4.7.0/samples/java/sbt/project/build.scala
new file mode 100644
index 00000000..5a7380b9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/sbt/project/build.scala
@@ -0,0 +1,22 @@
+import sbt._
+import Keys._
+
+object OpenCVJavaDemoBuild extends Build {
+  def scalaSettings = Seq(
+    scalaVersion := "2.10.0",
+    scalacOptions ++= Seq(
+      "-optimize",
+      "-unchecked",
+      "-deprecation"
+    )
+  )
+
+  def buildSettings =
+    Project.defaultSettings ++
+    scalaSettings
+
+  lazy val root = {
+    val settings = buildSettings ++ Seq(name := "OpenCVJavaDemo")
+    Project(id = "OpenCVJavaDemo", base = file("."), settings = settings)
+  }
+}
diff --git a/C++/opencv-4.7.0/samples/java/sbt/project/plugins.sbt b/C++/opencv-4.7.0/samples/java/sbt/project/plugins.sbt
new file mode 100644
index 00000000..737941de
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/sbt/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("com.typesafe.sbteclipse" % "sbteclipse-plugin" % "4.0.0")
diff --git a/C++/opencv-4.7.0/samples/java/sbt/sbt/sbt b/C++/opencv-4.7.0/samples/java/sbt/sbt/sbt
new file mode 100644
index 00000000..99ae7ec2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/sbt/sbt/sbt
@@ -0,0 +1 @@
+java -Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=384M -jar `dirname $0`/sbt-launch.jar "$@"
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/java/sbt/sbt/sbt-launch.jar b/C++/opencv-4.7.0/samples/java/sbt/sbt/sbt-launch.jar
new file mode 100644
index 00000000..06ad8d88
Binary files /dev/null and b/C++/opencv-4.7.0/samples/java/sbt/sbt/sbt-launch.jar differ
diff --git a/C++/opencv-4.7.0/samples/java/sbt/src/main/java/DetectFaceDemo.java b/C++/opencv-4.7.0/samples/java/sbt/src/main/java/DetectFaceDemo.java
new file mode 100644
index 00000000..2b795351
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/sbt/src/main/java/DetectFaceDemo.java
@@ -0,0 +1,45 @@
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfRect;
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.core.Scalar;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.objdetect.CascadeClassifier;
+
+/*
+ * Detects faces in an image, draws boxes around them, and writes the results
+ * to "faceDetection.png".
+ */
+public class DetectFaceDemo {
+    public void run() {
+        System.out.println("\nRunning DetectFaceDemo");
+
+        // Create a face detector from the cascade file in the resources
+        // directory.
+        CascadeClassifier faceDetector = new CascadeClassifier(getClass()
+                .getResource("/lbpcascade_frontalface.xml").getPath());
+        Mat image = Imgcodecs.imread(getClass().getResource(
+                "/AverageMaleFace.jpg").getPath());
+
+        // Detect faces in the image.
+        // MatOfRect is a special container class for Rect.
+        MatOfRect faceDetections = new MatOfRect();
+        faceDetector.detectMultiScale(image, faceDetections);
+
+        System.out.println(String.format("Detected %s faces",
+                faceDetections.toArray().length));
+
+        // Draw a bounding box around each face.
+        for (Rect rect : faceDetections.toArray()) {
+            Imgproc.rectangle(image, new Point(rect.x, rect.y), new Point(rect.x
+                    + rect.width, rect.y + rect.height), new Scalar(0, 255, 0));
+        }
+
+        // Save the visualized detection.
+        String filename = "faceDetection.png";
+        System.out.println(String.format("Writing %s", filename));
+        Imgcodecs.imwrite(filename, image);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/sbt/src/main/resources/AverageMaleFace.jpg b/C++/opencv-4.7.0/samples/java/sbt/src/main/resources/AverageMaleFace.jpg
new file mode 100644
index 00000000..3b96e03b
Binary files /dev/null and b/C++/opencv-4.7.0/samples/java/sbt/src/main/resources/AverageMaleFace.jpg differ
diff --git a/C++/opencv-4.7.0/samples/java/sbt/src/main/resources/img1.png b/C++/opencv-4.7.0/samples/java/sbt/src/main/resources/img1.png
new file mode 100644
index 00000000..93cd5945
Binary files /dev/null and b/C++/opencv-4.7.0/samples/java/sbt/src/main/resources/img1.png differ
diff --git a/C++/opencv-4.7.0/samples/java/sbt/src/main/resources/img2.png b/C++/opencv-4.7.0/samples/java/sbt/src/main/resources/img2.png
new file mode 100644
index 00000000..41959c66
Binary files /dev/null and b/C++/opencv-4.7.0/samples/java/sbt/src/main/resources/img2.png differ
diff --git a/C++/opencv-4.7.0/samples/java/sbt/src/main/scala/Main.scala b/C++/opencv-4.7.0/samples/java/sbt/src/main/scala/Main.scala
new file mode 100644
index 00000000..6f07aa19
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/sbt/src/main/scala/Main.scala
@@ -0,0 +1,23 @@
+/*
+ * The main runner for the Java demos.
+ * Demos whose name begins with "Scala" are written in the Scala language,
+ * demonstrating the generic nature of the interface.
+ * The other demos are in Java.
+ * Currently, all demos are run, sequentially.
+ *
+ * You're invited to submit your own examples, in any JVM language of
+ * your choosing so long as you can get them to build.
+ */
+
+import org.opencv.core.Core
+
+object Main extends App {
+  // We must load the native library before using any OpenCV functions.
+  // You must load this library _exactly once_ per Java invocation.
+  // If you load it more than once, you will get a java.lang.UnsatisfiedLinkError.
+  System.loadLibrary(Core.NATIVE_LIBRARY_NAME)
+
+  ScalaCorrespondenceMatchingDemo.run()
+  ScalaDetectFaceDemo.run()
+  new DetectFaceDemo().run()
+}
diff --git a/C++/opencv-4.7.0/samples/java/sbt/src/main/scala/ScalaCorrespondenceMatchingDemo.scala b/C++/opencv-4.7.0/samples/java/sbt/src/main/scala/ScalaCorrespondenceMatchingDemo.scala
new file mode 100644
index 00000000..47eae315
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/sbt/src/main/scala/ScalaCorrespondenceMatchingDemo.scala
@@ -0,0 +1,69 @@
+import org.opencv.imgcodecs.Imgcodecs
+import org.opencv.features2d.DescriptorExtractor
+import org.opencv.features2d.Features2d
+import org.opencv.core.MatOfKeyPoint
+import org.opencv.core.Mat
+import org.opencv.features2d.FeatureDetector
+import org.opencv.features2d.DescriptorMatcher
+import org.opencv.core.MatOfDMatch
+import reflect._
+
+/*
+ * Finds corresponding points between a pair of images using local descriptors.
+ * The correspondences are visualized in the image "scalaCorrespondences.png",
+ * which is written to disk.
+ */
+object ScalaCorrespondenceMatchingDemo {
+  def run() {
+    println(s"\nRunning ${classTag[this.type].toString.replace("$", "")}")
+
+    // Detects keypoints and extracts descriptors in a given image of type Mat.
+    def detectAndExtract(mat: Mat) = {
+      // A special container class for KeyPoint.
+      val keyPoints = new MatOfKeyPoint
+      // We're using the ORB detector.
+      val detector = FeatureDetector.create(FeatureDetector.ORB)
+      detector.detect(mat, keyPoints)
+
+      println(s"There were ${keyPoints.toArray.size} KeyPoints detected")
+
+      // Let's just use the best KeyPoints.
+      val sorted = keyPoints.toArray.sortBy(_.response).reverse.take(50)
+      // There isn't a constructor that takes Array[KeyPoint], so we unpack
+      // the array and use the constructor that can take any number of
+      // arguments.
+      val bestKeyPoints: MatOfKeyPoint = new MatOfKeyPoint(sorted: _*)
+
+      // We're using the ORB descriptor.
+      val extractor = DescriptorExtractor.create(DescriptorExtractor.ORB)
+      val descriptors = new Mat
+      extractor.compute(mat, bestKeyPoints, descriptors)
+
+      println(s"${descriptors.rows} descriptors were extracted, each with dimension ${descriptors.cols}")
+
+      (bestKeyPoints, descriptors)
+    }
+
+    // Load the images from the |resources| directory.
+    val leftImage = Imgcodecs.imread(getClass.getResource("/img1.png").getPath)
+    val rightImage = Imgcodecs.imread(getClass.getResource("/img2.png").getPath)
+
+    // Detect KeyPoints and extract descriptors.
+    val (leftKeyPoints, leftDescriptors) = detectAndExtract(leftImage)
+    val (rightKeyPoints, rightDescriptors) = detectAndExtract(rightImage)
+
+    // Match the descriptors.
+    val matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE)
+    // A special container class for DMatch.
+    val dmatches = new MatOfDMatch
+    // The backticks are because "match" is a keyword in Scala.
+    matcher.`match`(leftDescriptors, rightDescriptors, dmatches)
+
+    // Visualize the matches and save the visualization.
+    val correspondenceImage = new Mat
+    Features2d.drawMatches(leftImage, leftKeyPoints, rightImage, rightKeyPoints, dmatches, correspondenceImage)
+    val filename = "scalaCorrespondences.png"
+    println(s"Writing ${filename}")
+    assert(Imgcodecs.imwrite(filename, correspondenceImage))
+  }
+}
diff --git a/C++/opencv-4.7.0/samples/java/sbt/src/main/scala/ScalaDetectFaceDemo.scala b/C++/opencv-4.7.0/samples/java/sbt/src/main/scala/ScalaDetectFaceDemo.scala
new file mode 100644
index 00000000..cf8a1a2e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/sbt/src/main/scala/ScalaDetectFaceDemo.scala
@@ -0,0 +1,44 @@
+import org.opencv.core.Core
+import org.opencv.core.MatOfRect
+import org.opencv.core.Point
+import org.opencv.core.Scalar
+import org.opencv.imgcodecs.Imgcodecs
+import org.opencv.imgproc.Imgproc
+import org.opencv.objdetect.CascadeClassifier
+import reflect._
+
+/*
+ * Detects faces in an image, draws boxes around them, and writes the results
+ * to "scalaFaceDetection.png".
+ */
+object ScalaDetectFaceDemo {
+  def run() {
+    println(s"\nRunning ${classTag[this.type].toString.replace("$", "")}")
+
+    // Create a face detector from the cascade file in the resources directory.
+    val faceDetector = new CascadeClassifier(getClass.getResource("/lbpcascade_frontalface.xml").getPath)
+    val image = Imgcodecs.imread(getClass.getResource("/AverageMaleFace.jpg").getPath)
+
+    // Detect faces in the image.
+    // MatOfRect is a special container class for Rect.
+    val faceDetections = new MatOfRect
+    faceDetector.detectMultiScale(image, faceDetections)
+
+    println(s"Detected ${faceDetections.toArray.size} faces")
+
+    // Draw a bounding box around each face.
+    for (rect <- faceDetections.toArray) {
+      Imgproc.rectangle(
+        image,
+        new Point(rect.x, rect.y),
+        new Point(rect.x + rect.width,
+          rect.y + rect.height),
+        new Scalar(0, 255, 0))
+    }
+
+    // Save the visualized detection.
+    val filename = "scalaFaceDetection.png"
+    println(s"Writing ${filename}")
+    assert(Imgcodecs.imwrite(filename, image))
+  }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/CMakeLists.txt b/C++/opencv-4.7.0/samples/java/tutorial_code/CMakeLists.txt
new file mode 100644
index 00000000..31424f95
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/CMakeLists.txt
@@ -0,0 +1,39 @@
+# ----------------------------------------------------------------------------
+#  CMake file for Java tutorials compilation.
+#
+# ----------------------------------------------------------------------------
+if(NOT ANT_EXECUTABLE OR NOT TARGET opencv_java)
+  return()
+endif()
+
+project(compile_java_tutorials)
+
+set(curdir "${CMAKE_CURRENT_SOURCE_DIR}")
+set(opencv_tutorial_java_bin_dir "${CMAKE_CURRENT_BINARY_DIR}/.compiled")
+set(TUTORIALS_DIRS "")
+
+file(GLOB children RELATIVE ${curdir} ${curdir}/*/*)
+foreach(child ${children})
+  if(IS_DIRECTORY ${curdir}/${child})
+    file(GLOB contains_java_files "${child}/*.java")
+    if(contains_java_files)
+      list(APPEND TUTORIALS_DIRS ${child})
+    endif()
+  endif()
+endforeach()
+
+add_custom_target("${PROJECT_NAME}"
+                  DEPENDS opencv_java
+                 )
+
+foreach(TUTORIAL_DIR ${TUTORIALS_DIRS})
+  get_filename_component(TUTORIAL_NAME ${TUTORIAL_DIR} NAME_WE)
+  add_custom_command(TARGET "${PROJECT_NAME}"
+                     COMMAND ${ANT_EXECUTABLE} -q
+                          -DocvJarDir="${OpenCV_BINARY_DIR}/bin"
+                          -DsrcDir="${TUTORIAL_DIR}"
+                          -DdstDir="${opencv_tutorial_java_bin_dir}/${TUTORIAL_NAME}"
+                     WORKING_DIRECTORY "${curdir}"
+                     COMMENT "Compile the tutorial: ${TUTORIAL_NAME}"
+                    )
+endforeach()
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/back_projection/CalcBackProjectDemo1.java b/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/back_projection/CalcBackProjectDemo1.java
new file mode 100644
index 00000000..d2e03c88
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/back_projection/CalcBackProjectDemo1.java
@@ -0,0 +1,173 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfFloat;
+import org.opencv.core.MatOfInt;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class CalcBackProject1 {
+    private Mat hue;
+    private Mat histImg = new Mat();
+    private JFrame frame;
+    private JLabel imgLabel;
+    private JLabel backprojLabel;
+    private JLabel histImgLabel;
+    private static final int MAX_SLIDER = 180;
+    private int bins = 25;
+
+    public CalcBackProject1(String[] args) {
+        //! [Read the image]
+        if (args.length != 1) {
+            System.err.println("You must supply one argument that corresponds to the path to the image.");
+            System.exit(0);
+        }
+
+        Mat src = Imgcodecs.imread(args[0]);
+        if (src.empty()) {
+            System.err.println("Empty image: " + args[0]);
+            System.exit(0);
+        }
+        //! [Read the image]
+
+        //! [Transform it to HSV]
+        Mat hsv = new Mat();
+        Imgproc.cvtColor(src, hsv, Imgproc.COLOR_BGR2HSV);
+        //! [Transform it to HSV]
+
+        //! [Use only the Hue value]
+        hue = new Mat(hsv.size(), hsv.depth());
+        Core.mixChannels(Arrays.asList(hsv), Arrays.asList(hue), new MatOfInt(0, 0));
+        //! [Use only the Hue value]
+
+        // Create and set up the window.
+        frame = new JFrame("Back Projection 1 demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        //! [Show the image]
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        //! [Show the image]
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        //! [Create Trackbar to enter the number of bins]
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        sliderPanel.add(new JLabel("* Hue  bins: "));
+        JSlider slider = new JSlider(0, MAX_SLIDER, bins);
+        slider.setMajorTickSpacing(25);
+        slider.setMinorTickSpacing(5);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                bins = source.getValue();
+                update();
+            }
+        });
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+        //! [Create Trackbar to enter the number of bins]
+
+        JPanel imgPanel = new JPanel();
+        imgLabel = new JLabel(new ImageIcon(img));
+        imgPanel.add(imgLabel);
+
+        backprojLabel = new JLabel();
+        imgPanel.add(backprojLabel);
+
+        histImgLabel = new JLabel();
+        imgPanel.add(histImgLabel);
+        pane.add(imgPanel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        //! [initialize]
+        int histSize = Math.max(bins, 2);
+        float[] hueRange = {0, 180};
+        //! [initialize]
+
+        //! [Get the Histogram and normalize it]
+        Mat hist = new Mat();
+        List<Mat> hueList = Arrays.asList(hue);
+        Imgproc.calcHist(hueList, new MatOfInt(0), new Mat(), hist, new MatOfInt(histSize), new MatOfFloat(hueRange), false);
+        Core.normalize(hist, hist, 0, 255, Core.NORM_MINMAX);
+        //! [Get the Histogram and normalize it]
+
+        //! [Get Backprojection]
+        Mat backproj = new Mat();
+        Imgproc.calcBackProject(hueList, new MatOfInt(0), hist, backproj, new MatOfFloat(hueRange), 1);
+        //! [Get Backprojection]
+
+        //! [Draw the backproj]
+        Image backprojImg = HighGui.toBufferedImage(backproj);
+        backprojLabel.setIcon(new ImageIcon(backprojImg));
+        //! [Draw the backproj]
+
+        //! [Draw the histogram]
+        int w = 400, h = 400;
+        int binW = (int) Math.round((double) w / histSize);
+        histImg = Mat.zeros(h, w, CvType.CV_8UC3);
+
+        float[] histData = new float[(int) (hist.total() * hist.channels())];
+        hist.get(0, 0, histData);
+        for (int i = 0; i < bins; i++) {
+            Imgproc.rectangle(histImg, new Point(i * binW, h),
+                    new Point((i + 1) * binW, h - Math.round(histData[i] * h / 255.0)), new Scalar(0, 0, 255), Imgproc.FILLED);
+        }
+        Image histImage = HighGui.toBufferedImage(histImg);
+        histImgLabel.setIcon(new ImageIcon(histImage));
+        //! [Draw the histogram]
+
+        frame.repaint();
+        frame.pack();
+    }
+}
+
+public class CalcBackProjectDemo1 {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new CalcBackProject1(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/back_projection/CalcBackProjectDemo2.java b/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/back_projection/CalcBackProjectDemo2.java
new file mode 100644
index 00000000..a0ab39eb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/back_projection/CalcBackProjectDemo2.java
@@ -0,0 +1,189 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfFloat;
+import org.opencv.core.MatOfInt;
+import org.opencv.core.Point;
+import org.opencv.core.Range;
+import org.opencv.core.Rect;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class CalcBackProject2 {
+    private Mat src;
+    private Mat hsv = new Mat();
+    private Mat mask = new Mat();
+    private JFrame frame;
+    private JLabel imgLabel;
+    private JLabel backprojLabel;
+    private JLabel maskImgLabel;
+    private static final int MAX_SLIDER = 255;
+    private int low = 20;
+    private int up = 20;
+
+    public CalcBackProject2(String[] args) {
+        /// Read the image
+        if (args.length != 1) {
+            System.err.println("You must supply one argument that corresponds to the path to the image.");
+            System.exit(0);
+        }
+
+        src = Imgcodecs.imread(args[0]);
+        if (src.empty()) {
+            System.err.println("Empty image: " + args[0]);
+            System.exit(0);
+        }
+
+        /// Transform it to HSV
+        Imgproc.cvtColor(src, hsv, Imgproc.COLOR_BGR2HSV);
+
+        // Create and set up the window.
+        frame = new JFrame("Back Projection 2 demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        /// Set Trackbars for floodfill thresholds
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        sliderPanel.add(new JLabel("Low thresh"));
+        JSlider slider = new JSlider(0, MAX_SLIDER, low);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                low = source.getValue();
+            }
+        });
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        sliderPanel.add(new JLabel("High thresh"));
+        slider = new JSlider(0, MAX_SLIDER, up);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                up = source.getValue();
+            }
+        });
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        JPanel imgPanel = new JPanel();
+        imgLabel = new JLabel(new ImageIcon(img));
+        /// Set a Mouse Callback
+        imgLabel.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                update(e.getX(), e.getY());
+            }
+        });
+        imgPanel.add(imgLabel);
+
+        maskImgLabel = new JLabel();
+        imgPanel.add(maskImgLabel);
+
+        backprojLabel = new JLabel();
+        imgPanel.add(backprojLabel);
+
+        pane.add(imgPanel, BorderLayout.CENTER);
+    }
+
+    private void update(int x, int y) {
+        // Fill and get the mask
+        Point seed = new Point(x, y);
+
+        int newMaskVal = 255;
+        Scalar newVal = new Scalar(120, 120, 120);
+
+        int connectivity = 8;
+        int flags = connectivity + (newMaskVal << 8) + Imgproc.FLOODFILL_FIXED_RANGE + Imgproc.FLOODFILL_MASK_ONLY;
+
+        Mat mask2 = Mat.zeros(src.rows() + 2, src.cols() + 2, CvType.CV_8U);
+        Imgproc.floodFill(src, mask2, seed, newVal, new Rect(), new Scalar(low, low, low), new Scalar(up, up, up), flags);
+        mask = mask2.submat(new Range(1, mask2.rows() - 1), new Range(1, mask2.cols() - 1));
+
+        Image maskImg = HighGui.toBufferedImage(mask);
+        maskImgLabel.setIcon(new ImageIcon(maskImg));
+
+        int hBins = 30, sBins = 32;
+        int[] histSize = { hBins, sBins };
+        float[] ranges = { 0, 180, 0, 256 };
+        int[] channels = { 0, 1 };
+
+        /// Get the Histogram and normalize it
+        Mat hist = new Mat();
+        List<Mat> hsvList = Arrays.asList(hsv);
+        Imgproc.calcHist(hsvList, new MatOfInt(channels), mask, hist, new MatOfInt(histSize), new MatOfFloat(ranges), false );
+
+        Core.normalize(hist, hist, 0, 255, Core.NORM_MINMAX);
+
+        /// Get Backprojection
+        Mat backproj = new Mat();
+        Imgproc.calcBackProject(hsvList, new MatOfInt(channels), hist, backproj, new MatOfFloat(ranges), 1);
+
+        Image backprojImg = HighGui.toBufferedImage(backproj);
+        backprojLabel.setIcon(new ImageIcon(backprojImg));
+
+        frame.repaint();
+        frame.pack();
+    }
+}
+
+public class CalcBackProjectDemo2 {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new CalcBackProject2(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/histogram_calculation/CalcHistDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/histogram_calculation/CalcHistDemo.java
new file mode 100644
index 00000000..16874e7e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/histogram_calculation/CalcHistDemo.java
@@ -0,0 +1,99 @@
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfFloat;
+import org.opencv.core.MatOfInt;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class CalcHist {
+    public void run(String[] args) {
+        //! [Load image]
+        String filename = args.length > 0 ? args[0] : "../data/lena.jpg";
+        Mat src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+        //! [Load image]
+
+        //! [Separate the image in 3 places ( B, G and R )]
+        List<Mat> bgrPlanes = new ArrayList<>();
+        Core.split(src, bgrPlanes);
+        //! [Separate the image in 3 places ( B, G and R )]
+
+        //! [Establish the number of bins]
+        int histSize = 256;
+        //! [Establish the number of bins]
+
+        //! [Set the ranges ( for B,G,R) )]
+        float[] range = {0, 256}; //the upper boundary is exclusive
+        MatOfFloat histRange = new MatOfFloat(range);
+        //! [Set the ranges ( for B,G,R) )]
+
+        //! [Set histogram param]
+        boolean accumulate = false;
+        //! [Set histogram param]
+
+        //! [Compute the histograms]
+        Mat bHist = new Mat(), gHist = new Mat(), rHist = new Mat();
+        Imgproc.calcHist(bgrPlanes, new MatOfInt(0), new Mat(), bHist, new MatOfInt(histSize), histRange, accumulate);
+        Imgproc.calcHist(bgrPlanes, new MatOfInt(1), new Mat(), gHist, new MatOfInt(histSize), histRange, accumulate);
+        Imgproc.calcHist(bgrPlanes, new MatOfInt(2), new Mat(), rHist, new MatOfInt(histSize), histRange, accumulate);
+        //! [Compute the histograms]
+
+        //! [Draw the histograms for B, G and R]
+        int histW = 512, histH = 400;
+        int binW = (int) Math.round((double) histW / histSize);
+
+        Mat histImage = new Mat( histH, histW, CvType.CV_8UC3, new Scalar( 0,0,0) );
+        //! [Draw the histograms for B, G and R]
+
+        //! [Normalize the result to ( 0, histImage.rows )]
+        Core.normalize(bHist, bHist, 0, histImage.rows(), Core.NORM_MINMAX);
+        Core.normalize(gHist, gHist, 0, histImage.rows(), Core.NORM_MINMAX);
+        Core.normalize(rHist, rHist, 0, histImage.rows(), Core.NORM_MINMAX);
+        //! [Normalize the result to ( 0, histImage.rows )]
+
+        //! [Draw for each channel]
+        float[] bHistData = new float[(int) (bHist.total() * bHist.channels())];
+        bHist.get(0, 0, bHistData);
+        float[] gHistData = new float[(int) (gHist.total() * gHist.channels())];
+        gHist.get(0, 0, gHistData);
+        float[] rHistData = new float[(int) (rHist.total() * rHist.channels())];
+        rHist.get(0, 0, rHistData);
+
+        for( int i = 1; i < histSize; i++ ) {
+            Imgproc.line(histImage, new Point(binW * (i - 1), histH - Math.round(bHistData[i - 1])),
+                    new Point(binW * (i), histH - Math.round(bHistData[i])), new Scalar(255, 0, 0), 2);
+            Imgproc.line(histImage, new Point(binW * (i - 1), histH - Math.round(gHistData[i - 1])),
+                    new Point(binW * (i), histH - Math.round(gHistData[i])), new Scalar(0, 255, 0), 2);
+            Imgproc.line(histImage, new Point(binW * (i - 1), histH - Math.round(rHistData[i - 1])),
+                    new Point(binW * (i), histH - Math.round(rHistData[i])), new Scalar(0, 0, 255), 2);
+        }
+        //! [Draw for each channel]
+
+        //! [Display]
+        HighGui.imshow( "Source image", src );
+        HighGui.imshow( "calcHist Demo", histImage );
+        HighGui.waitKey(0);
+        //! [Display]
+
+        System.exit(0);
+    }
+}
+
+public class CalcHistDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new CalcHist().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/histogram_comparison/CompareHistDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/histogram_comparison/CompareHistDemo.java
new file mode 100644
index 00000000..fb65dc6d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/histogram_comparison/CompareHistDemo.java
@@ -0,0 +1,91 @@
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfFloat;
+import org.opencv.core.MatOfInt;
+import org.opencv.core.Range;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class CompareHist {
+    public void run(String[] args) {
+        //! [Load three images with different environment settings]
+        if (args.length != 3) {
+            System.err.println("You must supply 3 arguments that correspond to the paths to 3 images.");
+            System.exit(0);
+        }
+        Mat srcBase = Imgcodecs.imread(args[0]);
+        Mat srcTest1 = Imgcodecs.imread(args[1]);
+        Mat srcTest2 = Imgcodecs.imread(args[2]);
+        if (srcBase.empty() || srcTest1.empty() || srcTest2.empty()) {
+            System.err.println("Cannot read the images");
+            System.exit(0);
+        }
+        //! [Load three images with different environment settings]
+
+        //! [Convert to HSV]
+        Mat hsvBase = new Mat(), hsvTest1 = new Mat(), hsvTest2 = new Mat();
+        Imgproc.cvtColor( srcBase, hsvBase, Imgproc.COLOR_BGR2HSV );
+        Imgproc.cvtColor( srcTest1, hsvTest1, Imgproc.COLOR_BGR2HSV );
+        Imgproc.cvtColor( srcTest2, hsvTest2, Imgproc.COLOR_BGR2HSV );
+        //! [Convert to HSV]
+
+        //! [Convert to HSV half]
+        Mat hsvHalfDown = hsvBase.submat( new Range( hsvBase.rows()/2, hsvBase.rows() - 1 ), new Range( 0, hsvBase.cols() - 1 ) );
+        //! [Convert to HSV half]
+
+        //! [Using 50 bins for hue and 60 for saturation]
+        int hBins = 50, sBins = 60;
+        int[] histSize = { hBins, sBins };
+
+        // hue varies from 0 to 179, saturation from 0 to 255
+        float[] ranges = { 0, 180, 0, 256 };
+
+        // Use the 0-th and 1-st channels
+        int[] channels = { 0, 1 };
+        //! [Using 50 bins for hue and 60 for saturation]
+
+        //! [Calculate the histograms for the HSV images]
+        Mat histBase = new Mat(), histHalfDown = new Mat(), histTest1 = new Mat(), histTest2 = new Mat();
+
+        List<Mat> hsvBaseList = Arrays.asList(hsvBase);
+        Imgproc.calcHist(hsvBaseList, new MatOfInt(channels), new Mat(), histBase, new MatOfInt(histSize), new MatOfFloat(ranges), false);
+        Core.normalize(histBase, histBase, 0, 1, Core.NORM_MINMAX);
+
+        List<Mat> hsvHalfDownList = Arrays.asList(hsvHalfDown);
+        Imgproc.calcHist(hsvHalfDownList, new MatOfInt(channels), new Mat(), histHalfDown, new MatOfInt(histSize), new MatOfFloat(ranges), false);
+        Core.normalize(histHalfDown, histHalfDown, 0, 1, Core.NORM_MINMAX);
+
+        List<Mat> hsvTest1List = Arrays.asList(hsvTest1);
+        Imgproc.calcHist(hsvTest1List, new MatOfInt(channels), new Mat(), histTest1, new MatOfInt(histSize), new MatOfFloat(ranges), false);
+        Core.normalize(histTest1, histTest1, 0, 1, Core.NORM_MINMAX);
+
+        List<Mat> hsvTest2List = Arrays.asList(hsvTest2);
+        Imgproc.calcHist(hsvTest2List, new MatOfInt(channels), new Mat(), histTest2, new MatOfInt(histSize), new MatOfFloat(ranges), false);
+        Core.normalize(histTest2, histTest2, 0, 1, Core.NORM_MINMAX);
+        //! [Calculate the histograms for the HSV images]
+
+        //! [Apply the histogram comparison methods]
+        for( int compareMethod = 0; compareMethod < 4; compareMethod++ ) {
+            double baseBase = Imgproc.compareHist( histBase, histBase, compareMethod );
+            double baseHalf = Imgproc.compareHist( histBase, histHalfDown, compareMethod );
+            double baseTest1 = Imgproc.compareHist( histBase, histTest1, compareMethod );
+            double baseTest2 = Imgproc.compareHist( histBase, histTest2, compareMethod );
+
+            System.out.println("Method " + compareMethod + " Perfect, Base-Half, Base-Test(1), Base-Test(2) : " + baseBase + " / " + baseHalf
+                    + " / " + baseTest1 + " / " + baseTest2);
+        }
+        //! [Apply the histogram comparison methods]
+    }
+}
+
+public class CompareHistDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new CompareHist().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/histogram_equalization/EqualizeHistDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/histogram_equalization/EqualizeHistDemo.java
new file mode 100644
index 00000000..09192430
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/Histograms_Matching/histogram_equalization/EqualizeHistDemo.java
@@ -0,0 +1,49 @@
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class EqualizeHist {
+    public void run(String[] args) {
+        //! [Load image]
+        String filename = args.length > 0 ? args[0] : "../data/lena.jpg";
+        Mat src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+        //! [Load image]
+
+        //! [Convert to grayscale]
+        Imgproc.cvtColor(src, src, Imgproc.COLOR_BGR2GRAY);
+        //! [Convert to grayscale]
+
+        //! [Apply Histogram Equalization]
+        Mat dst = new Mat();
+        Imgproc.equalizeHist( src, dst );
+        //! [Apply Histogram Equalization]
+
+        //! [Display results]
+        HighGui.imshow( "Source image", src );
+        HighGui.imshow( "Equalized Image", dst );
+        //! [Display results]
+
+        //! [Wait until user exits the program]
+        HighGui.waitKey(0);
+        //! [Wait until user exits the program]
+
+        System.exit(0);
+    }
+}
+
+public class EqualizeHistDemo {
+
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new EqualizeHist().run(args);
+    }
+
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/BasicGeometricDrawing/BasicGeometricDrawing.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/BasicGeometricDrawing/BasicGeometricDrawing.java
new file mode 100644
index 00000000..d59d9903
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/BasicGeometricDrawing/BasicGeometricDrawing.java
@@ -0,0 +1,186 @@
+import org.opencv.core.*;
+import org.opencv.core.Point;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgproc.Imgproc;
+
+import java.util.*;
+import java.util.List;
+
+class GeometricDrawingRun{
+
+    private static final int W = 400;
+
+    public void run(){
+        //! [create_images]
+        /// Windows names
+        String atom_window = "Drawing 1: Atom";
+        String rook_window = "Drawing 2: Rook";
+
+        /// Create black empty images
+        Mat atom_image = Mat.zeros( W, W, CvType.CV_8UC3 );
+        Mat rook_image = Mat.zeros( W, W, CvType.CV_8UC3 );
+        //! [create_images]
+
+        //! [draw_atom]
+        /// 1. Draw a simple atom:
+        /// -----------------------
+        MyEllipse( atom_image, 90.0 );
+        MyEllipse( atom_image, 0.0 );
+        MyEllipse( atom_image, 45.0 );
+        MyEllipse( atom_image, -45.0 );
+
+        /// 1.b. Creating circles
+        MyFilledCircle( atom_image, new Point( W/2, W/2) );
+        //! [draw_atom]
+
+        //! [draw_rook]
+        /// 2. Draw a rook
+        /// ------------------
+        /// 2.a. Create a convex polygon
+        MyPolygon( rook_image );
+
+        //! [rectangle]
+        /// 2.b. Creating rectangles
+        Imgproc.rectangle( rook_image,
+                new Point( 0, 7*W/8 ),
+                new Point( W, W),
+                new Scalar( 0, 255, 255 ),
+                -1,
+                8,
+                0 );
+        //! [rectangle]
+
+        /// 2.c. Create a few lines
+        MyLine( rook_image, new Point( 0, 15*W/16 ), new Point( W, 15*W/16 ) );
+        MyLine( rook_image, new Point( W/4, 7*W/8 ), new Point( W/4, W ) );
+        MyLine( rook_image, new Point( W/2, 7*W/8 ), new Point( W/2, W ) );
+        MyLine( rook_image, new Point( 3*W/4, 7*W/8 ), new Point( 3*W/4, W ) );
+        //! [draw_rook]
+
+        /// 3. Display your stuff!
+        HighGui.imshow( atom_window, atom_image );
+        HighGui.moveWindow( atom_window, 0, 200 );
+        HighGui.imshow( rook_window, rook_image );
+        HighGui.moveWindow( rook_window, W, 200 );
+
+        HighGui.waitKey( 0 );
+        System.exit(0);
+    }
+
+    /// Function Declaration
+
+    /**
+     * @function MyEllipse
+     * @brief Draw a fixed-size ellipse with different angles
+     */
+    //! [my_ellipse]
+    private void MyEllipse( Mat img, double angle ) {
+        int thickness = 2;
+        int lineType = 8;
+        int shift = 0;
+
+        Imgproc.ellipse( img,
+                new Point( W/2, W/2 ),
+                new Size( W/4, W/16 ),
+                angle,
+                0.0,
+                360.0,
+                new Scalar( 255, 0, 0 ),
+                thickness,
+                lineType,
+                shift );
+    }
+    //! [my_ellipse]
+    /**
+     * @function MyFilledCircle
+     * @brief Draw a fixed-size filled circle
+     */
+    //! [my_filled_circle]
+    private void MyFilledCircle( Mat img, Point center ) {
+        int thickness = -1;
+        int lineType = 8;
+        int shift = 0;
+
+        Imgproc.circle( img,
+                center,
+                W/32,
+                new Scalar( 0, 0, 255 ),
+                thickness,
+                lineType,
+                shift );
+    }
+    //! [my_filled_circle]
+    /**
+     * @function MyPolygon
+     * @function Draw a simple concave polygon (rook)
+     */
+    //! [my_polygon]
+    private void MyPolygon( Mat img ) {
+        int lineType = 8;
+        int shift = 0;
+
+        /** Create some points */
+        Point[] rook_points = new Point[20];
+        rook_points[0]  = new Point(     W/4, 7*W/8   );
+        rook_points[1]  = new Point(   3*W/4, 7*W/8   );
+        rook_points[2]  = new Point(   3*W/4, 13*W/16 );
+        rook_points[3]  = new Point( 11*W/16, 13*W/16 );
+        rook_points[4]  = new Point( 19*W/32, 3*W/8   );
+        rook_points[5]  = new Point(   3*W/4, 3*W/8   );
+        rook_points[6]  = new Point(   3*W/4, W/8     );
+        rook_points[7]  = new Point( 26*W/40, W/8     );
+        rook_points[8]  = new Point( 26*W/40, W/4     );
+        rook_points[9]  = new Point( 22*W/40, W/4     );
+        rook_points[10] = new Point( 22*W/40, W/8     );
+        rook_points[11] = new Point( 18*W/40, W/8     );
+        rook_points[12] = new Point( 18*W/40, W/4     );
+        rook_points[13] = new Point( 14*W/40, W/4     );
+        rook_points[14] = new Point( 14*W/40, W/8     );
+        rook_points[15] = new Point(     W/4, W/8     );
+        rook_points[16] = new Point(     W/4, 3*W/8   );
+        rook_points[17] = new Point( 13*W/32, 3*W/8   );
+        rook_points[18] = new Point(  5*W/16, 13*W/16 );
+        rook_points[19] = new Point(     W/4, 13*W/16 );
+
+        MatOfPoint matPt = new MatOfPoint();
+        matPt.fromArray(rook_points);
+
+        List<MatOfPoint> ppt = new ArrayList<MatOfPoint>();
+        ppt.add(matPt);
+
+        Imgproc.fillPoly(img,
+                ppt,
+                new Scalar( 255, 255, 255 ),
+                lineType,
+                shift,
+                new Point(0,0) );
+    }
+    //! [my_polygon]
+    /**
+     * @function MyLine
+     * @brief Draw a simple line
+     */
+    //! [my_line]
+    private void MyLine( Mat img, Point start, Point end ) {
+        int thickness = 2;
+        int lineType = 8;
+        int shift = 0;
+
+        Imgproc.line( img,
+                start,
+                end,
+                new Scalar( 0, 0, 0 ),
+                thickness,
+                lineType,
+                shift );
+    }
+    //! [my_line]
+}
+
+public class BasicGeometricDrawing {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new GeometricDrawingRun().run();
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/HitMiss/HitMiss.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/HitMiss/HitMiss.java
new file mode 100644
index 00000000..806537f8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/HitMiss/HitMiss.java
@@ -0,0 +1,58 @@
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgproc.Imgproc;
+
+class HitMissRun{
+
+    public void run() {
+        Mat input_image = new Mat( 8, 8, CvType.CV_8UC1 );
+        int row = 0, col = 0;
+        input_image.put(row ,col,
+                0, 0, 0, 0, 0, 0, 0, 0,
+                0, 255, 255, 255, 0, 0, 0, 255,
+                0, 255, 255, 255, 0, 0, 0, 0,
+                0, 255, 255, 255, 0, 255, 0, 0,
+                0, 0, 255, 0, 0, 0, 0, 0,
+                0, 0, 255, 0, 0, 255, 255, 0,
+                0, 255, 0, 255, 0, 0, 255, 0,
+                0, 255, 255, 255, 0, 0, 0, 0);
+
+        Mat kernel = new Mat( 3, 3, CvType.CV_16S );
+        kernel.put(row ,col,
+                0, 1, 0,
+                1, -1, 1,
+                0, 1, 0 );
+
+        Mat output_image = new Mat();
+        Imgproc.morphologyEx(input_image, output_image, Imgproc.MORPH_HITMISS, kernel);
+
+        int rate = 50;
+        Core.add(kernel, new Scalar(1), kernel);
+        Core.multiply(kernel, new Scalar(127), kernel);
+        kernel.convertTo(kernel, CvType.CV_8U);
+
+        Imgproc.resize(kernel, kernel, new Size(), rate, rate, Imgproc.INTER_NEAREST);
+        HighGui.imshow("kernel", kernel);
+        HighGui.moveWindow("kernel", 0, 0);
+
+        Imgproc.resize(input_image, input_image, new Size(), rate, rate, Imgproc.INTER_NEAREST);
+        HighGui.imshow("Original", input_image);
+        HighGui.moveWindow("Original", 0, 200);
+
+        Imgproc.resize(output_image, output_image, new Size(), rate, rate, Imgproc.INTER_NEAREST);
+        HighGui.imshow("Hit or Miss", output_image);
+        HighGui.moveWindow("Hit or Miss", 500, 200);
+
+        HighGui.waitKey(0);
+        System.exit(0);
+    }
+}
+
+public class HitMiss
+{
+    public static void main(String[] args) {
+        // load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new HitMissRun().run();
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/Pyramids/Pyramids.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/Pyramids/Pyramids.java
new file mode 100644
index 00000000..b4ada166
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/Pyramids/Pyramids.java
@@ -0,0 +1,67 @@
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class PyramidsRun {
+
+    String window_name = "Pyramids Demo";
+
+    public void run(String[] args) {
+        /// General instructions
+        System.out.println("\n" +
+                " Zoom In-Out demo    \n" +
+                "------------------   \n" +
+                " * [i] -> Zoom [i]n  \n" +
+                " * [o] -> Zoom [o]ut \n" +
+                " * [ESC] -> Close program \n");
+
+        //! [load]
+        String filename = ((args.length > 0) ? args[0] : "../data/chicky_512.png");
+
+        // Load the image
+        Mat src = Imgcodecs.imread(filename);
+
+        // Check if image is loaded fine
+        if( src.empty() ) {
+            System.out.println("Error opening image!");
+            System.out.println("Program Arguments: [image_name -- default ../data/chicky_512.png] \n");
+            System.exit(-1);
+        }
+        //! [load]
+
+        //! [loop]
+        while (true){
+            //! [show_image]
+            HighGui.imshow( window_name, src );
+            //! [show_image]
+            char c = (char) HighGui.waitKey(0);
+            c = Character.toLowerCase(c);
+
+            if( c == 27 ){
+                break;
+                //![pyrup]
+            }else if( c == 'i'){
+                Imgproc.pyrUp( src, src, new Size( src.cols()*2, src.rows()*2 ) );
+                System.out.println( "** Zoom In: Image x 2" );
+                //![pyrup]
+                //![pyrdown]
+            }else if( c == 'o'){
+                Imgproc.pyrDown( src, src, new Size( src.cols()/2, src.rows()/2 ) );
+                System.out.println( "** Zoom Out: Image / 2" );
+                //![pyrdown]
+            }
+        }
+        //! [loop]
+
+        System.exit(0);
+    }
+}
+
+public class Pyramids {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new PyramidsRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/Smoothing/Smoothing.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/Smoothing/Smoothing.java
new file mode 100644
index 00000000..8b5a8330
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/Smoothing/Smoothing.java
@@ -0,0 +1,101 @@
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class SmoothingRun {
+
+    ///  Global Variables
+    int DELAY_CAPTION = 1500;
+    int DELAY_BLUR = 100;
+    int MAX_KERNEL_LENGTH = 31;
+
+    Mat src = new Mat(), dst = new Mat();
+    String windowName = "Filter Demo 1";
+
+    public void run(String[] args) {
+
+        String filename = ((args.length > 0) ? args[0] : "../data/lena.jpg");
+
+        src = Imgcodecs.imread(filename, Imgcodecs.IMREAD_COLOR);
+        if( src.empty() ) {
+            System.out.println("Error opening image");
+            System.out.println("Usage: ./Smoothing [image_name -- default ../data/lena.jpg] \n");
+            System.exit(-1);
+        }
+
+        if( displayCaption( "Original Image" ) != 0 ) { System.exit(0); }
+
+        dst = src.clone();
+        if( displayDst( DELAY_CAPTION ) != 0 ) { System.exit(0); }
+
+        /// Applying Homogeneous blur
+        if( displayCaption( "Homogeneous Blur" ) != 0 ) { System.exit(0); }
+
+        //! [blur]
+        for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
+            Imgproc.blur(src, dst, new Size(i, i), new Point(-1, -1));
+            displayDst(DELAY_BLUR);
+        }
+        //! [blur]
+
+        /// Applying Gaussian blur
+        if( displayCaption( "Gaussian Blur" ) != 0 ) { System.exit(0); }
+
+        //! [gaussianblur]
+        for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
+            Imgproc.GaussianBlur(src, dst, new Size(i, i), 0, 0);
+            displayDst(DELAY_BLUR);
+        }
+        //! [gaussianblur]
+
+        /// Applying Median blur
+        if( displayCaption( "Median Blur" ) != 0 ) { System.exit(0); }
+
+        //! [medianblur]
+        for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
+            Imgproc.medianBlur(src, dst, i);
+            displayDst(DELAY_BLUR);
+        }
+        //! [medianblur]
+
+        /// Applying Bilateral Filter
+        if( displayCaption( "Bilateral Blur" ) != 0 ) { System.exit(0); }
+
+        //![bilateralfilter]
+        for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
+            Imgproc.bilateralFilter(src, dst, i, i * 2, i / 2);
+            displayDst(DELAY_BLUR);
+        }
+        //![bilateralfilter]
+
+        /// Done
+        displayCaption( "Done!" );
+
+        System.exit(0);
+    }
+
+    int displayCaption(String caption) {
+        dst = Mat.zeros(src.size(), src.type());
+        Imgproc.putText(dst, caption,
+                new Point(src.cols() / 4, src.rows() / 2),
+                Imgproc.FONT_HERSHEY_COMPLEX, 1, new Scalar(255, 255, 255));
+
+        return displayDst(DELAY_CAPTION);
+    }
+
+    int displayDst(int delay) {
+        HighGui.imshow( windowName, dst );
+        int c = HighGui.waitKey( delay );
+        if (c >= 0) { return -1; }
+        return 0;
+    }
+}
+
+public class Smoothing {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new SmoothingRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/changing_contrast_brightness_image/BasicLinearTransformsDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/changing_contrast_brightness_image/BasicLinearTransformsDemo.java
new file mode 100644
index 00000000..e55e3d96
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/changing_contrast_brightness_image/BasicLinearTransformsDemo.java
@@ -0,0 +1,86 @@
+import java.util.Scanner;
+
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+
+class BasicLinearTransforms {
+    private byte saturate(double val) {
+        int iVal = (int) Math.round(val);
+        iVal = iVal > 255 ? 255 : (iVal < 0 ? 0 : iVal);
+        return (byte) iVal;
+    }
+
+    public void run(String[] args) {
+        /// Read image given by user
+        //! [basic-linear-transform-load]
+        String imagePath = args.length > 0 ? args[0] : "../data/lena.jpg";
+        Mat image = Imgcodecs.imread(imagePath);
+        if (image.empty()) {
+            System.out.println("Empty image: " + imagePath);
+            System.exit(0);
+        }
+        //! [basic-linear-transform-load]
+
+        //! [basic-linear-transform-output]
+        Mat newImage = Mat.zeros(image.size(), image.type());
+        //! [basic-linear-transform-output]
+
+        //! [basic-linear-transform-parameters]
+        double alpha = 1.0; /*< Simple contrast control */
+        int beta = 0;       /*< Simple brightness control */
+
+        /// Initialize values
+        System.out.println(" Basic Linear Transforms ");
+        System.out.println("-------------------------");
+        try (Scanner scanner = new Scanner(System.in)) {
+            System.out.print("* Enter the alpha value [1.0-3.0]: ");
+            alpha = scanner.nextDouble();
+            System.out.print("* Enter the beta value [0-100]: ");
+            beta = scanner.nextInt();
+        }
+        //! [basic-linear-transform-parameters]
+
+        /// Do the operation newImage(i,j) = alpha*image(i,j) + beta
+        /// Instead of these 'for' loops we could have used simply:
+        /// image.convertTo(newImage, -1, alpha, beta);
+        /// but we wanted to show you how to access the pixels :)
+        //! [basic-linear-transform-operation]
+        byte[] imageData = new byte[(int) (image.total()*image.channels())];
+        image.get(0, 0, imageData);
+        byte[] newImageData = new byte[(int) (newImage.total()*newImage.channels())];
+        for (int y = 0; y < image.rows(); y++) {
+            for (int x = 0; x < image.cols(); x++) {
+                for (int c = 0; c < image.channels(); c++) {
+                    double pixelValue = imageData[(y * image.cols() + x) * image.channels() + c];
+                    /// Java byte range is [-128, 127]
+                    pixelValue = pixelValue < 0 ? pixelValue + 256 : pixelValue;
+                    newImageData[(y * image.cols() + x) * image.channels() + c]
+                            = saturate(alpha * pixelValue + beta);
+                }
+            }
+        }
+        newImage.put(0, 0, newImageData);
+        //! [basic-linear-transform-operation]
+
+        //! [basic-linear-transform-display]
+        /// Show stuff
+        HighGui.imshow("Original Image", image);
+        HighGui.imshow("New Image", newImage);
+
+        /// Wait until user press some key
+        HighGui.waitKey();
+        //! [basic-linear-transform-display]
+        System.exit(0);
+    }
+}
+
+public class BasicLinearTransformsDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new BasicLinearTransforms().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/changing_contrast_brightness_image/ChangingContrastBrightnessImageDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/changing_contrast_brightness_image/ChangingContrastBrightnessImageDemo.java
new file mode 100644
index 00000000..62bdf38b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/changing_contrast_brightness_image/ChangingContrastBrightnessImageDemo.java
@@ -0,0 +1,202 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JCheckBox;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+
+class ChangingContrastBrightnessImage {
+    private static int MAX_VALUE_ALPHA = 500;
+    private static int MAX_VALUE_BETA_GAMMA = 200;
+    private static final String WINDOW_NAME = "Changing the contrast and brightness of an image demo";
+    private static final String ALPHA_NAME = "Alpha gain (contrast)";
+    private static final String BETA_NAME = "Beta bias (brightness)";
+    private static final String GAMMA_NAME = "Gamma correction";
+    private JFrame frame;
+    private Mat matImgSrc = new Mat();
+    private JLabel imgSrcLabel;
+    private JLabel imgModifLabel;
+    private JPanel controlPanel;
+    private JPanel alphaBetaPanel;
+    private JPanel gammaPanel;
+    private double alphaValue = 1.0;
+    private double betaValue = 0.0;
+    private double gammaValue = 1.0;
+    private JCheckBox methodCheckBox;
+    private JSlider sliderAlpha;
+    private JSlider sliderBeta;
+    private JSlider sliderGamma;
+
+    public ChangingContrastBrightnessImage(String[] args) {
+        String imagePath = args.length > 0 ? args[0] : "../data/lena.jpg";
+        matImgSrc = Imgcodecs.imread(imagePath);
+        if (matImgSrc.empty()) {
+            System.out.println("Empty image: " + imagePath);
+            System.exit(0);
+        }
+
+        // Create and set up the window.
+        frame = new JFrame(WINDOW_NAME);
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(matImgSrc);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        controlPanel = new JPanel();
+        controlPanel.setLayout(new BoxLayout(controlPanel, BoxLayout.PAGE_AXIS));
+
+        methodCheckBox = new JCheckBox("Do gamma correction");
+        methodCheckBox.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                JCheckBox cb = (JCheckBox) e.getSource();
+                if (cb.isSelected()) {
+                    controlPanel.remove(alphaBetaPanel);
+                    controlPanel.add(gammaPanel);
+                    performGammaCorrection();
+                    frame.revalidate();
+                    frame.repaint();
+                    frame.pack();
+                } else {
+                    controlPanel.remove(gammaPanel);
+                    controlPanel.add(alphaBetaPanel);
+                    performLinearTransformation();
+                    frame.revalidate();
+                    frame.repaint();
+                    frame.pack();
+                }
+            }
+        });
+        controlPanel.add(methodCheckBox);
+
+        alphaBetaPanel = new JPanel();
+        alphaBetaPanel.setLayout(new BoxLayout(alphaBetaPanel, BoxLayout.PAGE_AXIS));
+        alphaBetaPanel.add(new JLabel(ALPHA_NAME));
+        sliderAlpha = new JSlider(0, MAX_VALUE_ALPHA, 100);
+        sliderAlpha.setMajorTickSpacing(50);
+        sliderAlpha.setMinorTickSpacing(10);
+        sliderAlpha.setPaintTicks(true);
+        sliderAlpha.setPaintLabels(true);
+        sliderAlpha.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                alphaValue = sliderAlpha.getValue() / 100.0;
+                performLinearTransformation();
+            }
+        });
+        alphaBetaPanel.add(sliderAlpha);
+
+        alphaBetaPanel.add(new JLabel(BETA_NAME));
+        sliderBeta = new JSlider(0, MAX_VALUE_BETA_GAMMA, 100);
+        sliderBeta.setMajorTickSpacing(20);
+        sliderBeta.setMinorTickSpacing(5);
+        sliderBeta.setPaintTicks(true);
+        sliderBeta.setPaintLabels(true);
+        sliderBeta.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                betaValue = sliderBeta.getValue() - 100;
+                performLinearTransformation();
+            }
+        });
+        alphaBetaPanel.add(sliderBeta);
+        controlPanel.add(alphaBetaPanel);
+
+        gammaPanel = new JPanel();
+        gammaPanel.setLayout(new BoxLayout(gammaPanel, BoxLayout.PAGE_AXIS));
+        gammaPanel.add(new JLabel(GAMMA_NAME));
+        sliderGamma = new JSlider(0, MAX_VALUE_BETA_GAMMA, 100);
+        sliderGamma.setMajorTickSpacing(20);
+        sliderGamma.setMinorTickSpacing(5);
+        sliderGamma.setPaintTicks(true);
+        sliderGamma.setPaintLabels(true);
+        sliderGamma.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                gammaValue = sliderGamma.getValue() / 100.0;
+                performGammaCorrection();
+            }
+        });
+        gammaPanel.add(sliderGamma);
+
+        pane.add(controlPanel, BorderLayout.PAGE_START);
+        JPanel framePanel = new JPanel();
+        imgSrcLabel = new JLabel(new ImageIcon(img));
+        framePanel.add(imgSrcLabel);
+        imgModifLabel = new JLabel(new ImageIcon(img));
+        framePanel.add(imgModifLabel);
+        pane.add(framePanel, BorderLayout.CENTER);
+    }
+
+    private void performLinearTransformation() {
+        Mat img = new Mat();
+        matImgSrc.convertTo(img, -1, alphaValue, betaValue);
+        imgModifLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(img)));
+        frame.repaint();
+    }
+
+    private byte saturate(double val) {
+        int iVal = (int) Math.round(val);
+        iVal = iVal > 255 ? 255 : (iVal < 0 ? 0 : iVal);
+        return (byte) iVal;
+    }
+
+    private void performGammaCorrection() {
+        //! [changing-contrast-brightness-gamma-correction]
+        Mat lookUpTable = new Mat(1, 256, CvType.CV_8U);
+        byte[] lookUpTableData = new byte[(int) (lookUpTable.total()*lookUpTable.channels())];
+        for (int i = 0; i < lookUpTable.cols(); i++) {
+            lookUpTableData[i] = saturate(Math.pow(i / 255.0, gammaValue) * 255.0);
+        }
+        lookUpTable.put(0, 0, lookUpTableData);
+        Mat img = new Mat();
+        Core.LUT(matImgSrc, lookUpTable, img);
+        //! [changing-contrast-brightness-gamma-correction]
+
+        imgModifLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(img)));
+        frame.repaint();
+    }
+}
+
+public class ChangingContrastBrightnessImageDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new ChangingContrastBrightnessImage(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/erosion_dilatation/MorphologyDemo1.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/erosion_dilatation/MorphologyDemo1.java
new file mode 100644
index 00000000..e71400f7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/erosion_dilatation/MorphologyDemo1.java
@@ -0,0 +1,159 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JComboBox;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Size;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+public class MorphologyDemo1 {
+    private static final String[] ELEMENT_TYPE = { "Rectangle", "Cross", "Ellipse" };
+    private static final String[] MORPH_OP = { "Erosion", "Dilatation" };
+    private static final int MAX_KERNEL_SIZE = 21;
+    private Mat matImgSrc;
+    private Mat matImgDst = new Mat();
+    private int elementType = Imgproc.CV_SHAPE_RECT;
+    private int kernelSize = 0;
+    private boolean doErosion = true;
+    private JFrame frame;
+    private JLabel imgLabel;
+
+    //! [constructor]
+    public MorphologyDemo1(String[] args) {
+        String imagePath = args.length > 0 ? args[0] : "../data/LinuxLogo.jpg";
+        matImgSrc = Imgcodecs.imread(imagePath);
+        if (matImgSrc.empty()) {
+            System.out.println("Empty image: " + imagePath);
+            System.exit(0);
+        }
+
+        // Create and set up the window.
+        frame = new JFrame("Erosion and dilatation demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(matImgSrc);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+    }
+    //! [constructor]
+
+    //! [components]
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        JComboBox<String> elementTypeBox = new JComboBox<>(ELEMENT_TYPE);
+        elementTypeBox.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                @SuppressWarnings("unchecked")
+                JComboBox<String> cb = (JComboBox<String>)e.getSource();
+                if (cb.getSelectedIndex() == 0) {
+                    elementType = Imgproc.CV_SHAPE_RECT;
+                } else if (cb.getSelectedIndex() == 1) {
+                    elementType = Imgproc.CV_SHAPE_CROSS;
+                } else if (cb.getSelectedIndex() == 2) {
+                    elementType = Imgproc.CV_SHAPE_ELLIPSE;
+                }
+                update();
+            }
+        });
+        sliderPanel.add(elementTypeBox);
+
+        sliderPanel.add(new JLabel("Kernel size: 2n + 1"));
+        JSlider slider = new JSlider(0, MAX_KERNEL_SIZE, 0);
+        slider.setMajorTickSpacing(5);
+        slider.setMinorTickSpacing(5);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                kernelSize = source.getValue();
+                update();
+            }
+        });
+        sliderPanel.add(slider);
+
+        JComboBox<String> morphOpBox = new JComboBox<>(MORPH_OP);
+        morphOpBox.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                @SuppressWarnings("unchecked")
+                JComboBox<String> cb = (JComboBox<String>)e.getSource();
+                doErosion = cb.getSelectedIndex() == 0;
+                update();
+            }
+        });
+        sliderPanel.add(morphOpBox);
+
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+        imgLabel = new JLabel(new ImageIcon(img));
+        pane.add(imgLabel, BorderLayout.CENTER);
+    }
+    //! [components]
+
+    //! [update]
+    private void update() {
+        //! [kernel]
+        Mat element = Imgproc.getStructuringElement(elementType, new Size(2 * kernelSize + 1, 2 * kernelSize + 1),
+                new Point(kernelSize, kernelSize));
+        //! [kernel]
+
+        if (doErosion) {
+            //! [erosion]
+            Imgproc.erode(matImgSrc, matImgDst, element);
+            //! [erosion]
+        } else {
+            //! [dilation]
+            Imgproc.dilate(matImgSrc, matImgDst, element);
+            //! [dilation]
+        }
+        Image img = HighGui.toBufferedImage(matImgDst);
+        imgLabel.setIcon(new ImageIcon(img));
+        frame.repaint();
+    }
+    //! [update]
+
+    //! [main]
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new MorphologyDemo1(args);
+            }
+        });
+    }
+    //! [main]
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/morph_lines_detection/Morphology_3.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/morph_lines_detection/Morphology_3.java
new file mode 100644
index 00000000..23f72996
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/morph_lines_detection/Morphology_3.java
@@ -0,0 +1,152 @@
+/**
+ * @file Morphology_3.java
+ * @brief Use morphology transformations for extracting horizontal and vertical lines sample code
+ */
+
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class Morphology_3Run {
+
+    public void run(String[] args) {
+
+        //! [load_image]
+        // Check number of arguments
+        if (args.length == 0){
+            System.out.println("Not enough parameters!");
+            System.out.println("Program Arguments: [image_path]");
+            System.exit(-1);
+        }
+
+        // Load the image
+        Mat src = Imgcodecs.imread(args[0]);
+
+        // Check if image is loaded fine
+        if( src.empty() ) {
+            System.out.println("Error opening image: " + args[0]);
+            System.exit(-1);
+        }
+
+        // Show source image
+        HighGui.imshow("src", src);
+        //! [load_image]
+
+        //! [gray]
+        // Transform source image to gray if it is not already
+        Mat gray = new Mat();
+
+        if (src.channels() == 3)
+        {
+            Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
+        }
+        else
+        {
+            gray = src;
+        }
+
+        // Show gray image
+        showWaitDestroy("gray" , gray);
+        //! [gray]
+
+        //! [bin]
+        // Apply adaptiveThreshold at the bitwise_not of gray
+        Mat bw = new Mat();
+        Core.bitwise_not(gray, gray);
+        Imgproc.adaptiveThreshold(gray, bw, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 15, -2);
+
+        // Show binary image
+        showWaitDestroy("binary" , bw);
+        //! [bin]
+
+        //! [init]
+        // Create the images that will use to extract the horizontal and vertical lines
+        Mat horizontal = bw.clone();
+        Mat vertical = bw.clone();
+        //! [init]
+
+        //! [horiz]
+        // Specify size on horizontal axis
+        int horizontal_size = horizontal.cols() / 30;
+
+        // Create structure element for extracting horizontal lines through morphology operations
+        Mat horizontalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(horizontal_size,1));
+
+        // Apply morphology operations
+        Imgproc.erode(horizontal, horizontal, horizontalStructure);
+        Imgproc.dilate(horizontal, horizontal, horizontalStructure);
+
+        // Show extracted horizontal lines
+        showWaitDestroy("horizontal" , horizontal);
+        //! [horiz]
+
+        //! [vert]
+        // Specify size on vertical axis
+        int vertical_size = vertical.rows() / 30;
+
+        // Create structure element for extracting vertical lines through morphology operations
+        Mat verticalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size( 1,vertical_size));
+
+        // Apply morphology operations
+        Imgproc.erode(vertical, vertical, verticalStructure);
+        Imgproc.dilate(vertical, vertical, verticalStructure);
+
+        // Show extracted vertical lines
+        showWaitDestroy("vertical", vertical);
+        //! [vert]
+
+        //! [smooth]
+        // Inverse vertical image
+        Core.bitwise_not(vertical, vertical);
+        showWaitDestroy("vertical_bit" , vertical);
+
+        // Extract edges and smooth image according to the logic
+        // 1. extract edges
+        // 2. dilate(edges)
+        // 3. src.copyTo(smooth)
+        // 4. blur smooth img
+        // 5. smooth.copyTo(src, edges)
+
+        // Step 1
+        Mat edges = new Mat();
+        Imgproc.adaptiveThreshold(vertical, edges, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 3, -2);
+        showWaitDestroy("edges", edges);
+
+        // Step 2
+        Mat kernel = Mat.ones(2, 2, CvType.CV_8UC1);
+        Imgproc.dilate(edges, edges, kernel);
+        showWaitDestroy("dilate", edges);
+
+        // Step 3
+        Mat smooth = new Mat();
+        vertical.copyTo(smooth);
+
+        // Step 4
+        Imgproc.blur(smooth, smooth, new Size(2, 2));
+
+        // Step 5
+        smooth.copyTo(vertical, edges);
+
+        // Show final result
+        showWaitDestroy("smooth - final", vertical);
+        //! [smooth]
+
+        System.exit(0);
+    }
+
+    private void showWaitDestroy(String winname, Mat img) {
+        HighGui.imshow(winname, img);
+        HighGui.moveWindow(winname, 500, 0);
+        HighGui.waitKey(0);
+        HighGui.destroyWindow(winname);
+    }
+}
+
+public class Morphology_3 {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new Morphology_3Run().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/opening_closing_hats/MorphologyDemo2.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/opening_closing_hats/MorphologyDemo2.java
new file mode 100644
index 00000000..133c440e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/opening_closing_hats/MorphologyDemo2.java
@@ -0,0 +1,143 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JComboBox;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Size;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+public class MorphologyDemo2 {
+    private static final String[] MORPH_OP = { "Opening", "Closing", "Gradient", "Top Hat", "Black Hat" };
+    private static final int[] MORPH_OP_TYPE = { Imgproc.MORPH_OPEN, Imgproc.MORPH_CLOSE,
+            Imgproc.MORPH_GRADIENT, Imgproc.MORPH_TOPHAT, Imgproc.MORPH_BLACKHAT };
+    private static final String[] ELEMENT_TYPE = { "Rectangle", "Cross", "Ellipse" };
+    private static final int MAX_KERNEL_SIZE = 21;
+    private Mat matImgSrc;
+    private Mat matImgDst = new Mat();
+    private int morphOpType = Imgproc.MORPH_OPEN;
+    private int elementType = Imgproc.CV_SHAPE_RECT;
+    private int kernelSize = 0;
+    private JFrame frame;
+    private JLabel imgLabel;
+
+    public MorphologyDemo2(String[] args) {
+        String imagePath = args.length > 0 ? args[0] : "../data/LinuxLogo.jpg";
+        matImgSrc = Imgcodecs.imread(imagePath);
+        if (matImgSrc.empty()) {
+            System.out.println("Empty image: " + imagePath);
+            System.exit(0);
+        }
+
+        // Create and set up the window.
+        frame = new JFrame("Morphology Transformations demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(matImgSrc);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        JComboBox<String> morphOpBox = new JComboBox<>(MORPH_OP);
+        morphOpBox.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                @SuppressWarnings("unchecked")
+                JComboBox<String> cb = (JComboBox<String>)e.getSource();
+                morphOpType = MORPH_OP_TYPE[cb.getSelectedIndex()];
+                update();
+            }
+        });
+        sliderPanel.add(morphOpBox);
+
+        JComboBox<String> elementTypeBox = new JComboBox<>(ELEMENT_TYPE);
+        elementTypeBox.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                @SuppressWarnings("unchecked")
+                JComboBox<String> cb = (JComboBox<String>)e.getSource();
+                if (cb.getSelectedIndex() == 0) {
+                    elementType = Imgproc.CV_SHAPE_RECT;
+                } else if (cb.getSelectedIndex() == 1) {
+                    elementType = Imgproc.CV_SHAPE_CROSS;
+                } else if (cb.getSelectedIndex() == 2) {
+                    elementType = Imgproc.CV_SHAPE_ELLIPSE;
+                }
+                update();
+            }
+        });
+        sliderPanel.add(elementTypeBox);
+
+        sliderPanel.add(new JLabel("Kernel size: 2n + 1"));
+        JSlider slider = new JSlider(0, MAX_KERNEL_SIZE, 0);
+        slider.setMajorTickSpacing(5);
+        slider.setMinorTickSpacing(5);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                kernelSize = source.getValue();
+                update();
+            }
+        });
+        sliderPanel.add(slider);
+
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+        imgLabel = new JLabel(new ImageIcon(img));
+        pane.add(imgLabel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        Mat element = Imgproc.getStructuringElement(elementType, new Size(2 * kernelSize + 1, 2 * kernelSize + 1),
+                new Point(kernelSize, kernelSize));
+
+        Imgproc.morphologyEx(matImgSrc, matImgDst, morphOpType, element);
+        Image img = HighGui.toBufferedImage(matImgDst);
+        imgLabel.setIcon(new ImageIcon(img));
+        frame.repaint();
+    }
+
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new MorphologyDemo2(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/threshold/Threshold.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/threshold/Threshold.java
new file mode 100644
index 00000000..87952472
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/threshold/Threshold.java
@@ -0,0 +1,144 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+public class Threshold {
+    private static int MAX_VALUE = 255;
+    private static int MAX_TYPE = 4;
+    private static int MAX_BINARY_VALUE = 255;
+    private static final String WINDOW_NAME = "Threshold Demo";
+    private static final String TRACKBAR_TYPE = "<html><body>Type: <br> 0: Binary <br> "
+            + "1: Binary Inverted <br> 2: Truncate <br> "
+            + "3: To Zero <br> 4: To Zero Inverted</body></html>";
+    private static final String TRACKBAR_VALUE = "Value";
+    private int thresholdValue = 0;
+    private int thresholdType = 3;
+    private Mat src;
+    private Mat srcGray = new Mat();
+    private Mat dst = new Mat();
+    private JFrame frame;
+    private JLabel imgLabel;
+
+    public Threshold(String[] args) {
+        //! [load]
+        String imagePath = "../data/stuff.jpg";
+        if (args.length > 0) {
+            imagePath = args[0];
+        }
+        // Load an image
+        src = Imgcodecs.imread(imagePath);
+        if (src.empty()) {
+            System.out.println("Empty image: " + imagePath);
+            System.exit(0);
+        }
+        // Convert the image to Gray
+        Imgproc.cvtColor(src, srcGray, Imgproc.COLOR_BGR2GRAY);
+        //! [load]
+
+        //! [window]
+        // Create and set up the window.
+        frame = new JFrame(WINDOW_NAME);
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(srcGray);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        //! [window]
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        //! [trackbar]
+        sliderPanel.add(new JLabel(TRACKBAR_TYPE));
+        // Create Trackbar to choose type of Threshold
+        JSlider sliderThreshType = new JSlider(0, MAX_TYPE, thresholdType);
+        sliderThreshType.setMajorTickSpacing(1);
+        sliderThreshType.setMinorTickSpacing(1);
+        sliderThreshType.setPaintTicks(true);
+        sliderThreshType.setPaintLabels(true);
+        sliderPanel.add(sliderThreshType);
+
+        sliderPanel.add(new JLabel(TRACKBAR_VALUE));
+        // Create Trackbar to choose Threshold value
+        JSlider sliderThreshValue = new JSlider(0, MAX_VALUE, 0);
+        sliderThreshValue.setMajorTickSpacing(50);
+        sliderThreshValue.setMinorTickSpacing(10);
+        sliderThreshValue.setPaintTicks(true);
+        sliderThreshValue.setPaintLabels(true);
+        sliderPanel.add(sliderThreshValue);
+        //! [trackbar]
+
+        //! [on_trackbar]
+        sliderThreshType.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                thresholdType = source.getValue();
+                update();
+            }
+        });
+
+        sliderThreshValue.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                thresholdValue = source.getValue();
+                update();
+            }
+        });
+        //! [on_trackbar]
+
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+        imgLabel = new JLabel(new ImageIcon(img));
+        pane.add(imgLabel, BorderLayout.CENTER);
+    }
+
+    //! [Threshold_Demo]
+    private void update() {
+        Imgproc.threshold(srcGray, dst, thresholdValue, MAX_BINARY_VALUE, thresholdType);
+        Image img = HighGui.toBufferedImage(dst);
+        imgLabel.setIcon(new ImageIcon(img));
+        frame.repaint();
+    }
+    //! [Threshold_Demo]
+
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new Threshold(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/threshold_inRange/ThresholdInRange.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/threshold_inRange/ThresholdInRange.java
new file mode 100644
index 00000000..70c37602
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/threshold_inRange/ThresholdInRange.java
@@ -0,0 +1,259 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.util.List;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.SwingWorker;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.videoio.VideoCapture;
+
+public class ThresholdInRange {
+    private static int MAX_VALUE = 255;
+    private static int MAX_VALUE_H = 360/2;
+    private static final String WINDOW_NAME = "Thresholding Operations using inRange demo";
+    private static final String LOW_H_NAME = "Low H";
+    private static final String LOW_S_NAME = "Low S";
+    private static final String LOW_V_NAME = "Low V";
+    private static final String HIGH_H_NAME = "High H";
+    private static final String HIGH_S_NAME = "High S";
+    private static final String HIGH_V_NAME = "High V";
+    private JSlider sliderLowH;
+    private JSlider sliderHighH;
+    private JSlider sliderLowS;
+    private JSlider sliderHighS;
+    private JSlider sliderLowV;
+    private JSlider sliderHighV;
+    private VideoCapture cap;
+    private Mat matFrame = new Mat();
+    private JFrame frame;
+    private JLabel imgCaptureLabel;
+    private JLabel imgDetectionLabel;
+    private CaptureTask captureTask;
+
+    public ThresholdInRange(String[] args) {
+        int cameraDevice = 0;
+        if (args.length > 0) {
+            cameraDevice = Integer.parseInt(args[0]);
+        }
+        //! [cap]
+        cap = new VideoCapture(cameraDevice);
+        //! [cap]
+        if (!cap.isOpened()) {
+            System.err.println("Cannot open camera: " + cameraDevice);
+            System.exit(0);
+        }
+        if (!cap.read(matFrame)) {
+            System.err.println("Cannot read camera stream.");
+            System.exit(0);
+        }
+
+        //! [window]
+        // Create and set up the window.
+        frame = new JFrame(WINDOW_NAME);
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent windowEvent) {
+                captureTask.cancel(true);
+            }
+        });
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(matFrame);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        //! [window]
+
+        captureTask = new CaptureTask();
+        captureTask.execute();
+    }
+
+    //! [while]
+    private class CaptureTask extends SwingWorker<Void, Mat> {
+        @Override
+        protected Void doInBackground() {
+            Mat matFrame = new Mat();
+
+            while (!isCancelled()) {
+                if (!cap.read(matFrame)) {
+                    break;
+                }
+                publish(matFrame.clone());
+            }
+            return null;
+        }
+
+        @Override
+        protected void process(List<Mat> frames) {
+            Mat frame = frames.get(frames.size() - 1);
+            Mat frameHSV = new Mat();
+            Imgproc.cvtColor(frame, frameHSV, Imgproc.COLOR_BGR2HSV);
+            Mat thresh = new Mat();
+            Core.inRange(frameHSV, new Scalar(sliderLowH.getValue(), sliderLowS.getValue(), sliderLowV.getValue()),
+                    new Scalar(sliderHighH.getValue(), sliderHighS.getValue(), sliderHighV.getValue()), thresh);
+            update(frame, thresh);
+        }
+    }
+    //! [while]
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        //! [trackbar]
+        sliderPanel.add(new JLabel(LOW_H_NAME));
+        sliderLowH = new JSlider(0, MAX_VALUE_H, 0);
+        sliderLowH.setMajorTickSpacing(50);
+        sliderLowH.setMinorTickSpacing(10);
+        sliderLowH.setPaintTicks(true);
+        sliderLowH.setPaintLabels(true);
+        sliderPanel.add(sliderLowH);
+
+        sliderPanel.add(new JLabel(HIGH_H_NAME));
+        sliderHighH = new JSlider(0, MAX_VALUE_H, MAX_VALUE_H);
+        sliderHighH.setMajorTickSpacing(50);
+        sliderHighH.setMinorTickSpacing(10);
+        sliderHighH.setPaintTicks(true);
+        sliderHighH.setPaintLabels(true);
+        sliderPanel.add(sliderHighH);
+
+        sliderPanel.add(new JLabel(LOW_S_NAME));
+        sliderLowS = new JSlider(0, MAX_VALUE, 0);
+        sliderLowS.setMajorTickSpacing(50);
+        sliderLowS.setMinorTickSpacing(10);
+        sliderLowS.setPaintTicks(true);
+        sliderLowS.setPaintLabels(true);
+        sliderPanel.add(sliderLowS);
+
+        sliderPanel.add(new JLabel(HIGH_S_NAME));
+        sliderHighS = new JSlider(0, MAX_VALUE, MAX_VALUE);
+        sliderHighS.setMajorTickSpacing(50);
+        sliderHighS.setMinorTickSpacing(10);
+        sliderHighS.setPaintTicks(true);
+        sliderHighS.setPaintLabels(true);
+        sliderPanel.add(sliderHighS);
+
+        sliderPanel.add(new JLabel(LOW_V_NAME));
+        sliderLowV = new JSlider(0, MAX_VALUE, 0);
+        sliderLowV.setMajorTickSpacing(50);
+        sliderLowV.setMinorTickSpacing(10);
+        sliderLowV.setPaintTicks(true);
+        sliderLowV.setPaintLabels(true);
+        sliderPanel.add(sliderLowV);
+
+        sliderPanel.add(new JLabel(HIGH_V_NAME));
+        sliderHighV = new JSlider(0, MAX_VALUE, MAX_VALUE);
+        sliderHighV.setMajorTickSpacing(50);
+        sliderHighV.setMinorTickSpacing(10);
+        sliderHighV.setPaintTicks(true);
+        sliderHighV.setPaintLabels(true);
+        sliderPanel.add(sliderHighV);
+        //! [trackbar]
+
+        //! [low]
+        sliderLowH.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                int valH = Math.min(sliderHighH.getValue()-1, source.getValue());
+                sliderLowH.setValue(valH);
+            }
+        });
+        //! [low]
+        //! [high]
+        sliderHighH.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                int valH = Math.max(source.getValue(), sliderLowH.getValue()+1);
+                sliderHighH.setValue(valH);
+            }
+        });
+        //! [high]
+        sliderLowS.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                int valS = Math.min(sliderHighS.getValue()-1, source.getValue());
+                sliderLowS.setValue(valS);
+            }
+        });
+        sliderHighS.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                int valS = Math.max(source.getValue(), sliderLowS.getValue()+1);
+                sliderHighS.setValue(valS);
+            }
+        });
+        sliderLowV.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                int valV = Math.min(sliderHighV.getValue()-1, source.getValue());
+                sliderLowV.setValue(valV);
+            }
+        });
+        sliderHighV.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                int valV = Math.max(source.getValue(), sliderLowV.getValue()+1);
+                sliderHighV.setValue(valV);
+            }
+        });
+
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+        JPanel framePanel = new JPanel();
+        imgCaptureLabel = new JLabel(new ImageIcon(img));
+        framePanel.add(imgCaptureLabel);
+        imgDetectionLabel = new JLabel(new ImageIcon(img));
+        framePanel.add(imgDetectionLabel);
+        pane.add(framePanel, BorderLayout.CENTER);
+    }
+
+    private void update(Mat imgCapture, Mat imgThresh) {
+        //! [show]
+        imgCaptureLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(imgCapture)));
+        imgDetectionLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(imgThresh)));
+        frame.repaint();
+        //! [show]
+    }
+
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new ThresholdInRange(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/tutorial_template_matching/MatchTemplateDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/tutorial_template_matching/MatchTemplateDemo.java
new file mode 100644
index 00000000..b520cf33
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgProc/tutorial_template_matching/MatchTemplateDemo.java
@@ -0,0 +1,182 @@
+import java.awt.GridLayout;
+import java.awt.Image;
+import java.util.Hashtable;
+
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class MatchTemplateDemoRun implements ChangeListener {
+
+    //! [declare]
+    /// Global Variables
+    Boolean use_mask = false;
+    Mat img = new Mat(), templ = new Mat();
+    Mat mask = new Mat();
+
+    int match_method;
+
+    JLabel imgDisplay = new JLabel(), resultDisplay = new JLabel();
+    //! [declare]
+
+    public void run(String[] args) {
+        if (args.length < 2) {
+            System.out.println("Not enough parameters");
+            System.out.println("Program arguments:\n<image_name> <template_name> [<mask_name>]");
+            System.exit(-1);
+        }
+
+        //! [load_image]
+        /// Load image and template
+        img = Imgcodecs.imread(args[0], Imgcodecs.IMREAD_COLOR);
+        templ = Imgcodecs.imread(args[1], Imgcodecs.IMREAD_COLOR);
+        //! [load_image]
+
+        if (args.length > 2) {
+            use_mask = true;
+            mask = Imgcodecs.imread(args[2], Imgcodecs.IMREAD_COLOR);
+        }
+
+        if (img.empty() || templ.empty() || (use_mask && mask.empty())) {
+            System.out.println("Can't read one of the images");
+            System.exit(-1);
+        }
+
+        matchingMethod();
+        createJFrame();
+    }
+
+    private void matchingMethod() {
+        Mat result = new Mat();
+
+        //! [copy_source]
+        /// Source image to display
+        Mat img_display = new Mat();
+        img.copyTo(img_display);
+        //! [copy_source]
+
+        //! [create_result_matrix]
+        /// Create the result matrix
+        int result_cols = img.cols() - templ.cols() + 1;
+        int result_rows = img.rows() - templ.rows() + 1;
+
+        result.create(result_rows, result_cols, CvType.CV_32FC1);
+        //! [create_result_matrix]
+
+        //! [match_template]
+        /// Do the Matching and Normalize
+        Boolean method_accepts_mask = (Imgproc.TM_SQDIFF == match_method || match_method == Imgproc.TM_CCORR_NORMED);
+        if (use_mask && method_accepts_mask) {
+            Imgproc.matchTemplate(img, templ, result, match_method, mask);
+        } else {
+            Imgproc.matchTemplate(img, templ, result, match_method);
+        }
+        //! [match_template]
+
+        //! [normalize]
+        Core.normalize(result, result, 0, 1, Core.NORM_MINMAX, -1, new Mat());
+        //! [normalize]
+
+        //! [best_match]
+        /// Localizing the best match with minMaxLoc
+        Point matchLoc;
+
+        Core.MinMaxLocResult mmr = Core.minMaxLoc(result);
+        //! [best_match]
+
+        //! [match_loc]
+        /// For SQDIFF and SQDIFF_NORMED, the best matches are lower values.
+        /// For all the other methods, the higher the better
+        if (match_method == Imgproc.TM_SQDIFF || match_method == Imgproc.TM_SQDIFF_NORMED) {
+            matchLoc = mmr.minLoc;
+        } else {
+            matchLoc = mmr.maxLoc;
+        }
+        //! [match_loc]
+
+        //! [imshow]
+        /// Show me what you got
+        Imgproc.rectangle(img_display, matchLoc, new Point(matchLoc.x + templ.cols(), matchLoc.y + templ.rows()),
+                new Scalar(0, 0, 0), 2, 8, 0);
+        Imgproc.rectangle(result, matchLoc, new Point(matchLoc.x + templ.cols(), matchLoc.y + templ.rows()),
+                new Scalar(0, 0, 0), 2, 8, 0);
+
+        Image tmpImg = HighGui.toBufferedImage(img_display);
+        ImageIcon icon = new ImageIcon(tmpImg);
+        imgDisplay.setIcon(icon);
+
+        result.convertTo(result, CvType.CV_8UC1, 255.0);
+        tmpImg = HighGui.toBufferedImage(result);
+        icon = new ImageIcon(tmpImg);
+        resultDisplay.setIcon(icon);
+        //! [imshow]
+    }
+
+    @Override
+    public void stateChanged(ChangeEvent e) {
+        JSlider source = (JSlider) e.getSource();
+        if (!source.getValueIsAdjusting()) {
+            match_method = source.getValue();
+            matchingMethod();
+        }
+    }
+
+    private void createJFrame() {
+        String title = "Source image; Control; Result image";
+        JFrame frame = new JFrame(title);
+        frame.setLayout(new GridLayout(2, 2));
+        frame.add(imgDisplay);
+
+        //! [create_trackbar]
+        int min = 0, max = 5;
+        JSlider slider = new JSlider(JSlider.VERTICAL, min, max, match_method);
+        //! [create_trackbar]
+
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+
+        // Set the spacing for the minor tick mark
+        slider.setMinorTickSpacing(1);
+
+        // Customizing the labels
+        Hashtable<Integer, JLabel> labelTable = new Hashtable<>();
+        labelTable.put(new Integer(0), new JLabel("0 - SQDIFF"));
+        labelTable.put(new Integer(1), new JLabel("1 - SQDIFF NORMED"));
+        labelTable.put(new Integer(2), new JLabel("2 - TM CCORR"));
+        labelTable.put(new Integer(3), new JLabel("3 - TM CCORR NORMED"));
+        labelTable.put(new Integer(4), new JLabel("4 - TM COEFF"));
+        labelTable.put(new Integer(5), new JLabel("5 - TM COEFF NORMED : (Method)"));
+        slider.setLabelTable(labelTable);
+
+        slider.addChangeListener(this);
+
+        frame.add(slider);
+
+        frame.add(resultDisplay);
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.pack();
+        frame.setVisible(true);
+    }
+}
+
+public class MatchTemplateDemo {
+    public static void main(String[] args) {
+        // load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // run code
+        new MatchTemplateDemoRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/Filter2D/Filter2D_Demo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/Filter2D/Filter2D_Demo.java
new file mode 100644
index 00000000..aa685d9a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/Filter2D/Filter2D_Demo.java
@@ -0,0 +1,81 @@
+/**
+ * @file Filter2D_demo.java
+ * @brief Sample code that shows how to implement your own linear filters by using filter2D function
+ */
+
+import org.opencv.core.*;
+import org.opencv.core.Point;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class Filter2D_DemoRun {
+
+    public void run(String[] args) {
+        // Declare variables
+        Mat src, dst = new Mat();
+
+        Mat kernel = new Mat();
+        Point anchor;
+        double delta;
+        int ddepth;
+        int kernel_size;
+        String window_name = "filter2D Demo";
+
+        //! [load]
+        String imageName = ((args.length > 0) ? args[0] : "../data/lena.jpg");
+
+        // Load an image
+        src = Imgcodecs.imread(imageName, Imgcodecs.IMREAD_COLOR);
+
+        // Check if image is loaded fine
+        if( src.empty() ) {
+            System.out.println("Error opening image!");
+            System.out.println("Program Arguments: [image_name -- default ../data/lena.jpg] \n");
+            System.exit(-1);
+        }
+        //! [load]
+
+        //! [init_arguments]
+        // Initialize arguments for the filter
+        anchor = new Point( -1, -1);
+        delta = 0.0;
+        ddepth = -1;
+        //! [init_arguments]
+
+        // Loop - Will filter the image with different kernel sizes each 0.5 seconds
+        int ind = 0;
+        while( true )
+        {
+            //! [update_kernel]
+            // Update kernel size for a normalized box filter
+            kernel_size = 3 + 2*( ind%5 );
+            Mat ones = Mat.ones( kernel_size, kernel_size, CvType.CV_32F );
+            Core.multiply(ones, new Scalar(1/(double)(kernel_size*kernel_size)), kernel);
+            //! [update_kernel]
+
+            //! [apply_filter]
+            // Apply filter
+            Imgproc.filter2D(src, dst, ddepth , kernel, anchor, delta, Core.BORDER_DEFAULT );
+            //! [apply_filter]
+            HighGui.imshow( window_name, dst );
+
+            int c = HighGui.waitKey(500);
+            // Press 'ESC' to exit the program
+            if( c == 27 )
+            { break; }
+
+            ind++;
+        }
+
+        System.exit(0);
+    }
+}
+
+public class Filter2D_Demo {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new Filter2D_DemoRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/HoughCircle/HoughCircles.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/HoughCircle/HoughCircles.java
new file mode 100644
index 00000000..40f97ff8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/HoughCircle/HoughCircles.java
@@ -0,0 +1,77 @@
+package sample;
+/**
+ * @file HoughCircles.java
+ * @brief This program demonstrates circle finding with the Hough transform
+ */
+
+import org.opencv.core.*;
+import org.opencv.core.Point;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class HoughCirclesRun {
+
+    public void run(String[] args) {
+
+        //! [load]
+        String default_file = "../../../../data/smarties.png";
+        String filename = ((args.length > 0) ? args[0] : default_file);
+
+        // Load an image
+        Mat src = Imgcodecs.imread(filename, Imgcodecs.IMREAD_COLOR);
+
+        // Check if image is loaded fine
+        if( src.empty() ) {
+            System.out.println("Error opening image!");
+            System.out.println("Program Arguments: [image_name -- default "
+                    + default_file +"] \n");
+            System.exit(-1);
+        }
+        //! [load]
+
+        //! [convert_to_gray]
+        Mat gray = new Mat();
+        Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
+        //! [convert_to_gray]
+
+        //![reduce_noise]
+        Imgproc.medianBlur(gray, gray, 5);
+        //![reduce_noise]
+
+        //! [houghcircles]
+        Mat circles = new Mat();
+        Imgproc.HoughCircles(gray, circles, Imgproc.HOUGH_GRADIENT, 1.0,
+                (double)gray.rows()/16, // change this value to detect circles with different distances to each other
+                100.0, 30.0, 1, 30); // change the last two parameters
+                // (min_radius & max_radius) to detect larger circles
+        //! [houghcircles]
+
+        //! [draw]
+        for (int x = 0; x < circles.cols(); x++) {
+            double[] c = circles.get(0, x);
+            Point center = new Point(Math.round(c[0]), Math.round(c[1]));
+            // circle center
+            Imgproc.circle(src, center, 1, new Scalar(0,100,100), 3, 8, 0 );
+            // circle outline
+            int radius = (int) Math.round(c[2]);
+            Imgproc.circle(src, center, radius, new Scalar(255,0,255), 3, 8, 0 );
+        }
+        //! [draw]
+
+        //! [display]
+        HighGui.imshow("detected circles", src);
+        HighGui.waitKey();
+        //! [display]
+
+        System.exit(0);
+    }
+}
+
+public class HoughCircles {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new HoughCirclesRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/HoughLine/HoughLines.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/HoughLine/HoughLines.java
new file mode 100644
index 00000000..c968d321
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/HoughLine/HoughLines.java
@@ -0,0 +1,96 @@
+/**
+ * @file HoughLines.java
+ * @brief This program demonstrates line finding with the Hough transform
+ */
+
+import org.opencv.core.*;
+import org.opencv.core.Point;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class HoughLinesRun {
+
+    public void run(String[] args) {
+        // Declare the output variables
+        Mat dst = new Mat(), cdst = new Mat(), cdstP;
+
+        //! [load]
+        String default_file = "../../../../data/sudoku.png";
+        String filename = ((args.length > 0) ? args[0] : default_file);
+
+        // Load an image
+        Mat src = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
+
+        // Check if image is loaded fine
+        if( src.empty() ) {
+            System.out.println("Error opening image!");
+            System.out.println("Program Arguments: [image_name -- default "
+                    + default_file +"] \n");
+            System.exit(-1);
+        }
+        //! [load]
+
+        //! [edge_detection]
+        // Edge detection
+        Imgproc.Canny(src, dst, 50, 200, 3, false);
+        //! [edge_detection]
+
+        // Copy edges to the images that will display the results in BGR
+        Imgproc.cvtColor(dst, cdst, Imgproc.COLOR_GRAY2BGR);
+        cdstP = cdst.clone();
+
+        //! [hough_lines]
+        // Standard Hough Line Transform
+        Mat lines = new Mat(); // will hold the results of the detection
+        Imgproc.HoughLines(dst, lines, 1, Math.PI/180, 150); // runs the actual detection
+        //! [hough_lines]
+        //! [draw_lines]
+        // Draw the lines
+        for (int x = 0; x < lines.rows(); x++) {
+            double rho = lines.get(x, 0)[0],
+                    theta = lines.get(x, 0)[1];
+
+            double a = Math.cos(theta), b = Math.sin(theta);
+            double x0 = a*rho, y0 = b*rho;
+            Point pt1 = new Point(Math.round(x0 + 1000*(-b)), Math.round(y0 + 1000*(a)));
+            Point pt2 = new Point(Math.round(x0 - 1000*(-b)), Math.round(y0 - 1000*(a)));
+            Imgproc.line(cdst, pt1, pt2, new Scalar(0, 0, 255), 3, Imgproc.LINE_AA, 0);
+        }
+        //! [draw_lines]
+
+        //! [hough_lines_p]
+        // Probabilistic Line Transform
+        Mat linesP = new Mat(); // will hold the results of the detection
+        Imgproc.HoughLinesP(dst, linesP, 1, Math.PI/180, 50, 50, 10); // runs the actual detection
+        //! [hough_lines_p]
+        //! [draw_lines_p]
+        // Draw the lines
+        for (int x = 0; x < linesP.rows(); x++) {
+            double[] l = linesP.get(x, 0);
+            Imgproc.line(cdstP, new Point(l[0], l[1]), new Point(l[2], l[3]), new Scalar(0, 0, 255), 3, Imgproc.LINE_AA, 0);
+        }
+        //! [draw_lines_p]
+
+        //! [imshow]
+        // Show results
+        HighGui.imshow("Source", src);
+        HighGui.imshow("Detected Lines (in red) - Standard Hough Line Transform", cdst);
+        HighGui.imshow("Detected Lines (in red) - Probabilistic Line Transform", cdstP);
+        //! [imshow]
+
+        //! [exit]
+        // Wait and Exit
+        HighGui.waitKey();
+        System.exit(0);
+        //! [exit]
+    }
+}
+
+public class HoughLines {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new HoughLinesRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/LaPlace/LaplaceDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/LaPlace/LaplaceDemo.java
new file mode 100644
index 00000000..d9dba705
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/LaPlace/LaplaceDemo.java
@@ -0,0 +1,73 @@
+/**
+ * @file LaplaceDemo.java
+ * @brief Sample code showing how to detect edges using the Laplace operator
+ */
+
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class LaplaceDemoRun {
+
+    public void run(String[] args) {
+        //! [variables]
+        // Declare the variables we are going to use
+        Mat src, src_gray = new Mat(), dst = new Mat();
+        int kernel_size = 3;
+        int scale = 1;
+        int delta = 0;
+        int ddepth = CvType.CV_16S;
+        String window_name = "Laplace Demo";
+        //! [variables]
+
+        //! [load]
+        String imageName = ((args.length > 0) ? args[0] : "../data/lena.jpg");
+
+        src = Imgcodecs.imread(imageName, Imgcodecs.IMREAD_COLOR); // Load an image
+
+        // Check if image is loaded fine
+        if( src.empty() ) {
+            System.out.println("Error opening image");
+            System.out.println("Program Arguments: [image_name -- default ../data/lena.jpg] \n");
+            System.exit(-1);
+        }
+        //! [load]
+
+        //! [reduce_noise]
+        // Reduce noise by blurring with a Gaussian filter ( kernel size = 3 )
+        Imgproc.GaussianBlur( src, src, new Size(3, 3), 0, 0, Core.BORDER_DEFAULT );
+        //! [reduce_noise]
+
+        //! [convert_to_gray]
+        // Convert the image to grayscale
+        Imgproc.cvtColor( src, src_gray, Imgproc.COLOR_RGB2GRAY );
+        //! [convert_to_gray]
+
+        /// Apply Laplace function
+        Mat abs_dst = new Mat();
+        //! [laplacian]
+        Imgproc.Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, Core.BORDER_DEFAULT );
+        //! [laplacian]
+
+        //! [convert]
+        // converting back to CV_8U
+        Core.convertScaleAbs( dst, abs_dst );
+        //! [convert]
+
+        //! [display]
+        HighGui.imshow( window_name, abs_dst );
+        HighGui.waitKey(0);
+        //! [display]
+
+        System.exit(0);
+    }
+}
+
+public class LaplaceDemo {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new LaplaceDemoRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/MakeBorder/CopyMakeBorder.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/MakeBorder/CopyMakeBorder.java
new file mode 100644
index 00000000..8fffced2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/MakeBorder/CopyMakeBorder.java
@@ -0,0 +1,94 @@
+/**
+ * @file CopyMakeBorder.java
+ * @brief Sample code that shows the functionality of copyMakeBorder
+ */
+
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+
+import java.util.Random;
+
+class CopyMakeBorderRun {
+
+    public void run(String[] args) {
+
+        //! [variables]
+        // Declare the variables
+        Mat src, dst = new Mat();
+        int top, bottom, left, right;
+        int borderType = Core.BORDER_CONSTANT;
+        String window_name = "copyMakeBorder Demo";
+        Random rng;
+        //! [variables]
+
+        //! [load]
+        String imageName = ((args.length > 0) ? args[0] : "../data/lena.jpg");
+
+        // Load an image
+        src = Imgcodecs.imread(imageName, Imgcodecs.IMREAD_COLOR);
+
+        // Check if image is loaded fine
+        if( src.empty() ) {
+            System.out.println("Error opening image!");
+            System.out.println("Program Arguments: [image_name -- default ../data/lena.jpg] \n");
+            System.exit(-1);
+        }
+        //! [load]
+
+        // Brief how-to for this program
+        System.out.println("\n" +
+                "\t copyMakeBorder Demo: \n" +
+                "\t -------------------- \n" +
+                " ** Press 'c' to set the border to a random constant value \n" +
+                " ** Press 'r' to set the border to be replicated \n" +
+                " ** Press 'ESC' to exit the program \n");
+
+        //![create_window]
+        HighGui.namedWindow( window_name, HighGui.WINDOW_AUTOSIZE );
+        //![create_window]
+
+        //! [init_arguments]
+        // Initialize arguments for the filter
+        top = (int) (0.05*src.rows()); bottom = top;
+        left = (int) (0.05*src.cols()); right = left;
+        //! [init_arguments]
+
+        while( true ) {
+            //! [update_value]
+            rng = new Random();
+            Scalar value = new Scalar( rng.nextInt(256),
+                    rng.nextInt(256), rng.nextInt(256) );
+            //! [update_value]
+
+            //! [copymakeborder]
+            Core.copyMakeBorder( src, dst, top, bottom, left, right, borderType, value);
+            //! [copymakeborder]
+            //! [display]
+            HighGui.imshow( window_name, dst );
+            //! [display]
+
+            //![check_keypress]
+            char c = (char) HighGui.waitKey(500);
+            c = Character.toLowerCase(c);
+
+            if( c == 27 )
+            { break; }
+            else if( c == 'c' )
+            { borderType = Core.BORDER_CONSTANT;}
+            else if( c == 'r' )
+            { borderType = Core.BORDER_REPLICATE;}
+            //![check_keypress]
+        }
+
+        System.exit(0);
+    }
+}
+
+public class CopyMakeBorder {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new CopyMakeBorderRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/SobelDemo/SobelDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/SobelDemo/SobelDemo.java
new file mode 100644
index 00000000..815c16bc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/SobelDemo/SobelDemo.java
@@ -0,0 +1,94 @@
+/**
+ * @file SobelDemo.java
+ * @brief Sample code using Sobel and/or Scharr OpenCV functions to make a simple Edge Detector
+ */
+
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class SobelDemoRun {
+
+    public void run(String[] args) {
+
+        //! [declare_variables]
+        // First we declare the variables we are going to use
+        Mat src, src_gray = new Mat();
+        Mat grad = new Mat();
+        String window_name = "Sobel Demo - Simple Edge Detector";
+        int scale = 1;
+        int delta = 0;
+        int ddepth = CvType.CV_16S;
+        //! [declare_variables]
+
+        //! [load]
+        // As usual we load our source image (src)
+        // Check number of arguments
+        if (args.length == 0){
+            System.out.println("Not enough parameters!");
+            System.out.println("Program Arguments: [image_path]");
+            System.exit(-1);
+        }
+
+        // Load the image
+        src = Imgcodecs.imread(args[0]);
+
+        // Check if image is loaded fine
+        if( src.empty() ) {
+            System.out.println("Error opening image: " + args[0]);
+            System.exit(-1);
+        }
+        //! [load]
+
+        //! [reduce_noise]
+        // Remove noise by blurring with a Gaussian filter ( kernel size = 3 )
+        Imgproc.GaussianBlur( src, src, new Size(3, 3), 0, 0, Core.BORDER_DEFAULT );
+        //! [reduce_noise]
+
+        //! [convert_to_gray]
+        // Convert the image to grayscale
+        Imgproc.cvtColor( src, src_gray, Imgproc.COLOR_RGB2GRAY );
+        //! [convert_to_gray]
+
+        //! [sobel]
+        /// Generate grad_x and grad_y
+        Mat grad_x = new Mat(), grad_y = new Mat();
+        Mat abs_grad_x = new Mat(), abs_grad_y = new Mat();
+
+        /// Gradient X
+        //Imgproc.Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, Core.BORDER_DEFAULT );
+        Imgproc.Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, Core.BORDER_DEFAULT );
+
+        /// Gradient Y
+        //Imgproc.Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, Core.BORDER_DEFAULT );
+        Imgproc.Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, Core.BORDER_DEFAULT );
+        //! [sobel]
+
+        //![convert]
+        // converting back to CV_8U
+        Core.convertScaleAbs( grad_x, abs_grad_x );
+        Core.convertScaleAbs( grad_y, abs_grad_y );
+        //![convert]
+
+        //! [add_weighted]
+        /// Total Gradient (approximate)
+        Core.addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad );
+        //! [add_weighted]
+
+        //! [display]
+        HighGui.imshow( window_name, grad );
+        HighGui.waitKey(0);
+        //! [display]
+
+        System.exit(0);
+    }
+}
+
+public class SobelDemo {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new SobelDemoRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/canny_detector/CannyDetectorDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/canny_detector/CannyDetectorDemo.java
new file mode 100644
index 00000000..553b5bdf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/canny_detector/CannyDetectorDemo.java
@@ -0,0 +1,110 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+public class CannyDetectorDemo {
+    private static final int MAX_LOW_THRESHOLD = 100;
+    private static final int RATIO = 3;
+    private static final int KERNEL_SIZE = 3;
+    private static final Size BLUR_SIZE = new Size(3,3);
+    private int lowThresh = 0;
+    private Mat src;
+    private Mat srcBlur = new Mat();
+    private Mat detectedEdges = new Mat();
+    private Mat dst = new Mat();
+    private JFrame frame;
+    private JLabel imgLabel;
+
+    public CannyDetectorDemo(String[] args) {
+        String imagePath = args.length > 0 ? args[0] : "../data/fruits.jpg";
+        src = Imgcodecs.imread(imagePath);
+        if (src.empty()) {
+            System.out.println("Empty image: " + imagePath);
+            System.exit(0);
+        }
+
+        // Create and set up the window.
+        frame = new JFrame("Edge Map (Canny detector demo)");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        sliderPanel.add(new JLabel("Min Threshold:"));
+        JSlider slider = new JSlider(0, MAX_LOW_THRESHOLD, 0);
+        slider.setMajorTickSpacing(10);
+        slider.setMinorTickSpacing(5);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                lowThresh = source.getValue();
+                update();
+            }
+        });
+        sliderPanel.add(slider);
+
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+        imgLabel = new JLabel(new ImageIcon(img));
+        pane.add(imgLabel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        Imgproc.blur(src, srcBlur, BLUR_SIZE);
+        Imgproc.Canny(srcBlur, detectedEdges, lowThresh, lowThresh * RATIO, KERNEL_SIZE, false);
+        dst = new Mat(src.size(), CvType.CV_8UC3, Scalar.all(0));
+        src.copyTo(dst, detectedEdges);
+        Image img = HighGui.toBufferedImage(dst);
+        imgLabel.setIcon(new ImageIcon(img));
+        frame.repaint();
+    }
+
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new CannyDetectorDemo(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java
new file mode 100644
index 00000000..8f44a378
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/distance_transformation/ImageSegmentationDemo.java
@@ -0,0 +1,219 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+/**
+ *
+ * @brief Sample code showing how to segment overlapping objects using Laplacian filtering, in addition to Watershed
+ * and Distance Transformation
+ *
+ */
+class ImageSegmentation {
+    public void run(String[] args) {
+        //! [load_image]
+        // Load the image
+        String filename = args.length > 0 ? args[0] : "../data/cards.png";
+        Mat srcOriginal = Imgcodecs.imread(filename);
+        if (srcOriginal.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        // Show source image
+        HighGui.imshow("Source Image", srcOriginal);
+        //! [load_image]
+
+        //! [black_bg]
+        // Change the background from white to black, since that will help later to
+        // extract
+        // better results during the use of Distance Transform
+        Mat src = srcOriginal.clone();
+        byte[] srcData = new byte[(int) (src.total() * src.channels())];
+        src.get(0, 0, srcData);
+        for (int i = 0; i < src.rows(); i++) {
+            for (int j = 0; j < src.cols(); j++) {
+                if (srcData[(i * src.cols() + j) * 3] == (byte) 255 && srcData[(i * src.cols() + j) * 3 + 1] == (byte) 255
+                        && srcData[(i * src.cols() + j) * 3 + 2] == (byte) 255) {
+                    srcData[(i * src.cols() + j) * 3] = 0;
+                    srcData[(i * src.cols() + j) * 3 + 1] = 0;
+                    srcData[(i * src.cols() + j) * 3 + 2] = 0;
+                }
+            }
+        }
+        src.put(0, 0, srcData);
+
+        // Show output image
+        HighGui.imshow("Black Background Image", src);
+        //! [black_bg]
+
+        //! [sharp]
+        // Create a kernel that we will use to sharpen our image
+        Mat kernel = new Mat(3, 3, CvType.CV_32F);
+        // an approximation of second derivative, a quite strong kernel
+        float[] kernelData = new float[(int) (kernel.total() * kernel.channels())];
+        kernelData[0] = 1; kernelData[1] = 1; kernelData[2] = 1;
+        kernelData[3] = 1; kernelData[4] = -8; kernelData[5] = 1;
+        kernelData[6] = 1; kernelData[7] = 1; kernelData[8] = 1;
+        kernel.put(0, 0, kernelData);
+
+        // do the laplacian filtering as it is
+        // well, we need to convert everything in something more deeper then CV_8U
+        // because the kernel has some negative values,
+        // and we can expect in general to have a Laplacian image with negative values
+        // BUT a 8bits unsigned int (the one we are working with) can contain values
+        // from 0 to 255
+        // so the possible negative number will be truncated
+        Mat imgLaplacian = new Mat();
+        Imgproc.filter2D(src, imgLaplacian, CvType.CV_32F, kernel);
+        Mat sharp = new Mat();
+        src.convertTo(sharp, CvType.CV_32F);
+        Mat imgResult = new Mat();
+        Core.subtract(sharp, imgLaplacian, imgResult);
+
+        // convert back to 8bits gray scale
+        imgResult.convertTo(imgResult, CvType.CV_8UC3);
+        imgLaplacian.convertTo(imgLaplacian, CvType.CV_8UC3);
+
+        // imshow( "Laplace Filtered Image", imgLaplacian );
+        HighGui.imshow("New Sharped Image", imgResult);
+        //! [sharp]
+
+        //! [bin]
+        // Create binary image from source image
+        Mat bw = new Mat();
+        Imgproc.cvtColor(imgResult, bw, Imgproc.COLOR_BGR2GRAY);
+        Imgproc.threshold(bw, bw, 40, 255, Imgproc.THRESH_BINARY | Imgproc.THRESH_OTSU);
+        HighGui.imshow("Binary Image", bw);
+        //! [bin]
+
+        //! [dist]
+        // Perform the distance transform algorithm
+        Mat dist = new Mat();
+        Imgproc.distanceTransform(bw, dist, Imgproc.DIST_L2, 3);
+
+        // Normalize the distance image for range = {0.0, 1.0}
+        // so we can visualize and threshold it
+        Core.normalize(dist, dist, 0.0, 1.0, Core.NORM_MINMAX);
+        Mat distDisplayScaled = new Mat();
+        Core.multiply(dist, new Scalar(255), distDisplayScaled);
+        Mat distDisplay = new Mat();
+        distDisplayScaled.convertTo(distDisplay, CvType.CV_8U);
+        HighGui.imshow("Distance Transform Image", distDisplay);
+        //! [dist]
+
+        //! [peaks]
+        // Threshold to obtain the peaks
+        // This will be the markers for the foreground objects
+        Imgproc.threshold(dist, dist, 0.4, 1.0, Imgproc.THRESH_BINARY);
+
+        // Dilate a bit the dist image
+        Mat kernel1 = Mat.ones(3, 3, CvType.CV_8U);
+        Imgproc.dilate(dist, dist, kernel1);
+        Mat distDisplay2 = new Mat();
+        dist.convertTo(distDisplay2, CvType.CV_8U);
+        Core.multiply(distDisplay2, new Scalar(255), distDisplay2);
+        HighGui.imshow("Peaks", distDisplay2);
+        //! [peaks]
+
+        //! [seeds]
+        // Create the CV_8U version of the distance image
+        // It is needed for findContours()
+        Mat dist_8u = new Mat();
+        dist.convertTo(dist_8u, CvType.CV_8U);
+
+        // Find total markers
+        List<MatOfPoint> contours = new ArrayList<>();
+        Mat hierarchy = new Mat();
+        Imgproc.findContours(dist_8u, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
+
+        // Create the marker image for the watershed algorithm
+        Mat markers = Mat.zeros(dist.size(), CvType.CV_32S);
+
+        // Draw the foreground markers
+        for (int i = 0; i < contours.size(); i++) {
+            Imgproc.drawContours(markers, contours, i, new Scalar(i + 1), -1);
+        }
+
+        // Draw the background marker
+        Mat markersScaled = new Mat();
+        markers.convertTo(markersScaled, CvType.CV_32F);
+        Core.normalize(markersScaled, markersScaled, 0.0, 255.0, Core.NORM_MINMAX);
+        Imgproc.circle(markersScaled, new Point(5, 5), 3, new Scalar(255, 255, 255), -1);
+        Mat markersDisplay = new Mat();
+        markersScaled.convertTo(markersDisplay, CvType.CV_8U);
+        HighGui.imshow("Markers", markersDisplay);
+        Imgproc.circle(markers, new Point(5, 5), 3, new Scalar(255, 255, 255), -1);
+        //! [seeds]
+
+        //! [watershed]
+        // Perform the watershed algorithm
+        Imgproc.watershed(imgResult, markers);
+
+        Mat mark = Mat.zeros(markers.size(), CvType.CV_8U);
+        markers.convertTo(mark, CvType.CV_8UC1);
+        Core.bitwise_not(mark, mark);
+        // imshow("Markers_v2", mark); // uncomment this if you want to see how the mark
+        // image looks like at that point
+
+        // Generate random colors
+        Random rng = new Random(12345);
+        List<Scalar> colors = new ArrayList<>(contours.size());
+        for (int i = 0; i < contours.size(); i++) {
+            int b = rng.nextInt(256);
+            int g = rng.nextInt(256);
+            int r = rng.nextInt(256);
+
+            colors.add(new Scalar(b, g, r));
+        }
+
+        // Create the result image
+        Mat dst = Mat.zeros(markers.size(), CvType.CV_8UC3);
+        byte[] dstData = new byte[(int) (dst.total() * dst.channels())];
+        dst.get(0, 0, dstData);
+
+        // Fill labeled objects with random colors
+        int[] markersData = new int[(int) (markers.total() * markers.channels())];
+        markers.get(0, 0, markersData);
+        for (int i = 0; i < markers.rows(); i++) {
+            for (int j = 0; j < markers.cols(); j++) {
+                int index = markersData[i * markers.cols() + j];
+                if (index > 0 && index <= contours.size()) {
+                    dstData[(i * dst.cols() + j) * 3 + 0] = (byte) colors.get(index - 1).val[0];
+                    dstData[(i * dst.cols() + j) * 3 + 1] = (byte) colors.get(index - 1).val[1];
+                    dstData[(i * dst.cols() + j) * 3 + 2] = (byte) colors.get(index - 1).val[2];
+                } else {
+                    dstData[(i * dst.cols() + j) * 3 + 0] = 0;
+                    dstData[(i * dst.cols() + j) * 3 + 1] = 0;
+                    dstData[(i * dst.cols() + j) * 3 + 2] = 0;
+                }
+            }
+        }
+        dst.put(0, 0, dstData);
+
+        // Visualize the final image
+        HighGui.imshow("Final Result", dst);
+        //! [watershed]
+
+        HighGui.waitKey();
+        System.exit(0);
+    }
+}
+
+public class ImageSegmentationDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new ImageSegmentation().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/remap/RemapDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/remap/RemapDemo.java
new file mode 100644
index 00000000..e36b2329
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/remap/RemapDemo.java
@@ -0,0 +1,98 @@
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class Remap {
+    private Mat mapX = new Mat();
+    private Mat mapY = new Mat();
+    private Mat dst = new Mat();
+    private int ind = 0;
+
+    //! [Update]
+    private void updateMap() {
+        float buffX[] = new float[(int) (mapX.total() * mapX.channels())];
+        mapX.get(0, 0, buffX);
+
+        float buffY[] = new float[(int) (mapY.total() * mapY.channels())];
+        mapY.get(0, 0, buffY);
+
+        for (int i = 0; i < mapX.rows(); i++) {
+            for (int j = 0; j < mapX.cols(); j++) {
+                switch (ind) {
+                case 0:
+                    if( j > mapX.cols()*0.25 && j < mapX.cols()*0.75 && i > mapX.rows()*0.25 && i < mapX.rows()*0.75 ) {
+                        buffX[i*mapX.cols() + j] = 2*( j - mapX.cols()*0.25f ) + 0.5f;
+                        buffY[i*mapY.cols() + j] = 2*( i - mapX.rows()*0.25f ) + 0.5f;
+                    } else {
+                        buffX[i*mapX.cols() + j] = 0;
+                        buffY[i*mapY.cols() + j] = 0;
+                    }
+                    break;
+                case 1:
+                    buffX[i*mapX.cols() + j] = j;
+                    buffY[i*mapY.cols() + j] = mapY.rows() - i;
+                    break;
+                case 2:
+                    buffX[i*mapX.cols() + j] = mapY.cols() - j;
+                    buffY[i*mapY.cols() + j] = i;
+                    break;
+                case 3:
+                    buffX[i*mapX.cols() + j] = mapY.cols() - j;
+                    buffY[i*mapY.cols() + j] = mapY.rows() - i;
+                    break;
+                default:
+                    break;
+                }
+            }
+        }
+        mapX.put(0, 0, buffX);
+        mapY.put(0, 0, buffY);
+        ind = (ind+1) % 4;
+    }
+    //! [Update]
+
+    public void run(String[] args) {
+        String filename = args.length > 0 ? args[0] : "../data/chicky_512.png";
+        //! [Load]
+        Mat src = Imgcodecs.imread(filename, Imgcodecs.IMREAD_COLOR);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+        //! [Load]
+
+        //! [Create]
+        mapX = new Mat(src.size(), CvType.CV_32F);
+        mapY = new Mat(src.size(), CvType.CV_32F);
+        //! [Create]
+
+        //! [Window]
+        final String winname = "Remap demo";
+        HighGui.namedWindow(winname, HighGui.WINDOW_AUTOSIZE);
+        //! [Window]
+
+        //! [Loop]
+        for (;;) {
+            updateMap();
+            Imgproc.remap(src, dst, mapX, mapY, Imgproc.INTER_LINEAR);
+            HighGui.imshow(winname, dst);
+            if (HighGui.waitKey(1000) == 27) {
+                break;
+            }
+        }
+        //! [Loop]
+        System.exit(0);
+    }
+}
+
+public class RemapDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new Remap().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/warp_affine/GeometricTransformsDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/warp_affine/GeometricTransformsDemo.java
new file mode 100644
index 00000000..a3919300
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ImgTrans/warp_affine/GeometricTransformsDemo.java
@@ -0,0 +1,80 @@
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Point;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class GeometricTransforms {
+    public void run(String[] args) {
+        //! [Load the image]
+        String filename = args.length > 0 ? args[0] : "../data/lena.jpg";
+        Mat src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+        //! [Load the image]
+
+        //! [Set your 3 points to calculate the  Affine Transform]
+        Point[] srcTri = new Point[3];
+        srcTri[0] = new Point( 0, 0 );
+        srcTri[1] = new Point( src.cols() - 1, 0 );
+        srcTri[2] = new Point( 0, src.rows() - 1 );
+
+        Point[] dstTri = new Point[3];
+        dstTri[0] = new Point( 0, src.rows()*0.33 );
+        dstTri[1] = new Point( src.cols()*0.85, src.rows()*0.25 );
+        dstTri[2] = new Point( src.cols()*0.15, src.rows()*0.7 );
+        //! [Set your 3 points to calculate the  Affine Transform]
+
+        //! [Get the Affine Transform]
+        Mat warpMat = Imgproc.getAffineTransform( new MatOfPoint2f(srcTri), new MatOfPoint2f(dstTri) );
+        //! [Get the Affine Transform]
+
+        //! [Apply the Affine Transform just found to the src image]
+        Mat warpDst = Mat.zeros( src.rows(), src.cols(), src.type() );
+
+        Imgproc.warpAffine( src, warpDst, warpMat, warpDst.size() );
+        //! [Apply the Affine Transform just found to the src image]
+
+        /** Rotating the image after Warp */
+
+        //! [Compute a rotation matrix with respect to the center of the image]
+        Point center = new Point(warpDst.cols() / 2, warpDst.rows() / 2);
+        double angle = -50.0;
+        double scale = 0.6;
+        //! [Compute a rotation matrix with respect to the center of the image]
+
+        //! [Get the rotation matrix with the specifications above]
+        Mat rotMat = Imgproc.getRotationMatrix2D( center, angle, scale );
+        //! [Get the rotation matrix with the specifications above]
+
+        //! [Rotate the warped image]
+        Mat warpRotateDst = new Mat();
+        Imgproc.warpAffine( warpDst, warpRotateDst, rotMat, warpDst.size() );
+        //! [Rotate the warped image]
+
+        //! [Show what you got]
+        HighGui.imshow( "Source image", src );
+        HighGui.imshow( "Warp", warpDst );
+        HighGui.imshow( "Warp + Rotate", warpRotateDst );
+        //! [Show what you got]
+
+        //! [Wait until user exits the program]
+        HighGui.waitKey(0);
+        //! [Wait until user exits the program]
+
+        System.exit(0);
+    }
+}
+
+public class GeometricTransformsDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new GeometricTransforms().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/bounding_rects_circles/GeneralContoursDemo1.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/bounding_rects_circles/GeneralContoursDemo1.java
new file mode 100644
index 00000000..85bbf45e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/bounding_rects_circles/GeneralContoursDemo1.java
@@ -0,0 +1,179 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class GeneralContours1 {
+    private Mat srcGray = new Mat();
+    private JFrame frame;
+    private JLabel imgSrcLabel;
+    private JLabel imgContoursLabel;
+    private static final int MAX_THRESHOLD = 255;
+    private int threshold = 100;
+    private Random rng = new Random(12345);
+
+    public GeneralContours1(String[] args) {
+        //! [setup]
+        /// Load source image
+        String filename = args.length > 0 ? args[0] : "../data/stuff.jpg";
+        Mat src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        /// Convert image to gray and blur it
+        Imgproc.cvtColor(src, srcGray, Imgproc.COLOR_BGR2GRAY);
+        Imgproc.blur(srcGray, srcGray, new Size(3, 3));
+        //! [setup]
+
+        //! [createWindow]
+        // Create and set up the window.
+        frame = new JFrame("Creating Bounding boxes and circles for contours demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        //! [createWindow]
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        update();
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        //! [trackbar]
+        sliderPanel.add(new JLabel("Canny threshold: "));
+        JSlider slider = new JSlider(0, MAX_THRESHOLD, threshold);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                threshold = source.getValue();
+                update();
+            }
+        });
+        //! [trackbar]
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        JPanel imgPanel = new JPanel();
+        imgSrcLabel = new JLabel(new ImageIcon(img));
+        imgPanel.add(imgSrcLabel);
+
+        Mat blackImg = Mat.zeros(srcGray.size(), CvType.CV_8U);
+        imgContoursLabel = new JLabel(new ImageIcon(HighGui.toBufferedImage(blackImg)));
+        imgPanel.add(imgContoursLabel);
+
+        pane.add(imgPanel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        //! [Canny]
+        /// Detect edges using Canny
+        Mat cannyOutput = new Mat();
+        Imgproc.Canny(srcGray, cannyOutput, threshold, threshold * 2);
+        //! [Canny]
+
+        //! [findContours]
+        /// Find contours
+        List<MatOfPoint> contours = new ArrayList<>();
+        Mat hierarchy = new Mat();
+        Imgproc.findContours(cannyOutput, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
+        //! [findContours]
+
+        //! [allthework]
+        /// Approximate contours to polygons + get bounding rects and circles
+        MatOfPoint2f[] contoursPoly  = new MatOfPoint2f[contours.size()];
+        Rect[] boundRect = new Rect[contours.size()];
+        Point[] centers = new Point[contours.size()];
+        float[][] radius = new float[contours.size()][1];
+
+        for (int i = 0; i < contours.size(); i++) {
+            contoursPoly[i] = new MatOfPoint2f();
+            Imgproc.approxPolyDP(new MatOfPoint2f(contours.get(i).toArray()), contoursPoly[i], 3, true);
+            boundRect[i] = Imgproc.boundingRect(new MatOfPoint(contoursPoly[i].toArray()));
+            centers[i] = new Point();
+            Imgproc.minEnclosingCircle(contoursPoly[i], centers[i], radius[i]);
+        }
+        //! [allthework]
+
+        //! [zeroMat]
+        Mat drawing = Mat.zeros(cannyOutput.size(), CvType.CV_8UC3);
+        //! [zeroMat]
+        //! [forContour]
+        /// Draw polygonal contour + bonding rects + circles
+        List<MatOfPoint> contoursPolyList = new ArrayList<>(contoursPoly.length);
+        for (MatOfPoint2f poly : contoursPoly) {
+            contoursPolyList.add(new MatOfPoint(poly.toArray()));
+        }
+
+        for (int i = 0; i < contours.size(); i++) {
+            Scalar color = new Scalar(rng.nextInt(256), rng.nextInt(256), rng.nextInt(256));
+            Imgproc.drawContours(drawing, contoursPolyList, i, color);
+            Imgproc.rectangle(drawing, boundRect[i].tl(), boundRect[i].br(), color, 2);
+            Imgproc.circle(drawing, centers[i], (int) radius[i][0], color, 2);
+        }
+        //! [forContour]
+
+        //! [showDrawings]
+        /// Show in a window
+        imgContoursLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(drawing)));
+        frame.repaint();
+        //! [showDrawings]
+    }
+}
+
+public class GeneralContoursDemo1 {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new GeneralContours1(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/bounding_rotated_ellipses/GeneralContoursDemo2.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/bounding_rotated_ellipses/GeneralContoursDemo2.java
new file mode 100644
index 00000000..c7b13dd1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/bounding_rotated_ellipses/GeneralContoursDemo2.java
@@ -0,0 +1,176 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Point;
+import org.opencv.core.RotatedRect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class GeneralContours2 {
+    private Mat srcGray = new Mat();
+    private JFrame frame;
+    private JLabel imgSrcLabel;
+    private JLabel imgContoursLabel;
+    private static final int MAX_THRESHOLD = 255;
+    private int threshold = 100;
+    private Random rng = new Random(12345);
+
+    public GeneralContours2(String[] args) {
+        //! [setup]
+        /// Load source image
+        String filename = args.length > 0 ? args[0] : "../data/stuff.jpg";
+        Mat src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        /// Convert image to gray and blur it
+        Imgproc.cvtColor(src, srcGray, Imgproc.COLOR_BGR2GRAY);
+        Imgproc.blur(srcGray, srcGray, new Size(3, 3));
+        //! [setup]
+
+        //! [createWindow]
+        // Create and set up the window.
+        frame = new JFrame("Creating Bounding rotated boxes and ellipses for contours demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        //! [createWindow]
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        update();
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        //! [trackbar]
+        sliderPanel.add(new JLabel("Canny threshold: "));
+        JSlider slider = new JSlider(0, MAX_THRESHOLD, threshold);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                threshold = source.getValue();
+                update();
+            }
+        });
+        //! [trackbar]
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        JPanel imgPanel = new JPanel();
+        imgSrcLabel = new JLabel(new ImageIcon(img));
+        imgPanel.add(imgSrcLabel);
+
+        Mat blackImg = Mat.zeros(srcGray.size(), CvType.CV_8U);
+        imgContoursLabel = new JLabel(new ImageIcon(HighGui.toBufferedImage(blackImg)));
+        imgPanel.add(imgContoursLabel);
+
+        pane.add(imgPanel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        //! [Canny]
+        /// Detect edges using Canny
+        Mat cannyOutput = new Mat();
+        Imgproc.Canny(srcGray, cannyOutput, threshold, threshold * 2);
+        //! [Canny]
+
+        //! [findContours]
+        /// Find contours
+        List<MatOfPoint> contours = new ArrayList<>();
+        Mat hierarchy = new Mat();
+        Imgproc.findContours(cannyOutput, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
+        //! [findContours]
+
+        /// Find the rotated rectangles and ellipses for each contour
+        RotatedRect[] minRect = new RotatedRect[contours.size()];
+        RotatedRect[] minEllipse = new RotatedRect[contours.size()];
+        for (int i = 0; i < contours.size(); i++) {
+            minRect[i] = Imgproc.minAreaRect(new MatOfPoint2f(contours.get(i).toArray()));
+            minEllipse[i] = new RotatedRect();
+            if (contours.get(i).rows() > 5) {
+                minEllipse[i] = Imgproc.fitEllipse(new MatOfPoint2f(contours.get(i).toArray()));
+            }
+        }
+
+        //! [zeroMat]
+        /// Draw contours + rotated rects + ellipses
+        Mat drawing = Mat.zeros(cannyOutput.size(), CvType.CV_8UC3);
+        //! [zeroMat]
+        //! [forContour]
+        for (int i = 0; i < contours.size(); i++) {
+            Scalar color = new Scalar(rng.nextInt(256), rng.nextInt(256), rng.nextInt(256));
+            // contour
+            Imgproc.drawContours(drawing, contours, i, color);
+            // ellipse
+            Imgproc.ellipse(drawing, minEllipse[i], color, 2);
+            // rotated rectangle
+            Point[] rectPoints = new Point[4];
+            minRect[i].points(rectPoints);
+            for (int j = 0; j < 4; j++) {
+                Imgproc.line(drawing, rectPoints[j], rectPoints[(j+1) % 4], color);
+            }
+        }
+        //! [forContour]
+
+        //! [showDrawings]
+        /// Show in a window
+        imgContoursLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(drawing)));
+        frame.repaint();
+        //! [showDrawings]
+    }
+}
+
+public class GeneralContoursDemo2 {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new GeneralContours2(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/find_contours/FindContoursDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/find_contours/FindContoursDemo.java
new file mode 100644
index 00000000..af6a1c8b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/find_contours/FindContoursDemo.java
@@ -0,0 +1,137 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class FindContours {
+    private Mat srcGray = new Mat();
+    private JFrame frame;
+    private JLabel imgSrcLabel;
+    private JLabel imgContoursLabel;
+    private static final int MAX_THRESHOLD = 255;
+    private int threshold = 100;
+    private Random rng = new Random(12345);
+
+    public FindContours(String[] args) {
+        /// Load source image
+        String filename = args.length > 0 ? args[0] : "../data/HappyFish.jpg";
+        Mat src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        /// Convert image to gray and blur it
+        Imgproc.cvtColor(src, srcGray, Imgproc.COLOR_BGR2GRAY);
+        Imgproc.blur(srcGray, srcGray, new Size(3, 3));
+
+        // Create and set up the window.
+        frame = new JFrame("Finding contours in your image demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        update();
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        sliderPanel.add(new JLabel("Canny threshold: "));
+        JSlider slider = new JSlider(0, MAX_THRESHOLD, threshold);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                threshold = source.getValue();
+                update();
+            }
+        });
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        JPanel imgPanel = new JPanel();
+        imgSrcLabel = new JLabel(new ImageIcon(img));
+        imgPanel.add(imgSrcLabel);
+
+        Mat blackImg = Mat.zeros(srcGray.size(), CvType.CV_8U);
+        imgContoursLabel = new JLabel(new ImageIcon(HighGui.toBufferedImage(blackImg)));
+        imgPanel.add(imgContoursLabel);
+
+        pane.add(imgPanel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        /// Detect edges using Canny
+        Mat cannyOutput = new Mat();
+        Imgproc.Canny(srcGray, cannyOutput, threshold, threshold * 2);
+
+        /// Find contours
+        List<MatOfPoint> contours = new ArrayList<>();
+        Mat hierarchy = new Mat();
+        Imgproc.findContours(cannyOutput, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
+
+        /// Draw contours
+        Mat drawing = Mat.zeros(cannyOutput.size(), CvType.CV_8UC3);
+        for (int i = 0; i < contours.size(); i++) {
+            Scalar color = new Scalar(rng.nextInt(256), rng.nextInt(256), rng.nextInt(256));
+            Imgproc.drawContours(drawing, contours, i, color, 2, Imgproc.LINE_8, hierarchy, 0, new Point());
+        }
+
+        imgContoursLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(drawing)));
+        frame.repaint();
+    }
+}
+
+public class FindContoursDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new FindContours(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/hull/HullDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/hull/HullDemo.java
new file mode 100644
index 00000000..0e2104fb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/hull/HullDemo.java
@@ -0,0 +1,154 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfInt;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class Hull {
+    private Mat srcGray = new Mat();
+    private JFrame frame;
+    private JLabel imgSrcLabel;
+    private JLabel imgContoursLabel;
+    private static final int MAX_THRESHOLD = 255;
+    private int threshold = 100;
+    private Random rng = new Random(12345);
+
+    public Hull(String[] args) {
+        /// Load source image
+        String filename = args.length > 0 ? args[0] : "../data/stuff.jpg";
+        Mat src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        /// Convert image to gray and blur it
+        Imgproc.cvtColor(src, srcGray, Imgproc.COLOR_BGR2GRAY);
+        Imgproc.blur(srcGray, srcGray, new Size(3, 3));
+
+        // Create and set up the window.
+        frame = new JFrame("Convex Hull demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        update();
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        sliderPanel.add(new JLabel("Canny threshold: "));
+        JSlider slider = new JSlider(0, MAX_THRESHOLD, threshold);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                threshold = source.getValue();
+                update();
+            }
+        });
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        JPanel imgPanel = new JPanel();
+        imgSrcLabel = new JLabel(new ImageIcon(img));
+        imgPanel.add(imgSrcLabel);
+
+        Mat blackImg = Mat.zeros(srcGray.size(), CvType.CV_8U);
+        imgContoursLabel = new JLabel(new ImageIcon(HighGui.toBufferedImage(blackImg)));
+        imgPanel.add(imgContoursLabel);
+
+        pane.add(imgPanel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        /// Detect edges using Canny
+        Mat cannyOutput = new Mat();
+        Imgproc.Canny(srcGray, cannyOutput, threshold, threshold * 2);
+
+        /// Find contours
+        List<MatOfPoint> contours = new ArrayList<>();
+        Mat hierarchy = new Mat();
+        Imgproc.findContours(cannyOutput, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
+
+        /// Find the convex hull object for each contour
+        List<MatOfPoint> hullList = new ArrayList<>();
+        for (MatOfPoint contour : contours) {
+            MatOfInt hull = new MatOfInt();
+            Imgproc.convexHull(contour, hull);
+
+            Point[] contourArray = contour.toArray();
+            Point[] hullPoints = new Point[hull.rows()];
+            List<Integer> hullContourIdxList = hull.toList();
+            for (int i = 0; i < hullContourIdxList.size(); i++) {
+                hullPoints[i] = contourArray[hullContourIdxList.get(i)];
+            }
+            hullList.add(new MatOfPoint(hullPoints));
+        }
+
+        /// Draw contours + hull results
+        Mat drawing = Mat.zeros(cannyOutput.size(), CvType.CV_8UC3);
+        for (int i = 0; i < contours.size(); i++) {
+            Scalar color = new Scalar(rng.nextInt(256), rng.nextInt(256), rng.nextInt(256));
+            Imgproc.drawContours(drawing, contours, i, color);
+            Imgproc.drawContours(drawing, hullList, i, color );
+        }
+
+        imgContoursLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(drawing)));
+        frame.repaint();
+    }
+}
+
+public class HullDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new Hull(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/moments/MomentsDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/moments/MomentsDemo.java
new file mode 100644
index 00000000..ffc24207
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/moments/MomentsDemo.java
@@ -0,0 +1,178 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.imgproc.Moments;
+
+class MomentsClass {
+    private Mat srcGray = new Mat();
+    private JFrame frame;
+    private JLabel imgSrcLabel;
+    private JLabel imgContoursLabel;
+    private static final int MAX_THRESHOLD = 255;
+    private int threshold = 100;
+    private Random rng = new Random(12345);
+
+    public MomentsClass(String[] args) {
+        //! [setup]
+        /// Load source image
+        String filename = args.length > 0 ? args[0] : "../data/stuff.jpg";
+        Mat src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        /// Convert image to gray and blur it
+        Imgproc.cvtColor(src, srcGray, Imgproc.COLOR_BGR2GRAY);
+        Imgproc.blur(srcGray, srcGray, new Size(3, 3));
+        //! [setup]
+
+        //! [createWindow]
+        // Create and set up the window.
+        frame = new JFrame("Image Moments demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        //! [createWindow]
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        update();
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        //! [trackbar]
+        sliderPanel.add(new JLabel("Canny threshold: "));
+        JSlider slider = new JSlider(0, MAX_THRESHOLD, threshold);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                threshold = source.getValue();
+                update();
+            }
+        });
+        //! [trackbar]
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        JPanel imgPanel = new JPanel();
+        imgSrcLabel = new JLabel(new ImageIcon(img));
+        imgPanel.add(imgSrcLabel);
+
+        Mat blackImg = Mat.zeros(srcGray.size(), CvType.CV_8U);
+        imgContoursLabel = new JLabel(new ImageIcon(HighGui.toBufferedImage(blackImg)));
+        imgPanel.add(imgContoursLabel);
+
+        pane.add(imgPanel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        //! [Canny]
+        /// Detect edges using Canny
+        Mat cannyOutput = new Mat();
+        Imgproc.Canny(srcGray, cannyOutput, threshold, threshold * 2);
+        //! [Canny]
+
+        //! [findContours]
+        /// Find contours
+        List<MatOfPoint> contours = new ArrayList<>();
+        Mat hierarchy = new Mat();
+        Imgproc.findContours(cannyOutput, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
+        //! [findContours]
+
+        /// Get the moments
+        List<Moments> mu = new ArrayList<>(contours.size());
+        for (int i = 0; i < contours.size(); i++) {
+            mu.add(Imgproc.moments(contours.get(i)));
+        }
+
+        /// Get the mass centers
+        List<Point> mc = new ArrayList<>(contours.size());
+        for (int i = 0; i < contours.size(); i++) {
+            //add 1e-5 to avoid division by zero
+            mc.add(new Point(mu.get(i).m10 / (mu.get(i).m00 + 1e-5), mu.get(i).m01 / (mu.get(i).m00 + 1e-5)));
+        }
+
+        //! [zeroMat]
+        /// Draw contours
+        Mat drawing = Mat.zeros(cannyOutput.size(), CvType.CV_8UC3);
+        //! [zeroMat]
+        //! [forContour]
+        for (int i = 0; i < contours.size(); i++) {
+            Scalar color = new Scalar(rng.nextInt(256), rng.nextInt(256), rng.nextInt(256));
+            Imgproc.drawContours(drawing, contours, i, color, 2);
+            Imgproc.circle(drawing, mc.get(i), 4, color, -1);
+        }
+        //! [forContour]
+
+        //! [showDrawings]
+        /// Show in a window
+        imgContoursLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(drawing)));
+        frame.repaint();
+        //! [showDrawings]
+
+        /// Calculate the area with the moments 00 and compare with the result of the OpenCV function
+        System.out.println("\t Info: Area and Contour Length \n");
+        for (int i = 0; i < contours.size(); i++) {
+            System.out.format(" * Contour[%d] - Area (M_00) = %.2f - Area OpenCV: %.2f - Length: %.2f\n", i,
+                    mu.get(i).m00, Imgproc.contourArea(contours.get(i)),
+                    Imgproc.arcLength(new MatOfPoint2f(contours.get(i).toArray()), true));
+        }
+    }
+}
+
+public class MomentsDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new MomentsClass(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/point_polygon_test/PointPolygonTestDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/point_polygon_test/PointPolygonTestDemo.java
new file mode 100644
index 00000000..94d5c621
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ShapeDescriptors/point_polygon_test/PointPolygonTestDemo.java
@@ -0,0 +1,94 @@
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.Core.MinMaxLocResult;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgproc.Imgproc;
+
+class PointPolygonTest {
+    public void run() {
+        /// Create an image
+        int r = 100;
+        Mat src = Mat.zeros(new Size(4 * r, 4 * r), CvType.CV_8U);
+
+        /// Create a sequence of points to make a contour
+        List<Point> vert = new ArrayList<>(6);
+        vert.add(new Point(3 * r / 2, 1.34 * r));
+        vert.add(new Point(1 * r, 2 * r));
+        vert.add(new Point(3 * r / 2, 2.866 * r));
+        vert.add(new Point(5 * r / 2, 2.866 * r));
+        vert.add(new Point(3 * r, 2 * r));
+        vert.add(new Point(5 * r / 2, 1.34 * r));
+
+        /// Draw it in src
+        for (int i = 0; i < 6; i++) {
+            Imgproc.line(src, vert.get(i), vert.get((i + 1) % 6), new Scalar(255), 3);
+        }
+
+        /// Get the contours
+        List<MatOfPoint> contours = new ArrayList<>();
+        Mat hierarchy = new Mat();
+        Imgproc.findContours(src, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
+
+        /// Calculate the distances to the contour
+        Mat rawDist = new Mat(src.size(), CvType.CV_32F);
+        float[] rawDistData = new float[(int) (rawDist.total() * rawDist.channels())];
+        for (int i = 0; i < src.rows(); i++) {
+            for (int j = 0; j < src.cols(); j++) {
+                rawDistData[i * src.cols() + j] = (float) Imgproc
+                        .pointPolygonTest(new MatOfPoint2f(contours.get(0).toArray()), new Point(j, i), true);
+            }
+        }
+        rawDist.put(0, 0, rawDistData);
+
+        MinMaxLocResult res = Core.minMaxLoc(rawDist);
+        double minVal = Math.abs(res.minVal);
+        double maxVal = Math.abs(res.maxVal);
+
+        /// Depicting the distances graphically
+        Mat drawing = Mat.zeros(src.size(), CvType.CV_8UC3);
+        byte[] drawingData = new byte[(int) (drawing.total() * drawing.channels())];
+        for (int i = 0; i < src.rows(); i++) {
+            for (int j = 0; j < src.cols(); j++) {
+                if (rawDistData[i * src.cols() + j] < 0) {
+                    drawingData[(i * src.cols() + j) * 3] =
+                            (byte) (255 - Math.abs(rawDistData[i * src.cols() + j]) * 255 / minVal);
+                } else if (rawDistData[i * src.cols() + j] > 0) {
+                    drawingData[(i * src.cols() + j) * 3 + 2] =
+                            (byte) (255 - rawDistData[i * src.cols() + j] * 255 / maxVal);
+                } else {
+                    drawingData[(i * src.cols() + j) * 3] = (byte) 255;
+                    drawingData[(i * src.cols() + j) * 3 + 1] = (byte) 255;
+                    drawingData[(i * src.cols() + j) * 3 + 2] = (byte) 255;
+                }
+            }
+        }
+        drawing.put(0, 0, drawingData);
+        Imgproc.circle(drawing, res.maxLoc, (int)res.maxVal, new Scalar(255, 255, 255), 2, 8, 0);
+
+        /// Show your results
+        HighGui.imshow("Source", src);
+        HighGui.imshow("Distance and inscribed circle", drawing);
+
+        HighGui.waitKey();
+        System.exit(0);
+    }
+}
+
+public class PointPolygonTestDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new PointPolygonTest().run();
+    }
+
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/corner_subpixels/CornerSubPixDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/corner_subpixels/CornerSubPixDemo.java
new file mode 100644
index 00000000..cb1888c0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/corner_subpixels/CornerSubPixDemo.java
@@ -0,0 +1,158 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.util.Random;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.core.TermCriteria;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class CornerSubPix {
+    private Mat src = new Mat();
+    private Mat srcGray = new Mat();
+    private JFrame frame;
+    private JLabel imgLabel;
+    private static final int MAX_CORNERS = 25;
+    private int maxCorners = 10;
+    private Random rng = new Random(12345);
+
+    public CornerSubPix(String[] args) {
+        /// Load source image and convert it to gray
+        String filename = args.length > 0 ? args[0] : "../data/pic3.png";
+        src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        Imgproc.cvtColor(src, srcGray, Imgproc.COLOR_BGR2GRAY);
+
+        // Create and set up the window.
+        frame = new JFrame("Shi-Tomasi corner detector demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        update();
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        sliderPanel.add(new JLabel("Max  corners:"));
+        JSlider slider = new JSlider(0, MAX_CORNERS, maxCorners);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                maxCorners = source.getValue();
+                update();
+            }
+        });
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        imgLabel = new JLabel(new ImageIcon(img));
+        pane.add(imgLabel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        /// Parameters for Shi-Tomasi algorithm
+        maxCorners = Math.max(maxCorners, 1);
+        MatOfPoint corners = new MatOfPoint();
+        double qualityLevel = 0.01;
+        double minDistance = 10;
+        int blockSize = 3, gradientSize = 3;
+        boolean useHarrisDetector = false;
+        double k = 0.04;
+
+        /// Copy the source image
+        Mat copy = src.clone();
+
+        /// Apply corner detection
+        Imgproc.goodFeaturesToTrack(srcGray, corners, maxCorners, qualityLevel, minDistance, new Mat(),
+                blockSize, gradientSize, useHarrisDetector, k);
+
+        /// Draw corners detected
+        System.out.println("** Number of corners detected: " + corners.rows());
+        int[] cornersData = new int[(int) (corners.total() * corners.channels())];
+        corners.get(0, 0, cornersData);
+        int radius = 4;
+        Mat matCorners = new Mat(corners.rows(), 2, CvType.CV_32F);
+        float[] matCornersData = new float[(int) (matCorners.total() * matCorners.channels())];
+        matCorners.get(0, 0, matCornersData);
+        for (int i = 0; i < corners.rows(); i++) {
+            Imgproc.circle(copy, new Point(cornersData[i * 2], cornersData[i * 2 + 1]), radius,
+                    new Scalar(rng.nextInt(256), rng.nextInt(256), rng.nextInt(256)), Imgproc.FILLED);
+            matCornersData[i * 2] = cornersData[i * 2];
+            matCornersData[i * 2 + 1] = cornersData[i * 2 + 1];
+        }
+        matCorners.put(0, 0, matCornersData);
+
+        imgLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(copy)));
+        frame.repaint();
+
+        /// Set the needed parameters to find the refined corners
+        Size winSize = new Size(5, 5);
+        Size zeroZone = new Size(-1, -1);
+        TermCriteria criteria = new TermCriteria(TermCriteria.EPS + TermCriteria.COUNT, 40, 0.001);
+
+        /// Calculate the refined corner locations
+        Imgproc.cornerSubPix(srcGray, matCorners, winSize, zeroZone, criteria);
+
+        /// Write them down
+        matCorners.get(0, 0, matCornersData);
+        for (int i = 0; i < corners.rows(); i++) {
+            System.out.println(
+                    " -- Refined Corner [" + i + "]  (" + matCornersData[i * 2] + "," + matCornersData[i * 2 + 1] + ")");
+        }
+    }
+}
+
+public class CornerSubPixDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new CornerSubPix(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/generic_corner_detector/CornerDetectorDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/generic_corner_detector/CornerDetectorDemo.java
new file mode 100644
index 00000000..f7743f5d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/generic_corner_detector/CornerDetectorDemo.java
@@ -0,0 +1,190 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.util.Random;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.Core.MinMaxLocResult;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class CornerDetector {
+    private Mat src = new Mat();
+    private Mat srcGray = new Mat();
+    private Mat harrisDst = new Mat();
+    private Mat shiTomasiDst = new Mat();
+    private Mat harrisCopy = new Mat();
+    private Mat shiTomasiCopy = new Mat();
+    private Mat Mc = new Mat();
+    private JFrame frame;
+    private JLabel harrisImgLabel;
+    private JLabel shiTomasiImgLabel;
+    private static final int MAX_QUALITY_LEVEL = 100;
+    private int qualityLevel = 50;
+    private double harrisMinVal;
+    private double harrisMaxVal;
+    private double shiTomasiMinVal;
+    private double shiTomasiMaxVal;
+    private Random rng = new Random(12345);
+
+    public CornerDetector(String[] args) {
+        /// Load source image and convert it to gray
+        String filename = args.length > 0 ? args[0] : "../data/building.jpg";
+        src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        Imgproc.cvtColor(src, srcGray, Imgproc.COLOR_BGR2GRAY);
+
+        // Create and set up the window.
+        frame = new JFrame("Creating your own corner detector demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+
+        /// Set some parameters
+        int blockSize = 3, apertureSize = 3;
+
+        /// My Harris matrix -- Using cornerEigenValsAndVecs
+        Imgproc.cornerEigenValsAndVecs(srcGray, harrisDst, blockSize, apertureSize);
+
+        /* calculate Mc */
+        Mc = Mat.zeros(srcGray.size(), CvType.CV_32F);
+
+        float[] harrisData = new float[(int) (harrisDst.total() * harrisDst.channels())];
+        harrisDst.get(0, 0, harrisData);
+        float[] McData = new float[(int) (Mc.total() * Mc.channels())];
+        Mc.get(0, 0, McData);
+
+        for( int i = 0; i < srcGray.rows(); i++ ) {
+            for( int j = 0; j < srcGray.cols(); j++ ) {
+                float lambda1 = harrisData[(i*srcGray.cols() + j) * 6];
+                float lambda2 = harrisData[(i*srcGray.cols() + j) * 6 + 1];
+                McData[i*srcGray.cols()+j] = (float) (lambda1*lambda2 - 0.04f*Math.pow( ( lambda1 + lambda2 ), 2 ));
+            }
+        }
+        Mc.put(0, 0, McData);
+
+        MinMaxLocResult res = Core.minMaxLoc(Mc);
+        harrisMinVal = res.minVal;
+        harrisMaxVal = res.maxVal;
+
+        /// My Shi-Tomasi -- Using cornerMinEigenVal
+        Imgproc.cornerMinEigenVal(srcGray, shiTomasiDst, blockSize, apertureSize);
+        res = Core.minMaxLoc(shiTomasiDst);
+        shiTomasiMinVal = res.minVal;
+        shiTomasiMaxVal = res.maxVal;
+
+        update();
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        sliderPanel.add(new JLabel("Max  corners:"));
+        JSlider slider = new JSlider(0, MAX_QUALITY_LEVEL, qualityLevel);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                qualityLevel = source.getValue();
+                update();
+            }
+        });
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        JPanel imgPanel = new JPanel();
+        harrisImgLabel = new JLabel(new ImageIcon(img));
+        shiTomasiImgLabel = new JLabel(new ImageIcon(img));
+        imgPanel.add(harrisImgLabel);
+        imgPanel.add(shiTomasiImgLabel);
+        pane.add(imgPanel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        int qualityLevelVal = Math.max(qualityLevel, 1);
+
+        //Harris
+        harrisCopy = src.clone();
+
+        float[] McData = new float[(int) (Mc.total() * Mc.channels())];
+        Mc.get(0, 0, McData);
+        for (int i = 0; i < srcGray.rows(); i++) {
+            for (int j = 0; j < srcGray.cols(); j++) {
+                if (McData[i * srcGray.cols() + j] > harrisMinVal
+                        + (harrisMaxVal - harrisMinVal) * qualityLevelVal / MAX_QUALITY_LEVEL) {
+                    Imgproc.circle(harrisCopy, new Point(j, i), 4,
+                            new Scalar(rng.nextInt(256), rng.nextInt(256), rng.nextInt(256)), Imgproc.FILLED);
+                }
+            }
+        }
+
+        //Shi-Tomasi
+        shiTomasiCopy = src.clone();
+
+        float[] shiTomasiData = new float[(int) (shiTomasiDst.total() * shiTomasiDst.channels())];
+        shiTomasiDst.get(0, 0, shiTomasiData);
+        for (int i = 0; i < srcGray.rows(); i++) {
+            for (int j = 0; j < srcGray.cols(); j++) {
+                if (shiTomasiData[i * srcGray.cols() + j] > shiTomasiMinVal
+                        + (shiTomasiMaxVal - shiTomasiMinVal) * qualityLevelVal / MAX_QUALITY_LEVEL) {
+                    Imgproc.circle(shiTomasiCopy, new Point(j, i), 4,
+                            new Scalar(rng.nextInt(256), rng.nextInt(256), rng.nextInt(256)), Imgproc.FILLED);
+                }
+            }
+        }
+
+        harrisImgLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(harrisCopy)));
+        shiTomasiImgLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(shiTomasiCopy)));
+        frame.repaint();
+    }
+}
+
+public class CornerDetectorDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new CornerDetector(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/good_features_to_track/GoodFeaturesToTrackDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/good_features_to_track/GoodFeaturesToTrackDemo.java
new file mode 100644
index 00000000..2033cd57
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/good_features_to_track/GoodFeaturesToTrackDemo.java
@@ -0,0 +1,134 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+import java.util.Random;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class GoodFeaturesToTrack {
+    private Mat src = new Mat();
+    private Mat srcGray = new Mat();
+    private JFrame frame;
+    private JLabel imgLabel;
+    private static final int MAX_THRESHOLD = 100;
+    private int maxCorners = 23;
+    private Random rng = new Random(12345);
+
+    public GoodFeaturesToTrack(String[] args) {
+        /// Load source image and convert it to gray
+        String filename = args.length > 0 ? args[0] : "../data/pic3.png";
+        src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        Imgproc.cvtColor(src, srcGray, Imgproc.COLOR_BGR2GRAY);
+
+        // Create and set up the window.
+        frame = new JFrame("Shi-Tomasi corner detector demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        update();
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        sliderPanel.add(new JLabel("Max  corners:"));
+        JSlider slider = new JSlider(0, MAX_THRESHOLD, maxCorners);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                maxCorners = source.getValue();
+                update();
+            }
+        });
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        imgLabel = new JLabel(new ImageIcon(img));
+        pane.add(imgLabel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        /// Parameters for Shi-Tomasi algorithm
+        maxCorners = Math.max(maxCorners, 1);
+        MatOfPoint corners = new MatOfPoint();
+        double qualityLevel = 0.01;
+        double minDistance = 10;
+        int blockSize = 3, gradientSize = 3;
+        boolean useHarrisDetector = false;
+        double k = 0.04;
+
+        /// Copy the source image
+        Mat copy = src.clone();
+
+        /// Apply corner detection
+        Imgproc.goodFeaturesToTrack(srcGray, corners, maxCorners, qualityLevel, minDistance, new Mat(),
+                blockSize, gradientSize, useHarrisDetector, k);
+
+        /// Draw corners detected
+        System.out.println("** Number of corners detected: " + corners.rows());
+        int[] cornersData = new int[(int) (corners.total() * corners.channels())];
+        corners.get(0, 0, cornersData);
+        int radius = 4;
+        for (int i = 0; i < corners.rows(); i++) {
+            Imgproc.circle(copy, new Point(cornersData[i * 2], cornersData[i * 2 + 1]), radius,
+                    new Scalar(rng.nextInt(256), rng.nextInt(256), rng.nextInt(256)), Imgproc.FILLED);
+        }
+
+        imgLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(copy)));
+        frame.repaint();
+    }
+}
+
+public class GoodFeaturesToTrackDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new GoodFeaturesToTrack(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/harris_detector/CornerHarrisDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/harris_detector/CornerHarrisDemo.java
new file mode 100644
index 00000000..b3c759d2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/TrackingMotion/harris_detector/CornerHarrisDemo.java
@@ -0,0 +1,142 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class CornerHarris {
+    private Mat srcGray = new Mat();
+    private Mat dst = new Mat();
+    private Mat dstNorm = new Mat();
+    private Mat dstNormScaled = new Mat();
+    private JFrame frame;
+    private JLabel imgLabel;
+    private JLabel cornerLabel;
+    private static final int MAX_THRESHOLD = 255;
+    private int threshold = 200;
+
+    public CornerHarris(String[] args) {
+        /// Load source image and convert it to gray
+        String filename = args.length > 0 ? args[0] : "../data/building.jpg";
+        Mat src = Imgcodecs.imread(filename);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        Imgproc.cvtColor(src, srcGray, Imgproc.COLOR_BGR2GRAY);
+
+        // Create and set up the window.
+        frame = new JFrame("Harris corner detector demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(src);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        update();
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        sliderPanel.add(new JLabel("Threshold: "));
+        JSlider slider = new JSlider(0, MAX_THRESHOLD, threshold);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(10);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                threshold = source.getValue();
+                update();
+            }
+        });
+        sliderPanel.add(slider);
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+
+        JPanel imgPanel = new JPanel();
+        imgLabel = new JLabel(new ImageIcon(img));
+        imgPanel.add(imgLabel);
+
+        Mat blackImg = Mat.zeros(srcGray.size(), CvType.CV_8U);
+        cornerLabel = new JLabel(new ImageIcon(HighGui.toBufferedImage(blackImg)));
+        imgPanel.add(cornerLabel);
+
+        pane.add(imgPanel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        dst = Mat.zeros(srcGray.size(), CvType.CV_32F);
+
+        /// Detector parameters
+        int blockSize = 2;
+        int apertureSize = 3;
+        double k = 0.04;
+
+        /// Detecting corners
+        Imgproc.cornerHarris(srcGray, dst, blockSize, apertureSize, k);
+
+        /// Normalizing
+        Core.normalize(dst, dstNorm, 0, 255, Core.NORM_MINMAX);
+        Core.convertScaleAbs(dstNorm, dstNormScaled);
+
+        /// Drawing a circle around corners
+        float[] dstNormData = new float[(int) (dstNorm.total() * dstNorm.channels())];
+        dstNorm.get(0, 0, dstNormData);
+
+        for (int i = 0; i < dstNorm.rows(); i++) {
+            for (int j = 0; j < dstNorm.cols(); j++) {
+                if ((int) dstNormData[i * dstNorm.cols() + j] > threshold) {
+                    Imgproc.circle(dstNormScaled, new Point(j, i), 5, new Scalar(0), 2, 8, 0);
+                }
+            }
+        }
+
+        cornerLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(dstNormScaled)));
+        frame.repaint();
+    }
+}
+
+public class CornerHarrisDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new CornerHarris(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/build.xml b/C++/opencv-4.7.0/samples/java/tutorial_code/build.xml
new file mode 100644
index 00000000..4bba3c97
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/build.xml
@@ -0,0 +1,13 @@
+<project default="compile">
+
+    <property name="lib.dir"     value="${ocvJarDir}"/>
+    <path id="classpath">
+        <fileset dir="${lib.dir}" includes="**/*.jar"/>
+    </path>
+
+    <target name="compile">
+        <mkdir dir="${dstDir}"/>
+        <javac includeantruntime="false" srcdir="${srcDir}" destdir="${dstDir}" classpathref="classpath"/>
+    </target>
+
+</project>
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/core/AddingImages/AddingImages.java b/C++/opencv-4.7.0/samples/java/tutorial_code/core/AddingImages/AddingImages.java
new file mode 100644
index 00000000..238c5eee
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/core/AddingImages/AddingImages.java
@@ -0,0 +1,51 @@
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+class AddingImagesRun{
+    public void run() {
+        double alpha = 0.5; double beta; double input;
+
+        Mat src1, src2, dst = new Mat();
+
+        System.out.println(" Simple Linear Blender ");
+        System.out.println("-----------------------");
+        System.out.println("* Enter alpha [0.0-1.0]: ");
+        Scanner scan = new Scanner( System.in ).useLocale(Locale.US);
+        input = scan.nextDouble();
+
+        if( input >= 0.0 && input <= 1.0 )
+            alpha = input;
+
+        //! [load]
+        src1 = Imgcodecs.imread("../../images/LinuxLogo.jpg");
+        src2 = Imgcodecs.imread("../../images/WindowsLogo.jpg");
+        //! [load]
+
+        if( src1.empty() == true ){ System.out.println("Error loading src1"); return;}
+        if( src2.empty() == true ){ System.out.println("Error loading src2"); return;}
+
+        //! [blend_images]
+        beta = ( 1.0 - alpha );
+        Core.addWeighted( src1, alpha, src2, beta, 0.0, dst);
+        //! [blend_images]
+
+        //![display]
+        HighGui.imshow("Linear Blend", dst);
+        HighGui.waitKey(0);
+        //![display]
+
+        System.exit(0);
+    }
+}
+
+public class AddingImages {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new AddingImagesRun().run();
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/core/discrete_fourier_transform/DiscreteFourierTransform.java b/C++/opencv-4.7.0/samples/java/tutorial_code/core/discrete_fourier_transform/DiscreteFourierTransform.java
new file mode 100644
index 00000000..ca2560be
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/core/discrete_fourier_transform/DiscreteFourierTransform.java
@@ -0,0 +1,109 @@
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+
+import java.util.List;
+import java.util.*;
+
+class DiscreteFourierTransformRun{
+    private void help() {
+        System.out.println("" +
+                "This program demonstrated the use of the discrete Fourier transform (DFT). \n" +
+                "The dft of an image is taken and it's power spectrum is displayed.\n" +
+                "Usage:\n" +
+                "./DiscreteFourierTransform [image_name -- default ../data/lena.jpg]");
+    }
+
+    public void run(String[] args){
+
+        help();
+
+        String filename = ((args.length > 0) ? args[0] : "../data/lena.jpg");
+
+        Mat I = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
+        if( I.empty() ) {
+            System.out.println("Error opening image");
+            System.exit(-1);
+        }
+
+        //! [expand]
+        Mat padded = new Mat();                     //expand input image to optimal size
+        int m = Core.getOptimalDFTSize( I.rows() );
+        int n = Core.getOptimalDFTSize( I.cols() ); // on the border add zero values
+        Core.copyMakeBorder(I, padded, 0, m - I.rows(), 0, n - I.cols(), Core.BORDER_CONSTANT, Scalar.all(0));
+        //! [expand]
+
+        //! [complex_and_real]
+        List<Mat> planes = new ArrayList<Mat>();
+        padded.convertTo(padded, CvType.CV_32F);
+        planes.add(padded);
+        planes.add(Mat.zeros(padded.size(), CvType.CV_32F));
+        Mat complexI = new Mat();
+        Core.merge(planes, complexI);         // Add to the expanded another plane with zeros
+        //! [complex_and_real]
+
+        //! [dft]
+        Core.dft(complexI, complexI);         // this way the result may fit in the source matrix
+        //! [dft]
+
+        // compute the magnitude and switch to logarithmic scale
+        // => log(1 + sqrt(Re(DFT(I))^2 + Im(DFT(I))^2))
+        //! [magnitude]
+        Core.split(complexI, planes);                               // planes.get(0) = Re(DFT(I)
+                                                                    // planes.get(1) = Im(DFT(I))
+        Core.magnitude(planes.get(0), planes.get(1), planes.get(0));// planes.get(0) = magnitude
+        Mat magI = planes.get(0);
+        //! [magnitude]
+
+        //! [log]
+        Mat matOfOnes = Mat.ones(magI.size(), magI.type());
+        Core.add(matOfOnes, magI, magI);         // switch to logarithmic scale
+        Core.log(magI, magI);
+        //! [log]
+
+        //! [crop_rearrange]
+        // crop the spectrum, if it has an odd number of rows or columns
+        magI = magI.submat(new Rect(0, 0, magI.cols() & -2, magI.rows() & -2));
+
+        // rearrange the quadrants of Fourier image  so that the origin is at the image center
+        int cx = magI.cols()/2;
+        int cy = magI.rows()/2;
+
+        Mat q0 = new Mat(magI, new Rect(0, 0, cx, cy));   // Top-Left - Create a ROI per quadrant
+        Mat q1 = new Mat(magI, new Rect(cx, 0, cx, cy));  // Top-Right
+        Mat q2 = new Mat(magI, new Rect(0, cy, cx, cy));  // Bottom-Left
+        Mat q3 = new Mat(magI, new Rect(cx, cy, cx, cy)); // Bottom-Right
+
+        Mat tmp = new Mat();               // swap quadrants (Top-Left with Bottom-Right)
+        q0.copyTo(tmp);
+        q3.copyTo(q0);
+        tmp.copyTo(q3);
+
+        q1.copyTo(tmp);                    // swap quadrant (Top-Right with Bottom-Left)
+        q2.copyTo(q1);
+        tmp.copyTo(q2);
+        //! [crop_rearrange]
+
+        magI.convertTo(magI, CvType.CV_8UC1);
+        //! [normalize]
+        Core.normalize(magI, magI, 0, 255, Core.NORM_MINMAX, CvType.CV_8UC1); // Transform the matrix with float values
+                                                                            // into a viewable image form (float between
+                                                                            // values 0 and 255).
+        //! [normalize]
+
+        HighGui.imshow("Input Image"       , I   );    // Show the result
+        HighGui.imshow("Spectrum Magnitude", magI);
+        HighGui.waitKey();
+
+        System.exit(0);
+    }
+}
+
+
+public class DiscreteFourierTransform {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new DiscreteFourierTransformRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/core/mat_mask_operations/MatMaskOperations.java b/C++/opencv-4.7.0/samples/java/tutorial_code/core/mat_mask_operations/MatMaskOperations.java
new file mode 100644
index 00000000..12869c73
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/core/mat_mask_operations/MatMaskOperations.java
@@ -0,0 +1,120 @@
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+class MatMaskOperationsRun {
+
+    public void run(String[] args) {
+
+        String filename = "../data/lena.jpg";
+
+        int img_codec = Imgcodecs.IMREAD_COLOR;
+        if (args.length != 0) {
+            filename = args[0];
+            if (args.length >= 2 && args[1].equals("G"))
+                img_codec = Imgcodecs.IMREAD_GRAYSCALE;
+        }
+
+        Mat src = Imgcodecs.imread(filename, img_codec);
+
+        if (src.empty()) {
+            System.out.println("Can't open image [" + filename + "]");
+            System.out.println("Program Arguments: [image_path -- default ../data/lena.jpg] [G -- grayscale]");
+            System.exit(-1);
+        }
+
+        HighGui.namedWindow("Input", HighGui.WINDOW_AUTOSIZE);
+        HighGui.namedWindow("Output", HighGui.WINDOW_AUTOSIZE);
+
+        HighGui.imshow( "Input", src );
+        double t = System.currentTimeMillis();
+
+        Mat dst0 = sharpen(src, new Mat());
+
+        t = ((double) System.currentTimeMillis() - t) / 1000;
+        System.out.println("Hand written function time passed in seconds: " + t);
+
+        HighGui.imshow( "Output", dst0 );
+        HighGui.moveWindow("Output", 400, 400);
+        HighGui.waitKey();
+
+        //![kern]
+        Mat kern = new Mat(3, 3, CvType.CV_8S);
+        int row = 0, col = 0;
+        kern.put(row, col, 0, -1, 0, -1, 5, -1, 0, -1, 0);
+        //![kern]
+
+        t = System.currentTimeMillis();
+
+        Mat dst1 = new Mat();
+        //![filter2D]
+        Imgproc.filter2D(src, dst1, src.depth(), kern);
+        //![filter2D]
+        t = ((double) System.currentTimeMillis() - t) / 1000;
+        System.out.println("Built-in filter2D time passed in seconds:     " + t);
+
+        HighGui.imshow( "Output", dst1 );
+
+        HighGui.waitKey();
+        System.exit(0);
+    }
+
+    //! [basic_method]
+    public static double saturate(double x) {
+        return x > 255.0 ? 255.0 : (x < 0.0 ? 0.0 : x);
+    }
+
+    public Mat sharpen(Mat myImage, Mat Result) {
+        //! [8_bit]
+        myImage.convertTo(myImage, CvType.CV_8U);
+        //! [8_bit]
+
+        //! [create_channels]
+        int nChannels = myImage.channels();
+        Result.create(myImage.size(), myImage.type());
+        //! [create_channels]
+
+        //! [basic_method_loop]
+        for (int j = 1; j < myImage.rows() - 1; ++j) {
+            for (int i = 1; i < myImage.cols() - 1; ++i) {
+                double sum[] = new double[nChannels];
+
+                for (int k = 0; k < nChannels; ++k) {
+
+                    double top = -myImage.get(j - 1, i)[k];
+                    double bottom = -myImage.get(j + 1, i)[k];
+                    double center = (5 * myImage.get(j, i)[k]);
+                    double left = -myImage.get(j, i - 1)[k];
+                    double right = -myImage.get(j, i + 1)[k];
+
+                    sum[k] = saturate(top + bottom + center + left + right);
+                }
+
+                Result.put(j, i, sum);
+            }
+        }
+        //! [basic_method_loop]
+
+        //! [borders]
+        Result.row(0).setTo(new Scalar(0));
+        Result.row(Result.rows() - 1).setTo(new Scalar(0));
+        Result.col(0).setTo(new Scalar(0));
+        Result.col(Result.cols() - 1).setTo(new Scalar(0));
+        //! [borders]
+
+        return Result;
+    }
+    //! [basic_method]
+}
+
+public class MatMaskOperations {
+    public static void main(String[] args) {
+        // Load the native library.
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new MatMaskOperationsRun().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/core/mat_operations/MatOperations.java b/C++/opencv-4.7.0/samples/java/tutorial_code/core/mat_operations/MatOperations.java
new file mode 100644
index 00000000..e5fe7cdd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/core/mat_operations/MatOperations.java
@@ -0,0 +1,130 @@
+import java.util.Arrays;
+
+import org.opencv.core.Core;
+import org.opencv.core.Core.MinMaxLocResult;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Rect;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+public class MatOperations {
+    @SuppressWarnings("unused")
+    public static void main(String[] args) {
+        /*  Snippet code for Operations with images tutorial (not intended to be run) */
+
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        String filename = "";
+        // Input/Output
+        {
+            //! [Load an image from a file]
+            Mat img = Imgcodecs.imread(filename);
+            //! [Load an image from a file]
+        }
+        {
+            //! [Load an image from a file in grayscale]
+            Mat img = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
+            //! [Load an image from a file in grayscale]
+        }
+        {
+            Mat img = new Mat(4, 4, CvType.CV_8U);
+            //! [Save image]
+            Imgcodecs.imwrite(filename, img);
+            //! [Save image]
+        }
+        // Accessing pixel intensity values
+        {
+            Mat img = new Mat(4, 4, CvType.CV_8U);
+            int y = 0, x = 0;
+            {
+                //! [Pixel access 1]
+                byte[] imgData = new byte[(int) (img.total() * img.channels())];
+                img.get(0, 0, imgData);
+                byte intensity = imgData[y * img.cols() + x];
+                //! [Pixel access 1]
+            }
+            {
+                //! [Pixel access 5]
+                byte[] imgData = new byte[(int) (img.total() * img.channels())];
+                imgData[y * img.cols() + x] = (byte) 128;
+                img.put(0, 0, imgData);
+                //! [Pixel access 5]
+            }
+
+        }
+        // Memory management and reference counting
+        {
+            //! [Reference counting 2]
+            Mat img = Imgcodecs.imread("image.jpg");
+            Mat img1 = img.clone();
+            //! [Reference counting 2]
+        }
+        {
+            //! [Reference counting 3]
+            Mat img = Imgcodecs.imread("image.jpg");
+            Mat sobelx = new Mat();
+            Imgproc.Sobel(img, sobelx, CvType.CV_32F, 1, 0);
+            //! [Reference counting 3]
+        }
+        // Primitive operations
+        {
+            Mat img = new Mat(400, 400, CvType.CV_8UC3);
+            {
+                //! [Set image to black]
+                byte[] imgData = new byte[(int) (img.total() * img.channels())];
+                Arrays.fill(imgData, (byte) 0);
+                img.put(0, 0, imgData);
+                //! [Set image to black]
+            }
+            {
+                //! [Select ROI]
+                Rect r = new Rect(10, 10, 100, 100);
+                Mat smallImg = img.submat(r);
+                //! [Select ROI]
+            }
+        }
+        {
+            //! [BGR to Gray]
+            Mat img = Imgcodecs.imread("image.jpg"); // loading a 8UC3 image
+            Mat grey = new Mat();
+            Imgproc.cvtColor(img, grey, Imgproc.COLOR_BGR2GRAY);
+            //! [BGR to Gray]
+        }
+        {
+            Mat dst = new Mat(), src = new Mat();
+            //! [Convert to CV_32F]
+            src.convertTo(dst, CvType.CV_32F);
+            //! [Convert to CV_32F]
+        }
+        // Visualizing images
+        {
+            //! [imshow 1]
+            Mat img = Imgcodecs.imread("image.jpg");
+            HighGui.namedWindow("image", HighGui.WINDOW_AUTOSIZE);
+            HighGui.imshow("image", img);
+            HighGui.waitKey();
+            //! [imshow 1]
+        }
+        {
+            //! [imshow 2]
+            Mat img = Imgcodecs.imread("image.jpg");
+            Mat grey = new Mat();
+            Imgproc.cvtColor(img, grey, Imgproc.COLOR_BGR2GRAY);
+            Mat sobelx = new Mat();
+            Imgproc.Sobel(grey, sobelx, CvType.CV_32F, 1, 0);
+            MinMaxLocResult res = Core.minMaxLoc(sobelx); // find minimum and maximum intensities
+            Mat draw = new Mat();
+            double maxVal = res.maxVal, minVal = res.minVal;
+            sobelx.convertTo(draw, CvType.CV_8U, 255.0 / (maxVal - minVal), -minVal * 255.0 / (maxVal - minVal));
+            HighGui.namedWindow("image", HighGui.WINDOW_AUTOSIZE);
+            HighGui.imshow("image", draw);
+            HighGui.waitKey();
+            //! [imshow 2]
+        }
+        System.exit(0);
+    }
+
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/Homography/PanoramaStitchingRotatingCamera.java b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/Homography/PanoramaStitchingRotatingCamera.java
new file mode 100644
index 00000000..ba86895d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/Homography/PanoramaStitchingRotatingCamera.java
@@ -0,0 +1,89 @@
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.core.*;
+import org.opencv.core.Range;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+
+class PanoramaStitchingRotatingCameraRun {
+    void basicPanoramaStitching (String[] args) {
+        String img1path = args[0], img2path = args[1];
+        Mat img1 = new Mat(), img2 = new Mat();
+        img1 = Imgcodecs.imread(img1path);
+        img2 = Imgcodecs.imread(img2path);
+
+        //! [camera-pose-from-Blender-at-location-1]
+        Mat c1Mo = new Mat( 4, 4, CvType.CV_64FC1 );
+        c1Mo.put(0 ,0 ,0.9659258723258972, 0.2588190734386444, 0.0, 1.5529145002365112,
+                 0.08852133899927139, -0.3303661346435547, -0.9396926164627075, -0.10281121730804443,
+                 -0.24321036040782928, 0.9076734185218811, -0.342020183801651, 6.130080699920654,
+                 0, 0, 0, 1 );
+        //! [camera-pose-from-Blender-at-location-1]
+
+        //! [camera-pose-from-Blender-at-location-2]
+        Mat c2Mo = new Mat( 4, 4, CvType.CV_64FC1 );
+        c2Mo.put(0, 0, 0.9659258723258972, -0.2588190734386444, 0.0, -1.5529145002365112,
+                 -0.08852133899927139, -0.3303661346435547, -0.9396926164627075, -0.10281121730804443,
+                 0.24321036040782928, 0.9076734185218811, -0.342020183801651, 6.130080699920654,
+                 0, 0, 0, 1);
+        //! [camera-pose-from-Blender-at-location-2]
+
+        //! [camera-intrinsics-from-Blender]
+        Mat cameraMatrix = new Mat(3, 3, CvType.CV_64FC1);
+        cameraMatrix.put(0, 0, 700.0, 0.0, 320.0, 0.0, 700.0, 240.0, 0, 0, 1 );
+        //! [camera-intrinsics-from-Blender]
+
+        //! [extract-rotation]
+        Range rowRange = new Range(0,3);
+        Range colRange = new Range(0,3);
+        //! [extract-rotation]
+
+        //! [compute-rotation-displacement]
+        //c1Mo * oMc2
+        Mat R1 = new  Mat(c1Mo, rowRange, colRange);
+        Mat R2 = new Mat(c2Mo, rowRange, colRange);
+        Mat R_2to1 = new Mat();
+        Core.gemm(R1, R2.t(), 1, new Mat(), 0, R_2to1 );
+        //! [compute-rotation-displacement]
+
+        //! [compute-homography]
+        Mat tmp = new Mat(), H = new Mat();
+        Core.gemm(cameraMatrix, R_2to1, 1, new Mat(), 0, tmp);
+        Core.gemm(tmp, cameraMatrix.inv(), 1, new Mat(), 0, H);
+        Scalar s = new Scalar(H.get(2, 2)[0]);
+        Core.divide(H, s, H);
+        System.out.println(H.dump());
+        //! [compute-homography]
+
+        //! [stitch]
+        Mat img_stitch = new Mat();
+        Imgproc.warpPerspective(img2, img_stitch, H, new Size(img2.cols()*2, img2.rows()) );
+        Mat half = new Mat();
+        half =  new Mat(img_stitch, new Rect(0, 0, img1.cols(), img1.rows()));
+        img1.copyTo(half);
+        //! [stitch]
+
+        Mat img_compare = new Mat();
+        Mat img_space = Mat.zeros(new Size(50, img1.rows()), CvType.CV_8UC3);
+        List<Mat>list = new ArrayList<>();
+        list.add(img1);
+        list.add(img_space);
+        list.add(img2);
+        Core.hconcat(list, img_compare);
+
+        HighGui.imshow("Compare Images", img_compare);
+        HighGui.imshow("Panorama Stitching", img_stitch);
+        HighGui.waitKey(0);
+        System.exit(0);
+    }
+}
+
+public class PanoramaStitchingRotatingCamera {
+    public static void main(String[] args) {
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new PanoramaStitchingRotatingCameraRun().basicPanoramaStitching(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/Homography/PerspectiveCorrection.java b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/Homography/PerspectiveCorrection.java
new file mode 100644
index 00000000..f702c194
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/Homography/PerspectiveCorrection.java
@@ -0,0 +1,89 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import org.opencv.core.*;
+import org.opencv.calib3d.Calib3d;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+
+class PerspectiveCorrectionRun {
+    void perspectiveCorrection (String[] args) {
+        String img1Path = args[0], img2Path = args[1];
+        Mat img1 = Imgcodecs.imread(img1Path);
+        Mat img2 = Imgcodecs.imread(img2Path);
+
+        //! [find-corners]
+        MatOfPoint2f corners1 = new MatOfPoint2f(), corners2 = new MatOfPoint2f();
+        boolean found1 = Calib3d.findChessboardCorners(img1, new Size(9, 6), corners1 );
+        boolean found2 = Calib3d.findChessboardCorners(img2, new Size(9, 6), corners2 );
+        //! [find-corners]
+
+        if (!found1 || !found2) {
+            System.out.println("Error, cannot find the chessboard corners in both images.");
+            System.exit(-1);
+        }
+
+        //! [estimate-homography]
+        Mat H = new Mat();
+        H = Calib3d.findHomography(corners1, corners2);
+        System.out.println(H.dump());
+        //! [estimate-homography]
+
+        //! [warp-chessboard]
+        Mat img1_warp = new Mat();
+        Imgproc.warpPerspective(img1, img1_warp, H, img1.size());
+        //! [warp-chessboard]
+
+        Mat img_draw_warp = new Mat();
+        List<Mat> list1 = new ArrayList<>(), list2 = new ArrayList<>() ;
+        list1.add(img2);
+        list1.add(img1_warp);
+        Core.hconcat(list1, img_draw_warp);
+        HighGui.imshow("Desired chessboard view / Warped source chessboard view", img_draw_warp);
+
+        //! [compute-transformed-corners]
+        Mat img_draw_matches = new Mat();
+        list2.add(img1);
+        list2.add(img2);
+        Core.hconcat(list2, img_draw_matches);
+        Point []corners1Arr = corners1.toArray();
+
+        for (int i = 0 ; i < corners1Arr.length; i++) {
+            Mat pt1 = new Mat(3, 1, CvType.CV_64FC1), pt2 = new Mat();
+            pt1.put(0, 0, corners1Arr[i].x, corners1Arr[i].y, 1 );
+
+            Core.gemm(H, pt1, 1, new Mat(), 0, pt2);
+            double[] data = pt2.get(2, 0);
+            Core.divide(pt2, new Scalar(data[0]), pt2);
+
+            double[] data1 =pt2.get(0, 0);
+            double[] data2 = pt2.get(1, 0);
+            Point end = new Point((int)(img1.cols()+ data1[0]), (int)data2[0]);
+            Imgproc.line(img_draw_matches, corners1Arr[i], end, RandomColor(), 2);
+        }
+
+        HighGui.imshow("Draw matches", img_draw_matches);
+        HighGui.waitKey(0);
+        //! [compute-transformed-corners]
+
+        System.exit(0);
+    }
+
+    Scalar RandomColor () {
+        Random rng = new Random();
+        int r = rng.nextInt(256);
+        int g = rng.nextInt(256);
+        int b = rng.nextInt(256);
+        return new Scalar(r, g, b);
+    }
+}
+
+public class PerspectiveCorrection {
+    public static void main (String[] args) {
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new PerspectiveCorrectionRun().perspectiveCorrection(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/akaze_matching/AKAZEMatchDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/akaze_matching/AKAZEMatchDemo.java
new file mode 100644
index 00000000..33e3c38b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/akaze_matching/AKAZEMatchDemo.java
@@ -0,0 +1,163 @@
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.DMatch;
+import org.opencv.core.KeyPoint;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.AKAZE;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.Features2d;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+class AKAZEMatch {
+    public void run(String[] args) {
+        //! [load]
+        String filename1 = args.length > 2 ? args[0] : "../data/graf1.png";
+        String filename2 = args.length > 2 ? args[1] : "../data/graf3.png";
+        String filename3 = args.length > 2 ? args[2] : "../data/H1to3p.xml";
+        Mat img1 = Imgcodecs.imread(filename1, Imgcodecs.IMREAD_GRAYSCALE);
+        Mat img2 = Imgcodecs.imread(filename2, Imgcodecs.IMREAD_GRAYSCALE);
+        if (img1.empty() || img2.empty()) {
+            System.err.println("Cannot read images!");
+            System.exit(0);
+        }
+
+        File file = new File(filename3);
+        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
+        DocumentBuilder documentBuilder;
+        Document document;
+        Mat homography = new Mat(3, 3, CvType.CV_64F);
+        double[] homographyData = new double[(int) (homography.total()*homography.channels())];
+        try {
+            documentBuilder = documentBuilderFactory.newDocumentBuilder();
+            document = documentBuilder.parse(file);
+            String homographyStr = document.getElementsByTagName("data").item(0).getTextContent();
+            String[] splited = homographyStr.split("\\s+");
+            int idx = 0;
+            for (String s : splited) {
+                if (!s.isEmpty()) {
+                    homographyData[idx] = Double.parseDouble(s);
+                    idx++;
+                }
+            }
+        } catch (ParserConfigurationException e) {
+            e.printStackTrace();
+            System.exit(0);
+        } catch (SAXException e) {
+            e.printStackTrace();
+            System.exit(0);
+        } catch (IOException e) {
+            e.printStackTrace();
+            System.exit(0);
+        }
+        homography.put(0, 0, homographyData);
+        //! [load]
+
+        //! [AKAZE]
+        AKAZE akaze = AKAZE.create();
+        MatOfKeyPoint kpts1 = new MatOfKeyPoint(), kpts2 = new MatOfKeyPoint();
+        Mat desc1 = new Mat(), desc2 = new Mat();
+        akaze.detectAndCompute(img1, new Mat(), kpts1, desc1);
+        akaze.detectAndCompute(img2, new Mat(), kpts2, desc2);
+        //! [AKAZE]
+
+        //! [2-nn matching]
+        DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);
+        List<MatOfDMatch> knnMatches = new ArrayList<>();
+        matcher.knnMatch(desc1, desc2, knnMatches, 2);
+        //! [2-nn matching]
+
+        //! [ratio test filtering]
+        float ratioThreshold = 0.8f; // Nearest neighbor matching ratio
+        List<KeyPoint> listOfMatched1 = new ArrayList<>();
+        List<KeyPoint> listOfMatched2 = new ArrayList<>();
+        List<KeyPoint> listOfKeypoints1 = kpts1.toList();
+        List<KeyPoint> listOfKeypoints2 = kpts2.toList();
+        for (int i = 0; i < knnMatches.size(); i++) {
+            DMatch[] matches = knnMatches.get(i).toArray();
+            float dist1 = matches[0].distance;
+            float dist2 = matches[1].distance;
+            if (dist1 < ratioThreshold * dist2) {
+                listOfMatched1.add(listOfKeypoints1.get(matches[0].queryIdx));
+                listOfMatched2.add(listOfKeypoints2.get(matches[0].trainIdx));
+            }
+        }
+        //! [ratio test filtering]
+
+        //! [homography check]
+        double inlierThreshold = 2.5; // Distance threshold to identify inliers with homography check
+        List<KeyPoint> listOfInliers1 = new ArrayList<>();
+        List<KeyPoint> listOfInliers2 = new ArrayList<>();
+        List<DMatch> listOfGoodMatches = new ArrayList<>();
+        for (int i = 0; i < listOfMatched1.size(); i++) {
+            Mat col = new Mat(3, 1, CvType.CV_64F);
+            double[] colData = new double[(int) (col.total() * col.channels())];
+            colData[0] = listOfMatched1.get(i).pt.x;
+            colData[1] = listOfMatched1.get(i).pt.y;
+            colData[2] = 1.0;
+            col.put(0, 0, colData);
+
+            Mat colRes = new Mat();
+            Core.gemm(homography, col, 1.0, new Mat(), 0.0, colRes);
+            colRes.get(0, 0, colData);
+            Core.multiply(colRes, new Scalar(1.0 / colData[2]), col);
+            col.get(0, 0, colData);
+
+            double dist = Math.sqrt(Math.pow(colData[0] - listOfMatched2.get(i).pt.x, 2) +
+                    Math.pow(colData[1] - listOfMatched2.get(i).pt.y, 2));
+
+            if (dist < inlierThreshold) {
+                listOfGoodMatches.add(new DMatch(listOfInliers1.size(), listOfInliers2.size(), 0));
+                listOfInliers1.add(listOfMatched1.get(i));
+                listOfInliers2.add(listOfMatched2.get(i));
+            }
+        }
+        //! [homography check]
+
+        //! [draw final matches]
+        Mat res = new Mat();
+        MatOfKeyPoint inliers1 = new MatOfKeyPoint(listOfInliers1.toArray(new KeyPoint[listOfInliers1.size()]));
+        MatOfKeyPoint inliers2 = new MatOfKeyPoint(listOfInliers2.toArray(new KeyPoint[listOfInliers2.size()]));
+        MatOfDMatch goodMatches = new MatOfDMatch(listOfGoodMatches.toArray(new DMatch[listOfGoodMatches.size()]));
+        Features2d.drawMatches(img1, inliers1, img2, inliers2, goodMatches, res);
+        Imgcodecs.imwrite("akaze_result.png", res);
+
+        double inlierRatio = listOfInliers1.size() / (double) listOfMatched1.size();
+        System.out.println("A-KAZE Matching Results");
+        System.out.println("*******************************");
+        System.out.println("# Keypoints 1:                        \t" + listOfKeypoints1.size());
+        System.out.println("# Keypoints 2:                        \t" + listOfKeypoints2.size());
+        System.out.println("# Matches:                            \t" + listOfMatched1.size());
+        System.out.println("# Inliers:                            \t" + listOfInliers1.size());
+        System.out.println("# Inliers Ratio:                      \t" + inlierRatio);
+
+        HighGui.imshow("result", res);
+        HighGui.waitKey();
+        //! [draw final matches]
+
+        System.exit(0);
+    }
+}
+
+public class AKAZEMatchDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new AKAZEMatch().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_description/SURFMatchingDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_description/SURFMatchingDemo.java
new file mode 100644
index 00000000..ac64417d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_description/SURFMatchingDemo.java
@@ -0,0 +1,56 @@
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.Features2d;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.xfeatures2d.SURF;
+
+class SURFMatching {
+    public void run(String[] args) {
+        String filename1 = args.length > 1 ? args[0] : "../data/box.png";
+        String filename2 = args.length > 1 ? args[1] : "../data/box_in_scene.png";
+        Mat img1 = Imgcodecs.imread(filename1, Imgcodecs.IMREAD_GRAYSCALE);
+        Mat img2 = Imgcodecs.imread(filename2, Imgcodecs.IMREAD_GRAYSCALE);
+        if (img1.empty() || img2.empty()) {
+            System.err.println("Cannot read images!");
+            System.exit(0);
+        }
+
+        //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+        double hessianThreshold = 400;
+        int nOctaves = 4, nOctaveLayers = 3;
+        boolean extended = false, upright = false;
+        SURF detector = SURF.create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint(), keypoints2 = new MatOfKeyPoint();
+        Mat descriptors1 = new Mat(), descriptors2 = new Mat();
+        detector.detectAndCompute(img1, new Mat(), keypoints1, descriptors1);
+        detector.detectAndCompute(img2, new Mat(), keypoints2, descriptors2);
+
+        //-- Step 2: Matching descriptor vectors with a brute force matcher
+        // Since SURF is a floating-point descriptor NORM_L2 is used
+        DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE);
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.match(descriptors1, descriptors2, matches);
+
+        //-- Draw matches
+        Mat imgMatches = new Mat();
+        Features2d.drawMatches(img1, keypoints1, img2, keypoints2, matches, imgMatches);
+
+        HighGui.imshow("Matches", imgMatches);
+        HighGui.waitKey(0);
+
+        System.exit(0);
+    }
+}
+
+public class SURFMatchingDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new SURFMatching().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_detection/SURFDetectionDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_detection/SURFDetectionDemo.java
new file mode 100644
index 00000000..c78a0c66
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_detection/SURFDetectionDemo.java
@@ -0,0 +1,44 @@
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.features2d.Features2d;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.xfeatures2d.SURF;
+
+class SURFDetection {
+    public void run(String[] args) {
+        String filename = args.length > 0 ? args[0] : "../data/box.png";
+        Mat src = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        //-- Step 1: Detect the keypoints using SURF Detector
+        double hessianThreshold = 400;
+        int nOctaves = 4, nOctaveLayers = 3;
+        boolean extended = false, upright = false;
+        SURF detector = SURF.create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+        detector.detect(src, keypoints);
+
+        //-- Draw keypoints
+        Features2d.drawKeypoints(src, keypoints, src);
+
+        //-- Show detected (drawn) keypoints
+        HighGui.imshow("SURF Keypoints", src);
+        HighGui.waitKey(0);
+
+        System.exit(0);
+    }
+}
+
+public class SURFDetectionDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new SURFDetection().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_flann_matcher/SURFFLANNMatchingDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_flann_matcher/SURFFLANNMatchingDemo.java
new file mode 100644
index 00000000..bd24e9a8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_flann_matcher/SURFFLANNMatchingDemo.java
@@ -0,0 +1,78 @@
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.DMatch;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfByte;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.Features2d;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.xfeatures2d.SURF;
+
+class SURFFLANNMatching {
+    public void run(String[] args) {
+        String filename1 = args.length > 1 ? args[0] : "../data/box.png";
+        String filename2 = args.length > 1 ? args[1] : "../data/box_in_scene.png";
+        Mat img1 = Imgcodecs.imread(filename1, Imgcodecs.IMREAD_GRAYSCALE);
+        Mat img2 = Imgcodecs.imread(filename2, Imgcodecs.IMREAD_GRAYSCALE);
+        if (img1.empty() || img2.empty()) {
+            System.err.println("Cannot read images!");
+            System.exit(0);
+        }
+
+        //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+        double hessianThreshold = 400;
+        int nOctaves = 4, nOctaveLayers = 3;
+        boolean extended = false, upright = false;
+        SURF detector = SURF.create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint(), keypoints2 = new MatOfKeyPoint();
+        Mat descriptors1 = new Mat(), descriptors2 = new Mat();
+        detector.detectAndCompute(img1, new Mat(), keypoints1, descriptors1);
+        detector.detectAndCompute(img2, new Mat(), keypoints2, descriptors2);
+
+        //-- Step 2: Matching descriptor vectors with a FLANN based matcher
+        // Since SURF is a floating-point descriptor NORM_L2 is used
+        DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.FLANNBASED);
+        List<MatOfDMatch> knnMatches = new ArrayList<>();
+        matcher.knnMatch(descriptors1, descriptors2, knnMatches, 2);
+
+        //-- Filter matches using the Lowe's ratio test
+        float ratioThresh = 0.7f;
+        List<DMatch> listOfGoodMatches = new ArrayList<>();
+        for (int i = 0; i < knnMatches.size(); i++) {
+            if (knnMatches.get(i).rows() > 1) {
+                DMatch[] matches = knnMatches.get(i).toArray();
+                if (matches[0].distance < ratioThresh * matches[1].distance) {
+                    listOfGoodMatches.add(matches[0]);
+                }
+            }
+        }
+        MatOfDMatch goodMatches = new MatOfDMatch();
+        goodMatches.fromList(listOfGoodMatches);
+
+        //-- Draw matches
+        Mat imgMatches = new Mat();
+        Features2d.drawMatches(img1, keypoints1, img2, keypoints2, goodMatches, imgMatches, Scalar.all(-1),
+                Scalar.all(-1), new MatOfByte(), Features2d.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS);
+
+        //-- Show detected matches
+        HighGui.imshow("Good Matches", imgMatches);
+        HighGui.waitKey(0);
+
+        System.exit(0);
+    }
+}
+
+public class SURFFLANNMatchingDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new SURFFLANNMatching().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_homography/SURFFLANNMatchingHomographyDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_homography/SURFFLANNMatchingHomographyDemo.java
new file mode 100644
index 00000000..1ee33b44
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/features2D/feature_homography/SURFFLANNMatchingHomographyDemo.java
@@ -0,0 +1,130 @@
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.calib3d.Calib3d;
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.DMatch;
+import org.opencv.core.KeyPoint;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfByte;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.Features2d;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.xfeatures2d.SURF;
+
+class SURFFLANNMatchingHomography {
+    public void run(String[] args) {
+        String filenameObject = args.length > 1 ? args[0] : "../data/box.png";
+        String filenameScene = args.length > 1 ? args[1] : "../data/box_in_scene.png";
+        Mat imgObject = Imgcodecs.imread(filenameObject, Imgcodecs.IMREAD_GRAYSCALE);
+        Mat imgScene = Imgcodecs.imread(filenameScene, Imgcodecs.IMREAD_GRAYSCALE);
+        if (imgObject.empty() || imgScene.empty()) {
+            System.err.println("Cannot read images!");
+            System.exit(0);
+        }
+
+        //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+        double hessianThreshold = 400;
+        int nOctaves = 4, nOctaveLayers = 3;
+        boolean extended = false, upright = false;
+        SURF detector = SURF.create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
+        MatOfKeyPoint keypointsObject = new MatOfKeyPoint(), keypointsScene = new MatOfKeyPoint();
+        Mat descriptorsObject = new Mat(), descriptorsScene = new Mat();
+        detector.detectAndCompute(imgObject, new Mat(), keypointsObject, descriptorsObject);
+        detector.detectAndCompute(imgScene, new Mat(), keypointsScene, descriptorsScene);
+
+        //-- Step 2: Matching descriptor vectors with a FLANN based matcher
+        // Since SURF is a floating-point descriptor NORM_L2 is used
+        DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.FLANNBASED);
+        List<MatOfDMatch> knnMatches = new ArrayList<>();
+        matcher.knnMatch(descriptorsObject, descriptorsScene, knnMatches, 2);
+
+        //-- Filter matches using the Lowe's ratio test
+        float ratioThresh = 0.75f;
+        List<DMatch> listOfGoodMatches = new ArrayList<>();
+        for (int i = 0; i < knnMatches.size(); i++) {
+            if (knnMatches.get(i).rows() > 1) {
+                DMatch[] matches = knnMatches.get(i).toArray();
+                if (matches[0].distance < ratioThresh * matches[1].distance) {
+                    listOfGoodMatches.add(matches[0]);
+                }
+            }
+        }
+        MatOfDMatch goodMatches = new MatOfDMatch();
+        goodMatches.fromList(listOfGoodMatches);
+
+        //-- Draw matches
+        Mat imgMatches = new Mat();
+        Features2d.drawMatches(imgObject, keypointsObject, imgScene, keypointsScene, goodMatches, imgMatches, Scalar.all(-1),
+                Scalar.all(-1), new MatOfByte(), Features2d.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS);
+
+        //-- Localize the object
+        List<Point> obj = new ArrayList<>();
+        List<Point> scene = new ArrayList<>();
+
+        List<KeyPoint> listOfKeypointsObject = keypointsObject.toList();
+        List<KeyPoint> listOfKeypointsScene = keypointsScene.toList();
+        for (int i = 0; i < listOfGoodMatches.size(); i++) {
+            //-- Get the keypoints from the good matches
+            obj.add(listOfKeypointsObject.get(listOfGoodMatches.get(i).queryIdx).pt);
+            scene.add(listOfKeypointsScene.get(listOfGoodMatches.get(i).trainIdx).pt);
+        }
+
+        MatOfPoint2f objMat = new MatOfPoint2f(), sceneMat = new MatOfPoint2f();
+        objMat.fromList(obj);
+        sceneMat.fromList(scene);
+        double ransacReprojThreshold = 3.0;
+        Mat H = Calib3d.findHomography( objMat, sceneMat, Calib3d.RANSAC, ransacReprojThreshold );
+
+        //-- Get the corners from the image_1 ( the object to be "detected" )
+        Mat objCorners = new Mat(4, 1, CvType.CV_32FC2), sceneCorners = new Mat();
+        float[] objCornersData = new float[(int) (objCorners.total() * objCorners.channels())];
+        objCorners.get(0, 0, objCornersData);
+        objCornersData[0] = 0;
+        objCornersData[1] = 0;
+        objCornersData[2] = imgObject.cols();
+        objCornersData[3] = 0;
+        objCornersData[4] = imgObject.cols();
+        objCornersData[5] = imgObject.rows();
+        objCornersData[6] = 0;
+        objCornersData[7] = imgObject.rows();
+        objCorners.put(0, 0, objCornersData);
+
+        Core.perspectiveTransform(objCorners, sceneCorners, H);
+        float[] sceneCornersData = new float[(int) (sceneCorners.total() * sceneCorners.channels())];
+        sceneCorners.get(0, 0, sceneCornersData);
+
+        //-- Draw lines between the corners (the mapped object in the scene - image_2 )
+        Imgproc.line(imgMatches, new Point(sceneCornersData[0] + imgObject.cols(), sceneCornersData[1]),
+                new Point(sceneCornersData[2] + imgObject.cols(), sceneCornersData[3]), new Scalar(0, 255, 0), 4);
+        Imgproc.line(imgMatches, new Point(sceneCornersData[2] + imgObject.cols(), sceneCornersData[3]),
+                new Point(sceneCornersData[4] + imgObject.cols(), sceneCornersData[5]), new Scalar(0, 255, 0), 4);
+        Imgproc.line(imgMatches, new Point(sceneCornersData[4] + imgObject.cols(), sceneCornersData[5]),
+                new Point(sceneCornersData[6] + imgObject.cols(), sceneCornersData[7]), new Scalar(0, 255, 0), 4);
+        Imgproc.line(imgMatches, new Point(sceneCornersData[6] + imgObject.cols(), sceneCornersData[7]),
+                new Point(sceneCornersData[0] + imgObject.cols(), sceneCornersData[1]), new Scalar(0, 255, 0), 4);
+
+        //-- Show detected matches
+        HighGui.imshow("Good Matches & Object detection", imgMatches);
+        HighGui.waitKey(0);
+
+        System.exit(0);
+    }
+}
+
+public class SURFFLANNMatchingHomographyDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new SURFFLANNMatchingHomography().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/highgui/trackbar/AddingImagesTrackbar.java b/C++/opencv-4.7.0/samples/java/tutorial_code/highgui/trackbar/AddingImagesTrackbar.java
new file mode 100644
index 00000000..5eda2198
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/highgui/trackbar/AddingImagesTrackbar.java
@@ -0,0 +1,119 @@
+import java.awt.BorderLayout;
+import java.awt.Container;
+import java.awt.Image;
+
+import javax.swing.BoxLayout;
+import javax.swing.ImageIcon;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+
+public class AddingImagesTrackbar {
+    private static final int ALPHA_SLIDER_MAX = 100;
+    private int alphaVal = 0;
+    private Mat matImgSrc1;
+    private Mat matImgSrc2;
+    private Mat matImgDst = new Mat();
+    private JFrame frame;
+    private JLabel imgLabel;
+
+    public AddingImagesTrackbar(String[] args) {
+        //! [load]
+        String imagePath1 = "../data/LinuxLogo.jpg";
+        String imagePath2 = "../data/WindowsLogo.jpg";
+        if (args.length > 1) {
+            imagePath1 = args[0];
+            imagePath2 = args[1];
+        }
+        matImgSrc1 = Imgcodecs.imread(imagePath1);
+        matImgSrc2 = Imgcodecs.imread(imagePath2);
+        //! [load]
+        if (matImgSrc1.empty()) {
+            System.out.println("Empty image: " + imagePath1);
+            System.exit(0);
+        }
+        if (matImgSrc2.empty()) {
+            System.out.println("Empty image: " + imagePath2);
+            System.exit(0);
+        }
+
+        //! [window]
+        // Create and set up the window.
+        frame = new JFrame("Linear Blend");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // Set up the content pane.
+        Image img = HighGui.toBufferedImage(matImgSrc2);
+        addComponentsToPane(frame.getContentPane(), img);
+        // Use the content pane's default BorderLayout. No need for
+        // setLayout(new BorderLayout());
+        // Display the window.
+        frame.pack();
+        frame.setVisible(true);
+        //! [window]
+    }
+
+    private void addComponentsToPane(Container pane, Image img) {
+        if (!(pane.getLayout() instanceof BorderLayout)) {
+            pane.add(new JLabel("Container doesn't use BorderLayout!"));
+            return;
+        }
+
+        JPanel sliderPanel = new JPanel();
+        sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
+
+        //! [create_trackbar]
+        sliderPanel.add(new JLabel(String.format("Alpha x %d", ALPHA_SLIDER_MAX)));
+        JSlider slider = new JSlider(0, ALPHA_SLIDER_MAX, 0);
+        slider.setMajorTickSpacing(20);
+        slider.setMinorTickSpacing(5);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        //! [create_trackbar]
+        //! [on_trackbar]
+        slider.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JSlider source = (JSlider) e.getSource();
+                alphaVal = source.getValue();
+                update();
+            }
+        });
+        //! [on_trackbar]
+        sliderPanel.add(slider);
+
+        pane.add(sliderPanel, BorderLayout.PAGE_START);
+        imgLabel = new JLabel(new ImageIcon(img));
+        pane.add(imgLabel, BorderLayout.CENTER);
+    }
+
+    private void update() {
+        double alpha = alphaVal / (double) ALPHA_SLIDER_MAX;
+        double beta = 1.0 - alpha;
+        Core.addWeighted(matImgSrc1, alpha, matImgSrc2, beta, 0, matImgDst);
+        Image img = HighGui.toBufferedImage(matImgDst);
+        imgLabel.setIcon(new ImageIcon(img));
+        frame.repaint();
+    }
+
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Schedule a job for the event dispatch thread:
+        // creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new AddingImagesTrackbar(args);
+            }
+        });
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/introduction/documentation/Documentation.java b/C++/opencv-4.7.0/samples/java/tutorial_code/introduction/documentation/Documentation.java
new file mode 100644
index 00000000..f3f90a15
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/introduction/documentation/Documentation.java
@@ -0,0 +1,9 @@
+public class Documentation {
+
+    public static void main (String[] args) {
+
+        //! [hello_world]
+        System.out.println ("Hello World!");
+        //! [hello_world]
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ml/introduction_to_pca/IntroductionToPCADemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ml/introduction_to_pca/IntroductionToPCADemo.java
new file mode 100644
index 00000000..8f07675a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ml/introduction_to_pca/IntroductionToPCADemo.java
@@ -0,0 +1,144 @@
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+
+//This program demonstrates how to use OpenCV PCA to extract the orientation of an object.
+class IntroductionToPCA {
+    private void drawAxis(Mat img, Point p_, Point q_, Scalar colour, float scale) {
+        Point p = new Point(p_.x, p_.y);
+        Point q = new Point(q_.x, q_.y);
+        //! [visualization1]
+        double angle = Math.atan2(p.y - q.y, p.x - q.x); // angle in radians
+        double hypotenuse = Math.sqrt((p.y - q.y) * (p.y - q.y) + (p.x - q.x) * (p.x - q.x));
+
+        // Here we lengthen the arrow by a factor of scale
+        q.x = (int) (p.x - scale * hypotenuse * Math.cos(angle));
+        q.y = (int) (p.y - scale * hypotenuse * Math.sin(angle));
+        Imgproc.line(img, p, q, colour, 1, Imgproc.LINE_AA, 0);
+
+        // create the arrow hooks
+        p.x = (int) (q.x + 9 * Math.cos(angle + Math.PI / 4));
+        p.y = (int) (q.y + 9 * Math.sin(angle + Math.PI / 4));
+        Imgproc.line(img, p, q, colour, 1, Imgproc.LINE_AA, 0);
+
+        p.x = (int) (q.x + 9 * Math.cos(angle - Math.PI / 4));
+        p.y = (int) (q.y + 9 * Math.sin(angle - Math.PI / 4));
+        Imgproc.line(img, p, q, colour, 1, Imgproc.LINE_AA, 0);
+        //! [visualization1]
+    }
+
+    private double getOrientation(MatOfPoint ptsMat, Mat img) {
+        List<Point> pts = ptsMat.toList();
+        //! [pca]
+        // Construct a buffer used by the pca analysis
+        int sz = pts.size();
+        Mat dataPts = new Mat(sz, 2, CvType.CV_64F);
+        double[] dataPtsData = new double[(int) (dataPts.total() * dataPts.channels())];
+        for (int i = 0; i < dataPts.rows(); i++) {
+            dataPtsData[i * dataPts.cols()] = pts.get(i).x;
+            dataPtsData[i * dataPts.cols() + 1] = pts.get(i).y;
+        }
+        dataPts.put(0, 0, dataPtsData);
+
+        // Perform PCA analysis
+        Mat mean = new Mat();
+        Mat eigenvectors = new Mat();
+        Mat eigenvalues = new Mat();
+        Core.PCACompute2(dataPts, mean, eigenvectors, eigenvalues);
+        double[] meanData = new double[(int) (mean.total() * mean.channels())];
+        mean.get(0, 0, meanData);
+
+        // Store the center of the object
+        Point cntr = new Point(meanData[0], meanData[1]);
+
+        // Store the eigenvalues and eigenvectors
+        double[] eigenvectorsData = new double[(int) (eigenvectors.total() * eigenvectors.channels())];
+        double[] eigenvaluesData = new double[(int) (eigenvalues.total() * eigenvalues.channels())];
+        eigenvectors.get(0, 0, eigenvectorsData);
+        eigenvalues.get(0, 0, eigenvaluesData);
+        //! [pca]
+
+        //! [visualization]
+        // Draw the principal components
+        Imgproc.circle(img, cntr, 3, new Scalar(255, 0, 255), 2);
+        Point p1 = new Point(cntr.x + 0.02 * eigenvectorsData[0] * eigenvaluesData[0],
+                cntr.y + 0.02 * eigenvectorsData[1] * eigenvaluesData[0]);
+        Point p2 = new Point(cntr.x - 0.02 * eigenvectorsData[2] * eigenvaluesData[1],
+                cntr.y - 0.02 * eigenvectorsData[3] * eigenvaluesData[1]);
+        drawAxis(img, cntr, p1, new Scalar(0, 255, 0), 1);
+        drawAxis(img, cntr, p2, new Scalar(255, 255, 0), 5);
+
+        double angle = Math.atan2(eigenvectorsData[1], eigenvectorsData[0]); // orientation in radians
+        //! [visualization]
+
+        return angle;
+    }
+
+    public void run(String[] args) {
+        //! [pre-process]
+        // Load image
+        String filename = args.length > 0 ? args[0] : "../data/pca_test1.jpg";
+        Mat src = Imgcodecs.imread(filename);
+
+        // Check if image is loaded successfully
+        if (src.empty()) {
+            System.err.println("Cannot read image: " + filename);
+            System.exit(0);
+        }
+
+        Mat srcOriginal = src.clone();
+        HighGui.imshow("src", srcOriginal);
+
+        // Convert image to grayscale
+        Mat gray = new Mat();
+        Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
+
+        // Convert image to binary
+        Mat bw = new Mat();
+        Imgproc.threshold(gray, bw, 50, 255, Imgproc.THRESH_BINARY | Imgproc.THRESH_OTSU);
+        //! [pre-process]
+
+        //! [contours]
+        // Find all the contours in the thresholded image
+        List<MatOfPoint> contours = new ArrayList<>();
+        Mat hierarchy = new Mat();
+        Imgproc.findContours(bw, contours, hierarchy, Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_NONE);
+
+        for (int i = 0; i < contours.size(); i++) {
+            // Calculate the area of each contour
+            double area = Imgproc.contourArea(contours.get(i));
+            // Ignore contours that are too small or too large
+            if (area < 1e2 || 1e5 < area)
+                continue;
+
+            // Draw each contour only for visualisation purposes
+            Imgproc.drawContours(src, contours, i, new Scalar(0, 0, 255), 2);
+            // Find the orientation of each shape
+            getOrientation(contours.get(i), src);
+        }
+        //! [contours]
+
+        HighGui.imshow("output", src);
+
+        HighGui.waitKey();
+        System.exit(0);
+    }
+}
+
+public class IntroductionToPCADemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new IntroductionToPCA().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ml/introduction_to_svm/IntroductionToSVMDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ml/introduction_to_svm/IntroductionToSVMDemo.java
new file mode 100644
index 00000000..dcff5ff7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ml/introduction_to_svm/IntroductionToSVMDemo.java
@@ -0,0 +1,99 @@
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.TermCriteria;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.ml.Ml;
+import org.opencv.ml.SVM;
+
+public class IntroductionToSVMDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        // Set up training data
+        //! [setup1]
+        int[] labels = { 1, -1, -1, -1 };
+        float[] trainingData = { 501, 10, 255, 10, 501, 255, 10, 501 };
+        //! [setup1]
+        //! [setup2]
+        Mat trainingDataMat = new Mat(4, 2, CvType.CV_32FC1);
+        trainingDataMat.put(0, 0, trainingData);
+        Mat labelsMat = new Mat(4, 1, CvType.CV_32SC1);
+        labelsMat.put(0, 0, labels);
+        //! [setup2]
+
+        // Train the SVM
+        //! [init]
+        SVM svm = SVM.create();
+        svm.setType(SVM.C_SVC);
+        svm.setKernel(SVM.LINEAR);
+        svm.setTermCriteria(new TermCriteria(TermCriteria.MAX_ITER, 100, 1e-6));
+        //! [init]
+        //! [train]
+        svm.train(trainingDataMat, Ml.ROW_SAMPLE, labelsMat);
+        //! [train]
+
+        // Data for visual representation
+        int width = 512, height = 512;
+        Mat image = Mat.zeros(height, width, CvType.CV_8UC3);
+
+        // Show the decision regions given by the SVM
+        //! [show]
+        byte[] imageData = new byte[(int) (image.total() * image.channels())];
+        Mat sampleMat = new Mat(1, 2, CvType.CV_32F);
+        float[] sampleMatData = new float[(int) (sampleMat.total() * sampleMat.channels())];
+        for (int i = 0; i < image.rows(); i++) {
+            for (int j = 0; j < image.cols(); j++) {
+                sampleMatData[0] = j;
+                sampleMatData[1] = i;
+                sampleMat.put(0, 0, sampleMatData);
+                float response = svm.predict(sampleMat);
+
+                if (response == 1) {
+                    imageData[(i * image.cols() + j) * image.channels()] = 0;
+                    imageData[(i * image.cols() + j) * image.channels() + 1] = (byte) 255;
+                    imageData[(i * image.cols() + j) * image.channels() + 2] = 0;
+                } else if (response == -1) {
+                    imageData[(i * image.cols() + j) * image.channels()] = (byte) 255;
+                    imageData[(i * image.cols() + j) * image.channels() + 1] = 0;
+                    imageData[(i * image.cols() + j) * image.channels() + 2] = 0;
+                }
+            }
+        }
+        image.put(0, 0, imageData);
+        //! [show]
+
+        // Show the training data
+        //! [show_data]
+        int thickness = -1;
+        int lineType = Imgproc.LINE_8;
+        Imgproc.circle(image, new Point(501, 10), 5, new Scalar(0, 0, 0), thickness, lineType, 0);
+        Imgproc.circle(image, new Point(255, 10), 5, new Scalar(255, 255, 255), thickness, lineType, 0);
+        Imgproc.circle(image, new Point(501, 255), 5, new Scalar(255, 255, 255), thickness, lineType, 0);
+        Imgproc.circle(image, new Point(10, 501), 5, new Scalar(255, 255, 255), thickness, lineType, 0);
+        //! [show_data]
+
+        // Show support vectors
+        //! [show_vectors]
+        thickness = 2;
+        Mat sv = svm.getUncompressedSupportVectors();
+        float[] svData = new float[(int) (sv.total() * sv.channels())];
+        sv.get(0, 0, svData);
+        for (int i = 0; i < sv.rows(); ++i) {
+            Imgproc.circle(image, new Point(svData[i * sv.cols()], svData[i * sv.cols() + 1]), 6,
+                    new Scalar(128, 128, 128), thickness, lineType, 0);
+        }
+        //! [show_vectors]
+
+        Imgcodecs.imwrite("result.png", image); // save the image
+
+        HighGui.imshow("SVM Simple Example", image); // show it to the user
+        HighGui.waitKey();
+        System.exit(0);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/ml/non_linear_svms/NonLinearSVMsDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/ml/non_linear_svms/NonLinearSVMsDemo.java
new file mode 100644
index 00000000..b2b40d15
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/ml/non_linear_svms/NonLinearSVMsDemo.java
@@ -0,0 +1,186 @@
+import java.util.Random;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.TermCriteria;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.ml.Ml;
+import org.opencv.ml.SVM;
+
+public class NonLinearSVMsDemo {
+    public static final int NTRAINING_SAMPLES = 100;
+    public static final float FRAC_LINEAR_SEP = 0.9f;
+
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        System.out.println("\n--------------------------------------------------------------------------");
+        System.out.println("This program shows Support Vector Machines for Non-Linearly Separable Data. ");
+        System.out.println("--------------------------------------------------------------------------\n");
+
+        // Data for visual representation
+        int width = 512, height = 512;
+        Mat I = Mat.zeros(height, width, CvType.CV_8UC3);
+
+        // --------------------- 1. Set up training data randomly---------------------------------------
+        Mat trainData = new Mat(2 * NTRAINING_SAMPLES, 2, CvType.CV_32F);
+        Mat labels = new Mat(2 * NTRAINING_SAMPLES, 1, CvType.CV_32S);
+
+        Random rng = new Random(100); // Random value generation class
+
+        // Set up the linearly separable part of the training data
+        int nLinearSamples = (int) (FRAC_LINEAR_SEP * NTRAINING_SAMPLES);
+
+        //! [setup1]
+        // Generate random points for the class 1
+        Mat trainClass = trainData.rowRange(0, nLinearSamples);
+        // The x coordinate of the points is in [0, 0.4)
+        Mat c = trainClass.colRange(0, 1);
+        float[] cData = new float[(int) (c.total() * c.channels())];
+        double[] cDataDbl = rng.doubles(cData.length, 0, 0.4f * width).toArray();
+        for (int i = 0; i < cData.length; i++) {
+            cData[i] = (float) cDataDbl[i];
+        }
+        c.put(0, 0, cData);
+        // The y coordinate of the points is in [0, 1)
+        c = trainClass.colRange(1, 2);
+        cData = new float[(int) (c.total() * c.channels())];
+        cDataDbl = rng.doubles(cData.length, 0, height).toArray();
+        for (int i = 0; i < cData.length; i++) {
+            cData[i] = (float) cDataDbl[i];
+        }
+        c.put(0, 0, cData);
+
+        // Generate random points for the class 2
+        trainClass = trainData.rowRange(2 * NTRAINING_SAMPLES - nLinearSamples, 2 * NTRAINING_SAMPLES);
+        // The x coordinate of the points is in [0.6, 1]
+        c = trainClass.colRange(0, 1);
+        cData = new float[(int) (c.total() * c.channels())];
+        cDataDbl = rng.doubles(cData.length, 0.6 * width, width).toArray();
+        for (int i = 0; i < cData.length; i++) {
+            cData[i] = (float) cDataDbl[i];
+        }
+        c.put(0, 0, cData);
+        // The y coordinate of the points is in [0, 1)
+        c = trainClass.colRange(1, 2);
+        cData = new float[(int) (c.total() * c.channels())];
+        cDataDbl = rng.doubles(cData.length, 0, height).toArray();
+        for (int i = 0; i < cData.length; i++) {
+            cData[i] = (float) cDataDbl[i];
+        }
+        c.put(0, 0, cData);
+        //! [setup1]
+
+        // ------------------ Set up the non-linearly separable part of the training data ---------------
+        //! [setup2]
+        // Generate random points for the classes 1 and 2
+        trainClass = trainData.rowRange(nLinearSamples, 2 * NTRAINING_SAMPLES - nLinearSamples);
+        // The x coordinate of the points is in [0.4, 0.6)
+        c = trainClass.colRange(0, 1);
+        cData = new float[(int) (c.total() * c.channels())];
+        cDataDbl = rng.doubles(cData.length, 0.4 * width, 0.6 * width).toArray();
+        for (int i = 0; i < cData.length; i++) {
+            cData[i] = (float) cDataDbl[i];
+        }
+        c.put(0, 0, cData);
+        // The y coordinate of the points is in [0, 1)
+        c = trainClass.colRange(1, 2);
+        cData = new float[(int) (c.total() * c.channels())];
+        cDataDbl = rng.doubles(cData.length, 0, height).toArray();
+        for (int i = 0; i < cData.length; i++) {
+            cData[i] = (float) cDataDbl[i];
+        }
+        c.put(0, 0, cData);
+        //! [setup2]
+
+        // ------------------------- Set up the labels for the classes---------------------------------
+        labels.rowRange(0, NTRAINING_SAMPLES).setTo(new Scalar(1)); // Class 1
+        labels.rowRange(NTRAINING_SAMPLES, 2 * NTRAINING_SAMPLES).setTo(new Scalar(2)); // Class 2
+
+        // ------------------------ 2. Set up the support vector machines parameters--------------------
+        System.out.println("Starting training process");
+        //! [init]
+        SVM svm = SVM.create();
+        svm.setType(SVM.C_SVC);
+        svm.setC(0.1);
+        svm.setKernel(SVM.LINEAR);
+        svm.setTermCriteria(new TermCriteria(TermCriteria.MAX_ITER, (int) 1e7, 1e-6));
+        //! [init]
+
+        // ------------------------ 3. Train the svm----------------------------------------------------
+        //! [train]
+        svm.train(trainData, Ml.ROW_SAMPLE, labels);
+        //! [train]
+        System.out.println("Finished training process");
+
+        // ------------------------ 4. Show the decision regions----------------------------------------
+        //! [show]
+        byte[] IData = new byte[(int) (I.total() * I.channels())];
+        Mat sampleMat = new Mat(1, 2, CvType.CV_32F);
+        float[] sampleMatData = new float[(int) (sampleMat.total() * sampleMat.channels())];
+        for (int i = 0; i < I.rows(); i++) {
+            for (int j = 0; j < I.cols(); j++) {
+                sampleMatData[0] = j;
+                sampleMatData[1] = i;
+                sampleMat.put(0, 0, sampleMatData);
+                float response = svm.predict(sampleMat);
+
+                if (response == 1) {
+                    IData[(i * I.cols() + j) * I.channels()] = 0;
+                    IData[(i * I.cols() + j) * I.channels() + 1] = 100;
+                    IData[(i * I.cols() + j) * I.channels() + 2] = 0;
+                } else if (response == 2) {
+                    IData[(i * I.cols() + j) * I.channels()] = 100;
+                    IData[(i * I.cols() + j) * I.channels() + 1] = 0;
+                    IData[(i * I.cols() + j) * I.channels() + 2] = 0;
+                }
+            }
+        }
+        I.put(0, 0, IData);
+        //! [show]
+
+        // ----------------------- 5. Show the training data--------------------------------------------
+        //! [show_data]
+        int thick = -1;
+        int lineType = Imgproc.LINE_8;
+        float px, py;
+        // Class 1
+        float[] trainDataData = new float[(int) (trainData.total() * trainData.channels())];
+        trainData.get(0, 0, trainDataData);
+        for (int i = 0; i < NTRAINING_SAMPLES; i++) {
+            px = trainDataData[i * trainData.cols()];
+            py = trainDataData[i * trainData.cols() + 1];
+            Imgproc.circle(I, new Point(px, py), 3, new Scalar(0, 255, 0), thick, lineType, 0);
+        }
+        // Class 2
+        for (int i = NTRAINING_SAMPLES; i < 2 * NTRAINING_SAMPLES; ++i) {
+            px = trainDataData[i * trainData.cols()];
+            py = trainDataData[i * trainData.cols() + 1];
+            Imgproc.circle(I, new Point(px, py), 3, new Scalar(255, 0, 0), thick, lineType, 0);
+        }
+        //! [show_data]
+
+        // ------------------------- 6. Show support vectors--------------------------------------------
+        //! [show_vectors]
+        thick = 2;
+        Mat sv = svm.getUncompressedSupportVectors();
+        float[] svData = new float[(int) (sv.total() * sv.channels())];
+        sv.get(0, 0, svData);
+        for (int i = 0; i < sv.rows(); i++) {
+            Imgproc.circle(I, new Point(svData[i * sv.cols()], svData[i * sv.cols() + 1]), 6, new Scalar(128, 128, 128),
+                    thick, lineType, 0);
+        }
+        //! [show_vectors]
+
+        Imgcodecs.imwrite("result.png", I); // save the Image
+        HighGui.imshow("SVM for Non-Linear Training Data", I); // show it to the user
+        HighGui.waitKey();
+        System.exit(0);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/objectDetection/cascade_classifier/ObjectDetectionDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/objectDetection/cascade_classifier/ObjectDetectionDemo.java
new file mode 100644
index 00000000..33e0b515
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/objectDetection/cascade_classifier/ObjectDetectionDemo.java
@@ -0,0 +1,98 @@
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfRect;
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.objdetect.CascadeClassifier;
+import org.opencv.videoio.VideoCapture;
+
+class ObjectDetection {
+    public void detectAndDisplay(Mat frame, CascadeClassifier faceCascade, CascadeClassifier eyesCascade) {
+        Mat frameGray = new Mat();
+        Imgproc.cvtColor(frame, frameGray, Imgproc.COLOR_BGR2GRAY);
+        Imgproc.equalizeHist(frameGray, frameGray);
+
+        // -- Detect faces
+        MatOfRect faces = new MatOfRect();
+        faceCascade.detectMultiScale(frameGray, faces);
+
+        List<Rect> listOfFaces = faces.toList();
+        for (Rect face : listOfFaces) {
+            Point center = new Point(face.x + face.width / 2, face.y + face.height / 2);
+            Imgproc.ellipse(frame, center, new Size(face.width / 2, face.height / 2), 0, 0, 360,
+                    new Scalar(255, 0, 255));
+
+            Mat faceROI = frameGray.submat(face);
+
+            // -- In each face, detect eyes
+            MatOfRect eyes = new MatOfRect();
+            eyesCascade.detectMultiScale(faceROI, eyes);
+
+            List<Rect> listOfEyes = eyes.toList();
+            for (Rect eye : listOfEyes) {
+                Point eyeCenter = new Point(face.x + eye.x + eye.width / 2, face.y + eye.y + eye.height / 2);
+                int radius = (int) Math.round((eye.width + eye.height) * 0.25);
+                Imgproc.circle(frame, eyeCenter, radius, new Scalar(255, 0, 0), 4);
+            }
+        }
+
+        //-- Show what you got
+        HighGui.imshow("Capture - Face detection", frame );
+    }
+
+    public void run(String[] args) {
+        String filenameFaceCascade = args.length > 2 ? args[0] : "../../data/haarcascades/haarcascade_frontalface_alt.xml";
+        String filenameEyesCascade = args.length > 2 ? args[1] : "../../data/haarcascades/haarcascade_eye_tree_eyeglasses.xml";
+        int cameraDevice = args.length > 2 ? Integer.parseInt(args[2]) : 0;
+
+        CascadeClassifier faceCascade = new CascadeClassifier();
+        CascadeClassifier eyesCascade = new CascadeClassifier();
+
+        if (!faceCascade.load(filenameFaceCascade)) {
+            System.err.println("--(!)Error loading face cascade: " + filenameFaceCascade);
+            System.exit(0);
+        }
+        if (!eyesCascade.load(filenameEyesCascade)) {
+            System.err.println("--(!)Error loading eyes cascade: " + filenameEyesCascade);
+            System.exit(0);
+        }
+
+        VideoCapture capture = new VideoCapture(cameraDevice);
+        if (!capture.isOpened()) {
+            System.err.println("--(!)Error opening video capture");
+            System.exit(0);
+        }
+
+        Mat frame = new Mat();
+        while (capture.read(frame)) {
+            if (frame.empty()) {
+                System.err.println("--(!) No captured frame -- Break!");
+                break;
+            }
+
+            //-- 3. Apply the classifier to the frame
+            detectAndDisplay(frame, faceCascade, eyesCascade);
+
+            if (HighGui.waitKey(10) == 27) {
+                break;// escape
+            }
+        }
+
+        System.exit(0);
+    }
+}
+
+public class ObjectDetectionDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new ObjectDetection().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/photo/hdr_imaging/HDRImagingDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/photo/hdr_imaging/HDRImagingDemo.java
new file mode 100644
index 00000000..c6fddfb7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/photo/hdr_imaging/HDRImagingDemo.java
@@ -0,0 +1,103 @@
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Scalar;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.photo.CalibrateDebevec;
+import org.opencv.photo.MergeDebevec;
+import org.opencv.photo.MergeMertens;
+import org.opencv.photo.Photo;
+import org.opencv.photo.Tonemap;
+
+class HDRImaging {
+    public void loadExposureSeq(String path, List<Mat> images, List<Float> times) {
+        path += "/";
+
+        List<String> lines;
+        try {
+            lines = Files.readAllLines(Paths.get(path + "list.txt"));
+
+            for (String line : lines) {
+                String[] splitStr = line.split("\\s+");
+                if (splitStr.length == 2) {
+                    String name = splitStr[0];
+                    Mat img = Imgcodecs.imread(path + name);
+                    images.add(img);
+                    float val = Float.parseFloat(splitStr[1]);
+                    times.add(1/ val);
+                }
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void run(String[] args) {
+        String path = args.length > 0 ? args[0] : "";
+        if (path.isEmpty()) {
+            System.out.println("Path is empty. Use the directory that contains images and exposure times.");
+            System.exit(0);
+        }
+
+        //! [Load images and exposure times]
+        List<Mat> images = new ArrayList<>();
+        List<Float> times = new ArrayList<>();
+        loadExposureSeq(path, images, times);
+        //! [Load images and exposure times]
+
+        //! [Estimate camera response]
+        Mat response = new Mat();
+        CalibrateDebevec calibrate = Photo.createCalibrateDebevec();
+        Mat matTimes = new Mat(times.size(), 1, CvType.CV_32F);
+        float[] arrayTimes = new float[(int) (matTimes.total()*matTimes.channels())];
+        for (int i = 0; i < times.size(); i++) {
+            arrayTimes[i] = times.get(i);
+        }
+        matTimes.put(0, 0, arrayTimes);
+        calibrate.process(images, response, matTimes);
+        //! [Estimate camera response]
+
+        //! [Make HDR image]
+        Mat hdr = new Mat();
+        MergeDebevec mergeDebevec = Photo.createMergeDebevec();
+        mergeDebevec.process(images, hdr, matTimes);
+        //! [Make HDR image]
+
+        //! [Tonemap HDR image]
+        Mat ldr = new Mat();
+        Tonemap tonemap = Photo.createTonemap(2.2f);
+        tonemap.process(hdr, ldr);
+        //! [Tonemap HDR image]
+
+        //! [Perform exposure fusion]
+        Mat fusion = new Mat();
+        MergeMertens mergeMertens = Photo.createMergeMertens();
+        mergeMertens.process(images, fusion);
+        //! [Perform exposure fusion]
+
+        //! [Write results]
+        Core.multiply(fusion, new Scalar(255,255,255), fusion);
+        Core.multiply(ldr, new Scalar(255,255,255), ldr);
+        Imgcodecs.imwrite("fusion.png", fusion);
+        Imgcodecs.imwrite("ldr.png", ldr);
+        Imgcodecs.imwrite("hdr.hdr", hdr);
+        //! [Write results]
+
+        System.exit(0);
+    }
+}
+
+public class HDRImagingDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new HDRImaging().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/video/background_subtraction/BackgroundSubtractionDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/video/background_subtraction/BackgroundSubtractionDemo.java
new file mode 100644
index 00000000..fe9b69ea
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/video/background_subtraction/BackgroundSubtractionDemo.java
@@ -0,0 +1,79 @@
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.video.BackgroundSubtractor;
+import org.opencv.video.Video;
+import org.opencv.videoio.VideoCapture;
+import org.opencv.videoio.Videoio;
+
+class BackgroundSubtraction {
+    public void run(String[] args) {
+        String input = args.length > 0 ? args[0] : "../data/vtest.avi";
+        boolean useMOG2 = args.length > 1 ? args[1] == "MOG2" : true;
+
+        //! [create]
+        BackgroundSubtractor backSub;
+        if (useMOG2) {
+            backSub = Video.createBackgroundSubtractorMOG2();
+        } else {
+            backSub = Video.createBackgroundSubtractorKNN();
+        }
+        //! [create]
+
+        //! [capture]
+        VideoCapture capture = new VideoCapture(input);
+        if (!capture.isOpened()) {
+            System.err.println("Unable to open: " + input);
+            System.exit(0);
+        }
+        //! [capture]
+
+        Mat frame = new Mat(), fgMask = new Mat();
+        while (true) {
+            capture.read(frame);
+            if (frame.empty()) {
+                break;
+            }
+
+            //! [apply]
+            // update the background model
+            backSub.apply(frame, fgMask);
+            //! [apply]
+
+            //! [display_frame_number]
+            // get the frame number and write it on the current frame
+            Imgproc.rectangle(frame, new Point(10, 2), new Point(100, 20), new Scalar(255, 255, 255), -1);
+            String frameNumberString = String.format("%d", (int)capture.get(Videoio.CAP_PROP_POS_FRAMES));
+            Imgproc.putText(frame, frameNumberString, new Point(15, 15), Core.FONT_HERSHEY_SIMPLEX, 0.5,
+                    new Scalar(0, 0, 0));
+            //! [display_frame_number]
+
+            //! [show]
+            // show the current frame and the fg masks
+            HighGui.imshow("Frame", frame);
+            HighGui.imshow("FG Mask", fgMask);
+            //! [show]
+
+            // get the input from the keyboard
+            int keyboard = HighGui.waitKey(30);
+            if (keyboard == 'q' || keyboard == 27) {
+                break;
+            }
+        }
+
+        HighGui.waitKey();
+        System.exit(0);
+    }
+}
+
+public class BackgroundSubtractionDemo {
+    public static void main(String[] args) {
+        // Load the native OpenCV library
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+
+        new BackgroundSubtraction().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/video/meanshift/CamshiftDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/video/meanshift/CamshiftDemo.java
new file mode 100644
index 00000000..701851aa
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/video/meanshift/CamshiftDemo.java
@@ -0,0 +1,75 @@
+import java.util.Arrays;
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.video.Video;
+import org.opencv.videoio.VideoCapture;
+
+
+class Camshift {
+    public void run(String[] args) {
+        String filename = args[0];
+        VideoCapture capture = new VideoCapture(filename);
+        if (!capture.isOpened()) {
+            System.out.println("Unable to open file!");
+            System.exit(-1);
+        }
+
+        Mat frame = new Mat(), hsv_roi = new Mat(), mask = new Mat(), roi;
+
+        // take the first frame of the video
+        capture.read(frame);
+
+        //setup initial location of window
+        Rect track_window = new Rect(300, 200, 100, 50);
+
+        // set up the ROI for tracking
+        roi = new Mat(frame, track_window);
+        Imgproc.cvtColor(roi, hsv_roi, Imgproc.COLOR_BGR2HSV);
+        Core.inRange(hsv_roi, new Scalar(0, 60, 32), new Scalar(180, 255, 255), mask);
+
+        MatOfFloat range = new MatOfFloat(0, 256);
+        Mat roi_hist = new Mat();
+        MatOfInt histSize = new MatOfInt(180);
+        MatOfInt channels = new MatOfInt(0);
+        Imgproc.calcHist(Arrays.asList(hsv_roi), channels, mask, roi_hist, histSize, range);
+        Core.normalize(roi_hist, roi_hist, 0, 255, Core.NORM_MINMAX);
+
+        // Setup the termination criteria, either 10 iteration or move by at least 1 pt
+        TermCriteria term_crit = new TermCriteria(TermCriteria.EPS | TermCriteria.COUNT, 10, 1);
+
+        while (true) {
+            Mat hsv = new Mat() , dst = new Mat();
+            capture.read(frame);
+            if (frame.empty()) {
+                break;
+            }
+            Imgproc.cvtColor(frame, hsv, Imgproc.COLOR_BGR2HSV);
+            Imgproc.calcBackProject(Arrays.asList(hsv), channels, roi_hist, dst, range, 1);
+
+            // apply camshift to get the new location
+            RotatedRect rot_rect = Video.CamShift(dst, track_window, term_crit);
+
+            // Draw it on image
+            Point[] points = new Point[4];
+            rot_rect.points(points);
+            for (int i = 0; i < 4 ;i++) {
+                Imgproc.line(frame, points[i], points[(i+1)%4], new Scalar(255, 0, 0),2);
+            }
+
+            HighGui.imshow("img2", frame);
+            int keyboard = HighGui.waitKey(30);
+            if (keyboard == 'q'|| keyboard == 27) {
+                break;
+            }
+        }
+        System.exit(0);
+    }
+}
+
+public class CamshiftDemo {
+    public static void main(String[] args) {
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new Camshift().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/video/meanshift/MeanshiftDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/video/meanshift/MeanshiftDemo.java
new file mode 100644
index 00000000..f07adb5b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/video/meanshift/MeanshiftDemo.java
@@ -0,0 +1,70 @@
+import java.util.Arrays;
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.video.Video;
+import org.opencv.videoio.VideoCapture;
+
+
+class Meanshift {
+    public void run(String[] args) {
+        String filename = args[0];
+        VideoCapture capture = new VideoCapture(filename);
+        if (!capture.isOpened()) {
+            System.out.println("Unable to open file!");
+            System.exit(-1);
+        }
+        Mat frame = new Mat(), hsv_roi = new Mat(), mask = new Mat(), roi;
+
+        // take the first frame of the video
+        capture.read(frame);
+
+        //setup initial location of window
+        Rect track_window = new Rect(300, 200, 100, 50);
+
+        // setup initial location of window
+        roi = new Mat(frame, track_window);
+        Imgproc.cvtColor(roi, hsv_roi, Imgproc.COLOR_BGR2HSV);
+        Core.inRange(hsv_roi, new Scalar(0, 60, 32), new Scalar(180, 255, 255), mask);
+
+        MatOfFloat range = new MatOfFloat(0, 256);
+        Mat roi_hist = new Mat();
+        MatOfInt histSize = new MatOfInt(180);
+        MatOfInt channels = new MatOfInt(0);
+        Imgproc.calcHist(Arrays.asList(hsv_roi), channels, mask, roi_hist, histSize, range);
+        Core.normalize(roi_hist, roi_hist, 0, 255, Core.NORM_MINMAX);
+
+        // Setup the termination criteria, either 10 iteration or move by at least 1 pt
+        TermCriteria term_crit = new TermCriteria(TermCriteria.EPS | TermCriteria.COUNT, 10, 1);
+
+        while (true) {
+            Mat hsv = new Mat() , dst = new Mat();
+            capture.read(frame);
+            if (frame.empty()) {
+                break;
+            }
+            Imgproc.cvtColor(frame, hsv, Imgproc.COLOR_BGR2HSV);
+            Imgproc.calcBackProject(Arrays.asList(hsv), channels, roi_hist, dst, range, 1);
+
+            // apply meanshift to get the new location
+            Video.meanShift(dst, track_window, term_crit);
+
+            // Draw it on image
+            Imgproc.rectangle(frame, track_window, new Scalar(255, 0, 0), 2);
+            HighGui.imshow("img2", frame);
+
+            int keyboard = HighGui.waitKey(30);
+            if (keyboard == 'q' || keyboard == 27) {
+                break;
+            }
+        }
+        System.exit(0);
+    }
+}
+
+public class MeanshiftDemo {
+    public static void main(String[] args) {
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new Meanshift().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/video/optical_flow/OpticalFlowDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/video/optical_flow/OpticalFlowDemo.java
new file mode 100644
index 00000000..cf9f6788
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/video/optical_flow/OpticalFlowDemo.java
@@ -0,0 +1,96 @@
+import java.util.ArrayList;
+import java.util.Random;
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.video.Video;
+import org.opencv.videoio.VideoCapture;
+
+class OptFlow {
+    public void run(String[] args) {
+        String filename = args[0];
+        VideoCapture capture = new VideoCapture(filename);
+        if (!capture.isOpened()) {
+            System.out.println("Unable to open this file");
+            System.exit(-1);
+        }
+
+
+        // Create some random colors
+        Scalar[] colors = new Scalar[100];
+        Random rng = new Random();
+        for (int i = 0 ; i < 100 ; i++) {
+            int r = rng.nextInt(256);
+            int g = rng.nextInt(256);
+            int b = rng.nextInt(256);
+            colors[i] = new Scalar(r, g, b);
+        }
+
+        Mat old_frame = new Mat() , old_gray = new Mat();
+
+        // Since the function Imgproc.goodFeaturesToTrack requires MatofPoint
+        // therefore first p0MatofPoint is passed to the function and then converted to MatOfPoint2f
+        MatOfPoint p0MatofPoint = new MatOfPoint();
+        capture.read(old_frame);
+        Imgproc.cvtColor(old_frame, old_gray, Imgproc.COLOR_BGR2GRAY);
+        Imgproc.goodFeaturesToTrack(old_gray, p0MatofPoint,100,0.3,7, new Mat(),7,false,0.04);
+
+        MatOfPoint2f p0 = new MatOfPoint2f(p0MatofPoint.toArray()) , p1 = new MatOfPoint2f();
+
+        // Create a mask image for drawing purposes
+        Mat mask = Mat.zeros(old_frame.size(), old_frame.type());
+
+        while (true) {
+            Mat frame = new Mat(), frame_gray = new Mat();
+            capture.read(frame);
+            if (frame.empty()) {
+                break;
+            }
+
+            Imgproc.cvtColor(frame, frame_gray, Imgproc.COLOR_BGR2GRAY);
+
+            // calculate optical flow
+            MatOfByte status = new MatOfByte();
+            MatOfFloat err = new MatOfFloat();
+            TermCriteria criteria = new TermCriteria(TermCriteria.COUNT + TermCriteria.EPS,10,0.03);
+            Video.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, p1, status, err, new Size(15,15),2, criteria);
+
+            byte StatusArr[] = status.toArray();
+            Point p0Arr[] = p0.toArray();
+            Point p1Arr[] = p1.toArray();
+            ArrayList<Point> good_new = new ArrayList<>();
+
+            for (int i = 0; i<StatusArr.length ; i++ ) {
+                if (StatusArr[i] == 1) {
+                    good_new.add(p1Arr[i]);
+                    Imgproc.line(mask, p1Arr[i], p0Arr[i], colors[i],2);
+                    Imgproc.circle(frame, p1Arr[i],5, colors[i],-1);
+                }
+            }
+
+            Mat img = new Mat();
+            Core.add(frame, mask, img);
+
+            HighGui.imshow("Frame", img);
+
+            int keyboard = HighGui.waitKey(30);
+            if (keyboard == 'q' || keyboard == 27) {
+                break;
+            }
+
+            // Now update the previous frame and previous points
+            old_gray = frame_gray.clone();
+            Point[] good_new_arr = new Point[good_new.size()];
+            good_new_arr = good_new.toArray(good_new_arr);
+            p0 = new MatOfPoint2f(good_new_arr);
+        }
+        System.exit(0);
+    }
+}
+
+public class OpticalFlowDemo {
+    public static void main(String[] args) {
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new OptFlow().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/java/tutorial_code/video/optical_flow/OpticalFlowDenseDemo.java b/C++/opencv-4.7.0/samples/java/tutorial_code/video/optical_flow/OpticalFlowDenseDemo.java
new file mode 100644
index 00000000..979dbf65
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/java/tutorial_code/video/optical_flow/OpticalFlowDenseDemo.java
@@ -0,0 +1,72 @@
+import java.util.ArrayList;
+import org.opencv.core.*;
+import org.opencv.highgui.HighGui;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.video.Video;
+import org.opencv.videoio.VideoCapture;
+
+
+class OptFlowDense {
+    public void run(String[] args) {
+        String filename = args[0];
+        VideoCapture capture = new VideoCapture(filename);
+        if (!capture.isOpened()) {
+            //error in opening the video input
+            System.out.println("Unable to open file!");
+            System.exit(-1);
+        }
+
+        Mat frame1 = new Mat() , prvs = new Mat();
+        capture.read(frame1);
+        Imgproc.cvtColor(frame1, prvs, Imgproc.COLOR_BGR2GRAY);
+
+        while (true) {
+            Mat frame2 = new Mat(), next = new Mat();
+            capture.read(frame2);
+            if (frame2.empty()) {
+                break;
+            }
+            Imgproc.cvtColor(frame2, next, Imgproc.COLOR_BGR2GRAY);
+
+            Mat flow = new Mat(prvs.size(), CvType.CV_32FC2);
+            Video.calcOpticalFlowFarneback(prvs, next, flow,0.5,3,15,3,5,1.2,0);
+
+            // visualization
+            ArrayList<Mat> flow_parts = new ArrayList<>(2);
+            Core.split(flow, flow_parts);
+            Mat magnitude = new Mat(), angle = new Mat(), magn_norm = new Mat();
+            Core.cartToPolar(flow_parts.get(0), flow_parts.get(1), magnitude, angle,true);
+            Core.normalize(magnitude, magn_norm,0.0,1.0, Core.NORM_MINMAX);
+            float factor = (float) ((1.0/360.0)*(180.0/255.0));
+            Mat new_angle = new Mat();
+            Core.multiply(angle, new Scalar(factor), new_angle);
+
+            //build hsv image
+            ArrayList<Mat> _hsv = new ArrayList<>() ;
+            Mat hsv = new Mat(), hsv8 = new Mat(), bgr = new Mat();
+
+            _hsv.add(new_angle);
+            _hsv.add(Mat.ones(angle.size(), CvType.CV_32F));
+            _hsv.add(magn_norm);
+            Core.merge(_hsv, hsv);
+            hsv.convertTo(hsv8, CvType.CV_8U, 255.0);
+            Imgproc.cvtColor(hsv8, bgr, Imgproc.COLOR_HSV2BGR);
+
+            HighGui.imshow("frame2", bgr);
+
+            int keyboard = HighGui.waitKey(30);
+            if (keyboard == 'q' || keyboard == 27) {
+                break;
+            }
+            prvs = next;
+        }
+        System.exit(0);
+    }
+}
+
+public class OpticalFlowDenseDemo {
+    public static void main(String[] args) {
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        new OptFlowDense().run(args);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/opencl/CMakeLists.txt b/C++/opencv-4.7.0/samples/opencl/CMakeLists.txt
new file mode 100644
index 00000000..d71e866f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/opencl/CMakeLists.txt
@@ -0,0 +1,38 @@
+ocv_install_example_src(opencl *.cpp *.hpp CMakeLists.txt)
+
+# cmake 3.1 needed for find_package(OpenCL)
+if(CMAKE_VERSION VERSION_LESS "3.1")
+  message(STATUS "OpenCL samples require CMakes 3.1+")
+  return()
+endif()
+
+set(OPENCV_OPENCL_SAMPLES_REQUIRED_DEPS
+  opencv_core
+  opencv_imgproc
+  opencv_video
+  opencv_imgcodecs
+  opencv_videoio
+  opencv_highgui)
+ocv_check_dependencies(${OPENCV_OPENCL_SAMPLES_REQUIRED_DEPS})
+
+if(NOT BUILD_EXAMPLES OR NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+find_package(OpenCL 1.2 QUIET)
+if(NOT OpenCL_FOUND)
+  message(STATUS "OpenCL samples are skipped: OpenCL SDK is required")
+  return()
+endif()
+
+project(opencl_samples)
+ocv_include_modules_recurse(${OPENCV_OPENCL_SAMPLES_REQUIRED_DEPS})
+ocv_include_directories(${OpenCL_INCLUDE_DIR})
+file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+foreach(sample_filename ${all_samples})
+  ocv_define_sample(tgt ${sample_filename} opencl)
+  ocv_target_link_libraries(${tgt} PRIVATE
+    ${OPENCV_LINKER_LIBS}
+    ${OPENCV_OPENCL_SAMPLES_REQUIRED_DEPS}
+    ${OpenCL_LIBRARY})
+endforeach()
diff --git a/C++/opencv-4.7.0/samples/opencl/opencl-opencv-interop.cpp b/C++/opencv-4.7.0/samples/opencl/opencl-opencv-interop.cpp
new file mode 100644
index 00000000..3d6fec09
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/opencl/opencl-opencv-interop.cpp
@@ -0,0 +1,1010 @@
+/*
+// The example of interoperability between OpenCL and OpenCV.
+// This will loop through frames of video either from input media file
+// or camera device and do processing of these data in OpenCL and then
+// in OpenCV. In OpenCL it does inversion of pixels in left half of frame and
+// in OpenCV it does blurring in the right half of frame.
+*/
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+
+#define CL_USE_DEPRECATED_OPENCL_1_1_APIS
+#define CL_USE_DEPRECATED_OPENCL_1_2_APIS
+#define CL_USE_DEPRECATED_OPENCL_2_0_APIS // eliminate build warning
+#define CL_TARGET_OPENCL_VERSION 200  // 2.0
+
+#ifdef __APPLE__
+#define CL_SILENCE_DEPRECATION
+#include <OpenCL/cl.h>
+#else
+#include <CL/cl.h>
+#endif
+
+#include <opencv2/core/ocl.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/video.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+
+
+using namespace std;
+using namespace cv;
+
+namespace opencl {
+
+class PlatformInfo
+{
+public:
+    PlatformInfo()
+    {}
+
+    ~PlatformInfo()
+    {}
+
+    cl_int QueryInfo(cl_platform_id id)
+    {
+        query_param(id, CL_PLATFORM_PROFILE, m_profile);
+        query_param(id, CL_PLATFORM_VERSION, m_version);
+        query_param(id, CL_PLATFORM_NAME, m_name);
+        query_param(id, CL_PLATFORM_VENDOR, m_vendor);
+        query_param(id, CL_PLATFORM_EXTENSIONS, m_extensions);
+        return CL_SUCCESS;
+    }
+
+    std::string Profile()    { return m_profile; }
+    std::string Version()    { return m_version; }
+    std::string Name()       { return m_name; }
+    std::string Vendor()     { return m_vendor; }
+    std::string Extensions() { return m_extensions; }
+
+private:
+    cl_int query_param(cl_platform_id id, cl_platform_info param, std::string& paramStr)
+    {
+        cl_int res;
+
+        size_t psize;
+        cv::AutoBuffer<char> buf;
+
+        res = clGetPlatformInfo(id, param, 0, 0, &psize);
+        if (CL_SUCCESS != res)
+            throw std::runtime_error(std::string("clGetPlatformInfo failed"));
+
+        buf.resize(psize);
+        res = clGetPlatformInfo(id, param, psize, buf, 0);
+        if (CL_SUCCESS != res)
+            throw std::runtime_error(std::string("clGetPlatformInfo failed"));
+
+        // just in case, ensure trailing zero for ASCIIZ string
+        buf[psize] = 0;
+
+        paramStr = buf;
+
+        return CL_SUCCESS;
+    }
+
+private:
+    std::string m_profile;
+    std::string m_version;
+    std::string m_name;
+    std::string m_vendor;
+    std::string m_extensions;
+};
+
+
+class DeviceInfo
+{
+public:
+    DeviceInfo()
+    {}
+
+    ~DeviceInfo()
+    {}
+
+    cl_int QueryInfo(cl_device_id id)
+    {
+        query_param(id, CL_DEVICE_TYPE, m_type);
+        query_param(id, CL_DEVICE_VENDOR_ID, m_vendor_id);
+        query_param(id, CL_DEVICE_MAX_COMPUTE_UNITS, m_max_compute_units);
+        query_param(id, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, m_max_work_item_dimensions);
+        query_param(id, CL_DEVICE_MAX_WORK_ITEM_SIZES, m_max_work_item_sizes);
+        query_param(id, CL_DEVICE_MAX_WORK_GROUP_SIZE, m_max_work_group_size);
+        query_param(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, m_preferred_vector_width_char);
+        query_param(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, m_preferred_vector_width_short);
+        query_param(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, m_preferred_vector_width_int);
+        query_param(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, m_preferred_vector_width_long);
+        query_param(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, m_preferred_vector_width_float);
+        query_param(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, m_preferred_vector_width_double);
+#if defined(CL_VERSION_1_1)
+        query_param(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, m_preferred_vector_width_half);
+        query_param(id, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, m_native_vector_width_char);
+        query_param(id, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, m_native_vector_width_short);
+        query_param(id, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, m_native_vector_width_int);
+        query_param(id, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, m_native_vector_width_long);
+        query_param(id, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, m_native_vector_width_float);
+        query_param(id, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, m_native_vector_width_double);
+        query_param(id, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, m_native_vector_width_half);
+#endif
+        query_param(id, CL_DEVICE_MAX_CLOCK_FREQUENCY, m_max_clock_frequency);
+        query_param(id, CL_DEVICE_ADDRESS_BITS, m_address_bits);
+        query_param(id, CL_DEVICE_MAX_MEM_ALLOC_SIZE, m_max_mem_alloc_size);
+        query_param(id, CL_DEVICE_IMAGE_SUPPORT, m_image_support);
+        query_param(id, CL_DEVICE_MAX_READ_IMAGE_ARGS, m_max_read_image_args);
+        query_param(id, CL_DEVICE_MAX_WRITE_IMAGE_ARGS, m_max_write_image_args);
+#if defined(CL_VERSION_2_0)
+        query_param(id, CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, m_max_read_write_image_args);
+#endif
+        query_param(id, CL_DEVICE_IMAGE2D_MAX_WIDTH, m_image2d_max_width);
+        query_param(id, CL_DEVICE_IMAGE2D_MAX_HEIGHT, m_image2d_max_height);
+        query_param(id, CL_DEVICE_IMAGE3D_MAX_WIDTH, m_image3d_max_width);
+        query_param(id, CL_DEVICE_IMAGE3D_MAX_HEIGHT, m_image3d_max_height);
+        query_param(id, CL_DEVICE_IMAGE3D_MAX_DEPTH, m_image3d_max_depth);
+#if defined(CL_VERSION_1_2)
+        query_param(id, CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, m_image_max_buffer_size);
+        query_param(id, CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, m_image_max_array_size);
+#endif
+        query_param(id, CL_DEVICE_MAX_SAMPLERS, m_max_samplers);
+#if defined(CL_VERSION_1_2)
+        query_param(id, CL_DEVICE_IMAGE_PITCH_ALIGNMENT, m_image_pitch_alignment);
+        query_param(id, CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, m_image_base_address_alignment);
+#endif
+#if defined(CL_VERSION_2_0)
+        query_param(id, CL_DEVICE_MAX_PIPE_ARGS, m_max_pipe_args);
+        query_param(id, CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS, m_pipe_max_active_reservations);
+        query_param(id, CL_DEVICE_PIPE_MAX_PACKET_SIZE, m_pipe_max_packet_size);
+#endif
+        query_param(id, CL_DEVICE_MAX_PARAMETER_SIZE, m_max_parameter_size);
+        query_param(id, CL_DEVICE_MEM_BASE_ADDR_ALIGN, m_mem_base_addr_align);
+        query_param(id, CL_DEVICE_SINGLE_FP_CONFIG, m_single_fp_config);
+#if defined(CL_VERSION_1_2)
+        query_param(id, CL_DEVICE_DOUBLE_FP_CONFIG, m_double_fp_config);
+#endif
+        query_param(id, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, m_global_mem_cache_type);
+        query_param(id, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, m_global_mem_cacheline_size);
+        query_param(id, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, m_global_mem_cache_size);
+        query_param(id, CL_DEVICE_GLOBAL_MEM_SIZE, m_global_mem_size);
+        query_param(id, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, m_max_constant_buffer_size);
+        query_param(id, CL_DEVICE_MAX_CONSTANT_ARGS, m_max_constant_args);
+#if defined(CL_VERSION_2_0)
+        query_param(id, CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE, m_max_global_variable_size);
+        query_param(id, CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, m_global_variable_preferred_total_size);
+#endif
+        query_param(id, CL_DEVICE_LOCAL_MEM_TYPE, m_local_mem_type);
+        query_param(id, CL_DEVICE_LOCAL_MEM_SIZE, m_local_mem_size);
+        query_param(id, CL_DEVICE_ERROR_CORRECTION_SUPPORT, m_error_correction_support);
+#if defined(CL_VERSION_1_1)
+        query_param(id, CL_DEVICE_HOST_UNIFIED_MEMORY, m_host_unified_memory);
+#endif
+        query_param(id, CL_DEVICE_PROFILING_TIMER_RESOLUTION, m_profiling_timer_resolution);
+        query_param(id, CL_DEVICE_ENDIAN_LITTLE, m_endian_little);
+        query_param(id, CL_DEVICE_AVAILABLE, m_available);
+        query_param(id, CL_DEVICE_COMPILER_AVAILABLE, m_compiler_available);
+#if defined(CL_VERSION_1_2)
+        query_param(id, CL_DEVICE_LINKER_AVAILABLE, m_linker_available);
+#endif
+        query_param(id, CL_DEVICE_EXECUTION_CAPABILITIES, m_execution_capabilities);
+        query_param(id, CL_DEVICE_QUEUE_PROPERTIES, m_queue_properties);
+#if defined(CL_VERSION_2_0)
+        query_param(id, CL_DEVICE_QUEUE_ON_HOST_PROPERTIES, m_queue_on_host_properties);
+        query_param(id, CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES, m_queue_on_device_properties);
+        query_param(id, CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE, m_queue_on_device_preferred_size);
+        query_param(id, CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE, m_queue_on_device_max_size);
+        query_param(id, CL_DEVICE_MAX_ON_DEVICE_QUEUES, m_max_on_device_queues);
+        query_param(id, CL_DEVICE_MAX_ON_DEVICE_EVENTS, m_max_on_device_events);
+#endif
+#if defined(CL_VERSION_1_2)
+        query_param(id, CL_DEVICE_BUILT_IN_KERNELS, m_built_in_kernels);
+#endif
+        query_param(id, CL_DEVICE_PLATFORM, m_platform);
+        query_param(id, CL_DEVICE_NAME, m_name);
+        query_param(id, CL_DEVICE_VENDOR, m_vendor);
+        query_param(id, CL_DRIVER_VERSION, m_driver_version);
+        query_param(id, CL_DEVICE_PROFILE, m_profile);
+        query_param(id, CL_DEVICE_VERSION, m_version);
+#if defined(CL_VERSION_1_1)
+        query_param(id, CL_DEVICE_OPENCL_C_VERSION, m_opencl_c_version);
+#endif
+        query_param(id, CL_DEVICE_EXTENSIONS, m_extensions);
+#if defined(CL_VERSION_1_2)
+        query_param(id, CL_DEVICE_PRINTF_BUFFER_SIZE, m_printf_buffer_size);
+        query_param(id, CL_DEVICE_PREFERRED_INTEROP_USER_SYNC, m_preferred_interop_user_sync);
+        query_param(id, CL_DEVICE_PARENT_DEVICE, m_parent_device);
+        query_param(id, CL_DEVICE_PARTITION_MAX_SUB_DEVICES, m_partition_max_sub_devices);
+        query_param(id, CL_DEVICE_PARTITION_PROPERTIES, m_partition_properties);
+        query_param(id, CL_DEVICE_PARTITION_AFFINITY_DOMAIN, m_partition_affinity_domain);
+        query_param(id, CL_DEVICE_PARTITION_TYPE, m_partition_type);
+        query_param(id, CL_DEVICE_REFERENCE_COUNT, m_reference_count);
+#endif
+        return CL_SUCCESS;
+    }
+
+    std::string Name() { return m_name; }
+
+private:
+    template<typename T>
+    cl_int query_param(cl_device_id id, cl_device_info param, T& value)
+    {
+        cl_int res;
+        size_t size = 0;
+
+        res = clGetDeviceInfo(id, param, 0, 0, &size);
+        if (CL_SUCCESS != res && size != 0)
+            throw std::runtime_error(std::string("clGetDeviceInfo failed"));
+
+        if (0 == size)
+            return CL_SUCCESS;
+
+        if (sizeof(T) != size)
+            throw std::runtime_error(std::string("clGetDeviceInfo: param size mismatch"));
+
+        res = clGetDeviceInfo(id, param, size, &value, 0);
+        if (CL_SUCCESS != res)
+            throw std::runtime_error(std::string("clGetDeviceInfo failed"));
+
+        return CL_SUCCESS;
+    }
+
+    template<typename T>
+    cl_int query_param(cl_device_id id, cl_device_info param, std::vector<T>& value)
+    {
+        cl_int res;
+        size_t size;
+
+        res = clGetDeviceInfo(id, param, 0, 0, &size);
+        if (CL_SUCCESS != res)
+            throw std::runtime_error(std::string("clGetDeviceInfo failed"));
+
+        if (0 == size)
+            return CL_SUCCESS;
+
+        value.resize(size / sizeof(T));
+
+        res = clGetDeviceInfo(id, param, size, &value[0], 0);
+        if (CL_SUCCESS != res)
+            throw std::runtime_error(std::string("clGetDeviceInfo failed"));
+
+        return CL_SUCCESS;
+    }
+
+    cl_int query_param(cl_device_id id, cl_device_info param, std::string& value)
+    {
+        cl_int res;
+        size_t size;
+
+        res = clGetDeviceInfo(id, param, 0, 0, &size);
+        if (CL_SUCCESS != res)
+            throw std::runtime_error(std::string("clGetDeviceInfo failed"));
+
+        value.resize(size + 1);
+
+        res = clGetDeviceInfo(id, param, size, &value[0], 0);
+        if (CL_SUCCESS != res)
+            throw std::runtime_error(std::string("clGetDeviceInfo failed"));
+
+        // just in case, ensure trailing zero for ASCIIZ string
+        value[size] = 0;
+
+        return CL_SUCCESS;
+    }
+
+private:
+    cl_device_type                            m_type;
+    cl_uint                                   m_vendor_id;
+    cl_uint                                   m_max_compute_units;
+    cl_uint                                   m_max_work_item_dimensions;
+    std::vector<size_t>                       m_max_work_item_sizes;
+    size_t                                    m_max_work_group_size;
+    cl_uint                                   m_preferred_vector_width_char;
+    cl_uint                                   m_preferred_vector_width_short;
+    cl_uint                                   m_preferred_vector_width_int;
+    cl_uint                                   m_preferred_vector_width_long;
+    cl_uint                                   m_preferred_vector_width_float;
+    cl_uint                                   m_preferred_vector_width_double;
+#if defined(CL_VERSION_1_1)
+    cl_uint                                   m_preferred_vector_width_half;
+    cl_uint                                   m_native_vector_width_char;
+    cl_uint                                   m_native_vector_width_short;
+    cl_uint                                   m_native_vector_width_int;
+    cl_uint                                   m_native_vector_width_long;
+    cl_uint                                   m_native_vector_width_float;
+    cl_uint                                   m_native_vector_width_double;
+    cl_uint                                   m_native_vector_width_half;
+#endif
+    cl_uint                                   m_max_clock_frequency;
+    cl_uint                                   m_address_bits;
+    cl_ulong                                  m_max_mem_alloc_size;
+    cl_bool                                   m_image_support;
+    cl_uint                                   m_max_read_image_args;
+    cl_uint                                   m_max_write_image_args;
+#if defined(CL_VERSION_2_0)
+    cl_uint                                   m_max_read_write_image_args;
+#endif
+    size_t                                    m_image2d_max_width;
+    size_t                                    m_image2d_max_height;
+    size_t                                    m_image3d_max_width;
+    size_t                                    m_image3d_max_height;
+    size_t                                    m_image3d_max_depth;
+#if defined(CL_VERSION_1_2)
+    size_t                                    m_image_max_buffer_size;
+    size_t                                    m_image_max_array_size;
+#endif
+    cl_uint                                   m_max_samplers;
+#if defined(CL_VERSION_1_2)
+    cl_uint                                   m_image_pitch_alignment;
+    cl_uint                                   m_image_base_address_alignment;
+#endif
+#if defined(CL_VERSION_2_0)
+    cl_uint                                   m_max_pipe_args;
+    cl_uint                                   m_pipe_max_active_reservations;
+    cl_uint                                   m_pipe_max_packet_size;
+#endif
+    size_t                                    m_max_parameter_size;
+    cl_uint                                   m_mem_base_addr_align;
+    cl_device_fp_config                       m_single_fp_config;
+#if defined(CL_VERSION_1_2)
+    cl_device_fp_config                       m_double_fp_config;
+#endif
+    cl_device_mem_cache_type                  m_global_mem_cache_type;
+    cl_uint                                   m_global_mem_cacheline_size;
+    cl_ulong                                  m_global_mem_cache_size;
+    cl_ulong                                  m_global_mem_size;
+    cl_ulong                                  m_max_constant_buffer_size;
+    cl_uint                                   m_max_constant_args;
+#if defined(CL_VERSION_2_0)
+    size_t                                    m_max_global_variable_size;
+    size_t                                    m_global_variable_preferred_total_size;
+#endif
+    cl_device_local_mem_type                  m_local_mem_type;
+    cl_ulong                                  m_local_mem_size;
+    cl_bool                                   m_error_correction_support;
+#if defined(CL_VERSION_1_1)
+    cl_bool                                   m_host_unified_memory;
+#endif
+    size_t                                    m_profiling_timer_resolution;
+    cl_bool                                   m_endian_little;
+    cl_bool                                   m_available;
+    cl_bool                                   m_compiler_available;
+#if defined(CL_VERSION_1_2)
+    cl_bool                                   m_linker_available;
+#endif
+    cl_device_exec_capabilities               m_execution_capabilities;
+    cl_command_queue_properties               m_queue_properties;
+#if defined(CL_VERSION_2_0)
+    cl_command_queue_properties               m_queue_on_host_properties;
+    cl_command_queue_properties               m_queue_on_device_properties;
+    cl_uint                                   m_queue_on_device_preferred_size;
+    cl_uint                                   m_queue_on_device_max_size;
+    cl_uint                                   m_max_on_device_queues;
+    cl_uint                                   m_max_on_device_events;
+#endif
+#if defined(CL_VERSION_1_2)
+    std::string                               m_built_in_kernels;
+#endif
+    cl_platform_id                            m_platform;
+    std::string                               m_name;
+    std::string                               m_vendor;
+    std::string                               m_driver_version;
+    std::string                               m_profile;
+    std::string                               m_version;
+#if defined(CL_VERSION_1_1)
+    std::string                               m_opencl_c_version;
+#endif
+    std::string                               m_extensions;
+#if defined(CL_VERSION_1_2)
+    size_t                                    m_printf_buffer_size;
+    cl_bool                                   m_preferred_interop_user_sync;
+    cl_device_id                              m_parent_device;
+    cl_uint                                   m_partition_max_sub_devices;
+    std::vector<cl_device_partition_property> m_partition_properties;
+    cl_device_affinity_domain                 m_partition_affinity_domain;
+    std::vector<cl_device_partition_property> m_partition_type;
+    cl_uint                                   m_reference_count;
+#endif
+};
+
+} // namespace opencl
+
+
+class App
+{
+public:
+    App(CommandLineParser& cmd);
+    ~App();
+
+    int initOpenCL();
+    int initVideoSource();
+
+    int process_frame_with_open_cl(cv::Mat& frame, bool use_buffer, cl_mem* cl_buffer);
+    int process_cl_buffer_with_opencv(cl_mem buffer, size_t step, int rows, int cols, int type, cv::UMat& u);
+    int process_cl_image_with_opencv(cl_mem image, cv::UMat& u);
+
+    int run();
+
+    bool isRunning() { return m_running; }
+    bool doProcess() { return m_process; }
+    bool useBuffer() { return m_use_buffer; }
+
+    void setRunning(bool running)      { m_running = running; }
+    void setDoProcess(bool process)    { m_process = process; }
+    void setUseBuffer(bool use_buffer) { m_use_buffer = use_buffer; }
+
+protected:
+    bool nextFrame(cv::Mat& frame) { return m_cap.read(frame); }
+    void handleKey(char key);
+    void timerStart();
+    void timerEnd();
+    std::string timeStr() const;
+    std::string message() const;
+
+private:
+    bool                        m_running;
+    bool                        m_process;
+    bool                        m_use_buffer;
+
+    int64                       m_t0;
+    int64                       m_t1;
+    float                       m_time;
+    float                       m_frequency;
+
+    string                      m_file_name;
+    int                         m_camera_id;
+    cv::VideoCapture            m_cap;
+    cv::Mat                     m_frame;
+    cv::Mat                     m_frameGray;
+
+    opencl::PlatformInfo        m_platformInfo;
+    opencl::DeviceInfo          m_deviceInfo;
+    std::vector<cl_platform_id> m_platform_ids;
+    cl_context                  m_context;
+    cl_device_id                m_device_id;
+    cl_command_queue            m_queue;
+    cl_program                  m_program;
+    cl_kernel                   m_kernelBuf;
+    cl_kernel                   m_kernelImg;
+    cl_mem                      m_img_src; // used as src in case processing of cl image
+    cl_mem                      m_mem_obj;
+};
+
+
+App::App(CommandLineParser& cmd)
+{
+    cout << "\nPress ESC to exit\n" << endl;
+    cout << "\n      'p' to toggle ON/OFF processing\n" << endl;
+    cout << "\n       SPACE to switch between OpenCL buffer/image\n" << endl;
+
+    m_camera_id  = cmd.get<int>("camera");
+    m_file_name  = cmd.get<string>("video");
+
+    m_running    = false;
+    m_process    = false;
+    m_use_buffer = false;
+
+    m_t0         = 0;
+    m_t1         = 0;
+    m_time       = 0.0;
+    m_frequency  = (float)cv::getTickFrequency();
+
+    m_context    = 0;
+    m_device_id  = 0;
+    m_queue      = 0;
+    m_program    = 0;
+    m_kernelBuf  = 0;
+    m_kernelImg  = 0;
+    m_img_src    = 0;
+    m_mem_obj    = 0;
+} // ctor
+
+
+App::~App()
+{
+    if (m_queue)
+    {
+        clFinish(m_queue);
+        clReleaseCommandQueue(m_queue);
+        m_queue = 0;
+    }
+
+    if (m_program)
+    {
+        clReleaseProgram(m_program);
+        m_program = 0;
+    }
+
+    if (m_img_src)
+    {
+        clReleaseMemObject(m_img_src);
+        m_img_src = 0;
+    }
+
+    if (m_mem_obj)
+    {
+        clReleaseMemObject(m_mem_obj);
+        m_mem_obj = 0;
+    }
+
+    if (m_kernelBuf)
+    {
+        clReleaseKernel(m_kernelBuf);
+        m_kernelBuf = 0;
+    }
+
+    if (m_kernelImg)
+    {
+        clReleaseKernel(m_kernelImg);
+        m_kernelImg = 0;
+    }
+
+    if (m_device_id)
+    {
+        clReleaseDevice(m_device_id);
+        m_device_id = 0;
+    }
+
+    if (m_context)
+    {
+        clReleaseContext(m_context);
+        m_context = 0;
+    }
+} // dtor
+
+
+int App::initOpenCL()
+{
+    cl_int res = CL_SUCCESS;
+    cl_uint num_entries = 0;
+
+    res = clGetPlatformIDs(0, 0, &num_entries);
+    if (CL_SUCCESS != res)
+        return -1;
+
+    m_platform_ids.resize(num_entries);
+
+    res = clGetPlatformIDs(num_entries, &m_platform_ids[0], 0);
+    if (CL_SUCCESS != res)
+        return -1;
+
+    unsigned int i;
+
+    // create context from first platform with GPU device
+    for (i = 0; i < m_platform_ids.size(); i++)
+    {
+        cl_context_properties props[] =
+        {
+            CL_CONTEXT_PLATFORM,
+            (cl_context_properties)(m_platform_ids[i]),
+            0
+        };
+
+        m_context = clCreateContextFromType(props, CL_DEVICE_TYPE_GPU, 0, 0, &res);
+        if (0 == m_context || CL_SUCCESS != res)
+            continue;
+
+        res = clGetContextInfo(m_context, CL_CONTEXT_DEVICES, sizeof(cl_device_id), &m_device_id, 0);
+        if (CL_SUCCESS != res)
+            return -1;
+
+        m_queue = clCreateCommandQueue(m_context, m_device_id, 0, &res);
+        if (0 == m_queue || CL_SUCCESS != res)
+            return -1;
+
+        const char* kernelSrc =
+            "__kernel "
+            "void bitwise_inv_buf_8uC1("
+            "    __global unsigned char* pSrcDst,"
+            "             int            srcDstStep,"
+            "             int            rows,"
+            "             int            cols)"
+            "{"
+            "    int x = get_global_id(0);"
+            "    int y = get_global_id(1);"
+            "    int idx = mad24(y, srcDstStep, x);"
+            "    pSrcDst[idx] = ~pSrcDst[idx];"
+            "}"
+            "__kernel "
+            "void bitwise_inv_img_8uC1("
+            "    read_only  image2d_t srcImg,"
+            "    write_only image2d_t dstImg)"
+            "{"
+            "    int x = get_global_id(0);"
+            "    int y = get_global_id(1);"
+            "    int2 coord = (int2)(x, y);"
+            "    uint4 val = read_imageui(srcImg, coord);"
+            "    val.x = (~val.x) & 0x000000FF;"
+            "    write_imageui(dstImg, coord, val);"
+            "}";
+        size_t len = strlen(kernelSrc);
+        m_program = clCreateProgramWithSource(m_context, 1, &kernelSrc, &len, &res);
+        if (0 == m_program || CL_SUCCESS != res)
+            return -1;
+
+        res = clBuildProgram(m_program, 1, &m_device_id, 0, 0, 0);
+        if (CL_SUCCESS != res)
+            return -1;
+
+        m_kernelBuf = clCreateKernel(m_program, "bitwise_inv_buf_8uC1", &res);
+        if (0 == m_kernelBuf || CL_SUCCESS != res)
+            return -1;
+
+        m_kernelImg = clCreateKernel(m_program, "bitwise_inv_img_8uC1", &res);
+        if (0 == m_kernelImg || CL_SUCCESS != res)
+            return -1;
+
+        m_platformInfo.QueryInfo(m_platform_ids[i]);
+        m_deviceInfo.QueryInfo(m_device_id);
+
+        // attach OpenCL context to OpenCV
+        cv::ocl::attachContext(m_platformInfo.Name(), m_platform_ids[i], m_context, m_device_id);
+
+        break;
+    }
+
+    return m_context != 0 ? CL_SUCCESS : -1;
+} // initOpenCL()
+
+
+int App::initVideoSource()
+{
+    try
+    {
+        if (!m_file_name.empty() && m_camera_id == -1)
+        {
+            m_cap.open(m_file_name.c_str());
+            if (!m_cap.isOpened())
+                throw std::runtime_error(std::string("can't open video file: " + m_file_name));
+        }
+        else if (m_camera_id != -1)
+        {
+            m_cap.open(m_camera_id);
+            if (!m_cap.isOpened())
+            {
+                std::stringstream msg;
+                msg << "can't open camera: " << m_camera_id;
+                throw std::runtime_error(msg.str());
+            }
+        }
+        else
+            throw std::runtime_error(std::string("specify video source"));
+    }
+
+    catch (const std::exception& e)
+    {
+        cerr << "ERROR: " << e.what() << std::endl;
+        return -1;
+    }
+
+    return 0;
+} // initVideoSource()
+
+
+// this function is an example of "typical" OpenCL processing pipeline
+// It creates OpenCL buffer or image, depending on use_buffer flag,
+// from input media frame and process these data
+// (inverts each pixel value in half of frame) with OpenCL kernel
+int App::process_frame_with_open_cl(cv::Mat& frame, bool use_buffer, cl_mem* mem_obj)
+{
+    cl_int res = CL_SUCCESS;
+
+    CV_Assert(mem_obj);
+
+    cl_kernel kernel = 0;
+    cl_mem mem = mem_obj[0];
+
+    if (0 == mem || 0 == m_img_src)
+    {
+        // allocate/delete cl memory objects every frame for the simplicity.
+        // in real application more efficient pipeline can be built.
+
+        if (use_buffer)
+        {
+            cl_mem_flags flags = CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR;
+
+            mem = clCreateBuffer(m_context, flags, frame.total(), frame.ptr(), &res);
+            if (0 == mem || CL_SUCCESS != res)
+                return -1;
+
+            res = clSetKernelArg(m_kernelBuf, 0, sizeof(cl_mem), &mem);
+            if (CL_SUCCESS != res)
+                return -1;
+
+            res = clSetKernelArg(m_kernelBuf, 1, sizeof(int), &frame.step[0]);
+            if (CL_SUCCESS != res)
+                return -1;
+
+            res = clSetKernelArg(m_kernelBuf, 2, sizeof(int), &frame.rows);
+            if (CL_SUCCESS != res)
+                return -1;
+
+            int cols2 = frame.cols / 2;
+            res = clSetKernelArg(m_kernelBuf, 3, sizeof(int), &cols2);
+            if (CL_SUCCESS != res)
+                return -1;
+
+            kernel = m_kernelBuf;
+        }
+        else
+        {
+            cl_mem_flags flags_src = CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR;
+
+            cl_image_format fmt;
+            fmt.image_channel_order     = CL_R;
+            fmt.image_channel_data_type = CL_UNSIGNED_INT8;
+
+            cl_image_desc desc_src;
+            desc_src.image_type        = CL_MEM_OBJECT_IMAGE2D;
+            desc_src.image_width       = frame.cols;
+            desc_src.image_height      = frame.rows;
+            desc_src.image_depth       = 0;
+            desc_src.image_array_size  = 0;
+            desc_src.image_row_pitch   = frame.step[0];
+            desc_src.image_slice_pitch = 0;
+            desc_src.num_mip_levels    = 0;
+            desc_src.num_samples       = 0;
+            desc_src.buffer            = 0;
+            m_img_src = clCreateImage(m_context, flags_src, &fmt, &desc_src, frame.ptr(), &res);
+            if (0 == m_img_src || CL_SUCCESS != res)
+                return -1;
+
+            cl_mem_flags flags_dst = CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR;
+
+            cl_image_desc desc_dst;
+            desc_dst.image_type        = CL_MEM_OBJECT_IMAGE2D;
+            desc_dst.image_width       = frame.cols;
+            desc_dst.image_height      = frame.rows;
+            desc_dst.image_depth       = 0;
+            desc_dst.image_array_size  = 0;
+            desc_dst.image_row_pitch   = 0;
+            desc_dst.image_slice_pitch = 0;
+            desc_dst.num_mip_levels    = 0;
+            desc_dst.num_samples       = 0;
+            desc_dst.buffer            = 0;
+            mem = clCreateImage(m_context, flags_dst, &fmt, &desc_dst, 0, &res);
+            if (0 == mem || CL_SUCCESS != res)
+                return -1;
+
+            size_t origin[] = { 0, 0, 0 };
+            size_t region[] = { (size_t)frame.cols, (size_t)frame.rows, 1 };
+            cl_event asyncEvent = 0;
+            res = clEnqueueCopyImage(m_queue, m_img_src, mem, origin, origin, region, 0, 0, &asyncEvent);
+            if (CL_SUCCESS != res)
+                return -1;
+
+            res = clWaitForEvents(1, &asyncEvent);
+            clReleaseEvent(asyncEvent);
+            if (CL_SUCCESS != res)
+                return -1;
+
+            res = clSetKernelArg(m_kernelImg, 0, sizeof(cl_mem), &m_img_src);
+            if (CL_SUCCESS != res)
+                return -1;
+
+            res = clSetKernelArg(m_kernelImg, 1, sizeof(cl_mem), &mem);
+            if (CL_SUCCESS != res)
+                return -1;
+
+            kernel = m_kernelImg;
+        }
+    }
+
+    // process left half of frame in OpenCL
+    size_t size[] = { (size_t)frame.cols / 2, (size_t)frame.rows };
+    cl_event asyncEvent = 0;
+    res = clEnqueueNDRangeKernel(m_queue, kernel, 2, 0, size, 0, 0, 0, &asyncEvent);
+    if (CL_SUCCESS != res)
+        return -1;
+
+    res = clWaitForEvents(1, &asyncEvent);
+    clReleaseEvent(asyncEvent);
+    if (CL_SUCCESS != res)
+        return -1;
+
+    mem_obj[0] = mem;
+
+    return  0;
+}
+
+
+// this function is an example of interoperability between OpenCL buffer
+// and OpenCV UMat objects. It converts (without copying data) OpenCL buffer
+// to OpenCV UMat and then do blur on these data
+int App::process_cl_buffer_with_opencv(cl_mem buffer, size_t step, int rows, int cols, int type, cv::UMat& u)
+{
+    cv::ocl::convertFromBuffer(buffer, step, rows, cols, type, u);
+
+    // process right half of frame in OpenCV
+    cv::Point pt(u.cols / 2, 0);
+    cv::Size  sz(u.cols / 2, u.rows);
+    cv::Rect roi(pt, sz);
+    cv::UMat uroi(u, roi);
+    cv::blur(uroi, uroi, cv::Size(7, 7), cv::Point(-3, -3));
+
+    if (buffer)
+        clReleaseMemObject(buffer);
+    m_mem_obj = 0;
+
+    return 0;
+}
+
+
+// this function is an example of interoperability between OpenCL image
+// and OpenCV UMat objects. It converts OpenCL image
+// to OpenCV UMat and then do blur on these data
+int App::process_cl_image_with_opencv(cl_mem image, cv::UMat& u)
+{
+    cv::ocl::convertFromImage(image, u);
+
+    // process right half of frame in OpenCV
+    cv::Point pt(u.cols / 2, 0);
+    cv::Size  sz(u.cols / 2, u.rows);
+    cv::Rect roi(pt, sz);
+    cv::UMat uroi(u, roi);
+    cv::blur(uroi, uroi, cv::Size(7, 7), cv::Point(-3, -3));
+
+    if (image)
+        clReleaseMemObject(image);
+    m_mem_obj = 0;
+
+    if (m_img_src)
+        clReleaseMemObject(m_img_src);
+    m_img_src = 0;
+
+    return 0;
+}
+
+
+int App::run()
+{
+    if (0 != initOpenCL())
+        return -1;
+
+    if (0 != initVideoSource())
+        return -1;
+
+    Mat img_to_show;
+
+    // set running state until ESC pressed
+    setRunning(true);
+    // set process flag to show some data processing
+    // can be toggled on/off by 'p' button
+    setDoProcess(true);
+    // set use buffer flag,
+    // when it is set to true, will demo interop opencl buffer and cv::Umat,
+    // otherwise demo interop opencl image and cv::UMat
+    // can be switched on/of by SPACE button
+    setUseBuffer(true);
+
+    // Iterate over all frames
+    while (isRunning() && nextFrame(m_frame))
+    {
+        cv::cvtColor(m_frame, m_frameGray, COLOR_BGR2GRAY);
+
+        UMat uframe;
+
+        // work
+        timerStart();
+
+        if (doProcess())
+        {
+            process_frame_with_open_cl(m_frameGray, useBuffer(), &m_mem_obj);
+
+            if (useBuffer())
+                process_cl_buffer_with_opencv(
+                    m_mem_obj, m_frameGray.step[0], m_frameGray.rows, m_frameGray.cols, m_frameGray.type(), uframe);
+            else
+                process_cl_image_with_opencv(m_mem_obj, uframe);
+        }
+        else
+        {
+            m_frameGray.copyTo(uframe);
+        }
+
+        timerEnd();
+
+        uframe.copyTo(img_to_show);
+
+        putText(img_to_show, "Version : " + m_platformInfo.Version(), Point(5, 30), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+        putText(img_to_show, "Name : " + m_platformInfo.Name(), Point(5, 60), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+        putText(img_to_show, "Device : " + m_deviceInfo.Name(), Point(5, 90), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+        cv::String memtype = useBuffer() ? "buffer" : "image";
+        putText(img_to_show, "interop with OpenCL " + memtype, Point(5, 120), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+        putText(img_to_show, "Time : " + timeStr() + " msec", Point(5, 150), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+
+        imshow("opencl_interop", img_to_show);
+
+        handleKey((char)waitKey(3));
+    }
+
+    return 0;
+}
+
+
+void App::handleKey(char key)
+{
+    switch (key)
+    {
+    case 27:
+        setRunning(false);
+        break;
+
+    case ' ':
+        setUseBuffer(!useBuffer());
+        break;
+
+    case 'p':
+    case 'P':
+        setDoProcess( !doProcess() );
+        break;
+
+    default:
+        break;
+    }
+}
+
+
+inline void App::timerStart()
+{
+    m_t0 = getTickCount();
+}
+
+
+inline void App::timerEnd()
+{
+    m_t1 = getTickCount();
+    int64 delta = m_t1 - m_t0;
+    m_time = (delta / m_frequency) * 1000; // units msec
+}
+
+
+inline string App::timeStr() const
+{
+    stringstream ss;
+    ss << std::fixed << std::setprecision(1) << m_time;
+    return ss.str();
+}
+
+
+int main(int argc, char** argv)
+{
+    const char* keys =
+        "{ help h ?    |          | print help message }"
+        "{ camera c    | -1       | use camera as input }"
+        "{ video  v    |          | use video as input }";
+
+    CommandLineParser cmd(argc, argv, keys);
+    if (cmd.has("help"))
+    {
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+
+    App app(cmd);
+
+    try
+    {
+        app.run();
+    }
+
+    catch (const cv::Exception& e)
+    {
+        cout << "error: " << e.what() << endl;
+        return 1;
+    }
+
+    catch (const std::exception& e)
+    {
+        cout << "error: " << e.what() << endl;
+        return 1;
+    }
+
+    catch (...)
+    {
+        cout << "unknown exception" << endl;
+        return 1;
+    }
+
+    return EXIT_SUCCESS;
+} // main()
diff --git a/C++/opencv-4.7.0/samples/opengl/CMakeLists.txt b/C++/opencv-4.7.0/samples/opengl/CMakeLists.txt
new file mode 100644
index 00000000..158151c3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/opengl/CMakeLists.txt
@@ -0,0 +1,34 @@
+if(APPLE)
+  return()
+endif()
+
+if(UNIX)
+  find_package(X11 QUIET)
+endif()
+
+SET(OPENCV_OPENGL_SAMPLES_REQUIRED_DEPS
+  opencv_core
+  opencv_imgproc
+  opencv_imgcodecs
+  opencv_videoio
+  opencv_highgui)
+ocv_check_dependencies(${OPENCV_OPENGL_SAMPLES_REQUIRED_DEPS})
+
+if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
+  project(opengl_samples)
+  ocv_include_modules_recurse(${OPENCV_OPENGL_SAMPLES_REQUIRED_DEPS})
+  file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+  if(NOT X11_FOUND)
+    ocv_list_filterout(all_samples "opengl_interop")
+  endif()
+  foreach(sample_filename ${all_samples})
+    ocv_define_sample(tgt ${sample_filename} opengl)
+    ocv_target_link_libraries(${tgt} PRIVATE "${OPENGL_LIBRARIES}" "${OPENCV_OPENGL_SAMPLES_REQUIRED_DEPS}")
+    if(sample_filename STREQUAL "opengl_interop.cpp")
+      ocv_target_link_libraries(${tgt} PRIVATE ${X11_LIBRARIES})
+      ocv_target_include_directories(${tgt} ${X11_INCLUDE_DIR})
+    endif()
+  endforeach()
+endif()
+
+ocv_install_example_src(opengl *.cpp *.hpp CMakeLists.txt)
diff --git a/C++/opencv-4.7.0/samples/opengl/opengl.cpp b/C++/opencv-4.7.0/samples/opengl/opengl.cpp
new file mode 100644
index 00000000..dd2f9131
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/opengl/opengl.cpp
@@ -0,0 +1,114 @@
+#include <iostream>
+
+#ifdef _WIN32
+    #define WIN32_LEAN_AND_MEAN 1
+    #define NOMINMAX 1
+    #include <windows.h>
+#endif
+
+#if defined(__APPLE__)
+    #include <OpenGL/gl.h>
+    #include <OpenGL/glu.h>
+#else
+    #include <GL/gl.h>
+    #include <GL/glu.h>
+#endif
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/opengl.hpp"
+#include "opencv2/core/cuda.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::cuda;
+
+const int win_width = 800;
+const int win_height = 640;
+
+struct DrawData
+{
+    ogl::Arrays arr;
+    ogl::Texture2D tex;
+    ogl::Buffer indices;
+};
+
+void draw(void* userdata);
+
+void draw(void* userdata)
+{
+    DrawData* data = static_cast<DrawData*>(userdata);
+
+    glRotated(0.6, 0, 1, 0);
+
+    ogl::render(data->arr, data->indices, ogl::TRIANGLES);
+}
+
+int main(int argc, char* argv[])
+{
+    string filename;
+    if (argc < 2)
+    {
+        cout << "Usage: " << argv[0] << " image" << endl;
+        filename = "../data/lena.jpg";
+    }
+    else
+        filename = argv[1];
+
+    Mat img = imread(filename);
+    if (img.empty())
+    {
+        cerr << "Can't open image " << filename << endl;
+        return -1;
+    }
+
+    namedWindow("OpenGL", WINDOW_OPENGL);
+    resizeWindow("OpenGL", win_width, win_height);
+
+    Mat_<Vec2f> vertex(1, 4);
+    vertex << Vec2f(-1, 1), Vec2f(-1, -1), Vec2f(1, -1), Vec2f(1, 1);
+
+    Mat_<Vec2f> texCoords(1, 4);
+    texCoords << Vec2f(0, 0), Vec2f(0, 1), Vec2f(1, 1), Vec2f(1, 0);
+
+    Mat_<int> indices(1, 6);
+    indices << 0, 1, 2, 2, 3, 0;
+
+    DrawData data;
+
+    data.arr.setVertexArray(vertex);
+    data.arr.setTexCoordArray(texCoords);
+    data.indices.copyFrom(indices);
+    data.tex.copyFrom(img);
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluPerspective(45.0, (double)win_width / win_height, 0.1, 100.0);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    gluLookAt(0, 0, 3, 0, 0, 0, 0, 1, 0);
+
+    glEnable(GL_TEXTURE_2D);
+    data.tex.bind();
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexEnvi(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+    glDisable(GL_CULL_FACE);
+
+    setOpenGlDrawCallback("OpenGL", draw, &data);
+
+    for (;;)
+    {
+        updateWindow("OpenGL");
+        char key = (char)waitKey(40);
+        if (key == 27)
+            break;
+    }
+
+    setOpenGlDrawCallback("OpenGL", 0, 0);
+    destroyAllWindows();
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/opengl/opengl_interop.cpp b/C++/opencv-4.7.0/samples/opengl/opengl_interop.cpp
new file mode 100644
index 00000000..8d3e0f8d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/opengl/opengl_interop.cpp
@@ -0,0 +1,527 @@
+/*
+// Sample demonstrating interoperability of OpenCV UMat with OpenGL texture.
+// At first, the data obtained from video file or camera and placed onto
+// OpenGL texture, following mapping of this OpenGL texture to OpenCV UMat
+// and call cv::Blur function. The result is mapped back to OpenGL texture
+// and rendered through OpenGL API.
+*/
+#if defined(_WIN32)
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+#elif defined(__linux__)
+# include <X11/X.h>
+# include <X11/Xlib.h>
+#endif
+
+#include <iostream>
+#include <queue>
+#include <string>
+
+#include <stdio.h>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/opengl.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+
+#include "winapp.hpp"
+
+class GLWinApp : public WinApp
+{
+public:
+    enum MODE
+    {
+        MODE_CPU = 0,
+        MODE_GPU
+    };
+
+    GLWinApp(int width, int height, std::string& window_name, cv::VideoCapture& cap) :
+        WinApp(width, height, window_name)
+    {
+        m_shutdown        = false;
+        m_use_buffer      = false;
+        m_demo_processing = true;
+        m_mode            = MODE_CPU;
+        m_modeStr[0]      = cv::String("Processing on CPU");
+        m_modeStr[1]      = cv::String("Processing on GPU");
+        m_cap             = cap;
+    }
+
+    ~GLWinApp() {}
+
+    virtual void cleanup() CV_OVERRIDE
+    {
+        m_shutdown = true;
+#if defined(__linux__)
+        glXMakeCurrent(m_display, None, NULL);
+        glXDestroyContext(m_display, m_glctx);
+#endif
+        WinApp::cleanup();
+    }
+
+#if defined(_WIN32)
+    virtual LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) CV_OVERRIDE
+    {
+        switch (message)
+        {
+        case WM_CHAR:
+            if (wParam == '1')
+            {
+                set_mode(MODE_CPU);
+                return EXIT_SUCCESS;
+            }
+            if (wParam == '2')
+            {
+                set_mode(MODE_GPU);
+                return EXIT_SUCCESS;
+            }
+            else if (wParam == '9')
+            {
+                toggle_buffer();
+                return EXIT_SUCCESS;
+            }
+            else if (wParam == VK_SPACE)
+            {
+                m_demo_processing = !m_demo_processing;
+                return EXIT_SUCCESS;
+            }
+            else if (wParam == VK_ESCAPE)
+            {
+                cleanup();
+                return EXIT_SUCCESS;
+            }
+            break;
+
+        case WM_CLOSE:
+            cleanup();
+            return EXIT_SUCCESS;
+
+        case WM_DESTROY:
+            ::PostQuitMessage(0);
+            return EXIT_SUCCESS;
+        }
+
+        return ::DefWindowProc(hWnd, message, wParam, lParam);
+    }
+#endif
+
+#if defined(__linux__)
+    int handle_event(XEvent& e) CV_OVERRIDE
+    {
+        switch(e.type)
+        {
+        case ClientMessage:
+            if ((Atom)e.xclient.data.l[0] == m_WM_DELETE_WINDOW)
+            {
+                m_end_loop = true;
+                cleanup();
+            }
+            else
+            {
+                return EXIT_SUCCESS;
+            }
+            break;
+        case Expose:
+            render();
+            break;
+        case KeyPress:
+            switch(keycode_to_keysym(e.xkey.keycode))
+            {
+            case XK_space:
+                m_demo_processing = !m_demo_processing;
+                break;
+            case XK_1:
+                set_mode(MODE_CPU);
+                break;
+            case XK_2:
+                set_mode(MODE_GPU);
+                break;
+            case XK_9:
+                toggle_buffer();
+                break;
+            case XK_Escape:
+                m_end_loop = true;
+                cleanup();
+                break;
+            }
+            break;
+        default:
+            return EXIT_SUCCESS;
+        }
+        return 1;
+    }
+#endif
+
+    int init() CV_OVERRIDE
+    {
+#if defined(_WIN32)
+        m_hDC = GetDC(m_hWnd);
+
+        if (setup_pixel_format() != 0)
+        {
+            std::cerr << "Can't setup pixel format" << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        m_hRC = wglCreateContext(m_hDC);
+        wglMakeCurrent(m_hDC, m_hRC);
+#elif defined(__linux__)
+        m_glctx = glXCreateContext(m_display, m_visual_info, NULL, GL_TRUE);
+        glXMakeCurrent(m_display, m_window, m_glctx);
+#endif
+
+        glEnable(GL_TEXTURE_2D);
+        glEnable(GL_DEPTH_TEST);
+
+        glViewport(0, 0, m_width, m_height);
+
+        if (cv::ocl::haveOpenCL())
+        {
+            (void) cv::ogl::ocl::initializeContextFromGL();
+        }
+
+        m_oclDevName = cv::ocl::useOpenCL() ?
+            cv::ocl::Context::getDefault().device(0).name() :
+            (char*) "No OpenCL device";
+
+        return EXIT_SUCCESS;
+    } // init()
+
+    int get_frame(cv::ogl::Texture2D& texture, cv::ogl::Buffer& buffer, bool do_buffer)
+    {
+        if (!m_cap.read(m_frame_bgr))
+            return EXIT_FAILURE;
+
+        cv::cvtColor(m_frame_bgr, m_frame_rgba, cv::COLOR_RGB2RGBA);
+
+        if (do_buffer)
+            buffer.copyFrom(m_frame_rgba, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true);
+        else
+            texture.copyFrom(m_frame_rgba, true);
+
+        return EXIT_SUCCESS;
+    }
+
+    void print_info(MODE mode, double time, cv::String& oclDevName)
+    {
+#if defined(_WIN32)
+        HDC hDC = m_hDC;
+
+        HFONT hFont = (HFONT)::GetStockObject(SYSTEM_FONT);
+
+        HFONT hOldFont = (HFONT)::SelectObject(hDC, hFont);
+
+        if (hOldFont)
+        {
+            TEXTMETRIC tm;
+            ::GetTextMetrics(hDC, &tm);
+
+            char buf[256+1];
+            int  y = 0;
+
+            buf[0] = 0;
+            sprintf_s(buf, sizeof(buf)-1, "Mode: %s OpenGL %s", m_modeStr[mode].c_str(), use_buffer() ? "buffer" : "texture");
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            y += tm.tmHeight;
+            buf[0] = 0;
+            sprintf_s(buf, sizeof(buf)-1, "Time, msec: %2.1f", time);
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            y += tm.tmHeight;
+            buf[0] = 0;
+            sprintf_s(buf, sizeof(buf)-1, "OpenCL device: %s", oclDevName.c_str());
+            ::TextOut(hDC, 0, y, buf, (int)strlen(buf));
+
+            ::SelectObject(hDC, hOldFont);
+        }
+#elif defined(__linux__)
+
+        char buf[256+1];
+        snprintf(buf, sizeof(buf)-1, "Time, msec: %2.1f, Mode: %s OpenGL %s, Device: %s", time, m_modeStr[mode].c_str(), use_buffer() ? "buffer" : "texture", oclDevName.c_str());
+        XStoreName(m_display, m_window, buf);
+#endif
+    }
+
+    void idle() CV_OVERRIDE
+    {
+        render();
+    }
+
+    int render() CV_OVERRIDE
+    {
+        try
+        {
+            if (m_shutdown)
+                return EXIT_SUCCESS;
+
+            int r;
+            cv::ogl::Texture2D texture;
+            cv::ogl::Buffer buffer;
+
+            texture.setAutoRelease(true);
+            buffer.setAutoRelease(true);
+
+            MODE mode = get_mode();
+            bool do_buffer = use_buffer();
+
+            r = get_frame(texture, buffer, do_buffer);
+            if (r != 0)
+            {
+                return EXIT_FAILURE;
+            }
+
+            switch (mode)
+            {
+                case MODE_CPU: // process frame on CPU
+                    processFrameCPU(texture, buffer, do_buffer);
+                    break;
+
+                case MODE_GPU: // process frame on GPU
+                    processFrameGPU(texture, buffer, do_buffer);
+                    break;
+            } // switch
+
+            if (do_buffer) // buffer -> texture
+            {
+                cv::Mat m(m_height, m_width, CV_8UC4);
+                buffer.copyTo(m);
+                texture.copyFrom(m, true);
+            }
+
+#if defined(__linux__)
+            XWindowAttributes window_attributes;
+            XGetWindowAttributes(m_display, m_window, &window_attributes);
+            glViewport(0, 0, window_attributes.width, window_attributes.height);
+#endif
+
+            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+            glLoadIdentity();
+            glEnable(GL_TEXTURE_2D);
+
+            texture.bind();
+
+            glBegin(GL_QUADS);
+            glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 0.1f);
+            glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, 0.1f);
+            glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, -1.0f, 0.1f);
+            glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 1.0f, 0.1f);
+            glEnd();
+
+#if defined(_WIN32)
+            SwapBuffers(m_hDC);
+#elif defined(__linux__)
+            glXSwapBuffers(m_display, m_window);
+#endif
+
+            print_info(mode, m_timer.getTimeMilli(), m_oclDevName);
+        }
+
+
+        catch (const cv::Exception& e)
+        {
+            std::cerr << "Exception: " << e.what() << std::endl;
+            return 10;
+        }
+
+        return EXIT_SUCCESS;
+    }
+
+protected:
+
+    void processFrameCPU(cv::ogl::Texture2D& texture, cv::ogl::Buffer& buffer, bool do_buffer)
+    {
+        cv::Mat m(m_height, m_width, CV_8UC4);
+
+        m_timer.reset();
+        m_timer.start();
+
+        if (do_buffer)
+            buffer.copyTo(m);
+        else
+            texture.copyTo(m);
+
+        if (m_demo_processing)
+        {
+            // blur texture image with OpenCV on CPU
+            cv::blur(m, m, cv::Size(15, 15));
+        }
+
+        if (do_buffer)
+            buffer.copyFrom(m, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true);
+        else
+            texture.copyFrom(m, true);
+
+        m_timer.stop();
+    }
+
+    void processFrameGPU(cv::ogl::Texture2D& texture, cv::ogl::Buffer& buffer, bool do_buffer)
+    {
+        cv::UMat u;
+
+        m_timer.reset();
+        m_timer.start();
+
+        if (do_buffer)
+            u = cv::ogl::mapGLBuffer(buffer);
+        else
+            cv::ogl::convertFromGLTexture2D(texture, u);
+
+        if (m_demo_processing)
+        {
+            // blur texture image with OpenCV on GPU with OpenCL
+            cv::blur(u, u, cv::Size(15, 15));
+        }
+
+        if (do_buffer)
+            cv::ogl::unmapGLBuffer(u);
+        else
+            cv::ogl::convertToGLTexture2D(u, texture);
+
+        m_timer.stop();
+    }
+
+#if defined(_WIN32)
+    int setup_pixel_format()
+    {
+        PIXELFORMATDESCRIPTOR  pfd;
+
+        pfd.nSize           = sizeof(PIXELFORMATDESCRIPTOR);
+        pfd.nVersion        = 1;
+        pfd.dwFlags         = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL  | PFD_DOUBLEBUFFER;
+        pfd.iPixelType      = PFD_TYPE_RGBA;
+        pfd.cColorBits      = 24;
+        pfd.cRedBits        = 8;
+        pfd.cRedShift       = 0;
+        pfd.cGreenBits      = 8;
+        pfd.cGreenShift     = 0;
+        pfd.cBlueBits       = 8;
+        pfd.cBlueShift      = 0;
+        pfd.cAlphaBits      = 8;
+        pfd.cAlphaShift     = 0;
+        pfd.cAccumBits      = 0;
+        pfd.cAccumRedBits   = 0;
+        pfd.cAccumGreenBits = 0;
+        pfd.cAccumBlueBits  = 0;
+        pfd.cAccumAlphaBits = 0;
+        pfd.cDepthBits      = 24;
+        pfd.cStencilBits    = 8;
+        pfd.cAuxBuffers     = 0;
+        pfd.iLayerType      = PFD_MAIN_PLANE;
+        pfd.bReserved       = 0;
+        pfd.dwLayerMask     = 0;
+        pfd.dwVisibleMask   = 0;
+        pfd.dwDamageMask    = 0;
+
+        int pfmt = ChoosePixelFormat(m_hDC, &pfd);
+        if (pfmt == 0)
+            return EXIT_FAILURE;
+
+        if (SetPixelFormat(m_hDC, pfmt, &pfd) == 0)
+            return -2;
+
+        return EXIT_SUCCESS;
+    }
+#endif
+
+#if defined(__linux__)
+    KeySym keycode_to_keysym(unsigned keycode)
+    {   // note that XKeycodeToKeysym() is considered deprecated
+        int keysyms_per_keycode_return = 0;
+        KeySym *keysyms = XGetKeyboardMapping(m_display, keycode, 1, &keysyms_per_keycode_return);
+        KeySym keysym = keysyms[0];
+        XFree(keysyms);
+        return keysym;
+    }
+#endif
+
+    bool use_buffer()        { return m_use_buffer; }
+    void toggle_buffer()     { m_use_buffer = !m_use_buffer; }
+    MODE get_mode()          { return m_mode; }
+    void set_mode(MODE mode) { m_mode = mode; }
+
+private:
+    bool               m_shutdown;
+    bool               m_use_buffer;
+    bool               m_demo_processing;
+    MODE               m_mode;
+    cv::String         m_modeStr[2];
+#if defined(_WIN32)
+    HDC                m_hDC;
+    HGLRC              m_hRC;
+#elif defined(__linux__)
+    GLXContext         m_glctx;
+#endif
+    cv::VideoCapture   m_cap;
+    cv::Mat            m_frame_bgr;
+    cv::Mat            m_frame_rgba;
+    cv::String         m_oclDevName;
+};
+
+static const char* keys =
+{
+    "{c camera | 0     | camera id }"
+    "{f file   |       | movie file name  }"
+};
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv, keys);
+    int    camera_id = parser.get<int>("camera");
+    string file      = parser.get<string>("file");
+
+    parser.about(
+        "\nA sample program demonstrating interoperability of OpenGL and OpenCL with OpenCV.\n\n"
+        "Hot keys: \n"
+        "  SPACE - turn processing on/off\n"
+        "    1   - process GL data through OpenCV on CPU\n"
+        "    2   - process GL data through OpenCV on GPU (via OpenCL)\n"
+        "    9   - toggle use of GL texture/GL buffer\n"
+        "   ESC  - exit\n\n");
+
+    parser.printMessage();
+
+    cv::VideoCapture cap;
+
+    if (file.empty())
+        cap.open(camera_id);
+    else
+        cap.open(file.c_str());
+
+    if (!cap.isOpened())
+    {
+        printf("can not open camera or video file\n");
+        return EXIT_FAILURE;
+    }
+
+    int width  = (int)cap.get(CAP_PROP_FRAME_WIDTH);
+    int height = (int)cap.get(CAP_PROP_FRAME_HEIGHT);
+
+#if defined(_WIN32)
+    string wndname = "WGL Window";
+#elif defined(__linux__)
+    string wndname = "GLX Window";
+#endif
+
+    GLWinApp app(width, height, wndname, cap);
+
+    try
+    {
+        app.create();
+        return app.run();
+    }
+    catch (const cv::Exception& e)
+    {
+        cerr << "Exception: " << e.what() << endl;
+        return 10;
+    }
+    catch (...)
+    {
+        cerr << "FATAL ERROR: Unknown exception" << endl;
+        return 11;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/opengl/winapp.hpp b/C++/opencv-4.7.0/samples/opengl/winapp.hpp
new file mode 100644
index 00000000..c4f492df
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/opengl/winapp.hpp
@@ -0,0 +1,222 @@
+#if defined(_WIN32)
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+#elif defined(__linux__)
+# include <X11/X.h>
+# include <X11/Xlib.h>
+# include <X11/Xutil.h>
+#endif
+
+#include <string>
+
+#include <GL/gl.h>
+#if defined(_WIN32)
+# include <GL/glu.h>
+#elif defined(__linux__)
+# include <GL/glx.h>
+#endif
+
+#if defined(_WIN32)
+# define WINCLASS "WinAppWnd"
+#endif
+
+#define SAFE_RELEASE(p) if (p) { p->Release(); p = NULL; }
+
+class WinApp
+{
+public:
+    WinApp(int width, int height, std::string& window_name)
+    {
+        m_width       = width;
+        m_height      = height;
+        m_window_name = window_name;
+#if defined(_WIN32)
+        m_hInstance   = ::GetModuleHandle(NULL);
+#endif
+    }
+
+    virtual ~WinApp()
+    {
+#if defined(_WIN32)
+        ::UnregisterClass(WINCLASS, m_hInstance);
+#endif
+    }
+
+    int create()
+    {
+#if defined(_WIN32)
+        WNDCLASSEX wcex;
+
+        wcex.cbSize        = sizeof(WNDCLASSEX);
+        wcex.style         = CS_HREDRAW | CS_VREDRAW;
+        wcex.lpfnWndProc   = &WinApp::StaticWndProc;
+        wcex.cbClsExtra    = 0;
+        wcex.cbWndExtra    = 0;
+        wcex.hInstance     = m_hInstance;
+        wcex.hIcon         = LoadIcon(0, IDI_APPLICATION);
+        wcex.hCursor       = LoadCursor(0, IDC_ARROW);
+        wcex.hbrBackground = 0;
+        wcex.lpszMenuName  = 0L;
+        wcex.lpszClassName = WINCLASS;
+        wcex.hIconSm       = 0;
+
+        ATOM wc = ::RegisterClassEx(&wcex);
+
+        RECT rc = { 0, 0, m_width, m_height };
+        ::AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, false);
+
+        m_hWnd = ::CreateWindow(
+                     (LPCTSTR)wc, m_window_name.c_str(),
+                     WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
+                     rc.right - rc.left, rc.bottom - rc.top,
+                     NULL, NULL, m_hInstance, (void*)this);
+
+        if (!m_hWnd)
+            return -1;
+
+        ::ShowWindow(m_hWnd, SW_SHOW);
+        ::UpdateWindow(m_hWnd);
+        ::SetFocus(m_hWnd);
+#elif defined(__linux__)
+        m_display = XOpenDisplay(NULL);
+
+        if (m_display == NULL)
+        {
+            return -1;
+        }
+
+        m_WM_DELETE_WINDOW = XInternAtom(m_display, "WM_DELETE_WINDOW", False);
+
+        static GLint visual_attributes[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None };
+        m_visual_info = glXChooseVisual(m_display, 0, visual_attributes);
+
+        if (m_visual_info == NULL)
+        {
+            XCloseDisplay(m_display);
+            return -2;
+        }
+
+        Window root = DefaultRootWindow(m_display);
+
+        m_event_mask = ExposureMask | KeyPressMask;
+
+        XSetWindowAttributes window_attributes;
+        window_attributes.colormap = XCreateColormap(m_display, root, m_visual_info->visual, AllocNone);
+        window_attributes.event_mask = m_event_mask;
+
+        m_window = XCreateWindow(
+            m_display, root, 0, 0, m_width, m_height, 0, m_visual_info->depth,
+            InputOutput, m_visual_info->visual, CWColormap | CWEventMask, &window_attributes);
+
+        XMapWindow(m_display, m_window);
+        XSetWMProtocols(m_display, m_window, &m_WM_DELETE_WINDOW, 1);
+        XStoreName(m_display, m_window, m_window_name.c_str());
+#endif
+
+        return init();
+    }
+
+    virtual void cleanup()
+    {
+#if defined(_WIN32)
+        ::DestroyWindow(m_hWnd);
+#elif defined(__linux__)
+        XDestroyWindow(m_display, m_window);
+        XCloseDisplay(m_display);
+#endif
+    }
+
+#if defined(_WIN32)
+    virtual LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) = 0;
+#endif
+
+    int run()
+    {
+#if defined(_WIN32)
+        MSG msg;
+
+        ::ZeroMemory(&msg, sizeof(msg));
+
+        while (msg.message != WM_QUIT)
+        {
+            if (::PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
+            {
+                ::TranslateMessage(&msg);
+                ::DispatchMessage(&msg);
+            }
+            else
+            {
+                idle();
+            }
+        }
+
+        return static_cast<int>(msg.wParam);
+#elif defined(__linux__)
+        m_end_loop = false;
+
+        do {
+            XEvent e;
+
+            if (!XCheckWindowEvent(m_display, m_window, m_event_mask, &e) || !handle_event(e))
+            {
+                idle();
+            }
+        } while (!m_end_loop);
+
+        return 0;
+#endif
+    }
+
+protected:
+
+#if defined(_WIN32)
+    static LRESULT CALLBACK StaticWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+    {
+        WinApp* pWnd;
+
+        if (message == WM_NCCREATE)
+        {
+            LPCREATESTRUCT pCreateStruct = ((LPCREATESTRUCT)lParam);
+            pWnd = (WinApp*)(pCreateStruct->lpCreateParams);
+            ::SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)pWnd);
+        }
+
+        pWnd = GetObjectFromWindow(hWnd);
+
+        if (pWnd)
+            return pWnd->WndProc(hWnd, message, wParam, lParam);
+        else
+            return ::DefWindowProc(hWnd, message, wParam, lParam);
+    }
+
+    inline static WinApp* GetObjectFromWindow(HWND hWnd)
+    {
+        return (WinApp*)::GetWindowLongPtr(hWnd, GWLP_USERDATA);
+    }
+#endif
+
+#if defined(__linux__)
+    virtual int handle_event(XEvent& e) = 0;
+#endif
+
+    virtual int init() = 0;
+    virtual int render() = 0;
+
+    virtual void idle() = 0;
+
+#if defined(_WIN32)
+    HINSTANCE     m_hInstance;
+    HWND          m_hWnd;
+#elif defined(__linux__)
+    Display*      m_display;
+    XVisualInfo*  m_visual_info;
+    Window        m_window;
+    long          m_event_mask;
+    Atom          m_WM_DELETE_WINDOW;
+    bool          m_end_loop;
+#endif
+    int           m_width;
+    int           m_height;
+    std::string   m_window_name;
+    cv::TickMeter m_timer;
+};
diff --git a/C++/opencv-4.7.0/samples/openvx/CMakeLists.txt b/C++/opencv-4.7.0/samples/openvx/CMakeLists.txt
new file mode 100644
index 00000000..fd04e6b9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/openvx/CMakeLists.txt
@@ -0,0 +1,25 @@
+ocv_install_example_src(cpp *.cpp *.hpp CMakeLists.txt)
+
+cmake_minimum_required(VERSION 2.8.12.2)
+
+set(OPENCV_OPENVX_SAMPLE_REQUIRED_DEPS
+  opencv_core
+  opencv_imgproc
+  opencv_imgcodecs
+  opencv_videoio
+  opencv_highgui)
+ocv_check_dependencies(${OPENCV_OPENVX_SAMPLE_REQUIRED_DEPS})
+
+if(NOT BUILD_EXAMPLES OR NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+project(openvx_samples)
+ocv_include_modules_recurse(${OPENCV_OPENVX_SAMPLE_REQUIRED_DEPS})
+add_definitions(-DIVX_USE_OPENCV)
+add_definitions(-DIVX_HIDE_INFO_WARNINGS)
+file(GLOB_RECURSE cpp_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+foreach(sample_filename ${cpp_samples})
+  ocv_define_sample(tgt ${sample_filename} openvx)
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_OPENVX_SAMPLE_REQUIRED_DEPS})
+endforeach()
diff --git a/C++/opencv-4.7.0/samples/openvx/no_wrappers.cpp b/C++/opencv-4.7.0/samples/openvx/no_wrappers.cpp
new file mode 100644
index 00000000..7809f7b9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/openvx/no_wrappers.cpp
@@ -0,0 +1,385 @@
+#include <iostream>
+#include <stdexcept>
+
+//OpenVX includes
+#include <VX/vx.h>
+
+//OpenCV includes
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#ifndef VX_VERSION_1_1
+const vx_enum VX_IMAGE_FORMAT = VX_IMAGE_ATTRIBUTE_FORMAT;
+const vx_enum VX_IMAGE_WIDTH  = VX_IMAGE_ATTRIBUTE_WIDTH;
+const vx_enum VX_IMAGE_HEIGHT = VX_IMAGE_ATTRIBUTE_HEIGHT;
+const vx_enum VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST;
+const vx_enum VX_MEMORY_TYPE_NONE = VX_IMPORT_TYPE_NONE;
+const vx_enum VX_THRESHOLD_THRESHOLD_VALUE = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_VALUE;
+const vx_enum VX_THRESHOLD_THRESHOLD_LOWER = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_LOWER;
+const vx_enum VX_THRESHOLD_THRESHOLD_UPPER = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_UPPER;
+typedef uintptr_t vx_map_id;
+#endif
+
+enum UserMemoryMode
+{
+    COPY, USER_MEM
+};
+
+vx_image convertCvMatToVxImage(vx_context context, cv::Mat image, bool toCopy);
+cv::Mat copyVxImageToCvMat(vx_image ovxImage);
+void swapVxImage(vx_image ovxImage);
+vx_status createProcessingGraph(vx_image inputImage, vx_image outputImage, vx_graph& graph);
+int ovxDemo(std::string inputPath, UserMemoryMode mode);
+
+
+vx_image convertCvMatToVxImage(vx_context context, cv::Mat image, bool toCopy)
+{
+    if (!(!image.empty() && image.dims <= 2 && image.channels() == 1))
+        throw std::runtime_error("Invalid format");
+
+    vx_uint32 width  = image.cols;
+    vx_uint32 height = image.rows;
+
+    vx_df_image color;
+    switch (image.depth())
+    {
+    case CV_8U:
+        color = VX_DF_IMAGE_U8;
+        break;
+    case CV_16U:
+        color = VX_DF_IMAGE_U16;
+        break;
+    case CV_16S:
+        color = VX_DF_IMAGE_S16;
+        break;
+    case CV_32S:
+        color = VX_DF_IMAGE_S32;
+        break;
+    default:
+        throw std::runtime_error("Invalid format");
+        break;
+    }
+
+    vx_imagepatch_addressing_t addr;
+    addr.dim_x = width;
+    addr.dim_y = height;
+    addr.stride_x = (vx_uint32)image.elemSize();
+    addr.stride_y = (vx_uint32)image.step.p[0];
+    vx_uint8* ovxData = image.data;
+
+    vx_image ovxImage;
+    if (toCopy)
+    {
+        ovxImage = vxCreateImage(context, width, height, color);
+        if (vxGetStatus((vx_reference)ovxImage) != VX_SUCCESS)
+            throw std::runtime_error("Failed to create image");
+        vx_rectangle_t rect;
+
+        vx_status status = vxGetValidRegionImage(ovxImage, &rect);
+        if (status != VX_SUCCESS)
+            throw std::runtime_error("Failed to get valid region");
+
+#ifdef VX_VERSION_1_1
+        status = vxCopyImagePatch(ovxImage, &rect, 0, &addr, ovxData, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST);
+        if (status != VX_SUCCESS)
+            throw std::runtime_error("Failed to copy image patch");
+#else
+        status = vxAccessImagePatch(ovxImage, &rect, 0, &addr, (void**)&ovxData, VX_WRITE_ONLY);
+        if (status != VX_SUCCESS)
+            throw std::runtime_error("Failed to access image patch");
+        status = vxCommitImagePatch(ovxImage, &rect, 0, &addr, ovxData);
+        if (status != VX_SUCCESS)
+            throw std::runtime_error("Failed to commit image patch");
+#endif
+    }
+    else
+    {
+        ovxImage = vxCreateImageFromHandle(context, color, &addr, (void**)&ovxData, VX_MEMORY_TYPE_HOST);
+        if (vxGetStatus((vx_reference)ovxImage) != VX_SUCCESS)
+            throw std::runtime_error("Failed to create image from handle");
+    }
+
+    return ovxImage;
+}
+
+
+cv::Mat copyVxImageToCvMat(vx_image ovxImage)
+{
+    vx_status status;
+    vx_df_image df_image = 0;
+    vx_uint32 width, height;
+    status = vxQueryImage(ovxImage, VX_IMAGE_FORMAT, &df_image, sizeof(vx_df_image));
+    if (status != VX_SUCCESS)
+        throw std::runtime_error("Failed to query image");
+    status = vxQueryImage(ovxImage, VX_IMAGE_WIDTH, &width, sizeof(vx_uint32));
+    if (status != VX_SUCCESS)
+        throw std::runtime_error("Failed to query image");
+    status = vxQueryImage(ovxImage, VX_IMAGE_HEIGHT, &height, sizeof(vx_uint32));
+    if (status != VX_SUCCESS)
+        throw std::runtime_error("Failed to query image");
+
+    if (!(width > 0 && height > 0)) throw std::runtime_error("Invalid format");
+
+    int depth;
+    switch (df_image)
+    {
+    case VX_DF_IMAGE_U8:
+        depth = CV_8U;
+        break;
+    case VX_DF_IMAGE_U16:
+        depth = CV_16U;
+        break;
+    case VX_DF_IMAGE_S16:
+        depth = CV_16S;
+        break;
+    case VX_DF_IMAGE_S32:
+        depth = CV_32S;
+        break;
+    default:
+        throw std::runtime_error("Invalid format");
+        break;
+    }
+
+    cv::Mat image(height, width, CV_MAKE_TYPE(depth, 1));
+
+    vx_rectangle_t rect;
+    rect.start_x = rect.start_y = 0;
+    rect.end_x = width; rect.end_y = height;
+
+    vx_imagepatch_addressing_t addr;
+    addr.dim_x = width;
+    addr.dim_y = height;
+    addr.stride_x = (vx_uint32)image.elemSize();
+    addr.stride_y = (vx_uint32)image.step.p[0];
+    vx_uint8* matData = image.data;
+
+#ifdef VX_VERSION_1_1
+    status = vxCopyImagePatch(ovxImage, &rect, 0, &addr, matData, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
+    if (status != VX_SUCCESS)
+        throw std::runtime_error("Failed to copy image patch");
+#else
+    status = vxAccessImagePatch(ovxImage, &rect, 0, &addr, (void**)&matData, VX_READ_ONLY);
+    if (status != VX_SUCCESS)
+        throw std::runtime_error("Failed to access image patch");
+    status = vxCommitImagePatch(ovxImage, &rect, 0, &addr, matData);
+    if (status != VX_SUCCESS)
+        throw std::runtime_error("Failed to commit image patch");
+#endif
+
+    return image;
+}
+
+
+void swapVxImage(vx_image ovxImage)
+{
+#ifdef VX_VERSION_1_1
+    vx_status status;
+    vx_memory_type_e memType;
+    status = vxQueryImage(ovxImage, VX_IMAGE_MEMORY_TYPE, &memType, sizeof(vx_memory_type_e));
+    if (status != VX_SUCCESS)
+        throw std::runtime_error("Failed to query image");
+    if (memType == VX_MEMORY_TYPE_NONE)
+    {
+        //was created by copying user data
+        throw std::runtime_error("Image wasn't created from user handle");
+    }
+    else
+    {
+        //was created from user handle
+        status = vxSwapImageHandle(ovxImage, NULL, NULL, 0);
+        if (status != VX_SUCCESS)
+            throw std::runtime_error("Failed to swap image handle");
+    }
+#else
+    //not supported until OpenVX 1.1
+    (void) ovxImage;
+#endif
+}
+
+
+vx_status createProcessingGraph(vx_image inputImage, vx_image outputImage, vx_graph& graph)
+{
+    vx_status status;
+    vx_context context = vxGetContext((vx_reference)inputImage);
+    status = vxGetStatus((vx_reference)context);
+    if(status != VX_SUCCESS) return status;
+
+    graph = vxCreateGraph(context);
+    status = vxGetStatus((vx_reference)graph);
+    if (status != VX_SUCCESS) return status;
+
+    vx_uint32 width, height;
+    status = vxQueryImage(inputImage, VX_IMAGE_WIDTH, &width, sizeof(vx_uint32));
+    if (status != VX_SUCCESS) return status;
+    status = vxQueryImage(inputImage, VX_IMAGE_HEIGHT, &height, sizeof(vx_uint32));
+    if (status != VX_SUCCESS) return status;
+
+    // Intermediate images
+    vx_image
+        smoothed  = vxCreateVirtualImage(graph, 0, 0, VX_DF_IMAGE_VIRT),
+        cannied   = vxCreateVirtualImage(graph, 0, 0, VX_DF_IMAGE_VIRT),
+        halfImg   = vxCreateImage(context, width, height, VX_DF_IMAGE_U8),
+        halfCanny = vxCreateImage(context, width, height, VX_DF_IMAGE_U8);
+
+    vx_image virtualImages[] = {smoothed, cannied, halfImg, halfCanny};
+    for(size_t i = 0; i < sizeof(virtualImages)/sizeof(vx_image); i++)
+    {
+        status = vxGetStatus((vx_reference)virtualImages[i]);
+        if (status != VX_SUCCESS) return status;
+    }
+
+    // Constants
+    vx_uint32 threshValue = 50;
+    vx_threshold thresh = vxCreateThreshold(context, VX_THRESHOLD_TYPE_BINARY, VX_TYPE_UINT8);
+    vxSetThresholdAttribute(thresh, VX_THRESHOLD_THRESHOLD_VALUE,
+                            &threshValue, sizeof(threshValue));
+
+    vx_uint32 threshCannyMin = 127;
+    vx_uint32 threshCannyMax = 192;
+    vx_threshold threshCanny = vxCreateThreshold(context, VX_THRESHOLD_TYPE_RANGE, VX_TYPE_UINT8);
+    vxSetThresholdAttribute(threshCanny, VX_THRESHOLD_THRESHOLD_LOWER, &threshCannyMin,
+                            sizeof(threshCannyMin));
+    vxSetThresholdAttribute(threshCanny, VX_THRESHOLD_THRESHOLD_UPPER, &threshCannyMax,
+                            sizeof(threshCannyMax));
+    vx_float32 alphaValue = 0.5;
+    vx_scalar alpha = vxCreateScalar(context, VX_TYPE_FLOAT32, &alphaValue);
+
+    // Sequence of meaningless image operations
+    vx_node nodes[] = {
+        vxGaussian3x3Node(graph, inputImage, smoothed),
+        vxCannyEdgeDetectorNode(graph, smoothed, threshCanny, 3, VX_NORM_L2, cannied),
+        vxAccumulateWeightedImageNode(graph, inputImage, alpha, halfImg),
+        vxAccumulateWeightedImageNode(graph, cannied, alpha, halfCanny),
+        vxAddNode(graph, halfImg, halfCanny, VX_CONVERT_POLICY_SATURATE, outputImage)
+    };
+
+    for (size_t i = 0; i < sizeof(nodes) / sizeof(vx_node); i++)
+    {
+        status = vxGetStatus((vx_reference)nodes[i]);
+        if (status != VX_SUCCESS) return status;
+    }
+
+    status = vxVerifyGraph(graph);
+    return status;
+}
+
+
+int ovxDemo(std::string inputPath, UserMemoryMode mode)
+{
+    cv::Mat image = cv::imread(inputPath, cv::IMREAD_GRAYSCALE);
+    if (image.empty()) return -1;
+
+    //check image format
+    if (image.depth() != CV_8U || image.channels() != 1) return -1;
+
+    vx_status status;
+    vx_context context = vxCreateContext();
+    status = vxGetStatus((vx_reference)context);
+    if (status != VX_SUCCESS) return status;
+
+    //put user data from cv::Mat to vx_image
+    vx_image ovxImage;
+    ovxImage = convertCvMatToVxImage(context, image, mode == COPY);
+
+    vx_uint32 width = image.cols, height = image.rows;
+
+    vx_image ovxResult;
+    cv::Mat output;
+    if (mode == COPY)
+    {
+        //we will copy data from vx_image to cv::Mat
+        ovxResult = vxCreateImage(context, width, height, VX_DF_IMAGE_U8);
+        if (vxGetStatus((vx_reference)ovxResult) != VX_SUCCESS)
+            throw std::runtime_error("Failed to create image");
+    }
+    else
+    {
+        //create vx_image based on user data, no copying required
+        output = cv::Mat(height, width, CV_8U, cv::Scalar(0));
+        ovxResult = convertCvMatToVxImage(context, output, false);
+    }
+
+    vx_graph graph;
+    status = createProcessingGraph(ovxImage, ovxResult, graph);
+    if (status != VX_SUCCESS) return status;
+
+    // Graph execution
+    status = vxProcessGraph(graph);
+    if (status != VX_SUCCESS) return status;
+
+    //getting resulting image in cv::Mat
+    if (mode == COPY)
+    {
+        output = copyVxImageToCvMat(ovxResult);
+    }
+    else
+    {
+        //we should take user memory back from vx_image before using it (even before reading)
+        swapVxImage(ovxResult);
+    }
+
+    //here output goes
+    cv::imshow("processing result", output);
+    cv::waitKey(0);
+
+    //we need to take user memory back before releasing the image
+    if (mode == USER_MEM)
+        swapVxImage(ovxImage);
+
+    cv::destroyAllWindows();
+
+    status = vxReleaseContext(&context);
+    return status;
+}
+
+
+int main(int argc, char *argv[])
+{
+    const std::string keys =
+        "{help h usage ? | | }"
+        "{image    | <none> | image to be processed}"
+        "{mode | copy | user memory interaction mode: \n"
+        "copy: create VX images and copy data to/from them\n"
+        "user_mem: use handles to user-allocated memory}"
+        ;
+
+    cv::CommandLineParser parser(argc, argv, keys);
+    parser.about("OpenVX interoperability sample demonstrating standard OpenVX API."
+                 "The application loads an image, processes it with OpenVX graph and outputs result in a window");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    std::string imgPath = parser.get<std::string>("image");
+    std::string modeString = parser.get<std::string>("mode");
+    UserMemoryMode mode;
+    if(modeString == "copy")
+    {
+        mode = COPY;
+    }
+    else if(modeString == "user_mem")
+    {
+        mode = USER_MEM;
+    }
+    else if(modeString == "map")
+    {
+        std::cerr << modeString << " is not implemented in this sample" << std::endl;
+        return -1;
+    }
+    else
+    {
+        std::cerr << modeString << ": unknown memory mode" << std::endl;
+        return -1;
+    }
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    return ovxDemo(imgPath, mode);
+}
diff --git a/C++/opencv-4.7.0/samples/openvx/wrappers.cpp b/C++/opencv-4.7.0/samples/openvx/wrappers.cpp
new file mode 100644
index 00000000..b591862c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/openvx/wrappers.cpp
@@ -0,0 +1,214 @@
+#include <iostream>
+#include <stdexcept>
+
+//wrappers
+#include "ivx.hpp"
+
+//OpenCV includes
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+enum UserMemoryMode
+{
+    COPY, USER_MEM, MAP
+};
+
+ivx::Graph createProcessingGraph(ivx::Image& inputImage, ivx::Image& outputImage);
+int ovxDemo(std::string inputPath, UserMemoryMode mode);
+
+
+ivx::Graph createProcessingGraph(ivx::Image& inputImage, ivx::Image& outputImage)
+{
+    using namespace ivx;
+
+    Context context = inputImage.get<Context>();
+    Graph graph = Graph::create(context);
+
+    vx_uint32 width  = inputImage.width();
+    vx_uint32 height = inputImage.height();
+
+    // Intermediate images
+    Image
+        smoothed  = Image::createVirtual(graph),
+        cannied   = Image::createVirtual(graph),
+        halfImg   = Image::create(context, width, height, VX_DF_IMAGE_U8),
+        halfCanny = Image::create(context, width, height, VX_DF_IMAGE_U8);
+
+    // Constants
+    vx_uint32 threshCannyMin = 127;
+    vx_uint32 threshCannyMax = 192;
+    Threshold threshCanny = Threshold::createRange(context, VX_TYPE_UINT8, threshCannyMin, threshCannyMax);
+
+    ivx::Scalar alpha = ivx::Scalar::create<VX_TYPE_FLOAT32>(context, 0.5);
+
+    // Sequence of some image operations
+    // Node can also be added in function-like style
+    nodes::gaussian3x3(graph, inputImage, smoothed);
+    Node::create(graph, VX_KERNEL_CANNY_EDGE_DETECTOR, smoothed, threshCanny,
+                 ivx::Scalar::create<VX_TYPE_INT32>(context, 3),
+                 ivx::Scalar::create<VX_TYPE_ENUM>(context, VX_NORM_L2), cannied);
+    Node::create(graph, VX_KERNEL_ACCUMULATE_WEIGHTED, inputImage, alpha, halfImg);
+    Node::create(graph, VX_KERNEL_ACCUMULATE_WEIGHTED, cannied, alpha, halfCanny);
+    Node::create(graph, VX_KERNEL_ADD, halfImg, halfCanny,
+                 ivx::Scalar::create<VX_TYPE_ENUM>(context, VX_CONVERT_POLICY_SATURATE), outputImage);
+
+    graph.verify();
+
+    return graph;
+}
+
+
+int ovxDemo(std::string inputPath, UserMemoryMode mode)
+{
+    using namespace cv;
+    using namespace ivx;
+
+    Mat image = imread(inputPath, IMREAD_GRAYSCALE);
+    if (image.empty()) return -1;
+
+    //check image format
+    if (image.depth() != CV_8U || image.channels() != 1) return -1;
+
+    try
+    {
+        Context context = Context::create();
+        //put user data from cv::Mat to vx_image
+        vx_df_image color = Image::matTypeToFormat(image.type());
+        vx_uint32 width = image.cols, height = image.rows;
+        Image ivxImage;
+        if (mode == COPY)
+        {
+            ivxImage = Image::create(context, width, height, color);
+            ivxImage.copyFrom(0, image);
+        }
+        else
+        {
+            ivxImage = Image::createFromHandle(context, color, Image::createAddressing(image), image.data);
+        }
+
+        Image ivxResult;
+        Image::Patch resultPatch;
+        Mat output;
+        if (mode == COPY || mode == MAP)
+        {
+            //we will copy or map data from vx_image to cv::Mat
+            ivxResult = ivx::Image::create(context, width, height, VX_DF_IMAGE_U8);
+        }
+        else // if (mode == MAP_TO_VX)
+        {
+            //create vx_image based on user data, no copying required
+            output = cv::Mat(height, width, CV_8U, cv::Scalar(0));
+            ivxResult = Image::createFromHandle(context, Image::matTypeToFormat(CV_8U),
+                                                Image::createAddressing(output), output.data);
+        }
+
+        Graph graph = createProcessingGraph(ivxImage, ivxResult);
+
+        // Graph execution
+        graph.process();
+
+        //getting resulting image in cv::Mat
+        if (mode == COPY)
+        {
+            ivxResult.copyTo(0, output);
+        }
+        else if (mode == MAP)
+        {
+            //create cv::Mat based on vx_image mapped data
+            resultPatch.map(ivxResult, 0, ivxResult.getValidRegion());
+            //generally this is very bad idea!
+            //but in our case unmap() won't happen until output is in use
+            output = resultPatch.getMat();
+        }
+        else // if (mode == MAP_TO_VX)
+        {
+#ifdef VX_VERSION_1_1
+            //we should take user memory back from vx_image before using it (even before reading)
+            ivxResult.swapHandle();
+#endif
+        }
+
+        //here output goes
+        cv::imshow("processing result", output);
+        cv::waitKey(0);
+
+        cv::destroyAllWindows();
+
+#ifdef VX_VERSION_1_1
+        if (mode != COPY)
+        {
+            //we should take user memory back before release
+            //(it's not done automatically according to standard)
+            ivxImage.swapHandle();
+            if (mode == USER_MEM) ivxResult.swapHandle();
+        }
+#endif
+
+        //the line is unnecessary since unmapping is done on destruction of patch
+        //resultPatch.unmap();
+    }
+    catch (const ivx::RuntimeError& e)
+    {
+        std::cerr << "Error: code = " << e.status() << ", message = " << e.what() << std::endl;
+        return e.status();
+    }
+    catch (const ivx::WrapperError& e)
+    {
+        std::cerr << "Error: message = " << e.what() << std::endl;
+        return -1;
+    }
+
+    return 0;
+}
+
+
+int main(int argc, char *argv[])
+{
+    const std::string keys =
+        "{help h usage ? | | }"
+        "{image    | <none> | image to be processed}"
+        "{mode | copy | user memory interaction mode: \n"
+        "copy: create VX images and copy data to/from them\n"
+        "user_mem: use handles to user-allocated memory\n"
+        "map: map resulting VX image to user memory}"
+        ;
+
+    cv::CommandLineParser parser(argc, argv, keys);
+    parser.about("OpenVX interoperability sample demonstrating OpenVX wrappers usage."
+                 "The application loads an image, processes it with OpenVX graph and outputs result in a window");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    std::string imgPath = parser.get<std::string>("image");
+    std::string modeString = parser.get<std::string>("mode");
+    UserMemoryMode mode;
+    if(modeString == "copy")
+    {
+        mode = COPY;
+    }
+    else if(modeString == "user_mem")
+    {
+        mode = USER_MEM;
+    }
+    else if(modeString == "map")
+    {
+        mode = MAP;
+    }
+    else
+    {
+        std::cerr << modeString << ": unknown memory mode" << std::endl;
+        return -1;
+    }
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    return ovxDemo(imgPath, mode);
+}
diff --git a/C++/opencv-4.7.0/samples/openvx/wrappers_video.cpp b/C++/opencv-4.7.0/samples/openvx/wrappers_video.cpp
new file mode 100644
index 00000000..737f052b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/openvx/wrappers_video.cpp
@@ -0,0 +1,250 @@
+#include <iostream>
+#include <stdexcept>
+
+//wrappers
+#include "ivx.hpp"
+
+//OpenCV includes
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+enum UserMemoryMode
+{
+    COPY, USER_MEM, MAP
+};
+
+ivx::Graph createProcessingGraph(ivx::Image& inputImage, ivx::Image& outputImage);
+int ovxDemo(std::string inputPath, UserMemoryMode mode);
+
+
+ivx::Graph createProcessingGraph(ivx::Image& inputImage, ivx::Image& outputImage)
+{
+    using namespace ivx;
+
+    Context context = inputImage.get<Context>();
+    Graph graph = Graph::create(context);
+
+    vx_uint32 width  = inputImage.width();
+    vx_uint32 height = inputImage.height();
+
+    // Intermediate images
+    Image
+        yuv       = Image::createVirtual(graph, 0, 0, VX_DF_IMAGE_YUV4),
+        gray      = Image::createVirtual(graph),
+        smoothed  = Image::createVirtual(graph),
+        cannied   = Image::createVirtual(graph),
+        halfImg   = Image::create(context, width, height, VX_DF_IMAGE_U8),
+        halfCanny = Image::create(context, width, height, VX_DF_IMAGE_U8);
+
+    // Constants
+    vx_uint32 threshCannyMin = 127;
+    vx_uint32 threshCannyMax = 192;
+    Threshold threshCanny = Threshold::createRange(context, VX_TYPE_UINT8, threshCannyMin, threshCannyMax);
+
+    ivx::Scalar alpha = ivx::Scalar::create<VX_TYPE_FLOAT32>(context, 0.5);
+
+    // Sequence of some image operations
+    Node::create(graph, VX_KERNEL_COLOR_CONVERT, inputImage, yuv);
+    Node::create(graph, VX_KERNEL_CHANNEL_EXTRACT, yuv,
+                 ivx::Scalar::create<VX_TYPE_ENUM>(context, VX_CHANNEL_Y), gray);
+    //node can also be added in function-like style
+    nodes::gaussian3x3(graph, gray, smoothed);
+    Node::create(graph, VX_KERNEL_CANNY_EDGE_DETECTOR, smoothed, threshCanny,
+                 ivx::Scalar::create<VX_TYPE_INT32>(context, 3),
+                 ivx::Scalar::create<VX_TYPE_ENUM>(context, VX_NORM_L2), cannied);
+    Node::create(graph, VX_KERNEL_ACCUMULATE_WEIGHTED, gray, alpha, halfImg);
+    Node::create(graph, VX_KERNEL_ACCUMULATE_WEIGHTED, cannied, alpha, halfCanny);
+    Node::create(graph, VX_KERNEL_ADD, halfImg, halfCanny,
+                 ivx::Scalar::create<VX_TYPE_ENUM>(context, VX_CONVERT_POLICY_SATURATE), outputImage);
+
+    graph.verify();
+
+    return graph;
+}
+
+
+int ovxDemo(std::string inputPath, UserMemoryMode mode)
+{
+    using namespace cv;
+    using namespace ivx;
+
+    Mat frame;
+    VideoCapture vc(inputPath);
+    if (!vc.isOpened())
+        return -1;
+
+    vc >> frame;
+    if (frame.empty()) return -1;
+
+    //check frame format
+    if (frame.type() != CV_8UC3) return -1;
+
+    try
+    {
+        Context context = Context::create();
+        //put user data from cv::Mat to vx_image
+        vx_df_image color = Image::matTypeToFormat(frame.type());
+        vx_uint32 width = frame.cols, height = frame.rows;
+        Image ivxImage;
+        if (mode == COPY)
+        {
+            ivxImage = Image::create(context, width, height, color);
+        }
+        else
+        {
+            ivxImage = Image::createFromHandle(context, color, Image::createAddressing(frame), frame.data);
+        }
+
+        Image ivxResult;
+
+        Mat output;
+        if (mode == COPY || mode == MAP)
+        {
+            //we will copy or map data from vx_image to cv::Mat
+            ivxResult = ivx::Image::create(context, width, height, VX_DF_IMAGE_U8);
+        }
+        else // if (mode == MAP_TO_VX)
+        {
+            //create vx_image based on user data, no copying required
+            output = cv::Mat(height, width, CV_8U, cv::Scalar(0));
+            ivxResult = Image::createFromHandle(context, Image::matTypeToFormat(CV_8U),
+                                                Image::createAddressing(output), output.data);
+        }
+
+        Graph graph = createProcessingGraph(ivxImage, ivxResult);
+
+        bool stop = false;
+        while (!stop)
+        {
+            if (mode == COPY) ivxImage.copyFrom(0, frame);
+
+            // Graph execution
+            graph.process();
+
+            //getting resulting image in cv::Mat
+            Image::Patch resultPatch;
+            std::vector<void*> ptrs;
+            std::vector<void*> prevPtrs(ivxResult.planes());
+            if (mode == COPY)
+            {
+                ivxResult.copyTo(0, output);
+            }
+            else if (mode == MAP)
+            {
+                //create cv::Mat based on vx_image mapped data
+                resultPatch.map(ivxResult, 0, ivxResult.getValidRegion(), VX_READ_AND_WRITE);
+                //generally this is very bad idea!
+                //but in our case unmap() won't happen until output is in use
+                output = resultPatch.getMat();
+            }
+            else // if(mode == MAP_TO_VX)
+            {
+#ifdef VX_VERSION_1_1
+                //we should take user memory back from vx_image before using it (even before reading)
+                ivxResult.swapHandle(ptrs, prevPtrs);
+#endif
+            }
+
+            //here output goes
+            imshow("press q to quit", output);
+            if ((char)waitKey(1) == 'q') stop = true;
+
+#ifdef VX_VERSION_1_1
+            //restore handle
+            if (mode == USER_MEM)
+            {
+                ivxResult.swapHandle(prevPtrs, ptrs);
+            }
+#endif
+
+            //this line is unnecessary since unmapping is done on destruction of patch
+            //resultPatch.unmap();
+
+            //grab next frame
+            Mat temp = frame;
+            vc >> frame;
+            if (frame.empty()) stop = true;
+            if (mode != COPY && frame.data != temp.data)
+            {
+                //frame was reallocated, pointer to data changed
+                frame.copyTo(temp);
+            }
+        }
+
+        destroyAllWindows();
+
+#ifdef VX_VERSION_1_1
+        if (mode != COPY)
+        {
+            //we should take user memory back before release
+            //(it's not done automatically according to standard)
+            ivxImage.swapHandle();
+            if (mode == USER_MEM) ivxResult.swapHandle();
+        }
+#endif
+    }
+    catch (const ivx::RuntimeError& e)
+    {
+        std::cerr << "Error: code = " << e.status() << ", message = " << e.what() << std::endl;
+        return e.status();
+    }
+    catch (const ivx::WrapperError& e)
+    {
+        std::cerr << "Error: message = " << e.what() << std::endl;
+        return -1;
+    }
+
+    return 0;
+}
+
+
+int main(int argc, char *argv[])
+{
+    const std::string keys =
+        "{help h usage ? | | }"
+        "{video    | <none> | video file to be processed}"
+        "{mode | copy | user memory interaction mode: \n"
+        "copy: create VX images and copy data to/from them\n"
+        "user_mem: use handles to user-allocated memory\n"
+        "map: map resulting VX image to user memory}"
+        ;
+
+    cv::CommandLineParser parser(argc, argv, keys);
+    parser.about("OpenVX interoperability sample demonstrating OpenVX wrappers usage."
+                 "The application opens a video and processes it with OpenVX graph while outputting result in a window");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    std::string videoPath = parser.get<std::string>("video");
+    std::string modeString = parser.get<std::string>("mode");
+    UserMemoryMode mode;
+    if(modeString == "copy")
+    {
+        mode = COPY;
+    }
+    else if(modeString == "user_mem")
+    {
+        mode = USER_MEM;
+    }
+    else if(modeString == "map")
+    {
+        mode = MAP;
+    }
+    else
+    {
+        std::cerr << modeString << ": unknown memory mode" << std::endl;
+        return -1;
+    }
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    return ovxDemo(videoPath, mode);
+}
diff --git a/C++/opencv-4.7.0/samples/python/CMakeLists.txt b/C++/opencv-4.7.0/samples/python/CMakeLists.txt
new file mode 100644
index 00000000..31c2bd18
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/CMakeLists.txt
@@ -0,0 +1,6 @@
+if(INSTALL_PYTHON_EXAMPLES)
+  file(GLOB install_list *.py )
+  install(FILES ${install_list}
+          DESTINATION ${OPENCV_SAMPLES_SRC_INSTALL_PATH}/python
+          PERMISSIONS OWNER_READ GROUP_READ WORLD_READ COMPONENT samples)
+endif()
diff --git a/C++/opencv-4.7.0/samples/python/_coverage.py b/C++/opencv-4.7.0/samples/python/_coverage.py
new file mode 100644
index 00000000..62dd7aa5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/_coverage.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+'''
+Utility for measuring python opencv API coverage by samples.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+from glob import glob
+import cv2 as cv
+import re
+
+if __name__ == '__main__':
+    cv2_callable = set(['cv.'+name for name in dir(cv) if callable( getattr(cv, name) )])
+
+    found = set()
+    for fn in glob('*.py'):
+        print(' --- ', fn)
+        code = open(fn).read()
+        found |= set(re.findall('cv2?\.\w+', code))
+
+    cv2_used = found & cv2_callable
+    cv2_unused = cv2_callable - cv2_used
+    with open('unused_api.txt', 'w') as f:
+        f.write('\n'.join(sorted(cv2_unused)))
+
+    r = 1.0 * len(cv2_used) / len(cv2_callable)
+    print('\ncv api coverage: %d / %d  (%.1f%%)' % ( len(cv2_used), len(cv2_callable), r*100 ))
diff --git a/C++/opencv-4.7.0/samples/python/_doc.py b/C++/opencv-4.7.0/samples/python/_doc.py
new file mode 100644
index 00000000..02c733cf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/_doc.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+
+'''
+Scans current directory for *.py files and reports
+ones with missing __doc__ string.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+from glob import glob
+
+if __name__ == '__main__':
+    print('--- undocumented files:')
+    for fn in glob('*.py'):
+        loc = {}
+        try:
+            try:
+                execfile(fn, loc)           # Python 2
+            except NameError:
+                exec(open(fn).read(), loc)  # Python 3
+        except Exception:
+            pass
+        if '__doc__' not in loc:
+            print(fn)
diff --git a/C++/opencv-4.7.0/samples/python/_run_winpack_demo.cmd b/C++/opencv-4.7.0/samples/python/_run_winpack_demo.cmd
new file mode 100644
index 00000000..afc314bd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/_run_winpack_demo.cmd
@@ -0,0 +1,3 @@
+@echo off
+call ..\_winpack_run_python_sample.cmd %*
+exit /B
diff --git a/C++/opencv-4.7.0/samples/python/asift.py b/C++/opencv-4.7.0/samples/python/asift.py
new file mode 100644
index 00000000..e21ef5b0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/asift.py
@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+
+'''
+Affine invariant feature-based image matching sample.
+
+This sample is similar to find_obj.py, but uses the affine transformation
+space sampling technique, called ASIFT [1]. While the original implementation
+is based on SIFT, you can try to use SURF or ORB detectors instead. Homography RANSAC
+is used to reject outliers. Threading is used for faster affine sampling.
+
+[1] http://www.ipol.im/pub/algo/my_affine_sift/
+
+USAGE
+  asift.py [--feature=<sift|surf|orb|brisk>[-flann]] [ <image1> <image2> ]
+
+  --feature  - Feature to use. Can be sift, surf, orb or brisk. Append '-flann'
+               to feature name to use Flann-based matcher instead bruteforce.
+
+  Press left mouse button on a feature point to see its matching point.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+# built-in modules
+import itertools as it
+from multiprocessing.pool import ThreadPool
+
+# local modules
+from common import Timer
+from find_obj import init_feature, filter_matches, explore_match
+
+
+def affine_skew(tilt, phi, img, mask=None):
+    '''
+    affine_skew(tilt, phi, img, mask=None) -> skew_img, skew_mask, Ai
+
+    Ai - is an affine transform matrix from skew_img to img
+    '''
+    h, w = img.shape[:2]
+    if mask is None:
+        mask = np.zeros((h, w), np.uint8)
+        mask[:] = 255
+    A = np.float32([[1, 0, 0], [0, 1, 0]])
+    if phi != 0.0:
+        phi = np.deg2rad(phi)
+        s, c = np.sin(phi), np.cos(phi)
+        A = np.float32([[c,-s], [ s, c]])
+        corners = [[0, 0], [w, 0], [w, h], [0, h]]
+        tcorners = np.int32( np.dot(corners, A.T) )
+        x, y, w, h = cv.boundingRect(tcorners.reshape(1,-1,2))
+        A = np.hstack([A, [[-x], [-y]]])
+        img = cv.warpAffine(img, A, (w, h), flags=cv.INTER_LINEAR, borderMode=cv.BORDER_REPLICATE)
+    if tilt != 1.0:
+        s = 0.8*np.sqrt(tilt*tilt-1)
+        img = cv.GaussianBlur(img, (0, 0), sigmaX=s, sigmaY=0.01)
+        img = cv.resize(img, (0, 0), fx=1.0/tilt, fy=1.0, interpolation=cv.INTER_NEAREST)
+        A[0] /= tilt
+    if phi != 0.0 or tilt != 1.0:
+        h, w = img.shape[:2]
+        mask = cv.warpAffine(mask, A, (w, h), flags=cv.INTER_NEAREST)
+    Ai = cv.invertAffineTransform(A)
+    return img, mask, Ai
+
+
+def affine_detect(detector, img, mask=None, pool=None):
+    '''
+    affine_detect(detector, img, mask=None, pool=None) -> keypoints, descrs
+
+    Apply a set of affine transformations to the image, detect keypoints and
+    reproject them into initial image coordinates.
+    See http://www.ipol.im/pub/algo/my_affine_sift/ for the details.
+
+    ThreadPool object may be passed to speedup the computation.
+    '''
+    params = [(1.0, 0.0)]
+    for t in 2**(0.5*np.arange(1,6)):
+        for phi in np.arange(0, 180, 72.0 / t):
+            params.append((t, phi))
+
+    def f(p):
+        t, phi = p
+        timg, tmask, Ai = affine_skew(t, phi, img)
+        keypoints, descrs = detector.detectAndCompute(timg, tmask)
+        for kp in keypoints:
+            x, y = kp.pt
+            kp.pt = tuple( np.dot(Ai, (x, y, 1)) )
+        if descrs is None:
+            descrs = []
+        return keypoints, descrs
+
+    keypoints, descrs = [], []
+    if pool is None:
+        ires = it.imap(f, params)
+    else:
+        ires = pool.imap(f, params)
+
+    for i, (k, d) in enumerate(ires):
+        print('affine sampling: %d / %d\r' % (i+1, len(params)), end='')
+        keypoints.extend(k)
+        descrs.extend(d)
+
+    print()
+    return keypoints, np.array(descrs)
+
+
+def main():
+    import sys, getopt
+    opts, args = getopt.getopt(sys.argv[1:], '', ['feature='])
+    opts = dict(opts)
+    feature_name = opts.get('--feature', 'brisk-flann')
+    try:
+        fn1, fn2 = args
+    except:
+        fn1 = 'aero1.jpg'
+        fn2 = 'aero3.jpg'
+
+    img1 = cv.imread(cv.samples.findFile(fn1), cv.IMREAD_GRAYSCALE)
+    img2 = cv.imread(cv.samples.findFile(fn2), cv.IMREAD_GRAYSCALE)
+    detector, matcher = init_feature(feature_name)
+
+    if img1 is None:
+        print('Failed to load fn1:', fn1)
+        sys.exit(1)
+
+    if img2 is None:
+        print('Failed to load fn2:', fn2)
+        sys.exit(1)
+
+    if detector is None:
+        print('unknown feature:', feature_name)
+        sys.exit(1)
+
+    print('using', feature_name)
+
+    pool=ThreadPool(processes = cv.getNumberOfCPUs())
+    kp1, desc1 = affine_detect(detector, img1, pool=pool)
+    kp2, desc2 = affine_detect(detector, img2, pool=pool)
+    print('img1 - %d features, img2 - %d features' % (len(kp1), len(kp2)))
+
+    def match_and_draw(win):
+        with Timer('matching'):
+            raw_matches = matcher.knnMatch(desc1, trainDescriptors = desc2, k = 2) #2
+        p1, p2, kp_pairs = filter_matches(kp1, kp2, raw_matches)
+        if len(p1) >= 4:
+            H, status = cv.findHomography(p1, p2, cv.RANSAC, 5.0)
+            print('%d / %d  inliers/matched' % (np.sum(status), len(status)))
+            # do not draw outliers (there will be a lot of them)
+            kp_pairs = [kpp for kpp, flag in zip(kp_pairs, status) if flag]
+        else:
+            H, status = None, None
+            print('%d matches found, not enough for homography estimation' % len(p1))
+
+        explore_match(win, img1, img2, kp_pairs, None, H)
+
+
+    match_and_draw('affine find_obj')
+    cv.waitKey()
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/audio_spectrogram.py b/C++/opencv-4.7.0/samples/python/audio_spectrogram.py
new file mode 100644
index 00000000..f211bbb5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/audio_spectrogram.py
@@ -0,0 +1,804 @@
+import numpy as np
+import cv2 as cv
+import math
+import argparse
+
+class AudioDrawing:
+    '''
+        Used for drawing audio graphics
+    '''
+    def __init__(self, args):
+
+        self.inputType = args.inputType
+        self.draw = args.draw
+        self.graph = args.graph
+        self.audio = cv.samples.findFile(args.audio)
+        self.audioStream = args.audioStream
+
+        self.windowType = args.windowType
+        self.windLen = args.windLen
+        self.overlap = args.overlap
+
+        self.enableGrid = args.enableGrid
+
+        self.rows = args.rows
+        self.cols = args.cols
+
+        self.xmarkup = args.xmarkup
+        self.ymarkup = args.ymarkup
+        self.zmarkup = args.zmarkup
+
+        self.microTime = args.microTime
+        self.frameSizeTime = args.frameSizeTime
+        self.updateTime = args.updateTime
+        self.waitTime = args.waitTime
+
+        if self.initAndCheckArgs(args) is False:
+            exit()
+
+
+    def Draw(self):
+        if self.draw == "static":
+
+            if self.inputType == "file":
+                samplingRate, inputAudio = self.readAudioFile(self.audio)
+
+            elif self.inputType == "microphone":
+                samplingRate, inputAudio = self.readAudioMicrophone()
+
+            duration = len(inputAudio) // samplingRate
+
+            # since the dimensional grid is counted in integer seconds,
+            # if the input audio has an incomplete last second,
+            # then it is filled with zeros to complete
+            remainder = len(inputAudio) % samplingRate
+            if remainder != 0:
+                sizeToFullSec = samplingRate - remainder
+                zeroArr = np.zeros(sizeToFullSec)
+                inputAudio = np.concatenate((inputAudio, zeroArr), axis=0)
+                duration += 1
+                print("Update duration of audio to full second with ",
+                    sizeToFullSec, " zero samples")
+                print("New number of samples ", len(inputAudio))
+
+            if duration <= self.xmarkup:
+                self.xmarkup = duration + 1
+
+            if self.graph == "ampl":
+                imgAmplitude = self.drawAmplitude(inputAudio)
+                imgAmplitude = self.drawAmplitudeScale(imgAmplitude, inputAudio, samplingRate)
+                cv.imshow("Display window", imgAmplitude)
+                cv.waitKey(0)
+
+            elif self.graph == "spec":
+                stft = self.STFT(inputAudio)
+                imgSpec = self.drawSpectrogram(stft)
+                imgSpec = self.drawSpectrogramColorbar(imgSpec, inputAudio, samplingRate, stft)
+                cv.imshow("Display window", imgSpec)
+                cv.waitKey(0)
+
+            elif self.graph == "ampl_and_spec":
+                imgAmplitude = self.drawAmplitude(inputAudio)
+                imgAmplitude = self.drawAmplitudeScale(imgAmplitude, inputAudio, samplingRate)
+
+                stft = self.STFT(inputAudio)
+                imgSpec = self.drawSpectrogram(stft)
+                imgSpec = self.drawSpectrogramColorbar(imgSpec, inputAudio, samplingRate, stft)
+
+                imgTotal = self.concatenateImages(imgAmplitude, imgSpec)
+                cv.imshow("Display window", imgTotal)
+                cv.waitKey(0)
+
+        elif self.draw == "dynamic":
+
+            if self.inputType == "file":
+                self.dynamicFile(self.audio)
+
+            elif self.inputType == "microphone":
+                self.dynamicMicrophone()
+
+
+    def readAudioFile(self, file):
+        cap = cv.VideoCapture(file)
+
+        params = [cv.CAP_PROP_AUDIO_STREAM, self.audioStream,
+                cv.CAP_PROP_VIDEO_STREAM, -1,
+                cv.CAP_PROP_AUDIO_DATA_DEPTH, cv.CV_16S]
+        params = np.asarray(params)
+
+        cap.open(file, cv.CAP_ANY, params)
+        if cap.isOpened() == False:
+            print("Error : Can't read audio file: '", self.audio, "' with audioStream = ", self.audioStream)
+            print("Error: problems with audio reading, check input arguments")
+            exit()
+        audioBaseIndex = int(cap.get(cv.CAP_PROP_AUDIO_BASE_INDEX))
+        numberOfChannels = int(cap.get(cv.CAP_PROP_AUDIO_TOTAL_CHANNELS))
+
+        print("CAP_PROP_AUDIO_DATA_DEPTH: ", str((int(cap.get(cv.CAP_PROP_AUDIO_DATA_DEPTH)))))
+        print("CAP_PROP_AUDIO_SAMPLES_PER_SECOND: ", cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND))
+        print("CAP_PROP_AUDIO_TOTAL_CHANNELS: ", numberOfChannels)
+        print("CAP_PROP_AUDIO_TOTAL_STREAMS: ", cap.get(cv.CAP_PROP_AUDIO_TOTAL_STREAMS))
+
+        frame = []
+        frame = np.asarray(frame)
+        inputAudio = []
+
+        while (1):
+            if (cap.grab()):
+                frame = []
+                frame = np.asarray(frame)
+                frame = cap.retrieve(frame, audioBaseIndex)
+                for i in range(len(frame[1][0])):
+                    inputAudio.append(frame[1][0][i])
+            else:
+                break
+
+        inputAudio = np.asarray(inputAudio)
+        print("Number of samples: ", len(inputAudio))
+        samplingRate = int(cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND))
+        return samplingRate, inputAudio
+
+
+    def readAudioMicrophone(self):
+        cap = cv.VideoCapture()
+
+        params = [cv.CAP_PROP_AUDIO_STREAM, 0, cv.CAP_PROP_VIDEO_STREAM, -1]
+        params = np.asarray(params)
+
+        cap.open(0, cv.CAP_ANY, params)
+        if cap.isOpened() == False:
+            print("Error: Can't open microphone")
+            print("Error: problems with audio reading, check input arguments")
+            exit()
+        audioBaseIndex = int(cap.get(cv.CAP_PROP_AUDIO_BASE_INDEX))
+        numberOfChannels = int(cap.get(cv.CAP_PROP_AUDIO_TOTAL_CHANNELS))
+
+        print("CAP_PROP_AUDIO_DATA_DEPTH: ", str((int(cap.get(cv.CAP_PROP_AUDIO_DATA_DEPTH)))))
+        print("CAP_PROP_AUDIO_SAMPLES_PER_SECOND: ", cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND))
+        print("CAP_PROP_AUDIO_TOTAL_CHANNELS: ", numberOfChannels)
+        print("CAP_PROP_AUDIO_TOTAL_STREAMS: ", cap.get(cv.CAP_PROP_AUDIO_TOTAL_STREAMS))
+
+        cvTickFreq = cv.getTickFrequency()
+        sysTimeCurr = cv.getTickCount()
+        sysTimePrev = sysTimeCurr
+
+        frame = []
+        frame = np.asarray(frame)
+        inputAudio = []
+
+        while ((sysTimeCurr - sysTimePrev) / cvTickFreq < self.microTime):
+            if (cap.grab()):
+                frame = []
+                frame = np.asarray(frame)
+                frame = cap.retrieve(frame, audioBaseIndex)
+                for i in range(len(frame[1][0])):
+                    inputAudio.append(frame[1][0][i])
+                sysTimeCurr = cv.getTickCount()
+            else:
+                print("Error: Grab error")
+                break
+
+        inputAudio = np.asarray(inputAudio)
+        print("Number of samples: ", len(inputAudio))
+        samplingRate = int(cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND))
+
+        return samplingRate, inputAudio
+
+
+    def drawAmplitude(self, inputAudio):
+        color = (247, 111, 87)
+        thickness = 5
+        frameVectorRows = 500
+        middle = frameVectorRows // 2
+
+        # usually the input data is too big, so it is necessary
+        # to reduce size using interpolation of data
+        frameVectorCols = 40000
+        if len(inputAudio) < frameVectorCols:
+            frameVectorCols = len(inputAudio)
+
+        img = np.zeros((frameVectorRows, frameVectorCols, 3), np.uint8)
+        img += 255  # white background
+
+        audio = np.array(0)
+        audio = cv.resize(inputAudio, (1, frameVectorCols), interpolation=cv.INTER_LINEAR)
+        reshapeAudio = np.reshape(audio, (-1))
+
+        # normalization data by maximum element
+        minCv, maxCv, _, _ = cv.minMaxLoc(reshapeAudio)
+        maxElem = int(max(abs(minCv), abs(maxCv)))
+
+        # if all data values are zero (silence)
+        if maxElem == 0:
+            maxElem = 1
+        for i in range(len(reshapeAudio)):
+            reshapeAudio[i] = middle - reshapeAudio[i] * middle // maxElem
+
+        for i in range(1, frameVectorCols, 1):
+            cv.line(img, (i - 1, int(reshapeAudio[i - 1])), (i, int(reshapeAudio[i])), color, thickness)
+
+        img = cv.resize(img, (900, 400), interpolation=cv.INTER_AREA)
+        return img
+
+
+    def drawAmplitudeScale(self, inputImg, inputAudio, samplingRate, xmin=None, xmax=None):
+        # function of layout drawing for graph of volume amplitudes
+        # x axis for time
+        # y axis for amplitudes
+
+        # parameters for the new image size
+        preCol = 100
+        aftCol = 100
+        preLine = 40
+        aftLine = 50
+
+        frameVectorRows = inputImg.shape[0]
+        frameVectorCols = inputImg.shape[1]
+
+        totalRows = preLine + frameVectorRows + aftLine
+        totalCols = preCol + frameVectorCols + aftCol
+
+        imgTotal = np.zeros((totalRows, totalCols, 3), np.uint8)
+        imgTotal += 255  # white background
+        imgTotal[preLine: preLine + frameVectorRows, preCol: preCol + frameVectorCols] = inputImg
+
+        # calculating values on x axis
+        if xmin is None:
+            xmin = 0
+        if xmax is None:
+            xmax = len(inputAudio) / samplingRate
+
+        if xmax > self.xmarkup:
+            xList = np.linspace(xmin, xmax, self.xmarkup).astype(int)
+        else:
+            # this case is used to display a dynamic update
+            tmp = np.arange(xmin, xmax, 1).astype(int) + 1
+            xList = np.concatenate((np.zeros(self.xmarkup - len(tmp)), tmp[:]), axis=None)
+
+        # calculating values on y axis
+        ymin = np.min(inputAudio)
+        ymax = np.max(inputAudio)
+        yList = np.linspace(ymin, ymax, self.ymarkup)
+
+        # parameters for layout drawing
+        textThickness = 1
+        gridThickness = 1
+        gridColor = (0, 0, 0)
+        textColor = (0, 0, 0)
+        font = cv.FONT_HERSHEY_SIMPLEX
+        fontScale = 0.5
+
+        # horizontal axis under the graph
+        cv.line(imgTotal, (preCol, totalRows - aftLine),
+                (preCol + frameVectorCols, totalRows - aftLine),
+                gridColor, gridThickness)
+        # vertical axis for amplitude
+        cv.line(imgTotal, (preCol, preLine), (preCol, preLine + frameVectorRows),
+                gridColor, gridThickness)
+
+        # parameters for layout calculation
+        serifSize = 10
+        indentDownX = serifSize * 2
+        indentDownY = serifSize // 2
+        indentLeftX = serifSize
+        indentLeftY = 2 * preCol // 3
+
+        # drawing layout for x axis
+        numX = frameVectorCols // (self.xmarkup - 1)
+        for i in range(len(xList)):
+            a1 = preCol + i * numX
+            a2 = frameVectorRows + preLine
+            b1 = a1
+            b2 = a2 + serifSize
+            if self.enableGrid is True:
+                d1 = a1
+                d2 = preLine
+                cv.line(imgTotal, (a1, a2), (d1, d2), gridColor, gridThickness)
+            cv.line(imgTotal, (a1, a2), (b1, b2), gridColor, gridThickness)
+            cv.putText(imgTotal, str(int(xList[i])), (b1 - indentLeftX, b2 + indentDownX),
+                    font, fontScale, textColor, textThickness)
+
+        # drawing layout for y axis
+        numY = frameVectorRows // (self.ymarkup - 1)
+        for i in range(len(yList)):
+            a1 = preCol
+            a2 = totalRows - aftLine - i * numY
+            b1 = preCol - serifSize
+            b2 = a2
+            if self.enableGrid is True:
+                d1 = preCol + frameVectorCols
+                d2 = a2
+                cv.line(imgTotal, (a1, a2), (d1, d2), gridColor, gridThickness)
+            cv.line(imgTotal, (a1, a2), (b1, b2), gridColor, gridThickness)
+            cv.putText(imgTotal, str(int(yList[i])), (b1 - indentLeftY, b2 + indentDownY),
+                    font, fontScale, textColor, textThickness)
+        imgTotal = cv.resize(imgTotal, (self.cols, self.rows), interpolation=cv.INTER_AREA)
+        return imgTotal
+
+
+    def STFT(self, inputAudio):
+        """
+        The Short-time Fourier transform (STFT), is a Fourier-related transform used to determine
+        the sinusoidal frequency and phase content of local sections of a signal as it changes over
+        time.
+        In practice, the procedure for computing STFTs is to divide a longer time signal into
+        shorter segments of equal length and then compute the Fourier transform separately on each
+        shorter segment. This reveals the Fourier spectrum on each shorter segment. One then usually
+        plots the changing spectra as a function of time, known as a spectrogram or waterfall plot.
+
+        https://en.wikipedia.org/wiki/Short-time_Fourier_transform
+        """
+
+        time_step = self.windLen - self.overlap
+        stft = []
+
+        if self.windowType == "Hann":
+            # https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows
+            Hann_wind = []
+            for i in range (1 - self.windLen, self.windLen, 2):
+                Hann_wind.append(i * (0.5 + 0.5 * math.cos(math.pi * i / (self.windLen - 1))))
+            Hann_wind = np.asarray(Hann_wind)
+
+        elif self.windowType == "Hamming":
+            # https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows
+            Hamming_wind = []
+            for i in range (1 - self.windLen, self.windLen, 2):
+                Hamming_wind.append(i * (0.53836 - 0.46164 * (math.cos(2 * math.pi * i / (self.windLen - 1)))))
+            Hamming_wind = np.asarray(Hamming_wind)
+
+        for index in np.arange(0, len(inputAudio), time_step).astype(int):
+
+            section = inputAudio[index:index + self.windLen]
+            zeroArray = np.zeros(self.windLen - len(section))
+            section = np.concatenate((section, zeroArray), axis=None)
+
+            if self.windowType == "Hann":
+                section *= Hann_wind
+            elif self.windowType == "Hamming":
+                section *= Hamming_wind
+
+            dst = np.empty(0)
+            dst = cv.dft(section, dst, flags=cv.DFT_COMPLEX_OUTPUT)
+            reshape_dst = np.reshape(dst, (-1))
+            # we need only the first part of the spectrum, the second part is symmetrical
+            complexArr = np.zeros(len(dst) // 4, dtype=complex)
+            for i in range(len(dst) // 4):
+                complexArr[i] = complex(reshape_dst[2 * i], reshape_dst[2 * i + 1])
+            stft.append(np.abs(complexArr))
+
+        stft = np.array(stft).transpose()
+        # convert elements to the decibel scale
+        np.log10(stft, out=stft, where=(stft != 0.))
+        return 10 * stft
+
+
+    def drawSpectrogram(self, stft):
+
+        frameVectorRows = stft.shape[0]
+        frameVectorCols = stft.shape[1]
+
+        # Normalization of image values from 0 to 255 to get more contrast image
+        # and this normalization will be taken into account in the scale drawing
+        colormapImageRows = 255
+
+        imgSpec = np.zeros((frameVectorRows, frameVectorCols, 3), np.uint8)
+        stftMat = np.zeros((frameVectorRows, frameVectorCols), np.float64)
+        cv.normalize(stft, stftMat, 1.0, 0.0, cv.NORM_INF)
+
+        for i in range(frameVectorRows):
+            for j in range(frameVectorCols):
+                imgSpec[frameVectorRows - i - 1, j] = int(stftMat[i][j] * colormapImageRows)
+
+        imgSpec = cv.applyColorMap(imgSpec, cv.COLORMAP_INFERNO)
+        imgSpec = cv.resize(imgSpec, (900, 400), interpolation=cv.INTER_LINEAR)
+        return imgSpec
+
+
+    def drawSpectrogramColorbar(self, inputImg, inputAudio, samplingRate, stft, xmin=None, xmax=None):
+        # function of layout drawing for the three-dimensional graph of the spectrogram
+        # x axis for time
+        # y axis for frequencies
+        # z axis for magnitudes of frequencies shown by color scale
+
+        # parameters for the new image size
+        preCol = 100
+        aftCol = 100
+        preLine = 40
+        aftLine = 50
+        colColor = 20
+        ind_col = 20
+
+        frameVectorRows = inputImg.shape[0]
+        frameVectorCols = inputImg.shape[1]
+
+        totalRows = preLine + frameVectorRows + aftLine
+        totalCols = preCol + frameVectorCols + aftCol + colColor
+
+        imgTotal = np.zeros((totalRows, totalCols, 3), np.uint8)
+        imgTotal += 255  # white background
+        imgTotal[preLine: preLine + frameVectorRows, preCol: preCol + frameVectorCols] = inputImg
+
+        # colorbar image due to drawSpectrogram(..) picture has been normalised from 255 to 0,
+        # so here colorbar has values from 255 to 0
+        colorArrSize = 256
+        imgColorBar = np.zeros((colorArrSize, colColor, 1), np.uint8)
+
+        for i in range(colorArrSize):
+            imgColorBar[i] += colorArrSize - 1 - i
+
+        imgColorBar = cv.applyColorMap(imgColorBar, cv.COLORMAP_INFERNO)
+        imgColorBar = cv.resize(imgColorBar, (colColor, frameVectorRows), interpolation=cv.INTER_AREA)  #
+
+        imgTotal[preLine: preLine + frameVectorRows,
+        preCol + frameVectorCols + ind_col:
+        preCol + frameVectorCols + ind_col + colColor] = imgColorBar
+
+        # calculating values on x axis
+        if xmin is None:
+            xmin = 0
+        if xmax is None:
+            xmax = len(inputAudio) / samplingRate
+        if xmax > self.xmarkup:
+            xList = np.linspace(xmin, xmax, self.xmarkup).astype(int)
+        else:
+            # this case is used to display a dynamic update
+            tmpXList = np.arange(xmin, xmax, 1).astype(int) + 1
+            xList = np.concatenate((np.zeros(self.xmarkup - len(tmpXList)), tmpXList[:]), axis=None)
+
+        # calculating values on y axis
+        # according to the Nyquist sampling theorem,
+        # signal should posses frequencies equal to half of sampling rate
+        ymin = 0
+        ymax = int(samplingRate / 2.)
+        yList = np.linspace(ymin, ymax, self.ymarkup).astype(int)
+
+        # calculating values on z axis
+        zList = np.linspace(np.min(stft), np.max(stft), self.zmarkup)
+
+        # parameters for layout drawing
+        textThickness = 1
+        textColor = (0, 0, 0)
+        gridThickness = 1
+        gridColor = (0, 0, 0)
+        font = cv.FONT_HERSHEY_SIMPLEX
+        fontScale = 0.5
+
+        serifSize = 10
+        indentDownX = serifSize * 2
+        indentDownY = serifSize // 2
+        indentLeftX = serifSize
+        indentLeftY = 2 * preCol // 3
+
+        # horizontal axis
+        cv.line(imgTotal, (preCol, totalRows - aftLine), (preCol + frameVectorCols, totalRows - aftLine),
+                gridColor, gridThickness)
+        # vertical axis
+        cv.line(imgTotal, (preCol, preLine), (preCol, preLine + frameVectorRows),
+                gridColor, gridThickness)
+
+        # drawing layout for x axis
+        numX = frameVectorCols // (self.xmarkup - 1)
+        for i in range(len(xList)):
+            a1 = preCol + i * numX
+            a2 = frameVectorRows + preLine
+            b1 = a1
+            b2 = a2 + serifSize
+            cv.line(imgTotal, (a1, a2), (b1, b2), gridColor, gridThickness)
+            cv.putText(imgTotal, str(int(xList[i])), (b1 - indentLeftX, b2 + indentDownX),
+                    font, fontScale, textColor, textThickness)
+
+        # drawing layout for y axis
+        numY = frameVectorRows // (self.ymarkup - 1)
+        for i in range(len(yList)):
+            a1 = preCol
+            a2 = totalRows - aftLine - i * numY
+            b1 = preCol - serifSize
+            b2 = a2
+            cv.line(imgTotal, (a1, a2), (b1, b2), gridColor, gridThickness)
+            cv.putText(imgTotal, str(int(yList[i])), (b1 - indentLeftY, b2 + indentDownY),
+                    font, fontScale, textColor, textThickness)
+
+        # drawing layout for z axis
+        numZ = frameVectorRows // (self.zmarkup - 1)
+        for i in range(len(zList)):
+            a1 = preCol + frameVectorCols + ind_col + colColor
+            a2 = totalRows - aftLine - i * numZ
+            b1 = a1 + serifSize
+            b2 = a2
+            cv.line(imgTotal, (a1, a2), (b1, b2), gridColor, gridThickness)
+            cv.putText(imgTotal, str(int(zList[i])), (b1 + 10, b2 + indentDownY),
+                    font, fontScale, textColor, textThickness)
+        imgTotal = cv.resize(imgTotal, (self.cols, self.rows), interpolation=cv.INTER_AREA)
+        return imgTotal
+
+
+    def concatenateImages(self, img1, img2):
+        # first image will be under the second image
+        totalRows = img1.shape[0] + img2.shape[0]
+        totalCols = max(img1.shape[1], img2.shape[1])
+
+        # if images columns do not match, the difference is filled in white
+        imgTotal = np.zeros((totalRows, totalCols, 3), np.uint8)
+        imgTotal += 255
+
+        imgTotal[:img1.shape[0], :img1.shape[1]] = img1
+        imgTotal[img2.shape[0]:, :img2.shape[1]] = img2
+
+        return imgTotal
+
+
+    def dynamicFile(self, file):
+        cap = cv.VideoCapture(file)
+        params = [cv.CAP_PROP_AUDIO_STREAM, self.audioStream,
+                cv.CAP_PROP_VIDEO_STREAM, -1,
+                cv.CAP_PROP_AUDIO_DATA_DEPTH, cv.CV_16S]
+        params = np.asarray(params)
+
+        cap.open(file, cv.CAP_ANY, params)
+        if cap.isOpened() == False:
+            print("ERROR! Can't to open file")
+            return
+
+        audioBaseIndex = int(cap.get(cv.CAP_PROP_AUDIO_BASE_INDEX))
+        numberOfChannels = int(cap.get(cv.CAP_PROP_AUDIO_TOTAL_CHANNELS))
+        samplingRate = int(cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND))
+
+        print("CAP_PROP_AUDIO_DATA_DEPTH: ", str((int(cap.get(cv.CAP_PROP_AUDIO_DATA_DEPTH)))))
+        print("CAP_PROP_AUDIO_SAMPLES_PER_SECOND: ", cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND))
+        print("CAP_PROP_AUDIO_TOTAL_CHANNELS: ", numberOfChannels)
+        print("CAP_PROP_AUDIO_TOTAL_STREAMS: ", cap.get(cv.CAP_PROP_AUDIO_TOTAL_STREAMS))
+
+        step = int(self.updateTime * samplingRate)
+        frameSize = int(self.frameSizeTime * samplingRate)
+        # since the dimensional grid is counted in integer seconds,
+        # if duration of audio frame is less than xmarkup, to avoid an incorrect display,
+        # xmarkup will be taken equal to duration
+        if self.frameSizeTime <= self.xmarkup:
+            self.xmarkup = self.frameSizeTime
+
+        buffer = []
+        section = np.zeros(frameSize, dtype=np.int16)
+        currentSamples = 0
+
+        while (1):
+            if (cap.grab()):
+                frame = []
+                frame = np.asarray(frame)
+                frame = cap.retrieve(frame, audioBaseIndex)
+
+                for i in range(len(frame[1][0])):
+                    buffer.append(frame[1][0][i])
+
+                buffer_size = len(buffer)
+                if (buffer_size >= step):
+
+                    section = list(section)
+                    currentSamples += step
+
+                    del section[0:step]
+                    section.extend(buffer[0:step])
+                    del buffer[0:step]
+
+                    section = np.asarray(section)
+
+                    if currentSamples < frameSize:
+                        xmin = 0
+                        xmax = (currentSamples) / samplingRate
+                    else:
+                        xmin = (currentSamples - frameSize) / samplingRate + 1
+                        xmax = (currentSamples) / samplingRate
+
+                    if self.graph == "ampl":
+                        imgAmplitude = self.drawAmplitude(section)
+                        imgAmplitude = self.drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax)
+                        cv.imshow("Display amplitude graph", imgAmplitude)
+                        cv.waitKey(self.waitTime)
+
+                    elif self.graph == "spec":
+                        stft = self.STFT(section)
+                        imgSpec = self.drawSpectrogram(stft)
+                        imgSpec = self.drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax)
+                        cv.imshow("Display spectrogram", imgSpec)
+                        cv.waitKey(self.waitTime)
+
+                    elif self.graph == "ampl_and_spec":
+
+                        imgAmplitude = self.drawAmplitude(section)
+                        stft = self.STFT(section)
+                        imgSpec = self.drawSpectrogram(stft)
+
+                        imgAmplitude = self.drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax)
+                        imgSpec = self.drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax)
+
+                        imgTotal = self.concatenateImages(imgAmplitude, imgSpec)
+                        cv.imshow("Display amplitude graph and spectrogram", imgTotal)
+                        cv.waitKey(self.waitTime)
+            else:
+                break
+
+
+    def dynamicMicrophone(self):
+        cap = cv.VideoCapture()
+        params = [cv.CAP_PROP_AUDIO_STREAM, 0, cv.CAP_PROP_VIDEO_STREAM, -1]
+        params = np.asarray(params)
+
+        cap.open(0, cv.CAP_ANY, params)
+        if cap.isOpened() == False:
+            print("ERROR! Can't to open file")
+            return
+        audioBaseIndex = int(cap.get(cv.CAP_PROP_AUDIO_BASE_INDEX))
+        numberOfChannels = int(cap.get(cv.CAP_PROP_AUDIO_TOTAL_CHANNELS))
+
+        print("CAP_PROP_AUDIO_DATA_DEPTH: ", str((int(cap.get(cv.CAP_PROP_AUDIO_DATA_DEPTH)))))
+        print("CAP_PROP_AUDIO_SAMPLES_PER_SECOND: ", cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND))
+        print("CAP_PROP_AUDIO_TOTAL_CHANNELS: ", numberOfChannels)
+        print("CAP_PROP_AUDIO_TOTAL_STREAMS: ", cap.get(cv.CAP_PROP_AUDIO_TOTAL_STREAMS))
+
+        frame = []
+        frame = np.asarray(frame)
+        samplingRate = int(cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND))
+
+        step = int(self.updateTime * samplingRate)
+        frameSize = int(self.frameSizeTime * samplingRate)
+        self.xmarkup = self.frameSizeTime
+
+        currentSamples = 0
+
+        buffer = []
+        section = np.zeros(frameSize, dtype=np.int16)
+
+        cvTickFreq = cv.getTickFrequency()
+        sysTimeCurr = cv.getTickCount()
+        sysTimePrev = sysTimeCurr
+        self.waitTime = self.updateTime * 1000
+        while ((sysTimeCurr - sysTimePrev) / cvTickFreq < self.microTime):
+            if (cap.grab()):
+                frame = []
+                frame = np.asarray(frame)
+                frame = cap.retrieve(frame, audioBaseIndex)
+
+                for i in range(len(frame[1][0])):
+                    buffer.append(frame[1][0][i])
+
+                sysTimeCurr = cv.getTickCount()
+                buffer_size = len(buffer)
+                if (buffer_size >= step):
+
+                    section = list(section)
+                    currentSamples += step
+
+                    del section[0:step]
+                    section.extend(buffer[0:step])
+                    del buffer[0:step]
+
+                    section = np.asarray(section)
+
+                    if currentSamples < frameSize:
+                        xmin = 0
+                        xmax = (currentSamples) / samplingRate
+                    else:
+                        xmin = (currentSamples - frameSize) / samplingRate + 1
+                        xmax = (currentSamples) / samplingRate
+
+                    if self.graph == "ampl":
+                        imgAmplitude = self.drawAmplitude(section)
+                        imgAmplitude = self.drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax)
+                        cv.imshow("Display amplitude graph", imgAmplitude)
+                        cv.waitKey(self.waitTime)
+
+                    elif self.graph == "spec":
+                        stft = self.STFT(section)
+                        imgSpec = self.drawSpectrogram(stft)
+                        imgSpec = self.drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax)
+                        cv.imshow("Display spectrogram", imgSpec)
+                        cv.waitKey(self.waitTime)
+
+                    elif self.graph == "ampl_and_spec":
+                        imgAmplitude = self.drawAmplitude(section)
+                        stft = self.STFT(section)
+                        imgSpec = self.drawSpectrogram(stft)
+
+                        imgAmplitude = self.drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax)
+                        imgSpec = self.drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax)
+
+                        imgTotal = self.concatenateImages(imgAmplitude, imgSpec)
+                        cv.imshow("Display amplitude graph and spectrogram", imgTotal)
+                        cv.waitKey(self.waitTime)
+            else:
+                break
+
+
+    def initAndCheckArgs(self, args):
+        if args.inputType != "file" and args.inputType != "microphone":
+            print("Error: ", args.inputType, " input method doesnt exist")
+            return False
+        if args.draw != "static" and args.draw != "dynamic":
+            print("Error: ", args.draw, " draw type doesnt exist")
+            return False
+        if args.graph != "ampl" and args.graph != "spec" and args.graph != "ampl_and_spec":
+            print("Error: ", args.graph, " type of graph doesnt exist")
+            return False
+        if args.windowType != "Rect" and args.windowType != "Hann" and args.windowType != "Hamming":
+            print("Error: ", args.windowType, " type of window doesnt exist")
+            return False
+        if args.windLen <= 0:
+            print("Error: windLen = ", args.windLen, " - incorrect value. Must be > 0")
+            return False
+        if args.overlap <= 0:
+            print("Error: overlap = ", args.overlap, " - incorrect value. Must be > 0")
+            return False
+        if args.rows <= 0:
+            print("Error: rows = ", args.rows, " - incorrect value. Must be > 0")
+            return False
+        if args.cols <= 0:
+            print("Error: cols = ", args.cols, " - incorrect value. Must be > 0")
+            return False
+        if args.xmarkup < 2:
+            print("Error: xmarkup = ", args.xmarkup, " - incorrect value. Must be >= 2")
+            return False
+        if args.ymarkup < 2:
+            print("Error: ymarkup = ", args.ymarkup, " - incorrect value. Must be >= 2")
+            return False
+        if args.zmarkup < 2:
+            print("Error: zmarkup = ", args.zmarkup, " - incorrect value. Must be >= 2")
+            return False
+        if args.microTime <= 0:
+            print("Error: microTime = ", args.microTime, " - incorrect value. Must be > 0")
+            return False
+        if args.frameSizeTime <= 0:
+            print("Error: frameSizeTime = ", args.frameSizeTime, " - incorrect value. Must be > 0")
+            return False
+        if args.updateTime <= 0:
+            print("Error: updateTime = ", args.updateTime, " - incorrect value. Must be > 0")
+            return False
+        if args.waitTime < 0:
+            print("Error: waitTime = ", args.waitTime, " - incorrect value. Must be >= 0")
+            return False
+        return True
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,
+                                     description='''this sample draws a volume graph and/or spectrogram of audio/video files and microphone\nDefault usage: ./Spectrogram.exe''')
+
+    parser.add_argument("-i", "--inputType", dest="inputType", type=str, default="file", help="file or microphone")
+    parser.add_argument("-d", "--draw", dest="draw", type=str, default="static",
+                        help="type of drawing: static - for plotting graph(s) across the entire input audio; dynamic - for plotting graph(s) in a time-updating window")
+    parser.add_argument("-g", "--graph", dest="graph", type=str, default="ampl_and_spec",
+                        help="type of graph: amplitude graph or/and spectrogram. Please use tags below : ampl - draw the amplitude graph; spec - draw the spectrogram; ampl_and_spec - draw the amplitude graph and spectrogram on one image under each other")
+
+    parser.add_argument("-a", "--audio", dest="audio", type=str, default='Megamind.avi',
+                        help="name and path to file")
+    parser.add_argument("-s", "--audioStream", dest="audioStream", type=int, default=1,
+                        help=" CAP_PROP_AUDIO_STREAM value")
+
+    parser.add_argument("-t", '--windowType', dest="windowType", type=str, default="Rect",
+                        help="type of window for STFT. Please use tags below : Rect/Hann/Hamming")
+    parser.add_argument("-l", '--windLen', dest="windLen", type=int, default=256, help="size of window for STFT")
+    parser.add_argument("-o", '--overlap', dest="overlap", type=int, default=128, help="overlap of windows for STFT")
+
+    parser.add_argument("-gd", '--grid', dest="enableGrid", type=bool, default=False, help="grid on amplitude graph(on/off)")
+
+    parser.add_argument("-r", '--rows', dest="rows", type=int, default=400, help="rows of output image")
+    parser.add_argument("-c", '--cols', dest="cols", type=int, default=900, help="cols of output image")
+
+    parser.add_argument("-x", '--xmarkup', dest="xmarkup", type=int, default=5,
+                        help="number of x axis divisions (time asix)")
+    parser.add_argument("-y", '--ymarkup', dest="ymarkup", type=int, default=5,
+                        help="number of y axis divisions (frequency or/and amplitude axis)")  # ?
+    parser.add_argument("-z", '--zmarkup', dest="zmarkup", type=int, default=5,
+                        help="number of z axis divisions (colorbar)")  # ?
+
+    parser.add_argument("-m", '--microTime', dest="microTime", type=int, default=20,
+                        help="time of recording audio with microphone in seconds")
+    parser.add_argument("-f", '--frameSizeTime', dest="frameSizeTime", type=int, default=5,
+                        help="size of sliding window in seconds")
+    parser.add_argument("-u", '--updateTime', dest="updateTime", type=int, default=1,
+                        help="update time of sliding window in seconds")
+    parser.add_argument("-w", '--waitTime', dest="waitTime", type=int, default=10,
+                        help="parameter to cv.waitKey() for dynamic update, takes values in milliseconds")
+
+    args = parser.parse_args()
+
+    AudioDrawing(args).Draw()
diff --git a/C++/opencv-4.7.0/samples/python/browse.py b/C++/opencv-4.7.0/samples/python/browse.py
new file mode 100644
index 00000000..edc791f9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/browse.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+
+'''
+browse.py
+=========
+
+Sample shows how to implement a simple hi resolution image navigation
+
+Usage
+-----
+browse.py [image filename]
+
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+
+# built-in modules
+import sys
+
+def main():
+    if len(sys.argv) > 1:
+        fn = cv.samples.findFile(sys.argv[1])
+        print('loading %s ...' % fn)
+        img = cv.imread(fn)
+        if img is None:
+            print('Failed to load fn:', fn)
+            sys.exit(1)
+
+    else:
+        sz = 4096
+        print('generating %dx%d procedural image ...' % (sz, sz))
+        img = np.zeros((sz, sz), np.uint8)
+        track = np.cumsum(np.random.rand(500000, 2)-0.5, axis=0)
+        track = np.int32(track*10 + (sz/2, sz/2))
+        cv.polylines(img, [track], 0, 255, 1, cv.LINE_AA)
+
+
+    small = img
+    for _i in xrange(3):
+        small = cv.pyrDown(small)
+
+    def onmouse(event, x, y, flags, param):
+        h, _w = img.shape[:2]
+        h1, _w1 = small.shape[:2]
+        x, y = 1.0*x*h/h1, 1.0*y*h/h1
+        zoom = cv.getRectSubPix(img, (800, 600), (x+0.5, y+0.5))
+        cv.imshow('zoom', zoom)
+
+    cv.imshow('preview', small)
+    cv.setMouseCallback('preview', onmouse)
+    cv.waitKey()
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/calibrate.py b/C++/opencv-4.7.0/samples/python/calibrate.py
new file mode 100644
index 00000000..bca430b5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/calibrate.py
@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+
+'''
+camera calibration for distorted images with chess board samples
+reads distorted images, calculates the calibration and write undistorted images
+
+usage:
+    calibrate.py [--debug <output path>] [--square_size] [<image mask>]
+
+default values:
+    --debug:    ./output/
+    --square_size: 1.0
+    <image mask> defaults to ../data/left*.jpg
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+# local modules
+from common import splitfn
+
+# built-in modules
+import os
+
+def main():
+    import sys
+    import getopt
+    from glob import glob
+
+    args, img_mask = getopt.getopt(sys.argv[1:], '', ['debug=', 'square_size=', 'threads='])
+    args = dict(args)
+    args.setdefault('--debug', './output/')
+    args.setdefault('--square_size', 1.0)
+    args.setdefault('--threads', 4)
+    if not img_mask:
+        img_mask = '../data/left??.jpg'  # default
+    else:
+        img_mask = img_mask[0]
+
+    img_names = glob(img_mask)
+    debug_dir = args.get('--debug')
+    if debug_dir and not os.path.isdir(debug_dir):
+        os.mkdir(debug_dir)
+    square_size = float(args.get('--square_size'))
+
+    pattern_size = (9, 6)
+    pattern_points = np.zeros((np.prod(pattern_size), 3), np.float32)
+    pattern_points[:, :2] = np.indices(pattern_size).T.reshape(-1, 2)
+    pattern_points *= square_size
+
+    obj_points = []
+    img_points = []
+    h, w = cv.imread(img_names[0], cv.IMREAD_GRAYSCALE).shape[:2]  # TODO: use imquery call to retrieve results
+
+    def processImage(fn):
+        print('processing %s... ' % fn)
+        img = cv.imread(fn, 0)
+        if img is None:
+            print("Failed to load", fn)
+            return None
+
+        assert w == img.shape[1] and h == img.shape[0], ("size: %d x %d ... " % (img.shape[1], img.shape[0]))
+        found, corners = cv.findChessboardCorners(img, pattern_size)
+        if found:
+            term = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_COUNT, 30, 0.1)
+            cv.cornerSubPix(img, corners, (5, 5), (-1, -1), term)
+
+        if debug_dir:
+            vis = cv.cvtColor(img, cv.COLOR_GRAY2BGR)
+            cv.drawChessboardCorners(vis, pattern_size, corners, found)
+            _path, name, _ext = splitfn(fn)
+            outfile = os.path.join(debug_dir, name + '_chess.png')
+            cv.imwrite(outfile, vis)
+
+        if not found:
+            print('chessboard not found')
+            return None
+
+        print('           %s... OK' % fn)
+        return (corners.reshape(-1, 2), pattern_points)
+
+    threads_num = int(args.get('--threads'))
+    if threads_num <= 1:
+        chessboards = [processImage(fn) for fn in img_names]
+    else:
+        print("Run with %d threads..." % threads_num)
+        from multiprocessing.dummy import Pool as ThreadPool
+        pool = ThreadPool(threads_num)
+        chessboards = pool.map(processImage, img_names)
+
+    chessboards = [x for x in chessboards if x is not None]
+    for (corners, pattern_points) in chessboards:
+        img_points.append(corners)
+        obj_points.append(pattern_points)
+
+    # calculate camera distortion
+    rms, camera_matrix, dist_coefs, _rvecs, _tvecs = cv.calibrateCamera(obj_points, img_points, (w, h), None, None)
+
+    print("\nRMS:", rms)
+    print("camera matrix:\n", camera_matrix)
+    print("distortion coefficients: ", dist_coefs.ravel())
+
+    # undistort the image with the calibration
+    print('')
+    for fn in img_names if debug_dir else []:
+        _path, name, _ext = splitfn(fn)
+        img_found = os.path.join(debug_dir, name + '_chess.png')
+        outfile = os.path.join(debug_dir, name + '_undistorted.png')
+
+        img = cv.imread(img_found)
+        if img is None:
+            continue
+
+        h, w = img.shape[:2]
+        newcameramtx, roi = cv.getOptimalNewCameraMatrix(camera_matrix, dist_coefs, (w, h), 1, (w, h))
+
+        dst = cv.undistort(img, camera_matrix, dist_coefs, None, newcameramtx)
+
+        # crop and save the image
+        x, y, w, h = roi
+        dst = dst[y:y+h, x:x+w]
+
+        print('Undistorted image written to: %s' % outfile)
+        cv.imwrite(outfile, dst)
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/camera_calibration_show_extrinsics.py b/C++/opencv-4.7.0/samples/python/camera_calibration_show_extrinsics.py
new file mode 100644
index 00000000..0ee2a19b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/camera_calibration_show_extrinsics.py
@@ -0,0 +1,240 @@
+#!/usr/bin/env python
+
+'''
+Plot camera calibration extrinsics.
+
+usage:
+    camera_calibration_show_extrinsics.py [--calibration <input path>] [--cam_width] [--cam_height] [--scale_focal] [--patternCentric ]
+
+default values:
+    --calibration    : left_intrinsics.yml
+    --cam_width      : 0.064/2
+    --cam_height     : 0.048/2
+    --scale_focal    : 40
+    --patternCentric : True
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+from numpy import linspace
+
+def inverse_homogeneoux_matrix(M):
+    R = M[0:3, 0:3]
+    T = M[0:3, 3]
+    M_inv = np.identity(4)
+    M_inv[0:3, 0:3] = R.T
+    M_inv[0:3, 3] = -(R.T).dot(T)
+
+    return M_inv
+
+def transform_to_matplotlib_frame(cMo, X, inverse=False):
+    M = np.identity(4)
+    M[1,1] = 0
+    M[1,2] = 1
+    M[2,1] = -1
+    M[2,2] = 0
+
+    if inverse:
+        return M.dot(inverse_homogeneoux_matrix(cMo).dot(X))
+    else:
+        return M.dot(cMo.dot(X))
+
+def create_camera_model(camera_matrix, width, height, scale_focal, draw_frame_axis=False):
+    fx = camera_matrix[0,0]
+    fy = camera_matrix[1,1]
+    focal = 2 / (fx + fy)
+    f_scale = scale_focal * focal
+
+    # draw image plane
+    X_img_plane = np.ones((4,5))
+    X_img_plane[0:3,0] = [-width, height, f_scale]
+    X_img_plane[0:3,1] = [width, height, f_scale]
+    X_img_plane[0:3,2] = [width, -height, f_scale]
+    X_img_plane[0:3,3] = [-width, -height, f_scale]
+    X_img_plane[0:3,4] = [-width, height, f_scale]
+
+    # draw triangle above the image plane
+    X_triangle = np.ones((4,3))
+    X_triangle[0:3,0] = [-width, -height, f_scale]
+    X_triangle[0:3,1] = [0, -2*height, f_scale]
+    X_triangle[0:3,2] = [width, -height, f_scale]
+
+    # draw camera
+    X_center1 = np.ones((4,2))
+    X_center1[0:3,0] = [0, 0, 0]
+    X_center1[0:3,1] = [-width, height, f_scale]
+
+    X_center2 = np.ones((4,2))
+    X_center2[0:3,0] = [0, 0, 0]
+    X_center2[0:3,1] = [width, height, f_scale]
+
+    X_center3 = np.ones((4,2))
+    X_center3[0:3,0] = [0, 0, 0]
+    X_center3[0:3,1] = [width, -height, f_scale]
+
+    X_center4 = np.ones((4,2))
+    X_center4[0:3,0] = [0, 0, 0]
+    X_center4[0:3,1] = [-width, -height, f_scale]
+
+    # draw camera frame axis
+    X_frame1 = np.ones((4,2))
+    X_frame1[0:3,0] = [0, 0, 0]
+    X_frame1[0:3,1] = [f_scale/2, 0, 0]
+
+    X_frame2 = np.ones((4,2))
+    X_frame2[0:3,0] = [0, 0, 0]
+    X_frame2[0:3,1] = [0, f_scale/2, 0]
+
+    X_frame3 = np.ones((4,2))
+    X_frame3[0:3,0] = [0, 0, 0]
+    X_frame3[0:3,1] = [0, 0, f_scale/2]
+
+    if draw_frame_axis:
+        return [X_img_plane, X_triangle, X_center1, X_center2, X_center3, X_center4, X_frame1, X_frame2, X_frame3]
+    else:
+        return [X_img_plane, X_triangle, X_center1, X_center2, X_center3, X_center4]
+
+def create_board_model(extrinsics, board_width, board_height, square_size, draw_frame_axis=False):
+    width = board_width*square_size
+    height = board_height*square_size
+
+    # draw calibration board
+    X_board = np.ones((4,5))
+    #X_board_cam = np.ones((extrinsics.shape[0],4,5))
+    X_board[0:3,0] = [0,0,0]
+    X_board[0:3,1] = [width,0,0]
+    X_board[0:3,2] = [width,height,0]
+    X_board[0:3,3] = [0,height,0]
+    X_board[0:3,4] = [0,0,0]
+
+    # draw board frame axis
+    X_frame1 = np.ones((4,2))
+    X_frame1[0:3,0] = [0, 0, 0]
+    X_frame1[0:3,1] = [height/2, 0, 0]
+
+    X_frame2 = np.ones((4,2))
+    X_frame2[0:3,0] = [0, 0, 0]
+    X_frame2[0:3,1] = [0, height/2, 0]
+
+    X_frame3 = np.ones((4,2))
+    X_frame3[0:3,0] = [0, 0, 0]
+    X_frame3[0:3,1] = [0, 0, height/2]
+
+    if draw_frame_axis:
+        return [X_board, X_frame1, X_frame2, X_frame3]
+    else:
+        return [X_board]
+
+def draw_camera_boards(ax, camera_matrix, cam_width, cam_height, scale_focal,
+                       extrinsics, board_width, board_height, square_size,
+                       patternCentric):
+    from matplotlib import cm
+
+    min_values = np.zeros((3,1))
+    min_values = np.inf
+    max_values = np.zeros((3,1))
+    max_values = -np.inf
+
+    if patternCentric:
+        X_moving = create_camera_model(camera_matrix, cam_width, cam_height, scale_focal)
+        X_static = create_board_model(extrinsics, board_width, board_height, square_size)
+    else:
+        X_static = create_camera_model(camera_matrix, cam_width, cam_height, scale_focal, True)
+        X_moving = create_board_model(extrinsics, board_width, board_height, square_size)
+
+    cm_subsection = linspace(0.0, 1.0, extrinsics.shape[0])
+    colors = [ cm.jet(x) for x in cm_subsection ]
+
+    for i in range(len(X_static)):
+        X = np.zeros(X_static[i].shape)
+        for j in range(X_static[i].shape[1]):
+            X[:,j] = transform_to_matplotlib_frame(np.eye(4), X_static[i][:,j])
+        ax.plot3D(X[0,:], X[1,:], X[2,:], color='r')
+        min_values = np.minimum(min_values, X[0:3,:].min(1))
+        max_values = np.maximum(max_values, X[0:3,:].max(1))
+
+    for idx in range(extrinsics.shape[0]):
+        R, _ = cv.Rodrigues(extrinsics[idx,0:3])
+        cMo = np.eye(4,4)
+        cMo[0:3,0:3] = R
+        cMo[0:3,3] = extrinsics[idx,3:6]
+        for i in range(len(X_moving)):
+            X = np.zeros(X_moving[i].shape)
+            for j in range(X_moving[i].shape[1]):
+                X[0:4,j] = transform_to_matplotlib_frame(cMo, X_moving[i][0:4,j], patternCentric)
+            ax.plot3D(X[0,:], X[1,:], X[2,:], color=colors[idx])
+            min_values = np.minimum(min_values, X[0:3,:].min(1))
+            max_values = np.maximum(max_values, X[0:3,:].max(1))
+
+    return min_values, max_values
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Plot camera calibration extrinsics.',
+                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('--calibration', type=str, default='left_intrinsics.yml',
+                        help='YAML camera calibration file.')
+    parser.add_argument('--cam_width', type=float, default=0.064/2,
+                        help='Width/2 of the displayed camera.')
+    parser.add_argument('--cam_height', type=float, default=0.048/2,
+                        help='Height/2 of the displayed camera.')
+    parser.add_argument('--scale_focal', type=float, default=40,
+                        help='Value to scale the focal length.')
+    parser.add_argument('--patternCentric', action='store_true',
+                        help='The calibration board is static and the camera is moving.')
+    args = parser.parse_args()
+
+    fs = cv.FileStorage(cv.samples.findFile(args.calibration), cv.FILE_STORAGE_READ)
+    board_width = int(fs.getNode('board_width').real())
+    board_height = int(fs.getNode('board_height').real())
+    square_size = fs.getNode('square_size').real()
+    camera_matrix = fs.getNode('camera_matrix').mat()
+    extrinsics = fs.getNode('extrinsic_parameters').mat()
+
+    import matplotlib.pyplot as plt
+    from mpl_toolkits.mplot3d import Axes3D  # pylint: disable=unused-variable
+
+    fig = plt.figure()
+    ax = fig.gca(projection='3d')
+    ax.set_aspect("auto")
+
+    cam_width = args.cam_width
+    cam_height = args.cam_height
+    scale_focal = args.scale_focal
+    min_values, max_values = draw_camera_boards(ax, camera_matrix, cam_width, cam_height,
+                                                scale_focal, extrinsics, board_width,
+                                                board_height, square_size, args.patternCentric)
+
+    X_min = min_values[0]
+    X_max = max_values[0]
+    Y_min = min_values[1]
+    Y_max = max_values[1]
+    Z_min = min_values[2]
+    Z_max = max_values[2]
+    max_range = np.array([X_max-X_min, Y_max-Y_min, Z_max-Z_min]).max() / 2.0
+
+    mid_x = (X_max+X_min) * 0.5
+    mid_y = (Y_max+Y_min) * 0.5
+    mid_z = (Z_max+Z_min) * 0.5
+    ax.set_xlim(mid_x - max_range, mid_x + max_range)
+    ax.set_ylim(mid_y - max_range, mid_y + max_range)
+    ax.set_zlim(mid_z - max_range, mid_z + max_range)
+
+    ax.set_xlabel('x')
+    ax.set_ylabel('z')
+    ax.set_zlabel('-y')
+    ax.set_title('Extrinsic Parameters Visualization')
+
+    plt.show()
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/camshift.py b/C++/opencv-4.7.0/samples/python/camshift.py
new file mode 100644
index 00000000..0fcab728
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/camshift.py
@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+
+'''
+Camshift tracker
+================
+
+This is a demo that shows mean-shift based tracking
+You select a color objects such as your face and it tracks it.
+This reads from video camera (0 by default, or the camera number the user enters)
+
+[1] http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.14.7673
+
+Usage:
+------
+    camshift.py [<video source>]
+
+    To initialize tracking, select the object with mouse
+
+Keys:
+-----
+    ESC   - exit
+    b     - toggle back-projected probability visualization
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+
+# local module
+import video
+from video import presets
+
+
+class App(object):
+    def __init__(self, video_src):
+        self.cam = video.create_capture(video_src, presets['cube'])
+        _ret, self.frame = self.cam.read()
+        cv.namedWindow('camshift')
+        cv.setMouseCallback('camshift', self.onmouse)
+
+        self.selection = None
+        self.drag_start = None
+        self.show_backproj = False
+        self.track_window = None
+
+    def onmouse(self, event, x, y, flags, param):
+        if event == cv.EVENT_LBUTTONDOWN:
+            self.drag_start = (x, y)
+            self.track_window = None
+        if self.drag_start:
+            xmin = min(x, self.drag_start[0])
+            ymin = min(y, self.drag_start[1])
+            xmax = max(x, self.drag_start[0])
+            ymax = max(y, self.drag_start[1])
+            self.selection = (xmin, ymin, xmax, ymax)
+        if event == cv.EVENT_LBUTTONUP:
+            self.drag_start = None
+            self.track_window = (xmin, ymin, xmax - xmin, ymax - ymin)
+
+    def show_hist(self):
+        bin_count = self.hist.shape[0]
+        bin_w = 24
+        img = np.zeros((256, bin_count*bin_w, 3), np.uint8)
+        for i in xrange(bin_count):
+            h = int(self.hist[i])
+            cv.rectangle(img, (i*bin_w+2, 255), ((i+1)*bin_w-2, 255-h), (int(180.0*i/bin_count), 255, 255), -1)
+        img = cv.cvtColor(img, cv.COLOR_HSV2BGR)
+        cv.imshow('hist', img)
+
+    def run(self):
+        while True:
+            _ret, self.frame = self.cam.read()
+            vis = self.frame.copy()
+            hsv = cv.cvtColor(self.frame, cv.COLOR_BGR2HSV)
+            mask = cv.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.)))
+
+            if self.selection:
+                x0, y0, x1, y1 = self.selection
+                hsv_roi = hsv[y0:y1, x0:x1]
+                mask_roi = mask[y0:y1, x0:x1]
+                hist = cv.calcHist( [hsv_roi], [0], mask_roi, [16], [0, 180] )
+                cv.normalize(hist, hist, 0, 255, cv.NORM_MINMAX)
+                self.hist = hist.reshape(-1)
+                self.show_hist()
+
+                vis_roi = vis[y0:y1, x0:x1]
+                cv.bitwise_not(vis_roi, vis_roi)
+                vis[mask == 0] = 0
+
+            if self.track_window and self.track_window[2] > 0 and self.track_window[3] > 0:
+                self.selection = None
+                prob = cv.calcBackProject([hsv], [0], self.hist, [0, 180], 1)
+                prob &= mask
+                term_crit = ( cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1 )
+                track_box, self.track_window = cv.CamShift(prob, self.track_window, term_crit)
+
+                if self.show_backproj:
+                    vis[:] = prob[...,np.newaxis]
+                try:
+                    cv.ellipse(vis, track_box, (0, 0, 255), 2)
+                except:
+                    print(track_box)
+
+            cv.imshow('camshift', vis)
+
+            ch = cv.waitKey(5)
+            if ch == 27:
+                break
+            if ch == ord('b'):
+                self.show_backproj = not self.show_backproj
+        cv.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    import sys
+    try:
+        video_src = sys.argv[1]
+    except:
+        video_src = 0
+    App(video_src).run()
diff --git a/C++/opencv-4.7.0/samples/python/coherence.py b/C++/opencv-4.7.0/samples/python/coherence.py
new file mode 100644
index 00000000..147b33ee
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/coherence.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+
+'''
+Coherence-enhancing filtering example
+=====================================
+
+inspired by
+  Joachim Weickert "Coherence-Enhancing Shock Filters"
+  http://www.mia.uni-saarland.de/Publications/weickert-dagm03.pdf
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+
+def coherence_filter(img, sigma = 11, str_sigma = 11, blend = 0.5, iter_n = 4):
+    h, w = img.shape[:2]
+
+    for i in xrange(iter_n):
+        print(i)
+
+        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+        eigen = cv.cornerEigenValsAndVecs(gray, str_sigma, 3)
+        eigen = eigen.reshape(h, w, 3, 2)  # [[e1, e2], v1, v2]
+        x, y = eigen[:,:,1,0], eigen[:,:,1,1]
+
+        gxx = cv.Sobel(gray, cv.CV_32F, 2, 0, ksize=sigma)
+        gxy = cv.Sobel(gray, cv.CV_32F, 1, 1, ksize=sigma)
+        gyy = cv.Sobel(gray, cv.CV_32F, 0, 2, ksize=sigma)
+        gvv = x*x*gxx + 2*x*y*gxy + y*y*gyy
+        m = gvv < 0
+
+        ero = cv.erode(img, None)
+        dil = cv.dilate(img, None)
+        img1 = ero
+        img1[m] = dil[m]
+        img = np.uint8(img*(1.0 - blend) + img1*blend)
+    print('done')
+    return img
+
+
+def main():
+    import sys
+    try:
+        fn = sys.argv[1]
+    except:
+        fn = 'baboon.jpg'
+
+    src = cv.imread(cv.samples.findFile(fn))
+
+    def nothing(*argv):
+        pass
+
+    def update():
+        sigma = cv.getTrackbarPos('sigma', 'control')*2+1
+        str_sigma = cv.getTrackbarPos('str_sigma', 'control')*2+1
+        blend = cv.getTrackbarPos('blend', 'control') / 10.0
+        print('sigma: %d  str_sigma: %d  blend_coef: %f' % (sigma, str_sigma, blend))
+        dst = coherence_filter(src, sigma=sigma, str_sigma = str_sigma, blend = blend)
+        cv.imshow('dst', dst)
+
+    cv.namedWindow('control', 0)
+    cv.createTrackbar('sigma', 'control', 9, 15, nothing)
+    cv.createTrackbar('blend', 'control', 7, 10, nothing)
+    cv.createTrackbar('str_sigma', 'control', 9, 15, nothing)
+
+
+    print('Press SPACE to update the image\n')
+
+    cv.imshow('src', src)
+    update()
+    while True:
+        ch = cv.waitKey()
+        if ch == ord(' '):
+            update()
+        if ch == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/color_histogram.py b/C++/opencv-4.7.0/samples/python/color_histogram.py
new file mode 100644
index 00000000..a1924bab
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/color_histogram.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+'''
+Video histogram sample to show live histogram of video
+
+Keys:
+    ESC    - exit
+
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+# built-in modules
+import sys
+
+# local modules
+import video
+
+class App():
+
+    def set_scale(self, val):
+        self.hist_scale = val
+
+    def run(self):
+        hsv_map = np.zeros((180, 256, 3), np.uint8)
+        h, s = np.indices(hsv_map.shape[:2])
+        hsv_map[:,:,0] = h
+        hsv_map[:,:,1] = s
+        hsv_map[:,:,2] = 255
+        hsv_map = cv.cvtColor(hsv_map, cv.COLOR_HSV2BGR)
+        cv.imshow('hsv_map', hsv_map)
+
+        cv.namedWindow('hist', 0)
+        self.hist_scale = 10
+
+        cv.createTrackbar('scale', 'hist', self.hist_scale, 32, self.set_scale)
+
+        try:
+            fn = sys.argv[1]
+        except:
+            fn = 0
+        cam = video.create_capture(fn, fallback='synth:bg=baboon.jpg:class=chess:noise=0.05')
+
+        while True:
+            _flag, frame = cam.read()
+            cv.imshow('camera', frame)
+
+            small = cv.pyrDown(frame)
+
+            hsv = cv.cvtColor(small, cv.COLOR_BGR2HSV)
+            dark = hsv[...,2] < 32
+            hsv[dark] = 0
+            h = cv.calcHist([hsv], [0, 1], None, [180, 256], [0, 180, 0, 256])
+
+            h = np.clip(h*0.005*self.hist_scale, 0, 1)
+            vis = hsv_map*h[:,:,np.newaxis] / 255.0
+            cv.imshow('hist', vis)
+
+            ch = cv.waitKey(1)
+            if ch == 27:
+                break
+
+        print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    App().run()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/common.py b/C++/opencv-4.7.0/samples/python/common.py
new file mode 100644
index 00000000..e7ad478b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/common.py
@@ -0,0 +1,237 @@
+#!/usr/bin/env python
+
+'''
+This module contains some common routines used by other samples.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    from functools import reduce
+
+import numpy as np
+import cv2 as cv
+
+# built-in modules
+import os
+import itertools as it
+from contextlib import contextmanager
+
+image_extensions = ['.bmp', '.jpg', '.jpeg', '.png', '.tif', '.tiff', '.pbm', '.pgm', '.ppm']
+
+class Bunch(object):
+    def __init__(self, **kw):
+        self.__dict__.update(kw)
+    def __str__(self):
+        return str(self.__dict__)
+
+def splitfn(fn):
+    path, fn = os.path.split(fn)
+    name, ext = os.path.splitext(fn)
+    return path, name, ext
+
+def anorm2(a):
+    return (a*a).sum(-1)
+def anorm(a):
+    return np.sqrt( anorm2(a) )
+
+def homotrans(H, x, y):
+    xs = H[0, 0]*x + H[0, 1]*y + H[0, 2]
+    ys = H[1, 0]*x + H[1, 1]*y + H[1, 2]
+    s  = H[2, 0]*x + H[2, 1]*y + H[2, 2]
+    return xs/s, ys/s
+
+def to_rect(a):
+    a = np.ravel(a)
+    if len(a) == 2:
+        a = (0, 0, a[0], a[1])
+    return np.array(a, np.float64).reshape(2, 2)
+
+def rect2rect_mtx(src, dst):
+    src, dst = to_rect(src), to_rect(dst)
+    cx, cy = (dst[1] - dst[0]) / (src[1] - src[0])
+    tx, ty = dst[0] - src[0] * (cx, cy)
+    M = np.float64([[ cx,  0, tx],
+                    [  0, cy, ty],
+                    [  0,  0,  1]])
+    return M
+
+
+def lookat(eye, target, up = (0, 0, 1)):
+    fwd = np.asarray(target, np.float64) - eye
+    fwd /= anorm(fwd)
+    right = np.cross(fwd, up)
+    right /= anorm(right)
+    down = np.cross(fwd, right)
+    R = np.float64([right, down, fwd])
+    tvec = -np.dot(R, eye)
+    return R, tvec
+
+def mtx2rvec(R):
+    w, u, vt = cv.SVDecomp(R - np.eye(3))
+    p = vt[0] + u[:,0]*w[0]    # same as np.dot(R, vt[0])
+    c = np.dot(vt[0], p)
+    s = np.dot(vt[1], p)
+    axis = np.cross(vt[0], vt[1])
+    return axis * np.arctan2(s, c)
+
+def draw_str(dst, target, s):
+    x, y = target
+    cv.putText(dst, s, (x+1, y+1), cv.FONT_HERSHEY_PLAIN, 1.0, (0, 0, 0), thickness = 2, lineType=cv.LINE_AA)
+    cv.putText(dst, s, (x, y), cv.FONT_HERSHEY_PLAIN, 1.0, (255, 255, 255), lineType=cv.LINE_AA)
+
+class Sketcher:
+    def __init__(self, windowname, dests, colors_func):
+        self.prev_pt = None
+        self.windowname = windowname
+        self.dests = dests
+        self.colors_func = colors_func
+        self.dirty = False
+        self.show()
+        cv.setMouseCallback(self.windowname, self.on_mouse)
+
+    def show(self):
+        cv.imshow(self.windowname, self.dests[0])
+
+    def on_mouse(self, event, x, y, flags, param):
+        pt = (x, y)
+        if event == cv.EVENT_LBUTTONDOWN:
+            self.prev_pt = pt
+        elif event == cv.EVENT_LBUTTONUP:
+            self.prev_pt = None
+
+        if self.prev_pt and flags & cv.EVENT_FLAG_LBUTTON:
+            for dst, color in zip(self.dests, self.colors_func()):
+                cv.line(dst, self.prev_pt, pt, color, 5)
+            self.dirty = True
+            self.prev_pt = pt
+            self.show()
+
+
+# palette data from matplotlib/_cm.py
+_jet_data =   {'red':   ((0., 0, 0), (0.35, 0, 0), (0.66, 1, 1), (0.89,1, 1),
+                         (1, 0.5, 0.5)),
+               'green': ((0., 0, 0), (0.125,0, 0), (0.375,1, 1), (0.64,1, 1),
+                         (0.91,0,0), (1, 0, 0)),
+               'blue':  ((0., 0.5, 0.5), (0.11, 1, 1), (0.34, 1, 1), (0.65,0, 0),
+                         (1, 0, 0))}
+
+cmap_data = { 'jet' : _jet_data }
+
+def make_cmap(name, n=256):
+    data = cmap_data[name]
+    xs = np.linspace(0.0, 1.0, n)
+    channels = []
+    eps = 1e-6
+    for ch_name in ['blue', 'green', 'red']:
+        ch_data = data[ch_name]
+        xp, yp = [], []
+        for x, y1, y2 in ch_data:
+            xp += [x, x+eps]
+            yp += [y1, y2]
+        ch = np.interp(xs, xp, yp)
+        channels.append(ch)
+    return np.uint8(np.array(channels).T*255)
+
+def nothing(*arg, **kw):
+    pass
+
+def clock():
+    return cv.getTickCount() / cv.getTickFrequency()
+
+@contextmanager
+def Timer(msg):
+    print(msg, '...',)
+    start = clock()
+    try:
+        yield
+    finally:
+        print("%.2f ms" % ((clock()-start)*1000))
+
+class StatValue:
+    def __init__(self, smooth_coef = 0.5):
+        self.value = None
+        self.smooth_coef = smooth_coef
+    def update(self, v):
+        if self.value is None:
+            self.value = v
+        else:
+            c = self.smooth_coef
+            self.value = c * self.value + (1.0-c) * v
+
+class RectSelector:
+    def __init__(self, win, callback):
+        self.win = win
+        self.callback = callback
+        cv.setMouseCallback(win, self.onmouse)
+        self.drag_start = None
+        self.drag_rect = None
+    def onmouse(self, event, x, y, flags, param):
+        x, y = np.int16([x, y]) # BUG
+        if event == cv.EVENT_LBUTTONDOWN:
+            self.drag_start = (x, y)
+            return
+        if self.drag_start:
+            if flags & cv.EVENT_FLAG_LBUTTON:
+                xo, yo = self.drag_start
+                x0, y0 = np.minimum([xo, yo], [x, y])
+                x1, y1 = np.maximum([xo, yo], [x, y])
+                self.drag_rect = None
+                if x1-x0 > 0 and y1-y0 > 0:
+                    self.drag_rect = (x0, y0, x1, y1)
+            else:
+                rect = self.drag_rect
+                self.drag_start = None
+                self.drag_rect = None
+                if rect:
+                    self.callback(rect)
+    def draw(self, vis):
+        if not self.drag_rect:
+            return False
+        x0, y0, x1, y1 = self.drag_rect
+        cv.rectangle(vis, (x0, y0), (x1, y1), (0, 255, 0), 2)
+        return True
+    @property
+    def dragging(self):
+        return self.drag_rect is not None
+
+
+def grouper(n, iterable, fillvalue=None):
+    '''grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx'''
+    args = [iter(iterable)] * n
+    if PY3:
+        output = it.zip_longest(fillvalue=fillvalue, *args)
+    else:
+        output = it.izip_longest(fillvalue=fillvalue, *args)
+    return output
+
+def mosaic(w, imgs):
+    '''Make a grid from images.
+
+    w    -- number of grid columns
+    imgs -- images (must have same size and format)
+    '''
+    imgs = iter(imgs)
+    if PY3:
+        img0 = next(imgs)
+    else:
+        img0 = imgs.next()
+    pad = np.zeros_like(img0)
+    imgs = it.chain([img0], imgs)
+    rows = grouper(w, imgs, pad)
+    return np.vstack(list(map(np.hstack, rows)))
+
+def getsize(img):
+    h, w = img.shape[:2]
+    return w, h
+
+def mdot(*args):
+    return reduce(np.dot, args)
+
+def draw_keypoints(vis, keypoints, color = (0, 255, 255)):
+    for kp in keypoints:
+        x, y = kp.pt
+        cv.circle(vis, (int(x), int(y)), 2, color)
diff --git a/C++/opencv-4.7.0/samples/python/contours.py b/C++/opencv-4.7.0/samples/python/contours.py
new file mode 100644
index 00000000..285e376a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/contours.py
@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+
+'''
+This program illustrates the use of findContours and drawContours.
+The original image is put up along with the image of drawn contours.
+
+Usage:
+    contours.py
+A trackbar is put up which controls the contour level from -3 to 3
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+
+def make_image():
+    img = np.zeros((500, 500), np.uint8)
+    black, white = 0, 255
+    for i in xrange(6):
+        dx = int((i%2)*250 - 30)
+        dy = int((i/2.)*150)
+
+        if i == 0:
+            for j in xrange(11):
+                angle = (j+5)*np.pi/21
+                c, s = np.cos(angle), np.sin(angle)
+                x1, y1 = np.int32([dx+100+j*10-80*c, dy+100-90*s])
+                x2, y2 = np.int32([dx+100+j*10-30*c, dy+100-30*s])
+                cv.line(img, (x1, y1), (x2, y2), white)
+
+        cv.ellipse( img, (dx+150, dy+100), (100,70), 0, 0, 360, white, -1 )
+        cv.ellipse( img, (dx+115, dy+70), (30,20), 0, 0, 360, black, -1 )
+        cv.ellipse( img, (dx+185, dy+70), (30,20), 0, 0, 360, black, -1 )
+        cv.ellipse( img, (dx+115, dy+70), (15,15), 0, 0, 360, white, -1 )
+        cv.ellipse( img, (dx+185, dy+70), (15,15), 0, 0, 360, white, -1 )
+        cv.ellipse( img, (dx+115, dy+70), (5,5), 0, 0, 360, black, -1 )
+        cv.ellipse( img, (dx+185, dy+70), (5,5), 0, 0, 360, black, -1 )
+        cv.ellipse( img, (dx+150, dy+100), (10,5), 0, 0, 360, black, -1 )
+        cv.ellipse( img, (dx+150, dy+150), (40,10), 0, 0, 360, black, -1 )
+        cv.ellipse( img, (dx+27, dy+100), (20,35), 0, 0, 360, white, -1 )
+        cv.ellipse( img, (dx+273, dy+100), (20,35), 0, 0, 360, white, -1 )
+    return img
+
+def main():
+    img = make_image()
+    h, w = img.shape[:2]
+
+    contours0, hierarchy = cv.findContours( img.copy(), cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+    contours = [cv.approxPolyDP(cnt, 3, True) for cnt in contours0]
+
+    def update(levels):
+        vis = np.zeros((h, w, 3), np.uint8)
+        levels = levels - 3
+        cv.drawContours( vis, contours, (-1, 2)[levels <= 0], (128,255,255),
+            3, cv.LINE_AA, hierarchy, abs(levels) )
+        cv.imshow('contours', vis)
+    update(3)
+    cv.createTrackbar( "levels+3", "contours", 3, 7, update )
+    cv.imshow('image', img)
+    cv.waitKey()
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/deconvolution.py b/C++/opencv-4.7.0/samples/python/deconvolution.py
new file mode 100644
index 00000000..b276ca8c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/deconvolution.py
@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+
+'''
+Wiener deconvolution.
+
+Sample shows how DFT can be used to perform Weiner deconvolution [1]
+of an image with user-defined point spread function (PSF)
+
+Usage:
+  deconvolution.py  [--circle]
+      [--angle <degrees>]
+      [--d <diameter>]
+      [--snr <signal/noise ratio in db>]
+      [<input image>]
+
+  Use sliders to adjust PSF paramitiers.
+  Keys:
+    SPACE - switch btw linear/circular PSF
+    ESC   - exit
+
+Examples:
+  deconvolution.py --angle 135 --d 22  licenseplate_motion.jpg
+    (image source: http://www.topazlabs.com/infocus/_images/licenseplate_compare.jpg)
+
+  deconvolution.py --angle 86 --d 31  text_motion.jpg
+  deconvolution.py --circle --d 19  text_defocus.jpg
+    (image source: compact digital photo camera, no artificial distortion)
+
+
+[1] http://en.wikipedia.org/wiki/Wiener_deconvolution
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+# local module
+from common import nothing
+
+
+def blur_edge(img, d=31):
+    h, w  = img.shape[:2]
+    img_pad = cv.copyMakeBorder(img, d, d, d, d, cv.BORDER_WRAP)
+    img_blur = cv.GaussianBlur(img_pad, (2*d+1, 2*d+1), -1)[d:-d,d:-d]
+    y, x = np.indices((h, w))
+    dist = np.dstack([x, w-x-1, y, h-y-1]).min(-1)
+    w = np.minimum(np.float32(dist)/d, 1.0)
+    return img*w + img_blur*(1-w)
+
+def motion_kernel(angle, d, sz=65):
+    kern = np.ones((1, d), np.float32)
+    c, s = np.cos(angle), np.sin(angle)
+    A = np.float32([[c, -s, 0], [s, c, 0]])
+    sz2 = sz // 2
+    A[:,2] = (sz2, sz2) - np.dot(A[:,:2], ((d-1)*0.5, 0))
+    kern = cv.warpAffine(kern, A, (sz, sz), flags=cv.INTER_CUBIC)
+    return kern
+
+def defocus_kernel(d, sz=65):
+    kern = np.zeros((sz, sz), np.uint8)
+    cv.circle(kern, (sz, sz), d, 255, -1, cv.LINE_AA, shift=1)
+    kern = np.float32(kern) / 255.0
+    return kern
+
+
+def main():
+    import sys, getopt
+    opts, args = getopt.getopt(sys.argv[1:], '', ['circle', 'angle=', 'd=', 'snr='])
+    opts = dict(opts)
+    try:
+        fn = args[0]
+    except:
+        fn = 'licenseplate_motion.jpg'
+
+    win = 'deconvolution'
+
+    img = cv.imread(cv.samples.findFile(fn), cv.IMREAD_GRAYSCALE)
+    if img is None:
+        print('Failed to load file:', fn)
+        sys.exit(1)
+
+    img = np.float32(img)/255.0
+    cv.imshow('input', img)
+
+    img = blur_edge(img)
+    IMG = cv.dft(img, flags=cv.DFT_COMPLEX_OUTPUT)
+
+    defocus = '--circle' in opts
+
+    def update(_):
+        ang = np.deg2rad( cv.getTrackbarPos('angle', win) )
+        d = cv.getTrackbarPos('d', win)
+        noise = 10**(-0.1*cv.getTrackbarPos('SNR (db)', win))
+
+        if defocus:
+            psf = defocus_kernel(d)
+        else:
+            psf = motion_kernel(ang, d)
+        cv.imshow('psf', psf)
+
+        psf /= psf.sum()
+        psf_pad = np.zeros_like(img)
+        kh, kw = psf.shape
+        psf_pad[:kh, :kw] = psf
+        PSF = cv.dft(psf_pad, flags=cv.DFT_COMPLEX_OUTPUT, nonzeroRows = kh)
+        PSF2 = (PSF**2).sum(-1)
+        iPSF = PSF / (PSF2 + noise)[...,np.newaxis]
+        RES = cv.mulSpectrums(IMG, iPSF, 0)
+        res = cv.idft(RES, flags=cv.DFT_SCALE | cv.DFT_REAL_OUTPUT )
+        res = np.roll(res, -kh//2, 0)
+        res = np.roll(res, -kw//2, 1)
+        cv.imshow(win, res)
+
+    cv.namedWindow(win)
+    cv.namedWindow('psf', 0)
+    cv.createTrackbar('angle', win, int(opts.get('--angle', 135)), 180, update)
+    cv.createTrackbar('d', win, int(opts.get('--d', 22)), 50, update)
+    cv.createTrackbar('SNR (db)', win, int(opts.get('--snr', 25)), 50, update)
+    update(None)
+
+    while True:
+        ch = cv.waitKey()
+        if ch == 27:
+            break
+        if ch == ord(' '):
+            defocus = not defocus
+            update(None)
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/demo.py b/C++/opencv-4.7.0/samples/python/demo.py
new file mode 100644
index 00000000..a56614ce
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/demo.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python
+
+'''
+Sample-launcher application.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+
+# local modules
+from common import splitfn
+
+# built-in modules
+import webbrowser
+from glob import glob
+from subprocess import Popen
+
+try:
+    import tkinter as tk  # Python 3
+    from tkinter.scrolledtext import ScrolledText
+except ImportError:
+    import Tkinter as tk  # Python 2
+    from ScrolledText import ScrolledText
+
+
+#from IPython.Shell import IPShellEmbed
+#ipshell = IPShellEmbed()
+
+exclude_list = ['demo', 'common']
+
+class LinkManager:
+    def __init__(self, text, url_callback = None):
+        self.text = text
+        self.text.tag_config("link", foreground="blue", underline=1)
+        self.text.tag_bind("link", "<Enter>", self._enter)
+        self.text.tag_bind("link", "<Leave>", self._leave)
+        self.text.tag_bind("link", "<Button-1>", self._click)
+
+        self.url_callback = url_callback
+        self.reset()
+
+    def reset(self):
+        self.links = {}
+    def add(self, action):
+        # add an action to the manager.  returns tags to use in
+        # associated text widget
+        tag = "link-%d" % len(self.links)
+        self.links[tag] = action
+        return "link", tag
+
+    def _enter(self, event):
+        self.text.config(cursor="hand2")
+    def _leave(self, event):
+        self.text.config(cursor="")
+    def _click(self, event):
+        for tag in self.text.tag_names(tk.CURRENT):
+            if tag.startswith("link-"):
+                proc = self.links[tag]
+                if callable(proc):
+                    proc()
+                else:
+                    if self.url_callback:
+                        self.url_callback(proc)
+
+class App:
+    def __init__(self):
+        root = tk.Tk()
+        root.title('OpenCV Demo')
+
+        self.win = win = tk.PanedWindow(root, orient=tk.HORIZONTAL, sashrelief=tk.RAISED, sashwidth=4)
+        self.win.pack(fill=tk.BOTH, expand=1)
+
+        left = tk.Frame(win)
+        right = tk.Frame(win)
+        win.add(left)
+        win.add(right)
+
+        scrollbar = tk.Scrollbar(left, orient=tk.VERTICAL)
+        self.demos_lb = demos_lb = tk.Listbox(left, yscrollcommand=scrollbar.set)
+        scrollbar.config(command=demos_lb.yview)
+        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        demos_lb.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
+
+        self.samples = {}
+        for fn in glob('*.py'):
+            name = splitfn(fn)[1]
+            if fn[0] != '_' and name not in exclude_list:
+                self.samples[name] = fn
+
+        for name in sorted(self.samples):
+            demos_lb.insert(tk.END, name)
+
+        demos_lb.bind('<<ListboxSelect>>', self.on_demo_select)
+
+        self.cmd_entry = cmd_entry = tk.Entry(right)
+        cmd_entry.bind('<Return>', self.on_run)
+        run_btn = tk.Button(right, command=self.on_run, text='Run', width=8)
+
+        self.text = text = ScrolledText(right, font=('arial', 12, 'normal'), width = 30, wrap='word')
+        self.linker = _linker = LinkManager(text, self.on_link)
+        self.text.tag_config("header1", font=('arial', 14, 'bold'))
+        self.text.tag_config("header2", font=('arial', 12, 'bold'))
+        text.config(state='disabled')
+
+        text.pack(fill='both', expand=1, side=tk.BOTTOM)
+        cmd_entry.pack(fill='x', side='left' , expand=1)
+        run_btn.pack()
+
+    def on_link(self, url):
+        print(url)
+        webbrowser.open(url)
+
+    def on_demo_select(self, evt):
+        name = self.demos_lb.get( self.demos_lb.curselection()[0] )
+        fn = self.samples[name]
+
+        descr = ""
+        try:
+            if sys.version_info[0] > 2:
+                # Python 3.x
+                module_globals = {}
+                module_locals = {}
+                with open(fn, 'r') as f:
+                    module_code = f.read()
+                exec(compile(module_code, fn, 'exec'), module_globals, module_locals)
+                descr = module_locals.get('__doc__', 'no-description')
+            else:
+                # Python 2
+                module_globals = {}
+                execfile(fn, module_globals)  # noqa: F821
+                descr = module_globals.get('__doc__', 'no-description')
+        except Exception as e:
+            descr = str(e)
+
+        self.linker.reset()
+        self.text.config(state='normal')
+        self.text.delete(1.0, tk.END)
+        self.format_text(descr)
+        self.text.config(state='disabled')
+
+        self.cmd_entry.delete(0, tk.END)
+        self.cmd_entry.insert(0, fn)
+
+    def format_text(self, s):
+        text = self.text
+        lines = s.splitlines()
+        for i, s in enumerate(lines):
+            s = s.rstrip()
+            if i == 0 and not s:
+                continue
+            if s and s == '='*len(s):
+                text.tag_add('header1', 'end-2l', 'end-1l')
+            elif s and s == '-'*len(s):
+                text.tag_add('header2', 'end-2l', 'end-1l')
+            else:
+                text.insert('end', s+'\n')
+
+        def add_link(start, end, url):
+            for tag in self.linker.add(url):
+                text.tag_add(tag, start, end)
+        self.match_text(r'http://\S+', add_link)
+
+    def match_text(self, pattern, tag_proc, regexp=True):
+        text = self.text
+        text.mark_set('matchPos', '1.0')
+        count = tk.IntVar()
+        while True:
+            match_index = text.search(pattern, 'matchPos', count=count, regexp=regexp, stopindex='end')
+            if not match_index:
+                break
+            end_index = text.index( "%s+%sc" % (match_index, count.get()) )
+            text.mark_set('matchPos', end_index)
+            if callable(tag_proc):
+                tag_proc(match_index, end_index, text.get(match_index, end_index))
+            else:
+                text.tag_add(tag_proc, match_index, end_index)
+
+    def on_run(self, *args):
+        cmd = self.cmd_entry.get()
+        print('running:', cmd)
+        Popen(sys.executable + ' ' + cmd, shell=True)
+
+    def run(self):
+        tk.mainloop()
+
+
+if __name__ == '__main__':
+    App().run()
diff --git a/C++/opencv-4.7.0/samples/python/dft.py b/C++/opencv-4.7.0/samples/python/dft.py
new file mode 100644
index 00000000..98bc87dc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/dft.py
@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+
+'''
+sample for disctrete fourier transform (dft)
+
+USAGE:
+    dft.py <image_file>
+'''
+
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import sys
+
+
+def shift_dft(src, dst=None):
+    '''
+        Rearrange the quadrants of Fourier image so that the origin is at
+        the image center. Swaps quadrant 1 with 3, and 2 with 4.
+
+        src and dst arrays must be equal size & type
+    '''
+
+    if dst is None:
+        dst = np.empty(src.shape, src.dtype)
+    elif src.shape != dst.shape:
+        raise ValueError("src and dst must have equal sizes")
+    elif src.dtype != dst.dtype:
+        raise TypeError("src and dst must have equal types")
+
+    if src is dst:
+        ret = np.empty(src.shape, src.dtype)
+    else:
+        ret = dst
+
+    h, w = src.shape[:2]
+
+    cx1 = cx2 = w // 2
+    cy1 = cy2 = h // 2
+
+    # if the size is odd, then adjust the bottom/right quadrants
+    if w % 2 != 0:
+        cx2 += 1
+    if h % 2 != 0:
+        cy2 += 1
+
+    # swap quadrants
+
+    # swap q1 and q3
+    ret[h-cy1:, w-cx1:] = src[0:cy1 , 0:cx1 ]   # q1 -> q3
+    ret[0:cy2 , 0:cx2 ] = src[h-cy2:, w-cx2:]   # q3 -> q1
+
+    # swap q2 and q4
+    ret[0:cy2 , w-cx2:] = src[h-cy2:, 0:cx2 ]   # q2 -> q4
+    ret[h-cy1:, 0:cx1 ] = src[0:cy1 , w-cx1:]   # q4 -> q2
+
+    if src is dst:
+        dst[:,:] = ret
+
+    return dst
+
+
+def main():
+    if len(sys.argv) > 1:
+        fname = sys.argv[1]
+    else:
+        fname = 'baboon.jpg'
+        print("usage : python dft.py <image_file>")
+
+    im = cv.imread(cv.samples.findFile(fname))
+
+    # convert to grayscale
+    im = cv.cvtColor(im, cv.COLOR_BGR2GRAY)
+    h, w = im.shape[:2]
+
+    realInput = im.astype(np.float64)
+
+    # perform an optimally sized dft
+    dft_M = cv.getOptimalDFTSize(w)
+    dft_N = cv.getOptimalDFTSize(h)
+
+    # copy A to dft_A and pad dft_A with zeros
+    dft_A = np.zeros((dft_N, dft_M, 2), dtype=np.float64)
+    dft_A[:h, :w, 0] = realInput
+
+    # no need to pad bottom part of dft_A with zeros because of
+    # use of nonzeroRows parameter in cv.dft()
+    cv.dft(dft_A, dst=dft_A, nonzeroRows=h)
+
+    cv.imshow("win", im)
+
+    # Split fourier into real and imaginary parts
+    image_Re, image_Im = cv.split(dft_A)
+
+    # Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
+    magnitude = cv.sqrt(image_Re**2.0 + image_Im**2.0)
+
+    # Compute log(1 + Mag)
+    log_spectrum = cv.log(1.0 + magnitude)
+
+    # Rearrange the quadrants of Fourier image so that the origin is at
+    # the image center
+    shift_dft(log_spectrum, log_spectrum)
+
+    # normalize and display the results as rgb
+    cv.normalize(log_spectrum, log_spectrum, 0.0, 1.0, cv.NORM_MINMAX)
+    cv.imshow("magnitude", log_spectrum)
+
+    cv.waitKey(0)
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/digits.py b/C++/opencv-4.7.0/samples/python/digits.py
new file mode 100644
index 00000000..25db411f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/digits.py
@@ -0,0 +1,194 @@
+#!/usr/bin/env python
+
+'''
+SVM and KNearest digit recognition.
+
+Sample loads a dataset of handwritten digits from 'digits.png'.
+Then it trains a SVM and KNearest classifiers on it and evaluates
+their accuracy.
+
+Following preprocessing is applied to the dataset:
+ - Moment-based image deskew (see deskew())
+ - Digit images are split into 4 10x10 cells and 16-bin
+   histogram of oriented gradients is computed for each
+   cell
+ - Transform histograms to space with Hellinger metric (see [1] (RootSIFT))
+
+
+[1] R. Arandjelovic, A. Zisserman
+    "Three things everyone should know to improve object retrieval"
+    http://www.robots.ox.ac.uk/~vgg/publications/2012/Arandjelovic12/arandjelovic12.pdf
+
+Usage:
+   digits.py
+'''
+
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+# built-in modules
+from multiprocessing.pool import ThreadPool
+
+from numpy.linalg import norm
+
+# local modules
+from common import clock, mosaic
+
+
+
+SZ = 20 # size of each digit is SZ x SZ
+CLASS_N = 10
+DIGITS_FN = 'digits.png'
+
+def split2d(img, cell_size, flatten=True):
+    h, w = img.shape[:2]
+    sx, sy = cell_size
+    cells = [np.hsplit(row, w//sx) for row in np.vsplit(img, h//sy)]
+    cells = np.array(cells)
+    if flatten:
+        cells = cells.reshape(-1, sy, sx)
+    return cells
+
+def load_digits(fn):
+    fn = cv.samples.findFile(fn)
+    print('loading "%s" ...' % fn)
+    digits_img = cv.imread(fn, cv.IMREAD_GRAYSCALE)
+    digits = split2d(digits_img, (SZ, SZ))
+    labels = np.repeat(np.arange(CLASS_N), len(digits)/CLASS_N)
+    return digits, labels
+
+def deskew(img):
+    m = cv.moments(img)
+    if abs(m['mu02']) < 1e-2:
+        return img.copy()
+    skew = m['mu11']/m['mu02']
+    M = np.float32([[1, skew, -0.5*SZ*skew], [0, 1, 0]])
+    img = cv.warpAffine(img, M, (SZ, SZ), flags=cv.WARP_INVERSE_MAP | cv.INTER_LINEAR)
+    return img
+
+
+class KNearest(object):
+    def __init__(self, k = 3):
+        self.k = k
+        self.model = cv.ml.KNearest_create()
+
+    def train(self, samples, responses):
+        self.model.train(samples, cv.ml.ROW_SAMPLE, responses)
+
+    def predict(self, samples):
+        _retval, results, _neigh_resp, _dists = self.model.findNearest(samples, self.k)
+        return results.ravel()
+
+    def load(self, fn):
+        self.model = cv.ml.KNearest_load(fn)
+
+    def save(self, fn):
+        self.model.save(fn)
+
+class SVM(object):
+    def __init__(self, C = 1, gamma = 0.5):
+        self.model = cv.ml.SVM_create()
+        self.model.setGamma(gamma)
+        self.model.setC(C)
+        self.model.setKernel(cv.ml.SVM_RBF)
+        self.model.setType(cv.ml.SVM_C_SVC)
+
+    def train(self, samples, responses):
+        self.model.train(samples, cv.ml.ROW_SAMPLE, responses)
+
+    def predict(self, samples):
+        return self.model.predict(samples)[1].ravel()
+
+    def load(self, fn):
+        self.model = cv.ml.SVM_load(fn)
+
+    def save(self, fn):
+        self.model.save(fn)
+
+def evaluate_model(model, digits, samples, labels):
+    resp = model.predict(samples)
+    err = (labels != resp).mean()
+    print('error: %.2f %%' % (err*100))
+
+    confusion = np.zeros((10, 10), np.int32)
+    for i, j in zip(labels, resp):
+        confusion[i, int(j)] += 1
+    print('confusion matrix:')
+    print(confusion)
+    print()
+
+    vis = []
+    for img, flag in zip(digits, resp == labels):
+        img = cv.cvtColor(img, cv.COLOR_GRAY2BGR)
+        if not flag:
+            img[...,:2] = 0
+        vis.append(img)
+    return mosaic(25, vis)
+
+def preprocess_simple(digits):
+    return np.float32(digits).reshape(-1, SZ*SZ) / 255.0
+
+def preprocess_hog(digits):
+    samples = []
+    for img in digits:
+        gx = cv.Sobel(img, cv.CV_32F, 1, 0)
+        gy = cv.Sobel(img, cv.CV_32F, 0, 1)
+        mag, ang = cv.cartToPolar(gx, gy)
+        bin_n = 16
+        bin = np.int32(bin_n*ang/(2*np.pi))
+        bin_cells = bin[:10,:10], bin[10:,:10], bin[:10,10:], bin[10:,10:]
+        mag_cells = mag[:10,:10], mag[10:,:10], mag[:10,10:], mag[10:,10:]
+        hists = [np.bincount(b.ravel(), m.ravel(), bin_n) for b, m in zip(bin_cells, mag_cells)]
+        hist = np.hstack(hists)
+
+        # transform to Hellinger kernel
+        eps = 1e-7
+        hist /= hist.sum() + eps
+        hist = np.sqrt(hist)
+        hist /= norm(hist) + eps
+
+        samples.append(hist)
+    return np.float32(samples)
+
+
+if __name__ == '__main__':
+    print(__doc__)
+
+    digits, labels = load_digits(DIGITS_FN)
+
+    print('preprocessing...')
+    # shuffle digits
+    rand = np.random.RandomState(321)
+    shuffle = rand.permutation(len(digits))
+    digits, labels = digits[shuffle], labels[shuffle]
+
+    digits2 = list(map(deskew, digits))
+    samples = preprocess_hog(digits2)
+
+    train_n = int(0.9*len(samples))
+    cv.imshow('test set', mosaic(25, digits[train_n:]))
+    digits_train, digits_test = np.split(digits2, [train_n])
+    samples_train, samples_test = np.split(samples, [train_n])
+    labels_train, labels_test = np.split(labels, [train_n])
+
+
+    print('training KNearest...')
+    model = KNearest(k=4)
+    model.train(samples_train, labels_train)
+    vis = evaluate_model(model, digits_test, samples_test, labels_test)
+    cv.imshow('KNearest test', vis)
+
+    print('training SVM...')
+    model = SVM(C=2.67, gamma=5.383)
+    model.train(samples_train, labels_train)
+    vis = evaluate_model(model, digits_test, samples_test, labels_test)
+    cv.imshow('SVM test', vis)
+    print('saving SVM as "digits_svm.dat"...')
+    model.save('digits_svm.dat')
+
+    cv.waitKey(0)
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/digits_adjust.py b/C++/opencv-4.7.0/samples/python/digits_adjust.py
new file mode 100644
index 00000000..1c041c1d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/digits_adjust.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+
+'''
+Digit recognition adjustment.
+Grid search is used to find the best parameters for SVM and KNearest classifiers.
+SVM adjustment follows the guidelines given in
+http://www.csie.ntu.edu.tw/~cjlin/papers/guide/guide.pdf
+
+Usage:
+  digits_adjust.py [--model {svm|knearest}]
+
+  --model {svm|knearest}   - select the classifier (SVM is the default)
+
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+
+from multiprocessing.pool import ThreadPool
+
+from digits import *
+
+def cross_validate(model_class, params, samples, labels, kfold = 3, pool = None):
+    n = len(samples)
+    folds = np.array_split(np.arange(n), kfold)
+    def f(i):
+        model = model_class(**params)
+        test_idx = folds[i]
+        train_idx = list(folds)
+        train_idx.pop(i)
+        train_idx = np.hstack(train_idx)
+        train_samples, train_labels = samples[train_idx], labels[train_idx]
+        test_samples, test_labels = samples[test_idx], labels[test_idx]
+        model.train(train_samples, train_labels)
+        resp = model.predict(test_samples)
+        score = (resp != test_labels).mean()
+        print(".", end='')
+        return score
+    if pool is None:
+        scores = list(map(f, xrange(kfold)))
+    else:
+        scores = pool.map(f, xrange(kfold))
+    return np.mean(scores)
+
+
+class App(object):
+    def __init__(self):
+        self._samples, self._labels = self.preprocess()
+
+    def preprocess(self):
+        digits, labels = load_digits(DIGITS_FN)
+        shuffle = np.random.permutation(len(digits))
+        digits, labels = digits[shuffle], labels[shuffle]
+        digits2 = list(map(deskew, digits))
+        samples = preprocess_hog(digits2)
+        return samples, labels
+
+    def get_dataset(self):
+        return self._samples, self._labels
+
+    def run_jobs(self, f, jobs):
+        pool = ThreadPool(processes=cv.getNumberOfCPUs())
+        ires = pool.imap_unordered(f, jobs)
+        return ires
+
+    def adjust_SVM(self):
+        Cs = np.logspace(0, 10, 15, base=2)
+        gammas = np.logspace(-7, 4, 15, base=2)
+        scores = np.zeros((len(Cs), len(gammas)))
+        scores[:] = np.nan
+
+        print('adjusting SVM (may take a long time) ...')
+        def f(job):
+            i, j = job
+            samples, labels = self.get_dataset()
+            params = dict(C = Cs[i], gamma=gammas[j])
+            score = cross_validate(SVM, params, samples, labels)
+            return i, j, score
+
+        ires = self.run_jobs(f, np.ndindex(*scores.shape))
+        for count, (i, j, score) in enumerate(ires):
+            scores[i, j] = score
+            print('%d / %d (best error: %.2f %%, last: %.2f %%)' %
+                  (count+1, scores.size, np.nanmin(scores)*100, score*100))
+        print(scores)
+
+        print('writing score table to "svm_scores.npz"')
+        np.savez('svm_scores.npz', scores=scores, Cs=Cs, gammas=gammas)
+
+        i, j = np.unravel_index(scores.argmin(), scores.shape)
+        best_params = dict(C = Cs[i], gamma=gammas[j])
+        print('best params:', best_params)
+        print('best error: %.2f %%' % (scores.min()*100))
+        return best_params
+
+    def adjust_KNearest(self):
+        print('adjusting KNearest ...')
+        def f(k):
+            samples, labels = self.get_dataset()
+            err = cross_validate(KNearest, dict(k=k), samples, labels)
+            return k, err
+        best_err, best_k = np.inf, -1
+        for k, err in self.run_jobs(f, xrange(1, 9)):
+            if err < best_err:
+                best_err, best_k = err, k
+            print('k = %d, error: %.2f %%' % (k, err*100))
+        best_params = dict(k=best_k)
+        print('best params:', best_params, 'err: %.2f' % (best_err*100))
+        return best_params
+
+
+if __name__ == '__main__':
+    import getopt
+    import sys
+
+    print(__doc__)
+
+    args, _ = getopt.getopt(sys.argv[1:], '', ['model='])
+    args = dict(args)
+    args.setdefault('--model', 'svm')
+    args.setdefault('--env', '')
+    if args['--model'] not in ['svm', 'knearest']:
+        print('unknown model "%s"' % args['--model'])
+        sys.exit(1)
+
+    t = clock()
+    app = App()
+    if args['--model'] == 'knearest':
+        app.adjust_KNearest()
+    else:
+        app.adjust_SVM()
+    print('work time: %f s' % (clock() - t))
diff --git a/C++/opencv-4.7.0/samples/python/digits_video.py b/C++/opencv-4.7.0/samples/python/digits_video.py
new file mode 100644
index 00000000..17f44c33
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/digits_video.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+'''
+Digit recognition from video.
+
+Run digits.py before, to train and save the SVM.
+
+Usage:
+  digits_video.py [{camera_id|video_file}]
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+# built-in modules
+import os
+import sys
+
+# local modules
+import video
+from common import mosaic
+
+from digits import *
+
+def main():
+    try:
+        src = sys.argv[1]
+    except:
+        src = 0
+    cap = video.create_capture(src, fallback='synth:bg={}:noise=0.05'.format(cv.samples.findFile('sudoku.png')))
+
+    classifier_fn = 'digits_svm.dat'
+    if not os.path.exists(classifier_fn):
+        print('"%s" not found, run digits.py first' % classifier_fn)
+        return
+
+    model = cv.ml.SVM_load(classifier_fn)
+
+    while True:
+        _ret, frame = cap.read()
+        gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+
+
+        bin = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY_INV, 31, 10)
+        bin = cv.medianBlur(bin, 3)
+        contours, heirs = cv.findContours( bin.copy(), cv.RETR_CCOMP, cv.CHAIN_APPROX_SIMPLE)
+        try:
+            heirs = heirs[0]
+        except:
+            heirs = []
+
+        for cnt, heir in zip(contours, heirs):
+            _, _, _, outer_i = heir
+            if outer_i >= 0:
+                continue
+            x, y, w, h = cv.boundingRect(cnt)
+            if not (16 <= h <= 64  and w <= 1.2*h):
+                continue
+            pad = max(h-w, 0)
+            x, w = x - (pad // 2), w + pad
+            cv.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0))
+
+            bin_roi = bin[y:,x:][:h,:w]
+
+            m = bin_roi != 0
+            if not 0.1 < m.mean() < 0.4:
+                continue
+            '''
+            gray_roi = gray[y:,x:][:h,:w]
+            v_in, v_out = gray_roi[m], gray_roi[~m]
+            if v_out.std() > 10.0:
+                continue
+            s = "%f, %f" % (abs(v_in.mean() - v_out.mean()), v_out.std())
+            cv.putText(frame, s, (x, y), cv.FONT_HERSHEY_PLAIN, 1.0, (200, 0, 0), thickness = 1)
+            '''
+
+            s = 1.5*float(h)/SZ
+            m = cv.moments(bin_roi)
+            c1 = np.float32([m['m10'], m['m01']]) / m['m00']
+            c0 = np.float32([SZ/2, SZ/2])
+            t = c1 - s*c0
+            A = np.zeros((2, 3), np.float32)
+            A[:,:2] = np.eye(2)*s
+            A[:,2] = t
+            bin_norm = cv.warpAffine(bin_roi, A, (SZ, SZ), flags=cv.WARP_INVERSE_MAP | cv.INTER_LINEAR)
+            bin_norm = deskew(bin_norm)
+            if x+w+SZ < frame.shape[1] and y+SZ < frame.shape[0]:
+                frame[y:,x+w:][:SZ, :SZ] = bin_norm[...,np.newaxis]
+
+            sample = preprocess_hog([bin_norm])
+            digit = model.predict(sample)[1].ravel()
+            cv.putText(frame, '%d'%digit, (x, y), cv.FONT_HERSHEY_PLAIN, 1.0, (200, 0, 0), thickness = 1)
+
+
+        cv.imshow('frame', frame)
+        cv.imshow('bin', bin)
+        ch = cv.waitKey(1)
+        if ch == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/dis_opt_flow.py b/C++/opencv-4.7.0/samples/python/dis_opt_flow.py
new file mode 100644
index 00000000..14127aef
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/dis_opt_flow.py
@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+
+'''
+example to show optical flow estimation using DISOpticalFlow
+
+USAGE: dis_opt_flow.py [<video_source>]
+
+Keys:
+ 1  - toggle HSV flow visualization
+ 2  - toggle glitch
+ 3  - toggle spatial propagation of flow vectors
+ 4  - toggle temporal propagation of flow vectors
+ESC - exit
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import video
+
+
+def draw_flow(img, flow, step=16):
+    h, w = img.shape[:2]
+    y, x = np.mgrid[step/2:h:step, step/2:w:step].reshape(2,-1).astype(int)
+    fx, fy = flow[y,x].T
+    lines = np.vstack([x, y, x+fx, y+fy]).T.reshape(-1, 2, 2)
+    lines = np.int32(lines + 0.5)
+    vis = cv.cvtColor(img, cv.COLOR_GRAY2BGR)
+    cv.polylines(vis, lines, 0, (0, 255, 0))
+    for (x1, y1), (_x2, _y2) in lines:
+        cv.circle(vis, (x1, y1), 1, (0, 255, 0), -1)
+    return vis
+
+
+def draw_hsv(flow):
+    h, w = flow.shape[:2]
+    fx, fy = flow[:,:,0], flow[:,:,1]
+    ang = np.arctan2(fy, fx) + np.pi
+    v = np.sqrt(fx*fx+fy*fy)
+    hsv = np.zeros((h, w, 3), np.uint8)
+    hsv[...,0] = ang*(180/np.pi/2)
+    hsv[...,1] = 255
+    hsv[...,2] = np.minimum(v*4, 255)
+    bgr = cv.cvtColor(hsv, cv.COLOR_HSV2BGR)
+    return bgr
+
+
+def warp_flow(img, flow):
+    h, w = flow.shape[:2]
+    flow = -flow
+    flow[:,:,0] += np.arange(w)
+    flow[:,:,1] += np.arange(h)[:,np.newaxis]
+    res = cv.remap(img, flow, None, cv.INTER_LINEAR)
+    return res
+
+
+def main():
+    import sys
+    print(__doc__)
+    try:
+        fn = sys.argv[1]
+    except IndexError:
+        fn = 0
+
+    cam = video.create_capture(fn)
+    _ret, prev = cam.read()
+    prevgray = cv.cvtColor(prev, cv.COLOR_BGR2GRAY)
+    show_hsv = False
+    show_glitch = False
+    use_spatial_propagation = False
+    use_temporal_propagation = True
+    cur_glitch = prev.copy()
+    inst = cv.DISOpticalFlow.create(cv.DISOPTICAL_FLOW_PRESET_MEDIUM)
+    inst.setUseSpatialPropagation(use_spatial_propagation)
+
+    flow = None
+    while True:
+        _ret, img = cam.read()
+        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+        if flow is not None and use_temporal_propagation:
+            #warp previous flow to get an initial approximation for the current flow:
+            flow = inst.calc(prevgray, gray, warp_flow(flow,flow))
+        else:
+            flow = inst.calc(prevgray, gray, None)
+        prevgray = gray
+
+        cv.imshow('flow', draw_flow(gray, flow))
+        if show_hsv:
+            cv.imshow('flow HSV', draw_hsv(flow))
+        if show_glitch:
+            cur_glitch = warp_flow(cur_glitch, flow)
+            cv.imshow('glitch', cur_glitch)
+
+        ch = 0xFF & cv.waitKey(5)
+        if ch == 27:
+            break
+        if ch == ord('1'):
+            show_hsv = not show_hsv
+            print('HSV flow visualization is', ['off', 'on'][show_hsv])
+        if ch == ord('2'):
+            show_glitch = not show_glitch
+            if show_glitch:
+                cur_glitch = img.copy()
+            print('glitch is', ['off', 'on'][show_glitch])
+        if ch == ord('3'):
+            use_spatial_propagation = not use_spatial_propagation
+            inst.setUseSpatialPropagation(use_spatial_propagation)
+            print('spatial propagation is', ['off', 'on'][use_spatial_propagation])
+        if ch == ord('4'):
+            use_temporal_propagation = not use_temporal_propagation
+            print('temporal propagation is', ['off', 'on'][use_temporal_propagation])
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/distrans.py b/C++/opencv-4.7.0/samples/python/distrans.py
new file mode 100644
index 00000000..aa423a7a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/distrans.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+
+'''
+Distance transform sample.
+
+Usage:
+  distrans.py [<image>]
+
+Keys:
+  ESC   - exit
+  v     - toggle voronoi mode
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+from common import make_cmap
+
+def main():
+    import sys
+    try:
+        fn = sys.argv[1]
+    except:
+        fn = 'fruits.jpg'
+
+    fn = cv.samples.findFile(fn)
+    img = cv.imread(fn, cv.IMREAD_GRAYSCALE)
+    if img is None:
+        print('Failed to load fn:', fn)
+        sys.exit(1)
+
+    cm = make_cmap('jet')
+    need_update = True
+    voronoi = False
+
+    def update(dummy=None):
+        global need_update
+        need_update = False
+        thrs = cv.getTrackbarPos('threshold', 'distrans')
+        mark = cv.Canny(img, thrs, 3*thrs)
+        dist, labels = cv.distanceTransformWithLabels(~mark, cv.DIST_L2, 5)
+        if voronoi:
+            vis = cm[np.uint8(labels)]
+        else:
+            vis = cm[np.uint8(dist*2)]
+        vis[mark != 0] = 255
+        cv.imshow('distrans', vis)
+
+    def invalidate(dummy=None):
+        global need_update
+        need_update = True
+
+    cv.namedWindow('distrans')
+    cv.createTrackbar('threshold', 'distrans', 60, 255, invalidate)
+    update()
+
+
+    while True:
+        ch = cv.waitKey(50)
+        if ch == 27:
+            break
+        if ch == ord('v'):
+            voronoi = not voronoi
+            print('showing', ['distance', 'voronoi'][voronoi])
+            update()
+        if need_update:
+            update()
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/drawing.py b/C++/opencv-4.7.0/samples/python/drawing.py
new file mode 100644
index 00000000..e5db400d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/drawing.py
@@ -0,0 +1,191 @@
+#!/usr/bin/env python
+'''
+    This program demonstrates OpenCV drawing and text output functions by drawing different shapes and text strings
+    Usage :
+        python3 drawing.py
+    Press any button to exit
+    '''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+# Drawing Lines
+def lines():
+    for i in range(NUMBER*2):
+        pt1, pt2 = [], []
+        pt1.append(np.random.randint(x1, x2))
+        pt1.append(np.random.randint(y1, y2))
+        pt2.append(np.random.randint(x1, x2))
+        pt2.append(np.random.randint(y1, y2))
+        color = "%06x" % np.random.randint(0, 0xFFFFFF)
+        color = tuple(int(color[i:i+2], 16) for i in (0, 2 ,4))
+        arrowed =  np.random.randint(0, 6)
+        if (arrowed<3):
+            cv.line(image, tuple(pt1), tuple(pt2), color, np.random.randint(1, 10), lineType)
+        else:
+            cv.arrowedLine(image, tuple(pt1), tuple(pt2), color, np.random.randint(1, 10), lineType)
+        cv.imshow(wndname, image)
+        if cv.waitKey(DELAY)>=0:
+            return
+
+# Drawing Rectangle
+def rectangle():
+    for i in range(NUMBER*2):
+        pt1, pt2 = [], []
+        pt1.append(np.random.randint(x1, x2))
+        pt1.append(np.random.randint(y1, y2))
+        pt2.append(np.random.randint(x1, x2))
+        pt2.append(np.random.randint(y1, y2))
+        color = "%06x" % np.random.randint(0, 0xFFFFFF)
+        color = tuple(int(color[i:i+2], 16) for i in (0, 2 ,4))
+        thickness = np.random.randint(-3, 10)
+        marker = np.random.randint(0, 10)
+        marker_size = np.random.randint(30, 80)
+
+        if (marker > 5):
+            cv.rectangle(image, tuple(pt1), tuple(pt2), color, max(thickness, -1), lineType)
+        else:
+            cv.drawMarker(image, tuple(pt1), color, marker, marker_size)
+        cv.imshow(wndname, image)
+        if cv.waitKey(DELAY)>=0:
+            return
+
+# Drawing ellipse
+def ellipse():
+    for i in range(NUMBER*2):
+        center = []
+        center.append(np.random.randint(x1, x2))
+        center.append(np.random.randint(x1, x2))
+        axes = []
+        axes.append(np.random.randint(0, 200))
+        axes.append(np.random.randint(0, 200))
+        angle = np.random.randint(0, 180)
+        color = "%06x" % np.random.randint(0, 0xFFFFFF)
+        color = tuple(int(color[i:i+2], 16) for i in (0, 2 ,4))
+        thickness = np.random.randint(-1, 9)
+        cv.ellipse(image, tuple(center), tuple(axes), angle, angle-100, angle + 200, color, thickness, lineType)
+        cv.imshow(wndname, image)
+        if cv.waitKey(DELAY)>=0:
+            return
+
+# Drawing Polygonal Curves
+def polygonal():
+    for i in range(NUMBER):
+        pt = [(0, 0)]*6
+        pt = np.resize(pt, (2, 3, 2))
+        pt[0][0][0] = np.random.randint(x1, x2)
+        pt[0][0][1] = np.random.randint(y1, y2)
+        pt[0][1][0] = np.random.randint(x1, x2)
+        pt[0][1][1] = np.random.randint(y1, y2)
+        pt[0][2][0] = np.random.randint(x1, x2)
+        pt[0][2][1] = np.random.randint(y1, y2)
+        pt[1][0][0] = np.random.randint(x1, x2)
+        pt[1][0][1] = np.random.randint(y1, y2)
+        pt[1][1][0] = np.random.randint(x1, x2)
+        pt[1][1][1] = np.random.randint(y1, y2)
+        pt[1][2][0] = np.random.randint(x1, x2)
+        pt[1][2][1] = np.random.randint(y1, y2)
+        color = "%06x" % np.random.randint(0, 0xFFFFFF)
+        color = tuple(int(color[i:i+2], 16) for i in (0, 2 ,4))
+        alist = []
+        for k in pt[0]:
+            alist.append(k)
+        for k in pt[1]:
+            alist.append(k)
+        ppt = np.array(alist)
+        cv.polylines(image, [ppt], True, color, thickness = np.random.randint(1, 10), lineType = lineType)
+        cv.imshow(wndname, image)
+        if cv.waitKey(DELAY) >= 0:
+            return
+
+# fills an area bounded by several polygonal contours
+def fill():
+    for i in range(NUMBER):
+        pt = [(0, 0)]*6
+        pt = np.resize(pt, (2, 3, 2))
+        pt[0][0][0] = np.random.randint(x1, x2)
+        pt[0][0][1] = np.random.randint(y1, y2)
+        pt[0][1][0] = np.random.randint(x1, x2)
+        pt[0][1][1] = np.random.randint(y1, y2)
+        pt[0][2][0] = np.random.randint(x1, x2)
+        pt[0][2][1] = np.random.randint(y1, y2)
+        pt[1][0][0] = np.random.randint(x1, x2)
+        pt[1][0][1] = np.random.randint(y1, y2)
+        pt[1][1][0] = np.random.randint(x1, x2)
+        pt[1][1][1] = np.random.randint(y1, y2)
+        pt[1][2][0] = np.random.randint(x1, x2)
+        pt[1][2][1] = np.random.randint(y1, y2)
+        color = "%06x" % np.random.randint(0, 0xFFFFFF)
+        color = tuple(int(color[i:i+2], 16) for i in (0, 2 ,4))
+        alist = []
+        for k in pt[0]:
+            alist.append(k)
+        for k in pt[1]:
+            alist.append(k)
+        ppt = np.array(alist)
+        cv.fillPoly(image, [ppt], color, lineType)
+        cv.imshow(wndname, image)
+        if cv.waitKey(DELAY) >= 0:
+            return
+
+# Drawing Circles
+def circles():
+    for i in range(NUMBER):
+        center = []
+        center.append(np.random.randint(x1, x2))
+        center.append(np.random.randint(x1, x2))
+        color = "%06x" % np.random.randint(0, 0xFFFFFF)
+        color = tuple(int(color[i:i+2], 16) for i in (0, 2 ,4))
+        cv.circle(image, tuple(center), np.random.randint(0, 300), color, np.random.randint(-1, 9), lineType)
+        cv.imshow(wndname, image)
+        if cv.waitKey(DELAY) >= 0:
+            return
+
+# Draws a text string
+def string():
+    for i in range(NUMBER):
+        org = []
+        org.append(np.random.randint(x1, x2))
+        org.append(np.random.randint(x1, x2))
+        color = "%06x" % np.random.randint(0, 0xFFFFFF)
+        color = tuple(int(color[i:i+2], 16) for i in (0, 2 ,4))
+        cv.putText(image, "Testing text rendering", tuple(org), np.random.randint(0, 8), np.random.randint(0, 100)*0.05+0.1, color, np.random.randint(1, 10), lineType)
+        cv.imshow(wndname, image)
+        if cv.waitKey(DELAY) >= 0:
+            return
+
+
+def string1():
+    textsize = cv.getTextSize("OpenCV forever!", cv.FONT_HERSHEY_COMPLEX, 3, 5)
+    org = (int((width - textsize[0][0])/2), int((height - textsize[0][1])/2))
+    for i in range(0, 255, 2):
+        image2 = np.array(image) - i
+        cv.putText(image2, "OpenCV forever!", org, cv.FONT_HERSHEY_COMPLEX, 3, (i, i, 255), 5, lineType)
+        cv.imshow(wndname, image2)
+        if cv.waitKey(DELAY) >= 0:
+            return
+
+if __name__ == '__main__':
+    print(__doc__)
+    wndname = "Drawing Demo"
+    NUMBER = 100
+    DELAY = 5
+    width, height = 1000, 700
+    lineType = cv.LINE_AA  # change it to LINE_8 to see non-antialiased graphics
+    x1, x2, y1, y2 = -width/2, width*3/2, -height/2, height*3/2
+    image = np.zeros((height, width, 3), dtype = np.uint8)
+    cv.imshow(wndname, image)
+    cv.waitKey(DELAY)
+    lines()
+    rectangle()
+    ellipse()
+    polygonal()
+    fill()
+    circles()
+    string()
+    string1()
+    cv.waitKey(0)
+    cv.destroyAllWindows()
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/python/edge.py b/C++/opencv-4.7.0/samples/python/edge.py
new file mode 100644
index 00000000..e85c2f62
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/edge.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+'''
+This sample demonstrates Canny edge detection.
+
+Usage:
+  edge.py [<video source>]
+
+  Trackbars control edge thresholds.
+
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import cv2 as cv
+import numpy as np
+
+# relative module
+import video
+
+# built-in module
+import sys
+
+
+def main():
+    try:
+        fn = sys.argv[1]
+    except:
+        fn = 0
+
+    def nothing(*arg):
+        pass
+
+    cv.namedWindow('edge')
+    cv.createTrackbar('thrs1', 'edge', 2000, 5000, nothing)
+    cv.createTrackbar('thrs2', 'edge', 4000, 5000, nothing)
+
+    cap = video.create_capture(fn)
+    while True:
+        _flag, img = cap.read()
+        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+        thrs1 = cv.getTrackbarPos('thrs1', 'edge')
+        thrs2 = cv.getTrackbarPos('thrs2', 'edge')
+        edge = cv.Canny(gray, thrs1, thrs2, apertureSize=5)
+        vis = img.copy()
+        vis = np.uint8(vis/2.)
+        vis[edge != 0] = (0, 255, 0)
+        cv.imshow('edge', vis)
+        ch = cv.waitKey(5)
+        if ch == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/essential_mat_reconstr.py b/C++/opencv-4.7.0/samples/python/essential_mat_reconstr.py
new file mode 100644
index 00000000..cfb4fb1d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/essential_mat_reconstr.py
@@ -0,0 +1,137 @@
+import numpy as np, cv2 as cv, matplotlib.pyplot as plt, time, sys, os
+from mpl_toolkits.mplot3d import axes3d, Axes3D
+
+def getEpipolarError(F, pts1_, pts2_, inliers):
+    pts1 = np.concatenate((pts1_.T, np.ones((1, pts1_.shape[0]))))[:,inliers]
+    pts2 = np.concatenate((pts2_.T, np.ones((1, pts2_.shape[0]))))[:,inliers]
+    lines2 = np.dot(F  , pts1)
+    lines1 = np.dot(F.T, pts2)
+
+    return np.median((np.abs(np.sum(pts1 * lines1, axis=0)) / np.sqrt(lines1[0,:]**2 + lines1[1,:]**2) +
+                      np.abs(np.sum(pts2 * lines2, axis=0)) / np.sqrt(lines2[0,:]**2 + lines2[1,:]**2))/2)
+
+if __name__ == '__main__':
+    if len(sys.argv) < 3:
+        print("Path to data file and directory to image files are missing!\nData file must have"
+              " format:\n--------------\n image_name_1\nimage_name_2\nk11 k12 k13\n0   k22 k23\n"
+              "0   0   1\n--------------\nIf image_name_{1,2} are not in the same directory as "
+              "the data file then add argument with directory to image files.\nFor example: "
+              "python essential_mat_reconstr.py essential_mat_data.txt ./")
+        exit(1)
+    else:
+        data_file = sys.argv[1]
+        image_dir = sys.argv[2]
+
+    if not os.path.isfile(data_file):
+        print('Incorrect path to data file!')
+        exit(1)
+
+    with open(data_file, 'r') as f:
+        image1 = cv.imread(image_dir+f.readline()[:-1]) # remove '\n'
+        image2 = cv.imread(image_dir+f.readline()[:-1])
+        K = np.array([[float(x) for x in f.readline().split(' ')],
+                      [float(x) for x in f.readline().split(' ')],
+                      [float(x) for x in f.readline().split(' ')]])
+
+    if image1 is None or image2 is None:
+        print('Incorrect directory to images!')
+        exit(1)
+    if K.shape != (3,3):
+        print('Intrinsic matrix has incorrect format!')
+        exit(1)
+
+    print('find keypoints and compute descriptors')
+    detector = cv.SIFT_create(nfeatures=20000)
+    keypoints1, descriptors1 = detector.detectAndCompute(cv.cvtColor(image1, cv.COLOR_BGR2GRAY), None)
+    keypoints2, descriptors2 = detector.detectAndCompute(cv.cvtColor(image2, cv.COLOR_BGR2GRAY), None)
+
+    matcher = cv.FlannBasedMatcher(dict(algorithm=0, trees=5), dict(checks=32))
+    print('match with FLANN, size of descriptors', descriptors1.shape, descriptors2.shape)
+    matches_vector = matcher.knnMatch(descriptors1, descriptors2, k=2)
+
+    print('find good keypoints')
+    pts1 = []; pts2 = []
+    for m in matches_vector:
+        # compare best and second match using Lowe ratio test
+        if  m[0].distance / m[1].distance < 0.75:
+            pts1.append(keypoints1[m[0].queryIdx].pt)
+            pts2.append(keypoints2[m[0].trainIdx].pt)
+    pts1 = np.array(pts1); pts2 = np.array(pts2)
+    print('points size', pts1.shape[0])
+
+    print('Essential matrix RANSAC')
+    start = time.time()
+    E, inliers = cv.findEssentialMat(pts1, pts2, K, cv.RANSAC, 0.999, 1.0)
+    print('RANSAC time', time.time() - start, 'seconds')
+    print('Median error to epipolar lines', getEpipolarError
+          (np.dot(np.linalg.inv(K).T, np.dot(E, np.linalg.inv(K))), pts1, pts2, inliers.squeeze()),
+           'number of inliers', inliers.sum())
+
+    print('Decompose essential matrix')
+    R1, R2, t = cv.decomposeEssentialMat(E)
+
+    # Assume relative pose. Fix the first camera
+    P1 = np.concatenate((K, np.zeros((3,1))), axis=1) #   K [I | 0]
+    P2s = [np.dot(K, np.concatenate((R1,  t), axis=1)), # K[R1 |  t]
+           np.dot(K, np.concatenate((R1, -t), axis=1)), # K[R1 | -t]
+           np.dot(K, np.concatenate((R2,  t), axis=1)), # K[R2 |  t]
+           np.dot(K, np.concatenate((R2, -t), axis=1))] # K[R2 | -t]
+
+    obj_pts_per_cam = []
+    # enumerate over all P2 projection matrices
+    for cam_idx, P2 in enumerate(P2s):
+        obj_pts = []
+        for i, (pt1, pt2) in enumerate(zip(pts1, pts2)):
+            if not inliers[i]:
+                continue
+            # find object point by triangulation of image points by projection matrices
+            obj_pt = cv.triangulatePoints(P1, P2, pt1, pt2)
+            obj_pt /= obj_pt[3]
+            # check if reprojected point has positive depth
+            if obj_pt[2] > 0:
+                obj_pts.append([obj_pt[0], obj_pt[1], obj_pt[2]])
+        obj_pts_per_cam.append(obj_pts)
+
+    best_cam_idx = np.array([len(obj_pts_per_cam[0]),len(obj_pts_per_cam[1]),
+                             len(obj_pts_per_cam[2]),len(obj_pts_per_cam[3])]).argmax()
+    max_pts = len(obj_pts_per_cam[best_cam_idx])
+    print('Number of object points', max_pts)
+
+    # filter object points to have reasonable depth
+    MAX_DEPTH = 6.
+    obj_pts = []
+    for pt in obj_pts_per_cam[best_cam_idx]:
+        if pt[2] < MAX_DEPTH:
+            obj_pts.append(pt)
+    obj_pts = np.array(obj_pts).reshape(len(obj_pts), 3)
+
+    # visualize image points
+    for i, (pt1, pt2) in enumerate(zip(pts1, pts2)):
+        if inliers[i]:
+            cv.circle(image1, (int(pt1[0]), int(pt1[1])), 7, (255,0,0), -1)
+            cv.circle(image2, (int(pt2[0]), int(pt2[1])), 7, (255,0,0), -1)
+
+    # concatenate two images
+    image1 = np.concatenate((image1, image2), axis=1)
+    # resize concatenated image
+    new_img_size = 1200. * 800.
+    image1 = cv.resize(image1, (int(np.sqrt(image1.shape[1] * new_img_size / image1.shape[0])),
+                                 int(np.sqrt (image1.shape[0] * new_img_size / image1.shape[1]))))
+
+    # plot object points
+    fig = plt.figure(figsize=(13.0, 11.0))
+    ax = fig.add_subplot(111, projection='3d')
+    ax.set_aspect('equal')
+    ax.scatter(obj_pts[:,0], obj_pts[:,1], obj_pts[:,2], c='r', marker='o', s=3)
+    ax.set_xlabel('x')
+    ax.set_ylabel('y')
+    ax.set_zlabel('depth')
+    ax.view_init(azim=-80, elev=110)
+
+    # save figures
+    cv.imshow("matches", image1)
+    cv.imwrite('matches_E.png', image1)
+    plt.savefig('reconstruction_3D.png')
+
+    cv.waitKey(0)
+    plt.show()
diff --git a/C++/opencv-4.7.0/samples/python/facedetect.py b/C++/opencv-4.7.0/samples/python/facedetect.py
new file mode 100644
index 00000000..248206a7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/facedetect.py
@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+
+'''
+face detection using haar cascades
+
+USAGE:
+    facedetect.py [--cascade <cascade_fn>] [--nested-cascade <cascade_fn>] [<video_source>]
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+# local modules
+from video import create_capture
+from common import clock, draw_str
+
+
+def detect(img, cascade):
+    rects = cascade.detectMultiScale(img, scaleFactor=1.3, minNeighbors=4, minSize=(30, 30),
+                                     flags=cv.CASCADE_SCALE_IMAGE)
+    if len(rects) == 0:
+        return []
+    rects[:,2:] += rects[:,:2]
+    return rects
+
+def draw_rects(img, rects, color):
+    for x1, y1, x2, y2 in rects:
+        cv.rectangle(img, (x1, y1), (x2, y2), color, 2)
+
+def main():
+    import sys, getopt
+
+    args, video_src = getopt.getopt(sys.argv[1:], '', ['cascade=', 'nested-cascade='])
+    try:
+        video_src = video_src[0]
+    except:
+        video_src = 0
+    args = dict(args)
+    cascade_fn = args.get('--cascade', "haarcascades/haarcascade_frontalface_alt.xml")
+    nested_fn  = args.get('--nested-cascade', "haarcascades/haarcascade_eye.xml")
+
+    cascade = cv.CascadeClassifier(cv.samples.findFile(cascade_fn))
+    nested = cv.CascadeClassifier(cv.samples.findFile(nested_fn))
+
+    cam = create_capture(video_src, fallback='synth:bg={}:noise=0.05'.format(cv.samples.findFile('lena.jpg')))
+
+    while True:
+        _ret, img = cam.read()
+        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+        gray = cv.equalizeHist(gray)
+
+        t = clock()
+        rects = detect(gray, cascade)
+        vis = img.copy()
+        draw_rects(vis, rects, (0, 255, 0))
+        if not nested.empty():
+            for x1, y1, x2, y2 in rects:
+                roi = gray[y1:y2, x1:x2]
+                vis_roi = vis[y1:y2, x1:x2]
+                subrects = detect(roi.copy(), nested)
+                draw_rects(vis_roi, subrects, (255, 0, 0))
+        dt = clock() - t
+
+        draw_str(vis, (20, 20), 'time: %.1f ms' % (dt*1000))
+        cv.imshow('facedetect', vis)
+
+        if cv.waitKey(5) == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/feature_homography.py b/C++/opencv-4.7.0/samples/python/feature_homography.py
new file mode 100644
index 00000000..80537e03
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/feature_homography.py
@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+
+'''
+Feature homography
+==================
+
+Example of using features2d framework for interactive video homography matching.
+ORB features and FLANN matcher are used. The actual tracking is implemented by
+PlaneTracker class in plane_tracker.py
+
+Inspired by http://www.youtube.com/watch?v=-ZNYoL8rzPY
+
+video: http://www.youtube.com/watch?v=FirtmYcC0Vc
+
+Usage
+-----
+feature_homography.py [<video source>]
+
+Keys:
+   SPACE  -  pause video
+
+Select a textured planar object to track by drawing a box with a mouse.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+# local modules
+import video
+from video import presets
+import common
+from common import getsize, draw_keypoints
+from plane_tracker import PlaneTracker
+
+
+class App:
+    def __init__(self, src):
+        self.cap = video.create_capture(src, presets['book'])
+        self.frame = None
+        self.paused = False
+        self.tracker = PlaneTracker()
+
+        cv.namedWindow('plane')
+        self.rect_sel = common.RectSelector('plane', self.on_rect)
+
+    def on_rect(self, rect):
+        self.tracker.clear()
+        self.tracker.add_target(self.frame, rect)
+
+    def run(self):
+        while True:
+            playing = not self.paused and not self.rect_sel.dragging
+            if playing or self.frame is None:
+                ret, frame = self.cap.read()
+                if not ret:
+                    break
+                self.frame = frame.copy()
+
+            w, h = getsize(self.frame)
+            vis = np.zeros((h, w*2, 3), np.uint8)
+            vis[:h,:w] = self.frame
+            if len(self.tracker.targets) > 0:
+                target = self.tracker.targets[0]
+                vis[:,w:] = target.image
+                draw_keypoints(vis[:,w:], target.keypoints)
+                x0, y0, x1, y1 = target.rect
+                cv.rectangle(vis, (x0+w, y0), (x1+w, y1), (0, 255, 0), 2)
+
+            if playing:
+                tracked = self.tracker.track(self.frame)
+                if len(tracked) > 0:
+                    tracked = tracked[0]
+                    cv.polylines(vis, [np.int32(tracked.quad)], True, (255, 255, 255), 2)
+                    for (x0, y0), (x1, y1) in zip(np.int32(tracked.p0), np.int32(tracked.p1)):
+                        cv.line(vis, (x0+w, y0), (x1, y1), (0, 255, 0))
+            draw_keypoints(vis, self.tracker.frame_points)
+
+            self.rect_sel.draw(vis)
+            cv.imshow('plane', vis)
+            ch = cv.waitKey(1)
+            if ch == ord(' '):
+                self.paused = not self.paused
+            if ch == 27:
+                break
+
+
+if __name__ == '__main__':
+    print(__doc__)
+
+    import sys
+    try:
+        video_src = sys.argv[1]
+    except:
+        video_src = 0
+    App(video_src).run()
diff --git a/C++/opencv-4.7.0/samples/python/find_obj.py b/C++/opencv-4.7.0/samples/python/find_obj.py
new file mode 100644
index 00000000..c5783bf4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/find_obj.py
@@ -0,0 +1,197 @@
+#!/usr/bin/env python
+
+'''
+Feature-based image matching sample.
+
+Note, that you will need the https://github.com/opencv/opencv_contrib repo for SIFT and SURF
+
+USAGE
+  find_obj.py [--feature=<sift|surf|orb|akaze|brisk>[-flann]] [ <image1> <image2> ]
+
+  --feature  - Feature to use. Can be sift, surf, orb or brisk. Append '-flann'
+               to feature name to use Flann-based matcher instead bruteforce.
+
+  Press left mouse button on a feature point to see its matching point.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+from common import anorm, getsize
+
+FLANN_INDEX_KDTREE = 1  # bug: flann enums are missing
+FLANN_INDEX_LSH    = 6
+
+
+def init_feature(name):
+    chunks = name.split('-')
+    if chunks[0] == 'sift':
+        detector = cv.SIFT_create()
+        norm = cv.NORM_L2
+    elif chunks[0] == 'surf':
+        detector = cv.xfeatures2d.SURF_create(800)
+        norm = cv.NORM_L2
+    elif chunks[0] == 'orb':
+        detector = cv.ORB_create(400)
+        norm = cv.NORM_HAMMING
+    elif chunks[0] == 'akaze':
+        detector = cv.AKAZE_create()
+        norm = cv.NORM_HAMMING
+    elif chunks[0] == 'brisk':
+        detector = cv.BRISK_create()
+        norm = cv.NORM_HAMMING
+    else:
+        return None, None
+    if 'flann' in chunks:
+        if norm == cv.NORM_L2:
+            flann_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
+        else:
+            flann_params= dict(algorithm = FLANN_INDEX_LSH,
+                               table_number = 6, # 12
+                               key_size = 12,     # 20
+                               multi_probe_level = 1) #2
+        matcher = cv.FlannBasedMatcher(flann_params, {})  # bug : need to pass empty dict (#1329)
+    else:
+        matcher = cv.BFMatcher(norm)
+    return detector, matcher
+
+
+def filter_matches(kp1, kp2, matches, ratio = 0.75):
+    mkp1, mkp2 = [], []
+    for m in matches:
+        if len(m) == 2 and m[0].distance < m[1].distance * ratio:
+            m = m[0]
+            mkp1.append( kp1[m.queryIdx] )
+            mkp2.append( kp2[m.trainIdx] )
+    p1 = np.float32([kp.pt for kp in mkp1])
+    p2 = np.float32([kp.pt for kp in mkp2])
+    kp_pairs = zip(mkp1, mkp2)
+    return p1, p2, list(kp_pairs)
+
+def explore_match(win, img1, img2, kp_pairs, status = None, H = None):
+    h1, w1 = img1.shape[:2]
+    h2, w2 = img2.shape[:2]
+    vis = np.zeros((max(h1, h2), w1+w2), np.uint8)
+    vis[:h1, :w1] = img1
+    vis[:h2, w1:w1+w2] = img2
+    vis = cv.cvtColor(vis, cv.COLOR_GRAY2BGR)
+
+    if H is not None:
+        corners = np.float32([[0, 0], [w1, 0], [w1, h1], [0, h1]])
+        corners = np.int32( cv.perspectiveTransform(corners.reshape(1, -1, 2), H).reshape(-1, 2) + (w1, 0) )
+        cv.polylines(vis, [corners], True, (255, 255, 255))
+
+    if status is None:
+        status = np.ones(len(kp_pairs), np.bool_)
+        status = status.reshape((len(kp_pairs), 1))
+    p1, p2 = [], []  # python 2 / python 3 change of zip unpacking
+    for kpp in kp_pairs:
+        p1.append(np.int32(kpp[0].pt))
+        p2.append(np.int32(np.array(kpp[1].pt) + [w1, 0]))
+
+    green = (0, 255, 0)
+    red = (0, 0, 255)
+    kp_color = (51, 103, 236)
+    for (x1, y1), (x2, y2), inlier in zip(p1, p2, status):
+        if inlier:
+            col = green
+            cv.circle(vis, (x1, y1), 2, col, -1)
+            cv.circle(vis, (x2, y2), 2, col, -1)
+        else:
+            col = red
+            r = 2
+            thickness = 3
+            cv.line(vis, (x1-r, y1-r), (x1+r, y1+r), col, thickness)
+            cv.line(vis, (x1-r, y1+r), (x1+r, y1-r), col, thickness)
+            cv.line(vis, (x2-r, y2-r), (x2+r, y2+r), col, thickness)
+            cv.line(vis, (x2-r, y2+r), (x2+r, y2-r), col, thickness)
+    vis0 = vis.copy()
+    for (x1, y1), (x2, y2), inlier in zip(p1, p2, status):
+        if inlier:
+            cv.line(vis, (x1, y1), (x2, y2), green)
+
+    cv.imshow(win, vis)
+
+    def onmouse(event, x, y, flags, param):
+        cur_vis = vis
+        if flags & cv.EVENT_FLAG_LBUTTON:
+            cur_vis = vis0.copy()
+            r = 8
+            m = (anorm(np.array(p1) - (x, y)) < r) | (anorm(np.array(p2) - (x, y)) < r)
+            idxs = np.where(m)[0]
+
+            kp1s, kp2s = [], []
+            for i in idxs:
+                (x1, y1), (x2, y2) = p1[i], p2[i]
+                col = (red, green)[status[i][0]]
+                cv.line(cur_vis, (x1, y1), (x2, y2), col)
+                kp1, kp2 = kp_pairs[i]
+                kp1s.append(kp1)
+                kp2s.append(kp2)
+            cur_vis = cv.drawKeypoints(cur_vis, kp1s, None, flags=4, color=kp_color)
+            cur_vis[:,w1:] = cv.drawKeypoints(cur_vis[:,w1:], kp2s, None, flags=4, color=kp_color)
+
+        cv.imshow(win, cur_vis)
+    cv.setMouseCallback(win, onmouse)
+    return vis
+
+
+def main():
+    import sys, getopt
+    opts, args = getopt.getopt(sys.argv[1:], '', ['feature='])
+    opts = dict(opts)
+    feature_name = opts.get('--feature', 'brisk')
+    try:
+        fn1, fn2 = args
+    except:
+        fn1 = 'box.png'
+        fn2 = 'box_in_scene.png'
+
+    img1 = cv.imread(cv.samples.findFile(fn1), cv.IMREAD_GRAYSCALE)
+    img2 = cv.imread(cv.samples.findFile(fn2), cv.IMREAD_GRAYSCALE)
+    detector, matcher = init_feature(feature_name)
+
+    if img1 is None:
+        print('Failed to load fn1:', fn1)
+        sys.exit(1)
+
+    if img2 is None:
+        print('Failed to load fn2:', fn2)
+        sys.exit(1)
+
+    if detector is None:
+        print('unknown feature:', feature_name)
+        sys.exit(1)
+
+    print('using', feature_name)
+
+    kp1, desc1 = detector.detectAndCompute(img1, None)
+    kp2, desc2 = detector.detectAndCompute(img2, None)
+    print('img1 - %d features, img2 - %d features' % (len(kp1), len(kp2)))
+
+    def match_and_draw(win):
+        print('matching...')
+        raw_matches = matcher.knnMatch(desc1, trainDescriptors = desc2, k = 2) #2
+        p1, p2, kp_pairs = filter_matches(kp1, kp2, raw_matches)
+        if len(p1) >= 4:
+            H, status = cv.findHomography(p1, p2, cv.RANSAC, 5.0)
+            print('%d / %d  inliers/matched' % (np.sum(status), len(status)))
+        else:
+            H, status = None, None
+            print('%d matches found, not enough for homography estimation' % len(p1))
+
+        _vis = explore_match(win, img1, img2, kp_pairs, status, H)
+
+    match_and_draw('find_obj')
+    cv.waitKey()
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/fitline.py b/C++/opencv-4.7.0/samples/python/fitline.py
new file mode 100644
index 00000000..db695cbb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/fitline.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+
+'''
+Robust line fitting.
+==================
+
+Example of using cv.fitLine function for fitting line
+to points in presence of outliers.
+
+Usage
+-----
+fitline.py
+
+Switch through different M-estimator functions and see,
+how well the robust functions fit the line even
+in case of ~50% of outliers.
+
+Keys
+----
+SPACE - generate random points
+f     - change distance function
+ESC   - exit
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+import numpy as np
+import cv2 as cv
+
+# built-in modules
+import itertools as it
+
+# local modules
+from common import draw_str
+
+
+w, h = 512, 256
+
+def toint(p):
+    return tuple(map(int, p))
+
+def sample_line(p1, p2, n, noise=0.0):
+    p1 = np.float32(p1)
+    t = np.random.rand(n,1)
+    return p1 + (p2-p1)*t + np.random.normal(size=(n, 2))*noise
+
+dist_func_names = it.cycle('DIST_L2 DIST_L1 DIST_L12 DIST_FAIR DIST_WELSCH DIST_HUBER'.split())
+
+if PY3:
+    cur_func_name = next(dist_func_names)
+else:
+    cur_func_name = dist_func_names.next()
+
+def update(_=None):
+    noise = cv.getTrackbarPos('noise', 'fit line')
+    n = cv.getTrackbarPos('point n', 'fit line')
+    r = cv.getTrackbarPos('outlier %', 'fit line') / 100.0
+    outn = int(n*r)
+
+    p0, p1 = (90, 80), (w-90, h-80)
+    img = np.zeros((h, w, 3), np.uint8)
+    cv.line(img, toint(p0), toint(p1), (0, 255, 0))
+
+    if n > 0:
+        line_points = sample_line(p0, p1, n-outn, noise)
+        outliers = np.random.rand(outn, 2) * (w, h)
+        points = np.vstack([line_points, outliers])
+        for p in line_points:
+            cv.circle(img, toint(p), 2, (255, 255, 255), -1)
+        for p in outliers:
+            cv.circle(img, toint(p), 2, (64, 64, 255), -1)
+        func = getattr(cv, cur_func_name)
+        vx, vy, cx, cy = cv.fitLine(np.float32(points), func, 0, 0.01, 0.01)
+        cv.line(img, (int(cx-vx*w), int(cy-vy*w)), (int(cx+vx*w), int(cy+vy*w)), (0, 0, 255))
+
+    draw_str(img, (20, 20), cur_func_name)
+    cv.imshow('fit line', img)
+
+def main():
+    cv.namedWindow('fit line')
+    cv.createTrackbar('noise', 'fit line', 3, 50, update)
+    cv.createTrackbar('point n', 'fit line', 100, 500, update)
+    cv.createTrackbar('outlier %', 'fit line', 30, 100, update)
+    while True:
+        update()
+        ch = cv.waitKey(0)
+        if ch == ord('f'):
+            global cur_func_name
+            if PY3:
+                cur_func_name = next(dist_func_names)
+            else:
+                cur_func_name = dist_func_names.next()
+        if ch == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/floodfill.py b/C++/opencv-4.7.0/samples/python/floodfill.py
new file mode 100644
index 00000000..da4b0095
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/floodfill.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+
+'''
+Floodfill sample.
+
+Usage:
+  floodfill.py [<image>]
+
+  Click on the image to set seed point
+
+Keys:
+  f     - toggle floating range
+  c     - toggle 4/8 connectivity
+  ESC   - exit
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import sys
+
+class App():
+
+    def update(self, dummy=None):
+        if self.seed_pt is None:
+            cv.imshow('floodfill', self.img)
+            return
+        flooded = self.img.copy()
+        self.mask[:] = 0
+        lo = cv.getTrackbarPos('lo', 'floodfill')
+        hi = cv.getTrackbarPos('hi', 'floodfill')
+        flags = self.connectivity
+        if self.fixed_range:
+            flags |= cv.FLOODFILL_FIXED_RANGE
+        cv.floodFill(flooded, self.mask, self.seed_pt, (255, 255, 255), (lo,)*3, (hi,)*3, flags)
+        cv.circle(flooded, self.seed_pt, 2, (0, 0, 255), -1)
+        cv.imshow('floodfill', flooded)
+
+    def onmouse(self, event, x, y, flags, param):
+        if flags & cv.EVENT_FLAG_LBUTTON:
+            self.seed_pt = x, y
+            self.update()
+
+    def run(self):
+        try:
+            fn = sys.argv[1]
+        except:
+            fn = 'fruits.jpg'
+
+        self.img = cv.imread(cv.samples.findFile(fn))
+        if self.img is None:
+            print('Failed to load image file:', fn)
+            sys.exit(1)
+
+        h, w = self.img.shape[:2]
+        self.mask = np.zeros((h+2, w+2), np.uint8)
+        self.seed_pt = None
+        self.fixed_range = True
+        self.connectivity = 4
+
+        self.update()
+        cv.setMouseCallback('floodfill', self.onmouse)
+        cv.createTrackbar('lo', 'floodfill', 20, 255, self.update)
+        cv.createTrackbar('hi', 'floodfill', 20, 255, self.update)
+
+        while True:
+            ch = cv.waitKey()
+            if ch == 27:
+                break
+            if ch == ord('f'):
+                self.fixed_range = not self.fixed_range
+                print('using %s range' % ('floating', 'fixed')[self.fixed_range])
+                self.update()
+            if ch == ord('c'):
+                self.connectivity = 12-self.connectivity
+                print('connectivity =', self.connectivity)
+                self.update()
+
+        print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    App().run()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/gabor_threads.py b/C++/opencv-4.7.0/samples/python/gabor_threads.py
new file mode 100644
index 00000000..dd14e6bf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/gabor_threads.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+
+'''
+gabor_threads.py
+=========
+
+Sample demonstrates:
+- use of multiple Gabor filter convolutions to get Fractalius-like image effect (http://www.redfieldplugins.com/filterFractalius.htm)
+- use of python threading to accelerate the computation
+
+Usage
+-----
+gabor_threads.py [image filename]
+
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+from multiprocessing.pool import ThreadPool
+
+
+def build_filters():
+    filters = []
+    ksize = 31
+    for theta in np.arange(0, np.pi, np.pi / 16):
+        kern = cv.getGaborKernel((ksize, ksize), 4.0, theta, 10.0, 0.5, 0, ktype=cv.CV_32F)
+        kern /= 1.5*kern.sum()
+        filters.append(kern)
+    return filters
+
+def process(img, filters):
+    accum = np.zeros_like(img)
+    for kern in filters:
+        fimg = cv.filter2D(img, cv.CV_8UC3, kern)
+        np.maximum(accum, fimg, accum)
+    return accum
+
+def process_threaded(img, filters, threadn = 8):
+    accum = np.zeros_like(img)
+    def f(kern):
+        return cv.filter2D(img, cv.CV_8UC3, kern)
+    pool = ThreadPool(processes=threadn)
+    for fimg in pool.imap_unordered(f, filters):
+        np.maximum(accum, fimg, accum)
+    return accum
+
+def main():
+    import sys
+    from common import Timer
+
+    try:
+        img_fn = sys.argv[1]
+    except:
+        img_fn = 'baboon.jpg'
+
+    img = cv.imread(cv.samples.findFile(img_fn))
+    if img is None:
+        print('Failed to load image file:', img_fn)
+        sys.exit(1)
+
+    filters = build_filters()
+
+    with Timer('running single-threaded'):
+        res1 = process(img, filters)
+    with Timer('running multi-threaded'):
+        res2 = process_threaded(img, filters)
+
+    print('res1 == res2: ', (res1 == res2).all())
+    cv.imshow('img', img)
+    cv.imshow('result', res2)
+    cv.waitKey()
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/gaussian_mix.py b/C++/opencv-4.7.0/samples/python/gaussian_mix.py
new file mode 100644
index 00000000..4c1f8679
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/gaussian_mix.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+
+from numpy import random
+
+def make_gaussians(cluster_n, img_size):
+    points = []
+    ref_distrs = []
+    for _i in xrange(cluster_n):
+        mean = (0.1 + 0.8*random.rand(2)) * img_size
+        a = (random.rand(2, 2)-0.5)*img_size*0.1
+        cov = np.dot(a.T, a) + img_size*0.05*np.eye(2)
+        n = 100 + random.randint(900)
+        pts = random.multivariate_normal(mean, cov, n)
+        points.append( pts )
+        ref_distrs.append( (mean, cov) )
+    points = np.float32( np.vstack(points) )
+    return points, ref_distrs
+
+def draw_gaussain(img, mean, cov, color):
+    x, y = mean
+    w, u, _vt = cv.SVDecomp(cov)
+    ang = np.arctan2(u[1, 0], u[0, 0])*(180/np.pi)
+    s1, s2 = np.sqrt(w)*3.0
+    cv.ellipse(img, (int(x), int(y)), (int(s1), int(s2)), ang, 0, 360, color, 1, cv.LINE_AA)
+
+
+def main():
+    cluster_n = 5
+    img_size = 512
+
+    print('press any key to update distributions, ESC - exit\n')
+
+    while True:
+        print('sampling distributions...')
+        points, ref_distrs = make_gaussians(cluster_n, img_size)
+
+        print('EM (opencv) ...')
+        em = cv.ml.EM_create()
+        em.setClustersNumber(cluster_n)
+        em.setCovarianceMatrixType(cv.ml.EM_COV_MAT_GENERIC)
+        em.trainEM(points)
+        means = em.getMeans()
+        covs = em.getCovs()  # Known bug: https://github.com/opencv/opencv/pull/4232
+        found_distrs = zip(means, covs)
+        print('ready!\n')
+
+        img = np.zeros((img_size, img_size, 3), np.uint8)
+        for x, y in np.int32(points):
+            cv.circle(img, (x, y), 1, (255, 255, 255), -1)
+        for m, cov in ref_distrs:
+            draw_gaussain(img, m, cov, (0, 255, 0))
+        for m, cov in found_distrs:
+            draw_gaussain(img, m, cov, (0, 0, 255))
+
+        cv.imshow('gaussian mixture', img)
+        ch = cv.waitKey(0)
+        if ch == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/grabcut.py b/C++/opencv-4.7.0/samples/python/grabcut.py
new file mode 100644
index 00000000..e2a035a9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/grabcut.py
@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+'''
+===============================================================================
+Interactive Image Segmentation using GrabCut algorithm.
+
+This sample shows interactive image segmentation using grabcut algorithm.
+
+USAGE:
+    python grabcut.py <filename>
+
+README FIRST:
+    Two windows will show up, one for input and one for output.
+
+    At first, in input window, draw a rectangle around the object using the
+right mouse button. Then press 'n' to segment the object (once or a few times)
+For any finer touch-ups, you can press any of the keys below and draw lines on
+the areas you want. Then again press 'n' to update the output.
+
+Key '0' - To select areas of sure background
+Key '1' - To select areas of sure foreground
+Key '2' - To select areas of probable background
+Key '3' - To select areas of probable foreground
+
+Key 'n' - To update the segmentation
+Key 'r' - To reset the setup
+Key 's' - To save the results
+===============================================================================
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import sys
+
+class App():
+    BLUE = [255,0,0]        # rectangle color
+    RED = [0,0,255]         # PR BG
+    GREEN = [0,255,0]       # PR FG
+    BLACK = [0,0,0]         # sure BG
+    WHITE = [255,255,255]   # sure FG
+
+    DRAW_BG = {'color' : BLACK, 'val' : 0}
+    DRAW_FG = {'color' : WHITE, 'val' : 1}
+    DRAW_PR_BG = {'color' : RED, 'val' : 2}
+    DRAW_PR_FG = {'color' : GREEN, 'val' : 3}
+
+    # setting up flags
+    rect = (0,0,1,1)
+    drawing = False         # flag for drawing curves
+    rectangle = False       # flag for drawing rect
+    rect_over = False       # flag to check if rect drawn
+    rect_or_mask = 100      # flag for selecting rect or mask mode
+    value = DRAW_FG         # drawing initialized to FG
+    thickness = 3           # brush thickness
+
+    def onmouse(self, event, x, y, flags, param):
+        # Draw Rectangle
+        if event == cv.EVENT_RBUTTONDOWN:
+            self.rectangle = True
+            self.ix, self.iy = x,y
+
+        elif event == cv.EVENT_MOUSEMOVE:
+            if self.rectangle == True:
+                self.img = self.img2.copy()
+                cv.rectangle(self.img, (self.ix, self.iy), (x, y), self.BLUE, 2)
+                self.rect = (min(self.ix, x), min(self.iy, y), abs(self.ix - x), abs(self.iy - y))
+                self.rect_or_mask = 0
+
+        elif event == cv.EVENT_RBUTTONUP:
+            self.rectangle = False
+            self.rect_over = True
+            cv.rectangle(self.img, (self.ix, self.iy), (x, y), self.BLUE, 2)
+            self.rect = (min(self.ix, x), min(self.iy, y), abs(self.ix - x), abs(self.iy - y))
+            self.rect_or_mask = 0
+            print(" Now press the key 'n' a few times until no further change \n")
+
+        # draw touchup curves
+
+        if event == cv.EVENT_LBUTTONDOWN:
+            if self.rect_over == False:
+                print("first draw rectangle \n")
+            else:
+                self.drawing = True
+                cv.circle(self.img, (x,y), self.thickness, self.value['color'], -1)
+                cv.circle(self.mask, (x,y), self.thickness, self.value['val'], -1)
+
+        elif event == cv.EVENT_MOUSEMOVE:
+            if self.drawing == True:
+                cv.circle(self.img, (x, y), self.thickness, self.value['color'], -1)
+                cv.circle(self.mask, (x, y), self.thickness, self.value['val'], -1)
+
+        elif event == cv.EVENT_LBUTTONUP:
+            if self.drawing == True:
+                self.drawing = False
+                cv.circle(self.img, (x, y), self.thickness, self.value['color'], -1)
+                cv.circle(self.mask, (x, y), self.thickness, self.value['val'], -1)
+
+    def run(self):
+        # Loading images
+        if len(sys.argv) == 2:
+            filename = sys.argv[1] # for drawing purposes
+        else:
+            print("No input image given, so loading default image, lena.jpg \n")
+            print("Correct Usage: python grabcut.py <filename> \n")
+            filename = 'lena.jpg'
+
+        self.img = cv.imread(cv.samples.findFile(filename))
+        self.img2 = self.img.copy()                               # a copy of original image
+        self.mask = np.zeros(self.img.shape[:2], dtype = np.uint8) # mask initialized to PR_BG
+        self.output = np.zeros(self.img.shape, np.uint8)           # output image to be shown
+
+        # input and output windows
+        cv.namedWindow('output')
+        cv.namedWindow('input')
+        cv.setMouseCallback('input', self.onmouse)
+        cv.moveWindow('input', self.img.shape[1]+10,90)
+
+        print(" Instructions: \n")
+        print(" Draw a rectangle around the object using right mouse button \n")
+
+        while(1):
+
+            cv.imshow('output', self.output)
+            cv.imshow('input', self.img)
+            k = cv.waitKey(1)
+
+            # key bindings
+            if k == 27:         # esc to exit
+                break
+            elif k == ord('0'): # BG drawing
+                print(" mark background regions with left mouse button \n")
+                self.value = self.DRAW_BG
+            elif k == ord('1'): # FG drawing
+                print(" mark foreground regions with left mouse button \n")
+                self.value = self.DRAW_FG
+            elif k == ord('2'): # PR_BG drawing
+                self.value = self.DRAW_PR_BG
+            elif k == ord('3'): # PR_FG drawing
+                self.value = self.DRAW_PR_FG
+            elif k == ord('s'): # save image
+                bar = np.zeros((self.img.shape[0], 5, 3), np.uint8)
+                res = np.hstack((self.img2, bar, self.img, bar, self.output))
+                cv.imwrite('grabcut_output.png', res)
+                print(" Result saved as image \n")
+            elif k == ord('r'): # reset everything
+                print("resetting \n")
+                self.rect = (0,0,1,1)
+                self.drawing = False
+                self.rectangle = False
+                self.rect_or_mask = 100
+                self.rect_over = False
+                self.value = self.DRAW_FG
+                self.img = self.img2.copy()
+                self.mask = np.zeros(self.img.shape[:2], dtype = np.uint8) # mask initialized to PR_BG
+                self.output = np.zeros(self.img.shape, np.uint8)           # output image to be shown
+            elif k == ord('n'): # segment the image
+                print(""" For finer touchups, mark foreground and background after pressing keys 0-3
+                and again press 'n' \n""")
+                try:
+                    bgdmodel = np.zeros((1, 65), np.float64)
+                    fgdmodel = np.zeros((1, 65), np.float64)
+                    if (self.rect_or_mask == 0):         # grabcut with rect
+                        cv.grabCut(self.img2, self.mask, self.rect, bgdmodel, fgdmodel, 1, cv.GC_INIT_WITH_RECT)
+                        self.rect_or_mask = 1
+                    elif (self.rect_or_mask == 1):       # grabcut with mask
+                        cv.grabCut(self.img2, self.mask, self.rect, bgdmodel, fgdmodel, 1, cv.GC_INIT_WITH_MASK)
+                except:
+                    import traceback
+                    traceback.print_exc()
+
+            mask2 = np.where((self.mask==1) + (self.mask==3), 255, 0).astype('uint8')
+            self.output = cv.bitwise_and(self.img2, self.img2, mask=mask2)
+
+        print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    App().run()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/hist.py b/C++/opencv-4.7.0/samples/python/hist.py
new file mode 100644
index 00000000..8c1f4546
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/hist.py
@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+
+''' This is a sample for histogram plotting for RGB images and grayscale images for better understanding of colour distribution
+
+Benefit : Learn how to draw histogram of images
+          Get familier with cv.calcHist, cv.equalizeHist,cv.normalize and some drawing functions
+
+Level : Beginner or Intermediate
+
+Functions : 1) hist_curve : returns histogram of an image drawn as curves
+            2) hist_lines : return histogram of an image drawn as bins ( only for grayscale images )
+
+Usage : python hist.py <image_file>
+
+Abid Rahman 3/14/12 debug Gary Bradski
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+bins = np.arange(256).reshape(256,1)
+
+def hist_curve(im):
+    h = np.zeros((300,256,3))
+    if len(im.shape) == 2:
+        color = [(255,255,255)]
+    elif im.shape[2] == 3:
+        color = [ (255,0,0),(0,255,0),(0,0,255) ]
+    for ch, col in enumerate(color):
+        hist_item = cv.calcHist([im],[ch],None,[256],[0,256])
+        cv.normalize(hist_item,hist_item,0,255,cv.NORM_MINMAX)
+        hist=np.int32(np.around(hist_item))
+        pts = np.int32(np.column_stack((bins,hist)))
+        cv.polylines(h,[pts],False,col)
+    y=np.flipud(h)
+    return y
+
+def hist_lines(im):
+    h = np.zeros((300,256,3))
+    if len(im.shape)!=2:
+        print("hist_lines applicable only for grayscale images")
+        #print("so converting image to grayscale for representation"
+        im = cv.cvtColor(im,cv.COLOR_BGR2GRAY)
+    hist_item = cv.calcHist([im],[0],None,[256],[0,256])
+    cv.normalize(hist_item,hist_item,0,255,cv.NORM_MINMAX)
+    hist = np.int32(np.around(hist_item))
+    for x,y in enumerate(hist):
+        cv.line(h,(x,0),(x,y[0]),(255,255,255))
+    y = np.flipud(h)
+    return y
+
+
+def main():
+    import sys
+
+    if len(sys.argv)>1:
+        fname = sys.argv[1]
+    else :
+        fname = 'lena.jpg'
+        print("usage : python hist.py <image_file>")
+
+    im = cv.imread(cv.samples.findFile(fname))
+
+    if im is None:
+        print('Failed to load image file:', fname)
+        sys.exit(1)
+
+    gray = cv.cvtColor(im,cv.COLOR_BGR2GRAY)
+
+
+    print(''' Histogram plotting \n
+    Keymap :\n
+    a - show histogram for color image in curve mode \n
+    b - show histogram in bin mode \n
+    c - show equalized histogram (always in bin mode) \n
+    d - show histogram for gray image in curve mode \n
+    e - show histogram for a normalized image in curve mode \n
+    Esc - exit \n
+    ''')
+
+    cv.imshow('image',im)
+    while True:
+        k = cv.waitKey(0)
+        if k == ord('a'):
+            curve = hist_curve(im)
+            cv.imshow('histogram',curve)
+            cv.imshow('image',im)
+            print('a')
+        elif k == ord('b'):
+            print('b')
+            lines = hist_lines(im)
+            cv.imshow('histogram',lines)
+            cv.imshow('image',gray)
+        elif k == ord('c'):
+            print('c')
+            equ = cv.equalizeHist(gray)
+            lines = hist_lines(equ)
+            cv.imshow('histogram',lines)
+            cv.imshow('image',equ)
+        elif k == ord('d'):
+            print('d')
+            curve = hist_curve(gray)
+            cv.imshow('histogram',curve)
+            cv.imshow('image',gray)
+        elif k == ord('e'):
+            print('e')
+            norm = cv.normalize(gray, gray, alpha = 0,beta = 255,norm_type = cv.NORM_MINMAX)
+            lines = hist_lines(norm)
+            cv.imshow('histogram',lines)
+            cv.imshow('image',norm)
+        elif k == 27:
+            print('ESC')
+            cv.destroyAllWindows()
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/houghcircles.py b/C++/opencv-4.7.0/samples/python/houghcircles.py
new file mode 100644
index 00000000..60a36714
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/houghcircles.py
@@ -0,0 +1,49 @@
+#!/usr/bin/python
+
+'''
+This example illustrates how to use cv.HoughCircles() function.
+
+Usage:
+    houghcircles.py [<image_name>]
+    image argument defaults to board.jpg
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import sys
+
+def main():
+    try:
+        fn = sys.argv[1]
+    except IndexError:
+        fn = 'board.jpg'
+
+    src = cv.imread(cv.samples.findFile(fn))
+    img = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    img = cv.medianBlur(img, 5)
+    cimg = src.copy() # numpy function
+
+    circles = cv.HoughCircles(img, cv.HOUGH_GRADIENT, 1, 10, np.array([]), 100, 30, 1, 30)
+
+    if circles is not None: # Check if circles have been found and only then iterate over these and add them to the image
+        circles = np.uint16(np.around(circles))
+        _a, b, _c = circles.shape
+        for i in range(b):
+            cv.circle(cimg, (circles[0][i][0], circles[0][i][1]), circles[0][i][2], (0, 0, 255), 3, cv.LINE_AA)
+            cv.circle(cimg, (circles[0][i][0], circles[0][i][1]), 2, (0, 255, 0), 3, cv.LINE_AA)  # draw center of circle
+
+        cv.imshow("detected circles", cimg)
+
+    cv.imshow("source", src)
+    cv.waitKey(0)
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/houghlines.py b/C++/opencv-4.7.0/samples/python/houghlines.py
new file mode 100644
index 00000000..022b680f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/houghlines.py
@@ -0,0 +1,60 @@
+#!/usr/bin/python
+
+'''
+This example illustrates how to use Hough Transform to find lines
+
+Usage:
+    houghlines.py [<image_name>]
+    image argument defaults to pic1.png
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import cv2 as cv
+import numpy as np
+
+import sys
+import math
+
+def main():
+    try:
+        fn = sys.argv[1]
+    except IndexError:
+        fn = 'pic1.png'
+
+    src = cv.imread(cv.samples.findFile(fn))
+    dst = cv.Canny(src, 50, 200)
+    cdst = cv.cvtColor(dst, cv.COLOR_GRAY2BGR)
+
+    if True: # HoughLinesP
+        lines = cv.HoughLinesP(dst, 1, math.pi/180.0, 40, np.array([]), 50, 10)
+        a, b, _c = lines.shape
+        for i in range(a):
+            cv.line(cdst, (lines[i][0][0], lines[i][0][1]), (lines[i][0][2], lines[i][0][3]), (0, 0, 255), 3, cv.LINE_AA)
+
+    else:    # HoughLines
+        lines = cv.HoughLines(dst, 1, math.pi/180.0, 50, np.array([]), 0, 0)
+        if lines is not None:
+            a, b, _c = lines.shape
+            for i in range(a):
+                rho = lines[i][0][0]
+                theta = lines[i][0][1]
+                a = math.cos(theta)
+                b = math.sin(theta)
+                x0, y0 = a*rho, b*rho
+                pt1 = ( int(x0+1000*(-b)), int(y0+1000*(a)) )
+                pt2 = ( int(x0-1000*(-b)), int(y0-1000*(a)) )
+                cv.line(cdst, pt1, pt2, (0, 0, 255), 3, cv.LINE_AA)
+
+    cv.imshow("detected lines", cdst)
+
+    cv.imshow("source", src)
+    cv.waitKey(0)
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/inpaint.py b/C++/opencv-4.7.0/samples/python/inpaint.py
new file mode 100644
index 00000000..53f8e988
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/inpaint.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+'''
+Inpainting sample.
+
+Inpainting repairs damage to images by floodfilling
+the damage with surrounding image areas.
+
+Usage:
+  inpaint.py [<image>]
+
+Keys:
+  SPACE - inpaint
+  r     - reset the inpainting mask
+  ESC   - exit
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+from common import Sketcher
+
+def main():
+    import sys
+    try:
+        fn = sys.argv[1]
+    except:
+        fn = 'fruits.jpg'
+
+    img = cv.imread(cv.samples.findFile(fn))
+    if img is None:
+        print('Failed to load image file:', fn)
+        sys.exit(1)
+
+    img_mark = img.copy()
+    mark = np.zeros(img.shape[:2], np.uint8)
+    sketch = Sketcher('img', [img_mark, mark], lambda : ((255, 255, 255), 255))
+
+    while True:
+        ch = cv.waitKey()
+        if ch == 27:
+            break
+        if ch == ord(' '):
+            res = cv.inpaint(img_mark, mark, 3, cv.INPAINT_TELEA)
+            cv.imshow('inpaint', res)
+        if ch == ord('r'):
+            img_mark[:] = img
+            mark[:] = 0
+            sketch.show()
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/kalman.py b/C++/opencv-4.7.0/samples/python/kalman.py
new file mode 100644
index 00000000..cf152a87
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/kalman.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+"""
+   Tracking of rotating point.
+   Point moves in a circle and is characterized by a 1D state.
+   state_k+1 = state_k + speed + process_noise N(0, 1e-5)
+   The speed is constant.
+   Both state and measurements vectors are 1D (a point angle),
+   Measurement is the real state + gaussian noise N(0, 1e-1).
+   The real and the measured points are connected with red line segment,
+   the real and the estimated points are connected with yellow line segment,
+   the real and the corrected estimated points are connected with green line segment.
+   (if Kalman filter works correctly,
+    the yellow segment should be shorter than the red one and
+    the green segment should be shorter than the yellow one).
+   Pressing any key (except ESC) will reset the tracking.
+   Pressing ESC will stop the program.
+"""
+# Python 2/3 compatibility
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    long = int
+
+import numpy as np
+import cv2 as cv
+
+from math import cos, sin, sqrt, pi
+
+def main():
+    img_height = 500
+    img_width = 500
+    kalman = cv.KalmanFilter(2, 1, 0)
+
+    code = long(-1)
+    num_circle_steps = 12
+    while True:
+        img = np.zeros((img_height, img_width, 3), np.uint8)
+        state = np.array([[0.0],[(2 * pi) / num_circle_steps]])   # start state
+        kalman.transitionMatrix = np.array([[1., 1.], [0., 1.]])  # F. input
+        kalman.measurementMatrix = 1. * np.eye(1, 2)              # H. input
+        kalman.processNoiseCov = 1e-5 * np.eye(2)                 # Q. input
+        kalman.measurementNoiseCov = 1e-1 * np.ones((1, 1))       # R. input
+        kalman.errorCovPost = 1. * np.eye(2, 2)                   # P._k|k  KF state var
+        kalman.statePost = 0.1 * np.random.randn(2, 1)            # x^_k|k  KF state var
+
+        while True:
+            def calc_point(angle):
+                return (np.around(img_width / 2. + img_width / 3.0 * cos(angle), 0).astype(int),
+                        np.around(img_height / 2. - img_width / 3.0 * sin(angle), 1).astype(int))
+            img = img * 1e-3
+            state_angle = state[0, 0]
+            state_pt = calc_point(state_angle)
+            # advance Kalman filter to next timestep
+            # updates statePre, statePost, errorCovPre, errorCovPost
+            # k-> k+1, x'(k) = A*x(k)
+            # P'(k) = temp1*At + Q
+            prediction = kalman.predict()
+
+            predict_pt = calc_point(prediction[0, 0])  # equivalent to calc_point(kalman.statePre[0,0])
+            # generate measurement
+            measurement = kalman.measurementNoiseCov * np.random.randn(1, 1)
+            measurement = np.dot(kalman.measurementMatrix, state) + measurement
+
+            measurement_angle = measurement[0, 0]
+            measurement_pt = calc_point(measurement_angle)
+
+            # correct the state estimates based on measurements
+            # updates statePost & errorCovPost
+            kalman.correct(measurement)
+            improved_pt = calc_point(kalman.statePost[0, 0])
+
+            # plot points
+            cv.drawMarker(img, measurement_pt, (0, 0, 255), cv.MARKER_SQUARE, 5, 2)
+            cv.drawMarker(img, predict_pt, (0, 255, 255), cv.MARKER_SQUARE, 5, 2)
+            cv.drawMarker(img, improved_pt, (0, 255, 0), cv.MARKER_SQUARE, 5, 2)
+            cv.drawMarker(img, state_pt, (255, 255, 255), cv.MARKER_STAR, 10, 1)
+            # forecast one step
+            cv.drawMarker(img, calc_point(np.dot(kalman.transitionMatrix, kalman.statePost)[0, 0]),
+                          (255, 255, 0), cv.MARKER_SQUARE, 12, 1)
+
+            cv.line(img, state_pt, measurement_pt, (0, 0, 255), 1, cv.LINE_AA, 0)  # red measurement error
+            cv.line(img, state_pt, predict_pt, (0, 255, 255), 1, cv.LINE_AA, 0)  # yellow pre-meas error
+            cv.line(img, state_pt, improved_pt, (0, 255, 0), 1, cv.LINE_AA, 0)  # green post-meas error
+
+            # update the real process
+            process_noise = sqrt(kalman.processNoiseCov[0, 0]) * np.random.randn(2, 1)
+            state = np.dot(kalman.transitionMatrix, state) + process_noise  # x_k+1 = F x_k + w_k
+
+            cv.imshow("Kalman", img)
+            code = cv.waitKey(1000)
+            if code != -1:
+                break
+
+        if code in [27, ord('q'), ord('Q')]:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/kmeans.py b/C++/opencv-4.7.0/samples/python/kmeans.py
new file mode 100644
index 00000000..1b1c9d6a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/kmeans.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+
+'''
+K-means clusterization sample.
+Usage:
+   kmeans.py
+
+Keyboard shortcuts:
+   ESC   - exit
+   space - generate new distribution
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+from gaussian_mix import make_gaussians
+
+def main():
+    cluster_n = 5
+    img_size = 512
+
+    # generating bright palette
+    colors = np.zeros((1, cluster_n, 3), np.uint8)
+    colors[0,:] = 255
+    colors[0,:,0] = np.arange(0, 180, 180.0/cluster_n)
+    colors = cv.cvtColor(colors, cv.COLOR_HSV2BGR)[0]
+
+    while True:
+        print('sampling distributions...')
+        points, _ = make_gaussians(cluster_n, img_size)
+
+        term_crit = (cv.TERM_CRITERIA_EPS, 30, 0.1)
+        _ret, labels, _centers = cv.kmeans(points, cluster_n, None, term_crit, 10, 0)
+
+        img = np.zeros((img_size, img_size, 3), np.uint8)
+        for (x, y), label in zip(np.int32(points), labels.ravel()):
+            c = list(map(int, colors[label]))
+
+            cv.circle(img, (x, y), 1, c, -1)
+
+        cv.imshow('kmeans', img)
+        ch = cv.waitKey(0)
+        if ch == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/laplace.py b/C++/opencv-4.7.0/samples/python/laplace.py
new file mode 100644
index 00000000..f485e574
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/laplace.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+'''
+    This program demonstrates Laplace point/edge detection using
+    OpenCV function Laplacian()
+    It captures from the camera of your choice: 0, 1, ... default 0
+    Usage:
+        python laplace.py <ddepth> <smoothType> <sigma>
+        If no arguments given default arguments will be used.
+
+    Keyboard Shortcuts:
+    Press space bar to exit the program.
+    '''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+import sys
+
+def main():
+    # Declare the variables we are going to use
+    ddepth = cv.CV_16S
+    smoothType = "MedianBlur"
+    sigma = 3
+    if len(sys.argv)==4:
+        ddepth = sys.argv[1]
+        smoothType = sys.argv[2]
+        sigma = sys.argv[3]
+    # Taking input from the camera
+    cap=cv.VideoCapture(0)
+    # Create Window and Trackbar
+    cv.namedWindow("Laplace of Image", cv.WINDOW_AUTOSIZE)
+    cv.createTrackbar("Kernel Size Bar", "Laplace of Image", sigma, 15, lambda x:x)
+    # Printing frame width, height and FPS
+    print("=="*40)
+    print("Frame Width: ", cap.get(cv.CAP_PROP_FRAME_WIDTH), "Frame Height: ", cap.get(cv.CAP_PROP_FRAME_HEIGHT), "FPS: ", cap.get(cv.CAP_PROP_FPS))
+    while True:
+        # Reading input from the camera
+        ret, frame = cap.read()
+        if ret == False:
+            print("Can't open camera/video stream")
+            break
+        # Taking input/position from the trackbar
+        sigma = cv.getTrackbarPos("Kernel Size Bar", "Laplace of Image")
+        # Setting kernel size
+        ksize = (sigma*5)|1
+        # Removing noise by blurring with a filter
+        if smoothType == "GAUSSIAN":
+            smoothed = cv.GaussianBlur(frame, (ksize, ksize), sigma, sigma)
+        if smoothType == "BLUR":
+            smoothed = cv.blur(frame, (ksize, ksize))
+        if smoothType == "MedianBlur":
+            smoothed = cv.medianBlur(frame, ksize)
+
+        # Apply Laplace function
+        laplace = cv.Laplacian(smoothed, ddepth, 5)
+        # Converting back to uint8
+        result = cv.convertScaleAbs(laplace, (sigma+1)*0.25)
+        # Display Output
+        cv.imshow("Laplace of Image", result)
+        k = cv.waitKey(30)
+        if k == 27:
+            return
+if __name__ == "__main__":
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/lappyr.py b/C++/opencv-4.7.0/samples/python/lappyr.py
new file mode 100644
index 00000000..2835b98d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/lappyr.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+
+''' An example of Laplacian Pyramid construction and merging.
+
+Level : Intermediate
+
+Usage : python lappyr.py [<video source>]
+
+References:
+  http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.54.299
+
+Alexander Mordvintsev 6/10/12
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+
+import video
+from common import nothing, getsize
+
+def build_lappyr(img, leveln=6, dtype=np.int16):
+    img = dtype(img)
+    levels = []
+    for _i in xrange(leveln-1):
+        next_img = cv.pyrDown(img)
+        img1 = cv.pyrUp(next_img, dstsize=getsize(img))
+        levels.append(img-img1)
+        img = next_img
+    levels.append(img)
+    return levels
+
+def merge_lappyr(levels):
+    img = levels[-1]
+    for lev_img in levels[-2::-1]:
+        img = cv.pyrUp(img, dstsize=getsize(lev_img))
+        img += lev_img
+    return np.uint8(np.clip(img, 0, 255))
+
+
+def main():
+    import sys
+
+    try:
+        fn = sys.argv[1]
+    except:
+        fn = 0
+    cap = video.create_capture(fn)
+
+    leveln = 6
+    cv.namedWindow('level control')
+    for i in xrange(leveln):
+        cv.createTrackbar('%d'%i, 'level control', 5, 50, nothing)
+
+    while True:
+        _ret, frame = cap.read()
+
+        pyr = build_lappyr(frame, leveln)
+        for i in xrange(leveln):
+            v = int(cv.getTrackbarPos('%d'%i, 'level control') / 5)
+            pyr[i] *= v
+        res = merge_lappyr(pyr)
+
+        cv.imshow('laplacian pyramid filter', res)
+
+        if cv.waitKey(1) == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/letter_recog.py b/C++/opencv-4.7.0/samples/python/letter_recog.py
new file mode 100644
index 00000000..f646f178
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/letter_recog.py
@@ -0,0 +1,194 @@
+#!/usr/bin/env python
+
+'''
+The sample demonstrates how to train Random Trees classifier
+(or Boosting classifier, or MLP, or Knearest, or Support Vector Machines) using the provided dataset.
+
+We use the sample database letter-recognition.data
+from UCI Repository, here is the link:
+
+Newman, D.J. & Hettich, S. & Blake, C.L. & Merz, C.J. (1998).
+UCI Repository of machine learning databases
+[http://www.ics.uci.edu/~mlearn/MLRepository.html].
+Irvine, CA: University of California, Department of Information and Computer Science.
+
+The dataset consists of 20000 feature vectors along with the
+responses - capital latin letters A..Z.
+The first 10000 samples are used for training
+and the remaining 10000 - to test the classifier.
+======================================================
+USAGE:
+  letter_recog.py [--model <model>]
+                  [--data <data fn>]
+                  [--load <model fn>] [--save <model fn>]
+
+  Models: RTrees, KNearest, Boost, SVM, MLP
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+def load_base(fn):
+    a = np.loadtxt(fn, np.float32, delimiter=',', converters={ 0 : lambda ch : ord(ch)-ord('A') })
+    samples, responses = a[:,1:], a[:,0]
+    return samples, responses
+
+class LetterStatModel(object):
+    class_n = 26
+    train_ratio = 0.5
+
+    def load(self, fn):
+        self.model = self.model.load(fn)
+    def save(self, fn):
+        self.model.save(fn)
+
+    def unroll_samples(self, samples):
+        sample_n, var_n = samples.shape
+        new_samples = np.zeros((sample_n * self.class_n, var_n+1), np.float32)
+        new_samples[:,:-1] = np.repeat(samples, self.class_n, axis=0)
+        new_samples[:,-1] = np.tile(np.arange(self.class_n), sample_n)
+        return new_samples
+
+    def unroll_responses(self, responses):
+        sample_n = len(responses)
+        new_responses = np.zeros(sample_n*self.class_n, np.int32)
+        resp_idx = np.int32( responses + np.arange(sample_n)*self.class_n )
+        new_responses[resp_idx] = 1
+        return new_responses
+
+class RTrees(LetterStatModel):
+    def __init__(self):
+        self.model = cv.ml.RTrees_create()
+
+    def train(self, samples, responses):
+        self.model.setMaxDepth(20)
+        self.model.train(samples, cv.ml.ROW_SAMPLE, responses.astype(int))
+
+    def predict(self, samples):
+        _ret, resp = self.model.predict(samples)
+        return resp.ravel()
+
+
+class KNearest(LetterStatModel):
+    def __init__(self):
+        self.model = cv.ml.KNearest_create()
+
+    def train(self, samples, responses):
+        self.model.train(samples, cv.ml.ROW_SAMPLE, responses)
+
+    def predict(self, samples):
+        _retval, results, _neigh_resp, _dists = self.model.findNearest(samples, k = 10)
+        return results.ravel()
+
+
+class Boost(LetterStatModel):
+    def __init__(self):
+        self.model = cv.ml.Boost_create()
+
+    def train(self, samples, responses):
+        _sample_n, var_n = samples.shape
+        new_samples = self.unroll_samples(samples)
+        new_responses = self.unroll_responses(responses)
+        var_types = np.array([cv.ml.VAR_NUMERICAL] * var_n + [cv.ml.VAR_CATEGORICAL, cv.ml.VAR_CATEGORICAL], np.uint8)
+
+        self.model.setWeakCount(15)
+        self.model.setMaxDepth(10)
+        self.model.train(cv.ml.TrainData_create(new_samples, cv.ml.ROW_SAMPLE, new_responses.astype(int), varType = var_types))
+
+    def predict(self, samples):
+        new_samples = self.unroll_samples(samples)
+        _ret, resp = self.model.predict(new_samples)
+
+        return resp.ravel().reshape(-1, self.class_n).argmax(1)
+
+
+class SVM(LetterStatModel):
+    def __init__(self):
+        self.model = cv.ml.SVM_create()
+
+    def train(self, samples, responses):
+        self.model.setType(cv.ml.SVM_C_SVC)
+        self.model.setC(1)
+        self.model.setKernel(cv.ml.SVM_RBF)
+        self.model.setGamma(.1)
+        self.model.train(samples, cv.ml.ROW_SAMPLE, responses.astype(int))
+
+    def predict(self, samples):
+        _ret, resp = self.model.predict(samples)
+        return resp.ravel()
+
+
+class MLP(LetterStatModel):
+    def __init__(self):
+        self.model = cv.ml.ANN_MLP_create()
+
+    def train(self, samples, responses):
+        _sample_n, var_n = samples.shape
+        new_responses = self.unroll_responses(responses).reshape(-1, self.class_n)
+        layer_sizes = np.int32([var_n, 100, 100, self.class_n])
+
+        self.model.setLayerSizes(layer_sizes)
+        self.model.setTrainMethod(cv.ml.ANN_MLP_BACKPROP)
+        self.model.setBackpropMomentumScale(0.0)
+        self.model.setBackpropWeightScale(0.001)
+        self.model.setTermCriteria((cv.TERM_CRITERIA_COUNT, 20, 0.01))
+        self.model.setActivationFunction(cv.ml.ANN_MLP_SIGMOID_SYM, 2, 1)
+
+        self.model.train(samples, cv.ml.ROW_SAMPLE, np.float32(new_responses))
+
+    def predict(self, samples):
+        _ret, resp = self.model.predict(samples)
+        return resp.argmax(-1)
+
+
+
+def main():
+    import getopt
+    import sys
+
+    models = [RTrees, KNearest, Boost, SVM, MLP] # NBayes
+    models = dict( [(cls.__name__.lower(), cls) for cls in models] )
+
+
+    args, dummy = getopt.getopt(sys.argv[1:], '', ['model=', 'data=', 'load=', 'save='])
+    args = dict(args)
+    args.setdefault('--model', 'svm')
+    args.setdefault('--data', 'letter-recognition.data')
+
+    datafile = cv.samples.findFile(args['--data'])
+
+    print('loading data %s ...' % datafile)
+    samples, responses = load_base(datafile)
+    Model = models[args['--model']]
+    model = Model()
+
+    train_n = int(len(samples)*model.train_ratio)
+    if '--load' in args:
+        fn = args['--load']
+        print('loading model from %s ...' % fn)
+        model.load(fn)
+    else:
+        print('training %s ...' % Model.__name__)
+        model.train(samples[:train_n], responses[:train_n])
+
+    print('testing...')
+    train_rate = np.mean(model.predict(samples[:train_n]) == responses[:train_n].astype(int))
+    test_rate  = np.mean(model.predict(samples[train_n:]) == responses[train_n:].astype(int))
+
+    print('train rate: %f  test rate: %f' % (train_rate*100, test_rate*100))
+
+    if '--save' in args:
+        fn = args['--save']
+        print('saving model to %s ...' % fn)
+        model.save(fn)
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/lk_homography.py b/C++/opencv-4.7.0/samples/python/lk_homography.py
new file mode 100644
index 00000000..38a05f63
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/lk_homography.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python
+
+'''
+Lucas-Kanade homography tracker
+===============================
+
+Lucas-Kanade sparse optical flow demo. Uses goodFeaturesToTrack
+for track initialization and back-tracking for match verification
+between frames. Finds homography between reference and current views.
+
+Usage
+-----
+lk_homography.py [<video_source>]
+
+
+Keys
+----
+ESC   - exit
+SPACE - start tracking
+r     - toggle RANSAC
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import video
+from common import draw_str
+from video import presets
+
+lk_params = dict( winSize  = (19, 19),
+                  maxLevel = 2,
+                  criteria = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 0.03))
+
+feature_params = dict( maxCorners = 1000,
+                       qualityLevel = 0.01,
+                       minDistance = 8,
+                       blockSize = 19 )
+
+def checkedTrace(img0, img1, p0, back_threshold = 1.0):
+    p1, _st, _err = cv.calcOpticalFlowPyrLK(img0, img1, p0, None, **lk_params)
+    p0r, _st, _err = cv.calcOpticalFlowPyrLK(img1, img0, p1, None, **lk_params)
+    d = abs(p0-p0r).reshape(-1, 2).max(-1)
+    status = d < back_threshold
+    return p1, status
+
+green = (0, 255, 0)
+red = (0, 0, 255)
+
+class App:
+    def __init__(self, video_src):
+        self.cam = self.cam = video.create_capture(video_src, presets['book'])
+        self.p0 = None
+        self.use_ransac = True
+
+    def run(self):
+        while True:
+            _ret, frame = self.cam.read()
+            frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+            vis = frame.copy()
+            if self.p0 is not None:
+                p2, trace_status = checkedTrace(self.gray1, frame_gray, self.p1)
+
+                self.p1 = p2[trace_status].copy()
+                self.p0 = self.p0[trace_status].copy()
+                self.gray1 = frame_gray
+
+                if len(self.p0) < 4:
+                    self.p0 = None
+                    continue
+                H, status = cv.findHomography(self.p0, self.p1, (0, cv.RANSAC)[self.use_ransac], 10.0)
+                h, w = frame.shape[:2]
+                overlay = cv.warpPerspective(self.frame0, H, (w, h))
+                vis = cv.addWeighted(vis, 0.5, overlay, 0.5, 0.0)
+
+                for (x0, y0), (x1, y1), good in zip(self.p0[:,0], self.p1[:,0], status[:,0]):
+                    if good:
+                        cv.line(vis, (int(x0), int(y0)), (int(x1), int(y1)), (0, 128, 0))
+                    cv.circle(vis, (int(x1), int(y1)), 2, (red, green)[good], -1)
+                draw_str(vis, (20, 20), 'track count: %d' % len(self.p1))
+                if self.use_ransac:
+                    draw_str(vis, (20, 40), 'RANSAC')
+            else:
+                p = cv.goodFeaturesToTrack(frame_gray, **feature_params)
+                if p is not None:
+                    for x, y in p[:,0]:
+                        cv.circle(vis, (int(x), int(y)), 2, green, -1)
+                    draw_str(vis, (20, 20), 'feature count: %d' % len(p))
+
+            cv.imshow('lk_homography', vis)
+
+            ch = cv.waitKey(1)
+            if ch == 27:
+                break
+            if ch == ord(' '):
+                self.frame0 = frame.copy()
+                self.p0 = cv.goodFeaturesToTrack(frame_gray, **feature_params)
+                if self.p0 is not None:
+                    self.p1 = self.p0
+                    self.gray0 = frame_gray
+                    self.gray1 = frame_gray
+            if ch == ord('r'):
+                self.use_ransac = not self.use_ransac
+
+
+
+def main():
+    import sys
+    try:
+        video_src = sys.argv[1]
+    except:
+        video_src = 0
+
+    App(video_src).run()
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/lk_track.py b/C++/opencv-4.7.0/samples/python/lk_track.py
new file mode 100644
index 00000000..97a8c402
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/lk_track.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+
+'''
+Lucas-Kanade tracker
+====================
+
+Lucas-Kanade sparse optical flow demo. Uses goodFeaturesToTrack
+for track initialization and back-tracking for match verification
+between frames.
+
+Usage
+-----
+lk_track.py [<video_source>]
+
+
+Keys
+----
+ESC - exit
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import video
+from common import anorm2, draw_str
+
+lk_params = dict( winSize  = (15, 15),
+                  maxLevel = 2,
+                  criteria = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 0.03))
+
+feature_params = dict( maxCorners = 500,
+                       qualityLevel = 0.3,
+                       minDistance = 7,
+                       blockSize = 7 )
+
+class App:
+    def __init__(self, video_src):
+        self.track_len = 10
+        self.detect_interval = 5
+        self.tracks = []
+        self.cam = video.create_capture(video_src)
+        self.frame_idx = 0
+
+    def run(self):
+        while True:
+            _ret, frame = self.cam.read()
+            frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+            vis = frame.copy()
+
+            if len(self.tracks) > 0:
+                img0, img1 = self.prev_gray, frame_gray
+                p0 = np.float32([tr[-1] for tr in self.tracks]).reshape(-1, 1, 2)
+                p1, _st, _err = cv.calcOpticalFlowPyrLK(img0, img1, p0, None, **lk_params)
+                p0r, _st, _err = cv.calcOpticalFlowPyrLK(img1, img0, p1, None, **lk_params)
+                d = abs(p0-p0r).reshape(-1, 2).max(-1)
+                good = d < 1
+                new_tracks = []
+                for tr, (x, y), good_flag in zip(self.tracks, p1.reshape(-1, 2), good):
+                    if not good_flag:
+                        continue
+                    tr.append((x, y))
+                    if len(tr) > self.track_len:
+                        del tr[0]
+                    new_tracks.append(tr)
+                    cv.circle(vis, (int(x), int(y)), 2, (0, 255, 0), -1)
+                self.tracks = new_tracks
+                cv.polylines(vis, [np.int32(tr) for tr in self.tracks], False, (0, 255, 0))
+                draw_str(vis, (20, 20), 'track count: %d' % len(self.tracks))
+
+            if self.frame_idx % self.detect_interval == 0:
+                mask = np.zeros_like(frame_gray)
+                mask[:] = 255
+                for x, y in [np.int32(tr[-1]) for tr in self.tracks]:
+                    cv.circle(mask, (x, y), 5, 0, -1)
+                p = cv.goodFeaturesToTrack(frame_gray, mask = mask, **feature_params)
+                if p is not None:
+                    for x, y in np.float32(p).reshape(-1, 2):
+                        self.tracks.append([(x, y)])
+
+
+            self.frame_idx += 1
+            self.prev_gray = frame_gray
+            cv.imshow('lk_track', vis)
+
+            ch = cv.waitKey(1)
+            if ch == 27:
+                break
+
+def main():
+    import sys
+    try:
+        video_src = sys.argv[1]
+    except:
+        video_src = 0
+
+    App(video_src).run()
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/logpolar.py b/C++/opencv-4.7.0/samples/python/logpolar.py
new file mode 100644
index 00000000..0dc6b8ba
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/logpolar.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+
+'''
+plots image as logPolar and linearPolar
+
+Usage:
+    logpolar.py
+
+Keys:
+    ESC    - exit
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+def main():
+    import sys
+    try:
+        fn = sys.argv[1]
+    except IndexError:
+        fn = 'fruits.jpg'
+
+    img = cv.imread(cv.samples.findFile(fn))
+    if img is None:
+        print('Failed to load image file:', fn)
+        sys.exit(1)
+
+    img2 = cv.logPolar(img, (img.shape[0]/2, img.shape[1]/2), 40, cv.WARP_FILL_OUTLIERS)
+    img3 = cv.linearPolar(img, (img.shape[0]/2, img.shape[1]/2), 40, cv.WARP_FILL_OUTLIERS)
+
+    cv.imshow('before', img)
+    cv.imshow('logpolar', img2)
+    cv.imshow('linearpolar', img3)
+
+    cv.waitKey(0)
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/morphology.py b/C++/opencv-4.7.0/samples/python/morphology.py
new file mode 100644
index 00000000..183f5e82
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/morphology.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+
+'''
+Morphology operations.
+
+Usage:
+  morphology.py [<image>]
+
+Keys:
+  1   - change operation
+  2   - change structure element shape
+  ESC - exit
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+import numpy as np
+import cv2 as cv
+
+
+def main():
+    import sys
+    from itertools import cycle
+    from common import draw_str
+
+    try:
+        fn = sys.argv[1]
+    except:
+        fn = 'baboon.jpg'
+
+    img = cv.imread(cv.samples.findFile(fn))
+
+    if img is None:
+        print('Failed to load image file:', fn)
+        sys.exit(1)
+
+    cv.imshow('original', img)
+
+    modes = cycle(['erode/dilate', 'open/close', 'blackhat/tophat', 'gradient'])
+    str_modes = cycle(['ellipse', 'rect', 'cross'])
+
+    if PY3:
+        cur_mode = next(modes)
+        cur_str_mode = next(str_modes)
+    else:
+        cur_mode = modes.next()
+        cur_str_mode = str_modes.next()
+
+    def update(dummy=None):
+        try: # do not get trackbar position while trackbar is not created
+            sz = cv.getTrackbarPos('op/size', 'morphology')
+            iters = cv.getTrackbarPos('iters', 'morphology')
+        except:
+            return
+        opers = cur_mode.split('/')
+        if len(opers) > 1:
+            sz = sz - 10
+            op = opers[sz > 0]
+            sz = abs(sz)
+        else:
+            op = opers[0]
+        sz = sz*2+1
+
+        str_name = 'MORPH_' + cur_str_mode.upper()
+        oper_name = 'MORPH_' + op.upper()
+        st = cv.getStructuringElement(getattr(cv, str_name), (sz, sz))
+        res = cv.morphologyEx(img, getattr(cv, oper_name), st, iterations=iters)
+
+        draw_str(res, (10, 20), 'mode: ' + cur_mode)
+        draw_str(res, (10, 40), 'operation: ' + oper_name)
+        draw_str(res, (10, 60), 'structure: ' + str_name)
+        draw_str(res, (10, 80), 'ksize: %d  iters: %d' % (sz, iters))
+        cv.imshow('morphology', res)
+
+    cv.namedWindow('morphology')
+    cv.createTrackbar('op/size', 'morphology', 12, 20, update)
+    cv.createTrackbar('iters', 'morphology', 1, 10, update)
+    update()
+    while True:
+        ch = cv.waitKey()
+        if ch == 27:
+            break
+        if ch == ord('1'):
+            if PY3:
+                cur_mode = next(modes)
+            else:
+                cur_mode = modes.next()
+        if ch == ord('2'):
+            if PY3:
+                cur_str_mode = next(str_modes)
+            else:
+                cur_str_mode = str_modes.next()
+        update()
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/mosse.py b/C++/opencv-4.7.0/samples/python/mosse.py
new file mode 100644
index 00000000..e11e9215
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/mosse.py
@@ -0,0 +1,198 @@
+#!/usr/bin/env python
+
+'''
+MOSSE tracking sample
+
+This sample implements correlation-based tracking approach, described in [1].
+
+Usage:
+  mosse.py [--pause] [<video source>]
+
+  --pause  -  Start with playback paused at the first video frame.
+              Useful for tracking target selection.
+
+  Draw rectangles around objects with a mouse to track them.
+
+Keys:
+  SPACE    - pause video
+  c        - clear targets
+
+[1] David S. Bolme et al. "Visual Object Tracking using Adaptive Correlation Filters"
+    http://www.cs.colostate.edu/~draper/papers/bolme_cvpr10.pdf
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+from common import draw_str, RectSelector
+import video
+
+def rnd_warp(a):
+    h, w = a.shape[:2]
+    T = np.zeros((2, 3))
+    coef = 0.2
+    ang = (np.random.rand()-0.5)*coef
+    c, s = np.cos(ang), np.sin(ang)
+    T[:2, :2] = [[c,-s], [s, c]]
+    T[:2, :2] += (np.random.rand(2, 2) - 0.5)*coef
+    c = (w/2, h/2)
+    T[:,2] = c - np.dot(T[:2, :2], c)
+    return cv.warpAffine(a, T, (w, h), borderMode = cv.BORDER_REFLECT)
+
+def divSpec(A, B):
+    Ar, Ai = A[...,0], A[...,1]
+    Br, Bi = B[...,0], B[...,1]
+    C = (Ar+1j*Ai)/(Br+1j*Bi)
+    C = np.dstack([np.real(C), np.imag(C)]).copy()
+    return C
+
+eps = 1e-5
+
+class MOSSE:
+    def __init__(self, frame, rect):
+        x1, y1, x2, y2 = rect
+        w, h = map(cv.getOptimalDFTSize, [x2-x1, y2-y1])
+        x1, y1 = (x1+x2-w)//2, (y1+y2-h)//2
+        self.pos = x, y = x1+0.5*(w-1), y1+0.5*(h-1)
+        self.size = w, h
+        img = cv.getRectSubPix(frame, (w, h), (x, y))
+
+        self.win = cv.createHanningWindow((w, h), cv.CV_32F)
+        g = np.zeros((h, w), np.float32)
+        g[h//2, w//2] = 1
+        g = cv.GaussianBlur(g, (-1, -1), 2.0)
+        g /= g.max()
+
+        self.G = cv.dft(g, flags=cv.DFT_COMPLEX_OUTPUT)
+        self.H1 = np.zeros_like(self.G)
+        self.H2 = np.zeros_like(self.G)
+        for _i in xrange(128):
+            a = self.preprocess(rnd_warp(img))
+            A = cv.dft(a, flags=cv.DFT_COMPLEX_OUTPUT)
+            self.H1 += cv.mulSpectrums(self.G, A, 0, conjB=True)
+            self.H2 += cv.mulSpectrums(     A, A, 0, conjB=True)
+        self.update_kernel()
+        self.update(frame)
+
+    def update(self, frame, rate = 0.125):
+        (x, y), (w, h) = self.pos, self.size
+        self.last_img = img = cv.getRectSubPix(frame, (w, h), (x, y))
+        img = self.preprocess(img)
+        self.last_resp, (dx, dy), self.psr = self.correlate(img)
+        self.good = self.psr > 8.0
+        if not self.good:
+            return
+
+        self.pos = x+dx, y+dy
+        self.last_img = img = cv.getRectSubPix(frame, (w, h), self.pos)
+        img = self.preprocess(img)
+
+        A = cv.dft(img, flags=cv.DFT_COMPLEX_OUTPUT)
+        H1 = cv.mulSpectrums(self.G, A, 0, conjB=True)
+        H2 = cv.mulSpectrums(     A, A, 0, conjB=True)
+        self.H1 = self.H1 * (1.0-rate) + H1 * rate
+        self.H2 = self.H2 * (1.0-rate) + H2 * rate
+        self.update_kernel()
+
+    @property
+    def state_vis(self):
+        f = cv.idft(self.H, flags=cv.DFT_SCALE | cv.DFT_REAL_OUTPUT )
+        h, w = f.shape
+        f = np.roll(f, -h//2, 0)
+        f = np.roll(f, -w//2, 1)
+        kernel = np.uint8( (f-f.min()) / f.ptp()*255 )
+        resp = self.last_resp
+        resp = np.uint8(np.clip(resp/resp.max(), 0, 1)*255)
+        vis = np.hstack([self.last_img, kernel, resp])
+        return vis
+
+    def draw_state(self, vis):
+        (x, y), (w, h) = self.pos, self.size
+        x1, y1, x2, y2 = int(x-0.5*w), int(y-0.5*h), int(x+0.5*w), int(y+0.5*h)
+        cv.rectangle(vis, (x1, y1), (x2, y2), (0, 0, 255))
+        if self.good:
+            cv.circle(vis, (int(x), int(y)), 2, (0, 0, 255), -1)
+        else:
+            cv.line(vis, (x1, y1), (x2, y2), (0, 0, 255))
+            cv.line(vis, (x2, y1), (x1, y2), (0, 0, 255))
+        draw_str(vis, (x1, y2+16), 'PSR: %.2f' % self.psr)
+
+    def preprocess(self, img):
+        img = np.log(np.float32(img)+1.0)
+        img = (img-img.mean()) / (img.std()+eps)
+        return img*self.win
+
+    def correlate(self, img):
+        C = cv.mulSpectrums(cv.dft(img, flags=cv.DFT_COMPLEX_OUTPUT), self.H, 0, conjB=True)
+        resp = cv.idft(C, flags=cv.DFT_SCALE | cv.DFT_REAL_OUTPUT)
+        h, w = resp.shape
+        _, mval, _, (mx, my) = cv.minMaxLoc(resp)
+        side_resp = resp.copy()
+        cv.rectangle(side_resp, (mx-5, my-5), (mx+5, my+5), 0, -1)
+        smean, sstd = side_resp.mean(), side_resp.std()
+        psr = (mval-smean) / (sstd+eps)
+        return resp, (mx-w//2, my-h//2), psr
+
+    def update_kernel(self):
+        self.H = divSpec(self.H1, self.H2)
+        self.H[...,1] *= -1
+
+class App:
+    def __init__(self, video_src, paused = False):
+        self.cap = video.create_capture(video_src)
+        _, self.frame = self.cap.read()
+        cv.imshow('frame', self.frame)
+        self.rect_sel = RectSelector('frame', self.onrect)
+        self.trackers = []
+        self.paused = paused
+
+    def onrect(self, rect):
+        frame_gray = cv.cvtColor(self.frame, cv.COLOR_BGR2GRAY)
+        tracker = MOSSE(frame_gray, rect)
+        self.trackers.append(tracker)
+
+    def run(self):
+        while True:
+            if not self.paused:
+                ret, self.frame = self.cap.read()
+                if not ret:
+                    break
+                frame_gray = cv.cvtColor(self.frame, cv.COLOR_BGR2GRAY)
+                for tracker in self.trackers:
+                    tracker.update(frame_gray)
+
+            vis = self.frame.copy()
+            for tracker in self.trackers:
+                tracker.draw_state(vis)
+            if len(self.trackers) > 0:
+                cv.imshow('tracker state', self.trackers[-1].state_vis)
+            self.rect_sel.draw(vis)
+
+            cv.imshow('frame', vis)
+            ch = cv.waitKey(10)
+            if ch == 27:
+                break
+            if ch == ord(' '):
+                self.paused = not self.paused
+            if ch == ord('c'):
+                self.trackers = []
+
+
+if __name__ == '__main__':
+    print (__doc__)
+    import sys, getopt
+    opts, args = getopt.getopt(sys.argv[1:], '', ['pause'])
+    opts = dict(opts)
+    try:
+        video_src = args[0]
+    except:
+        video_src = '0'
+
+    App(video_src, paused = '--pause' in opts).run()
diff --git a/C++/opencv-4.7.0/samples/python/mouse_and_match.py b/C++/opencv-4.7.0/samples/python/mouse_and_match.py
new file mode 100644
index 00000000..0bc2fce7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/mouse_and_match.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+'''
+mouse_and_match.py [-i path | --input path: default ../data/]
+
+Demonstrate using a mouse to interact with an image:
+ Read in the images in a directory one by one
+ Allow the user to select parts of an image with a mouse
+ When they let go of the mouse, it correlates (using matchTemplate) that patch with the image.
+
+ SPACE for next image
+ ESC to exit
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+# built-in modules
+import os
+import sys
+import glob
+import argparse
+from math import *
+
+
+class App():
+    drag_start = None
+    sel = (0,0,0,0)
+
+    def onmouse(self, event, x, y, flags, param):
+        if event == cv.EVENT_LBUTTONDOWN:
+            self.drag_start = x, y
+            self.sel = (0,0,0,0)
+        elif event == cv.EVENT_LBUTTONUP:
+            if self.sel[2] > self.sel[0] and self.sel[3] > self.sel[1]:
+                patch = self.gray[self.sel[1]:self.sel[3], self.sel[0]:self.sel[2]]
+                result = cv.matchTemplate(self.gray, patch, cv.TM_CCOEFF_NORMED)
+                result = np.abs(result)**3
+                _val, result = cv.threshold(result, 0.01, 0, cv.THRESH_TOZERO)
+                result8 = cv.normalize(result, None, 0, 255, cv.NORM_MINMAX, cv.CV_8U)
+                cv.imshow("result", result8)
+            self.drag_start = None
+        elif self.drag_start:
+            #print flags
+            if flags & cv.EVENT_FLAG_LBUTTON:
+                minpos = min(self.drag_start[0], x), min(self.drag_start[1], y)
+                maxpos = max(self.drag_start[0], x), max(self.drag_start[1], y)
+                self.sel = (minpos[0], minpos[1], maxpos[0], maxpos[1])
+                img = cv.cvtColor(self.gray, cv.COLOR_GRAY2BGR)
+                cv.rectangle(img, (self.sel[0], self.sel[1]), (self.sel[2], self.sel[3]), (0,255,255), 1)
+                cv.imshow("gray", img)
+            else:
+                print("selection is complete")
+                self.drag_start = None
+
+    def run(self):
+        parser = argparse.ArgumentParser(description='Demonstrate mouse interaction with images')
+        parser.add_argument("-i","--input", default='../data/', help="Input directory.")
+        args = parser.parse_args()
+        path = args.input
+
+        cv.namedWindow("gray",1)
+        cv.setMouseCallback("gray", self.onmouse)
+        '''Loop through all the images in the directory'''
+        for infile in glob.glob( os.path.join(path, '*.*') ):
+            ext = os.path.splitext(infile)[1][1:] #get the filename extension
+            if ext == "png" or ext == "jpg" or ext == "bmp" or ext == "tiff" or ext == "pbm":
+                print(infile)
+
+                img = cv.imread(infile,1)
+                if img is None:
+                    continue
+                self.sel = (0,0,0,0)
+                self.drag_start = None
+                self.gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+                cv.imshow("gray", self.gray)
+                if cv.waitKey() == 27:
+                    break
+
+        print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    App().run()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/mser.py b/C++/opencv-4.7.0/samples/python/mser.py
new file mode 100644
index 00000000..929a3134
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/mser.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+'''
+MSER detector demo
+==================
+
+Usage:
+------
+    mser.py [<video source>]
+
+Keys:
+-----
+    ESC   - exit
+
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import video
+import sys
+
+def main():
+    try:
+        video_src = sys.argv[1]
+    except:
+        video_src = 0
+
+    cam = video.create_capture(video_src)
+    mser = cv.MSER_create()
+
+    while True:
+        ret, img = cam.read()
+        if ret == 0:
+            break
+        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+        vis = img.copy()
+
+        regions, _ = mser.detectRegions(gray)
+        hulls = [cv.convexHull(p.reshape(-1, 1, 2)) for p in regions]
+        cv.polylines(vis, hulls, 1, (0, 255, 0))
+
+        cv.imshow('img', vis)
+        if cv.waitKey(5) == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/opencv_version.py b/C++/opencv-4.7.0/samples/python/opencv_version.py
new file mode 100644
index 00000000..0763f791
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/opencv_version.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+
+'''
+prints OpenCV version
+
+Usage:
+    opencv_version.py [<params>]
+    params:
+        --build: print complete build info
+        --help:  print this help
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+def main():
+    import sys
+
+    try:
+        param = sys.argv[1]
+    except IndexError:
+        param = ""
+
+    if "--build" == param:
+        print(cv.getBuildInformation())
+    elif "--help" == param:
+        print("\t--build\n\t\tprint complete build info")
+        print("\t--help\n\t\tprint this help")
+    else:
+        print("Welcome to OpenCV")
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/opt_flow.py b/C++/opencv-4.7.0/samples/python/opt_flow.py
new file mode 100644
index 00000000..76a0ac2c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/opt_flow.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+
+'''
+example to show optical flow
+
+USAGE: opt_flow.py [<video_source>]
+
+Keys:
+ 1 - toggle HSV flow visualization
+ 2 - toggle glitch
+
+Keys:
+    ESC    - exit
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import video
+
+
+def draw_flow(img, flow, step=16):
+    h, w = img.shape[:2]
+    y, x = np.mgrid[step/2:h:step, step/2:w:step].reshape(2,-1).astype(int)
+    fx, fy = flow[y,x].T
+    lines = np.vstack([x, y, x+fx, y+fy]).T.reshape(-1, 2, 2)
+    lines = np.int32(lines + 0.5)
+    vis = cv.cvtColor(img, cv.COLOR_GRAY2BGR)
+    cv.polylines(vis, lines, 0, (0, 255, 0))
+    for (x1, y1), (_x2, _y2) in lines:
+        cv.circle(vis, (x1, y1), 1, (0, 255, 0), -1)
+    return vis
+
+
+def draw_hsv(flow):
+    h, w = flow.shape[:2]
+    fx, fy = flow[:,:,0], flow[:,:,1]
+    ang = np.arctan2(fy, fx) + np.pi
+    v = np.sqrt(fx*fx+fy*fy)
+    hsv = np.zeros((h, w, 3), np.uint8)
+    hsv[...,0] = ang*(180/np.pi/2)
+    hsv[...,1] = 255
+    hsv[...,2] = np.minimum(v*4, 255)
+    bgr = cv.cvtColor(hsv, cv.COLOR_HSV2BGR)
+    return bgr
+
+
+def warp_flow(img, flow):
+    h, w = flow.shape[:2]
+    flow = -flow
+    flow[:,:,0] += np.arange(w)
+    flow[:,:,1] += np.arange(h)[:,np.newaxis]
+    res = cv.remap(img, flow, None, cv.INTER_LINEAR)
+    return res
+
+def main():
+    import sys
+    try:
+        fn = sys.argv[1]
+    except IndexError:
+        fn = 0
+
+    cam = video.create_capture(fn)
+    _ret, prev = cam.read()
+    prevgray = cv.cvtColor(prev, cv.COLOR_BGR2GRAY)
+    show_hsv = False
+    show_glitch = False
+    cur_glitch = prev.copy()
+
+    while True:
+        _ret, img = cam.read()
+        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+        flow = cv.calcOpticalFlowFarneback(prevgray, gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)
+        prevgray = gray
+
+        cv.imshow('flow', draw_flow(gray, flow))
+        if show_hsv:
+            cv.imshow('flow HSV', draw_hsv(flow))
+        if show_glitch:
+            cur_glitch = warp_flow(cur_glitch, flow)
+            cv.imshow('glitch', cur_glitch)
+
+        ch = cv.waitKey(5)
+        if ch == 27:
+            break
+        if ch == ord('1'):
+            show_hsv = not show_hsv
+            print('HSV flow visualization is', ['off', 'on'][show_hsv])
+        if ch == ord('2'):
+            show_glitch = not show_glitch
+            if show_glitch:
+                cur_glitch = img.copy()
+            print('glitch is', ['off', 'on'][show_glitch])
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/peopledetect.py b/C++/opencv-4.7.0/samples/python/peopledetect.py
new file mode 100644
index 00000000..bdd49cab
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/peopledetect.py
@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+
+'''
+example to detect upright people in images using HOG features
+
+Usage:
+    peopledetect.py <image_names>
+
+Press any key to continue, ESC to stop.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+
+def inside(r, q):
+    rx, ry, rw, rh = r
+    qx, qy, qw, qh = q
+    return rx > qx and ry > qy and rx + rw < qx + qw and ry + rh < qy + qh
+
+
+def draw_detections(img, rects, thickness = 1):
+    for x, y, w, h in rects:
+        # the HOG detector returns slightly larger rectangles than the real objects.
+        # so we slightly shrink the rectangles to get a nicer output.
+        pad_w, pad_h = int(0.15*w), int(0.05*h)
+        cv.rectangle(img, (x+pad_w, y+pad_h), (x+w-pad_w, y+h-pad_h), (0, 255, 0), thickness)
+
+
+def main():
+    import sys
+    from glob import glob
+    import itertools as it
+
+    hog = cv.HOGDescriptor()
+    hog.setSVMDetector( cv.HOGDescriptor_getDefaultPeopleDetector() )
+
+    default = [cv.samples.findFile('basketball2.png')] if len(sys.argv[1:]) == 0 else []
+
+    for fn in it.chain(*map(glob, default + sys.argv[1:])):
+        print(fn, ' - ',)
+        try:
+            img = cv.imread(fn)
+            if img is None:
+                print('Failed to load image file:', fn)
+                continue
+        except:
+            print('loading error')
+            continue
+
+        found, _w = hog.detectMultiScale(img, winStride=(8,8), padding=(32,32), scale=1.05)
+        found_filtered = []
+        for ri, r in enumerate(found):
+            for qi, q in enumerate(found):
+                if ri != qi and inside(r, q):
+                    break
+            else:
+                found_filtered.append(r)
+        draw_detections(img, found)
+        draw_detections(img, found_filtered, 3)
+        print('%d (%d) found' % (len(found_filtered), len(found)))
+        cv.imshow('img', img)
+        ch = cv.waitKey()
+        if ch == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/plane_ar.py b/C++/opencv-4.7.0/samples/python/plane_ar.py
new file mode 100644
index 00000000..934550c0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/plane_ar.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python
+
+'''
+Planar augmented reality
+==================
+
+This sample shows an example of augmented reality overlay over a planar object
+tracked by PlaneTracker from plane_tracker.py. solvePnP function is used to
+estimate the tracked object location in 3d space.
+
+video: http://www.youtube.com/watch?v=pzVbhxx6aog
+
+Usage
+-----
+plane_ar.py [<video source>]
+
+Keys:
+   SPACE  -  pause video
+   c      -  clear targets
+
+Select a textured planar object to track by drawing a box with a mouse.
+Use 'focal' slider to adjust to camera focal length for proper video augmentation.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+import video
+import common
+from plane_tracker import PlaneTracker
+from video import presets
+
+# Simple model of a house - cube with a triangular prism "roof"
+ar_verts = np.float32([[0, 0, 0], [0, 1, 0], [1, 1, 0], [1, 0, 0],
+                       [0, 0, 1], [0, 1, 1], [1, 1, 1], [1, 0, 1],
+                       [0, 0.5, 2], [1, 0.5, 2]])
+ar_edges = [(0, 1), (1, 2), (2, 3), (3, 0),
+            (4, 5), (5, 6), (6, 7), (7, 4),
+            (0, 4), (1, 5), (2, 6), (3, 7),
+            (4, 8), (5, 8), (6, 9), (7, 9), (8, 9)]
+
+class App:
+    def __init__(self, src):
+        self.cap = video.create_capture(src, presets['book'])
+        self.frame = None
+        self.paused = False
+        self.tracker = PlaneTracker()
+
+        cv.namedWindow('plane')
+        cv.createTrackbar('focal', 'plane', 25, 50, common.nothing)
+        self.rect_sel = common.RectSelector('plane', self.on_rect)
+
+    def on_rect(self, rect):
+        self.tracker.add_target(self.frame, rect)
+
+    def run(self):
+        while True:
+            playing = not self.paused and not self.rect_sel.dragging
+            if playing or self.frame is None:
+                ret, frame = self.cap.read()
+                if not ret:
+                    break
+                self.frame = frame.copy()
+
+            vis = self.frame.copy()
+            if playing:
+                tracked = self.tracker.track(self.frame)
+                for tr in tracked:
+                    cv.polylines(vis, [np.int32(tr.quad)], True, (255, 255, 255), 2)
+                    for (x, y) in np.int32(tr.p1):
+                        cv.circle(vis, (x, y), 2, (255, 255, 255))
+                    self.draw_overlay(vis, tr)
+
+            self.rect_sel.draw(vis)
+            cv.imshow('plane', vis)
+            ch = cv.waitKey(1)
+            if ch == ord(' '):
+                self.paused = not self.paused
+            if ch == ord('c'):
+                self.tracker.clear()
+            if ch == 27:
+                break
+
+    def draw_overlay(self, vis, tracked):
+        x0, y0, x1, y1 = tracked.target.rect
+        quad_3d = np.float32([[x0, y0, 0], [x1, y0, 0], [x1, y1, 0], [x0, y1, 0]])
+        fx = 0.5 + cv.getTrackbarPos('focal', 'plane') / 50.0
+        h, w = vis.shape[:2]
+        K = np.float64([[fx*w, 0, 0.5*(w-1)],
+                        [0, fx*w, 0.5*(h-1)],
+                        [0.0,0.0,      1.0]])
+        dist_coef = np.zeros(4)
+        _ret, rvec, tvec = cv.solvePnP(quad_3d, tracked.quad, K, dist_coef)
+        verts = ar_verts * [(x1-x0), (y1-y0), -(x1-x0)*0.3] + (x0, y0, 0)
+        verts = cv.projectPoints(verts, rvec, tvec, K, dist_coef)[0].reshape(-1, 2)
+        for i, j in ar_edges:
+            (x0, y0), (x1, y1) = verts[i], verts[j]
+            cv.line(vis, (int(x0), int(y0)), (int(x1), int(y1)), (255, 255, 0), 2)
+
+
+if __name__ == '__main__':
+    print(__doc__)
+
+    import sys
+    try:
+        video_src = sys.argv[1]
+    except:
+        video_src = 0
+    App(video_src).run()
diff --git a/C++/opencv-4.7.0/samples/python/plane_tracker.py b/C++/opencv-4.7.0/samples/python/plane_tracker.py
new file mode 100644
index 00000000..ed84fb0d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/plane_tracker.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python
+
+'''
+Multitarget planar tracking
+==================
+
+Example of using features2d framework for interactive video homography matching.
+ORB features and FLANN matcher are used. This sample provides PlaneTracker class
+and an example of its usage.
+
+video: http://www.youtube.com/watch?v=pzVbhxx6aog
+
+Usage
+-----
+plane_tracker.py [<video source>]
+
+Keys:
+   SPACE  -  pause video
+   c      -  clear targets
+
+Select a textured planar object to track by drawing a box with a mouse.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+
+# built-in modules
+from collections import namedtuple
+
+# local modules
+import video
+import common
+from video import presets
+
+
+FLANN_INDEX_KDTREE = 1
+FLANN_INDEX_LSH    = 6
+flann_params= dict(algorithm = FLANN_INDEX_LSH,
+                   table_number = 6, # 12
+                   key_size = 12,     # 20
+                   multi_probe_level = 1) #2
+
+MIN_MATCH_COUNT = 10
+
+'''
+  image     - image to track
+  rect      - tracked rectangle (x1, y1, x2, y2)
+  keypoints - keypoints detected inside rect
+  descrs    - their descriptors
+  data      - some user-provided data
+'''
+PlanarTarget = namedtuple('PlaneTarget', 'image, rect, keypoints, descrs, data')
+
+'''
+  target - reference to PlanarTarget
+  p0     - matched points coords in target image
+  p1     - matched points coords in input frame
+  H      - homography matrix from p0 to p1
+  quad   - target boundary quad in input frame
+'''
+TrackedTarget = namedtuple('TrackedTarget', 'target, p0, p1, H, quad')
+
+class PlaneTracker:
+    def __init__(self):
+        self.detector = cv.ORB_create( nfeatures = 1000 )
+        self.matcher = cv.FlannBasedMatcher(flann_params, {})  # bug : need to pass empty dict (#1329)
+        self.targets = []
+        self.frame_points = []
+
+    def add_target(self, image, rect, data=None):
+        '''Add a new tracking target.'''
+        x0, y0, x1, y1 = rect
+        raw_points, raw_descrs = self.detect_features(image)
+        points, descs = [], []
+        for kp, desc in zip(raw_points, raw_descrs):
+            x, y = kp.pt
+            if x0 <= x <= x1 and y0 <= y <= y1:
+                points.append(kp)
+                descs.append(desc)
+        descs = np.uint8(descs)
+        self.matcher.add([descs])
+        target = PlanarTarget(image = image, rect=rect, keypoints = points, descrs=descs, data=data)
+        self.targets.append(target)
+
+    def clear(self):
+        '''Remove all targets'''
+        self.targets = []
+        self.matcher.clear()
+
+    def track(self, frame):
+        '''Returns a list of detected TrackedTarget objects'''
+        self.frame_points, frame_descrs = self.detect_features(frame)
+        if len(self.frame_points) < MIN_MATCH_COUNT:
+            return []
+        matches = self.matcher.knnMatch(frame_descrs, k = 2)
+        matches = [m[0] for m in matches if len(m) == 2 and m[0].distance < m[1].distance * 0.75]
+        if len(matches) < MIN_MATCH_COUNT:
+            return []
+        matches_by_id = [[] for _ in xrange(len(self.targets))]
+        for m in matches:
+            matches_by_id[m.imgIdx].append(m)
+        tracked = []
+        for imgIdx, matches in enumerate(matches_by_id):
+            if len(matches) < MIN_MATCH_COUNT:
+                continue
+            target = self.targets[imgIdx]
+            p0 = [target.keypoints[m.trainIdx].pt for m in matches]
+            p1 = [self.frame_points[m.queryIdx].pt for m in matches]
+            p0, p1 = np.float32((p0, p1))
+            H, status = cv.findHomography(p0, p1, cv.RANSAC, 3.0)
+            status = status.ravel() != 0
+            if status.sum() < MIN_MATCH_COUNT:
+                continue
+            p0, p1 = p0[status], p1[status]
+
+            x0, y0, x1, y1 = target.rect
+            quad = np.float32([[x0, y0], [x1, y0], [x1, y1], [x0, y1]])
+            quad = cv.perspectiveTransform(quad.reshape(1, -1, 2), H).reshape(-1, 2)
+
+            track = TrackedTarget(target=target, p0=p0, p1=p1, H=H, quad=quad)
+            tracked.append(track)
+        tracked.sort(key = lambda t: len(t.p0), reverse=True)
+        return tracked
+
+    def detect_features(self, frame):
+        '''detect_features(self, frame) -> keypoints, descrs'''
+        keypoints, descrs = self.detector.detectAndCompute(frame, None)
+        if descrs is None:  # detectAndCompute returns descs=None if not keypoints found
+            descrs = []
+        return keypoints, descrs
+
+
+class App:
+    def __init__(self, src):
+        self.cap = video.create_capture(src, presets['book'])
+        self.frame = None
+        self.paused = False
+        self.tracker = PlaneTracker()
+
+        cv.namedWindow('plane')
+        self.rect_sel = common.RectSelector('plane', self.on_rect)
+
+    def on_rect(self, rect):
+        self.tracker.add_target(self.frame, rect)
+
+    def run(self):
+        while True:
+            playing = not self.paused and not self.rect_sel.dragging
+            if playing or self.frame is None:
+                ret, frame = self.cap.read()
+                if not ret:
+                    break
+                self.frame = frame.copy()
+
+            vis = self.frame.copy()
+            if playing:
+                tracked = self.tracker.track(self.frame)
+                for tr in tracked:
+                    cv.polylines(vis, [np.int32(tr.quad)], True, (255, 255, 255), 2)
+                    for (x, y) in np.int32(tr.p1):
+                        cv.circle(vis, (x, y), 2, (255, 255, 255))
+
+            self.rect_sel.draw(vis)
+            cv.imshow('plane', vis)
+            ch = cv.waitKey(1)
+            if ch == ord(' '):
+                self.paused = not self.paused
+            if ch == ord('c'):
+                self.tracker.clear()
+            if ch == 27:
+                break
+
+if __name__ == '__main__':
+    print(__doc__)
+
+    import sys
+    try:
+        video_src = sys.argv[1]
+    except:
+        video_src = 0
+    App(video_src).run()
diff --git a/C++/opencv-4.7.0/samples/python/qrcode.py b/C++/opencv-4.7.0/samples/python/qrcode.py
new file mode 100644
index 00000000..21b1a590
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/qrcode.py
@@ -0,0 +1,250 @@
+#!/usr/bin/env python
+
+'''
+This program detects the QR-codes using OpenCV Library.
+
+Usage:
+   qrcode.py
+'''
+
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import argparse
+import sys
+
+PY3 = sys.version_info[0] == 3
+if PY3:
+    xrange = range
+
+
+class QrSample:
+    def __init__(self, args):
+        self.fname = ''
+        self.fext = ''
+        self.fsaveid = 0
+        self.input = args.input
+        self.detect = args.detect
+        self.out = args.out
+        self.multi = args.multi
+        self.saveDetections = args.save_detections
+        self.saveAll = args.save_all
+
+    def getQRModeString(self):
+        msg1 = "multi " if self.multi else ""
+        msg2 = "detector" if self.detect else "decoder"
+        msg = "QR {:s}{:s}".format(msg1, msg2)
+        return msg
+
+    def drawFPS(self, result, fps):
+        message = '{:.2f} FPS({:s})'.format(fps, self.getQRModeString())
+        cv.putText(result, message, (20, 20), 1,
+                   cv.FONT_HERSHEY_DUPLEX, (0, 0, 255))
+
+    def drawQRCodeContours(self, image, cnt):
+        if cnt.size != 0:
+            rows, cols, _ = image.shape
+            show_radius = 2.813 * ((rows / cols) if rows > cols else (cols / rows))
+            contour_radius = show_radius * 0.4
+            cv.drawContours(image, [cnt], 0, (0, 255, 0), int(round(contour_radius)))
+            tpl = cnt.reshape((-1, 2))
+            for x in tuple(tpl.tolist()):
+                color = (255, 0, 0)
+                cv.circle(image, tuple(x), int(round(contour_radius)), color, -1)
+
+    def drawQRCodeResults(self, result, points, decode_info, fps):
+        n = len(points)
+        if isinstance(decode_info, str):
+            decode_info = [decode_info]
+        if n > 0:
+            for i in range(n):
+                cnt = np.array(points[i]).reshape((-1, 1, 2)).astype(np.int32)
+                self.drawQRCodeContours(result, cnt)
+                msg = 'QR[{:d}]@{} : '.format(i, *(cnt.reshape(1, -1).tolist()))
+                print(msg, end="")
+                if len(decode_info) > i:
+                    if decode_info[i]:
+                        print("'", decode_info[i], "'")
+                    else:
+                        print("Can't decode QR code")
+                else:
+                    print("Decode information is not available (disabled)")
+        else:
+            print("QRCode not detected!")
+        self.drawFPS(result, fps)
+
+    def runQR(self, qrCode, inputimg):
+        if not self.multi:
+            if not self.detect:
+                decode_info, points, _ = qrCode.detectAndDecode(inputimg)
+                dec_info = decode_info
+            else:
+                _, points = qrCode.detect(inputimg)
+                dec_info = []
+        else:
+            if not self.detect:
+                _, decode_info, points, _ = qrCode.detectAndDecodeMulti(
+                    inputimg)
+                dec_info = decode_info
+            else:
+                _, points = qrCode.detectMulti(inputimg)
+                dec_info = []
+        if points is None:
+            points = []
+        return points, dec_info
+
+    def DetectQRFrmImage(self, inputfile):
+        inputimg = cv.imread(inputfile, cv.IMREAD_COLOR)
+        if inputimg is None:
+            print('ERROR: Can not read image: {}'.format(inputfile))
+            return
+        print('Run {:s} on image [{:d}x{:d}]'.format(
+            self.getQRModeString(), inputimg.shape[1], inputimg.shape[0]))
+        qrCode = cv.QRCodeDetector()
+        count = 10
+        timer = cv.TickMeter()
+        for _ in range(count):
+            timer.start()
+            points, decode_info = self.runQR(qrCode, inputimg)
+            timer.stop()
+        fps = count / timer.getTimeSec()
+        print('FPS: {}'.format(fps))
+        result = inputimg
+        self.drawQRCodeResults(result, points, decode_info, fps)
+        cv.imshow("QR", result)
+        cv.waitKey(1)
+        if self.out != '':
+            outfile = self.fname + self.fext
+            print("Saving Result: {}".format(outfile))
+            cv.imwrite(outfile, result)
+
+        print("Press any key to exit ...")
+        cv.waitKey(0)
+        print("Exit")
+
+    def processQRCodeDetection(self, qrcode, frame):
+        if len(frame.shape) == 2:
+            result = cv.cvtColor(frame, cv.COLOR_GRAY2BGR)
+        else:
+            result = frame
+        print('Run {:s} on video frame [{:d}x{:d}]'.format(
+            self.getQRModeString(), frame.shape[1], frame.shape[0]))
+        timer = cv.TickMeter()
+        timer.start()
+        points, decode_info = self.runQR(qrcode, frame)
+        timer.stop()
+
+        fps = 1 / timer.getTimeSec()
+        self.drawQRCodeResults(result, points, decode_info, fps)
+        return fps, result, points
+
+    def DetectQRFrmCamera(self):
+        cap = cv.VideoCapture(0)
+        if not cap.isOpened():
+            print("Cannot open the camera")
+            return
+        print("Press 'm' to switch between detectAndDecode and detectAndDecodeMulti")
+        print("Press 'd' to switch between decoder and detector")
+        print("Press ' ' (space) to save result into images")
+        print("Press 'ESC' to exit")
+
+        qrcode = cv.QRCodeDetector()
+
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                print("End of video stream")
+                break
+            forcesave = self.saveAll
+            result = frame
+            try:
+                fps, result, corners = self.processQRCodeDetection(qrcode, frame)
+                print('FPS: {:.2f}'.format(fps))
+                forcesave |= self.saveDetections and (len(corners) != 0)
+            except cv.error as e:
+                print("Error exception: ", e)
+                forcesave = True
+            cv.imshow("QR code", result)
+            code = cv.waitKey(1)
+            if code < 0 and (not forcesave):
+                continue
+            if code == ord(' ') or forcesave:
+                fsuffix = '-{:05d}'.format(self.fsaveid)
+                self.fsaveid += 1
+                fname_in = self.fname + fsuffix + "_input.png"
+                print("Saving QR code detection result: '{}' ...".format(fname_in))
+                cv.imwrite(fname_in, frame)
+                print("Saved")
+            if code == ord('m'):
+                self.multi = not self.multi
+                msg = 'Switching QR code mode ==> {:s}'.format(
+                    "detectAndDecodeMulti" if self.multi else "detectAndDecode")
+                print(msg)
+            if code == ord('d'):
+                self.detect = not self.detect
+                msg = 'Switching QR code mode ==> {:s}'.format(
+                    "detect" if self.detect else "decode")
+                print(msg)
+            if code == 27:
+                print("'ESC' is pressed. Exiting...")
+                break
+        print("Exit.")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='This program detects the QR-codes input images using OpenCV Library.')
+    parser.add_argument(
+        '-i',
+        '--input',
+        help="input image path (for example, 'opencv_extra/testdata/cv/qrcode/multiple/*_qrcodes.png)",
+        default="",
+        metavar="")
+    parser.add_argument(
+        '-d',
+        '--detect',
+        help="detect QR code only (skip decoding) (default: False)",
+        action='store_true')
+    parser.add_argument(
+        '-m',
+        '--multi',
+        help="enable multiple qr-codes detection",
+        action='store_true')
+    parser.add_argument(
+        '-o',
+        '--out',
+        help="path to result file (default: qr_code.png)",
+        default="qr_code.png",
+        metavar="")
+    parser.add_argument(
+        '--save_detections',
+        help="save all QR detections (video mode only)",
+        action='store_true')
+    parser.add_argument(
+        '--save_all',
+        help="save all processed frames (video mode only)",
+        action='store_true')
+    args = parser.parse_args()
+    qrinst = QrSample(args)
+    if args.out != '':
+        index = args.out.rfind('.')
+        if index != -1:
+            qrinst.fname = args.out[:index]
+            qrinst.fext = args.out[index:]
+        else:
+            qrinst.fname = args.out
+            qrinst.fext = ".png"
+    if args.input != '':
+        qrinst.DetectQRFrmImage(args.input)
+    else:
+        qrinst.DetectQRFrmCamera()
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/squares.py b/C++/opencv-4.7.0/samples/python/squares.py
new file mode 100644
index 00000000..99a69e9d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/squares.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+'''
+Simple "Square Detector" program.
+
+Loads several images sequentially and tries to find squares in each image.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+
+
+def angle_cos(p0, p1, p2):
+    d1, d2 = (p0-p1).astype('float'), (p2-p1).astype('float')
+    return abs( np.dot(d1, d2) / np.sqrt( np.dot(d1, d1)*np.dot(d2, d2) ) )
+
+def find_squares(img):
+    img = cv.GaussianBlur(img, (5, 5), 0)
+    squares = []
+    for gray in cv.split(img):
+        for thrs in xrange(0, 255, 26):
+            if thrs == 0:
+                bin = cv.Canny(gray, 0, 50, apertureSize=5)
+                bin = cv.dilate(bin, None)
+            else:
+                _retval, bin = cv.threshold(gray, thrs, 255, cv.THRESH_BINARY)
+            contours, _hierarchy = cv.findContours(bin, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)
+            for cnt in contours:
+                cnt_len = cv.arcLength(cnt, True)
+                cnt = cv.approxPolyDP(cnt, 0.02*cnt_len, True)
+                if len(cnt) == 4 and cv.contourArea(cnt) > 1000 and cv.isContourConvex(cnt):
+                    cnt = cnt.reshape(-1, 2)
+                    max_cos = np.max([angle_cos( cnt[i], cnt[(i+1) % 4], cnt[(i+2) % 4] ) for i in xrange(4)])
+                    if max_cos < 0.1:
+                        squares.append(cnt)
+    return squares
+
+def main():
+    from glob import glob
+    for fn in glob('../data/pic*.png'):
+        img = cv.imread(fn)
+        squares = find_squares(img)
+        cv.drawContours( img, squares, -1, (0, 255, 0), 3 )
+        cv.imshow('squares', img)
+        ch = cv.waitKey()
+        if ch == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/stereo_match.py b/C++/opencv-4.7.0/samples/python/stereo_match.py
new file mode 100644
index 00000000..4d5875b8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/stereo_match.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+
+'''
+Simple example of stereo image matching and point cloud generation.
+
+Resulting .ply file cam be easily viewed using MeshLab ( http://meshlab.sourceforge.net/ )
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+ply_header = '''ply
+format ascii 1.0
+element vertex %(vert_num)d
+property float x
+property float y
+property float z
+property uchar red
+property uchar green
+property uchar blue
+end_header
+'''
+
+def write_ply(fn, verts, colors):
+    verts = verts.reshape(-1, 3)
+    colors = colors.reshape(-1, 3)
+    verts = np.hstack([verts, colors])
+    with open(fn, 'wb') as f:
+        f.write((ply_header % dict(vert_num=len(verts))).encode('utf-8'))
+        np.savetxt(f, verts, fmt='%f %f %f %d %d %d ')
+
+
+def main():
+    print('loading images...')
+    imgL = cv.pyrDown(cv.imread(cv.samples.findFile('aloeL.jpg')))  # downscale images for faster processing
+    imgR = cv.pyrDown(cv.imread(cv.samples.findFile('aloeR.jpg')))
+
+    # disparity range is tuned for 'aloe' image pair
+    window_size = 3
+    min_disp = 16
+    num_disp = 112-min_disp
+    stereo = cv.StereoSGBM_create(minDisparity = min_disp,
+        numDisparities = num_disp,
+        blockSize = 16,
+        P1 = 8*3*window_size**2,
+        P2 = 32*3*window_size**2,
+        disp12MaxDiff = 1,
+        uniquenessRatio = 10,
+        speckleWindowSize = 100,
+        speckleRange = 32
+    )
+
+    print('computing disparity...')
+    disp = stereo.compute(imgL, imgR).astype(np.float32) / 16.0
+
+    print('generating 3d point cloud...',)
+    h, w = imgL.shape[:2]
+    f = 0.8*w                          # guess for focal length
+    Q = np.float32([[1, 0, 0, -0.5*w],
+                    [0,-1, 0,  0.5*h], # turn points 180 deg around x-axis,
+                    [0, 0, 0,     -f], # so that y-axis looks up
+                    [0, 0, 1,      0]])
+    points = cv.reprojectImageTo3D(disp, Q)
+    colors = cv.cvtColor(imgL, cv.COLOR_BGR2RGB)
+    mask = disp > disp.min()
+    out_points = points[mask]
+    out_colors = colors[mask]
+    out_fn = 'out.ply'
+    write_ply(out_fn, out_points, out_colors)
+    print('%s saved' % out_fn)
+
+    cv.imshow('left', imgL)
+    cv.imshow('disparity', (disp-min_disp)/num_disp)
+    cv.waitKey()
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/stitching.py b/C++/opencv-4.7.0/samples/python/stitching.py
new file mode 100644
index 00000000..18a160ec
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/stitching.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+
+'''
+Stitching sample
+================
+
+Show how to use Stitcher API from python in a simple way to stitch panoramas
+or scans.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import argparse
+import sys
+
+modes = (cv.Stitcher_PANORAMA, cv.Stitcher_SCANS)
+
+parser = argparse.ArgumentParser(prog='stitching.py', description='Stitching sample.')
+parser.add_argument('--mode',
+    type = int, choices = modes, default = cv.Stitcher_PANORAMA,
+    help = 'Determines configuration of stitcher. The default is `PANORAMA` (%d), '
+         'mode suitable for creating photo panoramas. Option `SCANS` (%d) is suitable '
+         'for stitching materials under affine transformation, such as scans.' % modes)
+parser.add_argument('--output', default = 'result.jpg',
+    help = 'Resulting image. The default is `result.jpg`.')
+parser.add_argument('img', nargs='+', help = 'input images')
+
+__doc__ += '\n' + parser.format_help()
+
+def main():
+    args = parser.parse_args()
+
+    # read input images
+    imgs = []
+    for img_name in args.img:
+        img = cv.imread(cv.samples.findFile(img_name))
+        if img is None:
+            print("can't read image " + img_name)
+            sys.exit(-1)
+        imgs.append(img)
+
+    stitcher = cv.Stitcher.create(args.mode)
+    status, pano = stitcher.stitch(imgs)
+
+    if status != cv.Stitcher_OK:
+        print("Can't stitch images, error code = %d" % status)
+        sys.exit(-1)
+
+    cv.imwrite(args.output, pano)
+    print("stitching completed successfully. %s saved!" % args.output)
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/stitching_detailed.py b/C++/opencv-4.7.0/samples/python/stitching_detailed.py
new file mode 100644
index 00000000..f8f580dd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/stitching_detailed.py
@@ -0,0 +1,520 @@
+"""
+Stitching sample (advanced)
+===========================
+
+Show how to use Stitcher API from python.
+"""
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import argparse
+from collections import OrderedDict
+
+import cv2 as cv
+import numpy as np
+
+EXPOS_COMP_CHOICES = OrderedDict()
+EXPOS_COMP_CHOICES['gain_blocks'] = cv.detail.ExposureCompensator_GAIN_BLOCKS
+EXPOS_COMP_CHOICES['gain'] = cv.detail.ExposureCompensator_GAIN
+EXPOS_COMP_CHOICES['channel'] = cv.detail.ExposureCompensator_CHANNELS
+EXPOS_COMP_CHOICES['channel_blocks'] = cv.detail.ExposureCompensator_CHANNELS_BLOCKS
+EXPOS_COMP_CHOICES['no'] = cv.detail.ExposureCompensator_NO
+
+BA_COST_CHOICES = OrderedDict()
+BA_COST_CHOICES['ray'] = cv.detail_BundleAdjusterRay
+BA_COST_CHOICES['reproj'] = cv.detail_BundleAdjusterReproj
+BA_COST_CHOICES['affine'] = cv.detail_BundleAdjusterAffinePartial
+BA_COST_CHOICES['no'] = cv.detail_NoBundleAdjuster
+
+FEATURES_FIND_CHOICES = OrderedDict()
+try:
+    cv.xfeatures2d_SURF.create() # check if the function can be called
+    FEATURES_FIND_CHOICES['surf'] = cv.xfeatures2d_SURF.create
+except (AttributeError, cv.error) as e:
+    print("SURF not available")
+# if SURF not available, ORB is default
+FEATURES_FIND_CHOICES['orb'] = cv.ORB.create
+try:
+    FEATURES_FIND_CHOICES['sift'] = cv.SIFT_create
+except AttributeError:
+    print("SIFT not available")
+try:
+    FEATURES_FIND_CHOICES['brisk'] = cv.BRISK_create
+except AttributeError:
+    print("BRISK not available")
+try:
+    FEATURES_FIND_CHOICES['akaze'] = cv.AKAZE_create
+except AttributeError:
+    print("AKAZE not available")
+
+SEAM_FIND_CHOICES = OrderedDict()
+SEAM_FIND_CHOICES['dp_color'] = cv.detail_DpSeamFinder('COLOR')
+SEAM_FIND_CHOICES['dp_colorgrad'] = cv.detail_DpSeamFinder('COLOR_GRAD')
+SEAM_FIND_CHOICES['voronoi'] = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_VORONOI_SEAM)
+SEAM_FIND_CHOICES['no'] = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO)
+
+ESTIMATOR_CHOICES = OrderedDict()
+ESTIMATOR_CHOICES['homography'] = cv.detail_HomographyBasedEstimator
+ESTIMATOR_CHOICES['affine'] = cv.detail_AffineBasedEstimator
+
+WARP_CHOICES = (
+    'spherical',
+    'plane',
+    'affine',
+    'cylindrical',
+    'fisheye',
+    'stereographic',
+    'compressedPlaneA2B1',
+    'compressedPlaneA1.5B1',
+    'compressedPlanePortraitA2B1',
+    'compressedPlanePortraitA1.5B1',
+    'paniniA2B1',
+    'paniniA1.5B1',
+    'paniniPortraitA2B1',
+    'paniniPortraitA1.5B1',
+    'mercator',
+    'transverseMercator',
+)
+
+WAVE_CORRECT_CHOICES = OrderedDict()
+WAVE_CORRECT_CHOICES['horiz'] = cv.detail.WAVE_CORRECT_HORIZ
+WAVE_CORRECT_CHOICES['no'] = None
+WAVE_CORRECT_CHOICES['vert'] = cv.detail.WAVE_CORRECT_VERT
+
+BLEND_CHOICES = ('multiband', 'feather', 'no',)
+
+parser = argparse.ArgumentParser(
+    prog="stitching_detailed.py", description="Rotation model images stitcher"
+)
+parser.add_argument(
+    'img_names', nargs='+',
+    help="Files to stitch", type=str
+)
+parser.add_argument(
+    '--try_cuda',
+    action='store',
+    default=False,
+    help="Try to use CUDA. The default value is no. All default values are for CPU mode.",
+    type=bool, dest='try_cuda'
+)
+parser.add_argument(
+    '--work_megapix', action='store', default=0.6,
+    help="Resolution for image registration step. The default is 0.6 Mpx",
+    type=float, dest='work_megapix'
+)
+parser.add_argument(
+    '--features', action='store', default=list(FEATURES_FIND_CHOICES.keys())[0],
+    help="Type of features used for images matching. The default is '%s'." % list(FEATURES_FIND_CHOICES.keys())[0],
+    choices=FEATURES_FIND_CHOICES.keys(),
+    type=str, dest='features'
+)
+parser.add_argument(
+    '--matcher', action='store', default='homography',
+    help="Matcher used for pairwise image matching. The default is 'homography'.",
+    choices=('homography', 'affine'),
+    type=str, dest='matcher'
+)
+parser.add_argument(
+    '--estimator', action='store', default=list(ESTIMATOR_CHOICES.keys())[0],
+    help="Type of estimator used for transformation estimation. The default is '%s'." % list(ESTIMATOR_CHOICES.keys())[0],
+    choices=ESTIMATOR_CHOICES.keys(),
+    type=str, dest='estimator'
+)
+parser.add_argument(
+    '--match_conf', action='store',
+    help="Confidence for feature matching step. The default is 0.3 for ORB and 0.65 for other feature types.",
+    type=float, dest='match_conf'
+)
+parser.add_argument(
+    '--conf_thresh', action='store', default=1.0,
+    help="Threshold for two images are from the same panorama confidence.The default is 1.0.",
+    type=float, dest='conf_thresh'
+)
+parser.add_argument(
+    '--ba', action='store', default=list(BA_COST_CHOICES.keys())[0],
+    help="Bundle adjustment cost function. The default is '%s'." % list(BA_COST_CHOICES.keys())[0],
+    choices=BA_COST_CHOICES.keys(),
+    type=str, dest='ba'
+)
+parser.add_argument(
+    '--ba_refine_mask', action='store', default='xxxxx',
+    help="Set refinement mask for bundle adjustment. It looks like 'x_xxx', "
+         "where 'x' means refine respective parameter and '_' means don't refine, "
+         "and has the following format:<fx><skew><ppx><aspect><ppy>. "
+         "The default mask is 'xxxxx'. "
+         "If bundle adjustment doesn't support estimation of selected parameter then "
+         "the respective flag is ignored.",
+    type=str, dest='ba_refine_mask'
+)
+parser.add_argument(
+    '--wave_correct', action='store', default=list(WAVE_CORRECT_CHOICES.keys())[0],
+    help="Perform wave effect correction. The default is '%s'" % list(WAVE_CORRECT_CHOICES.keys())[0],
+    choices=WAVE_CORRECT_CHOICES.keys(),
+    type=str, dest='wave_correct'
+)
+parser.add_argument(
+    '--save_graph', action='store', default=None,
+    help="Save matches graph represented in DOT language to <file_name> file.",
+    type=str, dest='save_graph'
+)
+parser.add_argument(
+    '--warp', action='store', default=WARP_CHOICES[0],
+    help="Warp surface type. The default is '%s'." % WARP_CHOICES[0],
+    choices=WARP_CHOICES,
+    type=str, dest='warp'
+)
+parser.add_argument(
+    '--seam_megapix', action='store', default=0.1,
+    help="Resolution for seam estimation step. The default is 0.1 Mpx.",
+    type=float, dest='seam_megapix'
+)
+parser.add_argument(
+    '--seam', action='store', default=list(SEAM_FIND_CHOICES.keys())[0],
+    help="Seam estimation method. The default is '%s'." % list(SEAM_FIND_CHOICES.keys())[0],
+    choices=SEAM_FIND_CHOICES.keys(),
+    type=str, dest='seam'
+)
+parser.add_argument(
+    '--compose_megapix', action='store', default=-1,
+    help="Resolution for compositing step. Use -1 for original resolution. The default is -1",
+    type=float, dest='compose_megapix'
+)
+parser.add_argument(
+    '--expos_comp', action='store', default=list(EXPOS_COMP_CHOICES.keys())[0],
+    help="Exposure compensation method. The default is '%s'." % list(EXPOS_COMP_CHOICES.keys())[0],
+    choices=EXPOS_COMP_CHOICES.keys(),
+    type=str, dest='expos_comp'
+)
+parser.add_argument(
+    '--expos_comp_nr_feeds', action='store', default=1,
+    help="Number of exposure compensation feed.",
+    type=np.int32, dest='expos_comp_nr_feeds'
+)
+parser.add_argument(
+    '--expos_comp_nr_filtering', action='store', default=2,
+    help="Number of filtering iterations of the exposure compensation gains.",
+    type=float, dest='expos_comp_nr_filtering'
+)
+parser.add_argument(
+    '--expos_comp_block_size', action='store', default=32,
+    help="BLock size in pixels used by the exposure compensator. The default is 32.",
+    type=np.int32, dest='expos_comp_block_size'
+)
+parser.add_argument(
+    '--blend', action='store', default=BLEND_CHOICES[0],
+    help="Blending method. The default is '%s'." % BLEND_CHOICES[0],
+    choices=BLEND_CHOICES,
+    type=str, dest='blend'
+)
+parser.add_argument(
+    '--blend_strength', action='store', default=5,
+    help="Blending strength from [0,100] range. The default is 5",
+    type=np.int32, dest='blend_strength'
+)
+parser.add_argument(
+    '--output', action='store', default='result.jpg',
+    help="The default is 'result.jpg'",
+    type=str, dest='output'
+)
+parser.add_argument(
+    '--timelapse', action='store', default=None,
+    help="Output warped images separately as frames of a time lapse movie, "
+         "with 'fixed_' prepended to input file names.",
+    type=str, dest='timelapse'
+)
+parser.add_argument(
+    '--rangewidth', action='store', default=-1,
+    help="uses range_width to limit number of images to match with.",
+    type=int, dest='rangewidth'
+)
+
+__doc__ += '\n' + parser.format_help()
+
+
+def get_matcher(args):
+    try_cuda = args.try_cuda
+    matcher_type = args.matcher
+    if args.match_conf is None:
+        if args.features == 'orb':
+            match_conf = 0.3
+        else:
+            match_conf = 0.65
+    else:
+        match_conf = args.match_conf
+    range_width = args.rangewidth
+    if matcher_type == "affine":
+        matcher = cv.detail_AffineBestOf2NearestMatcher(False, try_cuda, match_conf)
+    elif range_width == -1:
+        matcher = cv.detail_BestOf2NearestMatcher(try_cuda, match_conf)
+    else:
+        matcher = cv.detail_BestOf2NearestRangeMatcher(range_width, try_cuda, match_conf)
+    return matcher
+
+
+def get_compensator(args):
+    expos_comp_type = EXPOS_COMP_CHOICES[args.expos_comp]
+    expos_comp_nr_feeds = args.expos_comp_nr_feeds
+    expos_comp_block_size = args.expos_comp_block_size
+    # expos_comp_nr_filtering = args.expos_comp_nr_filtering
+    if expos_comp_type == cv.detail.ExposureCompensator_CHANNELS:
+        compensator = cv.detail_ChannelsCompensator(expos_comp_nr_feeds)
+        # compensator.setNrGainsFilteringIterations(expos_comp_nr_filtering)
+    elif expos_comp_type == cv.detail.ExposureCompensator_CHANNELS_BLOCKS:
+        compensator = cv.detail_BlocksChannelsCompensator(
+            expos_comp_block_size, expos_comp_block_size,
+            expos_comp_nr_feeds
+        )
+        # compensator.setNrGainsFilteringIterations(expos_comp_nr_filtering)
+    else:
+        compensator = cv.detail.ExposureCompensator_createDefault(expos_comp_type)
+    return compensator
+
+
+def main():
+    args = parser.parse_args()
+    img_names = args.img_names
+    print(img_names)
+    work_megapix = args.work_megapix
+    seam_megapix = args.seam_megapix
+    compose_megapix = args.compose_megapix
+    conf_thresh = args.conf_thresh
+    ba_refine_mask = args.ba_refine_mask
+    wave_correct = WAVE_CORRECT_CHOICES[args.wave_correct]
+    if args.save_graph is None:
+        save_graph = False
+    else:
+        save_graph = True
+    warp_type = args.warp
+    blend_type = args.blend
+    blend_strength = args.blend_strength
+    result_name = args.output
+    if args.timelapse is not None:
+        timelapse = True
+        if args.timelapse == "as_is":
+            timelapse_type = cv.detail.Timelapser_AS_IS
+        elif args.timelapse == "crop":
+            timelapse_type = cv.detail.Timelapser_CROP
+        else:
+            print("Bad timelapse method")
+            exit()
+    else:
+        timelapse = False
+    finder = FEATURES_FIND_CHOICES[args.features]()
+    seam_work_aspect = 1
+    full_img_sizes = []
+    features = []
+    images = []
+    is_work_scale_set = False
+    is_seam_scale_set = False
+    is_compose_scale_set = False
+    for name in img_names:
+        full_img = cv.imread(cv.samples.findFile(name))
+        if full_img is None:
+            print("Cannot read image ", name)
+            exit()
+        full_img_sizes.append((full_img.shape[1], full_img.shape[0]))
+        if work_megapix < 0:
+            img = full_img
+            work_scale = 1
+            is_work_scale_set = True
+        else:
+            if is_work_scale_set is False:
+                work_scale = min(1.0, np.sqrt(work_megapix * 1e6 / (full_img.shape[0] * full_img.shape[1])))
+                is_work_scale_set = True
+            img = cv.resize(src=full_img, dsize=None, fx=work_scale, fy=work_scale, interpolation=cv.INTER_LINEAR_EXACT)
+        if is_seam_scale_set is False:
+            if seam_megapix > 0:
+                seam_scale = min(1.0, np.sqrt(seam_megapix * 1e6 / (full_img.shape[0] * full_img.shape[1])))
+            else:
+                seam_scale = 1.0
+            seam_work_aspect = seam_scale / work_scale
+            is_seam_scale_set = True
+        img_feat = cv.detail.computeImageFeatures2(finder, img)
+        features.append(img_feat)
+        img = cv.resize(src=full_img, dsize=None, fx=seam_scale, fy=seam_scale, interpolation=cv.INTER_LINEAR_EXACT)
+        images.append(img)
+
+    matcher = get_matcher(args)
+    p = matcher.apply2(features)
+    matcher.collectGarbage()
+
+    if save_graph:
+        with open(args.save_graph, 'w') as fh:
+            fh.write(cv.detail.matchesGraphAsString(img_names, p, conf_thresh))
+
+    indices = cv.detail.leaveBiggestComponent(features, p, conf_thresh)
+    img_subset = []
+    img_names_subset = []
+    full_img_sizes_subset = []
+    for i in range(len(indices)):
+        img_names_subset.append(img_names[indices[i]])
+        img_subset.append(images[indices[i]])
+        full_img_sizes_subset.append(full_img_sizes[indices[i]])
+    images = img_subset
+    img_names = img_names_subset
+    full_img_sizes = full_img_sizes_subset
+    num_images = len(img_names)
+    if num_images < 2:
+        print("Need more images")
+        exit()
+
+    estimator = ESTIMATOR_CHOICES[args.estimator]()
+    b, cameras = estimator.apply(features, p, None)
+    if not b:
+        print("Homography estimation failed.")
+        exit()
+    for cam in cameras:
+        cam.R = cam.R.astype(np.float32)
+
+    adjuster = BA_COST_CHOICES[args.ba]()
+    adjuster.setConfThresh(conf_thresh)
+    refine_mask = np.zeros((3, 3), np.uint8)
+    if ba_refine_mask[0] == 'x':
+        refine_mask[0, 0] = 1
+    if ba_refine_mask[1] == 'x':
+        refine_mask[0, 1] = 1
+    if ba_refine_mask[2] == 'x':
+        refine_mask[0, 2] = 1
+    if ba_refine_mask[3] == 'x':
+        refine_mask[1, 1] = 1
+    if ba_refine_mask[4] == 'x':
+        refine_mask[1, 2] = 1
+    adjuster.setRefinementMask(refine_mask)
+    b, cameras = adjuster.apply(features, p, cameras)
+    if not b:
+        print("Camera parameters adjusting failed.")
+        exit()
+    focals = []
+    for cam in cameras:
+        focals.append(cam.focal)
+    focals.sort()
+    if len(focals) % 2 == 1:
+        warped_image_scale = focals[len(focals) // 2]
+    else:
+        warped_image_scale = (focals[len(focals) // 2] + focals[len(focals) // 2 - 1]) / 2
+    if wave_correct is not None:
+        rmats = []
+        for cam in cameras:
+            rmats.append(np.copy(cam.R))
+        rmats = cv.detail.waveCorrect(rmats, wave_correct)
+        for idx, cam in enumerate(cameras):
+            cam.R = rmats[idx]
+    corners = []
+    masks_warped = []
+    images_warped = []
+    sizes = []
+    masks = []
+    for i in range(0, num_images):
+        um = cv.UMat(255 * np.ones((images[i].shape[0], images[i].shape[1]), np.uint8))
+        masks.append(um)
+
+    warper = cv.PyRotationWarper(warp_type, warped_image_scale * seam_work_aspect)  # warper could be nullptr?
+    for idx in range(0, num_images):
+        K = cameras[idx].K().astype(np.float32)
+        swa = seam_work_aspect
+        K[0, 0] *= swa
+        K[0, 2] *= swa
+        K[1, 1] *= swa
+        K[1, 2] *= swa
+        corner, image_wp = warper.warp(images[idx], K, cameras[idx].R, cv.INTER_LINEAR, cv.BORDER_REFLECT)
+        corners.append(corner)
+        sizes.append((image_wp.shape[1], image_wp.shape[0]))
+        images_warped.append(image_wp)
+        p, mask_wp = warper.warp(masks[idx], K, cameras[idx].R, cv.INTER_NEAREST, cv.BORDER_CONSTANT)
+        masks_warped.append(mask_wp.get())
+
+    images_warped_f = []
+    for img in images_warped:
+        imgf = img.astype(np.float32)
+        images_warped_f.append(imgf)
+
+    compensator = get_compensator(args)
+    compensator.feed(corners=corners, images=images_warped, masks=masks_warped)
+
+    seam_finder = SEAM_FIND_CHOICES[args.seam]
+    masks_warped = seam_finder.find(images_warped_f, corners, masks_warped)
+    compose_scale = 1
+    corners = []
+    sizes = []
+    blender = None
+    timelapser = None
+    # https://github.com/opencv/opencv/blob/4.x/samples/cpp/stitching_detailed.cpp#L725 ?
+    for idx, name in enumerate(img_names):
+        full_img = cv.imread(name)
+        if not is_compose_scale_set:
+            if compose_megapix > 0:
+                compose_scale = min(1.0, np.sqrt(compose_megapix * 1e6 / (full_img.shape[0] * full_img.shape[1])))
+            is_compose_scale_set = True
+            compose_work_aspect = compose_scale / work_scale
+            warped_image_scale *= compose_work_aspect
+            warper = cv.PyRotationWarper(warp_type, warped_image_scale)
+            for i in range(0, len(img_names)):
+                cameras[i].focal *= compose_work_aspect
+                cameras[i].ppx *= compose_work_aspect
+                cameras[i].ppy *= compose_work_aspect
+                sz = (int(round(full_img_sizes[i][0] * compose_scale)),
+                      int(round(full_img_sizes[i][1] * compose_scale)))
+                K = cameras[i].K().astype(np.float32)
+                roi = warper.warpRoi(sz, K, cameras[i].R)
+                corners.append(roi[0:2])
+                sizes.append(roi[2:4])
+        if abs(compose_scale - 1) > 1e-1:
+            img = cv.resize(src=full_img, dsize=None, fx=compose_scale, fy=compose_scale,
+                            interpolation=cv.INTER_LINEAR_EXACT)
+        else:
+            img = full_img
+        _img_size = (img.shape[1], img.shape[0])
+        K = cameras[idx].K().astype(np.float32)
+        corner, image_warped = warper.warp(img, K, cameras[idx].R, cv.INTER_LINEAR, cv.BORDER_REFLECT)
+        mask = 255 * np.ones((img.shape[0], img.shape[1]), np.uint8)
+        p, mask_warped = warper.warp(mask, K, cameras[idx].R, cv.INTER_NEAREST, cv.BORDER_CONSTANT)
+        compensator.apply(idx, corners[idx], image_warped, mask_warped)
+        image_warped_s = image_warped.astype(np.int16)
+        dilated_mask = cv.dilate(masks_warped[idx], None)
+        seam_mask = cv.resize(dilated_mask, (mask_warped.shape[1], mask_warped.shape[0]), 0, 0, cv.INTER_LINEAR_EXACT)
+        mask_warped = cv.bitwise_and(seam_mask, mask_warped)
+        if blender is None and not timelapse:
+            blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
+            dst_sz = cv.detail.resultRoi(corners=corners, sizes=sizes)
+            blend_width = np.sqrt(dst_sz[2] * dst_sz[3]) * blend_strength / 100
+            if blend_width < 1:
+                blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
+            elif blend_type == "multiband":
+                blender = cv.detail_MultiBandBlender()
+                blender.setNumBands((np.log(blend_width) / np.log(2.) - 1.).astype(np.int32))
+            elif blend_type == "feather":
+                blender = cv.detail_FeatherBlender()
+                blender.setSharpness(1. / blend_width)
+            blender.prepare(dst_sz)
+        elif timelapser is None and timelapse:
+            timelapser = cv.detail.Timelapser_createDefault(timelapse_type)
+            timelapser.initialize(corners, sizes)
+        if timelapse:
+            ma_tones = np.ones((image_warped_s.shape[0], image_warped_s.shape[1]), np.uint8)
+            timelapser.process(image_warped_s, ma_tones, corners[idx])
+            pos_s = img_names[idx].rfind("/")
+            if pos_s == -1:
+                fixed_file_name = "fixed_" + img_names[idx]
+            else:
+                fixed_file_name = img_names[idx][:pos_s + 1] + "fixed_" + img_names[idx][pos_s + 1:]
+            cv.imwrite(fixed_file_name, timelapser.getDst())
+        else:
+            blender.feed(cv.UMat(image_warped_s), mask_warped, corners[idx])
+    if not timelapse:
+        result = None
+        result_mask = None
+        result, result_mask = blender.blend(result, result_mask)
+        cv.imwrite(result_name, result)
+        zoom_x = 600.0 / result.shape[1]
+        dst = cv.normalize(src=result, dst=None, alpha=255., norm_type=cv.NORM_MINMAX, dtype=cv.CV_8U)
+        dst = cv.resize(dst, dsize=None, fx=zoom_x, fy=zoom_x)
+        cv.imshow(result_name, dst)
+        cv.waitKey()
+
+    print("Done")
+
+
+if __name__ == '__main__':
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/text_skewness_correction.py b/C++/opencv-4.7.0/samples/python/text_skewness_correction.py
new file mode 100644
index 00000000..c3e97a33
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/text_skewness_correction.py
@@ -0,0 +1,60 @@
+'''
+Text skewness correction
+This tutorial demonstrates how to correct the skewness in a text.
+The program takes as input a skewed source image and shows non skewed text.
+
+Usage:
+        python text_skewness_correction.py --image "Image path"
+'''
+
+import numpy as np
+import cv2 as cv
+import sys
+import argparse
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-i", "--image", default="imageTextR.png", help="path to input image file")
+    args = vars(parser.parse_args())
+
+    # load the image from disk
+    image = cv.imread(cv.samples.findFile(args["image"]))
+    if image is None:
+        print("can't read image " + args["image"])
+        sys.exit(-1)
+    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
+
+    # threshold the image, setting all foreground pixels to
+    # 255 and all background pixels to 0
+    thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV | cv.THRESH_OTSU)[1]
+
+    # Applying erode filter to remove random noise
+    erosion_size = 1
+    element = cv.getStructuringElement(cv.MORPH_RECT, (2 * erosion_size + 1, 2 * erosion_size + 1), (erosion_size, erosion_size) )
+    thresh = cv.erode(thresh, element)
+
+    coords = cv.findNonZero(thresh)
+    angle = cv.minAreaRect(coords)[-1]
+    # the `cv.minAreaRect` function returns values in the
+    # range [0, 90) if the angle is more than 45 we need to subtract 90 from it
+    if angle > 45:
+        angle = (angle - 90)
+
+    (h, w) = image.shape[:2]
+    center = (w // 2, h // 2)
+    M = cv.getRotationMatrix2D(center, angle, 1.0)
+    rotated = cv.warpAffine(image, M, (w, h), flags=cv.INTER_CUBIC, borderMode=cv.BORDER_REPLICATE)
+    cv.putText(rotated, "Angle: {:.2f} degrees".format(angle), (10, 30), cv.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+
+    # show the output image
+    print("[INFO] angle: {:.2f}".format(angle))
+    cv.imshow("Input", image)
+    cv.imshow("Rotated", rotated)
+    cv.waitKey(0)
+
+
+if __name__ == "__main__":
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/texture_flow.py b/C++/opencv-4.7.0/samples/python/texture_flow.py
new file mode 100644
index 00000000..33110858
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/texture_flow.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+
+'''
+Texture flow direction estimation.
+
+Sample shows how cv.cornerEigenValsAndVecs function can be used
+to estimate image texture flow direction.
+
+Usage:
+    texture_flow.py [<image>]
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+def main():
+    import sys
+    try:
+        fn = sys.argv[1]
+    except:
+        fn = 'starry_night.jpg'
+
+    img = cv.imread(cv.samples.findFile(fn))
+    if img is None:
+        print('Failed to load image file:', fn)
+        sys.exit(1)
+
+    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+    h, w = img.shape[:2]
+
+    eigen = cv.cornerEigenValsAndVecs(gray, 15, 3)
+    eigen = eigen.reshape(h, w, 3, 2)  # [[e1, e2], v1, v2]
+    flow = eigen[:,:,2]
+
+    vis = img.copy()
+    vis[:] = (192 + np.uint32(vis)) / 2
+    d = 12
+    points =  np.dstack( np.mgrid[d/2:w:d, d/2:h:d] ).reshape(-1, 2)
+    for x, y in np.int32(points):
+        vx, vy = np.int32(flow[y, x]*d)
+        cv.line(vis, (x-vx, y-vy), (x+vx, y+vy), (0, 0, 0), 1, cv.LINE_AA)
+    cv.imshow('input', img)
+    cv.imshow('flow', vis)
+    cv.waitKey()
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/tracker.py b/C++/opencv-4.7.0/samples/python/tracker.py
new file mode 100644
index 00000000..42b17018
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tracker.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+'''
+Tracker demo
+
+For usage download models by following links
+For GOTURN:
+    goturn.prototxt and goturn.caffemodel: https://github.com/opencv/opencv_extra/tree/c4219d5eb3105ed8e634278fad312a1a8d2c182d/testdata/tracking
+For DaSiamRPN:
+    network:     https://www.dropbox.com/s/rr1lk9355vzolqv/dasiamrpn_model.onnx?dl=0
+    kernel_r1:   https://www.dropbox.com/s/999cqx5zrfi7w4p/dasiamrpn_kernel_r1.onnx?dl=0
+    kernel_cls1: https://www.dropbox.com/s/qvmtszx5h339a0w/dasiamrpn_kernel_cls1.onnx?dl=0
+For NanoTrack:
+    nanotrack_backbone: https://github.com/HonglinChu/SiamTrackers/blob/master/NanoTrack/models/nanotrackv2/nanotrack_backbone_sim.onnx
+    nanotrack_headneck: https://github.com/HonglinChu/SiamTrackers/blob/master/NanoTrack/models/nanotrackv2/nanotrack_head_sim.onnx
+
+USAGE:
+    tracker.py [-h] [--input INPUT] [--tracker_algo TRACKER_ALGO]
+                    [--goturn GOTURN] [--goturn_model GOTURN_MODEL]
+                    [--dasiamrpn_net DASIAMRPN_NET]
+                    [--dasiamrpn_kernel_r1 DASIAMRPN_KERNEL_R1]
+                    [--dasiamrpn_kernel_cls1 DASIAMRPN_KERNEL_CLS1]
+                    [--dasiamrpn_backend DASIAMRPN_BACKEND]
+                    [--dasiamrpn_target DASIAMRPN_TARGET]
+                    [--nanotrack_backbone NANOTRACK_BACKEND] [--nanotrack_headneck NANOTRACK_TARGET]
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import sys
+
+import numpy as np
+import cv2 as cv
+import argparse
+
+from video import create_capture, presets
+
+class App(object):
+
+    def __init__(self, args):
+        self.args = args
+        self.trackerAlgorithm = args.tracker_algo
+        self.tracker = self.createTracker()
+
+    def createTracker(self):
+        if self.trackerAlgorithm == 'mil':
+            tracker = cv.TrackerMIL_create()
+        elif self.trackerAlgorithm == 'goturn':
+            params = cv.TrackerGOTURN_Params()
+            params.modelTxt = self.args.goturn
+            params.modelBin = self.args.goturn_model
+            tracker = cv.TrackerGOTURN_create(params)
+        elif self.trackerAlgorithm == 'dasiamrpn':
+            params = cv.TrackerDaSiamRPN_Params()
+            params.model = self.args.dasiamrpn_net
+            params.kernel_cls1 = self.args.dasiamrpn_kernel_cls1
+            params.kernel_r1 = self.args.dasiamrpn_kernel_r1
+            tracker = cv.TrackerDaSiamRPN_create(params)
+        elif self.trackerAlgorithm == 'nanotrack':
+            params = cv.TrackerNano_Params()
+            params.backbone = args.nanotrack_backbone
+            params.neckhead = args.nanotrack_headneck
+            tracker = cv.TrackerNano_create(params)
+        else:
+            sys.exit("Tracker {} is not recognized. Please use one of three available: mil, goturn, dasiamrpn, nanotrack.".format(self.trackerAlgorithm))
+        return tracker
+
+    def initializeTracker(self, image):
+        while True:
+            print('==> Select object ROI for tracker ...')
+            bbox = cv.selectROI('tracking', image)
+            print('ROI: {}'.format(bbox))
+            if bbox[2] <= 0 or bbox[3] <= 0:
+                sys.exit("ROI selection cancelled. Exiting...")
+
+            try:
+                self.tracker.init(image, bbox)
+            except Exception as e:
+                print('Unable to initialize tracker with requested bounding box. Is there any object?')
+                print(e)
+                print('Try again ...')
+                continue
+
+            return
+
+    def run(self):
+        videoPath = self.args.input
+        print('Using video: {}'.format(videoPath))
+        camera = create_capture(cv.samples.findFileOrKeep(videoPath), presets['cube'])
+        if not camera.isOpened():
+            sys.exit("Can't open video stream: {}".format(videoPath))
+
+        ok, image = camera.read()
+        if not ok:
+            sys.exit("Can't read first frame")
+        assert image is not None
+
+        cv.namedWindow('tracking')
+        self.initializeTracker(image)
+
+        print("==> Tracking is started. Press 'SPACE' to re-initialize tracker or 'ESC' for exit...")
+
+        while camera.isOpened():
+            ok, image = camera.read()
+            if not ok:
+                print("Can't read frame")
+                break
+
+            ok, newbox = self.tracker.update(image)
+            #print(ok, newbox)
+
+            if ok:
+                cv.rectangle(image, newbox, (200,0,0))
+
+            cv.imshow("tracking", image)
+            k = cv.waitKey(1)
+            if k == 32:  # SPACE
+                self.initializeTracker(image)
+            if k == 27:  # ESC
+                break
+
+        print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    parser = argparse.ArgumentParser(description="Run tracker")
+    parser.add_argument("--input", type=str, default="vtest.avi", help="Path to video source")
+    parser.add_argument("--tracker_algo", type=str, default="nanotrack", help="One of available tracking algorithms: mil, goturn, dasiamrpn, nanotrack")
+    parser.add_argument("--goturn", type=str, default="goturn.prototxt", help="Path to GOTURN architecture")
+    parser.add_argument("--goturn_model", type=str, default="goturn.caffemodel", help="Path to GOTERN model")
+    parser.add_argument("--dasiamrpn_net", type=str, default="dasiamrpn_model.onnx", help="Path to onnx model of DaSiamRPN net")
+    parser.add_argument("--dasiamrpn_kernel_r1", type=str, default="dasiamrpn_kernel_r1.onnx", help="Path to onnx model of DaSiamRPN kernel_r1")
+    parser.add_argument("--dasiamrpn_kernel_cls1", type=str, default="dasiamrpn_kernel_cls1.onnx", help="Path to onnx model of DaSiamRPN kernel_cls1")
+    parser.add_argument("--nanotrack_backbone", type=str, default="nanotrack_backbone_sim.onnx", help="Path to onnx model of NanoTrack backBone")
+    parser.add_argument("--nanotrack_headneck", type=str, default="nanotrack_head_sim.onnx", help="Path to onnx model of NanoTrack headNeck")
+
+    args = parser.parse_args()
+    App(args).run()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/tst_scene_render.py b/C++/opencv-4.7.0/samples/python/tst_scene_render.py
new file mode 100644
index 00000000..9d09ea7b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tst_scene_render.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+from numpy import pi, sin, cos
+
+
+defaultSize = 512
+
+class TestSceneRender():
+
+    def __init__(self, bgImg = None, fgImg = None,
+        deformation = False, speed = 0.25, **params):
+        self.time = 0.0
+        self.timeStep = 1.0 / 30.0
+        self.foreground = fgImg
+        self.deformation = deformation
+        self.speed = speed
+
+        if bgImg is not None:
+            self.sceneBg = bgImg.copy()
+        else:
+            self.sceneBg = np.zeros(defaultSize, defaultSize, np.uint8)
+
+        self.w = self.sceneBg.shape[0]
+        self.h = self.sceneBg.shape[1]
+
+        if fgImg is not None:
+            self.foreground = fgImg.copy()
+            self.center = self.currentCenter = (int(self.w/2 - fgImg.shape[0]/2), int(self.h/2 - fgImg.shape[1]/2))
+
+            self.xAmpl = self.sceneBg.shape[0] - (self.center[0] + fgImg.shape[0])
+            self.yAmpl = self.sceneBg.shape[1] - (self.center[1] + fgImg.shape[1])
+
+        self.initialRect = np.array([ (self.h/2, self.w/2), (self.h/2, self.w/2 + self.w/10),
+         (self.h/2 + self.h/10, self.w/2 + self.w/10), (self.h/2 + self.h/10, self.w/2)]).astype(int)
+        self.currentRect = self.initialRect
+
+    def getXOffset(self, time):
+        return int( self.xAmpl*cos(time*self.speed))
+
+
+    def getYOffset(self, time):
+        return int(self.yAmpl*sin(time*self.speed))
+
+    def setInitialRect(self, rect):
+        self.initialRect = rect
+
+    def getRectInTime(self, time):
+
+        if self.foreground is not None:
+            tmp = np.array(self.center) + np.array((self.getXOffset(time), self.getYOffset(time)))
+            x0, y0 = tmp
+            x1, y1 = tmp + self.foreground.shape[0:2]
+            return np.array([y0, x0, y1, x1])
+        else:
+            x0, y0 = self.initialRect[0] + np.array((self.getXOffset(time), self.getYOffset(time)))
+            x1, y1 = self.initialRect[2] + np.array((self.getXOffset(time), self.getYOffset(time)))
+            return np.array([y0, x0, y1, x1])
+
+    def getCurrentRect(self):
+
+        if self.foreground is not None:
+
+            x0 = self.currentCenter[0]
+            y0 = self.currentCenter[1]
+            x1 = self.currentCenter[0] + self.foreground.shape[0]
+            y1 = self.currentCenter[1] + self.foreground.shape[1]
+            return np.array([y0, x0, y1, x1])
+        else:
+            x0, y0 = self.currentRect[0]
+            x1, y1 = self.currentRect[2]
+            return np.array([x0, y0, x1, y1])
+
+    def getNextFrame(self):
+        img = self.sceneBg.copy()
+
+        if self.foreground is not None:
+            self.currentCenter = (self.center[0] + self.getXOffset(self.time), self.center[1] + self.getYOffset(self.time))
+            img[self.currentCenter[0]:self.currentCenter[0]+self.foreground.shape[0],
+             self.currentCenter[1]:self.currentCenter[1]+self.foreground.shape[1]] = self.foreground
+        else:
+            self.currentRect = self.initialRect + np.int( 30*cos(self.time*self.speed) + 50*sin(self.time*self.speed))
+            if self.deformation:
+                self.currentRect[1:3] += int(self.h/20*cos(self.time))
+            cv.fillConvexPoly(img, self.currentRect, (0, 0, 255))
+
+        self.time += self.timeStep
+        return img
+
+    def resetTime(self):
+        self.time = 0.0
+
+
+def main():
+    backGr = cv.imread(cv.samples.findFile('graf1.png'))
+    fgr = cv.imread(cv.samples.findFile('box.png'))
+
+    render = TestSceneRender(backGr, fgr)
+
+    while True:
+
+        img = render.getNextFrame()
+        cv.imshow('img', img)
+
+        ch = cv.waitKey(3)
+        if  ch == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/turing.py b/C++/opencv-4.7.0/samples/python/turing.py
new file mode 100644
index 00000000..dc920d12
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/turing.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+
+'''
+Multiscale Turing Patterns generator
+====================================
+
+Inspired by http://www.jonathanmccabe.com/Cyclic_Symmetric_Multi-Scale_Turing_Patterns.pdf
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2 as cv
+from common import draw_str
+import getopt, sys
+from itertools import count
+
+help_message = '''
+USAGE: turing.py [-o <output.avi>]
+
+Press ESC to stop.
+'''
+
+def main():
+    print(help_message)
+
+    w, h = 512, 512
+
+    args, _args_list = getopt.getopt(sys.argv[1:], 'o:', [])
+    args = dict(args)
+    out = None
+    if '-o' in args:
+        fn = args['-o']
+        out = cv.VideoWriter(args['-o'], cv.VideoWriter_fourcc(*'DIB '), 30.0, (w, h), False)
+        print('writing %s ...' % fn)
+
+    a = np.zeros((h, w), np.float32)
+    cv.randu(a, np.array([0]), np.array([1]))
+
+    def process_scale(a_lods, lod):
+        d = a_lods[lod] - cv.pyrUp(a_lods[lod+1])
+        for _i in xrange(lod):
+            d = cv.pyrUp(d)
+        v = cv.GaussianBlur(d*d, (3, 3), 0)
+        return np.sign(d), v
+
+    scale_num = 6
+    for frame_i in count():
+        a_lods = [a]
+        for i in xrange(scale_num):
+            a_lods.append(cv.pyrDown(a_lods[-1]))
+        ms, vs = [], []
+        for i in xrange(1, scale_num):
+            m, v = process_scale(a_lods, i)
+            ms.append(m)
+            vs.append(v)
+        mi = np.argmin(vs, 0)
+        a += np.choose(mi, ms) * 0.025
+        a = (a-a.min()) / a.ptp()
+
+        if out:
+            out.write(a)
+        vis = a.copy()
+        draw_str(vis, (20, 20), 'frame %d' % frame_i)
+        cv.imshow('a', vis)
+        if cv.waitKey(5) == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/back_projection/calcBackProject_Demo1.py b/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/back_projection/calcBackProject_Demo1.py
new file mode 100644
index 00000000..8086b932
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/back_projection/calcBackProject_Demo1.py
@@ -0,0 +1,71 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+
+def Hist_and_Backproj(val):
+    ## [initialize]
+    bins = val
+    histSize = max(bins, 2)
+    ranges = [0, 180] # hue_range
+    ## [initialize]
+
+    ## [Get the Histogram and normalize it]
+    hist = cv.calcHist([hue], [0], None, [histSize], ranges, accumulate=False)
+    cv.normalize(hist, hist, alpha=0, beta=255, norm_type=cv.NORM_MINMAX)
+    ## [Get the Histogram and normalize it]
+
+    ## [Get Backprojection]
+    backproj = cv.calcBackProject([hue], [0], hist, ranges, scale=1)
+    ## [Get Backprojection]
+
+    ## [Draw the backproj]
+    cv.imshow('BackProj', backproj)
+    ## [Draw the backproj]
+
+    ## [Draw the histogram]
+    w = 400
+    h = 400
+    bin_w = int(round(w / histSize))
+    histImg = np.zeros((h, w, 3), dtype=np.uint8)
+
+    for i in range(bins):
+        cv.rectangle(histImg, (i*bin_w, h), ( (i+1)*bin_w, h - int(np.round( hist[i]*h/255.0 )) ), (0, 0, 255), cv.FILLED)
+
+    cv.imshow('Histogram', histImg)
+    ## [Draw the histogram]
+
+## [Read the image]
+parser = argparse.ArgumentParser(description='Code for Back Projection tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='home.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+## [Read the image]
+
+## [Transform it to HSV]
+hsv = cv.cvtColor(src, cv.COLOR_BGR2HSV)
+## [Transform it to HSV]
+
+## [Use only the Hue value]
+ch = (0, 0)
+hue = np.empty(hsv.shape, hsv.dtype)
+cv.mixChannels([hsv], [hue], ch)
+## [Use only the Hue value]
+
+## [Create Trackbar to enter the number of bins]
+window_image = 'Source image'
+cv.namedWindow(window_image)
+bins = 25
+cv.createTrackbar('* Hue  bins: ', window_image, bins, 180, Hist_and_Backproj )
+Hist_and_Backproj(bins)
+## [Create Trackbar to enter the number of bins]
+
+## [Show the image]
+cv.imshow(window_image, src)
+cv.waitKey()
+## [Show the image]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/back_projection/calcBackProject_Demo2.py b/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/back_projection/calcBackProject_Demo2.py
new file mode 100644
index 00000000..42d5a9b8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/back_projection/calcBackProject_Demo2.py
@@ -0,0 +1,79 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+low = 20
+up = 20
+
+def callback_low(val):
+    global low
+    low = val
+
+def callback_up(val):
+    global up
+    up = val
+
+def pickPoint(event, x, y, flags, param):
+    if event != cv.EVENT_LBUTTONDOWN:
+        return
+
+    # Fill and get the mask
+    seed = (x, y)
+    newMaskVal = 255
+    newVal = (120, 120, 120)
+    connectivity = 8
+    flags = connectivity + (newMaskVal << 8 ) + cv.FLOODFILL_FIXED_RANGE + cv.FLOODFILL_MASK_ONLY
+
+    mask2 = np.zeros((src.shape[0] + 2, src.shape[1] + 2), dtype=np.uint8)
+    print('low:', low, 'up:', up)
+    cv.floodFill(src, mask2, seed, newVal, (low, low, low), (up, up, up), flags)
+    mask = mask2[1:-1,1:-1]
+
+    cv.imshow('Mask', mask)
+    Hist_and_Backproj(mask)
+
+def Hist_and_Backproj(mask):
+    h_bins = 30
+    s_bins = 32
+    histSize = [h_bins, s_bins]
+    h_range = [0, 180]
+    s_range = [0, 256]
+    ranges = h_range + s_range # Concat list
+    channels = [0, 1]
+
+    # Get the Histogram and normalize it
+    hist = cv.calcHist([hsv], channels, mask, histSize, ranges, accumulate=False)
+    cv.normalize(hist, hist, alpha=0, beta=255, norm_type=cv.NORM_MINMAX)
+
+    # Get Backprojection
+    backproj = cv.calcBackProject([hsv], channels, hist, ranges, scale=1)
+
+    # Draw the backproj
+    cv.imshow('BackProj', backproj)
+
+# Read the image
+parser = argparse.ArgumentParser(description='Code for Back Projection tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='home.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Transform it to HSV
+hsv = cv.cvtColor(src, cv.COLOR_BGR2HSV)
+
+# Show the image
+window_image = 'Source image'
+cv.namedWindow(window_image)
+cv.imshow(window_image, src)
+
+# Set Trackbars for floodfill thresholds
+cv.createTrackbar('Low thresh', window_image, low, 255, callback_low)
+cv.createTrackbar('High thresh', window_image, up, 255, callback_up)
+# Set a Mouse Callback
+cv.setMouseCallback(window_image, pickPoint)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/histogram_calculation/calcHist_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/histogram_calculation/calcHist_Demo.py
new file mode 100644
index 00000000..1789d493
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/histogram_calculation/calcHist_Demo.py
@@ -0,0 +1,71 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+
+## [Load image]
+parser = argparse.ArgumentParser(description='Code for Histogram Calculation tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='lena.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+## [Load image]
+
+## [Separate the image in 3 places ( B, G and R )]
+bgr_planes = cv.split(src)
+## [Separate the image in 3 places ( B, G and R )]
+
+## [Establish the number of bins]
+histSize = 256
+## [Establish the number of bins]
+
+## [Set the ranges ( for B,G,R) )]
+histRange = (0, 256) # the upper boundary is exclusive
+## [Set the ranges ( for B,G,R) )]
+
+## [Set histogram param]
+accumulate = False
+## [Set histogram param]
+
+## [Compute the histograms]
+b_hist = cv.calcHist(bgr_planes, [0], None, [histSize], histRange, accumulate=accumulate)
+g_hist = cv.calcHist(bgr_planes, [1], None, [histSize], histRange, accumulate=accumulate)
+r_hist = cv.calcHist(bgr_planes, [2], None, [histSize], histRange, accumulate=accumulate)
+## [Compute the histograms]
+
+## [Draw the histograms for B, G and R]
+hist_w = 512
+hist_h = 400
+bin_w = int(round( hist_w/histSize ))
+
+histImage = np.zeros((hist_h, hist_w, 3), dtype=np.uint8)
+## [Draw the histograms for B, G and R]
+
+## [Normalize the result to ( 0, histImage.rows )]
+cv.normalize(b_hist, b_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
+cv.normalize(g_hist, g_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
+cv.normalize(r_hist, r_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
+## [Normalize the result to ( 0, histImage.rows )]
+
+## [Draw for each channel]
+for i in range(1, histSize):
+    cv.line(histImage, ( bin_w*(i-1), hist_h - int(b_hist[i-1]) ),
+            ( bin_w*(i), hist_h - int(b_hist[i]) ),
+            ( 255, 0, 0), thickness=2)
+    cv.line(histImage, ( bin_w*(i-1), hist_h - int(g_hist[i-1]) ),
+            ( bin_w*(i), hist_h - int(g_hist[i]) ),
+            ( 0, 255, 0), thickness=2)
+    cv.line(histImage, ( bin_w*(i-1), hist_h - int(r_hist[i-1]) ),
+            ( bin_w*(i), hist_h - int(r_hist[i]) ),
+            ( 0, 0, 255), thickness=2)
+## [Draw for each channel]
+
+## [Display]
+cv.imshow('Source image', src)
+cv.imshow('calcHist Demo', histImage)
+cv.waitKey()
+## [Display]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/histogram_comparison/compareHist_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/histogram_comparison/compareHist_Demo.py
new file mode 100644
index 00000000..08d0dc35
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/histogram_comparison/compareHist_Demo.py
@@ -0,0 +1,69 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+
+## [Load three images with different environment settings]
+parser = argparse.ArgumentParser(description='Code for Histogram Comparison tutorial.')
+parser.add_argument('--input1', help='Path to input image 1.')
+parser.add_argument('--input2', help='Path to input image 2.')
+parser.add_argument('--input3', help='Path to input image 3.')
+args = parser.parse_args()
+
+src_base = cv.imread(args.input1)
+src_test1 = cv.imread(args.input2)
+src_test2 = cv.imread(args.input3)
+if src_base is None or src_test1 is None or src_test2 is None:
+    print('Could not open or find the images!')
+    exit(0)
+## [Load three images with different environment settings]
+
+## [Convert to HSV]
+hsv_base = cv.cvtColor(src_base, cv.COLOR_BGR2HSV)
+hsv_test1 = cv.cvtColor(src_test1, cv.COLOR_BGR2HSV)
+hsv_test2 = cv.cvtColor(src_test2, cv.COLOR_BGR2HSV)
+## [Convert to HSV]
+
+## [Convert to HSV half]
+hsv_half_down = hsv_base[hsv_base.shape[0]//2:,:]
+## [Convert to HSV half]
+
+## [Using 50 bins for hue and 60 for saturation]
+h_bins = 50
+s_bins = 60
+histSize = [h_bins, s_bins]
+
+# hue varies from 0 to 179, saturation from 0 to 255
+h_ranges = [0, 180]
+s_ranges = [0, 256]
+ranges = h_ranges + s_ranges # concat lists
+
+# Use the 0-th and 1-st channels
+channels = [0, 1]
+## [Using 50 bins for hue and 60 for saturation]
+
+## [Calculate the histograms for the HSV images]
+hist_base = cv.calcHist([hsv_base], channels, None, histSize, ranges, accumulate=False)
+cv.normalize(hist_base, hist_base, alpha=0, beta=1, norm_type=cv.NORM_MINMAX)
+
+hist_half_down = cv.calcHist([hsv_half_down], channels, None, histSize, ranges, accumulate=False)
+cv.normalize(hist_half_down, hist_half_down, alpha=0, beta=1, norm_type=cv.NORM_MINMAX)
+
+hist_test1 = cv.calcHist([hsv_test1], channels, None, histSize, ranges, accumulate=False)
+cv.normalize(hist_test1, hist_test1, alpha=0, beta=1, norm_type=cv.NORM_MINMAX)
+
+hist_test2 = cv.calcHist([hsv_test2], channels, None, histSize, ranges, accumulate=False)
+cv.normalize(hist_test2, hist_test2, alpha=0, beta=1, norm_type=cv.NORM_MINMAX)
+## [Calculate the histograms for the HSV images]
+
+## [Apply the histogram comparison methods]
+for compare_method in range(4):
+    base_base = cv.compareHist(hist_base, hist_base, compare_method)
+    base_half = cv.compareHist(hist_base, hist_half_down, compare_method)
+    base_test1 = cv.compareHist(hist_base, hist_test1, compare_method)
+    base_test2 = cv.compareHist(hist_base, hist_test2, compare_method)
+
+    print('Method:', compare_method, 'Perfect, Base-Half, Base-Test(1), Base-Test(2) :',\
+          base_base, '/', base_half, '/', base_test1, '/', base_test2)
+## [Apply the histogram comparison methods]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/histogram_equalization/EqualizeHist_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/histogram_equalization/EqualizeHist_Demo.py
new file mode 100644
index 00000000..9bb82cee
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/Histograms_Matching/histogram_equalization/EqualizeHist_Demo.py
@@ -0,0 +1,31 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+## [Load image]
+parser = argparse.ArgumentParser(description='Code for Histogram Equalization tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='lena.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+## [Load image]
+
+## [Convert to grayscale]
+src = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+## [Convert to grayscale]
+
+## [Apply Histogram Equalization]
+dst = cv.equalizeHist(src)
+## [Apply Histogram Equalization]
+
+## [Display results]
+cv.imshow('Source image', src)
+cv.imshow('Equalized Image', dst)
+## [Display results]
+
+## [Wait until user exits the program]
+cv.waitKey()
+## [Wait until user exits the program]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/Filter2D/filter2D.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/Filter2D/filter2D.py
new file mode 100644
index 00000000..658e4636
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/Filter2D/filter2D.py
@@ -0,0 +1,54 @@
+"""
+@file filter2D.py
+@brief Sample code that shows how to implement your own linear filters by using filter2D function
+"""
+import sys
+import cv2 as cv
+import numpy as np
+
+
+def main(argv):
+    window_name = 'filter2D Demo'
+
+    ## [load]
+    imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
+
+    # Loads an image
+    src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image!')
+        print ('Usage: filter2D.py [image_name -- default lena.jpg] \n')
+        return -1
+    ## [load]
+    ## [init_arguments]
+    # Initialize ddepth argument for the filter
+    ddepth = -1
+    ## [init_arguments]
+    # Loop - Will filter the image with different kernel sizes each 0.5 seconds
+    ind = 0
+    while True:
+        ## [update_kernel]
+        # Update kernel size for a normalized box filter
+        kernel_size = 3 + 2 * (ind % 5)
+        kernel = np.ones((kernel_size, kernel_size), dtype=np.float32)
+        kernel /= (kernel_size * kernel_size)
+        ## [update_kernel]
+        ## [apply_filter]
+        # Apply filter
+        dst = cv.filter2D(src, ddepth, kernel)
+        ## [apply_filter]
+        cv.imshow(window_name, dst)
+
+        c = cv.waitKey(500)
+        if c == 27:
+            break
+
+        ind += 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/HoughCircle/hough_circle.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/HoughCircle/hough_circle.py
new file mode 100644
index 00000000..8da7eefe
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/HoughCircle/hough_circle.py
@@ -0,0 +1,59 @@
+import sys
+import cv2 as cv
+import numpy as np
+
+
+def main(argv):
+    ## [load]
+    default_file = 'smarties.png'
+    filename = argv[0] if len(argv) > 0 else default_file
+
+    # Loads an image
+    src = cv.imread(cv.samples.findFile(filename), cv.IMREAD_COLOR)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image!')
+        print ('Usage: hough_circle.py [image_name -- default ' + default_file + '] \n')
+        return -1
+    ## [load]
+
+    ## [convert_to_gray]
+    # Convert it to gray
+    gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    ## [convert_to_gray]
+
+    ## [reduce_noise]
+    # Reduce the noise to avoid false circle detection
+    gray = cv.medianBlur(gray, 5)
+    ## [reduce_noise]
+
+    ## [houghcircles]
+    rows = gray.shape[0]
+    circles = cv.HoughCircles(gray, cv.HOUGH_GRADIENT, 1, rows / 8,
+                               param1=100, param2=30,
+                               minRadius=1, maxRadius=30)
+    ## [houghcircles]
+
+    ## [draw]
+    if circles is not None:
+        circles = np.uint16(np.around(circles))
+        for i in circles[0, :]:
+            center = (i[0], i[1])
+            # circle center
+            cv.circle(src, center, 1, (0, 100, 100), 3)
+            # circle outline
+            radius = i[2]
+            cv.circle(src, center, radius, (255, 0, 255), 3)
+    ## [draw]
+
+    ## [display]
+    cv.imshow("detected circles", src)
+    cv.waitKey(0)
+    ## [display]
+
+    return 0
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/HoughLine/hough_lines.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/HoughLine/hough_lines.py
new file mode 100644
index 00000000..71e5a922
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/HoughLine/hough_lines.py
@@ -0,0 +1,79 @@
+"""
+@file hough_lines.py
+@brief This program demonstrates line finding with the Hough transform
+"""
+import sys
+import math
+import cv2 as cv
+import numpy as np
+
+
+def main(argv):
+    ## [load]
+    default_file = 'sudoku.png'
+    filename = argv[0] if len(argv) > 0 else default_file
+
+    # Loads an image
+    src = cv.imread(cv.samples.findFile(filename), cv.IMREAD_GRAYSCALE)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image!')
+        print ('Usage: hough_lines.py [image_name -- default ' + default_file + '] \n')
+        return -1
+    ## [load]
+
+    ## [edge_detection]
+    # Edge detection
+    dst = cv.Canny(src, 50, 200, None, 3)
+    ## [edge_detection]
+
+    # Copy edges to the images that will display the results in BGR
+    cdst = cv.cvtColor(dst, cv.COLOR_GRAY2BGR)
+    cdstP = np.copy(cdst)
+
+    ## [hough_lines]
+    #  Standard Hough Line Transform
+    lines = cv.HoughLines(dst, 1, np.pi / 180, 150, None, 0, 0)
+    ## [hough_lines]
+    ## [draw_lines]
+    # Draw the lines
+    if lines is not None:
+        for i in range(0, len(lines)):
+            rho = lines[i][0][0]
+            theta = lines[i][0][1]
+            a = math.cos(theta)
+            b = math.sin(theta)
+            x0 = a * rho
+            y0 = b * rho
+            pt1 = (int(x0 + 1000*(-b)), int(y0 + 1000*(a)))
+            pt2 = (int(x0 - 1000*(-b)), int(y0 - 1000*(a)))
+
+            cv.line(cdst, pt1, pt2, (0,0,255), 3, cv.LINE_AA)
+    ## [draw_lines]
+
+    ## [hough_lines_p]
+    # Probabilistic Line Transform
+    linesP = cv.HoughLinesP(dst, 1, np.pi / 180, 50, None, 50, 10)
+    ## [hough_lines_p]
+    ## [draw_lines_p]
+    # Draw the lines
+    if linesP is not None:
+        for i in range(0, len(linesP)):
+            l = linesP[i][0]
+            cv.line(cdstP, (l[0], l[1]), (l[2], l[3]), (0,0,255), 3, cv.LINE_AA)
+    ## [draw_lines_p]
+    ## [imshow]
+    # Show results
+    cv.imshow("Source", src)
+    cv.imshow("Detected Lines (in red) - Standard Hough Line Transform", cdst)
+    cv.imshow("Detected Lines (in red) - Probabilistic Line Transform", cdstP)
+    ## [imshow]
+    ## [exit]
+    # Wait and Exit
+    cv.waitKey()
+    return 0
+    ## [exit]
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/LaPlace/laplace_demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/LaPlace/laplace_demo.py
new file mode 100644
index 00000000..e3b13ca2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/LaPlace/laplace_demo.py
@@ -0,0 +1,59 @@
+"""
+@file laplace_demo.py
+@brief Sample code showing how to detect edges using the Laplace operator
+"""
+import sys
+import cv2 as cv
+
+def main(argv):
+    # [variables]
+    # Declare the variables we are going to use
+    ddepth = cv.CV_16S
+    kernel_size = 3
+    window_name = "Laplace Demo"
+    # [variables]
+
+    # [load]
+    imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
+
+    src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR) # Load an image
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image')
+        print ('Program Arguments: [image_name -- default lena.jpg]')
+        return -1
+    # [load]
+
+    # [reduce_noise]
+    # Remove noise by blurring with a Gaussian filter
+    src = cv.GaussianBlur(src, (3, 3), 0)
+    # [reduce_noise]
+
+    # [convert_to_gray]
+    # Convert the image to grayscale
+    src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    # [convert_to_gray]
+
+    # Create Window
+    cv.namedWindow(window_name, cv.WINDOW_AUTOSIZE)
+
+    # [laplacian]
+    # Apply Laplace function
+    dst = cv.Laplacian(src_gray, ddepth, ksize=kernel_size)
+    # [laplacian]
+
+    # [convert]
+    # converting back to uint8
+    abs_dst = cv.convertScaleAbs(dst)
+    # [convert]
+
+    # [display]
+    cv.imshow(window_name, abs_dst)
+    cv.waitKey(0)
+    # [display]
+
+    return 0
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/MakeBorder/copy_make_border.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/MakeBorder/copy_make_border.py
new file mode 100644
index 00000000..ff1f3669
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/MakeBorder/copy_make_border.py
@@ -0,0 +1,69 @@
+"""
+@file copy_make_border.py
+@brief Sample code that shows the functionality of copyMakeBorder
+"""
+import sys
+from random import randint
+import cv2 as cv
+
+
+def main(argv):
+    ## [variables]
+    # First we declare the variables we are going to use
+    borderType = cv.BORDER_CONSTANT
+    window_name = "copyMakeBorder Demo"
+    ## [variables]
+    ## [load]
+    imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
+
+    # Loads an image
+    src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image!')
+        print ('Usage: copy_make_border.py [image_name -- default lena.jpg] \n')
+        return -1
+    ## [load]
+    # Brief how-to for this program
+    print ('\n'
+           '\t 	 copyMakeBorder Demo: \n'
+           '	 -------------------- \n'
+           ' ** Press \'c\' to set the border to a random constant value \n'
+           ' ** Press \'r\' to set the border to be replicated \n'
+           ' ** Press \'ESC\' to exit the program ')
+    ## [create_window]
+    cv.namedWindow(window_name, cv.WINDOW_AUTOSIZE)
+    ## [create_window]
+    ## [init_arguments]
+    # Initialize arguments for the filter
+    top = int(0.05 * src.shape[0])  # shape[0] = rows
+    bottom = top
+    left = int(0.05 * src.shape[1])  # shape[1] = cols
+    right = left
+    ## [init_arguments]
+    while 1:
+        ## [update_value]
+        value = [randint(0, 255), randint(0, 255), randint(0, 255)]
+        ## [update_value]
+        ## [copymakeborder]
+        dst = cv.copyMakeBorder(src, top, bottom, left, right, borderType, None, value)
+        ## [copymakeborder]
+        ## [display]
+        cv.imshow(window_name, dst)
+        ## [display]
+        ## [check_keypress]
+        c = cv.waitKey(500)
+
+        if c == 27:
+            break
+        elif c == 99: # 99 = ord('c')
+            borderType = cv.BORDER_CONSTANT
+        elif c == 114: # 114 = ord('r')
+            borderType = cv.BORDER_REPLICATE
+        ## [check_keypress]
+    return 0
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/SobelDemo/sobel_demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/SobelDemo/sobel_demo.py
new file mode 100644
index 00000000..7c25542f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/SobelDemo/sobel_demo.py
@@ -0,0 +1,74 @@
+"""
+@file sobel_demo.py
+@brief Sample code using Sobel and/or Scharr OpenCV functions to make a simple Edge Detector
+"""
+import sys
+import cv2 as cv
+
+
+def main(argv):
+    ## [variables]
+    # First we declare the variables we are going to use
+    window_name = ('Sobel Demo - Simple Edge Detector')
+    scale = 1
+    delta = 0
+    ddepth = cv.CV_16S
+    ## [variables]
+
+    ## [load]
+    # As usual we load our source image (src)
+    # Check number of arguments
+    if len(argv) < 1:
+        print ('Not enough parameters')
+        print ('Usage:\nmorph_lines_detection.py < path_to_image >')
+        return -1
+
+    # Load the image
+    src = cv.imread(argv[0], cv.IMREAD_COLOR)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image: ' + argv[0])
+        return -1
+    ## [load]
+
+    ## [reduce_noise]
+    # Remove noise by blurring with a Gaussian filter ( kernel size = 3 )
+    src = cv.GaussianBlur(src, (3, 3), 0)
+    ## [reduce_noise]
+
+    ## [convert_to_gray]
+    # Convert the image to grayscale
+    gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    ## [convert_to_gray]
+
+    ## [sobel]
+    # Gradient-X
+    # grad_x = cv.Scharr(gray,ddepth,1,0)
+    grad_x = cv.Sobel(gray, ddepth, 1, 0, ksize=3, scale=scale, delta=delta, borderType=cv.BORDER_DEFAULT)
+
+    # Gradient-Y
+    # grad_y = cv.Scharr(gray,ddepth,0,1)
+    grad_y = cv.Sobel(gray, ddepth, 0, 1, ksize=3, scale=scale, delta=delta, borderType=cv.BORDER_DEFAULT)
+    ## [sobel]
+
+    ## [convert]
+    # converting back to uint8
+    abs_grad_x = cv.convertScaleAbs(grad_x)
+    abs_grad_y = cv.convertScaleAbs(grad_y)
+    ## [convert]
+
+    ## [blend]
+    ## Total Gradient (approximate)
+    grad = cv.addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0)
+    ## [blend]
+
+    ## [display]
+    cv.imshow(window_name, grad)
+    cv.waitKey(0)
+    ## [display]
+
+    return 0
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/canny_detector/CannyDetector_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/canny_detector/CannyDetector_Demo.py
new file mode 100644
index 00000000..39157281
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/canny_detector/CannyDetector_Demo.py
@@ -0,0 +1,34 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+max_lowThreshold = 100
+window_name = 'Edge Map'
+title_trackbar = 'Min Threshold:'
+ratio = 3
+kernel_size = 3
+
+def CannyThreshold(val):
+    low_threshold = val
+    img_blur = cv.blur(src_gray, (3,3))
+    detected_edges = cv.Canny(img_blur, low_threshold, low_threshold*ratio, kernel_size)
+    mask = detected_edges != 0
+    dst = src * (mask[:,:,None].astype(src.dtype))
+    cv.imshow(window_name, dst)
+
+parser = argparse.ArgumentParser(description='Code for Canny Edge Detector tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='fruits.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+cv.namedWindow(window_name)
+cv.createTrackbar(title_trackbar, window_name , 0, max_lowThreshold, CannyThreshold)
+
+CannyThreshold(0)
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py
new file mode 100644
index 00000000..e8add484
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py
@@ -0,0 +1,139 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+## [load_image]
+# Load the image
+parser = argparse.ArgumentParser(description='Code for Image Segmentation with Distance Transform and Watershed Algorithm.\
+    Sample code showing how to segment overlapping objects using Laplacian filtering, \
+    in addition to Watershed and Distance Transformation')
+parser.add_argument('--input', help='Path to input image.', default='cards.png')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Show source image
+cv.imshow('Source Image', src)
+## [load_image]
+
+## [black_bg]
+# Change the background from white to black, since that will help later to extract
+# better results during the use of Distance Transform
+src[np.all(src == 255, axis=2)] = 0
+
+# Show output image
+cv.imshow('Black Background Image', src)
+## [black_bg]
+
+## [sharp]
+# Create a kernel that we will use to sharpen our image
+# an approximation of second derivative, a quite strong kernel
+kernel = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]], dtype=np.float32)
+
+# do the laplacian filtering as it is
+# well, we need to convert everything in something more deeper then CV_8U
+# because the kernel has some negative values,
+# and we can expect in general to have a Laplacian image with negative values
+# BUT a 8bits unsigned int (the one we are working with) can contain values from 0 to 255
+# so the possible negative number will be truncated
+imgLaplacian = cv.filter2D(src, cv.CV_32F, kernel)
+sharp = np.float32(src)
+imgResult = sharp - imgLaplacian
+
+# convert back to 8bits gray scale
+imgResult = np.clip(imgResult, 0, 255)
+imgResult = imgResult.astype('uint8')
+imgLaplacian = np.clip(imgLaplacian, 0, 255)
+imgLaplacian = np.uint8(imgLaplacian)
+
+#cv.imshow('Laplace Filtered Image', imgLaplacian)
+cv.imshow('New Sharped Image', imgResult)
+## [sharp]
+
+## [bin]
+# Create binary image from source image
+bw = cv.cvtColor(imgResult, cv.COLOR_BGR2GRAY)
+_, bw = cv.threshold(bw, 40, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
+cv.imshow('Binary Image', bw)
+## [bin]
+
+## [dist]
+# Perform the distance transform algorithm
+dist = cv.distanceTransform(bw, cv.DIST_L2, 3)
+
+# Normalize the distance image for range = {0.0, 1.0}
+# so we can visualize and threshold it
+cv.normalize(dist, dist, 0, 1.0, cv.NORM_MINMAX)
+cv.imshow('Distance Transform Image', dist)
+## [dist]
+
+## [peaks]
+# Threshold to obtain the peaks
+# This will be the markers for the foreground objects
+_, dist = cv.threshold(dist, 0.4, 1.0, cv.THRESH_BINARY)
+
+# Dilate a bit the dist image
+kernel1 = np.ones((3,3), dtype=np.uint8)
+dist = cv.dilate(dist, kernel1)
+cv.imshow('Peaks', dist)
+## [peaks]
+
+## [seeds]
+# Create the CV_8U version of the distance image
+# It is needed for findContours()
+dist_8u = dist.astype('uint8')
+
+# Find total markers
+contours, _ = cv.findContours(dist_8u, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
+
+# Create the marker image for the watershed algorithm
+markers = np.zeros(dist.shape, dtype=np.int32)
+
+# Draw the foreground markers
+for i in range(len(contours)):
+    cv.drawContours(markers, contours, i, (i+1), -1)
+
+# Draw the background marker
+cv.circle(markers, (5,5), 3, (255,255,255), -1)
+markers_8u = (markers * 10).astype('uint8')
+cv.imshow('Markers', markers_8u)
+## [seeds]
+
+## [watershed]
+# Perform the watershed algorithm
+cv.watershed(imgResult, markers)
+
+#mark = np.zeros(markers.shape, dtype=np.uint8)
+mark = markers.astype('uint8')
+mark = cv.bitwise_not(mark)
+# uncomment this if you want to see how the mark
+# image looks like at that point
+#cv.imshow('Markers_v2', mark)
+
+# Generate random colors
+colors = []
+for contour in contours:
+    colors.append((rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)))
+
+# Create the result image
+dst = np.zeros((markers.shape[0], markers.shape[1], 3), dtype=np.uint8)
+
+# Fill labeled objects with random colors
+for i in range(markers.shape[0]):
+    for j in range(markers.shape[1]):
+        index = markers[i,j]
+        if index > 0 and index <= len(contours):
+            dst[i,j,:] = colors[index-1]
+
+# Visualize the final image
+cv.imshow('Final Result', dst)
+## [watershed]
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/remap/Remap_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/remap/Remap_Demo.py
new file mode 100644
index 00000000..f50aa365
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/remap/Remap_Demo.py
@@ -0,0 +1,65 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+## [Update]
+def update_map(ind, map_x, map_y):
+    if ind == 0:
+        for i in range(map_x.shape[0]):
+            for j in range(map_x.shape[1]):
+                if j > map_x.shape[1]*0.25 and j < map_x.shape[1]*0.75 and i > map_x.shape[0]*0.25 and i < map_x.shape[0]*0.75:
+                    map_x[i,j] = 2 * (j-map_x.shape[1]*0.25) + 0.5
+                    map_y[i,j] = 2 * (i-map_y.shape[0]*0.25) + 0.5
+                else:
+                    map_x[i,j] = 0
+                    map_y[i,j] = 0
+    elif ind == 1:
+        for i in range(map_x.shape[0]):
+            map_x[i,:] = [x for x in range(map_x.shape[1])]
+        for j in range(map_y.shape[1]):
+            map_y[:,j] = [map_y.shape[0]-y for y in range(map_y.shape[0])]
+    elif ind == 2:
+        for i in range(map_x.shape[0]):
+            map_x[i,:] = [map_x.shape[1]-x for x in range(map_x.shape[1])]
+        for j in range(map_y.shape[1]):
+            map_y[:,j] = [y for y in range(map_y.shape[0])]
+    elif ind == 3:
+        for i in range(map_x.shape[0]):
+            map_x[i,:] = [map_x.shape[1]-x for x in range(map_x.shape[1])]
+        for j in range(map_y.shape[1]):
+            map_y[:,j] = [map_y.shape[0]-y for y in range(map_y.shape[0])]
+## [Update]
+
+parser = argparse.ArgumentParser(description='Code for Remapping tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='chicky_512.png')
+args = parser.parse_args()
+
+## [Load]
+src = cv.imread(cv.samples.findFile(args.input), cv.IMREAD_COLOR)
+if src is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+## [Load]
+
+## [Create]
+map_x = np.zeros((src.shape[0], src.shape[1]), dtype=np.float32)
+map_y = np.zeros((src.shape[0], src.shape[1]), dtype=np.float32)
+## [Create]
+
+## [Window]
+window_name = 'Remap demo'
+cv.namedWindow(window_name)
+## [Window]
+
+## [Loop]
+ind = 0
+while True:
+    update_map(ind, map_x, map_y)
+    ind = (ind + 1) % 4
+    dst = cv.remap(src, map_x, map_y, cv.INTER_LINEAR)
+    cv.imshow(window_name, dst)
+    c = cv.waitKey(1000)
+    if c == 27:
+        break
+## [Loop]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/warp_affine/Geometric_Transforms_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/warp_affine/Geometric_Transforms_Demo.py
new file mode 100644
index 00000000..d141470c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ImgTrans/warp_affine/Geometric_Transforms_Demo.py
@@ -0,0 +1,54 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+## [Load the image]
+parser = argparse.ArgumentParser(description='Code for Affine Transformations tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='lena.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+## [Load the image]
+
+## [Set your 3 points to calculate the  Affine Transform]
+srcTri = np.array( [[0, 0], [src.shape[1] - 1, 0], [0, src.shape[0] - 1]] ).astype(np.float32)
+dstTri = np.array( [[0, src.shape[1]*0.33], [src.shape[1]*0.85, src.shape[0]*0.25], [src.shape[1]*0.15, src.shape[0]*0.7]] ).astype(np.float32)
+## [Set your 3 points to calculate the  Affine Transform]
+
+## [Get the Affine Transform]
+warp_mat = cv.getAffineTransform(srcTri, dstTri)
+## [Get the Affine Transform]
+
+## [Apply the Affine Transform just found to the src image]
+warp_dst = cv.warpAffine(src, warp_mat, (src.shape[1], src.shape[0]))
+## [Apply the Affine Transform just found to the src image]
+
+# Rotating the image after Warp
+
+## [Compute a rotation matrix with respect to the center of the image]
+center = (warp_dst.shape[1]//2, warp_dst.shape[0]//2)
+angle = -50
+scale = 0.6
+## [Compute a rotation matrix with respect to the center of the image]
+
+## [Get the rotation matrix with the specifications above]
+rot_mat = cv.getRotationMatrix2D( center, angle, scale )
+## [Get the rotation matrix with the specifications above]
+
+## [Rotate the warped image]
+warp_rotate_dst = cv.warpAffine(warp_dst, rot_mat, (warp_dst.shape[1], warp_dst.shape[0]))
+## [Rotate the warped image]
+
+## [Show what you got]
+cv.imshow('Source image', src)
+cv.imshow('Warp', warp_dst)
+cv.imshow('Warp + Rotate', warp_rotate_dst)
+## [Show what you got]
+
+## [Wait until user exits the program]
+cv.waitKey()
+## [Wait until user exits the program]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/bounding_rects_circles/generalContours_demo1.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/bounding_rects_circles/generalContours_demo1.py
new file mode 100644
index 00000000..0f6cb8ec
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/bounding_rects_circles/generalContours_demo1.py
@@ -0,0 +1,82 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+def thresh_callback(val):
+    threshold = val
+
+    ## [Canny]
+    # Detect edges using Canny
+    canny_output = cv.Canny(src_gray, threshold, threshold * 2)
+    ## [Canny]
+
+    ## [findContours]
+    # Find contours
+    contours, _ = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+    ## [findContours]
+
+    ## [allthework]
+    # Approximate contours to polygons + get bounding rects and circles
+    contours_poly = [None]*len(contours)
+    boundRect = [None]*len(contours)
+    centers = [None]*len(contours)
+    radius = [None]*len(contours)
+    for i, c in enumerate(contours):
+        contours_poly[i] = cv.approxPolyDP(c, 3, True)
+        boundRect[i] = cv.boundingRect(contours_poly[i])
+        centers[i], radius[i] = cv.minEnclosingCircle(contours_poly[i])
+    ## [allthework]
+
+    ## [zeroMat]
+    drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
+    ## [zeroMat]
+
+    ## [forContour]
+    # Draw polygonal contour + bonding rects + circles
+    for i in range(len(contours)):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        cv.drawContours(drawing, contours_poly, i, color)
+        cv.rectangle(drawing, (int(boundRect[i][0]), int(boundRect[i][1])), \
+          (int(boundRect[i][0]+boundRect[i][2]), int(boundRect[i][1]+boundRect[i][3])), color, 2)
+        cv.circle(drawing, (int(centers[i][0]), int(centers[i][1])), int(radius[i]), color, 2)
+    ## [forContour]
+
+    ## [showDrawings]
+    # Show in a window
+    cv.imshow('Contours', drawing)
+    ## [showDrawings]
+
+## [setup]
+# Load source image
+parser = argparse.ArgumentParser(description='Code for Creating Bounding boxes and circles for contours tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='stuff.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Convert image to gray and blur it
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+src_gray = cv.blur(src_gray, (3,3))
+## [setup]
+
+## [createWindow]
+# Create Window
+source_window = 'Source'
+cv.namedWindow(source_window)
+cv.imshow(source_window, src)
+## [createWindow]
+## [trackbar]
+max_thresh = 255
+thresh = 100 # initial threshold
+cv.createTrackbar('Canny thresh:', source_window, thresh, max_thresh, thresh_callback)
+thresh_callback(thresh)
+## [trackbar]
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/bounding_rotated_ellipses/generalContours_demo2.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/bounding_rotated_ellipses/generalContours_demo2.py
new file mode 100644
index 00000000..3d123f05
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/bounding_rotated_ellipses/generalContours_demo2.py
@@ -0,0 +1,82 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+def thresh_callback(val):
+    threshold = val
+
+    ## [Canny]
+    # Detect edges using Canny
+    canny_output = cv.Canny(src_gray, threshold, threshold * 2)
+    ## [Canny]
+
+    ## [findContours]
+    # Find contours
+    contours, _ = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+    ## [findContours]
+
+    # Find the rotated rectangles and ellipses for each contour
+    minRect = [None]*len(contours)
+    minEllipse = [None]*len(contours)
+    for i, c in enumerate(contours):
+        minRect[i] = cv.minAreaRect(c)
+        if c.shape[0] > 5:
+            minEllipse[i] = cv.fitEllipse(c)
+
+    # Draw contours + rotated rects + ellipses
+    ## [zeroMat]
+    drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
+    ## [zeroMat]
+    ## [forContour]
+    for i, c in enumerate(contours):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        # contour
+        cv.drawContours(drawing, contours, i, color)
+        # ellipse
+        if c.shape[0] > 5:
+            cv.ellipse(drawing, minEllipse[i], color, 2)
+        # rotated rectangle
+        box = cv.boxPoints(minRect[i])
+        box = np.intp(box) #np.intp: Integer used for indexing (same as C ssize_t; normally either int32 or int64)
+        cv.drawContours(drawing, [box], 0, color)
+    ## [forContour]
+
+    ## [showDrawings]
+    # Show in a window
+    cv.imshow('Contours', drawing)
+    ## [showDrawings]
+
+## [setup]
+# Load source image
+parser = argparse.ArgumentParser(description='Code for Creating Bounding rotated boxes and ellipses for contours tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='stuff.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Convert image to gray and blur it
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+src_gray = cv.blur(src_gray, (3,3))
+## [setup]
+
+## [createWindow]
+# Create Window
+source_window = 'Source'
+cv.namedWindow(source_window)
+cv.imshow(source_window, src)
+## [createWindow]
+## [trackbar]
+max_thresh = 255
+thresh = 100 # initial threshold
+cv.createTrackbar('Canny Thresh:', source_window, thresh, max_thresh, thresh_callback)
+thresh_callback(thresh)
+## [trackbar]
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/find_contours/findContours_demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/find_contours/findContours_demo.py
new file mode 100644
index 00000000..c4480a65
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/find_contours/findContours_demo.py
@@ -0,0 +1,50 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+def thresh_callback(val):
+    threshold = val
+
+    # Detect edges using Canny
+    canny_output = cv.Canny(src_gray, threshold, threshold * 2)
+
+    # Find contours
+    contours, hierarchy = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+
+    # Draw contours
+    drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
+    for i in range(len(contours)):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        cv.drawContours(drawing, contours, i, color, 2, cv.LINE_8, hierarchy, 0)
+
+    # Show in a window
+    cv.imshow('Contours', drawing)
+
+# Load source image
+parser = argparse.ArgumentParser(description='Code for Finding contours in your image tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='HappyFish.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Convert image to gray and blur it
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+src_gray = cv.blur(src_gray, (3,3))
+
+# Create Window
+source_window = 'Source'
+cv.namedWindow(source_window)
+cv.imshow(source_window, src)
+max_thresh = 255
+thresh = 100 # initial threshold
+cv.createTrackbar('Canny Thresh:', source_window, thresh, max_thresh, thresh_callback)
+thresh_callback(thresh)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/hull/hull_demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/hull/hull_demo.py
new file mode 100644
index 00000000..cd00131c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/hull/hull_demo.py
@@ -0,0 +1,57 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+def thresh_callback(val):
+    threshold = val
+
+    # Detect edges using Canny
+    canny_output = cv.Canny(src_gray, threshold, threshold * 2)
+
+    # Find contours
+    contours, _ = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+
+    # Find the convex hull object for each contour
+    hull_list = []
+    for i in range(len(contours)):
+        hull = cv.convexHull(contours[i])
+        hull_list.append(hull)
+
+    # Draw contours + hull results
+    drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
+    for i in range(len(contours)):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        cv.drawContours(drawing, contours, i, color)
+        cv.drawContours(drawing, hull_list, i, color)
+
+    # Show in a window
+    cv.imshow('Contours', drawing)
+
+# Load source image
+parser = argparse.ArgumentParser(description='Code for Convex Hull tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='stuff.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Convert image to gray and blur it
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+src_gray = cv.blur(src_gray, (3,3))
+
+# Create Window
+source_window = 'Source'
+cv.namedWindow(source_window)
+cv.imshow(source_window, src)
+max_thresh = 255
+thresh = 100 # initial threshold
+cv.createTrackbar('Canny thresh:', source_window, thresh, max_thresh, thresh_callback)
+thresh_callback(thresh)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/moments/moments_demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/moments/moments_demo.py
new file mode 100644
index 00000000..eac12c8a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/moments/moments_demo.py
@@ -0,0 +1,83 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+def thresh_callback(val):
+    threshold = val
+
+    ## [Canny]
+    # Detect edges using Canny
+    canny_output = cv.Canny(src_gray, threshold, threshold * 2)
+    ## [Canny]
+
+    ## [findContours]
+    # Find contours
+    contours, _ = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+    ## [findContours]
+
+    # Get the moments
+    mu = [None]*len(contours)
+    for i in range(len(contours)):
+        mu[i] = cv.moments(contours[i])
+
+    # Get the mass centers
+    mc = [None]*len(contours)
+    for i in range(len(contours)):
+        # add 1e-5 to avoid division by zero
+        mc[i] = (mu[i]['m10'] / (mu[i]['m00'] + 1e-5), mu[i]['m01'] / (mu[i]['m00'] + 1e-5))
+
+    # Draw contours
+    ## [zeroMat]
+    drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
+    ## [zeroMat]
+    ## [forContour]
+    for i in range(len(contours)):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        cv.drawContours(drawing, contours, i, color, 2)
+        cv.circle(drawing, (int(mc[i][0]), int(mc[i][1])), 4, color, -1)
+    ## [forContour]
+
+    ## [showDrawings]
+    # Show in a window
+    cv.imshow('Contours', drawing)
+    ## [showDrawings]
+
+    # Calculate the area with the moments 00 and compare with the result of the OpenCV function
+    for i in range(len(contours)):
+        print(' * Contour[%d] - Area (M_00) = %.2f - Area OpenCV: %.2f - Length: %.2f' % (i, mu[i]['m00'], cv.contourArea(contours[i]), cv.arcLength(contours[i], True)))
+
+## [setup]
+# Load source image
+parser = argparse.ArgumentParser(description='Code for Image Moments tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='stuff.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Convert image to gray and blur it
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+src_gray = cv.blur(src_gray, (3,3))
+## [setup]
+
+## [createWindow]
+# Create Window
+source_window = 'Source'
+cv.namedWindow(source_window)
+cv.imshow(source_window, src)
+## [createWindow]
+## [trackbar]
+max_thresh = 255
+thresh = 100 # initial threshold
+cv.createTrackbar('Canny Thresh:', source_window, thresh, max_thresh, thresh_callback)
+thresh_callback(thresh)
+## [trackbar]
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/point_polygon_test/pointPolygonTest_demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/point_polygon_test/pointPolygonTest_demo.py
new file mode 100644
index 00000000..3b50a5b7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ShapeDescriptors/point_polygon_test/pointPolygonTest_demo.py
@@ -0,0 +1,52 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+
+# Create an image
+r = 100
+src = np.zeros((4*r, 4*r), dtype=np.uint8)
+
+# Create a sequence of points to make a contour
+vert = [None]*6
+vert[0] = (3*r//2, int(1.34*r))
+vert[1] = (1*r, 2*r)
+vert[2] = (3*r//2, int(2.866*r))
+vert[3] = (5*r//2, int(2.866*r))
+vert[4] = (3*r, 2*r)
+vert[5] = (5*r//2, int(1.34*r))
+
+# Draw it in src
+for i in range(6):
+    cv.line(src, vert[i],  vert[(i+1)%6], ( 255 ), 3)
+
+# Get the contours
+contours, _ = cv.findContours(src, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+
+# Calculate the distances to the contour
+raw_dist = np.empty(src.shape, dtype=np.float32)
+for i in range(src.shape[0]):
+    for j in range(src.shape[1]):
+        raw_dist[i,j] = cv.pointPolygonTest(contours[0], (j,i), True)
+
+minVal, maxVal, _, maxDistPt = cv.minMaxLoc(raw_dist)
+minVal = abs(minVal)
+maxVal = abs(maxVal)
+
+# Depicting the  distances graphically
+drawing = np.zeros((src.shape[0], src.shape[1], 3), dtype=np.uint8)
+for i in range(src.shape[0]):
+    for j in range(src.shape[1]):
+        if raw_dist[i,j] < 0:
+            drawing[i,j,0] = 255 - abs(raw_dist[i,j]) * 255 / minVal
+        elif raw_dist[i,j] > 0:
+            drawing[i,j,2] = 255 - raw_dist[i,j] * 255 / maxVal
+        else:
+            drawing[i,j,0] = 255
+            drawing[i,j,1] = 255
+            drawing[i,j,2] = 255
+
+cv.circle(drawing,maxDistPt, int(maxVal),(255,255,255), 1, cv.LINE_8, 0)
+cv.imshow('Source', src)
+cv.imshow('Distance and inscribed circle', drawing)
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/corner_subpixels/cornerSubPix_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/corner_subpixels/cornerSubPix_Demo.py
new file mode 100644
index 00000000..37e38abd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/corner_subpixels/cornerSubPix_Demo.py
@@ -0,0 +1,70 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+source_window = 'Image'
+maxTrackbar = 25
+rng.seed(12345)
+
+def goodFeaturesToTrack_Demo(val):
+    maxCorners = max(val, 1)
+
+    # Parameters for Shi-Tomasi algorithm
+    qualityLevel = 0.01
+    minDistance = 10
+    blockSize = 3
+    gradientSize = 3
+    useHarrisDetector = False
+    k = 0.04
+
+    # Copy the source image
+    copy = np.copy(src)
+
+    # Apply corner detection
+    corners = cv.goodFeaturesToTrack(src_gray, maxCorners, qualityLevel, minDistance, None, \
+        blockSize=blockSize, gradientSize=gradientSize, useHarrisDetector=useHarrisDetector, k=k)
+
+    # Draw corners detected
+    print('** Number of corners detected:', corners.shape[0])
+    radius = 4
+    for i in range(corners.shape[0]):
+        cv.circle(copy, (int(corners[i,0,0]), int(corners[i,0,1])), radius, (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)), cv.FILLED)
+
+    # Show what you got
+    cv.namedWindow(source_window)
+    cv.imshow(source_window, copy)
+
+    # Set the needed parameters to find the refined corners
+    winSize = (5, 5)
+    zeroZone = (-1, -1)
+    criteria = (cv.TERM_CRITERIA_EPS + cv.TermCriteria_COUNT, 40, 0.001)
+
+    # Calculate the refined corner locations
+    corners = cv.cornerSubPix(src_gray, corners, winSize, zeroZone, criteria)
+
+    # Write them down
+    for i in range(corners.shape[0]):
+        print(" -- Refined Corner [", i, "]  (", corners[i,0,0], ",", corners[i,0,1], ")")
+
+# Load source image and convert it to gray
+parser = argparse.ArgumentParser(description='Code for Shi-Tomasi corner detector tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='pic3.png')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+# Create a window and a trackbar
+cv.namedWindow(source_window)
+maxCorners = 10 # initial threshold
+cv.createTrackbar('Threshold: ', source_window, maxCorners, maxTrackbar, goodFeaturesToTrack_Demo)
+cv.imshow(source_window, src)
+goodFeaturesToTrack_Demo(maxCorners)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/generic_corner_detector/cornerDetector_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/generic_corner_detector/cornerDetector_Demo.py
new file mode 100644
index 00000000..65330787
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/generic_corner_detector/cornerDetector_Demo.py
@@ -0,0 +1,80 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+myHarris_window = 'My Harris corner detector'
+myShiTomasi_window = 'My Shi Tomasi corner detector'
+myHarris_qualityLevel = 50
+myShiTomasi_qualityLevel = 50
+max_qualityLevel = 100
+rng.seed(12345)
+
+def myHarris_function(val):
+    myHarris_copy = np.copy(src)
+    myHarris_qualityLevel = max(val, 1)
+
+    for i in range(src_gray.shape[0]):
+        for j in range(src_gray.shape[1]):
+            if Mc[i,j] > myHarris_minVal + ( myHarris_maxVal - myHarris_minVal )*myHarris_qualityLevel/max_qualityLevel:
+                cv.circle(myHarris_copy, (j,i), 4, (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)), cv.FILLED)
+
+    cv.imshow(myHarris_window, myHarris_copy)
+
+def myShiTomasi_function(val):
+    myShiTomasi_copy = np.copy(src)
+    myShiTomasi_qualityLevel = max(val, 1)
+
+    for i in range(src_gray.shape[0]):
+        for j in range(src_gray.shape[1]):
+            if myShiTomasi_dst[i,j] > myShiTomasi_minVal + ( myShiTomasi_maxVal - myShiTomasi_minVal )*myShiTomasi_qualityLevel/max_qualityLevel:
+                cv.circle(myShiTomasi_copy, (j,i), 4, (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)), cv.FILLED)
+
+    cv.imshow(myShiTomasi_window, myShiTomasi_copy)
+
+# Load source image and convert it to gray
+parser = argparse.ArgumentParser(description='Code for Creating your own corner detector tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='building.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+# Set some parameters
+blockSize = 3
+apertureSize = 3
+
+# My Harris matrix -- Using cornerEigenValsAndVecs
+myHarris_dst = cv.cornerEigenValsAndVecs(src_gray, blockSize, apertureSize)
+
+# calculate Mc
+Mc = np.empty(src_gray.shape, dtype=np.float32)
+for i in range(src_gray.shape[0]):
+    for j in range(src_gray.shape[1]):
+        lambda_1 = myHarris_dst[i,j,0]
+        lambda_2 = myHarris_dst[i,j,1]
+        Mc[i,j] = lambda_1*lambda_2 - 0.04*pow( ( lambda_1 + lambda_2 ), 2 )
+
+myHarris_minVal, myHarris_maxVal, _, _ = cv.minMaxLoc(Mc)
+
+# Create Window and Trackbar
+cv.namedWindow(myHarris_window)
+cv.createTrackbar('Quality Level:', myHarris_window, myHarris_qualityLevel, max_qualityLevel, myHarris_function)
+myHarris_function(myHarris_qualityLevel)
+
+# My Shi-Tomasi -- Using cornerMinEigenVal
+myShiTomasi_dst = cv.cornerMinEigenVal(src_gray, blockSize, apertureSize)
+
+myShiTomasi_minVal, myShiTomasi_maxVal, _, _ = cv.minMaxLoc(myShiTomasi_dst)
+
+# Create Window and Trackbar
+cv.namedWindow(myShiTomasi_window)
+cv.createTrackbar('Quality Level:', myShiTomasi_window, myShiTomasi_qualityLevel, max_qualityLevel, myShiTomasi_function)
+myShiTomasi_function(myShiTomasi_qualityLevel)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/good_features_to_track/goodFeaturesToTrack_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/good_features_to_track/goodFeaturesToTrack_Demo.py
new file mode 100644
index 00000000..ef082bdd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/good_features_to_track/goodFeaturesToTrack_Demo.py
@@ -0,0 +1,58 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+source_window = 'Image'
+maxTrackbar = 100
+rng.seed(12345)
+
+def goodFeaturesToTrack_Demo(val):
+    maxCorners = max(val, 1)
+
+    # Parameters for Shi-Tomasi algorithm
+    qualityLevel = 0.01
+    minDistance = 10
+    blockSize = 3
+    gradientSize = 3
+    useHarrisDetector = False
+    k = 0.04
+
+    # Copy the source image
+    copy = np.copy(src)
+
+    # Apply corner detection
+    corners = cv.goodFeaturesToTrack(src_gray, maxCorners, qualityLevel, minDistance, None, \
+        blockSize=blockSize, gradientSize=gradientSize, useHarrisDetector=useHarrisDetector, k=k)
+
+    # Draw corners detected
+    print('** Number of corners detected:', corners.shape[0])
+    radius = 4
+    for i in range(corners.shape[0]):
+        cv.circle(copy, (int(corners[i,0,0]), int(corners[i,0,1])), radius, (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)), cv.FILLED)
+
+    # Show what you got
+    cv.namedWindow(source_window)
+    cv.imshow(source_window, copy)
+
+# Load source image and convert it to gray
+parser = argparse.ArgumentParser(description='Code for Shi-Tomasi corner detector tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='pic3.png')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+# Create a window and a trackbar
+cv.namedWindow(source_window)
+maxCorners = 23 # initial threshold
+cv.createTrackbar('Threshold: ', source_window, maxCorners, maxTrackbar, goodFeaturesToTrack_Demo)
+cv.imshow(source_window, src)
+goodFeaturesToTrack_Demo(maxCorners)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/harris_detector/cornerHarris_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/harris_detector/cornerHarris_Demo.py
new file mode 100644
index 00000000..63d765f2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/TrackingMotion/harris_detector/cornerHarris_Demo.py
@@ -0,0 +1,55 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+source_window = 'Source image'
+corners_window = 'Corners detected'
+max_thresh = 255
+
+def cornerHarris_demo(val):
+    thresh = val
+
+    # Detector parameters
+    blockSize = 2
+    apertureSize = 3
+    k = 0.04
+
+    # Detecting corners
+    dst = cv.cornerHarris(src_gray, blockSize, apertureSize, k)
+
+    # Normalizing
+    dst_norm = np.empty(dst.shape, dtype=np.float32)
+    cv.normalize(dst, dst_norm, alpha=0, beta=255, norm_type=cv.NORM_MINMAX)
+    dst_norm_scaled = cv.convertScaleAbs(dst_norm)
+
+    # Drawing a circle around corners
+    for i in range(dst_norm.shape[0]):
+        for j in range(dst_norm.shape[1]):
+            if int(dst_norm[i,j]) > thresh:
+                cv.circle(dst_norm_scaled, (j,i), 5, (0), 2)
+
+    # Showing the result
+    cv.namedWindow(corners_window)
+    cv.imshow(corners_window, dst_norm_scaled)
+
+# Load source image and convert it to gray
+parser = argparse.ArgumentParser(description='Code for Harris corner detector tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='building.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+# Create a window and a trackbar
+cv.namedWindow(source_window)
+thresh = 200 # initial threshold
+cv.createTrackbar('Threshold: ', source_window, thresh, max_thresh, cornerHarris_demo)
+cv.imshow(source_window, src)
+cornerHarris_demo(thresh)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/core/AddingImages/adding_images.py b/C++/opencv-4.7.0/samples/python/tutorial_code/core/AddingImages/adding_images.py
new file mode 100644
index 00000000..928686d1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/core/AddingImages/adding_images.py
@@ -0,0 +1,36 @@
+from __future__ import print_function
+
+import cv2 as cv
+
+alpha = 0.5
+
+try:
+    raw_input          # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+print(''' Simple Linear Blender
+-----------------------
+* Enter alpha [0.0-1.0]: ''')
+input_alpha = float(raw_input().strip())
+if 0 <= alpha <= 1:
+    alpha = input_alpha
+# [load]
+src1 = cv.imread(cv.samples.findFile('LinuxLogo.jpg'))
+src2 = cv.imread(cv.samples.findFile('WindowsLogo.jpg'))
+# [load]
+if src1 is None:
+    print("Error loading src1")
+    exit(-1)
+elif src2 is None:
+    print("Error loading src2")
+    exit(-1)
+# [blend_images]
+beta = (1.0 - alpha)
+dst = cv.addWeighted(src1, alpha, src2, beta, 0.0)
+# [blend_images]
+# [display]
+cv.imshow('dst', dst)
+cv.waitKey(0)
+# [display]
+cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.py b/C++/opencv-4.7.0/samples/python/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.py
new file mode 100644
index 00000000..a89a1097
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.py
@@ -0,0 +1,80 @@
+from __future__ import print_function
+import sys
+
+import cv2 as cv
+import numpy as np
+
+
+def print_help():
+    print('''
+    This program demonstrated the use of the discrete Fourier transform (DFT).
+    The dft of an image is taken and it's power spectrum is displayed.
+    Usage:
+    discrete_fourier_transform.py [image_name -- default lena.jpg]''')
+
+
+def main(argv):
+
+    print_help()
+
+    filename = argv[0] if len(argv) > 0 else 'lena.jpg'
+
+    I = cv.imread(cv.samples.findFile(filename), cv.IMREAD_GRAYSCALE)
+    if I is None:
+        print('Error opening image')
+        return -1
+    ## [expand]
+    rows, cols = I.shape
+    m = cv.getOptimalDFTSize( rows )
+    n = cv.getOptimalDFTSize( cols )
+    padded = cv.copyMakeBorder(I, 0, m - rows, 0, n - cols, cv.BORDER_CONSTANT, value=[0, 0, 0])
+    ## [expand]
+    ## [complex_and_real]
+    planes = [np.float32(padded), np.zeros(padded.shape, np.float32)]
+    complexI = cv.merge(planes)         # Add to the expanded another plane with zeros
+    ## [complex_and_real]
+    ## [dft]
+    cv.dft(complexI, complexI)         # this way the result may fit in the source matrix
+    ## [dft]
+    # compute the magnitude and switch to logarithmic scale
+    # = > log(1 + sqrt(Re(DFT(I)) ^ 2 + Im(DFT(I)) ^ 2))
+    ## [magnitude]
+    cv.split(complexI, planes)                   # planes[0] = Re(DFT(I), planes[1] = Im(DFT(I))
+    cv.magnitude(planes[0], planes[1], planes[0])# planes[0] = magnitude
+    magI = planes[0]
+    ## [magnitude]
+    ## [log]
+    matOfOnes = np.ones(magI.shape, dtype=magI.dtype)
+    cv.add(matOfOnes, magI, magI) #  switch to logarithmic scale
+    cv.log(magI, magI)
+    ## [log]
+    ## [crop_rearrange]
+    magI_rows, magI_cols = magI.shape
+    # crop the spectrum, if it has an odd number of rows or columns
+    magI = magI[0:(magI_rows & -2), 0:(magI_cols & -2)]
+    cx = int(magI_rows/2)
+    cy = int(magI_cols/2)
+
+    q0 = magI[0:cx, 0:cy]         # Top-Left - Create a ROI per quadrant
+    q1 = magI[cx:cx+cx, 0:cy]     # Top-Right
+    q2 = magI[0:cx, cy:cy+cy]     # Bottom-Left
+    q3 = magI[cx:cx+cx, cy:cy+cy] # Bottom-Right
+
+    tmp = np.copy(q0)               # swap quadrants (Top-Left with Bottom-Right)
+    magI[0:cx, 0:cy] = q3
+    magI[cx:cx + cx, cy:cy + cy] = tmp
+
+    tmp = np.copy(q1)               # swap quadrant (Top-Right with Bottom-Left)
+    magI[cx:cx + cx, 0:cy] = q2
+    magI[0:cx, cy:cy + cy] = tmp
+    ## [crop_rearrange]
+    ## [normalize]
+    cv.normalize(magI, magI, 0, 1, cv.NORM_MINMAX) # Transform the matrix with float values into a
+    ## viewable image form(float between values 0 and 1).
+    ## [normalize]
+    cv.imshow("Input Image"       , I   )    # Show the result
+    cv.imshow("spectrum magnitude", magI)
+    cv.waitKey()
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/core/file_input_output/file_input_output.py b/C++/opencv-4.7.0/samples/python/tutorial_code/core/file_input_output/file_input_output.py
new file mode 100644
index 00000000..66b3108d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/core/file_input_output/file_input_output.py
@@ -0,0 +1,157 @@
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+import sys
+
+def help(filename):
+    print (
+        '''
+        {0} shows the usage of the OpenCV serialization functionality. \n\n
+        usage:\n
+            python3 {0} outputfile.yml.gz\n\n
+        The output file may be either in XML, YAML or JSON. You can even compress it\n
+        by specifying this in its extension like xml.gz yaml.gz etc... With\n
+        FileStorage you can serialize objects in OpenCV.\n\n
+        For example: - create a class and have it serialized\n
+                     - use it to read and write matrices.\n
+        '''.format(filename)
+    )
+
+class MyData:
+    A = 97
+    X = np.pi
+    name = 'mydata1234'
+
+    def __repr__(self):
+        s = '{ name = ' + self.name + ', X = ' + str(self.X)
+        s = s + ', A = ' +  str(self.A) + '}'
+        return s
+
+    ## [inside]
+    def write(self, fs, name):
+        fs.startWriteStruct(name, cv.FileNode_MAP|cv.FileNode_FLOW)
+        fs.write('A', self.A)
+        fs.write('X', self.X)
+        fs.write('name', self.name)
+        fs.endWriteStruct()
+
+    def read(self, node):
+        if (not node.empty()):
+            self.A = int(node.getNode('A').real())
+            self.X = node.getNode('X').real()
+            self.name = node.getNode('name').string()
+        else:
+            self.A = self.X = 0
+            self.name = ''
+    ## [inside]
+
+def main(argv):
+    if len(argv) != 2:
+        help(argv[0])
+        exit(1)
+
+    # write
+    ## [iomati]
+    R = np.eye(3,3)
+    T = np.zeros((3,1))
+    ## [iomati]
+    ## [customIOi]
+    m = MyData()
+    ## [customIOi]
+
+    filename = argv[1]
+
+    ## [open]
+    s = cv.FileStorage(filename, cv.FileStorage_WRITE)
+    # or:
+    # s = cv.FileStorage()
+    # s.open(filename, cv.FileStorage_WRITE)
+    ## [open]
+
+    ## [writeNum]
+    s.write('iterationNr', 100)
+    ## [writeNum]
+
+    ## [writeStr]
+    s.startWriteStruct('strings', cv.FileNode_SEQ)
+    for elem in ['image1.jpg', 'Awesomeness', '../data/baboon.jpg']:
+        s.write('', elem)
+    s.endWriteStruct()
+    ## [writeStr]
+
+    ## [writeMap]
+    s.startWriteStruct('Mapping', cv.FileNode_MAP)
+    s.write('One', 1)
+    s.write('Two', 2)
+    s.endWriteStruct()
+    ## [writeMap]
+
+    ## [iomatw]
+    s.write('R_MAT', R)
+    s.write('T_MAT', T)
+    ## [iomatw]
+
+    ## [customIOw]
+    m.write(s, 'MyData')
+    ## [customIOw]
+    ## [close]
+    s.release()
+    ## [close]
+    print ('Write Done.')
+
+    # read
+    print ('\nReading: ')
+    s = cv.FileStorage()
+    s.open(filename, cv.FileStorage_READ)
+
+    ## [readNum]
+    n = s.getNode('iterationNr')
+    itNr = int(n.real())
+    ## [readNum]
+    print (itNr)
+
+    if (not s.isOpened()):
+        print ('Failed to open ', filename, file=sys.stderr)
+        help(argv[0])
+        exit(1)
+
+    ## [readStr]
+    n = s.getNode('strings')
+    if (not n.isSeq()):
+        print ('strings is not a sequence! FAIL', file=sys.stderr)
+        exit(1)
+
+    for i in range(n.size()):
+        print (n.at(i).string())
+    ## [readStr]
+
+    ## [readMap]
+    n = s.getNode('Mapping')
+    print ('Two',int(n.getNode('Two').real()),'; ')
+    print ('One',int(n.getNode('One').real()),'\n')
+    ## [readMap]
+
+    ## [iomat]
+    R = s.getNode('R_MAT').mat()
+    T = s.getNode('T_MAT').mat()
+    ## [iomat]
+    ## [customIO]
+    m.read(s.getNode('MyData'))
+    ## [customIO]
+
+    print ('\nR =',R)
+    print ('T =',T,'\n')
+    print ('MyData =','\n',m,'\n')
+
+    ## [nonexist]
+    print ('Attempt to read NonExisting (should initialize the data structure',
+            'with its default).')
+    m.read(s.getNode('NonExisting'))
+    print ('\nNonExisting =','\n',m)
+    ## [nonexist]
+
+    print ('\nTip: Open up',filename,'with a text editor to see the serialized data.')
+
+if __name__ == '__main__':
+    main(sys.argv)
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/core/mat_mask_operations/mat_mask_operations.py b/C++/opencv-4.7.0/samples/python/tutorial_code/core/mat_mask_operations/mat_mask_operations.py
new file mode 100644
index 00000000..ccbed22c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/core/mat_mask_operations/mat_mask_operations.py
@@ -0,0 +1,100 @@
+from __future__ import print_function
+import sys
+import time
+
+import numpy as np
+import cv2 as cv
+
+## [basic_method]
+def is_grayscale(my_image):
+    return len(my_image.shape) < 3
+
+
+def saturated(sum_value):
+    if sum_value > 255:
+        sum_value = 255
+    if sum_value < 0:
+        sum_value = 0
+
+    return sum_value
+
+
+def sharpen(my_image):
+    if is_grayscale(my_image):
+        height, width = my_image.shape
+    else:
+        my_image = cv.cvtColor(my_image, cv.CV_8U)
+        height, width, n_channels = my_image.shape
+
+    result = np.zeros(my_image.shape, my_image.dtype)
+    ## [basic_method_loop]
+    for j in range(1, height - 1):
+        for i in range(1, width - 1):
+            if is_grayscale(my_image):
+                sum_value = 5 * my_image[j, i] - my_image[j + 1, i] - my_image[j - 1, i] \
+                            - my_image[j, i + 1] - my_image[j, i - 1]
+                result[j, i] = saturated(sum_value)
+            else:
+                for k in range(0, n_channels):
+                    sum_value = 5 * my_image[j, i, k] - my_image[j + 1, i, k]  \
+                                - my_image[j - 1, i, k] - my_image[j, i + 1, k]\
+                                - my_image[j, i - 1, k]
+                    result[j, i, k] = saturated(sum_value)
+    ## [basic_method_loop]
+    return result
+## [basic_method]
+
+def main(argv):
+    filename = 'lena.jpg'
+
+    img_codec = cv.IMREAD_COLOR
+    if argv:
+        filename = sys.argv[1]
+        if len(argv) >= 2 and sys.argv[2] == "G":
+            img_codec = cv.IMREAD_GRAYSCALE
+
+    src = cv.imread(cv.samples.findFile(filename), img_codec)
+
+    if src is None:
+        print("Can't open image [" + filename + "]")
+        print("Usage:")
+        print("mat_mask_operations.py [image_path -- default lena.jpg] [G -- grayscale]")
+        return -1
+
+    cv.namedWindow("Input", cv.WINDOW_AUTOSIZE)
+    cv.namedWindow("Output", cv.WINDOW_AUTOSIZE)
+
+    cv.imshow("Input", src)
+    t = round(time.time())
+
+    dst0 = sharpen(src)
+
+    t = (time.time() - t)
+    print("Hand written function time passed in seconds: %s" % t)
+
+    cv.imshow("Output", dst0)
+    cv.waitKey()
+
+    t = time.time()
+    ## [kern]
+    kernel = np.array([[0, -1, 0],
+                       [-1, 5, -1],
+                       [0, -1, 0]], np.float32)  # kernel should be floating point type
+    ## [kern]
+    ## [filter2D]
+    dst1 = cv.filter2D(src, -1, kernel)
+    # ddepth = -1, means destination image has depth same as input image
+    ## [filter2D]
+
+    t = (time.time() - t)
+    print("Built-in filter2D time passed in seconds:     %s" % t)
+
+    cv.imshow("Output", dst1)
+
+    cv.waitKey(0)
+    cv.destroyAllWindows()
+    return 0
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/core/mat_operations/mat_operations.py b/C++/opencv-4.7.0/samples/python/tutorial_code/core/mat_operations/mat_operations.py
new file mode 100644
index 00000000..f237074f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/core/mat_operations/mat_operations.py
@@ -0,0 +1,92 @@
+from __future__ import division
+import cv2 as cv
+import numpy as np
+
+# Snippet code for Operations with images tutorial (not intended to be run)
+
+def load():
+    # Input/Output
+    filename = 'img.jpg'
+    ## [Load an image from a file]
+    img = cv.imread(filename)
+    ## [Load an image from a file]
+
+    ## [Load an image from a file in grayscale]
+    img = cv.imread(filename, cv.IMREAD_GRAYSCALE)
+    ## [Load an image from a file in grayscale]
+
+    ## [Save image]
+    cv.imwrite(filename, img)
+    ## [Save image]
+
+def access_pixel():
+    # Accessing pixel intensity values
+    img = np.empty((4,4,3), np.uint8)
+    y = 0
+    x = 0
+    ## [Pixel access 1]
+    _intensity = img[y,x]
+    ## [Pixel access 1]
+
+    ## [Pixel access 3]
+    _blue = img[y,x,0]
+    _green = img[y,x,1]
+    _red = img[y,x,2]
+    ## [Pixel access 3]
+
+    ## [Pixel access 5]
+    img[y,x] = 128
+    ## [Pixel access 5]
+
+def reference_counting():
+    # Memory management and reference counting
+    ## [Reference counting 2]
+    img = cv.imread('image.jpg')
+    _img1 = np.copy(img)
+    ## [Reference counting 2]
+
+    ## [Reference counting 3]
+    img = cv.imread('image.jpg')
+    _sobelx = cv.Sobel(img, cv.CV_32F, 1, 0)
+    ## [Reference counting 3]
+
+def primitive_operations():
+    img = np.empty((4,4,3), np.uint8)
+    ## [Set image to black]
+    img[:] = 0
+    ## [Set image to black]
+
+    ## [Select ROI]
+    _smallImg = img[10:110,10:110]
+    ## [Select ROI]
+
+    ## [BGR to Gray]
+    img = cv.imread('image.jpg')
+    _grey = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+    ## [BGR to Gray]
+
+    src = np.ones((4,4), np.uint8)
+    ## [Convert to CV_32F]
+    _dst = src.astype(np.float32)
+    ## [Convert to CV_32F]
+
+def visualize_images():
+    ## [imshow 1]
+    img = cv.imread('image.jpg')
+    cv.namedWindow('image', cv.WINDOW_AUTOSIZE)
+    cv.imshow('image', img)
+    cv.waitKey()
+    ## [imshow 1]
+
+    ## [imshow 2]
+    img = cv.imread('image.jpg')
+    grey = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+    sobelx = cv.Sobel(grey, cv.CV_32F, 1, 0)
+    # find minimum and maximum intensities
+    minVal = np.amin(sobelx)
+    maxVal = np.amax(sobelx)
+    draw = cv.convertScaleAbs(sobelx, alpha=255.0/(maxVal - minVal), beta=-minVal * 255.0/(maxVal - minVal))
+    cv.namedWindow('image', cv.WINDOW_AUTOSIZE)
+    cv.imshow('image', draw)
+    cv.waitKey()
+    ## [imshow 2]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/dnn/dnn_conversion/common/test/voc_segm_test.py b/C++/opencv-4.7.0/samples/python/tutorial_code/dnn/dnn_conversion/common/test/voc_segm_test.py
new file mode 100644
index 00000000..4dbce158
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/dnn/dnn_conversion/common/test/voc_segm_test.py
@@ -0,0 +1,41 @@
+import numpy as np
+
+from ..accuracy_eval import SemSegmEvaluation
+from ..utils import plot_acc
+
+
+def test_segm_models(models_list, data_fetcher, eval_params, experiment_name, is_print_eval_params=True,
+                     is_plot_acc=True):
+    if is_print_eval_params:
+        print(
+            "===== Running evaluation of the classification models with the following params:\n"
+            "\t0. val data location: {}\n"
+            "\t1. val data labels: {}\n"
+            "\t2. frame size: {}\n"
+            "\t3. batch size: {}\n"
+            "\t4. transform to RGB: {}\n"
+            "\t5. log file location: {}\n".format(
+                eval_params.imgs_segm_dir,
+                eval_params.img_cls_file,
+                eval_params.frame_size,
+                eval_params.batch_size,
+                eval_params.bgr_to_rgb,
+                eval_params.log
+            )
+        )
+
+    accuracy_evaluator = SemSegmEvaluation(eval_params.log, eval_params.img_cls_file, eval_params.batch_size)
+    accuracy_evaluator.process(models_list, data_fetcher)
+    accuracy_array = np.array(accuracy_evaluator.general_fw_accuracy)
+
+    print(
+        "===== End of processing. Accuracy results:\n"
+        "\t1. max accuracy (top-5) for the original model: {}\n"
+        "\t2. max accuracy (top-5) for the DNN model: {}\n".format(
+            max(accuracy_array[:, 0]),
+            max(accuracy_array[:, 1]),
+        )
+    )
+
+    if is_plot_acc:
+        plot_acc(accuracy_array, experiment_name)
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/dnn/dnn_conversion/pytorch/segmentation/py_to_py_fcn_resnet50.py b/C++/opencv-4.7.0/samples/python/tutorial_code/dnn/dnn_conversion/pytorch/segmentation/py_to_py_fcn_resnet50.py
new file mode 100644
index 00000000..3649d30e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/dnn/dnn_conversion/pytorch/segmentation/py_to_py_fcn_resnet50.py
@@ -0,0 +1,59 @@
+from torchvision import models
+
+from ..pytorch_model import (
+    PyTorchModelPreparer,
+    PyTorchModelProcessor,
+    PyTorchDnnModelProcessor
+)
+from ...common.utils import set_pytorch_env, create_parser
+
+
+class PyTorchFcnResNet50(PyTorchModelPreparer):
+    def __init__(self, model_name, original_model):
+        super(PyTorchFcnResNet50, self).__init__(model_name, original_model)
+
+
+def main():
+    parser = create_parser()
+    cmd_args = parser.parse_args()
+    set_pytorch_env()
+
+    # Test the base process of model retrieval
+    resnets = PyTorchFcnResNet50(
+        model_name="resnet50",
+        original_model=models.segmentation.fcn_resnet50(pretrained=True)
+    )
+    model_dict = resnets.get_prepared_models()
+
+    if cmd_args.is_evaluate:
+        from ...common.test_config import TestConfig
+        from ...common.accuracy_eval import PASCALDataFetch
+        from ...common.test.voc_segm_test import test_segm_models
+
+        eval_params = TestConfig()
+
+        model_names = list(model_dict.keys())
+        original_model_name = model_names[0]
+        dnn_model_name = model_names[1]
+
+        #img_dir, segm_dir, names_file, segm_cls_colors_file, preproc)
+        data_fetcher = PASCALDataFetch(
+            imgs_dir=eval_params.imgs_segm_dir,
+            frame_size=eval_params.frame_size,
+            bgr_to_rgb=eval_params.bgr_to_rgb,
+
+        )
+
+        test_segm_models(
+            [
+                PyTorchModelProcessor(model_dict[original_model_name], original_model_name),
+                PyTorchDnnModelProcessor(model_dict[dnn_model_name], dnn_model_name)
+            ],
+            data_fetcher,
+            eval_params,
+            original_model_name
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.py b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.py
new file mode 100644
index 00000000..81daed93
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+def basicPanoramaStitching(img1Path, img2Path):
+    img1 = cv.imread(cv.samples.findFile(img1Path))
+    img2 = cv.imread(cv.samples.findFile(img2Path))
+
+    # [camera-pose-from-Blender-at-location-1]
+    c1Mo = np.array([[0.9659258723258972, 0.2588190734386444, 0.0, 1.5529145002365112],
+                     [ 0.08852133899927139, -0.3303661346435547, -0.9396926164627075, -0.10281121730804443],
+                     [-0.24321036040782928, 0.9076734185218811, -0.342020183801651, 6.130080699920654],
+                     [0, 0, 0, 1]],dtype=np.float64)
+    # [camera-pose-from-Blender-at-location-1]
+
+    # [camera-pose-from-Blender-at-location-2]
+    c2Mo = np.array([[0.9659258723258972, -0.2588190734386444, 0.0, -1.5529145002365112],
+                     [-0.08852133899927139, -0.3303661346435547, -0.9396926164627075, -0.10281121730804443],
+                     [0.24321036040782928, 0.9076734185218811, -0.342020183801651, 6.130080699920654],
+                     [0, 0, 0, 1]],dtype=np.float64)
+    # [camera-pose-from-Blender-at-location-2]
+
+    # [camera-intrinsics-from-Blender]
+    cameraMatrix = np.array([[700.0, 0.0, 320.0], [0.0, 700.0, 240.0], [0, 0, 1]], dtype=np.float32)
+    # [camera-intrinsics-from-Blender]
+
+    # [extract-rotation]
+    R1 = c1Mo[0:3, 0:3]
+    R2 = c2Mo[0:3, 0:3]
+    #[extract-rotation]
+
+    # [compute-rotation-displacement]
+    R2 = R2.transpose()
+    R_2to1 = np.dot(R1,R2)
+    # [compute-rotation-displacement]
+
+    # [compute-homography]
+    H = cameraMatrix.dot(R_2to1).dot(np.linalg.inv(cameraMatrix))
+    H = H / H[2][2]
+    # [compute-homography]
+
+    # [stitch]
+    img_stitch = cv.warpPerspective(img2, H, (img2.shape[1]*2, img2.shape[0]))
+    img_stitch[0:img1.shape[0], 0:img1.shape[1]] = img1
+    # [stitch]
+
+    img_space = np.zeros((img1.shape[0],50,3), dtype=np.uint8)
+    img_compare = cv.hconcat([img1,img_space, img2])
+
+    cv.imshow("Final", img_compare)
+    cv.imshow("Panorama", img_stitch)
+    cv.waitKey(0)
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Code for homography tutorial. Example 5: basic panorama stitching from a rotating camera.")
+    parser.add_argument("-I1","--image1", help = "path to first image", default="Blender_Suzanne1.jpg")
+    parser.add_argument("-I2","--image2", help = "path to second image", default="Blender_Suzanne2.jpg")
+    args = parser.parse_args()
+    print("Panorama Stitching Started")
+    basicPanoramaStitching(args.image1, args.image2)
+    print("Panorama Stitching Completed Successfully")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/Homography/perspective_correction.py b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/Homography/perspective_correction.py
new file mode 100644
index 00000000..184c44ef
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/Homography/perspective_correction.py
@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+import sys
+
+
+def randomColor():
+    color = np.random.randint(0, 255,(1, 3))
+    return color[0].tolist()
+
+def  perspectiveCorrection(img1Path, img2Path ,patternSize ):
+    img1 = cv.imread(cv.samples.findFile(img1Path))
+    img2 = cv.imread(cv.samples.findFile(img2Path))
+
+    # [find-corners]
+    ret1, corners1 = cv.findChessboardCorners(img1, patternSize)
+    ret2, corners2 = cv.findChessboardCorners(img2, patternSize)
+    # [find-corners]
+
+    if not ret1 or not ret2:
+        print("Error, cannot find the chessboard corners in both images.")
+        sys.exit(-1)
+
+    # [estimate-homography]
+    H, _ = cv.findHomography(corners1, corners2)
+    print(H)
+    # [estimate-homography]
+
+    # [warp-chessboard]
+    img1_warp = cv.warpPerspective(img1, H, (img1.shape[1], img1.shape[0]))
+    # [warp-chessboard]
+
+    img_draw_warp = cv.hconcat([img2, img1_warp])
+    cv.imshow("Desired chessboard view / Warped source chessboard view", img_draw_warp )
+
+    corners1 = corners1.tolist()
+    corners1 = [a[0] for a in corners1]
+
+    # [compute-transformed-corners]
+    img_draw_matches = cv.hconcat([img1, img2])
+    for i in range(len(corners1)):
+        pt1 = np.array([corners1[i][0], corners1[i][1], 1])
+        pt1 = pt1.reshape(3, 1)
+        pt2 = np.dot(H, pt1)
+        pt2 = pt2/pt2[2]
+        end = (int(img1.shape[1] + pt2[0]), int(pt2[1]))
+        cv.line(img_draw_matches, tuple([int(j) for j in corners1[i]]), end, randomColor(), 2)
+
+    cv.imshow("Draw matches", img_draw_matches)
+    cv.waitKey(0)
+    # [compute-transformed-corners]
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-I1', "--image1", help="Path to the first image", default="left02.jpg")
+    parser.add_argument('-I2', "--image2", help="Path to the second image", default="left01.jpg")
+    parser.add_argument('-H', "--height", help="Height of pattern size", default=6)
+    parser.add_argument('-W', "--width", help="Width of pattern size", default=9)
+    args = parser.parse_args()
+
+    img1Path = args.image1
+    img2Path = args.image2
+    h = args.height
+    w = args.width
+    perspectiveCorrection(img1Path, img2Path, (w, h))
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/akaze_matching/AKAZE_match.py b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/akaze_matching/AKAZE_match.py
new file mode 100644
index 00000000..61d1e93a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/akaze_matching/AKAZE_match.py
@@ -0,0 +1,81 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+from math import sqrt
+
+## [load]
+parser = argparse.ArgumentParser(description='Code for AKAZE local features matching tutorial.')
+parser.add_argument('--input1', help='Path to input image 1.', default='graf1.png')
+parser.add_argument('--input2', help='Path to input image 2.', default='graf3.png')
+parser.add_argument('--homography', help='Path to the homography matrix.', default='H1to3p.xml')
+args = parser.parse_args()
+
+img1 = cv.imread(cv.samples.findFile(args.input1), cv.IMREAD_GRAYSCALE)
+img2 = cv.imread(cv.samples.findFile(args.input2), cv.IMREAD_GRAYSCALE)
+if img1 is None or img2 is None:
+    print('Could not open or find the images!')
+    exit(0)
+
+fs = cv.FileStorage(cv.samples.findFile(args.homography), cv.FILE_STORAGE_READ)
+homography = fs.getFirstTopLevelNode().mat()
+## [load]
+
+## [AKAZE]
+akaze = cv.AKAZE_create()
+kpts1, desc1 = akaze.detectAndCompute(img1, None)
+kpts2, desc2 = akaze.detectAndCompute(img2, None)
+## [AKAZE]
+
+## [2-nn matching]
+matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_BRUTEFORCE_HAMMING)
+nn_matches = matcher.knnMatch(desc1, desc2, 2)
+## [2-nn matching]
+
+## [ratio test filtering]
+matched1 = []
+matched2 = []
+nn_match_ratio = 0.8 # Nearest neighbor matching ratio
+for m, n in nn_matches:
+    if m.distance < nn_match_ratio * n.distance:
+        matched1.append(kpts1[m.queryIdx])
+        matched2.append(kpts2[m.trainIdx])
+## [ratio test filtering]
+
+## [homography check]
+inliers1 = []
+inliers2 = []
+good_matches = []
+inlier_threshold = 2.5 # Distance threshold to identify inliers with homography check
+for i, m in enumerate(matched1):
+    col = np.ones((3,1), dtype=np.float64)
+    col[0:2,0] = m.pt
+
+    col = np.dot(homography, col)
+    col /= col[2,0]
+    dist = sqrt(pow(col[0,0] - matched2[i].pt[0], 2) +\
+                pow(col[1,0] - matched2[i].pt[1], 2))
+
+    if dist < inlier_threshold:
+        good_matches.append(cv.DMatch(len(inliers1), len(inliers2), 0))
+        inliers1.append(matched1[i])
+        inliers2.append(matched2[i])
+## [homography check]
+
+## [draw final matches]
+res = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8)
+cv.drawMatches(img1, inliers1, img2, inliers2, good_matches, res)
+cv.imwrite("akaze_result.png", res)
+
+inlier_ratio = len(inliers1) / float(len(matched1))
+print('A-KAZE Matching Results')
+print('*******************************')
+print('# Keypoints 1:                        \t', len(kpts1))
+print('# Keypoints 2:                        \t', len(kpts2))
+print('# Matches:                            \t', len(matched1))
+print('# Inliers:                            \t', len(inliers1))
+print('# Inliers Ratio:                      \t', inlier_ratio)
+
+cv.imshow('result', res)
+cv.waitKey()
+## [draw final matches]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_description/SURF_matching_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_description/SURF_matching_Demo.py
new file mode 100644
index 00000000..d7f84814
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_description/SURF_matching_Demo.py
@@ -0,0 +1,35 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Code for Feature Detection tutorial.')
+parser.add_argument('--input1', help='Path to input image 1.', default='box.png')
+parser.add_argument('--input2', help='Path to input image 2.', default='box_in_scene.png')
+args = parser.parse_args()
+
+img1 = cv.imread(cv.samples.findFile(args.input1), cv.IMREAD_GRAYSCALE)
+img2 = cv.imread(cv.samples.findFile(args.input2), cv.IMREAD_GRAYSCALE)
+if img1 is None or img2 is None:
+    print('Could not open or find the images!')
+    exit(0)
+
+#-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+minHessian = 400
+detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
+keypoints1, descriptors1 = detector.detectAndCompute(img1, None)
+keypoints2, descriptors2 = detector.detectAndCompute(img2, None)
+
+#-- Step 2: Matching descriptor vectors with a brute force matcher
+# Since SURF is a floating-point descriptor NORM_L2 is used
+matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_BRUTEFORCE)
+matches = matcher.match(descriptors1, descriptors2)
+
+#-- Draw matches
+img_matches = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8)
+cv.drawMatches(img1, keypoints1, img2, keypoints2, matches, img_matches)
+
+#-- Show detected matches
+cv.imshow('Matches', img_matches)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_detection/SURF_detection_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_detection/SURF_detection_Demo.py
new file mode 100644
index 00000000..7a30e115
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_detection/SURF_detection_Demo.py
@@ -0,0 +1,27 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Code for Feature Detection tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='box.png')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input), cv.IMREAD_GRAYSCALE)
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+#-- Step 1: Detect the keypoints using SURF Detector
+minHessian = 400
+detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
+keypoints = detector.detect(src)
+
+#-- Draw keypoints
+img_keypoints = np.empty((src.shape[0], src.shape[1], 3), dtype=np.uint8)
+cv.drawKeypoints(src, keypoints, img_keypoints)
+
+#-- Show detected (drawn) keypoints
+cv.imshow('SURF Keypoints', img_keypoints)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_flann_matcher/SURF_FLANN_matching_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_flann_matcher/SURF_FLANN_matching_Demo.py
new file mode 100644
index 00000000..e0a684cd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_flann_matcher/SURF_FLANN_matching_Demo.py
@@ -0,0 +1,42 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Code for Feature Matching with FLANN tutorial.')
+parser.add_argument('--input1', help='Path to input image 1.', default='box.png')
+parser.add_argument('--input2', help='Path to input image 2.', default='box_in_scene.png')
+args = parser.parse_args()
+
+img1 = cv.imread(cv.samples.findFile(args.input1), cv.IMREAD_GRAYSCALE)
+img2 = cv.imread(cv.samples.findFile(args.input2), cv.IMREAD_GRAYSCALE)
+if img1 is None or img2 is None:
+    print('Could not open or find the images!')
+    exit(0)
+
+#-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+minHessian = 400
+detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
+keypoints1, descriptors1 = detector.detectAndCompute(img1, None)
+keypoints2, descriptors2 = detector.detectAndCompute(img2, None)
+
+#-- Step 2: Matching descriptor vectors with a FLANN based matcher
+# Since SURF is a floating-point descriptor NORM_L2 is used
+matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_FLANNBASED)
+knn_matches = matcher.knnMatch(descriptors1, descriptors2, 2)
+
+#-- Filter matches using the Lowe's ratio test
+ratio_thresh = 0.7
+good_matches = []
+for m,n in knn_matches:
+    if m.distance < ratio_thresh * n.distance:
+        good_matches.append(m)
+
+#-- Draw matches
+img_matches = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8)
+cv.drawMatches(img1, keypoints1, img2, keypoints2, good_matches, img_matches, flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
+
+#-- Show detected matches
+cv.imshow('Good Matches', img_matches)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_homography/SURF_FLANN_matching_homography_Demo.py b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_homography/SURF_FLANN_matching_homography_Demo.py
new file mode 100644
index 00000000..72cc4633
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/features2D/feature_homography/SURF_FLANN_matching_homography_Demo.py
@@ -0,0 +1,77 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Code for Feature Matching with FLANN tutorial.')
+parser.add_argument('--input1', help='Path to input image 1.', default='box.png')
+parser.add_argument('--input2', help='Path to input image 2.', default='box_in_scene.png')
+args = parser.parse_args()
+
+img_object = cv.imread(cv.samples.findFile(args.input1), cv.IMREAD_GRAYSCALE)
+img_scene = cv.imread(cv.samples.findFile(args.input2), cv.IMREAD_GRAYSCALE)
+if img_object is None or img_scene is None:
+    print('Could not open or find the images!')
+    exit(0)
+
+#-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+minHessian = 400
+detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
+keypoints_obj, descriptors_obj = detector.detectAndCompute(img_object, None)
+keypoints_scene, descriptors_scene = detector.detectAndCompute(img_scene, None)
+
+#-- Step 2: Matching descriptor vectors with a FLANN based matcher
+# Since SURF is a floating-point descriptor NORM_L2 is used
+matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_FLANNBASED)
+knn_matches = matcher.knnMatch(descriptors_obj, descriptors_scene, 2)
+
+#-- Filter matches using the Lowe's ratio test
+ratio_thresh = 0.75
+good_matches = []
+for m,n in knn_matches:
+    if m.distance < ratio_thresh * n.distance:
+        good_matches.append(m)
+
+#-- Draw matches
+img_matches = np.empty((max(img_object.shape[0], img_scene.shape[0]), img_object.shape[1]+img_scene.shape[1], 3), dtype=np.uint8)
+cv.drawMatches(img_object, keypoints_obj, img_scene, keypoints_scene, good_matches, img_matches, flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
+
+#-- Localize the object
+obj = np.empty((len(good_matches),2), dtype=np.float32)
+scene = np.empty((len(good_matches),2), dtype=np.float32)
+for i in range(len(good_matches)):
+    #-- Get the keypoints from the good matches
+    obj[i,0] = keypoints_obj[good_matches[i].queryIdx].pt[0]
+    obj[i,1] = keypoints_obj[good_matches[i].queryIdx].pt[1]
+    scene[i,0] = keypoints_scene[good_matches[i].trainIdx].pt[0]
+    scene[i,1] = keypoints_scene[good_matches[i].trainIdx].pt[1]
+
+H, _ =  cv.findHomography(obj, scene, cv.RANSAC)
+
+#-- Get the corners from the image_1 ( the object to be "detected" )
+obj_corners = np.empty((4,1,2), dtype=np.float32)
+obj_corners[0,0,0] = 0
+obj_corners[0,0,1] = 0
+obj_corners[1,0,0] = img_object.shape[1]
+obj_corners[1,0,1] = 0
+obj_corners[2,0,0] = img_object.shape[1]
+obj_corners[2,0,1] = img_object.shape[0]
+obj_corners[3,0,0] = 0
+obj_corners[3,0,1] = img_object.shape[0]
+
+scene_corners = cv.perspectiveTransform(obj_corners, H)
+
+#-- Draw lines between the corners (the mapped object in the scene - image_2 )
+cv.line(img_matches, (int(scene_corners[0,0,0] + img_object.shape[1]), int(scene_corners[0,0,1])),\
+    (int(scene_corners[1,0,0] + img_object.shape[1]), int(scene_corners[1,0,1])), (0,255,0), 4)
+cv.line(img_matches, (int(scene_corners[1,0,0] + img_object.shape[1]), int(scene_corners[1,0,1])),\
+    (int(scene_corners[2,0,0] + img_object.shape[1]), int(scene_corners[2,0,1])), (0,255,0), 4)
+cv.line(img_matches, (int(scene_corners[2,0,0] + img_object.shape[1]), int(scene_corners[2,0,1])),\
+    (int(scene_corners[3,0,0] + img_object.shape[1]), int(scene_corners[3,0,1])), (0,255,0), 4)
+cv.line(img_matches, (int(scene_corners[3,0,0] + img_object.shape[1]), int(scene_corners[3,0,1])),\
+    (int(scene_corners[0,0,0] + img_object.shape[1]), int(scene_corners[0,0,1])), (0,255,0), 4)
+
+#-- Show detected matches
+cv.imshow('Good Matches & Object detection', img_matches)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/highgui/trackbar/AddingImagesTrackbar.py b/C++/opencv-4.7.0/samples/python/tutorial_code/highgui/trackbar/AddingImagesTrackbar.py
new file mode 100644
index 00000000..ffb97804
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/highgui/trackbar/AddingImagesTrackbar.py
@@ -0,0 +1,48 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import argparse
+
+alpha_slider_max = 100
+title_window = 'Linear Blend'
+
+## [on_trackbar]
+def on_trackbar(val):
+    alpha = val / alpha_slider_max
+    beta = ( 1.0 - alpha )
+    dst = cv.addWeighted(src1, alpha, src2, beta, 0.0)
+    cv.imshow(title_window, dst)
+## [on_trackbar]
+
+parser = argparse.ArgumentParser(description='Code for Adding a Trackbar to our applications tutorial.')
+parser.add_argument('--input1', help='Path to the first input image.', default='LinuxLogo.jpg')
+parser.add_argument('--input2', help='Path to the second input image.', default='WindowsLogo.jpg')
+args = parser.parse_args()
+
+## [load]
+# Read images ( both have to be of the same size and type )
+src1 = cv.imread(cv.samples.findFile(args.input1))
+src2 = cv.imread(cv.samples.findFile(args.input2))
+## [load]
+if src1 is None:
+    print('Could not open or find the image: ', args.input1)
+    exit(0)
+
+if src2 is None:
+    print('Could not open or find the image: ', args.input2)
+    exit(0)
+
+## [window]
+cv.namedWindow(title_window)
+## [window]
+
+## [create_trackbar]
+trackbar_name = 'Alpha x %d' % alpha_slider_max
+cv.createTrackbar(trackbar_name, title_window , 0, alpha_slider_max, on_trackbar)
+## [create_trackbar]
+
+# Show some stuff
+on_trackbar(0)
+
+# Wait until user press some key
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/BasicGeometricDrawing/basic_geometric_drawing.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/BasicGeometricDrawing/basic_geometric_drawing.py
new file mode 100644
index 00000000..f80c2f10
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/BasicGeometricDrawing/basic_geometric_drawing.py
@@ -0,0 +1,115 @@
+import cv2 as cv
+import numpy as np
+
+W = 400
+## [my_ellipse]
+def my_ellipse(img, angle):
+    thickness = 2
+    line_type = 8
+
+    cv.ellipse(img,
+                (W // 2, W // 2),
+                (W // 4, W // 16),
+                angle,
+                0,
+                360,
+                (255, 0, 0),
+                thickness,
+                line_type)
+## [my_ellipse]
+## [my_filled_circle]
+def my_filled_circle(img, center):
+    thickness = -1
+    line_type = 8
+
+    cv.circle(img,
+               center,
+               W // 32,
+               (0, 0, 255),
+               thickness,
+               line_type)
+## [my_filled_circle]
+## [my_polygon]
+def my_polygon(img):
+    line_type = 8
+
+    # Create some points
+    ppt = np.array([[W / 4, 7 * W / 8], [3 * W / 4, 7 * W / 8],
+                    [3 * W / 4, 13 * W / 16], [11 * W / 16, 13 * W / 16],
+                    [19 * W / 32, 3 * W / 8], [3 * W / 4, 3 * W / 8],
+                    [3 * W / 4, W / 8], [26 * W / 40, W / 8],
+                    [26 * W / 40, W / 4], [22 * W / 40, W / 4],
+                    [22 * W / 40, W / 8], [18 * W / 40, W / 8],
+                    [18 * W / 40, W / 4], [14 * W / 40, W / 4],
+                    [14 * W / 40, W / 8], [W / 4, W / 8],
+                    [W / 4, 3 * W / 8], [13 * W / 32, 3 * W / 8],
+                    [5 * W / 16, 13 * W / 16], [W / 4, 13 * W / 16]], np.int32)
+    ppt = ppt.reshape((-1, 1, 2))
+    cv.fillPoly(img, [ppt], (255, 255, 255), line_type)
+    # Only drawind the lines would be:
+    # cv.polylines(img, [ppt], True, (255, 0, 255), line_type)
+## [my_polygon]
+## [my_line]
+def my_line(img, start, end):
+    thickness = 2
+    line_type = 8
+
+    cv.line(img,
+             start,
+             end,
+             (0, 0, 0),
+             thickness,
+             line_type)
+## [my_line]
+## [create_images]
+# Windows names
+atom_window = "Drawing 1: Atom"
+rook_window = "Drawing 2: Rook"
+
+# Create black empty images
+size = W, W, 3
+atom_image = np.zeros(size, dtype=np.uint8)
+rook_image = np.zeros(size, dtype=np.uint8)
+## [create_images]
+## [draw_atom]
+# 1. Draw a simple atom:
+# -----------------------
+
+# 1.a. Creating ellipses
+my_ellipse(atom_image, 90)
+my_ellipse(atom_image, 0)
+my_ellipse(atom_image, 45)
+my_ellipse(atom_image, -45)
+
+# 1.b. Creating circles
+my_filled_circle(atom_image, (W // 2, W // 2))
+## [draw_atom]
+## [draw_rook]
+
+# 2. Draw a rook
+# ------------------
+# 2.a. Create a convex polygon
+my_polygon(rook_image)
+## [rectangle]
+# 2.b. Creating rectangles
+cv.rectangle(rook_image,
+              (0, 7 * W // 8),
+              (W, W),
+              (0, 255, 255),
+              -1,
+              8)
+## [rectangle]
+
+#  2.c. Create a few lines
+my_line(rook_image, (0, 15 * W // 16), (W, 15 * W // 16))
+my_line(rook_image, (W // 4, 7 * W // 8), (W // 4, W))
+my_line(rook_image, (W // 2, 7 * W // 8), (W // 2, W))
+my_line(rook_image, (3 * W // 4, 7 * W // 8), (3 * W // 4, W))
+## [draw_rook]
+cv.imshow(atom_window, atom_image)
+cv.moveWindow(atom_window, 0, 200)
+cv.imshow(rook_window, rook_image)
+cv.moveWindow(rook_window, W, 200)
+
+cv.waitKey(0)
+cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/HitMiss/hit_miss.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/HitMiss/hit_miss.py
new file mode 100644
index 00000000..55605ac2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/HitMiss/hit_miss.py
@@ -0,0 +1,38 @@
+import cv2 as cv
+import numpy as np
+
+input_image = np.array((
+    [0, 0, 0, 0, 0, 0, 0, 0],
+    [0, 255, 255, 255, 0, 0, 0, 255],
+    [0, 255, 255, 255, 0, 0, 0, 0],
+    [0, 255, 255, 255, 0, 255, 0, 0],
+    [0, 0, 255, 0, 0, 0, 0, 0],
+    [0, 0, 255, 0, 0, 255, 255, 0],
+    [0,255, 0, 255, 0, 0, 255, 0],
+    [0, 255, 255, 255, 0, 0, 0, 0]), dtype="uint8")
+
+kernel = np.array((
+        [0, 1, 0],
+        [1, -1, 1],
+        [0, 1, 0]), dtype="int")
+
+output_image = cv.morphologyEx(input_image, cv.MORPH_HITMISS, kernel)
+
+rate = 50
+kernel = (kernel + 1) * 127
+kernel = np.uint8(kernel)
+
+kernel = cv.resize(kernel, None, fx = rate, fy = rate, interpolation = cv.INTER_NEAREST)
+cv.imshow("kernel", kernel)
+cv.moveWindow("kernel", 0, 0)
+
+input_image = cv.resize(input_image, None, fx = rate, fy = rate, interpolation = cv.INTER_NEAREST)
+cv.imshow("Original", input_image)
+cv.moveWindow("Original", 0, 200)
+
+output_image = cv.resize(output_image, None , fx = rate, fy = rate, interpolation = cv.INTER_NEAREST)
+cv.imshow("Hit or Miss", output_image)
+cv.moveWindow("Hit or Miss", 500, 200)
+
+cv.waitKey(0)
+cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/Pyramids/pyramids.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/Pyramids/pyramids.py
new file mode 100644
index 00000000..429156b5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/Pyramids/pyramids.py
@@ -0,0 +1,51 @@
+import sys
+import cv2 as cv
+
+
+def main(argv):
+    print("""
+    Zoom In-Out demo
+    ------------------
+    * [i] -> Zoom [i]n
+    * [o] -> Zoom [o]ut
+    * [ESC] -> Close program
+    """)
+    ## [load]
+    filename = argv[0] if len(argv) > 0 else 'chicky_512.png'
+
+    # Load the image
+    src = cv.imread(cv.samples.findFile(filename))
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image!')
+        print ('Usage: pyramids.py [image_name -- default ../data/chicky_512.png] \n')
+        return -1
+    ## [load]
+    ## [loop]
+    while 1:
+        rows, cols, _channels = map(int, src.shape)
+        ## [show_image]
+        cv.imshow('Pyramids Demo', src)
+        ## [show_image]
+        k = cv.waitKey(0)
+
+        if k == 27:
+            break
+            ## [pyrup]
+        elif chr(k) == 'i':
+            src = cv.pyrUp(src, dstsize=(2 * cols, 2 * rows))
+            print ('** Zoom In: Image x 2')
+            ## [pyrup]
+            ## [pyrdown]
+        elif chr(k) == 'o':
+            src = cv.pyrDown(src, dstsize=(cols // 2, rows // 2))
+            print ('** Zoom Out: Image / 2')
+            ## [pyrdown]
+    ## [loop]
+
+    cv.destroyAllWindows()
+    return 0
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/Smoothing/smoothing.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/Smoothing/smoothing.py
new file mode 100644
index 00000000..a67b92dc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/Smoothing/smoothing.py
@@ -0,0 +1,107 @@
+import sys
+import cv2 as cv
+import numpy as np
+
+#  Global Variables
+
+DELAY_CAPTION = 1500
+DELAY_BLUR = 100
+MAX_KERNEL_LENGTH = 31
+
+src = None
+dst = None
+window_name = 'Smoothing Demo'
+
+
+def main(argv):
+    cv.namedWindow(window_name, cv.WINDOW_AUTOSIZE)
+
+    # Load the source image
+    imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
+
+    global src
+    src = cv.imread(cv.samples.findFile(imageName))
+    if src is None:
+        print ('Error opening image')
+        print ('Usage: smoothing.py [image_name -- default ../data/lena.jpg] \n')
+        return -1
+
+    if display_caption('Original Image') != 0:
+        return 0
+
+    global dst
+    dst = np.copy(src)
+    if display_dst(DELAY_CAPTION) != 0:
+        return 0
+
+    # Applying Homogeneous blur
+    if display_caption('Homogeneous Blur') != 0:
+        return 0
+
+    ## [blur]
+    for i in range(1, MAX_KERNEL_LENGTH, 2):
+        dst = cv.blur(src, (i, i))
+        if display_dst(DELAY_BLUR) != 0:
+            return 0
+    ## [blur]
+
+    # Applying Gaussian blur
+    if display_caption('Gaussian Blur') != 0:
+        return 0
+
+    ## [gaussianblur]
+    for i in range(1, MAX_KERNEL_LENGTH, 2):
+        dst = cv.GaussianBlur(src, (i, i), 0)
+        if display_dst(DELAY_BLUR) != 0:
+            return 0
+    ## [gaussianblur]
+
+    # Applying Median blur
+    if display_caption('Median Blur') != 0:
+        return 0
+
+    ## [medianblur]
+    for i in range(1, MAX_KERNEL_LENGTH, 2):
+        dst = cv.medianBlur(src, i)
+        if display_dst(DELAY_BLUR) != 0:
+            return 0
+    ## [medianblur]
+
+    # Applying Bilateral Filter
+    if display_caption('Bilateral Blur') != 0:
+        return 0
+
+    ## [bilateralfilter]
+    # Remember, bilateral is a bit slow, so as value go higher, it takes long time
+    for i in range(1, MAX_KERNEL_LENGTH, 2):
+        dst = cv.bilateralFilter(src, i, i * 2, i / 2)
+        if display_dst(DELAY_BLUR) != 0:
+            return 0
+    ## [bilateralfilter]
+
+    #  Done
+    display_caption('Done!')
+
+    return 0
+
+
+def display_caption(caption):
+    global dst
+    dst = np.zeros(src.shape, src.dtype)
+    rows, cols, _ch = src.shape
+    cv.putText(dst, caption,
+                (int(cols / 4), int(rows / 2)),
+                cv.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255))
+
+    return display_dst(DELAY_CAPTION)
+
+
+def display_dst(delay):
+    cv.imshow(window_name, dst)
+    c = cv.waitKey(delay)
+    if c >= 0 : return -1
+    return 0
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py
new file mode 100644
index 00000000..a8a9ccb3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py
@@ -0,0 +1,92 @@
+
+import cv2 as cv
+import numpy as np
+import argparse
+
+W = 52          # window size is WxW
+C_Thr = 0.43    # threshold for coherency
+LowThr = 35     # threshold1 for orientation, it ranges from 0 to 180
+HighThr = 57    # threshold2 for orientation, it ranges from 0 to 180
+
+## [calcGST]
+## [calcJ_header]
+## [calcGST_proto]
+def calcGST(inputIMG, w):
+## [calcGST_proto]
+    img = inputIMG.astype(np.float32)
+
+    # GST components calculation (start)
+    # J =  (J11 J12; J12 J22) - GST
+    imgDiffX = cv.Sobel(img, cv.CV_32F, 1, 0, 3)
+    imgDiffY = cv.Sobel(img, cv.CV_32F, 0, 1, 3)
+    imgDiffXY = cv.multiply(imgDiffX, imgDiffY)
+    ## [calcJ_header]
+
+    imgDiffXX = cv.multiply(imgDiffX, imgDiffX)
+    imgDiffYY = cv.multiply(imgDiffY, imgDiffY)
+
+    J11 = cv.boxFilter(imgDiffXX, cv.CV_32F, (w,w))
+    J22 = cv.boxFilter(imgDiffYY, cv.CV_32F, (w,w))
+    J12 = cv.boxFilter(imgDiffXY, cv.CV_32F, (w,w))
+    # GST components calculations (stop)
+
+    # eigenvalue calculation (start)
+    # lambda1 = 0.5*(J11 + J22 + sqrt((J11-J22)^2 + 4*J12^2))
+    # lambda2 = 0.5*(J11 + J22 - sqrt((J11-J22)^2 + 4*J12^2))
+    tmp1 = J11 + J22
+    tmp2 = J11 - J22
+    tmp2 = cv.multiply(tmp2, tmp2)
+    tmp3 = cv.multiply(J12, J12)
+    tmp4 = np.sqrt(tmp2 + 4.0 * tmp3)
+
+    lambda1 = 0.5*(tmp1 + tmp4)    # biggest eigenvalue
+    lambda2 = 0.5*(tmp1 - tmp4)    # smallest eigenvalue
+    # eigenvalue calculation (stop)
+
+    # Coherency calculation (start)
+    # Coherency = (lambda1 - lambda2)/(lambda1 + lambda2)) - measure of anisotropism
+    # Coherency is anisotropy degree (consistency of local orientation)
+    imgCoherencyOut = cv.divide(lambda1 - lambda2, lambda1 + lambda2)
+    # Coherency calculation (stop)
+
+    # orientation angle calculation (start)
+    # tan(2*Alpha) = 2*J12/(J22 - J11)
+    # Alpha = 0.5 atan2(2*J12/(J22 - J11))
+    imgOrientationOut = cv.phase(J22 - J11, 2.0 * J12, angleInDegrees = True)
+    imgOrientationOut = 0.5 * imgOrientationOut
+    # orientation angle calculation (stop)
+
+    return imgCoherencyOut, imgOrientationOut
+## [calcGST]
+
+parser = argparse.ArgumentParser(description='Code for Anisotropic image segmentation tutorial.')
+parser.add_argument('-i', '--input', help='Path to input image.', required=True)
+args = parser.parse_args()
+
+imgIn = cv.imread(args.input, cv.IMREAD_GRAYSCALE)
+if imgIn is None:
+    print('Could not open or find the image: {}'.format(args.input))
+    exit(0)
+
+## [main_extra]
+## [main]
+imgCoherency, imgOrientation = calcGST(imgIn, W)
+
+## [thresholding]
+_, imgCoherencyBin = cv.threshold(imgCoherency, C_Thr, 255, cv.THRESH_BINARY)
+_, imgOrientationBin = cv.threshold(imgOrientation, LowThr, HighThr, cv.THRESH_BINARY)
+## [thresholding]
+
+## [combining]
+imgBin = cv.bitwise_and(imgCoherencyBin, imgOrientationBin)
+## [combining]
+## [main]
+
+imgCoherency = cv.normalize(imgCoherency, None, alpha=0, beta=1, norm_type=cv.NORM_MINMAX, dtype=cv.CV_32F)
+imgOrientation = cv.normalize(imgOrientation, None, alpha=0, beta=1, norm_type=cv.NORM_MINMAX, dtype=cv.CV_32F)
+
+cv.imshow('result.jpg', np.uint8(0.5*(imgIn + imgBin)))
+cv.imshow('Coherency.jpg', imgCoherency)
+cv.imshow('Orientation.jpg', imgOrientation)
+cv.waitKey(0)
+## [main_extra]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/changing_contrast_brightness_image/BasicLinearTransforms.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/changing_contrast_brightness_image/BasicLinearTransforms.py
new file mode 100644
index 00000000..6b299a62
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/changing_contrast_brightness_image/BasicLinearTransforms.py
@@ -0,0 +1,55 @@
+from __future__ import print_function
+from builtins import input
+import cv2 as cv
+import numpy as np
+import argparse
+
+# Read image given by user
+## [basic-linear-transform-load]
+parser = argparse.ArgumentParser(description='Code for Changing the contrast and brightness of an image! tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='lena.jpg')
+args = parser.parse_args()
+
+image = cv.imread(cv.samples.findFile(args.input))
+if image is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+## [basic-linear-transform-load]
+
+## [basic-linear-transform-output]
+new_image = np.zeros(image.shape, image.dtype)
+## [basic-linear-transform-output]
+
+## [basic-linear-transform-parameters]
+alpha = 1.0 # Simple contrast control
+beta = 0    # Simple brightness control
+
+# Initialize values
+print(' Basic Linear Transforms ')
+print('-------------------------')
+try:
+    alpha = float(input('* Enter the alpha value [1.0-3.0]: '))
+    beta = int(input('* Enter the beta value [0-100]: '))
+except ValueError:
+    print('Error, not a number')
+## [basic-linear-transform-parameters]
+
+# Do the operation new_image(i,j) = alpha*image(i,j) + beta
+# Instead of these 'for' loops we could have used simply:
+# new_image = cv.convertScaleAbs(image, alpha=alpha, beta=beta)
+# but we wanted to show you how to access the pixels :)
+## [basic-linear-transform-operation]
+for y in range(image.shape[0]):
+    for x in range(image.shape[1]):
+        for c in range(image.shape[2]):
+            new_image[y,x,c] = np.clip(alpha*image[y,x,c] + beta, 0, 255)
+## [basic-linear-transform-operation]
+
+## [basic-linear-transform-display]
+# Show stuff
+cv.imshow('Original Image', image)
+cv.imshow('New Image', new_image)
+
+# Wait until user press some key
+cv.waitKey()
+## [basic-linear-transform-display]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/changing_contrast_brightness_image/changing_contrast_brightness_image.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/changing_contrast_brightness_image/changing_contrast_brightness_image.py
new file mode 100644
index 00000000..127a0f43
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/changing_contrast_brightness_image/changing_contrast_brightness_image.py
@@ -0,0 +1,74 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+
+alpha = 1.0
+alpha_max = 500
+beta = 0
+beta_max = 200
+gamma = 1.0
+gamma_max = 200
+
+def basicLinearTransform():
+    res = cv.convertScaleAbs(img_original, alpha=alpha, beta=beta)
+    img_corrected = cv.hconcat([img_original, res])
+    cv.imshow("Brightness and contrast adjustments", img_corrected)
+
+def gammaCorrection():
+    ## [changing-contrast-brightness-gamma-correction]
+    lookUpTable = np.empty((1,256), np.uint8)
+    for i in range(256):
+        lookUpTable[0,i] = np.clip(pow(i / 255.0, gamma) * 255.0, 0, 255)
+
+    res = cv.LUT(img_original, lookUpTable)
+    ## [changing-contrast-brightness-gamma-correction]
+
+    img_gamma_corrected = cv.hconcat([img_original, res])
+    cv.imshow("Gamma correction", img_gamma_corrected)
+
+def on_linear_transform_alpha_trackbar(val):
+    global alpha
+    alpha = val / 100
+    basicLinearTransform()
+
+def on_linear_transform_beta_trackbar(val):
+    global beta
+    beta = val - 100
+    basicLinearTransform()
+
+def on_gamma_correction_trackbar(val):
+    global gamma
+    gamma = val / 100
+    gammaCorrection()
+
+parser = argparse.ArgumentParser(description='Code for Changing the contrast and brightness of an image! tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='lena.jpg')
+args = parser.parse_args()
+
+img_original = cv.imread(cv.samples.findFile(args.input))
+if img_original is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+
+img_corrected = np.empty((img_original.shape[0], img_original.shape[1]*2, img_original.shape[2]), img_original.dtype)
+img_gamma_corrected = np.empty((img_original.shape[0], img_original.shape[1]*2, img_original.shape[2]), img_original.dtype)
+
+img_corrected = cv.hconcat([img_original, img_original])
+img_gamma_corrected = cv.hconcat([img_original, img_original])
+
+cv.namedWindow('Brightness and contrast adjustments')
+cv.namedWindow('Gamma correction')
+
+alpha_init = int(alpha *100)
+cv.createTrackbar('Alpha gain (contrast)', 'Brightness and contrast adjustments', alpha_init, alpha_max, on_linear_transform_alpha_trackbar)
+beta_init = beta + 100
+cv.createTrackbar('Beta bias (brightness)', 'Brightness and contrast adjustments', beta_init, beta_max, on_linear_transform_beta_trackbar)
+gamma_init = int(gamma * 100)
+cv.createTrackbar('Gamma correction', 'Gamma correction', gamma_init, gamma_max, on_gamma_correction_trackbar)
+
+on_linear_transform_alpha_trackbar(alpha_init)
+on_gamma_correction_trackbar(gamma_init)
+
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/erosion_dilatation/morphology_1.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/erosion_dilatation/morphology_1.py
new file mode 100644
index 00000000..3645eab3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/erosion_dilatation/morphology_1.py
@@ -0,0 +1,78 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+src = None
+erosion_size = 0
+max_elem = 2
+max_kernel_size = 21
+title_trackbar_element_shape = 'Element:\n 0: Rect \n 1: Cross \n 2: Ellipse'
+title_trackbar_kernel_size = 'Kernel size:\n 2n +1'
+title_erosion_window = 'Erosion Demo'
+title_dilation_window = 'Dilation Demo'
+
+
+## [main]
+def main(image):
+    global src
+    src = cv.imread(cv.samples.findFile(image))
+    if src is None:
+        print('Could not open or find the image: ', image)
+        exit(0)
+
+    cv.namedWindow(title_erosion_window)
+    cv.createTrackbar(title_trackbar_element_shape, title_erosion_window, 0, max_elem, erosion)
+    cv.createTrackbar(title_trackbar_kernel_size, title_erosion_window, 0, max_kernel_size, erosion)
+
+    cv.namedWindow(title_dilation_window)
+    cv.createTrackbar(title_trackbar_element_shape, title_dilation_window, 0, max_elem, dilatation)
+    cv.createTrackbar(title_trackbar_kernel_size, title_dilation_window, 0, max_kernel_size, dilatation)
+
+    erosion(0)
+    dilatation(0)
+    cv.waitKey()
+## [main]
+
+# optional mapping of values with morphological shapes
+def morph_shape(val):
+    if val == 0:
+        return cv.MORPH_RECT
+    elif val == 1:
+        return cv.MORPH_CROSS
+    elif val == 2:
+        return cv.MORPH_ELLIPSE
+
+
+## [erosion]
+def erosion(val):
+    erosion_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_erosion_window)
+    erosion_shape = morph_shape(cv.getTrackbarPos(title_trackbar_element_shape, title_erosion_window))
+
+    ## [kernel]
+    element = cv.getStructuringElement(erosion_shape, (2 * erosion_size + 1, 2 * erosion_size + 1),
+                                       (erosion_size, erosion_size))
+    ## [kernel]
+    erosion_dst = cv.erode(src, element)
+    cv.imshow(title_erosion_window, erosion_dst)
+## [erosion]
+
+
+## [dilation]
+def dilatation(val):
+    dilatation_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_dilation_window)
+    dilation_shape = morph_shape(cv.getTrackbarPos(title_trackbar_element_shape, title_dilation_window))
+
+    element = cv.getStructuringElement(dilation_shape, (2 * dilatation_size + 1, 2 * dilatation_size + 1),
+                                       (dilatation_size, dilatation_size))
+    dilatation_dst = cv.dilate(src, element)
+    cv.imshow(title_dilation_window, dilatation_dst)
+## [dilation]
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Code for Eroding and Dilating tutorial.')
+    parser.add_argument('--input', help='Path to input image.', default='LinuxLogo.jpg')
+    args = parser.parse_args()
+
+    main(args.input)
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/hough_line_transform/hough_line_transform.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/hough_line_transform/hough_line_transform.py
new file mode 100644
index 00000000..9a30923c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/hough_line_transform/hough_line_transform.py
@@ -0,0 +1,22 @@
+import cv2 as cv
+import numpy as np
+
+img = cv.imread(cv.samples.findFile('sudoku.png'))
+gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
+edges = cv.Canny(gray,50,150,apertureSize = 3)
+
+lines = cv.HoughLines(edges,1,np.pi/180,200)
+for line in lines:
+    rho,theta = line[0]
+    a = np.cos(theta)
+    b = np.sin(theta)
+    x0 = a*rho
+    y0 = b*rho
+    x1 = int(x0 + 1000*(-b))
+    y1 = int(y0 + 1000*(a))
+    x2 = int(x0 - 1000*(-b))
+    y2 = int(y0 - 1000*(a))
+
+    cv.line(img,(x1,y1),(x2,y2),(0,0,255),2)
+
+cv.imwrite('houghlines3.jpg',img)
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/hough_line_transform/probabilistic_hough_line_transform.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/hough_line_transform/probabilistic_hough_line_transform.py
new file mode 100644
index 00000000..d01fe895
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/hough_line_transform/probabilistic_hough_line_transform.py
@@ -0,0 +1,12 @@
+import cv2 as cv
+import numpy as np
+
+img = cv.imread(cv.samples.findFile('sudoku.png'))
+gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
+edges = cv.Canny(gray,50,150,apertureSize = 3)
+lines = cv.HoughLinesP(edges,1,np.pi/180,100,minLineLength=100,maxLineGap=10)
+for line in lines:
+    x1,y1,x2,y2 = line[0]
+    cv.line(img,(x1,y1),(x2,y2),(0,255,0),2)
+
+cv.imwrite('houghlines5.jpg',img)
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/match_template/match_template.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/match_template/match_template.py
new file mode 100644
index 00000000..25c6e3bc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/match_template/match_template.py
@@ -0,0 +1,97 @@
+from __future__ import print_function
+import sys
+import cv2 as cv
+
+## [global_variables]
+use_mask = False
+img = None
+templ = None
+mask = None
+image_window = "Source Image"
+result_window = "Result window"
+
+match_method = 0
+max_Trackbar = 5
+## [global_variables]
+
+def main(argv):
+
+    if (len(sys.argv) < 3):
+        print('Not enough parameters')
+        print('Usage:\nmatch_template_demo.py <image_name> <template_name> [<mask_name>]')
+        return -1
+
+    ## [load_image]
+    global img
+    global templ
+    img = cv.imread(sys.argv[1], cv.IMREAD_COLOR)
+    templ = cv.imread(sys.argv[2], cv.IMREAD_COLOR)
+
+    if (len(sys.argv) > 3):
+        global use_mask
+        use_mask = True
+        global mask
+        mask = cv.imread( sys.argv[3], cv.IMREAD_COLOR )
+
+    if ((img is None) or (templ is None) or (use_mask and (mask is None))):
+        print('Can\'t read one of the images')
+        return -1
+    ## [load_image]
+
+    ## [create_windows]
+    cv.namedWindow( image_window, cv.WINDOW_AUTOSIZE )
+    cv.namedWindow( result_window, cv.WINDOW_AUTOSIZE )
+    ## [create_windows]
+
+    ## [create_trackbar]
+    trackbar_label = 'Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED'
+    cv.createTrackbar( trackbar_label, image_window, match_method, max_Trackbar, MatchingMethod )
+    ## [create_trackbar]
+
+    MatchingMethod(match_method)
+
+    ## [wait_key]
+    cv.waitKey(0)
+    return 0
+    ## [wait_key]
+
+def MatchingMethod(param):
+
+    global match_method
+    match_method = param
+
+    ## [copy_source]
+    img_display = img.copy()
+    ## [copy_source]
+    ## [match_template]
+    method_accepts_mask = (cv.TM_SQDIFF == match_method or match_method == cv.TM_CCORR_NORMED)
+    if (use_mask and method_accepts_mask):
+        result = cv.matchTemplate(img, templ, match_method, None, mask)
+    else:
+        result = cv.matchTemplate(img, templ, match_method)
+    ## [match_template]
+
+    ## [normalize]
+    cv.normalize( result, result, 0, 1, cv.NORM_MINMAX, -1 )
+    ## [normalize]
+    ## [best_match]
+    _minVal, _maxVal, minLoc, maxLoc = cv.minMaxLoc(result, None)
+    ## [best_match]
+
+    ## [match_loc]
+    if (match_method == cv.TM_SQDIFF or match_method == cv.TM_SQDIFF_NORMED):
+        matchLoc = minLoc
+    else:
+        matchLoc = maxLoc
+    ## [match_loc]
+
+    ## [imshow]
+    cv.rectangle(img_display, matchLoc, (matchLoc[0] + templ.shape[0], matchLoc[1] + templ.shape[1]), (0,0,0), 2, 8, 0 )
+    cv.rectangle(result, matchLoc, (matchLoc[0] + templ.shape[0], matchLoc[1] + templ.shape[1]), (0,0,0), 2, 8, 0 )
+    cv.imshow(image_window, img_display)
+    cv.imshow(result_window, result)
+    ## [imshow]
+    pass
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/morph_lines_detection/morph_lines_detection.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/morph_lines_detection/morph_lines_detection.py
new file mode 100644
index 00000000..b7c01503
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/morph_lines_detection/morph_lines_detection.py
@@ -0,0 +1,136 @@
+"""
+@file morph_lines_detection.py
+@brief Use morphology transformations for extracting horizontal and vertical lines sample code
+"""
+import numpy as np
+import sys
+import cv2 as cv
+
+
+def show_wait_destroy(winname, img):
+    cv.imshow(winname, img)
+    cv.moveWindow(winname, 500, 0)
+    cv.waitKey(0)
+    cv.destroyWindow(winname)
+
+
+def main(argv):
+    # [load_image]
+    # Check number of arguments
+    if len(argv) < 1:
+        print ('Not enough parameters')
+        print ('Usage:\nmorph_lines_detection.py < path_to_image >')
+        return -1
+
+    # Load the image
+    src = cv.imread(argv[0], cv.IMREAD_COLOR)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image: ' + argv[0])
+        return -1
+
+    # Show source image
+    cv.imshow("src", src)
+    # [load_image]
+
+    # [gray]
+    # Transform source image to gray if it is not already
+    if len(src.shape) != 2:
+        gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    else:
+        gray = src
+
+    # Show gray image
+    show_wait_destroy("gray", gray)
+    # [gray]
+
+    # [bin]
+    # Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
+    gray = cv.bitwise_not(gray)
+    bw = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
+                                cv.THRESH_BINARY, 15, -2)
+    # Show binary image
+    show_wait_destroy("binary", bw)
+    # [bin]
+
+    # [init]
+    # Create the images that will use to extract the horizontal and vertical lines
+    horizontal = np.copy(bw)
+    vertical = np.copy(bw)
+    # [init]
+
+    # [horiz]
+    # Specify size on horizontal axis
+    cols = horizontal.shape[1]
+    horizontal_size = cols // 30
+
+    # Create structure element for extracting horizontal lines through morphology operations
+    horizontalStructure = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
+
+    # Apply morphology operations
+    horizontal = cv.erode(horizontal, horizontalStructure)
+    horizontal = cv.dilate(horizontal, horizontalStructure)
+
+    # Show extracted horizontal lines
+    show_wait_destroy("horizontal", horizontal)
+    # [horiz]
+
+    # [vert]
+    # Specify size on vertical axis
+    rows = vertical.shape[0]
+    verticalsize = rows // 30
+
+    # Create structure element for extracting vertical lines through morphology operations
+    verticalStructure = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
+
+    # Apply morphology operations
+    vertical = cv.erode(vertical, verticalStructure)
+    vertical = cv.dilate(vertical, verticalStructure)
+
+    # Show extracted vertical lines
+    show_wait_destroy("vertical", vertical)
+    # [vert]
+
+    # [smooth]
+    # Inverse vertical image
+    vertical = cv.bitwise_not(vertical)
+    show_wait_destroy("vertical_bit", vertical)
+
+    '''
+    Extract edges and smooth image according to the logic
+    1. extract edges
+    2. dilate(edges)
+    3. src.copyTo(smooth)
+    4. blur smooth img
+    5. smooth.copyTo(src, edges)
+    '''
+
+    # Step 1
+    edges = cv.adaptiveThreshold(vertical, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
+                                cv.THRESH_BINARY, 3, -2)
+    show_wait_destroy("edges", edges)
+
+    # Step 2
+    kernel = np.ones((2, 2), np.uint8)
+    edges = cv.dilate(edges, kernel)
+    show_wait_destroy("dilate", edges)
+
+    # Step 3
+    smooth = np.copy(vertical)
+
+    # Step 4
+    smooth = cv.blur(smooth, (2, 2))
+
+    # Step 5
+    (rows, cols) = np.where(edges != 0)
+    vertical[rows, cols] = smooth[rows, cols]
+
+    # Show final result
+    show_wait_destroy("smooth - final", vertical)
+    # [smooth]
+
+    return 0
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/opening_closing_hats/morphology_2.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/opening_closing_hats/morphology_2.py
new file mode 100644
index 00000000..e0fc7584
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/opening_closing_hats/morphology_2.py
@@ -0,0 +1,48 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+morph_size = 0
+max_operator = 4
+max_elem = 2
+max_kernel_size = 21
+title_trackbar_operator_type = 'Operator:\n 0: Opening - 1: Closing  \n 2: Gradient - 3: Top Hat \n 4: Black Hat'
+title_trackbar_element_type = 'Element:\n 0: Rect - 1: Cross - 2: Ellipse'
+title_trackbar_kernel_size = 'Kernel size:\n 2n + 1'
+title_window = 'Morphology Transformations Demo'
+morph_op_dic = {0: cv.MORPH_OPEN, 1: cv.MORPH_CLOSE, 2: cv.MORPH_GRADIENT, 3: cv.MORPH_TOPHAT, 4: cv.MORPH_BLACKHAT}
+
+def morphology_operations(val):
+    morph_operator = cv.getTrackbarPos(title_trackbar_operator_type, title_window)
+    morph_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_window)
+    morph_elem = 0
+    val_type = cv.getTrackbarPos(title_trackbar_element_type, title_window)
+    if val_type == 0:
+        morph_elem = cv.MORPH_RECT
+    elif val_type == 1:
+        morph_elem = cv.MORPH_CROSS
+    elif val_type == 2:
+        morph_elem = cv.MORPH_ELLIPSE
+
+    element = cv.getStructuringElement(morph_elem, (2*morph_size + 1, 2*morph_size+1), (morph_size, morph_size))
+    operation = morph_op_dic[morph_operator]
+    dst = cv.morphologyEx(src, operation, element)
+    cv.imshow(title_window, dst)
+
+parser = argparse.ArgumentParser(description='Code for More Morphology Transformations tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='LinuxLogo.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+
+cv.namedWindow(title_window)
+cv.createTrackbar(title_trackbar_operator_type, title_window , 0, max_operator, morphology_operations)
+cv.createTrackbar(title_trackbar_element_type, title_window , 0, max_elem, morphology_operations)
+cv.createTrackbar(title_trackbar_kernel_size, title_window , 0, max_kernel_size, morphology_operations)
+
+morphology_operations(0)
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/threshold/threshold.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/threshold/threshold.py
new file mode 100644
index 00000000..209ff757
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/threshold/threshold.py
@@ -0,0 +1,54 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+max_value = 255
+max_type = 4
+max_binary_value = 255
+trackbar_type = 'Type: \n 0: Binary \n 1: Binary Inverted \n 2: Truncate \n 3: To Zero \n 4: To Zero Inverted'
+trackbar_value = 'Value'
+window_name = 'Threshold Demo'
+
+## [Threshold_Demo]
+def Threshold_Demo(val):
+    #0: Binary
+    #1: Binary Inverted
+    #2: Threshold Truncated
+    #3: Threshold to Zero
+    #4: Threshold to Zero Inverted
+    threshold_type = cv.getTrackbarPos(trackbar_type, window_name)
+    threshold_value = cv.getTrackbarPos(trackbar_value, window_name)
+    _, dst = cv.threshold(src_gray, threshold_value, max_binary_value, threshold_type )
+    cv.imshow(window_name, dst)
+## [Threshold_Demo]
+
+parser = argparse.ArgumentParser(description='Code for Basic Thresholding Operations tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='stuff.jpg')
+args = parser.parse_args()
+
+## [load]
+# Load an image
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+# Convert the image to Gray
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+## [load]
+
+## [window]
+# Create a window to display results
+cv.namedWindow(window_name)
+## [window]
+
+## [trackbar]
+# Create Trackbar to choose type of Threshold
+cv.createTrackbar(trackbar_type, window_name , 3, max_type, Threshold_Demo)
+# Create Trackbar to choose Threshold value
+cv.createTrackbar(trackbar_value, window_name , 0, max_value, Threshold_Demo)
+## [trackbar]
+
+# Call the function to initialize
+Threshold_Demo(0)
+# Wait until user finishes program
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/threshold_inRange/threshold_inRange.py b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/threshold_inRange/threshold_inRange.py
new file mode 100644
index 00000000..4905a2e1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/imgProc/threshold_inRange/threshold_inRange.py
@@ -0,0 +1,107 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+max_value = 255
+max_value_H = 360//2
+low_H = 0
+low_S = 0
+low_V = 0
+high_H = max_value_H
+high_S = max_value
+high_V = max_value
+window_capture_name = 'Video Capture'
+window_detection_name = 'Object Detection'
+low_H_name = 'Low H'
+low_S_name = 'Low S'
+low_V_name = 'Low V'
+high_H_name = 'High H'
+high_S_name = 'High S'
+high_V_name = 'High V'
+
+## [low]
+def on_low_H_thresh_trackbar(val):
+    global low_H
+    global high_H
+    low_H = val
+    low_H = min(high_H-1, low_H)
+    cv.setTrackbarPos(low_H_name, window_detection_name, low_H)
+## [low]
+
+## [high]
+def on_high_H_thresh_trackbar(val):
+    global low_H
+    global high_H
+    high_H = val
+    high_H = max(high_H, low_H+1)
+    cv.setTrackbarPos(high_H_name, window_detection_name, high_H)
+## [high]
+
+def on_low_S_thresh_trackbar(val):
+    global low_S
+    global high_S
+    low_S = val
+    low_S = min(high_S-1, low_S)
+    cv.setTrackbarPos(low_S_name, window_detection_name, low_S)
+
+def on_high_S_thresh_trackbar(val):
+    global low_S
+    global high_S
+    high_S = val
+    high_S = max(high_S, low_S+1)
+    cv.setTrackbarPos(high_S_name, window_detection_name, high_S)
+
+def on_low_V_thresh_trackbar(val):
+    global low_V
+    global high_V
+    low_V = val
+    low_V = min(high_V-1, low_V)
+    cv.setTrackbarPos(low_V_name, window_detection_name, low_V)
+
+def on_high_V_thresh_trackbar(val):
+    global low_V
+    global high_V
+    high_V = val
+    high_V = max(high_V, low_V+1)
+    cv.setTrackbarPos(high_V_name, window_detection_name, high_V)
+
+parser = argparse.ArgumentParser(description='Code for Thresholding Operations using inRange tutorial.')
+parser.add_argument('--camera', help='Camera divide number.', default=0, type=int)
+args = parser.parse_args()
+
+## [cap]
+cap = cv.VideoCapture(args.camera)
+## [cap]
+
+## [window]
+cv.namedWindow(window_capture_name)
+cv.namedWindow(window_detection_name)
+## [window]
+
+## [trackbar]
+cv.createTrackbar(low_H_name, window_detection_name , low_H, max_value_H, on_low_H_thresh_trackbar)
+cv.createTrackbar(high_H_name, window_detection_name , high_H, max_value_H, on_high_H_thresh_trackbar)
+cv.createTrackbar(low_S_name, window_detection_name , low_S, max_value, on_low_S_thresh_trackbar)
+cv.createTrackbar(high_S_name, window_detection_name , high_S, max_value, on_high_S_thresh_trackbar)
+cv.createTrackbar(low_V_name, window_detection_name , low_V, max_value, on_low_V_thresh_trackbar)
+cv.createTrackbar(high_V_name, window_detection_name , high_V, max_value, on_high_V_thresh_trackbar)
+## [trackbar]
+
+while True:
+    ## [while]
+    ret, frame = cap.read()
+    if frame is None:
+        break
+
+    frame_HSV = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
+    frame_threshold = cv.inRange(frame_HSV, (low_H, low_S, low_V), (high_H, high_S, high_V))
+    ## [while]
+
+    ## [show]
+    cv.imshow(window_capture_name, frame)
+    cv.imshow(window_detection_name, frame_threshold)
+    ## [show]
+
+    key = cv.waitKey(30)
+    if key == ord('q') or key == 27:
+        break
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/introduction/display_image/display_image.py b/C++/opencv-4.7.0/samples/python/tutorial_code/introduction/display_image/display_image.py
new file mode 100644
index 00000000..404d2839
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/introduction/display_image/display_image.py
@@ -0,0 +1,19 @@
+## [imports]
+import cv2 as cv
+import sys
+## [imports]
+## [imread]
+img = cv.imread(cv.samples.findFile("starry_night.jpg"))
+## [imread]
+## [empty]
+if img is None:
+    sys.exit("Could not read the image.")
+## [empty]
+## [imshow]
+cv.imshow("Display window", img)
+k = cv.waitKey(0)
+## [imshow]
+## [imsave]
+if k == ord("s"):
+    cv.imwrite("starry_night.png", img)
+## [imsave]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/introduction/documentation/documentation.py b/C++/opencv-4.7.0/samples/python/tutorial_code/introduction/documentation/documentation.py
new file mode 100644
index 00000000..bbd3e177
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/introduction/documentation/documentation.py
@@ -0,0 +1,5 @@
+print('Not showing this text because it is outside the snippet')
+
+## [hello_world]
+print('Hello world!')
+## [hello_world]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ml/introduction_to_pca/introduction_to_pca.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ml/introduction_to_pca/introduction_to_pca.py
new file mode 100644
index 00000000..64fd07b1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ml/introduction_to_pca/introduction_to_pca.py
@@ -0,0 +1,100 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+from math import atan2, cos, sin, sqrt, pi
+
+def drawAxis(img, p_, q_, colour, scale):
+    p = list(p_)
+    q = list(q_)
+    ## [visualization1]
+    angle = atan2(p[1] - q[1], p[0] - q[0]) # angle in radians
+    hypotenuse = sqrt((p[1] - q[1]) * (p[1] - q[1]) + (p[0] - q[0]) * (p[0] - q[0]))
+
+    # Here we lengthen the arrow by a factor of scale
+    q[0] = p[0] - scale * hypotenuse * cos(angle)
+    q[1] = p[1] - scale * hypotenuse * sin(angle)
+    cv.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv.LINE_AA)
+
+    # create the arrow hooks
+    p[0] = q[0] + 9 * cos(angle + pi / 4)
+    p[1] = q[1] + 9 * sin(angle + pi / 4)
+    cv.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv.LINE_AA)
+
+    p[0] = q[0] + 9 * cos(angle - pi / 4)
+    p[1] = q[1] + 9 * sin(angle - pi / 4)
+    cv.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv.LINE_AA)
+    ## [visualization1]
+
+def getOrientation(pts, img):
+    ## [pca]
+    # Construct a buffer used by the pca analysis
+    sz = len(pts)
+    data_pts = np.empty((sz, 2), dtype=np.float64)
+    for i in range(data_pts.shape[0]):
+        data_pts[i,0] = pts[i,0,0]
+        data_pts[i,1] = pts[i,0,1]
+
+    # Perform PCA analysis
+    mean = np.empty((0))
+    mean, eigenvectors, eigenvalues = cv.PCACompute2(data_pts, mean)
+
+    # Store the center of the object
+    cntr = (int(mean[0,0]), int(mean[0,1]))
+    ## [pca]
+
+    ## [visualization]
+    # Draw the principal components
+    cv.circle(img, cntr, 3, (255, 0, 255), 2)
+    p1 = (cntr[0] + 0.02 * eigenvectors[0,0] * eigenvalues[0,0], cntr[1] + 0.02 * eigenvectors[0,1] * eigenvalues[0,0])
+    p2 = (cntr[0] - 0.02 * eigenvectors[1,0] * eigenvalues[1,0], cntr[1] - 0.02 * eigenvectors[1,1] * eigenvalues[1,0])
+    drawAxis(img, cntr, p1, (0, 255, 0), 1)
+    drawAxis(img, cntr, p2, (255, 255, 0), 5)
+
+    angle = atan2(eigenvectors[0,1], eigenvectors[0,0]) # orientation in radians
+    ## [visualization]
+
+    return angle
+
+## [pre-process]
+# Load image
+parser = argparse.ArgumentParser(description='Code for Introduction to Principal Component Analysis (PCA) tutorial.\
+                                              This program demonstrates how to use OpenCV PCA to extract the orientation of an object.')
+parser.add_argument('--input', help='Path to input image.', default='pca_test1.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+# Check if image is loaded successfully
+if src is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+
+cv.imshow('src', src)
+
+# Convert image to grayscale
+gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+# Convert image to binary
+_, bw = cv.threshold(gray, 50, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
+## [pre-process]
+
+## [contours]
+# Find all the contours in the thresholded image
+contours, _ = cv.findContours(bw, cv.RETR_LIST, cv.CHAIN_APPROX_NONE)
+
+for i, c in enumerate(contours):
+    # Calculate the area of each contour
+    area = cv.contourArea(c)
+    # Ignore contours that are too small or too large
+    if area < 1e2 or 1e5 < area:
+        continue
+
+    # Draw each contour only for visualisation purposes
+    cv.drawContours(src, contours, i, (0, 0, 255), 2)
+    # Find the orientation of each shape
+    getOrientation(c, src)
+## [contours]
+
+cv.imshow('output', src)
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ml/introduction_to_svm/introduction_to_svm.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ml/introduction_to_svm/introduction_to_svm.py
new file mode 100644
index 00000000..eeb246bc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ml/introduction_to_svm/introduction_to_svm.py
@@ -0,0 +1,62 @@
+import cv2 as cv
+import numpy as np
+
+# Set up training data
+## [setup1]
+labels = np.array([1, -1, -1, -1])
+trainingData = np.matrix([[501, 10], [255, 10], [501, 255], [10, 501]], dtype=np.float32)
+## [setup1]
+
+# Train the SVM
+## [init]
+svm = cv.ml.SVM_create()
+svm.setType(cv.ml.SVM_C_SVC)
+svm.setKernel(cv.ml.SVM_LINEAR)
+svm.setTermCriteria((cv.TERM_CRITERIA_MAX_ITER, 100, 1e-6))
+## [init]
+## [train]
+svm.train(trainingData, cv.ml.ROW_SAMPLE, labels)
+## [train]
+
+# Data for visual representation
+width = 512
+height = 512
+image = np.zeros((height, width, 3), dtype=np.uint8)
+
+# Show the decision regions given by the SVM
+## [show]
+green = (0,255,0)
+blue = (255,0,0)
+for i in range(image.shape[0]):
+    for j in range(image.shape[1]):
+        sampleMat = np.matrix([[j,i]], dtype=np.float32)
+        response = svm.predict(sampleMat)[1]
+
+        if response == 1:
+            image[i,j] = green
+        elif response == -1:
+            image[i,j] = blue
+## [show]
+
+# Show the training data
+## [show_data]
+thickness = -1
+cv.circle(image, (501,  10), 5, (  0,   0,   0), thickness)
+cv.circle(image, (255,  10), 5, (255, 255, 255), thickness)
+cv.circle(image, (501, 255), 5, (255, 255, 255), thickness)
+cv.circle(image, ( 10, 501), 5, (255, 255, 255), thickness)
+## [show_data]
+
+# Show support vectors
+## [show_vectors]
+thickness = 2
+sv = svm.getUncompressedSupportVectors()
+
+for i in range(sv.shape[0]):
+    cv.circle(image, (int(sv[i,0]), int(sv[i,1])), 6, (128, 128, 128), thickness)
+## [show_vectors]
+
+cv.imwrite('result.png', image) # save the image
+
+cv.imshow('SVM Simple Example', image) # show it to the user
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ml/non_linear_svms/non_linear_svms.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ml/non_linear_svms/non_linear_svms.py
new file mode 100644
index 00000000..a88ac4bd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ml/non_linear_svms/non_linear_svms.py
@@ -0,0 +1,117 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import random as rng
+
+NTRAINING_SAMPLES = 100 # Number of training samples per class
+FRAC_LINEAR_SEP = 0.9   # Fraction of samples which compose the linear separable part
+
+# Data for visual representation
+WIDTH = 512
+HEIGHT = 512
+I = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
+
+# --------------------- 1. Set up training data randomly ---------------------------------------
+trainData = np.empty((2*NTRAINING_SAMPLES, 2), dtype=np.float32)
+labels = np.empty((2*NTRAINING_SAMPLES, 1), dtype=np.int32)
+
+rng.seed(100) # Random value generation class
+
+# Set up the linearly separable part of the training data
+nLinearSamples = int(FRAC_LINEAR_SEP * NTRAINING_SAMPLES)
+
+## [setup1]
+# Generate random points for the class 1
+trainClass = trainData[0:nLinearSamples,:]
+# The x coordinate of the points is in [0, 0.4)
+c = trainClass[:,0:1]
+c[:] = np.random.uniform(0.0, 0.4 * WIDTH, c.shape)
+# The y coordinate of the points is in [0, 1)
+c = trainClass[:,1:2]
+c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
+
+# Generate random points for the class 2
+trainClass = trainData[2*NTRAINING_SAMPLES-nLinearSamples:2*NTRAINING_SAMPLES,:]
+# The x coordinate of the points is in [0.6, 1]
+c = trainClass[:,0:1]
+c[:] = np.random.uniform(0.6*WIDTH, WIDTH, c.shape)
+# The y coordinate of the points is in [0, 1)
+c = trainClass[:,1:2]
+c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
+## [setup1]
+
+#------------------ Set up the non-linearly separable part of the training data ---------------
+## [setup2]
+# Generate random points for the classes 1 and 2
+trainClass = trainData[nLinearSamples:2*NTRAINING_SAMPLES-nLinearSamples,:]
+# The x coordinate of the points is in [0.4, 0.6)
+c = trainClass[:,0:1]
+c[:] = np.random.uniform(0.4*WIDTH, 0.6*WIDTH, c.shape)
+# The y coordinate of the points is in [0, 1)
+c = trainClass[:,1:2]
+c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
+## [setup2]
+
+#------------------------- Set up the labels for the classes ---------------------------------
+labels[0:NTRAINING_SAMPLES,:] = 1                   # Class 1
+labels[NTRAINING_SAMPLES:2*NTRAINING_SAMPLES,:] = 2 # Class 2
+
+#------------------------ 2. Set up the support vector machines parameters --------------------
+print('Starting training process')
+## [init]
+svm = cv.ml.SVM_create()
+svm.setType(cv.ml.SVM_C_SVC)
+svm.setC(0.1)
+svm.setKernel(cv.ml.SVM_LINEAR)
+svm.setTermCriteria((cv.TERM_CRITERIA_MAX_ITER, int(1e7), 1e-6))
+## [init]
+
+#------------------------ 3. Train the svm ----------------------------------------------------
+## [train]
+svm.train(trainData, cv.ml.ROW_SAMPLE, labels)
+## [train]
+print('Finished training process')
+
+#------------------------ 4. Show the decision regions ----------------------------------------
+## [show]
+green = (0,100,0)
+blue = (100,0,0)
+for i in range(I.shape[0]):
+    for j in range(I.shape[1]):
+        sampleMat = np.matrix([[j,i]], dtype=np.float32)
+        response = svm.predict(sampleMat)[1]
+
+        if response == 1:
+            I[i,j] = green
+        elif response == 2:
+            I[i,j] = blue
+## [show]
+
+#----------------------- 5. Show the training data --------------------------------------------
+## [show_data]
+thick = -1
+# Class 1
+for i in range(NTRAINING_SAMPLES):
+    px = trainData[i,0]
+    py = trainData[i,1]
+    cv.circle(I, (int(px), int(py)), 3, (0, 255, 0), thick)
+
+# Class 2
+for i in range(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES):
+    px = trainData[i,0]
+    py = trainData[i,1]
+    cv.circle(I, (int(px), int(py)), 3, (255, 0, 0), thick)
+## [show_data]
+
+#------------------------- 6. Show support vectors --------------------------------------------
+## [show_vectors]
+thick = 2
+sv = svm.getUncompressedSupportVectors()
+
+for i in range(sv.shape[0]):
+    cv.circle(I, (int(sv[i,0]), int(sv[i,1])), 6, (128, 128, 128), thick)
+## [show_vectors]
+
+cv.imwrite('result.png', I)                      # save the Image
+cv.imshow('SVM for Non-Linear Training Data', I) # show it to the user
+cv.waitKey()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/ml/py_svm_opencv/hogsvm.py b/C++/opencv-4.7.0/samples/python/tutorial_code/ml/py_svm_opencv/hogsvm.py
new file mode 100644
index 00000000..898c7dc4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/ml/py_svm_opencv/hogsvm.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+import cv2 as cv
+import numpy as np
+
+SZ=20
+bin_n = 16 # Number of bins
+
+
+affine_flags = cv.WARP_INVERSE_MAP|cv.INTER_LINEAR
+
+## [deskew]
+def deskew(img):
+    m = cv.moments(img)
+    if abs(m['mu02']) < 1e-2:
+        return img.copy()
+    skew = m['mu11']/m['mu02']
+    M = np.float32([[1, skew, -0.5*SZ*skew], [0, 1, 0]])
+    img = cv.warpAffine(img,M,(SZ, SZ),flags=affine_flags)
+    return img
+## [deskew]
+
+## [hog]
+def hog(img):
+    gx = cv.Sobel(img, cv.CV_32F, 1, 0)
+    gy = cv.Sobel(img, cv.CV_32F, 0, 1)
+    mag, ang = cv.cartToPolar(gx, gy)
+    bins = np.int32(bin_n*ang/(2*np.pi))    # quantizing binvalues in (0...16)
+    bin_cells = bins[:10,:10], bins[10:,:10], bins[:10,10:], bins[10:,10:]
+    mag_cells = mag[:10,:10], mag[10:,:10], mag[:10,10:], mag[10:,10:]
+    hists = [np.bincount(b.ravel(), m.ravel(), bin_n) for b, m in zip(bin_cells, mag_cells)]
+    hist = np.hstack(hists)     # hist is a 64 bit vector
+    return hist
+## [hog]
+
+img = cv.imread(cv.samples.findFile('digits.png'),0)
+if img is None:
+    raise Exception("we need the digits.png image from samples/data here !")
+
+
+cells = [np.hsplit(row,100) for row in np.vsplit(img,50)]
+
+# First half is trainData, remaining is testData
+train_cells = [ i[:50] for i in cells ]
+test_cells = [ i[50:] for i in cells]
+
+######     Now training      ########################
+
+deskewed = [list(map(deskew,row)) for row in train_cells]
+hogdata = [list(map(hog,row)) for row in deskewed]
+trainData = np.float32(hogdata).reshape(-1,64)
+responses = np.repeat(np.arange(10),250)[:,np.newaxis]
+
+svm = cv.ml.SVM_create()
+svm.setKernel(cv.ml.SVM_LINEAR)
+svm.setType(cv.ml.SVM_C_SVC)
+svm.setC(2.67)
+svm.setGamma(5.383)
+
+svm.train(trainData, cv.ml.ROW_SAMPLE, responses)
+svm.save('svm_data.dat')
+
+######     Now testing      ########################
+
+deskewed = [list(map(deskew,row)) for row in test_cells]
+hogdata = [list(map(hog,row)) for row in deskewed]
+testData = np.float32(hogdata).reshape(-1,bin_n*4)
+result = svm.predict(testData)[1]
+
+#######   Check Accuracy   ########################
+mask = result==responses
+correct = np.count_nonzero(mask)
+print(correct*100.0/result.size)
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/objectDetection/cascade_classifier/objectDetection.py b/C++/opencv-4.7.0/samples/python/tutorial_code/objectDetection/cascade_classifier/objectDetection.py
new file mode 100644
index 00000000..d9fb460c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/objectDetection/cascade_classifier/objectDetection.py
@@ -0,0 +1,61 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+def detectAndDisplay(frame):
+    frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+    frame_gray = cv.equalizeHist(frame_gray)
+
+    #-- Detect faces
+    faces = face_cascade.detectMultiScale(frame_gray)
+    for (x,y,w,h) in faces:
+        center = (x + w//2, y + h//2)
+        frame = cv.ellipse(frame, center, (w//2, h//2), 0, 0, 360, (255, 0, 255), 4)
+
+        faceROI = frame_gray[y:y+h,x:x+w]
+        #-- In each face, detect eyes
+        eyes = eyes_cascade.detectMultiScale(faceROI)
+        for (x2,y2,w2,h2) in eyes:
+            eye_center = (x + x2 + w2//2, y + y2 + h2//2)
+            radius = int(round((w2 + h2)*0.25))
+            frame = cv.circle(frame, eye_center, radius, (255, 0, 0 ), 4)
+
+    cv.imshow('Capture - Face detection', frame)
+
+parser = argparse.ArgumentParser(description='Code for Cascade Classifier tutorial.')
+parser.add_argument('--face_cascade', help='Path to face cascade.', default='data/haarcascades/haarcascade_frontalface_alt.xml')
+parser.add_argument('--eyes_cascade', help='Path to eyes cascade.', default='data/haarcascades/haarcascade_eye_tree_eyeglasses.xml')
+parser.add_argument('--camera', help='Camera divide number.', type=int, default=0)
+args = parser.parse_args()
+
+face_cascade_name = args.face_cascade
+eyes_cascade_name = args.eyes_cascade
+
+face_cascade = cv.CascadeClassifier()
+eyes_cascade = cv.CascadeClassifier()
+
+#-- 1. Load the cascades
+if not face_cascade.load(cv.samples.findFile(face_cascade_name)):
+    print('--(!)Error loading face cascade')
+    exit(0)
+if not eyes_cascade.load(cv.samples.findFile(eyes_cascade_name)):
+    print('--(!)Error loading eyes cascade')
+    exit(0)
+
+camera_device = args.camera
+#-- 2. Read the video stream
+cap = cv.VideoCapture(camera_device)
+if not cap.isOpened:
+    print('--(!)Error opening video capture')
+    exit(0)
+
+while True:
+    ret, frame = cap.read()
+    if frame is None:
+        print('--(!) No captured frame -- Break!')
+        break
+
+    detectAndDisplay(frame)
+
+    if cv.waitKey(10) == 27:
+        break
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/photo/hdr_imaging/hdr_imaging.py b/C++/opencv-4.7.0/samples/python/tutorial_code/photo/hdr_imaging/hdr_imaging.py
new file mode 100644
index 00000000..a5403d3c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/photo/hdr_imaging/hdr_imaging.py
@@ -0,0 +1,56 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+import os
+
+def loadExposureSeq(path):
+    images = []
+    times = []
+    with open(os.path.join(path, 'list.txt')) as f:
+        content = f.readlines()
+    for line in content:
+        tokens = line.split()
+        images.append(cv.imread(os.path.join(path, tokens[0])))
+        times.append(1 / float(tokens[1]))
+
+    return images, np.asarray(times, dtype=np.float32)
+
+parser = argparse.ArgumentParser(description='Code for High Dynamic Range Imaging tutorial.')
+parser.add_argument('--input', type=str, help='Path to the directory that contains images and exposure times.')
+args = parser.parse_args()
+
+if not args.input:
+    parser.print_help()
+    exit(0)
+
+## [Load images and exposure times]
+images, times = loadExposureSeq(args.input)
+## [Load images and exposure times]
+
+## [Estimate camera response]
+calibrate = cv.createCalibrateDebevec()
+response = calibrate.process(images, times)
+## [Estimate camera response]
+
+## [Make HDR image]
+merge_debevec = cv.createMergeDebevec()
+hdr = merge_debevec.process(images, times, response)
+## [Make HDR image]
+
+## [Tonemap HDR image]
+tonemap = cv.createTonemap(2.2)
+ldr = tonemap.process(hdr)
+## [Tonemap HDR image]
+
+## [Perform exposure fusion]
+merge_mertens = cv.createMergeMertens()
+fusion = merge_mertens.process(images)
+## [Perform exposure fusion]
+
+## [Write results]
+cv.imwrite('fusion.png', fusion * 255)
+cv.imwrite('ldr.png', ldr * 255)
+cv.imwrite('hdr.hdr', hdr)
+## [Write results]
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/video/background_subtraction/bg_sub.py b/C++/opencv-4.7.0/samples/python/tutorial_code/video/background_subtraction/bg_sub.py
new file mode 100644
index 00000000..1bf3d2fd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/video/background_subtraction/bg_sub.py
@@ -0,0 +1,51 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+parser = argparse.ArgumentParser(description='This program shows how to use background subtraction methods provided by \
+                                              OpenCV. You can process both videos and images.')
+parser.add_argument('--input', type=str, help='Path to a video or a sequence of image.', default='vtest.avi')
+parser.add_argument('--algo', type=str, help='Background subtraction method (KNN, MOG2).', default='MOG2')
+args = parser.parse_args()
+
+## [create]
+#create Background Subtractor objects
+if args.algo == 'MOG2':
+    backSub = cv.createBackgroundSubtractorMOG2()
+else:
+    backSub = cv.createBackgroundSubtractorKNN()
+## [create]
+
+## [capture]
+capture = cv.VideoCapture(cv.samples.findFileOrKeep(args.input))
+if not capture.isOpened():
+    print('Unable to open: ' + args.input)
+    exit(0)
+## [capture]
+
+while True:
+    ret, frame = capture.read()
+    if frame is None:
+        break
+
+    ## [apply]
+    #update the background model
+    fgMask = backSub.apply(frame)
+    ## [apply]
+
+    ## [display_frame_number]
+    #get the frame number and write it on the current frame
+    cv.rectangle(frame, (10, 2), (100,20), (255,255,255), -1)
+    cv.putText(frame, str(capture.get(cv.CAP_PROP_POS_FRAMES)), (15, 15),
+               cv.FONT_HERSHEY_SIMPLEX, 0.5 , (0,0,0))
+    ## [display_frame_number]
+
+    ## [show]
+    #show the current frame and the fg masks
+    cv.imshow('Frame', frame)
+    cv.imshow('FG Mask', fgMask)
+    ## [show]
+
+    keyboard = cv.waitKey(30)
+    if keyboard == 'q' or keyboard == 27:
+        break
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/video/meanshift/camshift.py b/C++/opencv-4.7.0/samples/python/tutorial_code/video/meanshift/camshift.py
new file mode 100644
index 00000000..774e8b6c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/video/meanshift/camshift.py
@@ -0,0 +1,50 @@
+import numpy as np
+import cv2 as cv
+import argparse
+
+parser = argparse.ArgumentParser(description='This sample demonstrates the camshift algorithm. \
+                                              The example file can be downloaded from: \
+                                              https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4')
+parser.add_argument('image', type=str, help='path to image file')
+args = parser.parse_args()
+
+cap = cv.VideoCapture(args.image)
+
+# take first frame of the video
+ret,frame = cap.read()
+
+# setup initial location of window
+x, y, w, h = 300, 200, 100, 50 # simply hardcoded the values
+track_window = (x, y, w, h)
+
+# set up the ROI for tracking
+roi = frame[y:y+h, x:x+w]
+hsv_roi =  cv.cvtColor(roi, cv.COLOR_BGR2HSV)
+mask = cv.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.)))
+roi_hist = cv.calcHist([hsv_roi],[0],mask,[180],[0,180])
+cv.normalize(roi_hist,roi_hist,0,255,cv.NORM_MINMAX)
+
+# Setup the termination criteria, either 10 iteration or move by at least 1 pt
+term_crit = ( cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1 )
+
+while(1):
+    ret, frame = cap.read()
+
+    if ret == True:
+        hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
+        dst = cv.calcBackProject([hsv],[0],roi_hist,[0,180],1)
+
+        # apply camshift to get the new location
+        ret, track_window = cv.CamShift(dst, track_window, term_crit)
+
+        # Draw it on image
+        pts = cv.boxPoints(ret)
+        pts = np.int0(pts)
+        img2 = cv.polylines(frame,[pts],True, 255,2)
+        cv.imshow('img2',img2)
+
+        k = cv.waitKey(30) & 0xff
+        if k == 27:
+            break
+    else:
+        break
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/video/meanshift/meanshift.py b/C++/opencv-4.7.0/samples/python/tutorial_code/video/meanshift/meanshift.py
new file mode 100644
index 00000000..ecdd573c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/video/meanshift/meanshift.py
@@ -0,0 +1,49 @@
+import numpy as np
+import cv2 as cv
+import argparse
+
+parser = argparse.ArgumentParser(description='This sample demonstrates the meanshift algorithm. \
+                                              The example file can be downloaded from: \
+                                              https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4')
+parser.add_argument('image', type=str, help='path to image file')
+args = parser.parse_args()
+
+cap = cv.VideoCapture(args.image)
+
+# take first frame of the video
+ret,frame = cap.read()
+
+# setup initial location of window
+x, y, w, h = 300, 200, 100, 50 # simply hardcoded the values
+track_window = (x, y, w, h)
+
+# set up the ROI for tracking
+roi = frame[y:y+h, x:x+w]
+hsv_roi =  cv.cvtColor(roi, cv.COLOR_BGR2HSV)
+mask = cv.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.)))
+roi_hist = cv.calcHist([hsv_roi],[0],mask,[180],[0,180])
+cv.normalize(roi_hist,roi_hist,0,255,cv.NORM_MINMAX)
+
+# Setup the termination criteria, either 10 iteration or move by at least 1 pt
+term_crit = ( cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1 )
+
+while(1):
+    ret, frame = cap.read()
+
+    if ret == True:
+        hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
+        dst = cv.calcBackProject([hsv],[0],roi_hist,[0,180],1)
+
+        # apply meanshift to get the new location
+        ret, track_window = cv.meanShift(dst, track_window, term_crit)
+
+        # Draw it on image
+        x,y,w,h = track_window
+        img2 = cv.rectangle(frame, (x,y), (x+w,y+h), 255,2)
+        cv.imshow('img2',img2)
+
+        k = cv.waitKey(30) & 0xff
+        if k == 27:
+            break
+    else:
+        break
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/video/optical_flow/optical_flow.py b/C++/opencv-4.7.0/samples/python/tutorial_code/video/optical_flow/optical_flow.py
new file mode 100644
index 00000000..0e298e77
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/video/optical_flow/optical_flow.py
@@ -0,0 +1,68 @@
+import numpy as np
+import cv2 as cv
+import argparse
+
+parser = argparse.ArgumentParser(description='This sample demonstrates Lucas-Kanade Optical Flow calculation. \
+                                              The example file can be downloaded from: \
+                                              https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4')
+parser.add_argument('image', type=str, help='path to image file')
+args = parser.parse_args()
+
+cap = cv.VideoCapture(args.image)
+
+# params for ShiTomasi corner detection
+feature_params = dict( maxCorners = 100,
+                       qualityLevel = 0.3,
+                       minDistance = 7,
+                       blockSize = 7 )
+
+# Parameters for lucas kanade optical flow
+lk_params = dict( winSize  = (15, 15),
+                  maxLevel = 2,
+                  criteria = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 0.03))
+
+# Create some random colors
+color = np.random.randint(0, 255, (100, 3))
+
+# Take first frame and find corners in it
+ret, old_frame = cap.read()
+old_gray = cv.cvtColor(old_frame, cv.COLOR_BGR2GRAY)
+p0 = cv.goodFeaturesToTrack(old_gray, mask = None, **feature_params)
+
+# Create a mask image for drawing purposes
+mask = np.zeros_like(old_frame)
+
+while(1):
+    ret, frame = cap.read()
+    if not ret:
+        print('No frames grabbed!')
+        break
+
+    frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+
+    # calculate optical flow
+    p1, st, err = cv.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)
+
+    # Select good points
+    if p1 is not None:
+        good_new = p1[st==1]
+        good_old = p0[st==1]
+
+    # draw the tracks
+    for i, (new, old) in enumerate(zip(good_new, good_old)):
+        a, b = new.ravel()
+        c, d = old.ravel()
+        mask = cv.line(mask, (int(a), int(b)), (int(c), int(d)), color[i].tolist(), 2)
+        frame = cv.circle(frame, (int(a), int(b)), 5, color[i].tolist(), -1)
+    img = cv.add(frame, mask)
+
+    cv.imshow('frame', img)
+    k = cv.waitKey(30) & 0xff
+    if k == 27:
+        break
+
+    # Now update the previous frame and previous points
+    old_gray = frame_gray.copy()
+    p0 = good_new.reshape(-1, 1, 2)
+
+cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/video/optical_flow/optical_flow_dense.py b/C++/opencv-4.7.0/samples/python/tutorial_code/video/optical_flow/optical_flow_dense.py
new file mode 100644
index 00000000..8980c151
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/video/optical_flow/optical_flow_dense.py
@@ -0,0 +1,29 @@
+import numpy as np
+import cv2 as cv
+cap = cv.VideoCapture(cv.samples.findFile("vtest.avi"))
+ret, frame1 = cap.read()
+prvs = cv.cvtColor(frame1, cv.COLOR_BGR2GRAY)
+hsv = np.zeros_like(frame1)
+hsv[..., 1] = 255
+while(1):
+    ret, frame2 = cap.read()
+    if not ret:
+        print('No frames grabbed!')
+        break
+
+    next = cv.cvtColor(frame2, cv.COLOR_BGR2GRAY)
+    flow = cv.calcOpticalFlowFarneback(prvs, next, None, 0.5, 3, 15, 3, 5, 1.2, 0)
+    mag, ang = cv.cartToPolar(flow[..., 0], flow[..., 1])
+    hsv[..., 0] = ang*180/np.pi/2
+    hsv[..., 2] = cv.normalize(mag, None, 0, 255, cv.NORM_MINMAX)
+    bgr = cv.cvtColor(hsv, cv.COLOR_HSV2BGR)
+    cv.imshow('frame2', bgr)
+    k = cv.waitKey(30) & 0xff
+    if k == 27:
+        break
+    elif k == ord('s'):
+        cv.imwrite('opticalfb.png', frame2)
+        cv.imwrite('opticalhsv.png', bgr)
+    prvs = next
+
+cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/tutorial_code/videoio/video-input-psnr-ssim.py b/C++/opencv-4.7.0/samples/python/tutorial_code/videoio/video-input-psnr-ssim.py
new file mode 100644
index 00000000..973854fe
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/tutorial_code/videoio/video-input-psnr-ssim.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+import argparse
+import sys
+
+# [get-psnr]
+def getPSNR(I1, I2):
+    s1 = cv.absdiff(I1, I2) #|I1 - I2|
+    s1 = np.float32(s1)     # cannot make a square on 8 bits
+    s1 = s1 * s1            # |I1 - I2|^2
+    sse = s1.sum()          # sum elements per channel
+    if sse <= 1e-10:        # sum channels
+        return 0            # for small values return zero
+    else:
+        shape = I1.shape
+        mse = 1.0 * sse / (shape[0] * shape[1] * shape[2])
+        psnr = 10.0 * np.log10((255 * 255) / mse)
+        return psnr
+# [get-psnr]
+
+# [get-mssim]
+def getMSSISM(i1, i2):
+    C1 = 6.5025
+    C2 = 58.5225
+    # INITS
+
+    I1 = np.float32(i1) # cannot calculate on one byte large values
+    I2 = np.float32(i2)
+
+    I2_2 = I2 * I2 # I2^2
+    I1_2 = I1 * I1 # I1^2
+    I1_I2 = I1 * I2 # I1 * I2
+    # END INITS
+
+    # PRELIMINARY COMPUTING
+    mu1 = cv.GaussianBlur(I1, (11, 11), 1.5)
+    mu2 = cv.GaussianBlur(I2, (11, 11), 1.5)
+
+    mu1_2 = mu1 * mu1
+    mu2_2 = mu2 * mu2
+    mu1_mu2 = mu1 * mu2
+
+    sigma1_2 = cv.GaussianBlur(I1_2, (11, 11), 1.5)
+    sigma1_2 -= mu1_2
+
+    sigma2_2 = cv.GaussianBlur(I2_2, (11, 11), 1.5)
+    sigma2_2 -= mu2_2
+
+    sigma12 = cv.GaussianBlur(I1_I2, (11, 11), 1.5)
+    sigma12 -= mu1_mu2
+
+    t1 = 2 * mu1_mu2 + C1
+    t2 = 2 * sigma12 + C2
+    t3 = t1 * t2                    # t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+
+    t1 = mu1_2 + mu2_2 + C1
+    t2 = sigma1_2 + sigma2_2 + C2
+    t1 = t1 * t2                    # t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+
+    ssim_map = cv.divide(t3, t1)    # ssim_map =  t3./t1;
+
+    mssim = cv.mean(ssim_map)       # mssim = average of ssim map
+    return mssim
+# [get-mssim]
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-d", "--delay", type=int, default=30, help=" Time delay")
+    parser.add_argument("-v", "--psnrtriggervalue", type=int, default=30, help="PSNR Trigger Value")
+    parser.add_argument("-r", "--ref", type=str, default="Megamind.avi", help="Path to reference video")
+    parser.add_argument("-t", "--undertest", type=str, default="Megamind_bugy.avi",
+                        help="Path to the video to be tested")
+    args = parser.parse_args()
+
+    sourceReference = args.ref
+    sourceCompareWith = args.undertest
+    delay = args.delay
+    psnrTriggerValue = args.psnrtriggervalue
+
+    framenum = -1 # Frame counter
+
+    captRefrnc = cv.VideoCapture(cv.samples.findFileOrKeep(sourceReference))
+    captUndTst = cv.VideoCapture(cv.samples.findFileOrKeep(sourceCompareWith))
+
+    if not captRefrnc.isOpened():
+        print("Could not open the reference " + sourceReference)
+        sys.exit(-1)
+    if not captUndTst.isOpened():
+        print("Could not open case test " + sourceCompareWith)
+        sys.exit(-1)
+
+    refS = (int(captRefrnc.get(cv.CAP_PROP_FRAME_WIDTH)), int(captRefrnc.get(cv.CAP_PROP_FRAME_HEIGHT)))
+    uTSi = (int(captUndTst.get(cv.CAP_PROP_FRAME_WIDTH)), int(captUndTst.get(cv.CAP_PROP_FRAME_HEIGHT)))
+
+    if refS != uTSi:
+        print("Inputs have different size!!! Closing.")
+        sys.exit(-1)
+
+    WIN_UT = "Under Test"
+    WIN_RF = "Reference"
+
+    cv.namedWindow(WIN_RF, cv.WINDOW_AUTOSIZE)
+    cv.namedWindow(WIN_UT, cv.WINDOW_AUTOSIZE)
+    cv.moveWindow(WIN_RF, 400, 0) #750,  2 (bernat =0)
+    cv.moveWindow(WIN_UT, refS[0], 0) #1500, 2
+
+    print("Reference frame resolution: Width={} Height={} of nr#: {}".format(refS[0], refS[1],
+                                                                             captRefrnc.get(cv.CAP_PROP_FRAME_COUNT)))
+    print("PSNR trigger value {}".format(psnrTriggerValue))
+
+    while True: # Show the image captured in the window and repeat
+        _, frameReference = captRefrnc.read()
+        _, frameUnderTest = captUndTst.read()
+
+        if frameReference is None or frameUnderTest is None:
+            print(" < < <  Game over!  > > > ")
+            break
+
+        framenum += 1
+        psnrv = getPSNR(frameReference, frameUnderTest)
+        print("Frame: {}# {}dB".format(framenum, round(psnrv, 3)), end=" ")
+
+        if (psnrv < psnrTriggerValue and psnrv):
+            mssimv = getMSSISM(frameReference, frameUnderTest)
+            print("MSSISM: R {}% G {}% B {}%".format(round(mssimv[2] * 100, 2), round(mssimv[1] * 100, 2),
+                                                     round(mssimv[0] * 100, 2)), end=" ")
+
+        print()
+
+        cv.imshow(WIN_RF, frameReference)
+        cv.imshow(WIN_UT, frameUnderTest)
+
+        k = cv.waitKey(delay)
+        if k == 27:
+            break
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/C++/opencv-4.7.0/samples/python/video.py b/C++/opencv-4.7.0/samples/python/video.py
new file mode 100644
index 00000000..68202683
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/video.py
@@ -0,0 +1,228 @@
+#!/usr/bin/env python
+
+'''
+Video capture sample.
+
+Sample shows how VideoCapture class can be used to acquire video
+frames from a camera of a movie file. Also the sample provides
+an example of procedural video generation by an object, mimicking
+the VideoCapture interface (see Chess class).
+
+'create_capture' is a convenience function for capture creation,
+falling back to procedural video in case of error.
+
+Usage:
+    video.py [--shotdir <shot path>] [source0] [source1] ...'
+
+    sourceN is an
+     - integer number for camera capture
+     - name of video file
+     - synth:<params> for procedural video
+
+Synth examples:
+    synth:bg=lena.jpg:noise=0.1
+    synth:class=chess:bg=lena.jpg:noise=0.1:size=640x480
+
+Keys:
+    ESC    - exit
+    SPACE  - save current frame to <shot path> directory
+
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+import re
+
+from numpy import pi, sin, cos
+
+# local modules
+from tst_scene_render import TestSceneRender
+import common
+
+class VideoSynthBase(object):
+    def __init__(self, size=None, noise=0.0, bg = None, **params):
+        self.bg = None
+        self.frame_size = (640, 480)
+        if bg is not None:
+            self.bg = cv.imread(cv.samples.findFile(bg))
+            h, w = self.bg.shape[:2]
+            self.frame_size = (w, h)
+
+        if size is not None:
+            w, h = map(int, size.split('x'))
+            self.frame_size = (w, h)
+            self.bg = cv.resize(self.bg, self.frame_size)
+
+        self.noise = float(noise)
+
+    def render(self, dst):
+        pass
+
+    def read(self, dst=None):
+        w, h = self.frame_size
+
+        if self.bg is None:
+            buf = np.zeros((h, w, 3), np.uint8)
+        else:
+            buf = self.bg.copy()
+
+        self.render(buf)
+
+        if self.noise > 0.0:
+            noise = np.zeros((h, w, 3), np.int8)
+            cv.randn(noise, np.zeros(3), np.ones(3)*255*self.noise)
+            buf = cv.add(buf, noise, dtype=cv.CV_8UC3)
+        return True, buf
+
+    def isOpened(self):
+        return True
+
+class Book(VideoSynthBase):
+    def __init__(self, **kw):
+        super(Book, self).__init__(**kw)
+        backGr = cv.imread(cv.samples.findFile('graf1.png'))
+        fgr = cv.imread(cv.samples.findFile('box.png'))
+        self.render = TestSceneRender(backGr, fgr, speed = 1)
+
+    def read(self, dst=None):
+        noise = np.zeros(self.render.sceneBg.shape, np.int8)
+        cv.randn(noise, np.zeros(3), np.ones(3)*255*self.noise)
+
+        return True, cv.add(self.render.getNextFrame(), noise, dtype=cv.CV_8UC3)
+
+class Cube(VideoSynthBase):
+    def __init__(self, **kw):
+        super(Cube, self).__init__(**kw)
+        self.render = TestSceneRender(cv.imread(cv.samples.findFile('pca_test1.jpg')), deformation = True,  speed = 1)
+
+    def read(self, dst=None):
+        noise = np.zeros(self.render.sceneBg.shape, np.int8)
+        cv.randn(noise, np.zeros(3), np.ones(3)*255*self.noise)
+
+        return True, cv.add(self.render.getNextFrame(), noise, dtype=cv.CV_8UC3)
+
+class Chess(VideoSynthBase):
+    def __init__(self, **kw):
+        super(Chess, self).__init__(**kw)
+
+        w, h = self.frame_size
+
+        self.grid_size = sx, sy = 10, 7
+        white_quads = []
+        black_quads = []
+        for i, j in np.ndindex(sy, sx):
+            q = [[j, i, 0], [j+1, i, 0], [j+1, i+1, 0], [j, i+1, 0]]
+            [white_quads, black_quads][(i + j) % 2].append(q)
+        self.white_quads = np.float32(white_quads)
+        self.black_quads = np.float32(black_quads)
+
+        fx = 0.9
+        self.K = np.float64([[fx*w, 0, 0.5*(w-1)],
+                        [0, fx*w, 0.5*(h-1)],
+                        [0.0,0.0,      1.0]])
+
+        self.dist_coef = np.float64([-0.2, 0.1, 0, 0])
+        self.t = 0
+
+    def draw_quads(self, img, quads, color = (0, 255, 0)):
+        img_quads = cv.projectPoints(quads.reshape(-1, 3), self.rvec, self.tvec, self.K, self.dist_coef) [0]
+        img_quads.shape = quads.shape[:2] + (2,)
+        for q in img_quads:
+            cv.fillConvexPoly(img, np.int32(q*4), color, cv.LINE_AA, shift=2)
+
+    def render(self, dst):
+        t = self.t
+        self.t += 1.0/30.0
+
+        sx, sy = self.grid_size
+        center = np.array([0.5*sx, 0.5*sy, 0.0])
+        phi = pi/3 + sin(t*3)*pi/8
+        c, s = cos(phi), sin(phi)
+        ofs = np.array([sin(1.2*t), cos(1.8*t), 0]) * sx * 0.2
+        eye_pos = center + np.array([cos(t)*c, sin(t)*c, s]) * 15.0 + ofs
+        target_pos = center + ofs
+
+        R, self.tvec = common.lookat(eye_pos, target_pos)
+        self.rvec = common.mtx2rvec(R)
+
+        self.draw_quads(dst, self.white_quads, (245, 245, 245))
+        self.draw_quads(dst, self.black_quads, (10, 10, 10))
+
+
+classes = dict(chess=Chess, book=Book, cube=Cube)
+
+presets = dict(
+    empty = 'synth:',
+    lena = 'synth:bg=lena.jpg:noise=0.1',
+    chess = 'synth:class=chess:bg=lena.jpg:noise=0.1:size=640x480',
+    book = 'synth:class=book:bg=graf1.png:noise=0.1:size=640x480',
+    cube = 'synth:class=cube:bg=pca_test1.jpg:noise=0.0:size=640x480'
+)
+
+
+def create_capture(source = 0, fallback = presets['chess']):
+    '''source: <int> or '<int>|<filename>|synth [:<param_name>=<value> [:...]]'
+    '''
+    source = str(source).strip()
+
+    # Win32: handle drive letter ('c:', ...)
+    source = re.sub(r'(^|=)([a-zA-Z]):([/\\a-zA-Z0-9])', r'\1?disk\2?\3', source)
+    chunks = source.split(':')
+    chunks = [re.sub(r'\?disk([a-zA-Z])\?', r'\1:', s) for s in chunks]
+
+    source = chunks[0]
+    try: source = int(source)
+    except ValueError: pass
+    params = dict( s.split('=') for s in chunks[1:] )
+
+    cap = None
+    if source == 'synth':
+        Class = classes.get(params.get('class', None), VideoSynthBase)
+        try: cap = Class(**params)
+        except: pass
+    else:
+        cap = cv.VideoCapture(source)
+        if 'size' in params:
+            w, h = map(int, params['size'].split('x'))
+            cap.set(cv.CAP_PROP_FRAME_WIDTH, w)
+            cap.set(cv.CAP_PROP_FRAME_HEIGHT, h)
+    if cap is None or not cap.isOpened():
+        print('Warning: unable to open video source: ', source)
+        if fallback is not None:
+            return create_capture(fallback, None)
+    return cap
+
+if __name__ == '__main__':
+    import sys
+    import getopt
+
+    print(__doc__)
+
+    args, sources = getopt.getopt(sys.argv[1:], '', 'shotdir=')
+    args = dict(args)
+    shotdir = args.get('--shotdir', '.')
+    if len(sources) == 0:
+        sources = [ 0 ]
+
+    caps = list(map(create_capture, sources))
+    shot_idx = 0
+    while True:
+        imgs = []
+        for i, cap in enumerate(caps):
+            ret, img = cap.read()
+            imgs.append(img)
+            cv.imshow('capture %d' % i, img)
+        ch = cv.waitKey(1)
+        if ch == 27:
+            break
+        if ch == ord(' '):
+            for i, img in enumerate(imgs):
+                fn = '%s/shot_%d_%03d.bmp' % (shotdir, i, shot_idx)
+                cv.imwrite(fn, img)
+                print(fn, 'saved')
+            shot_idx += 1
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/video_threaded.py b/C++/opencv-4.7.0/samples/python/video_threaded.py
new file mode 100644
index 00000000..cbc73d29
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/video_threaded.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+
+'''
+Multithreaded video processing sample.
+Usage:
+   video_threaded.py {<video device number>|<video file name>}
+
+   Shows how python threading capabilities can be used
+   to organize parallel captured frame processing pipeline
+   for smoother playback.
+
+Keyboard shortcuts:
+
+   ESC - exit
+   space - switch between multi and single threaded processing
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+from multiprocessing.pool import ThreadPool
+from collections import deque
+
+from common import clock, draw_str, StatValue
+import video
+
+
+class DummyTask:
+    def __init__(self, data):
+        self.data = data
+    def ready(self):
+        return True
+    def get(self):
+        return self.data
+
+def main():
+    import sys
+
+    try:
+        fn = sys.argv[1]
+    except:
+        fn = 0
+    cap = video.create_capture(fn)
+
+
+    def process_frame(frame, t0):
+        # some intensive computation...
+        frame = cv.medianBlur(frame, 19)
+        frame = cv.medianBlur(frame, 19)
+        return frame, t0
+
+    threadn = cv.getNumberOfCPUs()
+    pool = ThreadPool(processes = threadn)
+    pending = deque()
+
+    threaded_mode = True
+
+    latency = StatValue()
+    frame_interval = StatValue()
+    last_frame_time = clock()
+    while True:
+        while len(pending) > 0 and pending[0].ready():
+            res, t0 = pending.popleft().get()
+            latency.update(clock() - t0)
+            draw_str(res, (20, 20), "threaded      :  " + str(threaded_mode))
+            draw_str(res, (20, 40), "latency        :  %.1f ms" % (latency.value*1000))
+            draw_str(res, (20, 60), "frame interval :  %.1f ms" % (frame_interval.value*1000))
+            cv.imshow('threaded video', res)
+        if len(pending) < threadn:
+            _ret, frame = cap.read()
+            t = clock()
+            frame_interval.update(t - last_frame_time)
+            last_frame_time = t
+            if threaded_mode:
+                task = pool.apply_async(process_frame, (frame.copy(), t))
+            else:
+                task = DummyTask(process_frame(frame, t))
+            pending.append(task)
+        ch = cv.waitKey(1)
+        if ch == ord(' '):
+            threaded_mode = not threaded_mode
+        if ch == 27:
+            break
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/video_v4l2.py b/C++/opencv-4.7.0/samples/python/video_v4l2.py
new file mode 100644
index 00000000..abebb2a2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/video_v4l2.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+
+'''
+VideoCapture sample showcasing  some features of the Video4Linux2 backend
+
+Sample shows how VideoCapture class can be used to control parameters
+of a webcam such as focus or framerate.
+Also the sample provides an example how to access raw images delivered
+by the hardware to get a grayscale image in a very efficient fashion.
+
+Keys:
+    ESC    - exit
+    g      - toggle optimized grayscale conversion
+
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+def main():
+
+    def decode_fourcc(v):
+        v = int(v)
+        return "".join([chr((v >> 8 * i) & 0xFF) for i in range(4)])
+
+    font = cv.FONT_HERSHEY_SIMPLEX
+    color = (0, 255, 0)
+
+    cap = cv.VideoCapture(0)
+    cap.set(cv.CAP_PROP_AUTOFOCUS, 0)  # Known bug: https://github.com/opencv/opencv/pull/5474
+
+    cv.namedWindow("Video")
+
+    convert_rgb = True
+    fps = int(cap.get(cv.CAP_PROP_FPS))
+    focus = int(min(cap.get(cv.CAP_PROP_FOCUS) * 100, 2**31-1))  # ceil focus to C_LONG as Python3 int can go to +inf
+
+    cv.createTrackbar("FPS", "Video", fps, 30, lambda v: cap.set(cv.CAP_PROP_FPS, v))
+    cv.createTrackbar("Focus", "Video", focus, 100, lambda v: cap.set(cv.CAP_PROP_FOCUS, v / 100))
+
+    while True:
+        _status, img = cap.read()
+
+        fourcc = decode_fourcc(cap.get(cv.CAP_PROP_FOURCC))
+
+        fps = cap.get(cv.CAP_PROP_FPS)
+
+        if not bool(cap.get(cv.CAP_PROP_CONVERT_RGB)):
+            if fourcc == "MJPG":
+                img = cv.imdecode(img, cv.IMREAD_GRAYSCALE)
+            elif fourcc == "YUYV":
+                img = cv.cvtColor(img, cv.COLOR_YUV2GRAY_YUYV)
+            else:
+                print("unsupported format")
+                break
+
+        cv.putText(img, "Mode: {}".format(fourcc), (15, 40), font, 1.0, color)
+        cv.putText(img, "FPS: {}".format(fps), (15, 80), font, 1.0, color)
+        cv.imshow("Video", img)
+
+        k = cv.waitKey(1)
+
+        if k == 27:
+            break
+        elif k == ord('g'):
+            convert_rgb = not convert_rgb
+            cap.set(cv.CAP_PROP_CONVERT_RGB, 1 if convert_rgb else 0)
+
+    print('Done')
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    main()
+    cv.destroyAllWindows()
diff --git a/C++/opencv-4.7.0/samples/python/watershed.py b/C++/opencv-4.7.0/samples/python/watershed.py
new file mode 100644
index 00000000..7c71c815
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/python/watershed.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+
+'''
+Watershed segmentation
+=========
+
+This program demonstrates the watershed segmentation algorithm
+in OpenCV: watershed().
+
+Usage
+-----
+watershed.py [image filename]
+
+Keys
+----
+  1-7   - switch marker color
+  SPACE - update segmentation
+  r     - reset
+  a     - toggle autoupdate
+  ESC   - exit
+
+'''
+
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+from common import Sketcher
+
+class App:
+    def __init__(self, fn):
+        self.img = cv.imread(fn)
+        if self.img is None:
+            raise Exception('Failed to load image file: %s' % fn)
+
+        h, w = self.img.shape[:2]
+        self.markers = np.zeros((h, w), np.int32)
+        self.markers_vis = self.img.copy()
+        self.cur_marker = 1
+        self.colors = np.int32( list(np.ndindex(2, 2, 2)) ) * 255
+
+        self.auto_update = True
+        self.sketch = Sketcher('img', [self.markers_vis, self.markers], self.get_colors)
+
+    def get_colors(self):
+        return list(map(int, self.colors[self.cur_marker])), self.cur_marker
+
+    def watershed(self):
+        m = self.markers.copy()
+        cv.watershed(self.img, m)
+        overlay = self.colors[np.maximum(m, 0)]
+        vis = cv.addWeighted(self.img, 0.5, overlay, 0.5, 0.0, dtype=cv.CV_8UC3)
+        cv.imshow('watershed', vis)
+
+    def run(self):
+        while cv.getWindowProperty('img', 0) != -1 or cv.getWindowProperty('watershed', 0) != -1:
+            ch = cv.waitKey(50)
+            if ch == 27:
+                break
+            if ch >= ord('1') and ch <= ord('7'):
+                self.cur_marker = ch - ord('0')
+                print('marker: ', self.cur_marker)
+            if ch == ord(' ') or (self.sketch.dirty and self.auto_update):
+                self.watershed()
+                self.sketch.dirty = False
+            if ch in [ord('a'), ord('A')]:
+                self.auto_update = not self.auto_update
+                print('auto_update if', ['off', 'on'][self.auto_update])
+            if ch in [ord('r'), ord('R')]:
+                self.markers[:] = 0
+                self.markers_vis[:] = self.img
+                self.sketch.show()
+        cv.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    print(__doc__)
+    import sys
+    try:
+        fn = sys.argv[1]
+    except:
+        fn = 'fruits.jpg'
+    App(cv.samples.findFile(fn)).run()
diff --git a/C++/opencv-4.7.0/samples/samples_utils.cmake b/C++/opencv-4.7.0/samples/samples_utils.cmake
new file mode 100644
index 00000000..2780b479
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/samples_utils.cmake
@@ -0,0 +1,38 @@
+# Utility function: adds sample executable target with name "example_<group>_<file_name>"
+# Usage:
+#   ocv_define_sample(<output target> <relative filename> <group>)
+function(ocv_define_sample out_target source sub)
+  get_filename_component(name "${source}" NAME_WE)
+  set(the_target "example_${sub}_${name}")
+  if(OPENCV_DUMP_EXAMPLE_TARGET)
+    message(STATUS "Example: ${the_target}    (${source})")
+  endif()
+  add_executable(${the_target} "${source}")
+  if(TARGET Threads::Threads AND NOT OPENCV_EXAMPLES_DISABLE_THREADS)
+    target_link_libraries(${the_target} PRIVATE Threads::Threads)
+  endif()
+  set_target_properties(${the_target} PROPERTIES PROJECT_LABEL "(sample) ${name}")
+  if(ENABLE_SOLUTION_FOLDERS)
+    set_target_properties(${the_target} PROPERTIES FOLDER "samples/${sub}")
+  endif()
+  if(WIN32 AND MSVC AND NOT BUILD_SHARED_LIBS)
+    set_target_properties(${the_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:atlsd.lib /DEBUG")
+  endif()
+  # Should be usable in stand-alone build scenario
+  if((NOT DEFINED INSTALL_BIN_EXAMPLES AND WIN32) OR INSTALL_BIN_EXAMPLES)
+    if(NOT DEFINED OPENCV_SAMPLES_BIN_INSTALL_PATH)
+      set(OPENCV_SAMPLES_BIN_INSTALL_PATH "samples")
+    endif()
+    install(TARGETS ${the_target} RUNTIME DESTINATION "${OPENCV_SAMPLES_BIN_INSTALL_PATH}/${sub}" COMPONENT samples)
+  endif()
+  # Add single target to build all samples in the group: 'make opencv_samples_cpp'
+  set(parent_target opencv_samples_${sub})
+  if(NOT TARGET ${parent_target})
+    add_custom_target(${parent_target})
+    if(TARGET opencv_samples)
+      add_dependencies(opencv_samples ${parent_target})
+    endif()
+  endif()
+  add_dependencies(${parent_target} ${the_target})
+  set(${out_target} ${the_target} PARENT_SCOPE)
+endfunction()
diff --git a/C++/opencv-4.7.0/samples/semihosting/CMakeLists.txt b/C++/opencv-4.7.0/samples/semihosting/CMakeLists.txt
new file mode 100644
index 00000000..9fddb058
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/semihosting/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This file is part of OpenCV project.
+# It is subject to the license terms in the LICENSE file found in the top-level directory
+# of this distribution and at http://opencv.org/license.html
+
+set(SEMIHOSTING_SUFFIX semihosting)
+
+add_subdirectory(include)
+set(RAW_PIXEL_INCLUDE ${CMAKE_CURRENT_BINARY_DIR}/include)
+add_subdirectory(histogram)
+add_subdirectory(norm)
diff --git a/C++/opencv-4.7.0/samples/semihosting/README.md b/C++/opencv-4.7.0/samples/semihosting/README.md
new file mode 100644
index 00000000..881b09b7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/semihosting/README.md
@@ -0,0 +1,27 @@
+# Arm semihosting
+
+This folder contain a toolchain file and a couple of examples for
+building OpenCV based applications that can run in an [Arm
+semihosting](https://developer.arm.com/documentation/100863/latest)
+setup.
+
+OpenCV can be compiled to target a semihosting platform as follows:
+
+```
+cmake ../opencv/ \
+    -DCMAKE_TOOLCHAIN_FILE=../opencv/platforms/semihosting/aarch64-semihosting.toolchain.cmake \
+    -DSEMIHOSTING_TOOLCHAIN_PATH=/path/to/baremetal-toolchain/bin/ \
+    -DBUILD_EXAMPLES=ON -GNinja
+```
+
+A barematel toolchain for targeting aarch64 semihosting can be found
+[here](https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads),
+under `aarch64-none-elf`.
+
+The code of the examples in the `norm` and `histogram` folders can be
+executed with qemu in Linux userspace:
+
+```
+    qemu-aarch64 ./bin/example_semihosting_histogram
+    qemu-aarch64 ./bin/example_semihosting_norm
+```
diff --git a/C++/opencv-4.7.0/samples/semihosting/histogram/CMakeLists.txt b/C++/opencv-4.7.0/samples/semihosting/histogram/CMakeLists.txt
new file mode 100644
index 00000000..d2f065d1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/semihosting/histogram/CMakeLists.txt
@@ -0,0 +1,26 @@
+# This file is part of OpenCV project.
+# It is subject to the license terms in the LICENSE file found in the top-level directory
+# of this distribution and at http://opencv.org/license.html
+
+set(PROJECT_NAME histogram)
+project(${PROJECT_NAME})
+
+ocv_install_example_src(histogram *.cpp *.hpp CMakeLists.txt)
+
+set(LOCAL_DEPS
+  opencv_core
+  opencv_imgproc
+  ${OPENCV_MODULES_PUBLIC}
+  ${OpenCV_LIB_COMPONENTS})
+ocv_check_dependencies(${LOCAL_DEPS})
+
+if(NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+ocv_define_sample(histogram histogram.cpp ${SEMIHOSTING_SUFFIX})
+ocv_include_modules_recurse(${LOCAL_DEPS})
+target_include_directories(${histogram} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+target_include_directories(${histogram} PRIVATE ${RAW_PIXEL_INCLUDE})
+ocv_target_link_libraries(${histogram} PRIVATE ${OPENCV_LINKER_LIBS}
+  ${LOCAL_DEPS})
diff --git a/C++/opencv-4.7.0/samples/semihosting/histogram/histogram.cpp b/C++/opencv-4.7.0/samples/semihosting/histogram/histogram.cpp
new file mode 100644
index 00000000..49b9902b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/semihosting/histogram/histogram.cpp
@@ -0,0 +1,43 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include <opencv2/imgproc.hpp>
+#include <opencv2/imgcodecs.hpp>
+
+#include <cstdint>
+#include <array>
+#include <iostream>
+#include "raw_pixels.hpp"
+
+#define IMG_ROWS 100
+#define IMG_COLS 100
+
+static_assert(IMG_ROWS * IMG_COLS <= RAW_PIXELS_SIZE, "Incompatible size");
+
+int main(void)
+{
+    // Number of experiment runs
+    int no_runs = 2;
+
+    // https://docs.opencv.org/4.x/d3/d63/classcv_1_1Mat.html
+    cv::Mat src_new(IMG_ROWS, IMG_COLS, CV_8UC1, (void *)raw_pixels);
+
+    // Set parameters
+    int imgCount = 1;
+    const int channels[] = {0};
+    cv::Mat mask = cv::Mat();
+    cv::Mat hist;
+    int dims = 1;
+    const int hist_sizes[] = {256};
+    float Range[] = {0,256};
+    const float *ranges[] = {Range};
+
+    // Run calc Hist
+    for(int i=0; i < no_runs; i++){
+        std::cout << "Running iteration # "<< i << std::endl;
+        cv::calcHist(&src_new, imgCount, channels, mask, hist, dims, hist_sizes, ranges);
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/semihosting/include/CMakeLists.txt b/C++/opencv-4.7.0/samples/semihosting/include/CMakeLists.txt
new file mode 100644
index 00000000..3c429b8a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/semihosting/include/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Populate a C array with random data.
+set(RAW_PIXELS_SIZE 102400)
+set(RAW_PIXELS_HEADER ${CMAKE_CURRENT_BINARY_DIR}/raw_pixels.hpp)
+set(RAW_PIXELS_HEADER_IN ${CMAKE_CURRENT_SOURCE_DIR}/raw_pixels.hpp.in)
+
+set(RAW_PIXEL_VALUES "")
+# Seed the random number generator.
+string(RANDOM LENGTH 8 ALPHABET 0123456789abcdf RANDOM_SEED 314 number)
+math(EXPR LOOP_RANGE "${RAW_PIXELS_SIZE} - 1")
+
+foreach(i RANGE ${LOOP_RANGE})
+  string(RANDOM LENGTH 8 ALPHABET 0123456789abcdf number)
+  string(CONCAT RAW_PIXEL_VALUES ${RAW_PIXEL_VALUES} "0x${number}, \\\n")
+endforeach()
+
+configure_file(${RAW_PIXELS_HEADER_IN} ${RAW_PIXELS_HEADER})
diff --git a/C++/opencv-4.7.0/samples/semihosting/include/raw_pixels.hpp.in b/C++/opencv-4.7.0/samples/semihosting/include/raw_pixels.hpp.in
new file mode 100644
index 00000000..6ee98222
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/semihosting/include/raw_pixels.hpp.in
@@ -0,0 +1,11 @@
+#ifndef RAW_PIXELS_HPP
+#define RAW_PIXELS_HP
+#include <cstdint>
+
+#cmakedefine RAW_PIXEL_VALUES @RAW_PIXEL_VALUES@
+#cmakedefine RAW_PIXELS_SIZE @RAW_PIXELS_SIZE@
+
+static std::uint32_t raw_pixels[RAW_PIXELS_SIZE] = {
+    RAW_PIXEL_VALUES
+};
+#endif //RAW_PIXELS_HPP
diff --git a/C++/opencv-4.7.0/samples/semihosting/norm/CMakeLists.txt b/C++/opencv-4.7.0/samples/semihosting/norm/CMakeLists.txt
new file mode 100644
index 00000000..6f23d746
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/semihosting/norm/CMakeLists.txt
@@ -0,0 +1,25 @@
+# This file is part of OpenCV project.
+# It is subject to the license terms in the LICENSE file found in the top-level directory
+# of this distribution and at http://opencv.org/license.html
+
+set(PROJECT_NAME norm)
+project(${PROJECT_NAME})
+
+ocv_install_example_src(norm *.cpp *.hpp CMakeLists.txt)
+
+set(LOCAL_DEPS
+  opencv_core
+  ${OPENCV_MODULES_PUBLIC}
+  ${OpenCV_LIB_COMPONENTS})
+ocv_check_dependencies(${LOCAL_DEPS})
+
+if(NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+ocv_define_sample(norm norm.cpp ${SEMIHOSTING_SUFFIX})
+ocv_include_modules_recurse(${LOCAL_DEPS})
+target_include_directories(${norm} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+target_include_directories(${norm} PRIVATE ${RAW_PIXEL_INCLUDE})
+ocv_target_link_libraries(${norm} PRIVATE ${OPENCV_LINKER_LIBS}
+  ${LOCAL_DEPS})
diff --git a/C++/opencv-4.7.0/samples/semihosting/norm/norm.cpp b/C++/opencv-4.7.0/samples/semihosting/norm/norm.cpp
new file mode 100644
index 00000000..849c9cdc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/semihosting/norm/norm.cpp
@@ -0,0 +1,33 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgcodecs.hpp>
+
+#include <cstdint>
+#include <array>
+#include <iostream>
+#include "raw_pixels.hpp"
+
+#define IMG_ROWS 100
+#define IMG_COLS 100
+
+static_assert(IMG_ROWS * IMG_COLS <= RAW_PIXELS_SIZE, "Incompatible size");
+
+int main(void)
+{
+    // Number of experiment runs
+    int no_runs = 2;
+
+    // https://docs.opencv.org/4.x/d3/d63/classcv_1_1Mat.html
+    cv::Mat src(IMG_ROWS, IMG_COLS, CV_8UC1, (void *)raw_pixels);
+
+    // Run calc Hist
+    for(int i=0; i < no_runs; i++){
+        std::cout << "Running iteration # "<< i << std::endl;
+        cv::norm(src);
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection.xcodeproj/project.pbxproj b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection.xcodeproj/project.pbxproj
new file mode 100644
index 00000000..be696a84
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection.xcodeproj/project.pbxproj
@@ -0,0 +1,397 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 50;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		5B14CF802452E926003438BE /* OpenCV.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5B14CF7F2452E926003438BE /* OpenCV.framework */; };
+		5B8C4C2D243814E9003D9176 /* libc++.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 5B8C4C2C243814A0003D9176 /* libc++.tbd */; };
+		5B8C4C31243849E9003D9176 /* ColorBlobDetector.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5B8C4C30243849E9003D9176 /* ColorBlobDetector.swift */; };
+		5BBDB48A240D380F00BB10FE /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5BBDB489240D380F00BB10FE /* AppDelegate.swift */; };
+		5BBDB48E240D380F00BB10FE /* ViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5BBDB48D240D380F00BB10FE /* ViewController.swift */; };
+		5BBDB491240D380F00BB10FE /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB48F240D380F00BB10FE /* Main.storyboard */; };
+		5BBDB493240D381000BB10FE /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB492240D381000BB10FE /* Assets.xcassets */; };
+		5BBDB496240D381000BB10FE /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */; };
+		5BBDB517241923C800BB10FE /* AVFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5BBDB516241923C800BB10FE /* AVFoundation.framework */; };
+		5BBDB5192419241200BB10FE /* CoreMedia.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5BBDB5182419241200BB10FE /* CoreMedia.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		5B14CF7F2452E926003438BE /* OpenCV.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenCV.framework; path = ../../../OpenCV.framework; sourceTree = "<group>"; };
+		5B8C4C2C243814A0003D9176 /* libc++.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = "libc++.tbd"; path = "usr/lib/libc++.tbd"; sourceTree = SDKROOT; };
+		5B8C4C30243849E9003D9176 /* ColorBlobDetector.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ColorBlobDetector.swift; sourceTree = "<group>"; };
+		5BBDB486240D380F00BB10FE /* ColorBlobDetection.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = ColorBlobDetection.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		5BBDB489240D380F00BB10FE /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		5BBDB48D240D380F00BB10FE /* ViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ViewController.swift; sourceTree = "<group>"; };
+		5BBDB490240D380F00BB10FE /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		5BBDB492240D381000BB10FE /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		5BBDB495240D381000BB10FE /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		5BBDB497240D381000BB10FE /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		5BBDB516241923C800BB10FE /* AVFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AVFoundation.framework; path = System/Library/Frameworks/AVFoundation.framework; sourceTree = SDKROOT; };
+		5BBDB5182419241200BB10FE /* CoreMedia.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreMedia.framework; path = System/Library/Frameworks/CoreMedia.framework; sourceTree = SDKROOT; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		5BBDB483240D380F00BB10FE /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5BBDB5192419241200BB10FE /* CoreMedia.framework in Frameworks */,
+				5B8C4C2D243814E9003D9176 /* libc++.tbd in Frameworks */,
+				5BBDB517241923C800BB10FE /* AVFoundation.framework in Frameworks */,
+				5B14CF802452E926003438BE /* OpenCV.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		5BBDB47D240D380F00BB10FE = {
+			isa = PBXGroup;
+			children = (
+				5BBDB488240D380F00BB10FE /* ColorBlobDetection */,
+				5BBDB487240D380F00BB10FE /* Products */,
+				5BBDB515241923C800BB10FE /* Frameworks */,
+			);
+			sourceTree = "<group>";
+		};
+		5BBDB487240D380F00BB10FE /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				5BBDB486240D380F00BB10FE /* ColorBlobDetection.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		5BBDB488240D380F00BB10FE /* ColorBlobDetection */ = {
+			isa = PBXGroup;
+			children = (
+				5B14CF7F2452E926003438BE /* OpenCV.framework */,
+				5BBDB489240D380F00BB10FE /* AppDelegate.swift */,
+				5BBDB48D240D380F00BB10FE /* ViewController.swift */,
+				5BBDB48F240D380F00BB10FE /* Main.storyboard */,
+				5BBDB492240D381000BB10FE /* Assets.xcassets */,
+				5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */,
+				5BBDB497240D381000BB10FE /* Info.plist */,
+				5B8C4C30243849E9003D9176 /* ColorBlobDetector.swift */,
+			);
+			path = ColorBlobDetection;
+			sourceTree = "<group>";
+		};
+		5BBDB515241923C800BB10FE /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				5B8C4C2C243814A0003D9176 /* libc++.tbd */,
+				5BBDB5182419241200BB10FE /* CoreMedia.framework */,
+				5BBDB516241923C800BB10FE /* AVFoundation.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		5BBDB485240D380F00BB10FE /* ColorBlobDetection */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 5BBDB4B0240D381000BB10FE /* Build configuration list for PBXNativeTarget "ColorBlobDetection" */;
+			buildPhases = (
+				5BBDB482240D380F00BB10FE /* Sources */,
+				5BBDB483240D380F00BB10FE /* Frameworks */,
+				5BBDB484240D380F00BB10FE /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = ColorBlobDetection;
+			productName = ColorBlobDetection;
+			productReference = 5BBDB486240D380F00BB10FE /* ColorBlobDetection.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		5BBDB47E240D380F00BB10FE /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastSwiftUpdateCheck = 1130;
+				LastUpgradeCheck = 1130;
+				ORGANIZATIONNAME = OpenCV;
+				TargetAttributes = {
+					5BBDB485240D380F00BB10FE = {
+						CreatedOnToolsVersion = 11.3.1;
+						LastSwiftMigration = 1130;
+					};
+				};
+			};
+			buildConfigurationList = 5BBDB481240D380F00BB10FE /* Build configuration list for PBXProject "ColorBlobDetection" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 5BBDB47D240D380F00BB10FE;
+			productRefGroup = 5BBDB487240D380F00BB10FE /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				5BBDB485240D380F00BB10FE /* ColorBlobDetection */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		5BBDB484240D380F00BB10FE /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5BBDB496240D381000BB10FE /* LaunchScreen.storyboard in Resources */,
+				5BBDB493240D381000BB10FE /* Assets.xcassets in Resources */,
+				5BBDB491240D380F00BB10FE /* Main.storyboard in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		5BBDB482240D380F00BB10FE /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5BBDB48E240D380F00BB10FE /* ViewController.swift in Sources */,
+				5B8C4C31243849E9003D9176 /* ColorBlobDetector.swift in Sources */,
+				5BBDB48A240D380F00BB10FE /* AppDelegate.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+		5BBDB48F240D380F00BB10FE /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				5BBDB490240D380F00BB10FE /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				5BBDB495240D381000BB10FE /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		5BBDB4AE240D381000BB10FE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				FRAMEWORK_SEARCH_PATHS = ../..;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = "../../OpenCV/**";
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
+				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				OTHER_LDFLAGS = "";
+				SDKROOT = iphoneos;
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
+				SWIFT_OBJC_BRIDGING_HEADER = "";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+			};
+			name = Debug;
+		};
+		5BBDB4AF240D381000BB10FE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				FRAMEWORK_SEARCH_PATHS = ../..;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = "../../OpenCV/**";
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				MTL_FAST_MATH = YES;
+				OTHER_LDFLAGS = "";
+				SDKROOT = iphoneos;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OBJC_BRIDGING_HEADER = "";
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		5BBDB4B1240D381000BB10FE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
+				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/../..",
+				);
+				INFOPLIST_FILE = ColorBlobDetection/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				OTHER_SWIFT_FLAGS = "-Xcc -Wno-incomplete-umbrella";
+				PRODUCT_BUNDLE_IDENTIFIER = org.opencv.ColorBlobDetection;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				SWIFT_OBJC_BRIDGING_HEADER = "";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		5BBDB4B2240D381000BB10FE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
+				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/../..",
+				);
+				INFOPLIST_FILE = ColorBlobDetection/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				OTHER_SWIFT_FLAGS = "-Xcc -Wno-incomplete-umbrella";
+				PRODUCT_BUNDLE_IDENTIFIER = org.opencv.ColorBlobDetection;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				SWIFT_OBJC_BRIDGING_HEADER = "";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		5BBDB481240D380F00BB10FE /* Build configuration list for PBXProject "ColorBlobDetection" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				5BBDB4AE240D381000BB10FE /* Debug */,
+				5BBDB4AF240D381000BB10FE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		5BBDB4B0240D381000BB10FE /* Build configuration list for PBXNativeTarget "ColorBlobDetection" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				5BBDB4B1240D381000BB10FE /* Debug */,
+				5BBDB4B2240D381000BB10FE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 5BBDB47E240D380F00BB10FE /* Project object */;
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
new file mode 100644
index 00000000..3d4c1e55
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>IDEDidComputeMac32BitWarning</key>
+    <true/>
+</dict>
+</plist>
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/AppDelegate.swift b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/AppDelegate.swift
new file mode 100644
index 00000000..9965cc50
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/AppDelegate.swift
@@ -0,0 +1,19 @@
+//
+//  AppDelegate.swift
+//
+//  Created by Giles Payne on 2020/03/02.
+//
+
+import UIKit
+
+@UIApplicationMain
+class AppDelegate: UIResponder, UIApplicationDelegate {
+
+    var window: UIWindow?
+
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        // Override point for customization after application launch.
+        return true
+    }
+
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/100.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/100.png
new file mode 100644
index 00000000..1e700dd3
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/100.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/114.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/114.png
new file mode 100644
index 00000000..f4312fc9
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/114.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/120.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/120.png
new file mode 100644
index 00000000..3b0a91b6
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/120.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/144.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/144.png
new file mode 100644
index 00000000..a5660b32
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/144.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/152.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/152.png
new file mode 100644
index 00000000..99e2a23b
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/152.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/167.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/167.png
new file mode 100644
index 00000000..ea93ffc1
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/167.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/180.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/180.png
new file mode 100644
index 00000000..6d525448
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/180.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/20.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/20.png
new file mode 100644
index 00000000..d06f341d
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/20.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/29.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/29.png
new file mode 100644
index 00000000..cee7ce05
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/29.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/40.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/40.png
new file mode 100644
index 00000000..0340a78d
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/40.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/50.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/50.png
new file mode 100644
index 00000000..d143fdcc
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/50.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/57.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/57.png
new file mode 100644
index 00000000..55d57231
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/57.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/58.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/58.png
new file mode 100644
index 00000000..e2653bcf
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/58.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/60.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/60.png
new file mode 100644
index 00000000..908cc069
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/60.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/72.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/72.png
new file mode 100644
index 00000000..d33f50de
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/72.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/76.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/76.png
new file mode 100644
index 00000000..407d815e
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/76.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/80.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/80.png
new file mode 100644
index 00000000..6f3ad42b
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/80.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/87.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/87.png
new file mode 100644
index 00000000..767bb581
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/87.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/Contents.json b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/Contents.json
new file mode 100644
index 00000000..859fae7f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/Contents.json
@@ -0,0 +1,158 @@
+{
+  "images" : [
+    {
+      "filename" : "40.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "filename" : "60.png",
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "20x20"
+    },
+    {
+      "filename" : "29.png",
+      "idiom" : "iphone",
+      "scale" : "1x",
+      "size" : "29x29"
+    },
+    {
+      "filename" : "58.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "filename" : "87.png",
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "29x29"
+    },
+    {
+      "filename" : "80.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "120.png",
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "57.png",
+      "idiom" : "iphone",
+      "scale" : "1x",
+      "size" : "57x57"
+    },
+    {
+      "filename" : "114.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "57x57"
+    },
+    {
+      "filename" : "120.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "60x60"
+    },
+    {
+      "filename" : "180.png",
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "60x60"
+    },
+    {
+      "filename" : "20.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "20x20"
+    },
+    {
+      "filename" : "40.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "filename" : "29.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "29x29"
+    },
+    {
+      "filename" : "58.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "filename" : "40.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "80.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "50.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "50x50"
+    },
+    {
+      "filename" : "100.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "50x50"
+    },
+    {
+      "filename" : "72.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "72x72"
+    },
+    {
+      "filename" : "144.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "72x72"
+    },
+    {
+      "filename" : "76.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "76x76"
+    },
+    {
+      "filename" : "152.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "76x76"
+    },
+    {
+      "filename" : "167.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "83.5x83.5"
+    },
+    {
+      "filename" : "appstore.png",
+      "idiom" : "ios-marketing",
+      "scale" : "1x",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/appstore.png b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/appstore.png
new file mode 100644
index 00000000..772f3ff1
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/AppIcon.appiconset/appstore.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/Contents.json b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/Contents.json
new file mode 100644
index 00000000..da4a164c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Assets.xcassets/Contents.json
@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Base.lproj/LaunchScreen.storyboard b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Base.lproj/LaunchScreen.storyboard
new file mode 100644
index 00000000..865e9329
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Base.lproj/LaunchScreen.storyboard
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13122.16" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13104.12"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <color key="backgroundColor" xcode11CocoaTouchSystemColor="systemBackgroundColor" cocoaTouchSystemColor="whiteColor"/>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+</document>
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Base.lproj/Main.storyboard b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Base.lproj/Main.storyboard
new file mode 100644
index 00000000..071ca8c3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Base.lproj/Main.storyboard
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="15705" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="BYZ-38-t0r">
+    <device id="retina6_1" orientation="portrait" appearance="light"/>
+    <dependencies>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="15706"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="tne-QT-ifu">
+            <objects>
+                <viewController id="BYZ-38-t0r" customClass="ViewController" customModule="OpenCVSwiftTestMobile" customModuleProvider="target" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
+                        <rect key="frame" x="0.0" y="0.0" width="414" height="896"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <view contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="7db-Xp-qM4" userLabel="CameraOutputHolder">
+                                <rect key="frame" x="0.0" y="44" width="414" height="818"/>
+                                <color key="backgroundColor" systemColor="systemBackgroundColor" cocoaTouchSystemColor="whiteColor"/>
+                            </view>
+                        </subviews>
+                        <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                        <constraints>
+                            <constraint firstItem="6Tk-OE-BBY" firstAttribute="bottom" secondItem="7db-Xp-qM4" secondAttribute="bottom" id="0hV-Uz-R3z"/>
+                            <constraint firstItem="7db-Xp-qM4" firstAttribute="top" secondItem="6Tk-OE-BBY" secondAttribute="top" id="GbA-NU-Qxp"/>
+                            <constraint firstItem="6Tk-OE-BBY" firstAttribute="trailing" secondItem="7db-Xp-qM4" secondAttribute="trailing" id="YS2-18-VLx"/>
+                            <constraint firstItem="7db-Xp-qM4" firstAttribute="leading" secondItem="6Tk-OE-BBY" secondAttribute="leading" id="amh-MA-s7b"/>
+                        </constraints>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                    </view>
+                    <connections>
+                        <outlet property="cameraHolder" destination="7db-Xp-qM4" id="iWY-GM-D7N"/>
+                    </connections>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="137.68115942028987" y="133.92857142857142"/>
+        </scene>
+    </scenes>
+</document>
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/ColorBlobDetector.swift b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/ColorBlobDetector.swift
new file mode 100644
index 00000000..216b2b1c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/ColorBlobDetector.swift
@@ -0,0 +1,75 @@
+//
+//  ColorBlobDetector.swift
+//
+//  Created by Giles Payne on 2020/04/04.
+//
+
+import OpenCV
+
+public class ColorBlobDetector {
+    // Lower and Upper bounds for range checking in HSV color space
+    var lowerBound = Scalar(0.0)
+    var upperBound = Scalar(0.0)
+    // Minimum contour area in percent for contours filtering
+    static let minContourArea = 0.1
+    // Color radius for range checking in HSV color space
+    var colorRadius = Scalar(25.0, 50.0, 50.0, 0.0)
+    let spectrum = Mat()
+    var contours = [[Point]]()
+
+    // Cache
+    let pyrDownMat = Mat()
+    let hsvMat = Mat()
+    let mask = Mat()
+    let dilatedMask = Mat()
+    let hierarchy = Mat()
+
+    func setHsvColor(hsvColor:Scalar) {
+        let minH = (hsvColor.val[0].doubleValue >= colorRadius.val[0].doubleValue) ? hsvColor.val[0].doubleValue - colorRadius.val[0].doubleValue : 0
+        let maxH = (hsvColor.val[0].doubleValue + colorRadius.val[0].doubleValue <= 255) ? hsvColor.val[0].doubleValue + colorRadius.val[0].doubleValue : 255
+
+        lowerBound = Scalar(minH, hsvColor.val[1].doubleValue - colorRadius.val[1].doubleValue, hsvColor.val[2].doubleValue - colorRadius.val[2].doubleValue, 0)
+        upperBound = Scalar(maxH, hsvColor.val[1].doubleValue + colorRadius.val[1].doubleValue, hsvColor.val[2].doubleValue + colorRadius.val[2].doubleValue, 255)
+
+        let spectrumHsv = Mat(rows: 1, cols: (Int32)(maxH-minH), type:CvType.CV_8UC3);
+
+        for j:Int32 in 0..<Int32(maxH - minH) {
+            let tmp:[Double] = [Double(Int32(minH) + j), 255, 255]
+            try! spectrumHsv.put(row: 0, col: j, data: tmp)
+        }
+
+        Imgproc.cvtColor(src: spectrumHsv, dst: spectrum, code: .COLOR_HSV2RGB_FULL, dstCn: 4)
+    }
+
+    func process(rgbaImage:Mat) {
+        Imgproc.pyrDown(src: rgbaImage, dst: pyrDownMat)
+        Imgproc.pyrDown(src: pyrDownMat, dst: pyrDownMat)
+
+        Imgproc.cvtColor(src: pyrDownMat, dst: hsvMat, code: .COLOR_RGB2HSV_FULL)
+
+        Core.inRange(src: hsvMat, lowerb: lowerBound, upperb: upperBound, dst: mask)
+        Imgproc.dilate(src: mask, dst: dilatedMask, kernel: Mat())
+
+        var contoursTmp = [[Point]]()
+
+        Imgproc.findContours(image: dilatedMask, contours: &contoursTmp, hierarchy: hierarchy, mode: .RETR_EXTERNAL, method: .CHAIN_APPROX_SIMPLE)
+
+        // Find max contour area
+        var maxArea = 0.0
+        for contour in contoursTmp {
+            let contourMat = MatOfPoint(array: contour)
+            let area = Imgproc.contourArea(contour: contourMat)
+            maxArea = max(area, maxArea)
+        }
+
+        // Filter contours by area and resize to fit the original image size
+        contours.removeAll()
+        for contour in contoursTmp {
+            let contourMat = MatOfPoint(array: contour)
+            if (Imgproc.contourArea(contour: contourMat) > ColorBlobDetector.minContourArea * maxArea) {
+                Core.multiply(src1: contourMat, srcScalar: Scalar(4.0,4.0), dst: contourMat)
+                contours.append(contourMat.toArray())
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Info.plist b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Info.plist
new file mode 100644
index 00000000..19b473c2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/Info.plist
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>NSCameraUsageDescription</key>
+    <string>Please allow access to the camera for image processing</string>
+    <key>UIUserInterfaceStyle</key>
+    <string>Light</string>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>$(DEVELOPMENT_LANGUAGE)</string>
+    <key>CFBundleExecutable</key>
+    <string>$(EXECUTABLE_NAME)</string>
+    <key>CFBundleIdentifier</key>
+    <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>$(PRODUCT_NAME)</string>
+    <key>CFBundlePackageType</key>
+    <string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>LSRequiresIPhoneOS</key>
+    <true/>
+    <key>UILaunchStoryboardName</key>
+    <string>LaunchScreen</string>
+    <key>UIMainStoryboardFile</key>
+    <string>Main</string>
+    <key>UIRequiredDeviceCapabilities</key>
+    <array>
+        <string>armv7</string>
+    </array>
+    <key>UISupportedInterfaceOrientations</key>
+    <array>
+        <string>UIInterfaceOrientationPortrait</string>
+        <string>UIInterfaceOrientationLandscapeLeft</string>
+        <string>UIInterfaceOrientationLandscapeRight</string>
+    </array>
+    <key>UISupportedInterfaceOrientations~ipad</key>
+    <array>
+        <string>UIInterfaceOrientationPortrait</string>
+        <string>UIInterfaceOrientationPortraitUpsideDown</string>
+        <string>UIInterfaceOrientationLandscapeLeft</string>
+        <string>UIInterfaceOrientationLandscapeRight</string>
+    </array>
+</dict>
+</plist>
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/ViewController.swift b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/ViewController.swift
new file mode 100644
index 00000000..97f3ec74
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetection/ViewController.swift
@@ -0,0 +1,124 @@
+//
+//  ViewController.swift
+//
+//  Created by Giles Payne on 2020/03/02.
+//
+
+import UIKit
+import OpenCV
+
+class ViewController: UIViewController, CvVideoCameraDelegate2 {
+
+    var isColorSelected = false
+    var rgba: Mat? = nil
+    let detector = ColorBlobDetector()
+    let spectrum = Mat()
+    var blobColorRgba = Scalar(255.0)
+    var blobColorHsv = Scalar(255.0)
+    let SPECTRUM_SIZE = Size(width: 200, height: 64)
+    let CONTOUR_COLOR = Scalar(255.0, 0.0, 0.0, 255.0)
+    var cameraHolderWidth: CGFloat = 0
+    var cameraHolderHeight: CGFloat = 0
+
+    func processImage(_ image: Mat!) {
+        rgba = image
+        if isColorSelected {
+            detector.process(rgbaImage: image)
+            let contours = detector.contours
+            NSLog("Contours count: \(contours.count))")
+            Imgproc.drawContours(image: image, contours: contours as! [[Point]], contourIdx: -1, color: CONTOUR_COLOR)
+
+            let colorLabel = image.submat(rowStart: 4, rowEnd: 68, colStart: 4, colEnd: 68)
+            colorLabel.setTo(scalar: blobColorRgba)
+
+            let spectrumLabel = image.submat(rowStart: 4, rowEnd: 4 + spectrum.rows(), colStart: 70, colEnd: 70 + spectrum.cols())
+            spectrum.copy(to: spectrumLabel)
+        }
+    }
+
+    var camera: CvVideoCamera2? = nil
+
+    @IBOutlet weak var cameraHolder: UIView!
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        camera = CvVideoCamera2(parentView: cameraHolder)
+        camera?.rotateVideo = true
+        camera?.delegate = self
+        camera?.start()
+    }
+
+    override func viewDidLayoutSubviews() {
+        if UIDevice.current.orientation.isLandscape {
+            cameraHolderWidth = cameraHolder.bounds.height
+            cameraHolderHeight = cameraHolder.bounds.width
+        } else {
+            cameraHolderWidth = cameraHolder.bounds.width
+            cameraHolderHeight = cameraHolder.bounds.height
+        }
+    }
+
+    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
+        if let aRgba = rgba, touches.count == 1 {
+            let touch = touches.first!
+            let cols = CGFloat(aRgba.cols())
+            let rows = CGFloat(aRgba.rows())
+
+            let orientation = UIDevice.current.orientation
+            var x = touch.location(in: cameraHolder).x
+            var y = touch.location(in: cameraHolder).y
+            if orientation == .landscapeLeft {
+                let tempX = x
+                x = cameraHolder.bounds.height - y
+                y = tempX
+            } else if orientation == .landscapeRight {
+                let tempY = y
+                y = cameraHolder.bounds.width - x
+                x = tempY
+            }
+
+            x = x * (cols / cameraHolderWidth)
+            y = y * (rows / cameraHolderHeight)
+
+            if ((x < 0) || (y < 0) || (x > cols) || (y > rows)) {
+                return
+            }
+
+            let touchedRect = Rect()
+
+            touchedRect.x = (x>4) ? Int32(x)-4 : 0;
+            touchedRect.y = (y>4) ? Int32(y)-4 : 0;
+
+            touchedRect.width = (x+4 < cols) ? Int32(x) + 4 - touchedRect.x : Int32(cols) - touchedRect.x;
+            touchedRect.height = (y+4 < rows) ? Int32(y) + 4 - touchedRect.y : Int32(rows) - touchedRect.y;
+
+            let touchedRegionRgba = aRgba.submat(roi: touchedRect)
+
+            let touchedRegionHsv = Mat()
+            Imgproc.cvtColor(src: touchedRegionRgba, dst: touchedRegionHsv, code: .COLOR_RGB2HSV_FULL)
+
+            // Calculate average color of touched region
+            blobColorHsv = Core.sum(src: touchedRegionHsv)
+            let pointCount = touchedRect.width*touchedRect.height
+            blobColorHsv = blobColorHsv.mul(Scalar.all(1.0/Double(pointCount)))
+
+            blobColorRgba = convertScalarHsv2Rgba(hsvColor: blobColorHsv)
+
+            NSLog("Touched rgba color: (\(blobColorRgba.val[0]), \(blobColorRgba.val[1]), \( blobColorRgba.val[2]), \(blobColorRgba.val[3])")
+
+            detector.setHsvColor(hsvColor: blobColorHsv)
+
+            Imgproc.resize(src: detector.spectrum, dst: spectrum, dsize: SPECTRUM_SIZE, fx: 0, fy: 0, interpolation: InterpolationFlags.INTER_LINEAR_EXACT.rawValue)
+
+            isColorSelected = true
+        }
+    }
+
+    func convertScalarHsv2Rgba(hsvColor:Scalar) -> Scalar {
+        let pointMatRgba = Mat()
+        let pointMatHsv = Mat(rows: 1, cols: 1, type: CvType.CV_8UC3, scalar: hsvColor)
+        Imgproc.cvtColor(src: pointMatHsv, dst: pointMatRgba, code: .COLOR_HSV2RGB_FULL, dstCn: 4)
+        let elementData = pointMatRgba.get(row: 0, col: 0)
+        return Scalar(vals: elementData as [NSNumber])
+    }
+
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetectionDynamic.xcodeproj/project.pbxproj b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetectionDynamic.xcodeproj/project.pbxproj
new file mode 100644
index 00000000..fb842a38
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetectionDynamic.xcodeproj/project.pbxproj
@@ -0,0 +1,413 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 50;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		5B8C4C2D243814E9003D9176 /* libc++.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 5B8C4C2C243814A0003D9176 /* libc++.tbd */; };
+		5B8C4C31243849E9003D9176 /* ColorBlobDetector.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5B8C4C30243849E9003D9176 /* ColorBlobDetector.swift */; };
+		5BBDB48A240D380F00BB10FE /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5BBDB489240D380F00BB10FE /* AppDelegate.swift */; };
+		5BBDB48E240D380F00BB10FE /* ViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5BBDB48D240D380F00BB10FE /* ViewController.swift */; };
+		5BBDB491240D380F00BB10FE /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB48F240D380F00BB10FE /* Main.storyboard */; };
+		5BBDB493240D381000BB10FE /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB492240D381000BB10FE /* Assets.xcassets */; };
+		5BBDB496240D381000BB10FE /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */; };
+		5BBDB517241923C800BB10FE /* AVFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5BBDB516241923C800BB10FE /* AVFoundation.framework */; };
+		5BBDB5192419241200BB10FE /* CoreMedia.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5BBDB5182419241200BB10FE /* CoreMedia.framework */; };
+		5BE7205625201342004E84AE /* OpenCV.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5B14CF7F2452E926003438BE /* OpenCV.framework */; };
+		5BE7205725201342004E84AE /* OpenCV.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = 5B14CF7F2452E926003438BE /* OpenCV.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		5BE7205825201342004E84AE /* Embed Frameworks */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "";
+			dstSubfolderSpec = 10;
+			files = (
+				5BE7205725201342004E84AE /* OpenCV.framework in Embed Frameworks */,
+			);
+			name = "Embed Frameworks";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		5B14CF7F2452E926003438BE /* OpenCV.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenCV.framework; path = ../../../OpenCV.framework; sourceTree = "<group>"; };
+		5B8C4C2C243814A0003D9176 /* libc++.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = "libc++.tbd"; path = "usr/lib/libc++.tbd"; sourceTree = SDKROOT; };
+		5B8C4C30243849E9003D9176 /* ColorBlobDetector.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ColorBlobDetector.swift; sourceTree = "<group>"; };
+		5BBDB486240D380F00BB10FE /* ColorBlobDetection.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = ColorBlobDetection.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		5BBDB489240D380F00BB10FE /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		5BBDB48D240D380F00BB10FE /* ViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ViewController.swift; sourceTree = "<group>"; };
+		5BBDB490240D380F00BB10FE /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		5BBDB492240D381000BB10FE /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		5BBDB495240D381000BB10FE /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		5BBDB497240D381000BB10FE /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		5BBDB516241923C800BB10FE /* AVFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AVFoundation.framework; path = System/Library/Frameworks/AVFoundation.framework; sourceTree = SDKROOT; };
+		5BBDB5182419241200BB10FE /* CoreMedia.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreMedia.framework; path = System/Library/Frameworks/CoreMedia.framework; sourceTree = SDKROOT; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		5BBDB483240D380F00BB10FE /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5BBDB5192419241200BB10FE /* CoreMedia.framework in Frameworks */,
+				5B8C4C2D243814E9003D9176 /* libc++.tbd in Frameworks */,
+				5BBDB517241923C800BB10FE /* AVFoundation.framework in Frameworks */,
+				5BE7205625201342004E84AE /* OpenCV.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		5BBDB47D240D380F00BB10FE = {
+			isa = PBXGroup;
+			children = (
+				5BBDB488240D380F00BB10FE /* ColorBlobDetection */,
+				5BBDB487240D380F00BB10FE /* Products */,
+				5BBDB515241923C800BB10FE /* Frameworks */,
+			);
+			sourceTree = "<group>";
+		};
+		5BBDB487240D380F00BB10FE /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				5BBDB486240D380F00BB10FE /* ColorBlobDetection.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		5BBDB488240D380F00BB10FE /* ColorBlobDetection */ = {
+			isa = PBXGroup;
+			children = (
+				5B14CF7F2452E926003438BE /* OpenCV.framework */,
+				5BBDB489240D380F00BB10FE /* AppDelegate.swift */,
+				5BBDB48D240D380F00BB10FE /* ViewController.swift */,
+				5BBDB48F240D380F00BB10FE /* Main.storyboard */,
+				5BBDB492240D381000BB10FE /* Assets.xcassets */,
+				5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */,
+				5BBDB497240D381000BB10FE /* Info.plist */,
+				5B8C4C30243849E9003D9176 /* ColorBlobDetector.swift */,
+			);
+			path = ColorBlobDetection;
+			sourceTree = "<group>";
+		};
+		5BBDB515241923C800BB10FE /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				5B8C4C2C243814A0003D9176 /* libc++.tbd */,
+				5BBDB5182419241200BB10FE /* CoreMedia.framework */,
+				5BBDB516241923C800BB10FE /* AVFoundation.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		5BBDB485240D380F00BB10FE /* ColorBlobDetection */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 5BBDB4B0240D381000BB10FE /* Build configuration list for PBXNativeTarget "ColorBlobDetection" */;
+			buildPhases = (
+				5BBDB482240D380F00BB10FE /* Sources */,
+				5BBDB483240D380F00BB10FE /* Frameworks */,
+				5BBDB484240D380F00BB10FE /* Resources */,
+				5BE7205825201342004E84AE /* Embed Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = ColorBlobDetection;
+			productName = ColorBlobDetection;
+			productReference = 5BBDB486240D380F00BB10FE /* ColorBlobDetection.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		5BBDB47E240D380F00BB10FE /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastSwiftUpdateCheck = 1130;
+				LastUpgradeCheck = 1130;
+				ORGANIZATIONNAME = OpenCV;
+				TargetAttributes = {
+					5BBDB485240D380F00BB10FE = {
+						CreatedOnToolsVersion = 11.3.1;
+						LastSwiftMigration = 1130;
+					};
+				};
+			};
+			buildConfigurationList = 5BBDB481240D380F00BB10FE /* Build configuration list for PBXProject "ColorBlobDetectionDynamic" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 5BBDB47D240D380F00BB10FE;
+			productRefGroup = 5BBDB487240D380F00BB10FE /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				5BBDB485240D380F00BB10FE /* ColorBlobDetection */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		5BBDB484240D380F00BB10FE /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5BBDB496240D381000BB10FE /* LaunchScreen.storyboard in Resources */,
+				5BBDB493240D381000BB10FE /* Assets.xcassets in Resources */,
+				5BBDB491240D380F00BB10FE /* Main.storyboard in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		5BBDB482240D380F00BB10FE /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5BBDB48E240D380F00BB10FE /* ViewController.swift in Sources */,
+				5B8C4C31243849E9003D9176 /* ColorBlobDetector.swift in Sources */,
+				5BBDB48A240D380F00BB10FE /* AppDelegate.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+		5BBDB48F240D380F00BB10FE /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				5BBDB490240D380F00BB10FE /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				5BBDB495240D381000BB10FE /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		5BBDB4AE240D381000BB10FE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				FRAMEWORK_SEARCH_PATHS = ../..;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = "../../OpenCV/**";
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
+				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				OTHER_LDFLAGS = "";
+				SDKROOT = iphoneos;
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
+				SWIFT_OBJC_BRIDGING_HEADER = "";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+			};
+			name = Debug;
+		};
+		5BBDB4AF240D381000BB10FE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				FRAMEWORK_SEARCH_PATHS = ../..;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = "../../OpenCV/**";
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				MTL_FAST_MATH = YES;
+				OTHER_LDFLAGS = "";
+				SDKROOT = iphoneos;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OBJC_BRIDGING_HEADER = "";
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		5BBDB4B1240D381000BB10FE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
+				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/../..",
+				);
+				INFOPLIST_FILE = ColorBlobDetection/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				OTHER_SWIFT_FLAGS = "-Xcc -Wno-incomplete-umbrella";
+				PRODUCT_BUNDLE_IDENTIFIER = org.opencv.ColorBlobDetection;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				SWIFT_OBJC_BRIDGING_HEADER = "";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		5BBDB4B2240D381000BB10FE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
+				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/../..",
+				);
+				INFOPLIST_FILE = ColorBlobDetection/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				OTHER_SWIFT_FLAGS = "-Xcc -Wno-incomplete-umbrella";
+				PRODUCT_BUNDLE_IDENTIFIER = org.opencv.ColorBlobDetection;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				SWIFT_OBJC_BRIDGING_HEADER = "";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		5BBDB481240D380F00BB10FE /* Build configuration list for PBXProject "ColorBlobDetectionDynamic" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				5BBDB4AE240D381000BB10FE /* Debug */,
+				5BBDB4AF240D381000BB10FE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		5BBDB4B0240D381000BB10FE /* Build configuration list for PBXNativeTarget "ColorBlobDetection" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				5BBDB4B1240D381000BB10FE /* Debug */,
+				5BBDB4B2240D381000BB10FE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 5BBDB47E240D380F00BB10FE /* Project object */;
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetectionDynamic.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetectionDynamic.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
new file mode 100644
index 00000000..3d4c1e55
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/ColorBlobDetection/ColorBlobDetectionDynamic.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>IDEDidComputeMac32BitWarning</key>
+    <true/>
+</dict>
+</plist>
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection.xcodeproj/project.pbxproj b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection.xcodeproj/project.pbxproj
new file mode 100644
index 00000000..bc07ef89
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection.xcodeproj/project.pbxproj
@@ -0,0 +1,407 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 50;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		5B14CF822452EED3003438BE /* OpenCV.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5B14CF812452EED3003438BE /* OpenCV.framework */; };
+		5B79BD652439FF020062DD99 /* DetectionBasedTracker.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5B79BD642439FF020062DD99 /* DetectionBasedTracker.mm */; };
+		5B8C4C2D243814E9003D9176 /* libc++.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 5B8C4C2C243814A0003D9176 /* libc++.tbd */; };
+		5B8C4C2F2438383D003D9176 /* lbpcascade_frontalface.xml in Resources */ = {isa = PBXBuildFile; fileRef = 5B8C4C2E2438383D003D9176 /* lbpcascade_frontalface.xml */; };
+		5BBDB48A240D380F00BB10FE /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5BBDB489240D380F00BB10FE /* AppDelegate.swift */; };
+		5BBDB48E240D380F00BB10FE /* ViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5BBDB48D240D380F00BB10FE /* ViewController.swift */; };
+		5BBDB491240D380F00BB10FE /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB48F240D380F00BB10FE /* Main.storyboard */; };
+		5BBDB493240D381000BB10FE /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB492240D381000BB10FE /* Assets.xcassets */; };
+		5BBDB496240D381000BB10FE /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */; };
+		5BBDB517241923C800BB10FE /* AVFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5BBDB516241923C800BB10FE /* AVFoundation.framework */; };
+		5BBDB5192419241200BB10FE /* CoreMedia.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5BBDB5182419241200BB10FE /* CoreMedia.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		5B14CF812452EED3003438BE /* OpenCV.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenCV.framework; path = ../../../OpenCV.framework; sourceTree = "<group>"; };
+		5B79BD622439FEB60062DD99 /* DetectionBasedTracker.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DetectionBasedTracker.h; sourceTree = "<group>"; };
+		5B79BD632439FF020062DD99 /* FaceDetection-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "FaceDetection-Bridging-Header.h"; sourceTree = "<group>"; };
+		5B79BD642439FF020062DD99 /* DetectionBasedTracker.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = DetectionBasedTracker.mm; sourceTree = "<group>"; };
+		5B8C4C2C243814A0003D9176 /* libc++.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = "libc++.tbd"; path = "usr/lib/libc++.tbd"; sourceTree = SDKROOT; };
+		5B8C4C2E2438383D003D9176 /* lbpcascade_frontalface.xml */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = lbpcascade_frontalface.xml; sourceTree = "<group>"; };
+		5BBDB486240D380F00BB10FE /* FaceDetection.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = FaceDetection.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		5BBDB489240D380F00BB10FE /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		5BBDB48D240D380F00BB10FE /* ViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ViewController.swift; sourceTree = "<group>"; };
+		5BBDB490240D380F00BB10FE /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		5BBDB492240D381000BB10FE /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		5BBDB495240D381000BB10FE /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		5BBDB497240D381000BB10FE /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		5BBDB516241923C800BB10FE /* AVFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AVFoundation.framework; path = System/Library/Frameworks/AVFoundation.framework; sourceTree = SDKROOT; };
+		5BBDB5182419241200BB10FE /* CoreMedia.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreMedia.framework; path = System/Library/Frameworks/CoreMedia.framework; sourceTree = SDKROOT; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		5BBDB483240D380F00BB10FE /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5BBDB5192419241200BB10FE /* CoreMedia.framework in Frameworks */,
+				5B8C4C2D243814E9003D9176 /* libc++.tbd in Frameworks */,
+				5BBDB517241923C800BB10FE /* AVFoundation.framework in Frameworks */,
+				5B14CF822452EED3003438BE /* OpenCV.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		5BBDB47D240D380F00BB10FE = {
+			isa = PBXGroup;
+			children = (
+				5BBDB488240D380F00BB10FE /* FaceDetection */,
+				5BBDB487240D380F00BB10FE /* Products */,
+				5BBDB515241923C800BB10FE /* Frameworks */,
+			);
+			sourceTree = "<group>";
+		};
+		5BBDB487240D380F00BB10FE /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				5BBDB486240D380F00BB10FE /* FaceDetection.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		5BBDB488240D380F00BB10FE /* FaceDetection */ = {
+			isa = PBXGroup;
+			children = (
+				5B14CF812452EED3003438BE /* OpenCV.framework */,
+				5B8C4C2E2438383D003D9176 /* lbpcascade_frontalface.xml */,
+				5BBDB489240D380F00BB10FE /* AppDelegate.swift */,
+				5BBDB48D240D380F00BB10FE /* ViewController.swift */,
+				5BBDB48F240D380F00BB10FE /* Main.storyboard */,
+				5BBDB492240D381000BB10FE /* Assets.xcassets */,
+				5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */,
+				5BBDB497240D381000BB10FE /* Info.plist */,
+				5B79BD622439FEB60062DD99 /* DetectionBasedTracker.h */,
+				5B79BD642439FF020062DD99 /* DetectionBasedTracker.mm */,
+				5B79BD632439FF020062DD99 /* FaceDetection-Bridging-Header.h */,
+			);
+			path = FaceDetection;
+			sourceTree = "<group>";
+		};
+		5BBDB515241923C800BB10FE /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				5B8C4C2C243814A0003D9176 /* libc++.tbd */,
+				5BBDB5182419241200BB10FE /* CoreMedia.framework */,
+				5BBDB516241923C800BB10FE /* AVFoundation.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		5BBDB485240D380F00BB10FE /* FaceDetection */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 5BBDB4B0240D381000BB10FE /* Build configuration list for PBXNativeTarget "FaceDetection" */;
+			buildPhases = (
+				5BBDB482240D380F00BB10FE /* Sources */,
+				5BBDB483240D380F00BB10FE /* Frameworks */,
+				5BBDB484240D380F00BB10FE /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = FaceDetection;
+			productName = FaceDetection;
+			productReference = 5BBDB486240D380F00BB10FE /* FaceDetection.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		5BBDB47E240D380F00BB10FE /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastSwiftUpdateCheck = 1130;
+				LastUpgradeCheck = 1130;
+				ORGANIZATIONNAME = OpenCV;
+				TargetAttributes = {
+					5BBDB485240D380F00BB10FE = {
+						CreatedOnToolsVersion = 11.3.1;
+						LastSwiftMigration = 1130;
+					};
+				};
+			};
+			buildConfigurationList = 5BBDB481240D380F00BB10FE /* Build configuration list for PBXProject "FaceDetection" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 5BBDB47D240D380F00BB10FE;
+			productRefGroup = 5BBDB487240D380F00BB10FE /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				5BBDB485240D380F00BB10FE /* FaceDetection */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		5BBDB484240D380F00BB10FE /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5BBDB496240D381000BB10FE /* LaunchScreen.storyboard in Resources */,
+				5BBDB493240D381000BB10FE /* Assets.xcassets in Resources */,
+				5BBDB491240D380F00BB10FE /* Main.storyboard in Resources */,
+				5B8C4C2F2438383D003D9176 /* lbpcascade_frontalface.xml in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		5BBDB482240D380F00BB10FE /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5B79BD652439FF020062DD99 /* DetectionBasedTracker.mm in Sources */,
+				5BBDB48E240D380F00BB10FE /* ViewController.swift in Sources */,
+				5BBDB48A240D380F00BB10FE /* AppDelegate.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+		5BBDB48F240D380F00BB10FE /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				5BBDB490240D380F00BB10FE /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				5BBDB495240D381000BB10FE /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		5BBDB4AE240D381000BB10FE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				FRAMEWORK_SEARCH_PATHS = ../..;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = "../../OpenCV/**";
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
+				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				OTHER_LDFLAGS = "";
+				SDKROOT = iphoneos;
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
+				SWIFT_OBJC_BRIDGING_HEADER = "FaceDetection/FaceDetection-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+			};
+			name = Debug;
+		};
+		5BBDB4AF240D381000BB10FE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				FRAMEWORK_SEARCH_PATHS = ../..;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = "../../OpenCV/**";
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				MTL_FAST_MATH = YES;
+				OTHER_LDFLAGS = "";
+				SDKROOT = iphoneos;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OBJC_BRIDGING_HEADER = "FaceDetection/FaceDetection-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		5BBDB4B1240D381000BB10FE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
+				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/../..",
+				);
+				HEADER_SEARCH_PATHS = "$(PROJECT_DIR)/../../OpenCV.framework/Headers";
+				INFOPLIST_FILE = FaceDetection/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				OTHER_SWIFT_FLAGS = "-Xcc -Wno-incomplete-umbrella";
+				PRODUCT_BUNDLE_IDENTIFIER = org.opencv.FaceDetection;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				SWIFT_OBJC_BRIDGING_HEADER = "FaceDetection/FaceDetection-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		5BBDB4B2240D381000BB10FE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
+				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/../..",
+				);
+				HEADER_SEARCH_PATHS = "$(PROJECT_DIR)/../../OpenCV.framework/Headers";
+				INFOPLIST_FILE = FaceDetection/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				OTHER_SWIFT_FLAGS = "-Xcc -Wno-incomplete-umbrella";
+				PRODUCT_BUNDLE_IDENTIFIER = org.opencv.FaceDetection;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				SWIFT_OBJC_BRIDGING_HEADER = "FaceDetection/FaceDetection-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		5BBDB481240D380F00BB10FE /* Build configuration list for PBXProject "FaceDetection" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				5BBDB4AE240D381000BB10FE /* Debug */,
+				5BBDB4AF240D381000BB10FE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		5BBDB4B0240D381000BB10FE /* Build configuration list for PBXNativeTarget "FaceDetection" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				5BBDB4B1240D381000BB10FE /* Debug */,
+				5BBDB4B2240D381000BB10FE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 5BBDB47E240D380F00BB10FE /* Project object */;
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
new file mode 100644
index 00000000..3d4c1e55
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>IDEDidComputeMac32BitWarning</key>
+    <true/>
+</dict>
+</plist>
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/AppDelegate.swift b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/AppDelegate.swift
new file mode 100644
index 00000000..9965cc50
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/AppDelegate.swift
@@ -0,0 +1,19 @@
+//
+//  AppDelegate.swift
+//
+//  Created by Giles Payne on 2020/03/02.
+//
+
+import UIKit
+
+@UIApplicationMain
+class AppDelegate: UIResponder, UIApplicationDelegate {
+
+    var window: UIWindow?
+
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        // Override point for customization after application launch.
+        return true
+    }
+
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/100.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/100.png
new file mode 100644
index 00000000..1e700dd3
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/100.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/114.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/114.png
new file mode 100644
index 00000000..f4312fc9
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/114.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/120.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/120.png
new file mode 100644
index 00000000..3b0a91b6
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/120.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/144.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/144.png
new file mode 100644
index 00000000..a5660b32
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/144.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/152.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/152.png
new file mode 100644
index 00000000..99e2a23b
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/152.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/167.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/167.png
new file mode 100644
index 00000000..ea93ffc1
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/167.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/180.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/180.png
new file mode 100644
index 00000000..6d525448
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/180.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/20.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/20.png
new file mode 100644
index 00000000..d06f341d
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/20.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/29.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/29.png
new file mode 100644
index 00000000..cee7ce05
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/29.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/40.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/40.png
new file mode 100644
index 00000000..0340a78d
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/40.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/50.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/50.png
new file mode 100644
index 00000000..d143fdcc
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/50.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/57.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/57.png
new file mode 100644
index 00000000..55d57231
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/57.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/58.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/58.png
new file mode 100644
index 00000000..e2653bcf
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/58.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/60.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/60.png
new file mode 100644
index 00000000..908cc069
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/60.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/72.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/72.png
new file mode 100644
index 00000000..d33f50de
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/72.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/76.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/76.png
new file mode 100644
index 00000000..407d815e
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/76.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/80.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/80.png
new file mode 100644
index 00000000..6f3ad42b
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/80.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/87.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/87.png
new file mode 100644
index 00000000..767bb581
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/87.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/Contents.json b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/Contents.json
new file mode 100644
index 00000000..859fae7f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/Contents.json
@@ -0,0 +1,158 @@
+{
+  "images" : [
+    {
+      "filename" : "40.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "filename" : "60.png",
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "20x20"
+    },
+    {
+      "filename" : "29.png",
+      "idiom" : "iphone",
+      "scale" : "1x",
+      "size" : "29x29"
+    },
+    {
+      "filename" : "58.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "filename" : "87.png",
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "29x29"
+    },
+    {
+      "filename" : "80.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "120.png",
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "57.png",
+      "idiom" : "iphone",
+      "scale" : "1x",
+      "size" : "57x57"
+    },
+    {
+      "filename" : "114.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "57x57"
+    },
+    {
+      "filename" : "120.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "60x60"
+    },
+    {
+      "filename" : "180.png",
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "60x60"
+    },
+    {
+      "filename" : "20.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "20x20"
+    },
+    {
+      "filename" : "40.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "filename" : "29.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "29x29"
+    },
+    {
+      "filename" : "58.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "filename" : "40.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "80.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "50.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "50x50"
+    },
+    {
+      "filename" : "100.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "50x50"
+    },
+    {
+      "filename" : "72.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "72x72"
+    },
+    {
+      "filename" : "144.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "72x72"
+    },
+    {
+      "filename" : "76.png",
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "76x76"
+    },
+    {
+      "filename" : "152.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "76x76"
+    },
+    {
+      "filename" : "167.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "83.5x83.5"
+    },
+    {
+      "filename" : "appstore.png",
+      "idiom" : "ios-marketing",
+      "scale" : "1x",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/appstore.png b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/appstore.png
new file mode 100644
index 00000000..772f3ff1
Binary files /dev/null and b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/AppIcon.appiconset/appstore.png differ
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/Contents.json b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/Contents.json
new file mode 100644
index 00000000..da4a164c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Assets.xcassets/Contents.json
@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Base.lproj/LaunchScreen.storyboard b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Base.lproj/LaunchScreen.storyboard
new file mode 100644
index 00000000..865e9329
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Base.lproj/LaunchScreen.storyboard
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13122.16" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13104.12"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <color key="backgroundColor" xcode11CocoaTouchSystemColor="systemBackgroundColor" cocoaTouchSystemColor="whiteColor"/>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+</document>
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Base.lproj/Main.storyboard b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Base.lproj/Main.storyboard
new file mode 100644
index 00000000..071ca8c3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Base.lproj/Main.storyboard
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="15705" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="BYZ-38-t0r">
+    <device id="retina6_1" orientation="portrait" appearance="light"/>
+    <dependencies>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="15706"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="tne-QT-ifu">
+            <objects>
+                <viewController id="BYZ-38-t0r" customClass="ViewController" customModule="OpenCVSwiftTestMobile" customModuleProvider="target" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
+                        <rect key="frame" x="0.0" y="0.0" width="414" height="896"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <view contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="7db-Xp-qM4" userLabel="CameraOutputHolder">
+                                <rect key="frame" x="0.0" y="44" width="414" height="818"/>
+                                <color key="backgroundColor" systemColor="systemBackgroundColor" cocoaTouchSystemColor="whiteColor"/>
+                            </view>
+                        </subviews>
+                        <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                        <constraints>
+                            <constraint firstItem="6Tk-OE-BBY" firstAttribute="bottom" secondItem="7db-Xp-qM4" secondAttribute="bottom" id="0hV-Uz-R3z"/>
+                            <constraint firstItem="7db-Xp-qM4" firstAttribute="top" secondItem="6Tk-OE-BBY" secondAttribute="top" id="GbA-NU-Qxp"/>
+                            <constraint firstItem="6Tk-OE-BBY" firstAttribute="trailing" secondItem="7db-Xp-qM4" secondAttribute="trailing" id="YS2-18-VLx"/>
+                            <constraint firstItem="7db-Xp-qM4" firstAttribute="leading" secondItem="6Tk-OE-BBY" secondAttribute="leading" id="amh-MA-s7b"/>
+                        </constraints>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                    </view>
+                    <connections>
+                        <outlet property="cameraHolder" destination="7db-Xp-qM4" id="iWY-GM-D7N"/>
+                    </connections>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="137.68115942028987" y="133.92857142857142"/>
+        </scene>
+    </scenes>
+</document>
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/DetectionBasedTracker.h b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/DetectionBasedTracker.h
new file mode 100644
index 00000000..ee915607
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/DetectionBasedTracker.h
@@ -0,0 +1,32 @@
+//
+//  DetectionBasedTracker.h
+//
+//  Created by Giles Payne on 2020/04/05.
+//
+
+#pragma once
+
+#ifdef __cplusplus
+#import <OpenCV/OpenCV.h>
+#endif
+
+#import <Foundation/Foundation.h>
+
+@class Rect2i;
+@class Mat;
+
+@interface DetectionBasedTracker : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
+
+- (instancetype)initWithCascadeName:(NSString*)cascadeName minFaceSize:(int)minFaceSize;
+
+- (void)start;
+
+- (void)stop;
+
+- (void)setFaceSize:(int)size;
+
+- (void)detect:(Mat*)imageGray faces:(NSMutableArray<Rect2i*>*)faces;
+
+@end
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/DetectionBasedTracker.mm b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/DetectionBasedTracker.mm
new file mode 100644
index 00000000..2bc5a229
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/DetectionBasedTracker.mm
@@ -0,0 +1,85 @@
+//
+//  DetectionBasedTracker.mm
+//
+//  Created by Giles Payne on 2020/04/05.
+//
+
+#import "DetectionBasedTracker.h"
+#import "Mat.h"
+#import "Rect2i.h"
+#import "CVObjcUtil.h"
+
+class CascadeDetectorAdapter: public cv::DetectionBasedTracker::IDetector
+{
+public:
+    CascadeDetectorAdapter(cv::Ptr<cv::CascadeClassifier> detector):IDetector(), Detector(detector) {}
+
+    void detect(const cv::Mat &Image, std::vector<cv::Rect> &objects)
+    {
+        Detector->detectMultiScale(Image, objects, scaleFactor, minNeighbours, 0, minObjSize, maxObjSize);
+    }
+
+    virtual ~CascadeDetectorAdapter() {}
+
+private:
+    CascadeDetectorAdapter();
+    cv::Ptr<cv::CascadeClassifier> Detector;
+};
+
+
+struct DetectorAgregator
+{
+    cv::Ptr<CascadeDetectorAdapter> mainDetector;
+    cv::Ptr<CascadeDetectorAdapter> trackingDetector;
+    cv::Ptr<cv::DetectionBasedTracker> tracker;
+    DetectorAgregator(cv::Ptr<CascadeDetectorAdapter>& _mainDetector, cv::Ptr<CascadeDetectorAdapter>& _trackingDetector):mainDetector(_mainDetector), trackingDetector(_trackingDetector) {
+        CV_Assert(_mainDetector);
+        CV_Assert(_trackingDetector);
+        cv::DetectionBasedTracker::Parameters DetectorParams;
+        tracker = cv::makePtr<cv::DetectionBasedTracker>(mainDetector, trackingDetector, DetectorParams);
+    }
+};
+
+@implementation DetectionBasedTracker {
+    DetectorAgregator* agregator;
+}
+
+- (instancetype)initWithCascadeName:(NSString*)cascadeName minFaceSize:(int)faceSize {
+    self = [super init];
+    if (self) {
+        auto mainDetector = cv::makePtr<CascadeDetectorAdapter>(cv::makePtr<cv::CascadeClassifier>(cascadeName.UTF8String));
+        auto trackingDetector = cv::makePtr<CascadeDetectorAdapter>(
+            cv::makePtr<cv::CascadeClassifier>(cascadeName.UTF8String));
+        agregator = new DetectorAgregator(mainDetector, trackingDetector);
+        if (faceSize > 0) {
+            agregator->mainDetector->setMinObjectSize(cv::Size(faceSize, faceSize));
+        }
+    }
+    return self;
+}
+
+- (void)dealloc
+{
+    delete agregator;
+}
+
+- (void)start {
+    agregator->tracker->run();
+}
+
+- (void)stop {
+    agregator->tracker->stop();
+}
+
+- (void)setFaceSize:(int)size {
+    agregator->mainDetector->setMinObjectSize(cv::Size(size, size));
+}
+
+- (void)detect:(Mat*)imageGray faces:(NSMutableArray<Rect2i*>*)faces {
+    std::vector<cv::Rect> rectFaces;
+    agregator->tracker->process(*((cv::Mat*)imageGray.nativePtr));
+    agregator->tracker->getObjects(rectFaces);
+    CV2OBJC(cv::Rect, Rect2i, rectFaces, faces);
+}
+
+@end
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/FaceDetection-Bridging-Header.h b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/FaceDetection-Bridging-Header.h
new file mode 100644
index 00000000..260d556f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/FaceDetection-Bridging-Header.h
@@ -0,0 +1,5 @@
+//
+//  Use this file to import your target's public headers that you would like to expose to Swift.
+//
+
+#import "DetectionBasedTracker.h"
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Info.plist b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Info.plist
new file mode 100644
index 00000000..19b473c2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/Info.plist
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>NSCameraUsageDescription</key>
+    <string>Please allow access to the camera for image processing</string>
+    <key>UIUserInterfaceStyle</key>
+    <string>Light</string>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>$(DEVELOPMENT_LANGUAGE)</string>
+    <key>CFBundleExecutable</key>
+    <string>$(EXECUTABLE_NAME)</string>
+    <key>CFBundleIdentifier</key>
+    <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>$(PRODUCT_NAME)</string>
+    <key>CFBundlePackageType</key>
+    <string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>LSRequiresIPhoneOS</key>
+    <true/>
+    <key>UILaunchStoryboardName</key>
+    <string>LaunchScreen</string>
+    <key>UIMainStoryboardFile</key>
+    <string>Main</string>
+    <key>UIRequiredDeviceCapabilities</key>
+    <array>
+        <string>armv7</string>
+    </array>
+    <key>UISupportedInterfaceOrientations</key>
+    <array>
+        <string>UIInterfaceOrientationPortrait</string>
+        <string>UIInterfaceOrientationLandscapeLeft</string>
+        <string>UIInterfaceOrientationLandscapeRight</string>
+    </array>
+    <key>UISupportedInterfaceOrientations~ipad</key>
+    <array>
+        <string>UIInterfaceOrientationPortrait</string>
+        <string>UIInterfaceOrientationPortraitUpsideDown</string>
+        <string>UIInterfaceOrientationLandscapeLeft</string>
+        <string>UIInterfaceOrientationLandscapeRight</string>
+    </array>
+</dict>
+</plist>
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/ViewController.swift b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/ViewController.swift
new file mode 100644
index 00000000..d33e9e59
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/ViewController.swift
@@ -0,0 +1,92 @@
+//
+//  ViewController.swift
+//
+//  Created by Giles Payne on 2020/03/02.
+//
+
+import UIKit
+import OpenCV
+
+extension Rect {
+    func rotateClockwise(parentHeight:Int32) {
+        let tmpX = self.x
+        self.x = parentHeight - (self.y + self.height)
+        self.y = tmpX
+        swapDims()
+    }
+
+    func rotateCounterclockwise(parentWidth:Int32) {
+        let tmpY = self.y
+        self.y = parentWidth - (self.x + self.width)
+        self.x = tmpY
+        swapDims()
+    }
+
+    func swapDims() {
+        let tmpWidth = self.width
+        self.width = self.height
+        self.height = tmpWidth
+    }
+}
+
+class ViewController: UIViewController, CvVideoCameraDelegate2 {
+
+    let swiftDetector = CascadeClassifier(filename: Bundle(for: ViewController.self).path(forResource:"lbpcascade_frontalface", ofType:"xml")!)
+    let nativeDetector = DetectionBasedTracker(cascadeName: Bundle(for: ViewController.self).path(forResource:"lbpcascade_frontalface", ofType:"xml")!, minFaceSize: 0)
+    var rgba: Mat? = nil
+    var gray: Mat = Mat()
+    var relativeFaceSize: Float = 0.2
+    var absoluteFaceSize: Int32 = 0
+    let FACE_RECT_COLOR = Scalar(0.0, 255.0, 0.0, 255.0)
+    let FACE_RECT_THICKNESS: Int32 = 4
+
+    func processImage(_ image: Mat!) {
+        let orientation = UIDevice.current.orientation
+        switch orientation {
+        case .landscapeLeft:
+            rgba = Mat()
+            Core.rotate(src: image, dst: rgba!, rotateCode: .ROTATE_90_COUNTERCLOCKWISE)
+        case .landscapeRight:
+            rgba = Mat()
+            Core.rotate(src: image, dst: rgba!, rotateCode: .ROTATE_90_CLOCKWISE)
+        default:
+            rgba = image
+        }
+
+        Imgproc.cvtColor(src: rgba!, dst: gray, code: .COLOR_RGB2GRAY)
+
+        if (absoluteFaceSize == 0) {
+            let height = gray.rows()
+            if (round(Float(height) * relativeFaceSize) > 0) {
+                absoluteFaceSize = Int32(round(Float(height) * relativeFaceSize))
+            }
+        }
+
+        var faces = [Rect]()
+
+        swiftDetector.detectMultiScale(image: gray, objects: &faces, scaleFactor: 1.1, minNeighbors: Int32(2), flags: Int32(2), minSize: Size(width: absoluteFaceSize, height: absoluteFaceSize), maxSize: Size())
+        //let facesArray = NSMutableArray()
+        //nativeDetector!.detect(gray, faces: facesArray)
+        //faces.append(contentsOf: facesArray)
+
+        for face in faces {
+            if orientation == .landscapeLeft {
+                face.rotateClockwise(parentHeight: gray.rows())
+            } else if orientation == .landscapeRight {
+                face.rotateCounterclockwise(parentWidth: gray.cols())
+            }
+            Imgproc.rectangle(img: image, pt1: face.tl(), pt2: face.br(), color: FACE_RECT_COLOR, thickness: FACE_RECT_THICKNESS)
+        }
+    }
+
+    var camera: CvVideoCamera2? = nil
+
+    @IBOutlet weak var cameraHolder: UIView!
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        camera = CvVideoCamera2(parentView: cameraHolder)
+        camera?.rotateVideo = true
+        camera?.delegate = self
+        camera?.start()
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/lbpcascade_frontalface.xml b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/lbpcascade_frontalface.xml
new file mode 100644
index 00000000..fc7648ef
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetection/lbpcascade_frontalface.xml
@@ -0,0 +1,1505 @@
+<?xml version="1.0"?>
+<!--
+number of positive samples 3000
+number of negative samples 1500
+-->
+<opencv_storage>
+<cascade type_id="opencv-cascade-classifier">
+  <stageType>BOOST</stageType>
+  <featureType>LBP</featureType>
+  <height>24</height>
+  <width>24</width>
+  <stageParams>
+    <boostType>GAB</boostType>
+    <minHitRate>0.9950000047683716</minHitRate>
+    <maxFalseAlarm>0.5000000000000000</maxFalseAlarm>
+    <weightTrimRate>0.9500000000000000</weightTrimRate>
+    <maxDepth>1</maxDepth>
+    <maxWeakCount>100</maxWeakCount></stageParams>
+  <featureParams>
+    <maxCatCount>256</maxCatCount></featureParams>
+  <stageNum>20</stageNum>
+  <stages>
+    <!-- stage 0 -->
+    <_>
+      <maxWeakCount>3</maxWeakCount>
+      <stageThreshold>-0.7520892024040222</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 46 -67130709 -21569 -1426120013 -1275125205 -21585
+            -16385 587145899 -24005</internalNodes>
+          <leafValues>
+            -0.6543210148811340 0.8888888955116272</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 13 -163512766 -769593758 -10027009 -262145 -514457854
+            -193593353 -524289 -1</internalNodes>
+          <leafValues>
+            -0.7739216089248657 0.7278633713722229</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 2 -363936790 -893203669 -1337948010 -136907894
+            1088782736 -134217726 -741544961 -1590337</internalNodes>
+          <leafValues>
+            -0.7068563103675842 0.6761534214019775</leafValues></_></weakClassifiers></_>
+    <!-- stage 1 -->
+    <_>
+      <maxWeakCount>4</maxWeakCount>
+      <stageThreshold>-0.4872078299522400</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 84 2147483647 1946124287 -536870913 2147450879
+            738132490 1061101567 243204619 2147446655</internalNodes>
+          <leafValues>
+            -0.8083735704421997 0.7685696482658386</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 21 2147483647 263176079 1879048191 254749487 1879048191
+            -134252545 -268435457 801111999</internalNodes>
+          <leafValues>
+            -0.7698410153388977 0.6592915654182434</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 106 -98110272 1610939566 -285484400 -850010381
+            -189334372 -1671954433 -571026695 -262145</internalNodes>
+          <leafValues>
+            -0.7506558895111084 0.5444605946540833</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 48 -798690576 -131075 1095771153 -237144073 -65569 -1
+            -216727745 -69206049</internalNodes>
+          <leafValues>
+            -0.7775990366935730 0.5465461611747742</leafValues></_></weakClassifiers></_>
+    <!-- stage 2 -->
+    <_>
+      <maxWeakCount>4</maxWeakCount>
+      <stageThreshold>-1.1592328548431396</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 47 -21585 -20549 -100818262 -738254174 -20561 -36865
+            -151016790 -134238549</internalNodes>
+          <leafValues>
+            -0.5601882934570313 0.7743113040924072</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 12 -286003217 183435247 -268994614 -421330945
+            -402686081 1090387966 -286785545 -402653185</internalNodes>
+          <leafValues>
+            -0.6124526262283325 0.6978127956390381</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 26 -50347012 970882927 -50463492 -1253377 -134218251
+            -50364513 -33619992 -172490753</internalNodes>
+          <leafValues>
+            -0.6114496588706970 0.6537628173828125</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 8 -273 -135266321 1877977738 -2088243418 -134217987
+            2146926575 -18910642 1095231247</internalNodes>
+          <leafValues>
+            -0.6854077577590942 0.5403239130973816</leafValues></_></weakClassifiers></_>
+    <!-- stage 3 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.7562355995178223</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 96 -1273 1870659519 -20971602 -67633153 -134250731
+            2004875127 -250 -150995969</internalNodes>
+          <leafValues>
+            -0.4051094949245453 0.7584033608436585</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 33 -868162224 -76810262 -4262145 -257 1465211989
+            -268959873 -2656269 -524289</internalNodes>
+          <leafValues>
+            -0.7388162612915039 0.5340843200683594</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 57 -12817 -49 -541103378 -152950 -38993 -20481 -1153876
+            -72478976</internalNodes>
+          <leafValues>
+            -0.6582943797111511 0.5339496731758118</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 125 -269484161 -452984961 -319816180 -1594032130 -2111
+            -990117891 -488975296 -520947741</internalNodes>
+          <leafValues>
+            -0.5981323719024658 0.5323504805564880</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 53 557787431 670265215 -1342193665 -1075892225
+            1998528318 1056964607 -33570977 -1</internalNodes>
+          <leafValues>
+            -0.6498787999153137 0.4913350641727448</leafValues></_></weakClassifiers></_>
+    <!-- stage 4 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.8085358142852783</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 60 -536873708 880195381 -16842788 -20971521 -176687276
+            -168427659 -16777260 -33554626</internalNodes>
+          <leafValues>
+            -0.5278195738792419 0.6946372389793396</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 7 -1 -62981529 -1090591130 805330978 -8388827 -41945787
+            -39577 -531118985</internalNodes>
+          <leafValues>
+            -0.5206505060195923 0.6329920291900635</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 98 -725287348 1347747543 -852489 -16809993 1489881036
+            -167903241 -1 -1</internalNodes>
+          <leafValues>
+            -0.7516061067581177 0.4232024252414703</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 44 -32777 1006582562 -65 935312171 -8388609 -1078198273
+            -1 733886267</internalNodes>
+          <leafValues>
+            -0.7639313936233521 0.4123568832874298</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 24 -85474705 2138828511 -1036436754 817625855
+            1123369029 -58796809 -1013468481 -194513409</internalNodes>
+          <leafValues>
+            -0.5123769044876099 0.5791834592819214</leafValues></_></weakClassifiers></_>
+    <!-- stage 5 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.5549971461296082</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 42 -17409 -20481 -268457797 -134239493 -17473 -1 -21829
+            -21846</internalNodes>
+          <leafValues>
+            -0.3763174116611481 0.7298233509063721</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 6 -805310737 -2098262358 -269504725 682502698
+            2147483519 1740574719 -1090519233 -268472385</internalNodes>
+          <leafValues>
+            -0.5352765917778015 0.5659480094909668</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 61 -67109678 -6145 -8 -87884584 -20481 -1073762305
+            -50856216 -16849696</internalNodes>
+          <leafValues>
+            -0.5678374171257019 0.4961479902267456</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 123 -138428633 1002418167 -1359008245 -1908670465
+            -1346685918 910098423 -1359010520 -1346371657</internalNodes>
+          <leafValues>
+            -0.5706262588500977 0.4572288393974304</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 9 -89138513 -4196353 1256531674 -1330665426 1216308261
+            -36190633 33498198 -151796633</internalNodes>
+          <leafValues>
+            -0.5344601869583130 0.4672054052352905</leafValues></_></weakClassifiers></_>
+    <!-- stage 6 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.8776460289955139</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 105 1073769576 206601725 -34013449 -33554433 -789514004
+            -101384321 -690225153 -264193</internalNodes>
+          <leafValues>
+            -0.7700348496437073 0.5943940877914429</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 30 -1432340997 -823623681 -49153 -34291724 -269484035
+            -1342767105 -1078198273 -1277955</internalNodes>
+          <leafValues>
+            -0.5043668746948242 0.6151274442672730</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 35 -1067385040 -195758209 -436748425 -134217731
+            -50855988 -129 -1 -1</internalNodes>
+          <leafValues>
+            -0.6808040738105774 0.4667325913906097</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 119 832534325 -34111555 -26050561 -423659521 -268468364
+            2105014143 -2114244 -17367185</internalNodes>
+          <leafValues>
+            -0.4927591383457184 0.5401885509490967</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 82 -1089439888 -1080524865 2143059967 -1114121
+            -1140949004 -3 -2361356 -739516</internalNodes>
+          <leafValues>
+            -0.6445107460021973 0.4227822124958038</leafValues></_></weakClassifiers></_>
+    <!-- stage 7 -->
+    <_>
+      <maxWeakCount>6</maxWeakCount>
+      <stageThreshold>-1.1139287948608398</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 52 -1074071553 -1074003969 -1 -1280135430 -5324817 -1
+            -335548482 582134442</internalNodes>
+          <leafValues>
+            -0.5307556986808777 0.6258179545402527</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 99 -706937396 -705364068 -540016724 -570495027
+            -570630659 -587857963 -33628164 -35848193</internalNodes>
+          <leafValues>
+            -0.5227634310722351 0.5049746036529541</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 18 -2035630093 42119158 -268503053 -1671444 261017599
+            1325432815 1954394111 -805306449</internalNodes>
+          <leafValues>
+            -0.4983572661876679 0.5106441378593445</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 111 -282529488 -1558073088 1426018736 -170526448
+            -546832487 -5113037 -34243375 -570427929</internalNodes>
+          <leafValues>
+            -0.4990860521793366 0.5060507059097290</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 92 1016332500 -606301707 915094269 -1080086049
+            -1837027144 -1361600280 2147318747 1067975613</internalNodes>
+          <leafValues>
+            -0.5695009231567383 0.4460467398166657</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 51 -656420166 -15413034 -141599534 -603435836
+            1505950458 -787556946 -79823438 -1326199134</internalNodes>
+          <leafValues>
+            -0.6590405106544495 0.3616424500942230</leafValues></_></weakClassifiers></_>
+    <!-- stage 8 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.8243625760078430</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 28 -901591776 -201916417 -262 -67371009 -143312112
+            -524289 -41943178 -1</internalNodes>
+          <leafValues>
+            -0.4972776770591736 0.6027074456214905</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 112 -4507851 -411340929 -268437513 -67502145 -17350859
+            -32901 -71344315 -29377</internalNodes>
+          <leafValues>
+            -0.4383158981800079 0.5966237187385559</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 69 -75894785 -117379438 -239063587 -12538500 1485072126
+            2076233213 2123118847 801906927</internalNodes>
+          <leafValues>
+            -0.6386105418205261 0.3977999985218048</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 19 -823480413 786628589 -16876049 -1364262914 242165211
+            1315930109 -696268833 -455082829</internalNodes>
+          <leafValues>
+            -0.5512794256210327 0.4282079637050629</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 73 -521411968 6746762 -1396236286 -2038436114
+            -185612509 57669627 -143132877 -1041235973</internalNodes>
+          <leafValues>
+            -0.6418755054473877 0.3549866080284119</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 126 -478153869 1076028979 -1645895615 1365298272
+            -557859073 -339771473 1442574528 -1058802061</internalNodes>
+          <leafValues>
+            -0.4841901361942291 0.4668019413948059</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 45 -246350404 -1650402048 -1610612745 -788400696
+            1467604861 -2787397 1476263935 -4481349</internalNodes>
+          <leafValues>
+            -0.5855734348297119 0.3879135847091675</leafValues></_></weakClassifiers></_>
+    <!-- stage 9 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-1.2237116098403931</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 114 -24819 1572863935 -16809993 -67108865 2146778388
+            1433927541 -268608444 -34865205</internalNodes>
+          <leafValues>
+            -0.2518476545810700 0.7088654041290283</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 97 -1841359 -134271049 -32769 -5767369 -1116675 -2185
+            -8231 -33603327</internalNodes>
+          <leafValues>
+            -0.4303432404994965 0.5283288359642029</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 25 -1359507589 -1360593090 -1073778729 -269553812
+            -809512977 1744707583 -41959433 -134758978</internalNodes>
+          <leafValues>
+            -0.4259553551673889 0.5440809130668640</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 34 729753407 -134270989 -1140907329 -235200777
+            658456383 2147467263 -1140900929 -16385</internalNodes>
+          <leafValues>
+            -0.5605589151382446 0.4220733344554901</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 134 -310380553 -420675595 -193005472 -353568129
+            1205338070 -990380036 887604324 -420544526</internalNodes>
+          <leafValues>
+            -0.5192656517028809 0.4399855434894562</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 16 -1427119361 1978920959 -287119734 -487068946
+            114759245 -540578051 -707510259 -671660453</internalNodes>
+          <leafValues>
+            -0.5013077259063721 0.4570254683494568</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 74 -738463762 -889949281 -328301948 -121832450
+            -1142658284 -1863576559 2146417353 -263185</internalNodes>
+          <leafValues>
+            -0.4631414115428925 0.4790246188640595</leafValues></_></weakClassifiers></_>
+    <!-- stage 10 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.5544230937957764</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 113 -76228780 -65538 -1 -67174401 -148007 -33 -221796
+            -272842924</internalNodes>
+          <leafValues>
+            -0.3949716091156006 0.6082032322883606</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 110 369147696 -1625232112 2138570036 -1189900 790708019
+            -1212613127 799948719 -4456483</internalNodes>
+          <leafValues>
+            -0.4855885505676270 0.4785369932651520</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 37 784215839 -290015241 536832799 -402984963
+            -1342414991 -838864897 -176769 -268456129</internalNodes>
+          <leafValues>
+            -0.4620285332202911 0.4989669024944305</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 41 -486418688 -171915327 -340294900 -21938 -519766032
+            -772751172 -73096060 -585322623</internalNodes>
+          <leafValues>
+            -0.6420643329620361 0.3624351918697357</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 117 -33554953 -475332625 -1423463824 -2077230421
+            -4849669 -2080505925 -219032928 -1071915349</internalNodes>
+          <leafValues>
+            -0.4820112884044647 0.4632140696048737</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 65 -834130468 -134217476 -1349314083 -1073803559
+            -619913764 -1449131844 -1386890321 -1979118423</internalNodes>
+          <leafValues>
+            -0.4465552568435669 0.5061788558959961</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 56 -285249779 1912569855 -16530 -1731022870 -1161904146
+            -1342177297 -268439634 -1464078708</internalNodes>
+          <leafValues>
+            -0.5190586447715759 0.4441480338573456</leafValues></_></weakClassifiers></_>
+    <!-- stage 11 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.7161560654640198</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 20 1246232575 1078001186 -10027057 60102 -277348353
+            -43646987 -1210581153 1195769615</internalNodes>
+          <leafValues>
+            -0.4323809444904327 0.5663768053054810</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 15 -778583572 -612921106 -578775890 -4036478
+            -1946580497 -1164766570 -1986687009 -12103599</internalNodes>
+          <leafValues>
+            -0.4588732719421387 0.4547033011913300</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 129 -1073759445 2013231743 -1363169553 -1082459201
+            -1414286549 868185983 -1356133589 -1077936257</internalNodes>
+          <leafValues>
+            -0.5218553543090820 0.4111092388629913</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 102 -84148365 -2093417722 -1204850272 564290299
+            -67121221 -1342177350 -1309195902 -776734797</internalNodes>
+          <leafValues>
+            -0.4920000731945038 0.4326725304126740</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 88 -25694458 67104495 -290216278 -168563037 2083877442
+            1702788383 -144191964 -234882162</internalNodes>
+          <leafValues>
+            -0.4494568109512329 0.4448510706424713</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 59 -857980836 904682741 -1612267521 232279415
+            1550862252 -574825221 -357380888 -4579409</internalNodes>
+          <leafValues>
+            -0.5180826783180237 0.3888972699642181</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 27 -98549440 -137838400 494928389 -246013630 939541351
+            -1196072350 -620603549 2137216273</internalNodes>
+          <leafValues>
+            -0.6081240773200989 0.3333222270011902</leafValues></_></weakClassifiers></_>
+    <!-- stage 12 -->
+    <_>
+      <maxWeakCount>8</maxWeakCount>
+      <stageThreshold>-0.6743940711021423</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 29 -150995201 2071191945 -1302151626 536934335
+            -1059008937 914128709 1147328110 -268369925</internalNodes>
+          <leafValues>
+            -0.1790193915367127 0.6605972051620483</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 128 -134509479 1610575703 -1342177289 1861484541
+            -1107833788 1577058173 -333558568 -136319041</internalNodes>
+          <leafValues>
+            -0.3681024610996246 0.5139749646186829</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 70 -1 1060154476 -1090984524 -630918524 -539492875
+            779616255 -839568424 -321</internalNodes>
+          <leafValues>
+            -0.3217232525348663 0.6171553134918213</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 4 -269562385 -285029906 -791084350 -17923776 235286671
+            1275504943 1344390399 -966276889</internalNodes>
+          <leafValues>
+            -0.4373284578323364 0.4358185231685638</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 76 17825984 -747628419 595427229 1474759671 575672208
+            -1684005538 872217086 -1155858277</internalNodes>
+          <leafValues>
+            -0.4404836893081665 0.4601220190525055</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 124 -336593039 1873735591 -822231622 -355795238
+            -470820869 -1997537409 -1057132384 -1015285005</internalNodes>
+          <leafValues>
+            -0.4294152259826660 0.4452161788940430</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 54 -834212130 -593694721 -322142257 -364892500
+            -951029539 -302125121 -1615106053 -79249765</internalNodes>
+          <leafValues>
+            -0.3973052501678467 0.4854526817798615</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 95 1342144479 2147431935 -33554561 -47873 -855685912 -1
+            1988052447 536827383</internalNodes>
+          <leafValues>
+            -0.7054683566093445 0.2697997391223908</leafValues></_></weakClassifiers></_>
+    <!-- stage 13 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-1.2042298316955566</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 39 1431368960 -183437936 -537002499 -137497097
+            1560590321 -84611081 -2097193 -513</internalNodes>
+          <leafValues>
+            -0.5905947685241699 0.5101932883262634</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 120 -1645259691 2105491231 2130706431 1458995007
+            -8567536 -42483883 -33780003 -21004417</internalNodes>
+          <leafValues>
+            -0.4449204802513123 0.4490709304809570</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 89 -612381022 -505806938 -362027516 -452985106
+            275854917 1920431639 -12600561 -134221825</internalNodes>
+          <leafValues>
+            -0.4693818688392639 0.4061094820499420</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 14 -805573153 -161 -554172679 -530519488 -16779441
+            2000682871 -33604275 -150997129</internalNodes>
+          <leafValues>
+            -0.3600351214408875 0.5056326985359192</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 67 6192 435166195 1467449341 2046691505 -1608493775
+            -4755729 -1083162625 -71365637</internalNodes>
+          <leafValues>
+            -0.4459891915321350 0.4132415652275085</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 86 -41689215 -3281034 1853357967 -420712635 -415924289
+            -270209208 -1088293113 -825311232</internalNodes>
+          <leafValues>
+            -0.4466069042682648 0.4135067760944367</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 80 -117391116 -42203396 2080374461 -188709 -542008165
+            -356831940 -1091125345 -1073796897</internalNodes>
+          <leafValues>
+            -0.3394956290721893 0.5658645033836365</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 75 -276830049 1378714472 -1342181951 757272098
+            1073740607 -282199241 -415761549 170896931</internalNodes>
+          <leafValues>
+            -0.5346512198448181 0.3584479391574860</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 55 -796075825 -123166849 2113667055 -217530421
+            -1107432194 -16385 -806359809 -391188771</internalNodes>
+          <leafValues>
+            -0.4379335641860962 0.4123645126819611</leafValues></_></weakClassifiers></_>
+    <!-- stage 14 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.8402050137519836</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 71 -890246622 15525883 -487690486 47116238 -1212319899
+            -1291847681 -68159890 -469829921</internalNodes>
+          <leafValues>
+            -0.2670986354351044 0.6014143228530884</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 31 -1361180685 -1898008841 -1090588811 -285410071
+            -1074016265 -840443905 2147221487 -262145</internalNodes>
+          <leafValues>
+            -0.4149844348430634 0.4670888185501099</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 40 1426190596 1899364271 2142731795 -142607505
+            -508232452 -21563393 -41960001 -65</internalNodes>
+          <leafValues>
+            -0.4985891580581665 0.3719584941864014</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 109 -201337965 10543906 -236498096 -746195597
+            1974565825 -15204415 921907633 -190058309</internalNodes>
+          <leafValues>
+            -0.4568729996681213 0.3965812027454376</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 130 -595026732 -656401928 -268649235 -571490699
+            -440600392 -133131 -358810952 -2004088646</internalNodes>
+          <leafValues>
+            -0.4770836830139160 0.3862601518630981</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 66 941674740 -1107882114 1332789109 -67691015
+            -1360463693 -1556612430 -609108546 733546933</internalNodes>
+          <leafValues>
+            -0.4877715110778809 0.3778986334800720</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 49 -17114945 -240061474 1552871558 -82775604 -932393844
+            -1308544889 -532635478 -99042357</internalNodes>
+          <leafValues>
+            -0.3721654713153839 0.4994400143623352</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 133 -655906006 1405502603 -939205164 1884929228
+            -498859222 559417357 -1928559445 -286264385</internalNodes>
+          <leafValues>
+            -0.3934195041656494 0.4769641458988190</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 0 -335837777 1860677295 -90 -1946186226 931096183
+            251612987 2013265917 -671232197</internalNodes>
+          <leafValues>
+            -0.4323300719261169 0.4342164099216461</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 103 37769424 -137772680 374692301 2002666345 -536176194
+            -1644484728 807009019 1069089930</internalNodes>
+          <leafValues>
+            -0.4993278682231903 0.3665378093719482</leafValues></_></weakClassifiers></_>
+    <!-- stage 15 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-1.1974394321441650</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 43 -5505 2147462911 2143265466 -4511070 -16450 -257
+            -201348440 -71333206</internalNodes>
+          <leafValues>
+            -0.3310225307941437 0.5624626278877258</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 90 -136842268 -499330741 2015250980 -87107126
+            -641665744 -788524639 -1147864792 -134892563</internalNodes>
+          <leafValues>
+            -0.5266560912132263 0.3704403042793274</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 104 -146800880 -1780368555 2111170033 -140904684
+            -16777551 -1946681885 -1646463595 -839131947</internalNodes>
+          <leafValues>
+            -0.4171888828277588 0.4540435671806335</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 85 -832054034 -981663763 -301990281 -578814081
+            -932319000 -1997406723 -33555201 -69206017</internalNodes>
+          <leafValues>
+            -0.4556705355644226 0.3704262077808380</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 24 -118492417 -1209026825 1119023838 -1334313353
+            1112948738 -297319313 1378887291 -139469193</internalNodes>
+          <leafValues>
+            -0.4182529747486115 0.4267231225967407</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 78 -1714382628 -2353704 -112094959 -549613092
+            -1567058760 -1718550464 -342315012 -1074972227</internalNodes>
+          <leafValues>
+            -0.3625369668006897 0.4684656262397766</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 5 -85219702 316836394 -33279 1904970288 2117267315
+            -260901769 -621461759 -88607770</internalNodes>
+          <leafValues>
+            -0.4742925167083740 0.3689507246017456</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 11 -294654041 -353603585 -1641159686 -50331921
+            -2080899877 1145569279 -143132713 -152044037</internalNodes>
+          <leafValues>
+            -0.3666271567344666 0.4580127298831940</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 32 1887453658 -638545712 -1877976819 -34320972
+            -1071067983 -661345416 -583338277 1060190561</internalNodes>
+          <leafValues>
+            -0.4567637443542481 0.3894708156585693</leafValues></_></weakClassifiers></_>
+    <!-- stage 16 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-0.5733128190040588</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 122 -994063296 1088745462 -318837116 -319881377
+            1102566613 1165490103 -121679694 -134744129</internalNodes>
+          <leafValues>
+            -0.4055117964744568 0.5487945079803467</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 68 -285233233 -538992907 1811935199 -369234005 -529
+            -20593 -20505 -1561401854</internalNodes>
+          <leafValues>
+            -0.3787897229194641 0.4532003402709961</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 58 -1335245632 1968917183 1940861695 536816369
+            -1226071367 -570908176 457026619 1000020667</internalNodes>
+          <leafValues>
+            -0.4258328974246979 0.4202791750431061</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 94 -1360318719 -1979797897 -50435249 -18646473
+            -608879292 -805306691 -269304244 -17840167</internalNodes>
+          <leafValues>
+            -0.4561023116111755 0.4002747833728790</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 87 2062765935 -16449 -1275080721 -16406 45764335
+            -1090552065 -772846337 -570464322</internalNodes>
+          <leafValues>
+            -0.4314672648906708 0.4086346626281738</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 127 -536896021 1080817663 -738234288 -965478709
+            -2082767969 1290855887 1993822934 -990381609</internalNodes>
+          <leafValues>
+            -0.4174543321132660 0.4249868988990784</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 3 -818943025 168730891 -293610428 -79249354 669224671
+            621166734 1086506807 1473768907</internalNodes>
+          <leafValues>
+            -0.4321364760398865 0.4090838730335236</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 79 -68895696 -67107736 -1414315879 -841676168
+            -619843344 -1180610531 -1081990469 1043203389</internalNodes>
+          <leafValues>
+            -0.5018386244773865 0.3702533841133118</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 116 -54002134 -543485719 -2124882422 -1437445858
+            -115617074 -1195787391 -1096024366 -2140472445</internalNodes>
+          <leafValues>
+            -0.5037505626678467 0.3564981222152710</leafValues></_></weakClassifiers></_>
+    <!-- stage 17 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-0.4892596900463104</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 132 -67113211 2003808111 1862135111 846461923 -2752
+            2002237273 -273154752 1937223539</internalNodes>
+          <leafValues>
+            -0.2448196411132813 0.5689709186553955</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 62 1179423888 -78064940 -611839555 -539167899
+            -1289358360 -1650810108 -892540499 -1432827684</internalNodes>
+          <leafValues>
+            -0.4633283913135529 0.3587929606437683</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 23 -285212705 -78450761 -656212031 -264050110 -27787425
+            -1334349961 -547662981 -135796924</internalNodes>
+          <leafValues>
+            -0.3731099069118500 0.4290455579757690</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 77 341863476 403702016 -550588417 1600194541
+            -1080690735 951127993 -1388580949 -1153717473</internalNodes>
+          <leafValues>
+            -0.3658909499645233 0.4556473195552826</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 22 -586880702 -204831512 -100644596 -39319550
+            -1191150794 705692513 457203315 -75806957</internalNodes>
+          <leafValues>
+            -0.5214384198188782 0.3221037387847900</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 72 -416546870 545911370 -673716192 -775559454
+            -264113598 139424 -183369982 -204474641</internalNodes>
+          <leafValues>
+            -0.4289036989212036 0.4004956185817719</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 50 -1026505020 -589692154 -1740499937 -1563770497
+            1348491006 -60710713 -1109853489 -633909413</internalNodes>
+          <leafValues>
+            -0.4621542394161224 0.3832748532295227</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 108 -1448872304 -477895040 -1778390608 -772418127
+            -1789923416 -1612057181 -805306693 -1415842113</internalNodes>
+          <leafValues>
+            -0.3711548447608948 0.4612701535224915</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 92 407905424 -582449988 52654751 -1294472 -285103725
+            -74633006 1871559083 1057955850</internalNodes>
+          <leafValues>
+            -0.5180652141571045 0.3205870389938355</leafValues></_></weakClassifiers></_>
+    <!-- stage 18 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.5911940932273865</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 81 4112 -1259563825 -846671428 -100902460 1838164148
+            -74153752 -90653988 -1074263896</internalNodes>
+          <leafValues>
+            -0.2592592537403107 0.5873016119003296</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 1 -285216785 -823206977 -1085589 -1081346 1207959293
+            1157103471 2097133565 -2097169</internalNodes>
+          <leafValues>
+            -0.3801195919513702 0.4718827307224274</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 121 -12465 -536875169 2147478367 2130706303 -37765492
+            -866124467 -318782328 -1392509185</internalNodes>
+          <leafValues>
+            -0.3509117066860199 0.5094807147979736</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 38 2147449663 -20741 -16794757 1945873146 -16710 -1
+            -8406341 -67663041</internalNodes>
+          <leafValues>
+            -0.4068757295608521 0.4130136370658875</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 17 -155191713 866117231 1651407483 548272812 -479201468
+            -447742449 1354229504 -261884429</internalNodes>
+          <leafValues>
+            -0.4557141065597534 0.3539792001247406</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 100 -225319378 -251682065 -492783986 -792341777
+            -1287261695 1393643841 -11274182 -213909521</internalNodes>
+          <leafValues>
+            -0.4117803275585175 0.4118592441082001</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 63 -382220122 -2002072729 -51404800 -371201558
+            -923011069 -2135301457 -2066104743 -1042557441</internalNodes>
+          <leafValues>
+            -0.4008397758007050 0.4034757018089294</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 101 -627353764 -48295149 1581203952 -436258614
+            -105268268 -1435893445 -638126888 -1061107126</internalNodes>
+          <leafValues>
+            -0.5694189667701721 0.2964762747287750</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 118 -8399181 1058107691 -621022752 -251003468 -12582915
+            -574619739 -994397789 -1648362021</internalNodes>
+          <leafValues>
+            -0.3195341229438782 0.5294018983840942</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 92 -348343812 -1078389516 1717960437 364735981
+            -1783841602 -4883137 -457572354 -1076950384</internalNodes>
+          <leafValues>
+            -0.3365339040756226 0.5067458748817444</leafValues></_></weakClassifiers></_>
+    <!-- stage 19 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.7612916231155396</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 10 -1976661318 -287957604 -1659497122 -782068 43591089
+            -453637880 1435470000 -1077438561</internalNodes>
+          <leafValues>
+            -0.4204545319080353 0.5165745615959168</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 131 -67110925 14874979 -142633168 -1338923040
+            2046713291 -2067933195 1473503712 -789579837</internalNodes>
+          <leafValues>
+            -0.3762553930282593 0.4075302779674530</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 83 -272814301 -1577073 -1118685 -305156120 -1052289
+            -1073813756 -538971154 -355523038</internalNodes>
+          <leafValues>
+            -0.4253497421741486 0.3728055357933044</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 135 -2233 -214486242 -538514758 573747007 -159390971
+            1994225489 -973738098 -203424005</internalNodes>
+          <leafValues>
+            -0.3601998090744019 0.4563256204128265</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 115 -261031688 -1330369299 -641860609 1029570301
+            -1306461192 -1196149518 -1529767778 683139823</internalNodes>
+          <leafValues>
+            -0.4034293889999390 0.4160816967487335</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 64 -572993608 -34042628 -417865 -111109 -1433365268
+            -19869715 -1920939864 -1279457063</internalNodes>
+          <leafValues>
+            -0.3620899617671967 0.4594142735004425</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 36 -626275097 -615256993 1651946018 805366393
+            2016559730 -430780849 -799868165 -16580645</internalNodes>
+          <leafValues>
+            -0.3903816640377045 0.4381459355354309</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 93 1354797300 -1090957603 1976418270 -1342502178
+            -1851873892 -1194637077 -1153521668 -1108399474</internalNodes>
+          <leafValues>
+            -0.3591445386409760 0.4624078869819641</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 91 68157712 1211368313 -304759523 1063017136 798797750
+            -275513546 648167355 -1145357350</internalNodes>
+          <leafValues>
+            -0.4297670423984528 0.4023293554782867</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 107 -546318240 -1628569602 -163577944 -537002306
+            -545456389 -1325465645 -380446736 -1058473386</internalNodes>
+          <leafValues>
+            -0.5727006793022156 0.2995934784412384</leafValues></_></weakClassifiers></_></stages>
+  <features>
+    <_>
+      <rect>
+        0 0 3 5</rect></_>
+    <_>
+      <rect>
+        0 0 4 2</rect></_>
+    <_>
+      <rect>
+        0 0 6 3</rect></_>
+    <_>
+      <rect>
+        0 1 2 3</rect></_>
+    <_>
+      <rect>
+        0 1 3 3</rect></_>
+    <_>
+      <rect>
+        0 1 3 7</rect></_>
+    <_>
+      <rect>
+        0 4 3 3</rect></_>
+    <_>
+      <rect>
+        0 11 3 4</rect></_>
+    <_>
+      <rect>
+        0 12 8 4</rect></_>
+    <_>
+      <rect>
+        0 14 4 3</rect></_>
+    <_>
+      <rect>
+        1 0 5 3</rect></_>
+    <_>
+      <rect>
+        1 1 2 2</rect></_>
+    <_>
+      <rect>
+        1 3 3 1</rect></_>
+    <_>
+      <rect>
+        1 7 4 4</rect></_>
+    <_>
+      <rect>
+        1 12 2 2</rect></_>
+    <_>
+      <rect>
+        1 13 4 1</rect></_>
+    <_>
+      <rect>
+        1 14 4 3</rect></_>
+    <_>
+      <rect>
+        1 17 3 2</rect></_>
+    <_>
+      <rect>
+        2 0 2 3</rect></_>
+    <_>
+      <rect>
+        2 1 2 2</rect></_>
+    <_>
+      <rect>
+        2 2 4 6</rect></_>
+    <_>
+      <rect>
+        2 3 4 4</rect></_>
+    <_>
+      <rect>
+        2 7 2 1</rect></_>
+    <_>
+      <rect>
+        2 11 2 3</rect></_>
+    <_>
+      <rect>
+        2 17 3 2</rect></_>
+    <_>
+      <rect>
+        3 0 2 2</rect></_>
+    <_>
+      <rect>
+        3 1 7 3</rect></_>
+    <_>
+      <rect>
+        3 7 2 1</rect></_>
+    <_>
+      <rect>
+        3 7 2 4</rect></_>
+    <_>
+      <rect>
+        3 18 2 2</rect></_>
+    <_>
+      <rect>
+        4 0 2 3</rect></_>
+    <_>
+      <rect>
+        4 3 2 1</rect></_>
+    <_>
+      <rect>
+        4 6 2 1</rect></_>
+    <_>
+      <rect>
+        4 6 2 5</rect></_>
+    <_>
+      <rect>
+        4 7 5 2</rect></_>
+    <_>
+      <rect>
+        4 8 4 3</rect></_>
+    <_>
+      <rect>
+        4 18 2 2</rect></_>
+    <_>
+      <rect>
+        5 0 2 2</rect></_>
+    <_>
+      <rect>
+        5 3 4 4</rect></_>
+    <_>
+      <rect>
+        5 6 2 5</rect></_>
+    <_>
+      <rect>
+        5 9 2 2</rect></_>
+    <_>
+      <rect>
+        5 10 2 2</rect></_>
+    <_>
+      <rect>
+        6 3 4 4</rect></_>
+    <_>
+      <rect>
+        6 4 4 3</rect></_>
+    <_>
+      <rect>
+        6 5 2 3</rect></_>
+    <_>
+      <rect>
+        6 5 2 5</rect></_>
+    <_>
+      <rect>
+        6 5 4 3</rect></_>
+    <_>
+      <rect>
+        6 6 4 2</rect></_>
+    <_>
+      <rect>
+        6 6 4 4</rect></_>
+    <_>
+      <rect>
+        6 18 1 2</rect></_>
+    <_>
+      <rect>
+        6 21 2 1</rect></_>
+    <_>
+      <rect>
+        7 0 3 7</rect></_>
+    <_>
+      <rect>
+        7 4 2 3</rect></_>
+    <_>
+      <rect>
+        7 9 5 1</rect></_>
+    <_>
+      <rect>
+        7 21 2 1</rect></_>
+    <_>
+      <rect>
+        8 0 1 4</rect></_>
+    <_>
+      <rect>
+        8 5 2 2</rect></_>
+    <_>
+      <rect>
+        8 5 3 2</rect></_>
+    <_>
+      <rect>
+        8 17 3 1</rect></_>
+    <_>
+      <rect>
+        8 18 1 2</rect></_>
+    <_>
+      <rect>
+        9 0 5 3</rect></_>
+    <_>
+      <rect>
+        9 2 2 6</rect></_>
+    <_>
+      <rect>
+        9 5 1 1</rect></_>
+    <_>
+      <rect>
+        9 11 1 1</rect></_>
+    <_>
+      <rect>
+        9 16 1 1</rect></_>
+    <_>
+      <rect>
+        9 16 2 1</rect></_>
+    <_>
+      <rect>
+        9 17 1 1</rect></_>
+    <_>
+      <rect>
+        9 18 1 1</rect></_>
+    <_>
+      <rect>
+        10 5 1 2</rect></_>
+    <_>
+      <rect>
+        10 5 3 3</rect></_>
+    <_>
+      <rect>
+        10 7 1 5</rect></_>
+    <_>
+      <rect>
+        10 8 1 1</rect></_>
+    <_>
+      <rect>
+        10 9 1 1</rect></_>
+    <_>
+      <rect>
+        10 10 1 1</rect></_>
+    <_>
+      <rect>
+        10 10 1 2</rect></_>
+    <_>
+      <rect>
+        10 14 3 3</rect></_>
+    <_>
+      <rect>
+        10 15 1 1</rect></_>
+    <_>
+      <rect>
+        10 15 2 1</rect></_>
+    <_>
+      <rect>
+        10 16 1 1</rect></_>
+    <_>
+      <rect>
+        10 16 2 1</rect></_>
+    <_>
+      <rect>
+        10 17 1 1</rect></_>
+    <_>
+      <rect>
+        10 21 1 1</rect></_>
+    <_>
+      <rect>
+        11 3 2 2</rect></_>
+    <_>
+      <rect>
+        11 5 1 2</rect></_>
+    <_>
+      <rect>
+        11 5 3 3</rect></_>
+    <_>
+      <rect>
+        11 5 4 6</rect></_>
+    <_>
+      <rect>
+        11 6 1 1</rect></_>
+    <_>
+      <rect>
+        11 7 2 2</rect></_>
+    <_>
+      <rect>
+        11 8 1 2</rect></_>
+    <_>
+      <rect>
+        11 10 1 1</rect></_>
+    <_>
+      <rect>
+        11 10 1 2</rect></_>
+    <_>
+      <rect>
+        11 15 1 1</rect></_>
+    <_>
+      <rect>
+        11 17 1 1</rect></_>
+    <_>
+      <rect>
+        11 18 1 1</rect></_>
+    <_>
+      <rect>
+        12 0 2 2</rect></_>
+    <_>
+      <rect>
+        12 1 2 5</rect></_>
+    <_>
+      <rect>
+        12 2 4 1</rect></_>
+    <_>
+      <rect>
+        12 3 1 3</rect></_>
+    <_>
+      <rect>
+        12 7 3 4</rect></_>
+    <_>
+      <rect>
+        12 10 3 2</rect></_>
+    <_>
+      <rect>
+        12 11 1 1</rect></_>
+    <_>
+      <rect>
+        12 12 3 2</rect></_>
+    <_>
+      <rect>
+        12 14 4 3</rect></_>
+    <_>
+      <rect>
+        12 17 1 1</rect></_>
+    <_>
+      <rect>
+        12 21 2 1</rect></_>
+    <_>
+      <rect>
+        13 6 2 5</rect></_>
+    <_>
+      <rect>
+        13 7 3 5</rect></_>
+    <_>
+      <rect>
+        13 11 3 2</rect></_>
+    <_>
+      <rect>
+        13 17 2 2</rect></_>
+    <_>
+      <rect>
+        13 17 3 2</rect></_>
+    <_>
+      <rect>
+        13 18 1 2</rect></_>
+    <_>
+      <rect>
+        13 18 2 2</rect></_>
+    <_>
+      <rect>
+        14 0 2 2</rect></_>
+    <_>
+      <rect>
+        14 1 1 3</rect></_>
+    <_>
+      <rect>
+        14 2 3 2</rect></_>
+    <_>
+      <rect>
+        14 7 2 1</rect></_>
+    <_>
+      <rect>
+        14 13 2 1</rect></_>
+    <_>
+      <rect>
+        14 13 3 3</rect></_>
+    <_>
+      <rect>
+        14 17 2 2</rect></_>
+    <_>
+      <rect>
+        15 0 2 2</rect></_>
+    <_>
+      <rect>
+        15 0 2 3</rect></_>
+    <_>
+      <rect>
+        15 4 3 2</rect></_>
+    <_>
+      <rect>
+        15 4 3 6</rect></_>
+    <_>
+      <rect>
+        15 6 3 2</rect></_>
+    <_>
+      <rect>
+        15 11 3 4</rect></_>
+    <_>
+      <rect>
+        15 13 3 2</rect></_>
+    <_>
+      <rect>
+        15 17 2 2</rect></_>
+    <_>
+      <rect>
+        15 17 3 2</rect></_>
+    <_>
+      <rect>
+        16 1 2 3</rect></_>
+    <_>
+      <rect>
+        16 3 2 4</rect></_>
+    <_>
+      <rect>
+        16 6 1 1</rect></_>
+    <_>
+      <rect>
+        16 16 2 2</rect></_>
+    <_>
+      <rect>
+        17 1 2 2</rect></_>
+    <_>
+      <rect>
+        17 1 2 5</rect></_>
+    <_>
+      <rect>
+        17 12 2 2</rect></_>
+    <_>
+      <rect>
+        18 0 2 2</rect></_></features></cascade>
+</opencv_storage>
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetectionDynamic.xcodeproj/project.pbxproj b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetectionDynamic.xcodeproj/project.pbxproj
new file mode 100644
index 00000000..e0d17a8e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetectionDynamic.xcodeproj/project.pbxproj
@@ -0,0 +1,423 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 50;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		5B79BD652439FF020062DD99 /* DetectionBasedTracker.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5B79BD642439FF020062DD99 /* DetectionBasedTracker.mm */; };
+		5B8C4C2D243814E9003D9176 /* libc++.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 5B8C4C2C243814A0003D9176 /* libc++.tbd */; };
+		5B8C4C2F2438383D003D9176 /* lbpcascade_frontalface.xml in Resources */ = {isa = PBXBuildFile; fileRef = 5B8C4C2E2438383D003D9176 /* lbpcascade_frontalface.xml */; };
+		5BBDB48A240D380F00BB10FE /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5BBDB489240D380F00BB10FE /* AppDelegate.swift */; };
+		5BBDB48E240D380F00BB10FE /* ViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5BBDB48D240D380F00BB10FE /* ViewController.swift */; };
+		5BBDB491240D380F00BB10FE /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB48F240D380F00BB10FE /* Main.storyboard */; };
+		5BBDB493240D381000BB10FE /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB492240D381000BB10FE /* Assets.xcassets */; };
+		5BBDB496240D381000BB10FE /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */; };
+		5BBDB517241923C800BB10FE /* AVFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5BBDB516241923C800BB10FE /* AVFoundation.framework */; };
+		5BBDB5192419241200BB10FE /* CoreMedia.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5BBDB5182419241200BB10FE /* CoreMedia.framework */; };
+		5BE7205A25201437004E84AE /* OpenCV.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5B14CF812452EED3003438BE /* OpenCV.framework */; };
+		5BE7205B25201437004E84AE /* OpenCV.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = 5B14CF812452EED3003438BE /* OpenCV.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		5BE7205C25201437004E84AE /* Embed Frameworks */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "";
+			dstSubfolderSpec = 10;
+			files = (
+				5BE7205B25201437004E84AE /* OpenCV.framework in Embed Frameworks */,
+			);
+			name = "Embed Frameworks";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		5B14CF812452EED3003438BE /* OpenCV.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenCV.framework; path = ../../../OpenCV.framework; sourceTree = "<group>"; };
+		5B79BD622439FEB60062DD99 /* DetectionBasedTracker.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DetectionBasedTracker.h; sourceTree = "<group>"; };
+		5B79BD632439FF020062DD99 /* FaceDetection-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "FaceDetection-Bridging-Header.h"; sourceTree = "<group>"; };
+		5B79BD642439FF020062DD99 /* DetectionBasedTracker.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = DetectionBasedTracker.mm; sourceTree = "<group>"; };
+		5B8C4C2C243814A0003D9176 /* libc++.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = "libc++.tbd"; path = "usr/lib/libc++.tbd"; sourceTree = SDKROOT; };
+		5B8C4C2E2438383D003D9176 /* lbpcascade_frontalface.xml */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = lbpcascade_frontalface.xml; sourceTree = "<group>"; };
+		5BBDB486240D380F00BB10FE /* FaceDetection.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = FaceDetection.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		5BBDB489240D380F00BB10FE /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		5BBDB48D240D380F00BB10FE /* ViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ViewController.swift; sourceTree = "<group>"; };
+		5BBDB490240D380F00BB10FE /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		5BBDB492240D381000BB10FE /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		5BBDB495240D381000BB10FE /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		5BBDB497240D381000BB10FE /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		5BBDB516241923C800BB10FE /* AVFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AVFoundation.framework; path = System/Library/Frameworks/AVFoundation.framework; sourceTree = SDKROOT; };
+		5BBDB5182419241200BB10FE /* CoreMedia.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreMedia.framework; path = System/Library/Frameworks/CoreMedia.framework; sourceTree = SDKROOT; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		5BBDB483240D380F00BB10FE /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5BBDB5192419241200BB10FE /* CoreMedia.framework in Frameworks */,
+				5B8C4C2D243814E9003D9176 /* libc++.tbd in Frameworks */,
+				5BBDB517241923C800BB10FE /* AVFoundation.framework in Frameworks */,
+				5BE7205A25201437004E84AE /* OpenCV.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		5BBDB47D240D380F00BB10FE = {
+			isa = PBXGroup;
+			children = (
+				5BBDB488240D380F00BB10FE /* FaceDetection */,
+				5BBDB487240D380F00BB10FE /* Products */,
+				5BBDB515241923C800BB10FE /* Frameworks */,
+			);
+			sourceTree = "<group>";
+		};
+		5BBDB487240D380F00BB10FE /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				5BBDB486240D380F00BB10FE /* FaceDetection.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		5BBDB488240D380F00BB10FE /* FaceDetection */ = {
+			isa = PBXGroup;
+			children = (
+				5B14CF812452EED3003438BE /* OpenCV.framework */,
+				5B8C4C2E2438383D003D9176 /* lbpcascade_frontalface.xml */,
+				5BBDB489240D380F00BB10FE /* AppDelegate.swift */,
+				5BBDB48D240D380F00BB10FE /* ViewController.swift */,
+				5BBDB48F240D380F00BB10FE /* Main.storyboard */,
+				5BBDB492240D381000BB10FE /* Assets.xcassets */,
+				5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */,
+				5BBDB497240D381000BB10FE /* Info.plist */,
+				5B79BD622439FEB60062DD99 /* DetectionBasedTracker.h */,
+				5B79BD642439FF020062DD99 /* DetectionBasedTracker.mm */,
+				5B79BD632439FF020062DD99 /* FaceDetection-Bridging-Header.h */,
+			);
+			path = FaceDetection;
+			sourceTree = "<group>";
+		};
+		5BBDB515241923C800BB10FE /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				5B8C4C2C243814A0003D9176 /* libc++.tbd */,
+				5BBDB5182419241200BB10FE /* CoreMedia.framework */,
+				5BBDB516241923C800BB10FE /* AVFoundation.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		5BBDB485240D380F00BB10FE /* FaceDetection */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 5BBDB4B0240D381000BB10FE /* Build configuration list for PBXNativeTarget "FaceDetection" */;
+			buildPhases = (
+				5BBDB482240D380F00BB10FE /* Sources */,
+				5BBDB483240D380F00BB10FE /* Frameworks */,
+				5BBDB484240D380F00BB10FE /* Resources */,
+				5BE7205C25201437004E84AE /* Embed Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = FaceDetection;
+			productName = FaceDetection;
+			productReference = 5BBDB486240D380F00BB10FE /* FaceDetection.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		5BBDB47E240D380F00BB10FE /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastSwiftUpdateCheck = 1130;
+				LastUpgradeCheck = 1130;
+				ORGANIZATIONNAME = OpenCV;
+				TargetAttributes = {
+					5BBDB485240D380F00BB10FE = {
+						CreatedOnToolsVersion = 11.3.1;
+						LastSwiftMigration = 1130;
+					};
+				};
+			};
+			buildConfigurationList = 5BBDB481240D380F00BB10FE /* Build configuration list for PBXProject "FaceDetectionDynamic" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 5BBDB47D240D380F00BB10FE;
+			productRefGroup = 5BBDB487240D380F00BB10FE /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				5BBDB485240D380F00BB10FE /* FaceDetection */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		5BBDB484240D380F00BB10FE /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5BBDB496240D381000BB10FE /* LaunchScreen.storyboard in Resources */,
+				5BBDB493240D381000BB10FE /* Assets.xcassets in Resources */,
+				5BBDB491240D380F00BB10FE /* Main.storyboard in Resources */,
+				5B8C4C2F2438383D003D9176 /* lbpcascade_frontalface.xml in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		5BBDB482240D380F00BB10FE /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				5B79BD652439FF020062DD99 /* DetectionBasedTracker.mm in Sources */,
+				5BBDB48E240D380F00BB10FE /* ViewController.swift in Sources */,
+				5BBDB48A240D380F00BB10FE /* AppDelegate.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+		5BBDB48F240D380F00BB10FE /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				5BBDB490240D380F00BB10FE /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		5BBDB494240D381000BB10FE /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				5BBDB495240D381000BB10FE /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		5BBDB4AE240D381000BB10FE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				FRAMEWORK_SEARCH_PATHS = ../..;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = "../../OpenCV/**";
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
+				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				OTHER_LDFLAGS = "";
+				SDKROOT = iphoneos;
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
+				SWIFT_OBJC_BRIDGING_HEADER = "FaceDetection/FaceDetection-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+			};
+			name = Debug;
+		};
+		5BBDB4AF240D381000BB10FE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				FRAMEWORK_SEARCH_PATHS = ../..;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = "../../OpenCV/**";
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				MTL_FAST_MATH = YES;
+				OTHER_LDFLAGS = "";
+				SDKROOT = iphoneos;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OBJC_BRIDGING_HEADER = "FaceDetection/FaceDetection-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		5BBDB4B1240D381000BB10FE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
+				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/../..",
+				);
+				HEADER_SEARCH_PATHS = "$(PROJECT_DIR)/../../OpenCV.framework/Headers";
+				INFOPLIST_FILE = FaceDetection/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				OTHER_SWIFT_FLAGS = "-Xcc -Wno-incomplete-umbrella";
+				PRODUCT_BUNDLE_IDENTIFIER = org.opencv.FaceDetection;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				SWIFT_OBJC_BRIDGING_HEADER = "FaceDetection/FaceDetection-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		5BBDB4B2240D381000BB10FE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
+				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/../..",
+				);
+				HEADER_SEARCH_PATHS = "$(PROJECT_DIR)/../../OpenCV.framework/Headers";
+				INFOPLIST_FILE = FaceDetection/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				OTHER_SWIFT_FLAGS = "-Xcc -Wno-incomplete-umbrella";
+				PRODUCT_BUNDLE_IDENTIFIER = org.opencv.FaceDetection;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				SWIFT_OBJC_BRIDGING_HEADER = "FaceDetection/FaceDetection-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		5BBDB481240D380F00BB10FE /* Build configuration list for PBXProject "FaceDetectionDynamic" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				5BBDB4AE240D381000BB10FE /* Debug */,
+				5BBDB4AF240D381000BB10FE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		5BBDB4B0240D381000BB10FE /* Build configuration list for PBXNativeTarget "FaceDetection" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				5BBDB4B1240D381000BB10FE /* Debug */,
+				5BBDB4B2240D381000BB10FE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 5BBDB47E240D380F00BB10FE /* Project object */;
+}
diff --git a/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetectionDynamic.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetectionDynamic.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
new file mode 100644
index 00000000..3d4c1e55
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/swift/ios/FaceDetection/FaceDetectionDynamic.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>IDEDidComputeMac32BitWarning</key>
+    <true/>
+</dict>
+</plist>
diff --git a/C++/opencv-4.7.0/samples/sycl/CMakeLists.txt b/C++/opencv-4.7.0/samples/sycl/CMakeLists.txt
new file mode 100644
index 00000000..3a3483bd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/sycl/CMakeLists.txt
@@ -0,0 +1,80 @@
+if(OPENCV_SKIP_SAMPLES_SYCL)
+  return()
+endif()
+
+ocv_install_example_src(sycl *.cpp *.hpp CMakeLists.txt)
+
+set(OPENCV_SYCL_SAMPLES_REQUIRED_DEPS
+  opencv_core
+  opencv_imgproc
+  opencv_imgcodecs
+  opencv_videoio
+  opencv_highgui)
+ocv_check_dependencies(${OPENCV_SYCL_SAMPLES_REQUIRED_DEPS})
+
+if(NOT BUILD_EXAMPLES OR NOT OCV_DEPENDENCIES_FOUND OR OPENCV_SKIP_SAMPLES_BUILD_SYCL)
+  return()
+endif()
+
+if(CMAKE_VERSION VERSION_LESS "3.5")
+  message(STATUS "SYCL samples require CMake 3.5+")
+  return()
+endif()
+
+cmake_policy(VERSION 3.5)
+
+find_package(SYCL QUIET)  # will oneAPI support this straightforward way?
+
+if(NOT SYCL_FOUND AND NOT OPENCV_SKIP_SAMPLES_SYCL_ONEDNN)
+  # lets try scripts from oneAPI:oneDNN component
+  if(NOT DEFINED DNNLROOT AND DEFINED ENV{DNNLROOT})
+    set(DNNLROOT "$ENV{DNNLROOT}")
+  endif()
+  # Some verions of called script violate CMake policy and may emit unrecoverable CMake errors
+  # Use OPENCV_SKIP_SAMPLES_SYCL=1 / OPENCV_SKIP_SAMPLES_SYCL_ONEDNN to bypass this
+  find_package(dnnl CONFIG QUIET HINTS "${DNNLROOT}")
+endif()
+
+if(NOT SYCL_FOUND AND NOT OPENCV_SKIP_SAMPLES_SYCL_COMPUTECPP)
+  # lets try this SYCL SDK too: https://github.com/codeplaysoftware/computecpp-sdk
+  find_package(ComputeCpp QUIET)
+  if(ComputeCpp_FOUND)
+    set(SYCL_TARGET ComputeCpp::ComputeCpp)
+    set(SYCL_FLAGS ${ComputeCpp_FLAGS})
+    set(SYCL_INCLUDE_DIRS ${ComputeCpp_INCLUDE_DIRS})
+    set(SYCL_LIBRARIES ${ComputeCpp_LIBRARIES})
+  endif()
+endif()
+
+if(OPENCV_CMAKE_DEBUG_SYCL)
+  ocv_cmake_dump_vars("SYCL")  # OpenCV source tree is required
+endif()
+
+if(NOT SYCL_TARGET)
+  message(STATUS "SYCL/OpenCL samples are skipped: SYCL SDK is required")
+  message(STATUS "   - check configuration of SYCL_DIR/SYCL_ROOT/CMAKE_MODULE_PATH")
+  message(STATUS "   - ensure that right compiler is selected from SYCL SDK (e.g, clang++): CMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}")
+  return()
+endif()
+
+project(sycl_samples)
+
+if(SYCL_FLAGS)  # "target_link_libraries(... ${SYCL_TARGET})" is not enough. Hacking...
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SYCL_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SYCL_FLAGS}")
+endif()
+
+ocv_include_modules_recurse(${OPENCV_SYCL_SAMPLES_REQUIRED_DEPS})
+ocv_include_directories(${OpenCL_INCLUDE_DIR})
+file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+foreach(sample_filename ${all_samples})
+  ocv_define_sample(tgt ${sample_filename} sycl)
+  ocv_target_link_libraries(${tgt} PRIVATE
+    ${OPENCV_LINKER_LIBS}
+    ${OPENCV_SYCL_SAMPLES_REQUIRED_DEPS}
+    ${SYCL_TARGET})
+
+  if(COMMAND add_sycl_to_target)  # ComputeCpp
+    add_sycl_to_target(TARGET ${tgt} SOURCES ${sample_filename})
+  endif()
+endforeach()
diff --git a/C++/opencv-4.7.0/samples/sycl/sycl-opencv-interop.cpp b/C++/opencv-4.7.0/samples/sycl/sycl-opencv-interop.cpp
new file mode 100644
index 00000000..ccb8eaf4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/sycl/sycl-opencv-interop.cpp
@@ -0,0 +1,351 @@
+/*
+ * The example of interoperability between SYCL/OpenCL and OpenCV.
+ * - SYCL: https://www.khronos.org/sycl/
+ * - SYCL runtime parameters: https://github.com/intel/llvm/blob/sycl/sycl/doc/EnvironmentVariables.md
+ */
+#include <CL/sycl.hpp>
+
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/imgproc.hpp>
+
+#include <opencv2/core/ocl.hpp>
+
+
+class sycl_inverse_kernel;  // can be omitted - modern SYCL versions doesn't require this
+
+using namespace cv;
+
+
+class App
+{
+public:
+    App(const CommandLineParser& cmd);
+    ~App();
+
+    void initVideoSource();
+
+    void initSYCL();
+
+    void process_frame(cv::Mat& frame);
+
+    /// to check result with CPU-only reference code
+    Mat process_frame_reference(const cv::Mat& frame);
+
+    int run();
+
+    bool isRunning() { return m_running; }
+    bool doProcess() { return m_process; }
+
+    void setRunning(bool running)      { m_running = running; }
+    void setDoProcess(bool process)    { m_process = process; }
+
+protected:
+    void handleKey(char key);
+
+private:
+    bool                        m_running;
+    bool                        m_process;
+    bool                        m_show_ui;
+
+    int64                       m_t0;
+    int64                       m_t1;
+    float                       m_time;
+    float                       m_frequency;
+
+    std::string                 m_file_name;
+    int                         m_camera_id;
+    cv::VideoCapture            m_cap;
+    cv::Mat                     m_frame;
+
+    cl::sycl::queue sycl_queue;
+};
+
+
+App::App(const CommandLineParser& cmd)
+{
+    m_camera_id  = cmd.get<int>("camera");
+    m_file_name  = cmd.get<std::string>("video");
+
+    m_running    = false;
+    m_process    = false;
+} // ctor
+
+
+App::~App()
+{
+    // nothing
+}
+
+
+void App::initSYCL()
+{
+    using namespace cl::sycl;
+
+    // Configuration details: https://github.com/intel/llvm/blob/sycl/sycl/doc/EnvironmentVariables.md
+    cl::sycl::default_selector selector;
+
+    sycl_queue = cl::sycl::queue(selector, [](cl::sycl::exception_list l)
+    {
+        // exception_handler
+        for (auto ep : l)
+        {
+            try
+            {
+                std::rethrow_exception(ep);
+            }
+            catch (const cl::sycl::exception& e)
+            {
+                std::cerr << "SYCL exception: " << e.what() << std::endl;
+            }
+        }
+    });
+
+    auto device = sycl_queue.get_device();
+    auto platform = device.get_platform();
+    std::cout << "SYCL device: " << device.get_info<info::device::name>()
+        << " @ " << device.get_info<info::device::driver_version>()
+        << " (platform: " << platform.get_info<info::platform::name>() << ")" << std::endl;
+
+    if (device.is_host())
+    {
+        std::cerr << "SYCL can't select OpenCL device. Host is used for computations, interoperability is not available" << std::endl;
+    }
+    else
+    {
+        // bind OpenCL context/device/queue from SYCL to OpenCV
+        try
+        {
+            auto ctx = cv::ocl::OpenCLExecutionContext::create(
+                    platform.get_info<info::platform::name>(),
+                    platform.get(),
+                    sycl_queue.get_context().get(),
+                    device.get()
+                );
+            ctx.bind();
+        }
+        catch (const cv::Exception& e)
+        {
+            std::cerr << "OpenCV: Can't bind SYCL OpenCL context/device/queue: " << e.what() << std::endl;
+        }
+        std::cout << "OpenCV uses OpenCL: " << (cv::ocl::useOpenCL() ? "True" : "False") << std::endl;
+    }
+} // initSYCL()
+
+
+void App::initVideoSource()
+{
+    if (!m_file_name.empty() && m_camera_id == -1)
+    {
+        m_cap.open(samples::findFileOrKeep(m_file_name));
+        if (!m_cap.isOpened())
+            throw std::runtime_error(std::string("can't open video stream: ") + m_file_name);
+    }
+    else if (m_camera_id != -1)
+    {
+        m_cap.open(m_camera_id);
+        if (!m_cap.isOpened())
+            throw std::runtime_error(std::string("can't open camera: ") + std::to_string(m_camera_id));
+    }
+    else
+        throw std::runtime_error(std::string("specify video source"));
+} // initVideoSource()
+
+
+void App::process_frame(cv::Mat& frame)
+{
+    using namespace cl::sycl;
+
+    // cv::Mat => cl::sycl::buffer
+    {
+        CV_Assert(frame.isContinuous());
+        CV_CheckTypeEQ(frame.type(), CV_8UC1, "");
+
+        buffer<uint8_t, 2> frame_buffer(frame.data, range<2>(frame.rows, frame.cols));
+
+        // done automatically: frame_buffer.set_write_back(true);
+
+        sycl_queue.submit([&](handler& cgh) {
+          auto pixels = frame_buffer.get_access<access::mode::read_write>(cgh);
+
+          cgh.parallel_for<class sycl_inverse_kernel>(range<2>(frame.rows, frame.cols), [=](item<2> item) {
+              uint8_t v = pixels[item];
+              pixels[item] = ~v;
+          });
+        });
+
+        sycl_queue.wait_and_throw();
+    }
+
+    // No way to extract cl_mem from cl::sycl::buffer (ref: 3.6.11 "Interfacing with OpenCL" of SYCL 1.2.1)
+    // We just reusing OpenCL context/device/queue from SYCL here (see initSYCL() bind part) and call UMat processing
+    {
+        UMat blurResult;
+        {
+            UMat umat_buffer = frame.getUMat(ACCESS_RW);
+            cv::blur(umat_buffer, blurResult, Size(3, 3));  // UMat doesn't support inplace
+        }
+        Mat result;
+        blurResult.copyTo(result);
+        swap(result, frame);
+    }
+}
+
+Mat App::process_frame_reference(const cv::Mat& frame)
+{
+    Mat result;
+    cv::bitwise_not(frame, result);
+    Mat blurResult;
+    cv::blur(result, blurResult, Size(3, 3));  // avoid inplace
+    blurResult.copyTo(result);
+    return result;
+}
+
+int App::run()
+{
+    std::cout << "Initializing..." << std::endl;
+
+    initSYCL();
+    initVideoSource();
+
+    std::cout << "Press ESC to exit" << std::endl;
+    std::cout << "      'p' to toggle ON/OFF processing" << std::endl;
+
+    m_running = true;
+    m_process = true;
+    m_show_ui = true;
+
+    int processedFrames = 0;
+
+    cv::TickMeter timer;
+
+    // Iterate over all frames
+    while (isRunning() && m_cap.read(m_frame))
+    {
+        Mat m_frameGray;
+        cvtColor(m_frame, m_frameGray, COLOR_BGR2GRAY);
+
+        bool checkWithReference = (processedFrames == 0);
+        Mat reference_result;
+        if (checkWithReference)
+        {
+            reference_result = process_frame_reference(m_frameGray);
+        }
+
+        timer.reset();
+        timer.start();
+
+        if (m_process)
+        {
+            process_frame(m_frameGray);
+        }
+
+        timer.stop();
+
+        if (checkWithReference)
+        {
+            double diffInf = cv::norm(reference_result, m_frameGray, NORM_INF);
+            if (diffInf > 0)
+            {
+                std::cerr << "Result is not accurate. diffInf=" << diffInf << std::endl;
+                imwrite("reference.png", reference_result);
+                imwrite("actual.png", m_frameGray);
+            }
+        }
+
+        Mat img_to_show = m_frameGray;
+
+        std::ostringstream msg;
+        msg << "Frame " << processedFrames << " (" << m_frame.size
+            << ")   Time: " << cv::format("%.2f", timer.getTimeMilli()) << " msec"
+            << " (process: " << (m_process ? "True" : "False") << ")";
+        std::cout << msg.str() << std::endl;
+        putText(img_to_show, msg.str(), Point(5, 150), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+
+        if (m_show_ui)
+        {
+            try
+            {
+                imshow("sycl_interop", img_to_show);
+                int key = waitKey(1);
+                switch (key)
+                {
+                case 27:  // ESC
+                    m_running = false;
+                    break;
+
+                case 'p':  // fallthru
+                case 'P':
+                    m_process = !m_process;
+                    break;
+
+                default:
+                    break;
+                }
+            }
+            catch (const std::exception& e)
+            {
+                std::cerr << "ERROR(OpenCV UI): " << e.what() << std::endl;
+                if (processedFrames > 0)
+                    throw;
+                m_show_ui = false;  // UI is not available
+            }
+        }
+
+        processedFrames++;
+
+        if (!m_show_ui)
+        {
+            if (processedFrames > 100)
+                m_running = false;
+        }
+    }
+
+    return 0;
+}
+
+
+int main(int argc, char** argv)
+{
+    const char* keys =
+        "{ help h ?    |          | print help message }"
+        "{ camera c    | -1       | use camera as input }"
+        "{ video  v    |          | use video as input }";
+
+    CommandLineParser cmd(argc, argv, keys);
+    if (cmd.has("help"))
+    {
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+
+    try
+    {
+        App app(cmd);
+        if (!cmd.check())
+        {
+            cmd.printErrors();
+            return 1;
+        }
+        app.run();
+    }
+    catch (const cv::Exception& e)
+    {
+        std::cout << "FATAL: OpenCV error: " << e.what() << std::endl;
+        return 1;
+    }
+    catch (const std::exception& e)
+    {
+        std::cout << "FATAL: C++ error: " << e.what() << std::endl;
+        return 1;
+    }
+
+    catch (...)
+    {
+        std::cout << "FATAL: unknown C++ exception" << std::endl;
+        return 1;
+    }
+
+    return EXIT_SUCCESS;
+} // main()
diff --git a/C++/opencv-4.7.0/samples/tapi/CMakeLists.txt b/C++/opencv-4.7.0/samples/tapi/CMakeLists.txt
new file mode 100644
index 00000000..1f003261
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/CMakeLists.txt
@@ -0,0 +1,26 @@
+ocv_install_example_src(tapi *.cpp *.hpp CMakeLists.txt)
+
+set(OPENCV_TAPI_SAMPLES_REQUIRED_DEPS
+  opencv_core
+  opencv_imgproc
+  opencv_video
+  opencv_imgcodecs
+  opencv_videoio
+  opencv_highgui
+  opencv_objdetect
+  opencv_features2d
+  opencv_calib3d
+  opencv_flann)
+ocv_check_dependencies(${OPENCV_TAPI_SAMPLES_REQUIRED_DEPS})
+
+if(NOT BUILD_EXAMPLES OR NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+project(tapi_samples)
+ocv_include_modules_recurse(${OPENCV_TAPI_SAMPLES_REQUIRED_DEPS})
+file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+foreach(sample_filename ${all_samples})
+  ocv_define_sample(tgt ${sample_filename} tapi)
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_TAPI_SAMPLES_REQUIRED_DEPS})
+endforeach()
diff --git a/C++/opencv-4.7.0/samples/tapi/bgfg_segm.cpp b/C++/opencv-4.7.0/samples/tapi/bgfg_segm.cpp
new file mode 100644
index 00000000..ff097dc2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/bgfg_segm.cpp
@@ -0,0 +1,123 @@
+#include <iostream>
+#include <string>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/video.hpp"
+
+using namespace std;
+using namespace cv;
+
+#define M_MOG2 2
+#define M_KNN  3
+
+int main(int argc, const char** argv)
+{
+    CommandLineParser cmd(argc, argv,
+        "{ c camera   |                    | use camera }"
+        "{ f file     | ../data/vtest.avi  | input video file }"
+        "{ t type     | mog2               | method's type (knn, mog2) }"
+        "{ h help     |                    | print help message }"
+        "{ m cpu_mode | false              | press 'm' to switch OpenCL<->CPU}");
+
+    if (cmd.has("help"))
+    {
+        cout << "Usage : bgfg_segm [options]" << endl;
+        cout << "Available options:" << endl;
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+
+    bool useCamera = cmd.has("camera");
+    string file = cmd.get<string>("file");
+    string method = cmd.get<string>("type");
+
+    if (method != "mog" && method != "mog2")
+    {
+        cerr << "Incorrect method" << endl;
+        return EXIT_FAILURE;
+    }
+
+    int m = method == "mog2" ? M_MOG2 : M_KNN;
+
+    VideoCapture cap;
+    if (useCamera)
+        cap.open(0);
+    else
+        cap.open(file);
+
+    if (!cap.isOpened())
+    {
+        cout << "can not open camera or video file" << endl;
+        return EXIT_FAILURE;
+    }
+
+    UMat frame, fgmask, fgimg;
+    cap >> frame;
+    fgimg.create(frame.size(), frame.type());
+
+    Ptr<BackgroundSubtractorKNN> knn = createBackgroundSubtractorKNN();
+    Ptr<BackgroundSubtractorMOG2> mog2 = createBackgroundSubtractorMOG2();
+
+    switch (m)
+    {
+    case M_KNN:
+        knn->apply(frame, fgmask);
+        break;
+
+    case M_MOG2:
+        mog2->apply(frame, fgmask);
+        break;
+    }
+    bool running=true;
+    for (;;)
+    {
+        if(!running)
+            break;
+        cap >> frame;
+        if (frame.empty())
+            break;
+
+        int64 start = getTickCount();
+
+        //update the model
+        switch (m)
+        {
+        case M_KNN:
+            knn->apply(frame, fgmask);
+            break;
+
+        case M_MOG2:
+            mog2->apply(frame, fgmask);
+            break;
+        }
+
+        double fps = getTickFrequency() / (getTickCount() - start);
+        std::cout << "FPS : " << fps << std::endl;
+        std::cout << fgimg.size() << std::endl;
+        fgimg.setTo(Scalar::all(0));
+        frame.copyTo(fgimg, fgmask);
+
+        imshow("image", frame);
+        imshow("foreground mask", fgmask);
+        imshow("foreground image", fgimg);
+
+        char key = (char)waitKey(30);
+
+        switch (key)
+        {
+        case 27:
+            running = false;
+            break;
+        case 'm':
+        case 'M':
+            ocl::setUseOpenCL(!ocl::useOpenCL());
+            cout << "Switched to " << (ocl::useOpenCL() ? "OpenCL enabled" : "CPU") << " mode\n";
+            break;
+        }
+    }
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/tapi/camshift.cpp b/C++/opencv-4.7.0/samples/tapi/camshift.cpp
new file mode 100644
index 00000000..324e0734
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/camshift.cpp
@@ -0,0 +1,227 @@
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/video/tracking.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+#include <cctype>
+
+static cv::UMat image;
+static bool backprojMode = false;
+static bool selectObject = false;
+static int trackObject = 0;
+static bool showHist = true;
+static cv::Rect selection;
+static int vmin = 10, vmax = 256, smin = 30;
+
+static void onMouse(int event, int x, int y, int, void*)
+{
+    static cv::Point origin;
+
+    if (selectObject)
+    {
+        selection.x = std::min(x, origin.x);
+        selection.y = std::min(y, origin.y);
+        selection.width = std::abs(x - origin.x);
+        selection.height = std::abs(y - origin.y);
+
+        selection &= cv::Rect(0, 0, image.cols, image.rows);
+    }
+
+    switch (event)
+    {
+    case cv::EVENT_LBUTTONDOWN:
+        origin = cv::Point(x, y);
+        selection = cv::Rect(x, y, 0, 0);
+        selectObject = true;
+        break;
+    case cv::EVENT_LBUTTONUP:
+        selectObject = false;
+        if (selection.width > 0 && selection.height > 0)
+            trackObject = -1;
+        break;
+    default:
+        break;
+    }
+}
+
+static void help()
+{
+    std::cout << "\nThis is a demo that shows mean-shift based tracking using Transparent API\n"
+            "You select a color objects such as your face and it tracks it.\n"
+            "This reads from video camera (0 by default, or the camera number the user enters\n"
+            "Usage: \n"
+            "   ./camshiftdemo [camera number]\n";
+
+    std::cout << "\n\nHot keys: \n"
+            "\tESC - quit the program\n"
+            "\ts - stop the tracking\n"
+            "\tb - switch to/from backprojection view\n"
+            "\th - show/hide object histogram\n"
+            "\tp - pause video\n"
+            "\tc - use OpenCL or not\n"
+            "To initialize tracking, select the object with mouse\n";
+}
+
+int main(int argc, const char ** argv)
+{
+    help();
+
+    cv::VideoCapture cap;
+    cv::Rect trackWindow;
+    int hsize = 16;
+    float hranges[2] = { 0, 180 };
+
+    const char * const keys = { "{@camera_number| 0 | camera number}" };
+    cv::CommandLineParser parser(argc, argv, keys);
+    int camNum = parser.get<int>(0);
+
+    cap.open(camNum);
+
+    if (!cap.isOpened())
+    {
+        help();
+
+        std::cout << "***Could not initialize capturing...***\n";
+        std::cout << "Current parameter's value: \n";
+        parser.printMessage();
+
+        return EXIT_FAILURE;
+    }
+
+    cv::namedWindow("Histogram", cv::WINDOW_NORMAL);
+    cv::namedWindow("CamShift Demo", cv::WINDOW_NORMAL);
+    cv::setMouseCallback("CamShift Demo", onMouse);
+    cv::createTrackbar("Vmin", "CamShift Demo", &vmin, 256);
+    cv::createTrackbar("Vmax", "CamShift Demo", &vmax, 256);
+    cv::createTrackbar("Smin", "CamShift Demo", &smin, 256);
+
+    cv::Mat frame, histimg(200, 320, CV_8UC3, cv::Scalar::all(0));
+    cv::UMat hsv, hist, hue, mask, backproj;
+    bool paused = false;
+
+    for ( ; ; )
+    {
+        if (!paused)
+        {
+            cap >> frame;
+            if (frame.empty())
+                break;
+        }
+
+        frame.copyTo(image);
+
+        if (!paused)
+        {
+            cv::cvtColor(image, hsv, cv::COLOR_BGR2HSV);
+
+            if (trackObject)
+            {
+                int _vmin = vmin, _vmax = vmax;
+
+                cv::inRange(hsv, cv::Scalar(0, smin, std::min(_vmin, _vmax)),
+                        cv::Scalar(180, 256, std::max(_vmin, _vmax)), mask);
+
+                int fromTo[2] = { 0,0 };
+                hue.create(hsv.size(), hsv.depth());
+                cv::mixChannels(std::vector<cv::UMat>(1, hsv), std::vector<cv::UMat>(1, hue), fromTo, 1);
+
+                if (trackObject < 0)
+                {
+                    cv::UMat roi(hue, selection), maskroi(mask, selection);
+                    cv::calcHist(std::vector<cv::Mat>(1, roi.getMat(cv::ACCESS_READ)), std::vector<int>(1, 0),
+                                 maskroi, hist, std::vector<int>(1, hsize), std::vector<float>(hranges, hranges + 2));
+                    cv::normalize(hist, hist, 0, 255, cv::NORM_MINMAX);
+
+                    trackWindow = selection;
+                    trackObject = 1;
+
+                    histimg = cv::Scalar::all(0);
+                    int binW = histimg.cols / hsize;
+                    cv::Mat buf (1, hsize, CV_8UC3);
+                    for (int i = 0; i < hsize; i++)
+                        buf.at<cv::Vec3b>(i) = cv::Vec3b(cv::saturate_cast<uchar>(i*180./hsize), 255, 255);
+                    cv::cvtColor(buf, buf, cv::COLOR_HSV2BGR);
+
+                    {
+                        cv::Mat _hist = hist.getMat(cv::ACCESS_READ);
+                        for (int i = 0; i < hsize; i++)
+                        {
+                            int val = cv::saturate_cast<int>(_hist.at<float>(i)*histimg.rows/255);
+                            cv::rectangle(histimg, cv::Point(i*binW, histimg.rows),
+                                       cv::Point((i+1)*binW, histimg.rows - val),
+                                       cv::Scalar(buf.at<cv::Vec3b>(i)), -1, 8);
+                        }
+                    }
+                }
+
+                cv::calcBackProject(std::vector<cv::UMat>(1, hue), std::vector<int>(1, 0), hist, backproj,
+                                    std::vector<float>(hranges, hranges + 2), 1.0);
+                cv::bitwise_and(backproj, mask, backproj);
+
+                cv::RotatedRect trackBox = cv::CamShift(backproj, trackWindow,
+                                    cv::TermCriteria(cv::TermCriteria::EPS | cv::TermCriteria::COUNT, 10, 1));
+                if (trackWindow.area() <= 1)
+                {
+                    int cols = backproj.cols, rows = backproj.rows, r = (std::min(cols, rows) + 5)/6;
+                    trackWindow = cv::Rect(trackWindow.x - r, trackWindow.y - r,
+                                       trackWindow.x + r, trackWindow.y + r) &
+                                  cv::Rect(0, 0, cols, rows);
+                }
+
+                if (backprojMode)
+                    cv::cvtColor(backproj, image, cv::COLOR_GRAY2BGR);
+
+                {
+                    cv::Mat _image = image.getMat(cv::ACCESS_RW);
+                    cv::ellipse(_image, trackBox, cv::Scalar(0, 0, 255), 3, cv::LINE_AA);
+                }
+            }
+        }
+        else if (trackObject < 0)
+            paused = false;
+
+        if (selectObject && selection.width > 0 && selection.height > 0)
+        {
+            cv::UMat roi(image, selection);
+            cv::bitwise_not(roi, roi);
+        }
+
+        cv::imshow("CamShift Demo", image);
+        if (showHist)
+            cv::imshow("Histogram", histimg);
+
+        char c = (char)cv::waitKey(10);
+        if (c == 27)
+            break;
+
+        switch(c)
+        {
+        case 'b':
+            backprojMode = !backprojMode;
+            break;
+        case 't':
+            trackObject = 0;
+            histimg = cv::Scalar::all(0);
+            break;
+        case 'h':
+            showHist = !showHist;
+            if (!showHist)
+                cv::destroyWindow("Histogram");
+            else
+                cv::namedWindow("Histogram", cv::WINDOW_AUTOSIZE);
+            break;
+        case 'p':
+            paused = !paused;
+            break;
+        case 'c':
+            cv::ocl::setUseOpenCL(!cv::ocl::useOpenCL());
+        default:
+            break;
+        }
+    }
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/tapi/clahe.cpp b/C++/opencv-4.7.0/samples/tapi/clahe.cpp
new file mode 100644
index 00000000..ebef65f4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/clahe.cpp
@@ -0,0 +1,113 @@
+#include <iostream>
+#include "opencv2/core.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+using namespace std;
+
+Ptr<CLAHE> pFilter;
+int tilesize;
+int cliplimit;
+
+static void TSize_Callback(int pos, void* /*data*/)
+{
+    if(pos==0)
+        pFilter->setTilesGridSize(Size(1,1));
+    else
+        pFilter->setTilesGridSize(Size(tilesize,tilesize));
+}
+
+static void Clip_Callback(int, void* /*data*/)
+{
+    pFilter->setClipLimit(cliplimit);
+}
+
+int main(int argc, char** argv)
+{
+    const char* keys =
+        "{ i input    |                    | specify input image }"
+        "{ c camera   |  0                 | specify camera id   }"
+        "{ o output   | clahe_output.jpg   | specify output save path}"
+        "{ h help     |                    | print help message }";
+
+    cv::CommandLineParser cmd(argc, argv, keys);
+    if (cmd.has("help"))
+    {
+        cout << "Usage : clahe [options]" << endl;
+        cout << "Available options:" << endl;
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+
+    string infile = cmd.get<string>("i"), outfile = cmd.get<string>("o");
+    int camid = cmd.get<int>("c");
+    VideoCapture capture;
+
+    namedWindow("CLAHE");
+    createTrackbar("Tile Size", "CLAHE", &tilesize, 32, (TrackbarCallback)TSize_Callback);
+    createTrackbar("Clip Limit", "CLAHE", &cliplimit, 20, (TrackbarCallback)Clip_Callback);
+
+    UMat frame, outframe;
+
+    int cur_clip;
+    Size cur_tilesize;
+    pFilter = createCLAHE();
+
+    cur_clip = (int)pFilter->getClipLimit();
+    cur_tilesize = pFilter->getTilesGridSize();
+    setTrackbarPos("Tile Size", "CLAHE", cur_tilesize.width);
+    setTrackbarPos("Clip Limit", "CLAHE", cur_clip);
+
+    if(!infile.empty())
+    {
+        infile = samples::findFile(infile);
+        imread(infile).copyTo(frame);
+        if(frame.empty())
+        {
+            cout << "error read image: " << infile << endl;
+            return EXIT_FAILURE;
+        }
+    }
+    else
+        capture.open(camid);
+
+    cout << "\nControls:\n"
+         << "\to - save output image\n"
+         << "\tm - switch OpenCL <-> CPU mode"
+         << "\tESC - exit\n";
+
+    for (;;)
+    {
+        if(capture.isOpened())
+            capture.read(frame);
+        else
+            imread(infile).copyTo(frame);
+        if(frame.empty())
+        {
+            waitKey();
+            break;
+        }
+
+        cvtColor(frame, frame, COLOR_BGR2GRAY);
+        pFilter->apply(frame, outframe);
+
+        imshow("CLAHE", outframe);
+
+        char key = (char)waitKey(3);
+        if(key == 'o')
+            imwrite(outfile, outframe);
+        else if(key == 27)
+            break;
+        else if(key == 'm')
+        {
+            ocl::setUseOpenCL(!cv::ocl::useOpenCL());
+            cout << "Switched to " << (ocl::useOpenCL() ? "OpenCL enabled" : "CPU") << " mode\n";
+        }
+    }
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/tapi/dense_optical_flow.cpp b/C++/opencv-4.7.0/samples/tapi/dense_optical_flow.cpp
new file mode 100644
index 00000000..f90e63b8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/dense_optical_flow.cpp
@@ -0,0 +1,151 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include <iostream>
+#include <iomanip>
+#include <vector>
+
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/video.hpp"
+
+using namespace std;
+using namespace cv;
+
+static Mat getVisibleFlow(InputArray flow)
+{
+    vector<UMat> flow_vec;
+    split(flow, flow_vec);
+    UMat magnitude, angle;
+    cartToPolar(flow_vec[0], flow_vec[1], magnitude, angle, true);
+    magnitude.convertTo(magnitude, CV_32F, 0.2);
+    vector<UMat> hsv_vec;
+    hsv_vec.push_back(angle);
+    hsv_vec.push_back(UMat::ones(angle.size(), angle.type()));
+    hsv_vec.push_back(magnitude);
+    UMat hsv;
+    merge(hsv_vec, hsv);
+    Mat img;
+    cvtColor(hsv, img, COLOR_HSV2BGR);
+    return img;
+}
+
+static Size fitSize(const Size & sz,  const Size & bounds)
+{
+    CV_Assert(!sz.empty());
+    if (sz.width > bounds.width || sz.height > bounds.height)
+    {
+        double scale = std::min((double)bounds.width / sz.width, (double)bounds.height / sz.height);
+        return Size(cvRound(sz.width * scale), cvRound(sz.height * scale));
+    }
+    return sz;
+}
+
+int main(int argc, const char* argv[])
+{
+    const char* keys =
+            "{ h help     |     | print help message }"
+            "{ c camera   | 0   | capture video from camera (device index starting from 0) }"
+            "{ a algorithm | fb | algorithm (supported: 'fb', 'dis')}"
+            "{ m cpu      |     | run without OpenCL }"
+            "{ v video    |     | use video as input }"
+            "{ o original |     | use original frame size (do not resize to 640x480)}"
+            ;
+    CommandLineParser parser(argc, argv, keys);
+    parser.about("This sample demonstrates using of dense optical flow algorithms.");
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+    int camera = parser.get<int>("camera");
+    string algorithm = parser.get<string>("algorithm");
+    bool useCPU = parser.has("cpu");
+    string filename = parser.get<string>("video");
+    bool useOriginalSize = parser.has("original");
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+
+    VideoCapture cap;
+    if(filename.empty())
+        cap.open(camera);
+    else
+        cap.open(filename);
+    if (!cap.isOpened())
+    {
+        cout << "Can not open video stream: '" << (filename.empty() ? "<camera>" : filename) << "'" << endl;
+        return 2;
+    }
+
+    Ptr<DenseOpticalFlow> alg;
+    if (algorithm == "fb")
+        alg = FarnebackOpticalFlow::create();
+    else if (algorithm == "dis")
+        alg = DISOpticalFlow::create(DISOpticalFlow::PRESET_FAST);
+    else
+    {
+        cout << "Invalid algorithm: " << algorithm << endl;
+        return 3;
+    }
+
+    ocl::setUseOpenCL(!useCPU);
+
+    cout << "Press 'm' to toggle CPU/GPU processing mode" << endl;
+    cout << "Press ESC or 'q' to exit" << endl;
+
+    UMat prevFrame, frame, input_frame, flow;
+    for(;;)
+    {
+        if (!cap.read(input_frame) || input_frame.empty())
+        {
+            cout << "Finished reading: empty frame" << endl;
+            break;
+        }
+        Size small_size = fitSize(input_frame.size(), Size(640, 480));
+        if (!useOriginalSize && small_size != input_frame.size())
+            resize(input_frame, frame, small_size);
+        else
+            frame = input_frame;
+        cvtColor(frame, frame, COLOR_BGR2GRAY);
+        imshow("frame", frame);
+        if (!prevFrame.empty())
+        {
+            int64 t = getTickCount();
+            alg->calc(prevFrame, frame, flow);
+            t = getTickCount() - t;
+            {
+                Mat img = getVisibleFlow(flow);
+                ostringstream buf;
+                buf << "Algo: " << algorithm << " | "
+                    << "Mode: " << (useCPU ? "CPU" : "GPU") << " | "
+                    << "FPS: " << fixed << setprecision(1) << (getTickFrequency() / (double)t);
+                putText(img, buf.str(), Point(10, 30), FONT_HERSHEY_PLAIN, 2.0, Scalar(0, 0, 255), 2, LINE_AA);
+                imshow("Dense optical flow field", img);
+            }
+        }
+        frame.copyTo(prevFrame);
+
+        // interact with user
+        const char key = (char)waitKey(30);
+        if (key == 27 || key == 'q') // ESC
+        {
+            cout << "Exit requested" << endl;
+            break;
+        }
+        else if (key == 'm')
+        {
+            useCPU = !useCPU;
+            ocl::setUseOpenCL(!useCPU);
+            cout << "Set processing mode to: " << (useCPU ? "CPU" : "GPU") << endl;
+        }
+    }
+
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/tapi/hog.cpp b/C++/opencv-4.7.0/samples/tapi/hog.cpp
new file mode 100644
index 00000000..3425fe69
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/hog.cpp
@@ -0,0 +1,352 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+#include <opencv2/core/ocl.hpp>
+#include <opencv2/core/utility.hpp>
+#include "opencv2/imgcodecs.hpp"
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/objdetect.hpp>
+#include <opencv2/imgproc.hpp>
+
+using namespace std;
+using namespace cv;
+
+class App
+{
+public:
+    App(CommandLineParser& cmd);
+    void run();
+    void handleKey(char key);
+    void hogWorkBegin();
+    void hogWorkEnd();
+    string hogWorkFps() const;
+    void workBegin();
+    void workEnd();
+    string workFps() const;
+private:
+    App operator=(App&);
+
+    //Args args;
+    bool running;
+    bool make_gray;
+    double scale;
+    double resize_scale;
+    int win_width;
+    int win_stride_width, win_stride_height;
+    int gr_threshold;
+    int nlevels;
+    double hit_threshold;
+    bool gamma_corr;
+
+    int64 hog_work_begin;
+    double hog_work_fps;
+    int64 work_begin;
+    double work_fps;
+
+    string img_source;
+    string vdo_source;
+    string output;
+    int camera_id;
+    bool write_once;
+};
+
+int main(int argc, char** argv)
+{
+    const char* keys =
+        "{ h help      |                | print help message }"
+        "{ i input     |                | specify input image}"
+        "{ c camera    | -1             | enable camera capturing }"
+        "{ v video     | vtest.avi | use video as input }"
+        "{ g gray      |                | convert image to gray one or not}"
+        "{ s scale     | 1.0            | resize the image before detect}"
+        "{ o output    |   output.avi   | specify output path when input is images}";
+    CommandLineParser cmd(argc, argv, keys);
+    if (cmd.has("help"))
+    {
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+
+    App app(cmd);
+    try
+    {
+        app.run();
+    }
+    catch (const Exception& e)
+    {
+        return cout << "error: "  << e.what() << endl, 1;
+    }
+    catch (const exception& e)
+    {
+        return cout << "error: "  << e.what() << endl, 1;
+    }
+    catch(...)
+    {
+        return cout << "unknown exception" << endl, 1;
+    }
+    return EXIT_SUCCESS;
+}
+
+App::App(CommandLineParser& cmd)
+{
+    cout << "\nControls:\n"
+         << "\tESC - exit\n"
+         << "\tm - change mode GPU <-> CPU\n"
+         << "\tg - convert image to gray or not\n"
+         << "\to - save output image once, or switch on/off video save\n"
+         << "\t1/q - increase/decrease HOG scale\n"
+         << "\t2/w - increase/decrease levels count\n"
+         << "\t3/e - increase/decrease HOG group threshold\n"
+         << "\t4/r - increase/decrease hit threshold\n"
+         << endl;
+
+    make_gray = cmd.has("gray");
+    resize_scale = cmd.get<double>("s");
+    vdo_source = samples::findFileOrKeep(cmd.get<string>("v"));
+    img_source = cmd.get<string>("i");
+    output = cmd.get<string>("o");
+    camera_id = cmd.get<int>("c");
+
+    win_width = 48;
+    win_stride_width = 8;
+    win_stride_height = 8;
+    gr_threshold = 8;
+    nlevels = 13;
+    hit_threshold = 1.4;
+    scale = 1.05;
+    gamma_corr = true;
+    write_once = false;
+
+    cout << "Group threshold: " << gr_threshold << endl;
+    cout << "Levels number: " << nlevels << endl;
+    cout << "Win width: " << win_width << endl;
+    cout << "Win stride: (" << win_stride_width << ", " << win_stride_height << ")\n";
+    cout << "Hit threshold: " << hit_threshold << endl;
+    cout << "Gamma correction: " << gamma_corr << endl;
+    cout << endl;
+}
+
+void App::run()
+{
+    running = true;
+    VideoWriter video_writer;
+
+    Size win_size(win_width, win_width * 2);
+    Size win_stride(win_stride_width, win_stride_height);
+
+    // Create HOG descriptors and detectors here
+
+    HOGDescriptor hog(win_size, Size(16, 16), Size(8, 8), Size(8, 8), 9, 1, -1,
+                          HOGDescriptor::L2Hys, 0.2, gamma_corr, cv::HOGDescriptor::DEFAULT_NLEVELS);
+    hog.setSVMDetector( HOGDescriptor::getDaimlerPeopleDetector() );
+
+    while (running)
+    {
+        VideoCapture vc;
+        UMat frame;
+
+        if (vdo_source!="")
+        {
+            vc.open(vdo_source.c_str());
+            if (!vc.isOpened())
+                throw runtime_error(string("can't open video file: " + vdo_source));
+            vc >> frame;
+        }
+        else if (camera_id != -1)
+        {
+            vc.open(camera_id);
+            if (!vc.isOpened())
+            {
+                stringstream msg;
+                msg << "can't open camera: " << camera_id;
+                throw runtime_error(msg.str());
+            }
+            vc >> frame;
+        }
+        else
+        {
+            imread(img_source).copyTo(frame);
+            if (frame.empty())
+                throw runtime_error(string("can't open image file: " + img_source));
+        }
+
+        UMat img_aux, img, img_to_show;
+
+        // Iterate over all frames
+        while (running && !frame.empty())
+        {
+            workBegin();
+
+            // Change format of the image
+            if (make_gray) cvtColor(frame, img_aux, COLOR_BGR2GRAY );
+            else frame.copyTo(img_aux);
+
+            // Resize image
+            if (abs(scale-1.0)>0.001)
+            {
+                Size sz((int)((double)img_aux.cols/resize_scale), (int)((double)img_aux.rows/resize_scale));
+                resize(img_aux, img, sz, 0, 0, INTER_LINEAR_EXACT);
+            }
+            else img = img_aux;
+            img.copyTo(img_to_show);
+            hog.nlevels = nlevels;
+            vector<Rect> found;
+
+            // Perform HOG classification
+            hogWorkBegin();
+
+            hog.detectMultiScale(img, found, hit_threshold, win_stride,
+                    Size(0, 0), scale, gr_threshold);
+            hogWorkEnd();
+
+
+            // Draw positive classified windows
+            for (size_t i = 0; i < found.size(); i++)
+            {
+                rectangle(img_to_show, found[i], Scalar(0, 255, 0), 3);
+            }
+
+            putText(img_to_show, ocl::useOpenCL() ? "Mode: OpenCL"  : "Mode: CPU", Point(5, 25), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+            putText(img_to_show, "FPS (HOG only): " + hogWorkFps(), Point(5, 65), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+            putText(img_to_show, "FPS (total): " + workFps(), Point(5, 105), FONT_HERSHEY_SIMPLEX, 1., Scalar(255, 100, 0), 2);
+            imshow("opencv_hog", img_to_show);
+            if (vdo_source!="" || camera_id!=-1) vc >> frame;
+
+            workEnd();
+
+            if (output!="" && write_once)
+            {
+                if (img_source!="")     // write image
+                {
+                    write_once = false;
+                    imwrite(output, img_to_show);
+                }
+                else                    //write video
+                {
+                    if (!video_writer.isOpened())
+                    {
+                        video_writer.open(output, VideoWriter::fourcc('x','v','i','d'), 24,
+                                          img_to_show.size(), true);
+                        if (!video_writer.isOpened())
+                            throw std::runtime_error("can't create video writer");
+                    }
+
+                    if (make_gray) cvtColor(img_to_show, img, COLOR_GRAY2BGR);
+                    else cvtColor(img_to_show, img, COLOR_BGRA2BGR);
+
+                    video_writer << img;
+                }
+            }
+
+            handleKey((char)waitKey(3));
+        }
+    }
+}
+
+void App::handleKey(char key)
+{
+    switch (key)
+    {
+    case 27:
+        running = false;
+        break;
+    case 'm':
+    case 'M':
+        ocl::setUseOpenCL(!cv::ocl::useOpenCL());
+        cout << "Switched to " << (ocl::useOpenCL() ? "OpenCL enabled" : "CPU") << " mode\n";
+        break;
+    case 'g':
+    case 'G':
+        make_gray = !make_gray;
+        cout << "Convert image to gray: " << (make_gray ? "YES" : "NO") << endl;
+        break;
+    case '1':
+        scale *= 1.05;
+        cout << "Scale: " << scale << endl;
+        break;
+    case 'q':
+    case 'Q':
+        scale /= 1.05;
+        cout << "Scale: " << scale << endl;
+        break;
+    case '2':
+        nlevels++;
+        cout << "Levels number: " << nlevels << endl;
+        break;
+    case 'w':
+    case 'W':
+        nlevels = max(nlevels - 1, 1);
+        cout << "Levels number: " << nlevels << endl;
+        break;
+    case '3':
+        gr_threshold++;
+        cout << "Group threshold: " << gr_threshold << endl;
+        break;
+    case 'e':
+    case 'E':
+        gr_threshold = max(0, gr_threshold - 1);
+        cout << "Group threshold: " << gr_threshold << endl;
+        break;
+    case '4':
+        hit_threshold+=0.25;
+        cout << "Hit threshold: " << hit_threshold << endl;
+        break;
+    case 'r':
+    case 'R':
+        hit_threshold = max(0.0, hit_threshold - 0.25);
+        cout << "Hit threshold: " << hit_threshold << endl;
+        break;
+    case 'c':
+    case 'C':
+        gamma_corr = !gamma_corr;
+        cout << "Gamma correction: " << gamma_corr << endl;
+        break;
+    case 'o':
+    case 'O':
+        write_once = !write_once;
+        break;
+    }
+}
+
+
+inline void App::hogWorkBegin()
+{
+    hog_work_begin = getTickCount();
+}
+
+inline void App::hogWorkEnd()
+{
+    int64 delta = getTickCount() - hog_work_begin;
+    double freq = getTickFrequency();
+    hog_work_fps = freq / delta;
+}
+
+inline string App::hogWorkFps() const
+{
+    stringstream ss;
+    ss << hog_work_fps;
+    return ss.str();
+}
+
+inline void App::workBegin()
+{
+    work_begin = getTickCount();
+}
+
+inline void App::workEnd()
+{
+    int64 delta = getTickCount() - work_begin;
+    double freq = getTickFrequency();
+    work_fps = freq / delta;
+}
+
+inline string App::workFps() const
+{
+    stringstream ss;
+    ss << work_fps;
+    return ss.str();
+}
diff --git a/C++/opencv-4.7.0/samples/tapi/opencl_custom_kernel.cpp b/C++/opencv-4.7.0/samples/tapi/opencl_custom_kernel.cpp
new file mode 100644
index 00000000..c4e893a8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/opencl_custom_kernel.cpp
@@ -0,0 +1,164 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static const char* opencl_kernel_src =
+"__kernel void magnutude_filter_8u(\n"
+"       __global const uchar* src, int src_step, int src_offset,\n"
+"       __global uchar* dst, int dst_step, int dst_offset, int dst_rows, int dst_cols,\n"
+"       float scale)\n"
+"{\n"
+"   int x = get_global_id(0);\n"
+"   int y = get_global_id(1);\n"
+"   if (x < dst_cols && y < dst_rows)\n"
+"   {\n"
+"       int dst_idx = y * dst_step + x + dst_offset;\n"
+"       if (x > 0 && x < dst_cols - 1 && y > 0 && y < dst_rows - 2)\n"
+"       {\n"
+"           int src_idx = y * src_step + x + src_offset;\n"
+"           int dx = (int)src[src_idx]*2 - src[src_idx - 1]          - src[src_idx + 1];\n"
+"           int dy = (int)src[src_idx]*2 - src[src_idx - 1*src_step] - src[src_idx + 1*src_step];\n"
+"           dst[dst_idx] = convert_uchar_sat(sqrt((float)(dx*dx + dy*dy)) * scale);\n"
+"       }\n"
+"       else\n"
+"       {\n"
+"           dst[dst_idx] = 0;\n"
+"       }\n"
+"   }\n"
+"}\n";
+
+int main(int argc, char** argv)
+{
+    const char* keys =
+        "{ i input    | | specify input image }"
+        "{ h help     | | print help message }";
+
+    cv::CommandLineParser args(argc, argv, keys);
+    if (args.has("help"))
+    {
+        cout << "Usage : " << argv[0] << " [options]" << endl;
+        cout << "Available options:" << endl;
+        args.printMessage();
+        return EXIT_SUCCESS;
+    }
+
+    cv::ocl::Context ctx = cv::ocl::Context::getDefault();
+    if (!ctx.ptr())
+    {
+        cerr << "OpenCL is not available" << endl;
+        return 1;
+    }
+    cv::ocl::Device device = cv::ocl::Device::getDefault();
+    if (!device.compilerAvailable())
+    {
+        cerr << "OpenCL compiler is not available" << endl;
+        return 1;
+    }
+
+
+    UMat src;
+    {
+        string image_file = args.get<string>("i");
+        if (!image_file.empty())
+        {
+            Mat image = imread(samples::findFile(image_file));
+            if (image.empty())
+            {
+                cout << "error read image: " << image_file << endl;
+                return 1;
+            }
+            cvtColor(image, src, COLOR_BGR2GRAY);
+        }
+        else
+        {
+            Mat frame(cv::Size(640, 480), CV_8U, Scalar::all(128));
+            Point p(frame.cols / 2, frame.rows / 2);
+            line(frame, Point(0, frame.rows / 2), Point(frame.cols, frame.rows / 2), 1);
+            circle(frame, p, 200, Scalar(32, 32, 32), 8, LINE_AA);
+            string str = "OpenCL";
+            int baseLine = 0;
+            Size box = getTextSize(str, FONT_HERSHEY_COMPLEX, 2, 5, &baseLine);
+            putText(frame, str, Point((frame.cols - box.width) / 2, (frame.rows - box.height) / 2 + baseLine),
+                    FONT_HERSHEY_COMPLEX, 2, Scalar(255, 255, 255), 5, LINE_AA);
+            frame.copyTo(src);
+        }
+    }
+
+
+    cv::String module_name; // empty to disable OpenCL cache
+
+    {
+        cout << "OpenCL program source: " << endl;
+        cout << "======================================================================================================" << endl;
+        cout << opencl_kernel_src << endl;
+        cout << "======================================================================================================" << endl;
+        //! [Define OpenCL program source]
+        cv::ocl::ProgramSource source(module_name, "simple", opencl_kernel_src, "");
+        //! [Define OpenCL program source]
+
+        //! [Compile/build OpenCL for current OpenCL device]
+        cv::String errmsg;
+        cv::ocl::Program program(source, "", errmsg);
+        if (program.ptr() == NULL)
+        {
+            cerr << "Can't compile OpenCL program:" << endl << errmsg << endl;
+            return 1;
+        }
+        //! [Compile/build OpenCL for current OpenCL device]
+
+        if (!errmsg.empty())
+        {
+            cout << "OpenCL program build log:" << endl << errmsg << endl;
+        }
+
+        //! [Get OpenCL kernel by name]
+        cv::ocl::Kernel k("magnutude_filter_8u", program);
+        if (k.empty())
+        {
+            cerr << "Can't get OpenCL kernel" << endl;
+            return 1;
+        }
+        //! [Get OpenCL kernel by name]
+
+        UMat result(src.size(), CV_8UC1);
+
+        //! [Define kernel parameters and run]
+        size_t globalSize[2] = {(size_t)src.cols, (size_t)src.rows};
+        size_t localSize[2] = {8, 8};
+        bool executionResult = k
+            .args(
+                cv::ocl::KernelArg::ReadOnlyNoSize(src), // size is not used (similar to 'dst' size)
+                cv::ocl::KernelArg::WriteOnly(result),
+                (float)2.0
+            )
+            .run(2, globalSize, localSize, true);
+        if (!executionResult)
+        {
+            cerr << "OpenCL kernel launch failed" << endl;
+            return 1;
+        }
+        //! [Define kernel parameters and run]
+
+        imshow("Source", src);
+        imshow("Result", result);
+
+        for (;;)
+        {
+            int key = waitKey();
+            if (key == 27/*ESC*/ || key == 'q' || key == 'Q')
+                break;
+        }
+    }
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/tapi/pyrlk_optical_flow.cpp b/C++/opencv-4.7.0/samples/tapi/pyrlk_optical_flow.cpp
new file mode 100644
index 00000000..9c1364d1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/pyrlk_optical_flow.cpp
@@ -0,0 +1,232 @@
+#include <iostream>
+#include <vector>
+#include <iomanip>
+
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/video/video.hpp"
+
+using namespace std;
+using namespace cv;
+
+typedef unsigned char uchar;
+#define LOOP_NUM 10
+int64 work_begin = 0;
+int64 work_end = 0;
+
+static void workBegin()
+{
+    work_begin = getTickCount();
+}
+static void workEnd()
+{
+    work_end += (getTickCount() - work_begin);
+}
+static double getTime()
+{
+    return work_end * 1000. / getTickFrequency();
+}
+
+static void drawArrows(UMat& _frame, const vector<Point2f>& prevPts, const vector<Point2f>& nextPts, const vector<uchar>& status,
+                       Scalar line_color = Scalar(0, 0, 255))
+{
+    Mat frame = _frame.getMat(ACCESS_WRITE);
+    for (size_t i = 0; i < prevPts.size(); ++i)
+    {
+        if (status[i])
+        {
+            int line_thickness = 1;
+
+            Point p = prevPts[i];
+            Point q = nextPts[i];
+
+            double angle = atan2((double) p.y - q.y, (double) p.x - q.x);
+
+            double hypotenuse = sqrt( (double)(p.y - q.y)*(p.y - q.y) + (double)(p.x - q.x)*(p.x - q.x) );
+
+            if (hypotenuse < 1.0)
+                continue;
+
+            // Here we lengthen the arrow by a factor of three.
+            q.x = (int) (p.x - 3 * hypotenuse * cos(angle));
+            q.y = (int) (p.y - 3 * hypotenuse * sin(angle));
+
+            // Now we draw the main line of the arrow.
+            line(frame, p, q, line_color, line_thickness);
+
+            // Now draw the tips of the arrow. I do some scaling so that the
+            // tips look proportional to the main line of the arrow.
+
+            p.x = (int) (q.x + 9 * cos(angle + CV_PI / 4));
+            p.y = (int) (q.y + 9 * sin(angle + CV_PI / 4));
+            line(frame, p, q, line_color, line_thickness);
+
+            p.x = (int) (q.x + 9 * cos(angle - CV_PI / 4));
+            p.y = (int) (q.y + 9 * sin(angle - CV_PI / 4));
+            line(frame, p, q, line_color, line_thickness);
+        }
+    }
+}
+
+
+int main(int argc, const char* argv[])
+{
+    const char* keys =
+        "{ h help           |                 | print help message }"
+        "{ l left           |                 | specify left image }"
+        "{ r right          |                 | specify right image }"
+        "{ c camera         | 0               | enable camera capturing }"
+        "{ v video          |                 | use video as input }"
+        "{ o output         | pyrlk_output.jpg| specify output save path when input is images }"
+        "{ points           | 1000            | specify points count [GoodFeatureToTrack] }"
+        "{ min_dist         | 0               | specify minimal distance between points [GoodFeatureToTrack] }"
+        "{ m cpu_mode       | false           | run without OpenCL }";
+
+    CommandLineParser cmd(argc, argv, keys);
+
+    if (cmd.has("help"))
+    {
+        cout << "Usage: pyrlk_optical_flow [options]" << endl;
+        cout << "Available options:" << endl;
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+
+    bool defaultPicturesFail = true;
+    string fname0 = samples::findFile(cmd.get<string>("left"));
+    string fname1 = samples::findFile(cmd.get<string>("right"));
+    string vdofile = cmd.get<string>("video");
+    string outfile = cmd.get<string>("output");
+    int points = cmd.get<int>("points");
+    double minDist = cmd.get<double>("min_dist");
+    int inputName = cmd.get<int>("c");
+
+    UMat frame0;
+    imread(fname0, IMREAD_GRAYSCALE).copyTo(frame0);
+    UMat frame1;
+    imread(fname1, IMREAD_GRAYSCALE).copyTo(frame1);
+
+    vector<cv::Point2f> pts(points);
+    vector<cv::Point2f> nextPts(points);
+    vector<unsigned char> status(points);
+    vector<float> err;
+
+    cout << "Points count : " << points << endl << endl;
+
+    if (frame0.empty() || frame1.empty())
+    {
+        VideoCapture capture;
+        UMat frame, frameCopy;
+        UMat frame0Gray, frame1Gray;
+        UMat ptr0, ptr1;
+
+        if(vdofile.empty())
+            capture.open( inputName );
+        else
+            capture.open(vdofile.c_str());
+
+        int c = inputName ;
+        if(!capture.isOpened())
+        {
+            if(vdofile.empty())
+                cout << "Capture from CAM " << c << " didn't work" << endl;
+            else
+                cout << "Capture from file " << vdofile << " failed" <<endl;
+            if (defaultPicturesFail)
+                return EXIT_FAILURE;
+            goto nocamera;
+        }
+
+        cout << "In capture ..." << endl;
+        for(int i = 0;; i++)
+        {
+            if( !capture.read(frame) )
+                break;
+
+            if (i == 0)
+            {
+                frame.copyTo( frame0 );
+                cvtColor(frame0, frame0Gray, COLOR_BGR2GRAY);
+            }
+            else
+            {
+                if (i%2 == 1)
+                {
+                    frame.copyTo(frame1);
+                    cvtColor(frame1, frame1Gray, COLOR_BGR2GRAY);
+                    ptr0 = frame0Gray;
+                    ptr1 = frame1Gray;
+                }
+                else
+                {
+                    frame.copyTo(frame0);
+                    cvtColor(frame0, frame0Gray, COLOR_BGR2GRAY);
+                    ptr0 = frame1Gray;
+                    ptr1 = frame0Gray;
+                }
+
+
+                pts.clear();
+                goodFeaturesToTrack(ptr0, pts, points, 0.01, 0.0);
+                if(pts.size() == 0)
+                    continue;
+                calcOpticalFlowPyrLK(ptr0, ptr1, pts, nextPts, status, err);
+
+                if (i%2 == 1)
+                    frame1.copyTo(frameCopy);
+                else
+                    frame0.copyTo(frameCopy);
+                drawArrows(frameCopy, pts, nextPts, status, Scalar(255, 0, 0));
+                imshow("PyrLK [Sparse]", frameCopy);
+            }
+            char key = (char)waitKey(10);
+
+            if (key == 27)
+                break;
+            else if (key == 'm' || key == 'M')
+            {
+                ocl::setUseOpenCL(!cv::ocl::useOpenCL());
+                cout << "Switched to " << (ocl::useOpenCL() ? "OpenCL" : "CPU") << " mode\n";
+            }
+        }
+        capture.release();
+    }
+    else
+    {
+nocamera:
+        if (cmd.has("cpu_mode"))
+        {
+            ocl::setUseOpenCL(false);
+            std::cout << "OpenCL was disabled" << std::endl;
+        }
+        for(int i = 0; i <= LOOP_NUM; i ++)
+        {
+            cout << "loop" << i << endl;
+            if (i > 0) workBegin();
+
+            goodFeaturesToTrack(frame0, pts, points, 0.01, minDist);
+            calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err);
+
+            if (i > 0 && i <= LOOP_NUM)
+                workEnd();
+
+            if (i == LOOP_NUM)
+            {
+                cout << "average time (noCamera) : ";
+
+                cout << getTime() / LOOP_NUM << " ms" << endl;
+
+                drawArrows(frame0, pts, nextPts, status, Scalar(255, 0, 0));
+                imshow("PyrLK [Sparse]", frame0);
+                imwrite(outfile, frame0);
+            }
+        }
+    }
+
+    waitKey();
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/tapi/squares.cpp b/C++/opencv-4.7.0/samples/tapi/squares.cpp
new file mode 100644
index 00000000..4cdce225
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/squares.cpp
@@ -0,0 +1,200 @@
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+int thresh = 50, N = 11;
+const char* wndname = "Square Detection Demo";
+
+// helper function:
+// finds a cosine of angle between vectors
+// from pt0->pt1 and from pt0->pt2
+static double angle( Point pt1, Point pt2, Point pt0 )
+{
+    double dx1 = pt1.x - pt0.x;
+    double dy1 = pt1.y - pt0.y;
+    double dx2 = pt2.x - pt0.x;
+    double dy2 = pt2.y - pt0.y;
+    return (dx1*dx2 + dy1*dy2)/sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);
+}
+
+
+// returns sequence of squares detected on the image.
+static void findSquares( const UMat& image, vector<vector<Point> >& squares )
+{
+    squares.clear();
+    UMat pyr, timg, gray0(image.size(), CV_8U), gray;
+
+    // down-scale and upscale the image to filter out the noise
+    pyrDown(image, pyr, Size(image.cols/2, image.rows/2));
+    pyrUp(pyr, timg, image.size());
+    vector<vector<Point> > contours;
+
+    // find squares in every color plane of the image
+    for( int c = 0; c < 3; c++ )
+    {
+        int ch[] = {c, 0};
+        mixChannels(timg, gray0, ch, 1);
+
+        // try several threshold levels
+        for( int l = 0; l < N; l++ )
+        {
+            // hack: use Canny instead of zero threshold level.
+            // Canny helps to catch squares with gradient shading
+            if( l == 0 )
+            {
+                // apply Canny. Take the upper threshold from slider
+                // and set the lower to 0 (which forces edges merging)
+                Canny(gray0, gray, 0, thresh, 5);
+                // dilate canny output to remove potential
+                // holes between edge segments
+                dilate(gray, gray, UMat(), Point(-1,-1));
+            }
+            else
+            {
+                // apply threshold if l!=0:
+                //     tgray(x,y) = gray(x,y) < (l+1)*255/N ? 255 : 0
+                threshold(gray0, gray, (l+1)*255/N, 255, THRESH_BINARY);
+            }
+
+            // find contours and store them all as a list
+            findContours(gray, contours, RETR_LIST, CHAIN_APPROX_SIMPLE);
+
+            vector<Point> approx;
+
+            // test each contour
+            for( size_t i = 0; i < contours.size(); i++ )
+            {
+                // approximate contour with accuracy proportional
+                // to the contour perimeter
+
+                approxPolyDP(contours[i], approx, arcLength(contours[i], true)*0.02, true);
+
+                // square contours should have 4 vertices after approximation
+                // relatively large area (to filter out noisy contours)
+                // and be convex.
+                // Note: absolute value of an area is used because
+                // area may be positive or negative - in accordance with the
+                // contour orientation
+                if( approx.size() == 4 &&
+                        fabs(contourArea(approx)) > 1000 &&
+                        isContourConvex(approx) )
+                {
+                    double maxCosine = 0;
+
+                    for( int j = 2; j < 5; j++ )
+                    {
+                        // find the maximum cosine of the angle between joint edges
+                        double cosine = fabs(angle(approx[j%4], approx[j-2], approx[j-1]));
+                        maxCosine = MAX(maxCosine, cosine);
+                    }
+
+                    // if cosines of all angles are small
+                    // (all angles are ~90 degree) then write quandrange
+                    // vertices to resultant sequence
+                    if( maxCosine < 0.3 )
+                        squares.push_back(approx);
+                }
+            }
+        }
+    }
+}
+
+// the function draws all the squares in the image
+static void drawSquares( UMat& _image, const vector<vector<Point> >& squares )
+{
+    Mat image = _image.getMat(ACCESS_WRITE);
+    for( size_t i = 0; i < squares.size(); i++ )
+    {
+        const Point* p = &squares[i][0];
+        int n = (int)squares[i].size();
+        polylines(image, &p, &n, 1, true, Scalar(0,255,0), 3, LINE_AA);
+    }
+}
+
+
+// draw both pure-C++ and ocl square results onto a single image
+static UMat drawSquaresBoth( const UMat& image,
+                            const vector<vector<Point> >& sqs)
+{
+    UMat imgToShow(Size(image.cols, image.rows), image.type());
+    image.copyTo(imgToShow);
+
+    drawSquares(imgToShow, sqs);
+
+    return imgToShow;
+}
+
+
+int main(int argc, char** argv)
+{
+    const char* keys =
+        "{ i input    | ../data/pic1.png   | specify input image }"
+        "{ o output   | squares_output.jpg | specify output save path}"
+        "{ h help     |                    | print help message }"
+        "{ m cpu_mode |                    | run without OpenCL }";
+
+    CommandLineParser cmd(argc, argv, keys);
+
+    if(cmd.has("help"))
+    {
+        cout << "Usage : " << argv[0] << " [options]" << endl;
+        cout << "Available options:" << endl;
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+    if (cmd.has("cpu_mode"))
+    {
+        ocl::setUseOpenCL(false);
+        cout << "OpenCL was disabled" << endl;
+    }
+
+    string inputName = samples::findFile(cmd.get<string>("i"));
+    string outfile = cmd.get<string>("o");
+
+    int iterations = 10;
+    namedWindow( wndname, WINDOW_AUTOSIZE );
+    vector<vector<Point> > squares;
+
+    UMat image;
+    imread(inputName, IMREAD_COLOR).copyTo(image);
+    if( image.empty() )
+    {
+        cout << "Couldn't load " << inputName << endl;
+        cmd.printMessage();
+        return EXIT_FAILURE;
+    }
+
+    int j = iterations;
+    int64 t_cpp = 0;
+    //warm-ups
+    cout << "warming up ..." << endl;
+    findSquares(image, squares);
+
+    do
+    {
+        int64 t_start = getTickCount();
+        findSquares(image, squares);
+        t_cpp += cv::getTickCount() - t_start;
+
+        t_start  = getTickCount();
+
+        cout << "run loop: " << j << endl;
+    }
+    while(--j);
+    cout << "average time: " << 1000.0f * (double)t_cpp / getTickFrequency() / iterations << "ms" << endl;
+
+    UMat result = drawSquaresBoth(image, squares);
+    imshow(wndname, result);
+    imwrite(outfile, result);
+    waitKey(0);
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/tapi/ufacedetect.cpp b/C++/opencv-4.7.0/samples/tapi/ufacedetect.cpp
new file mode 100644
index 00000000..23445cc2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/ufacedetect.cpp
@@ -0,0 +1,253 @@
+#include "opencv2/objdetect.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/core/ocl.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+static void help()
+{
+    cout << "\nThis program demonstrates the cascade recognizer. Now you can use Haar or LBP features.\n"
+            "This classifier can recognize many kinds of rigid objects, once the appropriate classifier is trained.\n"
+            "It's most known use is for faces.\n"
+            "Usage:\n"
+            "./ufacedetect [--cascade=<cascade_path> this is the primary trained classifier such as frontal face]\n"
+               "   [--nested-cascade[=nested_cascade_path this an optional secondary classifier such as eyes]]\n"
+               "   [--scale=<image scale greater or equal to 1, try 1.3 for example>]\n"
+               "   [--try-flip]\n"
+               "   [filename|camera_index]\n\n"
+            "see facedetect.cmd for one call:\n"
+            "./ufacedetect --cascade=\"../../data/haarcascades/haarcascade_frontalface_alt.xml\" --nested-cascade=\"../../data/haarcascades/haarcascade_eye_tree_eyeglasses.xml\" --scale=1.3\n\n"
+            "During execution:\n\tHit any key to quit.\n"
+            "\tUsing OpenCV version " << CV_VERSION << "\n" << endl;
+}
+
+void detectAndDraw( UMat& img, Mat& canvas, CascadeClassifier& cascade,
+                    CascadeClassifier& nestedCascade,
+                    double scale, bool tryflip );
+
+int main( int argc, const char** argv )
+{
+    VideoCapture capture;
+    UMat frame, image;
+    Mat canvas;
+
+    string inputName;
+    bool tryflip;
+
+    CascadeClassifier cascade, nestedCascade;
+    double scale;
+
+    cv::CommandLineParser parser(argc, argv,
+        "{cascade|data/haarcascades/haarcascade_frontalface_alt.xml|}"
+        "{nested-cascade|data/haarcascades/haarcascade_eye_tree_eyeglasses.xml|}"
+        "{help h ||}{scale|1|}{try-flip||}{@filename||}"
+    );
+    if (parser.has("help"))
+    {
+        help();
+        return 0;
+    }
+    string cascadeName = samples::findFile(parser.get<string>("cascade"));
+    string nestedCascadeName = samples::findFileOrKeep(parser.get<string>("nested-cascade"));
+    scale = parser.get<double>("scale");
+    tryflip = parser.has("try-flip");
+    inputName = parser.get<string>("@filename");
+    if ( !parser.check())
+    {
+        parser.printErrors();
+        help();
+        return -1;
+    }
+
+    if ( !nestedCascade.load( nestedCascadeName ) )
+        cerr << "WARNING: Could not load classifier cascade for nested objects: " << nestedCascadeName << endl;
+    if( !cascade.load( cascadeName ) )
+    {
+        cerr << "ERROR: Could not load classifier cascade: " << cascadeName << endl;
+        help();
+        return -1;
+    }
+
+    cout << "old cascade: " << (cascade.isOldFormatCascade() ? "TRUE" : "FALSE") << endl;
+
+    if( inputName.empty() || (isdigit(inputName[0]) && inputName.size() == 1) )
+    {
+        int camera = inputName.empty() ? 0 : inputName[0] - '0';
+        if(!capture.open(camera))
+            cout << "Capture from camera #" <<  camera << " didn't work" << endl;
+    }
+    else
+    {
+        inputName = samples::findFileOrKeep(inputName);
+        imread(inputName, IMREAD_COLOR).copyTo(image);
+        if( image.empty() )
+        {
+            if(!capture.open( inputName ))
+                cout << "Could not read " << inputName << endl;
+        }
+    }
+
+    if( capture.isOpened() )
+    {
+        cout << "Video capturing has been started ..." << endl;
+        for(;;)
+        {
+            capture >> frame;
+            if( frame.empty() )
+                break;
+
+            detectAndDraw( frame, canvas, cascade, nestedCascade, scale, tryflip );
+
+            char c = (char)waitKey(10);
+            if( c == 27 || c == 'q' || c == 'Q' )
+                break;
+        }
+    }
+    else
+    {
+        cout << "Detecting face(s) in " << inputName << endl;
+        if( !image.empty() )
+        {
+            detectAndDraw( image, canvas, cascade, nestedCascade, scale, tryflip );
+            waitKey(0);
+        }
+        else if( !inputName.empty() )
+        {
+            /* assume it is a text file containing the
+            list of the image filenames to be processed - one per line */
+            FILE* f = fopen( inputName.c_str(), "rt" );
+            if( f )
+            {
+                char buf[1000+1];
+                while( fgets( buf, 1000, f ) )
+                {
+                    int len = (int)strlen(buf);
+                    while( len > 0 && isspace(buf[len-1]) )
+                        len--;
+                    buf[len] = '\0';
+                    cout << "file " << buf << endl;
+                    imread(samples::findFile(buf), IMREAD_COLOR).copyTo(image);
+                    if( !image.empty() )
+                    {
+                        detectAndDraw( image, canvas, cascade, nestedCascade, scale, tryflip );
+                        char c = (char)waitKey(0);
+                        if( c == 27 || c == 'q' || c == 'Q' )
+                            break;
+                    }
+                    else
+                    {
+                        cerr << "Aw snap, couldn't read image " << buf << endl;
+                    }
+                }
+                fclose(f);
+            }
+        }
+    }
+
+    return 0;
+}
+
+void detectAndDraw( UMat& img, Mat& canvas, CascadeClassifier& cascade,
+                    CascadeClassifier& nestedCascade,
+                    double scale, bool tryflip )
+{
+    double t = 0;
+    vector<Rect> faces, faces2;
+    const static Scalar colors[] =
+    {
+        Scalar(255,0,0),
+        Scalar(255,128,0),
+        Scalar(255,255,0),
+        Scalar(0,255,0),
+        Scalar(0,128,255),
+        Scalar(0,255,255),
+        Scalar(0,0,255),
+        Scalar(255,0,255)
+    };
+    static UMat gray, smallImg;
+
+    t = (double)getTickCount();
+
+    cvtColor( img, gray, COLOR_BGR2GRAY );
+    double fx = 1 / scale;
+    resize( gray, smallImg, Size(), fx, fx, INTER_LINEAR_EXACT );
+    equalizeHist( smallImg, smallImg );
+
+    cascade.detectMultiScale( smallImg, faces,
+        1.1, 3, 0
+        //|CASCADE_FIND_BIGGEST_OBJECT
+        //|CASCADE_DO_ROUGH_SEARCH
+        |CASCADE_SCALE_IMAGE,
+        Size(30, 30) );
+    if( tryflip )
+    {
+        flip(smallImg, smallImg, 1);
+        cascade.detectMultiScale( smallImg, faces2,
+                                 1.1, 2, 0
+                                 //|CASCADE_FIND_BIGGEST_OBJECT
+                                 //|CASCADE_DO_ROUGH_SEARCH
+                                 |CASCADE_SCALE_IMAGE,
+                                 Size(30, 30) );
+        for( vector<Rect>::const_iterator r = faces2.begin(); r != faces2.end(); ++r )
+        {
+            faces.push_back(Rect(smallImg.cols - r->x - r->width, r->y, r->width, r->height));
+        }
+    }
+    t = (double)getTickCount() - t;
+    img.copyTo(canvas);
+
+    double fps = getTickFrequency()/t;
+    static double avgfps = 0;
+    static int nframes = 0;
+    nframes++;
+    double alpha = nframes > 50 ? 0.01 : 1./nframes;
+    avgfps = avgfps*(1-alpha) + fps*alpha;
+
+    putText(canvas, cv::format("OpenCL: %s, fps: %.1f", ocl::useOpenCL() ? "ON" : "OFF", avgfps), Point(50, 30),
+            FONT_HERSHEY_SIMPLEX, 0.8, Scalar(0,255,0), 2);
+
+    for ( size_t i = 0; i < faces.size(); i++ )
+    {
+        Rect r = faces[i];
+        vector<Rect> nestedObjects;
+        Point center;
+        Scalar color = colors[i%8];
+        int radius;
+
+        double aspect_ratio = (double)r.width/r.height;
+        if( 0.75 < aspect_ratio && aspect_ratio < 1.3 )
+        {
+            center.x = cvRound((r.x + r.width*0.5)*scale);
+            center.y = cvRound((r.y + r.height*0.5)*scale);
+            radius = cvRound((r.width + r.height)*0.25*scale);
+            circle( canvas, center, radius, color, 3, 8, 0 );
+        }
+        else
+            rectangle( canvas, Point(cvRound(r.x*scale), cvRound(r.y*scale)),
+                       Point(cvRound((r.x + r.width-1)*scale), cvRound((r.y + r.height-1)*scale)),
+                       color, 3, 8, 0);
+        if( nestedCascade.empty() )
+            continue;
+        UMat smallImgROI = smallImg(r);
+        nestedCascade.detectMultiScale( smallImgROI, nestedObjects,
+            1.1, 2, 0
+            //|CASCADE_FIND_BIGGEST_OBJECT
+            //|CASCADE_DO_ROUGH_SEARCH
+            //|CASCADE_DO_CANNY_PRUNING
+            |CASCADE_SCALE_IMAGE,
+            Size(30, 30) );
+
+        for ( size_t j = 0; j < nestedObjects.size(); j++ )
+        {
+            Rect nr = nestedObjects[j];
+            center.x = cvRound((r.x + nr.x + nr.width*0.5)*scale);
+            center.y = cvRound((r.y + nr.y + nr.height*0.5)*scale);
+            radius = cvRound((nr.width + nr.height)*0.25*scale);
+            circle( canvas, center, radius, color, 3, 8, 0 );
+        }
+    }
+    imshow( "result", canvas );
+}
diff --git a/C++/opencv-4.7.0/samples/tapi/video_acceleration.cpp b/C++/opencv-4.7.0/samples/tapi/video_acceleration.cpp
new file mode 100644
index 00000000..5169236c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/tapi/video_acceleration.cpp
@@ -0,0 +1,211 @@
+#include <iostream>
+#include <chrono>
+#include "opencv2/core.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+using namespace std;
+
+const char* keys =
+"{ i input    |        | input video file }"
+"{ o output   |        | output video file, or specify 'null' to measure decoding without rendering to screen}"
+"{ backend    | any    | VideoCapture and VideoWriter backend, valid values: 'any', 'ffmpeg', 'msmf', 'gstreamer' }"
+"{ accel      | any    | GPU Video Acceleration, valid values: 'none', 'any', 'd3d11', 'vaapi', 'mfx' }"
+"{ device     | -1     | Video Acceleration device (GPU) index (-1 means default device) }"
+"{ out_w      |        | output width (resize by calling cv::resize) }"
+"{ out_h      |        | output height (resize by calling cv::resize) }"
+"{ bitwise_not| false  | apply simple image processing - bitwise_not pixels by calling cv::bitwise_not }"
+"{ opencl     | true   | use OpenCL (inside VideoCapture/VideoWriter and for image processing) }"
+"{ codec      | H264   | codec id (four characters string) of output file encoder }"
+"{ h help     |        | print help message }";
+
+struct {
+    cv::VideoCaptureAPIs backend;
+    const char* str;
+} backend_strings[] = {
+    { cv::CAP_ANY, "any" },
+    { cv::CAP_FFMPEG, "ffmpeg" },
+    { cv::CAP_MSMF, "msmf" },
+    { cv::CAP_GSTREAMER, "gstreamer" },
+};
+
+struct {
+    VideoAccelerationType acceleration;
+    const char* str;
+} acceleration_strings[] = {
+    { VIDEO_ACCELERATION_NONE, "none" },
+    { VIDEO_ACCELERATION_ANY, "any" },
+    { VIDEO_ACCELERATION_D3D11, "d3d11" },
+    { VIDEO_ACCELERATION_VAAPI, "vaapi" },
+    { VIDEO_ACCELERATION_MFX, "mfx" },
+};
+
+class FPSCounter {
+public:
+    FPSCounter(double _interval) : interval(_interval) {
+    }
+
+    ~FPSCounter() {
+        NewFrame(true);
+    }
+
+    void NewFrame(bool last_frame = false) {
+        num_frames++;
+        auto now = std::chrono::high_resolution_clock::now();
+        if (!last_time.time_since_epoch().count()) {
+            last_time = now;
+        }
+
+        double sec = std::chrono::duration_cast<std::chrono::duration<double>>(now - last_time).count();
+        if (sec >= interval || last_frame) {
+            printf("FPS(last %.2f sec) = %.2f\n", sec, num_frames / sec);
+            fflush(stdout);
+            num_frames = 0;
+            last_time = now;
+        }
+    }
+
+private:
+    double interval = 1;
+    std::chrono::time_point<std::chrono::high_resolution_clock> last_time;
+    int num_frames = 0;
+};
+
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser cmd(argc, argv, keys);
+    if (cmd.has("help"))
+    {
+        cout << "Usage : video_acceleration [options]" << endl;
+        cout << "Available options:" << endl;
+        cmd.printMessage();
+        return EXIT_SUCCESS;
+    }
+
+    string infile = cmd.get<string>("i");
+    string outfile = cmd.get<string>("o");
+    string codec = cmd.get<string>("codec");
+    int device = cmd.get<int>("device");
+    int out_w = cmd.get<int>("out_w");
+    int out_h = cmd.get<int>("out_h");
+    bool use_opencl = cmd.get<bool>("opencl");
+    bool bitwise_not = cmd.get<bool>("bitwise_not");
+
+    cv::VideoCaptureAPIs backend = cv::CAP_ANY;
+    string backend_str = cmd.get<string>("backend");
+    for (size_t i = 0; i < sizeof(backend_strings)/sizeof(backend_strings[0]); i++) {
+        if (backend_str == backend_strings[i].str) {
+            backend = backend_strings[i].backend;
+            break;
+        }
+    }
+
+    VideoAccelerationType accel = VIDEO_ACCELERATION_ANY;
+    string accel_str = cmd.get<string>("accel");
+    for (size_t i = 0; i < sizeof(acceleration_strings) / sizeof(acceleration_strings[0]); i++) {
+        if (accel_str == acceleration_strings[i].str) {
+            accel = acceleration_strings[i].acceleration;
+            break;
+        }
+    }
+
+    ocl::setUseOpenCL(use_opencl);
+
+    VideoCapture capture(infile, backend, {
+            CAP_PROP_HW_ACCELERATION, (int)accel,
+            CAP_PROP_HW_DEVICE, device
+    });
+    if (!capture.isOpened()) {
+        cerr << "Failed to open VideoCapture" << endl;
+        return 1;
+    }
+    cout << "VideoCapture backend = " << capture.getBackendName() << endl;
+    VideoAccelerationType actual_accel = static_cast<VideoAccelerationType>(static_cast<int>(capture.get(CAP_PROP_HW_ACCELERATION)));
+    for (size_t i = 0; i < sizeof(acceleration_strings) / sizeof(acceleration_strings[0]); i++) {
+        if (actual_accel == acceleration_strings[i].acceleration) {
+            cout << "VideoCapture acceleration = " << acceleration_strings[i].str << endl;
+            cout << "VideoCapture acceleration device = " << (int)capture.get(CAP_PROP_HW_DEVICE) << endl;
+            break;
+        }
+    }
+
+    VideoWriter writer;
+    if (!outfile.empty() && outfile != "null") {
+        const char* codec_str = codec.c_str();
+        int fourcc = VideoWriter::fourcc(codec_str[0], codec_str[1], codec_str[2], codec_str[3]);
+        double fps = capture.get(CAP_PROP_FPS);
+        Size frameSize = { out_w, out_h };
+        if (!out_w || !out_h) {
+            frameSize = { (int)capture.get(CAP_PROP_FRAME_WIDTH), (int)capture.get(CAP_PROP_FRAME_HEIGHT) };
+        }
+        writer = VideoWriter(outfile, backend, fourcc, fps, frameSize, {
+                VIDEOWRITER_PROP_HW_ACCELERATION, (int)accel,
+                VIDEOWRITER_PROP_HW_DEVICE, device
+        });
+        if (!writer.isOpened()) {
+            cerr << "Failed to open VideoWriter" << endl;
+            return 1;
+        }
+        cout << "VideoWriter backend = " << writer.getBackendName() << endl;
+        actual_accel = static_cast<VideoAccelerationType>(static_cast<int>(writer.get(VIDEOWRITER_PROP_HW_ACCELERATION)));
+        for (size_t i = 0; i < sizeof(acceleration_strings) / sizeof(acceleration_strings[0]); i++) {
+            if (actual_accel == acceleration_strings[i].acceleration) {
+                cout << "VideoWriter acceleration = " << acceleration_strings[i].str << endl;
+                cout << "VideoWriter acceleration device = " << (int)writer.get(VIDEOWRITER_PROP_HW_DEVICE) << endl;
+                break;
+            }
+        }
+    }
+
+    cout << "\nStarting frame loop. Press ESC to exit\n";
+
+    FPSCounter fps_counter(0.5); // print FPS every 0.5 seconds
+
+    UMat frame, frame2, frame3;
+
+    for (;;)
+    {
+        capture.read(frame);
+        if (frame.empty()) {
+            cout << "End of stream" << endl;
+            break;
+        }
+
+        if (out_w && out_h) {
+            cv::resize(frame, frame2, cv::Size(out_w, out_h));
+            //cv::cvtColor(frame, outframe, COLOR_BGRA2RGBA);
+        }
+        else {
+            frame2 = frame;
+        }
+
+        if (bitwise_not) {
+            cv::bitwise_not(frame2, frame3);
+        }
+        else {
+            frame3 = frame2;
+        }
+
+        if (writer.isOpened()) {
+            writer.write(frame3);
+        }
+
+        if (outfile.empty()) {
+            imshow("output", frame3);
+            char key = (char) waitKey(1);
+            if (key == 27)
+                break;
+            else if (key == 'm') {
+                ocl::setUseOpenCL(!cv::ocl::useOpenCL());
+                cout << "Switched to " << (ocl::useOpenCL() ? "OpenCL enabled" : "CPU") << " mode\n";
+            }
+        }
+        fps_counter.NewFrame();
+    }
+
+    return EXIT_SUCCESS;
+}
diff --git a/C++/opencv-4.7.0/samples/va_intel/CMakeLists.txt b/C++/opencv-4.7.0/samples/va_intel/CMakeLists.txt
new file mode 100644
index 00000000..c95a5ed5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/va_intel/CMakeLists.txt
@@ -0,0 +1,21 @@
+ocv_install_example_src(opencl *.cpp *.inc CMakeLists.txt)
+
+set(OPENCV_VA_INTEL_SAMPLES_REQUIRED_DEPS
+  opencv_core
+  opencv_imgproc
+  opencv_imgcodecs
+  opencv_videoio
+  opencv_highgui)
+ocv_check_dependencies(${OPENCV_VA_INTEL_SAMPLES_REQUIRED_DEPS})
+
+if(NOT BUILD_EXAMPLES OR NOT OCV_DEPENDENCIES_FOUND)
+  return()
+endif()
+
+project(va_intel_samples)
+ocv_include_modules_recurse(${OPENCV_VA_INTEL_SAMPLES_REQUIRED_DEPS})
+file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+foreach(sample_filename ${all_samples})
+  ocv_define_sample(tgt ${sample_filename} va_intel)
+  ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_VA_INTEL_SAMPLES_REQUIRED_DEPS} ${VA_LIBRARIES})
+endforeach()
diff --git a/C++/opencv-4.7.0/samples/va_intel/display.cpp.inc b/C++/opencv-4.7.0/samples/va_intel/display.cpp.inc
new file mode 100644
index 00000000..7570cfe6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/va_intel/display.cpp.inc
@@ -0,0 +1,238 @@
+#include <dirent.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <va/va.h>
+# include <va/va_drm.h>
+
+#include "opencv2/core.hpp"  // cv::format()
+
+namespace va {
+
+bool openDisplay();
+void closeDisplay();
+
+VADisplay display = NULL;
+bool initialized = false;
+
+#define VA_INTEL_PCI_DIR "/sys/bus/pci/devices"
+#define VA_INTEL_DRI_DIR "/dev/dri/"
+#define VA_INTEL_PCI_DISPLAY_CONTROLLER_CLASS 0x03
+
+static unsigned readId(const char* devName, const char* idName);
+static int findAdapter(unsigned desiredVendorId);
+
+int drmfd = -1;
+
+class Directory
+{
+    typedef int (*fsort)(const struct dirent**, const struct dirent**);
+public:
+    Directory(const char* path)
+        {
+            dirEntries = 0;
+            numEntries = scandir(path, &dirEntries, filterFunc, (fsort)alphasort);
+        }
+    ~Directory()
+        {
+            if (numEntries && dirEntries)
+            {
+                for (int i = 0;  i < numEntries;  ++i)
+                    free(dirEntries[i]);
+                free(dirEntries);
+            }
+        }
+    int count() const
+        {
+            return numEntries;
+        }
+    const struct dirent* operator[](int index) const
+        {
+            return ((dirEntries != 0) && (index >= 0) && (index < numEntries)) ? dirEntries[index] : 0;
+        }
+protected:
+    static int filterFunc(const struct dirent* dir)
+        {
+            if (!dir) return 0;
+            if (!strcmp(dir->d_name, ".")) return 0;
+            if (!strcmp(dir->d_name, "..")) return 0;
+            return 1;
+        }
+private:
+    int numEntries;
+    struct dirent** dirEntries;
+};
+
+static unsigned readId(const char* devName, const char* idName)
+{
+    long int id = 0;
+
+    std::string fileName = cv::format("%s/%s/%s", VA_INTEL_PCI_DIR, devName, idName);
+
+    FILE* file = fopen(fileName.c_str(), "r");
+    if (file)
+    {
+        char str[16] = "";
+        if (fgets(str, sizeof(str), file))
+            id = strtol(str, NULL, 16);
+        fclose(file);
+    }
+    return (unsigned)id;
+}
+
+static int findAdapter(unsigned desiredVendorId)
+{
+    int adapterIndex = -1;
+
+    Directory dir(VA_INTEL_PCI_DIR);
+
+    for (int i = 0;  i < dir.count();  ++i)
+    {
+        const char* name = dir[i]->d_name;
+
+        unsigned classId = readId(name, "class");
+        if ((classId >> 16) == VA_INTEL_PCI_DISPLAY_CONTROLLER_CLASS)
+        {
+            unsigned vendorId = readId(name, "vendor");
+            if (vendorId == desiredVendorId)
+            {
+                std::string subdirName = cv::format("%s/%s/%s", VA_INTEL_PCI_DIR, name, "drm");
+                Directory subdir(subdirName.c_str());
+                for (int j = 0; j < subdir.count(); ++j)
+                {
+                    if (!strncmp(subdir[j]->d_name, "card", 4))
+                    {
+                        adapterIndex = strtoul(subdir[j]->d_name + 4, NULL, 10);
+                    }
+                }
+                break;
+            }
+        }
+    }
+
+    return adapterIndex;
+}
+
+class NodeInfo
+{
+    enum { NUM_NODES = 2 };
+public:
+    NodeInfo(int adapterIndex)
+        {
+            const char* names[NUM_NODES] = { "renderD", "card" };
+            int numbers[NUM_NODES];
+            numbers[0] = adapterIndex+128;
+            numbers[1] = adapterIndex;
+            for (int i = 0;  i < NUM_NODES;  ++i)
+            {
+                paths[i] = cv::format("%s%s%d", VA_INTEL_DRI_DIR, names[i], numbers[i]);
+            }
+        }
+    ~NodeInfo()
+        {
+            // nothing
+        }
+    int count() const
+        {
+            return NUM_NODES;
+        }
+    const char* path(int index) const
+        {
+            return ((index >= 0) && (index < NUM_NODES)) ? paths[index].c_str() : 0;
+        }
+private:
+    std::string paths[NUM_NODES];
+};
+
+static bool openDeviceIntel();
+static bool openDeviceGeneric();
+
+static bool openDeviceIntel()
+{
+    const unsigned IntelVendorID = 0x8086;
+
+    int adapterIndex = findAdapter(IntelVendorID);
+    if (adapterIndex >= 0)
+    {
+        NodeInfo nodes(adapterIndex);
+
+        for (int i = 0; i < nodes.count(); ++i)
+        {
+            drmfd = open(nodes.path(i), O_RDWR);
+            if (drmfd >= 0)
+            {
+                display = vaGetDisplayDRM(drmfd);
+                if (display)
+                    return true;
+                close(drmfd);
+                drmfd = -1;
+            }
+        }
+    }
+    return false;
+}
+
+static bool openDeviceGeneric()
+{
+    static const char* device_paths[] = { "/dev/dri/renderD128", "/dev/dri/card0" };
+    static const int num_devices = sizeof(device_paths) / sizeof(device_paths[0]);
+
+    for (int i = 0; i < num_devices; ++i)
+    {
+        drmfd = open(device_paths[i], O_RDWR);
+        if (drmfd >= 0)
+        {
+            display = vaGetDisplayDRM(drmfd);
+            if (display)
+                return true;
+            close(drmfd);
+            drmfd = -1;
+        }
+    }
+    return false;
+}
+
+bool openDisplay()
+{
+    if (!initialized)
+    {
+        drmfd = -1;
+        display = 0;
+
+        if (openDeviceIntel() || openDeviceGeneric())
+        {
+            int majorVersion = 0, minorVersion = 0;
+            if (vaInitialize(display, &majorVersion, &minorVersion) == VA_STATUS_SUCCESS)
+            {
+                initialized = true;
+                return true;
+            }
+            close(drmfd);
+            display = 0;
+            drmfd = -1;
+        }
+        return false; // Can't open VA display
+    }
+    return true;
+}
+
+void closeDisplay()
+{
+    if (initialized)
+    {
+        if (display)
+            vaTerminate(display);
+        if (drmfd >= 0)
+            close(drmfd);
+        display = 0;
+        drmfd = -1;
+        initialized = false;
+    }
+}
+
+} // namespace va
diff --git a/C++/opencv-4.7.0/samples/va_intel/va_intel_interop.cpp b/C++/opencv-4.7.0/samples/va_intel/va_intel_interop.cpp
new file mode 100644
index 00000000..c4cf822f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/va_intel/va_intel_interop.cpp
@@ -0,0 +1,266 @@
+/* origin: libva-1.3.1/test/decode/mpeg2vldemo.cpp */
+
+/*
+ * Copyright (c) 2007-2008 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <iostream>
+#include <stdexcept>
+#include <string>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <va/va.h>
+
+#include "display.cpp.inc"
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/core/va_intel.hpp"
+
+#define CHECK_VASTATUS(_status,_func) \
+    if (_status != VA_STATUS_SUCCESS) \
+    { \
+        char str[256]; \
+        snprintf(str, sizeof(str)-1, "%s:%s (%d) failed(status=0x%08x),exit\n", __func__, _func, __LINE__, _status); \
+        throw std::runtime_error(str); \
+    }
+
+class CmdlineParser
+{
+public:
+    enum { fnInput=0, fnOutput1, fnOutput2, _fnNumFiles }; // file name indices
+    CmdlineParser(int argc, char** argv):
+        m_argc(argc), m_argv(argv)
+        {}
+    void usage()
+        {
+            fprintf(stderr,
+                    "Usage: va_intel_interop [-f] infile outfile1 outfile2\n\n"
+                    "Interop ON/OFF version\n\n"
+                    "where:  -f    option indicates interop is off (fallback mode); interop is on by default\n"
+                    "        infile   is to be existing, contains input image data (bmp, jpg, png, tiff, etc)\n"
+                    "        outfile1 is to be created, contains original surface data (NV12)\n"
+                    "        outfile2 is to be created, contains processed surface data (NV12)\n");
+        }
+    // true => go, false => usage/exit; extra args/unknown options are ignored for simplicity
+    bool run()
+        {
+            int n = 0;
+            for (int i = 0; i < _fnNumFiles; ++i)
+                m_files[i] = 0;
+            m_interop = true;
+            for (int i = 1; i < m_argc; ++i)
+            {
+                const char *arg = m_argv[i];
+                if (arg[0] == '-') // option
+                {
+                    if (!strcmp(arg, "-f"))
+                        m_interop = false;
+                }
+                else // parameter
+                {
+                    if (n < _fnNumFiles)
+                        m_files[n++] = arg;
+                }
+            }
+            return bool(n >= _fnNumFiles);
+        }
+    bool isInterop() const
+        {
+            return m_interop;
+        }
+    const char* getFile(int n) const
+        {
+            return ((n >= 0) && (n < _fnNumFiles)) ? m_files[n] : 0;
+        }
+private:
+    int m_argc;
+    char** m_argv;
+    const char* m_files[_fnNumFiles];
+    bool m_interop;
+};
+
+class Timer
+{
+public:
+    enum UNITS
+    {
+        USEC = 0,
+        MSEC,
+        SEC
+    };
+
+    Timer() : m_t0(0), m_diff(0)
+    {
+        m_tick_frequency = (float)cv::getTickFrequency();
+
+        m_unit_mul[USEC] = 1000000;
+        m_unit_mul[MSEC] = 1000;
+        m_unit_mul[SEC]  = 1;
+    }
+
+    void clear()
+    {
+        m_t0 = m_diff = 0;
+    }
+
+    void start()
+    {
+        m_t0 = cv::getTickCount();
+    }
+
+    void stop()
+    {
+        m_diff = cv::getTickCount() - m_t0;
+    }
+
+    float time(UNITS u = MSEC)
+    {
+        float sec = m_diff / m_tick_frequency;
+
+        return sec * m_unit_mul[u];
+    }
+
+public:
+    float m_tick_frequency;
+    int64 m_t0;
+    int64 m_diff;
+    int   m_unit_mul[3];
+};
+
+static void checkIfAvailableYUV420()
+{
+    VAEntrypoint entrypoints[5];
+    int num_entrypoints,vld_entrypoint;
+    VAConfigAttrib attrib;
+    VAStatus status;
+
+    status = vaQueryConfigEntrypoints(va::display, VAProfileMPEG2Main, entrypoints, &num_entrypoints);
+    CHECK_VASTATUS(status, "vaQueryConfigEntrypoints");
+
+    for (vld_entrypoint = 0; vld_entrypoint < num_entrypoints; ++vld_entrypoint)
+    {
+        if (entrypoints[vld_entrypoint] == VAEntrypointVLD)
+            break;
+    }
+    if (vld_entrypoint == num_entrypoints)
+        throw std::runtime_error("Failed to find VLD entry point");
+
+    attrib.type = VAConfigAttribRTFormat;
+    vaGetConfigAttributes(va::display, VAProfileMPEG2Main, VAEntrypointVLD, &attrib, 1);
+    if ((attrib.value & VA_RT_FORMAT_YUV420) == 0)
+        throw std::runtime_error("Desired YUV420 RT format not found");
+}
+
+static cv::UMat readImage(const char* fileName)
+{
+    cv::Mat m = cv::imread(fileName);
+    if (m.empty())
+        throw std::runtime_error("Failed to load image: " + std::string(fileName));
+    return m.getUMat(cv::ACCESS_RW);
+}
+
+static void writeImage(const cv::UMat& u, const char* fileName, bool doInterop)
+{
+    std::string fn = std::string(fileName) + std::string(doInterop ? ".on" : ".off") + std::string(".jpg");
+    cv::imwrite(fn, u);
+}
+
+static float run(const char* infile, const char* outfile1, const char* outfile2, bool doInterop)
+{
+    VASurfaceID surface;
+    VAStatus status;
+    Timer t;
+
+    // initialize CL context for CL/VA interop
+    cv::va_intel::ocl::initializeContextFromVA(va::display, doInterop);
+
+    // load input image
+    cv::UMat u1 = readImage(infile);
+    cv::Size size2 = u1.size();
+    status = vaCreateSurfaces(va::display, VA_RT_FORMAT_YUV420, size2.width, size2.height, &surface, 1, NULL, 0);
+    CHECK_VASTATUS(status, "vaCreateSurfaces");
+
+    // transfer image into VA surface, make sure all CL initialization is done (kernels etc)
+    cv::va_intel::convertToVASurface(va::display, u1, surface, size2);
+    cv::va_intel::convertFromVASurface(va::display, surface, size2, u1);
+    cv::UMat u2;
+    cv::blur(u1, u2, cv::Size(7, 7), cv::Point(-3, -3));
+
+    // measure performance on some image processing
+    writeImage(u1, outfile1, doInterop);
+    t.start();
+    cv::va_intel::convertFromVASurface(va::display, surface, size2, u1);
+    cv::blur(u1, u2, cv::Size(7, 7), cv::Point(-3, -3));
+    cv::va_intel::convertToVASurface(va::display, u2, surface, size2);
+    t.stop();
+    writeImage(u2, outfile2, doInterop);
+
+    vaDestroySurfaces(va::display, &surface,1);
+
+    return t.time(Timer::MSEC);
+}
+
+int main(int argc, char** argv)
+{
+    try
+    {
+        CmdlineParser cmd(argc, argv);
+        if (!cmd.run())
+        {
+            cmd.usage();
+            return 0;
+        }
+
+        if (!va::openDisplay())
+            throw std::runtime_error("Failed to open VA display for CL-VA interoperability");
+        std::cout << "VA display opened successfully" << std::endl;
+
+        checkIfAvailableYUV420();
+
+        const char* infile = cmd.getFile(CmdlineParser::fnInput);
+        const char* outfile1 = cmd.getFile(CmdlineParser::fnOutput1);
+        const char* outfile2 = cmd.getFile(CmdlineParser::fnOutput2);
+        bool doInterop = cmd.isInterop();
+
+        float time = run(infile, outfile1, outfile2, doInterop);
+
+        std::cout << "Interop " << (doInterop ? "ON " : "OFF") << ": processing time, msec: " << time << std::endl;
+    }
+    catch (const std::exception& ex)
+    {
+        std::cerr << "ERROR: " << ex.what() << std::endl;
+    }
+
+    va::closeDisplay();
+    return 0;
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection.sln b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection.sln
new file mode 100644
index 00000000..f27b6d37
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection.sln
@@ -0,0 +1,40 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FaceDetection", "FaceDetection\FaceDetection.vcxproj", "{0FAE44E0-6C15-4CCA-ABDA-29556B391390}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM = Debug|ARM
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|ARM = Release|ARM
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Debug|ARM.ActiveCfg = Debug|ARM
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Debug|ARM.Build.0 = Debug|ARM
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Debug|ARM.Deploy.0 = Debug|ARM
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Debug|Win32.ActiveCfg = Debug|Win32
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Debug|Win32.Build.0 = Debug|Win32
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Debug|Win32.Deploy.0 = Debug|Win32
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Debug|x64.ActiveCfg = Debug|x64
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Debug|x64.Build.0 = Debug|x64
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Debug|x64.Deploy.0 = Debug|x64
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Release|ARM.ActiveCfg = Release|ARM
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Release|ARM.Build.0 = Release|ARM
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Release|ARM.Deploy.0 = Release|ARM
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Release|Win32.ActiveCfg = Release|Win32
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Release|Win32.Build.0 = Release|Win32
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Release|Win32.Deploy.0 = Release|Win32
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Release|x64.ActiveCfg = Release|x64
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Release|x64.Build.0 = Release|x64
+		{0FAE44E0-6C15-4CCA-ABDA-29556B391390}.Release|x64.Deploy.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/App.xaml b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/App.xaml
new file mode 100644
index 00000000..15805bf2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/App.xaml
@@ -0,0 +1,7 @@
+<Application
+    x:Class="FaceDetection.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:FaceDetection">
+
+</Application>
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/App.xaml.cpp b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/App.xaml.cpp
new file mode 100644
index 00000000..c95b0519
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/App.xaml.cpp
@@ -0,0 +1,125 @@
+//
+// App.xaml.cpp
+// Implementation of the App class.
+//
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+
+using namespace FaceDetection;
+
+using namespace Platform;
+using namespace Windows::ApplicationModel;
+using namespace Windows::ApplicationModel::Activation;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Controls::Primitives;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Interop;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Navigation;
+
+// The Blank Application template is documented at http://go.microsoft.com/fwlink/?LinkId=234227
+
+/// <summary>
+/// Initializes the singleton application object.  This is the first line of authored code
+/// executed, and as such is the logical equivalent of main() or WinMain().
+/// </summary>
+App::App()
+{
+    InitializeComponent();
+    Suspending += ref new SuspendingEventHandler(this, &App::OnSuspending);
+}
+
+/// <summary>
+/// Invoked when the application is launched normally by the end user.	Other entry points
+/// will be used such as when the application is launched to open a specific file.
+/// </summary>
+/// <param name="e">Details about the launch request and process.</param>
+void App::OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ e)
+{
+
+#if _DEBUG
+        // Show graphics profiling information while debugging.
+        if (IsDebuggerPresent())
+        {
+            // Display the current frame rate counters
+             DebugSettings->EnableFrameRateCounter = true;
+        }
+#endif
+
+    auto rootFrame = dynamic_cast<Frame^>(Window::Current->Content);
+
+    // Do not repeat app initialization when the Window already has content,
+    // just ensure that the window is active
+    if (rootFrame == nullptr)
+    {
+        // Create a Frame to act as the navigation context and associate it with
+        // a SuspensionManager key
+        rootFrame = ref new Frame();
+
+        // Set the default language
+        rootFrame->Language = Windows::Globalization::ApplicationLanguages::Languages->GetAt(0);
+
+        rootFrame->NavigationFailed += ref new Windows::UI::Xaml::Navigation::NavigationFailedEventHandler(this, &App::OnNavigationFailed);
+
+        if (e->PreviousExecutionState == ApplicationExecutionState::Terminated)
+        {
+            // TODO: Restore the saved session state only when appropriate, scheduling the
+            // final launch steps after the restore is complete
+
+        }
+
+        if (rootFrame->Content == nullptr)
+        {
+            // When the navigation stack isn't restored navigate to the first page,
+            // configuring the new page by passing required information as a navigation
+            // parameter
+            rootFrame->Navigate(TypeName(MainPage::typeid), e->Arguments);
+        }
+        // Place the frame in the current Window
+        Window::Current->Content = rootFrame;
+        // Ensure the current window is active
+        Window::Current->Activate();
+    }
+    else
+    {
+        if (rootFrame->Content == nullptr)
+        {
+            // When the navigation stack isn't restored navigate to the first page,
+            // configuring the new page by passing required information as a navigation
+            // parameter
+            rootFrame->Navigate(TypeName(MainPage::typeid), e->Arguments);
+        }
+        // Ensure the current window is active
+        Window::Current->Activate();
+    }
+}
+
+/// <summary>
+/// Invoked when application execution is being suspended.	Application state is saved
+/// without knowing whether the application will be terminated or resumed with the contents
+/// of memory still intact.
+/// </summary>
+/// <param name="sender">The source of the suspend request.</param>
+/// <param name="e">Details about the suspend request.</param>
+void App::OnSuspending(Object^ sender, SuspendingEventArgs^ e)
+{
+    (void) sender;	// Unused parameter
+    (void) e;	// Unused parameter
+
+    //TODO: Save application state and stop any background activity
+}
+
+/// <summary>
+/// Invoked when Navigation to a certain page fails
+/// </summary>
+/// <param name="sender">The Frame which failed navigation</param>
+/// <param name="e">Details about the navigation failure</param>
+void App::OnNavigationFailed(Platform::Object ^sender, Windows::UI::Xaml::Navigation::NavigationFailedEventArgs ^e)
+{
+    throw ref new FailureException("Failed to load Page " + e->SourcePageType.Name);
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/App.xaml.h b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/App.xaml.h
new file mode 100644
index 00000000..086c70a2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/App.xaml.h
@@ -0,0 +1,27 @@
+//
+// App.xaml.h
+// Declaration of the App class.
+//
+
+#pragma once
+
+#include "App.g.h"
+
+namespace FaceDetection
+{
+    /// <summary>
+    /// Provides application-specific behavior to supplement the default Application class.
+    /// </summary>
+    ref class App sealed
+    {
+    protected:
+        virtual void OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ e) override;
+
+    internal:
+        App();
+
+    private:
+        void OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ e);
+        void OnNavigationFailed(Platform::Object ^sender, Windows::UI::Xaml::Navigation::NavigationFailedEventArgs ^e);
+    };
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/Logo.scale-100.png b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/Logo.scale-100.png
new file mode 100644
index 00000000..e26771cb
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/Logo.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/SmallLogo.scale-100.png b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/SmallLogo.scale-100.png
new file mode 100644
index 00000000..1eb0d9d5
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/SmallLogo.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/SplashScreen.scale-100.png b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/SplashScreen.scale-100.png
new file mode 100644
index 00000000..c951e031
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/SplashScreen.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/StoreLogo.scale-100.png b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/StoreLogo.scale-100.png
new file mode 100644
index 00000000..dcb67271
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/StoreLogo.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/group1.jpg b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/group1.jpg
new file mode 100644
index 00000000..0046e709
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/group1.jpg differ
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/group2.jpg b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/group2.jpg
new file mode 100644
index 00000000..777b8aa8
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/group2.jpg differ
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/group3.jpg b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/group3.jpg
new file mode 100644
index 00000000..403c47c7
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/group3.jpg differ
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/haarcascade_frontalface_alt.xml b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/haarcascade_frontalface_alt.xml
new file mode 100644
index 00000000..ade4b212
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Assets/haarcascade_frontalface_alt.xml
@@ -0,0 +1,24350 @@
+<?xml version="1.0"?>
+<!--
+    Stump-based 20x20 gentle adaboost frontal face detector.
+    Created by Rainer Lienhart.
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+
+  By downloading, copying, installing or using the software you agree to this license.
+  If you do not agree to this license, do not download, install,
+  copy or use the software.
+
+
+                        Intel License Agreement
+                For Open Source Computer Vision Library
+
+ Copyright (C) 2000, Intel Corporation, all rights reserved.
+ Third party copyrights are property of their respective owners.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+   * Redistribution's of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+   * Redistribution's in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+
+   * The name of Intel Corporation may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+ This software is provided by the copyright holders and contributors "as is" and
+ any express or implied warranties, including, but not limited to, the implied
+ warranties of merchantability and fitness for a particular purpose are disclaimed.
+ In no event shall the Intel Corporation or contributors be liable for any direct,
+ indirect, incidental, special, exemplary, or consequential damages
+ (including, but not limited to, procurement of substitute goods or services;
+ loss of use, data, or profits; or business interruption) however caused
+ and on any theory of liability, whether in contract, strict liability,
+ or tort (including negligence or otherwise) arising in any way out of
+ the use of this software, even if advised of the possibility of such damage.
+-->
+<opencv_storage>
+<cascade type_id="opencv-cascade-classifier"><stageType>BOOST</stageType>
+  <featureType>HAAR</featureType>
+  <height>20</height>
+  <width>20</width>
+  <stageParams>
+    <maxWeakCount>213</maxWeakCount></stageParams>
+  <featureParams>
+    <maxCatCount>0</maxCatCount></featureParams>
+  <stageNum>22</stageNum>
+  <stages>
+    <_>
+      <maxWeakCount>3</maxWeakCount>
+      <stageThreshold>8.2268941402435303e-01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 0 4.0141958743333817e-03</internalNodes>
+          <leafValues>
+            3.3794190734624863e-02 8.3781069517135620e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1 1.5151339583098888e-02</internalNodes>
+          <leafValues>
+            1.5141320228576660e-01 7.4888122081756592e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2 4.2109931819140911e-03</internalNodes>
+          <leafValues>
+            9.0049281716346741e-02 6.3748198747634888e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>16</maxWeakCount>
+      <stageThreshold>6.9566087722778320e+00</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 3 1.6227109590545297e-03</internalNodes>
+          <leafValues>
+            6.9308586418628693e-02 7.1109461784362793e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 4 2.2906649392098188e-03</internalNodes>
+          <leafValues>
+            1.7958030104637146e-01 6.6686922311782837e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 5 5.0025708042085171e-03</internalNodes>
+          <leafValues>
+            1.6936729848384857e-01 6.5540069341659546e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 6 7.9659894108772278e-03</internalNodes>
+          <leafValues>
+            5.8663320541381836e-01 9.1414518654346466e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 7 -3.5227010957896709e-03</internalNodes>
+          <leafValues>
+            1.4131669700145721e-01 6.0318958759307861e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 8 3.6667689681053162e-02</internalNodes>
+          <leafValues>
+            3.6756721138954163e-01 7.9203182458877563e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 9 9.3361474573612213e-03</internalNodes>
+          <leafValues>
+            6.1613857746124268e-01 2.0885099470615387e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 10 8.6961314082145691e-03</internalNodes>
+          <leafValues>
+            2.8362309932708740e-01 6.3602739572525024e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 11 1.1488880263641477e-03</internalNodes>
+          <leafValues>
+            2.2235809266567230e-01 5.8007007837295532e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 12 -2.1484689787030220e-03</internalNodes>
+          <leafValues>
+            2.4064640700817108e-01 5.7870548963546753e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 13 2.1219060290604830e-03</internalNodes>
+          <leafValues>
+            5.5596548318862915e-01 1.3622370362281799e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 14 -9.3949146568775177e-02</internalNodes>
+          <leafValues>
+            8.5027372837066650e-01 4.7177401185035706e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 15 1.3777789426967502e-03</internalNodes>
+          <leafValues>
+            5.9936738014221191e-01 2.8345298767089844e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 16 7.3063157498836517e-02</internalNodes>
+          <leafValues>
+            4.3418860435485840e-01 7.0600342750549316e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 17 3.6767389974556863e-04</internalNodes>
+          <leafValues>
+            3.0278879404067993e-01 6.0515749454498291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 18 -6.0479710809886456e-03</internalNodes>
+          <leafValues>
+            1.7984339594841003e-01 5.6752568483352661e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>21</maxWeakCount>
+      <stageThreshold>9.4985427856445312e+00</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 19 -1.6510689631104469e-02</internalNodes>
+          <leafValues>
+            6.6442251205444336e-01 1.4248579740524292e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 20 2.7052499353885651e-03</internalNodes>
+          <leafValues>
+            6.3253521919250488e-01 1.2884770333766937e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 21 2.8069869149476290e-03</internalNodes>
+          <leafValues>
+            1.2402880191802979e-01 6.1931931972503662e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 22 -1.5402400167658925e-03</internalNodes>
+          <leafValues>
+            1.4321430027484894e-01 5.6700158119201660e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 23 -5.6386279175058007e-04</internalNodes>
+          <leafValues>
+            1.6574330627918243e-01 5.9052079916000366e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 24 1.9253729842603207e-03</internalNodes>
+          <leafValues>
+            2.6955071091651917e-01 5.7388240098953247e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 25 -5.0214841030538082e-03</internalNodes>
+          <leafValues>
+            1.8935389816761017e-01 5.7827740907669067e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 26 2.6365420781075954e-03</internalNodes>
+          <leafValues>
+            2.3093290627002716e-01 5.6954258680343628e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 27 -1.5127769438549876e-03</internalNodes>
+          <leafValues>
+            2.7596020698547363e-01 5.9566420316696167e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 28 -1.0157439857721329e-02</internalNodes>
+          <leafValues>
+            1.7325380444526672e-01 5.5220472812652588e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 29 -1.1953660286962986e-02</internalNodes>
+          <leafValues>
+            1.3394099473953247e-01 5.5590140819549561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 30 4.8859491944313049e-03</internalNodes>
+          <leafValues>
+            3.6287039518356323e-01 6.1888492107391357e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 31 -8.0132916569709778e-02</internalNodes>
+          <leafValues>
+            9.1211050748825073e-02 5.4759448766708374e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 32 1.0643280111253262e-03</internalNodes>
+          <leafValues>
+            3.7151429057121277e-01 5.7113999128341675e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 33 -1.3419450260698795e-03</internalNodes>
+          <leafValues>
+            5.9533137083053589e-01 3.3180978894233704e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 34 -5.4601140320301056e-02</internalNodes>
+          <leafValues>
+            1.8440659344196320e-01 5.6028461456298828e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 35 2.9071690514683723e-03</internalNodes>
+          <leafValues>
+            3.5942441225051880e-01 6.1317151784896851e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 36 7.4718717951327562e-04</internalNodes>
+          <leafValues>
+            5.9943532943725586e-01 3.4595629572868347e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 37 4.3013808317482471e-03</internalNodes>
+          <leafValues>
+            4.1726520657539368e-01 6.9908452033996582e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 38 4.5017572119832039e-03</internalNodes>
+          <leafValues>
+            4.5097151398658752e-01 7.8014570474624634e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 39 2.4138500913977623e-02</internalNodes>
+          <leafValues>
+            5.4382127523422241e-01 1.3198269903659821e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>39</maxWeakCount>
+      <stageThreshold>1.8412969589233398e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 40 1.9212230108678341e-03</internalNodes>
+          <leafValues>
+            1.4152669906616211e-01 6.1998707056045532e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 41 -1.2748669541906565e-04</internalNodes>
+          <leafValues>
+            6.1910742521286011e-01 1.8849289417266846e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 42 5.1409931620582938e-04</internalNodes>
+          <leafValues>
+            1.4873969554901123e-01 5.8579277992248535e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 43 4.1878609918057919e-03</internalNodes>
+          <leafValues>
+            2.7469098567962646e-01 6.3592398166656494e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 44 5.1015717908740044e-03</internalNodes>
+          <leafValues>
+            5.8708512783050537e-01 2.1756289899349213e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 45 -2.1448440384119749e-03</internalNodes>
+          <leafValues>
+            5.8809447288513184e-01 2.9795908927917480e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 46 -2.8977119363844395e-03</internalNodes>
+          <leafValues>
+            2.3733270168304443e-01 5.8766472339630127e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 47 -2.1610679104924202e-02</internalNodes>
+          <leafValues>
+            1.2206549942493439e-01 5.1942020654678345e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 48 -4.6299318782985210e-03</internalNodes>
+          <leafValues>
+            2.6312309503555298e-01 5.8174091577529907e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 49 5.9393711853772402e-04</internalNodes>
+          <leafValues>
+            3.6386200785636902e-01 5.6985449790954590e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 50 5.3878661245107651e-02</internalNodes>
+          <leafValues>
+            4.3035310506820679e-01 7.5593662261962891e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 51 1.8887349870055914e-03</internalNodes>
+          <leafValues>
+            2.1226030588150024e-01 5.6134271621704102e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 52 -2.3635339457541704e-03</internalNodes>
+          <leafValues>
+            5.6318491697311401e-01 2.6427671313285828e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 53 2.4017799645662308e-02</internalNodes>
+          <leafValues>
+            5.7971078157424927e-01 2.7517059445381165e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 54 2.0543030404951423e-04</internalNodes>
+          <leafValues>
+            2.7052420377731323e-01 5.7525688409805298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 55 8.4790197433903813e-04</internalNodes>
+          <leafValues>
+            5.4356247186660767e-01 2.3348769545555115e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 56 1.4091329649090767e-03</internalNodes>
+          <leafValues>
+            5.3194248676300049e-01 2.0631550252437592e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 57 1.4642629539594054e-03</internalNodes>
+          <leafValues>
+            5.4189807176589966e-01 3.0688610672950745e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 58 1.6352549428120255e-03</internalNodes>
+          <leafValues>
+            3.6953729391098022e-01 6.1128681898117065e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 59 8.3172752056270838e-04</internalNodes>
+          <leafValues>
+            3.5650369524955750e-01 6.0252362489700317e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 60 -2.0998890977352858e-03</internalNodes>
+          <leafValues>
+            1.9139820337295532e-01 5.3628271818161011e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 61 -7.4213981861248612e-04</internalNodes>
+          <leafValues>
+            3.8355550169944763e-01 5.5293101072311401e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 62 3.2655049581080675e-03</internalNodes>
+          <leafValues>
+            4.3128961324691772e-01 7.1018958091735840e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 63 8.9134991867467761e-04</internalNodes>
+          <leafValues>
+            3.9848309755325317e-01 6.3919639587402344e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 64 -1.5284179709851742e-02</internalNodes>
+          <leafValues>
+            2.3667329549789429e-01 5.4337137937545776e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 65 4.8381411470472813e-03</internalNodes>
+          <leafValues>
+            5.8175009489059448e-01 3.2391890883445740e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 66 -9.1093179071322083e-04</internalNodes>
+          <leafValues>
+            5.5405938625335693e-01 2.9118689894676208e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 67 -6.1275060288608074e-03</internalNodes>
+          <leafValues>
+            1.7752550542354584e-01 5.1966291666030884e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 68 -4.4576259097084403e-04</internalNodes>
+          <leafValues>
+            3.0241701006889343e-01 5.5335938930511475e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 69 2.2646540775895119e-02</internalNodes>
+          <leafValues>
+            4.4149309396743774e-01 6.9753772020339966e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 70 -1.8804960418492556e-03</internalNodes>
+          <leafValues>
+            2.7913948893547058e-01 5.4979521036148071e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 71 7.0889107882976532e-03</internalNodes>
+          <leafValues>
+            5.2631992101669312e-01 2.3855470120906830e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 72 1.7318050377070904e-03</internalNodes>
+          <leafValues>
+            4.3193790316581726e-01 6.9836008548736572e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 73 -6.8482700735330582e-03</internalNodes>
+          <leafValues>
+            3.0820429325103760e-01 5.3909200429916382e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 74 -1.5062530110299122e-05</internalNodes>
+          <leafValues>
+            5.5219221115112305e-01 3.1203660368919373e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 75 2.9475569725036621e-02</internalNodes>
+          <leafValues>
+            5.4013228416442871e-01 1.7706030607223511e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 76 8.1387329846620560e-03</internalNodes>
+          <leafValues>
+            5.1786178350448608e-01 1.2110190093517303e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 77 2.0942950621247292e-02</internalNodes>
+          <leafValues>
+            5.2902942895889282e-01 3.3112218976020813e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 78 -9.5665529370307922e-03</internalNodes>
+          <leafValues>
+            7.4719941616058350e-01 4.4519689679145813e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>33</maxWeakCount>
+      <stageThreshold>1.5324139595031738e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 79 -2.8206960996612906e-04</internalNodes>
+          <leafValues>
+            2.0640860497951508e-01 6.0767322778701782e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 80 1.6790600493550301e-03</internalNodes>
+          <leafValues>
+            5.8519971370697021e-01 1.2553839385509491e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 81 6.9827912375330925e-04</internalNodes>
+          <leafValues>
+            9.4018429517745972e-02 5.7289612293243408e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 82 7.8959012171253562e-04</internalNodes>
+          <leafValues>
+            1.7819879949092865e-01 5.6943088769912720e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 83 -2.8560499195009470e-03</internalNodes>
+          <leafValues>
+            1.6383990645408630e-01 5.7886648178100586e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 84 -3.8122469559311867e-03</internalNodes>
+          <leafValues>
+            2.0854400098323822e-01 5.5085647106170654e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 85 1.5896620461717248e-03</internalNodes>
+          <leafValues>
+            5.7027608156204224e-01 1.8572150170803070e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 86 1.0078339837491512e-02</internalNodes>
+          <leafValues>
+            5.1169431209564209e-01 2.1897700428962708e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 87 -6.3526302576065063e-02</internalNodes>
+          <leafValues>
+            7.1313798427581787e-01 4.0438130497932434e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 88 -9.1031491756439209e-03</internalNodes>
+          <leafValues>
+            2.5671818852424622e-01 5.4639732837677002e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 89 -2.4035000242292881e-03</internalNodes>
+          <leafValues>
+            1.7006659507751465e-01 5.5909740924835205e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 90 1.5226360410451889e-03</internalNodes>
+          <leafValues>
+            5.4105567932128906e-01 2.6190540194511414e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 91 1.7997439950704575e-02</internalNodes>
+          <leafValues>
+            3.7324368953704834e-01 6.5352207422256470e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 92 -6.4538191072642803e-03</internalNodes>
+          <leafValues>
+            2.6264819502830505e-01 5.5374461412429810e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 93 -1.1880760081112385e-02</internalNodes>
+          <leafValues>
+            2.0037539303302765e-01 5.5447459220886230e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 94 1.2713660253211856e-03</internalNodes>
+          <leafValues>
+            5.5919027328491211e-01 3.0319759249687195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 95 1.1376109905540943e-03</internalNodes>
+          <leafValues>
+            2.7304071187973022e-01 5.6465089321136475e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 96 -4.2651998810470104e-03</internalNodes>
+          <leafValues>
+            1.4059090614318848e-01 5.4618209600448608e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 97 -2.9602861031889915e-03</internalNodes>
+          <leafValues>
+            1.7950350046157837e-01 5.4592901468276978e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 98 -8.8448226451873779e-03</internalNodes>
+          <leafValues>
+            5.7367831468582153e-01 2.8092199563980103e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 99 -6.6430689767003059e-03</internalNodes>
+          <leafValues>
+            2.3706759512424469e-01 5.5038261413574219e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 100 3.9997808635234833e-03</internalNodes>
+          <leafValues>
+            5.6081998348236084e-01 3.3042821288108826e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 101 -4.1221720166504383e-03</internalNodes>
+          <leafValues>
+            1.6401059925556183e-01 5.3789931535720825e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 102 1.5624909661710262e-02</internalNodes>
+          <leafValues>
+            5.2276492118835449e-01 2.2886039316654205e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 103 -1.0356419719755650e-02</internalNodes>
+          <leafValues>
+            7.0161938667297363e-01 4.2529278993606567e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 104 -8.7960809469223022e-03</internalNodes>
+          <leafValues>
+            2.7673470973968506e-01 5.3558301925659180e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 105 1.6226939857006073e-01</internalNodes>
+          <leafValues>
+            4.3422400951385498e-01 7.4425792694091797e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 106 4.5542530715465546e-03</internalNodes>
+          <leafValues>
+            5.7264858484268188e-01 2.5821250677108765e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 107 -2.1309209987521172e-03</internalNodes>
+          <leafValues>
+            2.1068480610847473e-01 5.3610187768936157e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 108 -1.3208420015871525e-02</internalNodes>
+          <leafValues>
+            7.5937908887863159e-01 4.5524680614471436e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 109 -6.5996676683425903e-02</internalNodes>
+          <leafValues>
+            1.2524759769439697e-01 5.3440397977828979e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 110 7.9142656177282333e-03</internalNodes>
+          <leafValues>
+            3.3153840899467468e-01 5.6010431051254272e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 111 2.0894279703497887e-02</internalNodes>
+          <leafValues>
+            5.5060499906539917e-01 2.7688381075859070e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>44</maxWeakCount>
+      <stageThreshold>2.1010639190673828e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 112 1.1961159761995077e-03</internalNodes>
+          <leafValues>
+            1.7626909911632538e-01 6.1562412977218628e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 113 -1.8679830245673656e-03</internalNodes>
+          <leafValues>
+            6.1181068420410156e-01 1.8323999643325806e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 114 -1.9579799845814705e-04</internalNodes>
+          <leafValues>
+            9.9044263362884521e-02 5.7238161563873291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 115 -8.0255657667294145e-04</internalNodes>
+          <leafValues>
+            5.5798798799514771e-01 2.3772829771041870e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 116 -2.4510810617357492e-03</internalNodes>
+          <leafValues>
+            2.2314579784870148e-01 5.8589351177215576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 117 5.0361850298941135e-04</internalNodes>
+          <leafValues>
+            2.6539939641952515e-01 5.7941037416458130e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 118 4.0293349884450436e-03</internalNodes>
+          <leafValues>
+            5.8038270473480225e-01 2.4848650395870209e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 119 -1.4451709575951099e-02</internalNodes>
+          <leafValues>
+            1.8303519487380981e-01 5.4842048883438110e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 120 2.0380979403853416e-03</internalNodes>
+          <leafValues>
+            3.3635589480400085e-01 6.0510927438735962e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 121 -1.6155190533027053e-03</internalNodes>
+          <leafValues>
+            2.2866420447826385e-01 5.4412460327148438e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 122 3.3458340913057327e-03</internalNodes>
+          <leafValues>
+            5.6259131431579590e-01 2.3923380672931671e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 123 1.6379579901695251e-03</internalNodes>
+          <leafValues>
+            3.9069938659667969e-01 5.9646219015121460e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 124 3.0251210555434227e-02</internalNodes>
+          <leafValues>
+            5.2484822273254395e-01 1.5757469832897186e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 125 3.7251990288496017e-02</internalNodes>
+          <leafValues>
+            4.1943109035491943e-01 6.7484188079833984e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 126 -2.5109790265560150e-02</internalNodes>
+          <leafValues>
+            1.8825499713420868e-01 5.4734510183334351e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 127 -5.3099058568477631e-03</internalNodes>
+          <leafValues>
+            1.3399730622768402e-01 5.2271109819412231e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 128 1.2086479691788554e-03</internalNodes>
+          <leafValues>
+            3.7620881199836731e-01 6.1096358299255371e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 129 -2.1907679736614227e-02</internalNodes>
+          <leafValues>
+            2.6631429791450500e-01 5.4040068387985229e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 130 5.4116579703986645e-03</internalNodes>
+          <leafValues>
+            5.3635787963867188e-01 2.2322730720043182e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 131 6.9946326315402985e-02</internalNodes>
+          <leafValues>
+            5.3582328557968140e-01 2.4536980688571930e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 132 3.4520021290518343e-04</internalNodes>
+          <leafValues>
+            2.4096719920635223e-01 5.3769302368164062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 133 1.2627709656953812e-03</internalNodes>
+          <leafValues>
+            5.4258567094802856e-01 3.1556931138038635e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 134 2.2719509899616241e-02</internalNodes>
+          <leafValues>
+            4.1584059596061707e-01 6.5978652238845825e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 135 -1.8111000536009669e-03</internalNodes>
+          <leafValues>
+            2.8112530708312988e-01 5.5052447319030762e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 136 3.3469670452177525e-03</internalNodes>
+          <leafValues>
+            5.2600282430648804e-01 1.8914650380611420e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 137 4.0791751234792173e-04</internalNodes>
+          <leafValues>
+            5.6735092401504517e-01 3.3442100882530212e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 138 1.2734799645841122e-02</internalNodes>
+          <leafValues>
+            5.3435921669006348e-01 2.3956120014190674e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 139 -7.3119727894663811e-03</internalNodes>
+          <leafValues>
+            6.0108900070190430e-01 4.0222078561782837e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 140 -5.6948751211166382e-02</internalNodes>
+          <leafValues>
+            8.1991511583328247e-01 4.5431908965110779e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 141 -5.0116591155529022e-03</internalNodes>
+          <leafValues>
+            2.2002810239791870e-01 5.3577107191085815e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 142 6.0334368608891964e-03</internalNodes>
+          <leafValues>
+            4.4130811095237732e-01 7.1817511320114136e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 143 3.9437441155314445e-03</internalNodes>
+          <leafValues>
+            5.4788607358932495e-01 2.7917331457138062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 144 -3.6591119132936001e-03</internalNodes>
+          <leafValues>
+            6.3578677177429199e-01 3.9897239208221436e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 145 -3.8456181064248085e-03</internalNodes>
+          <leafValues>
+            3.4936860203742981e-01 5.3006649017333984e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 146 -7.1926261298358440e-03</internalNodes>
+          <leafValues>
+            1.1196149885654449e-01 5.2296727895736694e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 147 -5.2798941731452942e-02</internalNodes>
+          <leafValues>
+            2.3871029913425446e-01 5.4534512758255005e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 148 -7.9537667334079742e-03</internalNodes>
+          <leafValues>
+            7.5869178771972656e-01 4.4393768906593323e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 149 -2.7344180271029472e-03</internalNodes>
+          <leafValues>
+            2.5654768943786621e-01 5.4893219470977783e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 150 -1.8507939530536532e-03</internalNodes>
+          <leafValues>
+            6.7343479394912720e-01 4.2524749040603638e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 151 1.5918919816613197e-02</internalNodes>
+          <leafValues>
+            5.4883527755737305e-01 2.2926619648933411e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 152 -1.2687679845839739e-03</internalNodes>
+          <leafValues>
+            6.1043310165405273e-01 4.0223899483680725e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 153 6.2883910723030567e-03</internalNodes>
+          <leafValues>
+            5.3108531236648560e-01 1.5361930429935455e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 154 -6.2259892001748085e-03</internalNodes>
+          <leafValues>
+            1.7291119694709778e-01 5.2416062355041504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 155 -1.2132599949836731e-02</internalNodes>
+          <leafValues>
+            6.5977597236633301e-01 4.3251821398735046e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>50</maxWeakCount>
+      <stageThreshold>2.3918790817260742e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 156 -3.9184908382594585e-03</internalNodes>
+          <leafValues>
+            6.1034351587295532e-01 1.4693309366703033e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 157 1.5971299726516008e-03</internalNodes>
+          <leafValues>
+            2.6323631405830383e-01 5.8964669704437256e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 158 1.7780110239982605e-02</internalNodes>
+          <leafValues>
+            5.8728742599487305e-01 1.7603619396686554e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 159 6.5334769897162914e-04</internalNodes>
+          <leafValues>
+            1.5678019821643829e-01 5.5960661172866821e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 160 -2.8353091329336166e-04</internalNodes>
+          <leafValues>
+            1.9131539762020111e-01 5.7320362329483032e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 161 1.6104689566418529e-03</internalNodes>
+          <leafValues>
+            2.9149138927459717e-01 5.6230807304382324e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 162 -9.7750619053840637e-02</internalNodes>
+          <leafValues>
+            1.9434769451618195e-01 5.6482332944869995e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 163 5.5182358482852578e-04</internalNodes>
+          <leafValues>
+            3.1346169114112854e-01 5.5046397447586060e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 164 -1.2858220376074314e-02</internalNodes>
+          <leafValues>
+            2.5364819169044495e-01 5.7601428031921387e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 165 4.1530239395797253e-03</internalNodes>
+          <leafValues>
+            5.7677221298217773e-01 3.6597740650177002e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 166 1.7092459602281451e-03</internalNodes>
+          <leafValues>
+            2.8431910276412964e-01 5.9189391136169434e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 167 7.5217359699308872e-03</internalNodes>
+          <leafValues>
+            4.0524271130561829e-01 6.1831092834472656e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 168 2.2479810286313295e-03</internalNodes>
+          <leafValues>
+            5.7837551832199097e-01 3.1354010105133057e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 169 5.2006211131811142e-02</internalNodes>
+          <leafValues>
+            5.5413120985031128e-01 1.9166369736194611e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 170 1.2085529975593090e-02</internalNodes>
+          <leafValues>
+            4.0326559543609619e-01 6.6445910930633545e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 171 1.4687820112158079e-05</internalNodes>
+          <leafValues>
+            3.5359779000282288e-01 5.7093828916549683e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 172 7.1395188570022583e-06</internalNodes>
+          <leafValues>
+            3.0374449491500854e-01 5.6102699041366577e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 173 -4.6001640148460865e-03</internalNodes>
+          <leafValues>
+            7.1810871362686157e-01 4.5803260803222656e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 174 2.0058949012309313e-03</internalNodes>
+          <leafValues>
+            5.6219518184661865e-01 2.9536840319633484e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 175 4.5050270855426788e-03</internalNodes>
+          <leafValues>
+            4.6153879165649414e-01 7.6190179586410522e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 176 1.1746830306947231e-02</internalNodes>
+          <leafValues>
+            5.3438371419906616e-01 1.7725290358066559e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 177 -5.8316338807344437e-02</internalNodes>
+          <leafValues>
+            1.6862459480762482e-01 5.3407722711563110e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 178 2.3629379575140774e-04</internalNodes>
+          <leafValues>
+            3.7920561432838440e-01 6.0268038511276245e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 179 -7.8156180679798126e-03</internalNodes>
+          <leafValues>
+            1.5128670632839203e-01 5.3243237733840942e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 180 -1.0876160115003586e-02</internalNodes>
+          <leafValues>
+            2.0818220078945160e-01 5.3199452161788940e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 181 -2.7745519764721394e-03</internalNodes>
+          <leafValues>
+            4.0982469916343689e-01 5.2103281021118164e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 182 -7.8276381827890873e-04</internalNodes>
+          <leafValues>
+            5.6932741403579712e-01 3.4788420796394348e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 183 1.3870409689843655e-02</internalNodes>
+          <leafValues>
+            5.3267508745193481e-01 2.2576980292797089e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 184 -2.3674910888075829e-02</internalNodes>
+          <leafValues>
+            1.5513050556182861e-01 5.2007079124450684e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 185 -1.4879409718560055e-05</internalNodes>
+          <leafValues>
+            5.5005669593811035e-01 3.8201761245727539e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 186 3.6190641112625599e-03</internalNodes>
+          <leafValues>
+            4.2386838793754578e-01 6.6397482156753540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 187 -1.9817110151052475e-02</internalNodes>
+          <leafValues>
+            2.1500380337238312e-01 5.3823578357696533e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 188 -3.8154039066284895e-03</internalNodes>
+          <leafValues>
+            6.6757112741470337e-01 4.2152971029281616e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 189 -4.9775829538702965e-03</internalNodes>
+          <leafValues>
+            2.2672890126705170e-01 5.3863281011581421e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 190 2.2441020701080561e-03</internalNodes>
+          <leafValues>
+            4.3086910247802734e-01 6.8557357788085938e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 191 1.2282459996640682e-02</internalNodes>
+          <leafValues>
+            5.8366149663925171e-01 3.4674790501594543e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 192 -2.8548699337989092e-03</internalNodes>
+          <leafValues>
+            7.0169448852539062e-01 4.3114539980888367e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 193 -3.7875669077038765e-03</internalNodes>
+          <leafValues>
+            2.8953450918197632e-01 5.2249461412429810e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 194 -1.2201230274513364e-03</internalNodes>
+          <leafValues>
+            2.9755708575248718e-01 5.4816448688507080e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 195 1.0160599835216999e-02</internalNodes>
+          <leafValues>
+            4.8888179659843445e-01 8.1826978921890259e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 196 -1.6174569725990295e-02</internalNodes>
+          <leafValues>
+            1.4814929664134979e-01 5.2399927377700806e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 197 1.9292460754513741e-02</internalNodes>
+          <leafValues>
+            4.7863098978996277e-01 7.3781907558441162e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 198 -3.2479539513587952e-03</internalNodes>
+          <leafValues>
+            7.3742228746414185e-01 4.4706439971923828e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 199 -9.3803480267524719e-03</internalNodes>
+          <leafValues>
+            3.4891548752784729e-01 5.5379962921142578e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 200 -1.2606129981577396e-02</internalNodes>
+          <leafValues>
+            2.3796869814395905e-01 5.3154432773590088e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 201 -2.5621930137276649e-02</internalNodes>
+          <leafValues>
+            1.9646880030632019e-01 5.1387697458267212e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 202 -7.5741496402770281e-05</internalNodes>
+          <leafValues>
+            5.5905228853225708e-01 3.3658531308174133e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 203 -8.9210882782936096e-02</internalNodes>
+          <leafValues>
+            6.3404656946659088e-02 5.1626348495483398e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 204 -2.7670480776578188e-03</internalNodes>
+          <leafValues>
+            7.3234677314758301e-01 4.4907060265541077e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 205 2.7152578695677221e-04</internalNodes>
+          <leafValues>
+            4.1148349642753601e-01 5.9855180978775024e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>51</maxWeakCount>
+      <stageThreshold>2.4527879714965820e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 206 1.4786219689995050e-03</internalNodes>
+          <leafValues>
+            2.6635450124740601e-01 6.6433167457580566e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 207 -1.8741659587249160e-03</internalNodes>
+          <leafValues>
+            6.1438488960266113e-01 2.5185129046440125e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 208 -1.7151009524241090e-03</internalNodes>
+          <leafValues>
+            5.7663410902023315e-01 2.3974630236625671e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 209 -1.8939269939437509e-03</internalNodes>
+          <leafValues>
+            5.6820458173751831e-01 2.5291448831558228e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 210 -5.3006052039563656e-03</internalNodes>
+          <leafValues>
+            1.6406759619712830e-01 5.5560797452926636e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 211 -4.6662531793117523e-02</internalNodes>
+          <leafValues>
+            6.1231541633605957e-01 4.7628301382064819e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 212 -7.9431332414969802e-04</internalNodes>
+          <leafValues>
+            5.7078588008880615e-01 2.8394040465354919e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 213 1.4891670085489750e-02</internalNodes>
+          <leafValues>
+            4.0896728634834290e-01 6.0063672065734863e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 214 -1.2046529445797205e-03</internalNodes>
+          <leafValues>
+            5.7124507427215576e-01 2.7052891254425049e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 215 6.0619381256401539e-03</internalNodes>
+          <leafValues>
+            5.2625042200088501e-01 3.2622259855270386e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 216 -2.5286648888140917e-03</internalNodes>
+          <leafValues>
+            6.8538308143615723e-01 4.1992568969726562e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 217 -5.9010218828916550e-03</internalNodes>
+          <leafValues>
+            3.2662820816040039e-01 5.4348129034042358e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 218 5.6702760048210621e-03</internalNodes>
+          <leafValues>
+            5.4684108495712280e-01 2.3190039396286011e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 219 -3.0304100364446640e-03</internalNodes>
+          <leafValues>
+            5.5706679821014404e-01 2.7082380652427673e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 220 2.9803649522364140e-03</internalNodes>
+          <leafValues>
+            3.7005689740180969e-01 5.8906257152557373e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 221 -7.5840510427951813e-02</internalNodes>
+          <leafValues>
+            2.1400700509548187e-01 5.4199481010437012e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 222 1.9262539222836494e-02</internalNodes>
+          <leafValues>
+            5.5267721414566040e-01 2.7265900373458862e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 223 1.8888259364757687e-04</internalNodes>
+          <leafValues>
+            3.9580118656158447e-01 6.0172098875045776e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 224 2.9369549825787544e-02</internalNodes>
+          <leafValues>
+            5.2413737773895264e-01 1.4357580244541168e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 225 1.0417619487270713e-03</internalNodes>
+          <leafValues>
+            3.3854091167449951e-01 5.9299832582473755e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 226 2.6125640142709017e-03</internalNodes>
+          <leafValues>
+            5.4853779077529907e-01 3.0215978622436523e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 227 9.6977467183023691e-04</internalNodes>
+          <leafValues>
+            3.3752760291099548e-01 5.5320328474044800e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 228 5.9512659208849072e-04</internalNodes>
+          <leafValues>
+            5.6317430734634399e-01 3.3593991398811340e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 229 -1.0156559944152832e-01</internalNodes>
+          <leafValues>
+            6.3735038042068481e-02 5.2304250001907349e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 230 3.6156699061393738e-02</internalNodes>
+          <leafValues>
+            5.1369631290435791e-01 1.0295289754867554e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 231 3.4624140243977308e-03</internalNodes>
+          <leafValues>
+            3.8793200254440308e-01 5.5582892894744873e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 232 1.9554980099201202e-02</internalNodes>
+          <leafValues>
+            5.2500867843627930e-01 1.8758599460124969e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 233 -2.3121440317481756e-03</internalNodes>
+          <leafValues>
+            6.6720288991928101e-01 4.6796411275863647e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 234 -1.8605289515107870e-03</internalNodes>
+          <leafValues>
+            7.1633791923522949e-01 4.3346709012985229e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 235 -9.4026362057775259e-04</internalNodes>
+          <leafValues>
+            3.0213609337806702e-01 5.6502032279968262e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 236 -5.2418331615626812e-03</internalNodes>
+          <leafValues>
+            1.8200090527534485e-01 5.2502560615539551e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 237 1.1729019752237946e-04</internalNodes>
+          <leafValues>
+            3.3891880512237549e-01 5.4459732770919800e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 238 1.1878840159624815e-03</internalNodes>
+          <leafValues>
+            4.0853491425514221e-01 6.2535631656646729e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 239 -1.0881359688937664e-02</internalNodes>
+          <leafValues>
+            3.3783990144729614e-01 5.7000827789306641e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 240 1.7354859737679362e-03</internalNodes>
+          <leafValues>
+            4.2046359181404114e-01 6.5230387449264526e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 241 -6.5119052305817604e-03</internalNodes>
+          <leafValues>
+            2.5952160358428955e-01 5.4281437397003174e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 242 -1.2136430013924837e-03</internalNodes>
+          <leafValues>
+            6.1651438474655151e-01 3.9778938889503479e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 243 -1.0354240424931049e-02</internalNodes>
+          <leafValues>
+            1.6280280053615570e-01 5.2195048332214355e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 244 5.5858830455690622e-04</internalNodes>
+          <leafValues>
+            3.1996509432792664e-01 5.5035740137100220e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 245 1.5299649909138680e-02</internalNodes>
+          <leafValues>
+            4.1039940714836121e-01 6.1223882436752319e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 246 -2.1588210016489029e-02</internalNodes>
+          <leafValues>
+            1.0349129885435104e-01 5.1973849534988403e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 247 -1.2834629416465759e-01</internalNodes>
+          <leafValues>
+            8.4938651323318481e-01 4.8931029438972473e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 248 -2.2927189711481333e-03</internalNodes>
+          <leafValues>
+            3.1301578879356384e-01 5.4715752601623535e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 249 7.9915106296539307e-02</internalNodes>
+          <leafValues>
+            4.8563209176063538e-01 6.0739892721176147e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 250 -7.9441092908382416e-02</internalNodes>
+          <leafValues>
+            8.3946740627288818e-01 4.6245330572128296e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 251 -5.2800010889768600e-03</internalNodes>
+          <leafValues>
+            1.8816959857940674e-01 5.3066980838775635e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 252 1.0463109938427806e-03</internalNodes>
+          <leafValues>
+            5.2712291479110718e-01 2.5830659270286560e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 253 2.6317298761568964e-04</internalNodes>
+          <leafValues>
+            4.2353048920631409e-01 5.7354408502578735e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 254 -3.6173160187900066e-03</internalNodes>
+          <leafValues>
+            6.9343960285186768e-01 4.4954448938369751e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 255 1.1421879753470421e-02</internalNodes>
+          <leafValues>
+            5.9009212255477905e-01 4.1381931304931641e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 256 -1.9963278900831938e-03</internalNodes>
+          <leafValues>
+            6.4663827419281006e-01 4.3272399902343750e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>56</maxWeakCount>
+      <stageThreshold>2.7153350830078125e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 257 -9.9691245704889297e-03</internalNodes>
+          <leafValues>
+            6.1423242092132568e-01 2.4822120368480682e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 258 7.3073059320449829e-04</internalNodes>
+          <leafValues>
+            5.7049518823623657e-01 2.3219659924507141e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 259 6.4045301405712962e-04</internalNodes>
+          <leafValues>
+            2.1122519671916962e-01 5.8149331808090210e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 260 4.5424019917845726e-03</internalNodes>
+          <leafValues>
+            2.9504820704460144e-01 5.8663117885589600e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 261 9.2477443104144186e-05</internalNodes>
+          <leafValues>
+            2.9909908771514893e-01 5.7913267612457275e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 262 -8.6603146046400070e-03</internalNodes>
+          <leafValues>
+            2.8130298852920532e-01 5.6355422735214233e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 263 8.0515816807746887e-03</internalNodes>
+          <leafValues>
+            3.5353690385818481e-01 6.0547572374343872e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 264 4.3835240649059415e-04</internalNodes>
+          <leafValues>
+            5.5965322256088257e-01 2.7315109968185425e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 265 -9.8168973636347800e-05</internalNodes>
+          <leafValues>
+            5.9780317544937134e-01 3.6385610699653625e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 266 -1.1298790341243148e-03</internalNodes>
+          <leafValues>
+            2.7552521228790283e-01 5.4327291250228882e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 267 6.4356150105595589e-03</internalNodes>
+          <leafValues>
+            4.3056419491767883e-01 7.0698332786560059e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 268 -5.6829329580068588e-02</internalNodes>
+          <leafValues>
+            2.4952429533004761e-01 5.2949970960617065e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 269 4.0668169967830181e-03</internalNodes>
+          <leafValues>
+            5.4785531759262085e-01 2.4977239966392517e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 270 4.8164798499783501e-05</internalNodes>
+          <leafValues>
+            3.9386010169982910e-01 5.7063561677932739e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 271 6.1795017682015896e-03</internalNodes>
+          <leafValues>
+            4.4076061248779297e-01 7.3947668075561523e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 272 6.4985752105712891e-03</internalNodes>
+          <leafValues>
+            5.4452431201934814e-01 2.4791529774665833e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 273 -1.0211090557277203e-03</internalNodes>
+          <leafValues>
+            2.5447669625282288e-01 5.3389710187911987e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 274 -5.4247528314590454e-03</internalNodes>
+          <leafValues>
+            2.7188581228256226e-01 5.3240692615509033e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 275 -1.0559899965301156e-03</internalNodes>
+          <leafValues>
+            3.1782880425453186e-01 5.5345088243484497e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 276 6.6465808777138591e-04</internalNodes>
+          <leafValues>
+            4.2842191457748413e-01 6.5581941604614258e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 277 -2.7524109464138746e-04</internalNodes>
+          <leafValues>
+            5.9028607606887817e-01 3.8102629780769348e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 278 4.2293202131986618e-03</internalNodes>
+          <leafValues>
+            3.8164898753166199e-01 5.7093858718872070e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 279 -3.2868210691958666e-03</internalNodes>
+          <leafValues>
+            1.7477439343929291e-01 5.2595442533493042e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 280 1.5611879643984139e-04</internalNodes>
+          <leafValues>
+            3.6017221212387085e-01 5.7256120443344116e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 281 -7.3621381488919724e-06</internalNodes>
+          <leafValues>
+            5.4018580913543701e-01 3.0444970726966858e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 282 -1.4767250046133995e-02</internalNodes>
+          <leafValues>
+            3.2207700610160828e-01 5.5734348297119141e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 283 2.4489590898156166e-02</internalNodes>
+          <leafValues>
+            4.3015280365943909e-01 6.5188127756118774e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 284 -3.7652091123163700e-04</internalNodes>
+          <leafValues>
+            3.5645830631256104e-01 5.5982369184494019e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 285 7.3657688517414499e-06</internalNodes>
+          <leafValues>
+            3.4907829761505127e-01 5.5618977546691895e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 286 -1.5099939890205860e-02</internalNodes>
+          <leafValues>
+            1.7762720584869385e-01 5.3352999687194824e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 287 -3.8316650316119194e-03</internalNodes>
+          <leafValues>
+            6.1496877670288086e-01 4.2213940620422363e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 288 1.6925400123000145e-02</internalNodes>
+          <leafValues>
+            5.4130148887634277e-01 2.1665850281715393e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 289 -3.0477850232273340e-03</internalNodes>
+          <leafValues>
+            6.4494907855987549e-01 4.3546178936958313e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 290 3.2140589319169521e-03</internalNodes>
+          <leafValues>
+            5.4001551866531372e-01 3.5232171416282654e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 291 -4.0023201145231724e-03</internalNodes>
+          <leafValues>
+            2.7745240926742554e-01 5.3384172916412354e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 292 7.4182129465043545e-03</internalNodes>
+          <leafValues>
+            5.6767392158508301e-01 3.7028178572654724e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 293 -8.8764587417244911e-03</internalNodes>
+          <leafValues>
+            7.7492219209671021e-01 4.5836889743804932e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 294 2.7311739977449179e-03</internalNodes>
+          <leafValues>
+            5.3387218713760376e-01 3.9966610074043274e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 295 -2.5082379579544067e-03</internalNodes>
+          <leafValues>
+            5.6119632720947266e-01 3.7774989008903503e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 296 -8.0541074275970459e-03</internalNodes>
+          <leafValues>
+            2.9152289032936096e-01 5.1791828870773315e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 297 -9.7938813269138336e-04</internalNodes>
+          <leafValues>
+            5.5364328622817993e-01 3.7001928687095642e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 298 -5.8745909482240677e-03</internalNodes>
+          <leafValues>
+            3.7543910741806030e-01 5.6793761253356934e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 299 -4.4936719350516796e-03</internalNodes>
+          <leafValues>
+            7.0196992158889771e-01 4.4809499382972717e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 300 -5.4389229044318199e-03</internalNodes>
+          <leafValues>
+            2.3103649914264679e-01 5.3133869171142578e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 301 -7.5094640487805009e-04</internalNodes>
+          <leafValues>
+            5.8648687601089478e-01 4.1293430328369141e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 302 1.4528800420521293e-05</internalNodes>
+          <leafValues>
+            3.7324070930480957e-01 5.6196212768554688e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 303 4.0758069604635239e-02</internalNodes>
+          <leafValues>
+            5.3120911121368408e-01 2.7205219864845276e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 304 6.6505931317806244e-03</internalNodes>
+          <leafValues>
+            4.7100159525871277e-01 6.6934937238693237e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 305 4.5759351924061775e-03</internalNodes>
+          <leafValues>
+            5.1678192615509033e-01 1.6372759640216827e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 306 6.5269311890006065e-03</internalNodes>
+          <leafValues>
+            5.3976088762283325e-01 2.9385319352149963e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 307 -1.3660379685461521e-02</internalNodes>
+          <leafValues>
+            7.0864880084991455e-01 4.5322000980377197e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 308 2.7358869090676308e-02</internalNodes>
+          <leafValues>
+            5.2064812183380127e-01 3.5892319679260254e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 309 6.2197551596909761e-04</internalNodes>
+          <leafValues>
+            3.5070759057998657e-01 5.4411232471466064e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 310 -3.3077080734074116e-03</internalNodes>
+          <leafValues>
+            5.8595228195190430e-01 4.0248918533325195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 311 -1.0631109587848186e-02</internalNodes>
+          <leafValues>
+            6.7432671785354614e-01 4.4226029515266418e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 312 1.9441649317741394e-02</internalNodes>
+          <leafValues>
+            5.2827161550521851e-01 1.7979049682617188e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>71</maxWeakCount>
+      <stageThreshold>3.4554111480712891e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 313 -5.5052167735993862e-03</internalNodes>
+          <leafValues>
+            5.9147310256958008e-01 2.6265591382980347e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 314 1.9562279339879751e-03</internalNodes>
+          <leafValues>
+            2.3125819861888885e-01 5.7416272163391113e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 315 -8.8924784213304520e-03</internalNodes>
+          <leafValues>
+            1.6565300524234772e-01 5.6266540288925171e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 316 8.3638377487659454e-02</internalNodes>
+          <leafValues>
+            5.4234498739242554e-01 1.9572949409484863e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 317 1.2282270472496748e-03</internalNodes>
+          <leafValues>
+            3.4179040789604187e-01 5.9925037622451782e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 318 5.7629169896245003e-03</internalNodes>
+          <leafValues>
+            3.7195819616317749e-01 6.0799038410186768e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 319 -1.6417410224676132e-03</internalNodes>
+          <leafValues>
+            2.5774860382080078e-01 5.5769157409667969e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 320 3.4113149158656597e-03</internalNodes>
+          <leafValues>
+            2.9507490992546082e-01 5.5141717195510864e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 321 -1.1069320142269135e-02</internalNodes>
+          <leafValues>
+            7.5693589448928833e-01 4.4770789146423340e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 322 3.4865971654653549e-02</internalNodes>
+          <leafValues>
+            5.5837088823318481e-01 2.6696211099624634e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 323 6.5701099811121821e-04</internalNodes>
+          <leafValues>
+            5.6273132562637329e-01 2.9888901114463806e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 324 -2.4339130148291588e-02</internalNodes>
+          <leafValues>
+            2.7711850404739380e-01 5.1088631153106689e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 325 5.9435202274471521e-04</internalNodes>
+          <leafValues>
+            5.5806517601013184e-01 3.1203418970108032e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 326 2.2971509024500847e-03</internalNodes>
+          <leafValues>
+            3.3302500844001770e-01 5.6790757179260254e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 327 -3.7801829166710377e-03</internalNodes>
+          <leafValues>
+            2.9905349016189575e-01 5.3448081016540527e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 328 -1.3420669734477997e-01</internalNodes>
+          <leafValues>
+            1.4638589322566986e-01 5.3925681114196777e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 329 7.5224548345431685e-04</internalNodes>
+          <leafValues>
+            3.7469539046287537e-01 5.6927347183227539e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 330 -4.0545541793107986e-02</internalNodes>
+          <leafValues>
+            2.7547478675842285e-01 5.4842978715896606e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 331 1.2572970008477569e-03</internalNodes>
+          <leafValues>
+            3.7445840239524841e-01 5.7560759782791138e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 332 -7.4249948374927044e-03</internalNodes>
+          <leafValues>
+            7.5138592720031738e-01 4.7282311320304871e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 333 5.0908129196614027e-04</internalNodes>
+          <leafValues>
+            5.4048967361450195e-01 2.9323211312294006e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 334 -1.2808450264856219e-03</internalNodes>
+          <leafValues>
+            6.1697798967361450e-01 4.2733490467071533e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 335 -1.8348860321566463e-03</internalNodes>
+          <leafValues>
+            2.0484960079193115e-01 5.2064722776412964e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 336 2.7484869584441185e-02</internalNodes>
+          <leafValues>
+            5.2529847621917725e-01 1.6755220293998718e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 337 2.2372419480234385e-03</internalNodes>
+          <leafValues>
+            5.2677828073501587e-01 2.7776581048965454e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 338 -8.8635291904211044e-03</internalNodes>
+          <leafValues>
+            6.9545578956604004e-01 4.8120489716529846e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 339 4.1753971017897129e-03</internalNodes>
+          <leafValues>
+            4.2918878793716431e-01 6.3491958379745483e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 340 -1.7098189564421773e-03</internalNodes>
+          <leafValues>
+            2.9305368661880493e-01 5.3612488508224487e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 341 6.5328548662364483e-03</internalNodes>
+          <leafValues>
+            4.4953250885009766e-01 7.4096941947937012e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 342 -9.5372907817363739e-03</internalNodes>
+          <leafValues>
+            3.1491199135780334e-01 5.4165017604827881e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 343 2.5310989469289780e-02</internalNodes>
+          <leafValues>
+            5.1218920946121216e-01 1.3117079436779022e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 344 3.6460969597101212e-02</internalNodes>
+          <leafValues>
+            5.1759117841720581e-01 2.5913399457931519e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 345 2.0854329690337181e-02</internalNodes>
+          <leafValues>
+            5.1371401548385620e-01 1.5823160111904144e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 346 -8.7207747856155038e-04</internalNodes>
+          <leafValues>
+            5.5743098258972168e-01 4.3989789485931396e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 347 -1.5227000403683633e-05</internalNodes>
+          <leafValues>
+            5.5489408969879150e-01 3.7080699205398560e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 348 -8.4316509310156107e-04</internalNodes>
+          <leafValues>
+            3.3874198794364929e-01 5.5542111396789551e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 349 3.6037859972566366e-03</internalNodes>
+          <leafValues>
+            5.3580617904663086e-01 3.4111711382865906e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 350 -6.8057891912758350e-03</internalNodes>
+          <leafValues>
+            6.1252027750015259e-01 4.3458628654479980e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 351 -4.7021660953760147e-02</internalNodes>
+          <leafValues>
+            2.3581659793853760e-01 5.1937389373779297e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 352 -3.6954108625650406e-02</internalNodes>
+          <leafValues>
+            7.3231112957000732e-01 4.7609439492225647e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 353 1.0439479956403375e-03</internalNodes>
+          <leafValues>
+            5.4194551706314087e-01 3.4113308787345886e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 354 -2.1050689974799752e-04</internalNodes>
+          <leafValues>
+            2.8216940164566040e-01 5.5549472570419312e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 355 -8.0831587314605713e-02</internalNodes>
+          <leafValues>
+            9.1299301385879517e-01 4.6974349021911621e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 356 -3.6579059087671340e-04</internalNodes>
+          <leafValues>
+            6.0226702690124512e-01 3.9782929420471191e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 357 -1.2545920617412776e-04</internalNodes>
+          <leafValues>
+            5.6132131814956665e-01 3.8455399870872498e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 358 -6.8786486983299255e-02</internalNodes>
+          <leafValues>
+            2.2616119682788849e-01 5.3004968166351318e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 359 1.2415789999067783e-02</internalNodes>
+          <leafValues>
+            4.0756919980049133e-01 5.8288121223449707e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 360 -4.7174817882478237e-03</internalNodes>
+          <leafValues>
+            2.8272539377212524e-01 5.2677577733993530e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 361 3.8136858493089676e-02</internalNodes>
+          <leafValues>
+            5.0747412443161011e-01 1.0236159712076187e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 362 -2.8168049175292253e-03</internalNodes>
+          <leafValues>
+            6.1690068244934082e-01 4.3596929311752319e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 363 8.1303603947162628e-03</internalNodes>
+          <leafValues>
+            4.5244330167770386e-01 7.6060950756072998e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 364 6.0056019574403763e-03</internalNodes>
+          <leafValues>
+            5.2404087781906128e-01 1.8597120046615601e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 365 1.9139319658279419e-02</internalNodes>
+          <leafValues>
+            5.2093791961669922e-01 2.3320719599723816e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 366 1.6445759683847427e-02</internalNodes>
+          <leafValues>
+            5.4507029056549072e-01 3.2642349600791931e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 367 -3.7356890738010406e-02</internalNodes>
+          <leafValues>
+            6.9990468025207520e-01 4.5332419872283936e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 368 -1.9727900624275208e-02</internalNodes>
+          <leafValues>
+            2.6536649465560913e-01 5.4128098487854004e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 369 6.6972579807043076e-03</internalNodes>
+          <leafValues>
+            4.4805660843849182e-01 7.1386522054672241e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 370 7.4457528535276651e-04</internalNodes>
+          <leafValues>
+            4.2313501238822937e-01 5.4713201522827148e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 371 1.1790640419349074e-03</internalNodes>
+          <leafValues>
+            5.3417021036148071e-01 3.1304550170898438e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 372 3.4980610013008118e-02</internalNodes>
+          <leafValues>
+            5.1186597347259521e-01 3.4305301308631897e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 373 5.6859792675822973e-04</internalNodes>
+          <leafValues>
+            3.5321870446205139e-01 5.4686397314071655e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 374 -1.1340649798512459e-02</internalNodes>
+          <leafValues>
+            2.8423538804054260e-01 5.3487008810043335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 375 -6.6228108480572701e-03</internalNodes>
+          <leafValues>
+            6.8836402893066406e-01 4.4926649332046509e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 376 -8.0160330981016159e-03</internalNodes>
+          <leafValues>
+            1.7098939418792725e-01 5.2243089675903320e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 377 1.4206819469109178e-03</internalNodes>
+          <leafValues>
+            5.2908462285995483e-01 2.9933831095695496e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 378 -2.7801711112260818e-03</internalNodes>
+          <leafValues>
+            6.4988541603088379e-01 4.4604998826980591e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 379 -1.4747589593753219e-03</internalNodes>
+          <leafValues>
+            3.2604381442070007e-01 5.3881132602691650e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 380 -2.3830339312553406e-02</internalNodes>
+          <leafValues>
+            7.5289410352706909e-01 4.8012199997901917e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 381 6.9369790144264698e-03</internalNodes>
+          <leafValues>
+            5.3351658582687378e-01 3.2614278793334961e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 382 8.2806255668401718e-03</internalNodes>
+          <leafValues>
+            4.5803940296173096e-01 5.7378298044204712e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 383 -1.0439500212669373e-02</internalNodes>
+          <leafValues>
+            2.5923201441764832e-01 5.2338278293609619e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>80</maxWeakCount>
+      <stageThreshold>3.9107288360595703e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 384 7.2006587870419025e-03</internalNodes>
+          <leafValues>
+            3.2588860392570496e-01 6.8498080968856812e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 385 -2.8593589086085558e-03</internalNodes>
+          <leafValues>
+            5.8388811349868774e-01 2.5378298759460449e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 386 6.8580528022721410e-04</internalNodes>
+          <leafValues>
+            5.7080817222595215e-01 2.8124240040779114e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 387 7.9580191522836685e-03</internalNodes>
+          <leafValues>
+            2.5010511279106140e-01 5.5442607402801514e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 388 -1.2124150525778532e-03</internalNodes>
+          <leafValues>
+            2.3853680491447449e-01 5.4333502054214478e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 389 7.9426132142543793e-03</internalNodes>
+          <leafValues>
+            3.9550709724426270e-01 6.2207579612731934e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 390 2.4630590341985226e-03</internalNodes>
+          <leafValues>
+            5.6397080421447754e-01 2.9923579096794128e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 391 -6.0396599583327770e-03</internalNodes>
+          <leafValues>
+            2.1865129470825195e-01 5.4116767644882202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 392 -1.2988339876756072e-03</internalNodes>
+          <leafValues>
+            2.3507060110569000e-01 5.3645849227905273e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 393 2.2299369447864592e-04</internalNodes>
+          <leafValues>
+            3.8041129708290100e-01 5.7296061515808105e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 394 1.4654280385002494e-03</internalNodes>
+          <leafValues>
+            2.5101679563522339e-01 5.2582687139511108e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 395 -8.1210042117163539e-04</internalNodes>
+          <leafValues>
+            5.9928238391876221e-01 3.8511589169502258e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 396 -1.3836020370945334e-03</internalNodes>
+          <leafValues>
+            5.6813961267471313e-01 3.6365869641304016e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 397 -2.7936449274420738e-02</internalNodes>
+          <leafValues>
+            1.4913170039653778e-01 5.3775602579116821e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 398 -4.6919551095925272e-04</internalNodes>
+          <leafValues>
+            3.6924299597740173e-01 5.5724847316741943e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 399 -4.9829659983515739e-03</internalNodes>
+          <leafValues>
+            6.7585092782974243e-01 4.5325040817260742e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 400 1.8815309740602970e-03</internalNodes>
+          <leafValues>
+            5.3680229187011719e-01 2.9325398802757263e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 401 -1.9067550078034401e-02</internalNodes>
+          <leafValues>
+            1.6493770480155945e-01 5.3300672769546509e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 402 -4.6906559728085995e-03</internalNodes>
+          <leafValues>
+            1.9639259576797485e-01 5.1193618774414062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 403 5.9777139686048031e-03</internalNodes>
+          <leafValues>
+            4.6711719036102295e-01 7.0083981752395630e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 404 -3.3303130418062210e-02</internalNodes>
+          <leafValues>
+            1.1554169654846191e-01 5.1041620969772339e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 405 9.0744107961654663e-02</internalNodes>
+          <leafValues>
+            5.1496601104736328e-01 1.3061730563640594e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 406 9.3555898638442159e-04</internalNodes>
+          <leafValues>
+            3.6054810881614685e-01 5.4398590326309204e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 407 1.4901650138199329e-02</internalNodes>
+          <leafValues>
+            4.8862120509147644e-01 7.6875698566436768e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 408 6.1594118596985936e-04</internalNodes>
+          <leafValues>
+            5.3568130731582642e-01 3.2409390807151794e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 409 -5.0670988857746124e-02</internalNodes>
+          <leafValues>
+            1.8486219644546509e-01 5.2304041385650635e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 410 6.8665749859064817e-04</internalNodes>
+          <leafValues>
+            3.8405799865722656e-01 5.5179458856582642e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 411 8.3712432533502579e-03</internalNodes>
+          <leafValues>
+            4.2885640263557434e-01 6.1317539215087891e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 412 -1.2953069526702166e-03</internalNodes>
+          <leafValues>
+            2.9136741161346436e-01 5.2807378768920898e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 413 -4.1941680014133453e-02</internalNodes>
+          <leafValues>
+            7.5547999143600464e-01 4.8560309410095215e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 414 -2.3529380559921265e-02</internalNodes>
+          <leafValues>
+            2.8382799029350281e-01 5.2560812234878540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 415 4.0857449173927307e-02</internalNodes>
+          <leafValues>
+            4.8709350824356079e-01 6.2772971391677856e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 416 -2.5406869128346443e-02</internalNodes>
+          <leafValues>
+            7.0997077226638794e-01 4.5750290155410767e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 417 -4.1415440500713885e-04</internalNodes>
+          <leafValues>
+            4.0308868885040283e-01 5.4694122076034546e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 418 2.1824119612574577e-02</internalNodes>
+          <leafValues>
+            4.5020240545272827e-01 6.7687010765075684e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 419 1.4114039950072765e-02</internalNodes>
+          <leafValues>
+            5.4428607225418091e-01 3.7917000055313110e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 420 6.7214590671937913e-05</internalNodes>
+          <leafValues>
+            4.2004638910293579e-01 5.8734762668609619e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 421 -7.9417638480663300e-03</internalNodes>
+          <leafValues>
+            3.7925618886947632e-01 5.5852657556533813e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 422 -7.2144409641623497e-03</internalNodes>
+          <leafValues>
+            7.2531038522720337e-01 4.6035489439964294e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 423 2.5817339774221182e-03</internalNodes>
+          <leafValues>
+            4.6933019161224365e-01 5.9002387523651123e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 424 1.3409319519996643e-01</internalNodes>
+          <leafValues>
+            5.1492130756378174e-01 1.8088449537754059e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 425 2.2962710354477167e-03</internalNodes>
+          <leafValues>
+            5.3997439146041870e-01 3.7178671360015869e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 426 -2.1575849968940020e-03</internalNodes>
+          <leafValues>
+            2.4084959924221039e-01 5.1488637924194336e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 427 -4.9196188338100910e-03</internalNodes>
+          <leafValues>
+            6.5735882520675659e-01 4.7387400269508362e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 428 1.6267469618469477e-03</internalNodes>
+          <leafValues>
+            4.1928219795227051e-01 6.3031142950057983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 429 3.3413388882763684e-04</internalNodes>
+          <leafValues>
+            5.5402982234954834e-01 3.7021011114120483e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 430 -2.6698080822825432e-02</internalNodes>
+          <leafValues>
+            1.7109179496765137e-01 5.1014107465744019e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 431 -3.0561879277229309e-02</internalNodes>
+          <leafValues>
+            1.9042180478572845e-01 5.1687937974929810e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 432 2.8511548880487680e-03</internalNodes>
+          <leafValues>
+            4.4475069642066956e-01 6.3138538599014282e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 433 -3.6211479455232620e-02</internalNodes>
+          <leafValues>
+            2.4907270073890686e-01 5.3773492574691772e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 434 -2.4115189444273710e-03</internalNodes>
+          <leafValues>
+            5.3812432289123535e-01 3.6642369627952576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 435 -7.7253201743587852e-04</internalNodes>
+          <leafValues>
+            5.5302321910858154e-01 3.5415500402450562e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 436 2.9481729143299162e-04</internalNodes>
+          <leafValues>
+            4.1326990723609924e-01 5.6672430038452148e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 437 -6.2334560789167881e-03</internalNodes>
+          <leafValues>
+            9.8787233233451843e-02 5.1986688375473022e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 438 -2.6274729520082474e-02</internalNodes>
+          <leafValues>
+            9.1127492487430573e-02 5.0281071662902832e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 439 5.3212260827422142e-03</internalNodes>
+          <leafValues>
+            4.7266489267349243e-01 6.2227207422256470e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 440 -4.1129058226943016e-03</internalNodes>
+          <leafValues>
+            2.1574570238590240e-01 5.1378047466278076e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 441 3.2457809429615736e-03</internalNodes>
+          <leafValues>
+            5.4107707738876343e-01 3.7217769026756287e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 442 -1.6359709203243256e-02</internalNodes>
+          <leafValues>
+            7.7878749370574951e-01 4.6852919459342957e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 443 3.2166109303943813e-04</internalNodes>
+          <leafValues>
+            5.4789870977401733e-01 4.2403739690780640e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 444 6.4452440710738301e-04</internalNodes>
+          <leafValues>
+            5.3305608034133911e-01 3.5013249516487122e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 445 -7.8909732401371002e-03</internalNodes>
+          <leafValues>
+            6.9235211610794067e-01 4.7265690565109253e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 446 4.8336211591959000e-02</internalNodes>
+          <leafValues>
+            5.0559002161026001e-01 7.5749203562736511e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 447 -7.5178127735853195e-04</internalNodes>
+          <leafValues>
+            3.7837418913841248e-01 5.5385738611221313e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 448 -2.4953910615295172e-03</internalNodes>
+          <leafValues>
+            3.0816510319709778e-01 5.3596121072769165e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 449 -2.2385010961443186e-03</internalNodes>
+          <leafValues>
+            6.6339588165283203e-01 4.6493428945541382e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 450 -1.7988430336117744e-03</internalNodes>
+          <leafValues>
+            6.5968447923660278e-01 4.3471878767013550e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 451 8.7860915809869766e-03</internalNodes>
+          <leafValues>
+            5.2318328619003296e-01 2.3155799508094788e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 452 3.6715380847454071e-03</internalNodes>
+          <leafValues>
+            5.2042502164840698e-01 2.9773768782615662e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 453 -3.5336449742317200e-02</internalNodes>
+          <leafValues>
+            7.2388780117034912e-01 4.8615050315856934e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 454 -6.9189240457490087e-04</internalNodes>
+          <leafValues>
+            3.1050220131874084e-01 5.2298247814178467e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 455 -3.3946109469980001e-03</internalNodes>
+          <leafValues>
+            3.1389680504798889e-01 5.2101737260818481e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 456 9.8569283727556467e-04</internalNodes>
+          <leafValues>
+            4.5365801453590393e-01 6.5850979089736938e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 457 -5.0163101404905319e-02</internalNodes>
+          <leafValues>
+            1.8044540286064148e-01 5.1989167928695679e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 458 -2.2367259953171015e-03</internalNodes>
+          <leafValues>
+            7.2557020187377930e-01 4.6513590216636658e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 459 7.4326287722215056e-04</internalNodes>
+          <leafValues>
+            4.4129210710525513e-01 5.8985459804534912e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 460 -9.3485182151198387e-04</internalNodes>
+          <leafValues>
+            3.5000529885292053e-01 5.3660178184509277e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 461 1.7497939988970757e-02</internalNodes>
+          <leafValues>
+            4.9121949076652527e-01 8.3152848482131958e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 462 -1.5200000489130616e-03</internalNodes>
+          <leafValues>
+            3.5702759027481079e-01 5.3705602884292603e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 463 7.8003940870985389e-04</internalNodes>
+          <leafValues>
+            4.3537721037864685e-01 5.9673351049423218e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>103</maxWeakCount>
+      <stageThreshold>5.0610481262207031e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 464 -9.9945552647113800e-03</internalNodes>
+          <leafValues>
+            6.1625832319259644e-01 3.0545330047607422e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 465 -1.1085229925811291e-03</internalNodes>
+          <leafValues>
+            5.8182948827743530e-01 3.1555780768394470e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 466 1.0364380432292819e-03</internalNodes>
+          <leafValues>
+            2.5520521402359009e-01 5.6929117441177368e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 467 6.8211311008781195e-04</internalNodes>
+          <leafValues>
+            3.6850899457931519e-01 5.9349310398101807e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 468 -6.8057340104132891e-04</internalNodes>
+          <leafValues>
+            2.3323920369148254e-01 5.4747921228408813e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 469 2.6068789884448051e-04</internalNodes>
+          <leafValues>
+            3.2574570178985596e-01 5.6675457954406738e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 470 5.1607372006401420e-04</internalNodes>
+          <leafValues>
+            3.7447169423103333e-01 5.8454728126525879e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 471 8.5007521556690335e-04</internalNodes>
+          <leafValues>
+            3.4203711152076721e-01 5.5228072404861450e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 472 -1.8607829697430134e-03</internalNodes>
+          <leafValues>
+            2.8044199943542480e-01 5.3754240274429321e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 473 -1.5033970121294260e-03</internalNodes>
+          <leafValues>
+            2.5790509581565857e-01 5.4989522695541382e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 474 2.3478909861296415e-03</internalNodes>
+          <leafValues>
+            4.1751560568809509e-01 6.3137108087539673e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 475 -2.8880240279249847e-04</internalNodes>
+          <leafValues>
+            5.8651697635650635e-01 4.0526661276817322e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 476 8.9405477046966553e-03</internalNodes>
+          <leafValues>
+            5.2111411094665527e-01 2.3186540603637695e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 477 -1.9327739253640175e-02</internalNodes>
+          <leafValues>
+            2.7534329891204834e-01 5.2415257692337036e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 478 -2.0202060113660991e-04</internalNodes>
+          <leafValues>
+            5.7229787111282349e-01 3.6771959066390991e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 479 2.1179069299250841e-03</internalNodes>
+          <leafValues>
+            4.4661080837249756e-01 5.5424308776855469e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 480 -1.7743760254234076e-03</internalNodes>
+          <leafValues>
+            2.8132531046867371e-01 5.3009599447250366e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 481 4.2234458960592747e-03</internalNodes>
+          <leafValues>
+            4.3997099995613098e-01 5.7954281568527222e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 482 -1.4375220052897930e-02</internalNodes>
+          <leafValues>
+            2.9811179637908936e-01 5.2920591831207275e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 483 -1.5349180437624454e-02</internalNodes>
+          <leafValues>
+            7.7052152156829834e-01 4.7481718659400940e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 484 1.5152279956964776e-05</internalNodes>
+          <leafValues>
+            3.7188440561294556e-01 5.5768972635269165e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 485 -9.1293919831514359e-03</internalNodes>
+          <leafValues>
+            3.6151960492134094e-01 5.2867668867111206e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 486 2.2512159775942564e-03</internalNodes>
+          <leafValues>
+            5.3647047281265259e-01 3.4862980246543884e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 487 -4.9696918576955795e-03</internalNodes>
+          <leafValues>
+            6.9276517629623413e-01 4.6768361330032349e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 488 -1.2829010374844074e-02</internalNodes>
+          <leafValues>
+            7.7121537923812866e-01 4.6607351303100586e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 489 -9.3660065904259682e-03</internalNodes>
+          <leafValues>
+            3.3749839663505554e-01 5.3512877225875854e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 490 3.2452319283038378e-03</internalNodes>
+          <leafValues>
+            5.3251898288726807e-01 3.2896101474761963e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 491 -1.1723560281097889e-02</internalNodes>
+          <leafValues>
+            6.8376529216766357e-01 4.7543001174926758e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 492 2.9257940695970319e-05</internalNodes>
+          <leafValues>
+            3.5720878839492798e-01 5.3605020046234131e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 493 -2.2244219508138485e-05</internalNodes>
+          <leafValues>
+            5.5414271354675293e-01 3.5520640015602112e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 494 5.0881509669125080e-03</internalNodes>
+          <leafValues>
+            5.0708442926406860e-01 1.2564620375633240e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 495 2.7429679408669472e-02</internalNodes>
+          <leafValues>
+            5.2695602178573608e-01 1.6258180141448975e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 496 -6.4142867922782898e-03</internalNodes>
+          <leafValues>
+            7.1455889940261841e-01 4.5841971039772034e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 497 3.3479959238320589e-03</internalNodes>
+          <leafValues>
+            5.3986120223999023e-01 3.4946969151496887e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 498 -8.2635492086410522e-02</internalNodes>
+          <leafValues>
+            2.4391929805278778e-01 5.1602262258529663e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 499 1.0261740535497665e-03</internalNodes>
+          <leafValues>
+            3.8868919014930725e-01 5.7679080963134766e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 500 -1.6307090409100056e-03</internalNodes>
+          <leafValues>
+            3.3894580602645874e-01 5.3477007150650024e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 501 2.4546680506318808e-03</internalNodes>
+          <leafValues>
+            4.6014139056205750e-01 6.3872468471527100e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 502 -9.9476519972085953e-04</internalNodes>
+          <leafValues>
+            5.7698792219161987e-01 4.1203960776329041e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 503 1.5409190207719803e-02</internalNodes>
+          <leafValues>
+            4.8787090182304382e-01 7.0898222923278809e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 504 1.1784400558099151e-03</internalNodes>
+          <leafValues>
+            5.2635532617568970e-01 2.8952449560165405e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 505 -2.7701919898390770e-02</internalNodes>
+          <leafValues>
+            1.4988289773464203e-01 5.2196067571640015e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 506 -2.9505399987101555e-02</internalNodes>
+          <leafValues>
+            2.4893319234251976e-02 4.9998161196708679e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 507 4.5159430010244250e-04</internalNodes>
+          <leafValues>
+            5.4646229743957520e-01 4.0296629071235657e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 508 7.1772639639675617e-03</internalNodes>
+          <leafValues>
+            4.2710569500923157e-01 5.8662968873977661e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 509 -7.4182048439979553e-02</internalNodes>
+          <leafValues>
+            6.8741792440414429e-01 4.9190279841423035e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 510 -1.7254160717129707e-02</internalNodes>
+          <leafValues>
+            3.3706760406494141e-01 5.3487390279769897e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 511 1.4851559884846210e-02</internalNodes>
+          <leafValues>
+            4.6267929673194885e-01 6.1299049854278564e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 512 1.0002000257372856e-02</internalNodes>
+          <leafValues>
+            5.3461229801177979e-01 3.4234538674354553e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 513 2.0138120744377375e-03</internalNodes>
+          <leafValues>
+            4.6438300609588623e-01 5.8243042230606079e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 514 1.5135470312088728e-03</internalNodes>
+          <leafValues>
+            5.1963961124420166e-01 2.8561499714851379e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 515 3.1381431035697460e-03</internalNodes>
+          <leafValues>
+            4.8381629586219788e-01 5.9585297107696533e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 516 -5.1450440660119057e-03</internalNodes>
+          <leafValues>
+            8.9203029870986938e-01 4.7414121031761169e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 517 -4.4736708514392376e-03</internalNodes>
+          <leafValues>
+            2.0339429378509521e-01 5.3372788429260254e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 518 1.9628470763564110e-03</internalNodes>
+          <leafValues>
+            4.5716339349746704e-01 6.7258632183074951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 519 5.4260450415313244e-03</internalNodes>
+          <leafValues>
+            5.2711081504821777e-01 2.8456708788871765e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 520 4.9611460417509079e-04</internalNodes>
+          <leafValues>
+            4.1383129358291626e-01 5.7185977697372437e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 521 9.3728788197040558e-03</internalNodes>
+          <leafValues>
+            5.2251511812210083e-01 2.8048470616340637e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 522 6.0500897234305739e-04</internalNodes>
+          <leafValues>
+            5.2367687225341797e-01 3.3145239949226379e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 523 5.6792551185935736e-04</internalNodes>
+          <leafValues>
+            4.5310598611831665e-01 6.2769711017608643e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 524 2.4644339457154274e-02</internalNodes>
+          <leafValues>
+            5.1308518648147583e-01 2.0171439647674561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 525 -1.0290450416505337e-02</internalNodes>
+          <leafValues>
+            7.7865952253341675e-01 4.8766410350799561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 526 2.0629419013857841e-03</internalNodes>
+          <leafValues>
+            4.2885988950729370e-01 5.8812642097473145e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 527 -5.0519481301307678e-03</internalNodes>
+          <leafValues>
+            3.5239779949188232e-01 5.2860087156295776e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 528 -5.7692620903253555e-03</internalNodes>
+          <leafValues>
+            6.8410861492156982e-01 4.5880940556526184e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 529 -4.5789941214025021e-04</internalNodes>
+          <leafValues>
+            3.5655200481414795e-01 5.4859781265258789e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 530 -7.5918837683275342e-04</internalNodes>
+          <leafValues>
+            3.3687931299209595e-01 5.2541971206665039e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 531 -1.7737259622663260e-03</internalNodes>
+          <leafValues>
+            3.4221610426902771e-01 5.4540151357650757e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 532 -8.5610467940568924e-03</internalNodes>
+          <leafValues>
+            6.5336120128631592e-01 4.4858568906784058e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 533 1.7277270089834929e-03</internalNodes>
+          <leafValues>
+            5.3075802326202393e-01 3.9253529906272888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 534 -2.8199609369039536e-02</internalNodes>
+          <leafValues>
+            6.8574589490890503e-01 4.5885840058326721e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 535 -1.7781109781935811e-03</internalNodes>
+          <leafValues>
+            4.0378510951995850e-01 5.3698569536209106e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 536 3.3177141449414194e-04</internalNodes>
+          <leafValues>
+            5.3997987508773804e-01 3.7057501077651978e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 537 2.6385399978607893e-03</internalNodes>
+          <leafValues>
+            4.6654370427131653e-01 6.4527308940887451e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 538 -2.1183069329708815e-03</internalNodes>
+          <leafValues>
+            5.9147810935974121e-01 4.0646770596504211e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 539 -1.4773289673030376e-02</internalNodes>
+          <leafValues>
+            3.6420381069183350e-01 5.2947628498077393e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 540 -1.6815440729260445e-02</internalNodes>
+          <leafValues>
+            2.6642319560050964e-01 5.1449728012084961e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 541 -6.3370140269398689e-03</internalNodes>
+          <leafValues>
+            6.7795312404632568e-01 4.8520979285240173e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 542 -4.4560048991115764e-05</internalNodes>
+          <leafValues>
+            5.6139647960662842e-01 4.1530540585517883e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 543 -1.0240620467811823e-03</internalNodes>
+          <leafValues>
+            5.9644782543182373e-01 4.5663040876388550e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 544 -2.3161689750850201e-03</internalNodes>
+          <leafValues>
+            2.9761150479316711e-01 5.1881599426269531e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 545 5.3217571973800659e-01</internalNodes>
+          <leafValues>
+            5.1878392696380615e-01 2.2026319801807404e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 546 -1.6643050312995911e-01</internalNodes>
+          <leafValues>
+            1.8660229444503784e-01 5.0603431463241577e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 547 1.1253529787063599e-01</internalNodes>
+          <leafValues>
+            5.2121251821517944e-01 1.1850229650735855e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 548 9.3046864494681358e-03</internalNodes>
+          <leafValues>
+            4.5899370312690735e-01 6.8261492252349854e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 549 -4.6255099587142467e-03</internalNodes>
+          <leafValues>
+            3.0799409747123718e-01 5.2250087261199951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 550 -1.1116469651460648e-01</internalNodes>
+          <leafValues>
+            2.1010440587997437e-01 5.0808018445968628e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 551 -1.0888439603149891e-02</internalNodes>
+          <leafValues>
+            5.7653552293777466e-01 4.7904640436172485e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 552 5.8564301580190659e-03</internalNodes>
+          <leafValues>
+            5.0651001930236816e-01 1.5635989606380463e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 553 5.4854389280080795e-02</internalNodes>
+          <leafValues>
+            4.9669149518013000e-01 7.2305107116699219e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 554 -1.1197339743375778e-02</internalNodes>
+          <leafValues>
+            2.1949790418148041e-01 5.0987982749938965e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 555 4.4069071300327778e-03</internalNodes>
+          <leafValues>
+            4.7784018516540527e-01 6.7709028720855713e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 556 -6.3665293157100677e-02</internalNodes>
+          <leafValues>
+            1.9363629817962646e-01 5.0810241699218750e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 557 -9.8081491887569427e-03</internalNodes>
+          <leafValues>
+            5.9990632534027100e-01 4.8103410005569458e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 558 -2.1717099007219076e-03</internalNodes>
+          <leafValues>
+            3.3383339643478394e-01 5.2354729175567627e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 559 -1.3315520249307156e-02</internalNodes>
+          <leafValues>
+            6.6170698404312134e-01 4.9192130565643311e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 560 2.5442079640924931e-03</internalNodes>
+          <leafValues>
+            4.4887441396713257e-01 6.0821849107742310e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 561 1.2037839740514755e-02</internalNodes>
+          <leafValues>
+            5.4093921184539795e-01 3.2924321293830872e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 562 -2.0701050758361816e-02</internalNodes>
+          <leafValues>
+            6.8191200494766235e-01 4.5949959754943848e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 563 2.7608279138803482e-02</internalNodes>
+          <leafValues>
+            4.6307921409606934e-01 5.7672828435897827e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 564 1.2370620388537645e-03</internalNodes>
+          <leafValues>
+            5.1653790473937988e-01 2.6350161433219910e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 565 -3.7669338285923004e-02</internalNodes>
+          <leafValues>
+            2.5363931059837341e-01 5.2789801359176636e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 566 -1.8057259730994701e-03</internalNodes>
+          <leafValues>
+            3.9851561188697815e-01 5.5175000429153442e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>111</maxWeakCount>
+      <stageThreshold>5.4620071411132812e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 567 4.4299028813838959e-03</internalNodes>
+          <leafValues>
+            2.8910180926322937e-01 6.3352262973785400e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 568 -2.3813319858163595e-03</internalNodes>
+          <leafValues>
+            6.2117892503738403e-01 3.4774878621101379e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 569 2.2915711160749197e-03</internalNodes>
+          <leafValues>
+            2.2544120252132416e-01 5.5821180343627930e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 570 9.9457940086722374e-04</internalNodes>
+          <leafValues>
+            3.7117108702659607e-01 5.9300708770751953e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 571 7.7164667891338468e-04</internalNodes>
+          <leafValues>
+            5.6517201662063599e-01 3.3479958772659302e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 572 -1.1386410333216190e-03</internalNodes>
+          <leafValues>
+            3.0691260099411011e-01 5.5086308717727661e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 573 -1.6403039626311511e-04</internalNodes>
+          <leafValues>
+            5.7628279924392700e-01 3.6990478634834290e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 574 2.9793529392918572e-05</internalNodes>
+          <leafValues>
+            2.6442441344261169e-01 5.4379111528396606e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 575 8.5774902254343033e-03</internalNodes>
+          <leafValues>
+            5.0511389970779419e-01 1.7957249283790588e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 576 -2.6032689493149519e-04</internalNodes>
+          <leafValues>
+            5.8269691467285156e-01 4.4468268752098083e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 577 -6.1404630541801453e-03</internalNodes>
+          <leafValues>
+            3.1138521432876587e-01 5.3469717502593994e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 578 -2.3086950182914734e-02</internalNodes>
+          <leafValues>
+            3.2779461145401001e-01 5.3311979770660400e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 579 -1.4243650250136852e-02</internalNodes>
+          <leafValues>
+            7.3817098140716553e-01 4.5880630612373352e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 580 1.9487129524350166e-02</internalNodes>
+          <leafValues>
+            5.2566307783126831e-01 2.2744719684123993e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 581 -9.6681108698248863e-04</internalNodes>
+          <leafValues>
+            5.5112308263778687e-01 3.8150069117546082e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 582 3.1474709976464510e-03</internalNodes>
+          <leafValues>
+            5.4256367683410645e-01 2.5437268614768982e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 583 -1.8026070029009134e-04</internalNodes>
+          <leafValues>
+            5.3801918029785156e-01 3.4063041210174561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 584 -6.0266260989010334e-03</internalNodes>
+          <leafValues>
+            3.0358019471168518e-01 5.4205721616744995e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 585 4.4462960795499384e-04</internalNodes>
+          <leafValues>
+            3.9909970760345459e-01 5.6601101160049438e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 586 2.2609760053455830e-03</internalNodes>
+          <leafValues>
+            5.5628067255020142e-01 3.9406880736351013e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 587 5.1133058965206146e-02</internalNodes>
+          <leafValues>
+            4.6096539497375488e-01 7.1185618638992310e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 588 -1.7786309123039246e-02</internalNodes>
+          <leafValues>
+            2.3161660134792328e-01 5.3221440315246582e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 589 -4.9679628573358059e-03</internalNodes>
+          <leafValues>
+            2.3307719826698303e-01 5.1220291852951050e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 590 2.0667689386755228e-03</internalNodes>
+          <leafValues>
+            4.6574440598487854e-01 6.4554882049560547e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 591 7.4413768015801907e-03</internalNodes>
+          <leafValues>
+            5.1543921232223511e-01 2.3616339266300201e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 592 -3.6277279723435640e-03</internalNodes>
+          <leafValues>
+            6.2197732925415039e-01 4.4766610860824585e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 593 -5.3530759178102016e-03</internalNodes>
+          <leafValues>
+            1.8373550474643707e-01 5.1022082567214966e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 594 1.4530919492244720e-01</internalNodes>
+          <leafValues>
+            5.1459872722625732e-01 1.5359309315681458e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 595 2.4394490756094456e-03</internalNodes>
+          <leafValues>
+            5.3436601161956787e-01 3.6246618628501892e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 596 -3.1283390708267689e-03</internalNodes>
+          <leafValues>
+            6.2150079011917114e-01 4.8455920815467834e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 597 1.7940260004252195e-03</internalNodes>
+          <leafValues>
+            4.2992618680000305e-01 5.8241981267929077e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 598 3.6253821104764938e-02</internalNodes>
+          <leafValues>
+            5.2603340148925781e-01 1.4394679665565491e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 599 -5.1746722310781479e-03</internalNodes>
+          <leafValues>
+            3.5065388679504395e-01 5.2870452404022217e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 600 6.5383297624066472e-04</internalNodes>
+          <leafValues>
+            4.8096409440040588e-01 6.1220401525497437e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 601 -2.6480229571461678e-02</internalNodes>
+          <leafValues>
+            1.1393620073795319e-01 5.0455862283706665e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 602 -3.0440660193562508e-03</internalNodes>
+          <leafValues>
+            6.3520950078964233e-01 4.7947341203689575e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 603 3.6993520334362984e-03</internalNodes>
+          <leafValues>
+            5.1311182975769043e-01 2.4985109269618988e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 604 -3.6762931267730892e-04</internalNodes>
+          <leafValues>
+            5.4213947057723999e-01 3.7095320224761963e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 605 -4.1382260620594025e-02</internalNodes>
+          <leafValues>
+            1.8949599564075470e-01 5.0816917419433594e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 606 -1.0532729793339968e-03</internalNodes>
+          <leafValues>
+            6.4543670415878296e-01 4.7836089134216309e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 607 -2.1648600231856108e-03</internalNodes>
+          <leafValues>
+            6.2150311470031738e-01 4.4998261332511902e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 608 -5.6747748749330640e-04</internalNodes>
+          <leafValues>
+            3.7126109004020691e-01 5.4193347692489624e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 609 1.7375840246677399e-01</internalNodes>
+          <leafValues>
+            5.0236439704895020e-01 1.2157420068979263e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 610 -2.9049699660390615e-03</internalNodes>
+          <leafValues>
+            3.2402679324150085e-01 5.3818839788436890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 611 1.2299539521336555e-03</internalNodes>
+          <leafValues>
+            4.1655078530311584e-01 5.7034862041473389e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 612 -5.4329237900674343e-04</internalNodes>
+          <leafValues>
+            3.8540428876876831e-01 5.5475491285324097e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 613 -8.3297258242964745e-03</internalNodes>
+          <leafValues>
+            2.2044940292835236e-01 5.0970828533172607e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 614 -1.0417630255687982e-04</internalNodes>
+          <leafValues>
+            5.6070661544799805e-01 4.3030360341072083e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 615 3.1204700469970703e-02</internalNodes>
+          <leafValues>
+            4.6216571331024170e-01 6.9820040464401245e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 616 7.8943502157926559e-03</internalNodes>
+          <leafValues>
+            5.2695941925048828e-01 2.2690680623054504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 617 -4.3645310215651989e-03</internalNodes>
+          <leafValues>
+            6.3592231273651123e-01 4.5379561185836792e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 618 7.6793059706687927e-03</internalNodes>
+          <leafValues>
+            5.2747678756713867e-01 2.7404838800430298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 619 -2.5431139394640923e-02</internalNodes>
+          <leafValues>
+            2.0385199785232544e-01 5.0717329978942871e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 620 8.2000601105391979e-04</internalNodes>
+          <leafValues>
+            4.5874550938606262e-01 6.1198681592941284e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 621 2.9284600168466568e-03</internalNodes>
+          <leafValues>
+            5.0712740421295166e-01 2.0282049477100372e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 622 4.5256470912136137e-05</internalNodes>
+          <leafValues>
+            4.8121041059494019e-01 5.4308217763900757e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 623 1.3158309739083052e-03</internalNodes>
+          <leafValues>
+            4.6258139610290527e-01 6.7793232202529907e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 624 1.5870389761403203e-03</internalNodes>
+          <leafValues>
+            5.3862917423248291e-01 3.4314650297164917e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 625 -2.1539660170674324e-02</internalNodes>
+          <leafValues>
+            2.5942500680685043e-02 5.0032228231430054e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 626 1.4334480278193951e-02</internalNodes>
+          <leafValues>
+            5.2028447389602661e-01 1.5906329452991486e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 627 -8.3881383761763573e-03</internalNodes>
+          <leafValues>
+            7.2824811935424805e-01 4.6480441093444824e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 628 9.1906841844320297e-03</internalNodes>
+          <leafValues>
+            5.5623567104339600e-01 3.9231911301612854e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 629 -5.8453059755265713e-03</internalNodes>
+          <leafValues>
+            6.8033927679061890e-01 4.6291279792785645e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 630 -5.4707799106836319e-02</internalNodes>
+          <leafValues>
+            2.5616711378097534e-01 5.2061259746551514e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 631 9.1142775490880013e-03</internalNodes>
+          <leafValues>
+            5.1896202564239502e-01 3.0538770556449890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 632 -1.5575000084936619e-02</internalNodes>
+          <leafValues>
+            1.2950749695301056e-01 5.1690948009490967e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 633 -1.2050600344082341e-04</internalNodes>
+          <leafValues>
+            5.7350981235504150e-01 4.2308250069618225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 634 1.2273970060050488e-03</internalNodes>
+          <leafValues>
+            5.2898782491683960e-01 4.0797919034957886e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 635 -1.2186600361019373e-03</internalNodes>
+          <leafValues>
+            6.5756398439407349e-01 4.5744091272354126e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 636 -3.3256649039685726e-03</internalNodes>
+          <leafValues>
+            3.6280471086502075e-01 5.1950198411941528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 637 -1.3288309797644615e-02</internalNodes>
+          <leafValues>
+            1.2842659652233124e-01 5.0434887409210205e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 638 -3.3839771058410406e-03</internalNodes>
+          <leafValues>
+            6.2922400236129761e-01 4.7575059533119202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 639 -2.1954220533370972e-01</internalNodes>
+          <leafValues>
+            1.4877319335937500e-01 5.0650137662887573e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 640 4.9111708067357540e-03</internalNodes>
+          <leafValues>
+            4.2561021447181702e-01 5.6658387184143066e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 641 -1.8744950648397207e-04</internalNodes>
+          <leafValues>
+            4.0041440725326538e-01 5.5868571996688843e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 642 -5.2178641781210899e-03</internalNodes>
+          <leafValues>
+            6.0091161727905273e-01 4.8127061128616333e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 643 -1.1111519997939467e-03</internalNodes>
+          <leafValues>
+            3.5149338841438293e-01 5.2870899438858032e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 644 4.4036400504410267e-03</internalNodes>
+          <leafValues>
+            4.6422758698463440e-01 5.9240859746932983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 645 1.2299499660730362e-01</internalNodes>
+          <leafValues>
+            5.0255292654037476e-01 6.9152481853961945e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 646 -1.2313510291278362e-02</internalNodes>
+          <leafValues>
+            5.8845919370651245e-01 4.9340128898620605e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 647 4.1471039876341820e-03</internalNodes>
+          <leafValues>
+            4.3722391128540039e-01 5.8934777975082397e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 648 -3.5502649843692780e-03</internalNodes>
+          <leafValues>
+            4.3275511264801025e-01 5.3962701559066772e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 649 -1.9224269315600395e-02</internalNodes>
+          <leafValues>
+            1.9131340086460114e-01 5.0683307647705078e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 650 1.4395059552043676e-03</internalNodes>
+          <leafValues>
+            5.3081780672073364e-01 4.2435330152511597e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 651 -6.7751999013125896e-03</internalNodes>
+          <leafValues>
+            6.3653957843780518e-01 4.5400860905647278e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 652 7.0119630545377731e-03</internalNodes>
+          <leafValues>
+            5.1898342370986938e-01 3.0261999368667603e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 653 5.4014651104807854e-03</internalNodes>
+          <leafValues>
+            5.1050621271133423e-01 2.5576829910278320e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 654 9.0274988906458020e-04</internalNodes>
+          <leafValues>
+            4.6969148516654968e-01 5.8618277311325073e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 655 1.1474450118839741e-02</internalNodes>
+          <leafValues>
+            5.0536459684371948e-01 1.5271779894828796e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 656 -6.7023430019617081e-03</internalNodes>
+          <leafValues>
+            6.5089809894561768e-01 4.8906040191650391e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 657 -2.0462959073483944e-03</internalNodes>
+          <leafValues>
+            6.2418168783187866e-01 4.5146000385284424e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 658 -9.9951568990945816e-03</internalNodes>
+          <leafValues>
+            3.4327811002731323e-01 5.4009538888931274e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 659 -3.5700708627700806e-02</internalNodes>
+          <leafValues>
+            1.8780590593814850e-01 5.0740778446197510e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 660 4.5584561303257942e-04</internalNodes>
+          <leafValues>
+            3.8052770495414734e-01 5.4025697708129883e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 661 -5.4260600358247757e-02</internalNodes>
+          <leafValues>
+            6.8437147140502930e-01 4.5950970053672791e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 662 6.0600461438298225e-03</internalNodes>
+          <leafValues>
+            5.5029052495956421e-01 4.5005279779434204e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 663 -6.4791832119226456e-03</internalNodes>
+          <leafValues>
+            3.3688580989837646e-01 5.3107571601867676e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 664 -1.4939469983801246e-03</internalNodes>
+          <leafValues>
+            6.4876401424407959e-01 4.7561758756637573e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 665 1.4610530342906713e-05</internalNodes>
+          <leafValues>
+            4.0345790982246399e-01 5.4510641098022461e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 666 -7.2321938350796700e-03</internalNodes>
+          <leafValues>
+            6.3868737220764160e-01 4.8247399926185608e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 667 -4.0645818226039410e-03</internalNodes>
+          <leafValues>
+            2.9864218831062317e-01 5.1573359966278076e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 668 3.0463080853223801e-02</internalNodes>
+          <leafValues>
+            5.0221997499465942e-01 7.1599560976028442e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 669 -8.0544911324977875e-03</internalNodes>
+          <leafValues>
+            6.4924520254135132e-01 4.6192750334739685e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 670 3.9505138993263245e-02</internalNodes>
+          <leafValues>
+            5.1505708694458008e-01 2.4506139755249023e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 671 8.4530208259820938e-03</internalNodes>
+          <leafValues>
+            4.5736691355705261e-01 6.3940370082855225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 672 -1.1688120430335402e-03</internalNodes>
+          <leafValues>
+            3.8655120134353638e-01 5.4836612939834595e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 673 2.8070670086890459e-03</internalNodes>
+          <leafValues>
+            5.1285791397094727e-01 2.7014800906181335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 674 4.7365209320560098e-04</internalNodes>
+          <leafValues>
+            4.0515819191932678e-01 5.3874611854553223e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 675 1.1741080321371555e-02</internalNodes>
+          <leafValues>
+            5.2959501743316650e-01 3.7194138765335083e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 676 3.1833238899707794e-03</internalNodes>
+          <leafValues>
+            4.7894069552421570e-01 6.8951261043548584e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 677 7.0241501089185476e-04</internalNodes>
+          <leafValues>
+            5.3844892978668213e-01 3.9180809259414673e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>102</maxWeakCount>
+      <stageThreshold>5.0169731140136719e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 678 1.7059929668903351e-02</internalNodes>
+          <leafValues>
+            3.9485278725624084e-01 7.1425348520278931e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 679 2.1840840578079224e-02</internalNodes>
+          <leafValues>
+            3.3703160285949707e-01 6.0900169610977173e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 680 2.4520049919374287e-04</internalNodes>
+          <leafValues>
+            3.5005760192871094e-01 5.9879022836685181e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 681 8.3272606134414673e-03</internalNodes>
+          <leafValues>
+            3.2675281167030334e-01 5.6972408294677734e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 682 5.7148298947140574e-04</internalNodes>
+          <leafValues>
+            3.0445998907089233e-01 5.5316567420959473e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 683 6.7373987985774875e-04</internalNodes>
+          <leafValues>
+            3.6500120162963867e-01 5.6726312637329102e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 684 3.4681590477703139e-05</internalNodes>
+          <leafValues>
+            3.3135411143302917e-01 5.3887271881103516e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 685 -5.8563398197293282e-03</internalNodes>
+          <leafValues>
+            2.6979428529739380e-01 5.4987788200378418e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 686 8.5102273151278496e-03</internalNodes>
+          <leafValues>
+            5.2693581581115723e-01 2.7628791332244873e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 687 -6.9817207753658295e-02</internalNodes>
+          <leafValues>
+            2.9096031188964844e-01 5.2592468261718750e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 688 -8.6113670840859413e-04</internalNodes>
+          <leafValues>
+            5.8925771713256836e-01 4.0736979246139526e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 689 9.7149249631911516e-04</internalNodes>
+          <leafValues>
+            3.5235640406608582e-01 5.4158622026443481e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 690 -1.4727490452060010e-05</internalNodes>
+          <leafValues>
+            5.4230177402496338e-01 3.5031560063362122e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 691 4.8420291393995285e-02</internalNodes>
+          <leafValues>
+            5.1939457654953003e-01 3.4111958742141724e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 692 1.3257140526548028e-03</internalNodes>
+          <leafValues>
+            3.1577691435813904e-01 5.3353762626647949e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 693 1.4922149603080470e-05</internalNodes>
+          <leafValues>
+            4.4512999057769775e-01 5.5365538597106934e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 694 -2.7173398993909359e-03</internalNodes>
+          <leafValues>
+            3.0317419767379761e-01 5.2480888366699219e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 695 2.9219500720500946e-03</internalNodes>
+          <leafValues>
+            4.7814530134201050e-01 6.6060417890548706e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 696 -1.9804988987743855e-03</internalNodes>
+          <leafValues>
+            3.1863081455230713e-01 5.2876251935958862e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 697 -4.0012109093368053e-03</internalNodes>
+          <leafValues>
+            6.4135968685150146e-01 4.7499281167984009e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 698 -4.3491991236805916e-03</internalNodes>
+          <leafValues>
+            1.5074980258941650e-01 5.0989967584609985e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 699 1.3490889687091112e-03</internalNodes>
+          <leafValues>
+            4.3161588907241821e-01 5.8811670541763306e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 700 1.8597070127725601e-02</internalNodes>
+          <leafValues>
+            4.7355538606643677e-01 9.0897941589355469e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 701 -1.8562379991635680e-03</internalNodes>
+          <leafValues>
+            3.5531890392303467e-01 5.5778372287750244e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 702 2.2940430790185928e-03</internalNodes>
+          <leafValues>
+            4.5000949501991272e-01 6.5808779001235962e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 703 2.9982850537635386e-04</internalNodes>
+          <leafValues>
+            5.6292420625686646e-01 3.9758789539337158e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 704 3.5455459728837013e-03</internalNodes>
+          <leafValues>
+            5.3815472126007080e-01 3.6054858565330505e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 705 9.6104722470045090e-03</internalNodes>
+          <leafValues>
+            5.2559971809387207e-01 1.7967459559440613e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 706 -6.2783220782876015e-03</internalNodes>
+          <leafValues>
+            2.2728569805622101e-01 5.1140302419662476e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 707 3.4598479978740215e-03</internalNodes>
+          <leafValues>
+            4.6263080835342407e-01 6.6082191467285156e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 708 -1.3112019514665008e-03</internalNodes>
+          <leafValues>
+            6.3175398111343384e-01 4.4368579983711243e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 709 2.6876179035753012e-03</internalNodes>
+          <leafValues>
+            5.4211097955703735e-01 4.0540221333503723e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 710 3.9118169806897640e-03</internalNodes>
+          <leafValues>
+            5.3584778308868408e-01 3.2734549045562744e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 711 -1.4206450432538986e-02</internalNodes>
+          <leafValues>
+            7.7935767173767090e-01 4.9757811427116394e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 712 7.1705528534948826e-04</internalNodes>
+          <leafValues>
+            5.2973198890686035e-01 3.5609039664268494e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 713 1.6635019565001130e-03</internalNodes>
+          <leafValues>
+            4.6780940890312195e-01 5.8164817094802856e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 714 3.3686188980937004e-03</internalNodes>
+          <leafValues>
+            5.2767342329025269e-01 3.4464201331138611e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 715 1.2799530290067196e-02</internalNodes>
+          <leafValues>
+            4.8346799612045288e-01 7.4721592664718628e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 716 3.3901201095432043e-03</internalNodes>
+          <leafValues>
+            4.5118591189384460e-01 6.4017212390899658e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 717 4.7070779837667942e-03</internalNodes>
+          <leafValues>
+            5.3356587886810303e-01 3.5552209615707397e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 718 1.4819339849054813e-03</internalNodes>
+          <leafValues>
+            4.2507070302963257e-01 5.7727241516113281e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 719 -6.9995759986341000e-03</internalNodes>
+          <leafValues>
+            3.0033200979232788e-01 5.2929002046585083e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 720 1.5939010307192802e-02</internalNodes>
+          <leafValues>
+            5.0673192739486694e-01 1.6755819320678711e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 721 7.6377349905669689e-03</internalNodes>
+          <leafValues>
+            4.7950699925422668e-01 7.0856010913848877e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 722 6.7334040068089962e-03</internalNodes>
+          <leafValues>
+            5.1331132650375366e-01 2.1624700725078583e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 723 -1.2858809903264046e-02</internalNodes>
+          <leafValues>
+            1.9388419389724731e-01 5.2513718605041504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 724 -6.2270800117403269e-04</internalNodes>
+          <leafValues>
+            5.6865382194519043e-01 4.1978681087493896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 725 -5.2651681471616030e-04</internalNodes>
+          <leafValues>
+            4.2241689562797546e-01 5.4296958446502686e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 726 1.1075099930167198e-02</internalNodes>
+          <leafValues>
+            5.1137751340866089e-01 2.5145179033279419e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 727 -3.6728251725435257e-02</internalNodes>
+          <leafValues>
+            7.1946620941162109e-01 4.8496189713478088e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 728 -2.8207109426148236e-04</internalNodes>
+          <leafValues>
+            3.8402619957923889e-01 5.3944462537765503e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 729 -2.7489690110087395e-03</internalNodes>
+          <leafValues>
+            5.9370887279510498e-01 4.5691820979118347e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 730 1.0047519579529762e-02</internalNodes>
+          <leafValues>
+            5.1385760307312012e-01 2.8022980690002441e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 731 -8.1497840583324432e-03</internalNodes>
+          <leafValues>
+            6.0900372266769409e-01 4.6361210942268372e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 732 -6.8833888508379459e-03</internalNodes>
+          <leafValues>
+            3.4586110711097717e-01 5.2546602487564087e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 733 -1.4039360394235700e-05</internalNodes>
+          <leafValues>
+            5.6931042671203613e-01 4.0820831060409546e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 734 1.5498419525101781e-03</internalNodes>
+          <leafValues>
+            4.3505370616912842e-01 5.8065170049667358e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 735 -6.7841499112546444e-03</internalNodes>
+          <leafValues>
+            1.4688730239868164e-01 5.1827752590179443e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 736 2.1705629478674382e-04</internalNodes>
+          <leafValues>
+            5.2935242652893066e-01 3.4561741352081299e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 737 3.1198898795992136e-04</internalNodes>
+          <leafValues>
+            4.6524509787559509e-01 5.9424138069152832e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 738 5.4507530294358730e-03</internalNodes>
+          <leafValues>
+            4.6535089612007141e-01 7.0248460769653320e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 739 -2.5818689027801156e-04</internalNodes>
+          <leafValues>
+            5.4972952604293823e-01 3.7689670920372009e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 740 -1.7442539334297180e-02</internalNodes>
+          <leafValues>
+            3.9190879464149475e-01 5.4574978351593018e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 741 -4.5343529433012009e-02</internalNodes>
+          <leafValues>
+            1.6313570737838745e-01 5.1549088954925537e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 742 1.9190689781680703e-03</internalNodes>
+          <leafValues>
+            5.1458978652954102e-01 2.7918958663940430e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 743 -6.0177869163453579e-03</internalNodes>
+          <leafValues>
+            6.5176361799240112e-01 4.7563329339027405e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 744 -4.0720738470554352e-03</internalNodes>
+          <leafValues>
+            5.5146527290344238e-01 4.0926858782768250e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 745 3.9855059003457427e-04</internalNodes>
+          <leafValues>
+            3.1652408838272095e-01 5.2855509519577026e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 746 -6.5418570302426815e-03</internalNodes>
+          <leafValues>
+            6.8533778190612793e-01 4.6528089046478271e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 747 3.4845089539885521e-03</internalNodes>
+          <leafValues>
+            5.4845881462097168e-01 4.5027598738670349e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 748 -1.3696780428290367e-02</internalNodes>
+          <leafValues>
+            6.3957798480987549e-01 4.5725551247596741e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 749 -1.7347140237689018e-02</internalNodes>
+          <leafValues>
+            2.7510729432106018e-01 5.1816147565841675e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 750 -4.0885428898036480e-03</internalNodes>
+          <leafValues>
+            3.3256360888481140e-01 5.1949840784072876e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 751 -9.4687901437282562e-03</internalNodes>
+          <leafValues>
+            5.9422808885574341e-01 4.8518198728561401e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 752 1.7084840219467878e-03</internalNodes>
+          <leafValues>
+            4.1671109199523926e-01 5.5198061466217041e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 753 9.4809094443917274e-03</internalNodes>
+          <leafValues>
+            5.4338949918746948e-01 4.2085149884223938e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 754 -4.7389650717377663e-03</internalNodes>
+          <leafValues>
+            6.4071899652481079e-01 4.5606550574302673e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 755 6.5761050209403038e-03</internalNodes>
+          <leafValues>
+            5.2145552635192871e-01 2.2582270205020905e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 756 -2.1690549328923225e-03</internalNodes>
+          <leafValues>
+            3.1515279412269592e-01 5.1567047834396362e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 757 1.4660170301795006e-02</internalNodes>
+          <leafValues>
+            4.8708370327949524e-01 6.6899412870407104e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 758 1.7231999663636088e-04</internalNodes>
+          <leafValues>
+            3.5697489976882935e-01 5.2510780096054077e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 759 -2.1803760901093483e-02</internalNodes>
+          <leafValues>
+            8.8259208202362061e-01 4.9663299322128296e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 760 -9.4736106693744659e-02</internalNodes>
+          <leafValues>
+            1.4461620151996613e-01 5.0611138343811035e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 761 5.5825551971793175e-03</internalNodes>
+          <leafValues>
+            5.3964787721633911e-01 4.2380660772323608e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 762 1.9517090404406190e-03</internalNodes>
+          <leafValues>
+            4.1704109311103821e-01 5.4977869987487793e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 763 1.2149900197982788e-02</internalNodes>
+          <leafValues>
+            4.6983671188354492e-01 5.6642740964889526e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 764 -7.5169620104134083e-03</internalNodes>
+          <leafValues>
+            6.2677729129791260e-01 4.4631358981132507e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 765 -7.1667909622192383e-02</internalNodes>
+          <leafValues>
+            3.0970111489295959e-01 5.2210032939910889e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 766 -8.8292419910430908e-02</internalNodes>
+          <leafValues>
+            8.1123888492584229e-02 5.0063651800155640e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 767 3.1063079833984375e-02</internalNodes>
+          <leafValues>
+            5.1555037498474121e-01 1.2822559475898743e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 768 4.6621840447187424e-02</internalNodes>
+          <leafValues>
+            4.6997779607772827e-01 7.3639607429504395e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 769 -1.2189489789307117e-02</internalNodes>
+          <leafValues>
+            3.9205300807952881e-01 5.5189967155456543e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 770 1.3016110286116600e-02</internalNodes>
+          <leafValues>
+            5.2606582641601562e-01 3.6851361393928528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 771 -3.4952899441123009e-03</internalNodes>
+          <leafValues>
+            6.3392949104309082e-01 4.7162809967994690e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 772 -4.4015039748046547e-05</internalNodes>
+          <leafValues>
+            5.3330272436141968e-01 3.7761849164962769e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 773 -1.0966490209102631e-01</internalNodes>
+          <leafValues>
+            1.7653420567512512e-01 5.1983469724655151e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 774 -9.0279558207839727e-04</internalNodes>
+          <leafValues>
+            5.3241598606109619e-01 3.8389080762863159e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 775 7.1126641705632210e-04</internalNodes>
+          <leafValues>
+            4.6479299664497375e-01 5.7552242279052734e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 776 -3.1250279862433672e-03</internalNodes>
+          <leafValues>
+            3.2367089390754700e-01 5.1667708158493042e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 777 2.4144679773598909e-03</internalNodes>
+          <leafValues>
+            4.7874391078948975e-01 6.4597177505493164e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 778 4.4391240226104856e-04</internalNodes>
+          <leafValues>
+            4.4093081355094910e-01 6.0102558135986328e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 779 -2.2611189342569560e-04</internalNodes>
+          <leafValues>
+            4.0381139516830444e-01 5.4932558536529541e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>135</maxWeakCount>
+      <stageThreshold>6.6669120788574219e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 780 -4.6901289373636246e-02</internalNodes>
+          <leafValues>
+            6.6001719236373901e-01 3.7438011169433594e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 781 -1.4568349579349160e-03</internalNodes>
+          <leafValues>
+            5.7839912176132202e-01 3.4377971291542053e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 782 5.5598369799554348e-03</internalNodes>
+          <leafValues>
+            3.6222669482231140e-01 5.9082162380218506e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 783 7.3170487303286791e-04</internalNodes>
+          <leafValues>
+            5.5004191398620605e-01 2.8735581040382385e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 784 1.3318009441718459e-03</internalNodes>
+          <leafValues>
+            2.6731699705123901e-01 5.4310190677642822e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 785 2.4347059661522508e-04</internalNodes>
+          <leafValues>
+            3.8550278544425964e-01 5.7413887977600098e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 786 -3.0512469820678234e-03</internalNodes>
+          <leafValues>
+            5.5032098293304443e-01 3.4628450870513916e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 787 -6.8657199153676629e-04</internalNodes>
+          <leafValues>
+            3.2912218570709229e-01 5.4295092821121216e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 788 1.4668200165033340e-03</internalNodes>
+          <leafValues>
+            3.5883820056915283e-01 5.3518110513687134e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 789 3.2021870720200241e-04</internalNodes>
+          <leafValues>
+            4.2968419194221497e-01 5.7002341747283936e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 790 7.4122188379988074e-04</internalNodes>
+          <leafValues>
+            5.2821648120880127e-01 3.3668708801269531e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 791 3.8330298848450184e-03</internalNodes>
+          <leafValues>
+            4.5595678687095642e-01 6.2573361396789551e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 792 -1.5456439927220345e-02</internalNodes>
+          <leafValues>
+            2.3501169681549072e-01 5.1294529438018799e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 793 2.6796779129654169e-03</internalNodes>
+          <leafValues>
+            5.3294152021408081e-01 4.1550621390342712e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 794 2.8296569362282753e-03</internalNodes>
+          <leafValues>
+            4.2730879783630371e-01 5.8045381307601929e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 795 -3.9444249123334885e-03</internalNodes>
+          <leafValues>
+            2.9126119613647461e-01 5.2026861906051636e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 796 2.7179559692740440e-03</internalNodes>
+          <leafValues>
+            5.3076881170272827e-01 3.5856771469116211e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 797 5.9077627956867218e-03</internalNodes>
+          <leafValues>
+            4.7037750482559204e-01 5.9415858983993530e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 798 -4.2240349575877190e-03</internalNodes>
+          <leafValues>
+            2.1415670216083527e-01 5.0887960195541382e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 799 4.0725888684391975e-03</internalNodes>
+          <leafValues>
+            4.7664138674736023e-01 6.8410611152648926e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 800 1.0149530135095119e-02</internalNodes>
+          <leafValues>
+            5.3607988357543945e-01 3.7484970688819885e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 801 -1.8864999583456665e-04</internalNodes>
+          <leafValues>
+            5.7201302051544189e-01 3.8538050651550293e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 802 -4.8864358104765415e-03</internalNodes>
+          <leafValues>
+            3.6931228637695312e-01 5.3409588336944580e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 803 2.6158479973673820e-02</internalNodes>
+          <leafValues>
+            4.9623748660087585e-01 6.0599899291992188e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 804 4.8560759751126170e-04</internalNodes>
+          <leafValues>
+            4.4389459490776062e-01 6.0124689340591431e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 805 1.1268709786236286e-02</internalNodes>
+          <leafValues>
+            5.2442502975463867e-01 1.8403880298137665e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 806 -2.8114619199186563e-03</internalNodes>
+          <leafValues>
+            6.0602837800979614e-01 4.4098970293998718e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 807 -5.6112729944288731e-03</internalNodes>
+          <leafValues>
+            3.8911709189414978e-01 5.5892372131347656e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 808 8.5680093616247177e-03</internalNodes>
+          <leafValues>
+            5.0693458318710327e-01 2.0626190304756165e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 809 -3.8172779022715986e-04</internalNodes>
+          <leafValues>
+            5.8822017908096313e-01 4.1926109790802002e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 810 -1.7680290329735726e-04</internalNodes>
+          <leafValues>
+            5.5336058139801025e-01 4.0033689141273499e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 811 6.5112537704408169e-03</internalNodes>
+          <leafValues>
+            3.3101469278335571e-01 5.4441910982131958e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 812 -6.5948683186434209e-05</internalNodes>
+          <leafValues>
+            5.4338318109512329e-01 3.9449059963226318e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 813 6.9939051754772663e-03</internalNodes>
+          <leafValues>
+            5.6003582477569580e-01 4.1927140951156616e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 814 -4.6744439750909805e-03</internalNodes>
+          <leafValues>
+            6.6854667663574219e-01 4.6049609780311584e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 815 1.1589850299060345e-02</internalNodes>
+          <leafValues>
+            5.3571212291717529e-01 2.9268300533294678e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 816 1.3007840141654015e-02</internalNodes>
+          <leafValues>
+            4.6798178553581238e-01 7.3074632883071899e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 817 -1.1008579749614000e-03</internalNodes>
+          <leafValues>
+            3.9375010132789612e-01 5.4150652885437012e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 818 6.0472649056464434e-04</internalNodes>
+          <leafValues>
+            4.2423760890960693e-01 5.6040412187576294e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 819 -1.4494840055704117e-02</internalNodes>
+          <leafValues>
+            3.6312100291252136e-01 5.2931827306747437e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 820 -5.3056948818266392e-03</internalNodes>
+          <leafValues>
+            6.8604522943496704e-01 4.6218210458755493e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 821 -8.1829127157106996e-04</internalNodes>
+          <leafValues>
+            3.9440968632698059e-01 5.4204392433166504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 822 -1.9077520817518234e-02</internalNodes>
+          <leafValues>
+            1.9626219570636749e-01 5.0378918647766113e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 823 3.5549470339901745e-04</internalNodes>
+          <leafValues>
+            4.0862590074539185e-01 5.6139731407165527e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 824 1.9679730758070946e-03</internalNodes>
+          <leafValues>
+            4.4891211390495300e-01 5.9261232614517212e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 825 6.9189141504466534e-03</internalNodes>
+          <leafValues>
+            5.3359258174896240e-01 3.7283858656883240e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 826 2.9872779268771410e-03</internalNodes>
+          <leafValues>
+            5.1113212108612061e-01 2.9756438732147217e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 827 -6.2264618463814259e-03</internalNodes>
+          <leafValues>
+            5.5414897203445435e-01 4.8245379328727722e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 828 1.3353300280869007e-02</internalNodes>
+          <leafValues>
+            4.5864239335060120e-01 6.4147979021072388e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 829 3.3505238592624664e-02</internalNodes>
+          <leafValues>
+            5.3924250602722168e-01 3.4299948811531067e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 830 -2.5294460356235504e-03</internalNodes>
+          <leafValues>
+            1.7037139832973480e-01 5.0133150815963745e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 831 -1.2801629491150379e-03</internalNodes>
+          <leafValues>
+            5.3054618835449219e-01 4.6974050998687744e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 832 7.0687388069927692e-03</internalNodes>
+          <leafValues>
+            4.6155458688735962e-01 6.4365047216415405e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 833 9.6880499040707946e-04</internalNodes>
+          <leafValues>
+            4.8335990309715271e-01 6.0438942909240723e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 834 3.9647659286856651e-03</internalNodes>
+          <leafValues>
+            5.1876372098922729e-01 3.2318168878555298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 835 -2.2057730704545975e-02</internalNodes>
+          <leafValues>
+            4.0792569518089294e-01 5.2009809017181396e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 836 -6.6906312713399529e-04</internalNodes>
+          <leafValues>
+            5.3316092491149902e-01 3.8156008720397949e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 837 -6.7009328631684184e-04</internalNodes>
+          <leafValues>
+            5.6554222106933594e-01 4.6889019012451172e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 838 7.4284552829340100e-04</internalNodes>
+          <leafValues>
+            4.5343810319900513e-01 6.2874001264572144e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 839 2.2227810695767403e-03</internalNodes>
+          <leafValues>
+            5.3506332635879517e-01 3.3036559820175171e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 840 -5.4130521602928638e-03</internalNodes>
+          <leafValues>
+            1.1136870086193085e-01 5.0054347515106201e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 841 -1.4520040167553816e-05</internalNodes>
+          <leafValues>
+            5.6287378072738647e-01 4.3251338601112366e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 842 2.3369169502984732e-04</internalNodes>
+          <leafValues>
+            4.1658350825309753e-01 5.4477912187576294e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 843 4.2894547805190086e-03</internalNodes>
+          <leafValues>
+            4.8603910207748413e-01 6.7786490917205811e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 844 5.9103150852024555e-03</internalNodes>
+          <leafValues>
+            5.2623051404953003e-01 3.6121138930320740e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 845 1.2900539673864841e-02</internalNodes>
+          <leafValues>
+            5.3193771839141846e-01 3.2502880692481995e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 846 4.6982979401946068e-03</internalNodes>
+          <leafValues>
+            4.6182450652122498e-01 6.6659259796142578e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 847 1.0439859703183174e-02</internalNodes>
+          <leafValues>
+            5.5056709051132202e-01 3.8836041092872620e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 848 3.0443191062659025e-03</internalNodes>
+          <leafValues>
+            4.6978530287742615e-01 7.3018449544906616e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 849 -6.1593751888722181e-04</internalNodes>
+          <leafValues>
+            3.8308390974998474e-01 5.4649841785430908e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 850 -3.4247159492224455e-03</internalNodes>
+          <leafValues>
+            2.5663000345230103e-01 5.0895309448242188e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 851 -9.3538565561175346e-03</internalNodes>
+          <leafValues>
+            6.4699661731719971e-01 4.9407958984375000e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 852 5.2338998764753342e-02</internalNodes>
+          <leafValues>
+            4.7459828853607178e-01 7.8787708282470703e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 853 3.5765620414167643e-03</internalNodes>
+          <leafValues>
+            5.3066647052764893e-01 2.7484980225563049e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 854 7.1555317845195532e-04</internalNodes>
+          <leafValues>
+            5.4131257534027100e-01 4.0419089794158936e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 855 -1.0516679845750332e-02</internalNodes>
+          <leafValues>
+            6.1585122346878052e-01 4.8152831196784973e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 856 7.7347927726805210e-03</internalNodes>
+          <leafValues>
+            4.6958059072494507e-01 7.0289808511734009e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 857 -4.3226778507232666e-03</internalNodes>
+          <leafValues>
+            2.8495660424232483e-01 5.3046840429306030e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 858 -2.5534399319440126e-03</internalNodes>
+          <leafValues>
+            7.0569849014282227e-01 4.6888920664787292e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 859 1.0268510231981054e-04</internalNodes>
+          <leafValues>
+            3.9029321074485779e-01 5.5734640359878540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 860 7.1395188570022583e-06</internalNodes>
+          <leafValues>
+            3.6842319369316101e-01 5.2639877796173096e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 861 -1.6711989883333445e-03</internalNodes>
+          <leafValues>
+            3.8491758704185486e-01 5.3872710466384888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 862 4.9260449595749378e-03</internalNodes>
+          <leafValues>
+            4.7297719120979309e-01 7.4472510814666748e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 863 4.3908702209591866e-03</internalNodes>
+          <leafValues>
+            4.8091810941696167e-01 5.5919218063354492e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 864 -1.7793629318475723e-02</internalNodes>
+          <leafValues>
+            6.9036781787872314e-01 4.6769270300865173e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 865 2.0469669252634048e-03</internalNodes>
+          <leafValues>
+            5.3706902265548706e-01 3.3081620931625366e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 866 2.9891489073634148e-02</internalNodes>
+          <leafValues>
+            5.1398652791976929e-01 3.3090591430664062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 867 1.5494900289922953e-03</internalNodes>
+          <leafValues>
+            4.6602371335029602e-01 6.0783427953720093e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 868 1.4956969534978271e-03</internalNodes>
+          <leafValues>
+            4.4048359990119934e-01 5.8639198541641235e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 869 9.5885928021743894e-04</internalNodes>
+          <leafValues>
+            5.4359710216522217e-01 4.2085230350494385e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 870 4.9643701640889049e-04</internalNodes>
+          <leafValues>
+            5.3705781698226929e-01 4.0006220340728760e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 871 -2.7280810754746199e-03</internalNodes>
+          <leafValues>
+            5.6594127416610718e-01 4.2596429586410522e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 872 2.3026480339467525e-03</internalNodes>
+          <leafValues>
+            5.1616579294204712e-01 3.3508691191673279e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 873 2.5151631236076355e-01</internalNodes>
+          <leafValues>
+            4.8696619272232056e-01 7.1473097801208496e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 874 -4.6328022144734859e-03</internalNodes>
+          <leafValues>
+            2.7274489402770996e-01 5.0837898254394531e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 875 -4.0434490889310837e-02</internalNodes>
+          <leafValues>
+            6.8514388799667358e-01 5.0217670202255249e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 876 1.4972220014897175e-05</internalNodes>
+          <leafValues>
+            4.2844650149345398e-01 5.5225551128387451e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 877 -2.4050309730228037e-04</internalNodes>
+          <leafValues>
+            4.2261189222335815e-01 5.3900748491287231e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 878 2.3657839745283127e-02</internalNodes>
+          <leafValues>
+            4.7446319460868835e-01 7.5043660402297974e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 879 -8.1449104472994804e-03</internalNodes>
+          <leafValues>
+            4.2450588941574097e-01 5.5383628606796265e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 880 -3.6992130335420370e-03</internalNodes>
+          <leafValues>
+            5.9523570537567139e-01 4.5297130942344666e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 881 -6.7718601785600185e-03</internalNodes>
+          <leafValues>
+            4.1377940773963928e-01 5.4733997583389282e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 882 4.2669530957937241e-03</internalNodes>
+          <leafValues>
+            4.4841149449348450e-01 5.7979941368103027e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 883 1.7791989957913756e-03</internalNodes>
+          <leafValues>
+            5.6248587369918823e-01 4.4324448704719543e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 884 1.6774770338088274e-03</internalNodes>
+          <leafValues>
+            4.6377518773078918e-01 6.3642418384552002e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 885 1.1732629500329494e-03</internalNodes>
+          <leafValues>
+            4.5445030927658081e-01 5.9144157171249390e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 886 8.6998171173036098e-04</internalNodes>
+          <leafValues>
+            5.3347527980804443e-01 3.8859179615974426e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 887 7.6378340600058436e-04</internalNodes>
+          <leafValues>
+            5.3985852003097534e-01 3.7449419498443604e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 888 1.5684569370932877e-04</internalNodes>
+          <leafValues>
+            4.3178731203079224e-01 5.6146162748336792e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 889 -2.1511370316147804e-02</internalNodes>
+          <leafValues>
+            1.7859250307083130e-01 5.1855427026748657e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 890 1.3081369979772717e-04</internalNodes>
+          <leafValues>
+            4.3424990773200989e-01 5.6828498840332031e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 891 2.1992040798068047e-02</internalNodes>
+          <leafValues>
+            5.1617169380187988e-01 2.3793940246105194e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 892 -8.0136500764638186e-04</internalNodes>
+          <leafValues>
+            5.9867632389068604e-01 4.4664269685745239e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 893 -8.2736099138855934e-03</internalNodes>
+          <leafValues>
+            4.1082179546356201e-01 5.2510571479797363e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 894 3.6831789184361696e-03</internalNodes>
+          <leafValues>
+            5.1738142967224121e-01 3.3975180983543396e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 895 -7.9525681212544441e-03</internalNodes>
+          <leafValues>
+            6.8889832496643066e-01 4.8459240794181824e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 896 1.5382299898192286e-03</internalNodes>
+          <leafValues>
+            5.1785671710968018e-01 3.4541139006614685e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 897 -1.4043530449271202e-02</internalNodes>
+          <leafValues>
+            1.6784210503101349e-01 5.1886677742004395e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 898 1.4315890148282051e-03</internalNodes>
+          <leafValues>
+            4.3682569265365601e-01 5.6557738780975342e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 899 -3.4014228731393814e-02</internalNodes>
+          <leafValues>
+            7.8022962808609009e-01 4.9592170119285583e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 900 -1.2027299962937832e-02</internalNodes>
+          <leafValues>
+            1.5851010382175446e-01 5.0322318077087402e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 901 1.3316619396209717e-01</internalNodes>
+          <leafValues>
+            5.1633048057556152e-01 2.7551281452178955e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 902 -1.5221949433907866e-03</internalNodes>
+          <leafValues>
+            3.7283179163932800e-01 5.2145522832870483e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 903 -9.3929271679371595e-04</internalNodes>
+          <leafValues>
+            5.8383792638778687e-01 4.5111650228500366e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 904 2.7719739824533463e-02</internalNodes>
+          <leafValues>
+            4.7282868623733521e-01 7.3315447568893433e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 905 3.1030150130391121e-03</internalNodes>
+          <leafValues>
+            5.3022021055221558e-01 4.1015630960464478e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 906 7.7861219644546509e-02</internalNodes>
+          <leafValues>
+            4.9983340501785278e-01 1.2729619443416595e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 907 -1.5854939818382263e-02</internalNodes>
+          <leafValues>
+            5.0833359360694885e-02 5.1656562089920044e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 908 -4.9725300632417202e-03</internalNodes>
+          <leafValues>
+            6.7981338500976562e-01 4.6842318773269653e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 909 -9.7676506265997887e-04</internalNodes>
+          <leafValues>
+            6.0107719898223877e-01 4.7889319062232971e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 910 -2.4647710379213095e-03</internalNodes>
+          <leafValues>
+            3.3933979272842407e-01 5.2205038070678711e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 911 -6.7937700077891350e-03</internalNodes>
+          <leafValues>
+            4.3651369214057922e-01 5.2396631240844727e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 912 3.2608021050691605e-02</internalNodes>
+          <leafValues>
+            5.0527238845825195e-01 2.4252149462699890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 913 -5.8514421107247472e-04</internalNodes>
+          <leafValues>
+            5.7339739799499512e-01 4.7585740685462952e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 914 -2.9632600024342537e-02</internalNodes>
+          <leafValues>
+            3.8922891020774841e-01 5.2635979652404785e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>137</maxWeakCount>
+      <stageThreshold>6.7698921203613281e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 915 4.6550851315259933e-02</internalNodes>
+          <leafValues>
+            3.2769501209259033e-01 6.2405228614807129e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 916 7.9537127166986465e-03</internalNodes>
+          <leafValues>
+            4.2564851045608521e-01 6.9429391622543335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 917 6.8221561377868056e-04</internalNodes>
+          <leafValues>
+            3.7114870548248291e-01 5.9007328748703003e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 918 -1.9348249770700932e-04</internalNodes>
+          <leafValues>
+            2.0411339402198792e-01 5.3005450963973999e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 919 -2.6710508973337710e-04</internalNodes>
+          <leafValues>
+            5.4161262512207031e-01 3.1031790375709534e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 920 2.7818060480058193e-03</internalNodes>
+          <leafValues>
+            5.2778327465057373e-01 3.4670698642730713e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 921 -4.6779078547842801e-04</internalNodes>
+          <leafValues>
+            5.3082311153411865e-01 3.2944920659065247e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 922 -3.0335160772665404e-05</internalNodes>
+          <leafValues>
+            5.7738727331161499e-01 3.8520970940589905e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 923 7.8038009814918041e-04</internalNodes>
+          <leafValues>
+            4.3174389004707336e-01 6.1500579118728638e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 924 -4.2553851380944252e-03</internalNodes>
+          <leafValues>
+            2.9339039325714111e-01 5.3242927789688110e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 925 -2.4735610350035131e-04</internalNodes>
+          <leafValues>
+            5.4688447713851929e-01 3.8430300354957581e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 926 -1.4724259381182492e-04</internalNodes>
+          <leafValues>
+            4.2815428972244263e-01 5.7555872201919556e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 927 1.1864770203828812e-03</internalNodes>
+          <leafValues>
+            3.7473011016845703e-01 5.4714661836624146e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 928 2.3936580400913954e-03</internalNodes>
+          <leafValues>
+            4.5377838611602783e-01 6.1115288734436035e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 929 -1.5390539774671197e-03</internalNodes>
+          <leafValues>
+            2.9713419079780579e-01 5.1895380020141602e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 930 -7.1968790143728256e-03</internalNodes>
+          <leafValues>
+            6.6990667581558228e-01 4.7264769673347473e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 931 -4.1499789222143590e-04</internalNodes>
+          <leafValues>
+            3.3849540352821350e-01 5.2603179216384888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 932 4.4359830208122730e-03</internalNodes>
+          <leafValues>
+            5.3991222381591797e-01 3.9201408624649048e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 933 2.6606200262904167e-03</internalNodes>
+          <leafValues>
+            4.4825780391693115e-01 6.1196178197860718e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 934 -1.5287200221791863e-03</internalNodes>
+          <leafValues>
+            3.7112379074096680e-01 5.3402662277221680e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 935 -4.7397250309586525e-03</internalNodes>
+          <leafValues>
+            6.0310882329940796e-01 4.4551450014114380e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 936 -1.4829129911959171e-02</internalNodes>
+          <leafValues>
+            2.8387540578842163e-01 5.3418618440628052e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 937 9.2275557108223438e-04</internalNodes>
+          <leafValues>
+            5.2095472812652588e-01 3.3616539835929871e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 938 8.3529807627201080e-02</internalNodes>
+          <leafValues>
+            5.1199698448181152e-01 8.1164449453353882e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 939 -7.5633148662745953e-04</internalNodes>
+          <leafValues>
+            3.3171200752258301e-01 5.1898312568664551e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 940 9.8403859883546829e-03</internalNodes>
+          <leafValues>
+            5.2475982904434204e-01 2.3349590599536896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 941 -1.5953830443322659e-03</internalNodes>
+          <leafValues>
+            5.7500940561294556e-01 4.2956221103668213e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 942 3.4766020689858124e-05</internalNodes>
+          <leafValues>
+            4.3424451351165771e-01 5.5640292167663574e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 943 2.9862910509109497e-02</internalNodes>
+          <leafValues>
+            4.5791471004486084e-01 6.5791881084442139e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 944 1.1325590312480927e-02</internalNodes>
+          <leafValues>
+            5.2743119001388550e-01 3.6738881468772888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 945 -8.7828645482659340e-03</internalNodes>
+          <leafValues>
+            7.1003687381744385e-01 4.6421670913696289e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 946 4.3639959767460823e-03</internalNodes>
+          <leafValues>
+            5.2792161703109741e-01 2.7058771252632141e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 947 4.1804728098213673e-03</internalNodes>
+          <leafValues>
+            5.0725251436233521e-01 2.4490830302238464e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 948 -4.5668511302210391e-04</internalNodes>
+          <leafValues>
+            4.2831051349639893e-01 5.5486911535263062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 949 -3.7140368949621916e-03</internalNodes>
+          <leafValues>
+            5.5193877220153809e-01 4.1036531329154968e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 950 -2.5304289534687996e-02</internalNodes>
+          <leafValues>
+            6.8670022487640381e-01 4.8698890209197998e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 951 -3.4454080741852522e-04</internalNodes>
+          <leafValues>
+            3.7288740277290344e-01 5.2876931428909302e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 952 -8.3935231668874621e-04</internalNodes>
+          <leafValues>
+            6.0601520538330078e-01 4.6160620450973511e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 953 1.7280049622058868e-02</internalNodes>
+          <leafValues>
+            5.0496357679367065e-01 1.8198239803314209e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 954 -6.3595077954232693e-03</internalNodes>
+          <leafValues>
+            1.6312399506568909e-01 5.2327787876129150e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 955 1.0298109846189618e-03</internalNodes>
+          <leafValues>
+            4.4632780551910400e-01 6.1765491962432861e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 956 1.0117109632119536e-03</internalNodes>
+          <leafValues>
+            5.4733848571777344e-01 4.3006989359855652e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 957 -1.0308800265192986e-02</internalNodes>
+          <leafValues>
+            1.1669850349426270e-01 5.0008672475814819e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 958 5.4682018235325813e-03</internalNodes>
+          <leafValues>
+            4.7692871093750000e-01 6.7192137241363525e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 959 -9.1696460731327534e-04</internalNodes>
+          <leafValues>
+            3.4710898995399475e-01 5.1781648397445679e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 960 2.3922820109874010e-03</internalNodes>
+          <leafValues>
+            4.7852361202239990e-01 6.2163108587265015e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 961 -7.5573818758130074e-03</internalNodes>
+          <leafValues>
+            5.8147960901260376e-01 4.4100850820541382e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 962 -7.7024032361805439e-04</internalNodes>
+          <leafValues>
+            3.8780000805854797e-01 5.4657220840454102e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 963 -8.7125990539789200e-03</internalNodes>
+          <leafValues>
+            1.6600510478019714e-01 4.9958360195159912e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 964 -1.0306320153176785e-02</internalNodes>
+          <leafValues>
+            4.0933910012245178e-01 5.2742338180541992e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 965 -2.0940979011356831e-03</internalNodes>
+          <leafValues>
+            6.2061947584152222e-01 4.5722800493240356e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 966 6.8099051713943481e-03</internalNodes>
+          <leafValues>
+            5.5677592754364014e-01 4.1556000709533691e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 967 -1.0746059706434608e-03</internalNodes>
+          <leafValues>
+            5.6389278173446655e-01 4.3530249595642090e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 968 2.1550289820879698e-03</internalNodes>
+          <leafValues>
+            4.8262658715248108e-01 6.7497581243515015e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 969 3.1742319464683533e-02</internalNodes>
+          <leafValues>
+            5.0483798980712891e-01 1.8832489848136902e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 970 -7.8382723033428192e-02</internalNodes>
+          <leafValues>
+            2.3695489764213562e-01 5.2601581811904907e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 971 5.7415119372308254e-03</internalNodes>
+          <leafValues>
+            5.0488287210464478e-01 2.7764698863029480e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 972 -2.9014600440859795e-03</internalNodes>
+          <leafValues>
+            6.2386047840118408e-01 4.6933171153068542e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 973 -2.6427931152284145e-03</internalNodes>
+          <leafValues>
+            3.3141419291496277e-01 5.1697772741317749e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 974 -1.0949660092592239e-01</internalNodes>
+          <leafValues>
+            2.3800450563430786e-01 5.1834410429000854e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 975 7.4075913289561868e-05</internalNodes>
+          <leafValues>
+            4.0696358680725098e-01 5.3621500730514526e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 976 -5.0593802006915212e-04</internalNodes>
+          <leafValues>
+            5.5067062377929688e-01 4.3745940923690796e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 977 -8.2131777890026569e-04</internalNodes>
+          <leafValues>
+            5.5257099866867065e-01 4.2093759775161743e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 978 -6.0276539443293586e-05</internalNodes>
+          <leafValues>
+            5.4554748535156250e-01 4.7482660412788391e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 979 6.8065142259001732e-03</internalNodes>
+          <leafValues>
+            5.1579958200454712e-01 3.4245771169662476e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 980 1.7202789895236492e-03</internalNodes>
+          <leafValues>
+            5.0132077932357788e-01 6.3312637805938721e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 981 -1.3016929733566940e-04</internalNodes>
+          <leafValues>
+            5.5397182703018188e-01 4.2268699407577515e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 982 -4.8016388900578022e-03</internalNodes>
+          <leafValues>
+            4.4250950217247009e-01 5.4307800531387329e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 983 -2.5399310979992151e-03</internalNodes>
+          <leafValues>
+            7.1457821130752563e-01 4.6976050734519958e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 984 -1.4278929447755218e-03</internalNodes>
+          <leafValues>
+            4.0704450011253357e-01 5.3996050357818604e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 985 -2.5142550468444824e-02</internalNodes>
+          <leafValues>
+            7.8846907615661621e-01 4.7473520040512085e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 986 -3.8899609353393316e-03</internalNodes>
+          <leafValues>
+            4.2961919307708740e-01 5.5771100521087646e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 987 4.3947459198534489e-03</internalNodes>
+          <leafValues>
+            4.6931621432304382e-01 7.0239442586898804e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 988 2.4678420275449753e-02</internalNodes>
+          <leafValues>
+            5.2423220872879028e-01 3.8125100731849670e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 989 3.8047678768634796e-02</internalNodes>
+          <leafValues>
+            5.0117397308349609e-01 1.6878280043601990e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 990 7.9424865543842316e-03</internalNodes>
+          <leafValues>
+            4.8285821080207825e-01 6.3695681095123291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 991 -1.5110049862414598e-03</internalNodes>
+          <leafValues>
+            5.9064859151840210e-01 4.4876679778099060e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 992 6.4201741479337215e-03</internalNodes>
+          <leafValues>
+            5.2410978078842163e-01 2.9905700683593750e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 993 -2.9802159406244755e-03</internalNodes>
+          <leafValues>
+            3.0414658784866333e-01 5.0784897804260254e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 994 -7.4580078944563866e-04</internalNodes>
+          <leafValues>
+            4.1281390190124512e-01 5.2568262815475464e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 995 -1.0470950044691563e-02</internalNodes>
+          <leafValues>
+            5.8083951473236084e-01 4.4942960143089294e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 996 9.3369204550981522e-03</internalNodes>
+          <leafValues>
+            5.2465528249740601e-01 2.6589488983154297e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 997 2.7936900034546852e-02</internalNodes>
+          <leafValues>
+            4.6749550104141235e-01 7.0872569084167480e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 998 7.4277678504586220e-03</internalNodes>
+          <leafValues>
+            5.4094868898391724e-01 3.7585180997848511e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 999 -2.3584509268403053e-02</internalNodes>
+          <leafValues>
+            3.7586399912834167e-01 5.2385509014129639e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1000 1.1452640173956752e-03</internalNodes>
+          <leafValues>
+            4.3295788764953613e-01 5.8042472600936890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1001 -4.3468660442158580e-04</internalNodes>
+          <leafValues>
+            5.2806180715560913e-01 3.8730698823928833e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1002 1.0648540221154690e-02</internalNodes>
+          <leafValues>
+            4.9021130800247192e-01 5.6812518835067749e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1003 -3.9418050437234342e-04</internalNodes>
+          <leafValues>
+            5.5708801746368408e-01 4.3182510137557983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1004 -1.3270479394122958e-04</internalNodes>
+          <leafValues>
+            5.6584399938583374e-01 4.3435549736022949e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1005 -2.0125510636717081e-03</internalNodes>
+          <leafValues>
+            6.0567390918731689e-01 4.5375239849090576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1006 2.4854319635778666e-03</internalNodes>
+          <leafValues>
+            5.3904771804809570e-01 4.1380101442337036e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1007 1.8237880431115627e-03</internalNodes>
+          <leafValues>
+            4.3548288941383362e-01 5.7171887159347534e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1008 -1.6656659543514252e-02</internalNodes>
+          <leafValues>
+            3.0109131336212158e-01 5.2161228656768799e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1009 8.0349558265879750e-04</internalNodes>
+          <leafValues>
+            5.3001511096954346e-01 3.8183969259262085e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1010 3.4170378930866718e-03</internalNodes>
+          <leafValues>
+            5.3280287981033325e-01 4.2414000630378723e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1011 -3.6222729249857366e-04</internalNodes>
+          <leafValues>
+            5.4917281866073608e-01 4.1869771480560303e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1012 -1.1630020290613174e-01</internalNodes>
+          <leafValues>
+            1.4407220482826233e-01 5.2264511585235596e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1013 -1.4695010147988796e-02</internalNodes>
+          <leafValues>
+            7.7477252483367920e-01 4.7157171368598938e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1014 2.1972130052745342e-03</internalNodes>
+          <leafValues>
+            5.3554338216781616e-01 3.3156448602676392e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1015 -4.6965209185145795e-04</internalNodes>
+          <leafValues>
+            5.7672351598739624e-01 4.4581368565559387e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1016 6.5144998952746391e-03</internalNodes>
+          <leafValues>
+            5.2156740427017212e-01 3.6478888988494873e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1017 2.1300060674548149e-02</internalNodes>
+          <leafValues>
+            4.9942049384117126e-01 1.5679509937763214e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1018 3.1881409231573343e-03</internalNodes>
+          <leafValues>
+            4.7422000765800476e-01 6.2872701883316040e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1019 9.0019777417182922e-04</internalNodes>
+          <leafValues>
+            5.3479540348052979e-01 3.9437520503997803e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1020 -5.1772277802228928e-03</internalNodes>
+          <leafValues>
+            6.7271918058395386e-01 5.0131380558013916e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1021 -4.3764649890363216e-03</internalNodes>
+          <leafValues>
+            3.1066751480102539e-01 5.1287931203842163e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1022 2.6299960445612669e-03</internalNodes>
+          <leafValues>
+            4.8863101005554199e-01 5.7552158832550049e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1023 -2.0458688959479332e-03</internalNodes>
+          <leafValues>
+            6.0257941484451294e-01 4.5580768585205078e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1024 6.9482706487178802e-02</internalNodes>
+          <leafValues>
+            5.2407479286193848e-01 2.1852590143680573e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1025 2.4048939347267151e-02</internalNodes>
+          <leafValues>
+            5.0118672847747803e-01 2.0906220376491547e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1026 3.1095340382307768e-03</internalNodes>
+          <leafValues>
+            4.8667120933532715e-01 7.1085482835769653e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1027 -1.2503260513767600e-03</internalNodes>
+          <leafValues>
+            3.4078910946846008e-01 5.1561951637268066e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1028 -1.0281190043315291e-03</internalNodes>
+          <leafValues>
+            5.5755722522735596e-01 4.4394320249557495e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1029 -8.8893622159957886e-03</internalNodes>
+          <leafValues>
+            6.4020007848739624e-01 4.6204420924186707e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1030 -6.1094801640138030e-04</internalNodes>
+          <leafValues>
+            3.7664419412612915e-01 5.4488998651504517e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1031 -5.7686357758939266e-03</internalNodes>
+          <leafValues>
+            3.3186489343643188e-01 5.1336771249771118e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1032 1.8506490159779787e-03</internalNodes>
+          <leafValues>
+            4.9035701155662537e-01 6.4069348573684692e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1033 -9.9799469113349915e-02</internalNodes>
+          <leafValues>
+            1.5360510349273682e-01 5.0155621767044067e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1034 -3.5128349065780640e-01</internalNodes>
+          <leafValues>
+            5.8823131024837494e-02 5.1743787527084351e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1035 -4.5244570821523666e-02</internalNodes>
+          <leafValues>
+            6.9614887237548828e-01 4.6778729557991028e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1036 7.1481578052043915e-02</internalNodes>
+          <leafValues>
+            5.1679861545562744e-01 1.0380929708480835e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1037 2.1895780228078365e-03</internalNodes>
+          <leafValues>
+            4.2730781435966492e-01 5.5320608615875244e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1038 -5.9242651332169771e-04</internalNodes>
+          <leafValues>
+            4.6389439702033997e-01 5.2763891220092773e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1039 1.6788389766588807e-03</internalNodes>
+          <leafValues>
+            5.3016489744186401e-01 3.9320349693298340e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1040 -2.2163488902151585e-03</internalNodes>
+          <leafValues>
+            5.6306940317153931e-01 4.7570338845252991e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1041 1.1568699846975505e-04</internalNodes>
+          <leafValues>
+            4.3075358867645264e-01 5.5357027053833008e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1042 -7.2017288766801357e-03</internalNodes>
+          <leafValues>
+            1.4448820054531097e-01 5.1930642127990723e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1043 8.9081272017210722e-04</internalNodes>
+          <leafValues>
+            4.3844321370124817e-01 5.5936211347579956e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1044 1.9605009583756328e-04</internalNodes>
+          <leafValues>
+            5.3404158353805542e-01 4.7059568762779236e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1045 5.2022142335772514e-04</internalNodes>
+          <leafValues>
+            5.2138561010360718e-01 3.8100790977478027e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1046 9.4588572392240167e-04</internalNodes>
+          <leafValues>
+            4.7694149613380432e-01 6.1307388544082642e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1047 9.1698471806012094e-05</internalNodes>
+          <leafValues>
+            4.2450091242790222e-01 5.4293632507324219e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1048 2.1833200007677078e-03</internalNodes>
+          <leafValues>
+            5.4577308893203735e-01 4.1910758614540100e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1049 -8.6039671441540122e-04</internalNodes>
+          <leafValues>
+            5.7645887136459351e-01 4.4716599583625793e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1050 -1.3236239552497864e-02</internalNodes>
+          <leafValues>
+            6.3728231191635132e-01 4.6950098872184753e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1051 4.3376701069064438e-04</internalNodes>
+          <leafValues>
+            5.3178739547729492e-01 3.9458298683166504e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>140</maxWeakCount>
+      <stageThreshold>6.9229873657226562e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1052 -2.4847149848937988e-02</internalNodes>
+          <leafValues>
+            6.5555167198181152e-01 3.8733118772506714e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1053 6.1348611488938332e-03</internalNodes>
+          <leafValues>
+            3.7480720877647400e-01 5.9739977121353149e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1054 6.4498498104512691e-03</internalNodes>
+          <leafValues>
+            5.4254919290542603e-01 2.5488111376762390e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1055 6.3491211039945483e-04</internalNodes>
+          <leafValues>
+            2.4624420702457428e-01 5.3872537612915039e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1056 1.4023890253156424e-03</internalNodes>
+          <leafValues>
+            5.5943220853805542e-01 3.5286578536033630e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1057 3.0044000595808029e-04</internalNodes>
+          <leafValues>
+            3.9585039019584656e-01 5.7659381628036499e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1058 1.0042409849120304e-04</internalNodes>
+          <leafValues>
+            3.6989969015121460e-01 5.5349981784820557e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1059 -5.0841490738093853e-03</internalNodes>
+          <leafValues>
+            3.7110909819602966e-01 5.5478000640869141e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1060 -1.9537260755896568e-02</internalNodes>
+          <leafValues>
+            7.4927550554275513e-01 4.5792970061302185e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1061 -7.4532740654831287e-06</internalNodes>
+          <leafValues>
+            5.6497871875762939e-01 3.9040699601173401e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1062 -3.6079459823668003e-03</internalNodes>
+          <leafValues>
+            3.3810880780220032e-01 5.2678012847900391e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1063 2.0697501022368670e-03</internalNodes>
+          <leafValues>
+            5.5192911624908447e-01 3.7143889069557190e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1064 -4.6463840408250690e-04</internalNodes>
+          <leafValues>
+            5.6082147359848022e-01 4.1135668754577637e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1065 7.5490452582016587e-04</internalNodes>
+          <leafValues>
+            3.5592061281204224e-01 5.3293561935424805e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1066 -9.8322238773107529e-04</internalNodes>
+          <leafValues>
+            5.4147958755493164e-01 3.7632051110267639e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1067 -1.9940640777349472e-02</internalNodes>
+          <leafValues>
+            6.3479030132293701e-01 4.7052991390228271e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1068 3.7680300883948803e-03</internalNodes>
+          <leafValues>
+            3.9134898781776428e-01 5.5637162923812866e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1069 -9.4528505578637123e-03</internalNodes>
+          <leafValues>
+            2.5548928976058960e-01 5.2151167392730713e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1070 2.9560849070549011e-03</internalNodes>
+          <leafValues>
+            5.1746791601181030e-01 3.0639201402664185e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1071 9.1078737750649452e-03</internalNodes>
+          <leafValues>
+            5.3884482383728027e-01 2.8859630227088928e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1072 1.8219229532405734e-03</internalNodes>
+          <leafValues>
+            4.3360430002212524e-01 5.8521968126296997e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1073 1.4688739553093910e-02</internalNodes>
+          <leafValues>
+            5.2873617410659790e-01 2.8700059652328491e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1074 -1.4387990348041058e-02</internalNodes>
+          <leafValues>
+            7.0194488763809204e-01 4.6473708748817444e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1075 -1.8986649811267853e-02</internalNodes>
+          <leafValues>
+            2.9865521192550659e-01 5.2470117807388306e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1076 1.1527639580890536e-03</internalNodes>
+          <leafValues>
+            4.3234738707542419e-01 5.9316617250442505e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1077 1.0933670215308666e-02</internalNodes>
+          <leafValues>
+            5.2868640422821045e-01 3.1303191184997559e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1078 -1.4932730235159397e-02</internalNodes>
+          <leafValues>
+            2.6584190130233765e-01 5.0840771198272705e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1079 -2.9970539617352188e-04</internalNodes>
+          <leafValues>
+            5.4635268449783325e-01 3.7407240271568298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1080 4.1677621193230152e-03</internalNodes>
+          <leafValues>
+            4.7034969925880432e-01 7.4357217550277710e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1081 -6.3905320130288601e-03</internalNodes>
+          <leafValues>
+            2.0692589879035950e-01 5.2805382013320923e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1082 4.5029609464108944e-03</internalNodes>
+          <leafValues>
+            5.1826488971710205e-01 3.4835430979728699e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1083 -9.2040365561842918e-03</internalNodes>
+          <leafValues>
+            6.8037772178649902e-01 4.9323600530624390e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1084 8.1327259540557861e-02</internalNodes>
+          <leafValues>
+            5.0583988428115845e-01 2.2530519962310791e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1085 -1.5079280734062195e-01</internalNodes>
+          <leafValues>
+            2.9634249210357666e-01 5.2646797895431519e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1086 3.3179009333252907e-03</internalNodes>
+          <leafValues>
+            4.6554958820343018e-01 7.0729321241378784e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1087 7.7402801252901554e-04</internalNodes>
+          <leafValues>
+            4.7803479433059692e-01 5.6682378053665161e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1088 6.8199541419744492e-04</internalNodes>
+          <leafValues>
+            4.2869961261749268e-01 5.7221567630767822e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1089 5.3671570494771004e-03</internalNodes>
+          <leafValues>
+            5.2993071079254150e-01 3.1146219372749329e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1090 9.7018666565418243e-05</internalNodes>
+          <leafValues>
+            3.6746388673782349e-01 5.2694618701934814e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1091 -1.2534089386463165e-01</internalNodes>
+          <leafValues>
+            2.3514920473098755e-01 5.2457910776138306e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1092 -5.2516269497573376e-03</internalNodes>
+          <leafValues>
+            7.1159368753433228e-01 4.6937671303749084e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1093 -7.8342109918594360e-03</internalNodes>
+          <leafValues>
+            4.4626510143280029e-01 5.4090857505798340e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1094 -1.1310069821774960e-03</internalNodes>
+          <leafValues>
+            5.9456187486648560e-01 4.4176620244979858e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1095 1.7601120052859187e-03</internalNodes>
+          <leafValues>
+            5.3532499074935913e-01 3.9734530448913574e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1096 -8.1581249833106995e-04</internalNodes>
+          <leafValues>
+            3.7602680921554565e-01 5.2647268772125244e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1097 -3.8687589112669230e-03</internalNodes>
+          <leafValues>
+            6.3099128007888794e-01 4.7498199343681335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1098 1.5207129763439298e-03</internalNodes>
+          <leafValues>
+            5.2301818132400513e-01 3.3612239360809326e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1099 5.4586738348007202e-01</internalNodes>
+          <leafValues>
+            5.1671397686004639e-01 1.1726350337266922e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1100 1.5650190412998199e-02</internalNodes>
+          <leafValues>
+            4.9794390797615051e-01 1.3932949304580688e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1101 -1.1731860227882862e-02</internalNodes>
+          <leafValues>
+            7.1296507120132446e-01 4.9211961030960083e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1102 -6.1765122227370739e-03</internalNodes>
+          <leafValues>
+            2.2881029546260834e-01 5.0497019290924072e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1103 2.2457661107182503e-03</internalNodes>
+          <leafValues>
+            4.6324339509010315e-01 6.0487258434295654e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1104 -5.1915869116783142e-03</internalNodes>
+          <leafValues>
+            6.4674210548400879e-01 4.6021929383277893e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1105 -2.3827880620956421e-02</internalNodes>
+          <leafValues>
+            1.4820009469985962e-01 5.2260792255401611e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1106 1.0284580057486892e-03</internalNodes>
+          <leafValues>
+            5.1354891061782837e-01 3.3759570121765137e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1107 -1.0078850202262402e-02</internalNodes>
+          <leafValues>
+            2.7405610680580139e-01 5.3035670518875122e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1108 2.6168930344283581e-03</internalNodes>
+          <leafValues>
+            5.3326708078384399e-01 3.9724540710449219e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1109 5.4385367548093200e-04</internalNodes>
+          <leafValues>
+            5.3656041622161865e-01 4.0634119510650635e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1110 5.3510512225329876e-03</internalNodes>
+          <leafValues>
+            4.6537590026855469e-01 6.8890458345413208e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1111 -1.5274790348485112e-03</internalNodes>
+          <leafValues>
+            5.4495012760162354e-01 3.6247238516807556e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1112 -8.0624416470527649e-02</internalNodes>
+          <leafValues>
+            1.6560870409011841e-01 5.0002872943878174e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1113 2.2192029282450676e-02</internalNodes>
+          <leafValues>
+            5.1327311992645264e-01 2.0028080046176910e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1114 7.3100631125271320e-03</internalNodes>
+          <leafValues>
+            4.6179479360580444e-01 6.3665360212326050e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1115 -6.4063072204589844e-03</internalNodes>
+          <leafValues>
+            5.9162509441375732e-01 4.8678609728813171e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1116 -7.6415040530264378e-04</internalNodes>
+          <leafValues>
+            3.8884091377258301e-01 5.3157979249954224e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1117 7.6734489994123578e-04</internalNodes>
+          <leafValues>
+            4.1590648889541626e-01 5.6052798032760620e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1118 6.1474501853808761e-04</internalNodes>
+          <leafValues>
+            3.0890220403671265e-01 5.1201480627059937e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1119 -5.0105270929634571e-03</internalNodes>
+          <leafValues>
+            3.9721998572349548e-01 5.2073061466217041e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1120 -8.6909132078289986e-03</internalNodes>
+          <leafValues>
+            6.2574082612991333e-01 4.6085759997367859e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1121 -1.6391459852457047e-02</internalNodes>
+          <leafValues>
+            2.0852099359035492e-01 5.2422660589218140e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1122 4.0973909199237823e-04</internalNodes>
+          <leafValues>
+            5.2224272489547729e-01 3.7803208827972412e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1123 -2.5242289993911982e-03</internalNodes>
+          <leafValues>
+            5.8039271831512451e-01 4.6118900179862976e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1124 5.0945312250405550e-04</internalNodes>
+          <leafValues>
+            4.4012719392776489e-01 5.8460158109664917e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1125 1.9656419754028320e-03</internalNodes>
+          <leafValues>
+            5.3223252296447754e-01 4.1845908761024475e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1126 5.6298897834494710e-04</internalNodes>
+          <leafValues>
+            3.7418448925018311e-01 5.2345657348632812e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1127 -6.7946797935292125e-04</internalNodes>
+          <leafValues>
+            4.6310418844223022e-01 5.3564780950546265e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1128 7.2856349870562553e-03</internalNodes>
+          <leafValues>
+            5.0446701049804688e-01 2.3775640130043030e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1129 -1.7459489405155182e-02</internalNodes>
+          <leafValues>
+            7.2891211509704590e-01 5.0504350662231445e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1130 -2.5421749800443649e-02</internalNodes>
+          <leafValues>
+            6.6671347618103027e-01 4.6781000494956970e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1131 -1.5647639520466328e-03</internalNodes>
+          <leafValues>
+            4.3917590379714966e-01 5.3236269950866699e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1132 1.1444360017776489e-02</internalNodes>
+          <leafValues>
+            4.3464401364326477e-01 5.6800121068954468e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1133 -6.7352550104260445e-04</internalNodes>
+          <leafValues>
+            4.4771409034729004e-01 5.2968120574951172e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1134 9.3194209039211273e-03</internalNodes>
+          <leafValues>
+            4.7402000427246094e-01 7.4626070261001587e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1135 1.3328490604180843e-04</internalNodes>
+          <leafValues>
+            5.3650617599487305e-01 4.7521349787712097e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1136 -7.8815799206495285e-03</internalNodes>
+          <leafValues>
+            1.7522190511226654e-01 5.0152552127838135e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1137 -5.7985680177807808e-03</internalNodes>
+          <leafValues>
+            7.2712367773056030e-01 4.8962008953094482e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1138 -3.8922499516047537e-04</internalNodes>
+          <leafValues>
+            4.0039089322090149e-01 5.3449410200119019e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1139 -1.9288610201328993e-03</internalNodes>
+          <leafValues>
+            5.6056129932403564e-01 4.8039558529853821e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1140 8.4214154630899429e-03</internalNodes>
+          <leafValues>
+            4.7532469034194946e-01 7.6236087083816528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1141 8.1655876711010933e-03</internalNodes>
+          <leafValues>
+            5.3932619094848633e-01 4.1916438937187195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1142 4.8280550981871784e-04</internalNodes>
+          <leafValues>
+            4.2408001422882080e-01 5.3998219966888428e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1143 -2.7186630759388208e-03</internalNodes>
+          <leafValues>
+            4.2445999383926392e-01 5.4249238967895508e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1144 -1.2507230043411255e-02</internalNodes>
+          <leafValues>
+            5.8958417177200317e-01 4.5504111051559448e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1145 -2.4286519736051559e-02</internalNodes>
+          <leafValues>
+            2.6471349596977234e-01 5.1891797780990601e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1146 -2.9676330741494894e-03</internalNodes>
+          <leafValues>
+            7.3476827144622803e-01 4.7497498989105225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1147 -1.2528999708592892e-02</internalNodes>
+          <leafValues>
+            2.7560499310493469e-01 5.1775997877120972e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1148 -1.0104000102728605e-03</internalNodes>
+          <leafValues>
+            3.5105609893798828e-01 5.1447242498397827e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1149 -2.1348530426621437e-03</internalNodes>
+          <leafValues>
+            5.6379258632659912e-01 4.6673199534416199e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1150 1.9564259797334671e-02</internalNodes>
+          <leafValues>
+            4.6145731210708618e-01 6.1376398801803589e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1151 -9.7146347165107727e-02</internalNodes>
+          <leafValues>
+            2.9983788728713989e-01 5.1935559511184692e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1152 4.5014568604528904e-03</internalNodes>
+          <leafValues>
+            5.0778847932815552e-01 3.0457559227943420e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1153 6.3706971704959869e-03</internalNodes>
+          <leafValues>
+            4.8610189557075500e-01 6.8875008821487427e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1154 -9.0721528977155685e-03</internalNodes>
+          <leafValues>
+            1.6733959317207336e-01 5.0175631046295166e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1155 -5.3537208586931229e-03</internalNodes>
+          <leafValues>
+            2.6927569508552551e-01 5.2426332235336304e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1156 -1.0932840406894684e-02</internalNodes>
+          <leafValues>
+            7.1838641166687012e-01 4.7360289096832275e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1157 8.2356072962284088e-03</internalNodes>
+          <leafValues>
+            5.2239668369293213e-01 2.3898629844188690e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1158 -1.0038160253316164e-03</internalNodes>
+          <leafValues>
+            5.7193559408187866e-01 4.4339430332183838e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1159 4.0859128348529339e-03</internalNodes>
+          <leafValues>
+            5.4728418588638306e-01 4.1488361358642578e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1160 1.5485419332981110e-01</internalNodes>
+          <leafValues>
+            4.9738121032714844e-01 6.1061598360538483e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1161 2.0897459762636572e-04</internalNodes>
+          <leafValues>
+            4.7091740369796753e-01 5.4238891601562500e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1162 3.3316991175524890e-04</internalNodes>
+          <leafValues>
+            4.0896269679069519e-01 5.3009921312332153e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1163 -1.0813400149345398e-02</internalNodes>
+          <leafValues>
+            6.1043697595596313e-01 4.9573341012001038e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1164 4.5656010508537292e-02</internalNodes>
+          <leafValues>
+            5.0696891546249390e-01 2.8666600584983826e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1165 1.2569549726322293e-03</internalNodes>
+          <leafValues>
+            4.8469170928001404e-01 6.3181710243225098e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1166 -1.2015070021152496e-01</internalNodes>
+          <leafValues>
+            6.0526140034198761e-02 4.9809598922729492e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1167 -1.0533799650147557e-04</internalNodes>
+          <leafValues>
+            5.3631097078323364e-01 4.7080421447753906e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1168 -2.0703190565109253e-01</internalNodes>
+          <leafValues>
+            5.9660330414772034e-02 4.9790981411933899e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1169 1.2909180077258497e-04</internalNodes>
+          <leafValues>
+            4.7129771113395691e-01 5.3779977560043335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1170 3.8818528992123902e-04</internalNodes>
+          <leafValues>
+            4.3635380268096924e-01 5.5341911315917969e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1171 -2.9243610333651304e-03</internalNodes>
+          <leafValues>
+            5.8111858367919922e-01 4.8252159357070923e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1172 8.3882332546636462e-04</internalNodes>
+          <leafValues>
+            5.3117001056671143e-01 4.0381389856338501e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1173 -1.9061550265178084e-03</internalNodes>
+          <leafValues>
+            3.7707018852233887e-01 5.2600151300430298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1174 8.9514348655939102e-03</internalNodes>
+          <leafValues>
+            4.7661679983139038e-01 7.6821839809417725e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1175 1.3083459809422493e-02</internalNodes>
+          <leafValues>
+            5.2644628286361694e-01 3.0622220039367676e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1176 -2.1159330010414124e-01</internalNodes>
+          <leafValues>
+            6.7371982336044312e-01 4.6958100795745850e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1177 3.1493250280618668e-03</internalNodes>
+          <leafValues>
+            5.6448352336883545e-01 4.3869531154632568e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1178 3.9754100725986063e-04</internalNodes>
+          <leafValues>
+            4.5260611176490784e-01 5.8956301212310791e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1179 -1.3814480043947697e-03</internalNodes>
+          <leafValues>
+            6.0705822706222534e-01 4.9424138665199280e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1180 -5.8122188784182072e-04</internalNodes>
+          <leafValues>
+            5.9982132911682129e-01 4.5082521438598633e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1181 -2.3905329871922731e-03</internalNodes>
+          <leafValues>
+            4.2055889964103699e-01 5.2238482236862183e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1182 2.7268929407000542e-02</internalNodes>
+          <leafValues>
+            5.2064472436904907e-01 3.5633018612861633e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1183 -3.7658358924090862e-03</internalNodes>
+          <leafValues>
+            3.1447041034698486e-01 5.2188140153884888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1184 -1.4903489500284195e-03</internalNodes>
+          <leafValues>
+            3.3801960945129395e-01 5.1244372129440308e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1185 -1.7428230494260788e-02</internalNodes>
+          <leafValues>
+            5.8299607038497925e-01 4.9197259545326233e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1186 -1.5278030186891556e-02</internalNodes>
+          <leafValues>
+            6.1631447076797485e-01 4.6178871393203735e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1187 3.1995609402656555e-02</internalNodes>
+          <leafValues>
+            5.1663571596145630e-01 1.7127640545368195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1188 -3.8256710395216942e-03</internalNodes>
+          <leafValues>
+            3.4080120921134949e-01 5.1313877105712891e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1189 -8.5186436772346497e-03</internalNodes>
+          <leafValues>
+            6.1055189371109009e-01 4.9979418516159058e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1190 9.0641621500253677e-04</internalNodes>
+          <leafValues>
+            4.3272709846496582e-01 5.5823111534118652e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1191 1.0344849899411201e-02</internalNodes>
+          <leafValues>
+            4.8556530475616455e-01 5.4524201154708862e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>160</maxWeakCount>
+      <stageThreshold>7.9249076843261719e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1192 7.8981826081871986e-03</internalNodes>
+          <leafValues>
+            3.3325248956680298e-01 5.9464621543884277e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1193 1.6170160379260778e-03</internalNodes>
+          <leafValues>
+            3.4906411170959473e-01 5.5778688192367554e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1194 -5.5449741194024682e-04</internalNodes>
+          <leafValues>
+            5.5425661802291870e-01 3.2915300130844116e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1195 1.5428980113938451e-03</internalNodes>
+          <leafValues>
+            3.6125791072845459e-01 5.5459791421890259e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1196 -1.0329450014978647e-03</internalNodes>
+          <leafValues>
+            3.5301390290260315e-01 5.5761402845382690e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1197 7.7698158565908670e-04</internalNodes>
+          <leafValues>
+            3.9167788624763489e-01 5.6453210115432739e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1198 1.4320300519466400e-01</internalNodes>
+          <leafValues>
+            4.6674820780754089e-01 7.0236331224441528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1199 -7.3866490274667740e-03</internalNodes>
+          <leafValues>
+            3.0736848711967468e-01 5.2892577648162842e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1200 -6.2936742324382067e-04</internalNodes>
+          <leafValues>
+            5.6221181154251099e-01 4.0370491147041321e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1201 7.8893528552725911e-04</internalNodes>
+          <leafValues>
+            5.2676612138748169e-01 3.5578748583793640e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1202 -1.2228050269186497e-02</internalNodes>
+          <leafValues>
+            6.6683208942413330e-01 4.6255499124526978e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1203 3.5420239437371492e-03</internalNodes>
+          <leafValues>
+            5.5214381217956543e-01 3.8696730136871338e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1204 -1.0585320414975286e-03</internalNodes>
+          <leafValues>
+            3.6286780238151550e-01 5.3209269046783447e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1205 1.4935660146875307e-05</internalNodes>
+          <leafValues>
+            4.6324449777603149e-01 5.3633230924606323e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1206 5.2537708543241024e-03</internalNodes>
+          <leafValues>
+            5.1322317123413086e-01 3.2657089829444885e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1207 -8.2338023930788040e-03</internalNodes>
+          <leafValues>
+            6.6936898231506348e-01 4.7741401195526123e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1208 2.1866810129722580e-05</internalNodes>
+          <leafValues>
+            4.0538620948791504e-01 5.4579311609268188e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1209 -3.8150229956954718e-03</internalNodes>
+          <leafValues>
+            6.4549958705902100e-01 4.7931781411170959e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1210 1.1105879675596952e-03</internalNodes>
+          <leafValues>
+            5.2704071998596191e-01 3.5296788811683655e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1211 -5.7707689702510834e-03</internalNodes>
+          <leafValues>
+            3.8035470247268677e-01 5.3529578447341919e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1212 -3.0158339068293571e-03</internalNodes>
+          <leafValues>
+            5.3394031524658203e-01 3.8871330022811890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1213 -8.5453689098358154e-04</internalNodes>
+          <leafValues>
+            3.5646161437034607e-01 5.2736037969589233e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1214 1.1050510220229626e-02</internalNodes>
+          <leafValues>
+            4.6719071269035339e-01 6.8497377634048462e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1215 4.2605839669704437e-02</internalNodes>
+          <leafValues>
+            5.1514732837677002e-01 7.0220090448856354e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1216 -3.0781750101596117e-03</internalNodes>
+          <leafValues>
+            3.0416610836982727e-01 5.1526021957397461e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1217 -5.4815728217363358e-03</internalNodes>
+          <leafValues>
+            6.4302957057952881e-01 4.8972299695014954e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1218 3.1881860923022032e-03</internalNodes>
+          <leafValues>
+            5.3074932098388672e-01 3.8262099027633667e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1219 3.5947180003859103e-04</internalNodes>
+          <leafValues>
+            4.6500471234321594e-01 5.4219049215316772e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1220 -4.0705031715333462e-03</internalNodes>
+          <leafValues>
+            2.8496798872947693e-01 5.0791162252426147e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1221 -1.4594170264899731e-02</internalNodes>
+          <leafValues>
+            2.9716458916664124e-01 5.1284617185592651e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1222 -1.1947689927183092e-04</internalNodes>
+          <leafValues>
+            5.6310981512069702e-01 4.3430820107460022e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1223 -6.9344649091362953e-04</internalNodes>
+          <leafValues>
+            4.4035780429840088e-01 5.3599590063095093e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1224 1.4834799912932795e-05</internalNodes>
+          <leafValues>
+            3.4210088849067688e-01 5.1646977663040161e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1225 9.0296985581517220e-03</internalNodes>
+          <leafValues>
+            4.6393430233001709e-01 6.1140751838684082e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1226 -8.0640818923711777e-03</internalNodes>
+          <leafValues>
+            2.8201588988304138e-01 5.0754940509796143e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1227 2.6062119752168655e-02</internalNodes>
+          <leafValues>
+            5.2089059352874756e-01 2.6887780427932739e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1228 1.7314659431576729e-02</internalNodes>
+          <leafValues>
+            4.6637138724327087e-01 6.7385399341583252e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1229 2.2666640579700470e-02</internalNodes>
+          <leafValues>
+            5.2093499898910522e-01 2.2127239406108856e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1230 -2.1965929772704840e-03</internalNodes>
+          <leafValues>
+            6.0631012916564941e-01 4.5381900668144226e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1231 -9.5282476395368576e-03</internalNodes>
+          <leafValues>
+            4.6352049708366394e-01 5.2474308013916016e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1232 8.0943619832396507e-03</internalNodes>
+          <leafValues>
+            5.2894401550292969e-01 3.9138820767402649e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1233 -7.2877332568168640e-02</internalNodes>
+          <leafValues>
+            7.7520018815994263e-01 4.9902349710464478e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1234 -6.9009521976113319e-03</internalNodes>
+          <leafValues>
+            2.4280390143394470e-01 5.0480902194976807e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1235 -1.1308239772915840e-02</internalNodes>
+          <leafValues>
+            5.7343649864196777e-01 4.8423761129379272e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1236 5.9613201767206192e-02</internalNodes>
+          <leafValues>
+            5.0298362970352173e-01 2.5249770283699036e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1237 -2.8624620754271746e-03</internalNodes>
+          <leafValues>
+            6.0730451345443726e-01 4.8984599113464355e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1238 4.4781449250876904e-03</internalNodes>
+          <leafValues>
+            5.0152891874313354e-01 2.2203169763088226e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1239 -1.7513240454718471e-03</internalNodes>
+          <leafValues>
+            6.6144287586212158e-01 4.9338689446449280e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1240 4.0163420140743256e-02</internalNodes>
+          <leafValues>
+            5.1808780431747437e-01 3.7410449981689453e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1241 3.4768949262797832e-04</internalNodes>
+          <leafValues>
+            4.7204169631004333e-01 5.8180320262908936e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1242 2.6551650371402502e-03</internalNodes>
+          <leafValues>
+            3.8050109148025513e-01 5.2213358879089355e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1243 -8.7706279009580612e-03</internalNodes>
+          <leafValues>
+            2.9441660642623901e-01 5.2312952280044556e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1244 -5.5122091434895992e-03</internalNodes>
+          <leafValues>
+            7.3461771011352539e-01 4.7228169441223145e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1245 6.8672042107209563e-04</internalNodes>
+          <leafValues>
+            5.4528760910034180e-01 4.2424130439758301e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1246 5.6019669864326715e-04</internalNodes>
+          <leafValues>
+            4.3988621234893799e-01 5.6012850999832153e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1247 2.4143769405782223e-03</internalNodes>
+          <leafValues>
+            4.7416868805885315e-01 6.1366218328475952e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1248 -1.5680900542065501e-03</internalNodes>
+          <leafValues>
+            6.0445529222488403e-01 4.5164099335670471e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1249 -3.6827491130679846e-03</internalNodes>
+          <leafValues>
+            2.4524590373039246e-01 5.2949821949005127e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1250 -2.9409190756268799e-04</internalNodes>
+          <leafValues>
+            3.7328380346298218e-01 5.2514511346817017e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1251 4.2847759323194623e-04</internalNodes>
+          <leafValues>
+            5.4988098144531250e-01 4.0655350685119629e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1252 -4.8817070201039314e-03</internalNodes>
+          <leafValues>
+            2.1399089694023132e-01 4.9999570846557617e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1253 2.7272020815871656e-04</internalNodes>
+          <leafValues>
+            4.6502870321273804e-01 5.8134287595748901e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1254 2.0947199664078653e-04</internalNodes>
+          <leafValues>
+            4.3874868750572205e-01 5.5727928876876831e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1255 4.8501189798116684e-02</internalNodes>
+          <leafValues>
+            5.2449727058410645e-01 3.2128891348838806e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1256 -4.5166411437094212e-03</internalNodes>
+          <leafValues>
+            6.0568130016326904e-01 4.5458820462226868e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1257 -1.2291680090129375e-02</internalNodes>
+          <leafValues>
+            2.0409290492534637e-01 5.1522141695022583e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1258 4.8549679922871292e-04</internalNodes>
+          <leafValues>
+            5.2376049757003784e-01 3.7395030260086060e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1259 3.0556049197912216e-02</internalNodes>
+          <leafValues>
+            4.9605339765548706e-01 5.9382462501525879e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1260 -1.5105320198927075e-04</internalNodes>
+          <leafValues>
+            5.3513038158416748e-01 4.1452041268348694e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1261 2.4937440175563097e-03</internalNodes>
+          <leafValues>
+            4.6933668851852417e-01 5.5149412155151367e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1262 -1.2382130138576031e-02</internalNodes>
+          <leafValues>
+            6.7913967370986938e-01 4.6816679835319519e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1263 -5.1333461888134480e-03</internalNodes>
+          <leafValues>
+            3.6087390780448914e-01 5.2291601896286011e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1264 5.1919277757406235e-04</internalNodes>
+          <leafValues>
+            5.3000730276107788e-01 3.6336138844490051e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1265 1.5060420334339142e-01</internalNodes>
+          <leafValues>
+            5.1573169231414795e-01 2.2117820382118225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1266 7.7144149690866470e-03</internalNodes>
+          <leafValues>
+            4.4104969501495361e-01 5.7766091823577881e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1267 9.4443522393703461e-03</internalNodes>
+          <leafValues>
+            5.4018551111221313e-01 3.7566500902175903e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1268 2.5006249779835343e-04</internalNodes>
+          <leafValues>
+            4.3682709336280823e-01 5.6073749065399170e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1269 -3.3077150583267212e-03</internalNodes>
+          <leafValues>
+            4.2447990179061890e-01 5.5182307958602905e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1270 7.4048910755664110e-04</internalNodes>
+          <leafValues>
+            4.4969621300697327e-01 5.9005767107009888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1271 4.4092051684856415e-02</internalNodes>
+          <leafValues>
+            5.2934932708740234e-01 3.1563550233840942e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1272 3.3639909233897924e-03</internalNodes>
+          <leafValues>
+            4.4832968711853027e-01 5.8486622571945190e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1273 -3.9760079234838486e-03</internalNodes>
+          <leafValues>
+            4.5595070719718933e-01 5.4836392402648926e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1274 2.7716930489987135e-03</internalNodes>
+          <leafValues>
+            5.3417861461639404e-01 3.7924841046333313e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1275 -2.4123019829858094e-04</internalNodes>
+          <leafValues>
+            5.6671887636184692e-01 4.5769730210304260e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1276 4.9425667384639382e-04</internalNodes>
+          <leafValues>
+            4.4212448596954346e-01 5.6287872791290283e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1277 -3.8876468897797167e-04</internalNodes>
+          <leafValues>
+            4.2883709073066711e-01 5.3910630941390991e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1278 -5.0048898905515671e-02</internalNodes>
+          <leafValues>
+            6.8995130062103271e-01 4.7037428617477417e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1279 -3.6635480821132660e-02</internalNodes>
+          <leafValues>
+            2.2177790105342865e-01 5.1918262243270874e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1280 2.4273579474538565e-03</internalNodes>
+          <leafValues>
+            5.1362240314483643e-01 3.4973978996276855e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1281 1.9558030180633068e-03</internalNodes>
+          <leafValues>
+            4.8261928558349609e-01 6.4083808660507202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1282 -1.7494610510766506e-03</internalNodes>
+          <leafValues>
+            3.9228358864784241e-01 5.2726852893829346e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1283 1.3955079950392246e-02</internalNodes>
+          <leafValues>
+            5.0782018899917603e-01 8.4165048599243164e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1284 -2.1896739781368524e-04</internalNodes>
+          <leafValues>
+            5.5204898118972778e-01 4.3142348527908325e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1285 -1.5131309628486633e-03</internalNodes>
+          <leafValues>
+            3.9346051216125488e-01 5.3825712203979492e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1286 -4.3622800149023533e-03</internalNodes>
+          <leafValues>
+            7.3706287145614624e-01 4.7364759445190430e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1287 6.5160587430000305e-02</internalNodes>
+          <leafValues>
+            5.1592797040939331e-01 3.2815951108932495e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1288 -2.3567399475723505e-03</internalNodes>
+          <leafValues>
+            3.6728268861770630e-01 5.1728862524032593e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1289 1.5146659687161446e-02</internalNodes>
+          <leafValues>
+            5.0314939022064209e-01 6.6876041889190674e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1290 -2.2850960493087769e-02</internalNodes>
+          <leafValues>
+            6.7675197124481201e-01 4.7095969319343567e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1291 4.8867650330066681e-03</internalNodes>
+          <leafValues>
+            5.2579981088638306e-01 4.0598788857460022e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1292 1.7619599821045995e-03</internalNodes>
+          <leafValues>
+            4.6962729096412659e-01 6.6882789134979248e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1293 -1.2942519970238209e-03</internalNodes>
+          <leafValues>
+            4.3207129836082458e-01 5.3442817926406860e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1294 1.0929949581623077e-02</internalNodes>
+          <leafValues>
+            4.9977061152458191e-01 1.6374860703945160e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1295 2.9958489903947338e-05</internalNodes>
+          <leafValues>
+            4.2824178934097290e-01 5.6332242488861084e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1296 -6.5884361974895000e-03</internalNodes>
+          <leafValues>
+            6.7721211910247803e-01 4.7005268931388855e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1297 3.2527779694646597e-03</internalNodes>
+          <leafValues>
+            5.3133970499038696e-01 4.5361489057540894e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1298 -4.0435739792883396e-03</internalNodes>
+          <leafValues>
+            5.6600618362426758e-01 4.4133889675140381e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1299 -1.2523540062829852e-03</internalNodes>
+          <leafValues>
+            3.7319138646125793e-01 5.3564518690109253e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1300 1.9246719602961093e-04</internalNodes>
+          <leafValues>
+            5.1899862289428711e-01 3.7388110160827637e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1301 -3.8589671254158020e-02</internalNodes>
+          <leafValues>
+            2.9563739895820618e-01 5.1888108253479004e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1302 1.5489870565943420e-04</internalNodes>
+          <leafValues>
+            4.3471351265907288e-01 5.5095332860946655e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1303 -3.3763848245143890e-02</internalNodes>
+          <leafValues>
+            3.2303300499916077e-01 5.1954758167266846e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1304 -8.2657067105174065e-03</internalNodes>
+          <leafValues>
+            5.9754890203475952e-01 4.5521140098571777e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1305 1.4481440302915871e-05</internalNodes>
+          <leafValues>
+            4.7456780076026917e-01 5.4974269866943359e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1306 1.4951299817766994e-05</internalNodes>
+          <leafValues>
+            4.3244731426239014e-01 5.4806441068649292e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1307 -1.8741799518465996e-02</internalNodes>
+          <leafValues>
+            1.5800529718399048e-01 5.1785331964492798e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1308 1.7572239739820361e-03</internalNodes>
+          <leafValues>
+            4.5176368951797485e-01 5.7737642526626587e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1309 -3.1391119118779898e-03</internalNodes>
+          <leafValues>
+            4.1496479511260986e-01 5.4608422517776489e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1310 6.6656779381446540e-05</internalNodes>
+          <leafValues>
+            4.0390908718109131e-01 5.2930849790573120e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1311 6.7743421532213688e-03</internalNodes>
+          <leafValues>
+            4.7676518559455872e-01 6.1219561100006104e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1312 -7.3868161998689175e-03</internalNodes>
+          <leafValues>
+            3.5862588882446289e-01 5.1872807741165161e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1313 1.4040930196642876e-02</internalNodes>
+          <leafValues>
+            4.7121399641036987e-01 5.5761557817459106e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1314 -5.5258329957723618e-03</internalNodes>
+          <leafValues>
+            2.6610270142555237e-01 5.0392812490463257e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1315 3.8684239983558655e-01</internalNodes>
+          <leafValues>
+            5.1443397998809814e-01 2.5258991122245789e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1316 1.1459240340627730e-04</internalNodes>
+          <leafValues>
+            4.2849949002265930e-01 5.4233711957931519e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1317 -1.8467569723725319e-02</internalNodes>
+          <leafValues>
+            3.8858351111412048e-01 5.2130621671676636e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1318 -4.5907011372037232e-04</internalNodes>
+          <leafValues>
+            5.4125630855560303e-01 4.2359098792076111e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1319 1.2527540093287826e-03</internalNodes>
+          <leafValues>
+            4.8993051052093506e-01 6.6240912675857544e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1320 1.4910609461367130e-03</internalNodes>
+          <leafValues>
+            5.2867782115936279e-01 4.0400519967079163e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1321 -7.5435562757775187e-04</internalNodes>
+          <leafValues>
+            6.0329902172088623e-01 4.7951200604438782e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1322 -6.9478838704526424e-03</internalNodes>
+          <leafValues>
+            4.0844011306762695e-01 5.3735041618347168e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1323 2.8092920547351241e-04</internalNodes>
+          <leafValues>
+            4.8460629582405090e-01 5.7593822479248047e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1324 9.6073717577382922e-04</internalNodes>
+          <leafValues>
+            5.1647412776947021e-01 3.5549798607826233e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1325 -2.6883929967880249e-04</internalNodes>
+          <leafValues>
+            5.6775820255279541e-01 4.7317659854888916e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1326 2.1599370520561934e-03</internalNodes>
+          <leafValues>
+            4.7314870357513428e-01 7.0705670118331909e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1327 5.6235301308333874e-03</internalNodes>
+          <leafValues>
+            5.2402430772781372e-01 2.7817919850349426e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1328 -5.0243991427123547e-03</internalNodes>
+          <leafValues>
+            2.8370139002799988e-01 5.0623041391372681e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1329 -9.7611639648675919e-03</internalNodes>
+          <leafValues>
+            7.4007177352905273e-01 4.9345690011978149e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1330 4.1515100747346878e-03</internalNodes>
+          <leafValues>
+            5.1191312074661255e-01 3.4070080518722534e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1331 6.2465080991387367e-03</internalNodes>
+          <leafValues>
+            4.9237880110740662e-01 6.5790587663650513e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1332 -7.0597478188574314e-03</internalNodes>
+          <leafValues>
+            2.4347110092639923e-01 5.0328421592712402e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1333 -2.0587709732353687e-03</internalNodes>
+          <leafValues>
+            5.9003108739852905e-01 4.6950870752334595e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1334 -2.4146060459315777e-03</internalNodes>
+          <leafValues>
+            3.6473178863525391e-01 5.1892018318176270e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1335 -1.4817609917372465e-03</internalNodes>
+          <leafValues>
+            6.0349482297897339e-01 4.9401280283927917e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1336 -6.3016400672495365e-03</internalNodes>
+          <leafValues>
+            5.8189898729324341e-01 4.5604279637336731e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1337 3.4763428848236799e-03</internalNodes>
+          <leafValues>
+            5.2174758911132812e-01 3.4839931130409241e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1338 -2.2250870242714882e-02</internalNodes>
+          <leafValues>
+            2.3607000708580017e-01 5.0320827960968018e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1339 -3.0612550675868988e-02</internalNodes>
+          <leafValues>
+            6.4991867542266846e-01 4.9149191379547119e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1340 1.3057479634881020e-02</internalNodes>
+          <leafValues>
+            4.4133231043815613e-01 5.6837642192840576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1341 -6.0095742810517550e-04</internalNodes>
+          <leafValues>
+            4.3597310781478882e-01 5.3334832191467285e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1342 -4.1514250915497541e-04</internalNodes>
+          <leafValues>
+            5.5040627717971802e-01 4.3260601162910461e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1343 -1.3776290230453014e-02</internalNodes>
+          <leafValues>
+            4.0641129016876221e-01 5.2015489339828491e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1344 -3.2296508550643921e-02</internalNodes>
+          <leafValues>
+            4.7351971268653870e-02 4.9771949648857117e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1345 5.3556978702545166e-02</internalNodes>
+          <leafValues>
+            4.8817330598831177e-01 6.6669392585754395e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1346 8.1889545544981956e-03</internalNodes>
+          <leafValues>
+            5.4000371694564819e-01 4.2408201098442078e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1347 2.1055320394225419e-04</internalNodes>
+          <leafValues>
+            4.8020479083061218e-01 5.5638527870178223e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1348 -2.4382730480283499e-03</internalNodes>
+          <leafValues>
+            7.3877930641174316e-01 4.7736850380897522e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1349 3.2835570164024830e-03</internalNodes>
+          <leafValues>
+            5.2885460853576660e-01 3.1712919473648071e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1350 2.3729570675641298e-03</internalNodes>
+          <leafValues>
+            4.7508129477500916e-01 7.0601707696914673e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1351 -1.4541699783876538e-03</internalNodes>
+          <leafValues>
+            3.8117301464080811e-01 5.3307390213012695e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>177</maxWeakCount>
+      <stageThreshold>8.7696029663085938e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1352 5.5755238980054855e-02</internalNodes>
+          <leafValues>
+            4.0191569924354553e-01 6.8060368299484253e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1353 2.4730248842388391e-03</internalNodes>
+          <leafValues>
+            3.3511489629745483e-01 5.9657198190689087e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1354 -3.5031698644161224e-04</internalNodes>
+          <leafValues>
+            5.5577081441879272e-01 3.4822869300842285e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1355 5.4167630150914192e-04</internalNodes>
+          <leafValues>
+            4.2608588933944702e-01 5.6933808326721191e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1356 7.7193678589537740e-04</internalNodes>
+          <leafValues>
+            3.4942400455474854e-01 5.4336887598037720e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1357 -1.5999219613149762e-03</internalNodes>
+          <leafValues>
+            4.0284991264343262e-01 5.4843592643737793e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1358 -1.1832080053864047e-04</internalNodes>
+          <leafValues>
+            3.8069018721580505e-01 5.4254651069641113e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1359 3.2909031142480671e-04</internalNodes>
+          <leafValues>
+            2.6201000809669495e-01 5.4295217990875244e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1360 2.9518108931370080e-04</internalNodes>
+          <leafValues>
+            3.7997689843177795e-01 5.3992640972137451e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1361 9.0466710389591753e-05</internalNodes>
+          <leafValues>
+            4.4336450099945068e-01 5.4402261972427368e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1362 1.5007190086180344e-05</internalNodes>
+          <leafValues>
+            3.7196549773216248e-01 5.4091197252273560e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1363 1.3935610651969910e-01</internalNodes>
+          <leafValues>
+            5.5253958702087402e-01 4.4790428876876831e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1364 1.6461990308016539e-03</internalNodes>
+          <leafValues>
+            4.2645010352134705e-01 5.7721698284149170e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1365 4.9984431825578213e-04</internalNodes>
+          <leafValues>
+            4.3595260381698608e-01 5.6858712434768677e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1366 -1.0971280280500650e-03</internalNodes>
+          <leafValues>
+            3.3901369571685791e-01 5.2054089307785034e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1367 6.6919892560690641e-04</internalNodes>
+          <leafValues>
+            4.5574560761451721e-01 5.9806597232818604e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1368 8.6471042595803738e-04</internalNodes>
+          <leafValues>
+            5.1348412036895752e-01 2.9440331459045410e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1369 -2.7182599296793342e-04</internalNodes>
+          <leafValues>
+            3.9065781235694885e-01 5.3771811723709106e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1370 3.0249499104684219e-05</internalNodes>
+          <leafValues>
+            3.6796098947525024e-01 5.2256888151168823e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1371 -8.5225896909832954e-03</internalNodes>
+          <leafValues>
+            7.2931021451950073e-01 4.8923650383949280e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1372 1.6705560265108943e-03</internalNodes>
+          <leafValues>
+            4.3453249335289001e-01 5.6961381435394287e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1373 -7.1433838456869125e-03</internalNodes>
+          <leafValues>
+            2.5912800431251526e-01 5.2256238460540771e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1374 -1.6319369897246361e-02</internalNodes>
+          <leafValues>
+            6.9222790002822876e-01 4.6515759825706482e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1375 4.8034260980784893e-03</internalNodes>
+          <leafValues>
+            5.3522628545761108e-01 3.2863029837608337e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1376 -7.5421929359436035e-03</internalNodes>
+          <leafValues>
+            2.0405440032482147e-01 5.0345462560653687e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1377 -1.4363110065460205e-02</internalNodes>
+          <leafValues>
+            6.8048888444900513e-01 4.8890590667724609e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1378 8.9063588529825211e-04</internalNodes>
+          <leafValues>
+            5.3106957674026489e-01 3.8954809308052063e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1379 -4.4060191139578819e-03</internalNodes>
+          <leafValues>
+            5.7415628433227539e-01 4.3724268674850464e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1380 -1.8862540309783071e-04</internalNodes>
+          <leafValues>
+            2.8317859768867493e-01 5.0982052087783813e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1381 -3.7979281041771173e-03</internalNodes>
+          <leafValues>
+            3.3725079894065857e-01 5.2465802431106567e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1382 1.4627049677073956e-04</internalNodes>
+          <leafValues>
+            5.3066742420196533e-01 3.9117100834846497e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1383 -4.9164638767251745e-05</internalNodes>
+          <leafValues>
+            5.4624962806701660e-01 3.9427208900451660e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1384 -3.3582501113414764e-02</internalNodes>
+          <leafValues>
+            2.1578240394592285e-01 5.0482118129730225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1385 -3.5339309833943844e-03</internalNodes>
+          <leafValues>
+            6.4653122425079346e-01 4.8726969957351685e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1386 5.0144111737608910e-03</internalNodes>
+          <leafValues>
+            4.6176680922508240e-01 6.2480747699737549e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1387 1.8817370757460594e-02</internalNodes>
+          <leafValues>
+            5.2206891775131226e-01 2.0000520348548889e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1388 -1.3434339780360460e-03</internalNodes>
+          <leafValues>
+            4.0145379304885864e-01 5.3016197681427002e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1389 1.7557960236445069e-03</internalNodes>
+          <leafValues>
+            4.7940391302108765e-01 5.6531697511672974e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1390 -9.5637463033199310e-02</internalNodes>
+          <leafValues>
+            2.0341950654983521e-01 5.0067067146301270e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1391 -2.2241229191422462e-02</internalNodes>
+          <leafValues>
+            7.6724731922149658e-01 5.0463402271270752e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1392 -1.5575819648802280e-02</internalNodes>
+          <leafValues>
+            7.4903422594070435e-01 4.7558510303497314e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1393 5.3599118255078793e-03</internalNodes>
+          <leafValues>
+            5.3653037548065186e-01 4.0046709775924683e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1394 -2.1763499826192856e-02</internalNodes>
+          <leafValues>
+            7.4015498161315918e-02 4.9641749262809753e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1395 -1.6561590135097504e-01</internalNodes>
+          <leafValues>
+            2.8591030836105347e-01 5.2180862426757812e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1396 1.6461320046801120e-04</internalNodes>
+          <leafValues>
+            4.1916158795356750e-01 5.3807932138442993e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1397 -8.9077502489089966e-03</internalNodes>
+          <leafValues>
+            6.2731927633285522e-01 4.8774048686027527e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1398 8.6346449097618461e-04</internalNodes>
+          <leafValues>
+            5.1599407196044922e-01 3.6710259318351746e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1399 -1.3751760125160217e-03</internalNodes>
+          <leafValues>
+            5.8843767642974854e-01 4.5790839195251465e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1400 -1.4081239933148026e-03</internalNodes>
+          <leafValues>
+            3.5605099797248840e-01 5.1399451494216919e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1401 -3.9342888630926609e-03</internalNodes>
+          <leafValues>
+            5.9942889213562012e-01 4.6642720699310303e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1402 -3.1966928392648697e-02</internalNodes>
+          <leafValues>
+            3.3454620838165283e-01 5.1441830396652222e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1403 -1.5089280168467667e-05</internalNodes>
+          <leafValues>
+            5.5826562643051147e-01 4.4140571355819702e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1404 5.1994470413774252e-04</internalNodes>
+          <leafValues>
+            4.6236801147460938e-01 6.1689937114715576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1405 -3.4220460802316666e-03</internalNodes>
+          <leafValues>
+            6.5570747852325439e-01 4.9748051166534424e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1406 1.7723299970384687e-04</internalNodes>
+          <leafValues>
+            5.2695018053054810e-01 3.9019080996513367e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1407 1.5716759953647852e-03</internalNodes>
+          <leafValues>
+            4.6333730220794678e-01 5.7904577255249023e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1408 -8.9041329920291901e-03</internalNodes>
+          <leafValues>
+            2.6896080374717712e-01 5.0535911321640015e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1409 4.0677518700249493e-04</internalNodes>
+          <leafValues>
+            5.4566031694412231e-01 4.3298989534378052e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1410 6.7604780197143555e-03</internalNodes>
+          <leafValues>
+            4.6489939093589783e-01 6.6897618770599365e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1411 2.9100088868290186e-03</internalNodes>
+          <leafValues>
+            5.3097039461135864e-01 3.3778399229049683e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1412 1.3885459629818797e-03</internalNodes>
+          <leafValues>
+            4.0747389197349548e-01 5.3491330146789551e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1413 -7.6764263212680817e-02</internalNodes>
+          <leafValues>
+            1.9921760261058807e-01 5.2282422780990601e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1414 -2.2688310127705336e-04</internalNodes>
+          <leafValues>
+            5.4385018348693848e-01 4.2530721426010132e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1415 -6.3094152137637138e-03</internalNodes>
+          <leafValues>
+            4.2591789364814758e-01 5.3789097070693970e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1416 -1.1007279902696609e-01</internalNodes>
+          <leafValues>
+            6.9041568040847778e-01 4.7217491269111633e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1417 2.8619659133255482e-04</internalNodes>
+          <leafValues>
+            4.5249149203300476e-01 5.5483061075210571e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1418 2.9425329557852820e-05</internalNodes>
+          <leafValues>
+            5.3703737258911133e-01 4.2364639043807983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1419 -2.4886570870876312e-02</internalNodes>
+          <leafValues>
+            6.4235579967498779e-01 4.9693039059638977e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1420 3.3148851245641708e-02</internalNodes>
+          <leafValues>
+            4.9884751439094543e-01 1.6138119995594025e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1421 7.8491691965609789e-04</internalNodes>
+          <leafValues>
+            5.4160261154174805e-01 4.2230090498924255e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1422 4.7087189741432667e-03</internalNodes>
+          <leafValues>
+            4.5763289928436279e-01 6.0275578498840332e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1423 2.4144479539245367e-03</internalNodes>
+          <leafValues>
+            5.3089731931686401e-01 4.4224989414215088e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1424 1.9523180089890957e-03</internalNodes>
+          <leafValues>
+            4.7056341171264648e-01 6.6633248329162598e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1425 1.3031980488449335e-03</internalNodes>
+          <leafValues>
+            4.4061261415481567e-01 5.5269622802734375e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1426 4.4735497795045376e-03</internalNodes>
+          <leafValues>
+            5.1290237903594971e-01 3.3014988899230957e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1427 -2.6652868837118149e-03</internalNodes>
+          <leafValues>
+            3.1354710459709167e-01 5.1750361919403076e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1428 1.3666770246345550e-04</internalNodes>
+          <leafValues>
+            4.1193708777427673e-01 5.3068768978118896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1429 -1.7126450315117836e-02</internalNodes>
+          <leafValues>
+            6.1778062582015991e-01 4.8365789651870728e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1430 -2.6601430727168918e-04</internalNodes>
+          <leafValues>
+            3.6543309688568115e-01 5.1697367429733276e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1431 -2.2932380437850952e-02</internalNodes>
+          <leafValues>
+            3.4909150004386902e-01 5.1639920473098755e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1432 2.3316550068557262e-03</internalNodes>
+          <leafValues>
+            5.1662999391555786e-01 3.7093898653984070e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1433 1.6925660893321037e-02</internalNodes>
+          <leafValues>
+            5.0147360563278198e-01 8.0539882183074951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1434 -8.9858826249837875e-03</internalNodes>
+          <leafValues>
+            6.4707887172698975e-01 4.6570208668708801e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1435 -1.1874699965119362e-02</internalNodes>
+          <leafValues>
+            3.2463788986206055e-01 5.2587550878524780e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1436 1.9350569345988333e-04</internalNodes>
+          <leafValues>
+            5.1919418573379517e-01 3.8396438956260681e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1437 5.8713490143418312e-03</internalNodes>
+          <leafValues>
+            4.9181339144706726e-01 6.1870431900024414e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1438 -2.4838790297508240e-01</internalNodes>
+          <leafValues>
+            1.8368029594421387e-01 4.9881500005722046e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1439 1.2256000190973282e-02</internalNodes>
+          <leafValues>
+            5.2270537614822388e-01 3.6320298910140991e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1440 8.3990179700776935e-04</internalNodes>
+          <leafValues>
+            4.4902500510215759e-01 5.7741481065750122e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1441 2.5407369248569012e-03</internalNodes>
+          <leafValues>
+            4.8047870397567749e-01 5.8582991361618042e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1442 -1.4822429977357388e-02</internalNodes>
+          <leafValues>
+            2.5210499763488770e-01 5.0235372781753540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1443 -5.7973959483206272e-03</internalNodes>
+          <leafValues>
+            5.9966957569122314e-01 4.8537150025367737e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1444 7.2662148158997297e-04</internalNodes>
+          <leafValues>
+            5.1537168025970459e-01 3.6717799305915833e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1445 -1.7232580110430717e-02</internalNodes>
+          <leafValues>
+            6.6217190027236938e-01 4.9946561455726624e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1446 7.8624086454510689e-03</internalNodes>
+          <leafValues>
+            4.6333950757980347e-01 6.2561017274856567e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1447 -4.7343620099127293e-03</internalNodes>
+          <leafValues>
+            3.6155730485916138e-01 5.2818852663040161e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1448 8.3048478700220585e-04</internalNodes>
+          <leafValues>
+            4.4428890943527222e-01 5.5509579181671143e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1449 7.6602199114859104e-03</internalNodes>
+          <leafValues>
+            5.1629352569580078e-01 2.6133549213409424e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1450 -4.1048377752304077e-03</internalNodes>
+          <leafValues>
+            2.7896320819854736e-01 5.0190317630767822e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1451 4.8512578941881657e-03</internalNodes>
+          <leafValues>
+            4.9689841270446777e-01 5.6616681814193726e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1452 9.9896453320980072e-04</internalNodes>
+          <leafValues>
+            4.4456079602241516e-01 5.5518132448196411e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1453 -2.7023631334304810e-01</internalNodes>
+          <leafValues>
+            2.9388209804892540e-02 5.1513141393661499e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1454 -1.3090680353343487e-02</internalNodes>
+          <leafValues>
+            5.6993997097015381e-01 4.4474598765373230e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1455 -9.4342790544033051e-03</internalNodes>
+          <leafValues>
+            4.3054661154747009e-01 5.4878950119018555e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1456 -1.5482039889320731e-03</internalNodes>
+          <leafValues>
+            3.6803171038627625e-01 5.1280808448791504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1457 5.3746132180094719e-03</internalNodes>
+          <leafValues>
+            4.8389169573783875e-01 6.1015558242797852e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1458 1.5786769799888134e-03</internalNodes>
+          <leafValues>
+            5.3252232074737549e-01 4.1185480356216431e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1459 3.6856050137430429e-03</internalNodes>
+          <leafValues>
+            4.8109480738639832e-01 6.2523031234741211e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1460 9.3887019902467728e-03</internalNodes>
+          <leafValues>
+            5.2002298831939697e-01 3.6294108629226685e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1461 1.2792630121111870e-02</internalNodes>
+          <leafValues>
+            4.9617099761962891e-01 6.7380160093307495e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1462 -3.3661040943115950e-03</internalNodes>
+          <leafValues>
+            4.0602791309356689e-01 5.2835988998413086e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1463 3.9771420415490866e-04</internalNodes>
+          <leafValues>
+            4.6741139888763428e-01 5.9007751941680908e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1464 1.4868030557408929e-03</internalNodes>
+          <leafValues>
+            4.5191168785095215e-01 6.0820537805557251e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1465 -8.8686749339103699e-02</internalNodes>
+          <leafValues>
+            2.8078991174697876e-01 5.1809918880462646e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1466 -7.4296112870797515e-05</internalNodes>
+          <leafValues>
+            5.2955842018127441e-01 4.0876251459121704e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1467 -1.4932939848222304e-05</internalNodes>
+          <leafValues>
+            5.4614001512527466e-01 4.5385429263114929e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1468 5.9162238612771034e-03</internalNodes>
+          <leafValues>
+            5.3291612863540649e-01 4.1921341419219971e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1469 1.1141640134155750e-03</internalNodes>
+          <leafValues>
+            4.5120179653167725e-01 5.7062172889709473e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1470 8.9249362645205110e-05</internalNodes>
+          <leafValues>
+            4.5778059959411621e-01 5.8976382017135620e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1471 2.5319510605186224e-03</internalNodes>
+          <leafValues>
+            5.2996039390563965e-01 3.3576390147209167e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1472 1.2426200322806835e-02</internalNodes>
+          <leafValues>
+            4.9590590596199036e-01 1.3466019928455353e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1473 2.8335750102996826e-02</internalNodes>
+          <leafValues>
+            5.1170790195465088e-01 6.1043637106195092e-04</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1474 6.6165882162749767e-03</internalNodes>
+          <leafValues>
+            4.7363498806953430e-01 7.0116281509399414e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1475 8.0468766391277313e-03</internalNodes>
+          <leafValues>
+            5.2164179086685181e-01 3.2828199863433838e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1476 -1.1193980462849140e-03</internalNodes>
+          <leafValues>
+            5.8098608255386353e-01 4.5637390017509460e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1477 1.3277590274810791e-02</internalNodes>
+          <leafValues>
+            5.3983622789382935e-01 4.1039010882377625e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1478 4.8794739996083081e-04</internalNodes>
+          <leafValues>
+            4.2492860555648804e-01 5.4105907678604126e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1479 1.1243170127272606e-02</internalNodes>
+          <leafValues>
+            5.2699637413024902e-01 3.4382158517837524e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1480 -8.9896668214350939e-04</internalNodes>
+          <leafValues>
+            5.6330758333206177e-01 4.4566130638122559e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1481 6.6677159629762173e-03</internalNodes>
+          <leafValues>
+            5.3128892183303833e-01 4.3626791238784790e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1482 2.8947299346327782e-02</internalNodes>
+          <leafValues>
+            4.7017949819564819e-01 6.5757977962493896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1483 -2.3400049656629562e-02</internalNodes>
+          <leafValues>
+            0. 5.1373988389968872e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1484 -8.9117050170898438e-02</internalNodes>
+          <leafValues>
+            2.3745279759168625e-02 4.9424308538436890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1485 -1.4054600149393082e-02</internalNodes>
+          <leafValues>
+            3.1273230910301208e-01 5.1175111532211304e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1486 8.1239398568868637e-03</internalNodes>
+          <leafValues>
+            5.0090491771697998e-01 2.5200259685516357e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1487 -4.9964650534093380e-03</internalNodes>
+          <leafValues>
+            6.3871437311172485e-01 4.9278119206428528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1488 3.1253970228135586e-03</internalNodes>
+          <leafValues>
+            5.1368498802185059e-01 3.6804521083831787e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1489 6.7669642157852650e-03</internalNodes>
+          <leafValues>
+            5.5098438262939453e-01 4.3636319041252136e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1490 -2.3711440153419971e-03</internalNodes>
+          <leafValues>
+            6.1623352766036987e-01 4.5869469642639160e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1491 -5.3522791713476181e-03</internalNodes>
+          <leafValues>
+            6.1854577064514160e-01 4.9204909801483154e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1492 -1.5968859195709229e-02</internalNodes>
+          <leafValues>
+            1.3826179504394531e-01 4.9832528829574585e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1493 4.7676060348749161e-03</internalNodes>
+          <leafValues>
+            4.6880578994750977e-01 5.4900461435317993e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1494 -2.4714691098779440e-03</internalNodes>
+          <leafValues>
+            2.3685149848461151e-01 5.0039529800415039e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1495 -7.1033788844943047e-04</internalNodes>
+          <leafValues>
+            5.8563941717147827e-01 4.7215330600738525e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1496 -1.4117559790611267e-01</internalNodes>
+          <leafValues>
+            8.6900062859058380e-02 4.9615910649299622e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1497 1.0651809722185135e-01</internalNodes>
+          <leafValues>
+            5.1388370990753174e-01 1.7410050332546234e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1498 -5.2744749933481216e-02</internalNodes>
+          <leafValues>
+            7.3536360263824463e-01 4.7728818655014038e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1499 -4.7431760467588902e-03</internalNodes>
+          <leafValues>
+            3.8844060897827148e-01 5.2927017211914062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1500 9.9676765967160463e-04</internalNodes>
+          <leafValues>
+            5.2234929800033569e-01 4.0034240484237671e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1501 8.0284131690859795e-03</internalNodes>
+          <leafValues>
+            4.9591061472892761e-01 7.2129642963409424e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1502 8.6025858763605356e-04</internalNodes>
+          <leafValues>
+            4.4448840618133545e-01 5.5384761095046997e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1503 9.3191501218825579e-04</internalNodes>
+          <leafValues>
+            5.3983712196350098e-01 4.1632440686225891e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1504 -2.5082060601562262e-03</internalNodes>
+          <leafValues>
+            5.8542650938034058e-01 4.5625001192092896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1505 -2.1378761157393456e-03</internalNodes>
+          <leafValues>
+            4.6080690622329712e-01 5.2802592515945435e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1506 -2.1546049974858761e-03</internalNodes>
+          <leafValues>
+            3.7911269068717957e-01 5.2559971809387207e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1507 -7.6214009895920753e-03</internalNodes>
+          <leafValues>
+            5.9986090660095215e-01 4.9520739912986755e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1508 2.2055360022932291e-03</internalNodes>
+          <leafValues>
+            4.4842061400413513e-01 5.5885308980941772e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1509 1.2586950324475765e-03</internalNodes>
+          <leafValues>
+            5.4507470130920410e-01 4.4238409399986267e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1510 -5.0926720723509789e-03</internalNodes>
+          <leafValues>
+            4.1182750463485718e-01 5.2630358934402466e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1511 -2.5095739401876926e-03</internalNodes>
+          <leafValues>
+            5.7879078388214111e-01 4.9984949827194214e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1512 -7.7327556908130646e-02</internalNodes>
+          <leafValues>
+            8.3978658914566040e-01 4.8111200332641602e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1513 -4.1485819965600967e-02</internalNodes>
+          <leafValues>
+            2.4086110293865204e-01 5.1769930124282837e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1514 1.0355669655837119e-04</internalNodes>
+          <leafValues>
+            4.3553608655929565e-01 5.4170542955398560e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1515 1.3255809899419546e-03</internalNodes>
+          <leafValues>
+            5.4539710283279419e-01 4.8940950632095337e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1516 -8.0598732456564903e-03</internalNodes>
+          <leafValues>
+            5.7710242271423340e-01 4.5779189467430115e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1517 1.9058620557188988e-02</internalNodes>
+          <leafValues>
+            5.1698678731918335e-01 3.4004750847816467e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1518 -3.5057891160249710e-02</internalNodes>
+          <leafValues>
+            2.2032439708709717e-01 5.0005030632019043e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1519 5.7296059094369411e-03</internalNodes>
+          <leafValues>
+            5.0434082746505737e-01 6.5975707769393921e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1520 -1.1648329906165600e-02</internalNodes>
+          <leafValues>
+            2.1862849593162537e-01 4.9966529011726379e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1521 1.4544479781761765e-03</internalNodes>
+          <leafValues>
+            5.0076818466186523e-01 5.5037277936935425e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1522 -2.5030909455381334e-04</internalNodes>
+          <leafValues>
+            4.1298410296440125e-01 5.2416700124740601e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1523 -8.2907272735610604e-04</internalNodes>
+          <leafValues>
+            5.4128682613372803e-01 4.9744960665702820e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1524 1.0862209601327777e-03</internalNodes>
+          <leafValues>
+            4.6055299043655396e-01 5.8792287111282349e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1525 2.0000500080641359e-04</internalNodes>
+          <leafValues>
+            5.2788549661636353e-01 4.7052091360092163e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1526 2.9212920926511288e-03</internalNodes>
+          <leafValues>
+            5.1296097040176392e-01 3.7555369734764099e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1527 2.5387400761246681e-02</internalNodes>
+          <leafValues>
+            4.8226919770240784e-01 5.7907682657241821e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1528 -3.1968469265848398e-03</internalNodes>
+          <leafValues>
+            5.2483952045440674e-01 3.9628401398658752e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>182</maxWeakCount>
+      <stageThreshold>9.0253349304199219e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1529 5.8031738735735416e-03</internalNodes>
+          <leafValues>
+            3.4989839792251587e-01 5.9619832038879395e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1530 -9.0003069490194321e-03</internalNodes>
+          <leafValues>
+            6.8166369199752808e-01 4.4785520434379578e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1531 -1.1549659539014101e-03</internalNodes>
+          <leafValues>
+            5.5857062339782715e-01 3.5782510042190552e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1532 -1.1069850297644734e-03</internalNodes>
+          <leafValues>
+            5.3650361299514771e-01 3.0504280328750610e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1533 1.0308309720130637e-04</internalNodes>
+          <leafValues>
+            3.6390951275825500e-01 5.3446358442306519e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1534 -5.0984839908778667e-03</internalNodes>
+          <leafValues>
+            2.8591570258140564e-01 5.5042648315429688e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1535 8.2572200335562229e-04</internalNodes>
+          <leafValues>
+            5.2365237474441528e-01 3.4760418534278870e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1536 9.9783325567841530e-03</internalNodes>
+          <leafValues>
+            4.7503221035003662e-01 6.2196469306945801e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1537 -3.7402529269456863e-02</internalNodes>
+          <leafValues>
+            3.3433759212493896e-01 5.2780628204345703e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1538 4.8548257909715176e-03</internalNodes>
+          <leafValues>
+            5.1921808719635010e-01 3.7004441022872925e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1539 -1.8664470408111811e-03</internalNodes>
+          <leafValues>
+            2.9298439621925354e-01 5.0919449329376221e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1540 1.6888890415430069e-02</internalNodes>
+          <leafValues>
+            3.6868458986282349e-01 5.4312258958816528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1541 -5.8372621424496174e-03</internalNodes>
+          <leafValues>
+            3.6321839690208435e-01 5.2213358879089355e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1542 -1.4713739510625601e-03</internalNodes>
+          <leafValues>
+            5.8706837892532349e-01 4.7006508708000183e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1543 -1.1522950371727347e-03</internalNodes>
+          <leafValues>
+            3.1958949565887451e-01 5.1409542560577393e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1544 -4.2560300789773464e-03</internalNodes>
+          <leafValues>
+            6.3018590211868286e-01 4.8149210214614868e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1545 -6.7378291860222816e-03</internalNodes>
+          <leafValues>
+            1.9770480692386627e-01 5.0258082151412964e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1546 1.1382670141756535e-02</internalNodes>
+          <leafValues>
+            4.9541321396827698e-01 6.8670457601547241e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1547 5.1794708706438541e-03</internalNodes>
+          <leafValues>
+            5.1644277572631836e-01 3.3506479859352112e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1548 -1.1743789911270142e-01</internalNodes>
+          <leafValues>
+            2.3152460157871246e-01 5.2344137430191040e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1549 2.8703449293971062e-02</internalNodes>
+          <leafValues>
+            4.6642971038818359e-01 6.7225211858749390e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1550 4.8231030814349651e-03</internalNodes>
+          <leafValues>
+            5.2208751440048218e-01 2.7235329151153564e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1551 2.6798530016094446e-03</internalNodes>
+          <leafValues>
+            5.0792771577835083e-01 2.9069489240646362e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1552 8.0504082143306732e-03</internalNodes>
+          <leafValues>
+            4.8859509825706482e-01 6.3950210809707642e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1553 4.8054959625005722e-03</internalNodes>
+          <leafValues>
+            5.1972568035125732e-01 3.6566638946533203e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1554 -2.2420159075409174e-03</internalNodes>
+          <leafValues>
+            6.1534678936004639e-01 4.7637018561363220e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1555 -1.3757710345089436e-02</internalNodes>
+          <leafValues>
+            2.6373448967933655e-01 5.0309032201766968e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1556 -1.0338299721479416e-01</internalNodes>
+          <leafValues>
+            2.2875219583511353e-01 5.1824611425399780e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1557 -9.4432085752487183e-03</internalNodes>
+          <leafValues>
+            6.9533038139343262e-01 4.6949490904808044e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1558 8.0271181650459766e-04</internalNodes>
+          <leafValues>
+            5.4506552219390869e-01 4.2687839269638062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1559 -4.1945669800043106e-03</internalNodes>
+          <leafValues>
+            6.0913878679275513e-01 4.5716428756713867e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1560 1.0942210443317890e-02</internalNodes>
+          <leafValues>
+            5.2410632371902466e-01 3.2845470309257507e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1561 -5.7841069065034389e-04</internalNodes>
+          <leafValues>
+            5.3879290819168091e-01 4.1793689131736755e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1562 -2.0888620056211948e-03</internalNodes>
+          <leafValues>
+            4.2926910519599915e-01 5.3017157316207886e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1563 3.2383969519287348e-03</internalNodes>
+          <leafValues>
+            3.7923479080200195e-01 5.2207440137863159e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1564 4.9075027927756310e-03</internalNodes>
+          <leafValues>
+            5.2372831106185913e-01 4.1267579793930054e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1565 -3.2277941703796387e-02</internalNodes>
+          <leafValues>
+            1.9476559758186340e-01 4.9945020675659180e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1566 -8.9711230248212814e-03</internalNodes>
+          <leafValues>
+            6.0112851858139038e-01 4.9290320277214050e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1567 1.5321089886128902e-02</internalNodes>
+          <leafValues>
+            5.0097537040710449e-01 2.0398220419883728e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1568 2.0855569746345282e-03</internalNodes>
+          <leafValues>
+            4.8621898889541626e-01 5.7216948270797729e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1569 5.0615021027624607e-03</internalNodes>
+          <leafValues>
+            5.0002187490463257e-01 1.8018059432506561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1570 -3.7174751050770283e-03</internalNodes>
+          <leafValues>
+            5.5301171541213989e-01 4.8975929617881775e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1571 -1.2170500122010708e-02</internalNodes>
+          <leafValues>
+            4.1786059737205505e-01 5.3837239742279053e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1572 4.6248398721218109e-03</internalNodes>
+          <leafValues>
+            4.9971699714660645e-01 5.7613271474838257e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1573 -2.1040429419372231e-04</internalNodes>
+          <leafValues>
+            5.3318071365356445e-01 4.0976810455322266e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1574 -1.4641780406236649e-02</internalNodes>
+          <leafValues>
+            5.7559251785278320e-01 5.0517761707305908e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1575 3.3199489116668701e-03</internalNodes>
+          <leafValues>
+            4.5769768953323364e-01 6.0318058729171753e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1576 3.7236879579722881e-03</internalNodes>
+          <leafValues>
+            4.3803969025611877e-01 5.4158830642700195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1577 8.2951161311939359e-04</internalNodes>
+          <leafValues>
+            5.1630318164825439e-01 3.7022191286087036e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1578 -1.1408490128815174e-02</internalNodes>
+          <leafValues>
+            6.0729467868804932e-01 4.8625651001930237e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1579 -4.5320121571421623e-03</internalNodes>
+          <leafValues>
+            3.2924759387969971e-01 5.0889629125595093e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1580 5.1276017911732197e-03</internalNodes>
+          <leafValues>
+            4.8297679424285889e-01 6.1227089166641235e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1581 9.8583158105611801e-03</internalNodes>
+          <leafValues>
+            4.6606799960136414e-01 6.5561771392822266e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1582 3.6985918879508972e-02</internalNodes>
+          <leafValues>
+            5.2048492431640625e-01 1.6904720664024353e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1583 4.6491161920130253e-03</internalNodes>
+          <leafValues>
+            5.1673221588134766e-01 3.7252250313758850e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1584 -4.2664702050387859e-03</internalNodes>
+          <leafValues>
+            6.4064931869506836e-01 4.9873429536819458e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1585 -4.7956590424291790e-04</internalNodes>
+          <leafValues>
+            5.8972930908203125e-01 4.4648739695549011e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1586 3.6827160511165857e-03</internalNodes>
+          <leafValues>
+            5.4415607452392578e-01 3.4726628661155701e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1587 -1.0059880092740059e-02</internalNodes>
+          <leafValues>
+            2.1431629359722137e-01 5.0048297643661499e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1588 -3.0361840617842972e-04</internalNodes>
+          <leafValues>
+            5.3864240646362305e-01 4.5903238654136658e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1589 -1.4545479789376259e-03</internalNodes>
+          <leafValues>
+            5.7511842250823975e-01 4.4970950484275818e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1590 1.6515209572389722e-03</internalNodes>
+          <leafValues>
+            5.4219377040863037e-01 4.2385208606719971e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1591 -7.8468639403581619e-03</internalNodes>
+          <leafValues>
+            4.0779209136962891e-01 5.2581572532653809e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1592 -5.1259850151836872e-03</internalNodes>
+          <leafValues>
+            4.2292758822441101e-01 5.4794532060623169e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1593 -3.6890961229801178e-02</internalNodes>
+          <leafValues>
+            6.5963757038116455e-01 4.6746781468391418e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1594 2.4035639944486320e-04</internalNodes>
+          <leafValues>
+            4.2511358857154846e-01 5.5732029676437378e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1595 -1.5150169929256663e-05</internalNodes>
+          <leafValues>
+            5.2592468261718750e-01 4.0741148591041565e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1596 2.2108471021056175e-03</internalNodes>
+          <leafValues>
+            4.6717229485511780e-01 5.8863520622253418e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1597 -1.1568620102480054e-03</internalNodes>
+          <leafValues>
+            5.7110661268234253e-01 4.4871619343757629e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1598 4.9996292218565941e-03</internalNodes>
+          <leafValues>
+            5.2641981840133667e-01 2.8983271121978760e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1599 -1.4656189596280456e-03</internalNodes>
+          <leafValues>
+            3.8917380571365356e-01 5.1978719234466553e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1600 -1.1975039960816503e-03</internalNodes>
+          <leafValues>
+            5.7958728075027466e-01 4.9279558658599854e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1601 -4.4954330660402775e-03</internalNodes>
+          <leafValues>
+            2.3776030540466309e-01 5.0125551223754883e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1602 1.4997160178609192e-04</internalNodes>
+          <leafValues>
+            4.8766261339187622e-01 5.6176078319549561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1603 2.6391509454697371e-03</internalNodes>
+          <leafValues>
+            5.1680880784988403e-01 3.7655091285705566e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1604 -2.9368131072260439e-04</internalNodes>
+          <leafValues>
+            5.4466491937637329e-01 4.8746308684349060e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1605 1.4211760135367513e-03</internalNodes>
+          <leafValues>
+            4.6878978610038757e-01 6.6913318634033203e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1606 7.9427637159824371e-02</internalNodes>
+          <leafValues>
+            5.1934438943862915e-01 2.7329459786415100e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1607 7.9937502741813660e-02</internalNodes>
+          <leafValues>
+            4.9717310070991516e-01 1.7820839583873749e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1608 1.1089259758591652e-02</internalNodes>
+          <leafValues>
+            5.1659947633743286e-01 3.2094758749008179e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1609 1.6560709627810866e-04</internalNodes>
+          <leafValues>
+            4.0584719181060791e-01 5.3072762489318848e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1610 -5.3354292176663876e-03</internalNodes>
+          <leafValues>
+            3.4450569748878479e-01 5.1581299304962158e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1611 1.1287260567769408e-03</internalNodes>
+          <leafValues>
+            4.5948630571365356e-01 6.0755330324172974e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1612 -2.1969219669699669e-02</internalNodes>
+          <leafValues>
+            1.6804009675979614e-01 5.2285957336425781e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1613 -2.1775320055894554e-04</internalNodes>
+          <leafValues>
+            3.8615968823432922e-01 5.2156728506088257e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1614 2.0200149447191507e-04</internalNodes>
+          <leafValues>
+            5.5179792642593384e-01 4.3630391359329224e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1615 -2.1733149886131287e-02</internalNodes>
+          <leafValues>
+            7.9994601011276245e-01 4.7898510098457336e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1616 -8.4399932529777288e-04</internalNodes>
+          <leafValues>
+            4.0859758853912354e-01 5.3747731447219849e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1617 -4.3895249837078154e-04</internalNodes>
+          <leafValues>
+            5.4704052209854126e-01 4.3661430478096008e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1618 1.5092400135472417e-03</internalNodes>
+          <leafValues>
+            4.9889969825744629e-01 5.8421492576599121e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1619 -3.5547839943319559e-03</internalNodes>
+          <leafValues>
+            6.7536902427673340e-01 4.7210058569908142e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1620 4.8191400128416717e-04</internalNodes>
+          <leafValues>
+            5.4158538579940796e-01 4.3571090698242188e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1621 -6.0264398343861103e-03</internalNodes>
+          <leafValues>
+            2.2585099935531616e-01 4.9918809533119202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1622 -1.1668140068650246e-02</internalNodes>
+          <leafValues>
+            6.2565547227859497e-01 4.9274989962577820e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1623 -2.8718370012938976e-03</internalNodes>
+          <leafValues>
+            3.9477849006652832e-01 5.2458018064498901e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1624 1.7051169648766518e-02</internalNodes>
+          <leafValues>
+            4.7525110840797424e-01 5.7942241430282593e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1625 -1.3352080248296261e-02</internalNodes>
+          <leafValues>
+            6.0411047935485840e-01 4.5445358753204346e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1626 -3.9301801007241011e-04</internalNodes>
+          <leafValues>
+            4.2582759261131287e-01 5.5449050664901733e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1627 3.0483349692076445e-03</internalNodes>
+          <leafValues>
+            5.2334201335906982e-01 3.7802729010581970e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1628 -4.3579288758337498e-03</internalNodes>
+          <leafValues>
+            6.3718891143798828e-01 4.8386740684509277e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1629 5.6661018170416355e-03</internalNodes>
+          <leafValues>
+            5.3747057914733887e-01 4.1636660695075989e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1630 6.0677339206449687e-05</internalNodes>
+          <leafValues>
+            4.6387958526611328e-01 5.3116250038146973e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1631 3.6738160997629166e-02</internalNodes>
+          <leafValues>
+            4.6886560320854187e-01 6.4665240049362183e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1632 8.6528137326240540e-03</internalNodes>
+          <leafValues>
+            5.2043187618255615e-01 2.1886579692363739e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1633 -1.5371359884738922e-01</internalNodes>
+          <leafValues>
+            1.6303719580173492e-01 4.9588400125503540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1634 -4.1560421232134104e-04</internalNodes>
+          <leafValues>
+            5.7744592428207397e-01 4.6964588761329651e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1635 -1.2640169588848948e-03</internalNodes>
+          <leafValues>
+            3.9771759510040283e-01 5.2171981334686279e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1636 -3.5473341122269630e-03</internalNodes>
+          <leafValues>
+            6.0465282201766968e-01 4.8083150386810303e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1637 3.0019069527043030e-05</internalNodes>
+          <leafValues>
+            3.9967238903045654e-01 5.2282011508941650e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1638 1.3113019522279501e-03</internalNodes>
+          <leafValues>
+            4.7121581435203552e-01 5.7659977674484253e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1639 -1.3374709524214268e-03</internalNodes>
+          <leafValues>
+            4.1095849871635437e-01 5.2531701326370239e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1640 2.0876709371805191e-02</internalNodes>
+          <leafValues>
+            5.2029937505722046e-01 1.7579819262027740e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1641 -7.5497948564589024e-03</internalNodes>
+          <leafValues>
+            6.5666097402572632e-01 4.6949750185012817e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1642 2.4188550189137459e-02</internalNodes>
+          <leafValues>
+            5.1286739110946655e-01 3.3702209591865540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1643 -2.9358828905969858e-03</internalNodes>
+          <leafValues>
+            6.5807867050170898e-01 4.6945410966873169e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1644 5.7557929307222366e-02</internalNodes>
+          <leafValues>
+            5.1464450359344482e-01 2.7752599120140076e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1645 -1.1343370424583554e-03</internalNodes>
+          <leafValues>
+            3.8366019725799561e-01 5.1926672458648682e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1646 1.6816999763250351e-02</internalNodes>
+          <leafValues>
+            5.0855928659439087e-01 6.1772608757019043e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1647 5.0535178743302822e-03</internalNodes>
+          <leafValues>
+            5.1387631893157959e-01 3.6847919225692749e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1648 -4.5874710194766521e-03</internalNodes>
+          <leafValues>
+            5.9896552562713623e-01 4.8352020978927612e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1649 1.6882460331544280e-03</internalNodes>
+          <leafValues>
+            4.5094868540763855e-01 5.7230567932128906e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1650 -1.6554000321775675e-03</internalNodes>
+          <leafValues>
+            3.4967708587646484e-01 5.2433192729949951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1651 -1.9373800605535507e-02</internalNodes>
+          <leafValues>
+            1.1205369979143143e-01 4.9687129259109497e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1652 1.0374450124800205e-02</internalNodes>
+          <leafValues>
+            5.1481968164443970e-01 4.3952131271362305e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1653 1.4973050565458834e-04</internalNodes>
+          <leafValues>
+            4.0849998593330383e-01 5.2698868513107300e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1654 -4.2981930077075958e-02</internalNodes>
+          <leafValues>
+            6.3941049575805664e-01 5.0185042619705200e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1655 8.3065936341881752e-03</internalNodes>
+          <leafValues>
+            4.7075539827346802e-01 6.6983532905578613e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1656 -4.1285790503025055e-03</internalNodes>
+          <leafValues>
+            4.5413690805435181e-01 5.3236472606658936e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1657 1.7399420030415058e-03</internalNodes>
+          <leafValues>
+            4.3339619040489197e-01 5.4398661851882935e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1658 1.1739750334527344e-04</internalNodes>
+          <leafValues>
+            4.5796871185302734e-01 5.5434262752532959e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1659 1.8585780344437808e-04</internalNodes>
+          <leafValues>
+            4.3246439099311829e-01 5.4267549514770508e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1660 5.5587692186236382e-03</internalNodes>
+          <leafValues>
+            5.2572208642959595e-01 3.5506111383438110e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1661 -7.9851560294628143e-03</internalNodes>
+          <leafValues>
+            6.0430181026458740e-01 4.6306359767913818e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1662 6.0594122624024749e-04</internalNodes>
+          <leafValues>
+            4.5982548594474792e-01 5.5331951379776001e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1663 -2.2983040253166109e-04</internalNodes>
+          <leafValues>
+            4.1307520866394043e-01 5.3224611282348633e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1664 4.3740210821852088e-04</internalNodes>
+          <leafValues>
+            4.0430399775505066e-01 5.4092890024185181e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1665 2.9482020181603730e-04</internalNodes>
+          <leafValues>
+            4.4949638843536377e-01 5.6288522481918335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1666 1.0312659665942192e-02</internalNodes>
+          <leafValues>
+            5.1775109767913818e-01 2.7043169736862183e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1667 -7.7241109684109688e-03</internalNodes>
+          <leafValues>
+            1.9880190491676331e-01 4.9805539846420288e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1668 -4.6797208487987518e-03</internalNodes>
+          <leafValues>
+            6.6447502374649048e-01 5.0182962417602539e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1669 -5.0755459815263748e-03</internalNodes>
+          <leafValues>
+            3.8983049988746643e-01 5.1852691173553467e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1670 2.2479740437120199e-03</internalNodes>
+          <leafValues>
+            4.8018088936805725e-01 5.6603360176086426e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1671 8.3327008178457618e-04</internalNodes>
+          <leafValues>
+            5.2109199762344360e-01 3.9571881294250488e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1672 -4.1279330849647522e-02</internalNodes>
+          <leafValues>
+            6.1545419692993164e-01 5.0070542097091675e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1673 -5.0930189900100231e-04</internalNodes>
+          <leafValues>
+            3.9759421348571777e-01 5.2284038066864014e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1674 1.2568780221045017e-03</internalNodes>
+          <leafValues>
+            4.9791380763053894e-01 5.9391832351684570e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1675 8.0048497766256332e-03</internalNodes>
+          <leafValues>
+            4.9844971299171448e-01 1.6333660483360291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1676 -1.1879300000146031e-03</internalNodes>
+          <leafValues>
+            5.9049648046493530e-01 4.9426248669624329e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1677 6.1948952497914433e-04</internalNodes>
+          <leafValues>
+            4.1995579004287720e-01 5.3287261724472046e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1678 6.6829859279096127e-03</internalNodes>
+          <leafValues>
+            5.4186028242111206e-01 4.9058890342712402e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1679 -3.7062340416014194e-03</internalNodes>
+          <leafValues>
+            3.7259390950202942e-01 5.1380002498626709e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1680 -3.9739411324262619e-02</internalNodes>
+          <leafValues>
+            6.4789611101150513e-01 5.0503468513488770e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1681 1.4085009461268783e-03</internalNodes>
+          <leafValues>
+            4.6823391318321228e-01 6.3778841495513916e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1682 3.9322688826359808e-04</internalNodes>
+          <leafValues>
+            5.4585301876068115e-01 4.1504821181297302e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1683 -1.8979819724336267e-03</internalNodes>
+          <leafValues>
+            3.6901599168777466e-01 5.1497042179107666e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1684 -1.3970440253615379e-02</internalNodes>
+          <leafValues>
+            6.0505628585815430e-01 4.8113578557968140e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1685 -1.0100819915533066e-01</internalNodes>
+          <leafValues>
+            2.0170800387859344e-01 4.9923619627952576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1686 -1.7346920445561409e-02</internalNodes>
+          <leafValues>
+            5.7131487131118774e-01 4.8994860053062439e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1687 1.5619759506080300e-04</internalNodes>
+          <leafValues>
+            4.2153888940811157e-01 5.3926420211791992e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1688 1.3438929617404938e-01</internalNodes>
+          <leafValues>
+            5.1361519098281860e-01 3.7676128745079041e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1689 -2.4582240730524063e-02</internalNodes>
+          <leafValues>
+            7.0273578166961670e-01 4.7479069232940674e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1690 -3.8553720805794001e-03</internalNodes>
+          <leafValues>
+            4.3174090981483459e-01 5.4277169704437256e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1691 -2.3165249731391668e-03</internalNodes>
+          <leafValues>
+            5.9426987171173096e-01 4.6186479926109314e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1692 -4.8518120311200619e-03</internalNodes>
+          <leafValues>
+            6.1915689706802368e-01 4.8848950862884521e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1693 2.4699938949197531e-03</internalNodes>
+          <leafValues>
+            5.2566647529602051e-01 4.0171998739242554e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1694 4.5496959239244461e-02</internalNodes>
+          <leafValues>
+            5.2378678321838379e-01 2.6857739686965942e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1695 -2.0319599658250809e-02</internalNodes>
+          <leafValues>
+            2.1304459869861603e-01 4.9797388911247253e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1696 2.6994998916052282e-04</internalNodes>
+          <leafValues>
+            4.8140418529510498e-01 5.5431222915649414e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1697 -1.8232699949294329e-03</internalNodes>
+          <leafValues>
+            6.4825797080993652e-01 4.7099891304969788e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1698 -6.3015790656208992e-03</internalNodes>
+          <leafValues>
+            4.5819279551506042e-01 5.3062361478805542e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1699 -2.4139499873854220e-04</internalNodes>
+          <leafValues>
+            5.2320867776870728e-01 4.0517631173133850e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1700 -1.0330369696021080e-03</internalNodes>
+          <leafValues>
+            5.5562019348144531e-01 4.7891938686370850e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1701 1.8041160365100950e-04</internalNodes>
+          <leafValues>
+            5.2294427156448364e-01 4.0118101239204407e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1702 -6.1407860368490219e-02</internalNodes>
+          <leafValues>
+            6.2986820936203003e-01 5.0107032060623169e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1703 -6.9543913006782532e-02</internalNodes>
+          <leafValues>
+            7.2282809019088745e-01 4.7731840610504150e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1704 -7.0542663335800171e-02</internalNodes>
+          <leafValues>
+            2.2695130109786987e-01 5.1825290918350220e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1705 2.4423799477517605e-03</internalNodes>
+          <leafValues>
+            5.2370971441268921e-01 4.0981510281562805e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1706 1.5494349645450711e-03</internalNodes>
+          <leafValues>
+            4.7737509012222290e-01 5.4680430889129639e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1707 -2.3914219811558723e-02</internalNodes>
+          <leafValues>
+            7.1469759941101074e-01 4.7838249802589417e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1708 -1.2453690171241760e-02</internalNodes>
+          <leafValues>
+            2.6352968811988831e-01 5.2411228418350220e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1709 -2.0760179904755205e-04</internalNodes>
+          <leafValues>
+            3.6237570643424988e-01 5.1136088371276855e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1710 2.9781080229440704e-05</internalNodes>
+          <leafValues>
+            4.7059321403503418e-01 5.4328018426895142e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>211</maxWeakCount>
+      <stageThreshold>1.0474919891357422e+02</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1711 1.1772749945521355e-02</internalNodes>
+          <leafValues>
+            3.8605189323425293e-01 6.4211672544479370e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1712 2.7037570253014565e-02</internalNodes>
+          <leafValues>
+            4.3856549263000488e-01 6.7540389299392700e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1713 -3.6419500247575343e-05</internalNodes>
+          <leafValues>
+            5.4871010780334473e-01 3.4233158826828003e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1714 1.9995409529656172e-03</internalNodes>
+          <leafValues>
+            3.2305321097373962e-01 5.4003179073333740e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1715 4.5278300531208515e-03</internalNodes>
+          <leafValues>
+            5.0916397571563721e-01 2.9350438714027405e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1716 4.7890920541249216e-04</internalNodes>
+          <leafValues>
+            4.1781538724899292e-01 5.3440642356872559e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1717 1.1720920447260141e-03</internalNodes>
+          <leafValues>
+            2.8991821408271790e-01 5.1320707798004150e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1718 9.5305702416226268e-04</internalNodes>
+          <leafValues>
+            4.2801249027252197e-01 5.5608451366424561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1719 1.5099150004971307e-05</internalNodes>
+          <leafValues>
+            4.0448719263076782e-01 5.4047602415084839e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1720 -6.0817901976406574e-04</internalNodes>
+          <leafValues>
+            4.2717689275741577e-01 5.5034661293029785e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1721 3.3224520739167929e-03</internalNodes>
+          <leafValues>
+            3.9627239108085632e-01 5.3697347640991211e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1722 -1.1037490330636501e-03</internalNodes>
+          <leafValues>
+            4.7271779179573059e-01 5.2377498149871826e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1723 -1.4350269921123981e-03</internalNodes>
+          <leafValues>
+            5.6030082702636719e-01 4.2235091328620911e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1724 2.0767399109899998e-03</internalNodes>
+          <leafValues>
+            5.2259171009063721e-01 4.7327259182929993e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1725 -1.6412809782195836e-04</internalNodes>
+          <leafValues>
+            3.9990758895874023e-01 5.4327398538589478e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1726 8.8302437216043472e-03</internalNodes>
+          <leafValues>
+            4.6783858537673950e-01 6.0273271799087524e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1727 -1.0552070103585720e-02</internalNodes>
+          <leafValues>
+            3.4939670562744141e-01 5.2139747142791748e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1728 -2.2731600329279900e-03</internalNodes>
+          <leafValues>
+            6.1858189105987549e-01 4.7490629553794861e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1729 -8.4786332445219159e-04</internalNodes>
+          <leafValues>
+            5.2853411436080933e-01 3.8434821367263794e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1730 1.2081359745934606e-03</internalNodes>
+          <leafValues>
+            5.3606408834457397e-01 3.4473359584808350e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1731 2.6512730401009321e-03</internalNodes>
+          <leafValues>
+            4.5582920312881470e-01 6.1939620971679688e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1732 -1.1012479662895203e-03</internalNodes>
+          <leafValues>
+            3.6802300810813904e-01 5.3276282548904419e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1733 4.9561518244445324e-04</internalNodes>
+          <leafValues>
+            3.9605951309204102e-01 5.2749407291412354e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1734 -4.3901771306991577e-02</internalNodes>
+          <leafValues>
+            7.0204448699951172e-01 4.9928390979766846e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1735 3.4690350294113159e-02</internalNodes>
+          <leafValues>
+            5.0491642951965332e-01 2.7666029334068298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1736 -2.7442190330475569e-03</internalNodes>
+          <leafValues>
+            2.6726329326629639e-01 5.2749711275100708e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1737 3.3316588960587978e-03</internalNodes>
+          <leafValues>
+            4.5794829726219177e-01 6.0011017322540283e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1738 -2.0044570788741112e-02</internalNodes>
+          <leafValues>
+            3.1715941429138184e-01 5.2357178926467896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1739 1.3492030557245016e-03</internalNodes>
+          <leafValues>
+            5.2653628587722778e-01 4.0343248844146729e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1740 2.9702018946409225e-03</internalNodes>
+          <leafValues>
+            5.3324568271636963e-01 4.5719841122627258e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1741 6.3039981760084629e-03</internalNodes>
+          <leafValues>
+            4.5933109521865845e-01 6.0346359014511108e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1742 -1.2936590239405632e-02</internalNodes>
+          <leafValues>
+            4.4379639625549316e-01 5.3729712963104248e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1743 4.0148729458451271e-03</internalNodes>
+          <leafValues>
+            4.6803238987922668e-01 6.4378339052200317e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1744 -2.6401679497212172e-03</internalNodes>
+          <leafValues>
+            3.7096318602561951e-01 5.3143328428268433e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1745 1.3918439857661724e-02</internalNodes>
+          <leafValues>
+            4.7235551476478577e-01 7.1308088302612305e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1746 -4.5087869511917233e-04</internalNodes>
+          <leafValues>
+            4.4923940300941467e-01 5.3704041242599487e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1747 2.5384349282830954e-04</internalNodes>
+          <leafValues>
+            4.4068640470504761e-01 5.5144029855728149e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1748 2.2710000630468130e-03</internalNodes>
+          <leafValues>
+            4.6824169158935547e-01 5.9679841995239258e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1749 2.4120779708027840e-03</internalNodes>
+          <leafValues>
+            5.0793921947479248e-01 3.0185988545417786e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1750 -3.6025670851813629e-05</internalNodes>
+          <leafValues>
+            5.6010371446609497e-01 4.4710969924926758e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1751 -7.4905529618263245e-03</internalNodes>
+          <leafValues>
+            2.2075350582599640e-01 4.9899441003799438e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1752 -1.7513120546936989e-02</internalNodes>
+          <leafValues>
+            6.5312159061431885e-01 5.0176489353179932e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1753 1.4281630516052246e-01</internalNodes>
+          <leafValues>
+            4.9679630994796753e-01 1.4820620417594910e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1754 5.5345268920063972e-03</internalNodes>
+          <leafValues>
+            4.8989468812942505e-01 5.9542238712310791e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1755 -9.6323591424152255e-04</internalNodes>
+          <leafValues>
+            3.9271169900894165e-01 5.1960742473602295e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1756 -2.0370010752230883e-03</internalNodes>
+          <leafValues>
+            5.6133252382278442e-01 4.8848581314086914e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1757 1.6614829655736685e-03</internalNodes>
+          <leafValues>
+            4.4728800654411316e-01 5.5788809061050415e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1758 -3.1188090797513723e-03</internalNodes>
+          <leafValues>
+            3.8405328989028931e-01 5.3974777460098267e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1759 -6.4000617712736130e-03</internalNodes>
+          <leafValues>
+            5.8439838886260986e-01 4.5332181453704834e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1760 3.1319601112045348e-04</internalNodes>
+          <leafValues>
+            5.4392218589782715e-01 4.2347279191017151e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1761 -1.8222099170088768e-02</internalNodes>
+          <leafValues>
+            1.2884649634361267e-01 4.9584048986434937e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1762 8.7969247251749039e-03</internalNodes>
+          <leafValues>
+            4.9512979388237000e-01 7.1534800529479980e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1763 -4.2395070195198059e-03</internalNodes>
+          <leafValues>
+            3.9465999603271484e-01 5.1949369907379150e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1764 9.7086271271109581e-03</internalNodes>
+          <leafValues>
+            4.8975038528442383e-01 6.0649001598358154e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1765 -3.9934171363711357e-03</internalNodes>
+          <leafValues>
+            3.2454401254653931e-01 5.0608289241790771e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1766 -1.6785059124231339e-02</internalNodes>
+          <leafValues>
+            1.5819530189037323e-01 5.2037787437438965e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1767 1.8272090703248978e-02</internalNodes>
+          <leafValues>
+            4.6809351444244385e-01 6.6269791126251221e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1768 5.6872838176786900e-03</internalNodes>
+          <leafValues>
+            5.2116978168487549e-01 3.5121849179267883e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1769 -1.0739039862528443e-03</internalNodes>
+          <leafValues>
+            5.7683861255645752e-01 4.5298451185226440e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1770 -3.7093870341777802e-03</internalNodes>
+          <leafValues>
+            4.5077630877494812e-01 5.3135812282562256e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1771 -2.1110709349159151e-04</internalNodes>
+          <leafValues>
+            5.4608201980590820e-01 4.3333768844604492e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1772 1.0670139454305172e-03</internalNodes>
+          <leafValues>
+            5.3718560934066772e-01 4.0783908963203430e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1773 3.5943021066486835e-03</internalNodes>
+          <leafValues>
+            4.4712871313095093e-01 5.6438362598419189e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1774 -5.1776031032204628e-03</internalNodes>
+          <leafValues>
+            4.4993931055068970e-01 5.2803301811218262e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1775 -2.5414369883947074e-04</internalNodes>
+          <leafValues>
+            5.5161732435226440e-01 4.4077080488204956e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1776 6.3522560521960258e-03</internalNodes>
+          <leafValues>
+            5.1941901445388794e-01 2.4652279913425446e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1777 -4.4205080484971404e-04</internalNodes>
+          <leafValues>
+            3.8307058811187744e-01 5.1396822929382324e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1778 7.4488727841526270e-04</internalNodes>
+          <leafValues>
+            4.8910909891128540e-01 5.9747868776321411e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1779 -3.5116379149258137e-03</internalNodes>
+          <leafValues>
+            7.4136817455291748e-01 4.7687649726867676e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1780 -1.2540910392999649e-02</internalNodes>
+          <leafValues>
+            3.6488190293312073e-01 5.2528268098831177e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1781 9.4931852072477341e-03</internalNodes>
+          <leafValues>
+            5.1004928350448608e-01 3.6295869946479797e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1782 1.2961150147020817e-02</internalNodes>
+          <leafValues>
+            5.2324420213699341e-01 4.3335610628128052e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1783 4.7209449112415314e-03</internalNodes>
+          <leafValues>
+            4.6481490135192871e-01 6.3310527801513672e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1784 -2.3119079414755106e-03</internalNodes>
+          <leafValues>
+            5.9303098917007446e-01 4.5310580730438232e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1785 -2.8262299019843340e-03</internalNodes>
+          <leafValues>
+            3.8704779744148254e-01 5.2571010589599609e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1786 -1.4311339473351836e-03</internalNodes>
+          <leafValues>
+            5.5225032567977905e-01 4.5618548989295959e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1787 1.9378310535103083e-03</internalNodes>
+          <leafValues>
+            4.5462208986282349e-01 5.7369667291641235e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1788 2.6343559147790074e-04</internalNodes>
+          <leafValues>
+            5.3457391262054443e-01 4.5718750357627869e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1789 7.8257522545754910e-04</internalNodes>
+          <leafValues>
+            3.9678159356117249e-01 5.2201879024505615e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1790 -1.9550440832972527e-02</internalNodes>
+          <leafValues>
+            2.8296428918838501e-01 5.2435082197189331e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1791 4.3914958951063454e-04</internalNodes>
+          <leafValues>
+            4.5900669693946838e-01 5.8990901708602905e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1792 2.1452000364661217e-02</internalNodes>
+          <leafValues>
+            5.2314108610153198e-01 2.8553789854049683e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1793 5.8973580598831177e-04</internalNodes>
+          <leafValues>
+            4.3972569704055786e-01 5.5064219236373901e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1794 -2.6157610118389130e-02</internalNodes>
+          <leafValues>
+            3.1350791454315186e-01 5.1891750097274780e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1795 -1.3959860429167747e-02</internalNodes>
+          <leafValues>
+            3.2132729887962341e-01 5.0407177209854126e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1796 -6.3699018210172653e-03</internalNodes>
+          <leafValues>
+            6.3875448703765869e-01 4.8495069146156311e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1797 -8.5613820701837540e-03</internalNodes>
+          <leafValues>
+            2.7591320872306824e-01 5.0320190191268921e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1798 9.6622901037335396e-04</internalNodes>
+          <leafValues>
+            4.6856409311294556e-01 5.8348792791366577e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1799 7.6550268568098545e-04</internalNodes>
+          <leafValues>
+            5.1752072572708130e-01 3.8964220881462097e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1800 -8.1833340227603912e-03</internalNodes>
+          <leafValues>
+            2.0691369473934174e-01 5.2081221342086792e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1801 -9.3976939097046852e-03</internalNodes>
+          <leafValues>
+            6.1340910196304321e-01 4.6412229537963867e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1802 4.8028980381786823e-03</internalNodes>
+          <leafValues>
+            5.4541081190109253e-01 4.3952199816703796e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1803 -3.5680569708347321e-03</internalNodes>
+          <leafValues>
+            6.3444852828979492e-01 4.6810939908027649e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1804 4.0733120404183865e-03</internalNodes>
+          <leafValues>
+            5.2926832437515259e-01 4.0156200528144836e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1805 1.2568129459396005e-03</internalNodes>
+          <leafValues>
+            4.3929880857467651e-01 5.4528248310089111e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1806 -2.9065010603517294e-03</internalNodes>
+          <leafValues>
+            5.8988320827484131e-01 4.8633798956871033e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1807 -2.4409340694546700e-03</internalNodes>
+          <leafValues>
+            4.0693649649620056e-01 5.2474218606948853e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1808 2.4830700829625130e-02</internalNodes>
+          <leafValues>
+            5.1827257871627808e-01 3.6825248599052429e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1809 -4.8854008316993713e-02</internalNodes>
+          <leafValues>
+            1.3075779378414154e-01 4.9612811207771301e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1810 -1.6110379947349429e-03</internalNodes>
+          <leafValues>
+            6.4210057258605957e-01 4.8726621270179749e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1811 -9.7009479999542236e-02</internalNodes>
+          <leafValues>
+            4.7769349068403244e-02 4.9509888887405396e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1812 1.1209240183234215e-03</internalNodes>
+          <leafValues>
+            4.6162670850753784e-01 5.3547459840774536e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1813 -1.3064090162515640e-03</internalNodes>
+          <leafValues>
+            6.2618541717529297e-01 4.6388059854507446e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1814 4.5771620352752507e-04</internalNodes>
+          <leafValues>
+            5.3844177722930908e-01 4.6466401219367981e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1815 -6.3149951165542006e-04</internalNodes>
+          <leafValues>
+            3.8040471076965332e-01 5.1302570104598999e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1816 1.4505970466416329e-04</internalNodes>
+          <leafValues>
+            4.5543101429939270e-01 5.6644618511199951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1817 -1.6474550589919090e-02</internalNodes>
+          <leafValues>
+            6.5969580411911011e-01 4.7158598899841309e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1818 1.3369579799473286e-02</internalNodes>
+          <leafValues>
+            5.1954662799835205e-01 3.0359649658203125e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1819 1.0271780047332868e-04</internalNodes>
+          <leafValues>
+            5.2291762828826904e-01 4.1070660948753357e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1820 -5.5311559699475765e-03</internalNodes>
+          <leafValues>
+            6.3528877496719360e-01 4.9609071016311646e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1821 -2.6187049224972725e-03</internalNodes>
+          <leafValues>
+            3.8245460391044617e-01 5.1409840583801270e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1822 5.0834268331527710e-03</internalNodes>
+          <leafValues>
+            4.9504399299621582e-01 6.2208187580108643e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1823 7.9818159341812134e-02</internalNodes>
+          <leafValues>
+            4.9523359537124634e-01 1.3224759697914124e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1824 -9.9226586520671844e-02</internalNodes>
+          <leafValues>
+            7.5427287817001343e-01 5.0084167718887329e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1825 -6.5174017800018191e-04</internalNodes>
+          <leafValues>
+            3.6993029713630676e-01 5.1301211118698120e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1826 -1.8996849656105042e-02</internalNodes>
+          <leafValues>
+            6.6891789436340332e-01 4.9212029576301575e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1827 1.7346899956464767e-02</internalNodes>
+          <leafValues>
+            4.9833008646965027e-01 1.8591980636119843e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1828 5.5082101607695222e-04</internalNodes>
+          <leafValues>
+            4.5744240283966064e-01 5.5221217870712280e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1829 2.0056050270795822e-03</internalNodes>
+          <leafValues>
+            5.1317447423934937e-01 3.8564699888229370e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1830 -7.7688191086053848e-03</internalNodes>
+          <leafValues>
+            4.3617001175880432e-01 5.4343092441558838e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1831 5.0878278911113739e-02</internalNodes>
+          <leafValues>
+            4.6827208995819092e-01 6.8406397104263306e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1832 -2.2901780903339386e-03</internalNodes>
+          <leafValues>
+            4.3292450904846191e-01 5.3060990571975708e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1833 -1.5715380141045898e-04</internalNodes>
+          <leafValues>
+            5.3700572252273560e-01 4.3781641125679016e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1834 1.0519240051507950e-01</internalNodes>
+          <leafValues>
+            5.1372742652893066e-01 6.7361466586589813e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1835 2.7198919560760260e-03</internalNodes>
+          <leafValues>
+            4.1120609641075134e-01 5.2556651830673218e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1836 4.8337779939174652e-02</internalNodes>
+          <leafValues>
+            5.4046237468719482e-01 4.4389671087265015e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1837 9.5703761326149106e-04</internalNodes>
+          <leafValues>
+            4.3559691309928894e-01 5.3995108604431152e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1838 -2.5371259078383446e-02</internalNodes>
+          <leafValues>
+            5.9951752424240112e-01 5.0310248136520386e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1839 5.2457951009273529e-02</internalNodes>
+          <leafValues>
+            4.9502879381179810e-01 1.3983510434627533e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1840 -1.2365629896521568e-02</internalNodes>
+          <leafValues>
+            6.3972991704940796e-01 4.9641060829162598e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1841 -1.4589719474315643e-01</internalNodes>
+          <leafValues>
+            1.0016699880361557e-01 4.9463221430778503e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1842 -1.5908600762486458e-02</internalNodes>
+          <leafValues>
+            3.3123299479484558e-01 5.2083408832550049e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1843 3.9486068999394774e-04</internalNodes>
+          <leafValues>
+            4.4063639640808105e-01 5.4261028766632080e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1844 -5.2454001270234585e-03</internalNodes>
+          <leafValues>
+            2.7995899319648743e-01 5.1899671554565430e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1845 -5.0421799533069134e-03</internalNodes>
+          <leafValues>
+            6.9875800609588623e-01 4.7521421313285828e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1846 2.9812189750373363e-03</internalNodes>
+          <leafValues>
+            4.9832889437675476e-01 6.3074797391891479e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1847 -7.2884308174252510e-03</internalNodes>
+          <leafValues>
+            2.9823330044746399e-01 5.0268697738647461e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1848 1.5094350092113018e-03</internalNodes>
+          <leafValues>
+            5.3084421157836914e-01 3.8329708576202393e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1849 -9.3340799212455750e-03</internalNodes>
+          <leafValues>
+            2.0379640161991119e-01 4.9698171019554138e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1850 2.8667140752077103e-02</internalNodes>
+          <leafValues>
+            5.0256967544555664e-01 6.9280272722244263e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1851 1.7019680142402649e-01</internalNodes>
+          <leafValues>
+            4.9600529670715332e-01 1.4764429628849030e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1852 -3.2614478841423988e-03</internalNodes>
+          <leafValues>
+            5.6030637025833130e-01 4.8260560631752014e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1853 5.5769277969375253e-04</internalNodes>
+          <leafValues>
+            5.2055621147155762e-01 4.1296330094337463e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1854 3.6258339881896973e-01</internalNodes>
+          <leafValues>
+            5.2216529846191406e-01 3.7686121463775635e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1855 -1.1615130119025707e-02</internalNodes>
+          <leafValues>
+            6.0226827859878540e-01 4.6374899148941040e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1856 -4.0795197710394859e-03</internalNodes>
+          <leafValues>
+            4.0704470872879028e-01 5.3374791145324707e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1857 5.7204300537705421e-04</internalNodes>
+          <leafValues>
+            4.6018350124359131e-01 5.9003931283950806e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1858 6.7543348995968699e-04</internalNodes>
+          <leafValues>
+            5.3982520103454590e-01 4.3454289436340332e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1859 6.3295697327703238e-04</internalNodes>
+          <leafValues>
+            5.2015632390975952e-01 4.0513589978218079e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1860 1.2435320531949401e-03</internalNodes>
+          <leafValues>
+            4.6423879265785217e-01 5.5474412441253662e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1861 -4.7363857738673687e-03</internalNodes>
+          <leafValues>
+            6.1985671520233154e-01 4.6725520491600037e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1862 -6.4658462069928646e-03</internalNodes>
+          <leafValues>
+            6.8373328447341919e-01 5.0190007686614990e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1863 3.5017321351915598e-04</internalNodes>
+          <leafValues>
+            4.3448030948638916e-01 5.3636229038238525e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1864 1.5754920605104417e-04</internalNodes>
+          <leafValues>
+            4.7600790858268738e-01 5.7320207357406616e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1865 9.9774366244673729e-03</internalNodes>
+          <leafValues>
+            5.0909858942031860e-01 3.6350399255752563e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1866 -4.1464529931545258e-04</internalNodes>
+          <leafValues>
+            5.5700647830963135e-01 4.5938020944595337e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1867 -3.5888899583369493e-04</internalNodes>
+          <leafValues>
+            5.3568458557128906e-01 4.3391349911689758e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1868 4.0463250479660928e-04</internalNodes>
+          <leafValues>
+            4.4398030638694763e-01 5.4367768764495850e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1869 -8.2184787606820464e-04</internalNodes>
+          <leafValues>
+            4.0422949194908142e-01 5.1762992143630981e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1870 5.9467419050633907e-03</internalNodes>
+          <leafValues>
+            4.9276518821716309e-01 5.6337797641754150e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1871 -2.1753389388322830e-02</internalNodes>
+          <leafValues>
+            8.0062937736511230e-01 4.8008409142494202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1872 -1.4540379866957664e-02</internalNodes>
+          <leafValues>
+            3.9460548758506775e-01 5.1822227239608765e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1873 -4.0510769933462143e-02</internalNodes>
+          <leafValues>
+            2.1324990317225456e-02 4.9357929825782776e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1874 -5.8458268176764250e-04</internalNodes>
+          <leafValues>
+            4.0127959847450256e-01 5.3140252828598022e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1875 5.5151800625026226e-03</internalNodes>
+          <leafValues>
+            4.6424189209938049e-01 5.8962607383728027e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1876 -6.0626221820712090e-03</internalNodes>
+          <leafValues>
+            6.5021592378616333e-01 5.0164777040481567e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1877 9.4535842537879944e-02</internalNodes>
+          <leafValues>
+            5.2647089958190918e-01 4.1268271207809448e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1878 4.7315051779150963e-03</internalNodes>
+          <leafValues>
+            4.8791998624801636e-01 5.8924478292465210e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1879 -5.2571471314877272e-04</internalNodes>
+          <leafValues>
+            3.9172801375389099e-01 5.1894128322601318e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1880 -2.5464049540460110e-03</internalNodes>
+          <leafValues>
+            5.8375990390777588e-01 4.9857059121131897e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1881 -2.6075689122080803e-02</internalNodes>
+          <leafValues>
+            1.2619839608669281e-01 4.9558219313621521e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1882 -5.4779709316790104e-03</internalNodes>
+          <leafValues>
+            5.7225137948989868e-01 5.0102657079696655e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1883 5.1337741315364838e-03</internalNodes>
+          <leafValues>
+            5.2732622623443604e-01 4.2263761162757874e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1884 4.7944980906322598e-04</internalNodes>
+          <leafValues>
+            4.4500669836997986e-01 5.8195871114730835e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1885 -2.1114079281687737e-03</internalNodes>
+          <leafValues>
+            5.7576531171798706e-01 4.5117148756980896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1886 -1.3179990462958813e-02</internalNodes>
+          <leafValues>
+            1.8843810260295868e-01 5.1607340574264526e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1887 -4.7968099825084209e-03</internalNodes>
+          <leafValues>
+            6.5897899866104126e-01 4.7361189126968384e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1888 6.7483168095350266e-03</internalNodes>
+          <leafValues>
+            5.2594298124313354e-01 3.3563950657844543e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1889 1.4623369788751006e-03</internalNodes>
+          <leafValues>
+            5.3552711009979248e-01 4.2640921473503113e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1890 4.7645159065723419e-03</internalNodes>
+          <leafValues>
+            5.0344067811965942e-01 5.7868278026580811e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1891 6.8066660314798355e-03</internalNodes>
+          <leafValues>
+            4.7566050291061401e-01 6.6778290271759033e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1892 3.6608621012419462e-03</internalNodes>
+          <leafValues>
+            5.3696119785308838e-01 4.3115469813346863e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1893 2.1449640393257141e-02</internalNodes>
+          <leafValues>
+            4.9686419963836670e-01 1.8888160586357117e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1894 4.1678901761770248e-03</internalNodes>
+          <leafValues>
+            4.9307331442832947e-01 5.8153688907623291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1895 8.6467564105987549e-03</internalNodes>
+          <leafValues>
+            5.2052050828933716e-01 4.1325950622558594e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1896 -3.6114078829996288e-04</internalNodes>
+          <leafValues>
+            5.4835551977157593e-01 4.8009279370307922e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1897 1.0808729566633701e-03</internalNodes>
+          <leafValues>
+            4.6899020671844482e-01 6.0414212942123413e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1898 5.7719959877431393e-03</internalNodes>
+          <leafValues>
+            5.1711422204971313e-01 3.0532771348953247e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1899 1.5720770461484790e-03</internalNodes>
+          <leafValues>
+            5.2199780941009521e-01 4.1788038611412048e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1900 -1.9307859474793077e-03</internalNodes>
+          <leafValues>
+            5.8603698015213013e-01 4.8129200935363770e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1901 -7.8926272690296173e-03</internalNodes>
+          <leafValues>
+            1.7492769658565521e-01 4.9717339873313904e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1902 -2.2224679123610258e-03</internalNodes>
+          <leafValues>
+            4.3425890803337097e-01 5.2128481864929199e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1903 1.9011989934369922e-03</internalNodes>
+          <leafValues>
+            4.7651869058609009e-01 6.8920552730560303e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1904 2.7576119173318148e-03</internalNodes>
+          <leafValues>
+            5.2621912956237793e-01 4.3374860286712646e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1905 5.1787449046969414e-03</internalNodes>
+          <leafValues>
+            4.8040691018104553e-01 7.8437292575836182e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1906 -9.0273341629654169e-04</internalNodes>
+          <leafValues>
+            4.1208469867706299e-01 5.3534239530563354e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1907 5.1797959022223949e-03</internalNodes>
+          <leafValues>
+            4.7403728961944580e-01 6.4259600639343262e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1908 -1.0114000178873539e-02</internalNodes>
+          <leafValues>
+            2.4687920510768890e-01 5.1750177145004272e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1909 -1.8617060035467148e-02</internalNodes>
+          <leafValues>
+            5.7562941312789917e-01 4.6289789676666260e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1910 5.9225959703326225e-03</internalNodes>
+          <leafValues>
+            5.1696258783340454e-01 3.2142710685729980e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1911 -6.2945079989731312e-03</internalNodes>
+          <leafValues>
+            3.8720148801803589e-01 5.1416367292404175e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1912 6.5353019163012505e-03</internalNodes>
+          <leafValues>
+            4.8530489206314087e-01 6.3104897737503052e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1913 1.0878399480134249e-03</internalNodes>
+          <leafValues>
+            5.1173150539398193e-01 3.7232589721679688e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1914 -2.2542240098118782e-02</internalNodes>
+          <leafValues>
+            5.6927400827407837e-01 4.8871129751205444e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1915 -3.0065660830587149e-03</internalNodes>
+          <leafValues>
+            2.5560128688812256e-01 5.0039929151535034e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1916 7.4741272255778313e-03</internalNodes>
+          <leafValues>
+            4.8108729720115662e-01 5.6759268045425415e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1917 2.6162320747971535e-02</internalNodes>
+          <leafValues>
+            4.9711948633193970e-01 1.7772370576858521e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1918 9.4352738233283162e-04</internalNodes>
+          <leafValues>
+            4.9400109052658081e-01 5.4912507534027100e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1919 3.3363241702318192e-02</internalNodes>
+          <leafValues>
+            5.0076121091842651e-01 2.7907240390777588e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1920 -1.5118650160729885e-02</internalNodes>
+          <leafValues>
+            7.0595788955688477e-01 4.9730318784713745e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1921 9.8648946732282639e-04</internalNodes>
+          <leafValues>
+            5.1286202669143677e-01 3.7767618894577026e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>213</maxWeakCount>
+      <stageThreshold>1.0576110076904297e+02</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1922 -9.5150798559188843e-02</internalNodes>
+          <leafValues>
+            6.4707571268081665e-01 4.0172868967056274e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1923 6.2702340073883533e-03</internalNodes>
+          <leafValues>
+            3.9998221397399902e-01 5.7464492321014404e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1924 3.0018089455552399e-04</internalNodes>
+          <leafValues>
+            3.5587701201438904e-01 5.5388098955154419e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1925 1.1757409665733576e-03</internalNodes>
+          <leafValues>
+            4.2565348744392395e-01 5.3826177120208740e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1926 4.4235268433112651e-05</internalNodes>
+          <leafValues>
+            3.6829081177711487e-01 5.5899268388748169e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1927 -2.9936920327600092e-05</internalNodes>
+          <leafValues>
+            5.4524701833724976e-01 4.0203678607940674e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1928 3.0073199886828661e-03</internalNodes>
+          <leafValues>
+            5.2390581369400024e-01 3.3178439736366272e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1929 -1.0513889603316784e-02</internalNodes>
+          <leafValues>
+            4.3206891417503357e-01 5.3079837560653687e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1930 8.3476826548576355e-03</internalNodes>
+          <leafValues>
+            4.5046371221542358e-01 6.4532989263534546e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1931 -3.1492270063608885e-03</internalNodes>
+          <leafValues>
+            4.3134251236915588e-01 5.3705251216888428e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1932 -1.4435649973165710e-05</internalNodes>
+          <leafValues>
+            5.3266030550003052e-01 3.8179719448089600e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1933 -4.2855090578086674e-04</internalNodes>
+          <leafValues>
+            4.3051639199256897e-01 5.3820097446441650e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1934 1.5062429883982986e-04</internalNodes>
+          <leafValues>
+            4.2359709739685059e-01 5.5449652671813965e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1935 7.1559831500053406e-02</internalNodes>
+          <leafValues>
+            5.3030598163604736e-01 2.6788029074668884e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1936 8.4095180500298738e-04</internalNodes>
+          <leafValues>
+            3.5571089386940002e-01 5.2054339647293091e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1937 6.2986500561237335e-02</internalNodes>
+          <leafValues>
+            5.2253627777099609e-01 2.8613761067390442e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1938 -3.3798629883676767e-03</internalNodes>
+          <leafValues>
+            3.6241859197616577e-01 5.2016979455947876e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1939 -1.1810739670181647e-04</internalNodes>
+          <leafValues>
+            5.4744768142700195e-01 3.9598938822746277e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1940 -5.4505601292476058e-04</internalNodes>
+          <leafValues>
+            3.7404221296310425e-01 5.2157157659530640e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1941 -1.8454910023137927e-03</internalNodes>
+          <leafValues>
+            5.8930522203445435e-01 4.5844489336013794e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1942 -4.3832371011376381e-04</internalNodes>
+          <leafValues>
+            4.0845820307731628e-01 5.3853511810302734e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1943 -2.4000830017030239e-03</internalNodes>
+          <leafValues>
+            3.7774550914764404e-01 5.2935802936553955e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1944 -9.8795741796493530e-02</internalNodes>
+          <leafValues>
+            2.9636120796203613e-01 5.0700891017913818e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1945 3.1798239797353745e-03</internalNodes>
+          <leafValues>
+            4.8776328563690186e-01 6.7264437675476074e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1946 3.2406419632025063e-04</internalNodes>
+          <leafValues>
+            4.3669110536575317e-01 5.5611097812652588e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1947 -3.2547250390052795e-02</internalNodes>
+          <leafValues>
+            3.1281578540802002e-01 5.3086161613464355e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1948 -7.7561130747199059e-03</internalNodes>
+          <leafValues>
+            6.5602248907089233e-01 4.6398720145225525e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1949 1.6027249395847321e-02</internalNodes>
+          <leafValues>
+            5.1726800203323364e-01 3.1418979167938232e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1950 7.1002350523485802e-06</internalNodes>
+          <leafValues>
+            4.0844461321830750e-01 5.3362947702407837e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1951 7.3422808200120926e-03</internalNodes>
+          <leafValues>
+            4.9669221043586731e-01 6.6034650802612305e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1952 -1.6970280557870865e-03</internalNodes>
+          <leafValues>
+            5.9082370996475220e-01 4.5001828670501709e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1953 2.4118260480463505e-03</internalNodes>
+          <leafValues>
+            5.3151607513427734e-01 3.5997208952903748e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1954 -5.5300937965512276e-03</internalNodes>
+          <leafValues>
+            2.3340409994125366e-01 4.9968141317367554e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1955 -2.6478730142116547e-03</internalNodes>
+          <leafValues>
+            5.8809357881546021e-01 4.6847340464591980e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1956 1.1295629665255547e-02</internalNodes>
+          <leafValues>
+            4.9837771058082581e-01 1.8845909833908081e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1957 -6.6952878842130303e-04</internalNodes>
+          <leafValues>
+            5.8721381425857544e-01 4.7990199923515320e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1958 1.4410680159926414e-03</internalNodes>
+          <leafValues>
+            5.1311892271041870e-01 3.5010111331939697e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1959 2.4637870956212282e-03</internalNodes>
+          <leafValues>
+            5.3393721580505371e-01 4.1176390647888184e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1960 3.3114518737420440e-04</internalNodes>
+          <leafValues>
+            4.3133831024169922e-01 5.3982460498809814e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1961 -3.3557269722223282e-02</internalNodes>
+          <leafValues>
+            2.6753368973731995e-01 5.1791548728942871e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1962 1.8539419397711754e-02</internalNodes>
+          <leafValues>
+            4.9738699197769165e-01 2.3171770572662354e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1963 -2.9698139405809343e-04</internalNodes>
+          <leafValues>
+            5.5297082662582397e-01 4.6436640620231628e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1964 -4.5577259152196348e-04</internalNodes>
+          <leafValues>
+            5.6295841932296753e-01 4.4691911339759827e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1965 -1.0158980265259743e-02</internalNodes>
+          <leafValues>
+            6.7062127590179443e-01 4.9259188771247864e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1966 -2.2413829356082715e-05</internalNodes>
+          <leafValues>
+            5.2394217252731323e-01 3.9129018783569336e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1967 7.2034963523037732e-05</internalNodes>
+          <leafValues>
+            4.7994381189346313e-01 5.5017888545989990e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1968 -6.9267209619283676e-03</internalNodes>
+          <leafValues>
+            6.9300097227096558e-01 4.6980848908424377e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1969 -7.6997838914394379e-03</internalNodes>
+          <leafValues>
+            4.0996238589286804e-01 5.4808831214904785e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1970 -7.3130549862980843e-03</internalNodes>
+          <leafValues>
+            3.2834759354591370e-01 5.0578862428665161e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1971 1.9650589674711227e-03</internalNodes>
+          <leafValues>
+            4.9780470132827759e-01 6.3982498645782471e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1972 7.1647600270807743e-03</internalNodes>
+          <leafValues>
+            4.6611601114273071e-01 6.2221372127532959e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1973 -2.4078639224171638e-02</internalNodes>
+          <leafValues>
+            2.3346449434757233e-01 5.2221620082855225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1974 -2.1027969196438789e-02</internalNodes>
+          <leafValues>
+            1.1836539953947067e-01 4.9382260441780090e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1975 3.6017020465806127e-04</internalNodes>
+          <leafValues>
+            5.3250199556350708e-01 4.1167110204696655e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1976 -1.7219729721546173e-02</internalNodes>
+          <leafValues>
+            6.2787622213363647e-01 4.6642690896987915e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1977 -7.8672142699360847e-03</internalNodes>
+          <leafValues>
+            3.4034150838851929e-01 5.2497369050979614e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1978 -4.4777389848604798e-04</internalNodes>
+          <leafValues>
+            3.6104118824005127e-01 5.0862592458724976e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1979 5.5486010387539864e-03</internalNodes>
+          <leafValues>
+            4.8842659592628479e-01 6.2034982442855835e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1980 -6.9461148232221603e-03</internalNodes>
+          <leafValues>
+            2.6259300112724304e-01 5.0110971927642822e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1981 1.3569870498031378e-04</internalNodes>
+          <leafValues>
+            4.3407949805259705e-01 5.6283122301101685e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1982 -4.5880250632762909e-02</internalNodes>
+          <leafValues>
+            6.5079987049102783e-01 4.6962749958038330e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1983 -2.1582560613751411e-02</internalNodes>
+          <leafValues>
+            3.8265028595924377e-01 5.2876168489456177e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1984 -2.0209539681673050e-02</internalNodes>
+          <leafValues>
+            3.2333680987358093e-01 5.0744771957397461e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1985 5.8496710844337940e-03</internalNodes>
+          <leafValues>
+            5.1776039600372314e-01 4.4896709918975830e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1986 -5.7476379879517481e-05</internalNodes>
+          <leafValues>
+            4.0208509564399719e-01 5.2463638782501221e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1987 -1.1513100471347570e-03</internalNodes>
+          <leafValues>
+            6.3150721788406372e-01 4.9051541090011597e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1988 1.9862831104546785e-03</internalNodes>
+          <leafValues>
+            4.7024598717689514e-01 6.4971512556076050e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1989 -5.2719512023031712e-03</internalNodes>
+          <leafValues>
+            3.6503839492797852e-01 5.2276527881622314e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1990 1.2662699446082115e-03</internalNodes>
+          <leafValues>
+            5.1661008596420288e-01 3.8776180148124695e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1991 -6.2919440679252148e-03</internalNodes>
+          <leafValues>
+            7.3758941888809204e-01 5.0238478183746338e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1992 6.7360111279413104e-04</internalNodes>
+          <leafValues>
+            4.4232261180877686e-01 5.4955857992172241e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1993 -1.0523450328037143e-03</internalNodes>
+          <leafValues>
+            5.9763962030410767e-01 4.8595830798149109e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1994 -4.4216238893568516e-04</internalNodes>
+          <leafValues>
+            5.9559392929077148e-01 4.3989309668540955e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1995 1.1747940443456173e-03</internalNodes>
+          <leafValues>
+            5.3498882055282593e-01 4.6050581336021423e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1996 5.2457437850534916e-03</internalNodes>
+          <leafValues>
+            5.0491911172866821e-01 2.9415771365165710e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1997 -2.4539720267057419e-02</internalNodes>
+          <leafValues>
+            2.5501778721809387e-01 5.2185869216918945e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1998 7.3793041519820690e-04</internalNodes>
+          <leafValues>
+            4.4248610734939575e-01 5.4908162355422974e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1999 1.4233799884095788e-03</internalNodes>
+          <leafValues>
+            5.3195142745971680e-01 4.0813559293746948e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2000 -2.4149110540747643e-03</internalNodes>
+          <leafValues>
+            4.0876591205596924e-01 5.2389502525329590e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2001 -1.2165299849584699e-03</internalNodes>
+          <leafValues>
+            5.6745791435241699e-01 4.9080529808998108e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2002 -1.2438809499144554e-03</internalNodes>
+          <leafValues>
+            4.1294258832931519e-01 5.2561181783676147e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2003 6.1942739412188530e-03</internalNodes>
+          <leafValues>
+            5.0601941347122192e-01 7.3136532306671143e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2004 -1.6607169527560472e-03</internalNodes>
+          <leafValues>
+            5.9796321392059326e-01 4.5963698625564575e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2005 -2.7316259220242500e-02</internalNodes>
+          <leafValues>
+            4.1743651032447815e-01 5.3088420629501343e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2006 -1.5845570014789701e-03</internalNodes>
+          <leafValues>
+            5.6158047914505005e-01 4.5194861292839050e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2007 -1.5514739789068699e-03</internalNodes>
+          <leafValues>
+            4.0761870145797729e-01 5.3607851266860962e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2008 3.8446558755822480e-04</internalNodes>
+          <leafValues>
+            4.3472939729690552e-01 5.4304420948028564e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2009 -1.4672259800136089e-02</internalNodes>
+          <leafValues>
+            1.6593049466609955e-01 5.1460939645767212e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2010 8.1608882173895836e-03</internalNodes>
+          <leafValues>
+            4.9618190526962280e-01 1.8847459554672241e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2011 1.1121659772470593e-03</internalNodes>
+          <leafValues>
+            4.8682639002799988e-01 6.0938161611557007e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2012 -7.2603770531713963e-03</internalNodes>
+          <leafValues>
+            6.2843251228332520e-01 4.6903759241104126e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2013 -2.4046430189628154e-04</internalNodes>
+          <leafValues>
+            5.5750000476837158e-01 4.0460440516471863e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2014 -2.3348190006799996e-04</internalNodes>
+          <leafValues>
+            4.1157621145248413e-01 5.2528482675552368e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2015 5.5736480280756950e-03</internalNodes>
+          <leafValues>
+            4.7300729155540466e-01 5.6901007890701294e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2016 3.0623769387602806e-02</internalNodes>
+          <leafValues>
+            4.9718868732452393e-01 1.7400950193405151e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2017 9.2074798885732889e-04</internalNodes>
+          <leafValues>
+            5.3721177577972412e-01 4.3548721075057983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2018 -4.3550739064812660e-05</internalNodes>
+          <leafValues>
+            5.3668838739395142e-01 4.3473169207572937e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2019 -6.6452710889279842e-03</internalNodes>
+          <leafValues>
+            3.4355181455612183e-01 5.1605331897735596e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2020 4.3221998959779739e-02</internalNodes>
+          <leafValues>
+            4.7667920589447021e-01 7.2936528921127319e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2021 2.2331769578158855e-03</internalNodes>
+          <leafValues>
+            5.0293159484863281e-01 5.6331712007522583e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2022 3.1829739455133677e-03</internalNodes>
+          <leafValues>
+            4.0160921216011047e-01 5.1921367645263672e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2023 -1.8027749320026487e-04</internalNodes>
+          <leafValues>
+            4.0883159637451172e-01 5.4179197549819946e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2024 -5.2934689447283745e-03</internalNodes>
+          <leafValues>
+            4.0756770968437195e-01 5.2435618638992310e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2025 1.2750959722325206e-03</internalNodes>
+          <leafValues>
+            4.9132829904556274e-01 6.3870108127593994e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2026 4.3385322205722332e-03</internalNodes>
+          <leafValues>
+            5.0316721200942993e-01 2.9473468661308289e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2027 8.5250744596123695e-03</internalNodes>
+          <leafValues>
+            4.9497890472412109e-01 6.3088691234588623e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2028 -9.4266352243721485e-04</internalNodes>
+          <leafValues>
+            5.3283667564392090e-01 4.2856499552726746e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2029 1.3609660090878606e-03</internalNodes>
+          <leafValues>
+            4.9915251135826111e-01 5.9415012598037720e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2030 4.4782509212382138e-04</internalNodes>
+          <leafValues>
+            4.5735040307044983e-01 5.8544808626174927e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2031 1.3360050506889820e-03</internalNodes>
+          <leafValues>
+            4.6043589711189270e-01 5.8490520715713501e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2032 -6.0967548051849008e-04</internalNodes>
+          <leafValues>
+            3.9693889021873474e-01 5.2294230461120605e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2033 -2.3656780831515789e-03</internalNodes>
+          <leafValues>
+            5.8083200454711914e-01 4.8983570933341980e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2034 1.0734340175986290e-03</internalNodes>
+          <leafValues>
+            4.3512108922004700e-01 5.4700392484664917e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2035 2.1923359017819166e-03</internalNodes>
+          <leafValues>
+            5.3550601005554199e-01 3.8429039716720581e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2036 5.4968618787825108e-03</internalNodes>
+          <leafValues>
+            5.0181388854980469e-01 2.8271919488906860e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2037 -7.5368821620941162e-02</internalNodes>
+          <leafValues>
+            1.2250760197639465e-01 5.1488268375396729e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2038 2.5134470313787460e-02</internalNodes>
+          <leafValues>
+            4.7317668795585632e-01 7.0254462957382202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2039 -2.9358599931583740e-05</internalNodes>
+          <leafValues>
+            5.4305320978164673e-01 4.6560868620872498e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2040 -5.8355910005047917e-04</internalNodes>
+          <leafValues>
+            4.0310400724411011e-01 5.1901197433471680e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2041 -2.6639450807124376e-03</internalNodes>
+          <leafValues>
+            4.3081268668174744e-01 5.1617711782455444e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2042 -1.3804089976474643e-03</internalNodes>
+          <leafValues>
+            6.2198299169540405e-01 4.6955159306526184e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2043 1.2313219485804439e-03</internalNodes>
+          <leafValues>
+            5.3793638944625854e-01 4.4258311390876770e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2044 -1.4644179827882908e-05</internalNodes>
+          <leafValues>
+            5.2816402912139893e-01 4.2225030064582825e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2045 -1.2818809598684311e-02</internalNodes>
+          <leafValues>
+            2.5820928812026978e-01 5.1799327135086060e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2046 2.2852189838886261e-02</internalNodes>
+          <leafValues>
+            4.7786930203437805e-01 7.6092642545700073e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2047 8.2305970136076212e-04</internalNodes>
+          <leafValues>
+            5.3409922122955322e-01 4.6717241406440735e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2048 1.2770120054483414e-02</internalNodes>
+          <leafValues>
+            4.9657610058784485e-01 1.4723660051822662e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2049 -5.0051510334014893e-02</internalNodes>
+          <leafValues>
+            6.4149940013885498e-01 5.0165921449661255e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2050 1.5775270760059357e-02</internalNodes>
+          <leafValues>
+            4.5223200321197510e-01 5.6853622198104858e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2051 -1.8501620739698410e-02</internalNodes>
+          <leafValues>
+            2.7647489309310913e-01 5.1379591226577759e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2052 2.4626250378787518e-03</internalNodes>
+          <leafValues>
+            5.1419419050216675e-01 3.7954080104827881e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2053 6.2916167080402374e-02</internalNodes>
+          <leafValues>
+            5.0606489181518555e-01 6.5804338455200195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2054 -2.1648500478477217e-05</internalNodes>
+          <leafValues>
+            5.1953881978988647e-01 4.0198868513107300e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2055 2.1180990152060986e-03</internalNodes>
+          <leafValues>
+            4.9623650312423706e-01 5.9544587135314941e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2056 -1.6634890809655190e-02</internalNodes>
+          <leafValues>
+            3.7579330801963806e-01 5.1754468679428101e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2057 -2.8899470344185829e-03</internalNodes>
+          <leafValues>
+            6.6240137815475464e-01 5.0571787357330322e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2058 7.6783262193202972e-02</internalNodes>
+          <leafValues>
+            4.7957968711853027e-01 8.0477148294448853e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2059 3.9170677773654461e-03</internalNodes>
+          <leafValues>
+            4.9378821253776550e-01 5.7199418544769287e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2060 -7.2670601308345795e-02</internalNodes>
+          <leafValues>
+            5.3894560784101486e-02 4.9439039826393127e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2061 5.4039502143859863e-01</internalNodes>
+          <leafValues>
+            5.1297742128372192e-01 1.1433389782905579e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2062 2.9510019812732935e-03</internalNodes>
+          <leafValues>
+            4.5283439755439758e-01 5.6985741853713989e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2063 3.4508369863033295e-03</internalNodes>
+          <leafValues>
+            5.3577268123626709e-01 4.2187309265136719e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2064 -4.2077939724549651e-04</internalNodes>
+          <leafValues>
+            5.9161728620529175e-01 4.6379259228706360e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2065 3.3051050268113613e-03</internalNodes>
+          <leafValues>
+            5.2733850479125977e-01 4.3820428848266602e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2066 4.7735060798004270e-04</internalNodes>
+          <leafValues>
+            4.0465280413627625e-01 5.1818847656250000e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2067 -2.5928510352969170e-02</internalNodes>
+          <leafValues>
+            7.4522358179092407e-01 5.0893861055374146e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2068 -2.9729790985584259e-03</internalNodes>
+          <leafValues>
+            3.2954359054565430e-01 5.0587952136993408e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2069 5.8508329093456268e-03</internalNodes>
+          <leafValues>
+            4.8571440577507019e-01 5.7930248975753784e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2070 -4.5967519283294678e-02</internalNodes>
+          <leafValues>
+            4.3127310276031494e-01 5.3806531429290771e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2071 1.5585960447788239e-01</internalNodes>
+          <leafValues>
+            5.1961702108383179e-01 1.6847139596939087e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2072 1.5164829790592194e-02</internalNodes>
+          <leafValues>
+            4.7357571125030518e-01 6.7350268363952637e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2073 -1.0604249546304345e-03</internalNodes>
+          <leafValues>
+            5.8229267597198486e-01 4.7757029533386230e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2074 6.6476291976869106e-03</internalNodes>
+          <leafValues>
+            4.9991989135742188e-01 2.3195350170135498e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2075 -1.2231130152940750e-02</internalNodes>
+          <leafValues>
+            4.7508931159973145e-01 5.2629822492599487e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2076 5.6528882123529911e-03</internalNodes>
+          <leafValues>
+            5.0697678327560425e-01 3.5618188977241516e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2077 1.2977829901501536e-03</internalNodes>
+          <leafValues>
+            4.8756939172744751e-01 5.6190627813339233e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2078 1.0781589895486832e-02</internalNodes>
+          <leafValues>
+            4.7507700324058533e-01 6.7823082208633423e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2079 2.8654779307544231e-03</internalNodes>
+          <leafValues>
+            5.3054618835449219e-01 4.2907360196113586e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2080 2.8663428965955973e-03</internalNodes>
+          <leafValues>
+            4.5184791088104248e-01 5.5393511056900024e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2081 -5.1983320154249668e-03</internalNodes>
+          <leafValues>
+            4.1491198539733887e-01 5.4341888427734375e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2082 5.3739990107715130e-03</internalNodes>
+          <leafValues>
+            4.7178968787193298e-01 6.5076571702957153e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2083 -1.4641529880464077e-02</internalNodes>
+          <leafValues>
+            2.1721640229225159e-01 5.1617771387100220e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2084 -1.5042580344015732e-05</internalNodes>
+          <leafValues>
+            5.3373837471008301e-01 4.2988368868827820e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2085 -1.1875660129589960e-04</internalNodes>
+          <leafValues>
+            4.6045941114425659e-01 5.5824470520019531e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2086 1.6995530575513840e-02</internalNodes>
+          <leafValues>
+            4.9458950757980347e-01 7.3880076408386230e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2087 -3.5095941275358200e-02</internalNodes>
+          <leafValues>
+            7.0055091381072998e-01 4.9775910377502441e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2088 2.4217350874096155e-03</internalNodes>
+          <leafValues>
+            4.4662651419639587e-01 5.4776942729949951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2089 -9.6340337768197060e-04</internalNodes>
+          <leafValues>
+            4.7140988707542419e-01 5.3133380413055420e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2090 1.6391130338888615e-04</internalNodes>
+          <leafValues>
+            4.3315461277961731e-01 5.3422421216964722e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2091 -2.1141460165381432e-02</internalNodes>
+          <leafValues>
+            2.6447001099586487e-01 5.2044987678527832e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2092 8.7775202700868249e-04</internalNodes>
+          <leafValues>
+            5.2083498239517212e-01 4.1527429223060608e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2093 -2.7943920344114304e-02</internalNodes>
+          <leafValues>
+            6.3441252708435059e-01 5.0188118219375610e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2094 6.7297378554940224e-03</internalNodes>
+          <leafValues>
+            5.0504380464553833e-01 3.5008639097213745e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2095 2.3281039670109749e-02</internalNodes>
+          <leafValues>
+            4.9663180112838745e-01 6.9686770439147949e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2096 -1.1644979938864708e-02</internalNodes>
+          <leafValues>
+            3.3002600073814392e-01 5.0496298074722290e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2097 1.5764309093356133e-02</internalNodes>
+          <leafValues>
+            4.9915981292724609e-01 7.3211538791656494e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2098 -1.3611479662358761e-03</internalNodes>
+          <leafValues>
+            3.9117351174354553e-01 5.1606708765029907e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2099 -8.1522337859496474e-04</internalNodes>
+          <leafValues>
+            5.6289112567901611e-01 4.9497190117835999e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2100 -6.0066272271797061e-04</internalNodes>
+          <leafValues>
+            5.8535951375961304e-01 4.5505958795547485e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2101 4.9715518252924085e-04</internalNodes>
+          <leafValues>
+            4.2714700102806091e-01 5.4435992240905762e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2102 2.3475370835512877e-03</internalNodes>
+          <leafValues>
+            5.1431107521057129e-01 3.8876569271087646e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2103 -8.9261569082736969e-03</internalNodes>
+          <leafValues>
+            6.0445022583007812e-01 4.9717208743095398e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2104 -1.3919910416007042e-02</internalNodes>
+          <leafValues>
+            2.5831609964370728e-01 5.0003677606582642e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2105 1.0209949687123299e-03</internalNodes>
+          <leafValues>
+            4.8573741316795349e-01 5.5603581666946411e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2106 -2.7441629208624363e-03</internalNodes>
+          <leafValues>
+            5.9368848800659180e-01 4.6457770466804504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2107 -1.6200130805373192e-02</internalNodes>
+          <leafValues>
+            3.1630149483680725e-01 5.1934951543807983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2108 4.3331980705261230e-03</internalNodes>
+          <leafValues>
+            5.0612241029739380e-01 3.4588789939880371e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2109 5.8497930876910686e-04</internalNodes>
+          <leafValues>
+            4.7790178656578064e-01 5.8701777458190918e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2110 -2.2466450463980436e-03</internalNodes>
+          <leafValues>
+            4.2978510260581970e-01 5.3747731447219849e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2111 2.3146099410951138e-03</internalNodes>
+          <leafValues>
+            5.4386717081069946e-01 4.6409699320793152e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2112 8.7679121643304825e-03</internalNodes>
+          <leafValues>
+            4.7268930077552795e-01 6.7717897891998291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2113 -2.2448020172305405e-04</internalNodes>
+          <leafValues>
+            4.2291730642318726e-01 5.4280489683151245e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2114 -7.4336021207273006e-03</internalNodes>
+          <leafValues>
+            6.0988807678222656e-01 4.6836739778518677e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2115 -2.3189240600913763e-03</internalNodes>
+          <leafValues>
+            5.6894367933273315e-01 4.4242420792579651e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2116 -2.1042178850620985e-03</internalNodes>
+          <leafValues>
+            3.7622210383415222e-01 5.1870870590209961e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2117 4.6034841216169298e-04</internalNodes>
+          <leafValues>
+            4.6994051337242126e-01 5.7712072134017944e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2118 1.0547629790380597e-03</internalNodes>
+          <leafValues>
+            4.4652169942855835e-01 5.6017017364501953e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2119 8.7148818420246243e-04</internalNodes>
+          <leafValues>
+            5.4498052597045898e-01 3.9147090911865234e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2120 3.3364820410497487e-04</internalNodes>
+          <leafValues>
+            4.5640090107917786e-01 5.6457388401031494e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2121 -1.4853250468149781e-03</internalNodes>
+          <leafValues>
+            5.7473778724670410e-01 4.6927788853645325e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2122 3.0251620337367058e-03</internalNodes>
+          <leafValues>
+            5.1661968231201172e-01 3.7628141045570374e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2123 5.0280741415917873e-03</internalNodes>
+          <leafValues>
+            5.0021117925643921e-01 6.1515271663665771e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2124 -5.8164511574432254e-04</internalNodes>
+          <leafValues>
+            5.3945982456207275e-01 4.3907511234283447e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2125 4.5141529291868210e-02</internalNodes>
+          <leafValues>
+            5.1883268356323242e-01 2.0630359649658203e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2126 -1.0795620037242770e-03</internalNodes>
+          <leafValues>
+            3.9046850800514221e-01 5.1379072666168213e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2127 1.5995999274309725e-04</internalNodes>
+          <leafValues>
+            4.8953229188919067e-01 5.4275041818618774e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2128 -1.9359270110726357e-02</internalNodes>
+          <leafValues>
+            6.9752287864685059e-01 4.7735071182250977e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2129 2.0725509524345398e-01</internalNodes>
+          <leafValues>
+            5.2336359024047852e-01 3.0349919199943542e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2130 -4.1953290929086506e-04</internalNodes>
+          <leafValues>
+            5.4193967580795288e-01 4.4601860642433167e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2131 2.2582069505006075e-03</internalNodes>
+          <leafValues>
+            4.8157641291618347e-01 6.0274088382720947e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2132 -6.7811207845807076e-03</internalNodes>
+          <leafValues>
+            3.9802789688110352e-01 5.1833057403564453e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2133 1.1154309846460819e-02</internalNodes>
+          <leafValues>
+            5.4312318563461304e-01 4.1887599229812622e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2134 4.3162431567907333e-02</internalNodes>
+          <leafValues>
+            4.7382280230522156e-01 6.5229612588882446e-01</leafValues></_></weakClassifiers></_></stages>
+  <features>
+    <_>
+      <rects>
+        <_>
+          3 7 14 4 -1.</_>
+        <_>
+          3 9 14 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 18 4 -1.</_>
+        <_>
+          7 2 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 15 9 -1.</_>
+        <_>
+          1 10 15 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 2 6 -1.</_>
+        <_>
+          5 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 3 -1.</_>
+        <_>
+          9 5 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 12 9 -1.</_>
+        <_>
+          4 3 12 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 10 8 -1.</_>
+        <_>
+          6 13 10 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 14 8 -1.</_>
+        <_>
+          3 10 14 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 1 6 10 -1.</_>
+        <_>
+          14 1 3 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 5 12 -1.</_>
+        <_>
+          7 12 5 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 18 3 -1.</_>
+        <_>
+          7 1 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 17 2 -1.</_>
+        <_>
+          1 9 17 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 6 4 2 -1.</_>
+        <_>
+          16 7 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 17 2 2 -1.</_>
+        <_>
+          5 18 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 12 -1.</_>
+        <_>
+          14 2 3 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 4 12 -1.</_>
+        <_>
+          4 0 2 6 2.</_>
+        <_>
+          6 6 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 18 8 -1.</_>
+        <_>
+          8 11 6 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 2 -1.</_>
+        <_>
+          5 8 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 5 3 -1.</_>
+        <_>
+          15 12 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 10 9 -1.</_>
+        <_>
+          5 6 10 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 14 -1.</_>
+        <_>
+          9 11 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 5 4 12 -1.</_>
+        <_>
+          3 9 4 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 5 -1.</_>
+        <_>
+          8 5 4 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 10 8 -1.</_>
+        <_>
+          5 10 10 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 6 9 -1.</_>
+        <_>
+          8 3 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 1 8 -1.</_>
+        <_>
+          9 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 20 6 -1.</_>
+        <_>
+          0 9 20 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 17 -1.</_>
+        <_>
+          9 0 2 17 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 6 4 -1.</_>
+        <_>
+          11 0 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 6 4 -1.</_>
+        <_>
+          7 1 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 1 6 16 -1.</_>
+        <_>
+          14 1 2 16 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 18 8 -1.</_>
+        <_>
+          0 5 9 4 2.</_>
+        <_>
+          9 9 9 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 10 4 -1.</_>
+        <_>
+          13 15 5 2 2.</_>
+        <_>
+          8 17 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 4 8 -1.</_>
+        <_>
+          3 1 2 4 2.</_>
+        <_>
+          5 5 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 14 10 -1.</_>
+        <_>
+          10 6 7 5 2.</_>
+        <_>
+          3 11 7 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 6 16 -1.</_>
+        <_>
+          4 1 2 16 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 18 20 2 -1.</_>
+        <_>
+          0 19 20 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 3 -1.</_>
+        <_>
+          8 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 12 9 6 -1.</_>
+        <_>
+          0 14 9 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 3 4 -1.</_>
+        <_>
+          5 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 2 16 -1.</_>
+        <_>
+          9 11 2 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 13 8 -1.</_>
+        <_>
+          3 10 13 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 8 2 -1.</_>
+        <_>
+          12 3 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 4 12 -1.</_>
+        <_>
+          8 12 4 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 8 6 -1.</_>
+        <_>
+          15 3 4 3 2.</_>
+        <_>
+          11 6 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 19 -1.</_>
+        <_>
+          9 1 2 19 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 6 4 -1.</_>
+        <_>
+          11 0 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 9 3 -1.</_>
+        <_>
+          6 1 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 10 4 -1.</_>
+        <_>
+          13 15 5 2 2.</_>
+        <_>
+          8 17 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 6 10 -1.</_>
+        <_>
+          3 3 3 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 15 15 -1.</_>
+        <_>
+          3 9 15 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 8 6 -1.</_>
+        <_>
+          6 7 8 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 12 10 -1.</_>
+        <_>
+          10 4 6 5 2.</_>
+        <_>
+          4 9 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 4 4 -1.</_>
+        <_>
+          8 4 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 1 2 -1.</_>
+        <_>
+          15 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 2 2 -1.</_>
+        <_>
+          3 12 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 11 1 3 -1.</_>
+        <_>
+          16 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 15 6 4 -1.</_>
+        <_>
+          3 15 3 2 2.</_>
+        <_>
+          6 17 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 8 2 -1.</_>
+        <_>
+          6 8 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 1 3 -1.</_>
+        <_>
+          3 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 12 2 -1.</_>
+        <_>
+          6 1 12 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 6 2 -1.</_>
+        <_>
+          7 16 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 4 6 -1.</_>
+        <_>
+          0 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 12 2 -1.</_>
+        <_>
+          8 12 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 1 9 -1.</_>
+        <_>
+          6 6 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 17 3 2 -1.</_>
+        <_>
+          11 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 4 -1.</_>
+        <_>
+          9 6 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 17 3 2 -1.</_>
+        <_>
+          8 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 17 3 3 -1.</_>
+        <_>
+          11 17 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 3 2 -1.</_>
+        <_>
+          8 13 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 6 2 -1.</_>
+        <_>
+          11 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 14 4 -1.</_>
+        <_>
+          3 13 14 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 18 4 -1.</_>
+        <_>
+          10 10 9 2 2.</_>
+        <_>
+          1 12 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 3 3 -1.</_>
+        <_>
+          0 11 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 1 6 6 -1.</_>
+        <_>
+          11 1 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 6 -1.</_>
+        <_>
+          9 7 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 9 -1.</_>
+        <_>
+          1 3 18 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 10 2 6 -1.</_>
+        <_>
+          12 13 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 19 8 -1.</_>
+        <_>
+          0 9 19 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 9 -1.</_>
+        <_>
+          9 0 2 9 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 6 1 -1.</_>
+        <_>
+          7 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 6 1 -1.</_>
+        <_>
+          13 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 4 6 -1.</_>
+        <_>
+          5 13 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 6 1 -1.</_>
+        <_>
+          13 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 12 6 -1.</_>
+        <_>
+          4 6 12 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 12 2 6 -1.</_>
+        <_>
+          15 14 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 2 2 -1.</_>
+        <_>
+          10 3 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 3 1 -1.</_>
+        <_>
+          10 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 4 14 -1.</_>
+        <_>
+          3 1 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 4 4 -1.</_>
+        <_>
+          11 0 2 2 2.</_>
+        <_>
+          9 2 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 1 14 -1.</_>
+        <_>
+          7 12 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 0 1 4 -1.</_>
+        <_>
+          19 2 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 6 4 -1.</_>
+        <_>
+          8 5 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 18 3 2 -1.</_>
+        <_>
+          10 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 18 3 2 -1.</_>
+        <_>
+          9 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 6 -1.</_>
+        <_>
+          4 7 12 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 2 6 -1.</_>
+        <_>
+          3 14 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 2 12 -1.</_>
+        <_>
+          10 12 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 18 3 2 -1.</_>
+        <_>
+          8 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 6 2 -1.</_>
+        <_>
+          11 0 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 9 3 -1.</_>
+        <_>
+          5 12 9 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 6 2 -1.</_>
+        <_>
+          11 0 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 18 5 -1.</_>
+        <_>
+          7 1 6 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 4 4 -1.</_>
+        <_>
+          10 0 2 2 2.</_>
+        <_>
+          8 2 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 1 3 -1.</_>
+        <_>
+          3 13 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 5 3 -1.</_>
+        <_>
+          8 15 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 10 12 -1.</_>
+        <_>
+          5 4 5 6 2.</_>
+        <_>
+          10 10 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 9 12 -1.</_>
+        <_>
+          9 10 9 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 12 14 -1.</_>
+        <_>
+          2 2 6 7 2.</_>
+        <_>
+          8 9 6 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 12 2 -1.</_>
+        <_>
+          8 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 6 4 -1.</_>
+        <_>
+          7 6 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 11 8 -1.</_>
+        <_>
+          4 9 11 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 10 16 4 -1.</_>
+        <_>
+          3 12 16 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 16 2 -1.</_>
+        <_>
+          0 1 16 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 2 -1.</_>
+        <_>
+          9 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 6 10 -1.</_>
+        <_>
+          3 2 3 5 2.</_>
+        <_>
+          6 7 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 5 8 15 -1.</_>
+        <_>
+          10 10 8 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 8 6 -1.</_>
+        <_>
+          3 14 4 3 2.</_>
+        <_>
+          7 17 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 2 2 -1.</_>
+        <_>
+          14 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 7 6 -1.</_>
+        <_>
+          1 13 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 4 4 3 -1.</_>
+        <_>
+          15 4 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 9 14 6 -1.</_>
+        <_>
+          2 9 7 3 2.</_>
+        <_>
+          9 12 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 4 -1.</_>
+        <_>
+          5 9 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 8 8 -1.</_>
+        <_>
+          6 9 4 4 2.</_>
+        <_>
+          10 13 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 1 3 2 -1.</_>
+        <_>
+          14 2 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 4 2 -1.</_>
+        <_>
+          3 4 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 2 8 -1.</_>
+        <_>
+          11 14 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 5 3 -1.</_>
+        <_>
+          0 1 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 5 18 8 -1.</_>
+        <_>
+          11 5 9 4 2.</_>
+        <_>
+          2 9 9 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 1 6 -1.</_>
+        <_>
+          6 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 1 1 3 -1.</_>
+        <_>
+          19 2 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 6 -1.</_>
+        <_>
+          9 6 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 1 1 3 -1.</_>
+        <_>
+          19 2 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 2 3 -1.</_>
+        <_>
+          3 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 4 8 12 -1.</_>
+        <_>
+          12 4 4 6 2.</_>
+        <_>
+          8 10 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 6 3 -1.</_>
+        <_>
+          7 2 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 9 10 -1.</_>
+        <_>
+          6 6 9 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 6 12 -1.</_>
+        <_>
+          2 4 2 12 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 3 -1.</_>
+        <_>
+          15 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 5 3 -1.</_>
+        <_>
+          7 15 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 3 3 -1.</_>
+        <_>
+          15 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 14 8 3 -1.</_>
+        <_>
+          6 15 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 3 3 -1.</_>
+        <_>
+          15 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 13 3 3 -1.</_>
+        <_>
+          2 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 12 12 -1.</_>
+        <_>
+          10 7 6 6 2.</_>
+        <_>
+          4 13 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 6 -1.</_>
+        <_>
+          10 7 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 5 2 -1.</_>
+        <_>
+          8 10 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 3 4 -1.</_>
+        <_>
+          9 6 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 8 -1.</_>
+        <_>
+          9 10 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 3 6 -1.</_>
+        <_>
+          8 7 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 3 3 -1.</_>
+        <_>
+          12 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 6 1 -1.</_>
+        <_>
+          7 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 10 3 -1.</_>
+        <_>
+          5 7 10 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 6 9 -1.</_>
+        <_>
+          7 6 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 9 1 -1.</_>
+        <_>
+          9 7 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 16 8 -1.</_>
+        <_>
+          2 12 16 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 2 6 -1.</_>
+        <_>
+          14 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 5 6 15 -1.</_>
+        <_>
+          1 10 6 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 6 9 -1.</_>
+        <_>
+          10 3 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 7 14 -1.</_>
+        <_>
+          6 13 7 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 3 6 -1.</_>
+        <_>
+          13 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 15 4 -1.</_>
+        <_>
+          6 8 5 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 3 10 -1.</_>
+        <_>
+          11 7 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 4 6 -1.</_>
+        <_>
+          3 9 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 3 6 10 -1.</_>
+        <_>
+          15 3 2 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 8 10 -1.</_>
+        <_>
+          5 7 4 5 2.</_>
+        <_>
+          9 12 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 12 12 -1.</_>
+        <_>
+          10 4 6 6 2.</_>
+        <_>
+          4 10 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 6 9 -1.</_>
+        <_>
+          3 4 2 9 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 2 5 -1.</_>
+        <_>
+          11 3 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 2 5 -1.</_>
+        <_>
+          8 3 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 2 3 -1.</_>
+        <_>
+          10 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 6 2 -1.</_>
+        <_>
+          8 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 12 6 -1.</_>
+        <_>
+          4 14 12 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 5 9 -1.</_>
+        <_>
+          11 14 5 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 15 3 2 -1.</_>
+        <_>
+          6 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 5 -1.</_>
+        <_>
+          12 0 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 6 7 -1.</_>
+        <_>
+          8 5 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 1 9 -1.</_>
+        <_>
+          13 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 4 8 -1.</_>
+        <_>
+          3 2 2 4 2.</_>
+        <_>
+          5 6 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 12 4 6 -1.</_>
+        <_>
+          13 14 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 4 6 -1.</_>
+        <_>
+          3 14 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 3 4 -1.</_>
+        <_>
+          13 13 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 4 3 -1.</_>
+        <_>
+          4 5 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 11 8 -1.</_>
+        <_>
+          7 9 11 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 3 4 -1.</_>
+        <_>
+          8 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 1 6 1 -1.</_>
+        <_>
+          11 1 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 3 3 -1.</_>
+        <_>
+          5 6 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 20 6 -1.</_>
+        <_>
+          10 9 10 3 2.</_>
+        <_>
+          0 12 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 3 5 -1.</_>
+        <_>
+          9 6 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 1 3 -1.</_>
+        <_>
+          11 1 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 4 2 -1.</_>
+        <_>
+          4 3 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 6 4 3 -1.</_>
+        <_>
+          12 7 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 6 4 -1.</_>
+        <_>
+          7 0 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 8 -1.</_>
+        <_>
+          10 7 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 2 -1.</_>
+        <_>
+          10 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 14 4 -1.</_>
+        <_>
+          13 7 7 2 2.</_>
+        <_>
+          6 9 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 3 6 -1.</_>
+        <_>
+          0 7 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 3 4 -1.</_>
+        <_>
+          13 13 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 3 4 -1.</_>
+        <_>
+          4 13 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 12 8 -1.</_>
+        <_>
+          11 9 6 4 2.</_>
+        <_>
+          5 13 6 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 1 3 -1.</_>
+        <_>
+          9 13 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 15 2 4 -1.</_>
+        <_>
+          10 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 1 -1.</_>
+        <_>
+          9 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 6 6 -1.</_>
+        <_>
+          15 3 3 3 2.</_>
+        <_>
+          12 6 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 10 6 -1.</_>
+        <_>
+          0 6 10 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 3 8 14 -1.</_>
+        <_>
+          12 3 4 7 2.</_>
+        <_>
+          8 10 4 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 7 15 -1.</_>
+        <_>
+          4 9 7 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 6 8 -1.</_>
+        <_>
+          15 2 3 4 2.</_>
+        <_>
+          12 6 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 6 8 -1.</_>
+        <_>
+          2 2 3 4 2.</_>
+        <_>
+          5 6 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 13 18 7 -1.</_>
+        <_>
+          8 13 6 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 8 14 -1.</_>
+        <_>
+          4 3 4 7 2.</_>
+        <_>
+          8 10 4 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 6 -1.</_>
+        <_>
+          18 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 6 -1.</_>
+        <_>
+          18 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 2 6 -1.</_>
+        <_>
+          0 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 5 18 6 -1.</_>
+        <_>
+          1 7 18 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 6 7 -1.</_>
+        <_>
+          3 2 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 6 14 -1.</_>
+        <_>
+          7 10 6 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 13 10 -1.</_>
+        <_>
+          3 12 13 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 15 2 2 -1.</_>
+        <_>
+          11 16 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 16 4 -1.</_>
+        <_>
+          2 11 8 2 2.</_>
+        <_>
+          10 13 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 6 4 -1.</_>
+        <_>
+          16 7 3 2 2.</_>
+        <_>
+          13 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 3 9 -1.</_>
+        <_>
+          6 13 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 1 6 -1.</_>
+        <_>
+          14 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 4 1 -1.</_>
+        <_>
+          7 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 8 15 5 -1.</_>
+        <_>
+          8 8 5 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 6 5 4 -1.</_>
+        <_>
+          1 8 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 17 6 -1.</_>
+        <_>
+          3 3 17 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 8 2 -1.</_>
+        <_>
+          10 7 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 2 -1.</_>
+        <_>
+          10 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 2 -1.</_>
+        <_>
+          9 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 4 2 -1.</_>
+        <_>
+          8 10 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 4 3 -1.</_>
+        <_>
+          8 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 4 -1.</_>
+        <_>
+          9 5 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 3 -1.</_>
+        <_>
+          8 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 12 6 -1.</_>
+        <_>
+          10 7 6 3 2.</_>
+        <_>
+          4 10 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          9 8 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 3 8 -1.</_>
+        <_>
+          8 4 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 3 6 -1.</_>
+        <_>
+          11 0 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 4 8 -1.</_>
+        <_>
+          8 3 2 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 6 13 -1.</_>
+        <_>
+          14 3 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 3 6 -1.</_>
+        <_>
+          8 16 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 6 13 -1.</_>
+        <_>
+          14 3 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 10 4 -1.</_>
+        <_>
+          0 7 5 2 2.</_>
+        <_>
+          5 9 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 6 13 -1.</_>
+        <_>
+          14 3 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 6 13 -1.</_>
+        <_>
+          3 3 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 1 4 1 -1.</_>
+        <_>
+          9 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 2 1 -1.</_>
+        <_>
+          9 0 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 4 4 -1.</_>
+        <_>
+          12 16 2 2 2.</_>
+        <_>
+          10 18 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 3 -1.</_>
+        <_>
+          10 6 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 2 -1.</_>
+        <_>
+          8 5 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 5 -1.</_>
+        <_>
+          9 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 8 6 -1.</_>
+        <_>
+          6 6 8 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 12 -1.</_>
+        <_>
+          9 11 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 6 6 8 -1.</_>
+        <_>
+          4 10 6 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 8 5 -1.</_>
+        <_>
+          12 2 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 18 3 -1.</_>
+        <_>
+          0 9 18 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 8 -1.</_>
+        <_>
+          8 16 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 8 5 -1.</_>
+        <_>
+          4 2 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 3 4 -1.</_>
+        <_>
+          13 13 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 6 1 -1.</_>
+        <_>
+          7 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 3 1 -1.</_>
+        <_>
+          12 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 5 3 -1.</_>
+        <_>
+          7 14 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 7 6 -1.</_>
+        <_>
+          11 14 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 7 6 -1.</_>
+        <_>
+          2 14 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 14 2 6 -1.</_>
+        <_>
+          12 16 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 3 3 -1.</_>
+        <_>
+          8 15 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 5 -1.</_>
+        <_>
+          12 0 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 4 9 -1.</_>
+        <_>
+          8 1 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 6 1 -1.</_>
+        <_>
+          12 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 3 4 -1.</_>
+        <_>
+          8 10 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          8 13 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 18 4 2 -1.</_>
+        <_>
+          5 19 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 18 6 -1.</_>
+        <_>
+          2 3 18 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 2 -1.</_>
+        <_>
+          7 0 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 8 6 2 -1.</_>
+        <_>
+          16 8 3 1 2.</_>
+        <_>
+          13 9 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 3 6 -1.</_>
+        <_>
+          6 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 20 4 -1.</_>
+        <_>
+          10 13 10 2 2.</_>
+        <_>
+          0 15 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 5 -1.</_>
+        <_>
+          9 7 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 2 2 -1.</_>
+        <_>
+          11 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 6 2 -1.</_>
+        <_>
+          1 8 3 1 2.</_>
+        <_>
+          4 9 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 20 2 -1.</_>
+        <_>
+          10 2 10 1 2.</_>
+        <_>
+          0 3 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 5 3 -1.</_>
+        <_>
+          7 15 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 6 -1.</_>
+        <_>
+          10 13 3 3 2.</_>
+        <_>
+          7 16 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 3 -1.</_>
+        <_>
+          9 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 11 1 6 -1.</_>
+        <_>
+          16 13 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 1 6 -1.</_>
+        <_>
+          3 13 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 14 12 -1.</_>
+        <_>
+          11 4 7 6 2.</_>
+        <_>
+          4 10 7 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 3 3 -1.</_>
+        <_>
+          13 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 8 3 -1.</_>
+        <_>
+          6 7 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 3 3 -1.</_>
+        <_>
+          13 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 4 10 -1.</_>
+        <_>
+          3 1 2 5 2.</_>
+        <_>
+          5 6 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 2 -1.</_>
+        <_>
+          5 7 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          9 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 12 2 3 -1.</_>
+        <_>
+          15 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 3 4 -1.</_>
+        <_>
+          8 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 1 12 -1.</_>
+        <_>
+          13 10 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 12 -1.</_>
+        <_>
+          4 5 6 6 2.</_>
+        <_>
+          10 11 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 7 3 -1.</_>
+        <_>
+          7 15 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 2 3 -1.</_>
+        <_>
+          3 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 14 2 -1.</_>
+        <_>
+          10 2 7 1 2.</_>
+        <_>
+          3 3 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 3 10 -1.</_>
+        <_>
+          1 1 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 6 5 -1.</_>
+        <_>
+          11 0 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 6 2 -1.</_>
+        <_>
+          8 7 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 10 -1.</_>
+        <_>
+          7 6 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 18 3 -1.</_>
+        <_>
+          7 1 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 6 -1.</_>
+        <_>
+          16 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 7 6 -1.</_>
+        <_>
+          6 6 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 12 2 -1.</_>
+        <_>
+          8 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 17 10 -1.</_>
+        <_>
+          0 9 17 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 15 16 -1.</_>
+        <_>
+          3 12 15 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 6 4 -1.</_>
+        <_>
+          7 17 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 2 4 9 -1.</_>
+        <_>
+          15 2 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 3 2 -1.</_>
+        <_>
+          2 4 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 6 7 9 -1.</_>
+        <_>
+          13 9 7 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 3 -1.</_>
+        <_>
+          8 12 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 20 6 -1.</_>
+        <_>
+          10 2 10 3 2.</_>
+        <_>
+          0 5 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 6 10 -1.</_>
+        <_>
+          3 2 3 5 2.</_>
+        <_>
+          6 7 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 10 3 4 -1.</_>
+        <_>
+          13 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 10 3 4 -1.</_>
+        <_>
+          4 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 3 -1.</_>
+        <_>
+          9 5 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 8 -1.</_>
+        <_>
+          7 10 6 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 11 20 6 -1.</_>
+        <_>
+          0 14 20 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 13 4 6 -1.</_>
+        <_>
+          4 13 2 3 2.</_>
+        <_>
+          6 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 12 -1.</_>
+        <_>
+          10 0 4 6 2.</_>
+        <_>
+          6 6 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 15 2 -1.</_>
+        <_>
+          2 1 15 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 3 -1.</_>
+        <_>
+          9 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 1 2 -1.</_>
+        <_>
+          3 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 3 1 -1.</_>
+        <_>
+          8 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 7 3 6 -1.</_>
+        <_>
+          17 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 3 2 -1.</_>
+        <_>
+          8 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 5 3 -1.</_>
+        <_>
+          11 5 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 5 3 -1.</_>
+        <_>
+          4 5 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 3 1 2 -1.</_>
+        <_>
+          19 4 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 4 3 -1.</_>
+        <_>
+          5 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 7 3 6 -1.</_>
+        <_>
+          17 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 3 6 -1.</_>
+        <_>
+          0 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 9 -1.</_>
+        <_>
+          14 5 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 5 6 -1.</_>
+        <_>
+          0 6 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 5 6 2 -1.</_>
+        <_>
+          12 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 6 2 -1.</_>
+        <_>
+          6 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 4 6 -1.</_>
+        <_>
+          8 3 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 6 -1.</_>
+        <_>
+          0 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 8 3 -1.</_>
+        <_>
+          6 7 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 5 9 -1.</_>
+        <_>
+          0 4 5 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 15 -1.</_>
+        <_>
+          16 0 2 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 3 2 -1.</_>
+        <_>
+          1 11 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 4 1 10 -1.</_>
+        <_>
+          14 9 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 4 12 -1.</_>
+        <_>
+          2 1 2 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 4 2 -1.</_>
+        <_>
+          11 11 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 4 2 -1.</_>
+        <_>
+          7 11 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 8 15 5 -1.</_>
+        <_>
+          8 8 5 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 6 10 -1.</_>
+        <_>
+          3 0 3 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 3 2 -1.</_>
+        <_>
+          12 4 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 3 8 -1.</_>
+        <_>
+          8 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 5 3 -1.</_>
+        <_>
+          8 15 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 4 3 -1.</_>
+        <_>
+          7 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 3 2 -1.</_>
+        <_>
+          12 4 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 15 14 4 -1.</_>
+        <_>
+          3 15 7 2 2.</_>
+        <_>
+          10 17 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 16 4 -1.</_>
+        <_>
+          10 2 8 2 2.</_>
+        <_>
+          2 4 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 6 12 -1.</_>
+        <_>
+          3 8 3 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 2 -1.</_>
+        <_>
+          5 7 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 5 -1.</_>
+        <_>
+          10 7 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 6 4 -1.</_>
+        <_>
+          16 7 3 2 2.</_>
+        <_>
+          13 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 8 2 -1.</_>
+        <_>
+          0 14 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 6 4 -1.</_>
+        <_>
+          16 7 3 2 2.</_>
+        <_>
+          13 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 6 4 -1.</_>
+        <_>
+          1 7 3 2 2.</_>
+        <_>
+          4 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 6 1 12 -1.</_>
+        <_>
+          12 12 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 6 -1.</_>
+        <_>
+          10 5 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 2 3 -1.</_>
+        <_>
+          14 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 3 -1.</_>
+        <_>
+          4 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 3 -1.</_>
+        <_>
+          8 13 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 2 4 -1.</_>
+        <_>
+          5 2 1 2 2.</_>
+        <_>
+          6 4 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 11 3 -1.</_>
+        <_>
+          5 6 11 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 4 12 -1.</_>
+        <_>
+          7 12 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 13 8 5 -1.</_>
+        <_>
+          12 13 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 1 12 -1.</_>
+        <_>
+          7 12 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 6 3 -1.</_>
+        <_>
+          4 2 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 10 -1.</_>
+        <_>
+          12 5 3 5 2.</_>
+        <_>
+          9 10 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 8 12 -1.</_>
+        <_>
+          5 5 4 6 2.</_>
+        <_>
+          9 11 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 20 6 -1.</_>
+        <_>
+          0 9 20 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 2 2 -1.</_>
+        <_>
+          4 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 18 12 2 -1.</_>
+        <_>
+          8 18 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 4 16 -1.</_>
+        <_>
+          7 12 4 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 7 8 -1.</_>
+        <_>
+          7 10 7 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 3 1 -1.</_>
+        <_>
+          7 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 15 2 4 -1.</_>
+        <_>
+          11 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 5 4 8 -1.</_>
+        <_>
+          3 9 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 12 -1.</_>
+        <_>
+          7 7 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 6 6 2 -1.</_>
+        <_>
+          6 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 4 4 6 -1.</_>
+        <_>
+          16 6 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 3 5 2 -1.</_>
+        <_>
+          3 4 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 4 2 -1.</_>
+        <_>
+          2 17 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 6 -1.</_>
+        <_>
+          10 13 3 3 2.</_>
+        <_>
+          7 16 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 3 4 -1.</_>
+        <_>
+          8 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 4 6 -1.</_>
+        <_>
+          0 6 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 12 3 -1.</_>
+        <_>
+          9 6 4 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 14 -1.</_>
+        <_>
+          9 6 2 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          10 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 2 4 -1.</_>
+        <_>
+          6 14 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 7 6 -1.</_>
+        <_>
+          10 14 7 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 15 2 -1.</_>
+        <_>
+          1 1 15 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 6 -1.</_>
+        <_>
+          14 0 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 3 1 -1.</_>
+        <_>
+          6 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 6 -1.</_>
+        <_>
+          14 0 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 20 10 -1.</_>
+        <_>
+          0 8 20 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 6 -1.</_>
+        <_>
+          14 0 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 6 6 -1.</_>
+        <_>
+          3 0 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 15 1 2 -1.</_>
+        <_>
+          19 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 4 8 -1.</_>
+        <_>
+          2 2 2 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 18 4 -1.</_>
+        <_>
+          11 1 9 2 2.</_>
+        <_>
+          2 3 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 1 2 -1.</_>
+        <_>
+          8 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 10 6 -1.</_>
+        <_>
+          10 2 5 3 2.</_>
+        <_>
+          5 5 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 4 -1.</_>
+        <_>
+          10 7 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          10 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 8 -1.</_>
+        <_>
+          8 5 4 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 15 4 3 -1.</_>
+        <_>
+          15 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 18 3 1 -1.</_>
+        <_>
+          9 18 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 4 3 -1.</_>
+        <_>
+          9 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 4 3 -1.</_>
+        <_>
+          7 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 15 1 2 -1.</_>
+        <_>
+          19 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 8 4 -1.</_>
+        <_>
+          0 17 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 6 4 -1.</_>
+        <_>
+          11 3 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 14 6 -1.</_>
+        <_>
+          3 16 14 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 6 6 -1.</_>
+        <_>
+          6 6 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 10 6 -1.</_>
+        <_>
+          5 14 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 10 3 4 -1.</_>
+        <_>
+          4 10 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 9 2 2 -1.</_>
+        <_>
+          13 9 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 6 4 -1.</_>
+        <_>
+          7 3 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          10 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 2 3 -1.</_>
+        <_>
+          2 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 3 12 -1.</_>
+        <_>
+          9 12 3 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 4 6 -1.</_>
+        <_>
+          3 14 2 3 2.</_>
+        <_>
+          5 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 15 2 2 -1.</_>
+        <_>
+          16 16 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 15 2 2 -1.</_>
+        <_>
+          2 16 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 3 -1.</_>
+        <_>
+          8 13 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 20 1 -1.</_>
+        <_>
+          10 7 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 8 3 -1.</_>
+        <_>
+          7 6 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 8 2 -1.</_>
+        <_>
+          9 7 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 5 -1.</_>
+        <_>
+          10 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 5 -1.</_>
+        <_>
+          9 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 1 3 5 -1.</_>
+        <_>
+          12 1 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 2 3 6 -1.</_>
+        <_>
+          7 2 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 14 6 5 -1.</_>
+        <_>
+          14 14 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 2 -1.</_>
+        <_>
+          9 9 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 1 3 -1.</_>
+        <_>
+          10 8 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 2 2 -1.</_>
+        <_>
+          6 6 1 1 2.</_>
+        <_>
+          7 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 18 4 -1.</_>
+        <_>
+          11 11 9 2 2.</_>
+        <_>
+          2 13 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 2 2 -1.</_>
+        <_>
+          6 6 1 1 2.</_>
+        <_>
+          7 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 20 2 -1.</_>
+        <_>
+          0 16 20 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 2 3 -1.</_>
+        <_>
+          4 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 2 3 -1.</_>
+        <_>
+          8 8 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 10 2 3 -1.</_>
+        <_>
+          9 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 10 4 -1.</_>
+        <_>
+          5 6 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 6 4 -1.</_>
+        <_>
+          12 7 3 2 2.</_>
+        <_>
+          9 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 3 6 -1.</_>
+        <_>
+          4 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 15 4 4 -1.</_>
+        <_>
+          13 15 2 2 2.</_>
+        <_>
+          11 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 4 2 -1.</_>
+        <_>
+          7 9 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 1 4 3 -1.</_>
+        <_>
+          13 1 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 15 4 4 -1.</_>
+        <_>
+          5 15 2 2 2.</_>
+        <_>
+          7 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 4 7 -1.</_>
+        <_>
+          9 5 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 8 3 -1.</_>
+        <_>
+          9 6 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 5 3 -1.</_>
+        <_>
+          7 16 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 4 3 -1.</_>
+        <_>
+          11 10 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 8 10 -1.</_>
+        <_>
+          6 14 8 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 6 2 -1.</_>
+        <_>
+          10 11 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 6 2 -1.</_>
+        <_>
+          7 11 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 8 1 -1.</_>
+        <_>
+          11 3 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 3 2 -1.</_>
+        <_>
+          7 3 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 5 6 5 -1.</_>
+        <_>
+          14 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 2 12 -1.</_>
+        <_>
+          7 11 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 3 -1.</_>
+        <_>
+          8 12 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 1 2 3 -1.</_>
+        <_>
+          5 1 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 3 2 6 -1.</_>
+        <_>
+          18 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 2 6 -1.</_>
+        <_>
+          0 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 3 -1.</_>
+        <_>
+          9 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 4 3 -1.</_>
+        <_>
+          7 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 0 2 6 -1.</_>
+        <_>
+          18 2 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 2 6 -1.</_>
+        <_>
+          0 2 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 6 3 -1.</_>
+        <_>
+          8 15 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 2 4 -1.</_>
+        <_>
+          8 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 5 4 6 -1.</_>
+        <_>
+          8 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 2 2 -1.</_>
+        <_>
+          7 4 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 14 4 -1.</_>
+        <_>
+          10 14 7 2 2.</_>
+        <_>
+          3 16 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 15 6 2 -1.</_>
+        <_>
+          6 15 3 1 2.</_>
+        <_>
+          9 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 15 6 2 -1.</_>
+        <_>
+          14 16 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 12 8 -1.</_>
+        <_>
+          2 16 12 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 7 2 -1.</_>
+        <_>
+          7 8 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 18 2 -1.</_>
+        <_>
+          0 3 18 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 5 -1.</_>
+        <_>
+          9 6 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 3 8 -1.</_>
+        <_>
+          8 5 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 3 4 -1.</_>
+        <_>
+          10 6 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 13 3 2 -1.</_>
+        <_>
+          4 14 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 6 3 -1.</_>
+        <_>
+          11 4 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 6 3 -1.</_>
+        <_>
+          7 4 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 11 5 2 -1.</_>
+        <_>
+          14 12 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 6 9 -1.</_>
+        <_>
+          3 2 2 9 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 6 13 -1.</_>
+        <_>
+          14 6 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 14 8 -1.</_>
+        <_>
+          3 6 7 4 2.</_>
+        <_>
+          10 10 7 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 11 -1.</_>
+        <_>
+          16 0 2 11 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 12 12 -1.</_>
+        <_>
+          3 4 6 6 2.</_>
+        <_>
+          9 10 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 5 3 -1.</_>
+        <_>
+          11 5 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 4 2 -1.</_>
+        <_>
+          4 12 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 2 2 -1.</_>
+        <_>
+          10 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 2 2 -1.</_>
+        <_>
+          9 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 2 -1.</_>
+        <_>
+          10 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 3 3 -1.</_>
+        <_>
+          5 7 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 3 3 -1.</_>
+        <_>
+          11 0 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 6 2 -1.</_>
+        <_>
+          5 6 3 1 2.</_>
+        <_>
+          8 7 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 16 4 3 -1.</_>
+        <_>
+          12 17 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 3 2 -1.</_>
+        <_>
+          3 13 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 3 2 -1.</_>
+        <_>
+          9 13 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 16 4 -1.</_>
+        <_>
+          1 11 8 2 2.</_>
+        <_>
+          9 13 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 5 3 -1.</_>
+        <_>
+          4 5 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 16 4 3 -1.</_>
+        <_>
+          12 17 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 2 2 -1.</_>
+        <_>
+          9 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 4 2 -1.</_>
+        <_>
+          8 10 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 4 3 -1.</_>
+        <_>
+          8 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 6 3 -1.</_>
+        <_>
+          2 13 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 14 3 2 -1.</_>
+        <_>
+          16 15 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 18 18 2 -1.</_>
+        <_>
+          7 18 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 14 3 2 -1.</_>
+        <_>
+          16 15 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 3 2 -1.</_>
+        <_>
+          1 15 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 6 3 -1.</_>
+        <_>
+          7 15 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 14 8 3 -1.</_>
+        <_>
+          5 15 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 4 14 -1.</_>
+        <_>
+          10 6 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 4 14 -1.</_>
+        <_>
+          8 6 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 3 -1.</_>
+        <_>
+          13 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 16 6 1 -1.</_>
+        <_>
+          9 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 3 3 -1.</_>
+        <_>
+          9 13 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 3 3 -1.</_>
+        <_>
+          8 0 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 16 18 -1.</_>
+        <_>
+          4 9 16 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 16 14 -1.</_>
+        <_>
+          1 8 16 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 9 15 4 -1.</_>
+        <_>
+          8 9 5 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 7 3 -1.</_>
+        <_>
+          6 13 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 15 2 3 -1.</_>
+        <_>
+          14 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 16 14 -1.</_>
+        <_>
+          2 3 8 7 2.</_>
+        <_>
+          10 10 8 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 2 4 18 -1.</_>
+        <_>
+          18 2 2 9 2.</_>
+        <_>
+          16 11 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 15 2 3 -1.</_>
+        <_>
+          4 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 2 4 18 -1.</_>
+        <_>
+          18 2 2 9 2.</_>
+        <_>
+          16 11 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 8 3 -1.</_>
+        <_>
+          1 2 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 3 -1.</_>
+        <_>
+          8 12 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 5 9 -1.</_>
+        <_>
+          5 14 5 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 11 -1.</_>
+        <_>
+          16 0 2 11 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 1 -1.</_>
+        <_>
+          9 0 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 7 -1.</_>
+        <_>
+          17 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 3 3 7 -1.</_>
+        <_>
+          2 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 6 12 -1.</_>
+        <_>
+          7 12 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 4 11 -1.</_>
+        <_>
+          2 0 2 11 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 20 -1.</_>
+        <_>
+          14 0 3 20 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 1 2 -1.</_>
+        <_>
+          0 4 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 10 8 -1.</_>
+        <_>
+          10 5 5 4 2.</_>
+        <_>
+          5 9 5 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 12 4 -1.</_>
+        <_>
+          4 7 6 2 2.</_>
+        <_>
+          10 9 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 6 4 -1.</_>
+        <_>
+          5 1 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 6 4 -1.</_>
+        <_>
+          12 7 3 2 2.</_>
+        <_>
+          9 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 2 6 -1.</_>
+        <_>
+          5 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 6 4 -1.</_>
+        <_>
+          12 16 3 2 2.</_>
+        <_>
+          9 18 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 12 -1.</_>
+        <_>
+          9 10 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 18 -1.</_>
+        <_>
+          9 1 2 18 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 12 2 -1.</_>
+        <_>
+          8 12 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 6 2 -1.</_>
+        <_>
+          8 9 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 3 6 -1.</_>
+        <_>
+          9 0 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 18 3 2 -1.</_>
+        <_>
+          11 19 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 17 4 -1.</_>
+        <_>
+          1 3 17 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 8 4 12 -1.</_>
+        <_>
+          11 8 2 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 2 17 -1.</_>
+        <_>
+          12 3 1 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 6 1 -1.</_>
+        <_>
+          6 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 3 2 3 -1.</_>
+        <_>
+          18 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 4 3 4 -1.</_>
+        <_>
+          8 6 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 10 -1.</_>
+        <_>
+          4 10 12 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 18 4 2 -1.</_>
+        <_>
+          7 18 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 2 3 6 -1.</_>
+        <_>
+          17 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 6 -1.</_>
+        <_>
+          9 7 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 2 3 6 -1.</_>
+        <_>
+          17 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 3 4 -1.</_>
+        <_>
+          9 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 12 6 3 -1.</_>
+        <_>
+          0 13 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 2 3 -1.</_>
+        <_>
+          3 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 12 7 -1.</_>
+        <_>
+          9 6 4 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 6 -1.</_>
+        <_>
+          0 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 1 3 -1.</_>
+        <_>
+          14 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 3 14 -1.</_>
+        <_>
+          3 0 1 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 14 5 6 -1.</_>
+        <_>
+          12 16 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 5 6 -1.</_>
+        <_>
+          4 16 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 2 2 -1.</_>
+        <_>
+          12 10 1 1 2.</_>
+        <_>
+          11 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 3 14 -1.</_>
+        <_>
+          6 0 1 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 15 2 3 -1.</_>
+        <_>
+          10 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 2 3 -1.</_>
+        <_>
+          0 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 12 6 -1.</_>
+        <_>
+          5 14 12 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 3 9 -1.</_>
+        <_>
+          6 14 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 2 2 -1.</_>
+        <_>
+          12 10 1 1 2.</_>
+        <_>
+          11 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 1 3 -1.</_>
+        <_>
+          5 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 13 3 -1.</_>
+        <_>
+          4 10 13 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 15 6 -1.</_>
+        <_>
+          6 7 5 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 6 -1.</_>
+        <_>
+          8 5 4 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 4 3 -1.</_>
+        <_>
+          8 11 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 14 1 3 -1.</_>
+        <_>
+          15 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 5 3 -1.</_>
+        <_>
+          1 12 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 7 12 -1.</_>
+        <_>
+          7 7 7 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 6 10 -1.</_>
+        <_>
+          0 1 3 5 2.</_>
+        <_>
+          3 6 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 1 4 3 -1.</_>
+        <_>
+          16 2 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 3 -1.</_>
+        <_>
+          5 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 3 5 -1.</_>
+        <_>
+          13 2 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 4 6 -1.</_>
+        <_>
+          0 5 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          8 13 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 18 3 1 -1.</_>
+        <_>
+          9 18 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 2 2 -1.</_>
+        <_>
+          12 10 1 1 2.</_>
+        <_>
+          11 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 10 2 2 -1.</_>
+        <_>
+          7 10 1 1 2.</_>
+        <_>
+          8 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 4 4 -1.</_>
+        <_>
+          11 13 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 3 8 -1.</_>
+        <_>
+          9 12 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 6 3 -1.</_>
+        <_>
+          13 1 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 3 4 -1.</_>
+        <_>
+          9 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 10 -1.</_>
+        <_>
+          10 7 5 5 2.</_>
+        <_>
+          5 12 5 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 18 8 2 -1.</_>
+        <_>
+          3 18 4 1 2.</_>
+        <_>
+          7 19 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 2 6 8 -1.</_>
+        <_>
+          12 2 2 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 6 8 -1.</_>
+        <_>
+          6 2 2 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 7 -1.</_>
+        <_>
+          12 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 2 1 -1.</_>
+        <_>
+          8 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 14 1 3 -1.</_>
+        <_>
+          15 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 2 2 -1.</_>
+        <_>
+          7 15 1 1 2.</_>
+        <_>
+          8 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 14 1 3 -1.</_>
+        <_>
+          15 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 7 -1.</_>
+        <_>
+          7 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 7 -1.</_>
+        <_>
+          18 1 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 8 20 -1.</_>
+        <_>
+          2 10 8 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 15 6 -1.</_>
+        <_>
+          3 2 15 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 12 2 -1.</_>
+        <_>
+          4 4 12 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 5 -1.</_>
+        <_>
+          16 0 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 3 4 -1.</_>
+        <_>
+          8 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 5 -1.</_>
+        <_>
+          16 0 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 6 13 -1.</_>
+        <_>
+          3 7 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 5 -1.</_>
+        <_>
+          16 0 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 4 5 -1.</_>
+        <_>
+          2 0 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 3 6 -1.</_>
+        <_>
+          14 14 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 3 6 -1.</_>
+        <_>
+          3 14 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 1 4 3 -1.</_>
+        <_>
+          16 2 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 2 10 -1.</_>
+        <_>
+          8 7 1 5 2.</_>
+        <_>
+          9 12 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 4 4 -1.</_>
+        <_>
+          11 13 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 4 3 -1.</_>
+        <_>
+          0 2 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 1 3 -1.</_>
+        <_>
+          13 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 3 5 -1.</_>
+        <_>
+          8 15 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 5 -1.</_>
+        <_>
+          10 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 5 -1.</_>
+        <_>
+          9 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 4 14 -1.</_>
+        <_>
+          10 6 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 5 6 -1.</_>
+        <_>
+          0 7 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 4 -1.</_>
+        <_>
+          9 5 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 18 10 -1.</_>
+        <_>
+          6 0 6 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 4 14 -1.</_>
+        <_>
+          10 6 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 4 14 -1.</_>
+        <_>
+          8 6 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 1 3 -1.</_>
+        <_>
+          13 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 2 3 -1.</_>
+        <_>
+          6 1 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 18 -1.</_>
+        <_>
+          19 1 1 9 2.</_>
+        <_>
+          18 10 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 4 3 -1.</_>
+        <_>
+          2 2 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 18 -1.</_>
+        <_>
+          19 1 1 9 2.</_>
+        <_>
+          18 10 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 4 6 -1.</_>
+        <_>
+          1 14 2 3 2.</_>
+        <_>
+          3 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 7 6 -1.</_>
+        <_>
+          10 13 7 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 6 10 -1.</_>
+        <_>
+          0 10 3 5 2.</_>
+        <_>
+          3 15 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 4 -1.</_>
+        <_>
+          12 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 5 6 -1.</_>
+        <_>
+          5 13 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 1 8 -1.</_>
+        <_>
+          14 10 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 18 6 -1.</_>
+        <_>
+          1 7 9 3 2.</_>
+        <_>
+          10 10 9 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 2 -1.</_>
+        <_>
+          9 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 4 5 -1.</_>
+        <_>
+          7 9 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 3 -1.</_>
+        <_>
+          9 6 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 4 -1.</_>
+        <_>
+          7 0 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 2 4 -1.</_>
+        <_>
+          7 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 19 9 -1.</_>
+        <_>
+          1 3 19 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 3 6 -1.</_>
+        <_>
+          3 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 4 4 -1.</_>
+        <_>
+          15 7 2 2 2.</_>
+        <_>
+          13 9 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 4 4 -1.</_>
+        <_>
+          3 7 2 2 2.</_>
+        <_>
+          5 9 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 10 8 -1.</_>
+        <_>
+          9 10 10 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 8 14 12 -1.</_>
+        <_>
+          3 14 14 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 10 12 -1.</_>
+        <_>
+          11 5 5 6 2.</_>
+        <_>
+          6 11 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 5 -1.</_>
+        <_>
+          9 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 4 -1.</_>
+        <_>
+          9 6 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 5 -1.</_>
+        <_>
+          9 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 6 5 -1.</_>
+        <_>
+          8 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 6 1 -1.</_>
+        <_>
+          13 2 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 6 1 -1.</_>
+        <_>
+          5 2 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 3 -1.</_>
+        <_>
+          13 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 1 4 -1.</_>
+        <_>
+          0 12 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 3 -1.</_>
+        <_>
+          13 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 18 3 2 -1.</_>
+        <_>
+          9 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 15 9 2 -1.</_>
+        <_>
+          6 16 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 4 -1.</_>
+        <_>
+          18 6 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 3 -1.</_>
+        <_>
+          5 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 16 3 2 -1.</_>
+        <_>
+          15 17 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 3 9 -1.</_>
+        <_>
+          0 3 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          9 8 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          8 8 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 6 -1.</_>
+        <_>
+          9 5 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 3 4 -1.</_>
+        <_>
+          9 6 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 8 12 -1.</_>
+        <_>
+          11 6 4 6 2.</_>
+        <_>
+          7 12 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 8 12 -1.</_>
+        <_>
+          5 6 4 6 2.</_>
+        <_>
+          9 12 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 3 2 -1.</_>
+        <_>
+          2 17 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 6 6 -1.</_>
+        <_>
+          2 14 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 3 -1.</_>
+        <_>
+          7 14 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 14 6 3 -1.</_>
+        <_>
+          6 15 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 15 5 3 -1.</_>
+        <_>
+          14 16 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 15 5 3 -1.</_>
+        <_>
+          14 16 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 6 2 -1.</_>
+        <_>
+          7 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 15 5 3 -1.</_>
+        <_>
+          1 16 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 6 -1.</_>
+        <_>
+          10 13 2 3 2.</_>
+        <_>
+          8 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 3 3 -1.</_>
+        <_>
+          8 8 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 5 4 -1.</_>
+        <_>
+          12 2 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 20 2 -1.</_>
+        <_>
+          0 2 10 1 2.</_>
+        <_>
+          10 3 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 4 -1.</_>
+        <_>
+          7 0 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 6 1 -1.</_>
+        <_>
+          6 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 18 13 2 -1.</_>
+        <_>
+          4 19 13 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 10 3 6 -1.</_>
+        <_>
+          2 12 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 6 8 -1.</_>
+        <_>
+          17 12 3 4 2.</_>
+        <_>
+          14 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 13 10 6 -1.</_>
+        <_>
+          4 13 5 3 2.</_>
+        <_>
+          9 16 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 1 2 -1.</_>
+        <_>
+          14 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 3 -1.</_>
+        <_>
+          8 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 2 2 -1.</_>
+        <_>
+          14 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 2 -1.</_>
+        <_>
+          4 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 9 2 -1.</_>
+        <_>
+          8 13 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 3 6 -1.</_>
+        <_>
+          11 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 9 12 -1.</_>
+        <_>
+          5 12 9 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 3 6 -1.</_>
+        <_>
+          11 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 3 6 -1.</_>
+        <_>
+          6 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 11 3 -1.</_>
+        <_>
+          5 5 11 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 5 10 -1.</_>
+        <_>
+          7 6 5 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 18 2 -1.</_>
+        <_>
+          2 9 18 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 17 5 3 -1.</_>
+        <_>
+          7 18 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 12 1 -1.</_>
+        <_>
+          9 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 6 6 -1.</_>
+        <_>
+          0 14 3 3 2.</_>
+        <_>
+          3 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 12 1 -1.</_>
+        <_>
+          9 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 9 12 1 -1.</_>
+        <_>
+          7 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 10 6 7 -1.</_>
+        <_>
+          14 10 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 16 2 -1.</_>
+        <_>
+          1 1 16 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 9 10 9 -1.</_>
+        <_>
+          10 12 10 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 10 2 -1.</_>
+        <_>
+          5 1 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 3 2 3 -1.</_>
+        <_>
+          17 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 3 2 3 -1.</_>
+        <_>
+          1 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 6 -1.</_>
+        <_>
+          10 7 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 4 3 -1.</_>
+        <_>
+          8 5 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 6 -1.</_>
+        <_>
+          9 5 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 12 12 -1.</_>
+        <_>
+          3 4 6 6 2.</_>
+        <_>
+          9 10 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 2 6 15 -1.</_>
+        <_>
+          11 2 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 6 17 -1.</_>
+        <_>
+          4 2 2 17 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 10 6 7 -1.</_>
+        <_>
+          14 10 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 6 7 -1.</_>
+        <_>
+          3 10 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 2 6 15 -1.</_>
+        <_>
+          11 2 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 6 15 -1.</_>
+        <_>
+          7 2 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 9 3 6 -1.</_>
+        <_>
+          17 11 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 6 6 -1.</_>
+        <_>
+          8 7 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 18 6 -1.</_>
+        <_>
+          10 10 9 3 2.</_>
+        <_>
+          1 13 9 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 10 9 -1.</_>
+        <_>
+          0 12 10 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 3 4 -1.</_>
+        <_>
+          5 14 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 3 16 12 -1.</_>
+        <_>
+          3 9 16 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 12 12 -1.</_>
+        <_>
+          1 1 6 6 2.</_>
+        <_>
+          7 7 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 4 2 4 -1.</_>
+        <_>
+          11 4 1 2 2.</_>
+        <_>
+          10 6 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 10 2 -1.</_>
+        <_>
+          0 9 5 1 2.</_>
+        <_>
+          5 10 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 3 3 -1.</_>
+        <_>
+          9 12 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 9 2 -1.</_>
+        <_>
+          3 13 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 13 6 -1.</_>
+        <_>
+          3 6 13 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 6 4 -1.</_>
+        <_>
+          12 7 3 2 2.</_>
+        <_>
+          9 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 6 8 -1.</_>
+        <_>
+          4 0 3 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 12 -1.</_>
+        <_>
+          9 11 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 3 10 -1.</_>
+        <_>
+          4 9 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 17 8 3 -1.</_>
+        <_>
+          6 18 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 10 6 -1.</_>
+        <_>
+          0 7 10 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 3 2 -1.</_>
+        <_>
+          13 3 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 4 5 -1.</_>
+        <_>
+          9 5 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 14 3 6 -1.</_>
+        <_>
+          12 16 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 8 2 -1.</_>
+        <_>
+          1 12 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 3 -1.</_>
+        <_>
+          7 14 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 3 6 -1.</_>
+        <_>
+          0 7 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 3 2 -1.</_>
+        <_>
+          13 3 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 4 6 -1.</_>
+        <_>
+          4 14 2 3 2.</_>
+        <_>
+          6 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 3 2 -1.</_>
+        <_>
+          13 3 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 4 12 -1.</_>
+        <_>
+          8 6 4 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 8 -1.</_>
+        <_>
+          17 0 3 4 2.</_>
+        <_>
+          14 4 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 17 3 2 -1.</_>
+        <_>
+          8 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          8 13 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 12 -1.</_>
+        <_>
+          6 0 4 6 2.</_>
+        <_>
+          10 6 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 2 10 -1.</_>
+        <_>
+          15 0 1 5 2.</_>
+        <_>
+          14 5 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 8 6 -1.</_>
+        <_>
+          5 3 4 3 2.</_>
+        <_>
+          9 6 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 10 -1.</_>
+        <_>
+          17 0 3 5 2.</_>
+        <_>
+          14 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 1 2 -1.</_>
+        <_>
+          9 15 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 10 4 3 -1.</_>
+        <_>
+          15 11 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 2 3 -1.</_>
+        <_>
+          8 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 14 4 -1.</_>
+        <_>
+          10 13 7 2 2.</_>
+        <_>
+          3 15 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 4 3 -1.</_>
+        <_>
+          1 11 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 6 1 -1.</_>
+        <_>
+          11 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 6 1 -1.</_>
+        <_>
+          7 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 5 16 15 -1.</_>
+        <_>
+          3 10 16 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 4 2 -1.</_>
+        <_>
+          8 12 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 12 10 -1.</_>
+        <_>
+          10 4 6 5 2.</_>
+        <_>
+          4 9 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 3 4 -1.</_>
+        <_>
+          9 6 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 8 -1.</_>
+        <_>
+          10 12 2 4 2.</_>
+        <_>
+          8 16 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 3 2 -1.</_>
+        <_>
+          13 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 3 2 -1.</_>
+        <_>
+          8 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 9 14 -1.</_>
+        <_>
+          9 0 3 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 3 -1.</_>
+        <_>
+          10 6 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 2 3 -1.</_>
+        <_>
+          10 9 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 4 6 -1.</_>
+        <_>
+          0 11 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 2 -1.</_>
+        <_>
+          6 1 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 14 7 3 -1.</_>
+        <_>
+          6 15 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 8 9 -1.</_>
+        <_>
+          8 13 8 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 3 2 -1.</_>
+        <_>
+          6 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 1 6 8 -1.</_>
+        <_>
+          17 1 3 4 2.</_>
+        <_>
+          14 5 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 6 8 -1.</_>
+        <_>
+          0 1 3 4 2.</_>
+        <_>
+          3 5 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 18 6 -1.</_>
+        <_>
+          10 2 9 3 2.</_>
+        <_>
+          1 5 9 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 2 1 -1.</_>
+        <_>
+          10 3 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 4 6 -1.</_>
+        <_>
+          15 2 2 3 2.</_>
+        <_>
+          13 5 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 1 3 -1.</_>
+        <_>
+          13 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 5 3 -1.</_>
+        <_>
+          2 17 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 4 6 -1.</_>
+        <_>
+          15 2 2 3 2.</_>
+        <_>
+          13 5 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 4 6 -1.</_>
+        <_>
+          3 2 2 3 2.</_>
+        <_>
+          5 5 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 1 2 -1.</_>
+        <_>
+          13 6 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 2 -1.</_>
+        <_>
+          5 6 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 9 2 2 -1.</_>
+        <_>
+          13 9 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 2 2 -1.</_>
+        <_>
+          6 9 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 17 3 2 -1.</_>
+        <_>
+          13 18 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 16 4 4 -1.</_>
+        <_>
+          6 16 2 2 2.</_>
+        <_>
+          8 18 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 2 3 -1.</_>
+        <_>
+          9 17 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 9 6 -1.</_>
+        <_>
+          0 15 9 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 6 -1.</_>
+        <_>
+          9 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 2 3 -1.</_>
+        <_>
+          9 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 18 6 -1.</_>
+        <_>
+          1 12 18 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 2 -1.</_>
+        <_>
+          8 12 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 9 6 2 -1.</_>
+        <_>
+          7 10 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 2 3 -1.</_>
+        <_>
+          8 9 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 5 3 4 -1.</_>
+        <_>
+          18 5 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 19 18 1 -1.</_>
+        <_>
+          7 19 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 3 2 -1.</_>
+        <_>
+          10 0 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 1 6 -1.</_>
+        <_>
+          1 10 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 17 8 3 -1.</_>
+        <_>
+          12 17 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 3 4 -1.</_>
+        <_>
+          1 5 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 3 -1.</_>
+        <_>
+          9 8 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 2 2 -1.</_>
+        <_>
+          7 11 1 1 2.</_>
+        <_>
+          8 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 2 5 -1.</_>
+        <_>
+          11 3 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 2 5 -1.</_>
+        <_>
+          8 3 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 3 -1.</_>
+        <_>
+          15 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 2 3 -1.</_>
+        <_>
+          5 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 19 15 1 -1.</_>
+        <_>
+          9 19 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 19 15 1 -1.</_>
+        <_>
+          6 19 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 3 -1.</_>
+        <_>
+          15 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 4 15 -1.</_>
+        <_>
+          7 0 2 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 5 -1.</_>
+        <_>
+          9 6 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 7 -1.</_>
+        <_>
+          10 5 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 11 3 3 -1.</_>
+        <_>
+          16 12 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 3 3 -1.</_>
+        <_>
+          1 12 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 8 3 -1.</_>
+        <_>
+          6 7 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 6 2 -1.</_>
+        <_>
+          0 16 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 6 -1.</_>
+        <_>
+          7 0 6 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 4 -1.</_>
+        <_>
+          7 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 10 4 10 -1.</_>
+        <_>
+          16 10 2 5 2.</_>
+        <_>
+          14 15 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 3 2 -1.</_>
+        <_>
+          4 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 2 2 -1.</_>
+        <_>
+          11 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 10 4 10 -1.</_>
+        <_>
+          2 10 2 5 2.</_>
+        <_>
+          4 15 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 20 6 -1.</_>
+        <_>
+          10 13 10 3 2.</_>
+        <_>
+          0 16 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 2 15 -1.</_>
+        <_>
+          1 5 1 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 18 4 -1.</_>
+        <_>
+          10 7 9 2 2.</_>
+        <_>
+          1 9 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 2 17 -1.</_>
+        <_>
+          1 0 1 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 6 16 6 -1.</_>
+        <_>
+          10 6 8 3 2.</_>
+        <_>
+          2 9 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 1 3 -1.</_>
+        <_>
+          8 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 2 -1.</_>
+        <_>
+          8 16 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 8 2 -1.</_>
+        <_>
+          5 2 4 1 2.</_>
+        <_>
+          9 3 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 8 6 -1.</_>
+        <_>
+          6 14 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 2 2 -1.</_>
+        <_>
+          9 14 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 6 -1.</_>
+        <_>
+          18 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 2 -1.</_>
+        <_>
+          9 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 6 -1.</_>
+        <_>
+          18 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 1 3 -1.</_>
+        <_>
+          9 14 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 6 -1.</_>
+        <_>
+          18 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 2 6 -1.</_>
+        <_>
+          0 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 3 3 -1.</_>
+        <_>
+          9 13 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 2 3 -1.</_>
+        <_>
+          3 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 13 4 3 -1.</_>
+        <_>
+          13 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 10 6 -1.</_>
+        <_>
+          5 4 10 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 4 3 -1.</_>
+        <_>
+          3 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 15 5 -1.</_>
+        <_>
+          8 7 5 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 12 2 -1.</_>
+        <_>
+          7 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 3 9 -1.</_>
+        <_>
+          11 3 1 9 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 4 6 -1.</_>
+        <_>
+          10 6 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 4 3 -1.</_>
+        <_>
+          9 8 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 4 9 -1.</_>
+        <_>
+          2 9 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 3 5 -1.</_>
+        <_>
+          10 13 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 3 -1.</_>
+        <_>
+          9 7 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 5 -1.</_>
+        <_>
+          10 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 8 2 -1.</_>
+        <_>
+          9 7 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 12 2 -1.</_>
+        <_>
+          9 9 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 10 3 -1.</_>
+        <_>
+          10 6 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 3 1 -1.</_>
+        <_>
+          11 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 11 15 -1.</_>
+        <_>
+          0 6 11 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 6 -1.</_>
+        <_>
+          7 0 6 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 1 -1.</_>
+        <_>
+          9 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 16 6 4 -1.</_>
+        <_>
+          5 16 3 2 2.</_>
+        <_>
+          8 18 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 9 8 -1.</_>
+        <_>
+          6 9 9 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 2 6 -1.</_>
+        <_>
+          5 13 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 8 10 -1.</_>
+        <_>
+          11 6 4 5 2.</_>
+        <_>
+          7 11 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 8 10 -1.</_>
+        <_>
+          5 6 4 5 2.</_>
+        <_>
+          9 11 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 2 -1.</_>
+        <_>
+          9 6 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 8 2 -1.</_>
+        <_>
+          5 13 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 2 8 2 -1.</_>
+        <_>
+          10 3 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 2 10 -1.</_>
+        <_>
+          4 0 1 5 2.</_>
+        <_>
+          5 5 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 10 2 2 -1.</_>
+        <_>
+          9 11 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 15 3 -1.</_>
+        <_>
+          2 9 15 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 3 -1.</_>
+        <_>
+          8 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 3 2 -1.</_>
+        <_>
+          8 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 3 -1.</_>
+        <_>
+          7 14 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 2 3 6 -1.</_>
+        <_>
+          17 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 5 3 4 -1.</_>
+        <_>
+          2 5 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 8 4 6 -1.</_>
+        <_>
+          14 10 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 3 8 -1.</_>
+        <_>
+          2 4 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 6 -1.</_>
+        <_>
+          8 16 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 2 2 -1.</_>
+        <_>
+          3 15 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 8 4 6 -1.</_>
+        <_>
+          14 10 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 4 6 -1.</_>
+        <_>
+          2 10 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 1 6 -1.</_>
+        <_>
+          10 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 3 6 -1.</_>
+        <_>
+          8 5 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 2 6 -1.</_>
+        <_>
+          12 2 1 3 2.</_>
+        <_>
+          11 5 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 6 5 -1.</_>
+        <_>
+          8 6 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 1 3 6 -1.</_>
+        <_>
+          17 3 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 5 -1.</_>
+        <_>
+          9 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 18 3 2 -1.</_>
+        <_>
+          10 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 18 3 2 -1.</_>
+        <_>
+          9 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 5 2 -1.</_>
+        <_>
+          12 4 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 5 12 -1.</_>
+        <_>
+          7 7 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 4 -1.</_>
+        <_>
+          7 0 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 2 2 -1.</_>
+        <_>
+          4 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 14 4 2 -1.</_>
+        <_>
+          13 14 2 1 2.</_>
+        <_>
+          11 15 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 6 -1.</_>
+        <_>
+          0 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 3 -1.</_>
+        <_>
+          9 8 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 1 3 -1.</_>
+        <_>
+          5 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 10 6 1 -1.</_>
+        <_>
+          10 10 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 10 6 1 -1.</_>
+        <_>
+          7 10 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 3 -1.</_>
+        <_>
+          9 18 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 1 3 -1.</_>
+        <_>
+          4 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 3 3 -1.</_>
+        <_>
+          12 6 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 3 -1.</_>
+        <_>
+          4 6 12 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 3 -1.</_>
+        <_>
+          9 9 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 3 3 -1.</_>
+        <_>
+          5 9 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 9 17 -1.</_>
+        <_>
+          9 0 3 17 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 1 3 -1.</_>
+        <_>
+          9 13 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 15 -1.</_>
+        <_>
+          9 10 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 2 3 -1.</_>
+        <_>
+          8 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 1 3 -1.</_>
+        <_>
+          10 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 5 -1.</_>
+        <_>
+          9 1 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 20 2 -1.</_>
+        <_>
+          0 0 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 13 5 3 -1.</_>
+        <_>
+          2 14 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 5 9 15 -1.</_>
+        <_>
+          2 10 9 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 12 10 -1.</_>
+        <_>
+          11 0 6 5 2.</_>
+        <_>
+          5 5 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 2 3 -1.</_>
+        <_>
+          6 1 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 6 1 -1.</_>
+        <_>
+          12 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 2 10 -1.</_>
+        <_>
+          3 1 1 5 2.</_>
+        <_>
+          4 6 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 2 1 -1.</_>
+        <_>
+          13 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 13 4 6 -1.</_>
+        <_>
+          4 15 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 2 1 -1.</_>
+        <_>
+          13 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 2 1 -1.</_>
+        <_>
+          6 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 18 4 -1.</_>
+        <_>
+          11 12 9 2 2.</_>
+        <_>
+          2 14 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 2 2 -1.</_>
+        <_>
+          5 7 1 1 2.</_>
+        <_>
+          6 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 4 2 -1.</_>
+        <_>
+          16 4 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 2 18 -1.</_>
+        <_>
+          0 2 1 9 2.</_>
+        <_>
+          1 11 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 18 4 -1.</_>
+        <_>
+          10 2 9 2 2.</_>
+        <_>
+          1 4 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 1 3 -1.</_>
+        <_>
+          9 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 18 4 -1.</_>
+        <_>
+          11 12 9 2 2.</_>
+        <_>
+          2 14 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 12 18 4 -1.</_>
+        <_>
+          0 12 9 2 2.</_>
+        <_>
+          9 14 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 5 3 -1.</_>
+        <_>
+          11 5 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 7 3 -1.</_>
+        <_>
+          6 5 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 17 3 3 -1.</_>
+        <_>
+          13 18 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 3 4 -1.</_>
+        <_>
+          9 1 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 2 4 -1.</_>
+        <_>
+          11 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 17 9 3 -1.</_>
+        <_>
+          3 17 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 2 8 -1.</_>
+        <_>
+          12 0 1 4 2.</_>
+        <_>
+          11 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 6 12 -1.</_>
+        <_>
+          0 8 3 6 2.</_>
+        <_>
+          3 14 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 4 12 -1.</_>
+        <_>
+          10 13 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 8 14 -1.</_>
+        <_>
+          5 10 8 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 10 6 1 -1.</_>
+        <_>
+          14 10 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 10 4 -1.</_>
+        <_>
+          0 6 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 5 8 -1.</_>
+        <_>
+          10 4 5 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 4 8 -1.</_>
+        <_>
+          8 1 2 4 2.</_>
+        <_>
+          10 5 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 6 1 -1.</_>
+        <_>
+          11 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 3 4 -1.</_>
+        <_>
+          9 9 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 6 -1.</_>
+        <_>
+          18 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 3 4 -1.</_>
+        <_>
+          9 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 13 3 -1.</_>
+        <_>
+          7 2 13 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 1 -1.</_>
+        <_>
+          9 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 11 3 6 -1.</_>
+        <_>
+          12 13 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 6 1 -1.</_>
+        <_>
+          7 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 18 10 -1.</_>
+        <_>
+          10 4 9 5 2.</_>
+        <_>
+          1 9 9 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 4 9 -1.</_>
+        <_>
+          8 9 4 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 4 3 -1.</_>
+        <_>
+          8 7 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          9 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 15 4 3 -1.</_>
+        <_>
+          14 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 3 10 -1.</_>
+        <_>
+          6 10 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 1 6 -1.</_>
+        <_>
+          0 10 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 15 1 3 -1.</_>
+        <_>
+          10 16 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 15 4 3 -1.</_>
+        <_>
+          2 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 3 2 8 -1.</_>
+        <_>
+          19 3 1 4 2.</_>
+        <_>
+          18 7 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 2 8 -1.</_>
+        <_>
+          0 3 1 4 2.</_>
+        <_>
+          1 7 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 14 10 -1.</_>
+        <_>
+          10 7 7 5 2.</_>
+        <_>
+          3 12 7 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 19 3 -1.</_>
+        <_>
+          0 8 19 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 6 3 3 -1.</_>
+        <_>
+          12 7 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 1 3 -1.</_>
+        <_>
+          0 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 6 3 3 -1.</_>
+        <_>
+          12 7 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 3 3 -1.</_>
+        <_>
+          5 7 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 4 2 -1.</_>
+        <_>
+          8 3 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 4 12 -1.</_>
+        <_>
+          8 3 2 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 6 2 3 -1.</_>
+        <_>
+          13 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 20 4 -1.</_>
+        <_>
+          0 12 20 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 17 14 -1.</_>
+        <_>
+          2 7 17 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 6 10 -1.</_>
+        <_>
+          0 0 3 5 2.</_>
+        <_>
+          3 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 6 4 -1.</_>
+        <_>
+          14 6 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 6 4 -1.</_>
+        <_>
+          3 6 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 7 2 -1.</_>
+        <_>
+          13 3 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 7 2 -1.</_>
+        <_>
+          0 3 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 14 2 -1.</_>
+        <_>
+          13 11 7 1 2.</_>
+        <_>
+          6 12 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 5 2 2 -1.</_>
+        <_>
+          8 5 1 1 2.</_>
+        <_>
+          9 6 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 9 2 3 -1.</_>
+        <_>
+          13 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 3 12 -1.</_>
+        <_>
+          2 1 1 12 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 4 1 3 -1.</_>
+        <_>
+          17 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 4 1 3 -1.</_>
+        <_>
+          2 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 5 1 3 -1.</_>
+        <_>
+          14 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 16 2 3 -1.</_>
+        <_>
+          7 17 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 6 -1.</_>
+        <_>
+          10 13 2 3 2.</_>
+        <_>
+          8 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 1 3 -1.</_>
+        <_>
+          5 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 20 -1.</_>
+        <_>
+          16 0 2 20 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 2 6 -1.</_>
+        <_>
+          5 1 1 3 2.</_>
+        <_>
+          6 4 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 10 4 -1.</_>
+        <_>
+          5 6 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 2 4 12 -1.</_>
+        <_>
+          15 2 2 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 4 12 -1.</_>
+        <_>
+          7 12 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 5 1 8 -1.</_>
+        <_>
+          14 9 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 14 10 -1.</_>
+        <_>
+          1 4 7 5 2.</_>
+        <_>
+          8 9 7 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 6 6 14 -1.</_>
+        <_>
+          14 6 3 7 2.</_>
+        <_>
+          11 13 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 6 14 -1.</_>
+        <_>
+          3 6 3 7 2.</_>
+        <_>
+          6 13 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 15 2 -1.</_>
+        <_>
+          9 9 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 6 3 -1.</_>
+        <_>
+          7 15 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 14 4 -1.</_>
+        <_>
+          13 3 7 2 2.</_>
+        <_>
+          6 5 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 15 2 -1.</_>
+        <_>
+          6 9 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 8 9 -1.</_>
+        <_>
+          6 14 8 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 3 8 -1.</_>
+        <_>
+          8 4 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 2 6 -1.</_>
+        <_>
+          14 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 6 4 -1.</_>
+        <_>
+          5 7 3 2 2.</_>
+        <_>
+          8 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 18 19 -1.</_>
+        <_>
+          7 1 6 19 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 6 5 -1.</_>
+        <_>
+          4 2 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 17 6 2 -1.</_>
+        <_>
+          12 18 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 17 6 2 -1.</_>
+        <_>
+          2 18 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 3 3 6 -1.</_>
+        <_>
+          17 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 3 3 -1.</_>
+        <_>
+          8 18 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 13 2 6 -1.</_>
+        <_>
+          10 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 3 -1.</_>
+        <_>
+          7 14 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 3 3 6 -1.</_>
+        <_>
+          17 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 2 3 -1.</_>
+        <_>
+          8 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 6 2 -1.</_>
+        <_>
+          11 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 3 6 -1.</_>
+        <_>
+          0 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 5 4 6 -1.</_>
+        <_>
+          8 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 3 2 -1.</_>
+        <_>
+          5 6 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 1 3 4 -1.</_>
+        <_>
+          11 1 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 5 9 -1.</_>
+        <_>
+          1 5 5 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 6 2 3 -1.</_>
+        <_>
+          13 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 14 3 -1.</_>
+        <_>
+          7 6 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 18 8 -1.</_>
+        <_>
+          2 15 18 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 2 3 -1.</_>
+        <_>
+          5 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 4 2 -1.</_>
+        <_>
+          12 6 2 1 2.</_>
+        <_>
+          10 7 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 4 2 -1.</_>
+        <_>
+          6 6 2 1 2.</_>
+        <_>
+          8 7 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 1 3 4 -1.</_>
+        <_>
+          11 1 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 2 7 -1.</_>
+        <_>
+          8 1 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 15 14 -1.</_>
+        <_>
+          4 9 15 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 2 -1.</_>
+        <_>
+          9 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 18 4 -1.</_>
+        <_>
+          11 3 9 2 2.</_>
+        <_>
+          2 5 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 2 -1.</_>
+        <_>
+          10 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 9 2 3 -1.</_>
+        <_>
+          13 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 6 2 -1.</_>
+        <_>
+          7 2 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 7 -1.</_>
+        <_>
+          9 5 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 2 3 -1.</_>
+        <_>
+          6 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 14 18 -1.</_>
+        <_>
+          6 9 14 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 6 3 -1.</_>
+        <_>
+          2 17 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 6 -1.</_>
+        <_>
+          10 7 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 4 3 -1.</_>
+        <_>
+          7 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 6 3 -1.</_>
+        <_>
+          7 13 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 3 -1.</_>
+        <_>
+          9 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 6 2 -1.</_>
+        <_>
+          9 12 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 4 6 -1.</_>
+        <_>
+          5 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 12 7 2 -1.</_>
+        <_>
+          11 13 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 8 6 -1.</_>
+        <_>
+          6 10 4 3 2.</_>
+        <_>
+          10 13 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 3 4 -1.</_>
+        <_>
+          11 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 2 3 -1.</_>
+        <_>
+          9 17 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 3 1 9 -1.</_>
+        <_>
+          13 6 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 13 14 6 -1.</_>
+        <_>
+          1 15 14 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 6 1 6 -1.</_>
+        <_>
+          13 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 3 8 -1.</_>
+        <_>
+          1 4 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 0 2 18 -1.</_>
+        <_>
+          18 0 1 18 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 6 2 -1.</_>
+        <_>
+          2 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 8 6 -1.</_>
+        <_>
+          9 2 8 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 1 6 -1.</_>
+        <_>
+          6 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 8 6 3 -1.</_>
+        <_>
+          14 9 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 2 18 -1.</_>
+        <_>
+          1 0 1 18 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 18 18 2 -1.</_>
+        <_>
+          10 18 9 1 2.</_>
+        <_>
+          1 19 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 15 2 2 -1.</_>
+        <_>
+          3 16 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 5 3 -1.</_>
+        <_>
+          8 15 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 2 3 -1.</_>
+        <_>
+          8 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 3 3 -1.</_>
+        <_>
+          13 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 2 -1.</_>
+        <_>
+          9 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 5 5 2 -1.</_>
+        <_>
+          15 6 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 5 2 -1.</_>
+        <_>
+          0 6 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 14 1 6 -1.</_>
+        <_>
+          17 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 9 9 3 -1.</_>
+        <_>
+          5 9 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 3 3 -1.</_>
+        <_>
+          13 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 4 18 -1.</_>
+        <_>
+          2 0 2 18 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 6 1 3 -1.</_>
+        <_>
+          17 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 14 1 6 -1.</_>
+        <_>
+          2 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 8 1 2 -1.</_>
+        <_>
+          19 9 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 3 3 -1.</_>
+        <_>
+          6 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 2 3 -1.</_>
+        <_>
+          9 17 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 6 1 3 -1.</_>
+        <_>
+          2 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 8 2 -1.</_>
+        <_>
+          16 4 4 1 2.</_>
+        <_>
+          12 5 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 8 2 -1.</_>
+        <_>
+          0 4 4 1 2.</_>
+        <_>
+          4 5 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 18 4 -1.</_>
+        <_>
+          2 18 18 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 2 4 -1.</_>
+        <_>
+          7 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 14 3 -1.</_>
+        <_>
+          4 1 14 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 4 20 -1.</_>
+        <_>
+          2 0 2 20 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 4 8 -1.</_>
+        <_>
+          14 4 2 4 2.</_>
+        <_>
+          12 8 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 2 2 -1.</_>
+        <_>
+          6 7 1 1 2.</_>
+        <_>
+          7 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 2 3 -1.</_>
+        <_>
+          10 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 2 -1.</_>
+        <_>
+          8 8 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 6 12 -1.</_>
+        <_>
+          8 8 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 11 12 -1.</_>
+        <_>
+          4 4 11 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 9 6 11 -1.</_>
+        <_>
+          16 9 2 11 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 4 3 -1.</_>
+        <_>
+          0 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 10 2 3 -1.</_>
+        <_>
+          9 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 3 2 -1.</_>
+        <_>
+          5 12 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 3 3 -1.</_>
+        <_>
+          10 15 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 3 4 -1.</_>
+        <_>
+          9 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 3 3 -1.</_>
+        <_>
+          10 15 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 3 2 -1.</_>
+        <_>
+          8 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 10 16 4 -1.</_>
+        <_>
+          10 10 8 2 2.</_>
+        <_>
+          2 12 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 4 17 -1.</_>
+        <_>
+          4 3 2 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 7 -1.</_>
+        <_>
+          15 13 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 6 1 -1.</_>
+        <_>
+          5 2 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 12 4 -1.</_>
+        <_>
+          9 2 4 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 12 -1.</_>
+        <_>
+          6 0 4 6 2.</_>
+        <_>
+          10 6 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 2 2 -1.</_>
+        <_>
+          14 7 1 1 2.</_>
+        <_>
+          13 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 12 20 6 -1.</_>
+        <_>
+          0 14 20 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 7 2 3 -1.</_>
+        <_>
+          14 7 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 9 12 -1.</_>
+        <_>
+          3 8 3 12 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 16 2 -1.</_>
+        <_>
+          3 0 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 15 3 3 -1.</_>
+        <_>
+          6 16 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 6 3 -1.</_>
+        <_>
+          8 16 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 1 6 -1.</_>
+        <_>
+          0 12 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 9 4 3 -1.</_>
+        <_>
+          10 10 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 2 3 -1.</_>
+        <_>
+          9 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 1 -1.</_>
+        <_>
+          5 7 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 12 19 -1.</_>
+        <_>
+          10 0 6 19 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 20 6 -1.</_>
+        <_>
+          10 6 10 3 2.</_>
+        <_>
+          0 9 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 2 2 -1.</_>
+        <_>
+          3 6 1 1 2.</_>
+        <_>
+          4 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 6 2 2 -1.</_>
+        <_>
+          16 6 1 1 2.</_>
+        <_>
+          15 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 2 2 -1.</_>
+        <_>
+          3 6 1 1 2.</_>
+        <_>
+          4 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 4 1 12 -1.</_>
+        <_>
+          14 10 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 5 16 10 -1.</_>
+        <_>
+          2 5 8 5 2.</_>
+        <_>
+          10 10 8 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 2 -1.</_>
+        <_>
+          10 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 2 2 -1.</_>
+        <_>
+          1 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 15 5 -1.</_>
+        <_>
+          10 0 5 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 15 5 -1.</_>
+        <_>
+          5 0 5 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 2 17 -1.</_>
+        <_>
+          11 2 1 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 2 17 -1.</_>
+        <_>
+          8 2 1 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 2 9 -1.</_>
+        <_>
+          15 11 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 2 9 -1.</_>
+        <_>
+          4 11 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 16 14 4 -1.</_>
+        <_>
+          5 16 7 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 18 1 -1.</_>
+        <_>
+          7 4 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 6 4 -1.</_>
+        <_>
+          16 7 3 2 2.</_>
+        <_>
+          13 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 12 -1.</_>
+        <_>
+          9 12 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 1 6 6 -1.</_>
+        <_>
+          12 3 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 6 6 -1.</_>
+        <_>
+          5 2 3 3 2.</_>
+        <_>
+          8 5 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 6 4 -1.</_>
+        <_>
+          12 16 3 2 2.</_>
+        <_>
+          9 18 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 18 3 -1.</_>
+        <_>
+          7 2 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 9 10 -1.</_>
+        <_>
+          7 9 9 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 4 4 -1.</_>
+        <_>
+          7 9 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 3 6 -1.</_>
+        <_>
+          11 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 5 3 -1.</_>
+        <_>
+          7 12 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 6 6 -1.</_>
+        <_>
+          10 11 3 3 2.</_>
+        <_>
+          7 14 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 10 9 -1.</_>
+        <_>
+          0 3 10 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 1 6 -1.</_>
+        <_>
+          13 16 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 6 -1.</_>
+        <_>
+          0 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 14 1 6 -1.</_>
+        <_>
+          6 16 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 2 3 -1.</_>
+        <_>
+          9 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 3 3 -1.</_>
+        <_>
+          7 4 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 11 3 -1.</_>
+        <_>
+          9 1 11 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 20 3 -1.</_>
+        <_>
+          0 7 20 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 1 1 2 -1.</_>
+        <_>
+          10 2 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 6 -1.</_>
+        <_>
+          10 6 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 8 12 1 -1.</_>
+        <_>
+          9 8 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 8 12 1 -1.</_>
+        <_>
+          7 8 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 5 -1.</_>
+        <_>
+          10 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 9 6 2 -1.</_>
+        <_>
+          6 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 1 -1.</_>
+        <_>
+          9 0 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 10 2 1 -1.</_>
+        <_>
+          8 10 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 9 13 -1.</_>
+        <_>
+          9 4 3 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 8 4 2 -1.</_>
+        <_>
+          6 9 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 2 4 6 -1.</_>
+        <_>
+          16 2 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 17 6 3 -1.</_>
+        <_>
+          0 18 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 10 3 10 -1.</_>
+        <_>
+          10 15 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 5 -1.</_>
+        <_>
+          9 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 4 4 3 -1.</_>
+        <_>
+          10 4 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 4 3 8 -1.</_>
+        <_>
+          9 4 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 9 13 -1.</_>
+        <_>
+          9 6 3 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 12 -1.</_>
+        <_>
+          6 0 4 6 2.</_>
+        <_>
+          10 6 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 8 -1.</_>
+        <_>
+          16 2 2 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 6 -1.</_>
+        <_>
+          7 0 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 8 -1.</_>
+        <_>
+          16 2 2 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 6 6 -1.</_>
+        <_>
+          0 8 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 6 2 -1.</_>
+        <_>
+          12 12 3 1 2.</_>
+        <_>
+          9 13 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 3 2 -1.</_>
+        <_>
+          9 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 6 2 2 -1.</_>
+        <_>
+          12 6 1 1 2.</_>
+        <_>
+          11 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 18 2 -1.</_>
+        <_>
+          7 9 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 6 2 2 -1.</_>
+        <_>
+          12 6 1 1 2.</_>
+        <_>
+          11 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 12 8 -1.</_>
+        <_>
+          7 4 4 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 5 3 -1.</_>
+        <_>
+          13 12 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 10 2 3 -1.</_>
+        <_>
+          9 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 7 2 3 -1.</_>
+        <_>
+          14 7 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 1 3 -1.</_>
+        <_>
+          5 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 2 3 -1.</_>
+        <_>
+          13 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 2 3 -1.</_>
+        <_>
+          5 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 3 -1.</_>
+        <_>
+          9 9 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 2 2 -1.</_>
+        <_>
+          8 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 14 1 4 -1.</_>
+        <_>
+          15 16 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 2 2 -1.</_>
+        <_>
+          3 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 15 2 2 -1.</_>
+        <_>
+          13 15 1 1 2.</_>
+        <_>
+          12 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 2 2 -1.</_>
+        <_>
+          9 14 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 14 9 -1.</_>
+        <_>
+          4 14 14 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 4 3 -1.</_>
+        <_>
+          7 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 14 1 4 -1.</_>
+        <_>
+          15 16 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 1 4 -1.</_>
+        <_>
+          4 16 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 13 -1.</_>
+        <_>
+          16 0 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 1 2 12 -1.</_>
+        <_>
+          4 1 1 6 2.</_>
+        <_>
+          5 7 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 14 6 6 -1.</_>
+        <_>
+          14 14 3 3 2.</_>
+        <_>
+          11 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 6 6 -1.</_>
+        <_>
+          3 14 3 3 2.</_>
+        <_>
+          6 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 17 3 2 -1.</_>
+        <_>
+          14 18 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 17 3 2 -1.</_>
+        <_>
+          3 18 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 13 -1.</_>
+        <_>
+          16 0 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 6 13 -1.</_>
+        <_>
+          2 0 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 10 7 6 -1.</_>
+        <_>
+          10 12 7 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 15 2 2 -1.</_>
+        <_>
+          6 15 1 1 2.</_>
+        <_>
+          7 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 8 6 -1.</_>
+        <_>
+          10 11 4 3 2.</_>
+        <_>
+          6 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 2 2 -1.</_>
+        <_>
+          7 6 1 1 2.</_>
+        <_>
+          8 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 16 6 -1.</_>
+        <_>
+          10 2 8 3 2.</_>
+        <_>
+          2 5 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 7 3 10 -1.</_>
+        <_>
+          11 12 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 3 10 -1.</_>
+        <_>
+          6 12 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 3 2 -1.</_>
+        <_>
+          11 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          8 13 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 1 1 3 -1.</_>
+        <_>
+          10 2 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 4 18 -1.</_>
+        <_>
+          1 2 2 9 2.</_>
+        <_>
+          3 11 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 4 12 -1.</_>
+        <_>
+          12 10 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 1 6 -1.</_>
+        <_>
+          0 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 4 3 -1.</_>
+        <_>
+          8 8 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 3 2 -1.</_>
+        <_>
+          11 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 3 2 -1.</_>
+        <_>
+          8 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 6 1 -1.</_>
+        <_>
+          11 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 2 3 -1.</_>
+        <_>
+          9 7 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 8 6 -1.</_>
+        <_>
+          16 7 4 3 2.</_>
+        <_>
+          12 10 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 8 6 -1.</_>
+        <_>
+          0 7 4 3 2.</_>
+        <_>
+          4 10 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 2 2 10 -1.</_>
+        <_>
+          19 2 1 5 2.</_>
+        <_>
+          18 7 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 6 4 -1.</_>
+        <_>
+          3 2 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 6 1 -1.</_>
+        <_>
+          11 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 2 2 -1.</_>
+        <_>
+          7 15 1 1 2.</_>
+        <_>
+          8 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 13 1 6 -1.</_>
+        <_>
+          11 16 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 1 6 -1.</_>
+        <_>
+          8 16 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 2 1 -1.</_>
+        <_>
+          14 3 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 2 3 -1.</_>
+        <_>
+          8 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 15 7 4 -1.</_>
+        <_>
+          12 17 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 12 3 -1.</_>
+        <_>
+          4 15 12 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 3 2 -1.</_>
+        <_>
+          11 3 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 2 -1.</_>
+        <_>
+          4 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 4 6 -1.</_>
+        <_>
+          10 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 2 2 -1.</_>
+        <_>
+          7 13 1 1 2.</_>
+        <_>
+          8 14 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 14 4 -1.</_>
+        <_>
+          11 11 7 2 2.</_>
+        <_>
+          4 13 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 18 18 2 -1.</_>
+        <_>
+          7 18 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 18 2 2 -1.</_>
+        <_>
+          12 18 1 1 2.</_>
+        <_>
+          11 19 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 18 2 2 -1.</_>
+        <_>
+          7 18 1 1 2.</_>
+        <_>
+          8 19 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 18 8 2 -1.</_>
+        <_>
+          12 19 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 6 2 -1.</_>
+        <_>
+          7 15 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 8 -1.</_>
+        <_>
+          10 12 2 4 2.</_>
+        <_>
+          8 16 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 3 3 -1.</_>
+        <_>
+          4 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 10 6 2 -1.</_>
+        <_>
+          9 10 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 4 15 -1.</_>
+        <_>
+          7 0 2 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 12 14 -1.</_>
+        <_>
+          12 6 4 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 16 3 3 -1.</_>
+        <_>
+          5 17 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 12 19 -1.</_>
+        <_>
+          12 1 4 19 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 3 2 -1.</_>
+        <_>
+          3 1 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 4 5 -1.</_>
+        <_>
+          10 12 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 4 5 -1.</_>
+        <_>
+          8 12 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 2 2 -1.</_>
+        <_>
+          12 11 1 1 2.</_>
+        <_>
+          11 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 6 -1.</_>
+        <_>
+          0 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 2 2 -1.</_>
+        <_>
+          12 11 1 1 2.</_>
+        <_>
+          11 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 4 10 -1.</_>
+        <_>
+          7 11 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 2 2 -1.</_>
+        <_>
+          12 11 1 1 2.</_>
+        <_>
+          11 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 13 5 2 -1.</_>
+        <_>
+          2 14 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 2 2 -1.</_>
+        <_>
+          12 11 1 1 2.</_>
+        <_>
+          11 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 2 2 -1.</_>
+        <_>
+          7 11 1 1 2.</_>
+        <_>
+          8 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 13 3 3 -1.</_>
+        <_>
+          14 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 3 3 -1.</_>
+        <_>
+          3 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          8 8 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 3 3 -1.</_>
+        <_>
+          13 6 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 5 3 -1.</_>
+        <_>
+          0 10 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 3 3 -1.</_>
+        <_>
+          13 6 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 8 -1.</_>
+        <_>
+          9 12 1 4 2.</_>
+        <_>
+          10 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 7 2 2 -1.</_>
+        <_>
+          12 7 1 1 2.</_>
+        <_>
+          11 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 16 6 4 -1.</_>
+        <_>
+          3 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 2 3 -1.</_>
+        <_>
+          10 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 6 -1.</_>
+        <_>
+          9 7 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 15 8 4 -1.</_>
+        <_>
+          12 15 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 8 6 -1.</_>
+        <_>
+          4 14 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 3 2 -1.</_>
+        <_>
+          10 0 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 15 4 2 -1.</_>
+        <_>
+          6 15 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 3 13 -1.</_>
+        <_>
+          13 7 1 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 3 13 -1.</_>
+        <_>
+          6 7 1 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 3 9 -1.</_>
+        <_>
+          9 9 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 7 12 -1.</_>
+        <_>
+          4 10 7 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 12 2 2 -1.</_>
+        <_>
+          13 12 1 1 2.</_>
+        <_>
+          12 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 2 2 -1.</_>
+        <_>
+          6 12 1 1 2.</_>
+        <_>
+          7 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 4 2 -1.</_>
+        <_>
+          10 9 2 1 2.</_>
+        <_>
+          8 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 2 2 -1.</_>
+        <_>
+          3 6 1 1 2.</_>
+        <_>
+          4 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 6 3 2 -1.</_>
+        <_>
+          16 7 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 19 4 -1.</_>
+        <_>
+          0 9 19 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 2 10 1 -1.</_>
+        <_>
+          10 2 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 12 -1.</_>
+        <_>
+          9 10 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 18 4 1 -1.</_>
+        <_>
+          12 18 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 6 4 -1.</_>
+        <_>
+          1 7 3 2 2.</_>
+        <_>
+          4 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 6 13 -1.</_>
+        <_>
+          14 0 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 6 13 -1.</_>
+        <_>
+          4 0 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 5 8 8 -1.</_>
+        <_>
+          10 9 8 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 3 2 5 -1.</_>
+        <_>
+          9 3 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 4 9 1 -1.</_>
+        <_>
+          11 4 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 9 1 -1.</_>
+        <_>
+          6 4 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 10 -1.</_>
+        <_>
+          7 0 6 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 17 5 3 -1.</_>
+        <_>
+          7 18 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 6 1 -1.</_>
+        <_>
+          9 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 3 2 -1.</_>
+        <_>
+          2 3 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          8 13 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 3 6 -1.</_>
+        <_>
+          6 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 2 4 -1.</_>
+        <_>
+          11 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 2 4 -1.</_>
+        <_>
+          8 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 4 -1.</_>
+        <_>
+          9 6 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 13 8 3 -1.</_>
+        <_>
+          6 14 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 3 4 -1.</_>
+        <_>
+          10 15 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 2 2 17 -1.</_>
+        <_>
+          10 2 1 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 1 -1.</_>
+        <_>
+          9 0 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 3 4 -1.</_>
+        <_>
+          9 15 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 7 3 -1.</_>
+        <_>
+          7 14 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 16 3 3 -1.</_>
+        <_>
+          9 16 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 2 8 10 -1.</_>
+        <_>
+          6 7 8 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 5 8 8 -1.</_>
+        <_>
+          2 9 8 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 16 2 2 -1.</_>
+        <_>
+          14 17 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 16 2 2 -1.</_>
+        <_>
+          4 17 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 4 6 -1.</_>
+        <_>
+          10 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 4 6 -1.</_>
+        <_>
+          6 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 1 3 -1.</_>
+        <_>
+          10 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 4 6 -1.</_>
+        <_>
+          12 0 2 3 2.</_>
+        <_>
+          10 3 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 20 2 -1.</_>
+        <_>
+          0 4 20 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 8 2 -1.</_>
+        <_>
+          16 0 4 1 2.</_>
+        <_>
+          12 1 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 10 8 -1.</_>
+        <_>
+          2 16 10 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 7 2 10 -1.</_>
+        <_>
+          18 7 1 5 2.</_>
+        <_>
+          17 12 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 2 10 -1.</_>
+        <_>
+          1 7 1 5 2.</_>
+        <_>
+          2 12 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 10 3 6 -1.</_>
+        <_>
+          15 12 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 6 2 -1.</_>
+        <_>
+          6 4 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 20 6 -1.</_>
+        <_>
+          0 7 20 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 8 2 -1.</_>
+        <_>
+          0 0 4 1 2.</_>
+        <_>
+          4 1 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 4 -1.</_>
+        <_>
+          7 0 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 13 6 2 -1.</_>
+        <_>
+          1 14 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 3 4 -1.</_>
+        <_>
+          11 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 6 1 -1.</_>
+        <_>
+          8 1 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 6 18 2 -1.</_>
+        <_>
+          10 6 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 1 2 -1.</_>
+        <_>
+          15 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 1 2 -1.</_>
+        <_>
+          6 6 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 1 3 -1.</_>
+        <_>
+          13 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 15 1 2 -1.</_>
+        <_>
+          2 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 4 3 -1.</_>
+        <_>
+          12 5 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 7 3 -1.</_>
+        <_>
+          0 1 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 6 2 -1.</_>
+        <_>
+          9 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 2 3 -1.</_>
+        <_>
+          5 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 3 -1.</_>
+        <_>
+          18 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 8 6 -1.</_>
+        <_>
+          3 2 8 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 20 6 -1.</_>
+        <_>
+          10 2 10 3 2.</_>
+        <_>
+          0 5 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 2 4 -1.</_>
+        <_>
+          5 7 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 10 15 2 -1.</_>
+        <_>
+          8 10 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 12 11 -1.</_>
+        <_>
+          9 0 6 11 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 2 6 -1.</_>
+        <_>
+          13 0 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 19 2 1 -1.</_>
+        <_>
+          1 19 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 10 4 10 -1.</_>
+        <_>
+          18 10 2 5 2.</_>
+        <_>
+          16 15 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 8 10 3 -1.</_>
+        <_>
+          4 9 10 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 3 3 -1.</_>
+        <_>
+          14 13 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 4 10 -1.</_>
+        <_>
+          0 10 2 5 2.</_>
+        <_>
+          2 15 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 3 2 6 -1.</_>
+        <_>
+          18 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 1 3 -1.</_>
+        <_>
+          6 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 7 2 -1.</_>
+        <_>
+          7 8 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 2 6 -1.</_>
+        <_>
+          0 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 1 3 1 -1.</_>
+        <_>
+          12 1 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 2 6 -1.</_>
+        <_>
+          6 0 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 18 14 -1.</_>
+        <_>
+          7 1 6 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 6 8 3 -1.</_>
+        <_>
+          8 6 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 6 2 -1.</_>
+        <_>
+          9 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 6 2 -1.</_>
+        <_>
+          8 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 3 5 -1.</_>
+        <_>
+          11 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 3 5 -1.</_>
+        <_>
+          8 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 3 10 -1.</_>
+        <_>
+          14 0 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 3 2 -1.</_>
+        <_>
+          4 12 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 3 3 6 -1.</_>
+        <_>
+          18 3 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 18 10 -1.</_>
+        <_>
+          1 13 18 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 3 10 -1.</_>
+        <_>
+          14 0 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 7 -1.</_>
+        <_>
+          17 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 3 10 -1.</_>
+        <_>
+          5 0 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 7 -1.</_>
+        <_>
+          17 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 1 2 -1.</_>
+        <_>
+          0 10 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 10 -1.</_>
+        <_>
+          18 1 1 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 2 10 -1.</_>
+        <_>
+          1 1 1 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 3 4 -1.</_>
+        <_>
+          11 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 3 3 -1.</_>
+        <_>
+          3 8 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 2 6 -1.</_>
+        <_>
+          12 0 1 3 2.</_>
+        <_>
+          11 3 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 2 6 -1.</_>
+        <_>
+          7 0 1 3 2.</_>
+        <_>
+          8 3 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 7 -1.</_>
+        <_>
+          17 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 3 3 7 -1.</_>
+        <_>
+          2 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 1 6 16 -1.</_>
+        <_>
+          16 1 2 16 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 6 16 -1.</_>
+        <_>
+          2 1 2 16 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 16 8 -1.</_>
+        <_>
+          10 0 8 4 2.</_>
+        <_>
+          2 4 8 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 8 5 3 -1.</_>
+        <_>
+          6 9 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          10 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 4 3 -1.</_>
+        <_>
+          8 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 4 -1.</_>
+        <_>
+          9 6 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 15 1 -1.</_>
+        <_>
+          5 7 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 7 9 -1.</_>
+        <_>
+          8 5 7 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 16 4 -1.</_>
+        <_>
+          1 7 8 2 2.</_>
+        <_>
+          9 9 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 8 2 -1.</_>
+        <_>
+          6 13 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 3 3 -1.</_>
+        <_>
+          8 12 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 14 10 -1.</_>
+        <_>
+          11 5 7 5 2.</_>
+        <_>
+          4 10 7 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 3 2 -1.</_>
+        <_>
+          4 13 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 6 1 -1.</_>
+        <_>
+          11 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 7 6 -1.</_>
+        <_>
+          4 11 7 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 10 6 3 -1.</_>
+        <_>
+          7 11 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 2 -1.</_>
+        <_>
+          9 12 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 20 6 -1.</_>
+        <_>
+          0 7 20 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 6 1 -1.</_>
+        <_>
+          8 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 6 1 -1.</_>
+        <_>
+          11 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 6 1 -1.</_>
+        <_>
+          7 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 3 4 -1.</_>
+        <_>
+          11 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          9 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 16 8 -1.</_>
+        <_>
+          2 16 16 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 15 2 -1.</_>
+        <_>
+          0 16 15 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 4 5 6 -1.</_>
+        <_>
+          15 6 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 4 -1.</_>
+        <_>
+          10 5 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 9 6 -1.</_>
+        <_>
+          8 12 9 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 19 15 1 -1.</_>
+        <_>
+          7 19 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 3 4 -1.</_>
+        <_>
+          11 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 20 4 -1.</_>
+        <_>
+          0 17 20 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 3 4 -1.</_>
+        <_>
+          11 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 16 3 4 -1.</_>
+        <_>
+          8 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 3 3 -1.</_>
+        <_>
+          9 17 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 6 -1.</_>
+        <_>
+          8 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 12 -1.</_>
+        <_>
+          9 10 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 4 3 -1.</_>
+        <_>
+          8 18 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 18 8 2 -1.</_>
+        <_>
+          13 18 4 1 2.</_>
+        <_>
+          9 19 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 18 8 2 -1.</_>
+        <_>
+          1 19 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 6 15 -1.</_>
+        <_>
+          15 5 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 2 -1.</_>
+        <_>
+          9 9 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 3 -1.</_>
+        <_>
+          9 5 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 5 6 15 -1.</_>
+        <_>
+          3 5 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 1 14 8 -1.</_>
+        <_>
+          11 1 7 4 2.</_>
+        <_>
+          4 5 7 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 4 4 16 -1.</_>
+        <_>
+          2 4 2 8 2.</_>
+        <_>
+          4 12 2 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 12 -1.</_>
+        <_>
+          12 10 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 10 12 -1.</_>
+        <_>
+          4 5 5 6 2.</_>
+        <_>
+          9 11 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 2 3 -1.</_>
+        <_>
+          5 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 4 10 -1.</_>
+        <_>
+          14 2 2 5 2.</_>
+        <_>
+          12 7 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 7 3 -1.</_>
+        <_>
+          6 5 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 18 2 -1.</_>
+        <_>
+          11 0 9 1 2.</_>
+        <_>
+          2 1 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 18 2 -1.</_>
+        <_>
+          0 0 9 1 2.</_>
+        <_>
+          9 1 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 13 4 6 -1.</_>
+        <_>
+          15 13 2 3 2.</_>
+        <_>
+          13 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 4 6 -1.</_>
+        <_>
+          3 13 2 3 2.</_>
+        <_>
+          5 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 2 6 -1.</_>
+        <_>
+          10 15 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 10 10 -1.</_>
+        <_>
+          5 9 5 5 2.</_>
+        <_>
+          10 14 5 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 4 2 -1.</_>
+        <_>
+          13 4 2 1 2.</_>
+        <_>
+          11 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 6 8 -1.</_>
+        <_>
+          10 12 3 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 4 10 -1.</_>
+        <_>
+          14 2 2 5 2.</_>
+        <_>
+          12 7 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 2 1 -1.</_>
+        <_>
+          9 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 5 1 12 -1.</_>
+        <_>
+          10 9 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 11 6 9 -1.</_>
+        <_>
+          3 11 3 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 4 10 -1.</_>
+        <_>
+          14 2 2 5 2.</_>
+        <_>
+          12 7 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 4 10 -1.</_>
+        <_>
+          4 2 2 5 2.</_>
+        <_>
+          6 7 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 4 2 -1.</_>
+        <_>
+          13 4 2 1 2.</_>
+        <_>
+          11 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 6 3 -1.</_>
+        <_>
+          0 15 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 4 2 -1.</_>
+        <_>
+          13 4 2 1 2.</_>
+        <_>
+          11 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 3 2 -1.</_>
+        <_>
+          7 1 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 4 2 -1.</_>
+        <_>
+          13 4 2 1 2.</_>
+        <_>
+          11 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 4 2 -1.</_>
+        <_>
+          5 4 2 1 2.</_>
+        <_>
+          7 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 2 12 -1.</_>
+        <_>
+          14 0 1 6 2.</_>
+        <_>
+          13 6 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 10 -1.</_>
+        <_>
+          7 0 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 17 8 -1.</_>
+        <_>
+          3 4 17 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 20 4 -1.</_>
+        <_>
+          0 6 20 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 8 2 -1.</_>
+        <_>
+          4 3 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 3 -1.</_>
+        <_>
+          8 12 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 6 4 -1.</_>
+        <_>
+          5 7 3 2 2.</_>
+        <_>
+          8 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 3 4 9 -1.</_>
+        <_>
+          8 6 4 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 1 4 -1.</_>
+        <_>
+          8 17 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 7 -1.</_>
+        <_>
+          8 5 4 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 4 10 -1.</_>
+        <_>
+          4 2 2 5 2.</_>
+        <_>
+          6 7 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 17 2 -1.</_>
+        <_>
+          3 1 17 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 16 15 -1.</_>
+        <_>
+          2 7 16 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 2 5 2 -1.</_>
+        <_>
+          15 3 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 2 2 -1.</_>
+        <_>
+          10 3 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 16 15 -1.</_>
+        <_>
+          4 10 16 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 5 6 -1.</_>
+        <_>
+          7 16 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 3 2 -1.</_>
+        <_>
+          11 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 3 3 1 -1.</_>
+        <_>
+          9 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 3 3 -1.</_>
+        <_>
+          9 17 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 5 2 -1.</_>
+        <_>
+          0 3 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 12 1 -1.</_>
+        <_>
+          5 7 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 14 -1.</_>
+        <_>
+          7 12 6 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 8 10 -1.</_>
+        <_>
+          0 0 4 5 2.</_>
+        <_>
+          4 5 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 1 3 2 -1.</_>
+        <_>
+          10 1 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 3 2 -1.</_>
+        <_>
+          9 1 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 6 16 -1.</_>
+        <_>
+          7 12 6 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 2 6 -1.</_>
+        <_>
+          2 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 9 -1.</_>
+        <_>
+          14 5 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 2 -1.</_>
+        <_>
+          10 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 3 -1.</_>
+        <_>
+          5 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 3 6 -1.</_>
+        <_>
+          13 13 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 2 6 -1.</_>
+        <_>
+          3 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 6 2 -1.</_>
+        <_>
+          14 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 16 2 -1.</_>
+        <_>
+          0 9 16 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 6 2 -1.</_>
+        <_>
+          14 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 5 6 -1.</_>
+        <_>
+          0 2 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 3 6 -1.</_>
+        <_>
+          4 13 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 1 3 -1.</_>
+        <_>
+          9 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 8 12 -1.</_>
+        <_>
+          6 12 8 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 9 2 -1.</_>
+        <_>
+          8 12 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 4 3 -1.</_>
+        <_>
+          4 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 9 2 -1.</_>
+        <_>
+          9 6 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 1 3 -1.</_>
+        <_>
+          4 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 6 6 -1.</_>
+        <_>
+          14 12 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 3 7 -1.</_>
+        <_>
+          8 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 3 3 -1.</_>
+        <_>
+          10 8 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 3 3 -1.</_>
+        <_>
+          9 8 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 11 3 -1.</_>
+        <_>
+          5 11 11 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 1 -1.</_>
+        <_>
+          10 7 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 2 -1.</_>
+        <_>
+          10 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 2 -1.</_>
+        <_>
+          9 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 9 4 2 -1.</_>
+        <_>
+          11 9 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 4 2 -1.</_>
+        <_>
+          7 9 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 10 2 4 -1.</_>
+        <_>
+          14 12 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 3 2 -1.</_>
+        <_>
+          8 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 17 6 3 -1.</_>
+        <_>
+          14 18 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 12 -1.</_>
+        <_>
+          4 5 6 6 2.</_>
+        <_>
+          10 11 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 8 8 -1.</_>
+        <_>
+          10 9 4 4 2.</_>
+        <_>
+          6 13 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 15 4 -1.</_>
+        <_>
+          5 4 5 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 4 1 -1.</_>
+        <_>
+          13 2 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 2 -1.</_>
+        <_>
+          4 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 3 -1.</_>
+        <_>
+          8 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 2 3 -1.</_>
+        <_>
+          9 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 2 3 -1.</_>
+        <_>
+          13 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 4 4 -1.</_>
+        <_>
+          7 12 2 2 2.</_>
+        <_>
+          9 14 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 2 2 -1.</_>
+        <_>
+          11 11 1 1 2.</_>
+        <_>
+          10 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 3 2 -1.</_>
+        <_>
+          9 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 2 2 -1.</_>
+        <_>
+          11 11 1 1 2.</_>
+        <_>
+          10 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 17 6 3 -1.</_>
+        <_>
+          0 18 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 2 2 -1.</_>
+        <_>
+          11 11 1 1 2.</_>
+        <_>
+          10 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 2 2 -1.</_>
+        <_>
+          8 11 1 1 2.</_>
+        <_>
+          9 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 8 4 -1.</_>
+        <_>
+          12 5 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 8 4 -1.</_>
+        <_>
+          4 5 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 4 1 -1.</_>
+        <_>
+          13 2 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 4 1 -1.</_>
+        <_>
+          5 2 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 4 2 -1.</_>
+        <_>
+          12 0 2 1 2.</_>
+        <_>
+          10 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 3 1 -1.</_>
+        <_>
+          8 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 8 -1.</_>
+        <_>
+          10 11 2 4 2.</_>
+        <_>
+          8 15 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 18 15 2 -1.</_>
+        <_>
+          3 19 15 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 6 2 12 -1.</_>
+        <_>
+          2 6 1 6 2.</_>
+        <_>
+          3 12 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 3 -1.</_>
+        <_>
+          9 9 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 10 3 2 -1.</_>
+        <_>
+          8 10 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 3 1 -1.</_>
+        <_>
+          12 11 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 3 1 -1.</_>
+        <_>
+          7 11 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 2 4 2 -1.</_>
+        <_>
+          11 2 2 1 2.</_>
+        <_>
+          9 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 3 -1.</_>
+        <_>
+          4 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 18 3 -1.</_>
+        <_>
+          8 1 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 4 14 -1.</_>
+        <_>
+          7 1 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 16 12 3 -1.</_>
+        <_>
+          8 16 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 17 18 3 -1.</_>
+        <_>
+          7 17 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 6 -1.</_>
+        <_>
+          9 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 1 8 -1.</_>
+        <_>
+          9 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 12 -1.</_>
+        <_>
+          9 10 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 4 8 -1.</_>
+        <_>
+          2 1 2 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 1 6 2 -1.</_>
+        <_>
+          12 1 3 1 2.</_>
+        <_>
+          9 2 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 3 12 14 -1.</_>
+        <_>
+          1 10 12 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          10 12 2 1 2.</_>
+        <_>
+          8 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 10 2 -1.</_>
+        <_>
+          1 9 5 1 2.</_>
+        <_>
+          6 10 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 8 8 3 -1.</_>
+        <_>
+          6 9 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 5 3 -1.</_>
+        <_>
+          9 16 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 4 3 -1.</_>
+        <_>
+          8 8 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 2 -1.</_>
+        <_>
+          7 8 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 8 2 -1.</_>
+        <_>
+          5 7 4 1 2.</_>
+        <_>
+          9 8 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 4 2 -1.</_>
+        <_>
+          4 8 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 9 -1.</_>
+        <_>
+          14 5 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 3 3 -1.</_>
+        <_>
+          5 9 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 6 9 -1.</_>
+        <_>
+          0 5 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 3 3 6 -1.</_>
+        <_>
+          18 3 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 3 6 -1.</_>
+        <_>
+          1 3 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 14 1 2 -1.</_>
+        <_>
+          17 15 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 4 3 -1.</_>
+        <_>
+          6 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 3 3 -1.</_>
+        <_>
+          5 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 8 -1.</_>
+        <_>
+          12 5 3 4 2.</_>
+        <_>
+          9 9 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 6 8 -1.</_>
+        <_>
+          5 5 3 4 2.</_>
+        <_>
+          8 9 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 1 4 6 -1.</_>
+        <_>
+          16 4 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 6 20 -1.</_>
+        <_>
+          3 0 2 20 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 11 3 2 -1.</_>
+        <_>
+          13 11 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 3 2 -1.</_>
+        <_>
+          6 11 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 6 1 -1.</_>
+        <_>
+          11 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 8 3 -1.</_>
+        <_>
+          4 0 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 0 2 5 -1.</_>
+        <_>
+          15 0 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 1 3 2 -1.</_>
+        <_>
+          5 1 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 15 -1.</_>
+        <_>
+          9 0 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 3 1 -1.</_>
+        <_>
+          7 11 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 3 4 -1.</_>
+        <_>
+          13 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 6 1 -1.</_>
+        <_>
+          7 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 3 2 -1.</_>
+        <_>
+          12 8 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 4 6 -1.</_>
+        <_>
+          0 4 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 3 2 -1.</_>
+        <_>
+          12 8 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 3 3 -1.</_>
+        <_>
+          2 17 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 8 6 10 -1.</_>
+        <_>
+          16 8 3 5 2.</_>
+        <_>
+          13 13 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 5 2 -1.</_>
+        <_>
+          0 10 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 11 2 2 -1.</_>
+        <_>
+          13 11 1 1 2.</_>
+        <_>
+          12 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 15 3 3 -1.</_>
+        <_>
+          3 16 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 3 2 -1.</_>
+        <_>
+          12 8 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 3 2 -1.</_>
+        <_>
+          5 8 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 9 9 -1.</_>
+        <_>
+          9 8 9 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 3 7 -1.</_>
+        <_>
+          6 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 12 5 -1.</_>
+        <_>
+          9 2 4 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 2 2 -1.</_>
+        <_>
+          6 11 1 1 2.</_>
+        <_>
+          7 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 15 3 2 -1.</_>
+        <_>
+          15 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 15 3 2 -1.</_>
+        <_>
+          2 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 6 8 -1.</_>
+        <_>
+          17 12 3 4 2.</_>
+        <_>
+          14 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 15 6 -1.</_>
+        <_>
+          7 8 5 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 18 17 -1.</_>
+        <_>
+          8 2 6 17 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 4 1 -1.</_>
+        <_>
+          7 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 12 5 -1.</_>
+        <_>
+          9 2 4 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 12 5 -1.</_>
+        <_>
+          7 2 4 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 12 4 -1.</_>
+        <_>
+          10 9 6 2 2.</_>
+        <_>
+          4 11 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 15 6 2 -1.</_>
+        <_>
+          5 15 3 1 2.</_>
+        <_>
+          8 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 2 3 -1.</_>
+        <_>
+          10 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 20 2 -1.</_>
+        <_>
+          0 13 10 1 2.</_>
+        <_>
+          10 14 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 12 8 -1.</_>
+        <_>
+          10 9 6 4 2.</_>
+        <_>
+          4 13 6 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 3 6 -1.</_>
+        <_>
+          8 16 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 2 2 -1.</_>
+        <_>
+          10 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 2 -1.</_>
+        <_>
+          9 12 1 1 2.</_>
+        <_>
+          10 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 14 4 -1.</_>
+        <_>
+          11 11 7 2 2.</_>
+        <_>
+          4 13 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 5 4 2 -1.</_>
+        <_>
+          8 6 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 10 6 3 -1.</_>
+        <_>
+          12 10 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 14 1 2 -1.</_>
+        <_>
+          2 15 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 8 6 12 -1.</_>
+        <_>
+          16 8 3 6 2.</_>
+        <_>
+          13 14 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 6 12 -1.</_>
+        <_>
+          1 8 3 6 2.</_>
+        <_>
+          4 14 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 6 10 -1.</_>
+        <_>
+          12 0 2 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 8 4 -1.</_>
+        <_>
+          5 11 4 2 2.</_>
+        <_>
+          9 13 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 8 4 -1.</_>
+        <_>
+          14 16 4 2 2.</_>
+        <_>
+          10 18 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 6 -1.</_>
+        <_>
+          9 7 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 2 4 10 -1.</_>
+        <_>
+          10 2 2 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 4 9 -1.</_>
+        <_>
+          8 1 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 19 2 1 -1.</_>
+        <_>
+          12 19 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 4 9 -1.</_>
+        <_>
+          3 2 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 4 -1.</_>
+        <_>
+          9 5 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 4 -1.</_>
+        <_>
+          9 6 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 5 2 8 -1.</_>
+        <_>
+          14 9 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 5 12 -1.</_>
+        <_>
+          7 12 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 2 6 -1.</_>
+        <_>
+          14 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 6 2 6 -1.</_>
+        <_>
+          4 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 10 4 -1.</_>
+        <_>
+          13 15 5 2 2.</_>
+        <_>
+          8 17 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 18 2 2 -1.</_>
+        <_>
+          7 18 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 6 2 -1.</_>
+        <_>
+          11 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 16 6 -1.</_>
+        <_>
+          2 2 16 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 6 2 -1.</_>
+        <_>
+          11 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 10 3 -1.</_>
+        <_>
+          4 12 10 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 6 2 -1.</_>
+        <_>
+          11 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 3 6 2 -1.</_>
+        <_>
+          3 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 7 -1.</_>
+        <_>
+          16 0 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 9 6 -1.</_>
+        <_>
+          0 16 9 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 3 3 -1.</_>
+        <_>
+          9 17 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 6 6 2 -1.</_>
+        <_>
+          6 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 1 3 -1.</_>
+        <_>
+          15 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 3 -1.</_>
+        <_>
+          5 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 9 2 2 -1.</_>
+        <_>
+          10 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 4 3 -1.</_>
+        <_>
+          5 1 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 7 -1.</_>
+        <_>
+          16 0 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 20 1 -1.</_>
+        <_>
+          10 0 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 1 3 -1.</_>
+        <_>
+          15 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 3 4 -1.</_>
+        <_>
+          1 4 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 6 -1.</_>
+        <_>
+          16 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 3 3 6 -1.</_>
+        <_>
+          1 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 2 12 6 -1.</_>
+        <_>
+          12 2 6 3 2.</_>
+        <_>
+          6 5 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 4 3 -1.</_>
+        <_>
+          8 11 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 14 6 -1.</_>
+        <_>
+          11 2 7 3 2.</_>
+        <_>
+          4 5 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 3 -1.</_>
+        <_>
+          15 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 3 -1.</_>
+        <_>
+          8 13 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 1 3 -1.</_>
+        <_>
+          15 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 5 2 -1.</_>
+        <_>
+          7 14 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 6 3 -1.</_>
+        <_>
+          7 13 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 4 4 -1.</_>
+        <_>
+          5 13 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 3 3 -1.</_>
+        <_>
+          12 4 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 3 3 -1.</_>
+        <_>
+          7 4 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 5 3 6 -1.</_>
+        <_>
+          17 5 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 12 7 -1.</_>
+        <_>
+          7 6 4 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 5 3 6 -1.</_>
+        <_>
+          17 5 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 2 3 -1.</_>
+        <_>
+          3 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 5 3 6 -1.</_>
+        <_>
+          17 5 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 5 3 6 -1.</_>
+        <_>
+          2 5 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 18 1 -1.</_>
+        <_>
+          7 9 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 8 7 -1.</_>
+        <_>
+          4 9 4 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 11 8 2 -1.</_>
+        <_>
+          12 12 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 11 8 2 -1.</_>
+        <_>
+          0 12 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 2 3 -1.</_>
+        <_>
+          9 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 10 12 4 -1.</_>
+        <_>
+          4 10 6 2 2.</_>
+        <_>
+          10 12 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 3 7 -1.</_>
+        <_>
+          10 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 3 5 -1.</_>
+        <_>
+          8 2 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 4 6 -1.</_>
+        <_>
+          11 12 2 3 2.</_>
+        <_>
+          9 15 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 6 -1.</_>
+        <_>
+          9 7 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 4 4 2 -1.</_>
+        <_>
+          15 5 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          9 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 4 -1.</_>
+        <_>
+          14 4 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 16 6 1 -1.</_>
+        <_>
+          9 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 3 -1.</_>
+        <_>
+          15 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 10 -1.</_>
+        <_>
+          9 7 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 2 6 -1.</_>
+        <_>
+          11 12 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 4 1 -1.</_>
+        <_>
+          8 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 9 2 2 -1.</_>
+        <_>
+          10 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 2 2 -1.</_>
+        <_>
+          8 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 2 2 -1.</_>
+        <_>
+          13 7 1 1 2.</_>
+        <_>
+          12 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 2 2 -1.</_>
+        <_>
+          5 7 1 1 2.</_>
+        <_>
+          6 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 3 14 -1.</_>
+        <_>
+          14 0 1 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 3 14 -1.</_>
+        <_>
+          5 0 1 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 3 14 -1.</_>
+        <_>
+          14 4 1 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 3 16 -1.</_>
+        <_>
+          5 2 1 16 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 8 10 -1.</_>
+        <_>
+          7 7 8 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 14 7 3 -1.</_>
+        <_>
+          6 15 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 2 10 12 -1.</_>
+        <_>
+          14 2 5 6 2.</_>
+        <_>
+          9 8 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 8 2 -1.</_>
+        <_>
+          6 8 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 6 -1.</_>
+        <_>
+          8 16 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 1 3 -1.</_>
+        <_>
+          6 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 2 4 6 -1.</_>
+        <_>
+          16 4 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 4 2 -1.</_>
+        <_>
+          6 6 2 1 2.</_>
+        <_>
+          8 7 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 2 4 6 -1.</_>
+        <_>
+          16 4 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 4 6 -1.</_>
+        <_>
+          0 4 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 6 -1.</_>
+        <_>
+          9 6 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 6 10 -1.</_>
+        <_>
+          3 9 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 6 -1.</_>
+        <_>
+          9 5 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 2 3 -1.</_>
+        <_>
+          3 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 13 3 2 -1.</_>
+        <_>
+          13 14 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 10 4 -1.</_>
+        <_>
+          2 16 5 2 2.</_>
+        <_>
+          7 18 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 10 6 -1.</_>
+        <_>
+          10 6 5 3 2.</_>
+        <_>
+          5 9 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 1 3 -1.</_>
+        <_>
+          7 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 16 6 3 -1.</_>
+        <_>
+          14 17 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 10 3 -1.</_>
+        <_>
+          7 5 10 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 5 4 -1.</_>
+        <_>
+          0 6 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 3 9 -1.</_>
+        <_>
+          13 14 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 3 9 -1.</_>
+        <_>
+          4 14 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 1 -1.</_>
+        <_>
+          9 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 6 17 -1.</_>
+        <_>
+          7 0 2 17 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 6 3 -1.</_>
+        <_>
+          10 3 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 15 4 -1.</_>
+        <_>
+          7 2 5 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 8 2 -1.</_>
+        <_>
+          12 2 4 1 2.</_>
+        <_>
+          8 3 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 3 6 -1.</_>
+        <_>
+          8 3 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 2 2 -1.</_>
+        <_>
+          9 18 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 2 14 -1.</_>
+        <_>
+          1 0 1 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 7 3 -1.</_>
+        <_>
+          12 1 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 1 2 -1.</_>
+        <_>
+          1 15 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 2 8 -1.</_>
+        <_>
+          15 12 1 4 2.</_>
+        <_>
+          14 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 7 3 -1.</_>
+        <_>
+          1 1 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 2 8 -1.</_>
+        <_>
+          15 12 1 4 2.</_>
+        <_>
+          14 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 12 -1.</_>
+        <_>
+          6 0 4 6 2.</_>
+        <_>
+          10 6 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 8 9 -1.</_>
+        <_>
+          6 4 8 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 2 2 -1.</_>
+        <_>
+          5 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 6 6 -1.</_>
+        <_>
+          16 14 3 3 2.</_>
+        <_>
+          13 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 17 20 2 -1.</_>
+        <_>
+          0 17 10 1 2.</_>
+        <_>
+          10 18 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 2 6 -1.</_>
+        <_>
+          11 3 1 3 2.</_>
+        <_>
+          10 6 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 6 2 -1.</_>
+        <_>
+          8 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 6 13 -1.</_>
+        <_>
+          10 7 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 15 10 5 -1.</_>
+        <_>
+          10 15 5 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 4 4 10 -1.</_>
+        <_>
+          10 4 2 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 2 1 -1.</_>
+        <_>
+          6 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 6 7 -1.</_>
+        <_>
+          10 3 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 6 7 -1.</_>
+        <_>
+          7 3 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 18 5 -1.</_>
+        <_>
+          7 7 6 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 17 4 3 -1.</_>
+        <_>
+          5 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 12 6 -1.</_>
+        <_>
+          14 14 6 3 2.</_>
+        <_>
+          8 17 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 20 4 -1.</_>
+        <_>
+          0 13 10 2 2.</_>
+        <_>
+          10 15 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 14 2 -1.</_>
+        <_>
+          11 5 7 1 2.</_>
+        <_>
+          4 6 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 10 12 -1.</_>
+        <_>
+          1 2 5 6 2.</_>
+        <_>
+          6 8 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 14 3 -1.</_>
+        <_>
+          6 2 14 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 16 2 3 -1.</_>
+        <_>
+          8 17 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 2 -1.</_>
+        <_>
+          10 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 15 4 2 -1.</_>
+        <_>
+          5 15 2 1 2.</_>
+        <_>
+          7 16 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 15 1 3 -1.</_>
+        <_>
+          10 16 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 16 4 4 -1.</_>
+        <_>
+          8 16 2 2 2.</_>
+        <_>
+          10 18 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 8 6 -1.</_>
+        <_>
+          6 14 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 13 5 2 -1.</_>
+        <_>
+          2 14 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 6 6 -1.</_>
+        <_>
+          16 14 3 3 2.</_>
+        <_>
+          13 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 18 4 -1.</_>
+        <_>
+          7 9 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 6 6 -1.</_>
+        <_>
+          16 14 3 3 2.</_>
+        <_>
+          13 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 1 6 -1.</_>
+        <_>
+          0 4 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 15 20 -1.</_>
+        <_>
+          5 10 15 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 6 6 -1.</_>
+        <_>
+          1 14 3 3 2.</_>
+        <_>
+          4 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 6 -1.</_>
+        <_>
+          10 14 2 3 2.</_>
+        <_>
+          8 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 2 1 -1.</_>
+        <_>
+          8 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 2 -1.</_>
+        <_>
+          10 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 3 2 -1.</_>
+        <_>
+          9 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 14 4 6 -1.</_>
+        <_>
+          14 14 2 3 2.</_>
+        <_>
+          12 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 4 6 -1.</_>
+        <_>
+          4 14 2 3 2.</_>
+        <_>
+          6 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 2 6 -1.</_>
+        <_>
+          14 14 1 3 2.</_>
+        <_>
+          13 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 14 2 6 -1.</_>
+        <_>
+          5 14 1 3 2.</_>
+        <_>
+          6 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 12 -1.</_>
+        <_>
+          7 4 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 12 2 -1.</_>
+        <_>
+          4 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 3 13 -1.</_>
+        <_>
+          11 3 1 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 3 13 -1.</_>
+        <_>
+          8 3 1 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 6 3 -1.</_>
+        <_>
+          10 9 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 3 2 -1.</_>
+        <_>
+          4 11 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 12 6 8 -1.</_>
+        <_>
+          16 12 3 4 2.</_>
+        <_>
+          13 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 5 -1.</_>
+        <_>
+          9 6 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 11 2 7 -1.</_>
+        <_>
+          17 11 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 8 2 -1.</_>
+        <_>
+          7 13 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 8 3 -1.</_>
+        <_>
+          6 10 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 4 3 -1.</_>
+        <_>
+          4 4 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 4 3 -1.</_>
+        <_>
+          11 4 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 17 12 -1.</_>
+        <_>
+          1 8 17 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 4 3 -1.</_>
+        <_>
+          11 4 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 8 6 3 -1.</_>
+        <_>
+          4 9 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 5 3 -1.</_>
+        <_>
+          12 4 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 2 7 -1.</_>
+        <_>
+          2 11 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 12 2 8 -1.</_>
+        <_>
+          16 12 1 4 2.</_>
+        <_>
+          15 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 8 11 3 -1.</_>
+        <_>
+          4 9 11 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 6 2 -1.</_>
+        <_>
+          12 13 3 1 2.</_>
+        <_>
+          9 14 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 13 4 3 -1.</_>
+        <_>
+          6 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 3 3 -1.</_>
+        <_>
+          10 12 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 3 3 -1.</_>
+        <_>
+          5 4 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 3 -1.</_>
+        <_>
+          9 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 16 3 -1.</_>
+        <_>
+          0 3 16 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 12 2 8 -1.</_>
+        <_>
+          16 12 1 4 2.</_>
+        <_>
+          15 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 2 8 -1.</_>
+        <_>
+          3 12 1 4 2.</_>
+        <_>
+          4 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 13 3 6 -1.</_>
+        <_>
+          14 15 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 3 6 -1.</_>
+        <_>
+          3 15 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 10 2 -1.</_>
+        <_>
+          11 5 5 1 2.</_>
+        <_>
+          6 6 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 14 14 6 -1.</_>
+        <_>
+          2 17 14 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 1 3 -1.</_>
+        <_>
+          10 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 16 2 2 -1.</_>
+        <_>
+          4 16 1 1 2.</_>
+        <_>
+          5 17 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 2 3 -1.</_>
+        <_>
+          10 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 17 20 2 -1.</_>
+        <_>
+          0 17 10 1 2.</_>
+        <_>
+          10 18 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 6 1 3 -1.</_>
+        <_>
+          13 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 3 2 -1.</_>
+        <_>
+          9 13 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 3 3 -1.</_>
+        <_>
+          13 2 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 18 2 2 -1.</_>
+        <_>
+          3 18 1 1 2.</_>
+        <_>
+          4 19 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 3 4 -1.</_>
+        <_>
+          10 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 1 3 -1.</_>
+        <_>
+          6 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 1 5 2 -1.</_>
+        <_>
+          13 2 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 6 2 -1.</_>
+        <_>
+          7 14 3 1 2.</_>
+        <_>
+          10 15 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 3 4 -1.</_>
+        <_>
+          12 3 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 13 12 6 -1.</_>
+        <_>
+          5 13 4 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 11 5 2 -1.</_>
+        <_>
+          14 12 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 15 14 4 -1.</_>
+        <_>
+          2 15 7 2 2.</_>
+        <_>
+          9 17 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 14 2 -1.</_>
+        <_>
+          10 7 7 1 2.</_>
+        <_>
+          3 8 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 4 2 -1.</_>
+        <_>
+          1 12 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 14 -1.</_>
+        <_>
+          16 0 2 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 1 3 -1.</_>
+        <_>
+          4 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 14 -1.</_>
+        <_>
+          16 0 2 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 3 7 -1.</_>
+        <_>
+          2 10 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 9 2 -1.</_>
+        <_>
+          8 13 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 20 1 -1.</_>
+        <_>
+          10 6 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 4 4 4 -1.</_>
+        <_>
+          8 4 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 2 2 -1.</_>
+        <_>
+          0 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 10 9 -1.</_>
+        <_>
+          5 6 10 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 2 4 10 -1.</_>
+        <_>
+          15 2 2 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 2 7 -1.</_>
+        <_>
+          9 2 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 12 1 -1.</_>
+        <_>
+          11 4 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 9 1 -1.</_>
+        <_>
+          6 4 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 10 1 4 -1.</_>
+        <_>
+          15 12 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 10 6 4 -1.</_>
+        <_>
+          7 10 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 9 1 6 -1.</_>
+        <_>
+          15 12 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 17 6 3 -1.</_>
+        <_>
+          7 18 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 2 16 -1.</_>
+        <_>
+          15 3 1 8 2.</_>
+        <_>
+          14 11 1 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 1 6 -1.</_>
+        <_>
+          4 12 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 1 5 2 -1.</_>
+        <_>
+          12 2 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 18 4 2 -1.</_>
+        <_>
+          6 18 2 1 2.</_>
+        <_>
+          8 19 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 4 16 10 -1.</_>
+        <_>
+          10 4 8 5 2.</_>
+        <_>
+          2 9 8 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 1 10 -1.</_>
+        <_>
+          6 10 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 8 15 2 -1.</_>
+        <_>
+          9 8 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 15 2 -1.</_>
+        <_>
+          6 8 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 3 6 -1.</_>
+        <_>
+          9 7 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 8 2 -1.</_>
+        <_>
+          9 7 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 16 3 -1.</_>
+        <_>
+          1 1 16 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 7 2 -1.</_>
+        <_>
+          11 3 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 10 18 -1.</_>
+        <_>
+          5 7 10 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 4 3 2 -1.</_>
+        <_>
+          18 4 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 1 3 -1.</_>
+        <_>
+          8 14 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 14 6 -1.</_>
+        <_>
+          3 16 14 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 4 -1.</_>
+        <_>
+          1 2 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 1 5 2 -1.</_>
+        <_>
+          12 2 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 5 2 -1.</_>
+        <_>
+          3 2 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 13 2 3 -1.</_>
+        <_>
+          10 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 2 3 -1.</_>
+        <_>
+          8 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 2 3 -1.</_>
+        <_>
+          14 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 2 3 -1.</_>
+        <_>
+          7 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 10 4 -1.</_>
+        <_>
+          10 6 5 2 2.</_>
+        <_>
+          5 8 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 1 6 -1.</_>
+        <_>
+          9 16 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 2 2 -1.</_>
+        <_>
+          11 12 1 1 2.</_>
+        <_>
+          10 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 3 -1.</_>
+        <_>
+          4 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 4 6 6 -1.</_>
+        <_>
+          14 6 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 2 3 -1.</_>
+        <_>
+          8 18 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 4 4 6 -1.</_>
+        <_>
+          16 6 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 4 6 -1.</_>
+        <_>
+          0 6 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 2 3 -1.</_>
+        <_>
+          14 6 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 8 1 -1.</_>
+        <_>
+          8 9 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 3 -1.</_>
+        <_>
+          8 13 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 10 6 -1.</_>
+        <_>
+          5 14 10 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 12 1 2 -1.</_>
+        <_>
+          11 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 2 -1.</_>
+        <_>
+          8 16 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 8 8 -1.</_>
+        <_>
+          10 9 4 4 2.</_>
+        <_>
+          6 13 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 4 6 -1.</_>
+        <_>
+          7 12 2 3 2.</_>
+        <_>
+          9 15 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 3 1 -1.</_>
+        <_>
+          11 11 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 10 -1.</_>
+        <_>
+          9 7 1 5 2.</_>
+        <_>
+          10 12 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 6 6 -1.</_>
+        <_>
+          10 0 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 2 6 -1.</_>
+        <_>
+          3 13 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 12 1 2 -1.</_>
+        <_>
+          16 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 6 6 -1.</_>
+        <_>
+          1 14 3 3 2.</_>
+        <_>
+          4 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 1 3 6 -1.</_>
+        <_>
+          14 1 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 2 2 -1.</_>
+        <_>
+          8 9 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 3 3 -1.</_>
+        <_>
+          10 9 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          8 8 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 2 3 -1.</_>
+        <_>
+          14 0 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 9 -1.</_>
+        <_>
+          7 0 6 9 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 5 4 15 -1.</_>
+        <_>
+          11 5 2 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 4 15 -1.</_>
+        <_>
+          7 5 2 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 2 3 -1.</_>
+        <_>
+          14 0 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 2 3 -1.</_>
+        <_>
+          5 0 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 12 2 2 -1.</_>
+        <_>
+          12 12 1 1 2.</_>
+        <_>
+          11 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 2 2 -1.</_>
+        <_>
+          7 12 1 1 2.</_>
+        <_>
+          8 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 3 4 -1.</_>
+        <_>
+          13 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 3 3 -1.</_>
+        <_>
+          4 12 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 4 2 -1.</_>
+        <_>
+          12 8 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 3 2 -1.</_>
+        <_>
+          9 10 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 3 2 -1.</_>
+        <_>
+          10 9 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 3 2 -1.</_>
+        <_>
+          9 9 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 3 4 -1.</_>
+        <_>
+          13 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 3 4 -1.</_>
+        <_>
+          6 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 12 4 -1.</_>
+        <_>
+          10 14 6 2 2.</_>
+        <_>
+          4 16 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 2 3 -1.</_>
+        <_>
+          8 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 10 3 8 -1.</_>
+        <_>
+          10 14 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 4 8 -1.</_>
+        <_>
+          8 10 2 4 2.</_>
+        <_>
+          10 14 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 3 1 -1.</_>
+        <_>
+          11 8 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 1 6 -1.</_>
+        <_>
+          9 15 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 3 1 -1.</_>
+        <_>
+          11 8 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 3 1 -1.</_>
+        <_>
+          8 8 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 15 14 -1.</_>
+        <_>
+          5 9 15 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 2 10 -1.</_>
+        <_>
+          2 1 1 5 2.</_>
+        <_>
+          3 6 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 14 2 3 -1.</_>
+        <_>
+          14 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 7 3 3 -1.</_>
+        <_>
+          3 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 4 3 3 -1.</_>
+        <_>
+          17 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 3 3 -1.</_>
+        <_>
+          0 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 6 2 -1.</_>
+        <_>
+          16 5 3 1 2.</_>
+        <_>
+          13 6 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 19 12 1 -1.</_>
+        <_>
+          8 19 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 12 2 4 -1.</_>
+        <_>
+          12 14 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 15 1 3 -1.</_>
+        <_>
+          3 16 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 16 6 4 -1.</_>
+        <_>
+          11 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 10 3 10 -1.</_>
+        <_>
+          3 10 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 8 2 4 -1.</_>
+        <_>
+          12 8 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 8 2 4 -1.</_>
+        <_>
+          7 8 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 2 3 -1.</_>
+        <_>
+          10 14 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 10 3 -1.</_>
+        <_>
+          10 1 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 3 2 -1.</_>
+        <_>
+          11 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 9 2 -1.</_>
+        <_>
+          8 6 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 2 -1.</_>
+        <_>
+          9 9 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 16 6 -1.</_>
+        <_>
+          2 11 8 3 2.</_>
+        <_>
+          10 14 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 2 2 -1.</_>
+        <_>
+          13 7 1 1 2.</_>
+        <_>
+          12 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 3 -1.</_>
+        <_>
+          9 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 2 -1.</_>
+        <_>
+          10 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 8 12 -1.</_>
+        <_>
+          5 7 8 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 2 -1.</_>
+        <_>
+          13 6 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 2 -1.</_>
+        <_>
+          5 6 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 2 3 -1.</_>
+        <_>
+          4 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 6 -1.</_>
+        <_>
+          10 14 1 3 2.</_>
+        <_>
+          9 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 3 2 -1.</_>
+        <_>
+          9 14 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 6 -1.</_>
+        <_>
+          11 5 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 6 6 -1.</_>
+        <_>
+          7 5 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 13 1 2 -1.</_>
+        <_>
+          13 14 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 10 2 -1.</_>
+        <_>
+          0 3 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 13 1 2 -1.</_>
+        <_>
+          13 14 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 2 2 -1.</_>
+        <_>
+          5 7 1 1 2.</_>
+        <_>
+          6 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 7 -1.</_>
+        <_>
+          13 5 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 13 1 2 -1.</_>
+        <_>
+          6 14 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 7 -1.</_>
+        <_>
+          12 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 2 16 -1.</_>
+        <_>
+          0 3 1 8 2.</_>
+        <_>
+          1 11 1 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 7 -1.</_>
+        <_>
+          12 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 7 -1.</_>
+        <_>
+          7 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 16 8 4 -1.</_>
+        <_>
+          11 16 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 16 8 4 -1.</_>
+        <_>
+          5 16 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 7 -1.</_>
+        <_>
+          13 5 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 7 -1.</_>
+        <_>
+          6 5 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 6 2 14 -1.</_>
+        <_>
+          18 13 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 3 4 -1.</_>
+        <_>
+          6 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 7 1 2 -1.</_>
+        <_>
+          14 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 18 6 -1.</_>
+        <_>
+          0 1 9 3 2.</_>
+        <_>
+          9 4 9 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 7 1 2 -1.</_>
+        <_>
+          14 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 2 14 -1.</_>
+        <_>
+          0 13 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 0 3 12 -1.</_>
+        <_>
+          18 0 1 12 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 18 3 -1.</_>
+        <_>
+          0 7 18 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 14 16 -1.</_>
+        <_>
+          6 8 14 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 3 12 -1.</_>
+        <_>
+          1 0 1 12 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 3 7 -1.</_>
+        <_>
+          14 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 1 2 -1.</_>
+        <_>
+          5 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 4 6 6 -1.</_>
+        <_>
+          14 6 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 7 2 -1.</_>
+        <_>
+          5 8 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 6 9 -1.</_>
+        <_>
+          8 9 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 6 1 -1.</_>
+        <_>
+          7 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 6 4 -1.</_>
+        <_>
+          16 0 3 2 2.</_>
+        <_>
+          13 2 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 18 12 -1.</_>
+        <_>
+          1 6 18 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 17 12 -1.</_>
+        <_>
+          3 6 17 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 14 7 3 -1.</_>
+        <_>
+          5 15 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 1 3 -1.</_>
+        <_>
+          10 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 3 3 -1.</_>
+        <_>
+          3 15 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 4 6 6 -1.</_>
+        <_>
+          14 6 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 6 6 -1.</_>
+        <_>
+          0 6 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 4 3 -1.</_>
+        <_>
+          4 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 0 2 6 -1.</_>
+        <_>
+          18 2 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 4 9 -1.</_>
+        <_>
+          10 1 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 8 2 -1.</_>
+        <_>
+          6 6 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 4 2 -1.</_>
+        <_>
+          6 5 2 1 2.</_>
+        <_>
+          8 6 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 5 2 3 -1.</_>
+        <_>
+          10 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 1 3 -1.</_>
+        <_>
+          9 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 10 2 2 -1.</_>
+        <_>
+          9 11 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 4 3 -1.</_>
+        <_>
+          0 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 6 -1.</_>
+        <_>
+          6 3 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 6 4 -1.</_>
+        <_>
+          1 0 3 2 2.</_>
+        <_>
+          4 2 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 3 7 -1.</_>
+        <_>
+          14 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 2 2 -1.</_>
+        <_>
+          9 17 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 6 10 -1.</_>
+        <_>
+          11 9 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 19 2 -1.</_>
+        <_>
+          0 11 19 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 8 9 -1.</_>
+        <_>
+          9 8 8 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 3 7 -1.</_>
+        <_>
+          5 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 4 12 -1.</_>
+        <_>
+          10 6 2 6 2.</_>
+        <_>
+          8 12 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 6 4 -1.</_>
+        <_>
+          0 4 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 3 7 -1.</_>
+        <_>
+          9 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 3 4 -1.</_>
+        <_>
+          10 5 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 5 3 4 -1.</_>
+        <_>
+          9 5 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 1 -1.</_>
+        <_>
+          9 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 4 4 -1.</_>
+        <_>
+          7 14 2 2 2.</_>
+        <_>
+          9 16 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 4 6 -1.</_>
+        <_>
+          15 14 2 3 2.</_>
+        <_>
+          13 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 1 8 -1.</_>
+        <_>
+          7 12 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 2 8 -1.</_>
+        <_>
+          17 0 1 4 2.</_>
+        <_>
+          16 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 2 8 -1.</_>
+        <_>
+          2 0 1 4 2.</_>
+        <_>
+          3 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 14 3 -1.</_>
+        <_>
+          6 2 14 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 9 3 10 -1.</_>
+        <_>
+          7 14 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 2 -1.</_>
+        <_>
+          9 15 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 8 -1.</_>
+        <_>
+          7 11 6 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 6 -1.</_>
+        <_>
+          9 10 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 3 3 -1.</_>
+        <_>
+          7 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 18 2 -1.</_>
+        <_>
+          6 1 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 14 -1.</_>
+        <_>
+          7 8 6 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 18 1 -1.</_>
+        <_>
+          7 9 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 2 -1.</_>
+        <_>
+          9 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 2 9 -1.</_>
+        <_>
+          10 3 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 14 2 3 -1.</_>
+        <_>
+          18 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 3 1 -1.</_>
+        <_>
+          8 11 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 3 4 -1.</_>
+        <_>
+          11 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 3 6 -1.</_>
+        <_>
+          8 14 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 3 4 -1.</_>
+        <_>
+          11 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 3 4 -1.</_>
+        <_>
+          8 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 9 6 9 -1.</_>
+        <_>
+          7 12 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 2 3 -1.</_>
+        <_>
+          0 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 12 1 2 -1.</_>
+        <_>
+          11 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 8 3 -1.</_>
+        <_>
+          8 3 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 20 6 -1.</_>
+        <_>
+          0 4 10 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 1 3 -1.</_>
+        <_>
+          9 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 14 4 -1.</_>
+        <_>
+          0 17 14 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 18 6 -1.</_>
+        <_>
+          1 17 18 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 10 6 -1.</_>
+        <_>
+          0 0 5 3 2.</_>
+        <_>
+          5 3 5 3 2.</_></rects></_></features></cascade>
+</opencv_storage>
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/FaceDetection.vcxproj b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/FaceDetection.vcxproj
new file mode 100644
index 00000000..46004ece
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/FaceDetection.vcxproj
@@ -0,0 +1,199 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{0fae44e0-6c15-4cca-abda-29556b391390}</ProjectGuid>
+    <RootNamespace>FaceDetection</RootNamespace>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>12.0</MinimumVisualStudioVersion>
+    <AppContainerApplication>true</AppContainerApplication>
+    <ApplicationType>Windows Store</ApplicationType>
+    <ApplicationTypeRevision>8.1</ApplicationTypeRevision>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <PackageCertificateKeyFile>FaceDetection_TemporaryKey.pfx</PackageCertificateKeyFile>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>opencv_objdetect300$(DebugSuffix).lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>opencv_objdetect300$(DebugSuffix).lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="App.xaml.h">
+      <DependentUpon>App.xaml</DependentUpon>
+    </ClInclude>
+    <ClInclude Include="MainPage.xaml.h">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+    <Page Include="MainPage.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest">
+      <SubType>Designer</SubType>
+    </AppxManifest>
+    <None Include="FaceDetection_TemporaryKey.pfx" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\group1.jpg" />
+    <Image Include="Assets\group2.JPG" />
+    <Image Include="Assets\group3.jpg" />
+    <Image Include="Assets\Logo.scale-100.png" />
+    <Image Include="Assets\SmallLogo.scale-100.png" />
+    <Image Include="Assets\StoreLogo.scale-100.png" />
+    <Image Include="Assets\SplashScreen.scale-100.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="App.xaml.cpp">
+      <DependentUpon>App.xaml</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="MainPage.xaml.cpp">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Xml Include="Assets\haarcascade_frontalface_alt.xml" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/FaceDetection.vcxproj.filters b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/FaceDetection.vcxproj.filters
new file mode 100644
index 00000000..8618e23e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/FaceDetection.vcxproj.filters
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Common">
+      <UniqueIdentifier>0fae44e0-6c15-4cca-abda-29556b391390</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Assets">
+      <UniqueIdentifier>cee6a8fd-c14c-4eab-b410-54073b7fc217</UniqueIdentifier>
+      <Extensions>bmp;fbx;gif;jpg;jpeg;tga;tiff;tif;png</Extensions>
+    </Filter>
+    <Image Include="Assets\Logo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SmallLogo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\StoreLogo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SplashScreen.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="App.xaml.cpp" />
+    <ClCompile Include="MainPage.xaml.cpp" />
+    <ClCompile Include="pch.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="App.xaml.h" />
+    <ClInclude Include="MainPage.xaml.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="FaceDetection_TemporaryKey.pfx" />
+    <None Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll" />
+    <None Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll" />
+    <None Include="$(OpenCV_Bin)opencv_features2d300$(DebugSuffix).dll" />
+    <None Include="$(OpenCV_Bin)opencv_flann300$(DebugSuffix).dll" />
+    <None Include="$(OpenCV_Bin)opencv_ml300$(DebugSuffix).dll" />
+    <None Include="$(OpenCV_Bin)opencv_objdetect300$(DebugSuffix).dll" />
+    <None Include="$(OpenCV_Bin)opencv_imgcodecs300$(DebugSuffix).dll" />
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="MainPage.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\group1.jpg">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\group2.JPG">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\group3.jpg">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+  <ItemGroup>
+    <Xml Include="Assets\haarcascade_frontalface_alt.xml">
+      <Filter>Assets</Filter>
+    </Xml>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/FaceDetection_TemporaryKey.pfx b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/FaceDetection_TemporaryKey.pfx
new file mode 100644
index 00000000..b56e03f3
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/FaceDetection_TemporaryKey.pfx differ
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/MainPage.xaml b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/MainPage.xaml
new file mode 100644
index 00000000..31c6ba8a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/MainPage.xaml
@@ -0,0 +1,34 @@
+<Page x:Class="FaceDetection.MainPage"
+      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+      xmlns:local="using:FaceDetection"
+      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+      mc:Ignorable="d">
+
+    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
+        <Button x:Name="InitBtn"
+                Width="218"
+                Height="67"
+                Margin="69,81,0,0"
+                HorizontalAlignment="Left"
+                VerticalAlignment="Top"
+                Click="InitBtn_Click"
+                Content="Initialize" />
+        <Button x:Name="detectBtn"
+                Width="218"
+                Height="67"
+                Margin="69,168,0,0"
+                HorizontalAlignment="Left"
+                VerticalAlignment="Top"
+                Click="detectBtn_Click"
+                Content="Detect Faces" />
+        <StackPanel x:Name="cvContainer"
+                    Width="883"
+                    Height="446"
+                    Margin="354,84,0,0"
+                    HorizontalAlignment="Left"
+                    VerticalAlignment="Top" />
+
+    </Grid>
+</Page>
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/MainPage.xaml.cpp b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/MainPage.xaml.cpp
new file mode 100644
index 00000000..a7f23ade
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/MainPage.xaml.cpp
@@ -0,0 +1,81 @@
+//
+// MainPage.xaml.cpp
+// Implementation of the MainPage class.
+//
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+
+#include <opencv2\imgproc\types_c.h>
+#include <opencv2\imgcodecs.hpp>
+#include <opencv2\core.hpp>
+#include <opencv2\imgproc.hpp>
+#include <opencv2\highgui.hpp>
+#include <opencv2\highgui\highgui_winrt.hpp>
+
+#include <Robuffer.h>
+
+using namespace FaceDetection;
+
+using namespace Platform;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Controls::Primitives;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Navigation;
+
+using namespace Windows::UI::Xaml::Media::Imaging;
+using namespace Windows::Storage::Streams;
+using namespace Microsoft::WRL;
+
+
+// Name of the resource classifier used to detect human faces (frontal)
+cv::String face_cascade_name = "Assets/haarcascade_frontalface_alt.xml";
+cv::String window_name = "Faces";
+
+MainPage::MainPage()
+{
+    InitializeComponent();
+}
+
+void FaceDetection::MainPage::InitBtn_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
+{
+    // load Image and Init recognizer
+    cv::Mat image = cv::imread("Assets/group1.jpg");
+    groupFaces = cv::Mat(image.rows, image.cols, CV_8UC4);
+    cv::cvtColor(image, groupFaces, COLOR_BGR2BGRA);
+    cv::winrt_initContainer(cvContainer);
+    cv::imshow(window_name, groupFaces);
+
+    if (!face_cascade.load(face_cascade_name)) {
+        Windows::UI::Popups::MessageDialog("Couldn't load face detector \n").ShowAsync();
+    }
+}
+
+
+void FaceDetection::MainPage::detectBtn_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
+{
+    if (!groupFaces.empty()) {
+        std::vector<cv::Rect> facesColl;
+        cv::Mat frame_gray;
+
+        cvtColor(groupFaces, frame_gray, COLOR_BGR2GRAY);
+        cv::equalizeHist(frame_gray, frame_gray);
+
+        // Detect faces
+        face_cascade.detectMultiScale(frame_gray, facesColl, 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, cv::Size(1, 1));
+        for (unsigned int i = 0; i < facesColl.size(); i++)
+        {
+            auto face = facesColl[i];
+            cv::rectangle(groupFaces, face, cv::Scalar(0, 255, 255), 5);
+        }
+
+        cv::imshow(window_name, groupFaces);
+    } else {
+        Windows::UI::Popups::MessageDialog("Initialize image before processing \n").ShowAsync();
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/MainPage.xaml.h b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/MainPage.xaml.h
new file mode 100644
index 00000000..034fffd5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/MainPage.xaml.h
@@ -0,0 +1,32 @@
+//
+// MainPage.xaml.h
+// Declaration of the MainPage class.
+//
+
+#pragma once
+
+#include "MainPage.g.h"
+#include <opencv2\core\core.hpp>
+#include <opencv2\objdetect.hpp>
+
+
+namespace FaceDetection
+{
+    /// <summary>
+    /// An empty page that can be used on its own or navigated to within a Frame.
+    /// </summary>
+    public ref class MainPage sealed
+    {
+    public:
+        MainPage();
+
+    private:
+        void InitBtn_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+        void detectBtn_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+
+    private:
+        cv::Mat groupFaces;
+        void UpdateImage(const cv::Mat& image);
+        cv::CascadeClassifier face_cascade;
+    };
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Package.appxmanifest b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Package.appxmanifest
new file mode 100644
index 00000000..3584efca
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/Package.appxmanifest
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest" xmlns:m2="http://schemas.microsoft.com/appx/2013/manifest">
+
+  <Identity Name="f8308285-aea6-41b1-a76e-9954cfd46c7e"
+            Publisher="CN=ericmitt"
+            Version="1.0.0.0" />
+
+  <Properties>
+    <DisplayName>FaceDetection</DisplayName>
+    <PublisherDisplayName>ericmitt</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+
+  <Prerequisites>
+    <OSMinVersion>6.3.0</OSMinVersion>
+    <OSMaxVersionTested>6.3.0</OSMaxVersionTested>
+  </Prerequisites>
+
+  <Resources>
+    <Resource Language="x-generate"/>
+  </Resources>
+
+  <Applications>
+    <Application Id="App"
+        Executable="$targetnametoken$.exe"
+        EntryPoint="FaceDetection.App">
+        <m2:VisualElements
+            DisplayName="FaceDetection"
+            Square150x150Logo="Assets\Logo.png"
+            Square30x30Logo="Assets\SmallLogo.png"
+            Description="FaceDetection"
+            ForegroundText="light"
+            BackgroundColor="#464646">
+            <m2:SplashScreen Image="Assets\SplashScreen.png" />
+        </m2:VisualElements>
+    </Application>
+  </Applications>
+  <Capabilities>
+    <Capability Name="internetClient" />
+  </Capabilities>
+</Package>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/opencv.props b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/opencv.props
new file mode 100644
index 00000000..435f7359
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/opencv.props
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros">
+    <Runtime Condition="'$(ApplicationType)'=='Windows Phone'">WP</Runtime>
+    <Runtime Condition="'$(ApplicationType)'=='Windows Store'">WS</Runtime>
+    <OpenCV_Bin>$(OPENCV_WINRT_INSTALL_DIR)\$(Runtime)\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\bin\</OpenCV_Bin>
+    <OpenCV_Lib>$(OPENCV_WINRT_INSTALL_DIR)\$(Runtime)\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\lib\</OpenCV_Lib>
+    <OpenCV_Include>$(OPENCV_WINRT_INSTALL_DIR)\$(Runtime)\8.1\$(PlatformTarget)\include\</OpenCV_Include>
+    <!--debug suffix for OpenCV dlls and libs -->
+    <DebugSuffix Condition="'$(Configuration)'=='Debug'">d</DebugSuffix>
+    <DebugSuffix Condition="'$(Configuration)'!='Debug'"></DebugSuffix>
+  </PropertyGroup>
+  <ItemGroup>
+    <!--Add required OpenCV dlls here-->
+    <None Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgcodecs300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_features2d300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_flann300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_ml300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_objdetect300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_videoio300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_highgui300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+  </ItemGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(OpenCV_Include);%(AdditionalIncludeDirectories);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <!--Add required OpenCV libs here-->
+      <AdditionalDependencies>opencv_core300$(DebugSuffix).lib;opencv_imgproc300$(DebugSuffix).lib;opencv_imgcodecs300$(DebugSuffix).lib;opencv_flann300$(DebugSuffix).lib;opencv_videoio300$(DebugSuffix).lib;opencv_features2d300$(DebugSuffix).lib;opencv_objdetect300$(DebugSuffix).lib;opencv_ml300$(DebugSuffix).lib;opencv_highgui300$(DebugSuffix).lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OpenCV_Lib);%(AdditionalLibraryDirectories);</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/pch.cpp b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/pch.cpp
new file mode 100644
index 00000000..083d1a02
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/pch.cpp
@@ -0,0 +1,6 @@
+//
+// pch.cpp
+// Include the standard header and generate the precompiled header.
+//
+
+#include "pch.h"
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/pch.h b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/pch.h
new file mode 100644
index 00000000..9f0bfccf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/FaceDetection/FaceDetection/pch.h
@@ -0,0 +1,11 @@
+//
+// pch.h
+// Header for standard system include files.
+//
+
+#pragma once
+
+#include <collection.h>
+#include <ppltasks.h>
+
+#include "App.xaml.h"
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/AdvancedCapture.xaml b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/AdvancedCapture.xaml
new file mode 100644
index 00000000..07db96f2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/AdvancedCapture.xaml
@@ -0,0 +1,75 @@
+<!--
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+-->
+
+<common:LayoutAwarePage
+    x:Class="SDKSample.MediaCapture.AdvancedCapture"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:$rootsnamespace$"
+    xmlns:common="using:SDKSample.Common"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    mc:Ignorable="d">
+
+    <Grid x:Name="LayoutRoot" Background="White" HorizontalAlignment="Left" VerticalAlignment="Top">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+        </Grid.RowDefinitions>
+        <Grid x:Name="Input" Grid.Row="0">
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="*"/>
+            </Grid.RowDefinitions>
+            <TextBlock TextWrapping="Wrap" Grid.Row="0"  Text="This scenario shows how to enumerate cameras in the system. Choose a camera from the list to preview, record or take a photo from the chosen camera.  You can add the gray scale effect using the checkbox provided." Style="{StaticResource BasicTextStyle}" HorizontalAlignment="Left"/>
+            <StackPanel Orientation="Horizontal" Grid.Row="1" Margin="0,10,0,0">
+                <ListBox x:Name="EnumedDeviceList2" SelectionChanged="lstEnumedDevices_SelectionChanged" />
+                <Button x:Name="btnStartDevice2" Click="btnStartDevice_Click" IsEnabled="true"  Margin="0,0,10,0" Content="StartDevice"/>
+                <Button x:Name="btnStartPreview2" Click="btnStartPreview_Click" IsEnabled="true"  Margin="0,0,10,0" Content="StartPreview"/>
+                <ComboBox x:Name="EffectTypeCombo" Width="120" SelectedIndex="0">
+                    <ComboBoxItem Content="Preview"/>
+                    <ComboBoxItem Content="Grayscale"/>
+                    <ComboBoxItem Content="Canny"/>
+                    <ComboBoxItem Content="Sobel"/>
+                    <ComboBoxItem Content="Histogram"/>
+                </ComboBox>
+                <Button Content="Apply" HorizontalAlignment="Stretch" VerticalAlignment="Top" Click="Button_Click"/>
+            </StackPanel>
+            <StackPanel x:Name="EffectTypeCombo1" Orientation="Horizontal" Grid.Row="1" Margin="324,5,-324,7"/>
+        </Grid>
+
+        <Grid x:Name="Output" HorizontalAlignment="Left" VerticalAlignment="Top" Grid.Row="1">
+            <StackPanel Orientation="Horizontal" Margin="0,10,0,0">
+                <StackPanel>
+                    <TextBlock Style="{StaticResource BasicTextStyle}"  HorizontalAlignment='Center'  VerticalAlignment='Center'  TextAlignment='Center'	Text='Preview' />
+                    <Canvas x:Name="previewCanvas2" Background="Gray">
+                        <CaptureElement x:Name="previewElement2" />
+                    </Canvas>
+                </StackPanel>
+                <StackPanel/>
+                <StackPanel/>
+            </StackPanel>
+        </Grid>
+
+        <!-- Add Storyboards to the visual states below as necessary for supporting the various layouts -->
+        <VisualStateManager.VisualStateGroups>
+            <VisualStateGroup>
+                <VisualState x:Name="FullScreenLandscape"/>
+                <VisualState x:Name="Filled"/>
+                <VisualState x:Name="FullScreenPortrait"/>
+                <VisualState x:Name="Snapped"/>
+            </VisualStateGroup>
+        </VisualStateManager.VisualStateGroups>
+    </Grid>
+
+</common:LayoutAwarePage>
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/AdvancedCapture.xaml.cpp b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/AdvancedCapture.xaml.cpp
new file mode 100644
index 00000000..f3459828
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/AdvancedCapture.xaml.cpp
@@ -0,0 +1,613 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+//
+// AdvancedCapture.xaml.cpp
+// Implementation of the AdvancedCapture class
+//
+
+#include "pch.h"
+#include "AdvancedCapture.xaml.h"
+
+using namespace SDKSample::MediaCapture;
+
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Navigation;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::System;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Platform;
+using namespace Windows::UI;
+using namespace Windows::UI::Core;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::Storage;
+using namespace Windows::Media::MediaProperties;
+using namespace Windows::Storage::Streams;
+using namespace Windows::System;
+using namespace Windows::UI::Xaml::Media::Imaging;
+using namespace Windows::Devices::Enumeration;
+
+ref class ReencodeState sealed
+{
+public:
+    ReencodeState()
+    {
+    }
+
+    virtual ~ReencodeState()
+    {
+        if (InputStream != nullptr)
+        {
+            delete InputStream;
+        }
+        if (OutputStream != nullptr)
+        {
+            delete OutputStream;
+        }
+    }
+
+internal:
+    Windows::Storage::Streams::IRandomAccessStream ^InputStream;
+    Windows::Storage::Streams::IRandomAccessStream ^OutputStream;
+    Windows::Storage::StorageFile ^PhotoStorage;
+    Windows::Graphics::Imaging::BitmapDecoder ^Decoder;
+    Windows::Graphics::Imaging::BitmapEncoder ^Encoder;
+};
+
+AdvancedCapture::AdvancedCapture()
+{
+    InitializeComponent();
+    ScenarioInit();
+}
+
+/// <summary>
+/// Invoked when this page is about to be displayed in a Frame.
+/// </summary>
+/// <param name="e">Event data that describes how this page was reached.  The Parameter
+/// property is typically used to configure the page.</param>
+void AdvancedCapture::OnNavigatedTo(NavigationEventArgs^ e)
+{
+    // A pointer back to the main page.  This is needed if you want to call methods in MainPage such
+    // as NotifyUser()
+    rootPage = MainPage::Current;
+
+    m_orientationChangedEventToken = Windows::Graphics::Display::DisplayProperties::OrientationChanged += ref new Windows::Graphics::Display::DisplayPropertiesEventHandler(this, &AdvancedCapture::DisplayProperties_OrientationChanged);
+}
+
+void AdvancedCapture::OnNavigatedFrom(NavigationEventArgs^ e)
+{
+    Windows::Media::MediaControl::SoundLevelChanged -= m_eventRegistrationToken;
+    Windows::Graphics::Display::DisplayProperties::OrientationChanged  -= m_orientationChangedEventToken;
+}
+
+void  AdvancedCapture::ScenarioInit()
+{
+    rootPage = MainPage::Current;
+    btnStartDevice2->IsEnabled = true;
+    btnStartPreview2->IsEnabled = false;
+    m_bRecording = false;
+    m_bPreviewing = false;
+    m_bEffectAdded = false;
+    previewElement2->Source = nullptr;
+    ShowStatusMessage("");
+    EffectTypeCombo->IsEnabled = false;
+    previewCanvas2->Visibility = Windows::UI::Xaml::Visibility::Collapsed;
+    EnumerateWebcamsAsync();
+    m_bSuspended = false;
+}
+
+void AdvancedCapture::ScenarioReset()
+{
+    previewCanvas2->Visibility = Windows::UI::Xaml::Visibility::Collapsed;
+    ScenarioInit();
+}
+
+void AdvancedCapture::Failed(Windows::Media::Capture::MediaCapture ^currentCaptureObject, Windows::Media::Capture::MediaCaptureFailedEventArgs^ currentFailure)
+{
+    String ^message = "Fatal error" + currentFailure->Message;
+    create_task(Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::High,
+        ref new Windows::UI::Core::DispatchedHandler([this, message]()
+    {
+        ShowStatusMessage(message);
+    })));
+}
+
+void AdvancedCapture::btnStartDevice_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
+{
+    try
+    {
+        EnableButton(false, "StartDevice");
+        ShowStatusMessage("Starting device");
+        auto mediaCapture = ref new Windows::Media::Capture::MediaCapture();
+        m_mediaCaptureMgr = mediaCapture;
+        auto settings = ref new Windows::Media::Capture::MediaCaptureInitializationSettings();
+        auto chosenDevInfo = m_devInfoCollection->GetAt(EnumedDeviceList2->SelectedIndex);
+        settings->VideoDeviceId = chosenDevInfo->Id;
+        if (chosenDevInfo->EnclosureLocation != nullptr && chosenDevInfo->EnclosureLocation->Panel == Windows::Devices::Enumeration::Panel::Back)
+        {
+            m_bRotateVideoOnOrientationChange = true;
+            m_bReversePreviewRotation = false;
+        }
+        else if (chosenDevInfo->EnclosureLocation != nullptr && chosenDevInfo->EnclosureLocation->Panel == Windows::Devices::Enumeration::Panel::Front)
+        {
+            m_bRotateVideoOnOrientationChange = true;
+            m_bReversePreviewRotation = true;
+        }
+        else
+        {
+            m_bRotateVideoOnOrientationChange = false;
+        }
+
+        create_task(mediaCapture->InitializeAsync(settings)).then([this](task<void> initTask)
+        {
+            try
+            {
+                initTask.get();
+
+                auto mediaCapture =  m_mediaCaptureMgr.Get();
+
+                DisplayProperties_OrientationChanged(nullptr);
+
+                EnableButton(true, "StartPreview");
+                EnableButton(true, "StartStopRecord");
+                EnableButton(true, "TakePhoto");
+                ShowStatusMessage("Device initialized successful");
+                EffectTypeCombo->IsEnabled = true;
+                mediaCapture->Failed += ref new Windows::Media::Capture::MediaCaptureFailedEventHandler(this, &AdvancedCapture::Failed);
+            }
+            catch (Exception ^ e)
+            {
+                ShowExceptionMessage(e);
+            }
+        });
+    }
+    catch (Platform::Exception^ e)
+    {
+        ShowExceptionMessage(e);
+    }
+}
+
+void AdvancedCapture::btnStartPreview_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
+{
+    m_bPreviewing = false;
+    try
+    {
+        ShowStatusMessage("Starting preview");
+        EnableButton(false, "StartPreview");
+
+        auto mediaCapture = m_mediaCaptureMgr.Get();
+        previewCanvas2->Visibility = Windows::UI::Xaml::Visibility::Visible;
+        previewElement2->Source = mediaCapture;
+        create_task(mediaCapture->StartPreviewAsync()).then([this](task<void> previewTask)
+        {
+            try
+            {
+                previewTask.get();
+                m_bPreviewing = true;
+                ShowStatusMessage("Start preview successful");
+            }
+            catch (Exception ^e)
+            {
+                ShowExceptionMessage(e);
+            }
+        });
+    }
+    catch (Platform::Exception^ e)
+    {
+        m_bPreviewing = false;
+        previewElement2->Source = nullptr;
+        EnableButton(true, "StartPreview");
+        ShowExceptionMessage(e);
+    }
+}
+
+void AdvancedCapture::lstEnumedDevices_SelectionChanged(Platform::Object^ sender, Windows::UI::Xaml::Controls::SelectionChangedEventArgs^ e)
+{
+     if ( m_bPreviewing )
+     {
+         create_task(m_mediaCaptureMgr->StopPreviewAsync()).then([this](task<void> previewTask)
+         {
+             try
+             {
+                 previewTask.get();
+                 m_bPreviewing = false;
+             }
+             catch (Exception ^e)
+             {
+                ShowExceptionMessage(e);
+             }
+         });
+    }
+
+    btnStartDevice2->IsEnabled = true;
+    btnStartPreview2->IsEnabled = false;
+    m_bRecording = false;
+    previewElement2->Source = nullptr;
+    EffectTypeCombo->IsEnabled = false;
+    m_bEffectAdded = false;
+    m_bEffectAddedToRecord = false;
+    m_bEffectAddedToPhoto = false;
+    ShowStatusMessage("");
+}
+
+void AdvancedCapture::EnumerateWebcamsAsync()
+{
+    try
+    {
+        ShowStatusMessage("Enumerating Webcams...");
+        m_devInfoCollection = nullptr;
+
+        EnumedDeviceList2->Items->Clear();
+
+        task<DeviceInformationCollection^>(DeviceInformation::FindAllAsync(DeviceClass::VideoCapture)).then([this](task<DeviceInformationCollection^> findTask)
+        {
+            try
+            {
+                m_devInfoCollection = findTask.get();
+                if (m_devInfoCollection == nullptr || m_devInfoCollection->Size == 0)
+                {
+                    ShowStatusMessage("No WebCams found.");
+                }
+                else
+                {
+                    for(unsigned int i = 0; i < m_devInfoCollection->Size; i++)
+                    {
+                        auto devInfo = m_devInfoCollection->GetAt(i);
+                        EnumedDeviceList2->Items->Append(devInfo->Name);
+                    }
+                    EnumedDeviceList2->SelectedIndex = 0;
+                    ShowStatusMessage("Enumerating Webcams completed successfully.");
+                    btnStartDevice2->IsEnabled = true;
+                }
+            }
+            catch (Exception ^e)
+            {
+                ShowExceptionMessage(e);
+            }
+        });
+    }
+    catch (Platform::Exception^ e)
+    {
+        ShowExceptionMessage(e);
+    }
+}
+
+void AdvancedCapture::AddEffectToImageStream()
+{
+    auto mediaCapture = m_mediaCaptureMgr.Get();
+    Windows::Media::Capture::VideoDeviceCharacteristic charecteristic = mediaCapture->MediaCaptureSettings->VideoDeviceCharacteristic;
+
+    if((charecteristic != Windows::Media::Capture::VideoDeviceCharacteristic::AllStreamsIdentical) &&
+        (charecteristic != Windows::Media::Capture::VideoDeviceCharacteristic::PreviewPhotoStreamsIdentical) &&
+        (charecteristic != Windows::Media::Capture::VideoDeviceCharacteristic::RecordPhotoStreamsIdentical))
+    {
+        Windows::Media::MediaProperties::IMediaEncodingProperties ^props = mediaCapture->VideoDeviceController->GetMediaStreamProperties(Windows::Media::Capture::MediaStreamType::Photo);
+        if(props->Type->Equals("Image"))
+        {
+            //Switch to a video media type instead since we can't add an effect to an image media type
+            Windows::Foundation::Collections::IVectorView<Windows::Media::MediaProperties::IMediaEncodingProperties^>^ supportedPropsList = mediaCapture->VideoDeviceController->GetAvailableMediaStreamProperties(Windows::Media::Capture::MediaStreamType::Photo);
+            {
+                unsigned int i = 0;
+                while (i < supportedPropsList->Size)
+                {
+                    Windows::Media::MediaProperties::IMediaEncodingProperties^ props = supportedPropsList->GetAt(i);
+
+                    String^ s = props->Type;
+                    if(props->Type->Equals("Video"))
+                    {
+                        task<void>(mediaCapture->VideoDeviceController->SetMediaStreamPropertiesAsync(Windows::Media::Capture::MediaStreamType::Photo,props)).then([this](task<void> changeTypeTask)
+                        {
+                            try
+                            {
+                                changeTypeTask.get();
+                                ShowStatusMessage("Change type on photo stream successful");
+                                //Now add the effect on the image pin
+                                task<void>(m_mediaCaptureMgr->AddEffectAsync(Windows::Media::Capture::MediaStreamType::Photo,"OcvTransform.OcvImageManipulations", nullptr)).then([this](task<void> effectTask3)
+                                {
+                                    try
+                                    {
+                                        effectTask3.get();
+                                        m_bEffectAddedToPhoto = true;
+                                        ShowStatusMessage("Adding effect to photo stream successful");
+                                        EffectTypeCombo->IsEnabled = true;
+
+                                    }
+                                    catch(Exception ^e)
+                                    {
+                                        ShowExceptionMessage(e);
+                                        EffectTypeCombo->IsEnabled = true;
+                                    }
+                                });
+
+                            }
+                            catch(Exception ^e)
+                            {
+                                ShowExceptionMessage(e);
+                                EffectTypeCombo->IsEnabled = true;
+                            }
+
+                        });
+                        break;
+
+                    }
+                    i++;
+                }
+            }
+        }
+        else
+        {
+            //Add the effect to the image pin if the type is already "Video"
+            task<void>(mediaCapture->AddEffectAsync(Windows::Media::Capture::MediaStreamType::Photo,"OcvTransform.OcvImageManipulations", nullptr)).then([this](task<void> effectTask3)
+            {
+                try
+                {
+                    effectTask3.get();
+                    m_bEffectAddedToPhoto = true;
+                    ShowStatusMessage("Adding effect to photo stream successful");
+                    EffectTypeCombo->IsEnabled = true;
+
+                }
+                catch(Exception ^e)
+                {
+                    ShowExceptionMessage(e);
+                    EffectTypeCombo->IsEnabled = true;
+                }
+            });
+        }
+    }
+}
+
+void AdvancedCapture::ShowStatusMessage(Platform::String^ text)
+{
+    rootPage->NotifyUser(text, NotifyType::StatusMessage);
+}
+
+void AdvancedCapture::ShowExceptionMessage(Platform::Exception^ ex)
+{
+    rootPage->NotifyUser(ex->Message, NotifyType::ErrorMessage);
+}
+
+void AdvancedCapture::EnableButton(bool enabled, String^ name)
+{
+    if (name->Equals("StartDevice"))
+    {
+        btnStartDevice2->IsEnabled = enabled;
+    }
+    else if (name->Equals("StartPreview"))
+    {
+        btnStartPreview2->IsEnabled = enabled;
+    }
+}
+
+task<Windows::Storage::StorageFile^> AdvancedCapture::ReencodePhotoAsync(
+    Windows::Storage::StorageFile ^tempStorageFile,
+    Windows::Storage::FileProperties::PhotoOrientation photoRotation)
+{
+    ReencodeState ^state = ref new ReencodeState();
+
+    return create_task(tempStorageFile->OpenAsync(Windows::Storage::FileAccessMode::Read)).then([state](Windows::Storage::Streams::IRandomAccessStream ^stream)
+    {
+        state->InputStream = stream;
+        return Windows::Graphics::Imaging::BitmapDecoder::CreateAsync(state->InputStream);
+    }).then([state](Windows::Graphics::Imaging::BitmapDecoder ^decoder)
+    {
+        state->Decoder = decoder;
+        return Windows::Storage::KnownFolders::PicturesLibrary->CreateFileAsync(PHOTO_FILE_NAME, Windows::Storage::CreationCollisionOption::GenerateUniqueName);
+    }).then([state](Windows::Storage::StorageFile ^storageFile)
+    {
+        state->PhotoStorage = storageFile;
+        return state->PhotoStorage->OpenAsync(Windows::Storage::FileAccessMode::ReadWrite);
+    }).then([state](Windows::Storage::Streams::IRandomAccessStream ^stream)
+    {
+        state->OutputStream = stream;
+        state->OutputStream->Size = 0;
+        return Windows::Graphics::Imaging::BitmapEncoder::CreateForTranscodingAsync(state->OutputStream, state->Decoder);
+    }).then([state, photoRotation](Windows::Graphics::Imaging::BitmapEncoder ^encoder)
+    {
+        state->Encoder = encoder;
+        auto properties = ref new Windows::Graphics::Imaging::BitmapPropertySet();
+        properties->Insert("System.Photo.Orientation",
+            ref new Windows::Graphics::Imaging::BitmapTypedValue((unsigned short)photoRotation, Windows::Foundation::PropertyType::UInt16));
+        return create_task(state->Encoder->BitmapProperties->SetPropertiesAsync(properties));
+    }).then([state]()
+    {
+        return state->Encoder->FlushAsync();
+    }).then([tempStorageFile, state](task<void> previousTask)
+    {
+        auto result = state->PhotoStorage;
+        delete state;
+
+        tempStorageFile->DeleteAsync(Windows::Storage::StorageDeleteOption::PermanentDelete);
+
+        previousTask.get();
+
+        return result;
+    });
+}
+
+Windows::Storage::FileProperties::PhotoOrientation AdvancedCapture::GetCurrentPhotoRotation()
+{
+    bool counterclockwiseRotation = m_bReversePreviewRotation;
+
+    if (m_bRotateVideoOnOrientationChange)
+    {
+        return PhotoRotationLookup(Windows::Graphics::Display::DisplayProperties::CurrentOrientation, counterclockwiseRotation);
+    }
+    else
+    {
+        return Windows::Storage::FileProperties::PhotoOrientation::Normal;
+    }
+}
+
+void AdvancedCapture::PrepareForVideoRecording()
+{
+    Windows::Media::Capture::MediaCapture ^mediaCapture = m_mediaCaptureMgr.Get();
+    if (mediaCapture == nullptr)
+    {
+        return;
+    }
+
+    bool counterclockwiseRotation = m_bReversePreviewRotation;
+
+    if (m_bRotateVideoOnOrientationChange)
+    {
+        mediaCapture->SetRecordRotation(VideoRotationLookup(Windows::Graphics::Display::DisplayProperties::CurrentOrientation, counterclockwiseRotation));
+    }
+    else
+    {
+        mediaCapture->SetRecordRotation(Windows::Media::Capture::VideoRotation::None);
+    }
+}
+
+void AdvancedCapture::DisplayProperties_OrientationChanged(Platform::Object^ sender)
+{
+    Windows::Media::Capture::MediaCapture ^mediaCapture = m_mediaCaptureMgr.Get();
+    if (mediaCapture == nullptr)
+    {
+        return;
+    }
+
+    bool previewMirroring = mediaCapture->GetPreviewMirroring();
+    bool counterclockwiseRotation = (previewMirroring && !m_bReversePreviewRotation) ||
+        (!previewMirroring && m_bReversePreviewRotation);
+
+    if (m_bRotateVideoOnOrientationChange)
+    {
+        mediaCapture->SetPreviewRotation(VideoRotationLookup(Windows::Graphics::Display::DisplayProperties::CurrentOrientation, counterclockwiseRotation));
+    }
+    else
+    {
+        mediaCapture->SetPreviewRotation(Windows::Media::Capture::VideoRotation::None);
+    }
+}
+
+Windows::Storage::FileProperties::PhotoOrientation AdvancedCapture::PhotoRotationLookup(
+    Windows::Graphics::Display::DisplayOrientations displayOrientation, bool counterclockwise)
+{
+    switch (displayOrientation)
+    {
+    case Windows::Graphics::Display::DisplayOrientations::Landscape:
+        return Windows::Storage::FileProperties::PhotoOrientation::Normal;
+
+    case Windows::Graphics::Display::DisplayOrientations::Portrait:
+        return (counterclockwise) ? Windows::Storage::FileProperties::PhotoOrientation::Rotate270:
+            Windows::Storage::FileProperties::PhotoOrientation::Rotate90;
+
+    case Windows::Graphics::Display::DisplayOrientations::LandscapeFlipped:
+        return Windows::Storage::FileProperties::PhotoOrientation::Rotate180;
+
+    case Windows::Graphics::Display::DisplayOrientations::PortraitFlipped:
+        return (counterclockwise) ? Windows::Storage::FileProperties::PhotoOrientation::Rotate90 :
+            Windows::Storage::FileProperties::PhotoOrientation::Rotate270;
+
+    default:
+        return Windows::Storage::FileProperties::PhotoOrientation::Unspecified;
+    }
+}
+
+Windows::Media::Capture::VideoRotation AdvancedCapture::VideoRotationLookup(
+    Windows::Graphics::Display::DisplayOrientations displayOrientation, bool counterclockwise)
+{
+    switch (displayOrientation)
+    {
+    case Windows::Graphics::Display::DisplayOrientations::Landscape:
+        return Windows::Media::Capture::VideoRotation::None;
+
+    case Windows::Graphics::Display::DisplayOrientations::Portrait:
+        return (counterclockwise) ? Windows::Media::Capture::VideoRotation::Clockwise270Degrees :
+            Windows::Media::Capture::VideoRotation::Clockwise90Degrees;
+
+    case Windows::Graphics::Display::DisplayOrientations::LandscapeFlipped:
+        return Windows::Media::Capture::VideoRotation::Clockwise180Degrees;
+
+    case Windows::Graphics::Display::DisplayOrientations::PortraitFlipped:
+        return (counterclockwise) ? Windows::Media::Capture::VideoRotation::Clockwise90Degrees:
+            Windows::Media::Capture::VideoRotation::Clockwise270Degrees ;
+
+    default:
+        return Windows::Media::Capture::VideoRotation::None;
+    }
+}
+
+void SDKSample::MediaCapture::AdvancedCapture::Button_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
+{
+    try
+    {
+        create_task(m_mediaCaptureMgr->ClearEffectsAsync(Windows::Media::Capture::MediaStreamType::VideoPreview)).then([this](task<void> cleanTask)
+        {
+            m_bEffectAdded = true;
+            int index = EffectTypeCombo->SelectedIndex;
+            PropertySet^ props = ref new PropertySet();
+            props->Insert(L"{698649BE-8EAE-4551-A4CB-3EC98FBD3D86}", index);
+            create_task(m_mediaCaptureMgr->AddEffectAsync(Windows::Media::Capture::MediaStreamType::VideoPreview,"OcvTransform.OcvImageManipulations", props)).then([this](task<void> effectTask)
+            {
+                try
+                {
+                    effectTask.get();
+
+                    auto mediaCapture = m_mediaCaptureMgr.Get();
+                    Windows::Media::Capture::VideoDeviceCharacteristic charecteristic = mediaCapture->MediaCaptureSettings->VideoDeviceCharacteristic;
+
+                    ShowStatusMessage("Add effect successful to preview stream successful");
+                    if((charecteristic != Windows::Media::Capture::VideoDeviceCharacteristic::AllStreamsIdentical) &&
+                        (charecteristic != Windows::Media::Capture::VideoDeviceCharacteristic::PreviewRecordStreamsIdentical))
+                    {
+                        Windows::Media::MediaProperties::IMediaEncodingProperties ^props = mediaCapture->VideoDeviceController->GetMediaStreamProperties(Windows::Media::Capture::MediaStreamType::VideoRecord);
+                        Windows::Media::MediaProperties::VideoEncodingProperties ^videoEncodingProperties  = static_cast<Windows::Media::MediaProperties::VideoEncodingProperties ^>(props);
+                        if(!videoEncodingProperties->Subtype->Equals("H264")) //Can't add an effect to an H264 stream
+                        {
+                            task<void>(mediaCapture->AddEffectAsync(Windows::Media::Capture::MediaStreamType::VideoRecord,"OcvTransform.OcvImageManipulations", nullptr)).then([this](task<void> effectTask2)
+                            {
+                                try
+                                {
+                                    effectTask2.get();
+                                    ShowStatusMessage("Add effect successful to record stream successful");
+                                    m_bEffectAddedToRecord = true;
+                                    AddEffectToImageStream();
+                                    EffectTypeCombo->IsEnabled = true;
+                                }
+                                catch(Exception ^e)
+                                {
+                                    ShowExceptionMessage(e);
+                                    EffectTypeCombo->IsEnabled = true;
+                                }
+                            });
+                        }
+                        else
+                        {
+                            AddEffectToImageStream();
+                            EffectTypeCombo->IsEnabled = true;
+                        }
+
+                    }
+                    else
+                    {
+                        AddEffectToImageStream();
+                        EffectTypeCombo->IsEnabled = true;
+                    }
+                }
+                catch (Exception ^e)
+                {
+                    ShowExceptionMessage(e);
+                    EffectTypeCombo->IsEnabled = true;
+                }
+            });
+        });
+    }
+    catch (Platform::Exception ^e)
+    {
+        ShowExceptionMessage(e);
+        EffectTypeCombo->IsEnabled = true;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/AdvancedCapture.xaml.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/AdvancedCapture.xaml.h
new file mode 100644
index 00000000..94fa87c6
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/AdvancedCapture.xaml.h
@@ -0,0 +1,95 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+//
+// AdvancedCapture.xaml.h
+// Declaration of the AdvancedCapture class
+//
+
+#pragma once
+
+#include "pch.h"
+#include "AdvancedCapture.g.h"
+#include "MainPage.xaml.h"
+#include <ppl.h>
+
+#define VIDEO_FILE_NAME "video.mp4"
+#define PHOTO_FILE_NAME "photo.jpg"
+#define TEMP_PHOTO_FILE_NAME "photoTmp.jpg"
+
+using namespace concurrency;
+using namespace Windows::Devices::Enumeration;
+
+namespace SDKSample
+{
+    namespace MediaCapture
+    {
+        /// <summary>
+        /// An empty page that can be used on its own or navigated to within a Frame.
+        /// </summary>
+        [Windows::Foundation::Metadata::WebHostHidden]
+        public ref class AdvancedCapture sealed
+        {
+        public:
+            AdvancedCapture();
+
+        protected:
+            virtual void OnNavigatedTo(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override;
+            virtual void OnNavigatedFrom(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override;
+
+        private:
+            MainPage^ rootPage;
+            void ScenarioInit();
+            void ScenarioReset();
+
+            void Failed(Windows::Media::Capture::MediaCapture ^ mediaCapture, Windows::Media::Capture::MediaCaptureFailedEventArgs ^ args);
+
+            void btnStartDevice_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+
+            void btnStartPreview_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+
+            void lstEnumedDevices_SelectionChanged(Platform::Object^ sender, Windows::UI::Xaml::Controls::SelectionChangedEventArgs^ e);
+            void EnumerateWebcamsAsync();
+
+            void AddEffectToImageStream();
+
+            void ShowStatusMessage(Platform::String^ text);
+            void ShowExceptionMessage(Platform::Exception^ ex);
+
+            void EnableButton(bool enabled, Platform::String ^name);
+
+            task<Windows::Storage::StorageFile^> ReencodePhotoAsync(
+                Windows::Storage::StorageFile ^tempStorageFile,
+                Windows::Storage::FileProperties::PhotoOrientation photoRotation);
+            Windows::Storage::FileProperties::PhotoOrientation GetCurrentPhotoRotation();
+            void PrepareForVideoRecording();
+            void DisplayProperties_OrientationChanged(Platform::Object^ sender);
+            Windows::Storage::FileProperties::PhotoOrientation PhotoRotationLookup(
+                Windows::Graphics::Display::DisplayOrientations displayOrientation, bool counterclockwise);
+            Windows::Media::Capture::VideoRotation VideoRotationLookup(
+                Windows::Graphics::Display::DisplayOrientations displayOrientation, bool counterclockwise);
+
+            Platform::Agile<Windows::Media::Capture::MediaCapture> m_mediaCaptureMgr;
+            Windows::Storage::StorageFile^ m_recordStorageFile;
+            bool m_bRecording;
+            bool m_bEffectAdded;
+            bool m_bEffectAddedToRecord;
+            bool m_bEffectAddedToPhoto;
+            bool m_bSuspended;
+            bool m_bPreviewing;
+            DeviceInformationCollection^ m_devInfoCollection;
+            Windows::Foundation::EventRegistrationToken m_eventRegistrationToken;
+            bool m_bRotateVideoOnOrientationChange;
+            bool m_bReversePreviewRotation;
+            Windows::Foundation::EventRegistrationToken m_orientationChangedEventToken;
+            void Button_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+        };
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/App.xaml b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/App.xaml
new file mode 100644
index 00000000..769f4400
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/App.xaml
@@ -0,0 +1,30 @@
+<!--
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+-->
+
+<Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    x:Class="SDKSample.App"
+    RequestedTheme="Light">
+    <Application.Resources>
+
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <!--
+                    Styles that define common aspects of the platform look and feel
+                    Required by Visual Studio project and item templates
+                 -->
+                <ResourceDictionary Source="Common/StandardStyles.xaml"/>
+                <ResourceDictionary Source="Sample-Utils/SampleTemplateStyles.xaml"/>
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/App.xaml.cpp b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/App.xaml.cpp
new file mode 100644
index 00000000..a24a4f9c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/App.xaml.cpp
@@ -0,0 +1,116 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+//
+// App.xaml.cpp
+// Implementation of the App.xaml class.
+//
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+#include "AdvancedCapture.xaml.h"
+#include "Common\SuspensionManager.h"
+
+using namespace SDKSample;
+using namespace SDKSample::Common;
+using namespace SDKSample::MediaCapture;
+
+using namespace Concurrency;
+using namespace Platform;
+using namespace Windows::ApplicationModel;
+using namespace Windows::ApplicationModel::Activation;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::UI::Core;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Controls::Primitives;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Interop;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Navigation;
+
+/// <summary>
+/// Initializes the singleton application object.  This is the first line of authored code
+/// executed, and as such is the logical equivalent of main() or WinMain().
+/// </summary>
+App::App()
+{
+    InitializeComponent();
+    this->Suspending += ref new SuspendingEventHandler(this, &SDKSample::App::OnSuspending);
+}
+
+/// <summary>
+/// Invoked when the application is launched normally by the end user.  Other entry points will
+/// be used when the application is launched to open a specific file, to display search results,
+/// and so forth.
+/// </summary>
+/// <param name="pArgs">Details about the launch request and process.</param>
+void App::OnLaunched(LaunchActivatedEventArgs^ pArgs)
+{
+    this->LaunchArgs = pArgs;
+
+    // Do not repeat app initialization when already running, just ensure that
+    // the window is active
+    if (pArgs->PreviousExecutionState == ApplicationExecutionState::Running)
+    {
+        Window::Current->Activate();
+        return;
+    }
+
+    // Create a Frame to act as the navigation context and associate it with
+    // a SuspensionManager key
+    auto rootFrame = ref new Frame();
+    SuspensionManager::RegisterFrame(rootFrame, "AppFrame");
+
+    auto prerequisite = task<void>([](){});
+    if (pArgs->PreviousExecutionState == ApplicationExecutionState::Terminated)
+    {
+        // Restore the saved session state only when appropriate, scheduling the
+        // final launch steps after the restore is complete
+        prerequisite = SuspensionManager::RestoreAsync();
+    }
+    prerequisite.then([=]()
+    {
+        // When the navigation stack isn't restored navigate to the first page,
+        // configuring the new page by passing required information as a navigation
+        // parameter
+        if (rootFrame->Content == nullptr)
+        {
+            if (!rootFrame->Navigate(TypeName(MainPage::typeid)))
+            {
+                throw ref new FailureException("Failed to create initial page");
+            }
+        }
+
+        // Place the frame in the current Window and ensure that it is active
+        Window::Current->Content = rootFrame;
+        Window::Current->Activate();
+    }, task_continuation_context::use_current());
+}
+
+/// <summary>
+/// Invoked when application execution is being suspended.  Application state is saved
+/// without knowing whether the application will be terminated or resumed with the contents
+/// of memory still intact.
+/// </summary>
+/// <param name="sender">The source of the suspend request.</param>
+/// <param name="e">Details about the suspend request.</param>
+void App::OnSuspending(Object^ sender, SuspendingEventArgs^ e)
+{
+    (void) sender;	// Unused parameter
+
+    auto deferral = e->SuspendingOperation->GetDeferral();
+    SuspensionManager::SaveAsync().then([=]()
+    {
+        deferral->Complete();
+    });
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/App.xaml.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/App.xaml.h
new file mode 100644
index 00000000..a8b60642
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/App.xaml.h
@@ -0,0 +1,35 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+//
+// App.xaml.h
+// Declaration of the App.xaml class.
+//
+
+#pragma once
+
+#include "pch.h"
+#include "App.g.h"
+#include "MainPage.g.h"
+
+namespace SDKSample
+{
+    ref class App
+    {
+    internal:
+        App();
+        virtual void OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ pArgs);
+        Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ LaunchArgs;
+    protected:
+        virtual void OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ pArgs) override;
+    private:
+        Windows::UI::Xaml::Controls::Frame^ rootFrame;
+    };
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/Constants.cpp b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/Constants.cpp
new file mode 100644
index 00000000..c819b768
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/Constants.cpp
@@ -0,0 +1,22 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+#include "Constants.h"
+
+using namespace SDKSample;
+
+Platform::Array<Scenario>^ MainPage::scenariosInner = ref new Platform::Array<Scenario>
+{
+    // The format here is the following:
+    //     { "Description for the sample", "Fully qualified name for the class that implements the scenario" }
+    { "Enumerate cameras and add a video effect", "SDKSample.MediaCapture.AdvancedCapture" },
+};
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/Constants.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/Constants.h
new file mode 100644
index 00000000..143f0696
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/Constants.h
@@ -0,0 +1,45 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+#pragma once
+
+#include <collection.h>
+namespace SDKSample
+{
+    public value struct Scenario
+    {
+        Platform::String^ Title;
+        Platform::String^ ClassName;
+    };
+
+    partial ref class MainPage
+    {
+    public:
+        static property Platform::String^ FEATURE_NAME
+        {
+            Platform::String^ get()
+            {
+                return ref new Platform::String(L"OpenCV Image Manipulations sample");
+            }
+        }
+
+        static property Platform::Array<Scenario>^ scenarios
+        {
+            Platform::Array<Scenario>^ get()
+            {
+                return scenariosInner;
+            }
+        }
+    private:
+        static Platform::Array<Scenario>^ scenariosInner;
+    };
+
+
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MainPage.xaml b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MainPage.xaml
new file mode 100644
index 00000000..7d86d52f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MainPage.xaml
@@ -0,0 +1,156 @@
+<!--
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+-->
+
+<common:LayoutAwarePage
+    x:Class="SDKSample.MainPage"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:common="using:SDKSample.Common"
+    mc:Ignorable="d"
+    x:Name="RootPage">
+
+    <common:LayoutAwarePage.Resources>
+        <Style x:Key="BaseStatusStyle" TargetType="TextBlock">
+            <Setter Property="FontFamily" Value="Segoe UI Semilight"/>
+            <Setter Property="FontSize" Value="14.667"/>
+            <Setter Property="Margin" Value="0,0,0,5"/>
+        </Style>
+        <Style x:Key="StatusStyle" BasedOn="{StaticResource BaseStatusStyle}" TargetType="TextBlock">
+            <Setter Property="Foreground" Value="Green"/>
+        </Style>
+        <Style x:Key="ErrorStyle" BasedOn="{StaticResource BaseStatusStyle}" TargetType="TextBlock">
+            <Setter Property="Foreground" Value="Blue"/>
+        </Style>
+    </common:LayoutAwarePage.Resources>
+
+
+    <Grid x:Name="LayoutRoot" Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
+
+        <Grid x:Name="ContentRoot" Background="{StaticResource ApplicationPageBackgroundThemeBrush}" Margin="100,20,100,20">
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="*"/>
+                <RowDefinition Height="Auto"/>
+            </Grid.RowDefinitions>
+
+            <!-- Header -->
+            <StackPanel Orientation="Horizontal" Grid.Row="0">
+                <Image x:Name="WindowsLogo" Stretch="None" Source="Assets/windows-sdk.png" AutomationProperties.Name="Windows Logo" HorizontalAlignment="Left" Grid.Column="0"/>
+                <TextBlock VerticalAlignment="Bottom" Style="{StaticResource TitleTextStyle}" TextWrapping="Wrap" Grid.Column="1" Text="OpenCV for Windows RT"/>
+            </StackPanel>
+            <ScrollViewer x:Name="MainScrollViewer" Grid.Row="1" ZoomMode="Disabled" IsTabStop="False" VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto" Padding="0,0,0,20" >
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                    </Grid.RowDefinitions>
+                    <TextBlock x:Name="FeatureName" Grid.Row="0"  Text="Add Sample Title Here" Style="{StaticResource HeaderTextStyle}" TextWrapping="Wrap"/>
+
+                    <!-- Content -->
+                    <Grid Grid.Row="1">
+
+                        <!-- All XAML in this section is purely for design time so you can see sample content in the designer. -->
+                        <!-- This will be replaced at runtime by live content.                                                 -->
+                        <Grid>
+                            <Grid.RowDefinitions>
+                                <RowDefinition Height="Auto"/>
+                                <RowDefinition Height="Auto"/>
+                                <RowDefinition Height="Auto"/>
+                                <RowDefinition Height="Auto"/>
+                                <RowDefinition Height="Auto"/>
+                                <RowDefinition Height="Auto"/>
+                                <RowDefinition Height="Auto"/>
+                                <RowDefinition Height="*"/>
+                            </Grid.RowDefinitions>
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="Auto"/>
+                                <ColumnDefinition Width="*"/>
+                            </Grid.ColumnDefinitions>
+                            <TextBlock Grid.Row="0" Text="Input" Style="{StaticResource H2Style}"/>
+
+                            <TextBlock x:Name="ScenarioListLabel" Text="Select Scenario:" Grid.Row="1"  Style="{StaticResource SubheaderTextStyle}" Margin="0,5,0,0" />
+                            <ListBox x:Name="Scenarios" Margin="0,0,20,0" Grid.Row="2" AutomationProperties.Name="Scenarios" HorizontalAlignment="Left"
+                                         VerticalAlignment="Top" ScrollViewer.HorizontalScrollBarVisibility="Auto"
+                                         AutomationProperties.LabeledBy="{Binding ElementName=ScenarioListLabel}" MaxHeight="125">
+                                <ListBox.ItemTemplate>
+                                    <DataTemplate>
+                                        <TextBlock Text="{Binding Name}"/>
+                                    </DataTemplate>
+                                </ListBox.ItemTemplate>
+                            </ListBox>
+                            <TextBlock x:Name="DescriptionText" Margin="0,5,0,0" Text="Description:" Style="{StaticResource SubheaderTextStyle}" Grid.Row="1" Grid.Column="1"/>
+                            <!-- Input Scenarios -->
+                            <UserControl x:Name="InputSection" Margin="0,5,0,0" IsTabStop="False" Grid.Row="2" Grid.Column="1" HorizontalAlignment="Left" VerticalAlignment="Top"/>
+
+                            <!-- Output section -->
+                            <TextBlock Text="Output" Grid.Row="5"  Margin="0,25,0,20" Style="{StaticResource H2Style}" Grid.ColumnSpan="2"/>
+                            <TextBlock x:Name="StatusBlock" Grid.Row="6" Margin="0,0,0,5" Grid.ColumnSpan="2"/>
+
+                            <!-- Output Scenarios -->
+                            <UserControl x:Name="OutputSection" Grid.Row="7" Grid.ColumnSpan="2" BorderThickness="0"/>
+                        </Grid>
+                    </Grid>
+                </Grid>
+            </ScrollViewer>
+
+            <!-- Footer -->
+            <Grid x:Name="Footer"  Grid.Row="3" Margin="0,10,0,10" VerticalAlignment="Bottom" >
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                </Grid.RowDefinitions>
+
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="*"/>
+                </Grid.ColumnDefinitions>
+                <StackPanel x:Name="FooterPanel" Orientation="Horizontal" Grid.Row="1" Grid.Column="1" HorizontalAlignment="Right"/>
+            </Grid>
+
+
+        </Grid>
+
+        <VisualStateManager.VisualStateGroups>
+            <!-- Visual states reflect the application's view state -->
+            <VisualStateGroup>
+                <VisualState x:Name="FullScreenLandscape">
+                    <Storyboard>
+                    </Storyboard>
+                </VisualState>
+                <VisualState x:Name="Filled">
+                    <Storyboard>
+                    </Storyboard>
+                </VisualState>
+
+                <VisualState x:Name="FullScreenPortrait">
+                    <Storyboard>
+                    </Storyboard>
+                </VisualState>
+
+                <VisualState x:Name="Snapped">
+                    <Storyboard>
+                        <ObjectAnimationUsingKeyFrames Storyboard.TargetProperty="(FrameworkElement.Margin)" Storyboard.TargetName="ContentRoot">
+                            <DiscreteObjectKeyFrame KeyTime="0">
+                                <DiscreteObjectKeyFrame.Value>
+                                    <Thickness>20,20,20,20</Thickness>
+                                </DiscreteObjectKeyFrame.Value>
+                            </DiscreteObjectKeyFrame>
+                        </ObjectAnimationUsingKeyFrames>
+                    </Storyboard>
+                </VisualState>
+            </VisualStateGroup>
+        </VisualStateManager.VisualStateGroups>
+    </Grid>
+</common:LayoutAwarePage>
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MainPage.xaml.cpp b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MainPage.xaml.cpp
new file mode 100644
index 00000000..73febc24
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MainPage.xaml.cpp
@@ -0,0 +1,315 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+//
+// MainPage.xaml.cpp
+// Implementation of the MainPage.xaml class.
+//
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+#include "App.xaml.h"
+
+#include <collection.h>
+
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Platform;
+using namespace SDKSample;
+using namespace Windows::UI::Xaml::Navigation;
+using namespace Windows::UI::Xaml::Interop;
+using namespace Windows::Graphics::Display;
+using namespace Windows::UI::ViewManagement;
+
+MainPage^ MainPage::Current = nullptr;
+
+MainPage::MainPage()
+{
+    InitializeComponent();
+
+    // This frame is hidden, meaning it is never shown.  It is simply used to load
+    // each scenario page and then pluck out the input and output sections and
+    // place them into the UserControls on the main page.
+    HiddenFrame = ref new Windows::UI::Xaml::Controls::Frame();
+    HiddenFrame->Visibility = Windows::UI::Xaml::Visibility::Collapsed;
+    ContentRoot->Children->Append(HiddenFrame);
+
+    FeatureName->Text = FEATURE_NAME;
+
+    this->SizeChanged += ref new SizeChangedEventHandler(this, &MainPage::MainPage_SizeChanged);
+    Scenarios->SelectionChanged += ref new SelectionChangedEventHandler(this, &MainPage::Scenarios_SelectionChanged);
+
+    MainPage::Current = this;
+    autoSizeInputSectionWhenSnapped = true;
+}
+
+/// <summary>
+/// We need to handle SizeChanged so that we can make the sample layout property
+/// in the various layouts.
+/// </summary>
+/// <param name="sender"></param>
+/// <param name="e"></param>
+void MainPage::MainPage_SizeChanged(Object^ sender, SizeChangedEventArgs^ e)
+{
+    InvalidateSize();
+    MainPageSizeChangedEventArgs^ args = ref new MainPageSizeChangedEventArgs();
+    args->ViewState = ApplicationView::Value;
+    MainPageResized(this, args);
+
+}
+
+void MainPage::InvalidateSize()
+{
+    // Get the window width
+    double windowWidth = this->ActualWidth;
+
+    if (windowWidth != 0.0)
+    {
+        // Get the width of the ListBox.
+        double listBoxWidth = Scenarios->ActualWidth;
+
+        // Is the ListBox using any margins that we need to consider?
+        double listBoxMarginLeft = Scenarios->Margin.Left;
+        double listBoxMarginRight = Scenarios->Margin.Right;
+
+        // Figure out how much room is left after considering the list box width
+        double availableWidth = windowWidth - listBoxWidth;
+
+        // Is the top most child using margins?
+        double layoutRootMarginLeft = ContentRoot->Margin.Left;
+        double layoutRootMarginRight = ContentRoot->Margin.Right;
+
+        // We have different widths to use depending on the view state
+        if (ApplicationView::Value != ApplicationViewState::Snapped)
+        {
+            // Make us as big as the left over space, factoring in the ListBox width, the ListBox margins.
+            // and the LayoutRoot's margins
+            InputSection->Width = ((availableWidth) -
+                (layoutRootMarginLeft + layoutRootMarginRight + listBoxMarginLeft + listBoxMarginRight));
+        }
+        else
+        {
+            // Make us as big as the left over space, factoring in just the LayoutRoot's margins.
+            if (autoSizeInputSectionWhenSnapped)
+            {
+                InputSection->Width = (windowWidth - (layoutRootMarginLeft + layoutRootMarginRight));
+            }
+        }
+    }
+    InvalidateViewState();
+}
+
+void MainPage::InvalidateViewState()
+{
+    // Are we going to snapped mode?
+    if (ApplicationView::Value == ApplicationViewState::Snapped)
+    {
+        Grid::SetRow(DescriptionText, 3);
+        Grid::SetColumn(DescriptionText, 0);
+
+        Grid::SetRow(InputSection, 4);
+        Grid::SetColumn(InputSection, 0);
+
+        Grid::SetRow(FooterPanel, 2);
+        Grid::SetColumn(FooterPanel, 0);
+    }
+    else
+    {
+        Grid::SetRow(DescriptionText, 1);
+        Grid::SetColumn(DescriptionText, 1);
+
+        Grid::SetRow(InputSection, 2);
+        Grid::SetColumn(InputSection, 1);
+
+        Grid::SetRow(FooterPanel, 1);
+        Grid::SetColumn(FooterPanel, 1);
+    }
+
+    //  Since we don't load the scenario page in the traditional manner (we just pluck out the
+    // input and output sections from the page) we need to ensure that any VSM code used
+    // by the scenario's input and output sections is fired.
+    VisualStateManager::GoToState(InputSection, "Input" + LayoutAwarePage::DetermineVisualState(ApplicationView::Value), false);
+    VisualStateManager::GoToState(OutputSection, "Output" + LayoutAwarePage::DetermineVisualState(ApplicationView::Value), false);
+}
+
+void MainPage::PopulateScenarios()
+{
+    ScenarioList = ref new Platform::Collections::Vector<Object^>();
+
+    // Populate the ListBox with the list of scenarios as defined in Constants.cpp.
+    for (unsigned int i = 0; i < scenarios->Length; ++i)
+    {
+        Scenario s = scenarios[i];
+        ListBoxItem^ item = ref new ListBoxItem();
+        item->Name = s.ClassName;
+        item->Content = (i + 1).ToString() + ") " + s.Title;
+        ScenarioList->Append(item);
+    }
+
+    // Bind the ListBox to the scenario list.
+    Scenarios->ItemsSource = ScenarioList;
+    Scenarios->ScrollIntoView(Scenarios->SelectedItem);
+}
+
+/// <summary>
+/// This method is responsible for loading the individual input and output sections for each scenario.  This
+/// is based on navigating a hidden Frame to the ScenarioX.xaml page and then extracting out the input
+/// and output sections into the respective UserControl on the main page.
+/// </summary>
+/// <param name="scenarioName"></param>
+void MainPage::LoadScenario(String^ scenarioName)
+{
+    autoSizeInputSectionWhenSnapped = true;
+
+    // Load the ScenarioX.xaml file into the Frame.
+    TypeName scenarioType = {scenarioName, TypeKind::Custom};
+    HiddenFrame->Navigate(scenarioType, this);
+
+    // Get the top element, the Page, so we can look up the elements
+    // that represent the input and output sections of the ScenarioX file.
+    Page^ hiddenPage = safe_cast<Page^>(HiddenFrame->Content);
+
+    // Get each element.
+    UIElement^ input = safe_cast<UIElement^>(hiddenPage->FindName("Input"));
+    UIElement^ output = safe_cast<UIElement^>(hiddenPage->FindName("Output"));
+
+    if (input == nullptr)
+    {
+        // Malformed input section.
+        NotifyUser("Cannot load scenario input section for " + scenarioName +
+            "  Make sure root of input section markup has x:Name of 'Input'", NotifyType::ErrorMessage);
+        return;
+    }
+
+    if (output == nullptr)
+    {
+        // Malformed output section.
+        NotifyUser("Cannot load scenario output section for " + scenarioName +
+            "  Make sure root of output section markup has x:Name of 'Output'", NotifyType::ErrorMessage);
+        return;
+    }
+
+    // Find the LayoutRoot which parents the input and output sections in the main page.
+    Panel^ panel = safe_cast<Panel^>(hiddenPage->FindName("LayoutRoot"));
+
+    if (panel != nullptr)
+    {
+        unsigned int index = 0;
+        UIElementCollection^ collection = panel->Children;
+
+        // Get rid of the content that is currently in the intput and output sections.
+        collection->IndexOf(input, &index);
+        collection->RemoveAt(index);
+
+        collection->IndexOf(output, &index);
+        collection->RemoveAt(index);
+
+        // Populate the input and output sections with the newly loaded content.
+        InputSection->Content = input;
+        OutputSection->Content = output;
+
+        ScenarioLoaded(this, nullptr);
+    }
+    else
+    {
+        // Malformed Scenario file.
+        NotifyUser("Cannot load scenario: " + scenarioName + ".  Make sure root tag in the '" +
+            scenarioName + "' file has an x:Name of 'LayoutRoot'", NotifyType::ErrorMessage);
+    }
+}
+
+void MainPage::Scenarios_SelectionChanged(Object^ sender, SelectionChangedEventArgs^ e)
+{
+    if (Scenarios->SelectedItem != nullptr)
+    {
+        NotifyUser("", NotifyType::StatusMessage);
+
+        LoadScenario((safe_cast<ListBoxItem^>(Scenarios->SelectedItem))->Name);
+        InvalidateSize();
+    }
+}
+
+void MainPage::NotifyUser(String^ strMessage, NotifyType type)
+{
+    switch (type)
+    {
+    case NotifyType::StatusMessage:
+        // Use the status message style.
+        StatusBlock->Style = safe_cast<Windows::UI::Xaml::Style^>(this->Resources->Lookup("StatusStyle"));
+        break;
+    case NotifyType::ErrorMessage:
+        // Use the error message style.
+        StatusBlock->Style = safe_cast<Windows::UI::Xaml::Style^>(this->Resources->Lookup("ErrorStyle"));
+        break;
+    default:
+        break;
+    }
+    StatusBlock->Text = strMessage;
+
+    // Collapsed the StatusBlock if it has no text to conserve real estate.
+    if (StatusBlock->Text != "")
+    {
+        StatusBlock->Visibility = Windows::UI::Xaml::Visibility::Visible;
+    }
+    else
+    {
+        StatusBlock->Visibility = Windows::UI::Xaml::Visibility::Collapsed;
+    }
+}
+
+void MainPage::Footer_Click(Object^ sender, RoutedEventArgs^ e)
+{
+    auto uri = ref new Uri((String^)((HyperlinkButton^)sender)->Tag);
+    Windows::System::Launcher::LaunchUriAsync(uri);
+}
+
+
+/// <summary>
+/// Populates the page with content passed during navigation.  Any saved state is also
+/// provided when recreating a page from a prior session.
+/// </summary>
+/// <param name="navigationParameter">The parameter value passed to
+/// <see cref="Frame::Navigate(Type, Object)"/> when this page was initially requested.
+/// </param>
+/// <param name="pageState">A map of state preserved by this page during an earlier
+/// session.  This will be null the first time a page is visited.</param>
+void MainPage::LoadState(Object^ navigationParameter, IMap<String^, Object^>^ pageState)
+{
+    (void) navigationParameter;    // Unused parameter
+
+    PopulateScenarios();
+
+    // Starting scenario is the first or based upon a previous state.
+    ListBoxItem^ startingScenario = nullptr;
+    int startingScenarioIndex = -1;
+
+    if (pageState != nullptr && pageState->HasKey("SelectedScenarioIndex"))
+    {
+        startingScenarioIndex = safe_cast<int>(pageState->Lookup("SelectedScenarioIndex"));
+    }
+
+    Scenarios->SelectedIndex = startingScenarioIndex != -1 ? startingScenarioIndex : 0;
+
+    InvalidateViewState();
+}
+
+/// <summary>
+/// Preserves state associated with this page in case the application is suspended or the
+/// page is discarded from the navigation cache.  Values must conform to the serialization
+/// requirements of <see cref="SuspensionManager::SessionState"/>.
+/// </summary>
+/// <param name="pageState">An empty map to be populated with serializable state.</param>
+void MainPage::SaveState(IMap<String^, Object^>^ pageState)
+{
+    int selectedListBoxItemIndex = Scenarios->SelectedIndex;
+    pageState->Insert("SelectedScenarioIndex", selectedListBoxItemIndex);
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MainPage.xaml.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MainPage.xaml.h
new file mode 100644
index 00000000..36fb7796
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MainPage.xaml.h
@@ -0,0 +1,105 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+//
+// MainPage.xaml.h
+// Declaration of the MainPage.xaml class.
+//
+
+#pragma once
+
+#include "pch.h"
+#include "MainPage.g.h"
+#include "Common\LayoutAwarePage.h" // Required by generated header
+#include "Constants.h"
+
+namespace SDKSample
+{
+    public enum class NotifyType
+    {
+        StatusMessage,
+        ErrorMessage
+    };
+
+    public ref class MainPageSizeChangedEventArgs sealed
+    {
+    public:
+        property Windows::UI::ViewManagement::ApplicationViewState ViewState
+        {
+            Windows::UI::ViewManagement::ApplicationViewState get()
+            {
+                return viewState;
+            }
+
+            void set(Windows::UI::ViewManagement::ApplicationViewState value)
+            {
+                viewState = value;
+            }
+        }
+
+    private:
+        Windows::UI::ViewManagement::ApplicationViewState viewState;
+    };
+
+    public ref class MainPage sealed
+    {
+    public:
+        MainPage();
+
+    protected:
+        virtual void LoadState(Platform::Object^ navigationParameter,
+            Windows::Foundation::Collections::IMap<Platform::String^, Platform::Object^>^ pageState) override;
+        virtual void SaveState(Windows::Foundation::Collections::IMap<Platform::String^, Platform::Object^>^ pageState) override;
+
+    internal:
+        property bool AutoSizeInputSectionWhenSnapped
+        {
+            bool get()
+            {
+                return autoSizeInputSectionWhenSnapped;
+            }
+
+            void set(bool value)
+            {
+                autoSizeInputSectionWhenSnapped = value;
+            }
+        }
+
+        property Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ LaunchArgs
+       {
+            Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ get()
+            {
+                return safe_cast<App^>(App::Current)->LaunchArgs;
+            }
+        }
+
+        void NotifyUser(Platform::String^ strMessage, NotifyType type);
+        void LoadScenario(Platform::String^ scenarioName);
+        event Windows::Foundation::EventHandler<Platform::Object^>^ ScenarioLoaded;
+        event Windows::Foundation::EventHandler<MainPageSizeChangedEventArgs^>^ MainPageResized;
+
+    private:
+        void PopulateScenarios();
+        void InvalidateSize();
+        void InvalidateViewState();
+
+        Platform::Collections::Vector<Object^>^ ScenarioList;
+        Windows::UI::Xaml::Controls::Frame^ HiddenFrame;
+        void Footer_Click(Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+        bool autoSizeInputSectionWhenSnapped;
+
+        void MainPage_SizeChanged(Object^ sender, Windows::UI::Xaml::SizeChangedEventArgs^ e);
+        void Scenarios_SelectionChanged(Object^ sender, Windows::UI::Xaml::Controls::SelectionChangedEventArgs^ e);
+
+    internal:
+        static MainPage^ Current;
+
+    };
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture.sln b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture.sln
new file mode 100644
index 00000000..f82f2039
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture.sln
@@ -0,0 +1,54 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MediaCapture", "MediaCapture.vcxproj", "{C5B886A7-8300-46FF-B533-9613DE2AF637}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OcvTransform", "MediaExtensions\OcvTransform\OcvTransform.vcxproj", "{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM = Debug|ARM
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|ARM = Release|ARM
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|ARM.ActiveCfg = Debug|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|ARM.Build.0 = Debug|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|ARM.Deploy.0 = Debug|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|Win32.Build.0 = Debug|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|Win32.Deploy.0 = Debug|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|x64.ActiveCfg = Debug|x64
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|x64.Build.0 = Debug|x64
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|x64.Deploy.0 = Debug|x64
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|ARM.ActiveCfg = Release|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|ARM.Build.0 = Release|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|ARM.Deploy.0 = Release|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|Win32.ActiveCfg = Release|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|Win32.Build.0 = Release|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|Win32.Deploy.0 = Release|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|x64.ActiveCfg = Release|x64
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|x64.Build.0 = Release|x64
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|x64.Deploy.0 = Release|x64
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|ARM.ActiveCfg = Debug|ARM
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|ARM.Build.0 = Debug|ARM
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|Win32.ActiveCfg = Debug|Win32
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|Win32.Build.0 = Debug|Win32
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|x64.ActiveCfg = Debug|x64
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|x64.Build.0 = Debug|x64
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|ARM.ActiveCfg = Release|ARM
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|ARM.Build.0 = Release|ARM
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|Win32.ActiveCfg = Release|Win32
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|Win32.Build.0 = Release|Win32
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|x64.ActiveCfg = Release|x64
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture.vcxproj b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture.vcxproj
new file mode 100644
index 00000000..ae243ce7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture.vcxproj
@@ -0,0 +1,200 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C5B886A7-8300-46FF-B533-9613DE2AF637}</ProjectGuid>
+    <RootNamespace>SDKSample</RootNamespace>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>12.0</MinimumVisualStudioVersion>
+    <AppContainerApplication>true</AppContainerApplication>
+    <ProjectName>MediaCapture</ProjectName>
+    <ApplicationType>Windows Store</ApplicationType>
+    <ApplicationTypeRevision>8.1</ApplicationTypeRevision>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros">
+    <AppxAutoIncrementPackageRevision>True</AppxAutoIncrementPackageRevision>
+    <AppxBundlePlatforms>x86</AppxBundlePlatforms>
+    <PackageCertificateThumbprint>76D64E4F88C9B7D47ACA757CDFD15D6F3AD81D92</PackageCertificateThumbprint>
+    <PackageCertificateKeyFile>MediaCapture_TemporaryKey.pfx</PackageCertificateKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LibraryPath>$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>	
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="AdvancedCapture.xaml.h">
+      <DependentUpon>AdvancedCapture.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </ClInclude>
+    <ClInclude Include="Constants.h" />
+    <ClInclude Include="MainPage.xaml.h">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClInclude>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="Common\LayoutAwarePage.h" />
+    <ClInclude Include="Common\SuspensionManager.h" />
+    <ClInclude Include="App.xaml.h">
+      <DependentUpon>App.xaml</DependentUpon>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+    <Page Include="AdvancedCapture.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="Common\StandardStyles.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="MainPage.xaml" />
+    <Page Include="Sample-Utils\SampleTemplateStyles.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest">
+      <SubType>Designer</SubType>
+    </AppxManifest>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="AdvancedCapture.xaml.cpp">
+      <DependentUpon>AdvancedCapture.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
+    <ClCompile Include="App.xaml.cpp">
+      <DependentUpon>App.xaml</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="Common\LayoutAwarePage.cpp" />
+    <ClCompile Include="Constants.cpp" />
+    <ClCompile Include="Common\SuspensionManager.cpp" />
+    <ClCompile Include="MainPage.xaml.cpp">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="assets\opencv-logo-150.png" />
+    <Image Include="assets\opencv-logo-30.png" />
+    <Image Include="Assets\splash-sdk.png" />
+    <Image Include="Assets\StoreLogo.png" />
+    <Image Include="Assets\windows-sdk.scale-100.png">
+      <DeploymentContent>true</DeploymentContent>
+    </Image>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="MediaExtensions\OcvTransform\OcvTransform.vcxproj">
+      <Project>{ba69218f-da5c-4d14-a78d-21a9e4dec669}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture.vcxproj.filters b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture.vcxproj.filters
new file mode 100644
index 00000000..fd077005
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture.vcxproj.filters
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="AdvancedCapture.xaml.cpp" />
+    <ClCompile Include="App.xaml.cpp" />
+    <ClCompile Include="Common\LayoutAwarePage.cpp" />
+    <ClCompile Include="Constants.cpp" />
+    <ClCompile Include="Common\SuspensionManager.cpp" />
+    <ClCompile Include="MainPage.xaml.cpp" />
+    <ClCompile Include="pch.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="AdvancedCapture.xaml.h" />
+    <ClInclude Include="Constants.h" />
+    <ClInclude Include="MainPage.xaml.h" />
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="Common\LayoutAwarePage.h" />
+    <ClInclude Include="Common\SuspensionManager.h" />
+    <ClInclude Include="App.xaml.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="assets\opencv-logo-30.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="assets\opencv-logo-150.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\splash-sdk.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\StoreLogo.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\windows-sdk.scale-100.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest" />
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="AdvancedCapture.xaml" />
+    <Page Include="Common\StandardStyles.xaml" />
+    <Page Include="MainPage.xaml" />
+    <Page Include="Sample-Utils\SampleTemplateStyles.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="Assets">
+      <UniqueIdentifier>{392352d8-f913-4741-82cf-d8075bb6f022}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="MediaCapture_TemporaryKey.pfx" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture_TemporaryKey.pfx b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture_TemporaryKey.pfx
new file mode 100644
index 00000000..0f4f0d9e
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaCapture_TemporaryKey.pfx differ
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/AsyncCB.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/AsyncCB.h
new file mode 100644
index 00000000..3321b47c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/AsyncCB.h
@@ -0,0 +1,81 @@
+#pragma once
+
+//////////////////////////////////////////////////////////////////////////
+//  AsyncCallback [template]
+//
+//  Description:
+//  Helper class that routes IMFAsyncCallback::Invoke calls to a class
+//  method on the parent class.
+//
+//  Usage:
+//  Add this class as a member variable. In the parent class constructor,
+//  initialize the AsyncCallback class like this:
+//  	m_cb(this, &CYourClass::OnInvoke)
+//  where
+//      m_cb       = AsyncCallback object
+//      CYourClass = parent class
+//      OnInvoke   = Method in the parent class to receive Invoke calls.
+//
+//  The parent's OnInvoke method (you can name it anything you like) must
+//  have a signature that matches the InvokeFn typedef below.
+//////////////////////////////////////////////////////////////////////////
+
+// T: Type of the parent object
+template<class T>
+class AsyncCallback : public IMFAsyncCallback
+{
+public:
+    typedef HRESULT (T::*InvokeFn)(IMFAsyncResult *pAsyncResult);
+
+    AsyncCallback(T *pParent, InvokeFn fn) : m_pParent(pParent), m_pInvokeFn(fn)
+    {
+    }
+
+    // IUnknown
+    STDMETHODIMP_(ULONG) AddRef() {
+        // Delegate to parent class.
+        return m_pParent->AddRef();
+    }
+    STDMETHODIMP_(ULONG) Release() {
+        // Delegate to parent class.
+        return m_pParent->Release();
+    }
+    STDMETHODIMP QueryInterface(REFIID iid, void** ppv)
+    {
+        if (!ppv)
+        {
+            return E_POINTER;
+        }
+        if (iid == __uuidof(IUnknown))
+        {
+            *ppv = static_cast<IUnknown*>(static_cast<IMFAsyncCallback*>(this));
+        }
+        else if (iid == __uuidof(IMFAsyncCallback))
+        {
+            *ppv = static_cast<IMFAsyncCallback*>(this);
+        }
+        else
+        {
+            *ppv = NULL;
+            return E_NOINTERFACE;
+        }
+        AddRef();
+        return S_OK;
+    }
+
+
+    // IMFAsyncCallback methods
+    STDMETHODIMP GetParameters(DWORD*, DWORD*)
+    {
+        // Implementation of this method is optional.
+        return E_NOTIMPL;
+    }
+
+    STDMETHODIMP Invoke(IMFAsyncResult* pAsyncResult)
+    {
+        return (m_pParent->*m_pInvokeFn)(pAsyncResult);
+    }
+
+    T *m_pParent;
+    InvokeFn m_pInvokeFn;
+};
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/BufferLock.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/BufferLock.h
new file mode 100644
index 00000000..1c47deab
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/BufferLock.h
@@ -0,0 +1,101 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+
+
+#pragma once
+
+
+//////////////////////////////////////////////////////////////////////////
+//  VideoBufferLock
+//
+//  Description:
+//  Locks a video buffer that might or might not support IMF2DBuffer.
+//
+//////////////////////////////////////////////////////////////////////////
+
+class VideoBufferLock
+{
+public:
+    VideoBufferLock(IMFMediaBuffer *pBuffer) : m_p2DBuffer(NULL)
+    {
+        m_pBuffer = pBuffer;
+        m_pBuffer->AddRef();
+
+        // Query for the 2-D buffer interface. OK if this fails.
+        m_pBuffer->QueryInterface(IID_PPV_ARGS(&m_p2DBuffer));
+    }
+
+    ~VideoBufferLock()
+    {
+        UnlockBuffer();
+        SafeRelease(&m_pBuffer);
+        SafeRelease(&m_p2DBuffer);
+    }
+
+    // LockBuffer:
+    // Locks the buffer. Returns a pointer to scan line 0 and returns the stride.
+
+    // The caller must provide the default stride as an input parameter, in case
+    // the buffer does not expose IMF2DBuffer. You can calculate the default stride
+    // from the media type.
+
+    HRESULT LockBuffer(
+        LONG  lDefaultStride,    // Minimum stride (with no padding).
+        DWORD dwHeightInPixels,  // Height of the image, in pixels.
+        BYTE  **ppbScanLine0,    // Receives a pointer to the start of scan line 0.
+        LONG  *plStride          // Receives the actual stride.
+        )
+    {
+        HRESULT hr = S_OK;
+
+        // Use the 2-D version if available.
+        if (m_p2DBuffer)
+        {
+            hr = m_p2DBuffer->Lock2D(ppbScanLine0, plStride);
+        }
+        else
+        {
+            // Use non-2D version.
+            BYTE *pData = NULL;
+
+            hr = m_pBuffer->Lock(&pData, NULL, NULL);
+            if (SUCCEEDED(hr))
+            {
+                *plStride = lDefaultStride;
+                if (lDefaultStride < 0)
+                {
+                    // Bottom-up orientation. Return a pointer to the start of the
+                    // last row *in memory* which is the top row of the image.
+                    *ppbScanLine0 = pData + abs(lDefaultStride) * (dwHeightInPixels - 1);
+                }
+                else
+                {
+                    // Top-down orientation. Return a pointer to the start of the
+                    // buffer.
+                    *ppbScanLine0 = pData;
+                }
+            }
+        }
+        return hr;
+    }
+
+    HRESULT UnlockBuffer()
+    {
+        if (m_p2DBuffer)
+        {
+            return m_p2DBuffer->Unlock2D();
+        }
+        else
+        {
+            return m_pBuffer->Unlock();
+        }
+    }
+
+private:
+    IMFMediaBuffer  *m_pBuffer;
+    IMF2DBuffer     *m_p2DBuffer;
+};
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/CritSec.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/CritSec.h
new file mode 100644
index 00000000..88851f9f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/CritSec.h
@@ -0,0 +1,62 @@
+#pragma once
+
+//////////////////////////////////////////////////////////////////////////
+//  CritSec
+//  Description: Wraps a critical section.
+//////////////////////////////////////////////////////////////////////////
+
+class CritSec
+{
+public:
+    CRITICAL_SECTION m_criticalSection;
+public:
+    CritSec()
+    {
+        InitializeCriticalSectionEx(&m_criticalSection, 100, 0);
+    }
+
+    ~CritSec()
+    {
+        DeleteCriticalSection(&m_criticalSection);
+    }
+
+    _Acquires_lock_(m_criticalSection)
+    void Lock()
+    {
+        EnterCriticalSection(&m_criticalSection);
+    }
+
+    _Releases_lock_(m_criticalSection)
+    void Unlock()
+    {
+        LeaveCriticalSection(&m_criticalSection);
+    }
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+//  AutoLock
+//  Description: Provides automatic locking and unlocking of a
+//               of a critical section.
+//
+//  Note: The AutoLock object must go out of scope before the CritSec.
+//////////////////////////////////////////////////////////////////////////
+
+class AutoLock
+{
+private:
+    CritSec *m_pCriticalSection;
+public:
+    _Acquires_lock_(m_pCriticalSection)
+    AutoLock(CritSec& crit)
+    {
+        m_pCriticalSection = &crit;
+        m_pCriticalSection->Lock();
+    }
+
+    _Releases_lock_(m_pCriticalSection)
+    ~AutoLock()
+    {
+        m_pCriticalSection->Unlock();
+    }
+};
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/LinkList.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/LinkList.h
new file mode 100644
index 00000000..3657b3d7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/LinkList.h
@@ -0,0 +1,516 @@
+//-----------------------------------------------------------------------------
+// File: Linklist.h
+// Desc: Linked list class.
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+//  Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+// Notes:
+//
+// The List class template implements a simple double-linked list.
+// It uses STL's copy semantics.
+
+// There are two versions of the Clear() method:
+//  Clear(void) clears the list w/out cleaning up the object.
+//  Clear(FN fn) takes a functor object that releases the objects, if they need cleanup.
+
+// The List class supports enumeration. Example of usage:
+//
+// List<T>::POSIITON pos = list.GetFrontPosition();
+// while (pos != list.GetEndPosition())
+// {
+//     T item;
+//     hr = list.GetItemPos(&item);
+//     pos = list.Next(pos);
+// }
+
+// The ComPtrList class template derives from List<> and implements a list of COM pointers.
+
+template <class T>
+struct NoOp
+{
+    void operator()(T& t)
+    {
+    }
+};
+
+template <class T>
+class List
+{
+protected:
+
+    // Nodes in the linked list
+    struct Node
+    {
+        Node *prev;
+        Node *next;
+        T    item;
+
+        Node() : prev(nullptr), next(nullptr)
+        {
+        }
+
+        Node(T item) : prev(nullptr), next(nullptr)
+        {
+            this->item = item;
+        }
+
+        T Item() const { return item; }
+    };
+
+public:
+
+    // Object for enumerating the list.
+    class POSITION
+    {
+        friend class List<T>;
+
+    public:
+        POSITION() : pNode(nullptr)
+        {
+        }
+
+        bool operator==(const POSITION &p) const
+        {
+            return pNode == p.pNode;
+        }
+
+        bool operator!=(const POSITION &p) const
+        {
+            return pNode != p.pNode;
+        }
+
+    private:
+        const Node *pNode;
+
+        POSITION(Node *p) : pNode(p)
+        {
+        }
+    };
+
+protected:
+    Node    m_anchor;  // Anchor node for the linked list.
+    DWORD   m_count;   // Number of items in the list.
+
+    Node* Front() const
+    {
+        return m_anchor.next;
+    }
+
+    Node* Back() const
+    {
+        return m_anchor.prev;
+    }
+
+    virtual HRESULT InsertAfter(T item, Node *pBefore)
+    {
+        if (pBefore == nullptr)
+        {
+            return E_POINTER;
+        }
+
+        Node *pNode = new Node(item);
+        if (pNode == nullptr)
+        {
+            return E_OUTOFMEMORY;
+        }
+
+        Node *pAfter = pBefore->next;
+
+        pBefore->next = pNode;
+        pAfter->prev = pNode;
+
+        pNode->prev = pBefore;
+        pNode->next = pAfter;
+
+        m_count++;
+
+        return S_OK;
+    }
+
+    virtual HRESULT GetItem(const Node *pNode, T* ppItem)
+    {
+        if (pNode == nullptr || ppItem == nullptr)
+        {
+            return E_POINTER;
+        }
+
+        *ppItem = pNode->item;
+        return S_OK;
+    }
+
+    // RemoveItem:
+    // Removes a node and optionally returns the item.
+    // ppItem can be nullptr.
+    virtual HRESULT RemoveItem(Node *pNode, T *ppItem)
+    {
+        if (pNode == nullptr)
+        {
+            return E_POINTER;
+        }
+
+        assert(pNode != &m_anchor); // We should never try to remove the anchor node.
+        if (pNode == &m_anchor)
+        {
+            return E_INVALIDARG;
+        }
+
+
+        T item;
+
+        // The next node's previous is this node's previous.
+        pNode->next->prev = pNode->prev;
+
+        // The previous node's next is this node's next.
+        pNode->prev->next = pNode->next;
+
+        item = pNode->item;
+        delete pNode;
+
+        m_count--;
+
+        if (ppItem)
+        {
+            *ppItem = item;
+        }
+
+        return S_OK;
+    }
+
+public:
+
+    List()
+    {
+        m_anchor.next = &m_anchor;
+        m_anchor.prev = &m_anchor;
+
+        m_count = 0;
+    }
+
+    virtual ~List()
+    {
+        Clear();
+    }
+
+    // Insertion functions
+    HRESULT InsertBack(T item)
+    {
+        return InsertAfter(item, m_anchor.prev);
+    }
+
+
+    HRESULT InsertFront(T item)
+    {
+        return InsertAfter(item, &m_anchor);
+    }
+
+    HRESULT InsertPos(POSITION pos, T item)
+    {
+        if (pos.pNode == nullptr)
+        {
+            return InsertBack(item);
+        }
+
+        return InsertAfter(item, pos.pNode->prev);
+    }
+
+    // RemoveBack: Removes the tail of the list and returns the value.
+    // ppItem can be nullptr if you don't want the item back. (But the method does not release the item.)
+    HRESULT RemoveBack(T *ppItem)
+    {
+        if (IsEmpty())
+        {
+            return E_FAIL;
+        }
+        else
+        {
+            return RemoveItem(Back(), ppItem);
+        }
+    }
+
+    // RemoveFront: Removes the head of the list and returns the value.
+    // ppItem can be nullptr if you don't want the item back. (But the method does not release the item.)
+    HRESULT RemoveFront(T *ppItem)
+    {
+        if (IsEmpty())
+        {
+            return E_FAIL;
+        }
+        else
+        {
+            return RemoveItem(Front(), ppItem);
+        }
+    }
+
+    // GetBack: Gets the tail item.
+    HRESULT GetBack(T *ppItem)
+    {
+        if (IsEmpty())
+        {
+            return E_FAIL;
+        }
+        else
+        {
+            return GetItem(Back(), ppItem);
+        }
+    }
+
+    // GetFront: Gets the front item.
+    HRESULT GetFront(T *ppItem)
+    {
+        if (IsEmpty())
+        {
+            return E_FAIL;
+        }
+        else
+        {
+            return GetItem(Front(), ppItem);
+        }
+    }
+
+
+    // GetCount: Returns the number of items in the list.
+    DWORD GetCount() const { return m_count; }
+
+    bool IsEmpty() const
+    {
+        return (GetCount() == 0);
+    }
+
+    // Clear: Takes a functor object whose operator()
+    // frees the object on the list.
+    template <class FN>
+    void Clear(FN& clear_fn)
+    {
+        Node *n = m_anchor.next;
+
+        // Delete the nodes
+        while (n != &m_anchor)
+        {
+            clear_fn(n->item);
+
+            Node *tmp = n->next;
+            delete n;
+            n = tmp;
+        }
+
+        // Reset the anchor to point at itself
+        m_anchor.next = &m_anchor;
+        m_anchor.prev = &m_anchor;
+
+        m_count = 0;
+    }
+
+    // Clear: Clears the list. (Does not delete or release the list items.)
+    virtual void Clear()
+    {
+        NoOp<T> clearOp;
+        Clear<>(clearOp);
+    }
+
+
+    // Enumerator functions
+
+    POSITION FrontPosition()
+    {
+        if (IsEmpty())
+        {
+            return POSITION(nullptr);
+        }
+        else
+        {
+            return POSITION(Front());
+        }
+    }
+
+    POSITION EndPosition() const
+    {
+        return POSITION();
+    }
+
+    HRESULT GetItemPos(POSITION pos, T *ppItem)
+    {
+        if (pos.pNode)
+        {
+            return GetItem(pos.pNode, ppItem);
+        }
+        else
+        {
+            return E_FAIL;
+        }
+    }
+
+    POSITION Next(const POSITION pos)
+    {
+        if (pos.pNode && (pos.pNode->next != &m_anchor))
+        {
+            return POSITION(pos.pNode->next);
+        }
+        else
+        {
+            return POSITION(nullptr);
+        }
+    }
+
+    // Remove an item at a position.
+    // The item is returns in ppItem, unless ppItem is nullptr.
+    // NOTE: This method invalidates the POSITION object.
+    HRESULT Remove(POSITION& pos, T *ppItem)
+    {
+        if (pos.pNode)
+        {
+            // Remove const-ness temporarily...
+            Node *pNode = const_cast<Node*>(pos.pNode);
+
+            pos = POSITION();
+
+            return RemoveItem(pNode, ppItem);
+        }
+        else
+        {
+            return E_INVALIDARG;
+        }
+    }
+
+};
+
+
+
+// Typical functors for Clear method.
+
+// ComAutoRelease: Releases COM pointers.
+// MemDelete: Deletes pointers to new'd memory.
+
+class ComAutoRelease
+{
+public:
+    void operator()(IUnknown *p)
+    {
+        if (p)
+        {
+            p->Release();
+        }
+    }
+};
+
+class MemDelete
+{
+public:
+    void operator()(void *p)
+    {
+        if (p)
+        {
+            delete p;
+        }
+    }
+};
+
+
+// ComPtrList class
+// Derived class that makes it safer to store COM pointers in the List<> class.
+// It automatically AddRef's the pointers that are inserted onto the list
+// (unless the insertion method fails).
+//
+// T must be a COM interface type.
+// example: ComPtrList<IUnknown>
+//
+// NULLABLE: If true, client can insert nullptr pointers. This means GetItem can
+// succeed but return a nullptr pointer. By default, the list does not allow nullptr
+// pointers.
+
+template <class T, bool NULLABLE = FALSE>
+class ComPtrList : public List<T*>
+{
+public:
+
+    typedef T* Ptr;
+
+    void Clear()
+    {
+        ComAutoRelease car;
+        List<Ptr>::Clear(car);
+    }
+
+    ~ComPtrList()
+    {
+        Clear();
+    }
+
+protected:
+    HRESULT InsertAfter(Ptr item, Node *pBefore)
+    {
+        // Do not allow nullptr item pointers unless NULLABLE is true.
+        if (item == nullptr && !NULLABLE)
+        {
+            return E_POINTER;
+        }
+
+        if (item)
+        {
+            item->AddRef();
+        }
+
+        HRESULT hr = List<Ptr>::InsertAfter(item, pBefore);
+        if (FAILED(hr) && item != nullptr)
+        {
+            item->Release();
+        }
+        return hr;
+    }
+
+    HRESULT GetItem(const Node *pNode, Ptr* ppItem)
+    {
+        Ptr pItem = nullptr;
+
+        // The base class gives us the pointer without AddRef'ing it.
+        // If we return the pointer to the caller, we must AddRef().
+        HRESULT hr = List<Ptr>::GetItem(pNode, &pItem);
+        if (SUCCEEDED(hr))
+        {
+            assert(pItem || NULLABLE);
+            if (pItem)
+            {
+                *ppItem = pItem;
+                (*ppItem)->AddRef();
+            }
+        }
+        return hr;
+    }
+
+    HRESULT RemoveItem(Node *pNode, Ptr *ppItem)
+    {
+        // ppItem can be nullptr, but we need to get the
+        // item so that we can release it.
+
+        // If ppItem is not nullptr, we will AddRef it on the way out.
+
+        Ptr pItem = nullptr;
+
+        HRESULT hr = List<Ptr>::RemoveItem(pNode, &pItem);
+
+        if (SUCCEEDED(hr))
+        {
+            assert(pItem || NULLABLE);
+            if (ppItem && pItem)
+            {
+                *ppItem = pItem;
+                (*ppItem)->AddRef();
+            }
+
+            if (pItem)
+            {
+                pItem->Release();
+                pItem = nullptr;
+            }
+        }
+
+        return hr;
+    }
+};
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/OpQueue.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/OpQueue.h
new file mode 100644
index 00000000..73f3042c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/Common/OpQueue.h
@@ -0,0 +1,222 @@
+//////////////////////////////////////////////////////////////////////////
+//
+// OpQueue.h
+// Async operation queue.
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+//////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#pragma warning( push )
+#pragma warning( disable : 4355 )  // 'this' used in base member initializer list
+
+/*
+    This header file defines an object to help queue and serialize
+    asynchronous operations.
+
+    Background:
+
+    To perform an operation asynchronously in Media Foundation, an object
+    does one of the following:
+
+        1. Calls MFPutWorkItem(Ex), using either a standard work queue
+           identifier or a caller-allocated work queue. The work-queue
+           thread invokes the object's callback.
+
+        2. Creates an async result object (IMFAsyncResult) and calls
+           MFInvokeCallback to invoke the object's callback.
+
+    Ultimately, either of these cause the object's callback to be invoked
+    from a work-queue thread. The object can then complete the operation
+    inside the callback.
+
+    However, the Media Foundation platform may dispatch async callbacks in
+    parallel on several threads. Putting an item on a work queue does NOT
+    guarantee that one operation will complete before the next one starts,
+    or even that work items will be dispatched in the same order they were
+    called.
+
+    To serialize async operations that should not overlap, an object should
+    use a queue. While one operation is pending, subsequent operations are
+    put on the queue, and only dispatched after the previous operation is
+    complete.
+
+    The granularity of a single "operation" depends on the requirements of
+    that particular object. A single operation might involve several
+    asynchronous calls before the object dispatches the next operation on
+    the queue.
+
+
+*/
+
+
+
+//-------------------------------------------------------------------
+// OpQueue class template
+//
+// Base class for an async operation queue.
+//
+// TOperation: The class used to describe operations. This class must
+//          implement IUnknown.
+//
+// The OpQueue class is an abstract class. The derived class must
+// implement the following pure-virtual methods:
+//
+// - IUnknown methods (AddRef, Release, QI)
+//
+// - DispatchOperation:
+//
+//      Performs the asynchronous operation specified by pOp.
+//
+//      At the end of each operation, the derived class must call
+//      ProcessQueue to process the next operation in the queue.
+//
+//      NOTE: An operation is not required to complete inside the
+//      DispatchOperation method. A single operation might consist
+//      of several asynchronous method calls.
+//
+// - ValidateOperation:
+//
+//      Checks whether the object can perform the operation specified
+//      by pOp at this time.
+//
+//      If the object cannot perform the operation now (e.g., because
+//      another operation is still in progress) the method should
+//      return MF_E_NOTACCEPTING.
+//
+//-------------------------------------------------------------------
+#include "linklist.h"
+#include "AsyncCB.h"
+
+template <class T, class TOperation>
+class OpQueue //: public IUnknown
+{
+public:
+
+    typedef ComPtrList<TOperation>   OpList;
+
+    HRESULT QueueOperation(TOperation *pOp);
+
+protected:
+
+    HRESULT ProcessQueue();
+    HRESULT ProcessQueueAsync(IMFAsyncResult *pResult);
+
+    virtual HRESULT DispatchOperation(TOperation *pOp) = 0;
+    virtual HRESULT ValidateOperation(TOperation *pOp) = 0;
+
+    OpQueue(CRITICAL_SECTION& critsec)
+        : m_OnProcessQueue(static_cast<T *>(this), &OpQueue::ProcessQueueAsync),
+          m_critsec(critsec)
+    {
+    }
+
+    virtual ~OpQueue()
+    {
+    }
+
+protected:
+    OpList                  m_OpQueue;         // Queue of operations.
+    CRITICAL_SECTION&       m_critsec;         // Protects the queue state.
+    AsyncCallback<T>  m_OnProcessQueue;  // ProcessQueueAsync callback.
+};
+
+
+
+//-------------------------------------------------------------------
+// Place an operation on the queue.
+// Public method.
+//-------------------------------------------------------------------
+
+template <class T, class TOperation>
+HRESULT OpQueue<T, TOperation>::QueueOperation(TOperation *pOp)
+{
+    HRESULT hr = S_OK;
+
+    EnterCriticalSection(&m_critsec);
+
+    hr = m_OpQueue.InsertBack(pOp);
+    if (SUCCEEDED(hr))
+    {
+        hr = ProcessQueue();
+    }
+
+    LeaveCriticalSection(&m_critsec);
+    return hr;
+}
+
+
+//-------------------------------------------------------------------
+// Process the next operation on the queue.
+// Protected method.
+//
+// Note: This method dispatches the operation to a work queue.
+//-------------------------------------------------------------------
+
+template <class T, class TOperation>
+HRESULT OpQueue<T, TOperation>::ProcessQueue()
+{
+    HRESULT hr = S_OK;
+    if (m_OpQueue.GetCount() > 0)
+    {
+        hr = MFPutWorkItem2(
+            MFASYNC_CALLBACK_QUEUE_STANDARD,    // Use the standard work queue.
+            0,                                  // Default priority
+            &m_OnProcessQueue,                  // Callback method.
+            nullptr                             // State object.
+            );
+    }
+    return hr;
+}
+
+
+//-------------------------------------------------------------------
+// Process the next operation on the queue.
+// Protected method.
+//
+// Note: This method is called from a work-queue thread.
+//-------------------------------------------------------------------
+
+template <class T, class TOperation>
+HRESULT OpQueue<T, TOperation>::ProcessQueueAsync(IMFAsyncResult *pResult)
+{
+    HRESULT hr = S_OK;
+    TOperation *pOp = nullptr;
+
+    EnterCriticalSection(&m_critsec);
+
+    if (m_OpQueue.GetCount() > 0)
+    {
+        hr = m_OpQueue.GetFront(&pOp);
+
+        if (SUCCEEDED(hr))
+        {
+            hr = ValidateOperation(pOp);
+        }
+        if (SUCCEEDED(hr))
+        {
+            hr = m_OpQueue.RemoveFront(nullptr);
+        }
+        if (SUCCEEDED(hr))
+        {
+            (void)DispatchOperation(pOp);
+        }
+    }
+
+    if (pOp != nullptr)
+    {
+        pOp->Release();
+    }
+
+    LeaveCriticalSection(&m_critsec);
+    return hr;
+}
+
+#pragma warning( pop )
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvImageManipulations.idl b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvImageManipulations.idl
new file mode 100644
index 00000000..1bec5d0d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvImageManipulations.idl
@@ -0,0 +1,12 @@
+import "Windows.Media.idl";
+
+#include <sdkddkver.h>
+
+namespace OcvTransform
+{
+    [version(NTDDI_WIN8)]
+    runtimeclass OcvImageManipulations
+    {
+        interface Windows.Media.IMediaExtension;
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.cpp b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.cpp
new file mode 100644
index 00000000..a2854d23
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.cpp
@@ -0,0 +1,1499 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+#include "OcvTransform.h"
+#include "bufferlock.h"
+
+#include <opencv2\core.hpp>
+#include <opencv2\imgproc.hpp>
+#include <opencv2\features2d.hpp>
+
+
+
+using namespace Microsoft::WRL;
+
+/*
+
+This sample implements a video effect as a Media Foundation transform (MFT).
+
+NOTES ON THE MFT IMPLEMENTATION
+
+1. The MFT has fixed streams: One input stream and one output stream.
+
+2. The MFT supports NV12 format only.
+
+3. If the MFT is holding an input sample, SetInputType and SetOutputType both fail.
+
+4. The input and output types must be identical.
+
+5. If both types are set, no type can be set until the current type is cleared.
+
+6. Preferred input types:
+
+     (a) If the output type is set, that's the preferred type.
+     (b) Otherwise, the preferred types are partial types, constructed from the
+         list of supported subtypes.
+
+7. Preferred output types: As above.
+
+8. Streaming:
+
+    The private BeingStreaming() method is called in response to the
+    MFT_MESSAGE_NOTIFY_BEGIN_STREAMING message.
+
+    If the client does not send MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, the MFT calls
+    BeginStreaming inside the first call to ProcessInput or ProcessOutput.
+
+    This is a good approach for allocating resources that your MFT requires for
+    streaming.
+
+9. The configuration attributes are applied in the BeginStreaming method. If the
+   client changes the attributes during streaming, the change is ignored until
+   streaming is stopped (either by changing the media types or by sending the
+   MFT_MESSAGE_NOTIFY_END_STREAMING message) and then restarted.
+
+*/
+
+
+// Static array of media types (preferred and accepted).
+const GUID g_MediaSubtypes[] =
+{
+    MFVideoFormat_NV12
+};
+
+HRESULT GetDefaultStride(IMFMediaType *pType, LONG *plStride);
+
+template <typename T>
+inline T clamp(const T& val, const T& minVal, const T& maxVal)
+{
+    return (val < minVal ? minVal : (val > maxVal ? maxVal : val));
+}
+
+OcvImageManipulations::OcvImageManipulations() :
+    m_pSample(NULL), m_pInputType(NULL), m_pOutputType(NULL),
+    m_imageWidthInPixels(0), m_imageHeightInPixels(0), m_cbImageSize(0),
+    m_TransformType(Preview), m_bStreamingInitialized(false),
+    m_pAttributes(NULL)
+{
+    InitializeCriticalSectionEx(&m_critSec, 3000, 0);
+}
+
+OcvImageManipulations::~OcvImageManipulations()
+{
+    SafeRelease(&m_pInputType);
+    SafeRelease(&m_pOutputType);
+    SafeRelease(&m_pSample);
+    SafeRelease(&m_pAttributes);
+    DeleteCriticalSection(&m_critSec);
+}
+
+// Initialize the instance.
+STDMETHODIMP OcvImageManipulations::RuntimeClassInitialize()
+{
+    // Create the attribute store.
+    return MFCreateAttributes(&m_pAttributes, 3);
+}
+
+// IMediaExtension methods
+
+//-------------------------------------------------------------------
+// SetProperties
+// Sets the configuration of the effect
+//-------------------------------------------------------------------
+HRESULT OcvImageManipulations::SetProperties(ABI::Windows::Foundation::Collections::IPropertySet *pConfiguration)
+{
+    HRESULT hr = S_OK;
+
+    if (!pConfiguration)
+        return hr;
+
+    HSTRING key;
+    WindowsCreateString(L"{698649BE-8EAE-4551-A4CB-3EC98FBD3D86}", 38, &key);
+    Microsoft::WRL::ComPtr<ABI::Windows::Foundation::Collections::IMap<HSTRING, IInspectable *>> spSetting;
+    pConfiguration->QueryInterface(IID_PPV_ARGS(&spSetting));
+    boolean found;
+    spSetting->HasKey(key, &found);
+
+    if (found)
+    {
+        Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IPropertyValue> spPropVal;
+        Microsoft::WRL::ComPtr<IInspectable> spInsp;
+
+        spSetting->Lookup(key, spInsp.ReleaseAndGetAddressOf());
+
+        hr = spInsp.As(&spPropVal);
+        if (hr != S_OK)
+        {
+            return hr;
+        }
+
+        INT32 effect;
+        hr = spPropVal->GetInt32(&effect);
+        if (hr != S_OK)
+        {
+            return hr;
+        }
+
+        if ((effect >= 0) && (effect < InvalidEffect))
+        {
+            m_TransformType = (ProcessingType)effect;
+        }
+    }
+
+    return hr;
+}
+
+// IMFTransform methods. Refer to the Media Foundation SDK documentation for details.
+
+//-------------------------------------------------------------------
+// GetStreamLimits
+// Returns the minimum and maximum number of streams.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetStreamLimits(
+    DWORD   *pdwInputMinimum,
+    DWORD   *pdwInputMaximum,
+    DWORD   *pdwOutputMinimum,
+    DWORD   *pdwOutputMaximum
+)
+{
+    if ((pdwInputMinimum == NULL) ||
+        (pdwInputMaximum == NULL) ||
+        (pdwOutputMinimum == NULL) ||
+        (pdwOutputMaximum == NULL))
+    {
+        return E_POINTER;
+    }
+
+    // This MFT has a fixed number of streams.
+    *pdwInputMinimum = 1;
+    *pdwInputMaximum = 1;
+    *pdwOutputMinimum = 1;
+    *pdwOutputMaximum = 1;
+    return S_OK;
+}
+
+
+//-------------------------------------------------------------------
+// GetStreamCount
+// Returns the actual number of streams.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetStreamCount(
+    DWORD   *pcInputStreams,
+    DWORD   *pcOutputStreams
+)
+{
+    if ((pcInputStreams == NULL) || (pcOutputStreams == NULL))
+
+    {
+        return E_POINTER;
+    }
+
+    // This MFT has a fixed number of streams.
+    *pcInputStreams = 1;
+    *pcOutputStreams = 1;
+    return S_OK;
+}
+
+
+
+//-------------------------------------------------------------------
+// GetStreamIDs
+// Returns stream IDs for the input and output streams.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetStreamIDs(
+    DWORD   dwInputIDArraySize,
+    DWORD   *pdwInputIDs,
+    DWORD   dwOutputIDArraySize,
+    DWORD   *pdwOutputIDs
+)
+{
+    // It is not required to implement this method if the MFT has a fixed number of
+    // streams AND the stream IDs are numbered sequentially from zero (that is, the
+    // stream IDs match the stream indexes).
+
+    // In that case, it is OK to return E_NOTIMPL.
+    return E_NOTIMPL;
+}
+
+
+//-------------------------------------------------------------------
+// GetInputStreamInfo
+// Returns information about an input stream.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetInputStreamInfo(
+    DWORD                     dwInputStreamID,
+    MFT_INPUT_STREAM_INFO *   pStreamInfo
+)
+{
+    if (pStreamInfo == NULL)
+    {
+        return E_POINTER;
+    }
+
+    EnterCriticalSection(&m_critSec);
+
+    if (!IsValidInputStream(dwInputStreamID))
+    {
+        LeaveCriticalSection(&m_critSec);
+        return MF_E_INVALIDSTREAMNUMBER;
+    }
+
+    // NOTE: This method should succeed even when there is no media type on the
+    //       stream. If there is no media type, we only need to fill in the dwFlags
+    //       member of MFT_INPUT_STREAM_INFO. The other members depend on having a
+    //       a valid media type.
+
+    pStreamInfo->hnsMaxLatency = 0;
+    pStreamInfo->dwFlags = MFT_INPUT_STREAM_WHOLE_SAMPLES | MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER;
+
+    if (m_pInputType == NULL)
+    {
+        pStreamInfo->cbSize = 0;
+    }
+    else
+    {
+        pStreamInfo->cbSize = m_cbImageSize;
+    }
+
+    pStreamInfo->cbMaxLookahead = 0;
+    pStreamInfo->cbAlignment = 0;
+
+    LeaveCriticalSection(&m_critSec);
+    return S_OK;
+}
+
+//-------------------------------------------------------------------
+// GetOutputStreamInfo
+// Returns information about an output stream.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetOutputStreamInfo(
+    DWORD                     dwOutputStreamID,
+    MFT_OUTPUT_STREAM_INFO *  pStreamInfo
+)
+{
+    if (pStreamInfo == NULL)
+    {
+        return E_POINTER;
+    }
+
+    EnterCriticalSection(&m_critSec);
+
+    if (!IsValidOutputStream(dwOutputStreamID))
+    {
+        LeaveCriticalSection(&m_critSec);
+        return MF_E_INVALIDSTREAMNUMBER;
+    }
+
+    // NOTE: This method should succeed even when there is no media type on the
+    //       stream. If there is no media type, we only need to fill in the dwFlags
+    //       member of MFT_OUTPUT_STREAM_INFO. The other members depend on having a
+    //       a valid media type.
+
+    pStreamInfo->dwFlags =
+        MFT_OUTPUT_STREAM_WHOLE_SAMPLES |
+        MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER |
+        MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE ;
+
+    if (m_pOutputType == NULL)
+    {
+        pStreamInfo->cbSize = 0;
+    }
+    else
+    {
+        pStreamInfo->cbSize = m_cbImageSize;
+    }
+
+    pStreamInfo->cbAlignment = 0;
+
+    LeaveCriticalSection(&m_critSec);
+    return S_OK;
+}
+
+
+//-------------------------------------------------------------------
+// GetAttributes
+// Returns the attributes for the MFT.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetAttributes(IMFAttributes** ppAttributes)
+{
+    if (ppAttributes == NULL)
+    {
+        return E_POINTER;
+    }
+
+    EnterCriticalSection(&m_critSec);
+
+    *ppAttributes = m_pAttributes;
+    (*ppAttributes)->AddRef();
+
+    LeaveCriticalSection(&m_critSec);
+    return S_OK;
+}
+
+
+//-------------------------------------------------------------------
+// GetInputStreamAttributes
+// Returns stream-level attributes for an input stream.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetInputStreamAttributes(
+    DWORD           dwInputStreamID,
+    IMFAttributes   **ppAttributes
+)
+{
+    // This MFT does not support any stream-level attributes, so the method is not implemented.
+    return E_NOTIMPL;
+}
+
+
+//-------------------------------------------------------------------
+// GetOutputStreamAttributes
+// Returns stream-level attributes for an output stream.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetOutputStreamAttributes(
+    DWORD           dwOutputStreamID,
+    IMFAttributes   **ppAttributes
+)
+{
+    // This MFT does not support any stream-level attributes, so the method is not implemented.
+    return E_NOTIMPL;
+}
+
+
+//-------------------------------------------------------------------
+// DeleteInputStream
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::DeleteInputStream(DWORD dwStreamID)
+{
+    // This MFT has a fixed number of input streams, so the method is not supported.
+    return E_NOTIMPL;
+}
+
+
+//-------------------------------------------------------------------
+// AddInputStreams
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::AddInputStreams(
+    DWORD   cStreams,
+    DWORD   *adwStreamIDs
+)
+{
+    // This MFT has a fixed number of output streams, so the method is not supported.
+    return E_NOTIMPL;
+}
+
+
+//-------------------------------------------------------------------
+// GetInputAvailableType
+// Returns a preferred input type.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetInputAvailableType(
+    DWORD           dwInputStreamID,
+    DWORD           dwTypeIndex, // 0-based
+    IMFMediaType    **ppType
+)
+{
+    if (ppType == NULL)
+    {
+        return E_INVALIDARG;
+    }
+
+    EnterCriticalSection(&m_critSec);
+
+    if (!IsValidInputStream(dwInputStreamID))
+    {
+        LeaveCriticalSection(&m_critSec);
+        return MF_E_INVALIDSTREAMNUMBER;
+    }
+
+    HRESULT hr = S_OK;
+
+    // If the output type is set, return that type as our preferred input type.
+    if (m_pOutputType == NULL)
+    {
+        // The output type is not set. Create a partial media type.
+        hr = OnGetPartialType(dwTypeIndex, ppType);
+    }
+    else if (dwTypeIndex > 0)
+    {
+        hr = MF_E_NO_MORE_TYPES;
+    }
+    else
+    {
+        *ppType = m_pOutputType;
+        (*ppType)->AddRef();
+    }
+
+    LeaveCriticalSection(&m_critSec);
+    return hr;
+}
+
+
+
+//-------------------------------------------------------------------
+// GetOutputAvailableType
+// Returns a preferred output type.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetOutputAvailableType(
+    DWORD           dwOutputStreamID,
+    DWORD           dwTypeIndex, // 0-based
+    IMFMediaType    **ppType
+)
+{
+    if (ppType == NULL)
+    {
+        return E_INVALIDARG;
+    }
+
+    EnterCriticalSection(&m_critSec);
+
+    if (!IsValidOutputStream(dwOutputStreamID))
+    {
+        LeaveCriticalSection(&m_critSec);
+        return MF_E_INVALIDSTREAMNUMBER;
+    }
+
+    HRESULT hr = S_OK;
+
+    if (m_pInputType == NULL)
+    {
+        // The input type is not set. Create a partial media type.
+        hr = OnGetPartialType(dwTypeIndex, ppType);
+    }
+    else if (dwTypeIndex > 0)
+    {
+        hr = MF_E_NO_MORE_TYPES;
+    }
+    else
+    {
+        *ppType = m_pInputType;
+        (*ppType)->AddRef();
+    }
+
+    LeaveCriticalSection(&m_critSec);
+    return hr;
+}
+
+
+//-------------------------------------------------------------------
+// SetInputType
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::SetInputType(
+    DWORD           dwInputStreamID,
+    IMFMediaType    *pType, // Can be NULL to clear the input type.
+    DWORD           dwFlags
+)
+{
+    // Validate flags.
+    if (dwFlags & ~MFT_SET_TYPE_TEST_ONLY)
+    {
+        return E_INVALIDARG;
+    }
+
+    EnterCriticalSection(&m_critSec);
+
+    if (!IsValidInputStream(dwInputStreamID))
+    {
+        LeaveCriticalSection(&m_critSec);
+        return MF_E_INVALIDSTREAMNUMBER;
+    }
+
+    HRESULT hr = S_OK;
+
+    // Does the caller want us to set the type, or just test it?
+    BOOL bReallySet = ((dwFlags & MFT_SET_TYPE_TEST_ONLY) == 0);
+
+    // If we have an input sample, the client cannot change the type now.
+    if (HasPendingOutput())
+    {
+        hr = MF_E_TRANSFORM_CANNOT_CHANGE_MEDIATYPE_WHILE_PROCESSING;
+        goto done;
+    }
+
+    // Validate the type, if non-NULL.
+    if (pType)
+    {
+        hr = OnCheckInputType(pType);
+        if (FAILED(hr))
+        {
+            goto done;
+        }
+    }
+
+    // The type is OK. Set the type, unless the caller was just testing.
+    if (bReallySet)
+    {
+        OnSetInputType(pType);
+
+        // When the type changes, end streaming.
+        hr = EndStreaming();
+    }
+
+done:
+    LeaveCriticalSection(&m_critSec);
+    return hr;
+}
+
+
+
+//-------------------------------------------------------------------
+// SetOutputType
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::SetOutputType(
+    DWORD           dwOutputStreamID,
+    IMFMediaType    *pType, // Can be NULL to clear the output type.
+    DWORD           dwFlags
+)
+{
+    // Validate flags.
+    if (dwFlags & ~MFT_SET_TYPE_TEST_ONLY)
+    {
+        return E_INVALIDARG;
+    }
+
+    EnterCriticalSection(&m_critSec);
+
+    if (!IsValidOutputStream(dwOutputStreamID))
+    {
+        LeaveCriticalSection(&m_critSec);
+        return MF_E_INVALIDSTREAMNUMBER;
+    }
+
+    HRESULT hr = S_OK;
+
+    // Does the caller want us to set the type, or just test it?
+    BOOL bReallySet = ((dwFlags & MFT_SET_TYPE_TEST_ONLY) == 0);
+
+    // If we have an input sample, the client cannot change the type now.
+    if (HasPendingOutput())
+    {
+        hr = MF_E_TRANSFORM_CANNOT_CHANGE_MEDIATYPE_WHILE_PROCESSING;
+        goto done;
+    }
+
+    // Validate the type, if non-NULL.
+    if (pType)
+    {
+        hr = OnCheckOutputType(pType);
+        if (FAILED(hr))
+        {
+            goto done;
+        }
+    }
+
+    // The type is OK. Set the type, unless the caller was just testing.
+    if (bReallySet)
+    {
+        OnSetOutputType(pType);
+
+        // When the type changes, end streaming.
+        hr = EndStreaming();
+    }
+
+done:
+    LeaveCriticalSection(&m_critSec);
+    return hr;
+}
+
+
+//-------------------------------------------------------------------
+// GetInputCurrentType
+// Returns the current input type.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetInputCurrentType(
+    DWORD           dwInputStreamID,
+    IMFMediaType    **ppType
+)
+{
+    if (ppType == NULL)
+    {
+        return E_POINTER;
+    }
+
+    HRESULT hr = S_OK;
+
+    EnterCriticalSection(&m_critSec);
+
+    if (!IsValidInputStream(dwInputStreamID))
+    {
+        hr = MF_E_INVALIDSTREAMNUMBER;
+    }
+    else if (!m_pInputType)
+    {
+        hr = MF_E_TRANSFORM_TYPE_NOT_SET;
+    }
+    else
+    {
+        *ppType = m_pInputType;
+        (*ppType)->AddRef();
+    }
+    LeaveCriticalSection(&m_critSec);
+    return hr;
+}
+
+
+//-------------------------------------------------------------------
+// GetOutputCurrentType
+// Returns the current output type.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetOutputCurrentType(
+    DWORD           dwOutputStreamID,
+    IMFMediaType    **ppType
+)
+{
+    if (ppType == NULL)
+    {
+        return E_POINTER;
+    }
+
+    HRESULT hr = S_OK;
+
+    EnterCriticalSection(&m_critSec);
+
+    if (!IsValidOutputStream(dwOutputStreamID))
+    {
+        hr = MF_E_INVALIDSTREAMNUMBER;
+    }
+    else if (!m_pOutputType)
+    {
+        hr = MF_E_TRANSFORM_TYPE_NOT_SET;
+    }
+    else
+    {
+        *ppType = m_pOutputType;
+        (*ppType)->AddRef();
+    }
+
+    LeaveCriticalSection(&m_critSec);
+    return hr;
+}
+
+
+//-------------------------------------------------------------------
+// GetInputStatus
+// Query if the MFT is accepting more input.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetInputStatus(
+    DWORD           dwInputStreamID,
+    DWORD           *pdwFlags
+)
+{
+    if (pdwFlags == NULL)
+    {
+        return E_POINTER;
+    }
+
+    EnterCriticalSection(&m_critSec);
+
+    if (!IsValidInputStream(dwInputStreamID))
+    {
+        LeaveCriticalSection(&m_critSec);
+        return MF_E_INVALIDSTREAMNUMBER;
+    }
+
+    // If an input sample is already queued, do not accept another sample until the
+    // client calls ProcessOutput or Flush.
+
+    // NOTE: It is possible for an MFT to accept more than one input sample. For
+    // example, this might be required in a video decoder if the frames do not
+    // arrive in temporal order. In the case, the decoder must hold a queue of
+    // samples. For the video effect, each sample is transformed independently, so
+    // there is no reason to queue multiple input samples.
+
+    if (m_pSample == NULL)
+    {
+        *pdwFlags = MFT_INPUT_STATUS_ACCEPT_DATA;
+    }
+    else
+    {
+        *pdwFlags = 0;
+    }
+
+    LeaveCriticalSection(&m_critSec);
+    return S_OK;
+}
+
+
+
+//-------------------------------------------------------------------
+// GetOutputStatus
+// Query if the MFT can produce output.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::GetOutputStatus(DWORD *pdwFlags)
+{
+    if (pdwFlags == NULL)
+    {
+        return E_POINTER;
+    }
+
+    EnterCriticalSection(&m_critSec);
+
+    // The MFT can produce an output sample if (and only if) there an input sample.
+    if (m_pSample != NULL)
+    {
+        *pdwFlags = MFT_OUTPUT_STATUS_SAMPLE_READY;
+    }
+    else
+    {
+        *pdwFlags = 0;
+    }
+
+    LeaveCriticalSection(&m_critSec);
+    return S_OK;
+}
+
+
+//-------------------------------------------------------------------
+// SetOutputBounds
+// Sets the range of time stamps that the MFT will output.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::SetOutputBounds(
+    LONGLONG        hnsLowerBound,
+    LONGLONG        hnsUpperBound
+)
+{
+    // Implementation of this method is optional.
+    return E_NOTIMPL;
+}
+
+
+//-------------------------------------------------------------------
+// ProcessEvent
+// Sends an event to an input stream.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::ProcessEvent(
+    DWORD              dwInputStreamID,
+    IMFMediaEvent      *pEvent
+)
+{
+    // This MFT does not handle any stream events, so the method can
+    // return E_NOTIMPL. This tells the pipeline that it can stop
+    // sending any more events to this MFT.
+    return E_NOTIMPL;
+}
+
+
+//-------------------------------------------------------------------
+// ProcessMessage
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::ProcessMessage(
+    MFT_MESSAGE_TYPE    eMessage,
+    ULONG_PTR           ulParam
+)
+{
+    EnterCriticalSection(&m_critSec);
+
+    HRESULT hr = S_OK;
+
+    switch (eMessage)
+    {
+    case MFT_MESSAGE_COMMAND_FLUSH:
+        // Flush the MFT.
+        hr = OnFlush();
+        break;
+
+    case MFT_MESSAGE_COMMAND_DRAIN:
+        // Drain: Tells the MFT to reject further input until all pending samples are
+        // processed. That is our default behavior already, so there is nothing to do.
+        //
+        // For a decoder that accepts a queue of samples, the MFT might need to drain
+        // the queue in response to this command.
+    break;
+
+    case MFT_MESSAGE_SET_D3D_MANAGER:
+        // Sets a pointer to the IDirect3DDeviceManager9 interface.
+
+        // The pipeline should never send this message unless the MFT sets the MF_SA_D3D_AWARE
+        // attribute set to TRUE. Because this MFT does not set MF_SA_D3D_AWARE, it is an error
+        // to send the MFT_MESSAGE_SET_D3D_MANAGER message to the MFT. Return an error code in
+        // this case.
+
+        // NOTE: If this MFT were D3D-enabled, it would cache the IDirect3DDeviceManager9
+        // pointer for use during streaming.
+
+        hr = E_NOTIMPL;
+        break;
+
+    case MFT_MESSAGE_NOTIFY_BEGIN_STREAMING:
+        hr = BeginStreaming();
+        break;
+
+    case MFT_MESSAGE_NOTIFY_END_STREAMING:
+        hr = EndStreaming();
+        break;
+
+    // The next two messages do not require any action from this MFT.
+
+    case MFT_MESSAGE_NOTIFY_END_OF_STREAM:
+        break;
+
+    case MFT_MESSAGE_NOTIFY_START_OF_STREAM:
+        break;
+    }
+
+    LeaveCriticalSection(&m_critSec);
+    return hr;
+}
+
+
+//-------------------------------------------------------------------
+// ProcessInput
+// Process an input sample.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::ProcessInput(
+    DWORD               dwInputStreamID,
+    IMFSample           *pSample,
+    DWORD               dwFlags
+)
+{
+    // Check input parameters.
+    if (pSample == NULL)
+    {
+        return E_POINTER;
+    }
+
+    if (dwFlags != 0)
+    {
+        return E_INVALIDARG; // dwFlags is reserved and must be zero.
+    }
+
+    HRESULT hr = S_OK;
+
+    EnterCriticalSection(&m_critSec);
+
+    // Validate the input stream number.
+    if (!IsValidInputStream(dwInputStreamID))
+    {
+        hr = MF_E_INVALIDSTREAMNUMBER;
+        goto done;
+    }
+
+    // Check for valid media types.
+    // The client must set input and output types before calling ProcessInput.
+    if (!m_pInputType || !m_pOutputType)
+    {
+        hr = MF_E_NOTACCEPTING;
+        goto done;
+    }
+
+    // Check if an input sample is already queued.
+    if (m_pSample != NULL)
+    {
+        hr = MF_E_NOTACCEPTING;   // We already have an input sample.
+        goto done;
+    }
+
+    // Initialize streaming.
+    hr = BeginStreaming();
+    if (FAILED(hr))
+    {
+        goto done;
+    }
+
+    // Cache the sample. We do the actual work in ProcessOutput.
+    m_pSample = pSample;
+    pSample->AddRef();  // Hold a reference count on the sample.
+
+done:
+    LeaveCriticalSection(&m_critSec);
+    return hr;
+}
+
+
+//-------------------------------------------------------------------
+// ProcessOutput
+// Process an output sample.
+//-------------------------------------------------------------------
+
+HRESULT OcvImageManipulations::ProcessOutput(
+    DWORD                   dwFlags,
+    DWORD                   cOutputBufferCount,
+    MFT_OUTPUT_DATA_BUFFER  *pOutputSamples, // one per stream
+    DWORD                   *pdwStatus
+)
+{
+    // Check input parameters...
+
+    // This MFT does not accept any flags for the dwFlags parameter.
+
+    // The only defined flag is MFT_PROCESS_OUTPUT_DISCARD_WHEN_NO_BUFFER. This flag
+    // applies only when the MFT marks an output stream as lazy or optional. But this
+    // MFT has no lazy or optional streams, so the flag is not valid.
+
+    if (dwFlags != 0)
+    {
+        return E_INVALIDARG;
+    }
+
+    if (pOutputSamples == NULL || pdwStatus == NULL)
+    {
+        return E_POINTER;
+    }
+
+    // There must be exactly one output buffer.
+    if (cOutputBufferCount != 1)
+    {
+        return E_INVALIDARG;
+    }
+
+    // It must contain a sample.
+    if (pOutputSamples[0].pSample == NULL)
+    {
+        return E_INVALIDARG;
+    }
+
+    HRESULT hr = S_OK;
+
+    IMFMediaBuffer *pInput = NULL;
+    IMFMediaBuffer *pOutput = NULL;
+
+    EnterCriticalSection(&m_critSec);
+
+    // There must be an input sample available for processing.
+    if (m_pSample == NULL)
+    {
+        hr = MF_E_TRANSFORM_NEED_MORE_INPUT;
+        goto done;
+    }
+
+    // Initialize streaming.
+
+    hr = BeginStreaming();
+    if (FAILED(hr))
+    {
+        goto done;
+    }
+
+    // Get the input buffer.
+    hr = m_pSample->ConvertToContiguousBuffer(&pInput);
+    if (FAILED(hr))
+    {
+        goto done;
+    }
+
+    // Get the output buffer.
+    hr = pOutputSamples[0].pSample->ConvertToContiguousBuffer(&pOutput);
+    if (FAILED(hr))
+    {
+        goto done;
+    }
+
+    hr = OnProcessOutput(pInput, pOutput);
+    if (FAILED(hr))
+    {
+        goto done;
+    }
+
+    // Set status flags.
+    pOutputSamples[0].dwStatus = 0;
+    *pdwStatus = 0;
+
+
+    // Copy the duration and time stamp from the input sample, if present.
+
+    LONGLONG hnsDuration = 0;
+    LONGLONG hnsTime = 0;
+
+    if (SUCCEEDED(m_pSample->GetSampleDuration(&hnsDuration)))
+    {
+        hr = pOutputSamples[0].pSample->SetSampleDuration(hnsDuration);
+        if (FAILED(hr))
+        {
+            goto done;
+        }
+    }
+
+    if (SUCCEEDED(m_pSample->GetSampleTime(&hnsTime)))
+    {
+        hr = pOutputSamples[0].pSample->SetSampleTime(hnsTime);
+    }
+
+done:
+    SafeRelease(&m_pSample);   // Release our input sample.
+    SafeRelease(&pInput);
+    SafeRelease(&pOutput);
+    LeaveCriticalSection(&m_critSec);
+    return hr;
+}
+
+// PRIVATE METHODS
+
+// All methods that follow are private to this MFT and are not part of the IMFTransform interface.
+
+// Create a partial media type from our list.
+//
+// dwTypeIndex: Index into the list of peferred media types.
+// ppmt:        Receives a pointer to the media type.
+
+HRESULT OcvImageManipulations::OnGetPartialType(DWORD dwTypeIndex, IMFMediaType **ppmt)
+{
+    if (dwTypeIndex >= ARRAYSIZE(g_MediaSubtypes))
+    {
+        return MF_E_NO_MORE_TYPES;
+    }
+
+    IMFMediaType *pmt = NULL;
+
+    HRESULT hr = MFCreateMediaType(&pmt);
+    if (FAILED(hr))
+    {
+        goto done;
+    }
+
+    hr = pmt->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
+    if (FAILED(hr))
+    {
+        goto done;
+    }
+
+    hr = pmt->SetGUID(MF_MT_SUBTYPE, g_MediaSubtypes[dwTypeIndex]);
+    if (FAILED(hr))
+    {
+        goto done;
+    }
+
+    *ppmt = pmt;
+    (*ppmt)->AddRef();
+
+done:
+    SafeRelease(&pmt);
+    return hr;
+}
+
+
+// Validate an input media type.
+
+HRESULT OcvImageManipulations::OnCheckInputType(IMFMediaType *pmt)
+{
+    assert(pmt != NULL);
+
+    HRESULT hr = S_OK;
+
+    // If the output type is set, see if they match.
+    if (m_pOutputType != NULL)
+    {
+        DWORD flags = 0;
+        hr = pmt->IsEqual(m_pOutputType, &flags);
+
+        // IsEqual can return S_FALSE. Treat this as failure.
+        if (hr != S_OK)
+        {
+            hr = MF_E_INVALIDMEDIATYPE;
+        }
+    }
+    else
+    {
+        // Output type is not set. Just check this type.
+        hr = OnCheckMediaType(pmt);
+    }
+    return hr;
+}
+
+
+// Validate an output media type.
+
+HRESULT OcvImageManipulations::OnCheckOutputType(IMFMediaType *pmt)
+{
+    assert(pmt != NULL);
+
+    HRESULT hr = S_OK;
+
+    // If the input type is set, see if they match.
+    if (m_pInputType != NULL)
+    {
+        DWORD flags = 0;
+        hr = pmt->IsEqual(m_pInputType, &flags);
+
+        // IsEqual can return S_FALSE. Treat this as failure.
+        if (hr != S_OK)
+        {
+            hr = MF_E_INVALIDMEDIATYPE;
+        }
+
+    }
+    else
+    {
+        // Input type is not set. Just check this type.
+        hr = OnCheckMediaType(pmt);
+    }
+    return hr;
+}
+
+
+// Validate a media type (input or output)
+
+HRESULT OcvImageManipulations::OnCheckMediaType(IMFMediaType *pmt)
+{
+    BOOL bFoundMatchingSubtype = FALSE;
+
+    // Major type must be video.
+    GUID major_type;
+    HRESULT hr = pmt->GetGUID(MF_MT_MAJOR_TYPE, &major_type);
+    if (FAILED(hr))
+    {
+        goto done;
+    }
+
+    if (major_type != MFMediaType_Video)
+    {
+        hr = MF_E_INVALIDMEDIATYPE;
+        goto done;
+    }
+
+    // Subtype must be one of the subtypes in our global list.
+
+    // Get the subtype GUID.
+    GUID subtype;
+    hr = pmt->GetGUID(MF_MT_SUBTYPE, &subtype);
+    if (FAILED(hr))
+    {
+        goto done;
+    }
+
+    // Look for the subtype in our list of accepted types.
+    for (DWORD i = 0; i < ARRAYSIZE(g_MediaSubtypes); i++)
+    {
+        if (subtype == g_MediaSubtypes[i])
+        {
+            bFoundMatchingSubtype = TRUE;
+            break;
+        }
+    }
+
+    if (!bFoundMatchingSubtype)
+    {
+        hr = MF_E_INVALIDMEDIATYPE; // The MFT does not support this subtype.
+        goto done;
+    }
+
+    // Reject single-field media types.
+    UINT32 interlace = MFGetAttributeUINT32(pmt, MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive);
+    if (interlace == MFVideoInterlace_FieldSingleUpper  || interlace == MFVideoInterlace_FieldSingleLower)
+    {
+        hr = MF_E_INVALIDMEDIATYPE;
+    }
+
+done:
+    return hr;
+}
+
+
+// Set or clear the input media type.
+//
+// Prerequisite: The input type was already validated.
+
+void OcvImageManipulations::OnSetInputType(IMFMediaType *pmt)
+{
+    // if pmt is NULL, clear the type.
+    // if pmt is non-NULL, set the type.
+
+    SafeRelease(&m_pInputType);
+    m_pInputType = pmt;
+    if (m_pInputType)
+    {
+        m_pInputType->AddRef();
+    }
+
+    // Update the format information.
+    UpdateFormatInfo();
+}
+
+
+// Set or clears the output media type.
+//
+// Prerequisite: The output type was already validated.
+
+void OcvImageManipulations::OnSetOutputType(IMFMediaType *pmt)
+{
+    // If pmt is NULL, clear the type. Otherwise, set the type.
+
+    SafeRelease(&m_pOutputType);
+    m_pOutputType = pmt;
+    if (m_pOutputType)
+    {
+        m_pOutputType->AddRef();
+    }
+}
+
+
+// Initialize streaming parameters.
+//
+// This method is called if the client sends the MFT_MESSAGE_NOTIFY_BEGIN_STREAMING
+// message, or when the client processes a sample, whichever happens first.
+
+HRESULT OcvImageManipulations::BeginStreaming()
+{
+    HRESULT hr = S_OK;
+
+    if (!m_bStreamingInitialized)
+    {
+        m_bStreamingInitialized = true;
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+
+// End streaming.
+
+// This method is called if the client sends an MFT_MESSAGE_NOTIFY_END_STREAMING
+// message, or when the media type changes. In general, it should be called whenever
+// the streaming parameters need to be reset.
+
+HRESULT OcvImageManipulations::EndStreaming()
+{
+    m_bStreamingInitialized = false;
+    return S_OK;
+}
+
+
+
+// Generate output data.
+
+HRESULT OcvImageManipulations::OnProcessOutput(IMFMediaBuffer *pIn, IMFMediaBuffer *pOut)
+{
+    BYTE *pDest = NULL;         // Destination buffer.
+    LONG lDestStride = 0;       // Destination stride.
+
+    BYTE *pSrc = NULL;          // Source buffer.
+    LONG lSrcStride = 0;        // Source stride.
+
+    // Helper objects to lock the buffers.
+    VideoBufferLock inputLock(pIn);
+    VideoBufferLock outputLock(pOut);
+
+    // Stride if the buffer does not support IMF2DBuffer
+    LONG lDefaultStride = 0;
+
+    HRESULT hr = GetDefaultStride(m_pInputType, &lDefaultStride);
+    if (FAILED(hr))
+    {
+        return hr;
+    }
+
+    // Lock the input buffer.
+    hr = inputLock.LockBuffer(lDefaultStride, m_imageHeightInPixels, &pSrc, &lSrcStride);
+    if (FAILED(hr))
+    {
+        return hr;
+    }
+
+    // Lock the output buffer.
+    hr = outputLock.LockBuffer(lDefaultStride, m_imageHeightInPixels, &pDest, &lDestStride);
+    if (FAILED(hr))
+    {
+        return hr;
+    }
+
+    cv::Mat InputFrame(m_imageHeightInPixels + m_imageHeightInPixels/2, m_imageWidthInPixels, CV_8UC1, pSrc, lSrcStride);
+    cv::Mat InputGreyScale(InputFrame, cv::Range(0, m_imageHeightInPixels), cv::Range(0, m_imageWidthInPixels));
+    cv::Mat OutputFrame(m_imageHeightInPixels + m_imageHeightInPixels/2, m_imageWidthInPixels, CV_8UC1, pDest, lDestStride);
+
+    switch (m_TransformType)
+    {
+    case Preview:
+        {
+            InputFrame.copyTo(OutputFrame);
+        } break;
+    case GrayScale:
+        {
+            OutputFrame.setTo(cv::Scalar(128));
+            cv::Mat OutputGreyScale(OutputFrame, cv::Range(0, m_imageHeightInPixels), cv::Range(0, m_imageWidthInPixels));
+            InputGreyScale.copyTo(OutputGreyScale);
+        } break;
+    case Canny:
+        {
+            OutputFrame.setTo(cv::Scalar(128));
+            cv::Mat OutputGreyScale(OutputFrame, cv::Range(0, m_imageHeightInPixels), cv::Range(0, m_imageWidthInPixels));
+            cv::Canny(InputGreyScale, OutputGreyScale, 80, 90);
+
+        } break;
+    case Sobel:
+        {
+            OutputFrame.setTo(cv::Scalar(128));
+            cv::Mat OutputGreyScale(OutputFrame, cv::Range(0, m_imageHeightInPixels), cv::Range(0, m_imageWidthInPixels));
+            cv::Sobel(InputGreyScale, OutputGreyScale, CV_8U, 1, 1);
+        } break;
+    case Histogram:
+        {
+            const int mHistSizeNum = 25;
+            const int channels[3][1] = {{0}, {1}, {2}};
+            const int mHistSize[] = {25};
+            const float baseRabge[] = {0.f,256.f};
+            const float* ranges[] = {baseRabge};
+
+            const cv::Scalar mColorsY[] = { cv::Scalar(76), cv::Scalar(149), cv::Scalar(29) };
+            const cv::Scalar mColorsUV[] = { cv::Scalar(84, 255), cv::Scalar(43, 21), cv::Scalar(255, 107) };
+
+            cv::Mat OutputY(m_imageHeightInPixels, m_imageWidthInPixels, CV_8UC1, pDest, lDestStride);
+            cv::Mat OutputUV(m_imageHeightInPixels/2, m_imageWidthInPixels/2,
+                             CV_8UC2, pDest+m_imageHeightInPixels*lDestStride, lDestStride);
+            cv::Mat BgrFrame;
+
+            InputFrame.copyTo(OutputFrame);
+
+            cv::cvtColor(InputFrame, BgrFrame, cv::COLOR_YUV420sp2BGR);
+            int thikness = (int) (BgrFrame.cols / (mHistSizeNum + 10) / 5);
+            if(thikness > 5) thikness = 5;
+            int offset = (int) ((BgrFrame.cols - (5*mHistSizeNum + 4*10)*thikness)/2);
+
+            // RGB
+            for (int c=0; c<3; c++)
+            {
+                cv::Mat hist;
+                cv::calcHist(&BgrFrame, 1, channels[c], cv::Mat(), hist, 1, mHistSize, ranges);
+                cv::normalize(hist, hist, BgrFrame.rows/2, 0, cv::NORM_INF);
+                for(int h=0; h<mHistSizeNum; h++) {
+                    cv::Point mP1, mP2;
+                    // Draw on Y plane
+                    mP1.x = mP2.x = offset + (c * (mHistSizeNum + 10) + h) * thikness;
+                    mP1.y = BgrFrame.rows-1;
+                    mP2.y = mP1.y - 2 - (int)hist.at<float>(h);
+                    cv::line(OutputY, mP1, mP2, mColorsY[c], thikness);
+
+                    // Draw on UV planes
+                    mP1.x /= 2;
+                    mP1.y /= 2;
+                    mP2.x /= 2;
+                    mP2.y /= 2;
+                    cv::line(OutputUV, mP1, mP2, mColorsUV[c], thikness/2);
+                }
+            }
+        } break;
+    default:
+        break;
+    }
+
+    // Set the data size on the output buffer.
+    hr = pOut->SetCurrentLength(m_cbImageSize);
+
+    return hr;
+}
+
+
+// Flush the MFT.
+
+HRESULT OcvImageManipulations::OnFlush()
+{
+    // For this MFT, flushing just means releasing the input sample.
+    SafeRelease(&m_pSample);
+    return S_OK;
+}
+
+
+// Update the format information. This method is called whenever the
+// input type is set.
+
+HRESULT OcvImageManipulations::UpdateFormatInfo()
+{
+    HRESULT hr = S_OK;
+
+    GUID subtype = GUID_NULL;
+
+    m_imageWidthInPixels = 0;
+    m_imageHeightInPixels = 0;
+    m_cbImageSize = 0;
+
+    if (m_pInputType != NULL)
+    {
+        hr = m_pInputType->GetGUID(MF_MT_SUBTYPE, &subtype);
+        if (FAILED(hr))
+        {
+            goto done;
+        }
+        if (subtype != MFVideoFormat_NV12)
+        {
+            hr = E_UNEXPECTED;
+            goto done;
+        }
+
+        hr = MFGetAttributeSize(m_pInputType, MF_MT_FRAME_SIZE, &m_imageWidthInPixels, &m_imageHeightInPixels);
+        if (FAILED(hr))
+        {
+            goto done;
+        }
+
+        // Calculate the image size for YUV NV12 image(not including padding)
+        m_cbImageSize = (m_imageHeightInPixels + m_imageHeightInPixels/2)*m_imageWidthInPixels;
+    }
+
+done:
+    return hr;
+}
+
+
+// Get the default stride for a video format.
+HRESULT GetDefaultStride(IMFMediaType *pType, LONG *plStride)
+{
+    LONG lStride = 0;
+
+    // Try to get the default stride from the media type.
+    HRESULT hr = pType->GetUINT32(MF_MT_DEFAULT_STRIDE, (UINT32*)&lStride);
+    if (FAILED(hr))
+    {
+        // Attribute not set. Try to calculate the default stride.
+        GUID subtype = GUID_NULL;
+
+        UINT32 width = 0;
+        UINT32 height = 0;
+
+        // Get the subtype and the image size.
+        hr = pType->GetGUID(MF_MT_SUBTYPE, &subtype);
+        if (SUCCEEDED(hr))
+        {
+            hr = MFGetAttributeSize(pType, MF_MT_FRAME_SIZE, &width, &height);
+        }
+        if (SUCCEEDED(hr))
+        {
+            if (subtype == MFVideoFormat_NV12)
+            {
+                lStride = width;
+            }
+            else if (subtype == MFVideoFormat_YUY2 || subtype == MFVideoFormat_UYVY)
+            {
+                lStride = ((width * 2) + 3) & ~3;
+            }
+            else
+            {
+                hr = E_INVALIDARG;
+            }
+        }
+
+        // Set the attribute for later reference.
+        if (SUCCEEDED(hr))
+        {
+            (void)pType->SetUINT32(MF_MT_DEFAULT_STRIDE, UINT32(lStride));
+        }
+    }
+    if (SUCCEEDED(hr))
+    {
+        *plStride = lStride;
+    }
+    return hr;
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.def b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.def
new file mode 100644
index 00000000..453349ad
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.def
@@ -0,0 +1,4 @@
+EXPORTS
+    DllCanUnloadNow                     PRIVATE
+    DllGetActivationFactory             PRIVATE
+    DllGetClassObject                   PRIVATE
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.h
new file mode 100644
index 00000000..9162593f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.h
@@ -0,0 +1,247 @@
+// Defines the transform class.
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+#ifndef GRAYSCALE_H
+#define GRAYSCALE_H
+
+#include <new>
+#include <mfapi.h>
+#include <mftransform.h>
+#include <mfidl.h>
+#include <mferror.h>
+#include <strsafe.h>
+#include <assert.h>
+
+#include <wrl\implements.h>
+#include <wrl\module.h>
+#include <windows.media.h>
+
+#include "OcvImageManipulations.h"
+
+// CLSID of the MFT.
+DEFINE_GUID(CLSID_GrayscaleMFT,
+0x2f3dbc05, 0xc011, 0x4a8f, 0xb2, 0x64, 0xe4, 0x2e, 0x35, 0xc6, 0x7b, 0xf4);
+
+//
+// * IMPORTANT: If you implement your own MFT, create a new GUID for the CLSID. *
+//
+
+
+// Configuration attributes
+// {698649BE-8EAE-4551-A4CB-3EC98FBD3D86}
+DEFINE_GUID(OCV_IMAGE_EFFECT,
+0x698649be, 0x8eae, 0x4551, 0xa4, 0xcb, 0x3e, 0xc9, 0x8f, 0xbd, 0x3d, 0x86);
+
+
+enum ProcessingType
+{
+    Preview,
+    GrayScale,
+    Canny,
+    Sobel,
+    Histogram,
+    InvalidEffect
+};
+
+template <class T> void SafeRelease(T **ppT)
+{
+    if (*ppT)
+    {
+        (*ppT)->Release();
+        *ppT = NULL;
+    }
+}
+
+// OcvImageManipulations class:
+// Implements a grayscale video effect.
+
+class OcvImageManipulations
+    : public Microsoft::WRL::RuntimeClass<
+           Microsoft::WRL::RuntimeClassFlags< Microsoft::WRL::RuntimeClassType::WinRtClassicComMix >,
+           ABI::Windows::Media::IMediaExtension,
+           IMFTransform >
+{
+    InspectableClass(RuntimeClass_OcvTransform_OcvImageManipulations, BaseTrust)
+
+public:
+    OcvImageManipulations();
+
+    ~OcvImageManipulations();
+
+    STDMETHOD(RuntimeClassInitialize)();
+
+    // IMediaExtension
+    STDMETHODIMP SetProperties(ABI::Windows::Foundation::Collections::IPropertySet *pConfiguration);
+
+    // IMFTransform
+    STDMETHODIMP GetStreamLimits(
+        DWORD   *pdwInputMinimum,
+        DWORD   *pdwInputMaximum,
+        DWORD   *pdwOutputMinimum,
+        DWORD   *pdwOutputMaximum
+    );
+
+    STDMETHODIMP GetStreamCount(
+        DWORD   *pcInputStreams,
+        DWORD   *pcOutputStreams
+    );
+
+    STDMETHODIMP GetStreamIDs(
+        DWORD   dwInputIDArraySize,
+        DWORD   *pdwInputIDs,
+        DWORD   dwOutputIDArraySize,
+        DWORD   *pdwOutputIDs
+    );
+
+    STDMETHODIMP GetInputStreamInfo(
+        DWORD                     dwInputStreamID,
+        MFT_INPUT_STREAM_INFO *   pStreamInfo
+    );
+
+    STDMETHODIMP GetOutputStreamInfo(
+        DWORD                     dwOutputStreamID,
+        MFT_OUTPUT_STREAM_INFO *  pStreamInfo
+    );
+
+    STDMETHODIMP GetAttributes(IMFAttributes** pAttributes);
+
+    STDMETHODIMP GetInputStreamAttributes(
+        DWORD           dwInputStreamID,
+        IMFAttributes   **ppAttributes
+    );
+
+    STDMETHODIMP GetOutputStreamAttributes(
+        DWORD           dwOutputStreamID,
+        IMFAttributes   **ppAttributes
+    );
+
+    STDMETHODIMP DeleteInputStream(DWORD dwStreamID);
+
+    STDMETHODIMP AddInputStreams(
+        DWORD   cStreams,
+        DWORD   *adwStreamIDs
+    );
+
+    STDMETHODIMP GetInputAvailableType(
+        DWORD           dwInputStreamID,
+        DWORD           dwTypeIndex, // 0-based
+        IMFMediaType    **ppType
+    );
+
+    STDMETHODIMP GetOutputAvailableType(
+        DWORD           dwOutputStreamID,
+        DWORD           dwTypeIndex, // 0-based
+        IMFMediaType    **ppType
+    );
+
+    STDMETHODIMP SetInputType(
+        DWORD           dwInputStreamID,
+        IMFMediaType    *pType,
+        DWORD           dwFlags
+    );
+
+    STDMETHODIMP SetOutputType(
+        DWORD           dwOutputStreamID,
+        IMFMediaType    *pType,
+        DWORD           dwFlags
+    );
+
+    STDMETHODIMP GetInputCurrentType(
+        DWORD           dwInputStreamID,
+        IMFMediaType    **ppType
+    );
+
+    STDMETHODIMP GetOutputCurrentType(
+        DWORD           dwOutputStreamID,
+        IMFMediaType    **ppType
+    );
+
+    STDMETHODIMP GetInputStatus(
+        DWORD           dwInputStreamID,
+        DWORD           *pdwFlags
+    );
+
+    STDMETHODIMP GetOutputStatus(DWORD *pdwFlags);
+
+    STDMETHODIMP SetOutputBounds(
+        LONGLONG        hnsLowerBound,
+        LONGLONG        hnsUpperBound
+    );
+
+    STDMETHODIMP ProcessEvent(
+        DWORD              dwInputStreamID,
+        IMFMediaEvent      *pEvent
+    );
+
+    STDMETHODIMP ProcessMessage(
+        MFT_MESSAGE_TYPE    eMessage,
+        ULONG_PTR           ulParam
+    );
+
+    STDMETHODIMP ProcessInput(
+        DWORD               dwInputStreamID,
+        IMFSample           *pSample,
+        DWORD               dwFlags
+    );
+
+    STDMETHODIMP ProcessOutput(
+        DWORD                   dwFlags,
+        DWORD                   cOutputBufferCount,
+        MFT_OUTPUT_DATA_BUFFER  *pOutputSamples, // one per stream
+        DWORD                   *pdwStatus
+    );
+
+
+private:
+    // HasPendingOutput: Returns TRUE if the MFT is holding an input sample.
+    BOOL HasPendingOutput() const { return m_pSample != NULL; }
+
+    // IsValidInputStream: Returns TRUE if dwInputStreamID is a valid input stream identifier.
+    BOOL IsValidInputStream(DWORD dwInputStreamID) const
+    {
+        return dwInputStreamID == 0;
+    }
+
+    // IsValidOutputStream: Returns TRUE if dwOutputStreamID is a valid output stream identifier.
+    BOOL IsValidOutputStream(DWORD dwOutputStreamID) const
+    {
+        return dwOutputStreamID == 0;
+    }
+
+    HRESULT OnGetPartialType(DWORD dwTypeIndex, IMFMediaType **ppmt);
+    HRESULT OnCheckInputType(IMFMediaType *pmt);
+    HRESULT OnCheckOutputType(IMFMediaType *pmt);
+    HRESULT OnCheckMediaType(IMFMediaType *pmt);
+    void    OnSetInputType(IMFMediaType *pmt);
+    void    OnSetOutputType(IMFMediaType *pmt);
+    HRESULT BeginStreaming();
+    HRESULT EndStreaming();
+    HRESULT OnProcessOutput(IMFMediaBuffer *pIn, IMFMediaBuffer *pOut);
+    HRESULT OnFlush();
+    HRESULT UpdateFormatInfo();
+
+    CRITICAL_SECTION            m_critSec;
+
+    // Transformation parameters
+    ProcessingType              m_TransformType;
+
+    // Streaming
+    bool                        m_bStreamingInitialized;
+    IMFSample                   *m_pSample;                 // Input sample.
+    IMFMediaType                *m_pInputType;              // Input media type.
+    IMFMediaType                *m_pOutputType;             // Output media type.
+
+    // Fomat information
+    UINT32                      m_imageWidthInPixels;
+    UINT32                      m_imageHeightInPixels;
+    DWORD                       m_cbImageSize;              // Image size, in bytes.
+
+    IMFAttributes               *m_pAttributes;
+};
+#endif
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.vcxproj b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.vcxproj
new file mode 100644
index 00000000..f335daf5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/OcvTransform.vcxproj
@@ -0,0 +1,327 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>OcvTransform</RootNamespace>
+    <ProjectName>OcvTransform</ProjectName>
+    <MinimumVisualStudioVersion>12.0</MinimumVisualStudioVersion>
+    <AppContainerApplication>true</AppContainerApplication>
+    <ApplicationType>Windows Store</ApplicationType>
+    <ApplicationTypeRevision>8.1</ApplicationTypeRevision>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <DefaultLanguage>en-US</DefaultLanguage>
+  </PropertyGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />	
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />	
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />	
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />	
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />	
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />	
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <GenerateManifest>false</GenerateManifest>
+    <OutDir>$(Configuration)\$(MSBuildProjectName)\</OutDir>
+    <LibraryPath>$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <GenerateManifest>false</GenerateManifest>
+    <OutDir>$(Configuration)\$(MSBuildProjectName)\</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PreprocessorDefinitions>_WINRT_DLL;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>
+      </PrecompiledHeaderOutputFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>false</CompileAsWinRT>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <ModuleDefinitionFile>OcvTransform.def</ModuleDefinitionFile>
+    </Link>
+    <CustomBuildStep>
+      <Command>mdmerge -metadata_dir "$(WindowsSDK_MetadataPath)" -o "$(ProjectDir)$(Configuration)\$(MSBuildProjectName)" -i "$(MSBuildProjectDirectory)" -v -partial</Command>
+      <Outputs>$(ProjectDir)$(Configuration)\$(MSBuildProjectName)\$(ProjectName).winmd</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PreprocessorDefinitions>_WINRT_DLL;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>
+      </PrecompiledHeaderOutputFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>false</CompileAsWinRT>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>      
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <ModuleDefinitionFile>OcvTransform.def</ModuleDefinitionFile>
+    </Link>
+    <CustomBuildStep>
+      <Command>mdmerge -metadata_dir "$(WindowsSDK_MetadataPath)" -o "$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)" -i "$(MSBuildProjectDirectory)" -v -partial</Command>
+      <Outputs>$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)\$(ProjectName).winmd</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PreprocessorDefinitions>_WINRT_DLL;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>
+      </PrecompiledHeaderOutputFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>false</CompileAsWinRT>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>      
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <ModuleDefinitionFile>OcvTransform.def</ModuleDefinitionFile>
+    </Link>
+    <CustomBuildStep>
+      <Command>mdmerge -metadata_dir "$(WindowsSDK_MetadataPath)" -o "$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)" -i "$(MSBuildProjectDirectory)" -v -partial</Command>
+      <Outputs>$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)\$(ProjectName).winmd</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PreprocessorDefinitions>_WINRT_DLL;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>
+      </PrecompiledHeaderOutputFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>false</CompileAsWinRT>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <ModuleDefinitionFile>OcvTransform.def</ModuleDefinitionFile>
+    </Link>
+    <CustomBuildStep>
+      <Command>mdmerge -metadata_dir "$(WindowsSDK_MetadataPath)" -o "$(ProjectDir)$(Configuration)\$(MSBuildProjectName)" -i "$(MSBuildProjectDirectory)" -v -partial</Command>
+      <Outputs>$(ProjectDir)$(Configuration)\$(MSBuildProjectName)\$(ProjectName).winmd</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PreprocessorDefinitions>_WINRT_DLL;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>
+      </PrecompiledHeaderOutputFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>false</CompileAsWinRT>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <ModuleDefinitionFile>OcvTransform.def</ModuleDefinitionFile>
+    </Link>
+    <CustomBuildStep>
+      <Command>mdmerge -metadata_dir "$(WindowsSDK_MetadataPath)" -o "$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)" -i "$(MSBuildProjectDirectory)" -v -partial</Command>
+      <Outputs>$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)\$(ProjectName).winmd</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PreprocessorDefinitions>_WINRT_DLL;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>
+      </PrecompiledHeaderOutputFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>false</CompileAsWinRT>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <ModuleDefinitionFile>OcvTransform.def</ModuleDefinitionFile>
+    </Link>
+    <CustomBuildStep>
+      <Command>mdmerge -metadata_dir "$(WindowsSDK_MetadataPath)" -o "$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)" -i "$(MSBuildProjectDirectory)" -v -partial</Command>
+      <Outputs>$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)\$(ProjectName).winmd</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="OcvTransform.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="OcvTransform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="OcvTransform.def" />
+  </ItemGroup>
+  <ItemGroup>
+    <Midl Include="OcvImageManipulations.idl">
+      <MetadataFileName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+      </MetadataFileName>
+      <MetadataFileName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+      </MetadataFileName>
+      <MetadataFileName Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+      </MetadataFileName>
+      <MetadataFileName Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+      </MetadataFileName>
+      <MetadataFileName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+      </MetadataFileName>
+      <MetadataFileName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+      </MetadataFileName>
+      <AdditionalMetadataDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(WindowsSDK_MetadataPath)</AdditionalMetadataDirectories>
+      <AdditionalMetadataDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(WindowsSDK_MetadataPath)</AdditionalMetadataDirectories>
+      <AdditionalMetadataDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">$(WindowsSDK_MetadataPath)</AdditionalMetadataDirectories>
+      <AdditionalMetadataDirectories Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">$(WindowsSDK_MetadataPath)</AdditionalMetadataDirectories>
+      <AdditionalMetadataDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(WindowsSDK_MetadataPath)</AdditionalMetadataDirectories>
+      <AdditionalMetadataDirectories Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(WindowsSDK_MetadataPath)</AdditionalMetadataDirectories>
+      <EnableWindowsRuntime Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</EnableWindowsRuntime>
+      <EnableWindowsRuntime Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</EnableWindowsRuntime>
+      <EnableWindowsRuntime Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">true</EnableWindowsRuntime>
+      <EnableWindowsRuntime Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">true</EnableWindowsRuntime>
+      <EnableWindowsRuntime Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</EnableWindowsRuntime>
+      <EnableWindowsRuntime Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</EnableWindowsRuntime>
+      <HeaderFileName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(Filename).h</HeaderFileName>
+      <HeaderFileName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(Filename).h</HeaderFileName>
+      <HeaderFileName Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">%(Filename).h</HeaderFileName>
+      <HeaderFileName Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">%(Filename).h</HeaderFileName>
+      <HeaderFileName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(Filename).h</HeaderFileName>
+      <HeaderFileName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(Filename).h</HeaderFileName>
+    </Midl>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ItemGroup>
+    <_MdMergeOutput Condition="'$(Platform)' == 'Win32'" Include="$(ProjectDir)$(Configuration)\$(MSBuildProjectName)\$(ProjectName).winmd" />
+    <_MdMergeOutput Condition="'$(Platform)' != 'Win32'" Include="$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)\$(ProjectName).winmd" />
+  </ItemGroup>
+  <Target Name="CopyWinmdArtifactsOutputGroup" Returns="@(CopyWinmdArtifactsOutputGroupOutputs)">
+    <ItemGroup>
+      <CopyWinmdArtifactsOutputGroupOutputs Include="@(_MdMergeOutput)">
+        <TargetPath>$(ProjectName).winmd</TargetPath>
+        <Implementation>$(TargetName)$(TargetExt)</Implementation>
+      </CopyWinmdArtifactsOutputGroupOutputs>
+    </ItemGroup>
+  </Target>
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/dllmain.cpp b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/dllmain.cpp
new file mode 100644
index 00000000..701e7d41
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/dllmain.cpp
@@ -0,0 +1,58 @@
+//////////////////////////////////////////////////////////////////////////
+//
+// dllmain.cpp
+//
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+//////////////////////////////////////////////////////////////////////////
+
+#include <initguid.h>
+#include "OcvTransform.h"
+
+using namespace Microsoft::WRL;
+
+namespace Microsoft { namespace Samples {
+    ActivatableClass(OcvImageManipulations);
+}}
+
+BOOL WINAPI DllMain( _In_ HINSTANCE hInstance, _In_ DWORD dwReason, _In_opt_ LPVOID lpReserved )
+{
+    if( DLL_PROCESS_ATTACH == dwReason )
+    {
+        //
+        //  Don't need per-thread callbacks
+        //
+        DisableThreadLibraryCalls( hInstance );
+
+        Module<InProc>::GetModule().Create();
+    }
+    else if( DLL_PROCESS_DETACH == dwReason )
+    {
+        Module<InProc>::GetModule().Terminate();
+    }
+
+    return TRUE;
+}
+
+HRESULT WINAPI DllGetActivationFactory( _In_ HSTRING activatibleClassId, _Outptr_ IActivationFactory** factory )
+{
+    auto &module = Microsoft::WRL::Module< Microsoft::WRL::InProc >::GetModule();
+    return module.GetActivationFactory( activatibleClassId, factory );
+}
+
+HRESULT WINAPI DllCanUnloadNow()
+{
+    auto &module = Microsoft::WRL::Module<Microsoft::WRL::InProc>::GetModule();
+    return (module.Terminate()) ? S_OK : S_FALSE;
+}
+
+STDAPI DllGetClassObject( _In_ REFCLSID rclsid, _In_ REFIID riid, _Outptr_ LPVOID FAR* ppv )
+{
+    auto &module = Microsoft::WRL::Module<Microsoft::WRL::InProc>::GetModule();
+    return module.GetClassObject( rclsid, riid, ppv );
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/opencv.props b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/opencv.props
new file mode 100644
index 00000000..0ddc0996
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/MediaExtensions/OcvTransform/opencv.props
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros">
+    <OpenCV_Bin>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\bin\</OpenCV_Bin>
+    <OpenCV_Lib>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\lib\</OpenCV_Lib>
+    <OpenCV_Include>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\include\</OpenCV_Include>
+    <!--debug suffix for OpenCV dlls and libs -->
+    <DebugSuffix Condition="'$(Configuration)'=='Debug'">d</DebugSuffix>
+    <DebugSuffix Condition="'$(Configuration)'!='Debug'"></DebugSuffix>
+  </PropertyGroup>
+  <ItemGroup>
+    <!--Add required OpenCV dlls here-->
+    <None Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+  </ItemGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(OpenCV_Include);$(ProjectDir)\..\Common;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <!--Add required OpenCV libs here-->
+      <AdditionalDependencies>opencv_core300$(DebugSuffix).lib;opencv_imgproc300$(DebugSuffix).lib;runtimeobject.lib;mf.lib;mfuuid.lib;mfplat.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OpenCV_Lib);%(AdditionalLibraryDirectories);</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/Package.appxmanifest b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/Package.appxmanifest
new file mode 100644
index 00000000..96b6455c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/Package.appxmanifest
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest" xmlns:m2="http://schemas.microsoft.com/appx/2013/manifest">
+  <Identity Name="Microsoft.SDKSamples.MediaCapture.CPP" Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US" Version="1.1.0.6" />
+  <Properties>
+    <DisplayName>MediaCapture CPP sample</DisplayName>
+    <PublisherDisplayName>Microsoft Corporation</PublisherDisplayName>
+    <Logo>Assets\windows-sdk.png</Logo>
+  </Properties>
+  <Prerequisites>
+    <OSMinVersion>6.3</OSMinVersion>
+    <OSMaxVersionTested>6.3</OSMaxVersionTested>
+  </Prerequisites>
+  <Resources>
+    <Resource Language="x-generate" />
+  </Resources>
+  <Applications>
+    <Application Id="MediaCapture.App" Executable="$targetnametoken$.exe" EntryPoint="MediaCapture.App">
+      <m2:VisualElements DisplayName="OCV Image Manipulations" Description="OpenCV Image Manipulations sample" BackgroundColor="#00b2f0" ForegroundText="light" Square150x150Logo="Assets\opencv-logo-150.png" Square30x30Logo="Assets\opencv-logo-30.png">
+        <m2:DefaultTile ShortName="Ocv ImageManipulations">
+          <m2:ShowNameOnTiles>
+            <m2:ShowOn Tile="square150x150Logo" />
+          </m2:ShowNameOnTiles>
+        </m2:DefaultTile>
+        <m2:SplashScreen BackgroundColor="#00b2f0" Image="Assets\splash-sdk.png" />
+      </m2:VisualElements>
+    </Application>
+  </Applications>
+  <Capabilities>
+    <DeviceCapability Name="webcam" />
+    <DeviceCapability Name="microphone" />
+  </Capabilities>
+  <Extensions>
+    <Extension Category="windows.activatableClass.inProcessServer">
+      <InProcessServer>
+        <Path>OcvTransform.dll</Path>
+        <ActivatableClass ActivatableClassId="OcvTransform.OcvImageManipulations" ThreadingModel="both" />
+      </InProcessServer>
+    </Extension>
+  </Extensions>
+</Package>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/StoreLogo.png b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/StoreLogo.png
new file mode 100644
index 00000000..0fb23ff2
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/StoreLogo.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/opencv-logo-150.png b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/opencv-logo-150.png
new file mode 100644
index 00000000..8f447ad3
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/opencv-logo-150.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/opencv-logo-30.png b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/opencv-logo-30.png
new file mode 100644
index 00000000..449be585
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/opencv-logo-30.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/splash-sdk.png b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/splash-sdk.png
new file mode 100644
index 00000000..901c3b08
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/splash-sdk.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/windows-sdk.png b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/windows-sdk.png
new file mode 100644
index 00000000..7f753f7b
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/windows-sdk.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/windows-sdk.scale-100.png b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/windows-sdk.scale-100.png
new file mode 100644
index 00000000..0fb23ff2
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/assets/windows-sdk.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/LayoutAwarePage.cpp b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/LayoutAwarePage.cpp
new file mode 100644
index 00000000..f3f4be23
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/LayoutAwarePage.cpp
@@ -0,0 +1,452 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+#include "pch.h"
+#include "LayoutAwarePage.h"
+#include "SuspensionManager.h"
+
+using namespace SDKSample::Common;
+
+using namespace Platform;
+using namespace Platform::Collections;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::System;
+using namespace Windows::UI::Core;
+using namespace Windows::UI::ViewManagement;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Interop;
+using namespace Windows::UI::Xaml::Navigation;
+
+/// <summary>
+/// Initializes a new instance of the <see cref="LayoutAwarePage"/> class.
+/// </summary>
+LayoutAwarePage::LayoutAwarePage()
+{
+    if (Windows::ApplicationModel::DesignMode::DesignModeEnabled)
+    {
+        return;
+    }
+
+    // Create an empty default view model
+    DefaultViewModel = ref new Map<String^, Object^>(std::less<String^>());
+
+    // When this page is part of the visual tree make two changes:
+    // 1) Map application view state to visual state for the page
+    // 2) Handle keyboard and mouse navigation requests
+    Loaded += ref new RoutedEventHandler(this, &LayoutAwarePage::OnLoaded);
+
+    // Undo the same changes when the page is no longer visible
+    Unloaded += ref new RoutedEventHandler(this, &LayoutAwarePage::OnUnloaded);
+}
+
+static DependencyProperty^ _defaultViewModelProperty =
+    DependencyProperty::Register("DefaultViewModel",
+    TypeName(IObservableMap<String^, Object^>::typeid), TypeName(LayoutAwarePage::typeid), nullptr);
+
+/// <summary>
+/// Identifies the <see cref="DefaultViewModel"/> dependency property.
+/// </summary>
+DependencyProperty^ LayoutAwarePage::DefaultViewModelProperty::get()
+{
+    return _defaultViewModelProperty;
+}
+
+/// <summary>
+/// Gets an implementation of <see cref="IObservableMap&lt;String, Object&gt;"/> designed to be
+/// used as a trivial view model.
+/// </summary>
+IObservableMap<String^, Object^>^ LayoutAwarePage::DefaultViewModel::get()
+{
+    return safe_cast<IObservableMap<String^, Object^>^>(GetValue(DefaultViewModelProperty));
+}
+
+/// <summary>
+/// Sets an implementation of <see cref="IObservableMap&lt;String, Object&gt;"/> designed to be
+/// used as a trivial view model.
+/// </summary>
+void LayoutAwarePage::DefaultViewModel::set(IObservableMap<String^, Object^>^ value)
+{
+    SetValue(DefaultViewModelProperty, value);
+}
+
+/// <summary>
+/// Invoked when the page is part of the visual tree
+/// </summary>
+/// <param name="sender">Instance that triggered the event.</param>
+/// <param name="e">Event data describing the conditions that led to the event.</param>
+void LayoutAwarePage::OnLoaded(Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
+{
+    this->StartLayoutUpdates(sender, e);
+
+    // Keyboard and mouse navigation only apply when occupying the entire window
+    if (this->ActualHeight == Window::Current->Bounds.Height &&
+        this->ActualWidth == Window::Current->Bounds.Width)
+    {
+        // Listen to the window directly so focus isn't required
+        _acceleratorKeyEventToken = Window::Current->CoreWindow->Dispatcher->AcceleratorKeyActivated +=
+            ref new TypedEventHandler<CoreDispatcher^, AcceleratorKeyEventArgs^>(this,
+            &LayoutAwarePage::CoreDispatcher_AcceleratorKeyActivated);
+        _pointerPressedEventToken = Window::Current->CoreWindow->PointerPressed +=
+            ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this,
+            &LayoutAwarePage::CoreWindow_PointerPressed);
+        _navigationShortcutsRegistered = true;
+    }
+}
+
+/// <summary>
+/// Invoked when the page is removed from visual tree
+/// </summary>
+/// <param name="sender">Instance that triggered the event.</param>
+/// <param name="e">Event data describing the conditions that led to the event.</param>
+void LayoutAwarePage::OnUnloaded(Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
+{
+    if (_navigationShortcutsRegistered)
+    {
+        Window::Current->CoreWindow->Dispatcher->AcceleratorKeyActivated -= _acceleratorKeyEventToken;
+        Window::Current->CoreWindow->PointerPressed -= _pointerPressedEventToken;
+        _navigationShortcutsRegistered = false;
+    }
+    StopLayoutUpdates(sender, e);
+}
+
+#pragma region Navigation support
+
+/// <summary>
+/// Invoked as an event handler to navigate backward in the page's associated <see cref="Frame"/>
+/// until it reaches the top of the navigation stack.
+/// </summary>
+/// <param name="sender">Instance that triggered the event.</param>
+/// <param name="e">Event data describing the conditions that led to the event.</param>
+void LayoutAwarePage::GoHome(Object^ sender, RoutedEventArgs^ e)
+{
+    (void) sender;	// Unused parameter
+    (void) e;	// Unused parameter
+
+    // Use the navigation frame to return to the topmost page
+    if (Frame != nullptr)
+    {
+        while (Frame->CanGoBack)
+        {
+            Frame->GoBack();
+        }
+    }
+}
+
+/// <summary>
+/// Invoked as an event handler to navigate backward in the navigation stack
+/// associated with this page's <see cref="Frame"/>.
+/// </summary>
+/// <param name="sender">Instance that triggered the event.</param>
+/// <param name="e">Event data describing the conditions that led to the event.</param>
+void LayoutAwarePage::GoBack(Object^ sender, RoutedEventArgs^ e)
+{
+    (void) sender;	// Unused parameter
+    (void) e;	// Unused parameter
+
+    // Use the navigation frame to return to the previous page
+    if (Frame != nullptr && Frame->CanGoBack)
+    {
+        Frame->GoBack();
+    }
+}
+
+/// <summary>
+/// Invoked as an event handler to navigate forward in the navigation stack
+/// associated with this page's <see cref="Frame"/>.
+/// </summary>
+/// <param name="sender">Instance that triggered the event.</param>
+/// <param name="e">Event data describing the conditions that led to the event.</param>
+void LayoutAwarePage::GoForward(Object^ sender, RoutedEventArgs^ e)
+{
+    (void) sender;	// Unused parameter
+    (void) e;	// Unused parameter
+
+    // Use the navigation frame to advance to the next page
+    if (Frame != nullptr && Frame->CanGoForward)
+    {
+        Frame->GoForward();
+    }
+}
+
+/// <summary>
+/// Invoked on every keystroke, including system keys such as Alt key combinations, when
+/// this page is active and occupies the entire window.  Used to detect keyboard navigation
+/// between pages even when the page itself doesn't have focus.
+/// </summary>
+/// <param name="sender">Instance that triggered the event.</param>
+/// <param name="args">Event data describing the conditions that led to the event.</param>
+void LayoutAwarePage::CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher^ sender, AcceleratorKeyEventArgs^ args)
+{
+    auto virtualKey = args->VirtualKey;
+
+    // Only investigate further when Left, Right, or the dedicated Previous or Next keys
+    // are pressed
+    if ((args->EventType == CoreAcceleratorKeyEventType::SystemKeyDown ||
+        args->EventType == CoreAcceleratorKeyEventType::KeyDown) &&
+        (virtualKey == VirtualKey::Left || virtualKey == VirtualKey::Right ||
+        (int)virtualKey == 166 || (int)virtualKey == 167))
+    {
+        auto coreWindow = Window::Current->CoreWindow;
+        auto downState = Windows::UI::Core::CoreVirtualKeyStates::Down;
+        bool menuKey = (coreWindow->GetKeyState(VirtualKey::Menu) & downState) == downState;
+        bool controlKey = (coreWindow->GetKeyState(VirtualKey::Control) & downState) == downState;
+        bool shiftKey = (coreWindow->GetKeyState(VirtualKey::Shift) & downState) == downState;
+        bool noModifiers = !menuKey && !controlKey && !shiftKey;
+        bool onlyAlt = menuKey && !controlKey && !shiftKey;
+
+        if (((int)virtualKey == 166 && noModifiers) ||
+            (virtualKey == VirtualKey::Left && onlyAlt))
+        {
+            // When the previous key or Alt+Left are pressed navigate back
+            args->Handled = true;
+            GoBack(this, ref new RoutedEventArgs());
+        }
+        else if (((int)virtualKey == 167 && noModifiers) ||
+            (virtualKey == VirtualKey::Right && onlyAlt))
+        {
+            // When the next key or Alt+Right are pressed navigate forward
+            args->Handled = true;
+            GoForward(this, ref new RoutedEventArgs());
+        }
+    }
+}
+
+/// <summary>
+/// Invoked on every mouse click, touch screen tap, or equivalent interaction when this
+/// page is active and occupies the entire window.  Used to detect browser-style next and
+/// previous mouse button clicks to navigate between pages.
+/// </summary>
+/// <param name="sender">Instance that triggered the event.</param>
+/// <param name="args">Event data describing the conditions that led to the event.</param>
+void LayoutAwarePage::CoreWindow_PointerPressed(CoreWindow^ sender, PointerEventArgs^ args)
+{
+    auto properties = args->CurrentPoint->Properties;
+
+    // Ignore button chords with the left, right, and middle buttons
+    if (properties->IsLeftButtonPressed || properties->IsRightButtonPressed ||
+        properties->IsMiddleButtonPressed) return;
+
+    // If back or forward are pressed (but not both) navigate appropriately
+    bool backPressed = properties->IsXButton1Pressed;
+    bool forwardPressed = properties->IsXButton2Pressed;
+    if (backPressed ^ forwardPressed)
+    {
+        args->Handled = true;
+        if (backPressed) GoBack(this, ref new RoutedEventArgs());
+        if (forwardPressed) GoForward(this, ref new RoutedEventArgs());
+    }
+}
+
+#pragma endregion
+
+#pragma region Visual state switching
+
+/// <summary>
+/// Invoked as an event handler, typically on the <see cref="Loaded"/> event of a
+/// <see cref="Control"/> within the page, to indicate that the sender should start receiving
+/// visual state management changes that correspond to application view state changes.
+/// </summary>
+/// <param name="sender">Instance of <see cref="Control"/> that supports visual state management
+/// corresponding to view states.</param>
+/// <param name="e">Event data that describes how the request was made.</param>
+/// <remarks>The current view state will immediately be used to set the corresponding visual state
+/// when layout updates are requested.  A corresponding <see cref="Unloaded"/> event handler
+/// connected to <see cref="StopLayoutUpdates"/> is strongly encouraged.  Instances of
+/// <see cref="LayoutAwarePage"/> automatically invoke these handlers in their Loaded and Unloaded
+/// events.</remarks>
+/// <seealso cref="DetermineVisualState"/>
+/// <seealso cref="InvalidateVisualState"/>
+void LayoutAwarePage::StartLayoutUpdates(Object^ sender, RoutedEventArgs^ e)
+{
+    (void) e;	// Unused parameter
+
+    auto control = safe_cast<Control^>(sender);
+    if (_layoutAwareControls == nullptr)
+    {
+        // Start listening to view state changes when there are controls interested in updates
+        _layoutAwareControls = ref new Vector<Control^>();
+        _windowSizeEventToken = Window::Current->SizeChanged += ref new WindowSizeChangedEventHandler(this, &LayoutAwarePage::WindowSizeChanged);
+
+        // Page receives notifications for children. Protect the page until we stopped layout updates for all controls.
+        _this = this;
+    }
+    _layoutAwareControls->Append(control);
+
+    // Set the initial visual state of the control
+    VisualStateManager::GoToState(control, DetermineVisualState(ApplicationView::Value), false);
+}
+
+void LayoutAwarePage::WindowSizeChanged(Object^ sender, Windows::UI::Core::WindowSizeChangedEventArgs^ e)
+{
+    (void) sender;	// Unused parameter
+    (void) e;	// Unused parameter
+
+    InvalidateVisualState();
+}
+
+/// <summary>
+/// Invoked as an event handler, typically on the <see cref="Unloaded"/> event of a
+/// <see cref="Control"/>, to indicate that the sender should start receiving visual state
+/// management changes that correspond to application view state changes.
+/// </summary>
+/// <param name="sender">Instance of <see cref="Control"/> that supports visual state management
+/// corresponding to view states.</param>
+/// <param name="e">Event data that describes how the request was made.</param>
+/// <remarks>The current view state will immediately be used to set the corresponding visual state
+/// when layout updates are requested.</remarks>
+/// <seealso cref="StartLayoutUpdates"/>
+void LayoutAwarePage::StopLayoutUpdates(Object^ sender, RoutedEventArgs^ e)
+{
+    (void) e;	// Unused parameter
+
+    auto control = safe_cast<Control^>(sender);
+    unsigned int index;
+    if (_layoutAwareControls != nullptr && _layoutAwareControls->IndexOf(control, &index))
+    {
+        _layoutAwareControls->RemoveAt(index);
+        if (_layoutAwareControls->Size == 0)
+        {
+            // Stop listening to view state changes when no controls are interested in updates
+            Window::Current->SizeChanged -= _windowSizeEventToken;
+            _layoutAwareControls = nullptr;
+            // Last control has received the Unload notification.
+            _this = nullptr;
+        }
+    }
+}
+
+/// <summary>
+/// Translates <see cref="ApplicationViewState"/> values into strings for visual state management
+/// within the page.  The default implementation uses the names of enum values.  Subclasses may
+/// override this method to control the mapping scheme used.
+/// </summary>
+/// <param name="viewState">View state for which a visual state is desired.</param>
+/// <returns>Visual state name used to drive the <see cref="VisualStateManager"/></returns>
+/// <seealso cref="InvalidateVisualState"/>
+String^ LayoutAwarePage::DetermineVisualState(ApplicationViewState viewState)
+{
+    switch (viewState)
+    {
+    case ApplicationViewState::Filled:
+        return "Filled";
+    case ApplicationViewState::Snapped:
+        return "Snapped";
+    case ApplicationViewState::FullScreenPortrait:
+        return "FullScreenPortrait";
+    case ApplicationViewState::FullScreenLandscape:
+    default:
+        return "FullScreenLandscape";
+    }
+}
+
+/// <summary>
+/// Updates all controls that are listening for visual state changes with the correct visual
+/// state.
+/// </summary>
+/// <remarks>
+/// Typically used in conjunction with overriding <see cref="DetermineVisualState"/> to
+/// signal that a different value may be returned even though the view state has not changed.
+/// </remarks>
+void LayoutAwarePage::InvalidateVisualState()
+{
+    if (_layoutAwareControls != nullptr)
+    {
+        String^ visualState = DetermineVisualState(ApplicationView::Value);
+        auto controlIterator = _layoutAwareControls->First();
+        while (controlIterator->HasCurrent)
+        {
+            auto control = controlIterator->Current;
+            VisualStateManager::GoToState(control, visualState, false);
+            controlIterator->MoveNext();
+        }
+    }
+}
+
+#pragma endregion
+
+#pragma region Process lifetime management
+
+/// <summary>
+/// Invoked when this page is about to be displayed in a Frame.
+/// </summary>
+/// <param name="e">Event data that describes how this page was reached.  The Parameter
+/// property provides the group to be displayed.</param>
+void LayoutAwarePage::OnNavigatedTo(NavigationEventArgs^ e)
+{
+    // Returning to a cached page through navigation shouldn't trigger state loading
+    if (_pageKey != nullptr) return;
+
+    auto frameState = SuspensionManager::SessionStateForFrame(Frame);
+    _pageKey = "Page-" + Frame->BackStackDepth;
+
+    if (e->NavigationMode == NavigationMode::New)
+    {
+        // Clear existing state for forward navigation when adding a new page to the
+        // navigation stack
+        auto nextPageKey = _pageKey;
+        int nextPageIndex = Frame->BackStackDepth;
+        while (frameState->HasKey(nextPageKey))
+        {
+            frameState->Remove(nextPageKey);
+            nextPageIndex++;
+            nextPageKey = "Page-" + nextPageIndex;
+        }
+
+        // Pass the navigation parameter to the new page
+        LoadState(e->Parameter, nullptr);
+    }
+    else
+    {
+        // Pass the navigation parameter and preserved page state to the page, using
+        // the same strategy for loading suspended state and recreating pages discarded
+        // from cache
+        LoadState(e->Parameter, safe_cast<IMap<String^, Object^>^>(frameState->Lookup(_pageKey)));
+    }
+}
+
+/// <summary>
+/// Invoked when this page will no longer be displayed in a Frame.
+/// </summary>
+/// <param name="e">Event data that describes how this page was reached.  The Parameter
+/// property provides the group to be displayed.</param>
+void LayoutAwarePage::OnNavigatedFrom(NavigationEventArgs^ e)
+{
+    auto frameState = SuspensionManager::SessionStateForFrame(Frame);
+    auto pageState = ref new Map<String^, Object^>();
+    SaveState(pageState);
+    frameState->Insert(_pageKey, pageState);
+}
+
+/// <summary>
+/// Populates the page with content passed during navigation.  Any saved state is also
+/// provided when recreating a page from a prior session.
+/// </summary>
+/// <param name="navigationParameter">The parameter value passed to
+/// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested.
+/// </param>
+/// <param name="pageState">A map of state preserved by this page during an earlier
+/// session.  This will be null the first time a page is visited.</param>
+void LayoutAwarePage::LoadState(Object^ navigationParameter, IMap<String^, Object^>^ pageState)
+{
+}
+
+/// <summary>
+/// Preserves state associated with this page in case the application is suspended or the
+/// page is discarded from the navigation cache.  Values must conform to the serialization
+/// requirements of <see cref="SuspensionManager.SessionState"/>.
+/// </summary>
+/// <param name="pageState">An empty map to be populated with serializable state.</param>
+void LayoutAwarePage::SaveState(IMap<String^, Object^>^ pageState)
+{
+}
+
+#pragma endregion
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/LayoutAwarePage.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/LayoutAwarePage.h
new file mode 100644
index 00000000..bd71062f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/LayoutAwarePage.h
@@ -0,0 +1,88 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+#pragma once
+
+#include <collection.h>
+
+namespace SDKSample
+{
+    namespace Common
+    {
+        /// <summary>
+        /// Typical implementation of Page that provides several important conveniences:
+        /// <list type="bullet">
+        /// <item>
+        /// <description>Application view state to visual state mapping</description>
+        /// </item>
+        /// <item>
+        /// <description>GoBack, GoForward, and GoHome event handlers</description>
+        /// </item>
+        /// <item>
+        /// <description>Mouse and keyboard shortcuts for navigation</description>
+        /// </item>
+        /// <item>
+        /// <description>State management for navigation and process lifetime management</description>
+        /// </item>
+        /// <item>
+        /// <description>A default view model</description>
+        /// </item>
+        /// </list>
+        /// </summary>
+        [Windows::Foundation::Metadata::WebHostHidden]
+        public ref class LayoutAwarePage : Windows::UI::Xaml::Controls::Page
+        {
+        internal:
+            LayoutAwarePage();
+
+        public:
+            void StartLayoutUpdates(Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+            void StopLayoutUpdates(Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+            void InvalidateVisualState();
+            static property Windows::UI::Xaml::DependencyProperty^ DefaultViewModelProperty
+            {
+                Windows::UI::Xaml::DependencyProperty^ get();
+            };
+            property Windows::Foundation::Collections::IObservableMap<Platform::String^, Platform::Object^>^ DefaultViewModel
+            {
+                Windows::Foundation::Collections::IObservableMap<Platform::String^, Platform::Object^>^ get();
+                void set(Windows::Foundation::Collections::IObservableMap<Platform::String^, Platform::Object^>^ value);
+            }
+
+        protected:
+            virtual void GoHome(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+            virtual void GoBack(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+            virtual void GoForward(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+            virtual Platform::String^ DetermineVisualState(Windows::UI::ViewManagement::ApplicationViewState viewState);
+            virtual void OnNavigatedTo(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override;
+            virtual void OnNavigatedFrom(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override;
+            virtual void LoadState(Platform::Object^ navigationParameter,
+                Windows::Foundation::Collections::IMap<Platform::String^, Platform::Object^>^ pageState);
+            virtual void SaveState(Windows::Foundation::Collections::IMap<Platform::String^, Platform::Object^>^ pageState);
+
+        private:
+            Platform::String^ _pageKey;
+            bool _navigationShortcutsRegistered;
+            Platform::Collections::Map<Platform::String^, Platform::Object^>^ _defaultViewModel;
+            Windows::Foundation::EventRegistrationToken _windowSizeEventToken,
+                _acceleratorKeyEventToken, _pointerPressedEventToken;
+            Platform::Collections::Vector<Windows::UI::Xaml::Controls::Control^>^ _layoutAwareControls;
+            void WindowSizeChanged(Platform::Object^ sender, Windows::UI::Core::WindowSizeChangedEventArgs^ e);
+            void OnLoaded(Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+            void OnUnloaded(Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+
+            void CoreDispatcher_AcceleratorKeyActivated(Windows::UI::Core::CoreDispatcher^ sender,
+                Windows::UI::Core::AcceleratorKeyEventArgs^ args);
+            void CoreWindow_PointerPressed(Windows::UI::Core::CoreWindow^ sender,
+                Windows::UI::Core::PointerEventArgs^ args);
+            LayoutAwarePage^ _this; // Strong reference to self, cleaned up in OnUnload
+        };
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/StandardStyles.xaml b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/StandardStyles.xaml
new file mode 100644
index 00000000..b4edc81f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/StandardStyles.xaml
@@ -0,0 +1,978 @@
+<!--
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+-->
+
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <!-- Non-brush values that vary across themes -->
+
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Key="Default">
+            <x:String x:Key="BackButtonGlyph">&#xE071;</x:String>
+            <x:String x:Key="BackButtonSnappedGlyph">&#xE0BA;</x:String>
+        </ResourceDictionary>
+
+        <ResourceDictionary x:Key="HighContrast">
+            <x:String x:Key="BackButtonGlyph">&#xE0A6;</x:String>
+            <x:String x:Key="BackButtonSnappedGlyph">&#xE0C4;</x:String>
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+
+    <!-- RichTextBlock styles -->
+
+    <Style x:Key="BasicRichTextStyle" TargetType="RichTextBlock">
+        <Setter Property="Foreground" Value="{StaticResource ApplicationForegroundThemeBrush}"/>
+        <Setter Property="FontSize" Value="{StaticResource ControlContentThemeFontSize}"/>
+        <Setter Property="FontFamily" Value="{StaticResource ContentControlThemeFontFamily}"/>
+        <Setter Property="TextTrimming" Value="WordEllipsis"/>
+        <Setter Property="TextWrapping" Value="Wrap"/>
+        <Setter Property="Typography.StylisticSet20" Value="True"/>
+        <Setter Property="Typography.DiscretionaryLigatures" Value="True"/>
+    </Style>
+
+    <Style x:Key="BaselineRichTextStyle" TargetType="RichTextBlock" BasedOn="{StaticResource BasicRichTextStyle}">
+        <Setter Property="LineHeight" Value="20"/>
+        <Setter Property="LineStackingStrategy" Value="BlockLineHeight"/>
+        <!-- Properly align text along its baseline -->
+        <Setter Property="RenderTransform">
+            <Setter.Value>
+                <TranslateTransform X="-1" Y="4"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="ItemRichTextStyle" TargetType="RichTextBlock" BasedOn="{StaticResource BaselineRichTextStyle}"/>
+
+    <Style x:Key="BodyRichTextStyle" TargetType="RichTextBlock" BasedOn="{StaticResource BaselineRichTextStyle}">
+        <Setter Property="FontWeight" Value="SemiLight"/>
+    </Style>
+
+    <!-- TextBlock styles -->
+
+    <Style x:Key="BasicTextStyle" TargetType="TextBlock">
+        <Setter Property="Foreground" Value="{StaticResource ApplicationForegroundThemeBrush}"/>
+        <Setter Property="FontSize" Value="{StaticResource ControlContentThemeFontSize}"/>
+        <Setter Property="FontFamily" Value="{StaticResource ContentControlThemeFontFamily}"/>
+        <Setter Property="TextTrimming" Value="WordEllipsis"/>
+        <Setter Property="TextWrapping" Value="Wrap"/>
+        <Setter Property="Typography.StylisticSet20" Value="True"/>
+        <Setter Property="Typography.DiscretionaryLigatures" Value="True"/>
+    </Style>
+
+    <Style x:Key="BaselineTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BasicTextStyle}">
+        <Setter Property="LineHeight" Value="20"/>
+        <Setter Property="LineStackingStrategy" Value="BlockLineHeight"/>
+        <!-- Properly align text along its baseline -->
+        <Setter Property="RenderTransform">
+            <Setter.Value>
+                <TranslateTransform X="-1" Y="4"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="HeaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontSize" Value="56"/>
+        <Setter Property="FontWeight" Value="Light"/>
+        <Setter Property="LineHeight" Value="40"/>
+        <Setter Property="RenderTransform">
+            <Setter.Value>
+                <TranslateTransform X="-2" Y="8"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="SubheaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontSize" Value="26.667"/>
+        <Setter Property="FontWeight" Value="Light"/>
+        <Setter Property="LineHeight" Value="30"/>
+        <Setter Property="RenderTransform">
+            <Setter.Value>
+                <TranslateTransform X="-1" Y="6"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="TitleTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontWeight" Value="SemiBold"/>
+    </Style>
+
+    <Style x:Key="ItemTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}"/>
+
+    <Style x:Key="BodyTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontWeight" Value="SemiLight"/>
+    </Style>
+
+    <Style x:Key="CaptionTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontSize" Value="12"/>
+        <Setter Property="Foreground" Value="{StaticResource ApplicationSecondaryForegroundThemeBrush}"/>
+    </Style>
+
+    <!-- Button styles -->
+
+    <!--
+        TextButtonStyle is used to style a Button using subheader-styled text with no other adornment.  This
+        style is used in the GroupedItemsPage as a group header and in the FileOpenPickerPage for triggering
+        commands.
+    -->
+    <Style x:Key="TextButtonStyle" TargetType="Button">
+        <Setter Property="MinWidth" Value="0"/>
+        <Setter Property="MinHeight" Value="0"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="Button">
+                    <Grid Background="Transparent">
+                        <TextBlock
+                            x:Name="Text"
+                            Text="{TemplateBinding Content}"
+                            Margin="3,-7,3,10"
+                            TextWrapping="NoWrap"
+                            Style="{StaticResource SubheaderTextStyle}"/>
+                        <Rectangle
+                            x:Name="FocusVisualWhite"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualWhiteStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="1.5"/>
+                        <Rectangle
+                            x:Name="FocusVisualBlack"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualBlackStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="0.5"/>
+
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup x:Name="CommonStates">
+                                <VisualState x:Name="Normal"/>
+                                <VisualState x:Name="PointerOver">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ApplicationPointerOverForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Pressed">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ApplicationPressedForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Disabled">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ButtonDisabledForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="FocusStates">
+                                <VisualState x:Name="Focused">
+                                    <Storyboard>
+                                        <DoubleAnimation Duration="0" To="1" Storyboard.TargetName="FocusVisualWhite" Storyboard.TargetProperty="Opacity"/>
+                                        <DoubleAnimation Duration="0" To="1" Storyboard.TargetName="FocusVisualBlack" Storyboard.TargetProperty="Opacity"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Unfocused"/>
+                            </VisualStateGroup>
+                        </VisualStateManager.VisualStateGroups>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!--
+        TextRadioButtonStyle is used to style a RadioButton using subheader-styled text with no other adornment.
+        This style is used in the SearchResultsPage to allow selection among filters.
+    -->
+    <Style x:Key="TextRadioButtonStyle" TargetType="RadioButton">
+        <Setter Property="MinWidth" Value="0"/>
+        <Setter Property="MinHeight" Value="0"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="RadioButton">
+                    <Grid Background="Transparent">
+                        <TextBlock
+                            x:Name="Text"
+                            Text="{TemplateBinding Content}"
+                            Margin="3,-7,3,10"
+                            TextWrapping="NoWrap"
+                            Style="{StaticResource SubheaderTextStyle}"/>
+                        <Rectangle
+                            x:Name="FocusVisualWhite"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualWhiteStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="1.5"/>
+                        <Rectangle
+                            x:Name="FocusVisualBlack"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualBlackStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="0.5"/>
+
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup x:Name="CommonStates">
+                                <VisualState x:Name="Normal"/>
+                                <VisualState x:Name="PointerOver">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ApplicationPointerOverForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Pressed">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ApplicationPressedForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Disabled">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ButtonDisabledForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="FocusStates">
+                                <VisualState x:Name="Focused">
+                                    <Storyboard>
+                                        <DoubleAnimation Duration="0" To="1" Storyboard.TargetName="FocusVisualWhite" Storyboard.TargetProperty="Opacity"/>
+                                        <DoubleAnimation Duration="0" To="1" Storyboard.TargetName="FocusVisualBlack" Storyboard.TargetProperty="Opacity"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Unfocused"/>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="CheckStates">
+                                <VisualState x:Name="Checked"/>
+                                <VisualState x:Name="Unchecked">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ApplicationSecondaryForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Indeterminate"/>
+                            </VisualStateGroup>
+                        </VisualStateManager.VisualStateGroups>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!--
+        AppBarButtonStyle is used to style a Button for use in an App Bar.  Content will be centered and should fit within
+        the 40-pixel radius glyph provided.  16-point Segoe UI Symbol is used for content text to simplify the use of glyphs
+        from that font.  AutomationProperties.Name is used for the text below the glyph.
+    -->
+    <Style x:Key="AppBarButtonStyle" TargetType="Button">
+        <Setter Property="Foreground" Value="{StaticResource AppBarItemForegroundThemeBrush}"/>
+        <Setter Property="VerticalAlignment" Value="Stretch"/>
+        <Setter Property="FontFamily" Value="Segoe UI Symbol"/>
+        <Setter Property="FontWeight" Value="Normal"/>
+        <Setter Property="FontSize" Value="20"/>
+        <Setter Property="AutomationProperties.ItemType" Value="App Bar Button"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="Button">
+                    <Grid Width="100" Background="Transparent">
+                        <StackPanel VerticalAlignment="Top" Margin="0,14,0,13">
+                            <Grid Width="40" Height="40" Margin="0,0,0,5" HorizontalAlignment="Center">
+                                <TextBlock x:Name="BackgroundGlyph" Text="&#xE0A8;" FontFamily="Segoe UI Symbol" FontSize="53.333" Margin="-4,-19,0,0" Foreground="{StaticResource AppBarItemBackgroundThemeBrush}"/>
+                                <TextBlock x:Name="OutlineGlyph" Text="&#xE0A7;" FontFamily="Segoe UI Symbol" FontSize="53.333" Margin="-4,-19,0,0"/>
+                                <ContentPresenter x:Name="Content" HorizontalAlignment="Center" Margin="-1,-1,0,0" VerticalAlignment="Center"/>
+                            </Grid>
+                            <TextBlock
+                                x:Name="TextLabel"
+                                Text="{TemplateBinding AutomationProperties.Name}"
+                                Margin="0,0,2,0"
+                                FontSize="12"
+                                TextAlignment="Center"
+                                Width="88"
+                                MaxHeight="32"
+                                TextTrimming="WordEllipsis"
+                                Style="{StaticResource BasicTextStyle}"/>
+                        </StackPanel>
+                        <Rectangle
+                                x:Name="FocusVisualWhite"
+                                IsHitTestVisible="False"
+                                Stroke="{StaticResource FocusVisualWhiteStrokeThemeBrush}"
+                                StrokeEndLineCap="Square"
+                                StrokeDashArray="1,1"
+                                Opacity="0"
+                                StrokeDashOffset="1.5"/>
+                        <Rectangle
+                                x:Name="FocusVisualBlack"
+                                IsHitTestVisible="False"
+                                Stroke="{StaticResource FocusVisualBlackStrokeThemeBrush}"
+                                StrokeEndLineCap="Square"
+                                StrokeDashArray="1,1"
+                                Opacity="0"
+                                StrokeDashOffset="0.5"/>
+
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup x:Name="CommonStates">
+                                <VisualState x:Name="Normal"/>
+                                <VisualState x:Name="PointerOver">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemPointerOverBackgroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Content" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemPointerOverForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Pressed">
+                                    <Storyboard>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="OutlineGlyph"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="0"
+                                            Duration="0"/>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Content" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemPressedForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Disabled">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="OutlineGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemDisabledForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Content" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemDisabledForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="TextLabel" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemDisabledForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="FocusStates">
+                                <VisualState x:Name="Focused">
+                                    <Storyboard>
+                                        <DoubleAnimation
+                                                Storyboard.TargetName="FocusVisualWhite"
+                                                Storyboard.TargetProperty="Opacity"
+                                                To="1"
+                                                Duration="0"/>
+                                        <DoubleAnimation
+                                                Storyboard.TargetName="FocusVisualBlack"
+                                                Storyboard.TargetProperty="Opacity"
+                                                To="1"
+                                                Duration="0"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Unfocused" />
+                                <VisualState x:Name="PointerFocused" />
+                            </VisualStateGroup>
+                        </VisualStateManager.VisualStateGroups>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!-- Standard App Bar buttons -->
+
+    <Style x:Key="SkipBackAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SkipBackAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Skip Back"/>
+        <Setter Property="Content" Value="&#xE100;"/>
+    </Style>
+    <Style x:Key="SkipAheadAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SkipAheadAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Skip Ahead"/>
+        <Setter Property="Content" Value="&#xE101;"/>
+    </Style>
+    <Style x:Key="PlayAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PlayAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Play"/>
+        <Setter Property="Content" Value="&#xE102;"/>
+    </Style>
+    <Style x:Key="PauseAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PauseAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Pause"/>
+        <Setter Property="Content" Value="&#xE103;"/>
+    </Style>
+    <Style x:Key="EditAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="EditAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Edit"/>
+        <Setter Property="Content" Value="&#xE104;"/>
+    </Style>
+    <Style x:Key="SaveAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SaveAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Save"/>
+        <Setter Property="Content" Value="&#xE105;"/>
+    </Style>
+    <Style x:Key="DeleteAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DeleteAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Delete"/>
+        <Setter Property="Content" Value="&#xE106;"/>
+    </Style>
+    <Style x:Key="DiscardAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DiscardAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Discard"/>
+        <Setter Property="Content" Value="&#xE107;"/>
+    </Style>
+    <Style x:Key="RemoveAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RemoveAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Remove"/>
+        <Setter Property="Content" Value="&#xE108;"/>
+    </Style>
+    <Style x:Key="AddAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AddAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Add"/>
+        <Setter Property="Content" Value="&#xE109;"/>
+    </Style>
+    <Style x:Key="NoAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="NoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="No"/>
+        <Setter Property="Content" Value="&#xE10A;"/>
+    </Style>
+    <Style x:Key="YesAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="YesAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Yes"/>
+        <Setter Property="Content" Value="&#xE10B;"/>
+    </Style>
+    <Style x:Key="MoreAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MoreAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="More"/>
+        <Setter Property="Content" Value="&#xE10C;"/>
+    </Style>
+    <Style x:Key="RedoAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RedoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Redo"/>
+        <Setter Property="Content" Value="&#xE10D;"/>
+    </Style>
+    <Style x:Key="UndoAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="UndoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Undo"/>
+        <Setter Property="Content" Value="&#xE10E;"/>
+    </Style>
+    <Style x:Key="HomeAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="HomeAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Home"/>
+        <Setter Property="Content" Value="&#xE10F;"/>
+    </Style>
+    <Style x:Key="OutAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="OutAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Out"/>
+        <Setter Property="Content" Value="&#xE110;"/>
+    </Style>
+    <Style x:Key="NextAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="NextAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Next"/>
+        <Setter Property="Content" Value="&#xE111;"/>
+    </Style>
+    <Style x:Key="PreviousAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PreviousAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Previous"/>
+        <Setter Property="Content" Value="&#xE112;"/>
+    </Style>
+    <Style x:Key="FavoriteAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FavoriteAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Favorite"/>
+        <Setter Property="Content" Value="&#xE113;"/>
+    </Style>
+    <Style x:Key="PhotoAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PhotoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Photo"/>
+        <Setter Property="Content" Value="&#xE114;"/>
+    </Style>
+    <Style x:Key="SettingsAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SettingsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Settings"/>
+        <Setter Property="Content" Value="&#xE115;"/>
+    </Style>
+    <Style x:Key="VideoAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="VideoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Video"/>
+        <Setter Property="Content" Value="&#xE116;"/>
+    </Style>
+    <Style x:Key="RefreshAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RefreshAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Refresh"/>
+        <Setter Property="Content" Value="&#xE117;"/>
+    </Style>
+    <Style x:Key="DownloadAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DownloadAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Download"/>
+        <Setter Property="Content" Value="&#xE118;"/>
+    </Style>
+    <Style x:Key="MailAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MailAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Mail"/>
+        <Setter Property="Content" Value="&#xE119;"/>
+    </Style>
+    <Style x:Key="SearchAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SearchAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Search"/>
+        <Setter Property="Content" Value="&#xE11A;"/>
+    </Style>
+    <Style x:Key="HelpAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="HelpAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Help"/>
+        <Setter Property="Content" Value="&#xE11B;"/>
+    </Style>
+    <Style x:Key="UploadAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="UploadAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Upload"/>
+        <Setter Property="Content" Value="&#xE11C;"/>
+    </Style>
+    <Style x:Key="PinAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PinAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Pin"/>
+        <Setter Property="Content" Value="&#xE141;"/>
+    </Style>
+    <Style x:Key="UnpinAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="UnpinAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Unpin"/>
+        <Setter Property="Content" Value="&#xE196;"/>
+    </Style>
+
+    <!-- Title area styles -->
+
+    <Style x:Key="PageHeaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource HeaderTextStyle}">
+        <Setter Property="TextWrapping" Value="NoWrap"/>
+        <Setter Property="VerticalAlignment" Value="Bottom"/>
+        <Setter Property="Margin" Value="0,0,40,40"/>
+    </Style>
+
+    <Style x:Key="PageSubheaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource SubheaderTextStyle}">
+        <Setter Property="TextWrapping" Value="NoWrap"/>
+        <Setter Property="VerticalAlignment" Value="Bottom"/>
+        <Setter Property="Margin" Value="0,0,0,40"/>
+    </Style>
+
+    <Style x:Key="SnappedPageHeaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource PageSubheaderTextStyle}">
+        <Setter Property="Margin" Value="0,0,18,40"/>
+    </Style>
+
+    <!--
+        BackButtonStyle is used to style a Button for use in the title area of a page.  Margins appropriate for
+        the conventional page layout are included as part of the style.
+    -->
+    <Style x:Key="BackButtonStyle" TargetType="Button">
+        <Setter Property="MinWidth" Value="0"/>
+        <Setter Property="Width" Value="48"/>
+        <Setter Property="Height" Value="48"/>
+        <Setter Property="Margin" Value="36,0,36,36"/>
+        <Setter Property="VerticalAlignment" Value="Bottom"/>
+        <Setter Property="FontFamily" Value="Segoe UI Symbol"/>
+        <Setter Property="FontWeight" Value="Normal"/>
+        <Setter Property="FontSize" Value="56"/>
+        <Setter Property="AutomationProperties.AutomationId" Value="BackButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Back"/>
+        <Setter Property="AutomationProperties.ItemType" Value="Navigation Button"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="Button">
+                    <Grid x:Name="RootGrid">
+                        <Grid Margin="-1,-16,0,0">
+                            <TextBlock x:Name="BackgroundGlyph" Text="&#xE0A8;" Foreground="{StaticResource BackButtonBackgroundThemeBrush}"/>
+                            <TextBlock x:Name="NormalGlyph" Text="{StaticResource BackButtonGlyph}" Foreground="{StaticResource BackButtonForegroundThemeBrush}"/>
+                            <TextBlock x:Name="ArrowGlyph" Text="&#xE0A6;" Foreground="{StaticResource BackButtonPressedForegroundThemeBrush}" Opacity="0"/>
+                        </Grid>
+                        <Rectangle
+                            x:Name="FocusVisualWhite"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualWhiteStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="1.5"/>
+                        <Rectangle
+                            x:Name="FocusVisualBlack"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualBlackStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="0.5"/>
+
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup x:Name="CommonStates">
+                                <VisualState x:Name="Normal" />
+                                <VisualState x:Name="PointerOver">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonPointerOverBackgroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="NormalGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonPointerOverForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Pressed">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="ArrowGlyph"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="NormalGlyph"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="0"
+                                            Duration="0"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Disabled">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="RootGrid" Storyboard.TargetProperty="Visibility">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="FocusStates">
+                                <VisualState x:Name="Focused">
+                                    <Storyboard>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="FocusVisualWhite"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="FocusVisualBlack"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Unfocused" />
+                                <VisualState x:Name="PointerFocused" />
+                            </VisualStateGroup>
+                        </VisualStateManager.VisualStateGroups>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!--
+        PortraitBackButtonStyle is used to style a Button for use in the title area of a portrait page.  Margins appropriate
+        for the conventional page layout are included as part of the style.
+    -->
+    <Style x:Key="PortraitBackButtonStyle" TargetType="Button" BasedOn="{StaticResource BackButtonStyle}">
+        <Setter Property="Margin" Value="26,0,26,36"/>
+    </Style>
+
+    <!--
+        SnappedBackButtonStyle is used to style a Button for use in the title area of a snapped page.  Margins appropriate
+        for the conventional page layout are included as part of the style.
+
+        The obvious duplication here is necessary as the glyphs used in snapped are not merely smaller versions of the same
+        glyph but are actually distinct.
+    -->
+    <Style x:Key="SnappedBackButtonStyle" TargetType="Button">
+        <Setter Property="MinWidth" Value="0"/>
+        <Setter Property="Margin" Value="20,0,0,0"/>
+        <Setter Property="VerticalAlignment" Value="Bottom"/>
+        <Setter Property="FontFamily" Value="Segoe UI Symbol"/>
+        <Setter Property="FontWeight" Value="Normal"/>
+        <Setter Property="FontSize" Value="26.66667"/>
+        <Setter Property="AutomationProperties.AutomationId" Value="BackButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Back"/>
+        <Setter Property="AutomationProperties.ItemType" Value="Navigation Button"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="Button">
+                    <Grid x:Name="RootGrid" Width="36" Height="36" Margin="-3,0,7,33">
+                        <Grid Margin="-1,-1,0,0">
+                            <TextBlock x:Name="BackgroundGlyph" Text="&#xE0D4;" Foreground="{StaticResource BackButtonBackgroundThemeBrush}"/>
+                            <TextBlock x:Name="NormalGlyph" Text="{StaticResource BackButtonSnappedGlyph}" Foreground="{StaticResource BackButtonForegroundThemeBrush}"/>
+                            <TextBlock x:Name="ArrowGlyph" Text="&#xE0C4;" Foreground="{StaticResource BackButtonPressedForegroundThemeBrush}" Opacity="0"/>
+                        </Grid>
+                        <Rectangle
+                            x:Name="FocusVisualWhite"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualWhiteStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="1.5"/>
+                        <Rectangle
+                            x:Name="FocusVisualBlack"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualBlackStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="0.5"/>
+
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup x:Name="CommonStates">
+                                <VisualState x:Name="Normal" />
+                                <VisualState x:Name="PointerOver">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonPointerOverBackgroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="NormalGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonPointerOverForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Pressed">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="ArrowGlyph"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="NormalGlyph"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="0"
+                                            Duration="0"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Disabled">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="RootGrid" Storyboard.TargetProperty="Visibility">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="FocusStates">
+                                <VisualState x:Name="Focused">
+                                    <Storyboard>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="FocusVisualWhite"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="FocusVisualBlack"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Unfocused" />
+                                <VisualState x:Name="PointerFocused" />
+                            </VisualStateGroup>
+                        </VisualStateManager.VisualStateGroups>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!-- Item templates -->
+
+    <!-- Grid-appropriate 250 pixel square item template as seen in the GroupedItemsPage and ItemsPage -->
+    <DataTemplate x:Key="Standard250x250ItemTemplate">
+        <Grid HorizontalAlignment="Left" Width="250" Height="250">
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}">
+                <Image Source="{Binding Image}" Stretch="UniformToFill"/>
+            </Border>
+            <StackPanel VerticalAlignment="Bottom" Background="{StaticResource ListViewItemOverlayBackgroundThemeBrush}">
+                <TextBlock Text="{Binding Title}" Foreground="{StaticResource ListViewItemOverlayForegroundThemeBrush}" Style="{StaticResource TitleTextStyle}" Height="60" Margin="15,0,15,0"/>
+                <TextBlock Text="{Binding Subtitle}" Foreground="{StaticResource ListViewItemOverlaySecondaryForegroundThemeBrush}" Style="{StaticResource CaptionTextStyle}" TextWrapping="NoWrap" Margin="15,0,15,10"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!-- Grid-appropriate 500 by 130 pixel item template as seen in the GroupDetailPage -->
+    <DataTemplate x:Key="Standard500x130ItemTemplate">
+        <Grid Height="110" Width="480" Margin="10">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Width="110" Height="110">
+                <Image Source="{Binding Image}" Stretch="UniformToFill"/>
+            </Border>
+            <StackPanel Grid.Column="1" VerticalAlignment="Top" Margin="10,0,0,0">
+                <TextBlock Text="{Binding Title}" Style="{StaticResource TitleTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Subtitle}" Style="{StaticResource CaptionTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Description}" Style="{StaticResource BodyTextStyle}" MaxHeight="60"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!-- List-appropriate 130 pixel high item template as seen in the SplitPage -->
+    <DataTemplate x:Key="Standard130ItemTemplate">
+        <Grid Height="110" Margin="6">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Width="110" Height="110">
+                <Image Source="{Binding Image}" Stretch="UniformToFill"/>
+            </Border>
+            <StackPanel Grid.Column="1" VerticalAlignment="Top" Margin="10,0,0,0">
+                <TextBlock Text="{Binding Title}" Style="{StaticResource TitleTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Subtitle}" Style="{StaticResource CaptionTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Description}" Style="{StaticResource BodyTextStyle}" MaxHeight="60"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!--
+        List-appropriate 80 pixel high item template as seen in the SplitPage when Filled, and
+        the following pages when snapped: GroupedItemsPage, GroupDetailPage, and ItemsPage
+    -->
+    <DataTemplate x:Key="Standard80ItemTemplate">
+        <Grid Margin="6">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Width="60" Height="60">
+                <Image Source="{Binding Image}" Stretch="UniformToFill"/>
+            </Border>
+            <StackPanel Grid.Column="1" Margin="10,0,0,0">
+                <TextBlock Text="{Binding Title}" Style="{StaticResource ItemTextStyle}" MaxHeight="40"/>
+                <TextBlock Text="{Binding Subtitle}" Style="{StaticResource CaptionTextStyle}" TextWrapping="NoWrap"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!-- Grid-appropriate 300 by 70 pixel item template as seen in the SearchResultsPage -->
+    <DataTemplate x:Key="StandardSmallIcon300x70ItemTemplate">
+        <Grid Width="300">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Margin="10,10,0,20" Width="40" Height="40">
+                <Image Source="{Binding Image}" Stretch="UniformToFill"/>
+            </Border>
+            <StackPanel Grid.Column="1" Margin="10,0,10,10">
+                <TextBlock Text="{Binding Title}" Style="{StaticResource BodyTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Subtitle}" Style="{StaticResource BodyTextStyle}" Foreground="{StaticResource ApplicationSecondaryForegroundThemeBrush}" Height="40"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!-- List-appropriate 70 pixel high item template as seen in the SearchResultsPage when Snapped -->
+    <DataTemplate x:Key="StandardSmallIcon70ItemTemplate">
+        <Grid Margin="6">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Margin="0,0,0,10" Width="40" Height="40">
+                <Image Source="{Binding Image}" Stretch="UniformToFill"/>
+            </Border>
+            <StackPanel Grid.Column="1" Margin="10,-10,0,0">
+                <TextBlock Text="{Binding Title}" Style="{StaticResource BodyTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Subtitle}" Style="{StaticResource BodyTextStyle}" Foreground="{StaticResource ApplicationSecondaryForegroundThemeBrush}" Height="40"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+  <!--
+      190x130 pixel item template for displaying file previews as seen in the FileOpenPickerPage
+      Includes an elaborate tooltip to display title and description text
+  -->
+  <DataTemplate x:Key="StandardFileWithTooltip190x130ItemTemplate">
+        <Grid>
+            <Grid Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}">
+                <Image
+                    Source="{Binding Image}"
+                    Width="190"
+                    Height="130"
+                    HorizontalAlignment="Center"
+                    VerticalAlignment="Center"
+                    Stretch="Uniform"/>
+            </Grid>
+            <ToolTipService.Placement>Mouse</ToolTipService.Placement>
+            <ToolTipService.ToolTip>
+                <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto"/>
+                        <ColumnDefinition Width="*"/>
+                    </Grid.ColumnDefinitions>
+
+                    <Grid Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Margin="20">
+                        <Image
+                            Source="{Binding Image}"
+                            Width="160"
+                            Height="160"
+                            HorizontalAlignment="Center"
+                            VerticalAlignment="Center"
+                            Stretch="Uniform"/>
+                    </Grid>
+                    <StackPanel Width="200" Grid.Column="1" Margin="0,20,20,20">
+                        <TextBlock Text="{Binding Title}" TextWrapping="NoWrap" Style="{StaticResource BodyTextStyle}"/>
+                        <TextBlock Text="{Binding Description}" MaxHeight="140" Foreground="{StaticResource ApplicationSecondaryForegroundThemeBrush}" Style="{StaticResource BodyTextStyle}"/>
+                    </StackPanel>
+                </Grid>
+            </ToolTipService.ToolTip>
+        </Grid>
+    </DataTemplate>
+
+    <!-- Default to 10-pixel spacing between grid items (after accounting for 4-pixel insets for focus) -->
+
+    <Style TargetType="GridViewItem">
+        <Setter Property="Margin" Value="0,0,2,2" />
+    </Style>
+
+    <!-- ScrollViewer styles -->
+
+    <Style x:Key="HorizontalScrollViewerStyle" TargetType="ScrollViewer">
+        <Setter Property="HorizontalScrollBarVisibility" Value="Auto"/>
+        <Setter Property="VerticalScrollBarVisibility" Value="Disabled"/>
+        <Setter Property="ScrollViewer.HorizontalScrollMode" Value="Enabled" />
+        <Setter Property="ScrollViewer.VerticalScrollMode" Value="Disabled" />
+        <Setter Property="ScrollViewer.ZoomMode" Value="Disabled" />
+    </Style>
+
+    <Style x:Key="VerticalScrollViewerStyle" TargetType="ScrollViewer">
+        <Setter Property="HorizontalScrollBarVisibility" Value="Disabled"/>
+        <Setter Property="VerticalScrollBarVisibility" Value="Auto"/>
+        <Setter Property="ScrollViewer.HorizontalScrollMode" Value="Disabled" />
+        <Setter Property="ScrollViewer.VerticalScrollMode" Value="Enabled" />
+        <Setter Property="ScrollViewer.ZoomMode" Value="Disabled" />
+    </Style>
+
+    <!-- Page layout roots typically use entrance animations and a theme-appropriate background color -->
+
+    <Style x:Key="LayoutRootStyle" TargetType="Panel">
+        <Setter Property="Background" Value="{StaticResource ApplicationPageBackgroundThemeBrush}"/>
+        <Setter Property="ChildrenTransitions">
+            <Setter.Value>
+                <TransitionCollection>
+                    <EntranceThemeTransition/>
+                </TransitionCollection>
+            </Setter.Value>
+        </Setter>
+    </Style>
+</ResourceDictionary>
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/suspensionmanager.cpp b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/suspensionmanager.cpp
new file mode 100644
index 00000000..06fd2630
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/suspensionmanager.cpp
@@ -0,0 +1,481 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+//
+// SuspensionManager.cpp
+// Implementation of the SuspensionManager class
+//
+
+#include "pch.h"
+#include "SuspensionManager.h"
+
+#include <collection.h>
+#include <algorithm>
+
+using namespace SDKSample::Common;
+
+using namespace Concurrency;
+using namespace Platform;
+using namespace Platform::Collections;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::Storage;
+using namespace Windows::Storage::FileProperties;
+using namespace Windows::Storage::Streams;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Interop;
+
+namespace
+{
+    Map<String^, Object^>^ _sessionState = ref new Map<String^, Object^>();
+    String^ sessionStateFilename = "_sessionState.dat";
+
+    // Forward declarations for object object read / write support
+    void WriteObject(Windows::Storage::Streams::DataWriter^ writer, Platform::Object^ object);
+    Platform::Object^ ReadObject(Windows::Storage::Streams::DataReader^ reader);
+}
+
+/// <summary>
+/// Provides access to global session state for the current session.  This state is serialized by
+/// <see cref="SaveAsync"/> and restored by <see cref="RestoreAsync"/> which require values to be
+/// one of the following: boxed values including integers, floating-point singles and doubles,
+/// wide characters, boolean, Strings and Guids, or Map<String^, Object^> where map values are
+/// subject to the same constraints.  Session state should be as compact as possible.
+/// </summary>
+IMap<String^, Object^>^ SuspensionManager::SessionState::get(void)
+{
+    return _sessionState;
+}
+
+/// <summary>
+/// Wrap a WeakReference as a reference object for use in a collection.
+/// </summary>
+private ref class WeakFrame sealed
+{
+private:
+    WeakReference _frameReference;
+
+internal:
+    WeakFrame(Frame^ frame) { _frameReference = frame; }
+    property Frame^ ResolvedFrame
+    {
+        Frame^ get(void) { return _frameReference.Resolve<Frame>(); }
+    };
+};
+
+namespace
+{
+    std::vector<WeakFrame^> _registeredFrames;
+    DependencyProperty^ FrameSessionStateKeyProperty =
+        DependencyProperty::RegisterAttached("_FrameSessionStateKeyProperty",
+        TypeName(String::typeid), TypeName(SuspensionManager::typeid), nullptr);
+    DependencyProperty^ FrameSessionStateProperty =
+        DependencyProperty::RegisterAttached("_FrameSessionStateProperty",
+        TypeName(IMap<String^, Object^>::typeid), TypeName(SuspensionManager::typeid), nullptr);
+}
+
+/// <summary>
+/// Registers a <see cref="Frame"/> instance to allow its navigation history to be saved to
+/// and restored from <see cref="SessionState"/>.  Frames should be registered once
+/// immediately after creation if they will participate in session state management.  Upon
+/// registration if state has already been restored for the specified key
+/// the navigation history will immediately be restored.  Subsequent invocations of
+/// <see cref="RestoreAsync(String)"/> will also restore navigation history.
+/// </summary>
+/// <param name="frame">An instance whose navigation history should be managed by
+/// <see cref="SuspensionManager"/></param>
+/// <param name="sessionStateKey">A unique key into <see cref="SessionState"/> used to
+/// store navigation-related information.</param>
+void SuspensionManager::RegisterFrame(Frame^ frame, String^ sessionStateKey)
+{
+    if (frame->GetValue(FrameSessionStateKeyProperty) != nullptr)
+    {
+        throw ref new FailureException("Frames can only be registered to one session state key");
+    }
+
+    if (frame->GetValue(FrameSessionStateProperty) != nullptr)
+    {
+        throw ref new FailureException("Frames must be either be registered before accessing frame session state, or not registered at all");
+    }
+
+    // Use a dependency property to associate the session key with a frame, and keep a list of frames whose
+    // navigation state should be managed
+    frame->SetValue(FrameSessionStateKeyProperty, sessionStateKey);
+    _registeredFrames.insert(_registeredFrames.begin(), ref new WeakFrame(frame));
+
+    // Check to see if navigation state can be restored
+    RestoreFrameNavigationState(frame);
+}
+
+/// <summary>
+/// Disassociates a <see cref="Frame"/> previously registered by <see cref="RegisterFrame"/>
+/// from <see cref="SessionState"/>.  Any navigation state previously captured will be
+/// removed.
+/// </summary>
+/// <param name="frame">An instance whose navigation history should no longer be
+/// managed.</param>
+void SuspensionManager::UnregisterFrame(Frame^ frame)
+{
+    // Remove session state and remove the frame from the list of frames whose navigation
+    // state will be saved (along with any weak references that are no longer reachable)
+    auto key = safe_cast<String^>(frame->GetValue(FrameSessionStateKeyProperty));
+    if (SessionState->HasKey(key)) SessionState->Remove(key);
+    _registeredFrames.erase(
+        std::remove_if(_registeredFrames.begin(), _registeredFrames.end(), [=](WeakFrame^& e)
+        {
+            auto testFrame = e->ResolvedFrame;
+            return testFrame == nullptr || testFrame == frame;
+        }),
+        _registeredFrames.end()
+    );
+}
+
+/// <summary>
+/// Provides storage for session state associated with the specified <see cref="Frame"/>.
+/// Frames that have been previously registered with <see cref="RegisterFrame"/> have
+/// their session state saved and restored automatically as a part of the global
+/// <see cref="SessionState"/>.  Frames that are not registered have transient state
+/// that can still be useful when restoring pages that have been discarded from the
+/// navigation cache.
+/// </summary>
+/// <remarks>Apps may choose to rely on <see cref="LayoutAwarePage"/> to manage
+/// page-specific state instead of working with frame session state directly.</remarks>
+/// <param name="frame">The instance for which session state is desired.</param>
+/// <returns>A collection of state subject to the same serialization mechanism as
+/// <see cref="SessionState"/>.</returns>
+IMap<String^, Object^>^ SuspensionManager::SessionStateForFrame(Frame^ frame)
+{
+    auto frameState = safe_cast<IMap<String^, Object^>^>(frame->GetValue(FrameSessionStateProperty));
+
+    if (frameState == nullptr)
+    {
+        auto frameSessionKey = safe_cast<String^>(frame->GetValue(FrameSessionStateKeyProperty));
+        if (frameSessionKey != nullptr)
+        {
+            // Registered frames reflect the corresponding session state
+            if (!_sessionState->HasKey(frameSessionKey))
+            {
+                _sessionState->Insert(frameSessionKey, ref new Map<String^, Object^>());
+            }
+            frameState = safe_cast<IMap<String^, Object^>^>(_sessionState->Lookup(frameSessionKey));
+        }
+        else
+        {
+            // Frames that aren't registered have transient state
+            frameState = ref new Map<String^, Object^>();
+        }
+        frame->SetValue(FrameSessionStateProperty, frameState);
+    }
+    return frameState;
+}
+
+void SuspensionManager::RestoreFrameNavigationState(Frame^ frame)
+{
+    auto frameState = SessionStateForFrame(frame);
+    if (frameState->HasKey("Navigation"))
+    {
+        frame->SetNavigationState(safe_cast<String^>(frameState->Lookup("Navigation")));
+    }
+}
+
+void SuspensionManager::SaveFrameNavigationState(Frame^ frame)
+{
+    auto frameState = SessionStateForFrame(frame);
+    frameState->Insert("Navigation", frame->GetNavigationState());
+}
+
+/// <summary>
+/// Save the current <see cref="SessionState"/>.  Any <see cref="Frame"/> instances
+/// registered with <see cref="RegisterFrame"/> will also preserve their current
+/// navigation stack, which in turn gives their active <see cref="Page"/> an opportunity
+/// to save its state.
+/// </summary>
+/// <returns>An asynchronous task that reflects when session state has been saved.</returns>
+task<void> SuspensionManager::SaveAsync(void)
+{
+    // Save the navigation state for all registered frames
+    for (auto&& weakFrame : _registeredFrames)
+    {
+        auto frame = weakFrame->ResolvedFrame;
+        if (frame != nullptr) SaveFrameNavigationState(frame);
+    }
+
+    // Serialize the session state synchronously to avoid asynchronous access to shared
+    // state
+    auto sessionData = ref new InMemoryRandomAccessStream();
+    auto sessionDataWriter = ref new DataWriter(sessionData->GetOutputStreamAt(0));
+    WriteObject(sessionDataWriter, _sessionState);
+
+    // Once session state has been captured synchronously, begin the asynchronous process
+    // of writing the result to disk
+    return task<unsigned int>(sessionDataWriter->StoreAsync()).then([=](unsigned int)
+    {
+        return sessionDataWriter->FlushAsync();
+    }).then([=](bool flushSucceeded)
+    {
+        (void)flushSucceeded; // Unused parameter
+        return ApplicationData::Current->LocalFolder->CreateFileAsync(sessionStateFilename,
+            CreationCollisionOption::ReplaceExisting);
+    }).then([=](StorageFile^ createdFile)
+    {
+        return createdFile->OpenAsync(FileAccessMode::ReadWrite);
+    }).then([=](IRandomAccessStream^ newStream)
+    {
+        return RandomAccessStream::CopyAndCloseAsync(
+            sessionData->GetInputStreamAt(0), newStream->GetOutputStreamAt(0));
+    }).then([=](UINT64 copiedBytes)
+    {
+        (void)copiedBytes; // Unused parameter
+        return;
+    });
+}
+
+/// <summary>
+/// Restores previously saved <see cref="SessionState"/>.  Any <see cref="Frame"/> instances
+/// registered with <see cref="RegisterFrame"/> will also restore their prior navigation
+/// state, which in turn gives their active <see cref="Page"/> an opportunity restore its
+/// state.
+/// </summary>
+/// <param name="version">A version identifier compared to the session state to prevent
+/// incompatible versions of session state from reaching app code.  Saved state with a
+/// different version will be ignored, resulting in an empty <see cref="SessionState"/>
+/// dictionary.</param>
+/// <returns>An asynchronous task that reflects when session state has been read.  The
+/// content of <see cref="SessionState"/> should not be relied upon until this task
+/// completes.</returns>
+task<void> SuspensionManager::RestoreAsync(void)
+{
+    _sessionState->Clear();
+
+    task<StorageFile^> getFileTask(ApplicationData::Current->LocalFolder->GetFileAsync(sessionStateFilename));
+    return getFileTask.then([=](StorageFile^ stateFile)
+    {
+        task<BasicProperties^> getBasicPropertiesTask(stateFile->GetBasicPropertiesAsync());
+        return getBasicPropertiesTask.then([=](BasicProperties^ stateFileProperties)
+        {
+            auto size = unsigned int(stateFileProperties->Size);
+            if (size != stateFileProperties->Size) throw ref new FailureException("Session state larger than 4GB");
+            task<IRandomAccessStreamWithContentType^> openReadTask(stateFile->OpenReadAsync());
+            return openReadTask.then([=](IRandomAccessStreamWithContentType^ stateFileStream)
+            {
+                auto stateReader = ref new DataReader(stateFileStream);
+                return task<unsigned int>(stateReader->LoadAsync(size)).then([=](unsigned int bytesRead)
+                {
+                    (void)bytesRead; // Unused parameter
+                    // Deserialize the Session State
+                    Object^ content = ReadObject(stateReader);
+                    _sessionState = (Map<String^, Object^>^)content;
+
+                    // Restore any registered frames to their saved state
+                    for (auto&& weakFrame : _registeredFrames)
+                    {
+                        auto frame = weakFrame->ResolvedFrame;
+                        if (frame != nullptr)
+                        {
+                            frame->ClearValue(FrameSessionStateProperty);
+                            RestoreFrameNavigationState(frame);
+                        }
+                    }
+                }, task_continuation_context::use_current());
+            });
+        });
+    });
+}
+
+#pragma region Object serialization for a known set of types
+
+namespace
+{
+    // Codes used for identifying serialized types
+    enum StreamTypes {
+        NullPtrType = 0,
+
+        // Supported IPropertyValue types
+        UInt8Type, UInt16Type, UInt32Type, UInt64Type, Int16Type, Int32Type, Int64Type,
+        SingleType, DoubleType, BooleanType, Char16Type, GuidType, StringType,
+
+        // Additional supported types
+        StringToObjectMapType,
+
+        // Marker values used to ensure stream integrity
+        MapEndMarker
+    };
+
+    void WriteString(DataWriter^ writer, String^ string)
+    {
+        writer->WriteByte(StringType);
+        writer->WriteUInt32(writer->MeasureString(string));
+        writer->WriteString(string);
+    }
+
+    void WriteProperty(DataWriter^ writer, IPropertyValue^ propertyValue)
+    {
+        switch (propertyValue->Type)
+        {
+        case PropertyType::UInt8:
+            writer->WriteByte(UInt8Type);
+            writer->WriteByte(propertyValue->GetUInt8());
+            return;
+        case PropertyType::UInt16:
+            writer->WriteByte(UInt16Type);
+            writer->WriteUInt16(propertyValue->GetUInt16());
+            return;
+        case PropertyType::UInt32:
+            writer->WriteByte(UInt32Type);
+            writer->WriteUInt32(propertyValue->GetUInt32());
+            return;
+        case PropertyType::UInt64:
+            writer->WriteByte(UInt64Type);
+            writer->WriteUInt64(propertyValue->GetUInt64());
+            return;
+        case PropertyType::Int16:
+            writer->WriteByte(Int16Type);
+            writer->WriteUInt16(propertyValue->GetInt16());
+            return;
+        case PropertyType::Int32:
+            writer->WriteByte(Int32Type);
+            writer->WriteUInt32(propertyValue->GetInt32());
+            return;
+        case PropertyType::Int64:
+            writer->WriteByte(Int64Type);
+            writer->WriteUInt64(propertyValue->GetInt64());
+            return;
+        case PropertyType::Single:
+            writer->WriteByte(SingleType);
+            writer->WriteSingle(propertyValue->GetSingle());
+            return;
+        case PropertyType::Double:
+            writer->WriteByte(DoubleType);
+            writer->WriteDouble(propertyValue->GetDouble());
+            return;
+        case PropertyType::Boolean:
+            writer->WriteByte(BooleanType);
+            writer->WriteBoolean(propertyValue->GetBoolean());
+            return;
+        case PropertyType::Char16:
+            writer->WriteByte(Char16Type);
+            writer->WriteUInt16(propertyValue->GetChar16());
+            return;
+        case PropertyType::Guid:
+            writer->WriteByte(GuidType);
+            writer->WriteGuid(propertyValue->GetGuid());
+            return;
+        case PropertyType::String:
+            WriteString(writer, propertyValue->GetString());
+            return;
+        default:
+            throw ref new InvalidArgumentException("Unsupported property type");
+        }
+    }
+
+    void WriteStringToObjectMap(DataWriter^ writer, IMap<String^, Object^>^ map)
+    {
+        writer->WriteByte(StringToObjectMapType);
+        writer->WriteUInt32(map->Size);
+        for (auto&& pair : map)
+        {
+            WriteObject(writer, pair->Key);
+            WriteObject(writer, pair->Value);
+        }
+        writer->WriteByte(MapEndMarker);
+    }
+
+    void WriteObject(DataWriter^ writer, Object^ object)
+    {
+        if (object == nullptr)
+        {
+            writer->WriteByte(NullPtrType);
+            return;
+        }
+
+        auto propertyObject = dynamic_cast<IPropertyValue^>(object);
+        if (propertyObject != nullptr)
+        {
+            WriteProperty(writer, propertyObject);
+            return;
+        }
+
+        auto mapObject = dynamic_cast<IMap<String^, Object^>^>(object);
+        if (mapObject != nullptr)
+        {
+            WriteStringToObjectMap(writer, mapObject);
+            return;
+        }
+
+        throw ref new InvalidArgumentException("Unsupported data type");
+    }
+
+    String^ ReadString(DataReader^ reader)
+    {
+        int length = reader->ReadUInt32();
+        String^ string = reader->ReadString(length);
+        return string;
+    }
+
+    IMap<String^, Object^>^ ReadStringToObjectMap(DataReader^ reader)
+    {
+        auto map = ref new Map<String^, Object^>();
+        auto size = reader->ReadUInt32();
+        for (unsigned int index = 0; index < size; index++)
+        {
+            auto key = safe_cast<String^>(ReadObject(reader));
+            auto value = ReadObject(reader);
+            map->Insert(key, value);
+        }
+        if (reader->ReadByte() != MapEndMarker)
+        {
+            throw ref new InvalidArgumentException("Invalid stream");
+        }
+        return map;
+    }
+
+    Object^ ReadObject(DataReader^ reader)
+    {
+        auto type = reader->ReadByte();
+        switch (type)
+        {
+        case NullPtrType:
+            return nullptr;
+        case UInt8Type:
+            return reader->ReadByte();
+        case UInt16Type:
+            return reader->ReadUInt16();
+        case UInt32Type:
+            return reader->ReadUInt32();
+        case UInt64Type:
+            return reader->ReadUInt64();
+        case Int16Type:
+            return reader->ReadInt16();
+        case Int32Type:
+            return reader->ReadInt32();
+        case Int64Type:
+            return reader->ReadInt64();
+        case SingleType:
+            return reader->ReadSingle();
+        case DoubleType:
+            return reader->ReadDouble();
+        case BooleanType:
+            return reader->ReadBoolean();
+        case Char16Type:
+            return (char16_t)reader->ReadUInt16();
+        case GuidType:
+            return reader->ReadGuid();
+        case StringType:
+            return ReadString(reader);
+        case StringToObjectMapType:
+            return ReadStringToObjectMap(reader);
+        default:
+            throw ref new InvalidArgumentException("Unsupported property type");
+        }
+    }
+}
+
+#pragma endregion
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/suspensionmanager.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/suspensionmanager.h
new file mode 100644
index 00000000..65e1180a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/common/suspensionmanager.h
@@ -0,0 +1,50 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+//
+// SuspensionManager.h
+// Declaration of the SuspensionManager class
+//
+
+#pragma once
+
+#include <ppltasks.h>
+
+namespace SDKSample
+{
+    namespace Common
+    {
+        /// <summary>
+        /// SuspensionManager captures global session state to simplify process lifetime management
+        /// for an application.  Note that session state will be automatically cleared under a variety
+        /// of conditions and should only be used to store information that would be convenient to
+        /// carry across sessions, but that should be disacarded when an application crashes or is
+        /// upgraded.
+        /// </summary>
+        ref class SuspensionManager sealed
+        {
+        internal:
+            static void RegisterFrame(Windows::UI::Xaml::Controls::Frame^ frame, Platform::String^ sessionStateKey);
+            static void UnregisterFrame(Windows::UI::Xaml::Controls::Frame^ frame);
+            static Concurrency::task<void> SaveAsync(void);
+            static Concurrency::task<void> RestoreAsync(void);
+            static property Windows::Foundation::Collections::IMap<Platform::String^, Platform::Object^>^ SessionState
+            {
+                Windows::Foundation::Collections::IMap<Platform::String^, Platform::Object^>^ get(void);
+            };
+            static Windows::Foundation::Collections::IMap<Platform::String^, Platform::Object^>^ SessionStateForFrame(
+                Windows::UI::Xaml::Controls::Frame^ frame);
+
+        private:
+            static void RestoreFrameNavigationState(Windows::UI::Xaml::Controls::Frame^ frame);
+            static void SaveFrameNavigationState(Windows::UI::Xaml::Controls::Frame^ frame);
+        };
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/opencv.props b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/opencv.props
new file mode 100644
index 00000000..12821502
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/opencv.props
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros">
+    <OpenCV_Bin>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\bin\</OpenCV_Bin>
+    <OpenCV_Lib>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\lib\</OpenCV_Lib>
+    <OpenCV_Include>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\include\</OpenCV_Include>
+    <!--debug suffix for OpenCV dlls and libs -->
+    <DebugSuffix Condition="'$(Configuration)'=='Debug'">d</DebugSuffix>
+    <DebugSuffix Condition="'$(Configuration)'!='Debug'"></DebugSuffix>
+  </PropertyGroup>
+  <ItemGroup>
+    <!--Add required OpenCV dlls here-->
+    <None Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+  </ItemGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(OpenCV_Include);$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <!--Add required OpenCV libs here-->
+      <AdditionalDependencies>opencv_core300$(DebugSuffix).lib;opencv_imgproc300$(DebugSuffix).lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OpenCV_Lib);%(AdditionalLibraryDirectories);</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/pch.cpp b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/pch.cpp
new file mode 100644
index 00000000..97389d94
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/pch.cpp
@@ -0,0 +1,16 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+//
+// pch.cpp
+// Include the standard header and generate the precompiled header.
+//
+
+#include "pch.h"
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/pch.h b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/pch.h
new file mode 100644
index 00000000..13f9bc34
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/pch.h
@@ -0,0 +1,23 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+//
+// pch.h
+// Header for standard system include files.
+//
+
+#pragma once
+
+#include <collection.h>
+#include <ppltasks.h>
+#include <agile.h>
+#include "Common\LayoutAwarePage.h"
+#include "Common\SuspensionManager.h"
+#include "App.xaml.h"
diff --git a/C++/opencv-4.7.0/samples/winrt/ImageManipulations/sample-utils/SampleTemplateStyles.xaml b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/sample-utils/SampleTemplateStyles.xaml
new file mode 100644
index 00000000..cddb2640
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/ImageManipulations/sample-utils/SampleTemplateStyles.xaml
@@ -0,0 +1,51 @@
+<!--
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+-->
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <Style x:Key="TitleTextStyle" TargetType="TextBlock">
+        <Setter Property="FontFamily" Value="Segoe UI Light" />
+        <Setter Property="FontSize" Value="16" />
+    </Style>
+    <Style x:Key="HeaderTextStyle" TargetType="TextBlock">
+        <Setter Property="FontFamily" Value="Segoe UI Semilight" />
+        <Setter Property="FontSize" Value="26.667" />
+        <Setter Property="Margin" Value="0,0,0,25" />
+    </Style>
+    <Style x:Key="H2Style" TargetType="TextBlock">
+        <Setter Property="FontFamily" Value="Segoe UI" />
+        <Setter Property="FontSize" Value="14.667" />
+        <Setter Property="Margin" Value="0,0,0,0" />
+    </Style>
+    <Style x:Key="SubheaderTextStyle" TargetType="TextBlock">
+        <Setter Property="FontFamily" Value="Segoe UI Semilight" />
+        <Setter Property="FontSize" Value="14.667" />
+        <Setter Property="Margin" Value="0,0,0,5" />
+    </Style>
+    <Style x:Key="BasicTextStyle" TargetType="TextBlock">
+        <Setter Property="FontFamily" Value="Segoe UI Light" />
+        <Setter Property="FontSize" Value="16" />
+    </Style>
+    <Style x:Key="SeparatorStyle" TargetType="TextBlock">
+        <Setter Property="FontFamily" Value="Segoe UI" />
+        <Setter Property="FontSize" Value="9" />
+    </Style>
+    <Style x:Key="FooterStyle" TargetType="TextBlock">
+        <Setter Property="FontFamily" Value="Segoe UI" />
+        <Setter Property="FontSize" Value="12" />
+        <Setter Property="Margin" Value="0,8,0,0" />
+    </Style>
+    <Style x:Key="HyperlinkStyle" TargetType="HyperlinkButton">
+        <Setter Property="Padding" Value="5"/>
+    </Style>
+</ResourceDictionary>
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/MediaCaptureJavaScript.jsproj b/C++/opencv-4.7.0/samples/winrt/JavaScript/MediaCaptureJavaScript.jsproj
new file mode 100644
index 00000000..550ec83d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/MediaCaptureJavaScript.jsproj
@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|AnyCPU">
+      <Configuration>Debug</Configuration>
+      <Platform>AnyCPU</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x86">
+      <Configuration>Debug</Configuration>
+      <Platform>x86</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|AnyCPU">
+      <Configuration>Release</Configuration>
+      <Platform>AnyCPU</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x86">
+      <Configuration>Release</Configuration>
+      <Platform>x86</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>d70a3790-48ce-4e58-af60-ebefc22e9c7a</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup Condition="'$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '12.0'">
+    <VisualStudioVersion>12.0</VisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\$(WMSJSProjectDirectory)\Microsoft.VisualStudio.$(WMSJSProject).Default.props" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\$(WMSJSProjectDirectory)\Microsoft.VisualStudio.$(WMSJSProject).props" />
+  <PropertyGroup>
+    <TargetPlatformIdentifier>Windows</TargetPlatformIdentifier>
+    <TargetPlatformVersion>8.1</TargetPlatformVersion>
+    <RequiredPlatformVersion>8.1</RequiredPlatformVersion>
+    <MinimumVisualStudioVersion>$(VersionNumberMajor).$(VersionNumberMinor)</MinimumVisualStudioVersion>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <PackageCertificateKeyFile>MediaCaptureJavaScript_TemporaryKey.pfx</PackageCertificateKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <AppxManifest Include="package.appxmanifest">
+      <SubType>Designer</SubType>
+    </AppxManifest>
+    <Content Include="default.html" />
+    <Content Include="html\AdvancedCapture.html" />
+    <Content Include="images\logo.scale-100.png" />
+    <Content Include="images\microsoft-sdk.png" />
+    <Content Include="images\smalllogo.scale-100.png" />
+    <Content Include="images\smallTile-sdk.png" />
+    <Content Include="images\splash-sdk.png" />
+    <Content Include="images\splashscreen.scale-100.png" />
+    <Content Include="images\squareTile-sdk.png" />
+    <Content Include="images\storeLogo-sdk.png" />
+    <Content Include="images\storelogo.scale-100.png" />
+    <Content Include="images\tile-sdk.png" />
+    <Content Include="images\windows-sdk.png" />
+    <Content Include="js\AdvancedCapture.js" />
+    <Content Include="js\default.js" />
+    <Content Include="css\default.css" />
+    <Content Include="sample-utils\sample-utils.css" />
+    <Content Include="sample-utils\sample-utils.js" />
+    <Content Include="sample-utils\scenario-select.html" />
+    <None Include="MediaCaptureJavaScript_TemporaryKey.pfx" />
+  </ItemGroup>
+  <ItemGroup>
+    <SDKReference Include="Microsoft.WinJS.2.0, Version=1.0" />
+  </ItemGroup>
+  <PropertyGroup Label="UserMacros">
+    <OpenCV_Bin>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\bin\</OpenCV_Bin>
+    <OpenCV_Lib>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\lib\</OpenCV_Lib>
+    <OpenCV_Include>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\include\</OpenCV_Include>
+    <!--debug suffix for OpenCV dlls and libs -->
+    <DebugSuffix Condition="'$(Configuration)'=='Debug'">d</DebugSuffix>
+    <DebugSuffix Condition="'$(Configuration)'!='Debug'">
+    </DebugSuffix>
+  </PropertyGroup>
+  <ItemGroup>
+    <!--Add required OpenCV dlls here-->
+    <Content Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ImageManipulations\MediaExtensions\OcvTransform\OcvTransform.vcxproj" />
+  </ItemGroup>
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\$(WMSJSProjectDirectory)\Microsoft.VisualStudio.$(WMSJSProject).targets" />
+  <!-- To modify your build process, add your task inside one of the targets below then uncomment
+       that target and the DisableFastUpToDateCheck PropertyGroup.
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  <PropertyGroup>
+    <DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
+  </PropertyGroup>
+  -->
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/MediaCaptureJavaScript.sln b/C++/opencv-4.7.0/samples/winrt/JavaScript/MediaCaptureJavaScript.sln
new file mode 100644
index 00000000..cb5c347f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/MediaCaptureJavaScript.sln
@@ -0,0 +1,84 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OcvTransform", "..\ImageManipulations\MediaExtensions\OcvTransform\OcvTransform.vcxproj", "{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}"
+EndProject
+Project("{262852C6-CD72-467D-83FE-5EEB1973A190}") = "MediaCaptureJavaScript", "MediaCaptureJavaScript.jsproj", "{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|ARM = Debug|ARM
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|Any CPU = Release|Any CPU
+		Release|ARM = Release|ARM
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|ARM.ActiveCfg = Debug|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|ARM.Build.0 = Debug|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|ARM.Deploy.0 = Debug|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|Win32.Build.0 = Debug|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|Win32.Deploy.0 = Debug|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|x64.ActiveCfg = Debug|x64
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|x64.Build.0 = Debug|x64
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Debug|x64.Deploy.0 = Debug|x64
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|Any CPU.ActiveCfg = Release|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|ARM.ActiveCfg = Release|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|ARM.Build.0 = Release|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|ARM.Deploy.0 = Release|ARM
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|Win32.ActiveCfg = Release|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|Win32.Build.0 = Release|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|Win32.Deploy.0 = Release|Win32
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|x64.ActiveCfg = Release|x64
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|x64.Build.0 = Release|x64
+		{C5B886A7-8300-46FF-B533-9613DE2AF637}.Release|x64.Deploy.0 = Release|x64
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|ARM.ActiveCfg = Debug|ARM
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|ARM.Build.0 = Debug|ARM
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|Win32.ActiveCfg = Debug|Win32
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|Win32.Build.0 = Debug|Win32
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|x64.ActiveCfg = Debug|x64
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Debug|x64.Build.0 = Debug|x64
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|Any CPU.ActiveCfg = Release|Win32
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|ARM.ActiveCfg = Release|ARM
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|ARM.Build.0 = Release|ARM
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|Win32.ActiveCfg = Release|Win32
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|Win32.Build.0 = Release|Win32
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|x64.ActiveCfg = Release|x64
+		{BA69218F-DA5C-4D14-A78D-21A9E4DEC669}.Release|x64.Build.0 = Release|x64
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|ARM.ActiveCfg = Debug|ARM
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|ARM.Build.0 = Debug|ARM
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|ARM.Deploy.0 = Debug|ARM
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|Win32.ActiveCfg = Debug|x86
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|Win32.Build.0 = Debug|x86
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|Win32.Deploy.0 = Debug|x86
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|x64.ActiveCfg = Debug|x64
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|x64.Build.0 = Debug|x64
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Debug|x64.Deploy.0 = Debug|x64
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|Any CPU.Deploy.0 = Release|Any CPU
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|ARM.ActiveCfg = Release|ARM
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|ARM.Build.0 = Release|ARM
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|ARM.Deploy.0 = Release|ARM
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|Win32.ActiveCfg = Release|x86
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|Win32.Build.0 = Release|x86
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|Win32.Deploy.0 = Release|x86
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|x64.ActiveCfg = Release|x64
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|x64.Build.0 = Release|x64
+		{D70A3790-48CE-4E58-AF60-EBEFC22E9C7A}.Release|x64.Deploy.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/MediaCaptureJavaScript_TemporaryKey.pfx b/C++/opencv-4.7.0/samples/winrt/JavaScript/MediaCaptureJavaScript_TemporaryKey.pfx
new file mode 100644
index 00000000..242376d0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/MediaCaptureJavaScript_TemporaryKey.pfx differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/css/default.css b/C++/opencv-4.7.0/samples/winrt/JavaScript/css/default.css
new file mode 100644
index 00000000..e47ef402
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/css/default.css
@@ -0,0 +1,6 @@
+/* styles */
+
+#featureLabel
+{
+    padding-top: 50px;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/default.html b/C++/opencv-4.7.0/samples/winrt/JavaScript/default.html
new file mode 100644
index 00000000..b229ddaf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/default.html
@@ -0,0 +1,31 @@
+<!-- Copyright (c) Microsoft Corporation. All rights reserved. -->
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8" />
+    <title>OpenCV for Windows RT</title>
+
+    <!-- WinJS references -->
+    <link rel="stylesheet" href="//Microsoft.WinJS.2.0/css/ui-light.css" />
+    <script src="//Microsoft.WinJS.2.0/js/base.js"></script>
+    <script src="//Microsoft.WinJS.2.0/js/ui.js"></script>
+
+    <!-- SDK sample framework references -->
+    <link rel="stylesheet" href="/sample-utils/sample-utils.css" />
+    <link rel="stylesheet" href="/css/default.css" />
+    <script src="/sample-utils/sample-utils.js"></script>
+    <script src="/js/default.js"></script>
+</head>
+<body role="application">
+    <div id="rootGrid">
+        <div id="content">
+            <h4>
+                <img src="images/windows-sdk.png"  />
+                <span>OpenCV for Windows RT</span>
+            </h4>
+            <h1 id="featureLabel"></h1>
+            <div id="contentHost"></div>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/html/AdvancedCapture.html b/C++/opencv-4.7.0/samples/winrt/JavaScript/html/AdvancedCapture.html
new file mode 100644
index 00000000..45239929
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/html/AdvancedCapture.html
@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+    <title></title>
+    <link rel="stylesheet" href="/css/default.css" />
+    <script src="/js/AdvancedCapture.js"></script>
+</head>
+<body>
+    <div data-win-control="SdkSample.ScenarioInput">
+        <p>
+            This scenario shows how to enumerate cameras in the system.
+            Choose a camera from the list to start previewing from that camera. You can add additional effect
+            using the dropdown provided.
+        </p>
+        <select id="cameraSelect" aria-labelledby="listLabel"></select>
+        <button id="btnStartDevice" disabled="disabled">Start Device</button>
+        <button id="btnStartPreview" disabled="disabled">Start Preview</button>
+        <select id="videoEffect" disabled="disabled">
+            <option>Preview</option>
+            <option>Grayscale</option>
+            <option>Canny</option>
+            <option>Sobel</option>
+            <option>Histogram</option>
+        </select>
+    </div>
+    <div data-win-control="SdkSample.ScenarioOutput">
+        <table>
+            <tr>
+                <td>Preview</td>
+            </tr>
+            <tr>
+                <td>
+                    <video width="320" height="240" id="previewVideo" style="border: 1px solid black">
+                    </video>
+                </td>
+            </tr>
+        </table>
+    </div>
+</body>
+</html>
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/logo.scale-100.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/logo.scale-100.png
new file mode 100644
index 00000000..8f447ad3
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/logo.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/microsoft-sdk.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/microsoft-sdk.png
new file mode 100644
index 00000000..380a0102
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/microsoft-sdk.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/smallTile-sdk.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/smallTile-sdk.png
new file mode 100644
index 00000000..5546e8b2
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/smallTile-sdk.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/smalllogo.scale-100.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/smalllogo.scale-100.png
new file mode 100644
index 00000000..f2d18773
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/smalllogo.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/splash-sdk.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/splash-sdk.png
new file mode 100644
index 00000000..901c3b08
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/splash-sdk.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/splashscreen.scale-100.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/splashscreen.scale-100.png
new file mode 100644
index 00000000..c951e031
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/splashscreen.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/squareTile-sdk.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/squareTile-sdk.png
new file mode 100644
index 00000000..126cf70d
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/squareTile-sdk.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/storeLogo-sdk.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/storeLogo-sdk.png
new file mode 100644
index 00000000..2133f177
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/storeLogo-sdk.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/storelogo.scale-100.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/storelogo.scale-100.png
new file mode 100644
index 00000000..dcb67271
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/storelogo.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/tile-sdk.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/tile-sdk.png
new file mode 100644
index 00000000..cdec0dbd
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/tile-sdk.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/images/windows-sdk.png b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/windows-sdk.png
new file mode 100644
index 00000000..0fb23ff2
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/JavaScript/images/windows-sdk.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/js/AdvancedCapture.js b/C++/opencv-4.7.0/samples/winrt/JavaScript/js/AdvancedCapture.js
new file mode 100644
index 00000000..211e1cd3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/js/AdvancedCapture.js
@@ -0,0 +1,161 @@
+//// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+//// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+//// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+//// PARTICULAR PURPOSE.
+////
+//// Copyright (c) Microsoft Corporation. All rights reserved
+
+(function () {
+    "use strict";
+
+    var cameraList = null;
+    var mediaCaptureMgr = null;
+    var captureInitSettings = null;
+
+    var page = WinJS.UI.Pages.define("/html/AdvancedCapture.html", {
+
+        ready: function (element, options) {
+            scenarioInitialize();
+        },
+
+        unload: function (element, options) {
+            // release resources
+            releaseMediaCapture();
+        }
+    });
+
+    function scenarioInitialize() {
+        // Initialize the UI elements
+        id("btnStartDevice").disabled = false;
+        id("btnStartDevice").addEventListener("click", startDevice, false);
+        id("btnStartPreview").disabled = true;
+        id("videoEffect").disabled = true;
+        id("btnStartPreview").addEventListener("click", startPreview, false);
+        id("cameraSelect").addEventListener("change", onDeviceChange, false);
+
+        id("videoEffect").addEventListener('change', addEffectToImageStream, false);
+
+        enumerateCameras();
+    }
+
+    function initCameraSettings() {
+        captureInitSettings = new Windows.Media.Capture.MediaCaptureInitializationSettings();
+        captureInitSettings.streamingCaptureMode = Windows.Media.Capture.StreamingCaptureMode.video
+
+        // If the user chose another capture device, use it by default
+        var selectedIndex = id("cameraSelect").selectedIndex;
+        var deviceInfo = cameraList[selectedIndex];
+        captureInitSettings.videoDeviceId = deviceInfo.id;
+    }
+
+    // this function takes care of releasing the resources associated with media capturing
+    function releaseMediaCapture() {
+        if (mediaCaptureMgr) {
+            mediaCaptureMgr.close();
+            mediaCaptureMgr = null;
+        }
+    }
+
+    //Initialize media capture with the current settings
+    function startDevice() {
+        displayStatus("Starting device");
+        releaseMediaCapture();
+        initCameraSettings();
+
+        mediaCaptureMgr = new Windows.Media.Capture.MediaCapture();
+        mediaCaptureMgr.initializeAsync(captureInitSettings).done(function (result) {
+            // Update the UI
+            id("btnStartPreview").disabled = false;
+            id("btnStartDevice").disabled = true;
+            displayStatus("Device started");
+        });
+    }
+
+    function startPreview() {
+        displayStatus("Starting preview");
+        id("btnStartPreview").disabled = true;
+        id("videoEffect").disabled = false;
+        var video = id("previewVideo");
+        video.src = URL.createObjectURL(mediaCaptureMgr, { oneTimeOnly: true });
+        video.play();
+        displayStatus("Preview started");
+    }
+
+    function addEffectToImageStream() {
+        var effectId = id("videoEffect").selectedIndex;
+        var props = new Windows.Foundation.Collections.PropertySet();
+        props.insert("{698649BE-8EAE-4551-A4CB-3EC98FBD3D86}", effectId);
+
+        mediaCaptureMgr.clearEffectsAsync(Windows.Media.Capture.MediaStreamType.videoPreview).then(function () {
+            return mediaCaptureMgr.addEffectAsync(Windows.Media.Capture.MediaStreamType.videoPreview, 'OcvTransform.OcvImageManipulations', props);
+        }).then(function () {
+            displayStatus('Effect has been successfully added');
+        }, errorHandler);
+    }
+
+    function enumerateCameras() {
+        displayStatus("Enumerating capture devices");
+        var cameraSelect = id("cameraSelect");
+        cameraList = null;
+        cameraList = new Array();
+
+        // Clear the previous list of capture devices if any
+        while (cameraSelect.length > 0) {
+            cameraSelect.remove(0);
+        }
+
+        // Enumerate cameras and add them to the list
+        var deviceInfo = Windows.Devices.Enumeration.DeviceInformation;
+        deviceInfo.findAllAsync(Windows.Devices.Enumeration.DeviceClass.videoCapture).done(function (cameras) {
+            if (cameras.length === 0) {
+                cameraSelect.disabled = true;
+                displayError("No camera was found");
+                id("btnStartDevice").disabled = true;
+                cameraSelect.add(new Option("No cameras available"));
+            } else {
+                cameras.forEach(function (camera) {
+                    cameraList.push(camera);
+                    cameraSelect.add(new Option(camera.name));
+                });
+            }
+        }, errorHandler);
+    }
+
+    function onDeviceChange() {
+        releaseMediaCapture();
+        id("btnStartDevice").disabled = false;
+        id("btnStartPreview").disabled = true;
+        id("videoEffect").disabled = true;
+        displayStatus("");
+    }
+
+    function suspendingHandler(suspendArg) {
+        displayStatus("Suspended");
+        releaseMediaCapture();
+    }
+
+    function resumingHandler(resumeArg) {
+        displayStatus("Resumed");
+        scenarioInitialize();
+    }
+
+    function errorHandler(err) {
+        displayError(err.message);
+    }
+
+    function failedEventHandler(e) {
+        displayError("Fatal error", e.message);
+    }
+
+    function displayStatus(statusText) {
+        SdkSample.displayStatus(statusText);
+    }
+
+    function displayError(error) {
+        SdkSample.displayError(error);
+    }
+
+    function id(elementId) {
+        return document.getElementById(elementId);
+    }
+})();
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/js/default.js b/C++/opencv-4.7.0/samples/winrt/JavaScript/js/default.js
new file mode 100644
index 00000000..4aa17a3d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/js/default.js
@@ -0,0 +1,74 @@
+//// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+//// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+//// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+//// PARTICULAR PURPOSE.
+////
+//// Copyright (c) Microsoft Corporation. All rights reserved
+
+
+(function () {
+    "use strict";
+
+    var sampleTitle = "OpenCV Image Manipulations sample";
+
+    var scenarios = [
+        { url: "/html/AdvancedCapture.html", title: "Enumerate cameras and add a video effect" },
+    ];
+
+    function activated(eventObject) {
+        if (eventObject.detail.kind === Windows.ApplicationModel.Activation.ActivationKind.launch) {
+            // Use setPromise to indicate to the system that the splash screen must not be torn down
+            // until after processAll and navigate complete asynchronously.
+            eventObject.setPromise(WinJS.UI.processAll().then(function () {
+                // Navigate to either the first scenario or to the last running scenario
+                // before suspension or termination.
+                var url = WinJS.Application.sessionState.lastUrl || scenarios[0].url;
+                return WinJS.Navigation.navigate(url);
+            }));
+        }
+    }
+
+    WinJS.Navigation.addEventListener("navigated", function (eventObject) {
+        var url = eventObject.detail.location;
+        var host = document.getElementById("contentHost");
+        // Call unload method on current scenario, if there is one
+        host.winControl && host.winControl.unload && host.winControl.unload();
+        WinJS.Utilities.empty(host);
+        eventObject.detail.setPromise(WinJS.UI.Pages.render(url, host, eventObject.detail.state).then(function () {
+            WinJS.Application.sessionState.lastUrl = url;
+        }));
+    });
+
+    WinJS.Namespace.define("SdkSample", {
+        sampleTitle: sampleTitle,
+        scenarios: scenarios,
+        mediaCaptureMgr: null,
+        photoFile: "photo.jpg",
+        deviceList: null,
+        recordState: null,
+        captureInitSettings: null,
+        encodingProfile: null,
+        storageFile: null,
+        photoStorage: null,
+        cameraControlSliders: null,
+
+
+        displayStatus: function (statusText) {
+            WinJS.log && WinJS.log(statusText, "MediaCapture", "status");
+        },
+
+        displayError: function (error) {
+            WinJS.log && WinJS.log(error, "MediaCapture", "error");
+        },
+
+        id: function (elementId) {
+            return document.getElementById(elementId);
+        },
+
+    });
+
+    WinJS.Application.addEventListener("activated", activated, false);
+    WinJS.Application.start();
+    Windows.UI.WebUI.WebUIApplication.addEventListener("suspending", SdkSample.suspendingHandler, false);
+    Windows.UI.WebUI.WebUIApplication.addEventListener("resuming", SdkSample.resumingHandler, false);
+})();
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/package.appxmanifest b/C++/opencv-4.7.0/samples/winrt/JavaScript/package.appxmanifest
new file mode 100644
index 00000000..aa4526c2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/package.appxmanifest
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest" xmlns:m2="http://schemas.microsoft.com/appx/2013/manifest">
+  <Identity Name="d70a3790-48ce-4e58-af60-ebefc22e9c7a" Version="1.0.0.0" Publisher="CN=Sergei" />
+  <Properties>
+    <DisplayName>MediaCaptureJavaScript</DisplayName>
+    <PublisherDisplayName>Sergei</PublisherDisplayName>
+    <Logo>images\storelogo.png</Logo>
+  </Properties>
+  <Prerequisites>
+    <OSMinVersion>6.3.0</OSMinVersion>
+    <OSMaxVersionTested>6.3.0</OSMaxVersionTested>
+  </Prerequisites>
+  <Resources>
+    <Resource Language="x-generate" />
+  </Resources>
+  <Applications>
+    <Application Id="App" StartPage="default.html">
+      <m2:VisualElements DisplayName="MediaCaptureJavaScript" Description="MediaCaptureJavaScript" ForegroundText="light" BackgroundColor="#464646" Square150x150Logo="images\Logo.png" Square30x30Logo="images\SmallLogo.png">
+        <m2:SplashScreen Image="images\splashscreen.png" />
+      </m2:VisualElements>
+    </Application>
+  </Applications>
+  <Capabilities>
+    <Capability Name="internetClient" />
+    <DeviceCapability Name="webcam" />
+  </Capabilities>
+  <Extensions>
+    <Extension Category="windows.activatableClass.inProcessServer">
+      <InProcessServer>
+        <Path>OcvTransform.dll</Path>
+        <ActivatableClass ActivatableClassId="OcvTransform.OcvImageManipulations" ThreadingModel="both" />
+      </InProcessServer>
+    </Extension>
+  </Extensions>
+</Package>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/sample-utils/sample-utils.css b/C++/opencv-4.7.0/samples/winrt/JavaScript/sample-utils/sample-utils.css
new file mode 100644
index 00000000..d209fafb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/sample-utils/sample-utils.css
@@ -0,0 +1,213 @@
+/* Copyright (c) Microsoft Corporation. All rights reserved. */
+html
+{
+    cursor: default;
+}
+
+#featureLabel
+{
+    font: 20pt/24pt "Segoe UI Semilight";
+    margin:0;
+    padding:5px 0 10px 0;
+    font-weight: normal;
+}
+
+#inputLabel, #outputLabel
+{
+    font: 11pt/15pt "Segoe UI";
+    margin:0;
+    padding:0;
+    font-weight: normal;
+}
+
+#listLabel, #descLabel
+{
+    font: 11pt/15pt "Segoe UI Semilight";
+    font-weight:normal;
+}
+
+#rootGrid
+{
+    width: 100%;
+    height: 100%;
+    display: -ms-grid;
+    -ms-grid-columns: 100px 1fr 100px;
+    -ms-grid-rows: 20px auto 1fr auto 20px;
+}
+
+#header
+{
+    -ms-grid-column: 2;
+    -ms-grid-row: 2;
+}
+
+#content
+{
+    padding-right:20px;
+    padding-bottom:20px;
+    overflow:auto;
+    display:-ms-grid;
+    -ms-grid-columns:1fr;
+    -ms-grid-rows: auto 1fr;
+    -ms-grid-column: 2;
+    -ms-grid-row: 3;
+}
+
+#footer
+{
+    -ms-grid-column: 2;
+    -ms-grid-row: 4;
+    padding-bottom:10px;
+}
+
+#featureLabel
+{
+    -ms-grid-row: 1;
+}
+
+#contentHost
+{
+    display:-ms-grid;
+    -ms-grid-columns:1fr;
+    -ms-grid-rows: auto auto auto 1fr;
+    -ms-grid-row: 2;
+}
+
+#inputLabel
+{
+    -ms-grid-row: 1;
+}
+
+
+#input
+{
+    -ms-grid-row: 2;
+    display: -ms-grid;
+    -ms-grid-columns: auto auto;
+    -ms-grid-rows: auto;
+    margin-top:10px;
+}
+
+#outputLabel
+{
+    -ms-grid-row: 3;
+    padding-top:10px;
+    padding-bottom:10px;
+}
+
+#output
+{
+    height:100%;
+    -ms-grid-row: 4;
+    -ms-grid-row-align:stretch;
+}
+
+.clear
+{
+    clear:both;
+}
+
+
+#footer span
+{
+    font-size:12px;
+}
+
+#footer .company
+{
+    float:left;
+}
+
+#footer .links
+{
+    float:right;
+}
+
+#footer .links a
+{
+    font-size:12px;
+    margin-left:8px;
+    text-decoration:none;
+}
+
+#footer .links .pipe
+{
+    font-size:9px;
+    margin-left:8px;
+}
+
+#statusMessage
+{
+    margin-bottom:5px;
+}
+
+#input .options
+{
+    -ms-grid-row: 1;
+    -ms-grid-column: 1;
+}
+
+#input .details
+{
+    -ms-grid-row: 1;
+    -ms-grid-column: 2;
+    cursor:text;
+}
+
+.imageHolder
+{
+    max-width:382px;
+}
+
+.imageHolder.withText
+{
+     float:left;
+     margin-right:10px;
+}
+
+#scenarios
+{
+    margin-right:20px;
+}
+
+
+
+@media screen and (min-width: 800px) and (max-width: 1024px)
+{
+    #rootGrid
+    {
+        -ms-grid-columns: 40px 1fr 40px;
+    }
+}
+
+@media screen and (max-width: 799px)
+{
+    #rootGrid
+    {
+        -ms-grid-columns: 20px 1fr 20px;
+    }
+
+    #output
+    {
+        padding-bottom:20px;
+    }
+
+    #input
+    {
+        -ms-grid-columns: auto;
+        -ms-grid-rows: auto auto;
+    }
+
+    #input .options
+    {
+        -ms-grid-row: 1;
+        -ms-grid-column: 1;
+        margin-bottom:10px;
+    }
+
+    #input .details
+    {
+        -ms-grid-row: 2;
+        -ms-grid-column: 1;
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/sample-utils/sample-utils.js b/C++/opencv-4.7.0/samples/winrt/JavaScript/sample-utils/sample-utils.js
new file mode 100644
index 00000000..ad2834d8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/sample-utils/sample-utils.js
@@ -0,0 +1,204 @@
+//// Copyright (c) Microsoft Corporation. All rights reserved
+
+// This file is a part of the SDK sample framework. For code demonstrating scenarios in this particular sample,
+// please see the html, css and js folders.
+
+(function () {
+
+    //
+    // Helper controls used in the sample pages
+    //
+
+    // The ScenarioInput control inserts the appropriate markup to get labels & controls
+    // hooked into the input section of a scenario page so that it's not repeated in
+    // every one.
+
+    var lastError = "";
+    var lastStatus = "";
+    var ScenarioInput = WinJS.Class.define(
+        function (element, options) {
+        element.winControl = this;
+        this.element = element;
+
+        new WinJS.Utilities.QueryCollection(element)
+                    .setAttribute("role", "main")
+                    .setAttribute("aria-labelledby", "inputLabel");
+        element.id = "input";
+
+        this.addInputLabel(element);
+        this.addDetailsElement(element);
+        this.addScenariosPicker(element);
+    }, {
+        addInputLabel: function (element) {
+            var label = document.createElement("h2");
+            label.textContent = "Input";
+            label.id = "inputLabel";
+            element.parentNode.insertBefore(label, element);
+        },
+        addScenariosPicker: function (parentElement) {
+            var scenarios = document.createElement("div");
+            scenarios.id = "scenarios";
+            var control = new ScenarioSelect(scenarios);
+
+            parentElement.insertBefore(scenarios, parentElement.childNodes[0]);
+        },
+
+        addDetailsElement: function (sourceElement) {
+            var detailsDiv = this._createDetailsDiv();
+            while (sourceElement.childNodes.length > 0) {
+                detailsDiv.appendChild(sourceElement.removeChild(sourceElement.childNodes[0]));
+            }
+            sourceElement.appendChild(detailsDiv);
+        },
+        _createDetailsDiv: function () {
+            var detailsDiv = document.createElement("div");
+
+            new WinJS.Utilities.QueryCollection(detailsDiv)
+                        .addClass("details")
+                        .setAttribute("role", "region")
+                        .setAttribute("aria-labelledby", "descLabel")
+                        .setAttribute("aria-live", "assertive");
+
+            var label = document.createElement("h3");
+            label.textContent = "Description";
+            label.id = "descLabel";
+
+            detailsDiv.appendChild(label);
+            return detailsDiv;
+        },
+    }
+    );
+
+    // The ScenarioOutput control inserts the appropriate markup to get labels & controls
+    // hooked into the output section of a scenario page so that it's not repeated in
+    // every one.
+
+    var ScenarioOutput = WinJS.Class.define(
+        function (element, options) {
+        element.winControl = this;
+        this.element = element;
+        new WinJS.Utilities.QueryCollection(element)
+                    .setAttribute("role", "region")
+                    .setAttribute("aria-labelledby", "outputLabel")
+                    .setAttribute("aria-live", "assertive");
+        element.id = "output";
+
+        this._addOutputLabel(element);
+        this._addStatusOutput(element);
+    }, {
+        _addOutputLabel: function (element) {
+            var label = document.createElement("h2");
+            label.id = "outputLabel";
+            label.textContent = "Output";
+            element.parentNode.insertBefore(label, element);
+        },
+        _addStatusOutput: function (element) {
+            var statusDiv = document.createElement("div");
+            statusDiv.id = "statusMessage";
+            statusDiv.setAttribute("role", "textbox");
+            element.insertBefore(statusDiv, element.childNodes[0]);
+        }
+    }
+    );
+
+
+    // Sample infrastructure internals
+
+    var currentScenarioUrl = null;
+
+    WinJS.Navigation.addEventListener("navigating", function (evt) {
+        currentScenarioUrl = evt.detail.location;
+    });
+
+    WinJS.log = function (message, tag, type) {
+        var isError = (type === "error");
+        var isStatus = (type === "status");
+
+        if (isError || isStatus) {
+            var statusDiv = /* @type(HTMLElement) */ document.getElementById("statusMessage");
+            if (statusDiv) {
+                statusDiv.innerText = message;
+                if (isError) {
+                    lastError = message;
+                    statusDiv.style.color = "blue";
+                } else if (isStatus) {
+                    lastStatus = message;
+                    statusDiv.style.color = "green";
+                }
+            }
+        }
+    };
+
+    // Control that populates and runs the scenario selector
+
+    var ScenarioSelect = WinJS.UI.Pages.define("/sample-utils/scenario-select.html", {
+        ready: function (element, options) {
+            var that = this;
+            var selectElement = WinJS.Utilities.query("#scenarioSelect", element);
+            this._selectElement = selectElement[0];
+
+            SdkSample.scenarios.forEach(function (s, index) {
+                that._addScenario(index, s);
+            });
+
+            selectElement.listen("change", function (evt) {
+                var select = evt.target;
+                if (select.selectedIndex >= 0) {
+                    var newUrl = select.options[select.selectedIndex].value;
+                    WinJS.Navigation.navigate(newUrl);
+                }
+            });
+            selectElement[0].size = (SdkSample.scenarios.length > 5 ? 5 : SdkSample.scenarios.length);
+            if (SdkSample.scenarios.length === 1) {
+                // Avoid showing down arrow when there is only one scenario
+                selectElement[0].setAttribute("multiple", "multiple");
+            }
+
+            // Use setImmediate to ensure that the select element is set as active only after
+            // the scenario page has been constructed.
+            setImmediate(function () {
+                that._selectElement.setActive();
+            });
+        },
+
+        _addScenario: function (index, info) {
+            var option = document.createElement("option");
+            if (info.url === currentScenarioUrl) {
+                option.selected = "selected";
+            }
+            option.text = (index + 1) + ") " + info.title;
+            option.value = info.url;
+            this._selectElement.appendChild(option);
+        }
+    });
+
+    function activated(e) {
+        WinJS.Utilities.query("#featureLabel")[0].textContent = SdkSample.sampleTitle;
+    }
+
+    WinJS.Application.addEventListener("activated", activated, false);
+
+    // Export public methods & controls
+    WinJS.Namespace.define("SdkSample", {
+        ScenarioInput: ScenarioInput,
+        ScenarioOutput: ScenarioOutput
+    });
+
+    // SDK Sample Test helper
+    document.TestSdkSample = {
+        getLastError: function () {
+            return lastError;
+        },
+
+        getLastStatus: function () {
+            return lastStatus;
+        },
+
+        selectScenario: function (scenarioID) {
+            scenarioID = scenarioID >> 0;
+            var select = document.getElementById("scenarioSelect");
+            var newUrl = select.options[scenarioID - 1].value;
+            WinJS.Navigation.navigate(newUrl);
+        }
+    };
+})();
diff --git a/C++/opencv-4.7.0/samples/winrt/JavaScript/sample-utils/scenario-select.html b/C++/opencv-4.7.0/samples/winrt/JavaScript/sample-utils/scenario-select.html
new file mode 100644
index 00000000..011fabee
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/JavaScript/sample-utils/scenario-select.html
@@ -0,0 +1,15 @@
+<!-- Copyright (c) Microsoft Corporation. All rights reserved. -->
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml">
+    <head>
+        <title></title>
+    </head>
+    <body>
+        <div class="options">
+             <h3 id="listLabel">Select scenario:</h3>
+            <select id="scenarioSelect" aria-labelledby="listLabel">
+                <!-- scenario list is inserted here -->
+            </select>
+        </div>
+    </body>
+</html>
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing.sln b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing.sln
new file mode 100644
index 00000000..c93d53e9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing.sln
@@ -0,0 +1,40 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OcvImageProcessing", "OcvImageProcessing\OcvImageProcessing.vcxproj", "{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM = Debug|ARM
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|ARM = Release|ARM
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Debug|ARM.ActiveCfg = Debug|ARM
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Debug|ARM.Build.0 = Debug|ARM
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Debug|ARM.Deploy.0 = Debug|ARM
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Debug|Win32.ActiveCfg = Debug|Win32
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Debug|Win32.Build.0 = Debug|Win32
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Debug|Win32.Deploy.0 = Debug|Win32
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Debug|x64.ActiveCfg = Debug|x64
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Debug|x64.Build.0 = Debug|x64
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Debug|x64.Deploy.0 = Debug|x64
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Release|ARM.ActiveCfg = Release|ARM
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Release|ARM.Build.0 = Release|ARM
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Release|ARM.Deploy.0 = Release|ARM
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Release|Win32.ActiveCfg = Release|Win32
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Release|Win32.Build.0 = Release|Win32
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Release|Win32.Deploy.0 = Release|Win32
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Release|x64.ActiveCfg = Release|x64
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Release|x64.Build.0 = Release|x64
+		{A5555EA2-F9E8-4078-90F5-D428F2C0D6D1}.Release|x64.Deploy.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/App.xaml b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/App.xaml
new file mode 100644
index 00000000..78409d51
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/App.xaml
@@ -0,0 +1,20 @@
+<Application
+    x:Class="OcvImageProcessing.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:OcvImageProcessing">
+
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+
+                <!--
+                    Styles that define common aspects of the platform look and feel
+                    Required by Visual Studio project and item templates
+                 -->
+                <ResourceDictionary Source="Common/StandardStyles.xaml"/>
+            </ResourceDictionary.MergedDictionaries>
+
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/App.xaml.cpp b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/App.xaml.cpp
new file mode 100644
index 00000000..228e24a1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/App.xaml.cpp
@@ -0,0 +1,107 @@
+//
+// App.xaml.cpp
+// Implementation of the App class.
+//
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+
+using namespace OcvImageProcessing;
+
+using namespace Platform;
+using namespace Windows::ApplicationModel;
+using namespace Windows::ApplicationModel::Activation;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Controls::Primitives;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Interop;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Navigation;
+
+// The Blank Application template is documented at http://go.microsoft.com/fwlink/?LinkId=234227
+
+/// <summary>
+/// Initializes the singleton application object.  This is the first line of authored code
+/// executed, and as such is the logical equivalent of main() or WinMain().
+/// </summary>
+App::App()
+{
+    InitializeComponent();
+    Suspending += ref new SuspendingEventHandler(this, &App::OnSuspending);
+}
+
+/// <summary>
+/// Invoked when the application is launched normally by the end user.  Other entry points
+/// will be used when the application is launched to open a specific file, to display
+/// search results, and so forth.
+/// </summary>
+/// <param name="args">Details about the launch request and process.</param>
+void App::OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ args)
+{
+    auto rootFrame = dynamic_cast<Frame^>(Window::Current->Content);
+
+    // Do not repeat app initialization when the Window already has content,
+    // just ensure that the window is active
+    if (rootFrame == nullptr)
+    {
+        // Create a Frame to act as the navigation context and associate it with
+        // a SuspensionManager key
+        rootFrame = ref new Frame();
+
+        if (args->PreviousExecutionState == ApplicationExecutionState::Terminated)
+        {
+            // TODO: Restore the saved session state only when appropriate, scheduling the
+            // final launch steps after the restore is complete
+
+        }
+
+        if (rootFrame->Content == nullptr)
+        {
+            // When the navigation stack isn't restored navigate to the first page,
+            // configuring the new page by passing required information as a navigation
+            // parameter
+            if (!rootFrame->Navigate(TypeName(MainPage::typeid), args->Arguments))
+            {
+                throw ref new FailureException("Failed to create initial page");
+            }
+        }
+        // Place the frame in the current Window
+        Window::Current->Content = rootFrame;
+        // Ensure the current window is active
+        Window::Current->Activate();
+    }
+    else
+    {
+        if (rootFrame->Content == nullptr)
+        {
+            // When the navigation stack isn't restored navigate to the first page,
+            // configuring the new page by passing required information as a navigation
+            // parameter
+            if (!rootFrame->Navigate(TypeName(MainPage::typeid), args->Arguments))
+            {
+                throw ref new FailureException("Failed to create initial page");
+            }
+        }
+        // Ensure the current window is active
+        Window::Current->Activate();
+    }
+}
+
+/// <summary>
+/// Invoked when application execution is being suspended.  Application state is saved
+/// without knowing whether the application will be terminated or resumed with the contents
+/// of memory still intact.
+/// </summary>
+/// <param name="sender">The source of the suspend request.</param>
+/// <param name="e">Details about the suspend request.</param>
+void App::OnSuspending(Object^ sender, SuspendingEventArgs^ e)
+{
+    (void) sender; // Unused parameter
+    (void) e;      // Unused parameter
+
+    //TODO: Save application state and stop any background activity
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/App.xaml.h b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/App.xaml.h
new file mode 100644
index 00000000..8e16532b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/App.xaml.h
@@ -0,0 +1,24 @@
+//
+// App.xaml.h
+// Declaration of the App class.
+//
+
+#pragma once
+
+#include "App.g.h"
+
+namespace OcvImageProcessing
+{
+    /// <summary>
+    /// Provides application-specific behavior to supplement the default Application class.
+    /// </summary>
+    ref class App sealed
+    {
+    public:
+        App();
+        virtual void OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ args) override;
+
+    private:
+        void OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ e);
+    };
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/Lena.png b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/Lena.png
new file mode 100644
index 00000000..3e866873
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/Lena.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/Logo.png b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/Logo.png
new file mode 100644
index 00000000..8f447ad3
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/Logo.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/SmallLogo.png b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/SmallLogo.png
new file mode 100644
index 00000000..449be585
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/SmallLogo.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/SplashScreen.png b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/SplashScreen.png
new file mode 100644
index 00000000..901c3b08
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/SplashScreen.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/StoreLogo.png b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/StoreLogo.png
new file mode 100644
index 00000000..0fb23ff2
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Assets/StoreLogo.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Common/StandardStyles.xaml b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Common/StandardStyles.xaml
new file mode 100644
index 00000000..c8f8500d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Common/StandardStyles.xaml
@@ -0,0 +1,1828 @@
+<!--
+    This file contains XAML styles that simplify application development.
+
+    These are not merely convenient, but are required by most Visual Studio project and item templates.
+    Removing, renaming, or otherwise modifying the content of these files may result in a project that
+    does not build, or that will not build once additional pages are added.  If variations on these
+    styles are desired it is recommended that you copy the content under a new name and modify your
+    private copy.
+-->
+
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <!-- Non-brush values that vary across themes -->
+
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Key="Default">
+            <x:String x:Key="BackButtonGlyph">&#xE071;</x:String>
+            <x:String x:Key="BackButtonSnappedGlyph">&#xE0BA;</x:String>
+        </ResourceDictionary>
+
+        <ResourceDictionary x:Key="HighContrast">
+            <x:String x:Key="BackButtonGlyph">&#xE071;</x:String>
+            <x:String x:Key="BackButtonSnappedGlyph">&#xE0C4;</x:String>
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+
+    <x:String x:Key="ChevronGlyph">&#xE26B;</x:String>
+
+    <!-- RichTextBlock styles -->
+
+    <Style x:Key="BasicRichTextStyle" TargetType="RichTextBlock">
+        <Setter Property="Foreground" Value="{StaticResource ApplicationForegroundThemeBrush}"/>
+        <Setter Property="FontSize" Value="{StaticResource ControlContentThemeFontSize}"/>
+        <Setter Property="FontFamily" Value="{StaticResource ContentControlThemeFontFamily}"/>
+        <Setter Property="TextTrimming" Value="WordEllipsis"/>
+        <Setter Property="TextWrapping" Value="Wrap"/>
+        <Setter Property="Typography.StylisticSet20" Value="True"/>
+        <Setter Property="Typography.DiscretionaryLigatures" Value="True"/>
+        <Setter Property="Typography.CaseSensitiveForms" Value="True"/>
+    </Style>
+
+    <Style x:Key="BaselineRichTextStyle" TargetType="RichTextBlock" BasedOn="{StaticResource BasicRichTextStyle}">
+        <Setter Property="LineHeight" Value="20"/>
+        <Setter Property="LineStackingStrategy" Value="BlockLineHeight"/>
+        <!-- Properly align text along its baseline -->
+        <Setter Property="RenderTransform">
+            <Setter.Value>
+                <TranslateTransform X="-1" Y="4"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="ItemRichTextStyle" TargetType="RichTextBlock" BasedOn="{StaticResource BaselineRichTextStyle}"/>
+
+    <Style x:Key="BodyRichTextStyle" TargetType="RichTextBlock" BasedOn="{StaticResource BaselineRichTextStyle}">
+        <Setter Property="FontWeight" Value="SemiLight"/>
+    </Style>
+
+    <!-- TextBlock styles -->
+
+    <Style x:Key="BasicTextStyle" TargetType="TextBlock">
+        <Setter Property="Foreground" Value="{StaticResource ApplicationForegroundThemeBrush}"/>
+        <Setter Property="FontSize" Value="{StaticResource ControlContentThemeFontSize}"/>
+        <Setter Property="FontFamily" Value="{StaticResource ContentControlThemeFontFamily}"/>
+        <Setter Property="TextTrimming" Value="WordEllipsis"/>
+        <Setter Property="TextWrapping" Value="Wrap"/>
+        <Setter Property="Typography.StylisticSet20" Value="True"/>
+        <Setter Property="Typography.DiscretionaryLigatures" Value="True"/>
+        <Setter Property="Typography.CaseSensitiveForms" Value="True"/>
+    </Style>
+
+    <Style x:Key="BaselineTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BasicTextStyle}">
+        <Setter Property="LineHeight" Value="20"/>
+        <Setter Property="LineStackingStrategy" Value="BlockLineHeight"/>
+        <!-- Properly align text along its baseline -->
+        <Setter Property="RenderTransform">
+            <Setter.Value>
+                <TranslateTransform X="-1" Y="4"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="HeaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontSize" Value="56"/>
+        <Setter Property="FontWeight" Value="Light"/>
+        <Setter Property="LineHeight" Value="40"/>
+        <Setter Property="RenderTransform">
+            <Setter.Value>
+                <TranslateTransform X="-2" Y="8"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="SubheaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontSize" Value="26.667"/>
+        <Setter Property="FontWeight" Value="Light"/>
+        <Setter Property="LineHeight" Value="30"/>
+        <Setter Property="RenderTransform">
+            <Setter.Value>
+                <TranslateTransform X="-1" Y="6"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="TitleTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontWeight" Value="SemiBold"/>
+    </Style>
+
+    <Style x:Key="SubtitleTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontWeight" Value="Normal"/>
+    </Style>
+
+    <Style x:Key="ItemTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}"/>
+
+    <Style x:Key="BodyTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontWeight" Value="SemiLight"/>
+    </Style>
+
+    <Style x:Key="CaptionTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaselineTextStyle}">
+        <Setter Property="FontSize" Value="12"/>
+        <Setter Property="Foreground" Value="{StaticResource ApplicationSecondaryForegroundThemeBrush}"/>
+    </Style>
+
+    <Style x:Key="GroupHeaderTextStyle" TargetType="TextBlock">
+        <Setter Property="FontFamily" Value="{StaticResource ContentControlThemeFontFamily}"/>
+        <Setter Property="TextTrimming" Value="WordEllipsis"/>
+        <Setter Property="TextWrapping" Value="NoWrap"/>
+        <Setter Property="Typography.StylisticSet20" Value="True"/>
+        <Setter Property="Typography.DiscretionaryLigatures" Value="True"/>
+        <Setter Property="Typography.CaseSensitiveForms" Value="True"/>
+        <Setter Property="FontSize" Value="26.667"/>
+        <Setter Property="LineStackingStrategy" Value="BlockLineHeight"/>
+        <Setter Property="FontWeight" Value="Light"/>
+        <Setter Property="LineHeight" Value="30"/>
+        <Setter Property="RenderTransform">
+            <Setter.Value>
+                <TranslateTransform X="-1" Y="6"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!-- Button styles -->
+ <!--
+        TextButtonStyle is used to style a Button using subheader-styled text with no other adornment.  There
+        are two styles that are based on TextButtonStyle (TextPrimaryButtonStyle and TextSecondaryButtonStyle)
+        which are used in the GroupedItemsPage as a group header and in the FileOpenPickerPage for triggering
+        commands.
+    -->
+    <Style x:Key="TextButtonStyle" TargetType="ButtonBase">
+        <Setter Property="MinWidth" Value="0"/>
+        <Setter Property="MinHeight" Value="0"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="ButtonBase">
+                    <Grid Background="Transparent">
+                        <ContentPresenter x:Name="Text" Content="{TemplateBinding Content}" />
+                        <Rectangle
+                            x:Name="FocusVisualWhite"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualWhiteStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="1.5"/>
+                        <Rectangle
+                            x:Name="FocusVisualBlack"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualBlackStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="0.5"/>
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup x:Name="CommonStates">
+                                <VisualState x:Name="Normal"/>
+                                <VisualState x:Name="PointerOver">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ApplicationPointerOverForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Pressed">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ApplicationPressedForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Disabled">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ApplicationPressedForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="FocusStates">
+                                <VisualState x:Name="Focused">
+                                    <Storyboard>
+                                        <DoubleAnimation Duration="0" To="1" Storyboard.TargetName="FocusVisualWhite" Storyboard.TargetProperty="Opacity"/>
+                                        <DoubleAnimation Duration="0" To="1" Storyboard.TargetName="FocusVisualBlack" Storyboard.TargetProperty="Opacity"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Unfocused"/>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="CheckStates">
+                                <VisualState x:Name="Checked"/>
+                                <VisualState x:Name="Unchecked">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Text" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource ApplicationSecondaryForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Indeterminate"/>
+                            </VisualStateGroup>
+                        </VisualStateManager.VisualStateGroups>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="TextPrimaryButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource TextButtonStyle}">
+        <Setter Property="Foreground" Value="{StaticResource ApplicationHeaderForegroundThemeBrush}"/>
+    </Style>
+
+    <Style x:Key="TextSecondaryButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource TextButtonStyle}">
+        <Setter Property="Foreground" Value="{StaticResource ApplicationSecondaryForegroundThemeBrush}"/>
+    </Style>
+
+    <!--
+        TextRadioButtonStyle is used to style a RadioButton using subheader-styled text with no other adornment.
+        This style is used in the SearchResultsPage to allow selection among filters.
+    -->
+    <Style x:Key="TextRadioButtonStyle" TargetType="RadioButton" BasedOn="{StaticResource TextButtonStyle}">
+        <Setter Property="Margin" Value="0,0,30,0"/>
+    </Style>
+
+    <!--
+        AppBarButtonStyle is used to style a Button (or ToggleButton) for use in an App Bar.  Content will be centered
+        and should fit within the 40 pixel radius glyph provided.  16-point Segoe UI Symbol is used for content text
+        to simplify the use of glyphs from that font.  AutomationProperties.Name is used for the text below the glyph.
+    -->
+    <Style x:Key="AppBarButtonStyle" TargetType="ButtonBase">
+        <Setter Property="Foreground" Value="{StaticResource AppBarItemForegroundThemeBrush}"/>
+        <Setter Property="VerticalAlignment" Value="Stretch"/>
+        <Setter Property="FontFamily" Value="Segoe UI Symbol"/>
+        <Setter Property="FontWeight" Value="Normal"/>
+        <Setter Property="FontSize" Value="20"/>
+        <Setter Property="AutomationProperties.ItemType" Value="App Bar Button"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="ButtonBase">
+                    <Grid x:Name="RootGrid" Width="100" Background="Transparent">
+                        <StackPanel VerticalAlignment="Top" Margin="0,12,0,11">
+                            <Grid Width="40" Height="40" Margin="0,0,0,5" HorizontalAlignment="Center">
+                                <TextBlock x:Name="BackgroundGlyph" Text="&#xE0A8;" FontFamily="Segoe UI Symbol" FontSize="53.333" Margin="-4,-19,0,0" Foreground="{StaticResource AppBarItemBackgroundThemeBrush}"/>
+                                <TextBlock x:Name="OutlineGlyph" Text="&#xE0A7;" FontFamily="Segoe UI Symbol" FontSize="53.333" Margin="-4,-19,0,0"/>
+                                <ContentPresenter x:Name="Content" HorizontalAlignment="Center" Margin="-1,-1,0,0" VerticalAlignment="Center"/>
+                            </Grid>
+                            <TextBlock
+                                x:Name="TextLabel"
+                                Text="{TemplateBinding AutomationProperties.Name}"
+                                Foreground="{StaticResource AppBarItemForegroundThemeBrush}"
+                                Margin="0,0,2,0"
+                                FontSize="12"
+                                TextAlignment="Center"
+                                Width="88"
+                                MaxHeight="32"
+                                TextTrimming="WordEllipsis"
+                                Style="{StaticResource BasicTextStyle}"/>
+                        </StackPanel>
+                        <Rectangle
+                                x:Name="FocusVisualWhite"
+                                IsHitTestVisible="False"
+                                Stroke="{StaticResource FocusVisualWhiteStrokeThemeBrush}"
+                                StrokeEndLineCap="Square"
+                                StrokeDashArray="1,1"
+                                Opacity="0"
+                                StrokeDashOffset="1.5"/>
+                        <Rectangle
+                                x:Name="FocusVisualBlack"
+                                IsHitTestVisible="False"
+                                Stroke="{StaticResource FocusVisualBlackStrokeThemeBrush}"
+                                StrokeEndLineCap="Square"
+                                StrokeDashArray="1,1"
+                                Opacity="0"
+                                StrokeDashOffset="0.5"/>
+
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup x:Name="ApplicationViewStates">
+                                <VisualState x:Name="FullScreenLandscape"/>
+                                <VisualState x:Name="Filled"/>
+                                <VisualState x:Name="FullScreenPortrait">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="TextLabel" Storyboard.TargetProperty="Visibility">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="RootGrid" Storyboard.TargetProperty="Width">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="60"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Snapped">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="TextLabel" Storyboard.TargetProperty="Visibility">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="RootGrid" Storyboard.TargetProperty="Width">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="60"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="CommonStates">
+                                <VisualState x:Name="Normal"/>
+                                <VisualState x:Name="PointerOver">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemPointerOverBackgroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Content" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemPointerOverForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Pressed">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="OutlineGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Content" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemPressedForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Disabled">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="OutlineGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemDisabledForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Content" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemDisabledForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="TextLabel" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemDisabledForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="FocusStates">
+                                <VisualState x:Name="Focused">
+                                    <Storyboard>
+                                        <DoubleAnimation
+                                                Storyboard.TargetName="FocusVisualWhite"
+                                                Storyboard.TargetProperty="Opacity"
+                                                To="1"
+                                                Duration="0"/>
+                                        <DoubleAnimation
+                                                Storyboard.TargetName="FocusVisualBlack"
+                                                Storyboard.TargetProperty="Opacity"
+                                                To="1"
+                                                Duration="0"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Unfocused" />
+                                <VisualState x:Name="PointerFocused" />
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="CheckStates">
+                                <VisualState x:Name="Checked">
+                                    <Storyboard>
+                                        <DoubleAnimation Duration="0" To="0" Storyboard.TargetName="OutlineGlyph" Storyboard.TargetProperty="Opacity"/>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundCheckedGlyph" Storyboard.TargetProperty="Visibility">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="Visible"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Content" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource AppBarItemPressedForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Unchecked"/>
+                                <VisualState x:Name="Indeterminate"/>
+                            </VisualStateGroup>
+                        </VisualStateManager.VisualStateGroups>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!--
+        Standard AppBarButton Styles for use with Button and ToggleButton
+
+  An AppBarButton Style is provided for each of the glyphs in the Segoe UI Symbol font.
+       Uncomment any style you reference (as not all may be required).
+    -->
+
+    <!--
+ <
+Style x:Key="SkipBackAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SkipBackAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Skip Back"/>
+        <Setter Property="Content" Value="&#xE100;"/>
+    </Style>
+    <Style x:Key="SkipAheadAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SkipAheadAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Skip Ahead"/>
+        <Setter Property="Content" Value="&#xE101;"/>
+    </Style>
+    <Style x:Key="PlayAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PlayAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Play"/>
+        <Setter Property="Content" Value="&#xE102;"/>
+    </Style>
+    <Style x:Key="PauseAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PauseAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Pause"/>
+        <Setter Property="Content" Value="&#xE103;"/>
+    </Style>
+    <Style x:Key="EditAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="EditAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Edit"/>
+        <Setter Property="Content" Value="&#xE104;"/>
+    </Style>
+    <Style x:Key="SaveAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SaveAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Save"/>
+        <Setter Property="Content" Value="&#xE105;"/>
+    </Style>
+    <Style x:Key="DeleteAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DeleteAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Delete"/>
+        <Setter Property="Content" Value="&#xE106;"/>
+    </Style>
+    <Style x:Key="DiscardAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DiscardAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Discard"/>
+        <Setter Property="Content" Value="&#xE107;"/>
+    </Style>
+    <Style x:Key="RemoveAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RemoveAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Remove"/>
+        <Setter Property="Content" Value="&#xE108;"/>
+    </Style>
+    <Style x:Key="AddAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AddAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Add"/>
+        <Setter Property="Content" Value="&#xE109;"/>
+    </Style>
+    <Style x:Key="NoAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="NoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="No"/>
+        <Setter Property="Content" Value="&#xE10A;"/>
+    </Style>
+    <Style x:Key="YesAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="YesAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Yes"/>
+        <Setter Property="Content" Value="&#xE10B;"/>
+    </Style>
+    <Style x:Key="MoreAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MoreAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="More"/>
+        <Setter Property="Content" Value="&#xE10C;"/>
+    </Style>
+    <Style x:Key="RedoAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RedoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Redo"/>
+        <Setter Property="Content" Value="&#xE10D;"/>
+    </Style>
+    <Style x:Key="UndoAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="UndoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Undo"/>
+        <Setter Property="Content" Value="&#xE10E;"/>
+    </Style>
+    <Style x:Key="HomeAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="HomeAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Home"/>
+        <Setter Property="Content" Value="&#xE10F;"/>
+    </Style>
+    <Style x:Key="OutAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="OutAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Out"/>
+        <Setter Property="Content" Value="&#xE110;"/>
+    </Style>
+    <Style x:Key="NextAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="NextAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Next"/>
+        <Setter Property="Content" Value="&#xE111;"/>
+    </Style>
+    <Style x:Key="PreviousAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PreviousAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Previous"/>
+        <Setter Property="Content" Value="&#xE112;"/>
+    </Style>
+    <Style x:Key="FavoriteAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FavoriteAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Favorite"/>
+        <Setter Property="Content" Value="&#xE113;"/>
+    </Style>
+    <Style x:Key="PhotoAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PhotoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Photo"/>
+        <Setter Property="Content" Value="&#xE114;"/>
+    </Style>
+    <Style x:Key="SettingsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SettingsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Settings"/>
+        <Setter Property="Content" Value="&#xE115;"/>
+    </Style>
+    -->
+
+    <!--
+    <Style x:Key="VideoAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="VideoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Video"/>
+        <Setter Property="Content" Value="&#xE116;"/>
+    </Style>
+    <Style x:Key="RefreshAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RefreshAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Refresh"/>
+        <Setter Property="Content" Value="&#xE117;"/>
+    </Style>
+    <Style x:Key="DownloadAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DownloadAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Download"/>
+        <Setter Property="Content" Value="&#xE118;"/>
+    </Style>
+    <Style x:Key="MailAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MailAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Mail"/>
+        <Setter Property="Content" Value="&#xE119;"/>
+    </Style>
+    <Style x:Key="SearchAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SearchAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Search"/>
+        <Setter Property="Content" Value="&#xE11A;"/>
+    </Style>
+    <Style x:Key="HelpAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="HelpAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Help"/>
+        <Setter Property="Content" Value="&#xE11B;"/>
+    </Style>
+    <Style x:Key="UploadAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="UploadAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Upload"/>
+        <Setter Property="Content" Value="&#xE11C;"/>
+    </Style>
+    <Style x:Key="EmojiAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="EmojiAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Emoji"/>
+        <Setter Property="Content" Value="&#xE11D;"/>
+    </Style>
+    <Style x:Key="TwoPageAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="TwoPageAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Two Page"/>
+        <Setter Property="Content" Value="&#xE11E;"/>
+    </Style>
+    <Style x:Key="LeaveChatAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="LeaveChatAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Upload"/>
+        <Setter Property="Content" Value="&#xE11F;"/>
+    </Style>
+    <Style x:Key="MailForwardAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MailForwardAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Forward Mail"/>
+        <Setter Property="Content" Value="&#xE120;"/>
+    </Style>
+    <Style x:Key="ClockAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ClockAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Clock"/>
+        <Setter Property="Content" Value="&#xE121;"/>
+    </Style>
+    <Style x:Key="SendAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SendAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Send"/>
+        <Setter Property="Content" Value="&#xE122;"/>
+    </Style>
+    <Style x:Key="CropAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CropAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Crop"/>
+        <Setter Property="Content" Value="&#xE123;"/>
+    </Style>
+    <Style x:Key="RotateCameraAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RotateCameraAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Rotate Camera"/>
+        <Setter Property="Content" Value="&#xE124;"/>
+    </Style>
+    <Style x:Key="PeopleAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PeopleAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="People"/>
+        <Setter Property="Content" Value="&#xE125;"/>
+    </Style>
+    <Style x:Key="ClosePaneAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ClosePaneAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Close Pane"/>
+        <Setter Property="Content" Value="&#xE126;"/>
+    </Style>
+    <Style x:Key="OpenPaneAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="OpenPaneAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Open Pane"/>
+        <Setter Property="Content" Value="&#xE127;"/>
+    </Style>
+    -->
+
+    <!--
+    <Style x:Key="WorldAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="WorldAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="World"/>
+        <Setter Property="Content" Value="&#xE128;"/>
+    </Style>
+    <Style x:Key="FlagAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FlagAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Flag"/>
+        <Setter Property="Content" Value="&#xE129;"/>
+    </Style>
+    <Style x:Key="PreviewLinkAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PreviewLinkAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Preview Link"/>
+        <Setter Property="Content" Value="&#xE12A;"/>
+    </Style>
+    <Style x:Key="GlobeAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="GlobeAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Globe"/>
+        <Setter Property="Content" Value="&#xE12B;"/>
+    </Style>
+    <Style x:Key="TrimAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="TrimAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Trim"/>
+        <Setter Property="Content" Value="&#xE12C;"/>
+    </Style>
+    <Style x:Key="AttachCameraAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AttachCameraAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Attach Camera"/>
+        <Setter Property="Content" Value="&#xE12D;"/>
+    </Style>
+    <Style x:Key="ZoomInAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ZoomInAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Zoom In"/>
+        <Setter Property="Content" Value="&#xE12E;"/>
+    </Style>
+    <Style x:Key="BookmarksAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="BookmarksAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Bookmarks"/>
+        <Setter Property="Content" Value="&#xE12F;"/>
+    </Style>
+    <Style x:Key="DocumentAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DocumentAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Document"/>
+        <Setter Property="Content" Value="&#xE130;"/>
+    </Style>
+    <Style x:Key="ProtectedDocumentAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ProtectedDocumentAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Protected Document"/>
+        <Setter Property="Content" Value="&#xE131;"/>
+    </Style>
+    <Style x:Key="PageAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PageAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Page"/>
+        <Setter Property="Content" Value="&#xE132;"/>
+    </Style>
+    <Style x:Key="BulletsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="BulletsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Bullets"/>
+        <Setter Property="Content" Value="&#xE133;"/>
+    </Style>
+    <Style x:Key="CommentAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CommentAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Comment"/>
+        <Setter Property="Content" Value="&#xE134;"/>
+    </Style>
+    <Style x:Key="Mail2AppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="Mail2AppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Mail2"/>
+        <Setter Property="Content" Value="&#xE135;"/>
+    </Style>
+    <Style x:Key="ContactInfoAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ContactInfoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Contact Info"/>
+        <Setter Property="Content" Value="&#xE136;"/>
+    </Style>
+    <Style x:Key="HangUpAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="HangUpAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Hang Up"/>
+        <Setter Property="Content" Value="&#xE137;"/>
+    </Style>
+    <Style x:Key="ViewAllAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ViewAllAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="View All"/>
+        <Setter Property="Content" Value="&#xE138;"/>
+    </Style>
+    <Style x:Key="MapPinAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MapPinAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Map Pin"/>
+        <Setter Property="Content" Value="&#xE139;"/>
+    </Style>
+    <Style x:Key="PhoneAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PhoneAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Phone"/>
+        <Setter Property="Content" Value="&#xE13A;"/>
+    </Style>
+    <Style x:Key="VideoChatAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="VideoChatAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Video Chat"/>
+        <Setter Property="Content" Value="&#xE13B;"/>
+    </Style>
+    <Style x:Key="SwitchAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SwitchAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Switch"/>
+        <Setter Property="Content" Value="&#xE13C;"/>
+    </Style>
+    <Style x:Key="ContactAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ContactAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Contact"/>
+        <Setter Property="Content" Value="&#xE13D;"/>
+    </Style>
+
+    -->
+
+    <!--
+
+    <Style x:Key="RenameAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RenameAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Rename"/>
+        <Setter Property="Content" Value="&#xE13E;"/>
+    </Style>
+    <Style x:Key="PinAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PinAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Pin"/>
+        <Setter Property="Content" Value="&#xE141;"/>
+    </Style>
+    <Style x:Key="MusicInfoAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MusicInfoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Music Info"/>
+        <Setter Property="Content" Value="&#xE142;"/>
+    </Style>
+    <Style x:Key="GoAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="GoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Go"/>
+        <Setter Property="Content" Value="&#xE143;"/>
+    </Style>
+    <Style x:Key="KeyboardAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="KeyboardAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Keyboard"/>
+        <Setter Property="Content" Value="&#xE144;"/>
+    </Style>
+    <Style x:Key="DockLeftAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DockLeftAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Dock Left"/>
+        <Setter Property="Content" Value="&#xE145;"/>
+    </Style>
+    <Style x:Key="DockRightAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DockRightAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Dock Right"/>
+        <Setter Property="Content" Value="&#xE146;"/>
+    </Style>
+    <Style x:Key="DockBottomAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DockBottomAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Dock Bottom"/>
+        <Setter Property="Content" Value="&#xE147;"/>
+    </Style>
+    <Style x:Key="RemoteAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RemoteAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Remote"/>
+        <Setter Property="Content" Value="&#xE148;"/>
+    </Style>
+    <Style x:Key="SyncAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SyncAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Sync"/>
+        <Setter Property="Content" Value="&#xE149;"/>
+    </Style>
+    <Style x:Key="RotateAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RotateAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Rotate"/>
+        <Setter Property="Content" Value="&#xE14A;"/>
+    </Style>
+    <Style x:Key="ShuffleAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ShuffleAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Shuffle"/>
+        <Setter Property="Content" Value="&#xE14B;"/>
+    </Style>
+    <Style x:Key="ListAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ListAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="List"/>
+        <Setter Property="Content" Value="&#xE14C;"/>
+    </Style>
+    <Style x:Key="ShopAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ShopAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Shop"/>
+        <Setter Property="Content" Value="&#xE14D;"/>
+    </Style>
+    <Style x:Key="SelectAllAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SelectAllAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Select All"/>
+        <Setter Property="Content" Value="&#xE14E;"/>
+    </Style>
+    <Style x:Key="OrientationAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="OrientationAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Orientation"/>
+        <Setter Property="Content" Value="&#xE14F;"/>
+    </Style>
+    <Style x:Key="ImportAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ImportAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Import"/>
+        <Setter Property="Content" Value="&#xE150;"/>
+    </Style>
+    <Style x:Key="ImportAllAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ImportAllAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Import All"/>
+        <Setter Property="Content" Value="&#xE151;"/>
+    </Style>
+    <Style x:Key="BrowsePhotosAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="BrowsePhotosAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Browse Photos"/>
+        <Setter Property="Content" Value="&#xE155;"/>
+    </Style>
+    <Style x:Key="WebcamAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="WebcamAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Webcam"/>
+        <Setter Property="Content" Value="&#xE156;"/>
+    </Style>
+    -->
+
+    <!--
+    <Style x:Key="PicturesAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PicturesAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Pictures"/>
+        <Setter Property="Content" Value="&#xE158;"/>
+    </Style>
+    <Style x:Key="SaveLocalAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SaveLocalAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Save Local"/>
+        <Setter Property="Content" Value="&#xE159;"/>
+    </Style>
+    <Style x:Key="CaptionAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CaptionAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Caption"/>
+        <Setter Property="Content" Value="&#xE15A;"/>
+    </Style>
+    <Style x:Key="StopAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="StopAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Stop"/>
+        <Setter Property="Content" Value="&#xE15B;"/>
+    </Style>
+    <Style x:Key="ShowResultsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ShowResultsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Show Results"/>
+        <Setter Property="Content" Value="&#xE15C;"/>
+    </Style>
+    <Style x:Key="VolumeAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="VolumeAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Volume"/>
+        <Setter Property="Content" Value="&#xE15D;"/>
+    </Style>
+    <Style x:Key="RepairAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RepairAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Repair"/>
+        <Setter Property="Content" Value="&#xE15E;"/>
+    </Style>
+    <Style x:Key="MessageAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MessageAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Message"/>
+        <Setter Property="Content" Value="&#xE15F;"/>
+    </Style>
+    <Style x:Key="Page2AppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="Page2AppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Page2"/>
+        <Setter Property="Content" Value="&#xE160;"/>
+    </Style>
+    <Style x:Key="CalendarDayAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CalendarDayAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Day"/>
+        <Setter Property="Content" Value="&#xE161;"/>
+    </Style>
+    <Style x:Key="CalendarWeekAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CalendarWeekAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Week"/>
+        <Setter Property="Content" Value="&#xE162;"/>
+    </Style>
+    <Style x:Key="CalendarAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CalendarAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Calendar"/>
+        <Setter Property="Content" Value="&#xE163;"/>
+    </Style>
+    <Style x:Key="CharactersAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CharactersAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Characters"/>
+        <Setter Property="Content" Value="&#xE164;"/>
+    </Style>
+    <Style x:Key="MailReplyAllAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MailReplyAllAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Reply All"/>
+        <Setter Property="Content" Value="&#xE165;"/>
+    </Style>
+    <Style x:Key="ReadAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ReadAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Read"/>
+        <Setter Property="Content" Value="&#xE166;"/>
+    </Style>
+    <Style x:Key="LinkAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="LinkAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Link"/>
+        <Setter Property="Content" Value="&#xE167;"/>
+    </Style>
+    <Style x:Key="AccountsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AccountsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Accounts"/>
+        <Setter Property="Content" Value="&#xE168;"/>
+    </Style>
+    <Style x:Key="ShowBccAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ShowBccAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Show Bcc"/>
+        <Setter Property="Content" Value="&#xE169;"/>
+    </Style>
+    <Style x:Key="HideBccAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="HideBccAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Hide Bcc"/>
+        <Setter Property="Content" Value="&#xE16A;"/>
+    </Style>
+    -->
+
+    <!--
+    <Style x:Key="CutAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CutAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Cut"/>
+        <Setter Property="Content" Value="&#xE16B;"/>
+    </Style>
+    <Style x:Key="AttachAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AttachAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Attach"/>
+        <Setter Property="Content" Value="&#xE16C;"/>
+    </Style>
+    <Style x:Key="PasteAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PasteAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Paste"/>
+        <Setter Property="Content" Value="&#xE16D;"/>
+    </Style>
+    <Style x:Key="FilterAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FilterAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Filter"/>
+        <Setter Property="Content" Value="&#xE16E;"/>
+    </Style>
+    <Style x:Key="CopyAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CopyAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Copy"/>
+        <Setter Property="Content" Value="&#xE16F;"/>
+    </Style>
+    <Style x:Key="Emoji2AppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="Emoji2AppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Emoji2"/>
+        <Setter Property="Content" Value="&#xE170;"/>
+    </Style>
+    <Style x:Key="ImportantAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ImportantAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Important"/>
+        <Setter Property="Content" Value="&#xE171;"/>
+    </Style>
+    <Style x:Key="MailReplyAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MailReplyAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Reply"/>
+        <Setter Property="Content" Value="&#xE172;"/>
+    </Style>
+    <Style x:Key="SlideShowAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SlideShowAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Slideshow"/>
+        <Setter Property="Content" Value="&#xE173;"/>
+    </Style>
+    <Style x:Key="SortAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SortAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Sort"/>
+        <Setter Property="Content" Value="&#xE174;"/>
+    </Style>
+    <Style x:Key="ManageAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ManageAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Manage"/>
+        <Setter Property="Content" Value="&#xE178;"/>
+    </Style>
+    <Style x:Key="AllAppsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AllAppsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="All Apps"/>
+        <Setter Property="Content" Value="&#xE179;"/>
+    </Style>
+    <Style x:Key="DisconnectDriveAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DisconnectDriveAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Disconnect Drive"/>
+        <Setter Property="Content" Value="&#xE17A;"/>
+    </Style>
+    <Style x:Key="MapDriveAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MapDriveAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Map Drive"/>
+        <Setter Property="Content" Value="&#xE17B;"/>
+    </Style>
+    <Style x:Key="NewWindowAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="NewWindowAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="New Window"/>
+        <Setter Property="Content" Value="&#xE17C;"/>
+    </Style>
+    <Style x:Key="OpenWithAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="OpenWithAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Open With"/>
+        <Setter Property="Content" Value="&#xE17D;"/>
+    </Style>
+    <Style x:Key="ContactPresenceAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ContactPresenceAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Presence"/>
+        <Setter Property="Content" Value="&#xE181;"/>
+    </Style>
+    <Style x:Key="PriorityAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PriorityAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Priority"/>
+        <Setter Property="Content" Value="&#xE182;"/>
+    </Style>
+    <Style x:Key="UploadSkyDriveAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="UploadSkyDriveAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Skydrive"/>
+        <Setter Property="Content" Value="&#xE183;"/>
+    </Style>
+    <Style x:Key="GoToTodayAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="GoToTodayAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Today"/>
+        <Setter Property="Content" Value="&#xE184;"/>
+    </Style>
+    <Style x:Key="FontAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FontAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Font"/>
+        <Setter Property="Content" Value="&#xE185;"/>
+    </Style>
+
+    -->
+
+    <!--
+
+    <Style x:Key="FontColorAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FontColorAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Font Color"/>
+        <Setter Property="Content" Value="&#xE186;"/>
+    </Style>
+    <Style x:Key="Contact2AppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="Contact2AppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Contact"/>
+        <Setter Property="Content" Value="&#xE187;"/>
+    </Style>
+    <Style x:Key="FolderppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FolderAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Folder"/>
+        <Setter Property="Content" Value="&#xE188;"/>
+    </Style>
+    <Style x:Key="AudioAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AudioAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Audio"/>
+        <Setter Property="Content" Value="&#xE189;"/>
+    </Style>
+    <Style x:Key="PlaceholderAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PlaceholderAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Placeholder"/>
+        <Setter Property="Content" Value="&#xE18A;"/>
+    </Style>
+    <Style x:Key="ViewAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ViewAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="View"/>
+        <Setter Property="Content" Value="&#xE18B;"/>
+    </Style>
+    <Style x:Key="SetLockScreenAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SetLockscreenAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Set Lockscreen"/>
+        <Setter Property="Content" Value="&#xE18C;"/>
+    </Style>
+    <Style x:Key="SetTitleAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SetTitleAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Set Title"/>
+        <Setter Property="Content" Value="&#xE18D;"/>
+    </Style>
+    <Style x:Key="CcAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CcAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Cc"/>
+        <Setter Property="Content" Value="&#xE190;"/>
+    </Style>
+    <Style x:Key="StopSlideShowAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="StopSlideshowAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Stop Slideshow"/>
+        <Setter Property="Content" Value="&#xE191;"/>
+    </Style>
+    <Style x:Key="PermissionsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PermissionsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Permissions"/>
+        <Setter Property="Content" Value="&#xE192;"/>
+    </Style>
+    <Style x:Key="HighlightAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="HighlightAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Highlight"/>
+        <Setter Property="Content" Value="&#xE193;"/>
+    </Style>
+    <Style x:Key="DisableUpdatesAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DisableUpdatesAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Disable Updates"/>
+        <Setter Property="Content" Value="&#xE194;"/>
+    </Style>
+    <Style x:Key="UnfavoriteAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="UnfavoriteAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Unfavorite"/>
+        <Setter Property="Content" Value="&#xE195;"/>
+    </Style>
+    <Style x:Key="UnPinAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="UnPinAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Unpin"/>
+        <Setter Property="Content" Value="&#xE196;"/>
+    </Style>
+    <Style x:Key="OpenLocalAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="OpenLocalAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Open Loal"/>
+        <Setter Property="Content" Value="&#xE197;"/>
+    </Style>
+    <Style x:Key="MuteAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MuteAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Mute"/>
+        <Setter Property="Content" Value="&#xE198;"/>
+    </Style>
+    <Style x:Key="ItalicAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ItalicAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Italic"/>
+        <Setter Property="Content" Value="&#xE199;"/>
+    </Style>
+    -->
+
+    <!--
+    <Style x:Key="UnderlineAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="UnderlineAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Underline"/>
+        <Setter Property="Content" Value="&#xE19A;"/>
+    </Style>
+    <Style x:Key="BoldAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="BoldAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Bold"/>
+        <Setter Property="Content" Value="&#xE19B;"/>
+    </Style>
+    <Style x:Key="MoveToFolderAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MoveToFolderAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Move to Folder"/>
+        <Setter Property="Content" Value="&#xE19C;"/>
+    </Style>
+    <Style x:Key="LikeDislikeAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="LikeDislikeAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Like/Dislike"/>
+        <Setter Property="Content" Value="&#xE19D;"/>
+    </Style>
+    <Style x:Key="DislikeAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DislikeAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Dislike"/>
+        <Setter Property="Content" Value="&#xE19E;"/>
+    </Style>
+    <Style x:Key="LikeAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="LikeAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Like"/>
+        <Setter Property="Content" Value="&#xE19F;"/>
+    </Style>
+    <Style x:Key="AlignRightAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AlignRightAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Align Right"/>
+        <Setter Property="Content" Value="&#xE1A0;"/>
+    </Style>
+    <Style x:Key="AlignCenterAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AlignCenterAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Align Center"/>
+        <Setter Property="Content" Value="&#xE1A1;"/>
+    </Style>
+    <Style x:Key="AlignLeftAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AlignLeftAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Align Left"/>
+        <Setter Property="Content" Value="&#xE1A2;"/>
+    </Style>
+    <Style x:Key="ZoomAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ZoomAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Zoom"/>
+        <Setter Property="Content" Value="&#xE1A3;"/>
+    </Style>
+    <Style x:Key="ZoomOutAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ZoomOutAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Zoom Out"/>
+        <Setter Property="Content" Value="&#xE1A4;"/>
+    </Style>
+    <Style x:Key="OpenFileAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="OpenFileAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Open File"/>
+        <Setter Property="Content" Value="&#xE1A5;"/>
+    </Style>
+    <Style x:Key="OtherUserAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="OtherUserAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Other User"/>
+        <Setter Property="Content" Value="&#xE1A6;"/>
+    </Style>
+    <Style x:Key="AdminAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AdminAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Admin"/>
+        <Setter Property="Content" Value="&#xE1A7;"/>
+    </Style>
+    <Style x:Key="StreetAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="StreetAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Street"/>
+        <Setter Property="Content" Value="&#xE1C3;"/>
+    </Style>
+    <Style x:Key="MapAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MapAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Map"/>
+        <Setter Property="Content" Value="&#xE1C4;"/>
+    </Style>
+    <Style x:Key="ClearSelectionAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ClearSelectionAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Clear Selection"/>
+        <Setter Property="Content" Value="&#xE1C5;"/>
+    </Style>
+    <Style x:Key="FontDecreaseAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FontDecreaseAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Decrease Font"/>
+        <Setter Property="Content" Value="&#xE1C6;"/>
+    </Style>
+    <Style x:Key="FontIncreaseAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FontIncreaseAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Increase Font"/>
+        <Setter Property="Content" Value="&#xE1C7;"/>
+    </Style>
+    <Style x:Key="FontSizeAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FontSizeAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Font Size"/>
+        <Setter Property="Content" Value="&#xE1C8;"/>
+    </Style>
+    -->
+
+    <!--
+    <Style x:Key="CellphoneAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CellphoneAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Cellphone"/>
+        <Setter Property="Content" Value="&#xE1C9;"/>
+    </Style>
+    <Style x:Key="ReshareAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ReshareAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Reshare"/>
+        <Setter Property="Content" Value="&#xE1CA;"/>
+    </Style>
+    <Style x:Key="TagAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="TagAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Tag"/>
+        <Setter Property="Content" Value="&#xE1CB;"/>
+    </Style>
+    <Style x:Key="RepeatOneAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RepeatOneAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Repeat Once"/>
+        <Setter Property="Content" Value="&#xE1CC;"/>
+    </Style>
+    <Style x:Key="RepeatAllAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="RepeatAllAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Repeat All"/>
+        <Setter Property="Content" Value="&#xE1CD;"/>
+    </Style>
+    <Style x:Key="OutlineStarAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="OutlineStarAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Outline Star"/>
+        <Setter Property="Content" Value="&#xE1CE;"/>
+    </Style>
+    <Style x:Key="SolidStarAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SolidStarAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Solid Star"/>
+        <Setter Property="Content" Value="&#xE1CF;"/>
+    </Style>
+    <Style x:Key="CalculatorAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CalculatorAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Calculator"/>
+        <Setter Property="Content" Value="&#xE1D0;"/>
+    </Style>
+    <Style x:Key="DirectionsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="DirectionsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Directions"/>
+        <Setter Property="Content" Value="&#xE1D1;"/>
+    </Style>
+    <Style x:Key="TargetAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="TargetAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Target"/>
+        <Setter Property="Content" Value="&#xE1D2;"/>
+    </Style>
+    <Style x:Key="LibraryAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="LibraryAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Library"/>
+        <Setter Property="Content" Value="&#xE1D3;"/>
+    </Style>
+    <Style x:Key="PhonebookAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PhonebookAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Phonebook"/>
+        <Setter Property="Content" Value="&#xE1D4;"/>
+    </Style>
+    <Style x:Key="MemoAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MemoAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Memo"/>
+        <Setter Property="Content" Value="&#xE1D5;"/>
+    </Style>
+    <Style x:Key="MicrophoneAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="MicrophoneAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Microphone"/>
+        <Setter Property="Content" Value="&#xE1D6;"/>
+    </Style>
+    <Style x:Key="PostUpdateAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="PostUpdateAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Post Update"/>
+        <Setter Property="Content" Value="&#xE1D7;"/>
+    </Style>
+    <Style x:Key="BackToWindowAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="BackToWindowAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Back to Window"/>
+        <Setter Property="Content" Value="&#xE1D8;"/>
+    </Style>
+    -->
+
+    <!--
+    <Style x:Key="FullScreenAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FullScreenAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Full Screen"/>
+        <Setter Property="Content" Value="&#xE1D9;"/>
+    </Style>
+    <Style x:Key="NewFolderAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="NewFolderAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="New Folder"/>
+        <Setter Property="Content" Value="&#xE1DA;"/>
+    </Style>
+    <Style x:Key="CalendarReplyAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="CalendarReplyAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Calendar Reply"/>
+        <Setter Property="Content" Value="&#xE1DB;"/>
+    </Style>
+    <Style x:Key="UnsyncFolderAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="UnsyncFolderAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Unsync Folder"/>
+        <Setter Property="Content" Value="&#xE1DD;"/>
+    </Style>
+    <Style x:Key="ReportHackedAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ReportHackedAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Report Hacked"/>
+        <Setter Property="Content" Value="&#xE1DE;"/>
+    </Style>
+    <Style x:Key="SyncFolderAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SyncFolderAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Sync Folder"/>
+        <Setter Property="Content" Value="&#xE1DF;"/>
+    </Style>
+    <Style x:Key="BlockContactAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="Block ContactAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="BlockContact"/>
+        <Setter Property="Content" Value="&#xE1E0;"/>
+    </Style>
+    <Style x:Key="SwitchAppsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="SwitchAppsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Switch Apps"/>
+        <Setter Property="Content" Value="&#xE1E1;"/>
+    </Style>
+    <Style x:Key="AddFriendAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="AddFriendAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Add Friend"/>
+        <Setter Property="Content" Value="&#xE1E2;"/>
+    </Style>
+    <Style x:Key="TouchPointerAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="TouchPointerAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Touch Pointer"/>
+        <Setter Property="Content" Value="&#xE1E3;"/>
+    </Style>
+    <Style x:Key="GoToStartAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="GoToStartAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Go to Start"/>
+        <Setter Property="Content" Value="&#xE1E4;"/>
+    </Style>
+    <Style x:Key="ZeroBarsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ZeroBarsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Zero Bars"/>
+        <Setter Property="Content" Value="&#xE1E5;"/>
+    </Style>
+    <Style x:Key="OneBarAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="OneBarAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="One Bar"/>
+        <Setter Property="Content" Value="&#xE1E6;"/>
+    </Style>
+    <Style x:Key="TwoBarsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="TwoBarsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Two Bars"/>
+        <Setter Property="Content" Value="&#xE1E7;"/>
+    </Style>
+    <Style x:Key="ThreeBarsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="ThreeBarsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Three Bars"/>
+        <Setter Property="Content" Value="&#xE1E8;"/>
+    </Style>
+    <Style x:Key="FourBarsAppBarButtonStyle" TargetType="ButtonBase" BasedOn="{StaticResource AppBarButtonStyle}">
+        <Setter Property="AutomationProperties.AutomationId" Value="FourBarsAppBarButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Four Bars"/>
+        <Setter Property="Content" Value="&#xE1E9;"/>
+    </Style>
+
+    -->
+
+    <!-- Title area styles -->
+
+    <Style x:Key="PageHeaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource HeaderTextStyle}">
+        <Setter Property="TextWrapping" Value="NoWrap"/>
+        <Setter Property="VerticalAlignment" Value="Bottom"/>
+        <Setter Property="Margin" Value="0,0,30,40"/>
+    </Style>
+
+    <Style x:Key="PageSubheaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource SubheaderTextStyle}">
+        <Setter Property="TextWrapping" Value="NoWrap"/>
+        <Setter Property="VerticalAlignment" Value="Bottom"/>
+        <Setter Property="Margin" Value="0,0,0,40"/>
+    </Style>
+
+    <Style x:Key="SnappedPageHeaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource PageSubheaderTextStyle}">
+        <Setter Property="Margin" Value="0,0,18,40"/>
+    </Style>
+
+    <!--
+        BackButtonStyle is used to style a Button for use in the title area of a page.  Margins appropriate for
+        the conventional page layout are included as part of the style.
+    -->
+    <Style x:Key="BackButtonStyle" TargetType="Button">
+        <Setter Property="MinWidth" Value="0"/>
+        <Setter Property="Width" Value="48"/>
+        <Setter Property="Height" Value="48"/>
+        <Setter Property="Margin" Value="36,0,36,36"/>
+        <Setter Property="VerticalAlignment" Value="Bottom"/>
+        <Setter Property="FontFamily" Value="Segoe UI Symbol"/>
+        <Setter Property="FontWeight" Value="Normal"/>
+        <Setter Property="FontSize" Value="56"/>
+        <Setter Property="AutomationProperties.AutomationId" Value="BackButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Back"/>
+        <Setter Property="AutomationProperties.ItemType" Value="Navigation Button"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="Button">
+                    <Grid x:Name="RootGrid">
+                        <Grid Margin="-1,-16,0,0">
+                            <TextBlock x:Name="BackgroundGlyph" Text="&#xE0A8;" Foreground="{StaticResource BackButtonBackgroundThemeBrush}"/>
+                            <TextBlock x:Name="NormalGlyph" Text="{StaticResource BackButtonGlyph}" Foreground="{StaticResource BackButtonForegroundThemeBrush}"/>
+                            <TextBlock x:Name="ArrowGlyph" Text="&#xE0A6;" Foreground="{StaticResource BackButtonPressedForegroundThemeBrush}" Opacity="0"/>
+                        </Grid>
+                        <Rectangle
+                            x:Name="FocusVisualWhite"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualWhiteStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="1.5"/>
+                        <Rectangle
+                            x:Name="FocusVisualBlack"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualBlackStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="0.5"/>
+
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup x:Name="CommonStates">
+                                <VisualState x:Name="Normal" />
+                                <VisualState x:Name="PointerOver">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonPointerOverBackgroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="NormalGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonPointerOverForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Pressed">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="ArrowGlyph"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="NormalGlyph"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="0"
+                                            Duration="0"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Disabled">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="RootGrid" Storyboard.TargetProperty="Visibility">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="FocusStates">
+                                <VisualState x:Name="Focused">
+                                    <Storyboard>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="FocusVisualWhite"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="FocusVisualBlack"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Unfocused" />
+                                <VisualState x:Name="PointerFocused" />
+                            </VisualStateGroup>
+                        </VisualStateManager.VisualStateGroups>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!--
+        PortraitBackButtonStyle is used to style a Button for use in the title area of a portrait page.  Margins appropriate
+        for the conventional page layout are included as part of the style.
+    -->
+    <Style x:Key="PortraitBackButtonStyle" TargetType="Button" BasedOn="{StaticResource BackButtonStyle}">
+        <Setter Property="Margin" Value="26,0,26,36"/>
+    </Style>
+
+    <!--
+        SnappedBackButtonStyle is used to style a Button for use in the title area of a snapped page.  Margins appropriate
+        for the conventional page layout are included as part of the style.
+ The o
+bvious duplication here is necessary as the glyphs used in snapped are not merely smaller versions of the same
+        glyph but are actually distinct.
+    -->
+    <Style x:Key="SnappedBackButtonStyle" TargetType="Button">
+        <Setter Property="MinWidth" Value="0"/>
+        <Setter Property="Margin" Value="20,0,0,0"/>
+        <Setter Property="VerticalAlignment" Value="Bottom"/>
+        <Setter Property="FontFamily" Value="Segoe UI Symbol"/>
+        <Setter Property="FontWeight" Value="Normal"/>
+        <Setter Property="FontSize" Value="26.66667"/>
+        <Setter Property="AutomationProperties.AutomationId" Value="BackButton"/>
+        <Setter Property="AutomationProperties.Name" Value="Back"/>
+        <Setter Property="AutomationProperties.ItemType" Value="Navigation Button"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="Button">
+                    <Grid x:Name="RootGrid" Width="36" Height="36" Margin="-3,0,7,33">
+                        <Grid Margin="-1,-1,0,0">
+                            <TextBlock x:Name="BackgroundGlyph" Text="&#xE0D4;" Foreground="{StaticResource BackButtonBackgroundThemeBrush}"/>
+                            <TextBlock x:Name="NormalGlyph" Text="{StaticResource BackButtonSnappedGlyph}" Foreground="{StaticResource BackButtonForegroundThemeBrush}"/>
+                            <TextBlock x:Name="ArrowGlyph" Text="&#xE0C4;" Foreground="{StaticResource BackButtonPressedForegroundThemeBrush}" Opacity="0"/>
+                        </Grid>
+                        <Rectangle
+                            x:Name="FocusVisualWhite"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualWhiteStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="1.5"/>
+                        <Rectangle
+                            x:Name="FocusVisualBlack"
+                            IsHitTestVisible="False"
+                            Stroke="{StaticResource FocusVisualBlackStrokeThemeBrush}"
+                            StrokeEndLineCap="Square"
+                            StrokeDashArray="1,1"
+                            Opacity="0"
+                            StrokeDashOffset="0.5"/>
+
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup x:Name="CommonStates">
+                                <VisualState x:Name="Normal" />
+                                <VisualState x:Name="PointerOver">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonPointerOverBackgroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="NormalGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonPointerOverForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Pressed">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="BackgroundGlyph" Storyboard.TargetProperty="Foreground">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="{StaticResource BackButtonForegroundThemeBrush}"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="ArrowGlyph"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="NormalGlyph"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="0"
+                                            Duration="0"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Disabled">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="RootGrid" Storyboard.TargetProperty="Visibility">
+                                            <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
+                                        </ObjectAnimationUsingKeyFrames>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="FocusStates">
+                                <VisualState x:Name="Focused">
+                                    <Storyboard>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="FocusVisualWhite"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="FocusVisualBlack"
+                                            Storyboard.TargetProperty="Opacity"
+                                            To="1"
+                                            Duration="0"/>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState x:Name="Unfocused" />
+                                <VisualState x:Name="PointerFocused" />
+                            </VisualStateGroup>
+                        </VisualStateManager.VisualStateGroups>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!-- Item templates -->
+
+    <!-- Grid-appropriate 250 pixel square item template as seen in the GroupedItemsPage and ItemsPage -->
+    <DataTemplate x:Key="Standard250x250ItemTemplate">
+        <Grid HorizontalAlignment="Left" Width="250" Height="250">
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}">
+                <Image Source="{Binding Image}" Stretch="UniformToFill" AutomationProperties.Name="{Binding Title}"/>
+            </Border>
+            <StackPanel VerticalAlignment="Bottom" Background="{StaticResource ListViewItemOverlayBackgroundThemeBrush}">
+                <TextBlock Text="{Binding Title}" Foreground="{StaticResource ListViewItemOverlayForegroundThemeBrush}" Style="{StaticResource TitleTextStyle}" Height="60" Margin="15,0,15,0"/>
+                <TextBlock Text="{Binding Subtitle}" Foreground="{StaticResource ListViewItemOverlaySecondaryForegroundThemeBrush}" Style="{StaticResource CaptionTextStyle}" TextWrapping="NoWrap" Margin="15,0,15,10"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!-- Grid-appropriate 500 by 130 pixel item template as seen in the GroupDetailPage -->
+    <DataTemplate x:Key="Standard500x130ItemTemplate">
+        <Grid Height="110" Width="480" Margin="10">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Width="110" Height="110">
+                <Image Source="{Binding Image}" Stretch="UniformToFill" AutomationProperties.Name="{Binding Title}"/>
+            </Border>
+            <StackPanel Grid.Column="1" VerticalAlignment="Top" Margin="10,0,0,0">
+                <TextBlock Text="{Binding Title}" Style="{StaticResource TitleTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Subtitle}" Style="{StaticResource CaptionTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Description}" Style="{StaticResource BodyTextStyle}" MaxHeight="60"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!-- List-appropriate 130 pixel high item template as seen in the SplitPage -->
+    <DataTemplate x:Key="Standard130ItemTemplate">
+        <Grid Height="110" Margin="6">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Width="110" Height="110">
+                <Image Source="{Binding Image}" Stretch="UniformToFill" AutomationProperties.Name="{Binding Title}"/>
+            </Border>
+            <StackPanel Grid.Column="1" VerticalAlignment="Top" Margin="10,0,0,0">
+                <TextBlock Text="{Binding Title}" Style="{StaticResource TitleTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Subtitle}" Style="{StaticResource CaptionTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Description}" Style="{StaticResource BodyTextStyle}" MaxHeight="60"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!--
+        List-appropriate 80 pixel high item template as seen in the SplitPage when Filled, and
+        the following pages when snapped: GroupedItemsPage, GroupDetailPage, and ItemsPage
+    -->
+    <DataTemplate x:Key="Standard80ItemTemplate">
+        <Grid Margin="6">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Width="60" Height="60">
+                <Image Source="{Binding Image}" Stretch="UniformToFill"/>
+            </Border>
+            <StackPanel Grid.Column="1" Margin="10,0,0,0">
+                <TextBlock Text="{Binding Title}" Style="{StaticResource ItemTextStyle}" MaxHeight="40"/>
+                <TextBlock Text="{Binding Subtitle}" Style="{StaticResource CaptionTextStyle}" TextWrapping="NoWrap"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!-- Grid-appropriate 300 by 70 pixel item template as seen in the SearchResultsPage -->
+    <DataTemplate x:Key="StandardSmallIcon300x70ItemTemplate">
+        <Grid Width="294" Margin="6">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Margin="0,0,0,10" Width="40" Height="40">
+                <Image Source="{Binding Image}" Stretch="UniformToFill"/>
+            </Border>
+            <StackPanel Grid.Column="1" Margin="10,-10,0,0">
+                <TextBlock Text="{Binding Title}" Style="{StaticResource BodyTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Subtitle}" Style="{StaticResource BodyTextStyle}" Foreground="{StaticResource ApplicationSecondaryForegroundThemeBrush}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Description}" Style="{StaticResource BodyTextStyle}" Foreground="{StaticResource ApplicationSecondaryForegroundThemeBrush}" TextWrapping="NoWrap"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!-- List-appropriate 70 pixel high item template as seen in the SearchResultsPage when Snapped -->
+    <DataTemplate x:Key="StandardSmallIcon70ItemTemplate">
+        <Grid Margin="6">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Border Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Margin="0,0,0,10" Width="40" Height="40">
+                <Image Source="{Binding Image}" Stretch="UniformToFill"/>
+            </Border>
+            <StackPanel Grid.Column="1" Margin="10,-10,0,0">
+                <TextBlock Text="{Binding Title}" Style="{StaticResource BodyTextStyle}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Subtitle}" Style="{StaticResource BodyTextStyle}" Foreground="{StaticResource ApplicationSecondaryForegroundThemeBrush}" TextWrapping="NoWrap"/>
+                <TextBlock Text="{Binding Description}" Style="{StaticResource BodyTextStyle}" Foreground="{StaticResource ApplicationSecondaryForegroundThemeBrush}" TextWrapping="NoWrap"/>
+            </StackPanel>
+        </Grid>
+    </DataTemplate>
+
+    <!--
+      190x130 pixel item template for displaying file previews as seen in the FileOpenPickerPage
+      Includes an elaborate tooltip to display title and description text
+  -->
+    <DataTemplate x:Key="StandardFileWithTooltip190x130ItemTemplate">
+        <Grid>
+            <Grid Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}">
+                <Image
+                    Source="{Binding Image}"
+                    Width="190"
+                    Height="130"
+                    HorizontalAlignment="Center"
+                    VerticalAlignment="Center"
+                    Stretch="Uniform"/>
+            </Grid>
+            <ToolTipService.Placement>Mouse</ToolTipService.Placement>
+            <ToolTipService.ToolTip>
+                <ToolTip>
+                    <ToolTip.Style>
+                        <Style TargetType="ToolTip">
+                            <Setter Property="BorderBrush" Value="{StaticResource ToolTipBackgroundThemeBrush}" />
+                            <Setter Property="Padding" Value="0" />
+                        </Style>
+                    </ToolTip.Style>
+
+                    <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="Auto"/>
+                            <ColumnDefinition Width="*"/>
+                        </Grid.ColumnDefinitions>
+
+                        <Grid Background="{StaticResource ListViewItemPlaceholderBackgroundThemeBrush}" Margin="20">
+                            <Image
+                                Source="{Binding Image}"
+                                Width="160"
+                                Height="160"
+                                HorizontalAlignment="Center"
+                                VerticalAlignment="Center"
+                                Stretch="Uniform"/>
+                        </Grid>
+                        <StackPanel Width="200" Grid.Column="1" Margin="0,20,20,20">
+                            <TextBlock Text="{Binding Title}" TextWrapping="NoWrap" Style="{StaticResource BodyTextStyle}"/>
+                            <TextBlock Text="{Binding Description}" MaxHeight="140" Foreground="{StaticResource ApplicationSecondaryForegroundThemeBrush}" Style="{StaticResource BodyTextStyle}"/>
+                        </StackPanel>
+                    </Grid>
+                </ToolTip>
+            </ToolTipService.ToolTip>
+        </Grid>
+    </DataTemplate>
+
+    <!-- ScrollViewer styles -->
+
+    <Style x:Key="HorizontalScrollViewerStyle" TargetType="ScrollViewer">
+        <Setter Property="HorizontalScrollBarVisibility" Value="Auto"/>
+        <Setter Property="VerticalScrollBarVisibility" Value="Disabled"/>
+        <Setter Property="ScrollViewer.HorizontalScrollMode" Value="Enabled" />
+        <Setter Property="ScrollViewer.VerticalScrollMode" Value="Disabled" />
+        <Setter Property="ScrollViewer.ZoomMode" Value="Disabled" />
+    </Style>
+
+    <Style x:Key="VerticalScrollViewerStyle" TargetType="ScrollViewer">
+        <Setter Property="HorizontalScrollBarVisibility" Value="Disabled"/>
+        <Setter Property="VerticalScrollBarVisibility" Value="Auto"/>
+        <Setter Property="ScrollViewer.HorizontalScrollMode" Value="Disabled" />
+        <Setter Property="ScrollViewer.VerticalScrollMode" Value="Enabled" />
+        <Setter Property="ScrollViewer.ZoomMode" Value="Disabled" />
+    </Style>
+
+    <!-- Page layout roots typically use entrance animations and a theme-appropriate background color -->
+
+    <Style x:Key="LayoutRootStyle" TargetType="Panel">
+        <Setter Property="Background" Value="{StaticResource ApplicationPageBackgroundThemeBrush}"/>
+        <Setter Property="ChildrenTransitions">
+            <Setter.Value>
+                <TransitionCollection>
+                    <EntranceThemeTransition/>
+                </TransitionCollection>
+            </Setter.Value>
+        </Setter>
+    </Style>
+</ResourceDictionary>
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/MainPage.xaml b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/MainPage.xaml
new file mode 100644
index 00000000..86db7b82
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/MainPage.xaml
@@ -0,0 +1,23 @@
+<Page
+    x:Class="OcvImageProcessing.MainPage"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:OcvImageProcessing"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    mc:Ignorable="d">
+
+    <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
+        <Image x:Name="PreviewWidget" HorizontalAlignment="Left" Height="512" Margin="10,10,0,0" VerticalAlignment="Top" Width="512"/>
+        <Button Content="Apply" HorizontalAlignment="Left" Margin="527,71,0,0" VerticalAlignment="Top" Width="293" Height="63" Click="Button_Click"/>
+        <ComboBox x:Name="FilterTypeWidget" HorizontalAlignment="Left" Margin="527,10,0,0" VerticalAlignment="Top" Width="293" Height="56" SelectedIndex="0">
+            <ComboBoxItem Content="Preview"/>
+            <ComboBoxItem Content="GrayScale"/>
+            <ComboBoxItem Content="Canny"/>
+            <ComboBoxItem Content="Blur"/>
+            <ComboBoxItem Content="Features"/>
+            <ComboBoxItem Content="Sepia"/>
+        </ComboBox>
+
+    </Grid>
+</Page>
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/MainPage.xaml.cpp b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/MainPage.xaml.cpp
new file mode 100644
index 00000000..d4152173
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/MainPage.xaml.cpp
@@ -0,0 +1,268 @@
+//
+// MainPage.xaml.cpp
+// Implementation of the MainPage class.
+//
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+#include <ppltasks.h>
+#include <wrl\client.h>
+#include <Robuffer.h>
+#include <vector>
+#include <opencv2\imgproc\types_c.h>
+#include <opencv2\imgcodecs.hpp>
+#include <opencv2\core.hpp>
+
+#include <windows.storage.h>
+
+using namespace OcvImageProcessing;
+
+using namespace Microsoft::WRL;
+using namespace concurrency;
+using namespace Platform;
+using namespace Windows::Foundation;
+using namespace Windows::Storage::Streams;
+using namespace Windows::Storage;
+using namespace Windows::UI::Xaml::Media::Imaging;
+using namespace Windows::Graphics::Imaging;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Controls::Primitives;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Navigation;
+
+Uri^ InputImageUri = ref new Uri(L"ms-appx:///Assets/Lena.png");
+
+// The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=234238
+
+MainPage::MainPage()
+{
+    InitializeComponent();
+
+#ifdef __OPENCV_IMGCODECS_HPP__
+
+    // Image loading OpenCV way ... way more simple
+    cv::Mat image = cv::imread("Assets/Lena.png");
+    Lena = cv::Mat(image.rows, image.cols, CV_8UC4);
+    cvtColor(image, Lena, COLOR_BGR2BGRA);
+    UpdateImage(Lena);
+
+#else
+
+    // Image loading WinRT way
+    RandomAccessStreamReference^ streamRef = RandomAccessStreamReference::CreateFromUri(InputImageUri);
+
+    task<IRandomAccessStreamWithContentType^> (streamRef->OpenReadAsync()).
+    then([](task<IRandomAccessStreamWithContentType^> thisTask)
+    {
+        IRandomAccessStreamWithContentType^ fileStream = thisTask.get();
+        return BitmapDecoder::CreateAsync(fileStream);
+    }).
+    then([](task<BitmapDecoder^> thisTask)
+    {
+        BitmapDecoder^ decoder = thisTask.get();
+        return decoder->GetFrameAsync(0);
+    }).
+    then([this](task<BitmapFrame^> thisTask)
+    {
+        BitmapFrame^ frame = thisTask.get();
+
+        // Save some information as fields
+        frameWidth = frame->PixelWidth;
+        frameHeight = frame->PixelHeight;
+
+        return frame->GetPixelDataAsync();
+    }).
+    then([this](task<PixelDataProvider^> thisTask)
+    {
+        PixelDataProvider^ pixelProvider = thisTask.get();
+        Platform::Array<byte>^ srcPixels = pixelProvider->DetachPixelData();
+        Lena = cv::Mat(frameHeight, frameWidth, CV_8UC4);
+        memcpy(Lena.data, srcPixels->Data, 4*frameWidth*frameHeight);
+        UpdateImage(Lena);
+    });
+
+#endif
+}
+
+/// <summary>
+/// Temporary file creation example. Will be created in WinRT application temporary directory
+/// which usually is "C:\Users\{username}\AppData\Local\Packages\{package_id}\TempState\{random_name}.{suffix}"
+/// </summary>
+/// <param name="suffix">Temporary file suffix, e.g. "tmp"</param>
+std::string OcvImageProcessing::MainPage::CreateTempFile(const std::string &suffix) {
+    return cv::tempfile(suffix.c_str());
+}
+
+/// <summary>
+/// Creating/writing a file in the application local directory
+/// </summary>
+/// <param name="path">Image to save</param>
+bool OcvImageProcessing::MainPage::SaveImage(cv::Mat image) {
+    StorageFolder^ localFolderRT = ApplicationData::Current->LocalFolder;
+    cv::String localFile = ConvertPath(ApplicationData::Current->LocalFolder->Path) + "\\Lena.png";
+
+    return cv::imwrite(localFile, image);
+}
+
+/// <summary>
+/// Getting std::string from managed string via std::wstring.
+/// Provides an example of three ways to do it.
+/// Can't use this one: https://msdn.microsoft.com/en-us/library/bb384865.aspx, not available on WinRT.
+/// </summary>
+/// <param name="path">Path to be converted</param>
+cv::String OcvImageProcessing::MainPage::ConvertPath(Platform::String^ path) {
+    std::wstring localPathW(path->Begin());
+
+    // Opt #1
+    //std::string localPath(localPathW.begin(), localPathW.end());
+
+    // Opt #2
+    //std::string localPath(StrToWStr(localPathW));
+
+    // Opt #3
+    size_t outSize = localPathW.length() + 1;
+    char* localPathC = new char[outSize];
+    size_t charsConverted = 0;
+    wcstombs_s(&charsConverted, localPathC, outSize, localPathW.c_str(), localPathW.length());
+    cv::String localPath(localPathC);
+
+    // Implicit conversion from std::string to cv::String
+    return localPath;
+}
+
+std::string OcvImageProcessing::MainPage::StrToWStr(const std::wstring &input) {
+    if (input.empty()) {
+        return std::string();
+    }
+
+    int size = WideCharToMultiByte(CP_UTF8, 0, &input[0], (int)input.size(), NULL, 0, NULL, NULL);
+    std::string result(size, 0);
+
+    WideCharToMultiByte(CP_UTF8, 0, &input[0], (int)input.size(), &result[0], size, NULL, NULL);
+
+    return result;
+}
+
+/// <summary>
+/// Invoked when this page is about to be displayed in a Frame.
+/// </summary>
+/// <param name="e">Event data that describes how this page was reached.  The Parameter
+/// property is typically used to configure the page.</param>
+void MainPage::OnNavigatedTo(NavigationEventArgs^ e)
+{
+    (void) e;    // Unused parameter
+}
+
+void OcvImageProcessing::MainPage::UpdateImage(const cv::Mat& image)
+{
+    // Create the WriteableBitmap
+    WriteableBitmap^ bitmap = ref new WriteableBitmap(image.cols, image.rows);
+
+    // Get access to the pixels
+    IBuffer^ buffer = bitmap->PixelBuffer;
+    unsigned char* dstPixels;
+
+    // Obtain IBufferByteAccess
+    ComPtr<IBufferByteAccess> pBufferByteAccess;
+    ComPtr<IInspectable> pBuffer((IInspectable*)buffer);
+    pBuffer.As(&pBufferByteAccess);
+
+    // Get pointer to pixel bytes
+    pBufferByteAccess->Buffer(&dstPixels);
+    memcpy(dstPixels, image.data, image.step.buf[1]*image.cols*image.rows);
+
+    // Set the bitmap to the Image element
+    PreviewWidget->Source = bitmap;
+}
+
+
+cv::Mat OcvImageProcessing::MainPage::ApplyGrayFilter(const cv::Mat& image)
+{
+    cv::Mat result;
+    cv::Mat intermediateMat;
+    cv::cvtColor(image, intermediateMat, COLOR_RGBA2GRAY);
+    cv::cvtColor(intermediateMat, result, COLOR_GRAY2BGRA);
+    return result;
+}
+
+cv::Mat OcvImageProcessing::MainPage::ApplyCannyFilter(const cv::Mat& image)
+{
+    cv::Mat result;
+    cv::Mat intermediateMat;
+    cv::Canny(image, intermediateMat, 80, 90);
+    cv::cvtColor(intermediateMat, result, COLOR_GRAY2BGRA);
+    return result;
+}
+
+cv::Mat OcvImageProcessing::MainPage::ApplyBlurFilter(const cv::Mat& image)
+{
+    cv::Mat result;
+    cv::blur(image, result, cv::Size(3,3));
+    return result;
+}
+
+cv::Mat OcvImageProcessing::MainPage::ApplyFindFeaturesFilter(const cv::Mat& image)
+{
+    cv::Mat result;
+    cv::Mat intermediateMat;
+    cv::Ptr<cv::FastFeatureDetector> detector = cv::FastFeatureDetector::create(50);
+    std::vector<cv::KeyPoint> features;
+
+    image.copyTo(result);
+    cv::cvtColor(image, intermediateMat, COLOR_RGBA2GRAY);
+    detector->detect(intermediateMat, features);
+
+    for( unsigned int i = 0; i < std::min(features.size(), (size_t)50); i++ )
+    {
+        const cv::KeyPoint& kp = features[i];
+        cv::circle(result, cv::Point((int)kp.pt.x, (int)kp.pt.y), 10, cv::Scalar(255,0,0,255));
+    }
+
+    return result;
+}
+
+cv::Mat OcvImageProcessing::MainPage::ApplySepiaFilter(const cv::Mat& image)
+{
+    const float SepiaKernelData[16] =
+    {
+        /* B */0.131f, 0.534f, 0.272f, 0.f,
+        /* G */0.168f, 0.686f, 0.349f, 0.f,
+        /* R */0.189f, 0.769f, 0.393f, 0.f,
+        /* A */0.000f, 0.000f, 0.000f, 1.f
+    };
+    const cv::Mat SepiaKernel(4, 4, CV_32FC1, (void*)SepiaKernelData);
+    cv::Mat result;
+    cv::transform(image, result, SepiaKernel);
+    return result;
+}
+
+void OcvImageProcessing::MainPage::Button_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
+{
+    switch(FilterTypeWidget->SelectedIndex)
+    {
+    case PREVIEW:
+        UpdateImage(Lena);
+        break;
+    case GRAY:
+        UpdateImage(ApplyGrayFilter(Lena));
+        break;
+    case CANNY:
+        UpdateImage(ApplyCannyFilter(Lena));
+        break;
+    case BLUR:
+        UpdateImage(ApplyBlurFilter(Lena));
+        break;
+    case FEATURES:
+        UpdateImage(ApplyFindFeaturesFilter(Lena));
+        break;
+    case SEPIA:
+        UpdateImage(ApplySepiaFilter(Lena));
+        break;
+    default:
+        UpdateImage(Lena);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/MainPage.xaml.h b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/MainPage.xaml.h
new file mode 100644
index 00000000..bb7c4c33
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/MainPage.xaml.h
@@ -0,0 +1,51 @@
+//
+// MainPage.xaml.h
+// Declaration of the MainPage class.
+//
+
+#pragma once
+
+#include "MainPage.g.h"
+#include <opencv2\core\core.hpp>
+#include <opencv2\imgproc\imgproc.hpp>
+#include <opencv2\features2d\features2d.hpp>
+
+namespace OcvImageProcessing
+{
+    /// <summary>
+    /// An empty page that can be used on its own or navigated to within a Frame.
+    /// </summary>
+    public ref class MainPage sealed
+    {
+    public:
+        MainPage();
+
+    protected:
+        virtual void OnNavigatedTo(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override;
+
+    private:
+        static const int PREVIEW  = 0;
+        static const int GRAY     = 1;
+        static const int CANNY    = 2;
+        static const int BLUR     = 3;
+        static const int FEATURES = 4;
+        static const int SEPIA    = 5;
+
+        void Button_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+        cv::Mat ApplyGrayFilter(const cv::Mat& image);
+        cv::Mat ApplyCannyFilter(const cv::Mat& image);
+        cv::Mat ApplyBlurFilter(const cv::Mat& image);
+        cv::Mat ApplyFindFeaturesFilter(const cv::Mat& image);
+        cv::Mat ApplySepiaFilter(const cv::Mat& image);
+
+        void UpdateImage(const cv::Mat& image);
+        std::string CreateTempFile(const std::string &suffix);
+        bool SaveImage(cv::Mat image);
+
+        std::string StrToWStr(const std::wstring &wstr);
+        cv::String ConvertPath(Platform::String^ path);
+
+        cv::Mat Lena;
+        unsigned int frameWidth, frameHeight;
+    };
+}
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/OcvImageProcessing.vcxproj b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/OcvImageProcessing.vcxproj
new file mode 100644
index 00000000..888dfca0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/OcvImageProcessing.vcxproj
@@ -0,0 +1,168 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{a5555ea2-f9e8-4078-90f5-d428f2c0d6d1}</ProjectGuid>
+    <RootNamespace>OcvImageProcessing</RootNamespace>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>12.0</MinimumVisualStudioVersion>
+    <AppContainerApplication>true</AppContainerApplication>
+    <ApplicationType>Windows Store</ApplicationType>
+    <ApplicationTypeRevision>8.1</ApplicationTypeRevision>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <PackageCertificateKeyFile>OcvImageProcessing_TemporaryKey.pfx</PackageCertificateKeyFile>
+    <AppxAutoIncrementPackageRevision>False</AppxAutoIncrementPackageRevision>
+    <AppxBundlePlatforms>x86</AppxBundlePlatforms>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453</DisableSpecificWarnings>
+	  <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+	  <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="App.xaml.h">
+      <DependentUpon>App.xaml</DependentUpon>
+    </ClInclude>
+    <ClInclude Include="MainPage.xaml.h">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+    <Page Include="Common\StandardStyles.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="MainPage.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest">
+      <SubType>Designer</SubType>
+    </AppxManifest>
+    <None Include="OcvImageProcessing_TemporaryKey.pfx" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\Lena.png" />
+    <Image Include="Assets\Logo.png" />
+    <Image Include="Assets\SmallLogo.png" />
+    <Image Include="Assets\StoreLogo.png" />
+    <Image Include="Assets\SplashScreen.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="App.xaml.cpp">
+      <DependentUpon>App.xaml</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="MainPage.xaml.cpp">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/OcvImageProcessing.vcxproj.filters b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/OcvImageProcessing.vcxproj.filters
new file mode 100644
index 00000000..15468223
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/OcvImageProcessing.vcxproj.filters
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Common">
+      <UniqueIdentifier>a5555ea2-f9e8-4078-90f5-d428f2c0d6d1</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Assets">
+      <UniqueIdentifier>714bc2d8-fb65-4062-80fa-4d1822fe24e2</UniqueIdentifier>
+    </Filter>
+    <Page Include="Common\StandardStyles.xaml">
+      <Filter>Common</Filter>
+    </Page>
+    <Image Include="Assets\Logo.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SmallLogo.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\StoreLogo.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SplashScreen.png">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="App.xaml.cpp" />
+    <ClCompile Include="MainPage.xaml.cpp" />
+    <ClCompile Include="pch.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="App.xaml.h" />
+    <ClInclude Include="MainPage.xaml.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="OcvImageProcessing_TemporaryKey.pfx" />
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="MainPage.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\Lena.png">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/OcvImageProcessing_TemporaryKey.pfx b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/OcvImageProcessing_TemporaryKey.pfx
new file mode 100644
index 00000000..b7e4c30f
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/OcvImageProcessing_TemporaryKey.pfx differ
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Package.appxmanifest b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Package.appxmanifest
new file mode 100644
index 00000000..19ed89b2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/Package.appxmanifest
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest" xmlns:m2="http://schemas.microsoft.com/appx/2013/manifest">
+  <Identity Name="96635370-3751-48a8-84a6-afd4229cf435" Publisher="CN=dalestam" Version="1.1.0.1" />
+  <Properties>
+    <DisplayName>OcvImageProcessing</DisplayName>
+    <PublisherDisplayName>asmorkalov</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+  <Prerequisites>
+    <OSMinVersion>6.3</OSMinVersion>
+    <OSMaxVersionTested>6.3</OSMaxVersionTested>
+  </Prerequisites>
+  <Resources>
+    <Resource Language="x-generate" />
+  </Resources>
+  <Applications>
+    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="OcvImageProcessing.App">
+      <m2:VisualElements DisplayName="OcvImageProcessing" Description="OcvImageProcessing" BackgroundColor="#464646" ForegroundText="light" Square150x150Logo="Assets\Logo.png" Square30x30Logo="Assets\SmallLogo.png">
+        <m2:DefaultTile>
+          <m2:ShowNameOnTiles>
+            <m2:ShowOn Tile="square150x150Logo" />
+          </m2:ShowNameOnTiles>
+        </m2:DefaultTile>
+        <m2:SplashScreen Image="Assets\SplashScreen.png" />
+      </m2:VisualElements>
+    </Application>
+  </Applications>
+</Package>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/opencv.props b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/opencv.props
new file mode 100644
index 00000000..3931297e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/opencv.props
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros">
+    <OpenCV_Bin>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\bin\</OpenCV_Bin>
+    <OpenCV_Lib>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\lib\</OpenCV_Lib>
+    <OpenCV_Include>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\$(PlatformTarget)\include\</OpenCV_Include>
+    <!--debug suffix for OpenCV dlls and libs -->
+    <DebugSuffix Condition="'$(Configuration)'=='Debug'">d</DebugSuffix>
+    <DebugSuffix Condition="'$(Configuration)'!='Debug'"></DebugSuffix>
+  </PropertyGroup>
+  <ItemGroup>
+    <!--Add required OpenCV dlls here-->
+    <None Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgcodecs300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_features2d300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_flann300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_ml300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+  </ItemGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(OpenCV_Include);$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <!--Add required OpenCV libs here-->
+      <AdditionalDependencies>opencv_core300$(DebugSuffix).lib;opencv_imgproc300$(DebugSuffix).lib;opencv_features2d300$(DebugSuffix).lib;opencv_flann300$(DebugSuffix).lib;opencv_ml300$(DebugSuffix).lib;opencv_imgcodecs300$(DebugSuffix).lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OpenCV_Lib);%(AdditionalLibraryDirectories);</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/pch.cpp b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/pch.cpp
new file mode 100644
index 00000000..01484ff5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/pch.cpp
@@ -0,0 +1,6 @@
+//
+// pch.cpp
+// Include the standard header and generate the precompiled header.
+//
+
+#include "pch.h"
diff --git a/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/pch.h b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/pch.h
new file mode 100644
index 00000000..fadf910d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/OcvImageProcessing/OcvImageProcessing/pch.h
@@ -0,0 +1,9 @@
+//
+// pch.h
+// Header for standard system include files.
+//
+
+#pragma once
+
+#include <collection.h>
+#include "App.xaml.h"
diff --git a/C++/opencv-4.7.0/samples/winrt/readme.txt b/C++/opencv-4.7.0/samples/winrt/readme.txt
new file mode 100644
index 00000000..53c4d7ca
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt/readme.txt
@@ -0,0 +1,6 @@
+Building OpenCV WinRT Samples
+=============================
+
+Samples are created to run against x86 architecture OpenCV binaries.
+
+Please follow the instructions in "platforms/winrt/readme.txt" to generate and build OpenCV for WinRT.
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/App.xaml b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/App.xaml
new file mode 100644
index 00000000..2f1febe3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/App.xaml
@@ -0,0 +1,7 @@
+<Application
+    x:Class="PhoneTutorial.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:PhoneTutorial">
+
+</Application>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/App.xaml.cpp b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/App.xaml.cpp
new file mode 100644
index 00000000..1e2ad733
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/App.xaml.cpp
@@ -0,0 +1,137 @@
+//
+// App.xaml.cpp
+// Implementation of the App class.
+//
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+
+using namespace PhoneTutorial;
+
+using namespace Platform;
+using namespace Windows::ApplicationModel;
+using namespace Windows::ApplicationModel::Activation;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Controls::Primitives;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Interop;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Media::Animation;
+using namespace Windows::UI::Xaml::Navigation;
+
+// The Blank Application template is documented at http://go.microsoft.com/fwlink/?LinkID=391641
+
+/// <summary>
+/// Initializes the singleton application object.  This is the first line of authored code
+/// executed, and as such is the logical equivalent of main() or WinMain().
+/// </summary>
+App::App()
+{
+    InitializeComponent();
+    Suspending += ref new SuspendingEventHandler(this, &App::OnSuspending);
+}
+
+/// <summary>
+/// Invoked when the application is launched normally by the end user. Other entry points
+/// will be used when the application is launched to open a specific file, to display
+/// search results, and so forth.
+/// </summary>
+/// <param name="e">Details about the launch request and process.</param>
+void App::OnLaunched(LaunchActivatedEventArgs^ e)
+{
+#if _DEBUG
+    if (IsDebuggerPresent())
+    {
+        DebugSettings->EnableFrameRateCounter = true;
+    }
+#endif
+
+    auto rootFrame = dynamic_cast<Frame^>(Window::Current->Content);
+
+    // Do not repeat app initialization when the Window already has content,
+    // just ensure that the window is active.
+    if (rootFrame == nullptr)
+    {
+        // Create a Frame to act as the navigation context and associate it with
+        // a SuspensionManager key
+        rootFrame = ref new Frame();
+
+        // TODO: Change this value to a cache size that is appropriate for your application.
+        rootFrame->CacheSize = 1;
+
+        if (e->PreviousExecutionState == ApplicationExecutionState::Terminated)
+        {
+            // TODO: Restore the saved session state only when appropriate, scheduling the
+            // final launch steps after the restore is complete.
+        }
+
+        // Place the frame in the current Window
+        Window::Current->Content = rootFrame;
+    }
+
+    if (rootFrame->Content == nullptr)
+    {
+        // Removes the turnstile navigation for startup.
+        if (rootFrame->ContentTransitions != nullptr)
+        {
+            _transitions = ref new TransitionCollection();
+            for (auto transition : rootFrame->ContentTransitions)
+            {
+                _transitions->Append(transition);
+            }
+        }
+
+        rootFrame->ContentTransitions = nullptr;
+        _firstNavigatedToken = rootFrame->Navigated += ref new NavigatedEventHandler(this, &App::RootFrame_FirstNavigated);
+
+        // When the navigation stack isn't restored navigate to the first page,
+        // configuring the new page by passing required information as a navigation
+        // parameter.
+        if (!rootFrame->Navigate(MainPage::typeid, e->Arguments))
+        {
+            throw ref new FailureException("Failed to create initial page");
+        }
+    }
+
+    // Ensure the current window is active
+    Window::Current->Activate();
+}
+
+/// <summary>
+/// Restores the content transitions after the app has launched.
+/// </summary>
+void App::RootFrame_FirstNavigated(Object^ sender, NavigationEventArgs^ e)
+{
+    auto rootFrame = safe_cast<Frame^>(sender);
+
+    TransitionCollection^ newTransitions;
+    if (_transitions == nullptr)
+    {
+        newTransitions = ref new TransitionCollection();
+        newTransitions->Append(ref new NavigationThemeTransition());
+    }
+    else
+    {
+        newTransitions = _transitions;
+    }
+
+    rootFrame->ContentTransitions = newTransitions;
+    rootFrame->Navigated -= _firstNavigatedToken;
+}
+
+/// <summary>
+/// Invoked when application execution is being suspended. Application state is saved
+/// without knowing whether the application will be terminated or resumed with the contents
+/// of memory still intact.
+/// </summary>
+void App::OnSuspending(Object^ sender, SuspendingEventArgs^ e)
+{
+    (void) sender;	// Unused parameter
+    (void) e;		// Unused parameter
+
+    // TODO: Save application state and stop any background activity
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/App.xaml.h b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/App.xaml.h
new file mode 100644
index 00000000..c9a831cc
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/App.xaml.h
@@ -0,0 +1,29 @@
+//
+// App.xaml.h
+// Declaration of the App class.
+//
+
+#pragma once
+
+#include "App.g.h"
+
+namespace PhoneTutorial
+{
+    /// <summary>
+    /// Provides application-specific behavior to supplement the default Application class.
+    /// </summary>
+    ref class App sealed
+    {
+    public:
+        App();
+
+        virtual void OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ e) override;
+
+    private:
+        Windows::UI::Xaml::Media::Animation::TransitionCollection^ _transitions;
+        Windows::Foundation::EventRegistrationToken _firstNavigatedToken;
+
+        void OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ e);
+        void RootFrame_FirstNavigated(Platform::Object^ sender, Windows::UI::Xaml::Navigation::NavigationEventArgs^ e);
+    };
+}
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/Logo.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/Logo.scale-240.png
new file mode 100644
index 00000000..76921ca9
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/Logo.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/SmallLogo.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/SmallLogo.scale-240.png
new file mode 100644
index 00000000..31663012
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/SmallLogo.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/SplashScreen.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/SplashScreen.scale-240.png
new file mode 100644
index 00000000..33f26b33
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/SplashScreen.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/Square71x71Logo.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/Square71x71Logo.scale-240.png
new file mode 100644
index 00000000..cfa54bee
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/Square71x71Logo.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/StoreLogo.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/StoreLogo.scale-240.png
new file mode 100644
index 00000000..47e084b5
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/StoreLogo.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/WideLogo.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/WideLogo.scale-240.png
new file mode 100644
index 00000000..6249d29d
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Assets/WideLogo.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Lena.png b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Lena.png
new file mode 100644
index 00000000..3e866873
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Lena.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/MainPage.xaml b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/MainPage.xaml
new file mode 100644
index 00000000..428b2fa9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/MainPage.xaml
@@ -0,0 +1,17 @@
+<Page
+    x:Class="PhoneTutorial.MainPage"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:PhoneTutorial"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    mc:Ignorable="d"
+    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
+        <Grid>
+        <StackPanel>
+            <Image x:Name="image" />
+            <Button x:Name="Process" Content="Process" HorizontalAlignment="Center" Click="Process_Click"/>
+            <Button x:Name="Reset" Content="Reset" HorizontalAlignment="Center" Click="Reset_Click"/>
+        </StackPanel>
+    </Grid>
+</Page>
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/MainPage.xaml.cpp b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/MainPage.xaml.cpp
new file mode 100644
index 00000000..77dc9f76
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/MainPage.xaml.cpp
@@ -0,0 +1,122 @@
+//
+// MainPage.xaml.cpp
+// Implementation of the MainPage class.
+//
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+
+#include <opencv2\imgproc\types_c.h>
+#include <opencv2\core.hpp>
+#include <opencv2\imgproc.hpp>
+#include <Robuffer.h>
+#include <ppl.h>
+#include <ppltasks.h>
+
+using namespace PhoneTutorial;
+using namespace Platform;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Controls::Primitives;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Navigation;
+using namespace Windows::UI::Xaml::Media::Imaging;
+using namespace Windows::Storage::Streams;
+using namespace Microsoft::WRL;
+using namespace Windows::ApplicationModel;
+
+MainPage::MainPage()
+{
+    InitializeComponent();
+}
+
+/// <summary>
+/// Invoked when this page is about to be displayed in a Frame.
+/// </summary>
+/// <param name="e">Event data that describes how this page was reached.  The Parameter
+/// property is typically used to configure the page.</param>
+void MainPage::OnNavigatedTo(NavigationEventArgs^ e)
+{
+    (void) e;	// Unused parameter
+    LoadImage();
+}
+
+inline void ThrowIfFailed(HRESULT hr)
+{
+    if (FAILED(hr))
+    {
+        throw Exception::CreateException(hr);
+    }
+}
+
+byte* GetPointerToPixelData(IBuffer^ buffer)
+{
+    // Cast to Object^, then to its underlying IInspectable interface.
+    Object^ obj = buffer;
+    ComPtr<IInspectable> insp(reinterpret_cast<IInspectable*>(obj));
+
+    // Query the IBufferByteAccess interface.
+    ComPtr<IBufferByteAccess> bufferByteAccess;
+    ThrowIfFailed(insp.As(&bufferByteAccess));
+
+    // Retrieve the buffer data.
+    byte* pixels = nullptr;
+    ThrowIfFailed(bufferByteAccess->Buffer(&pixels));
+    return pixels;
+}
+
+void PhoneTutorial::MainPage::Process_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
+{
+    (void) e;	// Unused parameter
+
+    // get the pixels from the WriteableBitmap
+    byte* pPixels = GetPointerToPixelData(m_bitmap->PixelBuffer);
+    int height = m_bitmap->PixelHeight;
+    int width = m_bitmap->PixelWidth;
+
+    // create a matrix the size and type of the image
+    cv::Mat mat(width, height, CV_8UC4);
+    memcpy(mat.data, pPixels, 4 * height*width);
+
+    // convert to grayscale
+    cv::Mat intermediateMat;
+    cv::cvtColor(mat, intermediateMat, COLOR_RGB2GRAY);
+
+    // convert to BGRA
+    cv::cvtColor(intermediateMat, mat, COLOR_GRAY2BGRA);
+
+    // copy processed image back to the WriteableBitmap
+    memcpy(pPixels, mat.data, 4 * height*width);
+
+    // update the WriteableBitmap
+    m_bitmap->Invalidate();
+}
+
+void PhoneTutorial::MainPage::LoadImage()
+{
+    Concurrency::task<Windows::Storage::StorageFile^> getFileTask(Package::Current->InstalledLocation->GetFileAsync(L"Lena.png"));
+
+    auto getStreamTask = getFileTask.then(
+        [](Windows::Storage::StorageFile ^storageFile)
+    {
+        return storageFile->OpenReadAsync();
+    });
+
+    getStreamTask.then(
+        [this](Windows::Storage::Streams::IRandomAccessStreamWithContentType^ stream)
+    {
+        m_bitmap = ref new Windows::UI::Xaml::Media::Imaging::WriteableBitmap(1, 1);
+        m_bitmap->SetSource(stream);
+        image->Source = m_bitmap;
+    });
+}
+
+void PhoneTutorial::MainPage::Reset_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
+{
+    (void) e;	// Unused parameter
+    LoadImage();
+}
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/MainPage.xaml.h b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/MainPage.xaml.h
new file mode 100644
index 00000000..4cc67e35
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/MainPage.xaml.h
@@ -0,0 +1,29 @@
+//
+// MainPage.xaml.h
+// Declaration of the MainPage class.
+//
+
+#pragma once
+
+#include "MainPage.g.h"
+
+namespace PhoneTutorial
+{
+    /// <summary>
+    /// An empty page that can be used on its own or navigated to within a Frame.
+    /// </summary>
+    public ref class MainPage sealed
+    {
+    public:
+        MainPage();
+
+    protected:
+        virtual void OnNavigatedTo(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override;
+    private:
+
+        Windows::UI::Xaml::Media::Imaging::WriteableBitmap^ m_bitmap;
+        void Process_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+        void Reset_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
+        void LoadImage();
+    };
+}
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Package.appxmanifest b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Package.appxmanifest
new file mode 100644
index 00000000..fef1d179
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/Package.appxmanifest
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest" xmlns:m2="http://schemas.microsoft.com/appx/2013/manifest" xmlns:m3="http://schemas.microsoft.com/appx/2014/manifest" xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest">
+  <Identity Name="0a7cc91b-c995-40cf-adf4-b7ac4ba969c6" Publisher="CN=dalestam" Version="1.0.0.0" />
+  <mp:PhoneIdentity PhoneProductId="0a7cc91b-c995-40cf-adf4-b7ac4ba969c6" PhonePublisherId="00000000-0000-0000-0000-000000000000" />
+  <Properties>
+    <DisplayName>PhoneTutorial</DisplayName>
+    <PublisherDisplayName>dalestam</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+  <Prerequisites>
+    <OSMinVersion>6.3.1</OSMinVersion>
+    <OSMaxVersionTested>6.3.1</OSMaxVersionTested>
+  </Prerequisites>
+  <Resources>
+    <Resource Language="x-generate" />
+  </Resources>
+  <Applications>
+    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="PhoneTutorial.App">
+      <m3:VisualElements DisplayName="PhoneTutorial" Square150x150Logo="Assets\Logo.png" Square44x44Logo="Assets\SmallLogo.png" Description="PhoneTutorial" ForegroundText="light" BackgroundColor="transparent">
+        <m3:DefaultTile Wide310x150Logo="Assets\WideLogo.png" Square71x71Logo="Assets\Square71x71Logo.png">
+        </m3:DefaultTile>
+        <m3:SplashScreen Image="Assets\SplashScreen.png" />
+        <m3:ApplicationView MinWidth="width320" />
+        <!--Used in XAML Designer. DO NOT REMOVE-->
+        <m3:InitialRotationPreference>
+          <m3:Rotation Preference="portrait" />
+        </m3:InitialRotationPreference>
+      </m3:VisualElements>
+    </Application>
+  </Applications>
+  <Capabilities>
+    <Capability Name="internetClientServer" />
+  </Capabilities>
+</Package>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/PhoneTutorial.sln b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/PhoneTutorial.sln
new file mode 100644
index 00000000..ddadee17
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/PhoneTutorial.sln
@@ -0,0 +1,32 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PhoneTutorial", "PhoneTutorial.vcxproj", "{8BEFFBBF-DF41-4539-86BC-A84722831035}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM = Debug|ARM
+		Debug|Win32 = Debug|Win32
+		Release|ARM = Release|ARM
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Debug|ARM.ActiveCfg = Debug|ARM
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Debug|ARM.Build.0 = Debug|ARM
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Debug|ARM.Deploy.0 = Debug|ARM
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Debug|Win32.Build.0 = Debug|Win32
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Debug|Win32.Deploy.0 = Debug|Win32
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Release|ARM.ActiveCfg = Release|ARM
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Release|ARM.Build.0 = Release|ARM
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Release|ARM.Deploy.0 = Release|ARM
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Release|Win32.ActiveCfg = Release|Win32
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Release|Win32.Build.0 = Release|Win32
+		{8BEFFBBF-DF41-4539-86BC-A84722831035}.Release|Win32.Deploy.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/PhoneTutorial.vcxproj b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/PhoneTutorial.vcxproj
new file mode 100644
index 00000000..a546b8c4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/PhoneTutorial.vcxproj
@@ -0,0 +1,168 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{8beffbbf-df41-4539-86bc-a84722831035}</ProjectGuid>
+    <RootNamespace>PhoneTutorial</RootNamespace>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>12.0</MinimumVisualStudioVersion>
+    <AppContainerApplication>true</AppContainerApplication>
+    <ApplicationType>Windows Phone</ApplicationType>
+    <ApplicationTypeRevision>8.1</ApplicationTypeRevision>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120_wp81</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120_wp81</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120_wp81</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120_wp81</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LibraryPath>$(ProjectDir)..\..\..\bin\WP\8.1\x86\lib\Debug;$(ProjectDir)..\..\..\bin\WP\8.1\x86\3rdparty\lib\Debug;$(VC_LibraryPath_x86);$(WindowsPhoneSDK_LibraryPath_x86)</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="App.xaml.h">
+      <DependentUpon>App.xaml</DependentUpon>
+    </ClInclude>
+    <ClInclude Include="MainPage.xaml.h">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+    <Page Include="MainPage.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest">
+      <SubType>Designer</SubType>
+    </AppxManifest>
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\Logo.scale-240.png" />
+    <Image Include="Assets\SmallLogo.scale-240.png" />
+    <Image Include="Assets\SplashScreen.scale-240.png" />
+    <Image Include="Assets\Square71x71Logo.scale-240.png" />
+    <Image Include="Assets\StoreLogo.scale-240.png" />
+    <Image Include="Assets\WideLogo.scale-240.png" />
+    <Image Include="Lena.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="App.xaml.cpp">
+      <DependentUpon>App.xaml</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="MainPage.xaml.cpp">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">Create</PrecompiledHeader>
+    </ClCompile>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/PhoneTutorial.vcxproj.filters b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/PhoneTutorial.vcxproj.filters
new file mode 100644
index 00000000..4a21284a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/PhoneTutorial.vcxproj.filters
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Assets">
+      <UniqueIdentifier>8beffbbf-df41-4539-86bc-a84722831035</UniqueIdentifier>
+      <Extensions>bmp;fbx;gif;jpg;jpeg;tga;tiff;tif;png</Extensions>
+    </Filter>
+    <Image Include="Assets\Logo.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SmallLogo.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SplashScreen.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\Square71x71Logo.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\StoreLogo.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\WideLogo.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="App.xaml.cpp" />
+    <ClCompile Include="MainPage.xaml.cpp" />
+    <ClCompile Include="pch.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="App.xaml.h" />
+    <ClInclude Include="MainPage.xaml.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest" />
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="MainPage.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Lena.png">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/opencv.props b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/opencv.props
new file mode 100644
index 00000000..ab4af259
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/opencv.props
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros">
+    <OpenCV_Bin>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\bin\</OpenCV_Bin>
+    <OpenCV_Lib>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\lib\</OpenCV_Lib>
+    <OpenCV_Include>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.1\$(PlatformTarget)\include\</OpenCV_Include>
+    <!--debug suffix for OpenCV dlls and libs -->
+    <DebugSuffix Condition="'$(Configuration)'=='Debug'">d</DebugSuffix>
+    <DebugSuffix Condition="'$(Configuration)'!='Debug'"></DebugSuffix>
+  </PropertyGroup>
+  <ItemGroup>
+    <!--Add required OpenCV dlls here-->
+    <None Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+  </ItemGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(OpenCV_Include);%(AdditionalIncludeDirectories);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <!--Add required OpenCV libs here-->
+      <AdditionalDependencies>opencv_core300$(DebugSuffix).lib;opencv_imgproc300$(DebugSuffix).lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OpenCV_Lib);%(AdditionalLibraryDirectories);</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/pch.cpp b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/pch.cpp
new file mode 100644
index 00000000..01484ff5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/pch.cpp
@@ -0,0 +1,6 @@
+//
+// pch.cpp
+// Include the standard header and generate the precompiled header.
+//
+
+#include "pch.h"
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/pch.h b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/pch.h
new file mode 100644
index 00000000..751c0efb
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/PhoneTutorial/pch.h
@@ -0,0 +1,10 @@
+//
+// pch.h
+// Header for standard system include files.
+//
+
+#pragma once
+
+#include <collection.h>
+#include <ppltasks.h>
+#include "App.xaml.h"
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/VideoCaptureXAML.sln b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/VideoCaptureXAML.sln
new file mode 100644
index 00000000..a489e3b5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/VideoCaptureXAML.sln
@@ -0,0 +1,84 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "video_capture_xaml", "video_capture_xaml", "{D7F9BEB3-65C8-443A-82C6-9D6A5B2B00FC}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "video_capture_xaml.Shared", "video_capture_xaml\video_capture_xaml.Shared\video_capture_xaml.Shared.vcxitems", "{6A274B7F-3982-499E-B55A-1F12EF2E3EC0}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "video_capture_xaml.Windows", "video_capture_xaml\video_capture_xaml.Windows\video_capture_xaml.Windows.vcxproj", "{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "video_capture_xaml.WindowsPhone", "video_capture_xaml\video_capture_xaml.WindowsPhone\video_capture_xaml.WindowsPhone.vcxproj", "{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}"
+EndProject
+Global
+	GlobalSection(SharedMSBuildProjectFiles) = preSolution
+		video_capture_xaml\video_capture_xaml.Shared\video_capture_xaml.Shared.vcxitems*{d7a82e7f-1535-4eec-aba9-2c8447669d33}*SharedItemsImports = 4
+		video_capture_xaml\video_capture_xaml.Shared\video_capture_xaml.Shared.vcxitems*{6a274b7f-3982-499e-b55a-1f12ef2e3ec0}*SharedItemsImports = 9
+		video_capture_xaml\video_capture_xaml.Shared\video_capture_xaml.Shared.vcxitems*{32fdab94-f87e-4f0a-89a4-9ec10a3b1d3d}*SharedItemsImports = 4
+	EndGlobalSection
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM = Debug|ARM
+		Debug|Mixed Platforms = Debug|Mixed Platforms
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|ARM = Release|ARM
+		Release|Mixed Platforms = Release|Mixed Platforms
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|ARM.ActiveCfg = Debug|ARM
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|ARM.Build.0 = Debug|ARM
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|ARM.Deploy.0 = Debug|ARM
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|Mixed Platforms.Deploy.0 = Debug|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|Win32.Build.0 = Debug|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|Win32.Deploy.0 = Debug|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|x64.ActiveCfg = Debug|x64
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|x64.Build.0 = Debug|x64
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Debug|x64.Deploy.0 = Debug|x64
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|ARM.ActiveCfg = Release|ARM
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|ARM.Build.0 = Release|ARM
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|ARM.Deploy.0 = Release|ARM
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|Mixed Platforms.ActiveCfg = Release|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|Mixed Platforms.Build.0 = Release|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|Mixed Platforms.Deploy.0 = Release|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|Win32.ActiveCfg = Release|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|Win32.Build.0 = Release|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|Win32.Deploy.0 = Release|Win32
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|x64.ActiveCfg = Release|x64
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|x64.Build.0 = Release|x64
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D}.Release|x64.Deploy.0 = Release|x64
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Debug|ARM.ActiveCfg = Debug|ARM
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Debug|ARM.Build.0 = Debug|ARM
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Debug|ARM.Deploy.0 = Debug|ARM
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Debug|Mixed Platforms.Deploy.0 = Debug|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Debug|Win32.Build.0 = Debug|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Debug|Win32.Deploy.0 = Debug|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Debug|x64.ActiveCfg = Debug|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Release|ARM.ActiveCfg = Release|ARM
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Release|ARM.Build.0 = Release|ARM
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Release|ARM.Deploy.0 = Release|ARM
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Release|Mixed Platforms.ActiveCfg = Release|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Release|Mixed Platforms.Build.0 = Release|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Release|Mixed Platforms.Deploy.0 = Release|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Release|Win32.ActiveCfg = Release|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Release|Win32.Build.0 = Release|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Release|Win32.Deploy.0 = Release|Win32
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33}.Release|x64.ActiveCfg = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{6A274B7F-3982-499E-B55A-1F12EF2E3EC0} = {D7F9BEB3-65C8-443A-82C6-9D6A5B2B00FC}
+		{32FDAB94-F87E-4F0A-89A4-9EC10A3B1D3D} = {D7F9BEB3-65C8-443A-82C6-9D6A5B2B00FC}
+		{D7A82E7F-1535-4EEC-ABA9-2C8447669D33} = {D7F9BEB3-65C8-443A-82C6-9D6A5B2B00FC}
+	EndGlobalSection
+EndGlobal
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/opencv.props b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/opencv.props
new file mode 100644
index 00000000..4bd1e9ee
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/opencv.props
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros">
+    <Runtime Condition="'$(ApplicationType)'=='Windows Phone'">WP</Runtime>
+    <Runtime Condition="'$(ApplicationType)'=='Windows Store'">WS</Runtime>
+    <OpenCV_Bin>$(OPENCV_WINRT_INSTALL_DIR)\$(Runtime)\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\bin\</OpenCV_Bin>
+    <OpenCV_Lib>$(OPENCV_WINRT_INSTALL_DIR)\$(Runtime)\8.1\$(PlatformTarget)\$(PlatformTarget)\vc12\lib\</OpenCV_Lib>
+    <OpenCV_Include>$(OPENCV_WINRT_INSTALL_DIR)\$(Runtime)\8.1\$(PlatformTarget)\include\</OpenCV_Include>
+    <!--debug suffix for OpenCV dlls and libs -->
+    <DebugSuffix Condition="'$(Configuration)'=='Debug'">d</DebugSuffix>
+    <DebugSuffix Condition="'$(Configuration)'!='Debug'"></DebugSuffix>
+
+</PropertyGroup>
+  <ItemGroup>
+    <!-- Add required OpenCV dlls here-->
+
+    <!-- General-->
+    <None Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_flann300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_features2d300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgcodecs300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+
+    <!-- Video processing -->
+    <None Include="$(OpenCV_Bin)opencv_videoio300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+
+    <!-- Face detection-->
+    <None Include="$(OpenCV_Bin)opencv_objdetect300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_ml300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+  </ItemGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(OpenCV_Include);%(AdditionalIncludeDirectories);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <!--Add required OpenCV libs here-->
+      <AdditionalDependencies>opencv_core300$(DebugSuffix).lib;opencv_imgproc300$(DebugSuffix).lib;opencv_flann300$(DebugSuffix).lib;opencv_videoio300$(DebugSuffix).lib;opencv_features2d300$(DebugSuffix).lib;opencv_objdetect300$(DebugSuffix).lib;opencv_ml300$(DebugSuffix).lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OpenCV_Lib);%(AdditionalLibraryDirectories);</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/App.xaml b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/App.xaml
new file mode 100644
index 00000000..ab25d184
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/App.xaml
@@ -0,0 +1,4 @@
+<Application x:Class="video_capture_xaml.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="using:video_capture_xaml" />
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/App.xaml.cpp b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/App.xaml.cpp
new file mode 100644
index 00000000..1e08d09d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/App.xaml.cpp
@@ -0,0 +1,173 @@
+//
+// App.xaml.cpp
+// Implementation of the App class.
+//
+
+// Copyright (c) Microsoft Open Technologies, Inc.
+// All rights reserved.
+//
+// (3 - clause BSD License)
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted provided that
+// the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
+// following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+// following disclaimer in the documentation and/or other materials provided with the distribution.
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or
+// promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+// PARTICULAR PURPOSE ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT(INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+#include "App.xaml.h"
+
+using namespace video_capture_xaml;
+
+using namespace Platform;
+using namespace Windows::ApplicationModel;
+using namespace Windows::ApplicationModel::Activation;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::UI::Xaml::Media::Animation;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Controls::Primitives;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Interop;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Navigation;
+
+// The Blank Application template is documented at http://go.microsoft.com/fwlink/?LinkId=234227
+
+/// <summary>
+/// Initializes the singleton application object. This is the first line of authored code
+/// executed, and as such is the logical equivalent of main() or WinMain().
+/// </summary>
+App::App()
+{
+    InitializeComponent();
+    Suspending += ref new SuspendingEventHandler(this, &App::OnSuspending);
+    Resuming += ref new Windows::Foundation::EventHandler<Platform::Object ^>(this, &video_capture_xaml::App::OnResuming);
+}
+
+/// <summary>
+/// Invoked when the application is launched normally by the end user. Other entry points
+/// will be used when the application is launched to open a specific file, to display
+/// search results, and so forth.
+/// </summary>
+/// <param name="e">Details about the launch request and process.</param>
+void App::OnLaunched(LaunchActivatedEventArgs^ e)
+{
+#if _DEBUG
+    if (IsDebuggerPresent())
+    {
+        DebugSettings->EnableFrameRateCounter = true;
+    }
+#endif
+
+    auto rootFrame = dynamic_cast<Frame^>(Window::Current->Content);
+
+    // Do not repeat app initialization when the Window already has content,
+    // just ensure that the window is active.
+    if (rootFrame == nullptr)
+    {
+        // Create a Frame to act as the navigation context and associate it with
+        // a SuspensionManager key
+        rootFrame = ref new Frame();
+
+        // TODO: Change this value to a cache size that is appropriate for your application.
+        rootFrame->CacheSize = 1;
+
+        if (e->PreviousExecutionState == ApplicationExecutionState::Terminated)
+        {
+            // TODO: Restore the saved session state only when appropriate, scheduling the
+            // final launch steps after the restore is complete.
+        }
+
+        // Place the frame in the current Window
+        Window::Current->Content = rootFrame;
+    }
+
+    if (rootFrame->Content == nullptr)
+    {
+#if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
+        // Removes the turnstile navigation for startup.
+        if (rootFrame->ContentTransitions != nullptr)
+        {
+            _transitions = ref new TransitionCollection();
+            for (auto transition : rootFrame->ContentTransitions)
+            {
+                _transitions->Append(transition);
+            }
+        }
+
+        rootFrame->ContentTransitions = nullptr;
+        _firstNavigatedToken = rootFrame->Navigated += ref new NavigatedEventHandler(this, &App::RootFrame_FirstNavigated);
+#endif
+
+        // When the navigation stack isn't restored navigate to the first page,
+        // configuring the new page by passing required information as a navigation
+        // parameter.
+        if (!rootFrame->Navigate(MainPage::typeid, e->Arguments))
+        {
+            throw ref new FailureException("Failed to create initial page");
+        }
+    }
+
+    // Ensure the current window is active
+    Window::Current->Activate();
+}
+
+#if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
+/// <summary>
+/// Restores the content transitions after the app has launched.
+/// </summary>
+void App::RootFrame_FirstNavigated(Object^ sender, NavigationEventArgs^ e)
+{
+    auto rootFrame = safe_cast<Frame^>(sender);
+
+    TransitionCollection^ newTransitions;
+    if (_transitions == nullptr)
+    {
+        newTransitions = ref new TransitionCollection();
+        newTransitions->Append(ref new NavigationThemeTransition());
+    }
+    else
+    {
+        newTransitions = _transitions;
+    }
+
+    rootFrame->ContentTransitions = newTransitions;
+
+    rootFrame->Navigated -= _firstNavigatedToken;
+}
+#endif
+
+/// <summary>
+/// Invoked when application execution is being suspended. Application state is saved
+/// without knowing whether the application will be terminated or resumed with the contents
+/// of memory still intact.
+/// </summary>
+void App::OnSuspending(Object^ sender, SuspendingEventArgs^ e)
+{
+    (void) sender;	// Unused parameter
+    (void) e;		// Unused parameter
+
+    // TODO: Save application state and stop any background activity
+}
+
+void video_capture_xaml::App::OnResuming(Platform::Object ^sender, Platform::Object ^args)
+{
+    // throw ref new Platform::NotImplementedException();
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/App.xaml.h b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/App.xaml.h
new file mode 100644
index 00000000..c68e7fab
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/App.xaml.h
@@ -0,0 +1,57 @@
+//
+// App.xaml.h
+// Declaration of the App class.
+//
+
+// Copyright (c) Microsoft Open Technologies, Inc.
+// All rights reserved.
+//
+// (3 - clause BSD License)
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted provided that
+// the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
+// following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+// following disclaimer in the documentation and/or other materials provided with the distribution.
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or
+// promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+// PARTICULAR PURPOSE ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT(INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "App.g.h"
+
+namespace video_capture_xaml
+{
+    /// <summary>
+    /// Provides application-specific behavior to supplement the default Application class.
+    /// </summary>
+    ref class App sealed
+    {
+    public:
+        App();
+
+        virtual void OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ e) override;
+
+    private:
+#if WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
+        Windows::UI::Xaml::Media::Animation::TransitionCollection^ _transitions;
+        Windows::Foundation::EventRegistrationToken _firstNavigatedToken;
+
+        void RootFrame_FirstNavigated(Platform::Object^ sender, Windows::UI::Xaml::Navigation::NavigationEventArgs^ e);
+#endif
+
+        void OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ e);
+        void OnResuming(Platform::Object ^sender, Platform::Object ^args);
+    };
+}
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/main.cpp b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/main.cpp
new file mode 100644
index 00000000..9e673a45
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/main.cpp
@@ -0,0 +1,141 @@
+// main.cpp
+
+// Copyright (c) Microsoft Open Technologies, Inc.
+// All rights reserved.
+//
+// (3 - clause BSD License)
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted provided that
+// the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
+// following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+// following disclaimer in the documentation and/or other materials provided with the distribution.
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or
+// promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+// PARTICULAR PURPOSE ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT(INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#include "pch.h"
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/objdetect.hpp>
+#include <opencv2/features2d.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/videoio/cap_winrt.hpp>
+
+// Switch definitions below to apply different filters
+// TODO: add UX controls to manipulate filters at runtime
+
+//#define COLOR
+#define CANNY
+//#define FACES
+
+using namespace cv;
+
+namespace video_capture_xaml {
+
+    // forward declaration
+    void cvFilterColor(Mat &frame);
+    void cvFilterCanny(Mat &frame);
+    void cvDetectFaces(Mat &frame);
+
+    CascadeClassifier face_cascade;
+    String face_cascade_name = "Assets/haarcascade_frontalface_alt.xml";
+
+    void cvMain()
+    {
+        //initializing frame counter used by face detection logic
+        long frameCounter = 0;
+
+        // loading classifier for face detection
+        face_cascade.load(face_cascade_name);
+
+        // open the default camera
+        VideoCapture cam;
+        cam.open(0);
+
+        Mat frame;
+
+        // process frames
+        while (1)
+        {
+            // get a new frame from camera - this is non-blocking per spec
+            cam >> frame;
+            frameCounter++;
+
+            // don't reprocess the same frame again
+            // if commented then flashing may occur
+            if (!cam.grab()) continue;
+
+            // image processing calculations here
+            // Mat frame is in RGB24 format (8UC3)
+
+            // select processing type
+    #if defined COLOR
+            cvFilterColor(frame);
+    #elif defined CANNY
+            cvFilterCanny(frame);
+    #elif defined FACES
+            // processing every other frame to reduce the load
+            if (frameCounter % 2 == 0) {
+                cvDetectFaces(frame);
+            }
+    #endif
+
+            // important step to get XAML image component updated
+            winrt_imshow();
+        }
+    }
+
+    // image processing example #1
+    // write color bar at row 100 for 200 rows
+    void cvFilterColor(Mat &frame)
+    {
+        auto ar = frame.ptr(100);
+        int bytesPerPixel = 3;
+        int adjust = (int)(((float)30 / 100.0f) * 255.0);
+        for (int i = 0; i < 640 * 100 * bytesPerPixel;)
+        {
+            ar[i++] = adjust;           // R
+            i++;                        // G
+            ar[i++] = 255 - adjust;     // B
+        }
+    }
+
+    // image processing example #2
+    // apply edge detection aka 'canny' filter
+    void cvFilterCanny(Mat &frame)
+    {
+        Mat edges;
+        cvtColor(frame, edges, COLOR_RGB2GRAY);
+        GaussianBlur(edges, edges, Size(7, 7), 1.5, 1.5);
+        Canny(edges, edges, 0, 30, 3);
+        cvtColor(edges, frame, COLOR_GRAY2RGB);
+    }
+
+    // image processing example #3
+    // detect human faces
+    void cvDetectFaces(Mat &frame)
+    {
+        Mat faces;
+        std::vector<cv::Rect> facesColl;
+        cvtColor(frame, faces, COLOR_RGB2GRAY);
+        equalizeHist(faces, faces);
+        face_cascade.detectMultiScale(faces, facesColl, 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, cv::Size(1, 1));
+        for (unsigned int i = 0; i < facesColl.size(); i++)
+        {
+            auto face = facesColl[i];
+            cv::rectangle(frame, face, cv::Scalar(0, 255, 255), 3);
+        }
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/pch.cpp b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/pch.cpp
new file mode 100644
index 00000000..01484ff5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/pch.cpp
@@ -0,0 +1,6 @@
+//
+// pch.cpp
+// Include the standard header and generate the precompiled header.
+//
+
+#include "pch.h"
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/pch.h b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/pch.h
new file mode 100644
index 00000000..2c4354dd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/pch.h
@@ -0,0 +1,11 @@
+//
+// pch.h
+// Header for standard system include files.
+//
+
+#pragma once
+
+#include <collection.h>
+#include <ppltasks.h>
+
+#include "App.xaml.h"
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/video_capture_xaml.Shared.vcxitems b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/video_capture_xaml.Shared.vcxitems
new file mode 100644
index 00000000..ab88eced
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/video_capture_xaml.Shared.vcxitems
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <SharedGUID>98633655-f156-43bb-b452-37cd6a71e3f0</SharedGUID>
+    <ItemsProjectGuid>{6a274b7f-3982-499e-b55a-1f12ef2e3ec0}</ItemsProjectGuid>
+    <ItemsRootNamespace>highgui_xaml</ItemsRootNamespace>
+    <ItemsProjectName>video_capture_xaml.Shared</ItemsProjectName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories);$(MSBuildThisFileDirectory)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="$(MSBuildThisFileDirectory)App.xaml">
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+    <ClCompile Include="$(MSBuildThisFileDirectory)App.xaml.cpp">
+      <DependentUpon>$(MSBuildThisFileDirectory)App.xaml</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="$(MSBuildThisFileDirectory)main.cpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)App.xaml.h">
+      <DependentUpon>$(MSBuildThisFileDirectory)App.xaml</DependentUpon>
+    </ClInclude>
+    <ClCompile Include="$(MSBuildThisFileDirectory)pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+    <ClInclude Include="$(MSBuildThisFileDirectory)pch.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectCapability Include="SourceItemsFromImports" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/video_capture_xaml.Shared.vcxitems.filters b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/video_capture_xaml.Shared.vcxitems.filters
new file mode 100644
index 00000000..2201d842
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Shared/video_capture_xaml.Shared.vcxitems.filters
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <CLCompile Include="$(MSBuildThisFileDirectory)App.xaml.cpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)App.xaml.h" />
+    <CLCompile Include="$(MSBuildThisFileDirectory)pch.cpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)pch.h" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)main.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="$(MSBuildThisFileDirectory)App.xaml" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/Logo.scale-100.png b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/Logo.scale-100.png
new file mode 100644
index 00000000..e26771cb
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/Logo.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/SmallLogo.scale-100.png b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/SmallLogo.scale-100.png
new file mode 100644
index 00000000..1eb0d9d5
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/SmallLogo.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/SplashScreen.scale-100.png b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/SplashScreen.scale-100.png
new file mode 100644
index 00000000..c951e031
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/SplashScreen.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/StoreLogo.scale-100.png b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/StoreLogo.scale-100.png
new file mode 100644
index 00000000..dcb67271
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/StoreLogo.scale-100.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/haarcascade_frontalface_alt.xml b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/haarcascade_frontalface_alt.xml
new file mode 100644
index 00000000..ade4b212
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Assets/haarcascade_frontalface_alt.xml
@@ -0,0 +1,24350 @@
+<?xml version="1.0"?>
+<!--
+    Stump-based 20x20 gentle adaboost frontal face detector.
+    Created by Rainer Lienhart.
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+
+  By downloading, copying, installing or using the software you agree to this license.
+  If you do not agree to this license, do not download, install,
+  copy or use the software.
+
+
+                        Intel License Agreement
+                For Open Source Computer Vision Library
+
+ Copyright (C) 2000, Intel Corporation, all rights reserved.
+ Third party copyrights are property of their respective owners.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+   * Redistribution's of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+   * Redistribution's in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+
+   * The name of Intel Corporation may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+ This software is provided by the copyright holders and contributors "as is" and
+ any express or implied warranties, including, but not limited to, the implied
+ warranties of merchantability and fitness for a particular purpose are disclaimed.
+ In no event shall the Intel Corporation or contributors be liable for any direct,
+ indirect, incidental, special, exemplary, or consequential damages
+ (including, but not limited to, procurement of substitute goods or services;
+ loss of use, data, or profits; or business interruption) however caused
+ and on any theory of liability, whether in contract, strict liability,
+ or tort (including negligence or otherwise) arising in any way out of
+ the use of this software, even if advised of the possibility of such damage.
+-->
+<opencv_storage>
+<cascade type_id="opencv-cascade-classifier"><stageType>BOOST</stageType>
+  <featureType>HAAR</featureType>
+  <height>20</height>
+  <width>20</width>
+  <stageParams>
+    <maxWeakCount>213</maxWeakCount></stageParams>
+  <featureParams>
+    <maxCatCount>0</maxCatCount></featureParams>
+  <stageNum>22</stageNum>
+  <stages>
+    <_>
+      <maxWeakCount>3</maxWeakCount>
+      <stageThreshold>8.2268941402435303e-01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 0 4.0141958743333817e-03</internalNodes>
+          <leafValues>
+            3.3794190734624863e-02 8.3781069517135620e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1 1.5151339583098888e-02</internalNodes>
+          <leafValues>
+            1.5141320228576660e-01 7.4888122081756592e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2 4.2109931819140911e-03</internalNodes>
+          <leafValues>
+            9.0049281716346741e-02 6.3748198747634888e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>16</maxWeakCount>
+      <stageThreshold>6.9566087722778320e+00</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 3 1.6227109590545297e-03</internalNodes>
+          <leafValues>
+            6.9308586418628693e-02 7.1109461784362793e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 4 2.2906649392098188e-03</internalNodes>
+          <leafValues>
+            1.7958030104637146e-01 6.6686922311782837e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 5 5.0025708042085171e-03</internalNodes>
+          <leafValues>
+            1.6936729848384857e-01 6.5540069341659546e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 6 7.9659894108772278e-03</internalNodes>
+          <leafValues>
+            5.8663320541381836e-01 9.1414518654346466e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 7 -3.5227010957896709e-03</internalNodes>
+          <leafValues>
+            1.4131669700145721e-01 6.0318958759307861e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 8 3.6667689681053162e-02</internalNodes>
+          <leafValues>
+            3.6756721138954163e-01 7.9203182458877563e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 9 9.3361474573612213e-03</internalNodes>
+          <leafValues>
+            6.1613857746124268e-01 2.0885099470615387e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 10 8.6961314082145691e-03</internalNodes>
+          <leafValues>
+            2.8362309932708740e-01 6.3602739572525024e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 11 1.1488880263641477e-03</internalNodes>
+          <leafValues>
+            2.2235809266567230e-01 5.8007007837295532e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 12 -2.1484689787030220e-03</internalNodes>
+          <leafValues>
+            2.4064640700817108e-01 5.7870548963546753e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 13 2.1219060290604830e-03</internalNodes>
+          <leafValues>
+            5.5596548318862915e-01 1.3622370362281799e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 14 -9.3949146568775177e-02</internalNodes>
+          <leafValues>
+            8.5027372837066650e-01 4.7177401185035706e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 15 1.3777789426967502e-03</internalNodes>
+          <leafValues>
+            5.9936738014221191e-01 2.8345298767089844e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 16 7.3063157498836517e-02</internalNodes>
+          <leafValues>
+            4.3418860435485840e-01 7.0600342750549316e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 17 3.6767389974556863e-04</internalNodes>
+          <leafValues>
+            3.0278879404067993e-01 6.0515749454498291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 18 -6.0479710809886456e-03</internalNodes>
+          <leafValues>
+            1.7984339594841003e-01 5.6752568483352661e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>21</maxWeakCount>
+      <stageThreshold>9.4985427856445312e+00</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 19 -1.6510689631104469e-02</internalNodes>
+          <leafValues>
+            6.6442251205444336e-01 1.4248579740524292e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 20 2.7052499353885651e-03</internalNodes>
+          <leafValues>
+            6.3253521919250488e-01 1.2884770333766937e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 21 2.8069869149476290e-03</internalNodes>
+          <leafValues>
+            1.2402880191802979e-01 6.1931931972503662e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 22 -1.5402400167658925e-03</internalNodes>
+          <leafValues>
+            1.4321430027484894e-01 5.6700158119201660e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 23 -5.6386279175058007e-04</internalNodes>
+          <leafValues>
+            1.6574330627918243e-01 5.9052079916000366e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 24 1.9253729842603207e-03</internalNodes>
+          <leafValues>
+            2.6955071091651917e-01 5.7388240098953247e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 25 -5.0214841030538082e-03</internalNodes>
+          <leafValues>
+            1.8935389816761017e-01 5.7827740907669067e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 26 2.6365420781075954e-03</internalNodes>
+          <leafValues>
+            2.3093290627002716e-01 5.6954258680343628e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 27 -1.5127769438549876e-03</internalNodes>
+          <leafValues>
+            2.7596020698547363e-01 5.9566420316696167e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 28 -1.0157439857721329e-02</internalNodes>
+          <leafValues>
+            1.7325380444526672e-01 5.5220472812652588e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 29 -1.1953660286962986e-02</internalNodes>
+          <leafValues>
+            1.3394099473953247e-01 5.5590140819549561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 30 4.8859491944313049e-03</internalNodes>
+          <leafValues>
+            3.6287039518356323e-01 6.1888492107391357e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 31 -8.0132916569709778e-02</internalNodes>
+          <leafValues>
+            9.1211050748825073e-02 5.4759448766708374e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 32 1.0643280111253262e-03</internalNodes>
+          <leafValues>
+            3.7151429057121277e-01 5.7113999128341675e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 33 -1.3419450260698795e-03</internalNodes>
+          <leafValues>
+            5.9533137083053589e-01 3.3180978894233704e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 34 -5.4601140320301056e-02</internalNodes>
+          <leafValues>
+            1.8440659344196320e-01 5.6028461456298828e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 35 2.9071690514683723e-03</internalNodes>
+          <leafValues>
+            3.5942441225051880e-01 6.1317151784896851e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 36 7.4718717951327562e-04</internalNodes>
+          <leafValues>
+            5.9943532943725586e-01 3.4595629572868347e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 37 4.3013808317482471e-03</internalNodes>
+          <leafValues>
+            4.1726520657539368e-01 6.9908452033996582e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 38 4.5017572119832039e-03</internalNodes>
+          <leafValues>
+            4.5097151398658752e-01 7.8014570474624634e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 39 2.4138500913977623e-02</internalNodes>
+          <leafValues>
+            5.4382127523422241e-01 1.3198269903659821e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>39</maxWeakCount>
+      <stageThreshold>1.8412969589233398e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 40 1.9212230108678341e-03</internalNodes>
+          <leafValues>
+            1.4152669906616211e-01 6.1998707056045532e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 41 -1.2748669541906565e-04</internalNodes>
+          <leafValues>
+            6.1910742521286011e-01 1.8849289417266846e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 42 5.1409931620582938e-04</internalNodes>
+          <leafValues>
+            1.4873969554901123e-01 5.8579277992248535e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 43 4.1878609918057919e-03</internalNodes>
+          <leafValues>
+            2.7469098567962646e-01 6.3592398166656494e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 44 5.1015717908740044e-03</internalNodes>
+          <leafValues>
+            5.8708512783050537e-01 2.1756289899349213e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 45 -2.1448440384119749e-03</internalNodes>
+          <leafValues>
+            5.8809447288513184e-01 2.9795908927917480e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 46 -2.8977119363844395e-03</internalNodes>
+          <leafValues>
+            2.3733270168304443e-01 5.8766472339630127e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 47 -2.1610679104924202e-02</internalNodes>
+          <leafValues>
+            1.2206549942493439e-01 5.1942020654678345e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 48 -4.6299318782985210e-03</internalNodes>
+          <leafValues>
+            2.6312309503555298e-01 5.8174091577529907e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 49 5.9393711853772402e-04</internalNodes>
+          <leafValues>
+            3.6386200785636902e-01 5.6985449790954590e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 50 5.3878661245107651e-02</internalNodes>
+          <leafValues>
+            4.3035310506820679e-01 7.5593662261962891e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 51 1.8887349870055914e-03</internalNodes>
+          <leafValues>
+            2.1226030588150024e-01 5.6134271621704102e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 52 -2.3635339457541704e-03</internalNodes>
+          <leafValues>
+            5.6318491697311401e-01 2.6427671313285828e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 53 2.4017799645662308e-02</internalNodes>
+          <leafValues>
+            5.7971078157424927e-01 2.7517059445381165e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 54 2.0543030404951423e-04</internalNodes>
+          <leafValues>
+            2.7052420377731323e-01 5.7525688409805298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 55 8.4790197433903813e-04</internalNodes>
+          <leafValues>
+            5.4356247186660767e-01 2.3348769545555115e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 56 1.4091329649090767e-03</internalNodes>
+          <leafValues>
+            5.3194248676300049e-01 2.0631550252437592e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 57 1.4642629539594054e-03</internalNodes>
+          <leafValues>
+            5.4189807176589966e-01 3.0688610672950745e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 58 1.6352549428120255e-03</internalNodes>
+          <leafValues>
+            3.6953729391098022e-01 6.1128681898117065e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 59 8.3172752056270838e-04</internalNodes>
+          <leafValues>
+            3.5650369524955750e-01 6.0252362489700317e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 60 -2.0998890977352858e-03</internalNodes>
+          <leafValues>
+            1.9139820337295532e-01 5.3628271818161011e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 61 -7.4213981861248612e-04</internalNodes>
+          <leafValues>
+            3.8355550169944763e-01 5.5293101072311401e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 62 3.2655049581080675e-03</internalNodes>
+          <leafValues>
+            4.3128961324691772e-01 7.1018958091735840e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 63 8.9134991867467761e-04</internalNodes>
+          <leafValues>
+            3.9848309755325317e-01 6.3919639587402344e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 64 -1.5284179709851742e-02</internalNodes>
+          <leafValues>
+            2.3667329549789429e-01 5.4337137937545776e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 65 4.8381411470472813e-03</internalNodes>
+          <leafValues>
+            5.8175009489059448e-01 3.2391890883445740e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 66 -9.1093179071322083e-04</internalNodes>
+          <leafValues>
+            5.5405938625335693e-01 2.9118689894676208e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 67 -6.1275060288608074e-03</internalNodes>
+          <leafValues>
+            1.7752550542354584e-01 5.1966291666030884e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 68 -4.4576259097084403e-04</internalNodes>
+          <leafValues>
+            3.0241701006889343e-01 5.5335938930511475e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 69 2.2646540775895119e-02</internalNodes>
+          <leafValues>
+            4.4149309396743774e-01 6.9753772020339966e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 70 -1.8804960418492556e-03</internalNodes>
+          <leafValues>
+            2.7913948893547058e-01 5.4979521036148071e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 71 7.0889107882976532e-03</internalNodes>
+          <leafValues>
+            5.2631992101669312e-01 2.3855470120906830e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 72 1.7318050377070904e-03</internalNodes>
+          <leafValues>
+            4.3193790316581726e-01 6.9836008548736572e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 73 -6.8482700735330582e-03</internalNodes>
+          <leafValues>
+            3.0820429325103760e-01 5.3909200429916382e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 74 -1.5062530110299122e-05</internalNodes>
+          <leafValues>
+            5.5219221115112305e-01 3.1203660368919373e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 75 2.9475569725036621e-02</internalNodes>
+          <leafValues>
+            5.4013228416442871e-01 1.7706030607223511e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 76 8.1387329846620560e-03</internalNodes>
+          <leafValues>
+            5.1786178350448608e-01 1.2110190093517303e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 77 2.0942950621247292e-02</internalNodes>
+          <leafValues>
+            5.2902942895889282e-01 3.3112218976020813e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 78 -9.5665529370307922e-03</internalNodes>
+          <leafValues>
+            7.4719941616058350e-01 4.4519689679145813e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>33</maxWeakCount>
+      <stageThreshold>1.5324139595031738e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 79 -2.8206960996612906e-04</internalNodes>
+          <leafValues>
+            2.0640860497951508e-01 6.0767322778701782e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 80 1.6790600493550301e-03</internalNodes>
+          <leafValues>
+            5.8519971370697021e-01 1.2553839385509491e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 81 6.9827912375330925e-04</internalNodes>
+          <leafValues>
+            9.4018429517745972e-02 5.7289612293243408e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 82 7.8959012171253562e-04</internalNodes>
+          <leafValues>
+            1.7819879949092865e-01 5.6943088769912720e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 83 -2.8560499195009470e-03</internalNodes>
+          <leafValues>
+            1.6383990645408630e-01 5.7886648178100586e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 84 -3.8122469559311867e-03</internalNodes>
+          <leafValues>
+            2.0854400098323822e-01 5.5085647106170654e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 85 1.5896620461717248e-03</internalNodes>
+          <leafValues>
+            5.7027608156204224e-01 1.8572150170803070e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 86 1.0078339837491512e-02</internalNodes>
+          <leafValues>
+            5.1169431209564209e-01 2.1897700428962708e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 87 -6.3526302576065063e-02</internalNodes>
+          <leafValues>
+            7.1313798427581787e-01 4.0438130497932434e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 88 -9.1031491756439209e-03</internalNodes>
+          <leafValues>
+            2.5671818852424622e-01 5.4639732837677002e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 89 -2.4035000242292881e-03</internalNodes>
+          <leafValues>
+            1.7006659507751465e-01 5.5909740924835205e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 90 1.5226360410451889e-03</internalNodes>
+          <leafValues>
+            5.4105567932128906e-01 2.6190540194511414e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 91 1.7997439950704575e-02</internalNodes>
+          <leafValues>
+            3.7324368953704834e-01 6.5352207422256470e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 92 -6.4538191072642803e-03</internalNodes>
+          <leafValues>
+            2.6264819502830505e-01 5.5374461412429810e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 93 -1.1880760081112385e-02</internalNodes>
+          <leafValues>
+            2.0037539303302765e-01 5.5447459220886230e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 94 1.2713660253211856e-03</internalNodes>
+          <leafValues>
+            5.5919027328491211e-01 3.0319759249687195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 95 1.1376109905540943e-03</internalNodes>
+          <leafValues>
+            2.7304071187973022e-01 5.6465089321136475e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 96 -4.2651998810470104e-03</internalNodes>
+          <leafValues>
+            1.4059090614318848e-01 5.4618209600448608e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 97 -2.9602861031889915e-03</internalNodes>
+          <leafValues>
+            1.7950350046157837e-01 5.4592901468276978e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 98 -8.8448226451873779e-03</internalNodes>
+          <leafValues>
+            5.7367831468582153e-01 2.8092199563980103e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 99 -6.6430689767003059e-03</internalNodes>
+          <leafValues>
+            2.3706759512424469e-01 5.5038261413574219e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 100 3.9997808635234833e-03</internalNodes>
+          <leafValues>
+            5.6081998348236084e-01 3.3042821288108826e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 101 -4.1221720166504383e-03</internalNodes>
+          <leafValues>
+            1.6401059925556183e-01 5.3789931535720825e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 102 1.5624909661710262e-02</internalNodes>
+          <leafValues>
+            5.2276492118835449e-01 2.2886039316654205e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 103 -1.0356419719755650e-02</internalNodes>
+          <leafValues>
+            7.0161938667297363e-01 4.2529278993606567e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 104 -8.7960809469223022e-03</internalNodes>
+          <leafValues>
+            2.7673470973968506e-01 5.3558301925659180e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 105 1.6226939857006073e-01</internalNodes>
+          <leafValues>
+            4.3422400951385498e-01 7.4425792694091797e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 106 4.5542530715465546e-03</internalNodes>
+          <leafValues>
+            5.7264858484268188e-01 2.5821250677108765e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 107 -2.1309209987521172e-03</internalNodes>
+          <leafValues>
+            2.1068480610847473e-01 5.3610187768936157e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 108 -1.3208420015871525e-02</internalNodes>
+          <leafValues>
+            7.5937908887863159e-01 4.5524680614471436e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 109 -6.5996676683425903e-02</internalNodes>
+          <leafValues>
+            1.2524759769439697e-01 5.3440397977828979e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 110 7.9142656177282333e-03</internalNodes>
+          <leafValues>
+            3.3153840899467468e-01 5.6010431051254272e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 111 2.0894279703497887e-02</internalNodes>
+          <leafValues>
+            5.5060499906539917e-01 2.7688381075859070e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>44</maxWeakCount>
+      <stageThreshold>2.1010639190673828e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 112 1.1961159761995077e-03</internalNodes>
+          <leafValues>
+            1.7626909911632538e-01 6.1562412977218628e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 113 -1.8679830245673656e-03</internalNodes>
+          <leafValues>
+            6.1181068420410156e-01 1.8323999643325806e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 114 -1.9579799845814705e-04</internalNodes>
+          <leafValues>
+            9.9044263362884521e-02 5.7238161563873291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 115 -8.0255657667294145e-04</internalNodes>
+          <leafValues>
+            5.5798798799514771e-01 2.3772829771041870e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 116 -2.4510810617357492e-03</internalNodes>
+          <leafValues>
+            2.2314579784870148e-01 5.8589351177215576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 117 5.0361850298941135e-04</internalNodes>
+          <leafValues>
+            2.6539939641952515e-01 5.7941037416458130e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 118 4.0293349884450436e-03</internalNodes>
+          <leafValues>
+            5.8038270473480225e-01 2.4848650395870209e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 119 -1.4451709575951099e-02</internalNodes>
+          <leafValues>
+            1.8303519487380981e-01 5.4842048883438110e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 120 2.0380979403853416e-03</internalNodes>
+          <leafValues>
+            3.3635589480400085e-01 6.0510927438735962e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 121 -1.6155190533027053e-03</internalNodes>
+          <leafValues>
+            2.2866420447826385e-01 5.4412460327148438e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 122 3.3458340913057327e-03</internalNodes>
+          <leafValues>
+            5.6259131431579590e-01 2.3923380672931671e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 123 1.6379579901695251e-03</internalNodes>
+          <leafValues>
+            3.9069938659667969e-01 5.9646219015121460e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 124 3.0251210555434227e-02</internalNodes>
+          <leafValues>
+            5.2484822273254395e-01 1.5757469832897186e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 125 3.7251990288496017e-02</internalNodes>
+          <leafValues>
+            4.1943109035491943e-01 6.7484188079833984e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 126 -2.5109790265560150e-02</internalNodes>
+          <leafValues>
+            1.8825499713420868e-01 5.4734510183334351e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 127 -5.3099058568477631e-03</internalNodes>
+          <leafValues>
+            1.3399730622768402e-01 5.2271109819412231e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 128 1.2086479691788554e-03</internalNodes>
+          <leafValues>
+            3.7620881199836731e-01 6.1096358299255371e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 129 -2.1907679736614227e-02</internalNodes>
+          <leafValues>
+            2.6631429791450500e-01 5.4040068387985229e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 130 5.4116579703986645e-03</internalNodes>
+          <leafValues>
+            5.3635787963867188e-01 2.2322730720043182e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 131 6.9946326315402985e-02</internalNodes>
+          <leafValues>
+            5.3582328557968140e-01 2.4536980688571930e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 132 3.4520021290518343e-04</internalNodes>
+          <leafValues>
+            2.4096719920635223e-01 5.3769302368164062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 133 1.2627709656953812e-03</internalNodes>
+          <leafValues>
+            5.4258567094802856e-01 3.1556931138038635e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 134 2.2719509899616241e-02</internalNodes>
+          <leafValues>
+            4.1584059596061707e-01 6.5978652238845825e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 135 -1.8111000536009669e-03</internalNodes>
+          <leafValues>
+            2.8112530708312988e-01 5.5052447319030762e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 136 3.3469670452177525e-03</internalNodes>
+          <leafValues>
+            5.2600282430648804e-01 1.8914650380611420e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 137 4.0791751234792173e-04</internalNodes>
+          <leafValues>
+            5.6735092401504517e-01 3.3442100882530212e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 138 1.2734799645841122e-02</internalNodes>
+          <leafValues>
+            5.3435921669006348e-01 2.3956120014190674e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 139 -7.3119727894663811e-03</internalNodes>
+          <leafValues>
+            6.0108900070190430e-01 4.0222078561782837e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 140 -5.6948751211166382e-02</internalNodes>
+          <leafValues>
+            8.1991511583328247e-01 4.5431908965110779e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 141 -5.0116591155529022e-03</internalNodes>
+          <leafValues>
+            2.2002810239791870e-01 5.3577107191085815e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 142 6.0334368608891964e-03</internalNodes>
+          <leafValues>
+            4.4130811095237732e-01 7.1817511320114136e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 143 3.9437441155314445e-03</internalNodes>
+          <leafValues>
+            5.4788607358932495e-01 2.7917331457138062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 144 -3.6591119132936001e-03</internalNodes>
+          <leafValues>
+            6.3578677177429199e-01 3.9897239208221436e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 145 -3.8456181064248085e-03</internalNodes>
+          <leafValues>
+            3.4936860203742981e-01 5.3006649017333984e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 146 -7.1926261298358440e-03</internalNodes>
+          <leafValues>
+            1.1196149885654449e-01 5.2296727895736694e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 147 -5.2798941731452942e-02</internalNodes>
+          <leafValues>
+            2.3871029913425446e-01 5.4534512758255005e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 148 -7.9537667334079742e-03</internalNodes>
+          <leafValues>
+            7.5869178771972656e-01 4.4393768906593323e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 149 -2.7344180271029472e-03</internalNodes>
+          <leafValues>
+            2.5654768943786621e-01 5.4893219470977783e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 150 -1.8507939530536532e-03</internalNodes>
+          <leafValues>
+            6.7343479394912720e-01 4.2524749040603638e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 151 1.5918919816613197e-02</internalNodes>
+          <leafValues>
+            5.4883527755737305e-01 2.2926619648933411e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 152 -1.2687679845839739e-03</internalNodes>
+          <leafValues>
+            6.1043310165405273e-01 4.0223899483680725e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 153 6.2883910723030567e-03</internalNodes>
+          <leafValues>
+            5.3108531236648560e-01 1.5361930429935455e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 154 -6.2259892001748085e-03</internalNodes>
+          <leafValues>
+            1.7291119694709778e-01 5.2416062355041504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 155 -1.2132599949836731e-02</internalNodes>
+          <leafValues>
+            6.5977597236633301e-01 4.3251821398735046e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>50</maxWeakCount>
+      <stageThreshold>2.3918790817260742e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 156 -3.9184908382594585e-03</internalNodes>
+          <leafValues>
+            6.1034351587295532e-01 1.4693309366703033e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 157 1.5971299726516008e-03</internalNodes>
+          <leafValues>
+            2.6323631405830383e-01 5.8964669704437256e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 158 1.7780110239982605e-02</internalNodes>
+          <leafValues>
+            5.8728742599487305e-01 1.7603619396686554e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 159 6.5334769897162914e-04</internalNodes>
+          <leafValues>
+            1.5678019821643829e-01 5.5960661172866821e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 160 -2.8353091329336166e-04</internalNodes>
+          <leafValues>
+            1.9131539762020111e-01 5.7320362329483032e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 161 1.6104689566418529e-03</internalNodes>
+          <leafValues>
+            2.9149138927459717e-01 5.6230807304382324e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 162 -9.7750619053840637e-02</internalNodes>
+          <leafValues>
+            1.9434769451618195e-01 5.6482332944869995e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 163 5.5182358482852578e-04</internalNodes>
+          <leafValues>
+            3.1346169114112854e-01 5.5046397447586060e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 164 -1.2858220376074314e-02</internalNodes>
+          <leafValues>
+            2.5364819169044495e-01 5.7601428031921387e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 165 4.1530239395797253e-03</internalNodes>
+          <leafValues>
+            5.7677221298217773e-01 3.6597740650177002e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 166 1.7092459602281451e-03</internalNodes>
+          <leafValues>
+            2.8431910276412964e-01 5.9189391136169434e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 167 7.5217359699308872e-03</internalNodes>
+          <leafValues>
+            4.0524271130561829e-01 6.1831092834472656e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 168 2.2479810286313295e-03</internalNodes>
+          <leafValues>
+            5.7837551832199097e-01 3.1354010105133057e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 169 5.2006211131811142e-02</internalNodes>
+          <leafValues>
+            5.5413120985031128e-01 1.9166369736194611e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 170 1.2085529975593090e-02</internalNodes>
+          <leafValues>
+            4.0326559543609619e-01 6.6445910930633545e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 171 1.4687820112158079e-05</internalNodes>
+          <leafValues>
+            3.5359779000282288e-01 5.7093828916549683e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 172 7.1395188570022583e-06</internalNodes>
+          <leafValues>
+            3.0374449491500854e-01 5.6102699041366577e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 173 -4.6001640148460865e-03</internalNodes>
+          <leafValues>
+            7.1810871362686157e-01 4.5803260803222656e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 174 2.0058949012309313e-03</internalNodes>
+          <leafValues>
+            5.6219518184661865e-01 2.9536840319633484e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 175 4.5050270855426788e-03</internalNodes>
+          <leafValues>
+            4.6153879165649414e-01 7.6190179586410522e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 176 1.1746830306947231e-02</internalNodes>
+          <leafValues>
+            5.3438371419906616e-01 1.7725290358066559e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 177 -5.8316338807344437e-02</internalNodes>
+          <leafValues>
+            1.6862459480762482e-01 5.3407722711563110e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 178 2.3629379575140774e-04</internalNodes>
+          <leafValues>
+            3.7920561432838440e-01 6.0268038511276245e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 179 -7.8156180679798126e-03</internalNodes>
+          <leafValues>
+            1.5128670632839203e-01 5.3243237733840942e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 180 -1.0876160115003586e-02</internalNodes>
+          <leafValues>
+            2.0818220078945160e-01 5.3199452161788940e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 181 -2.7745519764721394e-03</internalNodes>
+          <leafValues>
+            4.0982469916343689e-01 5.2103281021118164e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 182 -7.8276381827890873e-04</internalNodes>
+          <leafValues>
+            5.6932741403579712e-01 3.4788420796394348e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 183 1.3870409689843655e-02</internalNodes>
+          <leafValues>
+            5.3267508745193481e-01 2.2576980292797089e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 184 -2.3674910888075829e-02</internalNodes>
+          <leafValues>
+            1.5513050556182861e-01 5.2007079124450684e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 185 -1.4879409718560055e-05</internalNodes>
+          <leafValues>
+            5.5005669593811035e-01 3.8201761245727539e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 186 3.6190641112625599e-03</internalNodes>
+          <leafValues>
+            4.2386838793754578e-01 6.6397482156753540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 187 -1.9817110151052475e-02</internalNodes>
+          <leafValues>
+            2.1500380337238312e-01 5.3823578357696533e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 188 -3.8154039066284895e-03</internalNodes>
+          <leafValues>
+            6.6757112741470337e-01 4.2152971029281616e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 189 -4.9775829538702965e-03</internalNodes>
+          <leafValues>
+            2.2672890126705170e-01 5.3863281011581421e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 190 2.2441020701080561e-03</internalNodes>
+          <leafValues>
+            4.3086910247802734e-01 6.8557357788085938e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 191 1.2282459996640682e-02</internalNodes>
+          <leafValues>
+            5.8366149663925171e-01 3.4674790501594543e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 192 -2.8548699337989092e-03</internalNodes>
+          <leafValues>
+            7.0169448852539062e-01 4.3114539980888367e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 193 -3.7875669077038765e-03</internalNodes>
+          <leafValues>
+            2.8953450918197632e-01 5.2249461412429810e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 194 -1.2201230274513364e-03</internalNodes>
+          <leafValues>
+            2.9755708575248718e-01 5.4816448688507080e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 195 1.0160599835216999e-02</internalNodes>
+          <leafValues>
+            4.8888179659843445e-01 8.1826978921890259e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 196 -1.6174569725990295e-02</internalNodes>
+          <leafValues>
+            1.4814929664134979e-01 5.2399927377700806e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 197 1.9292460754513741e-02</internalNodes>
+          <leafValues>
+            4.7863098978996277e-01 7.3781907558441162e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 198 -3.2479539513587952e-03</internalNodes>
+          <leafValues>
+            7.3742228746414185e-01 4.4706439971923828e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 199 -9.3803480267524719e-03</internalNodes>
+          <leafValues>
+            3.4891548752784729e-01 5.5379962921142578e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 200 -1.2606129981577396e-02</internalNodes>
+          <leafValues>
+            2.3796869814395905e-01 5.3154432773590088e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 201 -2.5621930137276649e-02</internalNodes>
+          <leafValues>
+            1.9646880030632019e-01 5.1387697458267212e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 202 -7.5741496402770281e-05</internalNodes>
+          <leafValues>
+            5.5905228853225708e-01 3.3658531308174133e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 203 -8.9210882782936096e-02</internalNodes>
+          <leafValues>
+            6.3404656946659088e-02 5.1626348495483398e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 204 -2.7670480776578188e-03</internalNodes>
+          <leafValues>
+            7.3234677314758301e-01 4.4907060265541077e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 205 2.7152578695677221e-04</internalNodes>
+          <leafValues>
+            4.1148349642753601e-01 5.9855180978775024e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>51</maxWeakCount>
+      <stageThreshold>2.4527879714965820e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 206 1.4786219689995050e-03</internalNodes>
+          <leafValues>
+            2.6635450124740601e-01 6.6433167457580566e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 207 -1.8741659587249160e-03</internalNodes>
+          <leafValues>
+            6.1438488960266113e-01 2.5185129046440125e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 208 -1.7151009524241090e-03</internalNodes>
+          <leafValues>
+            5.7663410902023315e-01 2.3974630236625671e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 209 -1.8939269939437509e-03</internalNodes>
+          <leafValues>
+            5.6820458173751831e-01 2.5291448831558228e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 210 -5.3006052039563656e-03</internalNodes>
+          <leafValues>
+            1.6406759619712830e-01 5.5560797452926636e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 211 -4.6662531793117523e-02</internalNodes>
+          <leafValues>
+            6.1231541633605957e-01 4.7628301382064819e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 212 -7.9431332414969802e-04</internalNodes>
+          <leafValues>
+            5.7078588008880615e-01 2.8394040465354919e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 213 1.4891670085489750e-02</internalNodes>
+          <leafValues>
+            4.0896728634834290e-01 6.0063672065734863e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 214 -1.2046529445797205e-03</internalNodes>
+          <leafValues>
+            5.7124507427215576e-01 2.7052891254425049e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 215 6.0619381256401539e-03</internalNodes>
+          <leafValues>
+            5.2625042200088501e-01 3.2622259855270386e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 216 -2.5286648888140917e-03</internalNodes>
+          <leafValues>
+            6.8538308143615723e-01 4.1992568969726562e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 217 -5.9010218828916550e-03</internalNodes>
+          <leafValues>
+            3.2662820816040039e-01 5.4348129034042358e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 218 5.6702760048210621e-03</internalNodes>
+          <leafValues>
+            5.4684108495712280e-01 2.3190039396286011e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 219 -3.0304100364446640e-03</internalNodes>
+          <leafValues>
+            5.5706679821014404e-01 2.7082380652427673e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 220 2.9803649522364140e-03</internalNodes>
+          <leafValues>
+            3.7005689740180969e-01 5.8906257152557373e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 221 -7.5840510427951813e-02</internalNodes>
+          <leafValues>
+            2.1400700509548187e-01 5.4199481010437012e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 222 1.9262539222836494e-02</internalNodes>
+          <leafValues>
+            5.5267721414566040e-01 2.7265900373458862e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 223 1.8888259364757687e-04</internalNodes>
+          <leafValues>
+            3.9580118656158447e-01 6.0172098875045776e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 224 2.9369549825787544e-02</internalNodes>
+          <leafValues>
+            5.2413737773895264e-01 1.4357580244541168e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 225 1.0417619487270713e-03</internalNodes>
+          <leafValues>
+            3.3854091167449951e-01 5.9299832582473755e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 226 2.6125640142709017e-03</internalNodes>
+          <leafValues>
+            5.4853779077529907e-01 3.0215978622436523e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 227 9.6977467183023691e-04</internalNodes>
+          <leafValues>
+            3.3752760291099548e-01 5.5320328474044800e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 228 5.9512659208849072e-04</internalNodes>
+          <leafValues>
+            5.6317430734634399e-01 3.3593991398811340e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 229 -1.0156559944152832e-01</internalNodes>
+          <leafValues>
+            6.3735038042068481e-02 5.2304250001907349e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 230 3.6156699061393738e-02</internalNodes>
+          <leafValues>
+            5.1369631290435791e-01 1.0295289754867554e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 231 3.4624140243977308e-03</internalNodes>
+          <leafValues>
+            3.8793200254440308e-01 5.5582892894744873e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 232 1.9554980099201202e-02</internalNodes>
+          <leafValues>
+            5.2500867843627930e-01 1.8758599460124969e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 233 -2.3121440317481756e-03</internalNodes>
+          <leafValues>
+            6.6720288991928101e-01 4.6796411275863647e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 234 -1.8605289515107870e-03</internalNodes>
+          <leafValues>
+            7.1633791923522949e-01 4.3346709012985229e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 235 -9.4026362057775259e-04</internalNodes>
+          <leafValues>
+            3.0213609337806702e-01 5.6502032279968262e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 236 -5.2418331615626812e-03</internalNodes>
+          <leafValues>
+            1.8200090527534485e-01 5.2502560615539551e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 237 1.1729019752237946e-04</internalNodes>
+          <leafValues>
+            3.3891880512237549e-01 5.4459732770919800e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 238 1.1878840159624815e-03</internalNodes>
+          <leafValues>
+            4.0853491425514221e-01 6.2535631656646729e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 239 -1.0881359688937664e-02</internalNodes>
+          <leafValues>
+            3.3783990144729614e-01 5.7000827789306641e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 240 1.7354859737679362e-03</internalNodes>
+          <leafValues>
+            4.2046359181404114e-01 6.5230387449264526e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 241 -6.5119052305817604e-03</internalNodes>
+          <leafValues>
+            2.5952160358428955e-01 5.4281437397003174e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 242 -1.2136430013924837e-03</internalNodes>
+          <leafValues>
+            6.1651438474655151e-01 3.9778938889503479e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 243 -1.0354240424931049e-02</internalNodes>
+          <leafValues>
+            1.6280280053615570e-01 5.2195048332214355e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 244 5.5858830455690622e-04</internalNodes>
+          <leafValues>
+            3.1996509432792664e-01 5.5035740137100220e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 245 1.5299649909138680e-02</internalNodes>
+          <leafValues>
+            4.1039940714836121e-01 6.1223882436752319e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 246 -2.1588210016489029e-02</internalNodes>
+          <leafValues>
+            1.0349129885435104e-01 5.1973849534988403e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 247 -1.2834629416465759e-01</internalNodes>
+          <leafValues>
+            8.4938651323318481e-01 4.8931029438972473e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 248 -2.2927189711481333e-03</internalNodes>
+          <leafValues>
+            3.1301578879356384e-01 5.4715752601623535e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 249 7.9915106296539307e-02</internalNodes>
+          <leafValues>
+            4.8563209176063538e-01 6.0739892721176147e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 250 -7.9441092908382416e-02</internalNodes>
+          <leafValues>
+            8.3946740627288818e-01 4.6245330572128296e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 251 -5.2800010889768600e-03</internalNodes>
+          <leafValues>
+            1.8816959857940674e-01 5.3066980838775635e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 252 1.0463109938427806e-03</internalNodes>
+          <leafValues>
+            5.2712291479110718e-01 2.5830659270286560e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 253 2.6317298761568964e-04</internalNodes>
+          <leafValues>
+            4.2353048920631409e-01 5.7354408502578735e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 254 -3.6173160187900066e-03</internalNodes>
+          <leafValues>
+            6.9343960285186768e-01 4.4954448938369751e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 255 1.1421879753470421e-02</internalNodes>
+          <leafValues>
+            5.9009212255477905e-01 4.1381931304931641e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 256 -1.9963278900831938e-03</internalNodes>
+          <leafValues>
+            6.4663827419281006e-01 4.3272399902343750e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>56</maxWeakCount>
+      <stageThreshold>2.7153350830078125e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 257 -9.9691245704889297e-03</internalNodes>
+          <leafValues>
+            6.1423242092132568e-01 2.4822120368480682e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 258 7.3073059320449829e-04</internalNodes>
+          <leafValues>
+            5.7049518823623657e-01 2.3219659924507141e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 259 6.4045301405712962e-04</internalNodes>
+          <leafValues>
+            2.1122519671916962e-01 5.8149331808090210e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 260 4.5424019917845726e-03</internalNodes>
+          <leafValues>
+            2.9504820704460144e-01 5.8663117885589600e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 261 9.2477443104144186e-05</internalNodes>
+          <leafValues>
+            2.9909908771514893e-01 5.7913267612457275e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 262 -8.6603146046400070e-03</internalNodes>
+          <leafValues>
+            2.8130298852920532e-01 5.6355422735214233e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 263 8.0515816807746887e-03</internalNodes>
+          <leafValues>
+            3.5353690385818481e-01 6.0547572374343872e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 264 4.3835240649059415e-04</internalNodes>
+          <leafValues>
+            5.5965322256088257e-01 2.7315109968185425e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 265 -9.8168973636347800e-05</internalNodes>
+          <leafValues>
+            5.9780317544937134e-01 3.6385610699653625e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 266 -1.1298790341243148e-03</internalNodes>
+          <leafValues>
+            2.7552521228790283e-01 5.4327291250228882e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 267 6.4356150105595589e-03</internalNodes>
+          <leafValues>
+            4.3056419491767883e-01 7.0698332786560059e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 268 -5.6829329580068588e-02</internalNodes>
+          <leafValues>
+            2.4952429533004761e-01 5.2949970960617065e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 269 4.0668169967830181e-03</internalNodes>
+          <leafValues>
+            5.4785531759262085e-01 2.4977239966392517e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 270 4.8164798499783501e-05</internalNodes>
+          <leafValues>
+            3.9386010169982910e-01 5.7063561677932739e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 271 6.1795017682015896e-03</internalNodes>
+          <leafValues>
+            4.4076061248779297e-01 7.3947668075561523e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 272 6.4985752105712891e-03</internalNodes>
+          <leafValues>
+            5.4452431201934814e-01 2.4791529774665833e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 273 -1.0211090557277203e-03</internalNodes>
+          <leafValues>
+            2.5447669625282288e-01 5.3389710187911987e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 274 -5.4247528314590454e-03</internalNodes>
+          <leafValues>
+            2.7188581228256226e-01 5.3240692615509033e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 275 -1.0559899965301156e-03</internalNodes>
+          <leafValues>
+            3.1782880425453186e-01 5.5345088243484497e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 276 6.6465808777138591e-04</internalNodes>
+          <leafValues>
+            4.2842191457748413e-01 6.5581941604614258e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 277 -2.7524109464138746e-04</internalNodes>
+          <leafValues>
+            5.9028607606887817e-01 3.8102629780769348e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 278 4.2293202131986618e-03</internalNodes>
+          <leafValues>
+            3.8164898753166199e-01 5.7093858718872070e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 279 -3.2868210691958666e-03</internalNodes>
+          <leafValues>
+            1.7477439343929291e-01 5.2595442533493042e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 280 1.5611879643984139e-04</internalNodes>
+          <leafValues>
+            3.6017221212387085e-01 5.7256120443344116e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 281 -7.3621381488919724e-06</internalNodes>
+          <leafValues>
+            5.4018580913543701e-01 3.0444970726966858e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 282 -1.4767250046133995e-02</internalNodes>
+          <leafValues>
+            3.2207700610160828e-01 5.5734348297119141e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 283 2.4489590898156166e-02</internalNodes>
+          <leafValues>
+            4.3015280365943909e-01 6.5188127756118774e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 284 -3.7652091123163700e-04</internalNodes>
+          <leafValues>
+            3.5645830631256104e-01 5.5982369184494019e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 285 7.3657688517414499e-06</internalNodes>
+          <leafValues>
+            3.4907829761505127e-01 5.5618977546691895e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 286 -1.5099939890205860e-02</internalNodes>
+          <leafValues>
+            1.7762720584869385e-01 5.3352999687194824e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 287 -3.8316650316119194e-03</internalNodes>
+          <leafValues>
+            6.1496877670288086e-01 4.2213940620422363e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 288 1.6925400123000145e-02</internalNodes>
+          <leafValues>
+            5.4130148887634277e-01 2.1665850281715393e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 289 -3.0477850232273340e-03</internalNodes>
+          <leafValues>
+            6.4494907855987549e-01 4.3546178936958313e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 290 3.2140589319169521e-03</internalNodes>
+          <leafValues>
+            5.4001551866531372e-01 3.5232171416282654e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 291 -4.0023201145231724e-03</internalNodes>
+          <leafValues>
+            2.7745240926742554e-01 5.3384172916412354e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 292 7.4182129465043545e-03</internalNodes>
+          <leafValues>
+            5.6767392158508301e-01 3.7028178572654724e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 293 -8.8764587417244911e-03</internalNodes>
+          <leafValues>
+            7.7492219209671021e-01 4.5836889743804932e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 294 2.7311739977449179e-03</internalNodes>
+          <leafValues>
+            5.3387218713760376e-01 3.9966610074043274e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 295 -2.5082379579544067e-03</internalNodes>
+          <leafValues>
+            5.6119632720947266e-01 3.7774989008903503e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 296 -8.0541074275970459e-03</internalNodes>
+          <leafValues>
+            2.9152289032936096e-01 5.1791828870773315e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 297 -9.7938813269138336e-04</internalNodes>
+          <leafValues>
+            5.5364328622817993e-01 3.7001928687095642e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 298 -5.8745909482240677e-03</internalNodes>
+          <leafValues>
+            3.7543910741806030e-01 5.6793761253356934e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 299 -4.4936719350516796e-03</internalNodes>
+          <leafValues>
+            7.0196992158889771e-01 4.4809499382972717e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 300 -5.4389229044318199e-03</internalNodes>
+          <leafValues>
+            2.3103649914264679e-01 5.3133869171142578e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 301 -7.5094640487805009e-04</internalNodes>
+          <leafValues>
+            5.8648687601089478e-01 4.1293430328369141e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 302 1.4528800420521293e-05</internalNodes>
+          <leafValues>
+            3.7324070930480957e-01 5.6196212768554688e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 303 4.0758069604635239e-02</internalNodes>
+          <leafValues>
+            5.3120911121368408e-01 2.7205219864845276e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 304 6.6505931317806244e-03</internalNodes>
+          <leafValues>
+            4.7100159525871277e-01 6.6934937238693237e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 305 4.5759351924061775e-03</internalNodes>
+          <leafValues>
+            5.1678192615509033e-01 1.6372759640216827e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 306 6.5269311890006065e-03</internalNodes>
+          <leafValues>
+            5.3976088762283325e-01 2.9385319352149963e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 307 -1.3660379685461521e-02</internalNodes>
+          <leafValues>
+            7.0864880084991455e-01 4.5322000980377197e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 308 2.7358869090676308e-02</internalNodes>
+          <leafValues>
+            5.2064812183380127e-01 3.5892319679260254e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 309 6.2197551596909761e-04</internalNodes>
+          <leafValues>
+            3.5070759057998657e-01 5.4411232471466064e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 310 -3.3077080734074116e-03</internalNodes>
+          <leafValues>
+            5.8595228195190430e-01 4.0248918533325195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 311 -1.0631109587848186e-02</internalNodes>
+          <leafValues>
+            6.7432671785354614e-01 4.4226029515266418e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 312 1.9441649317741394e-02</internalNodes>
+          <leafValues>
+            5.2827161550521851e-01 1.7979049682617188e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>71</maxWeakCount>
+      <stageThreshold>3.4554111480712891e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 313 -5.5052167735993862e-03</internalNodes>
+          <leafValues>
+            5.9147310256958008e-01 2.6265591382980347e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 314 1.9562279339879751e-03</internalNodes>
+          <leafValues>
+            2.3125819861888885e-01 5.7416272163391113e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 315 -8.8924784213304520e-03</internalNodes>
+          <leafValues>
+            1.6565300524234772e-01 5.6266540288925171e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 316 8.3638377487659454e-02</internalNodes>
+          <leafValues>
+            5.4234498739242554e-01 1.9572949409484863e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 317 1.2282270472496748e-03</internalNodes>
+          <leafValues>
+            3.4179040789604187e-01 5.9925037622451782e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 318 5.7629169896245003e-03</internalNodes>
+          <leafValues>
+            3.7195819616317749e-01 6.0799038410186768e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 319 -1.6417410224676132e-03</internalNodes>
+          <leafValues>
+            2.5774860382080078e-01 5.5769157409667969e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 320 3.4113149158656597e-03</internalNodes>
+          <leafValues>
+            2.9507490992546082e-01 5.5141717195510864e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 321 -1.1069320142269135e-02</internalNodes>
+          <leafValues>
+            7.5693589448928833e-01 4.4770789146423340e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 322 3.4865971654653549e-02</internalNodes>
+          <leafValues>
+            5.5837088823318481e-01 2.6696211099624634e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 323 6.5701099811121821e-04</internalNodes>
+          <leafValues>
+            5.6273132562637329e-01 2.9888901114463806e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 324 -2.4339130148291588e-02</internalNodes>
+          <leafValues>
+            2.7711850404739380e-01 5.1088631153106689e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 325 5.9435202274471521e-04</internalNodes>
+          <leafValues>
+            5.5806517601013184e-01 3.1203418970108032e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 326 2.2971509024500847e-03</internalNodes>
+          <leafValues>
+            3.3302500844001770e-01 5.6790757179260254e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 327 -3.7801829166710377e-03</internalNodes>
+          <leafValues>
+            2.9905349016189575e-01 5.3448081016540527e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 328 -1.3420669734477997e-01</internalNodes>
+          <leafValues>
+            1.4638589322566986e-01 5.3925681114196777e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 329 7.5224548345431685e-04</internalNodes>
+          <leafValues>
+            3.7469539046287537e-01 5.6927347183227539e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 330 -4.0545541793107986e-02</internalNodes>
+          <leafValues>
+            2.7547478675842285e-01 5.4842978715896606e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 331 1.2572970008477569e-03</internalNodes>
+          <leafValues>
+            3.7445840239524841e-01 5.7560759782791138e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 332 -7.4249948374927044e-03</internalNodes>
+          <leafValues>
+            7.5138592720031738e-01 4.7282311320304871e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 333 5.0908129196614027e-04</internalNodes>
+          <leafValues>
+            5.4048967361450195e-01 2.9323211312294006e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 334 -1.2808450264856219e-03</internalNodes>
+          <leafValues>
+            6.1697798967361450e-01 4.2733490467071533e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 335 -1.8348860321566463e-03</internalNodes>
+          <leafValues>
+            2.0484960079193115e-01 5.2064722776412964e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 336 2.7484869584441185e-02</internalNodes>
+          <leafValues>
+            5.2529847621917725e-01 1.6755220293998718e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 337 2.2372419480234385e-03</internalNodes>
+          <leafValues>
+            5.2677828073501587e-01 2.7776581048965454e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 338 -8.8635291904211044e-03</internalNodes>
+          <leafValues>
+            6.9545578956604004e-01 4.8120489716529846e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 339 4.1753971017897129e-03</internalNodes>
+          <leafValues>
+            4.2918878793716431e-01 6.3491958379745483e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 340 -1.7098189564421773e-03</internalNodes>
+          <leafValues>
+            2.9305368661880493e-01 5.3612488508224487e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 341 6.5328548662364483e-03</internalNodes>
+          <leafValues>
+            4.4953250885009766e-01 7.4096941947937012e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 342 -9.5372907817363739e-03</internalNodes>
+          <leafValues>
+            3.1491199135780334e-01 5.4165017604827881e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 343 2.5310989469289780e-02</internalNodes>
+          <leafValues>
+            5.1218920946121216e-01 1.3117079436779022e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 344 3.6460969597101212e-02</internalNodes>
+          <leafValues>
+            5.1759117841720581e-01 2.5913399457931519e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 345 2.0854329690337181e-02</internalNodes>
+          <leafValues>
+            5.1371401548385620e-01 1.5823160111904144e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 346 -8.7207747856155038e-04</internalNodes>
+          <leafValues>
+            5.5743098258972168e-01 4.3989789485931396e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 347 -1.5227000403683633e-05</internalNodes>
+          <leafValues>
+            5.5489408969879150e-01 3.7080699205398560e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 348 -8.4316509310156107e-04</internalNodes>
+          <leafValues>
+            3.3874198794364929e-01 5.5542111396789551e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 349 3.6037859972566366e-03</internalNodes>
+          <leafValues>
+            5.3580617904663086e-01 3.4111711382865906e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 350 -6.8057891912758350e-03</internalNodes>
+          <leafValues>
+            6.1252027750015259e-01 4.3458628654479980e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 351 -4.7021660953760147e-02</internalNodes>
+          <leafValues>
+            2.3581659793853760e-01 5.1937389373779297e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 352 -3.6954108625650406e-02</internalNodes>
+          <leafValues>
+            7.3231112957000732e-01 4.7609439492225647e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 353 1.0439479956403375e-03</internalNodes>
+          <leafValues>
+            5.4194551706314087e-01 3.4113308787345886e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 354 -2.1050689974799752e-04</internalNodes>
+          <leafValues>
+            2.8216940164566040e-01 5.5549472570419312e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 355 -8.0831587314605713e-02</internalNodes>
+          <leafValues>
+            9.1299301385879517e-01 4.6974349021911621e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 356 -3.6579059087671340e-04</internalNodes>
+          <leafValues>
+            6.0226702690124512e-01 3.9782929420471191e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 357 -1.2545920617412776e-04</internalNodes>
+          <leafValues>
+            5.6132131814956665e-01 3.8455399870872498e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 358 -6.8786486983299255e-02</internalNodes>
+          <leafValues>
+            2.2616119682788849e-01 5.3004968166351318e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 359 1.2415789999067783e-02</internalNodes>
+          <leafValues>
+            4.0756919980049133e-01 5.8288121223449707e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 360 -4.7174817882478237e-03</internalNodes>
+          <leafValues>
+            2.8272539377212524e-01 5.2677577733993530e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 361 3.8136858493089676e-02</internalNodes>
+          <leafValues>
+            5.0747412443161011e-01 1.0236159712076187e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 362 -2.8168049175292253e-03</internalNodes>
+          <leafValues>
+            6.1690068244934082e-01 4.3596929311752319e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 363 8.1303603947162628e-03</internalNodes>
+          <leafValues>
+            4.5244330167770386e-01 7.6060950756072998e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 364 6.0056019574403763e-03</internalNodes>
+          <leafValues>
+            5.2404087781906128e-01 1.8597120046615601e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 365 1.9139319658279419e-02</internalNodes>
+          <leafValues>
+            5.2093791961669922e-01 2.3320719599723816e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 366 1.6445759683847427e-02</internalNodes>
+          <leafValues>
+            5.4507029056549072e-01 3.2642349600791931e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 367 -3.7356890738010406e-02</internalNodes>
+          <leafValues>
+            6.9990468025207520e-01 4.5332419872283936e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 368 -1.9727900624275208e-02</internalNodes>
+          <leafValues>
+            2.6536649465560913e-01 5.4128098487854004e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 369 6.6972579807043076e-03</internalNodes>
+          <leafValues>
+            4.4805660843849182e-01 7.1386522054672241e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 370 7.4457528535276651e-04</internalNodes>
+          <leafValues>
+            4.2313501238822937e-01 5.4713201522827148e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 371 1.1790640419349074e-03</internalNodes>
+          <leafValues>
+            5.3417021036148071e-01 3.1304550170898438e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 372 3.4980610013008118e-02</internalNodes>
+          <leafValues>
+            5.1186597347259521e-01 3.4305301308631897e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 373 5.6859792675822973e-04</internalNodes>
+          <leafValues>
+            3.5321870446205139e-01 5.4686397314071655e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 374 -1.1340649798512459e-02</internalNodes>
+          <leafValues>
+            2.8423538804054260e-01 5.3487008810043335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 375 -6.6228108480572701e-03</internalNodes>
+          <leafValues>
+            6.8836402893066406e-01 4.4926649332046509e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 376 -8.0160330981016159e-03</internalNodes>
+          <leafValues>
+            1.7098939418792725e-01 5.2243089675903320e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 377 1.4206819469109178e-03</internalNodes>
+          <leafValues>
+            5.2908462285995483e-01 2.9933831095695496e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 378 -2.7801711112260818e-03</internalNodes>
+          <leafValues>
+            6.4988541603088379e-01 4.4604998826980591e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 379 -1.4747589593753219e-03</internalNodes>
+          <leafValues>
+            3.2604381442070007e-01 5.3881132602691650e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 380 -2.3830339312553406e-02</internalNodes>
+          <leafValues>
+            7.5289410352706909e-01 4.8012199997901917e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 381 6.9369790144264698e-03</internalNodes>
+          <leafValues>
+            5.3351658582687378e-01 3.2614278793334961e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 382 8.2806255668401718e-03</internalNodes>
+          <leafValues>
+            4.5803940296173096e-01 5.7378298044204712e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 383 -1.0439500212669373e-02</internalNodes>
+          <leafValues>
+            2.5923201441764832e-01 5.2338278293609619e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>80</maxWeakCount>
+      <stageThreshold>3.9107288360595703e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 384 7.2006587870419025e-03</internalNodes>
+          <leafValues>
+            3.2588860392570496e-01 6.8498080968856812e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 385 -2.8593589086085558e-03</internalNodes>
+          <leafValues>
+            5.8388811349868774e-01 2.5378298759460449e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 386 6.8580528022721410e-04</internalNodes>
+          <leafValues>
+            5.7080817222595215e-01 2.8124240040779114e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 387 7.9580191522836685e-03</internalNodes>
+          <leafValues>
+            2.5010511279106140e-01 5.5442607402801514e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 388 -1.2124150525778532e-03</internalNodes>
+          <leafValues>
+            2.3853680491447449e-01 5.4333502054214478e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 389 7.9426132142543793e-03</internalNodes>
+          <leafValues>
+            3.9550709724426270e-01 6.2207579612731934e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 390 2.4630590341985226e-03</internalNodes>
+          <leafValues>
+            5.6397080421447754e-01 2.9923579096794128e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 391 -6.0396599583327770e-03</internalNodes>
+          <leafValues>
+            2.1865129470825195e-01 5.4116767644882202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 392 -1.2988339876756072e-03</internalNodes>
+          <leafValues>
+            2.3507060110569000e-01 5.3645849227905273e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 393 2.2299369447864592e-04</internalNodes>
+          <leafValues>
+            3.8041129708290100e-01 5.7296061515808105e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 394 1.4654280385002494e-03</internalNodes>
+          <leafValues>
+            2.5101679563522339e-01 5.2582687139511108e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 395 -8.1210042117163539e-04</internalNodes>
+          <leafValues>
+            5.9928238391876221e-01 3.8511589169502258e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 396 -1.3836020370945334e-03</internalNodes>
+          <leafValues>
+            5.6813961267471313e-01 3.6365869641304016e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 397 -2.7936449274420738e-02</internalNodes>
+          <leafValues>
+            1.4913170039653778e-01 5.3775602579116821e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 398 -4.6919551095925272e-04</internalNodes>
+          <leafValues>
+            3.6924299597740173e-01 5.5724847316741943e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 399 -4.9829659983515739e-03</internalNodes>
+          <leafValues>
+            6.7585092782974243e-01 4.5325040817260742e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 400 1.8815309740602970e-03</internalNodes>
+          <leafValues>
+            5.3680229187011719e-01 2.9325398802757263e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 401 -1.9067550078034401e-02</internalNodes>
+          <leafValues>
+            1.6493770480155945e-01 5.3300672769546509e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 402 -4.6906559728085995e-03</internalNodes>
+          <leafValues>
+            1.9639259576797485e-01 5.1193618774414062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 403 5.9777139686048031e-03</internalNodes>
+          <leafValues>
+            4.6711719036102295e-01 7.0083981752395630e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 404 -3.3303130418062210e-02</internalNodes>
+          <leafValues>
+            1.1554169654846191e-01 5.1041620969772339e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 405 9.0744107961654663e-02</internalNodes>
+          <leafValues>
+            5.1496601104736328e-01 1.3061730563640594e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 406 9.3555898638442159e-04</internalNodes>
+          <leafValues>
+            3.6054810881614685e-01 5.4398590326309204e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 407 1.4901650138199329e-02</internalNodes>
+          <leafValues>
+            4.8862120509147644e-01 7.6875698566436768e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 408 6.1594118596985936e-04</internalNodes>
+          <leafValues>
+            5.3568130731582642e-01 3.2409390807151794e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 409 -5.0670988857746124e-02</internalNodes>
+          <leafValues>
+            1.8486219644546509e-01 5.2304041385650635e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 410 6.8665749859064817e-04</internalNodes>
+          <leafValues>
+            3.8405799865722656e-01 5.5179458856582642e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 411 8.3712432533502579e-03</internalNodes>
+          <leafValues>
+            4.2885640263557434e-01 6.1317539215087891e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 412 -1.2953069526702166e-03</internalNodes>
+          <leafValues>
+            2.9136741161346436e-01 5.2807378768920898e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 413 -4.1941680014133453e-02</internalNodes>
+          <leafValues>
+            7.5547999143600464e-01 4.8560309410095215e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 414 -2.3529380559921265e-02</internalNodes>
+          <leafValues>
+            2.8382799029350281e-01 5.2560812234878540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 415 4.0857449173927307e-02</internalNodes>
+          <leafValues>
+            4.8709350824356079e-01 6.2772971391677856e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 416 -2.5406869128346443e-02</internalNodes>
+          <leafValues>
+            7.0997077226638794e-01 4.5750290155410767e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 417 -4.1415440500713885e-04</internalNodes>
+          <leafValues>
+            4.0308868885040283e-01 5.4694122076034546e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 418 2.1824119612574577e-02</internalNodes>
+          <leafValues>
+            4.5020240545272827e-01 6.7687010765075684e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 419 1.4114039950072765e-02</internalNodes>
+          <leafValues>
+            5.4428607225418091e-01 3.7917000055313110e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 420 6.7214590671937913e-05</internalNodes>
+          <leafValues>
+            4.2004638910293579e-01 5.8734762668609619e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 421 -7.9417638480663300e-03</internalNodes>
+          <leafValues>
+            3.7925618886947632e-01 5.5852657556533813e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 422 -7.2144409641623497e-03</internalNodes>
+          <leafValues>
+            7.2531038522720337e-01 4.6035489439964294e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 423 2.5817339774221182e-03</internalNodes>
+          <leafValues>
+            4.6933019161224365e-01 5.9002387523651123e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 424 1.3409319519996643e-01</internalNodes>
+          <leafValues>
+            5.1492130756378174e-01 1.8088449537754059e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 425 2.2962710354477167e-03</internalNodes>
+          <leafValues>
+            5.3997439146041870e-01 3.7178671360015869e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 426 -2.1575849968940020e-03</internalNodes>
+          <leafValues>
+            2.4084959924221039e-01 5.1488637924194336e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 427 -4.9196188338100910e-03</internalNodes>
+          <leafValues>
+            6.5735882520675659e-01 4.7387400269508362e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 428 1.6267469618469477e-03</internalNodes>
+          <leafValues>
+            4.1928219795227051e-01 6.3031142950057983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 429 3.3413388882763684e-04</internalNodes>
+          <leafValues>
+            5.5402982234954834e-01 3.7021011114120483e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 430 -2.6698080822825432e-02</internalNodes>
+          <leafValues>
+            1.7109179496765137e-01 5.1014107465744019e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 431 -3.0561879277229309e-02</internalNodes>
+          <leafValues>
+            1.9042180478572845e-01 5.1687937974929810e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 432 2.8511548880487680e-03</internalNodes>
+          <leafValues>
+            4.4475069642066956e-01 6.3138538599014282e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 433 -3.6211479455232620e-02</internalNodes>
+          <leafValues>
+            2.4907270073890686e-01 5.3773492574691772e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 434 -2.4115189444273710e-03</internalNodes>
+          <leafValues>
+            5.3812432289123535e-01 3.6642369627952576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 435 -7.7253201743587852e-04</internalNodes>
+          <leafValues>
+            5.5302321910858154e-01 3.5415500402450562e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 436 2.9481729143299162e-04</internalNodes>
+          <leafValues>
+            4.1326990723609924e-01 5.6672430038452148e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 437 -6.2334560789167881e-03</internalNodes>
+          <leafValues>
+            9.8787233233451843e-02 5.1986688375473022e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 438 -2.6274729520082474e-02</internalNodes>
+          <leafValues>
+            9.1127492487430573e-02 5.0281071662902832e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 439 5.3212260827422142e-03</internalNodes>
+          <leafValues>
+            4.7266489267349243e-01 6.2227207422256470e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 440 -4.1129058226943016e-03</internalNodes>
+          <leafValues>
+            2.1574570238590240e-01 5.1378047466278076e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 441 3.2457809429615736e-03</internalNodes>
+          <leafValues>
+            5.4107707738876343e-01 3.7217769026756287e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 442 -1.6359709203243256e-02</internalNodes>
+          <leafValues>
+            7.7878749370574951e-01 4.6852919459342957e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 443 3.2166109303943813e-04</internalNodes>
+          <leafValues>
+            5.4789870977401733e-01 4.2403739690780640e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 444 6.4452440710738301e-04</internalNodes>
+          <leafValues>
+            5.3305608034133911e-01 3.5013249516487122e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 445 -7.8909732401371002e-03</internalNodes>
+          <leafValues>
+            6.9235211610794067e-01 4.7265690565109253e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 446 4.8336211591959000e-02</internalNodes>
+          <leafValues>
+            5.0559002161026001e-01 7.5749203562736511e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 447 -7.5178127735853195e-04</internalNodes>
+          <leafValues>
+            3.7837418913841248e-01 5.5385738611221313e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 448 -2.4953910615295172e-03</internalNodes>
+          <leafValues>
+            3.0816510319709778e-01 5.3596121072769165e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 449 -2.2385010961443186e-03</internalNodes>
+          <leafValues>
+            6.6339588165283203e-01 4.6493428945541382e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 450 -1.7988430336117744e-03</internalNodes>
+          <leafValues>
+            6.5968447923660278e-01 4.3471878767013550e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 451 8.7860915809869766e-03</internalNodes>
+          <leafValues>
+            5.2318328619003296e-01 2.3155799508094788e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 452 3.6715380847454071e-03</internalNodes>
+          <leafValues>
+            5.2042502164840698e-01 2.9773768782615662e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 453 -3.5336449742317200e-02</internalNodes>
+          <leafValues>
+            7.2388780117034912e-01 4.8615050315856934e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 454 -6.9189240457490087e-04</internalNodes>
+          <leafValues>
+            3.1050220131874084e-01 5.2298247814178467e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 455 -3.3946109469980001e-03</internalNodes>
+          <leafValues>
+            3.1389680504798889e-01 5.2101737260818481e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 456 9.8569283727556467e-04</internalNodes>
+          <leafValues>
+            4.5365801453590393e-01 6.5850979089736938e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 457 -5.0163101404905319e-02</internalNodes>
+          <leafValues>
+            1.8044540286064148e-01 5.1989167928695679e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 458 -2.2367259953171015e-03</internalNodes>
+          <leafValues>
+            7.2557020187377930e-01 4.6513590216636658e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 459 7.4326287722215056e-04</internalNodes>
+          <leafValues>
+            4.4129210710525513e-01 5.8985459804534912e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 460 -9.3485182151198387e-04</internalNodes>
+          <leafValues>
+            3.5000529885292053e-01 5.3660178184509277e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 461 1.7497939988970757e-02</internalNodes>
+          <leafValues>
+            4.9121949076652527e-01 8.3152848482131958e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 462 -1.5200000489130616e-03</internalNodes>
+          <leafValues>
+            3.5702759027481079e-01 5.3705602884292603e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 463 7.8003940870985389e-04</internalNodes>
+          <leafValues>
+            4.3537721037864685e-01 5.9673351049423218e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>103</maxWeakCount>
+      <stageThreshold>5.0610481262207031e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 464 -9.9945552647113800e-03</internalNodes>
+          <leafValues>
+            6.1625832319259644e-01 3.0545330047607422e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 465 -1.1085229925811291e-03</internalNodes>
+          <leafValues>
+            5.8182948827743530e-01 3.1555780768394470e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 466 1.0364380432292819e-03</internalNodes>
+          <leafValues>
+            2.5520521402359009e-01 5.6929117441177368e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 467 6.8211311008781195e-04</internalNodes>
+          <leafValues>
+            3.6850899457931519e-01 5.9349310398101807e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 468 -6.8057340104132891e-04</internalNodes>
+          <leafValues>
+            2.3323920369148254e-01 5.4747921228408813e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 469 2.6068789884448051e-04</internalNodes>
+          <leafValues>
+            3.2574570178985596e-01 5.6675457954406738e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 470 5.1607372006401420e-04</internalNodes>
+          <leafValues>
+            3.7447169423103333e-01 5.8454728126525879e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 471 8.5007521556690335e-04</internalNodes>
+          <leafValues>
+            3.4203711152076721e-01 5.5228072404861450e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 472 -1.8607829697430134e-03</internalNodes>
+          <leafValues>
+            2.8044199943542480e-01 5.3754240274429321e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 473 -1.5033970121294260e-03</internalNodes>
+          <leafValues>
+            2.5790509581565857e-01 5.4989522695541382e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 474 2.3478909861296415e-03</internalNodes>
+          <leafValues>
+            4.1751560568809509e-01 6.3137108087539673e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 475 -2.8880240279249847e-04</internalNodes>
+          <leafValues>
+            5.8651697635650635e-01 4.0526661276817322e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 476 8.9405477046966553e-03</internalNodes>
+          <leafValues>
+            5.2111411094665527e-01 2.3186540603637695e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 477 -1.9327739253640175e-02</internalNodes>
+          <leafValues>
+            2.7534329891204834e-01 5.2415257692337036e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 478 -2.0202060113660991e-04</internalNodes>
+          <leafValues>
+            5.7229787111282349e-01 3.6771959066390991e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 479 2.1179069299250841e-03</internalNodes>
+          <leafValues>
+            4.4661080837249756e-01 5.5424308776855469e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 480 -1.7743760254234076e-03</internalNodes>
+          <leafValues>
+            2.8132531046867371e-01 5.3009599447250366e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 481 4.2234458960592747e-03</internalNodes>
+          <leafValues>
+            4.3997099995613098e-01 5.7954281568527222e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 482 -1.4375220052897930e-02</internalNodes>
+          <leafValues>
+            2.9811179637908936e-01 5.2920591831207275e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 483 -1.5349180437624454e-02</internalNodes>
+          <leafValues>
+            7.7052152156829834e-01 4.7481718659400940e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 484 1.5152279956964776e-05</internalNodes>
+          <leafValues>
+            3.7188440561294556e-01 5.5768972635269165e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 485 -9.1293919831514359e-03</internalNodes>
+          <leafValues>
+            3.6151960492134094e-01 5.2867668867111206e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 486 2.2512159775942564e-03</internalNodes>
+          <leafValues>
+            5.3647047281265259e-01 3.4862980246543884e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 487 -4.9696918576955795e-03</internalNodes>
+          <leafValues>
+            6.9276517629623413e-01 4.6768361330032349e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 488 -1.2829010374844074e-02</internalNodes>
+          <leafValues>
+            7.7121537923812866e-01 4.6607351303100586e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 489 -9.3660065904259682e-03</internalNodes>
+          <leafValues>
+            3.3749839663505554e-01 5.3512877225875854e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 490 3.2452319283038378e-03</internalNodes>
+          <leafValues>
+            5.3251898288726807e-01 3.2896101474761963e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 491 -1.1723560281097889e-02</internalNodes>
+          <leafValues>
+            6.8376529216766357e-01 4.7543001174926758e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 492 2.9257940695970319e-05</internalNodes>
+          <leafValues>
+            3.5720878839492798e-01 5.3605020046234131e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 493 -2.2244219508138485e-05</internalNodes>
+          <leafValues>
+            5.5414271354675293e-01 3.5520640015602112e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 494 5.0881509669125080e-03</internalNodes>
+          <leafValues>
+            5.0708442926406860e-01 1.2564620375633240e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 495 2.7429679408669472e-02</internalNodes>
+          <leafValues>
+            5.2695602178573608e-01 1.6258180141448975e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 496 -6.4142867922782898e-03</internalNodes>
+          <leafValues>
+            7.1455889940261841e-01 4.5841971039772034e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 497 3.3479959238320589e-03</internalNodes>
+          <leafValues>
+            5.3986120223999023e-01 3.4946969151496887e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 498 -8.2635492086410522e-02</internalNodes>
+          <leafValues>
+            2.4391929805278778e-01 5.1602262258529663e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 499 1.0261740535497665e-03</internalNodes>
+          <leafValues>
+            3.8868919014930725e-01 5.7679080963134766e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 500 -1.6307090409100056e-03</internalNodes>
+          <leafValues>
+            3.3894580602645874e-01 5.3477007150650024e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 501 2.4546680506318808e-03</internalNodes>
+          <leafValues>
+            4.6014139056205750e-01 6.3872468471527100e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 502 -9.9476519972085953e-04</internalNodes>
+          <leafValues>
+            5.7698792219161987e-01 4.1203960776329041e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 503 1.5409190207719803e-02</internalNodes>
+          <leafValues>
+            4.8787090182304382e-01 7.0898222923278809e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 504 1.1784400558099151e-03</internalNodes>
+          <leafValues>
+            5.2635532617568970e-01 2.8952449560165405e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 505 -2.7701919898390770e-02</internalNodes>
+          <leafValues>
+            1.4988289773464203e-01 5.2196067571640015e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 506 -2.9505399987101555e-02</internalNodes>
+          <leafValues>
+            2.4893319234251976e-02 4.9998161196708679e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 507 4.5159430010244250e-04</internalNodes>
+          <leafValues>
+            5.4646229743957520e-01 4.0296629071235657e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 508 7.1772639639675617e-03</internalNodes>
+          <leafValues>
+            4.2710569500923157e-01 5.8662968873977661e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 509 -7.4182048439979553e-02</internalNodes>
+          <leafValues>
+            6.8741792440414429e-01 4.9190279841423035e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 510 -1.7254160717129707e-02</internalNodes>
+          <leafValues>
+            3.3706760406494141e-01 5.3487390279769897e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 511 1.4851559884846210e-02</internalNodes>
+          <leafValues>
+            4.6267929673194885e-01 6.1299049854278564e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 512 1.0002000257372856e-02</internalNodes>
+          <leafValues>
+            5.3461229801177979e-01 3.4234538674354553e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 513 2.0138120744377375e-03</internalNodes>
+          <leafValues>
+            4.6438300609588623e-01 5.8243042230606079e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 514 1.5135470312088728e-03</internalNodes>
+          <leafValues>
+            5.1963961124420166e-01 2.8561499714851379e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 515 3.1381431035697460e-03</internalNodes>
+          <leafValues>
+            4.8381629586219788e-01 5.9585297107696533e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 516 -5.1450440660119057e-03</internalNodes>
+          <leafValues>
+            8.9203029870986938e-01 4.7414121031761169e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 517 -4.4736708514392376e-03</internalNodes>
+          <leafValues>
+            2.0339429378509521e-01 5.3372788429260254e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 518 1.9628470763564110e-03</internalNodes>
+          <leafValues>
+            4.5716339349746704e-01 6.7258632183074951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 519 5.4260450415313244e-03</internalNodes>
+          <leafValues>
+            5.2711081504821777e-01 2.8456708788871765e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 520 4.9611460417509079e-04</internalNodes>
+          <leafValues>
+            4.1383129358291626e-01 5.7185977697372437e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 521 9.3728788197040558e-03</internalNodes>
+          <leafValues>
+            5.2251511812210083e-01 2.8048470616340637e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 522 6.0500897234305739e-04</internalNodes>
+          <leafValues>
+            5.2367687225341797e-01 3.3145239949226379e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 523 5.6792551185935736e-04</internalNodes>
+          <leafValues>
+            4.5310598611831665e-01 6.2769711017608643e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 524 2.4644339457154274e-02</internalNodes>
+          <leafValues>
+            5.1308518648147583e-01 2.0171439647674561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 525 -1.0290450416505337e-02</internalNodes>
+          <leafValues>
+            7.7865952253341675e-01 4.8766410350799561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 526 2.0629419013857841e-03</internalNodes>
+          <leafValues>
+            4.2885988950729370e-01 5.8812642097473145e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 527 -5.0519481301307678e-03</internalNodes>
+          <leafValues>
+            3.5239779949188232e-01 5.2860087156295776e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 528 -5.7692620903253555e-03</internalNodes>
+          <leafValues>
+            6.8410861492156982e-01 4.5880940556526184e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 529 -4.5789941214025021e-04</internalNodes>
+          <leafValues>
+            3.5655200481414795e-01 5.4859781265258789e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 530 -7.5918837683275342e-04</internalNodes>
+          <leafValues>
+            3.3687931299209595e-01 5.2541971206665039e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 531 -1.7737259622663260e-03</internalNodes>
+          <leafValues>
+            3.4221610426902771e-01 5.4540151357650757e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 532 -8.5610467940568924e-03</internalNodes>
+          <leafValues>
+            6.5336120128631592e-01 4.4858568906784058e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 533 1.7277270089834929e-03</internalNodes>
+          <leafValues>
+            5.3075802326202393e-01 3.9253529906272888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 534 -2.8199609369039536e-02</internalNodes>
+          <leafValues>
+            6.8574589490890503e-01 4.5885840058326721e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 535 -1.7781109781935811e-03</internalNodes>
+          <leafValues>
+            4.0378510951995850e-01 5.3698569536209106e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 536 3.3177141449414194e-04</internalNodes>
+          <leafValues>
+            5.3997987508773804e-01 3.7057501077651978e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 537 2.6385399978607893e-03</internalNodes>
+          <leafValues>
+            4.6654370427131653e-01 6.4527308940887451e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 538 -2.1183069329708815e-03</internalNodes>
+          <leafValues>
+            5.9147810935974121e-01 4.0646770596504211e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 539 -1.4773289673030376e-02</internalNodes>
+          <leafValues>
+            3.6420381069183350e-01 5.2947628498077393e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 540 -1.6815440729260445e-02</internalNodes>
+          <leafValues>
+            2.6642319560050964e-01 5.1449728012084961e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 541 -6.3370140269398689e-03</internalNodes>
+          <leafValues>
+            6.7795312404632568e-01 4.8520979285240173e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 542 -4.4560048991115764e-05</internalNodes>
+          <leafValues>
+            5.6139647960662842e-01 4.1530540585517883e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 543 -1.0240620467811823e-03</internalNodes>
+          <leafValues>
+            5.9644782543182373e-01 4.5663040876388550e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 544 -2.3161689750850201e-03</internalNodes>
+          <leafValues>
+            2.9761150479316711e-01 5.1881599426269531e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 545 5.3217571973800659e-01</internalNodes>
+          <leafValues>
+            5.1878392696380615e-01 2.2026319801807404e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 546 -1.6643050312995911e-01</internalNodes>
+          <leafValues>
+            1.8660229444503784e-01 5.0603431463241577e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 547 1.1253529787063599e-01</internalNodes>
+          <leafValues>
+            5.2121251821517944e-01 1.1850229650735855e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 548 9.3046864494681358e-03</internalNodes>
+          <leafValues>
+            4.5899370312690735e-01 6.8261492252349854e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 549 -4.6255099587142467e-03</internalNodes>
+          <leafValues>
+            3.0799409747123718e-01 5.2250087261199951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 550 -1.1116469651460648e-01</internalNodes>
+          <leafValues>
+            2.1010440587997437e-01 5.0808018445968628e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 551 -1.0888439603149891e-02</internalNodes>
+          <leafValues>
+            5.7653552293777466e-01 4.7904640436172485e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 552 5.8564301580190659e-03</internalNodes>
+          <leafValues>
+            5.0651001930236816e-01 1.5635989606380463e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 553 5.4854389280080795e-02</internalNodes>
+          <leafValues>
+            4.9669149518013000e-01 7.2305107116699219e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 554 -1.1197339743375778e-02</internalNodes>
+          <leafValues>
+            2.1949790418148041e-01 5.0987982749938965e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 555 4.4069071300327778e-03</internalNodes>
+          <leafValues>
+            4.7784018516540527e-01 6.7709028720855713e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 556 -6.3665293157100677e-02</internalNodes>
+          <leafValues>
+            1.9363629817962646e-01 5.0810241699218750e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 557 -9.8081491887569427e-03</internalNodes>
+          <leafValues>
+            5.9990632534027100e-01 4.8103410005569458e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 558 -2.1717099007219076e-03</internalNodes>
+          <leafValues>
+            3.3383339643478394e-01 5.2354729175567627e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 559 -1.3315520249307156e-02</internalNodes>
+          <leafValues>
+            6.6170698404312134e-01 4.9192130565643311e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 560 2.5442079640924931e-03</internalNodes>
+          <leafValues>
+            4.4887441396713257e-01 6.0821849107742310e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 561 1.2037839740514755e-02</internalNodes>
+          <leafValues>
+            5.4093921184539795e-01 3.2924321293830872e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 562 -2.0701050758361816e-02</internalNodes>
+          <leafValues>
+            6.8191200494766235e-01 4.5949959754943848e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 563 2.7608279138803482e-02</internalNodes>
+          <leafValues>
+            4.6307921409606934e-01 5.7672828435897827e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 564 1.2370620388537645e-03</internalNodes>
+          <leafValues>
+            5.1653790473937988e-01 2.6350161433219910e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 565 -3.7669338285923004e-02</internalNodes>
+          <leafValues>
+            2.5363931059837341e-01 5.2789801359176636e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 566 -1.8057259730994701e-03</internalNodes>
+          <leafValues>
+            3.9851561188697815e-01 5.5175000429153442e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>111</maxWeakCount>
+      <stageThreshold>5.4620071411132812e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 567 4.4299028813838959e-03</internalNodes>
+          <leafValues>
+            2.8910180926322937e-01 6.3352262973785400e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 568 -2.3813319858163595e-03</internalNodes>
+          <leafValues>
+            6.2117892503738403e-01 3.4774878621101379e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 569 2.2915711160749197e-03</internalNodes>
+          <leafValues>
+            2.2544120252132416e-01 5.5821180343627930e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 570 9.9457940086722374e-04</internalNodes>
+          <leafValues>
+            3.7117108702659607e-01 5.9300708770751953e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 571 7.7164667891338468e-04</internalNodes>
+          <leafValues>
+            5.6517201662063599e-01 3.3479958772659302e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 572 -1.1386410333216190e-03</internalNodes>
+          <leafValues>
+            3.0691260099411011e-01 5.5086308717727661e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 573 -1.6403039626311511e-04</internalNodes>
+          <leafValues>
+            5.7628279924392700e-01 3.6990478634834290e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 574 2.9793529392918572e-05</internalNodes>
+          <leafValues>
+            2.6442441344261169e-01 5.4379111528396606e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 575 8.5774902254343033e-03</internalNodes>
+          <leafValues>
+            5.0511389970779419e-01 1.7957249283790588e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 576 -2.6032689493149519e-04</internalNodes>
+          <leafValues>
+            5.8269691467285156e-01 4.4468268752098083e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 577 -6.1404630541801453e-03</internalNodes>
+          <leafValues>
+            3.1138521432876587e-01 5.3469717502593994e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 578 -2.3086950182914734e-02</internalNodes>
+          <leafValues>
+            3.2779461145401001e-01 5.3311979770660400e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 579 -1.4243650250136852e-02</internalNodes>
+          <leafValues>
+            7.3817098140716553e-01 4.5880630612373352e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 580 1.9487129524350166e-02</internalNodes>
+          <leafValues>
+            5.2566307783126831e-01 2.2744719684123993e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 581 -9.6681108698248863e-04</internalNodes>
+          <leafValues>
+            5.5112308263778687e-01 3.8150069117546082e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 582 3.1474709976464510e-03</internalNodes>
+          <leafValues>
+            5.4256367683410645e-01 2.5437268614768982e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 583 -1.8026070029009134e-04</internalNodes>
+          <leafValues>
+            5.3801918029785156e-01 3.4063041210174561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 584 -6.0266260989010334e-03</internalNodes>
+          <leafValues>
+            3.0358019471168518e-01 5.4205721616744995e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 585 4.4462960795499384e-04</internalNodes>
+          <leafValues>
+            3.9909970760345459e-01 5.6601101160049438e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 586 2.2609760053455830e-03</internalNodes>
+          <leafValues>
+            5.5628067255020142e-01 3.9406880736351013e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 587 5.1133058965206146e-02</internalNodes>
+          <leafValues>
+            4.6096539497375488e-01 7.1185618638992310e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 588 -1.7786309123039246e-02</internalNodes>
+          <leafValues>
+            2.3161660134792328e-01 5.3221440315246582e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 589 -4.9679628573358059e-03</internalNodes>
+          <leafValues>
+            2.3307719826698303e-01 5.1220291852951050e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 590 2.0667689386755228e-03</internalNodes>
+          <leafValues>
+            4.6574440598487854e-01 6.4554882049560547e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 591 7.4413768015801907e-03</internalNodes>
+          <leafValues>
+            5.1543921232223511e-01 2.3616339266300201e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 592 -3.6277279723435640e-03</internalNodes>
+          <leafValues>
+            6.2197732925415039e-01 4.4766610860824585e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 593 -5.3530759178102016e-03</internalNodes>
+          <leafValues>
+            1.8373550474643707e-01 5.1022082567214966e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 594 1.4530919492244720e-01</internalNodes>
+          <leafValues>
+            5.1459872722625732e-01 1.5359309315681458e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 595 2.4394490756094456e-03</internalNodes>
+          <leafValues>
+            5.3436601161956787e-01 3.6246618628501892e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 596 -3.1283390708267689e-03</internalNodes>
+          <leafValues>
+            6.2150079011917114e-01 4.8455920815467834e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 597 1.7940260004252195e-03</internalNodes>
+          <leafValues>
+            4.2992618680000305e-01 5.8241981267929077e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 598 3.6253821104764938e-02</internalNodes>
+          <leafValues>
+            5.2603340148925781e-01 1.4394679665565491e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 599 -5.1746722310781479e-03</internalNodes>
+          <leafValues>
+            3.5065388679504395e-01 5.2870452404022217e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 600 6.5383297624066472e-04</internalNodes>
+          <leafValues>
+            4.8096409440040588e-01 6.1220401525497437e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 601 -2.6480229571461678e-02</internalNodes>
+          <leafValues>
+            1.1393620073795319e-01 5.0455862283706665e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 602 -3.0440660193562508e-03</internalNodes>
+          <leafValues>
+            6.3520950078964233e-01 4.7947341203689575e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 603 3.6993520334362984e-03</internalNodes>
+          <leafValues>
+            5.1311182975769043e-01 2.4985109269618988e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 604 -3.6762931267730892e-04</internalNodes>
+          <leafValues>
+            5.4213947057723999e-01 3.7095320224761963e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 605 -4.1382260620594025e-02</internalNodes>
+          <leafValues>
+            1.8949599564075470e-01 5.0816917419433594e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 606 -1.0532729793339968e-03</internalNodes>
+          <leafValues>
+            6.4543670415878296e-01 4.7836089134216309e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 607 -2.1648600231856108e-03</internalNodes>
+          <leafValues>
+            6.2150311470031738e-01 4.4998261332511902e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 608 -5.6747748749330640e-04</internalNodes>
+          <leafValues>
+            3.7126109004020691e-01 5.4193347692489624e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 609 1.7375840246677399e-01</internalNodes>
+          <leafValues>
+            5.0236439704895020e-01 1.2157420068979263e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 610 -2.9049699660390615e-03</internalNodes>
+          <leafValues>
+            3.2402679324150085e-01 5.3818839788436890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 611 1.2299539521336555e-03</internalNodes>
+          <leafValues>
+            4.1655078530311584e-01 5.7034862041473389e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 612 -5.4329237900674343e-04</internalNodes>
+          <leafValues>
+            3.8540428876876831e-01 5.5475491285324097e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 613 -8.3297258242964745e-03</internalNodes>
+          <leafValues>
+            2.2044940292835236e-01 5.0970828533172607e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 614 -1.0417630255687982e-04</internalNodes>
+          <leafValues>
+            5.6070661544799805e-01 4.3030360341072083e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 615 3.1204700469970703e-02</internalNodes>
+          <leafValues>
+            4.6216571331024170e-01 6.9820040464401245e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 616 7.8943502157926559e-03</internalNodes>
+          <leafValues>
+            5.2695941925048828e-01 2.2690680623054504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 617 -4.3645310215651989e-03</internalNodes>
+          <leafValues>
+            6.3592231273651123e-01 4.5379561185836792e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 618 7.6793059706687927e-03</internalNodes>
+          <leafValues>
+            5.2747678756713867e-01 2.7404838800430298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 619 -2.5431139394640923e-02</internalNodes>
+          <leafValues>
+            2.0385199785232544e-01 5.0717329978942871e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 620 8.2000601105391979e-04</internalNodes>
+          <leafValues>
+            4.5874550938606262e-01 6.1198681592941284e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 621 2.9284600168466568e-03</internalNodes>
+          <leafValues>
+            5.0712740421295166e-01 2.0282049477100372e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 622 4.5256470912136137e-05</internalNodes>
+          <leafValues>
+            4.8121041059494019e-01 5.4308217763900757e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 623 1.3158309739083052e-03</internalNodes>
+          <leafValues>
+            4.6258139610290527e-01 6.7793232202529907e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 624 1.5870389761403203e-03</internalNodes>
+          <leafValues>
+            5.3862917423248291e-01 3.4314650297164917e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 625 -2.1539660170674324e-02</internalNodes>
+          <leafValues>
+            2.5942500680685043e-02 5.0032228231430054e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 626 1.4334480278193951e-02</internalNodes>
+          <leafValues>
+            5.2028447389602661e-01 1.5906329452991486e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 627 -8.3881383761763573e-03</internalNodes>
+          <leafValues>
+            7.2824811935424805e-01 4.6480441093444824e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 628 9.1906841844320297e-03</internalNodes>
+          <leafValues>
+            5.5623567104339600e-01 3.9231911301612854e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 629 -5.8453059755265713e-03</internalNodes>
+          <leafValues>
+            6.8033927679061890e-01 4.6291279792785645e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 630 -5.4707799106836319e-02</internalNodes>
+          <leafValues>
+            2.5616711378097534e-01 5.2061259746551514e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 631 9.1142775490880013e-03</internalNodes>
+          <leafValues>
+            5.1896202564239502e-01 3.0538770556449890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 632 -1.5575000084936619e-02</internalNodes>
+          <leafValues>
+            1.2950749695301056e-01 5.1690948009490967e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 633 -1.2050600344082341e-04</internalNodes>
+          <leafValues>
+            5.7350981235504150e-01 4.2308250069618225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 634 1.2273970060050488e-03</internalNodes>
+          <leafValues>
+            5.2898782491683960e-01 4.0797919034957886e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 635 -1.2186600361019373e-03</internalNodes>
+          <leafValues>
+            6.5756398439407349e-01 4.5744091272354126e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 636 -3.3256649039685726e-03</internalNodes>
+          <leafValues>
+            3.6280471086502075e-01 5.1950198411941528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 637 -1.3288309797644615e-02</internalNodes>
+          <leafValues>
+            1.2842659652233124e-01 5.0434887409210205e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 638 -3.3839771058410406e-03</internalNodes>
+          <leafValues>
+            6.2922400236129761e-01 4.7575059533119202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 639 -2.1954220533370972e-01</internalNodes>
+          <leafValues>
+            1.4877319335937500e-01 5.0650137662887573e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 640 4.9111708067357540e-03</internalNodes>
+          <leafValues>
+            4.2561021447181702e-01 5.6658387184143066e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 641 -1.8744950648397207e-04</internalNodes>
+          <leafValues>
+            4.0041440725326538e-01 5.5868571996688843e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 642 -5.2178641781210899e-03</internalNodes>
+          <leafValues>
+            6.0091161727905273e-01 4.8127061128616333e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 643 -1.1111519997939467e-03</internalNodes>
+          <leafValues>
+            3.5149338841438293e-01 5.2870899438858032e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 644 4.4036400504410267e-03</internalNodes>
+          <leafValues>
+            4.6422758698463440e-01 5.9240859746932983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 645 1.2299499660730362e-01</internalNodes>
+          <leafValues>
+            5.0255292654037476e-01 6.9152481853961945e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 646 -1.2313510291278362e-02</internalNodes>
+          <leafValues>
+            5.8845919370651245e-01 4.9340128898620605e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 647 4.1471039876341820e-03</internalNodes>
+          <leafValues>
+            4.3722391128540039e-01 5.8934777975082397e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 648 -3.5502649843692780e-03</internalNodes>
+          <leafValues>
+            4.3275511264801025e-01 5.3962701559066772e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 649 -1.9224269315600395e-02</internalNodes>
+          <leafValues>
+            1.9131340086460114e-01 5.0683307647705078e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 650 1.4395059552043676e-03</internalNodes>
+          <leafValues>
+            5.3081780672073364e-01 4.2435330152511597e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 651 -6.7751999013125896e-03</internalNodes>
+          <leafValues>
+            6.3653957843780518e-01 4.5400860905647278e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 652 7.0119630545377731e-03</internalNodes>
+          <leafValues>
+            5.1898342370986938e-01 3.0261999368667603e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 653 5.4014651104807854e-03</internalNodes>
+          <leafValues>
+            5.1050621271133423e-01 2.5576829910278320e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 654 9.0274988906458020e-04</internalNodes>
+          <leafValues>
+            4.6969148516654968e-01 5.8618277311325073e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 655 1.1474450118839741e-02</internalNodes>
+          <leafValues>
+            5.0536459684371948e-01 1.5271779894828796e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 656 -6.7023430019617081e-03</internalNodes>
+          <leafValues>
+            6.5089809894561768e-01 4.8906040191650391e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 657 -2.0462959073483944e-03</internalNodes>
+          <leafValues>
+            6.2418168783187866e-01 4.5146000385284424e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 658 -9.9951568990945816e-03</internalNodes>
+          <leafValues>
+            3.4327811002731323e-01 5.4009538888931274e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 659 -3.5700708627700806e-02</internalNodes>
+          <leafValues>
+            1.8780590593814850e-01 5.0740778446197510e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 660 4.5584561303257942e-04</internalNodes>
+          <leafValues>
+            3.8052770495414734e-01 5.4025697708129883e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 661 -5.4260600358247757e-02</internalNodes>
+          <leafValues>
+            6.8437147140502930e-01 4.5950970053672791e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 662 6.0600461438298225e-03</internalNodes>
+          <leafValues>
+            5.5029052495956421e-01 4.5005279779434204e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 663 -6.4791832119226456e-03</internalNodes>
+          <leafValues>
+            3.3688580989837646e-01 5.3107571601867676e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 664 -1.4939469983801246e-03</internalNodes>
+          <leafValues>
+            6.4876401424407959e-01 4.7561758756637573e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 665 1.4610530342906713e-05</internalNodes>
+          <leafValues>
+            4.0345790982246399e-01 5.4510641098022461e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 666 -7.2321938350796700e-03</internalNodes>
+          <leafValues>
+            6.3868737220764160e-01 4.8247399926185608e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 667 -4.0645818226039410e-03</internalNodes>
+          <leafValues>
+            2.9864218831062317e-01 5.1573359966278076e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 668 3.0463080853223801e-02</internalNodes>
+          <leafValues>
+            5.0221997499465942e-01 7.1599560976028442e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 669 -8.0544911324977875e-03</internalNodes>
+          <leafValues>
+            6.4924520254135132e-01 4.6192750334739685e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 670 3.9505138993263245e-02</internalNodes>
+          <leafValues>
+            5.1505708694458008e-01 2.4506139755249023e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 671 8.4530208259820938e-03</internalNodes>
+          <leafValues>
+            4.5736691355705261e-01 6.3940370082855225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 672 -1.1688120430335402e-03</internalNodes>
+          <leafValues>
+            3.8655120134353638e-01 5.4836612939834595e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 673 2.8070670086890459e-03</internalNodes>
+          <leafValues>
+            5.1285791397094727e-01 2.7014800906181335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 674 4.7365209320560098e-04</internalNodes>
+          <leafValues>
+            4.0515819191932678e-01 5.3874611854553223e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 675 1.1741080321371555e-02</internalNodes>
+          <leafValues>
+            5.2959501743316650e-01 3.7194138765335083e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 676 3.1833238899707794e-03</internalNodes>
+          <leafValues>
+            4.7894069552421570e-01 6.8951261043548584e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 677 7.0241501089185476e-04</internalNodes>
+          <leafValues>
+            5.3844892978668213e-01 3.9180809259414673e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>102</maxWeakCount>
+      <stageThreshold>5.0169731140136719e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 678 1.7059929668903351e-02</internalNodes>
+          <leafValues>
+            3.9485278725624084e-01 7.1425348520278931e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 679 2.1840840578079224e-02</internalNodes>
+          <leafValues>
+            3.3703160285949707e-01 6.0900169610977173e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 680 2.4520049919374287e-04</internalNodes>
+          <leafValues>
+            3.5005760192871094e-01 5.9879022836685181e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 681 8.3272606134414673e-03</internalNodes>
+          <leafValues>
+            3.2675281167030334e-01 5.6972408294677734e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 682 5.7148298947140574e-04</internalNodes>
+          <leafValues>
+            3.0445998907089233e-01 5.5316567420959473e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 683 6.7373987985774875e-04</internalNodes>
+          <leafValues>
+            3.6500120162963867e-01 5.6726312637329102e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 684 3.4681590477703139e-05</internalNodes>
+          <leafValues>
+            3.3135411143302917e-01 5.3887271881103516e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 685 -5.8563398197293282e-03</internalNodes>
+          <leafValues>
+            2.6979428529739380e-01 5.4987788200378418e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 686 8.5102273151278496e-03</internalNodes>
+          <leafValues>
+            5.2693581581115723e-01 2.7628791332244873e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 687 -6.9817207753658295e-02</internalNodes>
+          <leafValues>
+            2.9096031188964844e-01 5.2592468261718750e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 688 -8.6113670840859413e-04</internalNodes>
+          <leafValues>
+            5.8925771713256836e-01 4.0736979246139526e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 689 9.7149249631911516e-04</internalNodes>
+          <leafValues>
+            3.5235640406608582e-01 5.4158622026443481e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 690 -1.4727490452060010e-05</internalNodes>
+          <leafValues>
+            5.4230177402496338e-01 3.5031560063362122e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 691 4.8420291393995285e-02</internalNodes>
+          <leafValues>
+            5.1939457654953003e-01 3.4111958742141724e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 692 1.3257140526548028e-03</internalNodes>
+          <leafValues>
+            3.1577691435813904e-01 5.3353762626647949e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 693 1.4922149603080470e-05</internalNodes>
+          <leafValues>
+            4.4512999057769775e-01 5.5365538597106934e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 694 -2.7173398993909359e-03</internalNodes>
+          <leafValues>
+            3.0317419767379761e-01 5.2480888366699219e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 695 2.9219500720500946e-03</internalNodes>
+          <leafValues>
+            4.7814530134201050e-01 6.6060417890548706e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 696 -1.9804988987743855e-03</internalNodes>
+          <leafValues>
+            3.1863081455230713e-01 5.2876251935958862e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 697 -4.0012109093368053e-03</internalNodes>
+          <leafValues>
+            6.4135968685150146e-01 4.7499281167984009e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 698 -4.3491991236805916e-03</internalNodes>
+          <leafValues>
+            1.5074980258941650e-01 5.0989967584609985e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 699 1.3490889687091112e-03</internalNodes>
+          <leafValues>
+            4.3161588907241821e-01 5.8811670541763306e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 700 1.8597070127725601e-02</internalNodes>
+          <leafValues>
+            4.7355538606643677e-01 9.0897941589355469e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 701 -1.8562379991635680e-03</internalNodes>
+          <leafValues>
+            3.5531890392303467e-01 5.5778372287750244e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 702 2.2940430790185928e-03</internalNodes>
+          <leafValues>
+            4.5000949501991272e-01 6.5808779001235962e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 703 2.9982850537635386e-04</internalNodes>
+          <leafValues>
+            5.6292420625686646e-01 3.9758789539337158e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 704 3.5455459728837013e-03</internalNodes>
+          <leafValues>
+            5.3815472126007080e-01 3.6054858565330505e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 705 9.6104722470045090e-03</internalNodes>
+          <leafValues>
+            5.2559971809387207e-01 1.7967459559440613e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 706 -6.2783220782876015e-03</internalNodes>
+          <leafValues>
+            2.2728569805622101e-01 5.1140302419662476e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 707 3.4598479978740215e-03</internalNodes>
+          <leafValues>
+            4.6263080835342407e-01 6.6082191467285156e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 708 -1.3112019514665008e-03</internalNodes>
+          <leafValues>
+            6.3175398111343384e-01 4.4368579983711243e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 709 2.6876179035753012e-03</internalNodes>
+          <leafValues>
+            5.4211097955703735e-01 4.0540221333503723e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 710 3.9118169806897640e-03</internalNodes>
+          <leafValues>
+            5.3584778308868408e-01 3.2734549045562744e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 711 -1.4206450432538986e-02</internalNodes>
+          <leafValues>
+            7.7935767173767090e-01 4.9757811427116394e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 712 7.1705528534948826e-04</internalNodes>
+          <leafValues>
+            5.2973198890686035e-01 3.5609039664268494e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 713 1.6635019565001130e-03</internalNodes>
+          <leafValues>
+            4.6780940890312195e-01 5.8164817094802856e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 714 3.3686188980937004e-03</internalNodes>
+          <leafValues>
+            5.2767342329025269e-01 3.4464201331138611e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 715 1.2799530290067196e-02</internalNodes>
+          <leafValues>
+            4.8346799612045288e-01 7.4721592664718628e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 716 3.3901201095432043e-03</internalNodes>
+          <leafValues>
+            4.5118591189384460e-01 6.4017212390899658e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 717 4.7070779837667942e-03</internalNodes>
+          <leafValues>
+            5.3356587886810303e-01 3.5552209615707397e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 718 1.4819339849054813e-03</internalNodes>
+          <leafValues>
+            4.2507070302963257e-01 5.7727241516113281e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 719 -6.9995759986341000e-03</internalNodes>
+          <leafValues>
+            3.0033200979232788e-01 5.2929002046585083e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 720 1.5939010307192802e-02</internalNodes>
+          <leafValues>
+            5.0673192739486694e-01 1.6755819320678711e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 721 7.6377349905669689e-03</internalNodes>
+          <leafValues>
+            4.7950699925422668e-01 7.0856010913848877e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 722 6.7334040068089962e-03</internalNodes>
+          <leafValues>
+            5.1331132650375366e-01 2.1624700725078583e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 723 -1.2858809903264046e-02</internalNodes>
+          <leafValues>
+            1.9388419389724731e-01 5.2513718605041504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 724 -6.2270800117403269e-04</internalNodes>
+          <leafValues>
+            5.6865382194519043e-01 4.1978681087493896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 725 -5.2651681471616030e-04</internalNodes>
+          <leafValues>
+            4.2241689562797546e-01 5.4296958446502686e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 726 1.1075099930167198e-02</internalNodes>
+          <leafValues>
+            5.1137751340866089e-01 2.5145179033279419e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 727 -3.6728251725435257e-02</internalNodes>
+          <leafValues>
+            7.1946620941162109e-01 4.8496189713478088e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 728 -2.8207109426148236e-04</internalNodes>
+          <leafValues>
+            3.8402619957923889e-01 5.3944462537765503e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 729 -2.7489690110087395e-03</internalNodes>
+          <leafValues>
+            5.9370887279510498e-01 4.5691820979118347e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 730 1.0047519579529762e-02</internalNodes>
+          <leafValues>
+            5.1385760307312012e-01 2.8022980690002441e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 731 -8.1497840583324432e-03</internalNodes>
+          <leafValues>
+            6.0900372266769409e-01 4.6361210942268372e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 732 -6.8833888508379459e-03</internalNodes>
+          <leafValues>
+            3.4586110711097717e-01 5.2546602487564087e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 733 -1.4039360394235700e-05</internalNodes>
+          <leafValues>
+            5.6931042671203613e-01 4.0820831060409546e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 734 1.5498419525101781e-03</internalNodes>
+          <leafValues>
+            4.3505370616912842e-01 5.8065170049667358e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 735 -6.7841499112546444e-03</internalNodes>
+          <leafValues>
+            1.4688730239868164e-01 5.1827752590179443e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 736 2.1705629478674382e-04</internalNodes>
+          <leafValues>
+            5.2935242652893066e-01 3.4561741352081299e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 737 3.1198898795992136e-04</internalNodes>
+          <leafValues>
+            4.6524509787559509e-01 5.9424138069152832e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 738 5.4507530294358730e-03</internalNodes>
+          <leafValues>
+            4.6535089612007141e-01 7.0248460769653320e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 739 -2.5818689027801156e-04</internalNodes>
+          <leafValues>
+            5.4972952604293823e-01 3.7689670920372009e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 740 -1.7442539334297180e-02</internalNodes>
+          <leafValues>
+            3.9190879464149475e-01 5.4574978351593018e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 741 -4.5343529433012009e-02</internalNodes>
+          <leafValues>
+            1.6313570737838745e-01 5.1549088954925537e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 742 1.9190689781680703e-03</internalNodes>
+          <leafValues>
+            5.1458978652954102e-01 2.7918958663940430e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 743 -6.0177869163453579e-03</internalNodes>
+          <leafValues>
+            6.5176361799240112e-01 4.7563329339027405e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 744 -4.0720738470554352e-03</internalNodes>
+          <leafValues>
+            5.5146527290344238e-01 4.0926858782768250e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 745 3.9855059003457427e-04</internalNodes>
+          <leafValues>
+            3.1652408838272095e-01 5.2855509519577026e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 746 -6.5418570302426815e-03</internalNodes>
+          <leafValues>
+            6.8533778190612793e-01 4.6528089046478271e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 747 3.4845089539885521e-03</internalNodes>
+          <leafValues>
+            5.4845881462097168e-01 4.5027598738670349e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 748 -1.3696780428290367e-02</internalNodes>
+          <leafValues>
+            6.3957798480987549e-01 4.5725551247596741e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 749 -1.7347140237689018e-02</internalNodes>
+          <leafValues>
+            2.7510729432106018e-01 5.1816147565841675e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 750 -4.0885428898036480e-03</internalNodes>
+          <leafValues>
+            3.3256360888481140e-01 5.1949840784072876e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 751 -9.4687901437282562e-03</internalNodes>
+          <leafValues>
+            5.9422808885574341e-01 4.8518198728561401e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 752 1.7084840219467878e-03</internalNodes>
+          <leafValues>
+            4.1671109199523926e-01 5.5198061466217041e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 753 9.4809094443917274e-03</internalNodes>
+          <leafValues>
+            5.4338949918746948e-01 4.2085149884223938e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 754 -4.7389650717377663e-03</internalNodes>
+          <leafValues>
+            6.4071899652481079e-01 4.5606550574302673e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 755 6.5761050209403038e-03</internalNodes>
+          <leafValues>
+            5.2145552635192871e-01 2.2582270205020905e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 756 -2.1690549328923225e-03</internalNodes>
+          <leafValues>
+            3.1515279412269592e-01 5.1567047834396362e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 757 1.4660170301795006e-02</internalNodes>
+          <leafValues>
+            4.8708370327949524e-01 6.6899412870407104e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 758 1.7231999663636088e-04</internalNodes>
+          <leafValues>
+            3.5697489976882935e-01 5.2510780096054077e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 759 -2.1803760901093483e-02</internalNodes>
+          <leafValues>
+            8.8259208202362061e-01 4.9663299322128296e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 760 -9.4736106693744659e-02</internalNodes>
+          <leafValues>
+            1.4461620151996613e-01 5.0611138343811035e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 761 5.5825551971793175e-03</internalNodes>
+          <leafValues>
+            5.3964787721633911e-01 4.2380660772323608e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 762 1.9517090404406190e-03</internalNodes>
+          <leafValues>
+            4.1704109311103821e-01 5.4977869987487793e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 763 1.2149900197982788e-02</internalNodes>
+          <leafValues>
+            4.6983671188354492e-01 5.6642740964889526e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 764 -7.5169620104134083e-03</internalNodes>
+          <leafValues>
+            6.2677729129791260e-01 4.4631358981132507e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 765 -7.1667909622192383e-02</internalNodes>
+          <leafValues>
+            3.0970111489295959e-01 5.2210032939910889e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 766 -8.8292419910430908e-02</internalNodes>
+          <leafValues>
+            8.1123888492584229e-02 5.0063651800155640e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 767 3.1063079833984375e-02</internalNodes>
+          <leafValues>
+            5.1555037498474121e-01 1.2822559475898743e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 768 4.6621840447187424e-02</internalNodes>
+          <leafValues>
+            4.6997779607772827e-01 7.3639607429504395e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 769 -1.2189489789307117e-02</internalNodes>
+          <leafValues>
+            3.9205300807952881e-01 5.5189967155456543e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 770 1.3016110286116600e-02</internalNodes>
+          <leafValues>
+            5.2606582641601562e-01 3.6851361393928528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 771 -3.4952899441123009e-03</internalNodes>
+          <leafValues>
+            6.3392949104309082e-01 4.7162809967994690e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 772 -4.4015039748046547e-05</internalNodes>
+          <leafValues>
+            5.3330272436141968e-01 3.7761849164962769e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 773 -1.0966490209102631e-01</internalNodes>
+          <leafValues>
+            1.7653420567512512e-01 5.1983469724655151e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 774 -9.0279558207839727e-04</internalNodes>
+          <leafValues>
+            5.3241598606109619e-01 3.8389080762863159e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 775 7.1126641705632210e-04</internalNodes>
+          <leafValues>
+            4.6479299664497375e-01 5.7552242279052734e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 776 -3.1250279862433672e-03</internalNodes>
+          <leafValues>
+            3.2367089390754700e-01 5.1667708158493042e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 777 2.4144679773598909e-03</internalNodes>
+          <leafValues>
+            4.7874391078948975e-01 6.4597177505493164e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 778 4.4391240226104856e-04</internalNodes>
+          <leafValues>
+            4.4093081355094910e-01 6.0102558135986328e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 779 -2.2611189342569560e-04</internalNodes>
+          <leafValues>
+            4.0381139516830444e-01 5.4932558536529541e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>135</maxWeakCount>
+      <stageThreshold>6.6669120788574219e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 780 -4.6901289373636246e-02</internalNodes>
+          <leafValues>
+            6.6001719236373901e-01 3.7438011169433594e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 781 -1.4568349579349160e-03</internalNodes>
+          <leafValues>
+            5.7839912176132202e-01 3.4377971291542053e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 782 5.5598369799554348e-03</internalNodes>
+          <leafValues>
+            3.6222669482231140e-01 5.9082162380218506e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 783 7.3170487303286791e-04</internalNodes>
+          <leafValues>
+            5.5004191398620605e-01 2.8735581040382385e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 784 1.3318009441718459e-03</internalNodes>
+          <leafValues>
+            2.6731699705123901e-01 5.4310190677642822e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 785 2.4347059661522508e-04</internalNodes>
+          <leafValues>
+            3.8550278544425964e-01 5.7413887977600098e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 786 -3.0512469820678234e-03</internalNodes>
+          <leafValues>
+            5.5032098293304443e-01 3.4628450870513916e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 787 -6.8657199153676629e-04</internalNodes>
+          <leafValues>
+            3.2912218570709229e-01 5.4295092821121216e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 788 1.4668200165033340e-03</internalNodes>
+          <leafValues>
+            3.5883820056915283e-01 5.3518110513687134e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 789 3.2021870720200241e-04</internalNodes>
+          <leafValues>
+            4.2968419194221497e-01 5.7002341747283936e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 790 7.4122188379988074e-04</internalNodes>
+          <leafValues>
+            5.2821648120880127e-01 3.3668708801269531e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 791 3.8330298848450184e-03</internalNodes>
+          <leafValues>
+            4.5595678687095642e-01 6.2573361396789551e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 792 -1.5456439927220345e-02</internalNodes>
+          <leafValues>
+            2.3501169681549072e-01 5.1294529438018799e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 793 2.6796779129654169e-03</internalNodes>
+          <leafValues>
+            5.3294152021408081e-01 4.1550621390342712e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 794 2.8296569362282753e-03</internalNodes>
+          <leafValues>
+            4.2730879783630371e-01 5.8045381307601929e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 795 -3.9444249123334885e-03</internalNodes>
+          <leafValues>
+            2.9126119613647461e-01 5.2026861906051636e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 796 2.7179559692740440e-03</internalNodes>
+          <leafValues>
+            5.3076881170272827e-01 3.5856771469116211e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 797 5.9077627956867218e-03</internalNodes>
+          <leafValues>
+            4.7037750482559204e-01 5.9415858983993530e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 798 -4.2240349575877190e-03</internalNodes>
+          <leafValues>
+            2.1415670216083527e-01 5.0887960195541382e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 799 4.0725888684391975e-03</internalNodes>
+          <leafValues>
+            4.7664138674736023e-01 6.8410611152648926e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 800 1.0149530135095119e-02</internalNodes>
+          <leafValues>
+            5.3607988357543945e-01 3.7484970688819885e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 801 -1.8864999583456665e-04</internalNodes>
+          <leafValues>
+            5.7201302051544189e-01 3.8538050651550293e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 802 -4.8864358104765415e-03</internalNodes>
+          <leafValues>
+            3.6931228637695312e-01 5.3409588336944580e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 803 2.6158479973673820e-02</internalNodes>
+          <leafValues>
+            4.9623748660087585e-01 6.0599899291992188e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 804 4.8560759751126170e-04</internalNodes>
+          <leafValues>
+            4.4389459490776062e-01 6.0124689340591431e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 805 1.1268709786236286e-02</internalNodes>
+          <leafValues>
+            5.2442502975463867e-01 1.8403880298137665e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 806 -2.8114619199186563e-03</internalNodes>
+          <leafValues>
+            6.0602837800979614e-01 4.4098970293998718e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 807 -5.6112729944288731e-03</internalNodes>
+          <leafValues>
+            3.8911709189414978e-01 5.5892372131347656e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 808 8.5680093616247177e-03</internalNodes>
+          <leafValues>
+            5.0693458318710327e-01 2.0626190304756165e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 809 -3.8172779022715986e-04</internalNodes>
+          <leafValues>
+            5.8822017908096313e-01 4.1926109790802002e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 810 -1.7680290329735726e-04</internalNodes>
+          <leafValues>
+            5.5336058139801025e-01 4.0033689141273499e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 811 6.5112537704408169e-03</internalNodes>
+          <leafValues>
+            3.3101469278335571e-01 5.4441910982131958e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 812 -6.5948683186434209e-05</internalNodes>
+          <leafValues>
+            5.4338318109512329e-01 3.9449059963226318e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 813 6.9939051754772663e-03</internalNodes>
+          <leafValues>
+            5.6003582477569580e-01 4.1927140951156616e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 814 -4.6744439750909805e-03</internalNodes>
+          <leafValues>
+            6.6854667663574219e-01 4.6049609780311584e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 815 1.1589850299060345e-02</internalNodes>
+          <leafValues>
+            5.3571212291717529e-01 2.9268300533294678e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 816 1.3007840141654015e-02</internalNodes>
+          <leafValues>
+            4.6798178553581238e-01 7.3074632883071899e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 817 -1.1008579749614000e-03</internalNodes>
+          <leafValues>
+            3.9375010132789612e-01 5.4150652885437012e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 818 6.0472649056464434e-04</internalNodes>
+          <leafValues>
+            4.2423760890960693e-01 5.6040412187576294e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 819 -1.4494840055704117e-02</internalNodes>
+          <leafValues>
+            3.6312100291252136e-01 5.2931827306747437e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 820 -5.3056948818266392e-03</internalNodes>
+          <leafValues>
+            6.8604522943496704e-01 4.6218210458755493e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 821 -8.1829127157106996e-04</internalNodes>
+          <leafValues>
+            3.9440968632698059e-01 5.4204392433166504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 822 -1.9077520817518234e-02</internalNodes>
+          <leafValues>
+            1.9626219570636749e-01 5.0378918647766113e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 823 3.5549470339901745e-04</internalNodes>
+          <leafValues>
+            4.0862590074539185e-01 5.6139731407165527e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 824 1.9679730758070946e-03</internalNodes>
+          <leafValues>
+            4.4891211390495300e-01 5.9261232614517212e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 825 6.9189141504466534e-03</internalNodes>
+          <leafValues>
+            5.3359258174896240e-01 3.7283858656883240e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 826 2.9872779268771410e-03</internalNodes>
+          <leafValues>
+            5.1113212108612061e-01 2.9756438732147217e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 827 -6.2264618463814259e-03</internalNodes>
+          <leafValues>
+            5.5414897203445435e-01 4.8245379328727722e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 828 1.3353300280869007e-02</internalNodes>
+          <leafValues>
+            4.5864239335060120e-01 6.4147979021072388e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 829 3.3505238592624664e-02</internalNodes>
+          <leafValues>
+            5.3924250602722168e-01 3.4299948811531067e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 830 -2.5294460356235504e-03</internalNodes>
+          <leafValues>
+            1.7037139832973480e-01 5.0133150815963745e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 831 -1.2801629491150379e-03</internalNodes>
+          <leafValues>
+            5.3054618835449219e-01 4.6974050998687744e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 832 7.0687388069927692e-03</internalNodes>
+          <leafValues>
+            4.6155458688735962e-01 6.4365047216415405e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 833 9.6880499040707946e-04</internalNodes>
+          <leafValues>
+            4.8335990309715271e-01 6.0438942909240723e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 834 3.9647659286856651e-03</internalNodes>
+          <leafValues>
+            5.1876372098922729e-01 3.2318168878555298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 835 -2.2057730704545975e-02</internalNodes>
+          <leafValues>
+            4.0792569518089294e-01 5.2009809017181396e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 836 -6.6906312713399529e-04</internalNodes>
+          <leafValues>
+            5.3316092491149902e-01 3.8156008720397949e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 837 -6.7009328631684184e-04</internalNodes>
+          <leafValues>
+            5.6554222106933594e-01 4.6889019012451172e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 838 7.4284552829340100e-04</internalNodes>
+          <leafValues>
+            4.5343810319900513e-01 6.2874001264572144e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 839 2.2227810695767403e-03</internalNodes>
+          <leafValues>
+            5.3506332635879517e-01 3.3036559820175171e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 840 -5.4130521602928638e-03</internalNodes>
+          <leafValues>
+            1.1136870086193085e-01 5.0054347515106201e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 841 -1.4520040167553816e-05</internalNodes>
+          <leafValues>
+            5.6287378072738647e-01 4.3251338601112366e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 842 2.3369169502984732e-04</internalNodes>
+          <leafValues>
+            4.1658350825309753e-01 5.4477912187576294e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 843 4.2894547805190086e-03</internalNodes>
+          <leafValues>
+            4.8603910207748413e-01 6.7786490917205811e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 844 5.9103150852024555e-03</internalNodes>
+          <leafValues>
+            5.2623051404953003e-01 3.6121138930320740e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 845 1.2900539673864841e-02</internalNodes>
+          <leafValues>
+            5.3193771839141846e-01 3.2502880692481995e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 846 4.6982979401946068e-03</internalNodes>
+          <leafValues>
+            4.6182450652122498e-01 6.6659259796142578e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 847 1.0439859703183174e-02</internalNodes>
+          <leafValues>
+            5.5056709051132202e-01 3.8836041092872620e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 848 3.0443191062659025e-03</internalNodes>
+          <leafValues>
+            4.6978530287742615e-01 7.3018449544906616e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 849 -6.1593751888722181e-04</internalNodes>
+          <leafValues>
+            3.8308390974998474e-01 5.4649841785430908e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 850 -3.4247159492224455e-03</internalNodes>
+          <leafValues>
+            2.5663000345230103e-01 5.0895309448242188e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 851 -9.3538565561175346e-03</internalNodes>
+          <leafValues>
+            6.4699661731719971e-01 4.9407958984375000e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 852 5.2338998764753342e-02</internalNodes>
+          <leafValues>
+            4.7459828853607178e-01 7.8787708282470703e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 853 3.5765620414167643e-03</internalNodes>
+          <leafValues>
+            5.3066647052764893e-01 2.7484980225563049e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 854 7.1555317845195532e-04</internalNodes>
+          <leafValues>
+            5.4131257534027100e-01 4.0419089794158936e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 855 -1.0516679845750332e-02</internalNodes>
+          <leafValues>
+            6.1585122346878052e-01 4.8152831196784973e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 856 7.7347927726805210e-03</internalNodes>
+          <leafValues>
+            4.6958059072494507e-01 7.0289808511734009e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 857 -4.3226778507232666e-03</internalNodes>
+          <leafValues>
+            2.8495660424232483e-01 5.3046840429306030e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 858 -2.5534399319440126e-03</internalNodes>
+          <leafValues>
+            7.0569849014282227e-01 4.6888920664787292e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 859 1.0268510231981054e-04</internalNodes>
+          <leafValues>
+            3.9029321074485779e-01 5.5734640359878540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 860 7.1395188570022583e-06</internalNodes>
+          <leafValues>
+            3.6842319369316101e-01 5.2639877796173096e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 861 -1.6711989883333445e-03</internalNodes>
+          <leafValues>
+            3.8491758704185486e-01 5.3872710466384888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 862 4.9260449595749378e-03</internalNodes>
+          <leafValues>
+            4.7297719120979309e-01 7.4472510814666748e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 863 4.3908702209591866e-03</internalNodes>
+          <leafValues>
+            4.8091810941696167e-01 5.5919218063354492e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 864 -1.7793629318475723e-02</internalNodes>
+          <leafValues>
+            6.9036781787872314e-01 4.6769270300865173e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 865 2.0469669252634048e-03</internalNodes>
+          <leafValues>
+            5.3706902265548706e-01 3.3081620931625366e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 866 2.9891489073634148e-02</internalNodes>
+          <leafValues>
+            5.1398652791976929e-01 3.3090591430664062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 867 1.5494900289922953e-03</internalNodes>
+          <leafValues>
+            4.6602371335029602e-01 6.0783427953720093e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 868 1.4956969534978271e-03</internalNodes>
+          <leafValues>
+            4.4048359990119934e-01 5.8639198541641235e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 869 9.5885928021743894e-04</internalNodes>
+          <leafValues>
+            5.4359710216522217e-01 4.2085230350494385e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 870 4.9643701640889049e-04</internalNodes>
+          <leafValues>
+            5.3705781698226929e-01 4.0006220340728760e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 871 -2.7280810754746199e-03</internalNodes>
+          <leafValues>
+            5.6594127416610718e-01 4.2596429586410522e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 872 2.3026480339467525e-03</internalNodes>
+          <leafValues>
+            5.1616579294204712e-01 3.3508691191673279e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 873 2.5151631236076355e-01</internalNodes>
+          <leafValues>
+            4.8696619272232056e-01 7.1473097801208496e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 874 -4.6328022144734859e-03</internalNodes>
+          <leafValues>
+            2.7274489402770996e-01 5.0837898254394531e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 875 -4.0434490889310837e-02</internalNodes>
+          <leafValues>
+            6.8514388799667358e-01 5.0217670202255249e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 876 1.4972220014897175e-05</internalNodes>
+          <leafValues>
+            4.2844650149345398e-01 5.5225551128387451e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 877 -2.4050309730228037e-04</internalNodes>
+          <leafValues>
+            4.2261189222335815e-01 5.3900748491287231e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 878 2.3657839745283127e-02</internalNodes>
+          <leafValues>
+            4.7446319460868835e-01 7.5043660402297974e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 879 -8.1449104472994804e-03</internalNodes>
+          <leafValues>
+            4.2450588941574097e-01 5.5383628606796265e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 880 -3.6992130335420370e-03</internalNodes>
+          <leafValues>
+            5.9523570537567139e-01 4.5297130942344666e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 881 -6.7718601785600185e-03</internalNodes>
+          <leafValues>
+            4.1377940773963928e-01 5.4733997583389282e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 882 4.2669530957937241e-03</internalNodes>
+          <leafValues>
+            4.4841149449348450e-01 5.7979941368103027e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 883 1.7791989957913756e-03</internalNodes>
+          <leafValues>
+            5.6248587369918823e-01 4.4324448704719543e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 884 1.6774770338088274e-03</internalNodes>
+          <leafValues>
+            4.6377518773078918e-01 6.3642418384552002e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 885 1.1732629500329494e-03</internalNodes>
+          <leafValues>
+            4.5445030927658081e-01 5.9144157171249390e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 886 8.6998171173036098e-04</internalNodes>
+          <leafValues>
+            5.3347527980804443e-01 3.8859179615974426e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 887 7.6378340600058436e-04</internalNodes>
+          <leafValues>
+            5.3985852003097534e-01 3.7449419498443604e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 888 1.5684569370932877e-04</internalNodes>
+          <leafValues>
+            4.3178731203079224e-01 5.6146162748336792e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 889 -2.1511370316147804e-02</internalNodes>
+          <leafValues>
+            1.7859250307083130e-01 5.1855427026748657e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 890 1.3081369979772717e-04</internalNodes>
+          <leafValues>
+            4.3424990773200989e-01 5.6828498840332031e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 891 2.1992040798068047e-02</internalNodes>
+          <leafValues>
+            5.1617169380187988e-01 2.3793940246105194e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 892 -8.0136500764638186e-04</internalNodes>
+          <leafValues>
+            5.9867632389068604e-01 4.4664269685745239e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 893 -8.2736099138855934e-03</internalNodes>
+          <leafValues>
+            4.1082179546356201e-01 5.2510571479797363e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 894 3.6831789184361696e-03</internalNodes>
+          <leafValues>
+            5.1738142967224121e-01 3.3975180983543396e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 895 -7.9525681212544441e-03</internalNodes>
+          <leafValues>
+            6.8889832496643066e-01 4.8459240794181824e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 896 1.5382299898192286e-03</internalNodes>
+          <leafValues>
+            5.1785671710968018e-01 3.4541139006614685e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 897 -1.4043530449271202e-02</internalNodes>
+          <leafValues>
+            1.6784210503101349e-01 5.1886677742004395e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 898 1.4315890148282051e-03</internalNodes>
+          <leafValues>
+            4.3682569265365601e-01 5.6557738780975342e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 899 -3.4014228731393814e-02</internalNodes>
+          <leafValues>
+            7.8022962808609009e-01 4.9592170119285583e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 900 -1.2027299962937832e-02</internalNodes>
+          <leafValues>
+            1.5851010382175446e-01 5.0322318077087402e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 901 1.3316619396209717e-01</internalNodes>
+          <leafValues>
+            5.1633048057556152e-01 2.7551281452178955e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 902 -1.5221949433907866e-03</internalNodes>
+          <leafValues>
+            3.7283179163932800e-01 5.2145522832870483e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 903 -9.3929271679371595e-04</internalNodes>
+          <leafValues>
+            5.8383792638778687e-01 4.5111650228500366e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 904 2.7719739824533463e-02</internalNodes>
+          <leafValues>
+            4.7282868623733521e-01 7.3315447568893433e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 905 3.1030150130391121e-03</internalNodes>
+          <leafValues>
+            5.3022021055221558e-01 4.1015630960464478e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 906 7.7861219644546509e-02</internalNodes>
+          <leafValues>
+            4.9983340501785278e-01 1.2729619443416595e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 907 -1.5854939818382263e-02</internalNodes>
+          <leafValues>
+            5.0833359360694885e-02 5.1656562089920044e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 908 -4.9725300632417202e-03</internalNodes>
+          <leafValues>
+            6.7981338500976562e-01 4.6842318773269653e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 909 -9.7676506265997887e-04</internalNodes>
+          <leafValues>
+            6.0107719898223877e-01 4.7889319062232971e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 910 -2.4647710379213095e-03</internalNodes>
+          <leafValues>
+            3.3933979272842407e-01 5.2205038070678711e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 911 -6.7937700077891350e-03</internalNodes>
+          <leafValues>
+            4.3651369214057922e-01 5.2396631240844727e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 912 3.2608021050691605e-02</internalNodes>
+          <leafValues>
+            5.0527238845825195e-01 2.4252149462699890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 913 -5.8514421107247472e-04</internalNodes>
+          <leafValues>
+            5.7339739799499512e-01 4.7585740685462952e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 914 -2.9632600024342537e-02</internalNodes>
+          <leafValues>
+            3.8922891020774841e-01 5.2635979652404785e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>137</maxWeakCount>
+      <stageThreshold>6.7698921203613281e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 915 4.6550851315259933e-02</internalNodes>
+          <leafValues>
+            3.2769501209259033e-01 6.2405228614807129e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 916 7.9537127166986465e-03</internalNodes>
+          <leafValues>
+            4.2564851045608521e-01 6.9429391622543335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 917 6.8221561377868056e-04</internalNodes>
+          <leafValues>
+            3.7114870548248291e-01 5.9007328748703003e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 918 -1.9348249770700932e-04</internalNodes>
+          <leafValues>
+            2.0411339402198792e-01 5.3005450963973999e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 919 -2.6710508973337710e-04</internalNodes>
+          <leafValues>
+            5.4161262512207031e-01 3.1031790375709534e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 920 2.7818060480058193e-03</internalNodes>
+          <leafValues>
+            5.2778327465057373e-01 3.4670698642730713e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 921 -4.6779078547842801e-04</internalNodes>
+          <leafValues>
+            5.3082311153411865e-01 3.2944920659065247e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 922 -3.0335160772665404e-05</internalNodes>
+          <leafValues>
+            5.7738727331161499e-01 3.8520970940589905e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 923 7.8038009814918041e-04</internalNodes>
+          <leafValues>
+            4.3174389004707336e-01 6.1500579118728638e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 924 -4.2553851380944252e-03</internalNodes>
+          <leafValues>
+            2.9339039325714111e-01 5.3242927789688110e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 925 -2.4735610350035131e-04</internalNodes>
+          <leafValues>
+            5.4688447713851929e-01 3.8430300354957581e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 926 -1.4724259381182492e-04</internalNodes>
+          <leafValues>
+            4.2815428972244263e-01 5.7555872201919556e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 927 1.1864770203828812e-03</internalNodes>
+          <leafValues>
+            3.7473011016845703e-01 5.4714661836624146e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 928 2.3936580400913954e-03</internalNodes>
+          <leafValues>
+            4.5377838611602783e-01 6.1115288734436035e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 929 -1.5390539774671197e-03</internalNodes>
+          <leafValues>
+            2.9713419079780579e-01 5.1895380020141602e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 930 -7.1968790143728256e-03</internalNodes>
+          <leafValues>
+            6.6990667581558228e-01 4.7264769673347473e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 931 -4.1499789222143590e-04</internalNodes>
+          <leafValues>
+            3.3849540352821350e-01 5.2603179216384888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 932 4.4359830208122730e-03</internalNodes>
+          <leafValues>
+            5.3991222381591797e-01 3.9201408624649048e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 933 2.6606200262904167e-03</internalNodes>
+          <leafValues>
+            4.4825780391693115e-01 6.1196178197860718e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 934 -1.5287200221791863e-03</internalNodes>
+          <leafValues>
+            3.7112379074096680e-01 5.3402662277221680e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 935 -4.7397250309586525e-03</internalNodes>
+          <leafValues>
+            6.0310882329940796e-01 4.4551450014114380e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 936 -1.4829129911959171e-02</internalNodes>
+          <leafValues>
+            2.8387540578842163e-01 5.3418618440628052e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 937 9.2275557108223438e-04</internalNodes>
+          <leafValues>
+            5.2095472812652588e-01 3.3616539835929871e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 938 8.3529807627201080e-02</internalNodes>
+          <leafValues>
+            5.1199698448181152e-01 8.1164449453353882e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 939 -7.5633148662745953e-04</internalNodes>
+          <leafValues>
+            3.3171200752258301e-01 5.1898312568664551e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 940 9.8403859883546829e-03</internalNodes>
+          <leafValues>
+            5.2475982904434204e-01 2.3349590599536896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 941 -1.5953830443322659e-03</internalNodes>
+          <leafValues>
+            5.7500940561294556e-01 4.2956221103668213e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 942 3.4766020689858124e-05</internalNodes>
+          <leafValues>
+            4.3424451351165771e-01 5.5640292167663574e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 943 2.9862910509109497e-02</internalNodes>
+          <leafValues>
+            4.5791471004486084e-01 6.5791881084442139e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 944 1.1325590312480927e-02</internalNodes>
+          <leafValues>
+            5.2743119001388550e-01 3.6738881468772888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 945 -8.7828645482659340e-03</internalNodes>
+          <leafValues>
+            7.1003687381744385e-01 4.6421670913696289e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 946 4.3639959767460823e-03</internalNodes>
+          <leafValues>
+            5.2792161703109741e-01 2.7058771252632141e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 947 4.1804728098213673e-03</internalNodes>
+          <leafValues>
+            5.0725251436233521e-01 2.4490830302238464e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 948 -4.5668511302210391e-04</internalNodes>
+          <leafValues>
+            4.2831051349639893e-01 5.5486911535263062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 949 -3.7140368949621916e-03</internalNodes>
+          <leafValues>
+            5.5193877220153809e-01 4.1036531329154968e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 950 -2.5304289534687996e-02</internalNodes>
+          <leafValues>
+            6.8670022487640381e-01 4.8698890209197998e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 951 -3.4454080741852522e-04</internalNodes>
+          <leafValues>
+            3.7288740277290344e-01 5.2876931428909302e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 952 -8.3935231668874621e-04</internalNodes>
+          <leafValues>
+            6.0601520538330078e-01 4.6160620450973511e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 953 1.7280049622058868e-02</internalNodes>
+          <leafValues>
+            5.0496357679367065e-01 1.8198239803314209e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 954 -6.3595077954232693e-03</internalNodes>
+          <leafValues>
+            1.6312399506568909e-01 5.2327787876129150e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 955 1.0298109846189618e-03</internalNodes>
+          <leafValues>
+            4.4632780551910400e-01 6.1765491962432861e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 956 1.0117109632119536e-03</internalNodes>
+          <leafValues>
+            5.4733848571777344e-01 4.3006989359855652e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 957 -1.0308800265192986e-02</internalNodes>
+          <leafValues>
+            1.1669850349426270e-01 5.0008672475814819e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 958 5.4682018235325813e-03</internalNodes>
+          <leafValues>
+            4.7692871093750000e-01 6.7192137241363525e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 959 -9.1696460731327534e-04</internalNodes>
+          <leafValues>
+            3.4710898995399475e-01 5.1781648397445679e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 960 2.3922820109874010e-03</internalNodes>
+          <leafValues>
+            4.7852361202239990e-01 6.2163108587265015e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 961 -7.5573818758130074e-03</internalNodes>
+          <leafValues>
+            5.8147960901260376e-01 4.4100850820541382e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 962 -7.7024032361805439e-04</internalNodes>
+          <leafValues>
+            3.8780000805854797e-01 5.4657220840454102e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 963 -8.7125990539789200e-03</internalNodes>
+          <leafValues>
+            1.6600510478019714e-01 4.9958360195159912e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 964 -1.0306320153176785e-02</internalNodes>
+          <leafValues>
+            4.0933910012245178e-01 5.2742338180541992e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 965 -2.0940979011356831e-03</internalNodes>
+          <leafValues>
+            6.2061947584152222e-01 4.5722800493240356e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 966 6.8099051713943481e-03</internalNodes>
+          <leafValues>
+            5.5677592754364014e-01 4.1556000709533691e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 967 -1.0746059706434608e-03</internalNodes>
+          <leafValues>
+            5.6389278173446655e-01 4.3530249595642090e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 968 2.1550289820879698e-03</internalNodes>
+          <leafValues>
+            4.8262658715248108e-01 6.7497581243515015e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 969 3.1742319464683533e-02</internalNodes>
+          <leafValues>
+            5.0483798980712891e-01 1.8832489848136902e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 970 -7.8382723033428192e-02</internalNodes>
+          <leafValues>
+            2.3695489764213562e-01 5.2601581811904907e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 971 5.7415119372308254e-03</internalNodes>
+          <leafValues>
+            5.0488287210464478e-01 2.7764698863029480e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 972 -2.9014600440859795e-03</internalNodes>
+          <leafValues>
+            6.2386047840118408e-01 4.6933171153068542e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 973 -2.6427931152284145e-03</internalNodes>
+          <leafValues>
+            3.3141419291496277e-01 5.1697772741317749e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 974 -1.0949660092592239e-01</internalNodes>
+          <leafValues>
+            2.3800450563430786e-01 5.1834410429000854e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 975 7.4075913289561868e-05</internalNodes>
+          <leafValues>
+            4.0696358680725098e-01 5.3621500730514526e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 976 -5.0593802006915212e-04</internalNodes>
+          <leafValues>
+            5.5067062377929688e-01 4.3745940923690796e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 977 -8.2131777890026569e-04</internalNodes>
+          <leafValues>
+            5.5257099866867065e-01 4.2093759775161743e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 978 -6.0276539443293586e-05</internalNodes>
+          <leafValues>
+            5.4554748535156250e-01 4.7482660412788391e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 979 6.8065142259001732e-03</internalNodes>
+          <leafValues>
+            5.1579958200454712e-01 3.4245771169662476e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 980 1.7202789895236492e-03</internalNodes>
+          <leafValues>
+            5.0132077932357788e-01 6.3312637805938721e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 981 -1.3016929733566940e-04</internalNodes>
+          <leafValues>
+            5.5397182703018188e-01 4.2268699407577515e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 982 -4.8016388900578022e-03</internalNodes>
+          <leafValues>
+            4.4250950217247009e-01 5.4307800531387329e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 983 -2.5399310979992151e-03</internalNodes>
+          <leafValues>
+            7.1457821130752563e-01 4.6976050734519958e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 984 -1.4278929447755218e-03</internalNodes>
+          <leafValues>
+            4.0704450011253357e-01 5.3996050357818604e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 985 -2.5142550468444824e-02</internalNodes>
+          <leafValues>
+            7.8846907615661621e-01 4.7473520040512085e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 986 -3.8899609353393316e-03</internalNodes>
+          <leafValues>
+            4.2961919307708740e-01 5.5771100521087646e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 987 4.3947459198534489e-03</internalNodes>
+          <leafValues>
+            4.6931621432304382e-01 7.0239442586898804e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 988 2.4678420275449753e-02</internalNodes>
+          <leafValues>
+            5.2423220872879028e-01 3.8125100731849670e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 989 3.8047678768634796e-02</internalNodes>
+          <leafValues>
+            5.0117397308349609e-01 1.6878280043601990e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 990 7.9424865543842316e-03</internalNodes>
+          <leafValues>
+            4.8285821080207825e-01 6.3695681095123291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 991 -1.5110049862414598e-03</internalNodes>
+          <leafValues>
+            5.9064859151840210e-01 4.4876679778099060e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 992 6.4201741479337215e-03</internalNodes>
+          <leafValues>
+            5.2410978078842163e-01 2.9905700683593750e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 993 -2.9802159406244755e-03</internalNodes>
+          <leafValues>
+            3.0414658784866333e-01 5.0784897804260254e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 994 -7.4580078944563866e-04</internalNodes>
+          <leafValues>
+            4.1281390190124512e-01 5.2568262815475464e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 995 -1.0470950044691563e-02</internalNodes>
+          <leafValues>
+            5.8083951473236084e-01 4.4942960143089294e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 996 9.3369204550981522e-03</internalNodes>
+          <leafValues>
+            5.2465528249740601e-01 2.6589488983154297e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 997 2.7936900034546852e-02</internalNodes>
+          <leafValues>
+            4.6749550104141235e-01 7.0872569084167480e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 998 7.4277678504586220e-03</internalNodes>
+          <leafValues>
+            5.4094868898391724e-01 3.7585180997848511e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 999 -2.3584509268403053e-02</internalNodes>
+          <leafValues>
+            3.7586399912834167e-01 5.2385509014129639e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1000 1.1452640173956752e-03</internalNodes>
+          <leafValues>
+            4.3295788764953613e-01 5.8042472600936890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1001 -4.3468660442158580e-04</internalNodes>
+          <leafValues>
+            5.2806180715560913e-01 3.8730698823928833e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1002 1.0648540221154690e-02</internalNodes>
+          <leafValues>
+            4.9021130800247192e-01 5.6812518835067749e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1003 -3.9418050437234342e-04</internalNodes>
+          <leafValues>
+            5.5708801746368408e-01 4.3182510137557983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1004 -1.3270479394122958e-04</internalNodes>
+          <leafValues>
+            5.6584399938583374e-01 4.3435549736022949e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1005 -2.0125510636717081e-03</internalNodes>
+          <leafValues>
+            6.0567390918731689e-01 4.5375239849090576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1006 2.4854319635778666e-03</internalNodes>
+          <leafValues>
+            5.3904771804809570e-01 4.1380101442337036e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1007 1.8237880431115627e-03</internalNodes>
+          <leafValues>
+            4.3548288941383362e-01 5.7171887159347534e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1008 -1.6656659543514252e-02</internalNodes>
+          <leafValues>
+            3.0109131336212158e-01 5.2161228656768799e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1009 8.0349558265879750e-04</internalNodes>
+          <leafValues>
+            5.3001511096954346e-01 3.8183969259262085e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1010 3.4170378930866718e-03</internalNodes>
+          <leafValues>
+            5.3280287981033325e-01 4.2414000630378723e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1011 -3.6222729249857366e-04</internalNodes>
+          <leafValues>
+            5.4917281866073608e-01 4.1869771480560303e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1012 -1.1630020290613174e-01</internalNodes>
+          <leafValues>
+            1.4407220482826233e-01 5.2264511585235596e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1013 -1.4695010147988796e-02</internalNodes>
+          <leafValues>
+            7.7477252483367920e-01 4.7157171368598938e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1014 2.1972130052745342e-03</internalNodes>
+          <leafValues>
+            5.3554338216781616e-01 3.3156448602676392e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1015 -4.6965209185145795e-04</internalNodes>
+          <leafValues>
+            5.7672351598739624e-01 4.4581368565559387e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1016 6.5144998952746391e-03</internalNodes>
+          <leafValues>
+            5.2156740427017212e-01 3.6478888988494873e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1017 2.1300060674548149e-02</internalNodes>
+          <leafValues>
+            4.9942049384117126e-01 1.5679509937763214e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1018 3.1881409231573343e-03</internalNodes>
+          <leafValues>
+            4.7422000765800476e-01 6.2872701883316040e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1019 9.0019777417182922e-04</internalNodes>
+          <leafValues>
+            5.3479540348052979e-01 3.9437520503997803e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1020 -5.1772277802228928e-03</internalNodes>
+          <leafValues>
+            6.7271918058395386e-01 5.0131380558013916e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1021 -4.3764649890363216e-03</internalNodes>
+          <leafValues>
+            3.1066751480102539e-01 5.1287931203842163e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1022 2.6299960445612669e-03</internalNodes>
+          <leafValues>
+            4.8863101005554199e-01 5.7552158832550049e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1023 -2.0458688959479332e-03</internalNodes>
+          <leafValues>
+            6.0257941484451294e-01 4.5580768585205078e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1024 6.9482706487178802e-02</internalNodes>
+          <leafValues>
+            5.2407479286193848e-01 2.1852590143680573e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1025 2.4048939347267151e-02</internalNodes>
+          <leafValues>
+            5.0118672847747803e-01 2.0906220376491547e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1026 3.1095340382307768e-03</internalNodes>
+          <leafValues>
+            4.8667120933532715e-01 7.1085482835769653e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1027 -1.2503260513767600e-03</internalNodes>
+          <leafValues>
+            3.4078910946846008e-01 5.1561951637268066e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1028 -1.0281190043315291e-03</internalNodes>
+          <leafValues>
+            5.5755722522735596e-01 4.4394320249557495e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1029 -8.8893622159957886e-03</internalNodes>
+          <leafValues>
+            6.4020007848739624e-01 4.6204420924186707e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1030 -6.1094801640138030e-04</internalNodes>
+          <leafValues>
+            3.7664419412612915e-01 5.4488998651504517e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1031 -5.7686357758939266e-03</internalNodes>
+          <leafValues>
+            3.3186489343643188e-01 5.1336771249771118e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1032 1.8506490159779787e-03</internalNodes>
+          <leafValues>
+            4.9035701155662537e-01 6.4069348573684692e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1033 -9.9799469113349915e-02</internalNodes>
+          <leafValues>
+            1.5360510349273682e-01 5.0155621767044067e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1034 -3.5128349065780640e-01</internalNodes>
+          <leafValues>
+            5.8823131024837494e-02 5.1743787527084351e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1035 -4.5244570821523666e-02</internalNodes>
+          <leafValues>
+            6.9614887237548828e-01 4.6778729557991028e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1036 7.1481578052043915e-02</internalNodes>
+          <leafValues>
+            5.1679861545562744e-01 1.0380929708480835e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1037 2.1895780228078365e-03</internalNodes>
+          <leafValues>
+            4.2730781435966492e-01 5.5320608615875244e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1038 -5.9242651332169771e-04</internalNodes>
+          <leafValues>
+            4.6389439702033997e-01 5.2763891220092773e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1039 1.6788389766588807e-03</internalNodes>
+          <leafValues>
+            5.3016489744186401e-01 3.9320349693298340e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1040 -2.2163488902151585e-03</internalNodes>
+          <leafValues>
+            5.6306940317153931e-01 4.7570338845252991e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1041 1.1568699846975505e-04</internalNodes>
+          <leafValues>
+            4.3075358867645264e-01 5.5357027053833008e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1042 -7.2017288766801357e-03</internalNodes>
+          <leafValues>
+            1.4448820054531097e-01 5.1930642127990723e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1043 8.9081272017210722e-04</internalNodes>
+          <leafValues>
+            4.3844321370124817e-01 5.5936211347579956e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1044 1.9605009583756328e-04</internalNodes>
+          <leafValues>
+            5.3404158353805542e-01 4.7059568762779236e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1045 5.2022142335772514e-04</internalNodes>
+          <leafValues>
+            5.2138561010360718e-01 3.8100790977478027e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1046 9.4588572392240167e-04</internalNodes>
+          <leafValues>
+            4.7694149613380432e-01 6.1307388544082642e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1047 9.1698471806012094e-05</internalNodes>
+          <leafValues>
+            4.2450091242790222e-01 5.4293632507324219e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1048 2.1833200007677078e-03</internalNodes>
+          <leafValues>
+            5.4577308893203735e-01 4.1910758614540100e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1049 -8.6039671441540122e-04</internalNodes>
+          <leafValues>
+            5.7645887136459351e-01 4.4716599583625793e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1050 -1.3236239552497864e-02</internalNodes>
+          <leafValues>
+            6.3728231191635132e-01 4.6950098872184753e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1051 4.3376701069064438e-04</internalNodes>
+          <leafValues>
+            5.3178739547729492e-01 3.9458298683166504e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>140</maxWeakCount>
+      <stageThreshold>6.9229873657226562e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1052 -2.4847149848937988e-02</internalNodes>
+          <leafValues>
+            6.5555167198181152e-01 3.8733118772506714e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1053 6.1348611488938332e-03</internalNodes>
+          <leafValues>
+            3.7480720877647400e-01 5.9739977121353149e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1054 6.4498498104512691e-03</internalNodes>
+          <leafValues>
+            5.4254919290542603e-01 2.5488111376762390e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1055 6.3491211039945483e-04</internalNodes>
+          <leafValues>
+            2.4624420702457428e-01 5.3872537612915039e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1056 1.4023890253156424e-03</internalNodes>
+          <leafValues>
+            5.5943220853805542e-01 3.5286578536033630e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1057 3.0044000595808029e-04</internalNodes>
+          <leafValues>
+            3.9585039019584656e-01 5.7659381628036499e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1058 1.0042409849120304e-04</internalNodes>
+          <leafValues>
+            3.6989969015121460e-01 5.5349981784820557e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1059 -5.0841490738093853e-03</internalNodes>
+          <leafValues>
+            3.7110909819602966e-01 5.5478000640869141e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1060 -1.9537260755896568e-02</internalNodes>
+          <leafValues>
+            7.4927550554275513e-01 4.5792970061302185e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1061 -7.4532740654831287e-06</internalNodes>
+          <leafValues>
+            5.6497871875762939e-01 3.9040699601173401e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1062 -3.6079459823668003e-03</internalNodes>
+          <leafValues>
+            3.3810880780220032e-01 5.2678012847900391e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1063 2.0697501022368670e-03</internalNodes>
+          <leafValues>
+            5.5192911624908447e-01 3.7143889069557190e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1064 -4.6463840408250690e-04</internalNodes>
+          <leafValues>
+            5.6082147359848022e-01 4.1135668754577637e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1065 7.5490452582016587e-04</internalNodes>
+          <leafValues>
+            3.5592061281204224e-01 5.3293561935424805e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1066 -9.8322238773107529e-04</internalNodes>
+          <leafValues>
+            5.4147958755493164e-01 3.7632051110267639e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1067 -1.9940640777349472e-02</internalNodes>
+          <leafValues>
+            6.3479030132293701e-01 4.7052991390228271e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1068 3.7680300883948803e-03</internalNodes>
+          <leafValues>
+            3.9134898781776428e-01 5.5637162923812866e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1069 -9.4528505578637123e-03</internalNodes>
+          <leafValues>
+            2.5548928976058960e-01 5.2151167392730713e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1070 2.9560849070549011e-03</internalNodes>
+          <leafValues>
+            5.1746791601181030e-01 3.0639201402664185e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1071 9.1078737750649452e-03</internalNodes>
+          <leafValues>
+            5.3884482383728027e-01 2.8859630227088928e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1072 1.8219229532405734e-03</internalNodes>
+          <leafValues>
+            4.3360430002212524e-01 5.8521968126296997e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1073 1.4688739553093910e-02</internalNodes>
+          <leafValues>
+            5.2873617410659790e-01 2.8700059652328491e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1074 -1.4387990348041058e-02</internalNodes>
+          <leafValues>
+            7.0194488763809204e-01 4.6473708748817444e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1075 -1.8986649811267853e-02</internalNodes>
+          <leafValues>
+            2.9865521192550659e-01 5.2470117807388306e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1076 1.1527639580890536e-03</internalNodes>
+          <leafValues>
+            4.3234738707542419e-01 5.9316617250442505e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1077 1.0933670215308666e-02</internalNodes>
+          <leafValues>
+            5.2868640422821045e-01 3.1303191184997559e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1078 -1.4932730235159397e-02</internalNodes>
+          <leafValues>
+            2.6584190130233765e-01 5.0840771198272705e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1079 -2.9970539617352188e-04</internalNodes>
+          <leafValues>
+            5.4635268449783325e-01 3.7407240271568298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1080 4.1677621193230152e-03</internalNodes>
+          <leafValues>
+            4.7034969925880432e-01 7.4357217550277710e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1081 -6.3905320130288601e-03</internalNodes>
+          <leafValues>
+            2.0692589879035950e-01 5.2805382013320923e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1082 4.5029609464108944e-03</internalNodes>
+          <leafValues>
+            5.1826488971710205e-01 3.4835430979728699e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1083 -9.2040365561842918e-03</internalNodes>
+          <leafValues>
+            6.8037772178649902e-01 4.9323600530624390e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1084 8.1327259540557861e-02</internalNodes>
+          <leafValues>
+            5.0583988428115845e-01 2.2530519962310791e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1085 -1.5079280734062195e-01</internalNodes>
+          <leafValues>
+            2.9634249210357666e-01 5.2646797895431519e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1086 3.3179009333252907e-03</internalNodes>
+          <leafValues>
+            4.6554958820343018e-01 7.0729321241378784e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1087 7.7402801252901554e-04</internalNodes>
+          <leafValues>
+            4.7803479433059692e-01 5.6682378053665161e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1088 6.8199541419744492e-04</internalNodes>
+          <leafValues>
+            4.2869961261749268e-01 5.7221567630767822e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1089 5.3671570494771004e-03</internalNodes>
+          <leafValues>
+            5.2993071079254150e-01 3.1146219372749329e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1090 9.7018666565418243e-05</internalNodes>
+          <leafValues>
+            3.6746388673782349e-01 5.2694618701934814e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1091 -1.2534089386463165e-01</internalNodes>
+          <leafValues>
+            2.3514920473098755e-01 5.2457910776138306e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1092 -5.2516269497573376e-03</internalNodes>
+          <leafValues>
+            7.1159368753433228e-01 4.6937671303749084e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1093 -7.8342109918594360e-03</internalNodes>
+          <leafValues>
+            4.4626510143280029e-01 5.4090857505798340e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1094 -1.1310069821774960e-03</internalNodes>
+          <leafValues>
+            5.9456187486648560e-01 4.4176620244979858e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1095 1.7601120052859187e-03</internalNodes>
+          <leafValues>
+            5.3532499074935913e-01 3.9734530448913574e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1096 -8.1581249833106995e-04</internalNodes>
+          <leafValues>
+            3.7602680921554565e-01 5.2647268772125244e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1097 -3.8687589112669230e-03</internalNodes>
+          <leafValues>
+            6.3099128007888794e-01 4.7498199343681335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1098 1.5207129763439298e-03</internalNodes>
+          <leafValues>
+            5.2301818132400513e-01 3.3612239360809326e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1099 5.4586738348007202e-01</internalNodes>
+          <leafValues>
+            5.1671397686004639e-01 1.1726350337266922e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1100 1.5650190412998199e-02</internalNodes>
+          <leafValues>
+            4.9794390797615051e-01 1.3932949304580688e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1101 -1.1731860227882862e-02</internalNodes>
+          <leafValues>
+            7.1296507120132446e-01 4.9211961030960083e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1102 -6.1765122227370739e-03</internalNodes>
+          <leafValues>
+            2.2881029546260834e-01 5.0497019290924072e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1103 2.2457661107182503e-03</internalNodes>
+          <leafValues>
+            4.6324339509010315e-01 6.0487258434295654e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1104 -5.1915869116783142e-03</internalNodes>
+          <leafValues>
+            6.4674210548400879e-01 4.6021929383277893e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1105 -2.3827880620956421e-02</internalNodes>
+          <leafValues>
+            1.4820009469985962e-01 5.2260792255401611e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1106 1.0284580057486892e-03</internalNodes>
+          <leafValues>
+            5.1354891061782837e-01 3.3759570121765137e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1107 -1.0078850202262402e-02</internalNodes>
+          <leafValues>
+            2.7405610680580139e-01 5.3035670518875122e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1108 2.6168930344283581e-03</internalNodes>
+          <leafValues>
+            5.3326708078384399e-01 3.9724540710449219e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1109 5.4385367548093200e-04</internalNodes>
+          <leafValues>
+            5.3656041622161865e-01 4.0634119510650635e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1110 5.3510512225329876e-03</internalNodes>
+          <leafValues>
+            4.6537590026855469e-01 6.8890458345413208e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1111 -1.5274790348485112e-03</internalNodes>
+          <leafValues>
+            5.4495012760162354e-01 3.6247238516807556e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1112 -8.0624416470527649e-02</internalNodes>
+          <leafValues>
+            1.6560870409011841e-01 5.0002872943878174e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1113 2.2192029282450676e-02</internalNodes>
+          <leafValues>
+            5.1327311992645264e-01 2.0028080046176910e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1114 7.3100631125271320e-03</internalNodes>
+          <leafValues>
+            4.6179479360580444e-01 6.3665360212326050e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1115 -6.4063072204589844e-03</internalNodes>
+          <leafValues>
+            5.9162509441375732e-01 4.8678609728813171e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1116 -7.6415040530264378e-04</internalNodes>
+          <leafValues>
+            3.8884091377258301e-01 5.3157979249954224e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1117 7.6734489994123578e-04</internalNodes>
+          <leafValues>
+            4.1590648889541626e-01 5.6052798032760620e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1118 6.1474501853808761e-04</internalNodes>
+          <leafValues>
+            3.0890220403671265e-01 5.1201480627059937e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1119 -5.0105270929634571e-03</internalNodes>
+          <leafValues>
+            3.9721998572349548e-01 5.2073061466217041e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1120 -8.6909132078289986e-03</internalNodes>
+          <leafValues>
+            6.2574082612991333e-01 4.6085759997367859e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1121 -1.6391459852457047e-02</internalNodes>
+          <leafValues>
+            2.0852099359035492e-01 5.2422660589218140e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1122 4.0973909199237823e-04</internalNodes>
+          <leafValues>
+            5.2224272489547729e-01 3.7803208827972412e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1123 -2.5242289993911982e-03</internalNodes>
+          <leafValues>
+            5.8039271831512451e-01 4.6118900179862976e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1124 5.0945312250405550e-04</internalNodes>
+          <leafValues>
+            4.4012719392776489e-01 5.8460158109664917e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1125 1.9656419754028320e-03</internalNodes>
+          <leafValues>
+            5.3223252296447754e-01 4.1845908761024475e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1126 5.6298897834494710e-04</internalNodes>
+          <leafValues>
+            3.7418448925018311e-01 5.2345657348632812e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1127 -6.7946797935292125e-04</internalNodes>
+          <leafValues>
+            4.6310418844223022e-01 5.3564780950546265e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1128 7.2856349870562553e-03</internalNodes>
+          <leafValues>
+            5.0446701049804688e-01 2.3775640130043030e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1129 -1.7459489405155182e-02</internalNodes>
+          <leafValues>
+            7.2891211509704590e-01 5.0504350662231445e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1130 -2.5421749800443649e-02</internalNodes>
+          <leafValues>
+            6.6671347618103027e-01 4.6781000494956970e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1131 -1.5647639520466328e-03</internalNodes>
+          <leafValues>
+            4.3917590379714966e-01 5.3236269950866699e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1132 1.1444360017776489e-02</internalNodes>
+          <leafValues>
+            4.3464401364326477e-01 5.6800121068954468e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1133 -6.7352550104260445e-04</internalNodes>
+          <leafValues>
+            4.4771409034729004e-01 5.2968120574951172e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1134 9.3194209039211273e-03</internalNodes>
+          <leafValues>
+            4.7402000427246094e-01 7.4626070261001587e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1135 1.3328490604180843e-04</internalNodes>
+          <leafValues>
+            5.3650617599487305e-01 4.7521349787712097e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1136 -7.8815799206495285e-03</internalNodes>
+          <leafValues>
+            1.7522190511226654e-01 5.0152552127838135e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1137 -5.7985680177807808e-03</internalNodes>
+          <leafValues>
+            7.2712367773056030e-01 4.8962008953094482e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1138 -3.8922499516047537e-04</internalNodes>
+          <leafValues>
+            4.0039089322090149e-01 5.3449410200119019e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1139 -1.9288610201328993e-03</internalNodes>
+          <leafValues>
+            5.6056129932403564e-01 4.8039558529853821e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1140 8.4214154630899429e-03</internalNodes>
+          <leafValues>
+            4.7532469034194946e-01 7.6236087083816528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1141 8.1655876711010933e-03</internalNodes>
+          <leafValues>
+            5.3932619094848633e-01 4.1916438937187195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1142 4.8280550981871784e-04</internalNodes>
+          <leafValues>
+            4.2408001422882080e-01 5.3998219966888428e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1143 -2.7186630759388208e-03</internalNodes>
+          <leafValues>
+            4.2445999383926392e-01 5.4249238967895508e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1144 -1.2507230043411255e-02</internalNodes>
+          <leafValues>
+            5.8958417177200317e-01 4.5504111051559448e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1145 -2.4286519736051559e-02</internalNodes>
+          <leafValues>
+            2.6471349596977234e-01 5.1891797780990601e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1146 -2.9676330741494894e-03</internalNodes>
+          <leafValues>
+            7.3476827144622803e-01 4.7497498989105225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1147 -1.2528999708592892e-02</internalNodes>
+          <leafValues>
+            2.7560499310493469e-01 5.1775997877120972e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1148 -1.0104000102728605e-03</internalNodes>
+          <leafValues>
+            3.5105609893798828e-01 5.1447242498397827e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1149 -2.1348530426621437e-03</internalNodes>
+          <leafValues>
+            5.6379258632659912e-01 4.6673199534416199e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1150 1.9564259797334671e-02</internalNodes>
+          <leafValues>
+            4.6145731210708618e-01 6.1376398801803589e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1151 -9.7146347165107727e-02</internalNodes>
+          <leafValues>
+            2.9983788728713989e-01 5.1935559511184692e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1152 4.5014568604528904e-03</internalNodes>
+          <leafValues>
+            5.0778847932815552e-01 3.0457559227943420e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1153 6.3706971704959869e-03</internalNodes>
+          <leafValues>
+            4.8610189557075500e-01 6.8875008821487427e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1154 -9.0721528977155685e-03</internalNodes>
+          <leafValues>
+            1.6733959317207336e-01 5.0175631046295166e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1155 -5.3537208586931229e-03</internalNodes>
+          <leafValues>
+            2.6927569508552551e-01 5.2426332235336304e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1156 -1.0932840406894684e-02</internalNodes>
+          <leafValues>
+            7.1838641166687012e-01 4.7360289096832275e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1157 8.2356072962284088e-03</internalNodes>
+          <leafValues>
+            5.2239668369293213e-01 2.3898629844188690e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1158 -1.0038160253316164e-03</internalNodes>
+          <leafValues>
+            5.7193559408187866e-01 4.4339430332183838e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1159 4.0859128348529339e-03</internalNodes>
+          <leafValues>
+            5.4728418588638306e-01 4.1488361358642578e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1160 1.5485419332981110e-01</internalNodes>
+          <leafValues>
+            4.9738121032714844e-01 6.1061598360538483e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1161 2.0897459762636572e-04</internalNodes>
+          <leafValues>
+            4.7091740369796753e-01 5.4238891601562500e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1162 3.3316991175524890e-04</internalNodes>
+          <leafValues>
+            4.0896269679069519e-01 5.3009921312332153e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1163 -1.0813400149345398e-02</internalNodes>
+          <leafValues>
+            6.1043697595596313e-01 4.9573341012001038e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1164 4.5656010508537292e-02</internalNodes>
+          <leafValues>
+            5.0696891546249390e-01 2.8666600584983826e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1165 1.2569549726322293e-03</internalNodes>
+          <leafValues>
+            4.8469170928001404e-01 6.3181710243225098e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1166 -1.2015070021152496e-01</internalNodes>
+          <leafValues>
+            6.0526140034198761e-02 4.9809598922729492e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1167 -1.0533799650147557e-04</internalNodes>
+          <leafValues>
+            5.3631097078323364e-01 4.7080421447753906e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1168 -2.0703190565109253e-01</internalNodes>
+          <leafValues>
+            5.9660330414772034e-02 4.9790981411933899e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1169 1.2909180077258497e-04</internalNodes>
+          <leafValues>
+            4.7129771113395691e-01 5.3779977560043335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1170 3.8818528992123902e-04</internalNodes>
+          <leafValues>
+            4.3635380268096924e-01 5.5341911315917969e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1171 -2.9243610333651304e-03</internalNodes>
+          <leafValues>
+            5.8111858367919922e-01 4.8252159357070923e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1172 8.3882332546636462e-04</internalNodes>
+          <leafValues>
+            5.3117001056671143e-01 4.0381389856338501e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1173 -1.9061550265178084e-03</internalNodes>
+          <leafValues>
+            3.7707018852233887e-01 5.2600151300430298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1174 8.9514348655939102e-03</internalNodes>
+          <leafValues>
+            4.7661679983139038e-01 7.6821839809417725e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1175 1.3083459809422493e-02</internalNodes>
+          <leafValues>
+            5.2644628286361694e-01 3.0622220039367676e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1176 -2.1159330010414124e-01</internalNodes>
+          <leafValues>
+            6.7371982336044312e-01 4.6958100795745850e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1177 3.1493250280618668e-03</internalNodes>
+          <leafValues>
+            5.6448352336883545e-01 4.3869531154632568e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1178 3.9754100725986063e-04</internalNodes>
+          <leafValues>
+            4.5260611176490784e-01 5.8956301212310791e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1179 -1.3814480043947697e-03</internalNodes>
+          <leafValues>
+            6.0705822706222534e-01 4.9424138665199280e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1180 -5.8122188784182072e-04</internalNodes>
+          <leafValues>
+            5.9982132911682129e-01 4.5082521438598633e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1181 -2.3905329871922731e-03</internalNodes>
+          <leafValues>
+            4.2055889964103699e-01 5.2238482236862183e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1182 2.7268929407000542e-02</internalNodes>
+          <leafValues>
+            5.2064472436904907e-01 3.5633018612861633e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1183 -3.7658358924090862e-03</internalNodes>
+          <leafValues>
+            3.1447041034698486e-01 5.2188140153884888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1184 -1.4903489500284195e-03</internalNodes>
+          <leafValues>
+            3.3801960945129395e-01 5.1244372129440308e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1185 -1.7428230494260788e-02</internalNodes>
+          <leafValues>
+            5.8299607038497925e-01 4.9197259545326233e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1186 -1.5278030186891556e-02</internalNodes>
+          <leafValues>
+            6.1631447076797485e-01 4.6178871393203735e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1187 3.1995609402656555e-02</internalNodes>
+          <leafValues>
+            5.1663571596145630e-01 1.7127640545368195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1188 -3.8256710395216942e-03</internalNodes>
+          <leafValues>
+            3.4080120921134949e-01 5.1313877105712891e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1189 -8.5186436772346497e-03</internalNodes>
+          <leafValues>
+            6.1055189371109009e-01 4.9979418516159058e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1190 9.0641621500253677e-04</internalNodes>
+          <leafValues>
+            4.3272709846496582e-01 5.5823111534118652e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1191 1.0344849899411201e-02</internalNodes>
+          <leafValues>
+            4.8556530475616455e-01 5.4524201154708862e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>160</maxWeakCount>
+      <stageThreshold>7.9249076843261719e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1192 7.8981826081871986e-03</internalNodes>
+          <leafValues>
+            3.3325248956680298e-01 5.9464621543884277e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1193 1.6170160379260778e-03</internalNodes>
+          <leafValues>
+            3.4906411170959473e-01 5.5778688192367554e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1194 -5.5449741194024682e-04</internalNodes>
+          <leafValues>
+            5.5425661802291870e-01 3.2915300130844116e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1195 1.5428980113938451e-03</internalNodes>
+          <leafValues>
+            3.6125791072845459e-01 5.5459791421890259e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1196 -1.0329450014978647e-03</internalNodes>
+          <leafValues>
+            3.5301390290260315e-01 5.5761402845382690e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1197 7.7698158565908670e-04</internalNodes>
+          <leafValues>
+            3.9167788624763489e-01 5.6453210115432739e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1198 1.4320300519466400e-01</internalNodes>
+          <leafValues>
+            4.6674820780754089e-01 7.0236331224441528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1199 -7.3866490274667740e-03</internalNodes>
+          <leafValues>
+            3.0736848711967468e-01 5.2892577648162842e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1200 -6.2936742324382067e-04</internalNodes>
+          <leafValues>
+            5.6221181154251099e-01 4.0370491147041321e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1201 7.8893528552725911e-04</internalNodes>
+          <leafValues>
+            5.2676612138748169e-01 3.5578748583793640e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1202 -1.2228050269186497e-02</internalNodes>
+          <leafValues>
+            6.6683208942413330e-01 4.6255499124526978e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1203 3.5420239437371492e-03</internalNodes>
+          <leafValues>
+            5.5214381217956543e-01 3.8696730136871338e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1204 -1.0585320414975286e-03</internalNodes>
+          <leafValues>
+            3.6286780238151550e-01 5.3209269046783447e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1205 1.4935660146875307e-05</internalNodes>
+          <leafValues>
+            4.6324449777603149e-01 5.3633230924606323e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1206 5.2537708543241024e-03</internalNodes>
+          <leafValues>
+            5.1322317123413086e-01 3.2657089829444885e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1207 -8.2338023930788040e-03</internalNodes>
+          <leafValues>
+            6.6936898231506348e-01 4.7741401195526123e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1208 2.1866810129722580e-05</internalNodes>
+          <leafValues>
+            4.0538620948791504e-01 5.4579311609268188e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1209 -3.8150229956954718e-03</internalNodes>
+          <leafValues>
+            6.4549958705902100e-01 4.7931781411170959e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1210 1.1105879675596952e-03</internalNodes>
+          <leafValues>
+            5.2704071998596191e-01 3.5296788811683655e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1211 -5.7707689702510834e-03</internalNodes>
+          <leafValues>
+            3.8035470247268677e-01 5.3529578447341919e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1212 -3.0158339068293571e-03</internalNodes>
+          <leafValues>
+            5.3394031524658203e-01 3.8871330022811890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1213 -8.5453689098358154e-04</internalNodes>
+          <leafValues>
+            3.5646161437034607e-01 5.2736037969589233e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1214 1.1050510220229626e-02</internalNodes>
+          <leafValues>
+            4.6719071269035339e-01 6.8497377634048462e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1215 4.2605839669704437e-02</internalNodes>
+          <leafValues>
+            5.1514732837677002e-01 7.0220090448856354e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1216 -3.0781750101596117e-03</internalNodes>
+          <leafValues>
+            3.0416610836982727e-01 5.1526021957397461e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1217 -5.4815728217363358e-03</internalNodes>
+          <leafValues>
+            6.4302957057952881e-01 4.8972299695014954e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1218 3.1881860923022032e-03</internalNodes>
+          <leafValues>
+            5.3074932098388672e-01 3.8262099027633667e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1219 3.5947180003859103e-04</internalNodes>
+          <leafValues>
+            4.6500471234321594e-01 5.4219049215316772e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1220 -4.0705031715333462e-03</internalNodes>
+          <leafValues>
+            2.8496798872947693e-01 5.0791162252426147e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1221 -1.4594170264899731e-02</internalNodes>
+          <leafValues>
+            2.9716458916664124e-01 5.1284617185592651e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1222 -1.1947689927183092e-04</internalNodes>
+          <leafValues>
+            5.6310981512069702e-01 4.3430820107460022e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1223 -6.9344649091362953e-04</internalNodes>
+          <leafValues>
+            4.4035780429840088e-01 5.3599590063095093e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1224 1.4834799912932795e-05</internalNodes>
+          <leafValues>
+            3.4210088849067688e-01 5.1646977663040161e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1225 9.0296985581517220e-03</internalNodes>
+          <leafValues>
+            4.6393430233001709e-01 6.1140751838684082e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1226 -8.0640818923711777e-03</internalNodes>
+          <leafValues>
+            2.8201588988304138e-01 5.0754940509796143e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1227 2.6062119752168655e-02</internalNodes>
+          <leafValues>
+            5.2089059352874756e-01 2.6887780427932739e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1228 1.7314659431576729e-02</internalNodes>
+          <leafValues>
+            4.6637138724327087e-01 6.7385399341583252e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1229 2.2666640579700470e-02</internalNodes>
+          <leafValues>
+            5.2093499898910522e-01 2.2127239406108856e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1230 -2.1965929772704840e-03</internalNodes>
+          <leafValues>
+            6.0631012916564941e-01 4.5381900668144226e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1231 -9.5282476395368576e-03</internalNodes>
+          <leafValues>
+            4.6352049708366394e-01 5.2474308013916016e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1232 8.0943619832396507e-03</internalNodes>
+          <leafValues>
+            5.2894401550292969e-01 3.9138820767402649e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1233 -7.2877332568168640e-02</internalNodes>
+          <leafValues>
+            7.7520018815994263e-01 4.9902349710464478e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1234 -6.9009521976113319e-03</internalNodes>
+          <leafValues>
+            2.4280390143394470e-01 5.0480902194976807e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1235 -1.1308239772915840e-02</internalNodes>
+          <leafValues>
+            5.7343649864196777e-01 4.8423761129379272e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1236 5.9613201767206192e-02</internalNodes>
+          <leafValues>
+            5.0298362970352173e-01 2.5249770283699036e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1237 -2.8624620754271746e-03</internalNodes>
+          <leafValues>
+            6.0730451345443726e-01 4.8984599113464355e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1238 4.4781449250876904e-03</internalNodes>
+          <leafValues>
+            5.0152891874313354e-01 2.2203169763088226e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1239 -1.7513240454718471e-03</internalNodes>
+          <leafValues>
+            6.6144287586212158e-01 4.9338689446449280e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1240 4.0163420140743256e-02</internalNodes>
+          <leafValues>
+            5.1808780431747437e-01 3.7410449981689453e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1241 3.4768949262797832e-04</internalNodes>
+          <leafValues>
+            4.7204169631004333e-01 5.8180320262908936e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1242 2.6551650371402502e-03</internalNodes>
+          <leafValues>
+            3.8050109148025513e-01 5.2213358879089355e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1243 -8.7706279009580612e-03</internalNodes>
+          <leafValues>
+            2.9441660642623901e-01 5.2312952280044556e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1244 -5.5122091434895992e-03</internalNodes>
+          <leafValues>
+            7.3461771011352539e-01 4.7228169441223145e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1245 6.8672042107209563e-04</internalNodes>
+          <leafValues>
+            5.4528760910034180e-01 4.2424130439758301e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1246 5.6019669864326715e-04</internalNodes>
+          <leafValues>
+            4.3988621234893799e-01 5.6012850999832153e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1247 2.4143769405782223e-03</internalNodes>
+          <leafValues>
+            4.7416868805885315e-01 6.1366218328475952e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1248 -1.5680900542065501e-03</internalNodes>
+          <leafValues>
+            6.0445529222488403e-01 4.5164099335670471e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1249 -3.6827491130679846e-03</internalNodes>
+          <leafValues>
+            2.4524590373039246e-01 5.2949821949005127e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1250 -2.9409190756268799e-04</internalNodes>
+          <leafValues>
+            3.7328380346298218e-01 5.2514511346817017e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1251 4.2847759323194623e-04</internalNodes>
+          <leafValues>
+            5.4988098144531250e-01 4.0655350685119629e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1252 -4.8817070201039314e-03</internalNodes>
+          <leafValues>
+            2.1399089694023132e-01 4.9999570846557617e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1253 2.7272020815871656e-04</internalNodes>
+          <leafValues>
+            4.6502870321273804e-01 5.8134287595748901e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1254 2.0947199664078653e-04</internalNodes>
+          <leafValues>
+            4.3874868750572205e-01 5.5727928876876831e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1255 4.8501189798116684e-02</internalNodes>
+          <leafValues>
+            5.2449727058410645e-01 3.2128891348838806e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1256 -4.5166411437094212e-03</internalNodes>
+          <leafValues>
+            6.0568130016326904e-01 4.5458820462226868e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1257 -1.2291680090129375e-02</internalNodes>
+          <leafValues>
+            2.0409290492534637e-01 5.1522141695022583e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1258 4.8549679922871292e-04</internalNodes>
+          <leafValues>
+            5.2376049757003784e-01 3.7395030260086060e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1259 3.0556049197912216e-02</internalNodes>
+          <leafValues>
+            4.9605339765548706e-01 5.9382462501525879e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1260 -1.5105320198927075e-04</internalNodes>
+          <leafValues>
+            5.3513038158416748e-01 4.1452041268348694e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1261 2.4937440175563097e-03</internalNodes>
+          <leafValues>
+            4.6933668851852417e-01 5.5149412155151367e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1262 -1.2382130138576031e-02</internalNodes>
+          <leafValues>
+            6.7913967370986938e-01 4.6816679835319519e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1263 -5.1333461888134480e-03</internalNodes>
+          <leafValues>
+            3.6087390780448914e-01 5.2291601896286011e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1264 5.1919277757406235e-04</internalNodes>
+          <leafValues>
+            5.3000730276107788e-01 3.6336138844490051e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1265 1.5060420334339142e-01</internalNodes>
+          <leafValues>
+            5.1573169231414795e-01 2.2117820382118225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1266 7.7144149690866470e-03</internalNodes>
+          <leafValues>
+            4.4104969501495361e-01 5.7766091823577881e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1267 9.4443522393703461e-03</internalNodes>
+          <leafValues>
+            5.4018551111221313e-01 3.7566500902175903e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1268 2.5006249779835343e-04</internalNodes>
+          <leafValues>
+            4.3682709336280823e-01 5.6073749065399170e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1269 -3.3077150583267212e-03</internalNodes>
+          <leafValues>
+            4.2447990179061890e-01 5.5182307958602905e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1270 7.4048910755664110e-04</internalNodes>
+          <leafValues>
+            4.4969621300697327e-01 5.9005767107009888e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1271 4.4092051684856415e-02</internalNodes>
+          <leafValues>
+            5.2934932708740234e-01 3.1563550233840942e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1272 3.3639909233897924e-03</internalNodes>
+          <leafValues>
+            4.4832968711853027e-01 5.8486622571945190e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1273 -3.9760079234838486e-03</internalNodes>
+          <leafValues>
+            4.5595070719718933e-01 5.4836392402648926e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1274 2.7716930489987135e-03</internalNodes>
+          <leafValues>
+            5.3417861461639404e-01 3.7924841046333313e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1275 -2.4123019829858094e-04</internalNodes>
+          <leafValues>
+            5.6671887636184692e-01 4.5769730210304260e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1276 4.9425667384639382e-04</internalNodes>
+          <leafValues>
+            4.4212448596954346e-01 5.6287872791290283e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1277 -3.8876468897797167e-04</internalNodes>
+          <leafValues>
+            4.2883709073066711e-01 5.3910630941390991e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1278 -5.0048898905515671e-02</internalNodes>
+          <leafValues>
+            6.8995130062103271e-01 4.7037428617477417e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1279 -3.6635480821132660e-02</internalNodes>
+          <leafValues>
+            2.2177790105342865e-01 5.1918262243270874e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1280 2.4273579474538565e-03</internalNodes>
+          <leafValues>
+            5.1362240314483643e-01 3.4973978996276855e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1281 1.9558030180633068e-03</internalNodes>
+          <leafValues>
+            4.8261928558349609e-01 6.4083808660507202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1282 -1.7494610510766506e-03</internalNodes>
+          <leafValues>
+            3.9228358864784241e-01 5.2726852893829346e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1283 1.3955079950392246e-02</internalNodes>
+          <leafValues>
+            5.0782018899917603e-01 8.4165048599243164e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1284 -2.1896739781368524e-04</internalNodes>
+          <leafValues>
+            5.5204898118972778e-01 4.3142348527908325e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1285 -1.5131309628486633e-03</internalNodes>
+          <leafValues>
+            3.9346051216125488e-01 5.3825712203979492e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1286 -4.3622800149023533e-03</internalNodes>
+          <leafValues>
+            7.3706287145614624e-01 4.7364759445190430e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1287 6.5160587430000305e-02</internalNodes>
+          <leafValues>
+            5.1592797040939331e-01 3.2815951108932495e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1288 -2.3567399475723505e-03</internalNodes>
+          <leafValues>
+            3.6728268861770630e-01 5.1728862524032593e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1289 1.5146659687161446e-02</internalNodes>
+          <leafValues>
+            5.0314939022064209e-01 6.6876041889190674e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1290 -2.2850960493087769e-02</internalNodes>
+          <leafValues>
+            6.7675197124481201e-01 4.7095969319343567e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1291 4.8867650330066681e-03</internalNodes>
+          <leafValues>
+            5.2579981088638306e-01 4.0598788857460022e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1292 1.7619599821045995e-03</internalNodes>
+          <leafValues>
+            4.6962729096412659e-01 6.6882789134979248e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1293 -1.2942519970238209e-03</internalNodes>
+          <leafValues>
+            4.3207129836082458e-01 5.3442817926406860e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1294 1.0929949581623077e-02</internalNodes>
+          <leafValues>
+            4.9977061152458191e-01 1.6374860703945160e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1295 2.9958489903947338e-05</internalNodes>
+          <leafValues>
+            4.2824178934097290e-01 5.6332242488861084e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1296 -6.5884361974895000e-03</internalNodes>
+          <leafValues>
+            6.7721211910247803e-01 4.7005268931388855e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1297 3.2527779694646597e-03</internalNodes>
+          <leafValues>
+            5.3133970499038696e-01 4.5361489057540894e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1298 -4.0435739792883396e-03</internalNodes>
+          <leafValues>
+            5.6600618362426758e-01 4.4133889675140381e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1299 -1.2523540062829852e-03</internalNodes>
+          <leafValues>
+            3.7319138646125793e-01 5.3564518690109253e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1300 1.9246719602961093e-04</internalNodes>
+          <leafValues>
+            5.1899862289428711e-01 3.7388110160827637e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1301 -3.8589671254158020e-02</internalNodes>
+          <leafValues>
+            2.9563739895820618e-01 5.1888108253479004e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1302 1.5489870565943420e-04</internalNodes>
+          <leafValues>
+            4.3471351265907288e-01 5.5095332860946655e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1303 -3.3763848245143890e-02</internalNodes>
+          <leafValues>
+            3.2303300499916077e-01 5.1954758167266846e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1304 -8.2657067105174065e-03</internalNodes>
+          <leafValues>
+            5.9754890203475952e-01 4.5521140098571777e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1305 1.4481440302915871e-05</internalNodes>
+          <leafValues>
+            4.7456780076026917e-01 5.4974269866943359e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1306 1.4951299817766994e-05</internalNodes>
+          <leafValues>
+            4.3244731426239014e-01 5.4806441068649292e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1307 -1.8741799518465996e-02</internalNodes>
+          <leafValues>
+            1.5800529718399048e-01 5.1785331964492798e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1308 1.7572239739820361e-03</internalNodes>
+          <leafValues>
+            4.5176368951797485e-01 5.7737642526626587e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1309 -3.1391119118779898e-03</internalNodes>
+          <leafValues>
+            4.1496479511260986e-01 5.4608422517776489e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1310 6.6656779381446540e-05</internalNodes>
+          <leafValues>
+            4.0390908718109131e-01 5.2930849790573120e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1311 6.7743421532213688e-03</internalNodes>
+          <leafValues>
+            4.7676518559455872e-01 6.1219561100006104e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1312 -7.3868161998689175e-03</internalNodes>
+          <leafValues>
+            3.5862588882446289e-01 5.1872807741165161e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1313 1.4040930196642876e-02</internalNodes>
+          <leafValues>
+            4.7121399641036987e-01 5.5761557817459106e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1314 -5.5258329957723618e-03</internalNodes>
+          <leafValues>
+            2.6610270142555237e-01 5.0392812490463257e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1315 3.8684239983558655e-01</internalNodes>
+          <leafValues>
+            5.1443397998809814e-01 2.5258991122245789e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1316 1.1459240340627730e-04</internalNodes>
+          <leafValues>
+            4.2849949002265930e-01 5.4233711957931519e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1317 -1.8467569723725319e-02</internalNodes>
+          <leafValues>
+            3.8858351111412048e-01 5.2130621671676636e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1318 -4.5907011372037232e-04</internalNodes>
+          <leafValues>
+            5.4125630855560303e-01 4.2359098792076111e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1319 1.2527540093287826e-03</internalNodes>
+          <leafValues>
+            4.8993051052093506e-01 6.6240912675857544e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1320 1.4910609461367130e-03</internalNodes>
+          <leafValues>
+            5.2867782115936279e-01 4.0400519967079163e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1321 -7.5435562757775187e-04</internalNodes>
+          <leafValues>
+            6.0329902172088623e-01 4.7951200604438782e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1322 -6.9478838704526424e-03</internalNodes>
+          <leafValues>
+            4.0844011306762695e-01 5.3735041618347168e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1323 2.8092920547351241e-04</internalNodes>
+          <leafValues>
+            4.8460629582405090e-01 5.7593822479248047e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1324 9.6073717577382922e-04</internalNodes>
+          <leafValues>
+            5.1647412776947021e-01 3.5549798607826233e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1325 -2.6883929967880249e-04</internalNodes>
+          <leafValues>
+            5.6775820255279541e-01 4.7317659854888916e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1326 2.1599370520561934e-03</internalNodes>
+          <leafValues>
+            4.7314870357513428e-01 7.0705670118331909e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1327 5.6235301308333874e-03</internalNodes>
+          <leafValues>
+            5.2402430772781372e-01 2.7817919850349426e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1328 -5.0243991427123547e-03</internalNodes>
+          <leafValues>
+            2.8370139002799988e-01 5.0623041391372681e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1329 -9.7611639648675919e-03</internalNodes>
+          <leafValues>
+            7.4007177352905273e-01 4.9345690011978149e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1330 4.1515100747346878e-03</internalNodes>
+          <leafValues>
+            5.1191312074661255e-01 3.4070080518722534e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1331 6.2465080991387367e-03</internalNodes>
+          <leafValues>
+            4.9237880110740662e-01 6.5790587663650513e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1332 -7.0597478188574314e-03</internalNodes>
+          <leafValues>
+            2.4347110092639923e-01 5.0328421592712402e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1333 -2.0587709732353687e-03</internalNodes>
+          <leafValues>
+            5.9003108739852905e-01 4.6950870752334595e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1334 -2.4146060459315777e-03</internalNodes>
+          <leafValues>
+            3.6473178863525391e-01 5.1892018318176270e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1335 -1.4817609917372465e-03</internalNodes>
+          <leafValues>
+            6.0349482297897339e-01 4.9401280283927917e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1336 -6.3016400672495365e-03</internalNodes>
+          <leafValues>
+            5.8189898729324341e-01 4.5604279637336731e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1337 3.4763428848236799e-03</internalNodes>
+          <leafValues>
+            5.2174758911132812e-01 3.4839931130409241e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1338 -2.2250870242714882e-02</internalNodes>
+          <leafValues>
+            2.3607000708580017e-01 5.0320827960968018e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1339 -3.0612550675868988e-02</internalNodes>
+          <leafValues>
+            6.4991867542266846e-01 4.9149191379547119e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1340 1.3057479634881020e-02</internalNodes>
+          <leafValues>
+            4.4133231043815613e-01 5.6837642192840576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1341 -6.0095742810517550e-04</internalNodes>
+          <leafValues>
+            4.3597310781478882e-01 5.3334832191467285e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1342 -4.1514250915497541e-04</internalNodes>
+          <leafValues>
+            5.5040627717971802e-01 4.3260601162910461e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1343 -1.3776290230453014e-02</internalNodes>
+          <leafValues>
+            4.0641129016876221e-01 5.2015489339828491e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1344 -3.2296508550643921e-02</internalNodes>
+          <leafValues>
+            4.7351971268653870e-02 4.9771949648857117e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1345 5.3556978702545166e-02</internalNodes>
+          <leafValues>
+            4.8817330598831177e-01 6.6669392585754395e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1346 8.1889545544981956e-03</internalNodes>
+          <leafValues>
+            5.4000371694564819e-01 4.2408201098442078e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1347 2.1055320394225419e-04</internalNodes>
+          <leafValues>
+            4.8020479083061218e-01 5.5638527870178223e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1348 -2.4382730480283499e-03</internalNodes>
+          <leafValues>
+            7.3877930641174316e-01 4.7736850380897522e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1349 3.2835570164024830e-03</internalNodes>
+          <leafValues>
+            5.2885460853576660e-01 3.1712919473648071e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1350 2.3729570675641298e-03</internalNodes>
+          <leafValues>
+            4.7508129477500916e-01 7.0601707696914673e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1351 -1.4541699783876538e-03</internalNodes>
+          <leafValues>
+            3.8117301464080811e-01 5.3307390213012695e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>177</maxWeakCount>
+      <stageThreshold>8.7696029663085938e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1352 5.5755238980054855e-02</internalNodes>
+          <leafValues>
+            4.0191569924354553e-01 6.8060368299484253e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1353 2.4730248842388391e-03</internalNodes>
+          <leafValues>
+            3.3511489629745483e-01 5.9657198190689087e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1354 -3.5031698644161224e-04</internalNodes>
+          <leafValues>
+            5.5577081441879272e-01 3.4822869300842285e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1355 5.4167630150914192e-04</internalNodes>
+          <leafValues>
+            4.2608588933944702e-01 5.6933808326721191e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1356 7.7193678589537740e-04</internalNodes>
+          <leafValues>
+            3.4942400455474854e-01 5.4336887598037720e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1357 -1.5999219613149762e-03</internalNodes>
+          <leafValues>
+            4.0284991264343262e-01 5.4843592643737793e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1358 -1.1832080053864047e-04</internalNodes>
+          <leafValues>
+            3.8069018721580505e-01 5.4254651069641113e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1359 3.2909031142480671e-04</internalNodes>
+          <leafValues>
+            2.6201000809669495e-01 5.4295217990875244e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1360 2.9518108931370080e-04</internalNodes>
+          <leafValues>
+            3.7997689843177795e-01 5.3992640972137451e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1361 9.0466710389591753e-05</internalNodes>
+          <leafValues>
+            4.4336450099945068e-01 5.4402261972427368e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1362 1.5007190086180344e-05</internalNodes>
+          <leafValues>
+            3.7196549773216248e-01 5.4091197252273560e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1363 1.3935610651969910e-01</internalNodes>
+          <leafValues>
+            5.5253958702087402e-01 4.4790428876876831e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1364 1.6461990308016539e-03</internalNodes>
+          <leafValues>
+            4.2645010352134705e-01 5.7721698284149170e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1365 4.9984431825578213e-04</internalNodes>
+          <leafValues>
+            4.3595260381698608e-01 5.6858712434768677e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1366 -1.0971280280500650e-03</internalNodes>
+          <leafValues>
+            3.3901369571685791e-01 5.2054089307785034e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1367 6.6919892560690641e-04</internalNodes>
+          <leafValues>
+            4.5574560761451721e-01 5.9806597232818604e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1368 8.6471042595803738e-04</internalNodes>
+          <leafValues>
+            5.1348412036895752e-01 2.9440331459045410e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1369 -2.7182599296793342e-04</internalNodes>
+          <leafValues>
+            3.9065781235694885e-01 5.3771811723709106e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1370 3.0249499104684219e-05</internalNodes>
+          <leafValues>
+            3.6796098947525024e-01 5.2256888151168823e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1371 -8.5225896909832954e-03</internalNodes>
+          <leafValues>
+            7.2931021451950073e-01 4.8923650383949280e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1372 1.6705560265108943e-03</internalNodes>
+          <leafValues>
+            4.3453249335289001e-01 5.6961381435394287e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1373 -7.1433838456869125e-03</internalNodes>
+          <leafValues>
+            2.5912800431251526e-01 5.2256238460540771e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1374 -1.6319369897246361e-02</internalNodes>
+          <leafValues>
+            6.9222790002822876e-01 4.6515759825706482e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1375 4.8034260980784893e-03</internalNodes>
+          <leafValues>
+            5.3522628545761108e-01 3.2863029837608337e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1376 -7.5421929359436035e-03</internalNodes>
+          <leafValues>
+            2.0405440032482147e-01 5.0345462560653687e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1377 -1.4363110065460205e-02</internalNodes>
+          <leafValues>
+            6.8048888444900513e-01 4.8890590667724609e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1378 8.9063588529825211e-04</internalNodes>
+          <leafValues>
+            5.3106957674026489e-01 3.8954809308052063e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1379 -4.4060191139578819e-03</internalNodes>
+          <leafValues>
+            5.7415628433227539e-01 4.3724268674850464e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1380 -1.8862540309783071e-04</internalNodes>
+          <leafValues>
+            2.8317859768867493e-01 5.0982052087783813e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1381 -3.7979281041771173e-03</internalNodes>
+          <leafValues>
+            3.3725079894065857e-01 5.2465802431106567e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1382 1.4627049677073956e-04</internalNodes>
+          <leafValues>
+            5.3066742420196533e-01 3.9117100834846497e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1383 -4.9164638767251745e-05</internalNodes>
+          <leafValues>
+            5.4624962806701660e-01 3.9427208900451660e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1384 -3.3582501113414764e-02</internalNodes>
+          <leafValues>
+            2.1578240394592285e-01 5.0482118129730225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1385 -3.5339309833943844e-03</internalNodes>
+          <leafValues>
+            6.4653122425079346e-01 4.8726969957351685e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1386 5.0144111737608910e-03</internalNodes>
+          <leafValues>
+            4.6176680922508240e-01 6.2480747699737549e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1387 1.8817370757460594e-02</internalNodes>
+          <leafValues>
+            5.2206891775131226e-01 2.0000520348548889e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1388 -1.3434339780360460e-03</internalNodes>
+          <leafValues>
+            4.0145379304885864e-01 5.3016197681427002e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1389 1.7557960236445069e-03</internalNodes>
+          <leafValues>
+            4.7940391302108765e-01 5.6531697511672974e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1390 -9.5637463033199310e-02</internalNodes>
+          <leafValues>
+            2.0341950654983521e-01 5.0067067146301270e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1391 -2.2241229191422462e-02</internalNodes>
+          <leafValues>
+            7.6724731922149658e-01 5.0463402271270752e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1392 -1.5575819648802280e-02</internalNodes>
+          <leafValues>
+            7.4903422594070435e-01 4.7558510303497314e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1393 5.3599118255078793e-03</internalNodes>
+          <leafValues>
+            5.3653037548065186e-01 4.0046709775924683e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1394 -2.1763499826192856e-02</internalNodes>
+          <leafValues>
+            7.4015498161315918e-02 4.9641749262809753e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1395 -1.6561590135097504e-01</internalNodes>
+          <leafValues>
+            2.8591030836105347e-01 5.2180862426757812e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1396 1.6461320046801120e-04</internalNodes>
+          <leafValues>
+            4.1916158795356750e-01 5.3807932138442993e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1397 -8.9077502489089966e-03</internalNodes>
+          <leafValues>
+            6.2731927633285522e-01 4.8774048686027527e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1398 8.6346449097618461e-04</internalNodes>
+          <leafValues>
+            5.1599407196044922e-01 3.6710259318351746e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1399 -1.3751760125160217e-03</internalNodes>
+          <leafValues>
+            5.8843767642974854e-01 4.5790839195251465e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1400 -1.4081239933148026e-03</internalNodes>
+          <leafValues>
+            3.5605099797248840e-01 5.1399451494216919e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1401 -3.9342888630926609e-03</internalNodes>
+          <leafValues>
+            5.9942889213562012e-01 4.6642720699310303e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1402 -3.1966928392648697e-02</internalNodes>
+          <leafValues>
+            3.3454620838165283e-01 5.1441830396652222e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1403 -1.5089280168467667e-05</internalNodes>
+          <leafValues>
+            5.5826562643051147e-01 4.4140571355819702e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1404 5.1994470413774252e-04</internalNodes>
+          <leafValues>
+            4.6236801147460938e-01 6.1689937114715576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1405 -3.4220460802316666e-03</internalNodes>
+          <leafValues>
+            6.5570747852325439e-01 4.9748051166534424e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1406 1.7723299970384687e-04</internalNodes>
+          <leafValues>
+            5.2695018053054810e-01 3.9019080996513367e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1407 1.5716759953647852e-03</internalNodes>
+          <leafValues>
+            4.6333730220794678e-01 5.7904577255249023e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1408 -8.9041329920291901e-03</internalNodes>
+          <leafValues>
+            2.6896080374717712e-01 5.0535911321640015e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1409 4.0677518700249493e-04</internalNodes>
+          <leafValues>
+            5.4566031694412231e-01 4.3298989534378052e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1410 6.7604780197143555e-03</internalNodes>
+          <leafValues>
+            4.6489939093589783e-01 6.6897618770599365e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1411 2.9100088868290186e-03</internalNodes>
+          <leafValues>
+            5.3097039461135864e-01 3.3778399229049683e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1412 1.3885459629818797e-03</internalNodes>
+          <leafValues>
+            4.0747389197349548e-01 5.3491330146789551e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1413 -7.6764263212680817e-02</internalNodes>
+          <leafValues>
+            1.9921760261058807e-01 5.2282422780990601e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1414 -2.2688310127705336e-04</internalNodes>
+          <leafValues>
+            5.4385018348693848e-01 4.2530721426010132e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1415 -6.3094152137637138e-03</internalNodes>
+          <leafValues>
+            4.2591789364814758e-01 5.3789097070693970e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1416 -1.1007279902696609e-01</internalNodes>
+          <leafValues>
+            6.9041568040847778e-01 4.7217491269111633e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1417 2.8619659133255482e-04</internalNodes>
+          <leafValues>
+            4.5249149203300476e-01 5.5483061075210571e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1418 2.9425329557852820e-05</internalNodes>
+          <leafValues>
+            5.3703737258911133e-01 4.2364639043807983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1419 -2.4886570870876312e-02</internalNodes>
+          <leafValues>
+            6.4235579967498779e-01 4.9693039059638977e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1420 3.3148851245641708e-02</internalNodes>
+          <leafValues>
+            4.9884751439094543e-01 1.6138119995594025e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1421 7.8491691965609789e-04</internalNodes>
+          <leafValues>
+            5.4160261154174805e-01 4.2230090498924255e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1422 4.7087189741432667e-03</internalNodes>
+          <leafValues>
+            4.5763289928436279e-01 6.0275578498840332e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1423 2.4144479539245367e-03</internalNodes>
+          <leafValues>
+            5.3089731931686401e-01 4.4224989414215088e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1424 1.9523180089890957e-03</internalNodes>
+          <leafValues>
+            4.7056341171264648e-01 6.6633248329162598e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1425 1.3031980488449335e-03</internalNodes>
+          <leafValues>
+            4.4061261415481567e-01 5.5269622802734375e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1426 4.4735497795045376e-03</internalNodes>
+          <leafValues>
+            5.1290237903594971e-01 3.3014988899230957e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1427 -2.6652868837118149e-03</internalNodes>
+          <leafValues>
+            3.1354710459709167e-01 5.1750361919403076e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1428 1.3666770246345550e-04</internalNodes>
+          <leafValues>
+            4.1193708777427673e-01 5.3068768978118896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1429 -1.7126450315117836e-02</internalNodes>
+          <leafValues>
+            6.1778062582015991e-01 4.8365789651870728e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1430 -2.6601430727168918e-04</internalNodes>
+          <leafValues>
+            3.6543309688568115e-01 5.1697367429733276e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1431 -2.2932380437850952e-02</internalNodes>
+          <leafValues>
+            3.4909150004386902e-01 5.1639920473098755e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1432 2.3316550068557262e-03</internalNodes>
+          <leafValues>
+            5.1662999391555786e-01 3.7093898653984070e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1433 1.6925660893321037e-02</internalNodes>
+          <leafValues>
+            5.0147360563278198e-01 8.0539882183074951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1434 -8.9858826249837875e-03</internalNodes>
+          <leafValues>
+            6.4707887172698975e-01 4.6570208668708801e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1435 -1.1874699965119362e-02</internalNodes>
+          <leafValues>
+            3.2463788986206055e-01 5.2587550878524780e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1436 1.9350569345988333e-04</internalNodes>
+          <leafValues>
+            5.1919418573379517e-01 3.8396438956260681e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1437 5.8713490143418312e-03</internalNodes>
+          <leafValues>
+            4.9181339144706726e-01 6.1870431900024414e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1438 -2.4838790297508240e-01</internalNodes>
+          <leafValues>
+            1.8368029594421387e-01 4.9881500005722046e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1439 1.2256000190973282e-02</internalNodes>
+          <leafValues>
+            5.2270537614822388e-01 3.6320298910140991e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1440 8.3990179700776935e-04</internalNodes>
+          <leafValues>
+            4.4902500510215759e-01 5.7741481065750122e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1441 2.5407369248569012e-03</internalNodes>
+          <leafValues>
+            4.8047870397567749e-01 5.8582991361618042e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1442 -1.4822429977357388e-02</internalNodes>
+          <leafValues>
+            2.5210499763488770e-01 5.0235372781753540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1443 -5.7973959483206272e-03</internalNodes>
+          <leafValues>
+            5.9966957569122314e-01 4.8537150025367737e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1444 7.2662148158997297e-04</internalNodes>
+          <leafValues>
+            5.1537168025970459e-01 3.6717799305915833e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1445 -1.7232580110430717e-02</internalNodes>
+          <leafValues>
+            6.6217190027236938e-01 4.9946561455726624e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1446 7.8624086454510689e-03</internalNodes>
+          <leafValues>
+            4.6333950757980347e-01 6.2561017274856567e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1447 -4.7343620099127293e-03</internalNodes>
+          <leafValues>
+            3.6155730485916138e-01 5.2818852663040161e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1448 8.3048478700220585e-04</internalNodes>
+          <leafValues>
+            4.4428890943527222e-01 5.5509579181671143e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1449 7.6602199114859104e-03</internalNodes>
+          <leafValues>
+            5.1629352569580078e-01 2.6133549213409424e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1450 -4.1048377752304077e-03</internalNodes>
+          <leafValues>
+            2.7896320819854736e-01 5.0190317630767822e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1451 4.8512578941881657e-03</internalNodes>
+          <leafValues>
+            4.9689841270446777e-01 5.6616681814193726e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1452 9.9896453320980072e-04</internalNodes>
+          <leafValues>
+            4.4456079602241516e-01 5.5518132448196411e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1453 -2.7023631334304810e-01</internalNodes>
+          <leafValues>
+            2.9388209804892540e-02 5.1513141393661499e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1454 -1.3090680353343487e-02</internalNodes>
+          <leafValues>
+            5.6993997097015381e-01 4.4474598765373230e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1455 -9.4342790544033051e-03</internalNodes>
+          <leafValues>
+            4.3054661154747009e-01 5.4878950119018555e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1456 -1.5482039889320731e-03</internalNodes>
+          <leafValues>
+            3.6803171038627625e-01 5.1280808448791504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1457 5.3746132180094719e-03</internalNodes>
+          <leafValues>
+            4.8389169573783875e-01 6.1015558242797852e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1458 1.5786769799888134e-03</internalNodes>
+          <leafValues>
+            5.3252232074737549e-01 4.1185480356216431e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1459 3.6856050137430429e-03</internalNodes>
+          <leafValues>
+            4.8109480738639832e-01 6.2523031234741211e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1460 9.3887019902467728e-03</internalNodes>
+          <leafValues>
+            5.2002298831939697e-01 3.6294108629226685e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1461 1.2792630121111870e-02</internalNodes>
+          <leafValues>
+            4.9617099761962891e-01 6.7380160093307495e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1462 -3.3661040943115950e-03</internalNodes>
+          <leafValues>
+            4.0602791309356689e-01 5.2835988998413086e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1463 3.9771420415490866e-04</internalNodes>
+          <leafValues>
+            4.6741139888763428e-01 5.9007751941680908e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1464 1.4868030557408929e-03</internalNodes>
+          <leafValues>
+            4.5191168785095215e-01 6.0820537805557251e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1465 -8.8686749339103699e-02</internalNodes>
+          <leafValues>
+            2.8078991174697876e-01 5.1809918880462646e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1466 -7.4296112870797515e-05</internalNodes>
+          <leafValues>
+            5.2955842018127441e-01 4.0876251459121704e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1467 -1.4932939848222304e-05</internalNodes>
+          <leafValues>
+            5.4614001512527466e-01 4.5385429263114929e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1468 5.9162238612771034e-03</internalNodes>
+          <leafValues>
+            5.3291612863540649e-01 4.1921341419219971e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1469 1.1141640134155750e-03</internalNodes>
+          <leafValues>
+            4.5120179653167725e-01 5.7062172889709473e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1470 8.9249362645205110e-05</internalNodes>
+          <leafValues>
+            4.5778059959411621e-01 5.8976382017135620e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1471 2.5319510605186224e-03</internalNodes>
+          <leafValues>
+            5.2996039390563965e-01 3.3576390147209167e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1472 1.2426200322806835e-02</internalNodes>
+          <leafValues>
+            4.9590590596199036e-01 1.3466019928455353e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1473 2.8335750102996826e-02</internalNodes>
+          <leafValues>
+            5.1170790195465088e-01 6.1043637106195092e-04</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1474 6.6165882162749767e-03</internalNodes>
+          <leafValues>
+            4.7363498806953430e-01 7.0116281509399414e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1475 8.0468766391277313e-03</internalNodes>
+          <leafValues>
+            5.2164179086685181e-01 3.2828199863433838e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1476 -1.1193980462849140e-03</internalNodes>
+          <leafValues>
+            5.8098608255386353e-01 4.5637390017509460e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1477 1.3277590274810791e-02</internalNodes>
+          <leafValues>
+            5.3983622789382935e-01 4.1039010882377625e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1478 4.8794739996083081e-04</internalNodes>
+          <leafValues>
+            4.2492860555648804e-01 5.4105907678604126e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1479 1.1243170127272606e-02</internalNodes>
+          <leafValues>
+            5.2699637413024902e-01 3.4382158517837524e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1480 -8.9896668214350939e-04</internalNodes>
+          <leafValues>
+            5.6330758333206177e-01 4.4566130638122559e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1481 6.6677159629762173e-03</internalNodes>
+          <leafValues>
+            5.3128892183303833e-01 4.3626791238784790e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1482 2.8947299346327782e-02</internalNodes>
+          <leafValues>
+            4.7017949819564819e-01 6.5757977962493896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1483 -2.3400049656629562e-02</internalNodes>
+          <leafValues>
+            0. 5.1373988389968872e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1484 -8.9117050170898438e-02</internalNodes>
+          <leafValues>
+            2.3745279759168625e-02 4.9424308538436890e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1485 -1.4054600149393082e-02</internalNodes>
+          <leafValues>
+            3.1273230910301208e-01 5.1175111532211304e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1486 8.1239398568868637e-03</internalNodes>
+          <leafValues>
+            5.0090491771697998e-01 2.5200259685516357e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1487 -4.9964650534093380e-03</internalNodes>
+          <leafValues>
+            6.3871437311172485e-01 4.9278119206428528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1488 3.1253970228135586e-03</internalNodes>
+          <leafValues>
+            5.1368498802185059e-01 3.6804521083831787e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1489 6.7669642157852650e-03</internalNodes>
+          <leafValues>
+            5.5098438262939453e-01 4.3636319041252136e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1490 -2.3711440153419971e-03</internalNodes>
+          <leafValues>
+            6.1623352766036987e-01 4.5869469642639160e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1491 -5.3522791713476181e-03</internalNodes>
+          <leafValues>
+            6.1854577064514160e-01 4.9204909801483154e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1492 -1.5968859195709229e-02</internalNodes>
+          <leafValues>
+            1.3826179504394531e-01 4.9832528829574585e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1493 4.7676060348749161e-03</internalNodes>
+          <leafValues>
+            4.6880578994750977e-01 5.4900461435317993e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1494 -2.4714691098779440e-03</internalNodes>
+          <leafValues>
+            2.3685149848461151e-01 5.0039529800415039e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1495 -7.1033788844943047e-04</internalNodes>
+          <leafValues>
+            5.8563941717147827e-01 4.7215330600738525e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1496 -1.4117559790611267e-01</internalNodes>
+          <leafValues>
+            8.6900062859058380e-02 4.9615910649299622e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1497 1.0651809722185135e-01</internalNodes>
+          <leafValues>
+            5.1388370990753174e-01 1.7410050332546234e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1498 -5.2744749933481216e-02</internalNodes>
+          <leafValues>
+            7.3536360263824463e-01 4.7728818655014038e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1499 -4.7431760467588902e-03</internalNodes>
+          <leafValues>
+            3.8844060897827148e-01 5.2927017211914062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1500 9.9676765967160463e-04</internalNodes>
+          <leafValues>
+            5.2234929800033569e-01 4.0034240484237671e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1501 8.0284131690859795e-03</internalNodes>
+          <leafValues>
+            4.9591061472892761e-01 7.2129642963409424e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1502 8.6025858763605356e-04</internalNodes>
+          <leafValues>
+            4.4448840618133545e-01 5.5384761095046997e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1503 9.3191501218825579e-04</internalNodes>
+          <leafValues>
+            5.3983712196350098e-01 4.1632440686225891e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1504 -2.5082060601562262e-03</internalNodes>
+          <leafValues>
+            5.8542650938034058e-01 4.5625001192092896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1505 -2.1378761157393456e-03</internalNodes>
+          <leafValues>
+            4.6080690622329712e-01 5.2802592515945435e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1506 -2.1546049974858761e-03</internalNodes>
+          <leafValues>
+            3.7911269068717957e-01 5.2559971809387207e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1507 -7.6214009895920753e-03</internalNodes>
+          <leafValues>
+            5.9986090660095215e-01 4.9520739912986755e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1508 2.2055360022932291e-03</internalNodes>
+          <leafValues>
+            4.4842061400413513e-01 5.5885308980941772e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1509 1.2586950324475765e-03</internalNodes>
+          <leafValues>
+            5.4507470130920410e-01 4.4238409399986267e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1510 -5.0926720723509789e-03</internalNodes>
+          <leafValues>
+            4.1182750463485718e-01 5.2630358934402466e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1511 -2.5095739401876926e-03</internalNodes>
+          <leafValues>
+            5.7879078388214111e-01 4.9984949827194214e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1512 -7.7327556908130646e-02</internalNodes>
+          <leafValues>
+            8.3978658914566040e-01 4.8111200332641602e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1513 -4.1485819965600967e-02</internalNodes>
+          <leafValues>
+            2.4086110293865204e-01 5.1769930124282837e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1514 1.0355669655837119e-04</internalNodes>
+          <leafValues>
+            4.3553608655929565e-01 5.4170542955398560e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1515 1.3255809899419546e-03</internalNodes>
+          <leafValues>
+            5.4539710283279419e-01 4.8940950632095337e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1516 -8.0598732456564903e-03</internalNodes>
+          <leafValues>
+            5.7710242271423340e-01 4.5779189467430115e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1517 1.9058620557188988e-02</internalNodes>
+          <leafValues>
+            5.1698678731918335e-01 3.4004750847816467e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1518 -3.5057891160249710e-02</internalNodes>
+          <leafValues>
+            2.2032439708709717e-01 5.0005030632019043e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1519 5.7296059094369411e-03</internalNodes>
+          <leafValues>
+            5.0434082746505737e-01 6.5975707769393921e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1520 -1.1648329906165600e-02</internalNodes>
+          <leafValues>
+            2.1862849593162537e-01 4.9966529011726379e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1521 1.4544479781761765e-03</internalNodes>
+          <leafValues>
+            5.0076818466186523e-01 5.5037277936935425e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1522 -2.5030909455381334e-04</internalNodes>
+          <leafValues>
+            4.1298410296440125e-01 5.2416700124740601e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1523 -8.2907272735610604e-04</internalNodes>
+          <leafValues>
+            5.4128682613372803e-01 4.9744960665702820e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1524 1.0862209601327777e-03</internalNodes>
+          <leafValues>
+            4.6055299043655396e-01 5.8792287111282349e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1525 2.0000500080641359e-04</internalNodes>
+          <leafValues>
+            5.2788549661636353e-01 4.7052091360092163e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1526 2.9212920926511288e-03</internalNodes>
+          <leafValues>
+            5.1296097040176392e-01 3.7555369734764099e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1527 2.5387400761246681e-02</internalNodes>
+          <leafValues>
+            4.8226919770240784e-01 5.7907682657241821e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1528 -3.1968469265848398e-03</internalNodes>
+          <leafValues>
+            5.2483952045440674e-01 3.9628401398658752e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>182</maxWeakCount>
+      <stageThreshold>9.0253349304199219e+01</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1529 5.8031738735735416e-03</internalNodes>
+          <leafValues>
+            3.4989839792251587e-01 5.9619832038879395e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1530 -9.0003069490194321e-03</internalNodes>
+          <leafValues>
+            6.8166369199752808e-01 4.4785520434379578e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1531 -1.1549659539014101e-03</internalNodes>
+          <leafValues>
+            5.5857062339782715e-01 3.5782510042190552e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1532 -1.1069850297644734e-03</internalNodes>
+          <leafValues>
+            5.3650361299514771e-01 3.0504280328750610e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1533 1.0308309720130637e-04</internalNodes>
+          <leafValues>
+            3.6390951275825500e-01 5.3446358442306519e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1534 -5.0984839908778667e-03</internalNodes>
+          <leafValues>
+            2.8591570258140564e-01 5.5042648315429688e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1535 8.2572200335562229e-04</internalNodes>
+          <leafValues>
+            5.2365237474441528e-01 3.4760418534278870e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1536 9.9783325567841530e-03</internalNodes>
+          <leafValues>
+            4.7503221035003662e-01 6.2196469306945801e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1537 -3.7402529269456863e-02</internalNodes>
+          <leafValues>
+            3.3433759212493896e-01 5.2780628204345703e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1538 4.8548257909715176e-03</internalNodes>
+          <leafValues>
+            5.1921808719635010e-01 3.7004441022872925e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1539 -1.8664470408111811e-03</internalNodes>
+          <leafValues>
+            2.9298439621925354e-01 5.0919449329376221e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1540 1.6888890415430069e-02</internalNodes>
+          <leafValues>
+            3.6868458986282349e-01 5.4312258958816528e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1541 -5.8372621424496174e-03</internalNodes>
+          <leafValues>
+            3.6321839690208435e-01 5.2213358879089355e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1542 -1.4713739510625601e-03</internalNodes>
+          <leafValues>
+            5.8706837892532349e-01 4.7006508708000183e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1543 -1.1522950371727347e-03</internalNodes>
+          <leafValues>
+            3.1958949565887451e-01 5.1409542560577393e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1544 -4.2560300789773464e-03</internalNodes>
+          <leafValues>
+            6.3018590211868286e-01 4.8149210214614868e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1545 -6.7378291860222816e-03</internalNodes>
+          <leafValues>
+            1.9770480692386627e-01 5.0258082151412964e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1546 1.1382670141756535e-02</internalNodes>
+          <leafValues>
+            4.9541321396827698e-01 6.8670457601547241e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1547 5.1794708706438541e-03</internalNodes>
+          <leafValues>
+            5.1644277572631836e-01 3.3506479859352112e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1548 -1.1743789911270142e-01</internalNodes>
+          <leafValues>
+            2.3152460157871246e-01 5.2344137430191040e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1549 2.8703449293971062e-02</internalNodes>
+          <leafValues>
+            4.6642971038818359e-01 6.7225211858749390e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1550 4.8231030814349651e-03</internalNodes>
+          <leafValues>
+            5.2208751440048218e-01 2.7235329151153564e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1551 2.6798530016094446e-03</internalNodes>
+          <leafValues>
+            5.0792771577835083e-01 2.9069489240646362e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1552 8.0504082143306732e-03</internalNodes>
+          <leafValues>
+            4.8859509825706482e-01 6.3950210809707642e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1553 4.8054959625005722e-03</internalNodes>
+          <leafValues>
+            5.1972568035125732e-01 3.6566638946533203e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1554 -2.2420159075409174e-03</internalNodes>
+          <leafValues>
+            6.1534678936004639e-01 4.7637018561363220e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1555 -1.3757710345089436e-02</internalNodes>
+          <leafValues>
+            2.6373448967933655e-01 5.0309032201766968e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1556 -1.0338299721479416e-01</internalNodes>
+          <leafValues>
+            2.2875219583511353e-01 5.1824611425399780e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1557 -9.4432085752487183e-03</internalNodes>
+          <leafValues>
+            6.9533038139343262e-01 4.6949490904808044e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1558 8.0271181650459766e-04</internalNodes>
+          <leafValues>
+            5.4506552219390869e-01 4.2687839269638062e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1559 -4.1945669800043106e-03</internalNodes>
+          <leafValues>
+            6.0913878679275513e-01 4.5716428756713867e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1560 1.0942210443317890e-02</internalNodes>
+          <leafValues>
+            5.2410632371902466e-01 3.2845470309257507e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1561 -5.7841069065034389e-04</internalNodes>
+          <leafValues>
+            5.3879290819168091e-01 4.1793689131736755e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1562 -2.0888620056211948e-03</internalNodes>
+          <leafValues>
+            4.2926910519599915e-01 5.3017157316207886e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1563 3.2383969519287348e-03</internalNodes>
+          <leafValues>
+            3.7923479080200195e-01 5.2207440137863159e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1564 4.9075027927756310e-03</internalNodes>
+          <leafValues>
+            5.2372831106185913e-01 4.1267579793930054e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1565 -3.2277941703796387e-02</internalNodes>
+          <leafValues>
+            1.9476559758186340e-01 4.9945020675659180e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1566 -8.9711230248212814e-03</internalNodes>
+          <leafValues>
+            6.0112851858139038e-01 4.9290320277214050e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1567 1.5321089886128902e-02</internalNodes>
+          <leafValues>
+            5.0097537040710449e-01 2.0398220419883728e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1568 2.0855569746345282e-03</internalNodes>
+          <leafValues>
+            4.8621898889541626e-01 5.7216948270797729e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1569 5.0615021027624607e-03</internalNodes>
+          <leafValues>
+            5.0002187490463257e-01 1.8018059432506561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1570 -3.7174751050770283e-03</internalNodes>
+          <leafValues>
+            5.5301171541213989e-01 4.8975929617881775e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1571 -1.2170500122010708e-02</internalNodes>
+          <leafValues>
+            4.1786059737205505e-01 5.3837239742279053e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1572 4.6248398721218109e-03</internalNodes>
+          <leafValues>
+            4.9971699714660645e-01 5.7613271474838257e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1573 -2.1040429419372231e-04</internalNodes>
+          <leafValues>
+            5.3318071365356445e-01 4.0976810455322266e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1574 -1.4641780406236649e-02</internalNodes>
+          <leafValues>
+            5.7559251785278320e-01 5.0517761707305908e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1575 3.3199489116668701e-03</internalNodes>
+          <leafValues>
+            4.5769768953323364e-01 6.0318058729171753e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1576 3.7236879579722881e-03</internalNodes>
+          <leafValues>
+            4.3803969025611877e-01 5.4158830642700195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1577 8.2951161311939359e-04</internalNodes>
+          <leafValues>
+            5.1630318164825439e-01 3.7022191286087036e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1578 -1.1408490128815174e-02</internalNodes>
+          <leafValues>
+            6.0729467868804932e-01 4.8625651001930237e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1579 -4.5320121571421623e-03</internalNodes>
+          <leafValues>
+            3.2924759387969971e-01 5.0889629125595093e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1580 5.1276017911732197e-03</internalNodes>
+          <leafValues>
+            4.8297679424285889e-01 6.1227089166641235e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1581 9.8583158105611801e-03</internalNodes>
+          <leafValues>
+            4.6606799960136414e-01 6.5561771392822266e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1582 3.6985918879508972e-02</internalNodes>
+          <leafValues>
+            5.2048492431640625e-01 1.6904720664024353e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1583 4.6491161920130253e-03</internalNodes>
+          <leafValues>
+            5.1673221588134766e-01 3.7252250313758850e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1584 -4.2664702050387859e-03</internalNodes>
+          <leafValues>
+            6.4064931869506836e-01 4.9873429536819458e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1585 -4.7956590424291790e-04</internalNodes>
+          <leafValues>
+            5.8972930908203125e-01 4.4648739695549011e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1586 3.6827160511165857e-03</internalNodes>
+          <leafValues>
+            5.4415607452392578e-01 3.4726628661155701e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1587 -1.0059880092740059e-02</internalNodes>
+          <leafValues>
+            2.1431629359722137e-01 5.0048297643661499e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1588 -3.0361840617842972e-04</internalNodes>
+          <leafValues>
+            5.3864240646362305e-01 4.5903238654136658e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1589 -1.4545479789376259e-03</internalNodes>
+          <leafValues>
+            5.7511842250823975e-01 4.4970950484275818e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1590 1.6515209572389722e-03</internalNodes>
+          <leafValues>
+            5.4219377040863037e-01 4.2385208606719971e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1591 -7.8468639403581619e-03</internalNodes>
+          <leafValues>
+            4.0779209136962891e-01 5.2581572532653809e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1592 -5.1259850151836872e-03</internalNodes>
+          <leafValues>
+            4.2292758822441101e-01 5.4794532060623169e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1593 -3.6890961229801178e-02</internalNodes>
+          <leafValues>
+            6.5963757038116455e-01 4.6746781468391418e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1594 2.4035639944486320e-04</internalNodes>
+          <leafValues>
+            4.2511358857154846e-01 5.5732029676437378e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1595 -1.5150169929256663e-05</internalNodes>
+          <leafValues>
+            5.2592468261718750e-01 4.0741148591041565e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1596 2.2108471021056175e-03</internalNodes>
+          <leafValues>
+            4.6717229485511780e-01 5.8863520622253418e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1597 -1.1568620102480054e-03</internalNodes>
+          <leafValues>
+            5.7110661268234253e-01 4.4871619343757629e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1598 4.9996292218565941e-03</internalNodes>
+          <leafValues>
+            5.2641981840133667e-01 2.8983271121978760e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1599 -1.4656189596280456e-03</internalNodes>
+          <leafValues>
+            3.8917380571365356e-01 5.1978719234466553e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1600 -1.1975039960816503e-03</internalNodes>
+          <leafValues>
+            5.7958728075027466e-01 4.9279558658599854e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1601 -4.4954330660402775e-03</internalNodes>
+          <leafValues>
+            2.3776030540466309e-01 5.0125551223754883e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1602 1.4997160178609192e-04</internalNodes>
+          <leafValues>
+            4.8766261339187622e-01 5.6176078319549561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1603 2.6391509454697371e-03</internalNodes>
+          <leafValues>
+            5.1680880784988403e-01 3.7655091285705566e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1604 -2.9368131072260439e-04</internalNodes>
+          <leafValues>
+            5.4466491937637329e-01 4.8746308684349060e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1605 1.4211760135367513e-03</internalNodes>
+          <leafValues>
+            4.6878978610038757e-01 6.6913318634033203e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1606 7.9427637159824371e-02</internalNodes>
+          <leafValues>
+            5.1934438943862915e-01 2.7329459786415100e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1607 7.9937502741813660e-02</internalNodes>
+          <leafValues>
+            4.9717310070991516e-01 1.7820839583873749e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1608 1.1089259758591652e-02</internalNodes>
+          <leafValues>
+            5.1659947633743286e-01 3.2094758749008179e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1609 1.6560709627810866e-04</internalNodes>
+          <leafValues>
+            4.0584719181060791e-01 5.3072762489318848e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1610 -5.3354292176663876e-03</internalNodes>
+          <leafValues>
+            3.4450569748878479e-01 5.1581299304962158e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1611 1.1287260567769408e-03</internalNodes>
+          <leafValues>
+            4.5948630571365356e-01 6.0755330324172974e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1612 -2.1969219669699669e-02</internalNodes>
+          <leafValues>
+            1.6804009675979614e-01 5.2285957336425781e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1613 -2.1775320055894554e-04</internalNodes>
+          <leafValues>
+            3.8615968823432922e-01 5.2156728506088257e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1614 2.0200149447191507e-04</internalNodes>
+          <leafValues>
+            5.5179792642593384e-01 4.3630391359329224e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1615 -2.1733149886131287e-02</internalNodes>
+          <leafValues>
+            7.9994601011276245e-01 4.7898510098457336e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1616 -8.4399932529777288e-04</internalNodes>
+          <leafValues>
+            4.0859758853912354e-01 5.3747731447219849e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1617 -4.3895249837078154e-04</internalNodes>
+          <leafValues>
+            5.4704052209854126e-01 4.3661430478096008e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1618 1.5092400135472417e-03</internalNodes>
+          <leafValues>
+            4.9889969825744629e-01 5.8421492576599121e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1619 -3.5547839943319559e-03</internalNodes>
+          <leafValues>
+            6.7536902427673340e-01 4.7210058569908142e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1620 4.8191400128416717e-04</internalNodes>
+          <leafValues>
+            5.4158538579940796e-01 4.3571090698242188e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1621 -6.0264398343861103e-03</internalNodes>
+          <leafValues>
+            2.2585099935531616e-01 4.9918809533119202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1622 -1.1668140068650246e-02</internalNodes>
+          <leafValues>
+            6.2565547227859497e-01 4.9274989962577820e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1623 -2.8718370012938976e-03</internalNodes>
+          <leafValues>
+            3.9477849006652832e-01 5.2458018064498901e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1624 1.7051169648766518e-02</internalNodes>
+          <leafValues>
+            4.7525110840797424e-01 5.7942241430282593e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1625 -1.3352080248296261e-02</internalNodes>
+          <leafValues>
+            6.0411047935485840e-01 4.5445358753204346e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1626 -3.9301801007241011e-04</internalNodes>
+          <leafValues>
+            4.2582759261131287e-01 5.5449050664901733e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1627 3.0483349692076445e-03</internalNodes>
+          <leafValues>
+            5.2334201335906982e-01 3.7802729010581970e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1628 -4.3579288758337498e-03</internalNodes>
+          <leafValues>
+            6.3718891143798828e-01 4.8386740684509277e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1629 5.6661018170416355e-03</internalNodes>
+          <leafValues>
+            5.3747057914733887e-01 4.1636660695075989e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1630 6.0677339206449687e-05</internalNodes>
+          <leafValues>
+            4.6387958526611328e-01 5.3116250038146973e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1631 3.6738160997629166e-02</internalNodes>
+          <leafValues>
+            4.6886560320854187e-01 6.4665240049362183e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1632 8.6528137326240540e-03</internalNodes>
+          <leafValues>
+            5.2043187618255615e-01 2.1886579692363739e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1633 -1.5371359884738922e-01</internalNodes>
+          <leafValues>
+            1.6303719580173492e-01 4.9588400125503540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1634 -4.1560421232134104e-04</internalNodes>
+          <leafValues>
+            5.7744592428207397e-01 4.6964588761329651e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1635 -1.2640169588848948e-03</internalNodes>
+          <leafValues>
+            3.9771759510040283e-01 5.2171981334686279e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1636 -3.5473341122269630e-03</internalNodes>
+          <leafValues>
+            6.0465282201766968e-01 4.8083150386810303e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1637 3.0019069527043030e-05</internalNodes>
+          <leafValues>
+            3.9967238903045654e-01 5.2282011508941650e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1638 1.3113019522279501e-03</internalNodes>
+          <leafValues>
+            4.7121581435203552e-01 5.7659977674484253e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1639 -1.3374709524214268e-03</internalNodes>
+          <leafValues>
+            4.1095849871635437e-01 5.2531701326370239e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1640 2.0876709371805191e-02</internalNodes>
+          <leafValues>
+            5.2029937505722046e-01 1.7579819262027740e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1641 -7.5497948564589024e-03</internalNodes>
+          <leafValues>
+            6.5666097402572632e-01 4.6949750185012817e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1642 2.4188550189137459e-02</internalNodes>
+          <leafValues>
+            5.1286739110946655e-01 3.3702209591865540e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1643 -2.9358828905969858e-03</internalNodes>
+          <leafValues>
+            6.5807867050170898e-01 4.6945410966873169e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1644 5.7557929307222366e-02</internalNodes>
+          <leafValues>
+            5.1464450359344482e-01 2.7752599120140076e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1645 -1.1343370424583554e-03</internalNodes>
+          <leafValues>
+            3.8366019725799561e-01 5.1926672458648682e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1646 1.6816999763250351e-02</internalNodes>
+          <leafValues>
+            5.0855928659439087e-01 6.1772608757019043e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1647 5.0535178743302822e-03</internalNodes>
+          <leafValues>
+            5.1387631893157959e-01 3.6847919225692749e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1648 -4.5874710194766521e-03</internalNodes>
+          <leafValues>
+            5.9896552562713623e-01 4.8352020978927612e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1649 1.6882460331544280e-03</internalNodes>
+          <leafValues>
+            4.5094868540763855e-01 5.7230567932128906e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1650 -1.6554000321775675e-03</internalNodes>
+          <leafValues>
+            3.4967708587646484e-01 5.2433192729949951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1651 -1.9373800605535507e-02</internalNodes>
+          <leafValues>
+            1.1205369979143143e-01 4.9687129259109497e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1652 1.0374450124800205e-02</internalNodes>
+          <leafValues>
+            5.1481968164443970e-01 4.3952131271362305e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1653 1.4973050565458834e-04</internalNodes>
+          <leafValues>
+            4.0849998593330383e-01 5.2698868513107300e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1654 -4.2981930077075958e-02</internalNodes>
+          <leafValues>
+            6.3941049575805664e-01 5.0185042619705200e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1655 8.3065936341881752e-03</internalNodes>
+          <leafValues>
+            4.7075539827346802e-01 6.6983532905578613e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1656 -4.1285790503025055e-03</internalNodes>
+          <leafValues>
+            4.5413690805435181e-01 5.3236472606658936e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1657 1.7399420030415058e-03</internalNodes>
+          <leafValues>
+            4.3339619040489197e-01 5.4398661851882935e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1658 1.1739750334527344e-04</internalNodes>
+          <leafValues>
+            4.5796871185302734e-01 5.5434262752532959e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1659 1.8585780344437808e-04</internalNodes>
+          <leafValues>
+            4.3246439099311829e-01 5.4267549514770508e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1660 5.5587692186236382e-03</internalNodes>
+          <leafValues>
+            5.2572208642959595e-01 3.5506111383438110e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1661 -7.9851560294628143e-03</internalNodes>
+          <leafValues>
+            6.0430181026458740e-01 4.6306359767913818e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1662 6.0594122624024749e-04</internalNodes>
+          <leafValues>
+            4.5982548594474792e-01 5.5331951379776001e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1663 -2.2983040253166109e-04</internalNodes>
+          <leafValues>
+            4.1307520866394043e-01 5.3224611282348633e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1664 4.3740210821852088e-04</internalNodes>
+          <leafValues>
+            4.0430399775505066e-01 5.4092890024185181e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1665 2.9482020181603730e-04</internalNodes>
+          <leafValues>
+            4.4949638843536377e-01 5.6288522481918335e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1666 1.0312659665942192e-02</internalNodes>
+          <leafValues>
+            5.1775109767913818e-01 2.7043169736862183e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1667 -7.7241109684109688e-03</internalNodes>
+          <leafValues>
+            1.9880190491676331e-01 4.9805539846420288e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1668 -4.6797208487987518e-03</internalNodes>
+          <leafValues>
+            6.6447502374649048e-01 5.0182962417602539e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1669 -5.0755459815263748e-03</internalNodes>
+          <leafValues>
+            3.8983049988746643e-01 5.1852691173553467e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1670 2.2479740437120199e-03</internalNodes>
+          <leafValues>
+            4.8018088936805725e-01 5.6603360176086426e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1671 8.3327008178457618e-04</internalNodes>
+          <leafValues>
+            5.2109199762344360e-01 3.9571881294250488e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1672 -4.1279330849647522e-02</internalNodes>
+          <leafValues>
+            6.1545419692993164e-01 5.0070542097091675e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1673 -5.0930189900100231e-04</internalNodes>
+          <leafValues>
+            3.9759421348571777e-01 5.2284038066864014e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1674 1.2568780221045017e-03</internalNodes>
+          <leafValues>
+            4.9791380763053894e-01 5.9391832351684570e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1675 8.0048497766256332e-03</internalNodes>
+          <leafValues>
+            4.9844971299171448e-01 1.6333660483360291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1676 -1.1879300000146031e-03</internalNodes>
+          <leafValues>
+            5.9049648046493530e-01 4.9426248669624329e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1677 6.1948952497914433e-04</internalNodes>
+          <leafValues>
+            4.1995579004287720e-01 5.3287261724472046e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1678 6.6829859279096127e-03</internalNodes>
+          <leafValues>
+            5.4186028242111206e-01 4.9058890342712402e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1679 -3.7062340416014194e-03</internalNodes>
+          <leafValues>
+            3.7259390950202942e-01 5.1380002498626709e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1680 -3.9739411324262619e-02</internalNodes>
+          <leafValues>
+            6.4789611101150513e-01 5.0503468513488770e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1681 1.4085009461268783e-03</internalNodes>
+          <leafValues>
+            4.6823391318321228e-01 6.3778841495513916e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1682 3.9322688826359808e-04</internalNodes>
+          <leafValues>
+            5.4585301876068115e-01 4.1504821181297302e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1683 -1.8979819724336267e-03</internalNodes>
+          <leafValues>
+            3.6901599168777466e-01 5.1497042179107666e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1684 -1.3970440253615379e-02</internalNodes>
+          <leafValues>
+            6.0505628585815430e-01 4.8113578557968140e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1685 -1.0100819915533066e-01</internalNodes>
+          <leafValues>
+            2.0170800387859344e-01 4.9923619627952576e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1686 -1.7346920445561409e-02</internalNodes>
+          <leafValues>
+            5.7131487131118774e-01 4.8994860053062439e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1687 1.5619759506080300e-04</internalNodes>
+          <leafValues>
+            4.2153888940811157e-01 5.3926420211791992e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1688 1.3438929617404938e-01</internalNodes>
+          <leafValues>
+            5.1361519098281860e-01 3.7676128745079041e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1689 -2.4582240730524063e-02</internalNodes>
+          <leafValues>
+            7.0273578166961670e-01 4.7479069232940674e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1690 -3.8553720805794001e-03</internalNodes>
+          <leafValues>
+            4.3174090981483459e-01 5.4277169704437256e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1691 -2.3165249731391668e-03</internalNodes>
+          <leafValues>
+            5.9426987171173096e-01 4.6186479926109314e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1692 -4.8518120311200619e-03</internalNodes>
+          <leafValues>
+            6.1915689706802368e-01 4.8848950862884521e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1693 2.4699938949197531e-03</internalNodes>
+          <leafValues>
+            5.2566647529602051e-01 4.0171998739242554e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1694 4.5496959239244461e-02</internalNodes>
+          <leafValues>
+            5.2378678321838379e-01 2.6857739686965942e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1695 -2.0319599658250809e-02</internalNodes>
+          <leafValues>
+            2.1304459869861603e-01 4.9797388911247253e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1696 2.6994998916052282e-04</internalNodes>
+          <leafValues>
+            4.8140418529510498e-01 5.5431222915649414e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1697 -1.8232699949294329e-03</internalNodes>
+          <leafValues>
+            6.4825797080993652e-01 4.7099891304969788e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1698 -6.3015790656208992e-03</internalNodes>
+          <leafValues>
+            4.5819279551506042e-01 5.3062361478805542e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1699 -2.4139499873854220e-04</internalNodes>
+          <leafValues>
+            5.2320867776870728e-01 4.0517631173133850e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1700 -1.0330369696021080e-03</internalNodes>
+          <leafValues>
+            5.5562019348144531e-01 4.7891938686370850e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1701 1.8041160365100950e-04</internalNodes>
+          <leafValues>
+            5.2294427156448364e-01 4.0118101239204407e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1702 -6.1407860368490219e-02</internalNodes>
+          <leafValues>
+            6.2986820936203003e-01 5.0107032060623169e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1703 -6.9543913006782532e-02</internalNodes>
+          <leafValues>
+            7.2282809019088745e-01 4.7731840610504150e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1704 -7.0542663335800171e-02</internalNodes>
+          <leafValues>
+            2.2695130109786987e-01 5.1825290918350220e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1705 2.4423799477517605e-03</internalNodes>
+          <leafValues>
+            5.2370971441268921e-01 4.0981510281562805e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1706 1.5494349645450711e-03</internalNodes>
+          <leafValues>
+            4.7737509012222290e-01 5.4680430889129639e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1707 -2.3914219811558723e-02</internalNodes>
+          <leafValues>
+            7.1469759941101074e-01 4.7838249802589417e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1708 -1.2453690171241760e-02</internalNodes>
+          <leafValues>
+            2.6352968811988831e-01 5.2411228418350220e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1709 -2.0760179904755205e-04</internalNodes>
+          <leafValues>
+            3.6237570643424988e-01 5.1136088371276855e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1710 2.9781080229440704e-05</internalNodes>
+          <leafValues>
+            4.7059321403503418e-01 5.4328018426895142e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>211</maxWeakCount>
+      <stageThreshold>1.0474919891357422e+02</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1711 1.1772749945521355e-02</internalNodes>
+          <leafValues>
+            3.8605189323425293e-01 6.4211672544479370e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1712 2.7037570253014565e-02</internalNodes>
+          <leafValues>
+            4.3856549263000488e-01 6.7540389299392700e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1713 -3.6419500247575343e-05</internalNodes>
+          <leafValues>
+            5.4871010780334473e-01 3.4233158826828003e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1714 1.9995409529656172e-03</internalNodes>
+          <leafValues>
+            3.2305321097373962e-01 5.4003179073333740e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1715 4.5278300531208515e-03</internalNodes>
+          <leafValues>
+            5.0916397571563721e-01 2.9350438714027405e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1716 4.7890920541249216e-04</internalNodes>
+          <leafValues>
+            4.1781538724899292e-01 5.3440642356872559e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1717 1.1720920447260141e-03</internalNodes>
+          <leafValues>
+            2.8991821408271790e-01 5.1320707798004150e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1718 9.5305702416226268e-04</internalNodes>
+          <leafValues>
+            4.2801249027252197e-01 5.5608451366424561e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1719 1.5099150004971307e-05</internalNodes>
+          <leafValues>
+            4.0448719263076782e-01 5.4047602415084839e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1720 -6.0817901976406574e-04</internalNodes>
+          <leafValues>
+            4.2717689275741577e-01 5.5034661293029785e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1721 3.3224520739167929e-03</internalNodes>
+          <leafValues>
+            3.9627239108085632e-01 5.3697347640991211e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1722 -1.1037490330636501e-03</internalNodes>
+          <leafValues>
+            4.7271779179573059e-01 5.2377498149871826e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1723 -1.4350269921123981e-03</internalNodes>
+          <leafValues>
+            5.6030082702636719e-01 4.2235091328620911e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1724 2.0767399109899998e-03</internalNodes>
+          <leafValues>
+            5.2259171009063721e-01 4.7327259182929993e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1725 -1.6412809782195836e-04</internalNodes>
+          <leafValues>
+            3.9990758895874023e-01 5.4327398538589478e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1726 8.8302437216043472e-03</internalNodes>
+          <leafValues>
+            4.6783858537673950e-01 6.0273271799087524e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1727 -1.0552070103585720e-02</internalNodes>
+          <leafValues>
+            3.4939670562744141e-01 5.2139747142791748e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1728 -2.2731600329279900e-03</internalNodes>
+          <leafValues>
+            6.1858189105987549e-01 4.7490629553794861e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1729 -8.4786332445219159e-04</internalNodes>
+          <leafValues>
+            5.2853411436080933e-01 3.8434821367263794e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1730 1.2081359745934606e-03</internalNodes>
+          <leafValues>
+            5.3606408834457397e-01 3.4473359584808350e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1731 2.6512730401009321e-03</internalNodes>
+          <leafValues>
+            4.5582920312881470e-01 6.1939620971679688e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1732 -1.1012479662895203e-03</internalNodes>
+          <leafValues>
+            3.6802300810813904e-01 5.3276282548904419e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1733 4.9561518244445324e-04</internalNodes>
+          <leafValues>
+            3.9605951309204102e-01 5.2749407291412354e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1734 -4.3901771306991577e-02</internalNodes>
+          <leafValues>
+            7.0204448699951172e-01 4.9928390979766846e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1735 3.4690350294113159e-02</internalNodes>
+          <leafValues>
+            5.0491642951965332e-01 2.7666029334068298e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1736 -2.7442190330475569e-03</internalNodes>
+          <leafValues>
+            2.6726329326629639e-01 5.2749711275100708e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1737 3.3316588960587978e-03</internalNodes>
+          <leafValues>
+            4.5794829726219177e-01 6.0011017322540283e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1738 -2.0044570788741112e-02</internalNodes>
+          <leafValues>
+            3.1715941429138184e-01 5.2357178926467896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1739 1.3492030557245016e-03</internalNodes>
+          <leafValues>
+            5.2653628587722778e-01 4.0343248844146729e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1740 2.9702018946409225e-03</internalNodes>
+          <leafValues>
+            5.3324568271636963e-01 4.5719841122627258e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1741 6.3039981760084629e-03</internalNodes>
+          <leafValues>
+            4.5933109521865845e-01 6.0346359014511108e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1742 -1.2936590239405632e-02</internalNodes>
+          <leafValues>
+            4.4379639625549316e-01 5.3729712963104248e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1743 4.0148729458451271e-03</internalNodes>
+          <leafValues>
+            4.6803238987922668e-01 6.4378339052200317e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1744 -2.6401679497212172e-03</internalNodes>
+          <leafValues>
+            3.7096318602561951e-01 5.3143328428268433e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1745 1.3918439857661724e-02</internalNodes>
+          <leafValues>
+            4.7235551476478577e-01 7.1308088302612305e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1746 -4.5087869511917233e-04</internalNodes>
+          <leafValues>
+            4.4923940300941467e-01 5.3704041242599487e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1747 2.5384349282830954e-04</internalNodes>
+          <leafValues>
+            4.4068640470504761e-01 5.5144029855728149e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1748 2.2710000630468130e-03</internalNodes>
+          <leafValues>
+            4.6824169158935547e-01 5.9679841995239258e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1749 2.4120779708027840e-03</internalNodes>
+          <leafValues>
+            5.0793921947479248e-01 3.0185988545417786e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1750 -3.6025670851813629e-05</internalNodes>
+          <leafValues>
+            5.6010371446609497e-01 4.4710969924926758e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1751 -7.4905529618263245e-03</internalNodes>
+          <leafValues>
+            2.2075350582599640e-01 4.9899441003799438e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1752 -1.7513120546936989e-02</internalNodes>
+          <leafValues>
+            6.5312159061431885e-01 5.0176489353179932e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1753 1.4281630516052246e-01</internalNodes>
+          <leafValues>
+            4.9679630994796753e-01 1.4820620417594910e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1754 5.5345268920063972e-03</internalNodes>
+          <leafValues>
+            4.8989468812942505e-01 5.9542238712310791e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1755 -9.6323591424152255e-04</internalNodes>
+          <leafValues>
+            3.9271169900894165e-01 5.1960742473602295e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1756 -2.0370010752230883e-03</internalNodes>
+          <leafValues>
+            5.6133252382278442e-01 4.8848581314086914e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1757 1.6614829655736685e-03</internalNodes>
+          <leafValues>
+            4.4728800654411316e-01 5.5788809061050415e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1758 -3.1188090797513723e-03</internalNodes>
+          <leafValues>
+            3.8405328989028931e-01 5.3974777460098267e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1759 -6.4000617712736130e-03</internalNodes>
+          <leafValues>
+            5.8439838886260986e-01 4.5332181453704834e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1760 3.1319601112045348e-04</internalNodes>
+          <leafValues>
+            5.4392218589782715e-01 4.2347279191017151e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1761 -1.8222099170088768e-02</internalNodes>
+          <leafValues>
+            1.2884649634361267e-01 4.9584048986434937e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1762 8.7969247251749039e-03</internalNodes>
+          <leafValues>
+            4.9512979388237000e-01 7.1534800529479980e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1763 -4.2395070195198059e-03</internalNodes>
+          <leafValues>
+            3.9465999603271484e-01 5.1949369907379150e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1764 9.7086271271109581e-03</internalNodes>
+          <leafValues>
+            4.8975038528442383e-01 6.0649001598358154e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1765 -3.9934171363711357e-03</internalNodes>
+          <leafValues>
+            3.2454401254653931e-01 5.0608289241790771e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1766 -1.6785059124231339e-02</internalNodes>
+          <leafValues>
+            1.5819530189037323e-01 5.2037787437438965e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1767 1.8272090703248978e-02</internalNodes>
+          <leafValues>
+            4.6809351444244385e-01 6.6269791126251221e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1768 5.6872838176786900e-03</internalNodes>
+          <leafValues>
+            5.2116978168487549e-01 3.5121849179267883e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1769 -1.0739039862528443e-03</internalNodes>
+          <leafValues>
+            5.7683861255645752e-01 4.5298451185226440e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1770 -3.7093870341777802e-03</internalNodes>
+          <leafValues>
+            4.5077630877494812e-01 5.3135812282562256e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1771 -2.1110709349159151e-04</internalNodes>
+          <leafValues>
+            5.4608201980590820e-01 4.3333768844604492e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1772 1.0670139454305172e-03</internalNodes>
+          <leafValues>
+            5.3718560934066772e-01 4.0783908963203430e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1773 3.5943021066486835e-03</internalNodes>
+          <leafValues>
+            4.4712871313095093e-01 5.6438362598419189e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1774 -5.1776031032204628e-03</internalNodes>
+          <leafValues>
+            4.4993931055068970e-01 5.2803301811218262e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1775 -2.5414369883947074e-04</internalNodes>
+          <leafValues>
+            5.5161732435226440e-01 4.4077080488204956e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1776 6.3522560521960258e-03</internalNodes>
+          <leafValues>
+            5.1941901445388794e-01 2.4652279913425446e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1777 -4.4205080484971404e-04</internalNodes>
+          <leafValues>
+            3.8307058811187744e-01 5.1396822929382324e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1778 7.4488727841526270e-04</internalNodes>
+          <leafValues>
+            4.8910909891128540e-01 5.9747868776321411e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1779 -3.5116379149258137e-03</internalNodes>
+          <leafValues>
+            7.4136817455291748e-01 4.7687649726867676e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1780 -1.2540910392999649e-02</internalNodes>
+          <leafValues>
+            3.6488190293312073e-01 5.2528268098831177e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1781 9.4931852072477341e-03</internalNodes>
+          <leafValues>
+            5.1004928350448608e-01 3.6295869946479797e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1782 1.2961150147020817e-02</internalNodes>
+          <leafValues>
+            5.2324420213699341e-01 4.3335610628128052e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1783 4.7209449112415314e-03</internalNodes>
+          <leafValues>
+            4.6481490135192871e-01 6.3310527801513672e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1784 -2.3119079414755106e-03</internalNodes>
+          <leafValues>
+            5.9303098917007446e-01 4.5310580730438232e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1785 -2.8262299019843340e-03</internalNodes>
+          <leafValues>
+            3.8704779744148254e-01 5.2571010589599609e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1786 -1.4311339473351836e-03</internalNodes>
+          <leafValues>
+            5.5225032567977905e-01 4.5618548989295959e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1787 1.9378310535103083e-03</internalNodes>
+          <leafValues>
+            4.5462208986282349e-01 5.7369667291641235e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1788 2.6343559147790074e-04</internalNodes>
+          <leafValues>
+            5.3457391262054443e-01 4.5718750357627869e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1789 7.8257522545754910e-04</internalNodes>
+          <leafValues>
+            3.9678159356117249e-01 5.2201879024505615e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1790 -1.9550440832972527e-02</internalNodes>
+          <leafValues>
+            2.8296428918838501e-01 5.2435082197189331e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1791 4.3914958951063454e-04</internalNodes>
+          <leafValues>
+            4.5900669693946838e-01 5.8990901708602905e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1792 2.1452000364661217e-02</internalNodes>
+          <leafValues>
+            5.2314108610153198e-01 2.8553789854049683e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1793 5.8973580598831177e-04</internalNodes>
+          <leafValues>
+            4.3972569704055786e-01 5.5064219236373901e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1794 -2.6157610118389130e-02</internalNodes>
+          <leafValues>
+            3.1350791454315186e-01 5.1891750097274780e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1795 -1.3959860429167747e-02</internalNodes>
+          <leafValues>
+            3.2132729887962341e-01 5.0407177209854126e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1796 -6.3699018210172653e-03</internalNodes>
+          <leafValues>
+            6.3875448703765869e-01 4.8495069146156311e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1797 -8.5613820701837540e-03</internalNodes>
+          <leafValues>
+            2.7591320872306824e-01 5.0320190191268921e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1798 9.6622901037335396e-04</internalNodes>
+          <leafValues>
+            4.6856409311294556e-01 5.8348792791366577e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1799 7.6550268568098545e-04</internalNodes>
+          <leafValues>
+            5.1752072572708130e-01 3.8964220881462097e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1800 -8.1833340227603912e-03</internalNodes>
+          <leafValues>
+            2.0691369473934174e-01 5.2081221342086792e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1801 -9.3976939097046852e-03</internalNodes>
+          <leafValues>
+            6.1340910196304321e-01 4.6412229537963867e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1802 4.8028980381786823e-03</internalNodes>
+          <leafValues>
+            5.4541081190109253e-01 4.3952199816703796e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1803 -3.5680569708347321e-03</internalNodes>
+          <leafValues>
+            6.3444852828979492e-01 4.6810939908027649e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1804 4.0733120404183865e-03</internalNodes>
+          <leafValues>
+            5.2926832437515259e-01 4.0156200528144836e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1805 1.2568129459396005e-03</internalNodes>
+          <leafValues>
+            4.3929880857467651e-01 5.4528248310089111e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1806 -2.9065010603517294e-03</internalNodes>
+          <leafValues>
+            5.8988320827484131e-01 4.8633798956871033e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1807 -2.4409340694546700e-03</internalNodes>
+          <leafValues>
+            4.0693649649620056e-01 5.2474218606948853e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1808 2.4830700829625130e-02</internalNodes>
+          <leafValues>
+            5.1827257871627808e-01 3.6825248599052429e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1809 -4.8854008316993713e-02</internalNodes>
+          <leafValues>
+            1.3075779378414154e-01 4.9612811207771301e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1810 -1.6110379947349429e-03</internalNodes>
+          <leafValues>
+            6.4210057258605957e-01 4.8726621270179749e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1811 -9.7009479999542236e-02</internalNodes>
+          <leafValues>
+            4.7769349068403244e-02 4.9509888887405396e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1812 1.1209240183234215e-03</internalNodes>
+          <leafValues>
+            4.6162670850753784e-01 5.3547459840774536e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1813 -1.3064090162515640e-03</internalNodes>
+          <leafValues>
+            6.2618541717529297e-01 4.6388059854507446e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1814 4.5771620352752507e-04</internalNodes>
+          <leafValues>
+            5.3844177722930908e-01 4.6466401219367981e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1815 -6.3149951165542006e-04</internalNodes>
+          <leafValues>
+            3.8040471076965332e-01 5.1302570104598999e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1816 1.4505970466416329e-04</internalNodes>
+          <leafValues>
+            4.5543101429939270e-01 5.6644618511199951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1817 -1.6474550589919090e-02</internalNodes>
+          <leafValues>
+            6.5969580411911011e-01 4.7158598899841309e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1818 1.3369579799473286e-02</internalNodes>
+          <leafValues>
+            5.1954662799835205e-01 3.0359649658203125e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1819 1.0271780047332868e-04</internalNodes>
+          <leafValues>
+            5.2291762828826904e-01 4.1070660948753357e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1820 -5.5311559699475765e-03</internalNodes>
+          <leafValues>
+            6.3528877496719360e-01 4.9609071016311646e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1821 -2.6187049224972725e-03</internalNodes>
+          <leafValues>
+            3.8245460391044617e-01 5.1409840583801270e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1822 5.0834268331527710e-03</internalNodes>
+          <leafValues>
+            4.9504399299621582e-01 6.2208187580108643e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1823 7.9818159341812134e-02</internalNodes>
+          <leafValues>
+            4.9523359537124634e-01 1.3224759697914124e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1824 -9.9226586520671844e-02</internalNodes>
+          <leafValues>
+            7.5427287817001343e-01 5.0084167718887329e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1825 -6.5174017800018191e-04</internalNodes>
+          <leafValues>
+            3.6993029713630676e-01 5.1301211118698120e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1826 -1.8996849656105042e-02</internalNodes>
+          <leafValues>
+            6.6891789436340332e-01 4.9212029576301575e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1827 1.7346899956464767e-02</internalNodes>
+          <leafValues>
+            4.9833008646965027e-01 1.8591980636119843e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1828 5.5082101607695222e-04</internalNodes>
+          <leafValues>
+            4.5744240283966064e-01 5.5221217870712280e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1829 2.0056050270795822e-03</internalNodes>
+          <leafValues>
+            5.1317447423934937e-01 3.8564699888229370e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1830 -7.7688191086053848e-03</internalNodes>
+          <leafValues>
+            4.3617001175880432e-01 5.4343092441558838e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1831 5.0878278911113739e-02</internalNodes>
+          <leafValues>
+            4.6827208995819092e-01 6.8406397104263306e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1832 -2.2901780903339386e-03</internalNodes>
+          <leafValues>
+            4.3292450904846191e-01 5.3060990571975708e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1833 -1.5715380141045898e-04</internalNodes>
+          <leafValues>
+            5.3700572252273560e-01 4.3781641125679016e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1834 1.0519240051507950e-01</internalNodes>
+          <leafValues>
+            5.1372742652893066e-01 6.7361466586589813e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1835 2.7198919560760260e-03</internalNodes>
+          <leafValues>
+            4.1120609641075134e-01 5.2556651830673218e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1836 4.8337779939174652e-02</internalNodes>
+          <leafValues>
+            5.4046237468719482e-01 4.4389671087265015e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1837 9.5703761326149106e-04</internalNodes>
+          <leafValues>
+            4.3559691309928894e-01 5.3995108604431152e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1838 -2.5371259078383446e-02</internalNodes>
+          <leafValues>
+            5.9951752424240112e-01 5.0310248136520386e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1839 5.2457951009273529e-02</internalNodes>
+          <leafValues>
+            4.9502879381179810e-01 1.3983510434627533e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1840 -1.2365629896521568e-02</internalNodes>
+          <leafValues>
+            6.3972991704940796e-01 4.9641060829162598e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1841 -1.4589719474315643e-01</internalNodes>
+          <leafValues>
+            1.0016699880361557e-01 4.9463221430778503e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1842 -1.5908600762486458e-02</internalNodes>
+          <leafValues>
+            3.3123299479484558e-01 5.2083408832550049e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1843 3.9486068999394774e-04</internalNodes>
+          <leafValues>
+            4.4063639640808105e-01 5.4261028766632080e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1844 -5.2454001270234585e-03</internalNodes>
+          <leafValues>
+            2.7995899319648743e-01 5.1899671554565430e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1845 -5.0421799533069134e-03</internalNodes>
+          <leafValues>
+            6.9875800609588623e-01 4.7521421313285828e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1846 2.9812189750373363e-03</internalNodes>
+          <leafValues>
+            4.9832889437675476e-01 6.3074797391891479e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1847 -7.2884308174252510e-03</internalNodes>
+          <leafValues>
+            2.9823330044746399e-01 5.0268697738647461e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1848 1.5094350092113018e-03</internalNodes>
+          <leafValues>
+            5.3084421157836914e-01 3.8329708576202393e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1849 -9.3340799212455750e-03</internalNodes>
+          <leafValues>
+            2.0379640161991119e-01 4.9698171019554138e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1850 2.8667140752077103e-02</internalNodes>
+          <leafValues>
+            5.0256967544555664e-01 6.9280272722244263e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1851 1.7019680142402649e-01</internalNodes>
+          <leafValues>
+            4.9600529670715332e-01 1.4764429628849030e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1852 -3.2614478841423988e-03</internalNodes>
+          <leafValues>
+            5.6030637025833130e-01 4.8260560631752014e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1853 5.5769277969375253e-04</internalNodes>
+          <leafValues>
+            5.2055621147155762e-01 4.1296330094337463e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1854 3.6258339881896973e-01</internalNodes>
+          <leafValues>
+            5.2216529846191406e-01 3.7686121463775635e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1855 -1.1615130119025707e-02</internalNodes>
+          <leafValues>
+            6.0226827859878540e-01 4.6374899148941040e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1856 -4.0795197710394859e-03</internalNodes>
+          <leafValues>
+            4.0704470872879028e-01 5.3374791145324707e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1857 5.7204300537705421e-04</internalNodes>
+          <leafValues>
+            4.6018350124359131e-01 5.9003931283950806e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1858 6.7543348995968699e-04</internalNodes>
+          <leafValues>
+            5.3982520103454590e-01 4.3454289436340332e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1859 6.3295697327703238e-04</internalNodes>
+          <leafValues>
+            5.2015632390975952e-01 4.0513589978218079e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1860 1.2435320531949401e-03</internalNodes>
+          <leafValues>
+            4.6423879265785217e-01 5.5474412441253662e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1861 -4.7363857738673687e-03</internalNodes>
+          <leafValues>
+            6.1985671520233154e-01 4.6725520491600037e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1862 -6.4658462069928646e-03</internalNodes>
+          <leafValues>
+            6.8373328447341919e-01 5.0190007686614990e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1863 3.5017321351915598e-04</internalNodes>
+          <leafValues>
+            4.3448030948638916e-01 5.3636229038238525e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1864 1.5754920605104417e-04</internalNodes>
+          <leafValues>
+            4.7600790858268738e-01 5.7320207357406616e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1865 9.9774366244673729e-03</internalNodes>
+          <leafValues>
+            5.0909858942031860e-01 3.6350399255752563e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1866 -4.1464529931545258e-04</internalNodes>
+          <leafValues>
+            5.5700647830963135e-01 4.5938020944595337e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1867 -3.5888899583369493e-04</internalNodes>
+          <leafValues>
+            5.3568458557128906e-01 4.3391349911689758e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1868 4.0463250479660928e-04</internalNodes>
+          <leafValues>
+            4.4398030638694763e-01 5.4367768764495850e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1869 -8.2184787606820464e-04</internalNodes>
+          <leafValues>
+            4.0422949194908142e-01 5.1762992143630981e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1870 5.9467419050633907e-03</internalNodes>
+          <leafValues>
+            4.9276518821716309e-01 5.6337797641754150e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1871 -2.1753389388322830e-02</internalNodes>
+          <leafValues>
+            8.0062937736511230e-01 4.8008409142494202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1872 -1.4540379866957664e-02</internalNodes>
+          <leafValues>
+            3.9460548758506775e-01 5.1822227239608765e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1873 -4.0510769933462143e-02</internalNodes>
+          <leafValues>
+            2.1324990317225456e-02 4.9357929825782776e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1874 -5.8458268176764250e-04</internalNodes>
+          <leafValues>
+            4.0127959847450256e-01 5.3140252828598022e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1875 5.5151800625026226e-03</internalNodes>
+          <leafValues>
+            4.6424189209938049e-01 5.8962607383728027e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1876 -6.0626221820712090e-03</internalNodes>
+          <leafValues>
+            6.5021592378616333e-01 5.0164777040481567e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1877 9.4535842537879944e-02</internalNodes>
+          <leafValues>
+            5.2647089958190918e-01 4.1268271207809448e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1878 4.7315051779150963e-03</internalNodes>
+          <leafValues>
+            4.8791998624801636e-01 5.8924478292465210e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1879 -5.2571471314877272e-04</internalNodes>
+          <leafValues>
+            3.9172801375389099e-01 5.1894128322601318e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1880 -2.5464049540460110e-03</internalNodes>
+          <leafValues>
+            5.8375990390777588e-01 4.9857059121131897e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1881 -2.6075689122080803e-02</internalNodes>
+          <leafValues>
+            1.2619839608669281e-01 4.9558219313621521e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1882 -5.4779709316790104e-03</internalNodes>
+          <leafValues>
+            5.7225137948989868e-01 5.0102657079696655e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1883 5.1337741315364838e-03</internalNodes>
+          <leafValues>
+            5.2732622623443604e-01 4.2263761162757874e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1884 4.7944980906322598e-04</internalNodes>
+          <leafValues>
+            4.4500669836997986e-01 5.8195871114730835e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1885 -2.1114079281687737e-03</internalNodes>
+          <leafValues>
+            5.7576531171798706e-01 4.5117148756980896e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1886 -1.3179990462958813e-02</internalNodes>
+          <leafValues>
+            1.8843810260295868e-01 5.1607340574264526e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1887 -4.7968099825084209e-03</internalNodes>
+          <leafValues>
+            6.5897899866104126e-01 4.7361189126968384e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1888 6.7483168095350266e-03</internalNodes>
+          <leafValues>
+            5.2594298124313354e-01 3.3563950657844543e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1889 1.4623369788751006e-03</internalNodes>
+          <leafValues>
+            5.3552711009979248e-01 4.2640921473503113e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1890 4.7645159065723419e-03</internalNodes>
+          <leafValues>
+            5.0344067811965942e-01 5.7868278026580811e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1891 6.8066660314798355e-03</internalNodes>
+          <leafValues>
+            4.7566050291061401e-01 6.6778290271759033e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1892 3.6608621012419462e-03</internalNodes>
+          <leafValues>
+            5.3696119785308838e-01 4.3115469813346863e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1893 2.1449640393257141e-02</internalNodes>
+          <leafValues>
+            4.9686419963836670e-01 1.8888160586357117e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1894 4.1678901761770248e-03</internalNodes>
+          <leafValues>
+            4.9307331442832947e-01 5.8153688907623291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1895 8.6467564105987549e-03</internalNodes>
+          <leafValues>
+            5.2052050828933716e-01 4.1325950622558594e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1896 -3.6114078829996288e-04</internalNodes>
+          <leafValues>
+            5.4835551977157593e-01 4.8009279370307922e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1897 1.0808729566633701e-03</internalNodes>
+          <leafValues>
+            4.6899020671844482e-01 6.0414212942123413e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1898 5.7719959877431393e-03</internalNodes>
+          <leafValues>
+            5.1711422204971313e-01 3.0532771348953247e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1899 1.5720770461484790e-03</internalNodes>
+          <leafValues>
+            5.2199780941009521e-01 4.1788038611412048e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1900 -1.9307859474793077e-03</internalNodes>
+          <leafValues>
+            5.8603698015213013e-01 4.8129200935363770e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1901 -7.8926272690296173e-03</internalNodes>
+          <leafValues>
+            1.7492769658565521e-01 4.9717339873313904e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1902 -2.2224679123610258e-03</internalNodes>
+          <leafValues>
+            4.3425890803337097e-01 5.2128481864929199e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1903 1.9011989934369922e-03</internalNodes>
+          <leafValues>
+            4.7651869058609009e-01 6.8920552730560303e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1904 2.7576119173318148e-03</internalNodes>
+          <leafValues>
+            5.2621912956237793e-01 4.3374860286712646e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1905 5.1787449046969414e-03</internalNodes>
+          <leafValues>
+            4.8040691018104553e-01 7.8437292575836182e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1906 -9.0273341629654169e-04</internalNodes>
+          <leafValues>
+            4.1208469867706299e-01 5.3534239530563354e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1907 5.1797959022223949e-03</internalNodes>
+          <leafValues>
+            4.7403728961944580e-01 6.4259600639343262e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1908 -1.0114000178873539e-02</internalNodes>
+          <leafValues>
+            2.4687920510768890e-01 5.1750177145004272e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1909 -1.8617060035467148e-02</internalNodes>
+          <leafValues>
+            5.7562941312789917e-01 4.6289789676666260e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1910 5.9225959703326225e-03</internalNodes>
+          <leafValues>
+            5.1696258783340454e-01 3.2142710685729980e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1911 -6.2945079989731312e-03</internalNodes>
+          <leafValues>
+            3.8720148801803589e-01 5.1416367292404175e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1912 6.5353019163012505e-03</internalNodes>
+          <leafValues>
+            4.8530489206314087e-01 6.3104897737503052e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1913 1.0878399480134249e-03</internalNodes>
+          <leafValues>
+            5.1173150539398193e-01 3.7232589721679688e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1914 -2.2542240098118782e-02</internalNodes>
+          <leafValues>
+            5.6927400827407837e-01 4.8871129751205444e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1915 -3.0065660830587149e-03</internalNodes>
+          <leafValues>
+            2.5560128688812256e-01 5.0039929151535034e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1916 7.4741272255778313e-03</internalNodes>
+          <leafValues>
+            4.8108729720115662e-01 5.6759268045425415e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1917 2.6162320747971535e-02</internalNodes>
+          <leafValues>
+            4.9711948633193970e-01 1.7772370576858521e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1918 9.4352738233283162e-04</internalNodes>
+          <leafValues>
+            4.9400109052658081e-01 5.4912507534027100e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1919 3.3363241702318192e-02</internalNodes>
+          <leafValues>
+            5.0076121091842651e-01 2.7907240390777588e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1920 -1.5118650160729885e-02</internalNodes>
+          <leafValues>
+            7.0595788955688477e-01 4.9730318784713745e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1921 9.8648946732282639e-04</internalNodes>
+          <leafValues>
+            5.1286202669143677e-01 3.7767618894577026e-01</leafValues></_></weakClassifiers></_>
+    <_>
+      <maxWeakCount>213</maxWeakCount>
+      <stageThreshold>1.0576110076904297e+02</stageThreshold>
+      <weakClassifiers>
+        <_>
+          <internalNodes>
+            0 -1 1922 -9.5150798559188843e-02</internalNodes>
+          <leafValues>
+            6.4707571268081665e-01 4.0172868967056274e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1923 6.2702340073883533e-03</internalNodes>
+          <leafValues>
+            3.9998221397399902e-01 5.7464492321014404e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1924 3.0018089455552399e-04</internalNodes>
+          <leafValues>
+            3.5587701201438904e-01 5.5388098955154419e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1925 1.1757409665733576e-03</internalNodes>
+          <leafValues>
+            4.2565348744392395e-01 5.3826177120208740e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1926 4.4235268433112651e-05</internalNodes>
+          <leafValues>
+            3.6829081177711487e-01 5.5899268388748169e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1927 -2.9936920327600092e-05</internalNodes>
+          <leafValues>
+            5.4524701833724976e-01 4.0203678607940674e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1928 3.0073199886828661e-03</internalNodes>
+          <leafValues>
+            5.2390581369400024e-01 3.3178439736366272e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1929 -1.0513889603316784e-02</internalNodes>
+          <leafValues>
+            4.3206891417503357e-01 5.3079837560653687e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1930 8.3476826548576355e-03</internalNodes>
+          <leafValues>
+            4.5046371221542358e-01 6.4532989263534546e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1931 -3.1492270063608885e-03</internalNodes>
+          <leafValues>
+            4.3134251236915588e-01 5.3705251216888428e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1932 -1.4435649973165710e-05</internalNodes>
+          <leafValues>
+            5.3266030550003052e-01 3.8179719448089600e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1933 -4.2855090578086674e-04</internalNodes>
+          <leafValues>
+            4.3051639199256897e-01 5.3820097446441650e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1934 1.5062429883982986e-04</internalNodes>
+          <leafValues>
+            4.2359709739685059e-01 5.5449652671813965e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1935 7.1559831500053406e-02</internalNodes>
+          <leafValues>
+            5.3030598163604736e-01 2.6788029074668884e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1936 8.4095180500298738e-04</internalNodes>
+          <leafValues>
+            3.5571089386940002e-01 5.2054339647293091e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1937 6.2986500561237335e-02</internalNodes>
+          <leafValues>
+            5.2253627777099609e-01 2.8613761067390442e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1938 -3.3798629883676767e-03</internalNodes>
+          <leafValues>
+            3.6241859197616577e-01 5.2016979455947876e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1939 -1.1810739670181647e-04</internalNodes>
+          <leafValues>
+            5.4744768142700195e-01 3.9598938822746277e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1940 -5.4505601292476058e-04</internalNodes>
+          <leafValues>
+            3.7404221296310425e-01 5.2157157659530640e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1941 -1.8454910023137927e-03</internalNodes>
+          <leafValues>
+            5.8930522203445435e-01 4.5844489336013794e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1942 -4.3832371011376381e-04</internalNodes>
+          <leafValues>
+            4.0845820307731628e-01 5.3853511810302734e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1943 -2.4000830017030239e-03</internalNodes>
+          <leafValues>
+            3.7774550914764404e-01 5.2935802936553955e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1944 -9.8795741796493530e-02</internalNodes>
+          <leafValues>
+            2.9636120796203613e-01 5.0700891017913818e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1945 3.1798239797353745e-03</internalNodes>
+          <leafValues>
+            4.8776328563690186e-01 6.7264437675476074e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1946 3.2406419632025063e-04</internalNodes>
+          <leafValues>
+            4.3669110536575317e-01 5.5611097812652588e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1947 -3.2547250390052795e-02</internalNodes>
+          <leafValues>
+            3.1281578540802002e-01 5.3086161613464355e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1948 -7.7561130747199059e-03</internalNodes>
+          <leafValues>
+            6.5602248907089233e-01 4.6398720145225525e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1949 1.6027249395847321e-02</internalNodes>
+          <leafValues>
+            5.1726800203323364e-01 3.1418979167938232e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1950 7.1002350523485802e-06</internalNodes>
+          <leafValues>
+            4.0844461321830750e-01 5.3362947702407837e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1951 7.3422808200120926e-03</internalNodes>
+          <leafValues>
+            4.9669221043586731e-01 6.6034650802612305e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1952 -1.6970280557870865e-03</internalNodes>
+          <leafValues>
+            5.9082370996475220e-01 4.5001828670501709e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1953 2.4118260480463505e-03</internalNodes>
+          <leafValues>
+            5.3151607513427734e-01 3.5997208952903748e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1954 -5.5300937965512276e-03</internalNodes>
+          <leafValues>
+            2.3340409994125366e-01 4.9968141317367554e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1955 -2.6478730142116547e-03</internalNodes>
+          <leafValues>
+            5.8809357881546021e-01 4.6847340464591980e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1956 1.1295629665255547e-02</internalNodes>
+          <leafValues>
+            4.9837771058082581e-01 1.8845909833908081e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1957 -6.6952878842130303e-04</internalNodes>
+          <leafValues>
+            5.8721381425857544e-01 4.7990199923515320e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1958 1.4410680159926414e-03</internalNodes>
+          <leafValues>
+            5.1311892271041870e-01 3.5010111331939697e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1959 2.4637870956212282e-03</internalNodes>
+          <leafValues>
+            5.3393721580505371e-01 4.1176390647888184e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1960 3.3114518737420440e-04</internalNodes>
+          <leafValues>
+            4.3133831024169922e-01 5.3982460498809814e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1961 -3.3557269722223282e-02</internalNodes>
+          <leafValues>
+            2.6753368973731995e-01 5.1791548728942871e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1962 1.8539419397711754e-02</internalNodes>
+          <leafValues>
+            4.9738699197769165e-01 2.3171770572662354e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1963 -2.9698139405809343e-04</internalNodes>
+          <leafValues>
+            5.5297082662582397e-01 4.6436640620231628e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1964 -4.5577259152196348e-04</internalNodes>
+          <leafValues>
+            5.6295841932296753e-01 4.4691911339759827e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1965 -1.0158980265259743e-02</internalNodes>
+          <leafValues>
+            6.7062127590179443e-01 4.9259188771247864e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1966 -2.2413829356082715e-05</internalNodes>
+          <leafValues>
+            5.2394217252731323e-01 3.9129018783569336e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1967 7.2034963523037732e-05</internalNodes>
+          <leafValues>
+            4.7994381189346313e-01 5.5017888545989990e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1968 -6.9267209619283676e-03</internalNodes>
+          <leafValues>
+            6.9300097227096558e-01 4.6980848908424377e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1969 -7.6997838914394379e-03</internalNodes>
+          <leafValues>
+            4.0996238589286804e-01 5.4808831214904785e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1970 -7.3130549862980843e-03</internalNodes>
+          <leafValues>
+            3.2834759354591370e-01 5.0578862428665161e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1971 1.9650589674711227e-03</internalNodes>
+          <leafValues>
+            4.9780470132827759e-01 6.3982498645782471e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1972 7.1647600270807743e-03</internalNodes>
+          <leafValues>
+            4.6611601114273071e-01 6.2221372127532959e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1973 -2.4078639224171638e-02</internalNodes>
+          <leafValues>
+            2.3346449434757233e-01 5.2221620082855225e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1974 -2.1027969196438789e-02</internalNodes>
+          <leafValues>
+            1.1836539953947067e-01 4.9382260441780090e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1975 3.6017020465806127e-04</internalNodes>
+          <leafValues>
+            5.3250199556350708e-01 4.1167110204696655e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1976 -1.7219729721546173e-02</internalNodes>
+          <leafValues>
+            6.2787622213363647e-01 4.6642690896987915e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1977 -7.8672142699360847e-03</internalNodes>
+          <leafValues>
+            3.4034150838851929e-01 5.2497369050979614e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1978 -4.4777389848604798e-04</internalNodes>
+          <leafValues>
+            3.6104118824005127e-01 5.0862592458724976e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1979 5.5486010387539864e-03</internalNodes>
+          <leafValues>
+            4.8842659592628479e-01 6.2034982442855835e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1980 -6.9461148232221603e-03</internalNodes>
+          <leafValues>
+            2.6259300112724304e-01 5.0110971927642822e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1981 1.3569870498031378e-04</internalNodes>
+          <leafValues>
+            4.3407949805259705e-01 5.6283122301101685e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1982 -4.5880250632762909e-02</internalNodes>
+          <leafValues>
+            6.5079987049102783e-01 4.6962749958038330e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1983 -2.1582560613751411e-02</internalNodes>
+          <leafValues>
+            3.8265028595924377e-01 5.2876168489456177e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1984 -2.0209539681673050e-02</internalNodes>
+          <leafValues>
+            3.2333680987358093e-01 5.0744771957397461e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1985 5.8496710844337940e-03</internalNodes>
+          <leafValues>
+            5.1776039600372314e-01 4.4896709918975830e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1986 -5.7476379879517481e-05</internalNodes>
+          <leafValues>
+            4.0208509564399719e-01 5.2463638782501221e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1987 -1.1513100471347570e-03</internalNodes>
+          <leafValues>
+            6.3150721788406372e-01 4.9051541090011597e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1988 1.9862831104546785e-03</internalNodes>
+          <leafValues>
+            4.7024598717689514e-01 6.4971512556076050e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1989 -5.2719512023031712e-03</internalNodes>
+          <leafValues>
+            3.6503839492797852e-01 5.2276527881622314e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1990 1.2662699446082115e-03</internalNodes>
+          <leafValues>
+            5.1661008596420288e-01 3.8776180148124695e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1991 -6.2919440679252148e-03</internalNodes>
+          <leafValues>
+            7.3758941888809204e-01 5.0238478183746338e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1992 6.7360111279413104e-04</internalNodes>
+          <leafValues>
+            4.4232261180877686e-01 5.4955857992172241e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1993 -1.0523450328037143e-03</internalNodes>
+          <leafValues>
+            5.9763962030410767e-01 4.8595830798149109e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1994 -4.4216238893568516e-04</internalNodes>
+          <leafValues>
+            5.9559392929077148e-01 4.3989309668540955e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1995 1.1747940443456173e-03</internalNodes>
+          <leafValues>
+            5.3498882055282593e-01 4.6050581336021423e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1996 5.2457437850534916e-03</internalNodes>
+          <leafValues>
+            5.0491911172866821e-01 2.9415771365165710e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1997 -2.4539720267057419e-02</internalNodes>
+          <leafValues>
+            2.5501778721809387e-01 5.2185869216918945e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1998 7.3793041519820690e-04</internalNodes>
+          <leafValues>
+            4.4248610734939575e-01 5.4908162355422974e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 1999 1.4233799884095788e-03</internalNodes>
+          <leafValues>
+            5.3195142745971680e-01 4.0813559293746948e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2000 -2.4149110540747643e-03</internalNodes>
+          <leafValues>
+            4.0876591205596924e-01 5.2389502525329590e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2001 -1.2165299849584699e-03</internalNodes>
+          <leafValues>
+            5.6745791435241699e-01 4.9080529808998108e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2002 -1.2438809499144554e-03</internalNodes>
+          <leafValues>
+            4.1294258832931519e-01 5.2561181783676147e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2003 6.1942739412188530e-03</internalNodes>
+          <leafValues>
+            5.0601941347122192e-01 7.3136532306671143e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2004 -1.6607169527560472e-03</internalNodes>
+          <leafValues>
+            5.9796321392059326e-01 4.5963698625564575e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2005 -2.7316259220242500e-02</internalNodes>
+          <leafValues>
+            4.1743651032447815e-01 5.3088420629501343e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2006 -1.5845570014789701e-03</internalNodes>
+          <leafValues>
+            5.6158047914505005e-01 4.5194861292839050e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2007 -1.5514739789068699e-03</internalNodes>
+          <leafValues>
+            4.0761870145797729e-01 5.3607851266860962e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2008 3.8446558755822480e-04</internalNodes>
+          <leafValues>
+            4.3472939729690552e-01 5.4304420948028564e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2009 -1.4672259800136089e-02</internalNodes>
+          <leafValues>
+            1.6593049466609955e-01 5.1460939645767212e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2010 8.1608882173895836e-03</internalNodes>
+          <leafValues>
+            4.9618190526962280e-01 1.8847459554672241e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2011 1.1121659772470593e-03</internalNodes>
+          <leafValues>
+            4.8682639002799988e-01 6.0938161611557007e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2012 -7.2603770531713963e-03</internalNodes>
+          <leafValues>
+            6.2843251228332520e-01 4.6903759241104126e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2013 -2.4046430189628154e-04</internalNodes>
+          <leafValues>
+            5.5750000476837158e-01 4.0460440516471863e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2014 -2.3348190006799996e-04</internalNodes>
+          <leafValues>
+            4.1157621145248413e-01 5.2528482675552368e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2015 5.5736480280756950e-03</internalNodes>
+          <leafValues>
+            4.7300729155540466e-01 5.6901007890701294e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2016 3.0623769387602806e-02</internalNodes>
+          <leafValues>
+            4.9718868732452393e-01 1.7400950193405151e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2017 9.2074798885732889e-04</internalNodes>
+          <leafValues>
+            5.3721177577972412e-01 4.3548721075057983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2018 -4.3550739064812660e-05</internalNodes>
+          <leafValues>
+            5.3668838739395142e-01 4.3473169207572937e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2019 -6.6452710889279842e-03</internalNodes>
+          <leafValues>
+            3.4355181455612183e-01 5.1605331897735596e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2020 4.3221998959779739e-02</internalNodes>
+          <leafValues>
+            4.7667920589447021e-01 7.2936528921127319e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2021 2.2331769578158855e-03</internalNodes>
+          <leafValues>
+            5.0293159484863281e-01 5.6331712007522583e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2022 3.1829739455133677e-03</internalNodes>
+          <leafValues>
+            4.0160921216011047e-01 5.1921367645263672e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2023 -1.8027749320026487e-04</internalNodes>
+          <leafValues>
+            4.0883159637451172e-01 5.4179197549819946e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2024 -5.2934689447283745e-03</internalNodes>
+          <leafValues>
+            4.0756770968437195e-01 5.2435618638992310e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2025 1.2750959722325206e-03</internalNodes>
+          <leafValues>
+            4.9132829904556274e-01 6.3870108127593994e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2026 4.3385322205722332e-03</internalNodes>
+          <leafValues>
+            5.0316721200942993e-01 2.9473468661308289e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2027 8.5250744596123695e-03</internalNodes>
+          <leafValues>
+            4.9497890472412109e-01 6.3088691234588623e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2028 -9.4266352243721485e-04</internalNodes>
+          <leafValues>
+            5.3283667564392090e-01 4.2856499552726746e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2029 1.3609660090878606e-03</internalNodes>
+          <leafValues>
+            4.9915251135826111e-01 5.9415012598037720e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2030 4.4782509212382138e-04</internalNodes>
+          <leafValues>
+            4.5735040307044983e-01 5.8544808626174927e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2031 1.3360050506889820e-03</internalNodes>
+          <leafValues>
+            4.6043589711189270e-01 5.8490520715713501e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2032 -6.0967548051849008e-04</internalNodes>
+          <leafValues>
+            3.9693889021873474e-01 5.2294230461120605e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2033 -2.3656780831515789e-03</internalNodes>
+          <leafValues>
+            5.8083200454711914e-01 4.8983570933341980e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2034 1.0734340175986290e-03</internalNodes>
+          <leafValues>
+            4.3512108922004700e-01 5.4700392484664917e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2035 2.1923359017819166e-03</internalNodes>
+          <leafValues>
+            5.3550601005554199e-01 3.8429039716720581e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2036 5.4968618787825108e-03</internalNodes>
+          <leafValues>
+            5.0181388854980469e-01 2.8271919488906860e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2037 -7.5368821620941162e-02</internalNodes>
+          <leafValues>
+            1.2250760197639465e-01 5.1488268375396729e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2038 2.5134470313787460e-02</internalNodes>
+          <leafValues>
+            4.7317668795585632e-01 7.0254462957382202e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2039 -2.9358599931583740e-05</internalNodes>
+          <leafValues>
+            5.4305320978164673e-01 4.6560868620872498e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2040 -5.8355910005047917e-04</internalNodes>
+          <leafValues>
+            4.0310400724411011e-01 5.1901197433471680e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2041 -2.6639450807124376e-03</internalNodes>
+          <leafValues>
+            4.3081268668174744e-01 5.1617711782455444e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2042 -1.3804089976474643e-03</internalNodes>
+          <leafValues>
+            6.2198299169540405e-01 4.6955159306526184e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2043 1.2313219485804439e-03</internalNodes>
+          <leafValues>
+            5.3793638944625854e-01 4.4258311390876770e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2044 -1.4644179827882908e-05</internalNodes>
+          <leafValues>
+            5.2816402912139893e-01 4.2225030064582825e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2045 -1.2818809598684311e-02</internalNodes>
+          <leafValues>
+            2.5820928812026978e-01 5.1799327135086060e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2046 2.2852189838886261e-02</internalNodes>
+          <leafValues>
+            4.7786930203437805e-01 7.6092642545700073e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2047 8.2305970136076212e-04</internalNodes>
+          <leafValues>
+            5.3409922122955322e-01 4.6717241406440735e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2048 1.2770120054483414e-02</internalNodes>
+          <leafValues>
+            4.9657610058784485e-01 1.4723660051822662e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2049 -5.0051510334014893e-02</internalNodes>
+          <leafValues>
+            6.4149940013885498e-01 5.0165921449661255e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2050 1.5775270760059357e-02</internalNodes>
+          <leafValues>
+            4.5223200321197510e-01 5.6853622198104858e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2051 -1.8501620739698410e-02</internalNodes>
+          <leafValues>
+            2.7647489309310913e-01 5.1379591226577759e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2052 2.4626250378787518e-03</internalNodes>
+          <leafValues>
+            5.1419419050216675e-01 3.7954080104827881e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2053 6.2916167080402374e-02</internalNodes>
+          <leafValues>
+            5.0606489181518555e-01 6.5804338455200195e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2054 -2.1648500478477217e-05</internalNodes>
+          <leafValues>
+            5.1953881978988647e-01 4.0198868513107300e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2055 2.1180990152060986e-03</internalNodes>
+          <leafValues>
+            4.9623650312423706e-01 5.9544587135314941e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2056 -1.6634890809655190e-02</internalNodes>
+          <leafValues>
+            3.7579330801963806e-01 5.1754468679428101e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2057 -2.8899470344185829e-03</internalNodes>
+          <leafValues>
+            6.6240137815475464e-01 5.0571787357330322e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2058 7.6783262193202972e-02</internalNodes>
+          <leafValues>
+            4.7957968711853027e-01 8.0477148294448853e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2059 3.9170677773654461e-03</internalNodes>
+          <leafValues>
+            4.9378821253776550e-01 5.7199418544769287e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2060 -7.2670601308345795e-02</internalNodes>
+          <leafValues>
+            5.3894560784101486e-02 4.9439039826393127e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2061 5.4039502143859863e-01</internalNodes>
+          <leafValues>
+            5.1297742128372192e-01 1.1433389782905579e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2062 2.9510019812732935e-03</internalNodes>
+          <leafValues>
+            4.5283439755439758e-01 5.6985741853713989e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2063 3.4508369863033295e-03</internalNodes>
+          <leafValues>
+            5.3577268123626709e-01 4.2187309265136719e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2064 -4.2077939724549651e-04</internalNodes>
+          <leafValues>
+            5.9161728620529175e-01 4.6379259228706360e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2065 3.3051050268113613e-03</internalNodes>
+          <leafValues>
+            5.2733850479125977e-01 4.3820428848266602e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2066 4.7735060798004270e-04</internalNodes>
+          <leafValues>
+            4.0465280413627625e-01 5.1818847656250000e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2067 -2.5928510352969170e-02</internalNodes>
+          <leafValues>
+            7.4522358179092407e-01 5.0893861055374146e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2068 -2.9729790985584259e-03</internalNodes>
+          <leafValues>
+            3.2954359054565430e-01 5.0587952136993408e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2069 5.8508329093456268e-03</internalNodes>
+          <leafValues>
+            4.8571440577507019e-01 5.7930248975753784e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2070 -4.5967519283294678e-02</internalNodes>
+          <leafValues>
+            4.3127310276031494e-01 5.3806531429290771e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2071 1.5585960447788239e-01</internalNodes>
+          <leafValues>
+            5.1961702108383179e-01 1.6847139596939087e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2072 1.5164829790592194e-02</internalNodes>
+          <leafValues>
+            4.7357571125030518e-01 6.7350268363952637e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2073 -1.0604249546304345e-03</internalNodes>
+          <leafValues>
+            5.8229267597198486e-01 4.7757029533386230e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2074 6.6476291976869106e-03</internalNodes>
+          <leafValues>
+            4.9991989135742188e-01 2.3195350170135498e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2075 -1.2231130152940750e-02</internalNodes>
+          <leafValues>
+            4.7508931159973145e-01 5.2629822492599487e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2076 5.6528882123529911e-03</internalNodes>
+          <leafValues>
+            5.0697678327560425e-01 3.5618188977241516e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2077 1.2977829901501536e-03</internalNodes>
+          <leafValues>
+            4.8756939172744751e-01 5.6190627813339233e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2078 1.0781589895486832e-02</internalNodes>
+          <leafValues>
+            4.7507700324058533e-01 6.7823082208633423e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2079 2.8654779307544231e-03</internalNodes>
+          <leafValues>
+            5.3054618835449219e-01 4.2907360196113586e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2080 2.8663428965955973e-03</internalNodes>
+          <leafValues>
+            4.5184791088104248e-01 5.5393511056900024e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2081 -5.1983320154249668e-03</internalNodes>
+          <leafValues>
+            4.1491198539733887e-01 5.4341888427734375e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2082 5.3739990107715130e-03</internalNodes>
+          <leafValues>
+            4.7178968787193298e-01 6.5076571702957153e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2083 -1.4641529880464077e-02</internalNodes>
+          <leafValues>
+            2.1721640229225159e-01 5.1617771387100220e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2084 -1.5042580344015732e-05</internalNodes>
+          <leafValues>
+            5.3373837471008301e-01 4.2988368868827820e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2085 -1.1875660129589960e-04</internalNodes>
+          <leafValues>
+            4.6045941114425659e-01 5.5824470520019531e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2086 1.6995530575513840e-02</internalNodes>
+          <leafValues>
+            4.9458950757980347e-01 7.3880076408386230e-02</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2087 -3.5095941275358200e-02</internalNodes>
+          <leafValues>
+            7.0055091381072998e-01 4.9775910377502441e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2088 2.4217350874096155e-03</internalNodes>
+          <leafValues>
+            4.4662651419639587e-01 5.4776942729949951e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2089 -9.6340337768197060e-04</internalNodes>
+          <leafValues>
+            4.7140988707542419e-01 5.3133380413055420e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2090 1.6391130338888615e-04</internalNodes>
+          <leafValues>
+            4.3315461277961731e-01 5.3422421216964722e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2091 -2.1141460165381432e-02</internalNodes>
+          <leafValues>
+            2.6447001099586487e-01 5.2044987678527832e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2092 8.7775202700868249e-04</internalNodes>
+          <leafValues>
+            5.2083498239517212e-01 4.1527429223060608e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2093 -2.7943920344114304e-02</internalNodes>
+          <leafValues>
+            6.3441252708435059e-01 5.0188118219375610e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2094 6.7297378554940224e-03</internalNodes>
+          <leafValues>
+            5.0504380464553833e-01 3.5008639097213745e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2095 2.3281039670109749e-02</internalNodes>
+          <leafValues>
+            4.9663180112838745e-01 6.9686770439147949e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2096 -1.1644979938864708e-02</internalNodes>
+          <leafValues>
+            3.3002600073814392e-01 5.0496298074722290e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2097 1.5764309093356133e-02</internalNodes>
+          <leafValues>
+            4.9915981292724609e-01 7.3211538791656494e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2098 -1.3611479662358761e-03</internalNodes>
+          <leafValues>
+            3.9117351174354553e-01 5.1606708765029907e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2099 -8.1522337859496474e-04</internalNodes>
+          <leafValues>
+            5.6289112567901611e-01 4.9497190117835999e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2100 -6.0066272271797061e-04</internalNodes>
+          <leafValues>
+            5.8535951375961304e-01 4.5505958795547485e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2101 4.9715518252924085e-04</internalNodes>
+          <leafValues>
+            4.2714700102806091e-01 5.4435992240905762e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2102 2.3475370835512877e-03</internalNodes>
+          <leafValues>
+            5.1431107521057129e-01 3.8876569271087646e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2103 -8.9261569082736969e-03</internalNodes>
+          <leafValues>
+            6.0445022583007812e-01 4.9717208743095398e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2104 -1.3919910416007042e-02</internalNodes>
+          <leafValues>
+            2.5831609964370728e-01 5.0003677606582642e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2105 1.0209949687123299e-03</internalNodes>
+          <leafValues>
+            4.8573741316795349e-01 5.5603581666946411e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2106 -2.7441629208624363e-03</internalNodes>
+          <leafValues>
+            5.9368848800659180e-01 4.6457770466804504e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2107 -1.6200130805373192e-02</internalNodes>
+          <leafValues>
+            3.1630149483680725e-01 5.1934951543807983e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2108 4.3331980705261230e-03</internalNodes>
+          <leafValues>
+            5.0612241029739380e-01 3.4588789939880371e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2109 5.8497930876910686e-04</internalNodes>
+          <leafValues>
+            4.7790178656578064e-01 5.8701777458190918e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2110 -2.2466450463980436e-03</internalNodes>
+          <leafValues>
+            4.2978510260581970e-01 5.3747731447219849e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2111 2.3146099410951138e-03</internalNodes>
+          <leafValues>
+            5.4386717081069946e-01 4.6409699320793152e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2112 8.7679121643304825e-03</internalNodes>
+          <leafValues>
+            4.7268930077552795e-01 6.7717897891998291e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2113 -2.2448020172305405e-04</internalNodes>
+          <leafValues>
+            4.2291730642318726e-01 5.4280489683151245e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2114 -7.4336021207273006e-03</internalNodes>
+          <leafValues>
+            6.0988807678222656e-01 4.6836739778518677e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2115 -2.3189240600913763e-03</internalNodes>
+          <leafValues>
+            5.6894367933273315e-01 4.4242420792579651e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2116 -2.1042178850620985e-03</internalNodes>
+          <leafValues>
+            3.7622210383415222e-01 5.1870870590209961e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2117 4.6034841216169298e-04</internalNodes>
+          <leafValues>
+            4.6994051337242126e-01 5.7712072134017944e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2118 1.0547629790380597e-03</internalNodes>
+          <leafValues>
+            4.4652169942855835e-01 5.6017017364501953e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2119 8.7148818420246243e-04</internalNodes>
+          <leafValues>
+            5.4498052597045898e-01 3.9147090911865234e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2120 3.3364820410497487e-04</internalNodes>
+          <leafValues>
+            4.5640090107917786e-01 5.6457388401031494e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2121 -1.4853250468149781e-03</internalNodes>
+          <leafValues>
+            5.7473778724670410e-01 4.6927788853645325e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2122 3.0251620337367058e-03</internalNodes>
+          <leafValues>
+            5.1661968231201172e-01 3.7628141045570374e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2123 5.0280741415917873e-03</internalNodes>
+          <leafValues>
+            5.0021117925643921e-01 6.1515271663665771e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2124 -5.8164511574432254e-04</internalNodes>
+          <leafValues>
+            5.3945982456207275e-01 4.3907511234283447e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2125 4.5141529291868210e-02</internalNodes>
+          <leafValues>
+            5.1883268356323242e-01 2.0630359649658203e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2126 -1.0795620037242770e-03</internalNodes>
+          <leafValues>
+            3.9046850800514221e-01 5.1379072666168213e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2127 1.5995999274309725e-04</internalNodes>
+          <leafValues>
+            4.8953229188919067e-01 5.4275041818618774e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2128 -1.9359270110726357e-02</internalNodes>
+          <leafValues>
+            6.9752287864685059e-01 4.7735071182250977e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2129 2.0725509524345398e-01</internalNodes>
+          <leafValues>
+            5.2336359024047852e-01 3.0349919199943542e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2130 -4.1953290929086506e-04</internalNodes>
+          <leafValues>
+            5.4193967580795288e-01 4.4601860642433167e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2131 2.2582069505006075e-03</internalNodes>
+          <leafValues>
+            4.8157641291618347e-01 6.0274088382720947e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2132 -6.7811207845807076e-03</internalNodes>
+          <leafValues>
+            3.9802789688110352e-01 5.1833057403564453e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2133 1.1154309846460819e-02</internalNodes>
+          <leafValues>
+            5.4312318563461304e-01 4.1887599229812622e-01</leafValues></_>
+        <_>
+          <internalNodes>
+            0 -1 2134 4.3162431567907333e-02</internalNodes>
+          <leafValues>
+            4.7382280230522156e-01 6.5229612588882446e-01</leafValues></_></weakClassifiers></_></stages>
+  <features>
+    <_>
+      <rects>
+        <_>
+          3 7 14 4 -1.</_>
+        <_>
+          3 9 14 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 18 4 -1.</_>
+        <_>
+          7 2 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 15 9 -1.</_>
+        <_>
+          1 10 15 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 2 6 -1.</_>
+        <_>
+          5 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 3 -1.</_>
+        <_>
+          9 5 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 12 9 -1.</_>
+        <_>
+          4 3 12 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 10 8 -1.</_>
+        <_>
+          6 13 10 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 14 8 -1.</_>
+        <_>
+          3 10 14 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 1 6 10 -1.</_>
+        <_>
+          14 1 3 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 5 12 -1.</_>
+        <_>
+          7 12 5 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 18 3 -1.</_>
+        <_>
+          7 1 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 17 2 -1.</_>
+        <_>
+          1 9 17 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 6 4 2 -1.</_>
+        <_>
+          16 7 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 17 2 2 -1.</_>
+        <_>
+          5 18 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 12 -1.</_>
+        <_>
+          14 2 3 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 4 12 -1.</_>
+        <_>
+          4 0 2 6 2.</_>
+        <_>
+          6 6 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 18 8 -1.</_>
+        <_>
+          8 11 6 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 2 -1.</_>
+        <_>
+          5 8 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 5 3 -1.</_>
+        <_>
+          15 12 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 10 9 -1.</_>
+        <_>
+          5 6 10 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 14 -1.</_>
+        <_>
+          9 11 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 5 4 12 -1.</_>
+        <_>
+          3 9 4 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 5 -1.</_>
+        <_>
+          8 5 4 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 10 8 -1.</_>
+        <_>
+          5 10 10 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 6 9 -1.</_>
+        <_>
+          8 3 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 1 8 -1.</_>
+        <_>
+          9 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 20 6 -1.</_>
+        <_>
+          0 9 20 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 17 -1.</_>
+        <_>
+          9 0 2 17 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 6 4 -1.</_>
+        <_>
+          11 0 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 6 4 -1.</_>
+        <_>
+          7 1 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 1 6 16 -1.</_>
+        <_>
+          14 1 2 16 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 18 8 -1.</_>
+        <_>
+          0 5 9 4 2.</_>
+        <_>
+          9 9 9 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 10 4 -1.</_>
+        <_>
+          13 15 5 2 2.</_>
+        <_>
+          8 17 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 4 8 -1.</_>
+        <_>
+          3 1 2 4 2.</_>
+        <_>
+          5 5 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 14 10 -1.</_>
+        <_>
+          10 6 7 5 2.</_>
+        <_>
+          3 11 7 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 6 16 -1.</_>
+        <_>
+          4 1 2 16 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 18 20 2 -1.</_>
+        <_>
+          0 19 20 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 3 -1.</_>
+        <_>
+          8 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 12 9 6 -1.</_>
+        <_>
+          0 14 9 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 3 4 -1.</_>
+        <_>
+          5 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 2 16 -1.</_>
+        <_>
+          9 11 2 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 13 8 -1.</_>
+        <_>
+          3 10 13 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 8 2 -1.</_>
+        <_>
+          12 3 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 4 12 -1.</_>
+        <_>
+          8 12 4 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 8 6 -1.</_>
+        <_>
+          15 3 4 3 2.</_>
+        <_>
+          11 6 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 19 -1.</_>
+        <_>
+          9 1 2 19 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 6 4 -1.</_>
+        <_>
+          11 0 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 9 3 -1.</_>
+        <_>
+          6 1 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 10 4 -1.</_>
+        <_>
+          13 15 5 2 2.</_>
+        <_>
+          8 17 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 6 10 -1.</_>
+        <_>
+          3 3 3 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 15 15 -1.</_>
+        <_>
+          3 9 15 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 8 6 -1.</_>
+        <_>
+          6 7 8 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 12 10 -1.</_>
+        <_>
+          10 4 6 5 2.</_>
+        <_>
+          4 9 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 4 4 -1.</_>
+        <_>
+          8 4 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 1 2 -1.</_>
+        <_>
+          15 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 2 2 -1.</_>
+        <_>
+          3 12 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 11 1 3 -1.</_>
+        <_>
+          16 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 15 6 4 -1.</_>
+        <_>
+          3 15 3 2 2.</_>
+        <_>
+          6 17 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 8 2 -1.</_>
+        <_>
+          6 8 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 1 3 -1.</_>
+        <_>
+          3 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 12 2 -1.</_>
+        <_>
+          6 1 12 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 6 2 -1.</_>
+        <_>
+          7 16 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 4 6 -1.</_>
+        <_>
+          0 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 12 2 -1.</_>
+        <_>
+          8 12 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 1 9 -1.</_>
+        <_>
+          6 6 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 17 3 2 -1.</_>
+        <_>
+          11 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 4 -1.</_>
+        <_>
+          9 6 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 17 3 2 -1.</_>
+        <_>
+          8 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 17 3 3 -1.</_>
+        <_>
+          11 17 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 3 2 -1.</_>
+        <_>
+          8 13 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 6 2 -1.</_>
+        <_>
+          11 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 14 4 -1.</_>
+        <_>
+          3 13 14 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 18 4 -1.</_>
+        <_>
+          10 10 9 2 2.</_>
+        <_>
+          1 12 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 3 3 -1.</_>
+        <_>
+          0 11 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 1 6 6 -1.</_>
+        <_>
+          11 1 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 6 -1.</_>
+        <_>
+          9 7 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 9 -1.</_>
+        <_>
+          1 3 18 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 10 2 6 -1.</_>
+        <_>
+          12 13 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 19 8 -1.</_>
+        <_>
+          0 9 19 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 9 -1.</_>
+        <_>
+          9 0 2 9 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 6 1 -1.</_>
+        <_>
+          7 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 6 1 -1.</_>
+        <_>
+          13 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 4 6 -1.</_>
+        <_>
+          5 13 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 6 1 -1.</_>
+        <_>
+          13 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 12 6 -1.</_>
+        <_>
+          4 6 12 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 12 2 6 -1.</_>
+        <_>
+          15 14 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 2 2 -1.</_>
+        <_>
+          10 3 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 3 1 -1.</_>
+        <_>
+          10 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 4 14 -1.</_>
+        <_>
+          3 1 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 4 4 -1.</_>
+        <_>
+          11 0 2 2 2.</_>
+        <_>
+          9 2 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 1 14 -1.</_>
+        <_>
+          7 12 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 0 1 4 -1.</_>
+        <_>
+          19 2 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 6 4 -1.</_>
+        <_>
+          8 5 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 18 3 2 -1.</_>
+        <_>
+          10 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 18 3 2 -1.</_>
+        <_>
+          9 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 6 -1.</_>
+        <_>
+          4 7 12 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 2 6 -1.</_>
+        <_>
+          3 14 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 2 12 -1.</_>
+        <_>
+          10 12 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 18 3 2 -1.</_>
+        <_>
+          8 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 6 2 -1.</_>
+        <_>
+          11 0 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 9 3 -1.</_>
+        <_>
+          5 12 9 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 6 2 -1.</_>
+        <_>
+          11 0 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 18 5 -1.</_>
+        <_>
+          7 1 6 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 4 4 -1.</_>
+        <_>
+          10 0 2 2 2.</_>
+        <_>
+          8 2 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 1 3 -1.</_>
+        <_>
+          3 13 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 5 3 -1.</_>
+        <_>
+          8 15 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 10 12 -1.</_>
+        <_>
+          5 4 5 6 2.</_>
+        <_>
+          10 10 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 9 12 -1.</_>
+        <_>
+          9 10 9 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 12 14 -1.</_>
+        <_>
+          2 2 6 7 2.</_>
+        <_>
+          8 9 6 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 12 2 -1.</_>
+        <_>
+          8 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 6 4 -1.</_>
+        <_>
+          7 6 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 11 8 -1.</_>
+        <_>
+          4 9 11 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 10 16 4 -1.</_>
+        <_>
+          3 12 16 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 16 2 -1.</_>
+        <_>
+          0 1 16 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 2 -1.</_>
+        <_>
+          9 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 6 10 -1.</_>
+        <_>
+          3 2 3 5 2.</_>
+        <_>
+          6 7 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 5 8 15 -1.</_>
+        <_>
+          10 10 8 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 8 6 -1.</_>
+        <_>
+          3 14 4 3 2.</_>
+        <_>
+          7 17 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 2 2 -1.</_>
+        <_>
+          14 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 7 6 -1.</_>
+        <_>
+          1 13 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 4 4 3 -1.</_>
+        <_>
+          15 4 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 9 14 6 -1.</_>
+        <_>
+          2 9 7 3 2.</_>
+        <_>
+          9 12 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 4 -1.</_>
+        <_>
+          5 9 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 8 8 -1.</_>
+        <_>
+          6 9 4 4 2.</_>
+        <_>
+          10 13 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 1 3 2 -1.</_>
+        <_>
+          14 2 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 4 2 -1.</_>
+        <_>
+          3 4 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 2 8 -1.</_>
+        <_>
+          11 14 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 5 3 -1.</_>
+        <_>
+          0 1 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 5 18 8 -1.</_>
+        <_>
+          11 5 9 4 2.</_>
+        <_>
+          2 9 9 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 1 6 -1.</_>
+        <_>
+          6 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 1 1 3 -1.</_>
+        <_>
+          19 2 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 6 -1.</_>
+        <_>
+          9 6 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 1 1 3 -1.</_>
+        <_>
+          19 2 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 2 3 -1.</_>
+        <_>
+          3 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 4 8 12 -1.</_>
+        <_>
+          12 4 4 6 2.</_>
+        <_>
+          8 10 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 6 3 -1.</_>
+        <_>
+          7 2 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 9 10 -1.</_>
+        <_>
+          6 6 9 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 6 12 -1.</_>
+        <_>
+          2 4 2 12 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 3 -1.</_>
+        <_>
+          15 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 5 3 -1.</_>
+        <_>
+          7 15 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 3 3 -1.</_>
+        <_>
+          15 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 14 8 3 -1.</_>
+        <_>
+          6 15 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 3 3 -1.</_>
+        <_>
+          15 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 13 3 3 -1.</_>
+        <_>
+          2 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 12 12 -1.</_>
+        <_>
+          10 7 6 6 2.</_>
+        <_>
+          4 13 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 6 -1.</_>
+        <_>
+          10 7 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 5 2 -1.</_>
+        <_>
+          8 10 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 3 4 -1.</_>
+        <_>
+          9 6 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 8 -1.</_>
+        <_>
+          9 10 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 3 6 -1.</_>
+        <_>
+          8 7 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 3 3 -1.</_>
+        <_>
+          12 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 6 1 -1.</_>
+        <_>
+          7 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 10 3 -1.</_>
+        <_>
+          5 7 10 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 6 9 -1.</_>
+        <_>
+          7 6 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 9 1 -1.</_>
+        <_>
+          9 7 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 16 8 -1.</_>
+        <_>
+          2 12 16 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 2 6 -1.</_>
+        <_>
+          14 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 5 6 15 -1.</_>
+        <_>
+          1 10 6 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 6 9 -1.</_>
+        <_>
+          10 3 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 7 14 -1.</_>
+        <_>
+          6 13 7 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 3 6 -1.</_>
+        <_>
+          13 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 15 4 -1.</_>
+        <_>
+          6 8 5 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 3 10 -1.</_>
+        <_>
+          11 7 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 4 6 -1.</_>
+        <_>
+          3 9 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 3 6 10 -1.</_>
+        <_>
+          15 3 2 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 8 10 -1.</_>
+        <_>
+          5 7 4 5 2.</_>
+        <_>
+          9 12 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 12 12 -1.</_>
+        <_>
+          10 4 6 6 2.</_>
+        <_>
+          4 10 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 6 9 -1.</_>
+        <_>
+          3 4 2 9 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 2 5 -1.</_>
+        <_>
+          11 3 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 2 5 -1.</_>
+        <_>
+          8 3 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 2 3 -1.</_>
+        <_>
+          10 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 6 2 -1.</_>
+        <_>
+          8 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 12 6 -1.</_>
+        <_>
+          4 14 12 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 5 9 -1.</_>
+        <_>
+          11 14 5 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 15 3 2 -1.</_>
+        <_>
+          6 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 5 -1.</_>
+        <_>
+          12 0 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 6 7 -1.</_>
+        <_>
+          8 5 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 1 9 -1.</_>
+        <_>
+          13 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 4 8 -1.</_>
+        <_>
+          3 2 2 4 2.</_>
+        <_>
+          5 6 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 12 4 6 -1.</_>
+        <_>
+          13 14 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 4 6 -1.</_>
+        <_>
+          3 14 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 3 4 -1.</_>
+        <_>
+          13 13 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 4 3 -1.</_>
+        <_>
+          4 5 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 11 8 -1.</_>
+        <_>
+          7 9 11 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 3 4 -1.</_>
+        <_>
+          8 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 1 6 1 -1.</_>
+        <_>
+          11 1 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 3 3 -1.</_>
+        <_>
+          5 6 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 20 6 -1.</_>
+        <_>
+          10 9 10 3 2.</_>
+        <_>
+          0 12 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 3 5 -1.</_>
+        <_>
+          9 6 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 1 3 -1.</_>
+        <_>
+          11 1 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 4 2 -1.</_>
+        <_>
+          4 3 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 6 4 3 -1.</_>
+        <_>
+          12 7 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 6 4 -1.</_>
+        <_>
+          7 0 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 8 -1.</_>
+        <_>
+          10 7 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 2 -1.</_>
+        <_>
+          10 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 14 4 -1.</_>
+        <_>
+          13 7 7 2 2.</_>
+        <_>
+          6 9 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 3 6 -1.</_>
+        <_>
+          0 7 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 3 4 -1.</_>
+        <_>
+          13 13 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 3 4 -1.</_>
+        <_>
+          4 13 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 12 8 -1.</_>
+        <_>
+          11 9 6 4 2.</_>
+        <_>
+          5 13 6 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 1 3 -1.</_>
+        <_>
+          9 13 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 15 2 4 -1.</_>
+        <_>
+          10 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 1 -1.</_>
+        <_>
+          9 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 6 6 -1.</_>
+        <_>
+          15 3 3 3 2.</_>
+        <_>
+          12 6 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 10 6 -1.</_>
+        <_>
+          0 6 10 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 3 8 14 -1.</_>
+        <_>
+          12 3 4 7 2.</_>
+        <_>
+          8 10 4 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 7 15 -1.</_>
+        <_>
+          4 9 7 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 6 8 -1.</_>
+        <_>
+          15 2 3 4 2.</_>
+        <_>
+          12 6 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 6 8 -1.</_>
+        <_>
+          2 2 3 4 2.</_>
+        <_>
+          5 6 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 13 18 7 -1.</_>
+        <_>
+          8 13 6 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 8 14 -1.</_>
+        <_>
+          4 3 4 7 2.</_>
+        <_>
+          8 10 4 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 6 -1.</_>
+        <_>
+          18 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 6 -1.</_>
+        <_>
+          18 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 2 6 -1.</_>
+        <_>
+          0 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 5 18 6 -1.</_>
+        <_>
+          1 7 18 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 6 7 -1.</_>
+        <_>
+          3 2 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 6 14 -1.</_>
+        <_>
+          7 10 6 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 13 10 -1.</_>
+        <_>
+          3 12 13 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 15 2 2 -1.</_>
+        <_>
+          11 16 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 16 4 -1.</_>
+        <_>
+          2 11 8 2 2.</_>
+        <_>
+          10 13 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 6 4 -1.</_>
+        <_>
+          16 7 3 2 2.</_>
+        <_>
+          13 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 3 9 -1.</_>
+        <_>
+          6 13 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 1 6 -1.</_>
+        <_>
+          14 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 4 1 -1.</_>
+        <_>
+          7 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 8 15 5 -1.</_>
+        <_>
+          8 8 5 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 6 5 4 -1.</_>
+        <_>
+          1 8 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 17 6 -1.</_>
+        <_>
+          3 3 17 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 8 2 -1.</_>
+        <_>
+          10 7 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 2 -1.</_>
+        <_>
+          10 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 2 -1.</_>
+        <_>
+          9 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 4 2 -1.</_>
+        <_>
+          8 10 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 4 3 -1.</_>
+        <_>
+          8 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 4 -1.</_>
+        <_>
+          9 5 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 3 -1.</_>
+        <_>
+          8 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 12 6 -1.</_>
+        <_>
+          10 7 6 3 2.</_>
+        <_>
+          4 10 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          9 8 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 3 8 -1.</_>
+        <_>
+          8 4 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 3 6 -1.</_>
+        <_>
+          11 0 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 4 8 -1.</_>
+        <_>
+          8 3 2 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 6 13 -1.</_>
+        <_>
+          14 3 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 3 6 -1.</_>
+        <_>
+          8 16 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 6 13 -1.</_>
+        <_>
+          14 3 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 10 4 -1.</_>
+        <_>
+          0 7 5 2 2.</_>
+        <_>
+          5 9 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 6 13 -1.</_>
+        <_>
+          14 3 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 6 13 -1.</_>
+        <_>
+          3 3 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 1 4 1 -1.</_>
+        <_>
+          9 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 2 1 -1.</_>
+        <_>
+          9 0 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 4 4 -1.</_>
+        <_>
+          12 16 2 2 2.</_>
+        <_>
+          10 18 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 3 -1.</_>
+        <_>
+          10 6 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 2 -1.</_>
+        <_>
+          8 5 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 5 -1.</_>
+        <_>
+          9 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 8 6 -1.</_>
+        <_>
+          6 6 8 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 12 -1.</_>
+        <_>
+          9 11 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 6 6 8 -1.</_>
+        <_>
+          4 10 6 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 8 5 -1.</_>
+        <_>
+          12 2 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 18 3 -1.</_>
+        <_>
+          0 9 18 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 8 -1.</_>
+        <_>
+          8 16 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 8 5 -1.</_>
+        <_>
+          4 2 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 3 4 -1.</_>
+        <_>
+          13 13 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 6 1 -1.</_>
+        <_>
+          7 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 3 1 -1.</_>
+        <_>
+          12 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 5 3 -1.</_>
+        <_>
+          7 14 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 7 6 -1.</_>
+        <_>
+          11 14 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 7 6 -1.</_>
+        <_>
+          2 14 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 14 2 6 -1.</_>
+        <_>
+          12 16 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 3 3 -1.</_>
+        <_>
+          8 15 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 5 -1.</_>
+        <_>
+          12 0 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 4 9 -1.</_>
+        <_>
+          8 1 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 6 1 -1.</_>
+        <_>
+          12 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 3 4 -1.</_>
+        <_>
+          8 10 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          8 13 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 18 4 2 -1.</_>
+        <_>
+          5 19 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 18 6 -1.</_>
+        <_>
+          2 3 18 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 2 -1.</_>
+        <_>
+          7 0 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 8 6 2 -1.</_>
+        <_>
+          16 8 3 1 2.</_>
+        <_>
+          13 9 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 3 6 -1.</_>
+        <_>
+          6 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 20 4 -1.</_>
+        <_>
+          10 13 10 2 2.</_>
+        <_>
+          0 15 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 5 -1.</_>
+        <_>
+          9 7 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 2 2 -1.</_>
+        <_>
+          11 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 6 2 -1.</_>
+        <_>
+          1 8 3 1 2.</_>
+        <_>
+          4 9 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 20 2 -1.</_>
+        <_>
+          10 2 10 1 2.</_>
+        <_>
+          0 3 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 5 3 -1.</_>
+        <_>
+          7 15 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 6 -1.</_>
+        <_>
+          10 13 3 3 2.</_>
+        <_>
+          7 16 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 3 -1.</_>
+        <_>
+          9 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 11 1 6 -1.</_>
+        <_>
+          16 13 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 1 6 -1.</_>
+        <_>
+          3 13 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 14 12 -1.</_>
+        <_>
+          11 4 7 6 2.</_>
+        <_>
+          4 10 7 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 3 3 -1.</_>
+        <_>
+          13 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 8 3 -1.</_>
+        <_>
+          6 7 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 3 3 -1.</_>
+        <_>
+          13 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 4 10 -1.</_>
+        <_>
+          3 1 2 5 2.</_>
+        <_>
+          5 6 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 2 -1.</_>
+        <_>
+          5 7 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          9 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 12 2 3 -1.</_>
+        <_>
+          15 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 3 4 -1.</_>
+        <_>
+          8 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 1 12 -1.</_>
+        <_>
+          13 10 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 12 -1.</_>
+        <_>
+          4 5 6 6 2.</_>
+        <_>
+          10 11 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 7 3 -1.</_>
+        <_>
+          7 15 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 2 3 -1.</_>
+        <_>
+          3 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 14 2 -1.</_>
+        <_>
+          10 2 7 1 2.</_>
+        <_>
+          3 3 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 3 10 -1.</_>
+        <_>
+          1 1 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 6 5 -1.</_>
+        <_>
+          11 0 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 6 2 -1.</_>
+        <_>
+          8 7 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 10 -1.</_>
+        <_>
+          7 6 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 18 3 -1.</_>
+        <_>
+          7 1 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 6 -1.</_>
+        <_>
+          16 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 7 6 -1.</_>
+        <_>
+          6 6 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 12 2 -1.</_>
+        <_>
+          8 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 17 10 -1.</_>
+        <_>
+          0 9 17 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 15 16 -1.</_>
+        <_>
+          3 12 15 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 6 4 -1.</_>
+        <_>
+          7 17 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 2 4 9 -1.</_>
+        <_>
+          15 2 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 3 2 -1.</_>
+        <_>
+          2 4 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 6 7 9 -1.</_>
+        <_>
+          13 9 7 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 3 -1.</_>
+        <_>
+          8 12 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 20 6 -1.</_>
+        <_>
+          10 2 10 3 2.</_>
+        <_>
+          0 5 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 6 10 -1.</_>
+        <_>
+          3 2 3 5 2.</_>
+        <_>
+          6 7 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 10 3 4 -1.</_>
+        <_>
+          13 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 10 3 4 -1.</_>
+        <_>
+          4 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 3 -1.</_>
+        <_>
+          9 5 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 8 -1.</_>
+        <_>
+          7 10 6 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 11 20 6 -1.</_>
+        <_>
+          0 14 20 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 13 4 6 -1.</_>
+        <_>
+          4 13 2 3 2.</_>
+        <_>
+          6 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 12 -1.</_>
+        <_>
+          10 0 4 6 2.</_>
+        <_>
+          6 6 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 15 2 -1.</_>
+        <_>
+          2 1 15 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 3 -1.</_>
+        <_>
+          9 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 1 2 -1.</_>
+        <_>
+          3 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 3 1 -1.</_>
+        <_>
+          8 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 7 3 6 -1.</_>
+        <_>
+          17 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 3 2 -1.</_>
+        <_>
+          8 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 5 3 -1.</_>
+        <_>
+          11 5 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 5 3 -1.</_>
+        <_>
+          4 5 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 3 1 2 -1.</_>
+        <_>
+          19 4 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 4 3 -1.</_>
+        <_>
+          5 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 7 3 6 -1.</_>
+        <_>
+          17 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 3 6 -1.</_>
+        <_>
+          0 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 9 -1.</_>
+        <_>
+          14 5 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 5 6 -1.</_>
+        <_>
+          0 6 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 5 6 2 -1.</_>
+        <_>
+          12 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 6 2 -1.</_>
+        <_>
+          6 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 4 6 -1.</_>
+        <_>
+          8 3 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 6 -1.</_>
+        <_>
+          0 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 8 3 -1.</_>
+        <_>
+          6 7 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 5 9 -1.</_>
+        <_>
+          0 4 5 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 15 -1.</_>
+        <_>
+          16 0 2 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 3 2 -1.</_>
+        <_>
+          1 11 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 4 1 10 -1.</_>
+        <_>
+          14 9 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 4 12 -1.</_>
+        <_>
+          2 1 2 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 4 2 -1.</_>
+        <_>
+          11 11 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 4 2 -1.</_>
+        <_>
+          7 11 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 8 15 5 -1.</_>
+        <_>
+          8 8 5 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 6 10 -1.</_>
+        <_>
+          3 0 3 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 3 2 -1.</_>
+        <_>
+          12 4 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 3 8 -1.</_>
+        <_>
+          8 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 5 3 -1.</_>
+        <_>
+          8 15 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 4 3 -1.</_>
+        <_>
+          7 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 3 2 -1.</_>
+        <_>
+          12 4 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 15 14 4 -1.</_>
+        <_>
+          3 15 7 2 2.</_>
+        <_>
+          10 17 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 16 4 -1.</_>
+        <_>
+          10 2 8 2 2.</_>
+        <_>
+          2 4 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 6 12 -1.</_>
+        <_>
+          3 8 3 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 2 -1.</_>
+        <_>
+          5 7 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 5 -1.</_>
+        <_>
+          10 7 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 6 4 -1.</_>
+        <_>
+          16 7 3 2 2.</_>
+        <_>
+          13 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 8 2 -1.</_>
+        <_>
+          0 14 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 6 4 -1.</_>
+        <_>
+          16 7 3 2 2.</_>
+        <_>
+          13 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 6 4 -1.</_>
+        <_>
+          1 7 3 2 2.</_>
+        <_>
+          4 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 6 1 12 -1.</_>
+        <_>
+          12 12 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 6 -1.</_>
+        <_>
+          10 5 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 2 3 -1.</_>
+        <_>
+          14 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 3 -1.</_>
+        <_>
+          4 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 3 -1.</_>
+        <_>
+          8 13 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 2 4 -1.</_>
+        <_>
+          5 2 1 2 2.</_>
+        <_>
+          6 4 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 11 3 -1.</_>
+        <_>
+          5 6 11 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 4 12 -1.</_>
+        <_>
+          7 12 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 13 8 5 -1.</_>
+        <_>
+          12 13 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 1 12 -1.</_>
+        <_>
+          7 12 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 6 3 -1.</_>
+        <_>
+          4 2 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 10 -1.</_>
+        <_>
+          12 5 3 5 2.</_>
+        <_>
+          9 10 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 8 12 -1.</_>
+        <_>
+          5 5 4 6 2.</_>
+        <_>
+          9 11 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 20 6 -1.</_>
+        <_>
+          0 9 20 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 2 2 -1.</_>
+        <_>
+          4 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 18 12 2 -1.</_>
+        <_>
+          8 18 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 4 16 -1.</_>
+        <_>
+          7 12 4 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 7 8 -1.</_>
+        <_>
+          7 10 7 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 3 1 -1.</_>
+        <_>
+          7 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 15 2 4 -1.</_>
+        <_>
+          11 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 5 4 8 -1.</_>
+        <_>
+          3 9 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 12 -1.</_>
+        <_>
+          7 7 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 6 6 2 -1.</_>
+        <_>
+          6 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 4 4 6 -1.</_>
+        <_>
+          16 6 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 3 5 2 -1.</_>
+        <_>
+          3 4 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 4 2 -1.</_>
+        <_>
+          2 17 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 6 -1.</_>
+        <_>
+          10 13 3 3 2.</_>
+        <_>
+          7 16 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 3 4 -1.</_>
+        <_>
+          8 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 4 6 -1.</_>
+        <_>
+          0 6 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 12 3 -1.</_>
+        <_>
+          9 6 4 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 14 -1.</_>
+        <_>
+          9 6 2 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          10 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 2 4 -1.</_>
+        <_>
+          6 14 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 7 6 -1.</_>
+        <_>
+          10 14 7 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 15 2 -1.</_>
+        <_>
+          1 1 15 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 6 -1.</_>
+        <_>
+          14 0 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 3 1 -1.</_>
+        <_>
+          6 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 6 -1.</_>
+        <_>
+          14 0 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 20 10 -1.</_>
+        <_>
+          0 8 20 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 6 -1.</_>
+        <_>
+          14 0 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 6 6 -1.</_>
+        <_>
+          3 0 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 15 1 2 -1.</_>
+        <_>
+          19 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 4 8 -1.</_>
+        <_>
+          2 2 2 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 18 4 -1.</_>
+        <_>
+          11 1 9 2 2.</_>
+        <_>
+          2 3 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 1 2 -1.</_>
+        <_>
+          8 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 10 6 -1.</_>
+        <_>
+          10 2 5 3 2.</_>
+        <_>
+          5 5 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 4 -1.</_>
+        <_>
+          10 7 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          10 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 8 -1.</_>
+        <_>
+          8 5 4 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 15 4 3 -1.</_>
+        <_>
+          15 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 18 3 1 -1.</_>
+        <_>
+          9 18 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 4 3 -1.</_>
+        <_>
+          9 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 4 3 -1.</_>
+        <_>
+          7 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 15 1 2 -1.</_>
+        <_>
+          19 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 8 4 -1.</_>
+        <_>
+          0 17 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 6 4 -1.</_>
+        <_>
+          11 3 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 14 6 -1.</_>
+        <_>
+          3 16 14 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 6 6 -1.</_>
+        <_>
+          6 6 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 10 6 -1.</_>
+        <_>
+          5 14 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 10 3 4 -1.</_>
+        <_>
+          4 10 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 9 2 2 -1.</_>
+        <_>
+          13 9 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 6 4 -1.</_>
+        <_>
+          7 3 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          10 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 2 3 -1.</_>
+        <_>
+          2 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 3 12 -1.</_>
+        <_>
+          9 12 3 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 4 6 -1.</_>
+        <_>
+          3 14 2 3 2.</_>
+        <_>
+          5 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 15 2 2 -1.</_>
+        <_>
+          16 16 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 15 2 2 -1.</_>
+        <_>
+          2 16 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 3 -1.</_>
+        <_>
+          8 13 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 20 1 -1.</_>
+        <_>
+          10 7 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 8 3 -1.</_>
+        <_>
+          7 6 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 8 2 -1.</_>
+        <_>
+          9 7 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 5 -1.</_>
+        <_>
+          10 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 5 -1.</_>
+        <_>
+          9 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 1 3 5 -1.</_>
+        <_>
+          12 1 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 2 3 6 -1.</_>
+        <_>
+          7 2 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 14 6 5 -1.</_>
+        <_>
+          14 14 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 2 -1.</_>
+        <_>
+          9 9 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 1 3 -1.</_>
+        <_>
+          10 8 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 2 2 -1.</_>
+        <_>
+          6 6 1 1 2.</_>
+        <_>
+          7 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 18 4 -1.</_>
+        <_>
+          11 11 9 2 2.</_>
+        <_>
+          2 13 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 2 2 -1.</_>
+        <_>
+          6 6 1 1 2.</_>
+        <_>
+          7 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 20 2 -1.</_>
+        <_>
+          0 16 20 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 2 3 -1.</_>
+        <_>
+          4 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 2 3 -1.</_>
+        <_>
+          8 8 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 10 2 3 -1.</_>
+        <_>
+          9 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 10 4 -1.</_>
+        <_>
+          5 6 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 6 4 -1.</_>
+        <_>
+          12 7 3 2 2.</_>
+        <_>
+          9 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 3 6 -1.</_>
+        <_>
+          4 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 15 4 4 -1.</_>
+        <_>
+          13 15 2 2 2.</_>
+        <_>
+          11 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 4 2 -1.</_>
+        <_>
+          7 9 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 1 4 3 -1.</_>
+        <_>
+          13 1 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 15 4 4 -1.</_>
+        <_>
+          5 15 2 2 2.</_>
+        <_>
+          7 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 4 7 -1.</_>
+        <_>
+          9 5 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 8 3 -1.</_>
+        <_>
+          9 6 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 5 3 -1.</_>
+        <_>
+          7 16 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 4 3 -1.</_>
+        <_>
+          11 10 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 8 10 -1.</_>
+        <_>
+          6 14 8 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 6 2 -1.</_>
+        <_>
+          10 11 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 6 2 -1.</_>
+        <_>
+          7 11 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 8 1 -1.</_>
+        <_>
+          11 3 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 3 2 -1.</_>
+        <_>
+          7 3 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 5 6 5 -1.</_>
+        <_>
+          14 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 2 12 -1.</_>
+        <_>
+          7 11 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 3 -1.</_>
+        <_>
+          8 12 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 1 2 3 -1.</_>
+        <_>
+          5 1 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 3 2 6 -1.</_>
+        <_>
+          18 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 2 6 -1.</_>
+        <_>
+          0 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 3 -1.</_>
+        <_>
+          9 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 4 3 -1.</_>
+        <_>
+          7 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 0 2 6 -1.</_>
+        <_>
+          18 2 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 2 6 -1.</_>
+        <_>
+          0 2 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 6 3 -1.</_>
+        <_>
+          8 15 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 2 4 -1.</_>
+        <_>
+          8 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 5 4 6 -1.</_>
+        <_>
+          8 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 2 2 -1.</_>
+        <_>
+          7 4 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 14 4 -1.</_>
+        <_>
+          10 14 7 2 2.</_>
+        <_>
+          3 16 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 15 6 2 -1.</_>
+        <_>
+          6 15 3 1 2.</_>
+        <_>
+          9 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 15 6 2 -1.</_>
+        <_>
+          14 16 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 12 8 -1.</_>
+        <_>
+          2 16 12 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 7 2 -1.</_>
+        <_>
+          7 8 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 18 2 -1.</_>
+        <_>
+          0 3 18 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 5 -1.</_>
+        <_>
+          9 6 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 3 8 -1.</_>
+        <_>
+          8 5 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 3 4 -1.</_>
+        <_>
+          10 6 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 13 3 2 -1.</_>
+        <_>
+          4 14 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 6 3 -1.</_>
+        <_>
+          11 4 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 6 3 -1.</_>
+        <_>
+          7 4 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 11 5 2 -1.</_>
+        <_>
+          14 12 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 6 9 -1.</_>
+        <_>
+          3 2 2 9 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 6 13 -1.</_>
+        <_>
+          14 6 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 14 8 -1.</_>
+        <_>
+          3 6 7 4 2.</_>
+        <_>
+          10 10 7 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 11 -1.</_>
+        <_>
+          16 0 2 11 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 12 12 -1.</_>
+        <_>
+          3 4 6 6 2.</_>
+        <_>
+          9 10 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 5 3 -1.</_>
+        <_>
+          11 5 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 4 2 -1.</_>
+        <_>
+          4 12 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 2 2 -1.</_>
+        <_>
+          10 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 2 2 -1.</_>
+        <_>
+          9 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 2 -1.</_>
+        <_>
+          10 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 3 3 -1.</_>
+        <_>
+          5 7 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 3 3 -1.</_>
+        <_>
+          11 0 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 6 2 -1.</_>
+        <_>
+          5 6 3 1 2.</_>
+        <_>
+          8 7 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 16 4 3 -1.</_>
+        <_>
+          12 17 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 3 2 -1.</_>
+        <_>
+          3 13 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 3 2 -1.</_>
+        <_>
+          9 13 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 16 4 -1.</_>
+        <_>
+          1 11 8 2 2.</_>
+        <_>
+          9 13 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 5 3 -1.</_>
+        <_>
+          4 5 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 16 4 3 -1.</_>
+        <_>
+          12 17 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 2 2 -1.</_>
+        <_>
+          9 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 4 2 -1.</_>
+        <_>
+          8 10 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 4 3 -1.</_>
+        <_>
+          8 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 6 3 -1.</_>
+        <_>
+          2 13 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 14 3 2 -1.</_>
+        <_>
+          16 15 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 18 18 2 -1.</_>
+        <_>
+          7 18 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 14 3 2 -1.</_>
+        <_>
+          16 15 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 3 2 -1.</_>
+        <_>
+          1 15 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 6 3 -1.</_>
+        <_>
+          7 15 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 14 8 3 -1.</_>
+        <_>
+          5 15 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 4 14 -1.</_>
+        <_>
+          10 6 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 4 14 -1.</_>
+        <_>
+          8 6 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 3 -1.</_>
+        <_>
+          13 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 16 6 1 -1.</_>
+        <_>
+          9 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 3 3 -1.</_>
+        <_>
+          9 13 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 3 3 -1.</_>
+        <_>
+          8 0 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 16 18 -1.</_>
+        <_>
+          4 9 16 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 16 14 -1.</_>
+        <_>
+          1 8 16 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 9 15 4 -1.</_>
+        <_>
+          8 9 5 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 7 3 -1.</_>
+        <_>
+          6 13 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 15 2 3 -1.</_>
+        <_>
+          14 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 16 14 -1.</_>
+        <_>
+          2 3 8 7 2.</_>
+        <_>
+          10 10 8 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 2 4 18 -1.</_>
+        <_>
+          18 2 2 9 2.</_>
+        <_>
+          16 11 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 15 2 3 -1.</_>
+        <_>
+          4 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 2 4 18 -1.</_>
+        <_>
+          18 2 2 9 2.</_>
+        <_>
+          16 11 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 8 3 -1.</_>
+        <_>
+          1 2 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 3 -1.</_>
+        <_>
+          8 12 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 5 9 -1.</_>
+        <_>
+          5 14 5 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 11 -1.</_>
+        <_>
+          16 0 2 11 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 1 -1.</_>
+        <_>
+          9 0 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 7 -1.</_>
+        <_>
+          17 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 3 3 7 -1.</_>
+        <_>
+          2 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 6 12 -1.</_>
+        <_>
+          7 12 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 4 11 -1.</_>
+        <_>
+          2 0 2 11 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 20 -1.</_>
+        <_>
+          14 0 3 20 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 1 2 -1.</_>
+        <_>
+          0 4 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 10 8 -1.</_>
+        <_>
+          10 5 5 4 2.</_>
+        <_>
+          5 9 5 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 12 4 -1.</_>
+        <_>
+          4 7 6 2 2.</_>
+        <_>
+          10 9 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 6 4 -1.</_>
+        <_>
+          5 1 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 6 4 -1.</_>
+        <_>
+          12 7 3 2 2.</_>
+        <_>
+          9 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 2 6 -1.</_>
+        <_>
+          5 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 6 4 -1.</_>
+        <_>
+          12 16 3 2 2.</_>
+        <_>
+          9 18 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 12 -1.</_>
+        <_>
+          9 10 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 18 -1.</_>
+        <_>
+          9 1 2 18 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 12 2 -1.</_>
+        <_>
+          8 12 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 6 2 -1.</_>
+        <_>
+          8 9 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 3 6 -1.</_>
+        <_>
+          9 0 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 18 3 2 -1.</_>
+        <_>
+          11 19 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 17 4 -1.</_>
+        <_>
+          1 3 17 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 8 4 12 -1.</_>
+        <_>
+          11 8 2 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 2 17 -1.</_>
+        <_>
+          12 3 1 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 6 1 -1.</_>
+        <_>
+          6 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 3 2 3 -1.</_>
+        <_>
+          18 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 4 3 4 -1.</_>
+        <_>
+          8 6 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 10 -1.</_>
+        <_>
+          4 10 12 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 18 4 2 -1.</_>
+        <_>
+          7 18 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 2 3 6 -1.</_>
+        <_>
+          17 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 6 -1.</_>
+        <_>
+          9 7 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 2 3 6 -1.</_>
+        <_>
+          17 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 3 4 -1.</_>
+        <_>
+          9 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 12 6 3 -1.</_>
+        <_>
+          0 13 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 2 3 -1.</_>
+        <_>
+          3 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 12 7 -1.</_>
+        <_>
+          9 6 4 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 6 -1.</_>
+        <_>
+          0 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 1 3 -1.</_>
+        <_>
+          14 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 3 14 -1.</_>
+        <_>
+          3 0 1 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 14 5 6 -1.</_>
+        <_>
+          12 16 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 5 6 -1.</_>
+        <_>
+          4 16 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 2 2 -1.</_>
+        <_>
+          12 10 1 1 2.</_>
+        <_>
+          11 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 3 14 -1.</_>
+        <_>
+          6 0 1 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 15 2 3 -1.</_>
+        <_>
+          10 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 2 3 -1.</_>
+        <_>
+          0 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 12 6 -1.</_>
+        <_>
+          5 14 12 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 3 9 -1.</_>
+        <_>
+          6 14 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 2 2 -1.</_>
+        <_>
+          12 10 1 1 2.</_>
+        <_>
+          11 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 1 3 -1.</_>
+        <_>
+          5 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 13 3 -1.</_>
+        <_>
+          4 10 13 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 15 6 -1.</_>
+        <_>
+          6 7 5 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 6 -1.</_>
+        <_>
+          8 5 4 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 4 3 -1.</_>
+        <_>
+          8 11 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 14 1 3 -1.</_>
+        <_>
+          15 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 5 3 -1.</_>
+        <_>
+          1 12 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 7 12 -1.</_>
+        <_>
+          7 7 7 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 6 10 -1.</_>
+        <_>
+          0 1 3 5 2.</_>
+        <_>
+          3 6 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 1 4 3 -1.</_>
+        <_>
+          16 2 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 3 -1.</_>
+        <_>
+          5 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 3 5 -1.</_>
+        <_>
+          13 2 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 4 6 -1.</_>
+        <_>
+          0 5 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          8 13 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 18 3 1 -1.</_>
+        <_>
+          9 18 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 2 2 -1.</_>
+        <_>
+          12 10 1 1 2.</_>
+        <_>
+          11 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 10 2 2 -1.</_>
+        <_>
+          7 10 1 1 2.</_>
+        <_>
+          8 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 4 4 -1.</_>
+        <_>
+          11 13 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 3 8 -1.</_>
+        <_>
+          9 12 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 6 3 -1.</_>
+        <_>
+          13 1 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 3 4 -1.</_>
+        <_>
+          9 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 10 -1.</_>
+        <_>
+          10 7 5 5 2.</_>
+        <_>
+          5 12 5 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 18 8 2 -1.</_>
+        <_>
+          3 18 4 1 2.</_>
+        <_>
+          7 19 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 2 6 8 -1.</_>
+        <_>
+          12 2 2 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 6 8 -1.</_>
+        <_>
+          6 2 2 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 7 -1.</_>
+        <_>
+          12 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 2 1 -1.</_>
+        <_>
+          8 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 14 1 3 -1.</_>
+        <_>
+          15 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 2 2 -1.</_>
+        <_>
+          7 15 1 1 2.</_>
+        <_>
+          8 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 14 1 3 -1.</_>
+        <_>
+          15 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 7 -1.</_>
+        <_>
+          7 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 7 -1.</_>
+        <_>
+          18 1 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 8 20 -1.</_>
+        <_>
+          2 10 8 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 15 6 -1.</_>
+        <_>
+          3 2 15 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 12 2 -1.</_>
+        <_>
+          4 4 12 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 5 -1.</_>
+        <_>
+          16 0 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 3 4 -1.</_>
+        <_>
+          8 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 5 -1.</_>
+        <_>
+          16 0 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 6 13 -1.</_>
+        <_>
+          3 7 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 5 -1.</_>
+        <_>
+          16 0 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 4 5 -1.</_>
+        <_>
+          2 0 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 3 6 -1.</_>
+        <_>
+          14 14 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 3 6 -1.</_>
+        <_>
+          3 14 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 1 4 3 -1.</_>
+        <_>
+          16 2 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 2 10 -1.</_>
+        <_>
+          8 7 1 5 2.</_>
+        <_>
+          9 12 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 4 4 -1.</_>
+        <_>
+          11 13 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 4 3 -1.</_>
+        <_>
+          0 2 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 1 3 -1.</_>
+        <_>
+          13 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 3 5 -1.</_>
+        <_>
+          8 15 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 5 -1.</_>
+        <_>
+          10 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 5 -1.</_>
+        <_>
+          9 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 4 14 -1.</_>
+        <_>
+          10 6 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 5 6 -1.</_>
+        <_>
+          0 7 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 4 -1.</_>
+        <_>
+          9 5 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 18 10 -1.</_>
+        <_>
+          6 0 6 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 4 14 -1.</_>
+        <_>
+          10 6 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 4 14 -1.</_>
+        <_>
+          8 6 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 1 3 -1.</_>
+        <_>
+          13 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 2 3 -1.</_>
+        <_>
+          6 1 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 18 -1.</_>
+        <_>
+          19 1 1 9 2.</_>
+        <_>
+          18 10 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 4 3 -1.</_>
+        <_>
+          2 2 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 18 -1.</_>
+        <_>
+          19 1 1 9 2.</_>
+        <_>
+          18 10 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 4 6 -1.</_>
+        <_>
+          1 14 2 3 2.</_>
+        <_>
+          3 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 7 6 -1.</_>
+        <_>
+          10 13 7 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 6 10 -1.</_>
+        <_>
+          0 10 3 5 2.</_>
+        <_>
+          3 15 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 4 -1.</_>
+        <_>
+          12 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 5 6 -1.</_>
+        <_>
+          5 13 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 1 8 -1.</_>
+        <_>
+          14 10 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 18 6 -1.</_>
+        <_>
+          1 7 9 3 2.</_>
+        <_>
+          10 10 9 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 2 -1.</_>
+        <_>
+          9 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 4 5 -1.</_>
+        <_>
+          7 9 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 3 -1.</_>
+        <_>
+          9 6 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 4 -1.</_>
+        <_>
+          7 0 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 2 4 -1.</_>
+        <_>
+          7 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 19 9 -1.</_>
+        <_>
+          1 3 19 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 3 6 -1.</_>
+        <_>
+          3 9 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 4 4 -1.</_>
+        <_>
+          15 7 2 2 2.</_>
+        <_>
+          13 9 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 4 4 -1.</_>
+        <_>
+          3 7 2 2 2.</_>
+        <_>
+          5 9 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 10 8 -1.</_>
+        <_>
+          9 10 10 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 8 14 12 -1.</_>
+        <_>
+          3 14 14 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 10 12 -1.</_>
+        <_>
+          11 5 5 6 2.</_>
+        <_>
+          6 11 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 5 -1.</_>
+        <_>
+          9 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 4 -1.</_>
+        <_>
+          9 6 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 5 -1.</_>
+        <_>
+          9 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 6 5 -1.</_>
+        <_>
+          8 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 6 1 -1.</_>
+        <_>
+          13 2 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 6 1 -1.</_>
+        <_>
+          5 2 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 3 -1.</_>
+        <_>
+          13 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 1 4 -1.</_>
+        <_>
+          0 12 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 3 -1.</_>
+        <_>
+          13 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 18 3 2 -1.</_>
+        <_>
+          9 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 15 9 2 -1.</_>
+        <_>
+          6 16 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 4 -1.</_>
+        <_>
+          18 6 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 3 -1.</_>
+        <_>
+          5 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 16 3 2 -1.</_>
+        <_>
+          15 17 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 3 9 -1.</_>
+        <_>
+          0 3 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          9 8 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          8 8 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 6 -1.</_>
+        <_>
+          9 5 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 3 4 -1.</_>
+        <_>
+          9 6 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 8 12 -1.</_>
+        <_>
+          11 6 4 6 2.</_>
+        <_>
+          7 12 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 8 12 -1.</_>
+        <_>
+          5 6 4 6 2.</_>
+        <_>
+          9 12 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 3 2 -1.</_>
+        <_>
+          2 17 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 6 6 -1.</_>
+        <_>
+          2 14 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 3 -1.</_>
+        <_>
+          7 14 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 14 6 3 -1.</_>
+        <_>
+          6 15 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 15 5 3 -1.</_>
+        <_>
+          14 16 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 15 5 3 -1.</_>
+        <_>
+          14 16 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 6 2 -1.</_>
+        <_>
+          7 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 15 5 3 -1.</_>
+        <_>
+          1 16 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 6 -1.</_>
+        <_>
+          10 13 2 3 2.</_>
+        <_>
+          8 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 3 3 -1.</_>
+        <_>
+          8 8 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 5 4 -1.</_>
+        <_>
+          12 2 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 20 2 -1.</_>
+        <_>
+          0 2 10 1 2.</_>
+        <_>
+          10 3 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 4 -1.</_>
+        <_>
+          7 0 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 6 1 -1.</_>
+        <_>
+          6 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 18 13 2 -1.</_>
+        <_>
+          4 19 13 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 10 3 6 -1.</_>
+        <_>
+          2 12 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 6 8 -1.</_>
+        <_>
+          17 12 3 4 2.</_>
+        <_>
+          14 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 13 10 6 -1.</_>
+        <_>
+          4 13 5 3 2.</_>
+        <_>
+          9 16 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 1 2 -1.</_>
+        <_>
+          14 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 3 -1.</_>
+        <_>
+          8 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 2 2 -1.</_>
+        <_>
+          14 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 2 -1.</_>
+        <_>
+          4 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 9 2 -1.</_>
+        <_>
+          8 13 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 3 6 -1.</_>
+        <_>
+          11 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 9 12 -1.</_>
+        <_>
+          5 12 9 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 3 6 -1.</_>
+        <_>
+          11 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 3 6 -1.</_>
+        <_>
+          6 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 11 3 -1.</_>
+        <_>
+          5 5 11 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 5 10 -1.</_>
+        <_>
+          7 6 5 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 18 2 -1.</_>
+        <_>
+          2 9 18 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 17 5 3 -1.</_>
+        <_>
+          7 18 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 12 1 -1.</_>
+        <_>
+          9 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 6 6 -1.</_>
+        <_>
+          0 14 3 3 2.</_>
+        <_>
+          3 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 12 1 -1.</_>
+        <_>
+          9 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 9 12 1 -1.</_>
+        <_>
+          7 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 10 6 7 -1.</_>
+        <_>
+          14 10 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 16 2 -1.</_>
+        <_>
+          1 1 16 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 9 10 9 -1.</_>
+        <_>
+          10 12 10 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 10 2 -1.</_>
+        <_>
+          5 1 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 3 2 3 -1.</_>
+        <_>
+          17 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 3 2 3 -1.</_>
+        <_>
+          1 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 6 -1.</_>
+        <_>
+          10 7 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 4 3 -1.</_>
+        <_>
+          8 5 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 6 -1.</_>
+        <_>
+          9 5 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 12 12 -1.</_>
+        <_>
+          3 4 6 6 2.</_>
+        <_>
+          9 10 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 2 6 15 -1.</_>
+        <_>
+          11 2 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 6 17 -1.</_>
+        <_>
+          4 2 2 17 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 10 6 7 -1.</_>
+        <_>
+          14 10 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 6 7 -1.</_>
+        <_>
+          3 10 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 2 6 15 -1.</_>
+        <_>
+          11 2 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 6 15 -1.</_>
+        <_>
+          7 2 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 9 3 6 -1.</_>
+        <_>
+          17 11 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 6 6 -1.</_>
+        <_>
+          8 7 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 18 6 -1.</_>
+        <_>
+          10 10 9 3 2.</_>
+        <_>
+          1 13 9 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 10 9 -1.</_>
+        <_>
+          0 12 10 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 3 4 -1.</_>
+        <_>
+          5 14 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 3 16 12 -1.</_>
+        <_>
+          3 9 16 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 12 12 -1.</_>
+        <_>
+          1 1 6 6 2.</_>
+        <_>
+          7 7 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 4 2 4 -1.</_>
+        <_>
+          11 4 1 2 2.</_>
+        <_>
+          10 6 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 10 2 -1.</_>
+        <_>
+          0 9 5 1 2.</_>
+        <_>
+          5 10 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 3 3 -1.</_>
+        <_>
+          9 12 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 9 2 -1.</_>
+        <_>
+          3 13 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 13 6 -1.</_>
+        <_>
+          3 6 13 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 6 4 -1.</_>
+        <_>
+          12 7 3 2 2.</_>
+        <_>
+          9 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 6 8 -1.</_>
+        <_>
+          4 0 3 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 12 -1.</_>
+        <_>
+          9 11 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 3 10 -1.</_>
+        <_>
+          4 9 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 17 8 3 -1.</_>
+        <_>
+          6 18 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 10 6 -1.</_>
+        <_>
+          0 7 10 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 3 2 -1.</_>
+        <_>
+          13 3 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 4 5 -1.</_>
+        <_>
+          9 5 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 14 3 6 -1.</_>
+        <_>
+          12 16 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 8 2 -1.</_>
+        <_>
+          1 12 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 3 -1.</_>
+        <_>
+          7 14 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 3 6 -1.</_>
+        <_>
+          0 7 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 3 2 -1.</_>
+        <_>
+          13 3 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 4 6 -1.</_>
+        <_>
+          4 14 2 3 2.</_>
+        <_>
+          6 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 3 2 -1.</_>
+        <_>
+          13 3 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 4 12 -1.</_>
+        <_>
+          8 6 4 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 8 -1.</_>
+        <_>
+          17 0 3 4 2.</_>
+        <_>
+          14 4 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 17 3 2 -1.</_>
+        <_>
+          8 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          8 13 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 12 -1.</_>
+        <_>
+          6 0 4 6 2.</_>
+        <_>
+          10 6 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 2 10 -1.</_>
+        <_>
+          15 0 1 5 2.</_>
+        <_>
+          14 5 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 8 6 -1.</_>
+        <_>
+          5 3 4 3 2.</_>
+        <_>
+          9 6 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 10 -1.</_>
+        <_>
+          17 0 3 5 2.</_>
+        <_>
+          14 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 1 2 -1.</_>
+        <_>
+          9 15 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 10 4 3 -1.</_>
+        <_>
+          15 11 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 2 3 -1.</_>
+        <_>
+          8 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 14 4 -1.</_>
+        <_>
+          10 13 7 2 2.</_>
+        <_>
+          3 15 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 4 3 -1.</_>
+        <_>
+          1 11 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 6 1 -1.</_>
+        <_>
+          11 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 6 1 -1.</_>
+        <_>
+          7 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 5 16 15 -1.</_>
+        <_>
+          3 10 16 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 4 2 -1.</_>
+        <_>
+          8 12 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 12 10 -1.</_>
+        <_>
+          10 4 6 5 2.</_>
+        <_>
+          4 9 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 3 4 -1.</_>
+        <_>
+          9 6 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 8 -1.</_>
+        <_>
+          10 12 2 4 2.</_>
+        <_>
+          8 16 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 3 2 -1.</_>
+        <_>
+          13 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 3 2 -1.</_>
+        <_>
+          8 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 9 14 -1.</_>
+        <_>
+          9 0 3 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 3 -1.</_>
+        <_>
+          10 6 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 2 3 -1.</_>
+        <_>
+          10 9 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 4 6 -1.</_>
+        <_>
+          0 11 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 2 -1.</_>
+        <_>
+          6 1 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 14 7 3 -1.</_>
+        <_>
+          6 15 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 8 9 -1.</_>
+        <_>
+          8 13 8 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 3 2 -1.</_>
+        <_>
+          6 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 1 6 8 -1.</_>
+        <_>
+          17 1 3 4 2.</_>
+        <_>
+          14 5 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 6 8 -1.</_>
+        <_>
+          0 1 3 4 2.</_>
+        <_>
+          3 5 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 18 6 -1.</_>
+        <_>
+          10 2 9 3 2.</_>
+        <_>
+          1 5 9 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 2 1 -1.</_>
+        <_>
+          10 3 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 4 6 -1.</_>
+        <_>
+          15 2 2 3 2.</_>
+        <_>
+          13 5 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 1 3 -1.</_>
+        <_>
+          13 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 5 3 -1.</_>
+        <_>
+          2 17 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 4 6 -1.</_>
+        <_>
+          15 2 2 3 2.</_>
+        <_>
+          13 5 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 4 6 -1.</_>
+        <_>
+          3 2 2 3 2.</_>
+        <_>
+          5 5 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 1 2 -1.</_>
+        <_>
+          13 6 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 2 -1.</_>
+        <_>
+          5 6 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 9 2 2 -1.</_>
+        <_>
+          13 9 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 2 2 -1.</_>
+        <_>
+          6 9 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 17 3 2 -1.</_>
+        <_>
+          13 18 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 16 4 4 -1.</_>
+        <_>
+          6 16 2 2 2.</_>
+        <_>
+          8 18 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 2 3 -1.</_>
+        <_>
+          9 17 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 9 6 -1.</_>
+        <_>
+          0 15 9 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 6 -1.</_>
+        <_>
+          9 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 2 3 -1.</_>
+        <_>
+          9 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 18 6 -1.</_>
+        <_>
+          1 12 18 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 2 -1.</_>
+        <_>
+          8 12 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 9 6 2 -1.</_>
+        <_>
+          7 10 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 2 3 -1.</_>
+        <_>
+          8 9 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 5 3 4 -1.</_>
+        <_>
+          18 5 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 19 18 1 -1.</_>
+        <_>
+          7 19 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 3 2 -1.</_>
+        <_>
+          10 0 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 1 6 -1.</_>
+        <_>
+          1 10 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 17 8 3 -1.</_>
+        <_>
+          12 17 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 3 4 -1.</_>
+        <_>
+          1 5 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 3 -1.</_>
+        <_>
+          9 8 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 2 2 -1.</_>
+        <_>
+          7 11 1 1 2.</_>
+        <_>
+          8 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 2 5 -1.</_>
+        <_>
+          11 3 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 2 5 -1.</_>
+        <_>
+          8 3 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 3 -1.</_>
+        <_>
+          15 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 2 3 -1.</_>
+        <_>
+          5 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 19 15 1 -1.</_>
+        <_>
+          9 19 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 19 15 1 -1.</_>
+        <_>
+          6 19 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 3 -1.</_>
+        <_>
+          15 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 4 15 -1.</_>
+        <_>
+          7 0 2 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 5 -1.</_>
+        <_>
+          9 6 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 7 -1.</_>
+        <_>
+          10 5 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 11 3 3 -1.</_>
+        <_>
+          16 12 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 3 3 -1.</_>
+        <_>
+          1 12 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 8 3 -1.</_>
+        <_>
+          6 7 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 6 2 -1.</_>
+        <_>
+          0 16 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 6 -1.</_>
+        <_>
+          7 0 6 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 4 -1.</_>
+        <_>
+          7 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 10 4 10 -1.</_>
+        <_>
+          16 10 2 5 2.</_>
+        <_>
+          14 15 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 3 2 -1.</_>
+        <_>
+          4 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 2 2 -1.</_>
+        <_>
+          11 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 10 4 10 -1.</_>
+        <_>
+          2 10 2 5 2.</_>
+        <_>
+          4 15 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 20 6 -1.</_>
+        <_>
+          10 13 10 3 2.</_>
+        <_>
+          0 16 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 2 15 -1.</_>
+        <_>
+          1 5 1 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 18 4 -1.</_>
+        <_>
+          10 7 9 2 2.</_>
+        <_>
+          1 9 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 2 17 -1.</_>
+        <_>
+          1 0 1 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 6 16 6 -1.</_>
+        <_>
+          10 6 8 3 2.</_>
+        <_>
+          2 9 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 1 3 -1.</_>
+        <_>
+          8 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 2 -1.</_>
+        <_>
+          8 16 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 8 2 -1.</_>
+        <_>
+          5 2 4 1 2.</_>
+        <_>
+          9 3 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 8 6 -1.</_>
+        <_>
+          6 14 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 2 2 -1.</_>
+        <_>
+          9 14 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 6 -1.</_>
+        <_>
+          18 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 2 -1.</_>
+        <_>
+          9 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 6 -1.</_>
+        <_>
+          18 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 1 3 -1.</_>
+        <_>
+          9 14 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 6 -1.</_>
+        <_>
+          18 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 2 6 -1.</_>
+        <_>
+          0 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 3 3 -1.</_>
+        <_>
+          9 13 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 2 3 -1.</_>
+        <_>
+          3 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 13 4 3 -1.</_>
+        <_>
+          13 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 10 6 -1.</_>
+        <_>
+          5 4 10 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 4 3 -1.</_>
+        <_>
+          3 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 15 5 -1.</_>
+        <_>
+          8 7 5 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 12 2 -1.</_>
+        <_>
+          7 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 3 9 -1.</_>
+        <_>
+          11 3 1 9 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 4 6 -1.</_>
+        <_>
+          10 6 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 4 3 -1.</_>
+        <_>
+          9 8 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 4 9 -1.</_>
+        <_>
+          2 9 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 3 5 -1.</_>
+        <_>
+          10 13 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 3 -1.</_>
+        <_>
+          9 7 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 5 -1.</_>
+        <_>
+          10 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 8 2 -1.</_>
+        <_>
+          9 7 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 12 2 -1.</_>
+        <_>
+          9 9 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 10 3 -1.</_>
+        <_>
+          10 6 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 3 1 -1.</_>
+        <_>
+          11 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 11 15 -1.</_>
+        <_>
+          0 6 11 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 6 -1.</_>
+        <_>
+          7 0 6 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 1 -1.</_>
+        <_>
+          9 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 16 6 4 -1.</_>
+        <_>
+          5 16 3 2 2.</_>
+        <_>
+          8 18 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 9 8 -1.</_>
+        <_>
+          6 9 9 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 2 6 -1.</_>
+        <_>
+          5 13 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 8 10 -1.</_>
+        <_>
+          11 6 4 5 2.</_>
+        <_>
+          7 11 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 8 10 -1.</_>
+        <_>
+          5 6 4 5 2.</_>
+        <_>
+          9 11 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 2 -1.</_>
+        <_>
+          9 6 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 8 2 -1.</_>
+        <_>
+          5 13 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 2 8 2 -1.</_>
+        <_>
+          10 3 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 2 10 -1.</_>
+        <_>
+          4 0 1 5 2.</_>
+        <_>
+          5 5 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 10 2 2 -1.</_>
+        <_>
+          9 11 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 15 3 -1.</_>
+        <_>
+          2 9 15 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 3 -1.</_>
+        <_>
+          8 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 3 2 -1.</_>
+        <_>
+          8 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 3 -1.</_>
+        <_>
+          7 14 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 2 3 6 -1.</_>
+        <_>
+          17 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 5 3 4 -1.</_>
+        <_>
+          2 5 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 8 4 6 -1.</_>
+        <_>
+          14 10 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 3 8 -1.</_>
+        <_>
+          2 4 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 6 -1.</_>
+        <_>
+          8 16 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 2 2 -1.</_>
+        <_>
+          3 15 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 8 4 6 -1.</_>
+        <_>
+          14 10 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 4 6 -1.</_>
+        <_>
+          2 10 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 1 6 -1.</_>
+        <_>
+          10 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 3 6 -1.</_>
+        <_>
+          8 5 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 2 6 -1.</_>
+        <_>
+          12 2 1 3 2.</_>
+        <_>
+          11 5 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 6 5 -1.</_>
+        <_>
+          8 6 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 1 3 6 -1.</_>
+        <_>
+          17 3 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 5 -1.</_>
+        <_>
+          9 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 18 3 2 -1.</_>
+        <_>
+          10 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 18 3 2 -1.</_>
+        <_>
+          9 18 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 5 2 -1.</_>
+        <_>
+          12 4 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 5 12 -1.</_>
+        <_>
+          7 7 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 4 -1.</_>
+        <_>
+          7 0 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 2 2 -1.</_>
+        <_>
+          4 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 14 4 2 -1.</_>
+        <_>
+          13 14 2 1 2.</_>
+        <_>
+          11 15 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 6 -1.</_>
+        <_>
+          0 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 3 -1.</_>
+        <_>
+          9 8 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 1 3 -1.</_>
+        <_>
+          5 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 10 6 1 -1.</_>
+        <_>
+          10 10 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 10 6 1 -1.</_>
+        <_>
+          7 10 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 3 -1.</_>
+        <_>
+          9 18 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 1 3 -1.</_>
+        <_>
+          4 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 3 3 -1.</_>
+        <_>
+          12 6 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 3 -1.</_>
+        <_>
+          4 6 12 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 3 -1.</_>
+        <_>
+          9 9 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 3 3 -1.</_>
+        <_>
+          5 9 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 9 17 -1.</_>
+        <_>
+          9 0 3 17 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 1 3 -1.</_>
+        <_>
+          9 13 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 15 -1.</_>
+        <_>
+          9 10 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 2 3 -1.</_>
+        <_>
+          8 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 1 3 -1.</_>
+        <_>
+          10 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 5 -1.</_>
+        <_>
+          9 1 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 20 2 -1.</_>
+        <_>
+          0 0 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 13 5 3 -1.</_>
+        <_>
+          2 14 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 5 9 15 -1.</_>
+        <_>
+          2 10 9 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 12 10 -1.</_>
+        <_>
+          11 0 6 5 2.</_>
+        <_>
+          5 5 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 2 3 -1.</_>
+        <_>
+          6 1 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 6 1 -1.</_>
+        <_>
+          12 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 2 10 -1.</_>
+        <_>
+          3 1 1 5 2.</_>
+        <_>
+          4 6 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 2 1 -1.</_>
+        <_>
+          13 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 13 4 6 -1.</_>
+        <_>
+          4 15 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 2 1 -1.</_>
+        <_>
+          13 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 2 1 -1.</_>
+        <_>
+          6 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 18 4 -1.</_>
+        <_>
+          11 12 9 2 2.</_>
+        <_>
+          2 14 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 2 2 -1.</_>
+        <_>
+          5 7 1 1 2.</_>
+        <_>
+          6 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 4 2 -1.</_>
+        <_>
+          16 4 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 2 18 -1.</_>
+        <_>
+          0 2 1 9 2.</_>
+        <_>
+          1 11 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 18 4 -1.</_>
+        <_>
+          10 2 9 2 2.</_>
+        <_>
+          1 4 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 1 3 -1.</_>
+        <_>
+          9 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 18 4 -1.</_>
+        <_>
+          11 12 9 2 2.</_>
+        <_>
+          2 14 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 12 18 4 -1.</_>
+        <_>
+          0 12 9 2 2.</_>
+        <_>
+          9 14 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 5 3 -1.</_>
+        <_>
+          11 5 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 7 3 -1.</_>
+        <_>
+          6 5 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 17 3 3 -1.</_>
+        <_>
+          13 18 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 3 4 -1.</_>
+        <_>
+          9 1 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 2 4 -1.</_>
+        <_>
+          11 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 17 9 3 -1.</_>
+        <_>
+          3 17 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 2 8 -1.</_>
+        <_>
+          12 0 1 4 2.</_>
+        <_>
+          11 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 6 12 -1.</_>
+        <_>
+          0 8 3 6 2.</_>
+        <_>
+          3 14 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 4 12 -1.</_>
+        <_>
+          10 13 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 8 14 -1.</_>
+        <_>
+          5 10 8 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 10 6 1 -1.</_>
+        <_>
+          14 10 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 10 4 -1.</_>
+        <_>
+          0 6 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 5 8 -1.</_>
+        <_>
+          10 4 5 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 4 8 -1.</_>
+        <_>
+          8 1 2 4 2.</_>
+        <_>
+          10 5 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 6 1 -1.</_>
+        <_>
+          11 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 3 4 -1.</_>
+        <_>
+          9 9 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 6 -1.</_>
+        <_>
+          18 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 3 4 -1.</_>
+        <_>
+          9 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 13 3 -1.</_>
+        <_>
+          7 2 13 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 1 -1.</_>
+        <_>
+          9 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 11 3 6 -1.</_>
+        <_>
+          12 13 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 6 1 -1.</_>
+        <_>
+          7 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 18 10 -1.</_>
+        <_>
+          10 4 9 5 2.</_>
+        <_>
+          1 9 9 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 4 9 -1.</_>
+        <_>
+          8 9 4 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 4 3 -1.</_>
+        <_>
+          8 7 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          9 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 15 4 3 -1.</_>
+        <_>
+          14 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 3 10 -1.</_>
+        <_>
+          6 10 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 1 6 -1.</_>
+        <_>
+          0 10 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 15 1 3 -1.</_>
+        <_>
+          10 16 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 15 4 3 -1.</_>
+        <_>
+          2 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 3 2 8 -1.</_>
+        <_>
+          19 3 1 4 2.</_>
+        <_>
+          18 7 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 2 8 -1.</_>
+        <_>
+          0 3 1 4 2.</_>
+        <_>
+          1 7 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 14 10 -1.</_>
+        <_>
+          10 7 7 5 2.</_>
+        <_>
+          3 12 7 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 19 3 -1.</_>
+        <_>
+          0 8 19 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 6 3 3 -1.</_>
+        <_>
+          12 7 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 1 3 -1.</_>
+        <_>
+          0 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 6 3 3 -1.</_>
+        <_>
+          12 7 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 3 3 -1.</_>
+        <_>
+          5 7 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 4 2 -1.</_>
+        <_>
+          8 3 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 4 12 -1.</_>
+        <_>
+          8 3 2 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 6 2 3 -1.</_>
+        <_>
+          13 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 20 4 -1.</_>
+        <_>
+          0 12 20 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 17 14 -1.</_>
+        <_>
+          2 7 17 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 6 10 -1.</_>
+        <_>
+          0 0 3 5 2.</_>
+        <_>
+          3 5 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 6 4 -1.</_>
+        <_>
+          14 6 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 6 4 -1.</_>
+        <_>
+          3 6 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 7 2 -1.</_>
+        <_>
+          13 3 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 7 2 -1.</_>
+        <_>
+          0 3 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 14 2 -1.</_>
+        <_>
+          13 11 7 1 2.</_>
+        <_>
+          6 12 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 5 2 2 -1.</_>
+        <_>
+          8 5 1 1 2.</_>
+        <_>
+          9 6 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 9 2 3 -1.</_>
+        <_>
+          13 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 3 12 -1.</_>
+        <_>
+          2 1 1 12 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 4 1 3 -1.</_>
+        <_>
+          17 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 4 1 3 -1.</_>
+        <_>
+          2 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 5 1 3 -1.</_>
+        <_>
+          14 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 16 2 3 -1.</_>
+        <_>
+          7 17 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 6 -1.</_>
+        <_>
+          10 13 2 3 2.</_>
+        <_>
+          8 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 1 3 -1.</_>
+        <_>
+          5 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 20 -1.</_>
+        <_>
+          16 0 2 20 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 2 6 -1.</_>
+        <_>
+          5 1 1 3 2.</_>
+        <_>
+          6 4 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 10 4 -1.</_>
+        <_>
+          5 6 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 2 4 12 -1.</_>
+        <_>
+          15 2 2 12 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 4 12 -1.</_>
+        <_>
+          7 12 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 5 1 8 -1.</_>
+        <_>
+          14 9 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 14 10 -1.</_>
+        <_>
+          1 4 7 5 2.</_>
+        <_>
+          8 9 7 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 6 6 14 -1.</_>
+        <_>
+          14 6 3 7 2.</_>
+        <_>
+          11 13 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 6 14 -1.</_>
+        <_>
+          3 6 3 7 2.</_>
+        <_>
+          6 13 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 15 2 -1.</_>
+        <_>
+          9 9 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 6 3 -1.</_>
+        <_>
+          7 15 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 3 14 4 -1.</_>
+        <_>
+          13 3 7 2 2.</_>
+        <_>
+          6 5 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 15 2 -1.</_>
+        <_>
+          6 9 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 8 9 -1.</_>
+        <_>
+          6 14 8 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 3 8 -1.</_>
+        <_>
+          8 4 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 2 6 -1.</_>
+        <_>
+          14 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 6 4 -1.</_>
+        <_>
+          5 7 3 2 2.</_>
+        <_>
+          8 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 18 19 -1.</_>
+        <_>
+          7 1 6 19 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 6 5 -1.</_>
+        <_>
+          4 2 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 17 6 2 -1.</_>
+        <_>
+          12 18 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 17 6 2 -1.</_>
+        <_>
+          2 18 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 3 3 6 -1.</_>
+        <_>
+          17 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 3 3 -1.</_>
+        <_>
+          8 18 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 13 2 6 -1.</_>
+        <_>
+          10 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 6 3 -1.</_>
+        <_>
+          7 14 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 3 3 6 -1.</_>
+        <_>
+          17 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 2 3 -1.</_>
+        <_>
+          8 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 6 2 -1.</_>
+        <_>
+          11 3 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 3 6 -1.</_>
+        <_>
+          0 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 5 4 6 -1.</_>
+        <_>
+          8 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 3 2 -1.</_>
+        <_>
+          5 6 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 1 3 4 -1.</_>
+        <_>
+          11 1 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 5 9 -1.</_>
+        <_>
+          1 5 5 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 6 2 3 -1.</_>
+        <_>
+          13 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 14 3 -1.</_>
+        <_>
+          7 6 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 18 8 -1.</_>
+        <_>
+          2 15 18 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 2 3 -1.</_>
+        <_>
+          5 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 4 2 -1.</_>
+        <_>
+          12 6 2 1 2.</_>
+        <_>
+          10 7 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 4 2 -1.</_>
+        <_>
+          6 6 2 1 2.</_>
+        <_>
+          8 7 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 1 3 4 -1.</_>
+        <_>
+          11 1 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 2 7 -1.</_>
+        <_>
+          8 1 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 15 14 -1.</_>
+        <_>
+          4 9 15 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 2 -1.</_>
+        <_>
+          9 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 18 4 -1.</_>
+        <_>
+          11 3 9 2 2.</_>
+        <_>
+          2 5 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 2 -1.</_>
+        <_>
+          10 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 9 2 3 -1.</_>
+        <_>
+          13 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 6 2 -1.</_>
+        <_>
+          7 2 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 7 -1.</_>
+        <_>
+          9 5 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 2 3 -1.</_>
+        <_>
+          6 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 14 18 -1.</_>
+        <_>
+          6 9 14 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 6 3 -1.</_>
+        <_>
+          2 17 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 6 -1.</_>
+        <_>
+          10 7 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 4 3 -1.</_>
+        <_>
+          7 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 6 3 -1.</_>
+        <_>
+          7 13 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 3 -1.</_>
+        <_>
+          9 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 6 2 -1.</_>
+        <_>
+          9 12 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 4 6 -1.</_>
+        <_>
+          5 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 12 7 2 -1.</_>
+        <_>
+          11 13 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 8 6 -1.</_>
+        <_>
+          6 10 4 3 2.</_>
+        <_>
+          10 13 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 3 4 -1.</_>
+        <_>
+          11 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 2 3 -1.</_>
+        <_>
+          9 17 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 3 1 9 -1.</_>
+        <_>
+          13 6 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 13 14 6 -1.</_>
+        <_>
+          1 15 14 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 6 1 6 -1.</_>
+        <_>
+          13 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 3 8 -1.</_>
+        <_>
+          1 4 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 0 2 18 -1.</_>
+        <_>
+          18 0 1 18 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 6 2 -1.</_>
+        <_>
+          2 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 8 6 -1.</_>
+        <_>
+          9 2 8 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 1 6 -1.</_>
+        <_>
+          6 9 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 8 6 3 -1.</_>
+        <_>
+          14 9 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 2 18 -1.</_>
+        <_>
+          1 0 1 18 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 18 18 2 -1.</_>
+        <_>
+          10 18 9 1 2.</_>
+        <_>
+          1 19 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 15 2 2 -1.</_>
+        <_>
+          3 16 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 5 3 -1.</_>
+        <_>
+          8 15 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 2 3 -1.</_>
+        <_>
+          8 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 3 3 -1.</_>
+        <_>
+          13 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 2 -1.</_>
+        <_>
+          9 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 5 5 2 -1.</_>
+        <_>
+          15 6 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 5 2 -1.</_>
+        <_>
+          0 6 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 14 1 6 -1.</_>
+        <_>
+          17 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 9 9 3 -1.</_>
+        <_>
+          5 9 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 3 3 -1.</_>
+        <_>
+          13 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 4 18 -1.</_>
+        <_>
+          2 0 2 18 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 6 1 3 -1.</_>
+        <_>
+          17 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 14 1 6 -1.</_>
+        <_>
+          2 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          19 8 1 2 -1.</_>
+        <_>
+          19 9 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 3 3 -1.</_>
+        <_>
+          6 3 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 2 3 -1.</_>
+        <_>
+          9 17 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 6 1 3 -1.</_>
+        <_>
+          2 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 8 2 -1.</_>
+        <_>
+          16 4 4 1 2.</_>
+        <_>
+          12 5 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 8 2 -1.</_>
+        <_>
+          0 4 4 1 2.</_>
+        <_>
+          4 5 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 18 4 -1.</_>
+        <_>
+          2 18 18 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 2 4 -1.</_>
+        <_>
+          7 17 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 14 3 -1.</_>
+        <_>
+          4 1 14 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 4 20 -1.</_>
+        <_>
+          2 0 2 20 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 4 8 -1.</_>
+        <_>
+          14 4 2 4 2.</_>
+        <_>
+          12 8 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 2 2 -1.</_>
+        <_>
+          6 7 1 1 2.</_>
+        <_>
+          7 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 2 3 -1.</_>
+        <_>
+          10 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 2 -1.</_>
+        <_>
+          8 8 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 6 12 -1.</_>
+        <_>
+          8 8 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 11 12 -1.</_>
+        <_>
+          4 4 11 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 9 6 11 -1.</_>
+        <_>
+          16 9 2 11 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 4 3 -1.</_>
+        <_>
+          0 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 10 2 3 -1.</_>
+        <_>
+          9 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 3 2 -1.</_>
+        <_>
+          5 12 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 3 3 -1.</_>
+        <_>
+          10 15 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 3 4 -1.</_>
+        <_>
+          9 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 3 3 -1.</_>
+        <_>
+          10 15 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 3 2 -1.</_>
+        <_>
+          8 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 10 16 4 -1.</_>
+        <_>
+          10 10 8 2 2.</_>
+        <_>
+          2 12 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 4 17 -1.</_>
+        <_>
+          4 3 2 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 7 -1.</_>
+        <_>
+          15 13 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 6 1 -1.</_>
+        <_>
+          5 2 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 12 4 -1.</_>
+        <_>
+          9 2 4 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 12 -1.</_>
+        <_>
+          6 0 4 6 2.</_>
+        <_>
+          10 6 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 2 2 -1.</_>
+        <_>
+          14 7 1 1 2.</_>
+        <_>
+          13 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 12 20 6 -1.</_>
+        <_>
+          0 14 20 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 7 2 3 -1.</_>
+        <_>
+          14 7 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 9 12 -1.</_>
+        <_>
+          3 8 3 12 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 16 2 -1.</_>
+        <_>
+          3 0 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 15 3 3 -1.</_>
+        <_>
+          6 16 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 6 3 -1.</_>
+        <_>
+          8 16 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 1 6 -1.</_>
+        <_>
+          0 12 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 9 4 3 -1.</_>
+        <_>
+          10 10 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 2 3 -1.</_>
+        <_>
+          9 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 1 -1.</_>
+        <_>
+          5 7 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 12 19 -1.</_>
+        <_>
+          10 0 6 19 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 20 6 -1.</_>
+        <_>
+          10 6 10 3 2.</_>
+        <_>
+          0 9 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 2 2 -1.</_>
+        <_>
+          3 6 1 1 2.</_>
+        <_>
+          4 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 6 2 2 -1.</_>
+        <_>
+          16 6 1 1 2.</_>
+        <_>
+          15 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 2 2 -1.</_>
+        <_>
+          3 6 1 1 2.</_>
+        <_>
+          4 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 4 1 12 -1.</_>
+        <_>
+          14 10 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 5 16 10 -1.</_>
+        <_>
+          2 5 8 5 2.</_>
+        <_>
+          10 10 8 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 2 -1.</_>
+        <_>
+          10 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 2 2 -1.</_>
+        <_>
+          1 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 15 5 -1.</_>
+        <_>
+          10 0 5 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 15 5 -1.</_>
+        <_>
+          5 0 5 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 2 17 -1.</_>
+        <_>
+          11 2 1 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 2 17 -1.</_>
+        <_>
+          8 2 1 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 2 9 -1.</_>
+        <_>
+          15 11 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 2 9 -1.</_>
+        <_>
+          4 11 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 16 14 4 -1.</_>
+        <_>
+          5 16 7 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 18 1 -1.</_>
+        <_>
+          7 4 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 7 6 4 -1.</_>
+        <_>
+          16 7 3 2 2.</_>
+        <_>
+          13 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 12 -1.</_>
+        <_>
+          9 12 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 1 6 6 -1.</_>
+        <_>
+          12 3 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 6 6 -1.</_>
+        <_>
+          5 2 3 3 2.</_>
+        <_>
+          8 5 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 6 4 -1.</_>
+        <_>
+          12 16 3 2 2.</_>
+        <_>
+          9 18 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 18 3 -1.</_>
+        <_>
+          7 2 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 9 10 -1.</_>
+        <_>
+          7 9 9 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 4 4 -1.</_>
+        <_>
+          7 9 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 3 6 -1.</_>
+        <_>
+          11 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 5 3 -1.</_>
+        <_>
+          7 12 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 6 6 -1.</_>
+        <_>
+          10 11 3 3 2.</_>
+        <_>
+          7 14 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 10 9 -1.</_>
+        <_>
+          0 3 10 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 1 6 -1.</_>
+        <_>
+          13 16 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 6 -1.</_>
+        <_>
+          0 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 14 1 6 -1.</_>
+        <_>
+          6 16 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 2 3 -1.</_>
+        <_>
+          9 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 3 3 -1.</_>
+        <_>
+          7 4 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 11 3 -1.</_>
+        <_>
+          9 1 11 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 20 3 -1.</_>
+        <_>
+          0 7 20 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 1 1 2 -1.</_>
+        <_>
+          10 2 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 6 -1.</_>
+        <_>
+          10 6 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 8 12 1 -1.</_>
+        <_>
+          9 8 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 8 12 1 -1.</_>
+        <_>
+          7 8 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 5 -1.</_>
+        <_>
+          10 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 9 6 2 -1.</_>
+        <_>
+          6 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 1 -1.</_>
+        <_>
+          9 0 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 10 2 1 -1.</_>
+        <_>
+          8 10 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 9 13 -1.</_>
+        <_>
+          9 4 3 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 8 4 2 -1.</_>
+        <_>
+          6 9 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 2 4 6 -1.</_>
+        <_>
+          16 2 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 17 6 3 -1.</_>
+        <_>
+          0 18 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 10 3 10 -1.</_>
+        <_>
+          10 15 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 5 -1.</_>
+        <_>
+          9 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 4 4 3 -1.</_>
+        <_>
+          10 4 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 4 3 8 -1.</_>
+        <_>
+          9 4 1 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 9 13 -1.</_>
+        <_>
+          9 6 3 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 12 -1.</_>
+        <_>
+          6 0 4 6 2.</_>
+        <_>
+          10 6 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 8 -1.</_>
+        <_>
+          16 2 2 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 6 -1.</_>
+        <_>
+          7 0 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 8 -1.</_>
+        <_>
+          16 2 2 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 6 6 -1.</_>
+        <_>
+          0 8 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 6 2 -1.</_>
+        <_>
+          12 12 3 1 2.</_>
+        <_>
+          9 13 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 3 2 -1.</_>
+        <_>
+          9 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 6 2 2 -1.</_>
+        <_>
+          12 6 1 1 2.</_>
+        <_>
+          11 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 18 2 -1.</_>
+        <_>
+          7 9 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 6 2 2 -1.</_>
+        <_>
+          12 6 1 1 2.</_>
+        <_>
+          11 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 12 8 -1.</_>
+        <_>
+          7 4 4 8 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 5 3 -1.</_>
+        <_>
+          13 12 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 10 2 3 -1.</_>
+        <_>
+          9 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 7 2 3 -1.</_>
+        <_>
+          14 7 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 1 3 -1.</_>
+        <_>
+          5 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 2 3 -1.</_>
+        <_>
+          13 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 2 3 -1.</_>
+        <_>
+          5 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 3 -1.</_>
+        <_>
+          9 9 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 2 2 -1.</_>
+        <_>
+          8 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 14 1 4 -1.</_>
+        <_>
+          15 16 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 2 2 -1.</_>
+        <_>
+          3 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 15 2 2 -1.</_>
+        <_>
+          13 15 1 1 2.</_>
+        <_>
+          12 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 2 2 -1.</_>
+        <_>
+          9 14 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 14 9 -1.</_>
+        <_>
+          4 14 14 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 4 3 -1.</_>
+        <_>
+          7 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 14 1 4 -1.</_>
+        <_>
+          15 16 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 1 4 -1.</_>
+        <_>
+          4 16 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 13 -1.</_>
+        <_>
+          16 0 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 1 2 12 -1.</_>
+        <_>
+          4 1 1 6 2.</_>
+        <_>
+          5 7 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 14 6 6 -1.</_>
+        <_>
+          14 14 3 3 2.</_>
+        <_>
+          11 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 6 6 -1.</_>
+        <_>
+          3 14 3 3 2.</_>
+        <_>
+          6 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 17 3 2 -1.</_>
+        <_>
+          14 18 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 17 3 2 -1.</_>
+        <_>
+          3 18 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 13 -1.</_>
+        <_>
+          16 0 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 6 13 -1.</_>
+        <_>
+          2 0 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 10 7 6 -1.</_>
+        <_>
+          10 12 7 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 15 2 2 -1.</_>
+        <_>
+          6 15 1 1 2.</_>
+        <_>
+          7 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 8 6 -1.</_>
+        <_>
+          10 11 4 3 2.</_>
+        <_>
+          6 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 2 2 -1.</_>
+        <_>
+          7 6 1 1 2.</_>
+        <_>
+          8 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 16 6 -1.</_>
+        <_>
+          10 2 8 3 2.</_>
+        <_>
+          2 5 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 7 3 10 -1.</_>
+        <_>
+          11 12 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 3 10 -1.</_>
+        <_>
+          6 12 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 3 2 -1.</_>
+        <_>
+          11 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          8 13 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 1 1 3 -1.</_>
+        <_>
+          10 2 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 4 18 -1.</_>
+        <_>
+          1 2 2 9 2.</_>
+        <_>
+          3 11 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 4 12 -1.</_>
+        <_>
+          12 10 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 1 6 -1.</_>
+        <_>
+          0 2 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 4 3 -1.</_>
+        <_>
+          8 8 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 3 2 -1.</_>
+        <_>
+          11 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 3 2 -1.</_>
+        <_>
+          8 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 6 1 -1.</_>
+        <_>
+          11 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 2 3 -1.</_>
+        <_>
+          9 7 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 8 6 -1.</_>
+        <_>
+          16 7 4 3 2.</_>
+        <_>
+          12 10 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 8 6 -1.</_>
+        <_>
+          0 7 4 3 2.</_>
+        <_>
+          4 10 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 2 2 10 -1.</_>
+        <_>
+          19 2 1 5 2.</_>
+        <_>
+          18 7 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 6 4 -1.</_>
+        <_>
+          3 2 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 6 1 -1.</_>
+        <_>
+          11 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 15 2 2 -1.</_>
+        <_>
+          7 15 1 1 2.</_>
+        <_>
+          8 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 13 1 6 -1.</_>
+        <_>
+          11 16 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 1 6 -1.</_>
+        <_>
+          8 16 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 2 1 -1.</_>
+        <_>
+          14 3 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 2 3 -1.</_>
+        <_>
+          8 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 15 7 4 -1.</_>
+        <_>
+          12 17 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 12 3 -1.</_>
+        <_>
+          4 15 12 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 3 2 -1.</_>
+        <_>
+          11 3 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 2 -1.</_>
+        <_>
+          4 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 4 6 -1.</_>
+        <_>
+          10 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 2 2 -1.</_>
+        <_>
+          7 13 1 1 2.</_>
+        <_>
+          8 14 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 14 4 -1.</_>
+        <_>
+          11 11 7 2 2.</_>
+        <_>
+          4 13 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 18 18 2 -1.</_>
+        <_>
+          7 18 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 18 2 2 -1.</_>
+        <_>
+          12 18 1 1 2.</_>
+        <_>
+          11 19 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 18 2 2 -1.</_>
+        <_>
+          7 18 1 1 2.</_>
+        <_>
+          8 19 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 18 8 2 -1.</_>
+        <_>
+          12 19 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 6 2 -1.</_>
+        <_>
+          7 15 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 8 -1.</_>
+        <_>
+          10 12 2 4 2.</_>
+        <_>
+          8 16 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 3 3 -1.</_>
+        <_>
+          4 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 10 6 2 -1.</_>
+        <_>
+          9 10 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 4 15 -1.</_>
+        <_>
+          7 0 2 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 12 14 -1.</_>
+        <_>
+          12 6 4 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 16 3 3 -1.</_>
+        <_>
+          5 17 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 12 19 -1.</_>
+        <_>
+          12 1 4 19 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 3 2 -1.</_>
+        <_>
+          3 1 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 4 5 -1.</_>
+        <_>
+          10 12 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 4 5 -1.</_>
+        <_>
+          8 12 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 2 2 -1.</_>
+        <_>
+          12 11 1 1 2.</_>
+        <_>
+          11 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 6 -1.</_>
+        <_>
+          0 4 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 2 2 -1.</_>
+        <_>
+          12 11 1 1 2.</_>
+        <_>
+          11 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 4 10 -1.</_>
+        <_>
+          7 11 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 2 2 -1.</_>
+        <_>
+          12 11 1 1 2.</_>
+        <_>
+          11 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 13 5 2 -1.</_>
+        <_>
+          2 14 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 2 2 -1.</_>
+        <_>
+          12 11 1 1 2.</_>
+        <_>
+          11 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 2 2 -1.</_>
+        <_>
+          7 11 1 1 2.</_>
+        <_>
+          8 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 13 3 3 -1.</_>
+        <_>
+          14 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 3 3 -1.</_>
+        <_>
+          3 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          8 8 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 3 3 -1.</_>
+        <_>
+          13 6 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 5 3 -1.</_>
+        <_>
+          0 10 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 3 3 -1.</_>
+        <_>
+          13 6 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 8 -1.</_>
+        <_>
+          9 12 1 4 2.</_>
+        <_>
+          10 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 7 2 2 -1.</_>
+        <_>
+          12 7 1 1 2.</_>
+        <_>
+          11 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 16 6 4 -1.</_>
+        <_>
+          3 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 2 3 -1.</_>
+        <_>
+          10 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 6 -1.</_>
+        <_>
+          9 7 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 15 8 4 -1.</_>
+        <_>
+          12 15 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 8 6 -1.</_>
+        <_>
+          4 14 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 0 3 2 -1.</_>
+        <_>
+          10 0 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 15 4 2 -1.</_>
+        <_>
+          6 15 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 3 13 -1.</_>
+        <_>
+          13 7 1 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 3 13 -1.</_>
+        <_>
+          6 7 1 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 3 9 -1.</_>
+        <_>
+          9 9 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 7 12 -1.</_>
+        <_>
+          4 10 7 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 12 2 2 -1.</_>
+        <_>
+          13 12 1 1 2.</_>
+        <_>
+          12 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 2 2 -1.</_>
+        <_>
+          6 12 1 1 2.</_>
+        <_>
+          7 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 4 2 -1.</_>
+        <_>
+          10 9 2 1 2.</_>
+        <_>
+          8 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 2 2 -1.</_>
+        <_>
+          3 6 1 1 2.</_>
+        <_>
+          4 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 6 3 2 -1.</_>
+        <_>
+          16 7 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 19 4 -1.</_>
+        <_>
+          0 9 19 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 2 10 1 -1.</_>
+        <_>
+          10 2 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 12 -1.</_>
+        <_>
+          9 10 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 18 4 1 -1.</_>
+        <_>
+          12 18 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 6 4 -1.</_>
+        <_>
+          1 7 3 2 2.</_>
+        <_>
+          4 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 6 13 -1.</_>
+        <_>
+          14 0 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 6 13 -1.</_>
+        <_>
+          4 0 2 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 5 8 8 -1.</_>
+        <_>
+          10 9 8 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 3 2 5 -1.</_>
+        <_>
+          9 3 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 4 9 1 -1.</_>
+        <_>
+          11 4 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 9 1 -1.</_>
+        <_>
+          6 4 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 10 -1.</_>
+        <_>
+          7 0 6 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 17 5 3 -1.</_>
+        <_>
+          7 18 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 6 1 -1.</_>
+        <_>
+          9 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 3 2 -1.</_>
+        <_>
+          2 3 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          8 13 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 3 6 -1.</_>
+        <_>
+          6 13 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 2 4 -1.</_>
+        <_>
+          11 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 2 4 -1.</_>
+        <_>
+          8 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 4 -1.</_>
+        <_>
+          9 6 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 13 8 3 -1.</_>
+        <_>
+          6 14 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 3 4 -1.</_>
+        <_>
+          10 15 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 2 2 17 -1.</_>
+        <_>
+          10 2 1 17 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 1 -1.</_>
+        <_>
+          9 0 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 3 4 -1.</_>
+        <_>
+          9 15 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 7 3 -1.</_>
+        <_>
+          7 14 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 16 3 3 -1.</_>
+        <_>
+          9 16 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 2 8 10 -1.</_>
+        <_>
+          6 7 8 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 5 8 8 -1.</_>
+        <_>
+          2 9 8 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 16 2 2 -1.</_>
+        <_>
+          14 17 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 16 2 2 -1.</_>
+        <_>
+          4 17 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 4 6 -1.</_>
+        <_>
+          10 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 4 6 -1.</_>
+        <_>
+          6 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 1 3 -1.</_>
+        <_>
+          10 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 4 6 -1.</_>
+        <_>
+          12 0 2 3 2.</_>
+        <_>
+          10 3 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 20 2 -1.</_>
+        <_>
+          0 4 20 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 8 2 -1.</_>
+        <_>
+          16 0 4 1 2.</_>
+        <_>
+          12 1 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 10 8 -1.</_>
+        <_>
+          2 16 10 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 7 2 10 -1.</_>
+        <_>
+          18 7 1 5 2.</_>
+        <_>
+          17 12 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 2 10 -1.</_>
+        <_>
+          1 7 1 5 2.</_>
+        <_>
+          2 12 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 10 3 6 -1.</_>
+        <_>
+          15 12 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 4 6 2 -1.</_>
+        <_>
+          6 4 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 20 6 -1.</_>
+        <_>
+          0 7 20 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 8 2 -1.</_>
+        <_>
+          0 0 4 1 2.</_>
+        <_>
+          4 1 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 4 -1.</_>
+        <_>
+          7 0 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 13 6 2 -1.</_>
+        <_>
+          1 14 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 3 4 -1.</_>
+        <_>
+          11 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 6 1 -1.</_>
+        <_>
+          8 1 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 6 18 2 -1.</_>
+        <_>
+          10 6 9 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 1 2 -1.</_>
+        <_>
+          15 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 1 2 -1.</_>
+        <_>
+          6 6 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 1 3 -1.</_>
+        <_>
+          13 5 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 15 1 2 -1.</_>
+        <_>
+          2 16 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 4 3 -1.</_>
+        <_>
+          12 5 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 7 3 -1.</_>
+        <_>
+          0 1 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 6 2 -1.</_>
+        <_>
+          9 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 2 3 -1.</_>
+        <_>
+          5 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 4 2 3 -1.</_>
+        <_>
+          18 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 8 6 -1.</_>
+        <_>
+          3 2 8 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 20 6 -1.</_>
+        <_>
+          10 2 10 3 2.</_>
+        <_>
+          0 5 10 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 2 4 -1.</_>
+        <_>
+          5 7 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 10 15 2 -1.</_>
+        <_>
+          8 10 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 12 11 -1.</_>
+        <_>
+          9 0 6 11 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 2 6 -1.</_>
+        <_>
+          13 0 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 19 2 1 -1.</_>
+        <_>
+          1 19 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 10 4 10 -1.</_>
+        <_>
+          18 10 2 5 2.</_>
+        <_>
+          16 15 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 8 10 3 -1.</_>
+        <_>
+          4 9 10 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 3 3 -1.</_>
+        <_>
+          14 13 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 4 10 -1.</_>
+        <_>
+          0 10 2 5 2.</_>
+        <_>
+          2 15 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 3 2 6 -1.</_>
+        <_>
+          18 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 1 3 -1.</_>
+        <_>
+          6 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 7 2 -1.</_>
+        <_>
+          7 8 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 2 6 -1.</_>
+        <_>
+          0 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 1 3 1 -1.</_>
+        <_>
+          12 1 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 2 6 -1.</_>
+        <_>
+          6 0 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 1 18 14 -1.</_>
+        <_>
+          7 1 6 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 6 8 3 -1.</_>
+        <_>
+          8 6 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 6 2 -1.</_>
+        <_>
+          9 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 6 2 -1.</_>
+        <_>
+          8 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 3 5 -1.</_>
+        <_>
+          11 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 3 5 -1.</_>
+        <_>
+          8 7 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 3 10 -1.</_>
+        <_>
+          14 0 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 3 2 -1.</_>
+        <_>
+          4 12 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 3 3 6 -1.</_>
+        <_>
+          18 3 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 18 10 -1.</_>
+        <_>
+          1 13 18 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 3 10 -1.</_>
+        <_>
+          14 0 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 7 -1.</_>
+        <_>
+          17 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 3 10 -1.</_>
+        <_>
+          5 0 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 7 -1.</_>
+        <_>
+          17 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 1 2 -1.</_>
+        <_>
+          0 10 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 1 2 10 -1.</_>
+        <_>
+          18 1 1 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 2 10 -1.</_>
+        <_>
+          1 1 1 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 3 4 -1.</_>
+        <_>
+          11 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 3 3 -1.</_>
+        <_>
+          3 8 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 2 6 -1.</_>
+        <_>
+          12 0 1 3 2.</_>
+        <_>
+          11 3 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 2 6 -1.</_>
+        <_>
+          7 0 1 3 2.</_>
+        <_>
+          8 3 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 7 -1.</_>
+        <_>
+          17 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 3 3 7 -1.</_>
+        <_>
+          2 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 1 6 16 -1.</_>
+        <_>
+          16 1 2 16 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 6 16 -1.</_>
+        <_>
+          2 1 2 16 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 16 8 -1.</_>
+        <_>
+          10 0 8 4 2.</_>
+        <_>
+          2 4 8 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 8 5 3 -1.</_>
+        <_>
+          6 9 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 3 -1.</_>
+        <_>
+          10 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 4 3 -1.</_>
+        <_>
+          8 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 4 -1.</_>
+        <_>
+          9 6 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 15 1 -1.</_>
+        <_>
+          5 7 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 7 9 -1.</_>
+        <_>
+          8 5 7 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 16 4 -1.</_>
+        <_>
+          1 7 8 2 2.</_>
+        <_>
+          9 9 8 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 12 8 2 -1.</_>
+        <_>
+          6 13 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 3 3 -1.</_>
+        <_>
+          8 12 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 14 10 -1.</_>
+        <_>
+          11 5 7 5 2.</_>
+        <_>
+          4 10 7 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 3 2 -1.</_>
+        <_>
+          4 13 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 6 1 -1.</_>
+        <_>
+          11 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 7 6 -1.</_>
+        <_>
+          4 11 7 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 10 6 3 -1.</_>
+        <_>
+          7 11 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 2 -1.</_>
+        <_>
+          9 12 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 20 6 -1.</_>
+        <_>
+          0 7 20 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 6 1 -1.</_>
+        <_>
+          8 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 6 1 -1.</_>
+        <_>
+          11 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 6 1 -1.</_>
+        <_>
+          7 11 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 3 4 -1.</_>
+        <_>
+          11 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          9 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 12 16 8 -1.</_>
+        <_>
+          2 16 16 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 15 2 -1.</_>
+        <_>
+          0 16 15 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 4 5 6 -1.</_>
+        <_>
+          15 6 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 4 -1.</_>
+        <_>
+          10 5 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 9 6 -1.</_>
+        <_>
+          8 12 9 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 19 15 1 -1.</_>
+        <_>
+          7 19 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 3 4 -1.</_>
+        <_>
+          11 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 20 4 -1.</_>
+        <_>
+          0 17 20 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 3 4 -1.</_>
+        <_>
+          11 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 16 3 4 -1.</_>
+        <_>
+          8 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 3 3 -1.</_>
+        <_>
+          9 17 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 6 -1.</_>
+        <_>
+          8 14 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 12 -1.</_>
+        <_>
+          9 10 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 4 3 -1.</_>
+        <_>
+          8 18 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 18 8 2 -1.</_>
+        <_>
+          13 18 4 1 2.</_>
+        <_>
+          9 19 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 18 8 2 -1.</_>
+        <_>
+          1 19 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 6 15 -1.</_>
+        <_>
+          15 5 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 2 -1.</_>
+        <_>
+          9 9 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 3 -1.</_>
+        <_>
+          9 5 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 5 6 15 -1.</_>
+        <_>
+          3 5 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 1 14 8 -1.</_>
+        <_>
+          11 1 7 4 2.</_>
+        <_>
+          4 5 7 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 4 4 16 -1.</_>
+        <_>
+          2 4 2 8 2.</_>
+        <_>
+          4 12 2 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 12 -1.</_>
+        <_>
+          12 10 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 10 12 -1.</_>
+        <_>
+          4 5 5 6 2.</_>
+        <_>
+          9 11 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 2 3 -1.</_>
+        <_>
+          5 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 4 10 -1.</_>
+        <_>
+          14 2 2 5 2.</_>
+        <_>
+          12 7 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 7 3 -1.</_>
+        <_>
+          6 5 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 18 2 -1.</_>
+        <_>
+          11 0 9 1 2.</_>
+        <_>
+          2 1 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 18 2 -1.</_>
+        <_>
+          0 0 9 1 2.</_>
+        <_>
+          9 1 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 13 4 6 -1.</_>
+        <_>
+          15 13 2 3 2.</_>
+        <_>
+          13 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 4 6 -1.</_>
+        <_>
+          3 13 2 3 2.</_>
+        <_>
+          5 16 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 2 6 -1.</_>
+        <_>
+          10 15 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 10 10 -1.</_>
+        <_>
+          5 9 5 5 2.</_>
+        <_>
+          10 14 5 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 4 2 -1.</_>
+        <_>
+          13 4 2 1 2.</_>
+        <_>
+          11 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 6 8 -1.</_>
+        <_>
+          10 12 3 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 4 10 -1.</_>
+        <_>
+          14 2 2 5 2.</_>
+        <_>
+          12 7 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 2 1 -1.</_>
+        <_>
+          9 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 5 1 12 -1.</_>
+        <_>
+          10 9 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 11 6 9 -1.</_>
+        <_>
+          3 11 3 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 4 10 -1.</_>
+        <_>
+          14 2 2 5 2.</_>
+        <_>
+          12 7 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 4 10 -1.</_>
+        <_>
+          4 2 2 5 2.</_>
+        <_>
+          6 7 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 4 2 -1.</_>
+        <_>
+          13 4 2 1 2.</_>
+        <_>
+          11 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 6 3 -1.</_>
+        <_>
+          0 15 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 4 2 -1.</_>
+        <_>
+          13 4 2 1 2.</_>
+        <_>
+          11 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 3 2 -1.</_>
+        <_>
+          7 1 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 4 2 -1.</_>
+        <_>
+          13 4 2 1 2.</_>
+        <_>
+          11 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 4 2 -1.</_>
+        <_>
+          5 4 2 1 2.</_>
+        <_>
+          7 5 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 2 12 -1.</_>
+        <_>
+          14 0 1 6 2.</_>
+        <_>
+          13 6 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 10 -1.</_>
+        <_>
+          7 0 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 17 8 -1.</_>
+        <_>
+          3 4 17 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 20 4 -1.</_>
+        <_>
+          0 6 20 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 8 2 -1.</_>
+        <_>
+          4 3 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 3 -1.</_>
+        <_>
+          8 12 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 6 4 -1.</_>
+        <_>
+          5 7 3 2 2.</_>
+        <_>
+          8 9 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 3 4 9 -1.</_>
+        <_>
+          8 6 4 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 1 4 -1.</_>
+        <_>
+          8 17 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 7 -1.</_>
+        <_>
+          8 5 4 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 4 10 -1.</_>
+        <_>
+          4 2 2 5 2.</_>
+        <_>
+          6 7 2 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 0 17 2 -1.</_>
+        <_>
+          3 1 17 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 16 15 -1.</_>
+        <_>
+          2 7 16 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 2 5 2 -1.</_>
+        <_>
+          15 3 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 2 2 -1.</_>
+        <_>
+          10 3 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 16 15 -1.</_>
+        <_>
+          4 10 16 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 5 6 -1.</_>
+        <_>
+          7 16 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 3 2 -1.</_>
+        <_>
+          11 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 3 3 1 -1.</_>
+        <_>
+          9 3 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 3 3 -1.</_>
+        <_>
+          9 17 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 5 2 -1.</_>
+        <_>
+          0 3 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 12 1 -1.</_>
+        <_>
+          5 7 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 14 -1.</_>
+        <_>
+          7 12 6 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 8 10 -1.</_>
+        <_>
+          0 0 4 5 2.</_>
+        <_>
+          4 5 4 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 1 3 2 -1.</_>
+        <_>
+          10 1 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 3 2 -1.</_>
+        <_>
+          9 1 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 6 16 -1.</_>
+        <_>
+          7 12 6 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 3 2 6 -1.</_>
+        <_>
+          2 5 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 9 -1.</_>
+        <_>
+          14 5 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 2 -1.</_>
+        <_>
+          10 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 3 -1.</_>
+        <_>
+          5 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 3 6 -1.</_>
+        <_>
+          13 13 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 2 6 -1.</_>
+        <_>
+          3 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 6 2 -1.</_>
+        <_>
+          14 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 16 2 -1.</_>
+        <_>
+          0 9 16 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 6 2 -1.</_>
+        <_>
+          14 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 5 6 -1.</_>
+        <_>
+          0 2 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 3 6 -1.</_>
+        <_>
+          4 13 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 1 3 -1.</_>
+        <_>
+          9 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 8 12 -1.</_>
+        <_>
+          6 12 8 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 9 2 -1.</_>
+        <_>
+          8 12 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 4 3 -1.</_>
+        <_>
+          4 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 9 2 -1.</_>
+        <_>
+          9 6 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 1 3 -1.</_>
+        <_>
+          4 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 6 6 -1.</_>
+        <_>
+          14 12 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 3 7 -1.</_>
+        <_>
+          8 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 3 3 -1.</_>
+        <_>
+          10 8 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 3 3 -1.</_>
+        <_>
+          9 8 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 10 11 3 -1.</_>
+        <_>
+          5 11 11 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 10 1 -1.</_>
+        <_>
+          10 7 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 2 -1.</_>
+        <_>
+          10 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 2 -1.</_>
+        <_>
+          9 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 9 4 2 -1.</_>
+        <_>
+          11 9 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 4 2 -1.</_>
+        <_>
+          7 9 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 10 2 4 -1.</_>
+        <_>
+          14 12 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 3 2 -1.</_>
+        <_>
+          8 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 17 6 3 -1.</_>
+        <_>
+          14 18 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 12 12 -1.</_>
+        <_>
+          4 5 6 6 2.</_>
+        <_>
+          10 11 6 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 8 8 -1.</_>
+        <_>
+          10 9 4 4 2.</_>
+        <_>
+          6 13 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 15 4 -1.</_>
+        <_>
+          5 4 5 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 4 1 -1.</_>
+        <_>
+          13 2 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 2 -1.</_>
+        <_>
+          4 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 3 -1.</_>
+        <_>
+          8 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 2 3 -1.</_>
+        <_>
+          9 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 2 3 -1.</_>
+        <_>
+          13 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 4 4 -1.</_>
+        <_>
+          7 12 2 2 2.</_>
+        <_>
+          9 14 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 2 2 -1.</_>
+        <_>
+          11 11 1 1 2.</_>
+        <_>
+          10 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 3 2 -1.</_>
+        <_>
+          9 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 2 2 -1.</_>
+        <_>
+          11 11 1 1 2.</_>
+        <_>
+          10 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 17 6 3 -1.</_>
+        <_>
+          0 18 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 2 2 -1.</_>
+        <_>
+          11 11 1 1 2.</_>
+        <_>
+          10 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 2 2 -1.</_>
+        <_>
+          8 11 1 1 2.</_>
+        <_>
+          9 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 8 4 -1.</_>
+        <_>
+          12 5 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 5 8 4 -1.</_>
+        <_>
+          4 5 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 2 4 1 -1.</_>
+        <_>
+          13 2 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 4 1 -1.</_>
+        <_>
+          5 2 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 4 2 -1.</_>
+        <_>
+          12 0 2 1 2.</_>
+        <_>
+          10 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 3 1 -1.</_>
+        <_>
+          8 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 11 4 8 -1.</_>
+        <_>
+          10 11 2 4 2.</_>
+        <_>
+          8 15 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 18 15 2 -1.</_>
+        <_>
+          3 19 15 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 6 2 12 -1.</_>
+        <_>
+          2 6 1 6 2.</_>
+        <_>
+          3 12 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 3 -1.</_>
+        <_>
+          9 9 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 10 3 2 -1.</_>
+        <_>
+          8 10 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 11 3 1 -1.</_>
+        <_>
+          12 11 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 3 1 -1.</_>
+        <_>
+          7 11 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 2 4 2 -1.</_>
+        <_>
+          11 2 2 1 2.</_>
+        <_>
+          9 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 3 -1.</_>
+        <_>
+          4 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 18 3 -1.</_>
+        <_>
+          8 1 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 4 14 -1.</_>
+        <_>
+          7 1 2 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 16 12 3 -1.</_>
+        <_>
+          8 16 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 17 18 3 -1.</_>
+        <_>
+          7 17 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 6 -1.</_>
+        <_>
+          9 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 1 8 -1.</_>
+        <_>
+          9 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 12 -1.</_>
+        <_>
+          9 10 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 4 8 -1.</_>
+        <_>
+          2 1 2 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 1 6 2 -1.</_>
+        <_>
+          12 1 3 1 2.</_>
+        <_>
+          9 2 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 3 12 14 -1.</_>
+        <_>
+          1 10 12 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 2 -1.</_>
+        <_>
+          10 12 2 1 2.</_>
+        <_>
+          8 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 10 2 -1.</_>
+        <_>
+          1 9 5 1 2.</_>
+        <_>
+          6 10 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 8 8 3 -1.</_>
+        <_>
+          6 9 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 15 5 3 -1.</_>
+        <_>
+          9 16 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 4 3 -1.</_>
+        <_>
+          8 8 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 2 -1.</_>
+        <_>
+          7 8 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 8 2 -1.</_>
+        <_>
+          5 7 4 1 2.</_>
+        <_>
+          9 8 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 7 4 2 -1.</_>
+        <_>
+          4 8 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 9 -1.</_>
+        <_>
+          14 5 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 3 3 -1.</_>
+        <_>
+          5 9 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 6 9 -1.</_>
+        <_>
+          0 5 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 3 3 6 -1.</_>
+        <_>
+          18 3 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 3 6 -1.</_>
+        <_>
+          1 3 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 14 1 2 -1.</_>
+        <_>
+          17 15 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 4 3 -1.</_>
+        <_>
+          6 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 9 3 3 -1.</_>
+        <_>
+          12 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 9 3 3 -1.</_>
+        <_>
+          5 10 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 8 -1.</_>
+        <_>
+          12 5 3 4 2.</_>
+        <_>
+          9 9 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 6 8 -1.</_>
+        <_>
+          5 5 3 4 2.</_>
+        <_>
+          8 9 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 1 4 6 -1.</_>
+        <_>
+          16 4 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 6 20 -1.</_>
+        <_>
+          3 0 2 20 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 11 3 2 -1.</_>
+        <_>
+          13 11 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 3 2 -1.</_>
+        <_>
+          6 11 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 6 1 -1.</_>
+        <_>
+          11 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 8 3 -1.</_>
+        <_>
+          4 0 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 0 2 5 -1.</_>
+        <_>
+          15 0 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 1 3 2 -1.</_>
+        <_>
+          5 1 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 15 -1.</_>
+        <_>
+          9 0 2 15 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 3 1 -1.</_>
+        <_>
+          7 11 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 3 4 -1.</_>
+        <_>
+          13 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 6 1 -1.</_>
+        <_>
+          7 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 3 2 -1.</_>
+        <_>
+          12 8 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 4 6 -1.</_>
+        <_>
+          0 4 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 3 2 -1.</_>
+        <_>
+          12 8 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 3 3 -1.</_>
+        <_>
+          2 17 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 8 6 10 -1.</_>
+        <_>
+          16 8 3 5 2.</_>
+        <_>
+          13 13 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 5 2 -1.</_>
+        <_>
+          0 10 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 11 2 2 -1.</_>
+        <_>
+          13 11 1 1 2.</_>
+        <_>
+          12 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 15 3 3 -1.</_>
+        <_>
+          3 16 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 3 2 -1.</_>
+        <_>
+          12 8 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 3 2 -1.</_>
+        <_>
+          5 8 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 9 9 -1.</_>
+        <_>
+          9 8 9 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 3 7 -1.</_>
+        <_>
+          6 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 12 5 -1.</_>
+        <_>
+          9 2 4 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 2 2 -1.</_>
+        <_>
+          6 11 1 1 2.</_>
+        <_>
+          7 12 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 15 3 2 -1.</_>
+        <_>
+          15 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 15 3 2 -1.</_>
+        <_>
+          2 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 6 8 -1.</_>
+        <_>
+          17 12 3 4 2.</_>
+        <_>
+          14 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 8 15 6 -1.</_>
+        <_>
+          7 8 5 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 18 17 -1.</_>
+        <_>
+          8 2 6 17 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 4 1 -1.</_>
+        <_>
+          7 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 12 5 -1.</_>
+        <_>
+          9 2 4 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 12 5 -1.</_>
+        <_>
+          7 2 4 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 12 4 -1.</_>
+        <_>
+          10 9 6 2 2.</_>
+        <_>
+          4 11 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 15 6 2 -1.</_>
+        <_>
+          5 15 3 1 2.</_>
+        <_>
+          8 16 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 2 3 -1.</_>
+        <_>
+          10 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 20 2 -1.</_>
+        <_>
+          0 13 10 1 2.</_>
+        <_>
+          10 14 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 12 8 -1.</_>
+        <_>
+          10 9 6 4 2.</_>
+        <_>
+          4 13 6 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 3 6 -1.</_>
+        <_>
+          8 16 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 2 2 -1.</_>
+        <_>
+          10 13 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 2 2 -1.</_>
+        <_>
+          9 12 1 1 2.</_>
+        <_>
+          10 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 14 4 -1.</_>
+        <_>
+          11 11 7 2 2.</_>
+        <_>
+          4 13 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 5 4 2 -1.</_>
+        <_>
+          8 6 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 10 6 3 -1.</_>
+        <_>
+          12 10 2 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 14 1 2 -1.</_>
+        <_>
+          2 15 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 8 6 12 -1.</_>
+        <_>
+          16 8 3 6 2.</_>
+        <_>
+          13 14 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 6 12 -1.</_>
+        <_>
+          1 8 3 6 2.</_>
+        <_>
+          4 14 3 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 0 6 10 -1.</_>
+        <_>
+          12 0 2 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 8 4 -1.</_>
+        <_>
+          5 11 4 2 2.</_>
+        <_>
+          9 13 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 16 8 4 -1.</_>
+        <_>
+          14 16 4 2 2.</_>
+        <_>
+          10 18 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 6 -1.</_>
+        <_>
+          9 7 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 2 4 10 -1.</_>
+        <_>
+          10 2 2 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 4 9 -1.</_>
+        <_>
+          8 1 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 19 2 1 -1.</_>
+        <_>
+          12 19 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 4 9 -1.</_>
+        <_>
+          3 2 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 5 6 4 -1.</_>
+        <_>
+          9 5 2 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 4 -1.</_>
+        <_>
+          9 6 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 5 2 8 -1.</_>
+        <_>
+          14 9 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 5 12 -1.</_>
+        <_>
+          7 12 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 2 6 -1.</_>
+        <_>
+          14 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 6 2 6 -1.</_>
+        <_>
+          4 9 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 10 4 -1.</_>
+        <_>
+          13 15 5 2 2.</_>
+        <_>
+          8 17 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 18 2 2 -1.</_>
+        <_>
+          7 18 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 6 2 -1.</_>
+        <_>
+          11 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 16 6 -1.</_>
+        <_>
+          2 2 16 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 6 2 -1.</_>
+        <_>
+          11 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 10 3 -1.</_>
+        <_>
+          4 12 10 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 6 2 -1.</_>
+        <_>
+          11 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 3 6 2 -1.</_>
+        <_>
+          3 4 6 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 7 -1.</_>
+        <_>
+          16 0 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 9 6 -1.</_>
+        <_>
+          0 16 9 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 3 3 -1.</_>
+        <_>
+          9 17 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 6 6 2 -1.</_>
+        <_>
+          6 6 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 1 3 -1.</_>
+        <_>
+          15 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 3 -1.</_>
+        <_>
+          5 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 9 2 2 -1.</_>
+        <_>
+          10 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 4 3 -1.</_>
+        <_>
+          5 1 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 4 7 -1.</_>
+        <_>
+          16 0 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 20 1 -1.</_>
+        <_>
+          10 0 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 1 3 -1.</_>
+        <_>
+          15 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 3 4 -1.</_>
+        <_>
+          1 4 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 3 3 6 -1.</_>
+        <_>
+          16 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 3 3 6 -1.</_>
+        <_>
+          1 5 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 2 12 6 -1.</_>
+        <_>
+          12 2 6 3 2.</_>
+        <_>
+          6 5 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 4 3 -1.</_>
+        <_>
+          8 11 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 14 6 -1.</_>
+        <_>
+          11 2 7 3 2.</_>
+        <_>
+          4 5 7 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 3 -1.</_>
+        <_>
+          15 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 3 -1.</_>
+        <_>
+          8 13 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 11 1 3 -1.</_>
+        <_>
+          15 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 5 2 -1.</_>
+        <_>
+          7 14 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 6 3 -1.</_>
+        <_>
+          7 13 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 11 4 4 -1.</_>
+        <_>
+          5 13 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 3 3 -1.</_>
+        <_>
+          12 4 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 4 3 3 -1.</_>
+        <_>
+          7 4 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 5 3 6 -1.</_>
+        <_>
+          17 5 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 6 12 7 -1.</_>
+        <_>
+          7 6 4 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 5 3 6 -1.</_>
+        <_>
+          17 5 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 2 3 -1.</_>
+        <_>
+          3 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 5 3 6 -1.</_>
+        <_>
+          17 5 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 5 3 6 -1.</_>
+        <_>
+          2 5 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 18 1 -1.</_>
+        <_>
+          7 9 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 9 8 7 -1.</_>
+        <_>
+          4 9 4 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 11 8 2 -1.</_>
+        <_>
+          12 12 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 11 8 2 -1.</_>
+        <_>
+          0 12 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 2 3 -1.</_>
+        <_>
+          9 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 10 12 4 -1.</_>
+        <_>
+          4 10 6 2 2.</_>
+        <_>
+          10 12 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 3 7 -1.</_>
+        <_>
+          10 3 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 3 5 -1.</_>
+        <_>
+          8 2 1 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 4 6 -1.</_>
+        <_>
+          11 12 2 3 2.</_>
+        <_>
+          9 15 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 6 -1.</_>
+        <_>
+          9 7 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 4 4 2 -1.</_>
+        <_>
+          15 5 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          9 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 2 6 4 -1.</_>
+        <_>
+          14 4 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 16 6 1 -1.</_>
+        <_>
+          9 16 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 13 2 3 -1.</_>
+        <_>
+          15 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 10 -1.</_>
+        <_>
+          9 7 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 10 2 6 -1.</_>
+        <_>
+          11 12 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 4 1 -1.</_>
+        <_>
+          8 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 9 2 2 -1.</_>
+        <_>
+          10 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 2 2 -1.</_>
+        <_>
+          8 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 2 2 -1.</_>
+        <_>
+          13 7 1 1 2.</_>
+        <_>
+          12 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 2 2 -1.</_>
+        <_>
+          5 7 1 1 2.</_>
+        <_>
+          6 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 3 14 -1.</_>
+        <_>
+          14 0 1 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 3 14 -1.</_>
+        <_>
+          5 0 1 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 4 3 14 -1.</_>
+        <_>
+          14 4 1 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 3 -1.</_>
+        <_>
+          9 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 2 3 16 -1.</_>
+        <_>
+          5 2 1 16 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 8 10 -1.</_>
+        <_>
+          7 7 8 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 14 7 3 -1.</_>
+        <_>
+          6 15 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 2 10 12 -1.</_>
+        <_>
+          14 2 5 6 2.</_>
+        <_>
+          9 8 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 7 8 2 -1.</_>
+        <_>
+          6 8 8 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 4 6 -1.</_>
+        <_>
+          8 16 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 1 3 -1.</_>
+        <_>
+          6 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 2 4 6 -1.</_>
+        <_>
+          16 4 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 4 2 -1.</_>
+        <_>
+          6 6 2 1 2.</_>
+        <_>
+          8 7 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 2 4 6 -1.</_>
+        <_>
+          16 4 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 4 6 -1.</_>
+        <_>
+          0 4 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 6 2 6 -1.</_>
+        <_>
+          9 6 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 6 10 -1.</_>
+        <_>
+          3 9 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 6 -1.</_>
+        <_>
+          9 5 1 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 2 3 -1.</_>
+        <_>
+          3 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 13 3 2 -1.</_>
+        <_>
+          13 14 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 16 10 4 -1.</_>
+        <_>
+          2 16 5 2 2.</_>
+        <_>
+          7 18 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 10 6 -1.</_>
+        <_>
+          10 6 5 3 2.</_>
+        <_>
+          5 9 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 1 3 -1.</_>
+        <_>
+          7 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 16 6 3 -1.</_>
+        <_>
+          14 17 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 10 3 -1.</_>
+        <_>
+          7 5 10 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 5 4 -1.</_>
+        <_>
+          0 6 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 11 3 9 -1.</_>
+        <_>
+          13 14 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 3 9 -1.</_>
+        <_>
+          4 14 3 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 1 -1.</_>
+        <_>
+          9 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 6 17 -1.</_>
+        <_>
+          7 0 2 17 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 6 3 -1.</_>
+        <_>
+          10 3 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 2 15 4 -1.</_>
+        <_>
+          7 2 5 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 8 2 -1.</_>
+        <_>
+          12 2 4 1 2.</_>
+        <_>
+          8 3 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 3 6 -1.</_>
+        <_>
+          8 3 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 2 2 -1.</_>
+        <_>
+          9 18 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 2 14 -1.</_>
+        <_>
+          1 0 1 14 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 7 3 -1.</_>
+        <_>
+          12 1 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 1 2 -1.</_>
+        <_>
+          1 15 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 2 8 -1.</_>
+        <_>
+          15 12 1 4 2.</_>
+        <_>
+          14 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 7 3 -1.</_>
+        <_>
+          1 1 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 2 8 -1.</_>
+        <_>
+          15 12 1 4 2.</_>
+        <_>
+          14 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 12 -1.</_>
+        <_>
+          6 0 4 6 2.</_>
+        <_>
+          10 6 4 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 8 9 -1.</_>
+        <_>
+          6 4 8 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 2 2 -1.</_>
+        <_>
+          5 3 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 6 6 -1.</_>
+        <_>
+          16 14 3 3 2.</_>
+        <_>
+          13 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 17 20 2 -1.</_>
+        <_>
+          0 17 10 1 2.</_>
+        <_>
+          10 18 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 2 6 -1.</_>
+        <_>
+          11 3 1 3 2.</_>
+        <_>
+          10 6 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 6 2 -1.</_>
+        <_>
+          8 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 6 13 -1.</_>
+        <_>
+          10 7 3 13 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 15 10 5 -1.</_>
+        <_>
+          10 15 5 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 4 4 10 -1.</_>
+        <_>
+          10 4 2 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 2 1 -1.</_>
+        <_>
+          6 7 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 6 7 -1.</_>
+        <_>
+          10 3 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 6 7 -1.</_>
+        <_>
+          7 3 3 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 7 18 5 -1.</_>
+        <_>
+          7 7 6 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 17 4 3 -1.</_>
+        <_>
+          5 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 12 6 -1.</_>
+        <_>
+          14 14 6 3 2.</_>
+        <_>
+          8 17 6 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 13 20 4 -1.</_>
+        <_>
+          0 13 10 2 2.</_>
+        <_>
+          10 15 10 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 14 2 -1.</_>
+        <_>
+          11 5 7 1 2.</_>
+        <_>
+          4 6 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 10 12 -1.</_>
+        <_>
+          1 2 5 6 2.</_>
+        <_>
+          6 8 5 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 14 3 -1.</_>
+        <_>
+          6 2 14 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 16 2 3 -1.</_>
+        <_>
+          8 17 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 2 -1.</_>
+        <_>
+          10 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 15 4 2 -1.</_>
+        <_>
+          5 15 2 1 2.</_>
+        <_>
+          7 16 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 15 1 3 -1.</_>
+        <_>
+          10 16 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 16 4 4 -1.</_>
+        <_>
+          8 16 2 2 2.</_>
+        <_>
+          10 18 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 11 8 6 -1.</_>
+        <_>
+          6 14 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 13 5 2 -1.</_>
+        <_>
+          2 14 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 6 6 -1.</_>
+        <_>
+          16 14 3 3 2.</_>
+        <_>
+          13 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 18 4 -1.</_>
+        <_>
+          7 9 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 6 6 -1.</_>
+        <_>
+          16 14 3 3 2.</_>
+        <_>
+          13 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 1 6 -1.</_>
+        <_>
+          0 4 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 15 20 -1.</_>
+        <_>
+          5 10 15 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 6 6 -1.</_>
+        <_>
+          1 14 3 3 2.</_>
+        <_>
+          4 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 6 -1.</_>
+        <_>
+          10 14 2 3 2.</_>
+        <_>
+          8 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 2 1 -1.</_>
+        <_>
+          8 11 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 17 3 2 -1.</_>
+        <_>
+          10 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 3 2 -1.</_>
+        <_>
+          9 17 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 14 4 6 -1.</_>
+        <_>
+          14 14 2 3 2.</_>
+        <_>
+          12 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 4 6 -1.</_>
+        <_>
+          4 14 2 3 2.</_>
+        <_>
+          6 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 2 6 -1.</_>
+        <_>
+          14 14 1 3 2.</_>
+        <_>
+          13 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 14 2 6 -1.</_>
+        <_>
+          5 14 1 3 2.</_>
+        <_>
+          6 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 0 6 12 -1.</_>
+        <_>
+          7 4 6 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 7 12 2 -1.</_>
+        <_>
+          4 7 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 3 3 13 -1.</_>
+        <_>
+          11 3 1 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 3 3 13 -1.</_>
+        <_>
+          8 3 1 13 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 6 3 -1.</_>
+        <_>
+          10 9 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 3 2 -1.</_>
+        <_>
+          4 11 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 12 6 8 -1.</_>
+        <_>
+          16 12 3 4 2.</_>
+        <_>
+          13 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 5 -1.</_>
+        <_>
+          9 6 2 5 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 11 2 7 -1.</_>
+        <_>
+          17 11 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 8 2 -1.</_>
+        <_>
+          7 13 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 8 3 -1.</_>
+        <_>
+          6 10 8 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 4 3 -1.</_>
+        <_>
+          4 4 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 4 3 -1.</_>
+        <_>
+          11 4 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 4 17 12 -1.</_>
+        <_>
+          1 8 17 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 4 3 -1.</_>
+        <_>
+          11 4 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 8 6 3 -1.</_>
+        <_>
+          4 9 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 3 5 3 -1.</_>
+        <_>
+          12 4 5 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 2 7 -1.</_>
+        <_>
+          2 11 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 12 2 8 -1.</_>
+        <_>
+          16 12 1 4 2.</_>
+        <_>
+          15 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 8 11 3 -1.</_>
+        <_>
+          4 9 11 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 6 2 -1.</_>
+        <_>
+          12 13 3 1 2.</_>
+        <_>
+          9 14 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 13 4 3 -1.</_>
+        <_>
+          6 14 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 3 3 -1.</_>
+        <_>
+          10 12 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 3 3 -1.</_>
+        <_>
+          5 4 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 4 2 3 -1.</_>
+        <_>
+          9 5 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 16 3 -1.</_>
+        <_>
+          0 3 16 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 12 2 8 -1.</_>
+        <_>
+          16 12 1 4 2.</_>
+        <_>
+          15 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 12 2 8 -1.</_>
+        <_>
+          3 12 1 4 2.</_>
+        <_>
+          4 16 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 13 3 6 -1.</_>
+        <_>
+          14 15 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 13 3 6 -1.</_>
+        <_>
+          3 15 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 10 2 -1.</_>
+        <_>
+          11 5 5 1 2.</_>
+        <_>
+          6 6 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 14 14 6 -1.</_>
+        <_>
+          2 17 14 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 1 3 -1.</_>
+        <_>
+          10 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 16 2 2 -1.</_>
+        <_>
+          4 16 1 1 2.</_>
+        <_>
+          5 17 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 6 2 3 -1.</_>
+        <_>
+          10 7 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 17 20 2 -1.</_>
+        <_>
+          0 17 10 1 2.</_>
+        <_>
+          10 18 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 6 1 3 -1.</_>
+        <_>
+          13 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 3 2 -1.</_>
+        <_>
+          9 13 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 2 3 3 -1.</_>
+        <_>
+          13 2 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 18 2 2 -1.</_>
+        <_>
+          3 18 1 1 2.</_>
+        <_>
+          4 19 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 3 4 -1.</_>
+        <_>
+          10 16 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 1 3 -1.</_>
+        <_>
+          6 7 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 1 5 2 -1.</_>
+        <_>
+          13 2 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 6 2 -1.</_>
+        <_>
+          7 14 3 1 2.</_>
+        <_>
+          10 15 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 3 3 4 -1.</_>
+        <_>
+          12 3 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 13 12 6 -1.</_>
+        <_>
+          5 13 4 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 11 5 2 -1.</_>
+        <_>
+          14 12 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 15 14 4 -1.</_>
+        <_>
+          2 15 7 2 2.</_>
+        <_>
+          9 17 7 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 7 14 2 -1.</_>
+        <_>
+          10 7 7 1 2.</_>
+        <_>
+          3 8 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 11 4 2 -1.</_>
+        <_>
+          1 12 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 14 -1.</_>
+        <_>
+          16 0 2 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 1 3 -1.</_>
+        <_>
+          4 12 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 6 14 -1.</_>
+        <_>
+          16 0 2 14 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 10 3 7 -1.</_>
+        <_>
+          2 10 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 9 2 -1.</_>
+        <_>
+          8 13 9 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 20 1 -1.</_>
+        <_>
+          10 6 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 4 4 4 -1.</_>
+        <_>
+          8 4 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 2 2 -1.</_>
+        <_>
+          0 1 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 3 10 9 -1.</_>
+        <_>
+          5 6 10 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 2 4 10 -1.</_>
+        <_>
+          15 2 2 10 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 2 2 7 -1.</_>
+        <_>
+          9 2 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 4 12 1 -1.</_>
+        <_>
+          11 4 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 4 9 1 -1.</_>
+        <_>
+          6 4 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 10 1 4 -1.</_>
+        <_>
+          15 12 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 10 6 4 -1.</_>
+        <_>
+          7 10 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          15 9 1 6 -1.</_>
+        <_>
+          15 12 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 17 6 3 -1.</_>
+        <_>
+          7 18 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 3 2 16 -1.</_>
+        <_>
+          15 3 1 8 2.</_>
+        <_>
+          14 11 1 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 1 6 -1.</_>
+        <_>
+          4 12 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 1 5 2 -1.</_>
+        <_>
+          12 2 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 18 4 2 -1.</_>
+        <_>
+          6 18 2 1 2.</_>
+        <_>
+          8 19 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 4 16 10 -1.</_>
+        <_>
+          10 4 8 5 2.</_>
+        <_>
+          2 9 8 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 1 10 -1.</_>
+        <_>
+          6 10 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 8 15 2 -1.</_>
+        <_>
+          9 8 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 8 15 2 -1.</_>
+        <_>
+          6 8 5 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 3 6 -1.</_>
+        <_>
+          9 7 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 8 2 -1.</_>
+        <_>
+          9 7 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 11 2 3 -1.</_>
+        <_>
+          9 12 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 16 3 -1.</_>
+        <_>
+          1 1 16 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 2 7 2 -1.</_>
+        <_>
+          11 3 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 10 18 -1.</_>
+        <_>
+          5 7 10 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 4 3 2 -1.</_>
+        <_>
+          18 4 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 1 3 -1.</_>
+        <_>
+          8 14 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 14 6 -1.</_>
+        <_>
+          3 16 14 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 3 4 -1.</_>
+        <_>
+          1 2 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 1 5 2 -1.</_>
+        <_>
+          12 2 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 1 5 2 -1.</_>
+        <_>
+          3 2 5 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 13 2 3 -1.</_>
+        <_>
+          10 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 2 3 -1.</_>
+        <_>
+          8 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 12 2 3 -1.</_>
+        <_>
+          14 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 2 2 3 -1.</_>
+        <_>
+          7 3 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 10 4 -1.</_>
+        <_>
+          10 6 5 2 2.</_>
+        <_>
+          5 8 5 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 13 1 6 -1.</_>
+        <_>
+          9 16 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 12 2 2 -1.</_>
+        <_>
+          11 12 1 1 2.</_>
+        <_>
+          10 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 12 2 3 -1.</_>
+        <_>
+          4 13 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 4 6 6 -1.</_>
+        <_>
+          14 6 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 17 2 3 -1.</_>
+        <_>
+          8 18 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 4 4 6 -1.</_>
+        <_>
+          16 6 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 4 6 -1.</_>
+        <_>
+          0 6 4 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 6 2 3 -1.</_>
+        <_>
+          14 6 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 9 8 1 -1.</_>
+        <_>
+          8 9 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 12 4 3 -1.</_>
+        <_>
+          8 13 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 12 10 6 -1.</_>
+        <_>
+          5 14 10 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 12 1 2 -1.</_>
+        <_>
+          11 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 2 -1.</_>
+        <_>
+          8 16 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 9 8 8 -1.</_>
+        <_>
+          10 9 4 4 2.</_>
+        <_>
+          6 13 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 4 6 -1.</_>
+        <_>
+          7 12 2 3 2.</_>
+        <_>
+          9 15 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 11 3 1 -1.</_>
+        <_>
+          11 11 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 10 -1.</_>
+        <_>
+          9 7 1 5 2.</_>
+        <_>
+          10 12 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 6 6 -1.</_>
+        <_>
+          10 0 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 11 2 6 -1.</_>
+        <_>
+          3 13 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 12 1 2 -1.</_>
+        <_>
+          16 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 6 6 -1.</_>
+        <_>
+          1 14 3 3 2.</_>
+        <_>
+          4 17 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 1 3 6 -1.</_>
+        <_>
+          14 1 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 8 2 2 -1.</_>
+        <_>
+          8 9 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 3 3 -1.</_>
+        <_>
+          10 9 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 7 3 3 -1.</_>
+        <_>
+          8 8 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 2 3 -1.</_>
+        <_>
+          14 0 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 18 9 -1.</_>
+        <_>
+          7 0 6 9 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 5 4 15 -1.</_>
+        <_>
+          11 5 2 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 4 15 -1.</_>
+        <_>
+          7 5 2 15 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 0 2 3 -1.</_>
+        <_>
+          14 0 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 2 3 -1.</_>
+        <_>
+          5 0 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 12 2 2 -1.</_>
+        <_>
+          12 12 1 1 2.</_>
+        <_>
+          11 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 12 2 2 -1.</_>
+        <_>
+          7 12 1 1 2.</_>
+        <_>
+          8 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 3 4 -1.</_>
+        <_>
+          13 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 11 3 3 -1.</_>
+        <_>
+          4 12 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 4 2 -1.</_>
+        <_>
+          12 8 4 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 3 2 -1.</_>
+        <_>
+          9 10 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 3 2 -1.</_>
+        <_>
+          10 9 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 9 3 2 -1.</_>
+        <_>
+          9 9 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 0 3 4 -1.</_>
+        <_>
+          13 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 0 3 4 -1.</_>
+        <_>
+          6 0 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 12 4 -1.</_>
+        <_>
+          10 14 6 2 2.</_>
+        <_>
+          4 16 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 13 2 3 -1.</_>
+        <_>
+          8 14 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 10 3 8 -1.</_>
+        <_>
+          10 14 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 10 4 8 -1.</_>
+        <_>
+          8 10 2 4 2.</_>
+        <_>
+          10 14 2 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 3 1 -1.</_>
+        <_>
+          11 8 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 12 1 6 -1.</_>
+        <_>
+          9 15 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 3 1 -1.</_>
+        <_>
+          11 8 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 3 1 -1.</_>
+        <_>
+          8 8 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 2 15 14 -1.</_>
+        <_>
+          5 9 15 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 1 2 10 -1.</_>
+        <_>
+          2 1 1 5 2.</_>
+        <_>
+          3 6 1 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 14 2 3 -1.</_>
+        <_>
+          14 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 7 3 3 -1.</_>
+        <_>
+          3 7 1 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 4 3 3 -1.</_>
+        <_>
+          17 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 3 3 -1.</_>
+        <_>
+          0 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 6 2 -1.</_>
+        <_>
+          16 5 3 1 2.</_>
+        <_>
+          13 6 3 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 19 12 1 -1.</_>
+        <_>
+          8 19 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 12 2 4 -1.</_>
+        <_>
+          12 14 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 15 1 3 -1.</_>
+        <_>
+          3 16 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 16 6 4 -1.</_>
+        <_>
+          11 16 3 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 10 3 10 -1.</_>
+        <_>
+          3 10 1 10 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 8 2 4 -1.</_>
+        <_>
+          12 8 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 8 2 4 -1.</_>
+        <_>
+          7 8 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 2 3 -1.</_>
+        <_>
+          10 14 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 10 3 -1.</_>
+        <_>
+          10 1 5 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 7 3 2 -1.</_>
+        <_>
+          11 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 6 9 2 -1.</_>
+        <_>
+          8 6 3 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 8 2 2 -1.</_>
+        <_>
+          9 9 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 11 16 6 -1.</_>
+        <_>
+          2 11 8 3 2.</_>
+        <_>
+          10 14 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 7 2 2 -1.</_>
+        <_>
+          13 7 1 1 2.</_>
+        <_>
+          12 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 2 3 -1.</_>
+        <_>
+          9 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 2 -1.</_>
+        <_>
+          10 7 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 1 8 12 -1.</_>
+        <_>
+          5 7 8 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 2 -1.</_>
+        <_>
+          13 6 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 2 -1.</_>
+        <_>
+          5 6 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 14 2 3 -1.</_>
+        <_>
+          4 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 4 3 3 -1.</_>
+        <_>
+          12 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 3 3 -1.</_>
+        <_>
+          5 5 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 6 -1.</_>
+        <_>
+          10 14 1 3 2.</_>
+        <_>
+          9 17 1 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 3 2 -1.</_>
+        <_>
+          9 14 1 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 6 6 -1.</_>
+        <_>
+          11 5 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 6 6 -1.</_>
+        <_>
+          7 5 2 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 13 1 2 -1.</_>
+        <_>
+          13 14 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 10 2 -1.</_>
+        <_>
+          0 3 10 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 13 1 2 -1.</_>
+        <_>
+          13 14 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 2 2 -1.</_>
+        <_>
+          5 7 1 1 2.</_>
+        <_>
+          6 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 7 -1.</_>
+        <_>
+          13 5 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 13 1 2 -1.</_>
+        <_>
+          6 14 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 7 -1.</_>
+        <_>
+          12 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 3 2 16 -1.</_>
+        <_>
+          0 3 1 8 2.</_>
+        <_>
+          1 11 1 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 0 3 7 -1.</_>
+        <_>
+          12 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 3 7 -1.</_>
+        <_>
+          7 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 16 8 4 -1.</_>
+        <_>
+          11 16 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 16 8 4 -1.</_>
+        <_>
+          5 16 4 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 5 2 7 -1.</_>
+        <_>
+          13 5 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 5 2 7 -1.</_>
+        <_>
+          6 5 1 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 6 2 14 -1.</_>
+        <_>
+          18 13 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 10 3 4 -1.</_>
+        <_>
+          6 12 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 7 1 2 -1.</_>
+        <_>
+          14 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 18 6 -1.</_>
+        <_>
+          0 1 9 3 2.</_>
+        <_>
+          9 4 9 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 7 1 2 -1.</_>
+        <_>
+          14 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 2 14 -1.</_>
+        <_>
+          0 13 2 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          17 0 3 12 -1.</_>
+        <_>
+          18 0 1 12 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 6 18 3 -1.</_>
+        <_>
+          0 7 18 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 14 16 -1.</_>
+        <_>
+          6 8 14 8 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 3 12 -1.</_>
+        <_>
+          1 0 1 12 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 3 7 -1.</_>
+        <_>
+          14 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 1 2 -1.</_>
+        <_>
+          5 8 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 4 6 6 -1.</_>
+        <_>
+          14 6 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 7 7 2 -1.</_>
+        <_>
+          5 8 7 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 6 9 -1.</_>
+        <_>
+          8 9 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 4 6 1 -1.</_>
+        <_>
+          7 4 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 6 4 -1.</_>
+        <_>
+          16 0 3 2 2.</_>
+        <_>
+          13 2 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 2 18 12 -1.</_>
+        <_>
+          1 6 18 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 2 17 12 -1.</_>
+        <_>
+          3 6 17 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          5 14 7 3 -1.</_>
+        <_>
+          5 15 7 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 14 1 3 -1.</_>
+        <_>
+          10 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          3 14 3 3 -1.</_>
+        <_>
+          3 15 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          14 4 6 6 -1.</_>
+        <_>
+          14 6 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 6 6 -1.</_>
+        <_>
+          0 6 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          12 5 4 3 -1.</_>
+        <_>
+          12 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 5 4 3 -1.</_>
+        <_>
+          4 6 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 0 2 6 -1.</_>
+        <_>
+          18 2 2 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 1 4 9 -1.</_>
+        <_>
+          10 1 2 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 6 8 2 -1.</_>
+        <_>
+          6 6 4 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 5 4 2 -1.</_>
+        <_>
+          6 5 2 1 2.</_>
+        <_>
+          8 6 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 5 2 3 -1.</_>
+        <_>
+          10 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 1 3 -1.</_>
+        <_>
+          9 6 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 10 2 2 -1.</_>
+        <_>
+          9 11 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 8 4 3 -1.</_>
+        <_>
+          0 9 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 0 8 6 -1.</_>
+        <_>
+          6 3 8 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 0 6 4 -1.</_>
+        <_>
+          1 0 3 2 2.</_>
+        <_>
+          4 2 3 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 0 3 7 -1.</_>
+        <_>
+          14 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 16 2 2 -1.</_>
+        <_>
+          9 17 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 4 6 10 -1.</_>
+        <_>
+          11 9 6 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 10 19 2 -1.</_>
+        <_>
+          0 11 19 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 8 9 -1.</_>
+        <_>
+          9 8 8 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 0 3 7 -1.</_>
+        <_>
+          5 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 6 4 12 -1.</_>
+        <_>
+          10 6 2 6 2.</_>
+        <_>
+          8 12 2 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 2 6 4 -1.</_>
+        <_>
+          0 4 6 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 15 4 3 -1.</_>
+        <_>
+          8 16 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 0 3 7 -1.</_>
+        <_>
+          9 0 1 7 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 5 3 4 -1.</_>
+        <_>
+          10 5 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 5 3 4 -1.</_>
+        <_>
+          9 5 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 6 6 1 -1.</_>
+        <_>
+          9 6 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 4 4 -1.</_>
+        <_>
+          7 14 2 2 2.</_>
+        <_>
+          9 16 2 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          13 14 4 6 -1.</_>
+        <_>
+          15 14 2 3 2.</_>
+        <_>
+          13 17 2 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 1 8 -1.</_>
+        <_>
+          7 12 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          16 0 2 8 -1.</_>
+        <_>
+          17 0 1 4 2.</_>
+        <_>
+          16 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          2 0 2 8 -1.</_>
+        <_>
+          2 0 1 4 2.</_>
+        <_>
+          3 4 1 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          6 1 14 3 -1.</_>
+        <_>
+          6 2 14 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 9 3 10 -1.</_>
+        <_>
+          7 14 3 5 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 2 2 -1.</_>
+        <_>
+          9 15 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 7 6 8 -1.</_>
+        <_>
+          7 11 6 4 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 3 6 -1.</_>
+        <_>
+          9 10 3 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 13 3 3 -1.</_>
+        <_>
+          7 14 3 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 9 2 2 -1.</_>
+        <_>
+          9 10 2 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 1 18 2 -1.</_>
+        <_>
+          6 1 6 2 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 1 6 14 -1.</_>
+        <_>
+          7 8 6 7 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 9 18 1 -1.</_>
+        <_>
+          7 9 6 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 7 2 2 -1.</_>
+        <_>
+          9 7 1 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 3 2 9 -1.</_>
+        <_>
+          10 3 1 9 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          18 14 2 3 -1.</_>
+        <_>
+          18 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 11 3 1 -1.</_>
+        <_>
+          8 11 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 3 4 -1.</_>
+        <_>
+          11 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 14 3 6 -1.</_>
+        <_>
+          8 14 1 6 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          10 8 3 4 -1.</_>
+        <_>
+          11 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 8 3 4 -1.</_>
+        <_>
+          8 8 1 4 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          7 9 6 9 -1.</_>
+        <_>
+          7 12 6 3 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 14 2 3 -1.</_>
+        <_>
+          0 15 2 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          11 12 1 2 -1.</_>
+        <_>
+          11 13 1 1 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          4 3 8 3 -1.</_>
+        <_>
+          8 3 4 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 4 20 6 -1.</_>
+        <_>
+          0 4 10 6 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          9 14 1 3 -1.</_>
+        <_>
+          9 15 1 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          8 14 4 3 -1.</_>
+        <_>
+          8 15 4 1 3.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 15 14 4 -1.</_>
+        <_>
+          0 17 14 2 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          1 14 18 6 -1.</_>
+        <_>
+          1 17 18 3 2.</_></rects></_>
+    <_>
+      <rects>
+        <_>
+          0 0 10 6 -1.</_>
+        <_>
+          0 0 5 3 2.</_>
+        <_>
+          5 3 5 3 2.</_></rects></_></features></cascade>
+</opencv_storage>
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/MainPage.xaml b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/MainPage.xaml
new file mode 100644
index 00000000..a38ad292
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/MainPage.xaml
@@ -0,0 +1,25 @@
+<Page x:Class="video_capture_xaml.MainPage"
+      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+      xmlns:local="using:video_capture_xaml"
+      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+      mc:Ignorable="d">
+
+    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
+        <TextBlock Margin="20,35,0,0"
+                   HorizontalAlignment="Left"
+                   VerticalAlignment="Top"
+                   FontSize="24"
+                   TextWrapping="Wrap">
+            <Run Text="OpenCV: videoio implementation using XAML and Universal App Framework" />
+            <Run />
+        </TextBlock>
+        <Image Name="cvImage"
+               Width="640"
+               Height="480"
+               Margin="20,100,0,0"
+               HorizontalAlignment="Left"
+               VerticalAlignment="Top" />
+    </Grid>
+</Page>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/MainPage.xaml.cpp b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/MainPage.xaml.cpp
new file mode 100644
index 00000000..59d76c44
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/MainPage.xaml.cpp
@@ -0,0 +1,61 @@
+//
+// MainPage.xaml.cpp
+// Implementation of the MainPage class.
+//
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/features2d.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/videoio/cap_winrt.hpp>
+
+using namespace video_capture_xaml;
+
+using namespace Platform;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Controls::Primitives;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Navigation;
+
+// The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=234238
+
+using namespace ::Windows::Foundation;
+using namespace Windows::UI::Xaml::Media::Imaging;
+
+namespace video_capture_xaml
+{
+    // nb. implemented in main.cpp
+    void cvMain();
+
+    MainPage::MainPage()
+    {
+        InitializeComponent();
+
+        Window::Current->VisibilityChanged += ref new Windows::UI::Xaml::WindowVisibilityChangedEventHandler(this, &video_capture_xaml::MainPage::OnVisibilityChanged);
+
+        // attach XAML elements
+        cv::winrt_setFrameContainer(cvImage);
+
+        // start (1) frame-grabbing loop and (2) message loop
+        //
+        // 1. Function passed as an argument must implement common OCV reading frames
+        //    pattern (see cv::VideoCapture documentation) AND call cv::winrt_imgshow().
+        // 2. Message processing loop required to overcome WinRT container and type
+        //    conversion restrictions. OCV provides default implementation
+        cv::winrt_startMessageLoop(cvMain);
+    }
+}
+
+void video_capture_xaml::MainPage::OnVisibilityChanged(Platform::Object ^sender,
+    Windows::UI::Core::VisibilityChangedEventArgs ^e)
+{
+    cv::winrt_onVisibilityChanged(e->Visible);
+}
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/MainPage.xaml.h b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/MainPage.xaml.h
new file mode 100644
index 00000000..8d90e6b2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/MainPage.xaml.h
@@ -0,0 +1,24 @@
+//
+// MainPage.xaml.h
+// Declaration of the MainPage class.
+//
+
+#pragma once
+
+#include "MainPage.g.h"
+
+namespace video_capture_xaml
+{
+    /// <summary>
+    /// An empty page that can be used on its own or navigated to within a Frame.
+    /// </summary>
+    public ref class MainPage sealed
+    {
+    public:
+        MainPage();
+
+    private:
+        void OnVisibilityChanged(Platform::Object ^sender, Windows::UI::Core::VisibilityChangedEventArgs ^e);
+
+    };
+}
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Package.appxmanifest b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Package.appxmanifest
new file mode 100644
index 00000000..484b3865
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/Package.appxmanifest
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest" xmlns:m2="http://schemas.microsoft.com/appx/2013/manifest">
+  <Identity Name="dd4947e8-f250-49d1-be17-4442dfea2737" Publisher="CN=daver_000" Version="1.0.0.0" />
+  <Properties>
+    <DisplayName>video_capture_xaml.Windows</DisplayName>
+    <PublisherDisplayName>daver_000</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+  <Prerequisites>
+    <OSMinVersion>6.3.0</OSMinVersion>
+    <OSMaxVersionTested>6.3.0</OSMaxVersionTested>
+  </Prerequisites>
+  <Resources>
+    <Resource Language="x-generate" />
+  </Resources>
+  <Applications>
+    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="video_capture_xaml_Windows.App">
+      <m2:VisualElements DisplayName="video_capture_xaml.Windows" Square150x150Logo="Assets\Logo.png" Square30x30Logo="Assets\SmallLogo.png" Description="video_capture_xaml.Windows" ForegroundText="light" BackgroundColor="#464646">
+        <m2:SplashScreen Image="Assets\SplashScreen.png" />
+      </m2:VisualElements>
+    </Application>
+  </Applications>
+  <Capabilities>
+    <Capability Name="internetClient" />
+    <DeviceCapability Name="webcam" />
+  </Capabilities>
+</Package>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/readme.txt b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/readme.txt
new file mode 100644
index 00000000..3a95854d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/readme.txt
@@ -0,0 +1,30 @@
+notes for OpenCV WinRT implementation:
+
+cvMain() in main.cpp
+  implements the image processing and OpenCV app control
+  it is running on a background thread, started by XAML
+  see file main.cpp
+  in the Application project
+
+class VideoCapture_WinRT:
+  implements the IVideoCapture interface from OpenCV
+  video is initialized and frames are grabbed on the UI thread
+  see files cap_winrt.hpp/cpp
+
+class HighguiBridge, a singleton
+  implements the OpenCV Highgui functions for XAML (limited at this time),
+  and also bridges to the UI thread functions for XAML and video operations.
+  see files cap_winrt_highgui.hpp/cpp
+
+class Video, a singleton
+  encapsulates the Media Foundation interface needed for video initialization and grabbing.
+  called through Highgui and XAML, only on the UI thread
+  see files cap_winrt_video.hpp/cpp
+
+threading:
+  requests from the OpenCV bg thread to the Video/XAML UI thread
+  are made through HighguiBridge::requestForUIthreadAsync(), which uses
+  the "progress reporter" method provided by the WinRT class
+  IAsyncActionWithProgress.  Also the bg thread is started by create_async().
+  see file MainPage.xaml.cpp
+  in the Application project
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/video_capture_xaml.Windows.vcxproj b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/video_capture_xaml.Windows.vcxproj
new file mode 100644
index 00000000..2a8a7d0d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/video_capture_xaml.Windows.vcxproj
@@ -0,0 +1,200 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{32fdab94-f87e-4f0a-89a4-9ec10a3b1d3d}</ProjectGuid>
+    <RootNamespace>video_capture_xaml</RootNamespace>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>12.0</MinimumVisualStudioVersion>
+    <AppContainerApplication>true</AppContainerApplication>
+    <ApplicationType>Windows Store</ApplicationType>
+    <ApplicationTypeRevision>8.1</ApplicationTypeRevision>
+    <ProjectName>video_capture_xaml.Windows</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <Import Project="..\video_capture_xaml.Shared\video_capture_xaml.Shared.vcxitems" Label="Shared" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\opencv.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <PackageCertificateKeyFile>video_capture_xaml.Windows_TemporaryKey.pfx</PackageCertificateKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <IgnoreImportLibrary>true</IgnoreImportLibrary>
+    <LibraryPath>$(OPENCV_WINRT_INSTALL_DIR)\WS\8.1\x86\x86\vc12\lib;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <IgnoreImportLibrary>false</IgnoreImportLibrary>
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <ProjectReference>
+      <UseLibraryDependencyInputs>true</UseLibraryDependencyInputs>
+    </ProjectReference>
+    <Link>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories);$(MSBuildThisFileDirectory)</AdditionalIncludeDirectories>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+    </ClCompile>
+    <ProjectReference>
+      <UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
+    </ProjectReference>
+    <Link>
+      <AdditionalDependencies>kernel32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="MainPage.xaml.h">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="MainPage.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest">
+      <SubType>Designer</SubType>
+    </AppxManifest>
+    <None Include="video_capture_xaml.Windows_TemporaryKey.pfx" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\Logo.scale-100.png" />
+    <Image Include="Assets\SmallLogo.scale-100.png" />
+    <Image Include="Assets\StoreLogo.scale-100.png" />
+    <Image Include="Assets\SplashScreen.scale-100.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="MainPage.xaml.cpp">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Text Include="readme.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <Xml Include="Assets\haarcascade_frontalface_alt.xml" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/video_capture_xaml.Windows.vcxproj.filters b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/video_capture_xaml.Windows.vcxproj.filters
new file mode 100644
index 00000000..a15ba63c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/video_capture_xaml.Windows.vcxproj.filters
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Assets">
+      <UniqueIdentifier>{ef9b8c45-f2b7-4eec-a8b4-a9b340be770b}</UniqueIdentifier>
+      <Extensions>bmp;fbx;gif;jpg;jpeg;tga;tiff;tif;png</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="MainPage.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="MainPage.xaml.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="MainPage.xaml.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="video_capture_xaml.Windows_TemporaryKey.pfx" />
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\Logo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SmallLogo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\StoreLogo.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SplashScreen.scale-100.png">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+  <ItemGroup>
+    <Text Include="readme.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <Xml Include="Assets\haarcascade_frontalface_alt.xml">
+      <Filter>Assets</Filter>
+    </Xml>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/video_capture_xaml.Windows_TemporaryKey.pfx b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/video_capture_xaml.Windows_TemporaryKey.pfx
new file mode 100644
index 00000000..2f87643f
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.Windows/video_capture_xaml.Windows_TemporaryKey.pfx differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/Logo.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/Logo.scale-240.png
new file mode 100644
index 00000000..76921ca9
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/Logo.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/SmallLogo.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/SmallLogo.scale-240.png
new file mode 100644
index 00000000..31663012
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/SmallLogo.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/SplashScreen.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/SplashScreen.scale-240.png
new file mode 100644
index 00000000..33f26b33
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/SplashScreen.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/Square71x71Logo.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/Square71x71Logo.scale-240.png
new file mode 100644
index 00000000..cfa54bee
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/Square71x71Logo.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/StoreLogo.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/StoreLogo.scale-240.png
new file mode 100644
index 00000000..47e084b5
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/StoreLogo.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/WideLogo.scale-240.png b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/WideLogo.scale-240.png
new file mode 100644
index 00000000..6249d29d
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Assets/WideLogo.scale-240.png differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/MainPage.xaml b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/MainPage.xaml
new file mode 100644
index 00000000..9aec35c8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/MainPage.xaml
@@ -0,0 +1,26 @@
+<Page x:Class="video_capture_xaml.MainPage"
+      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+      xmlns:local="using:video_capture_xaml"
+      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+      Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
+      mc:Ignorable="d">
+
+    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
+        <TextBlock Margin="20,35,0,0"
+                   HorizontalAlignment="Left"
+                   VerticalAlignment="Top"
+                   FontSize="24"
+                   TextWrapping="Wrap">
+            <Run Text="OpenCV: videoio" />
+            <Run />
+        </TextBlock>
+        <Image Name="cvImage"
+               Width="640"
+               Height="480"
+               Margin="20,100,0,0"
+               HorizontalAlignment="Left"
+               VerticalAlignment="Top" />
+    </Grid>
+</Page>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/MainPage.xaml.cpp b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/MainPage.xaml.cpp
new file mode 100644
index 00000000..7abc535f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/MainPage.xaml.cpp
@@ -0,0 +1,79 @@
+//
+// MainPage.xaml.cpp
+// Implementation of the MainPage class.
+//
+
+#include "pch.h"
+#include "MainPage.xaml.h"
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/features2d.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/videoio/cap_winrt.hpp>
+
+using namespace video_capture_xaml;
+
+using namespace Platform;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Controls::Primitives;
+using namespace Windows::UI::Xaml::Data;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Navigation;
+
+// The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=234238
+
+using namespace ::Windows::Foundation;
+using namespace Windows::UI::Xaml::Media::Imaging;
+
+namespace video_capture_xaml {
+
+    // nb. implemented in main.cpp
+    void cvMain();
+
+    MainPage::MainPage()
+    {
+        InitializeComponent();
+
+        Window::Current->VisibilityChanged += ref new Windows::UI::Xaml::WindowVisibilityChangedEventHandler(this, &video_capture_xaml::MainPage::OnVisibilityChanged);
+
+        // attach XAML elements
+        cv::winrt_setFrameContainer(cvImage);
+
+        // start (1) frame-grabbing loop and (2) message loop
+        //
+        // 1. Function passed as an argument must implement common OCV reading frames
+        //    pattern (see cv::VideoCapture documentation) AND call cv::winrt_imgshow().
+        // 2. Message processing loop required to overcome WinRT container and type
+        //    conversion restrictions. OCV provides default implementation
+        cv::winrt_startMessageLoop(cvMain);
+    }
+
+    void video_capture_xaml::MainPage::OnVisibilityChanged(Platform::Object ^sender,
+        Windows::UI::Core::VisibilityChangedEventArgs ^e)
+    {
+        cv::winrt_onVisibilityChanged(e->Visible);
+    }
+
+    /// <summary>
+    /// Invoked when this page is about to be displayed in a Frame.
+    /// </summary>
+    /// <param name="e">Event data that describes how this page was reached.  The Parameter
+    /// property is typically used to configure the page.</param>
+    void MainPage::OnNavigatedTo(NavigationEventArgs^ e)
+    {
+        (void)e;	// Unused parameter
+
+        // TODO: Prepare page for display here.
+
+        // TODO: If your application contains multiple pages, ensure that you are
+        // handling the hardware Back button by registering for the
+        // Windows::Phone::UI::Input::HardwareButtons.BackPressed event.
+        // If you are using the NavigationHelper provided by some templates,
+        // this event is handled for you.
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/MainPage.xaml.h b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/MainPage.xaml.h
new file mode 100644
index 00000000..b3f13473
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/MainPage.xaml.h
@@ -0,0 +1,28 @@
+//
+// MainPage.xaml.h
+// Declaration of the MainPage class.
+//
+
+#pragma once
+
+#include "MainPage.g.h"
+
+namespace video_capture_xaml
+{
+    /// <summary>
+    /// An empty page that can be used on its own or navigated to within a Frame.
+    /// </summary>
+    public ref class MainPage sealed
+    {
+    public:
+        MainPage();
+
+    protected:
+
+        virtual void OnNavigatedTo(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override;
+
+    private:
+
+        void OnVisibilityChanged(Platform::Object ^sender, Windows::UI::Core::VisibilityChangedEventArgs ^e);
+    };
+}
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Package.appxmanifest b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Package.appxmanifest
new file mode 100644
index 00000000..c03f143e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/Package.appxmanifest
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest" xmlns:m2="http://schemas.microsoft.com/appx/2013/manifest" xmlns:m3="http://schemas.microsoft.com/appx/2014/manifest" xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest">
+
+  <Identity Name="dfafcbf2-a525-4ed0-9b6c-4e8bd5a9c0ba"
+            Publisher="CN=daver_000"
+            Version="1.0.0.0" />
+
+  <mp:PhoneIdentity PhoneProductId="dfafcbf2-a525-4ed0-9b6c-4e8bd5a9c0ba" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
+
+  <Properties>
+    <DisplayName>video_capture_xaml.WindowsPhone</DisplayName>
+    <PublisherDisplayName>daver_000</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+
+  <Prerequisites>
+    <OSMinVersion>6.3.1</OSMinVersion>
+    <OSMaxVersionTested>6.3.1</OSMaxVersionTested>
+  </Prerequisites>
+
+  <Resources>
+    <Resource Language="x-generate"/>
+  </Resources>
+
+  <Applications>
+    <Application Id="App"
+        Executable="$targetnametoken$.exe"
+        EntryPoint="video_capture_xaml_WindowsPhone.App">
+        <m3:VisualElements
+            DisplayName="video_capture_xaml.WindowsPhone"
+            Square150x150Logo="Assets\Logo.png"
+            Square44x44Logo="Assets\SmallLogo.png"
+            Description="video_capture_xaml.WindowsPhone"
+            ForegroundText="light"
+            BackgroundColor="transparent">
+            <m3:DefaultTile Wide310x150Logo="Assets\WideLogo.png" Square71x71Logo="Assets\Square71x71Logo.png"/>
+            <m3:SplashScreen Image="Assets\SplashScreen.png"/>
+            <m3:ApplicationView MinWidth="width320"/> <!--Used in XAML Designer. DO NOT REMOVE-->
+        </m3:VisualElements>
+    </Application>
+  </Applications>
+  <Capabilities>
+    <Capability Name="internetClientServer" />
+    <DeviceCapability Name="webcam" />
+  </Capabilities>
+</Package>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/video_capture_xaml.WindowsPhone.vcxproj b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/video_capture_xaml.WindowsPhone.vcxproj
new file mode 100644
index 00000000..425bb526
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/video_capture_xaml.WindowsPhone.vcxproj
@@ -0,0 +1,147 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{d7a82e7f-1535-4eec-aba9-2c8447669d33}</ProjectGuid>
+    <RootNamespace>video_capture_xaml</RootNamespace>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>12.0</MinimumVisualStudioVersion>
+    <AppContainerApplication>true</AppContainerApplication>
+    <ApplicationType>Windows Phone</ApplicationType>
+    <ApplicationTypeRevision>8.1</ApplicationTypeRevision>
+    <ProjectName>video_capture_xaml.WindowsPhone</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120_wp81</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120_wp81</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120_wp81</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120_wp81</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <Import Project="..\video_capture_xaml.Shared\video_capture_xaml.Shared.vcxitems" Label="Shared" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\opencv.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LibraryPath>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.1\x86\x86\vc12\lib;$(VC_LibraryPath_x86);$(WindowsPhoneSDK_LibraryPath_x86);</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <LibraryPath>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.1\ARM\ARM\vc12\lib;$(VC_LibraryPath_ARM);$(WindowsPhoneSDK_LibraryPath_arm);</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>../../../../../modules/core/include;../../../../../modules/flann/include;../../../../../modules/videoio/include;../../../../../modules/hal/include;../../../../../modules/imgproc/include;../../../../../modules/features2d/include;%(AdditionalIncludeDirectories);$(MSBuildThisFileDirectory)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>opencv_core300d.lib;opencv_imgproc300d.lib;opencv_videoio300d.lib;WindowsPhoneCore.lib;RuntimeObject.lib;PhoneAppModelHost.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+      <AdditionalIncludeDirectories>../../../../../modules/core/include;../../../../../modules/flann/include;../../../../../modules/videoio/include;../../../../../modules/hal/include;../../../../../modules/imgproc/include;../../../../../modules/features2d/include;%(AdditionalIncludeDirectories);$(MSBuildThisFileDirectory)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>opencv_core300d.lib;opencv_imgproc300d.lib;opencv_videoio300d.lib;WindowsPhoneCore.lib;RuntimeObject.lib;PhoneAppModelHost.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="MainPage.xaml.h">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="MainPage.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest">
+      <SubType>Designer</SubType>
+    </AppxManifest>
+  </ItemGroup>
+  <ItemGroup>
+    <Image Include="Assets\Logo.scale-240.png" />
+    <Image Include="Assets\SmallLogo.scale-240.png" />
+    <Image Include="Assets\Square71x71Logo.scale-240.png" />
+    <Image Include="Assets\StoreLogo.scale-240.png" />
+    <Image Include="Assets\SplashScreen.scale-240.png" />
+    <Image Include="Assets\WideLogo.scale-240.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="MainPage.xaml.cpp">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="video_capture_xaml.WindowsPhone_TemporaryKey.pfx" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/video_capture_xaml.WindowsPhone.vcxproj.filters b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/video_capture_xaml.WindowsPhone.vcxproj.filters
new file mode 100644
index 00000000..ce06419c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/video_capture_xaml.WindowsPhone.vcxproj.filters
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Assets">
+      <UniqueIdentifier>{$guid3$}</UniqueIdentifier>
+      <Extensions>bmp;fbx;gif;jpg;jpeg;tga;tiff;tif;png</Extensions>
+    </Filter>
+    <Image Include="Assets\Logo.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SmallLogo.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\Square71x71Logo.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\StoreLogo.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\SplashScreen.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+    <Image Include="Assets\WideLogo.scale-240.png">
+      <Filter>Assets</Filter>
+    </Image>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="MainPage.xaml.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="MainPage.xaml.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest" />
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="MainPage.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="video_capture_xaml.WindowsPhone_TemporaryKey.pfx" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/video_capture_xaml.WindowsPhone_TemporaryKey.pfx b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/video_capture_xaml.WindowsPhone_TemporaryKey.pfx
new file mode 100644
index 00000000..26180417
Binary files /dev/null and b/C++/opencv-4.7.0/samples/winrt_universal/VideoCaptureXAML/video_capture_xaml/video_capture_xaml.WindowsPhone/video_capture_xaml.WindowsPhone_TemporaryKey.pfx differ
diff --git a/C++/opencv-4.7.0/samples/winrt_universal/readme.txt b/C++/opencv-4.7.0/samples/winrt_universal/readme.txt
new file mode 100644
index 00000000..61c1416c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/winrt_universal/readme.txt
@@ -0,0 +1,6 @@
+Building OpenCV WinRT Universal Samples
+=======================================
+
+Samples are created to run against x86 architecture OpenCV binaries.
+
+Please follow the instructions in "platforms/winrt/readme.txt" to generate and build OpenCV for WinRT.
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/ImageManipulation.sln b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/ImageManipulation.sln
new file mode 100644
index 00000000..59e79770
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/ImageManipulation.sln
@@ -0,0 +1,76 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OcvImageManipulation", "PhoneXamlDirect3DApp1\PhoneXamlDirect3DApp1\OcvImageManipulation.csproj", "{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PhoneXamlDirect3DApp1Comp", "PhoneXamlDirect3DApp1\PhoneXamlDirect3DApp1Comp\PhoneXamlDirect3DApp1Comp.vcxproj", "{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|ARM = Debug|ARM
+		Debug|Mixed Platforms = Debug|Mixed Platforms
+		Debug|Win32 = Debug|Win32
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|ARM = Release|ARM
+		Release|Mixed Platforms = Release|Mixed Platforms
+		Release|Win32 = Release|Win32
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|ARM.ActiveCfg = Debug|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|ARM.Build.0 = Debug|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|ARM.Deploy.0 = Debug|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Mixed Platforms.Deploy.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Win32.ActiveCfg = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Win32.Build.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Win32.Deploy.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|x86.ActiveCfg = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|x86.Build.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|x86.Deploy.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Any CPU.Deploy.0 = Release|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|ARM.ActiveCfg = Release|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|ARM.Build.0 = Release|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|ARM.Deploy.0 = Release|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Mixed Platforms.Build.0 = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Mixed Platforms.Deploy.0 = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Win32.ActiveCfg = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Win32.Build.0 = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Win32.Deploy.0 = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|x86.ActiveCfg = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|x86.Build.0 = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|x86.Deploy.0 = Release|x86
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|ARM.ActiveCfg = Debug|ARM
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|ARM.Build.0 = Debug|ARM
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|Win32.Build.0 = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|x86.ActiveCfg = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|x86.Build.0 = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|Any CPU.ActiveCfg = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|ARM.ActiveCfg = Release|ARM
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|ARM.Build.0 = Release|ARM
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|Mixed Platforms.ActiveCfg = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|Mixed Platforms.Build.0 = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|Win32.ActiveCfg = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|Win32.Build.0 = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|x86.ActiveCfg = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml
new file mode 100644
index 00000000..1a9cadac
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml
@@ -0,0 +1,20 @@
+<Application
+    x:Class="PhoneXamlDirect3DApp1.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
+    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone">
+
+    <!--Application Resources-->
+    <Application.Resources>
+        <local:LocalizedStrings xmlns:local="clr-namespace:PhoneXamlDirect3DApp1" x:Key="LocalizedStrings"/>
+    </Application.Resources>
+
+    <Application.ApplicationLifetimeObjects>
+        <!--Required object that handles lifetime events for the application-->
+        <shell:PhoneApplicationService
+            Launching="Application_Launching" Closing="Application_Closing"
+            Activated="Application_Activated" Deactivated="Application_Deactivated"/>
+    </Application.ApplicationLifetimeObjects>
+
+</Application>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs
new file mode 100644
index 00000000..73190e28
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs
@@ -0,0 +1,223 @@
+using System;
+using System.Diagnostics;
+using System.Resources;
+using System.Windows;
+using System.Windows.Markup;
+using System.Windows.Navigation;
+using Microsoft.Phone.Controls;
+using Microsoft.Phone.Shell;
+using PhoneXamlDirect3DApp1.Resources;
+
+namespace PhoneXamlDirect3DApp1
+{
+    public partial class App : Application
+    {
+        /// <summary>
+        /// Provides easy access to the root frame of the Phone Application.
+        /// </summary>
+        /// <returns>The root frame of the Phone Application.</returns>
+        public static PhoneApplicationFrame RootFrame { get; private set; }
+
+        /// <summary>
+        /// Constructor for the Application object.
+        /// </summary>
+        public App()
+        {
+            // Global handler for uncaught exceptions.
+            UnhandledException += Application_UnhandledException;
+
+            // Standard XAML initialization
+            InitializeComponent();
+
+            // Phone-specific initialization
+            InitializePhoneApplication();
+
+            // Language display initialization
+            InitializeLanguage();
+
+            // Show graphics profiling information while debugging.
+            if (Debugger.IsAttached)
+            {
+                // Display the current frame rate counters.
+                Application.Current.Host.Settings.EnableFrameRateCounter = true;
+
+                // Show the areas of the app that are being redrawn in each frame.
+                //Application.Current.Host.Settings.EnableRedrawRegions = true;
+
+                // Enable non-production analysis visualization mode,
+                // which shows areas of a page that are handed off to GPU with a colored overlay.
+                //Application.Current.Host.Settings.EnableCacheVisualization = true;
+
+                // Prevent the screen from turning off while under the debugger by disabling
+                // the application's idle detection.
+                // Caution:- Use this under debug mode only. Application that disables user idle detection will continue to run
+                // and consume battery power when the user is not using the phone.
+                PhoneApplicationService.Current.UserIdleDetectionMode = IdleDetectionMode.Disabled;
+            }
+
+        }
+
+        // Code to execute when the application is launching (eg, from Start)
+        // This code will not execute when the application is reactivated
+        private void Application_Launching(object sender, LaunchingEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is activated (brought to foreground)
+        // This code will not execute when the application is first launched
+        private void Application_Activated(object sender, ActivatedEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is deactivated (sent to background)
+        // This code will not execute when the application is closing
+        private void Application_Deactivated(object sender, DeactivatedEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is closing (eg, user hit Back)
+        // This code will not execute when the application is deactivated
+        private void Application_Closing(object sender, ClosingEventArgs e)
+        {
+        }
+
+        // Code to execute if a navigation fails
+        private void RootFrame_NavigationFailed(object sender, NavigationFailedEventArgs e)
+        {
+            if (Debugger.IsAttached)
+            {
+                // A navigation has failed; break into the debugger
+                Debugger.Break();
+            }
+        }
+
+        // Code to execute on Unhandled Exceptions
+        private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
+        {
+            if (Debugger.IsAttached)
+            {
+                // An unhandled exception has occurred; break into the debugger
+                Debugger.Break();
+            }
+        }
+
+        #region Phone application initialization
+
+        // Avoid double-initialization
+        private bool phoneApplicationInitialized = false;
+
+        // Do not add any additional code to this method
+        private void InitializePhoneApplication()
+        {
+            if (phoneApplicationInitialized)
+                return;
+
+            // Create the frame but don't set it as RootVisual yet; this allows the splash
+            // screen to remain active until the application is ready to render.
+            RootFrame = new PhoneApplicationFrame();
+            RootFrame.Navigated += CompleteInitializePhoneApplication;
+
+            // Handle navigation failures
+            RootFrame.NavigationFailed += RootFrame_NavigationFailed;
+
+            // Handle reset requests for clearing the backstack
+            RootFrame.Navigated += CheckForResetNavigation;
+
+            // Ensure we don't initialize again
+            phoneApplicationInitialized = true;
+        }
+
+        // Do not add any additional code to this method
+        private void CompleteInitializePhoneApplication(object sender, NavigationEventArgs e)
+        {
+            // Set the root visual to allow the application to render
+            if (RootVisual != RootFrame)
+                RootVisual = RootFrame;
+
+            // Remove this handler since it is no longer needed
+            RootFrame.Navigated -= CompleteInitializePhoneApplication;
+        }
+
+        private void CheckForResetNavigation(object sender, NavigationEventArgs e)
+        {
+            // If the app has received a 'reset' navigation, then we need to check
+            // on the next navigation to see if the page stack should be reset
+            if (e.NavigationMode == NavigationMode.Reset)
+                RootFrame.Navigated += ClearBackStackAfterReset;
+        }
+
+        private void ClearBackStackAfterReset(object sender, NavigationEventArgs e)
+        {
+            // Unregister the event so it doesn't get called again
+            RootFrame.Navigated -= ClearBackStackAfterReset;
+
+            // Only clear the stack for 'new' (forward) and 'refresh' navigations
+            if (e.NavigationMode != NavigationMode.New && e.NavigationMode != NavigationMode.Refresh)
+                return;
+
+            // For UI consistency, clear the entire page stack
+            while (RootFrame.RemoveBackEntry() != null)
+            {
+                ; // do nothing
+            }
+        }
+
+        #endregion
+
+        // Initialize the app's font and flow direction as defined in its localized resource strings.
+        //
+        // To ensure that the font of your application is aligned with its supported languages and that the
+        // FlowDirection for each of those languages follows its traditional direction, ResourceLanguage
+        // and ResourceFlowDirection should be initialized in each resx file to match these values with that
+        // file's culture. For example:
+        //
+        // AppResources.es-ES.resx
+        //    ResourceLanguage's value should be "es-ES"
+        //    ResourceFlowDirection's value should be "LeftToRight"
+        //
+        // AppResources.ar-SA.resx
+        //     ResourceLanguage's value should be "ar-SA"
+        //     ResourceFlowDirection's value should be "RightToLeft"
+        //
+        // For more info on localizing Windows Phone apps see http://go.microsoft.com/fwlink/?LinkId=262072.
+        //
+        private void InitializeLanguage()
+        {
+            try
+            {
+                // Set the font to match the display language defined by the
+                // ResourceLanguage resource string for each supported language.
+                //
+                // Fall back to the font of the neutral language if the Display
+                // language of the phone is not supported.
+                //
+                // If a compiler error is hit then ResourceLanguage is missing from
+                // the resource file.
+                RootFrame.Language = XmlLanguage.GetLanguage(AppResources.ResourceLanguage);
+
+                // Set the FlowDirection of all elements under the root frame based
+                // on the ResourceFlowDirection resource string for each
+                // supported language.
+                //
+                // If a compiler error is hit then ResourceFlowDirection is missing from
+                // the resource file.
+                FlowDirection flow = (FlowDirection)Enum.Parse(typeof(FlowDirection), AppResources.ResourceFlowDirection);
+                RootFrame.FlowDirection = flow;
+            }
+            catch
+            {
+                // If an exception is caught here it is most likely due to either
+                // ResourceLanguage not being correctly set to a supported language
+                // code or ResourceFlowDirection is set to a value other than LeftToRight
+                // or RightToLeft.
+
+                if (Debugger.IsAttached)
+                {
+                    Debugger.Break();
+                }
+
+                throw;
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/AlignmentGrid.png b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/AlignmentGrid.png
new file mode 100644
index 00000000..f7d2e978
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/AlignmentGrid.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/ApplicationIcon.png b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/ApplicationIcon.png
new file mode 100644
index 00000000..7d95d4e0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/ApplicationIcon.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileLarge.png b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileLarge.png
new file mode 100644
index 00000000..e0c59ac0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileLarge.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileMedium.png b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileMedium.png
new file mode 100644
index 00000000..e93b89d6
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileMedium.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileSmall.png b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileSmall.png
new file mode 100644
index 00000000..550b1b5e
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileSmall.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileMediumLarge.png b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileMediumLarge.png
new file mode 100644
index 00000000..686e6b53
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileMediumLarge.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileSmall.png b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileSmall.png
new file mode 100644
index 00000000..d4b5ede1
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileSmall.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/LocalizedStrings.cs b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/LocalizedStrings.cs
new file mode 100644
index 00000000..509836a9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/LocalizedStrings.cs
@@ -0,0 +1,14 @@
+using PhoneXamlDirect3DApp1.Resources;
+
+namespace PhoneXamlDirect3DApp1
+{
+    /// <summary>
+    /// Provides access to string resources.
+    /// </summary>
+    public class LocalizedStrings
+    {
+        private static AppResources _localizedResources = new AppResources();
+
+        public AppResources LocalizedResources { get { return _localizedResources; } }
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml
new file mode 100644
index 00000000..f5bc9eae
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml
@@ -0,0 +1,56 @@
+<phone:PhoneApplicationPage x:Class="PhoneXamlDirect3DApp1.MainPage"
+                            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+                            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+                            xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
+                            xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
+                            FontFamily="{StaticResource PhoneFontFamilyNormal}"
+                            FontSize="{StaticResource PhoneFontSizeNormal}"
+                            Foreground="{StaticResource PhoneForegroundBrush}"
+                            Orientation="Portrait"
+                            SupportedOrientations="Portrait"
+                            shell:SystemTray.IsVisible="True"
+                            mc:Ignorable="d">
+
+    <!--  LayoutRoot is the root grid where all page content is placed  -->
+    <Grid x:Name="LayoutRoot" Background="Transparent">
+        <DrawingSurface x:Name="DrawingSurface" Loaded="DrawingSurface_Loaded" />
+        <StackPanel Margin="40">
+            <RadioButton x:Name="Normal"
+                         Checked="RadioButton_Checked"
+                         Content="Normal"
+                         GroupName="Group1"
+                         IsChecked="True" />
+            <RadioButton x:Name="Gray"
+                         Checked="RadioButton_Checked"
+                         Content="Gray"
+                         GroupName="Group1" />
+            <RadioButton x:Name="Canny"
+                         Checked="RadioButton_Checked"
+                         Content="Canny"
+                         GroupName="Group1" />
+            <RadioButton x:Name="Sepia"
+                         Checked="RadioButton_Checked"
+                         Content="Sepia"
+                         GroupName="Group1" />
+            <RadioButton x:Name="Features"
+                         Checked="RadioButton_Checked"
+                         Content="Features"
+                         GroupName="Group1" />
+
+            <StackPanel Margin="20,0,0,0" Orientation="Horizontal">
+                <TextBlock Text="Memory: " />
+                <TextBlock x:Name="MemoryTextBlock" />
+                <TextBlock Text=" MB" />
+            </StackPanel>
+            <StackPanel Margin="20,0,0,0" Orientation="Horizontal">
+                <TextBlock Text="Peak Memory: " />
+                <TextBlock x:Name="PeakMemoryTextBlock" />
+                <TextBlock Text=" MB" />
+
+            </StackPanel>
+        </StackPanel>
+    </Grid>
+
+</phone:PhoneApplicationPage>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml.cs b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml.cs
new file mode 100644
index 00000000..265c6006
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml.cs
@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Navigation;
+using Microsoft.Phone.Controls;
+using Microsoft.Phone.Shell;
+using PhoneXamlDirect3DApp1Comp;
+using Microsoft.Phone.Tasks;
+using System.Windows.Media.Imaging;
+using System.Threading;
+using System.Windows.Resources;
+using System.IO;
+using  System.Runtime.InteropServices.WindowsRuntime;
+using Microsoft.Xna.Framework.Media;
+using System.Windows.Threading;
+using Microsoft.Phone.Info;
+
+namespace PhoneXamlDirect3DApp1
+{
+    public partial class MainPage : PhoneApplicationPage
+    {
+        private Direct3DInterop m_d3dInterop = new Direct3DInterop();
+        private DispatcherTimer m_timer;
+
+        // Constructor
+        public MainPage()
+        {
+            InitializeComponent();
+            m_timer = new DispatcherTimer();
+            m_timer.Interval = new TimeSpan(0, 0, 1);
+            m_timer.Tick += new EventHandler(timer_Tick);
+            m_timer.Start();
+        }
+
+        private void DrawingSurface_Loaded(object sender, RoutedEventArgs e)
+        {
+            // Set window bounds in dips
+            m_d3dInterop.WindowBounds = new Windows.Foundation.Size(
+                (float)DrawingSurface.ActualWidth,
+                (float)DrawingSurface.ActualHeight
+                );
+
+            // Set native resolution in pixels
+            m_d3dInterop.NativeResolution = new Windows.Foundation.Size(
+                (float)Math.Floor(DrawingSurface.ActualWidth * Application.Current.Host.Content.ScaleFactor / 100.0f + 0.5f),
+                (float)Math.Floor(DrawingSurface.ActualHeight * Application.Current.Host.Content.ScaleFactor / 100.0f + 0.5f)
+                );
+
+            // Set render resolution to the full native resolution
+            m_d3dInterop.RenderResolution = m_d3dInterop.NativeResolution;
+
+            // Hook-up native component to DrawingSurface
+            DrawingSurface.SetContentProvider(m_d3dInterop.CreateContentProvider());
+            DrawingSurface.SetManipulationHandler(m_d3dInterop);
+        }
+
+        private void RadioButton_Checked(object sender, RoutedEventArgs e)
+        {
+            RadioButton rb = sender as RadioButton;
+            switch (rb.Name)
+            {
+                case "Normal":
+                    m_d3dInterop.SetAlgorithm(OCVFilterType.ePreview);
+                    break;
+
+                case "Gray":
+                    m_d3dInterop.SetAlgorithm(OCVFilterType.eGray);
+                    break;
+
+                case "Canny":
+                    m_d3dInterop.SetAlgorithm(OCVFilterType.eCanny);
+                    break;
+
+                case "Sepia":
+                    m_d3dInterop.SetAlgorithm(OCVFilterType.eSepia);
+                    break;
+
+                case "Features":
+                    m_d3dInterop.SetAlgorithm(OCVFilterType.eFindFeatures);
+                    break;
+            }
+        }
+
+        private void timer_Tick(object sender, EventArgs e)
+        {
+            try
+            {
+                // These are TextBlock controls that are created in the page’s XAML file.
+                float value = DeviceStatus.ApplicationCurrentMemoryUsage / (1024.0f * 1024.0f) ;
+                MemoryTextBlock.Text = value.ToString();
+                value = DeviceStatus.ApplicationPeakMemoryUsage / (1024.0f * 1024.0f);
+                PeakMemoryTextBlock.Text = value.ToString();
+            }
+            catch (Exception ex)
+            {
+                MemoryTextBlock.Text = ex.Message;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/OcvImageManipulation.csproj b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/OcvImageManipulation.csproj
new file mode 100644
index 00000000..e53aa1a2
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/OcvImageManipulation.csproj
@@ -0,0 +1,166 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>10.0.20506</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}</ProjectGuid>
+    <ProjectTypeGuids>{C089C8C0-30E0-4E22-80C0-CE093F111A43};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>PhoneXamlDirect3DApp1</RootNamespace>
+    <AssemblyName>PhoneXamlDirect3DApp1</AssemblyName>
+    <TargetFrameworkIdentifier>WindowsPhone</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v8.0</TargetFrameworkVersion>
+    <SilverlightVersion>$(TargetFrameworkVersion)</SilverlightVersion>
+    <SilverlightApplication>true</SilverlightApplication>
+    <SupportedCultures>
+    </SupportedCultures>
+    <XapOutputs>true</XapOutputs>
+    <GenerateSilverlightManifest>true</GenerateSilverlightManifest>
+    <XapFilename>PhoneXamlDirect3DApp1_$(Configuration)_$(Platform).xap</XapFilename>
+    <SilverlightManifestTemplate>Properties\AppManifest.xml</SilverlightManifestTemplate>
+    <SilverlightAppEntry>PhoneXamlDirect3DApp1.App</SilverlightAppEntry>
+    <ValidateXaml>true</ValidateXaml>
+    <MinimumVisualStudioVersion>11.0</MinimumVisualStudioVersion>
+    <ThrowErrorsInValidation>true</ThrowErrorsInValidation>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>Bin\Debug</OutputPath>
+    <DefineConstants>DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>Bin\Release</OutputPath>
+    <DefineConstants>TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>Bin\x86\Debug</OutputPath>
+    <DefineConstants>DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>Bin\x86\Release</OutputPath>
+    <DefineConstants>TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|ARM' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>Bin\ARM\Debug</OutputPath>
+    <DefineConstants>DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|ARM' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>Bin\ARM\Release</OutputPath>
+    <DefineConstants>TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="App.xaml.cs">
+      <DependentUpon>App.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="LocalizedStrings.cs" />
+    <Compile Include="MainPage.xaml.cs">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Resources\AppResources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>AppResources.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </ApplicationDefinition>
+    <Page Include="MainPage.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Properties\AppManifest.xml" />
+    <None Include="Properties\WMAppManifest.xml">
+      <SubType>Designer</SubType>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Assets\AlignmentGrid.png" />
+    <Content Include="Assets\ApplicationIcon.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\FlipCycleTileLarge.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\FlipCycleTileMedium.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\FlipCycleTileSmall.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\IconicTileMediumLarge.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\IconicTileSmall.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="SplashScreenImage.jpg" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\PhoneXamlDirect3DApp1Comp\PhoneXamlDirect3DApp1Comp.vcxproj">
+      <Name>PhoneXamlDirect3DApp1Comp</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Resources\AppResources.resx">
+      <Generator>PublicResXFileCodeGenerator</Generator>
+      <LastGenOutput>AppResources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\$(TargetFrameworkIdentifier)\$(TargetFrameworkVersion)\Microsoft.$(TargetFrameworkIdentifier).$(TargetFrameworkVersion).Overrides.targets" />
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\$(TargetFrameworkIdentifier)\$(TargetFrameworkVersion)\Microsoft.$(TargetFrameworkIdentifier).CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <ProjectExtensions />
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AppManifest.xml b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AppManifest.xml
new file mode 100644
index 00000000..6712a117
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AppManifest.xml
@@ -0,0 +1,6 @@
+<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+>
+    <Deployment.Parts>
+    </Deployment.Parts>
+</Deployment>
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AssemblyInfo.cs b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..a22da51b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AssemblyInfo.cs
@@ -0,0 +1,37 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Resources;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("PhoneXamlDirect3DApp1")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("PhoneXamlDirect3DApp1")]
+[assembly: AssemblyCopyright("Copyright ©  2013")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("8ca838f9-f7c6-4550-9b89-59e915a2cddb")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: NeutralResourcesLanguageAttribute("en-US")]
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/WMAppManifest.xml b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/WMAppManifest.xml
new file mode 100644
index 00000000..acca43c9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/WMAppManifest.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Deployment xmlns="http://schemas.microsoft.com/windowsphone/2012/deployment" AppPlatformVersion="8.0">
+  <DefaultLanguage xmlns="" code="en-US" />
+  <App xmlns="" ProductID="{cc734b3d-d8f2-4528-b223-0e7b8a4f6cc7}" Title="OCVImageManipulation" RuntimeType="Silverlight" Version="1.0.0.0" Genre="apps.normal" Author="Microsoft Open Technologies, Inc." Description="Sample description" Publisher="Microsoft Open Technologies, Inc." PublisherID="{4029c95e-d442-45ca-b556-33d7e3bde613}">
+    <IconPath IsRelative="true" IsResource="false">Assets\ApplicationIcon.png</IconPath>
+    <Capabilities>
+      <Capability Name="ID_CAP_SENSORS" />
+      <Capability Name="ID_CAP_WEBBROWSERCOMPONENT" />
+      <Capability Name="ID_CAP_MEDIALIB_PLAYBACK" />
+      <Capability Name="ID_CAP_MEDIALIB_PHOTO" />
+      <Capability Name="ID_CAP_MEDIALIB_AUDIO" />
+      <Capability Name="ID_CAP_NETWORKING" />
+      <Capability Name="ID_CAP_ISV_CAMERA" />
+    </Capabilities>
+    <Tasks>
+      <DefaultTask Name="_default" NavigationPage="MainPage.xaml" />
+    </Tasks>
+    <Tokens>
+      <PrimaryToken TokenID="PhoneXamlDirect3DApp1Token" TaskName="_default">
+        <TemplateFlip>
+          <SmallImageURI IsRelative="true" IsResource="false">Assets\Tiles\FlipCycleTileSmall.png</SmallImageURI>
+          <Count>0</Count>
+          <BackgroundImageURI IsRelative="true" IsResource="false">Assets\Tiles\FlipCycleTileMedium.png</BackgroundImageURI>
+          <Title>OCVImageManipulation</Title>
+          <BackContent>
+          </BackContent>
+          <BackBackgroundImageURI>
+          </BackBackgroundImageURI>
+          <BackTitle>
+          </BackTitle>
+          <DeviceLockImageURI>
+          </DeviceLockImageURI>
+          <HasLarge>
+          </HasLarge>
+        </TemplateFlip>
+      </PrimaryToken>
+    </Tokens>
+    <ScreenResolutions>
+      <ScreenResolution Name="ID_RESOLUTION_WVGA" />
+      <ScreenResolution Name="ID_RESOLUTION_WXGA" />
+      <ScreenResolution Name="ID_RESOLUTION_HD720P" />
+    </ScreenResolutions>
+  </App>
+</Deployment>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.Designer.cs b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.Designer.cs
new file mode 100644
index 00000000..e34b684a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.Designer.cs
@@ -0,0 +1,105 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.17626
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace PhoneXamlDirect3DApp1.Resources
+{
+    using System;
+
+
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    public class AppResources
+    {
+
+        private static global::System.Resources.ResourceManager resourceMan;
+
+        private static global::System.Globalization.CultureInfo resourceCulture;
+
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal AppResources()
+        {
+        }
+
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Resources.ResourceManager ResourceManager
+        {
+            get
+            {
+                if (object.ReferenceEquals(resourceMan, null))
+                {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("PhoneXamlDirect3DApp1.Resources.AppResources", typeof(AppResources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Globalization.CultureInfo Culture
+        {
+            get
+            {
+                return resourceCulture;
+            }
+            set
+            {
+                resourceCulture = value;
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to LeftToRight.
+        /// </summary>
+        public static string ResourceFlowDirection
+        {
+            get
+            {
+                return ResourceManager.GetString("ResourceFlowDirection", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to us-EN.
+        /// </summary>
+        public static string ResourceLanguage
+        {
+            get
+            {
+                return ResourceManager.GetString("ResourceLanguage", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to MY APPLICATION.
+        /// </summary>
+        public static string ApplicationTitle
+        {
+            get
+            {
+                return ResourceManager.GetString("ApplicationTitle", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.resx b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.resx
new file mode 100644
index 00000000..38c1356d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.resx
@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ResourceFlowDirection" xml:space="preserve">
+    <value>LeftToRight</value>
+    <comment>Controls the FlowDirection for all elements in the RootFrame. Set to the traditional direction of this resource file's language</comment>
+  </data>
+  <data name="ResourceLanguage" xml:space="preserve">
+    <value>en-US</value>
+    <comment>Controls the Language and ensures that the font for all elements in the RootFrame aligns with the app's language. Set to the language code of this resource file's language.</comment>
+  </data>
+  <data name="ApplicationTitle" xml:space="preserve">
+    <value>MY APPLICATION</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/SplashScreenImage.jpg b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/SplashScreenImage.jpg
new file mode 100644
index 00000000..566fbb05
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/SplashScreenImage.jpg differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/BasicTimer.h b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/BasicTimer.h
new file mode 100644
index 00000000..640b6cb9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/BasicTimer.h
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <wrl.h>
+
+// Helper class for basic timing.
+ref class BasicTimer sealed
+{
+public:
+    // Initializes internal timer values.
+    BasicTimer()
+    {
+        if (!QueryPerformanceFrequency(&m_frequency))
+        {
+            throw ref new Platform::FailureException();
+        }
+        Reset();
+    }
+
+    // Reset the timer to initial values.
+    void Reset()
+    {
+        Update();
+        m_startTime = m_currentTime;
+        m_total = 0.0f;
+        m_delta = 1.0f / 60.0f;
+    }
+
+    // Update the timer's internal values.
+    void Update()
+    {
+        if (!QueryPerformanceCounter(&m_currentTime))
+        {
+            throw ref new Platform::FailureException();
+        }
+
+        m_total = static_cast<float>(
+            static_cast<double>(m_currentTime.QuadPart - m_startTime.QuadPart) /
+            static_cast<double>(m_frequency.QuadPart)
+            );
+
+        if (m_lastTime.QuadPart == m_startTime.QuadPart)
+        {
+            // If the timer was just reset, report a time delta equivalent to 60Hz frame time.
+            m_delta = 1.0f / 60.0f;
+        }
+        else
+        {
+            m_delta = static_cast<float>(
+                static_cast<double>(m_currentTime.QuadPart - m_lastTime.QuadPart) /
+                static_cast<double>(m_frequency.QuadPart)
+                );
+        }
+
+        m_lastTime = m_currentTime;
+    }
+
+    // Duration in seconds between the last call to Reset() and the last call to Update().
+    property float Total
+    {
+        float get() { return m_total; }
+    }
+
+    // Duration in seconds between the previous two calls to Update().
+    property float Delta
+    {
+        float get() { return m_delta; }
+    }
+
+private:
+    LARGE_INTEGER m_frequency;
+    LARGE_INTEGER m_currentTime;
+    LARGE_INTEGER m_startTime;
+    LARGE_INTEGER m_lastTime;
+    float m_total;
+    float m_delta;
+};
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.cpp b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.cpp
new file mode 100644
index 00000000..351629e1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.cpp
@@ -0,0 +1,162 @@
+#include "pch.h"
+#include "Direct3DBase.h"
+
+using namespace DirectX;
+using namespace Microsoft::WRL;
+using namespace Windows::UI::Core;
+using namespace Windows::Foundation;
+using namespace Windows::Graphics::Display;
+
+// Constructor.
+Direct3DBase::Direct3DBase()
+{
+}
+
+// Initialize the Direct3D resources required to run.
+void Direct3DBase::Initialize()
+{
+    CreateDeviceResources();
+}
+
+// These are the resources that depend on the device.
+void Direct3DBase::CreateDeviceResources()
+{
+    // This flag adds support for surfaces with a different color channel ordering
+    // than the API default. It is required for compatibility with Direct2D.
+    UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
+
+#if defined(_DEBUG)
+    // If the project is in a debug build, enable debugging via SDK Layers with this flag.
+    creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
+#endif
+
+    // This array defines the set of DirectX hardware feature levels this app will support.
+    // Note the ordering should be preserved.
+    // Don't forget to declare your application's minimum required feature level in its
+    // description.  All applications are assumed to support 9.1 unless otherwise stated.
+    D3D_FEATURE_LEVEL featureLevels[] =
+    {
+        D3D_FEATURE_LEVEL_11_1,
+        D3D_FEATURE_LEVEL_11_0,
+        D3D_FEATURE_LEVEL_10_1,
+        D3D_FEATURE_LEVEL_10_0,
+        D3D_FEATURE_LEVEL_9_3
+    };
+
+    // Create the Direct3D 11 API device object and a corresponding context.
+    ComPtr<ID3D11Device> device;
+    ComPtr<ID3D11DeviceContext> context;
+    DX::ThrowIfFailed(
+        D3D11CreateDevice(
+            nullptr, // Specify nullptr to use the default adapter.
+            D3D_DRIVER_TYPE_HARDWARE,
+            nullptr,
+            creationFlags, // Set set debug and Direct2D compatibility flags.
+            featureLevels, // List of feature levels this app can support.
+            ARRAYSIZE(featureLevels),
+            D3D11_SDK_VERSION, // Always set this to D3D11_SDK_VERSION.
+            &device, // Returns the Direct3D device created.
+            &m_featureLevel, // Returns feature level of device created.
+            &context // Returns the device immediate context.
+            )
+        );
+
+    // Get the Direct3D 11.1 API device and context interfaces.
+    DX::ThrowIfFailed(
+        device.As(&m_d3dDevice)
+        );
+
+    DX::ThrowIfFailed(
+        context.As(&m_d3dContext)
+        );
+}
+
+// Allocate all memory resources that depend on the window size.
+void Direct3DBase::CreateWindowSizeDependentResources()
+{
+    // Create a descriptor for the render target buffer.
+    CD3D11_TEXTURE2D_DESC renderTargetDesc(
+        DXGI_FORMAT_B8G8R8A8_UNORM,
+        static_cast<UINT>(m_renderTargetSize.Width),
+        static_cast<UINT>(m_renderTargetSize.Height),
+        1,
+        1,
+        D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE
+        );
+    renderTargetDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX | D3D11_RESOURCE_MISC_SHARED_NTHANDLE;
+
+    // Allocate a 2-D surface as the render target buffer.
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateTexture2D(
+            &renderTargetDesc,
+            nullptr,
+            &m_renderTarget
+            )
+        );
+
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateRenderTargetView(
+            m_renderTarget.Get(),
+            nullptr,
+            &m_renderTargetView
+            )
+        );
+
+    // Create a depth stencil view.
+    CD3D11_TEXTURE2D_DESC depthStencilDesc(
+        DXGI_FORMAT_D24_UNORM_S8_UINT,
+        static_cast<UINT>(m_renderTargetSize.Width),
+        static_cast<UINT>(m_renderTargetSize.Height),
+        1,
+        1,
+        D3D11_BIND_DEPTH_STENCIL
+        );
+
+    ComPtr<ID3D11Texture2D> depthStencil;
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateTexture2D(
+            &depthStencilDesc,
+            nullptr,
+            &depthStencil
+            )
+        );
+
+    CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D);
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateDepthStencilView(
+            depthStencil.Get(),
+            &depthStencilViewDesc,
+            &m_depthStencilView
+            )
+        );
+
+    // Set the rendering viewport to target the entire window.
+    CD3D11_VIEWPORT viewport(
+        0.0f,
+        0.0f,
+        m_renderTargetSize.Width,
+        m_renderTargetSize.Height
+        );
+
+    m_d3dContext->RSSetViewports(1, &viewport);
+}
+
+void Direct3DBase::UpdateForRenderResolutionChange(float width, float height)
+{
+    m_renderTargetSize.Width = width;
+    m_renderTargetSize.Height = height;
+
+    ID3D11RenderTargetView* nullViews[] = {nullptr};
+    m_d3dContext->OMSetRenderTargets(ARRAYSIZE(nullViews), nullViews, nullptr);
+    m_renderTarget = nullptr;
+    m_renderTargetView = nullptr;
+    m_depthStencilView = nullptr;
+    m_d3dContext->Flush();
+    CreateWindowSizeDependentResources();
+}
+
+void Direct3DBase::UpdateForWindowSizeChange(float width, float height)
+{
+    m_windowBounds.Width  = width;
+    m_windowBounds.Height = height;
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.h b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.h
new file mode 100644
index 00000000..c6f387c1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "DirectXHelper.h"
+
+// Helper class that initializes DirectX APIs for 3D rendering.
+ref class Direct3DBase abstract
+{
+internal:
+    Direct3DBase();
+
+public:
+    virtual void Initialize();
+    virtual void CreateDeviceResources();
+    virtual void CreateWindowSizeDependentResources();
+    virtual void UpdateForRenderResolutionChange(float width, float height);
+    virtual void UpdateForWindowSizeChange(float width, float height);
+    virtual void Render() = 0;
+
+internal:
+    virtual ID3D11Texture2D* GetTexture()
+    {
+        return m_renderTarget.Get();
+    }
+
+protected private:
+    // Direct3D Objects.
+    Microsoft::WRL::ComPtr<ID3D11Device1> m_d3dDevice;
+    Microsoft::WRL::ComPtr<ID3D11DeviceContext1> m_d3dContext;
+    Microsoft::WRL::ComPtr<ID3D11Texture2D> m_renderTarget;
+    Microsoft::WRL::ComPtr<ID3D11RenderTargetView> m_renderTargetView;
+    Microsoft::WRL::ComPtr<ID3D11DepthStencilView> m_depthStencilView;
+
+    // Cached renderer properties.
+    D3D_FEATURE_LEVEL m_featureLevel;
+    Windows::Foundation::Size m_renderTargetSize;
+    Windows::Foundation::Rect m_windowBounds;
+};
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.cpp b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.cpp
new file mode 100644
index 00000000..f1fae311
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.cpp
@@ -0,0 +1,77 @@
+#include "pch.h"
+#include "Direct3DContentProvider.h"
+
+using namespace PhoneXamlDirect3DApp1Comp;
+
+Direct3DContentProvider::Direct3DContentProvider(Direct3DInterop^ controller) :
+    m_controller(controller)
+{
+    m_controller->RequestAdditionalFrame += ref new RequestAdditionalFrameHandler([=] ()
+        {
+            if (m_host)
+            {
+                m_host->RequestAdditionalFrame();
+            }
+        });
+
+    m_controller->RecreateSynchronizedTexture += ref new RecreateSynchronizedTextureHandler([=] ()
+        {
+            if (m_host)
+            {
+                m_host->CreateSynchronizedTexture(m_controller->GetTexture(), &m_synchronizedTexture);
+            }
+        });
+}
+
+// IDrawingSurfaceContentProviderNative interface
+HRESULT Direct3DContentProvider::Connect(_In_ IDrawingSurfaceRuntimeHostNative* host)
+{
+    m_host = host;
+
+    return m_controller->Connect(host);
+}
+
+void Direct3DContentProvider::Disconnect()
+{
+    m_controller->Disconnect();
+    m_host = nullptr;
+    m_synchronizedTexture = nullptr;
+}
+
+HRESULT Direct3DContentProvider::PrepareResources(_In_ const LARGE_INTEGER* presentTargetTime, _Out_ BOOL* contentDirty)
+{
+    return m_controller->PrepareResources(presentTargetTime, contentDirty);
+}
+
+HRESULT Direct3DContentProvider::GetTexture(_In_ const DrawingSurfaceSizeF* size, _Out_ IDrawingSurfaceSynchronizedTextureNative** synchronizedTexture, _Out_ DrawingSurfaceRectF* textureSubRectangle)
+{
+    HRESULT hr = S_OK;
+
+    if (!m_synchronizedTexture)
+    {
+        hr = m_host->CreateSynchronizedTexture(m_controller->GetTexture(), &m_synchronizedTexture);
+    }
+
+    // Set output parameters.
+    textureSubRectangle->left = 0.0f;
+    textureSubRectangle->top = 0.0f;
+    textureSubRectangle->right = static_cast<FLOAT>(size->width);
+    textureSubRectangle->bottom = static_cast<FLOAT>(size->height);
+
+    m_synchronizedTexture.CopyTo(synchronizedTexture);
+
+    // Draw to the texture.
+    if (SUCCEEDED(hr))
+    {
+        hr = m_synchronizedTexture->BeginDraw();
+
+        if (SUCCEEDED(hr))
+        {
+            hr = m_controller->GetTexture(size, synchronizedTexture, textureSubRectangle);
+        }
+
+        m_synchronizedTexture->EndDraw();
+    }
+
+    return hr;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.h b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.h
new file mode 100644
index 00000000..13dd2d70
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "pch.h"
+#include <wrl/module.h>
+#include <Windows.Phone.Graphics.Interop.h>
+#include <DrawingSurfaceNative.h>
+
+#include "Direct3DInterop.h"
+
+class Direct3DContentProvider : public Microsoft::WRL::RuntimeClass<
+        Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::WinRtClassicComMix>,
+        ABI::Windows::Phone::Graphics::Interop::IDrawingSurfaceContentProvider,
+        IDrawingSurfaceContentProviderNative>
+{
+public:
+    Direct3DContentProvider(PhoneXamlDirect3DApp1Comp::Direct3DInterop^ controller);
+
+    void ReleaseD3DResources();
+
+    // IDrawingSurfaceContentProviderNative
+    HRESULT STDMETHODCALLTYPE Connect(_In_ IDrawingSurfaceRuntimeHostNative* host);
+    void STDMETHODCALLTYPE Disconnect();
+
+    HRESULT STDMETHODCALLTYPE PrepareResources(_In_ const LARGE_INTEGER* presentTargetTime, _Out_ BOOL* contentDirty);
+    HRESULT STDMETHODCALLTYPE GetTexture(_In_ const DrawingSurfaceSizeF* size, _Out_ IDrawingSurfaceSynchronizedTextureNative** synchronizedTexture, _Out_ DrawingSurfaceRectF* textureSubRectangle);
+
+private:
+    HRESULT InitializeTexture(_In_ const DrawingSurfaceSizeF* size);
+
+    PhoneXamlDirect3DApp1Comp::Direct3DInterop^ m_controller;
+    Microsoft::WRL::ComPtr<IDrawingSurfaceRuntimeHostNative> m_host;
+    Microsoft::WRL::ComPtr<IDrawingSurfaceSynchronizedTextureNative> m_synchronizedTexture;
+};
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.cpp b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.cpp
new file mode 100644
index 00000000..c319b4c0
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.cpp
@@ -0,0 +1,351 @@
+#include "pch.h"
+#include "Direct3DInterop.h"
+#include "Direct3DContentProvider.h"
+#include <windows.storage.streams.h>
+#include <wrl.h>
+#include <robuffer.h>
+#include <opencv2\core.hpp>
+#include <opencv2\imgproc.hpp>
+#include <opencv2\features2d.hpp>
+#include <algorithm>
+
+using namespace Windows::Storage::Streams;
+using namespace Microsoft::WRL;
+using namespace Windows::Foundation;
+using namespace Windows::UI::Core;
+using namespace Microsoft::WRL;
+using namespace Windows::Phone::Graphics::Interop;
+using namespace Windows::Phone::Input::Interop;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::Phone::Media::Capture;
+
+#if !defined(_M_ARM)
+#pragma message("warning: Direct3DInterop.cpp: Windows Phone camera code does not run in the emulator.")
+#pragma message("warning: Direct3DInterop.cpp: Please compile as an ARM build and run on a device.")
+#endif
+
+namespace PhoneXamlDirect3DApp1Comp
+{
+    // Called each time a preview frame is available
+    void CameraCapturePreviewSink::OnFrameAvailable(
+        DXGI_FORMAT format,
+        UINT width,
+        UINT height,
+        BYTE* pixels
+        )
+    {
+        m_Direct3dInterop->UpdateFrame(pixels, width, height);
+    }
+
+    // Called each time a captured frame is available
+    void CameraCaptureSampleSink::OnSampleAvailable(
+        ULONGLONG hnsPresentationTime,
+        ULONGLONG hnsSampleDuration,
+        DWORD cbSample,
+        BYTE* pSample)
+    {
+
+
+    }
+
+    Direct3DInterop::Direct3DInterop()
+        : m_algorithm(OCVFilterType::ePreview)
+        , m_contentDirty(false)
+        , m_backFrame(nullptr)
+        , m_frontFrame(nullptr)
+    {
+    }
+
+    bool Direct3DInterop::SwapFrames()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if(m_backFrame != nullptr)
+        {
+            std::swap(m_backFrame, m_frontFrame);
+            return true;
+        }
+        return false;
+    }
+
+    void Direct3DInterop::UpdateFrame(byte* buffer,int width,int height)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if(m_backFrame == nullptr)
+        {
+            m_backFrame = std::shared_ptr<cv::Mat> (new cv::Mat(height, width, CV_8UC4));
+            m_frontFrame = std::shared_ptr<cv::Mat> (new cv::Mat(height, width, CV_8UC4));
+        }
+
+        memcpy(m_backFrame.get()->data, buffer, 4 * height*width);
+        m_contentDirty = true;
+        RequestAdditionalFrame();
+    }
+
+    void Direct3DInterop::ProcessFrame()
+    {
+        if (SwapFrames())
+        {
+            if (m_renderer)
+            {
+                cv::Mat* mat = m_frontFrame.get();
+
+                switch (m_algorithm)
+                {
+                    case OCVFilterType::ePreview:
+                    {
+                        break;
+                    }
+
+                    case OCVFilterType::eGray:
+                    {
+                        ApplyGrayFilter(mat);
+                        break;
+                    }
+
+                    case OCVFilterType::eCanny:
+                    {
+                        ApplyCannyFilter(mat);
+                        break;
+                    }
+
+                    case OCVFilterType::eBlur:
+                    {
+                        ApplyBlurFilter(mat);
+                        break;
+                    }
+
+                    case OCVFilterType::eFindFeatures:
+                    {
+                        ApplyFindFeaturesFilter(mat);
+                        break;
+                    }
+
+                    case OCVFilterType::eSepia:
+                    {
+                        ApplySepiaFilter(mat);
+                        break;
+                    }
+                }
+
+                m_renderer->CreateTextureFromByte(mat->data, mat->cols, mat->rows);
+            }
+        }
+    }
+
+    void Direct3DInterop::ApplyGrayFilter(cv::Mat* mat)
+    {
+        cv::Mat intermediateMat;
+        cv::cvtColor(*mat, intermediateMat, COLOR_RGBA2GRAY);
+        cv::cvtColor(intermediateMat, *mat, COLOR_GRAY2BGRA);
+    }
+
+    void Direct3DInterop::ApplyCannyFilter(cv::Mat* mat)
+    {
+        cv::Mat intermediateMat;
+        cv::Canny(*mat, intermediateMat, 80, 90);
+        cv::cvtColor(intermediateMat, *mat, COLOR_GRAY2BGRA);
+    }
+
+    void Direct3DInterop::ApplyBlurFilter(cv::Mat* mat)
+    {
+        cv::Mat intermediateMat;
+        //	cv::Blur(image, intermediateMat, 80, 90);
+        cv::cvtColor(intermediateMat, *mat, COLOR_GRAY2BGRA);
+    }
+
+    void Direct3DInterop::ApplyFindFeaturesFilter(cv::Mat* mat)
+    {
+        cv::Mat intermediateMat;
+        cv::Ptr<cv::FastFeatureDetector> detector = cv::FastFeatureDetector::create(50);
+        std::vector<cv::KeyPoint> features;
+
+        cv::cvtColor(*mat, intermediateMat, COLOR_RGBA2GRAY);
+        detector->detect(intermediateMat, features);
+
+        for( unsigned int i = 0; i < std::min(features.size(), (size_t)50); i++ )
+        {
+            const cv::KeyPoint& kp = features[i];
+            cv::circle(*mat, cv::Point((int)kp.pt.x, (int)kp.pt.y), 10, cv::Scalar(255,0,0,255));
+        }
+    }
+
+    void Direct3DInterop::ApplySepiaFilter(cv::Mat* mat)
+    {
+        const float SepiaKernelData[16] =
+        {
+            /* B */0.131f, 0.534f, 0.272f, 0.f,
+            /* G */0.168f, 0.686f, 0.349f, 0.f,
+            /* R */0.189f, 0.769f, 0.393f, 0.f,
+            /* A */0.000f, 0.000f, 0.000f, 1.f
+        };
+
+        const cv::Mat SepiaKernel(4, 4, CV_32FC1, (void*)SepiaKernelData);
+        cv::transform(*mat, *mat, SepiaKernel);
+    }
+
+    IDrawingSurfaceContentProvider^ Direct3DInterop::CreateContentProvider()
+    {
+        ComPtr<Direct3DContentProvider> provider = Make<Direct3DContentProvider>(this);
+        return reinterpret_cast<IDrawingSurfaceContentProvider^>(provider.Detach());
+    }
+
+    // IDrawingSurfaceManipulationHandler
+    void Direct3DInterop::SetManipulationHost(DrawingSurfaceManipulationHost^ manipulationHost)
+    {
+        manipulationHost->PointerPressed +=
+            ref new TypedEventHandler<DrawingSurfaceManipulationHost^, PointerEventArgs^>(this, &Direct3DInterop::OnPointerPressed);
+
+        manipulationHost->PointerMoved +=
+            ref new TypedEventHandler<DrawingSurfaceManipulationHost^, PointerEventArgs^>(this, &Direct3DInterop::OnPointerMoved);
+
+        manipulationHost->PointerReleased +=
+            ref new TypedEventHandler<DrawingSurfaceManipulationHost^, PointerEventArgs^>(this, &Direct3DInterop::OnPointerReleased);
+    }
+
+    void Direct3DInterop::RenderResolution::set(Windows::Foundation::Size renderResolution)
+    {
+        if (renderResolution.Width  != m_renderResolution.Width ||
+            renderResolution.Height != m_renderResolution.Height)
+        {
+            m_renderResolution = renderResolution;
+
+            if (m_renderer)
+            {
+                m_renderer->UpdateForRenderResolutionChange(m_renderResolution.Width, m_renderResolution.Height);
+                RecreateSynchronizedTexture();
+            }
+        }
+    }
+
+    // Event Handlers
+
+    void Direct3DInterop::OnPointerPressed(DrawingSurfaceManipulationHost^ sender, PointerEventArgs^ args)
+    {
+        // Insert your code here.
+    }
+
+    void Direct3DInterop::OnPointerMoved(DrawingSurfaceManipulationHost^ sender, PointerEventArgs^ args)
+    {
+        // Insert your code here.
+    }
+
+    void Direct3DInterop::OnPointerReleased(DrawingSurfaceManipulationHost^ sender, PointerEventArgs^ args)
+    {
+        // Insert your code here.
+    }
+
+    void Direct3DInterop::StartCamera()
+    {
+        // Set the capture dimensions
+        Size captureDimensions;
+        captureDimensions.Width = 640;
+        captureDimensions.Height = 480;
+
+        // Open the AudioVideoCaptureDevice for video only
+        IAsyncOperation<AudioVideoCaptureDevice^> ^openOperation = AudioVideoCaptureDevice::OpenForVideoOnlyAsync(CameraSensorLocation::Back, captureDimensions);
+
+        openOperation->Completed = ref new AsyncOperationCompletedHandler<AudioVideoCaptureDevice^>(
+            [this] (IAsyncOperation<AudioVideoCaptureDevice^> ^operation, Windows::Foundation::AsyncStatus status)
+            {
+                if (status == Windows::Foundation::AsyncStatus::Completed)
+                {
+                    auto captureDevice = operation->GetResults();
+
+                    // Save the reference to the opened video capture device
+                    pAudioVideoCaptureDevice = captureDevice;
+
+                    // Retrieve the native ICameraCaptureDeviceNative interface from the managed video capture device
+                    ICameraCaptureDeviceNative *iCameraCaptureDeviceNative = NULL;
+                    HRESULT hr = reinterpret_cast<IUnknown*>(captureDevice)->QueryInterface(__uuidof(ICameraCaptureDeviceNative), (void**) &iCameraCaptureDeviceNative);
+
+                    // Save the pointer to the native interface
+                    pCameraCaptureDeviceNative = iCameraCaptureDeviceNative;
+
+                    // Initialize the preview dimensions (see the accompanying article at )
+                    // The aspect ratio of the capture and preview resolution must be equal,
+                    // 4:3 for capture => 4:3 for preview, and 16:9 for capture => 16:9 for preview.
+                    Size previewDimensions;
+                    previewDimensions.Width = 640;
+                    previewDimensions.Height = 480;
+
+                    IAsyncAction^ setPreviewResolutionAction = pAudioVideoCaptureDevice->SetPreviewResolutionAsync(previewDimensions);
+                    setPreviewResolutionAction->Completed = ref new AsyncActionCompletedHandler(
+                        [this](IAsyncAction^ action, Windows::Foundation::AsyncStatus status)
+                        {
+                            HResult hr = action->ErrorCode;
+
+                            if (status == Windows::Foundation::AsyncStatus::Completed)
+                            {
+                                // Create the sink
+                                MakeAndInitialize<CameraCapturePreviewSink>(&pCameraCapturePreviewSink);
+                                pCameraCapturePreviewSink->SetDelegate(this);
+                                pCameraCaptureDeviceNative->SetPreviewSink(pCameraCapturePreviewSink);
+
+                                // Set the preview format
+                                pCameraCaptureDeviceNative->SetPreviewFormat(DXGI_FORMAT::DXGI_FORMAT_B8G8R8A8_UNORM);
+                            }
+                        }
+                    );
+
+                    // Retrieve IAudioVideoCaptureDeviceNative native interface from managed projection.
+                    IAudioVideoCaptureDeviceNative *iAudioVideoCaptureDeviceNative = NULL;
+                    hr = reinterpret_cast<IUnknown*>(captureDevice)->QueryInterface(__uuidof(IAudioVideoCaptureDeviceNative), (void**) &iAudioVideoCaptureDeviceNative);
+
+                    // Save the pointer to the IAudioVideoCaptureDeviceNative native interface
+                    pAudioVideoCaptureDeviceNative = iAudioVideoCaptureDeviceNative;
+
+                    // Set sample encoding format to ARGB. See the documentation for further values.
+                    pAudioVideoCaptureDevice->VideoEncodingFormat = CameraCaptureVideoFormat::Argb;
+
+                    // Initialize and set the CameraCaptureSampleSink class as sink for captures samples
+                    MakeAndInitialize<CameraCaptureSampleSink>(&pCameraCaptureSampleSink);
+                    pAudioVideoCaptureDeviceNative->SetVideoSampleSink(pCameraCaptureSampleSink);
+
+                    // Start recording (only way to receive samples using the ICameraCaptureSampleSink interface
+                    pAudioVideoCaptureDevice->StartRecordingToSinkAsync();
+                }
+            }
+        );
+
+    }
+    // Interface With Direct3DContentProvider
+    HRESULT Direct3DInterop::Connect(_In_ IDrawingSurfaceRuntimeHostNative* host)
+    {
+        m_renderer = ref new QuadRenderer();
+        m_renderer->Initialize();
+        m_renderer->UpdateForWindowSizeChange(WindowBounds.Width, WindowBounds.Height);
+        m_renderer->UpdateForRenderResolutionChange(m_renderResolution.Width, m_renderResolution.Height);
+        StartCamera();
+
+        return S_OK;
+    }
+
+    void Direct3DInterop::Disconnect()
+    {
+        m_renderer = nullptr;
+    }
+
+    HRESULT Direct3DInterop::PrepareResources(_In_ const LARGE_INTEGER* presentTargetTime, _Out_ BOOL* contentDirty)
+    {
+        *contentDirty = m_contentDirty;
+        if(m_contentDirty)
+        {
+            ProcessFrame();
+        }
+        m_contentDirty = false;
+        return S_OK;
+    }
+
+    HRESULT Direct3DInterop::GetTexture(_In_ const DrawingSurfaceSizeF* size, _Out_ IDrawingSurfaceSynchronizedTextureNative** synchronizedTexture, _Out_ DrawingSurfaceRectF* textureSubRectangle)
+    {
+        m_renderer->Update();
+        m_renderer->Render();
+        return S_OK;
+    }
+
+    ID3D11Texture2D* Direct3DInterop::GetTexture()
+    {
+        return m_renderer->GetTexture();
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.h b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.h
new file mode 100644
index 00000000..ef105880
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.h
@@ -0,0 +1,143 @@
+#pragma once
+
+#include "pch.h"
+#include "BasicTimer.h"
+#include "QuadRenderer.h"
+#include <DrawingSurfaceNative.h>
+#include <ppltasks.h>
+#include <windows.storage.streams.h>
+#include <memory>
+#include <mutex>
+
+
+#include <opencv2\imgproc\types_c.h>
+
+
+namespace PhoneXamlDirect3DApp1Comp
+{
+
+public enum class OCVFilterType
+{
+    ePreview,
+    eGray,
+    eCanny,
+    eBlur,
+    eFindFeatures,
+    eSepia,
+    eNumOCVFilterTypes
+};
+
+class CameraCapturePreviewSink;
+class CameraCaptureSampleSink;
+
+public delegate void RequestAdditionalFrameHandler();
+public delegate void RecreateSynchronizedTextureHandler();
+
+[Windows::Foundation::Metadata::WebHostHidden]
+public ref class Direct3DInterop sealed : public Windows::Phone::Input::Interop::IDrawingSurfaceManipulationHandler
+{
+public:
+    Direct3DInterop();
+
+    Windows::Phone::Graphics::Interop::IDrawingSurfaceContentProvider^ CreateContentProvider();
+
+    // IDrawingSurfaceManipulationHandler
+    virtual void SetManipulationHost(Windows::Phone::Input::Interop::DrawingSurfaceManipulationHost^ manipulationHost);
+
+    event RequestAdditionalFrameHandler^ RequestAdditionalFrame;
+    event RecreateSynchronizedTextureHandler^ RecreateSynchronizedTexture;
+
+    property Windows::Foundation::Size WindowBounds;
+    property Windows::Foundation::Size NativeResolution;
+    property Windows::Foundation::Size RenderResolution
+    {
+        Windows::Foundation::Size get(){ return m_renderResolution; }
+        void set(Windows::Foundation::Size renderResolution);
+    }
+    void SetAlgorithm(OCVFilterType type) { m_algorithm = type; };
+    void UpdateFrame(byte* buffer, int width, int height);
+
+
+protected:
+    // Event Handlers
+    void OnPointerPressed(Windows::Phone::Input::Interop::DrawingSurfaceManipulationHost^ sender, Windows::UI::Core::PointerEventArgs^ args);
+    void OnPointerMoved(Windows::Phone::Input::Interop::DrawingSurfaceManipulationHost^ sender, Windows::UI::Core::PointerEventArgs^ args);
+    void OnPointerReleased(Windows::Phone::Input::Interop::DrawingSurfaceManipulationHost^ sender, Windows::UI::Core::PointerEventArgs^ args);
+
+internal:
+    HRESULT STDMETHODCALLTYPE Connect(_In_ IDrawingSurfaceRuntimeHostNative* host);
+    void STDMETHODCALLTYPE Disconnect();
+    HRESULT STDMETHODCALLTYPE PrepareResources(_In_ const LARGE_INTEGER* presentTargetTime, _Out_ BOOL* contentDirty);
+    HRESULT STDMETHODCALLTYPE GetTexture(_In_ const DrawingSurfaceSizeF* size, _Out_ IDrawingSurfaceSynchronizedTextureNative** synchronizedTexture, _Out_ DrawingSurfaceRectF* textureSubRectangle);
+    ID3D11Texture2D* GetTexture();
+
+private:
+    void StartCamera();
+    void ProcessFrame();
+    bool SwapFrames();
+
+    QuadRenderer^ m_renderer;
+    Windows::Foundation::Size m_renderResolution;
+    OCVFilterType m_algorithm;
+    bool m_contentDirty;
+    std::shared_ptr<cv::Mat> m_backFrame;
+    std::shared_ptr<cv::Mat> m_frontFrame;
+    std::mutex m_mutex;
+
+    Windows::Phone::Media::Capture::AudioVideoCaptureDevice ^pAudioVideoCaptureDevice;
+    ICameraCaptureDeviceNative* pCameraCaptureDeviceNative;
+    IAudioVideoCaptureDeviceNative* pAudioVideoCaptureDeviceNative;
+    CameraCapturePreviewSink* pCameraCapturePreviewSink;
+    CameraCaptureSampleSink* pCameraCaptureSampleSink;
+
+    //void ApplyPreviewFilter(const cv::Mat& image);
+    void ApplyGrayFilter(cv::Mat* mat);
+    void ApplyCannyFilter(cv::Mat* mat);
+    void ApplyBlurFilter(cv::Mat* mat);
+    void ApplyFindFeaturesFilter(cv::Mat* mat);
+    void ApplySepiaFilter(cv::Mat* mat);
+};
+
+class CameraCapturePreviewSink :
+    public Microsoft::WRL::RuntimeClass<
+        Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::RuntimeClassType::ClassicCom>,
+        ICameraCapturePreviewSink>
+{
+public:
+    void SetDelegate(Direct3DInterop^ delegate)
+    {
+        m_Direct3dInterop = delegate;
+    }
+
+    IFACEMETHODIMP_(void) OnFrameAvailable(
+        DXGI_FORMAT format,
+        UINT width,
+        UINT height,
+        BYTE* pixels);
+
+private:
+    Direct3DInterop^ m_Direct3dInterop;
+};
+
+class CameraCaptureSampleSink :
+    public Microsoft::WRL::RuntimeClass<
+        Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::RuntimeClassType::ClassicCom>,
+        ICameraCaptureSampleSink>
+{
+public:
+    void SetDelegate(Direct3DInterop^ delegate)
+    {
+        m_Direct3dInterop = delegate;
+    }
+
+    IFACEMETHODIMP_(void) OnSampleAvailable(
+            ULONGLONG hnsPresentationTime,
+            ULONGLONG hnsSampleDuration,
+            DWORD cbSample,
+            BYTE* pSample);
+
+private:
+    Direct3DInterop^ m_Direct3dInterop;
+};
+
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/DirectXHelper.h b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/DirectXHelper.h
new file mode 100644
index 00000000..3f1a3cf4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/DirectXHelper.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <wrl/client.h>
+#include <ppl.h>
+#include <ppltasks.h>
+
+namespace DX
+{
+    inline void ThrowIfFailed(HRESULT hr)
+    {
+        if (FAILED(hr))
+        {
+            // Set a breakpoint on this line to catch Win32 API errors.
+            throw Platform::Exception::CreateException(hr);
+        }
+    }
+
+    // Function that reads from a binary file asynchronously.
+    inline Concurrency::task<Platform::Array<byte>^> ReadDataAsync(Platform::String^ filename)
+    {
+        using namespace Windows::Storage;
+        using namespace Concurrency;
+
+        auto folder = Windows::ApplicationModel::Package::Current->InstalledLocation;
+
+        return create_task(folder->GetFileAsync(filename)).then([] (StorageFile^ file)
+        {
+            return file->OpenReadAsync();
+        }).then([] (Streams::IRandomAccessStreamWithContentType^ stream)
+        {
+            unsigned int bufferSize = static_cast<unsigned int>(stream->Size);
+            auto fileBuffer = ref new Streams::Buffer(bufferSize);
+            return stream->ReadAsync(fileBuffer, bufferSize, Streams::InputStreamOptions::None);
+        }).then([] (Streams::IBuffer^ fileBuffer) -> Platform::Array<byte>^
+        {
+            auto fileData = ref new Platform::Array<byte>(fileBuffer->Length);
+            Streams::DataReader::FromBuffer(fileBuffer)->ReadBytes(fileData);
+            return fileData;
+        });
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/PhoneXamlDirect3DApp1Comp.vcxproj b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/PhoneXamlDirect3DApp1Comp.vcxproj
new file mode 100644
index 00000000..7d6bbfdd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/PhoneXamlDirect3DApp1Comp.vcxproj
@@ -0,0 +1,143 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}</ProjectGuid>
+    <RootNamespace>PhoneXamlDirect3DApp1Comp</RootNamespace>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>11.0</MinimumVisualStudioVersion>
+    <WinMDAssembly>true</WinMDAssembly>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <!-- If OutDir was set outside of the project file, then we will append ProjectName -->
+    <OutDir Condition="'$(OutDirWasSpecified)' == 'true'">$(OutDir)\$(MSBuildProjectName)\</OutDir>
+    <!-- else, OutDir needs to have project specific directory in order to handle files with unique names -->
+    <OutDir Condition="'$(OutDirWasSpecified)' != 'true' and '$(Platform)' == 'Win32'">$(SolutionDir)$(Configuration)\$(MSBuildProjectName)\</OutDir>
+    <OutDir Condition="'$(OutDirWasSpecified)' != 'true' and '$(Platform)' != 'Win32'">$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)\</OutDir>
+    <!-- After OutDir has been fixed, disable Microsoft.common.targets from fixing it again -->
+    <OutDirWasSpecified>false</OutDirWasSpecified>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="opencv.props" />    
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <PreprocessorDefinitions>_WINRT_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_MetadataPath);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>true</CompileAsWinRT>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <IgnoreSpecificDefaultLibraries>ole32.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <PreprocessorDefinitions>_WINRT_DLL;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_MetadataPath);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>true</CompileAsWinRT>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <IgnoreSpecificDefaultLibraries>ole32.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Reference Include="platform.winmd">
+      <IsWinMDFile>true</IsWinMDFile>
+      <Private>false</Private>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="BasicTimer.h" />
+    <ClInclude Include="Direct3DInterop.h" />
+    <ClInclude Include="DirectXHelper.h" />
+    <ClInclude Include="Direct3DBase.h" />
+    <ClInclude Include="Direct3DContentProvider.h" />
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="QuadRenderer.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Direct3DInterop.cpp" />
+    <ClCompile Include="Direct3DBase.cpp" />
+    <ClCompile Include="Direct3DContentProvider.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="QuadRenderer.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <FxCompile Include="SimplePixelShader.hlsl">
+      <ShaderType>Pixel</ShaderType>
+      <ShaderModel>4.0_level_9_3</ShaderModel>
+    </FxCompile>
+    <FxCompile Include="SimpleVertexShader.hlsl">
+      <ShaderType>Vertex</ShaderType>
+      <ShaderModel>4.0_level_9_3</ShaderModel>
+    </FxCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsPhone\v$(TargetPlatformVersion)\Microsoft.Cpp.WindowsPhone.$(TargetPlatformVersion).targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\..\packages\NokiaImagingSDK.1.0.272.0\build\native\NokiaImagingSDK.targets" Condition="Exists('..\..\packages\NokiaImagingSDK.1.0.272.0\build\native\NokiaImagingSDK.targets')" />
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/QuadRenderer.cpp b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/QuadRenderer.cpp
new file mode 100644
index 00000000..2924b3c3
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/QuadRenderer.cpp
@@ -0,0 +1,340 @@
+#include "pch.h"
+#include "QuadRenderer.h"
+
+using namespace DirectX;
+using namespace Microsoft::WRL;
+using namespace Windows::Foundation;
+using namespace Windows::UI::Core;
+
+QuadRenderer::QuadRenderer() :
+    m_loadingComplete(false),
+    m_indexCount(0)
+{
+}
+
+void QuadRenderer::CreateTextureFromByte(byte* buffer,int width,int height)
+{
+    int pixelSize = 4;
+
+    if (m_Texture.Get() == nullptr)
+    {
+        CD3D11_TEXTURE2D_DESC textureDesc(
+            DXGI_FORMAT_B8G8R8A8_UNORM,		// format
+            static_cast<UINT>(width),		// width
+            static_cast<UINT>(height),		// height
+            1,								// arraySize
+            1,								// mipLevels
+            D3D11_BIND_SHADER_RESOURCE,		// bindFlags
+            D3D11_USAGE_DYNAMIC,			// usage
+            D3D11_CPU_ACCESS_WRITE,			// cpuaccessFlags
+            1,								// sampleCount
+            0,								// sampleQuality
+            0								// miscFlags
+            );
+
+        D3D11_SUBRESOURCE_DATA data;
+        data.pSysMem = buffer;
+        data.SysMemPitch = pixelSize*width;
+        data.SysMemSlicePitch = pixelSize*width*height;
+
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateTexture2D(
+            &textureDesc,
+            &data,
+            m_Texture.ReleaseAndGetAddressOf()
+            )
+            );
+
+        m_d3dDevice->CreateShaderResourceView(m_Texture.Get(), NULL, m_SRV.ReleaseAndGetAddressOf());
+        D3D11_SAMPLER_DESC sampDesc;
+        ZeroMemory(&sampDesc, sizeof(sampDesc));
+        sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+        sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
+        sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
+        sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
+        sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
+        sampDesc.MinLOD = 0;
+        sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
+        m_d3dDevice->CreateSamplerState(&sampDesc, m_QuadsTexSamplerState.ReleaseAndGetAddressOf());
+    }
+    else
+    {
+        int nRowSpan = width * pixelSize;
+        D3D11_MAPPED_SUBRESOURCE mappedResource;
+        HRESULT hr = m_d3dContext->Map(m_Texture.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+        BYTE* mappedData = static_cast<BYTE*>(mappedResource.pData);
+
+        for (int i = 0; i < height; ++i)
+        {
+            memcpy(mappedData + (i*mappedResource.RowPitch), buffer + (i*nRowSpan), nRowSpan);
+        }
+
+        m_d3dContext->Unmap(m_Texture.Get(), 0);
+    }
+}
+
+void QuadRenderer::CreateDeviceResources()
+{
+    Direct3DBase::CreateDeviceResources();
+    D3D11_BLEND_DESC blendDesc;
+    ZeroMemory( &blendDesc, sizeof(blendDesc) );
+
+    D3D11_RENDER_TARGET_BLEND_DESC rtbd;
+    ZeroMemory( &rtbd, sizeof(rtbd) );
+
+    rtbd.BlendEnable = TRUE;
+    rtbd.SrcBlend = D3D11_BLEND_SRC_ALPHA;
+    rtbd.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
+    rtbd.BlendOp = D3D11_BLEND_OP_ADD;
+    rtbd.SrcBlendAlpha = D3D11_BLEND_ONE;
+    rtbd.DestBlendAlpha = D3D11_BLEND_ZERO;
+    rtbd.BlendOpAlpha = D3D11_BLEND_OP_ADD;
+    rtbd.RenderTargetWriteMask = 0x0f;
+
+    blendDesc.AlphaToCoverageEnable = false;
+    blendDesc.RenderTarget[0] = rtbd;
+
+    m_d3dDevice->CreateBlendState(&blendDesc, &m_Transparency);
+
+    D3D11_RASTERIZER_DESC cmdesc;
+    ZeroMemory(&cmdesc, sizeof(D3D11_RASTERIZER_DESC));
+
+    cmdesc.FillMode = D3D11_FILL_SOLID;
+    cmdesc.CullMode = D3D11_CULL_BACK;
+    cmdesc.DepthClipEnable = TRUE;
+
+    cmdesc.FrontCounterClockwise = true;
+    m_d3dDevice->CreateRasterizerState(&cmdesc, &CCWcullMode);
+
+    cmdesc.FrontCounterClockwise = false;
+    m_d3dDevice->CreateRasterizerState(&cmdesc, &CWcullMode);
+
+    auto loadVSTask = DX::ReadDataAsync("SimpleVertexShader.cso");
+    auto loadPSTask = DX::ReadDataAsync("SimplePixelShader.cso");
+    auto createVSTask = loadVSTask.then([this](Platform::Array<byte>^ fileData)
+    {
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateVertexShader(
+            fileData->Data,
+            fileData->Length,
+            nullptr,
+            &m_vertexShader
+            )
+            );
+
+        const D3D11_INPUT_ELEMENT_DESC vertexDesc[] =
+        {
+            { "POSITION",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0,  D3D11_INPUT_PER_VERTEX_DATA, 0 },
+            { "TEXCOORD",    0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+        };
+
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateInputLayout(
+            vertexDesc,
+            ARRAYSIZE(vertexDesc),
+            fileData->Data,
+            fileData->Length,
+            &m_inputLayout
+            )
+            );
+    });
+
+    auto createPSTask = loadPSTask.then([this](Platform::Array<byte>^ fileData)
+    {
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreatePixelShader(
+            fileData->Data,
+            fileData->Length,
+            nullptr,
+            &m_pixelShader
+            )
+            );
+
+        CD3D11_BUFFER_DESC constantBufferDesc(sizeof(ModelViewProjectionConstantBuffer), D3D11_BIND_CONSTANT_BUFFER);
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateBuffer(
+            &constantBufferDesc,
+            nullptr,
+            &m_constantBuffer
+            )
+            );
+    });
+
+    auto createCubeTask = (createPSTask && createVSTask).then([this] ()
+    {
+        Vertex v[] =
+        {
+            Vertex(-1.0f, -1.0f, 1.0f, 1.0f, 1.0f),
+            Vertex(1.0f, -1.0f, 1.0f, 0.0f, 1.0f),
+            Vertex(1.0f, 1.0f, 1.0f, 0.0f, 0.0f),
+            Vertex(-1.0f, 1.0f, 1.0f, 1.0f, 0.0f)
+        };
+
+        D3D11_SUBRESOURCE_DATA vertexBufferData = {0};
+        vertexBufferData.pSysMem = v;
+        vertexBufferData.SysMemPitch = 0;
+        vertexBufferData.SysMemSlicePitch = 0;
+        CD3D11_BUFFER_DESC vertexBufferDesc(sizeof(v), D3D11_BIND_VERTEX_BUFFER);
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateBuffer(
+            &vertexBufferDesc,
+            &vertexBufferData,
+            &m_vertexBuffer
+            )
+            );
+
+        DWORD indices[] =
+        {
+            // Front Face
+            0,  2,  1,
+            0,  3,  2,
+
+        };
+
+        m_indexCount = ARRAYSIZE(indices);
+
+        D3D11_SUBRESOURCE_DATA indexBufferData = {0};
+        indexBufferData.pSysMem = indices;
+        indexBufferData.SysMemPitch = 0;
+        indexBufferData.SysMemSlicePitch = 0;
+        CD3D11_BUFFER_DESC indexBufferDesc(sizeof(indices), D3D11_BIND_INDEX_BUFFER);
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateBuffer(
+            &indexBufferDesc,
+            &indexBufferData,
+            &m_indexBuffer
+            )
+            );
+    });
+
+    createCubeTask.then([this] ()
+    {
+        m_loadingComplete = true;
+    });
+}
+
+void QuadRenderer::CreateWindowSizeDependentResources()
+{
+    Direct3DBase::CreateWindowSizeDependentResources();
+
+    float aspectRatio = m_windowBounds.Width / m_windowBounds.Height;
+    float fovAngleY = 60.0f * (XM_PI / 180.0f);
+
+    if (aspectRatio < 1.0f)
+    {
+        fovAngleY /= aspectRatio;
+    }
+
+    XMStoreFloat4x4(
+        &m_constantBufferData.projection,
+        XMMatrixTranspose(
+        XMMatrixPerspectiveFovRH(
+        fovAngleY,
+        aspectRatio,
+        0.01f,
+        100.0f
+        )
+        )
+        );
+}
+
+void QuadRenderer::Update(float timeTotal, float timeDelta)
+{
+    (void) timeDelta; // Unused parameter.
+
+    XMVECTOR X = XMVectorSet(0.0f, 0.0f, .3f, 0.0f);
+    XMVECTOR Y = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
+    XMVECTOR Z = XMVectorSet(1.0f, 0.0f, 0.0f, 0.0f);
+
+    XMStoreFloat4x4(&m_constantBufferData.view, XMMatrixTranspose(XMMatrixLookAtLH(X, Y, Z)));
+    XMStoreFloat4x4(&m_constantBufferData.model, XMMatrixTranspose(XMMatrixRotationY(timeTotal * XM_PIDIV4)));
+}
+
+void QuadRenderer::Render()
+{
+    Render(m_renderTargetView, m_depthStencilView);
+}
+
+void QuadRenderer::Render(Microsoft::WRL::ComPtr<ID3D11RenderTargetView> renderTargetView, Microsoft::WRL::ComPtr<ID3D11DepthStencilView> depthStencilView)
+{
+    const float black[] = {0, 0, 0, 1.0 };
+
+    m_d3dContext->ClearRenderTargetView(
+        renderTargetView.Get(),
+        black
+        );
+
+    m_d3dContext->ClearDepthStencilView(
+        depthStencilView.Get(),
+        D3D11_CLEAR_DEPTH,
+        1.0f,
+        0
+        );
+
+    if (m_SRV && m_loadingComplete)	// Only draw the cube once it is loaded (loading is asynchronous).
+    {
+        m_d3dContext->OMSetRenderTargets(
+            1,
+            renderTargetView.GetAddressOf(),
+            depthStencilView.Get()
+            );
+
+        m_d3dContext->UpdateSubresource(
+            m_constantBuffer.Get(),
+            0,
+            NULL,
+            &m_constantBufferData,
+            0,
+            0
+            );
+
+        UINT stride = sizeof(Vertex);
+        UINT offset = 0;
+
+        m_d3dContext->IASetVertexBuffers(
+            0,
+            1,
+            m_vertexBuffer.GetAddressOf(),
+            &stride,
+            &offset
+            );
+
+        m_d3dContext->IASetIndexBuffer(
+            m_indexBuffer.Get(),
+            DXGI_FORMAT_R32_UINT,
+            0
+            );
+
+        m_d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+        m_d3dContext->IASetInputLayout(m_inputLayout.Get());
+
+        m_d3dContext->VSSetShader(
+            m_vertexShader.Get(),
+            nullptr,
+            0
+            );
+
+        m_d3dContext->VSSetConstantBuffers(
+            0,
+            1,
+            m_constantBuffer.GetAddressOf()
+            );
+
+        m_d3dContext->PSSetShader(
+            m_pixelShader.Get(),
+            nullptr,
+            0
+            );
+
+        m_d3dContext->PSSetShaderResources(0, 1, m_SRV.GetAddressOf());
+        m_d3dContext->PSSetSamplers(0, 1, m_QuadsTexSamplerState.GetAddressOf());
+        m_d3dContext->OMSetBlendState(m_Transparency.Get(), nullptr, 0xffffffff);
+        m_d3dContext->RSSetState(CCWcullMode.Get());
+
+        m_d3dContext->DrawIndexed(
+            m_indexCount,
+            0,
+            0
+            );
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/QuadRenderer.h b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/QuadRenderer.h
new file mode 100644
index 00000000..433e380c
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/QuadRenderer.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "Direct3DBase.h"
+#include <d3d11.h>
+
+
+struct ModelViewProjectionConstantBuffer
+{
+    DirectX::XMFLOAT4X4 model;
+    DirectX::XMFLOAT4X4 view;
+    DirectX::XMFLOAT4X4 projection;
+};
+
+struct Vertex	//Overloaded Vertex Structure
+{
+    Vertex(){}
+    Vertex(float x, float y, float z,
+        float u, float v)
+        : pos(x,y,z), texCoord(u, v){}
+
+    DirectX::XMFLOAT3 pos;
+    DirectX::XMFLOAT2 texCoord;
+};
+
+// This class renders a simple quad.
+ref class QuadRenderer sealed : public Direct3DBase
+{
+public:
+    QuadRenderer();
+
+    void Update(float timeTotal = 0.0f, float timeDelta = 0.0f);
+    void CreateTextureFromByte(byte  *  buffer,int width,int height);
+
+    // Direct3DBase methods.
+    virtual void CreateDeviceResources() override;
+    virtual void CreateWindowSizeDependentResources() override;
+    virtual void Render() override;
+
+private:
+    void Render(Microsoft::WRL::ComPtr<ID3D11RenderTargetView> renderTargetView, Microsoft::WRL::ComPtr<ID3D11DepthStencilView> depthStencilView);
+    bool m_loadingComplete;
+    uint32 m_indexCount;
+    ModelViewProjectionConstantBuffer m_constantBufferData;
+    Microsoft::WRL::ComPtr<ID3D11InputLayout>	m_inputLayout;
+    Microsoft::WRL::ComPtr<ID3D11Buffer>		m_vertexBuffer;
+    Microsoft::WRL::ComPtr<ID3D11Buffer>		m_indexBuffer;
+    Microsoft::WRL::ComPtr<ID3D11VertexShader>	m_vertexShader;
+    Microsoft::WRL::ComPtr<ID3D11PixelShader>	m_pixelShader;
+    Microsoft::WRL::ComPtr<ID3D11Buffer>		m_constantBuffer;
+    Microsoft::WRL::ComPtr<ID3D11Texture2D>		 m_Texture;
+    Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> m_SRV;
+    Microsoft::WRL::ComPtr<ID3D11SamplerState> m_QuadsTexSamplerState;
+    Microsoft::WRL::ComPtr<ID3D11BlendState> m_Transparency;
+    Microsoft::WRL::ComPtr<ID3D11RasterizerState> CCWcullMode;
+    Microsoft::WRL::ComPtr<ID3D11RasterizerState> CWcullMode;
+};
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimplePixelShader.hlsl b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimplePixelShader.hlsl
new file mode 100644
index 00000000..17c7046a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimplePixelShader.hlsl
@@ -0,0 +1,25 @@
+Texture2D shaderTexture;
+SamplerState SampleType;
+
+//////////////
+// TYPEDEFS //
+//////////////
+struct PixelInputType
+{
+    float4 position : SV_POSITION;
+    float2 tex : TEXCOORD0;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Pixel Shader
+////////////////////////////////////////////////////////////////////////////////
+float4 main(PixelInputType input) : SV_TARGET
+{
+    float4 textureColor;
+
+
+    // Sample the pixel color from the texture using the sampler at this texture coordinate location.
+    textureColor = shaderTexture.Sample(SampleType, input.tex);
+
+    return textureColor;
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimpleVertexShader.hlsl b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimpleVertexShader.hlsl
new file mode 100644
index 00000000..06584f60
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimpleVertexShader.hlsl
@@ -0,0 +1,39 @@
+cbuffer ModelViewProjectionConstantBuffer : register(b0)
+{
+    matrix model;
+    matrix view;
+    matrix projection;
+};
+
+struct VertexInputType
+{
+    float4 position : POSITION;
+    float2 tex : TEXCOORD0;
+};
+
+struct PixelInputType
+{
+    float4 position : SV_POSITION;
+    float2 tex : TEXCOORD0;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Vertex Shader
+////////////////////////////////////////////////////////////////////////////////
+PixelInputType main(VertexInputType input)
+{
+    PixelInputType output;
+
+    // Change the position vector to be 4 units for proper matrix calculations.
+    input.position.w = 1.0f;
+
+    // Calculate the position of the vertex against the world, view, and projection matrices.
+    output.position = mul(input.position, model);
+    output.position = mul(output.position, view);
+    output.position = mul(output.position, projection);
+    // Store the texture coordinates for the pixel shader.
+    output.tex = input.tex;
+
+    return output;
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/opencv.props b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/opencv.props
new file mode 100644
index 00000000..25161a7d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/opencv.props
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros">
+    <OpenCV_Bin>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.0\$(PlatformTarget)\$(PlatformTarget)\vc11\bin\</OpenCV_Bin>
+    <OpenCV_Lib>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.0\$(PlatformTarget)\$(PlatformTarget)\vc11\lib\</OpenCV_Lib>
+    <OpenCV_Include>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.0\$(PlatformTarget)\include\</OpenCV_Include>
+    <!--debug suffix for OpenCV dlls and libs -->
+    <DebugSuffix Condition="'$(Configuration)'=='Debug'">d</DebugSuffix>
+    <DebugSuffix Condition="'$(Configuration)'!='Debug'">
+    </DebugSuffix>
+  </PropertyGroup>
+  <ItemGroup>
+    <!--Add required OpenCV dlls here-->
+    <None Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_features2d300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_flann300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_ml300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+  </ItemGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(OpenCV_Include);$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <!--Add required OpenCV libs here-->
+      <AdditionalDependencies>opencv_core300$(DebugSuffix).lib;opencv_imgproc300$(DebugSuffix).lib;opencv_features2d300$(DebugSuffix).lib;opencv_flann300$(DebugSuffix).lib;opencv_ml300$(DebugSuffix).lib;d3d11.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OpenCV_Lib);%(AdditionalLibraryDirectories);</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.cpp b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.cpp
new file mode 100644
index 00000000..bcb5590b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.cpp
@@ -0,0 +1 @@
+#include "pch.h"
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.h b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.h
new file mode 100644
index 00000000..124baaed
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvImageManipulation/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <wrl/client.h>
+#include <d3d11_1.h>
+#include <DirectXMath.h>
+#include <memory>
+#include <agile.h>
+#include <implements.h>
+#include <Windows.Phone.Media.Capture.h>
+#include <Windows.Phone.Media.Capture.Native.h>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/OcvRotatingCube.sln b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/OcvRotatingCube.sln
new file mode 100644
index 00000000..66cc56a8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/OcvRotatingCube.sln
@@ -0,0 +1,76 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PhoneXamlDirect3DApp1Comp", "PhoneXamlDirect3DApp1\PhoneXamlDirect3DApp1Comp\PhoneXamlDirect3DApp1Comp.vcxproj", "{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OcvRotatingCube", "PhoneXamlDirect3DApp1\PhoneXamlDirect3DApp1\OcvRotatingCube.csproj", "{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|ARM = Debug|ARM
+		Debug|Mixed Platforms = Debug|Mixed Platforms
+		Debug|Win32 = Debug|Win32
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|ARM = Release|ARM
+		Release|Mixed Platforms = Release|Mixed Platforms
+		Release|Win32 = Release|Win32
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|ARM.ActiveCfg = Debug|ARM
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|ARM.Build.0 = Debug|ARM
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|Win32.Build.0 = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|x86.ActiveCfg = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Debug|x86.Build.0 = Debug|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|Any CPU.ActiveCfg = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|ARM.ActiveCfg = Release|ARM
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|ARM.Build.0 = Release|ARM
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|Mixed Platforms.ActiveCfg = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|Mixed Platforms.Build.0 = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|Win32.ActiveCfg = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|Win32.Build.0 = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|x86.ActiveCfg = Release|Win32
+		{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}.Release|x86.Build.0 = Release|Win32
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|ARM.ActiveCfg = Debug|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|ARM.Build.0 = Debug|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|ARM.Deploy.0 = Debug|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Mixed Platforms.Deploy.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Win32.ActiveCfg = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Win32.Build.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|Win32.Deploy.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|x86.ActiveCfg = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|x86.Build.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Debug|x86.Deploy.0 = Debug|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Any CPU.Deploy.0 = Release|Any CPU
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|ARM.ActiveCfg = Release|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|ARM.Build.0 = Release|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|ARM.Deploy.0 = Release|ARM
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Mixed Platforms.Build.0 = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Mixed Platforms.Deploy.0 = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Win32.ActiveCfg = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Win32.Build.0 = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|Win32.Deploy.0 = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|x86.ActiveCfg = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|x86.Build.0 = Release|x86
+		{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}.Release|x86.Deploy.0 = Release|x86
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml
new file mode 100644
index 00000000..1a9cadac
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml
@@ -0,0 +1,20 @@
+<Application
+    x:Class="PhoneXamlDirect3DApp1.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
+    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone">
+
+    <!--Application Resources-->
+    <Application.Resources>
+        <local:LocalizedStrings xmlns:local="clr-namespace:PhoneXamlDirect3DApp1" x:Key="LocalizedStrings"/>
+    </Application.Resources>
+
+    <Application.ApplicationLifetimeObjects>
+        <!--Required object that handles lifetime events for the application-->
+        <shell:PhoneApplicationService
+            Launching="Application_Launching" Closing="Application_Closing"
+            Activated="Application_Activated" Deactivated="Application_Deactivated"/>
+    </Application.ApplicationLifetimeObjects>
+
+</Application>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs
new file mode 100644
index 00000000..73190e28
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/App.xaml.cs
@@ -0,0 +1,223 @@
+using System;
+using System.Diagnostics;
+using System.Resources;
+using System.Windows;
+using System.Windows.Markup;
+using System.Windows.Navigation;
+using Microsoft.Phone.Controls;
+using Microsoft.Phone.Shell;
+using PhoneXamlDirect3DApp1.Resources;
+
+namespace PhoneXamlDirect3DApp1
+{
+    public partial class App : Application
+    {
+        /// <summary>
+        /// Provides easy access to the root frame of the Phone Application.
+        /// </summary>
+        /// <returns>The root frame of the Phone Application.</returns>
+        public static PhoneApplicationFrame RootFrame { get; private set; }
+
+        /// <summary>
+        /// Constructor for the Application object.
+        /// </summary>
+        public App()
+        {
+            // Global handler for uncaught exceptions.
+            UnhandledException += Application_UnhandledException;
+
+            // Standard XAML initialization
+            InitializeComponent();
+
+            // Phone-specific initialization
+            InitializePhoneApplication();
+
+            // Language display initialization
+            InitializeLanguage();
+
+            // Show graphics profiling information while debugging.
+            if (Debugger.IsAttached)
+            {
+                // Display the current frame rate counters.
+                Application.Current.Host.Settings.EnableFrameRateCounter = true;
+
+                // Show the areas of the app that are being redrawn in each frame.
+                //Application.Current.Host.Settings.EnableRedrawRegions = true;
+
+                // Enable non-production analysis visualization mode,
+                // which shows areas of a page that are handed off to GPU with a colored overlay.
+                //Application.Current.Host.Settings.EnableCacheVisualization = true;
+
+                // Prevent the screen from turning off while under the debugger by disabling
+                // the application's idle detection.
+                // Caution:- Use this under debug mode only. Application that disables user idle detection will continue to run
+                // and consume battery power when the user is not using the phone.
+                PhoneApplicationService.Current.UserIdleDetectionMode = IdleDetectionMode.Disabled;
+            }
+
+        }
+
+        // Code to execute when the application is launching (eg, from Start)
+        // This code will not execute when the application is reactivated
+        private void Application_Launching(object sender, LaunchingEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is activated (brought to foreground)
+        // This code will not execute when the application is first launched
+        private void Application_Activated(object sender, ActivatedEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is deactivated (sent to background)
+        // This code will not execute when the application is closing
+        private void Application_Deactivated(object sender, DeactivatedEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is closing (eg, user hit Back)
+        // This code will not execute when the application is deactivated
+        private void Application_Closing(object sender, ClosingEventArgs e)
+        {
+        }
+
+        // Code to execute if a navigation fails
+        private void RootFrame_NavigationFailed(object sender, NavigationFailedEventArgs e)
+        {
+            if (Debugger.IsAttached)
+            {
+                // A navigation has failed; break into the debugger
+                Debugger.Break();
+            }
+        }
+
+        // Code to execute on Unhandled Exceptions
+        private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
+        {
+            if (Debugger.IsAttached)
+            {
+                // An unhandled exception has occurred; break into the debugger
+                Debugger.Break();
+            }
+        }
+
+        #region Phone application initialization
+
+        // Avoid double-initialization
+        private bool phoneApplicationInitialized = false;
+
+        // Do not add any additional code to this method
+        private void InitializePhoneApplication()
+        {
+            if (phoneApplicationInitialized)
+                return;
+
+            // Create the frame but don't set it as RootVisual yet; this allows the splash
+            // screen to remain active until the application is ready to render.
+            RootFrame = new PhoneApplicationFrame();
+            RootFrame.Navigated += CompleteInitializePhoneApplication;
+
+            // Handle navigation failures
+            RootFrame.NavigationFailed += RootFrame_NavigationFailed;
+
+            // Handle reset requests for clearing the backstack
+            RootFrame.Navigated += CheckForResetNavigation;
+
+            // Ensure we don't initialize again
+            phoneApplicationInitialized = true;
+        }
+
+        // Do not add any additional code to this method
+        private void CompleteInitializePhoneApplication(object sender, NavigationEventArgs e)
+        {
+            // Set the root visual to allow the application to render
+            if (RootVisual != RootFrame)
+                RootVisual = RootFrame;
+
+            // Remove this handler since it is no longer needed
+            RootFrame.Navigated -= CompleteInitializePhoneApplication;
+        }
+
+        private void CheckForResetNavigation(object sender, NavigationEventArgs e)
+        {
+            // If the app has received a 'reset' navigation, then we need to check
+            // on the next navigation to see if the page stack should be reset
+            if (e.NavigationMode == NavigationMode.Reset)
+                RootFrame.Navigated += ClearBackStackAfterReset;
+        }
+
+        private void ClearBackStackAfterReset(object sender, NavigationEventArgs e)
+        {
+            // Unregister the event so it doesn't get called again
+            RootFrame.Navigated -= ClearBackStackAfterReset;
+
+            // Only clear the stack for 'new' (forward) and 'refresh' navigations
+            if (e.NavigationMode != NavigationMode.New && e.NavigationMode != NavigationMode.Refresh)
+                return;
+
+            // For UI consistency, clear the entire page stack
+            while (RootFrame.RemoveBackEntry() != null)
+            {
+                ; // do nothing
+            }
+        }
+
+        #endregion
+
+        // Initialize the app's font and flow direction as defined in its localized resource strings.
+        //
+        // To ensure that the font of your application is aligned with its supported languages and that the
+        // FlowDirection for each of those languages follows its traditional direction, ResourceLanguage
+        // and ResourceFlowDirection should be initialized in each resx file to match these values with that
+        // file's culture. For example:
+        //
+        // AppResources.es-ES.resx
+        //    ResourceLanguage's value should be "es-ES"
+        //    ResourceFlowDirection's value should be "LeftToRight"
+        //
+        // AppResources.ar-SA.resx
+        //     ResourceLanguage's value should be "ar-SA"
+        //     ResourceFlowDirection's value should be "RightToLeft"
+        //
+        // For more info on localizing Windows Phone apps see http://go.microsoft.com/fwlink/?LinkId=262072.
+        //
+        private void InitializeLanguage()
+        {
+            try
+            {
+                // Set the font to match the display language defined by the
+                // ResourceLanguage resource string for each supported language.
+                //
+                // Fall back to the font of the neutral language if the Display
+                // language of the phone is not supported.
+                //
+                // If a compiler error is hit then ResourceLanguage is missing from
+                // the resource file.
+                RootFrame.Language = XmlLanguage.GetLanguage(AppResources.ResourceLanguage);
+
+                // Set the FlowDirection of all elements under the root frame based
+                // on the ResourceFlowDirection resource string for each
+                // supported language.
+                //
+                // If a compiler error is hit then ResourceFlowDirection is missing from
+                // the resource file.
+                FlowDirection flow = (FlowDirection)Enum.Parse(typeof(FlowDirection), AppResources.ResourceFlowDirection);
+                RootFrame.FlowDirection = flow;
+            }
+            catch
+            {
+                // If an exception is caught here it is most likely due to either
+                // ResourceLanguage not being correctly set to a supported language
+                // code or ResourceFlowDirection is set to a value other than LeftToRight
+                // or RightToLeft.
+
+                if (Debugger.IsAttached)
+                {
+                    Debugger.Break();
+                }
+
+                throw;
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/AlignmentGrid.png b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/AlignmentGrid.png
new file mode 100644
index 00000000..f7d2e978
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/AlignmentGrid.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/ApplicationIcon.png b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/ApplicationIcon.png
new file mode 100644
index 00000000..7d95d4e0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/ApplicationIcon.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Lena.png b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Lena.png
new file mode 100644
index 00000000..3e866873
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Lena.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileLarge.png b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileLarge.png
new file mode 100644
index 00000000..e0c59ac0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileLarge.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileMedium.png b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileMedium.png
new file mode 100644
index 00000000..e93b89d6
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileMedium.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileSmall.png b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileSmall.png
new file mode 100644
index 00000000..550b1b5e
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/FlipCycleTileSmall.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileMediumLarge.png b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileMediumLarge.png
new file mode 100644
index 00000000..686e6b53
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileMediumLarge.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileSmall.png b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileSmall.png
new file mode 100644
index 00000000..d4b5ede1
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Assets/Tiles/IconicTileSmall.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/LocalizedStrings.cs b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/LocalizedStrings.cs
new file mode 100644
index 00000000..509836a9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/LocalizedStrings.cs
@@ -0,0 +1,14 @@
+using PhoneXamlDirect3DApp1.Resources;
+
+namespace PhoneXamlDirect3DApp1
+{
+    /// <summary>
+    /// Provides access to string resources.
+    /// </summary>
+    public class LocalizedStrings
+    {
+        private static AppResources _localizedResources = new AppResources();
+
+        public AppResources LocalizedResources { get { return _localizedResources; } }
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml
new file mode 100644
index 00000000..3c8281df
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml
@@ -0,0 +1,40 @@
+<phone:PhoneApplicationPage x:Class="PhoneXamlDirect3DApp1.MainPage"
+                            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+                            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+                            xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
+                            xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
+                            FontFamily="{StaticResource PhoneFontFamilyNormal}"
+                            FontSize="{StaticResource PhoneFontSizeNormal}"
+                            Foreground="{StaticResource PhoneForegroundBrush}"
+                            Orientation="Portrait"
+                            SupportedOrientations="Portrait"
+                            shell:SystemTray.IsVisible="True"
+                            mc:Ignorable="d">
+
+    <!--  LayoutRoot is the root grid where all page content is placed  -->
+    <Grid x:Name="LayoutRoot" Background="Transparent">
+        <DrawingSurface x:Name="DrawingSurface" Loaded="DrawingSurface_Loaded" />
+        <StackPanel Margin="40">
+            <RadioButton x:Name="Normal"
+                         Checked="RadioButton_Checked"
+                         Content="Normal"
+                         GroupName="Group1"
+                         IsChecked="True" />
+            <RadioButton x:Name="Gray"
+                         Checked="RadioButton_Checked"
+                         Content="Gray"
+                         GroupName="Group1" />
+            <RadioButton x:Name="Canny"
+                         Checked="RadioButton_Checked"
+                         Content="Canny"
+                         GroupName="Group1" />
+            <RadioButton x:Name="Sepia"
+                         Checked="RadioButton_Checked"
+                         Content="Sepia"
+                         GroupName="Group1" />
+        </StackPanel>
+    </Grid>
+
+</phone:PhoneApplicationPage>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml.cs b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml.cs
new file mode 100644
index 00000000..7815d01e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/MainPage.xaml.cs
@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Navigation;
+using Microsoft.Phone.Controls;
+using Microsoft.Phone.Shell;
+using PhoneXamlDirect3DApp1Comp;
+using Microsoft.Phone.Tasks;
+using System.Windows.Media.Imaging;
+using System.Threading;
+using System.Windows.Resources;
+using System.IO;
+using  System.Runtime.InteropServices.WindowsRuntime;
+using Microsoft.Xna.Framework.Media;
+
+namespace PhoneXamlDirect3DApp1
+{
+    public partial class MainPage : PhoneApplicationPage
+    {
+        private Direct3DInterop m_d3dInterop = new Direct3DInterop();
+        WriteableBitmap m_bmp;
+        bool m_bInitialized = false;
+
+        // Constructor
+        public MainPage()
+        {
+            InitializeComponent();
+        }
+
+        private void DrawingSurface_Loaded(object sender, RoutedEventArgs e)
+        {
+            // Set window bounds in dips
+            m_d3dInterop.WindowBounds = new Windows.Foundation.Size(
+                (float)DrawingSurface.ActualWidth,
+                (float)DrawingSurface.ActualHeight
+                );
+
+            // Set native resolution in pixels
+            m_d3dInterop.NativeResolution = new Windows.Foundation.Size(
+                (float)Math.Floor(DrawingSurface.ActualWidth * Application.Current.Host.Content.ScaleFactor / 100.0f + 0.5f),
+                (float)Math.Floor(DrawingSurface.ActualHeight * Application.Current.Host.Content.ScaleFactor / 100.0f + 0.5f)
+                );
+
+            // Set render resolution to the full native resolution
+            m_d3dInterop.RenderResolution = m_d3dInterop.NativeResolution;
+
+            // Hook-up native component to DrawingSurface
+            DrawingSurface.SetContentProvider(m_d3dInterop.CreateContentProvider());
+            DrawingSurface.SetManipulationHandler(m_d3dInterop);
+
+
+            Deployment.Current.Dispatcher.BeginInvoke(() =>
+                {
+                    StreamResourceInfo resourceInfo = Application.GetResourceStream(new Uri("Assets/Lena.png", UriKind.Relative));
+                    BitmapImage bitmap = new BitmapImage();
+                    bitmap.SetSource(resourceInfo.Stream);
+                    m_bmp = new WriteableBitmap(bitmap);
+                    m_d3dInterop.CreateTexture(m_bmp.Pixels, m_bmp.PixelWidth, m_bmp.PixelHeight, OCVFilterType.ePreview);
+                    m_bInitialized = true;
+                });
+        }
+
+
+        private void RadioButton_Checked(object sender, RoutedEventArgs e)
+        {
+            if (!m_bInitialized)
+            {
+                return;
+            }
+
+            RadioButton rb = sender as RadioButton;
+            switch (rb.Name)
+            {
+                case "Normal":
+                    m_d3dInterop.CreateTexture(m_bmp.Pixels, m_bmp.PixelWidth, m_bmp.PixelHeight, OCVFilterType.ePreview);
+                    break;
+
+                case "Gray":
+                    m_d3dInterop.CreateTexture(m_bmp.Pixels, m_bmp.PixelWidth, m_bmp.PixelHeight, OCVFilterType.eGray);
+                    break;
+
+                case "Canny":
+                    m_d3dInterop.CreateTexture(m_bmp.Pixels, m_bmp.PixelWidth, m_bmp.PixelHeight, OCVFilterType.eCanny);
+                    break;
+
+                case "Sepia":
+                    m_d3dInterop.CreateTexture(m_bmp.Pixels, m_bmp.PixelWidth, m_bmp.PixelHeight, OCVFilterType.eSepia);
+                    break;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/OcvRotatingCube.csproj b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/OcvRotatingCube.csproj
new file mode 100644
index 00000000..6963fb51
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/OcvRotatingCube.csproj
@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>10.0.20506</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{CC734B3D-D8F2-4528-B223-0E7B8A4F6CC7}</ProjectGuid>
+    <ProjectTypeGuids>{C089C8C0-30E0-4E22-80C0-CE093F111A43};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>PhoneXamlDirect3DApp1</RootNamespace>
+    <AssemblyName>PhoneXamlDirect3DApp1</AssemblyName>
+    <TargetFrameworkIdentifier>WindowsPhone</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v8.0</TargetFrameworkVersion>
+    <SilverlightVersion>$(TargetFrameworkVersion)</SilverlightVersion>
+    <SilverlightApplication>true</SilverlightApplication>
+    <SupportedCultures>
+    </SupportedCultures>
+    <XapOutputs>true</XapOutputs>
+    <GenerateSilverlightManifest>true</GenerateSilverlightManifest>
+    <XapFilename>OCVRotatingCube.xap</XapFilename>
+    <SilverlightManifestTemplate>Properties\AppManifest.xml</SilverlightManifestTemplate>
+    <SilverlightAppEntry>PhoneXamlDirect3DApp1.App</SilverlightAppEntry>
+    <ValidateXaml>true</ValidateXaml>
+    <MinimumVisualStudioVersion>11.0</MinimumVisualStudioVersion>
+    <ThrowErrorsInValidation>true</ThrowErrorsInValidation>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>Bin\Debug</OutputPath>
+    <DefineConstants>DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>Bin\Release</OutputPath>
+    <DefineConstants>TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>Bin\x86\Debug</OutputPath>
+    <DefineConstants>DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>Bin\x86\Release</OutputPath>
+    <DefineConstants>TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|ARM' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>Bin\ARM\Debug</OutputPath>
+    <DefineConstants>DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|ARM' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>Bin\ARM\Release</OutputPath>
+    <DefineConstants>TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="App.xaml.cs">
+      <DependentUpon>App.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="LocalizedStrings.cs" />
+    <Compile Include="MainPage.xaml.cs">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Resources\AppResources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>AppResources.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </ApplicationDefinition>
+    <Page Include="MainPage.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Properties\AppManifest.xml" />
+    <None Include="Properties\WMAppManifest.xml">
+      <SubType>Designer</SubType>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Assets\AlignmentGrid.png" />
+    <Content Include="Assets\ApplicationIcon.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\FlipCycleTileLarge.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\FlipCycleTileMedium.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\FlipCycleTileSmall.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\IconicTileMediumLarge.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\IconicTileSmall.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Lena.png" />
+    <Content Include="SplashScreenImage.jpg" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\PhoneXamlDirect3DApp1Comp\PhoneXamlDirect3DApp1Comp.vcxproj">
+      <Name>PhoneXamlDirect3DApp1Comp</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Resources\AppResources.resx">
+      <Generator>PublicResXFileCodeGenerator</Generator>
+      <LastGenOutput>AppResources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\$(TargetFrameworkIdentifier)\$(TargetFrameworkVersion)\Microsoft.$(TargetFrameworkIdentifier).$(TargetFrameworkVersion).Overrides.targets" />
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\$(TargetFrameworkIdentifier)\$(TargetFrameworkVersion)\Microsoft.$(TargetFrameworkIdentifier).CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <ProjectExtensions />
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AppManifest.xml b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AppManifest.xml
new file mode 100644
index 00000000..6712a117
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AppManifest.xml
@@ -0,0 +1,6 @@
+<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+>
+    <Deployment.Parts>
+    </Deployment.Parts>
+</Deployment>
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AssemblyInfo.cs b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..a22da51b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/AssemblyInfo.cs
@@ -0,0 +1,37 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Resources;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("PhoneXamlDirect3DApp1")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("PhoneXamlDirect3DApp1")]
+[assembly: AssemblyCopyright("Copyright ©  2013")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("8ca838f9-f7c6-4550-9b89-59e915a2cddb")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: NeutralResourcesLanguageAttribute("en-US")]
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/WMAppManifest.xml b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/WMAppManifest.xml
new file mode 100644
index 00000000..9218e1e8
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Properties/WMAppManifest.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Deployment xmlns="http://schemas.microsoft.com/windowsphone/2012/deployment" AppPlatformVersion="8.0">
+  <DefaultLanguage xmlns="" code="en-US" />
+  <App xmlns="" ProductID="{cc734b3d-d8f2-4528-b223-0e7b8a4f6cc7}" Title="OCVRotatingCube" RuntimeType="Silverlight" Version="1.0.0.0" Genre="apps.normal" Author="Microsoft Open Technologies, Inc." Description="Sample description" Publisher="Microsoft Open Technologies, Inc." PublisherID="{4029c95e-d442-45ca-b556-33d7e3bde613}">
+    <IconPath IsRelative="true" IsResource="false">Assets\ApplicationIcon.png</IconPath>
+    <Capabilities>
+      <Capability Name="ID_CAP_SENSORS" />
+      <Capability Name="ID_CAP_WEBBROWSERCOMPONENT" />
+      <Capability Name="ID_CAP_MEDIALIB_PLAYBACK" />
+      <Capability Name="ID_CAP_MEDIALIB_PHOTO" />
+      <Capability Name="ID_CAP_MEDIALIB_AUDIO" />
+      <Capability Name="ID_CAP_NETWORKING" />
+    </Capabilities>
+    <Tasks>
+      <DefaultTask Name="_default" NavigationPage="MainPage.xaml" />
+    </Tasks>
+    <Tokens>
+      <PrimaryToken TokenID="PhoneXamlDirect3DApp1Token" TaskName="_default">
+        <TemplateFlip>
+          <SmallImageURI IsRelative="true" IsResource="false">Assets\Tiles\FlipCycleTileSmall.png</SmallImageURI>
+          <Count>0</Count>
+          <BackgroundImageURI IsRelative="true" IsResource="false">Assets\Tiles\FlipCycleTileMedium.png</BackgroundImageURI>
+          <Title>OCVRotatingCube</Title>
+          <BackContent>
+          </BackContent>
+          <BackBackgroundImageURI>
+          </BackBackgroundImageURI>
+          <BackTitle>
+          </BackTitle>
+          <DeviceLockImageURI>
+          </DeviceLockImageURI>
+          <HasLarge>
+          </HasLarge>
+        </TemplateFlip>
+      </PrimaryToken>
+    </Tokens>
+    <ScreenResolutions>
+      <ScreenResolution Name="ID_RESOLUTION_WVGA" />
+      <ScreenResolution Name="ID_RESOLUTION_WXGA" />
+      <ScreenResolution Name="ID_RESOLUTION_HD720P" />
+    </ScreenResolutions>
+  </App>
+</Deployment>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.Designer.cs b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.Designer.cs
new file mode 100644
index 00000000..e34b684a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.Designer.cs
@@ -0,0 +1,105 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.17626
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace PhoneXamlDirect3DApp1.Resources
+{
+    using System;
+
+
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    public class AppResources
+    {
+
+        private static global::System.Resources.ResourceManager resourceMan;
+
+        private static global::System.Globalization.CultureInfo resourceCulture;
+
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal AppResources()
+        {
+        }
+
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Resources.ResourceManager ResourceManager
+        {
+            get
+            {
+                if (object.ReferenceEquals(resourceMan, null))
+                {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("PhoneXamlDirect3DApp1.Resources.AppResources", typeof(AppResources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Globalization.CultureInfo Culture
+        {
+            get
+            {
+                return resourceCulture;
+            }
+            set
+            {
+                resourceCulture = value;
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to LeftToRight.
+        /// </summary>
+        public static string ResourceFlowDirection
+        {
+            get
+            {
+                return ResourceManager.GetString("ResourceFlowDirection", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to us-EN.
+        /// </summary>
+        public static string ResourceLanguage
+        {
+            get
+            {
+                return ResourceManager.GetString("ResourceLanguage", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to MY APPLICATION.
+        /// </summary>
+        public static string ApplicationTitle
+        {
+            get
+            {
+                return ResourceManager.GetString("ApplicationTitle", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.resx b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.resx
new file mode 100644
index 00000000..38c1356d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/Resources/AppResources.resx
@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ResourceFlowDirection" xml:space="preserve">
+    <value>LeftToRight</value>
+    <comment>Controls the FlowDirection for all elements in the RootFrame. Set to the traditional direction of this resource file's language</comment>
+  </data>
+  <data name="ResourceLanguage" xml:space="preserve">
+    <value>en-US</value>
+    <comment>Controls the Language and ensures that the font for all elements in the RootFrame aligns with the app's language. Set to the language code of this resource file's language.</comment>
+  </data>
+  <data name="ApplicationTitle" xml:space="preserve">
+    <value>MY APPLICATION</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/SplashScreenImage.jpg b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/SplashScreenImage.jpg
new file mode 100644
index 00000000..566fbb05
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1/SplashScreenImage.jpg differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/BasicTimer.h b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/BasicTimer.h
new file mode 100644
index 00000000..640b6cb9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/BasicTimer.h
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <wrl.h>
+
+// Helper class for basic timing.
+ref class BasicTimer sealed
+{
+public:
+    // Initializes internal timer values.
+    BasicTimer()
+    {
+        if (!QueryPerformanceFrequency(&m_frequency))
+        {
+            throw ref new Platform::FailureException();
+        }
+        Reset();
+    }
+
+    // Reset the timer to initial values.
+    void Reset()
+    {
+        Update();
+        m_startTime = m_currentTime;
+        m_total = 0.0f;
+        m_delta = 1.0f / 60.0f;
+    }
+
+    // Update the timer's internal values.
+    void Update()
+    {
+        if (!QueryPerformanceCounter(&m_currentTime))
+        {
+            throw ref new Platform::FailureException();
+        }
+
+        m_total = static_cast<float>(
+            static_cast<double>(m_currentTime.QuadPart - m_startTime.QuadPart) /
+            static_cast<double>(m_frequency.QuadPart)
+            );
+
+        if (m_lastTime.QuadPart == m_startTime.QuadPart)
+        {
+            // If the timer was just reset, report a time delta equivalent to 60Hz frame time.
+            m_delta = 1.0f / 60.0f;
+        }
+        else
+        {
+            m_delta = static_cast<float>(
+                static_cast<double>(m_currentTime.QuadPart - m_lastTime.QuadPart) /
+                static_cast<double>(m_frequency.QuadPart)
+                );
+        }
+
+        m_lastTime = m_currentTime;
+    }
+
+    // Duration in seconds between the last call to Reset() and the last call to Update().
+    property float Total
+    {
+        float get() { return m_total; }
+    }
+
+    // Duration in seconds between the previous two calls to Update().
+    property float Delta
+    {
+        float get() { return m_delta; }
+    }
+
+private:
+    LARGE_INTEGER m_frequency;
+    LARGE_INTEGER m_currentTime;
+    LARGE_INTEGER m_startTime;
+    LARGE_INTEGER m_lastTime;
+    float m_total;
+    float m_delta;
+};
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/CubeRenderer.cpp b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/CubeRenderer.cpp
new file mode 100644
index 00000000..3b7b61e7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/CubeRenderer.cpp
@@ -0,0 +1,416 @@
+#include "pch.h"
+#include "CubeRenderer.h"
+
+
+using namespace DirectX;
+using namespace Microsoft::WRL;
+using namespace Windows::Foundation;
+using namespace Windows::UI::Core;
+
+CubeRenderer::CubeRenderer() :
+    m_loadingComplete(false),
+    m_indexCount(0)
+{
+}
+
+void CubeRenderer::CreateTextureFromByte(byte* buffer, int width, int height)
+{
+    int pixelSize = 4;
+
+    if (m_texture.Get() == nullptr)
+    {
+        CD3D11_TEXTURE2D_DESC textureDesc(
+            DXGI_FORMAT_B8G8R8A8_UNORM,		// format
+            static_cast<UINT>(width),		// width
+            static_cast<UINT>(height),		// height
+            1,								// arraySize
+            1,								// mipLevels
+            D3D11_BIND_SHADER_RESOURCE,		// bindFlags
+            D3D11_USAGE_DYNAMIC,			// usage
+            D3D11_CPU_ACCESS_WRITE,			// cpuaccessFlags
+            1,								// sampleCount
+            0,								// sampleQuality
+            0								// miscFlags
+            );
+
+        D3D11_SUBRESOURCE_DATA data;
+        data.pSysMem = buffer;
+        data.SysMemPitch = pixelSize*width;
+        data.SysMemSlicePitch = pixelSize*width*height;
+
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateTexture2D(
+            &textureDesc,
+            &data,
+            m_texture.ReleaseAndGetAddressOf()
+            )
+            );
+
+        m_d3dDevice->CreateShaderResourceView(m_texture.Get(), NULL, m_SRV.ReleaseAndGetAddressOf());
+        D3D11_SAMPLER_DESC sampDesc;
+        ZeroMemory(&sampDesc, sizeof(sampDesc));
+        sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+        sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
+        sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
+        sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
+        sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
+        sampDesc.MinLOD = 0;
+        sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
+        m_d3dDevice->CreateSamplerState(&sampDesc, m_cubesTexSamplerState.ReleaseAndGetAddressOf());
+    }
+    else
+    {
+        int nRowSpan = width * pixelSize;
+        D3D11_MAPPED_SUBRESOURCE mappedResource;
+        HRESULT hr = m_d3dContext->Map(m_texture.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+        BYTE* mappedData = static_cast<BYTE*>(mappedResource.pData);
+
+        for (int i = 0; i < height; ++i)
+        {
+            memcpy(mappedData + (i*mappedResource.RowPitch), buffer + (i*nRowSpan), nRowSpan);
+        }
+
+        m_d3dContext->Unmap(m_texture.Get(), 0);
+    }
+}
+
+void CubeRenderer::CreateDeviceResources()
+{
+    Direct3DBase::CreateDeviceResources();
+    D3D11_BLEND_DESC blendDesc;
+    ZeroMemory( &blendDesc, sizeof(blendDesc) );
+
+    D3D11_RENDER_TARGET_BLEND_DESC rtbd;
+    ZeroMemory( &rtbd, sizeof(rtbd) );
+
+
+    rtbd.BlendEnable = TRUE;
+    rtbd.SrcBlend = D3D11_BLEND_SRC_ALPHA;
+    rtbd.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
+    rtbd.BlendOp = D3D11_BLEND_OP_ADD;
+    rtbd.SrcBlendAlpha = D3D11_BLEND_ONE;
+    rtbd.DestBlendAlpha = D3D11_BLEND_ZERO;
+    rtbd.BlendOpAlpha = D3D11_BLEND_OP_ADD;
+    rtbd.RenderTargetWriteMask = 0x0f;
+
+
+
+    blendDesc.AlphaToCoverageEnable = false;
+    blendDesc.RenderTarget[0] = rtbd;
+
+    m_d3dDevice->CreateBlendState(&blendDesc, &m_transparency);
+
+
+    D3D11_RASTERIZER_DESC cmdesc;
+    ZeroMemory(&cmdesc, sizeof(D3D11_RASTERIZER_DESC));
+
+    cmdesc.FillMode = D3D11_FILL_SOLID;
+    cmdesc.CullMode = D3D11_CULL_BACK;
+    cmdesc.DepthClipEnable = TRUE;
+
+
+    cmdesc.FrontCounterClockwise = true;
+    m_d3dDevice->CreateRasterizerState(&cmdesc, &m_CCWcullMode);
+
+    cmdesc.FrontCounterClockwise = false;
+    m_d3dDevice->CreateRasterizerState(&cmdesc, &m_CWcullMode);
+
+
+    auto loadVSTask = DX::ReadDataAsync("SimpleVertexShader.cso");
+    auto loadPSTask = DX::ReadDataAsync("SimplePixelShader.cso");
+
+    auto createVSTask = loadVSTask.then([this](Platform::Array<byte>^ fileData) {
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateVertexShader(
+            fileData->Data,
+            fileData->Length,
+            nullptr,
+            &m_vertexShader
+            )
+            );
+
+        const D3D11_INPUT_ELEMENT_DESC vertexDesc[] =
+        {
+            { "POSITION",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0,  D3D11_INPUT_PER_VERTEX_DATA, 0 },
+            { "TEXCOORD",    0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+        };
+
+
+
+
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateInputLayout(
+            vertexDesc,
+            ARRAYSIZE(vertexDesc),
+            fileData->Data,
+            fileData->Length,
+            &m_inputLayout
+            )
+            );
+    });
+
+    auto createPSTask = loadPSTask.then([this](Platform::Array<byte>^ fileData) {
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreatePixelShader(
+            fileData->Data,
+            fileData->Length,
+            nullptr,
+            &m_pixelShader
+            )
+            );
+
+        CD3D11_BUFFER_DESC constantBufferDesc(sizeof(ModelViewProjectionConstantBuffer), D3D11_BIND_CONSTANT_BUFFER);
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateBuffer(
+            &constantBufferDesc,
+            nullptr,
+            &m_constantBuffer
+            )
+            );
+    });
+
+    auto createCubeTask = (createPSTask && createVSTask).then([this] () {
+        Vertex v[] =
+        {
+            // Front Face
+            Vertex(-1.0f, -1.0f, -1.0f, 0.0f, 1.0f),
+            Vertex(-1.0f,  1.0f, -1.0f, 0.0f, 0.0f),
+            Vertex( 1.0f,  1.0f, -1.0f, 1.0f, 0.0f),
+            Vertex( 1.0f, -1.0f, -1.0f, 1.0f, 1.0f),
+
+            // Back Face
+            Vertex(-1.0f, -1.0f, 1.0f, 1.0f, 1.0f),
+            Vertex( 1.0f, -1.0f, 1.0f, 0.0f, 1.0f),
+            Vertex( 1.0f,  1.0f, 1.0f, 0.0f, 0.0f),
+            Vertex(-1.0f,  1.0f, 1.0f, 1.0f, 0.0f),
+
+            // Top Face
+            Vertex(-1.0f, 1.0f, -1.0f, 0.0f, 1.0f),
+            Vertex(-1.0f, 1.0f,  1.0f, 0.0f, 0.0f),
+            Vertex( 1.0f, 1.0f,  1.0f, 1.0f, 0.0f),
+            Vertex( 1.0f, 1.0f, -1.0f, 1.0f, 1.0f),
+
+            // Bottom Face
+            Vertex(-1.0f, -1.0f, -1.0f, 1.0f, 1.0f),
+            Vertex( 1.0f, -1.0f, -1.0f, 0.0f, 1.0f),
+            Vertex( 1.0f, -1.0f,  1.0f, 0.0f, 0.0f),
+            Vertex(-1.0f, -1.0f,  1.0f, 1.0f, 0.0f),
+
+            // Left Face
+            Vertex(-1.0f, -1.0f,  1.0f, 0.0f, 1.0f),
+            Vertex(-1.0f,  1.0f,  1.0f, 0.0f, 0.0f),
+            Vertex(-1.0f,  1.0f, -1.0f, 1.0f, 0.0f),
+            Vertex(-1.0f, -1.0f, -1.0f, 1.0f, 1.0f),
+
+            // Right Face
+            Vertex( 1.0f, -1.0f, -1.0f, 0.0f, 1.0f),
+            Vertex( 1.0f,  1.0f, -1.0f, 0.0f, 0.0f),
+            Vertex( 1.0f,  1.0f,  1.0f, 1.0f, 0.0f),
+            Vertex( 1.0f, -1.0f,  1.0f, 1.0f, 1.0f),
+        };
+
+
+
+        D3D11_SUBRESOURCE_DATA vertexBufferData = {0};
+        vertexBufferData.pSysMem = v;
+        vertexBufferData.SysMemPitch = 0;
+        vertexBufferData.SysMemSlicePitch = 0;
+        CD3D11_BUFFER_DESC vertexBufferDesc(sizeof(v), D3D11_BIND_VERTEX_BUFFER);
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateBuffer(
+            &vertexBufferDesc,
+            &vertexBufferData,
+            &m_vertexBuffer
+            )
+            );
+
+        DWORD indices[] = {
+            // Front Face
+            0,  2,  1,
+            0,  3,  2,
+
+            // Back Face
+            4,  6,  5,
+            4,  7,  6,
+
+            // Top Face
+            8,  10, 9,
+            8, 11, 10,
+
+            // Bottom Face
+            12, 14, 13,
+            12, 15, 14,
+
+            // Left Face
+            16, 18, 17,
+            16, 19, 18,
+
+            // Right Face
+            20, 22, 21,
+            20, 23, 22
+        };
+
+        m_indexCount = ARRAYSIZE(indices);
+
+        D3D11_SUBRESOURCE_DATA indexBufferData = {0};
+        indexBufferData.pSysMem = indices;
+        indexBufferData.SysMemPitch = 0;
+        indexBufferData.SysMemSlicePitch = 0;
+        CD3D11_BUFFER_DESC indexBufferDesc(sizeof(indices), D3D11_BIND_INDEX_BUFFER);
+        DX::ThrowIfFailed(
+            m_d3dDevice->CreateBuffer(
+            &indexBufferDesc,
+            &indexBufferData,
+            &m_indexBuffer
+            )
+            );
+    });
+
+    createCubeTask.then([this] () {
+        m_loadingComplete = true;
+    });
+}
+
+void CubeRenderer::CreateWindowSizeDependentResources()
+{
+    Direct3DBase::CreateWindowSizeDependentResources();
+
+    float aspectRatio = m_windowBounds.Width / m_windowBounds.Height;
+    float fovAngleY = 70.0f * XM_PI / 180.0f;
+    if (aspectRatio < 1.0f)
+    {
+        fovAngleY /= aspectRatio;
+    }
+
+    XMStoreFloat4x4(
+        &m_constantBufferData.projection,
+        XMMatrixTranspose(
+        XMMatrixPerspectiveFovRH(
+        fovAngleY,
+        aspectRatio,
+        0.01f,
+        100.0f
+        )
+        )
+        );
+}
+
+void CubeRenderer::Update(float timeTotal, float timeDelta)
+{
+    (void) timeDelta; // Unused parameter.
+
+    XMVECTOR eye = XMVectorSet(0.0f, 0.0f, 3.f, 0.0f);
+    XMVECTOR at = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
+    XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
+
+    XMStoreFloat4x4(&m_constantBufferData.view, XMMatrixTranspose(XMMatrixLookAtRH(eye, at, up)));
+    XMStoreFloat4x4(&m_constantBufferData.model, XMMatrixTranspose(XMMatrixRotationY(timeTotal * XM_PIDIV4)));
+
+
+}
+
+void CubeRenderer::Render()
+{
+
+    std::lock_guard<std::mutex> lock(m_mutex);
+    Render(m_renderTargetView, m_depthStencilView);
+}
+
+void CubeRenderer::Render(Microsoft::WRL::ComPtr<ID3D11RenderTargetView> renderTargetView, Microsoft::WRL::ComPtr<ID3D11DepthStencilView> depthStencilView)
+{
+
+    const float black[] = {0, 0, 0, 1.0 };
+    m_d3dContext->ClearRenderTargetView(
+        renderTargetView.Get(),
+        black
+        );
+
+    m_d3dContext->ClearDepthStencilView(
+        depthStencilView.Get(),
+        D3D11_CLEAR_DEPTH,
+        1.0f,
+        0
+        );
+
+
+
+    // Only draw the cube once it is loaded (loading is asynchronous).
+    if (!m_SRV || !m_loadingComplete)
+    {
+        return;
+    }
+
+    m_d3dContext->OMSetRenderTargets(
+        1,
+        renderTargetView.GetAddressOf(),
+        depthStencilView.Get()
+        );
+
+    m_d3dContext->UpdateSubresource(
+        m_constantBuffer.Get(),
+        0,
+        NULL,
+        &m_constantBufferData,
+        0,
+        0
+        );
+
+    UINT stride = sizeof(Vertex);
+    UINT offset = 0;
+    m_d3dContext->IASetVertexBuffers(
+        0,
+        1,
+        m_vertexBuffer.GetAddressOf(),
+        &stride,
+        &offset
+        );
+
+    m_d3dContext->IASetIndexBuffer(
+        m_indexBuffer.Get(),
+        DXGI_FORMAT_R32_UINT,
+        0
+        );
+
+
+    m_d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+
+    m_d3dContext->IASetInputLayout(m_inputLayout.Get());
+
+    m_d3dContext->VSSetShader(
+        m_vertexShader.Get(),
+        nullptr,
+        0
+        );
+
+    m_d3dContext->VSSetConstantBuffers(
+        0,
+        1,
+        m_constantBuffer.GetAddressOf()
+        );
+
+    m_d3dContext->PSSetShader(
+        m_pixelShader.Get(),
+        nullptr,
+        0
+        );
+
+    m_d3dContext->PSSetShaderResources( 0, 1, m_SRV.GetAddressOf());
+    m_d3dContext->PSSetSamplers( 0, 1, m_cubesTexSamplerState.GetAddressOf());
+
+    //float blendFactor[] = {0.75f, 0.75f, 0.75f, 1.0f};
+    m_d3dContext->OMSetBlendState(m_transparency.Get(), nullptr, 0xffffffff);
+
+    m_d3dContext->RSSetState(m_CCWcullMode.Get());
+    m_d3dContext->DrawIndexed(
+        m_indexCount,
+        0,
+        0
+        );
+
+    m_d3dContext->RSSetState(m_CWcullMode.Get());
+    m_d3dContext->DrawIndexed(
+        m_indexCount,
+        0,
+        0
+        );
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/CubeRenderer.h b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/CubeRenderer.h
new file mode 100644
index 00000000..cec5afa5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/CubeRenderer.h
@@ -0,0 +1,61 @@
+#pragma once
+
+#include "Direct3DBase.h"
+#include <d3d11.h>
+#include <mutex>
+
+
+struct ModelViewProjectionConstantBuffer
+{
+    DirectX::XMFLOAT4X4 model;
+    DirectX::XMFLOAT4X4 view;
+    DirectX::XMFLOAT4X4 projection;
+};
+
+struct Vertex	//Overloaded Vertex Structure
+{
+    Vertex(){}
+    Vertex(float x, float y, float z,
+        float u, float v)
+        : pos(x,y,z), texCoord(u, v){}
+
+    DirectX::XMFLOAT3 pos;
+    DirectX::XMFLOAT2 texCoord;
+};
+
+// This class renders a simple spinning cube.
+ref class CubeRenderer sealed : public Direct3DBase
+{
+public:
+    CubeRenderer();
+
+    // Direct3DBase methods.
+    virtual void CreateDeviceResources() override;
+    virtual void CreateWindowSizeDependentResources() override;
+    virtual void Render() override;
+
+    // Method for updating time-dependent objects.
+    void Update(float timeTotal, float timeDelta);
+
+    void CreateTextureFromByte(byte  *  buffer,int width,int height);
+private:
+    void Render(Microsoft::WRL::ComPtr<ID3D11RenderTargetView> renderTargetView, Microsoft::WRL::ComPtr<ID3D11DepthStencilView> depthStencilView);
+    bool m_loadingComplete;
+
+    Microsoft::WRL::ComPtr<ID3D11InputLayout>	m_inputLayout;
+    Microsoft::WRL::ComPtr<ID3D11Buffer>		m_vertexBuffer;
+    Microsoft::WRL::ComPtr<ID3D11Buffer>		m_indexBuffer;
+    Microsoft::WRL::ComPtr<ID3D11VertexShader>	m_vertexShader;
+    Microsoft::WRL::ComPtr<ID3D11PixelShader>	m_pixelShader;
+    Microsoft::WRL::ComPtr<ID3D11Buffer>		m_constantBuffer;
+    Microsoft::WRL::ComPtr<ID3D11Texture2D>		 m_texture;
+    Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> m_SRV;
+    Microsoft::WRL::ComPtr<ID3D11SamplerState> m_cubesTexSamplerState;
+    uint32 m_indexCount;
+    ModelViewProjectionConstantBuffer m_constantBufferData;
+    std::mutex   m_mutex;
+    Microsoft::WRL::ComPtr<ID3D11BlendState> m_transparency;
+    Microsoft::WRL::ComPtr<ID3D11RasterizerState> m_CCWcullMode;
+    Microsoft::WRL::ComPtr<ID3D11RasterizerState> m_CWcullMode;
+
+};
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.cpp b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.cpp
new file mode 100644
index 00000000..351629e1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.cpp
@@ -0,0 +1,162 @@
+#include "pch.h"
+#include "Direct3DBase.h"
+
+using namespace DirectX;
+using namespace Microsoft::WRL;
+using namespace Windows::UI::Core;
+using namespace Windows::Foundation;
+using namespace Windows::Graphics::Display;
+
+// Constructor.
+Direct3DBase::Direct3DBase()
+{
+}
+
+// Initialize the Direct3D resources required to run.
+void Direct3DBase::Initialize()
+{
+    CreateDeviceResources();
+}
+
+// These are the resources that depend on the device.
+void Direct3DBase::CreateDeviceResources()
+{
+    // This flag adds support for surfaces with a different color channel ordering
+    // than the API default. It is required for compatibility with Direct2D.
+    UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
+
+#if defined(_DEBUG)
+    // If the project is in a debug build, enable debugging via SDK Layers with this flag.
+    creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
+#endif
+
+    // This array defines the set of DirectX hardware feature levels this app will support.
+    // Note the ordering should be preserved.
+    // Don't forget to declare your application's minimum required feature level in its
+    // description.  All applications are assumed to support 9.1 unless otherwise stated.
+    D3D_FEATURE_LEVEL featureLevels[] =
+    {
+        D3D_FEATURE_LEVEL_11_1,
+        D3D_FEATURE_LEVEL_11_0,
+        D3D_FEATURE_LEVEL_10_1,
+        D3D_FEATURE_LEVEL_10_0,
+        D3D_FEATURE_LEVEL_9_3
+    };
+
+    // Create the Direct3D 11 API device object and a corresponding context.
+    ComPtr<ID3D11Device> device;
+    ComPtr<ID3D11DeviceContext> context;
+    DX::ThrowIfFailed(
+        D3D11CreateDevice(
+            nullptr, // Specify nullptr to use the default adapter.
+            D3D_DRIVER_TYPE_HARDWARE,
+            nullptr,
+            creationFlags, // Set set debug and Direct2D compatibility flags.
+            featureLevels, // List of feature levels this app can support.
+            ARRAYSIZE(featureLevels),
+            D3D11_SDK_VERSION, // Always set this to D3D11_SDK_VERSION.
+            &device, // Returns the Direct3D device created.
+            &m_featureLevel, // Returns feature level of device created.
+            &context // Returns the device immediate context.
+            )
+        );
+
+    // Get the Direct3D 11.1 API device and context interfaces.
+    DX::ThrowIfFailed(
+        device.As(&m_d3dDevice)
+        );
+
+    DX::ThrowIfFailed(
+        context.As(&m_d3dContext)
+        );
+}
+
+// Allocate all memory resources that depend on the window size.
+void Direct3DBase::CreateWindowSizeDependentResources()
+{
+    // Create a descriptor for the render target buffer.
+    CD3D11_TEXTURE2D_DESC renderTargetDesc(
+        DXGI_FORMAT_B8G8R8A8_UNORM,
+        static_cast<UINT>(m_renderTargetSize.Width),
+        static_cast<UINT>(m_renderTargetSize.Height),
+        1,
+        1,
+        D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE
+        );
+    renderTargetDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX | D3D11_RESOURCE_MISC_SHARED_NTHANDLE;
+
+    // Allocate a 2-D surface as the render target buffer.
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateTexture2D(
+            &renderTargetDesc,
+            nullptr,
+            &m_renderTarget
+            )
+        );
+
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateRenderTargetView(
+            m_renderTarget.Get(),
+            nullptr,
+            &m_renderTargetView
+            )
+        );
+
+    // Create a depth stencil view.
+    CD3D11_TEXTURE2D_DESC depthStencilDesc(
+        DXGI_FORMAT_D24_UNORM_S8_UINT,
+        static_cast<UINT>(m_renderTargetSize.Width),
+        static_cast<UINT>(m_renderTargetSize.Height),
+        1,
+        1,
+        D3D11_BIND_DEPTH_STENCIL
+        );
+
+    ComPtr<ID3D11Texture2D> depthStencil;
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateTexture2D(
+            &depthStencilDesc,
+            nullptr,
+            &depthStencil
+            )
+        );
+
+    CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D);
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateDepthStencilView(
+            depthStencil.Get(),
+            &depthStencilViewDesc,
+            &m_depthStencilView
+            )
+        );
+
+    // Set the rendering viewport to target the entire window.
+    CD3D11_VIEWPORT viewport(
+        0.0f,
+        0.0f,
+        m_renderTargetSize.Width,
+        m_renderTargetSize.Height
+        );
+
+    m_d3dContext->RSSetViewports(1, &viewport);
+}
+
+void Direct3DBase::UpdateForRenderResolutionChange(float width, float height)
+{
+    m_renderTargetSize.Width = width;
+    m_renderTargetSize.Height = height;
+
+    ID3D11RenderTargetView* nullViews[] = {nullptr};
+    m_d3dContext->OMSetRenderTargets(ARRAYSIZE(nullViews), nullViews, nullptr);
+    m_renderTarget = nullptr;
+    m_renderTargetView = nullptr;
+    m_depthStencilView = nullptr;
+    m_d3dContext->Flush();
+    CreateWindowSizeDependentResources();
+}
+
+void Direct3DBase::UpdateForWindowSizeChange(float width, float height)
+{
+    m_windowBounds.Width  = width;
+    m_windowBounds.Height = height;
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.h b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.h
new file mode 100644
index 00000000..c6f387c1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DBase.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "DirectXHelper.h"
+
+// Helper class that initializes DirectX APIs for 3D rendering.
+ref class Direct3DBase abstract
+{
+internal:
+    Direct3DBase();
+
+public:
+    virtual void Initialize();
+    virtual void CreateDeviceResources();
+    virtual void CreateWindowSizeDependentResources();
+    virtual void UpdateForRenderResolutionChange(float width, float height);
+    virtual void UpdateForWindowSizeChange(float width, float height);
+    virtual void Render() = 0;
+
+internal:
+    virtual ID3D11Texture2D* GetTexture()
+    {
+        return m_renderTarget.Get();
+    }
+
+protected private:
+    // Direct3D Objects.
+    Microsoft::WRL::ComPtr<ID3D11Device1> m_d3dDevice;
+    Microsoft::WRL::ComPtr<ID3D11DeviceContext1> m_d3dContext;
+    Microsoft::WRL::ComPtr<ID3D11Texture2D> m_renderTarget;
+    Microsoft::WRL::ComPtr<ID3D11RenderTargetView> m_renderTargetView;
+    Microsoft::WRL::ComPtr<ID3D11DepthStencilView> m_depthStencilView;
+
+    // Cached renderer properties.
+    D3D_FEATURE_LEVEL m_featureLevel;
+    Windows::Foundation::Size m_renderTargetSize;
+    Windows::Foundation::Rect m_windowBounds;
+};
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.cpp b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.cpp
new file mode 100644
index 00000000..f1fae311
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.cpp
@@ -0,0 +1,77 @@
+#include "pch.h"
+#include "Direct3DContentProvider.h"
+
+using namespace PhoneXamlDirect3DApp1Comp;
+
+Direct3DContentProvider::Direct3DContentProvider(Direct3DInterop^ controller) :
+    m_controller(controller)
+{
+    m_controller->RequestAdditionalFrame += ref new RequestAdditionalFrameHandler([=] ()
+        {
+            if (m_host)
+            {
+                m_host->RequestAdditionalFrame();
+            }
+        });
+
+    m_controller->RecreateSynchronizedTexture += ref new RecreateSynchronizedTextureHandler([=] ()
+        {
+            if (m_host)
+            {
+                m_host->CreateSynchronizedTexture(m_controller->GetTexture(), &m_synchronizedTexture);
+            }
+        });
+}
+
+// IDrawingSurfaceContentProviderNative interface
+HRESULT Direct3DContentProvider::Connect(_In_ IDrawingSurfaceRuntimeHostNative* host)
+{
+    m_host = host;
+
+    return m_controller->Connect(host);
+}
+
+void Direct3DContentProvider::Disconnect()
+{
+    m_controller->Disconnect();
+    m_host = nullptr;
+    m_synchronizedTexture = nullptr;
+}
+
+HRESULT Direct3DContentProvider::PrepareResources(_In_ const LARGE_INTEGER* presentTargetTime, _Out_ BOOL* contentDirty)
+{
+    return m_controller->PrepareResources(presentTargetTime, contentDirty);
+}
+
+HRESULT Direct3DContentProvider::GetTexture(_In_ const DrawingSurfaceSizeF* size, _Out_ IDrawingSurfaceSynchronizedTextureNative** synchronizedTexture, _Out_ DrawingSurfaceRectF* textureSubRectangle)
+{
+    HRESULT hr = S_OK;
+
+    if (!m_synchronizedTexture)
+    {
+        hr = m_host->CreateSynchronizedTexture(m_controller->GetTexture(), &m_synchronizedTexture);
+    }
+
+    // Set output parameters.
+    textureSubRectangle->left = 0.0f;
+    textureSubRectangle->top = 0.0f;
+    textureSubRectangle->right = static_cast<FLOAT>(size->width);
+    textureSubRectangle->bottom = static_cast<FLOAT>(size->height);
+
+    m_synchronizedTexture.CopyTo(synchronizedTexture);
+
+    // Draw to the texture.
+    if (SUCCEEDED(hr))
+    {
+        hr = m_synchronizedTexture->BeginDraw();
+
+        if (SUCCEEDED(hr))
+        {
+            hr = m_controller->GetTexture(size, synchronizedTexture, textureSubRectangle);
+        }
+
+        m_synchronizedTexture->EndDraw();
+    }
+
+    return hr;
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.h b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.h
new file mode 100644
index 00000000..13dd2d70
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DContentProvider.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "pch.h"
+#include <wrl/module.h>
+#include <Windows.Phone.Graphics.Interop.h>
+#include <DrawingSurfaceNative.h>
+
+#include "Direct3DInterop.h"
+
+class Direct3DContentProvider : public Microsoft::WRL::RuntimeClass<
+        Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::WinRtClassicComMix>,
+        ABI::Windows::Phone::Graphics::Interop::IDrawingSurfaceContentProvider,
+        IDrawingSurfaceContentProviderNative>
+{
+public:
+    Direct3DContentProvider(PhoneXamlDirect3DApp1Comp::Direct3DInterop^ controller);
+
+    void ReleaseD3DResources();
+
+    // IDrawingSurfaceContentProviderNative
+    HRESULT STDMETHODCALLTYPE Connect(_In_ IDrawingSurfaceRuntimeHostNative* host);
+    void STDMETHODCALLTYPE Disconnect();
+
+    HRESULT STDMETHODCALLTYPE PrepareResources(_In_ const LARGE_INTEGER* presentTargetTime, _Out_ BOOL* contentDirty);
+    HRESULT STDMETHODCALLTYPE GetTexture(_In_ const DrawingSurfaceSizeF* size, _Out_ IDrawingSurfaceSynchronizedTextureNative** synchronizedTexture, _Out_ DrawingSurfaceRectF* textureSubRectangle);
+
+private:
+    HRESULT InitializeTexture(_In_ const DrawingSurfaceSizeF* size);
+
+    PhoneXamlDirect3DApp1Comp::Direct3DInterop^ m_controller;
+    Microsoft::WRL::ComPtr<IDrawingSurfaceRuntimeHostNative> m_host;
+    Microsoft::WRL::ComPtr<IDrawingSurfaceSynchronizedTextureNative> m_synchronizedTexture;
+};
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.cpp b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.cpp
new file mode 100644
index 00000000..e3158080
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.cpp
@@ -0,0 +1,186 @@
+#include "pch.h"
+#include "Direct3DInterop.h"
+#include "Direct3DContentProvider.h"
+#include <windows.storage.streams.h>
+#include <wrl.h>
+#include <robuffer.h>
+#include <opencv2\imgproc\types_c.h>
+
+using namespace Windows::Storage::Streams;
+using namespace Microsoft::WRL;
+using namespace Windows::Foundation;
+using namespace Windows::UI::Core;
+using namespace Microsoft::WRL;
+using namespace Windows::Phone::Graphics::Interop;
+using namespace Windows::Phone::Input::Interop;
+
+namespace PhoneXamlDirect3DApp1Comp
+{
+    void Direct3DInterop::ApplyGrayFilter(const cv::Mat& image)
+    {
+        cv::Mat intermediateMat;
+        cv::cvtColor(image, intermediateMat, COLOR_RGBA2GRAY);
+        cv::cvtColor(intermediateMat, image, COLOR_GRAY2BGRA);
+    }
+
+    void Direct3DInterop::ApplyCannyFilter(const cv::Mat& image)
+    {
+        cv::Mat intermediateMat;
+        cv::Canny(image, intermediateMat, 80, 90);
+        cv::cvtColor(intermediateMat, image, COLOR_GRAY2BGRA);
+    }
+
+    void Direct3DInterop::ApplySepiaFilter(const cv::Mat& image)
+    {
+        const float SepiaKernelData[16] =
+        {
+            /* B */0.131f, 0.534f, 0.272f, 0.f,
+            /* G */0.168f, 0.686f, 0.349f, 0.f,
+            /* R */0.189f, 0.769f, 0.393f, 0.f,
+            /* A */0.000f, 0.000f, 0.000f, 1.f
+        };
+
+        const cv::Mat SepiaKernel(4, 4, CV_32FC1, (void*)SepiaKernelData);
+        cv::transform(image, image, SepiaKernel);
+    }
+
+    Direct3DInterop::Direct3DInterop() :
+        m_timer(ref new BasicTimer())
+    {
+    }
+
+    IDrawingSurfaceContentProvider^ Direct3DInterop::CreateContentProvider()
+    {
+        ComPtr<Direct3DContentProvider> provider = Make<Direct3DContentProvider>(this);
+        return reinterpret_cast<IDrawingSurfaceContentProvider^>(provider.Detach());
+    }
+
+    // IDrawingSurfaceManipulationHandler
+    void Direct3DInterop::SetManipulationHost(DrawingSurfaceManipulationHost^ manipulationHost)
+    {
+        manipulationHost->PointerPressed +=
+            ref new TypedEventHandler<DrawingSurfaceManipulationHost^, PointerEventArgs^>(this, &Direct3DInterop::OnPointerPressed);
+
+        manipulationHost->PointerMoved +=
+            ref new TypedEventHandler<DrawingSurfaceManipulationHost^, PointerEventArgs^>(this, &Direct3DInterop::OnPointerMoved);
+
+        manipulationHost->PointerReleased +=
+            ref new TypedEventHandler<DrawingSurfaceManipulationHost^, PointerEventArgs^>(this, &Direct3DInterop::OnPointerReleased);
+    }
+
+    void Direct3DInterop::RenderResolution::set(Windows::Foundation::Size renderResolution)
+    {
+        if (renderResolution.Width  != m_renderResolution.Width ||
+            renderResolution.Height != m_renderResolution.Height)
+        {
+            m_renderResolution = renderResolution;
+
+            if (m_renderer)
+            {
+                m_renderer->UpdateForRenderResolutionChange(m_renderResolution.Width, m_renderResolution.Height);
+                RecreateSynchronizedTexture();
+            }
+        }
+    }
+
+    // Event Handlers
+
+    void Direct3DInterop::OnPointerPressed(DrawingSurfaceManipulationHost^ sender, PointerEventArgs^ args)
+    {
+        // Insert your code here.
+    }
+
+    void Direct3DInterop::OnPointerMoved(DrawingSurfaceManipulationHost^ sender, PointerEventArgs^ args)
+    {
+        // Insert your code here.
+    }
+
+    void Direct3DInterop::OnPointerReleased(DrawingSurfaceManipulationHost^ sender, PointerEventArgs^ args)
+    {
+        // Insert your code here.
+    }
+
+    // Interface With Direct3DContentProvider
+    HRESULT Direct3DInterop::Connect(_In_ IDrawingSurfaceRuntimeHostNative* host)
+    {
+        m_renderer = ref new CubeRenderer();
+        m_renderer->Initialize();
+        m_renderer->UpdateForWindowSizeChange(WindowBounds.Width, WindowBounds.Height);
+        m_renderer->UpdateForRenderResolutionChange(m_renderResolution.Width, m_renderResolution.Height);
+
+        // Restart timer after renderer has finished initializing.
+        m_timer->Reset();
+
+        return S_OK;
+    }
+
+    void Direct3DInterop::Disconnect()
+    {
+        m_renderer = nullptr;
+    }
+
+    HRESULT Direct3DInterop::PrepareResources(_In_ const LARGE_INTEGER* presentTargetTime, _Out_ BOOL* contentDirty)
+    {
+        *contentDirty = true;
+
+        return S_OK;
+    }
+
+    HRESULT Direct3DInterop::GetTexture(_In_ const DrawingSurfaceSizeF* size, _Out_ IDrawingSurfaceSynchronizedTextureNative** synchronizedTexture, _Out_ DrawingSurfaceRectF* textureSubRectangle)
+    {
+        m_timer->Update();
+        m_renderer->Update(m_timer->Total, m_timer->Delta);
+        m_renderer->Render();
+
+        RequestAdditionalFrame();
+
+        return S_OK;
+    }
+
+    ID3D11Texture2D* Direct3DInterop::GetTexture()
+    {
+        return m_renderer->GetTexture();
+    }
+
+    void Direct3DInterop::CreateTexture(const Platform::Array<int>^  buffer,int width,int height, OCVFilterType filter)
+    {
+        if (m_renderer)
+        {
+            cv::Mat Lena = cv::Mat(height, width, CV_8UC4);
+            memcpy(Lena.data, buffer->Data, 4 * height*width);
+
+            switch (filter)
+            {
+                case OCVFilterType::ePreview:
+                    break;
+
+                case OCVFilterType::eGray:
+                    ApplyGrayFilter(Lena);
+                    break;
+
+                case OCVFilterType::eCanny:
+                    ApplyCannyFilter(Lena);
+                    break;
+
+                case OCVFilterType::eSepia:
+                    ApplySepiaFilter(Lena);
+                    break;
+            }
+
+            m_renderer->CreateTextureFromByte(Lena.data, width, height);
+        }
+    }
+
+    byte* GetPointerToPixelData( Windows::Storage::Streams::IBuffer ^ pixelBuffer)
+    {
+        // Query the IBufferByteAccess interface.
+        ComPtr<IBufferByteAccess> bufferByteAccess;
+        reinterpret_cast<IInspectable*>( pixelBuffer)->QueryInterface(IID_PPV_ARGS(&bufferByteAccess));
+
+        // Retrieve the buffer data.
+        byte* pixels = nullptr;
+        bufferByteAccess->Buffer(&pixels);
+        return pixels;
+    }
+
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.h b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.h
new file mode 100644
index 00000000..60abd586
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/Direct3DInterop.h
@@ -0,0 +1,80 @@
+#pragma once
+
+#include "pch.h"
+#include "BasicTimer.h"
+#include "CubeRenderer.h"
+#include <DrawingSurfaceNative.h>
+#include <ppltasks.h>
+#include <windows.storage.streams.h>
+#include <opencv2\core\core.hpp>
+#include <opencv2\imgproc\imgproc.hpp>
+#include <opencv2\features2d\features2d.hpp>
+
+namespace PhoneXamlDirect3DApp1Comp
+{
+
+public enum class OCVFilterType
+{
+    ePreview,
+    eGray,
+    eCanny,
+    eSepia,
+    eNumOCVFilterTypes
+};
+
+public delegate void RequestAdditionalFrameHandler();
+public delegate void RecreateSynchronizedTextureHandler();
+
+[Windows::Foundation::Metadata::WebHostHidden]
+public ref class Direct3DInterop sealed : public Windows::Phone::Input::Interop::IDrawingSurfaceManipulationHandler
+{
+public:
+    Direct3DInterop();
+
+    Windows::Phone::Graphics::Interop::IDrawingSurfaceContentProvider^ CreateContentProvider();
+
+    // IDrawingSurfaceManipulationHandler
+    virtual void SetManipulationHost(Windows::Phone::Input::Interop::DrawingSurfaceManipulationHost^ manipulationHost);
+
+    event RequestAdditionalFrameHandler^ RequestAdditionalFrame;
+    event RecreateSynchronizedTextureHandler^ RecreateSynchronizedTexture;
+
+    property Windows::Foundation::Size WindowBounds;
+    property Windows::Foundation::Size NativeResolution;
+    property Windows::Foundation::Size RenderResolution
+    {
+        Windows::Foundation::Size get(){ return m_renderResolution; }
+        void set(Windows::Foundation::Size renderResolution);
+    }
+    void CreateTexture(const Platform::Array<int>^ buffer, int with, int height, OCVFilterType filter);
+
+
+protected:
+    // Event Handlers
+    void OnPointerPressed(Windows::Phone::Input::Interop::DrawingSurfaceManipulationHost^ sender, Windows::UI::Core::PointerEventArgs^ args);
+    void OnPointerMoved(Windows::Phone::Input::Interop::DrawingSurfaceManipulationHost^ sender, Windows::UI::Core::PointerEventArgs^ args);
+    void OnPointerReleased(Windows::Phone::Input::Interop::DrawingSurfaceManipulationHost^ sender, Windows::UI::Core::PointerEventArgs^ args);
+
+internal:
+    HRESULT STDMETHODCALLTYPE Connect(_In_ IDrawingSurfaceRuntimeHostNative* host);
+    void STDMETHODCALLTYPE Disconnect();
+    HRESULT STDMETHODCALLTYPE PrepareResources(_In_ const LARGE_INTEGER* presentTargetTime, _Out_ BOOL* contentDirty);
+    HRESULT STDMETHODCALLTYPE GetTexture(_In_ const DrawingSurfaceSizeF* size, _Out_ IDrawingSurfaceSynchronizedTextureNative** synchronizedTexture, _Out_ DrawingSurfaceRectF* textureSubRectangle);
+    ID3D11Texture2D* GetTexture();
+
+private:
+    CubeRenderer^ m_renderer;
+    BasicTimer^ m_timer;
+    Windows::Foundation::Size m_renderResolution;
+
+    void ApplyGrayFilter(const cv::Mat& image);
+    void ApplyCannyFilter(const cv::Mat& image);
+    void ApplySepiaFilter(const cv::Mat& image);
+
+    void UpdateImage(const cv::Mat& image);
+
+    cv::Mat Lena;
+    unsigned int frameWidth, frameHeight;
+};
+
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/DirectXHelper.h b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/DirectXHelper.h
new file mode 100644
index 00000000..3f1a3cf4
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/DirectXHelper.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <wrl/client.h>
+#include <ppl.h>
+#include <ppltasks.h>
+
+namespace DX
+{
+    inline void ThrowIfFailed(HRESULT hr)
+    {
+        if (FAILED(hr))
+        {
+            // Set a breakpoint on this line to catch Win32 API errors.
+            throw Platform::Exception::CreateException(hr);
+        }
+    }
+
+    // Function that reads from a binary file asynchronously.
+    inline Concurrency::task<Platform::Array<byte>^> ReadDataAsync(Platform::String^ filename)
+    {
+        using namespace Windows::Storage;
+        using namespace Concurrency;
+
+        auto folder = Windows::ApplicationModel::Package::Current->InstalledLocation;
+
+        return create_task(folder->GetFileAsync(filename)).then([] (StorageFile^ file)
+        {
+            return file->OpenReadAsync();
+        }).then([] (Streams::IRandomAccessStreamWithContentType^ stream)
+        {
+            unsigned int bufferSize = static_cast<unsigned int>(stream->Size);
+            auto fileBuffer = ref new Streams::Buffer(bufferSize);
+            return stream->ReadAsync(fileBuffer, bufferSize, Streams::InputStreamOptions::None);
+        }).then([] (Streams::IBuffer^ fileBuffer) -> Platform::Array<byte>^
+        {
+            auto fileData = ref new Platform::Array<byte>(fileBuffer->Length);
+            Streams::DataReader::FromBuffer(fileBuffer)->ReadBytes(fileData);
+            return fileData;
+        });
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/PhoneXamlDirect3DApp1Comp.vcxproj b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/PhoneXamlDirect3DApp1Comp.vcxproj
new file mode 100644
index 00000000..b15c016f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/PhoneXamlDirect3DApp1Comp.vcxproj
@@ -0,0 +1,152 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C0F94AFA-466F-4FC4-B5C1-6CD955F3FF88}</ProjectGuid>
+    <RootNamespace>PhoneXamlDirect3DApp1Comp</RootNamespace>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>11.0</MinimumVisualStudioVersion>
+    <WinMDAssembly>true</WinMDAssembly>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <!-- If OutDir was set outside of the project file, then we will append ProjectName -->
+    <OutDir Condition="'$(OutDirWasSpecified)' == 'true'">$(OutDir)\$(MSBuildProjectName)\</OutDir>
+    <!-- else, OutDir needs to have project specific directory in order to handle files with unique names -->
+    <OutDir Condition="'$(OutDirWasSpecified)' != 'true' and '$(Platform)' == 'Win32'">$(SolutionDir)$(Configuration)\$(MSBuildProjectName)\</OutDir>
+    <OutDir Condition="'$(OutDirWasSpecified)' != 'true' and '$(Platform)' != 'Win32'">$(SolutionDir)$(Platform)\$(Configuration)\$(MSBuildProjectName)\</OutDir>
+    <!-- After OutDir has been fixed, disable Microsoft.common.targets from fixing it again -->
+    <OutDirWasSpecified>false</OutDirWasSpecified>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <PreprocessorDefinitions>_WINRT_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_MetadataPath);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>true</CompileAsWinRT>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <IgnoreSpecificDefaultLibraries>ole32.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <PreprocessorDefinitions>_WINRT_DLL;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_MetadataPath);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>true</CompileAsWinRT>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <IgnoreSpecificDefaultLibraries>ole32.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Reference Include="platform.winmd">
+      <IsWinMDFile>true</IsWinMDFile>
+      <Private>false</Private>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="BasicTimer.h" />
+    <ClInclude Include="Direct3DInterop.h" />
+    <ClInclude Include="CubeRenderer.h" />
+    <ClInclude Include="DirectXHelper.h" />
+    <ClInclude Include="Direct3DBase.h" />
+    <ClInclude Include="Direct3DContentProvider.h" />
+    <ClInclude Include="pch.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Direct3DInterop.cpp" />
+    <ClCompile Include="CubeRenderer.cpp" />
+    <ClCompile Include="Direct3DBase.cpp" />
+    <ClCompile Include="Direct3DContentProvider.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <FxCompile Include="SimplePixelShader.hlsl">
+      <ShaderType>Pixel</ShaderType>
+      <ShaderModel>4.0_level_9_3</ShaderModel>
+    </FxCompile>
+    <FxCompile Include="SimpleVertexShader.hlsl">
+      <ShaderType>Vertex</ShaderType>
+      <ShaderModel>4.0_level_9_3</ShaderModel>
+    </FxCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsPhone\v$(TargetPlatformVersion)\Microsoft.Cpp.WindowsPhone.$(TargetPlatformVersion).targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\..\packages\NokiaImagingSDK.1.0.272.0\build\native\NokiaImagingSDK.targets" Condition="Exists('..\..\packages\NokiaImagingSDK.1.0.272.0\build\native\NokiaImagingSDK.targets')" />
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimplePixelShader.hlsl b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimplePixelShader.hlsl
new file mode 100644
index 00000000..17c7046a
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimplePixelShader.hlsl
@@ -0,0 +1,25 @@
+Texture2D shaderTexture;
+SamplerState SampleType;
+
+//////////////
+// TYPEDEFS //
+//////////////
+struct PixelInputType
+{
+    float4 position : SV_POSITION;
+    float2 tex : TEXCOORD0;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Pixel Shader
+////////////////////////////////////////////////////////////////////////////////
+float4 main(PixelInputType input) : SV_TARGET
+{
+    float4 textureColor;
+
+
+    // Sample the pixel color from the texture using the sampler at this texture coordinate location.
+    textureColor = shaderTexture.Sample(SampleType, input.tex);
+
+    return textureColor;
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimpleVertexShader.hlsl b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimpleVertexShader.hlsl
new file mode 100644
index 00000000..06584f60
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/SimpleVertexShader.hlsl
@@ -0,0 +1,39 @@
+cbuffer ModelViewProjectionConstantBuffer : register(b0)
+{
+    matrix model;
+    matrix view;
+    matrix projection;
+};
+
+struct VertexInputType
+{
+    float4 position : POSITION;
+    float2 tex : TEXCOORD0;
+};
+
+struct PixelInputType
+{
+    float4 position : SV_POSITION;
+    float2 tex : TEXCOORD0;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Vertex Shader
+////////////////////////////////////////////////////////////////////////////////
+PixelInputType main(VertexInputType input)
+{
+    PixelInputType output;
+
+    // Change the position vector to be 4 units for proper matrix calculations.
+    input.position.w = 1.0f;
+
+    // Calculate the position of the vertex against the world, view, and projection matrices.
+    output.position = mul(input.position, model);
+    output.position = mul(output.position, view);
+    output.position = mul(output.position, projection);
+    // Store the texture coordinates for the pixel shader.
+    output.tex = input.tex;
+
+    return output;
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/opencv.props b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/opencv.props
new file mode 100644
index 00000000..203ad9bf
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/opencv.props
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros">
+    <OpenCV_Bin>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.0\$(PlatformTarget)\$(PlatformTarget)\vc11\bin\</OpenCV_Bin>
+    <OpenCV_Lib>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.0\$(PlatformTarget)\$(PlatformTarget)\vc11\lib\</OpenCV_Lib>
+    <OpenCV_Include>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.0\$(PlatformTarget)\include\</OpenCV_Include>
+    <!--debug suffix for OpenCV dlls and libs -->
+    <DebugSuffix Condition="'$(Configuration)'=='Debug'">d</DebugSuffix>
+    <DebugSuffix Condition="'$(Configuration)'!='Debug'"></DebugSuffix>
+  </PropertyGroup>
+  <ItemGroup>
+    <!--Add required OpenCV dlls here-->
+    <None Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_features2d300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_flann300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_ml300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+  </ItemGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(OpenCV_Include);$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <!--Add required OpenCV libs here-->
+      <AdditionalDependencies>opencv_core300$(DebugSuffix).lib;opencv_imgproc300$(DebugSuffix).lib;opencv_features2d300$(DebugSuffix).lib;opencv_flann300$(DebugSuffix).lib;opencv_ml300$(DebugSuffix).lib;d3d11.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OpenCV_Lib);%(AdditionalLibraryDirectories);</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.cpp b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.cpp
new file mode 100644
index 00000000..bcb5590b
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.cpp
@@ -0,0 +1 @@
+#include "pch.h"
diff --git a/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.h b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.h
new file mode 100644
index 00000000..aa7847d9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OcvRotatingCube/PhoneXamlDirect3DApp1/PhoneXamlDirect3DApp1Comp/pch.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include <wrl/client.h>
+#include <d3d11_1.h>
+#include <DirectXMath.h>
+#include <memory>
+#include <agile.h>
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.cpp b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.cpp
new file mode 100644
index 00000000..a1240f2f
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.cpp
@@ -0,0 +1,66 @@
+// OpenCVComponent.cpp
+#include "pch.h"
+#include "OpenCVComponent.h"
+
+#include <opencv2\imgproc\types_c.h>
+#include <opencv2\core.hpp>
+#include <opencv2\imgproc.hpp>
+#include <vector>
+#include <algorithm>
+
+using namespace OpenCVComponent;
+using namespace Platform;
+using namespace concurrency;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+
+void CopyIVectorToMatrix(IVector<int>^ input, cv::Mat& mat, int size);
+void CopyMatrixToVector(const cv::Mat& mat, std::vector<int>& vector, int size);
+
+OpenCVLib::OpenCVLib()
+{
+}
+
+IAsyncOperation<IVectorView<int>^>^ OpenCVLib::ProcessAsync(IVector<int>^ input, int width, int height)
+{
+    int size = input->Size;
+    cv::Mat mat(width, height, CV_8UC4);
+    CopyIVectorToMatrix(input, mat, size);
+
+    return create_async([=]() -> IVectorView<int>^
+    {
+        // convert to grayscale
+        cv::Mat intermediateMat;
+        cv::cvtColor(mat, intermediateMat, COLOR_RGB2GRAY);
+
+        // convert to BGRA
+        cv::cvtColor(intermediateMat, mat, COLOR_GRAY2BGRA);
+
+        std::vector<int> output;
+        CopyMatrixToVector(mat, output, size);
+
+        // Return the outputs as a VectorView<float>
+        return ref new Platform::Collections::VectorView<int>(output);
+    });
+}
+
+
+void CopyIVectorToMatrix(IVector<int>^ input, cv::Mat& mat, int size)
+{
+    unsigned char* data = mat.data;
+    for (int i = 0; i < size; i++)
+    {
+        int value = input->GetAt(i);
+        memcpy(data, (void*) &value, 4);
+        data += 4;
+    }
+}
+
+void CopyMatrixToVector(const cv::Mat& mat, std::vector<int>& vector, int size)
+{
+    int* data = (int*) mat.data;
+    for (int i = 0; i < size; i++)
+    {
+        vector.push_back(data[i]);
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.h b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.h
new file mode 100644
index 00000000..2037b704
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <ppltasks.h>
+#include <collection.h>
+
+namespace OpenCVComponent
+{
+    public ref class OpenCVLib sealed
+    {
+    public:
+        OpenCVLib();
+        Windows::Foundation::IAsyncOperation<Windows::Foundation::Collections::IVectorView<int>^>^ ProcessAsync(Windows::Foundation::Collections::IVector<int>^ input, int width, int height);
+    };
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.vcxproj b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.vcxproj
new file mode 100644
index 00000000..54a75a0e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.vcxproj
@@ -0,0 +1,153 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{eadff7b8-e6c3-4f34-9b33-014b3035c595}</ProjectGuid>
+    <RootNamespace>OpenCVComponent</RootNamespace>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>11.0</MinimumVisualStudioVersion>
+    <WinMDAssembly>true</WinMDAssembly>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v110_wp80</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <Import Project="opencv.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <GenerateManifest>false</GenerateManifest>
+    <IgnoreImportLibrary>false</IgnoreImportLibrary>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;_WINRT_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_MetadataPath);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>true</CompileAsWinRT>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <IgnoreSpecificDefaultLibraries>ole32.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+      <!--AdditionalDependencies>opencv_core300d.lib;opencv_imgproc300d.lib;zlibd.lib;WindowsPhoneCore.lib;RuntimeObject.lib;PhoneAppModelHost.lib;%(AdditionalDependencies)</AdditionalDependencies-->
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;_WINRT_DLL;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_MetadataPath);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>true</CompileAsWinRT>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <IgnoreSpecificDefaultLibraries>ole32.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;_WINRT_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_MetadataPath);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>true</CompileAsWinRT>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <IgnoreSpecificDefaultLibraries>ole32.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;_WINRT_DLL;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <AdditionalUsingDirectories>$(WindowsSDK_MetadataPath);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <CompileAsWinRT>true</CompileAsWinRT>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
+      <IgnoreSpecificDefaultLibraries>ole32.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Reference Include="platform.winmd">
+      <IsWinMDFile>true</IsWinMDFile>
+      <Private>false</Private>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="OpenCVComponent.h" />
+    <ClInclude Include="pch.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="OpenCVComponent.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsPhone\v$(TargetPlatformVersion)\Microsoft.Cpp.WindowsPhone.$(TargetPlatformVersion).targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.vcxproj.filters b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.vcxproj.filters
new file mode 100644
index 00000000..fdd57ac7
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/OpenCVComponent.vcxproj.filters
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Resources">
+      <UniqueIdentifier>5fd0e509-b6ae-4f29-bd2a-4d2cc10f3aa0</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="OpenCVComponent.cpp" />
+    <ClCompile Include="pch.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="OpenCVComponent.h" />
+    <ClInclude Include="pch.h" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/opencv.props b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/opencv.props
new file mode 100644
index 00000000..c29f8916
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/opencv.props
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros">
+    <OpenCV_Bin>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.0\$(PlatformTarget)\$(PlatformTarget)\vc11\bin\</OpenCV_Bin>
+    <OpenCV_Lib>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.0\$(PlatformTarget)\$(PlatformTarget)\vc11\lib\</OpenCV_Lib>
+    <OpenCV_Include>$(OPENCV_WINRT_INSTALL_DIR)\WP\8.0\$(PlatformTarget)\include\</OpenCV_Include>
+    <!--debug suffix for OpenCV dlls and libs -->
+    <DebugSuffix Condition="'$(Configuration)'=='Debug'">d</DebugSuffix>
+    <DebugSuffix Condition="'$(Configuration)'!='Debug'"></DebugSuffix>
+  </PropertyGroup>
+  <PropertyGroup>
+    <IgnoreImportLibrary>true</IgnoreImportLibrary>
+  </PropertyGroup>
+  <ItemGroup>
+    <!--Add required OpenCV dlls here-->
+    <None Include="$(OpenCV_Bin)opencv_core300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+    <None Include="$(OpenCV_Bin)opencv_imgproc300$(DebugSuffix).dll">
+      <DeploymentContent>true</DeploymentContent>
+    </None>
+  </ItemGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(OpenCV_Include);%(AdditionalIncludeDirectories);</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <!--Add required OpenCV libs here-->
+      <AdditionalDependencies>opencv_core300$(DebugSuffix).lib;opencv_imgproc300$(DebugSuffix).lib;WindowsPhoneCore.lib;RuntimeObject.lib;PhoneAppModelHost.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(OpenCV_Lib);%(AdditionalLibraryDirectories);</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/pch.cpp b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/pch.cpp
new file mode 100644
index 00000000..01484ff5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/pch.cpp
@@ -0,0 +1,6 @@
+//
+// pch.cpp
+// Include the standard header and generate the precompiled header.
+//
+
+#include "pch.h"
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/pch.h b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/pch.h
new file mode 100644
index 00000000..f815ac97
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVComponent/pch.h
@@ -0,0 +1,6 @@
+//
+// pch.h
+// Header for standard system include files.
+//
+
+#pragma once
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml.sln b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml.sln
new file mode 100644
index 00000000..55a0d061
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml.sln
@@ -0,0 +1,76 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCVXaml", "OpenCVXaml\OpenCVXaml.csproj", "{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OpenCVComponent", "OpenCVComponent\OpenCVComponent.vcxproj", "{EADFF7B8-E6C3-4F34-9B33-014B3035C595}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|ARM = Debug|ARM
+		Debug|Mixed Platforms = Debug|Mixed Platforms
+		Debug|Win32 = Debug|Win32
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|ARM = Release|ARM
+		Release|Mixed Platforms = Release|Mixed Platforms
+		Release|Win32 = Release|Win32
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|ARM.ActiveCfg = Debug|ARM
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|ARM.Build.0 = Debug|ARM
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|ARM.Deploy.0 = Debug|ARM
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|Mixed Platforms.Deploy.0 = Debug|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|Win32.ActiveCfg = Debug|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|Win32.Build.0 = Debug|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|Win32.Deploy.0 = Debug|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|x86.ActiveCfg = Debug|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|x86.Build.0 = Debug|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Debug|x86.Deploy.0 = Debug|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|Any CPU.Deploy.0 = Release|Any CPU
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|ARM.ActiveCfg = Release|ARM
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|ARM.Build.0 = Release|ARM
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|ARM.Deploy.0 = Release|ARM
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|Mixed Platforms.Build.0 = Release|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|Mixed Platforms.Deploy.0 = Release|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|Win32.ActiveCfg = Release|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|Win32.Build.0 = Release|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|Win32.Deploy.0 = Release|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|x86.ActiveCfg = Release|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|x86.Build.0 = Release|x86
+		{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}.Release|x86.Deploy.0 = Release|x86
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Debug|ARM.ActiveCfg = Debug|ARM
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Debug|ARM.Build.0 = Debug|ARM
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Debug|Win32.ActiveCfg = Debug|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Debug|Win32.Build.0 = Debug|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Debug|x86.ActiveCfg = Debug|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Debug|x86.Build.0 = Debug|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Release|Any CPU.ActiveCfg = Release|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Release|ARM.ActiveCfg = Release|ARM
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Release|ARM.Build.0 = Release|ARM
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Release|Mixed Platforms.ActiveCfg = Release|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Release|Mixed Platforms.Build.0 = Release|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Release|Win32.ActiveCfg = Release|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Release|Win32.Build.0 = Release|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Release|x86.ActiveCfg = Release|Win32
+		{EADFF7B8-E6C3-4F34-9B33-014B3035C595}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/App.xaml b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/App.xaml
new file mode 100644
index 00000000..ba41001e
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/App.xaml
@@ -0,0 +1,20 @@
+<Application
+    x:Class="OpenCVXaml.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
+    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone">
+
+    <!--Application Resources-->
+    <Application.Resources>
+        <local:LocalizedStrings xmlns:local="clr-namespace:OpenCVXaml" x:Key="LocalizedStrings"/>
+    </Application.Resources>
+
+    <Application.ApplicationLifetimeObjects>
+        <!--Required object that handles lifetime events for the application-->
+        <shell:PhoneApplicationService
+            Launching="Application_Launching" Closing="Application_Closing"
+            Activated="Application_Activated" Deactivated="Application_Deactivated"/>
+    </Application.ApplicationLifetimeObjects>
+
+</Application>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/App.xaml.cs b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/App.xaml.cs
new file mode 100644
index 00000000..17f8fed9
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/App.xaml.cs
@@ -0,0 +1,223 @@
+using System;
+using System.Diagnostics;
+using System.Resources;
+using System.Windows;
+using System.Windows.Markup;
+using System.Windows.Navigation;
+using Microsoft.Phone.Controls;
+using Microsoft.Phone.Shell;
+using OpenCVXaml.Resources;
+
+namespace OpenCVXaml
+{
+    public partial class App : Application
+    {
+        /// <summary>
+        /// Provides easy access to the root frame of the Phone Application.
+        /// </summary>
+        /// <returns>The root frame of the Phone Application.</returns>
+        public static PhoneApplicationFrame RootFrame { get; private set; }
+
+        /// <summary>
+        /// Constructor for the Application object.
+        /// </summary>
+        public App()
+        {
+            // Global handler for uncaught exceptions.
+            UnhandledException += Application_UnhandledException;
+
+            // Standard XAML initialization
+            InitializeComponent();
+
+            // Phone-specific initialization
+            InitializePhoneApplication();
+
+            // Language display initialization
+            InitializeLanguage();
+
+            // Show graphics profiling information while debugging.
+            if (Debugger.IsAttached)
+            {
+                // Display the current frame rate counters.
+                Application.Current.Host.Settings.EnableFrameRateCounter = true;
+
+                // Show the areas of the app that are being redrawn in each frame.
+                //Application.Current.Host.Settings.EnableRedrawRegions = true;
+
+                // Enable non-production analysis visualization mode,
+                // which shows areas of a page that are handed off to GPU with a colored overlay.
+                //Application.Current.Host.Settings.EnableCacheVisualization = true;
+
+                // Prevent the screen from turning off while under the debugger by disabling
+                // the application's idle detection.
+                // Caution:- Use this under debug mode only. Application that disables user idle detection will continue to run
+                // and consume battery power when the user is not using the phone.
+                PhoneApplicationService.Current.UserIdleDetectionMode = IdleDetectionMode.Disabled;
+            }
+
+        }
+
+        // Code to execute when the application is launching (eg, from Start)
+        // This code will not execute when the application is reactivated
+        private void Application_Launching(object sender, LaunchingEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is activated (brought to foreground)
+        // This code will not execute when the application is first launched
+        private void Application_Activated(object sender, ActivatedEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is deactivated (sent to background)
+        // This code will not execute when the application is closing
+        private void Application_Deactivated(object sender, DeactivatedEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is closing (eg, user hit Back)
+        // This code will not execute when the application is deactivated
+        private void Application_Closing(object sender, ClosingEventArgs e)
+        {
+        }
+
+        // Code to execute if a navigation fails
+        private void RootFrame_NavigationFailed(object sender, NavigationFailedEventArgs e)
+        {
+            if (Debugger.IsAttached)
+            {
+                // A navigation has failed; break into the debugger
+                Debugger.Break();
+            }
+        }
+
+        // Code to execute on Unhandled Exceptions
+        private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
+        {
+            if (Debugger.IsAttached)
+            {
+                // An unhandled exception has occurred; break into the debugger
+                Debugger.Break();
+            }
+        }
+
+        #region Phone application initialization
+
+        // Avoid double-initialization
+        private bool phoneApplicationInitialized = false;
+
+        // Do not add any additional code to this method
+        private void InitializePhoneApplication()
+        {
+            if (phoneApplicationInitialized)
+                return;
+
+            // Create the frame but don't set it as RootVisual yet; this allows the splash
+            // screen to remain active until the application is ready to render.
+            RootFrame = new PhoneApplicationFrame();
+            RootFrame.Navigated += CompleteInitializePhoneApplication;
+
+            // Handle navigation failures
+            RootFrame.NavigationFailed += RootFrame_NavigationFailed;
+
+            // Handle reset requests for clearing the backstack
+            RootFrame.Navigated += CheckForResetNavigation;
+
+            // Ensure we don't initialize again
+            phoneApplicationInitialized = true;
+        }
+
+        // Do not add any additional code to this method
+        private void CompleteInitializePhoneApplication(object sender, NavigationEventArgs e)
+        {
+            // Set the root visual to allow the application to render
+            if (RootVisual != RootFrame)
+                RootVisual = RootFrame;
+
+            // Remove this handler since it is no longer needed
+            RootFrame.Navigated -= CompleteInitializePhoneApplication;
+        }
+
+        private void CheckForResetNavigation(object sender, NavigationEventArgs e)
+        {
+            // If the app has received a 'reset' navigation, then we need to check
+            // on the next navigation to see if the page stack should be reset
+            if (e.NavigationMode == NavigationMode.Reset)
+                RootFrame.Navigated += ClearBackStackAfterReset;
+        }
+
+        private void ClearBackStackAfterReset(object sender, NavigationEventArgs e)
+        {
+            // Unregister the event so it doesn't get called again
+            RootFrame.Navigated -= ClearBackStackAfterReset;
+
+            // Only clear the stack for 'new' (forward) and 'refresh' navigations
+            if (e.NavigationMode != NavigationMode.New && e.NavigationMode != NavigationMode.Refresh)
+                return;
+
+            // For UI consistency, clear the entire page stack
+            while (RootFrame.RemoveBackEntry() != null)
+            {
+                ; // do nothing
+            }
+        }
+
+        #endregion
+
+        // Initialize the app's font and flow direction as defined in its localized resource strings.
+        //
+        // To ensure that the font of your application is aligned with its supported languages and that the
+        // FlowDirection for each of those languages follows its traditional direction, ResourceLanguage
+        // and ResourceFlowDirection should be initialized in each resx file to match these values with that
+        // file's culture. For example:
+        //
+        // AppResources.es-ES.resx
+        //    ResourceLanguage's value should be "es-ES"
+        //    ResourceFlowDirection's value should be "LeftToRight"
+        //
+        // AppResources.ar-SA.resx
+        //     ResourceLanguage's value should be "ar-SA"
+        //     ResourceFlowDirection's value should be "RightToLeft"
+        //
+        // For more info on localizing Windows Phone apps see http://go.microsoft.com/fwlink/?LinkId=262072.
+        //
+        private void InitializeLanguage()
+        {
+            try
+            {
+                // Set the font to match the display language defined by the
+                // ResourceLanguage resource string for each supported language.
+                //
+                // Fall back to the font of the neutral language if the Display
+                // language of the phone is not supported.
+                //
+                // If a compiler error is hit then ResourceLanguage is missing from
+                // the resource file.
+                RootFrame.Language = XmlLanguage.GetLanguage(AppResources.ResourceLanguage);
+
+                // Set the FlowDirection of all elements under the root frame based
+                // on the ResourceFlowDirection resource string for each
+                // supported language.
+                //
+                // If a compiler error is hit then ResourceFlowDirection is missing from
+                // the resource file.
+                FlowDirection flow = (FlowDirection)Enum.Parse(typeof(FlowDirection), AppResources.ResourceFlowDirection);
+                RootFrame.FlowDirection = flow;
+            }
+            catch
+            {
+                // If an exception is caught here it is most likely due to either
+                // ResourceLanguage not being correctly set to a supported language
+                // code or ResourceFlowDirection is set to a value other than LeftToRight
+                // or RightToLeft.
+
+                if (Debugger.IsAttached)
+                {
+                    Debugger.Break();
+                }
+
+                throw;
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/AlignmentGrid.png b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/AlignmentGrid.png
new file mode 100644
index 00000000..f7d2e978
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/AlignmentGrid.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/ApplicationIcon.png b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/ApplicationIcon.png
new file mode 100644
index 00000000..7d95d4e0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/ApplicationIcon.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Lena.png b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Lena.png
new file mode 100644
index 00000000..3e866873
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Lena.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/FlipCycleTileLarge.png b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/FlipCycleTileLarge.png
new file mode 100644
index 00000000..e0c59ac0
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/FlipCycleTileLarge.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/FlipCycleTileMedium.png b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/FlipCycleTileMedium.png
new file mode 100644
index 00000000..e93b89d6
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/FlipCycleTileMedium.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/FlipCycleTileSmall.png b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/FlipCycleTileSmall.png
new file mode 100644
index 00000000..550b1b5e
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/FlipCycleTileSmall.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/IconicTileMediumLarge.png b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/IconicTileMediumLarge.png
new file mode 100644
index 00000000..686e6b53
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/IconicTileMediumLarge.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/IconicTileSmall.png b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/IconicTileSmall.png
new file mode 100644
index 00000000..d4b5ede1
Binary files /dev/null and b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Assets/Tiles/IconicTileSmall.png differ
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/LocalizedStrings.cs b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/LocalizedStrings.cs
new file mode 100644
index 00000000..6eff65a5
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/LocalizedStrings.cs
@@ -0,0 +1,14 @@
+using OpenCVXaml.Resources;
+
+namespace OpenCVXaml
+{
+    /// <summary>
+    /// Provides access to string resources.
+    /// </summary>
+    public class LocalizedStrings
+    {
+        private static AppResources _localizedResources = new AppResources();
+
+        public AppResources LocalizedResources { get { return _localizedResources; } }
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/MainPage.xaml b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/MainPage.xaml
new file mode 100644
index 00000000..6b55b2d1
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/MainPage.xaml
@@ -0,0 +1,64 @@
+<phone:PhoneApplicationPage
+    x:Class="OpenCVXaml.MainPage"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
+    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    mc:Ignorable="d"
+    FontFamily="{StaticResource PhoneFontFamilyNormal}"
+    FontSize="{StaticResource PhoneFontSizeNormal}"
+    Foreground="{StaticResource PhoneForegroundBrush}"
+    SupportedOrientations="Portrait" Orientation="Portrait"
+    shell:SystemTray.IsVisible="True">
+
+    <!--LayoutRoot is the root grid where all page content is placed-->
+    <Grid x:Name="LayoutRoot" Background="Transparent">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+        </Grid.RowDefinitions>
+
+        <!-- LOCALIZATION NOTE:
+            To localize the displayed strings copy their values to appropriately named
+            keys in the app's neutral language resource file (AppResources.resx) then
+            replace the hard-coded text value between the attributes' quotation marks
+            with the binding clause whose path points to that string name.
+
+            For example:
+
+                Text="{Binding Path=LocalizedResources.ApplicationTitle, Source={StaticResource LocalizedStrings}}"
+
+            This binding points to the template's string resource named "ApplicationTitle".
+
+            Adding supported languages in the Project Properties tab will create a
+            new resx file per language that can carry the translated values of your
+            UI strings. The binding in these examples will cause the value of the
+            attributes to be drawn from the .resx file that matches the
+            CurrentUICulture of the app at run time.
+         -->
+
+        <!--TitlePanel contains the name of the application and page title-->
+        <StackPanel x:Name="TitlePanel" Grid.Row="0" Margin="12,17,0,28">
+            <TextBlock Text="OpenCV" Margin="9,-7,0,0" Style="{StaticResource PhoneTextTitle1Style}"/>
+        </StackPanel>
+
+        <!--ContentPanel - place additional content here-->
+        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
+            <StackPanel>
+                <Image Source="Assets\\Lena.png" Name="Preview"></Image>
+                <Button Content="Process" Name="ProcessButton" Click="Button_Click"></Button>
+            </StackPanel>
+        </Grid>
+
+        <!--Uncomment to see an alignment grid to help ensure your controls are
+            aligned on common boundaries.  The image has a top margin of -32px to
+            account for the System Tray. Set this to 0 (or remove the margin altogether)
+            if the System Tray is hidden.
+
+            Before shipping remove this XAML and the image itself.-->
+        <!--<Image Source="/Assets/AlignmentGrid.png" VerticalAlignment="Top" Height="800" Width="480" Margin="0,-32,0,0" Grid.Row="0" Grid.RowSpan="2" IsHitTestVisible="False" />-->
+    </Grid>
+
+</phone:PhoneApplicationPage>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/MainPage.xaml.cs b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/MainPage.xaml.cs
new file mode 100644
index 00000000..ed4f4f10
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/MainPage.xaml.cs
@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Navigation;
+using Microsoft.Phone.Controls;
+using Microsoft.Phone.Shell;
+using OpenCVXaml.Resources;
+using System.Windows.Media.Imaging;
+using OpenCVComponent;
+
+namespace OpenCVXaml
+{
+    public partial class MainPage : PhoneApplicationPage
+    {
+        private OpenCVLib m_opencv = new OpenCVLib();
+
+        // Constructor
+        public MainPage()
+        {
+            InitializeComponent();
+
+            // Sample code to localize the ApplicationBar
+            //BuildLocalizedApplicationBar();
+        }
+
+        private async void Button_Click(object sender, RoutedEventArgs e)
+        {
+            if (Preview.Source != null)
+            {
+                ProcessButton.IsEnabled = false;
+
+                // Get WriteableBitmap. ImageToModify is defined in MainPage.xaml
+                WriteableBitmap bitmap = new WriteableBitmap(Preview.Source as BitmapSource);
+
+                // call OpenCVLib to convert pixels to grayscale. This is an asynchronous call.
+                var pixels =  await m_opencv.ProcessAsync(bitmap.Pixels, bitmap.PixelWidth, bitmap.PixelHeight);
+
+                // copy the pixels into the WriteableBitmap
+                for (int x = 0; x < bitmap.Pixels.Length; x++)
+                {
+                    bitmap.Pixels[x] = pixels[x];
+                }
+
+                // Set Image object, defined in XAML, to the modified bitmap.
+                Preview.Source = bitmap;
+
+                ProcessButton.IsEnabled = true;
+            }
+        }
+
+        // Sample code for building a localized ApplicationBar
+        //private void BuildLocalizedApplicationBar()
+        //{
+        //    // Set the page's ApplicationBar to a new instance of ApplicationBar.
+        //    ApplicationBar = new ApplicationBar();
+
+        //    // Create a new button and set the text value to the localized string from AppResources.
+        //    ApplicationBarIconButton appBarButton = new ApplicationBarIconButton(new Uri("/Assets/AppBar/appbar.add.rest.png", UriKind.Relative));
+        //    appBarButton.Text = AppResources.AppBarButtonText;
+        //    ApplicationBar.Buttons.Add(appBarButton);
+
+        //    // Create a new menu item with the localized string from AppResources.
+        //    ApplicationBarMenuItem appBarMenuItem = new ApplicationBarMenuItem(AppResources.AppBarMenuItemText);
+        //    ApplicationBar.MenuItems.Add(appBarMenuItem);
+        //}
+    }
+}
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/OpenCVXaml.csproj b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/OpenCVXaml.csproj
new file mode 100644
index 00000000..c648fd3d
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/OpenCVXaml.csproj
@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>10.0.20506</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{AF139C56-D9C7-4AFE-8972-E5B30AABA1BC}</ProjectGuid>
+    <ProjectTypeGuids>{C089C8C0-30E0-4E22-80C0-CE093F111A43};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>OpenCVXaml</RootNamespace>
+    <AssemblyName>OpenCVXaml</AssemblyName>
+    <TargetFrameworkIdentifier>WindowsPhone</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v8.0</TargetFrameworkVersion>
+    <SilverlightVersion>$(TargetFrameworkVersion)</SilverlightVersion>
+    <SilverlightApplication>true</SilverlightApplication>
+    <SupportedCultures>
+    </SupportedCultures>
+    <XapOutputs>true</XapOutputs>
+    <GenerateSilverlightManifest>true</GenerateSilverlightManifest>
+    <XapFilename>OpenCVXaml_$(Configuration)_$(Platform).xap</XapFilename>
+    <SilverlightManifestTemplate>Properties\AppManifest.xml</SilverlightManifestTemplate>
+    <SilverlightAppEntry>OpenCVXaml.App</SilverlightAppEntry>
+    <ValidateXaml>true</ValidateXaml>
+    <MinimumVisualStudioVersion>11.0</MinimumVisualStudioVersion>
+    <ThrowErrorsInValidation>true</ThrowErrorsInValidation>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>Bin\Debug</OutputPath>
+    <DefineConstants>DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>Bin\Release</OutputPath>
+    <DefineConstants>TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>Bin\x86\Debug</OutputPath>
+    <DefineConstants>DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>Bin\x86\Release</OutputPath>
+    <DefineConstants>TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|ARM' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>Bin\ARM\Debug</OutputPath>
+    <DefineConstants>DEBUG;TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|ARM' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>Bin\ARM\Release</OutputPath>
+    <DefineConstants>TRACE;SILVERLIGHT;WINDOWS_PHONE</DefineConstants>
+    <NoStdLib>true</NoStdLib>
+    <NoConfig>true</NoConfig>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="App.xaml.cs">
+      <DependentUpon>App.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="LocalizedStrings.cs" />
+    <Compile Include="MainPage.xaml.cs">
+      <DependentUpon>MainPage.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Resources\AppResources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>AppResources.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </ApplicationDefinition>
+    <Page Include="MainPage.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Properties\AppManifest.xml" />
+    <None Include="Properties\WMAppManifest.xml">
+      <SubType>Designer</SubType>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Assets\AlignmentGrid.png" />
+    <Content Include="Assets\ApplicationIcon.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Lena.png" />
+    <Content Include="Assets\Tiles\FlipCycleTileLarge.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\FlipCycleTileMedium.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\FlipCycleTileSmall.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\IconicTileMediumLarge.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Assets\Tiles\IconicTileSmall.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Resources\AppResources.resx">
+      <Generator>PublicResXFileCodeGenerator</Generator>
+      <LastGenOutput>AppResources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\OpenCVComponent\OpenCVComponent.vcxproj">
+      <Project>{eadff7b8-e6c3-4f34-9b33-014b3035c595}</Project>
+      <Name>OpenCVComponent</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\$(TargetFrameworkIdentifier)\$(TargetFrameworkVersion)\Microsoft.$(TargetFrameworkIdentifier).$(TargetFrameworkVersion).Overrides.targets" />
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\$(TargetFrameworkIdentifier)\$(TargetFrameworkVersion)\Microsoft.$(TargetFrameworkIdentifier).CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <ProjectExtensions />
+</Project>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Properties/AppManifest.xml b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Properties/AppManifest.xml
new file mode 100644
index 00000000..6712a117
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Properties/AppManifest.xml
@@ -0,0 +1,6 @@
+<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+>
+    <Deployment.Parts>
+    </Deployment.Parts>
+</Deployment>
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Properties/AssemblyInfo.cs b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..af7506ff
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Properties/AssemblyInfo.cs
@@ -0,0 +1,37 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Resources;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenCVXaml")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("OpenCVXaml")]
+[assembly: AssemblyCopyright("Copyright ©  2014")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("0ceefb1d-fe54-4732-bca5-865e13ecdbf0")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: NeutralResourcesLanguageAttribute("en-US")]
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Properties/WMAppManifest.xml b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Properties/WMAppManifest.xml
new file mode 100644
index 00000000..9ee4bc59
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Properties/WMAppManifest.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<Deployment xmlns="http://schemas.microsoft.com/windowsphone/2012/deployment" AppPlatformVersion="8.0">
+  <DefaultLanguage xmlns="" code="en-US"/>
+  <App xmlns="" ProductID="{af139c56-d9c7-4afe-8972-e5b30aaba1bc}" Title="OpenCVXaml" RuntimeType="Silverlight" Version="1.0.0.0" Genre="apps.normal"  Author="OpenCVXaml author" Description="Sample description" Publisher="OpenCVXaml" PublisherID="{8dd284a7-c759-40d0-9076-a1ced47c6a9a}">
+    <IconPath IsRelative="true" IsResource="false">Assets\ApplicationIcon.png</IconPath>
+    <Capabilities>
+      <Capability Name="ID_CAP_NETWORKING"/>
+      <Capability Name="ID_CAP_MEDIALIB_AUDIO"/>
+      <Capability Name="ID_CAP_MEDIALIB_PLAYBACK"/>
+      <Capability Name="ID_CAP_SENSORS"/>
+      <Capability Name="ID_CAP_WEBBROWSERCOMPONENT"/>
+    </Capabilities>
+    <Tasks>
+      <DefaultTask  Name ="_default" NavigationPage="MainPage.xaml"/>
+    </Tasks>
+    <Tokens>
+      <PrimaryToken TokenID="OpenCVXamlToken" TaskName="_default">
+        <TemplateFlip>
+          <SmallImageURI IsRelative="true" IsResource="false">Assets\Tiles\FlipCycleTileSmall.png</SmallImageURI>
+          <Count>0</Count>
+          <BackgroundImageURI IsRelative="true" IsResource="false">Assets\Tiles\FlipCycleTileMedium.png</BackgroundImageURI>
+          <Title>OpenCVXaml</Title>
+          <BackContent></BackContent>
+          <BackBackgroundImageURI></BackBackgroundImageURI>
+          <BackTitle></BackTitle>
+          <DeviceLockImageURI></DeviceLockImageURI>
+          <HasLarge></HasLarge>
+        </TemplateFlip>
+      </PrimaryToken>
+    </Tokens>
+    <ScreenResolutions>
+      <ScreenResolution Name="ID_RESOLUTION_WVGA"/>
+      <ScreenResolution Name="ID_RESOLUTION_WXGA"/>
+      <ScreenResolution Name="ID_RESOLUTION_HD720P"/>
+    </ScreenResolutions>
+  </App>
+</Deployment>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Resources/AppResources.Designer.cs b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Resources/AppResources.Designer.cs
new file mode 100644
index 00000000..90bcaa93
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Resources/AppResources.Designer.cs
@@ -0,0 +1,127 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.17626
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace OpenCVXaml.Resources
+{
+    using System;
+
+
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    public class AppResources
+    {
+
+        private static global::System.Resources.ResourceManager resourceMan;
+
+        private static global::System.Globalization.CultureInfo resourceCulture;
+
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal AppResources()
+        {
+        }
+
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Resources.ResourceManager ResourceManager
+        {
+            get
+            {
+                if (object.ReferenceEquals(resourceMan, null))
+                {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("OpenCVXaml.Resources.AppResources", typeof(AppResources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Globalization.CultureInfo Culture
+        {
+            get
+            {
+                return resourceCulture;
+            }
+            set
+            {
+                resourceCulture = value;
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to LeftToRight.
+        /// </summary>
+        public static string ResourceFlowDirection
+        {
+            get
+            {
+                return ResourceManager.GetString("ResourceFlowDirection", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to us-EN.
+        /// </summary>
+        public static string ResourceLanguage
+        {
+            get
+            {
+                return ResourceManager.GetString("ResourceLanguage", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to MY APPLICATION.
+        /// </summary>
+        public static string ApplicationTitle
+        {
+            get
+            {
+                return ResourceManager.GetString("ApplicationTitle", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to button.
+        /// </summary>
+        public static string AppBarButtonText
+        {
+            get
+            {
+                return ResourceManager.GetString("AppBarButtonText", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to menu item.
+        /// </summary>
+        public static string AppBarMenuItemText
+        {
+            get
+            {
+                return ResourceManager.GetString("AppBarMenuItemText", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Resources/AppResources.resx b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Resources/AppResources.resx
new file mode 100644
index 00000000..529a1943
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/OpenCVXaml/OpenCVXaml/Resources/AppResources.resx
@@ -0,0 +1,137 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ResourceFlowDirection" xml:space="preserve">
+    <value>LeftToRight</value>
+    <comment>Controls the FlowDirection for all elements in the RootFrame. Set to the traditional direction of this resource file's language</comment>
+  </data>
+  <data name="ResourceLanguage" xml:space="preserve">
+    <value>en-US</value>
+    <comment>Controls the Language and ensures that the font for all elements in the RootFrame aligns with the app's language. Set to the language code of this resource file's language.</comment>
+  </data>
+  <data name="ApplicationTitle" xml:space="preserve">
+    <value>MY APPLICATION</value>
+  </data>
+  <data name="AppBarButtonText" xml:space="preserve">
+    <value>add</value>
+  </data>
+  <data name="AppBarMenuItemText" xml:space="preserve">
+    <value>Menu Item</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/C++/opencv-4.7.0/samples/wp8/readme.txt b/C++/opencv-4.7.0/samples/wp8/readme.txt
new file mode 100644
index 00000000..c25967cd
--- /dev/null
+++ b/C++/opencv-4.7.0/samples/wp8/readme.txt
@@ -0,0 +1,6 @@
+Building OpenCV Windows Phone Samples
+=====================================
+
+Samples are created to run against x86 architecture OpenCV binaries.
+
+Please follow the instructions in "platforms/winrt/readme.txt" to generate and build OpenCV for Windows Phone 8.0/8.1
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/3rdparty/librknn_api/armhf/librknn_api.so b/C++/yolo_bytetrack/3rdparty/librknn_api/armhf/librknn_api.so
new file mode 100644
index 00000000..b6726b4a
Binary files /dev/null and b/C++/yolo_bytetrack/3rdparty/librknn_api/armhf/librknn_api.so differ
diff --git a/C++/yolo_bytetrack/3rdparty/librknn_api/include/rknn_api.h b/C++/yolo_bytetrack/3rdparty/librknn_api/include/rknn_api.h
new file mode 100644
index 00000000..3bb6e1eb
--- /dev/null
+++ b/C++/yolo_bytetrack/3rdparty/librknn_api/include/rknn_api.h
@@ -0,0 +1,550 @@
+/****************************************************************************
+*
+*    Copyright (c) 2017 - 2018 by Rockchip Corp.  All rights reserved.
+*
+*    The material in this file is confidential and contains trade secrets
+*    of Rockchip Corporation. This is proprietary information owned by
+*    Rockchip Corporation. No part of this work may be disclosed,
+*    reproduced, copied, transmitted, or used in any way for any purpose,
+*    without the express written permission of Rockchip Corporation.
+*
+*****************************************************************************/
+
+
+#ifndef _RKNN_RUNTIME_H
+#define _RKNN_RUNTIME_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+/*
+    Definition of extended flag for rknn_init.
+*/
+/* set high priority context. */
+#define RKNN_FLAG_PRIOR_HIGH                    0x00000000
+
+/* set medium priority context */
+#define RKNN_FLAG_PRIOR_MEDIUM                  0x00000001
+
+/* set low priority context. */
+#define RKNN_FLAG_PRIOR_LOW                     0x00000002
+
+/* asynchronous mode.
+   when enable, rknn_outputs_get will not block for too long because it directly retrieves the result of
+   the previous frame which can increase the frame rate on single-threaded mode, but at the cost of
+   rknn_outputs_get not retrieves the result of the current frame.
+   in multi-threaded mode you do not need to turn this mode on. */
+#define RKNN_FLAG_ASYNC_MASK                    0x00000004
+
+/* collect performance mode.
+   when enable, you can get detailed performance reports via rknn_query(ctx, RKNN_QUERY_PERF_DETAIL, ...),
+   but it will reduce the frame rate. */
+#define RKNN_FLAG_COLLECT_PERF_MASK             0x00000008
+
+/*
+   save pre-compile model.
+*/
+#define RKNN_FLAG_PRECOMPILE_MASK               0x00000020
+
+/*
+    Error code returned by the RKNN API.
+*/
+#define RKNN_SUCC                               0       /* execute succeed. */
+#define RKNN_ERR_FAIL                           -1      /* execute failed. */
+#define RKNN_ERR_TIMEOUT                        -2      /* execute timeout. */
+#define RKNN_ERR_DEVICE_UNAVAILABLE             -3      /* device is unavailable. */
+#define RKNN_ERR_MALLOC_FAIL                    -4      /* memory malloc fail. */
+#define RKNN_ERR_PARAM_INVALID                  -5      /* parameter is invalid. */
+#define RKNN_ERR_MODEL_INVALID                  -6      /* model is invalid. */
+#define RKNN_ERR_CTX_INVALID                    -7      /* context is invalid. */
+#define RKNN_ERR_INPUT_INVALID                  -8      /* input is invalid. */
+#define RKNN_ERR_OUTPUT_INVALID                 -9      /* output is invalid. */
+#define RKNN_ERR_DEVICE_UNMATCH                 -10     /* the device is unmatch, please update rknn sdk
+                                                           and npu driver/firmware. */
+#define RKNN_ERR_INCOMPATILE_PRE_COMPILE_MODEL  -11     /* This RKNN model use pre_compile mode, but not compatible with current driver. */
+//add by chifred: for reporting optimization version bug info
+#define RKNN_ERR_INCOMPATILE_OPTIMIZATION_LEVEL_VERSION  -12     /* This RKNN model set optimization level, but not compatible with current driver. */
+#define RKNN_ERR_TARGET_PLATFORM_UNMATCH        -13     /* This RKNN model set target platform, but not compatible with current platform. */
+//chifred add end
+#define RKNN_ERR_NON_PRE_COMPILED_MODEL_ON_MINI_DRIVER -14  /* This RKNN model is not a pre-compiled model, but the npu driver is mini driver. */
+
+/*
+    Definition for tensor
+*/
+#define RKNN_MAX_DIMS                           16      /* maximum dimension of tensor. */
+#define RKNN_MAX_NAME_LEN                       256     /* maximum name lenth of tensor. */
+
+
+
+#ifdef __arm__
+typedef uint32_t rknn_context;
+#else
+typedef uint64_t rknn_context;
+#endif
+
+/*
+    The query command for rknn_query
+*/
+typedef enum _rknn_query_cmd {
+    RKNN_QUERY_IN_OUT_NUM = 0,                          /* query the number of input & output tensor. */
+    RKNN_QUERY_INPUT_ATTR,                              /* query the attribute of input tensor. */
+    RKNN_QUERY_OUTPUT_ATTR,                             /* query the attribute of output tensor. */
+    RKNN_QUERY_PERF_DETAIL,                             /* query the detail performance, need set
+                                                           RKNN_FLAG_COLLECT_PERF_MASK when call rknn_init. */
+    RKNN_QUERY_PERF_RUN,                                /* query the time of run. */
+    RKNN_QUERY_SDK_VERSION,                             /* query the sdk & driver version */
+    RKNN_QUERY_PRE_COMPILE,                             /* query the pre compile model */
+
+    RKNN_QUERY_CMD_MAX
+} rknn_query_cmd;
+
+/*
+    the tensor data type.
+*/
+typedef enum _rknn_tensor_type {
+    RKNN_TENSOR_FLOAT32 = 0,                            /* data type is float32. */
+    RKNN_TENSOR_FLOAT16,                                /* data type is float16. */
+    RKNN_TENSOR_INT8,                                   /* data type is int8. */
+    RKNN_TENSOR_UINT8,                                  /* data type is uint8. */
+    RKNN_TENSOR_INT16,                                  /* data type is int16. */
+
+    RKNN_TENSOR_TYPE_MAX
+} rknn_tensor_type;
+
+inline static const char *get_type_string(rknn_tensor_type type)
+{
+    switch (type)
+    {
+    case RKNN_TENSOR_FLOAT32:
+        return "FP32";
+    case RKNN_TENSOR_FLOAT16:
+        return "FP16";
+    case RKNN_TENSOR_INT8:
+        return "INT8";
+    case RKNN_TENSOR_UINT8:
+        return "UINT8";
+    case RKNN_TENSOR_INT16:
+        return "INT16";
+    default:
+        return "UNKNOW";
+    }
+}
+
+/*
+    the quantitative type.
+*/
+typedef enum _rknn_tensor_qnt_type {
+    RKNN_TENSOR_QNT_NONE = 0,                           /* none. */
+    RKNN_TENSOR_QNT_DFP,                                /* dynamic fixed point. */
+    RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC,                  /* asymmetric affine. */
+
+    RKNN_TENSOR_QNT_MAX
+} rknn_tensor_qnt_type;
+
+inline static const char *get_qnt_type_string(rknn_tensor_qnt_type type)
+{
+    switch (type)
+    {
+    case RKNN_TENSOR_QNT_NONE:
+        return "NONE";
+    case RKNN_TENSOR_QNT_DFP:
+        return "DFP";
+    case RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC:
+        return "AFFINE";
+    default:
+        return "UNKNOW";
+    }
+}
+
+/*
+    the tensor data format.
+*/
+typedef enum _rknn_tensor_format {
+    RKNN_TENSOR_NCHW = 0,                               /* data format is NCHW. */
+    RKNN_TENSOR_NHWC,                                   /* data format is NHWC. */
+
+    RKNN_TENSOR_FORMAT_MAX
+} rknn_tensor_format;
+
+inline static const char *get_format_string(rknn_tensor_format fmt)
+{
+    switch (fmt)
+    {
+    case RKNN_TENSOR_NCHW:
+        return "NCHW";
+    case RKNN_TENSOR_NHWC:
+        return "NHWC";
+    default:
+        return "UNKNOW";
+    }
+}
+
+/*
+    the information for RKNN_QUERY_IN_OUT_NUM.
+*/
+typedef struct _rknn_input_output_num {
+    uint32_t n_input;                                   /* the number of input. */
+    uint32_t n_output;                                  /* the number of output. */
+} rknn_input_output_num;
+
+/*
+    the information for RKNN_QUERY_INPUT_ATTR / RKNN_QUERY_OUTPUT_ATTR.
+*/
+typedef struct _rknn_tensor_attr {
+    uint32_t index;                                     /* input parameter, the index of input/output tensor,
+                                                           need set before call rknn_query. */
+
+    uint32_t n_dims;                                    /* the number of dimensions. */
+    uint32_t dims[RKNN_MAX_DIMS];                       /* the dimensions array. */
+    char name[RKNN_MAX_NAME_LEN];                       /* the name of tensor. */
+
+    uint32_t n_elems;                                   /* the number of elements. */
+    uint32_t size;                                      /* the bytes size of tensor. */
+
+    rknn_tensor_format fmt;                             /* the data format of tensor. */
+    rknn_tensor_type type;                              /* the data type of tensor. */
+    rknn_tensor_qnt_type qnt_type;                      /* the quantitative type of tensor. */
+    int8_t fl;                                          /* fractional length for RKNN_TENSOR_QNT_DFP. */
+    uint32_t zp;                                        /* zero point for RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC. */
+    float scale;                                        /* scale for RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC. */
+} rknn_tensor_attr;
+
+/*
+    the information for RKNN_QUERY_PERF_DETAIL.
+*/
+typedef struct _rknn_perf_detail {
+    char* perf_data;                                    /* the string pointer of perf detail. don't need free it by user. */
+    uint64_t data_len;                                  /* the string length. */
+} rknn_perf_detail;
+
+/*
+    the information for RKNN_QUERY_PERF_RUN.
+*/
+typedef struct _rknn_perf_run {
+    int64_t run_duration;                               /* real inference time (us) */
+} rknn_perf_run;
+
+/*
+    the information for RKNN_QUERY_SDK_VERSION.
+*/
+typedef struct _rknn_sdk_version {
+    char api_version[256];                              /* the version of rknn api. */
+    char drv_version[256];                              /* the version of rknn driver. */
+} rknn_sdk_version;
+
+/*
+   The flags of rknn_tensor_mem.
+*/
+typedef enum _rknn_tensor_mem_flags {
+    RKNN_TENSOR_MEMORY_FLAGS_UNKNOWN = 0,
+    RKNN_TENSOR_MEMORY_FLAGS_ALLOC_INSIDE = 1,           /*Used to mark in rknn_destroy_mem() whether it is necessary to release the "mem" pointer itself.
+                                                         If the flag RKNN_TENSOR_MEMORY_FLAGS_ALLOC_INSIDE is set, rknn_destroy_mem() will call free(mem).*/
+   
+} rknn_tensor_mem_flags;
+
+
+/*
+    the memory information of tensor.
+*/
+typedef struct _rknn_tensor_memory {
+    void*       logical_addr;                           /* the virtual address of tensor buffer. */
+    uint64_t    physical_addr;                          /* the physical address of tensor buffer. */
+    int32_t     fd;                                     /* the fd of tensor buffer. */
+    uint32_t    size;                                   /* the size of tensor buffer. */
+    uint32_t    handle;                                 /* the handle tensor buffer. */
+    void *      priv_data;                              /* the data which is reserved. */
+    uint64_t reserved_flag;                             /* the flag which is reserved. */
+} rknn_tensor_mem;
+
+/*
+    the input information for rknn_input_set.
+*/
+typedef struct _rknn_input {
+    uint32_t index;                                     /* the input index. */
+    void* buf;                                          /* the input buf for index. */
+    uint32_t size;                                      /* the size of input buf. */
+    uint8_t pass_through;                               /* pass through mode.
+                                                           if TRUE, the buf data is passed directly to the input node of the rknn model
+                                                                    without any conversion. the following variables do not need to be set.
+                                                           if FALSE, the buf data is converted into an input consistent with the model
+                                                                     according to the following type and fmt. so the following variables
+                                                                     need to be set.*/
+    rknn_tensor_type type;                              /* the data type of input buf. */
+    rknn_tensor_format fmt;                             /* the data format of input buf.
+                                                           currently the internal input format of NPU is NCHW by default.
+                                                           so entering NCHW data can avoid the format conversion in the driver. */
+} rknn_input;
+
+/*
+    the output information for rknn_outputs_get.
+*/
+typedef struct _rknn_output {
+    uint8_t want_float;                                 /* want transfer output data to float */
+    uint8_t is_prealloc;                                /* whether buf is pre-allocated.
+                                                           if true, the following variables need to be set.
+                                                           if false, The following variables do not need to be set. */
+    uint32_t index;                                     /* the output index. */
+    void* buf;                                          /* the output buf for index.
+                                                           when is_prealloc = FALSE and rknn_outputs_release called,
+                                                           this buf pointer will be free and don't use it anymore. */
+    uint32_t size;                                      /* the size of output buf. */
+} rknn_output;
+
+/*
+    the extend information for rknn_run.
+*/
+typedef struct _rknn_run_extend {
+    uint64_t frame_id;                                  /* output parameter, indicate current frame id of run. */
+} rknn_run_extend;
+
+/*
+    the extend information for rknn_outputs_get.
+*/
+typedef struct _rknn_output_extend {
+    uint64_t frame_id;                                  /* output parameter, indicate the frame id of outputs, corresponds to
+                                                           struct rknn_run_extend.frame_id.*/
+} rknn_output_extend;
+
+/*
+    the information for RKNN_QUERY_RKNN_PRECOMPILE.
+*/
+typedef struct _rknn_precompile {
+    void* model_data;                                   /* the pointer of precompile model. don't need free it by user. */
+    uint32_t data_len;                                  /* the model length. */
+} rknn_precompile;
+
+/*  rknn_init
+
+    initial the context and load the rknn model.
+
+    input:
+        rknn_context* context       the pointer of context handle.
+        void* model                 pointer to the rknn model.
+        uint32_t size               the size of rknn model.
+        uint32_t flag               extend flag, see the define of RKNN_FLAG_XXX_XXX.
+    return:
+        int                         error code.
+*/
+int rknn_init(rknn_context* context, void* model, uint32_t size, uint32_t flag);
+
+
+/*  rknn_destroy
+
+    unload the rknn model and destroy the context.
+
+    input:
+        rknn_context context        the handle of context.
+    return:
+        int                         error code.
+*/
+int rknn_destroy(rknn_context context);
+
+
+/*  rknn_query
+
+    query the information about model or others. see rknn_query_cmd.
+
+    input:
+        rknn_context context        the handle of context.
+        rknn_query_cmd cmd          the command of query.
+        void* info                  the buffer point of information.
+        uint32_t size               the size of information.
+    return:
+        int                         error code.
+*/
+int rknn_query(rknn_context context, rknn_query_cmd cmd, void* info, uint32_t size);
+
+
+/*  rknn_inputs_set
+
+    set inputs information by input index of rknn model.
+    inputs information see rknn_input.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_inputs           the number of inputs.
+        rknn_input inputs[]         the arrays of inputs information, see rknn_input.
+    return:
+        int                         error code
+*/
+int rknn_inputs_set(rknn_context context, uint32_t n_inputs, rknn_input inputs[]);
+
+
+/*  rknn_inputs_map
+
+    map inputs tensor memory information by input index of rknn model.
+    inputs information see rknn_input.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_inputs           the number of inputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code
+*/
+int rknn_inputs_map(rknn_context context, uint32_t n_inputs, rknn_tensor_mem mem[]);
+
+
+/*  rknn_inputs_sync
+
+    synchronize inputs tensor buffer by input index of rknn model.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_inputs           the number of inputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code
+*/
+int rknn_inputs_sync(rknn_context context, uint32_t n_inputs, rknn_tensor_mem mem[]);
+
+
+/*  rknn_inputs_unmap
+
+    unmap inputs tensor memory information by input index of rknn model.
+    inputs information see rknn_input.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_inputs           the number of inputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code
+*/
+int rknn_inputs_unmap(rknn_context context, uint32_t n_inputs, rknn_tensor_mem mem[]);
+
+
+/*  rknn_run
+
+    run the model to execute inference.
+
+    input:
+        rknn_context context        the handle of context.
+        rknn_run_extend* extend     the extend information of run.
+    return:
+        int                         error code.
+*/
+int rknn_run(rknn_context context, rknn_run_extend* extend);
+
+
+/*  rknn_outputs_get
+
+    wait the inference to finish and get the outputs.
+    this function will block until inference finish.
+    the results will set to outputs[].
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_outputs          the number of outputs.
+        rknn_output outputs[]       the arrays of output, see rknn_output.
+        rknn_output_extend*         the extend information of output.
+    return:
+        int                         error code.
+*/
+int rknn_outputs_get(rknn_context context, uint32_t n_outputs, rknn_output outputs[], rknn_output_extend* extend);
+
+
+/*  rknn_outputs_release
+
+    release the outputs that get by rknn_outputs_get.
+    after called, the rknn_output[x].buf get from rknn_outputs_get will
+    also be free when rknn_output[x].is_prealloc = FALSE.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_ouputs           the number of outputs.
+        rknn_output outputs[]       the arrays of output.
+    return:
+        int                         error code
+*/
+int rknn_outputs_release(rknn_context context, uint32_t n_ouputs, rknn_output outputs[]);
+
+
+/*  rknn_outputs_map
+
+    map the model output tensors memory information.
+    The difference between this function and "rknn_outputs_get" is
+    that it directly maps the model output tensor memory location to the user.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_outputs          the number of outputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code.
+*/
+int rknn_outputs_map(rknn_context context, uint32_t n_outputs, rknn_tensor_mem mem[]);
+
+/*  rknn_outputs_sync
+
+    synchronize the output tensors buffer to ensure cache cohenrency, wait the inference to finish.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_outputs          the number of outputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code.
+*/
+int rknn_outputs_sync(rknn_context context, uint32_t n_outputs, rknn_tensor_mem mem[]);
+
+/*  rknn_outputs_unmap
+
+    unmap the outputs memory information that get by rknn_outputs_map.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_ouputs           the number of outputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code
+*/
+int rknn_outputs_unmap(rknn_context context, uint32_t n_ouputs, rknn_tensor_mem mem[]);
+
+/*  rknn_create_mem (memory allocated inside)
+
+    Create tensor memory. This API require libdrm support!
+
+    input:
+        rknn_context ctx            the handle of context.
+        uint64_t size               the size of tensor buffer.
+    return:
+        rknn_tensor_mem             the pointer of tensor memory information.
+*/
+rknn_tensor_mem* rknn_create_mem(rknn_context ctx, uint64_t size);
+
+/*  rknn_destroy_mem (support allocate inside and outside)
+
+    destroy tensor memory.
+
+    input:
+        rknn_context ctx            the handle of context.
+        rknn_tensor_mem *mem        the pointer of tensor memory information.
+    return:
+        int                         error code
+*/
+int rknn_destroy_mem(rknn_context ctx, rknn_tensor_mem *mem);
+
+
+
+/*  rknn_set_io_mem
+
+    set the input and output tensors buffer.
+
+    input:
+        rknn_context ctx            the handle of context.
+        rknn_tensor_mem *mem        the array of tensor memory information.
+        rknn_tensor_attr *attr      the attribute of input or output tensor buffer.
+    return:
+        int                         error code.
+*/
+int rknn_set_io_mem(rknn_context ctx, rknn_tensor_mem *mem, rknn_tensor_attr *attr);
+
+#ifdef __cplusplus
+} //extern "C"
+#endif
+
+#endif  //_RKNN_RUNTIME_H
diff --git a/C++/yolo_bytetrack/3rdparty/rga/include/RgaUtils.h b/C++/yolo_bytetrack/3rdparty/rga/include/RgaUtils.h
new file mode 100644
index 00000000..1c5a6575
--- /dev/null
+++ b/C++/yolo_bytetrack/3rdparty/rga/include/RgaUtils.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2016 Rockchip Electronics Co., Ltd.
+ * Authors:
+ *  Zhiqin Wei <wzq@rock-chips.com>
+ *
+ * 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.
+ */
+
+#ifndef _rga_utils_h_
+#define _rga_utils_h_
+
+// -------------------------------------------------------------------------------
+float get_bpp_from_format(int format);
+int get_buf_from_file(void *buf, int f, int sw, int sh, int index);
+int output_buf_data_to_file(void *buf, int f, int sw, int sh, int index);
+const char *translate_format_str(int format);
+int get_buf_from_file_AFBC(void *buf, int f, int sw, int sh, int index);
+int output_buf_data_to_file_AFBC(void *buf, int f, int sw, int sh, int index);
+#endif
+
diff --git a/C++/yolo_bytetrack/3rdparty/rga/include/im2d.h b/C++/yolo_bytetrack/3rdparty/rga/include/im2d.h
new file mode 100644
index 00000000..74581712
--- /dev/null
+++ b/C++/yolo_bytetrack/3rdparty/rga/include/im2d.h
@@ -0,0 +1,963 @@
+/*
+ * Copyright (C) 2020 Rockchip Electronics Co., Ltd.
+ * Authors:
+ *  PutinLee <putin.lee@rock-chips.com>
+ *  Cerf Yu <cerf.yu@rock-chips.com>
+ *
+ * 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.
+ */
+
+#ifndef _im2d_h_
+#define _im2d_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#ifndef IM_API
+#define IM_API /* define API export as needed */
+#endif
+
+typedef enum {
+    /* Rotation */
+    IM_HAL_TRANSFORM_ROT_90     = 1 << 0,
+    IM_HAL_TRANSFORM_ROT_180    = 1 << 1,
+    IM_HAL_TRANSFORM_ROT_270    = 1 << 2,
+    IM_HAL_TRANSFORM_FLIP_H     = 1 << 3,
+    IM_HAL_TRANSFORM_FLIP_V     = 1 << 4,
+    IM_HAL_TRANSFORM_FLIP_H_V   = 1 << 5,
+    IM_HAL_TRANSFORM_MASK       = 0x3f,
+
+    /*
+     * Blend
+     * Additional blend usage, can be used with both source and target configs.
+     * If none of the below is set, the default "SRC over DST" is applied.
+     */
+    IM_ALPHA_BLEND_SRC_OVER     = 1 << 6,     /* Default, Porter-Duff "SRC over DST" */
+    IM_ALPHA_BLEND_SRC          = 1 << 7,     /* Porter-Duff "SRC" */
+    IM_ALPHA_BLEND_DST          = 1 << 8,     /* Porter-Duff "DST" */
+    IM_ALPHA_BLEND_SRC_IN       = 1 << 9,     /* Porter-Duff "SRC in DST" */
+    IM_ALPHA_BLEND_DST_IN       = 1 << 10,    /* Porter-Duff "DST in SRC" */
+    IM_ALPHA_BLEND_SRC_OUT      = 1 << 11,    /* Porter-Duff "SRC out DST" */
+    IM_ALPHA_BLEND_DST_OUT      = 1 << 12,    /* Porter-Duff "DST out SRC" */
+    IM_ALPHA_BLEND_DST_OVER     = 1 << 13,    /* Porter-Duff "DST over SRC" */
+    IM_ALPHA_BLEND_SRC_ATOP     = 1 << 14,    /* Porter-Duff "SRC ATOP" */
+    IM_ALPHA_BLEND_DST_ATOP     = 1 << 15,    /* Porter-Duff "DST ATOP" */
+    IM_ALPHA_BLEND_XOR          = 1 << 16,    /* Xor */
+    IM_ALPHA_BLEND_MASK         = 0x1ffc0,
+
+    IM_ALPHA_COLORKEY_NORMAL    = 1 << 17,
+    IM_ALPHA_COLORKEY_INVERTED  = 1 << 18,
+    IM_ALPHA_COLORKEY_MASK      = 0x60000,
+
+    IM_SYNC                     = 1 << 19,
+    IM_ASYNC                    = 1 << 26,
+    IM_CROP                     = 1 << 20,    /* Unused */
+    IM_COLOR_FILL               = 1 << 21,
+    IM_COLOR_PALETTE            = 1 << 22,
+    IM_NN_QUANTIZE              = 1 << 23,
+    IM_ROP                      = 1 << 24,
+    IM_ALPHA_BLEND_PRE_MUL      = 1 << 25,
+
+} IM_USAGE;
+
+typedef enum {
+    IM_RASTER_MODE  = 1 << 0,
+    IM_AFBC_MODE    = 1 << 1,
+    IM_TILE_MODE    = 1 << 2,
+} IM_RD_MODE;
+
+typedef enum {
+    IM_SCHEDULER_RGA3_CORE0 = 1 << 0,
+    IM_SCHEDULER_RGA3_CORE1 = 1 << 1,
+    IM_SCHEDULER_RGA2_CORE0 = 1 << 2,
+    IM_SCHEDULER_RGA3_DEFAULT = IM_SCHEDULER_RGA3_CORE0,
+    IM_SCHEDULER_RGA2_DEFAULT = IM_SCHEDULER_RGA2_CORE0,
+    IM_SCHEDULER_MASK       = 0x7,
+    IM_SCHEDULER_DEFAULT = 0,
+} IM_SCHEDULER_CORE;
+
+typedef enum {
+    IM_ROP_AND                  = 0x88,
+    IM_ROP_OR                   = 0xee,
+    IM_ROP_NOT_DST              = 0x55,
+    IM_ROP_NOT_SRC              = 0x33,
+    IM_ROP_XOR                  = 0xf6,
+    IM_ROP_NOT_XOR              = 0xf9,
+} IM_ROP_CODE;
+
+typedef enum {
+    IM_RGA_SUPPORT_FORMAT_ERROR_INDEX = 0,
+    IM_RGA_SUPPORT_FORMAT_RGB_INDEX,
+    IM_RGA_SUPPORT_FORMAT_RGB_OTHER_INDEX,
+    IM_RGA_SUPPORT_FORMAT_BPP_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_8_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_10_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUYV_420_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUYV_422_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_400_INDEX,
+    IM_RGA_SUPPORT_FORMAT_Y4_INDEX,
+    IM_RGA_SUPPORT_FORMAT_MASK_INDEX,
+} IM_RGA_SUPPORT_FORMAT_INDEX;
+
+typedef enum {
+    IM_RGA_SUPPORT_FORMAT_ERROR     = 1 << IM_RGA_SUPPORT_FORMAT_ERROR_INDEX,
+    IM_RGA_SUPPORT_FORMAT_RGB       = 1 << IM_RGA_SUPPORT_FORMAT_RGB_INDEX,
+    IM_RGA_SUPPORT_FORMAT_RGB_OTHER = 1 << IM_RGA_SUPPORT_FORMAT_RGB_OTHER_INDEX,
+    IM_RGA_SUPPORT_FORMAT_BPP       = 1 << IM_RGA_SUPPORT_FORMAT_BPP_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_8     = 1 << IM_RGA_SUPPORT_FORMAT_YUV_8_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_10    = 1 << IM_RGA_SUPPORT_FORMAT_YUV_10_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUYV_420  = 1 << IM_RGA_SUPPORT_FORMAT_YUYV_420_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUYV_422  = 1 << IM_RGA_SUPPORT_FORMAT_YUYV_422_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_400   = 1 << IM_RGA_SUPPORT_FORMAT_YUV_400_INDEX,
+    IM_RGA_SUPPORT_FORMAT_Y4        = 1 << IM_RGA_SUPPORT_FORMAT_Y4_INDEX,
+    IM_RGA_SUPPORT_FORMAT_MASK      = ~((~(unsigned int)0x0 << IM_RGA_SUPPORT_FORMAT_MASK_INDEX) | 1),
+} IM_RGA_SUPPORT_FORMAT;
+
+typedef enum {
+    IM_RGA_SUPPORT_FEATURE_ERROR_INDEX = 0,
+    IM_RGA_SUPPORT_FEATURE_COLOR_FILL_INDEX,
+    IM_RGA_SUPPORT_FEATURE_COLOR_PALETTE_INDEX,
+    IM_RGA_SUPPORT_FEATURE_ROP_INDEX,
+    IM_RGA_SUPPORT_FEATURE_QUANTIZE_INDEX,
+    IM_RGA_SUPPORT_FEATURE_SRC1_R2Y_CSC_INDEX,
+    IM_RGA_SUPPORT_FEATURE_DST_FULL_CSC_INDEX,
+    IM_RGA_SUPPORT_FEATURE_MASK_INDEX,
+} IM_RGA_SUPPORT_FEATURE_INDEX;
+
+typedef enum {
+    IM_RGA_SUPPORT_FEATURE_ERROR          = 1 << IM_RGA_SUPPORT_FEATURE_ERROR_INDEX,
+    IM_RGA_SUPPORT_FEATURE_COLOR_FILL     = 1 << IM_RGA_SUPPORT_FEATURE_COLOR_FILL_INDEX,
+    IM_RGA_SUPPORT_FEATURE_COLOR_PALETTE  = 1 << IM_RGA_SUPPORT_FEATURE_COLOR_PALETTE_INDEX,
+    IM_RGA_SUPPORT_FEATURE_ROP            = 1 << IM_RGA_SUPPORT_FEATURE_ROP_INDEX,
+    IM_RGA_SUPPORT_FEATURE_QUANTIZE       = 1 << IM_RGA_SUPPORT_FEATURE_QUANTIZE_INDEX,
+    IM_RGA_SUPPORT_FEATURE_SRC1_R2Y_CSC   = 1 << IM_RGA_SUPPORT_FEATURE_SRC1_R2Y_CSC_INDEX,
+    IM_RGA_SUPPORT_FEATURE_DST_FULL_CSC   = 1 << IM_RGA_SUPPORT_FEATURE_DST_FULL_CSC_INDEX,
+    IM_RGA_SUPPORT_FEATURE_MASK           = ~((~(unsigned int)0x0 << IM_RGA_SUPPORT_FEATURE_MASK_INDEX) | 1),
+} IM_RGA_SUPPORT_FEATURE;
+
+/* Status codes, returned by any blit function */
+typedef enum {
+    IM_STATUS_NOERROR         =  2,
+    IM_STATUS_SUCCESS         =  1,
+    IM_STATUS_NOT_SUPPORTED   = -1,
+    IM_STATUS_OUT_OF_MEMORY   = -2,
+    IM_STATUS_INVALID_PARAM   = -3,
+    IM_STATUS_ILLEGAL_PARAM   = -4,
+    IM_STATUS_FAILED          =  0,
+} IM_STATUS;
+
+/* Status codes, returned by any blit function */
+typedef enum {
+    IM_YUV_TO_RGB_BT601_LIMIT     = 1 << 0,
+    IM_YUV_TO_RGB_BT601_FULL      = 2 << 0,
+    IM_YUV_TO_RGB_BT709_LIMIT     = 3 << 0,
+    IM_YUV_TO_RGB_MASK            = 3 << 0,
+    IM_RGB_TO_YUV_BT601_FULL      = 1 << 2,
+    IM_RGB_TO_YUV_BT601_LIMIT     = 2 << 2,
+    IM_RGB_TO_YUV_BT709_LIMIT     = 3 << 2,
+    IM_RGB_TO_YUV_MASK            = 3 << 2,
+    IM_RGB_TO_Y4                  = 1 << 4,
+    IM_RGB_TO_Y4_DITHER           = 2 << 4,
+    IM_RGB_TO_Y1_DITHER           = 3 << 4,
+    IM_Y4_MASK                    = 3 << 4,
+    IM_RGB_FULL                   = 1 << 8,
+    IM_RGB_CLIP                   = 2 << 8,
+    IM_YUV_BT601_LIMIT_RANGE      = 3 << 8,
+    IM_YUV_BT601_FULL_RANGE       = 4 << 8,
+    IM_YUV_BT709_LIMIT_RANGE      = 5 << 8,
+    IM_YUV_BT709_FULL_RANGE       = 6 << 8,
+    IM_FULL_CSC_MASK              = 0xf << 8,
+    IM_COLOR_SPACE_DEFAULT        = 0,
+} IM_COLOR_SPACE_MODE;
+
+typedef enum {
+    IM_UP_SCALE,
+    IM_DOWN_SCALE,
+} IM_SCALE;
+
+typedef enum {
+    INTER_NEAREST,
+    INTER_LINEAR,
+    INTER_CUBIC,
+} IM_SCALE_MODE;
+
+/* Get RGA basic information index */
+typedef enum {
+    RGA_VENDOR = 0,
+    RGA_VERSION,
+    RGA_MAX_INPUT,
+    RGA_MAX_OUTPUT,
+    RGA_SCALE_LIMIT,
+    RGA_INPUT_FORMAT,
+    RGA_OUTPUT_FORMAT,
+    RGA_FEATURE,
+    RGA_EXPECTED,
+    RGA_ALL,
+} IM_INFORMATION;
+
+/*rga version index*/
+typedef enum {
+    RGA_V_ERR                  = 0x0,
+    RGA_1                      = 0x1,
+    RGA_1_PLUS                 = 0x2,
+    RGA_2                      = 0x3,
+    RGA_2_LITE0                = 0x4,
+    RGA_2_LITE1                = 0x5,
+    RGA_2_ENHANCE              = 0x6,
+} RGA_VERSION_NUM;
+
+typedef enum {
+    IM_CONFIG_SCHEDULER_CORE,
+    IM_CONFIG_PRIORITY,
+    IM_CHECK_CONFIG,
+} IM_CONFIG_NAME;
+
+//struct AHardwareBuffer AHardwareBuffer;
+
+typedef struct {
+    RGA_VERSION_NUM version;
+    unsigned int input_resolution;
+    unsigned int output_resolution;
+    unsigned int scale_limit;
+    unsigned int performance;
+    unsigned int input_format;
+    unsigned int output_format;
+    unsigned int feature;
+    char reserved[28];
+} rga_info_table_entry;
+
+/* Rectangle definition */
+typedef struct {
+    int x;        /* upper-left x */
+    int y;        /* upper-left y */
+    int width;    /* width */
+    int height;   /* height */
+} im_rect;
+
+typedef struct {
+    int max;                    /* The Maximum value of the color key */
+    int min;                    /* The minimum value of the color key */
+} im_colorkey_range;
+
+
+typedef struct im_nn {
+    int scale_r;                /* scaling factor on R channal */
+    int scale_g;                /* scaling factor on G channal */
+    int scale_b;                /* scaling factor on B channal */
+    int offset_r;               /* offset on R channal */
+    int offset_g;               /* offset on G channal */
+    int offset_b;               /* offset on B channal */
+} im_nn_t;
+
+/* im_info definition */
+typedef struct {
+    void* vir_addr;                     /* virtual address */
+    void* phy_addr;                     /* physical address */
+    int fd;                             /* shared fd */
+
+    int width;                          /* width */
+    int height;                         /* height */
+    int wstride;                        /* wstride */
+    int hstride;                        /* hstride */
+    int format;                         /* format */
+
+    int color_space_mode;               /* color_space_mode */
+    int global_alpha;                   /* global_alpha */
+    int rd_mode;
+
+    /* legarcy */
+    int color;                          /* color, used by color fill */
+    im_colorkey_range colorkey_range;   /* range value of color key */
+    im_nn_t nn;
+    int rop_code;
+} rga_buffer_t;
+
+typedef struct im_opt {
+    int color;                          /* color, used by color fill */
+    im_colorkey_range colorkey_range;   /* range value of color key */
+    im_nn_t nn;
+    int rop_code;
+
+    int priority;
+    int core;
+} im_opt_t;
+
+typedef struct im_context {
+    int priority;
+    IM_SCHEDULER_CORE core;
+    bool check_mode;
+} im_context_t;
+
+/*
+ * @return error message string
+ */
+#define imStrError(...) \
+    ({ \
+        const char* im2d_api_err; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_err = imStrError_t(IM_STATUS_INVALID_PARAM); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_err = imStrError_t((IM_STATUS)im2d_api_args[0]); \
+        } else { \
+            im2d_api_err = ("Fatal error, imStrError() too many parameters\n"); \
+            printf("Fatal error, imStrError() too many parameters\n"); \
+        } \
+        im2d_api_err; \
+    })
+IM_API const char* imStrError_t(IM_STATUS status);
+
+/*
+ * @return rga_buffer_t
+ */
+#define wrapbuffer_virtualaddr(vir_addr, width, height, format, ...) \
+    ({ \
+        rga_buffer_t im2d_api_buffer; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_buffer = wrapbuffer_virtualaddr_t(vir_addr, width, height, width, height, format); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_buffer = wrapbuffer_virtualaddr_t(vir_addr, width, height, im2d_api_args[0], im2d_api_args[1], format); \
+        } else { \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_buffer; \
+    })
+
+#define wrapbuffer_physicaladdr(phy_addr, width, height, format, ...) \
+    ({ \
+        rga_buffer_t im2d_api_buffer; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_buffer = wrapbuffer_physicaladdr_t(phy_addr, width, height, width, height, format); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_buffer = wrapbuffer_physicaladdr_t(phy_addr, width, height, im2d_api_args[0], im2d_api_args[1], format); \
+        } else { \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_buffer; \
+    })
+
+#define wrapbuffer_fd(fd, width, height, format, ...) \
+    ({ \
+        rga_buffer_t im2d_api_buffer; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_buffer = wrapbuffer_fd_t(fd, width, height, width, height, format); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_buffer = wrapbuffer_fd_t(fd, width, height, im2d_api_args[0], im2d_api_args[1], format); \
+        } else { \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_buffer; \
+    })
+
+IM_API rga_buffer_t wrapbuffer_virtualaddr_t(void* vir_addr, int width, int height, int wstride, int hstride, int format);
+IM_API rga_buffer_t wrapbuffer_physicaladdr_t(void* phy_addr, int width, int height, int wstride, int hstride, int format);
+IM_API rga_buffer_t wrapbuffer_fd_t(int fd, int width, int height, int wstride, int hstride, int format);
+
+/*
+ * Get RGA basic information, supported resolution, supported format, etc.
+ *
+ * @param name
+ *      RGA_VENDOR
+ *      RGA_VERSION
+ *      RGA_MAX_INPUT
+ *      RGA_MAX_OUTPUT
+ *      RGA_INPUT_FORMAT
+ *      RGA_OUTPUT_FORMAT
+ *      RGA_EXPECTED
+ *      RGA_ALL
+ *
+ * @returns a usage describing properties of RGA.
+ */
+//IM_API int rga_get_info(rga_info_table_entry *);
+IM_API IM_STATUS rga_get_info(rga_info_table_entry *return_table);
+
+/*
+ * Query RGA basic information, supported resolution, supported format, etc.
+ *
+ * @param name
+ *      RGA_VENDOR
+ *      RGA_VERSION
+ *      RGA_MAX_INPUT
+ *      RGA_MAX_OUTPUT
+ *      RGA_INPUT_FORMAT
+ *      RGA_OUTPUT_FORMAT
+ *      RGA_EXPECTED
+ *      RGA_ALL
+ *
+ * @returns a string describing properties of RGA.
+ */
+IM_API const char* querystring(int name);
+
+/*
+ * check RGA basic information, supported resolution, supported format, etc.
+ *
+ * @param src
+ * @param dst
+ * @param src_rect
+ * @param dst_rect
+ * @param mode_usage
+ *
+ * @returns no error or else negative error code.
+ */
+#define imcheck(src, dst, src_rect, dst_rect, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_NOERROR; \
+        rga_buffer_t im2d_api_pat; \
+        im_rect im2d_api_pat_rect; \
+        memset(&im2d_api_pat, 0, sizeof(rga_buffer_t)); \
+        memset(&im2d_api_pat_rect, 0, sizeof(im_rect)); \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            rga_check_perpare((rga_buffer_t *)(&src), (rga_buffer_t *)(&dst), (rga_buffer_t *)(&im2d_api_pat), \
+                              (im_rect *)(&src_rect), (im_rect *)(&dst_rect), (im_rect *)(&im2d_api_pat_rect), 0); \
+            im2d_api_ret = imcheck_t(src, dst, im2d_api_pat, src_rect, dst_rect, im2d_api_pat_rect, 0); \
+        } else if (im2d_api_argc == 1){ \
+            rga_check_perpare((rga_buffer_t *)(&src), (rga_buffer_t *)(&dst), (rga_buffer_t *)(&im2d_api_pat), \
+                              (im_rect *)(&src_rect), (im_rect *)(&dst_rect), (im_rect *)(&im2d_api_pat_rect), im2d_api_args[0]); \
+            im2d_api_ret = imcheck_t(src, dst, im2d_api_pat, src_rect, dst_rect, im2d_api_pat_rect, im2d_api_args[0]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_FAILED; \
+            printf("check failed\n"); \
+        } \
+        im2d_api_ret; \
+    })
+#define imcheck_composite(src, dst, pat, src_rect, dst_rect, pat_rect, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_NOERROR; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            rga_check_perpare((rga_buffer_t *)(&src), (rga_buffer_t *)(&dst), (rga_buffer_t *)(&pat), \
+                              (im_rect *)(&src_rect), (im_rect *)(&dst_rect), (im_rect *)(&pat_rect), 0); \
+            im2d_api_ret = imcheck_t(src, dst, pat, src_rect, dst_rect, pat_rect, 0); \
+        } else if (im2d_api_argc == 1){ \
+            rga_check_perpare((rga_buffer_t *)(&src), (rga_buffer_t *)(&dst), (rga_buffer_t *)(&pat), \
+                              (im_rect *)(&src_rect), (im_rect *)(&dst_rect), (im_rect *)(&pat_rect), im2d_api_args[0]); \
+            im2d_api_ret = imcheck_t(src, dst, pat, src_rect, dst_rect, pat_rect, im2d_api_args[0]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_FAILED; \
+            printf("check failed\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API void rga_check_perpare(rga_buffer_t *src, rga_buffer_t *dst, rga_buffer_t *pat,
+                              im_rect *src_rect, im_rect *dst_rect, im_rect *pat_rect, int mode_usage);
+IM_API IM_STATUS imcheck_t(const rga_buffer_t src, const rga_buffer_t dst, const rga_buffer_t pat,
+                           const im_rect src_rect, const im_rect dst_rect, const im_rect pat_rect, const int mode_usage);
+
+/*
+ * Resize
+ *
+ * @param src
+ * @param dst
+ * @param fx
+ * @param fy
+ * @param interpolation
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imresize(src, dst, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        double im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(double); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imresize_t(src, dst, 0, 0, IM_SCALE_MODE::INTER_LINEAR, 1); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_ret = imresize_t(src, dst, im2d_api_args[0], im2d_api_args[1], IM_SCALE_MODE::INTER_LINEAR, 1); \
+        } else if (im2d_api_argc == 3){ \
+            im2d_api_ret = imresize_t(src, dst, im2d_api_args[0], im2d_api_args[1], (int)im2d_api_args[2], 1); \
+        } else if (im2d_api_argc == 4){ \
+            im2d_api_ret = imresize_t(src, dst, im2d_api_args[0], im2d_api_args[1], (int)im2d_api_args[2], (int)im2d_api_args[3]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+#define impyramid(src, dst, direction) \
+        imresize_t(src, \
+                   dst, \
+                   direction == IM_UP_SCALE ? 0.5 : 2, \
+                   direction == IM_UP_SCALE ? 0.5 : 2, \
+                   INTER_LINEAR, 1)
+
+IM_API IM_STATUS imresize_t(const rga_buffer_t src, rga_buffer_t dst, double fx, double fy, int interpolation, int sync);
+
+/*
+ * Crop
+ *
+ * @param src
+ * @param dst
+ * @param rect
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imcrop(src, dst, rect, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imcrop_t(src, dst, rect, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imcrop_t(src, dst, rect, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imcrop_t(const rga_buffer_t src, rga_buffer_t dst, im_rect rect, int sync);
+
+/*
+ * rotation
+ *
+ * @param src
+ * @param dst
+ * @param rotation
+ *      IM_HAL_TRANSFORM_ROT_90
+ *      IM_HAL_TRANSFORM_ROT_180
+ *      IM_HAL_TRANSFORM_ROT_270
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imrotate(src, dst, rotation, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imrotate_t(src, dst, rotation, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imrotate_t(src, dst, rotation, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imrotate_t(const rga_buffer_t src, rga_buffer_t dst, int rotation, int sync);
+
+/*
+ * flip
+ *
+ * @param src
+ * @param dst
+ * @param mode
+ *      IM_HAL_TRANSFORM_FLIP_H
+ *      IM_HAL_TRANSFORM_FLIP_V
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imflip(src, dst, mode, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imflip_t(src, dst, mode, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imflip_t(src, dst, mode, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imflip_t (const rga_buffer_t src, rga_buffer_t dst, int mode, int sync);
+
+/*
+ * fill/reset/draw
+ *
+ * @param src
+ * @param dst
+ * @param rect
+ * @param color
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imfill(buf, rect, color, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imfill_t(buf, rect, color, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imfill_t(buf, rect, color, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+#define imreset(buf, rect, color, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imfill_t(buf, rect, color, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imfill_t(buf, rect, color, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+#define imdraw(buf, rect, color, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imfill_t(buf, rect, color, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imfill_t(buf, rect, color, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS imfill_t(rga_buffer_t dst, im_rect rect, int color, int sync);
+
+/*
+ * palette
+ *
+ * @param src
+ * @param dst
+ * @param lut
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define impalette(src, dst, lut,  ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = impalette_t(src, dst, lut, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = impalette_t(src, dst, lut, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS impalette_t(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t lut, int sync);
+
+/*
+ * translate
+ *
+ * @param src
+ * @param dst
+ * @param x
+ * @param y
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imtranslate(src, dst, x, y, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imtranslate_t(src, dst, x, y, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imtranslate_t(src, dst, x, y, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS imtranslate_t(const rga_buffer_t src, rga_buffer_t dst, int x, int y, int sync);
+
+/*
+ * copy
+ *
+ * @param src
+ * @param dst
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imcopy(src, dst, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imcopy_t(src, dst, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imcopy_t(src, dst, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imcopy_t(const rga_buffer_t src, rga_buffer_t dst, int sync);
+
+/*
+ * blend (SRC + DST -> DST or SRCA + SRCB -> DST)
+ *
+ * @param srcA
+ * @param srcB can be NULL.
+ * @param dst
+ * @param mode
+ *      IM_ALPHA_BLEND_MODE
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imblend(srcA, dst, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        rga_buffer_t srcB; \
+        memset(&srcB, 0x00, sizeof(rga_buffer_t)); \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, IM_ALPHA_BLEND_SRC_OVER, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, im2d_api_args[0], 1); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, im2d_api_args[0], im2d_api_args[1]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+#define imcomposite(srcA, srcB, dst, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, IM_ALPHA_BLEND_SRC_OVER, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, im2d_api_args[0], 1); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, im2d_api_args[0], im2d_api_args[1]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS imblend_t(const rga_buffer_t srcA, const rga_buffer_t srcB, rga_buffer_t dst, int mode, int sync);
+
+/*
+ * color key
+ *
+ * @param src
+ * @param dst
+ * @param colorkey_range
+ *      max color
+ *      min color
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imcolorkey(src, dst, range, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imcolorkey_t(src, dst, range, IM_ALPHA_COLORKEY_NORMAL, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imcolorkey_t(src, dst, range, im2d_api_args[0], 1); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_ret = imcolorkey_t(src, dst, range, im2d_api_args[0], im2d_api_args[1]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS imcolorkey_t(const rga_buffer_t src, rga_buffer_t dst, im_colorkey_range range, int mode, int sync);
+
+/*
+ * format convert
+ *
+ * @param src
+ * @param dst
+ * @param sfmt
+ * @param dfmt
+ * @param mode
+ *      color space mode: IM_COLOR_SPACE_MODE
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imcvtcolor(src, dst, sfmt, dfmt, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imcvtcolor_t(src, dst, sfmt, dfmt, IM_COLOR_SPACE_DEFAULT, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imcvtcolor_t(src, dst, sfmt, dfmt, im2d_api_args[0], 1); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_ret = imcvtcolor_t(src, dst, sfmt, dfmt, im2d_api_args[0], im2d_api_args[1]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imcvtcolor_t(rga_buffer_t src, rga_buffer_t dst, int sfmt, int dfmt, int mode, int sync);
+
+/*
+ * nn quantize
+ *
+ * @param src
+ * @param dst
+ * @param nninfo
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imquantize(src, dst, nn_info, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imquantize_t(src, dst, nn_info, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imquantize_t(src, dst, nn_info, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imquantize_t(const rga_buffer_t src, rga_buffer_t dst, im_nn_t nn_info, int sync);
+
+/*
+ * ROP
+ *
+ * @param src
+ * @param dst
+ * @param rop_code
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imrop(src, dst, rop_code, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imrop_t(src, dst, rop_code, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imrop_t(src, dst, rop_code, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS imrop_t(const rga_buffer_t src, rga_buffer_t dst, int rop_code, int sync);
+
+/*
+ * process
+ *
+ * @param src
+ * @param dst
+ * @param usage
+ * @param ...
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+IM_API IM_STATUS improcess(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat,
+                        im_rect srect, im_rect drect, im_rect prect, int usage);
+
+IM_API IM_STATUS improcess_t(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat,
+                        im_rect srect, im_rect drect, im_rect prect,
+                        int in_fence_fd, int *out_fence_fd, im_opt_t *opt, int usage);
+
+/*
+ * block until all execution is complete
+ *
+ * @returns success or else negative error code.
+ */
+IM_API IM_STATUS imsync(int out_fence_fd);
+
+/*
+ * config
+ *
+ * @param name
+ *      enum IM_CONFIG_NAME
+ * @param value
+ *
+ * @returns success or else negative error code.
+ */
+IM_API IM_STATUS imconfig(IM_CONFIG_NAME name, uint64_t value);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* _im2d_h_ */
+
diff --git a/C++/yolo_bytetrack/3rdparty/rga/include/im2d.hpp b/C++/yolo_bytetrack/3rdparty/rga/include/im2d.hpp
new file mode 100644
index 00000000..c3bba243
--- /dev/null
+++ b/C++/yolo_bytetrack/3rdparty/rga/include/im2d.hpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 Rockchip Electronics Co., Ltd.
+ * Authors:
+ *  PutinLee <putin.lee@rock-chips.com>
+ *  Cerf Yu <cerf.yu@rock-chips.com>
+ *
+ * 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.
+ */
+#ifndef _im2d_hpp_
+#define _im2d_hpp_
+
+#include "im2d.h"
+#include "RgaUtils.h"
+
+#ifdef ANDROID
+
+#include <ui/GraphicBuffer.h>
+
+using namespace android;
+
+IM_API rga_buffer_t wrapbuffer_handle(buffer_handle_t hnd);
+IM_API rga_buffer_t wrapbuffer_GraphicBuffer(sp<GraphicBuffer> buf);
+
+#if USE_AHARDWAREBUFFER
+#include <android/hardware_buffer.h>
+IM_API rga_buffer_t wrapbuffer_AHardwareBuffer(AHardwareBuffer *buf);
+
+#endif /* USE_AHARDWAREBUFFER */
+#endif /* ANDROID */
+#endif /* _im2d_hpp_ */
+
diff --git a/C++/yolo_bytetrack/3rdparty/rga/include/rga.h b/C++/yolo_bytetrack/3rdparty/rga/include/rga.h
new file mode 100644
index 00000000..8af08be7
--- /dev/null
+++ b/C++/yolo_bytetrack/3rdparty/rga/include/rga.h
@@ -0,0 +1,392 @@
+/*
+ * Copyright (C) 2016 Rockchip Electronics Co., Ltd.
+ * Authors:
+ *    Zhiqin Wei <wzq@rock-chips.com>
+ *
+ * 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.
+ */
+
+#ifndef _RGA_DRIVER_H_
+#define _RGA_DRIVER_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+
+#define RGA_BLIT_SYNC   0x5017
+#define RGA_BLIT_ASYNC  0x5018
+#define RGA_FLUSH       0x5019
+#define RGA_GET_RESULT  0x501a
+#define RGA_GET_VERSION 0x501b
+
+#define RGA2_BLIT_SYNC   0x6017
+#define RGA2_BLIT_ASYNC  0x6018
+#define RGA2_FLUSH       0x6019
+#define RGA2_GET_RESULT  0x601a
+#define RGA2_GET_VERSION 0x601b
+#define RGA2_GET_VERSION 0x601b
+
+#define RGA_REG_CTRL_LEN    0x8    /* 8  */
+#define RGA_REG_CMD_LEN     0x1c   /* 28 */
+#define RGA_CMD_BUF_SIZE    0x700  /* 16*28*4 */
+
+#ifndef ENABLE
+#define ENABLE 1
+#endif
+
+#ifndef DISABLE
+#define DISABLE 0
+#endif
+
+/* RGA process mode enum */
+enum {
+    bitblt_mode               = 0x0,
+    color_palette_mode        = 0x1,
+    color_fill_mode           = 0x2,
+    line_point_drawing_mode   = 0x3,
+    blur_sharp_filter_mode    = 0x4,
+    pre_scaling_mode          = 0x5,
+    update_palette_table_mode = 0x6,
+    update_patten_buff_mode   = 0x7,
+};
+
+
+enum {
+    rop_enable_mask          = 0x2,
+    dither_enable_mask       = 0x8,
+    fading_enable_mask       = 0x10,
+    PD_enbale_mask           = 0x20,
+};
+
+enum {
+    yuv2rgb_mode0            = 0x0,     /* BT.601 MPEG */
+    yuv2rgb_mode1            = 0x1,     /* BT.601 JPEG */
+    yuv2rgb_mode2            = 0x2,     /* BT.709      */
+
+    rgb2yuv_601_full                = 0x1 << 8,
+    rgb2yuv_709_full                = 0x2 << 8,
+    yuv2yuv_601_limit_2_709_limit   = 0x3 << 8,
+    yuv2yuv_601_limit_2_709_full    = 0x4 << 8,
+    yuv2yuv_709_limit_2_601_limit   = 0x5 << 8,
+    yuv2yuv_709_limit_2_601_full    = 0x6 << 8,     //not support
+    yuv2yuv_601_full_2_709_limit    = 0x7 << 8,
+    yuv2yuv_601_full_2_709_full     = 0x8 << 8,     //not support
+    yuv2yuv_709_full_2_601_limit    = 0x9 << 8,     //not support
+    yuv2yuv_709_full_2_601_full     = 0xa << 8,     //not support
+    full_csc_mask = 0xf00,
+};
+
+/* RGA rotate mode */
+enum {
+    rotate_mode0             = 0x0,     /* no rotate */
+    rotate_mode1             = 0x1,     /* rotate    */
+    rotate_mode2             = 0x2,     /* x_mirror  */
+    rotate_mode3             = 0x3,     /* y_mirror  */
+};
+
+enum {
+    color_palette_mode0      = 0x0,     /* 1K */
+    color_palette_mode1      = 0x1,     /* 2K */
+    color_palette_mode2      = 0x2,     /* 4K */
+    color_palette_mode3      = 0x3,     /* 8K */
+};
+
+enum {
+    BB_BYPASS   = 0x0,     /* no rotate */
+    BB_ROTATE   = 0x1,     /* rotate    */
+    BB_X_MIRROR = 0x2,     /* x_mirror  */
+    BB_Y_MIRROR = 0x3      /* y_mirror  */
+};
+
+enum {
+    nearby   = 0x0,     /* no rotate */
+    bilinear = 0x1,     /* rotate    */
+    bicubic  = 0x2,     /* x_mirror  */
+};
+
+#define RGA_SCHED_PRIORITY_DEFAULT 0
+#define RGA_SCHED_PRIORITY_MAX 6
+
+enum {
+	RGA3_SCHEDULER_CORE0		= 1 << 0,
+	RGA3_SCHEDULER_CORE1		= 1 << 1,
+	RGA2_SCHEDULER_CORE0		= 1 << 2,
+};
+
+/*
+//          Alpha    Red     Green   Blue
+{  4, 32, {{32,24,   8, 0,  16, 8,  24,16 }}, GGL_RGBA },   // RK_FORMAT_RGBA_8888
+{  4, 24, {{ 0, 0,   8, 0,  16, 8,  24,16 }}, GGL_RGB  },   // RK_FORMAT_RGBX_8888
+{  3, 24, {{ 0, 0,   8, 0,  16, 8,  24,16 }}, GGL_RGB  },   // RK_FORMAT_RGB_888
+{  4, 32, {{32,24,  24,16,  16, 8,   8, 0 }}, GGL_BGRA },   // RK_FORMAT_BGRA_8888
+{  2, 16, {{ 0, 0,  16,11,  11, 5,   5, 0 }}, GGL_RGB  },   // RK_FORMAT_RGB_565
+{  2, 16, {{ 1, 0,  16,11,  11, 6,   6, 1 }}, GGL_RGBA },   // RK_FORMAT_RGBA_5551
+{  2, 16, {{ 4, 0,  16,12,  12, 8,   8, 4 }}, GGL_RGBA },   // RK_FORMAT_RGBA_4444
+{  3, 24, {{ 0, 0,  24,16,  16, 8,   8, 0 }}, GGL_BGR  },   // RK_FORMAT_BGB_888
+
+*/
+/* In order to be compatible with RK_FORMAT_XX and HAL_PIXEL_FORMAT_XX,
+ * RK_FORMAT_XX is shifted to the left by 8 bits to distinguish.  */
+typedef enum _Rga_SURF_FORMAT {
+    RK_FORMAT_RGBA_8888    = 0x0 << 8,
+    RK_FORMAT_RGBX_8888    = 0x1 << 8,
+    RK_FORMAT_RGB_888      = 0x2 << 8,
+    RK_FORMAT_BGRA_8888    = 0x3 << 8,
+    RK_FORMAT_RGB_565      = 0x4 << 8,
+    RK_FORMAT_RGBA_5551    = 0x5 << 8,
+    RK_FORMAT_RGBA_4444    = 0x6 << 8,
+    RK_FORMAT_BGR_888      = 0x7 << 8,
+
+    RK_FORMAT_YCbCr_422_SP = 0x8 << 8,
+    RK_FORMAT_YCbCr_422_P  = 0x9 << 8,
+    RK_FORMAT_YCbCr_420_SP = 0xa << 8,
+    RK_FORMAT_YCbCr_420_P  = 0xb << 8,
+
+    RK_FORMAT_YCrCb_422_SP = 0xc << 8,
+    RK_FORMAT_YCrCb_422_P  = 0xd << 8,
+    RK_FORMAT_YCrCb_420_SP = 0xe << 8,
+    RK_FORMAT_YCrCb_420_P  = 0xf << 8,
+
+    RK_FORMAT_BPP1         = 0x10 << 8,
+    RK_FORMAT_BPP2         = 0x11 << 8,
+    RK_FORMAT_BPP4         = 0x12 << 8,
+    RK_FORMAT_BPP8         = 0x13 << 8,
+
+    RK_FORMAT_Y4           = 0x14 << 8,
+    RK_FORMAT_YCbCr_400    = 0x15 << 8,
+
+    RK_FORMAT_BGRX_8888    = 0x16 << 8,
+
+    RK_FORMAT_YVYU_422     = 0x18 << 8,
+    RK_FORMAT_YVYU_420     = 0x19 << 8,
+    RK_FORMAT_VYUY_422     = 0x1a << 8,
+    RK_FORMAT_VYUY_420     = 0x1b << 8,
+    RK_FORMAT_YUYV_422     = 0x1c << 8,
+    RK_FORMAT_YUYV_420     = 0x1d << 8,
+    RK_FORMAT_UYVY_422     = 0x1e << 8,
+    RK_FORMAT_UYVY_420     = 0x1f << 8,
+
+    RK_FORMAT_YCbCr_420_SP_10B = 0x20 << 8,
+    RK_FORMAT_YCrCb_420_SP_10B = 0x21 << 8,
+    RK_FORMAT_YCbCr_422_10b_SP = 0x22 << 8,
+    RK_FORMAT_YCrCb_422_10b_SP = 0x23 << 8,
+
+    RK_FORMAT_BGR_565      = 0x24 << 8,
+    RK_FORMAT_BGRA_5551    = 0x25 << 8,
+    RK_FORMAT_BGRA_4444    = 0x26 << 8,
+
+    RK_FORMAT_ARGB_8888    = 0x28 << 8,
+    RK_FORMAT_XRGB_8888    = 0x29 << 8,
+    RK_FORMAT_ARGB_5551    = 0x2a << 8,
+    RK_FORMAT_ARGB_4444    = 0x2b << 8,
+    RK_FORMAT_ABGR_8888    = 0x2c << 8,
+    RK_FORMAT_XBGR_8888    = 0x2d << 8,
+    RK_FORMAT_ABGR_5551    = 0x2e << 8,
+    RK_FORMAT_ABGR_4444    = 0x2f << 8,
+
+    RK_FORMAT_UNKNOWN      = 0x100 << 8,
+} RgaSURF_FORMAT;
+
+/* RGA3 rd_mode */
+enum
+{
+    raster_mode             = 0x1 << 0,
+    afbc_mode               = 0x1 << 1,
+    tile_mode               = 0x1 << 2,
+};
+
+typedef struct rga_img_info_t {
+    uint64_t yrgb_addr;          /* yrgb    mem addr         */
+    uint64_t uv_addr;            /* cb/cr   mem addr         */
+    uint64_t v_addr;             /* cr      mem addr         */
+
+    uint32_t format;             //definition by RK_FORMAT
+    uint16_t act_w;
+    uint16_t act_h;
+    uint16_t x_offset;
+    uint16_t y_offset;
+
+    uint16_t vir_w;
+    uint16_t vir_h;
+
+    uint16_t endian_mode; //for BPP
+    uint16_t alpha_swap;
+
+	//used by RGA3
+	uint16_t rotate_mode;
+    uint16_t rd_mode;
+
+	uint16_t is_10b_compact;
+	uint16_t is_10b_endian;
+
+	uint16_t enable;
+}
+rga_img_info_t;
+
+typedef struct POINT {
+    uint16_t x;
+    uint16_t y;
+}
+POINT;
+
+typedef struct RECT {
+    uint16_t xmin;
+    uint16_t xmax; // width - 1
+    uint16_t ymin;
+    uint16_t ymax; // height - 1
+} RECT;
+
+typedef struct MMU {
+    uint8_t mmu_en;
+    uint64_t base_addr;
+    uint32_t mmu_flag;     /* [0] mmu enable [1] src_flush [2] dst_flush [3] CMD_flush [4~5] page size*/
+} MMU;
+
+typedef struct COLOR_FILL {
+    int16_t gr_x_a;
+    int16_t gr_y_a;
+    int16_t gr_x_b;
+    int16_t gr_y_b;
+    int16_t gr_x_g;
+    int16_t gr_y_g;
+    int16_t gr_x_r;
+    int16_t gr_y_r;
+    //u8  cp_gr_saturation;
+}
+COLOR_FILL;
+
+typedef struct FADING {
+    uint8_t b;
+    uint8_t g;
+    uint8_t r;
+    uint8_t res;
+}
+FADING;
+
+typedef struct line_draw_t {
+    POINT start_point;                  /* LineDraw_start_point                */
+    POINT end_point;                    /* LineDraw_end_point                  */
+    uint32_t   color;                   /* LineDraw_color                      */
+    uint32_t   flag;                    /* (enum) LineDrawing mode sel         */
+    uint32_t   line_width;              /* range 1~16 */
+}
+line_draw_t;
+
+/* color space convert coefficient. */
+typedef struct csc_coe_t {
+    int16_t r_v;
+    int16_t g_y;
+    int16_t b_u;
+    int32_t off;
+} csc_coe_t;
+
+typedef struct full_csc_t {
+    uint8_t flag;
+    csc_coe_t coe_y;
+    csc_coe_t coe_u;
+    csc_coe_t coe_v;
+} full_csc_t;
+
+struct rga_req {
+    uint8_t render_mode;                  /* (enum) process mode sel */
+
+    rga_img_info_t src;                   /* src image info */
+    rga_img_info_t dst;                   /* dst image info */
+    rga_img_info_t pat;                   /* patten image info */
+
+    uint64_t rop_mask_addr;               /* rop4 mask addr */
+    uint64_t LUT_addr;                    /* LUT addr */
+
+    RECT clip;                            /* dst clip window default value is dst_vir */
+                                          /* value from [0, w-1] / [0, h-1]*/
+
+    int32_t sina;                         /* dst angle  default value 0  16.16 scan from table */
+    int32_t cosa;                         /* dst angle  default value 0  16.16 scan from table */
+
+    uint16_t alpha_rop_flag;              /* alpha rop process flag           */
+                                          /* ([0] = 1 alpha_rop_enable)       */
+                                          /* ([1] = 1 rop enable)             */
+                                          /* ([2] = 1 fading_enable)          */
+                                          /* ([3] = 1 PD_enable)              */
+                                          /* ([4] = 1 alpha cal_mode_sel)     */
+                                          /* ([5] = 1 dither_enable)          */
+                                          /* ([6] = 1 gradient fill mode sel) */
+                                          /* ([7] = 1 AA_enable)              */
+                                          /* ([8] = 1 nn_quantize)            */
+                                          /* ([9] = 1 Real color mode)        */
+
+    uint8_t  scale_mode;                  /* 0 nearst / 1 bilnear / 2 bicubic */
+
+    uint32_t color_key_max;               /* color key max */
+    uint32_t color_key_min;               /* color key min */
+
+    uint32_t fg_color;                    /* foreground color */
+    uint32_t bg_color;                    /* background color */
+
+    COLOR_FILL gr_color;                  /* color fill use gradient */
+
+    line_draw_t line_draw_info;
+
+    FADING fading;
+
+    uint8_t PD_mode;                      /* porter duff alpha mode sel */
+
+    uint8_t alpha_global_value;           /* global alpha value */
+
+    uint16_t rop_code;                    /* rop2/3/4 code  scan from rop code table*/
+
+    uint8_t bsfilter_flag;                /* [2] 0 blur 1 sharp / [1:0] filter_type*/
+
+    uint8_t palette_mode;                 /* (enum) color palatte  0/1bpp, 1/2bpp 2/4bpp 3/8bpp*/
+
+    uint8_t yuv2rgb_mode;                 /* (enum) BT.601 MPEG / BT.601 JPEG / BT.709  */
+
+    uint8_t endian_mode;                  /* 0/big endian 1/little endian*/
+
+    uint8_t rotate_mode;                  /* (enum) rotate mode  */
+                                          /* 0x0,     no rotate  */
+                                          /* 0x1,     rotate     */
+                                          /* 0x2,     x_mirror   */
+                                          /* 0x3,     y_mirror   */
+
+    uint8_t color_fill_mode;              /* 0 solid color / 1 patten color */
+
+    MMU mmu_info;                         /* mmu information */
+
+    uint8_t  alpha_rop_mode;              /* ([0~1] alpha mode)       */
+                                          /* ([2~3] rop   mode)       */
+                                          /* ([4]   zero  mode en)    */
+                                          /* ([5]   dst   alpha mode) (RGA1) */
+
+    uint8_t  src_trans_mode;
+
+    uint8_t  dither_mode;
+
+    full_csc_t full_csc;                  /* full color space convert */
+
+	int32_t in_fence_fd;
+    uint8_t core;
+    uint8_t priority;
+    int32_t out_fence_fd;
+
+	uint8_t reservr[128];
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_RK29_IPP_DRIVER_H_*/
diff --git a/C++/yolo_bytetrack/3rdparty/rga/lib/librga.so b/C++/yolo_bytetrack/3rdparty/rga/lib/librga.so
new file mode 100644
index 00000000..152ebf37
Binary files /dev/null and b/C++/yolo_bytetrack/3rdparty/rga/lib/librga.so differ
diff --git a/C++/yolo_bytetrack/CMakeLists.txt b/C++/yolo_bytetrack/CMakeLists.txt
new file mode 100644
index 00000000..4002fff2
--- /dev/null
+++ b/C++/yolo_bytetrack/CMakeLists.txt
@@ -0,0 +1,64 @@
+cmake_minimum_required(VERSION 3.16.3)
+
+project(yolo_bytetrack)
+
+set(TOOLCHAIN_DIR /home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf) 
+set(CMAKE_CXX_COMPILER ${TOOLCHAIN_DIR}/bin/arm-linux-gnueabihf-g++)
+set(CMAKE_C_COMPILER ${TOOLCHAIN_DIR}/bin/arm-linux-gnueabihf-gcc)
+
+set(OpenCV_DIR /home/huey/opencv-4.7.0/install/lib/cmake/opencv4)
+find_package(OpenCV 4 REQUIRED)
+include_directories(${OpenCV_INCLUDE_DIRS})
+
+set(OPENSSL_ROOT_DIR /home/huey/openssl/install/include/)
+set(OPENSSL_SSL_LIBRARY /home/huey/openssl/install/lib/libssl.so)
+set(OPENSSL_CRYPTO_LIBRARY /home/huey/openssl/install/lib/libcrypto.so)
+set(pkgcfg_lib__OPENSSL_crypto /home/huey/openssl/install/lib/libcrypto.so)
+set(pkgcfg_lib__OPENSSL_ssl /home/huey/openssl/install/lib/libssl.so)
+
+find_package(OpenSSL REQUIRED)
+include_directories(${OPENSSL_INCLUDE_DIR})
+
+set(CURL_INCLUDE_DIRS /home/huey/curl-8.8.0/install/include)
+set(CURL_LIBRARIES /home/huey/curl-8.8.0/install/lib/libcurl.a)
+
+
+set(CMAKE_INSTALL_PREFIX ${CMAKE_SOURCE_DIR}/install/rknn_yolov5_1109_new_${CMAKE_SYSTEM_NAME})
+
+set(CMAKE_SKIP_INSTALL_RPATH FALSE)
+set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+
+set(
+  include_libs
+  "${PROJECT_SOURCE_DIR}/include"
+  ${PROJECT_SOURCE_DIR}/3rdparty/librknn_api/include
+  ${PROJECT_SOURCE_DIR}/3rdparty/rga/include
+)
+
+include_directories(${include_libs})
+
+add_executable(yolo_bytetrack
+	src/bytetrack.cpp
+	src/BYTETracker.cpp
+	src/kalmanFilter.cpp
+  src/lapjv.cpp
+  src/STrack.cpp
+  src/utils.cpp
+)
+set(
+  link_libs pthread
+  ${PROJECT_SOURCE_DIR}/3rdparty/librknn_api/armhf/librknn_api.so
+  ${PROJECT_SOURCE_DIR}/3rdparty/rga/lib/librga.so
+)
+
+target_include_directories(yolo_bytetrack PRIVATE ${CURL_INCLUDE_DIRS})
+
+
+target_link_libraries(yolo_bytetrack
+  ${OpenCV_LIBS}
+  ${OPENSSL_LIBRARIES}
+  ${CURL_LIBRARIES}
+  ${link_libs}
+)
+
diff --git a/C++/yolo_bytetrack/build/CMakeCache.txt b/C++/yolo_bytetrack/build/CMakeCache.txt
new file mode 100644
index 00000000..ecedcb2d
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeCache.txt
@@ -0,0 +1,420 @@
+# This is the CMakeCache file.
+# For build in directory: /home/huey/Desktop/C/yolo_bytetrack/build
+# It was generated by CMake: /usr/bin/cmake
+# You can edit this file to change values found and used by cmake.
+# If you do not want to change any of the values, simply exit the editor.
+# If you do want to change a value, simply edit, save, and exit the editor.
+# The syntax for the file is as follows:
+# KEY:TYPE=VALUE
+# KEY is the name of a variable in the cache.
+# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
+# VALUE is the current value for the KEY.
+
+########################
+# EXTERNAL cache entries
+########################
+
+//Path to a program.
+CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line
+
+//Path to a program.
+CMAKE_AR:FILEPATH=/usr/bin/ar
+
+//Choose the type of build, options are: None Debug Release RelWithDebInfo
+// MinSizeRel ...
+CMAKE_BUILD_TYPE:STRING=
+
+//Enable/Disable color output during build.
+CMAKE_COLOR_MAKEFILE:BOOL=ON
+
+//CXX compiler
+CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++
+
+//A wrapper around 'ar' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_CXX_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar-9
+
+//A wrapper around 'ranlib' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-9
+
+//Flags used by the CXX compiler during all build types.
+CMAKE_CXX_FLAGS:STRING=
+
+//Flags used by the CXX compiler during DEBUG builds.
+CMAKE_CXX_FLAGS_DEBUG:STRING=-g
+
+//Flags used by the CXX compiler during MINSIZEREL builds.
+CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
+
+//Flags used by the CXX compiler during RELEASE builds.
+CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
+
+//Flags used by the CXX compiler during RELWITHDEBINFO builds.
+CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
+
+//C compiler
+CMAKE_C_COMPILER:FILEPATH=/usr/bin/cc
+
+//A wrapper around 'ar' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_C_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar-9
+
+//A wrapper around 'ranlib' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_C_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-9
+
+//Flags used by the C compiler during all build types.
+CMAKE_C_FLAGS:STRING=
+
+//Flags used by the C compiler during DEBUG builds.
+CMAKE_C_FLAGS_DEBUG:STRING=-g
+
+//Flags used by the C compiler during MINSIZEREL builds.
+CMAKE_C_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
+
+//Flags used by the C compiler during RELEASE builds.
+CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
+
+//Flags used by the C compiler during RELWITHDEBINFO builds.
+CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
+
+//Path to a program.
+CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND
+
+//Flags used by the linker during all build types.
+CMAKE_EXE_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during DEBUG builds.
+CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during MINSIZEREL builds.
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during RELEASE builds.
+CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during RELWITHDEBINFO builds.
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Enable/Disable output of compile commands during generation.
+CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=OFF
+
+//Install path prefix, prepended onto install directories.
+CMAKE_INSTALL_PREFIX:PATH=/usr/local
+
+//Path to a program.
+CMAKE_LINKER:FILEPATH=/usr/bin/ld
+
+//Path to a program.
+CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/make
+
+//Flags used by the linker during the creation of modules during
+// all build types.
+CMAKE_MODULE_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of modules during
+// DEBUG builds.
+CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of modules during
+// MINSIZEREL builds.
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of modules during
+// RELEASE builds.
+CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of modules during
+// RELWITHDEBINFO builds.
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Path to a program.
+CMAKE_NM:FILEPATH=/usr/bin/nm
+
+//Path to a program.
+CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy
+
+//Path to a program.
+CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump
+
+//Value Computed by CMake
+CMAKE_PROJECT_DESCRIPTION:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_HOMEPAGE_URL:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_NAME:STATIC=yolo_bytetrack
+
+//Path to a program.
+CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib
+
+//Path to a program.
+CMAKE_READELF:FILEPATH=/usr/bin/readelf
+
+//Flags used by the linker during the creation of shared libraries
+// during all build types.
+CMAKE_SHARED_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during DEBUG builds.
+CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during MINSIZEREL builds.
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during RELEASE builds.
+CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during RELWITHDEBINFO builds.
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//If set, runtime paths are not added when installing shared libraries,
+// but are added when building.
+CMAKE_SKIP_INSTALL_RPATH:BOOL=NO
+
+//If set, runtime paths are not added when using shared libraries.
+CMAKE_SKIP_RPATH:BOOL=NO
+
+//Flags used by the linker during the creation of static libraries
+// during all build types.
+CMAKE_STATIC_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during DEBUG builds.
+CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during MINSIZEREL builds.
+CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during RELEASE builds.
+CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during RELWITHDEBINFO builds.
+CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Path to a program.
+CMAKE_STRIP:FILEPATH=/usr/bin/strip
+
+//If this value is on, makefiles will be generated without the
+// .SILENT directive, and all commands will be echoed to the console
+// during the make.  This is useful for debugging only. With Visual
+// Studio IDE projects all commands are done without /nologo.
+CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE
+
+//Path to a file.
+OPENSSL_INCLUDE_DIR:PATH=/home/huey/openssl/install/include
+
+//pkg-config executable
+PKG_CONFIG_EXECUTABLE:FILEPATH=/usr/bin/pkg-config
+
+//Value Computed by CMake
+yolo_bytetrack_BINARY_DIR:STATIC=/home/huey/Desktop/C/yolo_bytetrack/build
+
+//Value Computed by CMake
+yolo_bytetrack_SOURCE_DIR:STATIC=/home/huey/Desktop/C/yolo_bytetrack
+
+
+########################
+# INTERNAL cache entries
+########################
+
+//ADVANCED property for variable: CMAKE_ADDR2LINE
+CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_AR
+CMAKE_AR-ADVANCED:INTERNAL=1
+//This is the directory where this CMakeCache.txt was created
+CMAKE_CACHEFILE_DIR:INTERNAL=/home/huey/Desktop/C/yolo_bytetrack/build
+//Major version of cmake used to create the current loaded cache
+CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3
+//Minor version of cmake used to create the current loaded cache
+CMAKE_CACHE_MINOR_VERSION:INTERNAL=16
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=3
+//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
+CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/usr/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest
+//ADVANCED property for variable: CMAKE_CXX_COMPILER
+CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR
+CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB
+CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS
+CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG
+CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL
+CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE
+CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO
+CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER
+CMAKE_C_COMPILER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER_AR
+CMAKE_C_COMPILER_AR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER_RANLIB
+CMAKE_C_COMPILER_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS
+CMAKE_C_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG
+CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL
+CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE
+CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO
+CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_DLLTOOL
+CMAKE_DLLTOOL-ADVANCED:INTERNAL=1
+//Path to cache edit program executable.
+CMAKE_EDIT_COMMAND:INTERNAL=/usr/bin/cmake-gui
+//Executable file format
+CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS
+CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG
+CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE
+CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS
+CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1
+//Name of external makefile project generator.
+CMAKE_EXTRA_GENERATOR:INTERNAL=
+//Name of generator.
+CMAKE_GENERATOR:INTERNAL=Unix Makefiles
+//Generator instance identifier.
+CMAKE_GENERATOR_INSTANCE:INTERNAL=
+//Name of generator platform.
+CMAKE_GENERATOR_PLATFORM:INTERNAL=
+//Name of generator toolset.
+CMAKE_GENERATOR_TOOLSET:INTERNAL=
+//Source directory with the top level CMakeLists.txt file for this
+// project
+CMAKE_HOME_DIRECTORY:INTERNAL=/home/huey/Desktop/C/yolo_bytetrack
+//Install .so files without execute permission.
+CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1
+//ADVANCED property for variable: CMAKE_LINKER
+CMAKE_LINKER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MAKE_PROGRAM
+CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS
+CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG
+CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE
+CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_NM
+CMAKE_NM-ADVANCED:INTERNAL=1
+//number of local generators
+CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1
+//ADVANCED property for variable: CMAKE_OBJCOPY
+CMAKE_OBJCOPY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_OBJDUMP
+CMAKE_OBJDUMP-ADVANCED:INTERNAL=1
+//Platform information initialized
+CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_RANLIB
+CMAKE_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_READELF
+CMAKE_READELF-ADVANCED:INTERNAL=1
+//Path to CMake installation.
+CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.16
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS
+CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG
+CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE
+CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH
+CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_RPATH
+CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS
+CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG
+CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL
+CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE
+CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STRIP
+CMAKE_STRIP-ADVANCED:INTERNAL=1
+//uname command
+CMAKE_UNAME:INTERNAL=/usr/bin/uname
+//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
+CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
+//Details about finding OpenCV
+FIND_PACKAGE_MESSAGE_DETAILS_OpenCV:INTERNAL=[/home/huey/opencv-4.7.0/install][v4.7.0(4)]
+//Details about finding OpenSSL
+FIND_PACKAGE_MESSAGE_DETAILS_OpenSSL:INTERNAL=[/home/huey/openssl/install/lib/libcrypto.so][/home/huey/openssl/install/include][c ][v()]
+//ADVANCED property for variable: OPENSSL_INCLUDE_DIR
+OPENSSL_INCLUDE_DIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: PKG_CONFIG_EXECUTABLE
+PKG_CONFIG_EXECUTABLE-ADVANCED:INTERNAL=1
+_OPENSSL_CFLAGS:INTERNAL=
+_OPENSSL_CFLAGS_I:INTERNAL=
+_OPENSSL_CFLAGS_OTHER:INTERNAL=
+_OPENSSL_FOUND:INTERNAL=1
+_OPENSSL_INCLUDEDIR:INTERNAL=/usr/include
+_OPENSSL_INCLUDE_DIRS:INTERNAL=
+_OPENSSL_LDFLAGS:INTERNAL=-lssl;-lcrypto
+_OPENSSL_LDFLAGS_OTHER:INTERNAL=
+_OPENSSL_LIBDIR:INTERNAL=/usr/lib/x86_64-linux-gnu
+_OPENSSL_LIBRARIES:INTERNAL=ssl;crypto
+_OPENSSL_LIBRARY_DIRS:INTERNAL=
+_OPENSSL_LIBS:INTERNAL=
+_OPENSSL_LIBS_L:INTERNAL=
+_OPENSSL_LIBS_OTHER:INTERNAL=
+_OPENSSL_LIBS_PATHS:INTERNAL=
+_OPENSSL_MODULE_NAME:INTERNAL=openssl
+_OPENSSL_PREFIX:INTERNAL=/usr
+_OPENSSL_STATIC_CFLAGS:INTERNAL=
+_OPENSSL_STATIC_CFLAGS_I:INTERNAL=
+_OPENSSL_STATIC_CFLAGS_OTHER:INTERNAL=
+_OPENSSL_STATIC_INCLUDE_DIRS:INTERNAL=
+_OPENSSL_STATIC_LDFLAGS:INTERNAL=-lssl;-lcrypto;-ldl;-pthread
+_OPENSSL_STATIC_LDFLAGS_OTHER:INTERNAL=-pthread
+_OPENSSL_STATIC_LIBDIR:INTERNAL=
+_OPENSSL_STATIC_LIBRARIES:INTERNAL=ssl;crypto;dl
+_OPENSSL_STATIC_LIBRARY_DIRS:INTERNAL=
+_OPENSSL_STATIC_LIBS:INTERNAL=
+_OPENSSL_STATIC_LIBS_L:INTERNAL=
+_OPENSSL_STATIC_LIBS_OTHER:INTERNAL=
+_OPENSSL_STATIC_LIBS_PATHS:INTERNAL=
+_OPENSSL_VERSION:INTERNAL=1.1.1f
+_OPENSSL_openssl_INCLUDEDIR:INTERNAL=
+_OPENSSL_openssl_LIBDIR:INTERNAL=
+_OPENSSL_openssl_PREFIX:INTERNAL=
+_OPENSSL_openssl_VERSION:INTERNAL=
+__pkg_config_arguments__OPENSSL:INTERNAL=QUIET;openssl
+__pkg_config_checked__OPENSSL:INTERNAL=1
+prefix_result:INTERNAL=/usr/lib/x86_64-linux-gnu
+
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeCCompiler.cmake b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeCCompiler.cmake
new file mode 100644
index 00000000..c5ece7b8
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeCCompiler.cmake
@@ -0,0 +1,76 @@
+set(CMAKE_C_COMPILER "/usr/bin/cc")
+set(CMAKE_C_COMPILER_ARG1 "")
+set(CMAKE_C_COMPILER_ID "GNU")
+set(CMAKE_C_COMPILER_VERSION "9.4.0")
+set(CMAKE_C_COMPILER_VERSION_INTERNAL "")
+set(CMAKE_C_COMPILER_WRAPPER "")
+set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "11")
+set(CMAKE_C_COMPILE_FEATURES "c_std_90;c_function_prototypes;c_std_99;c_restrict;c_variadic_macros;c_std_11;c_static_assert")
+set(CMAKE_C90_COMPILE_FEATURES "c_std_90;c_function_prototypes")
+set(CMAKE_C99_COMPILE_FEATURES "c_std_99;c_restrict;c_variadic_macros")
+set(CMAKE_C11_COMPILE_FEATURES "c_std_11;c_static_assert")
+
+set(CMAKE_C_PLATFORM_ID "Linux")
+set(CMAKE_C_SIMULATE_ID "")
+set(CMAKE_C_COMPILER_FRONTEND_VARIANT "")
+set(CMAKE_C_SIMULATE_VERSION "")
+
+
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_C_COMPILER_AR "/usr/bin/gcc-ar-9")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_C_COMPILER_RANLIB "/usr/bin/gcc-ranlib-9")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_MT "")
+set(CMAKE_COMPILER_IS_GNUCC 1)
+set(CMAKE_C_COMPILER_LOADED 1)
+set(CMAKE_C_COMPILER_WORKS TRUE)
+set(CMAKE_C_ABI_COMPILED TRUE)
+set(CMAKE_COMPILER_IS_MINGW )
+set(CMAKE_COMPILER_IS_CYGWIN )
+if(CMAKE_COMPILER_IS_CYGWIN)
+  set(CYGWIN 1)
+  set(UNIX 1)
+endif()
+
+set(CMAKE_C_COMPILER_ENV_VAR "CC")
+
+if(CMAKE_COMPILER_IS_MINGW)
+  set(MINGW 1)
+endif()
+set(CMAKE_C_COMPILER_ID_RUN 1)
+set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m)
+set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_C_LINKER_PREFERENCE 10)
+
+# Save compiler ABI information.
+set(CMAKE_C_SIZEOF_DATA_PTR "8")
+set(CMAKE_C_COMPILER_ABI "ELF")
+set(CMAKE_C_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+
+if(CMAKE_C_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_C_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
+endif()
+
+if(CMAKE_C_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+endif()
+
+set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "")
+if(CMAKE_C_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+
+
+
+
+set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/9/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include")
+set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "gcc;gcc_s;c;gcc;gcc_s")
+set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/9;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib")
+set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake
new file mode 100644
index 00000000..278ef39e
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake
@@ -0,0 +1,88 @@
+set(CMAKE_CXX_COMPILER "/usr/bin/c++")
+set(CMAKE_CXX_COMPILER_ARG1 "")
+set(CMAKE_CXX_COMPILER_ID "GNU")
+set(CMAKE_CXX_COMPILER_VERSION "9.4.0")
+set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "")
+set(CMAKE_CXX_COMPILER_WRAPPER "")
+set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14")
+set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20")
+set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters")
+set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates")
+set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates")
+set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17")
+set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20")
+
+set(CMAKE_CXX_PLATFORM_ID "Linux")
+set(CMAKE_CXX_SIMULATE_ID "")
+set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "")
+set(CMAKE_CXX_SIMULATE_VERSION "")
+
+
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar-9")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib-9")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_MT "")
+set(CMAKE_COMPILER_IS_GNUCXX 1)
+set(CMAKE_CXX_COMPILER_LOADED 1)
+set(CMAKE_CXX_COMPILER_WORKS TRUE)
+set(CMAKE_CXX_ABI_COMPILED TRUE)
+set(CMAKE_COMPILER_IS_MINGW )
+set(CMAKE_COMPILER_IS_CYGWIN )
+if(CMAKE_COMPILER_IS_CYGWIN)
+  set(CYGWIN 1)
+  set(UNIX 1)
+endif()
+
+set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
+
+if(CMAKE_COMPILER_IS_MINGW)
+  set(MINGW 1)
+endif()
+set(CMAKE_CXX_COMPILER_ID_RUN 1)
+set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;CPP)
+set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
+
+foreach (lang C OBJC OBJCXX)
+  if (CMAKE_${lang}_COMPILER_ID_RUN)
+    foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS)
+      list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension})
+    endforeach()
+  endif()
+endforeach()
+
+set(CMAKE_CXX_LINKER_PREFERENCE 30)
+set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1)
+
+# Save compiler ABI information.
+set(CMAKE_CXX_SIZEOF_DATA_PTR "8")
+set(CMAKE_CXX_COMPILER_ABI "ELF")
+set(CMAKE_CXX_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+
+if(CMAKE_CXX_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_CXX_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
+endif()
+
+if(CMAKE_CXX_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+endif()
+
+set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "")
+if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+
+
+
+
+set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/usr/include/c++/9;/usr/include/x86_64-linux-gnu/c++/9;/usr/include/c++/9/backward;/usr/lib/gcc/x86_64-linux-gnu/9/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include")
+set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc")
+set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/9;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib")
+set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_C.bin b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_C.bin
new file mode 100644
index 00000000..b7a0b099
Binary files /dev/null and b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_C.bin differ
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin
new file mode 100644
index 00000000..a9f2f4fc
Binary files /dev/null and b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin differ
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeSystem.cmake b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeSystem.cmake
new file mode 100644
index 00000000..b6b39409
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CMakeSystem.cmake
@@ -0,0 +1,15 @@
+set(CMAKE_HOST_SYSTEM "Linux-5.15.0-113-generic")
+set(CMAKE_HOST_SYSTEM_NAME "Linux")
+set(CMAKE_HOST_SYSTEM_VERSION "5.15.0-113-generic")
+set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+
+
+
+set(CMAKE_SYSTEM "Linux-5.15.0-113-generic")
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_VERSION "5.15.0-113-generic")
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+
+set(CMAKE_CROSSCOMPILING "FALSE")
+
+set(CMAKE_SYSTEM_LOADED 1)
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdC/CMakeCCompilerId.c b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdC/CMakeCCompilerId.c
new file mode 100644
index 00000000..d884b509
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdC/CMakeCCompilerId.c
@@ -0,0 +1,671 @@
+#ifdef __cplusplus
+# error "A C++ compiler has been selected for C."
+#endif
+
+#if defined(__18CXX)
+# define ID_VOID_MAIN
+#endif
+#if defined(__CLASSIC_C__)
+/* cv-qualifiers did not exist in K&R C */
+# define const
+# define volatile
+#endif
+
+
+/* Version number components: V=Version, R=Revision, P=Patch
+   Version date components:   YYYY=Year, MM=Month,   DD=Day  */
+
+#if defined(__INTEL_COMPILER) || defined(__ICC)
+# define COMPILER_ID "Intel"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_ID "GNU"
+# endif
+  /* __INTEL_COMPILER = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
+# if defined(__INTEL_COMPILER_UPDATE)
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
+# else
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)
+# endif
+# if defined(__INTEL_COMPILER_BUILD_DATE)
+  /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
+#  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
+# endif
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+# elif defined(__GNUG__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(__PATHCC__)
+# define COMPILER_ID "PathScale"
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+
+#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
+# define COMPILER_ID "Embarcadero"
+# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
+# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
+# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__     & 0xFFFF)
+
+#elif defined(__BORLANDC__)
+# define COMPILER_ID "Borland"
+  /* __BORLANDC__ = 0xVRR */
+# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
+# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
+
+#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
+# define COMPILER_ID "Watcom"
+   /* __WATCOMC__ = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__WATCOMC__)
+# define COMPILER_ID "OpenWatcom"
+   /* __WATCOMC__ = VVRP + 1100 */
+# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__SUNPRO_C)
+# define COMPILER_ID "SunPro"
+# if __SUNPRO_C >= 0x5100
+   /* __SUNPRO_C = 0xVRRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_C    & 0xF)
+# else
+   /* __SUNPRO_CC = 0xVRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_C    & 0xF)
+# endif
+
+#elif defined(__HP_cc)
+# define COMPILER_ID "HP"
+  /* __HP_cc = VVRRPP */
+# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000)
+# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__HP_cc     % 100)
+
+#elif defined(__DECC)
+# define COMPILER_ID "Compaq"
+  /* __DECC_VER = VVRRTPPPP */
+# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000)
+# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000  % 100)
+# define COMPILER_VERSION_PATCH DEC(__DECC_VER         % 10000)
+
+#elif defined(__IBMC__) && defined(__COMPILER_VER__)
+# define COMPILER_ID "zOS"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__ibmxl__) && defined(__clang__)
+# define COMPILER_ID "XLClang"
+# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
+# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
+# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
+
+
+#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800
+# define COMPILER_ID "XL"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800
+# define COMPILER_ID "VisualAge"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__PGI)
+# define COMPILER_ID "PGI"
+# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
+# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
+# if defined(__PGIC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
+# endif
+
+#elif defined(_CRAYC)
+# define COMPILER_ID "Cray"
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
+
+#elif defined(__TI_COMPILER_VERSION__)
+# define COMPILER_ID "TI"
+  /* __TI_COMPILER_VERSION__ = VVVRRRPPP */
+# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
+# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000   % 1000)
+# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__        % 1000)
+
+#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)
+# define COMPILER_ID "Fujitsu"
+
+#elif defined(__ghs__)
+# define COMPILER_ID "GHS"
+/* __GHS_VERSION_NUMBER = VVVVRP */
+# ifdef __GHS_VERSION_NUMBER
+# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
+# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER      % 10)
+# endif
+
+#elif defined(__TINYC__)
+# define COMPILER_ID "TinyCC"
+
+#elif defined(__BCC__)
+# define COMPILER_ID "Bruce"
+
+#elif defined(__SCO_VERSION__)
+# define COMPILER_ID "SCO"
+
+#elif defined(__ARMCC_VERSION) && !defined(__clang__)
+# define COMPILER_ID "ARMCC"
+#if __ARMCC_VERSION >= 1000000
+  /* __ARMCC_VERSION = VRRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION     % 10000)
+#else
+  /* __ARMCC_VERSION = VRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION    % 10000)
+#endif
+
+
+#elif defined(__clang__) && defined(__apple_build_version__)
+# define COMPILER_ID "AppleClang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
+
+#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
+# define COMPILER_ID "ARMClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION     % 10000)
+# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
+
+#elif defined(__clang__)
+# define COMPILER_ID "Clang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+
+#elif defined(__GNUC__)
+# define COMPILER_ID "GNU"
+# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
+# if defined(__GNUC_MINOR__)
+#  define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(_MSC_VER)
+# define COMPILER_ID "MSVC"
+  /* _MSC_VER = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
+# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
+# if defined(_MSC_FULL_VER)
+#  if _MSC_VER >= 1400
+    /* _MSC_FULL_VER = VVRRPPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
+#  else
+    /* _MSC_FULL_VER = VVRRPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
+#  endif
+# endif
+# if defined(_MSC_BUILD)
+#  define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
+# endif
+
+#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
+# define COMPILER_ID "ADSP"
+#if defined(__VISUALDSPVERSION__)
+  /* __VISUALDSPVERSION__ = 0xVVRRPP00 */
+# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
+# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
+# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8  & 0xFF)
+#endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# define COMPILER_ID "IAR"
+# if defined(__VER__) && defined(__ICCARM__)
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
+#  define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
+#  define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__))
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
+#  define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
+#  define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# endif
+
+#elif defined(__SDCC_VERSION_MAJOR) || defined(SDCC)
+# define COMPILER_ID "SDCC"
+# if defined(__SDCC_VERSION_MAJOR)
+#  define COMPILER_VERSION_MAJOR DEC(__SDCC_VERSION_MAJOR)
+#  define COMPILER_VERSION_MINOR DEC(__SDCC_VERSION_MINOR)
+#  define COMPILER_VERSION_PATCH DEC(__SDCC_VERSION_PATCH)
+# else
+  /* SDCC = VRP */
+#  define COMPILER_VERSION_MAJOR DEC(SDCC/100)
+#  define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10)
+#  define COMPILER_VERSION_PATCH DEC(SDCC    % 10)
+# endif
+
+
+/* These compilers are either not known or too old to define an
+  identification macro.  Try to identify the platform and guess that
+  it is the native compiler.  */
+#elif defined(__hpux) || defined(__hpua)
+# define COMPILER_ID "HP"
+
+#else /* unknown compiler */
+# define COMPILER_ID ""
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
+#ifdef SIMULATE_ID
+char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
+#endif
+
+#ifdef __QNXNTO__
+char const* qnxnto = "INFO" ":" "qnxnto[]";
+#endif
+
+#if defined(__CRAYXE) || defined(__CRAYXC)
+char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
+#endif
+
+#define STRINGIFY_HELPER(X) #X
+#define STRINGIFY(X) STRINGIFY_HELPER(X)
+
+/* Identify known platforms by name.  */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+# define PLATFORM_ID "Linux"
+
+#elif defined(__CYGWIN__)
+# define PLATFORM_ID "Cygwin"
+
+#elif defined(__MINGW32__)
+# define PLATFORM_ID "MinGW"
+
+#elif defined(__APPLE__)
+# define PLATFORM_ID "Darwin"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+# define PLATFORM_ID "Windows"
+
+#elif defined(__FreeBSD__) || defined(__FreeBSD)
+# define PLATFORM_ID "FreeBSD"
+
+#elif defined(__NetBSD__) || defined(__NetBSD)
+# define PLATFORM_ID "NetBSD"
+
+#elif defined(__OpenBSD__) || defined(__OPENBSD)
+# define PLATFORM_ID "OpenBSD"
+
+#elif defined(__sun) || defined(sun)
+# define PLATFORM_ID "SunOS"
+
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+# define PLATFORM_ID "AIX"
+
+#elif defined(__hpux) || defined(__hpux__)
+# define PLATFORM_ID "HP-UX"
+
+#elif defined(__HAIKU__)
+# define PLATFORM_ID "Haiku"
+
+#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
+# define PLATFORM_ID "BeOS"
+
+#elif defined(__QNX__) || defined(__QNXNTO__)
+# define PLATFORM_ID "QNX"
+
+#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
+# define PLATFORM_ID "Tru64"
+
+#elif defined(__riscos) || defined(__riscos__)
+# define PLATFORM_ID "RISCos"
+
+#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
+# define PLATFORM_ID "SINIX"
+
+#elif defined(__UNIX_SV__)
+# define PLATFORM_ID "UNIX_SV"
+
+#elif defined(__bsdos__)
+# define PLATFORM_ID "BSDOS"
+
+#elif defined(_MPRAS) || defined(MPRAS)
+# define PLATFORM_ID "MP-RAS"
+
+#elif defined(__osf) || defined(__osf__)
+# define PLATFORM_ID "OSF1"
+
+#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
+# define PLATFORM_ID "SCO_SV"
+
+#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
+# define PLATFORM_ID "ULTRIX"
+
+#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
+# define PLATFORM_ID "Xenix"
+
+#elif defined(__WATCOMC__)
+# if defined(__LINUX__)
+#  define PLATFORM_ID "Linux"
+
+# elif defined(__DOS__)
+#  define PLATFORM_ID "DOS"
+
+# elif defined(__OS2__)
+#  define PLATFORM_ID "OS2"
+
+# elif defined(__WINDOWS__)
+#  define PLATFORM_ID "Windows3x"
+
+# else /* unknown platform */
+#  define PLATFORM_ID
+# endif
+
+#elif defined(__INTEGRITY)
+# if defined(INT_178B)
+#  define PLATFORM_ID "Integrity178"
+
+# else /* regular Integrity */
+#  define PLATFORM_ID "Integrity"
+# endif
+
+#else /* unknown platform */
+# define PLATFORM_ID
+
+#endif
+
+/* For windows compilers MSVC and Intel we can determine
+   the architecture of the compiler being used.  This is because
+   the compilers do not have flags that can change the architecture,
+   but rather depend on which compiler is being used
+*/
+#if defined(_WIN32) && defined(_MSC_VER)
+# if defined(_M_IA64)
+#  define ARCHITECTURE_ID "IA64"
+
+# elif defined(_M_X64) || defined(_M_AMD64)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# elif defined(_M_ARM64)
+#  define ARCHITECTURE_ID "ARM64"
+
+# elif defined(_M_ARM)
+#  if _M_ARM == 4
+#   define ARCHITECTURE_ID "ARMV4I"
+#  elif _M_ARM == 5
+#   define ARCHITECTURE_ID "ARMV5I"
+#  else
+#   define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
+#  endif
+
+# elif defined(_M_MIPS)
+#  define ARCHITECTURE_ID "MIPS"
+
+# elif defined(_M_SH)
+#  define ARCHITECTURE_ID "SHx"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__WATCOMC__)
+# if defined(_M_I86)
+#  define ARCHITECTURE_ID "I86"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# if defined(__ICCARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__ICCRX__)
+#  define ARCHITECTURE_ID "RX"
+
+# elif defined(__ICCRH850__)
+#  define ARCHITECTURE_ID "RH850"
+
+# elif defined(__ICCRL78__)
+#  define ARCHITECTURE_ID "RL78"
+
+# elif defined(__ICCRISCV__)
+#  define ARCHITECTURE_ID "RISCV"
+
+# elif defined(__ICCAVR__)
+#  define ARCHITECTURE_ID "AVR"
+
+# elif defined(__ICC430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# elif defined(__ICCV850__)
+#  define ARCHITECTURE_ID "V850"
+
+# elif defined(__ICC8051__)
+#  define ARCHITECTURE_ID "8051"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__ghs__)
+# if defined(__PPC64__)
+#  define ARCHITECTURE_ID "PPC64"
+
+# elif defined(__ppc__)
+#  define ARCHITECTURE_ID "PPC"
+
+# elif defined(__ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__x86_64__)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(__i386__)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+#else
+#  define ARCHITECTURE_ID
+#endif
+
+/* Convert integer to decimal digit literals.  */
+#define DEC(n)                   \
+  ('0' + (((n) / 10000000)%10)), \
+  ('0' + (((n) / 1000000)%10)),  \
+  ('0' + (((n) / 100000)%10)),   \
+  ('0' + (((n) / 10000)%10)),    \
+  ('0' + (((n) / 1000)%10)),     \
+  ('0' + (((n) / 100)%10)),      \
+  ('0' + (((n) / 10)%10)),       \
+  ('0' +  ((n) % 10))
+
+/* Convert integer to hex digit literals.  */
+#define HEX(n)             \
+  ('0' + ((n)>>28 & 0xF)), \
+  ('0' + ((n)>>24 & 0xF)), \
+  ('0' + ((n)>>20 & 0xF)), \
+  ('0' + ((n)>>16 & 0xF)), \
+  ('0' + ((n)>>12 & 0xF)), \
+  ('0' + ((n)>>8  & 0xF)), \
+  ('0' + ((n)>>4  & 0xF)), \
+  ('0' + ((n)     & 0xF))
+
+/* Construct a string literal encoding the version number components. */
+#ifdef COMPILER_VERSION_MAJOR
+char const info_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
+  COMPILER_VERSION_MAJOR,
+# ifdef COMPILER_VERSION_MINOR
+  '.', COMPILER_VERSION_MINOR,
+#  ifdef COMPILER_VERSION_PATCH
+   '.', COMPILER_VERSION_PATCH,
+#   ifdef COMPILER_VERSION_TWEAK
+    '.', COMPILER_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct a string literal encoding the internal version number. */
+#ifdef COMPILER_VERSION_INTERNAL
+char const info_version_internal[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
+  'i','n','t','e','r','n','a','l','[',
+  COMPILER_VERSION_INTERNAL,']','\0'};
+#endif
+
+/* Construct a string literal encoding the version number components. */
+#ifdef SIMULATE_VERSION_MAJOR
+char const info_simulate_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
+  SIMULATE_VERSION_MAJOR,
+# ifdef SIMULATE_VERSION_MINOR
+  '.', SIMULATE_VERSION_MINOR,
+#  ifdef SIMULATE_VERSION_PATCH
+   '.', SIMULATE_VERSION_PATCH,
+#   ifdef SIMULATE_VERSION_TWEAK
+    '.', SIMULATE_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
+char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
+
+
+
+
+#if !defined(__STDC__)
+# if (defined(_MSC_VER) && !defined(__clang__)) \
+  || (defined(__ibmxl__) || defined(__IBMC__))
+#  define C_DIALECT "90"
+# else
+#  define C_DIALECT
+# endif
+#elif __STDC_VERSION__ >= 201000L
+# define C_DIALECT "11"
+#elif __STDC_VERSION__ >= 199901L
+# define C_DIALECT "99"
+#else
+# define C_DIALECT "90"
+#endif
+const char* info_language_dialect_default =
+  "INFO" ":" "dialect_default[" C_DIALECT "]";
+
+/*--------------------------------------------------------------------------*/
+
+#ifdef ID_VOID_MAIN
+void main() {}
+#else
+# if defined(__CLASSIC_C__)
+int main(argc, argv) int argc; char *argv[];
+# else
+int main(int argc, char* argv[])
+# endif
+{
+  int require = 0;
+  require += info_compiler[argc];
+  require += info_platform[argc];
+  require += info_arch[argc];
+#ifdef COMPILER_VERSION_MAJOR
+  require += info_version[argc];
+#endif
+#ifdef COMPILER_VERSION_INTERNAL
+  require += info_version_internal[argc];
+#endif
+#ifdef SIMULATE_ID
+  require += info_simulate[argc];
+#endif
+#ifdef SIMULATE_VERSION_MAJOR
+  require += info_simulate_version[argc];
+#endif
+#if defined(__CRAYXE) || defined(__CRAYXC)
+  require += info_cray[argc];
+#endif
+  require += info_language_dialect_default[argc];
+  (void)argv;
+  return require;
+}
+#endif
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdC/a.out b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdC/a.out
new file mode 100644
index 00000000..b5c91a37
Binary files /dev/null and b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdC/a.out differ
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp
new file mode 100644
index 00000000..69cfdba6
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp
@@ -0,0 +1,660 @@
+/* This source file must have a .cpp extension so that all C++ compilers
+   recognize the extension without flags.  Borland does not know .cxx for
+   example.  */
+#ifndef __cplusplus
+# error "A C compiler has been selected for C++."
+#endif
+
+
+/* Version number components: V=Version, R=Revision, P=Patch
+   Version date components:   YYYY=Year, MM=Month,   DD=Day  */
+
+#if defined(__COMO__)
+# define COMPILER_ID "Comeau"
+  /* __COMO_VERSION__ = VRR */
+# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100)
+# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100)
+
+#elif defined(__INTEL_COMPILER) || defined(__ICC)
+# define COMPILER_ID "Intel"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_ID "GNU"
+# endif
+  /* __INTEL_COMPILER = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
+# if defined(__INTEL_COMPILER_UPDATE)
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
+# else
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)
+# endif
+# if defined(__INTEL_COMPILER_BUILD_DATE)
+  /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
+#  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
+# endif
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+# elif defined(__GNUG__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(__PATHCC__)
+# define COMPILER_ID "PathScale"
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+
+#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
+# define COMPILER_ID "Embarcadero"
+# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
+# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
+# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__     & 0xFFFF)
+
+#elif defined(__BORLANDC__)
+# define COMPILER_ID "Borland"
+  /* __BORLANDC__ = 0xVRR */
+# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
+# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
+
+#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
+# define COMPILER_ID "Watcom"
+   /* __WATCOMC__ = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__WATCOMC__)
+# define COMPILER_ID "OpenWatcom"
+   /* __WATCOMC__ = VVRP + 1100 */
+# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__SUNPRO_CC)
+# define COMPILER_ID "SunPro"
+# if __SUNPRO_CC >= 0x5100
+   /* __SUNPRO_CC = 0xVRRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC    & 0xF)
+# else
+   /* __SUNPRO_CC = 0xVRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC    & 0xF)
+# endif
+
+#elif defined(__HP_aCC)
+# define COMPILER_ID "HP"
+  /* __HP_aCC = VVRRPP */
+# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000)
+# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__HP_aCC     % 100)
+
+#elif defined(__DECCXX)
+# define COMPILER_ID "Compaq"
+  /* __DECCXX_VER = VVRRTPPPP */
+# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000)
+# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000  % 100)
+# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER         % 10000)
+
+#elif defined(__IBMCPP__) && defined(__COMPILER_VER__)
+# define COMPILER_ID "zOS"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__ibmxl__) && defined(__clang__)
+# define COMPILER_ID "XLClang"
+# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
+# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
+# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
+
+
+#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800
+# define COMPILER_ID "XL"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800
+# define COMPILER_ID "VisualAge"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__PGI)
+# define COMPILER_ID "PGI"
+# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
+# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
+# if defined(__PGIC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
+# endif
+
+#elif defined(_CRAYC)
+# define COMPILER_ID "Cray"
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
+
+#elif defined(__TI_COMPILER_VERSION__)
+# define COMPILER_ID "TI"
+  /* __TI_COMPILER_VERSION__ = VVVRRRPPP */
+# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
+# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000   % 1000)
+# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__        % 1000)
+
+#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)
+# define COMPILER_ID "Fujitsu"
+
+#elif defined(__ghs__)
+# define COMPILER_ID "GHS"
+/* __GHS_VERSION_NUMBER = VVVVRP */
+# ifdef __GHS_VERSION_NUMBER
+# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
+# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER      % 10)
+# endif
+
+#elif defined(__SCO_VERSION__)
+# define COMPILER_ID "SCO"
+
+#elif defined(__ARMCC_VERSION) && !defined(__clang__)
+# define COMPILER_ID "ARMCC"
+#if __ARMCC_VERSION >= 1000000
+  /* __ARMCC_VERSION = VRRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION     % 10000)
+#else
+  /* __ARMCC_VERSION = VRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION    % 10000)
+#endif
+
+
+#elif defined(__clang__) && defined(__apple_build_version__)
+# define COMPILER_ID "AppleClang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
+
+#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
+# define COMPILER_ID "ARMClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION     % 10000)
+# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
+
+#elif defined(__clang__)
+# define COMPILER_ID "Clang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+
+#elif defined(__GNUC__) || defined(__GNUG__)
+# define COMPILER_ID "GNU"
+# if defined(__GNUC__)
+#  define COMPILER_VERSION_MAJOR DEC(__GNUC__)
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(_MSC_VER)
+# define COMPILER_ID "MSVC"
+  /* _MSC_VER = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
+# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
+# if defined(_MSC_FULL_VER)
+#  if _MSC_VER >= 1400
+    /* _MSC_FULL_VER = VVRRPPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
+#  else
+    /* _MSC_FULL_VER = VVRRPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
+#  endif
+# endif
+# if defined(_MSC_BUILD)
+#  define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
+# endif
+
+#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
+# define COMPILER_ID "ADSP"
+#if defined(__VISUALDSPVERSION__)
+  /* __VISUALDSPVERSION__ = 0xVVRRPP00 */
+# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
+# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
+# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8  & 0xFF)
+#endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# define COMPILER_ID "IAR"
+# if defined(__VER__) && defined(__ICCARM__)
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
+#  define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
+#  define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__))
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
+#  define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
+#  define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# endif
+
+
+/* These compilers are either not known or too old to define an
+  identification macro.  Try to identify the platform and guess that
+  it is the native compiler.  */
+#elif defined(__hpux) || defined(__hpua)
+# define COMPILER_ID "HP"
+
+#else /* unknown compiler */
+# define COMPILER_ID ""
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
+#ifdef SIMULATE_ID
+char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
+#endif
+
+#ifdef __QNXNTO__
+char const* qnxnto = "INFO" ":" "qnxnto[]";
+#endif
+
+#if defined(__CRAYXE) || defined(__CRAYXC)
+char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
+#endif
+
+#define STRINGIFY_HELPER(X) #X
+#define STRINGIFY(X) STRINGIFY_HELPER(X)
+
+/* Identify known platforms by name.  */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+# define PLATFORM_ID "Linux"
+
+#elif defined(__CYGWIN__)
+# define PLATFORM_ID "Cygwin"
+
+#elif defined(__MINGW32__)
+# define PLATFORM_ID "MinGW"
+
+#elif defined(__APPLE__)
+# define PLATFORM_ID "Darwin"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+# define PLATFORM_ID "Windows"
+
+#elif defined(__FreeBSD__) || defined(__FreeBSD)
+# define PLATFORM_ID "FreeBSD"
+
+#elif defined(__NetBSD__) || defined(__NetBSD)
+# define PLATFORM_ID "NetBSD"
+
+#elif defined(__OpenBSD__) || defined(__OPENBSD)
+# define PLATFORM_ID "OpenBSD"
+
+#elif defined(__sun) || defined(sun)
+# define PLATFORM_ID "SunOS"
+
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+# define PLATFORM_ID "AIX"
+
+#elif defined(__hpux) || defined(__hpux__)
+# define PLATFORM_ID "HP-UX"
+
+#elif defined(__HAIKU__)
+# define PLATFORM_ID "Haiku"
+
+#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
+# define PLATFORM_ID "BeOS"
+
+#elif defined(__QNX__) || defined(__QNXNTO__)
+# define PLATFORM_ID "QNX"
+
+#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
+# define PLATFORM_ID "Tru64"
+
+#elif defined(__riscos) || defined(__riscos__)
+# define PLATFORM_ID "RISCos"
+
+#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
+# define PLATFORM_ID "SINIX"
+
+#elif defined(__UNIX_SV__)
+# define PLATFORM_ID "UNIX_SV"
+
+#elif defined(__bsdos__)
+# define PLATFORM_ID "BSDOS"
+
+#elif defined(_MPRAS) || defined(MPRAS)
+# define PLATFORM_ID "MP-RAS"
+
+#elif defined(__osf) || defined(__osf__)
+# define PLATFORM_ID "OSF1"
+
+#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
+# define PLATFORM_ID "SCO_SV"
+
+#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
+# define PLATFORM_ID "ULTRIX"
+
+#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
+# define PLATFORM_ID "Xenix"
+
+#elif defined(__WATCOMC__)
+# if defined(__LINUX__)
+#  define PLATFORM_ID "Linux"
+
+# elif defined(__DOS__)
+#  define PLATFORM_ID "DOS"
+
+# elif defined(__OS2__)
+#  define PLATFORM_ID "OS2"
+
+# elif defined(__WINDOWS__)
+#  define PLATFORM_ID "Windows3x"
+
+# else /* unknown platform */
+#  define PLATFORM_ID
+# endif
+
+#elif defined(__INTEGRITY)
+# if defined(INT_178B)
+#  define PLATFORM_ID "Integrity178"
+
+# else /* regular Integrity */
+#  define PLATFORM_ID "Integrity"
+# endif
+
+#else /* unknown platform */
+# define PLATFORM_ID
+
+#endif
+
+/* For windows compilers MSVC and Intel we can determine
+   the architecture of the compiler being used.  This is because
+   the compilers do not have flags that can change the architecture,
+   but rather depend on which compiler is being used
+*/
+#if defined(_WIN32) && defined(_MSC_VER)
+# if defined(_M_IA64)
+#  define ARCHITECTURE_ID "IA64"
+
+# elif defined(_M_X64) || defined(_M_AMD64)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# elif defined(_M_ARM64)
+#  define ARCHITECTURE_ID "ARM64"
+
+# elif defined(_M_ARM)
+#  if _M_ARM == 4
+#   define ARCHITECTURE_ID "ARMV4I"
+#  elif _M_ARM == 5
+#   define ARCHITECTURE_ID "ARMV5I"
+#  else
+#   define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
+#  endif
+
+# elif defined(_M_MIPS)
+#  define ARCHITECTURE_ID "MIPS"
+
+# elif defined(_M_SH)
+#  define ARCHITECTURE_ID "SHx"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__WATCOMC__)
+# if defined(_M_I86)
+#  define ARCHITECTURE_ID "I86"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# if defined(__ICCARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__ICCRX__)
+#  define ARCHITECTURE_ID "RX"
+
+# elif defined(__ICCRH850__)
+#  define ARCHITECTURE_ID "RH850"
+
+# elif defined(__ICCRL78__)
+#  define ARCHITECTURE_ID "RL78"
+
+# elif defined(__ICCRISCV__)
+#  define ARCHITECTURE_ID "RISCV"
+
+# elif defined(__ICCAVR__)
+#  define ARCHITECTURE_ID "AVR"
+
+# elif defined(__ICC430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# elif defined(__ICCV850__)
+#  define ARCHITECTURE_ID "V850"
+
+# elif defined(__ICC8051__)
+#  define ARCHITECTURE_ID "8051"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__ghs__)
+# if defined(__PPC64__)
+#  define ARCHITECTURE_ID "PPC64"
+
+# elif defined(__ppc__)
+#  define ARCHITECTURE_ID "PPC"
+
+# elif defined(__ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__x86_64__)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(__i386__)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+#else
+#  define ARCHITECTURE_ID
+#endif
+
+/* Convert integer to decimal digit literals.  */
+#define DEC(n)                   \
+  ('0' + (((n) / 10000000)%10)), \
+  ('0' + (((n) / 1000000)%10)),  \
+  ('0' + (((n) / 100000)%10)),   \
+  ('0' + (((n) / 10000)%10)),    \
+  ('0' + (((n) / 1000)%10)),     \
+  ('0' + (((n) / 100)%10)),      \
+  ('0' + (((n) / 10)%10)),       \
+  ('0' +  ((n) % 10))
+
+/* Convert integer to hex digit literals.  */
+#define HEX(n)             \
+  ('0' + ((n)>>28 & 0xF)), \
+  ('0' + ((n)>>24 & 0xF)), \
+  ('0' + ((n)>>20 & 0xF)), \
+  ('0' + ((n)>>16 & 0xF)), \
+  ('0' + ((n)>>12 & 0xF)), \
+  ('0' + ((n)>>8  & 0xF)), \
+  ('0' + ((n)>>4  & 0xF)), \
+  ('0' + ((n)     & 0xF))
+
+/* Construct a string literal encoding the version number components. */
+#ifdef COMPILER_VERSION_MAJOR
+char const info_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
+  COMPILER_VERSION_MAJOR,
+# ifdef COMPILER_VERSION_MINOR
+  '.', COMPILER_VERSION_MINOR,
+#  ifdef COMPILER_VERSION_PATCH
+   '.', COMPILER_VERSION_PATCH,
+#   ifdef COMPILER_VERSION_TWEAK
+    '.', COMPILER_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct a string literal encoding the internal version number. */
+#ifdef COMPILER_VERSION_INTERNAL
+char const info_version_internal[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
+  'i','n','t','e','r','n','a','l','[',
+  COMPILER_VERSION_INTERNAL,']','\0'};
+#endif
+
+/* Construct a string literal encoding the version number components. */
+#ifdef SIMULATE_VERSION_MAJOR
+char const info_simulate_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
+  SIMULATE_VERSION_MAJOR,
+# ifdef SIMULATE_VERSION_MINOR
+  '.', SIMULATE_VERSION_MINOR,
+#  ifdef SIMULATE_VERSION_PATCH
+   '.', SIMULATE_VERSION_PATCH,
+#   ifdef SIMULATE_VERSION_TWEAK
+    '.', SIMULATE_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
+char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
+
+
+
+
+#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) && _MSVC_LANG < 201403L
+#  if defined(__INTEL_CXX11_MODE__)
+#    if defined(__cpp_aggregate_nsdmi)
+#      define CXX_STD 201402L
+#    else
+#      define CXX_STD 201103L
+#    endif
+#  else
+#    define CXX_STD 199711L
+#  endif
+#elif defined(_MSC_VER) && defined(_MSVC_LANG)
+#  define CXX_STD _MSVC_LANG
+#else
+#  define CXX_STD __cplusplus
+#endif
+
+const char* info_language_dialect_default = "INFO" ":" "dialect_default["
+#if CXX_STD > 201703L
+  "20"
+#elif CXX_STD >= 201703L
+  "17"
+#elif CXX_STD >= 201402L
+  "14"
+#elif CXX_STD >= 201103L
+  "11"
+#else
+  "98"
+#endif
+"]";
+
+/*--------------------------------------------------------------------------*/
+
+int main(int argc, char* argv[])
+{
+  int require = 0;
+  require += info_compiler[argc];
+  require += info_platform[argc];
+#ifdef COMPILER_VERSION_MAJOR
+  require += info_version[argc];
+#endif
+#ifdef COMPILER_VERSION_INTERNAL
+  require += info_version_internal[argc];
+#endif
+#ifdef SIMULATE_ID
+  require += info_simulate[argc];
+#endif
+#ifdef SIMULATE_VERSION_MAJOR
+  require += info_simulate_version[argc];
+#endif
+#if defined(__CRAYXE) || defined(__CRAYXC)
+  require += info_cray[argc];
+#endif
+  require += info_language_dialect_default[argc];
+  (void)argv;
+  return require;
+}
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out
new file mode 100644
index 00000000..2881803f
Binary files /dev/null and b/C++/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out differ
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/CMakeDirectoryInformation.cmake b/C++/yolo_bytetrack/build/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 00000000..4f5aa321
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/huey/Desktop/C/yolo_bytetrack")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/huey/Desktop/C/yolo_bytetrack/build")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/CMakeOutput.log b/C++/yolo_bytetrack/build/CMakeFiles/CMakeOutput.log
new file mode 100644
index 00000000..2543eb7c
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/CMakeOutput.log
@@ -0,0 +1,461 @@
+The system is: Linux - 5.15.0-113-generic - x86_64
+Compiling the C compiler identification source file "CMakeCCompilerId.c" succeeded.
+Compiler: /usr/bin/cc 
+Build flags: 
+Id flags:  
+
+The output was:
+0
+
+
+Compilation of the C compiler identification source "CMakeCCompilerId.c" produced "a.out"
+
+The C compiler identification is GNU, found in "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdC/a.out"
+
+Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded.
+Compiler: /usr/bin/c++ 
+Build flags: 
+Id flags:  
+
+The output was:
+0
+
+
+Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out"
+
+The CXX compiler identification is GNU, found in "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out"
+
+Determining if the C compiler works passed with the following output:
+Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp
+
+Run Build Command(s):/usr/bin/make cmTC_89148/fast && /usr/bin/make -f CMakeFiles/cmTC_89148.dir/build.make CMakeFiles/cmTC_89148.dir/build
+make[1]: 进入目录“/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp”
+Building C object CMakeFiles/cmTC_89148.dir/testCCompiler.c.o
+/usr/bin/cc    -o CMakeFiles/cmTC_89148.dir/testCCompiler.c.o   -c /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp/testCCompiler.c
+Linking C executable cmTC_89148
+/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_89148.dir/link.txt --verbose=1
+/usr/bin/cc      CMakeFiles/cmTC_89148.dir/testCCompiler.c.o  -o cmTC_89148 
+make[1]: 离开目录“/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp”
+
+
+
+Detecting C compiler ABI info compiled with the following output:
+Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp
+
+Run Build Command(s):/usr/bin/make cmTC_1d136/fast && /usr/bin/make -f CMakeFiles/cmTC_1d136.dir/build.make CMakeFiles/cmTC_1d136.dir/build
+make[1]: Entering directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp'
+Building C object CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o
+/usr/bin/cc   -v -o CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o   -c /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c
+Using built-in specs.
+COLLECT_GCC=/usr/bin/cc
+OFFLOAD_TARGET_NAMES=nvptx-none:hsa
+OFFLOAD_TARGET_DEFAULT=1
+Target: x86_64-linux-gnu
+Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
+Thread model: posix
+gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) 
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64'
+ /usr/lib/gcc/x86_64-linux-gnu/9/cc1 -quiet -v -imultiarch x86_64-linux-gnu /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c -quiet -dumpbase CMakeCCompilerABI.c -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccu0FvqW.s
+GNU C17 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)
+	compiled by GNU C version 9.4.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.22.1-GMP
+
+GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
+ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"
+ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"
+#include "..." search starts here:
+#include <...> search starts here:
+ /usr/lib/gcc/x86_64-linux-gnu/9/include
+ /usr/local/include
+ /usr/include/x86_64-linux-gnu
+ /usr/include
+End of search list.
+GNU C17 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)
+	compiled by GNU C version 9.4.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.22.1-GMP
+
+GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+Compiler executable checksum: 01da938ff5dc2163489aa33cb3b747a7
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64'
+ as -v --64 -o CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o /tmp/ccu0FvqW.s
+GNU assembler version 2.34 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.34
+COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/
+LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64'
+Linking C executable cmTC_1d136
+/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_1d136.dir/link.txt --verbose=1
+/usr/bin/cc     -v CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o  -o cmTC_1d136 
+Using built-in specs.
+COLLECT_GCC=/usr/bin/cc
+COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper
+OFFLOAD_TARGET_NAMES=nvptx-none:hsa
+OFFLOAD_TARGET_DEFAULT=1
+Target: x86_64-linux-gnu
+Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
+Thread model: posix
+gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) 
+COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/
+LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/
+COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_1d136' '-mtune=generic' '-march=x86-64'
+ /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=/tmp/ccQ6bl9Q.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_1d136 /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o
+COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_1d136' '-mtune=generic' '-march=x86-64'
+make[1]: Leaving directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp'
+
+
+
+Parsed C implicit include dir info from above output: rv=done
+  found start of include info
+  found start of implicit include info
+    add: [/usr/lib/gcc/x86_64-linux-gnu/9/include]
+    add: [/usr/local/include]
+    add: [/usr/include/x86_64-linux-gnu]
+    add: [/usr/include]
+  end of search list found
+  collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/9/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/9/include]
+  collapse include dir [/usr/local/include] ==> [/usr/local/include]
+  collapse include dir [/usr/include/x86_64-linux-gnu] ==> [/usr/include/x86_64-linux-gnu]
+  collapse include dir [/usr/include] ==> [/usr/include]
+  implicit include dirs: [/usr/lib/gcc/x86_64-linux-gnu/9/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include]
+
+
+Parsed C implicit link information from above output:
+  link line regex: [^( *|.*[/\])(ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\]+-)?ld|collect2)[^/\]*( |$)]
+  ignore line: [Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp]
+  ignore line: []
+  ignore line: [Run Build Command(s):/usr/bin/make cmTC_1d136/fast && /usr/bin/make -f CMakeFiles/cmTC_1d136.dir/build.make CMakeFiles/cmTC_1d136.dir/build]
+  ignore line: [make[1]: Entering directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp']
+  ignore line: [Building C object CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o]
+  ignore line: [/usr/bin/cc   -v -o CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o   -c /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c]
+  ignore line: [Using built-in specs.]
+  ignore line: [COLLECT_GCC=/usr/bin/cc]
+  ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:hsa]
+  ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+  ignore line: [Target: x86_64-linux-gnu]
+  ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu]
+  ignore line: [Thread model: posix]
+  ignore line: [gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) ]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64']
+  ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/9/cc1 -quiet -v -imultiarch x86_64-linux-gnu /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c -quiet -dumpbase CMakeCCompilerABI.c -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccu0FvqW.s]
+  ignore line: [GNU C17 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)]
+  ignore line: [	compiled by GNU C version 9.4.0  GMP version 6.2.0  MPFR version 4.0.2  MPC version 1.1.0  isl version isl-0.22.1-GMP]
+  ignore line: []
+  ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+  ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"]
+  ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"]
+  ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"]
+  ignore line: [#include "..." search starts here:]
+  ignore line: [#include <...> search starts here:]
+  ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/9/include]
+  ignore line: [ /usr/local/include]
+  ignore line: [ /usr/include/x86_64-linux-gnu]
+  ignore line: [ /usr/include]
+  ignore line: [End of search list.]
+  ignore line: [GNU C17 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)]
+  ignore line: [	compiled by GNU C version 9.4.0  GMP version 6.2.0  MPFR version 4.0.2  MPC version 1.1.0  isl version isl-0.22.1-GMP]
+  ignore line: []
+  ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+  ignore line: [Compiler executable checksum: 01da938ff5dc2163489aa33cb3b747a7]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64']
+  ignore line: [ as -v --64 -o CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o /tmp/ccu0FvqW.s]
+  ignore line: [GNU assembler version 2.34 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.34]
+  ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/]
+  ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64']
+  ignore line: [Linking C executable cmTC_1d136]
+  ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_1d136.dir/link.txt --verbose=1]
+  ignore line: [/usr/bin/cc     -v CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o  -o cmTC_1d136 ]
+  ignore line: [Using built-in specs.]
+  ignore line: [COLLECT_GCC=/usr/bin/cc]
+  ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper]
+  ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:hsa]
+  ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+  ignore line: [Target: x86_64-linux-gnu]
+  ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu]
+  ignore line: [Thread model: posix]
+  ignore line: [gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) ]
+  ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/]
+  ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_1d136' '-mtune=generic' '-march=x86-64']
+  link line: [ /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=/tmp/ccQ6bl9Q.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_1d136 /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o]
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/collect2] ==> ignore
+    arg [-plugin] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so] ==> ignore
+    arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper] ==> ignore
+    arg [-plugin-opt=-fresolution=/tmp/ccQ6bl9Q.res] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+    arg [-plugin-opt=-pass-through=-lc] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+    arg [--build-id] ==> ignore
+    arg [--eh-frame-hdr] ==> ignore
+    arg [-m] ==> ignore
+    arg [elf_x86_64] ==> ignore
+    arg [--hash-style=gnu] ==> ignore
+    arg [--as-needed] ==> ignore
+    arg [-dynamic-linker] ==> ignore
+    arg [/lib64/ld-linux-x86-64.so.2] ==> ignore
+    arg [-pie] ==> ignore
+    arg [-znow] ==> ignore
+    arg [-zrelro] ==> ignore
+    arg [-o] ==> ignore
+    arg [cmTC_1d136] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o] ==> ignore
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib]
+    arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu]
+    arg [-L/lib/../lib] ==> dir [/lib/../lib]
+    arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu]
+    arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../..]
+    arg [CMakeFiles/cmTC_1d136.dir/CMakeCCompilerABI.c.o] ==> ignore
+    arg [-lgcc] ==> lib [gcc]
+    arg [--push-state] ==> ignore
+    arg [--as-needed] ==> ignore
+    arg [-lgcc_s] ==> lib [gcc_s]
+    arg [--pop-state] ==> ignore
+    arg [-lc] ==> lib [c]
+    arg [-lgcc] ==> lib [gcc]
+    arg [--push-state] ==> ignore
+    arg [--as-needed] ==> ignore
+    arg [-lgcc_s] ==> lib [gcc_s]
+    arg [--pop-state] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o] ==> ignore
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9] ==> [/usr/lib/gcc/x86_64-linux-gnu/9]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib] ==> [/usr/lib]
+  collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu]
+  collapse library dir [/lib/../lib] ==> [/lib]
+  collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu]
+  collapse library dir [/usr/lib/../lib] ==> [/usr/lib]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../..] ==> [/usr/lib]
+  implicit libs: [gcc;gcc_s;c;gcc;gcc_s]
+  implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/9;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib]
+  implicit fwks: []
+
+
+Determining if the CXX compiler works passed with the following output:
+Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp
+
+Run Build Command(s):/usr/bin/make cmTC_150a3/fast && /usr/bin/make -f CMakeFiles/cmTC_150a3.dir/build.make CMakeFiles/cmTC_150a3.dir/build
+make[1]: 进入目录“/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp”
+Building CXX object CMakeFiles/cmTC_150a3.dir/testCXXCompiler.cxx.o
+/usr/bin/c++     -o CMakeFiles/cmTC_150a3.dir/testCXXCompiler.cxx.o -c /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp/testCXXCompiler.cxx
+Linking CXX executable cmTC_150a3
+/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_150a3.dir/link.txt --verbose=1
+/usr/bin/c++       CMakeFiles/cmTC_150a3.dir/testCXXCompiler.cxx.o  -o cmTC_150a3 
+make[1]: 离开目录“/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp”
+
+
+
+Detecting CXX compiler ABI info compiled with the following output:
+Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp
+
+Run Build Command(s):/usr/bin/make cmTC_7e483/fast && /usr/bin/make -f CMakeFiles/cmTC_7e483.dir/build.make CMakeFiles/cmTC_7e483.dir/build
+make[1]: Entering directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp'
+Building CXX object CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o
+/usr/bin/c++    -v -o CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp
+Using built-in specs.
+COLLECT_GCC=/usr/bin/c++
+OFFLOAD_TARGET_NAMES=nvptx-none:hsa
+OFFLOAD_TARGET_DEFAULT=1
+Target: x86_64-linux-gnu
+Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
+Thread model: posix
+gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) 
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+ /usr/lib/gcc/x86_64-linux-gnu/9/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccSGmaFU.s
+GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)
+	compiled by GNU C version 9.4.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.22.1-GMP
+
+GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/9"
+ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
+ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"
+ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"
+#include "..." search starts here:
+#include <...> search starts here:
+ /usr/include/c++/9
+ /usr/include/x86_64-linux-gnu/c++/9
+ /usr/include/c++/9/backward
+ /usr/lib/gcc/x86_64-linux-gnu/9/include
+ /usr/local/include
+ /usr/include/x86_64-linux-gnu
+ /usr/include
+End of search list.
+GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)
+	compiled by GNU C version 9.4.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.22.1-GMP
+
+GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+Compiler executable checksum: 3d1eba838554fa2348dba760e4770469
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+ as -v --64 -o CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccSGmaFU.s
+GNU assembler version 2.34 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.34
+COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/
+LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+Linking CXX executable cmTC_7e483
+/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_7e483.dir/link.txt --verbose=1
+/usr/bin/c++      -v CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o  -o cmTC_7e483 
+Using built-in specs.
+COLLECT_GCC=/usr/bin/c++
+COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper
+OFFLOAD_TARGET_NAMES=nvptx-none:hsa
+OFFLOAD_TARGET_DEFAULT=1
+Target: x86_64-linux-gnu
+Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
+Thread model: posix
+gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) 
+COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/
+LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/
+COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_7e483' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+ /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=/tmp/ccUWwGvq.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_7e483 /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o
+COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_7e483' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+make[1]: Leaving directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp'
+
+
+
+Parsed CXX implicit include dir info from above output: rv=done
+  found start of include info
+  found start of implicit include info
+    add: [/usr/include/c++/9]
+    add: [/usr/include/x86_64-linux-gnu/c++/9]
+    add: [/usr/include/c++/9/backward]
+    add: [/usr/lib/gcc/x86_64-linux-gnu/9/include]
+    add: [/usr/local/include]
+    add: [/usr/include/x86_64-linux-gnu]
+    add: [/usr/include]
+  end of search list found
+  collapse include dir [/usr/include/c++/9] ==> [/usr/include/c++/9]
+  collapse include dir [/usr/include/x86_64-linux-gnu/c++/9] ==> [/usr/include/x86_64-linux-gnu/c++/9]
+  collapse include dir [/usr/include/c++/9/backward] ==> [/usr/include/c++/9/backward]
+  collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/9/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/9/include]
+  collapse include dir [/usr/local/include] ==> [/usr/local/include]
+  collapse include dir [/usr/include/x86_64-linux-gnu] ==> [/usr/include/x86_64-linux-gnu]
+  collapse include dir [/usr/include] ==> [/usr/include]
+  implicit include dirs: [/usr/include/c++/9;/usr/include/x86_64-linux-gnu/c++/9;/usr/include/c++/9/backward;/usr/lib/gcc/x86_64-linux-gnu/9/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include]
+
+
+Parsed CXX implicit link information from above output:
+  link line regex: [^( *|.*[/\])(ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\]+-)?ld|collect2)[^/\]*( |$)]
+  ignore line: [Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp]
+  ignore line: []
+  ignore line: [Run Build Command(s):/usr/bin/make cmTC_7e483/fast && /usr/bin/make -f CMakeFiles/cmTC_7e483.dir/build.make CMakeFiles/cmTC_7e483.dir/build]
+  ignore line: [make[1]: Entering directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp']
+  ignore line: [Building CXX object CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o]
+  ignore line: [/usr/bin/c++    -v -o CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp]
+  ignore line: [Using built-in specs.]
+  ignore line: [COLLECT_GCC=/usr/bin/c++]
+  ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:hsa]
+  ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+  ignore line: [Target: x86_64-linux-gnu]
+  ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu]
+  ignore line: [Thread model: posix]
+  ignore line: [gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) ]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+  ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/9/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccSGmaFU.s]
+  ignore line: [GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)]
+  ignore line: [	compiled by GNU C version 9.4.0  GMP version 6.2.0  MPFR version 4.0.2  MPC version 1.1.0  isl version isl-0.22.1-GMP]
+  ignore line: []
+  ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+  ignore line: [ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/9"]
+  ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"]
+  ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"]
+  ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"]
+  ignore line: [#include "..." search starts here:]
+  ignore line: [#include <...> search starts here:]
+  ignore line: [ /usr/include/c++/9]
+  ignore line: [ /usr/include/x86_64-linux-gnu/c++/9]
+  ignore line: [ /usr/include/c++/9/backward]
+  ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/9/include]
+  ignore line: [ /usr/local/include]
+  ignore line: [ /usr/include/x86_64-linux-gnu]
+  ignore line: [ /usr/include]
+  ignore line: [End of search list.]
+  ignore line: [GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)]
+  ignore line: [	compiled by GNU C version 9.4.0  GMP version 6.2.0  MPFR version 4.0.2  MPC version 1.1.0  isl version isl-0.22.1-GMP]
+  ignore line: []
+  ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+  ignore line: [Compiler executable checksum: 3d1eba838554fa2348dba760e4770469]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+  ignore line: [ as -v --64 -o CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccSGmaFU.s]
+  ignore line: [GNU assembler version 2.34 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.34]
+  ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/]
+  ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+  ignore line: [Linking CXX executable cmTC_7e483]
+  ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_7e483.dir/link.txt --verbose=1]
+  ignore line: [/usr/bin/c++      -v CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o  -o cmTC_7e483 ]
+  ignore line: [Using built-in specs.]
+  ignore line: [COLLECT_GCC=/usr/bin/c++]
+  ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper]
+  ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:hsa]
+  ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+  ignore line: [Target: x86_64-linux-gnu]
+  ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu]
+  ignore line: [Thread model: posix]
+  ignore line: [gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) ]
+  ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/]
+  ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_7e483' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+  link line: [ /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=/tmp/ccUWwGvq.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_7e483 /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o]
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/collect2] ==> ignore
+    arg [-plugin] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so] ==> ignore
+    arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper] ==> ignore
+    arg [-plugin-opt=-fresolution=/tmp/ccUWwGvq.res] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+    arg [-plugin-opt=-pass-through=-lc] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+    arg [--build-id] ==> ignore
+    arg [--eh-frame-hdr] ==> ignore
+    arg [-m] ==> ignore
+    arg [elf_x86_64] ==> ignore
+    arg [--hash-style=gnu] ==> ignore
+    arg [--as-needed] ==> ignore
+    arg [-dynamic-linker] ==> ignore
+    arg [/lib64/ld-linux-x86-64.so.2] ==> ignore
+    arg [-pie] ==> ignore
+    arg [-znow] ==> ignore
+    arg [-zrelro] ==> ignore
+    arg [-o] ==> ignore
+    arg [cmTC_7e483] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o] ==> ignore
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib]
+    arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu]
+    arg [-L/lib/../lib] ==> dir [/lib/../lib]
+    arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu]
+    arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../..]
+    arg [CMakeFiles/cmTC_7e483.dir/CMakeCXXCompilerABI.cpp.o] ==> ignore
+    arg [-lstdc++] ==> lib [stdc++]
+    arg [-lm] ==> lib [m]
+    arg [-lgcc_s] ==> lib [gcc_s]
+    arg [-lgcc] ==> lib [gcc]
+    arg [-lc] ==> lib [c]
+    arg [-lgcc_s] ==> lib [gcc_s]
+    arg [-lgcc] ==> lib [gcc]
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o] ==> ignore
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9] ==> [/usr/lib/gcc/x86_64-linux-gnu/9]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib] ==> [/usr/lib]
+  collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu]
+  collapse library dir [/lib/../lib] ==> [/lib]
+  collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu]
+  collapse library dir [/usr/lib/../lib] ==> [/usr/lib]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../..] ==> [/usr/lib]
+  implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc]
+  implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/9;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib]
+  implicit fwks: []
+
+
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/Makefile.cmake b/C++/yolo_bytetrack/build/CMakeFiles/Makefile.cmake
new file mode 100644
index 00000000..6f41072f
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/Makefile.cmake
@@ -0,0 +1,128 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# The generator used is:
+set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles")
+
+# The top level Makefile was generated from the following files:
+set(CMAKE_MAKEFILE_DEPENDS
+  "CMakeCache.txt"
+  "../CMakeLists.txt"
+  "CMakeFiles/3.16.3/CMakeCCompiler.cmake"
+  "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake"
+  "CMakeFiles/3.16.3/CMakeSystem.cmake"
+  "/home/huey/opencv-4.7.0/install/lib/cmake/opencv4/OpenCVConfig-version.cmake"
+  "/home/huey/opencv-4.7.0/install/lib/cmake/opencv4/OpenCVConfig.cmake"
+  "/home/huey/opencv-4.7.0/install/lib/cmake/opencv4/OpenCVModules-release.cmake"
+  "/home/huey/opencv-4.7.0/install/lib/cmake/opencv4/OpenCVModules.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeCCompiler.cmake.in"
+  "/usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c"
+  "/usr/share/cmake-3.16/Modules/CMakeCInformation.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeCXXCompiler.cmake.in"
+  "/usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp"
+  "/usr/share/cmake-3.16/Modules/CMakeCXXInformation.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeCommonLanguageInclude.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeCompilerIdDetection.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCXXCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompileFeatures.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompilerABI.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompilerId.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineSystem.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeFindBinUtils.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeGenericSystem.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeInitializeConfigs.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeLanguageInformation.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeParseImplicitIncludeInfo.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeParseImplicitLinkInfo.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeSystem.cmake.in"
+  "/usr/share/cmake-3.16/Modules/CMakeSystemSpecificInformation.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeSystemSpecificInitialize.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeTestCCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeTestCXXCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeTestCompilerCommon.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeUnixFindMake.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/ADSP-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/ARMCC-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/ARMClang-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/AppleClang-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Borland-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Bruce-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Clang-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Compaq-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Cray-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Embarcadero-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Fujitsu-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GHS-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU-C.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU-CXX.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU-FindBinUtils.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/HP-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/HP-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/IAR-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Intel-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/MSVC-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/NVIDIA-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/PGI-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/PathScale-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/SCO-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/SDCC-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/SunPro-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/TI-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Watcom-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/XL-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/XL-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/XLClang-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/zOS-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/FindOpenSSL.cmake"
+  "/usr/share/cmake-3.16/Modules/FindPackageHandleStandardArgs.cmake"
+  "/usr/share/cmake-3.16/Modules/FindPackageMessage.cmake"
+  "/usr/share/cmake-3.16/Modules/FindPkgConfig.cmake"
+  "/usr/share/cmake-3.16/Modules/Internal/CMakeCheckCompilerFlag.cmake"
+  "/usr/share/cmake-3.16/Modules/Internal/FeatureTesting.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/Linux-Determine-CXX.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/Linux-GNU-C.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/Linux-GNU-CXX.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/Linux-GNU.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/Linux.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/UnixPaths.cmake"
+  )
+
+# The corresponding makefile is:
+set(CMAKE_MAKEFILE_OUTPUTS
+  "Makefile"
+  "CMakeFiles/cmake.check_cache"
+  )
+
+# Byproducts of CMake generate step:
+set(CMAKE_MAKEFILE_PRODUCTS
+  "CMakeFiles/3.16.3/CMakeSystem.cmake"
+  "CMakeFiles/3.16.3/CMakeCCompiler.cmake"
+  "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake"
+  "CMakeFiles/3.16.3/CMakeCCompiler.cmake"
+  "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake"
+  "CMakeFiles/CMakeDirectoryInformation.cmake"
+  )
+
+# Dependency information for all targets:
+set(CMAKE_DEPEND_INFO_FILES
+  "CMakeFiles/yolo_bytetrack.dir/DependInfo.cmake"
+  )
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/Makefile2 b/C++/yolo_bytetrack/build/CMakeFiles/Makefile2
new file mode 100644
index 00000000..71f447f7
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/Makefile2
@@ -0,0 +1,106 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# Default target executed when no arguments are given to make.
+default_target: all
+
+.PHONY : default_target
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+
+# Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+
+# A target that is always out of date.
+cmake_force:
+
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E remove -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/huey/Desktop/C/yolo_bytetrack
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/huey/Desktop/C/yolo_bytetrack/build
+
+#=============================================================================
+# Directory level rules for the build root directory
+
+# The main recursive "all" target.
+all: CMakeFiles/yolo_bytetrack.dir/all
+
+.PHONY : all
+
+# The main recursive "preinstall" target.
+preinstall:
+
+.PHONY : preinstall
+
+# The main recursive "clean" target.
+clean: CMakeFiles/yolo_bytetrack.dir/clean
+
+.PHONY : clean
+
+#=============================================================================
+# Target rules for target CMakeFiles/yolo_bytetrack.dir
+
+# All Build rule for target.
+CMakeFiles/yolo_bytetrack.dir/all:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/depend
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=1,2,3,4,5,6,7 "Built target yolo_bytetrack"
+.PHONY : CMakeFiles/yolo_bytetrack.dir/all
+
+# Build rule for subdir invocation for target.
+CMakeFiles/yolo_bytetrack.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles 7
+	$(MAKE) -f CMakeFiles/Makefile2 CMakeFiles/yolo_bytetrack.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles 0
+.PHONY : CMakeFiles/yolo_bytetrack.dir/rule
+
+# Convenience name for target.
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/rule
+
+.PHONY : yolo_bytetrack
+
+# clean rule for target.
+CMakeFiles/yolo_bytetrack.dir/clean:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/clean
+.PHONY : CMakeFiles/yolo_bytetrack.dir/clean
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/TargetDirectories.txt b/C++/yolo_bytetrack/build/CMakeFiles/TargetDirectories.txt
new file mode 100644
index 00000000..c5dc9c3a
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/TargetDirectories.txt
@@ -0,0 +1,3 @@
+/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/rebuild_cache.dir
+/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/edit_cache.dir
+/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/cmake.check_cache b/C++/yolo_bytetrack/build/CMakeFiles/cmake.check_cache
new file mode 100644
index 00000000..3dccd731
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/cmake.check_cache
@@ -0,0 +1 @@
+# This file is generated by cmake for dependency checking of the CMakeCache.txt file
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/progress.marks b/C++/yolo_bytetrack/build/CMakeFiles/progress.marks
new file mode 100644
index 00000000..7f8f011e
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+7
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/CXX.includecache b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/CXX.includecache
new file mode 100644
index 00000000..20ba3c2d
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/CXX.includecache
@@ -0,0 +1,2820 @@
+#IncludeRegexLine: ^[ 	]*[#%][ 	]*(include|import)[ 	]*[<"]([^">]+)([">])
+
+#IncludeRegexScan: ^.*$
+
+#IncludeRegexComplain: ^$
+
+#IncludeRegexTransform: 
+
+../3rdparty/librknn_api/include/rknn_api.h
+stdint.h
+-
+
+../include/BYTETracker.h
+STrack.h
+../include/STrack.h
+
+../include/Eigen/Cholesky
+Core
+../include/Eigen/Core
+Jacobi
+../include/Eigen/Jacobi
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/Cholesky/LLT.h
+../include/Eigen/src/Cholesky/LLT.h
+src/Cholesky/LDLT.h
+../include/Eigen/src/Cholesky/LDLT.h
+mkl_lapacke.h
+../include/Eigen/mkl_lapacke.h
+src/misc/lapacke.h
+../include/Eigen/src/misc/lapacke.h
+src/Cholesky/LLT_LAPACKE.h
+../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/Core
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/Core/util/Macros.h
+../include/Eigen/src/Core/util/Macros.h
+src/Core/util/ConfigureVectorization.h
+../include/Eigen/src/Core/util/ConfigureVectorization.h
+cuda_runtime.h
+-
+hip/hip_runtime.h
+-
+new
+-
+complex
+-
+src/Core/util/MKL_support.h
+../include/Eigen/src/Core/util/MKL_support.h
+omp.h
+-
+cerrno
+-
+cstddef
+-
+cstdlib
+-
+cmath
+-
+cassert
+-
+functional
+-
+sstream
+-
+iosfwd
+-
+cstring
+-
+string
+-
+limits
+-
+climits
+-
+algorithm
+-
+array
+-
+type_traits
+-
+iostream
+-
+intrin.h
+-
+CL/sycl.hpp
+-
+map
+-
+memory
+-
+utility
+-
+thread
+-
+src/Core/util/Constants.h
+../include/Eigen/src/Core/util/Constants.h
+src/Core/util/Meta.h
+../include/Eigen/src/Core/util/Meta.h
+src/Core/util/ForwardDeclarations.h
+../include/Eigen/src/Core/util/ForwardDeclarations.h
+src/Core/util/StaticAssert.h
+../include/Eigen/src/Core/util/StaticAssert.h
+src/Core/util/XprHelper.h
+../include/Eigen/src/Core/util/XprHelper.h
+src/Core/util/Memory.h
+../include/Eigen/src/Core/util/Memory.h
+src/Core/util/IntegralConstant.h
+../include/Eigen/src/Core/util/IntegralConstant.h
+src/Core/util/SymbolicIndex.h
+../include/Eigen/src/Core/util/SymbolicIndex.h
+src/Core/NumTraits.h
+../include/Eigen/src/Core/NumTraits.h
+src/Core/MathFunctions.h
+../include/Eigen/src/Core/MathFunctions.h
+src/Core/GenericPacketMath.h
+../include/Eigen/src/Core/GenericPacketMath.h
+src/Core/MathFunctionsImpl.h
+../include/Eigen/src/Core/MathFunctionsImpl.h
+src/Core/arch/Default/ConjHelper.h
+../include/Eigen/src/Core/arch/Default/ConjHelper.h
+src/Core/arch/Default/Half.h
+../include/Eigen/src/Core/arch/Default/Half.h
+src/Core/arch/Default/BFloat16.h
+../include/Eigen/src/Core/arch/Default/BFloat16.h
+src/Core/arch/Default/TypeCasting.h
+../include/Eigen/src/Core/arch/Default/TypeCasting.h
+src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+src/Core/arch/SSE/PacketMath.h
+../include/Eigen/src/Core/arch/SSE/PacketMath.h
+src/Core/arch/SSE/TypeCasting.h
+../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+src/Core/arch/SSE/Complex.h
+../include/Eigen/src/Core/arch/SSE/Complex.h
+src/Core/arch/AVX/PacketMath.h
+../include/Eigen/src/Core/arch/AVX/PacketMath.h
+src/Core/arch/AVX/TypeCasting.h
+../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+src/Core/arch/AVX/Complex.h
+../include/Eigen/src/Core/arch/AVX/Complex.h
+src/Core/arch/AVX512/PacketMath.h
+../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+src/Core/arch/AVX512/TypeCasting.h
+../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+src/Core/arch/AVX512/Complex.h
+../include/Eigen/src/Core/arch/AVX512/Complex.h
+src/Core/arch/SSE/MathFunctions.h
+../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+src/Core/arch/AVX/MathFunctions.h
+../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+src/Core/arch/AVX512/MathFunctions.h
+../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+src/Core/arch/SSE/PacketMath.h
+../include/Eigen/src/Core/arch/SSE/PacketMath.h
+src/Core/arch/SSE/TypeCasting.h
+../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+src/Core/arch/SSE/Complex.h
+../include/Eigen/src/Core/arch/SSE/Complex.h
+src/Core/arch/AVX/PacketMath.h
+../include/Eigen/src/Core/arch/AVX/PacketMath.h
+src/Core/arch/AVX/TypeCasting.h
+../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+src/Core/arch/AVX/Complex.h
+../include/Eigen/src/Core/arch/AVX/Complex.h
+src/Core/arch/SSE/MathFunctions.h
+../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+src/Core/arch/AVX/MathFunctions.h
+../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+src/Core/arch/SSE/PacketMath.h
+../include/Eigen/src/Core/arch/SSE/PacketMath.h
+src/Core/arch/SSE/TypeCasting.h
+../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+src/Core/arch/SSE/MathFunctions.h
+../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+src/Core/arch/SSE/Complex.h
+../include/Eigen/src/Core/arch/SSE/Complex.h
+src/Core/arch/AltiVec/PacketMath.h
+../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+src/Core/arch/AltiVec/MathFunctions.h
+../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+src/Core/arch/AltiVec/Complex.h
+../include/Eigen/src/Core/arch/AltiVec/Complex.h
+src/Core/arch/NEON/PacketMath.h
+../include/Eigen/src/Core/arch/NEON/PacketMath.h
+src/Core/arch/NEON/TypeCasting.h
+../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+src/Core/arch/NEON/MathFunctions.h
+../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+src/Core/arch/NEON/Complex.h
+../include/Eigen/src/Core/arch/NEON/Complex.h
+src/Core/arch/SVE/PacketMath.h
+../include/Eigen/src/Core/arch/SVE/PacketMath.h
+src/Core/arch/SVE/TypeCasting.h
+../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+src/Core/arch/SVE/MathFunctions.h
+../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+src/Core/arch/ZVector/PacketMath.h
+../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+src/Core/arch/ZVector/MathFunctions.h
+../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+src/Core/arch/ZVector/Complex.h
+../include/Eigen/src/Core/arch/ZVector/Complex.h
+src/Core/arch/MSA/PacketMath.h
+../include/Eigen/src/Core/arch/MSA/PacketMath.h
+src/Core/arch/MSA/MathFunctions.h
+../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+src/Core/arch/MSA/Complex.h
+../include/Eigen/src/Core/arch/MSA/Complex.h
+src/Core/arch/GPU/PacketMath.h
+../include/Eigen/src/Core/arch/GPU/PacketMath.h
+src/Core/arch/GPU/MathFunctions.h
+../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+src/Core/arch/GPU/TypeCasting.h
+../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+src/Core/arch/SYCL/SyclMemoryModel.h
+../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+src/Core/arch/SYCL/InteropHeaders.h
+../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+src/Core/arch/SYCL/PacketMath.h
+../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+src/Core/arch/SYCL/MathFunctions.h
+../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+src/Core/arch/SYCL/TypeCasting.h
+../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+src/Core/arch/Default/Settings.h
+../include/Eigen/src/Core/arch/Default/Settings.h
+src/Core/arch/Default/GenericPacketMathFunctions.h
+../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+src/Core/functors/TernaryFunctors.h
+../include/Eigen/src/Core/functors/TernaryFunctors.h
+src/Core/functors/BinaryFunctors.h
+../include/Eigen/src/Core/functors/BinaryFunctors.h
+src/Core/functors/UnaryFunctors.h
+../include/Eigen/src/Core/functors/UnaryFunctors.h
+src/Core/functors/NullaryFunctors.h
+../include/Eigen/src/Core/functors/NullaryFunctors.h
+src/Core/functors/StlFunctors.h
+../include/Eigen/src/Core/functors/StlFunctors.h
+src/Core/functors/AssignmentFunctors.h
+../include/Eigen/src/Core/functors/AssignmentFunctors.h
+src/Core/arch/CUDA/Complex.h
+../include/Eigen/src/Core/arch/CUDA/Complex.h
+src/Core/util/IndexedViewHelper.h
+../include/Eigen/src/Core/util/IndexedViewHelper.h
+src/Core/util/ReshapedHelper.h
+../include/Eigen/src/Core/util/ReshapedHelper.h
+src/Core/ArithmeticSequence.h
+../include/Eigen/src/Core/ArithmeticSequence.h
+src/Core/IO.h
+../include/Eigen/src/Core/IO.h
+src/Core/DenseCoeffsBase.h
+../include/Eigen/src/Core/DenseCoeffsBase.h
+src/Core/DenseBase.h
+../include/Eigen/src/Core/DenseBase.h
+src/Core/MatrixBase.h
+../include/Eigen/src/Core/MatrixBase.h
+src/Core/EigenBase.h
+../include/Eigen/src/Core/EigenBase.h
+src/Core/Product.h
+../include/Eigen/src/Core/Product.h
+src/Core/CoreEvaluators.h
+../include/Eigen/src/Core/CoreEvaluators.h
+src/Core/AssignEvaluator.h
+../include/Eigen/src/Core/AssignEvaluator.h
+src/Core/Assign.h
+../include/Eigen/src/Core/Assign.h
+src/Core/ArrayBase.h
+../include/Eigen/src/Core/ArrayBase.h
+src/Core/util/BlasUtil.h
+../include/Eigen/src/Core/util/BlasUtil.h
+src/Core/DenseStorage.h
+../include/Eigen/src/Core/DenseStorage.h
+src/Core/NestByValue.h
+../include/Eigen/src/Core/NestByValue.h
+src/Core/ReturnByValue.h
+../include/Eigen/src/Core/ReturnByValue.h
+src/Core/NoAlias.h
+../include/Eigen/src/Core/NoAlias.h
+src/Core/PlainObjectBase.h
+../include/Eigen/src/Core/PlainObjectBase.h
+src/Core/Matrix.h
+../include/Eigen/src/Core/Matrix.h
+src/Core/Array.h
+../include/Eigen/src/Core/Array.h
+src/Core/CwiseTernaryOp.h
+../include/Eigen/src/Core/CwiseTernaryOp.h
+src/Core/CwiseBinaryOp.h
+../include/Eigen/src/Core/CwiseBinaryOp.h
+src/Core/CwiseUnaryOp.h
+../include/Eigen/src/Core/CwiseUnaryOp.h
+src/Core/CwiseNullaryOp.h
+../include/Eigen/src/Core/CwiseNullaryOp.h
+src/Core/CwiseUnaryView.h
+../include/Eigen/src/Core/CwiseUnaryView.h
+src/Core/SelfCwiseBinaryOp.h
+../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+src/Core/Dot.h
+../include/Eigen/src/Core/Dot.h
+src/Core/StableNorm.h
+../include/Eigen/src/Core/StableNorm.h
+src/Core/Stride.h
+../include/Eigen/src/Core/Stride.h
+src/Core/MapBase.h
+../include/Eigen/src/Core/MapBase.h
+src/Core/Map.h
+../include/Eigen/src/Core/Map.h
+src/Core/Ref.h
+../include/Eigen/src/Core/Ref.h
+src/Core/Block.h
+../include/Eigen/src/Core/Block.h
+src/Core/VectorBlock.h
+../include/Eigen/src/Core/VectorBlock.h
+src/Core/IndexedView.h
+../include/Eigen/src/Core/IndexedView.h
+src/Core/Reshaped.h
+../include/Eigen/src/Core/Reshaped.h
+src/Core/Transpose.h
+../include/Eigen/src/Core/Transpose.h
+src/Core/DiagonalMatrix.h
+../include/Eigen/src/Core/DiagonalMatrix.h
+src/Core/Diagonal.h
+../include/Eigen/src/Core/Diagonal.h
+src/Core/DiagonalProduct.h
+../include/Eigen/src/Core/DiagonalProduct.h
+src/Core/Redux.h
+../include/Eigen/src/Core/Redux.h
+src/Core/Visitor.h
+../include/Eigen/src/Core/Visitor.h
+src/Core/Fuzzy.h
+../include/Eigen/src/Core/Fuzzy.h
+src/Core/Swap.h
+../include/Eigen/src/Core/Swap.h
+src/Core/CommaInitializer.h
+../include/Eigen/src/Core/CommaInitializer.h
+src/Core/GeneralProduct.h
+../include/Eigen/src/Core/GeneralProduct.h
+src/Core/Solve.h
+../include/Eigen/src/Core/Solve.h
+src/Core/Inverse.h
+../include/Eigen/src/Core/Inverse.h
+src/Core/SolverBase.h
+../include/Eigen/src/Core/SolverBase.h
+src/Core/PermutationMatrix.h
+../include/Eigen/src/Core/PermutationMatrix.h
+src/Core/Transpositions.h
+../include/Eigen/src/Core/Transpositions.h
+src/Core/TriangularMatrix.h
+../include/Eigen/src/Core/TriangularMatrix.h
+src/Core/SelfAdjointView.h
+../include/Eigen/src/Core/SelfAdjointView.h
+src/Core/products/GeneralBlockPanelKernel.h
+../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+src/Core/products/Parallelizer.h
+../include/Eigen/src/Core/products/Parallelizer.h
+src/Core/ProductEvaluators.h
+../include/Eigen/src/Core/ProductEvaluators.h
+src/Core/products/GeneralMatrixVector.h
+../include/Eigen/src/Core/products/GeneralMatrixVector.h
+src/Core/products/GeneralMatrixMatrix.h
+../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+src/Core/SolveTriangular.h
+../include/Eigen/src/Core/SolveTriangular.h
+src/Core/products/GeneralMatrixMatrixTriangular.h
+../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+src/Core/products/SelfadjointMatrixVector.h
+../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+src/Core/products/SelfadjointMatrixMatrix.h
+../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+src/Core/products/SelfadjointProduct.h
+../include/Eigen/src/Core/products/SelfadjointProduct.h
+src/Core/products/SelfadjointRank2Update.h
+../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+src/Core/products/TriangularMatrixVector.h
+../include/Eigen/src/Core/products/TriangularMatrixVector.h
+src/Core/products/TriangularMatrixMatrix.h
+../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+src/Core/products/TriangularSolverMatrix.h
+../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+src/Core/products/TriangularSolverVector.h
+../include/Eigen/src/Core/products/TriangularSolverVector.h
+src/Core/BandMatrix.h
+../include/Eigen/src/Core/BandMatrix.h
+src/Core/CoreIterators.h
+../include/Eigen/src/Core/CoreIterators.h
+src/Core/ConditionEstimator.h
+../include/Eigen/src/Core/ConditionEstimator.h
+src/Core/arch/AltiVec/MatrixProduct.h
+../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+src/Core/arch/NEON/GeneralBlockPanelKernel.h
+../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+src/Core/BooleanRedux.h
+../include/Eigen/src/Core/BooleanRedux.h
+src/Core/Select.h
+../include/Eigen/src/Core/Select.h
+src/Core/VectorwiseOp.h
+../include/Eigen/src/Core/VectorwiseOp.h
+src/Core/PartialReduxEvaluator.h
+../include/Eigen/src/Core/PartialReduxEvaluator.h
+src/Core/Random.h
+../include/Eigen/src/Core/Random.h
+src/Core/Replicate.h
+../include/Eigen/src/Core/Replicate.h
+src/Core/Reverse.h
+../include/Eigen/src/Core/Reverse.h
+src/Core/ArrayWrapper.h
+../include/Eigen/src/Core/ArrayWrapper.h
+src/Core/StlIterators.h
+../include/Eigen/src/Core/StlIterators.h
+src/Core/products/GeneralMatrixMatrix_BLAS.h
+../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+src/Core/products/GeneralMatrixVector_BLAS.h
+../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+src/Core/products/SelfadjointMatrixVector_BLAS.h
+../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+src/Core/products/TriangularMatrixMatrix_BLAS.h
+../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+src/Core/products/TriangularMatrixVector_BLAS.h
+../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+src/Core/products/TriangularSolverMatrix_BLAS.h
+../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+src/Core/Assign_MKL.h
+../include/Eigen/src/Core/Assign_MKL.h
+src/Core/GlobalFunctions.h
+../include/Eigen/src/Core/GlobalFunctions.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/Dense
+Core
+../include/Eigen/Core
+LU
+../include/Eigen/LU
+Cholesky
+../include/Eigen/Cholesky
+QR
+../include/Eigen/QR
+SVD
+../include/Eigen/SVD
+Geometry
+../include/Eigen/Geometry
+Eigenvalues
+../include/Eigen/Eigenvalues
+
+../include/Eigen/Eigenvalues
+Core
+../include/Eigen/Core
+Cholesky
+../include/Eigen/Cholesky
+Jacobi
+../include/Eigen/Jacobi
+Householder
+../include/Eigen/Householder
+LU
+../include/Eigen/LU
+Geometry
+../include/Eigen/Geometry
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/misc/RealSvd2x2.h
+../include/Eigen/src/misc/RealSvd2x2.h
+src/Eigenvalues/Tridiagonalization.h
+../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+src/Eigenvalues/RealSchur.h
+../include/Eigen/src/Eigenvalues/RealSchur.h
+src/Eigenvalues/EigenSolver.h
+../include/Eigen/src/Eigenvalues/EigenSolver.h
+src/Eigenvalues/SelfAdjointEigenSolver.h
+../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+src/Eigenvalues/HessenbergDecomposition.h
+../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+src/Eigenvalues/ComplexSchur.h
+../include/Eigen/src/Eigenvalues/ComplexSchur.h
+src/Eigenvalues/ComplexEigenSolver.h
+../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+src/Eigenvalues/RealQZ.h
+../include/Eigen/src/Eigenvalues/RealQZ.h
+src/Eigenvalues/GeneralizedEigenSolver.h
+../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+src/Eigenvalues/MatrixBaseEigenvalues.h
+../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+mkl_lapacke.h
+../include/Eigen/mkl_lapacke.h
+src/misc/lapacke.h
+../include/Eigen/src/misc/lapacke.h
+src/Eigenvalues/RealSchur_LAPACKE.h
+../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+src/Eigenvalues/ComplexSchur_LAPACKE.h
+../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/Geometry
+Core
+../include/Eigen/Core
+SVD
+../include/Eigen/SVD
+LU
+../include/Eigen/LU
+limits
+-
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/Geometry/OrthoMethods.h
+../include/Eigen/src/Geometry/OrthoMethods.h
+src/Geometry/EulerAngles.h
+../include/Eigen/src/Geometry/EulerAngles.h
+src/Geometry/Homogeneous.h
+../include/Eigen/src/Geometry/Homogeneous.h
+src/Geometry/RotationBase.h
+../include/Eigen/src/Geometry/RotationBase.h
+src/Geometry/Rotation2D.h
+../include/Eigen/src/Geometry/Rotation2D.h
+src/Geometry/Quaternion.h
+../include/Eigen/src/Geometry/Quaternion.h
+src/Geometry/AngleAxis.h
+../include/Eigen/src/Geometry/AngleAxis.h
+src/Geometry/Transform.h
+../include/Eigen/src/Geometry/Transform.h
+src/Geometry/Translation.h
+../include/Eigen/src/Geometry/Translation.h
+src/Geometry/Scaling.h
+../include/Eigen/src/Geometry/Scaling.h
+src/Geometry/Hyperplane.h
+../include/Eigen/src/Geometry/Hyperplane.h
+src/Geometry/ParametrizedLine.h
+../include/Eigen/src/Geometry/ParametrizedLine.h
+src/Geometry/AlignedBox.h
+../include/Eigen/src/Geometry/AlignedBox.h
+src/Geometry/Umeyama.h
+../include/Eigen/src/Geometry/Umeyama.h
+src/Geometry/arch/Geometry_SIMD.h
+../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/Householder
+Core
+../include/Eigen/Core
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/Householder/Householder.h
+../include/Eigen/src/Householder/Householder.h
+src/Householder/HouseholderSequence.h
+../include/Eigen/src/Householder/HouseholderSequence.h
+src/Householder/BlockHouseholder.h
+../include/Eigen/src/Householder/BlockHouseholder.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/Jacobi
+Core
+../include/Eigen/Core
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/Jacobi/Jacobi.h
+../include/Eigen/src/Jacobi/Jacobi.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/LU
+Core
+../include/Eigen/Core
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/misc/Kernel.h
+../include/Eigen/src/misc/Kernel.h
+src/misc/Image.h
+../include/Eigen/src/misc/Image.h
+src/LU/FullPivLU.h
+../include/Eigen/src/LU/FullPivLU.h
+src/LU/PartialPivLU.h
+../include/Eigen/src/LU/PartialPivLU.h
+mkl_lapacke.h
+../include/Eigen/mkl_lapacke.h
+src/misc/lapacke.h
+../include/Eigen/src/misc/lapacke.h
+src/LU/PartialPivLU_LAPACKE.h
+../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+src/LU/Determinant.h
+../include/Eigen/src/LU/Determinant.h
+src/LU/InverseImpl.h
+../include/Eigen/src/LU/InverseImpl.h
+src/LU/arch/InverseSize4.h
+../include/Eigen/src/LU/arch/InverseSize4.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/QR
+Core
+../include/Eigen/Core
+Cholesky
+../include/Eigen/Cholesky
+Jacobi
+../include/Eigen/Jacobi
+Householder
+../include/Eigen/Householder
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/QR/HouseholderQR.h
+../include/Eigen/src/QR/HouseholderQR.h
+src/QR/FullPivHouseholderQR.h
+../include/Eigen/src/QR/FullPivHouseholderQR.h
+src/QR/ColPivHouseholderQR.h
+../include/Eigen/src/QR/ColPivHouseholderQR.h
+src/QR/CompleteOrthogonalDecomposition.h
+../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+mkl_lapacke.h
+../include/Eigen/mkl_lapacke.h
+src/misc/lapacke.h
+../include/Eigen/src/misc/lapacke.h
+src/QR/HouseholderQR_LAPACKE.h
+../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+src/QR/ColPivHouseholderQR_LAPACKE.h
+../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/SVD
+QR
+../include/Eigen/QR
+Householder
+../include/Eigen/Householder
+Jacobi
+../include/Eigen/Jacobi
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/misc/RealSvd2x2.h
+../include/Eigen/src/misc/RealSvd2x2.h
+src/SVD/UpperBidiagonalization.h
+../include/Eigen/src/SVD/UpperBidiagonalization.h
+src/SVD/SVDBase.h
+../include/Eigen/src/SVD/SVDBase.h
+src/SVD/JacobiSVD.h
+../include/Eigen/src/SVD/JacobiSVD.h
+src/SVD/BDCSVD.h
+../include/Eigen/src/SVD/BDCSVD.h
+mkl_lapacke.h
+../include/Eigen/mkl_lapacke.h
+src/misc/lapacke.h
+../include/Eigen/src/misc/lapacke.h
+src/SVD/JacobiSVD_LAPACKE.h
+../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/src/Cholesky/LDLT.h
+
+../include/Eigen/src/Cholesky/LLT.h
+
+../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+
+../include/Eigen/src/Core/ArithmeticSequence.h
+
+../include/Eigen/src/Core/Array.h
+
+../include/Eigen/src/Core/ArrayBase.h
+../plugins/MatrixCwiseUnaryOps.h
+../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+../plugins/ArrayCwiseUnaryOps.h
+../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+../plugins/CommonCwiseBinaryOps.h
+../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+../plugins/MatrixCwiseBinaryOps.h
+../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+../plugins/ArrayCwiseBinaryOps.h
+../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+
+../include/Eigen/src/Core/ArrayWrapper.h
+
+../include/Eigen/src/Core/Assign.h
+
+../include/Eigen/src/Core/AssignEvaluator.h
+
+../include/Eigen/src/Core/Assign_MKL.h
+
+../include/Eigen/src/Core/BandMatrix.h
+
+../include/Eigen/src/Core/Block.h
+
+../include/Eigen/src/Core/BooleanRedux.h
+
+../include/Eigen/src/Core/CommaInitializer.h
+
+../include/Eigen/src/Core/ConditionEstimator.h
+
+../include/Eigen/src/Core/CoreEvaluators.h
+
+../include/Eigen/src/Core/CoreIterators.h
+
+../include/Eigen/src/Core/CwiseBinaryOp.h
+
+../include/Eigen/src/Core/CwiseNullaryOp.h
+
+../include/Eigen/src/Core/CwiseTernaryOp.h
+
+../include/Eigen/src/Core/CwiseUnaryOp.h
+
+../include/Eigen/src/Core/CwiseUnaryView.h
+
+../include/Eigen/src/Core/DenseBase.h
+../plugins/CommonCwiseUnaryOps.h
+../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+../plugins/BlockMethods.h
+../include/Eigen/src/plugins/BlockMethods.h
+../plugins/IndexedViewMethods.h
+../include/Eigen/src/plugins/IndexedViewMethods.h
+../plugins/ReshapedMethods.h
+../include/Eigen/src/plugins/ReshapedMethods.h
+
+../include/Eigen/src/Core/DenseCoeffsBase.h
+
+../include/Eigen/src/Core/DenseStorage.h
+
+../include/Eigen/src/Core/Diagonal.h
+
+../include/Eigen/src/Core/DiagonalMatrix.h
+
+../include/Eigen/src/Core/DiagonalProduct.h
+
+../include/Eigen/src/Core/Dot.h
+
+../include/Eigen/src/Core/EigenBase.h
+
+../include/Eigen/src/Core/Fuzzy.h
+
+../include/Eigen/src/Core/GeneralProduct.h
+
+../include/Eigen/src/Core/GenericPacketMath.h
+
+../include/Eigen/src/Core/GlobalFunctions.h
+
+../include/Eigen/src/Core/IO.h
+
+../include/Eigen/src/Core/IndexedView.h
+
+../include/Eigen/src/Core/Inverse.h
+
+../include/Eigen/src/Core/Map.h
+
+../include/Eigen/src/Core/MapBase.h
+
+../include/Eigen/src/Core/MathFunctions.h
+
+../include/Eigen/src/Core/MathFunctionsImpl.h
+
+../include/Eigen/src/Core/Matrix.h
+
+../include/Eigen/src/Core/MatrixBase.h
+../plugins/CommonCwiseBinaryOps.h
+../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+../plugins/MatrixCwiseUnaryOps.h
+../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+../plugins/MatrixCwiseBinaryOps.h
+../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+
+../include/Eigen/src/Core/NestByValue.h
+
+../include/Eigen/src/Core/NoAlias.h
+
+../include/Eigen/src/Core/NumTraits.h
+
+../include/Eigen/src/Core/PartialReduxEvaluator.h
+
+../include/Eigen/src/Core/PermutationMatrix.h
+
+../include/Eigen/src/Core/PlainObjectBase.h
+
+../include/Eigen/src/Core/Product.h
+
+../include/Eigen/src/Core/ProductEvaluators.h
+
+../include/Eigen/src/Core/Random.h
+
+../include/Eigen/src/Core/Redux.h
+
+../include/Eigen/src/Core/Ref.h
+
+../include/Eigen/src/Core/Replicate.h
+
+../include/Eigen/src/Core/Reshaped.h
+
+../include/Eigen/src/Core/ReturnByValue.h
+
+../include/Eigen/src/Core/Reverse.h
+
+../include/Eigen/src/Core/Select.h
+
+../include/Eigen/src/Core/SelfAdjointView.h
+
+../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+
+../include/Eigen/src/Core/Solve.h
+
+../include/Eigen/src/Core/SolveTriangular.h
+
+../include/Eigen/src/Core/SolverBase.h
+
+../include/Eigen/src/Core/StableNorm.h
+
+../include/Eigen/src/Core/StlIterators.h
+
+../include/Eigen/src/Core/Stride.h
+
+../include/Eigen/src/Core/Swap.h
+
+../include/Eigen/src/Core/Transpose.h
+
+../include/Eigen/src/Core/Transpositions.h
+
+../include/Eigen/src/Core/TriangularMatrix.h
+
+../include/Eigen/src/Core/VectorBlock.h
+
+../include/Eigen/src/Core/VectorwiseOp.h
+
+../include/Eigen/src/Core/Visitor.h
+
+../include/Eigen/src/Core/arch/AVX/Complex.h
+
+../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+
+../include/Eigen/src/Core/arch/AVX/PacketMath.h
+
+../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+
+../include/Eigen/src/Core/arch/AVX512/Complex.h
+
+../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+
+../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+
+../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+
+../include/Eigen/src/Core/arch/AltiVec/Complex.h
+
+../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+
+../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+MatrixProductCommon.h
+../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+MatrixProductMMA.h
+../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+
+../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+
+../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+
+../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+
+../include/Eigen/src/Core/arch/CUDA/Complex.h
+
+../include/Eigen/src/Core/arch/Default/BFloat16.h
+
+../include/Eigen/src/Core/arch/Default/ConjHelper.h
+
+../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+
+../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+
+../include/Eigen/src/Core/arch/Default/Half.h
+sstream
+-
+
+../include/Eigen/src/Core/arch/Default/Settings.h
+
+../include/Eigen/src/Core/arch/Default/TypeCasting.h
+
+../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+
+../include/Eigen/src/Core/arch/GPU/PacketMath.h
+
+../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+
+../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+
+../include/Eigen/src/Core/arch/MSA/Complex.h
+iostream
+-
+
+../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+
+../include/Eigen/src/Core/arch/MSA/PacketMath.h
+iostream
+-
+string
+-
+
+../include/Eigen/src/Core/arch/NEON/Complex.h
+
+../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+
+../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+
+../include/Eigen/src/Core/arch/NEON/PacketMath.h
+
+../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+
+../include/Eigen/src/Core/arch/SSE/Complex.h
+
+../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+
+../include/Eigen/src/Core/arch/SSE/PacketMath.h
+
+../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+
+../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+
+../include/Eigen/src/Core/arch/SVE/PacketMath.h
+
+../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+
+../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+
+../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+
+../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+type_traits
+-
+
+../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CL/sycl.hpp
+-
+stdexcept
+-
+cstddef
+-
+queue
+-
+set
+-
+unordered_map
+-
+
+../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+
+../include/Eigen/src/Core/arch/ZVector/Complex.h
+
+../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+
+../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+
+../include/Eigen/src/Core/functors/AssignmentFunctors.h
+
+../include/Eigen/src/Core/functors/BinaryFunctors.h
+
+../include/Eigen/src/Core/functors/NullaryFunctors.h
+
+../include/Eigen/src/Core/functors/StlFunctors.h
+
+../include/Eigen/src/Core/functors/TernaryFunctors.h
+
+../include/Eigen/src/Core/functors/UnaryFunctors.h
+
+../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+
+../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+
+../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+
+../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+
+../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+
+../include/Eigen/src/Core/products/GeneralMatrixVector.h
+
+../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+
+../include/Eigen/src/Core/products/Parallelizer.h
+atomic
+-
+
+../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+
+../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+
+../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+
+../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+
+../include/Eigen/src/Core/products/SelfadjointProduct.h
+
+../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+
+../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+
+../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+
+../include/Eigen/src/Core/products/TriangularMatrixVector.h
+
+../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+
+../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+
+../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+
+../include/Eigen/src/Core/products/TriangularSolverVector.h
+
+../include/Eigen/src/Core/util/BlasUtil.h
+
+../include/Eigen/src/Core/util/ConfigureVectorization.h
+malloc.h
+-
+immintrin.h
+-
+mmintrin.h
+-
+emmintrin.h
+-
+xmmintrin.h
+-
+pmmintrin.h
+-
+tmmintrin.h
+-
+smmintrin.h
+-
+nmmintrin.h
+-
+immintrin.h
+-
+altivec.h
+-
+altivec.h
+-
+arm_neon.h
+-
+arm_sve.h
+-
+vecintrin.h
+-
+msa.h
+-
+arm_fp16.h
+-
+immintrin.h
+-
+vector_types.h
+-
+cuda_runtime_api.h
+-
+cuda_fp16.h
+-
+hip/hip_vector_types.h
+-
+hip/hip_fp16.h
+-
+
+../include/Eigen/src/Core/util/Constants.h
+
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+
+../include/Eigen/src/Core/util/ForwardDeclarations.h
+
+../include/Eigen/src/Core/util/IndexedViewHelper.h
+
+../include/Eigen/src/Core/util/IntegralConstant.h
+
+../include/Eigen/src/Core/util/MKL_support.h
+mkl.h
+-
+../../misc/blas.h
+../include/Eigen/src/misc/blas.h
+
+../include/Eigen/src/Core/util/Macros.h
+cuda.h
+-
+hip/hip_runtime.h
+-
+cmath
+-
+cstdlib
+-
+iostream
+-
+
+../include/Eigen/src/Core/util/Memory.h
+
+../include/Eigen/src/Core/util/Meta.h
+cfloat
+-
+math_constants.h
+-
+Eigen/src/Core/arch/HIP/hcc/math_constants.h
+../include/Eigen/src/Core/util/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+cstdint
+-
+stdint.h
+-
+
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/src/Core/util/ReshapedHelper.h
+
+../include/Eigen/src/Core/util/StaticAssert.h
+
+../include/Eigen/src/Core/util/SymbolicIndex.h
+
+../include/Eigen/src/Core/util/XprHelper.h
+
+../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+./ComplexSchur.h
+../include/Eigen/src/Eigenvalues/ComplexSchur.h
+
+../include/Eigen/src/Eigenvalues/ComplexSchur.h
+./HessenbergDecomposition.h
+../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+
+../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+
+../include/Eigen/src/Eigenvalues/EigenSolver.h
+./RealSchur.h
+../include/Eigen/src/Eigenvalues/RealSchur.h
+
+../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+./RealQZ.h
+../include/Eigen/src/Eigenvalues/RealQZ.h
+
+../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+./Tridiagonalization.h
+../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+
+../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+
+../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+
+../include/Eigen/src/Eigenvalues/RealQZ.h
+
+../include/Eigen/src/Eigenvalues/RealSchur.h
+./HessenbergDecomposition.h
+../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+
+../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+
+../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+./Tridiagonalization.h
+../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+
+../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+
+../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+
+../include/Eigen/src/Geometry/AlignedBox.h
+
+../include/Eigen/src/Geometry/AngleAxis.h
+
+../include/Eigen/src/Geometry/EulerAngles.h
+
+../include/Eigen/src/Geometry/Homogeneous.h
+
+../include/Eigen/src/Geometry/Hyperplane.h
+
+../include/Eigen/src/Geometry/OrthoMethods.h
+
+../include/Eigen/src/Geometry/ParametrizedLine.h
+
+../include/Eigen/src/Geometry/Quaternion.h
+
+../include/Eigen/src/Geometry/Rotation2D.h
+
+../include/Eigen/src/Geometry/RotationBase.h
+
+../include/Eigen/src/Geometry/Scaling.h
+
+../include/Eigen/src/Geometry/Transform.h
+
+../include/Eigen/src/Geometry/Translation.h
+
+../include/Eigen/src/Geometry/Umeyama.h
+
+../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+
+../include/Eigen/src/Householder/BlockHouseholder.h
+
+../include/Eigen/src/Householder/Householder.h
+
+../include/Eigen/src/Householder/HouseholderSequence.h
+
+../include/Eigen/src/Jacobi/Jacobi.h
+
+../include/Eigen/src/LU/Determinant.h
+
+../include/Eigen/src/LU/FullPivLU.h
+
+../include/Eigen/src/LU/InverseImpl.h
+
+../include/Eigen/src/LU/PartialPivLU.h
+
+../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+
+../include/Eigen/src/LU/arch/InverseSize4.h
+
+../include/Eigen/src/QR/ColPivHouseholderQR.h
+
+../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+
+../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+
+../include/Eigen/src/QR/FullPivHouseholderQR.h
+
+../include/Eigen/src/QR/HouseholderQR.h
+
+../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+
+../include/Eigen/src/SVD/BDCSVD.h
+
+../include/Eigen/src/SVD/JacobiSVD.h
+
+../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+
+../include/Eigen/src/SVD/SVDBase.h
+
+../include/Eigen/src/SVD/UpperBidiagonalization.h
+
+../include/Eigen/src/misc/Image.h
+
+../include/Eigen/src/misc/Kernel.h
+
+../include/Eigen/src/misc/RealSvd2x2.h
+
+../include/Eigen/src/misc/blas.h
+
+../include/Eigen/src/misc/lapacke.h
+lapacke_config.h
+../include/Eigen/src/misc/lapacke_config.h
+stdlib.h
+-
+complex.h
+-
+complex.h
+-
+lapacke_mangling.h
+../include/Eigen/src/misc/lapacke_mangling.h
+
+../include/Eigen/src/misc/lapacke_mangling.h
+
+../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+
+../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+
+../include/Eigen/src/plugins/BlockMethods.h
+
+../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+
+../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+
+../include/Eigen/src/plugins/IndexedViewMethods.h
+IndexedViewMethods.h
+../include/Eigen/src/plugins/IndexedViewMethods.h
+
+../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+
+../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+
+../include/Eigen/src/plugins/ReshapedMethods.h
+ReshapedMethods.h
+../include/Eigen/src/plugins/ReshapedMethods.h
+
+../include/STrack.h
+opencv2/opencv.hpp
+-
+kalmanFilter.h
+../include/kalmanFilter.h
+
+../include/dataType.h
+cstddef
+-
+vector
+-
+Eigen/Core
+-
+Eigen/Dense
+-
+
+../include/kalmanFilter.h
+dataType.h
+../include/dataType.h
+
+../include/lapjv.h
+assert.h
+-
+
+/home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp
+BYTETracker.h
+/home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.h
+fstream
+-
+iostream
+-
+
+/home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp
+STrack.h
+/home/huey/Desktop/C/yolo_bytetrack/src/STrack.h
+dataType.h
+/home/huey/Desktop/C/yolo_bytetrack/src/dataType.h
+iostream
+-
+
+/home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp
+fstream
+-
+iostream
+-
+sstream
+-
+numeric
+-
+chrono
+-
+vector
+-
+openssl/sha.h
+-
+openssl/evp.h
+-
+curl/curl.h
+-
+ctime
+-
+cstring
+-
+unistd.h
+-
+atomic
+-
+thread
+-
+chrono
+-
+string
+-
+dirent.h
+-
+sys/time.h
+-
+BYTETracker.h
+/home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.h
+rknn_api.h
+/home/huey/Desktop/C/yolo_bytetrack/src/rknn_api.h
+opencv2/core/core.hpp
+/home/huey/Desktop/C/yolo_bytetrack/src/opencv2/core/core.hpp
+opencv2/imgproc/imgproc.hpp
+/home/huey/Desktop/C/yolo_bytetrack/src/opencv2/imgproc/imgproc.hpp
+opencv2/highgui/highgui.hpp
+/home/huey/Desktop/C/yolo_bytetrack/src/opencv2/highgui/highgui.hpp
+opencv2/videoio.hpp
+/home/huey/Desktop/C/yolo_bytetrack/src/opencv2/videoio.hpp
+opencv2/video.hpp
+/home/huey/Desktop/C/yolo_bytetrack/src/opencv2/video.hpp
+unordered_set
+-
+
+/home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp
+kalmanFilter.h
+/home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.h
+Eigen/Cholesky
+-
+iostream
+-
+
+/home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp
+stdio.h
+-
+stdlib.h
+-
+string.h
+-
+lapjv.h
+/home/huey/Desktop/C/yolo_bytetrack/src/lapjv.h
+
+/home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp
+BYTETracker.h
+/home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.h
+lapjv.h
+/home/huey/Desktop/C/yolo_bytetrack/src/lapjv.h
+map
+-
+iostream
+-
+
+/home/huey/curl-8.8.0/install/include/curl/curl.h
+curlver.h
+/home/huey/curl-8.8.0/install/include/curl/curlver.h
+system.h
+/home/huey/curl-8.8.0/install/include/curl/system.h
+stdio.h
+-
+limits.h
+-
+sys/param.h
+-
+sys/types.h
+-
+time.h
+-
+winsock2.h
+-
+ws2tcpip.h
+-
+sys/select.h
+-
+sys/socket.h
+-
+sys/time.h
+-
+easy.h
+/home/huey/curl-8.8.0/install/include/curl/easy.h
+multi.h
+/home/huey/curl-8.8.0/install/include/curl/multi.h
+urlapi.h
+/home/huey/curl-8.8.0/install/include/curl/urlapi.h
+options.h
+/home/huey/curl-8.8.0/install/include/curl/options.h
+header.h
+/home/huey/curl-8.8.0/install/include/curl/header.h
+websockets.h
+/home/huey/curl-8.8.0/install/include/curl/websockets.h
+mprintf.h
+/home/huey/curl-8.8.0/install/include/curl/mprintf.h
+typecheck-gcc.h
+/home/huey/curl-8.8.0/install/include/curl/typecheck-gcc.h
+
+/home/huey/curl-8.8.0/install/include/curl/curlver.h
+
+/home/huey/curl-8.8.0/install/include/curl/easy.h
+
+/home/huey/curl-8.8.0/install/include/curl/header.h
+
+/home/huey/curl-8.8.0/install/include/curl/mprintf.h
+stdarg.h
+-
+stdio.h
+-
+curl.h
+/home/huey/curl-8.8.0/install/include/curl/curl.h
+
+/home/huey/curl-8.8.0/install/include/curl/multi.h
+curl.h
+/home/huey/curl-8.8.0/install/include/curl/curl.h
+
+/home/huey/curl-8.8.0/install/include/curl/options.h
+
+/home/huey/curl-8.8.0/install/include/curl/system.h
+ConditionalMacros.h
+-
+inttypes.h
+-
+inttypes.h
+-
+sys/types.h
+-
+sys/socket.h
+-
+sys/poll.h
+-
+
+/home/huey/curl-8.8.0/install/include/curl/typecheck-gcc.h
+
+/home/huey/curl-8.8.0/install/include/curl/urlapi.h
+curl.h
+/home/huey/curl-8.8.0/install/include/curl/curl.h
+
+/home/huey/curl-8.8.0/install/include/curl/websockets.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/core/types.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/types.hpp
+opencv2/features2d.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/features2d.hpp
+opencv2/core/affine.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/affine.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/cvdef.h
+opencv2/core/base.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/base.hpp
+opencv2/core/cvstd.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/cvstd.hpp
+opencv2/core/traits.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/traits.hpp
+opencv2/core/matx.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/matx.hpp
+opencv2/core/types.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/types.hpp
+opencv2/core/mat.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/mat.hpp
+opencv2/core/persistence.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/persistence.hpp
+opencv2/core/operations.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/operations.hpp
+opencv2/core/cvstd.inl.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/cvstd.inl.hpp
+opencv2/core/utility.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/utility.hpp
+opencv2/core/optim.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/optim.hpp
+opencv2/core/ovx.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/ovx.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+opencv2/core.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+opencv2/core/mat.hpp
+-
+chrono
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/opencv_modules.hpp
+climits
+-
+algorithm
+-
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+opencv2/core/cvstd.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvstd.hpp
+opencv2/core/neon_utils.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/neon_utils.hpp
+opencv2/core/vsx_utils.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/vsx_utils.hpp
+opencv2/core/check.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/check.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+opencv2/core/base.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/core.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core.hpp
+opencv2/core/cuda_types.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cuda_types.hpp
+opencv2/opencv.hpp
+-
+opencv2/core/cuda.inl.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cuda.inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+opencv2/core/cuda.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cuda.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+cv_cpu_config.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_config.h
+cv_cpu_helper.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+emmintrin.h
+-
+pmmintrin.h
+-
+tmmintrin.h
+-
+smmintrin.h
+-
+nmmintrin.h
+-
+nmmintrin.h
+-
+popcntintrin.h
+-
+immintrin.h
+-
+arm_neon.h
+-
+immintrin.h
+-
+arm_neon.h
+-
+immintrin.h
+-
+immintrin.h
+-
+Intrin.h
+-
+arm_neon.h
+-
+arm_neon.h
+-
+riscv-vector.h
+-
+arm_neon.h
+-
+altivec.h
+-
+hal/msa_macros.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+lasxintrin.h
+-
+wasm_simd128.h
+-
+riscv_vector.h
+-
+emmintrin.h
+-
+Intrin.h
+-
+arm_neon.h
+-
+arm_neon.h
+-
+altivec.h
+-
+immintrin.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+opencv2/core/version.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/version.hpp
+cvconfig.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvconfig.h
+limits
+-
+limits.h
+-
+opencv2/core/hal/interface.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/hal/interface.h
+cv_cpu_dispatch.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+intrin.h
+-
+array
+-
+cstdint
+-
+stdint.h
+-
+stdint.h
+-
+opencv2/core/fast_math.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/fast_math.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+cstddef
+-
+cstring
+-
+cctype
+-
+string
+-
+algorithm
+-
+utility
+-
+cstdlib
+-
+cmath
+-
+cvstd_wrapper.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+complex
+-
+ostream
+-
+sstream
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+string
+-
+memory
+-
+type_traits
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+cmath
+-
+fastmath.h
+-
+math.h
+-
+emmintrin.h
+-
+altivec.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+cstddef
+-
+stddef.h
+-
+stdbool.h
+-
+cstdint
+-
+stdint.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+msa.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa.h
+stdint.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+opencv2/core/matx.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/matx.hpp
+opencv2/core/types.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/types.hpp
+opencv2/core/bufferpool.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/bufferpool.hpp
+type_traits
+-
+opencv2/core/mat.inl.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/mat.inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+opencv2/core/base.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/base.hpp
+opencv2/core/traits.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/traits.hpp
+opencv2/core/saturate.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/saturate.hpp
+initializer_list
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+cstdio
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+opencv2/core/types.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/types.hpp
+opencv2/core/mat.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/mat.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core.hpp
+time.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+climits
+-
+opencv2/core/fast_math.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/fast_math.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+climits
+-
+cfloat
+-
+vector
+-
+limits
+-
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+opencv2/core/cvstd.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvstd.hpp
+opencv2/core/matx.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/matx.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core.hpp
+ostream
+-
+functional
+-
+mutex
+-
+opencv2/core/utils/instrumentation.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/utils/instrumentation.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+opencv2/core/utility.hpp
+-
+opencv2/core/utils/tls.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+assert.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+opencv2/dnn/dnn.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+opencv2/core.hpp
+-
+map
+-
+ostream
+-
+opencv2/dnn/dnn.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+vector
+-
+opencv2/core.hpp
+-
+opencv2/core/async.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/opencv2/core/async.hpp
+../dnn/version.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+opencv2/dnn/dict.hpp
+-
+opencv2/dnn/layer.hpp
+-
+opencv2/dnn/dnn.inl.hpp
+-
+opencv2/dnn/utils/inference_engine.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+opencv2/dnn.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+opencv2/dnn.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+../dnn.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/opencv_modules.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/flann/miniflann.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/flann/miniflann.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/flann/miniflann.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/flann/miniflann.hpp
+opencv2/flann/flann_base.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/flann/flann_base.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+kdtree_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+kdtree_single_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+kmeans_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+composite_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+linear_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+hierarchical_clustering_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+lsh_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+autotuned_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+stdlib.h
+-
+stdio.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+defines.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+stdexcept
+-
+ostream
+-
+typeinfo
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+sstream
+-
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+ground_truth.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+index_testing.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+sampling.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+kdtree_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+kdtree_single_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+kmeans_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+composite_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+linear_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+logger.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+kdtree_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+kmeans_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+config.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+cmath
+-
+cstdlib
+-
+string.h
+-
+stdint.h
+-
+defines.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+Intrin.h
+-
+arm_neon.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/arm_neon.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+boost/dynamic_bitset.hpp
+-
+limits.h
+-
+dist.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+vector
+-
+cstdio
+-
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+params.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+all_indices.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+dist.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+algorithm
+-
+vector
+-
+unordered_map
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+algorithm
+-
+map
+-
+limits
+-
+cmath
+-
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+dist.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+heap.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+allocator.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+cstring
+-
+cmath
+-
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+logger.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+timer.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+algorithm
+-
+map
+-
+cstring
+-
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+dynamic_bitset.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+heap.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+allocator.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+algorithm
+-
+map
+-
+cstring
+-
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+heap.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+allocator.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+algorithm
+-
+map
+-
+limits
+-
+cmath
+-
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+dist.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+heap.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+allocator.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+logger.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+stdio.h
+-
+stdarg.h
+-
+defines.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+algorithm
+-
+cstring
+-
+map
+-
+vector
+-
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+heap.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+lsh_table.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+allocator.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+algorithm
+-
+iostream
+-
+iomanip
+-
+limits.h
+-
+unordered_map
+-
+map
+-
+math.h
+-
+stddef.h
+-
+dynamic_bitset.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+stdio.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/opencv2/core.hpp
+opencv2/flann/defines.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/opencv2/flann/defines.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+params.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+any.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+iostream
+-
+map
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+algorithm
+-
+cstdlib
+-
+vector
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+algorithm
+-
+cstring
+-
+iostream
+-
+limits
+-
+set
+-
+vector
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+cstring
+-
+vector
+-
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+time.h
+-
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/opencv2/core.hpp
+opencv2/core/utility.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/opencv2/core/utility.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/imgcodecs.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/imgcodecs.hpp
+opencv2/videoio.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/videoio.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui/highgui.hpp
+opencv2/highgui.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui/opencv2/highgui.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+./imgproc/segmentation.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/imgproc.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/opencv2/imgproc.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/opencv2/imgproc.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+float.h
+-
+map
+-
+iostream
+-
+opencv2/ml/ml.inl.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/objdetect/detection_based_tracker.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/objdetect/detection_based_tracker.hpp
+opencv2/objdetect/face.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/objdetect/face.hpp
+opencv2/objdetect/aruco_detector.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/objdetect/aruco_detector.hpp
+opencv2/objdetect/charuco_detector.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/objdetect/charuco_detector.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+opencv2/core.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+opencv2/objdetect/aruco_dictionary.hpp
+-
+opencv2/objdetect/aruco_board.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+opencv2/core.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+opencv2/objdetect/aruco_detector.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/opencv2/objdetect/aruco_detector.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+opencv2/core.hpp
+-
+vector
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+opencv2/core.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/opencv_modules.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/calib3d.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/calib3d.hpp
+opencv2/features2d.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/features2d.hpp
+opencv2/dnn.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/dnn.hpp
+opencv2/flann.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/flann.hpp
+opencv2/highgui.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/highgui.hpp
+opencv2/imgcodecs.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/imgcodecs.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/imgproc.hpp
+opencv2/ml.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/ml.hpp
+opencv2/objdetect.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/objdetect.hpp
+opencv2/photo.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/photo.hpp
+opencv2/stitching.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching.hpp
+opencv2/video.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/video.hpp
+opencv2/videoio.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/videoio.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/imgproc.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/features2d.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/features2d.hpp
+opencv2/stitching/warpers.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/warpers.hpp
+opencv2/stitching/detail/matchers.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/matchers.hpp
+opencv2/stitching/detail/motion_estimators.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/motion_estimators.hpp
+opencv2/stitching/detail/exposure_compensate.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/exposure_compensate.hpp
+opencv2/stitching/detail/seam_finders.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/seam_finders.hpp
+opencv2/stitching/detail/blenders.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/blenders.hpp
+opencv2/stitching/detail/camera.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/camera.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+opencv2/core/cuda.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core/cuda.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+opencv2/features2d.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/features2d.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/opencv_modules.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+matchers.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+util.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+camera.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+set
+-
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/opencv_modules.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+list
+-
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+util_inl.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+queue
+-
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+util.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+opencv2/core/cuda.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core/cuda.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/imgproc.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/opencv_modules.hpp
+warpers_inl.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+warpers.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+limits
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+opencv2/stitching/detail/warpers.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/opencv2/stitching/detail/warpers.hpp
+string
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+opencv2/video/tracking.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/video/tracking.hpp
+opencv2/video/background_segm.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/video/background_segm.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/opencv2/core.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/opencv2/imgproc.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+
+/home/huey/openssl/install/include/openssl/asn1.h
+openssl/macros.h
+-
+stdio.h
+-
+time.h
+-
+openssl/e_os2.h
+-
+openssl/opensslconf.h
+-
+openssl/bio.h
+-
+openssl/safestack.h
+-
+openssl/asn1err.h
+-
+openssl/symhacks.h
+-
+openssl/types.h
+-
+openssl/bn.h
+-
+
+/home/huey/openssl/install/include/openssl/asn1err.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/bio.h
+openssl/macros.h
+-
+openssl/e_os2.h
+-
+stdio.h
+-
+stdarg.h
+-
+openssl/crypto.h
+-
+openssl/bioerr.h
+-
+openssl/core.h
+-
+
+/home/huey/openssl/install/include/openssl/bioerr.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/bn.h
+openssl/macros.h
+-
+openssl/e_os2.h
+-
+stdio.h
+-
+openssl/opensslconf.h
+-
+openssl/types.h
+-
+openssl/crypto.h
+-
+openssl/bnerr.h
+-
+
+/home/huey/openssl/install/include/openssl/bnerr.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/configuration.h
+
+/home/huey/openssl/install/include/openssl/core.h
+stddef.h
+-
+openssl/types.h
+-
+
+/home/huey/openssl/install/include/openssl/core_dispatch.h
+stdarg.h
+-
+openssl/core.h
+-
+
+/home/huey/openssl/install/include/openssl/crypto.h
+openssl/macros.h
+-
+stdlib.h
+-
+time.h
+-
+openssl/e_os2.h
+-
+stdio.h
+-
+openssl/safestack.h
+-
+openssl/opensslv.h
+-
+openssl/types.h
+-
+openssl/opensslconf.h
+-
+openssl/cryptoerr.h
+-
+openssl/core.h
+-
+openssl/ebcdic.h
+-
+openssl/symhacks.h
+-
+openssl/opensslv.h
+-
+spthread.h
+-
+pthread.h
+-
+
+/home/huey/openssl/install/include/openssl/cryptoerr.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/cryptoerr_legacy.h
+openssl/macros.h
+-
+openssl/symhacks.h
+-
+
+/home/huey/openssl/install/include/openssl/e_os2.h
+openssl/macros.h
+-
+openssl/opensslconf.h
+-
+strings.h
+-
+spthread.h
+-
+pthread.h
+-
+sys/types.h
+-
+inttypes.h
+-
+stdint.h
+-
+sys/types.h
+-
+stdint.h
+-
+
+/home/huey/openssl/install/include/openssl/ebcdic.h
+openssl/macros.h
+-
+stdlib.h
+-
+
+/home/huey/openssl/install/include/openssl/evp.h
+openssl/macros.h
+-
+stdarg.h
+-
+stdio.h
+-
+openssl/opensslconf.h
+-
+openssl/types.h
+-
+openssl/core.h
+-
+openssl/core_dispatch.h
+-
+openssl/symhacks.h
+-
+openssl/bio.h
+-
+openssl/evperr.h
+-
+openssl/params.h
+-
+openssl/objects.h
+-
+
+/home/huey/openssl/install/include/openssl/evperr.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/macros.h
+openssl/opensslconf.h
+-
+openssl/opensslv.h
+-
+
+/home/huey/openssl/install/include/openssl/obj_mac.h
+
+/home/huey/openssl/install/include/openssl/objects.h
+openssl/macros.h
+-
+openssl/obj_mac.h
+-
+openssl/bio.h
+-
+openssl/asn1.h
+-
+openssl/objectserr.h
+-
+
+/home/huey/openssl/install/include/openssl/objectserr.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/opensslconf.h
+openssl/configuration.h
+-
+openssl/macros.h
+-
+
+/home/huey/openssl/install/include/openssl/opensslv.h
+openssl/macros.h
+-
+
+/home/huey/openssl/install/include/openssl/params.h
+openssl/core.h
+-
+openssl/bn.h
+-
+
+/home/huey/openssl/install/include/openssl/safestack.h
+openssl/macros.h
+-
+openssl/stack.h
+-
+openssl/e_os2.h
+-
+
+/home/huey/openssl/install/include/openssl/sha.h
+openssl/macros.h
+-
+openssl/e_os2.h
+-
+stddef.h
+-
+
+/home/huey/openssl/install/include/openssl/stack.h
+openssl/macros.h
+-
+
+/home/huey/openssl/install/include/openssl/symhacks.h
+openssl/macros.h
+-
+openssl/e_os2.h
+-
+
+/home/huey/openssl/install/include/openssl/types.h
+limits.h
+-
+openssl/e_os2.h
+-
+openssl/safestack.h
+-
+openssl/macros.h
+-
+
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/DependInfo.cmake b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/DependInfo.cmake
new file mode 100644
index 00000000..303ce9db
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/DependInfo.cmake
@@ -0,0 +1,31 @@
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  "CXX"
+  )
+# The set of files for implicit dependencies of each language:
+set(CMAKE_DEPENDS_CHECK_CXX
+  "/home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o"
+  "/home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o"
+  "/home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o"
+  "/home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o"
+  "/home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o"
+  "/home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o"
+  )
+set(CMAKE_CXX_COMPILER_ID "GNU")
+
+# The include file search paths:
+set(CMAKE_CXX_TARGET_INCLUDE_PATH
+  "/home/huey/openssl/install/include"
+  "../include"
+  "../3rdparty/librknn_api/include"
+  "../3rdparty/rga/include"
+  "/home/huey/curl-8.8.0/install/include"
+  "/home/huey/opencv-4.7.0/install/include/opencv4"
+  )
+
+# Targets to which this target links.
+set(CMAKE_TARGET_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/build.make b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/build.make
new file mode 100644
index 00000000..e741ce4b
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/build.make
@@ -0,0 +1,230 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+
+# Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+
+# A target that is always out of date.
+cmake_force:
+
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E remove -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/huey/Desktop/C/yolo_bytetrack
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/huey/Desktop/C/yolo_bytetrack/build
+
+# Include any dependencies generated for this target.
+include CMakeFiles/yolo_bytetrack.dir/depend.make
+
+# Include the progress variables for this target.
+include CMakeFiles/yolo_bytetrack.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include CMakeFiles/yolo_bytetrack.dir/flags.make
+
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../src/bytetrack.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp > CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp -o CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.s
+
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../src/BYTETracker.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp > CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp -o CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.s
+
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../src/kalmanFilter.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp > CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp -o CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.s
+
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o: ../src/lapjv.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp > CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp -o CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.s
+
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../src/STrack.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp > CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp -o CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.s
+
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../src/utils.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp > CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp -o CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.s
+
+# Object files for target yolo_bytetrack
+yolo_bytetrack_OBJECTS = \
+"CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o" \
+"CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o" \
+"CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o" \
+"CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o" \
+"CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o" \
+"CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o"
+
+# External object files for target yolo_bytetrack
+yolo_bytetrack_EXTERNAL_OBJECTS =
+
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/build.make
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_gapi.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_stitching.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_aruco.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_barcode.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_bgsegm.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_bioinspired.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_ccalib.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_dnn_objdetect.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_dnn_superres.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_dpm.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_face.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_fuzzy.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_hfs.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_img_hash.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_intensity_transform.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_line_descriptor.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_mcc.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_quality.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_rapid.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_reg.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_rgbd.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_saliency.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_stereo.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_structured_light.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_superres.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_surface_matching.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_tracking.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_videostab.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_wechat_qrcode.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_xfeatures2d.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_xobjdetect.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_xphoto.so.4.7.0
+yolo_bytetrack: /home/huey/openssl/install/lib/libssl.so
+yolo_bytetrack: /home/huey/openssl/install/lib/libcrypto.so
+yolo_bytetrack: /home/huey/curl-8.8.0/install/lib/libcurl.a
+yolo_bytetrack: ../3rdparty/librknn_api/armhf/librknn_api.so
+yolo_bytetrack: ../3rdparty/rga/lib/librga.so
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_shape.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_highgui.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_datasets.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_plot.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_text.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_ml.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_phase_unwrapping.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_optflow.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_ximgproc.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_video.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_videoio.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_imgcodecs.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_objdetect.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_calib3d.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_dnn.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_features2d.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_flann.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_photo.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_imgproc.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_core.so.4.7.0
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/link.txt
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "Linking CXX executable yolo_bytetrack"
+	$(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/yolo_bytetrack.dir/link.txt --verbose=$(VERBOSE)
+
+# Rule to build all files generated by this target.
+CMakeFiles/yolo_bytetrack.dir/build: yolo_bytetrack
+
+.PHONY : CMakeFiles/yolo_bytetrack.dir/build
+
+CMakeFiles/yolo_bytetrack.dir/clean:
+	$(CMAKE_COMMAND) -P CMakeFiles/yolo_bytetrack.dir/cmake_clean.cmake
+.PHONY : CMakeFiles/yolo_bytetrack.dir/clean
+
+CMakeFiles/yolo_bytetrack.dir/depend:
+	cd /home/huey/Desktop/C/yolo_bytetrack/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/huey/Desktop/C/yolo_bytetrack /home/huey/Desktop/C/yolo_bytetrack /home/huey/Desktop/C/yolo_bytetrack/build /home/huey/Desktop/C/yolo_bytetrack/build /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/DependInfo.cmake --color=$(COLOR)
+.PHONY : CMakeFiles/yolo_bytetrack.dir/depend
+
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/cmake_clean.cmake b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/cmake_clean.cmake
new file mode 100644
index 00000000..25b21c2e
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/cmake_clean.cmake
@@ -0,0 +1,15 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o"
+  "CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o"
+  "CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o"
+  "CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o"
+  "CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o"
+  "CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o"
+  "yolo_bytetrack"
+  "yolo_bytetrack.pdb"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang CXX)
+  include(CMakeFiles/yolo_bytetrack.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/depend.internal b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/depend.internal
new file mode 100644
index 00000000..5c905d42
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/depend.internal
@@ -0,0 +1,1710 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o
+ ../include/BYTETracker.h
+ ../include/Eigen/Cholesky
+ ../include/Eigen/Core
+ ../include/Eigen/Dense
+ ../include/Eigen/Eigenvalues
+ ../include/Eigen/Geometry
+ ../include/Eigen/Householder
+ ../include/Eigen/Jacobi
+ ../include/Eigen/LU
+ ../include/Eigen/QR
+ ../include/Eigen/SVD
+ ../include/Eigen/src/Cholesky/LDLT.h
+ ../include/Eigen/src/Cholesky/LLT.h
+ ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+ ../include/Eigen/src/Core/ArithmeticSequence.h
+ ../include/Eigen/src/Core/Array.h
+ ../include/Eigen/src/Core/ArrayBase.h
+ ../include/Eigen/src/Core/ArrayWrapper.h
+ ../include/Eigen/src/Core/Assign.h
+ ../include/Eigen/src/Core/AssignEvaluator.h
+ ../include/Eigen/src/Core/Assign_MKL.h
+ ../include/Eigen/src/Core/BandMatrix.h
+ ../include/Eigen/src/Core/Block.h
+ ../include/Eigen/src/Core/BooleanRedux.h
+ ../include/Eigen/src/Core/CommaInitializer.h
+ ../include/Eigen/src/Core/ConditionEstimator.h
+ ../include/Eigen/src/Core/CoreEvaluators.h
+ ../include/Eigen/src/Core/CoreIterators.h
+ ../include/Eigen/src/Core/CwiseBinaryOp.h
+ ../include/Eigen/src/Core/CwiseNullaryOp.h
+ ../include/Eigen/src/Core/CwiseTernaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryView.h
+ ../include/Eigen/src/Core/DenseBase.h
+ ../include/Eigen/src/Core/DenseCoeffsBase.h
+ ../include/Eigen/src/Core/DenseStorage.h
+ ../include/Eigen/src/Core/Diagonal.h
+ ../include/Eigen/src/Core/DiagonalMatrix.h
+ ../include/Eigen/src/Core/DiagonalProduct.h
+ ../include/Eigen/src/Core/Dot.h
+ ../include/Eigen/src/Core/EigenBase.h
+ ../include/Eigen/src/Core/Fuzzy.h
+ ../include/Eigen/src/Core/GeneralProduct.h
+ ../include/Eigen/src/Core/GenericPacketMath.h
+ ../include/Eigen/src/Core/GlobalFunctions.h
+ ../include/Eigen/src/Core/IO.h
+ ../include/Eigen/src/Core/IndexedView.h
+ ../include/Eigen/src/Core/Inverse.h
+ ../include/Eigen/src/Core/Map.h
+ ../include/Eigen/src/Core/MapBase.h
+ ../include/Eigen/src/Core/MathFunctions.h
+ ../include/Eigen/src/Core/MathFunctionsImpl.h
+ ../include/Eigen/src/Core/Matrix.h
+ ../include/Eigen/src/Core/MatrixBase.h
+ ../include/Eigen/src/Core/NestByValue.h
+ ../include/Eigen/src/Core/NoAlias.h
+ ../include/Eigen/src/Core/NumTraits.h
+ ../include/Eigen/src/Core/PartialReduxEvaluator.h
+ ../include/Eigen/src/Core/PermutationMatrix.h
+ ../include/Eigen/src/Core/PlainObjectBase.h
+ ../include/Eigen/src/Core/Product.h
+ ../include/Eigen/src/Core/ProductEvaluators.h
+ ../include/Eigen/src/Core/Random.h
+ ../include/Eigen/src/Core/Redux.h
+ ../include/Eigen/src/Core/Ref.h
+ ../include/Eigen/src/Core/Replicate.h
+ ../include/Eigen/src/Core/Reshaped.h
+ ../include/Eigen/src/Core/ReturnByValue.h
+ ../include/Eigen/src/Core/Reverse.h
+ ../include/Eigen/src/Core/Select.h
+ ../include/Eigen/src/Core/SelfAdjointView.h
+ ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+ ../include/Eigen/src/Core/Solve.h
+ ../include/Eigen/src/Core/SolveTriangular.h
+ ../include/Eigen/src/Core/SolverBase.h
+ ../include/Eigen/src/Core/StableNorm.h
+ ../include/Eigen/src/Core/StlIterators.h
+ ../include/Eigen/src/Core/Stride.h
+ ../include/Eigen/src/Core/Swap.h
+ ../include/Eigen/src/Core/Transpose.h
+ ../include/Eigen/src/Core/Transpositions.h
+ ../include/Eigen/src/Core/TriangularMatrix.h
+ ../include/Eigen/src/Core/VectorBlock.h
+ ../include/Eigen/src/Core/VectorwiseOp.h
+ ../include/Eigen/src/Core/Visitor.h
+ ../include/Eigen/src/Core/arch/AVX/Complex.h
+ ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AVX512/Complex.h
+ ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+ ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+ ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+ ../include/Eigen/src/Core/arch/CUDA/Complex.h
+ ../include/Eigen/src/Core/arch/Default/BFloat16.h
+ ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+ ../include/Eigen/src/Core/arch/Default/Half.h
+ ../include/Eigen/src/Core/arch/Default/Settings.h
+ ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+ ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+ ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+ ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+ ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+ ../include/Eigen/src/Core/arch/MSA/Complex.h
+ ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+ ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/Complex.h
+ ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+ ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SSE/Complex.h
+ ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+ ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+ ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+ ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+ ../include/Eigen/src/Core/arch/ZVector/Complex.h
+ ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+ ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+ ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+ ../include/Eigen/src/Core/functors/BinaryFunctors.h
+ ../include/Eigen/src/Core/functors/NullaryFunctors.h
+ ../include/Eigen/src/Core/functors/StlFunctors.h
+ ../include/Eigen/src/Core/functors/TernaryFunctors.h
+ ../include/Eigen/src/Core/functors/UnaryFunctors.h
+ ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/Parallelizer.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointProduct.h
+ ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverVector.h
+ ../include/Eigen/src/Core/util/BlasUtil.h
+ ../include/Eigen/src/Core/util/ConfigureVectorization.h
+ ../include/Eigen/src/Core/util/Constants.h
+ ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ForwardDeclarations.h
+ ../include/Eigen/src/Core/util/IndexedViewHelper.h
+ ../include/Eigen/src/Core/util/IntegralConstant.h
+ ../include/Eigen/src/Core/util/MKL_support.h
+ ../include/Eigen/src/Core/util/Macros.h
+ ../include/Eigen/src/Core/util/Memory.h
+ ../include/Eigen/src/Core/util/Meta.h
+ ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ReshapedHelper.h
+ ../include/Eigen/src/Core/util/StaticAssert.h
+ ../include/Eigen/src/Core/util/SymbolicIndex.h
+ ../include/Eigen/src/Core/util/XprHelper.h
+ ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/EigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+ ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+ ../include/Eigen/src/Eigenvalues/RealQZ.h
+ ../include/Eigen/src/Eigenvalues/RealSchur.h
+ ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+ ../include/Eigen/src/Geometry/AlignedBox.h
+ ../include/Eigen/src/Geometry/AngleAxis.h
+ ../include/Eigen/src/Geometry/EulerAngles.h
+ ../include/Eigen/src/Geometry/Homogeneous.h
+ ../include/Eigen/src/Geometry/Hyperplane.h
+ ../include/Eigen/src/Geometry/OrthoMethods.h
+ ../include/Eigen/src/Geometry/ParametrizedLine.h
+ ../include/Eigen/src/Geometry/Quaternion.h
+ ../include/Eigen/src/Geometry/Rotation2D.h
+ ../include/Eigen/src/Geometry/RotationBase.h
+ ../include/Eigen/src/Geometry/Scaling.h
+ ../include/Eigen/src/Geometry/Transform.h
+ ../include/Eigen/src/Geometry/Translation.h
+ ../include/Eigen/src/Geometry/Umeyama.h
+ ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+ ../include/Eigen/src/Householder/BlockHouseholder.h
+ ../include/Eigen/src/Householder/Householder.h
+ ../include/Eigen/src/Householder/HouseholderSequence.h
+ ../include/Eigen/src/Jacobi/Jacobi.h
+ ../include/Eigen/src/LU/Determinant.h
+ ../include/Eigen/src/LU/FullPivLU.h
+ ../include/Eigen/src/LU/InverseImpl.h
+ ../include/Eigen/src/LU/PartialPivLU.h
+ ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+ ../include/Eigen/src/LU/arch/InverseSize4.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+ ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+ ../include/Eigen/src/QR/FullPivHouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+ ../include/Eigen/src/SVD/BDCSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+ ../include/Eigen/src/SVD/SVDBase.h
+ ../include/Eigen/src/SVD/UpperBidiagonalization.h
+ ../include/Eigen/src/misc/Image.h
+ ../include/Eigen/src/misc/Kernel.h
+ ../include/Eigen/src/misc/RealSvd2x2.h
+ ../include/Eigen/src/misc/blas.h
+ ../include/Eigen/src/misc/lapacke.h
+ ../include/Eigen/src/misc/lapacke_mangling.h
+ ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/BlockMethods.h
+ ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/IndexedViewMethods.h
+ ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/ReshapedMethods.h
+ ../include/STrack.h
+ ../include/dataType.h
+ ../include/kalmanFilter.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o
+ ../include/Eigen/Cholesky
+ ../include/Eigen/Core
+ ../include/Eigen/Dense
+ ../include/Eigen/Eigenvalues
+ ../include/Eigen/Geometry
+ ../include/Eigen/Householder
+ ../include/Eigen/Jacobi
+ ../include/Eigen/LU
+ ../include/Eigen/QR
+ ../include/Eigen/SVD
+ ../include/Eigen/src/Cholesky/LDLT.h
+ ../include/Eigen/src/Cholesky/LLT.h
+ ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+ ../include/Eigen/src/Core/ArithmeticSequence.h
+ ../include/Eigen/src/Core/Array.h
+ ../include/Eigen/src/Core/ArrayBase.h
+ ../include/Eigen/src/Core/ArrayWrapper.h
+ ../include/Eigen/src/Core/Assign.h
+ ../include/Eigen/src/Core/AssignEvaluator.h
+ ../include/Eigen/src/Core/Assign_MKL.h
+ ../include/Eigen/src/Core/BandMatrix.h
+ ../include/Eigen/src/Core/Block.h
+ ../include/Eigen/src/Core/BooleanRedux.h
+ ../include/Eigen/src/Core/CommaInitializer.h
+ ../include/Eigen/src/Core/ConditionEstimator.h
+ ../include/Eigen/src/Core/CoreEvaluators.h
+ ../include/Eigen/src/Core/CoreIterators.h
+ ../include/Eigen/src/Core/CwiseBinaryOp.h
+ ../include/Eigen/src/Core/CwiseNullaryOp.h
+ ../include/Eigen/src/Core/CwiseTernaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryView.h
+ ../include/Eigen/src/Core/DenseBase.h
+ ../include/Eigen/src/Core/DenseCoeffsBase.h
+ ../include/Eigen/src/Core/DenseStorage.h
+ ../include/Eigen/src/Core/Diagonal.h
+ ../include/Eigen/src/Core/DiagonalMatrix.h
+ ../include/Eigen/src/Core/DiagonalProduct.h
+ ../include/Eigen/src/Core/Dot.h
+ ../include/Eigen/src/Core/EigenBase.h
+ ../include/Eigen/src/Core/Fuzzy.h
+ ../include/Eigen/src/Core/GeneralProduct.h
+ ../include/Eigen/src/Core/GenericPacketMath.h
+ ../include/Eigen/src/Core/GlobalFunctions.h
+ ../include/Eigen/src/Core/IO.h
+ ../include/Eigen/src/Core/IndexedView.h
+ ../include/Eigen/src/Core/Inverse.h
+ ../include/Eigen/src/Core/Map.h
+ ../include/Eigen/src/Core/MapBase.h
+ ../include/Eigen/src/Core/MathFunctions.h
+ ../include/Eigen/src/Core/MathFunctionsImpl.h
+ ../include/Eigen/src/Core/Matrix.h
+ ../include/Eigen/src/Core/MatrixBase.h
+ ../include/Eigen/src/Core/NestByValue.h
+ ../include/Eigen/src/Core/NoAlias.h
+ ../include/Eigen/src/Core/NumTraits.h
+ ../include/Eigen/src/Core/PartialReduxEvaluator.h
+ ../include/Eigen/src/Core/PermutationMatrix.h
+ ../include/Eigen/src/Core/PlainObjectBase.h
+ ../include/Eigen/src/Core/Product.h
+ ../include/Eigen/src/Core/ProductEvaluators.h
+ ../include/Eigen/src/Core/Random.h
+ ../include/Eigen/src/Core/Redux.h
+ ../include/Eigen/src/Core/Ref.h
+ ../include/Eigen/src/Core/Replicate.h
+ ../include/Eigen/src/Core/Reshaped.h
+ ../include/Eigen/src/Core/ReturnByValue.h
+ ../include/Eigen/src/Core/Reverse.h
+ ../include/Eigen/src/Core/Select.h
+ ../include/Eigen/src/Core/SelfAdjointView.h
+ ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+ ../include/Eigen/src/Core/Solve.h
+ ../include/Eigen/src/Core/SolveTriangular.h
+ ../include/Eigen/src/Core/SolverBase.h
+ ../include/Eigen/src/Core/StableNorm.h
+ ../include/Eigen/src/Core/StlIterators.h
+ ../include/Eigen/src/Core/Stride.h
+ ../include/Eigen/src/Core/Swap.h
+ ../include/Eigen/src/Core/Transpose.h
+ ../include/Eigen/src/Core/Transpositions.h
+ ../include/Eigen/src/Core/TriangularMatrix.h
+ ../include/Eigen/src/Core/VectorBlock.h
+ ../include/Eigen/src/Core/VectorwiseOp.h
+ ../include/Eigen/src/Core/Visitor.h
+ ../include/Eigen/src/Core/arch/AVX/Complex.h
+ ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AVX512/Complex.h
+ ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+ ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+ ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+ ../include/Eigen/src/Core/arch/CUDA/Complex.h
+ ../include/Eigen/src/Core/arch/Default/BFloat16.h
+ ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+ ../include/Eigen/src/Core/arch/Default/Half.h
+ ../include/Eigen/src/Core/arch/Default/Settings.h
+ ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+ ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+ ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+ ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+ ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+ ../include/Eigen/src/Core/arch/MSA/Complex.h
+ ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+ ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/Complex.h
+ ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+ ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SSE/Complex.h
+ ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+ ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+ ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+ ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+ ../include/Eigen/src/Core/arch/ZVector/Complex.h
+ ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+ ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+ ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+ ../include/Eigen/src/Core/functors/BinaryFunctors.h
+ ../include/Eigen/src/Core/functors/NullaryFunctors.h
+ ../include/Eigen/src/Core/functors/StlFunctors.h
+ ../include/Eigen/src/Core/functors/TernaryFunctors.h
+ ../include/Eigen/src/Core/functors/UnaryFunctors.h
+ ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/Parallelizer.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointProduct.h
+ ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverVector.h
+ ../include/Eigen/src/Core/util/BlasUtil.h
+ ../include/Eigen/src/Core/util/ConfigureVectorization.h
+ ../include/Eigen/src/Core/util/Constants.h
+ ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ForwardDeclarations.h
+ ../include/Eigen/src/Core/util/IndexedViewHelper.h
+ ../include/Eigen/src/Core/util/IntegralConstant.h
+ ../include/Eigen/src/Core/util/MKL_support.h
+ ../include/Eigen/src/Core/util/Macros.h
+ ../include/Eigen/src/Core/util/Memory.h
+ ../include/Eigen/src/Core/util/Meta.h
+ ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ReshapedHelper.h
+ ../include/Eigen/src/Core/util/StaticAssert.h
+ ../include/Eigen/src/Core/util/SymbolicIndex.h
+ ../include/Eigen/src/Core/util/XprHelper.h
+ ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/EigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+ ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+ ../include/Eigen/src/Eigenvalues/RealQZ.h
+ ../include/Eigen/src/Eigenvalues/RealSchur.h
+ ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+ ../include/Eigen/src/Geometry/AlignedBox.h
+ ../include/Eigen/src/Geometry/AngleAxis.h
+ ../include/Eigen/src/Geometry/EulerAngles.h
+ ../include/Eigen/src/Geometry/Homogeneous.h
+ ../include/Eigen/src/Geometry/Hyperplane.h
+ ../include/Eigen/src/Geometry/OrthoMethods.h
+ ../include/Eigen/src/Geometry/ParametrizedLine.h
+ ../include/Eigen/src/Geometry/Quaternion.h
+ ../include/Eigen/src/Geometry/Rotation2D.h
+ ../include/Eigen/src/Geometry/RotationBase.h
+ ../include/Eigen/src/Geometry/Scaling.h
+ ../include/Eigen/src/Geometry/Transform.h
+ ../include/Eigen/src/Geometry/Translation.h
+ ../include/Eigen/src/Geometry/Umeyama.h
+ ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+ ../include/Eigen/src/Householder/BlockHouseholder.h
+ ../include/Eigen/src/Householder/Householder.h
+ ../include/Eigen/src/Householder/HouseholderSequence.h
+ ../include/Eigen/src/Jacobi/Jacobi.h
+ ../include/Eigen/src/LU/Determinant.h
+ ../include/Eigen/src/LU/FullPivLU.h
+ ../include/Eigen/src/LU/InverseImpl.h
+ ../include/Eigen/src/LU/PartialPivLU.h
+ ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+ ../include/Eigen/src/LU/arch/InverseSize4.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+ ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+ ../include/Eigen/src/QR/FullPivHouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+ ../include/Eigen/src/SVD/BDCSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+ ../include/Eigen/src/SVD/SVDBase.h
+ ../include/Eigen/src/SVD/UpperBidiagonalization.h
+ ../include/Eigen/src/misc/Image.h
+ ../include/Eigen/src/misc/Kernel.h
+ ../include/Eigen/src/misc/RealSvd2x2.h
+ ../include/Eigen/src/misc/blas.h
+ ../include/Eigen/src/misc/lapacke.h
+ ../include/Eigen/src/misc/lapacke_mangling.h
+ ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/BlockMethods.h
+ ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/IndexedViewMethods.h
+ ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/ReshapedMethods.h
+ ../include/STrack.h
+ ../include/dataType.h
+ ../include/kalmanFilter.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o
+ ../3rdparty/librknn_api/include/rknn_api.h
+ ../include/BYTETracker.h
+ ../include/Eigen/Cholesky
+ ../include/Eigen/Core
+ ../include/Eigen/Dense
+ ../include/Eigen/Eigenvalues
+ ../include/Eigen/Geometry
+ ../include/Eigen/Householder
+ ../include/Eigen/Jacobi
+ ../include/Eigen/LU
+ ../include/Eigen/QR
+ ../include/Eigen/SVD
+ ../include/Eigen/src/Cholesky/LDLT.h
+ ../include/Eigen/src/Cholesky/LLT.h
+ ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+ ../include/Eigen/src/Core/ArithmeticSequence.h
+ ../include/Eigen/src/Core/Array.h
+ ../include/Eigen/src/Core/ArrayBase.h
+ ../include/Eigen/src/Core/ArrayWrapper.h
+ ../include/Eigen/src/Core/Assign.h
+ ../include/Eigen/src/Core/AssignEvaluator.h
+ ../include/Eigen/src/Core/Assign_MKL.h
+ ../include/Eigen/src/Core/BandMatrix.h
+ ../include/Eigen/src/Core/Block.h
+ ../include/Eigen/src/Core/BooleanRedux.h
+ ../include/Eigen/src/Core/CommaInitializer.h
+ ../include/Eigen/src/Core/ConditionEstimator.h
+ ../include/Eigen/src/Core/CoreEvaluators.h
+ ../include/Eigen/src/Core/CoreIterators.h
+ ../include/Eigen/src/Core/CwiseBinaryOp.h
+ ../include/Eigen/src/Core/CwiseNullaryOp.h
+ ../include/Eigen/src/Core/CwiseTernaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryView.h
+ ../include/Eigen/src/Core/DenseBase.h
+ ../include/Eigen/src/Core/DenseCoeffsBase.h
+ ../include/Eigen/src/Core/DenseStorage.h
+ ../include/Eigen/src/Core/Diagonal.h
+ ../include/Eigen/src/Core/DiagonalMatrix.h
+ ../include/Eigen/src/Core/DiagonalProduct.h
+ ../include/Eigen/src/Core/Dot.h
+ ../include/Eigen/src/Core/EigenBase.h
+ ../include/Eigen/src/Core/Fuzzy.h
+ ../include/Eigen/src/Core/GeneralProduct.h
+ ../include/Eigen/src/Core/GenericPacketMath.h
+ ../include/Eigen/src/Core/GlobalFunctions.h
+ ../include/Eigen/src/Core/IO.h
+ ../include/Eigen/src/Core/IndexedView.h
+ ../include/Eigen/src/Core/Inverse.h
+ ../include/Eigen/src/Core/Map.h
+ ../include/Eigen/src/Core/MapBase.h
+ ../include/Eigen/src/Core/MathFunctions.h
+ ../include/Eigen/src/Core/MathFunctionsImpl.h
+ ../include/Eigen/src/Core/Matrix.h
+ ../include/Eigen/src/Core/MatrixBase.h
+ ../include/Eigen/src/Core/NestByValue.h
+ ../include/Eigen/src/Core/NoAlias.h
+ ../include/Eigen/src/Core/NumTraits.h
+ ../include/Eigen/src/Core/PartialReduxEvaluator.h
+ ../include/Eigen/src/Core/PermutationMatrix.h
+ ../include/Eigen/src/Core/PlainObjectBase.h
+ ../include/Eigen/src/Core/Product.h
+ ../include/Eigen/src/Core/ProductEvaluators.h
+ ../include/Eigen/src/Core/Random.h
+ ../include/Eigen/src/Core/Redux.h
+ ../include/Eigen/src/Core/Ref.h
+ ../include/Eigen/src/Core/Replicate.h
+ ../include/Eigen/src/Core/Reshaped.h
+ ../include/Eigen/src/Core/ReturnByValue.h
+ ../include/Eigen/src/Core/Reverse.h
+ ../include/Eigen/src/Core/Select.h
+ ../include/Eigen/src/Core/SelfAdjointView.h
+ ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+ ../include/Eigen/src/Core/Solve.h
+ ../include/Eigen/src/Core/SolveTriangular.h
+ ../include/Eigen/src/Core/SolverBase.h
+ ../include/Eigen/src/Core/StableNorm.h
+ ../include/Eigen/src/Core/StlIterators.h
+ ../include/Eigen/src/Core/Stride.h
+ ../include/Eigen/src/Core/Swap.h
+ ../include/Eigen/src/Core/Transpose.h
+ ../include/Eigen/src/Core/Transpositions.h
+ ../include/Eigen/src/Core/TriangularMatrix.h
+ ../include/Eigen/src/Core/VectorBlock.h
+ ../include/Eigen/src/Core/VectorwiseOp.h
+ ../include/Eigen/src/Core/Visitor.h
+ ../include/Eigen/src/Core/arch/AVX/Complex.h
+ ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AVX512/Complex.h
+ ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+ ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+ ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+ ../include/Eigen/src/Core/arch/CUDA/Complex.h
+ ../include/Eigen/src/Core/arch/Default/BFloat16.h
+ ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+ ../include/Eigen/src/Core/arch/Default/Half.h
+ ../include/Eigen/src/Core/arch/Default/Settings.h
+ ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+ ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+ ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+ ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+ ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+ ../include/Eigen/src/Core/arch/MSA/Complex.h
+ ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+ ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/Complex.h
+ ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+ ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SSE/Complex.h
+ ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+ ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+ ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+ ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+ ../include/Eigen/src/Core/arch/ZVector/Complex.h
+ ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+ ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+ ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+ ../include/Eigen/src/Core/functors/BinaryFunctors.h
+ ../include/Eigen/src/Core/functors/NullaryFunctors.h
+ ../include/Eigen/src/Core/functors/StlFunctors.h
+ ../include/Eigen/src/Core/functors/TernaryFunctors.h
+ ../include/Eigen/src/Core/functors/UnaryFunctors.h
+ ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/Parallelizer.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointProduct.h
+ ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverVector.h
+ ../include/Eigen/src/Core/util/BlasUtil.h
+ ../include/Eigen/src/Core/util/ConfigureVectorization.h
+ ../include/Eigen/src/Core/util/Constants.h
+ ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ForwardDeclarations.h
+ ../include/Eigen/src/Core/util/IndexedViewHelper.h
+ ../include/Eigen/src/Core/util/IntegralConstant.h
+ ../include/Eigen/src/Core/util/MKL_support.h
+ ../include/Eigen/src/Core/util/Macros.h
+ ../include/Eigen/src/Core/util/Memory.h
+ ../include/Eigen/src/Core/util/Meta.h
+ ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ReshapedHelper.h
+ ../include/Eigen/src/Core/util/StaticAssert.h
+ ../include/Eigen/src/Core/util/SymbolicIndex.h
+ ../include/Eigen/src/Core/util/XprHelper.h
+ ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/EigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+ ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+ ../include/Eigen/src/Eigenvalues/RealQZ.h
+ ../include/Eigen/src/Eigenvalues/RealSchur.h
+ ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+ ../include/Eigen/src/Geometry/AlignedBox.h
+ ../include/Eigen/src/Geometry/AngleAxis.h
+ ../include/Eigen/src/Geometry/EulerAngles.h
+ ../include/Eigen/src/Geometry/Homogeneous.h
+ ../include/Eigen/src/Geometry/Hyperplane.h
+ ../include/Eigen/src/Geometry/OrthoMethods.h
+ ../include/Eigen/src/Geometry/ParametrizedLine.h
+ ../include/Eigen/src/Geometry/Quaternion.h
+ ../include/Eigen/src/Geometry/Rotation2D.h
+ ../include/Eigen/src/Geometry/RotationBase.h
+ ../include/Eigen/src/Geometry/Scaling.h
+ ../include/Eigen/src/Geometry/Transform.h
+ ../include/Eigen/src/Geometry/Translation.h
+ ../include/Eigen/src/Geometry/Umeyama.h
+ ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+ ../include/Eigen/src/Householder/BlockHouseholder.h
+ ../include/Eigen/src/Householder/Householder.h
+ ../include/Eigen/src/Householder/HouseholderSequence.h
+ ../include/Eigen/src/Jacobi/Jacobi.h
+ ../include/Eigen/src/LU/Determinant.h
+ ../include/Eigen/src/LU/FullPivLU.h
+ ../include/Eigen/src/LU/InverseImpl.h
+ ../include/Eigen/src/LU/PartialPivLU.h
+ ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+ ../include/Eigen/src/LU/arch/InverseSize4.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+ ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+ ../include/Eigen/src/QR/FullPivHouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+ ../include/Eigen/src/SVD/BDCSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+ ../include/Eigen/src/SVD/SVDBase.h
+ ../include/Eigen/src/SVD/UpperBidiagonalization.h
+ ../include/Eigen/src/misc/Image.h
+ ../include/Eigen/src/misc/Kernel.h
+ ../include/Eigen/src/misc/RealSvd2x2.h
+ ../include/Eigen/src/misc/blas.h
+ ../include/Eigen/src/misc/lapacke.h
+ ../include/Eigen/src/misc/lapacke_mangling.h
+ ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/BlockMethods.h
+ ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/IndexedViewMethods.h
+ ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/ReshapedMethods.h
+ ../include/STrack.h
+ ../include/dataType.h
+ ../include/kalmanFilter.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp
+ /home/huey/curl-8.8.0/install/include/curl/curl.h
+ /home/huey/curl-8.8.0/install/include/curl/curlver.h
+ /home/huey/curl-8.8.0/install/include/curl/easy.h
+ /home/huey/curl-8.8.0/install/include/curl/header.h
+ /home/huey/curl-8.8.0/install/include/curl/mprintf.h
+ /home/huey/curl-8.8.0/install/include/curl/multi.h
+ /home/huey/curl-8.8.0/install/include/curl/options.h
+ /home/huey/curl-8.8.0/install/include/curl/system.h
+ /home/huey/curl-8.8.0/install/include/curl/typecheck-gcc.h
+ /home/huey/curl-8.8.0/install/include/curl/urlapi.h
+ /home/huey/curl-8.8.0/install/include/curl/websockets.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/core.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui/highgui.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/imgproc.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+ /home/huey/openssl/install/include/openssl/asn1.h
+ /home/huey/openssl/install/include/openssl/asn1err.h
+ /home/huey/openssl/install/include/openssl/bio.h
+ /home/huey/openssl/install/include/openssl/bioerr.h
+ /home/huey/openssl/install/include/openssl/bn.h
+ /home/huey/openssl/install/include/openssl/bnerr.h
+ /home/huey/openssl/install/include/openssl/configuration.h
+ /home/huey/openssl/install/include/openssl/core.h
+ /home/huey/openssl/install/include/openssl/core_dispatch.h
+ /home/huey/openssl/install/include/openssl/crypto.h
+ /home/huey/openssl/install/include/openssl/cryptoerr.h
+ /home/huey/openssl/install/include/openssl/cryptoerr_legacy.h
+ /home/huey/openssl/install/include/openssl/e_os2.h
+ /home/huey/openssl/install/include/openssl/ebcdic.h
+ /home/huey/openssl/install/include/openssl/evp.h
+ /home/huey/openssl/install/include/openssl/evperr.h
+ /home/huey/openssl/install/include/openssl/macros.h
+ /home/huey/openssl/install/include/openssl/obj_mac.h
+ /home/huey/openssl/install/include/openssl/objects.h
+ /home/huey/openssl/install/include/openssl/objectserr.h
+ /home/huey/openssl/install/include/openssl/opensslconf.h
+ /home/huey/openssl/install/include/openssl/opensslv.h
+ /home/huey/openssl/install/include/openssl/params.h
+ /home/huey/openssl/install/include/openssl/safestack.h
+ /home/huey/openssl/install/include/openssl/sha.h
+ /home/huey/openssl/install/include/openssl/stack.h
+ /home/huey/openssl/install/include/openssl/symhacks.h
+ /home/huey/openssl/install/include/openssl/types.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o
+ ../include/Eigen/Cholesky
+ ../include/Eigen/Core
+ ../include/Eigen/Dense
+ ../include/Eigen/Eigenvalues
+ ../include/Eigen/Geometry
+ ../include/Eigen/Householder
+ ../include/Eigen/Jacobi
+ ../include/Eigen/LU
+ ../include/Eigen/QR
+ ../include/Eigen/SVD
+ ../include/Eigen/src/Cholesky/LDLT.h
+ ../include/Eigen/src/Cholesky/LLT.h
+ ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+ ../include/Eigen/src/Core/ArithmeticSequence.h
+ ../include/Eigen/src/Core/Array.h
+ ../include/Eigen/src/Core/ArrayBase.h
+ ../include/Eigen/src/Core/ArrayWrapper.h
+ ../include/Eigen/src/Core/Assign.h
+ ../include/Eigen/src/Core/AssignEvaluator.h
+ ../include/Eigen/src/Core/Assign_MKL.h
+ ../include/Eigen/src/Core/BandMatrix.h
+ ../include/Eigen/src/Core/Block.h
+ ../include/Eigen/src/Core/BooleanRedux.h
+ ../include/Eigen/src/Core/CommaInitializer.h
+ ../include/Eigen/src/Core/ConditionEstimator.h
+ ../include/Eigen/src/Core/CoreEvaluators.h
+ ../include/Eigen/src/Core/CoreIterators.h
+ ../include/Eigen/src/Core/CwiseBinaryOp.h
+ ../include/Eigen/src/Core/CwiseNullaryOp.h
+ ../include/Eigen/src/Core/CwiseTernaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryView.h
+ ../include/Eigen/src/Core/DenseBase.h
+ ../include/Eigen/src/Core/DenseCoeffsBase.h
+ ../include/Eigen/src/Core/DenseStorage.h
+ ../include/Eigen/src/Core/Diagonal.h
+ ../include/Eigen/src/Core/DiagonalMatrix.h
+ ../include/Eigen/src/Core/DiagonalProduct.h
+ ../include/Eigen/src/Core/Dot.h
+ ../include/Eigen/src/Core/EigenBase.h
+ ../include/Eigen/src/Core/Fuzzy.h
+ ../include/Eigen/src/Core/GeneralProduct.h
+ ../include/Eigen/src/Core/GenericPacketMath.h
+ ../include/Eigen/src/Core/GlobalFunctions.h
+ ../include/Eigen/src/Core/IO.h
+ ../include/Eigen/src/Core/IndexedView.h
+ ../include/Eigen/src/Core/Inverse.h
+ ../include/Eigen/src/Core/Map.h
+ ../include/Eigen/src/Core/MapBase.h
+ ../include/Eigen/src/Core/MathFunctions.h
+ ../include/Eigen/src/Core/MathFunctionsImpl.h
+ ../include/Eigen/src/Core/Matrix.h
+ ../include/Eigen/src/Core/MatrixBase.h
+ ../include/Eigen/src/Core/NestByValue.h
+ ../include/Eigen/src/Core/NoAlias.h
+ ../include/Eigen/src/Core/NumTraits.h
+ ../include/Eigen/src/Core/PartialReduxEvaluator.h
+ ../include/Eigen/src/Core/PermutationMatrix.h
+ ../include/Eigen/src/Core/PlainObjectBase.h
+ ../include/Eigen/src/Core/Product.h
+ ../include/Eigen/src/Core/ProductEvaluators.h
+ ../include/Eigen/src/Core/Random.h
+ ../include/Eigen/src/Core/Redux.h
+ ../include/Eigen/src/Core/Ref.h
+ ../include/Eigen/src/Core/Replicate.h
+ ../include/Eigen/src/Core/Reshaped.h
+ ../include/Eigen/src/Core/ReturnByValue.h
+ ../include/Eigen/src/Core/Reverse.h
+ ../include/Eigen/src/Core/Select.h
+ ../include/Eigen/src/Core/SelfAdjointView.h
+ ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+ ../include/Eigen/src/Core/Solve.h
+ ../include/Eigen/src/Core/SolveTriangular.h
+ ../include/Eigen/src/Core/SolverBase.h
+ ../include/Eigen/src/Core/StableNorm.h
+ ../include/Eigen/src/Core/StlIterators.h
+ ../include/Eigen/src/Core/Stride.h
+ ../include/Eigen/src/Core/Swap.h
+ ../include/Eigen/src/Core/Transpose.h
+ ../include/Eigen/src/Core/Transpositions.h
+ ../include/Eigen/src/Core/TriangularMatrix.h
+ ../include/Eigen/src/Core/VectorBlock.h
+ ../include/Eigen/src/Core/VectorwiseOp.h
+ ../include/Eigen/src/Core/Visitor.h
+ ../include/Eigen/src/Core/arch/AVX/Complex.h
+ ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AVX512/Complex.h
+ ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+ ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+ ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+ ../include/Eigen/src/Core/arch/CUDA/Complex.h
+ ../include/Eigen/src/Core/arch/Default/BFloat16.h
+ ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+ ../include/Eigen/src/Core/arch/Default/Half.h
+ ../include/Eigen/src/Core/arch/Default/Settings.h
+ ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+ ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+ ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+ ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+ ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+ ../include/Eigen/src/Core/arch/MSA/Complex.h
+ ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+ ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/Complex.h
+ ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+ ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SSE/Complex.h
+ ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+ ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+ ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+ ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+ ../include/Eigen/src/Core/arch/ZVector/Complex.h
+ ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+ ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+ ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+ ../include/Eigen/src/Core/functors/BinaryFunctors.h
+ ../include/Eigen/src/Core/functors/NullaryFunctors.h
+ ../include/Eigen/src/Core/functors/StlFunctors.h
+ ../include/Eigen/src/Core/functors/TernaryFunctors.h
+ ../include/Eigen/src/Core/functors/UnaryFunctors.h
+ ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/Parallelizer.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointProduct.h
+ ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverVector.h
+ ../include/Eigen/src/Core/util/BlasUtil.h
+ ../include/Eigen/src/Core/util/ConfigureVectorization.h
+ ../include/Eigen/src/Core/util/Constants.h
+ ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ForwardDeclarations.h
+ ../include/Eigen/src/Core/util/IndexedViewHelper.h
+ ../include/Eigen/src/Core/util/IntegralConstant.h
+ ../include/Eigen/src/Core/util/MKL_support.h
+ ../include/Eigen/src/Core/util/Macros.h
+ ../include/Eigen/src/Core/util/Memory.h
+ ../include/Eigen/src/Core/util/Meta.h
+ ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ReshapedHelper.h
+ ../include/Eigen/src/Core/util/StaticAssert.h
+ ../include/Eigen/src/Core/util/SymbolicIndex.h
+ ../include/Eigen/src/Core/util/XprHelper.h
+ ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/EigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+ ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+ ../include/Eigen/src/Eigenvalues/RealQZ.h
+ ../include/Eigen/src/Eigenvalues/RealSchur.h
+ ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+ ../include/Eigen/src/Geometry/AlignedBox.h
+ ../include/Eigen/src/Geometry/AngleAxis.h
+ ../include/Eigen/src/Geometry/EulerAngles.h
+ ../include/Eigen/src/Geometry/Homogeneous.h
+ ../include/Eigen/src/Geometry/Hyperplane.h
+ ../include/Eigen/src/Geometry/OrthoMethods.h
+ ../include/Eigen/src/Geometry/ParametrizedLine.h
+ ../include/Eigen/src/Geometry/Quaternion.h
+ ../include/Eigen/src/Geometry/Rotation2D.h
+ ../include/Eigen/src/Geometry/RotationBase.h
+ ../include/Eigen/src/Geometry/Scaling.h
+ ../include/Eigen/src/Geometry/Transform.h
+ ../include/Eigen/src/Geometry/Translation.h
+ ../include/Eigen/src/Geometry/Umeyama.h
+ ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+ ../include/Eigen/src/Householder/BlockHouseholder.h
+ ../include/Eigen/src/Householder/Householder.h
+ ../include/Eigen/src/Householder/HouseholderSequence.h
+ ../include/Eigen/src/Jacobi/Jacobi.h
+ ../include/Eigen/src/LU/Determinant.h
+ ../include/Eigen/src/LU/FullPivLU.h
+ ../include/Eigen/src/LU/InverseImpl.h
+ ../include/Eigen/src/LU/PartialPivLU.h
+ ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+ ../include/Eigen/src/LU/arch/InverseSize4.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+ ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+ ../include/Eigen/src/QR/FullPivHouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+ ../include/Eigen/src/SVD/BDCSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+ ../include/Eigen/src/SVD/SVDBase.h
+ ../include/Eigen/src/SVD/UpperBidiagonalization.h
+ ../include/Eigen/src/misc/Image.h
+ ../include/Eigen/src/misc/Kernel.h
+ ../include/Eigen/src/misc/RealSvd2x2.h
+ ../include/Eigen/src/misc/blas.h
+ ../include/Eigen/src/misc/lapacke.h
+ ../include/Eigen/src/misc/lapacke_mangling.h
+ ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/BlockMethods.h
+ ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/IndexedViewMethods.h
+ ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/ReshapedMethods.h
+ ../include/dataType.h
+ ../include/kalmanFilter.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o
+ ../include/lapjv.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o
+ ../include/BYTETracker.h
+ ../include/Eigen/Cholesky
+ ../include/Eigen/Core
+ ../include/Eigen/Dense
+ ../include/Eigen/Eigenvalues
+ ../include/Eigen/Geometry
+ ../include/Eigen/Householder
+ ../include/Eigen/Jacobi
+ ../include/Eigen/LU
+ ../include/Eigen/QR
+ ../include/Eigen/SVD
+ ../include/Eigen/src/Cholesky/LDLT.h
+ ../include/Eigen/src/Cholesky/LLT.h
+ ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+ ../include/Eigen/src/Core/ArithmeticSequence.h
+ ../include/Eigen/src/Core/Array.h
+ ../include/Eigen/src/Core/ArrayBase.h
+ ../include/Eigen/src/Core/ArrayWrapper.h
+ ../include/Eigen/src/Core/Assign.h
+ ../include/Eigen/src/Core/AssignEvaluator.h
+ ../include/Eigen/src/Core/Assign_MKL.h
+ ../include/Eigen/src/Core/BandMatrix.h
+ ../include/Eigen/src/Core/Block.h
+ ../include/Eigen/src/Core/BooleanRedux.h
+ ../include/Eigen/src/Core/CommaInitializer.h
+ ../include/Eigen/src/Core/ConditionEstimator.h
+ ../include/Eigen/src/Core/CoreEvaluators.h
+ ../include/Eigen/src/Core/CoreIterators.h
+ ../include/Eigen/src/Core/CwiseBinaryOp.h
+ ../include/Eigen/src/Core/CwiseNullaryOp.h
+ ../include/Eigen/src/Core/CwiseTernaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryView.h
+ ../include/Eigen/src/Core/DenseBase.h
+ ../include/Eigen/src/Core/DenseCoeffsBase.h
+ ../include/Eigen/src/Core/DenseStorage.h
+ ../include/Eigen/src/Core/Diagonal.h
+ ../include/Eigen/src/Core/DiagonalMatrix.h
+ ../include/Eigen/src/Core/DiagonalProduct.h
+ ../include/Eigen/src/Core/Dot.h
+ ../include/Eigen/src/Core/EigenBase.h
+ ../include/Eigen/src/Core/Fuzzy.h
+ ../include/Eigen/src/Core/GeneralProduct.h
+ ../include/Eigen/src/Core/GenericPacketMath.h
+ ../include/Eigen/src/Core/GlobalFunctions.h
+ ../include/Eigen/src/Core/IO.h
+ ../include/Eigen/src/Core/IndexedView.h
+ ../include/Eigen/src/Core/Inverse.h
+ ../include/Eigen/src/Core/Map.h
+ ../include/Eigen/src/Core/MapBase.h
+ ../include/Eigen/src/Core/MathFunctions.h
+ ../include/Eigen/src/Core/MathFunctionsImpl.h
+ ../include/Eigen/src/Core/Matrix.h
+ ../include/Eigen/src/Core/MatrixBase.h
+ ../include/Eigen/src/Core/NestByValue.h
+ ../include/Eigen/src/Core/NoAlias.h
+ ../include/Eigen/src/Core/NumTraits.h
+ ../include/Eigen/src/Core/PartialReduxEvaluator.h
+ ../include/Eigen/src/Core/PermutationMatrix.h
+ ../include/Eigen/src/Core/PlainObjectBase.h
+ ../include/Eigen/src/Core/Product.h
+ ../include/Eigen/src/Core/ProductEvaluators.h
+ ../include/Eigen/src/Core/Random.h
+ ../include/Eigen/src/Core/Redux.h
+ ../include/Eigen/src/Core/Ref.h
+ ../include/Eigen/src/Core/Replicate.h
+ ../include/Eigen/src/Core/Reshaped.h
+ ../include/Eigen/src/Core/ReturnByValue.h
+ ../include/Eigen/src/Core/Reverse.h
+ ../include/Eigen/src/Core/Select.h
+ ../include/Eigen/src/Core/SelfAdjointView.h
+ ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+ ../include/Eigen/src/Core/Solve.h
+ ../include/Eigen/src/Core/SolveTriangular.h
+ ../include/Eigen/src/Core/SolverBase.h
+ ../include/Eigen/src/Core/StableNorm.h
+ ../include/Eigen/src/Core/StlIterators.h
+ ../include/Eigen/src/Core/Stride.h
+ ../include/Eigen/src/Core/Swap.h
+ ../include/Eigen/src/Core/Transpose.h
+ ../include/Eigen/src/Core/Transpositions.h
+ ../include/Eigen/src/Core/TriangularMatrix.h
+ ../include/Eigen/src/Core/VectorBlock.h
+ ../include/Eigen/src/Core/VectorwiseOp.h
+ ../include/Eigen/src/Core/Visitor.h
+ ../include/Eigen/src/Core/arch/AVX/Complex.h
+ ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AVX512/Complex.h
+ ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+ ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+ ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+ ../include/Eigen/src/Core/arch/CUDA/Complex.h
+ ../include/Eigen/src/Core/arch/Default/BFloat16.h
+ ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+ ../include/Eigen/src/Core/arch/Default/Half.h
+ ../include/Eigen/src/Core/arch/Default/Settings.h
+ ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+ ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+ ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+ ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+ ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+ ../include/Eigen/src/Core/arch/MSA/Complex.h
+ ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+ ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/Complex.h
+ ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+ ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SSE/Complex.h
+ ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+ ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+ ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+ ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+ ../include/Eigen/src/Core/arch/ZVector/Complex.h
+ ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+ ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+ ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+ ../include/Eigen/src/Core/functors/BinaryFunctors.h
+ ../include/Eigen/src/Core/functors/NullaryFunctors.h
+ ../include/Eigen/src/Core/functors/StlFunctors.h
+ ../include/Eigen/src/Core/functors/TernaryFunctors.h
+ ../include/Eigen/src/Core/functors/UnaryFunctors.h
+ ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/Parallelizer.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointProduct.h
+ ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverVector.h
+ ../include/Eigen/src/Core/util/BlasUtil.h
+ ../include/Eigen/src/Core/util/ConfigureVectorization.h
+ ../include/Eigen/src/Core/util/Constants.h
+ ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ForwardDeclarations.h
+ ../include/Eigen/src/Core/util/IndexedViewHelper.h
+ ../include/Eigen/src/Core/util/IntegralConstant.h
+ ../include/Eigen/src/Core/util/MKL_support.h
+ ../include/Eigen/src/Core/util/Macros.h
+ ../include/Eigen/src/Core/util/Memory.h
+ ../include/Eigen/src/Core/util/Meta.h
+ ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ReshapedHelper.h
+ ../include/Eigen/src/Core/util/StaticAssert.h
+ ../include/Eigen/src/Core/util/SymbolicIndex.h
+ ../include/Eigen/src/Core/util/XprHelper.h
+ ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/EigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+ ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+ ../include/Eigen/src/Eigenvalues/RealQZ.h
+ ../include/Eigen/src/Eigenvalues/RealSchur.h
+ ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+ ../include/Eigen/src/Geometry/AlignedBox.h
+ ../include/Eigen/src/Geometry/AngleAxis.h
+ ../include/Eigen/src/Geometry/EulerAngles.h
+ ../include/Eigen/src/Geometry/Homogeneous.h
+ ../include/Eigen/src/Geometry/Hyperplane.h
+ ../include/Eigen/src/Geometry/OrthoMethods.h
+ ../include/Eigen/src/Geometry/ParametrizedLine.h
+ ../include/Eigen/src/Geometry/Quaternion.h
+ ../include/Eigen/src/Geometry/Rotation2D.h
+ ../include/Eigen/src/Geometry/RotationBase.h
+ ../include/Eigen/src/Geometry/Scaling.h
+ ../include/Eigen/src/Geometry/Transform.h
+ ../include/Eigen/src/Geometry/Translation.h
+ ../include/Eigen/src/Geometry/Umeyama.h
+ ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+ ../include/Eigen/src/Householder/BlockHouseholder.h
+ ../include/Eigen/src/Householder/Householder.h
+ ../include/Eigen/src/Householder/HouseholderSequence.h
+ ../include/Eigen/src/Jacobi/Jacobi.h
+ ../include/Eigen/src/LU/Determinant.h
+ ../include/Eigen/src/LU/FullPivLU.h
+ ../include/Eigen/src/LU/InverseImpl.h
+ ../include/Eigen/src/LU/PartialPivLU.h
+ ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+ ../include/Eigen/src/LU/arch/InverseSize4.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+ ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+ ../include/Eigen/src/QR/FullPivHouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+ ../include/Eigen/src/SVD/BDCSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+ ../include/Eigen/src/SVD/SVDBase.h
+ ../include/Eigen/src/SVD/UpperBidiagonalization.h
+ ../include/Eigen/src/misc/Image.h
+ ../include/Eigen/src/misc/Kernel.h
+ ../include/Eigen/src/misc/RealSvd2x2.h
+ ../include/Eigen/src/misc/blas.h
+ ../include/Eigen/src/misc/lapacke.h
+ ../include/Eigen/src/misc/lapacke_mangling.h
+ ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/BlockMethods.h
+ ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/IndexedViewMethods.h
+ ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/ReshapedMethods.h
+ ../include/STrack.h
+ ../include/dataType.h
+ ../include/kalmanFilter.h
+ ../include/lapjv.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/depend.make b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/depend.make
new file mode 100644
index 00000000..2e561f3f
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/depend.make
@@ -0,0 +1,1710 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/BYTETracker.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Cholesky
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Core
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Dense
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Eigenvalues
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Geometry
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Householder
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Jacobi
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/LU
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/QR
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/SVD
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Cholesky/LDLT.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Cholesky/LLT.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ArithmeticSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Array.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ArrayBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ArrayWrapper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Assign.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/AssignEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Assign_MKL.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/BandMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Block.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/BooleanRedux.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CommaInitializer.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ConditionEstimator.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CoreEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CoreIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CwiseNullaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CwiseTernaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CwiseUnaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CwiseUnaryView.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/DenseBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/DenseCoeffsBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/DenseStorage.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Diagonal.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/DiagonalMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/DiagonalProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Dot.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/EigenBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Fuzzy.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/GeneralProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/GenericPacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/GlobalFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/IO.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/IndexedView.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Inverse.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Map.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/MapBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/MathFunctionsImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/MatrixBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/NestByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/NoAlias.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/NumTraits.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/PartialReduxEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/PermutationMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/PlainObjectBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Product.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ProductEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Random.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Redux.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Ref.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Replicate.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Reshaped.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ReturnByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Reverse.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Select.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/SelfAdjointView.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Solve.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/SolveTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/SolverBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/StableNorm.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/StlIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Stride.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Swap.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Transpose.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Transpositions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/TriangularMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/VectorBlock.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/VectorwiseOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Visitor.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX512/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/CUDA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/BFloat16.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/Half.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/Settings.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/MSA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/NEON/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SSE/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/ZVector/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/BinaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/NullaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/StlFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/TernaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/UnaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/Parallelizer.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverVector.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/BlasUtil.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/ConfigureVectorization.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/Constants.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/ForwardDeclarations.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/IndexedViewHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/IntegralConstant.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/MKL_support.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/Macros.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/Memory.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/Meta.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/ReshapedHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/StaticAssert.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/SymbolicIndex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/XprHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/EigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/RealQZ.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/AlignedBox.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/AngleAxis.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/EulerAngles.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Homogeneous.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Hyperplane.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/OrthoMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/ParametrizedLine.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Quaternion.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Rotation2D.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/RotationBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Scaling.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Transform.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Translation.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Umeyama.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Householder/BlockHouseholder.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Householder/Householder.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Householder/HouseholderSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Jacobi/Jacobi.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/Determinant.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/FullPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/InverseImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/PartialPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/arch/InverseSize4.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/FullPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/HouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/SVD/BDCSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/SVD/JacobiSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/SVD/SVDBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/SVD/UpperBidiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/Image.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/Kernel.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/RealSvd2x2.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/blas.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/lapacke.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/lapacke_mangling.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/BlockMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/IndexedViewMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/ReshapedMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/STrack.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/dataType.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/kalmanFilter.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../src/BYTETracker.cpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Cholesky
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Core
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Dense
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Eigenvalues
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Geometry
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Householder
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Jacobi
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/LU
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/QR
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/SVD
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Cholesky/LDLT.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Cholesky/LLT.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ArithmeticSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Array.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ArrayBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ArrayWrapper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Assign.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/AssignEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Assign_MKL.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/BandMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Block.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/BooleanRedux.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CommaInitializer.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ConditionEstimator.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CoreEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CoreIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CwiseNullaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CwiseTernaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CwiseUnaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CwiseUnaryView.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/DenseBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/DenseCoeffsBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/DenseStorage.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Diagonal.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/DiagonalMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/DiagonalProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Dot.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/EigenBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Fuzzy.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/GeneralProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/GenericPacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/GlobalFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/IO.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/IndexedView.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Inverse.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Map.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/MapBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/MathFunctionsImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/MatrixBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/NestByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/NoAlias.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/NumTraits.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/PartialReduxEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/PermutationMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/PlainObjectBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Product.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ProductEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Random.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Redux.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Ref.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Replicate.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Reshaped.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ReturnByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Reverse.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Select.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/SelfAdjointView.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Solve.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/SolveTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/SolverBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/StableNorm.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/StlIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Stride.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Swap.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Transpose.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Transpositions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/TriangularMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/VectorBlock.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/VectorwiseOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Visitor.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/CUDA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/BFloat16.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/Half.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/Settings.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/BinaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/NullaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/StlFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/TernaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/UnaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/Parallelizer.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverVector.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/BlasUtil.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/ConfigureVectorization.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/Constants.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/ForwardDeclarations.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/IndexedViewHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/IntegralConstant.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/MKL_support.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/Macros.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/Memory.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/Meta.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/ReshapedHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/StaticAssert.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/SymbolicIndex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/XprHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/EigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealQZ.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/AlignedBox.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/AngleAxis.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/EulerAngles.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Homogeneous.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Hyperplane.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/OrthoMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/ParametrizedLine.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Quaternion.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Rotation2D.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/RotationBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Scaling.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Transform.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Translation.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Umeyama.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Householder/BlockHouseholder.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Householder/Householder.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Householder/HouseholderSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Jacobi/Jacobi.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/Determinant.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/FullPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/InverseImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/PartialPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/arch/InverseSize4.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/FullPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/HouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/SVD/BDCSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/SVD/JacobiSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/SVD/SVDBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/SVD/UpperBidiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/Image.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/Kernel.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/RealSvd2x2.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/blas.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/lapacke.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/lapacke_mangling.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/BlockMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/IndexedViewMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/ReshapedMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/STrack.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/dataType.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/kalmanFilter.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../src/STrack.cpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../3rdparty/librknn_api/include/rknn_api.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/BYTETracker.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Cholesky
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Core
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Dense
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Eigenvalues
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Geometry
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Householder
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Jacobi
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/LU
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/QR
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/SVD
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Cholesky/LDLT.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Cholesky/LLT.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ArithmeticSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Array.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ArrayBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ArrayWrapper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Assign.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/AssignEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Assign_MKL.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/BandMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Block.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/BooleanRedux.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CommaInitializer.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ConditionEstimator.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CoreEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CoreIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CwiseNullaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CwiseTernaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CwiseUnaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CwiseUnaryView.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/DenseBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/DenseCoeffsBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/DenseStorage.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Diagonal.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/DiagonalMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/DiagonalProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Dot.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/EigenBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Fuzzy.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/GeneralProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/GenericPacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/GlobalFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/IO.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/IndexedView.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Inverse.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Map.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/MapBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/MathFunctionsImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/MatrixBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/NestByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/NoAlias.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/NumTraits.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/PartialReduxEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/PermutationMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/PlainObjectBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Product.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ProductEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Random.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Redux.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Ref.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Replicate.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Reshaped.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ReturnByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Reverse.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Select.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/SelfAdjointView.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Solve.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/SolveTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/SolverBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/StableNorm.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/StlIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Stride.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Swap.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Transpose.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Transpositions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/TriangularMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/VectorBlock.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/VectorwiseOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Visitor.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/CUDA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/BFloat16.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/Half.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/Settings.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/BinaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/NullaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/StlFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/TernaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/UnaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/Parallelizer.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverVector.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/BlasUtil.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/ConfigureVectorization.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/Constants.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/ForwardDeclarations.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/IndexedViewHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/IntegralConstant.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/MKL_support.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/Macros.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/Memory.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/Meta.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/ReshapedHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/StaticAssert.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/SymbolicIndex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/XprHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/EigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealQZ.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/AlignedBox.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/AngleAxis.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/EulerAngles.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Homogeneous.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Hyperplane.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/OrthoMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/ParametrizedLine.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Quaternion.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Rotation2D.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/RotationBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Scaling.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Transform.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Translation.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Umeyama.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Householder/BlockHouseholder.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Householder/Householder.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Householder/HouseholderSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Jacobi/Jacobi.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/Determinant.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/FullPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/InverseImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/PartialPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/arch/InverseSize4.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/FullPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/HouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/SVD/BDCSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/SVD/JacobiSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/SVD/SVDBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/SVD/UpperBidiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/Image.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/Kernel.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/RealSvd2x2.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/blas.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/lapacke.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/lapacke_mangling.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/BlockMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/IndexedViewMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/ReshapedMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/STrack.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/dataType.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/kalmanFilter.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../src/bytetrack.cpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/curl.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/curlver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/easy.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/header.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/mprintf.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/multi.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/options.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/system.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/typecheck-gcc.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/urlapi.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/curl-8.8.0/install/include/curl/websockets.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/core.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui/highgui.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/imgproc.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/asn1.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/asn1err.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/bio.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/bioerr.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/bn.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/bnerr.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/configuration.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/core.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/core_dispatch.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/crypto.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/cryptoerr.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/cryptoerr_legacy.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/e_os2.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/ebcdic.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/evp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/evperr.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/macros.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/obj_mac.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/objects.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/objectserr.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/opensslconf.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/opensslv.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/params.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/safestack.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/sha.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/stack.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/symhacks.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/types.h
+
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Cholesky
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Core
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Dense
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Eigenvalues
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Geometry
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Householder
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Jacobi
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/LU
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/QR
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/SVD
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Cholesky/LDLT.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Cholesky/LLT.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ArithmeticSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Array.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ArrayBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ArrayWrapper.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Assign.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/AssignEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Assign_MKL.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/BandMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Block.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/BooleanRedux.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CommaInitializer.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ConditionEstimator.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CoreEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CoreIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CwiseNullaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CwiseTernaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CwiseUnaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CwiseUnaryView.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/DenseBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/DenseCoeffsBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/DenseStorage.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Diagonal.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/DiagonalMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/DiagonalProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Dot.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/EigenBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Fuzzy.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/GeneralProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/GenericPacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/GlobalFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/IO.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/IndexedView.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Inverse.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Map.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/MapBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/MathFunctionsImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/MatrixBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/NestByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/NoAlias.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/NumTraits.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/PartialReduxEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/PermutationMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/PlainObjectBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Product.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ProductEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Random.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Redux.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Ref.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Replicate.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Reshaped.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ReturnByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Reverse.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Select.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/SelfAdjointView.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Solve.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/SolveTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/SolverBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/StableNorm.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/StlIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Stride.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Swap.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Transpose.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Transpositions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/TriangularMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/VectorBlock.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/VectorwiseOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Visitor.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX512/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/CUDA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/BFloat16.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/Half.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/Settings.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/MSA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/NEON/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SSE/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/ZVector/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/BinaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/NullaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/StlFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/TernaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/UnaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/Parallelizer.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverVector.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/BlasUtil.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/ConfigureVectorization.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/Constants.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/ForwardDeclarations.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/IndexedViewHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/IntegralConstant.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/MKL_support.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/Macros.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/Memory.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/Meta.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/ReshapedHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/StaticAssert.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/SymbolicIndex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/XprHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/EigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/RealQZ.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/AlignedBox.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/AngleAxis.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/EulerAngles.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Homogeneous.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Hyperplane.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/OrthoMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/ParametrizedLine.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Quaternion.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Rotation2D.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/RotationBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Scaling.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Transform.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Translation.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Umeyama.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Householder/BlockHouseholder.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Householder/Householder.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Householder/HouseholderSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Jacobi/Jacobi.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/Determinant.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/FullPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/InverseImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/PartialPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/arch/InverseSize4.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/FullPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/HouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/SVD/BDCSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/SVD/JacobiSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/SVD/SVDBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/SVD/UpperBidiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/Image.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/Kernel.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/RealSvd2x2.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/blas.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/lapacke.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/lapacke_mangling.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/BlockMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/IndexedViewMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/ReshapedMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/dataType.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/kalmanFilter.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../src/kalmanFilter.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o: ../include/lapjv.h
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o: ../src/lapjv.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/BYTETracker.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Cholesky
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Core
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Dense
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Eigenvalues
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Geometry
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Householder
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Jacobi
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/LU
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/QR
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/SVD
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Cholesky/LDLT.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Cholesky/LLT.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ArithmeticSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Array.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ArrayBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ArrayWrapper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Assign.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/AssignEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Assign_MKL.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/BandMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Block.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/BooleanRedux.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CommaInitializer.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ConditionEstimator.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CoreEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CoreIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CwiseNullaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CwiseTernaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CwiseUnaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CwiseUnaryView.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/DenseBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/DenseCoeffsBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/DenseStorage.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Diagonal.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/DiagonalMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/DiagonalProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Dot.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/EigenBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Fuzzy.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/GeneralProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/GenericPacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/GlobalFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/IO.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/IndexedView.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Inverse.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Map.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/MapBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/MathFunctionsImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/MatrixBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/NestByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/NoAlias.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/NumTraits.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/PartialReduxEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/PermutationMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/PlainObjectBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Product.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ProductEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Random.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Redux.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Ref.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Replicate.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Reshaped.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ReturnByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Reverse.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Select.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/SelfAdjointView.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Solve.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/SolveTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/SolverBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/StableNorm.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/StlIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Stride.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Swap.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Transpose.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Transpositions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/TriangularMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/VectorBlock.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/VectorwiseOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Visitor.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX512/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/CUDA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/BFloat16.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/Half.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/Settings.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/MSA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/NEON/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SSE/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/ZVector/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/BinaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/NullaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/StlFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/TernaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/UnaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/Parallelizer.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverVector.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/BlasUtil.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/ConfigureVectorization.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/Constants.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/ForwardDeclarations.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/IndexedViewHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/IntegralConstant.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/MKL_support.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/Macros.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/Memory.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/Meta.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/ReshapedHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/StaticAssert.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/SymbolicIndex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/XprHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/EigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/RealQZ.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/AlignedBox.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/AngleAxis.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/EulerAngles.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Homogeneous.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Hyperplane.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/OrthoMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/ParametrizedLine.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Quaternion.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Rotation2D.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/RotationBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Scaling.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Transform.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Translation.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Umeyama.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Householder/BlockHouseholder.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Householder/Householder.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Householder/HouseholderSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Jacobi/Jacobi.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/Determinant.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/FullPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/InverseImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/PartialPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/arch/InverseSize4.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/FullPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/HouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/SVD/BDCSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/SVD/JacobiSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/SVD/SVDBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/SVD/UpperBidiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/Image.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/Kernel.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/RealSvd2x2.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/blas.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/lapacke.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/lapacke_mangling.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/BlockMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/IndexedViewMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/ReshapedMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/STrack.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/dataType.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/kalmanFilter.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/lapjv.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../src/utils.cpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/flags.make b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/flags.make
new file mode 100644
index 00000000..dec34263
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/flags.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# compile CXX with /home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++
+CXX_FLAGS =  
+
+CXX_DEFINES = 
+
+CXX_INCLUDES = -I/home/huey/openssl/install/include -I/home/huey/Desktop/C/yolo_bytetrack/include -I/home/huey/Desktop/C/yolo_bytetrack/3rdparty/librknn_api/include -I/home/huey/Desktop/C/yolo_bytetrack/3rdparty/rga/include -I/home/huey/curl-8.8.0/install/include -isystem /home/huey/opencv-4.7.0/install/include/opencv4 
+
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/link.txt b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/link.txt
new file mode 100644
index 00000000..d01ba00c
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/link.txt
@@ -0,0 +1 @@
+/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++     CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o  -o yolo_bytetrack  -Wl,-rpath,/home/huey/Desktop/C/yolo_bytetrack/install/rknn_yolov5_1109_new_Linux/lib /home/huey/opencv-4.7.0/install/lib/libopencv_gapi.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_stitching.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_aruco.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_barcode.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_bgsegm.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_bioinspired.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_ccalib.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_dnn_objdetect.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_dnn_superres.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_dpm.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_face.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_fuzzy.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_hfs.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_img_hash.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_intensity_transform.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_line_descriptor.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_mcc.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_quality.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_rapid.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_reg.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_rgbd.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_saliency.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_stereo.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_structured_light.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_superres.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_surface_matching.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_tracking.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_videostab.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_wechat_qrcode.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_xfeatures2d.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_xobjdetect.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_xphoto.so.4.7.0 /home/huey/openssl/install/lib/libssl.so /home/huey/openssl/install/lib/libcrypto.so /home/huey/curl-8.8.0/install/lib/libcurl.a -lpthread ../3rdparty/librknn_api/armhf/librknn_api.so ../3rdparty/rga/lib/librga.so /home/huey/opencv-4.7.0/install/lib/libopencv_shape.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_highgui.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_datasets.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_plot.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_text.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_ml.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_phase_unwrapping.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_optflow.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_ximgproc.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_video.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_videoio.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_imgcodecs.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_objdetect.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_calib3d.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_dnn.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_features2d.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_flann.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_photo.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_imgproc.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_core.so.4.7.0 
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/progress.make b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/progress.make
new file mode 100644
index 00000000..2f823159
--- /dev/null
+++ b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/progress.make
@@ -0,0 +1,8 @@
+CMAKE_PROGRESS_1 = 1
+CMAKE_PROGRESS_2 = 2
+CMAKE_PROGRESS_3 = 3
+CMAKE_PROGRESS_4 = 4
+CMAKE_PROGRESS_5 = 5
+CMAKE_PROGRESS_6 = 6
+CMAKE_PROGRESS_7 = 7
+
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o
new file mode 100644
index 00000000..4d793baa
Binary files /dev/null and b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o differ
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o
new file mode 100644
index 00000000..e0815c79
Binary files /dev/null and b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o differ
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o
new file mode 100644
index 00000000..5d5e127b
Binary files /dev/null and b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o differ
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o
new file mode 100644
index 00000000..b32eed07
Binary files /dev/null and b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o differ
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o
new file mode 100644
index 00000000..b203f038
Binary files /dev/null and b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o differ
diff --git a/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o
new file mode 100644
index 00000000..28fd4744
Binary files /dev/null and b/C++/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o differ
diff --git a/C++/yolo_bytetrack/build/Makefile b/C++/yolo_bytetrack/build/Makefile
new file mode 100644
index 00000000..03dab491
--- /dev/null
+++ b/C++/yolo_bytetrack/build/Makefile
@@ -0,0 +1,328 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# Default target executed when no arguments are given to make.
+default_target: all
+
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+
+# Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+
+# A target that is always out of date.
+cmake_force:
+
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E remove -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/huey/Desktop/C/yolo_bytetrack
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/huey/Desktop/C/yolo_bytetrack/build
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
+	/usr/bin/cmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..."
+	/usr/bin/cmake-gui -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+
+.PHONY : edit_cache/fast
+
+# The main all target
+all: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/progress.marks
+	$(MAKE) -f CMakeFiles/Makefile2 all
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	$(MAKE) -f CMakeFiles/Makefile2 clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	$(MAKE) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	$(MAKE) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+#=============================================================================
+# Target rules for targets named yolo_bytetrack
+
+# Build rule for target.
+yolo_bytetrack: cmake_check_build_system
+	$(MAKE) -f CMakeFiles/Makefile2 yolo_bytetrack
+.PHONY : yolo_bytetrack
+
+# fast build rule for target.
+yolo_bytetrack/fast:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/build
+.PHONY : yolo_bytetrack/fast
+
+src/BYTETracker.o: src/BYTETracker.cpp.o
+
+.PHONY : src/BYTETracker.o
+
+# target to build an object file
+src/BYTETracker.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o
+.PHONY : src/BYTETracker.cpp.o
+
+src/BYTETracker.i: src/BYTETracker.cpp.i
+
+.PHONY : src/BYTETracker.i
+
+# target to preprocess a source file
+src/BYTETracker.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.i
+.PHONY : src/BYTETracker.cpp.i
+
+src/BYTETracker.s: src/BYTETracker.cpp.s
+
+.PHONY : src/BYTETracker.s
+
+# target to generate assembly for a file
+src/BYTETracker.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.s
+.PHONY : src/BYTETracker.cpp.s
+
+src/STrack.o: src/STrack.cpp.o
+
+.PHONY : src/STrack.o
+
+# target to build an object file
+src/STrack.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o
+.PHONY : src/STrack.cpp.o
+
+src/STrack.i: src/STrack.cpp.i
+
+.PHONY : src/STrack.i
+
+# target to preprocess a source file
+src/STrack.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.i
+.PHONY : src/STrack.cpp.i
+
+src/STrack.s: src/STrack.cpp.s
+
+.PHONY : src/STrack.s
+
+# target to generate assembly for a file
+src/STrack.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.s
+.PHONY : src/STrack.cpp.s
+
+src/bytetrack.o: src/bytetrack.cpp.o
+
+.PHONY : src/bytetrack.o
+
+# target to build an object file
+src/bytetrack.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o
+.PHONY : src/bytetrack.cpp.o
+
+src/bytetrack.i: src/bytetrack.cpp.i
+
+.PHONY : src/bytetrack.i
+
+# target to preprocess a source file
+src/bytetrack.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.i
+.PHONY : src/bytetrack.cpp.i
+
+src/bytetrack.s: src/bytetrack.cpp.s
+
+.PHONY : src/bytetrack.s
+
+# target to generate assembly for a file
+src/bytetrack.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.s
+.PHONY : src/bytetrack.cpp.s
+
+src/kalmanFilter.o: src/kalmanFilter.cpp.o
+
+.PHONY : src/kalmanFilter.o
+
+# target to build an object file
+src/kalmanFilter.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o
+.PHONY : src/kalmanFilter.cpp.o
+
+src/kalmanFilter.i: src/kalmanFilter.cpp.i
+
+.PHONY : src/kalmanFilter.i
+
+# target to preprocess a source file
+src/kalmanFilter.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.i
+.PHONY : src/kalmanFilter.cpp.i
+
+src/kalmanFilter.s: src/kalmanFilter.cpp.s
+
+.PHONY : src/kalmanFilter.s
+
+# target to generate assembly for a file
+src/kalmanFilter.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.s
+.PHONY : src/kalmanFilter.cpp.s
+
+src/lapjv.o: src/lapjv.cpp.o
+
+.PHONY : src/lapjv.o
+
+# target to build an object file
+src/lapjv.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o
+.PHONY : src/lapjv.cpp.o
+
+src/lapjv.i: src/lapjv.cpp.i
+
+.PHONY : src/lapjv.i
+
+# target to preprocess a source file
+src/lapjv.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.i
+.PHONY : src/lapjv.cpp.i
+
+src/lapjv.s: src/lapjv.cpp.s
+
+.PHONY : src/lapjv.s
+
+# target to generate assembly for a file
+src/lapjv.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.s
+.PHONY : src/lapjv.cpp.s
+
+src/utils.o: src/utils.cpp.o
+
+.PHONY : src/utils.o
+
+# target to build an object file
+src/utils.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o
+.PHONY : src/utils.cpp.o
+
+src/utils.i: src/utils.cpp.i
+
+.PHONY : src/utils.i
+
+# target to preprocess a source file
+src/utils.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.i
+.PHONY : src/utils.cpp.i
+
+src/utils.s: src/utils.cpp.s
+
+.PHONY : src/utils.s
+
+# target to generate assembly for a file
+src/utils.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.s
+.PHONY : src/utils.cpp.s
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... rebuild_cache"
+	@echo "... edit_cache"
+	@echo "... yolo_bytetrack"
+	@echo "... src/BYTETracker.o"
+	@echo "... src/BYTETracker.i"
+	@echo "... src/BYTETracker.s"
+	@echo "... src/STrack.o"
+	@echo "... src/STrack.i"
+	@echo "... src/STrack.s"
+	@echo "... src/bytetrack.o"
+	@echo "... src/bytetrack.i"
+	@echo "... src/bytetrack.s"
+	@echo "... src/kalmanFilter.o"
+	@echo "... src/kalmanFilter.i"
+	@echo "... src/kalmanFilter.s"
+	@echo "... src/lapjv.o"
+	@echo "... src/lapjv.i"
+	@echo "... src/lapjv.s"
+	@echo "... src/utils.o"
+	@echo "... src/utils.i"
+	@echo "... src/utils.s"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/C++/yolo_bytetrack/build/cmake_install.cmake b/C++/yolo_bytetrack/build/cmake_install.cmake
new file mode 100644
index 00000000..b11ea028
--- /dev/null
+++ b/C++/yolo_bytetrack/build/cmake_install.cmake
@@ -0,0 +1,49 @@
+# Install script for directory: /home/huey/Desktop/C/yolo_bytetrack
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/home/huey/Desktop/C/yolo_bytetrack/install/rknn_yolov5_1109_new_Linux")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "1")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+if(CMAKE_INSTALL_COMPONENT)
+  set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
+else()
+  set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+file(WRITE "/home/huey/Desktop/C/yolo_bytetrack/build/${CMAKE_INSTALL_MANIFEST}"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
diff --git a/C++/yolo_bytetrack/build/yolo_bytetrack b/C++/yolo_bytetrack/build/yolo_bytetrack
new file mode 100644
index 00000000..ff9326d7
Binary files /dev/null and b/C++/yolo_bytetrack/build/yolo_bytetrack differ
diff --git a/C++/yolo_bytetrack/include/BYTETracker.h b/C++/yolo_bytetrack/include/BYTETracker.h
new file mode 100644
index 00000000..477c3344
--- /dev/null
+++ b/C++/yolo_bytetrack/include/BYTETracker.h
@@ -0,0 +1,49 @@
+#pragma once  //避免头文件重复包含
+
+#include "STrack.h"
+
+struct Object
+{
+    cv::Rect_<float> rect;
+    int label;
+    float prob;
+};
+
+class BYTETracker
+{
+public:
+	BYTETracker(int frame_rate = 30, int track_buffer = 30);
+	~BYTETracker();
+
+	vector<STrack> update(const vector<Object>& objects);
+	cv::Scalar get_color(int idx);
+
+private:
+	vector<STrack*> joint_stracks(vector<STrack*> &tlista, vector<STrack> &tlistb);
+	vector<STrack> joint_stracks(vector<STrack> &tlista, vector<STrack> &tlistb);
+
+	vector<STrack> sub_stracks(vector<STrack> &tlista, vector<STrack> &tlistb);
+	void remove_duplicate_stracks(vector<STrack> &resa, vector<STrack> &resb, vector<STrack> &stracksa, vector<STrack> &stracksb);
+
+	void linear_assignment(vector<vector<float> > &cost_matrix, int cost_matrix_size, int cost_matrix_size_size, float thresh,
+		vector<vector<int> > &matches, vector<int> &unmatched_a, vector<int> &unmatched_b);
+	vector<vector<float> > iou_distance(vector<STrack*> &atracks, vector<STrack> &btracks, int &dist_size, int &dist_size_size);
+	vector<vector<float> > iou_distance(vector<STrack> &atracks, vector<STrack> &btracks);
+	vector<vector<float> > ious(vector<vector<float> > &atlbrs, vector<vector<float> > &btlbrs);
+
+	double lapjv(const vector<vector<float> > &cost, vector<int> &rowsol, vector<int> &colsol, 
+		bool extend_cost = false, float cost_limit = LONG_MAX, bool return_cost = true);
+
+private:
+
+	float track_thresh;
+	float high_thresh;
+	float match_thresh;
+	int frame_id;
+	int max_time_lost;
+
+	vector<STrack> tracked_stracks;
+	vector<STrack> lost_stracks;
+	vector<STrack> removed_stracks;
+	byte_kalman::KalmanFilter kalman_filter;
+};
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/include/Eigen/Cholesky b/C++/yolo_bytetrack/include/Eigen/Cholesky
new file mode 100644
index 00000000..a318ceb7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/Cholesky
@@ -0,0 +1,45 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLESKY_MODULE_H
+#define EIGEN_CHOLESKY_MODULE_H
+
+#include "Core"
+#include "Jacobi"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Cholesky_Module Cholesky module
+  *
+  *
+  *
+  * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
+  * Those decompositions are also accessible via the following methods:
+  *  - MatrixBase::llt()
+  *  - MatrixBase::ldlt()
+  *  - SelfAdjointView::llt()
+  *  - SelfAdjointView::ldlt()
+  *
+  * \code
+  * #include <Eigen/Cholesky>
+  * \endcode
+  */
+
+#include "src/Cholesky/LLT.h"
+#include "src/Cholesky/LDLT.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/Cholesky/LLT_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CHOLESKY_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/CholmodSupport b/C++/yolo_bytetrack/include/Eigen/CholmodSupport
new file mode 100644
index 00000000..bed8924d
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/CholmodSupport
@@ -0,0 +1,48 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLMODSUPPORT_MODULE_H
+#define EIGEN_CHOLMODSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+extern "C" {
+  #include <cholmod.h>
+}
+
+/** \ingroup Support_modules
+  * \defgroup CholmodSupport_Module CholmodSupport module
+  *
+  * This module provides an interface to the Cholmod library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
+  * It provides the two following main factorization classes:
+  * - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization.
+  * - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial).
+  *
+  * For the sake of completeness, this module also propose the two following classes:
+  * - class CholmodSimplicialLLT
+  * - class CholmodSimplicialLDLT
+  * Note that these classes does not bring any particular advantage compared to the built-in
+  * SimplicialLLT and SimplicialLDLT factorization classes.
+  *
+  * \code
+  * #include <Eigen/CholmodSupport>
+  * \endcode
+  *
+  * In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies.
+  * The dependencies depend on how cholmod has been compiled.
+  * For a cmake based project, you can use our FindCholmod.cmake module to help you in this task.
+  *
+  */
+
+#include "src/CholmodSupport/CholmodSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CHOLMODSUPPORT_MODULE_H
+
diff --git a/C++/yolo_bytetrack/include/Eigen/Core b/C++/yolo_bytetrack/include/Eigen/Core
new file mode 100644
index 00000000..5921e15f
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/Core
@@ -0,0 +1,384 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2011 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CORE_H
+#define EIGEN_CORE_H
+
+// first thing Eigen does: stop the compiler from reporting useless warnings.
+#include "src/Core/util/DisableStupidWarnings.h"
+
+// then include this file where all our macros are defined. It's really important to do it first because
+// it's where we do all the compiler/OS/arch detections and define most defaults.
+#include "src/Core/util/Macros.h"
+
+// This detects SSE/AVX/NEON/etc. and configure alignment settings
+#include "src/Core/util/ConfigureVectorization.h"
+
+// We need cuda_runtime.h/hip_runtime.h to ensure that
+// the EIGEN_USING_STD macro works properly on the device side
+#if defined(EIGEN_CUDACC)
+  #include <cuda_runtime.h>
+#elif defined(EIGEN_HIPCC)
+  #include <hip/hip_runtime.h>
+#endif
+
+
+#ifdef EIGEN_EXCEPTIONS
+  #include <new>
+#endif
+
+// Disable the ipa-cp-clone optimization flag with MinGW 6.x or newer (enabled by default with -O3)
+// See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details.
+#if EIGEN_COMP_MINGW && EIGEN_GNUC_AT_LEAST(4,6) && EIGEN_GNUC_AT_MOST(5,5)
+  #pragma GCC optimize ("-fno-ipa-cp-clone")
+#endif
+
+// Prevent ICC from specializing std::complex operators that silently fail
+// on device. This allows us to use our own device-compatible specializations
+// instead.
+#if defined(EIGEN_COMP_ICC) && defined(EIGEN_GPU_COMPILE_PHASE) \
+    && !defined(_OVERRIDE_COMPLEX_SPECIALIZATION_)
+#define _OVERRIDE_COMPLEX_SPECIALIZATION_ 1
+#endif
+#include <complex>
+
+// this include file manages BLAS and MKL related macros
+// and inclusion of their respective header files
+#include "src/Core/util/MKL_support.h"
+
+
+#if defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)
+  #define EIGEN_HAS_GPU_FP16
+#endif
+
+#if defined(EIGEN_HAS_CUDA_BF16) || defined(EIGEN_HAS_HIP_BF16)
+  #define EIGEN_HAS_GPU_BF16
+#endif
+
+#if (defined _OPENMP) && (!defined EIGEN_DONT_PARALLELIZE)
+  #define EIGEN_HAS_OPENMP
+#endif
+
+#ifdef EIGEN_HAS_OPENMP
+#include <omp.h>
+#endif
+
+// MSVC for windows mobile does not have the errno.h file
+#if !(EIGEN_COMP_MSVC && EIGEN_OS_WINCE) && !EIGEN_COMP_ARM
+#define EIGEN_HAS_ERRNO
+#endif
+
+#ifdef EIGEN_HAS_ERRNO
+#include <cerrno>
+#endif
+#include <cstddef>
+#include <cstdlib>
+#include <cmath>
+#include <cassert>
+#include <functional>
+#include <sstream>
+#ifndef EIGEN_NO_IO
+  #include <iosfwd>
+#endif
+#include <cstring>
+#include <string>
+#include <limits>
+#include <climits> // for CHAR_BIT
+// for min/max:
+#include <algorithm>
+
+#if EIGEN_HAS_CXX11
+#include <array>
+#endif
+
+// for std::is_nothrow_move_assignable
+#ifdef EIGEN_INCLUDE_TYPE_TRAITS
+#include <type_traits>
+#endif
+
+// for outputting debug info
+#ifdef EIGEN_DEBUG_ASSIGN
+#include <iostream>
+#endif
+
+// required for __cpuid, needs to be included after cmath
+#if EIGEN_COMP_MSVC && EIGEN_ARCH_i386_OR_x86_64 && !EIGEN_OS_WINCE
+  #include <intrin.h>
+#endif
+
+#if defined(EIGEN_USE_SYCL)
+  #undef min
+  #undef max
+  #undef isnan
+  #undef isinf
+  #undef isfinite
+  #include <CL/sycl.hpp>
+  #include <map>
+  #include <memory>
+  #include <utility>
+  #include <thread>
+  #ifndef EIGEN_SYCL_LOCAL_THREAD_DIM0
+  #define EIGEN_SYCL_LOCAL_THREAD_DIM0 16
+  #endif
+  #ifndef EIGEN_SYCL_LOCAL_THREAD_DIM1
+  #define EIGEN_SYCL_LOCAL_THREAD_DIM1 16
+  #endif
+#endif
+
+
+#if defined EIGEN2_SUPPORT_STAGE40_FULL_EIGEN3_STRICTNESS || defined EIGEN2_SUPPORT_STAGE30_FULL_EIGEN3_API || defined EIGEN2_SUPPORT_STAGE20_RESOLVE_API_CONFLICTS || defined EIGEN2_SUPPORT_STAGE10_FULL_EIGEN2_API || defined EIGEN2_SUPPORT
+// This will generate an error message:
+#error Eigen2-support is only available up to version 3.2. Please go to "http://eigen.tuxfamily.org/index.php?title=Eigen2" for further information
+#endif
+
+namespace Eigen {
+
+// we use size_t frequently and we'll never remember to prepend it with std:: every time just to
+// ensure QNX/QCC support
+using std::size_t;
+// gcc 4.6.0 wants std:: for ptrdiff_t
+using std::ptrdiff_t;
+
+}
+
+/** \defgroup Core_Module Core module
+  * This is the main module of Eigen providing dense matrix and vector support
+  * (both fixed and dynamic size) with all the features corresponding to a BLAS library
+  * and much more...
+  *
+  * \code
+  * #include <Eigen/Core>
+  * \endcode
+  */
+
+#include "src/Core/util/Constants.h"
+#include "src/Core/util/Meta.h"
+#include "src/Core/util/ForwardDeclarations.h"
+#include "src/Core/util/StaticAssert.h"
+#include "src/Core/util/XprHelper.h"
+#include "src/Core/util/Memory.h"
+#include "src/Core/util/IntegralConstant.h"
+#include "src/Core/util/SymbolicIndex.h"
+
+#include "src/Core/NumTraits.h"
+#include "src/Core/MathFunctions.h"
+#include "src/Core/GenericPacketMath.h"
+#include "src/Core/MathFunctionsImpl.h"
+#include "src/Core/arch/Default/ConjHelper.h"
+// Generic half float support
+#include "src/Core/arch/Default/Half.h"
+#include "src/Core/arch/Default/BFloat16.h"
+#include "src/Core/arch/Default/TypeCasting.h"
+#include "src/Core/arch/Default/GenericPacketMathFunctionsFwd.h"
+
+#if defined EIGEN_VECTORIZE_AVX512
+  #include "src/Core/arch/SSE/PacketMath.h"
+  #include "src/Core/arch/SSE/TypeCasting.h"
+  #include "src/Core/arch/SSE/Complex.h"
+  #include "src/Core/arch/AVX/PacketMath.h"
+  #include "src/Core/arch/AVX/TypeCasting.h"
+  #include "src/Core/arch/AVX/Complex.h"
+  #include "src/Core/arch/AVX512/PacketMath.h"
+  #include "src/Core/arch/AVX512/TypeCasting.h"
+  #include "src/Core/arch/AVX512/Complex.h"
+  #include "src/Core/arch/SSE/MathFunctions.h"
+  #include "src/Core/arch/AVX/MathFunctions.h"
+  #include "src/Core/arch/AVX512/MathFunctions.h"
+#elif defined EIGEN_VECTORIZE_AVX
+  // Use AVX for floats and doubles, SSE for integers
+  #include "src/Core/arch/SSE/PacketMath.h"
+  #include "src/Core/arch/SSE/TypeCasting.h"
+  #include "src/Core/arch/SSE/Complex.h"
+  #include "src/Core/arch/AVX/PacketMath.h"
+  #include "src/Core/arch/AVX/TypeCasting.h"
+  #include "src/Core/arch/AVX/Complex.h"
+  #include "src/Core/arch/SSE/MathFunctions.h"
+  #include "src/Core/arch/AVX/MathFunctions.h"
+#elif defined EIGEN_VECTORIZE_SSE
+  #include "src/Core/arch/SSE/PacketMath.h"
+  #include "src/Core/arch/SSE/TypeCasting.h"
+  #include "src/Core/arch/SSE/MathFunctions.h"
+  #include "src/Core/arch/SSE/Complex.h"
+#elif defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)
+  #include "src/Core/arch/AltiVec/PacketMath.h"
+  #include "src/Core/arch/AltiVec/MathFunctions.h"
+  #include "src/Core/arch/AltiVec/Complex.h"
+#elif defined EIGEN_VECTORIZE_NEON
+  #include "src/Core/arch/NEON/PacketMath.h"
+  #include "src/Core/arch/NEON/TypeCasting.h"
+  #include "src/Core/arch/NEON/MathFunctions.h"
+  #include "src/Core/arch/NEON/Complex.h"
+#elif defined EIGEN_VECTORIZE_SVE
+  #include "src/Core/arch/SVE/PacketMath.h"
+  #include "src/Core/arch/SVE/TypeCasting.h"
+  #include "src/Core/arch/SVE/MathFunctions.h"
+#elif defined EIGEN_VECTORIZE_ZVECTOR
+  #include "src/Core/arch/ZVector/PacketMath.h"
+  #include "src/Core/arch/ZVector/MathFunctions.h"
+  #include "src/Core/arch/ZVector/Complex.h"
+#elif defined EIGEN_VECTORIZE_MSA
+  #include "src/Core/arch/MSA/PacketMath.h"
+  #include "src/Core/arch/MSA/MathFunctions.h"
+  #include "src/Core/arch/MSA/Complex.h"
+#endif
+
+#if defined EIGEN_VECTORIZE_GPU
+  #include "src/Core/arch/GPU/PacketMath.h"
+  #include "src/Core/arch/GPU/MathFunctions.h"
+  #include "src/Core/arch/GPU/TypeCasting.h"
+#endif
+
+#if defined(EIGEN_USE_SYCL)
+  #include "src/Core/arch/SYCL/SyclMemoryModel.h"
+  #include "src/Core/arch/SYCL/InteropHeaders.h"
+#if !defined(EIGEN_DONT_VECTORIZE_SYCL)
+  #include "src/Core/arch/SYCL/PacketMath.h"
+  #include "src/Core/arch/SYCL/MathFunctions.h"
+  #include "src/Core/arch/SYCL/TypeCasting.h"
+#endif
+#endif
+
+#include "src/Core/arch/Default/Settings.h"
+// This file provides generic implementations valid for scalar as well
+#include "src/Core/arch/Default/GenericPacketMathFunctions.h"
+
+#include "src/Core/functors/TernaryFunctors.h"
+#include "src/Core/functors/BinaryFunctors.h"
+#include "src/Core/functors/UnaryFunctors.h"
+#include "src/Core/functors/NullaryFunctors.h"
+#include "src/Core/functors/StlFunctors.h"
+#include "src/Core/functors/AssignmentFunctors.h"
+
+// Specialized functors to enable the processing of complex numbers
+// on CUDA devices
+#ifdef EIGEN_CUDACC
+#include "src/Core/arch/CUDA/Complex.h"
+#endif
+
+#include "src/Core/util/IndexedViewHelper.h"
+#include "src/Core/util/ReshapedHelper.h"
+#include "src/Core/ArithmeticSequence.h"
+#ifndef EIGEN_NO_IO
+  #include "src/Core/IO.h"
+#endif
+#include "src/Core/DenseCoeffsBase.h"
+#include "src/Core/DenseBase.h"
+#include "src/Core/MatrixBase.h"
+#include "src/Core/EigenBase.h"
+
+#include "src/Core/Product.h"
+#include "src/Core/CoreEvaluators.h"
+#include "src/Core/AssignEvaluator.h"
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN // work around Doxygen bug triggered by Assign.h r814874
+                                // at least confirmed with Doxygen 1.5.5 and 1.5.6
+  #include "src/Core/Assign.h"
+#endif
+
+#include "src/Core/ArrayBase.h"
+#include "src/Core/util/BlasUtil.h"
+#include "src/Core/DenseStorage.h"
+#include "src/Core/NestByValue.h"
+
+// #include "src/Core/ForceAlignedAccess.h"
+
+#include "src/Core/ReturnByValue.h"
+#include "src/Core/NoAlias.h"
+#include "src/Core/PlainObjectBase.h"
+#include "src/Core/Matrix.h"
+#include "src/Core/Array.h"
+#include "src/Core/CwiseTernaryOp.h"
+#include "src/Core/CwiseBinaryOp.h"
+#include "src/Core/CwiseUnaryOp.h"
+#include "src/Core/CwiseNullaryOp.h"
+#include "src/Core/CwiseUnaryView.h"
+#include "src/Core/SelfCwiseBinaryOp.h"
+#include "src/Core/Dot.h"
+#include "src/Core/StableNorm.h"
+#include "src/Core/Stride.h"
+#include "src/Core/MapBase.h"
+#include "src/Core/Map.h"
+#include "src/Core/Ref.h"
+#include "src/Core/Block.h"
+#include "src/Core/VectorBlock.h"
+#include "src/Core/IndexedView.h"
+#include "src/Core/Reshaped.h"
+#include "src/Core/Transpose.h"
+#include "src/Core/DiagonalMatrix.h"
+#include "src/Core/Diagonal.h"
+#include "src/Core/DiagonalProduct.h"
+#include "src/Core/Redux.h"
+#include "src/Core/Visitor.h"
+#include "src/Core/Fuzzy.h"
+#include "src/Core/Swap.h"
+#include "src/Core/CommaInitializer.h"
+#include "src/Core/GeneralProduct.h"
+#include "src/Core/Solve.h"
+#include "src/Core/Inverse.h"
+#include "src/Core/SolverBase.h"
+#include "src/Core/PermutationMatrix.h"
+#include "src/Core/Transpositions.h"
+#include "src/Core/TriangularMatrix.h"
+#include "src/Core/SelfAdjointView.h"
+#include "src/Core/products/GeneralBlockPanelKernel.h"
+#include "src/Core/products/Parallelizer.h"
+#include "src/Core/ProductEvaluators.h"
+#include "src/Core/products/GeneralMatrixVector.h"
+#include "src/Core/products/GeneralMatrixMatrix.h"
+#include "src/Core/SolveTriangular.h"
+#include "src/Core/products/GeneralMatrixMatrixTriangular.h"
+#include "src/Core/products/SelfadjointMatrixVector.h"
+#include "src/Core/products/SelfadjointMatrixMatrix.h"
+#include "src/Core/products/SelfadjointProduct.h"
+#include "src/Core/products/SelfadjointRank2Update.h"
+#include "src/Core/products/TriangularMatrixVector.h"
+#include "src/Core/products/TriangularMatrixMatrix.h"
+#include "src/Core/products/TriangularSolverMatrix.h"
+#include "src/Core/products/TriangularSolverVector.h"
+#include "src/Core/BandMatrix.h"
+#include "src/Core/CoreIterators.h"
+#include "src/Core/ConditionEstimator.h"
+
+#if defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)
+  #include "src/Core/arch/AltiVec/MatrixProduct.h"
+#elif defined EIGEN_VECTORIZE_NEON
+  #include "src/Core/arch/NEON/GeneralBlockPanelKernel.h"
+#endif
+
+#include "src/Core/BooleanRedux.h"
+#include "src/Core/Select.h"
+#include "src/Core/VectorwiseOp.h"
+#include "src/Core/PartialReduxEvaluator.h"
+#include "src/Core/Random.h"
+#include "src/Core/Replicate.h"
+#include "src/Core/Reverse.h"
+#include "src/Core/ArrayWrapper.h"
+#include "src/Core/StlIterators.h"
+
+#ifdef EIGEN_USE_BLAS
+#include "src/Core/products/GeneralMatrixMatrix_BLAS.h"
+#include "src/Core/products/GeneralMatrixVector_BLAS.h"
+#include "src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h"
+#include "src/Core/products/SelfadjointMatrixMatrix_BLAS.h"
+#include "src/Core/products/SelfadjointMatrixVector_BLAS.h"
+#include "src/Core/products/TriangularMatrixMatrix_BLAS.h"
+#include "src/Core/products/TriangularMatrixVector_BLAS.h"
+#include "src/Core/products/TriangularSolverMatrix_BLAS.h"
+#endif // EIGEN_USE_BLAS
+
+#ifdef EIGEN_USE_MKL_VML
+#include "src/Core/Assign_MKL.h"
+#endif
+
+#include "src/Core/GlobalFunctions.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CORE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/Dense b/C++/yolo_bytetrack/include/Eigen/Dense
new file mode 100644
index 00000000..5768910b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/Dense
@@ -0,0 +1,7 @@
+#include "Core"
+#include "LU"
+#include "Cholesky"
+#include "QR"
+#include "SVD"
+#include "Geometry"
+#include "Eigenvalues"
diff --git a/C++/yolo_bytetrack/include/Eigen/Eigen b/C++/yolo_bytetrack/include/Eigen/Eigen
new file mode 100644
index 00000000..654c8dc6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/Eigen
@@ -0,0 +1,2 @@
+#include "Dense"
+#include "Sparse"
diff --git a/C++/yolo_bytetrack/include/Eigen/Eigenvalues b/C++/yolo_bytetrack/include/Eigen/Eigenvalues
new file mode 100644
index 00000000..5467a2e7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/Eigenvalues
@@ -0,0 +1,60 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EIGENVALUES_MODULE_H
+#define EIGEN_EIGENVALUES_MODULE_H
+
+#include "Core"
+
+#include "Cholesky"
+#include "Jacobi"
+#include "Householder"
+#include "LU"
+#include "Geometry"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Eigenvalues_Module Eigenvalues module
+  *
+  *
+  *
+  * This module mainly provides various eigenvalue solvers.
+  * This module also provides some MatrixBase methods, including:
+  *  - MatrixBase::eigenvalues(),
+  *  - MatrixBase::operatorNorm()
+  *
+  * \code
+  * #include <Eigen/Eigenvalues>
+  * \endcode
+  */
+
+#include "src/misc/RealSvd2x2.h"
+#include "src/Eigenvalues/Tridiagonalization.h"
+#include "src/Eigenvalues/RealSchur.h"
+#include "src/Eigenvalues/EigenSolver.h"
+#include "src/Eigenvalues/SelfAdjointEigenSolver.h"
+#include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h"
+#include "src/Eigenvalues/HessenbergDecomposition.h"
+#include "src/Eigenvalues/ComplexSchur.h"
+#include "src/Eigenvalues/ComplexEigenSolver.h"
+#include "src/Eigenvalues/RealQZ.h"
+#include "src/Eigenvalues/GeneralizedEigenSolver.h"
+#include "src/Eigenvalues/MatrixBaseEigenvalues.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/Eigenvalues/RealSchur_LAPACKE.h"
+#include "src/Eigenvalues/ComplexSchur_LAPACKE.h"
+#include "src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_EIGENVALUES_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/Geometry b/C++/yolo_bytetrack/include/Eigen/Geometry
new file mode 100644
index 00000000..bc78110a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/Geometry
@@ -0,0 +1,59 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GEOMETRY_MODULE_H
+#define EIGEN_GEOMETRY_MODULE_H
+
+#include "Core"
+
+#include "SVD"
+#include "LU"
+#include <limits>
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Geometry_Module Geometry module
+  *
+  * This module provides support for:
+  *  - fixed-size homogeneous transformations
+  *  - translation, scaling, 2D and 3D rotations
+  *  - \link Quaternion quaternions \endlink
+  *  - cross products (\ref MatrixBase::cross, \ref MatrixBase::cross3)
+  *  - orthognal vector generation (\ref MatrixBase::unitOrthogonal)
+  *  - some linear components: \link ParametrizedLine parametrized-lines \endlink and \link Hyperplane hyperplanes \endlink
+  *  - \link AlignedBox axis aligned bounding boxes \endlink
+  *  - \link umeyama least-square transformation fitting \endlink
+  *
+  * \code
+  * #include <Eigen/Geometry>
+  * \endcode
+  */
+
+#include "src/Geometry/OrthoMethods.h"
+#include "src/Geometry/EulerAngles.h"
+
+#include "src/Geometry/Homogeneous.h"
+#include "src/Geometry/RotationBase.h"
+#include "src/Geometry/Rotation2D.h"
+#include "src/Geometry/Quaternion.h"
+#include "src/Geometry/AngleAxis.h"
+#include "src/Geometry/Transform.h"
+#include "src/Geometry/Translation.h"
+#include "src/Geometry/Scaling.h"
+#include "src/Geometry/Hyperplane.h"
+#include "src/Geometry/ParametrizedLine.h"
+#include "src/Geometry/AlignedBox.h"
+#include "src/Geometry/Umeyama.h"
+
+// Use the SSE optimized version whenever possible.
+#if (defined EIGEN_VECTORIZE_SSE) || (defined EIGEN_VECTORIZE_NEON)
+#include "src/Geometry/arch/Geometry_SIMD.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_GEOMETRY_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/Householder b/C++/yolo_bytetrack/include/Eigen/Householder
new file mode 100644
index 00000000..f2fa7996
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/Householder
@@ -0,0 +1,29 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOUSEHOLDER_MODULE_H
+#define EIGEN_HOUSEHOLDER_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Householder_Module Householder module
+  * This module provides Householder transformations.
+  *
+  * \code
+  * #include <Eigen/Householder>
+  * \endcode
+  */
+
+#include "src/Householder/Householder.h"
+#include "src/Householder/HouseholderSequence.h"
+#include "src/Householder/BlockHouseholder.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_HOUSEHOLDER_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/IterativeLinearSolvers b/C++/yolo_bytetrack/include/Eigen/IterativeLinearSolvers
new file mode 100644
index 00000000..957d5750
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/IterativeLinearSolvers
@@ -0,0 +1,48 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
+#define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
+
+#include "SparseCore"
+#include "OrderingMethods"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** 
+  * \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module
+  *
+  * This module currently provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a squared matrix, usually very large and sparse.
+  * Those solvers are accessible via the following classes:
+  *  - ConjugateGradient for selfadjoint (hermitian) matrices,
+  *  - LeastSquaresConjugateGradient for rectangular least-square problems,
+  *  - BiCGSTAB for general square matrices.
+  *
+  * These iterative solvers are associated with some preconditioners:
+  *  - IdentityPreconditioner - not really useful
+  *  - DiagonalPreconditioner - also called Jacobi preconditioner, work very well on diagonal dominant matrices.
+  *  - IncompleteLUT - incomplete LU factorization with dual thresholding
+  *
+  * Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport.
+  *
+    \code
+    #include <Eigen/IterativeLinearSolvers>
+    \endcode
+  */
+
+#include "src/IterativeLinearSolvers/SolveWithGuess.h"
+#include "src/IterativeLinearSolvers/IterativeSolverBase.h"
+#include "src/IterativeLinearSolvers/BasicPreconditioners.h"
+#include "src/IterativeLinearSolvers/ConjugateGradient.h"
+#include "src/IterativeLinearSolvers/LeastSquareConjugateGradient.h"
+#include "src/IterativeLinearSolvers/BiCGSTAB.h"
+#include "src/IterativeLinearSolvers/IncompleteLUT.h"
+#include "src/IterativeLinearSolvers/IncompleteCholesky.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/Jacobi b/C++/yolo_bytetrack/include/Eigen/Jacobi
new file mode 100644
index 00000000..43edc7a1
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/Jacobi
@@ -0,0 +1,32 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_JACOBI_MODULE_H
+#define EIGEN_JACOBI_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Jacobi_Module Jacobi module
+  * This module provides Jacobi and Givens rotations.
+  *
+  * \code
+  * #include <Eigen/Jacobi>
+  * \endcode
+  *
+  * In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation:
+  *  - MatrixBase::applyOnTheLeft()
+  *  - MatrixBase::applyOnTheRight().
+  */
+
+#include "src/Jacobi/Jacobi.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_JACOBI_MODULE_H
+
diff --git a/C++/yolo_bytetrack/include/Eigen/KLUSupport b/C++/yolo_bytetrack/include/Eigen/KLUSupport
new file mode 100644
index 00000000..b23d9053
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/KLUSupport
@@ -0,0 +1,41 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_KLUSUPPORT_MODULE_H
+#define EIGEN_KLUSUPPORT_MODULE_H
+
+#include <Eigen/SparseCore>
+
+#include <Eigen/src/Core/util/DisableStupidWarnings.h>
+
+extern "C" {
+#include <btf.h>
+#include <klu.h>
+   }
+
+/** \ingroup Support_modules
+  * \defgroup KLUSupport_Module KLUSupport module
+  *
+  * This module provides an interface to the KLU library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
+  * It provides the following factorization class:
+  * - class KLU: a sparse LU factorization, well-suited for circuit simulation.
+  *
+  * \code
+  * #include <Eigen/KLUSupport>
+  * \endcode
+  *
+  * In order to use this module, the klu and btf headers must be accessible from the include paths, and your binary must be linked to the klu library and its dependencies.
+  * The dependencies depend on how umfpack has been compiled.
+  * For a cmake based project, you can use our FindKLU.cmake module to help you in this task.
+  *
+  */
+
+#include "src/KLUSupport/KLUSupport.h"
+
+#include <Eigen/src/Core/util/ReenableStupidWarnings.h>
+
+#endif // EIGEN_KLUSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/LU b/C++/yolo_bytetrack/include/Eigen/LU
new file mode 100644
index 00000000..1236ceb0
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/LU
@@ -0,0 +1,47 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LU_MODULE_H
+#define EIGEN_LU_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup LU_Module LU module
+  * This module includes %LU decomposition and related notions such as matrix inversion and determinant.
+  * This module defines the following MatrixBase methods:
+  *  - MatrixBase::inverse()
+  *  - MatrixBase::determinant()
+  *
+  * \code
+  * #include <Eigen/LU>
+  * \endcode
+  */
+
+#include "src/misc/Kernel.h"
+#include "src/misc/Image.h"
+#include "src/LU/FullPivLU.h"
+#include "src/LU/PartialPivLU.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/LU/PartialPivLU_LAPACKE.h"
+#endif
+#include "src/LU/Determinant.h"
+#include "src/LU/InverseImpl.h"
+
+#if defined EIGEN_VECTORIZE_SSE || defined EIGEN_VECTORIZE_NEON
+  #include "src/LU/arch/InverseSize4.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_LU_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/MetisSupport b/C++/yolo_bytetrack/include/Eigen/MetisSupport
new file mode 100644
index 00000000..85c41bf3
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/MetisSupport
@@ -0,0 +1,35 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_METISSUPPORT_MODULE_H
+#define EIGEN_METISSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+extern "C" {
+#include <metis.h>
+}
+
+
+/** \ingroup Support_modules
+  * \defgroup MetisSupport_Module MetisSupport module
+  *
+  * \code
+  * #include <Eigen/MetisSupport>
+  * \endcode
+  * This module defines an interface to the METIS reordering package (http://glaros.dtc.umn.edu/gkhome/views/metis). 
+  * It can be used just as any other built-in method as explained in \link OrderingMethods_Module here. \endlink
+  */
+
+
+#include "src/MetisSupport/MetisSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_METISSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/OrderingMethods b/C++/yolo_bytetrack/include/Eigen/OrderingMethods
new file mode 100644
index 00000000..29691a62
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/OrderingMethods
@@ -0,0 +1,70 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ORDERINGMETHODS_MODULE_H
+#define EIGEN_ORDERINGMETHODS_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** 
+  * \defgroup OrderingMethods_Module OrderingMethods module
+  *
+  * This module is currently for internal use only
+  * 
+  * It defines various built-in and external ordering methods for sparse matrices. 
+  * They are typically used to reduce the number of elements during 
+  * the sparse matrix decomposition (LLT, LU, QR).
+  * Precisely, in a preprocessing step, a permutation matrix P is computed using 
+  * those ordering methods and applied to the columns of the matrix. 
+  * Using for instance the sparse Cholesky decomposition, it is expected that 
+  * the nonzeros elements in LLT(A*P) will be much smaller than that in LLT(A).
+  * 
+  * 
+  * Usage : 
+  * \code
+  * #include <Eigen/OrderingMethods>
+  * \endcode
+  * 
+  * A simple usage is as a template parameter in the sparse decomposition classes : 
+  * 
+  * \code 
+  * SparseLU<MatrixType, COLAMDOrdering<int> > solver;
+  * \endcode 
+  * 
+  * \code 
+  * SparseQR<MatrixType, COLAMDOrdering<int> > solver;
+  * \endcode
+  * 
+  * It is possible as well to call directly a particular ordering method for your own purpose, 
+  * \code 
+  * AMDOrdering<int> ordering;
+  * PermutationMatrix<Dynamic, Dynamic, int> perm;
+  * SparseMatrix<double> A; 
+  * //Fill the matrix ...
+  * 
+  * ordering(A, perm); // Call AMD
+  * \endcode
+  * 
+  * \note Some of these methods (like AMD or METIS), need the sparsity pattern 
+  * of the input matrix to be symmetric. When the matrix is structurally unsymmetric, 
+  * Eigen computes internally the pattern of \f$A^T*A\f$ before calling the method.
+  * If your matrix is already symmetric (at leat in structure), you can avoid that
+  * by calling the method with a SelfAdjointView type.
+  * 
+  * \code
+  *  // Call the ordering on the pattern of the lower triangular matrix A
+  * ordering(A.selfadjointView<Lower>(), perm);
+  * \endcode
+  */
+
+#include "src/OrderingMethods/Amd.h"
+#include "src/OrderingMethods/Ordering.h"
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_ORDERINGMETHODS_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/PaStiXSupport b/C++/yolo_bytetrack/include/Eigen/PaStiXSupport
new file mode 100644
index 00000000..234619ac
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/PaStiXSupport
@@ -0,0 +1,49 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PASTIXSUPPORT_MODULE_H
+#define EIGEN_PASTIXSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+extern "C" {
+#include <pastix_nompi.h>
+#include <pastix.h>
+}
+
+#ifdef complex
+#undef complex
+#endif
+
+/** \ingroup Support_modules
+  * \defgroup PaStiXSupport_Module PaStiXSupport module
+  * 
+  * This module provides an interface to the <a href="http://pastix.gforge.inria.fr/">PaSTiX</a> library.
+  * PaSTiX is a general \b supernodal, \b parallel and \b opensource sparse solver.
+  * It provides the two following main factorization classes:
+  * - class PastixLLT : a supernodal, parallel LLt Cholesky factorization.
+  * - class PastixLDLT: a supernodal, parallel LDLt Cholesky factorization.
+  * - class PastixLU : a supernodal, parallel LU factorization (optimized for a symmetric pattern).
+  * 
+  * \code
+  * #include <Eigen/PaStiXSupport>
+  * \endcode
+  *
+  * In order to use this module, the PaSTiX headers must be accessible from the include paths, and your binary must be linked to the PaSTiX library and its dependencies.
+  * This wrapper resuires PaStiX version 5.x compiled without MPI support.
+  * The dependencies depend on how PaSTiX has been compiled.
+  * For a cmake based project, you can use our FindPaSTiX.cmake module to help you in this task.
+  *
+  */
+
+#include "src/PaStiXSupport/PaStiXSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_PASTIXSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/PardisoSupport b/C++/yolo_bytetrack/include/Eigen/PardisoSupport
new file mode 100644
index 00000000..340edf51
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/PardisoSupport
@@ -0,0 +1,35 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARDISOSUPPORT_MODULE_H
+#define EIGEN_PARDISOSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#include <mkl_pardiso.h>
+
+/** \ingroup Support_modules
+  * \defgroup PardisoSupport_Module PardisoSupport module
+  *
+  * This module brings support for the Intel(R) MKL PARDISO direct sparse solvers.
+  *
+  * \code
+  * #include <Eigen/PardisoSupport>
+  * \endcode
+  *
+  * In order to use this module, the MKL headers must be accessible from the include paths, and your binary must be linked to the MKL library and its dependencies.
+  * See this \ref TopicUsingIntelMKL "page" for more information on MKL-Eigen integration.
+  * 
+  */
+
+#include "src/PardisoSupport/PardisoSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_PARDISOSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/QR b/C++/yolo_bytetrack/include/Eigen/QR
new file mode 100644
index 00000000..8465b62c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/QR
@@ -0,0 +1,50 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_QR_MODULE_H
+#define EIGEN_QR_MODULE_H
+
+#include "Core"
+
+#include "Cholesky"
+#include "Jacobi"
+#include "Householder"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup QR_Module QR module
+  *
+  *
+  *
+  * This module provides various QR decompositions
+  * This module also provides some MatrixBase methods, including:
+  *  - MatrixBase::householderQr()
+  *  - MatrixBase::colPivHouseholderQr()
+  *  - MatrixBase::fullPivHouseholderQr()
+  *
+  * \code
+  * #include <Eigen/QR>
+  * \endcode
+  */
+
+#include "src/QR/HouseholderQR.h"
+#include "src/QR/FullPivHouseholderQR.h"
+#include "src/QR/ColPivHouseholderQR.h"
+#include "src/QR/CompleteOrthogonalDecomposition.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/QR/HouseholderQR_LAPACKE.h"
+#include "src/QR/ColPivHouseholderQR_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_QR_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/QtAlignedMalloc b/C++/yolo_bytetrack/include/Eigen/QtAlignedMalloc
new file mode 100644
index 00000000..6fe82374
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/QtAlignedMalloc
@@ -0,0 +1,39 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_QTMALLOC_MODULE_H
+#define EIGEN_QTMALLOC_MODULE_H
+
+#include "Core"
+
+#if (!EIGEN_MALLOC_ALREADY_ALIGNED)
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+void *qMalloc(std::size_t size)
+{
+  return Eigen::internal::aligned_malloc(size);
+}
+
+void qFree(void *ptr)
+{
+  Eigen::internal::aligned_free(ptr);
+}
+
+void *qRealloc(void *ptr, std::size_t size)
+{
+  void* newPtr = Eigen::internal::aligned_malloc(size);
+  std::memcpy(newPtr, ptr, size);
+  Eigen::internal::aligned_free(ptr);
+  return newPtr;
+}
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif
+
+#endif // EIGEN_QTMALLOC_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/SPQRSupport b/C++/yolo_bytetrack/include/Eigen/SPQRSupport
new file mode 100644
index 00000000..f70390c1
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/SPQRSupport
@@ -0,0 +1,34 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPQRSUPPORT_MODULE_H
+#define EIGEN_SPQRSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#include "SuiteSparseQR.hpp"
+
+/** \ingroup Support_modules
+  * \defgroup SPQRSupport_Module SuiteSparseQR module
+  * 
+  * This module provides an interface to the SPQR library, which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
+  *
+  * \code
+  * #include <Eigen/SPQRSupport>
+  * \endcode
+  *
+  * In order to use this module, the SPQR headers must be accessible from the include paths, and your binary must be linked to the SPQR library and its dependencies (Cholmod, AMD, COLAMD,...).
+  * For a cmake based project, you can use our FindSPQR.cmake and FindCholmod.Cmake modules
+  *
+  */
+
+#include "src/CholmodSupport/CholmodSupport.h"
+#include "src/SPQRSupport/SuiteSparseQRSupport.h"
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/SVD b/C++/yolo_bytetrack/include/Eigen/SVD
new file mode 100644
index 00000000..34517949
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/SVD
@@ -0,0 +1,50 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SVD_MODULE_H
+#define EIGEN_SVD_MODULE_H
+
+#include "QR"
+#include "Householder"
+#include "Jacobi"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup SVD_Module SVD module
+  *
+  *
+  *
+  * This module provides SVD decomposition for matrices (both real and complex).
+  * Two decomposition algorithms are provided:
+  *  - JacobiSVD implementing two-sided Jacobi iterations is numerically very accurate, fast for small matrices, but very slow for larger ones.
+  *  - BDCSVD implementing a recursive divide & conquer strategy on top of an upper-bidiagonalization which remains fast for large problems.
+  * These decompositions are accessible via the respective classes and following MatrixBase methods:
+  *  - MatrixBase::jacobiSvd()
+  *  - MatrixBase::bdcSvd()
+  *
+  * \code
+  * #include <Eigen/SVD>
+  * \endcode
+  */
+
+#include "src/misc/RealSvd2x2.h"
+#include "src/SVD/UpperBidiagonalization.h"
+#include "src/SVD/SVDBase.h"
+#include "src/SVD/JacobiSVD.h"
+#include "src/SVD/BDCSVD.h"
+#if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT)
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/SVD/JacobiSVD_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_SVD_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/Sparse b/C++/yolo_bytetrack/include/Eigen/Sparse
new file mode 100644
index 00000000..a2ef7a66
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/Sparse
@@ -0,0 +1,34 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_MODULE_H
+#define EIGEN_SPARSE_MODULE_H
+
+/** \defgroup Sparse_Module Sparse meta-module
+  *
+  * Meta-module including all related modules:
+  * - \ref SparseCore_Module
+  * - \ref OrderingMethods_Module
+  * - \ref SparseCholesky_Module
+  * - \ref SparseLU_Module
+  * - \ref SparseQR_Module
+  * - \ref IterativeLinearSolvers_Module
+  *
+    \code
+    #include <Eigen/Sparse>
+    \endcode
+  */
+
+#include "SparseCore"
+#include "OrderingMethods"
+#include "SparseCholesky"
+#include "SparseLU"
+#include "SparseQR"
+#include "IterativeLinearSolvers"
+
+#endif // EIGEN_SPARSE_MODULE_H
+
diff --git a/C++/yolo_bytetrack/include/Eigen/SparseCholesky b/C++/yolo_bytetrack/include/Eigen/SparseCholesky
new file mode 100644
index 00000000..d2b1f127
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/SparseCholesky
@@ -0,0 +1,37 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2013 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSECHOLESKY_MODULE_H
+#define EIGEN_SPARSECHOLESKY_MODULE_H
+
+#include "SparseCore"
+#include "OrderingMethods"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** 
+  * \defgroup SparseCholesky_Module SparseCholesky module
+  *
+  * This module currently provides two variants of the direct sparse Cholesky decomposition for selfadjoint (hermitian) matrices.
+  * Those decompositions are accessible via the following classes:
+  *  - SimplicialLLt,
+  *  - SimplicialLDLt
+  *
+  * Such problems can also be solved using the ConjugateGradient solver from the IterativeLinearSolvers module.
+  *
+  * \code
+  * #include <Eigen/SparseCholesky>
+  * \endcode
+  */
+
+#include "src/SparseCholesky/SimplicialCholesky.h"
+#include "src/SparseCholesky/SimplicialCholesky_impl.h"
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_SPARSECHOLESKY_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/SparseCore b/C++/yolo_bytetrack/include/Eigen/SparseCore
new file mode 100644
index 00000000..76966c4c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/SparseCore
@@ -0,0 +1,69 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSECORE_MODULE_H
+#define EIGEN_SPARSECORE_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#include <vector>
+#include <map>
+#include <cstdlib>
+#include <cstring>
+#include <algorithm>
+
+/** 
+  * \defgroup SparseCore_Module SparseCore module
+  *
+  * This module provides a sparse matrix representation, and basic associated matrix manipulations
+  * and operations.
+  *
+  * See the \ref TutorialSparse "Sparse tutorial"
+  *
+  * \code
+  * #include <Eigen/SparseCore>
+  * \endcode
+  *
+  * This module depends on: Core.
+  */
+
+#include "src/SparseCore/SparseUtil.h"
+#include "src/SparseCore/SparseMatrixBase.h"
+#include "src/SparseCore/SparseAssign.h"
+#include "src/SparseCore/CompressedStorage.h"
+#include "src/SparseCore/AmbiVector.h"
+#include "src/SparseCore/SparseCompressedBase.h"
+#include "src/SparseCore/SparseMatrix.h"
+#include "src/SparseCore/SparseMap.h"
+#include "src/SparseCore/MappedSparseMatrix.h"
+#include "src/SparseCore/SparseVector.h"
+#include "src/SparseCore/SparseRef.h"
+#include "src/SparseCore/SparseCwiseUnaryOp.h"
+#include "src/SparseCore/SparseCwiseBinaryOp.h"
+#include "src/SparseCore/SparseTranspose.h"
+#include "src/SparseCore/SparseBlock.h"
+#include "src/SparseCore/SparseDot.h"
+#include "src/SparseCore/SparseRedux.h"
+#include "src/SparseCore/SparseView.h"
+#include "src/SparseCore/SparseDiagonalProduct.h"
+#include "src/SparseCore/ConservativeSparseSparseProduct.h"
+#include "src/SparseCore/SparseSparseProductWithPruning.h"
+#include "src/SparseCore/SparseProduct.h"
+#include "src/SparseCore/SparseDenseProduct.h"
+#include "src/SparseCore/SparseSelfAdjointView.h"
+#include "src/SparseCore/SparseTriangularView.h"
+#include "src/SparseCore/TriangularSolver.h"
+#include "src/SparseCore/SparsePermutation.h"
+#include "src/SparseCore/SparseFuzzy.h"
+#include "src/SparseCore/SparseSolverBase.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_SPARSECORE_MODULE_H
+
diff --git a/C++/yolo_bytetrack/include/Eigen/SparseLU b/C++/yolo_bytetrack/include/Eigen/SparseLU
new file mode 100644
index 00000000..37c4a5c5
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/SparseLU
@@ -0,0 +1,50 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSELU_MODULE_H
+#define EIGEN_SPARSELU_MODULE_H
+
+#include "SparseCore"
+
+/** 
+  * \defgroup SparseLU_Module SparseLU module
+  * This module defines a supernodal factorization of general sparse matrices.
+  * The code is fully optimized for supernode-panel updates with specialized kernels.
+  * Please, see the documentation of the SparseLU class for more details.
+  */
+
+// Ordering interface
+#include "OrderingMethods"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#include "src/SparseLU/SparseLU_gemm_kernel.h"
+
+#include "src/SparseLU/SparseLU_Structs.h"
+#include "src/SparseLU/SparseLU_SupernodalMatrix.h"
+#include "src/SparseLU/SparseLUImpl.h"
+#include "src/SparseCore/SparseColEtree.h"
+#include "src/SparseLU/SparseLU_Memory.h"
+#include "src/SparseLU/SparseLU_heap_relax_snode.h"
+#include "src/SparseLU/SparseLU_relax_snode.h"
+#include "src/SparseLU/SparseLU_pivotL.h"
+#include "src/SparseLU/SparseLU_panel_dfs.h"
+#include "src/SparseLU/SparseLU_kernel_bmod.h"
+#include "src/SparseLU/SparseLU_panel_bmod.h"
+#include "src/SparseLU/SparseLU_column_dfs.h"
+#include "src/SparseLU/SparseLU_column_bmod.h"
+#include "src/SparseLU/SparseLU_copy_to_ucol.h"
+#include "src/SparseLU/SparseLU_pruneL.h"
+#include "src/SparseLU/SparseLU_Utils.h"
+#include "src/SparseLU/SparseLU.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_SPARSELU_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/SparseQR b/C++/yolo_bytetrack/include/Eigen/SparseQR
new file mode 100644
index 00000000..f5fc5fa7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/SparseQR
@@ -0,0 +1,36 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEQR_MODULE_H
+#define EIGEN_SPARSEQR_MODULE_H
+
+#include "SparseCore"
+#include "OrderingMethods"
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup SparseQR_Module SparseQR module
+  * \brief Provides QR decomposition for sparse matrices
+  * 
+  * This module provides a simplicial version of the left-looking Sparse QR decomposition. 
+  * The columns of the input matrix should be reordered to limit the fill-in during the 
+  * decomposition. Built-in methods (COLAMD, AMD) or external  methods (METIS) can be used to this end.
+  * See the \link OrderingMethods_Module OrderingMethods\endlink module for the list 
+  * of built-in and external ordering methods.
+  * 
+  * \code
+  * #include <Eigen/SparseQR>
+  * \endcode
+  * 
+  * 
+  */
+
+#include "src/SparseCore/SparseColEtree.h"
+#include "src/SparseQR/SparseQR.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/StdDeque b/C++/yolo_bytetrack/include/Eigen/StdDeque
new file mode 100644
index 00000000..bc68397b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/StdDeque
@@ -0,0 +1,27 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDDEQUE_MODULE_H
+#define EIGEN_STDDEQUE_MODULE_H
+
+#include "Core"
+#include <deque>
+
+#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
+
+#define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...)
+
+#else
+
+#include "src/StlSupport/StdDeque.h"
+
+#endif
+
+#endif // EIGEN_STDDEQUE_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/StdList b/C++/yolo_bytetrack/include/Eigen/StdList
new file mode 100644
index 00000000..4c6262c0
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/StdList
@@ -0,0 +1,26 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDLIST_MODULE_H
+#define EIGEN_STDLIST_MODULE_H
+
+#include "Core"
+#include <list>
+
+#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
+
+#define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...)
+
+#else
+
+#include "src/StlSupport/StdList.h"
+
+#endif
+
+#endif // EIGEN_STDLIST_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/StdVector b/C++/yolo_bytetrack/include/Eigen/StdVector
new file mode 100644
index 00000000..0c4697ad
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/StdVector
@@ -0,0 +1,27 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDVECTOR_MODULE_H
+#define EIGEN_STDVECTOR_MODULE_H
+
+#include "Core"
+#include <vector>
+
+#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
+
+#define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...)
+
+#else
+
+#include "src/StlSupport/StdVector.h"
+
+#endif
+
+#endif // EIGEN_STDVECTOR_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/SuperLUSupport b/C++/yolo_bytetrack/include/Eigen/SuperLUSupport
new file mode 100644
index 00000000..59312a82
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/SuperLUSupport
@@ -0,0 +1,64 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SUPERLUSUPPORT_MODULE_H
+#define EIGEN_SUPERLUSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#ifdef EMPTY
+#define EIGEN_EMPTY_WAS_ALREADY_DEFINED
+#endif
+
+typedef int int_t;
+#include <slu_Cnames.h>
+#include <supermatrix.h>
+#include <slu_util.h>
+
+// slu_util.h defines a preprocessor token named EMPTY which is really polluting,
+// so we remove it in favor of a SUPERLU_EMPTY token.
+// If EMPTY was already defined then we don't undef it.
+
+#if defined(EIGEN_EMPTY_WAS_ALREADY_DEFINED)
+# undef EIGEN_EMPTY_WAS_ALREADY_DEFINED
+#elif defined(EMPTY)
+# undef EMPTY
+#endif
+
+#define SUPERLU_EMPTY (-1)
+
+namespace Eigen { struct SluMatrix; }
+
+/** \ingroup Support_modules
+  * \defgroup SuperLUSupport_Module SuperLUSupport module
+  *
+  * This module provides an interface to the <a href="http://crd-legacy.lbl.gov/~xiaoye/SuperLU/">SuperLU</a> library.
+  * It provides the following factorization class:
+  * - class SuperLU: a supernodal sequential LU factorization.
+  * - class SuperILU: a supernodal sequential incomplete LU factorization (to be used as a preconditioner for iterative methods).
+  *
+  * \warning This wrapper requires at least versions 4.0 of SuperLU. The 3.x versions are not supported.
+  *
+  * \warning When including this module, you have to use SUPERLU_EMPTY instead of EMPTY which is no longer defined because it is too polluting.
+  *
+  * \code
+  * #include <Eigen/SuperLUSupport>
+  * \endcode
+  *
+  * In order to use this module, the superlu headers must be accessible from the include paths, and your binary must be linked to the superlu library and its dependencies.
+  * The dependencies depend on how superlu has been compiled.
+  * For a cmake based project, you can use our FindSuperLU.cmake module to help you in this task.
+  *
+  */
+
+#include "src/SuperLUSupport/SuperLUSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_SUPERLUSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/UmfPackSupport b/C++/yolo_bytetrack/include/Eigen/UmfPackSupport
new file mode 100644
index 00000000..00eec808
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/UmfPackSupport
@@ -0,0 +1,40 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UMFPACKSUPPORT_MODULE_H
+#define EIGEN_UMFPACKSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+extern "C" {
+#include <umfpack.h>
+}
+
+/** \ingroup Support_modules
+  * \defgroup UmfPackSupport_Module UmfPackSupport module
+  *
+  * This module provides an interface to the UmfPack library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
+  * It provides the following factorization class:
+  * - class UmfPackLU: a multifrontal sequential LU factorization.
+  *
+  * \code
+  * #include <Eigen/UmfPackSupport>
+  * \endcode
+  *
+  * In order to use this module, the umfpack headers must be accessible from the include paths, and your binary must be linked to the umfpack library and its dependencies.
+  * The dependencies depend on how umfpack has been compiled.
+  * For a cmake based project, you can use our FindUmfPack.cmake module to help you in this task.
+  *
+  */
+
+#include "src/UmfPackSupport/UmfPackSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_UMFPACKSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Cholesky/LDLT.h b/C++/yolo_bytetrack/include/Eigen/src/Cholesky/LDLT.h
new file mode 100644
index 00000000..1013ca04
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Cholesky/LDLT.h
@@ -0,0 +1,688 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Keir Mierle <mierle@gmail.com>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2011 Timothy E. Holy <tim.holy@gmail.com >
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LDLT_H
+#define EIGEN_LDLT_H
+
+namespace Eigen {
+
+namespace internal {
+  template<typename _MatrixType, int _UpLo> struct traits<LDLT<_MatrixType, _UpLo> >
+   : traits<_MatrixType>
+  {
+    typedef MatrixXpr XprKind;
+    typedef SolverStorage StorageKind;
+    typedef int StorageIndex;
+    enum { Flags = 0 };
+  };
+
+  template<typename MatrixType, int UpLo> struct LDLT_Traits;
+
+  // PositiveSemiDef means positive semi-definite and non-zero; same for NegativeSemiDef
+  enum SignMatrix { PositiveSemiDef, NegativeSemiDef, ZeroSign, Indefinite };
+}
+
+/** \ingroup Cholesky_Module
+  *
+  * \class LDLT
+  *
+  * \brief Robust Cholesky decomposition of a matrix with pivoting
+  *
+  * \tparam _MatrixType the type of the matrix of which to compute the LDL^T Cholesky decomposition
+  * \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
+  *             The other triangular part won't be read.
+  *
+  * Perform a robust Cholesky decomposition of a positive semidefinite or negative semidefinite
+  * matrix \f$ A \f$ such that \f$ A =  P^TLDL^*P \f$, where P is a permutation matrix, L
+  * is lower triangular with a unit diagonal and D is a diagonal matrix.
+  *
+  * The decomposition uses pivoting to ensure stability, so that D will have
+  * zeros in the bottom right rank(A) - n submatrix. Avoiding the square root
+  * on D also stabilizes the computation.
+  *
+  * Remember that Cholesky decompositions are not rank-revealing. Also, do not use a Cholesky
+  * decomposition to determine whether a system of equations has a solution.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * \sa MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT
+  */
+template<typename _MatrixType, int _UpLo> class LDLT
+        : public SolverBase<LDLT<_MatrixType, _UpLo> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<LDLT> Base;
+    friend class SolverBase<LDLT>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(LDLT)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+      UpLo = _UpLo
+    };
+    typedef Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1> TmpMatrixType;
+
+    typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType;
+    typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType;
+
+    typedef internal::LDLT_Traits<MatrixType,UpLo> Traits;
+
+    /** \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via LDLT::compute(const MatrixType&).
+      */
+    LDLT()
+      : m_matrix(),
+        m_transpositions(),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa LDLT()
+      */
+    explicit LDLT(Index size)
+      : m_matrix(size, size),
+        m_transpositions(size),
+        m_temporary(size),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {}
+
+    /** \brief Constructor with decomposition
+      *
+      * This calculates the decomposition for the input \a matrix.
+      *
+      * \sa LDLT(Index size)
+      */
+    template<typename InputType>
+    explicit LDLT(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.rows(), matrix.cols()),
+        m_transpositions(matrix.rows()),
+        m_temporary(matrix.rows()),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a LDLT factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa LDLT(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit LDLT(EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_transpositions(matrix.rows()),
+        m_temporary(matrix.rows()),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** Clear any existing decomposition
+     * \sa rankUpdate(w,sigma)
+     */
+    void setZero()
+    {
+      m_isInitialized = false;
+    }
+
+    /** \returns a view of the upper triangular matrix U */
+    inline typename Traits::MatrixU matrixU() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return Traits::getU(m_matrix);
+    }
+
+    /** \returns a view of the lower triangular matrix L */
+    inline typename Traits::MatrixL matrixL() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return Traits::getL(m_matrix);
+    }
+
+    /** \returns the permutation matrix P as a transposition sequence.
+      */
+    inline const TranspositionType& transpositionsP() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_transpositions;
+    }
+
+    /** \returns the coefficients of the diagonal matrix D */
+    inline Diagonal<const MatrixType> vectorD() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_matrix.diagonal();
+    }
+
+    /** \returns true if the matrix is positive (semidefinite) */
+    inline bool isPositive() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_sign == internal::PositiveSemiDef || m_sign == internal::ZeroSign;
+    }
+
+    /** \returns true if the matrix is negative (semidefinite) */
+    inline bool isNegative(void) const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_sign == internal::NegativeSemiDef || m_sign == internal::ZeroSign;
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \returns a solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * This function also supports in-place solves using the syntax <tt>x = decompositionObject.solve(x)</tt> .
+      *
+      * \note_about_checking_solutions
+      *
+      * More precisely, this method solves \f$ A x = b \f$ using the decomposition \f$ A = P^T L D L^* P \f$
+      * by solving the systems \f$ P^T y_1 = b \f$, \f$ L y_2 = y_1 \f$, \f$ D y_3 = y_2 \f$,
+      * \f$ L^* y_4 = y_3 \f$ and \f$ P x = y_4 \f$ in succession. If the matrix \f$ A \f$ is singular, then
+      * \f$ D \f$ will also be singular (all the other matrices are invertible). In that case, the
+      * least-square solution of \f$ D y_3 = y_2 \f$ is computed. This does not mean that this function
+      * computes the least-square solution of \f$ A x = b \f$ if \f$ A \f$ is singular.
+      *
+      * \sa MatrixBase::ldlt(), SelfAdjointView::ldlt()
+      */
+    template<typename Rhs>
+    inline const Solve<LDLT, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    template<typename Derived>
+    bool solveInPlace(MatrixBase<Derived> &bAndX) const;
+
+    template<typename InputType>
+    LDLT& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of
+     *  which \c *this is the LDLT decomposition.
+     */
+    RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    template <typename Derived>
+    LDLT& rankUpdate(const MatrixBase<Derived>& w, const RealScalar& alpha=1);
+
+    /** \returns the internal LDLT decomposition matrix
+      *
+      * TODO: document the storage layout
+      */
+    inline const MatrixType& matrixLDLT() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_matrix;
+    }
+
+    MatrixType reconstructedMatrix() const;
+
+    /** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
+      *
+      * This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
+      * \code x = decomposition.adjoint().solve(b) \endcode
+      */
+    const LDLT& adjoint() const { return *this; };
+
+    EIGEN_DEVICE_FUNC inline EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    EIGEN_DEVICE_FUNC inline EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the factorization failed because of a zero pivot.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_info;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    /** \internal
+      * Used to compute and store the Cholesky decomposition A = L D L^* = U^* D U.
+      * The strict upper part is used during the decomposition, the strict lower
+      * part correspond to the coefficients of L (its diagonal is equal to 1 and
+      * is not stored), and the diagonal entries correspond to D.
+      */
+    MatrixType m_matrix;
+    RealScalar m_l1_norm;
+    TranspositionType m_transpositions;
+    TmpMatrixType m_temporary;
+    internal::SignMatrix m_sign;
+    bool m_isInitialized;
+    ComputationInfo m_info;
+};
+
+namespace internal {
+
+template<int UpLo> struct ldlt_inplace;
+
+template<> struct ldlt_inplace<Lower>
+{
+  template<typename MatrixType, typename TranspositionType, typename Workspace>
+  static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign)
+  {
+    using std::abs;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename TranspositionType::StorageIndex IndexType;
+    eigen_assert(mat.rows()==mat.cols());
+    const Index size = mat.rows();
+    bool found_zero_pivot = false;
+    bool ret = true;
+
+    if (size <= 1)
+    {
+      transpositions.setIdentity();
+      if(size==0) sign = ZeroSign;
+      else if (numext::real(mat.coeff(0,0)) > static_cast<RealScalar>(0) ) sign = PositiveSemiDef;
+      else if (numext::real(mat.coeff(0,0)) < static_cast<RealScalar>(0)) sign = NegativeSemiDef;
+      else sign = ZeroSign;
+      return true;
+    }
+
+    for (Index k = 0; k < size; ++k)
+    {
+      // Find largest diagonal element
+      Index index_of_biggest_in_corner;
+      mat.diagonal().tail(size-k).cwiseAbs().maxCoeff(&index_of_biggest_in_corner);
+      index_of_biggest_in_corner += k;
+
+      transpositions.coeffRef(k) = IndexType(index_of_biggest_in_corner);
+      if(k != index_of_biggest_in_corner)
+      {
+        // apply the transposition while taking care to consider only
+        // the lower triangular part
+        Index s = size-index_of_biggest_in_corner-1; // trailing size after the biggest element
+        mat.row(k).head(k).swap(mat.row(index_of_biggest_in_corner).head(k));
+        mat.col(k).tail(s).swap(mat.col(index_of_biggest_in_corner).tail(s));
+        std::swap(mat.coeffRef(k,k),mat.coeffRef(index_of_biggest_in_corner,index_of_biggest_in_corner));
+        for(Index i=k+1;i<index_of_biggest_in_corner;++i)
+        {
+          Scalar tmp = mat.coeffRef(i,k);
+          mat.coeffRef(i,k) = numext::conj(mat.coeffRef(index_of_biggest_in_corner,i));
+          mat.coeffRef(index_of_biggest_in_corner,i) = numext::conj(tmp);
+        }
+        if(NumTraits<Scalar>::IsComplex)
+          mat.coeffRef(index_of_biggest_in_corner,k) = numext::conj(mat.coeff(index_of_biggest_in_corner,k));
+      }
+
+      // partition the matrix:
+      //       A00 |  -  |  -
+      // lu  = A10 | A11 |  -
+      //       A20 | A21 | A22
+      Index rs = size - k - 1;
+      Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
+      Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
+      Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
+
+      if(k>0)
+      {
+        temp.head(k) = mat.diagonal().real().head(k).asDiagonal() * A10.adjoint();
+        mat.coeffRef(k,k) -= (A10 * temp.head(k)).value();
+        if(rs>0)
+          A21.noalias() -= A20 * temp.head(k);
+      }
+
+      // In some previous versions of Eigen (e.g., 3.2.1), the scaling was omitted if the pivot
+      // was smaller than the cutoff value. However, since LDLT is not rank-revealing
+      // we should only make sure that we do not introduce INF or NaN values.
+      // Remark that LAPACK also uses 0 as the cutoff value.
+      RealScalar realAkk = numext::real(mat.coeffRef(k,k));
+      bool pivot_is_valid = (abs(realAkk) > RealScalar(0));
+
+      if(k==0 && !pivot_is_valid)
+      {
+        // The entire diagonal is zero, there is nothing more to do
+        // except filling the transpositions, and checking whether the matrix is zero.
+        sign = ZeroSign;
+        for(Index j = 0; j<size; ++j)
+        {
+          transpositions.coeffRef(j) = IndexType(j);
+          ret = ret && (mat.col(j).tail(size-j-1).array()==Scalar(0)).all();
+        }
+        return ret;
+      }
+
+      if((rs>0) && pivot_is_valid)
+        A21 /= realAkk;
+      else if(rs>0)
+        ret = ret && (A21.array()==Scalar(0)).all();
+
+      if(found_zero_pivot && pivot_is_valid) ret = false; // factorization failed
+      else if(!pivot_is_valid) found_zero_pivot = true;
+
+      if (sign == PositiveSemiDef) {
+        if (realAkk < static_cast<RealScalar>(0)) sign = Indefinite;
+      } else if (sign == NegativeSemiDef) {
+        if (realAkk > static_cast<RealScalar>(0)) sign = Indefinite;
+      } else if (sign == ZeroSign) {
+        if (realAkk > static_cast<RealScalar>(0)) sign = PositiveSemiDef;
+        else if (realAkk < static_cast<RealScalar>(0)) sign = NegativeSemiDef;
+      }
+    }
+
+    return ret;
+  }
+
+  // Reference for the algorithm: Davis and Hager, "Multiple Rank
+  // Modifications of a Sparse Cholesky Factorization" (Algorithm 1)
+  // Trivial rearrangements of their computations (Timothy E. Holy)
+  // allow their algorithm to work for rank-1 updates even if the
+  // original matrix is not of full rank.
+  // Here only rank-1 updates are implemented, to reduce the
+  // requirement for intermediate storage and improve accuracy
+  template<typename MatrixType, typename WDerived>
+  static bool updateInPlace(MatrixType& mat, MatrixBase<WDerived>& w, const typename MatrixType::RealScalar& sigma=1)
+  {
+    using numext::isfinite;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+
+    const Index size = mat.rows();
+    eigen_assert(mat.cols() == size && w.size()==size);
+
+    RealScalar alpha = 1;
+
+    // Apply the update
+    for (Index j = 0; j < size; j++)
+    {
+      // Check for termination due to an original decomposition of low-rank
+      if (!(isfinite)(alpha))
+        break;
+
+      // Update the diagonal terms
+      RealScalar dj = numext::real(mat.coeff(j,j));
+      Scalar wj = w.coeff(j);
+      RealScalar swj2 = sigma*numext::abs2(wj);
+      RealScalar gamma = dj*alpha + swj2;
+
+      mat.coeffRef(j,j) += swj2/alpha;
+      alpha += swj2/dj;
+
+
+      // Update the terms of L
+      Index rs = size-j-1;
+      w.tail(rs) -= wj * mat.col(j).tail(rs);
+      if(gamma != 0)
+        mat.col(j).tail(rs) += (sigma*numext::conj(wj)/gamma)*w.tail(rs);
+    }
+    return true;
+  }
+
+  template<typename MatrixType, typename TranspositionType, typename Workspace, typename WType>
+  static bool update(MatrixType& mat, const TranspositionType& transpositions, Workspace& tmp, const WType& w, const typename MatrixType::RealScalar& sigma=1)
+  {
+    // Apply the permutation to the input w
+    tmp = transpositions * w;
+
+    return ldlt_inplace<Lower>::updateInPlace(mat,tmp,sigma);
+  }
+};
+
+template<> struct ldlt_inplace<Upper>
+{
+  template<typename MatrixType, typename TranspositionType, typename Workspace>
+  static EIGEN_STRONG_INLINE bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign)
+  {
+    Transpose<MatrixType> matt(mat);
+    return ldlt_inplace<Lower>::unblocked(matt, transpositions, temp, sign);
+  }
+
+  template<typename MatrixType, typename TranspositionType, typename Workspace, typename WType>
+  static EIGEN_STRONG_INLINE bool update(MatrixType& mat, TranspositionType& transpositions, Workspace& tmp, WType& w, const typename MatrixType::RealScalar& sigma=1)
+  {
+    Transpose<MatrixType> matt(mat);
+    return ldlt_inplace<Lower>::update(matt, transpositions, tmp, w.conjugate(), sigma);
+  }
+};
+
+template<typename MatrixType> struct LDLT_Traits<MatrixType,Lower>
+{
+  typedef const TriangularView<const MatrixType, UnitLower> MatrixL;
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitUpper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
+};
+
+template<typename MatrixType> struct LDLT_Traits<MatrixType,Upper>
+{
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitLower> MatrixL;
+  typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
+};
+
+} // end namespace internal
+
+/** Compute / recompute the LDLT decomposition A = L D L^* = U^* D U of \a matrix
+  */
+template<typename MatrixType, int _UpLo>
+template<typename InputType>
+LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
+{
+  check_template_parameters();
+
+  eigen_assert(a.rows()==a.cols());
+  const Index size = a.rows();
+
+  m_matrix = a.derived();
+
+  // Compute matrix L1 norm = max abs column sum.
+  m_l1_norm = RealScalar(0);
+  // TODO move this code to SelfAdjointView
+  for (Index col = 0; col < size; ++col) {
+    RealScalar abs_col_sum;
+    if (_UpLo == Lower)
+      abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
+    else
+      abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
+    if (abs_col_sum > m_l1_norm)
+      m_l1_norm = abs_col_sum;
+  }
+
+  m_transpositions.resize(size);
+  m_isInitialized = false;
+  m_temporary.resize(size);
+  m_sign = internal::ZeroSign;
+
+  m_info = internal::ldlt_inplace<UpLo>::unblocked(m_matrix, m_transpositions, m_temporary, m_sign) ? Success : NumericalIssue;
+
+  m_isInitialized = true;
+  return *this;
+}
+
+/** Update the LDLT decomposition:  given A = L D L^T, efficiently compute the decomposition of A + sigma w w^T.
+ * \param w a vector to be incorporated into the decomposition.
+ * \param sigma a scalar, +1 for updates and -1 for "downdates," which correspond to removing previously-added column vectors. Optional; default value is +1.
+ * \sa setZero()
+  */
+template<typename MatrixType, int _UpLo>
+template<typename Derived>
+LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::rankUpdate(const MatrixBase<Derived>& w, const typename LDLT<MatrixType,_UpLo>::RealScalar& sigma)
+{
+  typedef typename TranspositionType::StorageIndex IndexType;
+  const Index size = w.rows();
+  if (m_isInitialized)
+  {
+    eigen_assert(m_matrix.rows()==size);
+  }
+  else
+  {
+    m_matrix.resize(size,size);
+    m_matrix.setZero();
+    m_transpositions.resize(size);
+    for (Index i = 0; i < size; i++)
+      m_transpositions.coeffRef(i) = IndexType(i);
+    m_temporary.resize(size);
+    m_sign = sigma>=0 ? internal::PositiveSemiDef : internal::NegativeSemiDef;
+    m_isInitialized = true;
+  }
+
+  internal::ldlt_inplace<UpLo>::update(m_matrix, m_transpositions, m_temporary, w, sigma);
+
+  return *this;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType, int _UpLo>
+template<typename RhsType, typename DstType>
+void LDLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  _solve_impl_transposed<true>(rhs, dst);
+}
+
+template<typename _MatrixType,int _UpLo>
+template<bool Conjugate, typename RhsType, typename DstType>
+void LDLT<_MatrixType,_UpLo>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  // dst = P b
+  dst = m_transpositions * rhs;
+
+  // dst = L^-1 (P b)
+  // dst = L^-*T (P b)
+  matrixL().template conjugateIf<!Conjugate>().solveInPlace(dst);
+
+  // dst = D^-* (L^-1 P b)
+  // dst = D^-1 (L^-*T P b)
+  // more precisely, use pseudo-inverse of D (see bug 241)
+  using std::abs;
+  const typename Diagonal<const MatrixType>::RealReturnType vecD(vectorD());
+  // In some previous versions, tolerance was set to the max of 1/highest (or rather numeric_limits::min())
+  // and the maximal diagonal entry * epsilon as motivated by LAPACK's xGELSS:
+  // RealScalar tolerance = numext::maxi(vecD.array().abs().maxCoeff() * NumTraits<RealScalar>::epsilon(),RealScalar(1) / NumTraits<RealScalar>::highest());
+  // However, LDLT is not rank revealing, and so adjusting the tolerance wrt to the highest
+  // diagonal element is not well justified and leads to numerical issues in some cases.
+  // Moreover, Lapack's xSYTRS routines use 0 for the tolerance.
+  // Using numeric_limits::min() gives us more robustness to denormals.
+  RealScalar tolerance = (std::numeric_limits<RealScalar>::min)();
+  for (Index i = 0; i < vecD.size(); ++i)
+  {
+    if(abs(vecD(i)) > tolerance)
+      dst.row(i) /= vecD(i);
+    else
+      dst.row(i).setZero();
+  }
+
+  // dst = L^-* (D^-* L^-1 P b)
+  // dst = L^-T (D^-1 L^-*T P b)
+  matrixL().transpose().template conjugateIf<Conjugate>().solveInPlace(dst);
+
+  // dst = P^T (L^-* D^-* L^-1 P b) = A^-1 b
+  // dst = P^-T (L^-T D^-1 L^-*T P b) = A^-1 b
+  dst = m_transpositions.transpose() * dst;
+}
+#endif
+
+/** \internal use x = ldlt_object.solve(x);
+  *
+  * This is the \em in-place version of solve().
+  *
+  * \param bAndX represents both the right-hand side matrix b and result x.
+  *
+  * \returns true always! If you need to check for existence of solutions, use another decomposition like LU, QR, or SVD.
+  *
+  * This version avoids a copy when the right hand side matrix b is not
+  * needed anymore.
+  *
+  * \sa LDLT::solve(), MatrixBase::ldlt()
+  */
+template<typename MatrixType,int _UpLo>
+template<typename Derived>
+bool LDLT<MatrixType,_UpLo>::solveInPlace(MatrixBase<Derived> &bAndX) const
+{
+  eigen_assert(m_isInitialized && "LDLT is not initialized.");
+  eigen_assert(m_matrix.rows() == bAndX.rows());
+
+  bAndX = this->solve(bAndX);
+
+  return true;
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: P^T L D L^* P.
+ * This function is provided for debug purpose. */
+template<typename MatrixType, int _UpLo>
+MatrixType LDLT<MatrixType,_UpLo>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LDLT is not initialized.");
+  const Index size = m_matrix.rows();
+  MatrixType res(size,size);
+
+  // P
+  res.setIdentity();
+  res = transpositionsP() * res;
+  // L^* P
+  res = matrixU() * res;
+  // D(L^*P)
+  res = vectorD().real().asDiagonal() * res;
+  // L(DL^*P)
+  res = matrixL() * res;
+  // P^T (LDL^*P)
+  res = transpositionsP().transpose() * res;
+
+  return res;
+}
+
+/** \cholesky_module
+  * \returns the Cholesky decomposition with full pivoting without square root of \c *this
+  * \sa MatrixBase::ldlt()
+  */
+template<typename MatrixType, unsigned int UpLo>
+inline const LDLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
+SelfAdjointView<MatrixType, UpLo>::ldlt() const
+{
+  return LDLT<PlainObject,UpLo>(m_matrix);
+}
+
+/** \cholesky_module
+  * \returns the Cholesky decomposition with full pivoting without square root of \c *this
+  * \sa SelfAdjointView::ldlt()
+  */
+template<typename Derived>
+inline const LDLT<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::ldlt() const
+{
+  return LDLT<PlainObject>(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_LDLT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Cholesky/LLT.h b/C++/yolo_bytetrack/include/Eigen/src/Cholesky/LLT.h
new file mode 100644
index 00000000..8c9b2b39
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Cholesky/LLT.h
@@ -0,0 +1,558 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LLT_H
+#define EIGEN_LLT_H
+
+namespace Eigen {
+
+namespace internal{
+
+template<typename _MatrixType, int _UpLo> struct traits<LLT<_MatrixType, _UpLo> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+template<typename MatrixType, int UpLo> struct LLT_Traits;
+}
+
+/** \ingroup Cholesky_Module
+  *
+  * \class LLT
+  *
+  * \brief Standard Cholesky decomposition (LL^T) of a matrix and associated features
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the LL^T Cholesky decomposition
+  * \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
+  *               The other triangular part won't be read.
+  *
+  * This class performs a LL^T Cholesky decomposition of a symmetric, positive definite
+  * matrix A such that A = LL^* = U^*U, where L is lower triangular.
+  *
+  * While the Cholesky decomposition is particularly useful to solve selfadjoint problems like  D^*D x = b,
+  * for that purpose, we recommend the Cholesky decomposition without square root which is more stable
+  * and even faster. Nevertheless, this standard Cholesky decomposition remains useful in many other
+  * situations like generalised eigen problems with hermitian matrices.
+  *
+  * Remember that Cholesky decompositions are not rank-revealing. This LLT decomposition is only stable on positive definite matrices,
+  * use LDLT instead for the semidefinite case. Also, do not use a Cholesky decomposition to determine whether a system of equations
+  * has a solution.
+  *
+  * Example: \include LLT_example.cpp
+  * Output: \verbinclude LLT_example.out
+  *
+  * \b Performance: for best performance, it is recommended to use a column-major storage format
+  * with the Lower triangular part (the default), or, equivalently, a row-major storage format
+  * with the Upper triangular part. Otherwise, you might get a 20% slowdown for the full factorization
+  * step, and rank-updates can be up to 3 times slower.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * Note that during the decomposition, only the lower (or upper, as defined by _UpLo) triangular part of A is considered.
+  * Therefore, the strict lower part does not have to store correct values.
+  *
+  * \sa MatrixBase::llt(), SelfAdjointView::llt(), class LDLT
+  */
+template<typename _MatrixType, int _UpLo> class LLT
+        : public SolverBase<LLT<_MatrixType, _UpLo> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<LLT> Base;
+    friend class SolverBase<LLT>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(LLT)
+    enum {
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    enum {
+      PacketSize = internal::packet_traits<Scalar>::size,
+      AlignmentMask = int(PacketSize)-1,
+      UpLo = _UpLo
+    };
+
+    typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via LLT::compute(const MatrixType&).
+      */
+    LLT() : m_matrix(), m_isInitialized(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa LLT()
+      */
+    explicit LLT(Index size) : m_matrix(size, size),
+                    m_isInitialized(false) {}
+
+    template<typename InputType>
+    explicit LLT(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.rows(), matrix.cols()),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a LLT factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when
+      * \c MatrixType is a Eigen::Ref.
+      *
+      * \sa LLT(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit LLT(EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \returns a view of the upper triangular matrix U */
+    inline typename Traits::MatrixU matrixU() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return Traits::getU(m_matrix);
+    }
+
+    /** \returns a view of the lower triangular matrix L */
+    inline typename Traits::MatrixL matrixL() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return Traits::getL(m_matrix);
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * Since this LLT class assumes anyway that the matrix A is invertible, the solution
+      * theoretically exists and is unique regardless of b.
+      *
+      * Example: \include LLT_solve.cpp
+      * Output: \verbinclude LLT_solve.out
+      *
+      * \sa solveInPlace(), MatrixBase::llt(), SelfAdjointView::llt()
+      */
+    template<typename Rhs>
+    inline const Solve<LLT, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    template<typename Derived>
+    void solveInPlace(const MatrixBase<Derived> &bAndX) const;
+
+    template<typename InputType>
+    LLT& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of
+      *  which \c *this is the Cholesky decomposition.
+      */
+    RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    /** \returns the LLT decomposition matrix
+      *
+      * TODO: document the storage layout
+      */
+    inline const MatrixType& matrixLLT() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return m_matrix;
+    }
+
+    MatrixType reconstructedMatrix() const;
+
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears not to be positive definite.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return m_info;
+    }
+
+    /** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
+      *
+      * This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
+      * \code x = decomposition.adjoint().solve(b) \endcode
+      */
+    const LLT& adjoint() const EIGEN_NOEXCEPT { return *this; };
+
+    inline EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    inline EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+    template<typename VectorType>
+    LLT & rankUpdate(const VectorType& vec, const RealScalar& sigma = 1);
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    /** \internal
+      * Used to compute and store L
+      * The strict upper part is not used and even not initialized.
+      */
+    MatrixType m_matrix;
+    RealScalar m_l1_norm;
+    bool m_isInitialized;
+    ComputationInfo m_info;
+};
+
+namespace internal {
+
+template<typename Scalar, int UpLo> struct llt_inplace;
+
+template<typename MatrixType, typename VectorType>
+static Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)
+{
+  using std::sqrt;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename MatrixType::ColXpr ColXpr;
+  typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
+  typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
+  typedef Matrix<Scalar,Dynamic,1> TempVectorType;
+  typedef typename TempVectorType::SegmentReturnType TempVecSegment;
+
+  Index n = mat.cols();
+  eigen_assert(mat.rows()==n && vec.size()==n);
+
+  TempVectorType temp;
+
+  if(sigma>0)
+  {
+    // This version is based on Givens rotations.
+    // It is faster than the other one below, but only works for updates,
+    // i.e., for sigma > 0
+    temp = sqrt(sigma) * vec;
+
+    for(Index i=0; i<n; ++i)
+    {
+      JacobiRotation<Scalar> g;
+      g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
+
+      Index rs = n-i-1;
+      if(rs>0)
+      {
+        ColXprSegment x(mat.col(i).tail(rs));
+        TempVecSegment y(temp.tail(rs));
+        apply_rotation_in_the_plane(x, y, g);
+      }
+    }
+  }
+  else
+  {
+    temp = vec;
+    RealScalar beta = 1;
+    for(Index j=0; j<n; ++j)
+    {
+      RealScalar Ljj = numext::real(mat.coeff(j,j));
+      RealScalar dj = numext::abs2(Ljj);
+      Scalar wj = temp.coeff(j);
+      RealScalar swj2 = sigma*numext::abs2(wj);
+      RealScalar gamma = dj*beta + swj2;
+
+      RealScalar x = dj + swj2/beta;
+      if (x<=RealScalar(0))
+        return j;
+      RealScalar nLjj = sqrt(x);
+      mat.coeffRef(j,j) = nLjj;
+      beta += swj2/dj;
+
+      // Update the terms of L
+      Index rs = n-j-1;
+      if(rs)
+      {
+        temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
+        if(gamma != 0)
+          mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
+      }
+    }
+  }
+  return -1;
+}
+
+template<typename Scalar> struct llt_inplace<Scalar, Lower>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename MatrixType>
+  static Index unblocked(MatrixType& mat)
+  {
+    using std::sqrt;
+
+    eigen_assert(mat.rows()==mat.cols());
+    const Index size = mat.rows();
+    for(Index k = 0; k < size; ++k)
+    {
+      Index rs = size-k-1; // remaining size
+
+      Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
+      Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
+      Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
+
+      RealScalar x = numext::real(mat.coeff(k,k));
+      if (k>0) x -= A10.squaredNorm();
+      if (x<=RealScalar(0))
+        return k;
+      mat.coeffRef(k,k) = x = sqrt(x);
+      if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint();
+      if (rs>0) A21 /= x;
+    }
+    return -1;
+  }
+
+  template<typename MatrixType>
+  static Index blocked(MatrixType& m)
+  {
+    eigen_assert(m.rows()==m.cols());
+    Index size = m.rows();
+    if(size<32)
+      return unblocked(m);
+
+    Index blockSize = size/8;
+    blockSize = (blockSize/16)*16;
+    blockSize = (std::min)((std::max)(blockSize,Index(8)), Index(128));
+
+    for (Index k=0; k<size; k+=blockSize)
+    {
+      // partition the matrix:
+      //       A00 |  -  |  -
+      // lu  = A10 | A11 |  -
+      //       A20 | A21 | A22
+      Index bs = (std::min)(blockSize, size-k);
+      Index rs = size - k - bs;
+      Block<MatrixType,Dynamic,Dynamic> A11(m,k,   k,   bs,bs);
+      Block<MatrixType,Dynamic,Dynamic> A21(m,k+bs,k,   rs,bs);
+      Block<MatrixType,Dynamic,Dynamic> A22(m,k+bs,k+bs,rs,rs);
+
+      Index ret;
+      if((ret=unblocked(A11))>=0) return k+ret;
+      if(rs>0) A11.adjoint().template triangularView<Upper>().template solveInPlace<OnTheRight>(A21);
+      if(rs>0) A22.template selfadjointView<Lower>().rankUpdate(A21,typename NumTraits<RealScalar>::Literal(-1)); // bottleneck
+    }
+    return -1;
+  }
+
+  template<typename MatrixType, typename VectorType>
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
+  {
+    return Eigen::internal::llt_rank_update_lower(mat, vec, sigma);
+  }
+};
+
+template<typename Scalar> struct llt_inplace<Scalar, Upper>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  template<typename MatrixType>
+  static EIGEN_STRONG_INLINE Index unblocked(MatrixType& mat)
+  {
+    Transpose<MatrixType> matt(mat);
+    return llt_inplace<Scalar, Lower>::unblocked(matt);
+  }
+  template<typename MatrixType>
+  static EIGEN_STRONG_INLINE Index blocked(MatrixType& mat)
+  {
+    Transpose<MatrixType> matt(mat);
+    return llt_inplace<Scalar, Lower>::blocked(matt);
+  }
+  template<typename MatrixType, typename VectorType>
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
+  {
+    Transpose<MatrixType> matt(mat);
+    return llt_inplace<Scalar, Lower>::rankUpdate(matt, vec.conjugate(), sigma);
+  }
+};
+
+template<typename MatrixType> struct LLT_Traits<MatrixType,Lower>
+{
+  typedef const TriangularView<const MatrixType, Lower> MatrixL;
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
+  static bool inplace_decomposition(MatrixType& m)
+  { return llt_inplace<typename MatrixType::Scalar, Lower>::blocked(m)==-1; }
+};
+
+template<typename MatrixType> struct LLT_Traits<MatrixType,Upper>
+{
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
+  typedef const TriangularView<const MatrixType, Upper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
+  static bool inplace_decomposition(MatrixType& m)
+  { return llt_inplace<typename MatrixType::Scalar, Upper>::blocked(m)==-1; }
+};
+
+} // end namespace internal
+
+/** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix
+  *
+  * \returns a reference to *this
+  *
+  * Example: \include TutorialLinAlgComputeTwice.cpp
+  * Output: \verbinclude TutorialLinAlgComputeTwice.out
+  */
+template<typename MatrixType, int _UpLo>
+template<typename InputType>
+LLT<MatrixType,_UpLo>& LLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
+{
+  check_template_parameters();
+
+  eigen_assert(a.rows()==a.cols());
+  const Index size = a.rows();
+  m_matrix.resize(size, size);
+  if (!internal::is_same_dense(m_matrix, a.derived()))
+    m_matrix = a.derived();
+
+  // Compute matrix L1 norm = max abs column sum.
+  m_l1_norm = RealScalar(0);
+  // TODO move this code to SelfAdjointView
+  for (Index col = 0; col < size; ++col) {
+    RealScalar abs_col_sum;
+    if (_UpLo == Lower)
+      abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
+    else
+      abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
+    if (abs_col_sum > m_l1_norm)
+      m_l1_norm = abs_col_sum;
+  }
+
+  m_isInitialized = true;
+  bool ok = Traits::inplace_decomposition(m_matrix);
+  m_info = ok ? Success : NumericalIssue;
+
+  return *this;
+}
+
+/** Performs a rank one update (or dowdate) of the current decomposition.
+  * If A = LL^* before the rank one update,
+  * then after it we have LL^* = A + sigma * v v^* where \a v must be a vector
+  * of same dimension.
+  */
+template<typename _MatrixType, int _UpLo>
+template<typename VectorType>
+LLT<_MatrixType,_UpLo> & LLT<_MatrixType,_UpLo>::rankUpdate(const VectorType& v, const RealScalar& sigma)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType);
+  eigen_assert(v.size()==m_matrix.cols());
+  eigen_assert(m_isInitialized);
+  if(internal::llt_inplace<typename MatrixType::Scalar, UpLo>::rankUpdate(m_matrix,v,sigma)>=0)
+    m_info = NumericalIssue;
+  else
+    m_info = Success;
+
+  return *this;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType,int _UpLo>
+template<typename RhsType, typename DstType>
+void LLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  _solve_impl_transposed<true>(rhs, dst);
+}
+
+template<typename _MatrixType,int _UpLo>
+template<bool Conjugate, typename RhsType, typename DstType>
+void LLT<_MatrixType,_UpLo>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+    dst = rhs;
+
+    matrixL().template conjugateIf<!Conjugate>().solveInPlace(dst);
+    matrixU().template conjugateIf<!Conjugate>().solveInPlace(dst);
+}
+#endif
+
+/** \internal use x = llt_object.solve(x);
+  *
+  * This is the \em in-place version of solve().
+  *
+  * \param bAndX represents both the right-hand side matrix b and result x.
+  *
+  * This version avoids a copy when the right hand side matrix b is not needed anymore.
+  *
+  * \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here.
+  * This function will const_cast it, so constness isn't honored here.
+  *
+  * \sa LLT::solve(), MatrixBase::llt()
+  */
+template<typename MatrixType, int _UpLo>
+template<typename Derived>
+void LLT<MatrixType,_UpLo>::solveInPlace(const MatrixBase<Derived> &bAndX) const
+{
+  eigen_assert(m_isInitialized && "LLT is not initialized.");
+  eigen_assert(m_matrix.rows()==bAndX.rows());
+  matrixL().solveInPlace(bAndX);
+  matrixU().solveInPlace(bAndX);
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: L L^*.
+ * This function is provided for debug purpose. */
+template<typename MatrixType, int _UpLo>
+MatrixType LLT<MatrixType,_UpLo>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LLT is not initialized.");
+  return matrixL() * matrixL().adjoint().toDenseMatrix();
+}
+
+/** \cholesky_module
+  * \returns the LLT decomposition of \c *this
+  * \sa SelfAdjointView::llt()
+  */
+template<typename Derived>
+inline const LLT<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::llt() const
+{
+  return LLT<PlainObject>(derived());
+}
+
+/** \cholesky_module
+  * \returns the LLT decomposition of \c *this
+  * \sa SelfAdjointView::llt()
+  */
+template<typename MatrixType, unsigned int UpLo>
+inline const LLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
+SelfAdjointView<MatrixType, UpLo>::llt() const
+{
+  return LLT<PlainObject,UpLo>(m_matrix);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_LLT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Cholesky/LLT_LAPACKE.h b/C++/yolo_bytetrack/include/Eigen/src/Cholesky/LLT_LAPACKE.h
new file mode 100644
index 00000000..bc6489e6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Cholesky/LLT_LAPACKE.h
@@ -0,0 +1,99 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *     LLt decomposition based on LAPACKE_?potrf function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_LLT_LAPACKE_H
+#define EIGEN_LLT_LAPACKE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Scalar> struct lapacke_llt;
+
+#define EIGEN_LAPACKE_LLT(EIGTYPE, BLASTYPE, LAPACKE_PREFIX) \
+template<> struct lapacke_llt<EIGTYPE> \
+{ \
+  template<typename MatrixType> \
+  static inline Index potrf(MatrixType& m, char uplo) \
+  { \
+    lapack_int matrix_order; \
+    lapack_int size, lda, info, StorageOrder; \
+    EIGTYPE* a; \
+    eigen_assert(m.rows()==m.cols()); \
+    /* Set up parameters for ?potrf */ \
+    size = convert_index<lapack_int>(m.rows()); \
+    StorageOrder = MatrixType::Flags&RowMajorBit?RowMajor:ColMajor; \
+    matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
+    a = &(m.coeffRef(0,0)); \
+    lda = convert_index<lapack_int>(m.outerStride()); \
+\
+    info = LAPACKE_##LAPACKE_PREFIX##potrf( matrix_order, uplo, size, (BLASTYPE*)a, lda ); \
+    info = (info==0) ? -1 : info>0 ? info-1 : size; \
+    return info; \
+  } \
+}; \
+template<> struct llt_inplace<EIGTYPE, Lower> \
+{ \
+  template<typename MatrixType> \
+  static Index blocked(MatrixType& m) \
+  { \
+    return lapacke_llt<EIGTYPE>::potrf(m, 'L'); \
+  } \
+  template<typename MatrixType, typename VectorType> \
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \
+  { return Eigen::internal::llt_rank_update_lower(mat, vec, sigma); } \
+}; \
+template<> struct llt_inplace<EIGTYPE, Upper> \
+{ \
+  template<typename MatrixType> \
+  static Index blocked(MatrixType& m) \
+  { \
+    return lapacke_llt<EIGTYPE>::potrf(m, 'U'); \
+  } \
+  template<typename MatrixType, typename VectorType> \
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \
+  { \
+    Transpose<MatrixType> matt(mat); \
+    return llt_inplace<EIGTYPE, Lower>::rankUpdate(matt, vec.conjugate(), sigma); \
+  } \
+};
+
+EIGEN_LAPACKE_LLT(double, double, d)
+EIGEN_LAPACKE_LLT(float, float, s)
+EIGEN_LAPACKE_LLT(dcomplex, lapack_complex_double, z)
+EIGEN_LAPACKE_LLT(scomplex, lapack_complex_float, c)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_LLT_LAPACKE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/CholmodSupport/CholmodSupport.h b/C++/yolo_bytetrack/include/Eigen/src/CholmodSupport/CholmodSupport.h
new file mode 100644
index 00000000..adaf5285
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/CholmodSupport/CholmodSupport.h
@@ -0,0 +1,682 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLMODSUPPORT_H
+#define EIGEN_CHOLMODSUPPORT_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Scalar> struct cholmod_configure_matrix;
+
+template<> struct cholmod_configure_matrix<double> {
+  template<typename CholmodType>
+  static void run(CholmodType& mat) {
+    mat.xtype = CHOLMOD_REAL;
+    mat.dtype = CHOLMOD_DOUBLE;
+  }
+};
+
+template<> struct cholmod_configure_matrix<std::complex<double> > {
+  template<typename CholmodType>
+  static void run(CholmodType& mat) {
+    mat.xtype = CHOLMOD_COMPLEX;
+    mat.dtype = CHOLMOD_DOUBLE;
+  }
+};
+
+// Other scalar types are not yet supported by Cholmod
+// template<> struct cholmod_configure_matrix<float> {
+//   template<typename CholmodType>
+//   static void run(CholmodType& mat) {
+//     mat.xtype = CHOLMOD_REAL;
+//     mat.dtype = CHOLMOD_SINGLE;
+//   }
+// };
+//
+// template<> struct cholmod_configure_matrix<std::complex<float> > {
+//   template<typename CholmodType>
+//   static void run(CholmodType& mat) {
+//     mat.xtype = CHOLMOD_COMPLEX;
+//     mat.dtype = CHOLMOD_SINGLE;
+//   }
+// };
+
+} // namespace internal
+
+/** Wraps the Eigen sparse matrix \a mat into a Cholmod sparse matrix object.
+  * Note that the data are shared.
+  */
+template<typename _Scalar, int _Options, typename _StorageIndex>
+cholmod_sparse viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_StorageIndex> > mat)
+{
+  cholmod_sparse res;
+  res.nzmax   = mat.nonZeros();
+  res.nrow    = mat.rows();
+  res.ncol    = mat.cols();
+  res.p       = mat.outerIndexPtr();
+  res.i       = mat.innerIndexPtr();
+  res.x       = mat.valuePtr();
+  res.z       = 0;
+  res.sorted  = 1;
+  if(mat.isCompressed())
+  {
+    res.packed  = 1;
+    res.nz = 0;
+  }
+  else
+  {
+    res.packed  = 0;
+    res.nz = mat.innerNonZeroPtr();
+  }
+
+  res.dtype   = 0;
+  res.stype   = -1;
+
+  if (internal::is_same<_StorageIndex,int>::value)
+  {
+    res.itype = CHOLMOD_INT;
+  }
+  else if (internal::is_same<_StorageIndex,SuiteSparse_long>::value)
+  {
+    res.itype = CHOLMOD_LONG;
+  }
+  else
+  {
+    eigen_assert(false && "Index type not supported yet");
+  }
+
+  // setup res.xtype
+  internal::cholmod_configure_matrix<_Scalar>::run(res);
+
+  res.stype = 0;
+
+  return res;
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+const cholmod_sparse viewAsCholmod(const SparseMatrix<_Scalar,_Options,_Index>& mat)
+{
+  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.const_cast_derived()));
+  return res;
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+const cholmod_sparse viewAsCholmod(const SparseVector<_Scalar,_Options,_Index>& mat)
+{
+  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.const_cast_derived()));
+  return res;
+}
+
+/** Returns a view of the Eigen sparse matrix \a mat as Cholmod sparse matrix.
+  * The data are not copied but shared. */
+template<typename _Scalar, int _Options, typename _Index, unsigned int UpLo>
+cholmod_sparse viewAsCholmod(const SparseSelfAdjointView<const SparseMatrix<_Scalar,_Options,_Index>, UpLo>& mat)
+{
+  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.matrix().const_cast_derived()));
+
+  if(UpLo==Upper) res.stype =  1;
+  if(UpLo==Lower) res.stype = -1;
+  // swap stype for rowmajor matrices (only works for real matrices)
+  EIGEN_STATIC_ASSERT((_Options & RowMajorBit) == 0 || NumTraits<_Scalar>::IsComplex == 0, THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  if(_Options & RowMajorBit) res.stype *=-1;
+
+  return res;
+}
+
+/** Returns a view of the Eigen \b dense matrix \a mat as Cholmod dense matrix.
+  * The data are not copied but shared. */
+template<typename Derived>
+cholmod_dense viewAsCholmod(MatrixBase<Derived>& mat)
+{
+  EIGEN_STATIC_ASSERT((internal::traits<Derived>::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  typedef typename Derived::Scalar Scalar;
+
+  cholmod_dense res;
+  res.nrow   = mat.rows();
+  res.ncol   = mat.cols();
+  res.nzmax  = res.nrow * res.ncol;
+  res.d      = Derived::IsVectorAtCompileTime ? mat.derived().size() : mat.derived().outerStride();
+  res.x      = (void*)(mat.derived().data());
+  res.z      = 0;
+
+  internal::cholmod_configure_matrix<Scalar>::run(res);
+
+  return res;
+}
+
+/** Returns a view of the Cholmod sparse matrix \a cm as an Eigen sparse matrix.
+  * The data are not copied but shared. */
+template<typename Scalar, int Flags, typename StorageIndex>
+MappedSparseMatrix<Scalar,Flags,StorageIndex> viewAsEigen(cholmod_sparse& cm)
+{
+  return MappedSparseMatrix<Scalar,Flags,StorageIndex>
+         (cm.nrow, cm.ncol, static_cast<StorageIndex*>(cm.p)[cm.ncol],
+          static_cast<StorageIndex*>(cm.p), static_cast<StorageIndex*>(cm.i),static_cast<Scalar*>(cm.x) );
+}
+
+namespace internal {
+
+// template specializations for int and long that call the correct cholmod method
+
+#define EIGEN_CHOLMOD_SPECIALIZE0(ret, name) \
+    template<typename _StorageIndex> inline ret cm_ ## name       (cholmod_common &Common) { return cholmod_ ## name   (&Common); } \
+    template<>                       inline ret cm_ ## name<SuiteSparse_long> (cholmod_common &Common) { return cholmod_l_ ## name (&Common); }
+
+#define EIGEN_CHOLMOD_SPECIALIZE1(ret, name, t1, a1) \
+    template<typename _StorageIndex> inline ret cm_ ## name       (t1& a1, cholmod_common &Common) { return cholmod_ ## name   (&a1, &Common); } \
+    template<>                       inline ret cm_ ## name<SuiteSparse_long> (t1& a1, cholmod_common &Common) { return cholmod_l_ ## name (&a1, &Common); }
+
+EIGEN_CHOLMOD_SPECIALIZE0(int, start)
+EIGEN_CHOLMOD_SPECIALIZE0(int, finish)
+
+EIGEN_CHOLMOD_SPECIALIZE1(int, free_factor, cholmod_factor*, L)
+EIGEN_CHOLMOD_SPECIALIZE1(int, free_dense,  cholmod_dense*,  X)
+EIGEN_CHOLMOD_SPECIALIZE1(int, free_sparse, cholmod_sparse*, A)
+
+EIGEN_CHOLMOD_SPECIALIZE1(cholmod_factor*, analyze, cholmod_sparse, A)
+
+template<typename _StorageIndex> inline cholmod_dense*  cm_solve         (int sys, cholmod_factor& L, cholmod_dense&  B, cholmod_common &Common) { return cholmod_solve     (sys, &L, &B, &Common); }
+template<>                       inline cholmod_dense*  cm_solve<SuiteSparse_long>   (int sys, cholmod_factor& L, cholmod_dense&  B, cholmod_common &Common) { return cholmod_l_solve   (sys, &L, &B, &Common); }
+
+template<typename _StorageIndex> inline cholmod_sparse* cm_spsolve       (int sys, cholmod_factor& L, cholmod_sparse& B, cholmod_common &Common) { return cholmod_spsolve   (sys, &L, &B, &Common); }
+template<>                       inline cholmod_sparse* cm_spsolve<SuiteSparse_long> (int sys, cholmod_factor& L, cholmod_sparse& B, cholmod_common &Common) { return cholmod_l_spsolve (sys, &L, &B, &Common); }
+
+template<typename _StorageIndex>
+inline int  cm_factorize_p       (cholmod_sparse*  A, double beta[2], _StorageIndex* fset, std::size_t fsize, cholmod_factor* L, cholmod_common &Common) { return cholmod_factorize_p   (A, beta, fset, fsize, L, &Common); }
+template<>
+inline int  cm_factorize_p<SuiteSparse_long> (cholmod_sparse*  A, double beta[2], SuiteSparse_long* fset,          std::size_t fsize, cholmod_factor* L, cholmod_common &Common) { return cholmod_l_factorize_p (A, beta, fset, fsize, L, &Common); }
+
+#undef EIGEN_CHOLMOD_SPECIALIZE0
+#undef EIGEN_CHOLMOD_SPECIALIZE1
+
+}  // namespace internal
+
+
+enum CholmodMode {
+  CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt
+};
+
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodBase
+  * \brief The base class for the direct Cholesky factorization of Cholmod
+  * \sa class CholmodSupernodalLLT, class CholmodSimplicialLDLT, class CholmodSimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo, typename Derived>
+class CholmodBase : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+  public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef MatrixType CholMatrixType;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    CholmodBase()
+      : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<double,RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
+      m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
+      internal::cm_start<StorageIndex>(m_cholmod);
+    }
+
+    explicit CholmodBase(const MatrixType& matrix)
+      : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<double,RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
+      m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
+      internal::cm_start<StorageIndex>(m_cholmod);
+      compute(matrix);
+    }
+
+    ~CholmodBase()
+    {
+      if(m_cholmodFactor)
+        internal::cm_free_factor<StorageIndex>(m_cholmodFactor, m_cholmod);
+      internal::cm_finish<StorageIndex>(m_cholmod);
+    }
+
+    inline StorageIndex cols() const { return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }
+    inline StorageIndex rows() const { return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    Derived& compute(const MatrixType& matrix)
+    {
+      analyzePattern(matrix);
+      factorize(matrix);
+      return derived();
+    }
+
+    /** Performs a symbolic decomposition on the sparsity pattern of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      if(m_cholmodFactor)
+      {
+        internal::cm_free_factor<StorageIndex>(m_cholmodFactor, m_cholmod);
+        m_cholmodFactor = 0;
+      }
+      cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
+      m_cholmodFactor = internal::cm_analyze<StorageIndex>(A, m_cholmod);
+
+      this->m_isInitialized = true;
+      this->m_info = Success;
+      m_analysisIsOk = true;
+      m_factorizationIsOk = false;
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must have the same sparsity pattern as the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& matrix)
+    {
+      eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+      cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
+      internal::cm_factorize_p<StorageIndex>(&A, m_shiftOffset, 0, 0, m_cholmodFactor, m_cholmod);
+
+      // If the factorization failed, minor is the column at which it did. On success minor == n.
+      this->m_info = (m_cholmodFactor->minor == m_cholmodFactor->n ? Success : NumericalIssue);
+      m_factorizationIsOk = true;
+    }
+
+    /** Returns a reference to the Cholmod's configuration structure to get a full control over the performed operations.
+     *  See the Cholmod user guide for details. */
+    cholmod_common& cholmod() { return m_cholmod; }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      const Index size = m_cholmodFactor->n;
+      EIGEN_UNUSED_VARIABLE(size);
+      eigen_assert(size==b.rows());
+
+      // Cholmod needs column-major storage without inner-stride, which corresponds to the default behavior of Ref.
+      Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b.derived());
+
+      cholmod_dense b_cd = viewAsCholmod(b_ref);
+      cholmod_dense* x_cd = internal::cm_solve<StorageIndex>(CHOLMOD_A, *m_cholmodFactor, b_cd, m_cholmod);
+      if(!x_cd)
+      {
+        this->m_info = NumericalIssue;
+        return;
+      }
+      // TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
+      // NOTE Actually, the copy can be avoided by calling cholmod_solve2 instead of cholmod_solve
+      dest = Matrix<Scalar,Dest::RowsAtCompileTime,Dest::ColsAtCompileTime>::Map(reinterpret_cast<Scalar*>(x_cd->x),b.rows(),b.cols());
+      internal::cm_free_dense<StorageIndex>(x_cd, m_cholmod);
+    }
+
+    /** \internal */
+    template<typename RhsDerived, typename DestDerived>
+    void _solve_impl(const SparseMatrixBase<RhsDerived> &b, SparseMatrixBase<DestDerived> &dest) const
+    {
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      const Index size = m_cholmodFactor->n;
+      EIGEN_UNUSED_VARIABLE(size);
+      eigen_assert(size==b.rows());
+
+      // note: cs stands for Cholmod Sparse
+      Ref<SparseMatrix<typename RhsDerived::Scalar,ColMajor,typename RhsDerived::StorageIndex> > b_ref(b.const_cast_derived());
+      cholmod_sparse b_cs = viewAsCholmod(b_ref);
+      cholmod_sparse* x_cs = internal::cm_spsolve<StorageIndex>(CHOLMOD_A, *m_cholmodFactor, b_cs, m_cholmod);
+      if(!x_cs)
+      {
+        this->m_info = NumericalIssue;
+        return;
+      }
+      // TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
+      // NOTE cholmod_spsolve in fact just calls the dense solver for blocks of 4 columns at a time (similar to Eigen's sparse solver)
+      dest.derived() = viewAsEigen<typename DestDerived::Scalar,ColMajor,typename DestDerived::StorageIndex>(*x_cs);
+      internal::cm_free_sparse<StorageIndex>(x_cs, m_cholmod);
+    }
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+
+
+    /** Sets the shift parameter that will be used to adjust the diagonal coefficients during the numerical factorization.
+      *
+      * During the numerical factorization, an offset term is added to the diagonal coefficients:\n
+      * \c d_ii = \a offset + \c d_ii
+      *
+      * The default is \a offset=0.
+      *
+      * \returns a reference to \c *this.
+      */
+    Derived& setShift(const RealScalar& offset)
+    {
+      m_shiftOffset[0] = double(offset);
+      return derived();
+    }
+
+    /** \returns the determinant of the underlying matrix from the current factorization */
+    Scalar determinant() const
+    {
+      using std::exp;
+      return exp(logDeterminant());
+    }
+
+    /** \returns the log determinant of the underlying matrix from the current factorization */
+    Scalar logDeterminant() const
+    {
+      using std::log;
+      using numext::real;
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+
+      RealScalar logDet = 0;
+      Scalar *x = static_cast<Scalar*>(m_cholmodFactor->x);
+      if (m_cholmodFactor->is_super)
+      {
+        // Supernodal factorization stored as a packed list of dense column-major blocs,
+        // as described by the following structure:
+
+        // super[k] == index of the first column of the j-th super node
+        StorageIndex *super = static_cast<StorageIndex*>(m_cholmodFactor->super);
+        // pi[k] == offset to the description of row indices
+        StorageIndex *pi = static_cast<StorageIndex*>(m_cholmodFactor->pi);
+        // px[k] == offset to the respective dense block
+        StorageIndex *px = static_cast<StorageIndex*>(m_cholmodFactor->px);
+
+        Index nb_super_nodes = m_cholmodFactor->nsuper;
+        for (Index k=0; k < nb_super_nodes; ++k)
+        {
+          StorageIndex ncols = super[k + 1] - super[k];
+          StorageIndex nrows = pi[k + 1] - pi[k];
+
+          Map<const Array<Scalar,1,Dynamic>, 0, InnerStride<> > sk(x + px[k], ncols, InnerStride<>(nrows+1));
+          logDet += sk.real().log().sum();
+        }
+      }
+      else
+      {
+        // Simplicial factorization stored as standard CSC matrix.
+        StorageIndex *p = static_cast<StorageIndex*>(m_cholmodFactor->p);
+        Index size = m_cholmodFactor->n;
+        for (Index k=0; k<size; ++k)
+          logDet += log(real( x[p[k]] ));
+      }
+      if (m_cholmodFactor->is_ll)
+        logDet *= 2.0;
+      return logDet;
+    };
+
+    template<typename Stream>
+    void dumpMemory(Stream& /*s*/)
+    {}
+
+  protected:
+    mutable cholmod_common m_cholmod;
+    cholmod_factor* m_cholmodFactor;
+    double m_shiftOffset[2];
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+};
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodSimplicialLLT
+  * \brief A simplicial direct Cholesky (LLT) factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a simplicial LL^T Cholesky factorization
+  * using the Cholmod library.
+  * This simplicial variant is equivalent to Eigen's built-in SimplicialLLT class. Therefore, it has little practical interest.
+  * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept, class CholmodSupernodalLLT, class SimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodSimplicialLLT : public CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLLT<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLLT> Base;
+    using Base::m_cholmod;
+
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    CholmodSimplicialLLT() : Base() { init(); }
+
+    CholmodSimplicialLLT(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodSimplicialLLT() {}
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 0;
+      m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+      m_cholmod.final_ll = 1;
+    }
+};
+
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodSimplicialLDLT
+  * \brief A simplicial direct Cholesky (LDLT) factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a simplicial LDL^T Cholesky factorization
+  * using the Cholmod library.
+  * This simplicial variant is equivalent to Eigen's built-in SimplicialLDLT class. Therefore, it has little practical interest.
+  * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept, class CholmodSupernodalLLT, class SimplicialLDLT
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodSimplicialLDLT : public CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLDLT<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLDLT> Base;
+    using Base::m_cholmod;
+
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    CholmodSimplicialLDLT() : Base() { init(); }
+
+    CholmodSimplicialLDLT(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodSimplicialLDLT() {}
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 1;
+      m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+    }
+};
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodSupernodalLLT
+  * \brief A supernodal Cholesky (LLT) factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a supernodal LL^T Cholesky factorization
+  * using the Cholmod library.
+  * This supernodal variant performs best on dense enough problems, e.g., 3D FEM, or very high order 2D FEM.
+  * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodSupernodalLLT : public CholmodBase<_MatrixType, _UpLo, CholmodSupernodalLLT<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodSupernodalLLT> Base;
+    using Base::m_cholmod;
+
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    CholmodSupernodalLLT() : Base() { init(); }
+
+    CholmodSupernodalLLT(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodSupernodalLLT() {}
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 1;
+      m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
+    }
+};
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodDecomposition
+  * \brief A general Cholesky factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LL^T or LDL^T Cholesky factorization
+  * using the Cholmod library. The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * This variant permits to change the underlying Cholesky method at runtime.
+  * On the other hand, it does not provide access to the result of the factorization.
+  * The default is to let Cholmod automatically choose between a simplicial and supernodal factorization.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodDecomposition : public CholmodBase<_MatrixType, _UpLo, CholmodDecomposition<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodDecomposition> Base;
+    using Base::m_cholmod;
+
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    CholmodDecomposition() : Base() { init(); }
+
+    CholmodDecomposition(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodDecomposition() {}
+
+    void setMode(CholmodMode mode)
+    {
+      switch(mode)
+      {
+        case CholmodAuto:
+          m_cholmod.final_asis = 1;
+          m_cholmod.supernodal = CHOLMOD_AUTO;
+          break;
+        case CholmodSimplicialLLt:
+          m_cholmod.final_asis = 0;
+          m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+          m_cholmod.final_ll = 1;
+          break;
+        case CholmodSupernodalLLt:
+          m_cholmod.final_asis = 1;
+          m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
+          break;
+        case CholmodLDLt:
+          m_cholmod.final_asis = 1;
+          m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+          break;
+        default:
+          break;
+      }
+    }
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 1;
+      m_cholmod.supernodal = CHOLMOD_AUTO;
+    }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CHOLMODSUPPORT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/ArithmeticSequence.h b/C++/yolo_bytetrack/include/Eigen/src/Core/ArithmeticSequence.h
new file mode 100644
index 00000000..b6200fac
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/ArithmeticSequence.h
@@ -0,0 +1,413 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARITHMETIC_SEQUENCE_H
+#define EIGEN_ARITHMETIC_SEQUENCE_H
+
+namespace Eigen {
+
+namespace internal {
+
+#if (!EIGEN_HAS_CXX11) || !((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48)
+template<typename T> struct aseq_negate {};
+
+template<> struct aseq_negate<Index> {
+  typedef Index type;
+};
+
+template<int N> struct aseq_negate<FixedInt<N> > {
+  typedef FixedInt<-N> type;
+};
+
+// Compilation error in the following case:
+template<> struct aseq_negate<FixedInt<DynamicIndex> > {};
+
+template<typename FirstType,typename SizeType,typename IncrType,
+         bool FirstIsSymbolic=symbolic::is_symbolic<FirstType>::value,
+         bool SizeIsSymbolic =symbolic::is_symbolic<SizeType>::value>
+struct aseq_reverse_first_type {
+  typedef Index type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,true> {
+  typedef symbolic::AddExpr<FirstType,
+                            symbolic::ProductExpr<symbolic::AddExpr<SizeType,symbolic::ValueExpr<FixedInt<-1> > >,
+                                                  symbolic::ValueExpr<IncrType> >
+                           > type;
+};
+
+template<typename SizeType,typename IncrType,typename EnableIf = void>
+struct aseq_reverse_first_type_aux {
+  typedef Index type;
+};
+
+template<typename SizeType,typename IncrType>
+struct aseq_reverse_first_type_aux<SizeType,IncrType,typename internal::enable_if<bool((SizeType::value+IncrType::value)|0x1)>::type> {
+  typedef FixedInt<(SizeType::value-1)*IncrType::value> type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,false> {
+  typedef typename aseq_reverse_first_type_aux<SizeType,IncrType>::type Aux;
+  typedef symbolic::AddExpr<FirstType,symbolic::ValueExpr<Aux> > type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct aseq_reverse_first_type<FirstType,SizeType,IncrType,false,true> {
+  typedef symbolic::AddExpr<symbolic::ProductExpr<symbolic::AddExpr<SizeType,symbolic::ValueExpr<FixedInt<-1> > >,
+                                                  symbolic::ValueExpr<IncrType> >,
+                            symbolic::ValueExpr<> > type;
+};
+#endif
+
+// Helper to cleanup the type of the increment:
+template<typename T> struct cleanup_seq_incr {
+  typedef typename cleanup_index_type<T,DynamicIndex>::type type;
+};
+
+}
+
+//--------------------------------------------------------------------------------
+// seq(first,last,incr) and seqN(first,size,incr)
+//--------------------------------------------------------------------------------
+
+template<typename FirstType=Index,typename SizeType=Index,typename IncrType=internal::FixedInt<1> >
+class ArithmeticSequence;
+
+template<typename FirstType,typename SizeType,typename IncrType>
+ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
+                   typename internal::cleanup_index_type<SizeType>::type,
+                   typename internal::cleanup_seq_incr<IncrType>::type >
+seqN(FirstType first, SizeType size, IncrType incr);
+
+/** \class ArithmeticSequence
+  * \ingroup Core_Module
+  *
+  * This class represents an arithmetic progression \f$ a_0, a_1, a_2, ..., a_{n-1}\f$ defined by
+  * its \em first value \f$ a_0 \f$, its \em size (aka length) \em n, and the \em increment (aka stride)
+  * that is equal to \f$ a_{i+1}-a_{i}\f$ for any \em i.
+  *
+  * It is internally used as the return type of the Eigen::seq and Eigen::seqN functions, and as the input arguments
+  * of DenseBase::operator()(const RowIndices&, const ColIndices&), and most of the time this is the
+  * only way it is used.
+  *
+  * \tparam FirstType type of the first element, usually an Index,
+  *                   but internally it can be a symbolic expression
+  * \tparam SizeType type representing the size of the sequence, usually an Index
+  *                  or a compile time integral constant. Internally, it can also be a symbolic expression
+  * \tparam IncrType type of the increment, can be a runtime Index, or a compile time integral constant (default is compile-time 1)
+  *
+  * \sa Eigen::seq, Eigen::seqN, DenseBase::operator()(const RowIndices&, const ColIndices&), class IndexedView
+  */
+template<typename FirstType,typename SizeType,typename IncrType>
+class ArithmeticSequence
+{
+public:
+  ArithmeticSequence(FirstType first, SizeType size) : m_first(first), m_size(size) {}
+  ArithmeticSequence(FirstType first, SizeType size, IncrType incr) : m_first(first), m_size(size), m_incr(incr) {}
+
+  enum {
+    SizeAtCompileTime = internal::get_fixed_value<SizeType>::value,
+    IncrAtCompileTime = internal::get_fixed_value<IncrType,DynamicIndex>::value
+  };
+
+  /** \returns the size, i.e., number of elements, of the sequence */
+  Index size()  const { return m_size; }
+
+  /** \returns the first element \f$ a_0 \f$ in the sequence */
+  Index first()  const { return m_first; }
+
+  /** \returns the value \f$ a_i \f$ at index \a i in the sequence. */
+  Index operator[](Index i) const { return m_first + i * m_incr; }
+
+  const FirstType& firstObject() const { return m_first; }
+  const SizeType&  sizeObject()  const { return m_size; }
+  const IncrType&  incrObject()  const { return m_incr; }
+
+protected:
+  FirstType m_first;
+  SizeType  m_size;
+  IncrType  m_incr;
+
+public:
+
+#if EIGEN_HAS_CXX11 && ((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48)
+  auto reverse() const -> decltype(Eigen::seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr)) {
+    return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr);
+  }
+#else
+protected:
+  typedef typename internal::aseq_negate<IncrType>::type ReverseIncrType;
+  typedef typename internal::aseq_reverse_first_type<FirstType,SizeType,IncrType>::type ReverseFirstType;
+public:
+  ArithmeticSequence<ReverseFirstType,SizeType,ReverseIncrType>
+  reverse() const {
+    return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr);
+  }
+#endif
+};
+
+/** \returns an ArithmeticSequence starting at \a first, of length \a size, and increment \a incr
+  *
+  * \sa seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) */
+template<typename FirstType,typename SizeType,typename IncrType>
+ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type,typename internal::cleanup_seq_incr<IncrType>::type >
+seqN(FirstType first, SizeType size, IncrType incr)  {
+  return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type,typename internal::cleanup_seq_incr<IncrType>::type>(first,size,incr);
+}
+
+/** \returns an ArithmeticSequence starting at \a first, of length \a size, and unit increment
+  *
+  * \sa seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType) */
+template<typename FirstType,typename SizeType>
+ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type >
+seqN(FirstType first, SizeType size)  {
+  return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type>(first,size);
+}
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+
+/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and with positive (or negative) increment \a incr
+  *
+  * It is essentially an alias to:
+  * \code
+  * seqN(f, (l-f+incr)/incr, incr);
+  * \endcode
+  *
+  * \sa seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType)
+  */
+template<typename FirstType,typename LastType, typename IncrType>
+auto seq(FirstType f, LastType l, IncrType incr);
+
+/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and unit increment
+  *
+  * It is essentially an alias to:
+  * \code
+  * seqN(f,l-f+1);
+  * \endcode
+  *
+  * \sa seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType)
+  */
+template<typename FirstType,typename LastType>
+auto seq(FirstType f, LastType l);
+
+#else // EIGEN_PARSED_BY_DOXYGEN
+
+#if EIGEN_HAS_CXX11
+template<typename FirstType,typename LastType>
+auto seq(FirstType f, LastType l) -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+                                                   (  typename internal::cleanup_index_type<LastType>::type(l)
+                                                    - typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>())))
+{
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              (typename internal::cleanup_index_type<LastType>::type(l)
+               -typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()));
+}
+
+template<typename FirstType,typename LastType, typename IncrType>
+auto seq(FirstType f, LastType l, IncrType incr)
+  -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+                   (   typename internal::cleanup_index_type<LastType>::type(l)
+                     - typename internal::cleanup_index_type<FirstType>::type(f)+typename internal::cleanup_seq_incr<IncrType>::type(incr)
+                   ) / typename internal::cleanup_seq_incr<IncrType>::type(incr),
+                   typename internal::cleanup_seq_incr<IncrType>::type(incr)))
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              ( typename internal::cleanup_index_type<LastType>::type(l)
+               -typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr)) / CleanedIncrType(incr),
+              CleanedIncrType(incr));
+}
+
+#else // EIGEN_HAS_CXX11
+
+template<typename FirstType,typename LastType>
+typename internal::enable_if<!(symbolic::is_symbolic<FirstType>::value || symbolic::is_symbolic<LastType>::value),
+                             ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index> >::type
+seq(FirstType f, LastType l)
+{
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              Index((typename internal::cleanup_index_type<LastType>::type(l)-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>())));
+}
+
+template<typename FirstTypeDerived,typename LastType>
+typename internal::enable_if<!symbolic::is_symbolic<LastType>::value,
+    ArithmeticSequence<FirstTypeDerived, symbolic::AddExpr<symbolic::AddExpr<symbolic::NegateExpr<FirstTypeDerived>,symbolic::ValueExpr<> >,
+                                                            symbolic::ValueExpr<internal::FixedInt<1> > > > >::type
+seq(const symbolic::BaseExpr<FirstTypeDerived> &f, LastType l)
+{
+  return seqN(f.derived(),(typename internal::cleanup_index_type<LastType>::type(l)-f.derived()+fix<1>()));
+}
+
+template<typename FirstType,typename LastTypeDerived>
+typename internal::enable_if<!symbolic::is_symbolic<FirstType>::value,
+    ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
+                        symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::ValueExpr<> >,
+                                          symbolic::ValueExpr<internal::FixedInt<1> > > > >::type
+seq(FirstType f, const symbolic::BaseExpr<LastTypeDerived> &l)
+{
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),(l.derived()-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()));
+}
+
+template<typename FirstTypeDerived,typename LastTypeDerived>
+ArithmeticSequence<FirstTypeDerived,
+                    symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::NegateExpr<FirstTypeDerived> >,symbolic::ValueExpr<internal::FixedInt<1> > > >
+seq(const symbolic::BaseExpr<FirstTypeDerived> &f, const symbolic::BaseExpr<LastTypeDerived> &l)
+{
+  return seqN(f.derived(),(l.derived()-f.derived()+fix<1>()));
+}
+
+
+template<typename FirstType,typename LastType, typename IncrType>
+typename internal::enable_if<!(symbolic::is_symbolic<FirstType>::value || symbolic::is_symbolic<LastType>::value),
+    ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index,typename internal::cleanup_seq_incr<IncrType>::type> >::type
+seq(FirstType f, LastType l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              Index((typename internal::cleanup_index_type<LastType>::type(l)-typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr))/CleanedIncrType(incr)), incr);
+}
+
+template<typename FirstTypeDerived,typename LastType, typename IncrType>
+typename internal::enable_if<!symbolic::is_symbolic<LastType>::value,
+    ArithmeticSequence<FirstTypeDerived,
+                        symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<symbolic::NegateExpr<FirstTypeDerived>,
+                                                                                   symbolic::ValueExpr<> >,
+                                                                 symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                                              symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                        typename internal::cleanup_seq_incr<IncrType>::type> >::type
+seq(const symbolic::BaseExpr<FirstTypeDerived> &f, LastType l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(f.derived(),(typename internal::cleanup_index_type<LastType>::type(l)-f.derived()+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
+}
+
+template<typename FirstType,typename LastTypeDerived, typename IncrType>
+typename internal::enable_if<!symbolic::is_symbolic<FirstType>::value,
+    ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
+                        symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::ValueExpr<> >,
+                                                                 symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                                               symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                        typename internal::cleanup_seq_incr<IncrType>::type> >::type
+seq(FirstType f, const symbolic::BaseExpr<LastTypeDerived> &l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              (l.derived()-typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
+}
+
+template<typename FirstTypeDerived,typename LastTypeDerived, typename IncrType>
+ArithmeticSequence<FirstTypeDerived,
+                    symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,
+                                                                               symbolic::NegateExpr<FirstTypeDerived> >,
+                                                             symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                                          symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                    typename internal::cleanup_seq_incr<IncrType>::type>
+seq(const symbolic::BaseExpr<FirstTypeDerived> &f, const symbolic::BaseExpr<LastTypeDerived> &l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(f.derived(),(l.derived()-f.derived()+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
+}
+#endif // EIGEN_HAS_CXX11
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+
+#if EIGEN_HAS_CXX11 || defined(EIGEN_PARSED_BY_DOXYGEN)
+/** \cpp11
+  * \returns a symbolic ArithmeticSequence representing the last \a size elements with increment \a incr.
+  *
+  * It is a shortcut for: \code seqN(last-(size-fix<1>)*incr, size, incr) \endcode
+  * 
+  * \sa lastN(SizeType), seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) */
+template<typename SizeType,typename IncrType>
+auto lastN(SizeType size, IncrType incr)
+-> decltype(seqN(Eigen::last-(size-fix<1>())*incr, size, incr))
+{
+  return seqN(Eigen::last-(size-fix<1>())*incr, size, incr);
+}
+
+/** \cpp11
+  * \returns a symbolic ArithmeticSequence representing the last \a size elements with a unit increment.
+  *
+  *  It is a shortcut for: \code seq(last+fix<1>-size, last) \endcode
+  * 
+  * \sa lastN(SizeType,IncrType, seqN(FirstType,SizeType), seq(FirstType,LastType) */
+template<typename SizeType>
+auto lastN(SizeType size)
+-> decltype(seqN(Eigen::last+fix<1>()-size, size))
+{
+  return seqN(Eigen::last+fix<1>()-size, size);
+}
+#endif
+
+namespace internal {
+
+// Convert a symbolic span into a usable one (i.e., remove last/end "keywords")
+template<typename T>
+struct make_size_type {
+  typedef typename internal::conditional<symbolic::is_symbolic<T>::value, Index, T>::type type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType,int XprSize>
+struct IndexedViewCompatibleType<ArithmeticSequence<FirstType,SizeType,IncrType>, XprSize> {
+  typedef ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType> type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType>
+makeIndexedViewCompatible(const ArithmeticSequence<FirstType,SizeType,IncrType>& ids, Index size,SpecializedType) {
+  return ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType>(
+            eval_expr_given_size(ids.firstObject(),size),eval_expr_given_size(ids.sizeObject(),size),ids.incrObject());
+}
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct get_compile_time_incr<ArithmeticSequence<FirstType,SizeType,IncrType> > {
+  enum { value = get_fixed_value<IncrType,DynamicIndex>::value };
+};
+
+} // end namespace internal
+
+/** \namespace Eigen::indexing
+  * \ingroup Core_Module
+  * 
+  * The sole purpose of this namespace is to be able to import all functions
+  * and symbols that are expected to be used within operator() for indexing
+  * and slicing. If you already imported the whole Eigen namespace:
+  * \code using namespace Eigen; \endcode
+  * then you are already all set. Otherwise, if you don't want/cannot import
+  * the whole Eigen namespace, the following line:
+  * \code using namespace Eigen::indexing; \endcode
+  * is equivalent to:
+  * \code
+  using Eigen::all;
+  using Eigen::seq;
+  using Eigen::seqN;
+  using Eigen::lastN; // c++11 only
+  using Eigen::last;
+  using Eigen::lastp1;
+  using Eigen::fix;
+  \endcode
+  */
+namespace indexing {
+  using Eigen::all;
+  using Eigen::seq;
+  using Eigen::seqN;
+  #if EIGEN_HAS_CXX11
+  using Eigen::lastN;
+  #endif
+  using Eigen::last;
+  using Eigen::lastp1;
+  using Eigen::fix;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARITHMETIC_SEQUENCE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Array.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Array.h
new file mode 100644
index 00000000..20c789b1
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Array.h
@@ -0,0 +1,417 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARRAY_H
+#define EIGEN_ARRAY_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct traits<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > : traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+  typedef ArrayXpr XprKind;
+  typedef ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > XprBase;
+};
+}
+
+/** \class Array
+  * \ingroup Core_Module
+  *
+  * \brief General-purpose arrays with easy API for coefficient-wise operations
+  *
+  * The %Array class is very similar to the Matrix class. It provides
+  * general-purpose one- and two-dimensional arrays. The difference between the
+  * %Array and the %Matrix class is primarily in the API: the API for the
+  * %Array class provides easy access to coefficient-wise operations, while the
+  * API for the %Matrix class provides easy access to linear-algebra
+  * operations.
+  *
+  * See documentation of class Matrix for detailed information on the template parameters
+  * storage layout.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_ARRAY_PLUGIN.
+  *
+  * \sa \blank \ref TutorialArrayClass, \ref TopicClassHierarchy
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+class Array
+  : public PlainObjectBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+  public:
+
+    typedef PlainObjectBase<Array> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Array)
+
+    enum { Options = _Options };
+    typedef typename Base::PlainObject PlainObject;
+
+  protected:
+    template <typename Derived, typename OtherDerived, bool IsVector>
+    friend struct internal::conservative_resize_like_impl;
+
+    using Base::m_storage;
+
+  public:
+
+    using Base::base;
+    using Base::coeff;
+    using Base::coeffRef;
+
+    /**
+      * The usage of
+      *   using Base::operator=;
+      * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped
+      * the usage of 'using'. This should be done only for operator=.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const EigenBase<OtherDerived> &other)
+    {
+      return Base::operator=(other);
+    }
+
+    /** Set all the entries to \a value.
+      * \sa DenseBase::setConstant(), DenseBase::fill()
+      */
+    /* This overload is needed because the usage of
+      *   using Base::operator=;
+      * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped
+      * the usage of 'using'. This should be done only for operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const Scalar &value)
+    {
+      Base::setConstant(value);
+      return *this;
+    }
+
+    /** Copies the value of the expression \a other into \c *this with automatic resizing.
+      *
+      * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
+      * it will be initialized.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const DenseBase<OtherDerived>& other)
+    {
+      return Base::_set(other);
+    }
+
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const Array& other)
+    {
+      return Base::_set(other);
+    }
+
+    /** Default constructor.
+      *
+      * For fixed-size matrices, does nothing.
+      *
+      * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix
+      * is called a null matrix. This constructor is the unique way to create null matrices: resizing
+      * a matrix to 0 is not supported.
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array() : Base()
+    {
+      Base::_check_template_params();
+      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    // FIXME is it still needed ??
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    Array(internal::constructor_without_unaligned_array_assert)
+      : Base(internal::constructor_without_unaligned_array_assert())
+    {
+      Base::_check_template_params();
+      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+#endif
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    Array(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible<Scalar>::value)
+      : Base(std::move(other))
+    {
+      Base::_check_template_params();
+    }
+    EIGEN_DEVICE_FUNC
+    Array& operator=(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
+    {
+      Base::operator=(std::move(other));
+      return *this;
+    }
+#endif
+
+    #if EIGEN_HAS_CXX11
+    /** \copydoc PlainObjectBase(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
+     *
+     * Example: \include Array_variadic_ctor_cxx11.cpp
+     * Output: \verbinclude Array_variadic_ctor_cxx11.out
+     *
+     * \sa Array(const std::initializer_list<std::initializer_list<Scalar>>&)
+     * \sa Array(const Scalar&), Array(const Scalar&,const Scalar&)
+     */
+    template <typename... ArgTypes>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
+      : Base(a0, a1, a2, a3, args...) {}
+
+    /** \brief Constructs an array and initializes it from the coefficients given as initializer-lists grouped by row. \cpp11
+      *
+      * In the general case, the constructor takes a list of rows, each row being represented as a list of coefficients:
+      *
+      * Example: \include Array_initializer_list_23_cxx11.cpp
+      * Output: \verbinclude Array_initializer_list_23_cxx11.out
+      *
+      * Each of the inner initializer lists must contain the exact same number of elements, otherwise an assertion is triggered.
+      *
+      * In the case of a compile-time column 1D array, implicit transposition from a single row is allowed.
+      * Therefore <code> Array<int,Dynamic,1>{{1,2,3,4,5}}</code> is legal and the more verbose syntax
+      * <code>Array<int,Dynamic,1>{{1},{2},{3},{4},{5}}</code> can be avoided:
+      *
+      * Example: \include Array_initializer_list_vector_cxx11.cpp
+      * Output: \verbinclude Array_initializer_list_vector_cxx11.out
+      *
+      * In the case of fixed-sized arrays, the initializer list sizes must exactly match the array sizes,
+      * and implicit transposition is allowed for compile-time 1D arrays only.
+      *
+      * \sa  Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const std::initializer_list<std::initializer_list<Scalar>>& list) : Base(list) {}
+    #endif // end EIGEN_HAS_CXX11
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE explicit Array(const T& x)
+    {
+      Base::_check_template_params();
+      Base::template _init1<T>(x);
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1)
+    {
+      Base::_check_template_params();
+      this->template _init2<T0,T1>(val0, val1);
+    }
+
+    #else
+    /** \brief Constructs a fixed-sized array initialized with coefficients starting at \a data */
+    EIGEN_DEVICE_FUNC explicit Array(const Scalar *data);
+    /** Constructs a vector or row-vector with given dimension. \only_for_vectors
+      *
+      * Note that this is only useful for dynamic-size vectors. For fixed-size vectors,
+      * it is redundant to pass the dimension here, so it makes more sense to use the default
+      * constructor Array() instead.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE explicit Array(Index dim);
+    /** constructs an initialized 1x1 Array with the given coefficient
+      * \sa const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args */
+    Array(const Scalar& value);
+    /** constructs an uninitialized array with \a rows rows and \a cols columns.
+      *
+      * This is useful for dynamic-size arrays. For fixed-size arrays,
+      * it is redundant to pass these parameters, so one should use the default constructor
+      * Array() instead. */
+    Array(Index rows, Index cols);
+    /** constructs an initialized 2D vector with given coefficients
+      * \sa Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args) */
+    Array(const Scalar& val0, const Scalar& val1);
+    #endif  // end EIGEN_PARSED_BY_DOXYGEN
+
+    /** constructs an initialized 3D vector with given coefficients
+      * \sa Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 3)
+      m_storage.data()[0] = val0;
+      m_storage.data()[1] = val1;
+      m_storage.data()[2] = val2;
+    }
+    /** constructs an initialized 4D vector with given coefficients
+      * \sa Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2, const Scalar& val3)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 4)
+      m_storage.data()[0] = val0;
+      m_storage.data()[1] = val1;
+      m_storage.data()[2] = val2;
+      m_storage.data()[3] = val3;
+    }
+
+    /** Copy constructor */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const Array& other)
+            : Base(other)
+    { }
+
+  private:
+    struct PrivateType {};
+  public:
+
+    /** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other,
+                              typename internal::enable_if<internal::is_convertible<typename OtherDerived::Scalar,Scalar>::value,
+                                                           PrivateType>::type = PrivateType())
+      : Base(other.derived())
+    { }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT{ return 1; }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return this->innerSize(); }
+
+    #ifdef EIGEN_ARRAY_PLUGIN
+    #include EIGEN_ARRAY_PLUGIN
+    #endif
+
+  private:
+
+    template<typename MatrixType, typename OtherDerived, bool SwapPointers>
+    friend struct internal::matrix_swap_impl;
+};
+
+/** \defgroup arraytypedefs Global array typedefs
+  * \ingroup Core_Module
+  *
+  * %Eigen defines several typedef shortcuts for most common 1D and 2D array types.
+  *
+  * The general patterns are the following:
+  *
+  * \c ArrayRowsColsType where \c Rows and \c Cols can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd
+  * for complex double.
+  *
+  * For example, \c Array33d is a fixed-size 3x3 array type of doubles, and \c ArrayXXf is a dynamic-size matrix of floats.
+  *
+  * There are also \c ArraySizeType which are self-explanatory. For example, \c Array4cf is
+  * a fixed-size 1D array of 4 complex floats.
+  *
+  * With \cpp11, template alias are also defined for common sizes.
+  * They follow the same pattern as above except that the scalar type suffix is replaced by a
+  * template parameter, i.e.:
+  *   - `ArrayRowsCols<Type>` where `Rows` and `Cols` can be \c 2,\c 3,\c 4, or \c X for fixed or dynamic size.
+  *   - `ArraySize<Type>` where `Size` can be \c 2,\c 3,\c 4 or \c X for fixed or dynamic size 1D arrays.
+  *
+  * \sa class Array
+  */
+
+#define EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix)   \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Size, Size> Array##SizeSuffix##SizeSuffix##TypeSuffix;  \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Size, 1>    Array##SizeSuffix##TypeSuffix;
+
+#define EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, Size)         \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Size, Dynamic> Array##Size##X##TypeSuffix;  \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Dynamic, Size> Array##X##Size##TypeSuffix;
+
+#define EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 2, 2) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 3, 3) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 4, 4) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 4)
+
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(int,                  i)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(float,                f)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(double,               d)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<float>,  cf)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
+
+#undef EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES
+#undef EIGEN_MAKE_ARRAY_TYPEDEFS
+#undef EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS
+
+#if EIGEN_HAS_CXX11
+
+#define EIGEN_MAKE_ARRAY_TYPEDEFS(Size, SizeSuffix)               \
+/** \ingroup arraytypedefs */                                     \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Array##SizeSuffix##SizeSuffix = Array<Type, Size, Size>;    \
+/** \ingroup arraytypedefs */                                     \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Array##SizeSuffix = Array<Type, Size, 1>;
+
+#define EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Size)                     \
+/** \ingroup arraytypedefs */                                     \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Array##Size##X = Array<Type, Size, Dynamic>;                \
+/** \ingroup arraytypedefs */                                     \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Array##X##Size = Array<Type, Dynamic, Size>;
+
+EIGEN_MAKE_ARRAY_TYPEDEFS(2, 2)
+EIGEN_MAKE_ARRAY_TYPEDEFS(3, 3)
+EIGEN_MAKE_ARRAY_TYPEDEFS(4, 4)
+EIGEN_MAKE_ARRAY_TYPEDEFS(Dynamic, X)
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(2)
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(3)
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(4)
+
+#undef EIGEN_MAKE_ARRAY_TYPEDEFS
+#undef EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS
+
+#endif // EIGEN_HAS_CXX11
+
+#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, SizeSuffix) \
+using Eigen::Matrix##SizeSuffix##TypeSuffix; \
+using Eigen::Vector##SizeSuffix##TypeSuffix; \
+using Eigen::RowVector##SizeSuffix##TypeSuffix;
+
+#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(TypeSuffix) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 2) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 3) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 4) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, X) \
+
+#define EIGEN_USING_ARRAY_TYPEDEFS \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(i) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(f) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(d) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cf) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cd)
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARRAY_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/ArrayBase.h b/C++/yolo_bytetrack/include/Eigen/src/Core/ArrayBase.h
new file mode 100644
index 00000000..ea3dd1c3
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/ArrayBase.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARRAYBASE_H
+#define EIGEN_ARRAYBASE_H
+
+namespace Eigen { 
+
+template<typename ExpressionType> class MatrixWrapper;
+
+/** \class ArrayBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for all 1D and 2D array, and related expressions
+  *
+  * An array is similar to a dense vector or matrix. While matrices are mathematical
+  * objects with well defined linear algebra operators, an array is just a collection
+  * of scalar values arranged in a one or two dimensionnal fashion. As the main consequence,
+  * all operations applied to an array are performed coefficient wise. Furthermore,
+  * arrays support scalar math functions of the c++ standard library (e.g., std::sin(x)), and convenient
+  * constructors allowing to easily write generic code working for both scalar values
+  * and arrays.
+  *
+  * This class is the base that is inherited by all array expression types.
+  *
+  * \tparam Derived is the derived type, e.g., an array or an expression type.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_ARRAYBASE_PLUGIN.
+  *
+  * \sa class MatrixBase, \ref TopicClassHierarchy
+  */
+template<typename Derived> class ArrayBase
+  : public DenseBase<Derived>
+{
+  public:
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** The base class for a given storage type. */
+    typedef ArrayBase StorageBaseType;
+
+    typedef ArrayBase Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    typedef DenseBase<Derived> Base;
+    using Base::RowsAtCompileTime;
+    using Base::ColsAtCompileTime;
+    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+    
+    using Base::derived;
+    using Base::const_cast_derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+    using Base::lazyAssign;
+    using Base::operator-;
+    using Base::operator=;
+    using Base::operator+=;
+    using Base::operator-=;
+    using Base::operator*=;
+    using Base::operator/=;
+
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Base::PlainObject PlainObject;
+
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#   include "../plugins/MatrixCwiseUnaryOps.h"
+#   include "../plugins/ArrayCwiseUnaryOps.h"
+#   include "../plugins/CommonCwiseBinaryOps.h"
+#   include "../plugins/MatrixCwiseBinaryOps.h"
+#   include "../plugins/ArrayCwiseBinaryOps.h"
+#   ifdef EIGEN_ARRAYBASE_PLUGIN
+#     include EIGEN_ARRAYBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_UNARY_ADDONS
+
+    /** Special case of the template operator=, in order to prevent the compiler
+      * from generating a default operator= (issue hit with g++ 4.1)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const ArrayBase& other)
+    {
+      internal::call_assignment(derived(), other.derived());
+      return derived();
+    }
+    
+    /** Set all the entries to \a value.
+      * \sa DenseBase::setConstant(), DenseBase::fill() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const Scalar &value)
+    { Base::setConstant(value); return derived(); }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator+=(const Scalar& scalar);
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator-=(const Scalar& scalar);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator+=(const ArrayBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator-=(const ArrayBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator*=(const ArrayBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator/=(const ArrayBase<OtherDerived>& other);
+
+  public:
+    EIGEN_DEVICE_FUNC
+    ArrayBase<Derived>& array() { return *this; }
+    EIGEN_DEVICE_FUNC
+    const ArrayBase<Derived>& array() const { return *this; }
+
+    /** \returns an \link Eigen::MatrixBase Matrix \endlink expression of this array
+      * \sa MatrixBase::array() */
+    EIGEN_DEVICE_FUNC
+    MatrixWrapper<Derived> matrix() { return MatrixWrapper<Derived>(derived()); }
+    EIGEN_DEVICE_FUNC
+    const MatrixWrapper<const Derived> matrix() const { return MatrixWrapper<const Derived>(derived()); }
+
+//     template<typename Dest>
+//     inline void evalTo(Dest& dst) const { dst = matrix(); }
+
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(ArrayBase)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(ArrayBase)
+
+  private:
+    explicit ArrayBase(Index);
+    ArrayBase(Index,Index);
+    template<typename OtherDerived> explicit ArrayBase(const ArrayBase<OtherDerived>&);
+  protected:
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator+=(const MatrixBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator-=(const MatrixBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+};
+
+/** replaces \c *this by \c *this - \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator-=(const ArrayBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this + \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator+=(const ArrayBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this * \a other coefficient wise.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator*=(const ArrayBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::mul_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this / \a other coefficient wise.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator/=(const ArrayBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::div_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARRAYBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/ArrayWrapper.h b/C++/yolo_bytetrack/include/Eigen/src/Core/ArrayWrapper.h
new file mode 100644
index 00000000..2e9555b5
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/ArrayWrapper.h
@@ -0,0 +1,209 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARRAYWRAPPER_H
+#define EIGEN_ARRAYWRAPPER_H
+
+namespace Eigen {
+
+/** \class ArrayWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a mathematical vector or matrix as an array object
+  *
+  * This class is the return type of MatrixBase::array(), and most of the time
+  * this is the only way it is use.
+  *
+  * \sa MatrixBase::array(), class MatrixWrapper
+  */
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<ArrayWrapper<ExpressionType> >
+  : public traits<typename remove_all<typename ExpressionType::Nested>::type >
+{
+  typedef ArrayXpr XprKind;
+  // Let's remove NestByRefBit
+  enum {
+    Flags0 = traits<typename remove_all<typename ExpressionType::Nested>::type >::Flags,
+    LvalueBitFlag = is_lvalue<ExpressionType>::value ? LvalueBit : 0,
+    Flags = (Flags0 & ~(NestByRefBit | LvalueBit)) | LvalueBitFlag
+  };
+};
+}
+
+template<typename ExpressionType>
+class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> >
+{
+  public:
+    typedef ArrayBase<ArrayWrapper> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ArrayWrapper)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ArrayWrapper)
+    typedef typename internal::remove_all<ExpressionType>::type NestedExpression;
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<ExpressionType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    typedef typename internal::ref_selector<ExpressionType>::non_const_type NestedExpressionType;
+
+    using Base::coeffRef;
+
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE ArrayWrapper(ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_expression.cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return m_expression.outerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return m_expression.innerStride(); }
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return m_expression.data(); }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return m_expression.coeffRef(rowId, colId);
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      return m_expression.coeffRef(index);
+    }
+
+    template<typename Dest>
+    EIGEN_DEVICE_FUNC
+    inline void evalTo(Dest& dst) const { dst = m_expression; }
+
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<NestedExpressionType>::type&
+    nestedExpression() const
+    {
+      return m_expression;
+    }
+
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index)  */
+    EIGEN_DEVICE_FUNC
+    void resize(Index newSize) { m_expression.resize(newSize); }
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index,Index)*/
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols) { m_expression.resize(rows,cols); }
+
+  protected:
+    NestedExpressionType m_expression;
+};
+
+/** \class MatrixWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Expression of an array as a mathematical vector or matrix
+  *
+  * This class is the return type of ArrayBase::matrix(), and most of the time
+  * this is the only way it is use.
+  *
+  * \sa MatrixBase::matrix(), class ArrayWrapper
+  */
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<MatrixWrapper<ExpressionType> >
+ : public traits<typename remove_all<typename ExpressionType::Nested>::type >
+{
+  typedef MatrixXpr XprKind;
+  // Let's remove NestByRefBit
+  enum {
+    Flags0 = traits<typename remove_all<typename ExpressionType::Nested>::type >::Flags,
+    LvalueBitFlag = is_lvalue<ExpressionType>::value ? LvalueBit : 0,
+    Flags = (Flags0 & ~(NestByRefBit | LvalueBit)) | LvalueBitFlag
+  };
+};
+}
+
+template<typename ExpressionType>
+class MatrixWrapper : public MatrixBase<MatrixWrapper<ExpressionType> >
+{
+  public:
+    typedef MatrixBase<MatrixWrapper<ExpressionType> > Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(MatrixWrapper)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(MatrixWrapper)
+    typedef typename internal::remove_all<ExpressionType>::type NestedExpression;
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<ExpressionType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    typedef typename internal::ref_selector<ExpressionType>::non_const_type NestedExpressionType;
+
+    using Base::coeffRef;
+
+    EIGEN_DEVICE_FUNC
+    explicit inline MatrixWrapper(ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_expression.cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return m_expression.outerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return m_expression.innerStride(); }
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return m_expression.data(); }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return m_expression.derived().coeffRef(rowId, colId);
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      return m_expression.coeffRef(index);
+    }
+
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<NestedExpressionType>::type&
+    nestedExpression() const
+    {
+      return m_expression;
+    }
+
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index)  */
+    EIGEN_DEVICE_FUNC
+    void resize(Index newSize) { m_expression.resize(newSize); }
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index,Index)*/
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols) { m_expression.resize(rows,cols); }
+
+  protected:
+    NestedExpressionType m_expression;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARRAYWRAPPER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Assign.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Assign.h
new file mode 100644
index 00000000..655412ef
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Assign.h
@@ -0,0 +1,90 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Michael Olbrich <michael.olbrich@gmx.net>
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ASSIGN_H
+#define EIGEN_ASSIGN_H
+
+namespace Eigen {
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>
+  ::lazyAssign(const DenseBase<OtherDerived>& other)
+{
+  enum{
+    SameType = internal::is_same<typename Derived::Scalar,typename OtherDerived::Scalar>::value
+  };
+
+  EIGEN_STATIC_ASSERT_LVALUE(Derived)
+  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived)
+  EIGEN_STATIC_ASSERT(SameType,YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  eigen_assert(rows() == other.rows() && cols() == other.cols());
+  internal::call_assignment_no_alias(derived(),other.derived());
+  
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase<OtherDerived>& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const MatrixBase& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const DenseBase<OtherDerived>& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const EigenBase<OtherDerived>& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  other.derived().evalTo(derived());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ASSIGN_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/AssignEvaluator.h b/C++/yolo_bytetrack/include/Eigen/src/Core/AssignEvaluator.h
new file mode 100644
index 00000000..7d76f0c2
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/AssignEvaluator.h
@@ -0,0 +1,1010 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2011-2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ASSIGN_EVALUATOR_H
+#define EIGEN_ASSIGN_EVALUATOR_H
+
+namespace Eigen {
+
+// This implementation is based on Assign.h
+
+namespace internal {
+
+/***************************************************************************
+* Part 1 : the logic deciding a strategy for traversal and unrolling       *
+***************************************************************************/
+
+// copy_using_evaluator_traits is based on assign_traits
+
+template <typename DstEvaluator, typename SrcEvaluator, typename AssignFunc, int MaxPacketSize = -1>
+struct copy_using_evaluator_traits
+{
+  typedef typename DstEvaluator::XprType Dst;
+  typedef typename Dst::Scalar DstScalar;
+
+  enum {
+    DstFlags = DstEvaluator::Flags,
+    SrcFlags = SrcEvaluator::Flags
+  };
+
+public:
+  enum {
+    DstAlignment = DstEvaluator::Alignment,
+    SrcAlignment = SrcEvaluator::Alignment,
+    DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit,
+    JointAlignment = EIGEN_PLAIN_ENUM_MIN(DstAlignment,SrcAlignment)
+  };
+
+private:
+  enum {
+    InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
+              : int(DstFlags)&RowMajorBit ? int(Dst::ColsAtCompileTime)
+              : int(Dst::RowsAtCompileTime),
+    InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
+              : int(DstFlags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime)
+              : int(Dst::MaxRowsAtCompileTime),
+    RestrictedInnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(InnerSize,MaxPacketSize),
+    RestrictedLinearSize = EIGEN_SIZE_MIN_PREFER_FIXED(Dst::SizeAtCompileTime,MaxPacketSize),
+    OuterStride = int(outer_stride_at_compile_time<Dst>::ret),
+    MaxSizeAtCompileTime = Dst::SizeAtCompileTime
+  };
+
+  // TODO distinguish between linear traversal and inner-traversals
+  typedef typename find_best_packet<DstScalar,RestrictedLinearSize>::type LinearPacketType;
+  typedef typename find_best_packet<DstScalar,RestrictedInnerSize>::type InnerPacketType;
+
+  enum {
+    LinearPacketSize = unpacket_traits<LinearPacketType>::size,
+    InnerPacketSize = unpacket_traits<InnerPacketType>::size
+  };
+
+public:
+  enum {
+    LinearRequiredAlignment = unpacket_traits<LinearPacketType>::alignment,
+    InnerRequiredAlignment = unpacket_traits<InnerPacketType>::alignment
+  };
+
+private:
+  enum {
+    DstIsRowMajor = DstFlags&RowMajorBit,
+    SrcIsRowMajor = SrcFlags&RowMajorBit,
+    StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)),
+    MightVectorize = bool(StorageOrdersAgree)
+                  && (int(DstFlags) & int(SrcFlags) & ActualPacketAccessBit)
+                  && bool(functor_traits<AssignFunc>::PacketAccess),
+    MayInnerVectorize  = MightVectorize
+                       && int(InnerSize)!=Dynamic && int(InnerSize)%int(InnerPacketSize)==0
+                       && int(OuterStride)!=Dynamic && int(OuterStride)%int(InnerPacketSize)==0
+                       && (EIGEN_UNALIGNED_VECTORIZE  || int(JointAlignment)>=int(InnerRequiredAlignment)),
+    MayLinearize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & LinearAccessBit),
+    MayLinearVectorize = bool(MightVectorize) && bool(MayLinearize) && bool(DstHasDirectAccess)
+                       && (EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)) || MaxSizeAtCompileTime == Dynamic),
+      /* If the destination isn't aligned, we have to do runtime checks and we don't unroll,
+         so it's only good for large enough sizes. */
+    MaySliceVectorize  = bool(MightVectorize) && bool(DstHasDirectAccess)
+                       && (int(InnerMaxSize)==Dynamic || int(InnerMaxSize)>=(EIGEN_UNALIGNED_VECTORIZE?InnerPacketSize:(3*InnerPacketSize)))
+      /* slice vectorization can be slow, so we only want it if the slices are big, which is
+         indicated by InnerMaxSize rather than InnerSize, think of the case of a dynamic block
+         in a fixed-size matrix
+         However, with EIGEN_UNALIGNED_VECTORIZE and unrolling, slice vectorization is still worth it */
+  };
+
+public:
+  enum {
+    Traversal =  int(Dst::SizeAtCompileTime) == 0 ? int(AllAtOnceTraversal) // If compile-size is zero, traversing will fail at compile-time.
+              : (int(MayLinearVectorize) && (LinearPacketSize>InnerPacketSize)) ? int(LinearVectorizedTraversal)
+              : int(MayInnerVectorize)   ? int(InnerVectorizedTraversal)
+              : int(MayLinearVectorize)  ? int(LinearVectorizedTraversal)
+              : int(MaySliceVectorize)   ? int(SliceVectorizedTraversal)
+              : int(MayLinearize)        ? int(LinearTraversal)
+                                         : int(DefaultTraversal),
+    Vectorized = int(Traversal) == InnerVectorizedTraversal
+              || int(Traversal) == LinearVectorizedTraversal
+              || int(Traversal) == SliceVectorizedTraversal
+  };
+
+  typedef typename conditional<int(Traversal)==LinearVectorizedTraversal, LinearPacketType, InnerPacketType>::type PacketType;
+
+private:
+  enum {
+    ActualPacketSize    = int(Traversal)==LinearVectorizedTraversal ? LinearPacketSize
+                        : Vectorized ? InnerPacketSize
+                        : 1,
+    UnrollingLimit      = EIGEN_UNROLLING_LIMIT * ActualPacketSize,
+    MayUnrollCompletely = int(Dst::SizeAtCompileTime) != Dynamic
+                       && int(Dst::SizeAtCompileTime) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit),
+    MayUnrollInner      = int(InnerSize) != Dynamic
+                       && int(InnerSize) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit)
+  };
+
+public:
+  enum {
+    Unrolling = (int(Traversal) == int(InnerVectorizedTraversal) || int(Traversal) == int(DefaultTraversal))
+                ? (
+                    int(MayUnrollCompletely) ? int(CompleteUnrolling)
+                  : int(MayUnrollInner)      ? int(InnerUnrolling)
+                                             : int(NoUnrolling)
+                  )
+              : int(Traversal) == int(LinearVectorizedTraversal)
+                ? ( bool(MayUnrollCompletely) && ( EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)))
+                          ? int(CompleteUnrolling)
+                          : int(NoUnrolling) )
+              : int(Traversal) == int(LinearTraversal)
+                ? ( bool(MayUnrollCompletely) ? int(CompleteUnrolling)
+                                              : int(NoUnrolling) )
+#if EIGEN_UNALIGNED_VECTORIZE
+              : int(Traversal) == int(SliceVectorizedTraversal)
+                ? ( bool(MayUnrollInner) ? int(InnerUnrolling)
+                                         : int(NoUnrolling) )
+#endif
+              : int(NoUnrolling)
+  };
+
+#ifdef EIGEN_DEBUG_ASSIGN
+  static void debug()
+  {
+    std::cerr << "DstXpr: " << typeid(typename DstEvaluator::XprType).name() << std::endl;
+    std::cerr << "SrcXpr: " << typeid(typename SrcEvaluator::XprType).name() << std::endl;
+    std::cerr.setf(std::ios::hex, std::ios::basefield);
+    std::cerr << "DstFlags" << " = " << DstFlags << " (" << demangle_flags(DstFlags) << " )" << std::endl;
+    std::cerr << "SrcFlags" << " = " << SrcFlags << " (" << demangle_flags(SrcFlags) << " )" << std::endl;
+    std::cerr.unsetf(std::ios::hex);
+    EIGEN_DEBUG_VAR(DstAlignment)
+    EIGEN_DEBUG_VAR(SrcAlignment)
+    EIGEN_DEBUG_VAR(LinearRequiredAlignment)
+    EIGEN_DEBUG_VAR(InnerRequiredAlignment)
+    EIGEN_DEBUG_VAR(JointAlignment)
+    EIGEN_DEBUG_VAR(InnerSize)
+    EIGEN_DEBUG_VAR(InnerMaxSize)
+    EIGEN_DEBUG_VAR(LinearPacketSize)
+    EIGEN_DEBUG_VAR(InnerPacketSize)
+    EIGEN_DEBUG_VAR(ActualPacketSize)
+    EIGEN_DEBUG_VAR(StorageOrdersAgree)
+    EIGEN_DEBUG_VAR(MightVectorize)
+    EIGEN_DEBUG_VAR(MayLinearize)
+    EIGEN_DEBUG_VAR(MayInnerVectorize)
+    EIGEN_DEBUG_VAR(MayLinearVectorize)
+    EIGEN_DEBUG_VAR(MaySliceVectorize)
+    std::cerr << "Traversal" << " = " << Traversal << " (" << demangle_traversal(Traversal) << ")" << std::endl;
+    EIGEN_DEBUG_VAR(SrcEvaluator::CoeffReadCost)
+    EIGEN_DEBUG_VAR(DstEvaluator::CoeffReadCost)
+    EIGEN_DEBUG_VAR(Dst::SizeAtCompileTime)
+    EIGEN_DEBUG_VAR(UnrollingLimit)
+    EIGEN_DEBUG_VAR(MayUnrollCompletely)
+    EIGEN_DEBUG_VAR(MayUnrollInner)
+    std::cerr << "Unrolling" << " = " << Unrolling << " (" << demangle_unrolling(Unrolling) << ")" << std::endl;
+    std::cerr << std::endl;
+  }
+#endif
+};
+
+/***************************************************************************
+* Part 2 : meta-unrollers
+***************************************************************************/
+
+/************************
+*** Default traversal ***
+************************/
+
+template<typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling
+{
+  // FIXME: this is not very clean, perhaps this information should be provided by the kernel?
+  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
+  typedef typename DstEvaluatorType::XprType DstXprType;
+
+  enum {
+    outer = Index / DstXprType::InnerSizeAtCompileTime,
+    inner = Index % DstXprType::InnerSizeAtCompileTime
+  };
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    kernel.assignCoeffByOuterInner(outer, inner);
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Index+1, Stop>::run(kernel);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
+};
+
+template<typename Kernel, int Index_, int Stop>
+struct copy_using_evaluator_DefaultTraversal_InnerUnrolling
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer)
+  {
+    kernel.assignCoeffByOuterInner(outer, Index_);
+    copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Index_+1, Stop>::run(kernel, outer);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index) { }
+};
+
+/***********************
+*** Linear traversal ***
+***********************/
+
+template<typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_LinearTraversal_CompleteUnrolling
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel& kernel)
+  {
+    kernel.assignCoeff(Index);
+    copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Index+1, Stop>::run(kernel);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
+};
+
+/**************************
+*** Inner vectorization ***
+**************************/
+
+template<typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_innervec_CompleteUnrolling
+{
+  // FIXME: this is not very clean, perhaps this information should be provided by the kernel?
+  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
+  typedef typename DstEvaluatorType::XprType DstXprType;
+  typedef typename Kernel::PacketType PacketType;
+
+  enum {
+    outer = Index / DstXprType::InnerSizeAtCompileTime,
+    inner = Index % DstXprType::InnerSizeAtCompileTime,
+    SrcAlignment = Kernel::AssignmentTraits::SrcAlignment,
+    DstAlignment = Kernel::AssignmentTraits::DstAlignment
+  };
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, inner);
+    enum { NextIndex = Index + unpacket_traits<PacketType>::size };
+    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, NextIndex, Stop>::run(kernel);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_innervec_CompleteUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
+};
+
+template<typename Kernel, int Index_, int Stop, int SrcAlignment, int DstAlignment>
+struct copy_using_evaluator_innervec_InnerUnrolling
+{
+  typedef typename Kernel::PacketType PacketType;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer)
+  {
+    kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, Index_);
+    enum { NextIndex = Index_ + unpacket_traits<PacketType>::size };
+    copy_using_evaluator_innervec_InnerUnrolling<Kernel, NextIndex, Stop, SrcAlignment, DstAlignment>::run(kernel, outer);
+  }
+};
+
+template<typename Kernel, int Stop, int SrcAlignment, int DstAlignment>
+struct copy_using_evaluator_innervec_InnerUnrolling<Kernel, Stop, Stop, SrcAlignment, DstAlignment>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &, Index) { }
+};
+
+/***************************************************************************
+* Part 3 : implementation of all cases
+***************************************************************************/
+
+// dense_assignment_loop is based on assign_impl
+
+template<typename Kernel,
+         int Traversal = Kernel::AssignmentTraits::Traversal,
+         int Unrolling = Kernel::AssignmentTraits::Unrolling>
+struct dense_assignment_loop;
+
+/************************
+***** Special Cases *****
+************************/
+
+// Zero-sized assignment is a no-op.
+template<typename Kernel, int Unrolling>
+struct dense_assignment_loop<Kernel, AllAtOnceTraversal, Unrolling>
+{
+  EIGEN_DEVICE_FUNC static void EIGEN_STRONG_INLINE run(Kernel& /*kernel*/)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    EIGEN_STATIC_ASSERT(int(DstXprType::SizeAtCompileTime) == 0,
+      EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT)
+  }
+};
+
+/************************
+*** Default traversal ***
+************************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, DefaultTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static void EIGEN_STRONG_INLINE run(Kernel &kernel)
+  {
+    for(Index outer = 0; outer < kernel.outerSize(); ++outer) {
+      for(Index inner = 0; inner < kernel.innerSize(); ++inner) {
+        kernel.assignCoeffByOuterInner(outer, inner);
+      }
+    }
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, DefaultTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, DefaultTraversal, InnerUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+
+    const Index outerSize = kernel.outerSize();
+    for(Index outer = 0; outer < outerSize; ++outer)
+      copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime>::run(kernel, outer);
+  }
+};
+
+/***************************
+*** Linear vectorization ***
+***************************/
+
+
+// The goal of unaligned_dense_assignment_loop is simply to factorize the handling
+// of the non vectorizable beginning and ending parts
+
+template <bool IsAligned = false>
+struct unaligned_dense_assignment_loop
+{
+  // if IsAligned = true, then do nothing
+  template <typename Kernel>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index, Index) {}
+};
+
+template <>
+struct unaligned_dense_assignment_loop<false>
+{
+  // MSVC must not inline this functions. If it does, it fails to optimize the
+  // packet access path.
+  // FIXME check which version exhibits this issue
+#if EIGEN_COMP_MSVC
+  template <typename Kernel>
+  static EIGEN_DONT_INLINE void run(Kernel &kernel,
+                                    Index start,
+                                    Index end)
+#else
+  template <typename Kernel>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel,
+                                      Index start,
+                                      Index end)
+#endif
+  {
+    for (Index index = start; index < end; ++index)
+      kernel.assignCoeff(index);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearVectorizedTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    const Index size = kernel.size();
+    typedef typename Kernel::Scalar Scalar;
+    typedef typename Kernel::PacketType PacketType;
+    enum {
+      requestedAlignment = Kernel::AssignmentTraits::LinearRequiredAlignment,
+      packetSize = unpacket_traits<PacketType>::size,
+      dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
+      dstAlignment = packet_traits<Scalar>::AlignedOnScalar ? int(requestedAlignment)
+                                                            : int(Kernel::AssignmentTraits::DstAlignment),
+      srcAlignment = Kernel::AssignmentTraits::JointAlignment
+    };
+    const Index alignedStart = dstIsAligned ? 0 : internal::first_aligned<requestedAlignment>(kernel.dstDataPtr(), size);
+    const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;
+
+    unaligned_dense_assignment_loop<dstIsAligned!=0>::run(kernel, 0, alignedStart);
+
+    for(Index index = alignedStart; index < alignedEnd; index += packetSize)
+      kernel.template assignPacket<dstAlignment, srcAlignment, PacketType>(index);
+
+    unaligned_dense_assignment_loop<>::run(kernel, alignedEnd, size);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearVectorizedTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    typedef typename Kernel::PacketType PacketType;
+
+    enum { size = DstXprType::SizeAtCompileTime,
+           packetSize =unpacket_traits<PacketType>::size,
+           alignedSize = (int(size)/packetSize)*packetSize };
+
+    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, alignedSize>::run(kernel);
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, alignedSize, size>::run(kernel);
+  }
+};
+
+/**************************
+*** Inner vectorization ***
+**************************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, NoUnrolling>
+{
+  typedef typename Kernel::PacketType PacketType;
+  enum {
+    SrcAlignment = Kernel::AssignmentTraits::SrcAlignment,
+    DstAlignment = Kernel::AssignmentTraits::DstAlignment
+  };
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    const Index innerSize = kernel.innerSize();
+    const Index outerSize = kernel.outerSize();
+    const Index packetSize = unpacket_traits<PacketType>::size;
+    for(Index outer = 0; outer < outerSize; ++outer)
+      for(Index inner = 0; inner < innerSize; inner+=packetSize)
+        kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, inner);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, InnerUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    typedef typename Kernel::AssignmentTraits Traits;
+    const Index outerSize = kernel.outerSize();
+    for(Index outer = 0; outer < outerSize; ++outer)
+      copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime,
+                                                   Traits::SrcAlignment, Traits::DstAlignment>::run(kernel, outer);
+  }
+};
+
+/***********************
+*** Linear traversal ***
+***********************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    const Index size = kernel.size();
+    for(Index i = 0; i < size; ++i)
+      kernel.assignCoeff(i);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
+  }
+};
+
+/**************************
+*** Slice vectorization ***
+***************************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::Scalar Scalar;
+    typedef typename Kernel::PacketType PacketType;
+    enum {
+      packetSize = unpacket_traits<PacketType>::size,
+      requestedAlignment = int(Kernel::AssignmentTraits::InnerRequiredAlignment),
+      alignable = packet_traits<Scalar>::AlignedOnScalar || int(Kernel::AssignmentTraits::DstAlignment)>=sizeof(Scalar),
+      dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
+      dstAlignment = alignable ? int(requestedAlignment)
+                               : int(Kernel::AssignmentTraits::DstAlignment)
+    };
+    const Scalar *dst_ptr = kernel.dstDataPtr();
+    if((!bool(dstIsAligned)) && (UIntPtr(dst_ptr) % sizeof(Scalar))>0)
+    {
+      // the pointer is not aligned-on scalar, so alignment is not possible
+      return dense_assignment_loop<Kernel,DefaultTraversal,NoUnrolling>::run(kernel);
+    }
+    const Index packetAlignedMask = packetSize - 1;
+    const Index innerSize = kernel.innerSize();
+    const Index outerSize = kernel.outerSize();
+    const Index alignedStep = alignable ? (packetSize - kernel.outerStride() % packetSize) & packetAlignedMask : 0;
+    Index alignedStart = ((!alignable) || bool(dstIsAligned)) ? 0 : internal::first_aligned<requestedAlignment>(dst_ptr, innerSize);
+
+    for(Index outer = 0; outer < outerSize; ++outer)
+    {
+      const Index alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask);
+      // do the non-vectorizable part of the assignment
+      for(Index inner = 0; inner<alignedStart ; ++inner)
+        kernel.assignCoeffByOuterInner(outer, inner);
+
+      // do the vectorizable part of the assignment
+      for(Index inner = alignedStart; inner<alignedEnd; inner+=packetSize)
+        kernel.template assignPacketByOuterInner<dstAlignment, Unaligned, PacketType>(outer, inner);
+
+      // do the non-vectorizable part of the assignment
+      for(Index inner = alignedEnd; inner<innerSize ; ++inner)
+        kernel.assignCoeffByOuterInner(outer, inner);
+
+      alignedStart = numext::mini((alignedStart+alignedStep)%packetSize, innerSize);
+    }
+  }
+};
+
+#if EIGEN_UNALIGNED_VECTORIZE
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, InnerUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    typedef typename Kernel::PacketType PacketType;
+
+    enum { innerSize = DstXprType::InnerSizeAtCompileTime,
+           packetSize =unpacket_traits<PacketType>::size,
+           vectorizableSize = (int(innerSize) / int(packetSize)) * int(packetSize),
+           size = DstXprType::SizeAtCompileTime };
+
+    for(Index outer = 0; outer < kernel.outerSize(); ++outer)
+    {
+      copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, vectorizableSize, 0, 0>::run(kernel, outer);
+      copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, vectorizableSize, innerSize>::run(kernel, outer);
+    }
+  }
+};
+#endif
+
+
+/***************************************************************************
+* Part 4 : Generic dense assignment kernel
+***************************************************************************/
+
+// This class generalize the assignment of a coefficient (or packet) from one dense evaluator
+// to another dense writable evaluator.
+// It is parametrized by the two evaluators, and the actual assignment functor.
+// This abstraction level permits to keep the evaluation loops as simple and as generic as possible.
+// One can customize the assignment using this generic dense_assignment_kernel with different
+// functors, or by completely overloading it, by-passing a functor.
+template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version = Specialized>
+class generic_dense_assignment_kernel
+{
+protected:
+  typedef typename DstEvaluatorTypeT::XprType DstXprType;
+  typedef typename SrcEvaluatorTypeT::XprType SrcXprType;
+public:
+
+  typedef DstEvaluatorTypeT DstEvaluatorType;
+  typedef SrcEvaluatorTypeT SrcEvaluatorType;
+  typedef typename DstEvaluatorType::Scalar Scalar;
+  typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor> AssignmentTraits;
+  typedef typename AssignmentTraits::PacketType PacketType;
+
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  generic_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
+    : m_dst(dst), m_src(src), m_functor(func), m_dstExpr(dstExpr)
+  {
+    #ifdef EIGEN_DEBUG_ASSIGN
+    AssignmentTraits::debug();
+    #endif
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT { return m_dstExpr.size(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index innerSize() const EIGEN_NOEXCEPT { return m_dstExpr.innerSize(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index outerSize() const EIGEN_NOEXCEPT { return m_dstExpr.outerSize(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_dstExpr.rows(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_dstExpr.cols(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index outerStride() const EIGEN_NOEXCEPT { return m_dstExpr.outerStride(); }
+
+  EIGEN_DEVICE_FUNC DstEvaluatorType& dstEvaluator() EIGEN_NOEXCEPT { return m_dst; }
+  EIGEN_DEVICE_FUNC const SrcEvaluatorType& srcEvaluator() const EIGEN_NOEXCEPT { return m_src; }
+
+  /// Assign src(row,col) to dst(row,col) through the assignment functor.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index row, Index col)
+  {
+    m_functor.assignCoeff(m_dst.coeffRef(row,col), m_src.coeff(row,col));
+  }
+
+  /// \sa assignCoeff(Index,Index)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index index)
+  {
+    m_functor.assignCoeff(m_dst.coeffRef(index), m_src.coeff(index));
+  }
+
+  /// \sa assignCoeff(Index,Index)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeffByOuterInner(Index outer, Index inner)
+  {
+    Index row = rowIndexByOuterInner(outer, inner);
+    Index col = colIndexByOuterInner(outer, inner);
+    assignCoeff(row, col);
+  }
+
+
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index row, Index col)
+  {
+    m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(row,col), m_src.template packet<LoadMode,PacketType>(row,col));
+  }
+
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index index)
+  {
+    m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(index), m_src.template packet<LoadMode,PacketType>(index));
+  }
+
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacketByOuterInner(Index outer, Index inner)
+  {
+    Index row = rowIndexByOuterInner(outer, inner);
+    Index col = colIndexByOuterInner(outer, inner);
+    assignPacket<StoreMode,LoadMode,PacketType>(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner)
+  {
+    typedef typename DstEvaluatorType::ExpressionTraits Traits;
+    return int(Traits::RowsAtCompileTime) == 1 ? 0
+      : int(Traits::ColsAtCompileTime) == 1 ? inner
+      : int(DstEvaluatorType::Flags)&RowMajorBit ? outer
+      : inner;
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner)
+  {
+    typedef typename DstEvaluatorType::ExpressionTraits Traits;
+    return int(Traits::ColsAtCompileTime) == 1 ? 0
+      : int(Traits::RowsAtCompileTime) == 1 ? inner
+      : int(DstEvaluatorType::Flags)&RowMajorBit ? inner
+      : outer;
+  }
+
+  EIGEN_DEVICE_FUNC const Scalar* dstDataPtr() const
+  {
+    return m_dstExpr.data();
+  }
+
+protected:
+  DstEvaluatorType& m_dst;
+  const SrcEvaluatorType& m_src;
+  const Functor &m_functor;
+  // TODO find a way to avoid the needs of the original expression
+  DstXprType& m_dstExpr;
+};
+
+// Special kernel used when computing small products whose operands have dynamic dimensions.  It ensures that the
+// PacketSize used is no larger than 4, thereby increasing the chance that vectorized instructions will be used
+// when computing the product.
+
+template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor>
+class restricted_packet_dense_assignment_kernel : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, BuiltIn>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, BuiltIn> Base;
+ public:
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::DstXprType DstXprType;
+    typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, 4> AssignmentTraits;
+    typedef typename AssignmentTraits::PacketType PacketType;
+
+    EIGEN_DEVICE_FUNC restricted_packet_dense_assignment_kernel(DstEvaluatorTypeT &dst, const SrcEvaluatorTypeT &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {
+  }
+ };
+
+/***************************************************************************
+* Part 5 : Entry point for dense rectangular assignment
+***************************************************************************/
+
+template<typename DstXprType,typename SrcXprType, typename Functor>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const Functor &/*func*/)
+{
+  EIGEN_ONLY_USED_FOR_DEBUG(dst);
+  EIGEN_ONLY_USED_FOR_DEBUG(src);
+  eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+}
+
+template<typename DstXprType,typename SrcXprType, typename T1, typename T2>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
+{
+  Index dstRows = src.rows();
+  Index dstCols = src.cols();
+  if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
+    dst.resize(dstRows, dstCols);
+  eigen_assert(dst.rows() == dstRows && dst.cols() == dstCols);
+}
+
+template<typename DstXprType, typename SrcXprType, typename Functor>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
+{
+  typedef evaluator<DstXprType> DstEvaluatorType;
+  typedef evaluator<SrcXprType> SrcEvaluatorType;
+
+  SrcEvaluatorType srcEvaluator(src);
+
+  // NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
+  // we need to resize the destination after the source evaluator has been created.
+  resize_if_allowed(dst, src, func);
+
+  DstEvaluatorType dstEvaluator(dst);
+
+  typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
+  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+
+  dense_assignment_loop<Kernel>::run(kernel);
+}
+
+// Specialization for filling the destination with a constant value.
+#ifndef EIGEN_GPU_COMPILE_PHASE
+template<typename DstXprType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<typename DstXprType::Scalar>, DstXprType>& src, const internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>& func)
+{
+  resize_if_allowed(dst, src, func);
+  std::fill_n(dst.data(), dst.size(), src.functor()());
+}
+#endif
+
+template<typename DstXprType, typename SrcXprType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src)
+{
+  call_dense_assignment_loop(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
+}
+
+/***************************************************************************
+* Part 6 : Generic assignment
+***************************************************************************/
+
+// Based on the respective shapes of the destination and source,
+// the class AssignmentKind determine the kind of assignment mechanism.
+// AssignmentKind must define a Kind typedef.
+template<typename DstShape, typename SrcShape> struct AssignmentKind;
+
+// Assignment kind defined in this file:
+struct Dense2Dense {};
+struct EigenBase2EigenBase {};
+
+template<typename,typename> struct AssignmentKind { typedef EigenBase2EigenBase Kind; };
+template<> struct AssignmentKind<DenseShape,DenseShape> { typedef Dense2Dense Kind; };
+
+// This is the main assignment class
+template< typename DstXprType, typename SrcXprType, typename Functor,
+          typename Kind = typename AssignmentKind< typename evaluator_traits<DstXprType>::Shape , typename evaluator_traits<SrcXprType>::Shape >::Kind,
+          typename EnableIf = void>
+struct Assignment;
+
+
+// The only purpose of this call_assignment() function is to deal with noalias() / "assume-aliasing" and automatic transposition.
+// Indeed, I (Gael) think that this concept of "assume-aliasing" was a mistake, and it makes thing quite complicated.
+// So this intermediate function removes everything related to "assume-aliasing" such that Assignment
+// does not has to bother about these annoying details.
+
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(Dst& dst, const Src& src)
+{
+  call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(const Dst& dst, const Src& src)
+{
+  call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+
+// Deal with "assume-aliasing"
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
+{
+  typename plain_matrix_type<Src>::type tmp(src);
+  call_assignment_no_alias(dst, tmp, func);
+}
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if<!evaluator_assume_aliasing<Src>::value, void*>::type = 0)
+{
+  call_assignment_no_alias(dst, src, func);
+}
+
+// by-pass "assume-aliasing"
+// When there is no aliasing, we require that 'dst' has been properly resized
+template<typename Dst, template <typename> class StorageBase, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(NoAlias<Dst,StorageBase>& dst, const Src& src, const Func& func)
+{
+  call_assignment_no_alias(dst.expression(), src, func);
+}
+
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
+{
+  enum {
+    NeedToTranspose = (    (int(Dst::RowsAtCompileTime) == 1 && int(Src::ColsAtCompileTime) == 1)
+                        || (int(Dst::ColsAtCompileTime) == 1 && int(Src::RowsAtCompileTime) == 1)
+                      ) && int(Dst::SizeAtCompileTime) != 1
+  };
+
+  typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst>::type ActualDstTypeCleaned;
+  typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst&>::type ActualDstType;
+  ActualDstType actualDst(dst);
+
+  // TODO check whether this is the right place to perform these checks:
+  EIGEN_STATIC_ASSERT_LVALUE(Dst)
+  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(ActualDstTypeCleaned,Src)
+  EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename ActualDstTypeCleaned::Scalar,typename Src::Scalar);
+
+  Assignment<ActualDstTypeCleaned,Src,Func>::run(actualDst, src, func);
+}
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_restricted_packet_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
+{
+    typedef evaluator<Dst> DstEvaluatorType;
+    typedef evaluator<Src> SrcEvaluatorType;
+    typedef restricted_packet_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Func> Kernel;
+
+    EIGEN_STATIC_ASSERT_LVALUE(Dst)
+    EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename Dst::Scalar,typename Src::Scalar);
+
+    SrcEvaluatorType srcEvaluator(src);
+    resize_if_allowed(dst, src, func);
+
+    DstEvaluatorType dstEvaluator(dst);
+    Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+
+    dense_assignment_loop<Kernel>::run(kernel);
+}
+
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias(Dst& dst, const Src& src)
+{
+  call_assignment_no_alias(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, const Func& func)
+{
+  // TODO check whether this is the right place to perform these checks:
+  EIGEN_STATIC_ASSERT_LVALUE(Dst)
+  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src)
+  EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename Dst::Scalar,typename Src::Scalar);
+
+  Assignment<Dst,Src,Func>::run(dst, src, func);
+}
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
+{
+  call_assignment_no_alias_no_transpose(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+
+// forward declaration
+template<typename Dst, typename Src> void check_for_aliasing(const Dst &dst, const Src &src);
+
+// Generic Dense to Dense assignment
+// Note that the last template argument "Weak" is needed to make it possible to perform
+// both partial specialization+SFINAE without ambiguous specialization
+template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
+struct Assignment<DstXprType, SrcXprType, Functor, Dense2Dense, Weak>
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+#ifndef EIGEN_NO_DEBUG
+    internal::check_for_aliasing(dst, src);
+#endif
+
+    call_dense_assignment_loop(dst, src, func);
+  }
+};
+
+// Generic assignment through evalTo.
+// TODO: not sure we have to keep that one, but it helps porting current code to new evaluator mechanism.
+// Note that the last template argument "Weak" is needed to make it possible to perform
+// both partial specialization+SFINAE without ambiguous specialization
+template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
+struct Assignment<DstXprType, SrcXprType, Functor, EigenBase2EigenBase, Weak>
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    src.evalTo(dst);
+  }
+
+  // NOTE The following two functions are templated to avoid their instantiation if not needed
+  //      This is needed because some expressions supports evalTo only and/or have 'void' as scalar type.
+  template<typename SrcScalarType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,SrcScalarType> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    src.addTo(dst);
+  }
+
+  template<typename SrcScalarType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,SrcScalarType> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    src.subTo(dst);
+  }
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_ASSIGN_EVALUATOR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Assign_MKL.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Assign_MKL.h
new file mode 100644
index 00000000..c6140d18
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Assign_MKL.h
@@ -0,0 +1,178 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+ Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+ 
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to Intel(R) MKL
+ *   MKL VML support for coefficient-wise unary Eigen expressions like a=b.sin()
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_ASSIGN_VML_H
+#define EIGEN_ASSIGN_VML_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Dst, typename Src>
+class vml_assign_traits
+{
+  private:
+    enum {
+      DstHasDirectAccess = Dst::Flags & DirectAccessBit,
+      SrcHasDirectAccess = Src::Flags & DirectAccessBit,
+      StorageOrdersAgree = (int(Dst::IsRowMajor) == int(Src::IsRowMajor)),
+      InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
+                : int(Dst::Flags)&RowMajorBit ? int(Dst::ColsAtCompileTime)
+                : int(Dst::RowsAtCompileTime),
+      InnerMaxSize  = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
+                    : int(Dst::Flags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime)
+                    : int(Dst::MaxRowsAtCompileTime),
+      MaxSizeAtCompileTime = Dst::SizeAtCompileTime,
+
+      MightEnableVml = StorageOrdersAgree && DstHasDirectAccess && SrcHasDirectAccess && Src::InnerStrideAtCompileTime==1 && Dst::InnerStrideAtCompileTime==1,
+      MightLinearize = MightEnableVml && (int(Dst::Flags) & int(Src::Flags) & LinearAccessBit),
+      VmlSize = MightLinearize ? MaxSizeAtCompileTime : InnerMaxSize,
+      LargeEnough = VmlSize==Dynamic || VmlSize>=EIGEN_MKL_VML_THRESHOLD
+    };
+  public:
+    enum {
+      EnableVml = MightEnableVml && LargeEnough,
+      Traversal = MightLinearize ? LinearTraversal : DefaultTraversal
+    };
+};
+
+#define EIGEN_PP_EXPAND(ARG) ARG
+#if !defined (EIGEN_FAST_MATH) || (EIGEN_FAST_MATH != 1)
+#define EIGEN_VMLMODE_EXPAND_xLA , VML_HA
+#else
+#define EIGEN_VMLMODE_EXPAND_xLA , VML_LA
+#endif
+
+#define EIGEN_VMLMODE_EXPAND_x_
+
+#define EIGEN_VMLMODE_PREFIX_xLA vm
+#define EIGEN_VMLMODE_PREFIX_x_  v
+#define EIGEN_VMLMODE_PREFIX(VMLMODE) EIGEN_CAT(EIGEN_VMLMODE_PREFIX_x,VMLMODE)
+
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE)                                           \
+  template< typename DstXprType, typename SrcXprNested>                                                                         \
+  struct Assignment<DstXprType, CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested>, assign_op<EIGENTYPE,EIGENTYPE>,   \
+                   Dense2Dense, typename enable_if<vml_assign_traits<DstXprType,SrcXprNested>::EnableVml>::type> {              \
+    typedef CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested> SrcXprType;                                            \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<EIGENTYPE,EIGENTYPE> &func) {                       \
+      resize_if_allowed(dst, src, func);                                                                                        \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                                       \
+      if(vml_assign_traits<DstXprType,SrcXprNested>::Traversal==LinearTraversal) {                                              \
+        VMLOP(dst.size(), (const VMLTYPE*)src.nestedExpression().data(),                                                        \
+              (VMLTYPE*)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE) );                                           \
+      } else {                                                                                                                  \
+        const Index outerSize = dst.outerSize();                                                                                \
+        for(Index outer = 0; outer < outerSize; ++outer) {                                                                      \
+          const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.nestedExpression().coeffRef(outer,0)) :                             \
+                                                      &(src.nestedExpression().coeffRef(0, outer));                             \
+          EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer,0)) : &(dst.coeffRef(0, outer));                           \
+          VMLOP( dst.innerSize(), (const VMLTYPE*)src_ptr,                                                                      \
+                (VMLTYPE*)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE));                                             \
+        }                                                                                                                       \
+      }                                                                                                                         \
+    }                                                                                                                           \
+  };                                                                                                                            \
+
+
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE)                                                         \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),s##VMLOP), float, float, VMLMODE)           \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),d##VMLOP), double, double, VMLMODE)
+
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(EIGENOP, VMLOP, VMLMODE)                                                         \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),c##VMLOP), scomplex, MKL_Complex8, VMLMODE) \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),z##VMLOP), dcomplex, MKL_Complex16, VMLMODE)
+  
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS(EIGENOP, VMLOP, VMLMODE)                                                              \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE)                                                               \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(EIGENOP, VMLOP, VMLMODE)
+
+  
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sin,   Sin,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(asin,  Asin,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sinh,  Sinh,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(cos,   Cos,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(acos,  Acos,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(cosh,  Cosh,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(tan,   Tan,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(atan,  Atan,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(tanh,  Tanh,  LA)
+// EIGEN_MKL_VML_DECLARE_UNARY_CALLS(abs,   Abs,    _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(exp,   Exp,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(log,   Ln,    LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(log10, Log10, LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sqrt,  Sqrt,  _)
+
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(square, Sqr,   _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(arg, Arg,      _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(round, Round,  _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(floor, Floor,  _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(ceil,  Ceil,   _)
+
+#define EIGEN_MKL_VML_DECLARE_POW_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE)                                           \
+  template< typename DstXprType, typename SrcXprNested, typename Plain>                                                       \
+  struct Assignment<DstXprType, CwiseBinaryOp<scalar_##EIGENOP##_op<EIGENTYPE,EIGENTYPE>, SrcXprNested,                       \
+                    const CwiseNullaryOp<internal::scalar_constant_op<EIGENTYPE>,Plain> >, assign_op<EIGENTYPE,EIGENTYPE>,    \
+                   Dense2Dense, typename enable_if<vml_assign_traits<DstXprType,SrcXprNested>::EnableVml>::type> {            \
+    typedef CwiseBinaryOp<scalar_##EIGENOP##_op<EIGENTYPE,EIGENTYPE>, SrcXprNested,                                           \
+                    const CwiseNullaryOp<internal::scalar_constant_op<EIGENTYPE>,Plain> > SrcXprType;                         \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<EIGENTYPE,EIGENTYPE> &func) {                     \
+      resize_if_allowed(dst, src, func);                                                                                      \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                                     \
+      VMLTYPE exponent = reinterpret_cast<const VMLTYPE&>(src.rhs().functor().m_other);                                       \
+      if(vml_assign_traits<DstXprType,SrcXprNested>::Traversal==LinearTraversal)                                              \
+      {                                                                                                                       \
+        VMLOP( dst.size(), (const VMLTYPE*)src.lhs().data(), exponent,                                                        \
+              (VMLTYPE*)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE) );                                         \
+      } else {                                                                                                                \
+        const Index outerSize = dst.outerSize();                                                                              \
+        for(Index outer = 0; outer < outerSize; ++outer) {                                                                    \
+          const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.lhs().coeffRef(outer,0)) :                                        \
+                                                      &(src.lhs().coeffRef(0, outer));                                        \
+          EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer,0)) : &(dst.coeffRef(0, outer));                         \
+          VMLOP( dst.innerSize(), (const VMLTYPE*)src_ptr, exponent,                                                          \
+                 (VMLTYPE*)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE));                                          \
+        }                                                                                                                     \
+      }                                                                                                                       \
+    }                                                                                                                         \
+  };
+  
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmsPowx, float,    float,         LA)
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmdPowx, double,   double,        LA)
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmcPowx, scomplex, MKL_Complex8,  LA)
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmzPowx, dcomplex, MKL_Complex16, LA)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_ASSIGN_VML_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/BandMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/Core/BandMatrix.h
new file mode 100644
index 00000000..878c0240
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/BandMatrix.h
@@ -0,0 +1,353 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BANDMATRIX_H
+#define EIGEN_BANDMATRIX_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Derived>
+class BandMatrixBase : public EigenBase<Derived>
+{
+  public:
+
+    enum {
+      Flags = internal::traits<Derived>::Flags,
+      CoeffReadCost = internal::traits<Derived>::CoeffReadCost,
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+      Supers = internal::traits<Derived>::Supers,
+      Subs   = internal::traits<Derived>::Subs,
+      Options = internal::traits<Derived>::Options
+    };
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> DenseMatrixType;
+    typedef typename DenseMatrixType::StorageIndex StorageIndex;
+    typedef typename internal::traits<Derived>::CoefficientsType CoefficientsType;
+    typedef EigenBase<Derived> Base;
+
+  protected:
+    enum {
+      DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic))
+                            ? 1 + Supers + Subs
+                            : Dynamic,
+      SizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime)
+    };
+
+  public:
+
+    using Base::derived;
+    using Base::rows;
+    using Base::cols;
+
+    /** \returns the number of super diagonals */
+    inline Index supers() const { return derived().supers(); }
+
+    /** \returns the number of sub diagonals */
+    inline Index subs() const { return derived().subs(); }
+
+    /** \returns an expression of the underlying coefficient matrix */
+    inline const CoefficientsType& coeffs() const { return derived().coeffs(); }
+
+    /** \returns an expression of the underlying coefficient matrix */
+    inline CoefficientsType& coeffs() { return derived().coeffs(); }
+
+    /** \returns a vector expression of the \a i -th column,
+      * only the meaningful part is returned.
+      * \warning the internal storage must be column major. */
+    inline Block<CoefficientsType,Dynamic,1> col(Index i)
+    {
+      EIGEN_STATIC_ASSERT((int(Options) & int(RowMajor)) == 0, THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+      Index start = 0;
+      Index len = coeffs().rows();
+      if (i<=supers())
+      {
+        start = supers()-i;
+        len = (std::min)(rows(),std::max<Index>(0,coeffs().rows() - (supers()-i)));
+      }
+      else if (i>=rows()-subs())
+        len = std::max<Index>(0,coeffs().rows() - (i + 1 - rows() + subs()));
+      return Block<CoefficientsType,Dynamic,1>(coeffs(), start, i, len, 1);
+    }
+
+    /** \returns a vector expression of the main diagonal */
+    inline Block<CoefficientsType,1,SizeAtCompileTime> diagonal()
+    { return Block<CoefficientsType,1,SizeAtCompileTime>(coeffs(),supers(),0,1,(std::min)(rows(),cols())); }
+
+    /** \returns a vector expression of the main diagonal (const version) */
+    inline const Block<const CoefficientsType,1,SizeAtCompileTime> diagonal() const
+    { return Block<const CoefficientsType,1,SizeAtCompileTime>(coeffs(),supers(),0,1,(std::min)(rows(),cols())); }
+
+    template<int Index> struct DiagonalIntReturnType {
+      enum {
+        ReturnOpposite = (int(Options) & int(SelfAdjoint)) && (((Index) > 0 && Supers == 0) || ((Index) < 0 && Subs == 0)),
+        Conjugate = ReturnOpposite && NumTraits<Scalar>::IsComplex,
+        ActualIndex = ReturnOpposite ? -Index : Index,
+        DiagonalSize = (RowsAtCompileTime==Dynamic || ColsAtCompileTime==Dynamic)
+                     ? Dynamic
+                     : (ActualIndex<0
+                     ? EIGEN_SIZE_MIN_PREFER_DYNAMIC(ColsAtCompileTime, RowsAtCompileTime + ActualIndex)
+                     : EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime - ActualIndex))
+      };
+      typedef Block<CoefficientsType,1, DiagonalSize> BuildType;
+      typedef typename internal::conditional<Conjugate,
+                 CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>,BuildType >,
+                 BuildType>::type Type;
+    };
+
+    /** \returns a vector expression of the \a N -th sub or super diagonal */
+    template<int N> inline typename DiagonalIntReturnType<N>::Type diagonal()
+    {
+      return typename DiagonalIntReturnType<N>::BuildType(coeffs(), supers()-N, (std::max)(0,N), 1, diagonalLength(N));
+    }
+
+    /** \returns a vector expression of the \a N -th sub or super diagonal */
+    template<int N> inline const typename DiagonalIntReturnType<N>::Type diagonal() const
+    {
+      return typename DiagonalIntReturnType<N>::BuildType(coeffs(), supers()-N, (std::max)(0,N), 1, diagonalLength(N));
+    }
+
+    /** \returns a vector expression of the \a i -th sub or super diagonal */
+    inline Block<CoefficientsType,1,Dynamic> diagonal(Index i)
+    {
+      eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers()));
+      return Block<CoefficientsType,1,Dynamic>(coeffs(), supers()-i, std::max<Index>(0,i), 1, diagonalLength(i));
+    }
+
+    /** \returns a vector expression of the \a i -th sub or super diagonal */
+    inline const Block<const CoefficientsType,1,Dynamic> diagonal(Index i) const
+    {
+      eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers()));
+      return Block<const CoefficientsType,1,Dynamic>(coeffs(), supers()-i, std::max<Index>(0,i), 1, diagonalLength(i));
+    }
+
+    template<typename Dest> inline void evalTo(Dest& dst) const
+    {
+      dst.resize(rows(),cols());
+      dst.setZero();
+      dst.diagonal() = diagonal();
+      for (Index i=1; i<=supers();++i)
+        dst.diagonal(i) = diagonal(i);
+      for (Index i=1; i<=subs();++i)
+        dst.diagonal(-i) = diagonal(-i);
+    }
+
+    DenseMatrixType toDenseMatrix() const
+    {
+      DenseMatrixType res(rows(),cols());
+      evalTo(res);
+      return res;
+    }
+
+  protected:
+
+    inline Index diagonalLength(Index i) const
+    { return i<0 ? (std::min)(cols(),rows()+i) : (std::min)(rows(),cols()-i); }
+};
+
+/**
+  * \class BandMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Represents a rectangular matrix with a banded storage
+  *
+  * \tparam _Scalar Numeric type, i.e. float, double, int
+  * \tparam _Rows Number of rows, or \b Dynamic
+  * \tparam _Cols Number of columns, or \b Dynamic
+  * \tparam _Supers Number of super diagonal
+  * \tparam _Subs Number of sub diagonal
+  * \tparam _Options A combination of either \b #RowMajor or \b #ColMajor, and of \b #SelfAdjoint
+  *                  The former controls \ref TopicStorageOrders "storage order", and defaults to
+  *                  column-major. The latter controls whether the matrix represents a selfadjoint
+  *                  matrix in which case either Supers of Subs have to be null.
+  *
+  * \sa class TridiagonalMatrix
+  */
+
+template<typename _Scalar, int _Rows, int _Cols, int _Supers, int _Subs, int _Options>
+struct traits<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef _Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef Eigen::Index StorageIndex;
+  enum {
+    CoeffReadCost = NumTraits<Scalar>::ReadCost,
+    RowsAtCompileTime = _Rows,
+    ColsAtCompileTime = _Cols,
+    MaxRowsAtCompileTime = _Rows,
+    MaxColsAtCompileTime = _Cols,
+    Flags = LvalueBit,
+    Supers = _Supers,
+    Subs = _Subs,
+    Options = _Options,
+    DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic
+  };
+  typedef Matrix<Scalar, DataRowsAtCompileTime, ColsAtCompileTime, int(Options) & int(RowMajor) ? RowMajor : ColMajor> CoefficientsType;
+};
+
+template<typename _Scalar, int Rows, int Cols, int Supers, int Subs, int Options>
+class BandMatrix : public BandMatrixBase<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Options> >
+{
+  public:
+
+    typedef typename internal::traits<BandMatrix>::Scalar Scalar;
+    typedef typename internal::traits<BandMatrix>::StorageIndex StorageIndex;
+    typedef typename internal::traits<BandMatrix>::CoefficientsType CoefficientsType;
+
+    explicit inline BandMatrix(Index rows=Rows, Index cols=Cols, Index supers=Supers, Index subs=Subs)
+      : m_coeffs(1+supers+subs,cols),
+        m_rows(rows), m_supers(supers), m_subs(subs)
+    {
+    }
+
+    /** \returns the number of columns */
+    inline EIGEN_CONSTEXPR Index rows() const { return m_rows.value(); }
+
+    /** \returns the number of rows */
+    inline EIGEN_CONSTEXPR Index cols() const { return m_coeffs.cols(); }
+
+    /** \returns the number of super diagonals */
+    inline EIGEN_CONSTEXPR Index supers() const { return m_supers.value(); }
+
+    /** \returns the number of sub diagonals */
+    inline EIGEN_CONSTEXPR Index subs() const { return m_subs.value(); }
+
+    inline const CoefficientsType& coeffs() const { return m_coeffs; }
+    inline CoefficientsType& coeffs() { return m_coeffs; }
+
+  protected:
+
+    CoefficientsType m_coeffs;
+    internal::variable_if_dynamic<Index, Rows>   m_rows;
+    internal::variable_if_dynamic<Index, Supers> m_supers;
+    internal::variable_if_dynamic<Index, Subs>   m_subs;
+};
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+class BandMatrixWrapper;
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+struct traits<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef typename _CoefficientsType::Scalar Scalar;
+  typedef typename _CoefficientsType::StorageKind StorageKind;
+  typedef typename _CoefficientsType::StorageIndex StorageIndex;
+  enum {
+    CoeffReadCost = internal::traits<_CoefficientsType>::CoeffReadCost,
+    RowsAtCompileTime = _Rows,
+    ColsAtCompileTime = _Cols,
+    MaxRowsAtCompileTime = _Rows,
+    MaxColsAtCompileTime = _Cols,
+    Flags = LvalueBit,
+    Supers = _Supers,
+    Subs = _Subs,
+    Options = _Options,
+    DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic
+  };
+  typedef _CoefficientsType CoefficientsType;
+};
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+class BandMatrixWrapper : public BandMatrixBase<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  public:
+
+    typedef typename internal::traits<BandMatrixWrapper>::Scalar Scalar;
+    typedef typename internal::traits<BandMatrixWrapper>::CoefficientsType CoefficientsType;
+    typedef typename internal::traits<BandMatrixWrapper>::StorageIndex StorageIndex;
+
+    explicit inline BandMatrixWrapper(const CoefficientsType& coeffs, Index rows=_Rows, Index cols=_Cols, Index supers=_Supers, Index subs=_Subs)
+      : m_coeffs(coeffs),
+        m_rows(rows), m_supers(supers), m_subs(subs)
+    {
+      EIGEN_UNUSED_VARIABLE(cols);
+      //internal::assert(coeffs.cols()==cols() && (supers()+subs()+1)==coeffs.rows());
+    }
+
+    /** \returns the number of columns */
+    inline EIGEN_CONSTEXPR Index rows() const { return m_rows.value(); }
+
+    /** \returns the number of rows */
+    inline EIGEN_CONSTEXPR Index cols() const { return m_coeffs.cols(); }
+
+    /** \returns the number of super diagonals */
+    inline EIGEN_CONSTEXPR Index supers() const { return m_supers.value(); }
+
+    /** \returns the number of sub diagonals */
+    inline EIGEN_CONSTEXPR Index subs() const { return m_subs.value(); }
+
+    inline const CoefficientsType& coeffs() const { return m_coeffs; }
+
+  protected:
+
+    const CoefficientsType& m_coeffs;
+    internal::variable_if_dynamic<Index, _Rows>   m_rows;
+    internal::variable_if_dynamic<Index, _Supers> m_supers;
+    internal::variable_if_dynamic<Index, _Subs>   m_subs;
+};
+
+/**
+  * \class TridiagonalMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Represents a tridiagonal matrix with a compact banded storage
+  *
+  * \tparam Scalar Numeric type, i.e. float, double, int
+  * \tparam Size Number of rows and cols, or \b Dynamic
+  * \tparam Options Can be 0 or \b SelfAdjoint
+  *
+  * \sa class BandMatrix
+  */
+template<typename Scalar, int Size, int Options>
+class TridiagonalMatrix : public BandMatrix<Scalar,Size,Size,Options&SelfAdjoint?0:1,1,Options|RowMajor>
+{
+    typedef BandMatrix<Scalar,Size,Size,Options&SelfAdjoint?0:1,1,Options|RowMajor> Base;
+    typedef typename Base::StorageIndex StorageIndex;
+  public:
+    explicit TridiagonalMatrix(Index size = Size) : Base(size,size,Options&SelfAdjoint?0:1,1) {}
+
+    inline typename Base::template DiagonalIntReturnType<1>::Type super()
+    { return Base::template diagonal<1>(); }
+    inline const typename Base::template DiagonalIntReturnType<1>::Type super() const
+    { return Base::template diagonal<1>(); }
+    inline typename Base::template DiagonalIntReturnType<-1>::Type sub()
+    { return Base::template diagonal<-1>(); }
+    inline const typename Base::template DiagonalIntReturnType<-1>::Type sub() const
+    { return Base::template diagonal<-1>(); }
+  protected:
+};
+
+
+struct BandShape {};
+
+template<typename _Scalar, int _Rows, int _Cols, int _Supers, int _Subs, int _Options>
+struct evaluator_traits<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
+  : public evaluator_traits_base<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef BandShape Shape;
+};
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+struct evaluator_traits<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+  : public evaluator_traits_base<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef BandShape Shape;
+};
+
+template<> struct AssignmentKind<DenseShape,BandShape> { typedef EigenBase2EigenBase Kind; };
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BANDMATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Block.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Block.h
new file mode 100644
index 00000000..3206d663
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Block.h
@@ -0,0 +1,448 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BLOCK_H
+#define EIGEN_BLOCK_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+struct traits<Block<XprType, BlockRows, BlockCols, InnerPanel> > : traits<XprType>
+{
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename traits<XprType>::StorageKind StorageKind;
+  typedef typename traits<XprType>::XprKind XprKind;
+  typedef typename ref_selector<XprType>::type XprTypeNested;
+  typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
+  enum{
+    MatrixRows = traits<XprType>::RowsAtCompileTime,
+    MatrixCols = traits<XprType>::ColsAtCompileTime,
+    RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows,
+    ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols,
+    MaxRowsAtCompileTime = BlockRows==0 ? 0
+                         : RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime)
+                         : int(traits<XprType>::MaxRowsAtCompileTime),
+    MaxColsAtCompileTime = BlockCols==0 ? 0
+                         : ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime)
+                         : int(traits<XprType>::MaxColsAtCompileTime),
+
+    XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0,
+    IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
+               : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
+               : XprTypeIsRowMajor,
+    HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
+    InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+    InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
+                             ? int(inner_stride_at_compile_time<XprType>::ret)
+                             : int(outer_stride_at_compile_time<XprType>::ret),
+    OuterStrideAtCompileTime = HasSameStorageOrderAsXprType
+                             ? int(outer_stride_at_compile_time<XprType>::ret)
+                             : int(inner_stride_at_compile_time<XprType>::ret),
+
+    // FIXME, this traits is rather specialized for dense object and it needs to be cleaned further
+    FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
+    FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
+    Flags = (traits<XprType>::Flags & (DirectAccessBit | (InnerPanel?CompressedAccessBit:0))) | FlagsLvalueBit | FlagsRowMajorBit,
+    // FIXME DirectAccessBit should not be handled by expressions
+    //
+    // Alignment is needed by MapBase's assertions
+    // We can sefely set it to false here. Internal alignment errors will be detected by an eigen_internal_assert in the respective evaluator
+    Alignment = 0
+  };
+};
+
+template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false,
+         bool HasDirectAccess = internal::has_direct_access<XprType>::ret> class BlockImpl_dense;
+
+} // end namespace internal
+
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, typename StorageKind> class BlockImpl;
+
+/** \class Block
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a fixed-size or dynamic-size block
+  *
+  * \tparam XprType the type of the expression in which we are taking a block
+  * \tparam BlockRows the number of rows of the block we are taking at compile time (optional)
+  * \tparam BlockCols the number of columns of the block we are taking at compile time (optional)
+  * \tparam InnerPanel is true, if the block maps to a set of rows of a row major matrix or
+  *         to set of columns of a column major matrix (optional). The parameter allows to determine
+  *         at compile time whether aligned access is possible on the block expression.
+  *
+  * This class represents an expression of either a fixed-size or dynamic-size block. It is the return
+  * type of DenseBase::block(Index,Index,Index,Index) and DenseBase::block<int,int>(Index,Index) and
+  * most of the time this is the only way it is used.
+  *
+  * However, if you want to directly maniputate block expressions,
+  * for instance if you want to write a function returning such an expression, you
+  * will need to use this class.
+  *
+  * Here is an example illustrating the dynamic case:
+  * \include class_Block.cpp
+  * Output: \verbinclude class_Block.out
+  *
+  * \note Even though this expression has dynamic size, in the case where \a XprType
+  * has fixed size, this expression inherits a fixed maximal size which means that evaluating
+  * it does not cause a dynamic memory allocation.
+  *
+  * Here is an example illustrating the fixed-size case:
+  * \include class_FixedBlock.cpp
+  * Output: \verbinclude class_FixedBlock.out
+  *
+  * \sa DenseBase::block(Index,Index,Index,Index), DenseBase::block(Index,Index), class VectorBlock
+  */
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> class Block
+  : public BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind>
+{
+    typedef BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind> Impl;
+  public:
+    //typedef typename Impl::Base Base;
+    typedef Impl Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
+
+    typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+    /** Column or Row constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Block(XprType& xpr, Index i) : Impl(xpr,i)
+    {
+      eigen_assert( (i>=0) && (
+          ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i<xpr.rows())
+        ||((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && i<xpr.cols())));
+    }
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Block(XprType& xpr, Index startRow, Index startCol)
+      : Impl(xpr, startRow, startCol)
+    {
+      EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
+      eigen_assert(startRow >= 0 && BlockRows >= 0 && startRow + BlockRows <= xpr.rows()
+             && startCol >= 0 && BlockCols >= 0 && startCol + BlockCols <= xpr.cols());
+    }
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Block(XprType& xpr,
+          Index startRow, Index startCol,
+          Index blockRows, Index blockCols)
+      : Impl(xpr, startRow, startCol, blockRows, blockCols)
+    {
+      eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
+          && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
+      eigen_assert(startRow >= 0 && blockRows >= 0 && startRow  <= xpr.rows() - blockRows
+          && startCol >= 0 && blockCols >= 0 && startCol <= xpr.cols() - blockCols);
+    }
+};
+
+// The generic default implementation for dense block simplu forward to the internal::BlockImpl_dense
+// that must be specialized for direct and non-direct access...
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Dense>
+  : public internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel>
+{
+    typedef internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel> Impl;
+    typedef typename XprType::StorageIndex StorageIndex;
+  public:
+    typedef Impl Base;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl)
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol) : Impl(xpr, startRow, startCol) {}
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : Impl(xpr, startRow, startCol, blockRows, blockCols) {}
+};
+
+namespace internal {
+
+/** \internal Internal implementation of dense Blocks in the general case. */
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess> class BlockImpl_dense
+  : public internal::dense_xpr_base<Block<XprType, BlockRows, BlockCols, InnerPanel> >::type
+{
+    typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
+    typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+  public:
+
+    typedef typename internal::dense_xpr_base<BlockType>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
+
+    // class InnerIterator; // FIXME apparently never used
+
+    /** Column or Row constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr, Index i)
+      : m_xpr(xpr),
+        // It is a row if and only if BlockRows==1 and BlockCols==XprType::ColsAtCompileTime,
+        // and it is a column if and only if BlockRows==XprType::RowsAtCompileTime and BlockCols==1,
+        // all other cases are invalid.
+        // The case a 1x1 matrix seems ambiguous, but the result is the same anyway.
+        m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
+        m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
+        m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
+        m_blockCols(BlockCols==1 ? 1 : xpr.cols())
+    {}
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
+      : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
+                    m_blockRows(BlockRows), m_blockCols(BlockCols)
+    {}
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr,
+          Index startRow, Index startCol,
+          Index blockRows, Index blockCols)
+      : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
+                    m_blockRows(blockRows), m_blockCols(blockCols)
+    {}
+
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_blockRows.value(); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_blockCols.value(); }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index rowId, Index colId)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(XprType)
+      return m_xpr.coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return m_xpr.derived().coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
+    {
+      return m_xpr.coeff(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index index)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(XprType)
+      return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                            m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                            m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const CoeffReturnType coeff(Index index) const
+    {
+      return m_xpr.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                         m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    template<int LoadMode>
+    inline PacketScalar packet(Index rowId, Index colId) const
+    {
+      return m_xpr.template packet<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
+    {
+      m_xpr.template writePacket<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value(), val);
+    }
+
+    template<int LoadMode>
+    inline PacketScalar packet(Index index) const
+    {
+      return m_xpr.template packet<Unaligned>
+              (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+               m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index index, const PacketScalar& val)
+    {
+      m_xpr.template writePacket<Unaligned>
+         (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+          m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0), val);
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \sa MapBase::data() */
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const;
+    EIGEN_DEVICE_FUNC inline Index innerStride() const;
+    EIGEN_DEVICE_FUNC inline Index outerStride() const;
+    #endif
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
+    {
+      return m_xpr;
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    XprType& nestedExpression() { return m_xpr; }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    StorageIndex startRow() const EIGEN_NOEXCEPT
+    {
+      return m_startRow.value();
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    StorageIndex startCol() const EIGEN_NOEXCEPT
+    {
+      return m_startCol.value();
+    }
+
+  protected:
+
+    XprTypeNested m_xpr;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
+    const internal::variable_if_dynamic<StorageIndex, RowsAtCompileTime> m_blockRows;
+    const internal::variable_if_dynamic<StorageIndex, ColsAtCompileTime> m_blockCols;
+};
+
+/** \internal Internal implementation of dense Blocks in the direct access case.*/
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
+  : public MapBase<Block<XprType, BlockRows, BlockCols, InnerPanel> >
+{
+    typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
+    typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+    enum {
+      XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0
+    };
+  public:
+
+    typedef MapBase<BlockType> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
+
+    /** Column or Row constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    BlockImpl_dense(XprType& xpr, Index i)
+      : Base(xpr.data() + i * (    ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && (!XprTypeIsRowMajor))
+                                || ((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && ( XprTypeIsRowMajor)) ? xpr.innerStride() : xpr.outerStride()),
+             BlockRows==1 ? 1 : xpr.rows(),
+             BlockCols==1 ? 1 : xpr.cols()),
+        m_xpr(xpr),
+        m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
+        m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0)
+    {
+      init();
+    }
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
+      : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol)),
+        m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
+    {
+      init();
+    }
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    BlockImpl_dense(XprType& xpr,
+          Index startRow, Index startCol,
+          Index blockRows, Index blockCols)
+      : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol), blockRows, blockCols),
+        m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
+    {
+      init();
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const EIGEN_NOEXCEPT
+    {
+      return m_xpr;
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    XprType& nestedExpression() { return m_xpr; }
+
+    /** \sa MapBase::innerStride() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index innerStride() const EIGEN_NOEXCEPT
+    {
+      return internal::traits<BlockType>::HasSameStorageOrderAsXprType
+             ? m_xpr.innerStride()
+             : m_xpr.outerStride();
+    }
+
+    /** \sa MapBase::outerStride() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index outerStride() const EIGEN_NOEXCEPT
+    {
+      return internal::traits<BlockType>::HasSameStorageOrderAsXprType
+                    ? m_xpr.outerStride()
+                    : m_xpr.innerStride();
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    StorageIndex startRow() const EIGEN_NOEXCEPT { return m_startRow.value(); }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    StorageIndex startCol() const EIGEN_NOEXCEPT { return m_startCol.value(); }
+
+  #ifndef __SUNPRO_CC
+  // FIXME sunstudio is not friendly with the above friend...
+  // META-FIXME there is no 'friend' keyword around here. Is this obsolete?
+  protected:
+  #endif
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal used by allowAligned() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols)
+      : Base(data, blockRows, blockCols), m_xpr(xpr)
+    {
+      init();
+    }
+    #endif
+
+  protected:
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void init()
+    {
+      m_outerStride = internal::traits<BlockType>::HasSameStorageOrderAsXprType
+                    ? m_xpr.outerStride()
+                    : m_xpr.innerStride();
+    }
+
+    XprTypeNested m_xpr;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
+    Index m_outerStride;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BLOCK_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/BooleanRedux.h b/C++/yolo_bytetrack/include/Eigen/src/Core/BooleanRedux.h
new file mode 100644
index 00000000..852de8b9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/BooleanRedux.h
@@ -0,0 +1,162 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ALLANDANY_H
+#define EIGEN_ALLANDANY_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Derived, int UnrollCount, int Rows>
+struct all_unroller
+{
+  enum {
+    col = (UnrollCount-1) / Rows,
+    row = (UnrollCount-1) % Rows
+  };
+
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived &mat)
+  {
+    return all_unroller<Derived, UnrollCount-1, Rows>::run(mat) && mat.coeff(row, col);
+  }
+};
+
+template<typename Derived, int Rows>
+struct all_unroller<Derived, 0, Rows>
+{
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived &/*mat*/) { return true; }
+};
+
+template<typename Derived, int Rows>
+struct all_unroller<Derived, Dynamic, Rows>
+{
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived &) { return false; }
+};
+
+template<typename Derived, int UnrollCount, int Rows>
+struct any_unroller
+{
+  enum {
+    col = (UnrollCount-1) / Rows,
+    row = (UnrollCount-1) % Rows
+  };
+  
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived &mat)
+  {
+    return any_unroller<Derived, UnrollCount-1, Rows>::run(mat) || mat.coeff(row, col);
+  }
+};
+
+template<typename Derived, int Rows>
+struct any_unroller<Derived, 0, Rows>
+{
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived & /*mat*/) { return false; }
+};
+
+template<typename Derived, int Rows>
+struct any_unroller<Derived, Dynamic, Rows>
+{
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived &) { return false; }
+};
+
+} // end namespace internal
+
+/** \returns true if all coefficients are true
+  *
+  * Example: \include MatrixBase_all.cpp
+  * Output: \verbinclude MatrixBase_all.out
+  *
+  * \sa any(), Cwise::operator<()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::all() const
+{
+  typedef internal::evaluator<Derived> Evaluator;
+  enum {
+    unroll = SizeAtCompileTime != Dynamic
+          && SizeAtCompileTime * (int(Evaluator::CoeffReadCost) + int(NumTraits<Scalar>::AddCost)) <= EIGEN_UNROLLING_LIMIT
+  };
+  Evaluator evaluator(derived());
+  if(unroll)
+    return internal::all_unroller<Evaluator, unroll ? int(SizeAtCompileTime) : Dynamic, internal::traits<Derived>::RowsAtCompileTime>::run(evaluator);
+  else
+  {
+    for(Index j = 0; j < cols(); ++j)
+      for(Index i = 0; i < rows(); ++i)
+        if (!evaluator.coeff(i, j)) return false;
+    return true;
+  }
+}
+
+/** \returns true if at least one coefficient is true
+  *
+  * \sa all()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::any() const
+{
+  typedef internal::evaluator<Derived> Evaluator;
+  enum {
+    unroll = SizeAtCompileTime != Dynamic
+          && SizeAtCompileTime * (int(Evaluator::CoeffReadCost) + int(NumTraits<Scalar>::AddCost)) <= EIGEN_UNROLLING_LIMIT
+  };
+  Evaluator evaluator(derived());
+  if(unroll)
+    return internal::any_unroller<Evaluator, unroll ? int(SizeAtCompileTime) : Dynamic, internal::traits<Derived>::RowsAtCompileTime>::run(evaluator);
+  else
+  {
+    for(Index j = 0; j < cols(); ++j)
+      for(Index i = 0; i < rows(); ++i)
+        if (evaluator.coeff(i, j)) return true;
+    return false;
+  }
+}
+
+/** \returns the number of coefficients which evaluate to true
+  *
+  * \sa all(), any()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Eigen::Index DenseBase<Derived>::count() const
+{
+  return derived().template cast<bool>().template cast<Index>().sum();
+}
+
+/** \returns true is \c *this contains at least one Not A Number (NaN).
+  *
+  * \sa allFinite()
+  */
+template<typename Derived>
+inline bool DenseBase<Derived>::hasNaN() const
+{
+#if EIGEN_COMP_MSVC || (defined __FAST_MATH__)
+  return derived().array().isNaN().any();
+#else
+  return !((derived().array()==derived().array()).all());
+#endif
+}
+
+/** \returns true if \c *this contains only finite numbers, i.e., no NaN and no +/-INF values.
+  *
+  * \sa hasNaN()
+  */
+template<typename Derived>
+inline bool DenseBase<Derived>::allFinite() const
+{
+#if EIGEN_COMP_MSVC || (defined __FAST_MATH__)
+  return derived().array().isFinite().all();
+#else
+  return !((derived()-derived()).hasNaN());
+#endif
+}
+    
+} // end namespace Eigen
+
+#endif // EIGEN_ALLANDANY_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/CommaInitializer.h b/C++/yolo_bytetrack/include/Eigen/src/Core/CommaInitializer.h
new file mode 100644
index 00000000..c0e29c75
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/CommaInitializer.h
@@ -0,0 +1,164 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMMAINITIALIZER_H
+#define EIGEN_COMMAINITIALIZER_H
+
+namespace Eigen { 
+
+/** \class CommaInitializer
+  * \ingroup Core_Module
+  *
+  * \brief Helper class used by the comma initializer operator
+  *
+  * This class is internally used to implement the comma initializer feature. It is
+  * the return type of MatrixBase::operator<<, and most of the time this is the only
+  * way it is used.
+  *
+  * \sa \blank \ref MatrixBaseCommaInitRef "MatrixBase::operator<<", CommaInitializer::finished()
+  */
+template<typename XprType>
+struct CommaInitializer
+{
+  typedef typename XprType::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  inline CommaInitializer(XprType& xpr, const Scalar& s)
+    : m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1)
+  {
+    eigen_assert(m_xpr.rows() > 0 && m_xpr.cols() > 0
+      && "Cannot comma-initialize a 0x0 matrix (operator<<)");
+    m_xpr.coeffRef(0,0) = s;
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline CommaInitializer(XprType& xpr, const DenseBase<OtherDerived>& other)
+    : m_xpr(xpr), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows())
+  {
+    eigen_assert(m_xpr.rows() >= other.rows() && m_xpr.cols() >= other.cols()
+      && "Cannot comma-initialize a 0x0 matrix (operator<<)");
+    m_xpr.block(0, 0, other.rows(), other.cols()) = other;
+  }
+
+  /* Copy/Move constructor which transfers ownership. This is crucial in 
+   * absence of return value optimization to avoid assertions during destruction. */
+  // FIXME in C++11 mode this could be replaced by a proper RValue constructor
+  EIGEN_DEVICE_FUNC
+  inline CommaInitializer(const CommaInitializer& o)
+  : m_xpr(o.m_xpr), m_row(o.m_row), m_col(o.m_col), m_currentBlockRows(o.m_currentBlockRows) {
+    // Mark original object as finished. In absence of R-value references we need to const_cast:
+    const_cast<CommaInitializer&>(o).m_row = m_xpr.rows();
+    const_cast<CommaInitializer&>(o).m_col = m_xpr.cols();
+    const_cast<CommaInitializer&>(o).m_currentBlockRows = 0;
+  }
+
+  /* inserts a scalar value in the target matrix */
+  EIGEN_DEVICE_FUNC
+  CommaInitializer& operator,(const Scalar& s)
+  {
+    if (m_col==m_xpr.cols())
+    {
+      m_row+=m_currentBlockRows;
+      m_col = 0;
+      m_currentBlockRows = 1;
+      eigen_assert(m_row<m_xpr.rows()
+        && "Too many rows passed to comma initializer (operator<<)");
+    }
+    eigen_assert(m_col<m_xpr.cols()
+      && "Too many coefficients passed to comma initializer (operator<<)");
+    eigen_assert(m_currentBlockRows==1);
+    m_xpr.coeffRef(m_row, m_col++) = s;
+    return *this;
+  }
+
+  /* inserts a matrix expression in the target matrix */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  CommaInitializer& operator,(const DenseBase<OtherDerived>& other)
+  {
+    if (m_col==m_xpr.cols() && (other.cols()!=0 || other.rows()!=m_currentBlockRows))
+    {
+      m_row+=m_currentBlockRows;
+      m_col = 0;
+      m_currentBlockRows = other.rows();
+      eigen_assert(m_row+m_currentBlockRows<=m_xpr.rows()
+        && "Too many rows passed to comma initializer (operator<<)");
+    }
+    eigen_assert((m_col + other.cols() <= m_xpr.cols())
+      && "Too many coefficients passed to comma initializer (operator<<)");
+    eigen_assert(m_currentBlockRows==other.rows());
+    m_xpr.template block<OtherDerived::RowsAtCompileTime, OtherDerived::ColsAtCompileTime>
+                    (m_row, m_col, other.rows(), other.cols()) = other;
+    m_col += other.cols();
+    return *this;
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline ~CommaInitializer()
+#if defined VERIFY_RAISES_ASSERT && (!defined EIGEN_NO_ASSERTION_CHECKING) && defined EIGEN_EXCEPTIONS
+  EIGEN_EXCEPTION_SPEC(Eigen::eigen_assert_exception)
+#endif
+  {
+    finished();
+  }
+
+  /** \returns the built matrix once all its coefficients have been set.
+    * Calling finished is 100% optional. Its purpose is to write expressions
+    * like this:
+    * \code
+    * quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished());
+    * \endcode
+    */
+  EIGEN_DEVICE_FUNC
+  inline XprType& finished() {
+      eigen_assert(((m_row+m_currentBlockRows) == m_xpr.rows() || m_xpr.cols() == 0)
+           && m_col == m_xpr.cols()
+           && "Too few coefficients passed to comma initializer (operator<<)");
+      return m_xpr;
+  }
+
+  XprType& m_xpr;           // target expression
+  Index m_row;              // current row id
+  Index m_col;              // current col id
+  Index m_currentBlockRows; // current block height
+};
+
+/** \anchor MatrixBaseCommaInitRef
+  * Convenient operator to set the coefficients of a matrix.
+  *
+  * The coefficients must be provided in a row major order and exactly match
+  * the size of the matrix. Otherwise an assertion is raised.
+  *
+  * Example: \include MatrixBase_set.cpp
+  * Output: \verbinclude MatrixBase_set.out
+  * 
+  * \note According the c++ standard, the argument expressions of this comma initializer are evaluated in arbitrary order.
+  *
+  * \sa CommaInitializer::finished(), class CommaInitializer
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline CommaInitializer<Derived> DenseBase<Derived>::operator<< (const Scalar& s)
+{
+  return CommaInitializer<Derived>(*static_cast<Derived*>(this), s);
+}
+
+/** \sa operator<<(const Scalar&) */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline CommaInitializer<Derived>
+DenseBase<Derived>::operator<<(const DenseBase<OtherDerived>& other)
+{
+  return CommaInitializer<Derived>(*static_cast<Derived *>(this), other);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMMAINITIALIZER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/ConditionEstimator.h b/C++/yolo_bytetrack/include/Eigen/src/Core/ConditionEstimator.h
new file mode 100644
index 00000000..51a2e5f1
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/ConditionEstimator.h
@@ -0,0 +1,175 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Rasmus Munk Larsen (rmlarsen@google.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONDITIONESTIMATOR_H
+#define EIGEN_CONDITIONESTIMATOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Vector, typename RealVector, bool IsComplex>
+struct rcond_compute_sign {
+  static inline Vector run(const Vector& v) {
+    const RealVector v_abs = v.cwiseAbs();
+    return (v_abs.array() == static_cast<typename Vector::RealScalar>(0))
+            .select(Vector::Ones(v.size()), v.cwiseQuotient(v_abs));
+  }
+};
+
+// Partial specialization to avoid elementwise division for real vectors.
+template <typename Vector>
+struct rcond_compute_sign<Vector, Vector, false> {
+  static inline Vector run(const Vector& v) {
+    return (v.array() < static_cast<typename Vector::RealScalar>(0))
+           .select(-Vector::Ones(v.size()), Vector::Ones(v.size()));
+  }
+};
+
+/**
+  * \returns an estimate of ||inv(matrix)||_1 given a decomposition of
+  * \a matrix that implements .solve() and .adjoint().solve() methods.
+  *
+  * This function implements Algorithms 4.1 and 5.1 from
+  *   http://www.maths.manchester.ac.uk/~higham/narep/narep135.pdf
+  * which also forms the basis for the condition number estimators in
+  * LAPACK. Since at most 10 calls to the solve method of dec are
+  * performed, the total cost is O(dims^2), as opposed to O(dims^3)
+  * needed to compute the inverse matrix explicitly.
+  *
+  * The most common usage is in estimating the condition number
+  * ||matrix||_1 * ||inv(matrix)||_1. The first term ||matrix||_1 can be
+  * computed directly in O(n^2) operations.
+  *
+  * Supports the following decompositions: FullPivLU, PartialPivLU, LDLT, and
+  * LLT.
+  *
+  * \sa FullPivLU, PartialPivLU, LDLT, LLT.
+  */
+template <typename Decomposition>
+typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomposition& dec)
+{
+  typedef typename Decomposition::MatrixType MatrixType;
+  typedef typename Decomposition::Scalar Scalar;
+  typedef typename Decomposition::RealScalar RealScalar;
+  typedef typename internal::plain_col_type<MatrixType>::type Vector;
+  typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVector;
+  const bool is_complex = (NumTraits<Scalar>::IsComplex != 0);
+
+  eigen_assert(dec.rows() == dec.cols());
+  const Index n = dec.rows();
+  if (n == 0)
+    return 0;
+
+  // Disable Index to float conversion warning
+#ifdef __INTEL_COMPILER
+  #pragma warning push
+  #pragma warning ( disable : 2259 )
+#endif
+  Vector v = dec.solve(Vector::Ones(n) / Scalar(n));
+#ifdef __INTEL_COMPILER
+  #pragma warning pop
+#endif
+
+  // lower_bound is a lower bound on
+  //   ||inv(matrix)||_1  = sup_v ||inv(matrix) v||_1 / ||v||_1
+  // and is the objective maximized by the ("super-") gradient ascent
+  // algorithm below.
+  RealScalar lower_bound = v.template lpNorm<1>();
+  if (n == 1)
+    return lower_bound;
+
+  // Gradient ascent algorithm follows: We know that the optimum is achieved at
+  // one of the simplices v = e_i, so in each iteration we follow a
+  // super-gradient to move towards the optimal one.
+  RealScalar old_lower_bound = lower_bound;
+  Vector sign_vector(n);
+  Vector old_sign_vector;
+  Index v_max_abs_index = -1;
+  Index old_v_max_abs_index = v_max_abs_index;
+  for (int k = 0; k < 4; ++k)
+  {
+    sign_vector = internal::rcond_compute_sign<Vector, RealVector, is_complex>::run(v);
+    if (k > 0 && !is_complex && sign_vector == old_sign_vector) {
+      // Break if the solution stagnated.
+      break;
+    }
+    // v_max_abs_index = argmax |real( inv(matrix)^T * sign_vector )|
+    v = dec.adjoint().solve(sign_vector);
+    v.real().cwiseAbs().maxCoeff(&v_max_abs_index);
+    if (v_max_abs_index == old_v_max_abs_index) {
+      // Break if the solution stagnated.
+      break;
+    }
+    // Move to the new simplex e_j, where j = v_max_abs_index.
+    v = dec.solve(Vector::Unit(n, v_max_abs_index));  // v = inv(matrix) * e_j.
+    lower_bound = v.template lpNorm<1>();
+    if (lower_bound <= old_lower_bound) {
+      // Break if the gradient step did not increase the lower_bound.
+      break;
+    }
+    if (!is_complex) {
+      old_sign_vector = sign_vector;
+    }
+    old_v_max_abs_index = v_max_abs_index;
+    old_lower_bound = lower_bound;
+  }
+  // The following calculates an independent estimate of ||matrix||_1 by
+  // multiplying matrix by a vector with entries of slowly increasing
+  // magnitude and alternating sign:
+  //   v_i = (-1)^{i} (1 + (i / (dim-1))), i = 0,...,dim-1.
+  // This improvement to Hager's algorithm above is due to Higham. It was
+  // added to make the algorithm more robust in certain corner cases where
+  // large elements in the matrix might otherwise escape detection due to
+  // exact cancellation (especially when op and op_adjoint correspond to a
+  // sequence of backsubstitutions and permutations), which could cause
+  // Hager's algorithm to vastly underestimate ||matrix||_1.
+  Scalar alternating_sign(RealScalar(1));
+  for (Index i = 0; i < n; ++i) {
+    // The static_cast is needed when Scalar is a complex and RealScalar implements expression templates
+    v[i] = alternating_sign * static_cast<RealScalar>(RealScalar(1) + (RealScalar(i) / (RealScalar(n - 1))));
+    alternating_sign = -alternating_sign;
+  }
+  v = dec.solve(v);
+  const RealScalar alternate_lower_bound = (2 * v.template lpNorm<1>()) / (3 * RealScalar(n));
+  return numext::maxi(lower_bound, alternate_lower_bound);
+}
+
+/** \brief Reciprocal condition number estimator.
+  *
+  * Computing a decomposition of a dense matrix takes O(n^3) operations, while
+  * this method estimates the condition number quickly and reliably in O(n^2)
+  * operations.
+  *
+  * \returns an estimate of the reciprocal condition number
+  * (1 / (||matrix||_1 * ||inv(matrix)||_1)) of matrix, given ||matrix||_1 and
+  * its decomposition. Supports the following decompositions: FullPivLU,
+  * PartialPivLU, LDLT, and LLT.
+  *
+  * \sa FullPivLU, PartialPivLU, LDLT, LLT.
+  */
+template <typename Decomposition>
+typename Decomposition::RealScalar
+rcond_estimate_helper(typename Decomposition::RealScalar matrix_norm, const Decomposition& dec)
+{
+  typedef typename Decomposition::RealScalar RealScalar;
+  eigen_assert(dec.rows() == dec.cols());
+  if (dec.rows() == 0)              return NumTraits<RealScalar>::infinity();
+  if (matrix_norm == RealScalar(0)) return RealScalar(0);
+  if (dec.rows() == 1)              return RealScalar(1);
+  const RealScalar inverse_matrix_norm = rcond_invmatrix_L1_norm_estimate(dec);
+  return (inverse_matrix_norm == RealScalar(0) ? RealScalar(0)
+                                               : (RealScalar(1) / inverse_matrix_norm) / matrix_norm);
+}
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/CoreEvaluators.h b/C++/yolo_bytetrack/include/Eigen/src/Core/CoreEvaluators.h
new file mode 100644
index 00000000..0ff8c8de
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/CoreEvaluators.h
@@ -0,0 +1,1741 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2011-2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_COREEVALUATORS_H
+#define EIGEN_COREEVALUATORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+// This class returns the evaluator kind from the expression storage kind.
+// Default assumes index based accessors
+template<typename StorageKind>
+struct storage_kind_to_evaluator_kind {
+  typedef IndexBased Kind;
+};
+
+// This class returns the evaluator shape from the expression storage kind.
+// It can be Dense, Sparse, Triangular, Diagonal, SelfAdjoint, Band, etc.
+template<typename StorageKind> struct storage_kind_to_shape;
+
+template<> struct storage_kind_to_shape<Dense>                  { typedef DenseShape Shape;           };
+template<> struct storage_kind_to_shape<SolverStorage>          { typedef SolverShape Shape;           };
+template<> struct storage_kind_to_shape<PermutationStorage>     { typedef PermutationShape Shape;     };
+template<> struct storage_kind_to_shape<TranspositionsStorage>  { typedef TranspositionsShape Shape;  };
+
+// Evaluators have to be specialized with respect to various criteria such as:
+//  - storage/structure/shape
+//  - scalar type
+//  - etc.
+// Therefore, we need specialization of evaluator providing additional template arguments for each kind of evaluators.
+// We currently distinguish the following kind of evaluators:
+// - unary_evaluator    for expressions taking only one arguments (CwiseUnaryOp, CwiseUnaryView, Transpose, MatrixWrapper, ArrayWrapper, Reverse, Replicate)
+// - binary_evaluator   for expression taking two arguments (CwiseBinaryOp)
+// - ternary_evaluator   for expression taking three arguments (CwiseTernaryOp)
+// - product_evaluator  for linear algebra products (Product); special case of binary_evaluator because it requires additional tags for dispatching.
+// - mapbase_evaluator  for Map, Block, Ref
+// - block_evaluator    for Block (special dispatching to a mapbase_evaluator or unary_evaluator)
+
+template< typename T,
+          typename Arg1Kind   = typename evaluator_traits<typename T::Arg1>::Kind,
+          typename Arg2Kind   = typename evaluator_traits<typename T::Arg2>::Kind,
+          typename Arg3Kind   = typename evaluator_traits<typename T::Arg3>::Kind,
+          typename Arg1Scalar = typename traits<typename T::Arg1>::Scalar,
+          typename Arg2Scalar = typename traits<typename T::Arg2>::Scalar,
+          typename Arg3Scalar = typename traits<typename T::Arg3>::Scalar> struct ternary_evaluator;
+
+template< typename T,
+          typename LhsKind   = typename evaluator_traits<typename T::Lhs>::Kind,
+          typename RhsKind   = typename evaluator_traits<typename T::Rhs>::Kind,
+          typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
+          typename RhsScalar = typename traits<typename T::Rhs>::Scalar> struct binary_evaluator;
+
+template< typename T,
+          typename Kind   = typename evaluator_traits<typename T::NestedExpression>::Kind,
+          typename Scalar = typename T::Scalar> struct unary_evaluator;
+
+// evaluator_traits<T> contains traits for evaluator<T>
+
+template<typename T>
+struct evaluator_traits_base
+{
+  // by default, get evaluator kind and shape from storage
+  typedef typename storage_kind_to_evaluator_kind<typename traits<T>::StorageKind>::Kind Kind;
+  typedef typename storage_kind_to_shape<typename traits<T>::StorageKind>::Shape Shape;
+};
+
+// Default evaluator traits
+template<typename T>
+struct evaluator_traits : public evaluator_traits_base<T>
+{
+};
+
+template<typename T, typename Shape = typename evaluator_traits<T>::Shape >
+struct evaluator_assume_aliasing {
+  static const bool value = false;
+};
+
+// By default, we assume a unary expression:
+template<typename T>
+struct evaluator : public unary_evaluator<T>
+{
+  typedef unary_evaluator<T> Base;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const T& xpr) : Base(xpr) {}
+};
+
+
+// TODO: Think about const-correctness
+template<typename T>
+struct evaluator<const T>
+  : evaluator<T>
+{
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const T& xpr) : evaluator<T>(xpr) {}
+};
+
+// ---------- base class for all evaluators ----------
+
+template<typename ExpressionType>
+struct evaluator_base
+{
+  // TODO that's not very nice to have to propagate all these traits. They are currently only needed to handle outer,inner indices.
+  typedef traits<ExpressionType> ExpressionTraits;
+
+  enum {
+    Alignment = 0
+  };
+  // noncopyable:
+  // Don't make this class inherit noncopyable as this kills EBO (Empty Base Optimization)
+  // and make complex evaluator much larger than then should do.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator_base() {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ~evaluator_base() {}
+private:
+  EIGEN_DEVICE_FUNC evaluator_base(const evaluator_base&);
+  EIGEN_DEVICE_FUNC const evaluator_base& operator=(const evaluator_base&);
+};
+
+// -------------------- Matrix and Array --------------------
+//
+// evaluator<PlainObjectBase> is a common base class for the
+// Matrix and Array evaluators.
+// Here we directly specialize evaluator. This is not really a unary expression, and it is, by definition, dense,
+// so no need for more sophisticated dispatching.
+
+// this helper permits to completely eliminate m_outerStride if it is known at compiletime.
+template<typename Scalar,int OuterStride> class plainobjectbase_evaluator_data {
+public:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride) : data(ptr)
+  {
+#ifndef EIGEN_INTERNAL_DEBUGGING
+    EIGEN_UNUSED_VARIABLE(outerStride);
+#endif
+    eigen_internal_assert(outerStride==OuterStride);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+  Index outerStride() const EIGEN_NOEXCEPT { return OuterStride; }
+  const Scalar *data;
+};
+
+template<typename Scalar> class plainobjectbase_evaluator_data<Scalar,Dynamic> {
+public:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride) : data(ptr), m_outerStride(outerStride) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Index outerStride() const { return m_outerStride; }
+  const Scalar *data;
+protected:
+  Index m_outerStride;
+};
+
+template<typename Derived>
+struct evaluator<PlainObjectBase<Derived> >
+  : evaluator_base<Derived>
+{
+  typedef PlainObjectBase<Derived> PlainObjectType;
+  typedef typename PlainObjectType::Scalar Scalar;
+  typedef typename PlainObjectType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    IsRowMajor = PlainObjectType::IsRowMajor,
+    IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime,
+    RowsAtCompileTime = PlainObjectType::RowsAtCompileTime,
+    ColsAtCompileTime = PlainObjectType::ColsAtCompileTime,
+
+    CoeffReadCost = NumTraits<Scalar>::ReadCost,
+    Flags = traits<Derived>::EvaluatorFlags,
+    Alignment = traits<Derived>::Alignment
+  };
+  enum {
+    // We do not need to know the outer stride for vectors
+    OuterStrideAtCompileTime = IsVectorAtCompileTime  ? 0
+                                                      : int(IsRowMajor) ? ColsAtCompileTime
+                                                                        : RowsAtCompileTime
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  evaluator()
+    : m_d(0,OuterStrideAtCompileTime)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const PlainObjectType& m)
+    : m_d(m.data(),IsVectorAtCompileTime ? 0 : m.outerStride())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    if (IsRowMajor)
+      return m_d.data[row * m_d.outerStride() + col];
+    else
+      return m_d.data[row + col * m_d.outerStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.data[index];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    if (IsRowMajor)
+      return const_cast<Scalar*>(m_d.data)[row * m_d.outerStride() + col];
+    else
+      return const_cast<Scalar*>(m_d.data)[row + col * m_d.outerStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return const_cast<Scalar*>(m_d.data)[index];
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    if (IsRowMajor)
+      return ploadt<PacketType, LoadMode>(m_d.data + row * m_d.outerStride() + col);
+    else
+      return ploadt<PacketType, LoadMode>(m_d.data + row + col * m_d.outerStride());
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return ploadt<PacketType, LoadMode>(m_d.data + index);
+  }
+
+  template<int StoreMode,typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    if (IsRowMajor)
+      return pstoret<Scalar, PacketType, StoreMode>
+	            (const_cast<Scalar*>(m_d.data) + row * m_d.outerStride() + col, x);
+    else
+      return pstoret<Scalar, PacketType, StoreMode>
+                    (const_cast<Scalar*>(m_d.data) + row + col * m_d.outerStride(), x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    return pstoret<Scalar, PacketType, StoreMode>(const_cast<Scalar*>(m_d.data) + index, x);
+  }
+
+protected:
+
+  plainobjectbase_evaluator_data<Scalar,OuterStrideAtCompileTime> m_d;
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+struct evaluator<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
+  : evaluator<PlainObjectBase<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > >
+{
+  typedef Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  evaluator() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& m)
+    : evaluator<PlainObjectBase<XprType> >(m)
+  { }
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+struct evaluator<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
+  : evaluator<PlainObjectBase<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > >
+{
+  typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  evaluator() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& m)
+    : evaluator<PlainObjectBase<XprType> >(m)
+  { }
+};
+
+// -------------------- Transpose --------------------
+
+template<typename ArgType>
+struct unary_evaluator<Transpose<ArgType>, IndexBased>
+  : evaluator_base<Transpose<ArgType> >
+{
+  typedef Transpose<ArgType> XprType;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    Flags = evaluator<ArgType>::Flags ^ RowMajorBit,
+    Alignment = evaluator<ArgType>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& t) : m_argImpl(t.nestedExpression()) {}
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(col, row);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(col, row);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  typename XprType::Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(index);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(col, row);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(index);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode,PacketType>(col, row, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode,PacketType>(index, x);
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+};
+
+// -------------------- CwiseNullaryOp --------------------
+// Like Matrix and Array, this is not really a unary expression, so we directly specialize evaluator.
+// Likewise, there is not need to more sophisticated dispatching here.
+
+template<typename Scalar,typename NullaryOp,
+         bool has_nullary = has_nullary_operator<NullaryOp>::value,
+         bool has_unary   = has_unary_operator<NullaryOp>::value,
+         bool has_binary  = has_binary_operator<NullaryOp>::value>
+struct nullary_wrapper
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const { return op(i,j); }
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { return op(i); }
+
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const { return op.template packetOp<T>(i,j); }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { return op.template packetOp<T>(i); }
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,true,false,false>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType=0, IndexType=0) const { return op(); }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType=0, IndexType=0) const { return op.template packetOp<T>(); }
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,false,false,true>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j=0) const { return op(i,j); }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j=0) const { return op.template packetOp<T>(i,j); }
+};
+
+// We need the following specialization for vector-only functors assigned to a runtime vector,
+// for instance, using linspace and assigning a RowVectorXd to a MatrixXd or even a row of a MatrixXd.
+// In this case, i==0 and j is used for the actual iteration.
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,false,true,false>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const {
+    eigen_assert(i==0 || j==0);
+    return op(i+j);
+  }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const {
+    eigen_assert(i==0 || j==0);
+    return op.template packetOp<T>(i+j);
+  }
+
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { return op(i); }
+  template <typename T, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { return op.template packetOp<T>(i); }
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,false,false,false> {};
+
+#if 0 && EIGEN_COMP_MSVC>0
+// Disable this ugly workaround. This is now handled in traits<Ref>::match,
+// but this piece of code might still become handly if some other weird compilation
+// erros pop up again.
+
+// MSVC exhibits a weird compilation error when
+// compiling:
+//    Eigen::MatrixXf A = MatrixXf::Random(3,3);
+//    Ref<const MatrixXf> R = 2.f*A;
+// and that has_*ary_operator<scalar_constant_op<float>> have not been instantiated yet.
+// The "problem" is that evaluator<2.f*A> is instantiated by traits<Ref>::match<2.f*A>
+// and at that time has_*ary_operator<T> returns true regardless of T.
+// Then nullary_wrapper is badly instantiated as nullary_wrapper<.,.,true,true,true>.
+// The trick is thus to defer the proper instantiation of nullary_wrapper when coeff(),
+// and packet() are really instantiated as implemented below:
+
+// This is a simple wrapper around Index to enforce the re-instantiation of
+// has_*ary_operator when needed.
+template<typename T> struct nullary_wrapper_workaround_msvc {
+  nullary_wrapper_workaround_msvc(const T&);
+  operator T()const;
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,true,true,true>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().operator()(op,i,j);
+  }
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().operator()(op,i);
+  }
+
+  template <typename T, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().template packetOp<T>(op,i,j);
+  }
+  template <typename T, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().template packetOp<T>(op,i);
+  }
+};
+#endif // MSVC workaround
+
+template<typename NullaryOp, typename PlainObjectType>
+struct evaluator<CwiseNullaryOp<NullaryOp,PlainObjectType> >
+  : evaluator_base<CwiseNullaryOp<NullaryOp,PlainObjectType> >
+{
+  typedef CwiseNullaryOp<NullaryOp,PlainObjectType> XprType;
+  typedef typename internal::remove_all<PlainObjectType>::type PlainObjectTypeCleaned;
+
+  enum {
+    CoeffReadCost = internal::functor_traits<NullaryOp>::Cost,
+
+    Flags = (evaluator<PlainObjectTypeCleaned>::Flags
+          &  (  HereditaryBits
+              | (functor_has_linear_access<NullaryOp>::ret  ? LinearAccessBit : 0)
+              | (functor_traits<NullaryOp>::PacketAccess    ? PacketAccessBit : 0)))
+          | (functor_traits<NullaryOp>::IsRepeatable ? 0 : EvalBeforeNestingBit),
+    Alignment = AlignedMax
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& n)
+    : m_functor(n.functor()), m_wrapper()
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(IndexType row, IndexType col) const
+  {
+    return m_wrapper(m_functor, row, col);
+  }
+
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(IndexType index) const
+  {
+    return m_wrapper(m_functor,index);
+  }
+
+  template<int LoadMode, typename PacketType, typename IndexType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(IndexType row, IndexType col) const
+  {
+    return m_wrapper.template packetOp<PacketType>(m_functor, row, col);
+  }
+
+  template<int LoadMode, typename PacketType, typename IndexType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(IndexType index) const
+  {
+    return m_wrapper.template packetOp<PacketType>(m_functor, index);
+  }
+
+protected:
+  const NullaryOp m_functor;
+  const internal::nullary_wrapper<CoeffReturnType,NullaryOp> m_wrapper;
+};
+
+// -------------------- CwiseUnaryOp --------------------
+
+template<typename UnaryOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IndexBased >
+  : evaluator_base<CwiseUnaryOp<UnaryOp, ArgType> >
+{
+  typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;
+
+  enum {
+    CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<UnaryOp>::Cost),
+
+    Flags = evaluator<ArgType>::Flags
+          & (HereditaryBits | LinearAccessBit | (functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)),
+    Alignment = evaluator<ArgType>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& op) : m_d(op)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(index));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_d.func().packetOp(m_d.argImpl.template packet<LoadMode, PacketType>(row, col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_d.func().packetOp(m_d.argImpl.template packet<LoadMode, PacketType>(index));
+  }
+
+protected:
+
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : op(xpr.functor()), argImpl(xpr.nestedExpression()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const UnaryOp& func() const { return op; }
+    UnaryOp op;
+    evaluator<ArgType> argImpl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- CwiseTernaryOp --------------------
+
+// this is a ternary expression
+template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+struct evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
+  : public ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
+{
+  typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
+  typedef ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > Base;
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+struct ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>, IndexBased, IndexBased>
+  : evaluator_base<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
+{
+  typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
+
+  enum {
+    CoeffReadCost = int(evaluator<Arg1>::CoeffReadCost) + int(evaluator<Arg2>::CoeffReadCost) + int(evaluator<Arg3>::CoeffReadCost) + int(functor_traits<TernaryOp>::Cost),
+
+    Arg1Flags = evaluator<Arg1>::Flags,
+    Arg2Flags = evaluator<Arg2>::Flags,
+    Arg3Flags = evaluator<Arg3>::Flags,
+    SameType = is_same<typename Arg1::Scalar,typename Arg2::Scalar>::value && is_same<typename Arg1::Scalar,typename Arg3::Scalar>::value,
+    StorageOrdersAgree = (int(Arg1Flags)&RowMajorBit)==(int(Arg2Flags)&RowMajorBit) && (int(Arg1Flags)&RowMajorBit)==(int(Arg3Flags)&RowMajorBit),
+    Flags0 = (int(Arg1Flags) | int(Arg2Flags) | int(Arg3Flags)) & (
+        HereditaryBits
+        | (int(Arg1Flags) & int(Arg2Flags) & int(Arg3Flags) &
+           ( (StorageOrdersAgree ? LinearAccessBit : 0)
+           | (functor_traits<TernaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)
+           )
+        )
+     ),
+    Flags = (Flags0 & ~RowMajorBit) | (Arg1Flags & RowMajorBit),
+    Alignment = EIGEN_PLAIN_ENUM_MIN(
+        EIGEN_PLAIN_ENUM_MIN(evaluator<Arg1>::Alignment, evaluator<Arg2>::Alignment),
+        evaluator<Arg3>::Alignment)
+  };
+
+  EIGEN_DEVICE_FUNC explicit ternary_evaluator(const XprType& xpr) : m_d(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<TernaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.arg1Impl.coeff(row, col), m_d.arg2Impl.coeff(row, col), m_d.arg3Impl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.arg1Impl.coeff(index), m_d.arg2Impl.coeff(index), m_d.arg3Impl.coeff(index));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_d.func().packetOp(m_d.arg1Impl.template packet<LoadMode,PacketType>(row, col),
+                               m_d.arg2Impl.template packet<LoadMode,PacketType>(row, col),
+                               m_d.arg3Impl.template packet<LoadMode,PacketType>(row, col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_d.func().packetOp(m_d.arg1Impl.template packet<LoadMode,PacketType>(index),
+                               m_d.arg2Impl.template packet<LoadMode,PacketType>(index),
+                               m_d.arg3Impl.template packet<LoadMode,PacketType>(index));
+  }
+
+protected:
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : op(xpr.functor()), arg1Impl(xpr.arg1()), arg2Impl(xpr.arg2()), arg3Impl(xpr.arg3()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TernaryOp& func() const { return op; }
+    TernaryOp op;
+    evaluator<Arg1> arg1Impl;
+    evaluator<Arg2> arg2Impl;
+    evaluator<Arg3> arg3Impl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- CwiseBinaryOp --------------------
+
+// this is a binary expression
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+  : public binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > Base;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IndexBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+
+  enum {
+    CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluator<Rhs>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+
+    LhsFlags = evaluator<Lhs>::Flags,
+    RhsFlags = evaluator<Rhs>::Flags,
+    SameType = is_same<typename Lhs::Scalar,typename Rhs::Scalar>::value,
+    StorageOrdersAgree = (int(LhsFlags)&RowMajorBit)==(int(RhsFlags)&RowMajorBit),
+    Flags0 = (int(LhsFlags) | int(RhsFlags)) & (
+        HereditaryBits
+      | (int(LhsFlags) & int(RhsFlags) &
+           ( (StorageOrdersAgree ? LinearAccessBit : 0)
+           | (functor_traits<BinaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)
+           )
+        )
+     ),
+    Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit),
+    Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<Lhs>::Alignment,evaluator<Rhs>::Alignment)
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit binary_evaluator(const XprType& xpr) : m_d(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.lhsImpl.coeff(row, col), m_d.rhsImpl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.lhsImpl.coeff(index), m_d.rhsImpl.coeff(index));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode,PacketType>(row, col),
+                               m_d.rhsImpl.template packet<LoadMode,PacketType>(row, col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode,PacketType>(index),
+                               m_d.rhsImpl.template packet<LoadMode,PacketType>(index));
+  }
+
+protected:
+
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : op(xpr.functor()), lhsImpl(xpr.lhs()), rhsImpl(xpr.rhs()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const BinaryOp& func() const { return op; }
+    BinaryOp op;
+    evaluator<Lhs> lhsImpl;
+    evaluator<Rhs> rhsImpl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- CwiseUnaryView --------------------
+
+template<typename UnaryOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryView<UnaryOp, ArgType>, IndexBased>
+  : evaluator_base<CwiseUnaryView<UnaryOp, ArgType> >
+{
+  typedef CwiseUnaryView<UnaryOp, ArgType> XprType;
+
+  enum {
+    CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<UnaryOp>::Cost),
+
+    Flags = (evaluator<ArgType>::Flags & (HereditaryBits | LinearAccessBit | DirectAccessBit)),
+
+    Alignment = 0 // FIXME it is not very clear why alignment is necessarily lost...
+  };
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op) : m_d(op)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_d.func()(m_d.argImpl.coeffRef(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_d.func()(m_d.argImpl.coeffRef(index));
+  }
+
+protected:
+
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : op(xpr.functor()), argImpl(xpr.nestedExpression()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const UnaryOp& func() const { return op; }
+    UnaryOp op;
+    evaluator<ArgType> argImpl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- Map --------------------
+
+// FIXME perhaps the PlainObjectType could be provided by Derived::PlainObject ?
+// but that might complicate template specialization
+template<typename Derived, typename PlainObjectType>
+struct mapbase_evaluator;
+
+template<typename Derived, typename PlainObjectType>
+struct mapbase_evaluator : evaluator_base<Derived>
+{
+  typedef Derived  XprType;
+  typedef typename XprType::PointerType PointerType;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    IsRowMajor = XprType::RowsAtCompileTime,
+    ColsAtCompileTime = XprType::ColsAtCompileTime,
+    CoeffReadCost = NumTraits<Scalar>::ReadCost
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit mapbase_evaluator(const XprType& map)
+    : m_data(const_cast<PointerType>(map.data())),
+      m_innerStride(map.innerStride()),
+      m_outerStride(map.outerStride())
+  {
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(evaluator<Derived>::Flags&PacketAccessBit, internal::inner_stride_at_compile_time<Derived>::ret==1),
+                        PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_data[col * colStride() + row * rowStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_data[index * m_innerStride.value()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_data[col * colStride() + row * rowStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_data[index * m_innerStride.value()];
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    PointerType ptr = m_data + row * rowStride() + col * colStride();
+    return internal::ploadt<PacketType, LoadMode>(ptr);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return internal::ploadt<PacketType, LoadMode>(m_data + index * m_innerStride.value());
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    PointerType ptr = m_data + row * rowStride() + col * colStride();
+    return internal::pstoret<Scalar, PacketType, StoreMode>(ptr, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    internal::pstoret<Scalar, PacketType, StoreMode>(m_data + index * m_innerStride.value(), x);
+  }
+protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+  Index rowStride() const EIGEN_NOEXCEPT {
+    return XprType::IsRowMajor ? m_outerStride.value() : m_innerStride.value();
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+  Index colStride() const EIGEN_NOEXCEPT {
+     return XprType::IsRowMajor ? m_innerStride.value() : m_outerStride.value();
+  }
+
+  PointerType m_data;
+  const internal::variable_if_dynamic<Index, XprType::InnerStrideAtCompileTime> m_innerStride;
+  const internal::variable_if_dynamic<Index, XprType::OuterStrideAtCompileTime> m_outerStride;
+};
+
+template<typename PlainObjectType, int MapOptions, typename StrideType>
+struct evaluator<Map<PlainObjectType, MapOptions, StrideType> >
+  : public mapbase_evaluator<Map<PlainObjectType, MapOptions, StrideType>, PlainObjectType>
+{
+  typedef Map<PlainObjectType, MapOptions, StrideType> XprType;
+  typedef typename XprType::Scalar Scalar;
+  // TODO: should check for smaller packet types once we can handle multi-sized packet types
+  typedef typename packet_traits<Scalar>::type PacketScalar;
+
+  enum {
+    InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
+                             ? int(PlainObjectType::InnerStrideAtCompileTime)
+                             : int(StrideType::InnerStrideAtCompileTime),
+    OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
+                             ? int(PlainObjectType::OuterStrideAtCompileTime)
+                             : int(StrideType::OuterStrideAtCompileTime),
+    HasNoInnerStride = InnerStrideAtCompileTime == 1,
+    HasNoOuterStride = StrideType::OuterStrideAtCompileTime == 0,
+    HasNoStride = HasNoInnerStride && HasNoOuterStride,
+    IsDynamicSize = PlainObjectType::SizeAtCompileTime==Dynamic,
+
+    PacketAccessMask = bool(HasNoInnerStride) ? ~int(0) : ~int(PacketAccessBit),
+    LinearAccessMask = bool(HasNoStride) || bool(PlainObjectType::IsVectorAtCompileTime) ? ~int(0) : ~int(LinearAccessBit),
+    Flags = int( evaluator<PlainObjectType>::Flags) & (LinearAccessMask&PacketAccessMask),
+
+    Alignment = int(MapOptions)&int(AlignedMask)
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& map)
+    : mapbase_evaluator<XprType, PlainObjectType>(map)
+  { }
+};
+
+// -------------------- Ref --------------------
+
+template<typename PlainObjectType, int RefOptions, typename StrideType>
+struct evaluator<Ref<PlainObjectType, RefOptions, StrideType> >
+  : public mapbase_evaluator<Ref<PlainObjectType, RefOptions, StrideType>, PlainObjectType>
+{
+  typedef Ref<PlainObjectType, RefOptions, StrideType> XprType;
+
+  enum {
+    Flags = evaluator<Map<PlainObjectType, RefOptions, StrideType> >::Flags,
+    Alignment = evaluator<Map<PlainObjectType, RefOptions, StrideType> >::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& ref)
+    : mapbase_evaluator<XprType, PlainObjectType>(ref)
+  { }
+};
+
+// -------------------- Block --------------------
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel,
+         bool HasDirectAccess = internal::has_direct_access<ArgType>::ret> struct block_evaluator;
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
+  : block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel>
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+  typedef typename XprType::Scalar Scalar;
+  // TODO: should check for smaller packet types once we can handle multi-sized packet types
+  typedef typename packet_traits<Scalar>::type PacketScalar;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+
+    RowsAtCompileTime = traits<XprType>::RowsAtCompileTime,
+    ColsAtCompileTime = traits<XprType>::ColsAtCompileTime,
+    MaxRowsAtCompileTime = traits<XprType>::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime,
+
+    ArgTypeIsRowMajor = (int(evaluator<ArgType>::Flags)&RowMajorBit) != 0,
+    IsRowMajor = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? 1
+               : (MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1) ? 0
+               : ArgTypeIsRowMajor,
+    HasSameStorageOrderAsArgType = (IsRowMajor == ArgTypeIsRowMajor),
+    InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+    InnerStrideAtCompileTime = HasSameStorageOrderAsArgType
+                             ? int(inner_stride_at_compile_time<ArgType>::ret)
+                             : int(outer_stride_at_compile_time<ArgType>::ret),
+    OuterStrideAtCompileTime = HasSameStorageOrderAsArgType
+                             ? int(outer_stride_at_compile_time<ArgType>::ret)
+                             : int(inner_stride_at_compile_time<ArgType>::ret),
+    MaskPacketAccessBit = (InnerStrideAtCompileTime == 1 || HasSameStorageOrderAsArgType) ? PacketAccessBit : 0,
+
+    FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1 || (InnerPanel && (evaluator<ArgType>::Flags&LinearAccessBit))) ? LinearAccessBit : 0,
+    FlagsRowMajorBit = XprType::Flags&RowMajorBit,
+    Flags0 = evaluator<ArgType>::Flags & ( (HereditaryBits & ~RowMajorBit) |
+                                           DirectAccessBit |
+                                           MaskPacketAccessBit),
+    Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit,
+
+    PacketAlignment = unpacket_traits<PacketScalar>::alignment,
+    Alignment0 = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic)
+                             && (OuterStrideAtCompileTime!=0)
+                             && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % int(PacketAlignment)) == 0)) ? int(PacketAlignment) : 0,
+    Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ArgType>::Alignment, Alignment0)
+  };
+  typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> block_evaluator_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& block) : block_evaluator_type(block)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+};
+
+// no direct-access => dispatch to a unary evaluator
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /*HasDirectAccess*/ false>
+  : unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit block_evaluator(const XprType& block)
+    : unary_evaluator<XprType>(block)
+  {}
+};
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IndexBased>
+  : evaluator_base<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& block)
+    : m_argImpl(block.nestedExpression()),
+      m_startRow(block.startRow()),
+      m_startCol(block.startCol()),
+      m_linear_offset(ForwardLinearAccess?(ArgType::IsRowMajor ? block.startRow()*block.nestedExpression().cols() + block.startCol() : block.startCol()*block.nestedExpression().rows() + block.startRow()):0)
+  { }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    RowsAtCompileTime = XprType::RowsAtCompileTime,
+    ForwardLinearAccess = (InnerPanel || int(XprType::IsRowMajor)==int(ArgType::IsRowMajor)) && bool(evaluator<ArgType>::Flags&LinearAccessBit)
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(m_startRow.value() + row, m_startCol.value() + col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return linear_coeff_impl(index, bool_constant<ForwardLinearAccess>());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(m_startRow.value() + row, m_startCol.value() + col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return linear_coeffRef_impl(index, bool_constant<ForwardLinearAccess>());
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(m_startRow.value() + row, m_startCol.value() + col);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    if (ForwardLinearAccess)
+      return m_argImpl.template packet<LoadMode,PacketType>(m_linear_offset.value() + index);
+    else
+      return packet<LoadMode,PacketType>(RowsAtCompileTime == 1 ? 0 : index,
+                                         RowsAtCompileTime == 1 ? index : 0);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    return m_argImpl.template writePacket<StoreMode,PacketType>(m_startRow.value() + row, m_startCol.value() + col, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    if (ForwardLinearAccess)
+      return m_argImpl.template writePacket<StoreMode,PacketType>(m_linear_offset.value() + index, x);
+    else
+      return writePacket<StoreMode,PacketType>(RowsAtCompileTime == 1 ? 0 : index,
+                                              RowsAtCompileTime == 1 ? index : 0,
+                                              x);
+  }
+
+protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType linear_coeff_impl(Index index, internal::true_type /* ForwardLinearAccess */) const
+  {
+    return m_argImpl.coeff(m_linear_offset.value() + index);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType linear_coeff_impl(Index index, internal::false_type /* not ForwardLinearAccess */) const
+  {
+    return coeff(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& linear_coeffRef_impl(Index index, internal::true_type /* ForwardLinearAccess */)
+  {
+    return m_argImpl.coeffRef(m_linear_offset.value() + index);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& linear_coeffRef_impl(Index index, internal::false_type /* not ForwardLinearAccess */)
+  {
+    return coeffRef(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
+  }
+
+  evaluator<ArgType> m_argImpl;
+  const variable_if_dynamic<Index, (ArgType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
+  const variable_if_dynamic<Index, (ArgType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
+  const variable_if_dynamic<Index, ForwardLinearAccess ? Dynamic : 0> m_linear_offset;
+};
+
+// TODO: This evaluator does not actually use the child evaluator;
+// all action is via the data() as returned by the Block expression.
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /* HasDirectAccess */ true>
+  : mapbase_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>,
+                      typename Block<ArgType, BlockRows, BlockCols, InnerPanel>::PlainObject>
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+  typedef typename XprType::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit block_evaluator(const XprType& block)
+    : mapbase_evaluator<XprType, typename XprType::PlainObject>(block)
+  {
+    // TODO: for the 3.3 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime
+    eigen_assert(((internal::UIntPtr(block.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned");
+  }
+};
+
+
+// -------------------- Select --------------------
+// NOTE shall we introduce a ternary_evaluator?
+
+// TODO enable vectorization for Select
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
+struct evaluator<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
+  : evaluator_base<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
+{
+  typedef Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> XprType;
+  enum {
+    CoeffReadCost = evaluator<ConditionMatrixType>::CoeffReadCost
+                  + EIGEN_PLAIN_ENUM_MAX(evaluator<ThenMatrixType>::CoeffReadCost,
+                                         evaluator<ElseMatrixType>::CoeffReadCost),
+
+    Flags = (unsigned int)evaluator<ThenMatrixType>::Flags & evaluator<ElseMatrixType>::Flags & HereditaryBits,
+
+    Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ThenMatrixType>::Alignment, evaluator<ElseMatrixType>::Alignment)
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& select)
+    : m_conditionImpl(select.conditionMatrix()),
+      m_thenImpl(select.thenMatrix()),
+      m_elseImpl(select.elseMatrix())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    if (m_conditionImpl.coeff(row, col))
+      return m_thenImpl.coeff(row, col);
+    else
+      return m_elseImpl.coeff(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    if (m_conditionImpl.coeff(index))
+      return m_thenImpl.coeff(index);
+    else
+      return m_elseImpl.coeff(index);
+  }
+
+protected:
+  evaluator<ConditionMatrixType> m_conditionImpl;
+  evaluator<ThenMatrixType> m_thenImpl;
+  evaluator<ElseMatrixType> m_elseImpl;
+};
+
+
+// -------------------- Replicate --------------------
+
+template<typename ArgType, int RowFactor, int ColFactor>
+struct unary_evaluator<Replicate<ArgType, RowFactor, ColFactor> >
+  : evaluator_base<Replicate<ArgType, RowFactor, ColFactor> >
+{
+  typedef Replicate<ArgType, RowFactor, ColFactor> XprType;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  enum {
+    Factor = (RowFactor==Dynamic || ColFactor==Dynamic) ? Dynamic : RowFactor*ColFactor
+  };
+  typedef typename internal::nested_eval<ArgType,Factor>::type ArgTypeNested;
+  typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNestedCleaned;
+
+  enum {
+    CoeffReadCost = evaluator<ArgTypeNestedCleaned>::CoeffReadCost,
+    LinearAccessMask = XprType::IsVectorAtCompileTime ? LinearAccessBit : 0,
+    Flags = (evaluator<ArgTypeNestedCleaned>::Flags & (HereditaryBits|LinearAccessMask) & ~RowMajorBit) | (traits<XprType>::Flags & RowMajorBit),
+
+    Alignment = evaluator<ArgTypeNestedCleaned>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& replicate)
+    : m_arg(replicate.nestedExpression()),
+      m_argImpl(m_arg),
+      m_rows(replicate.nestedExpression().rows()),
+      m_cols(replicate.nestedExpression().cols())
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    // try to avoid using modulo; this is a pure optimization strategy
+    const Index actual_row = internal::traits<XprType>::RowsAtCompileTime==1 ? 0
+                           : RowFactor==1 ? row
+                           : row % m_rows.value();
+    const Index actual_col = internal::traits<XprType>::ColsAtCompileTime==1 ? 0
+                           : ColFactor==1 ? col
+                           : col % m_cols.value();
+
+    return m_argImpl.coeff(actual_row, actual_col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    // try to avoid using modulo; this is a pure optimization strategy
+    const Index actual_index = internal::traits<XprType>::RowsAtCompileTime==1
+                                  ? (ColFactor==1 ?  index : index%m_cols.value())
+                                  : (RowFactor==1 ?  index : index%m_rows.value());
+
+    return m_argImpl.coeff(actual_index);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    const Index actual_row = internal::traits<XprType>::RowsAtCompileTime==1 ? 0
+                           : RowFactor==1 ? row
+                           : row % m_rows.value();
+    const Index actual_col = internal::traits<XprType>::ColsAtCompileTime==1 ? 0
+                           : ColFactor==1 ? col
+                           : col % m_cols.value();
+
+    return m_argImpl.template packet<LoadMode,PacketType>(actual_row, actual_col);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    const Index actual_index = internal::traits<XprType>::RowsAtCompileTime==1
+                                  ? (ColFactor==1 ?  index : index%m_cols.value())
+                                  : (RowFactor==1 ?  index : index%m_rows.value());
+
+    return m_argImpl.template packet<LoadMode,PacketType>(actual_index);
+  }
+
+protected:
+  const ArgTypeNested m_arg;
+  evaluator<ArgTypeNestedCleaned> m_argImpl;
+  const variable_if_dynamic<Index, ArgType::RowsAtCompileTime> m_rows;
+  const variable_if_dynamic<Index, ArgType::ColsAtCompileTime> m_cols;
+};
+
+// -------------------- MatrixWrapper and ArrayWrapper --------------------
+//
+// evaluator_wrapper_base<T> is a common base class for the
+// MatrixWrapper and ArrayWrapper evaluators.
+
+template<typename XprType>
+struct evaluator_wrapper_base
+  : evaluator_base<XprType>
+{
+  typedef typename remove_all<typename XprType::NestedExpressionType>::type ArgType;
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    Flags = evaluator<ArgType>::Flags,
+    Alignment = evaluator<ArgType>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator_wrapper_base(const ArgType& arg) : m_argImpl(arg) {}
+
+  typedef typename ArgType::Scalar Scalar;
+  typedef typename ArgType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(index);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(row, col);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(index);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode>(row, col, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode>(index, x);
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+};
+
+template<typename TArgType>
+struct unary_evaluator<MatrixWrapper<TArgType> >
+  : evaluator_wrapper_base<MatrixWrapper<TArgType> >
+{
+  typedef MatrixWrapper<TArgType> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& wrapper)
+    : evaluator_wrapper_base<MatrixWrapper<TArgType> >(wrapper.nestedExpression())
+  { }
+};
+
+template<typename TArgType>
+struct unary_evaluator<ArrayWrapper<TArgType> >
+  : evaluator_wrapper_base<ArrayWrapper<TArgType> >
+{
+  typedef ArrayWrapper<TArgType> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& wrapper)
+    : evaluator_wrapper_base<ArrayWrapper<TArgType> >(wrapper.nestedExpression())
+  { }
+};
+
+
+// -------------------- Reverse --------------------
+
+// defined in Reverse.h:
+template<typename PacketType, bool ReversePacket> struct reverse_packet_cond;
+
+template<typename ArgType, int Direction>
+struct unary_evaluator<Reverse<ArgType, Direction> >
+  : evaluator_base<Reverse<ArgType, Direction> >
+{
+  typedef Reverse<ArgType, Direction> XprType;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    IsRowMajor = XprType::IsRowMajor,
+    IsColMajor = !IsRowMajor,
+    ReverseRow = (Direction == Vertical)   || (Direction == BothDirections),
+    ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
+    ReversePacket = (Direction == BothDirections)
+                    || ((Direction == Vertical)   && IsColMajor)
+                    || ((Direction == Horizontal) && IsRowMajor),
+
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+
+    // let's enable LinearAccess only with vectorization because of the product overhead
+    // FIXME enable DirectAccess with negative strides?
+    Flags0 = evaluator<ArgType>::Flags,
+    LinearAccess = ( (Direction==BothDirections) && (int(Flags0)&PacketAccessBit) )
+                  || ((ReverseRow && XprType::ColsAtCompileTime==1) || (ReverseCol && XprType::RowsAtCompileTime==1))
+                 ? LinearAccessBit : 0,
+
+    Flags = int(Flags0) & (HereditaryBits | PacketAccessBit | LinearAccess),
+
+    Alignment = 0 // FIXME in some rare cases, Alignment could be preserved, like a Vector4f.
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& reverse)
+    : m_argImpl(reverse.nestedExpression()),
+      m_rows(ReverseRow ? reverse.nestedExpression().rows() : 1),
+      m_cols(ReverseCol ? reverse.nestedExpression().cols() : 1)
+  { }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(ReverseRow ? m_rows.value() - row - 1 : row,
+                           ReverseCol ? m_cols.value() - col - 1 : col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(m_rows.value() * m_cols.value() - index - 1);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(ReverseRow ? m_rows.value() - row - 1 : row,
+                              ReverseCol ? m_cols.value() - col - 1 : col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(m_rows.value() * m_cols.value() - index - 1);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    enum {
+      PacketSize = unpacket_traits<PacketType>::size,
+      OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
+      OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1
+    };
+    typedef internal::reverse_packet_cond<PacketType,ReversePacket> reverse_packet;
+    return reverse_packet::run(m_argImpl.template packet<LoadMode,PacketType>(
+                                  ReverseRow ? m_rows.value() - row - OffsetRow : row,
+                                  ReverseCol ? m_cols.value() - col - OffsetCol : col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    enum { PacketSize = unpacket_traits<PacketType>::size };
+    return preverse(m_argImpl.template packet<LoadMode,PacketType>(m_rows.value() * m_cols.value() - index - PacketSize));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    // FIXME we could factorize some code with packet(i,j)
+    enum {
+      PacketSize = unpacket_traits<PacketType>::size,
+      OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
+      OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1
+    };
+    typedef internal::reverse_packet_cond<PacketType,ReversePacket> reverse_packet;
+    m_argImpl.template writePacket<LoadMode>(
+                                  ReverseRow ? m_rows.value() - row - OffsetRow : row,
+                                  ReverseCol ? m_cols.value() - col - OffsetCol : col,
+                                  reverse_packet::run(x));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    enum { PacketSize = unpacket_traits<PacketType>::size };
+    m_argImpl.template writePacket<LoadMode>
+      (m_rows.value() * m_cols.value() - index - PacketSize, preverse(x));
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+
+  // If we do not reverse rows, then we do not need to know the number of rows; same for columns
+  // Nonetheless, in this case it is important to set to 1 such that the coeff(index) method works fine for vectors.
+  const variable_if_dynamic<Index, ReverseRow ? ArgType::RowsAtCompileTime : 1> m_rows;
+  const variable_if_dynamic<Index, ReverseCol ? ArgType::ColsAtCompileTime : 1> m_cols;
+};
+
+
+// -------------------- Diagonal --------------------
+
+template<typename ArgType, int DiagIndex>
+struct evaluator<Diagonal<ArgType, DiagIndex> >
+  : evaluator_base<Diagonal<ArgType, DiagIndex> >
+{
+  typedef Diagonal<ArgType, DiagIndex> XprType;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+
+    Flags = (unsigned int)(evaluator<ArgType>::Flags & (HereditaryBits | DirectAccessBit) & ~RowMajorBit) | LinearAccessBit,
+
+    Alignment = 0
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& diagonal)
+    : m_argImpl(diagonal.nestedExpression()),
+      m_index(diagonal.index())
+  { }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index) const
+  {
+    return m_argImpl.coeff(row + rowOffset(), row + colOffset());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(index + rowOffset(), index + colOffset());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index)
+  {
+    return m_argImpl.coeffRef(row + rowOffset(), row + colOffset());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(index + rowOffset(), index + colOffset());
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+  const internal::variable_if_dynamicindex<Index, XprType::DiagIndex> m_index;
+
+private:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+  Index rowOffset() const { return m_index.value() > 0 ? 0 : -m_index.value(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+  Index colOffset() const { return m_index.value() > 0 ? m_index.value() : 0; }
+};
+
+
+//----------------------------------------------------------------------
+// deprecated code
+//----------------------------------------------------------------------
+
+// -------------------- EvalToTemp --------------------
+
+// expression class for evaluating nested expression to a temporary
+
+template<typename ArgType> class EvalToTemp;
+
+template<typename ArgType>
+struct traits<EvalToTemp<ArgType> >
+  : public traits<ArgType>
+{ };
+
+template<typename ArgType>
+class EvalToTemp
+  : public dense_xpr_base<EvalToTemp<ArgType> >::type
+{
+ public:
+
+  typedef typename dense_xpr_base<EvalToTemp>::type Base;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)
+
+  explicit EvalToTemp(const ArgType& arg)
+    : m_arg(arg)
+  { }
+
+  const ArgType& arg() const
+  {
+    return m_arg;
+  }
+
+  EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
+  {
+    return m_arg.rows();
+  }
+
+  EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
+  {
+    return m_arg.cols();
+  }
+
+ private:
+  const ArgType& m_arg;
+};
+
+template<typename ArgType>
+struct evaluator<EvalToTemp<ArgType> >
+  : public evaluator<typename ArgType::PlainObject>
+{
+  typedef EvalToTemp<ArgType>                   XprType;
+  typedef typename ArgType::PlainObject         PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
+    : m_result(xpr.arg())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+  }
+
+  // This constructor is used when nesting an EvalTo evaluator in another evaluator
+  EIGEN_DEVICE_FUNC evaluator(const ArgType& arg)
+    : m_result(arg)
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COREEVALUATORS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/CoreIterators.h b/C++/yolo_bytetrack/include/Eigen/src/Core/CoreIterators.h
new file mode 100644
index 00000000..b9671968
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/CoreIterators.h
@@ -0,0 +1,132 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COREITERATORS_H
+#define EIGEN_COREITERATORS_H
+
+namespace Eigen { 
+
+/* This file contains the respective InnerIterator definition of the expressions defined in Eigen/Core
+ */
+
+namespace internal {
+
+template<typename XprType, typename EvaluatorKind>
+class inner_iterator_selector;
+
+}
+
+/** \class InnerIterator
+  * \brief An InnerIterator allows to loop over the element of any matrix expression.
+  * 
+  * \warning To be used with care because an evaluator is constructed every time an InnerIterator iterator is constructed.
+  * 
+  * TODO: add a usage example
+  */
+template<typename XprType>
+class InnerIterator
+{
+protected:
+  typedef internal::inner_iterator_selector<XprType, typename internal::evaluator_traits<XprType>::Kind> IteratorType;
+  typedef internal::evaluator<XprType> EvaluatorType;
+  typedef typename internal::traits<XprType>::Scalar Scalar;
+public:
+  /** Construct an iterator over the \a outerId -th row or column of \a xpr */
+  InnerIterator(const XprType &xpr, const Index &outerId)
+    : m_eval(xpr), m_iter(m_eval, outerId, xpr.innerSize())
+  {}
+  
+  /// \returns the value of the current coefficient.
+  EIGEN_STRONG_INLINE Scalar value() const          { return m_iter.value(); }
+  /** Increment the iterator \c *this to the next non-zero coefficient.
+    * Explicit zeros are not skipped over. To skip explicit zeros, see class SparseView
+    */
+  EIGEN_STRONG_INLINE InnerIterator& operator++()   { m_iter.operator++(); return *this; }
+  EIGEN_STRONG_INLINE InnerIterator& operator+=(Index i) { m_iter.operator+=(i); return *this; }
+  EIGEN_STRONG_INLINE InnerIterator operator+(Index i) 
+  { InnerIterator result(*this); result+=i; return result; }
+    
+
+  /// \returns the column or row index of the current coefficient.
+  EIGEN_STRONG_INLINE Index index() const           { return m_iter.index(); }
+  /// \returns the row index of the current coefficient.
+  EIGEN_STRONG_INLINE Index row() const             { return m_iter.row(); }
+  /// \returns the column index of the current coefficient.
+  EIGEN_STRONG_INLINE Index col() const             { return m_iter.col(); }
+  /// \returns \c true if the iterator \c *this still references a valid coefficient.
+  EIGEN_STRONG_INLINE operator bool() const         { return m_iter; }
+  
+protected:
+  EvaluatorType m_eval;
+  IteratorType m_iter;
+private:
+  // If you get here, then you're not using the right InnerIterator type, e.g.:
+  //   SparseMatrix<double,RowMajor> A;
+  //   SparseMatrix<double>::InnerIterator it(A,0);
+  template<typename T> InnerIterator(const EigenBase<T>&,Index outer);
+};
+
+namespace internal {
+
+// Generic inner iterator implementation for dense objects
+template<typename XprType>
+class inner_iterator_selector<XprType, IndexBased>
+{
+protected:
+  typedef evaluator<XprType> EvaluatorType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  enum { IsRowMajor = (XprType::Flags&RowMajorBit)==RowMajorBit };
+  
+public:
+  EIGEN_STRONG_INLINE inner_iterator_selector(const EvaluatorType &eval, const Index &outerId, const Index &innerSize)
+    : m_eval(eval), m_inner(0), m_outer(outerId), m_end(innerSize)
+  {}
+
+  EIGEN_STRONG_INLINE Scalar value() const
+  {
+    return (IsRowMajor) ? m_eval.coeff(m_outer, m_inner)
+                        : m_eval.coeff(m_inner, m_outer);
+  }
+
+  EIGEN_STRONG_INLINE inner_iterator_selector& operator++() { m_inner++; return *this; }
+
+  EIGEN_STRONG_INLINE Index index() const { return m_inner; }
+  inline Index row() const { return IsRowMajor ? m_outer : index(); }
+  inline Index col() const { return IsRowMajor ? index() : m_outer; }
+
+  EIGEN_STRONG_INLINE operator bool() const { return m_inner < m_end && m_inner>=0; }
+
+protected:
+  const EvaluatorType& m_eval;
+  Index m_inner;
+  const Index m_outer;
+  const Index m_end;
+};
+
+// For iterator-based evaluator, inner-iterator is already implemented as
+// evaluator<>::InnerIterator
+template<typename XprType>
+class inner_iterator_selector<XprType, IteratorBased>
+ : public evaluator<XprType>::InnerIterator
+{
+protected:
+  typedef typename evaluator<XprType>::InnerIterator Base;
+  typedef evaluator<XprType> EvaluatorType;
+  
+public:
+  EIGEN_STRONG_INLINE inner_iterator_selector(const EvaluatorType &eval, const Index &outerId, const Index &/*innerSize*/)
+    : Base(eval, outerId)
+  {}  
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COREITERATORS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseBinaryOp.h b/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseBinaryOp.h
new file mode 100644
index 00000000..2202b1cc
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseBinaryOp.h
@@ -0,0 +1,183 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_BINARY_OP_H
+#define EIGEN_CWISE_BINARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  // we must not inherit from traits<Lhs> since it has
+  // the potential to cause problems with MSVC
+  typedef typename remove_all<Lhs>::type Ancestor;
+  typedef typename traits<Ancestor>::XprKind XprKind;
+  enum {
+    RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime,
+    ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime,
+    MaxRowsAtCompileTime = traits<Ancestor>::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = traits<Ancestor>::MaxColsAtCompileTime
+  };
+
+  // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor),
+  // we still want to handle the case when the result type is different.
+  typedef typename result_of<
+                     BinaryOp(
+                       const typename Lhs::Scalar&,
+                       const typename Rhs::Scalar&
+                     )
+                   >::type Scalar;
+  typedef typename cwise_promote_storage_type<typename traits<Lhs>::StorageKind,
+                                              typename traits<Rhs>::StorageKind,
+                                              BinaryOp>::ret StorageKind;
+  typedef typename promote_index_type<typename traits<Lhs>::StorageIndex,
+                                      typename traits<Rhs>::StorageIndex>::type StorageIndex;
+  typedef typename Lhs::Nested LhsNested;
+  typedef typename Rhs::Nested RhsNested;
+  typedef typename remove_reference<LhsNested>::type _LhsNested;
+  typedef typename remove_reference<RhsNested>::type _RhsNested;
+  enum {
+    Flags = cwise_promote_storage_order<typename traits<Lhs>::StorageKind,typename traits<Rhs>::StorageKind,_LhsNested::Flags & RowMajorBit,_RhsNested::Flags & RowMajorBit>::value
+  };
+};
+} // end namespace internal
+
+template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
+class CwiseBinaryOpImpl;
+
+/** \class CwiseBinaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression where a coefficient-wise binary operator is applied to two expressions
+  *
+  * \tparam BinaryOp template functor implementing the operator
+  * \tparam LhsType the type of the left-hand side
+  * \tparam RhsType the type of the right-hand side
+  *
+  * This class represents an expression  where a coefficient-wise binary operator is applied to two expressions.
+  * It is the return type of binary operators, by which we mean only those binary operators where
+  * both the left-hand side and the right-hand side are Eigen expressions.
+  * For example, the return type of matrix1+matrix2 is a CwiseBinaryOp.
+  *
+  * Most of the time, this is the only way that it is used, so you typically don't have to name
+  * CwiseBinaryOp types explicitly.
+  *
+  * \sa MatrixBase::binaryExpr(const MatrixBase<OtherDerived> &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp
+  */
+template<typename BinaryOp, typename LhsType, typename RhsType>
+class CwiseBinaryOp :
+  public CwiseBinaryOpImpl<
+          BinaryOp, LhsType, RhsType,
+          typename internal::cwise_promote_storage_type<typename internal::traits<LhsType>::StorageKind,
+                                                        typename internal::traits<RhsType>::StorageKind,
+                                                        BinaryOp>::ret>,
+  internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::remove_all<BinaryOp>::type Functor;
+    typedef typename internal::remove_all<LhsType>::type Lhs;
+    typedef typename internal::remove_all<RhsType>::type Rhs;
+
+    typedef typename CwiseBinaryOpImpl<
+        BinaryOp, LhsType, RhsType,
+        typename internal::cwise_promote_storage_type<typename internal::traits<LhsType>::StorageKind,
+                                                      typename internal::traits<Rhs>::StorageKind,
+                                                      BinaryOp>::ret>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp)
+
+    typedef typename internal::ref_selector<LhsType>::type LhsNested;
+    typedef typename internal::ref_selector<RhsType>::type RhsNested;
+    typedef typename internal::remove_reference<LhsNested>::type _LhsNested;
+    typedef typename internal::remove_reference<RhsNested>::type _RhsNested;
+
+#if EIGEN_COMP_MSVC && EIGEN_HAS_CXX11
+    //Required for Visual Studio or the Copy constructor will probably not get inlined!
+    EIGEN_STRONG_INLINE
+    CwiseBinaryOp(const CwiseBinaryOp<BinaryOp,LhsType,RhsType>&) = default;
+#endif
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp())
+      : m_lhs(aLhs), m_rhs(aRhs), m_functor(func)
+    {
+      EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename Rhs::Scalar);
+      // require the sizes to match
+      EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
+      eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols());
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT {
+      // return the fixed size type if available to enable compile time optimizations
+      return internal::traits<typename internal::remove_all<LhsNested>::type>::RowsAtCompileTime==Dynamic ? m_rhs.rows() : m_lhs.rows();
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT {
+      // return the fixed size type if available to enable compile time optimizations
+      return internal::traits<typename internal::remove_all<LhsNested>::type>::ColsAtCompileTime==Dynamic ? m_rhs.cols() : m_lhs.cols();
+    }
+
+    /** \returns the left hand side nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const _LhsNested& lhs() const { return m_lhs; }
+    /** \returns the right hand side nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const _RhsNested& rhs() const { return m_rhs; }
+    /** \returns the functor representing the binary operation */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const BinaryOp& functor() const { return m_functor; }
+
+  protected:
+    LhsNested m_lhs;
+    RhsNested m_rhs;
+    const BinaryOp m_functor;
+};
+
+// Generic API dispatcher
+template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
+class CwiseBinaryOpImpl
+  : public internal::generic_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type Base;
+};
+
+/** replaces \c *this by \c *this - \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this + \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_BINARY_OP_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseNullaryOp.h b/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseNullaryOp.h
new file mode 100644
index 00000000..289ec510
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseNullaryOp.h
@@ -0,0 +1,1001 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_NULLARY_OP_H
+#define EIGEN_CWISE_NULLARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename NullaryOp, typename PlainObjectType>
+struct traits<CwiseNullaryOp<NullaryOp, PlainObjectType> > : traits<PlainObjectType>
+{
+  enum {
+    Flags = traits<PlainObjectType>::Flags & RowMajorBit
+  };
+};
+
+} // namespace internal
+
+/** \class CwiseNullaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression of a matrix where all coefficients are defined by a functor
+  *
+  * \tparam NullaryOp template functor implementing the operator
+  * \tparam PlainObjectType the underlying plain matrix/array type
+  *
+  * This class represents an expression of a generic nullary operator.
+  * It is the return type of the Ones(), Zero(), Constant(), Identity() and Random() methods,
+  * and most of the time this is the only way it is used.
+  *
+  * However, if you want to write a function returning such an expression, you
+  * will need to use this class.
+  *
+  * The functor NullaryOp must expose one of the following method:
+    <table class="manual">
+    <tr            ><td>\c operator()() </td><td>if the procedural generation does not depend on the coefficient entries (e.g., random numbers)</td></tr>
+    <tr class="alt"><td>\c operator()(Index i)</td><td>if the procedural generation makes sense for vectors only and that it depends on the coefficient index \c i (e.g., linspace) </td></tr>
+    <tr            ><td>\c operator()(Index i,Index j)</td><td>if the procedural generation depends on the matrix coordinates \c i, \c j (e.g., to generate a checkerboard with 0 and 1)</td></tr>
+    </table>
+  * It is also possible to expose the last two operators if the generation makes sense for matrices but can be optimized for vectors.
+  *
+  * See DenseBase::NullaryExpr(Index,const CustomNullaryOp&) for an example binding
+  * C++11 random number generators.
+  *
+  * A nullary expression can also be used to implement custom sophisticated matrix manipulations
+  * that cannot be covered by the existing set of natively supported matrix manipulations.
+  * See this \ref TopicCustomizing_NullaryExpr "page" for some examples and additional explanations
+  * on the behavior of CwiseNullaryOp.
+  *
+  * \sa class CwiseUnaryOp, class CwiseBinaryOp, DenseBase::NullaryExpr
+  */
+template<typename NullaryOp, typename PlainObjectType>
+class CwiseNullaryOp : public internal::dense_xpr_base< CwiseNullaryOp<NullaryOp, PlainObjectType> >::type, internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<CwiseNullaryOp>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(CwiseNullaryOp)
+
+    EIGEN_DEVICE_FUNC
+    CwiseNullaryOp(Index rows, Index cols, const NullaryOp& func = NullaryOp())
+      : m_rows(rows), m_cols(cols), m_functor(func)
+    {
+      eigen_assert(rows >= 0
+            && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
+            &&  cols >= 0
+            && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols));
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const { return m_rows.value(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const { return m_cols.value(); }
+
+    /** \returns the functor representing the nullary operation */
+    EIGEN_DEVICE_FUNC
+    const NullaryOp& functor() const { return m_functor; }
+
+  protected:
+    const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
+    const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
+    const NullaryOp m_functor;
+};
+
+
+/** \returns an expression of a matrix defined by a custom functor \a func
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+template<typename CustomNullaryOp>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const CwiseNullaryOp<CustomNullaryOp,typename DenseBase<Derived>::PlainObject>
+#else
+const CwiseNullaryOp<CustomNullaryOp,PlainObject>
+#endif
+DenseBase<Derived>::NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func)
+{
+  return CwiseNullaryOp<CustomNullaryOp, PlainObject>(rows, cols, func);
+}
+
+/** \returns an expression of a matrix defined by a custom functor \a func
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * Here is an example with C++11 random generators: \include random_cpp11.cpp
+  * Output: \verbinclude random_cpp11.out
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+template<typename CustomNullaryOp>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const CwiseNullaryOp<CustomNullaryOp, typename DenseBase<Derived>::PlainObject>
+#else
+const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+#endif
+DenseBase<Derived>::NullaryExpr(Index size, const CustomNullaryOp& func)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  if(RowsAtCompileTime == 1) return CwiseNullaryOp<CustomNullaryOp, PlainObject>(1, size, func);
+  else return CwiseNullaryOp<CustomNullaryOp, PlainObject>(size, 1, func);
+}
+
+/** \returns an expression of a matrix defined by a custom functor \a func
+  *
+  * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+template<typename CustomNullaryOp>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const CwiseNullaryOp<CustomNullaryOp, typename DenseBase<Derived>::PlainObject>
+#else
+const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+#endif
+DenseBase<Derived>::NullaryExpr(const CustomNullaryOp& func)
+{
+  return CwiseNullaryOp<CustomNullaryOp, PlainObject>(RowsAtCompileTime, ColsAtCompileTime, func);
+}
+
+/** \returns an expression of a constant matrix of value \a value
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this DenseBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Constant(Index rows, Index cols, const Scalar& value)
+{
+  return DenseBase<Derived>::NullaryExpr(rows, cols, internal::scalar_constant_op<Scalar>(value));
+}
+
+/** \returns an expression of a constant matrix of value \a value
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this DenseBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Constant(Index size, const Scalar& value)
+{
+  return DenseBase<Derived>::NullaryExpr(size, internal::scalar_constant_op<Scalar>(value));
+}
+
+/** \returns an expression of a constant matrix of value \a value
+  *
+  * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Constant(const Scalar& value)
+{
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return DenseBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_constant_op<Scalar>(value));
+}
+
+/** \deprecated because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(Index,const Scalar&,const Scalar&)
+  *
+  * \only_for_vectors
+  *
+  * Example: \include DenseBase_LinSpaced_seq_deprecated.cpp
+  * Output: \verbinclude DenseBase_LinSpaced_seq_deprecated.out
+  *
+  * \sa LinSpaced(Index,const Scalar&, const Scalar&), setLinSpaced(Index,const Scalar&,const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEPRECATED EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar>(low,high,size));
+}
+
+/** \deprecated because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(const Scalar&,const Scalar&)
+  *
+  * \sa LinSpaced(const Scalar&, const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEPRECATED EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(Sequential_t, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar>(low,high,Derived::SizeAtCompileTime));
+}
+
+/**
+  * \brief Sets a linearly spaced vector.
+  *
+  * The function generates 'size' equally spaced values in the closed interval [low,high].
+  * When size is set to 1, a vector of length 1 containing 'high' is returned.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include DenseBase_LinSpaced.cpp
+  * Output: \verbinclude DenseBase_LinSpaced.out
+  *
+  * For integer scalar types, an even spacing is possible if and only if the length of the range,
+  * i.e., \c high-low is a scalar multiple of \c size-1, or if \c size is a scalar multiple of the
+  * number of values \c high-low+1 (meaning each value can be repeated the same number of time).
+  * If one of these two considions is not satisfied, then \c high is lowered to the largest value
+  * satisfying one of this constraint.
+  * Here are some examples:
+  *
+  * Example: \include DenseBase_LinSpacedInt.cpp
+  * Output: \verbinclude DenseBase_LinSpacedInt.out
+  *
+  * \sa setLinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(Index size, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar>(low,high,size));
+}
+
+/**
+  * \copydoc DenseBase::LinSpaced(Index, const Scalar&, const Scalar&)
+  * Special version for fixed size types which does not require the size parameter.
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar>(low,high,Derived::SizeAtCompileTime));
+}
+
+/** \returns true if all coefficients in this matrix are approximately equal to \a val, to within precision \a prec */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isApproxToConstant
+(const Scalar& val, const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = 0; i < rows(); ++i)
+      if(!internal::isApprox(self.coeff(i, j), val, prec))
+        return false;
+  return true;
+}
+
+/** This is just an alias for isApproxToConstant().
+  *
+  * \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isConstant
+(const Scalar& val, const RealScalar& prec) const
+{
+  return isApproxToConstant(val, prec);
+}
+
+/** Alias for setConstant(): sets all coefficients in this expression to \a val.
+  *
+  * \sa setConstant(), Constant(), class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void DenseBase<Derived>::fill(const Scalar& val)
+{
+  setConstant(val);
+}
+
+/** Sets all coefficients in this expression to value \a val.
+  *
+  * \sa fill(), setConstant(Index,const Scalar&), setConstant(Index,Index,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setConstant(const Scalar& val)
+{
+  return derived() = Constant(rows(), cols(), val);
+}
+
+/** Resizes to the given \a size, and sets all coefficients in this expression to the given value \a val.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setConstant_int.cpp
+  * Output: \verbinclude Matrix_setConstant_int.out
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setConstant(Index size, const Scalar& val)
+{
+  resize(size);
+  return setConstant(val);
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to the given value \a val.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  * \param val the value to which all coefficients are set
+  *
+  * Example: \include Matrix_setConstant_int_int.cpp
+  * Output: \verbinclude Matrix_setConstant_int_int.out
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setConstant(Index rows, Index cols, const Scalar& val)
+{
+  resize(rows, cols);
+  return setConstant(val);
+}
+
+/** Resizes to the given size, changing only the number of columns, and sets all
+  * coefficients in this expression to the given value \a val. For the parameter
+  * of type NoChange_t, just pass the special value \c NoChange.
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setConstant(NoChange_t, Index cols, const Scalar& val)
+{
+  return setConstant(rows(), cols, val);
+}
+
+/** Resizes to the given size, changing only the number of rows, and sets all
+  * coefficients in this expression to the given value \a val. For the parameter
+  * of type NoChange_t, just pass the special value \c NoChange.
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setConstant(Index rows, NoChange_t, const Scalar& val)
+{
+  return setConstant(rows, cols(), val);
+}
+
+
+/**
+  * \brief Sets a linearly spaced vector.
+  *
+  * The function generates 'size' equally spaced values in the closed interval [low,high].
+  * When size is set to 1, a vector of length 1 containing 'high' is returned.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include DenseBase_setLinSpaced.cpp
+  * Output: \verbinclude DenseBase_setLinSpaced.out
+  *
+  * For integer scalar types, do not miss the explanations on the definition
+  * of \link LinSpaced(Index,const Scalar&,const Scalar&) even spacing \endlink.
+  *
+  * \sa LinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(Index newSize, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return derived() = Derived::NullaryExpr(newSize, internal::linspaced_op<Scalar>(low,high,newSize));
+}
+
+/**
+  * \brief Sets a linearly spaced vector.
+  *
+  * The function fills \c *this with equally spaced values in the closed interval [low,high].
+  * When size is set to 1, a vector of length 1 containing 'high' is returned.
+  *
+  * \only_for_vectors
+  *
+  * For integer scalar types, do not miss the explanations on the definition
+  * of \link LinSpaced(Index,const Scalar&,const Scalar&) even spacing \endlink.
+  *
+  * \sa LinSpaced(Index,const Scalar&,const Scalar&), setLinSpaced(Index, const Scalar&, const Scalar&), CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return setLinSpaced(size(), low, high);
+}
+
+// zero:
+
+/** \returns an expression of a zero matrix.
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_zero_int_int.cpp
+  * Output: \verbinclude MatrixBase_zero_int_int.out
+  *
+  * \sa Zero(), Zero(Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Zero(Index rows, Index cols)
+{
+  return Constant(rows, cols, Scalar(0));
+}
+
+/** \returns an expression of a zero vector.
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Zero() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_zero_int.cpp
+  * Output: \verbinclude MatrixBase_zero_int.out
+  *
+  * \sa Zero(), Zero(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Zero(Index size)
+{
+  return Constant(size, Scalar(0));
+}
+
+/** \returns an expression of a fixed-size zero matrix or vector.
+  *
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * Example: \include MatrixBase_zero.cpp
+  * Output: \verbinclude MatrixBase_zero.out
+  *
+  * \sa Zero(Index), Zero(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Zero()
+{
+  return Constant(Scalar(0));
+}
+
+/** \returns true if *this is approximately equal to the zero matrix,
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isZero.cpp
+  * Output: \verbinclude MatrixBase_isZero.out
+  *
+  * \sa class CwiseNullaryOp, Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isZero(const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = 0; i < rows(); ++i)
+      if(!internal::isMuchSmallerThan(self.coeff(i, j), static_cast<Scalar>(1), prec))
+        return false;
+  return true;
+}
+
+/** Sets all coefficients in this expression to zero.
+  *
+  * Example: \include MatrixBase_setZero.cpp
+  * Output: \verbinclude MatrixBase_setZero.out
+  *
+  * \sa class CwiseNullaryOp, Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setZero()
+{
+  return setConstant(Scalar(0));
+}
+
+/** Resizes to the given \a size, and sets all coefficients in this expression to zero.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setZero_int.cpp
+  * Output: \verbinclude Matrix_setZero_int.out
+  *
+  * \sa DenseBase::setZero(), setZero(Index,Index), class CwiseNullaryOp, DenseBase::Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setZero(Index newSize)
+{
+  resize(newSize);
+  return setConstant(Scalar(0));
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to zero.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setZero_int_int.cpp
+  * Output: \verbinclude Matrix_setZero_int_int.out
+  *
+  * \sa DenseBase::setZero(), setZero(Index), class CwiseNullaryOp, DenseBase::Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setZero(Index rows, Index cols)
+{
+  resize(rows, cols);
+  return setConstant(Scalar(0));
+}
+
+/** Resizes to the given size, changing only the number of columns, and sets all
+  * coefficients in this expression to zero. For the parameter of type NoChange_t,
+  * just pass the special value \c NoChange.
+  *
+  * \sa DenseBase::setZero(), setZero(Index), setZero(Index, Index), setZero(Index, NoChange_t), class CwiseNullaryOp, DenseBase::Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setZero(NoChange_t, Index cols)
+{
+  return setZero(rows(), cols);
+}
+
+/** Resizes to the given size, changing only the number of rows, and sets all
+  * coefficients in this expression to zero. For the parameter of type NoChange_t,
+  * just pass the special value \c NoChange.
+  *
+  * \sa DenseBase::setZero(), setZero(Index), setZero(Index, Index), setZero(NoChange_t, Index), class CwiseNullaryOp, DenseBase::Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setZero(Index rows, NoChange_t)
+{
+  return setZero(rows, cols());
+}
+
+// ones:
+
+/** \returns an expression of a matrix where all coefficients equal one.
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Ones() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_ones_int_int.cpp
+  * Output: \verbinclude MatrixBase_ones_int_int.out
+  *
+  * \sa Ones(), Ones(Index), isOnes(), class Ones
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Ones(Index rows, Index cols)
+{
+  return Constant(rows, cols, Scalar(1));
+}
+
+/** \returns an expression of a vector where all coefficients equal one.
+  *
+  * The parameter \a newSize is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Ones() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_ones_int.cpp
+  * Output: \verbinclude MatrixBase_ones_int.out
+  *
+  * \sa Ones(), Ones(Index,Index), isOnes(), class Ones
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Ones(Index newSize)
+{
+  return Constant(newSize, Scalar(1));
+}
+
+/** \returns an expression of a fixed-size matrix or vector where all coefficients equal one.
+  *
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * Example: \include MatrixBase_ones.cpp
+  * Output: \verbinclude MatrixBase_ones.out
+  *
+  * \sa Ones(Index), Ones(Index,Index), isOnes(), class Ones
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Ones()
+{
+  return Constant(Scalar(1));
+}
+
+/** \returns true if *this is approximately equal to the matrix where all coefficients
+  *          are equal to 1, within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isOnes.cpp
+  * Output: \verbinclude MatrixBase_isOnes.out
+  *
+  * \sa class CwiseNullaryOp, Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isOnes
+(const RealScalar& prec) const
+{
+  return isApproxToConstant(Scalar(1), prec);
+}
+
+/** Sets all coefficients in this expression to one.
+  *
+  * Example: \include MatrixBase_setOnes.cpp
+  * Output: \verbinclude MatrixBase_setOnes.out
+  *
+  * \sa class CwiseNullaryOp, Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setOnes()
+{
+  return setConstant(Scalar(1));
+}
+
+/** Resizes to the given \a newSize, and sets all coefficients in this expression to one.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setOnes_int.cpp
+  * Output: \verbinclude Matrix_setOnes_int.out
+  *
+  * \sa MatrixBase::setOnes(), setOnes(Index,Index), class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setOnes(Index newSize)
+{
+  resize(newSize);
+  return setConstant(Scalar(1));
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to one.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setOnes_int_int.cpp
+  * Output: \verbinclude Matrix_setOnes_int_int.out
+  *
+  * \sa MatrixBase::setOnes(), setOnes(Index), class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setOnes(Index rows, Index cols)
+{
+  resize(rows, cols);
+  return setConstant(Scalar(1));
+}
+
+/** Resizes to the given size, changing only the number of rows, and sets all
+  * coefficients in this expression to one. For the parameter of type NoChange_t,
+  * just pass the special value \c NoChange.
+  *
+ * \sa MatrixBase::setOnes(), setOnes(Index), setOnes(Index, Index), setOnes(NoChange_t, Index), class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setOnes(Index rows, NoChange_t)
+{
+  return setOnes(rows, cols());
+}
+
+/** Resizes to the given size, changing only the number of columns, and sets all
+  * coefficients in this expression to one. For the parameter of type NoChange_t,
+  * just pass the special value \c NoChange.
+  *
+ * \sa MatrixBase::setOnes(), setOnes(Index), setOnes(Index, Index), setOnes(Index, NoChange_t) class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setOnes(NoChange_t, Index cols)
+{
+  return setOnes(rows(), cols);
+}
+
+// Identity:
+
+/** \returns an expression of the identity matrix (not necessarily square).
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Identity() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_identity_int_int.cpp
+  * Output: \verbinclude MatrixBase_identity_int_int.out
+  *
+  * \sa Identity(), setIdentity(), isIdentity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType
+MatrixBase<Derived>::Identity(Index rows, Index cols)
+{
+  return DenseBase<Derived>::NullaryExpr(rows, cols, internal::scalar_identity_op<Scalar>());
+}
+
+/** \returns an expression of the identity matrix (not necessarily square).
+  *
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variant taking size arguments.
+  *
+  * Example: \include MatrixBase_identity.cpp
+  * Output: \verbinclude MatrixBase_identity.out
+  *
+  * \sa Identity(Index,Index), setIdentity(), isIdentity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType
+MatrixBase<Derived>::Identity()
+{
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return MatrixBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_identity_op<Scalar>());
+}
+
+/** \returns true if *this is approximately equal to the identity matrix
+  *          (not necessarily square),
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isIdentity.cpp
+  * Output: \verbinclude MatrixBase_isIdentity.out
+  *
+  * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), setIdentity()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isIdentity
+(const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index j = 0; j < cols(); ++j)
+  {
+    for(Index i = 0; i < rows(); ++i)
+    {
+      if(i == j)
+      {
+        if(!internal::isApprox(self.coeff(i, j), static_cast<Scalar>(1), prec))
+          return false;
+      }
+      else
+      {
+        if(!internal::isMuchSmallerThan(self.coeff(i, j), static_cast<RealScalar>(1), prec))
+          return false;
+      }
+    }
+  }
+  return true;
+}
+
+namespace internal {
+
+template<typename Derived, bool Big = (Derived::SizeAtCompileTime>=16)>
+struct setIdentity_impl
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Derived& run(Derived& m)
+  {
+    return m = Derived::Identity(m.rows(), m.cols());
+  }
+};
+
+template<typename Derived>
+struct setIdentity_impl<Derived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Derived& run(Derived& m)
+  {
+    m.setZero();
+    const Index size = numext::mini(m.rows(), m.cols());
+    for(Index i = 0; i < size; ++i) m.coeffRef(i,i) = typename Derived::Scalar(1);
+    return m;
+  }
+};
+
+} // end namespace internal
+
+/** Writes the identity expression (not necessarily square) into *this.
+  *
+  * Example: \include MatrixBase_setIdentity.cpp
+  * Output: \verbinclude MatrixBase_setIdentity.out
+  *
+  * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), isIdentity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity()
+{
+  return internal::setIdentity_impl<Derived>::run(derived());
+}
+
+/** \brief Resizes to the given size, and writes the identity expression (not necessarily square) into *this.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setIdentity_int_int.cpp
+  * Output: \verbinclude Matrix_setIdentity_int_int.out
+  *
+  * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Identity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity(Index rows, Index cols)
+{
+  derived().resize(rows, cols);
+  return setIdentity();
+}
+
+/** \returns an expression of the i-th unit (basis) vector.
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::Unit(Index newSize, Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return BasisReturnType(SquareMatrixType::Identity(newSize,newSize), i);
+}
+
+/** \returns an expression of the i-th unit (basis) vector.
+  *
+  * \only_for_vectors
+  *
+  * This variant is for fixed-size vector only.
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::Unit(Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return BasisReturnType(SquareMatrixType::Identity(),i);
+}
+
+/** \returns an expression of the X axis unit vector (1{,0}^*)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitX()
+{ return Derived::Unit(0); }
+
+/** \returns an expression of the Y axis unit vector (0,1{,0}^*)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitY()
+{ return Derived::Unit(1); }
+
+/** \returns an expression of the Z axis unit vector (0,0,1{,0}^*)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitZ()
+{ return Derived::Unit(2); }
+
+/** \returns an expression of the W axis unit vector (0,0,0,1)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitW()
+{ return Derived::Unit(3); }
+
+/** \brief Set the coefficients of \c *this to the i-th unit (basis) vector
+  *
+  * \param i index of the unique coefficient to be set to 1
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Unit(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setUnit(Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  eigen_assert(i<size());
+  derived().setZero();
+  derived().coeffRef(i) = Scalar(1);
+  return derived();
+}
+
+/** \brief Resizes to the given \a newSize, and writes the i-th unit (basis) vector into *this.
+  *
+  * \param newSize the new size of the vector
+  * \param i index of the unique coefficient to be set to 1
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Unit(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setUnit(Index newSize, Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  eigen_assert(i<newSize);
+  derived().resize(newSize);
+  return setUnit(i);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_NULLARY_OP_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseTernaryOp.h b/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseTernaryOp.h
new file mode 100644
index 00000000..9f3576fe
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseTernaryOp.h
@@ -0,0 +1,197 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_TERNARY_OP_H
+#define EIGEN_CWISE_TERNARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+struct traits<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > {
+  // we must not inherit from traits<Arg1> since it has
+  // the potential to cause problems with MSVC
+  typedef typename remove_all<Arg1>::type Ancestor;
+  typedef typename traits<Ancestor>::XprKind XprKind;
+  enum {
+    RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime,
+    ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime,
+    MaxRowsAtCompileTime = traits<Ancestor>::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = traits<Ancestor>::MaxColsAtCompileTime
+  };
+
+  // even though we require Arg1, Arg2, and Arg3 to have the same scalar type
+  // (see CwiseTernaryOp constructor),
+  // we still want to handle the case when the result type is different.
+  typedef typename result_of<TernaryOp(
+      const typename Arg1::Scalar&, const typename Arg2::Scalar&,
+      const typename Arg3::Scalar&)>::type Scalar;
+
+  typedef typename internal::traits<Arg1>::StorageKind StorageKind;
+  typedef typename internal::traits<Arg1>::StorageIndex StorageIndex;
+
+  typedef typename Arg1::Nested Arg1Nested;
+  typedef typename Arg2::Nested Arg2Nested;
+  typedef typename Arg3::Nested Arg3Nested;
+  typedef typename remove_reference<Arg1Nested>::type _Arg1Nested;
+  typedef typename remove_reference<Arg2Nested>::type _Arg2Nested;
+  typedef typename remove_reference<Arg3Nested>::type _Arg3Nested;
+  enum { Flags = _Arg1Nested::Flags & RowMajorBit };
+};
+}  // end namespace internal
+
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3,
+          typename StorageKind>
+class CwiseTernaryOpImpl;
+
+/** \class CwiseTernaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression where a coefficient-wise ternary operator is
+ * applied to two expressions
+  *
+  * \tparam TernaryOp template functor implementing the operator
+  * \tparam Arg1Type the type of the first argument
+  * \tparam Arg2Type the type of the second argument
+  * \tparam Arg3Type the type of the third argument
+  *
+  * This class represents an expression where a coefficient-wise ternary
+ * operator is applied to three expressions.
+  * It is the return type of ternary operators, by which we mean only those
+ * ternary operators where
+  * all three arguments are Eigen expressions.
+  * For example, the return type of betainc(matrix1, matrix2, matrix3) is a
+ * CwiseTernaryOp.
+  *
+  * Most of the time, this is the only way that it is used, so you typically
+ * don't have to name
+  * CwiseTernaryOp types explicitly.
+  *
+  * \sa MatrixBase::ternaryExpr(const MatrixBase<Argument2> &, const
+ * MatrixBase<Argument3> &, const CustomTernaryOp &) const, class CwiseBinaryOp,
+ * class CwiseUnaryOp, class CwiseNullaryOp
+  */
+template <typename TernaryOp, typename Arg1Type, typename Arg2Type,
+          typename Arg3Type>
+class CwiseTernaryOp : public CwiseTernaryOpImpl<
+                           TernaryOp, Arg1Type, Arg2Type, Arg3Type,
+                           typename internal::traits<Arg1Type>::StorageKind>,
+                       internal::no_assignment_operator
+{
+ public:
+  typedef typename internal::remove_all<Arg1Type>::type Arg1;
+  typedef typename internal::remove_all<Arg2Type>::type Arg2;
+  typedef typename internal::remove_all<Arg3Type>::type Arg3;
+
+  typedef typename CwiseTernaryOpImpl<
+      TernaryOp, Arg1Type, Arg2Type, Arg3Type,
+      typename internal::traits<Arg1Type>::StorageKind>::Base Base;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseTernaryOp)
+
+  typedef typename internal::ref_selector<Arg1Type>::type Arg1Nested;
+  typedef typename internal::ref_selector<Arg2Type>::type Arg2Nested;
+  typedef typename internal::ref_selector<Arg3Type>::type Arg3Nested;
+  typedef typename internal::remove_reference<Arg1Nested>::type _Arg1Nested;
+  typedef typename internal::remove_reference<Arg2Nested>::type _Arg2Nested;
+  typedef typename internal::remove_reference<Arg3Nested>::type _Arg3Nested;
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE CwiseTernaryOp(const Arg1& a1, const Arg2& a2,
+                                     const Arg3& a3,
+                                     const TernaryOp& func = TernaryOp())
+      : m_arg1(a1), m_arg2(a2), m_arg3(a3), m_functor(func) {
+    // require the sizes to match
+    EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Arg1, Arg2)
+    EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Arg1, Arg3)
+
+    // The index types should match
+    EIGEN_STATIC_ASSERT((internal::is_same<
+                         typename internal::traits<Arg1Type>::StorageKind,
+                         typename internal::traits<Arg2Type>::StorageKind>::value),
+                        STORAGE_KIND_MUST_MATCH)
+    EIGEN_STATIC_ASSERT((internal::is_same<
+                         typename internal::traits<Arg1Type>::StorageKind,
+                         typename internal::traits<Arg3Type>::StorageKind>::value),
+                        STORAGE_KIND_MUST_MATCH)
+
+    eigen_assert(a1.rows() == a2.rows() && a1.cols() == a2.cols() &&
+                 a1.rows() == a3.rows() && a1.cols() == a3.cols());
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE Index rows() const {
+    // return the fixed size type if available to enable compile time
+    // optimizations
+    if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                RowsAtCompileTime == Dynamic &&
+        internal::traits<typename internal::remove_all<Arg2Nested>::type>::
+                RowsAtCompileTime == Dynamic)
+      return m_arg3.rows();
+    else if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                     RowsAtCompileTime == Dynamic &&
+             internal::traits<typename internal::remove_all<Arg3Nested>::type>::
+                     RowsAtCompileTime == Dynamic)
+      return m_arg2.rows();
+    else
+      return m_arg1.rows();
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE Index cols() const {
+    // return the fixed size type if available to enable compile time
+    // optimizations
+    if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                ColsAtCompileTime == Dynamic &&
+        internal::traits<typename internal::remove_all<Arg2Nested>::type>::
+                ColsAtCompileTime == Dynamic)
+      return m_arg3.cols();
+    else if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                     ColsAtCompileTime == Dynamic &&
+             internal::traits<typename internal::remove_all<Arg3Nested>::type>::
+                     ColsAtCompileTime == Dynamic)
+      return m_arg2.cols();
+    else
+      return m_arg1.cols();
+  }
+
+  /** \returns the first argument nested expression */
+  EIGEN_DEVICE_FUNC
+  const _Arg1Nested& arg1() const { return m_arg1; }
+  /** \returns the first argument nested expression */
+  EIGEN_DEVICE_FUNC
+  const _Arg2Nested& arg2() const { return m_arg2; }
+  /** \returns the third argument nested expression */
+  EIGEN_DEVICE_FUNC
+  const _Arg3Nested& arg3() const { return m_arg3; }
+  /** \returns the functor representing the ternary operation */
+  EIGEN_DEVICE_FUNC
+  const TernaryOp& functor() const { return m_functor; }
+
+ protected:
+  Arg1Nested m_arg1;
+  Arg2Nested m_arg2;
+  Arg3Nested m_arg3;
+  const TernaryOp m_functor;
+};
+
+// Generic API dispatcher
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3,
+          typename StorageKind>
+class CwiseTernaryOpImpl
+    : public internal::generic_xpr_base<
+          CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >::type {
+ public:
+  typedef typename internal::generic_xpr_base<
+      CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >::type Base;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_CWISE_TERNARY_OP_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseUnaryOp.h b/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseUnaryOp.h
new file mode 100644
index 00000000..e68c4f74
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseUnaryOp.h
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_UNARY_OP_H
+#define EIGEN_CWISE_UNARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename UnaryOp, typename XprType>
+struct traits<CwiseUnaryOp<UnaryOp, XprType> >
+ : traits<XprType>
+{
+  typedef typename result_of<
+                     UnaryOp(const typename XprType::Scalar&)
+                   >::type Scalar;
+  typedef typename XprType::Nested XprTypeNested;
+  typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
+  enum {
+    Flags = _XprTypeNested::Flags & RowMajorBit
+  };
+};
+}
+
+template<typename UnaryOp, typename XprType, typename StorageKind>
+class CwiseUnaryOpImpl;
+
+/** \class CwiseUnaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression where a coefficient-wise unary operator is applied to an expression
+  *
+  * \tparam UnaryOp template functor implementing the operator
+  * \tparam XprType the type of the expression to which we are applying the unary operator
+  *
+  * This class represents an expression where a unary operator is applied to an expression.
+  * It is the return type of all operations taking exactly 1 input expression, regardless of the
+  * presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix
+  * is considered unary, because only the right-hand side is an expression, and its
+  * return type is a specialization of CwiseUnaryOp.
+  *
+  * Most of the time, this is the only way that it is used, so you typically don't have to name
+  * CwiseUnaryOp types explicitly.
+  *
+  * \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp
+  */
+template<typename UnaryOp, typename XprType>
+class CwiseUnaryOp : public CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind>, internal::no_assignment_operator
+{
+  public:
+
+    typedef typename CwiseUnaryOpImpl<UnaryOp, XprType,typename internal::traits<XprType>::StorageKind>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
+    typedef typename internal::ref_selector<XprType>::type XprTypeNested;
+    typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    explicit CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp())
+      : m_xpr(xpr), m_functor(func) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_xpr.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_xpr.cols(); }
+
+    /** \returns the functor representing the unary operation */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const UnaryOp& functor() const { return m_functor; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const typename internal::remove_all<XprTypeNested>::type&
+    nestedExpression() const { return m_xpr; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    typename internal::remove_all<XprTypeNested>::type&
+    nestedExpression() { return m_xpr; }
+
+  protected:
+    XprTypeNested m_xpr;
+    const UnaryOp m_functor;
+};
+
+// Generic API dispatcher
+template<typename UnaryOp, typename XprType, typename StorageKind>
+class CwiseUnaryOpImpl
+  : public internal::generic_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_UNARY_OP_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseUnaryView.h b/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseUnaryView.h
new file mode 100644
index 00000000..a06d7621
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/CwiseUnaryView.h
@@ -0,0 +1,132 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_UNARY_VIEW_H
+#define EIGEN_CWISE_UNARY_VIEW_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename ViewOp, typename MatrixType>
+struct traits<CwiseUnaryView<ViewOp, MatrixType> >
+ : traits<MatrixType>
+{
+  typedef typename result_of<
+                     ViewOp(const typename traits<MatrixType>::Scalar&)
+                   >::type Scalar;
+  typedef typename MatrixType::Nested MatrixTypeNested;
+  typedef typename remove_all<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags = traits<_MatrixTypeNested>::Flags & (RowMajorBit | FlagsLvalueBit | DirectAccessBit), // FIXME DirectAccessBit should not be handled by expressions
+    MatrixTypeInnerStride =  inner_stride_at_compile_time<MatrixType>::ret,
+    // need to cast the sizeof's from size_t to int explicitly, otherwise:
+    // "error: no integral type can represent all of the enumerator values
+    InnerStrideAtCompileTime = MatrixTypeInnerStride == Dynamic
+                             ? int(Dynamic)
+                             : int(MatrixTypeInnerStride) * int(sizeof(typename traits<MatrixType>::Scalar) / sizeof(Scalar)),
+    OuterStrideAtCompileTime = outer_stride_at_compile_time<MatrixType>::ret == Dynamic
+                             ? int(Dynamic)
+                             : outer_stride_at_compile_time<MatrixType>::ret * int(sizeof(typename traits<MatrixType>::Scalar) / sizeof(Scalar))
+  };
+};
+}
+
+template<typename ViewOp, typename MatrixType, typename StorageKind>
+class CwiseUnaryViewImpl;
+
+/** \class CwiseUnaryView
+  * \ingroup Core_Module
+  *
+  * \brief Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector
+  *
+  * \tparam ViewOp template functor implementing the view
+  * \tparam MatrixType the type of the matrix we are applying the unary operator
+  *
+  * This class represents a lvalue expression of a generic unary view operator of a matrix or a vector.
+  * It is the return type of real() and imag(), and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::unaryViewExpr(const CustomUnaryOp &) const, class CwiseUnaryOp
+  */
+template<typename ViewOp, typename MatrixType>
+class CwiseUnaryView : public CwiseUnaryViewImpl<ViewOp, MatrixType, typename internal::traits<MatrixType>::StorageKind>
+{
+  public:
+
+    typedef typename CwiseUnaryViewImpl<ViewOp, MatrixType,typename internal::traits<MatrixType>::StorageKind>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryView)
+    typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+    explicit EIGEN_DEVICE_FUNC inline CwiseUnaryView(MatrixType& mat, const ViewOp& func = ViewOp())
+      : m_matrix(mat), m_functor(func) {}
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryView)
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+    /** \returns the functor representing unary operation */
+    EIGEN_DEVICE_FUNC const ViewOp& functor() const { return m_functor; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC const typename internal::remove_all<MatrixTypeNested>::type&
+    nestedExpression() const { return m_matrix; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC typename internal::remove_reference<MatrixTypeNested>::type&
+    nestedExpression() { return m_matrix; }
+
+  protected:
+    MatrixTypeNested m_matrix;
+    ViewOp m_functor;
+};
+
+// Generic API dispatcher
+template<typename ViewOp, typename XprType, typename StorageKind>
+class CwiseUnaryViewImpl
+  : public internal::generic_xpr_base<CwiseUnaryView<ViewOp, XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<CwiseUnaryView<ViewOp, XprType> >::type Base;
+};
+
+template<typename ViewOp, typename MatrixType>
+class CwiseUnaryViewImpl<ViewOp,MatrixType,Dense>
+  : public internal::dense_xpr_base< CwiseUnaryView<ViewOp, MatrixType> >::type
+{
+  public:
+
+    typedef CwiseUnaryView<ViewOp, MatrixType> Derived;
+    typedef typename internal::dense_xpr_base< CwiseUnaryView<ViewOp, MatrixType> >::type Base;
+
+    EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryViewImpl)
+
+    EIGEN_DEVICE_FUNC inline Scalar* data() { return &(this->coeffRef(0)); }
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const { return &(this->coeff(0)); }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index innerStride() const
+    {
+      return derived().nestedExpression().innerStride() * sizeof(typename internal::traits<MatrixType>::Scalar) / sizeof(Scalar);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index outerStride() const
+    {
+      return derived().nestedExpression().outerStride() * sizeof(typename internal::traits<MatrixType>::Scalar) / sizeof(Scalar);
+    }
+  protected:
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(CwiseUnaryViewImpl)
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_UNARY_VIEW_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/DenseBase.h b/C++/yolo_bytetrack/include/Eigen/src/Core/DenseBase.h
new file mode 100644
index 00000000..9b16db68
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/DenseBase.h
@@ -0,0 +1,701 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DENSEBASE_H
+#define EIGEN_DENSEBASE_H
+
+namespace Eigen {
+
+namespace internal {
+
+// The index type defined by EIGEN_DEFAULT_DENSE_INDEX_TYPE must be a signed type.
+// This dummy function simply aims at checking that at compile time.
+static inline void check_DenseIndex_is_signed() {
+  EIGEN_STATIC_ASSERT(NumTraits<DenseIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE)
+}
+
+} // end namespace internal
+
+/** \class DenseBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for all dense matrices, vectors, and arrays
+  *
+  * This class is the base that is inherited by all dense objects (matrix, vector, arrays,
+  * and related expression types). The common Eigen API for dense objects is contained in this class.
+  *
+  * \tparam Derived is the derived type, e.g., a matrix type or an expression.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_DENSEBASE_PLUGIN.
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived> class DenseBase
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  : public DenseCoeffsBase<Derived, internal::accessors_level<Derived>::value>
+#else
+  : public DenseCoeffsBase<Derived,DirectWriteAccessors>
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+{
+  public:
+
+    /** Inner iterator type to iterate over the coefficients of a row or column.
+      * \sa class InnerIterator
+      */
+    typedef Eigen::InnerIterator<Derived> InnerIterator;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+
+    /**
+      * \brief The type used to store indices
+      * \details This typedef is relevant for types that store multiple indices such as
+      *          PermutationMatrix or Transpositions, otherwise it defaults to Eigen::Index
+      * \sa \blank \ref TopicPreprocessorDirectives, Eigen::Index, SparseMatrixBase.
+     */
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+
+    /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc. */
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+
+    /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.
+      *
+      * It is an alias for the Scalar type */
+    typedef Scalar value_type;
+
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef DenseCoeffsBase<Derived, internal::accessors_level<Derived>::value> Base;
+
+    using Base::derived;
+    using Base::const_cast_derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::rowIndexByOuterInner;
+    using Base::colIndexByOuterInner;
+    using Base::coeff;
+    using Base::coeffByOuterInner;
+    using Base::operator();
+    using Base::operator[];
+    using Base::x;
+    using Base::y;
+    using Base::z;
+    using Base::w;
+    using Base::stride;
+    using Base::innerStride;
+    using Base::outerStride;
+    using Base::rowStride;
+    using Base::colStride;
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+
+    enum {
+
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+        /**< The number of rows at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
+
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+        /**< The number of columns at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
+
+
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                   internal::traits<Derived>::ColsAtCompileTime>::ret),
+        /**< This is equal to the number of coefficients, i.e. the number of
+          * rows times the number of columns, or to \a Dynamic if this is not
+          * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
+
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+        /**< This value is equal to the maximum possible number of rows that this expression
+          * might have. If this expression might have an arbitrarily high number of rows,
+          * this value is set to \a Dynamic.
+          *
+          * This value is useful to know when evaluating an expression, in order to determine
+          * whether it is possible to avoid doing a dynamic memory allocation.
+          *
+          * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime
+          */
+
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+        /**< This value is equal to the maximum possible number of columns that this expression
+          * might have. If this expression might have an arbitrarily high number of columns,
+          * this value is set to \a Dynamic.
+          *
+          * This value is useful to know when evaluating an expression, in order to determine
+          * whether it is possible to avoid doing a dynamic memory allocation.
+          *
+          * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime
+          */
+
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
+                                                      internal::traits<Derived>::MaxColsAtCompileTime>::ret),
+        /**< This value is equal to the maximum possible number of coefficients that this expression
+          * might have. If this expression might have an arbitrarily high number of coefficients,
+          * this value is set to \a Dynamic.
+          *
+          * This value is useful to know when evaluating an expression, in order to determine
+          * whether it is possible to avoid doing a dynamic memory allocation.
+          *
+          * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime
+          */
+
+      IsVectorAtCompileTime = internal::traits<Derived>::RowsAtCompileTime == 1
+                           || internal::traits<Derived>::ColsAtCompileTime == 1,
+        /**< This is set to true if either the number of rows or the number of
+          * columns is known at compile-time to be equal to 1. Indeed, in that case,
+          * we are dealing with a column-vector (if there is only one column) or with
+          * a row-vector (if there is only one row). */
+
+      NumDimensions = int(MaxSizeAtCompileTime) == 1 ? 0 : bool(IsVectorAtCompileTime) ? 1 : 2,
+        /**< This value is equal to Tensor::NumDimensions, i.e. 0 for scalars, 1 for vectors,
+         * and 2 for matrices.
+         */
+
+      Flags = internal::traits<Derived>::Flags,
+        /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
+          * constructed from this one. See the \ref flags "list of flags".
+          */
+
+      IsRowMajor = int(Flags) & RowMajorBit, /**< True if this expression has row-major storage order. */
+
+      InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime)
+                             : int(IsRowMajor) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+
+      InnerStrideAtCompileTime = internal::inner_stride_at_compile_time<Derived>::ret,
+      OuterStrideAtCompileTime = internal::outer_stride_at_compile_time<Derived>::ret
+    };
+
+    typedef typename internal::find_best_packet<Scalar,SizeAtCompileTime>::type PacketScalar;
+
+    enum { IsPlainObjectBase = 0 };
+
+    /** The plain matrix type corresponding to this expression.
+      * \sa PlainObject */
+    typedef Matrix<typename internal::traits<Derived>::Scalar,
+                internal::traits<Derived>::RowsAtCompileTime,
+                internal::traits<Derived>::ColsAtCompileTime,
+                AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
+                internal::traits<Derived>::MaxRowsAtCompileTime,
+                internal::traits<Derived>::MaxColsAtCompileTime
+          > PlainMatrix;
+
+    /** The plain array type corresponding to this expression.
+      * \sa PlainObject */
+    typedef Array<typename internal::traits<Derived>::Scalar,
+                internal::traits<Derived>::RowsAtCompileTime,
+                internal::traits<Derived>::ColsAtCompileTime,
+                AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
+                internal::traits<Derived>::MaxRowsAtCompileTime,
+                internal::traits<Derived>::MaxColsAtCompileTime
+          > PlainArray;
+
+    /** \brief The plain matrix or array type corresponding to this expression.
+      *
+      * This is not necessarily exactly the return type of eval(). In the case of plain matrices,
+      * the return type of eval() is a const reference to a matrix, not a matrix! It is however guaranteed
+      * that the return type of eval() is either PlainObject or const PlainObject&.
+      */
+    typedef typename internal::conditional<internal::is_same<typename internal::traits<Derived>::XprKind,MatrixXpr >::value,
+                                 PlainMatrix, PlainArray>::type PlainObject;
+
+    /** \returns the number of nonzero coefficients which is in practice the number
+      * of stored coefficients. */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index nonZeros() const { return size(); }
+
+    /** \returns the outer size.
+      *
+      * \note For a vector, this returns just 1. For a matrix (non-vector), this is the major dimension
+      * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of columns for a
+      * column-major matrix, and the number of rows for a row-major matrix. */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index outerSize() const
+    {
+      return IsVectorAtCompileTime ? 1
+           : int(IsRowMajor) ? this->rows() : this->cols();
+    }
+
+    /** \returns the inner size.
+      *
+      * \note For a vector, this is just the size. For a matrix (non-vector), this is the minor dimension
+      * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of rows for a
+      * column-major matrix, and the number of columns for a row-major matrix. */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index innerSize() const
+    {
+      return IsVectorAtCompileTime ? this->size()
+           : int(IsRowMajor) ? this->cols() : this->rows();
+    }
+
+    /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
+      * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
+      * nothing else.
+      */
+    EIGEN_DEVICE_FUNC
+    void resize(Index newSize)
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(newSize);
+      eigen_assert(newSize == this->size()
+                && "DenseBase::resize() does not actually allow to resize.");
+    }
+    /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
+      * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
+      * nothing else.
+      */
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols)
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(rows);
+      EIGEN_ONLY_USED_FOR_DEBUG(cols);
+      eigen_assert(rows == this->rows() && cols == this->cols()
+                && "DenseBase::resize() does not actually allow to resize.");
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
+    /** \internal \deprecated Represents a vector with linearly spaced coefficients that allows sequential access only. */
+    EIGEN_DEPRECATED typedef CwiseNullaryOp<internal::linspaced_op<Scalar>,PlainObject> SequentialLinSpacedReturnType;
+    /** \internal Represents a vector with linearly spaced coefficients that allows random access. */
+    typedef CwiseNullaryOp<internal::linspaced_op<Scalar>,PlainObject> RandomAccessLinSpacedReturnType;
+    /** \internal the return type of MatrixBase::eigenvalues() */
+    typedef Matrix<typename NumTraits<typename internal::traits<Derived>::Scalar>::Real, internal::traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+    /** Copies \a other into *this. \returns a reference to *this. */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const DenseBase<OtherDerived>& other);
+
+    /** Special case of the template operator=, in order to prevent the compiler
+      * from generating a default operator= (issue hit with g++ 4.1)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const DenseBase& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const EigenBase<OtherDerived> &other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator+=(const EigenBase<OtherDerived> &other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator-=(const EigenBase<OtherDerived> &other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const ReturnByValue<OtherDerived>& func);
+
+    /** \internal
+      * Copies \a other into *this without evaluating other. \returns a reference to *this. */
+    template<typename OtherDerived>
+    /** \deprecated */
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
+    Derived& lazyAssign(const DenseBase<OtherDerived>& other);
+
+    EIGEN_DEVICE_FUNC
+    CommaInitializer<Derived> operator<< (const Scalar& s);
+
+    template<unsigned int Added,unsigned int Removed>
+    /** \deprecated it now returns \c *this */
+    EIGEN_DEPRECATED
+    const Derived& flagged() const
+    { return derived(); }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    CommaInitializer<Derived> operator<< (const DenseBase<OtherDerived>& other);
+
+    typedef Transpose<Derived> TransposeReturnType;
+    EIGEN_DEVICE_FUNC
+    TransposeReturnType transpose();
+    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
+    EIGEN_DEVICE_FUNC
+    ConstTransposeReturnType transpose() const;
+    EIGEN_DEVICE_FUNC
+    void transposeInPlace();
+
+    EIGEN_DEVICE_FUNC static const ConstantReturnType
+    Constant(Index rows, Index cols, const Scalar& value);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType
+    Constant(Index size, const Scalar& value);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType
+    Constant(const Scalar& value);
+
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
+    LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high);
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
+    LinSpaced(Sequential_t, const Scalar& low, const Scalar& high);
+
+    EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
+    LinSpaced(Index size, const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
+    LinSpaced(const Scalar& low, const Scalar& high);
+
+    template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
+    static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+    NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func);
+    template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
+    static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+    NullaryExpr(Index size, const CustomNullaryOp& func);
+    template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
+    static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+    NullaryExpr(const CustomNullaryOp& func);
+
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(Index size);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Zero();
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index size);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Ones();
+
+    EIGEN_DEVICE_FUNC void fill(const Scalar& value);
+    EIGEN_DEVICE_FUNC Derived& setConstant(const Scalar& value);
+    EIGEN_DEVICE_FUNC Derived& setLinSpaced(Index size, const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC Derived& setLinSpaced(const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC Derived& setZero();
+    EIGEN_DEVICE_FUNC Derived& setOnes();
+    EIGEN_DEVICE_FUNC Derived& setRandom();
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC
+    bool isApprox(const DenseBase<OtherDerived>& other,
+                  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC
+    bool isMuchSmallerThan(const RealScalar& other,
+                           const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC
+    bool isMuchSmallerThan(const DenseBase<OtherDerived>& other,
+                           const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    EIGEN_DEVICE_FUNC bool isApproxToConstant(const Scalar& value, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC bool isConstant(const Scalar& value, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC bool isZero(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC bool isOnes(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    inline bool hasNaN() const;
+    inline bool allFinite() const;
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator*=(const Scalar& other);
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator/=(const Scalar& other);
+
+    typedef typename internal::add_const_on_value_type<typename internal::eval<Derived>::type>::type EvalReturnType;
+    /** \returns the matrix or vector obtained by evaluating this expression.
+      *
+      * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
+      * a const reference, in order to avoid a useless copy.
+      *
+      * \warning Be careful with eval() and the auto C++ keyword, as detailed in this \link TopicPitfalls_auto_keyword page \endlink.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE EvalReturnType eval() const
+    {
+      // Even though MSVC does not honor strong inlining when the return type
+      // is a dynamic matrix, we desperately need strong inlining for fixed
+      // size types on MSVC.
+      return typename internal::eval<Derived>::type(derived());
+    }
+
+    /** swaps *this with the expression \a other.
+      *
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void swap(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT(!OtherDerived::IsPlainObjectBase,THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      eigen_assert(rows()==other.rows() && cols()==other.cols());
+      call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    /** swaps *this with the matrix or array \a other.
+      *
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void swap(PlainObjectBase<OtherDerived>& other)
+    {
+      eigen_assert(rows()==other.rows() && cols()==other.cols());
+      call_assignment(derived(), other.derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC inline const NestByValue<Derived> nestByValue() const;
+    EIGEN_DEVICE_FUNC inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
+    EIGEN_DEVICE_FUNC inline ForceAlignedAccess<Derived> forceAlignedAccess();
+    template<bool Enable> EIGEN_DEVICE_FUNC
+    inline const typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf() const;
+    template<bool Enable> EIGEN_DEVICE_FUNC
+    inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf();
+
+    EIGEN_DEVICE_FUNC Scalar sum() const;
+    EIGEN_DEVICE_FUNC Scalar mean() const;
+    EIGEN_DEVICE_FUNC Scalar trace() const;
+
+    EIGEN_DEVICE_FUNC Scalar prod() const;
+
+    template<int NaNPropagation>
+    EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff() const;
+    template<int NaNPropagation>
+    EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff() const;
+
+
+    // By default, the fastest version with undefined NaN propagation semantics is
+    // used.
+    // TODO(rmlarsen): Replace with default template argument when we move to
+    // c++11 or beyond.
+    EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar minCoeff() const {
+      return minCoeff<PropagateFast>();
+    }
+    EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar maxCoeff() const {
+      return maxCoeff<PropagateFast>();
+    }
+
+    template<int NaNPropagation, typename IndexType>
+    EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const;
+    template<int NaNPropagation, typename IndexType>
+    EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const;
+    template<int NaNPropagation, typename IndexType>
+    EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const;
+    template<int NaNPropagation, typename IndexType>
+    EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const;
+
+    // TODO(rmlarsen): Replace these methods with a default template argument.
+    template<typename IndexType>
+    EIGEN_DEVICE_FUNC inline
+    typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const {
+      return minCoeff<PropagateFast>(row, col);
+    }
+    template<typename IndexType>
+    EIGEN_DEVICE_FUNC inline
+    typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const {
+      return maxCoeff<PropagateFast>(row, col);
+    }
+    template<typename IndexType>
+     EIGEN_DEVICE_FUNC inline
+    typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const {
+      return minCoeff<PropagateFast>(index);
+    }
+    template<typename IndexType>
+    EIGEN_DEVICE_FUNC inline
+    typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const {
+      return maxCoeff<PropagateFast>(index);
+    }
+  
+    template<typename BinaryOp>
+    EIGEN_DEVICE_FUNC
+    Scalar redux(const BinaryOp& func) const;
+
+    template<typename Visitor>
+    EIGEN_DEVICE_FUNC
+    void visit(Visitor& func) const;
+
+    /** \returns a WithFormat proxy object allowing to print a matrix the with given
+      * format \a fmt.
+      *
+      * See class IOFormat for some examples.
+      *
+      * \sa class IOFormat, class WithFormat
+      */
+    inline const WithFormat<Derived> format(const IOFormat& fmt) const
+    {
+      return WithFormat<Derived>(derived(), fmt);
+    }
+
+    /** \returns the unique coefficient of a 1x1 expression */
+    EIGEN_DEVICE_FUNC
+    CoeffReturnType value() const
+    {
+      EIGEN_STATIC_ASSERT_SIZE_1x1(Derived)
+      eigen_assert(this->rows() == 1 && this->cols() == 1);
+      return derived().coeff(0,0);
+    }
+
+    EIGEN_DEVICE_FUNC bool all() const;
+    EIGEN_DEVICE_FUNC bool any() const;
+    EIGEN_DEVICE_FUNC Index count() const;
+
+    typedef VectorwiseOp<Derived, Horizontal> RowwiseReturnType;
+    typedef const VectorwiseOp<const Derived, Horizontal> ConstRowwiseReturnType;
+    typedef VectorwiseOp<Derived, Vertical> ColwiseReturnType;
+    typedef const VectorwiseOp<const Derived, Vertical> ConstColwiseReturnType;
+
+    /** \returns a VectorwiseOp wrapper of *this for broadcasting and partial reductions
+    *
+    * Example: \include MatrixBase_rowwise.cpp
+    * Output: \verbinclude MatrixBase_rowwise.out
+    *
+    * \sa colwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+    */
+    //Code moved here due to a CUDA compiler bug
+    EIGEN_DEVICE_FUNC inline ConstRowwiseReturnType rowwise() const {
+      return ConstRowwiseReturnType(derived());
+    }
+    EIGEN_DEVICE_FUNC RowwiseReturnType rowwise();
+
+    /** \returns a VectorwiseOp wrapper of *this broadcasting and partial reductions
+    *
+    * Example: \include MatrixBase_colwise.cpp
+    * Output: \verbinclude MatrixBase_colwise.out
+    *
+    * \sa rowwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+    */
+    EIGEN_DEVICE_FUNC inline ConstColwiseReturnType colwise() const {
+      return ConstColwiseReturnType(derived());
+    }
+    EIGEN_DEVICE_FUNC ColwiseReturnType colwise();
+
+    typedef CwiseNullaryOp<internal::scalar_random_op<Scalar>,PlainObject> RandomReturnType;
+    static const RandomReturnType Random(Index rows, Index cols);
+    static const RandomReturnType Random(Index size);
+    static const RandomReturnType Random();
+
+    template<typename ThenDerived,typename ElseDerived>
+    inline EIGEN_DEVICE_FUNC const Select<Derived,ThenDerived,ElseDerived>
+    select(const DenseBase<ThenDerived>& thenMatrix,
+           const DenseBase<ElseDerived>& elseMatrix) const;
+
+    template<typename ThenDerived>
+    inline EIGEN_DEVICE_FUNC const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
+    select(const DenseBase<ThenDerived>& thenMatrix, const typename ThenDerived::Scalar& elseScalar) const;
+
+    template<typename ElseDerived>
+    inline EIGEN_DEVICE_FUNC const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
+    select(const typename ElseDerived::Scalar& thenScalar, const DenseBase<ElseDerived>& elseMatrix) const;
+
+    template<int p> RealScalar lpNorm() const;
+
+    template<int RowFactor, int ColFactor>
+    EIGEN_DEVICE_FUNC
+    const Replicate<Derived,RowFactor,ColFactor> replicate() const;
+    /**
+    * \return an expression of the replication of \c *this
+    *
+    * Example: \include MatrixBase_replicate_int_int.cpp
+    * Output: \verbinclude MatrixBase_replicate_int_int.out
+    *
+    * \sa VectorwiseOp::replicate(), DenseBase::replicate<int,int>(), class Replicate
+    */
+    //Code moved here due to a CUDA compiler bug
+    EIGEN_DEVICE_FUNC
+    const Replicate<Derived, Dynamic, Dynamic> replicate(Index rowFactor, Index colFactor) const
+    {
+      return Replicate<Derived, Dynamic, Dynamic>(derived(), rowFactor, colFactor);
+    }
+
+    typedef Reverse<Derived, BothDirections> ReverseReturnType;
+    typedef const Reverse<const Derived, BothDirections> ConstReverseReturnType;
+    EIGEN_DEVICE_FUNC ReverseReturnType reverse();
+    /** This is the const version of reverse(). */
+    //Code moved here due to a CUDA compiler bug
+    EIGEN_DEVICE_FUNC ConstReverseReturnType reverse() const
+    {
+      return ConstReverseReturnType(derived());
+    }
+    EIGEN_DEVICE_FUNC void reverseInPlace();
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** STL-like <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">RandomAccessIterator</a>
+      * iterator type as returned by the begin() and end() methods.
+      */
+    typedef random_access_iterator_type iterator;
+    /** This is the const version of iterator (aka read-only) */
+    typedef random_access_iterator_type const_iterator;
+    #else
+    typedef typename internal::conditional< (Flags&DirectAccessBit)==DirectAccessBit,
+                                            internal::pointer_based_stl_iterator<Derived>,
+                                            internal::generic_randaccess_stl_iterator<Derived>
+                                          >::type iterator_type;
+
+    typedef typename internal::conditional< (Flags&DirectAccessBit)==DirectAccessBit,
+                                            internal::pointer_based_stl_iterator<const Derived>,
+                                            internal::generic_randaccess_stl_iterator<const Derived>
+                                          >::type const_iterator_type;
+
+    // Stl-style iterators are supported only for vectors.
+
+    typedef typename internal::conditional< IsVectorAtCompileTime,
+                                            iterator_type,
+                                            void
+                                          >::type iterator;
+
+    typedef typename internal::conditional< IsVectorAtCompileTime,
+                                            const_iterator_type,
+                                            void
+                                          >::type const_iterator;
+    #endif
+
+    inline iterator begin();
+    inline const_iterator begin() const;
+    inline const_iterator cbegin() const;
+    inline iterator end();
+    inline const_iterator end() const;
+    inline const_iterator cend() const;
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::DenseBase
+#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND)
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#   include "../plugins/CommonCwiseUnaryOps.h"
+#   include "../plugins/BlockMethods.h"
+#   include "../plugins/IndexedViewMethods.h"
+#   include "../plugins/ReshapedMethods.h"
+#   ifdef EIGEN_DENSEBASE_PLUGIN
+#     include EIGEN_DENSEBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#undef EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF
+#undef EIGEN_DOC_UNARY_ADDONS
+
+    // disable the use of evalTo for dense objects with a nice compilation error
+    template<typename Dest>
+    EIGEN_DEVICE_FUNC
+    inline void evalTo(Dest& ) const
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<Dest,void>::value),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS);
+    }
+
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(DenseBase)
+    /** Default constructor. Do nothing. */
+    EIGEN_DEVICE_FUNC DenseBase()
+    {
+      /* Just checks for self-consistency of the flags.
+       * Only do it when debugging Eigen, as this borders on paranoia and could slow compilation down
+       */
+#ifdef EIGEN_INTERNAL_DEBUGGING
+      EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor))
+                        && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))),
+                          INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION)
+#endif
+    }
+
+  private:
+    EIGEN_DEVICE_FUNC explicit DenseBase(int);
+    EIGEN_DEVICE_FUNC DenseBase(int,int);
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit DenseBase(const DenseBase<OtherDerived>&);
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_DENSEBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/DenseCoeffsBase.h b/C++/yolo_bytetrack/include/Eigen/src/Core/DenseCoeffsBase.h
new file mode 100644
index 00000000..37fcdb59
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/DenseCoeffsBase.h
@@ -0,0 +1,685 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DENSECOEFFSBASE_H
+#define EIGEN_DENSECOEFFSBASE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename T> struct add_const_on_value_type_if_arithmetic
+{
+  typedef typename conditional<is_arithmetic<T>::value, T, typename add_const_on_value_type<T>::type>::type type;
+};
+}
+
+/** \brief Base class providing read-only coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  *
+  * \note #ReadOnlyAccessors Constant indicating read-only access
+  *
+  * This class defines the \c operator() \c const function and friends, which can be used to read specific
+  * entries of a matrix or array.
+  *
+  * \sa DenseCoeffsBase<Derived, WriteAccessors>, DenseCoeffsBase<Derived, DirectAccessors>,
+  *     \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
+{
+  public:
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+
+    // Explanation for this CoeffReturnType typedef.
+    // - This is the return type of the coeff() method.
+    // - The LvalueBit means exactly that we can offer a coeffRef() method, which means exactly that we can get references
+    // to coeffs, which means exactly that we can have coeff() return a const reference (as opposed to returning a value).
+    // - The is_artihmetic check is required since "const int", "const double", etc. will cause warnings on some systems
+    // while the declaration of "const T", where T is a non arithmetic type does not. Always returning "const Scalar&" is
+    // not possible, since the underlying expressions might not offer a valid address the reference could be referring to.
+    typedef typename internal::conditional<bool(internal::traits<Derived>::Flags&LvalueBit),
+                         const Scalar&,
+                         typename internal::conditional<internal::is_arithmetic<Scalar>::value, Scalar, const Scalar>::type
+                     >::type CoeffReturnType;
+
+    typedef typename internal::add_const_on_value_type_if_arithmetic<
+                         typename internal::packet_traits<Scalar>::type
+                     >::type PacketReturnType;
+
+    typedef EigenBase<Derived> Base;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner) const
+    {
+      return int(Derived::RowsAtCompileTime) == 1 ? 0
+          : int(Derived::ColsAtCompileTime) == 1 ? inner
+          : int(Derived::Flags)&RowMajorBit ? outer
+          : inner;
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner) const
+    {
+      return int(Derived::ColsAtCompileTime) == 1 ? 0
+          : int(Derived::RowsAtCompileTime) == 1 ? inner
+          : int(Derived::Flags)&RowMajorBit ? inner
+          : outer;
+    }
+
+    /** Short version: don't use this function, use
+      * \link operator()(Index,Index) const \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator()(Index,Index) const \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameters \a row and \a col are in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator()(Index,Index) const \endlink.
+      *
+      * \sa operator()(Index,Index) const, coeffRef(Index,Index), coeff(Index) const
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
+    {
+      eigen_internal_assert(row >= 0 && row < rows()
+                         && col >= 0 && col < cols());
+      return internal::evaluator<Derived>(derived()).coeff(row,col);
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType coeffByOuterInner(Index outer, Index inner) const
+    {
+      return coeff(rowIndexByOuterInner(outer, inner),
+                   colIndexByOuterInner(outer, inner));
+    }
+
+    /** \returns the coefficient at given the given row and column.
+      *
+      * \sa operator()(Index,Index), operator[](Index)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType operator()(Index row, Index col) const
+    {
+      eigen_assert(row >= 0 && row < rows()
+          && col >= 0 && col < cols());
+      return coeff(row, col);
+    }
+
+    /** Short version: don't use this function, use
+      * \link operator[](Index) const \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator[](Index) const \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameter \a index is in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator[](Index) const \endlink.
+      *
+      * \sa operator[](Index) const, coeffRef(Index), coeff(Index,Index) const
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    coeff(Index index) const
+    {
+      EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
+                          THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
+      eigen_internal_assert(index >= 0 && index < size());
+      return internal::evaluator<Derived>(derived()).coeff(index);
+    }
+
+
+    /** \returns the coefficient at given index.
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const,
+      * z() const, w() const
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    operator[](Index index) const
+    {
+      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
+                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
+      eigen_assert(index >= 0 && index < size());
+      return coeff(index);
+    }
+
+    /** \returns the coefficient at given index.
+      *
+      * This is synonymous to operator[](Index) const.
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const,
+      * z() const, w() const
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    operator()(Index index) const
+    {
+      eigen_assert(index >= 0 && index < size());
+      return coeff(index);
+    }
+
+    /** equivalent to operator[](0).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    x() const { return (*this)[0]; }
+
+    /** equivalent to operator[](1).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    y() const
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=2, OUT_OF_RANGE_ACCESS);
+      return (*this)[1];
+    }
+
+    /** equivalent to operator[](2).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    z() const
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=3, OUT_OF_RANGE_ACCESS);
+      return (*this)[2];
+    }
+
+    /** equivalent to operator[](3).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    w() const
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS);
+      return (*this)[3];
+    }
+
+    /** \internal
+      * \returns the packet of coefficients starting at the given row and column. It is your responsibility
+      * to ensure that a packet really starts there. This method is only available on expressions having the
+      * PacketAccessBit.
+      *
+      * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select
+      * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
+      * starting at an address which is a multiple of the packet size.
+      */
+
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketReturnType packet(Index row, Index col) const
+    {
+      typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
+      eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols());
+      return internal::evaluator<Derived>(derived()).template packet<LoadMode,DefaultPacketType>(row,col);
+    }
+
+
+    /** \internal */
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketReturnType packetByOuterInner(Index outer, Index inner) const
+    {
+      return packet<LoadMode>(rowIndexByOuterInner(outer, inner),
+                              colIndexByOuterInner(outer, inner));
+    }
+
+    /** \internal
+      * \returns the packet of coefficients starting at the given index. It is your responsibility
+      * to ensure that a packet really starts there. This method is only available on expressions having the
+      * PacketAccessBit and the LinearAccessBit.
+      *
+      * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select
+      * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
+      * starting at an address which is a multiple of the packet size.
+      */
+
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
+    {
+      EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
+                          THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
+      typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
+      eigen_internal_assert(index >= 0 && index < size());
+      return internal::evaluator<Derived>(derived()).template packet<LoadMode,DefaultPacketType>(index);
+    }
+
+  protected:
+    // explanation: DenseBase is doing "using ..." on the methods from DenseCoeffsBase.
+    // But some methods are only available in the DirectAccess case.
+    // So we add dummy methods here with these names, so that "using... " doesn't fail.
+    // It's not private so that the child class DenseBase can access them, and it's not public
+    // either since it's an implementation detail, so has to be protected.
+    void coeffRef();
+    void coeffRefByOuterInner();
+    void writePacket();
+    void writePacketByOuterInner();
+    void copyCoeff();
+    void copyCoeffByOuterInner();
+    void copyPacket();
+    void copyPacketByOuterInner();
+    void stride();
+    void innerStride();
+    void outerStride();
+    void rowStride();
+    void colStride();
+};
+
+/** \brief Base class providing read/write coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  *
+  * \note #WriteAccessors Constant indicating read/write access
+  *
+  * This class defines the non-const \c operator() function and friends, which can be used to write specific
+  * entries of a matrix or array. This class inherits DenseCoeffsBase<Derived, ReadOnlyAccessors> which
+  * defines the const variant for reading specific entries.
+  *
+  * \sa DenseCoeffsBase<Derived, DirectAccessors>, \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
+{
+  public:
+
+    typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    using Base::coeff;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+    using Base::rowIndexByOuterInner;
+    using Base::colIndexByOuterInner;
+    using Base::operator[];
+    using Base::operator();
+    using Base::x;
+    using Base::y;
+    using Base::z;
+    using Base::w;
+
+    /** Short version: don't use this function, use
+      * \link operator()(Index,Index) \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator()(Index,Index) \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameters \a row and \a col are in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator()(Index,Index) \endlink.
+      *
+      * \sa operator()(Index,Index), coeff(Index, Index) const, coeffRef(Index)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
+    {
+      eigen_internal_assert(row >= 0 && row < rows()
+                         && col >= 0 && col < cols());
+      return internal::evaluator<Derived>(derived()).coeffRef(row,col);
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    coeffRefByOuterInner(Index outer, Index inner)
+    {
+      return coeffRef(rowIndexByOuterInner(outer, inner),
+                      colIndexByOuterInner(outer, inner));
+    }
+
+    /** \returns a reference to the coefficient at given the given row and column.
+      *
+      * \sa operator[](Index)
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    operator()(Index row, Index col)
+    {
+      eigen_assert(row >= 0 && row < rows()
+          && col >= 0 && col < cols());
+      return coeffRef(row, col);
+    }
+
+
+    /** Short version: don't use this function, use
+      * \link operator[](Index) \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator[](Index) \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameters \a row and \a col are in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator[](Index) \endlink.
+      *
+      * \sa operator[](Index), coeff(Index) const, coeffRef(Index,Index)
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    coeffRef(Index index)
+    {
+      EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
+                          THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
+      eigen_internal_assert(index >= 0 && index < size());
+      return internal::evaluator<Derived>(derived()).coeffRef(index);
+    }
+
+    /** \returns a reference to the coefficient at given index.
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    operator[](Index index)
+    {
+      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
+                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
+      eigen_assert(index >= 0 && index < size());
+      return coeffRef(index);
+    }
+
+    /** \returns a reference to the coefficient at given index.
+      *
+      * This is synonymous to operator[](Index).
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    operator()(Index index)
+    {
+      eigen_assert(index >= 0 && index < size());
+      return coeffRef(index);
+    }
+
+    /** equivalent to operator[](0).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    x() { return (*this)[0]; }
+
+    /** equivalent to operator[](1).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    y()
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=2, OUT_OF_RANGE_ACCESS);
+      return (*this)[1];
+    }
+
+    /** equivalent to operator[](2).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    z()
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=3, OUT_OF_RANGE_ACCESS);
+      return (*this)[2];
+    }
+
+    /** equivalent to operator[](3).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    w()
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS);
+      return (*this)[3];
+    }
+};
+
+/** \brief Base class providing direct read-only coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  *
+  * \note #DirectAccessors Constant indicating direct access
+  *
+  * This class defines functions to work with strides which can be used to access entries directly. This class
+  * inherits DenseCoeffsBase<Derived, ReadOnlyAccessors> which defines functions to access entries read-only using
+  * \c operator() .
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
+{
+  public:
+
+    typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+
+    /** \returns the pointer increment between two consecutive elements within a slice in the inner direction.
+      *
+      * \sa outerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const
+    {
+      return derived().innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns
+      *          in a column-major matrix).
+      *
+      * \sa innerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const
+    {
+      return derived().outerStride();
+    }
+
+    // FIXME shall we remove it ?
+    EIGEN_CONSTEXPR inline Index stride() const
+    {
+      return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive rows.
+      *
+      * \sa innerStride(), outerStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rowStride() const
+    {
+      return Derived::IsRowMajor ? outerStride() : innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive columns.
+      *
+      * \sa innerStride(), outerStride(), rowStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index colStride() const
+    {
+      return Derived::IsRowMajor ? innerStride() : outerStride();
+    }
+};
+
+/** \brief Base class providing direct read/write coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  *
+  * \note #DirectWriteAccessors Constant indicating direct access
+  *
+  * This class defines functions to work with strides which can be used to access entries directly. This class
+  * inherits DenseCoeffsBase<Derived, WriteAccessors> which defines functions to access entries read/write using
+  * \c operator().
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived, DirectWriteAccessors>
+  : public DenseCoeffsBase<Derived, WriteAccessors>
+{
+  public:
+
+    typedef DenseCoeffsBase<Derived, WriteAccessors> Base;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+
+    /** \returns the pointer increment between two consecutive elements within a slice in the inner direction.
+      *
+      * \sa outerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT
+    {
+      return derived().innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns
+      *          in a column-major matrix).
+      *
+      * \sa innerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT
+    {
+      return derived().outerStride();
+    }
+
+    // FIXME shall we remove it ?
+    EIGEN_CONSTEXPR inline Index stride() const EIGEN_NOEXCEPT
+    {
+      return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive rows.
+      *
+      * \sa innerStride(), outerStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rowStride() const EIGEN_NOEXCEPT
+    {
+      return Derived::IsRowMajor ? outerStride() : innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive columns.
+      *
+      * \sa innerStride(), outerStride(), rowStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index colStride() const EIGEN_NOEXCEPT
+    {
+      return Derived::IsRowMajor ? innerStride() : outerStride();
+    }
+};
+
+namespace internal {
+
+template<int Alignment, typename Derived, bool JustReturnZero>
+struct first_aligned_impl
+{
+  static EIGEN_CONSTEXPR inline Index run(const Derived&) EIGEN_NOEXCEPT
+  { return 0; }
+};
+
+template<int Alignment, typename Derived>
+struct first_aligned_impl<Alignment, Derived, false>
+{
+  static inline Index run(const Derived& m)
+  {
+    return internal::first_aligned<Alignment>(m.data(), m.size());
+  }
+};
+
+/** \internal \returns the index of the first element of the array stored by \a m that is properly aligned with respect to \a Alignment for vectorization.
+  *
+  * \tparam Alignment requested alignment in Bytes.
+  *
+  * There is also the variant first_aligned(const Scalar*, Integer) defined in Memory.h. See it for more
+  * documentation.
+  */
+template<int Alignment, typename Derived>
+static inline Index first_aligned(const DenseBase<Derived>& m)
+{
+  enum { ReturnZero = (int(evaluator<Derived>::Alignment) >= Alignment) || !(Derived::Flags & DirectAccessBit) };
+  return first_aligned_impl<Alignment, Derived, ReturnZero>::run(m.derived());
+}
+
+template<typename Derived>
+static inline Index first_default_aligned(const DenseBase<Derived>& m)
+{
+  typedef typename Derived::Scalar Scalar;
+  typedef typename packet_traits<Scalar>::type DefaultPacketType;
+  return internal::first_aligned<int(unpacket_traits<DefaultPacketType>::alignment),Derived>(m);
+}
+
+template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
+struct inner_stride_at_compile_time
+{
+  enum { ret = traits<Derived>::InnerStrideAtCompileTime };
+};
+
+template<typename Derived>
+struct inner_stride_at_compile_time<Derived, false>
+{
+  enum { ret = 0 };
+};
+
+template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
+struct outer_stride_at_compile_time
+{
+  enum { ret = traits<Derived>::OuterStrideAtCompileTime };
+};
+
+template<typename Derived>
+struct outer_stride_at_compile_time<Derived, false>
+{
+  enum { ret = 0 };
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_DENSECOEFFSBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/DenseStorage.h b/C++/yolo_bytetrack/include/Eigen/src/Core/DenseStorage.h
new file mode 100644
index 00000000..08ef6c53
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/DenseStorage.h
@@ -0,0 +1,652 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2010-2013 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIXSTORAGE_H
+#define EIGEN_MATRIXSTORAGE_H
+
+#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+  #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X) X; EIGEN_DENSE_STORAGE_CTOR_PLUGIN;
+#else
+  #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X)
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+struct constructor_without_unaligned_array_assert {};
+
+template<typename T, int Size>
+EIGEN_DEVICE_FUNC
+void check_static_allocation_size()
+{
+  // if EIGEN_STACK_ALLOCATION_LIMIT is defined to 0, then no limit
+  #if EIGEN_STACK_ALLOCATION_LIMIT
+  EIGEN_STATIC_ASSERT(Size * sizeof(T) <= EIGEN_STACK_ALLOCATION_LIMIT, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG);
+  #endif
+}
+
+/** \internal
+  * Static array. If the MatrixOrArrayOptions require auto-alignment, the array will be automatically aligned:
+  * to 16 bytes boundary if the total size is a multiple of 16 bytes.
+  */
+template <typename T, int Size, int MatrixOrArrayOptions,
+          int Alignment = (MatrixOrArrayOptions&DontAlign) ? 0
+                        : compute_default_alignment<T,Size>::value >
+struct plain_array
+{
+  T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  {
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  {
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+#if defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT)
+  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask)
+#elif EIGEN_GNUC_AT_LEAST(4,7)
+  // GCC 4.7 is too aggressive in its optimizations and remove the alignment test based on the fact the array is declared to be aligned.
+  // See this bug report: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53900
+  // Hiding the origin of the array pointer behind a function argument seems to do the trick even if the function is inlined:
+  template<typename PtrType>
+  EIGEN_ALWAYS_INLINE PtrType eigen_unaligned_array_assert_workaround_gcc47(PtrType array) { return array; }
+  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \
+    eigen_assert((internal::UIntPtr(eigen_unaligned_array_assert_workaround_gcc47(array)) & (sizemask)) == 0 \
+              && "this assertion is explained here: " \
+              "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \
+              " **** READ THIS WEB PAGE !!! ****");
+#else
+  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \
+    eigen_assert((internal::UIntPtr(array) & (sizemask)) == 0 \
+              && "this assertion is explained here: " \
+              "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \
+              " **** READ THIS WEB PAGE !!! ****");
+#endif
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 8>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(8) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  {
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(7);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  {
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 16>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(16) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  {
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(15);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  {
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 32>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(32) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  {
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(31);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  {
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 64>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(64) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  {
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(63);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  {
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int MatrixOrArrayOptions, int Alignment>
+struct plain_array<T, 0, MatrixOrArrayOptions, Alignment>
+{
+  T array[1];
+  EIGEN_DEVICE_FUNC plain_array() {}
+  EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert) {}
+};
+
+struct plain_array_helper {
+  template<typename T, int Size, int MatrixOrArrayOptions, int Alignment>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  static void copy(const plain_array<T, Size, MatrixOrArrayOptions, Alignment>& src, const Eigen::Index size,
+                         plain_array<T, Size, MatrixOrArrayOptions, Alignment>& dst) {
+    smart_copy(src.array, src.array + size, dst.array);
+  }
+  
+  template<typename T, int Size, int MatrixOrArrayOptions, int Alignment>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  static void swap(plain_array<T, Size, MatrixOrArrayOptions, Alignment>& a, const Eigen::Index a_size,
+                   plain_array<T, Size, MatrixOrArrayOptions, Alignment>& b, const Eigen::Index b_size) {
+    if (a_size < b_size) {
+      std::swap_ranges(b.array, b.array + a_size, a.array);
+      smart_move(b.array + a_size, b.array + b_size, a.array + a_size);
+    } else if (a_size > b_size) {
+      std::swap_ranges(a.array, a.array + b_size, b.array);
+      smart_move(a.array + b_size, a.array + a_size, b.array + b_size);
+    } else {
+      std::swap_ranges(a.array, a.array + a_size, b.array);
+    }
+  }
+};
+
+} // end namespace internal
+
+/** \internal
+  *
+  * \class DenseStorage
+  * \ingroup Core_Module
+  *
+  * \brief Stores the data of a matrix
+  *
+  * This class stores the data of fixed-size, dynamic-size or mixed matrices
+  * in a way as compact as possible.
+  *
+  * \sa Matrix
+  */
+template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage;
+
+// purely fixed-size matrix
+template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage
+{
+    internal::plain_array<T,Size,_Options> m_data;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size)
+    }
+    EIGEN_DEVICE_FUNC
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()) {}
+#if !EIGEN_HAS_CXX11 || defined(EIGEN_DENSE_STORAGE_CTOR_PLUGIN)
+    EIGEN_DEVICE_FUNC
+    DenseStorage(const DenseStorage& other) : m_data(other.m_data) {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size)
+    }
+#else
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) = default;
+#endif
+#if !EIGEN_HAS_CXX11
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other) m_data = other.m_data;
+      return *this;
+    }
+#else
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage&) = default;
+#endif
+#if EIGEN_HAS_RVALUE_REFERENCES
+#if !EIGEN_HAS_CXX11
+    EIGEN_DEVICE_FUNC DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+    {
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      if (this != &other)
+        m_data = std::move(other.m_data);
+      return *this;
+    }
+#else
+    EIGEN_DEVICE_FUNC DenseStorage(DenseStorage&&) = default;
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(DenseStorage&&) = default;
+#endif
+#endif
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows==_Rows && cols==_Cols);
+      EIGEN_UNUSED_VARIABLE(size);
+      EIGEN_UNUSED_VARIABLE(rows);
+      EIGEN_UNUSED_VARIABLE(cols);
+    }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) {
+      numext::swap(m_data, other.m_data);
+    }
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index rows(void) EIGEN_NOEXCEPT {return _Rows;}
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index cols(void) EIGEN_NOEXCEPT {return _Cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// null matrix
+template<typename T, int _Rows, int _Cols, int _Options> class DenseStorage<T, 0, _Rows, _Cols, _Options>
+{
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) {}
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage&) { return *this; }
+    EIGEN_DEVICE_FUNC DenseStorage(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& ) {}
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index rows(void) EIGEN_NOEXCEPT {return _Rows;}
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index cols(void) EIGEN_NOEXCEPT {return _Cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC const T *data() const { return 0; }
+    EIGEN_DEVICE_FUNC T *data() { return 0; }
+};
+
+// more specializations for null matrices; these are necessary to resolve ambiguities
+template<typename T, int _Options> class DenseStorage<T, 0, Dynamic, Dynamic, _Options>
+: public DenseStorage<T, 0, 0, 0, _Options> { };
+
+template<typename T, int _Rows, int _Options> class DenseStorage<T, 0, _Rows, Dynamic, _Options>
+: public DenseStorage<T, 0, 0, 0, _Options> { };
+
+template<typename T, int _Cols, int _Options> class DenseStorage<T, 0, Dynamic, _Cols, _Options>
+: public DenseStorage<T, 0, 0, 0, _Options> { };
+
+// dynamic-size matrix with fixed-size storage
+template<typename T, int Size, int _Options> class DenseStorage<T, Size, Dynamic, Dynamic, _Options>
+{
+    internal::plain_array<T,Size,_Options> m_data;
+    Index m_rows;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(other.m_rows), m_cols(other.m_cols)
+    {
+      internal::plain_array_helper::copy(other.m_data, m_rows * m_cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        m_rows = other.m_rows;
+        m_cols = other.m_cols;
+        internal::plain_array_helper::copy(other.m_data, m_rows * m_cols, m_data);
+      }
+      return *this;
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(rows), m_cols(cols) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other)
+    {
+      internal::plain_array_helper::swap(m_data, m_rows * m_cols, other.m_data, other.m_rows * other.m_cols);
+      numext::swap(m_rows,other.m_rows);
+      numext::swap(m_cols,other.m_cols);
+    }
+    EIGEN_DEVICE_FUNC Index rows() const {return m_rows;}
+    EIGEN_DEVICE_FUNC Index cols() const {return m_cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; }
+    EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// dynamic-size matrix with fixed-size storage and fixed width
+template<typename T, int Size, int _Cols, int _Options> class DenseStorage<T, Size, Dynamic, _Cols, _Options>
+{
+    internal::plain_array<T,Size,_Options> m_data;
+    Index m_rows;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(other.m_rows)
+    {
+      internal::plain_array_helper::copy(other.m_data, m_rows * _Cols, m_data);
+    }
+    
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        m_rows = other.m_rows;
+        internal::plain_array_helper::copy(other.m_data, m_rows * _Cols, m_data);
+      }
+      return *this;
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other)
+    { 
+      internal::plain_array_helper::swap(m_data, m_rows * _Cols, other.m_data, other.m_rows * _Cols);
+      numext::swap(m_rows, other.m_rows);
+    }
+    EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT {return m_rows;}
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols(void) const EIGEN_NOEXCEPT {return _Cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index) { m_rows = rows; }
+    EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index) { m_rows = rows; }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// dynamic-size matrix with fixed-size storage and fixed height
+template<typename T, int Size, int _Rows, int _Options> class DenseStorage<T, Size, _Rows, Dynamic, _Options>
+{
+    internal::plain_array<T,Size,_Options> m_data;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_cols(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) 
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(other.m_cols)
+    {
+      internal::plain_array_helper::copy(other.m_data, _Rows * m_cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        m_cols = other.m_cols;
+        internal::plain_array_helper::copy(other.m_data, _Rows * m_cols, m_data);
+      }
+      return *this;
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) {
+      internal::plain_array_helper::swap(m_data, _Rows * m_cols, other.m_data, _Rows * other.m_cols);
+      numext::swap(m_cols, other.m_cols);
+    }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows(void) const EIGEN_NOEXCEPT {return _Rows;}
+    EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT {return m_cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index, Index, Index cols) { m_cols = cols; }
+    EIGEN_DEVICE_FUNC void resize(Index, Index, Index cols) { m_cols = cols; }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// purely dynamic matrix.
+template<typename T, int _Options> class DenseStorage<T, Dynamic, Dynamic, Dynamic, _Options>
+{
+    T *m_data;
+    Index m_rows;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+       : m_data(0), m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_rows(rows), m_cols(cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows>=0 && cols >=0);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(other.m_rows*other.m_cols))
+      , m_rows(other.m_rows)
+      , m_cols(other.m_cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_rows*m_cols)
+      internal::smart_copy(other.m_data, other.m_data+other.m_rows*other.m_cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        DenseStorage tmp(other);
+        this->swap(tmp);
+      }
+      return *this;
+    }
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+      , m_rows(std::move(other.m_rows))
+      , m_cols(std::move(other.m_cols))
+    {
+      other.m_data = nullptr;
+      other.m_rows = 0;
+      other.m_cols = 0;
+    }
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      numext::swap(m_data, other.m_data);
+      numext::swap(m_rows, other.m_rows);
+      numext::swap(m_cols, other.m_cols);
+      return *this;
+    }
+#endif
+    EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols); }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other)
+    {
+      numext::swap(m_data,other.m_data);
+      numext::swap(m_rows,other.m_rows);
+      numext::swap(m_cols,other.m_cols);
+    }
+    EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT {return m_rows;}
+    EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT {return m_cols;}
+    void conservativeResize(Index size, Index rows, Index cols)
+    {
+      m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, m_rows*m_cols);
+      m_rows = rows;
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
+    {
+      if(size != m_rows*m_cols)
+      {
+        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
+        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
+          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
+        else
+          m_data = 0;
+        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      }
+      m_rows = rows;
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data; }
+};
+
+// matrix with dynamic width and fixed height (so that matrix has dynamic size).
+template<typename T, int _Rows, int _Options> class DenseStorage<T, Dynamic, _Rows, Dynamic, _Options>
+{
+    T *m_data;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_cols(0) {}
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_cols(cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows==_Rows && cols >=0);
+      EIGEN_UNUSED_VARIABLE(rows);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(_Rows*other.m_cols))
+      , m_cols(other.m_cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_cols*_Rows)
+      internal::smart_copy(other.m_data, other.m_data+_Rows*m_cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        DenseStorage tmp(other);
+        this->swap(tmp);
+      }
+      return *this;
+    }
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+      , m_cols(std::move(other.m_cols))
+    {
+      other.m_data = nullptr;
+      other.m_cols = 0;
+    }
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      numext::swap(m_data, other.m_data);
+      numext::swap(m_cols, other.m_cols);
+      return *this;
+    }
+#endif
+    EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols); }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) {
+      numext::swap(m_data,other.m_data);
+      numext::swap(m_cols,other.m_cols);
+    }
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index rows(void) EIGEN_NOEXCEPT {return _Rows;}
+    EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT {return m_cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols)
+    {
+      m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, _Rows*m_cols);
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols)
+    {
+      if(size != _Rows*m_cols)
+      {
+        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols);
+        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
+          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
+        else
+          m_data = 0;
+        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      }
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data; }
+};
+
+// matrix with dynamic height and fixed width (so that matrix has dynamic size).
+template<typename T, int _Cols, int _Options> class DenseStorage<T, Dynamic, Dynamic, _Cols, _Options>
+{
+    T *m_data;
+    Index m_rows;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0) {}
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_rows(rows)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows>=0 && cols == _Cols);
+      EIGEN_UNUSED_VARIABLE(cols);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(other.m_rows*_Cols))
+      , m_rows(other.m_rows)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_rows*_Cols)
+      internal::smart_copy(other.m_data, other.m_data+other.m_rows*_Cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        DenseStorage tmp(other);
+        this->swap(tmp);
+      }
+      return *this;
+    }
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+      , m_rows(std::move(other.m_rows))
+    {
+      other.m_data = nullptr;
+      other.m_rows = 0;
+    }
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      numext::swap(m_data, other.m_data);
+      numext::swap(m_rows, other.m_rows);
+      return *this;
+    }
+#endif
+    EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows); }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) {
+      numext::swap(m_data,other.m_data);
+      numext::swap(m_rows,other.m_rows);
+    }
+    EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT {return m_rows;}
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index cols(void) {return _Cols;}
+    void conservativeResize(Index size, Index rows, Index)
+    {
+      m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, m_rows*_Cols);
+      m_rows = rows;
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index)
+    {
+      if(size != m_rows*_Cols)
+      {
+        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows);
+        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
+          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
+        else
+          m_data = 0;
+        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      }
+      m_rows = rows;
+    }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data; }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Diagonal.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Diagonal.h
new file mode 100644
index 00000000..3112d2c1
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Diagonal.h
@@ -0,0 +1,258 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DIAGONAL_H
+#define EIGEN_DIAGONAL_H
+
+namespace Eigen {
+
+/** \class Diagonal
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a diagonal/subdiagonal/superdiagonal in a matrix
+  *
+  * \param MatrixType the type of the object in which we are taking a sub/main/super diagonal
+  * \param DiagIndex the index of the sub/super diagonal. The default is 0 and it means the main diagonal.
+  *              A positive value means a superdiagonal, a negative value means a subdiagonal.
+  *              You can also use DynamicIndex so the index can be set at runtime.
+  *
+  * The matrix is not required to be square.
+  *
+  * This class represents an expression of the main diagonal, or any sub/super diagonal
+  * of a square matrix. It is the return type of MatrixBase::diagonal() and MatrixBase::diagonal(Index) and most of the
+  * time this is the only way it is used.
+  *
+  * \sa MatrixBase::diagonal(), MatrixBase::diagonal(Index)
+  */
+
+namespace internal {
+template<typename MatrixType, int DiagIndex>
+struct traits<Diagonal<MatrixType,DiagIndex> >
+ : traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  typedef typename MatrixType::StorageKind StorageKind;
+  enum {
+    RowsAtCompileTime = (int(DiagIndex) == DynamicIndex || int(MatrixType::SizeAtCompileTime) == Dynamic) ? Dynamic
+                      : (EIGEN_PLAIN_ENUM_MIN(MatrixType::RowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0),
+                                              MatrixType::ColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))),
+    ColsAtCompileTime = 1,
+    MaxRowsAtCompileTime = int(MatrixType::MaxSizeAtCompileTime) == Dynamic ? Dynamic
+                         : DiagIndex == DynamicIndex ? EIGEN_SIZE_MIN_PREFER_FIXED(MatrixType::MaxRowsAtCompileTime,
+                                                                              MatrixType::MaxColsAtCompileTime)
+                         : (EIGEN_PLAIN_ENUM_MIN(MatrixType::MaxRowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0),
+                                                 MatrixType::MaxColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))),
+    MaxColsAtCompileTime = 1,
+    MaskLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags = (unsigned int)_MatrixTypeNested::Flags & (RowMajorBit | MaskLvalueBit | DirectAccessBit) & ~RowMajorBit, // FIXME DirectAccessBit should not be handled by expressions
+    MatrixTypeOuterStride = outer_stride_at_compile_time<MatrixType>::ret,
+    InnerStrideAtCompileTime = MatrixTypeOuterStride == Dynamic ? Dynamic : MatrixTypeOuterStride+1,
+    OuterStrideAtCompileTime = 0
+  };
+};
+}
+
+template<typename MatrixType, int _DiagIndex> class Diagonal
+   : public internal::dense_xpr_base< Diagonal<MatrixType,_DiagIndex> >::type
+{
+  public:
+
+    enum { DiagIndex = _DiagIndex };
+    typedef typename internal::dense_xpr_base<Diagonal>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Diagonal)
+
+    EIGEN_DEVICE_FUNC
+    explicit inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) : m_matrix(matrix), m_index(a_index)
+    {
+      eigen_assert( a_index <= m_matrix.cols() && -a_index <= m_matrix.rows() );
+    }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Diagonal)
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const
+    {
+      return m_index.value()<0 ? numext::mini<Index>(m_matrix.cols(),m_matrix.rows()+m_index.value())
+                               : numext::mini<Index>(m_matrix.rows(),m_matrix.cols()-m_index.value());
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return 1; }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT {
+      return m_matrix.outerStride() + 1;
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return 0; }
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<MatrixType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return &(m_matrix.coeffRef(rowOffset(), colOffset())); }
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return &(m_matrix.coeffRef(rowOffset(), colOffset())); }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      return m_matrix.coeffRef(row+rowOffset(), row+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index row, Index) const
+    {
+      return m_matrix.coeffRef(row+rowOffset(), row+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline CoeffReturnType coeff(Index row, Index) const
+    {
+      return m_matrix.coeff(row+rowOffset(), row+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index idx)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      return m_matrix.coeffRef(idx+rowOffset(), idx+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index idx) const
+    {
+      return m_matrix.coeffRef(idx+rowOffset(), idx+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline CoeffReturnType coeff(Index idx) const
+    {
+      return m_matrix.coeff(idx+rowOffset(), idx+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const typename internal::remove_all<typename MatrixType::Nested>::type&
+    nestedExpression() const
+    {
+      return m_matrix;
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Index index() const
+    {
+      return m_index.value();
+    }
+
+  protected:
+    typename internal::ref_selector<MatrixType>::non_const_type m_matrix;
+    const internal::variable_if_dynamicindex<Index, DiagIndex> m_index;
+
+  private:
+    // some compilers may fail to optimize std::max etc in case of compile-time constants...
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index absDiagIndex() const EIGEN_NOEXCEPT { return m_index.value()>0 ? m_index.value() : -m_index.value(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rowOffset() const EIGEN_NOEXCEPT { return m_index.value()>0 ? 0 : -m_index.value(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index colOffset() const EIGEN_NOEXCEPT { return m_index.value()>0 ? m_index.value() : 0; }
+    // trigger a compile-time error if someone try to call packet
+    template<int LoadMode> typename MatrixType::PacketReturnType packet(Index) const;
+    template<int LoadMode> typename MatrixType::PacketReturnType packet(Index,Index) const;
+};
+
+/** \returns an expression of the main diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * Example: \include MatrixBase_diagonal.cpp
+  * Output: \verbinclude MatrixBase_diagonal.out
+  *
+  * \sa class Diagonal */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::DiagonalReturnType
+MatrixBase<Derived>::diagonal()
+{
+  return DiagonalReturnType(derived());
+}
+
+/** This is the const version of diagonal(). */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::ConstDiagonalReturnType
+MatrixBase<Derived>::diagonal() const
+{
+  return ConstDiagonalReturnType(derived());
+}
+
+/** \returns an expression of the \a DiagIndex-th sub or super diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * The template parameter \a DiagIndex represent a super diagonal if \a DiagIndex > 0
+  * and a sub diagonal otherwise. \a DiagIndex == 0 is equivalent to the main diagonal.
+  *
+  * Example: \include MatrixBase_diagonal_int.cpp
+  * Output: \verbinclude MatrixBase_diagonal_int.out
+  *
+  * \sa MatrixBase::diagonal(), class Diagonal */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::DiagonalDynamicIndexReturnType
+MatrixBase<Derived>::diagonal(Index index)
+{
+  return DiagonalDynamicIndexReturnType(derived(), index);
+}
+
+/** This is the const version of diagonal(Index). */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::ConstDiagonalDynamicIndexReturnType
+MatrixBase<Derived>::diagonal(Index index) const
+{
+  return ConstDiagonalDynamicIndexReturnType(derived(), index);
+}
+
+/** \returns an expression of the \a DiagIndex-th sub or super diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * The template parameter \a DiagIndex represent a super diagonal if \a DiagIndex > 0
+  * and a sub diagonal otherwise. \a DiagIndex == 0 is equivalent to the main diagonal.
+  *
+  * Example: \include MatrixBase_diagonal_template_int.cpp
+  * Output: \verbinclude MatrixBase_diagonal_template_int.out
+  *
+  * \sa MatrixBase::diagonal(), class Diagonal */
+template<typename Derived>
+template<int Index_>
+EIGEN_DEVICE_FUNC
+inline typename MatrixBase<Derived>::template DiagonalIndexReturnType<Index_>::Type
+MatrixBase<Derived>::diagonal()
+{
+  return typename DiagonalIndexReturnType<Index_>::Type(derived());
+}
+
+/** This is the const version of diagonal<int>(). */
+template<typename Derived>
+template<int Index_>
+EIGEN_DEVICE_FUNC
+inline typename MatrixBase<Derived>::template ConstDiagonalIndexReturnType<Index_>::Type
+MatrixBase<Derived>::diagonal() const
+{
+  return typename ConstDiagonalIndexReturnType<Index_>::Type(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DIAGONAL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/DiagonalMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/Core/DiagonalMatrix.h
new file mode 100644
index 00000000..542685c6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/DiagonalMatrix.h
@@ -0,0 +1,391 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DIAGONALMATRIX_H
+#define EIGEN_DIAGONALMATRIX_H
+
+namespace Eigen { 
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename Derived>
+class DiagonalBase : public EigenBase<Derived>
+{
+  public:
+    typedef typename internal::traits<Derived>::DiagonalVectorType DiagonalVectorType;
+    typedef typename DiagonalVectorType::Scalar Scalar;
+    typedef typename DiagonalVectorType::RealScalar RealScalar;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+
+    enum {
+      RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+      ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+      MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+      MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+      IsVectorAtCompileTime = 0,
+      Flags = NoPreferredStorageOrderBit
+    };
+
+    typedef Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime> DenseMatrixType;
+    typedef DenseMatrixType DenseType;
+    typedef DiagonalMatrix<Scalar,DiagonalVectorType::SizeAtCompileTime,DiagonalVectorType::MaxSizeAtCompileTime> PlainObject;
+
+    EIGEN_DEVICE_FUNC
+    inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    EIGEN_DEVICE_FUNC
+    inline Derived& derived() { return *static_cast<Derived*>(this); }
+
+    EIGEN_DEVICE_FUNC
+    DenseMatrixType toDenseMatrix() const { return derived(); }
+
+    EIGEN_DEVICE_FUNC
+    inline const DiagonalVectorType& diagonal() const { return derived().diagonal(); }
+    EIGEN_DEVICE_FUNC
+    inline DiagonalVectorType& diagonal() { return derived().diagonal(); }
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const { return diagonal().size(); }
+    EIGEN_DEVICE_FUNC
+    inline Index cols() const { return diagonal().size(); }
+
+    template<typename MatrixDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived,MatrixDerived,LazyProduct>
+    operator*(const MatrixBase<MatrixDerived> &matrix) const
+    {
+      return Product<Derived, MatrixDerived, LazyProduct>(derived(),matrix.derived());
+    }
+
+    typedef DiagonalWrapper<const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const DiagonalVectorType> > InverseReturnType;
+    EIGEN_DEVICE_FUNC
+    inline const InverseReturnType
+    inverse() const
+    {
+      return InverseReturnType(diagonal().cwiseInverse());
+    }
+    
+    EIGEN_DEVICE_FUNC
+    inline const DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType,Scalar,product) >
+    operator*(const Scalar& scalar) const
+    {
+      return DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType,Scalar,product) >(diagonal() * scalar);
+    }
+    EIGEN_DEVICE_FUNC
+    friend inline const DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,DiagonalVectorType,product) >
+    operator*(const Scalar& scalar, const DiagonalBase& other)
+    {
+      return DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,DiagonalVectorType,product) >(scalar * other.diagonal());
+    }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    inline unspecified_expression_type
+    #else
+    inline const DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(DiagonalVectorType,typename OtherDerived::DiagonalVectorType,sum) >
+    #endif
+    operator+(const DiagonalBase<OtherDerived>& other) const
+    {
+      return (diagonal() + other.diagonal()).asDiagonal();
+    }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    inline unspecified_expression_type
+    #else
+    inline const DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(DiagonalVectorType,typename OtherDerived::DiagonalVectorType,difference) >
+    #endif
+    operator-(const DiagonalBase<OtherDerived>& other) const
+    {
+      return (diagonal() - other.diagonal()).asDiagonal();
+    }
+};
+
+#endif
+
+/** \class DiagonalMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Represents a diagonal matrix with its storage
+  *
+  * \param _Scalar the type of coefficients
+  * \param SizeAtCompileTime the dimension of the matrix, or Dynamic
+  * \param MaxSizeAtCompileTime the dimension of the matrix, or Dynamic. This parameter is optional and defaults
+  *        to SizeAtCompileTime. Most of the time, you do not need to specify it.
+  *
+  * \sa class DiagonalWrapper
+  */
+
+namespace internal {
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
+struct traits<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
+ : traits<Matrix<_Scalar,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  typedef Matrix<_Scalar,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1> DiagonalVectorType;
+  typedef DiagonalShape StorageKind;
+  enum {
+    Flags = LvalueBit | NoPreferredStorageOrderBit
+  };
+};
+}
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
+class DiagonalMatrix
+  : public DiagonalBase<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  public:
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename internal::traits<DiagonalMatrix>::DiagonalVectorType DiagonalVectorType;
+    typedef const DiagonalMatrix& Nested;
+    typedef _Scalar Scalar;
+    typedef typename internal::traits<DiagonalMatrix>::StorageKind StorageKind;
+    typedef typename internal::traits<DiagonalMatrix>::StorageIndex StorageIndex;
+    #endif
+
+  protected:
+
+    DiagonalVectorType m_diagonal;
+
+  public:
+
+    /** const version of diagonal(). */
+    EIGEN_DEVICE_FUNC
+    inline const DiagonalVectorType& diagonal() const { return m_diagonal; }
+    /** \returns a reference to the stored vector of diagonal coefficients. */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalVectorType& diagonal() { return m_diagonal; }
+
+    /** Default constructor without initialization */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix() {}
+
+    /** Constructs a diagonal matrix with given dimension  */
+    EIGEN_DEVICE_FUNC
+    explicit inline DiagonalMatrix(Index dim) : m_diagonal(dim) {}
+
+    /** 2D constructor. */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix(const Scalar& x, const Scalar& y) : m_diagonal(x,y) {}
+
+    /** 3D constructor. */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix(const Scalar& x, const Scalar& y, const Scalar& z) : m_diagonal(x,y,z) {}
+
+    #if EIGEN_HAS_CXX11
+    /** \brief Construct a diagonal matrix with fixed size from an arbitrary number of coefficients. \cpp11
+      * 
+      * There exists C++98 anologue constructors for fixed-size diagonal matrices having 2 or 3 coefficients.
+      * 
+      * \warning To construct a diagonal matrix of fixed size, the number of values passed to this 
+      * constructor must match the fixed dimension of \c *this.
+      * 
+      * \sa DiagonalMatrix(const Scalar&, const Scalar&)
+      * \sa DiagonalMatrix(const Scalar&, const Scalar&, const Scalar&)
+      */
+    template <typename... ArgTypes>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    DiagonalMatrix(const Scalar& a0, const Scalar& a1, const Scalar& a2, const ArgTypes&... args)
+      : m_diagonal(a0, a1, a2, args...) {}
+
+    /** \brief Constructs a DiagonalMatrix and initializes it by elements given by an initializer list of initializer
+      * lists \cpp11
+      */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE DiagonalMatrix(const std::initializer_list<std::initializer_list<Scalar>>& list)
+      : m_diagonal(list) {}
+    #endif  // EIGEN_HAS_CXX11
+
+    /** Copy constructor. */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix(const DiagonalBase<OtherDerived>& other) : m_diagonal(other.diagonal()) {}
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** copy constructor. prevent a default copy constructor from hiding the other templated constructor */
+    inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.diagonal()) {}
+    #endif
+
+    /** generic constructor from expression of the diagonal coefficients */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    explicit inline DiagonalMatrix(const MatrixBase<OtherDerived>& other) : m_diagonal(other)
+    {}
+
+    /** Copy operator. */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    DiagonalMatrix& operator=(const DiagonalBase<OtherDerived>& other)
+    {
+      m_diagonal = other.diagonal();
+      return *this;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    DiagonalMatrix& operator=(const DiagonalMatrix& other)
+    {
+      m_diagonal = other.diagonal();
+      return *this;
+    }
+    #endif
+
+    /** Resizes to given size. */
+    EIGEN_DEVICE_FUNC
+    inline void resize(Index size) { m_diagonal.resize(size); }
+    /** Sets all coefficients to zero. */
+    EIGEN_DEVICE_FUNC
+    inline void setZero() { m_diagonal.setZero(); }
+    /** Resizes and sets all coefficients to zero. */
+    EIGEN_DEVICE_FUNC
+    inline void setZero(Index size) { m_diagonal.setZero(size); }
+    /** Sets this matrix to be the identity matrix of the current size. */
+    EIGEN_DEVICE_FUNC
+    inline void setIdentity() { m_diagonal.setOnes(); }
+    /** Sets this matrix to be the identity matrix of the given size. */
+    EIGEN_DEVICE_FUNC
+    inline void setIdentity(Index size) { m_diagonal.setOnes(size); }
+};
+
+/** \class DiagonalWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a diagonal matrix
+  *
+  * \param _DiagonalVectorType the type of the vector of diagonal coefficients
+  *
+  * This class is an expression of a diagonal matrix, but not storing its own vector of diagonal coefficients,
+  * instead wrapping an existing vector expression. It is the return type of MatrixBase::asDiagonal()
+  * and most of the time this is the only way that it is used.
+  *
+  * \sa class DiagonalMatrix, class DiagonalBase, MatrixBase::asDiagonal()
+  */
+
+namespace internal {
+template<typename _DiagonalVectorType>
+struct traits<DiagonalWrapper<_DiagonalVectorType> >
+{
+  typedef _DiagonalVectorType DiagonalVectorType;
+  typedef typename DiagonalVectorType::Scalar Scalar;
+  typedef typename DiagonalVectorType::StorageIndex StorageIndex;
+  typedef DiagonalShape StorageKind;
+  typedef typename traits<DiagonalVectorType>::XprKind XprKind;
+  enum {
+    RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+    ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+    MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+    MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+    Flags =  (traits<DiagonalVectorType>::Flags & LvalueBit) | NoPreferredStorageOrderBit
+  };
+};
+}
+
+template<typename _DiagonalVectorType>
+class DiagonalWrapper
+  : public DiagonalBase<DiagonalWrapper<_DiagonalVectorType> >, internal::no_assignment_operator
+{
+  public:
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef _DiagonalVectorType DiagonalVectorType;
+    typedef DiagonalWrapper Nested;
+    #endif
+
+    /** Constructor from expression of diagonal coefficients to wrap. */
+    EIGEN_DEVICE_FUNC
+    explicit inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_diagonal) {}
+
+    /** \returns a const reference to the wrapped expression of diagonal coefficients. */
+    EIGEN_DEVICE_FUNC
+    const DiagonalVectorType& diagonal() const { return m_diagonal; }
+
+  protected:
+    typename DiagonalVectorType::Nested m_diagonal;
+};
+
+/** \returns a pseudo-expression of a diagonal matrix with *this as vector of diagonal coefficients
+  *
+  * \only_for_vectors
+  *
+  * Example: \include MatrixBase_asDiagonal.cpp
+  * Output: \verbinclude MatrixBase_asDiagonal.out
+  *
+  * \sa class DiagonalWrapper, class DiagonalMatrix, diagonal(), isDiagonal()
+  **/
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const DiagonalWrapper<const Derived>
+MatrixBase<Derived>::asDiagonal() const
+{
+  return DiagonalWrapper<const Derived>(derived());
+}
+
+/** \returns true if *this is approximately equal to a diagonal matrix,
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isDiagonal.cpp
+  * Output: \verbinclude MatrixBase_isDiagonal.out
+  *
+  * \sa asDiagonal()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isDiagonal(const RealScalar& prec) const
+{
+  if(cols() != rows()) return false;
+  RealScalar maxAbsOnDiagonal = static_cast<RealScalar>(-1);
+  for(Index j = 0; j < cols(); ++j)
+  {
+    RealScalar absOnDiagonal = numext::abs(coeff(j,j));
+    if(absOnDiagonal > maxAbsOnDiagonal) maxAbsOnDiagonal = absOnDiagonal;
+  }
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = 0; i < j; ++i)
+    {
+      if(!internal::isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false;
+      if(!internal::isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false;
+    }
+  return true;
+}
+
+namespace internal {
+
+template<> struct storage_kind_to_shape<DiagonalShape> { typedef DiagonalShape Shape; };
+
+struct Diagonal2Dense {};
+
+template<> struct AssignmentKind<DenseShape,DiagonalShape> { typedef Diagonal2Dense Kind; };
+
+// Diagonal matrix to Dense assignment
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Dense>
+{
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    
+    dst.setZero();
+    dst.diagonal() = src.diagonal();
+  }
+  
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.diagonal() += src.diagonal(); }
+  
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.diagonal() -= src.diagonal(); }
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_DIAGONALMATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/DiagonalProduct.h b/C++/yolo_bytetrack/include/Eigen/src/Core/DiagonalProduct.h
new file mode 100644
index 00000000..7911d1cd
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/DiagonalProduct.h
@@ -0,0 +1,28 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DIAGONALPRODUCT_H
+#define EIGEN_DIAGONALPRODUCT_H
+
+namespace Eigen { 
+
+/** \returns the diagonal matrix product of \c *this by the diagonal matrix \a diagonal.
+  */
+template<typename Derived>
+template<typename DiagonalDerived>
+EIGEN_DEVICE_FUNC inline const Product<Derived, DiagonalDerived, LazyProduct>
+MatrixBase<Derived>::operator*(const DiagonalBase<DiagonalDerived> &a_diagonal) const
+{
+  return Product<Derived, DiagonalDerived, LazyProduct>(derived(),a_diagonal.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DIAGONALPRODUCT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Dot.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Dot.h
new file mode 100644
index 00000000..5c3441b9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Dot.h
@@ -0,0 +1,318 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008, 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DOT_H
+#define EIGEN_DOT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// helper function for dot(). The problem is that if we put that in the body of dot(), then upon calling dot
+// with mismatched types, the compiler emits errors about failing to instantiate cwiseProduct BEFORE
+// looking at the static assertions. Thus this is a trick to get better compile errors.
+template<typename T, typename U,
+// the NeedToTranspose condition here is taken straight from Assign.h
+         bool NeedToTranspose = T::IsVectorAtCompileTime
+                && U::IsVectorAtCompileTime
+                && ((int(T::RowsAtCompileTime) == 1 && int(U::ColsAtCompileTime) == 1)
+                      |  // FIXME | instead of || to please GCC 4.4.0 stupid warning "suggest parentheses around &&".
+                         // revert to || as soon as not needed anymore.
+                    (int(T::ColsAtCompileTime) == 1 && int(U::RowsAtCompileTime) == 1))
+>
+struct dot_nocheck
+{
+  typedef scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> conj_prod;
+  typedef typename conj_prod::result_type ResScalar;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE
+  static ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)
+  {
+    return a.template binaryExpr<conj_prod>(b).sum();
+  }
+};
+
+template<typename T, typename U>
+struct dot_nocheck<T, U, true>
+{
+  typedef scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> conj_prod;
+  typedef typename conj_prod::result_type ResScalar;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE
+  static ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)
+  {
+    return a.transpose().template binaryExpr<conj_prod>(b).sum();
+  }
+};
+
+} // end namespace internal
+
+/** \fn MatrixBase::dot
+  * \returns the dot product of *this with other.
+  *
+  * \only_for_vectors
+  *
+  * \note If the scalar type is complex numbers, then this function returns the hermitian
+  * (sesquilinear) dot product, conjugate-linear in the first variable and linear in the
+  * second variable.
+  *
+  * \sa squaredNorm(), norm()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE
+typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
+MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
+#if !(defined(EIGEN_NO_STATIC_ASSERT) && defined(EIGEN_NO_DEBUG))
+  typedef internal::scalar_conj_product_op<Scalar,typename OtherDerived::Scalar> func;
+  EIGEN_CHECK_BINARY_COMPATIBILIY(func,Scalar,typename OtherDerived::Scalar);
+#endif
+  
+  eigen_assert(size() == other.size());
+
+  return internal::dot_nocheck<Derived,OtherDerived>::run(*this, other);
+}
+
+//---------- implementation of L2 norm and related functions ----------
+
+/** \returns, for vectors, the squared \em l2 norm of \c *this, and for matrices the squared Frobenius norm.
+  * In both cases, it consists in the sum of the square of all the matrix entries.
+  * For vectors, this is also equals to the dot product of \c *this with itself.
+  *
+  * \sa dot(), norm(), lpNorm()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::squaredNorm() const
+{
+  return numext::real((*this).cwiseAbs2().sum());
+}
+
+/** \returns, for vectors, the \em l2 norm of \c *this, and for matrices the Frobenius norm.
+  * In both cases, it consists in the square root of the sum of the square of all the matrix entries.
+  * For vectors, this is also equals to the square root of the dot product of \c *this with itself.
+  *
+  * \sa lpNorm(), dot(), squaredNorm()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::norm() const
+{
+  return numext::sqrt(squaredNorm());
+}
+
+/** \returns an expression of the quotient of \c *this by its own norm.
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0),
+  *          then this function returns a copy of the input.
+  *
+  * \only_for_vectors
+  *
+  * \sa norm(), normalize()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::normalized() const
+{
+  typedef typename internal::nested_eval<Derived,2>::type _Nested;
+  _Nested n(derived());
+  RealScalar z = n.squaredNorm();
+  // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
+  if(z>RealScalar(0))
+    return n / numext::sqrt(z);
+  else
+    return n;
+}
+
+/** Normalizes the vector, i.e. divides it by its own norm.
+  *
+  * \only_for_vectors
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0), then \c *this is left unchanged.
+  *
+  * \sa norm(), normalized()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void MatrixBase<Derived>::normalize()
+{
+  RealScalar z = squaredNorm();
+  // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
+  if(z>RealScalar(0))
+    derived() /= numext::sqrt(z);
+}
+
+/** \returns an expression of the quotient of \c *this by its own norm while avoiding underflow and overflow.
+  *
+  * \only_for_vectors
+  *
+  * This method is analogue to the normalized() method, but it reduces the risk of
+  * underflow and overflow when computing the norm.
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0),
+  *          then this function returns a copy of the input.
+  *
+  * \sa stableNorm(), stableNormalize(), normalized()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::stableNormalized() const
+{
+  typedef typename internal::nested_eval<Derived,3>::type _Nested;
+  _Nested n(derived());
+  RealScalar w = n.cwiseAbs().maxCoeff();
+  RealScalar z = (n/w).squaredNorm();
+  if(z>RealScalar(0))
+    return n / (numext::sqrt(z)*w);
+  else
+    return n;
+}
+
+/** Normalizes the vector while avoid underflow and overflow
+  *
+  * \only_for_vectors
+  *
+  * This method is analogue to the normalize() method, but it reduces the risk of
+  * underflow and overflow when computing the norm.
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0), then \c *this is left unchanged.
+  *
+  * \sa stableNorm(), stableNormalized(), normalize()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void MatrixBase<Derived>::stableNormalize()
+{
+  RealScalar w = cwiseAbs().maxCoeff();
+  RealScalar z = (derived()/w).squaredNorm();
+  if(z>RealScalar(0))
+    derived() /= numext::sqrt(z)*w;
+}
+
+//---------- implementation of other norms ----------
+
+namespace internal {
+
+template<typename Derived, int p>
+struct lpNorm_selector
+{
+  typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const MatrixBase<Derived>& m)
+  {
+    EIGEN_USING_STD(pow)
+    return pow(m.cwiseAbs().array().pow(p).sum(), RealScalar(1)/p);
+  }
+};
+
+template<typename Derived>
+struct lpNorm_selector<Derived, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline typename NumTraits<typename traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m)
+  {
+    return m.cwiseAbs().sum();
+  }
+};
+
+template<typename Derived>
+struct lpNorm_selector<Derived, 2>
+{
+  EIGEN_DEVICE_FUNC
+  static inline typename NumTraits<typename traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m)
+  {
+    return m.norm();
+  }
+};
+
+template<typename Derived>
+struct lpNorm_selector<Derived, Infinity>
+{
+  typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const MatrixBase<Derived>& m)
+  {
+    if(Derived::SizeAtCompileTime==0 || (Derived::SizeAtCompileTime==Dynamic && m.size()==0))
+      return RealScalar(0);
+    return m.cwiseAbs().maxCoeff();
+  }
+};
+
+} // end namespace internal
+
+/** \returns the \b coefficient-wise \f$ \ell^p \f$ norm of \c *this, that is, returns the p-th root of the sum of the p-th powers of the absolute values
+  *          of the coefficients of \c *this. If \a p is the special value \a Eigen::Infinity, this function returns the \f$ \ell^\infty \f$
+  *          norm, that is the maximum of the absolute values of the coefficients of \c *this.
+  *
+  * In all cases, if \c *this is empty, then the value 0 is returned.
+  *
+  * \note For matrices, this function does not compute the <a href="https://en.wikipedia.org/wiki/Operator_norm">operator-norm</a>. That is, if \c *this is a matrix, then its coefficients are interpreted as a 1D vector. Nonetheless, you can easily compute the 1-norm and \f$\infty\f$-norm matrix operator norms using \link TutorialReductionsVisitorsBroadcastingReductionsNorm partial reductions \endlink.
+  *
+  * \sa norm()
+  */
+template<typename Derived>
+template<int p>
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_DEVICE_FUNC inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+#else
+EIGEN_DEVICE_FUNC MatrixBase<Derived>::RealScalar
+#endif
+MatrixBase<Derived>::lpNorm() const
+{
+  return internal::lpNorm_selector<Derived, p>::run(*this);
+}
+
+//---------- implementation of isOrthogonal / isUnitary ----------
+
+/** \returns true if *this is approximately orthogonal to \a other,
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isOrthogonal.cpp
+  * Output: \verbinclude MatrixBase_isOrthogonal.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+bool MatrixBase<Derived>::isOrthogonal
+(const MatrixBase<OtherDerived>& other, const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,2>::type nested(derived());
+  typename internal::nested_eval<OtherDerived,2>::type otherNested(other.derived());
+  return numext::abs2(nested.dot(otherNested)) <= prec * prec * nested.squaredNorm() * otherNested.squaredNorm();
+}
+
+/** \returns true if *this is approximately an unitary matrix,
+  *          within the precision given by \a prec. In the case where the \a Scalar
+  *          type is real numbers, a unitary matrix is an orthogonal matrix, whence the name.
+  *
+  * \note This can be used to check whether a family of vectors forms an orthonormal basis.
+  *       Indeed, \c m.isUnitary() returns true if and only if the columns (equivalently, the rows) of m form an
+  *       orthonormal basis.
+  *
+  * Example: \include MatrixBase_isUnitary.cpp
+  * Output: \verbinclude MatrixBase_isUnitary.out
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isUnitary(const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index i = 0; i < cols(); ++i)
+  {
+    if(!internal::isApprox(self.col(i).squaredNorm(), static_cast<RealScalar>(1), prec))
+      return false;
+    for(Index j = 0; j < i; ++j)
+      if(!internal::isMuchSmallerThan(self.col(i).dot(self.col(j)), static_cast<Scalar>(1), prec))
+        return false;
+  }
+  return true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DOT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/EigenBase.h b/C++/yolo_bytetrack/include/Eigen/src/Core/EigenBase.h
new file mode 100644
index 00000000..6b3c7d37
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/EigenBase.h
@@ -0,0 +1,160 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EIGENBASE_H
+#define EIGEN_EIGENBASE_H
+
+namespace Eigen {
+
+/** \class EigenBase
+  * \ingroup Core_Module
+  *
+  * Common base class for all classes T such that MatrixBase has an operator=(T) and a constructor MatrixBase(T).
+  *
+  * In other words, an EigenBase object is an object that can be copied into a MatrixBase.
+  *
+  * Besides MatrixBase-derived classes, this also includes special matrix classes such as diagonal matrices, etc.
+  *
+  * Notice that this class is trivial, it is only used to disambiguate overloaded functions.
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived> struct EigenBase
+{
+//   typedef typename internal::plain_matrix_type<Derived>::type PlainObject;
+
+  /** \brief The interface type of indices
+    * \details To change this, \c \#define the preprocessor symbol \c EIGEN_DEFAULT_DENSE_INDEX_TYPE.
+    * \sa StorageIndex, \ref TopicPreprocessorDirectives.
+    * DEPRECATED: Since Eigen 3.3, its usage is deprecated. Use Eigen::Index instead.
+    * Deprecation is not marked with a doxygen comment because there are too many existing usages to add the deprecation attribute.
+    */
+  typedef Eigen::Index Index;
+
+  // FIXME is it needed?
+  typedef typename internal::traits<Derived>::StorageKind StorageKind;
+
+  /** \returns a reference to the derived object */
+  EIGEN_DEVICE_FUNC
+  Derived& derived() { return *static_cast<Derived*>(this); }
+  /** \returns a const reference to the derived object */
+  EIGEN_DEVICE_FUNC
+  const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+  EIGEN_DEVICE_FUNC
+  inline Derived& const_cast_derived() const
+  { return *static_cast<Derived*>(const_cast<EigenBase*>(this)); }
+  EIGEN_DEVICE_FUNC
+  inline const Derived& const_derived() const
+  { return *static_cast<const Derived*>(this); }
+
+  /** \returns the number of rows. \sa cols(), RowsAtCompileTime */
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  inline Index rows() const EIGEN_NOEXCEPT { return derived().rows(); }
+  /** \returns the number of columns. \sa rows(), ColsAtCompileTime*/
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  inline Index cols() const EIGEN_NOEXCEPT { return derived().cols(); }
+  /** \returns the number of coefficients, which is rows()*cols().
+    * \sa rows(), cols(), SizeAtCompileTime. */
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  inline Index size() const EIGEN_NOEXCEPT { return rows() * cols(); }
+
+  /** \internal Don't use it, but do the equivalent: \code dst = *this; \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC
+  inline void evalTo(Dest& dst) const
+  { derived().evalTo(dst); }
+
+  /** \internal Don't use it, but do the equivalent: \code dst += *this; \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC
+  inline void addTo(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    typename Dest::PlainObject res(rows(),cols());
+    evalTo(res);
+    dst += res;
+  }
+
+  /** \internal Don't use it, but do the equivalent: \code dst -= *this; \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC
+  inline void subTo(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    typename Dest::PlainObject res(rows(),cols());
+    evalTo(res);
+    dst -= res;
+  }
+
+  /** \internal Don't use it, but do the equivalent: \code dst.applyOnTheRight(*this); \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC inline void applyThisOnTheRight(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    dst = dst * this->derived();
+  }
+
+  /** \internal Don't use it, but do the equivalent: \code dst.applyOnTheLeft(*this); \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC inline void applyThisOnTheLeft(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    dst = this->derived() * dst;
+  }
+
+};
+
+/***************************************************************************
+* Implementation of matrix base methods
+***************************************************************************/
+
+/** \brief Copies the generic expression \a other into *this.
+  *
+  * \details The expression must provide a (templated) evalTo(Derived& dst) const
+  * function which does the actual job. In practice, this allows any user to write
+  * its own special matrix without having to modify MatrixBase
+  *
+  * \returns a reference to *this.
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+Derived& DenseBase<Derived>::operator=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+Derived& DenseBase<Derived>::operator+=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+Derived& DenseBase<Derived>::operator-=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_EIGENBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/ForceAlignedAccess.h b/C++/yolo_bytetrack/include/Eigen/src/Core/ForceAlignedAccess.h
new file mode 100644
index 00000000..817a43af
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/ForceAlignedAccess.h
@@ -0,0 +1,150 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FORCEALIGNEDACCESS_H
+#define EIGEN_FORCEALIGNEDACCESS_H
+
+namespace Eigen {
+
+/** \class ForceAlignedAccess
+  * \ingroup Core_Module
+  *
+  * \brief Enforce aligned packet loads and stores regardless of what is requested
+  *
+  * \param ExpressionType the type of the object of which we are forcing aligned packet access
+  *
+  * This class is the return type of MatrixBase::forceAlignedAccess()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::forceAlignedAccess()
+  */
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<ForceAlignedAccess<ExpressionType> > : public traits<ExpressionType>
+{};
+}
+
+template<typename ExpressionType> class ForceAlignedAccess
+  : public internal::dense_xpr_base< ForceAlignedAccess<ExpressionType> >::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<ForceAlignedAccess>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ForceAlignedAccess)
+
+    EIGEN_DEVICE_FUNC explicit inline ForceAlignedAccess(const ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_expression.cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return m_expression.outerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return m_expression.innerStride(); }
+
+    EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index row, Index col) const
+    {
+      return m_expression.coeff(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col)
+    {
+      return m_expression.const_cast_derived().coeffRef(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index index) const
+    {
+      return m_expression.coeff(index);
+    }
+
+    EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index index)
+    {
+      return m_expression.const_cast_derived().coeffRef(index);
+    }
+
+    template<int LoadMode>
+    inline const PacketScalar packet(Index row, Index col) const
+    {
+      return m_expression.template packet<Aligned>(row, col);
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index row, Index col, const PacketScalar& x)
+    {
+      m_expression.const_cast_derived().template writePacket<Aligned>(row, col, x);
+    }
+
+    template<int LoadMode>
+    inline const PacketScalar packet(Index index) const
+    {
+      return m_expression.template packet<Aligned>(index);
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index index, const PacketScalar& x)
+    {
+      m_expression.const_cast_derived().template writePacket<Aligned>(index, x);
+    }
+
+    EIGEN_DEVICE_FUNC operator const ExpressionType&() const { return m_expression; }
+
+  protected:
+    const ExpressionType& m_expression;
+
+  private:
+    ForceAlignedAccess& operator=(const ForceAlignedAccess&);
+};
+
+/** \returns an expression of *this with forced aligned access
+  * \sa forceAlignedAccessIf(),class ForceAlignedAccess
+  */
+template<typename Derived>
+inline const ForceAlignedAccess<Derived>
+MatrixBase<Derived>::forceAlignedAccess() const
+{
+  return ForceAlignedAccess<Derived>(derived());
+}
+
+/** \returns an expression of *this with forced aligned access
+  * \sa forceAlignedAccessIf(), class ForceAlignedAccess
+  */
+template<typename Derived>
+inline ForceAlignedAccess<Derived>
+MatrixBase<Derived>::forceAlignedAccess()
+{
+  return ForceAlignedAccess<Derived>(derived());
+}
+
+/** \returns an expression of *this with forced aligned access if \a Enable is true.
+  * \sa forceAlignedAccess(), class ForceAlignedAccess
+  */
+template<typename Derived>
+template<bool Enable>
+inline typename internal::add_const_on_value_type<typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type>::type
+MatrixBase<Derived>::forceAlignedAccessIf() const
+{
+  return derived();  // FIXME This should not work but apparently is never used
+}
+
+/** \returns an expression of *this with forced aligned access if \a Enable is true.
+  * \sa forceAlignedAccess(), class ForceAlignedAccess
+  */
+template<typename Derived>
+template<bool Enable>
+inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type
+MatrixBase<Derived>::forceAlignedAccessIf()
+{
+  return derived();  // FIXME This should not work but apparently is never used
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FORCEALIGNEDACCESS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Fuzzy.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Fuzzy.h
new file mode 100644
index 00000000..43aa49b2
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Fuzzy.h
@@ -0,0 +1,155 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FUZZY_H
+#define EIGEN_FUZZY_H
+
+namespace Eigen { 
+
+namespace internal
+{
+
+template<typename Derived, typename OtherDerived, bool is_integer = NumTraits<typename Derived::Scalar>::IsInteger>
+struct isApprox_selector
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar& prec)
+  {
+    typename internal::nested_eval<Derived,2>::type nested(x);
+    typename internal::nested_eval<OtherDerived,2>::type otherNested(y);
+    return (nested - otherNested).cwiseAbs2().sum() <= prec * prec * numext::mini(nested.cwiseAbs2().sum(), otherNested.cwiseAbs2().sum());
+  }
+};
+
+template<typename Derived, typename OtherDerived>
+struct isApprox_selector<Derived, OtherDerived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar&)
+  {
+    return x.matrix() == y.matrix();
+  }
+};
+
+template<typename Derived, typename OtherDerived, bool is_integer = NumTraits<typename Derived::Scalar>::IsInteger>
+struct isMuchSmallerThan_object_selector
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar& prec)
+  {
+    return x.cwiseAbs2().sum() <= numext::abs2(prec) * y.cwiseAbs2().sum();
+  }
+};
+
+template<typename Derived, typename OtherDerived>
+struct isMuchSmallerThan_object_selector<Derived, OtherDerived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived&, const typename Derived::RealScalar&)
+  {
+    return x.matrix() == Derived::Zero(x.rows(), x.cols()).matrix();
+  }
+};
+
+template<typename Derived, bool is_integer = NumTraits<typename Derived::Scalar>::IsInteger>
+struct isMuchSmallerThan_scalar_selector
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const typename Derived::RealScalar& y, const typename Derived::RealScalar& prec)
+  {
+    return x.cwiseAbs2().sum() <= numext::abs2(prec * y);
+  }
+};
+
+template<typename Derived>
+struct isMuchSmallerThan_scalar_selector<Derived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const typename Derived::RealScalar&, const typename Derived::RealScalar&)
+  {
+    return x.matrix() == Derived::Zero(x.rows(), x.cols()).matrix();
+  }
+};
+
+} // end namespace internal
+
+
+/** \returns \c true if \c *this is approximately equal to \a other, within the precision
+  * determined by \a prec.
+  *
+  * \note The fuzzy compares are done multiplicatively. Two vectors \f$ v \f$ and \f$ w \f$
+  * are considered to be approximately equal within precision \f$ p \f$ if
+  * \f[ \Vert v - w \Vert \leqslant p\,\min(\Vert v\Vert, \Vert w\Vert). \f]
+  * For matrices, the comparison is done using the Hilbert-Schmidt norm (aka Frobenius norm
+  * L2 norm).
+  *
+  * \note Because of the multiplicativeness of this comparison, one can't use this function
+  * to check whether \c *this is approximately equal to the zero matrix or vector.
+  * Indeed, \c isApprox(zero) returns false unless \c *this itself is exactly the zero matrix
+  * or vector. If you want to test whether \c *this is zero, use internal::isMuchSmallerThan(const
+  * RealScalar&, RealScalar) instead.
+  *
+  * \sa internal::isMuchSmallerThan(const RealScalar&, RealScalar) const
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isApprox(
+  const DenseBase<OtherDerived>& other,
+  const RealScalar& prec
+) const
+{
+  return internal::isApprox_selector<Derived, OtherDerived>::run(derived(), other.derived(), prec);
+}
+
+/** \returns \c true if the norm of \c *this is much smaller than \a other,
+  * within the precision determined by \a prec.
+  *
+  * \note The fuzzy compares are done multiplicatively. A vector \f$ v \f$ is
+  * considered to be much smaller than \f$ x \f$ within precision \f$ p \f$ if
+  * \f[ \Vert v \Vert \leqslant p\,\vert x\vert. \f]
+  *
+  * For matrices, the comparison is done using the Hilbert-Schmidt norm. For this reason,
+  * the value of the reference scalar \a other should come from the Hilbert-Schmidt norm
+  * of a reference matrix of same dimensions.
+  *
+  * \sa isApprox(), isMuchSmallerThan(const DenseBase<OtherDerived>&, RealScalar) const
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isMuchSmallerThan(
+  const typename NumTraits<Scalar>::Real& other,
+  const RealScalar& prec
+) const
+{
+  return internal::isMuchSmallerThan_scalar_selector<Derived>::run(derived(), other, prec);
+}
+
+/** \returns \c true if the norm of \c *this is much smaller than the norm of \a other,
+  * within the precision determined by \a prec.
+  *
+  * \note The fuzzy compares are done multiplicatively. A vector \f$ v \f$ is
+  * considered to be much smaller than a vector \f$ w \f$ within precision \f$ p \f$ if
+  * \f[ \Vert v \Vert \leqslant p\,\Vert w\Vert. \f]
+  * For matrices, the comparison is done using the Hilbert-Schmidt norm.
+  *
+  * \sa isApprox(), isMuchSmallerThan(const RealScalar&, RealScalar) const
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isMuchSmallerThan(
+  const DenseBase<OtherDerived>& other,
+  const RealScalar& prec
+) const
+{
+  return internal::isMuchSmallerThan_object_selector<Derived, OtherDerived>::run(derived(), other.derived(), prec);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FUZZY_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/GeneralProduct.h b/C++/yolo_bytetrack/include/Eigen/src/Core/GeneralProduct.h
new file mode 100644
index 00000000..6906aa75
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/GeneralProduct.h
@@ -0,0 +1,465 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_PRODUCT_H
+#define EIGEN_GENERAL_PRODUCT_H
+
+namespace Eigen {
+
+enum {
+  Large = 2,
+  Small = 3
+};
+
+// Define the threshold value to fallback from the generic matrix-matrix product
+// implementation (heavy) to the lightweight coeff-based product one.
+// See generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct>
+// in products/GeneralMatrixMatrix.h for more details.
+// TODO This threshold should also be used in the compile-time selector below.
+#ifndef EIGEN_GEMM_TO_COEFFBASED_THRESHOLD
+// This default value has been obtained on a Haswell architecture.
+#define EIGEN_GEMM_TO_COEFFBASED_THRESHOLD 20
+#endif
+
+namespace internal {
+
+template<int Rows, int Cols, int Depth> struct product_type_selector;
+
+template<int Size, int MaxSize> struct product_size_category
+{
+  enum {
+    #ifndef EIGEN_GPU_COMPILE_PHASE
+    is_large = MaxSize == Dynamic ||
+               Size >= EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD ||
+               (Size==Dynamic && MaxSize>=EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD),
+    #else
+    is_large = 0,
+    #endif
+    value = is_large  ? Large
+          : Size == 1 ? 1
+                      : Small
+  };
+};
+
+template<typename Lhs, typename Rhs> struct product_type
+{
+  typedef typename remove_all<Lhs>::type _Lhs;
+  typedef typename remove_all<Rhs>::type _Rhs;
+  enum {
+    MaxRows = traits<_Lhs>::MaxRowsAtCompileTime,
+    Rows    = traits<_Lhs>::RowsAtCompileTime,
+    MaxCols = traits<_Rhs>::MaxColsAtCompileTime,
+    Cols    = traits<_Rhs>::ColsAtCompileTime,
+    MaxDepth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::MaxColsAtCompileTime,
+                                           traits<_Rhs>::MaxRowsAtCompileTime),
+    Depth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::ColsAtCompileTime,
+                                        traits<_Rhs>::RowsAtCompileTime)
+  };
+
+  // the splitting into different lines of code here, introducing the _select enums and the typedef below,
+  // is to work around an internal compiler error with gcc 4.1 and 4.2.
+private:
+  enum {
+    rows_select = product_size_category<Rows,MaxRows>::value,
+    cols_select = product_size_category<Cols,MaxCols>::value,
+    depth_select = product_size_category<Depth,MaxDepth>::value
+  };
+  typedef product_type_selector<rows_select, cols_select, depth_select> selector;
+
+public:
+  enum {
+    value = selector::ret,
+    ret = selector::ret
+  };
+#ifdef EIGEN_DEBUG_PRODUCT
+  static void debug()
+  {
+      EIGEN_DEBUG_VAR(Rows);
+      EIGEN_DEBUG_VAR(Cols);
+      EIGEN_DEBUG_VAR(Depth);
+      EIGEN_DEBUG_VAR(rows_select);
+      EIGEN_DEBUG_VAR(cols_select);
+      EIGEN_DEBUG_VAR(depth_select);
+      EIGEN_DEBUG_VAR(value);
+  }
+#endif
+};
+
+/* The following allows to select the kind of product at compile time
+ * based on the three dimensions of the product.
+ * This is a compile time mapping from {1,Small,Large}^3 -> {product types} */
+// FIXME I'm not sure the current mapping is the ideal one.
+template<int M, int N>  struct product_type_selector<M,N,1>              { enum { ret = OuterProduct }; };
+template<int M>         struct product_type_selector<M, 1, 1>            { enum { ret = LazyCoeffBasedProductMode }; };
+template<int N>         struct product_type_selector<1, N, 1>            { enum { ret = LazyCoeffBasedProductMode }; };
+template<int Depth>     struct product_type_selector<1,    1,    Depth>  { enum { ret = InnerProduct }; };
+template<>              struct product_type_selector<1,    1,    1>      { enum { ret = InnerProduct }; };
+template<>              struct product_type_selector<Small,1,    Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<1,    Small,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small,Small,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small, Small, 1>    { enum { ret = LazyCoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small, Large, 1>    { enum { ret = LazyCoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large, Small, 1>    { enum { ret = LazyCoeffBasedProductMode }; };
+template<>              struct product_type_selector<1,    Large,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<1,    Large,Large>  { enum { ret = GemvProduct }; };
+template<>              struct product_type_selector<1,    Small,Large>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large,1,    Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large,1,    Large>  { enum { ret = GemvProduct }; };
+template<>              struct product_type_selector<Small,1,    Large>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small,Small,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Large,Small,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Small,Large,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Large,Large,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Large,Small,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small,Large,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large,Large,Small>  { enum { ret = GemmProduct }; };
+
+} // end namespace internal
+
+/***********************************************************************
+*  Implementation of Inner Vector Vector Product
+***********************************************************************/
+
+// FIXME : maybe the "inner product" could return a Scalar
+// instead of a 1x1 matrix ??
+// Pro: more natural for the user
+// Cons: this could be a problem if in a meta unrolled algorithm a matrix-matrix
+// product ends up to a row-vector times col-vector product... To tackle this use
+// case, we could have a specialization for Block<MatrixType,1,1> with: operator=(Scalar x);
+
+/***********************************************************************
+*  Implementation of Outer Vector Vector Product
+***********************************************************************/
+
+/***********************************************************************
+*  Implementation of General Matrix Vector Product
+***********************************************************************/
+
+/*  According to the shape/flags of the matrix we have to distinghish 3 different cases:
+ *   1 - the matrix is col-major, BLAS compatible and M is large => call fast BLAS-like colmajor routine
+ *   2 - the matrix is row-major, BLAS compatible and N is large => call fast BLAS-like rowmajor routine
+ *   3 - all other cases are handled using a simple loop along the outer-storage direction.
+ *  Therefore we need a lower level meta selector.
+ *  Furthermore, if the matrix is the rhs, then the product has to be transposed.
+ */
+namespace internal {
+
+template<int Side, int StorageOrder, bool BlasCompatible>
+struct gemv_dense_selector;
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Scalar,int Size,int MaxSize,bool Cond> struct gemv_static_vector_if;
+
+template<typename Scalar,int Size,int MaxSize>
+struct gemv_static_vector_if<Scalar,Size,MaxSize,false>
+{
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Scalar* data() { eigen_internal_assert(false && "should never be called"); return 0; }
+};
+
+template<typename Scalar,int Size>
+struct gemv_static_vector_if<Scalar,Size,Dynamic,true>
+{
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Scalar* data() { return 0; }
+};
+
+template<typename Scalar,int Size,int MaxSize>
+struct gemv_static_vector_if<Scalar,Size,MaxSize,true>
+{
+  enum {
+    ForceAlignment  = internal::packet_traits<Scalar>::Vectorizable,
+    PacketSize      = internal::packet_traits<Scalar>::size
+  };
+  #if EIGEN_MAX_STATIC_ALIGN_BYTES!=0
+  internal::plain_array<Scalar,EIGEN_SIZE_MIN_PREFER_FIXED(Size,MaxSize),0,EIGEN_PLAIN_ENUM_MIN(AlignedMax,PacketSize)> m_data;
+  EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; }
+  #else
+  // Some architectures cannot align on the stack,
+  // => let's manually enforce alignment by allocating more data and return the address of the first aligned element.
+  internal::plain_array<Scalar,EIGEN_SIZE_MIN_PREFER_FIXED(Size,MaxSize)+(ForceAlignment?EIGEN_MAX_ALIGN_BYTES:0),0> m_data;
+  EIGEN_STRONG_INLINE Scalar* data() {
+    return ForceAlignment
+            ? reinterpret_cast<Scalar*>((internal::UIntPtr(m_data.array) & ~(std::size_t(EIGEN_MAX_ALIGN_BYTES-1))) + EIGEN_MAX_ALIGN_BYTES)
+            : m_data.array;
+  }
+  #endif
+};
+
+// The vector is on the left => transposition
+template<int StorageOrder, bool BlasCompatible>
+struct gemv_dense_selector<OnTheLeft,StorageOrder,BlasCompatible>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    Transpose<Dest> destT(dest);
+    enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor };
+    gemv_dense_selector<OnTheRight,OtherStorageOrder,BlasCompatible>
+      ::run(rhs.transpose(), lhs.transpose(), destT, alpha);
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,ColMajor,true>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static inline void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar   LhsScalar;
+    typedef typename Rhs::Scalar   RhsScalar;
+    typedef typename Dest::Scalar  ResScalar;
+    typedef typename Dest::RealScalar  RealScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  
+    typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest;
+
+    ActualLhsType actualLhs = LhsBlasTraits::extract(lhs);
+    ActualRhsType actualRhs = RhsBlasTraits::extract(rhs);
+
+    ResScalar actualAlpha = combine_scalar_factors(alpha, lhs, rhs);
+
+    // make sure Dest is a compile-time vector type (bug 1166)
+    typedef typename conditional<Dest::IsVectorAtCompileTime, Dest, typename Dest::ColXpr>::type ActualDest;
+
+    enum {
+      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
+      // on, the other hand it is good for the cache to pack the vector anyways...
+      EvalToDestAtCompileTime = (ActualDest::InnerStrideAtCompileTime==1),
+      ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex),
+      MightCannotUseDest = ((!EvalToDestAtCompileTime) || ComplexByReal) && (ActualDest::MaxSizeAtCompileTime!=0)
+    };
+
+    typedef const_blas_data_mapper<LhsScalar,Index,ColMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,RowMajor> RhsMapper;
+    RhsScalar compatibleAlpha = get_factor<ResScalar,RhsScalar>::run(actualAlpha);
+
+    if(!MightCannotUseDest)
+    {
+      // shortcut if we are sure to be able to use dest directly,
+      // this ease the compiler to generate cleaner and more optimzized code for most common cases
+      general_matrix_vector_product
+          <Index,LhsScalar,LhsMapper,ColMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
+          actualLhs.rows(), actualLhs.cols(),
+          LhsMapper(actualLhs.data(), actualLhs.outerStride()),
+          RhsMapper(actualRhs.data(), actualRhs.innerStride()),
+          dest.data(), 1,
+          compatibleAlpha);
+    }
+    else
+    {
+      gemv_static_vector_if<ResScalar,ActualDest::SizeAtCompileTime,ActualDest::MaxSizeAtCompileTime,MightCannotUseDest> static_dest;
+
+      const bool alphaIsCompatible = (!ComplexByReal) || (numext::imag(actualAlpha)==RealScalar(0));
+      const bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
+
+      ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(),
+                                                    evalToDest ? dest.data() : static_dest.data());
+
+      if(!evalToDest)
+      {
+        #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+        Index size = dest.size();
+        EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+        #endif
+        if(!alphaIsCompatible)
+        {
+          MappedDest(actualDestPtr, dest.size()).setZero();
+          compatibleAlpha = RhsScalar(1);
+        }
+        else
+          MappedDest(actualDestPtr, dest.size()) = dest;
+      }
+
+      general_matrix_vector_product
+          <Index,LhsScalar,LhsMapper,ColMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
+          actualLhs.rows(), actualLhs.cols(),
+          LhsMapper(actualLhs.data(), actualLhs.outerStride()),
+          RhsMapper(actualRhs.data(), actualRhs.innerStride()),
+          actualDestPtr, 1,
+          compatibleAlpha);
+
+      if (!evalToDest)
+      {
+        if(!alphaIsCompatible)
+          dest.matrix() += actualAlpha * MappedDest(actualDestPtr, dest.size());
+        else
+          dest = MappedDest(actualDestPtr, dest.size());
+      }
+    }
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,RowMajor,true>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar   LhsScalar;
+    typedef typename Rhs::Scalar   RhsScalar;
+    typedef typename Dest::Scalar  ResScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+    typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
+    typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
+
+    ResScalar actualAlpha = combine_scalar_factors(alpha, lhs, rhs);
+
+    enum {
+      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
+      // on, the other hand it is good for the cache to pack the vector anyways...
+      DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1 || ActualRhsTypeCleaned::MaxSizeAtCompileTime==0
+    };
+
+    gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;
+
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
+        DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
+
+    if(!DirectlyUseRhs)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = actualRhs.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    }
+
+    typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
+    general_matrix_vector_product
+        <Index,LhsScalar,LhsMapper,RowMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
+        actualLhs.rows(), actualLhs.cols(),
+        LhsMapper(actualLhs.data(), actualLhs.outerStride()),
+        RhsMapper(actualRhsPtr, 1),
+        dest.data(), dest.col(0).innerStride(), //NOTE  if dest is not a vector at compile-time, then dest.innerStride() might be wrong. (bug 1166)
+        actualAlpha);
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,ColMajor,false>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    EIGEN_STATIC_ASSERT((!nested_eval<Lhs,1>::Evaluate),EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE);
+    // TODO if rhs is large enough it might be beneficial to make sure that dest is sequentially stored in memory, otherwise use a temp
+    typename nested_eval<Rhs,1>::type actual_rhs(rhs);
+    const Index size = rhs.rows();
+    for(Index k=0; k<size; ++k)
+      dest += (alpha*actual_rhs.coeff(k)) * lhs.col(k);
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,RowMajor,false>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    EIGEN_STATIC_ASSERT((!nested_eval<Lhs,1>::Evaluate),EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE);
+    typename nested_eval<Rhs,Lhs::RowsAtCompileTime>::type actual_rhs(rhs);
+    const Index rows = dest.rows();
+    for(Index i=0; i<rows; ++i)
+      dest.coeffRef(i) += alpha * (lhs.row(i).cwiseProduct(actual_rhs.transpose())).sum();
+  }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Implementation of matrix base methods
+***************************************************************************/
+
+/** \returns the matrix product of \c *this and \a other.
+  *
+  * \note If instead of the matrix product you want the coefficient-wise product, see Cwise::operator*().
+  *
+  * \sa lazyProduct(), operator*=(const MatrixBase&), Cwise::operator*()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const Product<Derived, OtherDerived>
+MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived> &other) const
+{
+  // A note regarding the function declaration: In MSVC, this function will sometimes
+  // not be inlined since DenseStorage is an unwindable object for dynamic
+  // matrices and product types are holding a member to store the result.
+  // Thus it does not help tagging this function with EIGEN_STRONG_INLINE.
+  enum {
+    ProductIsValid =  Derived::ColsAtCompileTime==Dynamic
+                   || OtherDerived::RowsAtCompileTime==Dynamic
+                   || int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime),
+    AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime,
+    SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived)
+  };
+  // note to the lost user:
+  //    * for a dot product use: v1.dot(v2)
+  //    * for a coeff-wise product use: v1.cwiseProduct(v2)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes),
+    INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors),
+    INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
+  EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)
+#ifdef EIGEN_DEBUG_PRODUCT
+  internal::product_type<Derived,OtherDerived>::debug();
+#endif
+
+  return Product<Derived, OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the matrix product of \c *this and \a other without implicit evaluation.
+  *
+  * The returned product will behave like any other expressions: the coefficients of the product will be
+  * computed once at a time as requested. This might be useful in some extremely rare cases when only
+  * a small and no coherent fraction of the result's coefficients have to be computed.
+  *
+  * \warning This version of the matrix product can be much much slower. So use it only if you know
+  * what you are doing and that you measured a true speed improvement.
+  *
+  * \sa operator*(const MatrixBase&)
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const Product<Derived,OtherDerived,LazyProduct>
+MatrixBase<Derived>::lazyProduct(const MatrixBase<OtherDerived> &other) const
+{
+  enum {
+    ProductIsValid =  Derived::ColsAtCompileTime==Dynamic
+                   || OtherDerived::RowsAtCompileTime==Dynamic
+                   || int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime),
+    AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime,
+    SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived)
+  };
+  // note to the lost user:
+  //    * for a dot product use: v1.dot(v2)
+  //    * for a coeff-wise product use: v1.cwiseProduct(v2)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes),
+    INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors),
+    INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
+  EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)
+
+  return Product<Derived,OtherDerived,LazyProduct>(derived(), other.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PRODUCT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/GenericPacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/GenericPacketMath.h
new file mode 100644
index 00000000..cf677a19
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/GenericPacketMath.h
@@ -0,0 +1,1040 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERIC_PACKET_MATH_H
+#define EIGEN_GENERIC_PACKET_MATH_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+  * \file GenericPacketMath.h
+  *
+  * Default implementation for types not supported by the vectorization.
+  * In practice these functions are provided to make easier the writing
+  * of generic vectorized code.
+  */
+
+#ifndef EIGEN_DEBUG_ALIGNED_LOAD
+#define EIGEN_DEBUG_ALIGNED_LOAD
+#endif
+
+#ifndef EIGEN_DEBUG_UNALIGNED_LOAD
+#define EIGEN_DEBUG_UNALIGNED_LOAD
+#endif
+
+#ifndef EIGEN_DEBUG_ALIGNED_STORE
+#define EIGEN_DEBUG_ALIGNED_STORE
+#endif
+
+#ifndef EIGEN_DEBUG_UNALIGNED_STORE
+#define EIGEN_DEBUG_UNALIGNED_STORE
+#endif
+
+struct default_packet_traits
+{
+  enum {
+    HasHalfPacket = 0,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 0,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 1,
+    HasBlend     = 0,
+    // This flag is used to indicate whether packet comparison is supported.
+    // pcmp_eq, pcmp_lt and pcmp_le should be defined for it to be true.
+    HasCmp       = 0,
+
+    HasDiv    = 0,
+    HasSqrt   = 0,
+    HasRsqrt  = 0,
+    HasExp    = 0,
+    HasExpm1  = 0,
+    HasLog    = 0,
+    HasLog1p  = 0,
+    HasLog10  = 0,
+    HasPow    = 0,
+
+    HasSin    = 0,
+    HasCos    = 0,
+    HasTan    = 0,
+    HasASin   = 0,
+    HasACos   = 0,
+    HasATan   = 0,
+    HasSinh   = 0,
+    HasCosh   = 0,
+    HasTanh   = 0,
+    HasLGamma = 0,
+    HasDiGamma = 0,
+    HasZeta = 0,
+    HasPolygamma = 0,
+    HasErf = 0,
+    HasErfc = 0,
+    HasNdtri = 0,
+    HasBessel = 0,
+    HasIGamma = 0,
+    HasIGammaDerA = 0,
+    HasGammaSampleDerAlpha = 0,
+    HasIGammac = 0,
+    HasBetaInc = 0,
+
+    HasRound  = 0,
+    HasRint   = 0,
+    HasFloor  = 0,
+    HasCeil   = 0,
+    HasSign   = 0
+  };
+};
+
+template<typename T> struct packet_traits : default_packet_traits
+{
+  typedef T type;
+  typedef T half;
+  enum {
+    Vectorizable = 0,
+    size = 1,
+    AlignedOnScalar = 0,
+    HasHalfPacket = 0
+  };
+  enum {
+    HasAdd    = 0,
+    HasSub    = 0,
+    HasMul    = 0,
+    HasNegate = 0,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasConj   = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<typename T> struct packet_traits<const T> : packet_traits<T> { };
+
+template<typename T> struct unpacket_traits
+{
+  typedef T type;
+  typedef T half;
+  enum
+  {
+    size = 1,
+    alignment = 1,
+    vectorizable = false,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<typename T> struct unpacket_traits<const T> : unpacket_traits<T> { };
+
+template <typename Src, typename Tgt> struct type_casting_traits {
+  enum {
+    VectorizedCast = 0,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+/** \internal Wrapper to ensure that multiple packet types can map to the same
+    same underlying vector type. */
+template<typename T, int unique_id = 0>
+struct eigen_packet_wrapper
+{
+  EIGEN_ALWAYS_INLINE operator T&() { return m_val; }
+  EIGEN_ALWAYS_INLINE operator const T&() const { return m_val; }
+  EIGEN_ALWAYS_INLINE eigen_packet_wrapper() {}
+  EIGEN_ALWAYS_INLINE eigen_packet_wrapper(const T &v) : m_val(v) {}
+  EIGEN_ALWAYS_INLINE eigen_packet_wrapper& operator=(const T &v) {
+    m_val = v;
+    return *this;
+  }
+
+  T m_val;
+};
+
+
+/** \internal A convenience utility for determining if the type is a scalar.
+ * This is used to enable some generic packet implementations.
+ */
+template<typename Packet>
+struct is_scalar {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  enum {
+    value = internal::is_same<Packet, Scalar>::value
+  };
+};
+
+/** \internal \returns static_cast<TgtType>(a) (coeff-wise) */
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a) {
+  return static_cast<TgtPacket>(a);
+}
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a, const SrcPacket& /*b*/) {
+  return static_cast<TgtPacket>(a);
+}
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a, const SrcPacket& /*b*/, const SrcPacket& /*c*/, const SrcPacket& /*d*/) {
+  return static_cast<TgtPacket>(a);
+}
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a, const SrcPacket& /*b*/, const SrcPacket& /*c*/, const SrcPacket& /*d*/,
+      const SrcPacket& /*e*/, const SrcPacket& /*f*/, const SrcPacket& /*g*/, const SrcPacket& /*h*/) {
+  return static_cast<TgtPacket>(a);
+}
+
+/** \internal \returns reinterpret_cast<Target>(a) */
+template <typename Target, typename Packet>
+EIGEN_DEVICE_FUNC inline Target
+preinterpret(const Packet& a); /* { return reinterpret_cast<const Target&>(a); } */
+
+/** \internal \returns a + b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+padd(const Packet& a, const Packet& b) { return a+b; }
+// Avoid compiler warning for boolean algebra.
+template<> EIGEN_DEVICE_FUNC inline bool
+padd(const bool& a, const bool& b) { return a || b; }
+
+/** \internal \returns a - b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+psub(const Packet& a, const Packet& b) { return a-b; }
+
+/** \internal \returns -a (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pnegate(const Packet& a) { return -a; }
+
+template<> EIGEN_DEVICE_FUNC inline bool
+pnegate(const bool& a) { return !a; }
+
+/** \internal \returns conj(a) (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pconj(const Packet& a) { return numext::conj(a); }
+
+/** \internal \returns a * b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmul(const Packet& a, const Packet& b) { return a*b; }
+// Avoid compiler warning for boolean algebra.
+template<> EIGEN_DEVICE_FUNC inline bool
+pmul(const bool& a, const bool& b) { return a && b; }
+
+/** \internal \returns a / b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pdiv(const Packet& a, const Packet& b) { return a/b; }
+
+// In the generic case, memset to all one bits.
+template<typename Packet, typename EnableIf = void>
+struct ptrue_impl {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& /*a*/){
+    Packet b;
+    memset(static_cast<void*>(&b), 0xff, sizeof(Packet));
+    return b;
+  }
+};
+
+// For non-trivial scalars, set to Scalar(1) (i.e. a non-zero value).
+// Although this is technically not a valid bitmask, the scalar path for pselect
+// uses a comparison to zero, so this should still work in most cases. We don't
+// have another option, since the scalar type requires initialization.
+template<typename T>
+struct ptrue_impl<T, 
+    typename internal::enable_if<is_scalar<T>::value && NumTraits<T>::RequireInitialization>::type > {
+  static EIGEN_DEVICE_FUNC inline T run(const T& /*a*/){
+    return T(1);
+  }
+};
+
+/** \internal \returns one bits. */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+ptrue(const Packet& a) {
+  return ptrue_impl<Packet>::run(a);
+}
+
+// In the general case, memset to zero.
+template<typename Packet, typename EnableIf = void>
+struct pzero_impl {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& /*a*/) {
+    Packet b;
+    memset(static_cast<void*>(&b), 0x00, sizeof(Packet));
+    return b;
+  }
+};
+
+// For scalars, explicitly set to Scalar(0), since the underlying representation
+// for zero may not consist of all-zero bits.
+template<typename T>
+struct pzero_impl<T,
+    typename internal::enable_if<is_scalar<T>::value>::type> {
+  static EIGEN_DEVICE_FUNC inline T run(const T& /*a*/) {
+    return T(0);
+  }
+};
+
+/** \internal \returns packet of zeros */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pzero(const Packet& a) {
+  return pzero_impl<Packet>::run(a);
+}
+
+/** \internal \returns a <= b as a bit mask */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pcmp_le(const Packet& a, const Packet& b)  { return a<=b ? ptrue(a) : pzero(a); }
+
+/** \internal \returns a < b as a bit mask */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pcmp_lt(const Packet& a, const Packet& b)  { return a<b ? ptrue(a) : pzero(a); }
+
+/** \internal \returns a == b as a bit mask */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pcmp_eq(const Packet& a, const Packet& b) { return a==b ? ptrue(a) : pzero(a); }
+
+/** \internal \returns a < b or a==NaN or b==NaN as a bit mask */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pcmp_lt_or_nan(const Packet& a, const Packet& b) { return a>=b ? pzero(a) : ptrue(a); }
+
+template<typename T>
+struct bit_and {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(const T& a, const T& b) const {
+    return a & b;
+  }
+};
+
+template<typename T>
+struct bit_or {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(const T& a, const T& b) const {
+    return a | b;
+  }
+};
+
+template<typename T>
+struct bit_xor {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(const T& a, const T& b) const {
+    return a ^ b;
+  }
+};
+
+template<typename T>
+struct bit_not {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(const T& a) const {
+    return ~a;
+  }
+};
+
+// Use operators &, |, ^, ~.
+template<typename T>
+struct operator_bitwise_helper {
+  EIGEN_DEVICE_FUNC static inline T bitwise_and(const T& a, const T& b) { return bit_and<T>()(a, b); }
+  EIGEN_DEVICE_FUNC static inline T bitwise_or(const T& a, const T& b) { return bit_or<T>()(a, b); }
+  EIGEN_DEVICE_FUNC static inline T bitwise_xor(const T& a, const T& b) { return bit_xor<T>()(a, b); }
+  EIGEN_DEVICE_FUNC static inline T bitwise_not(const T& a) { return bit_not<T>()(a); }
+};
+
+// Apply binary operations byte-by-byte
+template<typename T>
+struct bytewise_bitwise_helper {
+  EIGEN_DEVICE_FUNC static inline T bitwise_and(const T& a, const T& b) {
+    return binary(a, b, bit_and<unsigned char>());
+  }
+  EIGEN_DEVICE_FUNC static inline T bitwise_or(const T& a, const T& b) { 
+    return binary(a, b, bit_or<unsigned char>());
+   }
+  EIGEN_DEVICE_FUNC static inline T bitwise_xor(const T& a, const T& b) {
+    return binary(a, b, bit_xor<unsigned char>());
+  }
+  EIGEN_DEVICE_FUNC static inline T bitwise_not(const T& a) { 
+    return unary(a,bit_not<unsigned char>());
+   }
+  
+ private:
+  template<typename Op>
+  EIGEN_DEVICE_FUNC static inline T unary(const T& a, Op op) {
+    const unsigned char* a_ptr = reinterpret_cast<const unsigned char*>(&a);
+    T c;
+    unsigned char* c_ptr = reinterpret_cast<unsigned char*>(&c);
+    for (size_t i = 0; i < sizeof(T); ++i) {
+      *c_ptr++ = op(*a_ptr++);
+    }
+    return c;
+  }
+
+  template<typename Op>
+  EIGEN_DEVICE_FUNC static inline T binary(const T& a, const T& b, Op op) {
+    const unsigned char* a_ptr = reinterpret_cast<const unsigned char*>(&a);
+    const unsigned char* b_ptr = reinterpret_cast<const unsigned char*>(&b);
+    T c;
+    unsigned char* c_ptr = reinterpret_cast<unsigned char*>(&c);
+    for (size_t i = 0; i < sizeof(T); ++i) {
+      *c_ptr++ = op(*a_ptr++, *b_ptr++);
+    }
+    return c;
+  }
+};
+
+// In the general case, use byte-by-byte manipulation.
+template<typename T, typename EnableIf = void>
+struct bitwise_helper : public bytewise_bitwise_helper<T> {};
+
+// For integers or non-trivial scalars, use binary operators.
+template<typename T>
+struct bitwise_helper<T,
+  typename internal::enable_if<
+    is_scalar<T>::value && (NumTraits<T>::IsInteger || NumTraits<T>::RequireInitialization)>::type
+  > : public operator_bitwise_helper<T> {};
+
+/** \internal \returns the bitwise and of \a a and \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pand(const Packet& a, const Packet& b) {
+  return bitwise_helper<Packet>::bitwise_and(a, b);
+}
+
+/** \internal \returns the bitwise or of \a a and \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+por(const Packet& a, const Packet& b) {
+  return bitwise_helper<Packet>::bitwise_or(a, b);
+}
+
+/** \internal \returns the bitwise xor of \a a and \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pxor(const Packet& a, const Packet& b) {
+  return bitwise_helper<Packet>::bitwise_xor(a, b);
+}
+
+/** \internal \returns the bitwise not of \a a */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pnot(const Packet& a) {
+  return bitwise_helper<Packet>::bitwise_not(a);
+}
+
+/** \internal \returns the bitwise and of \a a and not \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pandnot(const Packet& a, const Packet& b) { return pand(a, pnot(b)); }
+
+// In the general case, use bitwise select.
+template<typename Packet, typename EnableIf = void>
+struct pselect_impl {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& mask, const Packet& a, const Packet& b) {
+    return por(pand(a,mask),pandnot(b,mask));
+  }
+};
+
+// For scalars, use ternary select.
+template<typename Packet>
+struct pselect_impl<Packet, 
+    typename internal::enable_if<is_scalar<Packet>::value>::type > {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& mask, const Packet& a, const Packet& b) {
+    return numext::equal_strict(mask, Packet(0)) ? b : a;
+  }
+};
+
+/** \internal \returns \a or \b for each field in packet according to \mask */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pselect(const Packet& mask, const Packet& a, const Packet& b) {
+  return pselect_impl<Packet>::run(mask, a, b);
+}
+
+template<> EIGEN_DEVICE_FUNC inline bool pselect<bool>(
+    const bool& cond, const bool& a, const bool& b) {
+  return cond ? a : b;
+}
+
+/** \internal \returns the min or of \a a and \a b (coeff-wise)
+    If either \a a or \a b are NaN, the result is implementation defined. */
+template<int NaNPropagation>
+struct pminmax_impl {
+  template <typename Packet, typename Op>
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
+    return op(a,b);
+  }
+};
+
+/** \internal \returns the min or max of \a a and \a b (coeff-wise)
+    If either \a a or \a b are NaN, NaN is returned. */
+template<>
+struct pminmax_impl<PropagateNaN> {
+  template <typename Packet, typename Op>
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
+  Packet not_nan_mask_a = pcmp_eq(a, a);
+  Packet not_nan_mask_b = pcmp_eq(b, b);
+  return pselect(not_nan_mask_a,
+                 pselect(not_nan_mask_b, op(a, b), b),
+                 a);
+  }
+};
+
+/** \internal \returns the min or max of \a a and \a b (coeff-wise)
+    If both \a a and \a b are NaN, NaN is returned.
+    Equivalent to std::fmin(a, b).  */
+template<>
+struct pminmax_impl<PropagateNumbers> {
+  template <typename Packet, typename Op>
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
+  Packet not_nan_mask_a = pcmp_eq(a, a);
+  Packet not_nan_mask_b = pcmp_eq(b, b);
+  return pselect(not_nan_mask_a,
+                 pselect(not_nan_mask_b, op(a, b), a),
+                 b);
+  }
+};
+
+
+#ifndef SYCL_DEVICE_ONLY
+#define EIGEN_BINARY_OP_NAN_PROPAGATION(Type, Func) Func
+#else
+#define EIGEN_BINARY_OP_NAN_PROPAGATION(Type, Func) \
+[](const Type& a, const Type& b) { \
+        return Func(a, b);}
+#endif
+
+/** \internal \returns the min of \a a and \a b  (coeff-wise).
+    If \a a or \b b is NaN, the return value is implementation defined. */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmin(const Packet& a, const Packet& b) { return numext::mini(a,b); }
+
+/** \internal \returns the min of \a a and \a b  (coeff-wise).
+    NaNPropagation determines the NaN propagation semantics. */
+template <int NaNPropagation, typename Packet>
+EIGEN_DEVICE_FUNC inline Packet pmin(const Packet& a, const Packet& b) {
+  return pminmax_impl<NaNPropagation>::run(a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet, (pmin<Packet>)));
+}
+
+/** \internal \returns the max of \a a and \a b  (coeff-wise)
+    If \a a or \b b is NaN, the return value is implementation defined. */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmax(const Packet& a, const Packet& b) { return numext::maxi(a, b); }
+
+/** \internal \returns the max of \a a and \a b  (coeff-wise).
+    NaNPropagation determines the NaN propagation semantics. */
+template <int NaNPropagation, typename Packet>
+EIGEN_DEVICE_FUNC inline Packet pmax(const Packet& a, const Packet& b) {
+  return pminmax_impl<NaNPropagation>::run(a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet,(pmax<Packet>)));
+}
+
+/** \internal \returns the absolute value of \a a */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pabs(const Packet& a) { return numext::abs(a); }
+template<> EIGEN_DEVICE_FUNC inline unsigned int
+pabs(const unsigned int& a) { return a; }
+template<> EIGEN_DEVICE_FUNC inline unsigned long
+pabs(const unsigned long& a) { return a; }
+template<> EIGEN_DEVICE_FUNC inline unsigned long long
+pabs(const unsigned long long& a) { return a; }
+
+/** \internal \returns the addsub value of \a a,b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+paddsub(const Packet& a, const Packet& b) {
+  return pselect(peven_mask(a), padd(a, b), psub(a, b));
+ }
+
+/** \internal \returns the phase angle of \a a */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+parg(const Packet& a) { using numext::arg; return arg(a); }
+
+
+/** \internal \returns \a a logically shifted by N bits to the right */
+template<int N> EIGEN_DEVICE_FUNC inline int
+parithmetic_shift_right(const int& a) { return a >> N; }
+template<int N> EIGEN_DEVICE_FUNC inline long int
+parithmetic_shift_right(const long int& a) { return a >> N; }
+
+/** \internal \returns \a a arithmetically shifted by N bits to the right */
+template<int N> EIGEN_DEVICE_FUNC inline int
+plogical_shift_right(const int& a) { return static_cast<int>(static_cast<unsigned int>(a) >> N); }
+template<int N> EIGEN_DEVICE_FUNC inline long int
+plogical_shift_right(const long int& a) { return static_cast<long>(static_cast<unsigned long>(a) >> N); }
+
+/** \internal \returns \a a shifted by N bits to the left */
+template<int N> EIGEN_DEVICE_FUNC inline int
+plogical_shift_left(const int& a) { return a << N; }
+template<int N> EIGEN_DEVICE_FUNC inline long int
+plogical_shift_left(const long int& a) { return a << N; }
+
+/** \internal \returns the significant and exponent of the underlying floating point numbers
+  * See https://en.cppreference.com/w/cpp/numeric/math/frexp
+  */
+template <typename Packet>
+EIGEN_DEVICE_FUNC inline Packet pfrexp(const Packet& a, Packet& exponent) {
+  int exp;
+  EIGEN_USING_STD(frexp);
+  Packet result = static_cast<Packet>(frexp(a, &exp));
+  exponent = static_cast<Packet>(exp);
+  return result;
+}
+
+/** \internal \returns a * 2^((int)exponent)
+  * See https://en.cppreference.com/w/cpp/numeric/math/ldexp
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pldexp(const Packet &a, const Packet &exponent) {
+  EIGEN_USING_STD(ldexp)
+  return static_cast<Packet>(ldexp(a, static_cast<int>(exponent)));
+}
+
+/** \internal \returns the min of \a a and \a b  (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pabsdiff(const Packet& a, const Packet& b) { return pselect(pcmp_lt(a, b), psub(b, a), psub(a, b)); }
+
+/** \internal \returns a packet version of \a *from, from must be 16 bytes aligned */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pload(const typename unpacket_traits<Packet>::type* from) { return *from; }
+
+/** \internal \returns a packet version of \a *from, (un-aligned load) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+ploadu(const typename unpacket_traits<Packet>::type* from) { return *from; }
+
+/** \internal \returns a packet version of \a *from, (un-aligned masked load)
+ * There is no generic implementation. We only have implementations for specialized
+ * cases. Generic case should not be called.
+ */
+template<typename Packet> EIGEN_DEVICE_FUNC inline
+typename enable_if<unpacket_traits<Packet>::masked_load_available, Packet>::type
+ploadu(const typename unpacket_traits<Packet>::type* from, typename unpacket_traits<Packet>::mask_t umask);
+
+/** \internal \returns a packet with constant coefficients \a a, e.g.: (a,a,a,a) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pset1(const typename unpacket_traits<Packet>::type& a) { return a; }
+
+/** \internal \returns a packet with constant coefficients set from bits */
+template<typename Packet,typename BitsType> EIGEN_DEVICE_FUNC inline Packet
+pset1frombits(BitsType a);
+
+/** \internal \returns a packet with constant coefficients \a a[0], e.g.: (a[0],a[0],a[0],a[0]) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pload1(const typename unpacket_traits<Packet>::type  *a) { return pset1<Packet>(*a); }
+
+/** \internal \returns a packet with elements of \a *from duplicated.
+  * For instance, for a packet of 8 elements, 4 scalars will be read from \a *from and
+  * duplicated to form: {from[0],from[0],from[1],from[1],from[2],from[2],from[3],from[3]}
+  * Currently, this function is only used for scalar * complex products.
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
+ploaddup(const typename unpacket_traits<Packet>::type* from) { return *from; }
+
+/** \internal \returns a packet with elements of \a *from quadrupled.
+  * For instance, for a packet of 8 elements, 2 scalars will be read from \a *from and
+  * replicated to form: {from[0],from[0],from[0],from[0],from[1],from[1],from[1],from[1]}
+  * Currently, this function is only used in matrix products.
+  * For packet-size smaller or equal to 4, this function is equivalent to pload1
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+ploadquad(const typename unpacket_traits<Packet>::type* from)
+{ return pload1<Packet>(from); }
+
+/** \internal equivalent to
+  * \code
+  * a0 = pload1(a+0);
+  * a1 = pload1(a+1);
+  * a2 = pload1(a+2);
+  * a3 = pload1(a+3);
+  * \endcode
+  * \sa pset1, pload1, ploaddup, pbroadcast2
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC
+inline void pbroadcast4(const typename unpacket_traits<Packet>::type *a,
+                        Packet& a0, Packet& a1, Packet& a2, Packet& a3)
+{
+  a0 = pload1<Packet>(a+0);
+  a1 = pload1<Packet>(a+1);
+  a2 = pload1<Packet>(a+2);
+  a3 = pload1<Packet>(a+3);
+}
+
+/** \internal equivalent to
+  * \code
+  * a0 = pload1(a+0);
+  * a1 = pload1(a+1);
+  * \endcode
+  * \sa pset1, pload1, ploaddup, pbroadcast4
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC
+inline void pbroadcast2(const typename unpacket_traits<Packet>::type *a,
+                        Packet& a0, Packet& a1)
+{
+  a0 = pload1<Packet>(a+0);
+  a1 = pload1<Packet>(a+1);
+}
+
+/** \internal \brief Returns a packet with coefficients (a,a+1,...,a+packet_size-1). */
+template<typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
+plset(const typename unpacket_traits<Packet>::type& a) { return a; }
+
+/** \internal \returns a packet with constant coefficients \a a, e.g.: (x, 0, x, 0),
+     where x is the value of all 1-bits. */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+peven_mask(const Packet& /*a*/) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  const size_t n = unpacket_traits<Packet>::size;
+  EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar elements[n];
+  for(size_t i = 0; i < n; ++i) {
+    memset(elements+i, ((i & 1) == 0 ? 0xff : 0), sizeof(Scalar));
+  }
+  return ploadu<Packet>(elements);
+}
+
+
+/** \internal copy the packet \a from to \a *to, \a to must be 16 bytes aligned */
+template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstore(Scalar* to, const Packet& from)
+{ (*to) = from; }
+
+/** \internal copy the packet \a from to \a *to, (un-aligned store) */
+template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstoreu(Scalar* to, const Packet& from)
+{  (*to) = from; }
+
+/** \internal copy the packet \a from to \a *to, (un-aligned store with a mask)
+ * There is no generic implementation. We only have implementations for specialized
+ * cases. Generic case should not be called.
+ */
+template<typename Scalar, typename Packet>
+EIGEN_DEVICE_FUNC inline
+typename enable_if<unpacket_traits<Packet>::masked_store_available, void>::type
+pstoreu(Scalar* to, const Packet& from, typename unpacket_traits<Packet>::mask_t umask);
+
+ template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather(const Scalar* from, Index /*stride*/)
+ { return ploadu<Packet>(from); }
+
+ template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pscatter(Scalar* to, const Packet& from, Index /*stride*/)
+ { pstore(to, from); }
+
+/** \internal tries to do cache prefetching of \a addr */
+template<typename Scalar> EIGEN_DEVICE_FUNC inline void prefetch(const Scalar* addr)
+{
+#if defined(EIGEN_HIP_DEVICE_COMPILE)
+  // do nothing
+#elif defined(EIGEN_CUDA_ARCH)
+#if defined(__LP64__) || EIGEN_OS_WIN64
+  // 64-bit pointer operand constraint for inlined asm
+  asm(" prefetch.L1 [ %1 ];" : "=l"(addr) : "l"(addr));
+#else
+  // 32-bit pointer operand constraint for inlined asm
+  asm(" prefetch.L1 [ %1 ];" : "=r"(addr) : "r"(addr));
+#endif
+#elif (!EIGEN_COMP_MSVC) && (EIGEN_COMP_GNUC || EIGEN_COMP_CLANG || EIGEN_COMP_ICC)
+  __builtin_prefetch(addr);
+#endif
+}
+
+/** \internal \returns the reversed elements of \a a*/
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet preverse(const Packet& a)
+{ return a; }
+
+/** \internal \returns \a a with real and imaginary part flipped (for complex type only) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet pcplxflip(const Packet& a)
+{
+  return Packet(numext::imag(a),numext::real(a));
+}
+
+/**************************
+* Special math functions
+***************************/
+
+/** \internal \returns the sine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet psin(const Packet& a) { EIGEN_USING_STD(sin); return sin(a); }
+
+/** \internal \returns the cosine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pcos(const Packet& a) { EIGEN_USING_STD(cos); return cos(a); }
+
+/** \internal \returns the tan of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet ptan(const Packet& a) { EIGEN_USING_STD(tan); return tan(a); }
+
+/** \internal \returns the arc sine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pasin(const Packet& a) { EIGEN_USING_STD(asin); return asin(a); }
+
+/** \internal \returns the arc cosine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pacos(const Packet& a) { EIGEN_USING_STD(acos); return acos(a); }
+
+/** \internal \returns the arc tangent of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet patan(const Packet& a) { EIGEN_USING_STD(atan); return atan(a); }
+
+/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet psinh(const Packet& a) { EIGEN_USING_STD(sinh); return sinh(a); }
+
+/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pcosh(const Packet& a) { EIGEN_USING_STD(cosh); return cosh(a); }
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet ptanh(const Packet& a) { EIGEN_USING_STD(tanh); return tanh(a); }
+
+/** \internal \returns the exp of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pexp(const Packet& a) { EIGEN_USING_STD(exp); return exp(a); }
+
+/** \internal \returns the expm1 of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pexpm1(const Packet& a) { return numext::expm1(a); }
+
+/** \internal \returns the log of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog(const Packet& a) { EIGEN_USING_STD(log); return log(a); }
+
+/** \internal \returns the log1p of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog1p(const Packet& a) { return numext::log1p(a); }
+
+/** \internal \returns the log10 of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog10(const Packet& a) { EIGEN_USING_STD(log10); return log10(a); }
+
+/** \internal \returns the log10 of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog2(const Packet& a) {
+  typedef typename internal::unpacket_traits<Packet>::type Scalar;
+  return pmul(pset1<Packet>(Scalar(EIGEN_LOG2E)), plog(a)); 
+}
+
+/** \internal \returns the square-root of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet psqrt(const Packet& a) { return numext::sqrt(a); }
+
+/** \internal \returns the reciprocal square-root of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet prsqrt(const Packet& a) {
+  typedef typename internal::unpacket_traits<Packet>::type Scalar;
+  return pdiv(pset1<Packet>(Scalar(1)), psqrt(a));
+}
+
+/** \internal \returns the rounded value of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pround(const Packet& a) { using numext::round; return round(a); }
+
+/** \internal \returns the floor of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pfloor(const Packet& a) { using numext::floor; return floor(a); }
+
+/** \internal \returns the rounded value of \a a (coeff-wise) with current
+ * rounding mode */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet print(const Packet& a) { using numext::rint; return rint(a); }
+
+/** \internal \returns the ceil of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pceil(const Packet& a) { using numext::ceil; return ceil(a); }
+
+/** \internal \returns the first element of a packet */
+template<typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type
+pfirst(const Packet& a)
+{ return a; }
+
+/** \internal \returns the sum of the elements of upper and lower half of \a a if \a a is larger than 4.
+  * For a packet {a0, a1, a2, a3, a4, a5, a6, a7}, it returns a half packet {a0+a4, a1+a5, a2+a6, a3+a7}
+  * For packet-size smaller or equal to 4, this boils down to a noop.
+  */
+template<typename Packet>
+EIGEN_DEVICE_FUNC inline typename conditional<(unpacket_traits<Packet>::size%8)==0,typename unpacket_traits<Packet>::half,Packet>::type
+predux_half_dowto4(const Packet& a)
+{ return a; }
+
+// Slow generic implementation of Packet reduction.
+template <typename Packet, typename Op>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type
+predux_helper(const Packet& a, Op op) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  const size_t n = unpacket_traits<Packet>::size;
+  EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar elements[n];
+  pstoreu<Scalar>(elements, a);
+  for(size_t k = n / 2; k > 0; k /= 2)  {
+    for(size_t i = 0; i < k; ++i) {
+      elements[i] = op(elements[i], elements[i + k]);
+    }
+  }
+  return elements[0];
+}
+
+/** \internal \returns the sum of the elements of \a a*/
+template<typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type
+predux(const Packet& a)
+{
+  return a;
+}
+
+/** \internal \returns the product of the elements of \a a */
+template <typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_mul(
+    const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type Scalar; 
+  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmul<Scalar>)));
+}
+
+/** \internal \returns the min of the elements of \a a */
+template <typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_min(
+    const Packet &a) {
+  typedef typename unpacket_traits<Packet>::type Scalar; 
+  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmin<PropagateFast, Scalar>)));
+}
+
+template <int NaNPropagation, typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_min(
+    const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type Scalar; 
+  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmin<NaNPropagation, Scalar>)));
+}
+
+/** \internal \returns the min of the elements of \a a */
+template <typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_max(
+    const Packet &a) {
+  typedef typename unpacket_traits<Packet>::type Scalar; 
+  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmax<PropagateFast, Scalar>)));
+}
+
+template <int NaNPropagation, typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_max(
+    const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type Scalar; 
+  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmax<NaNPropagation, Scalar>)));
+}
+
+#undef EIGEN_BINARY_OP_NAN_PROPAGATION
+
+/** \internal \returns true if all coeffs of \a a means "true"
+  * It is supposed to be called on values returned by pcmp_*.
+  */
+// not needed yet
+// template<typename Packet> EIGEN_DEVICE_FUNC inline bool predux_all(const Packet& a)
+// { return bool(a); }
+
+/** \internal \returns true if any coeffs of \a a means "true"
+  * It is supposed to be called on values returned by pcmp_*.
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC inline bool predux_any(const Packet& a)
+{
+  // Dirty but generic implementation where "true" is assumed to be non 0 and all the sames.
+  // It is expected that "true" is either:
+  //  - Scalar(1)
+  //  - bits full of ones (NaN for floats),
+  //  - or first bit equals to 1 (1 for ints, smallest denormal for floats).
+  // For all these cases, taking the sum is just fine, and this boils down to a no-op for scalars.
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  return numext::not_equal_strict(predux(a), Scalar(0));
+}
+
+/***************************************************************************
+* The following functions might not have to be overwritten for vectorized types
+***************************************************************************/
+
+/** \internal copy a packet with constant coefficient \a a (e.g., [a,a,a,a]) to \a *to. \a to must be 16 bytes aligned */
+// NOTE: this function must really be templated on the packet type (think about different packet types for the same scalar type)
+template<typename Packet>
+inline void pstore1(typename unpacket_traits<Packet>::type* to, const typename unpacket_traits<Packet>::type& a)
+{
+  pstore(to, pset1<Packet>(a));
+}
+
+/** \internal \returns a * b + c (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmadd(const Packet&  a,
+         const Packet&  b,
+         const Packet&  c)
+{ return padd(pmul(a, b),c); }
+
+/** \internal \returns a packet version of \a *from.
+  * The pointer \a from must be aligned on a \a Alignment bytes boundary. */
+template<typename Packet, int Alignment>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt(const typename unpacket_traits<Packet>::type* from)
+{
+  if(Alignment >= unpacket_traits<Packet>::alignment)
+    return pload<Packet>(from);
+  else
+    return ploadu<Packet>(from);
+}
+
+/** \internal copy the packet \a from to \a *to.
+  * The pointer \a from must be aligned on a \a Alignment bytes boundary. */
+template<typename Scalar, typename Packet, int Alignment>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(Scalar* to, const Packet& from)
+{
+  if(Alignment >= unpacket_traits<Packet>::alignment)
+    pstore(to, from);
+  else
+    pstoreu(to, from);
+}
+
+/** \internal \returns a packet version of \a *from.
+  * Unlike ploadt, ploadt_ro takes advantage of the read-only memory path on the
+  * hardware if available to speedup the loading of data that won't be modified
+  * by the current computation.
+  */
+template<typename Packet, int LoadMode>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt_ro(const typename unpacket_traits<Packet>::type* from)
+{
+  return ploadt<Packet, LoadMode>(from);
+}
+
+/***************************************************************************
+* Fast complex products (GCC generates a function call which is very slow)
+***************************************************************************/
+
+// Eigen+CUDA does not support complexes.
+#if !defined(EIGEN_GPUCC)
+
+template<> inline std::complex<float> pmul(const std::complex<float>& a, const std::complex<float>& b)
+{ return std::complex<float>(a.real()*b.real() - a.imag()*b.imag(), a.imag()*b.real() + a.real()*b.imag()); }
+
+template<> inline std::complex<double> pmul(const std::complex<double>& a, const std::complex<double>& b)
+{ return std::complex<double>(a.real()*b.real() - a.imag()*b.imag(), a.imag()*b.real() + a.real()*b.imag()); }
+
+#endif
+
+
+/***************************************************************************
+ * PacketBlock, that is a collection of N packets where the number of words
+ * in the packet is a multiple of N.
+***************************************************************************/
+template <typename Packet,int N=unpacket_traits<Packet>::size> struct PacketBlock {
+  Packet packet[N];
+};
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet,1>& /*kernel*/) {
+  // Nothing to do in the scalar case, i.e. a 1x1 matrix.
+}
+
+/***************************************************************************
+ * Selector, i.e. vector of N boolean values used to select (i.e. blend)
+ * words from 2 packets.
+***************************************************************************/
+template <size_t N> struct Selector {
+  bool select[N];
+};
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pblend(const Selector<unpacket_traits<Packet>::size>& ifPacket, const Packet& thenPacket, const Packet& elsePacket) {
+  return ifPacket.select[0] ? thenPacket : elsePacket;
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERIC_PACKET_MATH_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/GlobalFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/GlobalFunctions.h
new file mode 100644
index 00000000..629af94b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/GlobalFunctions.h
@@ -0,0 +1,194 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GLOBAL_FUNCTIONS_H
+#define EIGEN_GLOBAL_FUNCTIONS_H
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(NAME,FUNCTOR,DOC_OP,DOC_DETAILS) \
+  /** \returns an expression of the coefficient-wise DOC_OP of \a x
+
+    DOC_DETAILS
+
+    \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_##NAME">Math functions</a>, class CwiseUnaryOp
+    */ \
+  template<typename Derived> \
+  inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> \
+  NAME(const Eigen::ArrayBase<Derived>& x);
+
+#else
+
+#define EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(NAME,FUNCTOR,DOC_OP,DOC_DETAILS) \
+  template<typename Derived> \
+  inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> \
+  (NAME)(const Eigen::ArrayBase<Derived>& x) { \
+    return Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived>(x.derived()); \
+  }
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME,FUNCTOR) \
+  \
+  template<typename Derived> \
+  struct NAME##_retval<ArrayBase<Derived> > \
+  { \
+    typedef const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> type; \
+  }; \
+  template<typename Derived> \
+  struct NAME##_impl<ArrayBase<Derived> > \
+  { \
+    static inline typename NAME##_retval<ArrayBase<Derived> >::type run(const Eigen::ArrayBase<Derived>& x) \
+    { \
+      return typename NAME##_retval<ArrayBase<Derived> >::type(x.derived()); \
+    } \
+  };
+
+namespace Eigen
+{
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(real,scalar_real_op,real part,\sa ArrayBase::real)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(imag,scalar_imag_op,imaginary part,\sa ArrayBase::imag)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(conj,scalar_conjugate_op,complex conjugate,\sa ArrayBase::conjugate)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(inverse,scalar_inverse_op,inverse,\sa ArrayBase::inverse)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sin,scalar_sin_op,sine,\sa ArrayBase::sin)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cos,scalar_cos_op,cosine,\sa ArrayBase::cos)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tan,scalar_tan_op,tangent,\sa ArrayBase::tan)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(atan,scalar_atan_op,arc-tangent,\sa ArrayBase::atan)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(asin,scalar_asin_op,arc-sine,\sa ArrayBase::asin)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(acos,scalar_acos_op,arc-consine,\sa ArrayBase::acos)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sinh,scalar_sinh_op,hyperbolic sine,\sa ArrayBase::sinh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cosh,scalar_cosh_op,hyperbolic cosine,\sa ArrayBase::cosh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tanh,scalar_tanh_op,hyperbolic tangent,\sa ArrayBase::tanh)
+#if EIGEN_HAS_CXX11_MATH
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(asinh,scalar_asinh_op,inverse hyperbolic sine,\sa ArrayBase::asinh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(acosh,scalar_acosh_op,inverse hyperbolic cosine,\sa ArrayBase::acosh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(atanh,scalar_atanh_op,inverse hyperbolic tangent,\sa ArrayBase::atanh)
+#endif
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(logistic,scalar_logistic_op,logistic function,\sa ArrayBase::logistic)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(lgamma,scalar_lgamma_op,natural logarithm of the gamma function,\sa ArrayBase::lgamma)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(digamma,scalar_digamma_op,derivative of lgamma,\sa ArrayBase::digamma)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(erf,scalar_erf_op,error function,\sa ArrayBase::erf)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(erfc,scalar_erfc_op,complement error function,\sa ArrayBase::erfc)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(ndtri,scalar_ndtri_op,inverse normal distribution function,\sa ArrayBase::ndtri)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(exp,scalar_exp_op,exponential,\sa ArrayBase::exp)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(expm1,scalar_expm1_op,exponential of a value minus 1,\sa ArrayBase::expm1)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log,scalar_log_op,natural logarithm,\sa Eigen::log10 DOXCOMMA ArrayBase::log)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log1p,scalar_log1p_op,natural logarithm of 1 plus the value,\sa ArrayBase::log1p)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log10,scalar_log10_op,base 10 logarithm,\sa Eigen::log DOXCOMMA ArrayBase::log10)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log2,scalar_log2_op,base 2 logarithm,\sa Eigen::log DOXCOMMA ArrayBase::log2)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs,scalar_abs_op,absolute value,\sa ArrayBase::abs DOXCOMMA MatrixBase::cwiseAbs)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs2,scalar_abs2_op,squared absolute value,\sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(arg,scalar_arg_op,complex argument,\sa ArrayBase::arg DOXCOMMA MatrixBase::cwiseArg)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sqrt,scalar_sqrt_op,square root,\sa ArrayBase::sqrt DOXCOMMA MatrixBase::cwiseSqrt)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(rsqrt,scalar_rsqrt_op,reciprocal square root,\sa ArrayBase::rsqrt)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(square,scalar_square_op,square (power 2),\sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cube,scalar_cube_op,cube (power 3),\sa Eigen::pow DOXCOMMA ArrayBase::cube)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(rint,scalar_rint_op,nearest integer,\sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(round,scalar_round_op,nearest integer,\sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(floor,scalar_floor_op,nearest integer not greater than the giben value,\sa Eigen::ceil DOXCOMMA ArrayBase::floor)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(ceil,scalar_ceil_op,nearest integer not less than the giben value,\sa Eigen::floor DOXCOMMA ArrayBase::ceil)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isnan,scalar_isnan_op,not-a-number test,\sa Eigen::isinf DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isnan)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isinf,scalar_isinf_op,infinite value test,\sa Eigen::isnan DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isinf)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isfinite,scalar_isfinite_op,finite value test,\sa Eigen::isinf DOXCOMMA Eigen::isnan DOXCOMMA ArrayBase::isfinite)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sign,scalar_sign_op,sign (or 0),\sa ArrayBase::sign)
+
+  /** \returns an expression of the coefficient-wise power of \a x to the given constant \a exponent.
+    *
+    * \tparam ScalarExponent is the scalar type of \a exponent. It must be compatible with the scalar type of the given expression (\c Derived::Scalar).
+    *
+    * \sa ArrayBase::pow()
+    *
+    * \relates ArrayBase
+    */
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  template<typename Derived,typename ScalarExponent>
+  inline const CwiseBinaryOp<internal::scalar_pow_op<Derived::Scalar,ScalarExponent>,Derived,Constant<ScalarExponent> >
+  pow(const Eigen::ArrayBase<Derived>& x, const ScalarExponent& exponent);
+#else
+  template <typename Derived,typename ScalarExponent>
+  EIGEN_DEVICE_FUNC inline
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(
+    const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,typename internal::promote_scalar_arg<typename Derived::Scalar
+                                                 EIGEN_COMMA ScalarExponent EIGEN_COMMA
+                                                 EIGEN_SCALAR_BINARY_SUPPORTED(pow,typename Derived::Scalar,ScalarExponent)>::type,pow))
+  pow(const Eigen::ArrayBase<Derived>& x, const ScalarExponent& exponent)
+  {
+    typedef typename internal::promote_scalar_arg<typename Derived::Scalar,ScalarExponent,
+                                                  EIGEN_SCALAR_BINARY_SUPPORTED(pow,typename Derived::Scalar,ScalarExponent)>::type PromotedExponent;
+    return EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,PromotedExponent,pow)(x.derived(),
+           typename internal::plain_constant_type<Derived,PromotedExponent>::type(x.derived().rows(), x.derived().cols(), internal::scalar_constant_op<PromotedExponent>(exponent)));
+  }
+#endif
+
+  /** \returns an expression of the coefficient-wise power of \a x to the given array of \a exponents.
+    *
+    * This function computes the coefficient-wise power.
+    *
+    * Example: \include Cwise_array_power_array.cpp
+    * Output: \verbinclude Cwise_array_power_array.out
+    *
+    * \sa ArrayBase::pow()
+    *
+    * \relates ArrayBase
+    */
+  template<typename Derived,typename ExponentDerived>
+  inline const Eigen::CwiseBinaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar, typename ExponentDerived::Scalar>, const Derived, const ExponentDerived>
+  pow(const Eigen::ArrayBase<Derived>& x, const Eigen::ArrayBase<ExponentDerived>& exponents)
+  {
+    return Eigen::CwiseBinaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar, typename ExponentDerived::Scalar>, const Derived, const ExponentDerived>(
+      x.derived(),
+      exponents.derived()
+    );
+  }
+
+  /** \returns an expression of the coefficient-wise power of the scalar \a x to the given array of \a exponents.
+    *
+    * This function computes the coefficient-wise power between a scalar and an array of exponents.
+    *
+    * \tparam Scalar is the scalar type of \a x. It must be compatible with the scalar type of the given array expression (\c Derived::Scalar).
+    *
+    * Example: \include Cwise_scalar_power_array.cpp
+    * Output: \verbinclude Cwise_scalar_power_array.out
+    *
+    * \sa ArrayBase::pow()
+    *
+    * \relates ArrayBase
+    */
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  template<typename Scalar,typename Derived>
+  inline const CwiseBinaryOp<internal::scalar_pow_op<Scalar,Derived::Scalar>,Constant<Scalar>,Derived>
+  pow(const Scalar& x,const Eigen::ArrayBase<Derived>& x);
+#else
+  template <typename Scalar, typename Derived>
+  EIGEN_DEVICE_FUNC inline
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(
+    const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename internal::promote_scalar_arg<typename Derived::Scalar
+                                                 EIGEN_COMMA Scalar EIGEN_COMMA
+                                                 EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type,Derived,pow))
+  pow(const Scalar& x, const Eigen::ArrayBase<Derived>& exponents) {
+    typedef typename internal::promote_scalar_arg<typename Derived::Scalar,Scalar,
+                                                  EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type PromotedScalar;
+    return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedScalar,Derived,pow)(
+           typename internal::plain_constant_type<Derived,PromotedScalar>::type(exponents.derived().rows(), exponents.derived().cols(), internal::scalar_constant_op<PromotedScalar>(x)), exponents.derived());
+  }
+#endif
+
+
+  namespace internal
+  {
+    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(real,scalar_real_op)
+    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(imag,scalar_imag_op)
+    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs2,scalar_abs2_op)
+  }
+}
+
+// TODO: cleanly disable those functions that are not supported on Array (numext::real_ref, internal::random, internal::isApprox...)
+
+#endif // EIGEN_GLOBAL_FUNCTIONS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/IO.h b/C++/yolo_bytetrack/include/Eigen/src/Core/IO.h
new file mode 100644
index 00000000..e81c3152
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/IO.h
@@ -0,0 +1,258 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_IO_H
+#define EIGEN_IO_H
+
+namespace Eigen { 
+
+enum { DontAlignCols = 1 };
+enum { StreamPrecision = -1,
+       FullPrecision = -2 };
+
+namespace internal {
+template<typename Derived>
+std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt);
+}
+
+/** \class IOFormat
+  * \ingroup Core_Module
+  *
+  * \brief Stores a set of parameters controlling the way matrices are printed
+  *
+  * List of available parameters:
+  *  - \b precision number of digits for floating point values, or one of the special constants \c StreamPrecision and \c FullPrecision.
+  *                 The default is the special value \c StreamPrecision which means to use the
+  *                 stream's own precision setting, as set for instance using \c cout.precision(3). The other special value
+  *                 \c FullPrecision means that the number of digits will be computed to match the full precision of each floating-point
+  *                 type.
+  *  - \b flags an OR-ed combination of flags, the default value is 0, the only currently available flag is \c DontAlignCols which
+  *             allows to disable the alignment of columns, resulting in faster code.
+  *  - \b coeffSeparator string printed between two coefficients of the same row
+  *  - \b rowSeparator string printed between two rows
+  *  - \b rowPrefix string printed at the beginning of each row
+  *  - \b rowSuffix string printed at the end of each row
+  *  - \b matPrefix string printed at the beginning of the matrix
+  *  - \b matSuffix string printed at the end of the matrix
+  *  - \b fill character printed to fill the empty space in aligned columns
+  *
+  * Example: \include IOFormat.cpp
+  * Output: \verbinclude IOFormat.out
+  *
+  * \sa DenseBase::format(), class WithFormat
+  */
+struct IOFormat
+{
+  /** Default constructor, see class IOFormat for the meaning of the parameters */
+  IOFormat(int _precision = StreamPrecision, int _flags = 0,
+    const std::string& _coeffSeparator = " ",
+    const std::string& _rowSeparator = "\n", const std::string& _rowPrefix="", const std::string& _rowSuffix="",
+    const std::string& _matPrefix="", const std::string& _matSuffix="", const char _fill=' ')
+  : matPrefix(_matPrefix), matSuffix(_matSuffix), rowPrefix(_rowPrefix), rowSuffix(_rowSuffix), rowSeparator(_rowSeparator),
+    rowSpacer(""), coeffSeparator(_coeffSeparator), fill(_fill), precision(_precision), flags(_flags)
+  {
+    // TODO check if rowPrefix, rowSuffix or rowSeparator contains a newline
+    // don't add rowSpacer if columns are not to be aligned
+    if((flags & DontAlignCols))
+      return;
+    int i = int(matSuffix.length())-1;
+    while (i>=0 && matSuffix[i]!='\n')
+    {
+      rowSpacer += ' ';
+      i--;
+    }
+  }
+  std::string matPrefix, matSuffix;
+  std::string rowPrefix, rowSuffix, rowSeparator, rowSpacer;
+  std::string coeffSeparator;
+  char fill;
+  int precision;
+  int flags;
+};
+
+/** \class WithFormat
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression providing matrix output with given format
+  *
+  * \tparam ExpressionType the type of the object on which IO stream operations are performed
+  *
+  * This class represents an expression with stream operators controlled by a given IOFormat.
+  * It is the return type of DenseBase::format()
+  * and most of the time this is the only way it is used.
+  *
+  * See class IOFormat for some examples.
+  *
+  * \sa DenseBase::format(), class IOFormat
+  */
+template<typename ExpressionType>
+class WithFormat
+{
+  public:
+
+    WithFormat(const ExpressionType& matrix, const IOFormat& format)
+      : m_matrix(matrix), m_format(format)
+    {}
+
+    friend std::ostream & operator << (std::ostream & s, const WithFormat& wf)
+    {
+      return internal::print_matrix(s, wf.m_matrix.eval(), wf.m_format);
+    }
+
+  protected:
+    typename ExpressionType::Nested m_matrix;
+    IOFormat m_format;
+};
+
+namespace internal {
+
+// NOTE: This helper is kept for backward compatibility with previous code specializing
+//       this internal::significant_decimals_impl structure. In the future we should directly
+//       call digits10() which has been introduced in July 2016 in 3.3.
+template<typename Scalar>
+struct significant_decimals_impl
+{
+  static inline int run()
+  {
+    return NumTraits<Scalar>::digits10();
+  }
+};
+
+/** \internal
+  * print the matrix \a _m to the output stream \a s using the output format \a fmt */
+template<typename Derived>
+std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt)
+{
+  using internal::is_same;
+  using internal::conditional;
+
+  if(_m.size() == 0)
+  {
+    s << fmt.matPrefix << fmt.matSuffix;
+    return s;
+  }
+  
+  typename Derived::Nested m = _m;
+  typedef typename Derived::Scalar Scalar;
+  typedef typename
+      conditional<
+          is_same<Scalar, char>::value ||
+            is_same<Scalar, unsigned char>::value ||
+            is_same<Scalar, numext::int8_t>::value ||
+            is_same<Scalar, numext::uint8_t>::value,
+          int,
+          typename conditional<
+              is_same<Scalar, std::complex<char> >::value ||
+                is_same<Scalar, std::complex<unsigned char> >::value ||
+                is_same<Scalar, std::complex<numext::int8_t> >::value ||
+                is_same<Scalar, std::complex<numext::uint8_t> >::value,
+              std::complex<int>,
+              const Scalar&
+            >::type
+        >::type PrintType;
+
+  Index width = 0;
+
+  std::streamsize explicit_precision;
+  if(fmt.precision == StreamPrecision)
+  {
+    explicit_precision = 0;
+  }
+  else if(fmt.precision == FullPrecision)
+  {
+    if (NumTraits<Scalar>::IsInteger)
+    {
+      explicit_precision = 0;
+    }
+    else
+    {
+      explicit_precision = significant_decimals_impl<Scalar>::run();
+    }
+  }
+  else
+  {
+    explicit_precision = fmt.precision;
+  }
+
+  std::streamsize old_precision = 0;
+  if(explicit_precision) old_precision = s.precision(explicit_precision);
+
+  bool align_cols = !(fmt.flags & DontAlignCols);
+  if(align_cols)
+  {
+    // compute the largest width
+    for(Index j = 0; j < m.cols(); ++j)
+      for(Index i = 0; i < m.rows(); ++i)
+      {
+        std::stringstream sstr;
+        sstr.copyfmt(s);
+        sstr << static_cast<PrintType>(m.coeff(i,j));
+        width = std::max<Index>(width, Index(sstr.str().length()));
+      }
+  }
+  std::streamsize old_width = s.width();
+  char old_fill_character = s.fill();
+  s << fmt.matPrefix;
+  for(Index i = 0; i < m.rows(); ++i)
+  {
+    if (i)
+      s << fmt.rowSpacer;
+    s << fmt.rowPrefix;
+    if(width) {
+      s.fill(fmt.fill);
+      s.width(width);
+    }
+    s << static_cast<PrintType>(m.coeff(i, 0));
+    for(Index j = 1; j < m.cols(); ++j)
+    {
+      s << fmt.coeffSeparator;
+      if(width) {
+        s.fill(fmt.fill);
+        s.width(width);
+      }
+      s << static_cast<PrintType>(m.coeff(i, j));
+    }
+    s << fmt.rowSuffix;
+    if( i < m.rows() - 1)
+      s << fmt.rowSeparator;
+  }
+  s << fmt.matSuffix;
+  if(explicit_precision) s.precision(old_precision);
+  if(width) {
+    s.fill(old_fill_character);
+    s.width(old_width);
+  }
+  return s;
+}
+
+} // end namespace internal
+
+/** \relates DenseBase
+  *
+  * Outputs the matrix, to the given stream.
+  *
+  * If you wish to print the matrix with a format different than the default, use DenseBase::format().
+  *
+  * It is also possible to change the default format by defining EIGEN_DEFAULT_IO_FORMAT before including Eigen headers.
+  * If not defined, this will automatically be defined to Eigen::IOFormat(), that is the Eigen::IOFormat with default parameters.
+  *
+  * \sa DenseBase::format()
+  */
+template<typename Derived>
+std::ostream & operator <<
+(std::ostream & s,
+ const DenseBase<Derived> & m)
+{
+  return internal::print_matrix(s, m.eval(), EIGEN_DEFAULT_IO_FORMAT);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_IO_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/IndexedView.h b/C++/yolo_bytetrack/include/Eigen/src/Core/IndexedView.h
new file mode 100644
index 00000000..08476251
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/IndexedView.h
@@ -0,0 +1,237 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INDEXED_VIEW_H
+#define EIGEN_INDEXED_VIEW_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename XprType, typename RowIndices, typename ColIndices>
+struct traits<IndexedView<XprType, RowIndices, ColIndices> >
+ : traits<XprType>
+{
+  enum {
+    RowsAtCompileTime = int(array_size<RowIndices>::value),
+    ColsAtCompileTime = int(array_size<ColIndices>::value),
+    MaxRowsAtCompileTime = RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime) : Dynamic,
+    MaxColsAtCompileTime = ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime) : Dynamic,
+
+    XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0,
+    IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
+               : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
+               : XprTypeIsRowMajor,
+
+    RowIncr = int(get_compile_time_incr<RowIndices>::value),
+    ColIncr = int(get_compile_time_incr<ColIndices>::value),
+    InnerIncr = IsRowMajor ? ColIncr : RowIncr,
+    OuterIncr = IsRowMajor ? RowIncr : ColIncr,
+
+    HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
+    XprInnerStride = HasSameStorageOrderAsXprType ? int(inner_stride_at_compile_time<XprType>::ret) : int(outer_stride_at_compile_time<XprType>::ret),
+    XprOuterstride = HasSameStorageOrderAsXprType ? int(outer_stride_at_compile_time<XprType>::ret) : int(inner_stride_at_compile_time<XprType>::ret),
+
+    InnerSize = XprTypeIsRowMajor ? ColsAtCompileTime : RowsAtCompileTime,
+    IsBlockAlike = InnerIncr==1 && OuterIncr==1,
+    IsInnerPannel = HasSameStorageOrderAsXprType && is_same<AllRange<InnerSize>,typename conditional<XprTypeIsRowMajor,ColIndices,RowIndices>::type>::value,
+
+    InnerStrideAtCompileTime = InnerIncr<0 || InnerIncr==DynamicIndex || XprInnerStride==Dynamic ? Dynamic : XprInnerStride * InnerIncr,
+    OuterStrideAtCompileTime = OuterIncr<0 || OuterIncr==DynamicIndex || XprOuterstride==Dynamic ? Dynamic : XprOuterstride * OuterIncr,
+
+    ReturnAsScalar = is_same<RowIndices,SingleRange>::value && is_same<ColIndices,SingleRange>::value,
+    ReturnAsBlock = (!ReturnAsScalar) && IsBlockAlike,
+    ReturnAsIndexedView = (!ReturnAsScalar) && (!ReturnAsBlock),
+
+    // FIXME we deal with compile-time strides if and only if we have DirectAccessBit flag,
+    // but this is too strict regarding negative strides...
+    DirectAccessMask = (int(InnerIncr)!=UndefinedIncr && int(OuterIncr)!=UndefinedIncr && InnerIncr>=0 && OuterIncr>=0) ? DirectAccessBit : 0,
+    FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
+    FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
+    FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
+    Flags = (traits<XprType>::Flags & (HereditaryBits | DirectAccessMask )) | FlagsLvalueBit | FlagsRowMajorBit | FlagsLinearAccessBit
+  };
+
+  typedef Block<XprType,RowsAtCompileTime,ColsAtCompileTime,IsInnerPannel> BlockType;
+};
+
+}
+
+template<typename XprType, typename RowIndices, typename ColIndices, typename StorageKind>
+class IndexedViewImpl;
+
+
+/** \class IndexedView
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a non-sequential sub-matrix defined by arbitrary sequences of row and column indices
+  *
+  * \tparam XprType the type of the expression in which we are taking the intersections of sub-rows and sub-columns
+  * \tparam RowIndices the type of the object defining the sequence of row indices
+  * \tparam ColIndices the type of the object defining the sequence of column indices
+  *
+  * This class represents an expression of a sub-matrix (or sub-vector) defined as the intersection
+  * of sub-sets of rows and columns, that are themself defined by generic sequences of row indices \f$ \{r_0,r_1,..r_{m-1}\} \f$
+  * and column indices \f$ \{c_0,c_1,..c_{n-1} \}\f$. Let \f$ A \f$  be the nested matrix, then the resulting matrix \f$ B \f$ has \c m
+  * rows and \c n columns, and its entries are given by: \f$ B(i,j) = A(r_i,c_j) \f$.
+  *
+  * The \c RowIndices and \c ColIndices types must be compatible with the following API:
+  * \code
+  * <integral type> operator[](Index) const;
+  * Index size() const;
+  * \endcode
+  *
+  * Typical supported types thus include:
+  *  - std::vector<int>
+  *  - std::valarray<int>
+  *  - std::array<int>
+  *  - Plain C arrays: int[N]
+  *  - Eigen::ArrayXi
+  *  - decltype(ArrayXi::LinSpaced(...))
+  *  - Any view/expressions of the previous types
+  *  - Eigen::ArithmeticSequence
+  *  - Eigen::internal::AllRange      (helper for Eigen::all)
+  *  - Eigen::internal::SingleRange  (helper for single index)
+  *  - etc.
+  *
+  * In typical usages of %Eigen, this class should never be used directly. It is the return type of
+  * DenseBase::operator()(const RowIndices&, const ColIndices&).
+  *
+  * \sa class Block
+  */
+template<typename XprType, typename RowIndices, typename ColIndices>
+class IndexedView : public IndexedViewImpl<XprType, RowIndices, ColIndices, typename internal::traits<XprType>::StorageKind>
+{
+public:
+  typedef typename IndexedViewImpl<XprType, RowIndices, ColIndices, typename internal::traits<XprType>::StorageKind>::Base Base;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(IndexedView)
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(IndexedView)
+
+  typedef typename internal::ref_selector<XprType>::non_const_type MatrixTypeNested;
+  typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+  template<typename T0, typename T1>
+  IndexedView(XprType& xpr, const T0& rowIndices, const T1& colIndices)
+    : m_xpr(xpr), m_rowIndices(rowIndices), m_colIndices(colIndices)
+  {}
+
+  /** \returns number of rows */
+  Index rows() const { return internal::size(m_rowIndices); }
+
+  /** \returns number of columns */
+  Index cols() const { return internal::size(m_colIndices); }
+
+  /** \returns the nested expression */
+  const typename internal::remove_all<XprType>::type&
+  nestedExpression() const { return m_xpr; }
+
+  /** \returns the nested expression */
+  typename internal::remove_reference<XprType>::type&
+  nestedExpression() { return m_xpr; }
+
+  /** \returns a const reference to the object storing/generating the row indices */
+  const RowIndices& rowIndices() const { return m_rowIndices; }
+
+  /** \returns a const reference to the object storing/generating the column indices */
+  const ColIndices& colIndices() const { return m_colIndices; }
+
+protected:
+  MatrixTypeNested m_xpr;
+  RowIndices m_rowIndices;
+  ColIndices m_colIndices;
+};
+
+
+// Generic API dispatcher
+template<typename XprType, typename RowIndices, typename ColIndices, typename StorageKind>
+class IndexedViewImpl
+  : public internal::generic_xpr_base<IndexedView<XprType, RowIndices, ColIndices> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<IndexedView<XprType, RowIndices, ColIndices> >::type Base;
+};
+
+namespace internal {
+
+
+template<typename ArgType, typename RowIndices, typename ColIndices>
+struct unary_evaluator<IndexedView<ArgType, RowIndices, ColIndices>, IndexBased>
+  : evaluator_base<IndexedView<ArgType, RowIndices, ColIndices> >
+{
+  typedef IndexedView<ArgType, RowIndices, ColIndices> XprType;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost /* TODO + cost of row/col index */,
+
+    FlagsLinearAccessBit = (traits<XprType>::RowsAtCompileTime == 1 || traits<XprType>::ColsAtCompileTime == 1) ? LinearAccessBit : 0,
+
+    FlagsRowMajorBit = traits<XprType>::FlagsRowMajorBit, 
+
+    Flags = (evaluator<ArgType>::Flags & (HereditaryBits & ~RowMajorBit /*| LinearAccessBit | DirectAccessBit*/)) | FlagsLinearAccessBit | FlagsRowMajorBit,
+
+    Alignment = 0
+  };
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_xpr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    EIGEN_STATIC_ASSERT_LVALUE(XprType)
+    Index row = XprType::RowsAtCompileTime == 1 ? 0 : index;
+    Index col = XprType::RowsAtCompileTime == 1 ? index : 0;
+    return m_argImpl.coeffRef( m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar& coeffRef(Index index) const
+  {
+    Index row = XprType::RowsAtCompileTime == 1 ? 0 : index;
+    Index col = XprType::RowsAtCompileTime == 1 ? index : 0;
+    return m_argImpl.coeffRef( m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const CoeffReturnType coeff(Index index) const
+  {
+    Index row = XprType::RowsAtCompileTime == 1 ? 0 : index;
+    Index col = XprType::RowsAtCompileTime == 1 ? index : 0;
+    return m_argImpl.coeff( m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+protected:
+
+  evaluator<ArgType> m_argImpl;
+  const XprType& m_xpr;
+
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_INDEXED_VIEW_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Inverse.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Inverse.h
new file mode 100644
index 00000000..c514438c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Inverse.h
@@ -0,0 +1,117 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014-2019 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INVERSE_H
+#define EIGEN_INVERSE_H
+
+namespace Eigen {
+
+template<typename XprType,typename StorageKind> class InverseImpl;
+
+namespace internal {
+
+template<typename XprType>
+struct traits<Inverse<XprType> >
+  : traits<typename XprType::PlainObject>
+{
+  typedef typename XprType::PlainObject PlainObject;
+  typedef traits<PlainObject> BaseTraits;
+  enum {
+    Flags = BaseTraits::Flags & RowMajorBit
+  };
+};
+
+} // end namespace internal
+
+/** \class Inverse
+  *
+  * \brief Expression of the inverse of another expression
+  *
+  * \tparam XprType the type of the expression we are taking the inverse
+  *
+  * This class represents an abstract expression of A.inverse()
+  * and most of the time this is the only way it is used.
+  *
+  */
+template<typename XprType>
+class Inverse : public InverseImpl<XprType,typename internal::traits<XprType>::StorageKind>
+{
+public:
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename XprType::Scalar                            Scalar;
+  typedef typename internal::ref_selector<XprType>::type      XprTypeNested;
+  typedef typename internal::remove_all<XprTypeNested>::type  XprTypeNestedCleaned;
+  typedef typename internal::ref_selector<Inverse>::type Nested;
+  typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+  explicit EIGEN_DEVICE_FUNC Inverse(const XprType &xpr)
+    : m_xpr(xpr)
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR  Index rows() const EIGEN_NOEXCEPT { return m_xpr.cols(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR  Index cols() const EIGEN_NOEXCEPT { return m_xpr.rows(); }
+
+  EIGEN_DEVICE_FUNC const XprTypeNestedCleaned& nestedExpression() const { return m_xpr; }
+
+protected:
+  XprTypeNested m_xpr;
+};
+
+// Generic API dispatcher
+template<typename XprType, typename StorageKind>
+class InverseImpl
+  : public internal::generic_xpr_base<Inverse<XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<Inverse<XprType> >::type Base;
+  typedef typename XprType::Scalar Scalar;
+private:
+
+  Scalar coeff(Index row, Index col) const;
+  Scalar coeff(Index i) const;
+};
+
+namespace internal {
+
+/** \internal
+  * \brief Default evaluator for Inverse expression.
+  *
+  * This default evaluator for Inverse expression simply evaluate the inverse into a temporary
+  * by a call to internal::call_assignment_no_alias.
+  * Therefore, inverse implementers only have to specialize Assignment<Dst,Inverse<...>, ...> for
+  * there own nested expression.
+  *
+  * \sa class Inverse
+  */
+template<typename ArgType>
+struct unary_evaluator<Inverse<ArgType> >
+  : public evaluator<typename Inverse<ArgType>::PlainObject>
+{
+  typedef Inverse<ArgType> InverseType;
+  typedef typename InverseType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum { Flags = Base::Flags | EvalBeforeNestingBit };
+
+  unary_evaluator(const InverseType& inv_xpr)
+    : m_result(inv_xpr.rows(), inv_xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    internal::call_assignment_no_alias(m_result, inv_xpr);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_INVERSE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Map.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Map.h
new file mode 100644
index 00000000..218cc157
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Map.h
@@ -0,0 +1,171 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MAP_H
+#define EIGEN_MAP_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename PlainObjectType, int MapOptions, typename StrideType>
+struct traits<Map<PlainObjectType, MapOptions, StrideType> >
+  : public traits<PlainObjectType>
+{
+  typedef traits<PlainObjectType> TraitsBase;
+  enum {
+    PlainObjectTypeInnerSize = ((traits<PlainObjectType>::Flags&RowMajorBit)==RowMajorBit)
+                             ? PlainObjectType::ColsAtCompileTime
+                             : PlainObjectType::RowsAtCompileTime,
+
+    InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
+                             ? int(PlainObjectType::InnerStrideAtCompileTime)
+                             : int(StrideType::InnerStrideAtCompileTime),
+    OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
+                             ? (InnerStrideAtCompileTime==Dynamic || PlainObjectTypeInnerSize==Dynamic
+                                ? Dynamic
+                                : int(InnerStrideAtCompileTime) * int(PlainObjectTypeInnerSize))
+                             : int(StrideType::OuterStrideAtCompileTime),
+    Alignment = int(MapOptions)&int(AlignedMask),
+    Flags0 = TraitsBase::Flags & (~NestByRefBit),
+    Flags = is_lvalue<PlainObjectType>::value ? int(Flags0) : (int(Flags0) & ~LvalueBit)
+  };
+private:
+  enum { Options }; // Expressions don't have Options
+};
+}
+
+/** \class Map
+  * \ingroup Core_Module
+  *
+  * \brief A matrix or vector expression mapping an existing array of data.
+  *
+  * \tparam PlainObjectType the equivalent matrix type of the mapped data
+  * \tparam MapOptions specifies the pointer alignment in bytes. It can be: \c #Aligned128, \c #Aligned64, \c #Aligned32, \c #Aligned16, \c #Aligned8 or \c #Unaligned.
+  *                The default is \c #Unaligned.
+  * \tparam StrideType optionally specifies strides. By default, Map assumes the memory layout
+  *                   of an ordinary, contiguous array. This can be overridden by specifying strides.
+  *                   The type passed here must be a specialization of the Stride template, see examples below.
+  *
+  * This class represents a matrix or vector expression mapping an existing array of data.
+  * It can be used to let Eigen interface without any overhead with non-Eigen data structures,
+  * such as plain C arrays or structures from other libraries. By default, it assumes that the
+  * data is laid out contiguously in memory. You can however override this by explicitly specifying
+  * inner and outer strides.
+  *
+  * Here's an example of simply mapping a contiguous array as a \ref TopicStorageOrders "column-major" matrix:
+  * \include Map_simple.cpp
+  * Output: \verbinclude Map_simple.out
+  *
+  * If you need to map non-contiguous arrays, you can do so by specifying strides:
+  *
+  * Here's an example of mapping an array as a vector, specifying an inner stride, that is, the pointer
+  * increment between two consecutive coefficients. Here, we're specifying the inner stride as a compile-time
+  * fixed value.
+  * \include Map_inner_stride.cpp
+  * Output: \verbinclude Map_inner_stride.out
+  *
+  * Here's an example of mapping an array while specifying an outer stride. Here, since we're mapping
+  * as a column-major matrix, 'outer stride' means the pointer increment between two consecutive columns.
+  * Here, we're specifying the outer stride as a runtime parameter. Note that here \c OuterStride<> is
+  * a short version of \c OuterStride<Dynamic> because the default template parameter of OuterStride
+  * is  \c Dynamic
+  * \include Map_outer_stride.cpp
+  * Output: \verbinclude Map_outer_stride.out
+  *
+  * For more details and for an example of specifying both an inner and an outer stride, see class Stride.
+  *
+  * \b Tip: to change the array of data mapped by a Map object, you can use the C++
+  * placement new syntax:
+  *
+  * Example: \include Map_placement_new.cpp
+  * Output: \verbinclude Map_placement_new.out
+  *
+  * This class is the return type of PlainObjectBase::Map() but can also be used directly.
+  *
+  * \sa PlainObjectBase::Map(), \ref TopicStorageOrders
+  */
+template<typename PlainObjectType, int MapOptions, typename StrideType> class Map
+  : public MapBase<Map<PlainObjectType, MapOptions, StrideType> >
+{
+  public:
+
+    typedef MapBase<Map> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Map)
+
+    typedef typename Base::PointerType PointerType;
+    typedef PointerType PointerArgType;
+    EIGEN_DEVICE_FUNC
+    inline PointerType cast_to_pointer_type(PointerArgType ptr) { return ptr; }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const
+    {
+      return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const
+    {
+      return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
+           : internal::traits<Map>::OuterStrideAtCompileTime != Dynamic ? Index(internal::traits<Map>::OuterStrideAtCompileTime)
+           : IsVectorAtCompileTime ? (this->size() * innerStride())
+           : int(Flags)&RowMajorBit ? (this->cols() * innerStride())
+           : (this->rows() * innerStride());
+    }
+
+    /** Constructor in the fixed-size case.
+      *
+      * \param dataPtr pointer to the array to map
+      * \param stride optional Stride object, passing the strides.
+      */
+    EIGEN_DEVICE_FUNC
+    explicit inline Map(PointerArgType dataPtr, const StrideType& stride = StrideType())
+      : Base(cast_to_pointer_type(dataPtr)), m_stride(stride)
+    {
+      PlainObjectType::Base::_check_template_params();
+    }
+
+    /** Constructor in the dynamic-size vector case.
+      *
+      * \param dataPtr pointer to the array to map
+      * \param size the size of the vector expression
+      * \param stride optional Stride object, passing the strides.
+      */
+    EIGEN_DEVICE_FUNC
+    inline Map(PointerArgType dataPtr, Index size, const StrideType& stride = StrideType())
+      : Base(cast_to_pointer_type(dataPtr), size), m_stride(stride)
+    {
+      PlainObjectType::Base::_check_template_params();
+    }
+
+    /** Constructor in the dynamic-size matrix case.
+      *
+      * \param dataPtr pointer to the array to map
+      * \param rows the number of rows of the matrix expression
+      * \param cols the number of columns of the matrix expression
+      * \param stride optional Stride object, passing the strides.
+      */
+    EIGEN_DEVICE_FUNC
+    inline Map(PointerArgType dataPtr, Index rows, Index cols, const StrideType& stride = StrideType())
+      : Base(cast_to_pointer_type(dataPtr), rows, cols), m_stride(stride)
+    {
+      PlainObjectType::Base::_check_template_params();
+    }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
+
+  protected:
+    StrideType m_stride;
+};
+
+
+} // end namespace Eigen
+
+#endif // EIGEN_MAP_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/MapBase.h b/C++/yolo_bytetrack/include/Eigen/src/Core/MapBase.h
new file mode 100644
index 00000000..d856447f
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/MapBase.h
@@ -0,0 +1,310 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MAPBASE_H
+#define EIGEN_MAPBASE_H
+
+#define EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) \
+      EIGEN_STATIC_ASSERT((int(internal::evaluator<Derived>::Flags) & LinearAccessBit) || Derived::IsVectorAtCompileTime, \
+                          YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT)
+
+namespace Eigen {
+
+/** \ingroup Core_Module
+  *
+  * \brief Base class for dense Map and Block expression with direct access
+  *
+  * This base class provides the const low-level accessors (e.g. coeff, coeffRef) of dense
+  * Map and Block objects with direct access.
+  * Typical users do not have to directly deal with this class.
+  *
+  * This class can be extended by through the macro plugin \c EIGEN_MAPBASE_PLUGIN.
+  * See \link TopicCustomizing_Plugins customizing Eigen \endlink for details.
+  *
+  * The \c Derived class has to provide the following two methods describing the memory layout:
+  *  \code Index innerStride() const; \endcode
+  *  \code Index outerStride() const; \endcode
+  *
+  * \sa class Map, class Block
+  */
+template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
+  : public internal::dense_xpr_base<Derived>::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<Derived>::type Base;
+    enum {
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      InnerStrideAtCompileTime = internal::traits<Derived>::InnerStrideAtCompileTime,
+      SizeAtCompileTime = Base::SizeAtCompileTime
+    };
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef typename internal::conditional<
+                         bool(internal::is_lvalue<Derived>::value),
+                         Scalar *,
+                         const Scalar *>::type
+                     PointerType;
+
+    using Base::derived;
+//    using Base::RowsAtCompileTime;
+//    using Base::ColsAtCompileTime;
+//    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+    using Base::IsRowMajor;
+
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+    using Base::lazyAssign;
+    using Base::eval;
+
+    using Base::innerStride;
+    using Base::outerStride;
+    using Base::rowStride;
+    using Base::colStride;
+
+    // bug 217 - compile error on ICC 11.1
+    using Base::operator=;
+
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+
+    /** \copydoc DenseBase::rows() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_rows.value(); }
+    /** \copydoc DenseBase::cols() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_cols.value(); }
+
+    /** Returns a pointer to the first coefficient of the matrix or vector.
+      *
+      * \note When addressing this data, make sure to honor the strides returned by innerStride() and outerStride().
+      *
+      * \sa innerStride(), outerStride()
+      */
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const { return m_data; }
+
+    /** \copydoc PlainObjectBase::coeff(Index,Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeff(Index rowId, Index colId) const
+    {
+      return m_data[colId * colStride() + rowId * rowStride()];
+    }
+
+    /** \copydoc PlainObjectBase::coeff(Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeff(Index index) const
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return m_data[index * innerStride()];
+    }
+
+    /** \copydoc PlainObjectBase::coeffRef(Index,Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return this->m_data[colId * colStride() + rowId * rowStride()];
+    }
+
+    /** \copydoc PlainObjectBase::coeffRef(Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return this->m_data[index * innerStride()];
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    inline PacketScalar packet(Index rowId, Index colId) const
+    {
+      return internal::ploadt<PacketScalar, LoadMode>
+               (m_data + (colId * colStride() + rowId * rowStride()));
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    inline PacketScalar packet(Index index) const
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride());
+    }
+
+    /** \internal Constructor for fixed size matrices or vectors */
+    EIGEN_DEVICE_FUNC
+    explicit inline MapBase(PointerType dataPtr) : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime)
+    {
+      EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+      checkSanity<Derived>();
+    }
+
+    /** \internal Constructor for dynamically sized vectors */
+    EIGEN_DEVICE_FUNC
+    inline MapBase(PointerType dataPtr, Index vecSize)
+            : m_data(dataPtr),
+              m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)),
+              m_cols(ColsAtCompileTime == Dynamic ? vecSize : Index(ColsAtCompileTime))
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+      eigen_assert(vecSize >= 0);
+      eigen_assert(dataPtr == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == vecSize);
+      checkSanity<Derived>();
+    }
+
+    /** \internal Constructor for dynamically sized matrices */
+    EIGEN_DEVICE_FUNC
+    inline MapBase(PointerType dataPtr, Index rows, Index cols)
+            : m_data(dataPtr), m_rows(rows), m_cols(cols)
+    {
+      eigen_assert( (dataPtr == 0)
+              || (   rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
+                  && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)));
+      checkSanity<Derived>();
+    }
+
+    #ifdef EIGEN_MAPBASE_PLUGIN
+    #include EIGEN_MAPBASE_PLUGIN
+    #endif
+
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(MapBase)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(MapBase)
+
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    void checkSanity(typename internal::enable_if<(internal::traits<T>::Alignment>0),void*>::type = 0) const
+    {
+#if EIGEN_MAX_ALIGN_BYTES>0
+      // innerStride() is not set yet when this function is called, so we optimistically assume the lowest plausible value:
+      const Index minInnerStride = InnerStrideAtCompileTime == Dynamic ? 1 : Index(InnerStrideAtCompileTime);
+      EIGEN_ONLY_USED_FOR_DEBUG(minInnerStride);
+      eigen_assert((   ((internal::UIntPtr(m_data) % internal::traits<Derived>::Alignment) == 0)
+                    || (cols() * rows() * minInnerStride * sizeof(Scalar)) < internal::traits<Derived>::Alignment ) && "data is not aligned");
+#endif
+    }
+
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    void checkSanity(typename internal::enable_if<internal::traits<T>::Alignment==0,void*>::type = 0) const
+    {}
+
+    PointerType m_data;
+    const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
+    const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
+};
+
+/** \ingroup Core_Module
+  *
+  * \brief Base class for non-const dense Map and Block expression with direct access
+  *
+  * This base class provides the non-const low-level accessors (e.g. coeff and coeffRef) of
+  * dense Map and Block objects with direct access.
+  * It inherits MapBase<Derived, ReadOnlyAccessors> which defines the const variant for reading specific entries.
+  *
+  * \sa class Map, class Block
+  */
+template<typename Derived> class MapBase<Derived, WriteAccessors>
+  : public MapBase<Derived, ReadOnlyAccessors>
+{
+    typedef MapBase<Derived, ReadOnlyAccessors> ReadOnlyMapBase;
+  public:
+
+    typedef MapBase<Derived, ReadOnlyAccessors> Base;
+
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::PacketScalar PacketScalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    typedef typename Base::PointerType PointerType;
+
+    using Base::derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+
+    using Base::innerStride;
+    using Base::outerStride;
+    using Base::rowStride;
+    using Base::colStride;
+
+    typedef typename internal::conditional<
+                    internal::is_lvalue<Derived>::value,
+                    Scalar,
+                    const Scalar
+                  >::type ScalarWithConstIfNotLvalue;
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return this->m_data; }
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue& coeffRef(Index row, Index col)
+    {
+      return this->m_data[col * colStride() + row * rowStride()];
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue& coeffRef(Index index)
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return this->m_data[index * innerStride()];
+    }
+
+    template<int StoreMode>
+    inline void writePacket(Index row, Index col, const PacketScalar& val)
+    {
+      internal::pstoret<Scalar, PacketScalar, StoreMode>
+               (this->m_data + (col * colStride() + row * rowStride()), val);
+    }
+
+    template<int StoreMode>
+    inline void writePacket(Index index, const PacketScalar& val)
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      internal::pstoret<Scalar, PacketScalar, StoreMode>
+                (this->m_data + index * innerStride(), val);
+    }
+
+    EIGEN_DEVICE_FUNC explicit inline MapBase(PointerType dataPtr) : Base(dataPtr) {}
+    EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index vecSize) : Base(dataPtr, vecSize) {}
+    EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index rows, Index cols) : Base(dataPtr, rows, cols) {}
+
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const MapBase& other)
+    {
+      ReadOnlyMapBase::Base::operator=(other);
+      return derived();
+    }
+
+    // In theory we could simply refer to Base:Base::operator=, but MSVC does not like Base::Base,
+    // see bugs 821 and 920.
+    using ReadOnlyMapBase::Base::operator=;
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(MapBase)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(MapBase)
+};
+
+#undef EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS
+
+} // end namespace Eigen
+
+#endif // EIGEN_MAPBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/MathFunctions.h
new file mode 100644
index 00000000..61b78f4f
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/MathFunctions.h
@@ -0,0 +1,2057 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATHFUNCTIONS_H
+#define EIGEN_MATHFUNCTIONS_H
+
+// TODO this should better be moved to NumTraits
+// Source: WolframAlpha
+#define EIGEN_PI    3.141592653589793238462643383279502884197169399375105820974944592307816406L
+#define EIGEN_LOG2E 1.442695040888963407359924681001892137426645954152985934135449406931109219L
+#define EIGEN_LN2   0.693147180559945309417232121458176568075500134360255254120680009493393621L
+
+namespace Eigen {
+
+// On WINCE, std::abs is defined for int only, so let's defined our own overloads:
+// This issue has been confirmed with MSVC 2008 only, but the issue might exist for more recent versions too.
+#if EIGEN_OS_WINCE && EIGEN_COMP_MSVC && EIGEN_COMP_MSVC<=1500
+long        abs(long        x) { return (labs(x));  }
+double      abs(double      x) { return (fabs(x));  }
+float       abs(float       x) { return (fabsf(x)); }
+long double abs(long double x) { return (fabsl(x)); }
+#endif
+
+namespace internal {
+
+/** \internal \class global_math_functions_filtering_base
+  *
+  * What it does:
+  * Defines a typedef 'type' as follows:
+  * - if type T has a member typedef Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl, then
+  *   global_math_functions_filtering_base<T>::type is a typedef for it.
+  * - otherwise, global_math_functions_filtering_base<T>::type is a typedef for T.
+  *
+  * How it's used:
+  * To allow to defined the global math functions (like sin...) in certain cases, like the Array expressions.
+  * When you do sin(array1+array2), the object array1+array2 has a complicated expression type, all what you want to know
+  * is that it inherits ArrayBase. So we implement a partial specialization of sin_impl for ArrayBase<Derived>.
+  * So we must make sure to use sin_impl<ArrayBase<Derived> > and not sin_impl<Derived>, otherwise our partial specialization
+  * won't be used. How does sin know that? That's exactly what global_math_functions_filtering_base tells it.
+  *
+  * How it's implemented:
+  * SFINAE in the style of enable_if. Highly susceptible of breaking compilers. With GCC, it sure does work, but if you replace
+  * the typename dummy by an integer template parameter, it doesn't work anymore!
+  */
+
+template<typename T, typename dummy = void>
+struct global_math_functions_filtering_base
+{
+  typedef T type;
+};
+
+template<typename T> struct always_void { typedef void type; };
+
+template<typename T>
+struct global_math_functions_filtering_base
+  <T,
+   typename always_void<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>::type
+  >
+{
+  typedef typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl type;
+};
+
+#define EIGEN_MATHFUNC_IMPL(func, scalar) Eigen::internal::func##_impl<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>
+#define EIGEN_MATHFUNC_RETVAL(func, scalar) typename Eigen::internal::func##_retval<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>::type
+
+/****************************************************************************
+* Implementation of real                                                 *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct real_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return x;
+  }
+};
+
+template<typename Scalar>
+struct real_default_impl<Scalar,true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    using std::real;
+    return real(x);
+  }
+};
+
+template<typename Scalar> struct real_impl : real_default_impl<Scalar> {};
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+template<typename T>
+struct real_impl<std::complex<T> >
+{
+  typedef T RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline T run(const std::complex<T>& x)
+  {
+    return x.real();
+  }
+};
+#endif
+
+template<typename Scalar>
+struct real_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of imag                                                 *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct imag_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar&)
+  {
+    return RealScalar(0);
+  }
+};
+
+template<typename Scalar>
+struct imag_default_impl<Scalar,true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    using std::imag;
+    return imag(x);
+  }
+};
+
+template<typename Scalar> struct imag_impl : imag_default_impl<Scalar> {};
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+template<typename T>
+struct imag_impl<std::complex<T> >
+{
+  typedef T RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline T run(const std::complex<T>& x)
+  {
+    return x.imag();
+  }
+};
+#endif
+
+template<typename Scalar>
+struct imag_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of real_ref                                             *
+****************************************************************************/
+
+template<typename Scalar>
+struct real_ref_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar& run(Scalar& x)
+  {
+    return reinterpret_cast<RealScalar*>(&x)[0];
+  }
+  EIGEN_DEVICE_FUNC
+  static inline const RealScalar& run(const Scalar& x)
+  {
+    return reinterpret_cast<const RealScalar*>(&x)[0];
+  }
+};
+
+template<typename Scalar>
+struct real_ref_retval
+{
+  typedef typename NumTraits<Scalar>::Real & type;
+};
+
+/****************************************************************************
+* Implementation of imag_ref                                             *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex>
+struct imag_ref_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar& run(Scalar& x)
+  {
+    return reinterpret_cast<RealScalar*>(&x)[1];
+  }
+  EIGEN_DEVICE_FUNC
+  static inline const RealScalar& run(const Scalar& x)
+  {
+    return reinterpret_cast<RealScalar*>(&x)[1];
+  }
+};
+
+template<typename Scalar>
+struct imag_ref_default_impl<Scalar, false>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline Scalar run(Scalar&)
+  {
+    return Scalar(0);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline const Scalar run(const Scalar&)
+  {
+    return Scalar(0);
+  }
+};
+
+template<typename Scalar>
+struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
+
+template<typename Scalar>
+struct imag_ref_retval
+{
+  typedef typename NumTraits<Scalar>::Real & type;
+};
+
+/****************************************************************************
+* Implementation of conj                                                 *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct conj_default_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    return x;
+  }
+};
+
+template<typename Scalar>
+struct conj_default_impl<Scalar,true>
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    using std::conj;
+    return conj(x);
+  }
+};
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct conj_impl : conj_default_impl<Scalar, IsComplex> {};
+
+template<typename Scalar>
+struct conj_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of abs2                                                 *
+****************************************************************************/
+
+template<typename Scalar,bool IsComplex>
+struct abs2_impl_default
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return x*x;
+  }
+};
+
+template<typename Scalar>
+struct abs2_impl_default<Scalar, true> // IsComplex
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return x.real()*x.real() + x.imag()*x.imag();
+  }
+};
+
+template<typename Scalar>
+struct abs2_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return abs2_impl_default<Scalar,NumTraits<Scalar>::IsComplex>::run(x);
+  }
+};
+
+template<typename Scalar>
+struct abs2_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of sqrt/rsqrt                                             *
+****************************************************************************/
+
+template<typename Scalar>
+struct sqrt_impl
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE Scalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD(sqrt);
+    return sqrt(x);
+  }
+};
+
+// Complex sqrt defined in MathFunctionsImpl.h.
+template<typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_sqrt(const std::complex<T>& a_x);
+
+// Custom implementation is faster than `std::sqrt`, works on
+// GPU, and correctly handles special cases (unlike MSVC).
+template<typename T>
+struct sqrt_impl<std::complex<T> >
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE std::complex<T> run(const std::complex<T>& x)
+  {
+    return complex_sqrt<T>(x);
+  }
+};
+
+template<typename Scalar>
+struct sqrt_retval
+{
+  typedef Scalar type;
+};
+
+// Default implementation relies on numext::sqrt, at bottom of file.
+template<typename T>
+struct rsqrt_impl;
+
+// Complex rsqrt defined in MathFunctionsImpl.h.
+template<typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_rsqrt(const std::complex<T>& a_x);
+
+template<typename T>
+struct rsqrt_impl<std::complex<T> >
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE std::complex<T> run(const std::complex<T>& x)
+  {
+    return complex_rsqrt<T>(x);
+  }
+};
+
+template<typename Scalar>
+struct rsqrt_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of norm1                                                *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex>
+struct norm1_default_impl;
+
+template<typename Scalar>
+struct norm1_default_impl<Scalar,true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD(abs);
+    return abs(x.real()) + abs(x.imag());
+  }
+};
+
+template<typename Scalar>
+struct norm1_default_impl<Scalar, false>
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD(abs);
+    return abs(x);
+  }
+};
+
+template<typename Scalar>
+struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
+
+template<typename Scalar>
+struct norm1_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of hypot                                                *
+****************************************************************************/
+
+template<typename Scalar> struct hypot_impl;
+
+template<typename Scalar>
+struct hypot_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of cast                                                 *
+****************************************************************************/
+
+template<typename OldType, typename NewType, typename EnableIf = void>
+struct cast_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline NewType run(const OldType& x)
+  {
+    return static_cast<NewType>(x);
+  }
+};
+
+// Casting from S -> Complex<T> leads to an implicit conversion from S to T,
+// generating warnings on clang.  Here we explicitly cast the real component.
+template<typename OldType, typename NewType>
+struct cast_impl<OldType, NewType,
+  typename internal::enable_if<
+    !NumTraits<OldType>::IsComplex && NumTraits<NewType>::IsComplex
+  >::type>
+{
+  EIGEN_DEVICE_FUNC
+  static inline NewType run(const OldType& x)
+  {
+    typedef typename NumTraits<NewType>::Real NewReal;
+    return static_cast<NewType>(static_cast<NewReal>(x));
+  }
+};
+
+// here, for once, we're plainly returning NewType: we don't want cast to do weird things.
+
+template<typename OldType, typename NewType>
+EIGEN_DEVICE_FUNC
+inline NewType cast(const OldType& x)
+{
+  return cast_impl<OldType, NewType>::run(x);
+}
+
+/****************************************************************************
+* Implementation of round                                                   *
+****************************************************************************/
+
+template<typename Scalar>
+struct round_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
+#if EIGEN_HAS_CXX11_MATH
+    EIGEN_USING_STD(round);
+#endif
+    return Scalar(round(x));
+  }
+};
+
+#if !EIGEN_HAS_CXX11_MATH
+#if EIGEN_HAS_C99_MATH
+// Use ::roundf for float.
+template<>
+struct round_impl<float> {
+  EIGEN_DEVICE_FUNC
+  static inline float run(const float& x)
+  {
+    return ::roundf(x);
+  }
+};
+#else
+template<typename Scalar>
+struct round_using_floor_ceil_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
+    // Without C99 round/roundf, resort to floor/ceil.
+    EIGEN_USING_STD(floor);
+    EIGEN_USING_STD(ceil);
+    // If not enough precision to resolve a decimal at all, return the input.
+    // Otherwise, adding 0.5 can trigger an increment by 1.
+    const Scalar limit = Scalar(1ull << (NumTraits<Scalar>::digits() - 1));
+    if (x >= limit || x <= -limit) {
+      return x;
+    }
+    return (x > Scalar(0)) ? Scalar(floor(x + Scalar(0.5))) : Scalar(ceil(x - Scalar(0.5)));
+  }
+};
+
+template<>
+struct round_impl<float> : round_using_floor_ceil_impl<float> {};
+
+template<>
+struct round_impl<double> : round_using_floor_ceil_impl<double> {};
+#endif // EIGEN_HAS_C99_MATH
+#endif // !EIGEN_HAS_CXX11_MATH
+
+template<typename Scalar>
+struct round_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of rint                                                    *
+****************************************************************************/
+
+template<typename Scalar>
+struct rint_impl {
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
+#if EIGEN_HAS_CXX11_MATH
+      EIGEN_USING_STD(rint);
+#endif
+    return rint(x);
+  }
+};
+
+#if !EIGEN_HAS_CXX11_MATH
+template<>
+struct rint_impl<double> {
+  EIGEN_DEVICE_FUNC
+  static inline double run(const double& x)
+  {
+    return ::rint(x);
+  }
+};
+template<>
+struct rint_impl<float> {
+  EIGEN_DEVICE_FUNC
+  static inline float run(const float& x)
+  {
+    return ::rintf(x);
+  }
+};
+#endif
+
+template<typename Scalar>
+struct rint_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of arg                                                     *
+****************************************************************************/
+
+// Visual Studio 2017 has a bug where arg(float) returns 0 for negative inputs.
+// This seems to be fixed in VS 2019.
+#if EIGEN_HAS_CXX11_MATH && (!EIGEN_COMP_MSVC || EIGEN_COMP_MSVC >= 1920)
+// std::arg is only defined for types of std::complex, or integer types or float/double/long double
+template<typename Scalar,
+          bool HasStdImpl = NumTraits<Scalar>::IsComplex || is_integral<Scalar>::value
+                            || is_same<Scalar, float>::value || is_same<Scalar, double>::value
+                            || is_same<Scalar, long double>::value >
+struct arg_default_impl;
+
+template<typename Scalar>
+struct arg_default_impl<Scalar, true> {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    #if defined(EIGEN_HIP_DEVICE_COMPILE)
+    // HIP does not seem to have a native device side implementation for the math routine "arg"
+    using std::arg;
+    #else
+    EIGEN_USING_STD(arg);
+    #endif
+    return static_cast<RealScalar>(arg(x));
+  }
+};
+
+// Must be non-complex floating-point type (e.g. half/bfloat16).
+template<typename Scalar>
+struct arg_default_impl<Scalar, false> {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return (x < Scalar(0)) ? RealScalar(EIGEN_PI) : RealScalar(0);
+  }
+};
+#else
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct arg_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return (x < RealScalar(0)) ? RealScalar(EIGEN_PI) : RealScalar(0);
+  }
+};
+
+template<typename Scalar>
+struct arg_default_impl<Scalar,true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD(arg);
+    return arg(x);
+  }
+};
+#endif
+template<typename Scalar> struct arg_impl : arg_default_impl<Scalar> {};
+
+template<typename Scalar>
+struct arg_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of expm1                                                   *
+****************************************************************************/
+
+// This implementation is based on GSL Math's expm1.
+namespace std_fallback {
+  // fallback expm1 implementation in case there is no expm1(Scalar) function in namespace of Scalar,
+  // or that there is no suitable std::expm1 function available. Implementation
+  // attributed to Kahan. See: http://www.plunk.org/~hatch/rightway.php.
+  template<typename Scalar>
+  EIGEN_DEVICE_FUNC inline Scalar expm1(const Scalar& x) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    EIGEN_USING_STD(exp);
+    Scalar u = exp(x);
+    if (numext::equal_strict(u, Scalar(1))) {
+      return x;
+    }
+    Scalar um1 = u - RealScalar(1);
+    if (numext::equal_strict(um1, Scalar(-1))) {
+      return RealScalar(-1);
+    }
+
+    EIGEN_USING_STD(log);
+    Scalar logu = log(u);
+    return numext::equal_strict(u, logu) ? u : (u - RealScalar(1)) * x / logu;
+  }
+}
+
+template<typename Scalar>
+struct expm1_impl {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    #if EIGEN_HAS_CXX11_MATH
+    using std::expm1;
+    #else
+    using std_fallback::expm1;
+    #endif
+    return expm1(x);
+  }
+};
+
+template<typename Scalar>
+struct expm1_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of log                                                     *
+****************************************************************************/
+
+// Complex log defined in MathFunctionsImpl.h.
+template<typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_log(const std::complex<T>& z);
+
+template<typename Scalar>
+struct log_impl {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD(log);
+    return static_cast<Scalar>(log(x));
+  }
+};
+
+template<typename Scalar>
+struct log_impl<std::complex<Scalar> > {
+  EIGEN_DEVICE_FUNC static inline std::complex<Scalar> run(const std::complex<Scalar>& z)
+  {
+    return complex_log(z);
+  }
+};
+
+/****************************************************************************
+* Implementation of log1p                                                   *
+****************************************************************************/
+
+namespace std_fallback {
+  // fallback log1p implementation in case there is no log1p(Scalar) function in namespace of Scalar,
+  // or that there is no suitable std::log1p function available
+  template<typename Scalar>
+  EIGEN_DEVICE_FUNC inline Scalar log1p(const Scalar& x) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    EIGEN_USING_STD(log);
+    Scalar x1p = RealScalar(1) + x;
+    Scalar log_1p = log_impl<Scalar>::run(x1p);
+    const bool is_small = numext::equal_strict(x1p, Scalar(1));
+    const bool is_inf = numext::equal_strict(x1p, log_1p);
+    return (is_small || is_inf) ? x : x * (log_1p / (x1p - RealScalar(1)));
+  }
+}
+
+template<typename Scalar>
+struct log1p_impl {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    #if EIGEN_HAS_CXX11_MATH
+    using std::log1p;
+    #else
+    using std_fallback::log1p;
+    #endif
+    return log1p(x);
+  }
+};
+
+// Specialization for complex types that are not supported by std::log1p.
+template <typename RealScalar>
+struct log1p_impl<std::complex<RealScalar> > {
+  EIGEN_DEVICE_FUNC static inline std::complex<RealScalar> run(
+      const std::complex<RealScalar>& x) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
+    return std_fallback::log1p(x);
+  }
+};
+
+template<typename Scalar>
+struct log1p_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of pow                                                  *
+****************************************************************************/
+
+template<typename ScalarX,typename ScalarY, bool IsInteger = NumTraits<ScalarX>::IsInteger&&NumTraits<ScalarY>::IsInteger>
+struct pow_impl
+{
+  //typedef Scalar retval;
+  typedef typename ScalarBinaryOpTraits<ScalarX,ScalarY,internal::scalar_pow_op<ScalarX,ScalarY> >::ReturnType result_type;
+  static EIGEN_DEVICE_FUNC inline result_type run(const ScalarX& x, const ScalarY& y)
+  {
+    EIGEN_USING_STD(pow);
+    return pow(x, y);
+  }
+};
+
+template<typename ScalarX,typename ScalarY>
+struct pow_impl<ScalarX,ScalarY, true>
+{
+  typedef ScalarX result_type;
+  static EIGEN_DEVICE_FUNC inline ScalarX run(ScalarX x, ScalarY y)
+  {
+    ScalarX res(1);
+    eigen_assert(!NumTraits<ScalarY>::IsSigned || y >= 0);
+    if(y & 1) res *= x;
+    y >>= 1;
+    while(y)
+    {
+      x *= x;
+      if(y&1) res *= x;
+      y >>= 1;
+    }
+    return res;
+  }
+};
+
+/****************************************************************************
+* Implementation of random                                               *
+****************************************************************************/
+
+template<typename Scalar,
+         bool IsComplex,
+         bool IsInteger>
+struct random_default_impl {};
+
+template<typename Scalar>
+struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
+
+template<typename Scalar>
+struct random_retval
+{
+  typedef Scalar type;
+};
+
+template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y);
+template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random();
+
+template<typename Scalar>
+struct random_default_impl<Scalar, false, false>
+{
+  static inline Scalar run(const Scalar& x, const Scalar& y)
+  {
+    return x + (y-x) * Scalar(std::rand()) / Scalar(RAND_MAX);
+  }
+  static inline Scalar run()
+  {
+    return run(Scalar(NumTraits<Scalar>::IsSigned ? -1 : 0), Scalar(1));
+  }
+};
+
+enum {
+  meta_floor_log2_terminate,
+  meta_floor_log2_move_up,
+  meta_floor_log2_move_down,
+  meta_floor_log2_bogus
+};
+
+template<unsigned int n, int lower, int upper> struct meta_floor_log2_selector
+{
+  enum { middle = (lower + upper) / 2,
+         value = (upper <= lower + 1) ? int(meta_floor_log2_terminate)
+               : (n < (1 << middle)) ? int(meta_floor_log2_move_down)
+               : (n==0) ? int(meta_floor_log2_bogus)
+               : int(meta_floor_log2_move_up)
+  };
+};
+
+template<unsigned int n,
+         int lower = 0,
+         int upper = sizeof(unsigned int) * CHAR_BIT - 1,
+         int selector = meta_floor_log2_selector<n, lower, upper>::value>
+struct meta_floor_log2 {};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_down>
+{
+  enum { value = meta_floor_log2<n, lower, meta_floor_log2_selector<n, lower, upper>::middle>::value };
+};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_up>
+{
+  enum { value = meta_floor_log2<n, meta_floor_log2_selector<n, lower, upper>::middle, upper>::value };
+};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_terminate>
+{
+  enum { value = (n >= ((unsigned int)(1) << (lower+1))) ? lower+1 : lower };
+};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>
+{
+  // no value, error at compile time
+};
+
+template<typename Scalar>
+struct random_default_impl<Scalar, false, true>
+{
+  static inline Scalar run(const Scalar& x, const Scalar& y)
+  {
+    if (y <= x)
+      return x;
+    // ScalarU is the unsigned counterpart of Scalar, possibly Scalar itself.
+    typedef typename make_unsigned<Scalar>::type ScalarU;
+    // ScalarX is the widest of ScalarU and unsigned int.
+    // We'll deal only with ScalarX and unsigned int below thus avoiding signed
+    // types and arithmetic and signed overflows (which are undefined behavior).
+    typedef typename conditional<(ScalarU(-1) > unsigned(-1)), ScalarU, unsigned>::type ScalarX;
+    // The following difference doesn't overflow, provided our integer types are two's
+    // complement and have the same number of padding bits in signed and unsigned variants.
+    // This is the case in most modern implementations of C++.
+    ScalarX range = ScalarX(y) - ScalarX(x);
+    ScalarX offset = 0;
+    ScalarX divisor = 1;
+    ScalarX multiplier = 1;
+    const unsigned rand_max = RAND_MAX;
+    if (range <= rand_max) divisor = (rand_max + 1) / (range + 1);
+    else                   multiplier = 1 + range / (rand_max + 1);
+    // Rejection sampling.
+    do {
+      offset = (unsigned(std::rand()) * multiplier) / divisor;
+    } while (offset > range);
+    return Scalar(ScalarX(x) + offset);
+  }
+
+  static inline Scalar run()
+  {
+#ifdef EIGEN_MAKING_DOCS
+    return run(Scalar(NumTraits<Scalar>::IsSigned ? -10 : 0), Scalar(10));
+#else
+    enum { rand_bits = meta_floor_log2<(unsigned int)(RAND_MAX)+1>::value,
+           scalar_bits = sizeof(Scalar) * CHAR_BIT,
+           shift = EIGEN_PLAIN_ENUM_MAX(0, int(rand_bits) - int(scalar_bits)),
+           offset = NumTraits<Scalar>::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0
+    };
+    return Scalar((std::rand() >> shift) - offset);
+#endif
+  }
+};
+
+template<typename Scalar>
+struct random_default_impl<Scalar, true, false>
+{
+  static inline Scalar run(const Scalar& x, const Scalar& y)
+  {
+    return Scalar(random(x.real(), y.real()),
+                  random(x.imag(), y.imag()));
+  }
+  static inline Scalar run()
+  {
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    return Scalar(random<RealScalar>(), random<RealScalar>());
+  }
+};
+
+template<typename Scalar>
+inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y)
+{
+  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
+}
+
+template<typename Scalar>
+inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random()
+{
+  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
+}
+
+// Implementation of is* functions
+
+// std::is* do not work with fast-math and gcc, std::is* are available on MSVC 2013 and newer, as well as in clang.
+#if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG)
+#define EIGEN_USE_STD_FPCLASSIFY 1
+#else
+#define EIGEN_USE_STD_FPCLASSIFY 0
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<internal::is_integral<T>::value,bool>::type
+isnan_impl(const T&) { return false; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<internal::is_integral<T>::value,bool>::type
+isinf_impl(const T&) { return false; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<internal::is_integral<T>::value,bool>::type
+isfinite_impl(const T&) { return true; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
+isfinite_impl(const T& x)
+{
+  #if defined(EIGEN_GPU_COMPILE_PHASE)
+    return (::isfinite)(x);
+  #elif EIGEN_USE_STD_FPCLASSIFY
+    using std::isfinite;
+    return isfinite EIGEN_NOT_A_MACRO (x);
+  #else
+    return x<=NumTraits<T>::highest() && x>=NumTraits<T>::lowest();
+  #endif
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
+isinf_impl(const T& x)
+{
+  #if defined(EIGEN_GPU_COMPILE_PHASE)
+    return (::isinf)(x);
+  #elif EIGEN_USE_STD_FPCLASSIFY
+    using std::isinf;
+    return isinf EIGEN_NOT_A_MACRO (x);
+  #else
+    return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
+  #endif
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
+isnan_impl(const T& x)
+{
+  #if defined(EIGEN_GPU_COMPILE_PHASE)
+    return (::isnan)(x);
+  #elif EIGEN_USE_STD_FPCLASSIFY
+    using std::isnan;
+    return isnan EIGEN_NOT_A_MACRO (x);
+  #else
+    return x != x;
+  #endif
+}
+
+#if (!EIGEN_USE_STD_FPCLASSIFY)
+
+#if EIGEN_COMP_MSVC
+
+template<typename T> EIGEN_DEVICE_FUNC bool isinf_msvc_helper(T x)
+{
+  return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF;
+}
+
+//MSVC defines a _isnan builtin function, but for double only
+EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return _isnan(x)!=0; }
+EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x)      { return _isnan(x)!=0; }
+EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x)       { return _isnan(x)!=0; }
+
+EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return isinf_msvc_helper(x); }
+EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x)      { return isinf_msvc_helper(x); }
+EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x)       { return isinf_msvc_helper(x); }
+
+#elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC)
+
+#if EIGEN_GNUC_AT_LEAST(5,0)
+  #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only")))
+#else
+  // NOTE the inline qualifier and noinline attribute are both needed: the former is to avoid linking issue (duplicate symbol),
+  //      while the second prevent too aggressive optimizations in fast-math mode:
+  #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((noinline,optimize("no-finite-math-only")))
+#endif
+
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const long double& x) { return __builtin_isnan(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const double& x)      { return __builtin_isnan(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const float& x)       { return __builtin_isnan(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const double& x)      { return __builtin_isinf(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const float& x)       { return __builtin_isinf(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const long double& x) { return __builtin_isinf(x); }
+
+#undef EIGEN_TMP_NOOPT_ATTRIB
+
+#endif
+
+#endif
+
+// The following overload are defined at the end of this file
+template<typename T> EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x);
+template<typename T> EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x);
+template<typename T> EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x);
+
+template<typename T> T generic_fast_tanh_float(const T& a_x);
+} // end namespace internal
+
+/****************************************************************************
+* Generic math functions                                                    *
+****************************************************************************/
+
+namespace numext {
+
+#if (!defined(EIGEN_GPUCC) || defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC))
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
+{
+  EIGEN_USING_STD(min)
+  return min EIGEN_NOT_A_MACRO (x,y);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
+{
+  EIGEN_USING_STD(max)
+  return max EIGEN_NOT_A_MACRO (x,y);
+}
+#else
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
+{
+  return y < x ? y : x;
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE float mini(const float& x, const float& y)
+{
+  return fminf(x, y);
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE double mini(const double& x, const double& y)
+{
+  return fmin(x, y);
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE long double mini(const long double& x, const long double& y)
+{
+#if defined(EIGEN_HIPCC)
+  // no "fminl" on HIP yet
+  return (x < y) ? x : y;
+#else
+  return fminl(x, y);
+#endif
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
+{
+  return x < y ? y : x;
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE float maxi(const float& x, const float& y)
+{
+  return fmaxf(x, y);
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE double maxi(const double& x, const double& y)
+{
+  return fmax(x, y);
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE long double maxi(const long double& x, const long double& y)
+{
+#if defined(EIGEN_HIPCC)
+  // no "fmaxl" on HIP yet
+  return (x > y) ? x : y;
+#else
+  return fmaxl(x, y);
+#endif
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+
+
+#define SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_char)   \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_short)  \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_int)    \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_long)
+#define SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_char)   \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_short)  \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_int)    \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_long)
+#define SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_uchar)  \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_ushort) \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_uint)   \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_ulong)
+#define SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_uchar)  \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_ushort) \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_uint)   \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_ulong)
+#define SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY(NAME, FUNC)
+#define SYCL_SPECIALIZE_INTEGER_TYPES_UNARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY(NAME, FUNC)
+#define SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_float) \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC,cl::sycl::cl_double)
+#define SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_float) \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC,cl::sycl::cl_double)
+#define SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(NAME, FUNC, RET_TYPE) \
+  SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, RET_TYPE, cl::sycl::cl_float) \
+  SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, RET_TYPE, cl::sycl::cl_double)
+
+#define SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE) \
+template<>                                               \
+  EIGEN_DEVICE_FUNC                                      \
+  EIGEN_ALWAYS_INLINE RET_TYPE NAME(const ARG_TYPE& x) { \
+    return cl::sycl::FUNC(x);                            \
+  }
+
+#define SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, TYPE) \
+  SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, TYPE, TYPE)
+
+#define SYCL_SPECIALIZE_GEN1_BINARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE1, ARG_TYPE2) \
+  template<>                                                                  \
+  EIGEN_DEVICE_FUNC                                                           \
+  EIGEN_ALWAYS_INLINE RET_TYPE NAME(const ARG_TYPE1& x, const ARG_TYPE2& y) { \
+    return cl::sycl::FUNC(x, y);                                              \
+  }
+
+#define SYCL_SPECIALIZE_GEN2_BINARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE) \
+  SYCL_SPECIALIZE_GEN1_BINARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE, ARG_TYPE)
+
+#define SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, TYPE) \
+  SYCL_SPECIALIZE_GEN2_BINARY_FUNC(NAME, FUNC, TYPE, TYPE)
+
+SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(mini, min)
+SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(mini, fmin)
+SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(maxi, max)
+SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(maxi, fmax)
+
+#endif
+
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(real, Scalar) real(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(const Scalar& x)
+{
+  return internal::real_ref_impl<Scalar>::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(imag, Scalar) imag(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(arg, Scalar) arg(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(arg, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(const Scalar& x)
+{
+  return internal::imag_ref_impl<Scalar>::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) abs2(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x);
+}
+
+EIGEN_DEVICE_FUNC
+inline bool abs2(bool x) { return x; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T absdiff(const T& x, const T& y)
+{
+  return x > y ? x - y : y - x;
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE float absdiff(const float& x, const float& y)
+{
+  return fabsf(x - y);
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE double absdiff(const double& x, const double& y)
+{
+  return fabs(x - y);
+}
+
+#if !defined(EIGEN_GPUCC)
+// HIP and CUDA do not support long double.
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE long double absdiff(const long double& x, const long double& y) {
+  return fabsl(x - y);
+}
+#endif
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(const Scalar& x, const Scalar& y)
+{
+  return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+  SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(hypot, hypot)
+#endif
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(log1p, Scalar) log1p(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(log1p, Scalar)::run(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(log1p, log1p)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float log1p(const float &x) { return ::log1pf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double log1p(const double &x) { return ::log1p(x); }
+#endif
+
+template<typename ScalarX,typename ScalarY>
+EIGEN_DEVICE_FUNC
+inline typename internal::pow_impl<ScalarX,ScalarY>::result_type pow(const ScalarX& x, const ScalarY& y)
+{
+  return internal::pow_impl<ScalarX,ScalarY>::run(x, y);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(pow, pow)
+#endif
+
+template<typename T> EIGEN_DEVICE_FUNC bool (isnan)   (const T &x) { return internal::isnan_impl(x); }
+template<typename T> EIGEN_DEVICE_FUNC bool (isinf)   (const T &x) { return internal::isinf_impl(x); }
+template<typename T> EIGEN_DEVICE_FUNC bool (isfinite)(const T &x) { return internal::isfinite_impl(x); }
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isnan, isnan, bool)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isinf, isinf, bool)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isfinite, isfinite, bool)
+#endif
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(rint, Scalar) rint(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(rint, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(round, Scalar) round(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(round, Scalar)::run(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(round, round)
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+T (floor)(const T& x)
+{
+  EIGEN_USING_STD(floor)
+  return floor(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(floor, floor)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float floor(const float &x) { return ::floorf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double floor(const double &x) { return ::floor(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+T (ceil)(const T& x)
+{
+  EIGEN_USING_STD(ceil);
+  return ceil(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(ceil, ceil)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float ceil(const float &x) { return ::ceilf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double ceil(const double &x) { return ::ceil(x); }
+#endif
+
+
+/** Log base 2 for 32 bits positive integers.
+  * Conveniently returns 0 for x==0. */
+inline int log2(int x)
+{
+  eigen_assert(x>=0);
+  unsigned int v(x);
+  static const int table[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+  v |= v >> 1;
+  v |= v >> 2;
+  v |= v >> 4;
+  v |= v >> 8;
+  v |= v >> 16;
+  return table[(v * 0x07C4ACDDU) >> 27];
+}
+
+/** \returns the square root of \a x.
+  *
+  * It is essentially equivalent to
+  * \code using std::sqrt; return sqrt(x); \endcode
+  * but slightly faster for float/double and some compilers (e.g., gcc), thanks to
+  * specializations when SSE is enabled.
+  *
+  * It's usage is justified in performance critical functions, like norm/normalize.
+  */
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE EIGEN_MATHFUNC_RETVAL(sqrt, Scalar) sqrt(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(sqrt, Scalar)::run(x);
+}
+
+// Boolean specialization, avoids implicit float to bool conversion (-Wimplicit-conversion-floating-point-to-bool).
+template<>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC
+bool sqrt<bool>(const bool &x) { return x; }
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sqrt, sqrt)
+#endif
+
+/** \returns the reciprocal square root of \a x. **/
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T rsqrt(const T& x)
+{
+  return internal::rsqrt_impl<T>::run(x);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T log(const T &x) {
+  return internal::log_impl<T>::run(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(log, log)
+#endif
+
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float log(const float &x) { return ::logf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double log(const double &x) { return ::log(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+typename internal::enable_if<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex,typename NumTraits<T>::Real>::type
+abs(const T &x) {
+  EIGEN_USING_STD(abs);
+  return abs(x);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+typename internal::enable_if<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex),typename NumTraits<T>::Real>::type
+abs(const T &x) {
+  return x;
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_INTEGER_TYPES_UNARY(abs, abs)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(abs, fabs)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float abs(const float &x) { return ::fabsf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double abs(const double &x) { return ::fabs(x); }
+
+template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float abs(const std::complex<float>& x) {
+  return ::hypotf(x.real(), x.imag());
+}
+
+template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double abs(const std::complex<double>& x) {
+  return ::hypot(x.real(), x.imag());
+}
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T exp(const T &x) {
+  EIGEN_USING_STD(exp);
+  return exp(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(exp, exp)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float exp(const float &x) { return ::expf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double exp(const double &x) { return ::exp(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+std::complex<float> exp(const std::complex<float>& x) {
+  float com = ::expf(x.real());
+  float res_real = com * ::cosf(x.imag());
+  float res_imag = com * ::sinf(x.imag());
+  return std::complex<float>(res_real, res_imag);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+std::complex<double> exp(const std::complex<double>& x) {
+  double com = ::exp(x.real());
+  double res_real = com * ::cos(x.imag());
+  double res_imag = com * ::sin(x.imag());
+  return std::complex<double>(res_real, res_imag);
+}
+#endif
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(expm1, Scalar) expm1(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(expm1, Scalar)::run(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(expm1, expm1)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float expm1(const float &x) { return ::expm1f(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double expm1(const double &x) { return ::expm1(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T cos(const T &x) {
+  EIGEN_USING_STD(cos);
+  return cos(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(cos,cos)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float cos(const float &x) { return ::cosf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double cos(const double &x) { return ::cos(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T sin(const T &x) {
+  EIGEN_USING_STD(sin);
+  return sin(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sin, sin)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float sin(const float &x) { return ::sinf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double sin(const double &x) { return ::sin(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T tan(const T &x) {
+  EIGEN_USING_STD(tan);
+  return tan(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(tan, tan)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float tan(const float &x) { return ::tanf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double tan(const double &x) { return ::tan(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T acos(const T &x) {
+  EIGEN_USING_STD(acos);
+  return acos(x);
+}
+
+#if EIGEN_HAS_CXX11_MATH
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T acosh(const T &x) {
+  EIGEN_USING_STD(acosh);
+  return static_cast<T>(acosh(x));
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(acos, acos)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(acosh, acosh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float acos(const float &x) { return ::acosf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double acos(const double &x) { return ::acos(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T asin(const T &x) {
+  EIGEN_USING_STD(asin);
+  return asin(x);
+}
+
+#if EIGEN_HAS_CXX11_MATH
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T asinh(const T &x) {
+  EIGEN_USING_STD(asinh);
+  return static_cast<T>(asinh(x));
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(asin, asin)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(asinh, asinh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float asin(const float &x) { return ::asinf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double asin(const double &x) { return ::asin(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T atan(const T &x) {
+  EIGEN_USING_STD(atan);
+  return static_cast<T>(atan(x));
+}
+
+#if EIGEN_HAS_CXX11_MATH
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T atanh(const T &x) {
+  EIGEN_USING_STD(atanh);
+  return static_cast<T>(atanh(x));
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(atan, atan)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(atanh, atanh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float atan(const float &x) { return ::atanf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double atan(const double &x) { return ::atan(x); }
+#endif
+
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T cosh(const T &x) {
+  EIGEN_USING_STD(cosh);
+  return static_cast<T>(cosh(x));
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(cosh, cosh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float cosh(const float &x) { return ::coshf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double cosh(const double &x) { return ::cosh(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T sinh(const T &x) {
+  EIGEN_USING_STD(sinh);
+  return static_cast<T>(sinh(x));
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sinh, sinh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float sinh(const float &x) { return ::sinhf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double sinh(const double &x) { return ::sinh(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T tanh(const T &x) {
+  EIGEN_USING_STD(tanh);
+  return tanh(x);
+}
+
+#if (!defined(EIGEN_GPUCC)) && EIGEN_FAST_MATH && !defined(SYCL_DEVICE_ONLY)
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float tanh(float x) { return internal::generic_fast_tanh_float(x); }
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(tanh, tanh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float tanh(const float &x) { return ::tanhf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double tanh(const double &x) { return ::tanh(x); }
+#endif
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T fmod(const T& a, const T& b) {
+  EIGEN_USING_STD(fmod);
+  return fmod(a, b);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(fmod, fmod)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float fmod(const float& a, const float& b) {
+  return ::fmodf(a, b);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double fmod(const double& a, const double& b) {
+  return ::fmod(a, b);
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+#undef SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY
+#undef SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY
+#undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY
+#undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY
+#undef SYCL_SPECIALIZE_INTEGER_TYPES_BINARY
+#undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY
+#undef SYCL_SPECIALIZE_FLOATING_TYPES_BINARY
+#undef SYCL_SPECIALIZE_FLOATING_TYPES_UNARY
+#undef SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE
+#undef SYCL_SPECIALIZE_GEN_UNARY_FUNC
+#undef SYCL_SPECIALIZE_UNARY_FUNC
+#undef SYCL_SPECIALIZE_GEN1_BINARY_FUNC
+#undef SYCL_SPECIALIZE_GEN2_BINARY_FUNC
+#undef SYCL_SPECIALIZE_BINARY_FUNC
+#endif
+
+} // end namespace numext
+
+namespace internal {
+
+template<typename T>
+EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x)
+{
+  return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x)
+{
+  return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x)
+{
+  return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
+}
+
+/****************************************************************************
+* Implementation of fuzzy comparisons                                       *
+****************************************************************************/
+
+template<typename Scalar,
+         bool IsComplex,
+         bool IsInteger>
+struct scalar_fuzzy_default_impl {};
+
+template<typename Scalar>
+struct scalar_fuzzy_default_impl<Scalar, false, false>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
+  {
+    return numext::abs(x) <= numext::abs(y) * prec;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
+  {
+    return numext::abs(x - y) <= numext::mini(numext::abs(x), numext::abs(y)) * prec;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar& prec)
+  {
+    return x <= y || isApprox(x, y, prec);
+  }
+};
+
+template<typename Scalar>
+struct scalar_fuzzy_default_impl<Scalar, false, true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, const RealScalar&)
+  {
+    return x == Scalar(0);
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar&)
+  {
+    return x == y;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar&)
+  {
+    return x <= y;
+  }
+};
+
+template<typename Scalar>
+struct scalar_fuzzy_default_impl<Scalar, true, false>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
+  {
+    return numext::abs2(x) <= numext::abs2(y) * prec * prec;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
+  {
+    return numext::abs2(x - y) <= numext::mini(numext::abs2(x), numext::abs2(y)) * prec * prec;
+  }
+};
+
+template<typename Scalar>
+struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
+
+template<typename Scalar, typename OtherScalar> EIGEN_DEVICE_FUNC
+inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
+                              const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
+{
+  return scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision);
+}
+
+template<typename Scalar> EIGEN_DEVICE_FUNC
+inline bool isApprox(const Scalar& x, const Scalar& y,
+                     const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
+{
+  return scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision);
+}
+
+template<typename Scalar> EIGEN_DEVICE_FUNC
+inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y,
+                               const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
+{
+  return scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision);
+}
+
+/******************************************
+***  The special case of the  bool type ***
+******************************************/
+
+template<> struct random_impl<bool>
+{
+  static inline bool run()
+  {
+    return random<int>(0,1)==0 ? false : true;
+  }
+
+  static inline bool run(const bool& a, const bool& b)
+  {
+    return random<int>(a, b)==0 ? false : true;
+  }
+};
+
+template<> struct scalar_fuzzy_impl<bool>
+{
+  typedef bool RealScalar;
+
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const bool& x, const bool&, const bool&)
+  {
+    return !x;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(bool x, bool y, bool)
+  {
+    return x == y;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline bool isApproxOrLessThan(const bool& x, const bool& y, const bool&)
+  {
+    return (!x) || y;
+  }
+
+};
+
+} // end namespace internal
+
+// Default implementations that rely on other numext implementations
+namespace internal {
+
+// Specialization for complex types that are not supported by std::expm1.
+template <typename RealScalar>
+struct expm1_impl<std::complex<RealScalar> > {
+  EIGEN_DEVICE_FUNC static inline std::complex<RealScalar> run(
+      const std::complex<RealScalar>& x) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
+    RealScalar xr = x.real();
+    RealScalar xi = x.imag();
+    // expm1(z) = exp(z) - 1
+    //          = exp(x +  i * y) - 1
+    //          = exp(x) * (cos(y) + i * sin(y)) - 1
+    //          = exp(x) * cos(y) - 1 + i * exp(x) * sin(y)
+    // Imag(expm1(z)) = exp(x) * sin(y)
+    // Real(expm1(z)) = exp(x) * cos(y) - 1
+    //          = exp(x) * cos(y) - 1.
+    //          = expm1(x) + exp(x) * (cos(y) - 1)
+    //          = expm1(x) + exp(x) * (2 * sin(y / 2) ** 2)
+    RealScalar erm1 = numext::expm1<RealScalar>(xr);
+    RealScalar er = erm1 + RealScalar(1.);
+    RealScalar sin2 = numext::sin(xi / RealScalar(2.));
+    sin2 = sin2 * sin2;
+    RealScalar s = numext::sin(xi);
+    RealScalar real_part = erm1 - RealScalar(2.) * er * sin2;
+    return std::complex<RealScalar>(real_part, er * s);
+  }
+};
+
+template<typename T>
+struct rsqrt_impl {
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE T run(const T& x) {
+    return T(1)/numext::sqrt(x);
+  }
+};
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+template<typename T>
+struct conj_impl<std::complex<T>, true>
+{
+  EIGEN_DEVICE_FUNC
+  static inline std::complex<T> run(const std::complex<T>& x)
+  {
+    return std::complex<T>(numext::real(x), -numext::imag(x));
+  }
+};
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATHFUNCTIONS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/MathFunctionsImpl.h b/C++/yolo_bytetrack/include/Eigen/src/Core/MathFunctionsImpl.h
new file mode 100644
index 00000000..4eaaaa78
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/MathFunctionsImpl.h
@@ -0,0 +1,200 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATHFUNCTIONSIMPL_H
+#define EIGEN_MATHFUNCTIONSIMPL_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise)
+    Doesn't do anything fancy, just a 13/6-degree rational interpolant which
+    is accurate up to a couple of ulps in the (approximate) range [-8, 8],
+    outside of which tanh(x) = +/-1 in single precision. The input is clamped
+    to the range [-c, c]. The value c is chosen as the smallest value where
+    the approximation evaluates to exactly 1. In the reange [-0.0004, 0.0004]
+    the approxmation tanh(x) ~= x is used for better accuracy as x tends to zero.
+
+    This implementation works on both scalars and packets.
+*/
+template<typename T>
+T generic_fast_tanh_float(const T& a_x)
+{
+  // Clamp the inputs to the range [-c, c]
+#ifdef EIGEN_VECTORIZE_FMA
+  const T plus_clamp = pset1<T>(7.99881172180175781f);
+  const T minus_clamp = pset1<T>(-7.99881172180175781f);
+#else
+  const T plus_clamp = pset1<T>(7.90531110763549805f);
+  const T minus_clamp = pset1<T>(-7.90531110763549805f);
+#endif
+  const T tiny = pset1<T>(0.0004f);
+  const T x = pmax(pmin(a_x, plus_clamp), minus_clamp);
+  const T tiny_mask = pcmp_lt(pabs(a_x), tiny);
+  // The monomial coefficients of the numerator polynomial (odd).
+  const T alpha_1 = pset1<T>(4.89352455891786e-03f);
+  const T alpha_3 = pset1<T>(6.37261928875436e-04f);
+  const T alpha_5 = pset1<T>(1.48572235717979e-05f);
+  const T alpha_7 = pset1<T>(5.12229709037114e-08f);
+  const T alpha_9 = pset1<T>(-8.60467152213735e-11f);
+  const T alpha_11 = pset1<T>(2.00018790482477e-13f);
+  const T alpha_13 = pset1<T>(-2.76076847742355e-16f);
+
+  // The monomial coefficients of the denominator polynomial (even).
+  const T beta_0 = pset1<T>(4.89352518554385e-03f);
+  const T beta_2 = pset1<T>(2.26843463243900e-03f);
+  const T beta_4 = pset1<T>(1.18534705686654e-04f);
+  const T beta_6 = pset1<T>(1.19825839466702e-06f);
+
+  // Since the polynomials are odd/even, we need x^2.
+  const T x2 = pmul(x, x);
+
+  // Evaluate the numerator polynomial p.
+  T p = pmadd(x2, alpha_13, alpha_11);
+  p = pmadd(x2, p, alpha_9);
+  p = pmadd(x2, p, alpha_7);
+  p = pmadd(x2, p, alpha_5);
+  p = pmadd(x2, p, alpha_3);
+  p = pmadd(x2, p, alpha_1);
+  p = pmul(x, p);
+
+  // Evaluate the denominator polynomial q.
+  T q = pmadd(x2, beta_6, beta_4);
+  q = pmadd(x2, q, beta_2);
+  q = pmadd(x2, q, beta_0);
+
+  // Divide the numerator by the denominator.
+  return pselect(tiny_mask, x, pdiv(p, q));
+}
+
+template<typename RealScalar>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+RealScalar positive_real_hypot(const RealScalar& x, const RealScalar& y)
+{
+  // IEEE IEC 6059 special cases.
+  if ((numext::isinf)(x) || (numext::isinf)(y))
+    return NumTraits<RealScalar>::infinity();
+  if ((numext::isnan)(x) || (numext::isnan)(y))
+    return NumTraits<RealScalar>::quiet_NaN();
+    
+  EIGEN_USING_STD(sqrt);
+  RealScalar p, qp;
+  p = numext::maxi(x,y);
+  if(p==RealScalar(0)) return RealScalar(0);
+  qp = numext::mini(y,x) / p;
+  return p * sqrt(RealScalar(1) + qp*qp);
+}
+
+template<typename Scalar>
+struct hypot_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  static EIGEN_DEVICE_FUNC
+  inline RealScalar run(const Scalar& x, const Scalar& y)
+  {
+    EIGEN_USING_STD(abs);
+    return positive_real_hypot<RealScalar>(abs(x), abs(y));
+  }
+};
+
+// Generic complex sqrt implementation that correctly handles corner cases
+// according to https://en.cppreference.com/w/cpp/numeric/complex/sqrt
+template<typename T>
+EIGEN_DEVICE_FUNC std::complex<T> complex_sqrt(const std::complex<T>& z) {
+  // Computes the principal sqrt of the input.
+  //
+  // For a complex square root of the number x + i*y. We want to find real
+  // numbers u and v such that
+  //    (u + i*v)^2 = x + i*y  <=>
+  //    u^2 - v^2 + i*2*u*v = x + i*v.
+  // By equating the real and imaginary parts we get:
+  //    u^2 - v^2 = x
+  //    2*u*v = y.
+  //
+  // For x >= 0, this has the numerically stable solution
+  //    u = sqrt(0.5 * (x + sqrt(x^2 + y^2)))
+  //    v = y / (2 * u)
+  // and for x < 0,
+  //    v = sign(y) * sqrt(0.5 * (-x + sqrt(x^2 + y^2)))
+  //    u = y / (2 * v)
+  //
+  // Letting w = sqrt(0.5 * (|x| + |z|)),
+  //   if x == 0: u = w, v = sign(y) * w
+  //   if x > 0:  u = w, v = y / (2 * w)
+  //   if x < 0:  u = |y| / (2 * w), v = sign(y) * w
+
+  const T x = numext::real(z);
+  const T y = numext::imag(z);
+  const T zero = T(0);
+  const T w = numext::sqrt(T(0.5) * (numext::abs(x) + numext::hypot(x, y)));
+
+  return
+    (numext::isinf)(y) ? std::complex<T>(NumTraits<T>::infinity(), y)
+      : x == zero ? std::complex<T>(w, y < zero ? -w : w)
+      : x > zero ? std::complex<T>(w, y / (2 * w))
+      : std::complex<T>(numext::abs(y) / (2 * w), y < zero ? -w : w );
+}
+
+// Generic complex rsqrt implementation.
+template<typename T>
+EIGEN_DEVICE_FUNC std::complex<T> complex_rsqrt(const std::complex<T>& z) {
+  // Computes the principal reciprocal sqrt of the input.
+  //
+  // For a complex reciprocal square root of the number z = x + i*y. We want to
+  // find real numbers u and v such that
+  //    (u + i*v)^2 = 1 / (x + i*y)  <=>
+  //    u^2 - v^2 + i*2*u*v = x/|z|^2 - i*v/|z|^2.
+  // By equating the real and imaginary parts we get:
+  //    u^2 - v^2 = x/|z|^2
+  //    2*u*v = y/|z|^2.
+  //
+  // For x >= 0, this has the numerically stable solution
+  //    u = sqrt(0.5 * (x + |z|)) / |z|
+  //    v = -y / (2 * u * |z|)
+  // and for x < 0,
+  //    v = -sign(y) * sqrt(0.5 * (-x + |z|)) / |z|
+  //    u = -y / (2 * v * |z|)
+  //
+  // Letting w = sqrt(0.5 * (|x| + |z|)),
+  //   if x == 0: u = w / |z|, v = -sign(y) * w / |z|
+  //   if x > 0:  u = w / |z|, v = -y / (2 * w * |z|)
+  //   if x < 0:  u = |y| / (2 * w * |z|), v = -sign(y) * w / |z|
+
+  const T x = numext::real(z);
+  const T y = numext::imag(z);
+  const T zero = T(0);
+
+  const T abs_z = numext::hypot(x, y);
+  const T w = numext::sqrt(T(0.5) * (numext::abs(x) + abs_z));
+  const T woz = w / abs_z;
+  // Corner cases consistent with 1/sqrt(z) on gcc/clang.
+  return
+    abs_z == zero ? std::complex<T>(NumTraits<T>::infinity(), NumTraits<T>::quiet_NaN())
+      : ((numext::isinf)(x) || (numext::isinf)(y)) ? std::complex<T>(zero, zero)
+      : x == zero ? std::complex<T>(woz, y < zero ? woz : -woz)
+      : x > zero ? std::complex<T>(woz, -y / (2 * w * abs_z))
+      : std::complex<T>(numext::abs(y) / (2 * w * abs_z), y < zero ? woz : -woz );
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC std::complex<T> complex_log(const std::complex<T>& z) {
+  // Computes complex log.
+  T a = numext::abs(z);
+  EIGEN_USING_STD(atan2);
+  T b = atan2(z.imag(), z.real());
+  return std::complex<T>(numext::log(a), b);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATHFUNCTIONSIMPL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Matrix.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Matrix.h
new file mode 100644
index 00000000..f0e59a91
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Matrix.h
@@ -0,0 +1,565 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIX_H
+#define EIGEN_MATRIX_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+private:
+  enum { size = internal::size_at_compile_time<_Rows,_Cols>::ret };
+  typedef typename find_best_packet<_Scalar,size>::type PacketScalar;
+  enum {
+      row_major_bit = _Options&RowMajor ? RowMajorBit : 0,
+      is_dynamic_size_storage = _MaxRows==Dynamic || _MaxCols==Dynamic,
+      max_size = is_dynamic_size_storage ? Dynamic : _MaxRows*_MaxCols,
+      default_alignment = compute_default_alignment<_Scalar,max_size>::value,
+      actual_alignment = ((_Options&DontAlign)==0) ? default_alignment : 0,
+      required_alignment = unpacket_traits<PacketScalar>::alignment,
+      packet_access_bit = (packet_traits<_Scalar>::Vectorizable && (EIGEN_UNALIGNED_VECTORIZE || (actual_alignment>=required_alignment))) ? PacketAccessBit : 0
+    };
+
+public:
+  typedef _Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef Eigen::Index StorageIndex;
+  typedef MatrixXpr XprKind;
+  enum {
+    RowsAtCompileTime = _Rows,
+    ColsAtCompileTime = _Cols,
+    MaxRowsAtCompileTime = _MaxRows,
+    MaxColsAtCompileTime = _MaxCols,
+    Flags = compute_matrix_flags<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::ret,
+    Options = _Options,
+    InnerStrideAtCompileTime = 1,
+    OuterStrideAtCompileTime = (Options&RowMajor) ? ColsAtCompileTime : RowsAtCompileTime,
+
+    // FIXME, the following flag in only used to define NeedsToAlign in PlainObjectBase
+    EvaluatorFlags = LinearAccessBit | DirectAccessBit | packet_access_bit | row_major_bit,
+    Alignment = actual_alignment
+  };
+};
+}
+
+/** \class Matrix
+  * \ingroup Core_Module
+  *
+  * \brief The matrix class, also used for vectors and row-vectors
+  *
+  * The %Matrix class is the work-horse for all \em dense (\ref dense "note") matrices and vectors within Eigen.
+  * Vectors are matrices with one column, and row-vectors are matrices with one row.
+  *
+  * The %Matrix class encompasses \em both fixed-size and dynamic-size objects (\ref fixedsize "note").
+  *
+  * The first three template parameters are required:
+  * \tparam _Scalar Numeric type, e.g. float, double, int or std::complex<float>.
+  *                 User defined scalar types are supported as well (see \ref user_defined_scalars "here").
+  * \tparam _Rows Number of rows, or \b Dynamic
+  * \tparam _Cols Number of columns, or \b Dynamic
+  *
+  * The remaining template parameters are optional -- in most cases you don't have to worry about them.
+  * \tparam _Options A combination of either \b #RowMajor or \b #ColMajor, and of either
+  *                 \b #AutoAlign or \b #DontAlign.
+  *                 The former controls \ref TopicStorageOrders "storage order", and defaults to column-major. The latter controls alignment, which is required
+  *                 for vectorization. It defaults to aligning matrices except for fixed sizes that aren't a multiple of the packet size.
+  * \tparam _MaxRows Maximum number of rows. Defaults to \a _Rows (\ref maxrows "note").
+  * \tparam _MaxCols Maximum number of columns. Defaults to \a _Cols (\ref maxrows "note").
+  *
+  * Eigen provides a number of typedefs covering the usual cases. Here are some examples:
+  *
+  * \li \c Matrix2d is a 2x2 square matrix of doubles (\c Matrix<double, 2, 2>)
+  * \li \c Vector4f is a vector of 4 floats (\c Matrix<float, 4, 1>)
+  * \li \c RowVector3i is a row-vector of 3 ints (\c Matrix<int, 1, 3>)
+  *
+  * \li \c MatrixXf is a dynamic-size matrix of floats (\c Matrix<float, Dynamic, Dynamic>)
+  * \li \c VectorXf is a dynamic-size vector of floats (\c Matrix<float, Dynamic, 1>)
+  *
+  * \li \c Matrix2Xf is a partially fixed-size (dynamic-size) matrix of floats (\c Matrix<float, 2, Dynamic>)
+  * \li \c MatrixX3d is a partially dynamic-size (fixed-size) matrix of double (\c Matrix<double, Dynamic, 3>)
+  *
+  * See \link matrixtypedefs this page \endlink for a complete list of predefined \em %Matrix and \em Vector typedefs.
+  *
+  * You can access elements of vectors and matrices using normal subscripting:
+  *
+  * \code
+  * Eigen::VectorXd v(10);
+  * v[0] = 0.1;
+  * v[1] = 0.2;
+  * v(0) = 0.3;
+  * v(1) = 0.4;
+  *
+  * Eigen::MatrixXi m(10, 10);
+  * m(0, 1) = 1;
+  * m(0, 2) = 2;
+  * m(0, 3) = 3;
+  * \endcode
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_MATRIX_PLUGIN.
+  *
+  * <i><b>Some notes:</b></i>
+  *
+  * <dl>
+  * <dt><b>\anchor dense Dense versus sparse:</b></dt>
+  * <dd>This %Matrix class handles dense, not sparse matrices and vectors. For sparse matrices and vectors, see the Sparse module.
+  *
+  * Dense matrices and vectors are plain usual arrays of coefficients. All the coefficients are stored, in an ordinary contiguous array.
+  * This is unlike Sparse matrices and vectors where the coefficients are stored as a list of nonzero coefficients.</dd>
+  *
+  * <dt><b>\anchor fixedsize Fixed-size versus dynamic-size:</b></dt>
+  * <dd>Fixed-size means that the numbers of rows and columns are known are compile-time. In this case, Eigen allocates the array
+  * of coefficients as a fixed-size array, as a class member. This makes sense for very small matrices, typically up to 4x4, sometimes up
+  * to 16x16. Larger matrices should be declared as dynamic-size even if one happens to know their size at compile-time.
+  *
+  * Dynamic-size means that the numbers of rows or columns are not necessarily known at compile-time. In this case they are runtime
+  * variables, and the array of coefficients is allocated dynamically on the heap.
+  *
+  * Note that \em dense matrices, be they Fixed-size or Dynamic-size, <em>do not</em> expand dynamically in the sense of a std::map.
+  * If you want this behavior, see the Sparse module.</dd>
+  *
+  * <dt><b>\anchor maxrows _MaxRows and _MaxCols:</b></dt>
+  * <dd>In most cases, one just leaves these parameters to the default values.
+  * These parameters mean the maximum size of rows and columns that the matrix may have. They are useful in cases
+  * when the exact numbers of rows and columns are not known are compile-time, but it is known at compile-time that they cannot
+  * exceed a certain value. This happens when taking dynamic-size blocks inside fixed-size matrices: in this case _MaxRows and _MaxCols
+  * are the dimensions of the original matrix, while _Rows and _Cols are Dynamic.</dd>
+  * </dl>
+  *
+  * <i><b>ABI and storage layout</b></i>
+  *
+  * The table below summarizes the ABI of some possible Matrix instances which is fixed thorough the lifetime of Eigen 3.
+  * <table  class="manual">
+  * <tr><th>Matrix type</th><th>Equivalent C structure</th></tr>
+  * <tr><td>\code Matrix<T,Dynamic,Dynamic> \endcode</td><td>\code
+  * struct {
+  *   T *data;                  // with (size_t(data)%EIGEN_MAX_ALIGN_BYTES)==0
+  *   Eigen::Index rows, cols;
+  *  };
+  * \endcode</td></tr>
+  * <tr class="alt"><td>\code
+  * Matrix<T,Dynamic,1>
+  * Matrix<T,1,Dynamic> \endcode</td><td>\code
+  * struct {
+  *   T *data;                  // with (size_t(data)%EIGEN_MAX_ALIGN_BYTES)==0
+  *   Eigen::Index size;
+  *  };
+  * \endcode</td></tr>
+  * <tr><td>\code Matrix<T,Rows,Cols> \endcode</td><td>\code
+  * struct {
+  *   T data[Rows*Cols];        // with (size_t(data)%A(Rows*Cols*sizeof(T)))==0
+  *  };
+  * \endcode</td></tr>
+  * <tr class="alt"><td>\code Matrix<T,Dynamic,Dynamic,0,MaxRows,MaxCols> \endcode</td><td>\code
+  * struct {
+  *   T data[MaxRows*MaxCols];  // with (size_t(data)%A(MaxRows*MaxCols*sizeof(T)))==0
+  *   Eigen::Index rows, cols;
+  *  };
+  * \endcode</td></tr>
+  * </table>
+  * Note that in this table Rows, Cols, MaxRows and MaxCols are all positive integers. A(S) is defined to the largest possible power-of-two
+  * smaller to EIGEN_MAX_STATIC_ALIGN_BYTES.
+  *
+  * \see MatrixBase for the majority of the API methods for matrices, \ref TopicClassHierarchy,
+  * \ref TopicStorageOrders
+  */
+
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+class Matrix
+  : public PlainObjectBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+  public:
+
+    /** \brief Base class typedef.
+      * \sa PlainObjectBase
+      */
+    typedef PlainObjectBase<Matrix> Base;
+
+    enum { Options = _Options };
+
+    EIGEN_DENSE_PUBLIC_INTERFACE(Matrix)
+
+    typedef typename Base::PlainObject PlainObject;
+
+    using Base::base;
+    using Base::coeffRef;
+
+    /**
+      * \brief Assigns matrices to each other.
+      *
+      * \note This is a special case of the templated operator=. Its purpose is
+      * to prevent a default operator= from hiding the templated operator=.
+      *
+      * \callgraph
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const Matrix& other)
+    {
+      return Base::_set(other);
+    }
+
+    /** \internal
+      * \brief Copies the value of the expression \a other into \c *this with automatic resizing.
+      *
+      * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
+      * it will be initialized.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const DenseBase<OtherDerived>& other)
+    {
+      return Base::_set(other);
+    }
+
+    /* Here, doxygen failed to copy the brief information when using \copydoc */
+
+    /**
+      * \brief Copies the generic expression \a other into *this.
+      * \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other)
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const EigenBase<OtherDerived> &other)
+    {
+      return Base::operator=(other);
+    }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const ReturnByValue<OtherDerived>& func)
+    {
+      return Base::operator=(func);
+    }
+
+    /** \brief Default constructor.
+      *
+      * For fixed-size matrices, does nothing.
+      *
+      * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix
+      * is called a null matrix. This constructor is the unique way to create null matrices: resizing
+      * a matrix to 0 is not supported.
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Matrix() : Base()
+    {
+      Base::_check_template_params();
+      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+    // FIXME is it still needed
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    explicit Matrix(internal::constructor_without_unaligned_array_assert)
+      : Base(internal::constructor_without_unaligned_array_assert())
+    { Base::_check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED }
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Matrix(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible<Scalar>::value)
+      : Base(std::move(other))
+    {
+      Base::_check_template_params();
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Matrix& operator=(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
+    {
+      Base::operator=(std::move(other));
+      return *this;
+    }
+#endif
+
+#if EIGEN_HAS_CXX11
+    /** \copydoc PlainObjectBase(const Scalar&, const Scalar&, const Scalar&,  const Scalar&, const ArgTypes&... args)
+     *
+     * Example: \include Matrix_variadic_ctor_cxx11.cpp
+     * Output: \verbinclude Matrix_variadic_ctor_cxx11.out
+     *
+     * \sa Matrix(const std::initializer_list<std::initializer_list<Scalar>>&)
+     */
+    template <typename... ArgTypes>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Matrix(const Scalar& a0, const Scalar& a1, const Scalar& a2,  const Scalar& a3, const ArgTypes&... args)
+      : Base(a0, a1, a2, a3, args...) {}
+
+    /** \brief Constructs a Matrix and initializes it from the coefficients given as initializer-lists grouped by row. \cpp11
+      *
+      * In the general case, the constructor takes a list of rows, each row being represented as a list of coefficients:
+      *
+      * Example: \include Matrix_initializer_list_23_cxx11.cpp
+      * Output: \verbinclude Matrix_initializer_list_23_cxx11.out
+      *
+      * Each of the inner initializer lists must contain the exact same number of elements, otherwise an assertion is triggered.
+      *
+      * In the case of a compile-time column vector, implicit transposition from a single row is allowed.
+      * Therefore <code>VectorXd{{1,2,3,4,5}}</code> is legal and the more verbose syntax
+      * <code>RowVectorXd{{1},{2},{3},{4},{5}}</code> can be avoided:
+      *
+      * Example: \include Matrix_initializer_list_vector_cxx11.cpp
+      * Output: \verbinclude Matrix_initializer_list_vector_cxx11.out
+      *
+      * In the case of fixed-sized matrices, the initializer list sizes must exactly match the matrix sizes,
+      * and implicit transposition is allowed for compile-time vectors only.
+      *
+      * \sa Matrix(const Scalar& a0, const Scalar& a1, const Scalar& a2,  const Scalar& a3, const ArgTypes&... args)
+      */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE Matrix(const std::initializer_list<std::initializer_list<Scalar>>& list) : Base(list) {}
+#endif // end EIGEN_HAS_CXX11
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+    // This constructor is for both 1x1 matrices and dynamic vectors
+    template<typename T>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    explicit Matrix(const T& x)
+    {
+      Base::_check_template_params();
+      Base::template _init1<T>(x);
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Matrix(const T0& x, const T1& y)
+    {
+      Base::_check_template_params();
+      Base::template _init2<T0,T1>(x, y);
+    }
+
+
+#else
+    /** \brief Constructs a fixed-sized matrix initialized with coefficients starting at \a data */
+    EIGEN_DEVICE_FUNC
+    explicit Matrix(const Scalar *data);
+
+    /** \brief Constructs a vector or row-vector with given dimension. \only_for_vectors
+      *
+      * This is useful for dynamic-size vectors. For fixed-size vectors,
+      * it is redundant to pass these parameters, so one should use the default constructor
+      * Matrix() instead.
+      *
+      * \warning This constructor is disabled for fixed-size \c 1x1 matrices. For instance,
+      * calling Matrix<double,1,1>(1) will call the initialization constructor: Matrix(const Scalar&).
+      * For fixed-size \c 1x1 matrices it is therefore recommended to use the default
+      * constructor Matrix() instead, especially when using one of the non standard
+      * \c EIGEN_INITIALIZE_MATRICES_BY_{ZERO,\c NAN} macros (see \ref TopicPreprocessorDirectives).
+      */
+    EIGEN_STRONG_INLINE explicit Matrix(Index dim);
+    /** \brief Constructs an initialized 1x1 matrix with the given coefficient
+      * \sa Matrix(const Scalar&, const Scalar&, const Scalar&,  const Scalar&, const ArgTypes&...) */
+    Matrix(const Scalar& x);
+    /** \brief Constructs an uninitialized matrix with \a rows rows and \a cols columns.
+      *
+      * This is useful for dynamic-size matrices. For fixed-size matrices,
+      * it is redundant to pass these parameters, so one should use the default constructor
+      * Matrix() instead.
+      *
+      * \warning This constructor is disabled for fixed-size \c 1x2 and \c 2x1 vectors. For instance,
+      * calling Matrix2f(2,1) will call the initialization constructor: Matrix(const Scalar& x, const Scalar& y).
+      * For fixed-size \c 1x2 or \c 2x1 vectors it is therefore recommended to use the default
+      * constructor Matrix() instead, especially when using one of the non standard
+      * \c EIGEN_INITIALIZE_MATRICES_BY_{ZERO,\c NAN} macros (see \ref TopicPreprocessorDirectives).
+      */
+    EIGEN_DEVICE_FUNC
+    Matrix(Index rows, Index cols);
+
+    /** \brief Constructs an initialized 2D vector with given coefficients
+      * \sa Matrix(const Scalar&, const Scalar&, const Scalar&,  const Scalar&, const ArgTypes&...) */
+    Matrix(const Scalar& x, const Scalar& y);
+    #endif  // end EIGEN_PARSED_BY_DOXYGEN
+
+    /** \brief Constructs an initialized 3D vector with given coefficients
+      * \sa Matrix(const Scalar&, const Scalar&, const Scalar&,  const Scalar&, const ArgTypes&...)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 3)
+      m_storage.data()[0] = x;
+      m_storage.data()[1] = y;
+      m_storage.data()[2] = z;
+    }
+    /** \brief Constructs an initialized 4D vector with given coefficients
+      * \sa Matrix(const Scalar&, const Scalar&, const Scalar&,  const Scalar&, const ArgTypes&...)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 4)
+      m_storage.data()[0] = x;
+      m_storage.data()[1] = y;
+      m_storage.data()[2] = z;
+      m_storage.data()[3] = w;
+    }
+
+
+    /** \brief Copy constructor */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const Matrix& other) : Base(other)
+    { }
+
+    /** \brief Copy constructor for generic expressions.
+      * \sa MatrixBase::operator=(const EigenBase<OtherDerived>&)
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other)
+      : Base(other.derived())
+    { }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return 1; }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return this->innerSize(); }
+
+    /////////// Geometry module ///////////
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    explicit Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Matrix& operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
+
+    // allow to extend Matrix outside Eigen
+    #ifdef EIGEN_MATRIX_PLUGIN
+    #include EIGEN_MATRIX_PLUGIN
+    #endif
+
+  protected:
+    template <typename Derived, typename OtherDerived, bool IsVector>
+    friend struct internal::conservative_resize_like_impl;
+
+    using Base::m_storage;
+};
+
+/** \defgroup matrixtypedefs Global matrix typedefs
+  *
+  * \ingroup Core_Module
+  *
+  * %Eigen defines several typedef shortcuts for most common matrix and vector types.
+  *
+  * The general patterns are the following:
+  *
+  * \c MatrixSizeType where \c Size can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd
+  * for complex double.
+  *
+  * For example, \c Matrix3d is a fixed-size 3x3 matrix type of doubles, and \c MatrixXf is a dynamic-size matrix of floats.
+  *
+  * There are also \c VectorSizeType and \c RowVectorSizeType which are self-explanatory. For example, \c Vector4cf is
+  * a fixed-size vector of 4 complex floats.
+  *
+  * With \cpp11, template alias are also defined for common sizes.
+  * They follow the same pattern as above except that the scalar type suffix is replaced by a
+  * template parameter, i.e.:
+  *   - `MatrixSize<Type>` where `Size` can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size.
+  *   - `MatrixXSize<Type>` and `MatrixSizeX<Type>` where `Size` can be \c 2,\c 3,\c 4 for hybrid dynamic/fixed matrices.
+  *   - `VectorSize<Type>` and `RowVectorSize<Type>` for column and row vectors.
+  *
+  * With \cpp11, you can also use fully generic column and row vector types: `Vector<Type,Size>` and `RowVector<Type,Size>`.
+  *
+  * \sa class Matrix
+  */
+
+#define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix)   \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Size, Size> Matrix##SizeSuffix##TypeSuffix;  \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Size, 1>    Vector##SizeSuffix##TypeSuffix;  \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, 1, Size>    RowVector##SizeSuffix##TypeSuffix;
+
+#define EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, Size)         \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Size, Dynamic> Matrix##Size##X##TypeSuffix;  \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Dynamic, Size> Matrix##X##Size##TypeSuffix;
+
+#define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \
+EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \
+EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \
+EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 4)
+
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(int,                  i)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(float,                f)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(double,               d)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<float>,  cf)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
+
+#undef EIGEN_MAKE_TYPEDEFS_ALL_SIZES
+#undef EIGEN_MAKE_TYPEDEFS
+#undef EIGEN_MAKE_FIXED_TYPEDEFS
+
+#if EIGEN_HAS_CXX11
+
+#define EIGEN_MAKE_TYPEDEFS(Size, SizeSuffix)                     \
+/** \ingroup matrixtypedefs */                                    \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Matrix##SizeSuffix = Matrix<Type, Size, Size>;              \
+/** \ingroup matrixtypedefs */                                    \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Vector##SizeSuffix = Matrix<Type, Size, 1>;                 \
+/** \ingroup matrixtypedefs */                                    \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using RowVector##SizeSuffix = Matrix<Type, 1, Size>;
+
+#define EIGEN_MAKE_FIXED_TYPEDEFS(Size)                           \
+/** \ingroup matrixtypedefs */                                    \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Matrix##Size##X = Matrix<Type, Size, Dynamic>;              \
+/** \ingroup matrixtypedefs */                                    \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Matrix##X##Size = Matrix<Type, Dynamic, Size>;
+
+EIGEN_MAKE_TYPEDEFS(2, 2)
+EIGEN_MAKE_TYPEDEFS(3, 3)
+EIGEN_MAKE_TYPEDEFS(4, 4)
+EIGEN_MAKE_TYPEDEFS(Dynamic, X)
+EIGEN_MAKE_FIXED_TYPEDEFS(2)
+EIGEN_MAKE_FIXED_TYPEDEFS(3)
+EIGEN_MAKE_FIXED_TYPEDEFS(4)
+
+/** \ingroup matrixtypedefs
+  * \brief \cpp11 */
+template <typename Type, int Size>
+using Vector = Matrix<Type, Size, 1>;
+
+/** \ingroup matrixtypedefs
+  * \brief \cpp11 */
+template <typename Type, int Size>
+using RowVector = Matrix<Type, 1, Size>;
+
+#undef EIGEN_MAKE_TYPEDEFS
+#undef EIGEN_MAKE_FIXED_TYPEDEFS
+
+#endif // EIGEN_HAS_CXX11
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/MatrixBase.h b/C++/yolo_bytetrack/include/Eigen/src/Core/MatrixBase.h
new file mode 100644
index 00000000..45c3a596
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/MatrixBase.h
@@ -0,0 +1,547 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIXBASE_H
+#define EIGEN_MATRIXBASE_H
+
+namespace Eigen {
+
+/** \class MatrixBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for all dense matrices, vectors, and expressions
+  *
+  * This class is the base that is inherited by all matrix, vector, and related expression
+  * types. Most of the Eigen API is contained in this class, and its base classes. Other important
+  * classes for the Eigen API are Matrix, and VectorwiseOp.
+  *
+  * Note that some methods are defined in other modules such as the \ref LU_Module LU module
+  * for all functions related to matrix inversions.
+  *
+  * \tparam Derived is the derived type, e.g. a matrix type, or an expression, etc.
+  *
+  * When writing a function taking Eigen objects as argument, if you want your function
+  * to take as argument any matrix, vector, or expression, just let it take a
+  * MatrixBase argument. As an example, here is a function printFirstRow which, given
+  * a matrix, vector, or expression \a x, prints the first row of \a x.
+  *
+  * \code
+    template<typename Derived>
+    void printFirstRow(const Eigen::MatrixBase<Derived>& x)
+    {
+      cout << x.row(0) << endl;
+    }
+  * \endcode
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_MATRIXBASE_PLUGIN.
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived> class MatrixBase
+  : public DenseBase<Derived>
+{
+  public:
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef MatrixBase StorageBaseType;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    typedef DenseBase<Derived> Base;
+    using Base::RowsAtCompileTime;
+    using Base::ColsAtCompileTime;
+    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+
+    using Base::derived;
+    using Base::const_cast_derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+    using Base::lazyAssign;
+    using Base::eval;
+    using Base::operator-;
+    using Base::operator+=;
+    using Base::operator-=;
+    using Base::operator*=;
+    using Base::operator/=;
+
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+    typedef typename Base::ConstTransposeReturnType ConstTransposeReturnType;
+    typedef typename Base::RowXpr RowXpr;
+    typedef typename Base::ColXpr ColXpr;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** type of the equivalent square matrix */
+    typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime),
+                          EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+    /** \returns the size of the main diagonal, which is min(rows(),cols()).
+      * \sa rows(), cols(), SizeAtCompileTime. */
+    EIGEN_DEVICE_FUNC
+    inline Index diagonalSize() const { return (numext::mini)(rows(),cols()); }
+
+    typedef typename Base::PlainObject PlainObject;
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
+    /** \internal the return type of MatrixBase::adjoint() */
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
+                        ConstTransposeReturnType
+                     >::type AdjointReturnType;
+    /** \internal Return type of eigenvalues() */
+    typedef Matrix<std::complex<RealScalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType;
+    /** \internal the return type of identity */
+    typedef CwiseNullaryOp<internal::scalar_identity_op<Scalar>,PlainObject> IdentityReturnType;
+    /** \internal the return type of unit vectors */
+    typedef Block<const CwiseNullaryOp<internal::scalar_identity_op<Scalar>, SquareMatrixType>,
+                  internal::traits<Derived>::RowsAtCompileTime,
+                  internal::traits<Derived>::ColsAtCompileTime> BasisReturnType;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#   include "../plugins/CommonCwiseBinaryOps.h"
+#   include "../plugins/MatrixCwiseUnaryOps.h"
+#   include "../plugins/MatrixCwiseBinaryOps.h"
+#   ifdef EIGEN_MATRIXBASE_PLUGIN
+#     include EIGEN_MATRIXBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_UNARY_ADDONS
+
+    /** Special case of the template operator=, in order to prevent the compiler
+      * from generating a default operator= (issue hit with g++ 4.1)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const MatrixBase& other);
+
+    // We cannot inherit here via Base::operator= since it is causing
+    // trouble with MSVC.
+
+    template <typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const DenseBase<OtherDerived>& other);
+
+    template <typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const EigenBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const ReturnByValue<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator+=(const MatrixBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator-=(const MatrixBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived,OtherDerived>
+    operator*(const MatrixBase<OtherDerived> &other) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived,OtherDerived,LazyProduct>
+    lazyProduct(const MatrixBase<OtherDerived> &other) const;
+
+    template<typename OtherDerived>
+    Derived& operator*=(const EigenBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    void applyOnTheLeft(const EigenBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    void applyOnTheRight(const EigenBase<OtherDerived>& other);
+
+    template<typename DiagonalDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived, DiagonalDerived, LazyProduct>
+    operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
+    dot(const MatrixBase<OtherDerived>& other) const;
+
+    EIGEN_DEVICE_FUNC RealScalar squaredNorm() const;
+    EIGEN_DEVICE_FUNC RealScalar norm() const;
+    RealScalar stableNorm() const;
+    RealScalar blueNorm() const;
+    RealScalar hypotNorm() const;
+    EIGEN_DEVICE_FUNC const PlainObject normalized() const;
+    EIGEN_DEVICE_FUNC const PlainObject stableNormalized() const;
+    EIGEN_DEVICE_FUNC void normalize();
+    EIGEN_DEVICE_FUNC void stableNormalize();
+
+    EIGEN_DEVICE_FUNC const AdjointReturnType adjoint() const;
+    EIGEN_DEVICE_FUNC void adjointInPlace();
+
+    typedef Diagonal<Derived> DiagonalReturnType;
+    EIGEN_DEVICE_FUNC
+    DiagonalReturnType diagonal();
+
+    typedef typename internal::add_const<Diagonal<const Derived> >::type ConstDiagonalReturnType;
+    EIGEN_DEVICE_FUNC
+    ConstDiagonalReturnType diagonal() const;
+
+    template<int Index> struct DiagonalIndexReturnType { typedef Diagonal<Derived,Index> Type; };
+    template<int Index> struct ConstDiagonalIndexReturnType { typedef const Diagonal<const Derived,Index> Type; };
+
+    template<int Index>
+    EIGEN_DEVICE_FUNC
+    typename DiagonalIndexReturnType<Index>::Type diagonal();
+
+    template<int Index>
+    EIGEN_DEVICE_FUNC
+    typename ConstDiagonalIndexReturnType<Index>::Type diagonal() const;
+
+    typedef Diagonal<Derived,DynamicIndex> DiagonalDynamicIndexReturnType;
+    typedef typename internal::add_const<Diagonal<const Derived,DynamicIndex> >::type ConstDiagonalDynamicIndexReturnType;
+
+    EIGEN_DEVICE_FUNC
+    DiagonalDynamicIndexReturnType diagonal(Index index);
+    EIGEN_DEVICE_FUNC
+    ConstDiagonalDynamicIndexReturnType diagonal(Index index) const;
+
+    template<unsigned int Mode> struct TriangularViewReturnType { typedef TriangularView<Derived, Mode> Type; };
+    template<unsigned int Mode> struct ConstTriangularViewReturnType { typedef const TriangularView<const Derived, Mode> Type; };
+
+    template<unsigned int Mode>
+    EIGEN_DEVICE_FUNC
+    typename TriangularViewReturnType<Mode>::Type triangularView();
+    template<unsigned int Mode>
+    EIGEN_DEVICE_FUNC
+    typename ConstTriangularViewReturnType<Mode>::Type triangularView() const;
+
+    template<unsigned int UpLo> struct SelfAdjointViewReturnType { typedef SelfAdjointView<Derived, UpLo> Type; };
+    template<unsigned int UpLo> struct ConstSelfAdjointViewReturnType { typedef const SelfAdjointView<const Derived, UpLo> Type; };
+
+    template<unsigned int UpLo>
+    EIGEN_DEVICE_FUNC
+    typename SelfAdjointViewReturnType<UpLo>::Type selfadjointView();
+    template<unsigned int UpLo>
+    EIGEN_DEVICE_FUNC
+    typename ConstSelfAdjointViewReturnType<UpLo>::Type selfadjointView() const;
+
+    const SparseView<Derived> sparseView(const Scalar& m_reference = Scalar(0),
+                                         const typename NumTraits<Scalar>::Real& m_epsilon = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC static const IdentityReturnType Identity();
+    EIGEN_DEVICE_FUNC static const IdentityReturnType Identity(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC static const BasisReturnType Unit(Index size, Index i);
+    EIGEN_DEVICE_FUNC static const BasisReturnType Unit(Index i);
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitX();
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitY();
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitZ();
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitW();
+
+    EIGEN_DEVICE_FUNC
+    const DiagonalWrapper<const Derived> asDiagonal() const;
+    const PermutationWrapper<const Derived> asPermutation() const;
+
+    EIGEN_DEVICE_FUNC
+    Derived& setIdentity();
+    EIGEN_DEVICE_FUNC
+    Derived& setIdentity(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setUnit(Index i);
+    EIGEN_DEVICE_FUNC Derived& setUnit(Index newSize, Index i);
+
+    bool isIdentity(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    bool isDiagonal(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    bool isUpperTriangular(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    bool isLowerTriangular(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    template<typename OtherDerived>
+    bool isOrthogonal(const MatrixBase<OtherDerived>& other,
+                      const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    bool isUnitary(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    /** \returns true if each coefficients of \c *this and \a other are all exactly equal.
+      * \warning When using floating point scalar values you probably should rather use a
+      *          fuzzy comparison such as isApprox()
+      * \sa isApprox(), operator!= */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC inline bool operator==(const MatrixBase<OtherDerived>& other) const
+    { return cwiseEqual(other).all(); }
+
+    /** \returns true if at least one pair of coefficients of \c *this and \a other are not exactly equal to each other.
+      * \warning When using floating point scalar values you probably should rather use a
+      *          fuzzy comparison such as isApprox()
+      * \sa isApprox(), operator== */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC inline bool operator!=(const MatrixBase<OtherDerived>& other) const
+    { return cwiseNotEqual(other).any(); }
+
+    NoAlias<Derived,Eigen::MatrixBase > EIGEN_DEVICE_FUNC noalias();
+
+    // TODO forceAlignedAccess is temporarily disabled
+    // Need to find a nicer workaround.
+    inline const Derived& forceAlignedAccess() const { return derived(); }
+    inline Derived& forceAlignedAccess() { return derived(); }
+    template<bool Enable> inline const Derived& forceAlignedAccessIf() const { return derived(); }
+    template<bool Enable> inline Derived& forceAlignedAccessIf() { return derived(); }
+
+    EIGEN_DEVICE_FUNC Scalar trace() const;
+
+    template<int p> EIGEN_DEVICE_FUNC RealScalar lpNorm() const;
+
+    EIGEN_DEVICE_FUNC MatrixBase<Derived>& matrix() { return *this; }
+    EIGEN_DEVICE_FUNC const MatrixBase<Derived>& matrix() const { return *this; }
+
+    /** \returns an \link Eigen::ArrayBase Array \endlink expression of this matrix
+      * \sa ArrayBase::matrix() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ArrayWrapper<Derived> array() { return ArrayWrapper<Derived>(derived()); }
+    /** \returns a const \link Eigen::ArrayBase Array \endlink expression of this matrix
+      * \sa ArrayBase::matrix() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArrayWrapper<const Derived> array() const { return ArrayWrapper<const Derived>(derived()); }
+
+/////////// LU module ///////////
+
+    inline const FullPivLU<PlainObject> fullPivLu() const;
+    inline const PartialPivLU<PlainObject> partialPivLu() const;
+
+    inline const PartialPivLU<PlainObject> lu() const;
+
+    EIGEN_DEVICE_FUNC
+    inline const Inverse<Derived> inverse() const;
+
+    template<typename ResultType>
+    inline void computeInverseAndDetWithCheck(
+      ResultType& inverse,
+      typename ResultType::Scalar& determinant,
+      bool& invertible,
+      const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
+    ) const;
+
+    template<typename ResultType>
+    inline void computeInverseWithCheck(
+      ResultType& inverse,
+      bool& invertible,
+      const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
+    ) const;
+
+    EIGEN_DEVICE_FUNC
+    Scalar determinant() const;
+
+/////////// Cholesky module ///////////
+
+    inline const LLT<PlainObject>  llt() const;
+    inline const LDLT<PlainObject> ldlt() const;
+
+/////////// QR module ///////////
+
+    inline const HouseholderQR<PlainObject> householderQr() const;
+    inline const ColPivHouseholderQR<PlainObject> colPivHouseholderQr() const;
+    inline const FullPivHouseholderQR<PlainObject> fullPivHouseholderQr() const;
+    inline const CompleteOrthogonalDecomposition<PlainObject> completeOrthogonalDecomposition() const;
+
+/////////// Eigenvalues module ///////////
+
+    inline EigenvaluesReturnType eigenvalues() const;
+    inline RealScalar operatorNorm() const;
+
+/////////// SVD module ///////////
+
+    inline JacobiSVD<PlainObject> jacobiSvd(unsigned int computationOptions = 0) const;
+    inline BDCSVD<PlainObject>    bdcSvd(unsigned int computationOptions = 0) const;
+
+/////////// Geometry module ///////////
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /// \internal helper struct to form the return type of the cross product
+    template<typename OtherDerived> struct cross_product_return_type {
+      typedef typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType Scalar;
+      typedef Matrix<Scalar,MatrixBase::RowsAtCompileTime,MatrixBase::ColsAtCompileTime> type;
+    };
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    inline typename cross_product_return_type<OtherDerived>::type
+#else
+    inline PlainObject
+#endif
+    cross(const MatrixBase<OtherDerived>& other) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    inline PlainObject cross3(const MatrixBase<OtherDerived>& other) const;
+
+    EIGEN_DEVICE_FUNC
+    inline PlainObject unitOrthogonal(void) const;
+
+    EIGEN_DEVICE_FUNC
+    inline Matrix<Scalar,3,1> eulerAngles(Index a0, Index a1, Index a2) const;
+
+    // put this as separate enum value to work around possible GCC 4.3 bug (?)
+    enum { HomogeneousReturnTypeDirection = ColsAtCompileTime==1&&RowsAtCompileTime==1 ? ((internal::traits<Derived>::Flags&RowMajorBit)==RowMajorBit ? Horizontal : Vertical)
+                                          : ColsAtCompileTime==1 ? Vertical : Horizontal };
+    typedef Homogeneous<Derived, HomogeneousReturnTypeDirection> HomogeneousReturnType;
+    EIGEN_DEVICE_FUNC
+    inline HomogeneousReturnType homogeneous() const;
+
+    enum {
+      SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1
+    };
+    typedef Block<const Derived,
+                  internal::traits<Derived>::ColsAtCompileTime==1 ? SizeMinusOne : 1,
+                  internal::traits<Derived>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> ConstStartMinusOne;
+    typedef EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(ConstStartMinusOne,Scalar,quotient) HNormalizedReturnType;
+    EIGEN_DEVICE_FUNC
+    inline const HNormalizedReturnType hnormalized() const;
+
+////////// Householder module ///////////
+
+    EIGEN_DEVICE_FUNC
+    void makeHouseholderInPlace(Scalar& tau, RealScalar& beta);
+    template<typename EssentialPart>
+    EIGEN_DEVICE_FUNC
+    void makeHouseholder(EssentialPart& essential,
+                         Scalar& tau, RealScalar& beta) const;
+    template<typename EssentialPart>
+    EIGEN_DEVICE_FUNC
+    void applyHouseholderOnTheLeft(const EssentialPart& essential,
+                                   const Scalar& tau,
+                                   Scalar* workspace);
+    template<typename EssentialPart>
+    EIGEN_DEVICE_FUNC
+    void applyHouseholderOnTheRight(const EssentialPart& essential,
+                                    const Scalar& tau,
+                                    Scalar* workspace);
+
+///////// Jacobi module /////////
+
+    template<typename OtherScalar>
+    EIGEN_DEVICE_FUNC
+    void applyOnTheLeft(Index p, Index q, const JacobiRotation<OtherScalar>& j);
+    template<typename OtherScalar>
+    EIGEN_DEVICE_FUNC
+    void applyOnTheRight(Index p, Index q, const JacobiRotation<OtherScalar>& j);
+
+///////// SparseCore module /////////
+
+    template<typename OtherDerived>
+    EIGEN_STRONG_INLINE const typename SparseMatrixBase<OtherDerived>::template CwiseProductDenseReturnType<Derived>::Type
+    cwiseProduct(const SparseMatrixBase<OtherDerived> &other) const
+    {
+      return other.cwiseProduct(derived());
+    }
+
+///////// MatrixFunctions module /////////
+
+    typedef typename internal::stem_function<Scalar>::type StemFunction;
+#define EIGEN_MATRIX_FUNCTION(ReturnType, Name, Description) \
+    /** \returns an expression of the matrix Description of \c *this. \brief This function requires the <a href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>. To compute the coefficient-wise Description use ArrayBase::##Name . */ \
+    const ReturnType<Derived> Name() const;
+#define EIGEN_MATRIX_FUNCTION_1(ReturnType, Name, Description, Argument) \
+    /** \returns an expression of the matrix Description of \c *this. \brief This function requires the <a href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>. To compute the coefficient-wise Description use ArrayBase::##Name . */ \
+    const ReturnType<Derived> Name(Argument) const;
+
+    EIGEN_MATRIX_FUNCTION(MatrixExponentialReturnValue, exp, exponential)
+    /** \brief Helper function for the <a href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>.*/
+    const MatrixFunctionReturnValue<Derived> matrixFunction(StemFunction f) const;
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, cosh, hyperbolic cosine)
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, sinh, hyperbolic sine)
+#if EIGEN_HAS_CXX11_MATH
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, atanh, inverse hyperbolic cosine)
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, acosh, inverse hyperbolic cosine)
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, asinh, inverse hyperbolic sine)
+#endif
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, cos, cosine)
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, sin, sine)
+    EIGEN_MATRIX_FUNCTION(MatrixSquareRootReturnValue, sqrt, square root)
+    EIGEN_MATRIX_FUNCTION(MatrixLogarithmReturnValue, log, logarithm)
+    EIGEN_MATRIX_FUNCTION_1(MatrixPowerReturnValue,        pow, power to \c p, const RealScalar& p)
+    EIGEN_MATRIX_FUNCTION_1(MatrixComplexPowerReturnValue, pow, power to \c p, const std::complex<RealScalar>& p)
+
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(MatrixBase)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(MatrixBase)
+
+  private:
+    EIGEN_DEVICE_FUNC explicit MatrixBase(int);
+    EIGEN_DEVICE_FUNC MatrixBase(int,int);
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit MatrixBase(const MatrixBase<OtherDerived>&);
+  protected:
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator+=(const ArrayBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator-=(const ArrayBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+};
+
+
+/***************************************************************************
+* Implementation of matrix base methods
+***************************************************************************/
+
+/** replaces \c *this by \c *this * \a other.
+  *
+  * \returns a reference to \c *this
+  *
+  * Example: \include MatrixBase_applyOnTheRight.cpp
+  * Output: \verbinclude MatrixBase_applyOnTheRight.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+inline Derived&
+MatrixBase<Derived>::operator*=(const EigenBase<OtherDerived> &other)
+{
+  other.derived().applyThisOnTheRight(derived());
+  return derived();
+}
+
+/** replaces \c *this by \c *this * \a other. It is equivalent to MatrixBase::operator*=().
+  *
+  * Example: \include MatrixBase_applyOnTheRight.cpp
+  * Output: \verbinclude MatrixBase_applyOnTheRight.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+inline void MatrixBase<Derived>::applyOnTheRight(const EigenBase<OtherDerived> &other)
+{
+  other.derived().applyThisOnTheRight(derived());
+}
+
+/** replaces \c *this by \a other * \c *this.
+  *
+  * Example: \include MatrixBase_applyOnTheLeft.cpp
+  * Output: \verbinclude MatrixBase_applyOnTheLeft.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+inline void MatrixBase<Derived>::applyOnTheLeft(const EigenBase<OtherDerived> &other)
+{
+  other.derived().applyThisOnTheLeft(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIXBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/NestByValue.h b/C++/yolo_bytetrack/include/Eigen/src/Core/NestByValue.h
new file mode 100644
index 00000000..b4275768
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/NestByValue.h
@@ -0,0 +1,85 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NESTBYVALUE_H
+#define EIGEN_NESTBYVALUE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<NestByValue<ExpressionType> > : public traits<ExpressionType>
+{
+  enum {
+    Flags = traits<ExpressionType>::Flags & ~NestByRefBit
+  };
+};
+}
+
+/** \class NestByValue
+  * \ingroup Core_Module
+  *
+  * \brief Expression which must be nested by value
+  *
+  * \tparam ExpressionType the type of the object of which we are requiring nesting-by-value
+  *
+  * This class is the return type of MatrixBase::nestByValue()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::nestByValue()
+  */
+template<typename ExpressionType> class NestByValue
+  : public internal::dense_xpr_base< NestByValue<ExpressionType> >::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<NestByValue>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(NestByValue)
+
+    EIGEN_DEVICE_FUNC explicit inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index rows() const EIGEN_NOEXCEPT { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index cols() const EIGEN_NOEXCEPT { return m_expression.cols(); }
+
+    EIGEN_DEVICE_FUNC operator const ExpressionType&() const { return m_expression; }
+
+    EIGEN_DEVICE_FUNC const ExpressionType& nestedExpression() const { return m_expression; }
+
+  protected:
+    const ExpressionType m_expression;
+};
+
+/** \returns an expression of the temporary version of *this.
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const NestByValue<Derived>
+DenseBase<Derived>::nestByValue() const
+{
+  return NestByValue<Derived>(derived());
+}
+
+namespace internal {
+
+// Evaluator of Solve -> eval into a temporary
+template<typename ArgType>
+struct evaluator<NestByValue<ArgType> >
+  : public evaluator<ArgType>
+{
+  typedef evaluator<ArgType> Base;
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const NestByValue<ArgType>& xpr)
+    : Base(xpr.nestedExpression())
+  {}
+};
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_NESTBYVALUE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/NoAlias.h b/C++/yolo_bytetrack/include/Eigen/src/Core/NoAlias.h
new file mode 100644
index 00000000..570283d9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/NoAlias.h
@@ -0,0 +1,109 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NOALIAS_H
+#define EIGEN_NOALIAS_H
+
+namespace Eigen {
+
+/** \class NoAlias
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression providing an operator = assuming no aliasing
+  *
+  * \tparam ExpressionType the type of the object on which to do the lazy assignment
+  *
+  * This class represents an expression with special assignment operators
+  * assuming no aliasing between the target expression and the source expression.
+  * More precisely it alloas to bypass the EvalBeforeAssignBit flag of the source expression.
+  * It is the return type of MatrixBase::noalias()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::noalias()
+  */
+template<typename ExpressionType, template <typename> class StorageBase>
+class NoAlias
+{
+  public:
+    typedef typename ExpressionType::Scalar Scalar;
+    
+    EIGEN_DEVICE_FUNC
+    explicit NoAlias(ExpressionType& expression) : m_expression(expression) {}
+    
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase<OtherDerived>& other)
+    {
+      call_assignment_no_alias(m_expression, other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+      return m_expression;
+    }
+    
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase<OtherDerived>& other)
+    {
+      call_assignment_no_alias(m_expression, other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+      return m_expression;
+    }
+    
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase<OtherDerived>& other)
+    {
+      call_assignment_no_alias(m_expression, other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+      return m_expression;
+    }
+
+    EIGEN_DEVICE_FUNC
+    ExpressionType& expression() const
+    {
+      return m_expression;
+    }
+
+  protected:
+    ExpressionType& m_expression;
+};
+
+/** \returns a pseudo expression of \c *this with an operator= assuming
+  * no aliasing between \c *this and the source expression.
+  *
+  * More precisely, noalias() allows to bypass the EvalBeforeAssignBit flag.
+  * Currently, even though several expressions may alias, only product
+  * expressions have this flag. Therefore, noalias() is only useful when
+  * the source expression contains a matrix product.
+  *
+  * Here are some examples where noalias is useful:
+  * \code
+  * D.noalias()  = A * B;
+  * D.noalias() += A.transpose() * B;
+  * D.noalias() -= 2 * A * B.adjoint();
+  * \endcode
+  *
+  * On the other hand the following example will lead to a \b wrong result:
+  * \code
+  * A.noalias() = A * B;
+  * \endcode
+  * because the result matrix A is also an operand of the matrix product. Therefore,
+  * there is no alternative than evaluating A * B in a temporary, that is the default
+  * behavior when you write:
+  * \code
+  * A = A * B;
+  * \endcode
+  *
+  * \sa class NoAlias
+  */
+template<typename Derived>
+NoAlias<Derived,MatrixBase> EIGEN_DEVICE_FUNC MatrixBase<Derived>::noalias()
+{
+  return NoAlias<Derived, Eigen::MatrixBase >(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_NOALIAS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/NumTraits.h b/C++/yolo_bytetrack/include/Eigen/src/Core/NumTraits.h
new file mode 100644
index 00000000..72eac5a9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/NumTraits.h
@@ -0,0 +1,335 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NUMTRAITS_H
+#define EIGEN_NUMTRAITS_H
+
+namespace Eigen {
+
+namespace internal {
+
+// default implementation of digits10(), based on numeric_limits if specialized,
+// 0 for integer types, and log10(epsilon()) otherwise.
+template< typename T,
+          bool use_numeric_limits = std::numeric_limits<T>::is_specialized,
+          bool is_integer = NumTraits<T>::IsInteger>
+struct default_digits10_impl
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() { return std::numeric_limits<T>::digits10; }
+};
+
+template<typename T>
+struct default_digits10_impl<T,false,false> // Floating point
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() {
+    using std::log10;
+    using std::ceil;
+    typedef typename NumTraits<T>::Real Real;
+    return int(ceil(-log10(NumTraits<Real>::epsilon())));
+  }
+};
+
+template<typename T>
+struct default_digits10_impl<T,false,true> // Integer
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() { return 0; }
+};
+
+
+// default implementation of digits(), based on numeric_limits if specialized,
+// 0 for integer types, and log2(epsilon()) otherwise.
+template< typename T,
+          bool use_numeric_limits = std::numeric_limits<T>::is_specialized,
+          bool is_integer = NumTraits<T>::IsInteger>
+struct default_digits_impl
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() { return std::numeric_limits<T>::digits; }
+};
+
+template<typename T>
+struct default_digits_impl<T,false,false> // Floating point
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() {
+    using std::log;
+    using std::ceil;
+    typedef typename NumTraits<T>::Real Real;
+    return int(ceil(-log(NumTraits<Real>::epsilon())/log(static_cast<Real>(2))));
+  }
+};
+
+template<typename T>
+struct default_digits_impl<T,false,true> // Integer
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() { return 0; }
+};
+
+} // end namespace internal
+
+namespace numext {
+/** \internal bit-wise cast without changing the underlying bit representation. */
+
+// TODO: Replace by std::bit_cast (available in C++20)
+template <typename Tgt, typename Src>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Tgt bit_cast(const Src& src) {
+#if EIGEN_HAS_TYPE_TRAITS
+  // The behaviour of memcpy is not specified for non-trivially copyable types
+  EIGEN_STATIC_ASSERT(std::is_trivially_copyable<Src>::value, THIS_TYPE_IS_NOT_SUPPORTED);
+  EIGEN_STATIC_ASSERT(std::is_trivially_copyable<Tgt>::value && std::is_default_constructible<Tgt>::value,
+                      THIS_TYPE_IS_NOT_SUPPORTED);
+#endif
+
+  EIGEN_STATIC_ASSERT(sizeof(Src) == sizeof(Tgt), THIS_TYPE_IS_NOT_SUPPORTED);
+  Tgt tgt;
+  EIGEN_USING_STD(memcpy)
+  memcpy(&tgt, &src, sizeof(Tgt));
+  return tgt;
+}
+}  // namespace numext
+
+/** \class NumTraits
+  * \ingroup Core_Module
+  *
+  * \brief Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
+  *
+  * \tparam T the numeric type at hand
+  *
+  * This class stores enums, typedefs and static methods giving information about a numeric type.
+  *
+  * The provided data consists of:
+  * \li A typedef \c Real, giving the "real part" type of \a T. If \a T is already real,
+  *     then \c Real is just a typedef to \a T. If \a T is \c std::complex<U> then \c Real
+  *     is a typedef to \a U.
+  * \li A typedef \c NonInteger, giving the type that should be used for operations producing non-integral values,
+  *     such as quotients, square roots, etc. If \a T is a floating-point type, then this typedef just gives
+  *     \a T again. Note however that many Eigen functions such as internal::sqrt simply refuse to
+  *     take integers. Outside of a few cases, Eigen doesn't do automatic type promotion. Thus, this typedef is
+  *     only intended as a helper for code that needs to explicitly promote types.
+  * \li A typedef \c Literal giving the type to use for numeric literals such as "2" or "0.5". For instance, for \c std::complex<U>, Literal is defined as \c U.
+  *     Of course, this type must be fully compatible with \a T. In doubt, just use \a T here.
+  * \li A typedef \a Nested giving the type to use to nest a value inside of the expression tree. If you don't know what
+  *     this means, just use \a T here.
+  * \li An enum value \a IsComplex. It is equal to 1 if \a T is a \c std::complex
+  *     type, and to 0 otherwise.
+  * \li An enum value \a IsInteger. It is equal to \c 1 if \a T is an integer type such as \c int,
+  *     and to \c 0 otherwise.
+  * \li Enum values ReadCost, AddCost and MulCost representing a rough estimate of the number of CPU cycles needed
+  *     to by move / add / mul instructions respectively, assuming the data is already stored in CPU registers.
+  *     Stay vague here. No need to do architecture-specific stuff. If you don't know what this means, just use \c Eigen::HugeCost.
+  * \li An enum value \a IsSigned. It is equal to \c 1 if \a T is a signed type and to 0 if \a T is unsigned.
+  * \li An enum value \a RequireInitialization. It is equal to \c 1 if the constructor of the numeric type \a T must
+  *     be called, and to 0 if it is safe not to call it. Default is 0 if \a T is an arithmetic type, and 1 otherwise.
+  * \li An epsilon() function which, unlike <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/epsilon">std::numeric_limits::epsilon()</a>,
+  *     it returns a \a Real instead of a \a T.
+  * \li A dummy_precision() function returning a weak epsilon value. It is mainly used as a default
+  *     value by the fuzzy comparison operators.
+  * \li highest() and lowest() functions returning the highest and lowest possible values respectively.
+  * \li digits() function returning the number of radix digits (non-sign digits for integers, mantissa for floating-point). This is
+  *     the analogue of <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/digits">std::numeric_limits<T>::digits</a>
+  *     which is used as the default implementation if specialized.
+  * \li digits10() function returning the number of decimal digits that can be represented without change. This is
+  *     the analogue of <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/digits10">std::numeric_limits<T>::digits10</a>
+  *     which is used as the default implementation if specialized.
+  * \li min_exponent() and max_exponent() functions returning the highest and lowest possible values, respectively,
+  *     such that the radix raised to the power exponent-1 is a normalized floating-point number.  These are equivalent to
+  *     <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/min_exponent">std::numeric_limits<T>::min_exponent</a>/
+  *     <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/max_exponent">std::numeric_limits<T>::max_exponent</a>.
+  * \li infinity() function returning a representation of positive infinity, if available.
+  * \li quiet_NaN function returning a non-signaling "not-a-number", if available.
+  */
+
+template<typename T> struct GenericNumTraits
+{
+  enum {
+    IsInteger = std::numeric_limits<T>::is_integer,
+    IsSigned = std::numeric_limits<T>::is_signed,
+    IsComplex = 0,
+    RequireInitialization = internal::is_arithmetic<T>::value ? 0 : 1,
+    ReadCost = 1,
+    AddCost = 1,
+    MulCost = 1
+  };
+
+  typedef T Real;
+  typedef typename internal::conditional<
+                     IsInteger,
+                     typename internal::conditional<sizeof(T)<=2, float, double>::type,
+                     T
+                   >::type NonInteger;
+  typedef T Nested;
+  typedef T Literal;
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline Real epsilon()
+  {
+    return numext::numeric_limits<T>::epsilon();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline int digits10()
+  {
+    return internal::default_digits10_impl<T>::run();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline int digits()
+  {
+    return internal::default_digits_impl<T>::run();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline int min_exponent()
+  {
+    return numext::numeric_limits<T>::min_exponent;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline int max_exponent()
+  {
+    return numext::numeric_limits<T>::max_exponent;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline Real dummy_precision()
+  {
+    // make sure to override this for floating-point types
+    return Real(0);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline T highest() {
+    return (numext::numeric_limits<T>::max)();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline T lowest()  {
+    return IsInteger ? (numext::numeric_limits<T>::min)()
+                     : static_cast<T>(-(numext::numeric_limits<T>::max)());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline T infinity() {
+    return numext::numeric_limits<T>::infinity();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline T quiet_NaN() {
+    return numext::numeric_limits<T>::quiet_NaN();
+  }
+};
+
+template<typename T> struct NumTraits : GenericNumTraits<T>
+{};
+
+template<> struct NumTraits<float>
+  : GenericNumTraits<float>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline float dummy_precision() { return 1e-5f; }
+};
+
+template<> struct NumTraits<double> : GenericNumTraits<double>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline double dummy_precision() { return 1e-12; }
+};
+
+template<> struct NumTraits<long double>
+  : GenericNumTraits<long double>
+{
+  EIGEN_CONSTEXPR
+  static inline long double dummy_precision() { return 1e-15l; }
+};
+
+template<typename _Real> struct NumTraits<std::complex<_Real> >
+  : GenericNumTraits<std::complex<_Real> >
+{
+  typedef _Real Real;
+  typedef typename NumTraits<_Real>::Literal Literal;
+  enum {
+    IsComplex = 1,
+    RequireInitialization = NumTraits<_Real>::RequireInitialization,
+    ReadCost = 2 * NumTraits<_Real>::ReadCost,
+    AddCost = 2 * NumTraits<Real>::AddCost,
+    MulCost = 4 * NumTraits<Real>::MulCost + 2 * NumTraits<Real>::AddCost
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline Real epsilon() { return NumTraits<Real>::epsilon(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline Real dummy_precision() { return NumTraits<Real>::dummy_precision(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline int digits10() { return NumTraits<Real>::digits10(); }
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+struct NumTraits<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
+{
+  typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> ArrayType;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Array<RealScalar, Rows, Cols, Options, MaxRows, MaxCols> Real;
+  typedef typename NumTraits<Scalar>::NonInteger NonIntegerScalar;
+  typedef Array<NonIntegerScalar, Rows, Cols, Options, MaxRows, MaxCols> NonInteger;
+  typedef ArrayType & Nested;
+  typedef typename NumTraits<Scalar>::Literal Literal;
+
+  enum {
+    IsComplex = NumTraits<Scalar>::IsComplex,
+    IsInteger = NumTraits<Scalar>::IsInteger,
+    IsSigned  = NumTraits<Scalar>::IsSigned,
+    RequireInitialization = 1,
+    ReadCost = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * int(NumTraits<Scalar>::ReadCost),
+    AddCost  = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * int(NumTraits<Scalar>::AddCost),
+    MulCost  = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * int(NumTraits<Scalar>::MulCost)
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline RealScalar epsilon() { return NumTraits<RealScalar>::epsilon(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline RealScalar dummy_precision() { return NumTraits<RealScalar>::dummy_precision(); }
+
+  EIGEN_CONSTEXPR
+  static inline int digits10() { return NumTraits<Scalar>::digits10(); }
+};
+
+template<> struct NumTraits<std::string>
+  : GenericNumTraits<std::string>
+{
+  enum {
+    RequireInitialization = 1,
+    ReadCost = HugeCost,
+    AddCost  = HugeCost,
+    MulCost  = HugeCost
+  };
+
+  EIGEN_CONSTEXPR
+  static inline int digits10() { return 0; }
+
+private:
+  static inline std::string epsilon();
+  static inline std::string dummy_precision();
+  static inline std::string lowest();
+  static inline std::string highest();
+  static inline std::string infinity();
+  static inline std::string quiet_NaN();
+};
+
+// Empty specialization for void to allow template specialization based on NumTraits<T>::Real with T==void and SFINAE.
+template<> struct NumTraits<void> {};
+
+template<> struct NumTraits<bool> : GenericNumTraits<bool> {};
+
+} // end namespace Eigen
+
+#endif // EIGEN_NUMTRAITS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/PartialReduxEvaluator.h b/C++/yolo_bytetrack/include/Eigen/src/Core/PartialReduxEvaluator.h
new file mode 100644
index 00000000..29abf35b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/PartialReduxEvaluator.h
@@ -0,0 +1,232 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2018 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARTIALREDUX_H
+#define EIGEN_PARTIALREDUX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+/***************************************************************************
+*
+* This file provides evaluators for partial reductions.
+* There are two modes:
+*
+*  - scalar path: simply calls the respective function on the column or row.
+*    -> nothing special here, all the tricky part is handled by the return
+*       types of VectorwiseOp's members. They embed the functor calling the
+*       respective DenseBase's member function.
+*
+*  - vectorized path: implements a packet-wise reductions followed by
+*    some (optional) processing of the outcome, e.g., division by n for mean.
+*
+* For the vectorized path let's observe that the packet-size and outer-unrolling
+* are both decided by the assignement logic. So all we have to do is to decide
+* on the inner unrolling.
+*
+* For the unrolling, we can reuse "internal::redux_vec_unroller" from Redux.h,
+* but be need to be careful to specify correct increment.
+*
+***************************************************************************/
+
+
+/* logic deciding a strategy for unrolling of vectorized paths */
+template<typename Func, typename Evaluator>
+struct packetwise_redux_traits
+{
+  enum {
+    OuterSize = int(Evaluator::IsRowMajor) ? Evaluator::RowsAtCompileTime : Evaluator::ColsAtCompileTime,
+    Cost = OuterSize == Dynamic ? HugeCost
+         : OuterSize * Evaluator::CoeffReadCost + (OuterSize-1) * functor_traits<Func>::Cost,
+    Unrolling = Cost <= EIGEN_UNROLLING_LIMIT ? CompleteUnrolling : NoUnrolling
+  };
+
+};
+
+/* Value to be returned when size==0 , by default let's return 0 */
+template<typename PacketType,typename Func>
+EIGEN_DEVICE_FUNC
+PacketType packetwise_redux_empty_value(const Func& ) { return pset1<PacketType>(0); }
+
+/* For products the default is 1 */
+template<typename PacketType,typename Scalar>
+EIGEN_DEVICE_FUNC
+PacketType packetwise_redux_empty_value(const scalar_product_op<Scalar,Scalar>& ) { return pset1<PacketType>(1); }
+
+/* Perform the actual reduction */
+template<typename Func, typename Evaluator,
+         int Unrolling = packetwise_redux_traits<Func, Evaluator>::Unrolling
+>
+struct packetwise_redux_impl;
+
+/* Perform the actual reduction with unrolling */
+template<typename Func, typename Evaluator>
+struct packetwise_redux_impl<Func, Evaluator, CompleteUnrolling>
+{
+  typedef redux_novec_unroller<Func,Evaluator, 0, Evaluator::SizeAtCompileTime> Base;
+  typedef typename Evaluator::Scalar Scalar;
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE
+  PacketType run(const Evaluator &eval, const Func& func, Index /*size*/)
+  {
+    return redux_vec_unroller<Func, Evaluator, 0, packetwise_redux_traits<Func, Evaluator>::OuterSize>::template run<PacketType>(eval,func);
+  }
+};
+
+/* Add a specialization of redux_vec_unroller for size==0 at compiletime.
+ * This specialization is not required for general reductions, which is
+ * why it is defined here.
+ */
+template<typename Func, typename Evaluator, int Start>
+struct redux_vec_unroller<Func, Evaluator, Start, 0>
+{
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE PacketType run(const Evaluator &, const Func& f)
+  {
+    return packetwise_redux_empty_value<PacketType>(f);
+  }
+};
+
+/* Perform the actual reduction for dynamic sizes */
+template<typename Func, typename Evaluator>
+struct packetwise_redux_impl<Func, Evaluator, NoUnrolling>
+{
+  typedef typename Evaluator::Scalar Scalar;
+  typedef typename redux_traits<Func, Evaluator>::PacketType PacketScalar;
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC
+  static PacketType run(const Evaluator &eval, const Func& func, Index size)
+  {
+    if(size==0)
+      return packetwise_redux_empty_value<PacketType>(func);
+    
+    const Index size4 = (size-1)&(~3);
+    PacketType p = eval.template packetByOuterInner<Unaligned,PacketType>(0,0);
+    Index i = 1;
+    // This loop is optimized for instruction pipelining:
+    // - each iteration generates two independent instructions
+    // - thanks to branch prediction and out-of-order execution we have independent instructions across loops
+    for(; i<size4; i+=4)
+      p = func.packetOp(p,
+            func.packetOp(
+              func.packetOp(eval.template packetByOuterInner<Unaligned,PacketType>(i+0,0),eval.template packetByOuterInner<Unaligned,PacketType>(i+1,0)),
+              func.packetOp(eval.template packetByOuterInner<Unaligned,PacketType>(i+2,0),eval.template packetByOuterInner<Unaligned,PacketType>(i+3,0))));
+    for(; i<size; ++i)
+      p = func.packetOp(p, eval.template packetByOuterInner<Unaligned,PacketType>(i,0));
+    return p;
+  }
+};
+
+template< typename ArgType, typename MemberOp, int Direction>
+struct evaluator<PartialReduxExpr<ArgType, MemberOp, Direction> >
+  : evaluator_base<PartialReduxExpr<ArgType, MemberOp, Direction> >
+{
+  typedef PartialReduxExpr<ArgType, MemberOp, Direction> XprType;
+  typedef typename internal::nested_eval<ArgType,1>::type ArgTypeNested;
+  typedef typename internal::add_const_on_value_type<ArgTypeNested>::type ConstArgTypeNested;
+  typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNestedCleaned;
+  typedef typename ArgType::Scalar InputScalar;
+  typedef typename XprType::Scalar Scalar;
+  enum {
+    TraversalSize = Direction==int(Vertical) ? int(ArgType::RowsAtCompileTime) :  int(ArgType::ColsAtCompileTime)
+  };
+  typedef typename MemberOp::template Cost<int(TraversalSize)> CostOpType;
+  enum {
+    CoeffReadCost = TraversalSize==Dynamic ? HugeCost
+                  : TraversalSize==0 ? 1
+                  : int(TraversalSize) * int(evaluator<ArgType>::CoeffReadCost) + int(CostOpType::value),
+    
+    _ArgFlags = evaluator<ArgType>::Flags,
+
+    _Vectorizable =  bool(int(_ArgFlags)&PacketAccessBit)
+                  && bool(MemberOp::Vectorizable)
+                  && (Direction==int(Vertical) ? bool(_ArgFlags&RowMajorBit) : (_ArgFlags&RowMajorBit)==0)
+                  && (TraversalSize!=0),
+                  
+    Flags = (traits<XprType>::Flags&RowMajorBit)
+          | (evaluator<ArgType>::Flags&(HereditaryBits&(~RowMajorBit)))
+          | (_Vectorizable ? PacketAccessBit : 0)
+          | LinearAccessBit,
+    
+    Alignment = 0 // FIXME this will need to be improved once PartialReduxExpr is vectorized
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType xpr)
+    : m_arg(xpr.nestedExpression()), m_functor(xpr.functor())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(TraversalSize==Dynamic ? HugeCost : (TraversalSize==0 ? 1 : int(CostOpType::value)));
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar coeff(Index i, Index j) const
+  {
+    return coeff(Direction==Vertical ? j : i);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar coeff(Index index) const
+  {
+    return m_functor(m_arg.template subVector<DirectionType(Direction)>(index));
+  }
+
+  template<int LoadMode,typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  PacketType packet(Index i, Index j) const
+  {
+    return packet<LoadMode,PacketType>(Direction==Vertical ? j : i);
+  }
+  
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+  PacketType packet(Index idx) const
+  {
+    enum { PacketSize = internal::unpacket_traits<PacketType>::size };
+    typedef Block<const ArgTypeNestedCleaned,
+                  Direction==Vertical ? int(ArgType::RowsAtCompileTime) : int(PacketSize),
+                  Direction==Vertical ? int(PacketSize) : int(ArgType::ColsAtCompileTime),
+                  true /* InnerPanel */> PanelType;
+    
+    PanelType panel(m_arg,
+                    Direction==Vertical ? 0 : idx,
+                    Direction==Vertical ? idx : 0,
+                    Direction==Vertical ? m_arg.rows() : Index(PacketSize),
+                    Direction==Vertical ? Index(PacketSize) : m_arg.cols());
+
+    // FIXME
+    // See bug 1612, currently if PacketSize==1 (i.e. complex<double> with 128bits registers) then the storage-order of panel get reversed
+    // and methods like packetByOuterInner do not make sense anymore in this context.
+    // So let's just by pass "vectorization" in this case:
+    if(PacketSize==1)
+      return internal::pset1<PacketType>(coeff(idx));
+    
+    typedef typename internal::redux_evaluator<PanelType> PanelEvaluator;
+    PanelEvaluator panel_eval(panel);
+    typedef typename MemberOp::BinaryOp BinaryOp;
+    PacketType p = internal::packetwise_redux_impl<BinaryOp,PanelEvaluator>::template run<PacketType>(panel_eval,m_functor.binaryFunc(),m_arg.outerSize());
+    return p;
+  }
+
+protected:
+  ConstArgTypeNested m_arg;
+  const MemberOp m_functor;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIALREDUX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/PermutationMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/Core/PermutationMatrix.h
new file mode 100644
index 00000000..69401bf4
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/PermutationMatrix.h
@@ -0,0 +1,605 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PERMUTATIONMATRIX_H
+#define EIGEN_PERMUTATIONMATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+enum PermPermProduct_t {PermPermProduct};
+
+} // end namespace internal
+
+/** \class PermutationBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for permutations
+  *
+  * \tparam Derived the derived class
+  *
+  * This class is the base class for all expressions representing a permutation matrix,
+  * internally stored as a vector of integers.
+  * The convention followed here is that if \f$ \sigma \f$ is a permutation, the corresponding permutation matrix
+  * \f$ P_\sigma \f$ is such that if \f$ (e_1,\ldots,e_p) \f$ is the canonical basis, we have:
+  *  \f[ P_\sigma(e_i) = e_{\sigma(i)}. \f]
+  * This convention ensures that for any two permutations \f$ \sigma, \tau \f$, we have:
+  *  \f[ P_{\sigma\circ\tau} = P_\sigma P_\tau. \f]
+  *
+  * Permutation matrices are square and invertible.
+  *
+  * Notice that in addition to the member functions and operators listed here, there also are non-member
+  * operator* to multiply any kind of permutation object with any kind of matrix expression (MatrixBase)
+  * on either side.
+  *
+  * \sa class PermutationMatrix, class PermutationWrapper
+  */
+template<typename Derived>
+class PermutationBase : public EigenBase<Derived>
+{
+    typedef internal::traits<Derived> Traits;
+    typedef EigenBase<Derived> Base;
+  public:
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    enum {
+      Flags = Traits::Flags,
+      RowsAtCompileTime = Traits::RowsAtCompileTime,
+      ColsAtCompileTime = Traits::ColsAtCompileTime,
+      MaxRowsAtCompileTime = Traits::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = Traits::MaxColsAtCompileTime
+    };
+    typedef typename Traits::StorageIndex StorageIndex;
+    typedef Matrix<StorageIndex,RowsAtCompileTime,ColsAtCompileTime,0,MaxRowsAtCompileTime,MaxColsAtCompileTime>
+            DenseMatrixType;
+    typedef PermutationMatrix<IndicesType::SizeAtCompileTime,IndicesType::MaxSizeAtCompileTime,StorageIndex>
+            PlainPermutationType;
+    typedef PlainPermutationType PlainObject;
+    using Base::derived;
+    typedef Inverse<Derived> InverseReturnType;
+    typedef void Scalar;
+    #endif
+
+    /** Copies the other permutation into *this */
+    template<typename OtherDerived>
+    Derived& operator=(const PermutationBase<OtherDerived>& other)
+    {
+      indices() = other.indices();
+      return derived();
+    }
+
+    /** Assignment from the Transpositions \a tr */
+    template<typename OtherDerived>
+    Derived& operator=(const TranspositionsBase<OtherDerived>& tr)
+    {
+      setIdentity(tr.size());
+      for(Index k=size()-1; k>=0; --k)
+        applyTranspositionOnTheRight(k,tr.coeff(k));
+      return derived();
+    }
+
+    /** \returns the number of rows */
+    inline EIGEN_DEVICE_FUNC Index rows() const { return Index(indices().size()); }
+
+    /** \returns the number of columns */
+    inline EIGEN_DEVICE_FUNC Index cols() const { return Index(indices().size()); }
+
+    /** \returns the size of a side of the respective square matrix, i.e., the number of indices */
+    inline EIGEN_DEVICE_FUNC Index size() const { return Index(indices().size()); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename DenseDerived>
+    void evalTo(MatrixBase<DenseDerived>& other) const
+    {
+      other.setZero();
+      for (Index i=0; i<rows(); ++i)
+        other.coeffRef(indices().coeff(i),i) = typename DenseDerived::Scalar(1);
+    }
+    #endif
+
+    /** \returns a Matrix object initialized from this permutation matrix. Notice that it
+      * is inefficient to return this Matrix object by value. For efficiency, favor using
+      * the Matrix constructor taking EigenBase objects.
+      */
+    DenseMatrixType toDenseMatrix() const
+    {
+      return derived();
+    }
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return derived().indices(); }
+    /** \returns a reference to the stored array representing the permutation. */
+    IndicesType& indices() { return derived().indices(); }
+
+    /** Resizes to given size.
+      */
+    inline void resize(Index newSize)
+    {
+      indices().resize(newSize);
+    }
+
+    /** Sets *this to be the identity permutation matrix */
+    void setIdentity()
+    {
+      StorageIndex n = StorageIndex(size());
+      for(StorageIndex i = 0; i < n; ++i)
+        indices().coeffRef(i) = i;
+    }
+
+    /** Sets *this to be the identity permutation matrix of given size.
+      */
+    void setIdentity(Index newSize)
+    {
+      resize(newSize);
+      setIdentity();
+    }
+
+    /** Multiplies *this by the transposition \f$(ij)\f$ on the left.
+      *
+      * \returns a reference to *this.
+      *
+      * \warning This is much slower than applyTranspositionOnTheRight(Index,Index):
+      * this has linear complexity and requires a lot of branching.
+      *
+      * \sa applyTranspositionOnTheRight(Index,Index)
+      */
+    Derived& applyTranspositionOnTheLeft(Index i, Index j)
+    {
+      eigen_assert(i>=0 && j>=0 && i<size() && j<size());
+      for(Index k = 0; k < size(); ++k)
+      {
+        if(indices().coeff(k) == i) indices().coeffRef(k) = StorageIndex(j);
+        else if(indices().coeff(k) == j) indices().coeffRef(k) = StorageIndex(i);
+      }
+      return derived();
+    }
+
+    /** Multiplies *this by the transposition \f$(ij)\f$ on the right.
+      *
+      * \returns a reference to *this.
+      *
+      * This is a fast operation, it only consists in swapping two indices.
+      *
+      * \sa applyTranspositionOnTheLeft(Index,Index)
+      */
+    Derived& applyTranspositionOnTheRight(Index i, Index j)
+    {
+      eigen_assert(i>=0 && j>=0 && i<size() && j<size());
+      std::swap(indices().coeffRef(i), indices().coeffRef(j));
+      return derived();
+    }
+
+    /** \returns the inverse permutation matrix.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    inline InverseReturnType inverse() const
+    { return InverseReturnType(derived()); }
+    /** \returns the tranpose permutation matrix.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    inline InverseReturnType transpose() const
+    { return InverseReturnType(derived()); }
+
+    /**** multiplication helpers to hopefully get RVO ****/
+
+  
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  protected:
+    template<typename OtherDerived>
+    void assignTranspose(const PermutationBase<OtherDerived>& other)
+    {
+      for (Index i=0; i<rows();++i) indices().coeffRef(other.indices().coeff(i)) = i;
+    }
+    template<typename Lhs,typename Rhs>
+    void assignProduct(const Lhs& lhs, const Rhs& rhs)
+    {
+      eigen_assert(lhs.cols() == rhs.rows());
+      for (Index i=0; i<rows();++i) indices().coeffRef(i) = lhs.indices().coeff(rhs.indices().coeff(i));
+    }
+#endif
+
+  public:
+
+    /** \returns the product permutation matrix.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    template<typename Other>
+    inline PlainPermutationType operator*(const PermutationBase<Other>& other) const
+    { return PlainPermutationType(internal::PermPermProduct, derived(), other.derived()); }
+
+    /** \returns the product of a permutation with another inverse permutation.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    template<typename Other>
+    inline PlainPermutationType operator*(const InverseImpl<Other,PermutationStorage>& other) const
+    { return PlainPermutationType(internal::PermPermProduct, *this, other.eval()); }
+
+    /** \returns the product of an inverse permutation with another permutation.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    template<typename Other> friend
+    inline PlainPermutationType operator*(const InverseImpl<Other, PermutationStorage>& other, const PermutationBase& perm)
+    { return PlainPermutationType(internal::PermPermProduct, other.eval(), perm); }
+    
+    /** \returns the determinant of the permutation matrix, which is either 1 or -1 depending on the parity of the permutation.
+      *
+      * This function is O(\c n) procedure allocating a buffer of \c n booleans.
+      */
+    Index determinant() const
+    {
+      Index res = 1;
+      Index n = size();
+      Matrix<bool,RowsAtCompileTime,1,0,MaxRowsAtCompileTime> mask(n);
+      mask.fill(false);
+      Index r = 0;
+      while(r < n)
+      {
+        // search for the next seed
+        while(r<n && mask[r]) r++;
+        if(r>=n)
+          break;
+        // we got one, let's follow it until we are back to the seed
+        Index k0 = r++;
+        mask.coeffRef(k0) = true;
+        for(Index k=indices().coeff(k0); k!=k0; k=indices().coeff(k))
+        {
+          mask.coeffRef(k) = true;
+          res = -res;
+        }
+      }
+      return res;
+    }
+
+  protected:
+
+};
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+struct traits<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex> >
+ : traits<Matrix<_StorageIndex,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  typedef PermutationStorage StorageKind;
+  typedef Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> IndicesType;
+  typedef _StorageIndex StorageIndex;
+  typedef void Scalar;
+};
+}
+
+/** \class PermutationMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Permutation matrix
+  *
+  * \tparam SizeAtCompileTime the number of rows/cols, or Dynamic
+  * \tparam MaxSizeAtCompileTime the maximum number of rows/cols, or Dynamic. This optional parameter defaults to SizeAtCompileTime. Most of the time, you should not have to specify it.
+  * \tparam _StorageIndex the integer type of the indices
+  *
+  * This class represents a permutation matrix, internally stored as a vector of integers.
+  *
+  * \sa class PermutationBase, class PermutationWrapper, class DiagonalMatrix
+  */
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+class PermutationMatrix : public PermutationBase<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex> >
+{
+    typedef PermutationBase<PermutationMatrix> Base;
+    typedef internal::traits<PermutationMatrix> Traits;
+  public:
+
+    typedef const PermutationMatrix& Nested;
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename Traits::StorageIndex StorageIndex;
+    #endif
+
+    inline PermutationMatrix()
+    {}
+
+    /** Constructs an uninitialized permutation matrix of given size.
+      */
+    explicit inline PermutationMatrix(Index size) : m_indices(size)
+    {
+      eigen_internal_assert(size <= NumTraits<StorageIndex>::highest());
+    }
+
+    /** Copy constructor. */
+    template<typename OtherDerived>
+    inline PermutationMatrix(const PermutationBase<OtherDerived>& other)
+      : m_indices(other.indices()) {}
+
+    /** Generic constructor from expression of the indices. The indices
+      * array has the meaning that the permutations sends each integer i to indices[i].
+      *
+      * \warning It is your responsibility to check that the indices array that you passes actually
+      * describes a permutation, i.e., each value between 0 and n-1 occurs exactly once, where n is the
+      * array's size.
+      */
+    template<typename Other>
+    explicit inline PermutationMatrix(const MatrixBase<Other>& indices) : m_indices(indices)
+    {}
+
+    /** Convert the Transpositions \a tr to a permutation matrix */
+    template<typename Other>
+    explicit PermutationMatrix(const TranspositionsBase<Other>& tr)
+      : m_indices(tr.size())
+    {
+      *this = tr;
+    }
+
+    /** Copies the other permutation into *this */
+    template<typename Other>
+    PermutationMatrix& operator=(const PermutationBase<Other>& other)
+    {
+      m_indices = other.indices();
+      return *this;
+    }
+
+    /** Assignment from the Transpositions \a tr */
+    template<typename Other>
+    PermutationMatrix& operator=(const TranspositionsBase<Other>& tr)
+    {
+      return Base::operator=(tr.derived());
+    }
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return m_indices; }
+    /** \returns a reference to the stored array representing the permutation. */
+    IndicesType& indices() { return m_indices; }
+
+
+    /**** multiplication helpers to hopefully get RVO ****/
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename Other>
+    PermutationMatrix(const InverseImpl<Other,PermutationStorage>& other)
+      : m_indices(other.derived().nestedExpression().size())
+    {
+      eigen_internal_assert(m_indices.size() <= NumTraits<StorageIndex>::highest());
+      StorageIndex end = StorageIndex(m_indices.size());
+      for (StorageIndex i=0; i<end;++i)
+        m_indices.coeffRef(other.derived().nestedExpression().indices().coeff(i)) = i;
+    }
+    template<typename Lhs,typename Rhs>
+    PermutationMatrix(internal::PermPermProduct_t, const Lhs& lhs, const Rhs& rhs)
+      : m_indices(lhs.indices().size())
+    {
+      Base::assignProduct(lhs,rhs);
+    }
+#endif
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess>
+struct traits<Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess> >
+ : traits<Matrix<_StorageIndex,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  typedef PermutationStorage StorageKind;
+  typedef Map<const Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>, _PacketAccess> IndicesType;
+  typedef _StorageIndex StorageIndex;
+  typedef void Scalar;
+};
+}
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess>
+class Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess>
+  : public PermutationBase<Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess> >
+{
+    typedef PermutationBase<Map> Base;
+    typedef internal::traits<Map> Traits;
+  public:
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+    #endif
+
+    inline Map(const StorageIndex* indicesPtr)
+      : m_indices(indicesPtr)
+    {}
+
+    inline Map(const StorageIndex* indicesPtr, Index size)
+      : m_indices(indicesPtr,size)
+    {}
+
+    /** Copies the other permutation into *this */
+    template<typename Other>
+    Map& operator=(const PermutationBase<Other>& other)
+    { return Base::operator=(other.derived()); }
+
+    /** Assignment from the Transpositions \a tr */
+    template<typename Other>
+    Map& operator=(const TranspositionsBase<Other>& tr)
+    { return Base::operator=(tr.derived()); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    Map& operator=(const Map& other)
+    {
+      m_indices = other.m_indices;
+      return *this;
+    }
+    #endif
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return m_indices; }
+    /** \returns a reference to the stored array representing the permutation. */
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+template<typename _IndicesType> class TranspositionsWrapper;
+namespace internal {
+template<typename _IndicesType>
+struct traits<PermutationWrapper<_IndicesType> >
+{
+  typedef PermutationStorage StorageKind;
+  typedef void Scalar;
+  typedef typename _IndicesType::Scalar StorageIndex;
+  typedef _IndicesType IndicesType;
+  enum {
+    RowsAtCompileTime = _IndicesType::SizeAtCompileTime,
+    ColsAtCompileTime = _IndicesType::SizeAtCompileTime,
+    MaxRowsAtCompileTime = IndicesType::MaxSizeAtCompileTime,
+    MaxColsAtCompileTime = IndicesType::MaxSizeAtCompileTime,
+    Flags = 0
+  };
+};
+}
+
+/** \class PermutationWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Class to view a vector of integers as a permutation matrix
+  *
+  * \tparam _IndicesType the type of the vector of integer (can be any compatible expression)
+  *
+  * This class allows to view any vector expression of integers as a permutation matrix.
+  *
+  * \sa class PermutationBase, class PermutationMatrix
+  */
+template<typename _IndicesType>
+class PermutationWrapper : public PermutationBase<PermutationWrapper<_IndicesType> >
+{
+    typedef PermutationBase<PermutationWrapper> Base;
+    typedef internal::traits<PermutationWrapper> Traits;
+  public:
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    #endif
+
+    inline PermutationWrapper(const IndicesType& indices)
+      : m_indices(indices)
+    {}
+
+    /** const version of indices(). */
+    const typename internal::remove_all<typename IndicesType::Nested>::type&
+    indices() const { return m_indices; }
+
+  protected:
+
+    typename IndicesType::Nested m_indices;
+};
+
+
+/** \returns the matrix with the permutation applied to the columns.
+  */
+template<typename MatrixDerived, typename PermutationDerived>
+EIGEN_DEVICE_FUNC
+const Product<MatrixDerived, PermutationDerived, AliasFreeProduct>
+operator*(const MatrixBase<MatrixDerived> &matrix,
+          const PermutationBase<PermutationDerived>& permutation)
+{
+  return Product<MatrixDerived, PermutationDerived, AliasFreeProduct>
+            (matrix.derived(), permutation.derived());
+}
+
+/** \returns the matrix with the permutation applied to the rows.
+  */
+template<typename PermutationDerived, typename MatrixDerived>
+EIGEN_DEVICE_FUNC
+const Product<PermutationDerived, MatrixDerived, AliasFreeProduct>
+operator*(const PermutationBase<PermutationDerived> &permutation,
+          const MatrixBase<MatrixDerived>& matrix)
+{
+  return Product<PermutationDerived, MatrixDerived, AliasFreeProduct>
+            (permutation.derived(), matrix.derived());
+}
+
+
+template<typename PermutationType>
+class InverseImpl<PermutationType, PermutationStorage>
+  : public EigenBase<Inverse<PermutationType> >
+{
+    typedef typename PermutationType::PlainPermutationType PlainPermutationType;
+    typedef internal::traits<PermutationType> PermTraits;
+  protected:
+    InverseImpl() {}
+  public:
+    typedef Inverse<PermutationType> InverseType;
+    using EigenBase<Inverse<PermutationType> >::derived;
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename PermutationType::DenseMatrixType DenseMatrixType;
+    enum {
+      RowsAtCompileTime = PermTraits::RowsAtCompileTime,
+      ColsAtCompileTime = PermTraits::ColsAtCompileTime,
+      MaxRowsAtCompileTime = PermTraits::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = PermTraits::MaxColsAtCompileTime
+    };
+    #endif
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename DenseDerived>
+    void evalTo(MatrixBase<DenseDerived>& other) const
+    {
+      other.setZero();
+      for (Index i=0; i<derived().rows();++i)
+        other.coeffRef(i, derived().nestedExpression().indices().coeff(i)) = typename DenseDerived::Scalar(1);
+    }
+    #endif
+
+    /** \return the equivalent permutation matrix */
+    PlainPermutationType eval() const { return derived(); }
+
+    DenseMatrixType toDenseMatrix() const { return derived(); }
+
+    /** \returns the matrix with the inverse permutation applied to the columns.
+      */
+    template<typename OtherDerived> friend
+    const Product<OtherDerived, InverseType, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix, const InverseType& trPerm)
+    {
+      return Product<OtherDerived, InverseType, AliasFreeProduct>(matrix.derived(), trPerm.derived());
+    }
+
+    /** \returns the matrix with the inverse permutation applied to the rows.
+      */
+    template<typename OtherDerived>
+    const Product<InverseType, OtherDerived, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix) const
+    {
+      return Product<InverseType, OtherDerived, AliasFreeProduct>(derived(), matrix.derived());
+    }
+};
+
+template<typename Derived>
+const PermutationWrapper<const Derived> MatrixBase<Derived>::asPermutation() const
+{
+  return derived();
+}
+
+namespace internal {
+
+template<> struct AssignmentKind<DenseShape,PermutationShape> { typedef EigenBase2EigenBase Kind; };
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PERMUTATIONMATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/PlainObjectBase.h b/C++/yolo_bytetrack/include/Eigen/src/Core/PlainObjectBase.h
new file mode 100644
index 00000000..e2ddbd1d
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/PlainObjectBase.h
@@ -0,0 +1,1128 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DENSESTORAGEBASE_H
+#define EIGEN_DENSESTORAGEBASE_H
+
+#if defined(EIGEN_INITIALIZE_MATRICES_BY_ZERO)
+# define EIGEN_INITIALIZE_COEFFS
+# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(Index i=0;i<base().size();++i) coeffRef(i)=Scalar(0);
+#elif defined(EIGEN_INITIALIZE_MATRICES_BY_NAN)
+# define EIGEN_INITIALIZE_COEFFS
+# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(Index i=0;i<base().size();++i) coeffRef(i)=std::numeric_limits<Scalar>::quiet_NaN();
+#else
+# undef EIGEN_INITIALIZE_COEFFS
+# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+template<int MaxSizeAtCompileTime> struct check_rows_cols_for_overflow {
+  template<typename Index>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE void run(Index, Index)
+  {
+  }
+};
+
+template<> struct check_rows_cols_for_overflow<Dynamic> {
+  template<typename Index>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols)
+  {
+    // http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242
+    // we assume Index is signed
+    Index max_index = (std::size_t(1) << (8 * sizeof(Index) - 1)) - 1; // assume Index is signed
+    bool error = (rows == 0 || cols == 0) ? false
+               : (rows > max_index / cols);
+    if (error)
+      throw_std_bad_alloc();
+  }
+};
+
+template <typename Derived,
+          typename OtherDerived = Derived,
+          bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
+struct conservative_resize_like_impl;
+
+template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct matrix_swap_impl;
+
+} // end namespace internal
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+namespace doxygen {
+
+// This is a workaround to doxygen not being able to understand the inheritance logic
+// when it is hidden by the dense_xpr_base helper struct.
+// Moreover, doxygen fails to include members that are not documented in the declaration body of
+// MatrixBase if we inherits MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >,
+// this is why we simply inherits MatrixBase, though this does not make sense.
+
+/** This class is just a workaround for Doxygen and it does not not actually exist. */
+template<typename Derived> struct dense_xpr_base_dispatcher;
+/** This class is just a workaround for Doxygen and it does not not actually exist. */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct dense_xpr_base_dispatcher<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+    : public MatrixBase {};
+/** This class is just a workaround for Doxygen and it does not not actually exist. */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct dense_xpr_base_dispatcher<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+    : public ArrayBase {};
+
+} // namespace doxygen
+
+/** \class PlainObjectBase
+  * \ingroup Core_Module
+  * \brief %Dense storage base class for matrices and arrays.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_PLAINOBJECTBASE_PLUGIN.
+  *
+  * \tparam Derived is the derived type, e.g., a Matrix or Array
+  *
+  * \sa \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class PlainObjectBase : public doxygen::dense_xpr_base_dispatcher<Derived>
+#else
+template<typename Derived>
+class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
+#endif
+{
+  public:
+    enum { Options = internal::traits<Derived>::Options };
+    typedef typename internal::dense_xpr_base<Derived>::type Base;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Derived DenseType;
+
+    using Base::RowsAtCompileTime;
+    using Base::ColsAtCompileTime;
+    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+
+    typedef Eigen::Map<Derived, Unaligned>  MapType;
+    typedef const Eigen::Map<const Derived, Unaligned> ConstMapType;
+    typedef Eigen::Map<Derived, AlignedMax> AlignedMapType;
+    typedef const Eigen::Map<const Derived, AlignedMax> ConstAlignedMapType;
+    template<typename StrideType> struct StridedMapType { typedef Eigen::Map<Derived, Unaligned, StrideType> type; };
+    template<typename StrideType> struct StridedConstMapType { typedef Eigen::Map<const Derived, Unaligned, StrideType> type; };
+    template<typename StrideType> struct StridedAlignedMapType { typedef Eigen::Map<Derived, AlignedMax, StrideType> type; };
+    template<typename StrideType> struct StridedConstAlignedMapType { typedef Eigen::Map<const Derived, AlignedMax, StrideType> type; };
+
+  protected:
+    DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
+
+  public:
+    enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment>0) };
+    EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
+
+    EIGEN_DEVICE_FUNC
+    Base& base() { return *static_cast<Base*>(this); }
+    EIGEN_DEVICE_FUNC
+    const Base& base() const { return *static_cast<const Base*>(this); }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_storage.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_storage.cols(); }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index,Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
+    {
+      if(Flags & RowMajorBit)
+        return m_storage.data()[colId + rowId * m_storage.cols()];
+      else // column-major
+        return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
+    {
+      return m_storage.data()[index];
+    }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
+    {
+      if(Flags & RowMajorBit)
+        return m_storage.data()[colId + rowId * m_storage.cols()];
+      else // column-major
+        return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
+    {
+      return m_storage.data()[index];
+    }
+
+    /** This is the const version of coeffRef(Index,Index) which is thus synonym of coeff(Index,Index).
+      * It is provided for convenience. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      if(Flags & RowMajorBit)
+        return m_storage.data()[colId + rowId * m_storage.cols()];
+      else // column-major
+        return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
+
+    /** This is the const version of coeffRef(Index) which is thus synonym of coeff(Index).
+      * It is provided for convenience. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
+    {
+      return m_storage.data()[index];
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
+    {
+      return internal::ploadt<PacketScalar, LoadMode>
+               (m_storage.data() + (Flags & RowMajorBit
+                                   ? colId + rowId * m_storage.cols()
+                                   : rowId + colId * m_storage.rows()));
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
+    {
+      return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
+    }
+
+    /** \internal */
+    template<int StoreMode>
+    EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
+    {
+      internal::pstoret<Scalar, PacketScalar, StoreMode>
+              (m_storage.data() + (Flags & RowMajorBit
+                                   ? colId + rowId * m_storage.cols()
+                                   : rowId + colId * m_storage.rows()), val);
+    }
+
+    /** \internal */
+    template<int StoreMode>
+    EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
+    {
+      internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
+    }
+
+    /** \returns a const pointer to the data array of this matrix */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar *data() const
+    { return m_storage.data(); }
+
+    /** \returns a pointer to the data array of this matrix */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *data()
+    { return m_storage.data(); }
+
+    /** Resizes \c *this to a \a rows x \a cols matrix.
+      *
+      * This method is intended for dynamic-size matrices, although it is legal to call it on any
+      * matrix as long as fixed dimensions are left unchanged. If you only want to change the number
+      * of rows and/or of columns, you can use resize(NoChange_t, Index), resize(Index, NoChange_t).
+      *
+      * If the current number of coefficients of \c *this exactly matches the
+      * product \a rows * \a cols, then no memory allocation is performed and
+      * the current values are left unchanged. In all other cases, including
+      * shrinking, the data is reallocated and all previous values are lost.
+      *
+      * Example: \include Matrix_resize_int_int.cpp
+      * Output: \verbinclude Matrix_resize_int_int.out
+      *
+      * \sa resize(Index) for vectors, resize(NoChange_t, Index), resize(Index, NoChange_t)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
+    {
+      eigen_assert(   EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,rows==RowsAtCompileTime)
+                   && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,cols==ColsAtCompileTime)
+                   && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,rows<=MaxRowsAtCompileTime)
+                   && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,cols<=MaxColsAtCompileTime)
+                   && rows>=0 && cols>=0 && "Invalid sizes when resizing a matrix or array.");
+      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
+      #ifdef EIGEN_INITIALIZE_COEFFS
+        Index size = rows*cols;
+        bool size_changed = size != this->size();
+        m_storage.resize(size, rows, cols);
+        if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+      #else
+        m_storage.resize(rows*cols, rows, cols);
+      #endif
+    }
+
+    /** Resizes \c *this to a vector of length \a size
+      *
+      * \only_for_vectors. This method does not work for
+      * partially dynamic matrices when the static dimension is anything other
+      * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
+      *
+      * Example: \include Matrix_resize_int.cpp
+      * Output: \verbinclude Matrix_resize_int.out
+      *
+      * \sa resize(Index,Index), resize(NoChange_t, Index), resize(Index, NoChange_t)
+      */
+    EIGEN_DEVICE_FUNC
+    inline void resize(Index size)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
+      eigen_assert(((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime==Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
+      #ifdef EIGEN_INITIALIZE_COEFFS
+        bool size_changed = size != this->size();
+      #endif
+      if(RowsAtCompileTime == 1)
+        m_storage.resize(size, 1, size);
+      else
+        m_storage.resize(size, size, 1);
+      #ifdef EIGEN_INITIALIZE_COEFFS
+        if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+      #endif
+    }
+
+    /** Resizes the matrix, changing only the number of columns. For the parameter of type NoChange_t, just pass the special value \c NoChange
+      * as in the example below.
+      *
+      * Example: \include Matrix_resize_NoChange_int.cpp
+      * Output: \verbinclude Matrix_resize_NoChange_int.out
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC
+    inline void resize(NoChange_t, Index cols)
+    {
+      resize(rows(), cols);
+    }
+
+    /** Resizes the matrix, changing only the number of rows. For the parameter of type NoChange_t, just pass the special value \c NoChange
+      * as in the example below.
+      *
+      * Example: \include Matrix_resize_int_NoChange.cpp
+      * Output: \verbinclude Matrix_resize_int_NoChange.out
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC
+    inline void resize(Index rows, NoChange_t)
+    {
+      resize(rows, cols());
+    }
+
+    /** Resizes \c *this to have the same dimensions as \a other.
+      * Takes care of doing all the checking that's needed.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
+    {
+      const OtherDerived& other = _other.derived();
+      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
+      const Index othersize = other.rows()*other.cols();
+      if(RowsAtCompileTime == 1)
+      {
+        eigen_assert(other.rows() == 1 || other.cols() == 1);
+        resize(1, othersize);
+      }
+      else if(ColsAtCompileTime == 1)
+      {
+        eigen_assert(other.rows() == 1 || other.cols() == 1);
+        resize(othersize, 1);
+      }
+      else resize(other.rows(), other.cols());
+    }
+
+    /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
+      *
+      * The method is intended for matrices of dynamic size. If you only want to change the number
+      * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
+      * conservativeResize(Index, NoChange_t).
+      *
+      * Matrices are resized relative to the top-left element. In case values need to be
+      * appended to the matrix they will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols)
+    {
+      internal::conservative_resize_like_impl<Derived>::run(*this, rows, cols);
+    }
+
+    /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
+      *
+      * As opposed to conservativeResize(Index rows, Index cols), this version leaves
+      * the number of columns unchanged.
+      *
+      * In case the matrix is growing, new rows will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t)
+    {
+      // Note: see the comment in conservativeResize(Index,Index)
+      conservativeResize(rows, cols());
+    }
+
+    /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
+      *
+      * As opposed to conservativeResize(Index rows, Index cols), this version leaves
+      * the number of rows unchanged.
+      *
+      * In case the matrix is growing, new columns will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols)
+    {
+      // Note: see the comment in conservativeResize(Index,Index)
+      conservativeResize(rows(), cols);
+    }
+
+    /** Resizes the vector to \a size while retaining old values.
+      *
+      * \only_for_vectors. This method does not work for
+      * partially dynamic matrices when the static dimension is anything other
+      * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
+      *
+      * When values are appended, they will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(Index size)
+    {
+      internal::conservative_resize_like_impl<Derived>::run(*this, size);
+    }
+
+    /** Resizes the matrix to \a rows x \a cols of \c other, while leaving old values untouched.
+      *
+      * The method is intended for matrices of dynamic size. If you only want to change the number
+      * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
+      * conservativeResize(Index, NoChange_t).
+      *
+      * Matrices are resized relative to the top-left element. In case values need to be
+      * appended to the matrix they will copied from \c other.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
+    {
+      internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other);
+    }
+
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
+    {
+      return _set(other);
+    }
+
+    /** \sa MatrixBase::lazyAssign() */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
+    {
+      _resize_to_match(other);
+      return Base::lazyAssign(other.derived());
+    }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
+    {
+      resize(func.rows(), func.cols());
+      return Base::operator=(func);
+    }
+
+    // Prevent user from trying to instantiate PlainObjectBase objects
+    // by making all its constructor protected. See bug 1074.
+  protected:
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
+    {
+//       _check_template_params();
+//       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    // FIXME is it still needed ?
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
+      : m_storage(internal::constructor_without_unaligned_array_assert())
+    {
+//       _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+#endif
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
+      : m_storage( std::move(other.m_storage) )
+    {
+    }
+
+    EIGEN_DEVICE_FUNC
+    PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
+    {
+      _check_template_params();
+      m_storage = std::move(other.m_storage);
+      return *this;
+    }
+#endif
+
+    /** Copy constructor */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other)
+      : Base(), m_storage(other.m_storage) { }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
+      : m_storage(size, rows, cols)
+    {
+//       _check_template_params();
+//       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+    #if EIGEN_HAS_CXX11
+    /** \brief Construct a row of column vector with fixed size from an arbitrary number of coefficients. \cpp11
+      *
+      * \only_for_vectors
+      *
+      * This constructor is for 1D array or vectors with more than 4 coefficients.
+      * There exists C++98 analogue constructors for fixed-size array/vector having 1, 2, 3, or 4 coefficients.
+      *
+      * \warning To construct a column (resp. row) vector of fixed length, the number of values passed to this
+      * constructor must match the the fixed number of rows (resp. columns) of \c *this.
+      */
+    template <typename... ArgTypes>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    PlainObjectBase(const Scalar& a0, const Scalar& a1, const Scalar& a2,  const Scalar& a3, const ArgTypes&... args)
+      : m_storage()
+    {
+      _check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, sizeof...(args) + 4);
+      m_storage.data()[0] = a0;
+      m_storage.data()[1] = a1;
+      m_storage.data()[2] = a2;
+      m_storage.data()[3] = a3;
+      Index i = 4;
+      auto x = {(m_storage.data()[i++] = args, 0)...};
+      static_cast<void>(x);
+    }
+
+    /** \brief Constructs a Matrix or Array and initializes it by elements given by an initializer list of initializer
+      * lists \cpp11
+      */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<std::initializer_list<Scalar>>& list)
+      : m_storage()
+    {
+      _check_template_params();
+
+      size_t list_size = 0;
+      if (list.begin() != list.end()) {
+        list_size = list.begin()->size();
+      }
+
+      // This is to allow syntax like VectorXi {{1, 2, 3, 4}}
+      if (ColsAtCompileTime == 1 && list.size() == 1) {
+        eigen_assert(list_size == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
+        resize(list_size, ColsAtCompileTime);
+        std::copy(list.begin()->begin(), list.begin()->end(), m_storage.data());
+      } else {
+        eigen_assert(list.size() == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
+        eigen_assert(list_size == static_cast<size_t>(ColsAtCompileTime) || ColsAtCompileTime == Dynamic);
+        resize(list.size(), list_size);
+
+        Index row_index = 0;
+        for (const std::initializer_list<Scalar>& row : list) {
+          eigen_assert(list_size == row.size());
+          Index col_index = 0;
+          for (const Scalar& e : row) {
+            coeffRef(row_index, col_index) = e;
+            ++col_index;
+          }
+          ++row_index;
+        }
+      }
+    }
+    #endif  // end EIGEN_HAS_CXX11
+
+    /** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
+      : m_storage()
+    {
+      _check_template_params();
+      resizeLike(other);
+      _set_noalias(other);
+    }
+
+    /** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
+      : m_storage()
+    {
+      _check_template_params();
+      resizeLike(other);
+      *this = other.derived();
+    }
+    /** \brief Copy constructor with in-place evaluation */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& other)
+    {
+      _check_template_params();
+      // FIXME this does not automatically transpose vectors if necessary
+      resize(other.rows(), other.cols());
+      other.evalTo(this->derived());
+    }
+
+  public:
+
+    /** \brief Copies the generic expression \a other into *this.
+      * \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other)
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
+    {
+      _resize_to_match(other);
+      Base::operator=(other.derived());
+      return this->derived();
+    }
+
+    /** \name Map
+      * These are convenience functions returning Map objects. The Map() static functions return unaligned Map objects,
+      * while the AlignedMap() functions return aligned Map objects and thus should be called only with 16-byte-aligned
+      * \a data pointers.
+      *
+      * Here is an example using strides:
+      * \include Matrix_Map_stride.cpp
+      * Output: \verbinclude Matrix_Map_stride.out
+      *
+      * \see class Map
+      */
+    //@{
+    static inline ConstMapType Map(const Scalar* data)
+    { return ConstMapType(data); }
+    static inline MapType Map(Scalar* data)
+    { return MapType(data); }
+    static inline ConstMapType Map(const Scalar* data, Index size)
+    { return ConstMapType(data, size); }
+    static inline MapType Map(Scalar* data, Index size)
+    { return MapType(data, size); }
+    static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
+    { return ConstMapType(data, rows, cols); }
+    static inline MapType Map(Scalar* data, Index rows, Index cols)
+    { return MapType(data, rows, cols); }
+
+    static inline ConstAlignedMapType MapAligned(const Scalar* data)
+    { return ConstAlignedMapType(data); }
+    static inline AlignedMapType MapAligned(Scalar* data)
+    { return AlignedMapType(data); }
+    static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
+    { return ConstAlignedMapType(data, size); }
+    static inline AlignedMapType MapAligned(Scalar* data, Index size)
+    { return AlignedMapType(data, size); }
+    static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
+    { return ConstAlignedMapType(data, rows, cols); }
+    static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
+    { return AlignedMapType(data, rows, cols); }
+
+    template<int Outer, int Inner>
+    static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+
+    template<int Outer, int Inner>
+    static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+    //@}
+
+    using Base::setConstant;
+    EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val);
+    EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val);
+    EIGEN_DEVICE_FUNC Derived& setConstant(NoChange_t, Index cols, const Scalar& val);
+    EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, NoChange_t, const Scalar& val);
+
+    using Base::setZero;
+    EIGEN_DEVICE_FUNC Derived& setZero(Index size);
+    EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setZero(NoChange_t, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setZero(Index rows, NoChange_t);
+
+    using Base::setOnes;
+    EIGEN_DEVICE_FUNC Derived& setOnes(Index size);
+    EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setOnes(NoChange_t, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, NoChange_t);
+
+    using Base::setRandom;
+    Derived& setRandom(Index size);
+    Derived& setRandom(Index rows, Index cols);
+    Derived& setRandom(NoChange_t, Index cols);
+    Derived& setRandom(Index rows, NoChange_t);
+
+    #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
+    #include EIGEN_PLAINOBJECTBASE_PLUGIN
+    #endif
+
+  protected:
+    /** \internal Resizes *this in preparation for assigning \a other to it.
+      * Takes care of doing all the checking that's needed.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
+    {
+      #ifdef EIGEN_NO_AUTOMATIC_RESIZING
+      eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
+                 : (rows() == other.rows() && cols() == other.cols())))
+        && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
+      EIGEN_ONLY_USED_FOR_DEBUG(other);
+      #else
+      resizeLike(other);
+      #endif
+    }
+
+    /**
+      * \brief Copies the value of the expression \a other into \c *this with automatic resizing.
+      *
+      * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
+      * it will be initialized.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      *
+      * \sa operator=(const MatrixBase<OtherDerived>&), _set_noalias()
+      *
+      * \internal
+      */
+    // aliasing is dealt once in internal::call_assignment
+    // so at this stage we have to assume aliasing... and resising has to be done later.
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
+    {
+      internal::call_assignment(this->derived(), other.derived());
+      return this->derived();
+    }
+
+    /** \internal Like _set() but additionally makes the assumption that no aliasing effect can happen (which
+      * is the case when creating a new matrix) so one can enforce lazy evaluation.
+      *
+      * \sa operator=(const MatrixBase<OtherDerived>&), _set()
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
+    {
+      // I don't think we need this resize call since the lazyAssign will anyways resize
+      // and lazyAssign will be called by the assign selector.
+      //_resize_to_match(other);
+      // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
+      // it wouldn't allow to copy a row-vector into a column-vector.
+      internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+      return this->derived();
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
+    {
+      const bool t0_is_integer_alike = internal::is_valid_index_type<T0>::value;
+      const bool t1_is_integer_alike = internal::is_valid_index_type<T1>::value;
+      EIGEN_STATIC_ASSERT(t0_is_integer_alike &&
+                          t1_is_integer_alike,
+                          FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
+      resize(rows,cols);
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
+      m_storage.data()[0] = Scalar(val0);
+      m_storage.data()[1] = Scalar(val1);
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1,
+                                    typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
+                                                                  && (internal::is_same<T0,Index>::value)
+                                                                  && (internal::is_same<T1,Index>::value)
+                                                                  && Base::SizeAtCompileTime==2,T1>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
+      m_storage.data()[0] = Scalar(val0);
+      m_storage.data()[1] = Scalar(val1);
+    }
+
+    // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
+    // then the argument is meant to be the size of the object.
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(Index size, typename internal::enable_if<    (Base::SizeAtCompileTime!=1 || !internal::is_convertible<T, Scalar>::value)
+                                                                              && ((!internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value || Base::SizeAtCompileTime==Dynamic)),T>::type* = 0)
+    {
+      // NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT argument.
+      const bool is_integer_alike = internal::is_valid_index_type<T>::value;
+      EIGEN_UNUSED_VARIABLE(is_integer_alike);
+      EIGEN_STATIC_ASSERT(is_integer_alike,
+                          FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
+      resize(size);
+    }
+
+    // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type can be implicitly converted)
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Scalar& val0, typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
+      m_storage.data()[0] = val0;
+    }
+
+    // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type match the index type)
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Index& val0,
+                                    typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
+                                                                  && (internal::is_same<Index,T>::value)
+                                                                  && Base::SizeAtCompileTime==1
+                                                                  && internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
+      m_storage.data()[0] = Scalar(val0);
+    }
+
+    // Initialize a fixed size matrix from a pointer to raw data
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Scalar* data){
+      this->_set_noalias(ConstMapType(data));
+    }
+
+    // Initialize an arbitrary matrix from a dense expression
+    template<typename T, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const DenseBase<OtherDerived>& other){
+      this->_set_noalias(other);
+    }
+
+    // Initialize an arbitrary matrix from an object convertible to the Derived type.
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Derived& other){
+      this->_set_noalias(other);
+    }
+
+    // Initialize an arbitrary matrix from a generic Eigen expression
+    template<typename T, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const EigenBase<OtherDerived>& other){
+      this->derived() = other;
+    }
+
+    template<typename T, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const ReturnByValue<OtherDerived>& other)
+    {
+      resize(other.rows(), other.cols());
+      other.evalTo(this->derived());
+    }
+
+    template<typename T, typename OtherDerived, int ColsAtCompileTime>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
+    {
+      this->derived() = r;
+    }
+
+    // For fixed-size Array<Scalar,...>
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Scalar& val0,
+                                    typename internal::enable_if<    Base::SizeAtCompileTime!=Dynamic
+                                                                  && Base::SizeAtCompileTime!=1
+                                                                  && internal::is_convertible<T, Scalar>::value
+                                                                  && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T>::type* = 0)
+    {
+      Base::setConstant(val0);
+    }
+
+    // For fixed-size Array<Index,...>
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Index& val0,
+                                    typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
+                                                                  && (internal::is_same<Index,T>::value)
+                                                                  && Base::SizeAtCompileTime!=Dynamic
+                                                                  && Base::SizeAtCompileTime!=1
+                                                                  && internal::is_convertible<T, Scalar>::value
+                                                                  && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T*>::type* = 0)
+    {
+      Base::setConstant(val0);
+    }
+
+    template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
+    friend struct internal::matrix_swap_impl;
+
+  public:
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal
+      * \brief Override DenseBase::swap() since for dynamic-sized matrices
+      * of same type it is enough to swap the data pointers.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void swap(DenseBase<OtherDerived> & other)
+    {
+      enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==Dynamic };
+      internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.derived());
+    }
+
+    /** \internal
+      * \brief const version forwarded to DenseBase::swap
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void swap(DenseBase<OtherDerived> const & other)
+    { Base::swap(other.derived()); }
+
+    EIGEN_DEVICE_FUNC
+    static EIGEN_STRONG_INLINE void _check_template_params()
+    {
+      EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (int(Options)&RowMajor)==RowMajor)
+                        && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (int(Options)&RowMajor)==0)
+                        && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0))
+                        && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0))
+                        && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0))
+                        && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0))
+                        && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
+                        && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
+                        && (Options & (DontAlign|RowMajor)) == Options),
+        INVALID_MATRIX_TEMPLATE_PARAMETERS)
+    }
+
+    enum { IsPlainObjectBase = 1 };
+#endif
+  public:
+    // These apparently need to be down here for nvcc+icc to prevent duplicate
+    // Map symbol.
+    template<typename PlainObjectType, int MapOptions, typename StrideType> friend class Eigen::Map;
+    friend class Eigen::Map<Derived, Unaligned>;
+    friend class Eigen::Map<const Derived, Unaligned>;
+#if EIGEN_MAX_ALIGN_BYTES>0
+    // for EIGEN_MAX_ALIGN_BYTES==0, AlignedMax==Unaligned, and many compilers generate warnings for friend-ing a class twice.
+    friend class Eigen::Map<Derived, AlignedMax>;
+    friend class Eigen::Map<const Derived, AlignedMax>;
+#endif
+};
+
+namespace internal {
+
+template <typename Derived, typename OtherDerived, bool IsVector>
+struct conservative_resize_like_impl
+{
+  #if EIGEN_HAS_TYPE_TRAITS
+  static const bool IsRelocatable = std::is_trivially_copyable<typename Derived::Scalar>::value;
+  #else
+  static const bool IsRelocatable = !NumTraits<typename Derived::Scalar>::RequireInitialization;
+  #endif
+  static void run(DenseBase<Derived>& _this, Index rows, Index cols)
+  {
+    if (_this.rows() == rows && _this.cols() == cols) return;
+    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
+
+    if ( IsRelocatable
+          && (( Derived::IsRowMajor && _this.cols() == cols) ||  // row-major and we change only the number of rows
+              (!Derived::IsRowMajor && _this.rows() == rows) ))  // column-major and we change only the number of columns
+    {
+      internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
+      _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
+    }
+    else
+    {
+      // The storage order does not allow us to use reallocation.
+      Derived tmp(rows,cols);
+      const Index common_rows = numext::mini(rows, _this.rows());
+      const Index common_cols = numext::mini(cols, _this.cols());
+      tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
+      _this.derived().swap(tmp);
+    }
+  }
+
+  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
+  {
+    if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
+
+    // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
+    // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
+    // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
+    // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
+    // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
+    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
+    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
+
+    if ( IsRelocatable &&
+          (( Derived::IsRowMajor && _this.cols() == other.cols()) ||  // row-major and we change only the number of rows
+           (!Derived::IsRowMajor && _this.rows() == other.rows()) ))  // column-major and we change only the number of columns
+    {
+      const Index new_rows = other.rows() - _this.rows();
+      const Index new_cols = other.cols() - _this.cols();
+      _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols());
+      if (new_rows>0)
+        _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
+      else if (new_cols>0)
+        _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
+    }
+    else
+    {
+      // The storage order does not allow us to use reallocation.
+      Derived tmp(other);
+      const Index common_rows = numext::mini(tmp.rows(), _this.rows());
+      const Index common_cols = numext::mini(tmp.cols(), _this.cols());
+      tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
+      _this.derived().swap(tmp);
+    }
+  }
+};
+
+// Here, the specialization for vectors inherits from the general matrix case
+// to allow calling .conservativeResize(rows,cols) on vectors.
+template <typename Derived, typename OtherDerived>
+struct conservative_resize_like_impl<Derived,OtherDerived,true>
+  : conservative_resize_like_impl<Derived,OtherDerived,false>
+{
+  typedef conservative_resize_like_impl<Derived,OtherDerived,false> Base;
+  using Base::run;
+  using Base::IsRelocatable;
+
+  static void run(DenseBase<Derived>& _this, Index size)
+  {
+    const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
+    const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
+    if(IsRelocatable)
+      _this.derived().m_storage.conservativeResize(size,new_rows,new_cols);
+    else
+      Base::run(_this.derived(), new_rows, new_cols);
+  }
+
+  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
+  {
+    if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
+
+    const Index num_new_elements = other.size() - _this.size();
+
+    const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
+    const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
+    if(IsRelocatable)
+      _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);
+    else
+      Base::run(_this.derived(), new_rows, new_cols);
+
+    if (num_new_elements > 0)
+      _this.tail(num_new_elements) = other.tail(num_new_elements);
+  }
+};
+
+template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
+struct matrix_swap_impl
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(MatrixTypeA& a, MatrixTypeB& b)
+  {
+    a.base().swap(b);
+  }
+};
+
+template<typename MatrixTypeA, typename MatrixTypeB>
+struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
+  {
+    static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_DENSESTORAGEBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Product.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Product.h
new file mode 100644
index 00000000..70a6c106
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Product.h
@@ -0,0 +1,191 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PRODUCT_H
+#define EIGEN_PRODUCT_H
+
+namespace Eigen {
+
+template<typename Lhs, typename Rhs, int Option, typename StorageKind> class ProductImpl;
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Option>
+struct traits<Product<Lhs, Rhs, Option> >
+{
+  typedef typename remove_all<Lhs>::type LhsCleaned;
+  typedef typename remove_all<Rhs>::type RhsCleaned;
+  typedef traits<LhsCleaned> LhsTraits;
+  typedef traits<RhsCleaned> RhsTraits;
+
+  typedef MatrixXpr XprKind;
+
+  typedef typename ScalarBinaryOpTraits<typename traits<LhsCleaned>::Scalar, typename traits<RhsCleaned>::Scalar>::ReturnType Scalar;
+  typedef typename product_promote_storage_type<typename LhsTraits::StorageKind,
+                                                typename RhsTraits::StorageKind,
+                                                internal::product_type<Lhs,Rhs>::ret>::ret StorageKind;
+  typedef typename promote_index_type<typename LhsTraits::StorageIndex,
+                                      typename RhsTraits::StorageIndex>::type StorageIndex;
+
+  enum {
+    RowsAtCompileTime    = LhsTraits::RowsAtCompileTime,
+    ColsAtCompileTime    = RhsTraits::ColsAtCompileTime,
+    MaxRowsAtCompileTime = LhsTraits::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = RhsTraits::MaxColsAtCompileTime,
+
+    // FIXME: only needed by GeneralMatrixMatrixTriangular
+    InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(LhsTraits::ColsAtCompileTime, RhsTraits::RowsAtCompileTime),
+
+    // The storage order is somewhat arbitrary here. The correct one will be determined through the evaluator.
+    Flags = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? RowMajorBit
+          : (MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1) ? 0
+          : (   ((LhsTraits::Flags&NoPreferredStorageOrderBit) && (RhsTraits::Flags&RowMajorBit))
+             || ((RhsTraits::Flags&NoPreferredStorageOrderBit) && (LhsTraits::Flags&RowMajorBit)) ) ? RowMajorBit
+          : NoPreferredStorageOrderBit
+  };
+};
+
+} // end namespace internal
+
+/** \class Product
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the product of two arbitrary matrices or vectors
+  *
+  * \tparam _Lhs the type of the left-hand side expression
+  * \tparam _Rhs the type of the right-hand side expression
+  *
+  * This class represents an expression of the product of two arbitrary matrices.
+  *
+  * The other template parameters are:
+  * \tparam Option     can be DefaultProduct, AliasFreeProduct, or LazyProduct
+  *
+  */
+template<typename _Lhs, typename _Rhs, int Option>
+class Product : public ProductImpl<_Lhs,_Rhs,Option,
+                                   typename internal::product_promote_storage_type<typename internal::traits<_Lhs>::StorageKind,
+                                                                                   typename internal::traits<_Rhs>::StorageKind,
+                                                                                   internal::product_type<_Lhs,_Rhs>::ret>::ret>
+{
+  public:
+
+    typedef _Lhs Lhs;
+    typedef _Rhs Rhs;
+
+    typedef typename ProductImpl<
+        Lhs, Rhs, Option,
+        typename internal::product_promote_storage_type<typename internal::traits<Lhs>::StorageKind,
+                                                        typename internal::traits<Rhs>::StorageKind,
+                                                        internal::product_type<Lhs,Rhs>::ret>::ret>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Product)
+
+    typedef typename internal::ref_selector<Lhs>::type LhsNested;
+    typedef typename internal::ref_selector<Rhs>::type RhsNested;
+    typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
+    typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Product(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), m_rhs(rhs)
+    {
+      eigen_assert(lhs.cols() == rhs.rows()
+        && "invalid matrix product"
+        && "if you wanted a coeff-wise or a dot product use the respective explicit functions");
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_lhs.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const LhsNestedCleaned& lhs() const { return m_lhs; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const RhsNestedCleaned& rhs() const { return m_rhs; }
+
+  protected:
+
+    LhsNested m_lhs;
+    RhsNested m_rhs;
+};
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Option, int ProductTag = internal::product_type<Lhs,Rhs>::ret>
+class dense_product_base
+ : public internal::dense_xpr_base<Product<Lhs,Rhs,Option> >::type
+{};
+
+/** Conversion to scalar for inner-products */
+template<typename Lhs, typename Rhs, int Option>
+class dense_product_base<Lhs, Rhs, Option, InnerProduct>
+ : public internal::dense_xpr_base<Product<Lhs,Rhs,Option> >::type
+{
+  typedef Product<Lhs,Rhs,Option> ProductXpr;
+  typedef typename internal::dense_xpr_base<ProductXpr>::type Base;
+public:
+  using Base::derived;
+  typedef typename Base::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE operator const Scalar() const
+  {
+    return internal::evaluator<ProductXpr>(derived()).coeff(0,0);
+  }
+};
+
+} // namespace internal
+
+// Generic API dispatcher
+template<typename Lhs, typename Rhs, int Option, typename StorageKind>
+class ProductImpl : public internal::generic_xpr_base<Product<Lhs,Rhs,Option>, MatrixXpr, StorageKind>::type
+{
+  public:
+    typedef typename internal::generic_xpr_base<Product<Lhs,Rhs,Option>, MatrixXpr, StorageKind>::type Base;
+};
+
+template<typename Lhs, typename Rhs, int Option>
+class ProductImpl<Lhs,Rhs,Option,Dense>
+  : public internal::dense_product_base<Lhs,Rhs,Option>
+{
+    typedef Product<Lhs, Rhs, Option> Derived;
+
+  public:
+
+    typedef typename internal::dense_product_base<Lhs, Rhs, Option> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
+  protected:
+    enum {
+      IsOneByOne = (RowsAtCompileTime == 1 || RowsAtCompileTime == Dynamic) &&
+                   (ColsAtCompileTime == 1 || ColsAtCompileTime == Dynamic),
+      EnableCoeff = IsOneByOne || Option==LazyProduct
+    };
+
+  public:
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(Index row, Index col) const
+    {
+      EIGEN_STATIC_ASSERT(EnableCoeff, THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS);
+      eigen_assert( (Option==LazyProduct) || (this->rows() == 1 && this->cols() == 1) );
+
+      return internal::evaluator<Derived>(derived()).coeff(row,col);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(Index i) const
+    {
+      EIGEN_STATIC_ASSERT(EnableCoeff, THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS);
+      eigen_assert( (Option==LazyProduct) || (this->rows() == 1 && this->cols() == 1) );
+
+      return internal::evaluator<Derived>(derived()).coeff(i);
+    }
+
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_PRODUCT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/ProductEvaluators.h b/C++/yolo_bytetrack/include/Eigen/src/Core/ProductEvaluators.h
new file mode 100644
index 00000000..8cf294b2
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/ProductEvaluators.h
@@ -0,0 +1,1179 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2011 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_PRODUCTEVALUATORS_H
+#define EIGEN_PRODUCTEVALUATORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+  * Evaluator of a product expression.
+  * Since products require special treatments to handle all possible cases,
+  * we simply defer the evaluation logic to a product_evaluator class
+  * which offers more partial specialization possibilities.
+  *
+  * \sa class product_evaluator
+  */
+template<typename Lhs, typename Rhs, int Options>
+struct evaluator<Product<Lhs, Rhs, Options> >
+ : public product_evaluator<Product<Lhs, Rhs, Options> >
+{
+  typedef Product<Lhs, Rhs, Options> XprType;
+  typedef product_evaluator<XprType> Base;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// Catch "scalar * ( A * B )" and transform it to "(A*scalar) * B"
+// TODO we should apply that rule only if that's really helpful
+template<typename Lhs, typename Rhs, typename Scalar1, typename Scalar2, typename Plain1>
+struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_product_op<Scalar1,Scalar2>,
+                                               const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                                               const Product<Lhs, Rhs, DefaultProduct> > >
+{
+  static const bool value = true;
+};
+template<typename Lhs, typename Rhs, typename Scalar1, typename Scalar2, typename Plain1>
+struct evaluator<CwiseBinaryOp<internal::scalar_product_op<Scalar1,Scalar2>,
+                               const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                               const Product<Lhs, Rhs, DefaultProduct> > >
+ : public evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1,Lhs,product), Rhs, DefaultProduct> >
+{
+  typedef CwiseBinaryOp<internal::scalar_product_op<Scalar1,Scalar2>,
+                               const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                               const Product<Lhs, Rhs, DefaultProduct> > XprType;
+  typedef evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1,Lhs,product), Rhs, DefaultProduct> > Base;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr)
+    : Base(xpr.lhs().functor().m_other * xpr.rhs().lhs() * xpr.rhs().rhs())
+  {}
+};
+
+
+template<typename Lhs, typename Rhs, int DiagIndex>
+struct evaluator<Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex> >
+ : public evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex> >
+{
+  typedef Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex> XprType;
+  typedef evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex> > Base;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr)
+    : Base(Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex>(
+        Product<Lhs, Rhs, LazyProduct>(xpr.nestedExpression().lhs(), xpr.nestedExpression().rhs()),
+        xpr.index() ))
+  {}
+};
+
+
+// Helper class to perform a matrix product with the destination at hand.
+// Depending on the sizes of the factors, there are different evaluation strategies
+// as controlled by internal::product_type.
+template< typename Lhs, typename Rhs,
+          typename LhsShape = typename evaluator_traits<Lhs>::Shape,
+          typename RhsShape = typename evaluator_traits<Rhs>::Shape,
+          int ProductType = internal::product_type<Lhs,Rhs>::value>
+struct generic_product_impl;
+
+template<typename Lhs, typename Rhs>
+struct evaluator_assume_aliasing<Product<Lhs, Rhs, DefaultProduct> > {
+  static const bool value = true;
+};
+
+// This is the default evaluator implementation for products:
+// It creates a temporary and call generic_product_impl
+template<typename Lhs, typename Rhs, int Options, int ProductTag, typename LhsShape, typename RhsShape>
+struct product_evaluator<Product<Lhs, Rhs, Options>, ProductTag, LhsShape, RhsShape>
+  : public evaluator<typename Product<Lhs, Rhs, Options>::PlainObject>
+{
+  typedef Product<Lhs, Rhs, Options> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit product_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+
+// FIXME shall we handle nested_eval here?,
+// if so, then we must take care at removing the call to nested_eval in the specializations (e.g., in permutation_matrix_product, transposition_matrix_product, etc.)
+//     typedef typename internal::nested_eval<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
+//     typedef typename internal::nested_eval<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
+//     typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
+//     typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
+//
+//     const LhsNested lhs(xpr.lhs());
+//     const RhsNested rhs(xpr.rhs());
+//
+//     generic_product_impl<LhsNestedCleaned, RhsNestedCleaned>::evalTo(m_result, lhs, rhs);
+
+    generic_product_impl<Lhs, Rhs, LhsShape, RhsShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+// The following three shortcuts are enabled only if the scalar types match exactly.
+// TODO: we could enable them for different scalar types when the product is not vectorized.
+
+// Dense = Product
+template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::assign_op<Scalar,Scalar>, Dense2Dense,
+  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type>
+{
+  typedef Product<Lhs,Rhs,Options> SrcXprType;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    // FIXME shall we handle nested_eval here?
+    generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());
+  }
+};
+
+// Dense += Product
+template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::add_assign_op<Scalar,Scalar>, Dense2Dense,
+  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type>
+{
+  typedef Product<Lhs,Rhs,Options> SrcXprType;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar,Scalar> &)
+  {
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    // FIXME shall we handle nested_eval here?
+    generic_product_impl<Lhs, Rhs>::addTo(dst, src.lhs(), src.rhs());
+  }
+};
+
+// Dense -= Product
+template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::sub_assign_op<Scalar,Scalar>, Dense2Dense,
+  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type>
+{
+  typedef Product<Lhs,Rhs,Options> SrcXprType;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar,Scalar> &)
+  {
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    // FIXME shall we handle nested_eval here?
+    generic_product_impl<Lhs, Rhs>::subTo(dst, src.lhs(), src.rhs());
+  }
+};
+
+
+// Dense ?= scalar * Product
+// TODO we should apply that rule if that's really helpful
+// for instance, this is not good for inner products
+template< typename DstXprType, typename Lhs, typename Rhs, typename AssignFunc, typename Scalar, typename ScalarBis, typename Plain>
+struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_product_op<ScalarBis,Scalar>, const CwiseNullaryOp<internal::scalar_constant_op<ScalarBis>,Plain>,
+                                           const Product<Lhs,Rhs,DefaultProduct> >, AssignFunc, Dense2Dense>
+{
+  typedef CwiseBinaryOp<internal::scalar_product_op<ScalarBis,Scalar>,
+                        const CwiseNullaryOp<internal::scalar_constant_op<ScalarBis>,Plain>,
+                        const Product<Lhs,Rhs,DefaultProduct> > SrcXprType;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const AssignFunc& func)
+  {
+    call_assignment_no_alias(dst, (src.lhs().functor().m_other * src.rhs().lhs())*src.rhs().rhs(), func);
+  }
+};
+
+//----------------------------------------
+// Catch "Dense ?= xpr + Product<>" expression to save one temporary
+// FIXME we could probably enable these rules for any product, i.e., not only Dense and DefaultProduct
+
+template<typename OtherXpr, typename Lhs, typename Rhs>
+struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_sum_op<typename OtherXpr::Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, const OtherXpr,
+                                               const Product<Lhs,Rhs,DefaultProduct> >, DenseShape > {
+  static const bool value = true;
+};
+
+template<typename OtherXpr, typename Lhs, typename Rhs>
+struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_difference_op<typename OtherXpr::Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, const OtherXpr,
+                                               const Product<Lhs,Rhs,DefaultProduct> >, DenseShape > {
+  static const bool value = true;
+};
+
+template<typename DstXprType, typename OtherXpr, typename ProductType, typename Func1, typename Func2>
+struct assignment_from_xpr_op_product
+{
+  template<typename SrcXprType, typename InitialFunc>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const InitialFunc& /*func*/)
+  {
+    call_assignment_no_alias(dst, src.lhs(), Func1());
+    call_assignment_no_alias(dst, src.rhs(), Func2());
+  }
+};
+
+#define EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(ASSIGN_OP,BINOP,ASSIGN_OP2) \
+  template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename DstScalar, typename SrcScalar, typename OtherScalar,typename ProdScalar> \
+  struct Assignment<DstXprType, CwiseBinaryOp<internal::BINOP<OtherScalar,ProdScalar>, const OtherXpr, \
+                                            const Product<Lhs,Rhs,DefaultProduct> >, internal::ASSIGN_OP<DstScalar,SrcScalar>, Dense2Dense> \
+    : assignment_from_xpr_op_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, internal::ASSIGN_OP<DstScalar,OtherScalar>, internal::ASSIGN_OP2<DstScalar,ProdScalar> > \
+  {}
+
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(assign_op,    scalar_sum_op,add_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(add_assign_op,scalar_sum_op,add_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(sub_assign_op,scalar_sum_op,sub_assign_op);
+
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(assign_op,    scalar_difference_op,sub_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(add_assign_op,scalar_difference_op,sub_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(sub_assign_op,scalar_difference_op,add_assign_op);
+
+//----------------------------------------
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,InnerProduct>
+{
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    dst.coeffRef(0,0) = (lhs.transpose().cwiseProduct(rhs)).sum();
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    dst.coeffRef(0,0) += (lhs.transpose().cwiseProduct(rhs)).sum();
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { dst.coeffRef(0,0) -= (lhs.transpose().cwiseProduct(rhs)).sum(); }
+};
+
+
+/***********************************************************************
+*  Implementation of outer dense * dense vector product
+***********************************************************************/
+
+// Column major result
+template<typename Dst, typename Lhs, typename Rhs, typename Func>
+void EIGEN_DEVICE_FUNC outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const false_type&)
+{
+  evaluator<Rhs> rhsEval(rhs);
+  ei_declare_local_nested_eval(Lhs,lhs,Rhs::SizeAtCompileTime,actual_lhs);
+  // FIXME if cols is large enough, then it might be useful to make sure that lhs is sequentially stored
+  // FIXME not very good if rhs is real and lhs complex while alpha is real too
+  const Index cols = dst.cols();
+  for (Index j=0; j<cols; ++j)
+    func(dst.col(j), rhsEval.coeff(Index(0),j) * actual_lhs);
+}
+
+// Row major result
+template<typename Dst, typename Lhs, typename Rhs, typename Func>
+void EIGEN_DEVICE_FUNC outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const true_type&)
+{
+  evaluator<Lhs> lhsEval(lhs);
+  ei_declare_local_nested_eval(Rhs,rhs,Lhs::SizeAtCompileTime,actual_rhs);
+  // FIXME if rows is large enough, then it might be useful to make sure that rhs is sequentially stored
+  // FIXME not very good if lhs is real and rhs complex while alpha is real too
+  const Index rows = dst.rows();
+  for (Index i=0; i<rows; ++i)
+    func(dst.row(i), lhsEval.coeff(i,Index(0)) * actual_rhs);
+}
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,OuterProduct>
+{
+  template<typename T> struct is_row_major : internal::conditional<(int(T::Flags)&RowMajorBit), internal::true_type, internal::false_type>::type {};
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  // TODO it would be nice to be able to exploit our *_assign_op functors for that purpose
+  struct set  { template<typename Dst, typename Src> EIGEN_DEVICE_FUNC void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived()  = src; } };
+  struct add  { template<typename Dst, typename Src> EIGEN_DEVICE_FUNC void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() += src; } };
+  struct sub  { template<typename Dst, typename Src> EIGEN_DEVICE_FUNC void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() -= src; } };
+  struct adds {
+    Scalar m_scale;
+    explicit adds(const Scalar& s) : m_scale(s) {}
+    template<typename Dst, typename Src> void EIGEN_DEVICE_FUNC operator()(const Dst& dst, const Src& src) const {
+      dst.const_cast_derived() += m_scale * src;
+    }
+  };
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, set(), is_row_major<Dst>());
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, add(), is_row_major<Dst>());
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, sub(), is_row_major<Dst>());
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, adds(alpha), is_row_major<Dst>());
+  }
+
+};
+
+
+// This base class provides default implementations for evalTo, addTo, subTo, in terms of scaleAndAddTo
+template<typename Lhs, typename Rhs, typename Derived>
+struct generic_product_impl_base
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { dst.setZero(); scaleAndAddTo(dst, lhs, rhs, Scalar(1)); }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { scaleAndAddTo(dst,lhs, rhs, Scalar(1)); }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { scaleAndAddTo(dst, lhs, rhs, Scalar(-1)); }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  { Derived::scaleAndAddTo(dst,lhs,rhs,alpha); }
+
+};
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemvProduct>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemvProduct> >
+{
+  typedef typename nested_eval<Lhs,1>::type LhsNested;
+  typedef typename nested_eval<Rhs,1>::type RhsNested;
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  enum { Side = Lhs::IsVectorAtCompileTime ? OnTheLeft : OnTheRight };
+  typedef typename internal::remove_all<typename internal::conditional<int(Side)==OnTheRight,LhsNested,RhsNested>::type>::type MatrixType;
+
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    // Fallback to inner product if both the lhs and rhs is a runtime vector.
+    if (lhs.rows() == 1 && rhs.cols() == 1) {
+      dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rhs.col(0));
+      return;
+    }
+    LhsNested actual_lhs(lhs);
+    RhsNested actual_rhs(rhs);
+    internal::gemv_dense_selector<Side,
+                            (int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor,
+                            bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)
+                           >::run(actual_lhs, actual_rhs, dst, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,CoeffBasedProductMode>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // Same as: dst.noalias() = lhs.lazyProduct(rhs);
+    // but easier on the compiler side
+    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::assign_op<typename Dst::Scalar,Scalar>());
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // dst.noalias() += lhs.lazyProduct(rhs);
+    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::add_assign_op<typename Dst::Scalar,Scalar>());
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // dst.noalias() -= lhs.lazyProduct(rhs);
+    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::sub_assign_op<typename Dst::Scalar,Scalar>());
+  }
+
+  // This is a special evaluation path called from generic_product_impl<...,GemmProduct> in file GeneralMatrixMatrix.h
+  // This variant tries to extract scalar multiples from both the LHS and RHS and factor them out. For instance:
+  //   dst {,+,-}= (s1*A)*(B*s2)
+  // will be rewritten as:
+  //   dst {,+,-}= (s1*s2) * (A.lazyProduct(B))
+  // There are at least four benefits of doing so:
+  //  1 - huge performance gain for heap-allocated matrix types as it save costly allocations.
+  //  2 - it is faster than simply by-passing the heap allocation through stack allocation.
+  //  3 - it makes this fallback consistent with the heavy GEMM routine.
+  //  4 - it fully by-passes huge stack allocation attempts when multiplying huge fixed-size matrices.
+  //      (see https://stackoverflow.com/questions/54738495)
+  // For small fixed sizes matrices, howver, the gains are less obvious, it is sometimes x2 faster, but sometimes x3 slower,
+  // and the behavior depends also a lot on the compiler... This is why this re-writting strategy is currently
+  // enabled only when falling back from the main GEMM.
+  template<typename Dst, typename Func>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void eval_dynamic(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Func &func)
+  {
+    enum {
+      HasScalarFactor = blas_traits<Lhs>::HasScalarFactor || blas_traits<Rhs>::HasScalarFactor,
+      ConjLhs = blas_traits<Lhs>::NeedToConjugate,
+      ConjRhs = blas_traits<Rhs>::NeedToConjugate
+    };
+    // FIXME: in c++11 this should be auto, and extractScalarFactor should also return auto
+    //        this is important for real*complex_mat
+    Scalar actualAlpha = combine_scalar_factors<Scalar>(lhs, rhs);
+
+    eval_dynamic_impl(dst,
+                      blas_traits<Lhs>::extract(lhs).template conjugateIf<ConjLhs>(),
+                      blas_traits<Rhs>::extract(rhs).template conjugateIf<ConjRhs>(),
+                      func,
+                      actualAlpha,
+                      typename conditional<HasScalarFactor,true_type,false_type>::type());
+  }
+
+protected:
+
+  template<typename Dst, typename LhsT, typename RhsT, typename Func, typename Scalar>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void eval_dynamic_impl(Dst& dst, const LhsT& lhs, const RhsT& rhs, const Func &func, const Scalar&  s /* == 1 */, false_type)
+  {
+    EIGEN_UNUSED_VARIABLE(s);
+    eigen_internal_assert(s==Scalar(1));
+    call_restricted_packet_assignment_no_alias(dst, lhs.lazyProduct(rhs), func);
+  }
+
+  template<typename Dst, typename LhsT, typename RhsT, typename Func, typename Scalar>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void eval_dynamic_impl(Dst& dst, const LhsT& lhs, const RhsT& rhs, const Func &func, const Scalar& s, true_type)
+  {
+    call_restricted_packet_assignment_no_alias(dst, s * lhs.lazyProduct(rhs), func);
+  }
+};
+
+// This specialization enforces the use of a coefficient-based evaluation strategy
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,LazyCoeffBasedProductMode>
+  : generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,CoeffBasedProductMode> {};
+
+// Case 2: Evaluate coeff by coeff
+//
+// This is mostly taken from CoeffBasedProduct.h
+// The main difference is that we add an extra argument to the etor_product_*_impl::run() function
+// for the inner dimension of the product, because evaluator object do not know their size.
+
+template<int Traversal, int UnrollingIndex, typename Lhs, typename Rhs, typename RetScalar>
+struct etor_product_coeff_impl;
+
+template<int StorageOrder, int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, DenseShape>
+    : evaluator_base<Product<Lhs, Rhs, LazyProduct> >
+{
+  typedef Product<Lhs, Rhs, LazyProduct> XprType;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit product_evaluator(const XprType& xpr)
+    : m_lhs(xpr.lhs()),
+      m_rhs(xpr.rhs()),
+      m_lhsImpl(m_lhs),     // FIXME the creation of the evaluator objects should result in a no-op, but check that!
+      m_rhsImpl(m_rhs),     //       Moreover, they are only useful for the packet path, so we could completely disable them when not needed,
+                            //       or perhaps declare them on the fly on the packet method... We have experiment to check what's best.
+      m_innerDim(xpr.lhs().cols())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::MulCost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::AddCost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+#if 0
+    std::cerr << "LhsOuterStrideBytes=  " << LhsOuterStrideBytes << "\n";
+    std::cerr << "RhsOuterStrideBytes=  " << RhsOuterStrideBytes << "\n";
+    std::cerr << "LhsAlignment=         " << LhsAlignment << "\n";
+    std::cerr << "RhsAlignment=         " << RhsAlignment << "\n";
+    std::cerr << "CanVectorizeLhs=      " << CanVectorizeLhs << "\n";
+    std::cerr << "CanVectorizeRhs=      " << CanVectorizeRhs << "\n";
+    std::cerr << "CanVectorizeInner=    " << CanVectorizeInner << "\n";
+    std::cerr << "EvalToRowMajor=       " << EvalToRowMajor << "\n";
+    std::cerr << "Alignment=            " << Alignment << "\n";
+    std::cerr << "Flags=                " << Flags << "\n";
+#endif
+  }
+
+  // Everything below here is taken from CoeffBasedProduct.h
+
+  typedef typename internal::nested_eval<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
+  typedef typename internal::nested_eval<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
+
+  typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
+  typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
+
+  typedef evaluator<LhsNestedCleaned> LhsEtorType;
+  typedef evaluator<RhsNestedCleaned> RhsEtorType;
+
+  enum {
+    RowsAtCompileTime = LhsNestedCleaned::RowsAtCompileTime,
+    ColsAtCompileTime = RhsNestedCleaned::ColsAtCompileTime,
+    InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(LhsNestedCleaned::ColsAtCompileTime, RhsNestedCleaned::RowsAtCompileTime),
+    MaxRowsAtCompileTime = LhsNestedCleaned::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = RhsNestedCleaned::MaxColsAtCompileTime
+  };
+
+  typedef typename find_best_packet<Scalar,RowsAtCompileTime>::type LhsVecPacketType;
+  typedef typename find_best_packet<Scalar,ColsAtCompileTime>::type RhsVecPacketType;
+
+  enum {
+
+    LhsCoeffReadCost = LhsEtorType::CoeffReadCost,
+    RhsCoeffReadCost = RhsEtorType::CoeffReadCost,
+    CoeffReadCost = InnerSize==0 ? NumTraits<Scalar>::ReadCost
+                  : InnerSize == Dynamic ? HugeCost
+                    : InnerSize * (NumTraits<Scalar>::MulCost + int(LhsCoeffReadCost) + int(RhsCoeffReadCost))
+                    + (InnerSize - 1) * NumTraits<Scalar>::AddCost,
+
+    Unroll = CoeffReadCost <= EIGEN_UNROLLING_LIMIT,
+
+    LhsFlags = LhsEtorType::Flags,
+    RhsFlags = RhsEtorType::Flags,
+
+    LhsRowMajor = LhsFlags & RowMajorBit,
+    RhsRowMajor = RhsFlags & RowMajorBit,
+
+    LhsVecPacketSize = unpacket_traits<LhsVecPacketType>::size,
+    RhsVecPacketSize = unpacket_traits<RhsVecPacketType>::size,
+
+    // Here, we don't care about alignment larger than the usable packet size.
+    LhsAlignment = EIGEN_PLAIN_ENUM_MIN(LhsEtorType::Alignment,LhsVecPacketSize*int(sizeof(typename LhsNestedCleaned::Scalar))),
+    RhsAlignment = EIGEN_PLAIN_ENUM_MIN(RhsEtorType::Alignment,RhsVecPacketSize*int(sizeof(typename RhsNestedCleaned::Scalar))),
+
+    SameType = is_same<typename LhsNestedCleaned::Scalar,typename RhsNestedCleaned::Scalar>::value,
+
+    CanVectorizeRhs = bool(RhsRowMajor) && (RhsFlags & PacketAccessBit) && (ColsAtCompileTime!=1),
+    CanVectorizeLhs = (!LhsRowMajor) && (LhsFlags & PacketAccessBit) && (RowsAtCompileTime!=1),
+
+    EvalToRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
+                    : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
+                    : (bool(RhsRowMajor) && !CanVectorizeLhs),
+
+    Flags = ((int(LhsFlags) | int(RhsFlags)) & HereditaryBits & ~RowMajorBit)
+          | (EvalToRowMajor ? RowMajorBit : 0)
+          // TODO enable vectorization for mixed types
+          | (SameType && (CanVectorizeLhs || CanVectorizeRhs) ? PacketAccessBit : 0)
+          | (XprType::IsVectorAtCompileTime ? LinearAccessBit : 0),
+
+    LhsOuterStrideBytes = int(LhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename LhsNestedCleaned::Scalar)),
+    RhsOuterStrideBytes = int(RhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename RhsNestedCleaned::Scalar)),
+
+    Alignment = bool(CanVectorizeLhs) ? (LhsOuterStrideBytes<=0 || (int(LhsOuterStrideBytes) % EIGEN_PLAIN_ENUM_MAX(1,LhsAlignment))!=0 ? 0 : LhsAlignment)
+              : bool(CanVectorizeRhs) ? (RhsOuterStrideBytes<=0 || (int(RhsOuterStrideBytes) % EIGEN_PLAIN_ENUM_MAX(1,RhsAlignment))!=0 ? 0 : RhsAlignment)
+              : 0,
+
+    /* CanVectorizeInner deserves special explanation. It does not affect the product flags. It is not used outside
+     * of Product. If the Product itself is not a packet-access expression, there is still a chance that the inner
+     * loop of the product might be vectorized. This is the meaning of CanVectorizeInner. Since it doesn't affect
+     * the Flags, it is safe to make this value depend on ActualPacketAccessBit, that doesn't affect the ABI.
+     */
+    CanVectorizeInner =    SameType
+                        && LhsRowMajor
+                        && (!RhsRowMajor)
+                        && (int(LhsFlags) & int(RhsFlags) & ActualPacketAccessBit)
+                        && (int(InnerSize) % packet_traits<Scalar>::size == 0)
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index row, Index col) const
+  {
+    return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum();
+  }
+
+  /* Allow index-based non-packet access. It is impossible though to allow index-based packed access,
+   * which is why we don't set the LinearAccessBit.
+   * TODO: this seems possible when the result is a vector
+   */
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const CoeffReturnType coeff(Index index) const
+  {
+    const Index row = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? 0 : index;
+    const Index col = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? index : 0;
+    return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum();
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const PacketType packet(Index row, Index col) const
+  {
+    PacketType res;
+    typedef etor_product_packet_impl<bool(int(Flags)&RowMajorBit) ? RowMajor : ColMajor,
+                                     Unroll ? int(InnerSize) : Dynamic,
+                                     LhsEtorType, RhsEtorType, PacketType, LoadMode> PacketImpl;
+    PacketImpl::run(row, col, m_lhsImpl, m_rhsImpl, m_innerDim, res);
+    return res;
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const PacketType packet(Index index) const
+  {
+    const Index row = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? 0 : index;
+    const Index col = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? index : 0;
+    return packet<LoadMode,PacketType>(row,col);
+  }
+
+protected:
+  typename internal::add_const_on_value_type<LhsNested>::type m_lhs;
+  typename internal::add_const_on_value_type<RhsNested>::type m_rhs;
+
+  LhsEtorType m_lhsImpl;
+  RhsEtorType m_rhsImpl;
+
+  // TODO: Get rid of m_innerDim if known at compile time
+  Index m_innerDim;
+};
+
+template<typename Lhs, typename Rhs>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, LazyCoeffBasedProductMode, DenseShape, DenseShape>
+  : product_evaluator<Product<Lhs, Rhs, LazyProduct>, CoeffBasedProductMode, DenseShape, DenseShape>
+{
+  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  typedef Product<Lhs, Rhs, LazyProduct> BaseProduct;
+  typedef product_evaluator<BaseProduct, CoeffBasedProductMode, DenseShape, DenseShape> Base;
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit product_evaluator(const XprType& xpr)
+    : Base(BaseProduct(xpr.lhs(),xpr.rhs()))
+  {}
+};
+
+/****************************************
+*** Coeff based product, Packet path  ***
+****************************************/
+
+template<int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet &res)
+  {
+    etor_product_packet_impl<RowMajor, UnrollingIndex-1, Lhs, Rhs, Packet, LoadMode>::run(row, col, lhs, rhs, innerDim, res);
+    res =  pmadd(pset1<Packet>(lhs.coeff(row, Index(UnrollingIndex-1))), rhs.template packet<LoadMode,Packet>(Index(UnrollingIndex-1), col), res);
+  }
+};
+
+template<int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet &res)
+  {
+    etor_product_packet_impl<ColMajor, UnrollingIndex-1, Lhs, Rhs, Packet, LoadMode>::run(row, col, lhs, rhs, innerDim, res);
+    res =  pmadd(lhs.template packet<LoadMode,Packet>(row, Index(UnrollingIndex-1)), pset1<Packet>(rhs.coeff(Index(UnrollingIndex-1), col)), res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, 1, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index /*innerDim*/, Packet &res)
+  {
+    res = pmul(pset1<Packet>(lhs.coeff(row, Index(0))),rhs.template packet<LoadMode,Packet>(Index(0), col));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, 1, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index /*innerDim*/, Packet &res)
+  {
+    res = pmul(lhs.template packet<LoadMode,Packet>(row, Index(0)), pset1<Packet>(rhs.coeff(Index(0), col)));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, 0, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const Lhs& /*lhs*/, const Rhs& /*rhs*/, Index /*innerDim*/, Packet &res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, 0, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const Lhs& /*lhs*/, const Rhs& /*rhs*/, Index /*innerDim*/, Packet &res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet& res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+    for(Index i = 0; i < innerDim; ++i)
+      res =  pmadd(pset1<Packet>(lhs.coeff(row, i)), rhs.template packet<LoadMode,Packet>(i, col), res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet& res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+    for(Index i = 0; i < innerDim; ++i)
+      res =  pmadd(lhs.template packet<LoadMode,Packet>(row, i), pset1<Packet>(rhs.coeff(i, col)), res);
+  }
+};
+
+
+/***************************************************************************
+* Triangular products
+***************************************************************************/
+template<int Mode, bool LhsIsTriangular,
+         typename Lhs, bool LhsIsVector,
+         typename Rhs, bool RhsIsVector>
+struct triangular_product_impl;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,TriangularShape,DenseShape,ProductTag>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,TriangularShape,DenseShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    triangular_product_impl<Lhs::Mode,true,typename Lhs::MatrixType,false,Rhs, Rhs::ColsAtCompileTime==1>
+        ::run(dst, lhs.nestedExpression(), rhs, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,DenseShape,TriangularShape,ProductTag>
+: generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,TriangularShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    triangular_product_impl<Rhs::Mode,false,Lhs,Lhs::RowsAtCompileTime==1, typename Rhs::MatrixType, false>::run(dst, lhs, rhs.nestedExpression(), alpha);
+  }
+};
+
+
+/***************************************************************************
+* SelfAdjoint products
+***************************************************************************/
+template <typename Lhs, int LhsMode, bool LhsIsVector,
+          typename Rhs, int RhsMode, bool RhsIsVector>
+struct selfadjoint_product_impl;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,SelfAdjointShape,DenseShape,ProductTag>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,SelfAdjointShape,DenseShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC
+  void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    selfadjoint_product_impl<typename Lhs::MatrixType,Lhs::Mode,false,Rhs,0,Rhs::IsVectorAtCompileTime>::run(dst, lhs.nestedExpression(), rhs, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,DenseShape,SelfAdjointShape,ProductTag>
+: generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,SelfAdjointShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    selfadjoint_product_impl<Lhs,0,Lhs::IsVectorAtCompileTime,typename Rhs::MatrixType,Rhs::Mode,false>::run(dst, lhs, rhs.nestedExpression(), alpha);
+  }
+};
+
+
+/***************************************************************************
+* Diagonal products
+***************************************************************************/
+
+template<typename MatrixType, typename DiagonalType, typename Derived, int ProductOrder>
+struct diagonal_product_evaluator_base
+  : evaluator_base<Derived>
+{
+   typedef typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType Scalar;
+public:
+  enum {
+    CoeffReadCost = int(NumTraits<Scalar>::MulCost) + int(evaluator<MatrixType>::CoeffReadCost) + int(evaluator<DiagonalType>::CoeffReadCost),
+
+    MatrixFlags = evaluator<MatrixType>::Flags,
+    DiagFlags = evaluator<DiagonalType>::Flags,
+
+    _StorageOrder = (Derived::MaxRowsAtCompileTime==1 && Derived::MaxColsAtCompileTime!=1) ? RowMajor
+                  : (Derived::MaxColsAtCompileTime==1 && Derived::MaxRowsAtCompileTime!=1) ? ColMajor
+                  : MatrixFlags & RowMajorBit ? RowMajor : ColMajor,
+    _SameStorageOrder = _StorageOrder == (MatrixFlags & RowMajorBit ? RowMajor : ColMajor),
+
+    _ScalarAccessOnDiag =  !((int(_StorageOrder) == ColMajor && int(ProductOrder) == OnTheLeft)
+                           ||(int(_StorageOrder) == RowMajor && int(ProductOrder) == OnTheRight)),
+    _SameTypes = is_same<typename MatrixType::Scalar, typename DiagonalType::Scalar>::value,
+    // FIXME currently we need same types, but in the future the next rule should be the one
+    //_Vectorizable = bool(int(MatrixFlags)&PacketAccessBit) && ((!_PacketOnDiag) || (_SameTypes && bool(int(DiagFlags)&PacketAccessBit))),
+    _Vectorizable =   bool(int(MatrixFlags)&PacketAccessBit)
+                  &&  _SameTypes
+                  && (_SameStorageOrder || (MatrixFlags&LinearAccessBit)==LinearAccessBit)
+                  && (_ScalarAccessOnDiag || (bool(int(DiagFlags)&PacketAccessBit))),
+    _LinearAccessMask = (MatrixType::RowsAtCompileTime==1 || MatrixType::ColsAtCompileTime==1) ? LinearAccessBit : 0,
+    Flags = ((HereditaryBits|_LinearAccessMask) & (unsigned int)(MatrixFlags)) | (_Vectorizable ? PacketAccessBit : 0),
+    Alignment = evaluator<MatrixType>::Alignment,
+
+    AsScalarProduct =     (DiagonalType::SizeAtCompileTime==1)
+                      ||  (DiagonalType::SizeAtCompileTime==Dynamic && MatrixType::RowsAtCompileTime==1 && ProductOrder==OnTheLeft)
+                      ||  (DiagonalType::SizeAtCompileTime==Dynamic && MatrixType::ColsAtCompileTime==1 && ProductOrder==OnTheRight)
+  };
+
+  EIGEN_DEVICE_FUNC diagonal_product_evaluator_base(const MatrixType &mat, const DiagonalType &diag)
+    : m_diagImpl(diag), m_matImpl(mat)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::MulCost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index idx) const
+  {
+    if(AsScalarProduct)
+      return m_diagImpl.coeff(0) * m_matImpl.coeff(idx);
+    else
+      return m_diagImpl.coeff(idx) * m_matImpl.coeff(idx);
+  }
+
+protected:
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::true_type) const
+  {
+    return internal::pmul(m_matImpl.template packet<LoadMode,PacketType>(row, col),
+                          internal::pset1<PacketType>(m_diagImpl.coeff(id)));
+  }
+
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::false_type) const
+  {
+    enum {
+      InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime,
+      DiagonalPacketLoadMode = EIGEN_PLAIN_ENUM_MIN(LoadMode,((InnerSize%16) == 0) ? int(Aligned16) : int(evaluator<DiagonalType>::Alignment)) // FIXME hardcoded 16!!
+    };
+    return internal::pmul(m_matImpl.template packet<LoadMode,PacketType>(row, col),
+                          m_diagImpl.template packet<DiagonalPacketLoadMode,PacketType>(id));
+  }
+
+  evaluator<DiagonalType> m_diagImpl;
+  evaluator<MatrixType>   m_matImpl;
+};
+
+// diagonal * dense
+template<typename Lhs, typename Rhs, int ProductKind, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DiagonalShape, DenseShape>
+  : diagonal_product_evaluator_base<Rhs, typename Lhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheLeft>
+{
+  typedef diagonal_product_evaluator_base<Rhs, typename Lhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheLeft> Base;
+  using Base::m_diagImpl;
+  using Base::m_matImpl;
+  using Base::coeff;
+  typedef typename Base::Scalar Scalar;
+
+  typedef Product<Lhs, Rhs, ProductKind> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef typename Lhs::DiagonalVectorType DiagonalType;
+
+
+  enum { StorageOrder = Base::_StorageOrder };
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.rhs(), xpr.lhs().diagonal())
+  {
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const
+  {
+    return m_diagImpl.coeff(row) * m_matImpl.coeff(row, col);
+  }
+
+#ifndef EIGEN_GPUCC
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
+  {
+    // FIXME: NVCC used to complain about the template keyword, but we have to check whether this is still the case.
+    // See also similar calls below.
+    return this->template packet_impl<LoadMode,PacketType>(row,col, row,
+                                 typename internal::conditional<int(StorageOrder)==RowMajor, internal::true_type, internal::false_type>::type());
+  }
+
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index idx) const
+  {
+    return packet<LoadMode,PacketType>(int(StorageOrder)==ColMajor?idx:0,int(StorageOrder)==ColMajor?0:idx);
+  }
+#endif
+};
+
+// dense * diagonal
+template<typename Lhs, typename Rhs, int ProductKind, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DenseShape, DiagonalShape>
+  : diagonal_product_evaluator_base<Lhs, typename Rhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheRight>
+{
+  typedef diagonal_product_evaluator_base<Lhs, typename Rhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheRight> Base;
+  using Base::m_diagImpl;
+  using Base::m_matImpl;
+  using Base::coeff;
+  typedef typename Base::Scalar Scalar;
+
+  typedef Product<Lhs, Rhs, ProductKind> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+
+  enum { StorageOrder = Base::_StorageOrder };
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.lhs(), xpr.rhs().diagonal())
+  {
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const
+  {
+    return m_matImpl.coeff(row, col) * m_diagImpl.coeff(col);
+  }
+
+#ifndef EIGEN_GPUCC
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
+  {
+    return this->template packet_impl<LoadMode,PacketType>(row,col, col,
+                                 typename internal::conditional<int(StorageOrder)==ColMajor, internal::true_type, internal::false_type>::type());
+  }
+
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index idx) const
+  {
+    return packet<LoadMode,PacketType>(int(StorageOrder)==ColMajor?idx:0,int(StorageOrder)==ColMajor?0:idx);
+  }
+#endif
+};
+
+/***************************************************************************
+* Products with permutation matrices
+***************************************************************************/
+
+/** \internal
+  * \class permutation_matrix_product
+  * Internal helper class implementing the product between a permutation matrix and a matrix.
+  * This class is specialized for DenseShape below and for SparseShape in SparseCore/SparsePermutation.h
+  */
+template<typename ExpressionType, int Side, bool Transposed, typename ExpressionShape>
+struct permutation_matrix_product;
+
+template<typename ExpressionType, int Side, bool Transposed>
+struct permutation_matrix_product<ExpressionType, Side, Transposed, DenseShape>
+{
+    typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
+    typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+
+    template<typename Dest, typename PermutationType>
+    static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Dest& dst, const PermutationType& perm, const ExpressionType& xpr)
+    {
+      MatrixType mat(xpr);
+      const Index n = Side==OnTheLeft ? mat.rows() : mat.cols();
+      // FIXME we need an is_same for expression that is not sensitive to constness. For instance
+      // is_same_xpr<Block<const Matrix>, Block<Matrix> >::value should be true.
+      //if(is_same<MatrixTypeCleaned,Dest>::value && extract_data(dst) == extract_data(mat))
+      if(is_same_dense(dst, mat))
+      {
+        // apply the permutation inplace
+        Matrix<bool,PermutationType::RowsAtCompileTime,1,0,PermutationType::MaxRowsAtCompileTime> mask(perm.size());
+        mask.fill(false);
+        Index r = 0;
+        while(r < perm.size())
+        {
+          // search for the next seed
+          while(r<perm.size() && mask[r]) r++;
+          if(r>=perm.size())
+            break;
+          // we got one, let's follow it until we are back to the seed
+          Index k0 = r++;
+          Index kPrev = k0;
+          mask.coeffRef(k0) = true;
+          for(Index k=perm.indices().coeff(k0); k!=k0; k=perm.indices().coeff(k))
+          {
+                  Block<Dest, Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime, Side==OnTheRight ? 1 : Dest::ColsAtCompileTime>(dst, k)
+            .swap(Block<Dest, Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime, Side==OnTheRight ? 1 : Dest::ColsAtCompileTime>
+                       (dst,((Side==OnTheLeft) ^ Transposed) ? k0 : kPrev));
+
+            mask.coeffRef(k) = true;
+            kPrev = k;
+          }
+        }
+      }
+      else
+      {
+        for(Index i = 0; i < n; ++i)
+        {
+          Block<Dest, Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime, Side==OnTheRight ? 1 : Dest::ColsAtCompileTime>
+               (dst, ((Side==OnTheLeft) ^ Transposed) ? perm.indices().coeff(i) : i)
+
+          =
+
+          Block<const MatrixTypeCleaned,Side==OnTheLeft ? 1 : MatrixTypeCleaned::RowsAtCompileTime,Side==OnTheRight ? 1 : MatrixTypeCleaned::ColsAtCompileTime>
+               (mat, ((Side==OnTheRight) ^ Transposed) ? perm.indices().coeff(i) : i);
+        }
+      }
+    }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, PermutationShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    permutation_matrix_product<Rhs, OnTheLeft, false, MatrixShape>::run(dst, lhs, rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, MatrixShape, PermutationShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    permutation_matrix_product<Lhs, OnTheRight, false, MatrixShape>::run(dst, rhs, lhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Inverse<Lhs>, Rhs, PermutationShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Inverse<Lhs>& lhs, const Rhs& rhs)
+  {
+    permutation_matrix_product<Rhs, OnTheLeft, true, MatrixShape>::run(dst, lhs.nestedExpression(), rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Inverse<Rhs>, MatrixShape, PermutationShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Inverse<Rhs>& rhs)
+  {
+    permutation_matrix_product<Lhs, OnTheRight, true, MatrixShape>::run(dst, rhs.nestedExpression(), lhs);
+  }
+};
+
+
+/***************************************************************************
+* Products with transpositions matrices
+***************************************************************************/
+
+// FIXME could we unify Transpositions and Permutation into a single "shape"??
+
+/** \internal
+  * \class transposition_matrix_product
+  * Internal helper class implementing the product between a permutation matrix and a matrix.
+  */
+template<typename ExpressionType, int Side, bool Transposed, typename ExpressionShape>
+struct transposition_matrix_product
+{
+  typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
+  typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+
+  template<typename Dest, typename TranspositionType>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Dest& dst, const TranspositionType& tr, const ExpressionType& xpr)
+  {
+    MatrixType mat(xpr);
+    typedef typename TranspositionType::StorageIndex StorageIndex;
+    const Index size = tr.size();
+    StorageIndex j = 0;
+
+    if(!is_same_dense(dst,mat))
+      dst = mat;
+
+    for(Index k=(Transposed?size-1:0) ; Transposed?k>=0:k<size ; Transposed?--k:++k)
+      if(Index(j=tr.coeff(k))!=k)
+      {
+        if(Side==OnTheLeft)        dst.row(k).swap(dst.row(j));
+        else if(Side==OnTheRight)  dst.col(k).swap(dst.col(j));
+      }
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, TranspositionsShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    transposition_matrix_product<Rhs, OnTheLeft, false, MatrixShape>::run(dst, lhs, rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, MatrixShape, TranspositionsShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    transposition_matrix_product<Lhs, OnTheRight, false, MatrixShape>::run(dst, rhs, lhs);
+  }
+};
+
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Transpose<Lhs>, Rhs, TranspositionsShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Transpose<Lhs>& lhs, const Rhs& rhs)
+  {
+    transposition_matrix_product<Rhs, OnTheLeft, true, MatrixShape>::run(dst, lhs.nestedExpression(), rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Transpose<Rhs>, MatrixShape, TranspositionsShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Transpose<Rhs>& rhs)
+  {
+    transposition_matrix_product<Lhs, OnTheRight, true, MatrixShape>::run(dst, rhs.nestedExpression(), lhs);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PRODUCT_EVALUATORS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Random.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Random.h
new file mode 100644
index 00000000..dab2ac8e
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Random.h
@@ -0,0 +1,218 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_RANDOM_H
+#define EIGEN_RANDOM_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Scalar> struct scalar_random_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_random_op)
+  inline const Scalar operator() () const { return random<Scalar>(); }
+};
+
+template<typename Scalar>
+struct functor_traits<scalar_random_op<Scalar> >
+{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false, IsRepeatable = false }; };
+
+} // end namespace internal
+
+/** \returns a random matrix expression
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * \not_reentrant
+  * 
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Random() should be used
+  * instead.
+  * 
+  *
+  * Example: \include MatrixBase_random_int_int.cpp
+  * Output: \verbinclude MatrixBase_random_int_int.out
+  *
+  * This expression has the "evaluate before nesting" flag so that it will be evaluated into
+  * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected
+  * behavior with expressions involving random matrices.
+  * 
+  * See DenseBase::NullaryExpr(Index, const CustomNullaryOp&) for an example using C++11 random generators.
+  *
+  * \sa DenseBase::setRandom(), DenseBase::Random(Index), DenseBase::Random()
+  */
+template<typename Derived>
+inline const typename DenseBase<Derived>::RandomReturnType
+DenseBase<Derived>::Random(Index rows, Index cols)
+{
+  return NullaryExpr(rows, cols, internal::scalar_random_op<Scalar>());
+}
+
+/** \returns a random vector expression
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  * \not_reentrant
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Random() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_random_int.cpp
+  * Output: \verbinclude MatrixBase_random_int.out
+  *
+  * This expression has the "evaluate before nesting" flag so that it will be evaluated into
+  * a temporary vector whenever it is nested in a larger expression. This prevents unexpected
+  * behavior with expressions involving random matrices.
+  *
+  * \sa DenseBase::setRandom(), DenseBase::Random(Index,Index), DenseBase::Random()
+  */
+template<typename Derived>
+inline const typename DenseBase<Derived>::RandomReturnType
+DenseBase<Derived>::Random(Index size)
+{
+  return NullaryExpr(size, internal::scalar_random_op<Scalar>());
+}
+
+/** \returns a fixed-size random matrix or vector expression
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * Example: \include MatrixBase_random.cpp
+  * Output: \verbinclude MatrixBase_random.out
+  *
+  * This expression has the "evaluate before nesting" flag so that it will be evaluated into
+  * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected
+  * behavior with expressions involving random matrices.
+  * 
+  * \not_reentrant
+  *
+  * \sa DenseBase::setRandom(), DenseBase::Random(Index,Index), DenseBase::Random(Index)
+  */
+template<typename Derived>
+inline const typename DenseBase<Derived>::RandomReturnType
+DenseBase<Derived>::Random()
+{
+  return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_random_op<Scalar>());
+}
+
+/** Sets all coefficients in this expression to random values.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * \not_reentrant
+  * 
+  * Example: \include MatrixBase_setRandom.cpp
+  * Output: \verbinclude MatrixBase_setRandom.out
+  *
+  * \sa class CwiseNullaryOp, setRandom(Index), setRandom(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Derived& DenseBase<Derived>::setRandom()
+{
+  return *this = Random(rows(), cols());
+}
+
+/** Resizes to the given \a newSize, and sets all coefficients in this expression to random values.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * \only_for_vectors
+  * \not_reentrant
+  *
+  * Example: \include Matrix_setRandom_int.cpp
+  * Output: \verbinclude Matrix_setRandom_int.out
+  *
+  * \sa DenseBase::setRandom(), setRandom(Index,Index), class CwiseNullaryOp, DenseBase::Random()
+  */
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setRandom(Index newSize)
+{
+  resize(newSize);
+  return setRandom();
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to random values.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  *
+  * \not_reentrant
+  * 
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setRandom_int_int.cpp
+  * Output: \verbinclude Matrix_setRandom_int_int.out
+  *
+  * \sa DenseBase::setRandom(), setRandom(Index), class CwiseNullaryOp, DenseBase::Random()
+  */
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setRandom(Index rows, Index cols)
+{
+  resize(rows, cols);
+  return setRandom();
+}
+
+/** Resizes to the given size, changing only the number of columns, and sets all
+  * coefficients in this expression to random values. For the parameter of type
+  * NoChange_t, just pass the special value \c NoChange.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  *
+  * \not_reentrant
+  *
+  * \sa DenseBase::setRandom(), setRandom(Index), setRandom(Index, NoChange_t), class CwiseNullaryOp, DenseBase::Random()
+  */
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setRandom(NoChange_t, Index cols)
+{
+  return setRandom(rows(), cols);
+}
+
+/** Resizes to the given size, changing only the number of rows, and sets all
+  * coefficients in this expression to random values. For the parameter of type
+  * NoChange_t, just pass the special value \c NoChange.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  *
+  * \not_reentrant
+  *
+  * \sa DenseBase::setRandom(), setRandom(Index), setRandom(NoChange_t, Index), class CwiseNullaryOp, DenseBase::Random()
+  */
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setRandom(Index rows, NoChange_t)
+{
+  return setRandom(rows, cols());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_RANDOM_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Redux.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Redux.h
new file mode 100644
index 00000000..b6790d11
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Redux.h
@@ -0,0 +1,515 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REDUX_H
+#define EIGEN_REDUX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// TODO
+//  * implement other kind of vectorization
+//  * factorize code
+
+/***************************************************************************
+* Part 1 : the logic deciding a strategy for vectorization and unrolling
+***************************************************************************/
+
+template<typename Func, typename Evaluator>
+struct redux_traits
+{
+public:
+    typedef typename find_best_packet<typename Evaluator::Scalar,Evaluator::SizeAtCompileTime>::type PacketType;
+  enum {
+    PacketSize = unpacket_traits<PacketType>::size,
+    InnerMaxSize = int(Evaluator::IsRowMajor)
+                 ? Evaluator::MaxColsAtCompileTime
+                 : Evaluator::MaxRowsAtCompileTime,
+    OuterMaxSize = int(Evaluator::IsRowMajor)
+                 ? Evaluator::MaxRowsAtCompileTime
+                 : Evaluator::MaxColsAtCompileTime,
+    SliceVectorizedWork = int(InnerMaxSize)==Dynamic ? Dynamic
+                        : int(OuterMaxSize)==Dynamic ? (int(InnerMaxSize)>=int(PacketSize) ? Dynamic : 0)
+                        : (int(InnerMaxSize)/int(PacketSize)) * int(OuterMaxSize)
+  };
+
+  enum {
+    MightVectorize = (int(Evaluator::Flags)&ActualPacketAccessBit)
+                  && (functor_traits<Func>::PacketAccess),
+    MayLinearVectorize = bool(MightVectorize) && (int(Evaluator::Flags)&LinearAccessBit),
+    MaySliceVectorize  = bool(MightVectorize) && (int(SliceVectorizedWork)==Dynamic || int(SliceVectorizedWork)>=3)
+  };
+
+public:
+  enum {
+    Traversal = int(MayLinearVectorize) ? int(LinearVectorizedTraversal)
+              : int(MaySliceVectorize)  ? int(SliceVectorizedTraversal)
+                                        : int(DefaultTraversal)
+  };
+
+public:
+  enum {
+    Cost = Evaluator::SizeAtCompileTime == Dynamic ? HugeCost
+         : int(Evaluator::SizeAtCompileTime) * int(Evaluator::CoeffReadCost) + (Evaluator::SizeAtCompileTime-1) * functor_traits<Func>::Cost,
+    UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Traversal) == int(DefaultTraversal) ? 1 : int(PacketSize))
+  };
+
+public:
+  enum {
+    Unrolling = Cost <= UnrollingLimit ? CompleteUnrolling : NoUnrolling
+  };
+  
+#ifdef EIGEN_DEBUG_ASSIGN
+  static void debug()
+  {
+    std::cerr << "Xpr: " << typeid(typename Evaluator::XprType).name() << std::endl;
+    std::cerr.setf(std::ios::hex, std::ios::basefield);
+    EIGEN_DEBUG_VAR(Evaluator::Flags)
+    std::cerr.unsetf(std::ios::hex);
+    EIGEN_DEBUG_VAR(InnerMaxSize)
+    EIGEN_DEBUG_VAR(OuterMaxSize)
+    EIGEN_DEBUG_VAR(SliceVectorizedWork)
+    EIGEN_DEBUG_VAR(PacketSize)
+    EIGEN_DEBUG_VAR(MightVectorize)
+    EIGEN_DEBUG_VAR(MayLinearVectorize)
+    EIGEN_DEBUG_VAR(MaySliceVectorize)
+    std::cerr << "Traversal" << " = " << Traversal << " (" << demangle_traversal(Traversal) << ")" << std::endl;
+    EIGEN_DEBUG_VAR(UnrollingLimit)
+    std::cerr << "Unrolling" << " = " << Unrolling << " (" << demangle_unrolling(Unrolling) << ")" << std::endl;
+    std::cerr << std::endl;
+  }
+#endif
+};
+
+/***************************************************************************
+* Part 2 : unrollers
+***************************************************************************/
+
+/*** no vectorization ***/
+
+template<typename Func, typename Evaluator, int Start, int Length>
+struct redux_novec_unroller
+{
+  enum {
+    HalfLength = Length/2
+  };
+
+  typedef typename Evaluator::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Scalar run(const Evaluator &eval, const Func& func)
+  {
+    return func(redux_novec_unroller<Func, Evaluator, Start, HalfLength>::run(eval,func),
+                redux_novec_unroller<Func, Evaluator, Start+HalfLength, Length-HalfLength>::run(eval,func));
+  }
+};
+
+template<typename Func, typename Evaluator, int Start>
+struct redux_novec_unroller<Func, Evaluator, Start, 1>
+{
+  enum {
+    outer = Start / Evaluator::InnerSizeAtCompileTime,
+    inner = Start % Evaluator::InnerSizeAtCompileTime
+  };
+
+  typedef typename Evaluator::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Scalar run(const Evaluator &eval, const Func&)
+  {
+    return eval.coeffByOuterInner(outer, inner);
+  }
+};
+
+// This is actually dead code and will never be called. It is required
+// to prevent false warnings regarding failed inlining though
+// for 0 length run() will never be called at all.
+template<typename Func, typename Evaluator, int Start>
+struct redux_novec_unroller<Func, Evaluator, Start, 0>
+{
+  typedef typename Evaluator::Scalar Scalar;
+  EIGEN_DEVICE_FUNC 
+  static EIGEN_STRONG_INLINE Scalar run(const Evaluator&, const Func&) { return Scalar(); }
+};
+
+/*** vectorization ***/
+
+template<typename Func, typename Evaluator, int Start, int Length>
+struct redux_vec_unroller
+{
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE PacketType run(const Evaluator &eval, const Func& func)
+  {
+    enum {
+      PacketSize = unpacket_traits<PacketType>::size,
+      HalfLength = Length/2
+    };
+
+    return func.packetOp(
+            redux_vec_unroller<Func, Evaluator, Start, HalfLength>::template run<PacketType>(eval,func),
+            redux_vec_unroller<Func, Evaluator, Start+HalfLength, Length-HalfLength>::template run<PacketType>(eval,func) );
+  }
+};
+
+template<typename Func, typename Evaluator, int Start>
+struct redux_vec_unroller<Func, Evaluator, Start, 1>
+{
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE PacketType run(const Evaluator &eval, const Func&)
+  {
+    enum {
+      PacketSize = unpacket_traits<PacketType>::size,
+      index = Start * PacketSize,
+      outer = index / int(Evaluator::InnerSizeAtCompileTime),
+      inner = index % int(Evaluator::InnerSizeAtCompileTime),
+      alignment = Evaluator::Alignment
+    };
+    return eval.template packetByOuterInner<alignment,PacketType>(outer, inner);
+  }
+};
+
+/***************************************************************************
+* Part 3 : implementation of all cases
+***************************************************************************/
+
+template<typename Func, typename Evaluator,
+         int Traversal = redux_traits<Func, Evaluator>::Traversal,
+         int Unrolling = redux_traits<Func, Evaluator>::Unrolling
+>
+struct redux_impl;
+
+template<typename Func, typename Evaluator>
+struct redux_impl<Func, Evaluator, DefaultTraversal, NoUnrolling>
+{
+  typedef typename Evaluator::Scalar Scalar;
+
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE
+  Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
+  {
+    eigen_assert(xpr.rows()>0 && xpr.cols()>0 && "you are using an empty matrix");
+    Scalar res;
+    res = eval.coeffByOuterInner(0, 0);
+    for(Index i = 1; i < xpr.innerSize(); ++i)
+      res = func(res, eval.coeffByOuterInner(0, i));
+    for(Index i = 1; i < xpr.outerSize(); ++i)
+      for(Index j = 0; j < xpr.innerSize(); ++j)
+        res = func(res, eval.coeffByOuterInner(i, j));
+    return res;
+  }
+};
+
+template<typename Func, typename Evaluator>
+struct redux_impl<Func,Evaluator, DefaultTraversal, CompleteUnrolling>
+  : redux_novec_unroller<Func,Evaluator, 0, Evaluator::SizeAtCompileTime>
+{
+  typedef redux_novec_unroller<Func,Evaluator, 0, Evaluator::SizeAtCompileTime> Base;
+  typedef typename Evaluator::Scalar Scalar;
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE
+  Scalar run(const Evaluator &eval, const Func& func, const XprType& /*xpr*/)
+  {
+    return Base::run(eval,func);
+  }
+};
+
+template<typename Func, typename Evaluator>
+struct redux_impl<Func, Evaluator, LinearVectorizedTraversal, NoUnrolling>
+{
+  typedef typename Evaluator::Scalar Scalar;
+  typedef typename redux_traits<Func, Evaluator>::PacketType PacketScalar;
+
+  template<typename XprType>
+  static Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
+  {
+    const Index size = xpr.size();
+    
+    const Index packetSize = redux_traits<Func, Evaluator>::PacketSize;
+    const int packetAlignment = unpacket_traits<PacketScalar>::alignment;
+    enum {
+      alignment0 = (bool(Evaluator::Flags & DirectAccessBit) && bool(packet_traits<Scalar>::AlignedOnScalar)) ? int(packetAlignment) : int(Unaligned),
+      alignment = EIGEN_PLAIN_ENUM_MAX(alignment0, Evaluator::Alignment)
+    };
+    const Index alignedStart = internal::first_default_aligned(xpr);
+    const Index alignedSize2 = ((size-alignedStart)/(2*packetSize))*(2*packetSize);
+    const Index alignedSize = ((size-alignedStart)/(packetSize))*(packetSize);
+    const Index alignedEnd2 = alignedStart + alignedSize2;
+    const Index alignedEnd  = alignedStart + alignedSize;
+    Scalar res;
+    if(alignedSize)
+    {
+      PacketScalar packet_res0 = eval.template packet<alignment,PacketScalar>(alignedStart);
+      if(alignedSize>packetSize) // we have at least two packets to partly unroll the loop
+      {
+        PacketScalar packet_res1 = eval.template packet<alignment,PacketScalar>(alignedStart+packetSize);
+        for(Index index = alignedStart + 2*packetSize; index < alignedEnd2; index += 2*packetSize)
+        {
+          packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment,PacketScalar>(index));
+          packet_res1 = func.packetOp(packet_res1, eval.template packet<alignment,PacketScalar>(index+packetSize));
+        }
+
+        packet_res0 = func.packetOp(packet_res0,packet_res1);
+        if(alignedEnd>alignedEnd2)
+          packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment,PacketScalar>(alignedEnd2));
+      }
+      res = func.predux(packet_res0);
+
+      for(Index index = 0; index < alignedStart; ++index)
+        res = func(res,eval.coeff(index));
+
+      for(Index index = alignedEnd; index < size; ++index)
+        res = func(res,eval.coeff(index));
+    }
+    else // too small to vectorize anything.
+         // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
+    {
+      res = eval.coeff(0);
+      for(Index index = 1; index < size; ++index)
+        res = func(res,eval.coeff(index));
+    }
+
+    return res;
+  }
+};
+
+// NOTE: for SliceVectorizedTraversal we simply bypass unrolling
+template<typename Func, typename Evaluator, int Unrolling>
+struct redux_impl<Func, Evaluator, SliceVectorizedTraversal, Unrolling>
+{
+  typedef typename Evaluator::Scalar Scalar;
+  typedef typename redux_traits<Func, Evaluator>::PacketType PacketType;
+
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC static Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
+  {
+    eigen_assert(xpr.rows()>0 && xpr.cols()>0 && "you are using an empty matrix");
+    const Index innerSize = xpr.innerSize();
+    const Index outerSize = xpr.outerSize();
+    enum {
+      packetSize = redux_traits<Func, Evaluator>::PacketSize
+    };
+    const Index packetedInnerSize = ((innerSize)/packetSize)*packetSize;
+    Scalar res;
+    if(packetedInnerSize)
+    {
+      PacketType packet_res = eval.template packet<Unaligned,PacketType>(0,0);
+      for(Index j=0; j<outerSize; ++j)
+        for(Index i=(j==0?packetSize:0); i<packetedInnerSize; i+=Index(packetSize))
+          packet_res = func.packetOp(packet_res, eval.template packetByOuterInner<Unaligned,PacketType>(j,i));
+
+      res = func.predux(packet_res);
+      for(Index j=0; j<outerSize; ++j)
+        for(Index i=packetedInnerSize; i<innerSize; ++i)
+          res = func(res, eval.coeffByOuterInner(j,i));
+    }
+    else // too small to vectorize anything.
+         // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
+    {
+      res = redux_impl<Func, Evaluator, DefaultTraversal, NoUnrolling>::run(eval, func, xpr);
+    }
+
+    return res;
+  }
+};
+
+template<typename Func, typename Evaluator>
+struct redux_impl<Func, Evaluator, LinearVectorizedTraversal, CompleteUnrolling>
+{
+  typedef typename Evaluator::Scalar Scalar;
+
+  typedef typename redux_traits<Func, Evaluator>::PacketType PacketType;
+  enum {
+    PacketSize = redux_traits<Func, Evaluator>::PacketSize,
+    Size = Evaluator::SizeAtCompileTime,
+    VectorizedSize = (int(Size) / int(PacketSize)) * int(PacketSize)
+  };
+
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE
+  Scalar run(const Evaluator &eval, const Func& func, const XprType &xpr)
+  {
+    EIGEN_ONLY_USED_FOR_DEBUG(xpr)
+    eigen_assert(xpr.rows()>0 && xpr.cols()>0 && "you are using an empty matrix");
+    if (VectorizedSize > 0) {
+      Scalar res = func.predux(redux_vec_unroller<Func, Evaluator, 0, Size / PacketSize>::template run<PacketType>(eval,func));
+      if (VectorizedSize != Size)
+        res = func(res,redux_novec_unroller<Func, Evaluator, VectorizedSize, Size-VectorizedSize>::run(eval,func));
+      return res;
+    }
+    else {
+      return redux_novec_unroller<Func, Evaluator, 0, Size>::run(eval,func);
+    }
+  }
+};
+
+// evaluator adaptor
+template<typename _XprType>
+class redux_evaluator : public internal::evaluator<_XprType>
+{
+  typedef internal::evaluator<_XprType> Base;
+public:
+  typedef _XprType XprType;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit redux_evaluator(const XprType &xpr) : Base(xpr) {}
+  
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename XprType::PacketScalar PacketScalar;
+  
+  enum {
+    MaxRowsAtCompileTime = XprType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = XprType::MaxColsAtCompileTime,
+    // TODO we should not remove DirectAccessBit and rather find an elegant way to query the alignment offset at runtime from the evaluator
+    Flags = Base::Flags & ~DirectAccessBit,
+    IsRowMajor = XprType::IsRowMajor,
+    SizeAtCompileTime = XprType::SizeAtCompileTime,
+    InnerSizeAtCompileTime = XprType::InnerSizeAtCompileTime
+  };
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeffByOuterInner(Index outer, Index inner) const
+  { return Base::coeff(IsRowMajor ? outer : inner, IsRowMajor ? inner : outer); }
+  
+  template<int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  PacketType packetByOuterInner(Index outer, Index inner) const
+  { return Base::template packet<LoadMode,PacketType>(IsRowMajor ? outer : inner, IsRowMajor ? inner : outer); }
+  
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Part 4 : public API
+***************************************************************************/
+
+
+/** \returns the result of a full redux operation on the whole matrix or vector using \a func
+  *
+  * The template parameter \a BinaryOp is the type of the functor \a func which must be
+  * an associative operator. Both current C++98 and C++11 functor styles are handled.
+  *
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  *
+  * \sa DenseBase::sum(), DenseBase::minCoeff(), DenseBase::maxCoeff(), MatrixBase::colwise(), MatrixBase::rowwise()
+  */
+template<typename Derived>
+template<typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::redux(const Func& func) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  typedef typename internal::redux_evaluator<Derived> ThisEvaluator;
+  ThisEvaluator thisEval(derived());
+
+  // The initial expression is passed to the reducer as an additional argument instead of
+  // passing it as a member of redux_evaluator to help  
+  return internal::redux_impl<Func, ThisEvaluator>::run(thisEval, func, derived());
+}
+
+/** \returns the minimum of all coefficients of \c *this.
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is minimum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  */
+template<typename Derived>
+template<int NaNPropagation>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::minCoeff() const
+{
+  return derived().redux(Eigen::internal::scalar_min_op<Scalar,Scalar, NaNPropagation>());
+}
+
+/** \returns the maximum of all coefficients of \c *this. 
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  */
+template<typename Derived>
+template<int NaNPropagation>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::maxCoeff() const
+{
+  return derived().redux(Eigen::internal::scalar_max_op<Scalar,Scalar, NaNPropagation>());
+}
+
+/** \returns the sum of all coefficients of \c *this
+  *
+  * If \c *this is empty, then the value 0 is returned.
+  *
+  * \sa trace(), prod(), mean()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::sum() const
+{
+  if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0))
+    return Scalar(0);
+  return derived().redux(Eigen::internal::scalar_sum_op<Scalar,Scalar>());
+}
+
+/** \returns the mean of all coefficients of *this
+*
+* \sa trace(), prod(), sum()
+*/
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::mean() const
+{
+#ifdef __INTEL_COMPILER
+  #pragma warning push
+  #pragma warning ( disable : 2259 )
+#endif
+  return Scalar(derived().redux(Eigen::internal::scalar_sum_op<Scalar,Scalar>())) / Scalar(this->size());
+#ifdef __INTEL_COMPILER
+  #pragma warning pop
+#endif
+}
+
+/** \returns the product of all coefficients of *this
+  *
+  * Example: \include MatrixBase_prod.cpp
+  * Output: \verbinclude MatrixBase_prod.out
+  *
+  * \sa sum(), mean(), trace()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::prod() const
+{
+  if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0))
+    return Scalar(1);
+  return derived().redux(Eigen::internal::scalar_product_op<Scalar>());
+}
+
+/** \returns the trace of \c *this, i.e. the sum of the coefficients on the main diagonal.
+  *
+  * \c *this can be any matrix, not necessarily square.
+  *
+  * \sa diagonal(), sum()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+MatrixBase<Derived>::trace() const
+{
+  return derived().diagonal().sum();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REDUX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Ref.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Ref.h
new file mode 100644
index 00000000..c2a37ead
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Ref.h
@@ -0,0 +1,381 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REF_H
+#define EIGEN_REF_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename _PlainObjectType, int _Options, typename _StrideType>
+struct traits<Ref<_PlainObjectType, _Options, _StrideType> >
+  : public traits<Map<_PlainObjectType, _Options, _StrideType> >
+{
+  typedef _PlainObjectType PlainObjectType;
+  typedef _StrideType StrideType;
+  enum {
+    Options = _Options,
+    Flags = traits<Map<_PlainObjectType, _Options, _StrideType> >::Flags | NestByRefBit,
+    Alignment = traits<Map<_PlainObjectType, _Options, _StrideType> >::Alignment
+  };
+
+  template<typename Derived> struct match {
+    enum {
+      IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime,
+      HasDirectAccess = internal::has_direct_access<Derived>::ret,
+      StorageOrderMatch = IsVectorAtCompileTime || ((PlainObjectType::Flags&RowMajorBit)==(Derived::Flags&RowMajorBit)),
+      InnerStrideMatch = int(StrideType::InnerStrideAtCompileTime)==int(Dynamic)
+                      || int(StrideType::InnerStrideAtCompileTime)==int(Derived::InnerStrideAtCompileTime)
+                      || (int(StrideType::InnerStrideAtCompileTime)==0 && int(Derived::InnerStrideAtCompileTime)==1),
+      OuterStrideMatch = IsVectorAtCompileTime
+                      || int(StrideType::OuterStrideAtCompileTime)==int(Dynamic) || int(StrideType::OuterStrideAtCompileTime)==int(Derived::OuterStrideAtCompileTime),
+      // NOTE, this indirection of evaluator<Derived>::Alignment is needed
+      // to workaround a very strange bug in MSVC related to the instantiation
+      // of has_*ary_operator in evaluator<CwiseNullaryOp>.
+      // This line is surprisingly very sensitive. For instance, simply adding parenthesis
+      // as "DerivedAlignment = (int(evaluator<Derived>::Alignment))," will make MSVC fail...
+      DerivedAlignment = int(evaluator<Derived>::Alignment),
+      AlignmentMatch = (int(traits<PlainObjectType>::Alignment)==int(Unaligned)) || (DerivedAlignment >= int(Alignment)), // FIXME the first condition is not very clear, it should be replaced by the required alignment
+      ScalarTypeMatch = internal::is_same<typename PlainObjectType::Scalar, typename Derived::Scalar>::value,
+      MatchAtCompileTime = HasDirectAccess && StorageOrderMatch && InnerStrideMatch && OuterStrideMatch && AlignmentMatch && ScalarTypeMatch
+    };
+    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
+  };
+
+};
+
+template<typename Derived>
+struct traits<RefBase<Derived> > : public traits<Derived> {};
+
+}
+
+template<typename Derived> class RefBase
+ : public MapBase<Derived>
+{
+  typedef typename internal::traits<Derived>::PlainObjectType PlainObjectType;
+  typedef typename internal::traits<Derived>::StrideType StrideType;
+
+public:
+
+  typedef MapBase<Derived> Base;
+  EIGEN_DENSE_PUBLIC_INTERFACE(RefBase)
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index innerStride() const
+  {
+    return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index outerStride() const
+  {
+    return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
+         : IsVectorAtCompileTime ? this->size()
+         : int(Flags)&RowMajorBit ? this->cols()
+         : this->rows();
+  }
+
+  EIGEN_DEVICE_FUNC RefBase()
+    : Base(0,RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime),
+      // Stride<> does not allow default ctor for Dynamic strides, so let' initialize it with dummy values:
+      m_stride(StrideType::OuterStrideAtCompileTime==Dynamic?0:StrideType::OuterStrideAtCompileTime,
+               StrideType::InnerStrideAtCompileTime==Dynamic?0:StrideType::InnerStrideAtCompileTime)
+  {}
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(RefBase)
+
+protected:
+
+  typedef Stride<StrideType::OuterStrideAtCompileTime,StrideType::InnerStrideAtCompileTime> StrideBase;
+
+  // Resolves inner stride if default 0.
+  static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index resolveInnerStride(Index inner) {
+    return inner == 0 ? 1 : inner;
+  }
+
+  // Resolves outer stride if default 0.
+  static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index resolveOuterStride(Index inner, Index outer, Index rows, Index cols, bool isVectorAtCompileTime, bool isRowMajor) {
+    return outer == 0 ? isVectorAtCompileTime ? inner * rows * cols : isRowMajor ? inner * cols : inner * rows : outer;
+  }
+
+  // Returns true if construction is valid, false if there is a stride mismatch,
+  // and fails if there is a size mismatch.
+  template<typename Expression>
+  EIGEN_DEVICE_FUNC bool construct(Expression& expr)
+  {
+    // Check matrix sizes.  If this is a compile-time vector, we do allow
+    // implicitly transposing.
+    EIGEN_STATIC_ASSERT(
+      EIGEN_PREDICATE_SAME_MATRIX_SIZE(PlainObjectType, Expression)
+      // If it is a vector, the transpose sizes might match.
+      || ( PlainObjectType::IsVectorAtCompileTime
+            && ((int(PlainObjectType::RowsAtCompileTime)==Eigen::Dynamic
+              || int(Expression::ColsAtCompileTime)==Eigen::Dynamic
+              || int(PlainObjectType::RowsAtCompileTime)==int(Expression::ColsAtCompileTime))
+            &&  (int(PlainObjectType::ColsAtCompileTime)==Eigen::Dynamic
+              || int(Expression::RowsAtCompileTime)==Eigen::Dynamic
+              || int(PlainObjectType::ColsAtCompileTime)==int(Expression::RowsAtCompileTime)))),
+      YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES
+    )
+
+    // Determine runtime rows and columns.
+    Index rows = expr.rows();
+    Index cols = expr.cols();
+    if(PlainObjectType::RowsAtCompileTime==1)
+    {
+      eigen_assert(expr.rows()==1 || expr.cols()==1);
+      rows = 1;
+      cols = expr.size();
+    }
+    else if(PlainObjectType::ColsAtCompileTime==1)
+    {
+      eigen_assert(expr.rows()==1 || expr.cols()==1);
+      rows = expr.size();
+      cols = 1;
+    }
+    // Verify that the sizes are valid.
+    eigen_assert(
+      (PlainObjectType::RowsAtCompileTime == Dynamic) || (PlainObjectType::RowsAtCompileTime == rows));
+    eigen_assert(
+      (PlainObjectType::ColsAtCompileTime == Dynamic) || (PlainObjectType::ColsAtCompileTime == cols));
+
+
+    // If this is a vector, we might be transposing, which means that stride should swap.
+    const bool transpose = PlainObjectType::IsVectorAtCompileTime && (rows != expr.rows());
+    // If the storage format differs, we also need to swap the stride.
+    const bool row_major = ((PlainObjectType::Flags)&RowMajorBit) != 0;
+    const bool expr_row_major = (Expression::Flags&RowMajorBit) != 0;
+    const bool storage_differs =  (row_major != expr_row_major);
+
+    const bool swap_stride = (transpose != storage_differs);
+
+    // Determine expr's actual strides, resolving any defaults if zero.
+    const Index expr_inner_actual = resolveInnerStride(expr.innerStride());
+    const Index expr_outer_actual = resolveOuterStride(expr_inner_actual,
+                                                       expr.outerStride(),
+                                                       expr.rows(),
+                                                       expr.cols(),
+                                                       Expression::IsVectorAtCompileTime != 0,
+                                                       expr_row_major);
+
+    // If this is a column-major row vector or row-major column vector, the inner-stride
+    // is arbitrary, so set it to either the compile-time inner stride or 1.
+    const bool row_vector = (rows == 1);
+    const bool col_vector = (cols == 1);
+    const Index inner_stride =
+        ( (!row_major && row_vector) || (row_major && col_vector) ) ?
+            ( StrideType::InnerStrideAtCompileTime > 0 ? Index(StrideType::InnerStrideAtCompileTime) : 1)
+            : swap_stride ? expr_outer_actual : expr_inner_actual;
+
+    // If this is a column-major column vector or row-major row vector, the outer-stride
+    // is arbitrary, so set it to either the compile-time outer stride or vector size.
+    const Index outer_stride =
+      ( (!row_major && col_vector) || (row_major && row_vector) ) ?
+          ( StrideType::OuterStrideAtCompileTime > 0 ? Index(StrideType::OuterStrideAtCompileTime) : rows * cols * inner_stride)
+          : swap_stride ? expr_inner_actual : expr_outer_actual;
+
+    // Check if given inner/outer strides are compatible with compile-time strides.
+    const bool inner_valid = (StrideType::InnerStrideAtCompileTime == Dynamic)
+        || (resolveInnerStride(Index(StrideType::InnerStrideAtCompileTime)) == inner_stride);
+    if (!inner_valid) {
+      return false;
+    }
+
+    const bool outer_valid = (StrideType::OuterStrideAtCompileTime == Dynamic)
+        || (resolveOuterStride(
+              inner_stride,
+              Index(StrideType::OuterStrideAtCompileTime),
+              rows, cols, PlainObjectType::IsVectorAtCompileTime != 0,
+              row_major)
+            == outer_stride);
+    if (!outer_valid) {
+      return false;
+    }
+
+    ::new (static_cast<Base*>(this)) Base(expr.data(), rows, cols);
+    ::new (&m_stride) StrideBase(
+      (StrideType::OuterStrideAtCompileTime == 0) ? 0 : outer_stride,
+      (StrideType::InnerStrideAtCompileTime == 0) ? 0 : inner_stride );
+    return true;
+  }
+
+  StrideBase m_stride;
+};
+
+/** \class Ref
+  * \ingroup Core_Module
+  *
+  * \brief A matrix or vector expression mapping an existing expression
+  *
+  * \tparam PlainObjectType the equivalent matrix type of the mapped data
+  * \tparam Options specifies the pointer alignment in bytes. It can be: \c #Aligned128, , \c #Aligned64, \c #Aligned32, \c #Aligned16, \c #Aligned8 or \c #Unaligned.
+  *                 The default is \c #Unaligned.
+  * \tparam StrideType optionally specifies strides. By default, Ref implies a contiguous storage along the inner dimension (inner stride==1),
+  *                   but accepts a variable outer stride (leading dimension).
+  *                   This can be overridden by specifying strides.
+  *                   The type passed here must be a specialization of the Stride template, see examples below.
+  *
+  * This class provides a way to write non-template functions taking Eigen objects as parameters while limiting the number of copies.
+  * A Ref<> object can represent either a const expression or a l-value:
+  * \code
+  * // in-out argument:
+  * void foo1(Ref<VectorXf> x);
+  *
+  * // read-only const argument:
+  * void foo2(const Ref<const VectorXf>& x);
+  * \endcode
+  *
+  * In the in-out case, the input argument must satisfy the constraints of the actual Ref<> type, otherwise a compilation issue will be triggered.
+  * By default, a Ref<VectorXf> can reference any dense vector expression of float having a contiguous memory layout.
+  * Likewise, a Ref<MatrixXf> can reference any column-major dense matrix expression of float whose column's elements are contiguously stored with
+  * the possibility to have a constant space in-between each column, i.e. the inner stride must be equal to 1, but the outer stride (or leading dimension)
+  * can be greater than the number of rows.
+  *
+  * In the const case, if the input expression does not match the above requirement, then it is evaluated into a temporary before being passed to the function.
+  * Here are some examples:
+  * \code
+  * MatrixXf A;
+  * VectorXf a;
+  * foo1(a.head());             // OK
+  * foo1(A.col());              // OK
+  * foo1(A.row());              // Compilation error because here innerstride!=1
+  * foo2(A.row());              // Compilation error because A.row() is a 1xN object while foo2 is expecting a Nx1 object
+  * foo2(A.row().transpose());  // The row is copied into a contiguous temporary
+  * foo2(2*a);                  // The expression is evaluated into a temporary
+  * foo2(A.col().segment(2,4)); // No temporary
+  * \endcode
+  *
+  * The range of inputs that can be referenced without temporary can be enlarged using the last two template parameters.
+  * Here is an example accepting an innerstride!=1:
+  * \code
+  * // in-out argument:
+  * void foo3(Ref<VectorXf,0,InnerStride<> > x);
+  * foo3(A.row());              // OK
+  * \endcode
+  * The downside here is that the function foo3 might be significantly slower than foo1 because it won't be able to exploit vectorization, and will involve more
+  * expensive address computations even if the input is contiguously stored in memory. To overcome this issue, one might propose to overload internally calling a
+  * template function, e.g.:
+  * \code
+  * // in the .h:
+  * void foo(const Ref<MatrixXf>& A);
+  * void foo(const Ref<MatrixXf,0,Stride<> >& A);
+  *
+  * // in the .cpp:
+  * template<typename TypeOfA> void foo_impl(const TypeOfA& A) {
+  *     ... // crazy code goes here
+  * }
+  * void foo(const Ref<MatrixXf>& A) { foo_impl(A); }
+  * void foo(const Ref<MatrixXf,0,Stride<> >& A) { foo_impl(A); }
+  * \endcode
+  *
+  * See also the following stackoverflow questions for further references:
+  *  - <a href="http://stackoverflow.com/questions/21132538/correct-usage-of-the-eigenref-class">Correct usage of the Eigen::Ref<> class</a>
+  *
+  * \sa PlainObjectBase::Map(), \ref TopicStorageOrders
+  */
+template<typename PlainObjectType, int Options, typename StrideType> class Ref
+  : public RefBase<Ref<PlainObjectType, Options, StrideType> >
+{
+  private:
+    typedef internal::traits<Ref> Traits;
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(const PlainObjectBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0);
+  public:
+
+    typedef RefBase<Ref> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Ref)
+
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(PlainObjectBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      // Construction must pass since we will not create temprary storage in the non-const case.
+      const bool success = Base::construct(expr.derived());
+      EIGEN_UNUSED_VARIABLE(success)
+      eigen_assert(success);
+    }
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(const DenseBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0)
+    #else
+    /** Implicit constructor from any dense expression */
+    template<typename Derived>
+    inline Ref(DenseBase<Derived>& expr)
+    #endif
+    {
+      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      EIGEN_STATIC_ASSERT(!Derived::IsPlainObjectBase,THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      // Construction must pass since we will not create temporary storage in the non-const case.
+      const bool success = Base::construct(expr.const_cast_derived());
+      EIGEN_UNUSED_VARIABLE(success)
+      eigen_assert(success);
+    }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Ref)
+
+};
+
+// this is the const ref version
+template<typename TPlainObjectType, int Options, typename StrideType> class Ref<const TPlainObjectType, Options, StrideType>
+  : public RefBase<Ref<const TPlainObjectType, Options, StrideType> >
+{
+    typedef internal::traits<Ref> Traits;
+  public:
+
+    typedef RefBase<Ref> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Ref)
+
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(const DenseBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::ScalarTypeMatch),Derived>::type* = 0)
+    {
+//      std::cout << match_helper<Derived>::HasDirectAccess << "," << match_helper<Derived>::OuterStrideMatch << "," << match_helper<Derived>::InnerStrideMatch << "\n";
+//      std::cout << int(StrideType::OuterStrideAtCompileTime) << " - " << int(Derived::OuterStrideAtCompileTime) << "\n";
+//      std::cout << int(StrideType::InnerStrideAtCompileTime) << " - " << int(Derived::InnerStrideAtCompileTime) << "\n";
+      construct(expr.derived(), typename Traits::template match<Derived>::type());
+    }
+
+    EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) {
+      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
+    }
+
+    template<typename OtherRef>
+    EIGEN_DEVICE_FUNC inline Ref(const RefBase<OtherRef>& other) {
+      construct(other.derived(), typename Traits::template match<OtherRef>::type());
+    }
+
+  protected:
+
+    template<typename Expression>
+    EIGEN_DEVICE_FUNC void construct(const Expression& expr,internal::true_type)
+    {
+      // Check if we can use the underlying expr's storage directly, otherwise call the copy version.
+      if (!Base::construct(expr)) {
+        construct(expr, internal::false_type());
+      }
+    }
+
+    template<typename Expression>
+    EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type)
+    {
+      internal::call_assignment_no_alias(m_object,expr,internal::assign_op<Scalar,Scalar>());
+      Base::construct(m_object);
+    }
+
+  protected:
+    TPlainObjectType m_object;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_REF_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Replicate.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Replicate.h
new file mode 100644
index 00000000..ab5be7e6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Replicate.h
@@ -0,0 +1,142 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REPLICATE_H
+#define EIGEN_REPLICATE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename MatrixType,int RowFactor,int ColFactor>
+struct traits<Replicate<MatrixType,RowFactor,ColFactor> >
+ : traits<MatrixType>
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename traits<MatrixType>::XprKind XprKind;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    RowsAtCompileTime = RowFactor==Dynamic || int(MatrixType::RowsAtCompileTime)==Dynamic
+                      ? Dynamic
+                      : RowFactor * MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = ColFactor==Dynamic || int(MatrixType::ColsAtCompileTime)==Dynamic
+                      ? Dynamic
+                      : ColFactor * MatrixType::ColsAtCompileTime,
+   //FIXME we don't propagate the max sizes !!!
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    IsRowMajor = MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1 ? 1
+               : MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1 ? 0
+               : (MatrixType::Flags & RowMajorBit) ? 1 : 0,
+
+    // FIXME enable DirectAccess with negative strides?
+    Flags = IsRowMajor ? RowMajorBit : 0
+  };
+};
+}
+
+/**
+  * \class Replicate
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the multiple replication of a matrix or vector
+  *
+  * \tparam MatrixType the type of the object we are replicating
+  * \tparam RowFactor number of repetitions at compile time along the vertical direction, can be Dynamic.
+  * \tparam ColFactor number of repetitions at compile time along the horizontal direction, can be Dynamic.
+  *
+  * This class represents an expression of the multiple replication of a matrix or vector.
+  * It is the return type of DenseBase::replicate() and most of the time
+  * this is the only way it is used.
+  *
+  * \sa DenseBase::replicate()
+  */
+template<typename MatrixType,int RowFactor,int ColFactor> class Replicate
+  : public internal::dense_xpr_base< Replicate<MatrixType,RowFactor,ColFactor> >::type
+{
+    typedef typename internal::traits<Replicate>::MatrixTypeNested MatrixTypeNested;
+    typedef typename internal::traits<Replicate>::_MatrixTypeNested _MatrixTypeNested;
+  public:
+
+    typedef typename internal::dense_xpr_base<Replicate>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Replicate)
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+    template<typename OriginalMatrixType>
+    EIGEN_DEVICE_FUNC
+    inline explicit Replicate(const OriginalMatrixType& matrix)
+      : m_matrix(matrix), m_rowFactor(RowFactor), m_colFactor(ColFactor)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<typename internal::remove_const<MatrixType>::type,OriginalMatrixType>::value),
+                          THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE)
+      eigen_assert(RowFactor!=Dynamic && ColFactor!=Dynamic);
+    }
+
+    template<typename OriginalMatrixType>
+    EIGEN_DEVICE_FUNC
+    inline Replicate(const OriginalMatrixType& matrix, Index rowFactor, Index colFactor)
+      : m_matrix(matrix), m_rowFactor(rowFactor), m_colFactor(colFactor)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<typename internal::remove_const<MatrixType>::type,OriginalMatrixType>::value),
+                          THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE)
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const { return m_matrix.rows() * m_rowFactor.value(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const { return m_matrix.cols() * m_colFactor.value(); }
+
+    EIGEN_DEVICE_FUNC
+    const _MatrixTypeNested& nestedExpression() const
+    {
+      return m_matrix;
+    }
+
+  protected:
+    MatrixTypeNested m_matrix;
+    const internal::variable_if_dynamic<Index, RowFactor> m_rowFactor;
+    const internal::variable_if_dynamic<Index, ColFactor> m_colFactor;
+};
+
+/**
+  * \return an expression of the replication of \c *this
+  *
+  * Example: \include MatrixBase_replicate.cpp
+  * Output: \verbinclude MatrixBase_replicate.out
+  *
+  * \sa VectorwiseOp::replicate(), DenseBase::replicate(Index,Index), class Replicate
+  */
+template<typename Derived>
+template<int RowFactor, int ColFactor>
+EIGEN_DEVICE_FUNC const Replicate<Derived,RowFactor,ColFactor>
+DenseBase<Derived>::replicate() const
+{
+  return Replicate<Derived,RowFactor,ColFactor>(derived());
+}
+
+/**
+  * \return an expression of the replication of each column (or row) of \c *this
+  *
+  * Example: \include DirectionWise_replicate_int.cpp
+  * Output: \verbinclude DirectionWise_replicate_int.out
+  *
+  * \sa VectorwiseOp::replicate(), DenseBase::replicate(), class Replicate
+  */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC const typename VectorwiseOp<ExpressionType,Direction>::ReplicateReturnType
+VectorwiseOp<ExpressionType,Direction>::replicate(Index factor) const
+{
+  return typename VectorwiseOp<ExpressionType,Direction>::ReplicateReturnType
+          (_expression(),Direction==Vertical?factor:1,Direction==Horizontal?factor:1);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REPLICATE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Reshaped.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Reshaped.h
new file mode 100644
index 00000000..52de73b6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Reshaped.h
@@ -0,0 +1,454 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2014 yoco <peter.xiau@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_RESHAPED_H
+#define EIGEN_RESHAPED_H
+
+namespace Eigen {
+
+/** \class Reshaped
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a fixed-size or dynamic-size reshape
+  *
+  * \tparam XprType the type of the expression in which we are taking a reshape
+  * \tparam Rows the number of rows of the reshape we are taking at compile time (optional)
+  * \tparam Cols the number of columns of the reshape we are taking at compile time (optional)
+  * \tparam Order can be ColMajor or RowMajor, default is ColMajor.
+  *
+  * This class represents an expression of either a fixed-size or dynamic-size reshape.
+  * It is the return type of DenseBase::reshaped(NRowsType,NColsType) and
+  * most of the time this is the only way it is used.
+  *
+  * However, in C++98, if you want to directly maniputate reshaped expressions,
+  * for instance if you want to write a function returning such an expression, you
+  * will need to use this class. In C++11, it is advised to use the \em auto
+  * keyword for such use cases.
+  *
+  * Here is an example illustrating the dynamic case:
+  * \include class_Reshaped.cpp
+  * Output: \verbinclude class_Reshaped.out
+  *
+  * Here is an example illustrating the fixed-size case:
+  * \include class_FixedReshaped.cpp
+  * Output: \verbinclude class_FixedReshaped.out
+  *
+  * \sa DenseBase::reshaped(NRowsType,NColsType)
+  */
+
+namespace internal {
+
+template<typename XprType, int Rows, int Cols, int Order>
+struct traits<Reshaped<XprType, Rows, Cols, Order> > : traits<XprType>
+{
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename traits<XprType>::StorageKind StorageKind;
+  typedef typename traits<XprType>::XprKind XprKind;
+  enum{
+    MatrixRows = traits<XprType>::RowsAtCompileTime,
+    MatrixCols = traits<XprType>::ColsAtCompileTime,
+    RowsAtCompileTime = Rows,
+    ColsAtCompileTime = Cols,
+    MaxRowsAtCompileTime = Rows,
+    MaxColsAtCompileTime = Cols,
+    XpxStorageOrder = ((int(traits<XprType>::Flags) & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor,
+    ReshapedStorageOrder = (RowsAtCompileTime == 1 && ColsAtCompileTime != 1) ? RowMajor
+                         : (ColsAtCompileTime == 1 && RowsAtCompileTime != 1) ? ColMajor
+                         : XpxStorageOrder,
+    HasSameStorageOrderAsXprType = (ReshapedStorageOrder == XpxStorageOrder),
+    InnerSize = (ReshapedStorageOrder==int(RowMajor)) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+    InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
+                             ? int(inner_stride_at_compile_time<XprType>::ret)
+                             : Dynamic,
+    OuterStrideAtCompileTime = Dynamic,
+
+    HasDirectAccess = internal::has_direct_access<XprType>::ret
+                    && (Order==int(XpxStorageOrder))
+                    && ((evaluator<XprType>::Flags&LinearAccessBit)==LinearAccessBit),
+
+    MaskPacketAccessBit = (InnerSize == Dynamic || (InnerSize % packet_traits<Scalar>::size) == 0)
+                       && (InnerStrideAtCompileTime == 1)
+                        ? PacketAccessBit : 0,
+    //MaskAlignedBit = ((OuterStrideAtCompileTime!=Dynamic) && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % 16) == 0)) ? AlignedBit : 0,
+    FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
+    FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
+    FlagsRowMajorBit = (ReshapedStorageOrder==int(RowMajor)) ? RowMajorBit : 0,
+    FlagsDirectAccessBit = HasDirectAccess ? DirectAccessBit : 0,
+    Flags0 = traits<XprType>::Flags & ( (HereditaryBits & ~RowMajorBit) | MaskPacketAccessBit),
+
+    Flags = (Flags0 | FlagsLinearAccessBit | FlagsLvalueBit | FlagsRowMajorBit | FlagsDirectAccessBit)
+  };
+};
+
+template<typename XprType, int Rows, int Cols, int Order, bool HasDirectAccess> class ReshapedImpl_dense;
+
+} // end namespace internal
+
+template<typename XprType, int Rows, int Cols, int Order, typename StorageKind> class ReshapedImpl;
+
+template<typename XprType, int Rows, int Cols, int Order> class Reshaped
+  : public ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind>
+{
+    typedef ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind> Impl;
+  public:
+    //typedef typename Impl::Base Base;
+    typedef Impl Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Reshaped)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reshaped)
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline Reshaped(XprType& xpr)
+      : Impl(xpr)
+    {
+      EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
+      eigen_assert(Rows * Cols == xpr.rows() * xpr.cols());
+    }
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline Reshaped(XprType& xpr,
+          Index reshapeRows, Index reshapeCols)
+      : Impl(xpr, reshapeRows, reshapeCols)
+    {
+      eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==reshapeRows)
+          && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==reshapeCols));
+      eigen_assert(reshapeRows * reshapeCols == xpr.rows() * xpr.cols());
+    }
+};
+
+// The generic default implementation for dense reshape simply forward to the internal::ReshapedImpl_dense
+// that must be specialized for direct and non-direct access...
+template<typename XprType, int Rows, int Cols, int Order>
+class ReshapedImpl<XprType, Rows, Cols, Order, Dense>
+  : public internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,internal::traits<Reshaped<XprType,Rows,Cols,Order> >::HasDirectAccess>
+{
+    typedef internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,internal::traits<Reshaped<XprType,Rows,Cols,Order> >::HasDirectAccess> Impl;
+  public:
+    typedef Impl Base;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl)
+    EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr) : Impl(xpr) {}
+    EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr, Index reshapeRows, Index reshapeCols)
+      : Impl(xpr, reshapeRows, reshapeCols) {}
+};
+
+namespace internal {
+
+/** \internal Internal implementation of dense Reshaped in the general case. */
+template<typename XprType, int Rows, int Cols, int Order>
+class ReshapedImpl_dense<XprType,Rows,Cols,Order,false>
+  : public internal::dense_xpr_base<Reshaped<XprType, Rows, Cols, Order> >::type
+{
+    typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType;
+  public:
+
+    typedef typename internal::dense_xpr_base<ReshapedType>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense)
+
+    typedef typename internal::ref_selector<XprType>::non_const_type MatrixTypeNested;
+    typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+    class InnerIterator;
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline ReshapedImpl_dense(XprType& xpr)
+      : m_xpr(xpr), m_rows(Rows), m_cols(Cols)
+    {}
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline ReshapedImpl_dense(XprType& xpr, Index nRows, Index nCols)
+      : m_xpr(xpr), m_rows(nRows), m_cols(nCols)
+    {}
+
+    EIGEN_DEVICE_FUNC Index rows() const { return m_rows; }
+    EIGEN_DEVICE_FUNC Index cols() const { return m_cols; }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \sa MapBase::data() */
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const;
+    EIGEN_DEVICE_FUNC inline Index innerStride() const;
+    EIGEN_DEVICE_FUNC inline Index outerStride() const;
+    #endif
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<XprType>::type&
+    nestedExpression() const { return m_xpr; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC
+    typename internal::remove_reference<XprType>::type&
+    nestedExpression() { return m_xpr; }
+
+  protected:
+
+    MatrixTypeNested m_xpr;
+    const internal::variable_if_dynamic<Index, Rows> m_rows;
+    const internal::variable_if_dynamic<Index, Cols> m_cols;
+};
+
+
+/** \internal Internal implementation of dense Reshaped in the direct access case. */
+template<typename XprType, int Rows, int Cols, int Order>
+class ReshapedImpl_dense<XprType, Rows, Cols, Order, true>
+  : public MapBase<Reshaped<XprType, Rows, Cols, Order> >
+{
+    typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType;
+    typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+  public:
+
+    typedef MapBase<ReshapedType> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense)
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline ReshapedImpl_dense(XprType& xpr)
+      : Base(xpr.data()), m_xpr(xpr)
+    {}
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline ReshapedImpl_dense(XprType& xpr, Index nRows, Index nCols)
+      : Base(xpr.data(), nRows, nCols),
+        m_xpr(xpr)
+    {}
+
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
+    {
+      return m_xpr;
+    }
+
+    EIGEN_DEVICE_FUNC
+    XprType& nestedExpression() { return m_xpr; }
+
+    /** \sa MapBase::innerStride() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const
+    {
+      return m_xpr.innerStride();
+    }
+
+    /** \sa MapBase::outerStride() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const
+    {
+      return ((Flags&RowMajorBit)==RowMajorBit) ? this->cols() : this->rows();
+    }
+
+  protected:
+
+    XprTypeNested m_xpr;
+};
+
+// Evaluators
+template<typename ArgType, int Rows, int Cols, int Order, bool HasDirectAccess> struct reshaped_evaluator;
+
+template<typename ArgType, int Rows, int Cols, int Order>
+struct evaluator<Reshaped<ArgType, Rows, Cols, Order> >
+  : reshaped_evaluator<ArgType, Rows, Cols, Order, traits<Reshaped<ArgType,Rows,Cols,Order> >::HasDirectAccess>
+{
+  typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
+  typedef typename XprType::Scalar Scalar;
+  // TODO: should check for smaller packet types
+  typedef typename packet_traits<Scalar>::type PacketScalar;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    HasDirectAccess = traits<XprType>::HasDirectAccess,
+
+//     RowsAtCompileTime = traits<XprType>::RowsAtCompileTime,
+//     ColsAtCompileTime = traits<XprType>::ColsAtCompileTime,
+//     MaxRowsAtCompileTime = traits<XprType>::MaxRowsAtCompileTime,
+//     MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime,
+//
+//     InnerStrideAtCompileTime = traits<XprType>::HasSameStorageOrderAsXprType
+//                              ? int(inner_stride_at_compile_time<ArgType>::ret)
+//                              : Dynamic,
+//     OuterStrideAtCompileTime = Dynamic,
+
+    FlagsLinearAccessBit = (traits<XprType>::RowsAtCompileTime == 1 || traits<XprType>::ColsAtCompileTime == 1 || HasDirectAccess) ? LinearAccessBit : 0,
+    FlagsRowMajorBit = (traits<XprType>::ReshapedStorageOrder==int(RowMajor)) ? RowMajorBit : 0,
+    FlagsDirectAccessBit =  HasDirectAccess ? DirectAccessBit : 0,
+    Flags0 = evaluator<ArgType>::Flags & (HereditaryBits & ~RowMajorBit),
+    Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit | FlagsDirectAccessBit,
+
+    PacketAlignment = unpacket_traits<PacketScalar>::alignment,
+    Alignment = evaluator<ArgType>::Alignment
+  };
+  typedef reshaped_evaluator<ArgType, Rows, Cols, Order, HasDirectAccess> reshaped_evaluator_type;
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : reshaped_evaluator_type(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+};
+
+template<typename ArgType, int Rows, int Cols, int Order>
+struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ false>
+  : evaluator_base<Reshaped<ArgType, Rows, Cols, Order> >
+{
+  typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost /* TODO + cost of index computations */,
+
+    Flags = (evaluator<ArgType>::Flags & (HereditaryBits /*| LinearAccessBit | DirectAccessBit*/)),
+
+    Alignment = 0
+  };
+
+  EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_xpr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  typedef std::pair<Index, Index> RowCol;
+
+  inline RowCol index_remap(Index rowId, Index colId) const
+  {
+    if(Order==ColMajor)
+    {
+      const Index nth_elem_idx = colId * m_xpr.rows() + rowId;
+      return RowCol(nth_elem_idx % m_xpr.nestedExpression().rows(),
+                    nth_elem_idx / m_xpr.nestedExpression().rows());
+    }
+    else
+    {
+      const Index nth_elem_idx = colId + rowId * m_xpr.cols();
+      return RowCol(nth_elem_idx / m_xpr.nestedExpression().cols(),
+                    nth_elem_idx % m_xpr.nestedExpression().cols());
+    }
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline Scalar& coeffRef(Index rowId, Index colId)
+  {
+    EIGEN_STATIC_ASSERT_LVALUE(XprType)
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.coeffRef(row_col.first, row_col.second);
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline const Scalar& coeffRef(Index rowId, Index colId) const
+  {
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.coeffRef(row_col.first, row_col.second);
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
+  {
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.coeff(row_col.first, row_col.second);
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline Scalar& coeffRef(Index index)
+  {
+    EIGEN_STATIC_ASSERT_LVALUE(XprType)
+    const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
+                                       Rows == 1 ? index : 0);
+    return m_argImpl.coeffRef(row_col.first, row_col.second);
+
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline const Scalar& coeffRef(Index index) const
+  {
+    const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
+                                       Rows == 1 ? index : 0);
+    return m_argImpl.coeffRef(row_col.first, row_col.second);
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline const CoeffReturnType coeff(Index index) const
+  {
+    const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
+                                       Rows == 1 ? index : 0);
+    return m_argImpl.coeff(row_col.first, row_col.second);
+  }
+#if 0
+  EIGEN_DEVICE_FUNC
+  template<int LoadMode>
+  inline PacketScalar packet(Index rowId, Index colId) const
+  {
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second);
+
+  }
+
+  template<int LoadMode>
+  EIGEN_DEVICE_FUNC
+  inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
+  {
+    const RowCol row_col = index_remap(rowId, colId);
+    m_argImpl.const_cast_derived().template writePacket<Unaligned>
+            (row_col.first, row_col.second, val);
+  }
+
+  template<int LoadMode>
+  EIGEN_DEVICE_FUNC
+  inline PacketScalar packet(Index index) const
+  {
+    const RowCol row_col = index_remap(RowsAtCompileTime == 1 ? 0 : index,
+                                        RowsAtCompileTime == 1 ? index : 0);
+    return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second);
+  }
+
+  template<int LoadMode>
+  EIGEN_DEVICE_FUNC
+  inline void writePacket(Index index, const PacketScalar& val)
+  {
+    const RowCol row_col = index_remap(RowsAtCompileTime == 1 ? 0 : index,
+                                        RowsAtCompileTime == 1 ? index : 0);
+    return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second, val);
+  }
+#endif
+protected:
+
+  evaluator<ArgType> m_argImpl;
+  const XprType& m_xpr;
+
+};
+
+template<typename ArgType, int Rows, int Cols, int Order>
+struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ true>
+: mapbase_evaluator<Reshaped<ArgType, Rows, Cols, Order>,
+                      typename Reshaped<ArgType, Rows, Cols, Order>::PlainObject>
+{
+  typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
+  typedef typename XprType::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr)
+    : mapbase_evaluator<XprType, typename XprType::PlainObject>(xpr)
+  {
+    // TODO: for the 3.4 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime
+    eigen_assert(((internal::UIntPtr(xpr.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned");
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_RESHAPED_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/ReturnByValue.h b/C++/yolo_bytetrack/include/Eigen/src/Core/ReturnByValue.h
new file mode 100644
index 00000000..4dad13ea
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/ReturnByValue.h
@@ -0,0 +1,119 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_RETURNBYVALUE_H
+#define EIGEN_RETURNBYVALUE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Derived>
+struct traits<ReturnByValue<Derived> >
+  : public traits<typename traits<Derived>::ReturnType>
+{
+  enum {
+    // We're disabling the DirectAccess because e.g. the constructor of
+    // the Block-with-DirectAccess expression requires to have a coeffRef method.
+    // Also, we don't want to have to implement the stride stuff.
+    Flags = (traits<typename traits<Derived>::ReturnType>::Flags
+             | EvalBeforeNestingBit) & ~DirectAccessBit
+  };
+};
+
+/* The ReturnByValue object doesn't even have a coeff() method.
+ * So the only way that nesting it in an expression can work, is by evaluating it into a plain matrix.
+ * So internal::nested always gives the plain return matrix type.
+ *
+ * FIXME: I don't understand why we need this specialization: isn't this taken care of by the EvalBeforeNestingBit ??
+ * Answer: EvalBeforeNestingBit should be deprecated since we have the evaluators
+ */
+template<typename Derived,int n,typename PlainObject>
+struct nested_eval<ReturnByValue<Derived>, n, PlainObject>
+{
+  typedef typename traits<Derived>::ReturnType type;
+};
+
+} // end namespace internal
+
+/** \class ReturnByValue
+  * \ingroup Core_Module
+  *
+  */
+template<typename Derived> class ReturnByValue
+  : public internal::dense_xpr_base< ReturnByValue<Derived> >::type, internal::no_assignment_operator
+{
+  public:
+    typedef typename internal::traits<Derived>::ReturnType ReturnType;
+
+    typedef typename internal::dense_xpr_base<ReturnByValue>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue)
+
+    template<typename Dest>
+    EIGEN_DEVICE_FUNC
+    inline void evalTo(Dest& dst) const
+    { static_cast<const Derived*>(this)->evalTo(dst); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return static_cast<const Derived*>(this)->rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return static_cast<const Derived*>(this)->cols(); }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+#define Unusable YOU_ARE_TRYING_TO_ACCESS_A_SINGLE_COEFFICIENT_IN_A_SPECIAL_EXPRESSION_WHERE_THAT_IS_NOT_ALLOWED_BECAUSE_THAT_WOULD_BE_INEFFICIENT
+    class Unusable{
+      Unusable(const Unusable&) {}
+      Unusable& operator=(const Unusable&) {return *this;}
+    };
+    const Unusable& coeff(Index) const { return *reinterpret_cast<const Unusable*>(this); }
+    const Unusable& coeff(Index,Index) const { return *reinterpret_cast<const Unusable*>(this); }
+    Unusable& coeffRef(Index) { return *reinterpret_cast<Unusable*>(this); }
+    Unusable& coeffRef(Index,Index) { return *reinterpret_cast<Unusable*>(this); }
+#undef Unusable
+#endif
+};
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Derived& DenseBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  other.evalTo(derived());
+  return derived();
+}
+
+namespace internal {
+
+// Expression is evaluated in a temporary; default implementation of Assignment is bypassed so that
+// when a ReturnByValue expression is assigned, the evaluator is not constructed.
+// TODO: Finalize port to new regime; ReturnByValue should not exist in the expression world
+
+template<typename Derived>
+struct evaluator<ReturnByValue<Derived> >
+  : public evaluator<typename internal::traits<Derived>::ReturnType>
+{
+  typedef ReturnByValue<Derived> XprType;
+  typedef typename internal::traits<Derived>::ReturnType PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    xpr.evalTo(m_result);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_RETURNBYVALUE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Reverse.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Reverse.h
new file mode 100644
index 00000000..28cdd76a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Reverse.h
@@ -0,0 +1,217 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Ricard Marxer <email@ricardmarxer.com>
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REVERSE_H
+#define EIGEN_REVERSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatrixType, int Direction>
+struct traits<Reverse<MatrixType, Direction> >
+ : traits<MatrixType>
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename traits<MatrixType>::XprKind XprKind;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    Flags = _MatrixTypeNested::Flags & (RowMajorBit | LvalueBit)
+  };
+};
+
+template<typename PacketType, bool ReversePacket> struct reverse_packet_cond
+{
+  static inline PacketType run(const PacketType& x) { return preverse(x); }
+};
+
+template<typename PacketType> struct reverse_packet_cond<PacketType,false>
+{
+  static inline PacketType run(const PacketType& x) { return x; }
+};
+
+} // end namespace internal
+
+/** \class Reverse
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the reverse of a vector or matrix
+  *
+  * \tparam MatrixType the type of the object of which we are taking the reverse
+  * \tparam Direction defines the direction of the reverse operation, can be Vertical, Horizontal, or BothDirections
+  *
+  * This class represents an expression of the reverse of a vector.
+  * It is the return type of MatrixBase::reverse() and VectorwiseOp::reverse()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::reverse(), VectorwiseOp::reverse()
+  */
+template<typename MatrixType, int Direction> class Reverse
+  : public internal::dense_xpr_base< Reverse<MatrixType, Direction> >::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<Reverse>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Reverse)
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+    using Base::IsRowMajor;
+
+  protected:
+    enum {
+      PacketSize = internal::packet_traits<Scalar>::size,
+      IsColMajor = !IsRowMajor,
+      ReverseRow = (Direction == Vertical)   || (Direction == BothDirections),
+      ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
+      OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
+      OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1,
+      ReversePacket = (Direction == BothDirections)
+                    || ((Direction == Vertical)   && IsColMajor)
+                    || ((Direction == Horizontal) && IsRowMajor)
+    };
+    typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> reverse_packet;
+  public:
+
+    EIGEN_DEVICE_FUNC explicit inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reverse)
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+    EIGEN_DEVICE_FUNC inline Index innerStride() const
+    {
+      return -m_matrix.innerStride();
+    }
+
+    EIGEN_DEVICE_FUNC const typename internal::remove_all<typename MatrixType::Nested>::type&
+    nestedExpression() const
+    {
+      return m_matrix;
+    }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+};
+
+/** \returns an expression of the reverse of *this.
+  *
+  * Example: \include MatrixBase_reverse.cpp
+  * Output: \verbinclude MatrixBase_reverse.out
+  *
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::ReverseReturnType
+DenseBase<Derived>::reverse()
+{
+  return ReverseReturnType(derived());
+}
+
+
+//reverse const overload moved DenseBase.h due to a CUDA compiler bug
+
+/** This is the "in place" version of reverse: it reverses \c *this.
+  *
+  * In most cases it is probably better to simply use the reversed expression
+  * of a matrix. However, when reversing the matrix data itself is really needed,
+  * then this "in-place" version is probably the right choice because it provides
+  * the following additional benefits:
+  *  - less error prone: doing the same operation with .reverse() requires special care:
+  *    \code m = m.reverse().eval(); \endcode
+  *  - this API enables reverse operations without the need for a temporary
+  *  - it allows future optimizations (cache friendliness, etc.)
+  *
+  * \sa VectorwiseOp::reverseInPlace(), reverse() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void DenseBase<Derived>::reverseInPlace()
+{
+  if(cols()>rows())
+  {
+    Index half = cols()/2;
+    leftCols(half).swap(rightCols(half).reverse());
+    if((cols()%2)==1)
+    {
+      Index half2 = rows()/2;
+      col(half).head(half2).swap(col(half).tail(half2).reverse());
+    }
+  }
+  else
+  {
+    Index half = rows()/2;
+    topRows(half).swap(bottomRows(half).reverse());
+    if((rows()%2)==1)
+    {
+      Index half2 = cols()/2;
+      row(half).head(half2).swap(row(half).tail(half2).reverse());
+    }
+  }
+}
+
+namespace internal {
+
+template<int Direction>
+struct vectorwise_reverse_inplace_impl;
+
+template<>
+struct vectorwise_reverse_inplace_impl<Vertical>
+{
+  template<typename ExpressionType>
+  static void run(ExpressionType &xpr)
+  {
+    const int HalfAtCompileTime = ExpressionType::RowsAtCompileTime==Dynamic?Dynamic:ExpressionType::RowsAtCompileTime/2;
+    Index half = xpr.rows()/2;
+    xpr.topRows(fix<HalfAtCompileTime>(half))
+       .swap(xpr.bottomRows(fix<HalfAtCompileTime>(half)).colwise().reverse());
+  }
+};
+
+template<>
+struct vectorwise_reverse_inplace_impl<Horizontal>
+{
+  template<typename ExpressionType>
+  static void run(ExpressionType &xpr)
+  {
+    const int HalfAtCompileTime = ExpressionType::ColsAtCompileTime==Dynamic?Dynamic:ExpressionType::ColsAtCompileTime/2;
+    Index half = xpr.cols()/2;
+    xpr.leftCols(fix<HalfAtCompileTime>(half))
+       .swap(xpr.rightCols(fix<HalfAtCompileTime>(half)).rowwise().reverse());
+  }
+};
+
+} // end namespace internal
+
+/** This is the "in place" version of VectorwiseOp::reverse: it reverses each column or row of \c *this.
+  *
+  * In most cases it is probably better to simply use the reversed expression
+  * of a matrix. However, when reversing the matrix data itself is really needed,
+  * then this "in-place" version is probably the right choice because it provides
+  * the following additional benefits:
+  *  - less error prone: doing the same operation with .reverse() requires special care:
+  *    \code m = m.reverse().eval(); \endcode
+  *  - this API enables reverse operations without the need for a temporary
+  *
+  * \sa DenseBase::reverseInPlace(), reverse() */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC void VectorwiseOp<ExpressionType,Direction>::reverseInPlace()
+{
+  internal::vectorwise_reverse_inplace_impl<Direction>::run(m_matrix);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REVERSE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Select.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Select.h
new file mode 100644
index 00000000..7c86bf87
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Select.h
@@ -0,0 +1,164 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELECT_H
+#define EIGEN_SELECT_H
+
+namespace Eigen {
+
+/** \class Select
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a coefficient wise version of the C++ ternary operator ?:
+  *
+  * \param ConditionMatrixType the type of the \em condition expression which must be a boolean matrix
+  * \param ThenMatrixType the type of the \em then expression
+  * \param ElseMatrixType the type of the \em else expression
+  *
+  * This class represents an expression of a coefficient wise version of the C++ ternary operator ?:.
+  * It is the return type of DenseBase::select() and most of the time this is the only way it is used.
+  *
+  * \sa DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const
+  */
+
+namespace internal {
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
+struct traits<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
+ : traits<ThenMatrixType>
+{
+  typedef typename traits<ThenMatrixType>::Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef typename traits<ThenMatrixType>::XprKind XprKind;
+  typedef typename ConditionMatrixType::Nested ConditionMatrixNested;
+  typedef typename ThenMatrixType::Nested ThenMatrixNested;
+  typedef typename ElseMatrixType::Nested ElseMatrixNested;
+  enum {
+    RowsAtCompileTime = ConditionMatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = ConditionMatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = ConditionMatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = ConditionMatrixType::MaxColsAtCompileTime,
+    Flags = (unsigned int)ThenMatrixType::Flags & ElseMatrixType::Flags & RowMajorBit
+  };
+};
+}
+
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
+class Select : public internal::dense_xpr_base< Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >::type,
+               internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<Select>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Select)
+
+    inline EIGEN_DEVICE_FUNC
+    Select(const ConditionMatrixType& a_conditionMatrix,
+           const ThenMatrixType& a_thenMatrix,
+           const ElseMatrixType& a_elseMatrix)
+      : m_condition(a_conditionMatrix), m_then(a_thenMatrix), m_else(a_elseMatrix)
+    {
+      eigen_assert(m_condition.rows() == m_then.rows() && m_condition.rows() == m_else.rows());
+      eigen_assert(m_condition.cols() == m_then.cols() && m_condition.cols() == m_else.cols());
+    }
+
+    inline EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_condition.rows(); }
+    inline EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_condition.cols(); }
+
+    inline EIGEN_DEVICE_FUNC
+    const Scalar coeff(Index i, Index j) const
+    {
+      if (m_condition.coeff(i,j))
+        return m_then.coeff(i,j);
+      else
+        return m_else.coeff(i,j);
+    }
+
+    inline EIGEN_DEVICE_FUNC
+    const Scalar coeff(Index i) const
+    {
+      if (m_condition.coeff(i))
+        return m_then.coeff(i);
+      else
+        return m_else.coeff(i);
+    }
+
+    inline EIGEN_DEVICE_FUNC const ConditionMatrixType& conditionMatrix() const
+    {
+      return m_condition;
+    }
+
+    inline EIGEN_DEVICE_FUNC const ThenMatrixType& thenMatrix() const
+    {
+      return m_then;
+    }
+
+    inline EIGEN_DEVICE_FUNC const ElseMatrixType& elseMatrix() const
+    {
+      return m_else;
+    }
+
+  protected:
+    typename ConditionMatrixType::Nested m_condition;
+    typename ThenMatrixType::Nested m_then;
+    typename ElseMatrixType::Nested m_else;
+};
+
+
+/** \returns a matrix where each coefficient (i,j) is equal to \a thenMatrix(i,j)
+  * if \c *this(i,j), and \a elseMatrix(i,j) otherwise.
+  *
+  * Example: \include MatrixBase_select.cpp
+  * Output: \verbinclude MatrixBase_select.out
+  *
+  * \sa class Select
+  */
+template<typename Derived>
+template<typename ThenDerived,typename ElseDerived>
+inline EIGEN_DEVICE_FUNC const Select<Derived,ThenDerived,ElseDerived>
+DenseBase<Derived>::select(const DenseBase<ThenDerived>& thenMatrix,
+                            const DenseBase<ElseDerived>& elseMatrix) const
+{
+  return Select<Derived,ThenDerived,ElseDerived>(derived(), thenMatrix.derived(), elseMatrix.derived());
+}
+
+/** Version of DenseBase::select(const DenseBase&, const DenseBase&) with
+  * the \em else expression being a scalar value.
+  *
+  * \sa DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const, class Select
+  */
+template<typename Derived>
+template<typename ThenDerived>
+inline EIGEN_DEVICE_FUNC const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
+DenseBase<Derived>::select(const DenseBase<ThenDerived>& thenMatrix,
+                           const typename ThenDerived::Scalar& elseScalar) const
+{
+  return Select<Derived,ThenDerived,typename ThenDerived::ConstantReturnType>(
+    derived(), thenMatrix.derived(), ThenDerived::Constant(rows(),cols(),elseScalar));
+}
+
+/** Version of DenseBase::select(const DenseBase&, const DenseBase&) with
+  * the \em then expression being a scalar value.
+  *
+  * \sa DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const, class Select
+  */
+template<typename Derived>
+template<typename ElseDerived>
+inline EIGEN_DEVICE_FUNC const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
+DenseBase<Derived>::select(const typename ElseDerived::Scalar& thenScalar,
+                           const DenseBase<ElseDerived>& elseMatrix) const
+{
+  return Select<Derived,typename ElseDerived::ConstantReturnType,ElseDerived>(
+    derived(), ElseDerived::Constant(rows(),cols(),thenScalar), elseMatrix.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELECT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/SelfAdjointView.h b/C++/yolo_bytetrack/include/Eigen/src/Core/SelfAdjointView.h
new file mode 100644
index 00000000..8ce3b372
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/SelfAdjointView.h
@@ -0,0 +1,365 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINTMATRIX_H
+#define EIGEN_SELFADJOINTMATRIX_H
+
+namespace Eigen {
+
+/** \class SelfAdjointView
+  * \ingroup Core_Module
+  *
+  *
+  * \brief Expression of a selfadjoint matrix from a triangular part of a dense matrix
+  *
+  * \param MatrixType the type of the dense matrix storing the coefficients
+  * \param TriangularPart can be either \c #Lower or \c #Upper
+  *
+  * This class is an expression of a sefladjoint matrix from a triangular part of a matrix
+  * with given dense storage of the coefficients. It is the return type of MatrixBase::selfadjointView()
+  * and most of the time this is the only way that it is used.
+  *
+  * \sa class TriangularBase, MatrixBase::selfadjointView()
+  */
+
+namespace internal {
+template<typename MatrixType, unsigned int UpLo>
+struct traits<SelfAdjointView<MatrixType, UpLo> > : traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+  typedef typename remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
+  typedef MatrixType ExpressionType;
+  typedef typename MatrixType::PlainObject FullMatrixType;
+  enum {
+    Mode = UpLo | SelfAdjoint,
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags =  MatrixTypeNestedCleaned::Flags & (HereditaryBits|FlagsLvalueBit)
+           & (~(PacketAccessBit | DirectAccessBit | LinearAccessBit)) // FIXME these flags should be preserved
+  };
+};
+}
+
+
+template<typename _MatrixType, unsigned int UpLo> class SelfAdjointView
+  : public TriangularBase<SelfAdjointView<_MatrixType, UpLo> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef TriangularBase<SelfAdjointView> Base;
+    typedef typename internal::traits<SelfAdjointView>::MatrixTypeNested MatrixTypeNested;
+    typedef typename internal::traits<SelfAdjointView>::MatrixTypeNestedCleaned MatrixTypeNestedCleaned;
+    typedef MatrixTypeNestedCleaned NestedExpression;
+
+    /** \brief The type of coefficients in this matrix */
+    typedef typename internal::traits<SelfAdjointView>::Scalar Scalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType;
+    typedef SelfAdjointView<typename internal::add_const<MatrixType>::type, UpLo> ConstSelfAdjointView;
+
+    enum {
+      Mode = internal::traits<SelfAdjointView>::Mode,
+      Flags = internal::traits<SelfAdjointView>::Flags,
+      TransposeMode = ((int(Mode) & int(Upper)) ? Lower : 0) | ((int(Mode) & int(Lower)) ? Upper : 0)
+    };
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    EIGEN_DEVICE_FUNC
+    explicit inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
+    {
+      EIGEN_STATIC_ASSERT(UpLo==Lower || UpLo==Upper,SELFADJOINTVIEW_ACCEPTS_UPPER_AND_LOWER_MODE_ONLY);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return m_matrix.outerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return m_matrix.innerStride(); }
+
+    /** \sa MatrixBase::coeff()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar coeff(Index row, Index col) const
+    {
+      Base::check_coordinates_internal(row, col);
+      return m_matrix.coeff(row, col);
+    }
+
+    /** \sa MatrixBase::coeffRef()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(SelfAdjointView);
+      Base::check_coordinates_internal(row, col);
+      return m_matrix.coeffRef(row, col);
+    }
+
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    const MatrixTypeNestedCleaned& _expression() const { return m_matrix; }
+
+    EIGEN_DEVICE_FUNC
+    const MatrixTypeNestedCleaned& nestedExpression() const { return m_matrix; }
+    EIGEN_DEVICE_FUNC
+    MatrixTypeNestedCleaned& nestedExpression() { return m_matrix; }
+
+    /** Efficient triangular matrix times vector/matrix product */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<SelfAdjointView,OtherDerived>
+    operator*(const MatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<SelfAdjointView,OtherDerived>(*this, rhs.derived());
+    }
+
+    /** Efficient vector/matrix times triangular matrix product */
+    template<typename OtherDerived> friend
+    EIGEN_DEVICE_FUNC
+    const Product<OtherDerived,SelfAdjointView>
+    operator*(const MatrixBase<OtherDerived>& lhs, const SelfAdjointView& rhs)
+    {
+      return Product<OtherDerived,SelfAdjointView>(lhs.derived(),rhs);
+    }
+
+    friend EIGEN_DEVICE_FUNC
+    const SelfAdjointView<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,MatrixType,product),UpLo>
+    operator*(const Scalar& s, const SelfAdjointView& mat)
+    {
+      return (s*mat.nestedExpression()).template selfadjointView<UpLo>();
+    }
+
+    /** Perform a symmetric rank 2 update of the selfadjoint matrix \c *this:
+      * \f$ this = this + \alpha u v^* + conj(\alpha) v u^* \f$
+      * \returns a reference to \c *this
+      *
+      * The vectors \a u and \c v \b must be column vectors, however they can be
+      * a adjoint expression without any overhead. Only the meaningful triangular
+      * part of the matrix is updated, the rest is left unchanged.
+      *
+      * \sa rankUpdate(const MatrixBase<DerivedU>&, Scalar)
+      */
+    template<typename DerivedU, typename DerivedV>
+    EIGEN_DEVICE_FUNC
+    SelfAdjointView& rankUpdate(const MatrixBase<DerivedU>& u, const MatrixBase<DerivedV>& v, const Scalar& alpha = Scalar(1));
+
+    /** Perform a symmetric rank K update of the selfadjoint matrix \c *this:
+      * \f$ this = this + \alpha ( u u^* ) \f$ where \a u is a vector or matrix.
+      *
+      * \returns a reference to \c *this
+      *
+      * Note that to perform \f$ this = this + \alpha ( u^* u ) \f$ you can simply
+      * call this function with u.adjoint().
+      *
+      * \sa rankUpdate(const MatrixBase<DerivedU>&, const MatrixBase<DerivedV>&, Scalar)
+      */
+    template<typename DerivedU>
+    EIGEN_DEVICE_FUNC
+    SelfAdjointView& rankUpdate(const MatrixBase<DerivedU>& u, const Scalar& alpha = Scalar(1));
+
+    /** \returns an expression of a triangular view extracted from the current selfadjoint view of a given triangular part
+      *
+      * The parameter \a TriMode can have the following values: \c #Upper, \c #StrictlyUpper, \c #UnitUpper,
+      * \c #Lower, \c #StrictlyLower, \c #UnitLower.
+      *
+      * If \c TriMode references the same triangular part than \c *this, then this method simply return a \c TriangularView of the nested expression,
+      * otherwise, the nested expression is first transposed, thus returning a \c TriangularView<Transpose<MatrixType>> object.
+      *
+      * \sa MatrixBase::triangularView(), class TriangularView
+      */
+    template<unsigned int TriMode>
+    EIGEN_DEVICE_FUNC
+    typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)),
+                                   TriangularView<MatrixType,TriMode>,
+                                   TriangularView<typename MatrixType::AdjointReturnType,TriMode> >::type
+    triangularView() const
+    {
+      typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)), MatrixType&, typename MatrixType::ConstTransposeReturnType>::type tmp1(m_matrix);
+      typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)), MatrixType&, typename MatrixType::AdjointReturnType>::type tmp2(tmp1);
+      return typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)),
+                                   TriangularView<MatrixType,TriMode>,
+                                   TriangularView<typename MatrixType::AdjointReturnType,TriMode> >::type(tmp2);
+    }
+
+    typedef SelfAdjointView<const MatrixConjugateReturnType,UpLo> ConjugateReturnType;
+    /** \sa MatrixBase::conjugate() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConjugateReturnType conjugate() const
+    { return ConjugateReturnType(m_matrix.conjugate()); }
+
+    /** \returns an expression of the complex conjugate of \c *this if Cond==true,
+     *           returns \c *this otherwise.
+     */
+    template<bool Cond>
+    EIGEN_DEVICE_FUNC
+    inline typename internal::conditional<Cond,ConjugateReturnType,ConstSelfAdjointView>::type
+    conjugateIf() const
+    {
+      typedef typename internal::conditional<Cond,ConjugateReturnType,ConstSelfAdjointView>::type ReturnType;
+      return ReturnType(m_matrix.template conjugateIf<Cond>());
+    }
+
+    typedef SelfAdjointView<const typename MatrixType::AdjointReturnType,TransposeMode> AdjointReturnType;
+    /** \sa MatrixBase::adjoint() const */
+    EIGEN_DEVICE_FUNC
+    inline const AdjointReturnType adjoint() const
+    { return AdjointReturnType(m_matrix.adjoint()); }
+
+    typedef SelfAdjointView<typename MatrixType::TransposeReturnType,TransposeMode> TransposeReturnType;
+     /** \sa MatrixBase::transpose() */
+    EIGEN_DEVICE_FUNC
+    inline TransposeReturnType transpose()
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      typename MatrixType::TransposeReturnType tmp(m_matrix);
+      return TransposeReturnType(tmp);
+    }
+
+    typedef SelfAdjointView<const typename MatrixType::ConstTransposeReturnType,TransposeMode> ConstTransposeReturnType;
+    /** \sa MatrixBase::transpose() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConstTransposeReturnType transpose() const
+    {
+      return ConstTransposeReturnType(m_matrix.transpose());
+    }
+
+    /** \returns a const expression of the main diagonal of the matrix \c *this
+      *
+      * This method simply returns the diagonal of the nested expression, thus by-passing the SelfAdjointView decorator.
+      *
+      * \sa MatrixBase::diagonal(), class Diagonal */
+    EIGEN_DEVICE_FUNC
+    typename MatrixType::ConstDiagonalReturnType diagonal() const
+    {
+      return typename MatrixType::ConstDiagonalReturnType(m_matrix);
+    }
+
+/////////// Cholesky module ///////////
+
+    const LLT<PlainObject, UpLo> llt() const;
+    const LDLT<PlainObject, UpLo> ldlt() const;
+
+/////////// Eigenvalue module ///////////
+
+    /** Real part of #Scalar */
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    /** Return type of eigenvalues() */
+    typedef Matrix<RealScalar, internal::traits<MatrixType>::ColsAtCompileTime, 1> EigenvaluesReturnType;
+
+    EIGEN_DEVICE_FUNC
+    EigenvaluesReturnType eigenvalues() const;
+    EIGEN_DEVICE_FUNC
+    RealScalar operatorNorm() const;
+
+  protected:
+    MatrixTypeNested m_matrix;
+};
+
+
+// template<typename OtherDerived, typename MatrixType, unsigned int UpLo>
+// internal::selfadjoint_matrix_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> >
+// operator*(const MatrixBase<OtherDerived>& lhs, const SelfAdjointView<MatrixType,UpLo>& rhs)
+// {
+//   return internal::matrix_selfadjoint_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> >(lhs.derived(),rhs);
+// }
+
+// selfadjoint to dense matrix
+
+namespace internal {
+
+// TODO currently a selfadjoint expression has the form SelfAdjointView<.,.>
+//      in the future selfadjoint-ness should be defined by the expression traits
+//      such that Transpose<SelfAdjointView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
+template<typename MatrixType, unsigned int Mode>
+struct evaluator_traits<SelfAdjointView<MatrixType,Mode> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef SelfAdjointShape Shape;
+};
+
+template<int UpLo, int SetOpposite, typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version>
+class triangular_dense_assignment_kernel<UpLo,SelfAdjoint,SetOpposite,DstEvaluatorTypeT,SrcEvaluatorTypeT,Functor,Version>
+  : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> Base;
+  typedef typename Base::DstXprType DstXprType;
+  typedef typename Base::SrcXprType SrcXprType;
+  using Base::m_dst;
+  using Base::m_src;
+  using Base::m_functor;
+public:
+
+  typedef typename Base::DstEvaluatorType DstEvaluatorType;
+  typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
+  typedef typename Base::Scalar Scalar;
+  typedef typename Base::AssignmentTraits AssignmentTraits;
+
+
+  EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {}
+
+  EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
+  {
+    eigen_internal_assert(row!=col);
+    Scalar tmp = m_src.coeff(row,col);
+    m_functor.assignCoeff(m_dst.coeffRef(row,col), tmp);
+    m_functor.assignCoeff(m_dst.coeffRef(col,row), numext::conj(tmp));
+  }
+
+  EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
+  {
+    Base::assignCoeff(id,id);
+  }
+
+  EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index, Index)
+  { eigen_internal_assert(false && "should never be called"); }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Implementation of MatrixBase methods
+***************************************************************************/
+
+/** This is the const version of MatrixBase::selfadjointView() */
+template<typename Derived>
+template<unsigned int UpLo>
+EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type
+MatrixBase<Derived>::selfadjointView() const
+{
+  return typename ConstSelfAdjointViewReturnType<UpLo>::Type(derived());
+}
+
+/** \returns an expression of a symmetric/self-adjoint view extracted from the upper or lower triangular part of the current matrix
+  *
+  * The parameter \a UpLo can be either \c #Upper or \c #Lower
+  *
+  * Example: \include MatrixBase_selfadjointView.cpp
+  * Output: \verbinclude MatrixBase_selfadjointView.out
+  *
+  * \sa class SelfAdjointView
+  */
+template<typename Derived>
+template<unsigned int UpLo>
+EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type
+MatrixBase<Derived>::selfadjointView()
+{
+  return typename SelfAdjointViewReturnType<UpLo>::Type(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINTMATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/SelfCwiseBinaryOp.h b/C++/yolo_bytetrack/include/Eigen/src/Core/SelfCwiseBinaryOp.h
new file mode 100644
index 00000000..7c89c2e2
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/SelfCwiseBinaryOp.h
@@ -0,0 +1,47 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFCWISEBINARYOP_H
+#define EIGEN_SELFCWISEBINARYOP_H
+
+namespace Eigen { 
+
+// TODO generalize the scalar type of 'other'
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator*=(const Scalar& other)
+{
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::mul_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator+=(const Scalar& other)
+{
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::add_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator-=(const Scalar& other)
+{
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::sub_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator/=(const Scalar& other)
+{
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::div_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFCWISEBINARYOP_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Solve.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Solve.h
new file mode 100644
index 00000000..23d5cb70
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Solve.h
@@ -0,0 +1,188 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVE_H
+#define EIGEN_SOLVE_H
+
+namespace Eigen {
+
+template<typename Decomposition, typename RhsType, typename StorageKind> class SolveImpl;
+
+/** \class Solve
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression representing a solving operation
+  *
+  * \tparam Decomposition the type of the matrix or decomposition object
+  * \tparam Rhstype the type of the right-hand side
+  *
+  * This class represents an expression of A.solve(B)
+  * and most of the time this is the only way it is used.
+  *
+  */
+namespace internal {
+
+// this solve_traits class permits to determine the evaluation type with respect to storage kind (Dense vs Sparse)
+template<typename Decomposition, typename RhsType,typename StorageKind> struct solve_traits;
+
+template<typename Decomposition, typename RhsType>
+struct solve_traits<Decomposition,RhsType,Dense>
+{
+  typedef typename make_proper_matrix_type<typename RhsType::Scalar,
+                 Decomposition::ColsAtCompileTime,
+                 RhsType::ColsAtCompileTime,
+                 RhsType::PlainObject::Options,
+                 Decomposition::MaxColsAtCompileTime,
+                 RhsType::MaxColsAtCompileTime>::type PlainObject;
+};
+
+template<typename Decomposition, typename RhsType>
+struct traits<Solve<Decomposition, RhsType> >
+  : traits<typename solve_traits<Decomposition,RhsType,typename internal::traits<RhsType>::StorageKind>::PlainObject>
+{
+  typedef typename solve_traits<Decomposition,RhsType,typename internal::traits<RhsType>::StorageKind>::PlainObject PlainObject;
+  typedef typename promote_index_type<typename Decomposition::StorageIndex, typename RhsType::StorageIndex>::type StorageIndex;
+  typedef traits<PlainObject> BaseTraits;
+  enum {
+    Flags = BaseTraits::Flags & RowMajorBit,
+    CoeffReadCost = HugeCost
+  };
+};
+
+}
+
+
+template<typename Decomposition, typename RhsType>
+class Solve : public SolveImpl<Decomposition,RhsType,typename internal::traits<RhsType>::StorageKind>
+{
+public:
+  typedef typename internal::traits<Solve>::PlainObject PlainObject;
+  typedef typename internal::traits<Solve>::StorageIndex StorageIndex;
+
+  Solve(const Decomposition &dec, const RhsType &rhs)
+    : m_dec(dec), m_rhs(rhs)
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_dec.cols(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+  EIGEN_DEVICE_FUNC const Decomposition& dec() const { return m_dec; }
+  EIGEN_DEVICE_FUNC const RhsType&       rhs() const { return m_rhs; }
+
+protected:
+  const Decomposition &m_dec;
+  const RhsType       &m_rhs;
+};
+
+
+// Specialization of the Solve expression for dense results
+template<typename Decomposition, typename RhsType>
+class SolveImpl<Decomposition,RhsType,Dense>
+  : public MatrixBase<Solve<Decomposition,RhsType> >
+{
+  typedef Solve<Decomposition,RhsType> Derived;
+
+public:
+
+  typedef MatrixBase<Solve<Decomposition,RhsType> > Base;
+  EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
+
+private:
+
+  Scalar coeff(Index row, Index col) const;
+  Scalar coeff(Index i) const;
+};
+
+// Generic API dispatcher
+template<typename Decomposition, typename RhsType, typename StorageKind>
+class SolveImpl : public internal::generic_xpr_base<Solve<Decomposition,RhsType>, MatrixXpr, StorageKind>::type
+{
+  public:
+    typedef typename internal::generic_xpr_base<Solve<Decomposition,RhsType>, MatrixXpr, StorageKind>::type Base;
+};
+
+namespace internal {
+
+// Evaluator of Solve -> eval into a temporary
+template<typename Decomposition, typename RhsType>
+struct evaluator<Solve<Decomposition,RhsType> >
+  : public evaluator<typename Solve<Decomposition,RhsType>::PlainObject>
+{
+  typedef Solve<Decomposition,RhsType> SolveType;
+  typedef typename SolveType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum { Flags = Base::Flags | EvalBeforeNestingBit };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const SolveType& solve)
+    : m_result(solve.rows(), solve.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    solve.dec()._solve_impl(solve.rhs(), m_result);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+// Specialization for "dst = dec.solve(rhs)"
+// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef Solve<DecType,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec()._solve_impl(src.rhs(), dst);
+  }
+};
+
+// Specialization for "dst = dec.transpose().solve(rhs)"
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<Transpose<const DecType>,RhsType>, internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef Solve<Transpose<const DecType>,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec().nestedExpression().template _solve_impl_transposed<false>(src.rhs(), dst);
+  }
+};
+
+// Specialization for "dst = dec.adjoint().solve(rhs)"
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType>,
+                  internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec().nestedExpression().nestedExpression().template _solve_impl_transposed<true>(src.rhs(), dst);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/SolveTriangular.h b/C++/yolo_bytetrack/include/Eigen/src/Core/SolveTriangular.h
new file mode 100644
index 00000000..dfbf9952
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/SolveTriangular.h
@@ -0,0 +1,235 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVETRIANGULAR_H
+#define EIGEN_SOLVETRIANGULAR_H
+
+namespace Eigen {
+
+namespace internal {
+
+// Forward declarations:
+// The following two routines are implemented in the products/TriangularSolver*.h files
+template<typename LhsScalar, typename RhsScalar, typename Index, int Side, int Mode, bool Conjugate, int StorageOrder>
+struct triangular_solve_vector;
+
+template <typename Scalar, typename Index, int Side, int Mode, bool Conjugate, int TriStorageOrder, int OtherStorageOrder, int OtherInnerStride>
+struct triangular_solve_matrix;
+
+// small helper struct extracting some traits on the underlying solver operation
+template<typename Lhs, typename Rhs, int Side>
+class trsolve_traits
+{
+  private:
+    enum {
+      RhsIsVectorAtCompileTime = (Side==OnTheLeft ? Rhs::ColsAtCompileTime : Rhs::RowsAtCompileTime)==1
+    };
+  public:
+    enum {
+      Unrolling   = (RhsIsVectorAtCompileTime && Rhs::SizeAtCompileTime != Dynamic && Rhs::SizeAtCompileTime <= 8)
+                  ? CompleteUnrolling : NoUnrolling,
+      RhsVectors  = RhsIsVectorAtCompileTime ? 1 : Dynamic
+    };
+};
+
+template<typename Lhs, typename Rhs,
+  int Side, // can be OnTheLeft/OnTheRight
+  int Mode, // can be Upper/Lower | UnitDiag
+  int Unrolling = trsolve_traits<Lhs,Rhs,Side>::Unrolling,
+  int RhsVectors = trsolve_traits<Lhs,Rhs,Side>::RhsVectors
+  >
+struct triangular_solver_selector;
+
+template<typename Lhs, typename Rhs, int Side, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,1>
+{
+  typedef typename Lhs::Scalar LhsScalar;
+  typedef typename Rhs::Scalar RhsScalar;
+  typedef blas_traits<Lhs> LhsProductTraits;
+  typedef typename LhsProductTraits::ExtractType ActualLhsType;
+  typedef Map<Matrix<RhsScalar,Dynamic,1>, Aligned> MappedRhs;
+  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
+  {
+    ActualLhsType actualLhs = LhsProductTraits::extract(lhs);
+
+    // FIXME find a way to allow an inner stride if packet_traits<Scalar>::size==1
+
+    bool useRhsDirectly = Rhs::InnerStrideAtCompileTime==1 || rhs.innerStride()==1;
+
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhs,rhs.size(),
+                                                  (useRhsDirectly ? rhs.data() : 0));
+
+    if(!useRhsDirectly)
+      MappedRhs(actualRhs,rhs.size()) = rhs;
+
+    triangular_solve_vector<LhsScalar, RhsScalar, Index, Side, Mode, LhsProductTraits::NeedToConjugate,
+                            (int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor>
+      ::run(actualLhs.cols(), actualLhs.data(), actualLhs.outerStride(), actualRhs);
+
+    if(!useRhsDirectly)
+      rhs = MappedRhs(actualRhs, rhs.size());
+  }
+};
+
+// the rhs is a matrix
+template<typename Lhs, typename Rhs, int Side, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,Dynamic>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef blas_traits<Lhs> LhsProductTraits;
+  typedef typename LhsProductTraits::DirectLinearAccessType ActualLhsType;
+
+  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
+  {
+    typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);
+
+    const Index size = lhs.rows();
+    const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();
+
+    typedef internal::gemm_blocking_space<(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
+              Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxRowsAtCompileTime,4> BlockingType;
+
+    BlockingType blocking(rhs.rows(), rhs.cols(), size, 1, false);
+
+    triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,(int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor,
+                               (Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor, Rhs::InnerStrideAtCompileTime>
+      ::run(size, othersize, &actualLhs.coeffRef(0,0), actualLhs.outerStride(), &rhs.coeffRef(0,0), rhs.innerStride(), rhs.outerStride(), blocking);
+  }
+};
+
+/***************************************************************************
+* meta-unrolling implementation
+***************************************************************************/
+
+template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size,
+         bool Stop = LoopIndex==Size>
+struct triangular_solver_unroller;
+
+template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size>
+struct triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex,Size,false> {
+  enum {
+    IsLower = ((Mode&Lower)==Lower),
+    DiagIndex  = IsLower ? LoopIndex : Size - LoopIndex - 1,
+    StartIndex = IsLower ? 0         : DiagIndex+1
+  };
+  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
+  {
+    if (LoopIndex>0)
+      rhs.coeffRef(DiagIndex) -= lhs.row(DiagIndex).template segment<LoopIndex>(StartIndex).transpose()
+                                .cwiseProduct(rhs.template segment<LoopIndex>(StartIndex)).sum();
+
+    if(!(Mode & UnitDiag))
+      rhs.coeffRef(DiagIndex) /= lhs.coeff(DiagIndex,DiagIndex);
+
+    triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex+1,Size>::run(lhs,rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size>
+struct triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex,Size,true> {
+  static EIGEN_DEVICE_FUNC void run(const Lhs&, Rhs&) {}
+};
+
+template<typename Lhs, typename Rhs, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,CompleteUnrolling,1> {
+  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
+  { triangular_solver_unroller<Lhs,Rhs,Mode,0,Rhs::SizeAtCompileTime>::run(lhs,rhs); }
+};
+
+template<typename Lhs, typename Rhs, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,OnTheRight,Mode,CompleteUnrolling,1> {
+  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
+  {
+    Transpose<const Lhs> trLhs(lhs);
+    Transpose<Rhs> trRhs(rhs);
+
+    triangular_solver_unroller<Transpose<const Lhs>,Transpose<Rhs>,
+                              ((Mode&Upper)==Upper ? Lower : Upper) | (Mode&UnitDiag),
+                              0,Rhs::SizeAtCompileTime>::run(trLhs,trRhs);
+  }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* TriangularView methods
+***************************************************************************/
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatrixType, unsigned int Mode>
+template<int Side, typename OtherDerived>
+EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType,Mode,Dense>::solveInPlace(const MatrixBase<OtherDerived>& _other) const
+{
+  OtherDerived& other = _other.const_cast_derived();
+  eigen_assert( derived().cols() == derived().rows() && ((Side==OnTheLeft && derived().cols() == other.rows()) || (Side==OnTheRight && derived().cols() == other.cols())) );
+  eigen_assert((!(int(Mode) & int(ZeroDiag))) && bool(int(Mode) & (int(Upper) | int(Lower))));
+  // If solving for a 0x0 matrix, nothing to do, simply return.
+  if (derived().cols() == 0)
+    return;
+
+  enum { copy = (internal::traits<OtherDerived>::Flags & RowMajorBit)  && OtherDerived::IsVectorAtCompileTime && OtherDerived::SizeAtCompileTime!=1};
+  typedef typename internal::conditional<copy,
+    typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
+  OtherCopy otherCopy(other);
+
+  internal::triangular_solver_selector<MatrixType, typename internal::remove_reference<OtherCopy>::type,
+    Side, Mode>::run(derived().nestedExpression(), otherCopy);
+
+  if (copy)
+    other = otherCopy;
+}
+
+template<typename Derived, unsigned int Mode>
+template<int Side, typename Other>
+const internal::triangular_solve_retval<Side,TriangularView<Derived,Mode>,Other>
+TriangularViewImpl<Derived,Mode,Dense>::solve(const MatrixBase<Other>& other) const
+{
+  return internal::triangular_solve_retval<Side,TriangularViewType,Other>(derived(), other.derived());
+}
+#endif
+
+namespace internal {
+
+
+template<int Side, typename TriangularType, typename Rhs>
+struct traits<triangular_solve_retval<Side, TriangularType, Rhs> >
+{
+  typedef typename internal::plain_matrix_type_column_major<Rhs>::type ReturnType;
+};
+
+template<int Side, typename TriangularType, typename Rhs> struct triangular_solve_retval
+ : public ReturnByValue<triangular_solve_retval<Side, TriangularType, Rhs> >
+{
+  typedef typename remove_all<typename Rhs::Nested>::type RhsNestedCleaned;
+  typedef ReturnByValue<triangular_solve_retval> Base;
+
+  triangular_solve_retval(const TriangularType& tri, const Rhs& rhs)
+    : m_triangularMatrix(tri), m_rhs(rhs)
+  {}
+
+  inline EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_rhs.rows(); }
+  inline EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+  template<typename Dest> inline void evalTo(Dest& dst) const
+  {
+    if(!is_same_dense(dst,m_rhs))
+      dst = m_rhs;
+    m_triangularMatrix.template solveInPlace<Side>(dst);
+  }
+
+  protected:
+    const TriangularType& m_triangularMatrix;
+    typename Rhs::Nested m_rhs;
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVETRIANGULAR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/SolverBase.h b/C++/yolo_bytetrack/include/Eigen/src/Core/SolverBase.h
new file mode 100644
index 00000000..50146104
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/SolverBase.h
@@ -0,0 +1,168 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVERBASE_H
+#define EIGEN_SOLVERBASE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Derived>
+struct solve_assertion {
+    template<bool Transpose_, typename Rhs>
+    static void run(const Derived& solver, const Rhs& b) { solver.template _check_solve_assertion<Transpose_>(b); }
+};
+
+template<typename Derived>
+struct solve_assertion<Transpose<Derived> >
+{
+    typedef Transpose<Derived> type;
+
+    template<bool Transpose_, typename Rhs>
+    static void run(const type& transpose, const Rhs& b)
+    {
+        internal::solve_assertion<typename internal::remove_all<Derived>::type>::template run<true>(transpose.nestedExpression(), b);
+    }
+};
+
+template<typename Scalar, typename Derived>
+struct solve_assertion<CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<Scalar>, const Transpose<Derived> > >
+{
+    typedef CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<Scalar>, const Transpose<Derived> > type;
+
+    template<bool Transpose_, typename Rhs>
+    static void run(const type& adjoint, const Rhs& b)
+    {
+        internal::solve_assertion<typename internal::remove_all<Transpose<Derived> >::type>::template run<true>(adjoint.nestedExpression(), b);
+    }
+};
+} // end namespace internal
+
+/** \class SolverBase
+  * \brief A base class for matrix decomposition and solvers
+  *
+  * \tparam Derived the actual type of the decomposition/solver.
+  *
+  * Any matrix decomposition inheriting this base class provide the following API:
+  *
+  * \code
+  * MatrixType A, b, x;
+  * DecompositionType dec(A);
+  * x = dec.solve(b);             // solve A   * x = b
+  * x = dec.transpose().solve(b); // solve A^T * x = b
+  * x = dec.adjoint().solve(b);   // solve A'  * x = b
+  * \endcode
+  *
+  * \warning Currently, any other usage of transpose() and adjoint() are not supported and will produce compilation errors.
+  *
+  * \sa class PartialPivLU, class FullPivLU, class HouseholderQR, class ColPivHouseholderQR, class FullPivHouseholderQR, class CompleteOrthogonalDecomposition, class LLT, class LDLT, class SVDBase
+  */
+template<typename Derived>
+class SolverBase : public EigenBase<Derived>
+{
+  public:
+
+    typedef EigenBase<Derived> Base;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef Scalar CoeffReturnType;
+
+    template<typename Derived_>
+    friend struct internal::solve_assertion;
+
+    enum {
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                          internal::traits<Derived>::ColsAtCompileTime>::ret),
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
+                                                             internal::traits<Derived>::MaxColsAtCompileTime>::ret),
+      IsVectorAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime == 1
+                           || internal::traits<Derived>::MaxColsAtCompileTime == 1,
+      NumDimensions = int(MaxSizeAtCompileTime) == 1 ? 0 : bool(IsVectorAtCompileTime) ? 1 : 2
+    };
+
+    /** Default constructor */
+    SolverBase()
+    {}
+
+    ~SolverBase()
+    {}
+
+    using Base::derived;
+
+    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      */
+    template<typename Rhs>
+    inline const Solve<Derived, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      internal::solve_assertion<typename internal::remove_all<Derived>::type>::template run<false>(derived(), b);
+      return Solve<Derived, Rhs>(derived(), b.derived());
+    }
+
+    /** \internal the return type of transpose() */
+    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
+    /** \returns an expression of the transposed of the factored matrix.
+      *
+      * A typical usage is to solve for the transposed problem A^T x = b:
+      * \code x = dec.transpose().solve(b); \endcode
+      *
+      * \sa adjoint(), solve()
+      */
+    inline ConstTransposeReturnType transpose() const
+    {
+      return ConstTransposeReturnType(derived());
+    }
+
+    /** \internal the return type of adjoint() */
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
+                        ConstTransposeReturnType
+                     >::type AdjointReturnType;
+    /** \returns an expression of the adjoint of the factored matrix
+      *
+      * A typical usage is to solve for the adjoint problem A' x = b:
+      * \code x = dec.adjoint().solve(b); \endcode
+      *
+      * For real scalar types, this function is equivalent to transpose().
+      *
+      * \sa transpose(), solve()
+      */
+    inline AdjointReturnType adjoint() const
+    {
+      return AdjointReturnType(derived().transpose());
+    }
+
+  protected:
+
+    template<bool Transpose_, typename Rhs>
+    void _check_solve_assertion(const Rhs& b) const {
+        EIGEN_ONLY_USED_FOR_DEBUG(b);
+        eigen_assert(derived().m_isInitialized && "Solver is not initialized.");
+        eigen_assert((Transpose_?derived().cols():derived().rows())==b.rows() && "SolverBase::solve(): invalid number of rows of the right hand side matrix b");
+    }
+};
+
+namespace internal {
+
+template<typename Derived>
+struct generic_xpr_base<Derived, MatrixXpr, SolverStorage>
+{
+  typedef SolverBase<Derived> type;
+
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVERBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/StableNorm.h b/C++/yolo_bytetrack/include/Eigen/src/Core/StableNorm.h
new file mode 100644
index 00000000..4a3f0cca
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/StableNorm.h
@@ -0,0 +1,251 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STABLENORM_H
+#define EIGEN_STABLENORM_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename ExpressionType, typename Scalar>
+inline void stable_norm_kernel(const ExpressionType& bl, Scalar& ssq, Scalar& scale, Scalar& invScale)
+{
+  Scalar maxCoeff = bl.cwiseAbs().maxCoeff();
+  
+  if(maxCoeff>scale)
+  {
+    ssq = ssq * numext::abs2(scale/maxCoeff);
+    Scalar tmp = Scalar(1)/maxCoeff;
+    if(tmp > NumTraits<Scalar>::highest())
+    {
+      invScale = NumTraits<Scalar>::highest();
+      scale = Scalar(1)/invScale;
+    }
+    else if(maxCoeff>NumTraits<Scalar>::highest()) // we got a INF
+    {
+      invScale = Scalar(1);
+      scale = maxCoeff;
+    }
+    else
+    {
+      scale = maxCoeff;
+      invScale = tmp;
+    }
+  }
+  else if(maxCoeff!=maxCoeff) // we got a NaN
+  {
+    scale = maxCoeff;
+  }
+  
+  // TODO if the maxCoeff is much much smaller than the current scale,
+  // then we can neglect this sub vector
+  if(scale>Scalar(0)) // if scale==0, then bl is 0 
+    ssq += (bl*invScale).squaredNorm();
+}
+
+template<typename VectorType, typename RealScalar>
+void stable_norm_impl_inner_step(const VectorType &vec, RealScalar& ssq, RealScalar& scale, RealScalar& invScale)
+{
+  typedef typename VectorType::Scalar Scalar;
+  const Index blockSize = 4096;
+  
+  typedef typename internal::nested_eval<VectorType,2>::type VectorTypeCopy;
+  typedef typename internal::remove_all<VectorTypeCopy>::type VectorTypeCopyClean;
+  const VectorTypeCopy copy(vec);
+  
+  enum {
+    CanAlign = (   (int(VectorTypeCopyClean::Flags)&DirectAccessBit)
+                || (int(internal::evaluator<VectorTypeCopyClean>::Alignment)>0) // FIXME Alignment)>0 might not be enough
+               ) && (blockSize*sizeof(Scalar)*2<EIGEN_STACK_ALLOCATION_LIMIT)
+                 && (EIGEN_MAX_STATIC_ALIGN_BYTES>0) // if we cannot allocate on the stack, then let's not bother about this optimization
+  };
+  typedef typename internal::conditional<CanAlign, Ref<const Matrix<Scalar,Dynamic,1,0,blockSize,1>, internal::evaluator<VectorTypeCopyClean>::Alignment>,
+                                                   typename VectorTypeCopyClean::ConstSegmentReturnType>::type SegmentWrapper;
+  Index n = vec.size();
+  
+  Index bi = internal::first_default_aligned(copy);
+  if (bi>0)
+    internal::stable_norm_kernel(copy.head(bi), ssq, scale, invScale);
+  for (; bi<n; bi+=blockSize)
+    internal::stable_norm_kernel(SegmentWrapper(copy.segment(bi,numext::mini(blockSize, n - bi))), ssq, scale, invScale);
+}
+
+template<typename VectorType>
+typename VectorType::RealScalar
+stable_norm_impl(const VectorType &vec, typename enable_if<VectorType::IsVectorAtCompileTime>::type* = 0 )
+{
+  using std::sqrt;
+  using std::abs;
+
+  Index n = vec.size();
+
+  if(n==1)
+    return abs(vec.coeff(0));
+
+  typedef typename VectorType::RealScalar RealScalar;
+  RealScalar scale(0);
+  RealScalar invScale(1);
+  RealScalar ssq(0); // sum of squares
+
+  stable_norm_impl_inner_step(vec, ssq, scale, invScale);
+  
+  return scale * sqrt(ssq);
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar
+stable_norm_impl(const MatrixType &mat, typename enable_if<!MatrixType::IsVectorAtCompileTime>::type* = 0 )
+{
+  using std::sqrt;
+
+  typedef typename MatrixType::RealScalar RealScalar;
+  RealScalar scale(0);
+  RealScalar invScale(1);
+  RealScalar ssq(0); // sum of squares
+
+  for(Index j=0; j<mat.outerSize(); ++j)
+    stable_norm_impl_inner_step(mat.innerVector(j), ssq, scale, invScale);
+  return scale * sqrt(ssq);
+}
+
+template<typename Derived>
+inline typename NumTraits<typename traits<Derived>::Scalar>::Real
+blueNorm_impl(const EigenBase<Derived>& _vec)
+{
+  typedef typename Derived::RealScalar RealScalar;  
+  using std::pow;
+  using std::sqrt;
+  using std::abs;
+
+  // This program calculates the machine-dependent constants
+  // bl, b2, slm, s2m, relerr overfl
+  // from the "basic" machine-dependent numbers
+  // nbig, ibeta, it, iemin, iemax, rbig.
+  // The following define the basic machine-dependent constants.
+  // For portability, the PORT subprograms "ilmaeh" and "rlmach"
+  // are used. For any specific computer, each of the assignment
+  // statements can be replaced
+  static const int ibeta = std::numeric_limits<RealScalar>::radix;  // base for floating-point numbers
+  static const int it    = NumTraits<RealScalar>::digits();  // number of base-beta digits in mantissa
+  static const int iemin = NumTraits<RealScalar>::min_exponent();  // minimum exponent
+  static const int iemax = NumTraits<RealScalar>::max_exponent();  // maximum exponent
+  static const RealScalar rbig   = NumTraits<RealScalar>::highest();  // largest floating-point number
+  static const RealScalar b1     = RealScalar(pow(RealScalar(ibeta),RealScalar(-((1-iemin)/2))));  // lower boundary of midrange
+  static const RealScalar b2     = RealScalar(pow(RealScalar(ibeta),RealScalar((iemax + 1 - it)/2)));  // upper boundary of midrange
+  static const RealScalar s1m    = RealScalar(pow(RealScalar(ibeta),RealScalar((2-iemin)/2)));  // scaling factor for lower range
+  static const RealScalar s2m    = RealScalar(pow(RealScalar(ibeta),RealScalar(- ((iemax+it)/2))));  // scaling factor for upper range
+  static const RealScalar eps    = RealScalar(pow(double(ibeta), 1-it));
+  static const RealScalar relerr = sqrt(eps);  // tolerance for neglecting asml
+
+  const Derived& vec(_vec.derived());
+  Index n = vec.size();
+  RealScalar ab2 = b2 / RealScalar(n);
+  RealScalar asml = RealScalar(0);
+  RealScalar amed = RealScalar(0);
+  RealScalar abig = RealScalar(0);
+
+  for(Index j=0; j<vec.outerSize(); ++j)
+  {
+    for(typename Derived::InnerIterator iter(vec, j); iter; ++iter)
+    {
+      RealScalar ax = abs(iter.value());
+      if(ax > ab2)     abig += numext::abs2(ax*s2m);
+      else if(ax < b1) asml += numext::abs2(ax*s1m);
+      else             amed += numext::abs2(ax);
+    }
+  }
+  if(amed!=amed)
+    return amed;  // we got a NaN
+  if(abig > RealScalar(0))
+  {
+    abig = sqrt(abig);
+    if(abig > rbig) // overflow, or *this contains INF values
+      return abig;  // return INF
+    if(amed > RealScalar(0))
+    {
+      abig = abig/s2m;
+      amed = sqrt(amed);
+    }
+    else
+      return abig/s2m;
+  }
+  else if(asml > RealScalar(0))
+  {
+    if (amed > RealScalar(0))
+    {
+      abig = sqrt(amed);
+      amed = sqrt(asml) / s1m;
+    }
+    else
+      return sqrt(asml)/s1m;
+  }
+  else
+    return sqrt(amed);
+  asml = numext::mini(abig, amed);
+  abig = numext::maxi(abig, amed);
+  if(asml <= abig*relerr)
+    return abig;
+  else
+    return abig * sqrt(RealScalar(1) + numext::abs2(asml/abig));
+}
+
+} // end namespace internal
+
+/** \returns the \em l2 norm of \c *this avoiding underflow and overflow.
+  * This version use a blockwise two passes algorithm:
+  *  1 - find the absolute largest coefficient \c s
+  *  2 - compute \f$ s \Vert \frac{*this}{s} \Vert \f$ in a standard way
+  *
+  * For architecture/scalar types supporting vectorization, this version
+  * is faster than blueNorm(). Otherwise the blueNorm() is much faster.
+  *
+  * \sa norm(), blueNorm(), hypotNorm()
+  */
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+MatrixBase<Derived>::stableNorm() const
+{
+  return internal::stable_norm_impl(derived());
+}
+
+/** \returns the \em l2 norm of \c *this using the Blue's algorithm.
+  * A Portable Fortran Program to Find the Euclidean Norm of a Vector,
+  * ACM TOMS, Vol 4, Issue 1, 1978.
+  *
+  * For architecture/scalar types without vectorization, this version
+  * is much faster than stableNorm(). Otherwise the stableNorm() is faster.
+  *
+  * \sa norm(), stableNorm(), hypotNorm()
+  */
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+MatrixBase<Derived>::blueNorm() const
+{
+  return internal::blueNorm_impl(*this);
+}
+
+/** \returns the \em l2 norm of \c *this avoiding undeflow and overflow.
+  * This version use a concatenation of hypot() calls, and it is very slow.
+  *
+  * \sa norm(), stableNorm()
+  */
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+MatrixBase<Derived>::hypotNorm() const
+{
+  if(size()==1)
+    return numext::abs(coeff(0,0));
+  else
+    return this->cwiseAbs().redux(internal::scalar_hypot_op<RealScalar>());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_STABLENORM_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/StlIterators.h b/C++/yolo_bytetrack/include/Eigen/src/Core/StlIterators.h
new file mode 100644
index 00000000..09041db1
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/StlIterators.h
@@ -0,0 +1,463 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STLITERATORS_H
+#define EIGEN_STLITERATORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename IteratorType>
+struct indexed_based_stl_iterator_traits;
+
+template<typename  Derived>
+class indexed_based_stl_iterator_base
+{
+protected:
+  typedef indexed_based_stl_iterator_traits<Derived> traits;
+  typedef typename traits::XprType XprType;
+  typedef indexed_based_stl_iterator_base<typename traits::non_const_iterator> non_const_iterator;
+  typedef indexed_based_stl_iterator_base<typename traits::const_iterator> const_iterator;
+  typedef typename internal::conditional<internal::is_const<XprType>::value,non_const_iterator,const_iterator>::type other_iterator;
+  // NOTE: in C++03 we cannot declare friend classes through typedefs because we need to write friend class:
+  friend class indexed_based_stl_iterator_base<typename traits::const_iterator>;
+  friend class indexed_based_stl_iterator_base<typename traits::non_const_iterator>;
+public:
+  typedef Index difference_type;
+  typedef std::random_access_iterator_tag iterator_category;
+
+  indexed_based_stl_iterator_base() EIGEN_NO_THROW : mp_xpr(0), m_index(0) {}
+  indexed_based_stl_iterator_base(XprType& xpr, Index index) EIGEN_NO_THROW : mp_xpr(&xpr), m_index(index) {}
+
+  indexed_based_stl_iterator_base(const non_const_iterator& other) EIGEN_NO_THROW
+    : mp_xpr(other.mp_xpr), m_index(other.m_index)
+  {}
+
+  indexed_based_stl_iterator_base& operator=(const non_const_iterator& other)
+  {
+    mp_xpr = other.mp_xpr;
+    m_index = other.m_index;
+    return *this;
+  }
+
+  Derived& operator++() { ++m_index; return derived(); }
+  Derived& operator--() { --m_index; return derived(); }
+
+  Derived operator++(int) { Derived prev(derived()); operator++(); return prev;}
+  Derived operator--(int) { Derived prev(derived()); operator--(); return prev;}
+
+  friend Derived operator+(const indexed_based_stl_iterator_base& a, Index b) { Derived ret(a.derived()); ret += b; return ret; }
+  friend Derived operator-(const indexed_based_stl_iterator_base& a, Index b) { Derived ret(a.derived()); ret -= b; return ret; }
+  friend Derived operator+(Index a, const indexed_based_stl_iterator_base& b) { Derived ret(b.derived()); ret += a; return ret; }
+  friend Derived operator-(Index a, const indexed_based_stl_iterator_base& b) { Derived ret(b.derived()); ret -= a; return ret; }
+  
+  Derived& operator+=(Index b) { m_index += b; return derived(); }
+  Derived& operator-=(Index b) { m_index -= b; return derived(); }
+
+  difference_type operator-(const indexed_based_stl_iterator_base& other) const
+  {
+    eigen_assert(mp_xpr == other.mp_xpr);
+    return m_index - other.m_index;
+  }
+
+  difference_type operator-(const other_iterator& other) const
+  {
+    eigen_assert(mp_xpr == other.mp_xpr);
+    return m_index - other.m_index;
+  }
+
+  bool operator==(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
+  bool operator!=(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
+  bool operator< (const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <  other.m_index; }
+  bool operator<=(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
+  bool operator> (const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >  other.m_index; }
+  bool operator>=(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
+
+  bool operator==(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
+  bool operator!=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
+  bool operator< (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <  other.m_index; }
+  bool operator<=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
+  bool operator> (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >  other.m_index; }
+  bool operator>=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
+
+protected:
+
+  Derived& derived() { return static_cast<Derived&>(*this); }
+  const Derived& derived() const { return static_cast<const Derived&>(*this); }
+
+  XprType *mp_xpr;
+  Index m_index;
+};
+
+template<typename  Derived>
+class indexed_based_stl_reverse_iterator_base
+{
+protected:
+  typedef indexed_based_stl_iterator_traits<Derived> traits;
+  typedef typename traits::XprType XprType;
+  typedef indexed_based_stl_reverse_iterator_base<typename traits::non_const_iterator> non_const_iterator;
+  typedef indexed_based_stl_reverse_iterator_base<typename traits::const_iterator> const_iterator;
+  typedef typename internal::conditional<internal::is_const<XprType>::value,non_const_iterator,const_iterator>::type other_iterator;
+  // NOTE: in C++03 we cannot declare friend classes through typedefs because we need to write friend class:
+  friend class indexed_based_stl_reverse_iterator_base<typename traits::const_iterator>;
+  friend class indexed_based_stl_reverse_iterator_base<typename traits::non_const_iterator>;
+public:
+  typedef Index difference_type;
+  typedef std::random_access_iterator_tag iterator_category;
+
+  indexed_based_stl_reverse_iterator_base() : mp_xpr(0), m_index(0) {}
+  indexed_based_stl_reverse_iterator_base(XprType& xpr, Index index) : mp_xpr(&xpr), m_index(index) {}
+
+  indexed_based_stl_reverse_iterator_base(const non_const_iterator& other)
+    : mp_xpr(other.mp_xpr), m_index(other.m_index)
+  {}
+
+  indexed_based_stl_reverse_iterator_base& operator=(const non_const_iterator& other)
+  {
+    mp_xpr = other.mp_xpr;
+    m_index = other.m_index;
+    return *this;
+  }
+
+  Derived& operator++() { --m_index; return derived(); }
+  Derived& operator--() { ++m_index; return derived(); }
+
+  Derived operator++(int) { Derived prev(derived()); operator++(); return prev;}
+  Derived operator--(int) { Derived prev(derived()); operator--(); return prev;}
+
+  friend Derived operator+(const indexed_based_stl_reverse_iterator_base& a, Index b) { Derived ret(a.derived()); ret += b; return ret; }
+  friend Derived operator-(const indexed_based_stl_reverse_iterator_base& a, Index b) { Derived ret(a.derived()); ret -= b; return ret; }
+  friend Derived operator+(Index a, const indexed_based_stl_reverse_iterator_base& b) { Derived ret(b.derived()); ret += a; return ret; }
+  friend Derived operator-(Index a, const indexed_based_stl_reverse_iterator_base& b) { Derived ret(b.derived()); ret -= a; return ret; }
+  
+  Derived& operator+=(Index b) { m_index -= b; return derived(); }
+  Derived& operator-=(Index b) { m_index += b; return derived(); }
+
+  difference_type operator-(const indexed_based_stl_reverse_iterator_base& other) const
+  {
+    eigen_assert(mp_xpr == other.mp_xpr);
+    return other.m_index - m_index;
+  }
+
+  difference_type operator-(const other_iterator& other) const
+  {
+    eigen_assert(mp_xpr == other.mp_xpr);
+    return other.m_index - m_index;
+  }
+
+  bool operator==(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
+  bool operator!=(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
+  bool operator< (const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >  other.m_index; }
+  bool operator<=(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
+  bool operator> (const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <  other.m_index; }
+  bool operator>=(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
+
+  bool operator==(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
+  bool operator!=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
+  bool operator< (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >  other.m_index; }
+  bool operator<=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
+  bool operator> (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <  other.m_index; }
+  bool operator>=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
+
+protected:
+
+  Derived& derived() { return static_cast<Derived&>(*this); }
+  const Derived& derived() const { return static_cast<const Derived&>(*this); }
+
+  XprType *mp_xpr;
+  Index m_index;
+};
+
+template<typename XprType>
+class pointer_based_stl_iterator
+{
+  enum { is_lvalue  = internal::is_lvalue<XprType>::value };
+  typedef pointer_based_stl_iterator<typename internal::remove_const<XprType>::type> non_const_iterator;
+  typedef pointer_based_stl_iterator<typename internal::add_const<XprType>::type> const_iterator;
+  typedef typename internal::conditional<internal::is_const<XprType>::value,non_const_iterator,const_iterator>::type other_iterator;
+  // NOTE: in C++03 we cannot declare friend classes through typedefs because we need to write friend class:
+  friend class pointer_based_stl_iterator<typename internal::add_const<XprType>::type>;
+  friend class pointer_based_stl_iterator<typename internal::remove_const<XprType>::type>;
+public:
+  typedef Index difference_type;
+  typedef typename XprType::Scalar value_type;
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef typename internal::conditional<bool(is_lvalue), value_type*, const value_type*>::type pointer;
+  typedef typename internal::conditional<bool(is_lvalue), value_type&, const value_type&>::type reference;
+
+
+  pointer_based_stl_iterator() EIGEN_NO_THROW : m_ptr(0) {}
+  pointer_based_stl_iterator(XprType& xpr, Index index) EIGEN_NO_THROW : m_incr(xpr.innerStride())
+  {
+    m_ptr = xpr.data() + index * m_incr.value();
+  }
+
+  pointer_based_stl_iterator(const non_const_iterator& other) EIGEN_NO_THROW
+    : m_ptr(other.m_ptr), m_incr(other.m_incr)
+  {}
+
+  pointer_based_stl_iterator& operator=(const non_const_iterator& other) EIGEN_NO_THROW
+  {
+    m_ptr = other.m_ptr;
+    m_incr.setValue(other.m_incr);
+    return *this;
+  }
+
+  reference operator*()         const { return *m_ptr;   }
+  reference operator[](Index i) const { return *(m_ptr+i*m_incr.value()); }
+  pointer   operator->()        const { return m_ptr;    }
+
+  pointer_based_stl_iterator& operator++() { m_ptr += m_incr.value(); return *this; }
+  pointer_based_stl_iterator& operator--() { m_ptr -= m_incr.value(); return *this; }
+
+  pointer_based_stl_iterator operator++(int) { pointer_based_stl_iterator prev(*this); operator++(); return prev;}
+  pointer_based_stl_iterator operator--(int) { pointer_based_stl_iterator prev(*this); operator--(); return prev;}
+
+  friend pointer_based_stl_iterator operator+(const pointer_based_stl_iterator& a, Index b) { pointer_based_stl_iterator ret(a); ret += b; return ret; }
+  friend pointer_based_stl_iterator operator-(const pointer_based_stl_iterator& a, Index b) { pointer_based_stl_iterator ret(a); ret -= b; return ret; }
+  friend pointer_based_stl_iterator operator+(Index a, const pointer_based_stl_iterator& b) { pointer_based_stl_iterator ret(b); ret += a; return ret; }
+  friend pointer_based_stl_iterator operator-(Index a, const pointer_based_stl_iterator& b) { pointer_based_stl_iterator ret(b); ret -= a; return ret; }
+  
+  pointer_based_stl_iterator& operator+=(Index b) { m_ptr += b*m_incr.value(); return *this; }
+  pointer_based_stl_iterator& operator-=(Index b) { m_ptr -= b*m_incr.value(); return *this; }
+
+  difference_type operator-(const pointer_based_stl_iterator& other) const {
+    return (m_ptr - other.m_ptr)/m_incr.value();
+  }
+
+  difference_type operator-(const other_iterator& other) const {
+    return (m_ptr - other.m_ptr)/m_incr.value();
+  }
+
+  bool operator==(const pointer_based_stl_iterator& other) const { return m_ptr == other.m_ptr; }
+  bool operator!=(const pointer_based_stl_iterator& other) const { return m_ptr != other.m_ptr; }
+  bool operator< (const pointer_based_stl_iterator& other) const { return m_ptr <  other.m_ptr; }
+  bool operator<=(const pointer_based_stl_iterator& other) const { return m_ptr <= other.m_ptr; }
+  bool operator> (const pointer_based_stl_iterator& other) const { return m_ptr >  other.m_ptr; }
+  bool operator>=(const pointer_based_stl_iterator& other) const { return m_ptr >= other.m_ptr; }
+
+  bool operator==(const other_iterator& other) const { return m_ptr == other.m_ptr; }
+  bool operator!=(const other_iterator& other) const { return m_ptr != other.m_ptr; }
+  bool operator< (const other_iterator& other) const { return m_ptr <  other.m_ptr; }
+  bool operator<=(const other_iterator& other) const { return m_ptr <= other.m_ptr; }
+  bool operator> (const other_iterator& other) const { return m_ptr >  other.m_ptr; }
+  bool operator>=(const other_iterator& other) const { return m_ptr >= other.m_ptr; }
+
+protected:
+
+  pointer m_ptr;
+  internal::variable_if_dynamic<Index, XprType::InnerStrideAtCompileTime> m_incr;
+};
+
+template<typename _XprType>
+struct indexed_based_stl_iterator_traits<generic_randaccess_stl_iterator<_XprType> >
+{
+  typedef _XprType XprType;
+  typedef generic_randaccess_stl_iterator<typename internal::remove_const<XprType>::type> non_const_iterator;
+  typedef generic_randaccess_stl_iterator<typename internal::add_const<XprType>::type> const_iterator;
+};
+
+template<typename XprType>
+class generic_randaccess_stl_iterator : public indexed_based_stl_iterator_base<generic_randaccess_stl_iterator<XprType> >
+{
+public:
+  typedef typename XprType::Scalar value_type;
+
+protected:
+
+  enum {
+    has_direct_access = (internal::traits<XprType>::Flags & DirectAccessBit) ? 1 : 0,
+    is_lvalue  = internal::is_lvalue<XprType>::value
+  };
+
+  typedef indexed_based_stl_iterator_base<generic_randaccess_stl_iterator> Base;
+  using Base::m_index;
+  using Base::mp_xpr;
+
+  // TODO currently const Transpose/Reshape expressions never returns const references,
+  // so lets return by value too.
+  //typedef typename internal::conditional<bool(has_direct_access), const value_type&, const value_type>::type read_only_ref_t;
+  typedef const value_type read_only_ref_t;
+
+public:
+  
+  typedef typename internal::conditional<bool(is_lvalue), value_type *, const value_type *>::type pointer;
+  typedef typename internal::conditional<bool(is_lvalue), value_type&, read_only_ref_t>::type reference;
+  
+  generic_randaccess_stl_iterator() : Base() {}
+  generic_randaccess_stl_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
+  generic_randaccess_stl_iterator(const typename Base::non_const_iterator& other) : Base(other) {}
+  using Base::operator=;
+
+  reference operator*()         const { return   (*mp_xpr)(m_index);   }
+  reference operator[](Index i) const { return   (*mp_xpr)(m_index+i); }
+  pointer   operator->()        const { return &((*mp_xpr)(m_index)); }
+};
+
+template<typename _XprType, DirectionType Direction>
+struct indexed_based_stl_iterator_traits<subvector_stl_iterator<_XprType,Direction> >
+{
+  typedef _XprType XprType;
+  typedef subvector_stl_iterator<typename internal::remove_const<XprType>::type, Direction> non_const_iterator;
+  typedef subvector_stl_iterator<typename internal::add_const<XprType>::type, Direction> const_iterator;
+};
+
+template<typename XprType, DirectionType Direction>
+class subvector_stl_iterator : public indexed_based_stl_iterator_base<subvector_stl_iterator<XprType,Direction> >
+{
+protected:
+
+  enum { is_lvalue  = internal::is_lvalue<XprType>::value };
+
+  typedef indexed_based_stl_iterator_base<subvector_stl_iterator> Base;
+  using Base::m_index;
+  using Base::mp_xpr;
+
+  typedef typename internal::conditional<Direction==Vertical,typename XprType::ColXpr,typename XprType::RowXpr>::type SubVectorType;
+  typedef typename internal::conditional<Direction==Vertical,typename XprType::ConstColXpr,typename XprType::ConstRowXpr>::type ConstSubVectorType;
+
+
+public:
+  typedef typename internal::conditional<bool(is_lvalue), SubVectorType, ConstSubVectorType>::type reference;
+  typedef typename reference::PlainObject value_type;
+
+private:
+  class subvector_stl_iterator_ptr
+  {
+  public:
+      subvector_stl_iterator_ptr(const reference &subvector) : m_subvector(subvector) {}
+      reference* operator->() { return &m_subvector; }
+  private:
+      reference m_subvector;
+  };
+public:
+
+  typedef subvector_stl_iterator_ptr pointer;
+  
+  subvector_stl_iterator() : Base() {}
+  subvector_stl_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
+
+  reference operator*()         const { return (*mp_xpr).template subVector<Direction>(m_index); }
+  reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index+i); }
+  pointer   operator->()        const { return (*mp_xpr).template subVector<Direction>(m_index); }
+};
+
+template<typename _XprType, DirectionType Direction>
+struct indexed_based_stl_iterator_traits<subvector_stl_reverse_iterator<_XprType,Direction> >
+{
+  typedef _XprType XprType;
+  typedef subvector_stl_reverse_iterator<typename internal::remove_const<XprType>::type, Direction> non_const_iterator;
+  typedef subvector_stl_reverse_iterator<typename internal::add_const<XprType>::type, Direction> const_iterator;
+};
+
+template<typename XprType, DirectionType Direction>
+class subvector_stl_reverse_iterator : public indexed_based_stl_reverse_iterator_base<subvector_stl_reverse_iterator<XprType,Direction> >
+{
+protected:
+
+  enum { is_lvalue  = internal::is_lvalue<XprType>::value };
+
+  typedef indexed_based_stl_reverse_iterator_base<subvector_stl_reverse_iterator> Base;
+  using Base::m_index;
+  using Base::mp_xpr;
+
+  typedef typename internal::conditional<Direction==Vertical,typename XprType::ColXpr,typename XprType::RowXpr>::type SubVectorType;
+  typedef typename internal::conditional<Direction==Vertical,typename XprType::ConstColXpr,typename XprType::ConstRowXpr>::type ConstSubVectorType;
+
+
+public:
+  typedef typename internal::conditional<bool(is_lvalue), SubVectorType, ConstSubVectorType>::type reference;
+  typedef typename reference::PlainObject value_type;
+
+private:
+  class subvector_stl_reverse_iterator_ptr
+  {
+  public:
+      subvector_stl_reverse_iterator_ptr(const reference &subvector) : m_subvector(subvector) {}
+      reference* operator->() { return &m_subvector; }
+  private:
+      reference m_subvector;
+  };
+public:
+
+  typedef subvector_stl_reverse_iterator_ptr pointer;
+  
+  subvector_stl_reverse_iterator() : Base() {}
+  subvector_stl_reverse_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
+
+  reference operator*()         const { return (*mp_xpr).template subVector<Direction>(m_index); }
+  reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index+i); }
+  pointer   operator->()        const { return (*mp_xpr).template subVector<Direction>(m_index); }
+};
+
+} // namespace internal
+
+
+/** returns an iterator to the first element of the 1D vector or array
+  * \only_for_vectors
+  * \sa end(), cbegin()
+  */
+template<typename Derived>
+inline typename DenseBase<Derived>::iterator DenseBase<Derived>::begin()
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return iterator(derived(), 0);
+}
+
+/** const version of begin() */
+template<typename Derived>
+inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::begin() const
+{
+  return cbegin();
+}
+
+/** returns a read-only const_iterator to the first element of the 1D vector or array
+  * \only_for_vectors
+  * \sa cend(), begin()
+  */
+template<typename Derived>
+inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cbegin() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return const_iterator(derived(), 0);
+}
+
+/** returns an iterator to the element following the last element of the 1D vector or array
+  * \only_for_vectors
+  * \sa begin(), cend()
+  */
+template<typename Derived>
+inline typename DenseBase<Derived>::iterator DenseBase<Derived>::end()
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return iterator(derived(), size());
+}
+
+/** const version of end() */
+template<typename Derived>
+inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::end() const
+{
+  return cend();
+}
+
+/** returns a read-only const_iterator to the element following the last element of the 1D vector or array
+  * \only_for_vectors
+  * \sa begin(), cend()
+  */
+template<typename Derived>
+inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cend() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return const_iterator(derived(), size());
+}
+
+} // namespace Eigen
+
+#endif // EIGEN_STLITERATORS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Stride.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Stride.h
new file mode 100644
index 00000000..6494d514
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Stride.h
@@ -0,0 +1,116 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STRIDE_H
+#define EIGEN_STRIDE_H
+
+namespace Eigen {
+
+/** \class Stride
+  * \ingroup Core_Module
+  *
+  * \brief Holds strides information for Map
+  *
+  * This class holds the strides information for mapping arrays with strides with class Map.
+  *
+  * It holds two values: the inner stride and the outer stride.
+  *
+  * The inner stride is the pointer increment between two consecutive entries within a given row of a
+  * row-major matrix or within a given column of a column-major matrix.
+  *
+  * The outer stride is the pointer increment between two consecutive rows of a row-major matrix or
+  * between two consecutive columns of a column-major matrix.
+  *
+  * These two values can be passed either at compile-time as template parameters, or at runtime as
+  * arguments to the constructor.
+  *
+  * Indeed, this class takes two template parameters:
+  *  \tparam _OuterStrideAtCompileTime the outer stride, or Dynamic if you want to specify it at runtime.
+  *  \tparam _InnerStrideAtCompileTime the inner stride, or Dynamic if you want to specify it at runtime.
+  *
+  * Here is an example:
+  * \include Map_general_stride.cpp
+  * Output: \verbinclude Map_general_stride.out
+  *
+  * Both strides can be negative, however, a negative stride of -1 cannot be specified at compiletime
+  * because of the ambiguity with Dynamic which is defined to -1 (historically, negative strides were
+  * not allowed).
+  *
+  * \sa class InnerStride, class OuterStride, \ref TopicStorageOrders
+  */
+template<int _OuterStrideAtCompileTime, int _InnerStrideAtCompileTime>
+class Stride
+{
+  public:
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    enum {
+      InnerStrideAtCompileTime = _InnerStrideAtCompileTime,
+      OuterStrideAtCompileTime = _OuterStrideAtCompileTime
+    };
+
+    /** Default constructor, for use when strides are fixed at compile time */
+    EIGEN_DEVICE_FUNC
+    Stride()
+      : m_outer(OuterStrideAtCompileTime), m_inner(InnerStrideAtCompileTime)
+    {
+      // FIXME: for Eigen 4 we should use DynamicIndex instead of Dynamic.
+      // FIXME: for Eigen 4 we should also unify this API with fix<>
+      eigen_assert(InnerStrideAtCompileTime != Dynamic && OuterStrideAtCompileTime != Dynamic);
+    }
+
+    /** Constructor allowing to pass the strides at runtime */
+    EIGEN_DEVICE_FUNC
+    Stride(Index outerStride, Index innerStride)
+      : m_outer(outerStride), m_inner(innerStride)
+    {
+    }
+
+    /** Copy constructor */
+    EIGEN_DEVICE_FUNC
+    Stride(const Stride& other)
+      : m_outer(other.outer()), m_inner(other.inner())
+    {}
+
+    /** \returns the outer stride */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outer() const { return m_outer.value(); }
+    /** \returns the inner stride */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index inner() const { return m_inner.value(); }
+
+  protected:
+    internal::variable_if_dynamic<Index, OuterStrideAtCompileTime> m_outer;
+    internal::variable_if_dynamic<Index, InnerStrideAtCompileTime> m_inner;
+};
+
+/** \brief Convenience specialization of Stride to specify only an inner stride
+  * See class Map for some examples */
+template<int Value>
+class InnerStride : public Stride<0, Value>
+{
+    typedef Stride<0, Value> Base;
+  public:
+    EIGEN_DEVICE_FUNC InnerStride() : Base() {}
+    EIGEN_DEVICE_FUNC InnerStride(Index v) : Base(0, v) {} // FIXME making this explicit could break valid code
+};
+
+/** \brief Convenience specialization of Stride to specify only an outer stride
+  * See class Map for some examples */
+template<int Value>
+class OuterStride : public Stride<Value, 0>
+{
+    typedef Stride<Value, 0> Base;
+  public:
+    EIGEN_DEVICE_FUNC OuterStride() : Base() {}
+    EIGEN_DEVICE_FUNC OuterStride(Index v) : Base(v,0) {} // FIXME making this explicit could break valid code
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_STRIDE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Swap.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Swap.h
new file mode 100644
index 00000000..180a4e5a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Swap.h
@@ -0,0 +1,68 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SWAP_H
+#define EIGEN_SWAP_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// Overload default assignPacket behavior for swapping them
+template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT>
+class generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, Specialized>
+ : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn> Base;
+  using Base::m_dst;
+  using Base::m_src;
+  using Base::m_functor;
+  
+public:
+  typedef typename Base::Scalar Scalar;
+  typedef typename Base::DstXprType DstXprType;
+  typedef swap_assign_op<Scalar> Functor;
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  generic_dense_assignment_kernel(DstEvaluatorTypeT &dst, const SrcEvaluatorTypeT &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {}
+  
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE void assignPacket(Index row, Index col)
+  {
+    PacketType tmp = m_src.template packet<LoadMode,PacketType>(row,col);
+    const_cast<SrcEvaluatorTypeT&>(m_src).template writePacket<LoadMode>(row,col, m_dst.template packet<StoreMode,PacketType>(row,col));
+    m_dst.template writePacket<StoreMode>(row,col,tmp);
+  }
+  
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE void assignPacket(Index index)
+  {
+    PacketType tmp = m_src.template packet<LoadMode,PacketType>(index);
+    const_cast<SrcEvaluatorTypeT&>(m_src).template writePacket<LoadMode>(index, m_dst.template packet<StoreMode,PacketType>(index));
+    m_dst.template writePacket<StoreMode>(index,tmp);
+  }
+  
+  // TODO find a simple way not to have to copy/paste this function from generic_dense_assignment_kernel, by simple I mean no CRTP (Gael)
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE void assignPacketByOuterInner(Index outer, Index inner)
+  {
+    Index row = Base::rowIndexByOuterInner(outer, inner); 
+    Index col = Base::colIndexByOuterInner(outer, inner);
+    assignPacket<StoreMode,LoadMode,PacketType>(row, col);
+  }
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SWAP_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Transpose.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Transpose.h
new file mode 100644
index 00000000..2bc658f4
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Transpose.h
@@ -0,0 +1,464 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSPOSE_H
+#define EIGEN_TRANSPOSE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename MatrixType>
+struct traits<Transpose<MatrixType> > : public traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type MatrixTypeNestedPlain;
+  enum {
+    RowsAtCompileTime = MatrixType::ColsAtCompileTime,
+    ColsAtCompileTime = MatrixType::RowsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags0 = traits<MatrixTypeNestedPlain>::Flags & ~(LvalueBit | NestByRefBit),
+    Flags1 = Flags0 | FlagsLvalueBit,
+    Flags = Flags1 ^ RowMajorBit,
+    InnerStrideAtCompileTime = inner_stride_at_compile_time<MatrixType>::ret,
+    OuterStrideAtCompileTime = outer_stride_at_compile_time<MatrixType>::ret
+  };
+};
+}
+
+template<typename MatrixType, typename StorageKind> class TransposeImpl;
+
+/** \class Transpose
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the transpose of a matrix
+  *
+  * \tparam MatrixType the type of the object of which we are taking the transpose
+  *
+  * This class represents an expression of the transpose of a matrix.
+  * It is the return type of MatrixBase::transpose() and MatrixBase::adjoint()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::transpose(), MatrixBase::adjoint()
+  */
+template<typename MatrixType> class Transpose
+  : public TransposeImpl<MatrixType,typename internal::traits<MatrixType>::StorageKind>
+{
+  public:
+
+    typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+
+    typedef typename TransposeImpl<MatrixType,typename internal::traits<MatrixType>::StorageKind>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Transpose)
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE Transpose(MatrixType& matrix) : m_matrix(matrix) {}
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Transpose)
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const typename internal::remove_all<MatrixTypeNested>::type&
+    nestedExpression() const { return m_matrix; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    typename internal::remove_reference<MatrixTypeNested>::type&
+    nestedExpression() { return m_matrix; }
+
+    /** \internal */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void resize(Index nrows, Index ncols) {
+      m_matrix.resize(ncols,nrows);
+    }
+
+  protected:
+    typename internal::ref_selector<MatrixType>::non_const_type m_matrix;
+};
+
+namespace internal {
+
+template<typename MatrixType, bool HasDirectAccess = has_direct_access<MatrixType>::ret>
+struct TransposeImpl_base
+{
+  typedef typename dense_xpr_base<Transpose<MatrixType> >::type type;
+};
+
+template<typename MatrixType>
+struct TransposeImpl_base<MatrixType, false>
+{
+  typedef typename dense_xpr_base<Transpose<MatrixType> >::type type;
+};
+
+} // end namespace internal
+
+// Generic API dispatcher
+template<typename XprType, typename StorageKind>
+class TransposeImpl
+  : public internal::generic_xpr_base<Transpose<XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<Transpose<XprType> >::type Base;
+};
+
+template<typename MatrixType> class TransposeImpl<MatrixType,Dense>
+  : public internal::TransposeImpl_base<MatrixType>::type
+{
+  public:
+
+    typedef typename internal::TransposeImpl_base<MatrixType>::type Base;
+    using Base::coeffRef;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Transpose<MatrixType>)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TransposeImpl)
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Index innerStride() const { return derived().nestedExpression().innerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Index outerStride() const { return derived().nestedExpression().outerStride(); }
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<MatrixType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    ScalarWithConstIfNotLvalue* data() { return derived().nestedExpression().data(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const Scalar* data() const { return derived().nestedExpression().data(); }
+
+    // FIXME: shall we keep the const version of coeffRef?
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return derived().nestedExpression().coeffRef(colId, rowId);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const Scalar& coeffRef(Index index) const
+    {
+      return derived().nestedExpression().coeffRef(index);
+    }
+  protected:
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(TransposeImpl)
+};
+
+/** \returns an expression of the transpose of *this.
+  *
+  * Example: \include MatrixBase_transpose.cpp
+  * Output: \verbinclude MatrixBase_transpose.out
+  *
+  * \warning If you want to replace a matrix by its own transpose, do \b NOT do this:
+  * \code
+  * m = m.transpose(); // bug!!! caused by aliasing effect
+  * \endcode
+  * Instead, use the transposeInPlace() method:
+  * \code
+  * m.transposeInPlace();
+  * \endcode
+  * which gives Eigen good opportunities for optimization, or alternatively you can also do:
+  * \code
+  * m = m.transpose().eval();
+  * \endcode
+  *
+  * \sa transposeInPlace(), adjoint() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+Transpose<Derived>
+DenseBase<Derived>::transpose()
+{
+  return TransposeReturnType(derived());
+}
+
+/** This is the const version of transpose().
+  *
+  * Make sure you read the warning for transpose() !
+  *
+  * \sa transposeInPlace(), adjoint() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename DenseBase<Derived>::ConstTransposeReturnType
+DenseBase<Derived>::transpose() const
+{
+  return ConstTransposeReturnType(derived());
+}
+
+/** \returns an expression of the adjoint (i.e. conjugate transpose) of *this.
+  *
+  * Example: \include MatrixBase_adjoint.cpp
+  * Output: \verbinclude MatrixBase_adjoint.out
+  *
+  * \warning If you want to replace a matrix by its own adjoint, do \b NOT do this:
+  * \code
+  * m = m.adjoint(); // bug!!! caused by aliasing effect
+  * \endcode
+  * Instead, use the adjointInPlace() method:
+  * \code
+  * m.adjointInPlace();
+  * \endcode
+  * which gives Eigen good opportunities for optimization, or alternatively you can also do:
+  * \code
+  * m = m.adjoint().eval();
+  * \endcode
+  *
+  * \sa adjointInPlace(), transpose(), conjugate(), class Transpose, class internal::scalar_conjugate_op */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const typename MatrixBase<Derived>::AdjointReturnType
+MatrixBase<Derived>::adjoint() const
+{
+  return AdjointReturnType(this->transpose());
+}
+
+/***************************************************************************
+* "in place" transpose implementation
+***************************************************************************/
+
+namespace internal {
+
+template<typename MatrixType,
+  bool IsSquare = (MatrixType::RowsAtCompileTime == MatrixType::ColsAtCompileTime) && MatrixType::RowsAtCompileTime!=Dynamic,
+  bool MatchPacketSize =
+        (int(MatrixType::RowsAtCompileTime) == int(internal::packet_traits<typename MatrixType::Scalar>::size))
+    &&  (internal::evaluator<MatrixType>::Flags&PacketAccessBit) >
+struct inplace_transpose_selector;
+
+template<typename MatrixType>
+struct inplace_transpose_selector<MatrixType,true,false> { // square matrix
+  static void run(MatrixType& m) {
+    m.matrix().template triangularView<StrictlyUpper>().swap(m.matrix().transpose().template triangularView<StrictlyUpper>());
+  }
+};
+
+template<typename MatrixType>
+struct inplace_transpose_selector<MatrixType,true,true> { // PacketSize x PacketSize
+  static void run(MatrixType& m) {
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename internal::packet_traits<typename MatrixType::Scalar>::type Packet;
+    const Index PacketSize = internal::packet_traits<Scalar>::size;
+    const Index Alignment = internal::evaluator<MatrixType>::Alignment;
+    PacketBlock<Packet> A;
+    for (Index i=0; i<PacketSize; ++i)
+      A.packet[i] = m.template packetByOuterInner<Alignment>(i,0);
+    internal::ptranspose(A);
+    for (Index i=0; i<PacketSize; ++i)
+      m.template writePacket<Alignment>(m.rowIndexByOuterInner(i,0), m.colIndexByOuterInner(i,0), A.packet[i]);
+  }
+};
+
+
+template <typename MatrixType, Index Alignment>
+void BlockedInPlaceTranspose(MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename internal::packet_traits<typename MatrixType::Scalar>::type Packet;
+  const Index PacketSize = internal::packet_traits<Scalar>::size;
+  eigen_assert(m.rows() == m.cols());
+  int row_start = 0;
+  for (; row_start + PacketSize <= m.rows(); row_start += PacketSize) {
+    for (int col_start = row_start; col_start + PacketSize <= m.cols(); col_start += PacketSize) {
+      PacketBlock<Packet> A;
+      if (row_start == col_start) {
+        for (Index i=0; i<PacketSize; ++i)
+          A.packet[i] = m.template packetByOuterInner<Alignment>(row_start + i,col_start);
+        internal::ptranspose(A);
+        for (Index i=0; i<PacketSize; ++i)
+          m.template writePacket<Alignment>(m.rowIndexByOuterInner(row_start + i, col_start), m.colIndexByOuterInner(row_start + i,col_start), A.packet[i]);
+      } else {
+        PacketBlock<Packet> B;
+        for (Index i=0; i<PacketSize; ++i) {
+          A.packet[i] = m.template packetByOuterInner<Alignment>(row_start + i,col_start);
+          B.packet[i] = m.template packetByOuterInner<Alignment>(col_start + i, row_start);
+        }
+        internal::ptranspose(A);
+        internal::ptranspose(B);
+        for (Index i=0; i<PacketSize; ++i) {
+          m.template writePacket<Alignment>(m.rowIndexByOuterInner(row_start + i, col_start), m.colIndexByOuterInner(row_start + i,col_start), B.packet[i]);
+          m.template writePacket<Alignment>(m.rowIndexByOuterInner(col_start + i, row_start), m.colIndexByOuterInner(col_start + i,row_start), A.packet[i]);
+        }
+      }
+    }
+  }
+  for (Index row = row_start; row < m.rows(); ++row) {
+    m.matrix().row(row).head(row).swap(
+        m.matrix().col(row).head(row).transpose());
+  }
+}
+
+template<typename MatrixType,bool MatchPacketSize>
+struct inplace_transpose_selector<MatrixType,false,MatchPacketSize> { // non square or dynamic matrix
+  static void run(MatrixType& m) {
+    typedef typename MatrixType::Scalar Scalar;
+    if (m.rows() == m.cols()) {
+      const Index PacketSize = internal::packet_traits<Scalar>::size;
+      if (!NumTraits<Scalar>::IsComplex && m.rows() >= PacketSize) {
+        if ((m.rows() % PacketSize) == 0)
+          BlockedInPlaceTranspose<MatrixType,internal::evaluator<MatrixType>::Alignment>(m);
+        else
+          BlockedInPlaceTranspose<MatrixType,Unaligned>(m);
+      }
+      else {
+        m.matrix().template triangularView<StrictlyUpper>().swap(m.matrix().transpose().template triangularView<StrictlyUpper>());
+      }
+    } else {
+      m = m.transpose().eval();
+    }
+  }
+};
+
+
+} // end namespace internal
+
+/** This is the "in place" version of transpose(): it replaces \c *this by its own transpose.
+  * Thus, doing
+  * \code
+  * m.transposeInPlace();
+  * \endcode
+  * has the same effect on m as doing
+  * \code
+  * m = m.transpose().eval();
+  * \endcode
+  * and is faster and also safer because in the latter line of code, forgetting the eval() results
+  * in a bug caused by \ref TopicAliasing "aliasing".
+  *
+  * Notice however that this method is only useful if you want to replace a matrix by its own transpose.
+  * If you just need the transpose of a matrix, use transpose().
+  *
+  * \note if the matrix is not square, then \c *this must be a resizable matrix.
+  * This excludes (non-square) fixed-size matrices, block-expressions and maps.
+  *
+  * \sa transpose(), adjoint(), adjointInPlace() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void DenseBase<Derived>::transposeInPlace()
+{
+  eigen_assert((rows() == cols() || (RowsAtCompileTime == Dynamic && ColsAtCompileTime == Dynamic))
+               && "transposeInPlace() called on a non-square non-resizable matrix");
+  internal::inplace_transpose_selector<Derived>::run(derived());
+}
+
+/***************************************************************************
+* "in place" adjoint implementation
+***************************************************************************/
+
+/** This is the "in place" version of adjoint(): it replaces \c *this by its own transpose.
+  * Thus, doing
+  * \code
+  * m.adjointInPlace();
+  * \endcode
+  * has the same effect on m as doing
+  * \code
+  * m = m.adjoint().eval();
+  * \endcode
+  * and is faster and also safer because in the latter line of code, forgetting the eval() results
+  * in a bug caused by aliasing.
+  *
+  * Notice however that this method is only useful if you want to replace a matrix by its own adjoint.
+  * If you just need the adjoint of a matrix, use adjoint().
+  *
+  * \note if the matrix is not square, then \c *this must be a resizable matrix.
+  * This excludes (non-square) fixed-size matrices, block-expressions and maps.
+  *
+  * \sa transpose(), adjoint(), transposeInPlace() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void MatrixBase<Derived>::adjointInPlace()
+{
+  derived() = adjoint().eval();
+}
+
+#ifndef EIGEN_NO_DEBUG
+
+// The following is to detect aliasing problems in most common cases.
+
+namespace internal {
+
+template<bool DestIsTransposed, typename OtherDerived>
+struct check_transpose_aliasing_compile_time_selector
+{
+  enum { ret = bool(blas_traits<OtherDerived>::IsTransposed) != DestIsTransposed };
+};
+
+template<bool DestIsTransposed, typename BinOp, typename DerivedA, typename DerivedB>
+struct check_transpose_aliasing_compile_time_selector<DestIsTransposed,CwiseBinaryOp<BinOp,DerivedA,DerivedB> >
+{
+  enum { ret =    bool(blas_traits<DerivedA>::IsTransposed) != DestIsTransposed
+               || bool(blas_traits<DerivedB>::IsTransposed) != DestIsTransposed
+  };
+};
+
+template<typename Scalar, bool DestIsTransposed, typename OtherDerived>
+struct check_transpose_aliasing_run_time_selector
+{
+  static bool run(const Scalar* dest, const OtherDerived& src)
+  {
+    return (bool(blas_traits<OtherDerived>::IsTransposed) != DestIsTransposed) && (dest!=0 && dest==(const Scalar*)extract_data(src));
+  }
+};
+
+template<typename Scalar, bool DestIsTransposed, typename BinOp, typename DerivedA, typename DerivedB>
+struct check_transpose_aliasing_run_time_selector<Scalar,DestIsTransposed,CwiseBinaryOp<BinOp,DerivedA,DerivedB> >
+{
+  static bool run(const Scalar* dest, const CwiseBinaryOp<BinOp,DerivedA,DerivedB>& src)
+  {
+    return ((blas_traits<DerivedA>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(const Scalar*)extract_data(src.lhs())))
+        || ((blas_traits<DerivedB>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(const Scalar*)extract_data(src.rhs())));
+  }
+};
+
+// the following selector, checkTransposeAliasing_impl, based on MightHaveTransposeAliasing,
+// is because when the condition controlling the assert is known at compile time, ICC emits a warning.
+// This is actually a good warning: in expressions that don't have any transposing, the condition is
+// known at compile time to be false, and using that, we can avoid generating the code of the assert again
+// and again for all these expressions that don't need it.
+
+template<typename Derived, typename OtherDerived,
+         bool MightHaveTransposeAliasing
+                 = check_transpose_aliasing_compile_time_selector
+                     <blas_traits<Derived>::IsTransposed,OtherDerived>::ret
+        >
+struct checkTransposeAliasing_impl
+{
+    static void run(const Derived& dst, const OtherDerived& other)
+    {
+        eigen_assert((!check_transpose_aliasing_run_time_selector
+                      <typename Derived::Scalar,blas_traits<Derived>::IsTransposed,OtherDerived>
+                      ::run(extract_data(dst), other))
+          && "aliasing detected during transposition, use transposeInPlace() "
+             "or evaluate the rhs into a temporary using .eval()");
+
+    }
+};
+
+template<typename Derived, typename OtherDerived>
+struct checkTransposeAliasing_impl<Derived, OtherDerived, false>
+{
+    static void run(const Derived&, const OtherDerived&)
+    {
+    }
+};
+
+template<typename Dst, typename Src>
+void check_for_aliasing(const Dst &dst, const Src &src)
+{
+  if((!Dst::IsVectorAtCompileTime) && dst.rows()>1 && dst.cols()>1)
+    internal::checkTransposeAliasing_impl<Dst, Src>::run(dst, src);
+}
+
+} // end namespace internal
+
+#endif // EIGEN_NO_DEBUG
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSPOSE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Transpositions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Transpositions.h
new file mode 100644
index 00000000..38a7b01c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Transpositions.h
@@ -0,0 +1,386 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSPOSITIONS_H
+#define EIGEN_TRANSPOSITIONS_H
+
+namespace Eigen {
+
+template<typename Derived>
+class TranspositionsBase
+{
+    typedef internal::traits<Derived> Traits;
+
+  public:
+
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    EIGEN_DEVICE_FUNC
+    Derived& derived() { return *static_cast<Derived*>(this); }
+    EIGEN_DEVICE_FUNC
+    const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    Derived& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      indices() = other.indices();
+      return derived();
+    }
+
+    /** \returns the number of transpositions */
+    EIGEN_DEVICE_FUNC
+    Index size() const { return indices().size(); }
+    /** \returns the number of rows of the equivalent permutation matrix */
+    EIGEN_DEVICE_FUNC
+    Index rows() const { return indices().size(); }
+    /** \returns the number of columns of the equivalent permutation matrix */
+    EIGEN_DEVICE_FUNC
+    Index cols() const { return indices().size(); }
+
+    /** Direct access to the underlying index vector */
+    EIGEN_DEVICE_FUNC
+    inline const StorageIndex& coeff(Index i) const { return indices().coeff(i); }
+    /** Direct access to the underlying index vector */
+    inline StorageIndex& coeffRef(Index i) { return indices().coeffRef(i); }
+    /** Direct access to the underlying index vector */
+    inline const StorageIndex& operator()(Index i) const { return indices()(i); }
+    /** Direct access to the underlying index vector */
+    inline StorageIndex& operator()(Index i) { return indices()(i); }
+    /** Direct access to the underlying index vector */
+    inline const StorageIndex& operator[](Index i) const { return indices()(i); }
+    /** Direct access to the underlying index vector */
+    inline StorageIndex& operator[](Index i) { return indices()(i); }
+
+    /** const version of indices(). */
+    EIGEN_DEVICE_FUNC
+    const IndicesType& indices() const { return derived().indices(); }
+    /** \returns a reference to the stored array representing the transpositions. */
+    EIGEN_DEVICE_FUNC
+    IndicesType& indices() { return derived().indices(); }
+
+    /** Resizes to given size. */
+    inline void resize(Index newSize)
+    {
+      indices().resize(newSize);
+    }
+
+    /** Sets \c *this to represents an identity transformation */
+    void setIdentity()
+    {
+      for(StorageIndex i = 0; i < indices().size(); ++i)
+        coeffRef(i) = i;
+    }
+
+    // FIXME: do we want such methods ?
+    // might be useful when the target matrix expression is complex, e.g.:
+    // object.matrix().block(..,..,..,..) = trans * object.matrix().block(..,..,..,..);
+    /*
+    template<typename MatrixType>
+    void applyForwardToRows(MatrixType& mat) const
+    {
+      for(Index k=0 ; k<size() ; ++k)
+        if(m_indices(k)!=k)
+          mat.row(k).swap(mat.row(m_indices(k)));
+    }
+
+    template<typename MatrixType>
+    void applyBackwardToRows(MatrixType& mat) const
+    {
+      for(Index k=size()-1 ; k>=0 ; --k)
+        if(m_indices(k)!=k)
+          mat.row(k).swap(mat.row(m_indices(k)));
+    }
+    */
+
+    /** \returns the inverse transformation */
+    inline Transpose<TranspositionsBase> inverse() const
+    { return Transpose<TranspositionsBase>(derived()); }
+
+    /** \returns the tranpose transformation */
+    inline Transpose<TranspositionsBase> transpose() const
+    { return Transpose<TranspositionsBase>(derived()); }
+
+  protected:
+};
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+struct traits<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+ : traits<PermutationMatrix<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+{
+  typedef Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> IndicesType;
+  typedef TranspositionsStorage StorageKind;
+};
+}
+
+/** \class Transpositions
+  * \ingroup Core_Module
+  *
+  * \brief Represents a sequence of transpositions (row/column interchange)
+  *
+  * \tparam SizeAtCompileTime the number of transpositions, or Dynamic
+  * \tparam MaxSizeAtCompileTime the maximum number of transpositions, or Dynamic. This optional parameter defaults to SizeAtCompileTime. Most of the time, you should not have to specify it.
+  *
+  * This class represents a permutation transformation as a sequence of \em n transpositions
+  * \f$[T_{n-1} \ldots T_{i} \ldots T_{0}]\f$. It is internally stored as a vector of integers \c indices.
+  * Each transposition \f$ T_{i} \f$ applied on the left of a matrix (\f$ T_{i} M\f$) interchanges
+  * the rows \c i and \c indices[i] of the matrix \c M.
+  * A transposition applied on the right (e.g., \f$ M T_{i}\f$) yields a column interchange.
+  *
+  * Compared to the class PermutationMatrix, such a sequence of transpositions is what is
+  * computed during a decomposition with pivoting, and it is faster when applying the permutation in-place.
+  *
+  * To apply a sequence of transpositions to a matrix, simply use the operator * as in the following example:
+  * \code
+  * Transpositions tr;
+  * MatrixXf mat;
+  * mat = tr * mat;
+  * \endcode
+  * In this example, we detect that the matrix appears on both side, and so the transpositions
+  * are applied in-place without any temporary or extra copy.
+  *
+  * \sa class PermutationMatrix
+  */
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+class Transpositions : public TranspositionsBase<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+{
+    typedef internal::traits<Transpositions> Traits;
+  public:
+
+    typedef TranspositionsBase<Transpositions> Base;
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+
+    inline Transpositions() {}
+
+    /** Copy constructor. */
+    template<typename OtherDerived>
+    inline Transpositions(const TranspositionsBase<OtherDerived>& other)
+      : m_indices(other.indices()) {}
+
+    /** Generic constructor from expression of the transposition indices. */
+    template<typename Other>
+    explicit inline Transpositions(const MatrixBase<Other>& indices) : m_indices(indices)
+    {}
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    Transpositions& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      return Base::operator=(other);
+    }
+
+    /** Constructs an uninitialized permutation matrix of given size.
+      */
+    inline Transpositions(Index size) : m_indices(size)
+    {}
+
+    /** const version of indices(). */
+    EIGEN_DEVICE_FUNC
+    const IndicesType& indices() const { return m_indices; }
+    /** \returns a reference to the stored array representing the transpositions. */
+    EIGEN_DEVICE_FUNC
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess>
+struct traits<Map<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex>,_PacketAccess> >
+ : traits<PermutationMatrix<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+{
+  typedef Map<const Matrix<_StorageIndex,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1>, _PacketAccess> IndicesType;
+  typedef _StorageIndex StorageIndex;
+  typedef TranspositionsStorage StorageKind;
+};
+}
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int PacketAccess>
+class Map<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex>,PacketAccess>
+ : public TranspositionsBase<Map<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex>,PacketAccess> >
+{
+    typedef internal::traits<Map> Traits;
+  public:
+
+    typedef TranspositionsBase<Map> Base;
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+
+    explicit inline Map(const StorageIndex* indicesPtr)
+      : m_indices(indicesPtr)
+    {}
+
+    inline Map(const StorageIndex* indicesPtr, Index size)
+      : m_indices(indicesPtr,size)
+    {}
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    Map& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      return Base::operator=(other);
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    Map& operator=(const Map& other)
+    {
+      m_indices = other.m_indices;
+      return *this;
+    }
+    #endif
+
+    /** const version of indices(). */
+    EIGEN_DEVICE_FUNC
+    const IndicesType& indices() const { return m_indices; }
+
+    /** \returns a reference to the stored array representing the transpositions. */
+    EIGEN_DEVICE_FUNC
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+namespace internal {
+template<typename _IndicesType>
+struct traits<TranspositionsWrapper<_IndicesType> >
+ : traits<PermutationWrapper<_IndicesType> >
+{
+  typedef TranspositionsStorage StorageKind;
+};
+}
+
+template<typename _IndicesType>
+class TranspositionsWrapper
+ : public TranspositionsBase<TranspositionsWrapper<_IndicesType> >
+{
+    typedef internal::traits<TranspositionsWrapper> Traits;
+  public:
+
+    typedef TranspositionsBase<TranspositionsWrapper> Base;
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+
+    explicit inline TranspositionsWrapper(IndicesType& indices)
+      : m_indices(indices)
+    {}
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    TranspositionsWrapper& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      return Base::operator=(other);
+    }
+
+    /** const version of indices(). */
+    EIGEN_DEVICE_FUNC
+    const IndicesType& indices() const { return m_indices; }
+
+    /** \returns a reference to the stored array representing the transpositions. */
+    EIGEN_DEVICE_FUNC
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    typename IndicesType::Nested m_indices;
+};
+
+
+
+/** \returns the \a matrix with the \a transpositions applied to the columns.
+  */
+template<typename MatrixDerived, typename TranspositionsDerived>
+EIGEN_DEVICE_FUNC
+const Product<MatrixDerived, TranspositionsDerived, AliasFreeProduct>
+operator*(const MatrixBase<MatrixDerived> &matrix,
+          const TranspositionsBase<TranspositionsDerived>& transpositions)
+{
+  return Product<MatrixDerived, TranspositionsDerived, AliasFreeProduct>
+            (matrix.derived(), transpositions.derived());
+}
+
+/** \returns the \a matrix with the \a transpositions applied to the rows.
+  */
+template<typename TranspositionsDerived, typename MatrixDerived>
+EIGEN_DEVICE_FUNC
+const Product<TranspositionsDerived, MatrixDerived, AliasFreeProduct>
+operator*(const TranspositionsBase<TranspositionsDerived> &transpositions,
+          const MatrixBase<MatrixDerived>& matrix)
+{
+  return Product<TranspositionsDerived, MatrixDerived, AliasFreeProduct>
+            (transpositions.derived(), matrix.derived());
+}
+
+// Template partial specialization for transposed/inverse transpositions
+
+namespace internal {
+
+template<typename Derived>
+struct traits<Transpose<TranspositionsBase<Derived> > >
+ : traits<Derived>
+{};
+
+} // end namespace internal
+
+template<typename TranspositionsDerived>
+class Transpose<TranspositionsBase<TranspositionsDerived> >
+{
+    typedef TranspositionsDerived TranspositionType;
+    typedef typename TranspositionType::IndicesType IndicesType;
+  public:
+
+    explicit Transpose(const TranspositionType& t) : m_transpositions(t) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index size() const EIGEN_NOEXCEPT { return m_transpositions.size(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_transpositions.size(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_transpositions.size(); }
+
+    /** \returns the \a matrix with the inverse transpositions applied to the columns.
+      */
+    template<typename OtherDerived> friend
+    const Product<OtherDerived, Transpose, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix, const Transpose& trt)
+    {
+      return Product<OtherDerived, Transpose, AliasFreeProduct>(matrix.derived(), trt);
+    }
+
+    /** \returns the \a matrix with the inverse transpositions applied to the rows.
+      */
+    template<typename OtherDerived>
+    const Product<Transpose, OtherDerived, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix) const
+    {
+      return Product<Transpose, OtherDerived, AliasFreeProduct>(*this, matrix.derived());
+    }
+
+    EIGEN_DEVICE_FUNC
+    const TranspositionType& nestedExpression() const { return m_transpositions; }
+
+  protected:
+    const TranspositionType& m_transpositions;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSPOSITIONS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/TriangularMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/Core/TriangularMatrix.h
new file mode 100644
index 00000000..fdb8bc15
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/TriangularMatrix.h
@@ -0,0 +1,1001 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULARMATRIX_H
+#define EIGEN_TRIANGULARMATRIX_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<int Side, typename TriangularType, typename Rhs> struct triangular_solve_retval;
+
+}
+
+/** \class TriangularBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for triangular part in a matrix
+  */
+template<typename Derived> class TriangularBase : public EigenBase<Derived>
+{
+  public:
+
+    enum {
+      Mode = internal::traits<Derived>::Mode,
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                   internal::traits<Derived>::ColsAtCompileTime>::ret),
+      /**< This is equal to the number of coefficients, i.e. the number of
+          * rows times the number of columns, or to \a Dynamic if this is not
+          * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
+
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
+                                                   internal::traits<Derived>::MaxColsAtCompileTime>::ret)
+
+    };
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+    typedef typename internal::traits<Derived>::FullMatrixType DenseMatrixType;
+    typedef DenseMatrixType DenseType;
+    typedef Derived const& Nested;
+
+    EIGEN_DEVICE_FUNC
+    inline TriangularBase() { eigen_assert(!((int(Mode) & int(UnitDiag)) && (int(Mode) & int(ZeroDiag)))); }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return derived().rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return derived().cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return derived().outerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return derived().innerStride(); }
+
+    // dummy resize function
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols)
+    {
+      EIGEN_UNUSED_VARIABLE(rows);
+      EIGEN_UNUSED_VARIABLE(cols);
+      eigen_assert(rows==this->rows() && cols==this->cols());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar coeff(Index row, Index col) const  { return derived().coeff(row,col); }
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index col) { return derived().coeffRef(row,col); }
+
+    /** \see MatrixBase::copyCoeff(row,col)
+      */
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void copyCoeff(Index row, Index col, Other& other)
+    {
+      derived().coeffRef(row, col) = other.coeff(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar operator()(Index row, Index col) const
+    {
+      check_coordinates(row, col);
+      return coeff(row,col);
+    }
+    EIGEN_DEVICE_FUNC
+    inline Scalar& operator()(Index row, Index col)
+    {
+      check_coordinates(row, col);
+      return coeffRef(row,col);
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    EIGEN_DEVICE_FUNC
+    inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    EIGEN_DEVICE_FUNC
+    inline Derived& derived() { return *static_cast<Derived*>(this); }
+    #endif // not EIGEN_PARSED_BY_DOXYGEN
+
+    template<typename DenseDerived>
+    EIGEN_DEVICE_FUNC
+    void evalTo(MatrixBase<DenseDerived> &other) const;
+    template<typename DenseDerived>
+    EIGEN_DEVICE_FUNC
+    void evalToLazy(MatrixBase<DenseDerived> &other) const;
+
+    EIGEN_DEVICE_FUNC
+    DenseMatrixType toDenseMatrix() const
+    {
+      DenseMatrixType res(rows(), cols());
+      evalToLazy(res);
+      return res;
+    }
+
+  protected:
+
+    void check_coordinates(Index row, Index col) const
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(row);
+      EIGEN_ONLY_USED_FOR_DEBUG(col);
+      eigen_assert(col>=0 && col<cols() && row>=0 && row<rows());
+      const int mode = int(Mode) & ~SelfAdjoint;
+      EIGEN_ONLY_USED_FOR_DEBUG(mode);
+      eigen_assert((mode==Upper && col>=row)
+                || (mode==Lower && col<=row)
+                || ((mode==StrictlyUpper || mode==UnitUpper) && col>row)
+                || ((mode==StrictlyLower || mode==UnitLower) && col<row));
+    }
+
+    #ifdef EIGEN_INTERNAL_DEBUGGING
+    void check_coordinates_internal(Index row, Index col) const
+    {
+      check_coordinates(row, col);
+    }
+    #else
+    void check_coordinates_internal(Index , Index ) const {}
+    #endif
+
+};
+
+/** \class TriangularView
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a triangular part in a matrix
+  *
+  * \param MatrixType the type of the object in which we are taking the triangular part
+  * \param Mode the kind of triangular matrix expression to construct. Can be #Upper,
+  *             #Lower, #UnitUpper, #UnitLower, #StrictlyUpper, or #StrictlyLower.
+  *             This is in fact a bit field; it must have either #Upper or #Lower,
+  *             and additionally it may have #UnitDiag or #ZeroDiag or neither.
+  *
+  * This class represents a triangular part of a matrix, not necessarily square. Strictly speaking, for rectangular
+  * matrices one should speak of "trapezoid" parts. This class is the return type
+  * of MatrixBase::triangularView() and SparseMatrixBase::triangularView(), and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::triangularView()
+  */
+namespace internal {
+template<typename MatrixType, unsigned int _Mode>
+struct traits<TriangularView<MatrixType, _Mode> > : traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
+  typedef typename remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
+  typedef typename MatrixType::PlainObject FullMatrixType;
+  typedef MatrixType ExpressionType;
+  enum {
+    Mode = _Mode,
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags = (MatrixTypeNestedCleaned::Flags & (HereditaryBits | FlagsLvalueBit) & (~(PacketAccessBit | DirectAccessBit | LinearAccessBit)))
+  };
+};
+}
+
+template<typename _MatrixType, unsigned int _Mode, typename StorageKind> class TriangularViewImpl;
+
+template<typename _MatrixType, unsigned int _Mode> class TriangularView
+  : public TriangularViewImpl<_MatrixType, _Mode, typename internal::traits<_MatrixType>::StorageKind >
+{
+  public:
+
+    typedef TriangularViewImpl<_MatrixType, _Mode, typename internal::traits<_MatrixType>::StorageKind > Base;
+    typedef typename internal::traits<TriangularView>::Scalar Scalar;
+    typedef _MatrixType MatrixType;
+
+  protected:
+    typedef typename internal::traits<TriangularView>::MatrixTypeNested MatrixTypeNested;
+    typedef typename internal::traits<TriangularView>::MatrixTypeNestedNonRef MatrixTypeNestedNonRef;
+
+    typedef typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType;
+    typedef TriangularView<typename internal::add_const<MatrixType>::type, _Mode> ConstTriangularView;
+
+  public:
+
+    typedef typename internal::traits<TriangularView>::StorageKind StorageKind;
+    typedef typename internal::traits<TriangularView>::MatrixTypeNestedCleaned NestedExpression;
+
+    enum {
+      Mode = _Mode,
+      Flags = internal::traits<TriangularView>::Flags,
+      TransposeMode = (Mode & Upper ? Lower : 0)
+                    | (Mode & Lower ? Upper : 0)
+                    | (Mode & (UnitDiag))
+                    | (Mode & (ZeroDiag)),
+      IsVectorAtCompileTime = false
+    };
+
+    EIGEN_DEVICE_FUNC
+    explicit inline TriangularView(MatrixType& matrix) : m_matrix(matrix)
+    {}
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TriangularView)
+
+    /** \copydoc EigenBase::rows() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    /** \copydoc EigenBase::cols() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+    /** \returns a const reference to the nested expression */
+    EIGEN_DEVICE_FUNC
+    const NestedExpression& nestedExpression() const { return m_matrix; }
+
+    /** \returns a reference to the nested expression */
+    EIGEN_DEVICE_FUNC
+    NestedExpression& nestedExpression() { return m_matrix; }
+
+    typedef TriangularView<const MatrixConjugateReturnType,Mode> ConjugateReturnType;
+    /** \sa MatrixBase::conjugate() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConjugateReturnType conjugate() const
+    { return ConjugateReturnType(m_matrix.conjugate()); }
+
+    /** \returns an expression of the complex conjugate of \c *this if Cond==true,
+     *           returns \c *this otherwise.
+     */
+    template<bool Cond>
+    EIGEN_DEVICE_FUNC
+    inline typename internal::conditional<Cond,ConjugateReturnType,ConstTriangularView>::type
+    conjugateIf() const
+    {
+      typedef typename internal::conditional<Cond,ConjugateReturnType,ConstTriangularView>::type ReturnType;
+      return ReturnType(m_matrix.template conjugateIf<Cond>());
+    }
+
+    typedef TriangularView<const typename MatrixType::AdjointReturnType,TransposeMode> AdjointReturnType;
+    /** \sa MatrixBase::adjoint() const */
+    EIGEN_DEVICE_FUNC
+    inline const AdjointReturnType adjoint() const
+    { return AdjointReturnType(m_matrix.adjoint()); }
+
+    typedef TriangularView<typename MatrixType::TransposeReturnType,TransposeMode> TransposeReturnType;
+     /** \sa MatrixBase::transpose() */
+    EIGEN_DEVICE_FUNC
+    inline TransposeReturnType transpose()
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      typename MatrixType::TransposeReturnType tmp(m_matrix);
+      return TransposeReturnType(tmp);
+    }
+
+    typedef TriangularView<const typename MatrixType::ConstTransposeReturnType,TransposeMode> ConstTransposeReturnType;
+    /** \sa MatrixBase::transpose() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConstTransposeReturnType transpose() const
+    {
+      return ConstTransposeReturnType(m_matrix.transpose());
+    }
+
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    inline const Solve<TriangularView, Other>
+    solve(const MatrixBase<Other>& other) const
+    { return Solve<TriangularView, Other>(*this, other.derived()); }
+
+  // workaround MSVC ICE
+  #if EIGEN_COMP_MSVC
+    template<int Side, typename Other>
+    EIGEN_DEVICE_FUNC
+    inline const internal::triangular_solve_retval<Side,TriangularView, Other>
+    solve(const MatrixBase<Other>& other) const
+    { return Base::template solve<Side>(other); }
+  #else
+    using Base::solve;
+  #endif
+
+    /** \returns a selfadjoint view of the referenced triangular part which must be either \c #Upper or \c #Lower.
+      *
+      * This is a shortcut for \code this->nestedExpression().selfadjointView<(*this)::Mode>() \endcode
+      * \sa MatrixBase::selfadjointView() */
+    EIGEN_DEVICE_FUNC
+    SelfAdjointView<MatrixTypeNestedNonRef,Mode> selfadjointView()
+    {
+      EIGEN_STATIC_ASSERT((Mode&(UnitDiag|ZeroDiag))==0,PROGRAMMING_ERROR);
+      return SelfAdjointView<MatrixTypeNestedNonRef,Mode>(m_matrix);
+    }
+
+    /** This is the const version of selfadjointView() */
+    EIGEN_DEVICE_FUNC
+    const SelfAdjointView<MatrixTypeNestedNonRef,Mode> selfadjointView() const
+    {
+      EIGEN_STATIC_ASSERT((Mode&(UnitDiag|ZeroDiag))==0,PROGRAMMING_ERROR);
+      return SelfAdjointView<MatrixTypeNestedNonRef,Mode>(m_matrix);
+    }
+
+
+    /** \returns the determinant of the triangular matrix
+      * \sa MatrixBase::determinant() */
+    EIGEN_DEVICE_FUNC
+    Scalar determinant() const
+    {
+      if (Mode & UnitDiag)
+        return 1;
+      else if (Mode & ZeroDiag)
+        return 0;
+      else
+        return m_matrix.diagonal().prod();
+    }
+
+  protected:
+
+    MatrixTypeNested m_matrix;
+};
+
+/** \ingroup Core_Module
+  *
+  * \brief Base class for a triangular part in a \b dense matrix
+  *
+  * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be instantiated.
+  * It extends class TriangularView with additional methods which available for dense expressions only.
+  *
+  * \sa class TriangularView, MatrixBase::triangularView()
+  */
+template<typename _MatrixType, unsigned int _Mode> class TriangularViewImpl<_MatrixType,_Mode,Dense>
+  : public TriangularBase<TriangularView<_MatrixType, _Mode> >
+{
+  public:
+
+    typedef TriangularView<_MatrixType, _Mode> TriangularViewType;
+    typedef TriangularBase<TriangularViewType> Base;
+    typedef typename internal::traits<TriangularViewType>::Scalar Scalar;
+
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::PlainObject DenseMatrixType;
+    typedef DenseMatrixType PlainObject;
+
+  public:
+    using Base::evalToLazy;
+    using Base::derived;
+
+    typedef typename internal::traits<TriangularViewType>::StorageKind StorageKind;
+
+    enum {
+      Mode = _Mode,
+      Flags = internal::traits<TriangularViewType>::Flags
+    };
+
+    /** \returns the outer-stride of the underlying dense matrix
+      * \sa DenseCoeffsBase::outerStride() */
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const { return derived().nestedExpression().outerStride(); }
+    /** \returns the inner-stride of the underlying dense matrix
+      * \sa DenseCoeffsBase::innerStride() */
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const { return derived().nestedExpression().innerStride(); }
+
+    /** \sa MatrixBase::operator+=() */
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator+=(const DenseBase<Other>& other) {
+      internal::call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename Other::Scalar>());
+      return derived();
+    }
+    /** \sa MatrixBase::operator-=() */
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator-=(const DenseBase<Other>& other) {
+      internal::call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename Other::Scalar>());
+      return derived();
+    }
+
+    /** \sa MatrixBase::operator*=() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator*=(const typename internal::traits<MatrixType>::Scalar& other) { return *this = derived().nestedExpression() * other; }
+    /** \sa DenseBase::operator/=() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator/=(const typename internal::traits<MatrixType>::Scalar& other) { return *this = derived().nestedExpression() / other; }
+
+    /** \sa MatrixBase::fill() */
+    EIGEN_DEVICE_FUNC
+    void fill(const Scalar& value) { setConstant(value); }
+    /** \sa MatrixBase::setConstant() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& setConstant(const Scalar& value)
+    { return *this = MatrixType::Constant(derived().rows(), derived().cols(), value); }
+    /** \sa MatrixBase::setZero() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& setZero() { return setConstant(Scalar(0)); }
+    /** \sa MatrixBase::setOnes() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& setOnes() { return setConstant(Scalar(1)); }
+
+    /** \sa MatrixBase::coeff()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar coeff(Index row, Index col) const
+    {
+      Base::check_coordinates_internal(row, col);
+      return derived().nestedExpression().coeff(row, col);
+    }
+
+    /** \sa MatrixBase::coeffRef()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(TriangularViewType);
+      Base::check_coordinates_internal(row, col);
+      return derived().nestedExpression().coeffRef(row, col);
+    }
+
+    /** Assigns a triangular matrix to a triangular part of a dense matrix */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& operator=(const TriangularBase<OtherDerived>& other);
+
+    /** Shortcut for\code *this = other.other.triangularView<(*this)::Mode>() \endcode */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& operator=(const MatrixBase<OtherDerived>& other);
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& operator=(const TriangularViewImpl& other)
+    { return *this = other.derived().nestedExpression(); }
+
+    template<typename OtherDerived>
+    /** \deprecated */
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
+    void lazyAssign(const TriangularBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    /** \deprecated */
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
+    void lazyAssign(const MatrixBase<OtherDerived>& other);
+#endif
+
+    /** Efficient triangular matrix times vector/matrix product */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<TriangularViewType,OtherDerived>
+    operator*(const MatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<TriangularViewType,OtherDerived>(derived(), rhs.derived());
+    }
+
+    /** Efficient vector/matrix times triangular matrix product */
+    template<typename OtherDerived> friend
+    EIGEN_DEVICE_FUNC
+    const Product<OtherDerived,TriangularViewType>
+    operator*(const MatrixBase<OtherDerived>& lhs, const TriangularViewImpl& rhs)
+    {
+      return Product<OtherDerived,TriangularViewType>(lhs.derived(),rhs.derived());
+    }
+
+    /** \returns the product of the inverse of \c *this with \a other, \a *this being triangular.
+      *
+      * This function computes the inverse-matrix matrix product inverse(\c *this) * \a other if
+      * \a Side==OnTheLeft (the default), or the right-inverse-multiply  \a other * inverse(\c *this) if
+      * \a Side==OnTheRight.
+      *
+      * Note that the template parameter \c Side can be omitted, in which case \c Side==OnTheLeft
+      *
+      * The matrix \c *this must be triangular and invertible (i.e., all the coefficients of the
+      * diagonal must be non zero). It works as a forward (resp. backward) substitution if \c *this
+      * is an upper (resp. lower) triangular matrix.
+      *
+      * Example: \include Triangular_solve.cpp
+      * Output: \verbinclude Triangular_solve.out
+      *
+      * This function returns an expression of the inverse-multiply and can works in-place if it is assigned
+      * to the same matrix or vector \a other.
+      *
+      * For users coming from BLAS, this function (and more specifically solveInPlace()) offer
+      * all the operations supported by the \c *TRSV and \c *TRSM BLAS routines.
+      *
+      * \sa TriangularView::solveInPlace()
+      */
+    template<int Side, typename Other>
+    inline const internal::triangular_solve_retval<Side,TriangularViewType, Other>
+    solve(const MatrixBase<Other>& other) const;
+
+    /** "in-place" version of TriangularView::solve() where the result is written in \a other
+      *
+      * \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here.
+      * This function will const_cast it, so constness isn't honored here.
+      *
+      * Note that the template parameter \c Side can be omitted, in which case \c Side==OnTheLeft
+      *
+      * See TriangularView:solve() for the details.
+      */
+    template<int Side, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void solveInPlace(const MatrixBase<OtherDerived>& other) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void solveInPlace(const MatrixBase<OtherDerived>& other) const
+    { return solveInPlace<OnTheLeft>(other); }
+
+    /** Swaps the coefficients of the common triangular parts of two matrices */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+    void swap(TriangularBase<OtherDerived> &other)
+#else
+    void swap(TriangularBase<OtherDerived> const & other)
+#endif
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(OtherDerived);
+      call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    /** Shortcut for \code (*this).swap(other.triangularView<(*this)::Mode>()) \endcode */
+    template<typename OtherDerived>
+    /** \deprecated */
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
+    void swap(MatrixBase<OtherDerived> const & other)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(OtherDerived);
+      call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    template<typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _solve_impl(const RhsType &rhs, DstType &dst) const {
+      if(!internal::is_same_dense(dst,rhs))
+        dst = rhs;
+      this->solveInPlace(dst);
+    }
+
+    template<typename ProductType>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE TriangularViewType& _assignProduct(const ProductType& prod, const Scalar& alpha, bool beta);
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(TriangularViewImpl)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(TriangularViewImpl)
+
+};
+
+/***************************************************************************
+* Implementation of triangular evaluation/assignment
+***************************************************************************/
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+// FIXME should we keep that possibility
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline TriangularView<MatrixType, Mode>&
+TriangularViewImpl<MatrixType, Mode, Dense>::operator=(const MatrixBase<OtherDerived>& other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+// FIXME should we keep that possibility
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const MatrixBase<OtherDerived>& other)
+{
+  internal::call_assignment_no_alias(derived(), other.template triangularView<Mode>());
+}
+
+
+
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline TriangularView<MatrixType, Mode>&
+TriangularViewImpl<MatrixType, Mode, Dense>::operator=(const TriangularBase<OtherDerived>& other)
+{
+  eigen_assert(Mode == int(OtherDerived::Mode));
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const TriangularBase<OtherDerived>& other)
+{
+  eigen_assert(Mode == int(OtherDerived::Mode));
+  internal::call_assignment_no_alias(derived(), other.derived());
+}
+#endif
+
+/***************************************************************************
+* Implementation of TriangularBase methods
+***************************************************************************/
+
+/** Assigns a triangular or selfadjoint matrix to a dense matrix.
+  * If the matrix is triangular, the opposite part is set to zero. */
+template<typename Derived>
+template<typename DenseDerived>
+EIGEN_DEVICE_FUNC void TriangularBase<Derived>::evalTo(MatrixBase<DenseDerived> &other) const
+{
+  evalToLazy(other.derived());
+}
+
+/***************************************************************************
+* Implementation of TriangularView methods
+***************************************************************************/
+
+/***************************************************************************
+* Implementation of MatrixBase methods
+***************************************************************************/
+
+/**
+  * \returns an expression of a triangular view extracted from the current matrix
+  *
+  * The parameter \a Mode can have the following values: \c #Upper, \c #StrictlyUpper, \c #UnitUpper,
+  * \c #Lower, \c #StrictlyLower, \c #UnitLower.
+  *
+  * Example: \include MatrixBase_triangularView.cpp
+  * Output: \verbinclude MatrixBase_triangularView.out
+  *
+  * \sa class TriangularView
+  */
+template<typename Derived>
+template<unsigned int Mode>
+EIGEN_DEVICE_FUNC
+typename MatrixBase<Derived>::template TriangularViewReturnType<Mode>::Type
+MatrixBase<Derived>::triangularView()
+{
+  return typename TriangularViewReturnType<Mode>::Type(derived());
+}
+
+/** This is the const version of MatrixBase::triangularView() */
+template<typename Derived>
+template<unsigned int Mode>
+EIGEN_DEVICE_FUNC
+typename MatrixBase<Derived>::template ConstTriangularViewReturnType<Mode>::Type
+MatrixBase<Derived>::triangularView() const
+{
+  return typename ConstTriangularViewReturnType<Mode>::Type(derived());
+}
+
+/** \returns true if *this is approximately equal to an upper triangular matrix,
+  *          within the precision given by \a prec.
+  *
+  * \sa isLowerTriangular()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isUpperTriangular(const RealScalar& prec) const
+{
+  RealScalar maxAbsOnUpperPart = static_cast<RealScalar>(-1);
+  for(Index j = 0; j < cols(); ++j)
+  {
+    Index maxi = numext::mini(j, rows()-1);
+    for(Index i = 0; i <= maxi; ++i)
+    {
+      RealScalar absValue = numext::abs(coeff(i,j));
+      if(absValue > maxAbsOnUpperPart) maxAbsOnUpperPart = absValue;
+    }
+  }
+  RealScalar threshold = maxAbsOnUpperPart * prec;
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = j+1; i < rows(); ++i)
+      if(numext::abs(coeff(i, j)) > threshold) return false;
+  return true;
+}
+
+/** \returns true if *this is approximately equal to a lower triangular matrix,
+  *          within the precision given by \a prec.
+  *
+  * \sa isUpperTriangular()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isLowerTriangular(const RealScalar& prec) const
+{
+  RealScalar maxAbsOnLowerPart = static_cast<RealScalar>(-1);
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = j; i < rows(); ++i)
+    {
+      RealScalar absValue = numext::abs(coeff(i,j));
+      if(absValue > maxAbsOnLowerPart) maxAbsOnLowerPart = absValue;
+    }
+  RealScalar threshold = maxAbsOnLowerPart * prec;
+  for(Index j = 1; j < cols(); ++j)
+  {
+    Index maxi = numext::mini(j, rows()-1);
+    for(Index i = 0; i < maxi; ++i)
+      if(numext::abs(coeff(i, j)) > threshold) return false;
+  }
+  return true;
+}
+
+
+/***************************************************************************
+****************************************************************************
+* Evaluators and Assignment of triangular expressions
+***************************************************************************
+***************************************************************************/
+
+namespace internal {
+
+
+// TODO currently a triangular expression has the form TriangularView<.,.>
+//      in the future triangular-ness should be defined by the expression traits
+//      such that Transpose<TriangularView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
+template<typename MatrixType, unsigned int Mode>
+struct evaluator_traits<TriangularView<MatrixType,Mode> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef typename glue_shapes<typename evaluator_traits<MatrixType>::Shape, TriangularShape>::type Shape;
+};
+
+template<typename MatrixType, unsigned int Mode>
+struct unary_evaluator<TriangularView<MatrixType,Mode>, IndexBased>
+ : evaluator<typename internal::remove_all<MatrixType>::type>
+{
+  typedef TriangularView<MatrixType,Mode> XprType;
+  typedef evaluator<typename internal::remove_all<MatrixType>::type> Base;
+  EIGEN_DEVICE_FUNC
+  unary_evaluator(const XprType &xpr) : Base(xpr.nestedExpression()) {}
+};
+
+// Additional assignment kinds:
+struct Triangular2Triangular    {};
+struct Triangular2Dense         {};
+struct Dense2Triangular         {};
+
+
+template<typename Kernel, unsigned int Mode, int UnrollCount, bool ClearOpposite> struct triangular_assignment_loop;
+
+
+/** \internal Specialization of the dense assignment kernel for triangular matrices.
+  * The main difference is that the triangular, diagonal, and opposite parts are processed through three different functions.
+  * \tparam UpLo must be either Lower or Upper
+  * \tparam Mode must be either 0, UnitDiag, ZeroDiag, or SelfAdjoint
+  */
+template<int UpLo, int Mode, int SetOpposite, typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version = Specialized>
+class triangular_dense_assignment_kernel : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> Base;
+  typedef typename Base::DstXprType DstXprType;
+  typedef typename Base::SrcXprType SrcXprType;
+  using Base::m_dst;
+  using Base::m_src;
+  using Base::m_functor;
+public:
+
+  typedef typename Base::DstEvaluatorType DstEvaluatorType;
+  typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
+  typedef typename Base::Scalar Scalar;
+  typedef typename Base::AssignmentTraits AssignmentTraits;
+
+
+  EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {}
+
+#ifdef EIGEN_INTERNAL_DEBUGGING
+  EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
+  {
+    eigen_internal_assert(row!=col);
+    Base::assignCoeff(row,col);
+  }
+#else
+  using Base::assignCoeff;
+#endif
+
+  EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
+  {
+         if(Mode==UnitDiag && SetOpposite) m_functor.assignCoeff(m_dst.coeffRef(id,id), Scalar(1));
+    else if(Mode==ZeroDiag && SetOpposite) m_functor.assignCoeff(m_dst.coeffRef(id,id), Scalar(0));
+    else if(Mode==0)                       Base::assignCoeff(id,id);
+  }
+
+  EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index row, Index col)
+  {
+    eigen_internal_assert(row!=col);
+    if(SetOpposite)
+      m_functor.assignCoeff(m_dst.coeffRef(row,col), Scalar(0));
+  }
+};
+
+template<int Mode, bool SetOpposite, typename DstXprType, typename SrcXprType, typename Functor>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_triangular_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
+{
+  typedef evaluator<DstXprType> DstEvaluatorType;
+  typedef evaluator<SrcXprType> SrcEvaluatorType;
+
+  SrcEvaluatorType srcEvaluator(src);
+
+  Index dstRows = src.rows();
+  Index dstCols = src.cols();
+  if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+    dst.resize(dstRows, dstCols);
+  DstEvaluatorType dstEvaluator(dst);
+
+  typedef triangular_dense_assignment_kernel< Mode&(Lower|Upper),Mode&(UnitDiag|ZeroDiag|SelfAdjoint),SetOpposite,
+                                              DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
+  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+
+  enum {
+      unroll = DstXprType::SizeAtCompileTime != Dynamic
+            && SrcEvaluatorType::CoeffReadCost < HugeCost
+            && DstXprType::SizeAtCompileTime * (int(DstEvaluatorType::CoeffReadCost) + int(SrcEvaluatorType::CoeffReadCost)) / 2 <= EIGEN_UNROLLING_LIMIT
+    };
+
+  triangular_assignment_loop<Kernel, Mode, unroll ? int(DstXprType::SizeAtCompileTime) : Dynamic, SetOpposite>::run(kernel);
+}
+
+template<int Mode, bool SetOpposite, typename DstXprType, typename SrcXprType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_triangular_assignment_loop(DstXprType& dst, const SrcXprType& src)
+{
+  call_triangular_assignment_loop<Mode,SetOpposite>(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
+}
+
+template<> struct AssignmentKind<TriangularShape,TriangularShape> { typedef Triangular2Triangular Kind; };
+template<> struct AssignmentKind<DenseShape,TriangularShape>      { typedef Triangular2Dense      Kind; };
+template<> struct AssignmentKind<TriangularShape,DenseShape>      { typedef Dense2Triangular      Kind; };
+
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Triangular2Triangular>
+{
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    eigen_assert(int(DstXprType::Mode) == int(SrcXprType::Mode));
+
+    call_triangular_assignment_loop<DstXprType::Mode, false>(dst, src, func);
+  }
+};
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Triangular2Dense>
+{
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    call_triangular_assignment_loop<SrcXprType::Mode, (int(SrcXprType::Mode) & int(SelfAdjoint)) == 0>(dst, src, func);
+  }
+};
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Dense2Triangular>
+{
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    call_triangular_assignment_loop<DstXprType::Mode, false>(dst, src, func);
+  }
+};
+
+
+template<typename Kernel, unsigned int Mode, int UnrollCount, bool SetOpposite>
+struct triangular_assignment_loop
+{
+  // FIXME: this is not very clean, perhaps this information should be provided by the kernel?
+  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
+  typedef typename DstEvaluatorType::XprType DstXprType;
+
+  enum {
+    col = (UnrollCount-1) / DstXprType::RowsAtCompileTime,
+    row = (UnrollCount-1) % DstXprType::RowsAtCompileTime
+  };
+
+  typedef typename Kernel::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  static inline void run(Kernel &kernel)
+  {
+    triangular_assignment_loop<Kernel, Mode, UnrollCount-1, SetOpposite>::run(kernel);
+
+    if(row==col)
+      kernel.assignDiagonalCoeff(row);
+    else if( ((Mode&Lower) && row>col) || ((Mode&Upper) && row<col) )
+      kernel.assignCoeff(row,col);
+    else if(SetOpposite)
+      kernel.assignOppositeCoeff(row,col);
+  }
+};
+
+// prevent buggy user code from causing an infinite recursion
+template<typename Kernel, unsigned int Mode, bool SetOpposite>
+struct triangular_assignment_loop<Kernel, Mode, 0, SetOpposite>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(Kernel &) {}
+};
+
+
+
+// TODO: experiment with a recursive assignment procedure splitting the current
+//       triangular part into one rectangular and two triangular parts.
+
+
+template<typename Kernel, unsigned int Mode, bool SetOpposite>
+struct triangular_assignment_loop<Kernel, Mode, Dynamic, SetOpposite>
+{
+  typedef typename Kernel::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  static inline void run(Kernel &kernel)
+  {
+    for(Index j = 0; j < kernel.cols(); ++j)
+    {
+      Index maxi = numext::mini(j, kernel.rows());
+      Index i = 0;
+      if (((Mode&Lower) && SetOpposite) || (Mode&Upper))
+      {
+        for(; i < maxi; ++i)
+          if(Mode&Upper) kernel.assignCoeff(i, j);
+          else           kernel.assignOppositeCoeff(i, j);
+      }
+      else
+        i = maxi;
+
+      if(i<kernel.rows()) // then i==j
+        kernel.assignDiagonalCoeff(i++);
+
+      if (((Mode&Upper) && SetOpposite) || (Mode&Lower))
+      {
+        for(; i < kernel.rows(); ++i)
+          if(Mode&Lower) kernel.assignCoeff(i, j);
+          else           kernel.assignOppositeCoeff(i, j);
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+/** Assigns a triangular or selfadjoint matrix to a dense matrix.
+  * If the matrix is triangular, the opposite part is set to zero. */
+template<typename Derived>
+template<typename DenseDerived>
+EIGEN_DEVICE_FUNC void TriangularBase<Derived>::evalToLazy(MatrixBase<DenseDerived> &other) const
+{
+  other.derived().resize(this->rows(), this->cols());
+  internal::call_triangular_assignment_loop<Derived::Mode, (int(Derived::Mode) & int(SelfAdjoint)) == 0 /* SetOpposite */>(other.derived(), derived().nestedExpression());
+}
+
+namespace internal {
+
+// Triangular = Product
+template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular>
+{
+  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename SrcXprType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst._assignProduct(src, Scalar(1), false);
+  }
+};
+
+// Triangular += Product
+template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::add_assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular>
+{
+  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar,typename SrcXprType::Scalar> &)
+  {
+    dst._assignProduct(src, Scalar(1), true);
+  }
+};
+
+// Triangular -= Product
+template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::sub_assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular>
+{
+  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar,typename SrcXprType::Scalar> &)
+  {
+    dst._assignProduct(src, Scalar(-1), true);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULARMATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/VectorBlock.h b/C++/yolo_bytetrack/include/Eigen/src/Core/VectorBlock.h
new file mode 100644
index 00000000..71c5b95e
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/VectorBlock.h
@@ -0,0 +1,96 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_VECTORBLOCK_H
+#define EIGEN_VECTORBLOCK_H
+
+namespace Eigen { 
+
+namespace internal {
+template<typename VectorType, int Size>
+struct traits<VectorBlock<VectorType, Size> >
+  : public traits<Block<VectorType,
+                     traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
+                     traits<VectorType>::Flags & RowMajorBit ? Size : 1> >
+{
+};
+}
+
+/** \class VectorBlock
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a fixed-size or dynamic-size sub-vector
+  *
+  * \tparam VectorType the type of the object in which we are taking a sub-vector
+  * \tparam Size size of the sub-vector we are taking at compile time (optional)
+  *
+  * This class represents an expression of either a fixed-size or dynamic-size sub-vector.
+  * It is the return type of DenseBase::segment(Index,Index) and DenseBase::segment<int>(Index) and
+  * most of the time this is the only way it is used.
+  *
+  * However, if you want to directly manipulate sub-vector expressions,
+  * for instance if you want to write a function returning such an expression, you
+  * will need to use this class.
+  *
+  * Here is an example illustrating the dynamic case:
+  * \include class_VectorBlock.cpp
+  * Output: \verbinclude class_VectorBlock.out
+  *
+  * \note Even though this expression has dynamic size, in the case where \a VectorType
+  * has fixed size, this expression inherits a fixed maximal size which means that evaluating
+  * it does not cause a dynamic memory allocation.
+  *
+  * Here is an example illustrating the fixed-size case:
+  * \include class_FixedVectorBlock.cpp
+  * Output: \verbinclude class_FixedVectorBlock.out
+  *
+  * \sa class Block, DenseBase::segment(Index,Index,Index,Index), DenseBase::segment(Index,Index)
+  */
+template<typename VectorType, int Size> class VectorBlock
+  : public Block<VectorType,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1>
+{
+    typedef Block<VectorType,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1> Base;
+    enum {
+      IsColVector = !(internal::traits<VectorType>::Flags & RowMajorBit)
+    };
+  public:
+    EIGEN_DENSE_PUBLIC_INTERFACE(VectorBlock)
+
+    using Base::operator=;
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    VectorBlock(VectorType& vector, Index start, Index size)
+      : Base(vector,
+             IsColVector ? start : 0, IsColVector ? 0 : start,
+             IsColVector ? size  : 1, IsColVector ? 1 : size)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorBlock);
+    }
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    VectorBlock(VectorType& vector, Index start)
+      : Base(vector, IsColVector ? start : 0, IsColVector ? 0 : start)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorBlock);
+    }
+};
+
+
+} // end namespace Eigen
+
+#endif // EIGEN_VECTORBLOCK_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/VectorwiseOp.h b/C++/yolo_bytetrack/include/Eigen/src/Core/VectorwiseOp.h
new file mode 100644
index 00000000..870f4f1e
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/VectorwiseOp.h
@@ -0,0 +1,784 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2019 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARTIAL_REDUX_H
+#define EIGEN_PARTIAL_REDUX_H
+
+namespace Eigen {
+
+/** \class PartialReduxExpr
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression of a partially reduxed matrix
+  *
+  * \tparam MatrixType the type of the matrix we are applying the redux operation
+  * \tparam MemberOp type of the member functor
+  * \tparam Direction indicates the direction of the redux (#Vertical or #Horizontal)
+  *
+  * This class represents an expression of a partial redux operator of a matrix.
+  * It is the return type of some VectorwiseOp functions,
+  * and most of the time this is the only way it is used.
+  *
+  * \sa class VectorwiseOp
+  */
+
+template< typename MatrixType, typename MemberOp, int Direction>
+class PartialReduxExpr;
+
+namespace internal {
+template<typename MatrixType, typename MemberOp, int Direction>
+struct traits<PartialReduxExpr<MatrixType, MemberOp, Direction> >
+ : traits<MatrixType>
+{
+  typedef typename MemberOp::result_type Scalar;
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename traits<MatrixType>::XprKind XprKind;
+  typedef typename MatrixType::Scalar InputScalar;
+  enum {
+    RowsAtCompileTime = Direction==Vertical   ? 1 : MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = Direction==Vertical   ? 1 : MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::MaxColsAtCompileTime,
+    Flags = RowsAtCompileTime == 1 ? RowMajorBit : 0,
+    TraversalSize = Direction==Vertical ? MatrixType::RowsAtCompileTime :  MatrixType::ColsAtCompileTime
+  };
+};
+}
+
+template< typename MatrixType, typename MemberOp, int Direction>
+class PartialReduxExpr : public internal::dense_xpr_base< PartialReduxExpr<MatrixType, MemberOp, Direction> >::type,
+                         internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<PartialReduxExpr>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(PartialReduxExpr)
+
+    EIGEN_DEVICE_FUNC
+    explicit PartialReduxExpr(const MatrixType& mat, const MemberOp& func = MemberOp())
+      : m_matrix(mat), m_functor(func) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return (Direction==Vertical   ? 1 : m_matrix.rows()); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return (Direction==Horizontal ? 1 : m_matrix.cols()); }
+
+    EIGEN_DEVICE_FUNC
+    typename MatrixType::Nested nestedExpression() const { return m_matrix; }
+
+    EIGEN_DEVICE_FUNC
+    const MemberOp& functor() const { return m_functor; }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+    const MemberOp m_functor;
+};
+
+template<typename A,typename B> struct partial_redux_dummy_func;
+
+#define EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(MEMBER,COST,VECTORIZABLE,BINARYOP)                \
+  template <typename ResultType,typename Scalar>                                                            \
+  struct member_##MEMBER {                                                                  \
+    EIGEN_EMPTY_STRUCT_CTOR(member_##MEMBER)                                                \
+    typedef ResultType result_type;                                                         \
+    typedef BINARYOP<Scalar,Scalar> BinaryOp;   \
+    template<int Size> struct Cost { enum { value = COST }; };             \
+    enum { Vectorizable = VECTORIZABLE };                                                   \
+    template<typename XprType>                                                              \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                   \
+    ResultType operator()(const XprType& mat) const                                         \
+    { return mat.MEMBER(); }                                                                \
+    BinaryOp binaryFunc() const { return BinaryOp(); }                                      \
+  }
+
+#define EIGEN_MEMBER_FUNCTOR(MEMBER,COST) \
+  EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(MEMBER,COST,0,partial_redux_dummy_func)
+
+namespace internal {
+
+EIGEN_MEMBER_FUNCTOR(norm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(stableNorm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(blueNorm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size-1) * functor_traits<scalar_hypot_op<Scalar> >::Cost );
+EIGEN_MEMBER_FUNCTOR(all, (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(any, (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(count, (Size-1)*NumTraits<Scalar>::AddCost);
+
+EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(sum, (Size-1)*NumTraits<Scalar>::AddCost, 1, internal::scalar_sum_op);
+EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(minCoeff, (Size-1)*NumTraits<Scalar>::AddCost, 1, internal::scalar_min_op);
+EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(maxCoeff, (Size-1)*NumTraits<Scalar>::AddCost, 1, internal::scalar_max_op);
+EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(prod, (Size-1)*NumTraits<Scalar>::MulCost, 1, internal::scalar_product_op);
+
+template <int p, typename ResultType,typename Scalar>
+struct member_lpnorm {
+  typedef ResultType result_type;
+  enum { Vectorizable = 0 };
+  template<int Size> struct Cost
+  { enum { value = (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost }; };
+  EIGEN_DEVICE_FUNC member_lpnorm() {}
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC inline ResultType operator()(const XprType& mat) const
+  { return mat.template lpNorm<p>(); }
+};
+
+template <typename BinaryOpT, typename Scalar>
+struct member_redux {
+  typedef BinaryOpT BinaryOp;
+  typedef typename result_of<
+                     BinaryOp(const Scalar&,const Scalar&)
+                   >::type  result_type;
+
+  enum { Vectorizable = functor_traits<BinaryOp>::PacketAccess };
+  template<int Size> struct Cost { enum { value = (Size-1) * functor_traits<BinaryOp>::Cost }; };
+  EIGEN_DEVICE_FUNC explicit member_redux(const BinaryOp func) : m_functor(func) {}
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline result_type operator()(const DenseBase<Derived>& mat) const
+  { return mat.redux(m_functor); }
+  const BinaryOp& binaryFunc() const { return m_functor; }
+  const BinaryOp m_functor;
+};
+}
+
+/** \class VectorwiseOp
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression providing broadcasting and partial reduction operations
+  *
+  * \tparam ExpressionType the type of the object on which to do partial reductions
+  * \tparam Direction indicates whether to operate on columns (#Vertical) or rows (#Horizontal)
+  *
+  * This class represents a pseudo expression with broadcasting and partial reduction features.
+  * It is the return type of DenseBase::colwise() and DenseBase::rowwise()
+  * and most of the time this is the only way it is explicitly used.
+  *
+  * To understand the logic of rowwise/colwise expression, let's consider a generic case `A.colwise().foo()`
+  * where `foo` is any method of `VectorwiseOp`. This expression is equivalent to applying `foo()` to each
+  * column of `A` and then re-assemble the outputs in a matrix expression:
+  * \code [A.col(0).foo(), A.col(1).foo(), ..., A.col(A.cols()-1).foo()] \endcode
+  *
+  * Example: \include MatrixBase_colwise.cpp
+  * Output: \verbinclude MatrixBase_colwise.out
+  *
+  * The begin() and end() methods are obviously exceptions to the previous rule as they
+  * return STL-compatible begin/end iterators to the rows or columns of the nested expression.
+  * Typical use cases include for-range-loop and calls to STL algorithms:
+  *
+  * Example: \include MatrixBase_colwise_iterator_cxx11.cpp
+  * Output: \verbinclude MatrixBase_colwise_iterator_cxx11.out
+  *
+  * For a partial reduction on an empty input, some rules apply.
+  * For the sake of clarity, let's consider a vertical reduction:
+  *   - If the number of columns is zero, then a 1x0 row-major vector expression is returned.
+  *   - Otherwise, if the number of rows is zero, then
+  *       - a row vector of zeros is returned for sum-like reductions (sum, squaredNorm, norm, etc.)
+  *       - a row vector of ones is returned for a product reduction (e.g., <code>MatrixXd(n,0).colwise().prod()</code>)
+  *       - an assert is triggered for all other reductions (minCoeff,maxCoeff,redux(bin_op))
+  *
+  * \sa DenseBase::colwise(), DenseBase::rowwise(), class PartialReduxExpr
+  */
+template<typename ExpressionType, int Direction> class VectorwiseOp
+{
+  public:
+
+    typedef typename ExpressionType::Scalar Scalar;
+    typedef typename ExpressionType::RealScalar RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    typedef typename internal::ref_selector<ExpressionType>::non_const_type ExpressionTypeNested;
+    typedef typename internal::remove_all<ExpressionTypeNested>::type ExpressionTypeNestedCleaned;
+
+    template<template<typename OutScalar,typename InputScalar> class Functor,
+                      typename ReturnScalar=Scalar> struct ReturnType
+    {
+      typedef PartialReduxExpr<ExpressionType,
+                               Functor<ReturnScalar,Scalar>,
+                               Direction
+                              > Type;
+    };
+
+    template<typename BinaryOp> struct ReduxReturnType
+    {
+      typedef PartialReduxExpr<ExpressionType,
+                               internal::member_redux<BinaryOp,Scalar>,
+                               Direction
+                              > Type;
+    };
+
+    enum {
+      isVertical   = (Direction==Vertical) ? 1 : 0,
+      isHorizontal = (Direction==Horizontal) ? 1 : 0
+    };
+
+  protected:
+
+    template<typename OtherDerived> struct ExtendedType {
+      typedef Replicate<OtherDerived,
+                        isVertical   ? 1 : ExpressionType::RowsAtCompileTime,
+                        isHorizontal ? 1 : ExpressionType::ColsAtCompileTime> Type;
+    };
+
+    /** \internal
+      * Replicates a vector to match the size of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    typename ExtendedType<OtherDerived>::Type
+    extendedTo(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isVertical, OtherDerived::MaxColsAtCompileTime==1),
+                          YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED)
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isHorizontal, OtherDerived::MaxRowsAtCompileTime==1),
+                          YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED)
+      return typename ExtendedType<OtherDerived>::Type
+                      (other.derived(),
+                       isVertical   ? 1 : m_matrix.rows(),
+                       isHorizontal ? 1 : m_matrix.cols());
+    }
+
+    template<typename OtherDerived> struct OppositeExtendedType {
+      typedef Replicate<OtherDerived,
+                        isHorizontal ? 1 : ExpressionType::RowsAtCompileTime,
+                        isVertical   ? 1 : ExpressionType::ColsAtCompileTime> Type;
+    };
+
+    /** \internal
+      * Replicates a vector in the opposite direction to match the size of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    typename OppositeExtendedType<OtherDerived>::Type
+    extendedToOpposite(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isHorizontal, OtherDerived::MaxColsAtCompileTime==1),
+                          YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED)
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isVertical, OtherDerived::MaxRowsAtCompileTime==1),
+                          YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED)
+      return typename OppositeExtendedType<OtherDerived>::Type
+                      (other.derived(),
+                       isHorizontal  ? 1 : m_matrix.rows(),
+                       isVertical    ? 1 : m_matrix.cols());
+    }
+
+  public:
+    EIGEN_DEVICE_FUNC
+    explicit inline VectorwiseOp(ExpressionType& matrix) : m_matrix(matrix) {}
+
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    inline const ExpressionType& _expression() const { return m_matrix; }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** STL-like <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">RandomAccessIterator</a>
+      * iterator type over the columns or rows as returned by the begin() and end() methods.
+      */
+    random_access_iterator_type iterator;
+    /** This is the const version of iterator (aka read-only) */
+    random_access_iterator_type const_iterator;
+    #else
+    typedef internal::subvector_stl_iterator<ExpressionType,               DirectionType(Direction)> iterator;
+    typedef internal::subvector_stl_iterator<const ExpressionType,         DirectionType(Direction)> const_iterator;
+    typedef internal::subvector_stl_reverse_iterator<ExpressionType,       DirectionType(Direction)> reverse_iterator;
+    typedef internal::subvector_stl_reverse_iterator<const ExpressionType, DirectionType(Direction)> const_reverse_iterator;
+    #endif
+
+    /** returns an iterator to the first row (rowwise) or column (colwise) of the nested expression.
+      * \sa end(), cbegin()
+      */
+    iterator                 begin()       { return iterator      (m_matrix, 0); }
+    /** const version of begin() */
+    const_iterator           begin() const { return const_iterator(m_matrix, 0); }
+    /** const version of begin() */
+    const_iterator          cbegin() const { return const_iterator(m_matrix, 0); }
+
+    /** returns a reverse iterator to the last row (rowwise) or column (colwise) of the nested expression.
+      * \sa rend(), crbegin()
+      */
+    reverse_iterator        rbegin()       { return reverse_iterator       (m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()-1); }
+	/** const version of rbegin() */
+    const_reverse_iterator  rbegin() const { return const_reverse_iterator (m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()-1); }
+	/** const version of rbegin() */
+	const_reverse_iterator crbegin() const { return const_reverse_iterator (m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()-1); }
+
+    /** returns an iterator to the row (resp. column) following the last row (resp. column) of the nested expression
+      * \sa begin(), cend()
+      */
+    iterator                 end()         { return iterator      (m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()); }
+    /** const version of end() */
+    const_iterator           end()  const  { return const_iterator(m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()); }
+    /** const version of end() */
+    const_iterator          cend()  const  { return const_iterator(m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()); }
+
+    /** returns a reverse iterator to the row (resp. column) before the first row (resp. column) of the nested expression
+      * \sa begin(), cend()
+      */
+    reverse_iterator        rend()         { return reverse_iterator       (m_matrix, -1); }
+    /** const version of rend() */
+    const_reverse_iterator  rend()  const  { return const_reverse_iterator (m_matrix, -1); }
+    /** const version of rend() */
+    const_reverse_iterator crend()  const  { return const_reverse_iterator (m_matrix, -1); }
+
+    /** \returns a row or column vector expression of \c *this reduxed by \a func
+      *
+      * The template parameter \a BinaryOp is the type of the functor
+      * of the custom redux operator. Note that func must be an associative operator.
+      *
+      * \warning the size along the reduction direction must be strictly positive,
+      *          otherwise an assertion is triggered.
+      *
+      * \sa class VectorwiseOp, DenseBase::colwise(), DenseBase::rowwise()
+      */
+    template<typename BinaryOp>
+    EIGEN_DEVICE_FUNC
+    const typename ReduxReturnType<BinaryOp>::Type
+    redux(const BinaryOp& func = BinaryOp()) const
+    {
+      eigen_assert(redux_length()>0 && "you are using an empty matrix");
+      return typename ReduxReturnType<BinaryOp>::Type(_expression(), internal::member_redux<BinaryOp,Scalar>(func));
+    }
+
+    typedef typename ReturnType<internal::member_minCoeff>::Type MinCoeffReturnType;
+    typedef typename ReturnType<internal::member_maxCoeff>::Type MaxCoeffReturnType;
+    typedef PartialReduxExpr<const CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const ExpressionTypeNestedCleaned>,internal::member_sum<RealScalar,RealScalar>,Direction> SquaredNormReturnType;
+    typedef CwiseUnaryOp<internal::scalar_sqrt_op<RealScalar>, const SquaredNormReturnType> NormReturnType;
+    typedef typename ReturnType<internal::member_blueNorm,RealScalar>::Type BlueNormReturnType;
+    typedef typename ReturnType<internal::member_stableNorm,RealScalar>::Type StableNormReturnType;
+    typedef typename ReturnType<internal::member_hypotNorm,RealScalar>::Type HypotNormReturnType;
+    typedef typename ReturnType<internal::member_sum>::Type SumReturnType;
+    typedef EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(SumReturnType,Scalar,quotient) MeanReturnType;
+    typedef typename ReturnType<internal::member_all>::Type AllReturnType;
+    typedef typename ReturnType<internal::member_any>::Type AnyReturnType;
+    typedef PartialReduxExpr<ExpressionType, internal::member_count<Index,Scalar>, Direction> CountReturnType;
+    typedef typename ReturnType<internal::member_prod>::Type ProdReturnType;
+    typedef Reverse<const ExpressionType, Direction> ConstReverseReturnType;
+    typedef Reverse<ExpressionType, Direction> ReverseReturnType;
+
+    template<int p> struct LpNormReturnType {
+      typedef PartialReduxExpr<ExpressionType, internal::member_lpnorm<p,RealScalar,Scalar>,Direction> Type;
+    };
+
+    /** \returns a row (or column) vector expression of the smallest coefficient
+      * of each column (or row) of the referenced expression.
+      *
+      * \warning the size along the reduction direction must be strictly positive,
+      *          otherwise an assertion is triggered.
+      *
+      * \warning the result is undefined if \c *this contains NaN.
+      *
+      * Example: \include PartialRedux_minCoeff.cpp
+      * Output: \verbinclude PartialRedux_minCoeff.out
+      *
+      * \sa DenseBase::minCoeff() */
+    EIGEN_DEVICE_FUNC
+    const MinCoeffReturnType minCoeff() const
+    {
+      eigen_assert(redux_length()>0 && "you are using an empty matrix");
+      return MinCoeffReturnType(_expression());
+    }
+
+    /** \returns a row (or column) vector expression of the largest coefficient
+      * of each column (or row) of the referenced expression.
+      *
+      * \warning the size along the reduction direction must be strictly positive,
+      *          otherwise an assertion is triggered.
+      *
+      * \warning the result is undefined if \c *this contains NaN.
+      *
+      * Example: \include PartialRedux_maxCoeff.cpp
+      * Output: \verbinclude PartialRedux_maxCoeff.out
+      *
+      * \sa DenseBase::maxCoeff() */
+    EIGEN_DEVICE_FUNC
+    const MaxCoeffReturnType maxCoeff() const
+    {
+      eigen_assert(redux_length()>0 && "you are using an empty matrix");
+      return MaxCoeffReturnType(_expression());
+    }
+
+    /** \returns a row (or column) vector expression of the squared norm
+      * of each column (or row) of the referenced expression.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * Example: \include PartialRedux_squaredNorm.cpp
+      * Output: \verbinclude PartialRedux_squaredNorm.out
+      *
+      * \sa DenseBase::squaredNorm() */
+    EIGEN_DEVICE_FUNC
+    const SquaredNormReturnType squaredNorm() const
+    { return SquaredNormReturnType(m_matrix.cwiseAbs2()); }
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * Example: \include PartialRedux_norm.cpp
+      * Output: \verbinclude PartialRedux_norm.out
+      *
+      * \sa DenseBase::norm() */
+    EIGEN_DEVICE_FUNC
+    const NormReturnType norm() const
+    { return NormReturnType(squaredNorm()); }
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * Example: \include PartialRedux_norm.cpp
+      * Output: \verbinclude PartialRedux_norm.out
+      *
+      * \sa DenseBase::norm() */
+    template<int p>
+    EIGEN_DEVICE_FUNC
+    const typename LpNormReturnType<p>::Type lpNorm() const
+    { return typename LpNormReturnType<p>::Type(_expression()); }
+
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression, using
+      * Blue's algorithm.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * \sa DenseBase::blueNorm() */
+    EIGEN_DEVICE_FUNC
+    const BlueNormReturnType blueNorm() const
+    { return BlueNormReturnType(_expression()); }
+
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression, avoiding
+      * underflow and overflow.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * \sa DenseBase::stableNorm() */
+    EIGEN_DEVICE_FUNC
+    const StableNormReturnType stableNorm() const
+    { return StableNormReturnType(_expression()); }
+
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression, avoiding
+      * underflow and overflow using a concatenation of hypot() calls.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * \sa DenseBase::hypotNorm() */
+    EIGEN_DEVICE_FUNC
+    const HypotNormReturnType hypotNorm() const
+    { return HypotNormReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the sum
+      * of each column (or row) of the referenced expression.
+      *
+      * Example: \include PartialRedux_sum.cpp
+      * Output: \verbinclude PartialRedux_sum.out
+      *
+      * \sa DenseBase::sum() */
+    EIGEN_DEVICE_FUNC
+    const SumReturnType sum() const
+    { return SumReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the mean
+    * of each column (or row) of the referenced expression.
+    *
+    * \sa DenseBase::mean() */
+    EIGEN_DEVICE_FUNC
+    const MeanReturnType mean() const
+    { return sum() / Scalar(Direction==Vertical?m_matrix.rows():m_matrix.cols()); }
+
+    /** \returns a row (or column) vector expression representing
+      * whether \b all coefficients of each respective column (or row) are \c true.
+      * This expression can be assigned to a vector with entries of type \c bool.
+      *
+      * \sa DenseBase::all() */
+    EIGEN_DEVICE_FUNC
+    const AllReturnType all() const
+    { return AllReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression representing
+      * whether \b at \b least one coefficient of each respective column (or row) is \c true.
+      * This expression can be assigned to a vector with entries of type \c bool.
+      *
+      * \sa DenseBase::any() */
+    EIGEN_DEVICE_FUNC
+    const AnyReturnType any() const
+    { return AnyReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression representing
+      * the number of \c true coefficients of each respective column (or row).
+      * This expression can be assigned to a vector whose entries have the same type as is used to
+      * index entries of the original matrix; for dense matrices, this is \c std::ptrdiff_t .
+      *
+      * Example: \include PartialRedux_count.cpp
+      * Output: \verbinclude PartialRedux_count.out
+      *
+      * \sa DenseBase::count() */
+    EIGEN_DEVICE_FUNC
+    const CountReturnType count() const
+    { return CountReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the product
+      * of each column (or row) of the referenced expression.
+      *
+      * Example: \include PartialRedux_prod.cpp
+      * Output: \verbinclude PartialRedux_prod.out
+      *
+      * \sa DenseBase::prod() */
+    EIGEN_DEVICE_FUNC
+    const ProdReturnType prod() const
+    { return ProdReturnType(_expression()); }
+
+
+    /** \returns a matrix expression
+      * where each column (or row) are reversed.
+      *
+      * Example: \include Vectorwise_reverse.cpp
+      * Output: \verbinclude Vectorwise_reverse.out
+      *
+      * \sa DenseBase::reverse() */
+    EIGEN_DEVICE_FUNC
+    const ConstReverseReturnType reverse() const
+    { return ConstReverseReturnType( _expression() ); }
+
+    /** \returns a writable matrix expression
+      * where each column (or row) are reversed.
+      *
+      * \sa reverse() const */
+    EIGEN_DEVICE_FUNC
+    ReverseReturnType reverse()
+    { return ReverseReturnType( _expression() ); }
+
+    typedef Replicate<ExpressionType,(isVertical?Dynamic:1),(isHorizontal?Dynamic:1)> ReplicateReturnType;
+    EIGEN_DEVICE_FUNC
+    const ReplicateReturnType replicate(Index factor) const;
+
+    /**
+      * \return an expression of the replication of each column (or row) of \c *this
+      *
+      * Example: \include DirectionWise_replicate.cpp
+      * Output: \verbinclude DirectionWise_replicate.out
+      *
+      * \sa VectorwiseOp::replicate(Index), DenseBase::replicate(), class Replicate
+      */
+    // NOTE implemented here because of sunstudio's compilation errors
+    // isVertical*Factor+isHorizontal instead of (isVertical?Factor:1) to handle CUDA bug with ternary operator
+    template<int Factor> const Replicate<ExpressionType,isVertical*Factor+isHorizontal,isHorizontal*Factor+isVertical>
+    EIGEN_DEVICE_FUNC
+    replicate(Index factor = Factor) const
+    {
+      return Replicate<ExpressionType,(isVertical?Factor:1),(isHorizontal?Factor:1)>
+          (_expression(),isVertical?factor:1,isHorizontal?factor:1);
+    }
+
+/////////// Artithmetic operators ///////////
+
+    /** Copies the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      //eigen_assert((m_matrix.isNull()) == (other.isNull())); FIXME
+      return m_matrix = extendedTo(other.derived());
+    }
+
+    /** Adds the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator+=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix += extendedTo(other.derived());
+    }
+
+    /** Substracts the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator-=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix -= extendedTo(other.derived());
+    }
+
+    /** Multiples each subvector of \c *this by the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator*=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      m_matrix *= extendedTo(other.derived());
+      return m_matrix;
+    }
+
+    /** Divides each subvector of \c *this by the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator/=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      m_matrix /= extendedTo(other.derived());
+      return m_matrix;
+    }
+
+    /** Returns the expression of the sum of the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_sum_op<Scalar,typename OtherDerived::Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    operator+(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix + extendedTo(other.derived());
+    }
+
+    /** Returns the expression of the difference between each subvector of \c *this and the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_difference_op<Scalar,typename OtherDerived::Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    operator-(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix - extendedTo(other.derived());
+    }
+
+    /** Returns the expression where each subvector is the product of the vector \a other
+      * by the corresponding subvector of \c *this */
+    template<typename OtherDerived> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_product_op<Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    EIGEN_DEVICE_FUNC
+    operator*(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix * extendedTo(other.derived());
+    }
+
+    /** Returns the expression where each subvector is the quotient of the corresponding
+      * subvector of \c *this by the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_quotient_op<Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    operator/(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix / extendedTo(other.derived());
+    }
+
+    /** \returns an expression where each column (or row) of the referenced matrix are normalized.
+      * The referenced matrix is \b not modified.
+      * \sa MatrixBase::normalized(), normalize()
+      */
+    EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_quotient_op<Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename OppositeExtendedType<NormReturnType>::Type>
+    normalized() const { return m_matrix.cwiseQuotient(extendedToOpposite(this->norm())); }
+
+
+    /** Normalize in-place each row or columns of the referenced matrix.
+      * \sa MatrixBase::normalize(), normalized()
+      */
+    EIGEN_DEVICE_FUNC void normalize() {
+      m_matrix = this->normalized();
+    }
+
+    EIGEN_DEVICE_FUNC inline void reverseInPlace();
+
+/////////// Geometry module ///////////
+
+    typedef Homogeneous<ExpressionType,Direction> HomogeneousReturnType;
+    EIGEN_DEVICE_FUNC
+    HomogeneousReturnType homogeneous() const;
+
+    typedef typename ExpressionType::PlainObject CrossReturnType;
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const CrossReturnType cross(const MatrixBase<OtherDerived>& other) const;
+
+    enum {
+      HNormalized_Size = Direction==Vertical ? internal::traits<ExpressionType>::RowsAtCompileTime
+                                             : internal::traits<ExpressionType>::ColsAtCompileTime,
+      HNormalized_SizeMinusOne = HNormalized_Size==Dynamic ? Dynamic : HNormalized_Size-1
+    };
+    typedef Block<const ExpressionType,
+                  Direction==Vertical   ? int(HNormalized_SizeMinusOne)
+                                        : int(internal::traits<ExpressionType>::RowsAtCompileTime),
+                  Direction==Horizontal ? int(HNormalized_SizeMinusOne)
+                                        : int(internal::traits<ExpressionType>::ColsAtCompileTime)>
+            HNormalized_Block;
+    typedef Block<const ExpressionType,
+                  Direction==Vertical   ? 1 : int(internal::traits<ExpressionType>::RowsAtCompileTime),
+                  Direction==Horizontal ? 1 : int(internal::traits<ExpressionType>::ColsAtCompileTime)>
+            HNormalized_Factors;
+    typedef CwiseBinaryOp<internal::scalar_quotient_op<typename internal::traits<ExpressionType>::Scalar>,
+                const HNormalized_Block,
+                const Replicate<HNormalized_Factors,
+                  Direction==Vertical   ? HNormalized_SizeMinusOne : 1,
+                  Direction==Horizontal ? HNormalized_SizeMinusOne : 1> >
+            HNormalizedReturnType;
+
+    EIGEN_DEVICE_FUNC
+    const HNormalizedReturnType hnormalized() const;
+
+#   ifdef EIGEN_VECTORWISEOP_PLUGIN
+#     include EIGEN_VECTORWISEOP_PLUGIN
+#   endif
+
+  protected:
+    Index redux_length() const
+    {
+      return Direction==Vertical ? m_matrix.rows() : m_matrix.cols();
+    }
+    ExpressionTypeNested m_matrix;
+};
+
+//const colwise moved to DenseBase.h due to CUDA compiler bug
+
+
+/** \returns a writable VectorwiseOp wrapper of *this providing additional partial reduction operations
+  *
+  * \sa rowwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::ColwiseReturnType
+DenseBase<Derived>::colwise()
+{
+  return ColwiseReturnType(derived());
+}
+
+//const rowwise moved to DenseBase.h due to CUDA compiler bug
+
+
+/** \returns a writable VectorwiseOp wrapper of *this providing additional partial reduction operations
+  *
+  * \sa colwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::RowwiseReturnType
+DenseBase<Derived>::rowwise()
+{
+  return RowwiseReturnType(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIAL_REDUX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/Visitor.h b/C++/yolo_bytetrack/include/Eigen/src/Core/Visitor.h
new file mode 100644
index 00000000..00bcca87
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/Visitor.h
@@ -0,0 +1,381 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_VISITOR_H
+#define EIGEN_VISITOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Visitor, typename Derived, int UnrollCount>
+struct visitor_impl
+{
+  enum {
+    col = (UnrollCount-1) / Derived::RowsAtCompileTime,
+    row = (UnrollCount-1) % Derived::RowsAtCompileTime
+  };
+
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived &mat, Visitor& visitor)
+  {
+    visitor_impl<Visitor, Derived, UnrollCount-1>::run(mat, visitor);
+    visitor(mat.coeff(row, col), row, col);
+  }
+};
+
+template<typename Visitor, typename Derived>
+struct visitor_impl<Visitor, Derived, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived &mat, Visitor& visitor)
+  {
+    return visitor.init(mat.coeff(0, 0), 0, 0);
+  }
+};
+
+// This specialization enables visitors on empty matrices at compile-time
+template<typename Visitor, typename Derived>
+struct visitor_impl<Visitor, Derived, 0> {
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived &/*mat*/, Visitor& /*visitor*/)
+  {}
+};
+
+template<typename Visitor, typename Derived>
+struct visitor_impl<Visitor, Derived, Dynamic>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived& mat, Visitor& visitor)
+  {
+    visitor.init(mat.coeff(0,0), 0, 0);
+    for(Index i = 1; i < mat.rows(); ++i)
+      visitor(mat.coeff(i, 0), i, 0);
+    for(Index j = 1; j < mat.cols(); ++j)
+      for(Index i = 0; i < mat.rows(); ++i)
+        visitor(mat.coeff(i, j), i, j);
+  }
+};
+
+// evaluator adaptor
+template<typename XprType>
+class visitor_evaluator
+{
+public:
+  EIGEN_DEVICE_FUNC
+  explicit visitor_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) {}
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    RowsAtCompileTime = XprType::RowsAtCompileTime,
+    CoeffReadCost = internal::evaluator<XprType>::CoeffReadCost
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_xpr.rows(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_xpr.cols(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT { return m_xpr.size(); }
+
+  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index row, Index col) const
+  { return m_evaluator.coeff(row, col); }
+
+protected:
+  internal::evaluator<XprType> m_evaluator;
+  const XprType &m_xpr;
+};
+} // end namespace internal
+
+/** Applies the visitor \a visitor to the whole coefficients of the matrix or vector.
+  *
+  * The template parameter \a Visitor is the type of the visitor and provides the following interface:
+  * \code
+  * struct MyVisitor {
+  *   // called for the first coefficient
+  *   void init(const Scalar& value, Index i, Index j);
+  *   // called for all other coefficients
+  *   void operator() (const Scalar& value, Index i, Index j);
+  * };
+  * \endcode
+  *
+  * \note compared to one or two \em for \em loops, visitors offer automatic
+  * unrolling for small fixed size matrix.
+  *
+  * \note if the matrix is empty, then the visitor is left unchanged.
+  *
+  * \sa minCoeff(Index*,Index*), maxCoeff(Index*,Index*), DenseBase::redux()
+  */
+template<typename Derived>
+template<typename Visitor>
+EIGEN_DEVICE_FUNC
+void DenseBase<Derived>::visit(Visitor& visitor) const
+{
+  if(size()==0)
+    return;
+
+  typedef typename internal::visitor_evaluator<Derived> ThisEvaluator;
+  ThisEvaluator thisEval(derived());
+
+  enum {
+    unroll =  SizeAtCompileTime != Dynamic
+           && SizeAtCompileTime * int(ThisEvaluator::CoeffReadCost) + (SizeAtCompileTime-1) * int(internal::functor_traits<Visitor>::Cost) <= EIGEN_UNROLLING_LIMIT
+  };
+  return internal::visitor_impl<Visitor, ThisEvaluator, unroll ? int(SizeAtCompileTime) : Dynamic>::run(thisEval, visitor);
+}
+
+namespace internal {
+
+/** \internal
+  * \brief Base class to implement min and max visitors
+  */
+template <typename Derived>
+struct coeff_visitor
+{
+  // default initialization to avoid countless invalid maybe-uninitialized warnings by gcc
+  EIGEN_DEVICE_FUNC
+  coeff_visitor() : row(-1), col(-1), res(0) {}
+  typedef typename Derived::Scalar Scalar;
+  Index row, col;
+  Scalar res;
+  EIGEN_DEVICE_FUNC
+  inline void init(const Scalar& value, Index i, Index j)
+  {
+    res = value;
+    row = i;
+    col = j;
+  }
+};
+
+/** \internal
+  * \brief Visitor computing the min coefficient with its value and coordinates
+  *
+  * \sa DenseBase::minCoeff(Index*, Index*)
+  */
+template <typename Derived, int NaNPropagation>
+struct min_coeff_visitor : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if(value < this->res)
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template <typename Derived>
+struct min_coeff_visitor<Derived, PropagateNumbers> : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if((numext::isnan)(this->res) || (!(numext::isnan)(value) && value < this->res))
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template <typename Derived>
+struct min_coeff_visitor<Derived, PropagateNaN> : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if((numext::isnan)(value) || value < this->res)
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template<typename Scalar, int NaNPropagation>
+    struct functor_traits<min_coeff_visitor<Scalar, NaNPropagation> > {
+  enum {
+    Cost = NumTraits<Scalar>::AddCost
+  };
+};
+
+/** \internal
+  * \brief Visitor computing the max coefficient with its value and coordinates
+  *
+  * \sa DenseBase::maxCoeff(Index*, Index*)
+  */
+template <typename Derived, int NaNPropagation>
+struct max_coeff_visitor : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if(value > this->res)
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template <typename Derived>
+struct max_coeff_visitor<Derived, PropagateNumbers> : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if((numext::isnan)(this->res) || (!(numext::isnan)(value) && value > this->res))
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template <typename Derived>
+struct max_coeff_visitor<Derived, PropagateNaN> : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if((numext::isnan)(value) || value > this->res)
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template<typename Scalar, int NaNPropagation>
+struct functor_traits<max_coeff_visitor<Scalar, NaNPropagation> > {
+  enum {
+    Cost = NumTraits<Scalar>::AddCost
+  };
+};
+
+} // end namespace internal
+
+/** \fn DenseBase<Derived>::minCoeff(IndexType* rowId, IndexType* colId) const
+  * \returns the minimum of all coefficients of *this and puts in *row and *col its location.
+  *
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  *
+  * \sa DenseBase::minCoeff(Index*), DenseBase::maxCoeff(Index*,Index*), DenseBase::visit(), DenseBase::minCoeff()
+  */
+template<typename Derived>
+template<int NaNPropagation, typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::minCoeff(IndexType* rowId, IndexType* colId) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  internal::min_coeff_visitor<Derived, NaNPropagation> minVisitor;
+  this->visit(minVisitor);
+  *rowId = minVisitor.row;
+  if (colId) *colId = minVisitor.col;
+  return minVisitor.res;
+}
+
+/** \returns the minimum of all coefficients of *this and puts in *index its location.
+  *
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  *
+  * \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::minCoeff()
+  */
+template<typename Derived>
+template<int NaNPropagation, typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::minCoeff(IndexType* index) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+      internal::min_coeff_visitor<Derived, NaNPropagation> minVisitor;
+  this->visit(minVisitor);
+  *index = IndexType((RowsAtCompileTime==1) ? minVisitor.col : minVisitor.row);
+  return minVisitor.res;
+}
+
+/** \fn DenseBase<Derived>::maxCoeff(IndexType* rowId, IndexType* colId) const
+  * \returns the maximum of all coefficients of *this and puts in *row and *col its location.
+  *
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  *
+  * \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::maxCoeff()
+  */
+template<typename Derived>
+template<int NaNPropagation, typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::maxCoeff(IndexType* rowPtr, IndexType* colPtr) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  internal::max_coeff_visitor<Derived, NaNPropagation> maxVisitor;
+  this->visit(maxVisitor);
+  *rowPtr = maxVisitor.row;
+  if (colPtr) *colPtr = maxVisitor.col;
+  return maxVisitor.res;
+}
+
+/** \returns the maximum of all coefficients of *this and puts in *index its location.
+  *
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  *
+  * \sa DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visitor(), DenseBase::maxCoeff()
+  */
+template<typename Derived>
+template<int NaNPropagation, typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::maxCoeff(IndexType* index) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+      internal::max_coeff_visitor<Derived, NaNPropagation> maxVisitor;
+  this->visit(maxVisitor);
+  *index = (RowsAtCompileTime==1) ? maxVisitor.col : maxVisitor.row;
+  return maxVisitor.res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_VISITOR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/Complex.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/Complex.h
new file mode 100644
index 00000000..ab7bd6c6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/Complex.h
@@ -0,0 +1,372 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner (benoit.steiner.goog@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_AVX_H
+#define EIGEN_COMPLEX_AVX_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- float ----------
+struct Packet4cf
+{
+  EIGEN_STRONG_INLINE Packet4cf() {}
+  EIGEN_STRONG_INLINE explicit Packet4cf(const __m256& a) : v(a) {}
+  __m256  v;
+};
+
+#ifndef EIGEN_VECTORIZE_AVX512
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet4cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+#endif
+
+template<> struct unpacket_traits<Packet4cf> {
+  typedef std::complex<float> type;
+  typedef Packet2cf half;
+  typedef Packet8f as_real;
+  enum {
+    size=4,
+    alignment=Aligned32,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4cf padd<Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_add_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf psub<Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_sub_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf pnegate(const Packet4cf& a)
+{
+  return Packet4cf(pnegate(a.v));
+}
+template<> EIGEN_STRONG_INLINE Packet4cf pconj(const Packet4cf& a)
+{
+  const __m256 mask = _mm256_castsi256_ps(_mm256_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000));
+  return Packet4cf(_mm256_xor_ps(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf pmul<Packet4cf>(const Packet4cf& a, const Packet4cf& b)
+{
+  __m256 tmp1 = _mm256_mul_ps(_mm256_moveldup_ps(a.v), b.v);
+  __m256 tmp2 = _mm256_mul_ps(_mm256_movehdup_ps(a.v), _mm256_permute_ps(b.v, _MM_SHUFFLE(2,3,0,1)));
+  __m256 result = _mm256_addsub_ps(tmp1, tmp2);
+  return Packet4cf(result);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4cf pcmp_eq(const Packet4cf& a, const Packet4cf& b) {
+  __m256 eq = _mm256_cmp_ps(a.v, b.v, _CMP_EQ_OQ);
+  return Packet4cf(_mm256_and_ps(eq, _mm256_permute_ps(eq, 0xb1)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf ptrue<Packet4cf>(const Packet4cf& a) { return Packet4cf(ptrue(Packet8f(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet4cf pand   <Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_and_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf por    <Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_or_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf pxor   <Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_xor_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf pandnot<Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_andnot_ps(b.v,a.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet4cf pload <Packet4cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet4cf(pload<Packet8f>(&numext::real_ref(*from))); }
+template<> EIGEN_STRONG_INLINE Packet4cf ploadu<Packet4cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet4cf(ploadu<Packet8f>(&numext::real_ref(*from))); }
+
+
+template<> EIGEN_STRONG_INLINE Packet4cf pset1<Packet4cf>(const std::complex<float>& from)
+{
+  return Packet4cf(_mm256_castpd_ps(_mm256_broadcast_sd((const double*)(const void*)&from)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf ploaddup<Packet4cf>(const std::complex<float>* from)
+{
+  // FIXME The following might be optimized using _mm256_movedup_pd
+  Packet2cf a = ploaddup<Packet2cf>(from);
+  Packet2cf b = ploaddup<Packet2cf>(from+1);
+  return  Packet4cf(_mm256_insertf128_ps(_mm256_castps128_ps256(a.v), b.v, 1));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float>* to, const Packet4cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore(&numext::real_ref(*to), from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float>* to, const Packet4cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&numext::real_ref(*to), from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet4cf pgather<std::complex<float>, Packet4cf>(const std::complex<float>* from, Index stride)
+{
+  return Packet4cf(_mm256_set_ps(std::imag(from[3*stride]), std::real(from[3*stride]),
+                                 std::imag(from[2*stride]), std::real(from[2*stride]),
+                                 std::imag(from[1*stride]), std::real(from[1*stride]),
+                                 std::imag(from[0*stride]), std::real(from[0*stride])));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet4cf>(std::complex<float>* to, const Packet4cf& from, Index stride)
+{
+  __m128 low = _mm256_extractf128_ps(from.v, 0);
+  to[stride*0] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(low, low, 0)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(low, low, 1)));
+  to[stride*1] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(low, low, 2)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(low, low, 3)));
+
+  __m128 high = _mm256_extractf128_ps(from.v, 1);
+  to[stride*2] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(high, high, 0)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(high, high, 1)));
+  to[stride*3] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(high, high, 2)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(high, high, 3)));
+
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet4cf>(const Packet4cf& a)
+{
+  return pfirst(Packet2cf(_mm256_castps256_ps128(a.v)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf preverse(const Packet4cf& a) {
+  __m128 low  = _mm256_extractf128_ps(a.v, 0);
+  __m128 high = _mm256_extractf128_ps(a.v, 1);
+  __m128d lowd  = _mm_castps_pd(low);
+  __m128d highd = _mm_castps_pd(high);
+  low  = _mm_castpd_ps(_mm_shuffle_pd(lowd,lowd,0x1));
+  high = _mm_castpd_ps(_mm_shuffle_pd(highd,highd,0x1));
+  __m256 result = _mm256_setzero_ps();
+  result = _mm256_insertf128_ps(result, low, 1);
+  result = _mm256_insertf128_ps(result, high, 0);
+  return Packet4cf(result);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet4cf>(const Packet4cf& a)
+{
+  return predux(padd(Packet2cf(_mm256_extractf128_ps(a.v,0)),
+                     Packet2cf(_mm256_extractf128_ps(a.v,1))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet4cf>(const Packet4cf& a)
+{
+  return predux_mul(pmul(Packet2cf(_mm256_extractf128_ps(a.v, 0)),
+                         Packet2cf(_mm256_extractf128_ps(a.v, 1))));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet4cf,Packet8f)
+
+template<> EIGEN_STRONG_INLINE Packet4cf pdiv<Packet4cf>(const Packet4cf& a, const Packet4cf& b)
+{
+  Packet4cf num = pmul(a, pconj(b));
+  __m256 tmp = _mm256_mul_ps(b.v, b.v);
+  __m256 tmp2    = _mm256_shuffle_ps(tmp,tmp,0xB1);
+  __m256 denom = _mm256_add_ps(tmp, tmp2);
+  return Packet4cf(_mm256_div_ps(num.v, denom));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf pcplxflip<Packet4cf>(const Packet4cf& x)
+{
+  return Packet4cf(_mm256_shuffle_ps(x.v, x.v, _MM_SHUFFLE(2, 3, 0 ,1)));
+}
+
+//---------- double ----------
+struct Packet2cd
+{
+  EIGEN_STRONG_INLINE Packet2cd() {}
+  EIGEN_STRONG_INLINE explicit Packet2cd(const __m256d& a) : v(a) {}
+  __m256d  v;
+};
+
+#ifndef EIGEN_VECTORIZE_AVX512
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet2cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 2,
+    HasHalfPacket = 1,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+#endif
+
+template<> struct unpacket_traits<Packet2cd> {
+  typedef std::complex<double> type;
+  typedef Packet1cd half;
+  typedef Packet4d as_real;
+  enum {
+    size=2,
+    alignment=Aligned32,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet2cd padd<Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_add_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd psub<Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_sub_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pnegate(const Packet2cd& a) { return Packet2cd(pnegate(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pconj(const Packet2cd& a)
+{
+  const __m256d mask = _mm256_castsi256_pd(_mm256_set_epi32(0x80000000,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0));
+  return Packet2cd(_mm256_xor_pd(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd pmul<Packet2cd>(const Packet2cd& a, const Packet2cd& b)
+{
+  __m256d tmp1 = _mm256_shuffle_pd(a.v,a.v,0x0);
+  __m256d even = _mm256_mul_pd(tmp1, b.v);
+  __m256d tmp2 = _mm256_shuffle_pd(a.v,a.v,0xF);
+  __m256d tmp3 = _mm256_shuffle_pd(b.v,b.v,0x5);
+  __m256d odd  = _mm256_mul_pd(tmp2, tmp3);
+  return Packet2cd(_mm256_addsub_pd(even, odd));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cd pcmp_eq(const Packet2cd& a, const Packet2cd& b) {
+  __m256d eq = _mm256_cmp_pd(a.v, b.v, _CMP_EQ_OQ);
+  return Packet2cd(pand(eq, _mm256_permute_pd(eq, 0x5)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd ptrue<Packet2cd>(const Packet2cd& a) { return Packet2cd(ptrue(Packet4d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet2cd pand   <Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_and_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd por    <Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_or_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pxor   <Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_xor_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pandnot<Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_andnot_pd(b.v,a.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cd pload <Packet2cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet2cd(pload<Packet4d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cd ploadu<Packet2cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cd(ploadu<Packet4d>((const double*)from)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cd pset1<Packet2cd>(const std::complex<double>& from)
+{
+  // in case casting to a __m128d* is really not safe, then we can still fallback to this version: (much slower though)
+//   return Packet2cd(_mm256_loadu2_m128d((const double*)&from,(const double*)&from));
+    return Packet2cd(_mm256_broadcast_pd((const __m128d*)(const void*)&from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd ploaddup<Packet2cd>(const std::complex<double>* from) { return pset1<Packet2cd>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet2cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet2cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cd pgather<std::complex<double>, Packet2cd>(const std::complex<double>* from, Index stride)
+{
+  return Packet2cd(_mm256_set_pd(std::imag(from[1*stride]), std::real(from[1*stride]),
+				 std::imag(from[0*stride]), std::real(from[0*stride])));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet2cd>(std::complex<double>* to, const Packet2cd& from, Index stride)
+{
+  __m128d low = _mm256_extractf128_pd(from.v, 0);
+  to[stride*0] = std::complex<double>(_mm_cvtsd_f64(low), _mm_cvtsd_f64(_mm_shuffle_pd(low, low, 1)));
+  __m128d high = _mm256_extractf128_pd(from.v, 1);
+  to[stride*1] = std::complex<double>(_mm_cvtsd_f64(high), _mm_cvtsd_f64(_mm_shuffle_pd(high, high, 1)));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet2cd>(const Packet2cd& a)
+{
+  __m128d low = _mm256_extractf128_pd(a.v, 0);
+  EIGEN_ALIGN16 double res[2];
+  _mm_store_pd(res, low);
+  return std::complex<double>(res[0],res[1]);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd preverse(const Packet2cd& a) {
+  __m256d result = _mm256_permute2f128_pd(a.v, a.v, 1);
+  return Packet2cd(result);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet2cd>(const Packet2cd& a)
+{
+  return predux(padd(Packet1cd(_mm256_extractf128_pd(a.v,0)),
+                     Packet1cd(_mm256_extractf128_pd(a.v,1))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet2cd>(const Packet2cd& a)
+{
+  return predux(pmul(Packet1cd(_mm256_extractf128_pd(a.v,0)),
+                     Packet1cd(_mm256_extractf128_pd(a.v,1))));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cd,Packet4d)
+
+template<> EIGEN_STRONG_INLINE Packet2cd pdiv<Packet2cd>(const Packet2cd& a, const Packet2cd& b)
+{
+  Packet2cd num = pmul(a, pconj(b));
+  __m256d tmp = _mm256_mul_pd(b.v, b.v);
+  __m256d denom = _mm256_hadd_pd(tmp, tmp);
+  return Packet2cd(_mm256_div_pd(num.v, denom));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd pcplxflip<Packet2cd>(const Packet2cd& x)
+{
+  return Packet2cd(_mm256_shuffle_pd(x.v, x.v, 0x5));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4cf,4>& kernel) {
+  __m256d P0 = _mm256_castps_pd(kernel.packet[0].v);
+  __m256d P1 = _mm256_castps_pd(kernel.packet[1].v);
+  __m256d P2 = _mm256_castps_pd(kernel.packet[2].v);
+  __m256d P3 = _mm256_castps_pd(kernel.packet[3].v);
+
+  __m256d T0 = _mm256_shuffle_pd(P0, P1, 15);
+  __m256d T1 = _mm256_shuffle_pd(P0, P1, 0);
+  __m256d T2 = _mm256_shuffle_pd(P2, P3, 15);
+  __m256d T3 = _mm256_shuffle_pd(P2, P3, 0);
+
+  kernel.packet[1].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T0, T2, 32));
+  kernel.packet[3].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T0, T2, 49));
+  kernel.packet[0].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T1, T3, 32));
+  kernel.packet[2].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T1, T3, 49));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2cd,2>& kernel) {
+  __m256d tmp = _mm256_permute2f128_pd(kernel.packet[0].v, kernel.packet[1].v, 0+(2<<4));
+  kernel.packet[1].v = _mm256_permute2f128_pd(kernel.packet[0].v, kernel.packet[1].v, 1+(3<<4));
+ kernel.packet[0].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd psqrt<Packet2cd>(const Packet2cd& a) {
+  return psqrt_complex<Packet2cd>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf psqrt<Packet4cf>(const Packet4cf& a) {
+  return psqrt_complex<Packet4cf>(a);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_AVX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/MathFunctions.h
new file mode 100644
index 00000000..67041c81
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/MathFunctions.h
@@ -0,0 +1,228 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_AVX_H
+#define EIGEN_MATH_FUNCTIONS_AVX_H
+
+/* The sin and cos functions of this file are loosely derived from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+namespace Eigen {
+
+namespace internal {
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+psin<Packet8f>(const Packet8f& _x) {
+  return psin_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+pcos<Packet8f>(const Packet8f& _x) {
+  return pcos_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+plog<Packet8f>(const Packet8f& _x) {
+  return plog_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d
+plog<Packet4d>(const Packet4d& _x) {
+  return plog_double(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+plog2<Packet8f>(const Packet8f& _x) {
+  return plog2_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d
+plog2<Packet4d>(const Packet4d& _x) {
+  return plog2_double(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f plog1p<Packet8f>(const Packet8f& _x) {
+  return generic_plog1p(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f pexpm1<Packet8f>(const Packet8f& _x) {
+  return generic_expm1(_x);
+}
+
+// Exponential function. Works by writing "x = m*log(2) + r" where
+// "m = floor(x/log(2)+1/2)" and "r" is the remainder. The result is then
+// "exp(x) = 2^m*exp(r)" where exp(r) is in the range [-1,1).
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+pexp<Packet8f>(const Packet8f& _x) {
+  return pexp_float(_x);
+}
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+ptanh<Packet8f>(const Packet8f& _x) {
+  return internal::generic_fast_tanh_float(_x);
+}
+
+// Exponential function for doubles.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d
+pexp<Packet4d>(const Packet4d& _x) {
+  return pexp_double(_x);
+}
+
+// Functions for sqrt.
+// The EIGEN_FAST_MATH version uses the _mm_rsqrt_ps approximation and one step
+// of Newton's method, at a cost of 1-2 bits of precision as opposed to the
+// exact solution. It does not handle +inf, or denormalized numbers correctly.
+// The main advantage of this approach is not just speed, but also the fact that
+// it can be inlined and pipelined with other computations, further reducing its
+// effective latency. This is similar to Quake3's fast inverse square root.
+// For detail see here: http://www.beyond3d.com/content/articles/8/
+#if EIGEN_FAST_MATH
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f psqrt<Packet8f>(const Packet8f& _x) {
+  Packet8f minus_half_x = pmul(_x, pset1<Packet8f>(-0.5f));
+  Packet8f denormal_mask = pandnot(
+      pcmp_lt(_x, pset1<Packet8f>((std::numeric_limits<float>::min)())),
+      pcmp_lt(_x, pzero(_x)));
+
+  // Compute approximate reciprocal sqrt.
+  Packet8f x = _mm256_rsqrt_ps(_x);
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(minus_half_x, pmul(x,x), pset1<Packet8f>(1.5f)));
+  // Flush results for denormals to zero.
+  return pandnot(pmul(_x,x), denormal_mask);
+}
+
+#else
+
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f psqrt<Packet8f>(const Packet8f& _x) {
+  return _mm256_sqrt_ps(_x);
+}
+
+#endif
+
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4d psqrt<Packet4d>(const Packet4d& _x) {
+  return _mm256_sqrt_pd(_x);
+}
+
+#if EIGEN_FAST_MATH
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f prsqrt<Packet8f>(const Packet8f& _x) {
+  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(inf, 0x7f800000);
+  _EIGEN_DECLARE_CONST_Packet8f(one_point_five, 1.5f);
+  _EIGEN_DECLARE_CONST_Packet8f(minus_half, -0.5f);
+  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(flt_min, 0x00800000);
+
+  Packet8f neg_half = pmul(_x, p8f_minus_half);
+
+  // select only the inverse sqrt of positive normal inputs (denormals are
+  // flushed to zero and cause infs as well).
+  Packet8f lt_min_mask = _mm256_cmp_ps(_x, p8f_flt_min, _CMP_LT_OQ);
+  Packet8f inf_mask =  _mm256_cmp_ps(_x, p8f_inf, _CMP_EQ_OQ);
+  Packet8f not_normal_finite_mask = _mm256_or_ps(lt_min_mask, inf_mask);
+
+  // Compute an approximate result using the rsqrt intrinsic.
+  Packet8f y_approx = _mm256_rsqrt_ps(_x);
+
+  // Do a single step of Newton-Raphson iteration to improve the approximation.
+  // This uses the formula y_{n+1} = y_n * (1.5 - y_n * (0.5 * x) * y_n).
+  // It is essential to evaluate the inner term like this because forming
+  // y_n^2 may over- or underflow.
+  Packet8f y_newton = pmul(y_approx, pmadd(y_approx, pmul(neg_half, y_approx), p8f_one_point_five));
+
+  // Select the result of the Newton-Raphson step for positive normal arguments.
+  // For other arguments, choose the output of the intrinsic. This will
+  // return rsqrt(+inf) = 0, rsqrt(x) = NaN if x < 0, and rsqrt(x) = +inf if
+  // x is zero or a positive denormalized float (equivalent to flushing positive
+  // denormalized inputs to zero).
+  return pselect<Packet8f>(not_normal_finite_mask, y_approx, y_newton);
+}
+
+#else
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f prsqrt<Packet8f>(const Packet8f& _x) {
+  _EIGEN_DECLARE_CONST_Packet8f(one, 1.0f);
+  return _mm256_div_ps(p8f_one, _mm256_sqrt_ps(_x));
+}
+#endif
+
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4d prsqrt<Packet4d>(const Packet4d& _x) {
+  _EIGEN_DECLARE_CONST_Packet4d(one, 1.0);
+  return _mm256_div_pd(p4d_one, _mm256_sqrt_pd(_x));
+}
+
+F16_PACKET_FUNCTION(Packet8f, Packet8h, psin)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, pcos)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, plog)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, plog2)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, plog1p)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, pexpm1)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, pexp)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, ptanh)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, psqrt)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, prsqrt)
+
+template <>
+EIGEN_STRONG_INLINE Packet8h pfrexp(const Packet8h& a, Packet8h& exponent) {
+  Packet8f fexponent;
+  const Packet8h out = float2half(pfrexp<Packet8f>(half2float(a), fexponent));
+  exponent = float2half(fexponent);
+  return out;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h pldexp(const Packet8h& a, const Packet8h& exponent) {
+  return float2half(pldexp<Packet8f>(half2float(a), half2float(exponent)));
+}
+
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, psin)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, pcos)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, plog)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, plog2)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, plog1p)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, pexpm1)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, pexp)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, ptanh)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, psqrt)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, prsqrt)
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pfrexp(const Packet8bf& a, Packet8bf& exponent) {
+  Packet8f fexponent;
+  const Packet8bf out = F32ToBf16(pfrexp<Packet8f>(Bf16ToF32(a), fexponent));
+  exponent = F32ToBf16(fexponent);
+  return out;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pldexp(const Packet8bf& a, const Packet8bf& exponent) {
+  return F32ToBf16(pldexp<Packet8f>(Bf16ToF32(a), Bf16ToF32(exponent)));
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_AVX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/PacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/PacketMath.h
new file mode 100644
index 00000000..7fc32fd7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/PacketMath.h
@@ -0,0 +1,1574 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner (benoit.steiner.goog@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_AVX_H
+#define EIGEN_PACKET_MATH_AVX_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#if !defined(EIGEN_VECTORIZE_AVX512) && !defined(EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS)
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 16
+#endif
+
+#ifdef EIGEN_VECTORIZE_FMA
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+#endif
+
+typedef __m256  Packet8f;
+typedef __m256i Packet8i;
+typedef __m256d Packet4d;
+typedef eigen_packet_wrapper<__m128i, 2> Packet8h;
+typedef eigen_packet_wrapper<__m128i, 3> Packet8bf;
+
+template<> struct is_arithmetic<__m256>  { enum { value = true }; };
+template<> struct is_arithmetic<__m256i> { enum { value = true }; };
+template<> struct is_arithmetic<__m256d> { enum { value = true }; };
+template<> struct is_arithmetic<Packet8h> { enum { value = true }; };
+template<> struct is_arithmetic<Packet8bf> { enum { value = true }; };
+
+#define _EIGEN_DECLARE_CONST_Packet8f(NAME,X) \
+  const Packet8f p8f_##NAME = pset1<Packet8f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4d(NAME,X) \
+  const Packet4d p4d_##NAME = pset1<Packet4d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(NAME,X) \
+  const Packet8f p8f_##NAME = _mm256_castsi256_ps(pset1<Packet8i>(X))
+
+#define _EIGEN_DECLARE_CONST_Packet8i(NAME,X) \
+  const Packet8i p8i_##NAME = pset1<Packet8i>(X)
+
+// Use the packet_traits defined in AVX512/PacketMath.h instead if we're going
+// to leverage AVX512 instructions.
+#ifndef EIGEN_VECTORIZE_AVX512
+template<> struct packet_traits<float>  : default_packet_traits
+{
+  typedef Packet8f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+
+    HasCmp  = 1,
+    HasDiv = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasLog1p = 1,
+    HasExpm1 = 1,
+    HasExp = 1,
+    HasNdtri = 1,
+    HasBessel = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+    HasBlend = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1
+  };
+};
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet4d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+    HasHalfPacket = 1,
+
+    HasCmp  = 1,
+    HasDiv  = 1,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasBlend = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1
+  };
+};
+
+template <>
+struct packet_traits<Eigen::half> : default_packet_traits {
+  typedef Packet8h type;
+  // There is no half-size packet for Packet8h.
+  typedef Packet8h half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+
+    HasCmp    = 1,
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasSin    = EIGEN_FAST_MATH,
+    HasCos    = EIGEN_FAST_MATH,
+    HasNegate = 1,
+    HasAbs    = 1,
+    HasAbs2   = 0,
+    HasMin    = 1,
+    HasMax    = 1,
+    HasConj   = 1,
+    HasSetLinear = 0,
+    HasLog    = 1,
+    HasLog1p  = 1,
+    HasExpm1  = 1,
+    HasExp    = 1,
+    HasSqrt   = 1,
+    HasRsqrt  = 1,
+    HasTanh   = EIGEN_FAST_MATH,
+    HasErf    = EIGEN_FAST_MATH,
+    HasBlend  = 0,
+    HasRound  = 1,
+    HasFloor  = 1,
+    HasCeil   = 1,
+    HasRint   = 1,
+    HasBessel = 1,
+    HasNdtri  = 1
+  };
+};
+
+template <>
+struct packet_traits<bfloat16> : default_packet_traits {
+  typedef Packet8bf type;
+  // There is no half-size packet for current Packet8bf.
+  // TODO: support as SSE path.
+  typedef Packet8bf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+
+    HasCmp = 1,
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasNegate = 1,
+    HasAbs    = 1,
+    HasAbs2   = 0,
+    HasMin    = 1,
+    HasMax    = 1,
+    HasConj   = 1,
+    HasSetLinear = 0,
+    HasLog = 1,
+    HasLog1p  = 1,
+    HasExpm1  = 1,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+    HasBlend = 0,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+    HasBessel = 1,
+    HasNdtri  = 1
+  };
+};
+#endif
+
+template<> struct scalar_div_cost<float,true> { enum { value = 14 }; };
+template<> struct scalar_div_cost<double,true> { enum { value = 16 }; };
+
+/* Proper support for integers is only provided by AVX2. In the meantime, we'll
+   use SSE instructions and packets to deal with integers.
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet8i type;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=8
+  };
+};
+*/
+
+template<> struct unpacket_traits<Packet8f> {
+  typedef float     type;
+  typedef Packet4f  half;
+  typedef Packet8i  integer_packet;
+  typedef uint8_t   mask_t;
+  enum {size=8, alignment=Aligned32, vectorizable=true, masked_load_available=true, masked_store_available=true};
+};
+template<> struct unpacket_traits<Packet4d> {
+  typedef double type;
+  typedef Packet2d half;
+  enum {size=4, alignment=Aligned32, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet8i> { typedef int    type; typedef Packet4i half; enum {size=8, alignment=Aligned32, vectorizable=false, masked_load_available=false, masked_store_available=false}; };
+template<> struct unpacket_traits<Packet8bf> { typedef bfloat16 type; typedef Packet8bf half; enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; };
+
+// Helper function for bit packing snippet of low precision comparison.
+// It packs the flags from 16x16 to 8x16.
+EIGEN_STRONG_INLINE __m128i Pack16To8(Packet8f rf) {
+  return _mm_packs_epi32(_mm256_extractf128_si256(_mm256_castps_si256(rf), 0),
+                         _mm256_extractf128_si256(_mm256_castps_si256(rf), 1));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet8f pset1<Packet8f>(const float&  from) { return _mm256_set1_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet4d pset1<Packet4d>(const double& from) { return _mm256_set1_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet8i pset1<Packet8i>(const int&    from) { return _mm256_set1_epi32(from); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pset1frombits<Packet8f>(unsigned int from) { return _mm256_castsi256_ps(pset1<Packet8i>(from)); }
+template<> EIGEN_STRONG_INLINE Packet4d pset1frombits<Packet4d>(uint64_t from) { return _mm256_castsi256_pd(_mm256_set1_epi64x(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pzero(const Packet8f& /*a*/) { return _mm256_setzero_ps(); }
+template<> EIGEN_STRONG_INLINE Packet4d pzero(const Packet4d& /*a*/) { return _mm256_setzero_pd(); }
+template<> EIGEN_STRONG_INLINE Packet8i pzero(const Packet8i& /*a*/) { return _mm256_setzero_si256(); }
+
+
+template<> EIGEN_STRONG_INLINE Packet8f peven_mask(const Packet8f& /*a*/) { return _mm256_castsi256_ps(_mm256_set_epi32(0, -1, 0, -1, 0, -1, 0, -1)); }
+template<> EIGEN_STRONG_INLINE Packet8i peven_mask(const Packet8i& /*a*/) { return _mm256_set_epi32(0, -1, 0, -1, 0, -1, 0, -1); }
+template<> EIGEN_STRONG_INLINE Packet4d peven_mask(const Packet4d& /*a*/) { return _mm256_castsi256_pd(_mm256_set_epi32(0, 0, -1, -1, 0, 0, -1, -1)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pload1<Packet8f>(const float*  from) { return _mm256_broadcast_ss(from); }
+template<> EIGEN_STRONG_INLINE Packet4d pload1<Packet4d>(const double* from) { return _mm256_broadcast_sd(from); }
+
+template<> EIGEN_STRONG_INLINE Packet8f plset<Packet8f>(const float& a) { return _mm256_add_ps(_mm256_set1_ps(a), _mm256_set_ps(7.0,6.0,5.0,4.0,3.0,2.0,1.0,0.0)); }
+template<> EIGEN_STRONG_INLINE Packet4d plset<Packet4d>(const double& a) { return _mm256_add_pd(_mm256_set1_pd(a), _mm256_set_pd(3.0,2.0,1.0,0.0)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f padd<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_add_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d padd<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_add_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i padd<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_add_epi32(a,b);
+#else
+  __m128i lo = _mm_add_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
+  __m128i hi = _mm_add_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f psub<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_sub_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d psub<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_sub_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i psub<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_sub_epi32(a,b);
+#else
+  __m128i lo = _mm_sub_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
+  __m128i hi = _mm_sub_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pnegate(const Packet8f& a)
+{
+  return _mm256_sub_ps(_mm256_set1_ps(0.0),a);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pnegate(const Packet4d& a)
+{
+  return _mm256_sub_pd(_mm256_set1_pd(0.0),a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pconj(const Packet8f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4d pconj(const Packet4d& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8i pconj(const Packet8i& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet8f pmul<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_mul_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pmul<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_mul_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i pmul<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_mullo_epi32(a,b);
+#else
+  const __m128i lo = _mm_mullo_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
+  const __m128i hi = _mm_mullo_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pdiv<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_div_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pdiv<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_div_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i pdiv<Packet8i>(const Packet8i& /*a*/, const Packet8i& /*b*/)
+{ eigen_assert(false && "packet integer division are not supported by AVX");
+  return pset1<Packet8i>(0);
+}
+
+#ifdef EIGEN_VECTORIZE_FMA
+template<> EIGEN_STRONG_INLINE Packet8f pmadd(const Packet8f& a, const Packet8f& b, const Packet8f& c) {
+#if ( (EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC<80) || (EIGEN_COMP_CLANG) )
+  // Clang stupidly generates a vfmadd213ps instruction plus some vmovaps on registers,
+  //  and even register spilling with clang>=6.0 (bug 1637).
+  // Gcc stupidly generates a vfmadd132ps instruction.
+  // So let's enforce it to generate a vfmadd231ps instruction since the most common use
+  //  case is to accumulate the result of the product.
+  Packet8f res = c;
+  __asm__("vfmadd231ps %[a], %[b], %[c]" : [c] "+x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  return _mm256_fmadd_ps(a,b,c);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4d pmadd(const Packet4d& a, const Packet4d& b, const Packet4d& c) {
+#if ( (EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC<80) || (EIGEN_COMP_CLANG) )
+  // see above
+  Packet4d res = c;
+  __asm__("vfmadd231pd %[a], %[b], %[c]" : [c] "+x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  return _mm256_fmadd_pd(a,b,c);
+#endif
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet8f pcmp_le(const Packet8f& a, const Packet8f& b) { return _mm256_cmp_ps(a,b,_CMP_LE_OQ); }
+template<> EIGEN_STRONG_INLINE Packet8f pcmp_lt(const Packet8f& a, const Packet8f& b) { return _mm256_cmp_ps(a,b,_CMP_LT_OQ); }
+template<> EIGEN_STRONG_INLINE Packet8f pcmp_lt_or_nan(const Packet8f& a, const Packet8f& b) { return _mm256_cmp_ps(a, b, _CMP_NGE_UQ); }
+template<> EIGEN_STRONG_INLINE Packet8f pcmp_eq(const Packet8f& a, const Packet8f& b) { return _mm256_cmp_ps(a,b,_CMP_EQ_OQ); }
+
+template<> EIGEN_STRONG_INLINE Packet4d pcmp_le(const Packet4d& a, const Packet4d& b) { return _mm256_cmp_pd(a,b,_CMP_LE_OQ); }
+template<> EIGEN_STRONG_INLINE Packet4d pcmp_lt(const Packet4d& a, const Packet4d& b) { return _mm256_cmp_pd(a,b,_CMP_LT_OQ); }
+template<> EIGEN_STRONG_INLINE Packet4d pcmp_lt_or_nan(const Packet4d& a, const Packet4d& b) { return _mm256_cmp_pd(a, b, _CMP_NGE_UQ); }
+template<> EIGEN_STRONG_INLINE Packet4d pcmp_eq(const Packet4d& a, const Packet4d& b) { return _mm256_cmp_pd(a,b,_CMP_EQ_OQ); }
+
+
+template<> EIGEN_STRONG_INLINE Packet8i pcmp_eq(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_cmpeq_epi32(a,b);
+#else
+  __m128i lo = _mm_cmpeq_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
+  __m128i hi = _mm_cmpeq_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pmin<Packet8f>(const Packet8f& a, const Packet8f& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // There appears to be a bug in GCC, by which the optimizer may flip
+  // the argument order in calls to _mm_min_ps/_mm_max_ps, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  Packet8f res;
+  asm("vminps %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  // Arguments are swapped to match NaN propagation behavior of std::min.
+  return _mm256_min_ps(b,a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4d pmin<Packet4d>(const Packet4d& a, const Packet4d& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // See pmin above
+  Packet4d res;
+  asm("vminpd %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  // Arguments are swapped to match NaN propagation behavior of std::min.
+  return _mm256_min_pd(b,a);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pmax<Packet8f>(const Packet8f& a, const Packet8f& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // See pmin above
+  Packet8f res;
+  asm("vmaxps %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  // Arguments are swapped to match NaN propagation behavior of std::max.
+  return _mm256_max_ps(b,a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4d pmax<Packet4d>(const Packet4d& a, const Packet4d& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // See pmin above
+  Packet4d res;
+  asm("vmaxpd %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  // Arguments are swapped to match NaN propagation behavior of std::max.
+  return _mm256_max_pd(b,a);
+#endif
+}
+
+// Add specializations for min/max with prescribed NaN progation.
+template<>
+EIGEN_STRONG_INLINE Packet8f pmin<PropagateNumbers, Packet8f>(const Packet8f& a, const Packet8f& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet8f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4d pmin<PropagateNumbers, Packet4d>(const Packet4d& a, const Packet4d& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet4d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8f pmax<PropagateNumbers, Packet8f>(const Packet8f& a, const Packet8f& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet8f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4d pmax<PropagateNumbers, Packet4d>(const Packet4d& a, const Packet4d& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet4d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8f pmin<PropagateNaN, Packet8f>(const Packet8f& a, const Packet8f& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet8f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4d pmin<PropagateNaN, Packet4d>(const Packet4d& a, const Packet4d& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet4d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8f pmax<PropagateNaN, Packet8f>(const Packet8f& a, const Packet8f& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet8f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4d pmax<PropagateNaN, Packet4d>(const Packet4d& a, const Packet4d& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet4d>);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f print<Packet8f>(const Packet8f& a) { return _mm256_round_ps(a, _MM_FROUND_CUR_DIRECTION); }
+template<> EIGEN_STRONG_INLINE Packet4d print<Packet4d>(const Packet4d& a) { return _mm256_round_pd(a, _MM_FROUND_CUR_DIRECTION); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pceil<Packet8f>(const Packet8f& a) { return _mm256_ceil_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet4d pceil<Packet4d>(const Packet4d& a) { return _mm256_ceil_pd(a); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pfloor<Packet8f>(const Packet8f& a) { return _mm256_floor_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet4d pfloor<Packet4d>(const Packet4d& a) { return _mm256_floor_pd(a); }
+
+
+template<> EIGEN_STRONG_INLINE Packet8i ptrue<Packet8i>(const Packet8i& a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  // vpcmpeqd has lower latency than the more general vcmpps
+  return _mm256_cmpeq_epi32(a,a);
+#else
+  const __m256 b = _mm256_castsi256_ps(a);
+  return _mm256_castps_si256(_mm256_cmp_ps(b,b,_CMP_TRUE_UQ));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f ptrue<Packet8f>(const Packet8f& a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  // vpcmpeqd has lower latency than the more general vcmpps
+  const __m256i b = _mm256_castps_si256(a);
+  return _mm256_castsi256_ps(_mm256_cmpeq_epi32(b,b));
+#else
+  return _mm256_cmp_ps(a,a,_CMP_TRUE_UQ);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4d ptrue<Packet4d>(const Packet4d& a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  // vpcmpeqq has lower latency than the more general vcmppd
+  const __m256i b = _mm256_castpd_si256(a);
+  return _mm256_castsi256_pd(_mm256_cmpeq_epi64(b,b));
+#else
+  return _mm256_cmp_pd(a,a,_CMP_TRUE_UQ);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pand<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_and_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pand<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_and_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i pand<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_and_si256(a,b);
+#else
+  return _mm256_castps_si256(_mm256_and_ps(_mm256_castsi256_ps(a),_mm256_castsi256_ps(b)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f por<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_or_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d por<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_or_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i por<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_or_si256(a,b);
+#else
+  return _mm256_castps_si256(_mm256_or_ps(_mm256_castsi256_ps(a),_mm256_castsi256_ps(b)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pxor<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_xor_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pxor<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_xor_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i pxor<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_xor_si256(a,b);
+#else
+  return _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(a),_mm256_castsi256_ps(b)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pandnot<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_andnot_ps(b,a); }
+template<> EIGEN_STRONG_INLINE Packet4d pandnot<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_andnot_pd(b,a); }
+template<> EIGEN_STRONG_INLINE Packet8i pandnot<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_andnot_si256(b,a);
+#else
+  return _mm256_castps_si256(_mm256_andnot_ps(_mm256_castsi256_ps(b),_mm256_castsi256_ps(a)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pround<Packet8f>(const Packet8f& a)
+{
+  const Packet8f mask = pset1frombits<Packet8f>(static_cast<numext::uint32_t>(0x80000000u));
+  const Packet8f prev0dot5 = pset1frombits<Packet8f>(static_cast<numext::uint32_t>(0x3EFFFFFFu));
+  return _mm256_round_ps(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pround<Packet4d>(const Packet4d& a)
+{
+  const Packet4d mask = pset1frombits<Packet4d>(static_cast<numext::uint64_t>(0x8000000000000000ull));
+  const Packet4d prev0dot5 = pset1frombits<Packet4d>(static_cast<numext::uint64_t>(0x3FDFFFFFFFFFFFFFull));
+  return _mm256_round_pd(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pselect<Packet8f>(const Packet8f& mask, const Packet8f& a, const Packet8f& b)
+{ return _mm256_blendv_ps(b,a,mask); }
+template<> EIGEN_STRONG_INLINE Packet4d pselect<Packet4d>(const Packet4d& mask, const Packet4d& a, const Packet4d& b)
+{ return _mm256_blendv_pd(b,a,mask); }
+
+template<int N> EIGEN_STRONG_INLINE Packet8i parithmetic_shift_right(Packet8i a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_srai_epi32(a, N);
+#else
+  __m128i lo = _mm_srai_epi32(_mm256_extractf128_si256(a, 0), N);
+  __m128i hi = _mm_srai_epi32(_mm256_extractf128_si256(a, 1), N);
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet8i plogical_shift_right(Packet8i a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_srli_epi32(a, N);
+#else
+  __m128i lo = _mm_srli_epi32(_mm256_extractf128_si256(a, 0), N);
+  __m128i hi = _mm_srli_epi32(_mm256_extractf128_si256(a, 1), N);
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet8i plogical_shift_left(Packet8i a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_slli_epi32(a, N);
+#else
+  __m128i lo = _mm_slli_epi32(_mm256_extractf128_si256(a, 0), N);
+  __m128i hi = _mm_slli_epi32(_mm256_extractf128_si256(a, 1), N);
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pload<Packet8f>(const float*   from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet4d pload<Packet4d>(const double*  from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet8i pload<Packet8i>(const int*     from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_si256(reinterpret_cast<const __m256i*>(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f ploadu<Packet8f>(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet4d ploadu<Packet4d>(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet8i ploadu<Packet8i>(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f ploadu<Packet8f>(const float* from, uint8_t umask) {
+  Packet8i mask = _mm256_set1_epi8(static_cast<char>(umask));
+  const Packet8i bit_mask = _mm256_set_epi32(0xffffff7f, 0xffffffbf, 0xffffffdf, 0xffffffef, 0xfffffff7, 0xfffffffb, 0xfffffffd, 0xfffffffe);
+  mask = por<Packet8i>(mask, bit_mask);
+  mask = pcmp_eq<Packet8i>(mask, _mm256_set1_epi32(0xffffffff));
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_maskload_ps(from, mask);
+}
+
+// Loads 4 floats from memory a returns the packet {a0, a0  a1, a1, a2, a2, a3, a3}
+template<> EIGEN_STRONG_INLINE Packet8f ploaddup<Packet8f>(const float* from)
+{
+  // TODO try to find a way to avoid the need of a temporary register
+//   Packet8f tmp  = _mm256_castps128_ps256(_mm_loadu_ps(from));
+//   tmp = _mm256_insertf128_ps(tmp, _mm_movehl_ps(_mm256_castps256_ps128(tmp),_mm256_castps256_ps128(tmp)), 1);
+//   return _mm256_unpacklo_ps(tmp,tmp);
+
+  // _mm256_insertf128_ps is very slow on Haswell, thus:
+  Packet8f tmp = _mm256_broadcast_ps((const __m128*)(const void*)from);
+  // mimic an "inplace" permutation of the lower 128bits using a blend
+  tmp = _mm256_blend_ps(tmp,_mm256_castps128_ps256(_mm_permute_ps( _mm256_castps256_ps128(tmp), _MM_SHUFFLE(1,0,1,0))), 15);
+  // then we can perform a consistent permutation on the global register to get everything in shape:
+  return  _mm256_permute_ps(tmp, _MM_SHUFFLE(3,3,2,2));
+}
+// Loads 2 doubles from memory a returns the packet {a0, a0  a1, a1}
+template<> EIGEN_STRONG_INLINE Packet4d ploaddup<Packet4d>(const double* from)
+{
+  Packet4d tmp = _mm256_broadcast_pd((const __m128d*)(const void*)from);
+  return  _mm256_permute_pd(tmp, 3<<2);
+}
+
+// Loads 2 floats from memory a returns the packet {a0, a0  a0, a0, a1, a1, a1, a1}
+template<> EIGEN_STRONG_INLINE Packet8f ploadquad<Packet8f>(const float* from)
+{
+  Packet8f tmp = _mm256_castps128_ps256(_mm_broadcast_ss(from));
+  return _mm256_insertf128_ps(tmp, _mm_broadcast_ss(from+1), 1);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet8f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_store_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet4d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_store_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet8i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*   to, const Packet8f& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet4d& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*       to, const Packet8i& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*   to, const Packet8f& from, uint8_t umask) {
+  Packet8i mask = _mm256_set1_epi8(static_cast<char>(umask));
+  const Packet8i bit_mask = _mm256_set_epi32(0xffffff7f, 0xffffffbf, 0xffffffdf, 0xffffffef, 0xfffffff7, 0xfffffffb, 0xfffffffd, 0xfffffffe);
+  mask = por<Packet8i>(mask, bit_mask);
+  mask = pcmp_eq<Packet8i>(mask, _mm256_set1_epi32(0xffffffff));
+  EIGEN_DEBUG_UNALIGNED_STORE return _mm256_maskstore_ps(to, mask, from);
+}
+
+// NOTE: leverage _mm256_i32gather_ps and _mm256_i32gather_pd if AVX2 instructions are available
+// NOTE: for the record the following seems to be slower: return _mm256_i32gather_ps(from, _mm256_set1_epi32(stride), 4);
+template<> EIGEN_DEVICE_FUNC inline Packet8f pgather<float, Packet8f>(const float* from, Index stride)
+{
+  return _mm256_set_ps(from[7*stride], from[6*stride], from[5*stride], from[4*stride],
+                       from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet4d pgather<double, Packet4d>(const double* from, Index stride)
+{
+  return _mm256_set_pd(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet8f>(float* to, const Packet8f& from, Index stride)
+{
+  __m128 low = _mm256_extractf128_ps(from, 0);
+  to[stride*0] = _mm_cvtss_f32(low);
+  to[stride*1] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 1));
+  to[stride*2] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 2));
+  to[stride*3] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 3));
+
+  __m128 high = _mm256_extractf128_ps(from, 1);
+  to[stride*4] = _mm_cvtss_f32(high);
+  to[stride*5] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 1));
+  to[stride*6] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 2));
+  to[stride*7] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 3));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet4d>(double* to, const Packet4d& from, Index stride)
+{
+  __m128d low = _mm256_extractf128_pd(from, 0);
+  to[stride*0] = _mm_cvtsd_f64(low);
+  to[stride*1] = _mm_cvtsd_f64(_mm_shuffle_pd(low, low, 1));
+  __m128d high = _mm256_extractf128_pd(from, 1);
+  to[stride*2] = _mm_cvtsd_f64(high);
+  to[stride*3] = _mm_cvtsd_f64(_mm_shuffle_pd(high, high, 1));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore1<Packet8f>(float* to, const float& a)
+{
+  Packet8f pa = pset1<Packet8f>(a);
+  pstore(to, pa);
+}
+template<> EIGEN_STRONG_INLINE void pstore1<Packet4d>(double* to, const double& a)
+{
+  Packet4d pa = pset1<Packet4d>(a);
+  pstore(to, pa);
+}
+template<> EIGEN_STRONG_INLINE void pstore1<Packet8i>(int* to, const int& a)
+{
+  Packet8i pa = pset1<Packet8i>(a);
+  pstore(to, pa);
+}
+
+#ifndef EIGEN_VECTORIZE_AVX512
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+#endif
+
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet8f>(const Packet8f& a) {
+  return _mm_cvtss_f32(_mm256_castps256_ps128(a));
+}
+template<> EIGEN_STRONG_INLINE double pfirst<Packet4d>(const Packet4d& a) {
+  return _mm_cvtsd_f64(_mm256_castpd256_pd128(a));
+}
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet8i>(const Packet8i& a) {
+  return _mm_cvtsi128_si32(_mm256_castsi256_si128(a));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet8f preverse(const Packet8f& a)
+{
+  __m256 tmp = _mm256_shuffle_ps(a,a,0x1b);
+  return _mm256_permute2f128_ps(tmp, tmp, 1);
+}
+template<> EIGEN_STRONG_INLINE Packet4d preverse(const Packet4d& a)
+{
+   __m256d tmp = _mm256_shuffle_pd(a,a,5);
+  return _mm256_permute2f128_pd(tmp, tmp, 1);
+  #if 0
+  // This version is unlikely to be faster as _mm256_shuffle_ps and _mm256_permute_pd
+  // exhibit the same latency/throughput, but it is here for future reference/benchmarking...
+  __m256d swap_halves = _mm256_permute2f128_pd(a,a,1);
+    return _mm256_permute_pd(swap_halves,5);
+  #endif
+}
+
+// pabs should be ok
+template<> EIGEN_STRONG_INLINE Packet8f pabs(const Packet8f& a)
+{
+  const Packet8f mask = _mm256_castsi256_ps(_mm256_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF));
+  return _mm256_and_ps(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pabs(const Packet4d& a)
+{
+  const Packet4d mask = _mm256_castsi256_pd(_mm256_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF));
+  return _mm256_and_pd(a,mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pfrexp<Packet8f>(const Packet8f& a, Packet8f& exponent) {
+  return pfrexp_generic(a,exponent);
+}
+
+// Extract exponent without existence of Packet4l.
+template<>
+EIGEN_STRONG_INLINE  
+Packet4d pfrexp_generic_get_biased_exponent(const Packet4d& a) {
+  const Packet4d cst_exp_mask  = pset1frombits<Packet4d>(static_cast<uint64_t>(0x7ff0000000000000ull));
+  __m256i a_expo = _mm256_castpd_si256(pand(a, cst_exp_mask));
+#ifdef EIGEN_VECTORIZE_AVX2
+  a_expo = _mm256_srli_epi64(a_expo, 52);
+  __m128i lo = _mm256_extractf128_si256(a_expo, 0);
+  __m128i hi = _mm256_extractf128_si256(a_expo, 1);
+#else
+  __m128i lo = _mm256_extractf128_si256(a_expo, 0);
+  __m128i hi = _mm256_extractf128_si256(a_expo, 1);
+  lo = _mm_srli_epi64(lo, 52);
+  hi = _mm_srli_epi64(hi, 52);
+#endif
+  Packet2d exponent_lo = _mm_cvtepi32_pd(vec4i_swizzle1(lo, 0, 2, 1, 3));
+  Packet2d exponent_hi = _mm_cvtepi32_pd(vec4i_swizzle1(hi, 0, 2, 1, 3));
+  Packet4d exponent = _mm256_insertf128_pd(_mm256_setzero_pd(), exponent_lo, 0);
+  exponent = _mm256_insertf128_pd(exponent, exponent_hi, 1);
+  return exponent;
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4d pfrexp<Packet4d>(const Packet4d& a, Packet4d& exponent) {
+  return pfrexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pldexp<Packet8f>(const Packet8f& a, const Packet8f& exponent) {
+  return pldexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4d pldexp<Packet4d>(const Packet4d& a, const Packet4d& exponent) {
+  // Clamp exponent to [-2099, 2099]
+  const Packet4d max_exponent = pset1<Packet4d>(2099.0);
+  const Packet4i e = _mm256_cvtpd_epi32(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
+  
+  // Split 2^e into four factors and multiply.
+  const Packet4i bias = pset1<Packet4i>(1023);
+  Packet4i b = parithmetic_shift_right<2>(e);  // floor(e/4)
+  
+  // 2^b
+  Packet4i hi = vec4i_swizzle1(padd(b, bias), 0, 2, 1, 3);
+  Packet4i lo = _mm_slli_epi64(hi, 52);
+  hi = _mm_slli_epi64(_mm_srli_epi64(hi, 32), 52);
+  Packet4d c = _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
+  Packet4d out = pmul(pmul(pmul(a, c), c), c);  // a * 2^(3b)
+  
+  // 2^(e - 3b)
+  b = psub(psub(psub(e, b), b), b);  // e - 3b
+  hi = vec4i_swizzle1(padd(b, bias), 0, 2, 1, 3);
+  lo = _mm_slli_epi64(hi, 52);
+  hi = _mm_slli_epi64(_mm_srli_epi64(hi, 32), 52);
+  c = _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
+  out = pmul(out, c); // a * 2^e
+  return out;
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet8f>(const Packet8f& a)
+{
+  return predux(Packet4f(_mm_add_ps(_mm256_castps256_ps128(a),_mm256_extractf128_ps(a,1))));
+}
+template<> EIGEN_STRONG_INLINE double predux<Packet4d>(const Packet4d& a)
+{
+  return predux(Packet2d(_mm_add_pd(_mm256_castpd256_pd128(a),_mm256_extractf128_pd(a,1))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f predux_half_dowto4<Packet8f>(const Packet8f& a)
+{
+  return _mm_add_ps(_mm256_castps256_ps128(a),_mm256_extractf128_ps(a,1));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet8f>(const Packet8f& a)
+{
+  Packet8f tmp;
+  tmp = _mm256_mul_ps(a, _mm256_permute2f128_ps(a,a,1));
+  tmp = _mm256_mul_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
+  return pfirst(_mm256_mul_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet4d>(const Packet4d& a)
+{
+  Packet4d tmp;
+  tmp = _mm256_mul_pd(a, _mm256_permute2f128_pd(a,a,1));
+  return pfirst(_mm256_mul_pd(tmp, _mm256_shuffle_pd(tmp,tmp,1)));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_min<Packet8f>(const Packet8f& a)
+{
+  Packet8f tmp = _mm256_min_ps(a, _mm256_permute2f128_ps(a,a,1));
+  tmp = _mm256_min_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
+  return pfirst(_mm256_min_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_min<Packet4d>(const Packet4d& a)
+{
+  Packet4d tmp = _mm256_min_pd(a, _mm256_permute2f128_pd(a,a,1));
+  return pfirst(_mm256_min_pd(tmp, _mm256_shuffle_pd(tmp, tmp, 1)));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_max<Packet8f>(const Packet8f& a)
+{
+  Packet8f tmp = _mm256_max_ps(a, _mm256_permute2f128_ps(a,a,1));
+  tmp = _mm256_max_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
+  return pfirst(_mm256_max_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
+}
+
+template<> EIGEN_STRONG_INLINE double predux_max<Packet4d>(const Packet4d& a)
+{
+  Packet4d tmp = _mm256_max_pd(a, _mm256_permute2f128_pd(a,a,1));
+  return pfirst(_mm256_max_pd(tmp, _mm256_shuffle_pd(tmp, tmp, 1)));
+}
+
+// not needed yet
+// template<> EIGEN_STRONG_INLINE bool predux_all(const Packet8f& x)
+// {
+//   return _mm256_movemask_ps(x)==0xFF;
+// }
+
+template<> EIGEN_STRONG_INLINE bool predux_any(const Packet8f& x)
+{
+  return _mm256_movemask_ps(x)!=0;
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8f,8>& kernel) {
+  __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+  __m256 T4 = _mm256_unpacklo_ps(kernel.packet[4], kernel.packet[5]);
+  __m256 T5 = _mm256_unpackhi_ps(kernel.packet[4], kernel.packet[5]);
+  __m256 T6 = _mm256_unpacklo_ps(kernel.packet[6], kernel.packet[7]);
+  __m256 T7 = _mm256_unpackhi_ps(kernel.packet[6], kernel.packet[7]);
+  __m256 S0 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(1,0,1,0));
+  __m256 S1 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(3,2,3,2));
+  __m256 S2 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(1,0,1,0));
+  __m256 S3 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(3,2,3,2));
+  __m256 S4 = _mm256_shuffle_ps(T4,T6,_MM_SHUFFLE(1,0,1,0));
+  __m256 S5 = _mm256_shuffle_ps(T4,T6,_MM_SHUFFLE(3,2,3,2));
+  __m256 S6 = _mm256_shuffle_ps(T5,T7,_MM_SHUFFLE(1,0,1,0));
+  __m256 S7 = _mm256_shuffle_ps(T5,T7,_MM_SHUFFLE(3,2,3,2));
+  kernel.packet[0] = _mm256_permute2f128_ps(S0, S4, 0x20);
+  kernel.packet[1] = _mm256_permute2f128_ps(S1, S5, 0x20);
+  kernel.packet[2] = _mm256_permute2f128_ps(S2, S6, 0x20);
+  kernel.packet[3] = _mm256_permute2f128_ps(S3, S7, 0x20);
+  kernel.packet[4] = _mm256_permute2f128_ps(S0, S4, 0x31);
+  kernel.packet[5] = _mm256_permute2f128_ps(S1, S5, 0x31);
+  kernel.packet[6] = _mm256_permute2f128_ps(S2, S6, 0x31);
+  kernel.packet[7] = _mm256_permute2f128_ps(S3, S7, 0x31);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8f,4>& kernel) {
+  __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+
+  __m256 S0 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(1,0,1,0));
+  __m256 S1 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(3,2,3,2));
+  __m256 S2 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(1,0,1,0));
+  __m256 S3 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(3,2,3,2));
+
+  kernel.packet[0] = _mm256_permute2f128_ps(S0, S1, 0x20);
+  kernel.packet[1] = _mm256_permute2f128_ps(S2, S3, 0x20);
+  kernel.packet[2] = _mm256_permute2f128_ps(S0, S1, 0x31);
+  kernel.packet[3] = _mm256_permute2f128_ps(S2, S3, 0x31);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4d,4>& kernel) {
+  __m256d T0 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 15);
+  __m256d T1 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 0);
+  __m256d T2 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 15);
+  __m256d T3 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 0);
+
+  kernel.packet[1] = _mm256_permute2f128_pd(T0, T2, 32);
+  kernel.packet[3] = _mm256_permute2f128_pd(T0, T2, 49);
+  kernel.packet[0] = _mm256_permute2f128_pd(T1, T3, 32);
+  kernel.packet[2] = _mm256_permute2f128_pd(T1, T3, 49);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pblend(const Selector<8>& ifPacket, const Packet8f& thenPacket, const Packet8f& elsePacket) {
+  const __m256 zero = _mm256_setzero_ps();
+  const __m256 select = _mm256_set_ps(ifPacket.select[7], ifPacket.select[6], ifPacket.select[5], ifPacket.select[4], ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m256 false_mask = _mm256_cmp_ps(select, zero, _CMP_EQ_UQ);
+  return _mm256_blendv_ps(thenPacket, elsePacket, false_mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pblend(const Selector<4>& ifPacket, const Packet4d& thenPacket, const Packet4d& elsePacket) {
+  const __m256d zero = _mm256_setzero_pd();
+  const __m256d select = _mm256_set_pd(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m256d false_mask = _mm256_cmp_pd(select, zero, _CMP_EQ_UQ);
+  return _mm256_blendv_pd(thenPacket, elsePacket, false_mask);
+}
+
+// Packet math for Eigen::half
+
+template<> struct unpacket_traits<Packet8h> { typedef Eigen::half type; enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet8h half; };
+
+template<> EIGEN_STRONG_INLINE Packet8h pset1<Packet8h>(const Eigen::half& from) {
+  return _mm_set1_epi16(numext::bit_cast<numext::uint16_t>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half pfirst<Packet8h>(const Packet8h& from) {
+  return numext::bit_cast<Eigen::half>(static_cast<numext::uint16_t>(_mm_extract_epi16(from, 0)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pload<Packet8h>(const Eigen::half* from) {
+  return _mm_load_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h ploadu<Packet8h>(const Eigen::half* from) {
+  return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet8h& from) {
+  _mm_store_si128(reinterpret_cast<__m128i*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet8h& from) {
+  _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h
+ploaddup<Packet8h>(const Eigen::half*  from) {
+  const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
+  const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
+  const numext::uint16_t c = numext::bit_cast<numext::uint16_t>(from[2]);
+  const numext::uint16_t d = numext::bit_cast<numext::uint16_t>(from[3]);
+  return _mm_set_epi16(d, d, c, c, b, b, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h
+ploadquad<Packet8h>(const Eigen::half* from) {
+  const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
+  const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
+  return _mm_set_epi16(b, b, b, b, a, a, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h ptrue(const Packet8h& a) {
+ return _mm_cmpeq_epi32(a, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h pabs(const Packet8h& a) {
+  const __m128i sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm_andnot_si128(sign_mask, a);
+}
+
+EIGEN_STRONG_INLINE Packet8f half2float(const Packet8h& a) {
+#ifdef EIGEN_HAS_FP16_C
+  return _mm256_cvtph_ps(a);
+#else
+  EIGEN_ALIGN32 Eigen::half aux[8];
+  pstore(aux, a);
+  float f0(aux[0]);
+  float f1(aux[1]);
+  float f2(aux[2]);
+  float f3(aux[3]);
+  float f4(aux[4]);
+  float f5(aux[5]);
+  float f6(aux[6]);
+  float f7(aux[7]);
+
+  return _mm256_set_ps(f7, f6, f5, f4, f3, f2, f1, f0);
+#endif
+}
+
+EIGEN_STRONG_INLINE Packet8h float2half(const Packet8f& a) {
+#ifdef EIGEN_HAS_FP16_C
+  return _mm256_cvtps_ph(a, _MM_FROUND_TO_NEAREST_INT|_MM_FROUND_NO_EXC);
+#else
+  EIGEN_ALIGN32 float aux[8];
+  pstore(aux, a);
+  const numext::uint16_t s0 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[0]));
+  const numext::uint16_t s1 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[1]));
+  const numext::uint16_t s2 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[2]));
+  const numext::uint16_t s3 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[3]));
+  const numext::uint16_t s4 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[4]));
+  const numext::uint16_t s5 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[5]));
+  const numext::uint16_t s6 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[6]));
+  const numext::uint16_t s7 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[7]));
+  return _mm_set_epi16(s7, s6, s5, s4, s3, s2, s1, s0);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h pmin<Packet8h>(const Packet8h& a,
+                                            const Packet8h& b) {
+  return float2half(pmin<Packet8f>(half2float(a), half2float(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h pmax<Packet8h>(const Packet8h& a,
+                                            const Packet8h& b) {
+  return float2half(pmax<Packet8f>(half2float(a), half2float(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h plset<Packet8h>(const half& a) {
+  return float2half(plset<Packet8f>(static_cast<float>(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h por(const Packet8h& a,const Packet8h& b) {
+  // in some cases Packet4i is a wrapper around __m128i, so we either need to
+  // cast to Packet4i to directly call the intrinsics as below:
+  return _mm_or_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8h pxor(const Packet8h& a,const Packet8h& b) {
+  return _mm_xor_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8h pand(const Packet8h& a,const Packet8h& b) {
+  return _mm_and_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8h pandnot(const Packet8h& a,const Packet8h& b) {
+  return _mm_andnot_si128(b,a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pselect(const Packet8h& mask, const Packet8h& a, const Packet8h& b) {
+  return _mm_blendv_epi8(b, a, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pround<Packet8h>(const Packet8h& a) {
+  return float2half(pround<Packet8f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h print<Packet8h>(const Packet8h& a) {
+  return float2half(print<Packet8f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pceil<Packet8h>(const Packet8h& a) {
+  return float2half(pceil<Packet8f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pfloor<Packet8h>(const Packet8h& a) {
+  return float2half(pfloor<Packet8f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pcmp_eq(const Packet8h& a,const Packet8h& b) {
+  return Pack16To8(pcmp_eq(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pcmp_le(const Packet8h& a,const Packet8h& b) {
+  return Pack16To8(pcmp_le(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pcmp_lt(const Packet8h& a,const Packet8h& b) {
+  return Pack16To8(pcmp_lt(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pcmp_lt_or_nan(const Packet8h& a,const Packet8h& b) {
+  return Pack16To8(pcmp_lt_or_nan(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pconj(const Packet8h& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet8h pnegate(const Packet8h& a) {
+  Packet8h sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm_xor_si128(a, sign_mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h padd<Packet8h>(const Packet8h& a, const Packet8h& b) {
+  Packet8f af = half2float(a);
+  Packet8f bf = half2float(b);
+  Packet8f rf = padd(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h psub<Packet8h>(const Packet8h& a, const Packet8h& b) {
+  Packet8f af = half2float(a);
+  Packet8f bf = half2float(b);
+  Packet8f rf = psub(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pmul<Packet8h>(const Packet8h& a, const Packet8h& b) {
+  Packet8f af = half2float(a);
+  Packet8f bf = half2float(b);
+  Packet8f rf = pmul(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pdiv<Packet8h>(const Packet8h& a, const Packet8h& b) {
+  Packet8f af = half2float(a);
+  Packet8f bf = half2float(b);
+  Packet8f rf = pdiv(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pgather<Eigen::half, Packet8h>(const Eigen::half* from, Index stride)
+{
+  const numext::uint16_t s0 = numext::bit_cast<numext::uint16_t>(from[0*stride]);
+  const numext::uint16_t s1 = numext::bit_cast<numext::uint16_t>(from[1*stride]);
+  const numext::uint16_t s2 = numext::bit_cast<numext::uint16_t>(from[2*stride]);
+  const numext::uint16_t s3 = numext::bit_cast<numext::uint16_t>(from[3*stride]);
+  const numext::uint16_t s4 = numext::bit_cast<numext::uint16_t>(from[4*stride]);
+  const numext::uint16_t s5 = numext::bit_cast<numext::uint16_t>(from[5*stride]);
+  const numext::uint16_t s6 = numext::bit_cast<numext::uint16_t>(from[6*stride]);
+  const numext::uint16_t s7 = numext::bit_cast<numext::uint16_t>(from[7*stride]);
+  return _mm_set_epi16(s7, s6, s5, s4, s3, s2, s1, s0);
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet8h>(Eigen::half* to, const Packet8h& from, Index stride)
+{
+  EIGEN_ALIGN32 Eigen::half aux[8];
+  pstore(aux, from);
+  to[stride*0] = aux[0];
+  to[stride*1] = aux[1];
+  to[stride*2] = aux[2];
+  to[stride*3] = aux[3];
+  to[stride*4] = aux[4];
+  to[stride*5] = aux[5];
+  to[stride*6] = aux[6];
+  to[stride*7] = aux[7];
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_max<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux_max<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_min<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux_min<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux_mul<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h preverse(const Packet8h& a)
+{
+  __m128i m = _mm_setr_epi8(14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1);
+  return _mm_shuffle_epi8(a,m);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet8h,8>& kernel) {
+  __m128i a = kernel.packet[0];
+  __m128i b = kernel.packet[1];
+  __m128i c = kernel.packet[2];
+  __m128i d = kernel.packet[3];
+  __m128i e = kernel.packet[4];
+  __m128i f = kernel.packet[5];
+  __m128i g = kernel.packet[6];
+  __m128i h = kernel.packet[7];
+
+  __m128i a03b03 = _mm_unpacklo_epi16(a, b);
+  __m128i c03d03 = _mm_unpacklo_epi16(c, d);
+  __m128i e03f03 = _mm_unpacklo_epi16(e, f);
+  __m128i g03h03 = _mm_unpacklo_epi16(g, h);
+  __m128i a47b47 = _mm_unpackhi_epi16(a, b);
+  __m128i c47d47 = _mm_unpackhi_epi16(c, d);
+  __m128i e47f47 = _mm_unpackhi_epi16(e, f);
+  __m128i g47h47 = _mm_unpackhi_epi16(g, h);
+
+  __m128i a01b01c01d01 = _mm_unpacklo_epi32(a03b03, c03d03);
+  __m128i a23b23c23d23 = _mm_unpackhi_epi32(a03b03, c03d03);
+  __m128i e01f01g01h01 = _mm_unpacklo_epi32(e03f03, g03h03);
+  __m128i e23f23g23h23 = _mm_unpackhi_epi32(e03f03, g03h03);
+  __m128i a45b45c45d45 = _mm_unpacklo_epi32(a47b47, c47d47);
+  __m128i a67b67c67d67 = _mm_unpackhi_epi32(a47b47, c47d47);
+  __m128i e45f45g45h45 = _mm_unpacklo_epi32(e47f47, g47h47);
+  __m128i e67f67g67h67 = _mm_unpackhi_epi32(e47f47, g47h47);
+
+  __m128i a0b0c0d0e0f0g0h0 = _mm_unpacklo_epi64(a01b01c01d01, e01f01g01h01);
+  __m128i a1b1c1d1e1f1g1h1 = _mm_unpackhi_epi64(a01b01c01d01, e01f01g01h01);
+  __m128i a2b2c2d2e2f2g2h2 = _mm_unpacklo_epi64(a23b23c23d23, e23f23g23h23);
+  __m128i a3b3c3d3e3f3g3h3 = _mm_unpackhi_epi64(a23b23c23d23, e23f23g23h23);
+  __m128i a4b4c4d4e4f4g4h4 = _mm_unpacklo_epi64(a45b45c45d45, e45f45g45h45);
+  __m128i a5b5c5d5e5f5g5h5 = _mm_unpackhi_epi64(a45b45c45d45, e45f45g45h45);
+  __m128i a6b6c6d6e6f6g6h6 = _mm_unpacklo_epi64(a67b67c67d67, e67f67g67h67);
+  __m128i a7b7c7d7e7f7g7h7 = _mm_unpackhi_epi64(a67b67c67d67, e67f67g67h67);
+
+  kernel.packet[0] = a0b0c0d0e0f0g0h0;
+  kernel.packet[1] = a1b1c1d1e1f1g1h1;
+  kernel.packet[2] = a2b2c2d2e2f2g2h2;
+  kernel.packet[3] = a3b3c3d3e3f3g3h3;
+  kernel.packet[4] = a4b4c4d4e4f4g4h4;
+  kernel.packet[5] = a5b5c5d5e5f5g5h5;
+  kernel.packet[6] = a6b6c6d6e6f6g6h6;
+  kernel.packet[7] = a7b7c7d7e7f7g7h7;
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet8h,4>& kernel) {
+  EIGEN_ALIGN32 Eigen::half in[4][8];
+  pstore<Eigen::half>(in[0], kernel.packet[0]);
+  pstore<Eigen::half>(in[1], kernel.packet[1]);
+  pstore<Eigen::half>(in[2], kernel.packet[2]);
+  pstore<Eigen::half>(in[3], kernel.packet[3]);
+
+  EIGEN_ALIGN32 Eigen::half out[4][8];
+
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      out[i][j] = in[j][2*i];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+4] = in[j][2*i+1];
+    }
+  }
+
+  kernel.packet[0] = pload<Packet8h>(out[0]);
+  kernel.packet[1] = pload<Packet8h>(out[1]);
+  kernel.packet[2] = pload<Packet8h>(out[2]);
+  kernel.packet[3] = pload<Packet8h>(out[3]);
+}
+
+// BFloat16 implementation.
+
+EIGEN_STRONG_INLINE Packet8f Bf16ToF32(const Packet8bf& a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  __m256i extend = _mm256_cvtepu16_epi32(a);
+  return _mm256_castsi256_ps(_mm256_slli_epi32(extend, 16));
+#else
+  __m128i lo = _mm_cvtepu16_epi32(a);
+  __m128i hi = _mm_cvtepu16_epi32(_mm_srli_si128(a, 8));
+  __m128i lo_shift = _mm_slli_epi32(lo, 16);
+  __m128i hi_shift = _mm_slli_epi32(hi, 16);
+  return _mm256_castsi256_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(lo_shift), hi_shift, 1));
+#endif
+}
+
+// Convert float to bfloat16 according to round-to-nearest-even/denormals algorithm.
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16(const Packet8f& a) {
+  Packet8bf r;
+
+  __m256i input = _mm256_castps_si256(a);
+
+#ifdef EIGEN_VECTORIZE_AVX2
+  // uint32_t lsb = (input >> 16);
+  __m256i t = _mm256_srli_epi32(input, 16);
+  // uint32_t lsb = lsb & 1;
+  t = _mm256_and_si256(t, _mm256_set1_epi32(1));
+  // uint32_t rounding_bias = 0x7fff + lsb;
+  t = _mm256_add_epi32(t, _mm256_set1_epi32(0x7fff));
+  // input += rounding_bias;
+  t = _mm256_add_epi32(t, input);
+  // input = input >> 16;
+  t = _mm256_srli_epi32(t, 16);
+  // Check NaN before converting back to bf16
+  __m256 mask = _mm256_cmp_ps(a, a, _CMP_ORD_Q);
+  __m256i nan = _mm256_set1_epi32(0x7fc0);
+  t = _mm256_blendv_epi8(nan, t, _mm256_castps_si256(mask));
+  // output = numext::bit_cast<uint16_t>(input);
+  return _mm_packus_epi32(_mm256_extractf128_si256(t, 0),
+                         _mm256_extractf128_si256(t, 1));
+#else
+  // uint32_t lsb = (input >> 16);
+  __m128i lo = _mm_srli_epi32(_mm256_extractf128_si256(input, 0), 16);
+  __m128i hi = _mm_srli_epi32(_mm256_extractf128_si256(input, 1), 16);
+  // uint32_t lsb = lsb & 1;
+  lo = _mm_and_si128(lo, _mm_set1_epi32(1));
+  hi = _mm_and_si128(hi, _mm_set1_epi32(1));
+  // uint32_t rounding_bias = 0x7fff + lsb;
+  lo = _mm_add_epi32(lo, _mm_set1_epi32(0x7fff));
+  hi = _mm_add_epi32(hi, _mm_set1_epi32(0x7fff));
+  // input += rounding_bias;
+  lo = _mm_add_epi32(lo, _mm256_extractf128_si256(input, 0));
+  hi = _mm_add_epi32(hi, _mm256_extractf128_si256(input, 1));
+  // input = input >> 16;
+  lo = _mm_srli_epi32(lo, 16);
+  hi = _mm_srli_epi32(hi, 16);
+  // Check NaN before converting back to bf16
+  __m256 mask = _mm256_cmp_ps(a, a, _CMP_ORD_Q);
+  __m128i nan = _mm_set1_epi32(0x7fc0);
+  lo = _mm_blendv_epi8(nan, lo, _mm_castps_si128(_mm256_castps256_ps128(mask)));
+  hi = _mm_blendv_epi8(nan, hi, _mm_castps_si128(_mm256_extractf128_ps(mask, 1)));
+  // output = numext::bit_cast<uint16_t>(input);
+  return _mm_packus_epi32(lo, hi);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pset1<Packet8bf>(const bfloat16& from) {
+  return _mm_set1_epi16(numext::bit_cast<numext::uint16_t>(from));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 pfirst<Packet8bf>(const Packet8bf& from) {
+  return numext::bit_cast<bfloat16>(static_cast<numext::uint16_t>(_mm_extract_epi16(from, 0)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pload<Packet8bf>(const bfloat16* from) {
+  return _mm_load_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf ploadu<Packet8bf>(const bfloat16* from) {
+  return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<bfloat16>(bfloat16* to, const Packet8bf& from) {
+  _mm_store_si128(reinterpret_cast<__m128i*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<bfloat16>(bfloat16* to, const Packet8bf& from) {
+  _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf
+ploaddup<Packet8bf>(const bfloat16* from) {
+  const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
+  const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
+  const numext::uint16_t c = numext::bit_cast<numext::uint16_t>(from[2]);
+  const numext::uint16_t d = numext::bit_cast<numext::uint16_t>(from[3]);
+  return _mm_set_epi16(d, d, c, c, b, b, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf
+ploadquad<Packet8bf>(const bfloat16* from) {
+  const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
+  const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
+  return _mm_set_epi16(b, b, b, b, a, a, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf ptrue(const Packet8bf& a) {
+ return _mm_cmpeq_epi32(a, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pabs(const Packet8bf& a) {
+  const __m128i sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm_andnot_si128(sign_mask, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pmin<Packet8bf>(const Packet8bf& a,
+                                                const Packet8bf& b) {
+  return F32ToBf16(pmin<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pmax<Packet8bf>(const Packet8bf& a,
+                                                const Packet8bf& b) {
+  return F32ToBf16(pmax<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf plset<Packet8bf>(const bfloat16& a) {
+  return F32ToBf16(plset<Packet8f>(static_cast<float>(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf por(const Packet8bf& a,const Packet8bf& b) {
+  return _mm_or_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pxor(const Packet8bf& a,const Packet8bf& b) {
+  return _mm_xor_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pand(const Packet8bf& a,const Packet8bf& b) {
+  return _mm_and_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pandnot(const Packet8bf& a,const Packet8bf& b) {
+  return _mm_andnot_si128(b,a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pselect(const Packet8bf& mask, const Packet8bf& a, const Packet8bf& b) {
+  return _mm_blendv_epi8(b, a, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pround<Packet8bf>(const Packet8bf& a)
+{
+  return F32ToBf16(pround<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf print<Packet8bf>(const Packet8bf& a) {
+  return F32ToBf16(print<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pceil<Packet8bf>(const Packet8bf& a) {
+  return F32ToBf16(pceil<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pfloor<Packet8bf>(const Packet8bf& a) {
+  return F32ToBf16(pfloor<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_eq(const Packet8bf& a,const Packet8bf& b) {
+  return Pack16To8(pcmp_eq(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_le(const Packet8bf& a,const Packet8bf& b) {
+  return Pack16To8(pcmp_le(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_lt(const Packet8bf& a,const Packet8bf& b) {
+  return Pack16To8(pcmp_lt(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_lt_or_nan(const Packet8bf& a,const Packet8bf& b) {
+  return Pack16To8(pcmp_lt_or_nan(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pconj(const Packet8bf& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet8bf pnegate(const Packet8bf& a) {
+  Packet8bf sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm_xor_si128(a, sign_mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf padd<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return F32ToBf16(padd<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf psub<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return F32ToBf16(psub<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pmul<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return F32ToBf16(pmul<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pdiv<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return F32ToBf16(pdiv<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet8bf pgather<bfloat16, Packet8bf>(const bfloat16* from, Index stride)
+{
+  const numext::uint16_t s0 = numext::bit_cast<numext::uint16_t>(from[0*stride]);
+  const numext::uint16_t s1 = numext::bit_cast<numext::uint16_t>(from[1*stride]);
+  const numext::uint16_t s2 = numext::bit_cast<numext::uint16_t>(from[2*stride]);
+  const numext::uint16_t s3 = numext::bit_cast<numext::uint16_t>(from[3*stride]);
+  const numext::uint16_t s4 = numext::bit_cast<numext::uint16_t>(from[4*stride]);
+  const numext::uint16_t s5 = numext::bit_cast<numext::uint16_t>(from[5*stride]);
+  const numext::uint16_t s6 = numext::bit_cast<numext::uint16_t>(from[6*stride]);
+  const numext::uint16_t s7 = numext::bit_cast<numext::uint16_t>(from[7*stride]);
+  return _mm_set_epi16(s7, s6, s5, s4, s3, s2, s1, s0);
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<bfloat16, Packet8bf>(bfloat16* to, const Packet8bf& from, Index stride)
+{
+  EIGEN_ALIGN32 bfloat16 aux[8];
+  pstore(aux, from);
+  to[stride*0] = aux[0];
+  to[stride*1] = aux[1];
+  to[stride*2] = aux[2];
+  to[stride*3] = aux[3];
+  to[stride*4] = aux[4];
+  to[stride*5] = aux[5];
+  to[stride*6] = aux[6];
+  to[stride*7] = aux[7];
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux<Packet8bf>(const Packet8bf& a) {
+  return static_cast<bfloat16>(predux<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_max<Packet8bf>(const Packet8bf& a) {
+  return static_cast<bfloat16>(predux_max<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_min<Packet8bf>(const Packet8bf& a) {
+  return static_cast<bfloat16>(predux_min<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_mul<Packet8bf>(const Packet8bf& a) {
+  return static_cast<bfloat16>(predux_mul<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf preverse(const Packet8bf& a)
+{
+  __m128i m = _mm_setr_epi8(14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1);
+  return _mm_shuffle_epi8(a,m);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet8bf,8>& kernel) {
+  __m128i a = kernel.packet[0];
+  __m128i b = kernel.packet[1];
+  __m128i c = kernel.packet[2];
+  __m128i d = kernel.packet[3];
+  __m128i e = kernel.packet[4];
+  __m128i f = kernel.packet[5];
+  __m128i g = kernel.packet[6];
+  __m128i h = kernel.packet[7];
+
+  __m128i a03b03 = _mm_unpacklo_epi16(a, b);
+  __m128i c03d03 = _mm_unpacklo_epi16(c, d);
+  __m128i e03f03 = _mm_unpacklo_epi16(e, f);
+  __m128i g03h03 = _mm_unpacklo_epi16(g, h);
+  __m128i a47b47 = _mm_unpackhi_epi16(a, b);
+  __m128i c47d47 = _mm_unpackhi_epi16(c, d);
+  __m128i e47f47 = _mm_unpackhi_epi16(e, f);
+  __m128i g47h47 = _mm_unpackhi_epi16(g, h);
+
+  __m128i a01b01c01d01 = _mm_unpacklo_epi32(a03b03, c03d03);
+  __m128i a23b23c23d23 = _mm_unpackhi_epi32(a03b03, c03d03);
+  __m128i e01f01g01h01 = _mm_unpacklo_epi32(e03f03, g03h03);
+  __m128i e23f23g23h23 = _mm_unpackhi_epi32(e03f03, g03h03);
+  __m128i a45b45c45d45 = _mm_unpacklo_epi32(a47b47, c47d47);
+  __m128i a67b67c67d67 = _mm_unpackhi_epi32(a47b47, c47d47);
+  __m128i e45f45g45h45 = _mm_unpacklo_epi32(e47f47, g47h47);
+  __m128i e67f67g67h67 = _mm_unpackhi_epi32(e47f47, g47h47);
+
+  kernel.packet[0] = _mm_unpacklo_epi64(a01b01c01d01, e01f01g01h01);
+  kernel.packet[1] = _mm_unpackhi_epi64(a01b01c01d01, e01f01g01h01);
+  kernel.packet[2] = _mm_unpacklo_epi64(a23b23c23d23, e23f23g23h23);
+  kernel.packet[3] = _mm_unpackhi_epi64(a23b23c23d23, e23f23g23h23);
+  kernel.packet[4] = _mm_unpacklo_epi64(a45b45c45d45, e45f45g45h45);
+  kernel.packet[5] = _mm_unpackhi_epi64(a45b45c45d45, e45f45g45h45);
+  kernel.packet[6] = _mm_unpacklo_epi64(a67b67c67d67, e67f67g67h67);
+  kernel.packet[7] = _mm_unpackhi_epi64(a67b67c67d67, e67f67g67h67);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet8bf,4>& kernel) {
+  __m128i a = kernel.packet[0];
+  __m128i b = kernel.packet[1];
+  __m128i c = kernel.packet[2];
+  __m128i d = kernel.packet[3];
+
+  __m128i ab_03 = _mm_unpacklo_epi16(a, b);
+  __m128i cd_03 = _mm_unpacklo_epi16(c, d);
+  __m128i ab_47 = _mm_unpackhi_epi16(a, b);
+  __m128i cd_47 = _mm_unpackhi_epi16(c, d);
+
+  kernel.packet[0] = _mm_unpacklo_epi32(ab_03, cd_03);
+  kernel.packet[1] = _mm_unpackhi_epi32(ab_03, cd_03);
+  kernel.packet[2] = _mm_unpacklo_epi32(ab_47, cd_47);
+  kernel.packet[3] = _mm_unpackhi_epi32(ab_47, cd_47);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_AVX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/TypeCasting.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/TypeCasting.h
new file mode 100644
index 00000000..d507fb67
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX/TypeCasting.h
@@ -0,0 +1,115 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_AVX_H
+#define EIGEN_TYPE_CASTING_AVX_H
+
+namespace Eigen {
+
+namespace internal {
+
+// For now we use SSE to handle integers, so we can't use AVX instructions to cast
+// from int to float
+template <>
+struct type_casting_traits<float, int> {
+  enum {
+    VectorizedCast = 0,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<int, float> {
+  enum {
+    VectorizedCast = 0,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+
+#ifndef EIGEN_VECTORIZE_AVX512
+
+template <>
+struct type_casting_traits<Eigen::half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+
+template <>
+struct type_casting_traits<float, Eigen::half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<bfloat16, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<float, bfloat16> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+#endif  // EIGEN_VECTORIZE_AVX512
+
+template<> EIGEN_STRONG_INLINE Packet8i pcast<Packet8f, Packet8i>(const Packet8f& a) {
+  return _mm256_cvttps_epi32(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pcast<Packet8i, Packet8f>(const Packet8i& a) {
+  return _mm256_cvtepi32_ps(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8i preinterpret<Packet8i,Packet8f>(const Packet8f& a) {
+  return _mm256_castps_si256(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f preinterpret<Packet8f,Packet8i>(const Packet8i& a) {
+  return _mm256_castsi256_ps(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pcast<Packet8h, Packet8f>(const Packet8h& a) {
+  return half2float(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pcast<Packet8bf, Packet8f>(const Packet8bf& a) {
+  return Bf16ToF32(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pcast<Packet8f, Packet8h>(const Packet8f& a) {
+  return float2half(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcast<Packet8f, Packet8bf>(const Packet8f& a) {
+  return F32ToBf16(a);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_AVX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/Complex.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/Complex.h
new file mode 100644
index 00000000..49c72b3f
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/Complex.h
@@ -0,0 +1,422 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_AVX512_H
+#define EIGEN_COMPLEX_AVX512_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- float ----------
+struct Packet8cf
+{
+  EIGEN_STRONG_INLINE Packet8cf() {}
+  EIGEN_STRONG_INLINE explicit Packet8cf(const __m512& a) : v(a) {}
+  __m512  v;
+};
+
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet8cf type;
+  typedef Packet4cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet8cf> {
+  typedef std::complex<float> type;
+  typedef Packet4cf half;
+  typedef Packet16f as_real;
+  enum {
+    size = 8,
+    alignment=unpacket_traits<Packet16f>::alignment,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet8cf ptrue<Packet8cf>(const Packet8cf& a) { return Packet8cf(ptrue(Packet16f(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet8cf padd<Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(_mm512_add_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet8cf psub<Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(_mm512_sub_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet8cf pnegate(const Packet8cf& a)
+{
+  return Packet8cf(pnegate(a.v));
+}
+template<> EIGEN_STRONG_INLINE Packet8cf pconj(const Packet8cf& a)
+{
+  const __m512 mask = _mm512_castsi512_ps(_mm512_setr_epi32(
+    0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000,
+    0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000));
+  return Packet8cf(pxor(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf pmul<Packet8cf>(const Packet8cf& a, const Packet8cf& b)
+{
+  __m512 tmp2 = _mm512_mul_ps(_mm512_movehdup_ps(a.v), _mm512_permute_ps(b.v, _MM_SHUFFLE(2,3,0,1)));
+  return Packet8cf(_mm512_fmaddsub_ps(_mm512_moveldup_ps(a.v), b.v, tmp2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf pand   <Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(pand(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet8cf por    <Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(por(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet8cf pxor   <Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(pxor(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet8cf pandnot<Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(pandnot(a.v,b.v)); }
+
+template <>
+EIGEN_STRONG_INLINE Packet8cf pcmp_eq(const Packet8cf& a, const Packet8cf& b) {
+  __m512 eq = pcmp_eq<Packet16f>(a.v, b.v);
+  return Packet8cf(pand(eq, _mm512_permute_ps(eq, 0xB1)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf pload <Packet8cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet8cf(pload<Packet16f>(&numext::real_ref(*from))); }
+template<> EIGEN_STRONG_INLINE Packet8cf ploadu<Packet8cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet8cf(ploadu<Packet16f>(&numext::real_ref(*from))); }
+
+
+template<> EIGEN_STRONG_INLINE Packet8cf pset1<Packet8cf>(const std::complex<float>& from)
+{
+  return Packet8cf(_mm512_castpd_ps(pload1<Packet8d>((const double*)(const void*)&from)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf ploaddup<Packet8cf>(const std::complex<float>* from)
+{
+  return Packet8cf( _mm512_castpd_ps( ploaddup<Packet8d>((const double*)(const void*)from )) );
+}
+template<> EIGEN_STRONG_INLINE Packet8cf ploadquad<Packet8cf>(const std::complex<float>* from)
+{
+  return Packet8cf( _mm512_castpd_ps( ploadquad<Packet8d>((const double*)(const void*)from )) );
+}
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float>* to, const Packet8cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore(&numext::real_ref(*to), from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float>* to, const Packet8cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&numext::real_ref(*to), from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet8cf pgather<std::complex<float>, Packet8cf>(const std::complex<float>* from, Index stride)
+{
+  return Packet8cf(_mm512_castpd_ps(pgather<double,Packet8d>((const double*)(const void*)from, stride)));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet8cf>(std::complex<float>* to, const Packet8cf& from, Index stride)
+{
+  pscatter((double*)(void*)to, _mm512_castps_pd(from.v), stride);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet8cf>(const Packet8cf& a)
+{
+  return pfirst(Packet2cf(_mm512_castps512_ps128(a.v)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf preverse(const Packet8cf& a) {
+  return Packet8cf(_mm512_castsi512_ps(
+            _mm512_permutexvar_epi64( _mm512_set_epi32(0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7),
+                                      _mm512_castps_si512(a.v))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet8cf>(const Packet8cf& a)
+{
+  return predux(padd(Packet4cf(extract256<0>(a.v)),
+                     Packet4cf(extract256<1>(a.v))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet8cf>(const Packet8cf& a)
+{
+  return predux_mul(pmul(Packet4cf(extract256<0>(a.v)),
+                         Packet4cf(extract256<1>(a.v))));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4cf predux_half_dowto4<Packet8cf>(const Packet8cf& a) {
+  __m256 lane0 = extract256<0>(a.v);
+  __m256 lane1 = extract256<1>(a.v);
+  __m256 res = _mm256_add_ps(lane0, lane1);
+  return Packet4cf(res);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet8cf,Packet16f)
+
+template<> EIGEN_STRONG_INLINE Packet8cf pdiv<Packet8cf>(const Packet8cf& a, const Packet8cf& b)
+{
+  Packet8cf num = pmul(a, pconj(b));
+  __m512 tmp = _mm512_mul_ps(b.v, b.v);
+  __m512 tmp2    = _mm512_shuffle_ps(tmp,tmp,0xB1);
+  __m512 denom = _mm512_add_ps(tmp, tmp2);
+  return Packet8cf(_mm512_div_ps(num.v, denom));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf pcplxflip<Packet8cf>(const Packet8cf& x)
+{
+  return Packet8cf(_mm512_shuffle_ps(x.v, x.v, _MM_SHUFFLE(2, 3, 0 ,1)));
+}
+
+//---------- double ----------
+struct Packet4cd
+{
+  EIGEN_STRONG_INLINE Packet4cd() {}
+  EIGEN_STRONG_INLINE explicit Packet4cd(const __m512d& a) : v(a) {}
+  __m512d  v;
+};
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet4cd type;
+  typedef Packet2cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet4cd> {
+  typedef std::complex<double> type;
+  typedef Packet2cd half;
+  typedef Packet8d as_real;
+  enum {
+    size = 4,
+    alignment = unpacket_traits<Packet8d>::alignment,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4cd padd<Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(_mm512_add_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd psub<Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(_mm512_sub_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd pnegate(const Packet4cd& a) { return Packet4cd(pnegate(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd pconj(const Packet4cd& a)
+{
+  const __m512d mask = _mm512_castsi512_pd(
+          _mm512_set_epi32(0x80000000,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,
+                           0x80000000,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0));
+  return Packet4cd(pxor(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd pmul<Packet4cd>(const Packet4cd& a, const Packet4cd& b)
+{
+  __m512d tmp1 = _mm512_shuffle_pd(a.v,a.v,0x0);
+  __m512d tmp2 = _mm512_shuffle_pd(a.v,a.v,0xFF);
+  __m512d tmp3 = _mm512_shuffle_pd(b.v,b.v,0x55);
+  __m512d odd  = _mm512_mul_pd(tmp2, tmp3);
+  return Packet4cd(_mm512_fmaddsub_pd(tmp1, b.v, odd));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd ptrue<Packet4cd>(const Packet4cd& a) { return Packet4cd(ptrue(Packet8d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet4cd pand   <Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(pand(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd por    <Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(por(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd pxor   <Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(pxor(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd pandnot<Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(pandnot(a.v,b.v)); }
+
+template <>
+EIGEN_STRONG_INLINE Packet4cd pcmp_eq(const Packet4cd& a, const Packet4cd& b) {
+  __m512d eq = pcmp_eq<Packet8d>(a.v, b.v);
+  return Packet4cd(pand(eq, _mm512_permute_pd(eq, 0x55)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd pload <Packet4cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet4cd(pload<Packet8d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet4cd ploadu<Packet4cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet4cd(ploadu<Packet8d>((const double*)from)); }
+
+template<> EIGEN_STRONG_INLINE Packet4cd pset1<Packet4cd>(const std::complex<double>& from)
+{
+  #ifdef EIGEN_VECTORIZE_AVX512DQ
+  return Packet4cd(_mm512_broadcast_f64x2(pset1<Packet1cd>(from).v));
+  #else
+  return Packet4cd(_mm512_castps_pd(_mm512_broadcast_f32x4( _mm_castpd_ps(pset1<Packet1cd>(from).v))));
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd ploaddup<Packet4cd>(const std::complex<double>* from) {
+  return Packet4cd(_mm512_insertf64x4(
+          _mm512_castpd256_pd512(ploaddup<Packet2cd>(from).v), ploaddup<Packet2cd>(from+1).v, 1));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet4cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet4cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet4cd pgather<std::complex<double>, Packet4cd>(const std::complex<double>* from, Index stride)
+{
+  return Packet4cd(_mm512_insertf64x4(_mm512_castpd256_pd512(
+            _mm256_insertf128_pd(_mm256_castpd128_pd256(ploadu<Packet1cd>(from+0*stride).v), ploadu<Packet1cd>(from+1*stride).v,1)),
+            _mm256_insertf128_pd(_mm256_castpd128_pd256(ploadu<Packet1cd>(from+2*stride).v), ploadu<Packet1cd>(from+3*stride).v,1), 1));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet4cd>(std::complex<double>* to, const Packet4cd& from, Index stride)
+{
+  __m512i fromi = _mm512_castpd_si512(from.v);
+  double* tod = (double*)(void*)to;
+  _mm_storeu_pd(tod+0*stride, _mm_castsi128_pd(_mm512_extracti32x4_epi32(fromi,0)) );
+  _mm_storeu_pd(tod+2*stride, _mm_castsi128_pd(_mm512_extracti32x4_epi32(fromi,1)) );
+  _mm_storeu_pd(tod+4*stride, _mm_castsi128_pd(_mm512_extracti32x4_epi32(fromi,2)) );
+  _mm_storeu_pd(tod+6*stride, _mm_castsi128_pd(_mm512_extracti32x4_epi32(fromi,3)) );
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet4cd>(const Packet4cd& a)
+{
+  __m128d low = extract128<0>(a.v);
+  EIGEN_ALIGN16 double res[2];
+  _mm_store_pd(res, low);
+  return std::complex<double>(res[0],res[1]);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd preverse(const Packet4cd& a) {
+  return Packet4cd(_mm512_shuffle_f64x2(a.v, a.v, (shuffle_mask<3,2,1,0>::mask)));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet4cd>(const Packet4cd& a)
+{
+  return predux(padd(Packet2cd(_mm512_extractf64x4_pd(a.v,0)),
+                     Packet2cd(_mm512_extractf64x4_pd(a.v,1))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet4cd>(const Packet4cd& a)
+{
+  return predux_mul(pmul(Packet2cd(_mm512_extractf64x4_pd(a.v,0)),
+                         Packet2cd(_mm512_extractf64x4_pd(a.v,1))));
+}
+
+template<> struct conj_helper<Packet4cd, Packet4cd, false,true>
+{
+  EIGEN_STRONG_INLINE Packet4cd pmadd(const Packet4cd& x, const Packet4cd& y, const Packet4cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet4cd pmul(const Packet4cd& a, const Packet4cd& b) const
+  {
+    return internal::pmul(a, pconj(b));
+  }
+};
+
+template<> struct conj_helper<Packet4cd, Packet4cd, true,false>
+{
+  EIGEN_STRONG_INLINE Packet4cd pmadd(const Packet4cd& x, const Packet4cd& y, const Packet4cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet4cd pmul(const Packet4cd& a, const Packet4cd& b) const
+  {
+    return internal::pmul(pconj(a), b);
+  }
+};
+
+template<> struct conj_helper<Packet4cd, Packet4cd, true,true>
+{
+  EIGEN_STRONG_INLINE Packet4cd pmadd(const Packet4cd& x, const Packet4cd& y, const Packet4cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet4cd pmul(const Packet4cd& a, const Packet4cd& b) const
+  {
+    return pconj(internal::pmul(a, b));
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet4cd,Packet8d)
+
+template<> EIGEN_STRONG_INLINE Packet4cd pdiv<Packet4cd>(const Packet4cd& a, const Packet4cd& b)
+{
+  Packet4cd num = pmul(a, pconj(b));
+  __m512d tmp = _mm512_mul_pd(b.v, b.v);
+  __m512d denom =  padd(_mm512_permute_pd(tmp,0x55), tmp);
+  return Packet4cd(_mm512_div_pd(num.v, denom));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd pcplxflip<Packet4cd>(const Packet4cd& x)
+{
+  return Packet4cd(_mm512_permute_pd(x.v,0x55));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8cf,4>& kernel) {
+  PacketBlock<Packet8d,4> pb;
+  
+  pb.packet[0] = _mm512_castps_pd(kernel.packet[0].v);
+  pb.packet[1] = _mm512_castps_pd(kernel.packet[1].v);
+  pb.packet[2] = _mm512_castps_pd(kernel.packet[2].v);
+  pb.packet[3] = _mm512_castps_pd(kernel.packet[3].v);
+  ptranspose(pb);
+  kernel.packet[0].v = _mm512_castpd_ps(pb.packet[0]);
+  kernel.packet[1].v = _mm512_castpd_ps(pb.packet[1]);
+  kernel.packet[2].v = _mm512_castpd_ps(pb.packet[2]);
+  kernel.packet[3].v = _mm512_castpd_ps(pb.packet[3]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8cf,8>& kernel) {
+  PacketBlock<Packet8d,8> pb;
+  
+  pb.packet[0] = _mm512_castps_pd(kernel.packet[0].v);
+  pb.packet[1] = _mm512_castps_pd(kernel.packet[1].v);
+  pb.packet[2] = _mm512_castps_pd(kernel.packet[2].v);
+  pb.packet[3] = _mm512_castps_pd(kernel.packet[3].v);
+  pb.packet[4] = _mm512_castps_pd(kernel.packet[4].v);
+  pb.packet[5] = _mm512_castps_pd(kernel.packet[5].v);
+  pb.packet[6] = _mm512_castps_pd(kernel.packet[6].v);
+  pb.packet[7] = _mm512_castps_pd(kernel.packet[7].v);
+  ptranspose(pb);
+  kernel.packet[0].v = _mm512_castpd_ps(pb.packet[0]);
+  kernel.packet[1].v = _mm512_castpd_ps(pb.packet[1]);
+  kernel.packet[2].v = _mm512_castpd_ps(pb.packet[2]);
+  kernel.packet[3].v = _mm512_castpd_ps(pb.packet[3]);
+  kernel.packet[4].v = _mm512_castpd_ps(pb.packet[4]);
+  kernel.packet[5].v = _mm512_castpd_ps(pb.packet[5]);
+  kernel.packet[6].v = _mm512_castpd_ps(pb.packet[6]);
+  kernel.packet[7].v = _mm512_castpd_ps(pb.packet[7]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4cd,4>& kernel) {
+  __m512d T0 = _mm512_shuffle_f64x2(kernel.packet[0].v, kernel.packet[1].v, (shuffle_mask<0,1,0,1>::mask)); // [a0 a1 b0 b1]
+  __m512d T1 = _mm512_shuffle_f64x2(kernel.packet[0].v, kernel.packet[1].v, (shuffle_mask<2,3,2,3>::mask)); // [a2 a3 b2 b3]
+  __m512d T2 = _mm512_shuffle_f64x2(kernel.packet[2].v, kernel.packet[3].v, (shuffle_mask<0,1,0,1>::mask)); // [c0 c1 d0 d1]
+  __m512d T3 = _mm512_shuffle_f64x2(kernel.packet[2].v, kernel.packet[3].v, (shuffle_mask<2,3,2,3>::mask)); // [c2 c3 d2 d3]
+
+  kernel.packet[3] = Packet4cd(_mm512_shuffle_f64x2(T1, T3, (shuffle_mask<1,3,1,3>::mask))); // [a3 b3 c3 d3]
+  kernel.packet[2] = Packet4cd(_mm512_shuffle_f64x2(T1, T3, (shuffle_mask<0,2,0,2>::mask))); // [a2 b2 c2 d2]
+  kernel.packet[1] = Packet4cd(_mm512_shuffle_f64x2(T0, T2, (shuffle_mask<1,3,1,3>::mask))); // [a1 b1 c1 d1]
+  kernel.packet[0] = Packet4cd(_mm512_shuffle_f64x2(T0, T2, (shuffle_mask<0,2,0,2>::mask))); // [a0 b0 c0 d0]
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd psqrt<Packet4cd>(const Packet4cd& a) {
+  return psqrt_complex<Packet4cd>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf psqrt<Packet8cf>(const Packet8cf& a) {
+  return psqrt_complex<Packet8cf>(a);
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_AVX512_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/MathFunctions.h
new file mode 100644
index 00000000..6fd726d2
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/MathFunctions.h
@@ -0,0 +1,362 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Pedro Gonnet (pedro.gonnet@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
+#define THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
+
+namespace Eigen {
+
+namespace internal {
+
+// Disable the code for older versions of gcc that don't support many of the required avx512 instrinsics.
+#if EIGEN_GNUC_AT_LEAST(5, 3) || EIGEN_COMP_CLANG  || EIGEN_COMP_MSVC >= 1923
+
+#define _EIGEN_DECLARE_CONST_Packet16f(NAME, X) \
+  const Packet16f p16f_##NAME = pset1<Packet16f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(NAME, X) \
+  const Packet16f p16f_##NAME =  preinterpret<Packet16f,Packet16i>(pset1<Packet16i>(X))
+
+#define _EIGEN_DECLARE_CONST_Packet8d(NAME, X) \
+  const Packet8d p8d_##NAME = pset1<Packet8d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet8d_FROM_INT64(NAME, X) \
+  const Packet8d p8d_##NAME = _mm512_castsi512_pd(_mm512_set1_epi64(X))
+
+#define _EIGEN_DECLARE_CONST_Packet16bf(NAME, X) \
+  const Packet16bf p16bf_##NAME = pset1<Packet16bf>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet16bf_FROM_INT(NAME, X) \
+  const Packet16bf p16bf_##NAME =  preinterpret<Packet16bf,Packet16i>(pset1<Packet16i>(X))
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+plog<Packet16f>(const Packet16f& _x) {
+  return plog_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+plog<Packet8d>(const Packet8d& _x) {
+  return plog_double(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, plog)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, plog)
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+plog2<Packet16f>(const Packet16f& _x) {
+  return plog2_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+plog2<Packet8d>(const Packet8d& _x) {
+  return plog2_double(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, plog2)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, plog2)
+
+// Exponential function. Works by writing "x = m*log(2) + r" where
+// "m = floor(x/log(2)+1/2)" and "r" is the remainder. The result is then
+// "exp(x) = 2^m*exp(r)" where exp(r) is in the range [-1,1).
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+pexp<Packet16f>(const Packet16f& _x) {
+  _EIGEN_DECLARE_CONST_Packet16f(1, 1.0f);
+  _EIGEN_DECLARE_CONST_Packet16f(half, 0.5f);
+  _EIGEN_DECLARE_CONST_Packet16f(127, 127.0f);
+
+  _EIGEN_DECLARE_CONST_Packet16f(exp_hi, 88.3762626647950f);
+  _EIGEN_DECLARE_CONST_Packet16f(exp_lo, -88.3762626647949f);
+
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_LOG2EF, 1.44269504088896341f);
+
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p0, 1.9875691500E-4f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p1, 1.3981999507E-3f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p2, 8.3334519073E-3f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p3, 4.1665795894E-2f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p4, 1.6666665459E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p5, 5.0000001201E-1f);
+
+  // Clamp x.
+  Packet16f x = pmax(pmin(_x, p16f_exp_hi), p16f_exp_lo);
+
+  // Express exp(x) as exp(m*ln(2) + r), start by extracting
+  // m = floor(x/ln(2) + 0.5).
+  Packet16f m = _mm512_floor_ps(pmadd(x, p16f_cephes_LOG2EF, p16f_half));
+
+  // Get r = x - m*ln(2). Note that we can do this without losing more than one
+  // ulp precision due to the FMA instruction.
+  _EIGEN_DECLARE_CONST_Packet16f(nln2, -0.6931471805599453f);
+  Packet16f r = _mm512_fmadd_ps(m, p16f_nln2, x);
+  Packet16f r2 = pmul(r, r);
+  Packet16f r3 = pmul(r2, r);
+
+  // Evaluate the polynomial approximant,improved by instruction-level parallelism.
+  Packet16f y, y1, y2;
+  y  = pmadd(p16f_cephes_exp_p0, r, p16f_cephes_exp_p1);
+  y1 = pmadd(p16f_cephes_exp_p3, r, p16f_cephes_exp_p4);
+  y2 = padd(r, p16f_1);
+  y  = pmadd(y, r, p16f_cephes_exp_p2);
+  y1 = pmadd(y1, r, p16f_cephes_exp_p5);
+  y  = pmadd(y, r3, y1);
+  y  = pmadd(y, r2, y2);
+
+  // Build emm0 = 2^m.
+  Packet16i emm0 = _mm512_cvttps_epi32(padd(m, p16f_127));
+  emm0 = _mm512_slli_epi32(emm0, 23);
+
+  // Return 2^m * exp(r).
+  return pmax(pmul(y, _mm512_castsi512_ps(emm0)), _x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+pexp<Packet8d>(const Packet8d& _x) {
+  return pexp_double(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, pexp)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, pexp)
+
+template <>
+EIGEN_STRONG_INLINE Packet16h pfrexp(const Packet16h& a, Packet16h& exponent) {
+  Packet16f fexponent;
+  const Packet16h out = float2half(pfrexp<Packet16f>(half2float(a), fexponent));
+  exponent = float2half(fexponent);
+  return out;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16h pldexp(const Packet16h& a, const Packet16h& exponent) {
+  return float2half(pldexp<Packet16f>(half2float(a), half2float(exponent)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pfrexp(const Packet16bf& a, Packet16bf& exponent) {
+  Packet16f fexponent;
+  const Packet16bf out = F32ToBf16(pfrexp<Packet16f>(Bf16ToF32(a), fexponent));
+  exponent = F32ToBf16(fexponent);
+  return out;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pldexp(const Packet16bf& a, const Packet16bf& exponent) {
+  return F32ToBf16(pldexp<Packet16f>(Bf16ToF32(a), Bf16ToF32(exponent)));
+}
+
+// Functions for sqrt.
+// The EIGEN_FAST_MATH version uses the _mm_rsqrt_ps approximation and one step
+// of Newton's method, at a cost of 1-2 bits of precision as opposed to the
+// exact solution. The main advantage of this approach is not just speed, but
+// also the fact that it can be inlined and pipelined with other computations,
+// further reducing its effective latency.
+#if EIGEN_FAST_MATH
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+psqrt<Packet16f>(const Packet16f& _x) {
+  Packet16f neg_half = pmul(_x, pset1<Packet16f>(-.5f));
+  __mmask16 denormal_mask = _mm512_kand(
+      _mm512_cmp_ps_mask(_x, pset1<Packet16f>((std::numeric_limits<float>::min)()),
+                        _CMP_LT_OQ),
+      _mm512_cmp_ps_mask(_x, _mm512_setzero_ps(), _CMP_GE_OQ));
+
+  Packet16f x = _mm512_rsqrt14_ps(_x);
+
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), pset1<Packet16f>(1.5f)));
+
+  // Flush results for denormals to zero.
+  return _mm512_mask_blend_ps(denormal_mask, pmul(_x,x), _mm512_setzero_ps());
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+psqrt<Packet8d>(const Packet8d& _x) {
+  Packet8d neg_half = pmul(_x, pset1<Packet8d>(-.5));
+  __mmask16 denormal_mask = _mm512_kand(
+      _mm512_cmp_pd_mask(_x, pset1<Packet8d>((std::numeric_limits<double>::min)()),
+                        _CMP_LT_OQ),
+      _mm512_cmp_pd_mask(_x, _mm512_setzero_pd(), _CMP_GE_OQ));
+
+  Packet8d x = _mm512_rsqrt14_pd(_x);
+
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), pset1<Packet8d>(1.5)));
+
+  // Do a second step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), pset1<Packet8d>(1.5)));
+
+  return _mm512_mask_blend_pd(denormal_mask, pmul(_x,x), _mm512_setzero_pd());
+}
+#else
+template <>
+EIGEN_STRONG_INLINE Packet16f psqrt<Packet16f>(const Packet16f& x) {
+  return _mm512_sqrt_ps(x);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d psqrt<Packet8d>(const Packet8d& x) {
+  return _mm512_sqrt_pd(x);
+}
+#endif
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, psqrt)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, psqrt)
+
+// prsqrt for float.
+#if defined(EIGEN_VECTORIZE_AVX512ER)
+
+template <>
+EIGEN_STRONG_INLINE Packet16f prsqrt<Packet16f>(const Packet16f& x) {
+  return _mm512_rsqrt28_ps(x);
+}
+#elif EIGEN_FAST_MATH
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+prsqrt<Packet16f>(const Packet16f& _x) {
+  _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(inf, 0x7f800000);
+  _EIGEN_DECLARE_CONST_Packet16f(one_point_five, 1.5f);
+  _EIGEN_DECLARE_CONST_Packet16f(minus_half, -0.5f);
+
+  Packet16f neg_half = pmul(_x, p16f_minus_half);
+
+  // Identity infinite, negative and denormal arguments.
+  __mmask16 inf_mask = _mm512_cmp_ps_mask(_x, p16f_inf, _CMP_EQ_OQ);
+  __mmask16 not_pos_mask = _mm512_cmp_ps_mask(_x, _mm512_setzero_ps(), _CMP_LE_OQ);
+  __mmask16 not_finite_pos_mask = not_pos_mask | inf_mask;
+
+  // Compute an approximate result using the rsqrt intrinsic, forcing +inf
+  // for denormals for consistency with AVX and SSE implementations.
+  Packet16f y_approx = _mm512_rsqrt14_ps(_x);
+
+  // Do a single step of Newton-Raphson iteration to improve the approximation.
+  // This uses the formula y_{n+1} = y_n * (1.5 - y_n * (0.5 * x) * y_n).
+  // It is essential to evaluate the inner term like this because forming
+  // y_n^2 may over- or underflow.
+  Packet16f y_newton = pmul(y_approx, pmadd(y_approx, pmul(neg_half, y_approx), p16f_one_point_five));
+
+  // Select the result of the Newton-Raphson step for positive finite arguments.
+  // For other arguments, choose the output of the intrinsic. This will
+  // return rsqrt(+inf) = 0, rsqrt(x) = NaN if x < 0, and rsqrt(0) = +inf.
+  return _mm512_mask_blend_ps(not_finite_pos_mask, y_newton, y_approx);
+}
+#else
+
+template <>
+EIGEN_STRONG_INLINE Packet16f prsqrt<Packet16f>(const Packet16f& x) {
+  _EIGEN_DECLARE_CONST_Packet16f(one, 1.0f);
+  return _mm512_div_ps(p16f_one, _mm512_sqrt_ps(x));
+}
+#endif
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, prsqrt)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, prsqrt)
+
+// prsqrt for double.
+#if EIGEN_FAST_MATH
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+prsqrt<Packet8d>(const Packet8d& _x) {
+  _EIGEN_DECLARE_CONST_Packet8d(one_point_five, 1.5);
+  _EIGEN_DECLARE_CONST_Packet8d(minus_half, -0.5);
+  _EIGEN_DECLARE_CONST_Packet8d_FROM_INT64(inf, 0x7ff0000000000000LL);
+
+  Packet8d neg_half = pmul(_x, p8d_minus_half);
+
+  // Identity infinite, negative and denormal arguments.
+  __mmask8 inf_mask = _mm512_cmp_pd_mask(_x, p8d_inf, _CMP_EQ_OQ);
+  __mmask8 not_pos_mask = _mm512_cmp_pd_mask(_x, _mm512_setzero_pd(), _CMP_LE_OQ);
+  __mmask8 not_finite_pos_mask = not_pos_mask | inf_mask;
+
+  // Compute an approximate result using the rsqrt intrinsic, forcing +inf
+  // for denormals for consistency with AVX and SSE implementations.
+#if defined(EIGEN_VECTORIZE_AVX512ER)
+  Packet8d y_approx = _mm512_rsqrt28_pd(_x);
+#else
+  Packet8d y_approx = _mm512_rsqrt14_pd(_x);
+#endif
+  // Do one or two steps of Newton-Raphson's to improve the approximation, depending on the
+  // starting accuracy (either 2^-14 or 2^-28, depending on whether AVX512ER is available).
+  // The Newton-Raphson algorithm has quadratic convergence and roughly doubles the number
+  // of correct digits for each step.
+  // This uses the formula y_{n+1} = y_n * (1.5 - y_n * (0.5 * x) * y_n).
+  // It is essential to evaluate the inner term like this because forming
+  // y_n^2 may over- or underflow.
+  Packet8d y_newton = pmul(y_approx, pmadd(neg_half, pmul(y_approx, y_approx), p8d_one_point_five));
+#if !defined(EIGEN_VECTORIZE_AVX512ER)
+  y_newton = pmul(y_newton, pmadd(y_newton, pmul(neg_half, y_newton), p8d_one_point_five));
+#endif
+  // Select the result of the Newton-Raphson step for positive finite arguments.
+  // For other arguments, choose the output of the intrinsic. This will
+  // return rsqrt(+inf) = 0, rsqrt(x) = NaN if x < 0, and rsqrt(0) = +inf.
+  return _mm512_mask_blend_pd(not_finite_pos_mask, y_newton, y_approx);
+}
+#else
+template <>
+EIGEN_STRONG_INLINE Packet8d prsqrt<Packet8d>(const Packet8d& x) {
+  _EIGEN_DECLARE_CONST_Packet8d(one, 1.0f);
+  return _mm512_div_pd(p8d_one, _mm512_sqrt_pd(x));
+}
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet16f plog1p<Packet16f>(const Packet16f& _x) {
+  return generic_plog1p(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, plog1p)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, plog1p)
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet16f pexpm1<Packet16f>(const Packet16f& _x) {
+  return generic_expm1(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, pexpm1)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, pexpm1)
+
+#endif
+
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+psin<Packet16f>(const Packet16f& _x) {
+  return psin_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+pcos<Packet16f>(const Packet16f& _x) {
+  return pcos_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+ptanh<Packet16f>(const Packet16f& _x) {
+  return internal::generic_fast_tanh_float(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, psin)
+F16_PACKET_FUNCTION(Packet16f, Packet16h, pcos)
+F16_PACKET_FUNCTION(Packet16f, Packet16h, ptanh)
+
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, psin)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, pcos)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, ptanh)
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/PacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/PacketMath.h
new file mode 100644
index 00000000..34d49ab6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -0,0 +1,2303 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner (benoit.steiner.goog@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_AVX512_H
+#define EIGEN_PACKET_MATH_AVX512_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
+#endif
+
+#ifdef EIGEN_VECTORIZE_FMA
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+#endif
+
+typedef __m512 Packet16f;
+typedef __m512i Packet16i;
+typedef __m512d Packet8d;
+typedef eigen_packet_wrapper<__m256i, 1> Packet16h;
+typedef eigen_packet_wrapper<__m256i, 2> Packet16bf;
+
+template <>
+struct is_arithmetic<__m512> {
+  enum { value = true };
+};
+template <>
+struct is_arithmetic<__m512i> {
+  enum { value = true };
+};
+template <>
+struct is_arithmetic<__m512d> {
+  enum { value = true };
+};
+
+template<> struct is_arithmetic<Packet16h> { enum { value = true }; };
+
+template <>
+struct packet_traits<half> : default_packet_traits {
+  typedef Packet16h type;
+  // There is no half-size packet for Packet16h.
+  typedef Packet16h half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+
+    HasCmp    = 1,
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 1,
+    HasAbs2   = 0,
+    HasMin    = 1,
+    HasMax    = 1,
+    HasConj   = 1,
+    HasSetLinear = 0,
+    HasLog    = 1,
+    HasLog1p  = 1,
+    HasExpm1  = 1,
+    HasExp    = 1,
+    HasSqrt   = 1,
+    HasRsqrt  = 1,
+    HasSin    = EIGEN_FAST_MATH,
+    HasCos    = EIGEN_FAST_MATH,
+    HasTanh   = EIGEN_FAST_MATH,
+    HasErf    = EIGEN_FAST_MATH,
+    HasBlend = 0,
+    HasRound  = 1,
+    HasFloor  = 1,
+    HasCeil   = 1,
+    HasRint   = 1,
+    HasBessel = 1,
+    HasNdtri  = 1
+  };
+};
+
+template<> struct packet_traits<float>  : default_packet_traits
+{
+  typedef Packet16f type;
+  typedef Packet8f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+
+    HasAbs = 1,
+    HasMin    = 1,
+    HasMax    = 1,
+    HasConj   = 1,
+    HasBlend = 0,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+#if EIGEN_GNUC_AT_LEAST(5, 3) || (!EIGEN_COMP_GNUC_STRICT)
+    HasLog = 1,
+    HasLog1p  = 1,
+    HasExpm1  = 1,
+    HasNdtri = 1,
+    HasBessel  = 1,
+    HasExp = 1,
+    HasSqrt = EIGEN_FAST_MATH,
+    HasRsqrt = EIGEN_FAST_MATH,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+#endif
+    HasCmp  = 1,
+    HasDiv = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1
+  };
+ };
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet8d type;
+  typedef Packet4d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+#if EIGEN_GNUC_AT_LEAST(5, 3) || (!EIGEN_COMP_GNUC_STRICT)
+    HasLog  = 1,
+    HasExp = 1,
+    HasSqrt = EIGEN_FAST_MATH,
+    HasRsqrt = EIGEN_FAST_MATH,
+#endif
+    HasCmp  = 1,
+    HasDiv = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1
+  };
+};
+
+/* TODO Implement AVX512 for integers
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet16i type;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=8
+  };
+};
+*/
+
+template <>
+struct unpacket_traits<Packet16f> {
+  typedef float type;
+  typedef Packet8f half;
+  typedef Packet16i integer_packet;
+  typedef uint16_t mask_t;
+  enum { size = 16, alignment=Aligned64, vectorizable=true, masked_load_available=true, masked_store_available=true };
+};
+template <>
+struct unpacket_traits<Packet8d> {
+  typedef double type;
+  typedef Packet4d half;
+  enum { size = 8, alignment=Aligned64, vectorizable=true, masked_load_available=false, masked_store_available=false };
+};
+template <>
+struct unpacket_traits<Packet16i> {
+  typedef int type;
+  typedef Packet8i half;
+  enum { size = 16, alignment=Aligned64, vectorizable=false, masked_load_available=false, masked_store_available=false };
+};
+
+template<>
+struct unpacket_traits<Packet16h> {
+  typedef Eigen::half type;
+  typedef Packet8h half;
+  enum {size=16, alignment=Aligned32, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pset1<Packet16f>(const float& from) {
+  return _mm512_set1_ps(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pset1<Packet8d>(const double& from) {
+  return _mm512_set1_pd(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pset1<Packet16i>(const int& from) {
+  return _mm512_set1_epi32(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pset1frombits<Packet16f>(unsigned int from) {
+  return _mm512_castsi512_ps(_mm512_set1_epi32(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d pset1frombits<Packet8d>(const numext::uint64_t from) {
+  return _mm512_castsi512_pd(_mm512_set1_epi64(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pzero(const Packet16f& /*a*/) { return _mm512_setzero_ps(); }
+template<> EIGEN_STRONG_INLINE Packet8d pzero(const Packet8d& /*a*/) { return _mm512_setzero_pd(); }
+template<> EIGEN_STRONG_INLINE Packet16i pzero(const Packet16i& /*a*/) { return _mm512_setzero_si512(); }
+
+template<> EIGEN_STRONG_INLINE Packet16f peven_mask(const Packet16f& /*a*/) {
+  return _mm512_castsi512_ps(_mm512_set_epi32(0, -1, 0, -1, 0, -1, 0, -1,
+                                              0, -1, 0, -1, 0, -1, 0, -1));
+}
+template<> EIGEN_STRONG_INLINE Packet16i peven_mask(const Packet16i& /*a*/) {
+  return _mm512_set_epi32(0, -1, 0, -1, 0, -1, 0, -1,
+                          0, -1, 0, -1, 0, -1, 0, -1);
+}
+template<> EIGEN_STRONG_INLINE Packet8d peven_mask(const Packet8d& /*a*/) {
+  return _mm512_castsi512_pd(_mm512_set_epi32(0, 0, -1, -1, 0, 0, -1, -1,
+                                              0, 0, -1, -1, 0, 0, -1, -1));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pload1<Packet16f>(const float* from) {
+  return _mm512_broadcastss_ps(_mm_load_ps1(from));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pload1<Packet8d>(const double* from) {
+  return _mm512_set1_pd(*from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f plset<Packet16f>(const float& a) {
+  return _mm512_add_ps(
+      _mm512_set1_ps(a),
+      _mm512_set_ps(15.0f, 14.0f, 13.0f, 12.0f, 11.0f, 10.0f, 9.0f, 8.0f, 7.0f, 6.0f, 5.0f,
+                    4.0f, 3.0f, 2.0f, 1.0f, 0.0f));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d plset<Packet8d>(const double& a) {
+  return _mm512_add_pd(_mm512_set1_pd(a),
+                       _mm512_set_pd(7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f padd<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_add_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d padd<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_add_pd(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i padd<Packet16i>(const Packet16i& a,
+                                              const Packet16i& b) {
+  return _mm512_add_epi32(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f psub<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_sub_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d psub<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_sub_pd(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i psub<Packet16i>(const Packet16i& a,
+                                              const Packet16i& b) {
+  return _mm512_sub_epi32(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pnegate(const Packet16f& a) {
+  return _mm512_sub_ps(_mm512_set1_ps(0.0), a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pnegate(const Packet8d& a) {
+  return _mm512_sub_pd(_mm512_set1_pd(0.0), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pconj(const Packet16f& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pconj(const Packet8d& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pconj(const Packet16i& a) {
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pmul<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_mul_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmul<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_mul_pd(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pmul<Packet16i>(const Packet16i& a,
+                                              const Packet16i& b) {
+  return _mm512_mullo_epi32(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pdiv<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_div_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pdiv<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_div_pd(a, b);
+}
+
+#ifdef EIGEN_VECTORIZE_FMA
+template <>
+EIGEN_STRONG_INLINE Packet16f pmadd(const Packet16f& a, const Packet16f& b,
+                                    const Packet16f& c) {
+  return _mm512_fmadd_ps(a, b, c);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmadd(const Packet8d& a, const Packet8d& b,
+                                   const Packet8d& c) {
+  return _mm512_fmadd_pd(a, b, c);
+}
+#endif
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet16f pselect(const Packet16f& mask,
+                                           const Packet16f& a,
+                                           const Packet16f& b) {
+  __mmask16 mask16 = _mm512_cmp_epi32_mask(
+      _mm512_castps_si512(mask), _mm512_setzero_epi32(), _MM_CMPINT_EQ);
+  return _mm512_mask_blend_ps(mask16, a, b);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet8d pselect(const Packet8d& mask,
+                                          const Packet8d& a,
+                                          const Packet8d& b) {
+  __mmask8 mask8 = _mm512_cmp_epi64_mask(_mm512_castpd_si512(mask),
+                                         _mm512_setzero_epi32(), _MM_CMPINT_EQ);
+  return _mm512_mask_blend_pd(mask8, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pmin<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm512_min_ps(b, a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmin<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm512_min_pd(b, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pmax<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm512_max_ps(b, a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmax<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm512_max_pd(b, a);
+}
+
+// Add specializations for min/max with prescribed NaN progation.
+template<>
+EIGEN_STRONG_INLINE Packet16f pmin<PropagateNumbers, Packet16f>(const Packet16f& a, const Packet16f& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet16f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8d pmin<PropagateNumbers, Packet8d>(const Packet8d& a, const Packet8d& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet8d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet16f pmax<PropagateNumbers, Packet16f>(const Packet16f& a, const Packet16f& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet16f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8d pmax<PropagateNumbers, Packet8d>(const Packet8d& a, const Packet8d& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet8d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet16f pmin<PropagateNaN, Packet16f>(const Packet16f& a, const Packet16f& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet16f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8d pmin<PropagateNaN, Packet8d>(const Packet8d& a, const Packet8d& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet8d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet16f pmax<PropagateNaN, Packet16f>(const Packet16f& a, const Packet16f& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet16f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8d pmax<PropagateNaN, Packet8d>(const Packet8d& a, const Packet8d& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet8d>);
+}
+
+
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+template<int I_> EIGEN_STRONG_INLINE Packet8f extract256(Packet16f x) { return _mm512_extractf32x8_ps(x,I_); }
+template<int I_> EIGEN_STRONG_INLINE Packet2d extract128(Packet8d x) { return _mm512_extractf64x2_pd(x,I_); }
+EIGEN_STRONG_INLINE Packet16f cat256(Packet8f a, Packet8f b) { return _mm512_insertf32x8(_mm512_castps256_ps512(a),b,1); }
+#else
+// AVX512F does not define _mm512_extractf32x8_ps to extract _m256 from _m512
+template<int I_> EIGEN_STRONG_INLINE Packet8f extract256(Packet16f x) {
+  return  _mm256_castsi256_ps(_mm512_extracti64x4_epi64( _mm512_castps_si512(x),I_));
+}
+
+// AVX512F does not define _mm512_extractf64x2_pd to extract _m128 from _m512
+template<int I_> EIGEN_STRONG_INLINE Packet2d extract128(Packet8d x) {
+  return _mm_castsi128_pd(_mm512_extracti32x4_epi32( _mm512_castpd_si512(x),I_));
+}
+
+EIGEN_STRONG_INLINE Packet16f cat256(Packet8f a, Packet8f b) {
+  return _mm512_castsi512_ps(_mm512_inserti64x4(_mm512_castsi256_si512(_mm256_castps_si256(a)),
+                                                _mm256_castps_si256(b),1));
+}
+#endif
+
+// Helper function for bit packing snippet of low precision comparison.
+// It packs the flags from 32x16 to 16x16.
+EIGEN_STRONG_INLINE __m256i Pack32To16(Packet16f rf) {
+  // Split data into small pieces and handle with AVX instructions
+  // to guarantee internal order of vector.
+  // Operation:
+  //   dst[15:0]    := Saturate16(rf[31:0])
+  //   dst[31:16]   := Saturate16(rf[63:32])
+  //   ...
+  //   dst[255:240] := Saturate16(rf[255:224])
+  __m256i lo = _mm256_castps_si256(extract256<0>(rf));
+  __m256i hi = _mm256_castps_si256(extract256<1>(rf));
+  __m128i result_lo = _mm_packs_epi32(_mm256_extractf128_si256(lo, 0),
+                                      _mm256_extractf128_si256(lo, 1));
+  __m128i result_hi = _mm_packs_epi32(_mm256_extractf128_si256(hi, 0),
+                                      _mm256_extractf128_si256(hi, 1));
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(result_lo), result_hi, 1);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pcmp_eq(const Packet16f& a, const Packet16f& b) {
+  __mmask16 mask = _mm512_cmp_ps_mask(a, b, _CMP_EQ_OQ);
+  return _mm512_castsi512_ps(
+      _mm512_mask_set1_epi32(_mm512_set1_epi32(0), mask, 0xffffffffu));
+}
+template<> EIGEN_STRONG_INLINE Packet16f pcmp_le(const Packet16f& a, const Packet16f& b) {
+  __mmask16 mask = _mm512_cmp_ps_mask(a, b, _CMP_LE_OQ);
+  return _mm512_castsi512_ps(
+      _mm512_mask_set1_epi32(_mm512_set1_epi32(0), mask, 0xffffffffu));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pcmp_lt(const Packet16f& a, const Packet16f& b) {
+  __mmask16 mask = _mm512_cmp_ps_mask(a, b, _CMP_LT_OQ);
+  return _mm512_castsi512_ps(
+      _mm512_mask_set1_epi32(_mm512_set1_epi32(0), mask, 0xffffffffu));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pcmp_lt_or_nan(const Packet16f& a, const Packet16f& b) {
+  __mmask16 mask = _mm512_cmp_ps_mask(a, b, _CMP_NGE_UQ);
+  return _mm512_castsi512_ps(
+      _mm512_mask_set1_epi32(_mm512_set1_epi32(0), mask, 0xffffffffu));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16i pcmp_eq(const Packet16i& a, const Packet16i& b) {
+  __mmask16 mask = _mm512_cmp_epi32_mask(a, b, _CMP_EQ_OQ);
+  return _mm512_mask_set1_epi32(_mm512_set1_epi32(0), mask, 0xffffffffu);
+}
+
+
+template <>
+EIGEN_STRONG_INLINE Packet8d pcmp_eq(const Packet8d& a, const Packet8d& b) {
+  __mmask8 mask = _mm512_cmp_pd_mask(a, b, _CMP_EQ_OQ);
+  return _mm512_castsi512_pd(
+      _mm512_mask_set1_epi64(_mm512_set1_epi64(0), mask, 0xffffffffffffffffu));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pcmp_le(const Packet8d& a, const Packet8d& b) {
+  __mmask8 mask = _mm512_cmp_pd_mask(a, b, _CMP_LE_OQ);
+  return _mm512_castsi512_pd(
+      _mm512_mask_set1_epi64(_mm512_set1_epi64(0), mask, 0xffffffffffffffffu));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pcmp_lt(const Packet8d& a, const Packet8d& b) {
+  __mmask8 mask = _mm512_cmp_pd_mask(a, b, _CMP_LT_OQ);
+  return _mm512_castsi512_pd(
+      _mm512_mask_set1_epi64(_mm512_set1_epi64(0), mask, 0xffffffffffffffffu));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pcmp_lt_or_nan(const Packet8d& a, const Packet8d& b) {
+  __mmask8 mask = _mm512_cmp_pd_mask(a, b, _CMP_NGE_UQ);
+  return _mm512_castsi512_pd(
+      _mm512_mask_set1_epi64(_mm512_set1_epi64(0), mask, 0xffffffffffffffffu));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f print<Packet16f>(const Packet16f& a) { return _mm512_roundscale_ps(a, _MM_FROUND_CUR_DIRECTION); }
+template<> EIGEN_STRONG_INLINE Packet8d print<Packet8d>(const Packet8d& a) { return _mm512_roundscale_pd(a, _MM_FROUND_CUR_DIRECTION); }
+
+template<> EIGEN_STRONG_INLINE Packet16f pceil<Packet16f>(const Packet16f& a) { return _mm512_roundscale_ps(a, _MM_FROUND_TO_POS_INF); }
+template<> EIGEN_STRONG_INLINE Packet8d pceil<Packet8d>(const Packet8d& a) { return _mm512_roundscale_pd(a, _MM_FROUND_TO_POS_INF); }
+
+template<> EIGEN_STRONG_INLINE Packet16f pfloor<Packet16f>(const Packet16f& a) { return _mm512_roundscale_ps(a, _MM_FROUND_TO_NEG_INF); }
+template<> EIGEN_STRONG_INLINE Packet8d pfloor<Packet8d>(const Packet8d& a) { return _mm512_roundscale_pd(a, _MM_FROUND_TO_NEG_INF); }
+
+template <>
+EIGEN_STRONG_INLINE Packet16i ptrue<Packet16i>(const Packet16i& /*a*/) {
+  return _mm512_set1_epi32(0xffffffffu);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f ptrue<Packet16f>(const Packet16f& a) {
+  return _mm512_castsi512_ps(ptrue<Packet16i>(_mm512_castps_si512(a)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d ptrue<Packet8d>(const Packet8d& a) {
+  return _mm512_castsi512_pd(ptrue<Packet16i>(_mm512_castpd_si512(a)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16i pand<Packet16i>(const Packet16i& a,
+                                              const Packet16i& b) {
+  return _mm512_and_si512(a,b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pand<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_and_ps(a, b);
+#else
+  return _mm512_castsi512_ps(pand(_mm512_castps_si512(a),_mm512_castps_si512(b)));
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pand<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_and_pd(a, b);
+#else
+  Packet8d res = _mm512_undefined_pd();
+  Packet4d lane0_a = _mm512_extractf64x4_pd(a, 0);
+  Packet4d lane0_b = _mm512_extractf64x4_pd(b, 0);
+  res = _mm512_insertf64x4(res, _mm256_and_pd(lane0_a, lane0_b), 0);
+
+  Packet4d lane1_a = _mm512_extractf64x4_pd(a, 1);
+  Packet4d lane1_b = _mm512_extractf64x4_pd(b, 1);
+  return _mm512_insertf64x4(res, _mm256_and_pd(lane1_a, lane1_b), 1);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16i por<Packet16i>(const Packet16i& a, const Packet16i& b) {
+  return _mm512_or_si512(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f por<Packet16f>(const Packet16f& a, const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_or_ps(a, b);
+#else
+  return _mm512_castsi512_ps(por(_mm512_castps_si512(a),_mm512_castps_si512(b)));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d por<Packet8d>(const Packet8d& a,
+                                           const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_or_pd(a, b);
+#else
+  return _mm512_castsi512_pd(por(_mm512_castpd_si512(a),_mm512_castpd_si512(b)));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16i pxor<Packet16i>(const Packet16i& a, const Packet16i& b) {
+  return _mm512_xor_si512(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pxor<Packet16f>(const Packet16f& a, const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_xor_ps(a, b);
+#else
+  return _mm512_castsi512_ps(pxor(_mm512_castps_si512(a),_mm512_castps_si512(b)));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d pxor<Packet8d>(const Packet8d& a, const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_xor_pd(a, b);
+#else
+  return _mm512_castsi512_pd(pxor(_mm512_castpd_si512(a),_mm512_castpd_si512(b)));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16i pandnot<Packet16i>(const Packet16i& a, const Packet16i& b) {
+  return _mm512_andnot_si512(b, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pandnot<Packet16f>(const Packet16f& a, const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_andnot_ps(b, a);
+#else
+  return _mm512_castsi512_ps(pandnot(_mm512_castps_si512(a),_mm512_castps_si512(b)));
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pandnot<Packet8d>(const Packet8d& a,const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_andnot_pd(b, a);
+#else
+  return _mm512_castsi512_pd(pandnot(_mm512_castpd_si512(a),_mm512_castpd_si512(b)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pround<Packet16f>(const Packet16f& a)
+{
+  // Work-around for default std::round rounding mode.
+  const Packet16f mask = pset1frombits<Packet16f>(static_cast<numext::uint32_t>(0x80000000u));
+  const Packet16f prev0dot5 = pset1frombits<Packet16f>(static_cast<numext::uint32_t>(0x3EFFFFFFu));
+  return _mm512_roundscale_ps(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+template<> EIGEN_STRONG_INLINE Packet8d pround<Packet8d>(const Packet8d& a)
+{
+  // Work-around for default std::round rounding mode.
+  const Packet8d mask = pset1frombits<Packet8d>(static_cast<numext::uint64_t>(0x8000000000000000ull));
+  const Packet8d prev0dot5 = pset1frombits<Packet8d>(static_cast<numext::uint64_t>(0x3FDFFFFFFFFFFFFFull));
+  return _mm512_roundscale_pd(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet16i parithmetic_shift_right(Packet16i a) {
+  return _mm512_srai_epi32(a, N);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet16i plogical_shift_right(Packet16i a) {
+  return _mm512_srli_epi32(a, N);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet16i plogical_shift_left(Packet16i a) {
+  return _mm512_slli_epi32(a, N);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pload<Packet16f>(const float* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_ps(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pload<Packet8d>(const double* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_pd(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pload<Packet16i>(const int* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_si512(
+      reinterpret_cast<const __m512i*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f ploadu<Packet16f>(const float* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_ps(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d ploadu<Packet8d>(const double* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_pd(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i ploadu<Packet16i>(const int* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_si512(
+      reinterpret_cast<const __m512i*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f ploadu<Packet16f>(const float* from, uint16_t umask) {
+  __mmask16 mask = static_cast<__mmask16>(umask);
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_maskz_loadu_ps(mask, from);
+}
+
+// Loads 8 floats from memory a returns the packet
+// {a0, a0  a1, a1, a2, a2, a3, a3, a4, a4, a5, a5, a6, a6, a7, a7}
+template <>
+EIGEN_STRONG_INLINE Packet16f ploaddup<Packet16f>(const float* from) {
+  // an unaligned load is required here as there is no requirement
+  // on the alignment of input pointer 'from'
+  __m256i low_half = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
+  __m512 even_elements = _mm512_castsi512_ps(_mm512_cvtepu32_epi64(low_half));
+  __m512 pairs = _mm512_permute_ps(even_elements, _MM_SHUFFLE(2, 2, 0, 0));
+  return pairs;
+}
+
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+// FIXME: this does not look optimal, better load a Packet4d and shuffle...
+// Loads 4 doubles from memory a returns the packet {a0, a0  a1, a1, a2, a2, a3,
+// a3}
+template <>
+EIGEN_STRONG_INLINE Packet8d ploaddup<Packet8d>(const double* from) {
+ __m512d x = _mm512_setzero_pd();
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[0]), 0);
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[1]), 1);
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[2]), 2);
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[3]), 3);
+  return x;
+}
+#else
+template <>
+EIGEN_STRONG_INLINE Packet8d ploaddup<Packet8d>(const double* from) {
+  __m512d x = _mm512_setzero_pd();
+  x = _mm512_mask_broadcastsd_pd(x, 0x3<<0, _mm_load_sd(from+0));
+  x = _mm512_mask_broadcastsd_pd(x, 0x3<<2, _mm_load_sd(from+1));
+  x = _mm512_mask_broadcastsd_pd(x, 0x3<<4, _mm_load_sd(from+2));
+  x = _mm512_mask_broadcastsd_pd(x, 0x3<<6, _mm_load_sd(from+3));
+  return x;
+}
+#endif
+
+// Loads 4 floats from memory a returns the packet
+// {a0, a0  a0, a0, a1, a1, a1, a1, a2, a2, a2, a2, a3, a3, a3, a3}
+template <>
+EIGEN_STRONG_INLINE Packet16f ploadquad<Packet16f>(const float* from) {
+  Packet16f tmp = _mm512_castps128_ps512(ploadu<Packet4f>(from));
+  const Packet16i scatter_mask = _mm512_set_epi32(3,3,3,3, 2,2,2,2, 1,1,1,1, 0,0,0,0);
+  return _mm512_permutexvar_ps(scatter_mask, tmp);
+}
+
+// Loads 2 doubles from memory a returns the packet
+// {a0, a0  a0, a0, a1, a1, a1, a1}
+template <>
+EIGEN_STRONG_INLINE Packet8d ploadquad<Packet8d>(const double* from) {
+  __m256d lane0 = _mm256_set1_pd(*from);
+  __m256d lane1 = _mm256_set1_pd(*(from+1));
+  __m512d tmp = _mm512_undefined_pd();
+  tmp = _mm512_insertf64x4(tmp, lane0, 0);
+  return _mm512_insertf64x4(tmp, lane1, 1);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet16f& from) {
+  EIGEN_DEBUG_ALIGNED_STORE _mm512_store_ps(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet8d& from) {
+  EIGEN_DEBUG_ALIGNED_STORE _mm512_store_pd(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore<int>(int* to, const Packet16i& from) {
+  EIGEN_DEBUG_ALIGNED_STORE _mm512_storeu_si512(reinterpret_cast<__m512i*>(to),
+                                                from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet16f& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_ps(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet8d& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_pd(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstoreu<int>(int* to, const Packet16i& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_si512(
+      reinterpret_cast<__m512i*>(to), from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet16f& from, uint16_t umask) {
+  __mmask16 mask = static_cast<__mmask16>(umask);
+  EIGEN_DEBUG_UNALIGNED_STORE return _mm512_mask_storeu_ps(to, mask, from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet16f pgather<float, Packet16f>(const float* from,
+                                                             Index stride) {
+  Packet16i stride_vector = _mm512_set1_epi32(convert_index<int>(stride));
+  Packet16i stride_multiplier =
+      _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  Packet16i indices = _mm512_mullo_epi32(stride_vector, stride_multiplier);
+
+  return _mm512_i32gather_ps(indices, from, 4);
+}
+template <>
+EIGEN_DEVICE_FUNC inline Packet8d pgather<double, Packet8d>(const double* from,
+                                                            Index stride) {
+  Packet8i stride_vector = _mm256_set1_epi32(convert_index<int>(stride));
+  Packet8i stride_multiplier = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
+  Packet8i indices = _mm256_mullo_epi32(stride_vector, stride_multiplier);
+
+  return _mm512_i32gather_pd(indices, from, 8);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<float, Packet16f>(float* to,
+                                                         const Packet16f& from,
+                                                         Index stride) {
+  Packet16i stride_vector = _mm512_set1_epi32(convert_index<int>(stride));
+  Packet16i stride_multiplier =
+      _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  Packet16i indices = _mm512_mullo_epi32(stride_vector, stride_multiplier);
+  _mm512_i32scatter_ps(to, indices, from, 4);
+}
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<double, Packet8d>(double* to,
+                                                         const Packet8d& from,
+                                                         Index stride) {
+  Packet8i stride_vector = _mm256_set1_epi32(convert_index<int>(stride));
+  Packet8i stride_multiplier = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
+  Packet8i indices = _mm256_mullo_epi32(stride_vector, stride_multiplier);
+  _mm512_i32scatter_pd(to, indices, from, 8);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore1<Packet16f>(float* to, const float& a) {
+  Packet16f pa = pset1<Packet16f>(a);
+  pstore(to, pa);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore1<Packet8d>(double* to, const double& a) {
+  Packet8d pa = pset1<Packet8d>(a);
+  pstore(to, pa);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore1<Packet16i>(int* to, const int& a) {
+  Packet16i pa = pset1<Packet16i>(a);
+  pstore(to, pa);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+
+template <>
+EIGEN_STRONG_INLINE float pfirst<Packet16f>(const Packet16f& a) {
+  return _mm_cvtss_f32(_mm512_extractf32x4_ps(a, 0));
+}
+template <>
+EIGEN_STRONG_INLINE double pfirst<Packet8d>(const Packet8d& a) {
+  return _mm_cvtsd_f64(_mm256_extractf128_pd(_mm512_extractf64x4_pd(a, 0), 0));
+}
+template <>
+EIGEN_STRONG_INLINE int pfirst<Packet16i>(const Packet16i& a) {
+  return _mm_extract_epi32(_mm512_extracti32x4_epi32(a, 0), 0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f preverse(const Packet16f& a)
+{
+  return _mm512_permutexvar_ps(_mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8d preverse(const Packet8d& a)
+{
+  return _mm512_permutexvar_pd(_mm512_set_epi32(0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pabs(const Packet16f& a)
+{
+  // _mm512_abs_ps intrinsic not found, so hack around it
+  return _mm512_castsi512_ps(_mm512_and_si512(_mm512_castps_si512(a), _mm512_set1_epi32(0x7fffffff)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pabs(const Packet8d& a) {
+  // _mm512_abs_ps intrinsic not found, so hack around it
+  return _mm512_castsi512_pd(_mm512_and_si512(_mm512_castpd_si512(a),
+                                   _mm512_set1_epi64(0x7fffffffffffffff)));
+}
+
+template<>
+EIGEN_STRONG_INLINE Packet16f pfrexp<Packet16f>(const Packet16f& a, Packet16f& exponent){
+  return pfrexp_generic(a, exponent);
+}
+
+// Extract exponent without existence of Packet8l.
+template<>
+EIGEN_STRONG_INLINE  
+Packet8d pfrexp_generic_get_biased_exponent(const Packet8d& a) {
+  const Packet8d cst_exp_mask  = pset1frombits<Packet8d>(static_cast<uint64_t>(0x7ff0000000000000ull));
+  #ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_cvtepi64_pd(_mm512_srli_epi64(_mm512_castpd_si512(pand(a, cst_exp_mask)), 52));
+  #else
+  return _mm512_cvtepi32_pd(_mm512_cvtepi64_epi32(_mm512_srli_epi64(_mm512_castpd_si512(pand(a, cst_exp_mask)), 52)));
+  #endif
+}
+
+template<>
+EIGEN_STRONG_INLINE Packet8d pfrexp<Packet8d>(const Packet8d& a, Packet8d& exponent) {
+  return pfrexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pldexp<Packet16f>(const Packet16f& a, const Packet16f& exponent) {
+  return pldexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8d pldexp<Packet8d>(const Packet8d& a, const Packet8d& exponent) {
+  // Clamp exponent to [-2099, 2099]
+  const Packet8d max_exponent = pset1<Packet8d>(2099.0);
+  const Packet8i e = _mm512_cvtpd_epi32(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
+  
+  // Split 2^e into four factors and multiply.
+  const Packet8i bias = pset1<Packet8i>(1023);
+  Packet8i b = parithmetic_shift_right<2>(e);  // floor(e/4)
+  
+  // 2^b
+  const Packet8i permute_idx = _mm256_setr_epi32(0, 4, 1, 5, 2, 6, 3, 7);
+  Packet8i hi = _mm256_permutevar8x32_epi32(padd(b, bias), permute_idx);
+  Packet8i lo = _mm256_slli_epi64(hi, 52);
+  hi = _mm256_slli_epi64(_mm256_srli_epi64(hi, 32), 52);
+  Packet8d c = _mm512_castsi512_pd(_mm512_inserti64x4(_mm512_castsi256_si512(lo), hi, 1));
+  Packet8d out = pmul(pmul(pmul(a, c), c), c);  // a * 2^(3b)
+  
+  // 2^(e - 3b)
+  b = psub(psub(psub(e, b), b), b);  // e - 3b
+  hi = _mm256_permutevar8x32_epi32(padd(b, bias), permute_idx);
+  lo = _mm256_slli_epi64(hi, 52);
+  hi = _mm256_slli_epi64(_mm256_srli_epi64(hi, 32), 52);
+  c = _mm512_castsi512_pd(_mm512_inserti64x4(_mm512_castsi256_si512(lo), hi, 1));
+  out = pmul(out, c);  // a * 2^e
+  return out;
+}
+
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+// AVX512F does not define _mm512_extractf32x8_ps to extract _m256 from _m512
+#define EIGEN_EXTRACT_8f_FROM_16f(INPUT, OUTPUT)                           \
+  __m256 OUTPUT##_0 = _mm512_extractf32x8_ps(INPUT, 0);                    \
+  __m256 OUTPUT##_1 = _mm512_extractf32x8_ps(INPUT, 1)
+#else
+#define EIGEN_EXTRACT_8f_FROM_16f(INPUT, OUTPUT)                \
+  __m256 OUTPUT##_0 = _mm256_insertf128_ps(                     \
+      _mm256_castps128_ps256(_mm512_extractf32x4_ps(INPUT, 0)), \
+      _mm512_extractf32x4_ps(INPUT, 1), 1);                     \
+  __m256 OUTPUT##_1 = _mm256_insertf128_ps(                     \
+      _mm256_castps128_ps256(_mm512_extractf32x4_ps(INPUT, 2)), \
+      _mm512_extractf32x4_ps(INPUT, 3), 1);
+#endif
+
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+#define EIGEN_INSERT_8f_INTO_16f(OUTPUT, INPUTA, INPUTB) \
+  OUTPUT = _mm512_insertf32x8(_mm512_castps256_ps512(INPUTA), INPUTB, 1);
+#else
+#define EIGEN_INSERT_8f_INTO_16f(OUTPUT, INPUTA, INPUTB)                    \
+  OUTPUT = _mm512_undefined_ps();                                           \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTA, 0), 0); \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTA, 1), 1); \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTB, 0), 2); \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTB, 1), 3);
+#endif
+
+template <>
+EIGEN_STRONG_INLINE float predux<Packet16f>(const Packet16f& a) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  __m256 lane0 = _mm512_extractf32x8_ps(a, 0);
+  __m256 lane1 = _mm512_extractf32x8_ps(a, 1);
+  Packet8f x = _mm256_add_ps(lane0, lane1);
+  return predux<Packet8f>(x);
+#else
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 sum = _mm_add_ps(_mm_add_ps(lane0, lane1), _mm_add_ps(lane2, lane3));
+  sum = _mm_hadd_ps(sum, sum);
+  sum = _mm_hadd_ps(sum, _mm_permute_ps(sum, 1));
+  return _mm_cvtss_f32(sum);
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE double predux<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d sum = _mm256_add_pd(lane0, lane1);
+  __m256d tmp0 = _mm256_hadd_pd(sum, _mm256_permute2f128_pd(sum, sum, 1));
+  return _mm_cvtsd_f64(_mm256_castpd256_pd128(_mm256_hadd_pd(tmp0, tmp0)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8f predux_half_dowto4<Packet16f>(const Packet16f& a) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  __m256 lane0 = _mm512_extractf32x8_ps(a, 0);
+  __m256 lane1 = _mm512_extractf32x8_ps(a, 1);
+  return _mm256_add_ps(lane0, lane1);
+#else
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 sum0 = _mm_add_ps(lane0, lane2);
+  __m128 sum1 = _mm_add_ps(lane1, lane3);
+  return _mm256_insertf128_ps(_mm256_castps128_ps256(sum0), sum1, 1);
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet4d predux_half_dowto4<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  return _mm256_add_pd(lane0, lane1);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_mul<Packet16f>(const Packet16f& a) {
+//#ifdef EIGEN_VECTORIZE_AVX512DQ
+#if 0
+  Packet8f lane0 = _mm512_extractf32x8_ps(a, 0);
+  Packet8f lane1 = _mm512_extractf32x8_ps(a, 1);
+  Packet8f res = pmul(lane0, lane1);
+  res = pmul(res, _mm256_permute2f128_ps(res, res, 1));
+  res = pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+#else
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 res = pmul(pmul(lane0, lane1), pmul(lane2, lane3));
+  res = pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE double predux_mul<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d res = pmul(lane0, lane1);
+  res = pmul(res, _mm256_permute2f128_pd(res, res, 1));
+  return pfirst(pmul(res, _mm256_shuffle_pd(res, res, 1)));
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_min<Packet16f>(const Packet16f& a) {
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 res = _mm_min_ps(_mm_min_ps(lane0, lane1), _mm_min_ps(lane2, lane3));
+  res = _mm_min_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(_mm_min_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+}
+template <>
+EIGEN_STRONG_INLINE double predux_min<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d res = _mm256_min_pd(lane0, lane1);
+  res = _mm256_min_pd(res, _mm256_permute2f128_pd(res, res, 1));
+  return pfirst(_mm256_min_pd(res, _mm256_shuffle_pd(res, res, 1)));
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_max<Packet16f>(const Packet16f& a) {
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 res = _mm_max_ps(_mm_max_ps(lane0, lane1), _mm_max_ps(lane2, lane3));
+  res = _mm_max_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(_mm_max_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+}
+
+template <>
+EIGEN_STRONG_INLINE double predux_max<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d res = _mm256_max_pd(lane0, lane1);
+  res = _mm256_max_pd(res, _mm256_permute2f128_pd(res, res, 1));
+  return pfirst(_mm256_max_pd(res, _mm256_shuffle_pd(res, res, 1)));
+}
+
+template<> EIGEN_STRONG_INLINE bool predux_any(const Packet16f& x)
+{
+  Packet16i xi = _mm512_castps_si512(x);
+  __mmask16 tmp = _mm512_test_epi32_mask(xi,xi);
+  return !_mm512_kortestz(tmp,tmp);
+}
+
+
+
+#define PACK_OUTPUT(OUTPUT, INPUT, INDEX, STRIDE) \
+  EIGEN_INSERT_8f_INTO_16f(OUTPUT[INDEX], INPUT[INDEX], INPUT[INDEX + STRIDE]);
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet16f, 16>& kernel) {
+  __m512 T0 = _mm512_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T1 = _mm512_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T2 = _mm512_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m512 T3 = _mm512_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+  __m512 T4 = _mm512_unpacklo_ps(kernel.packet[4], kernel.packet[5]);
+  __m512 T5 = _mm512_unpackhi_ps(kernel.packet[4], kernel.packet[5]);
+  __m512 T6 = _mm512_unpacklo_ps(kernel.packet[6], kernel.packet[7]);
+  __m512 T7 = _mm512_unpackhi_ps(kernel.packet[6], kernel.packet[7]);
+  __m512 T8 = _mm512_unpacklo_ps(kernel.packet[8], kernel.packet[9]);
+  __m512 T9 = _mm512_unpackhi_ps(kernel.packet[8], kernel.packet[9]);
+  __m512 T10 = _mm512_unpacklo_ps(kernel.packet[10], kernel.packet[11]);
+  __m512 T11 = _mm512_unpackhi_ps(kernel.packet[10], kernel.packet[11]);
+  __m512 T12 = _mm512_unpacklo_ps(kernel.packet[12], kernel.packet[13]);
+  __m512 T13 = _mm512_unpackhi_ps(kernel.packet[12], kernel.packet[13]);
+  __m512 T14 = _mm512_unpacklo_ps(kernel.packet[14], kernel.packet[15]);
+  __m512 T15 = _mm512_unpackhi_ps(kernel.packet[14], kernel.packet[15]);
+  __m512 S0 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S1 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S2 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S3 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S4 = _mm512_shuffle_ps(T4, T6, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S5 = _mm512_shuffle_ps(T4, T6, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S6 = _mm512_shuffle_ps(T5, T7, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S7 = _mm512_shuffle_ps(T5, T7, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S8 = _mm512_shuffle_ps(T8, T10, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S9 = _mm512_shuffle_ps(T8, T10, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S10 = _mm512_shuffle_ps(T9, T11, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S11 = _mm512_shuffle_ps(T9, T11, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S12 = _mm512_shuffle_ps(T12, T14, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S13 = _mm512_shuffle_ps(T12, T14, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S14 = _mm512_shuffle_ps(T13, T15, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S15 = _mm512_shuffle_ps(T13, T15, _MM_SHUFFLE(3, 2, 3, 2));
+
+  EIGEN_EXTRACT_8f_FROM_16f(S0, S0);
+  EIGEN_EXTRACT_8f_FROM_16f(S1, S1);
+  EIGEN_EXTRACT_8f_FROM_16f(S2, S2);
+  EIGEN_EXTRACT_8f_FROM_16f(S3, S3);
+  EIGEN_EXTRACT_8f_FROM_16f(S4, S4);
+  EIGEN_EXTRACT_8f_FROM_16f(S5, S5);
+  EIGEN_EXTRACT_8f_FROM_16f(S6, S6);
+  EIGEN_EXTRACT_8f_FROM_16f(S7, S7);
+  EIGEN_EXTRACT_8f_FROM_16f(S8, S8);
+  EIGEN_EXTRACT_8f_FROM_16f(S9, S9);
+  EIGEN_EXTRACT_8f_FROM_16f(S10, S10);
+  EIGEN_EXTRACT_8f_FROM_16f(S11, S11);
+  EIGEN_EXTRACT_8f_FROM_16f(S12, S12);
+  EIGEN_EXTRACT_8f_FROM_16f(S13, S13);
+  EIGEN_EXTRACT_8f_FROM_16f(S14, S14);
+  EIGEN_EXTRACT_8f_FROM_16f(S15, S15);
+
+  PacketBlock<Packet8f, 32> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_ps(S0_0, S4_0, 0x20);
+  tmp.packet[1] = _mm256_permute2f128_ps(S1_0, S5_0, 0x20);
+  tmp.packet[2] = _mm256_permute2f128_ps(S2_0, S6_0, 0x20);
+  tmp.packet[3] = _mm256_permute2f128_ps(S3_0, S7_0, 0x20);
+  tmp.packet[4] = _mm256_permute2f128_ps(S0_0, S4_0, 0x31);
+  tmp.packet[5] = _mm256_permute2f128_ps(S1_0, S5_0, 0x31);
+  tmp.packet[6] = _mm256_permute2f128_ps(S2_0, S6_0, 0x31);
+  tmp.packet[7] = _mm256_permute2f128_ps(S3_0, S7_0, 0x31);
+
+  tmp.packet[8] = _mm256_permute2f128_ps(S0_1, S4_1, 0x20);
+  tmp.packet[9] = _mm256_permute2f128_ps(S1_1, S5_1, 0x20);
+  tmp.packet[10] = _mm256_permute2f128_ps(S2_1, S6_1, 0x20);
+  tmp.packet[11] = _mm256_permute2f128_ps(S3_1, S7_1, 0x20);
+  tmp.packet[12] = _mm256_permute2f128_ps(S0_1, S4_1, 0x31);
+  tmp.packet[13] = _mm256_permute2f128_ps(S1_1, S5_1, 0x31);
+  tmp.packet[14] = _mm256_permute2f128_ps(S2_1, S6_1, 0x31);
+  tmp.packet[15] = _mm256_permute2f128_ps(S3_1, S7_1, 0x31);
+
+  // Second set of _m256 outputs
+  tmp.packet[16] = _mm256_permute2f128_ps(S8_0, S12_0, 0x20);
+  tmp.packet[17] = _mm256_permute2f128_ps(S9_0, S13_0, 0x20);
+  tmp.packet[18] = _mm256_permute2f128_ps(S10_0, S14_0, 0x20);
+  tmp.packet[19] = _mm256_permute2f128_ps(S11_0, S15_0, 0x20);
+  tmp.packet[20] = _mm256_permute2f128_ps(S8_0, S12_0, 0x31);
+  tmp.packet[21] = _mm256_permute2f128_ps(S9_0, S13_0, 0x31);
+  tmp.packet[22] = _mm256_permute2f128_ps(S10_0, S14_0, 0x31);
+  tmp.packet[23] = _mm256_permute2f128_ps(S11_0, S15_0, 0x31);
+
+  tmp.packet[24] = _mm256_permute2f128_ps(S8_1, S12_1, 0x20);
+  tmp.packet[25] = _mm256_permute2f128_ps(S9_1, S13_1, 0x20);
+  tmp.packet[26] = _mm256_permute2f128_ps(S10_1, S14_1, 0x20);
+  tmp.packet[27] = _mm256_permute2f128_ps(S11_1, S15_1, 0x20);
+  tmp.packet[28] = _mm256_permute2f128_ps(S8_1, S12_1, 0x31);
+  tmp.packet[29] = _mm256_permute2f128_ps(S9_1, S13_1, 0x31);
+  tmp.packet[30] = _mm256_permute2f128_ps(S10_1, S14_1, 0x31);
+  tmp.packet[31] = _mm256_permute2f128_ps(S11_1, S15_1, 0x31);
+
+  // Pack them into the output
+  PACK_OUTPUT(kernel.packet, tmp.packet, 0, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 1, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 2, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 3, 16);
+
+  PACK_OUTPUT(kernel.packet, tmp.packet, 4, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 5, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 6, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 7, 16);
+
+  PACK_OUTPUT(kernel.packet, tmp.packet, 8, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 9, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 10, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 11, 16);
+
+  PACK_OUTPUT(kernel.packet, tmp.packet, 12, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 13, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 14, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 15, 16);
+}
+#define PACK_OUTPUT_2(OUTPUT, INPUT, INDEX, STRIDE)         \
+  EIGEN_INSERT_8f_INTO_16f(OUTPUT[INDEX], INPUT[2 * INDEX], \
+                           INPUT[2 * INDEX + STRIDE]);
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet16f, 4>& kernel) {
+  __m512 T0 = _mm512_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T1 = _mm512_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T2 = _mm512_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m512 T3 = _mm512_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+
+  __m512 S0 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S1 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S2 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S3 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
+
+  EIGEN_EXTRACT_8f_FROM_16f(S0, S0);
+  EIGEN_EXTRACT_8f_FROM_16f(S1, S1);
+  EIGEN_EXTRACT_8f_FROM_16f(S2, S2);
+  EIGEN_EXTRACT_8f_FROM_16f(S3, S3);
+
+  PacketBlock<Packet8f, 8> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_ps(S0_0, S1_0, 0x20);
+  tmp.packet[1] = _mm256_permute2f128_ps(S2_0, S3_0, 0x20);
+  tmp.packet[2] = _mm256_permute2f128_ps(S0_0, S1_0, 0x31);
+  tmp.packet[3] = _mm256_permute2f128_ps(S2_0, S3_0, 0x31);
+
+  tmp.packet[4] = _mm256_permute2f128_ps(S0_1, S1_1, 0x20);
+  tmp.packet[5] = _mm256_permute2f128_ps(S2_1, S3_1, 0x20);
+  tmp.packet[6] = _mm256_permute2f128_ps(S0_1, S1_1, 0x31);
+  tmp.packet[7] = _mm256_permute2f128_ps(S2_1, S3_1, 0x31);
+
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 0, 1);
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 1, 1);
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 2, 1);
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 3, 1);
+}
+
+#define PACK_OUTPUT_SQ_D(OUTPUT, INPUT, INDEX, STRIDE)                \
+  OUTPUT[INDEX] = _mm512_insertf64x4(OUTPUT[INDEX], INPUT[INDEX], 0); \
+  OUTPUT[INDEX] = _mm512_insertf64x4(OUTPUT[INDEX], INPUT[INDEX + STRIDE], 1);
+
+#define PACK_OUTPUT_D(OUTPUT, INPUT, INDEX, STRIDE)                         \
+  OUTPUT[INDEX] = _mm512_insertf64x4(OUTPUT[INDEX], INPUT[(2 * INDEX)], 0); \
+  OUTPUT[INDEX] =                                                           \
+      _mm512_insertf64x4(OUTPUT[INDEX], INPUT[(2 * INDEX) + STRIDE], 1);
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8d, 4>& kernel) {
+  __m512d T0 = _mm512_shuffle_pd(kernel.packet[0], kernel.packet[1], 0);
+  __m512d T1 = _mm512_shuffle_pd(kernel.packet[0], kernel.packet[1], 0xff);
+  __m512d T2 = _mm512_shuffle_pd(kernel.packet[2], kernel.packet[3], 0);
+  __m512d T3 = _mm512_shuffle_pd(kernel.packet[2], kernel.packet[3], 0xff);
+
+  PacketBlock<Packet4d, 8> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x20);
+  tmp.packet[1] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x20);
+  tmp.packet[2] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x31);
+  tmp.packet[3] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x31);
+
+  tmp.packet[4] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x20);
+  tmp.packet[5] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x20);
+  tmp.packet[6] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x31);
+  tmp.packet[7] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x31);
+
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 0, 1);
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 1, 1);
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 2, 1);
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 3, 1);
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8d, 8>& kernel) {
+  __m512d T0 = _mm512_unpacklo_pd(kernel.packet[0], kernel.packet[1]);
+  __m512d T1 = _mm512_unpackhi_pd(kernel.packet[0], kernel.packet[1]);
+  __m512d T2 = _mm512_unpacklo_pd(kernel.packet[2], kernel.packet[3]);
+  __m512d T3 = _mm512_unpackhi_pd(kernel.packet[2], kernel.packet[3]);
+  __m512d T4 = _mm512_unpacklo_pd(kernel.packet[4], kernel.packet[5]);
+  __m512d T5 = _mm512_unpackhi_pd(kernel.packet[4], kernel.packet[5]);
+  __m512d T6 = _mm512_unpacklo_pd(kernel.packet[6], kernel.packet[7]);
+  __m512d T7 = _mm512_unpackhi_pd(kernel.packet[6], kernel.packet[7]);
+
+  PacketBlock<Packet4d, 16> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x20);
+  tmp.packet[1] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x20);
+  tmp.packet[2] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x31);
+  tmp.packet[3] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x31);
+
+  tmp.packet[4] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x20);
+  tmp.packet[5] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x20);
+  tmp.packet[6] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x31);
+  tmp.packet[7] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x31);
+
+  tmp.packet[8] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 0),
+                                         _mm512_extractf64x4_pd(T6, 0), 0x20);
+  tmp.packet[9] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 0),
+                                         _mm512_extractf64x4_pd(T7, 0), 0x20);
+  tmp.packet[10] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 0),
+                                          _mm512_extractf64x4_pd(T6, 0), 0x31);
+  tmp.packet[11] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 0),
+                                          _mm512_extractf64x4_pd(T7, 0), 0x31);
+
+  tmp.packet[12] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 1),
+                                          _mm512_extractf64x4_pd(T6, 1), 0x20);
+  tmp.packet[13] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 1),
+                                          _mm512_extractf64x4_pd(T7, 1), 0x20);
+  tmp.packet[14] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 1),
+                                          _mm512_extractf64x4_pd(T6, 1), 0x31);
+  tmp.packet[15] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 1),
+                                          _mm512_extractf64x4_pd(T7, 1), 0x31);
+
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 0, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 1, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 2, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 3, 8);
+
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 4, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 5, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 6, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 7, 8);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16f pblend(const Selector<16>& /*ifPacket*/,
+                                     const Packet16f& /*thenPacket*/,
+                                     const Packet16f& /*elsePacket*/) {
+  assert(false && "To be implemented");
+  return Packet16f();
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pblend(const Selector<8>& ifPacket,
+                                    const Packet8d& thenPacket,
+                                    const Packet8d& elsePacket) {
+  __mmask8 m = (ifPacket.select[0]   )
+             | (ifPacket.select[1]<<1)
+             | (ifPacket.select[2]<<2)
+             | (ifPacket.select[3]<<3)
+             | (ifPacket.select[4]<<4)
+             | (ifPacket.select[5]<<5)
+             | (ifPacket.select[6]<<6)
+             | (ifPacket.select[7]<<7);
+  return _mm512_mask_blend_pd(m, elsePacket, thenPacket);
+}
+
+// Packet math for Eigen::half
+template<> EIGEN_STRONG_INLINE Packet16h pset1<Packet16h>(const Eigen::half& from) {
+  return _mm256_set1_epi16(from.x);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half pfirst<Packet16h>(const Packet16h& from) {
+  return half_impl::raw_uint16_to_half(static_cast<unsigned short>(_mm256_extract_epi16(from, 0)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pload<Packet16h>(const Eigen::half* from) {
+  return _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h ploadu<Packet16h>(const Eigen::half* from) {
+  return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<half>(Eigen::half* to, const Packet16h& from) {
+  // (void*) -> workaround clang warning:
+  // cast from 'Eigen::half *' to '__m256i *' increases required alignment from 2 to 32
+  _mm256_store_si256((__m256i*)(void*)to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<half>(Eigen::half* to, const Packet16h& from) {
+  // (void*) -> workaround clang warning:
+  // cast from 'Eigen::half *' to '__m256i *' increases required alignment from 2 to 32
+  _mm256_storeu_si256((__m256i*)(void*)to, from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h
+ploaddup<Packet16h>(const Eigen::half*  from) {
+  unsigned short a = from[0].x;
+  unsigned short b = from[1].x;
+  unsigned short c = from[2].x;
+  unsigned short d = from[3].x;
+  unsigned short e = from[4].x;
+  unsigned short f = from[5].x;
+  unsigned short g = from[6].x;
+  unsigned short h = from[7].x;
+  return _mm256_set_epi16(h, h, g, g, f, f, e, e, d, d, c, c, b, b, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h
+ploadquad(const Eigen::half* from) {
+  unsigned short a = from[0].x;
+  unsigned short b = from[1].x;
+  unsigned short c = from[2].x;
+  unsigned short d = from[3].x;
+  return _mm256_set_epi16(d, d, d, d, c, c, c, c, b, b, b, b, a, a, a, a);
+}
+
+EIGEN_STRONG_INLINE Packet16f half2float(const Packet16h& a) {
+#ifdef EIGEN_HAS_FP16_C
+  return _mm512_cvtph_ps(a);
+#else
+  EIGEN_ALIGN64 half aux[16];
+  pstore(aux, a);
+  float f0(aux[0]);
+  float f1(aux[1]);
+  float f2(aux[2]);
+  float f3(aux[3]);
+  float f4(aux[4]);
+  float f5(aux[5]);
+  float f6(aux[6]);
+  float f7(aux[7]);
+  float f8(aux[8]);
+  float f9(aux[9]);
+  float fa(aux[10]);
+  float fb(aux[11]);
+  float fc(aux[12]);
+  float fd(aux[13]);
+  float fe(aux[14]);
+  float ff(aux[15]);
+
+  return _mm512_set_ps(
+      ff, fe, fd, fc, fb, fa, f9, f8, f7, f6, f5, f4, f3, f2, f1, f0);
+#endif
+}
+
+EIGEN_STRONG_INLINE Packet16h float2half(const Packet16f& a) {
+#ifdef EIGEN_HAS_FP16_C
+  return _mm512_cvtps_ph(a, _MM_FROUND_TO_NEAREST_INT|_MM_FROUND_NO_EXC);
+#else
+  EIGEN_ALIGN64 float aux[16];
+  pstore(aux, a);
+  half h0(aux[0]);
+  half h1(aux[1]);
+  half h2(aux[2]);
+  half h3(aux[3]);
+  half h4(aux[4]);
+  half h5(aux[5]);
+  half h6(aux[6]);
+  half h7(aux[7]);
+  half h8(aux[8]);
+  half h9(aux[9]);
+  half ha(aux[10]);
+  half hb(aux[11]);
+  half hc(aux[12]);
+  half hd(aux[13]);
+  half he(aux[14]);
+  half hf(aux[15]);
+
+  return _mm256_set_epi16(
+      hf.x, he.x, hd.x, hc.x, hb.x, ha.x, h9.x, h8.x,
+      h7.x, h6.x, h5.x, h4.x, h3.x, h2.x, h1.x, h0.x);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h ptrue(const Packet16h& a) {
+  return ptrue(Packet8i(a));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16h pabs(const Packet16h& a) {
+  const __m256i sign_mask = _mm256_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm256_andnot_si256(sign_mask, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16h pmin<Packet16h>(const Packet16h& a,
+                                              const Packet16h& b) {
+  return float2half(pmin<Packet16f>(half2float(a), half2float(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16h pmax<Packet16h>(const Packet16h& a,
+                                              const Packet16h& b) {
+  return float2half(pmax<Packet16f>(half2float(a), half2float(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16h plset<Packet16h>(const half& a) {
+  return float2half(plset<Packet16f>(static_cast<float>(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h por(const Packet16h& a,const Packet16h& b) {
+  // in some cases Packet8i is a wrapper around __m256i, so we need to
+  // cast to Packet8i to call the correct overload.
+  return por(Packet8i(a),Packet8i(b));
+}
+template<> EIGEN_STRONG_INLINE Packet16h pxor(const Packet16h& a,const Packet16h& b) {
+  return pxor(Packet8i(a),Packet8i(b));
+}
+template<> EIGEN_STRONG_INLINE Packet16h pand(const Packet16h& a,const Packet16h& b) {
+  return pand(Packet8i(a),Packet8i(b));
+}
+template<> EIGEN_STRONG_INLINE Packet16h pandnot(const Packet16h& a,const Packet16h& b) {
+  return pandnot(Packet8i(a),Packet8i(b));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pselect(const Packet16h& mask, const Packet16h& a, const Packet16h& b) {
+  return _mm256_blendv_epi8(b, a, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pround<Packet16h>(const Packet16h& a) {
+  return float2half(pround<Packet16f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h print<Packet16h>(const Packet16h& a) {
+  return float2half(print<Packet16f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pceil<Packet16h>(const Packet16h& a) {
+  return float2half(pceil<Packet16f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pfloor<Packet16h>(const Packet16h& a) {
+  return float2half(pfloor<Packet16f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pcmp_eq(const Packet16h& a,const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  return Pack32To16(pcmp_eq(af, bf));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pcmp_le(const Packet16h& a,const Packet16h& b) {
+  return Pack32To16(pcmp_le(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pcmp_lt(const Packet16h& a,const Packet16h& b) {
+  return Pack32To16(pcmp_lt(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pcmp_lt_or_nan(const Packet16h& a,const Packet16h& b) {
+  return Pack32To16(pcmp_lt_or_nan(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pconj(const Packet16h& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet16h pnegate(const Packet16h& a) {
+  Packet16h sign_mask = _mm256_set1_epi16(static_cast<unsigned short>(0x8000));
+  return _mm256_xor_si256(a, sign_mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h padd<Packet16h>(const Packet16h& a, const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  Packet16f rf = padd(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h psub<Packet16h>(const Packet16h& a, const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  Packet16f rf = psub(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pmul<Packet16h>(const Packet16h& a, const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  Packet16f rf = pmul(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pdiv<Packet16h>(const Packet16h& a, const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  Packet16f rf = pdiv(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE half predux<Packet16h>(const Packet16h& from) {
+  Packet16f from_float = half2float(from);
+  return half(predux(from_float));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h predux_half_dowto4<Packet16h>(const Packet16h& a) {
+  Packet8h lane0 = _mm256_extractf128_si256(a, 0);
+  Packet8h lane1 = _mm256_extractf128_si256(a, 1);
+  return padd<Packet8h>(lane0, lane1);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_max<Packet16h>(const Packet16h& a) {
+  Packet16f af = half2float(a);
+  float reduced = predux_max<Packet16f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_min<Packet16h>(const Packet16h& a) {
+  Packet16f af = half2float(a);
+  float reduced = predux_min<Packet16f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE half predux_mul<Packet16h>(const Packet16h& from) {
+  Packet16f from_float = half2float(from);
+  return half(predux_mul(from_float));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h preverse(const Packet16h& a)
+{
+  __m128i m = _mm_setr_epi8(14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1);
+  return _mm256_insertf128_si256(
+                    _mm256_castsi128_si256(_mm_shuffle_epi8(_mm256_extractf128_si256(a,1),m)),
+                                           _mm_shuffle_epi8(_mm256_extractf128_si256(a,0),m), 1);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pgather<Eigen::half, Packet16h>(const Eigen::half* from, Index stride)
+{
+  return _mm256_set_epi16(
+      from[15*stride].x, from[14*stride].x, from[13*stride].x, from[12*stride].x,
+      from[11*stride].x, from[10*stride].x, from[9*stride].x, from[8*stride].x,
+      from[7*stride].x, from[6*stride].x, from[5*stride].x, from[4*stride].x,
+      from[3*stride].x, from[2*stride].x, from[1*stride].x, from[0*stride].x);
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<half, Packet16h>(half* to, const Packet16h& from, Index stride)
+{
+  EIGEN_ALIGN64 half aux[16];
+  pstore(aux, from);
+  to[stride*0] = aux[0];
+  to[stride*1] = aux[1];
+  to[stride*2] = aux[2];
+  to[stride*3] = aux[3];
+  to[stride*4] = aux[4];
+  to[stride*5] = aux[5];
+  to[stride*6] = aux[6];
+  to[stride*7] = aux[7];
+  to[stride*8] = aux[8];
+  to[stride*9] = aux[9];
+  to[stride*10] = aux[10];
+  to[stride*11] = aux[11];
+  to[stride*12] = aux[12];
+  to[stride*13] = aux[13];
+  to[stride*14] = aux[14];
+  to[stride*15] = aux[15];
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet16h,16>& kernel) {
+  __m256i a = kernel.packet[0];
+  __m256i b = kernel.packet[1];
+  __m256i c = kernel.packet[2];
+  __m256i d = kernel.packet[3];
+  __m256i e = kernel.packet[4];
+  __m256i f = kernel.packet[5];
+  __m256i g = kernel.packet[6];
+  __m256i h = kernel.packet[7];
+  __m256i i = kernel.packet[8];
+  __m256i j = kernel.packet[9];
+  __m256i k = kernel.packet[10];
+  __m256i l = kernel.packet[11];
+  __m256i m = kernel.packet[12];
+  __m256i n = kernel.packet[13];
+  __m256i o = kernel.packet[14];
+  __m256i p = kernel.packet[15];
+
+  __m256i ab_07 = _mm256_unpacklo_epi16(a, b);
+  __m256i cd_07 = _mm256_unpacklo_epi16(c, d);
+  __m256i ef_07 = _mm256_unpacklo_epi16(e, f);
+  __m256i gh_07 = _mm256_unpacklo_epi16(g, h);
+  __m256i ij_07 = _mm256_unpacklo_epi16(i, j);
+  __m256i kl_07 = _mm256_unpacklo_epi16(k, l);
+  __m256i mn_07 = _mm256_unpacklo_epi16(m, n);
+  __m256i op_07 = _mm256_unpacklo_epi16(o, p);
+
+  __m256i ab_8f = _mm256_unpackhi_epi16(a, b);
+  __m256i cd_8f = _mm256_unpackhi_epi16(c, d);
+  __m256i ef_8f = _mm256_unpackhi_epi16(e, f);
+  __m256i gh_8f = _mm256_unpackhi_epi16(g, h);
+  __m256i ij_8f = _mm256_unpackhi_epi16(i, j);
+  __m256i kl_8f = _mm256_unpackhi_epi16(k, l);
+  __m256i mn_8f = _mm256_unpackhi_epi16(m, n);
+  __m256i op_8f = _mm256_unpackhi_epi16(o, p);
+
+  __m256i abcd_03 = _mm256_unpacklo_epi32(ab_07, cd_07);
+  __m256i abcd_47 = _mm256_unpackhi_epi32(ab_07, cd_07);
+  __m256i efgh_03 = _mm256_unpacklo_epi32(ef_07, gh_07);
+  __m256i efgh_47 = _mm256_unpackhi_epi32(ef_07, gh_07);
+  __m256i ijkl_03 = _mm256_unpacklo_epi32(ij_07, kl_07);
+  __m256i ijkl_47 = _mm256_unpackhi_epi32(ij_07, kl_07);
+  __m256i mnop_03 = _mm256_unpacklo_epi32(mn_07, op_07);
+  __m256i mnop_47 = _mm256_unpackhi_epi32(mn_07, op_07);
+
+  __m256i abcd_8b = _mm256_unpacklo_epi32(ab_8f, cd_8f);
+  __m256i abcd_cf = _mm256_unpackhi_epi32(ab_8f, cd_8f);
+  __m256i efgh_8b = _mm256_unpacklo_epi32(ef_8f, gh_8f);
+  __m256i efgh_cf = _mm256_unpackhi_epi32(ef_8f, gh_8f);
+  __m256i ijkl_8b = _mm256_unpacklo_epi32(ij_8f, kl_8f);
+  __m256i ijkl_cf = _mm256_unpackhi_epi32(ij_8f, kl_8f);
+  __m256i mnop_8b = _mm256_unpacklo_epi32(mn_8f, op_8f);
+  __m256i mnop_cf = _mm256_unpackhi_epi32(mn_8f, op_8f);
+
+  __m256i abcdefgh_01 = _mm256_unpacklo_epi64(abcd_03, efgh_03);
+  __m256i abcdefgh_23 = _mm256_unpackhi_epi64(abcd_03, efgh_03);
+  __m256i ijklmnop_01 = _mm256_unpacklo_epi64(ijkl_03, mnop_03);
+  __m256i ijklmnop_23 = _mm256_unpackhi_epi64(ijkl_03, mnop_03);
+  __m256i abcdefgh_45 = _mm256_unpacklo_epi64(abcd_47, efgh_47);
+  __m256i abcdefgh_67 = _mm256_unpackhi_epi64(abcd_47, efgh_47);
+  __m256i ijklmnop_45 = _mm256_unpacklo_epi64(ijkl_47, mnop_47);
+  __m256i ijklmnop_67 = _mm256_unpackhi_epi64(ijkl_47, mnop_47);
+  __m256i abcdefgh_89 = _mm256_unpacklo_epi64(abcd_8b, efgh_8b);
+  __m256i abcdefgh_ab = _mm256_unpackhi_epi64(abcd_8b, efgh_8b);
+  __m256i ijklmnop_89 = _mm256_unpacklo_epi64(ijkl_8b, mnop_8b);
+  __m256i ijklmnop_ab = _mm256_unpackhi_epi64(ijkl_8b, mnop_8b);
+  __m256i abcdefgh_cd = _mm256_unpacklo_epi64(abcd_cf, efgh_cf);
+  __m256i abcdefgh_ef = _mm256_unpackhi_epi64(abcd_cf, efgh_cf);
+  __m256i ijklmnop_cd = _mm256_unpacklo_epi64(ijkl_cf, mnop_cf);
+  __m256i ijklmnop_ef = _mm256_unpackhi_epi64(ijkl_cf, mnop_cf);
+
+  // NOTE: no unpacklo/hi instr in this case, so using permute instr.
+  __m256i a_p_0 = _mm256_permute2x128_si256(abcdefgh_01, ijklmnop_01, 0x20);
+  __m256i a_p_1 = _mm256_permute2x128_si256(abcdefgh_23, ijklmnop_23, 0x20);
+  __m256i a_p_2 = _mm256_permute2x128_si256(abcdefgh_45, ijklmnop_45, 0x20);
+  __m256i a_p_3 = _mm256_permute2x128_si256(abcdefgh_67, ijklmnop_67, 0x20);
+  __m256i a_p_4 = _mm256_permute2x128_si256(abcdefgh_89, ijklmnop_89, 0x20);
+  __m256i a_p_5 = _mm256_permute2x128_si256(abcdefgh_ab, ijklmnop_ab, 0x20);
+  __m256i a_p_6 = _mm256_permute2x128_si256(abcdefgh_cd, ijklmnop_cd, 0x20);
+  __m256i a_p_7 = _mm256_permute2x128_si256(abcdefgh_ef, ijklmnop_ef, 0x20);
+  __m256i a_p_8 = _mm256_permute2x128_si256(abcdefgh_01, ijklmnop_01, 0x31);
+  __m256i a_p_9 = _mm256_permute2x128_si256(abcdefgh_23, ijklmnop_23, 0x31);
+  __m256i a_p_a = _mm256_permute2x128_si256(abcdefgh_45, ijklmnop_45, 0x31);
+  __m256i a_p_b = _mm256_permute2x128_si256(abcdefgh_67, ijklmnop_67, 0x31);
+  __m256i a_p_c = _mm256_permute2x128_si256(abcdefgh_89, ijklmnop_89, 0x31);
+  __m256i a_p_d = _mm256_permute2x128_si256(abcdefgh_ab, ijklmnop_ab, 0x31);
+  __m256i a_p_e = _mm256_permute2x128_si256(abcdefgh_cd, ijklmnop_cd, 0x31);
+  __m256i a_p_f = _mm256_permute2x128_si256(abcdefgh_ef, ijklmnop_ef, 0x31);
+
+  kernel.packet[0] = a_p_0;
+  kernel.packet[1] = a_p_1;
+  kernel.packet[2] = a_p_2;
+  kernel.packet[3] = a_p_3;
+  kernel.packet[4] = a_p_4;
+  kernel.packet[5] = a_p_5;
+  kernel.packet[6] = a_p_6;
+  kernel.packet[7] = a_p_7;
+  kernel.packet[8] = a_p_8;
+  kernel.packet[9] = a_p_9;
+  kernel.packet[10] = a_p_a;
+  kernel.packet[11] = a_p_b;
+  kernel.packet[12] = a_p_c;
+  kernel.packet[13] = a_p_d;
+  kernel.packet[14] = a_p_e;
+  kernel.packet[15] = a_p_f;
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet16h,8>& kernel) {
+  EIGEN_ALIGN64 half in[8][16];
+  pstore<half>(in[0], kernel.packet[0]);
+  pstore<half>(in[1], kernel.packet[1]);
+  pstore<half>(in[2], kernel.packet[2]);
+  pstore<half>(in[3], kernel.packet[3]);
+  pstore<half>(in[4], kernel.packet[4]);
+  pstore<half>(in[5], kernel.packet[5]);
+  pstore<half>(in[6], kernel.packet[6]);
+  pstore<half>(in[7], kernel.packet[7]);
+
+  EIGEN_ALIGN64 half out[8][16];
+
+  for (int i = 0; i < 8; ++i) {
+    for (int j = 0; j < 8; ++j) {
+      out[i][j] = in[j][2*i];
+    }
+    for (int j = 0; j < 8; ++j) {
+      out[i][j+8] = in[j][2*i+1];
+    }
+  }
+
+  kernel.packet[0] = pload<Packet16h>(out[0]);
+  kernel.packet[1] = pload<Packet16h>(out[1]);
+  kernel.packet[2] = pload<Packet16h>(out[2]);
+  kernel.packet[3] = pload<Packet16h>(out[3]);
+  kernel.packet[4] = pload<Packet16h>(out[4]);
+  kernel.packet[5] = pload<Packet16h>(out[5]);
+  kernel.packet[6] = pload<Packet16h>(out[6]);
+  kernel.packet[7] = pload<Packet16h>(out[7]);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet16h,4>& kernel) {
+  EIGEN_ALIGN64 half in[4][16];
+  pstore<half>(in[0], kernel.packet[0]);
+  pstore<half>(in[1], kernel.packet[1]);
+  pstore<half>(in[2], kernel.packet[2]);
+  pstore<half>(in[3], kernel.packet[3]);
+
+  EIGEN_ALIGN64 half out[4][16];
+
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      out[i][j] = in[j][4*i];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+4] = in[j][4*i+1];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+8] = in[j][4*i+2];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+12] = in[j][4*i+3];
+    }
+  }
+
+  kernel.packet[0] = pload<Packet16h>(out[0]);
+  kernel.packet[1] = pload<Packet16h>(out[1]);
+  kernel.packet[2] = pload<Packet16h>(out[2]);
+  kernel.packet[3] = pload<Packet16h>(out[3]);
+}
+
+template <> struct is_arithmetic<Packet16bf> { enum { value = true }; };
+
+template <>
+struct packet_traits<bfloat16> : default_packet_traits {
+  typedef Packet16bf type;
+  typedef Packet8bf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+    HasBlend = 0,
+    HasInsert = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+#if EIGEN_GNUC_AT_LEAST(5, 3) || (!EIGEN_COMP_GNUC_STRICT)
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+    HasLog = 1,  // Currently fails test with bad accuracy.
+    HasLog1p  = 1,
+    HasExpm1  = 1,
+    HasNdtri = 1,
+    HasBessel  = 1,
+#endif
+    HasExp = 1,
+    HasSqrt = EIGEN_FAST_MATH,
+    HasRsqrt = EIGEN_FAST_MATH,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+#endif
+    HasCmp  = 1,
+    HasDiv = 1
+  };
+};
+
+template <>
+struct unpacket_traits<Packet16bf>
+{
+  typedef bfloat16 type;
+  enum {size=16, alignment=Aligned32, vectorizable=true, masked_load_available=false, masked_store_available=false};
+  typedef Packet8bf half;
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pset1<Packet16bf>(const bfloat16& from) {
+  return _mm256_set1_epi16(from.value);
+}
+
+template <>
+EIGEN_STRONG_INLINE bfloat16 pfirst<Packet16bf>(const Packet16bf& from) {
+  bfloat16 t;
+  t.value = static_cast<unsigned short>(_mm256_extract_epi16(from, 0));
+  return t;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pload<Packet16bf>(const bfloat16* from) {
+  return _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf ploadu<Packet16bf>(const bfloat16* from) {
+  return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<bfloat16>(bfloat16* to,
+                                          const Packet16bf& from) {
+  _mm256_store_si256(reinterpret_cast<__m256i*>(to), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<bfloat16>(bfloat16* to,
+                                           const Packet16bf& from) {
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf
+ploaddup<Packet16bf>(const bfloat16* from) {
+  Packet16bf r;
+  unsigned short a = from[0].value;
+  unsigned short b = from[1].value;
+  unsigned short c = from[2].value;
+  unsigned short d = from[3].value;
+  unsigned short e = from[4].value;
+  unsigned short f = from[5].value;
+  unsigned short g = from[6].value;
+  unsigned short h = from[7].value;
+  return _mm256_set_epi16(h, h, g, g, f, f, e, e, d, d, c, c, b, b, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf
+ploadquad(const bfloat16* from) {
+  Packet16bf r;
+  unsigned short a = from[0].value;
+  unsigned short b = from[1].value;
+  unsigned short c = from[2].value;
+  unsigned short d = from[3].value;
+  return _mm256_set_epi16(d, d, d, d, c, c, c, c, b, b, b, b, a, a, a, a);
+}
+
+EIGEN_STRONG_INLINE Packet16f Bf16ToF32(const Packet16bf& a) {
+  return _mm512_castsi512_ps(_mm512_slli_epi32(_mm512_cvtepu16_epi32(a), 16));
+}
+
+// Convert float to bfloat16 according to round-to-nearest-even/denormals algorithm.
+EIGEN_STRONG_INLINE Packet16bf F32ToBf16(const Packet16f& a) {
+  Packet16bf r;
+
+#if defined(EIGEN_VECTORIZE_AVX512BF16) && EIGEN_GNUC_AT_LEAST(10, 1)
+  // Since GCC 10.1 supports avx512bf16 and C style explicit cast
+  // (C++ static_cast is not supported yet), do converion via intrinsic
+  // and register path for performance.
+  r = (__m256i)(_mm512_cvtneps_pbh(a));
+
+#else
+  __m512i t;
+  __m512i input = _mm512_castps_si512(a);
+  __m512i nan = _mm512_set1_epi32(0x7fc0);
+
+  // uint32_t lsb = (input >> 16) & 1;
+  t = _mm512_and_si512(_mm512_srli_epi32(input, 16), _mm512_set1_epi32(1));
+  // uint32_t rounding_bias = 0x7fff + lsb;
+  t = _mm512_add_epi32(t, _mm512_set1_epi32(0x7fff));
+  // input += rounding_bias;
+  t = _mm512_add_epi32(t, input);
+  // input = input >> 16;
+  t = _mm512_srli_epi32(t, 16);
+
+  // Check NaN before converting back to bf16
+  __mmask16 mask = _mm512_cmp_ps_mask(a, a, _CMP_ORD_Q);
+
+  t = _mm512_mask_blend_epi32(mask, nan, t);
+  // output.value = static_cast<uint16_t>(input);
+  r = _mm512_cvtepi32_epi16(t);
+#endif // EIGEN_VECTORIZE_AVX512BF16
+
+  return r;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf ptrue(const Packet16bf& a) {
+  return ptrue<Packet8i>(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf por(const Packet16bf& a, const Packet16bf& b) {
+  return por<Packet8i>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pxor(const Packet16bf& a, const Packet16bf& b) {
+  return pxor<Packet8i>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pand(const Packet16bf& a, const Packet16bf& b) {
+  return pand<Packet8i>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pandnot(const Packet16bf& a,
+                                       const Packet16bf& b) {
+  return pandnot<Packet8i>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pselect(const Packet16bf& mask,
+                                       const Packet16bf& a,
+                                       const Packet16bf& b) {
+  // Input mask is expected to be all 0/1, handle it with 8-bit
+  // intrinsic for performance.
+  return _mm256_blendv_epi8(b, a, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf pround<Packet16bf>(const Packet16bf& a)
+{
+  return F32ToBf16(pround<Packet16f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf print<Packet16bf>(const Packet16bf& a) {
+  return F32ToBf16(print<Packet16f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf pceil<Packet16bf>(const Packet16bf& a) {
+  return F32ToBf16(pceil<Packet16f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf pfloor<Packet16bf>(const Packet16bf& a) {
+  return F32ToBf16(pfloor<Packet16f>(Bf16ToF32(a)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pcmp_eq(const Packet16bf& a,
+                                       const Packet16bf& b) {
+  return Pack32To16(pcmp_eq(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pcmp_le(const Packet16bf& a,
+                                       const Packet16bf& b) {
+  return Pack32To16(pcmp_le(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pcmp_lt(const Packet16bf& a,
+                                       const Packet16bf& b) {
+  return Pack32To16(pcmp_lt(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pcmp_lt_or_nan(const Packet16bf& a,
+                                              const Packet16bf& b) {
+  return Pack32To16(pcmp_lt_or_nan(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pnegate(const Packet16bf& a) {
+  Packet16bf sign_mask = _mm256_set1_epi16(static_cast<unsigned short>(0x8000));
+  return _mm256_xor_si256(a, sign_mask);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pconj(const Packet16bf& a) {
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pabs(const Packet16bf& a) {
+  const __m256i sign_mask = _mm256_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm256_andnot_si256(sign_mask, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf padd<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(padd<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf psub<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(psub<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pmul<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(pmul<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pdiv<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(pdiv<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pmin<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(pmin<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pmax<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(pmax<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf plset<Packet16bf>(const bfloat16& a) {
+  return F32ToBf16(plset<Packet16f>(static_cast<float>(a)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf predux_half_dowto4<Packet16bf>(const Packet16bf& a) {
+  Packet8bf lane0 = _mm256_extractf128_si256(a, 0);
+  Packet8bf lane1 = _mm256_extractf128_si256(a, 1);
+  return padd<Packet8bf>(lane0, lane1);
+}
+
+template <>
+EIGEN_STRONG_INLINE bfloat16 predux<Packet16bf>(const Packet16bf& p) {
+  return static_cast<bfloat16>(predux<Packet16f>(Bf16ToF32(p)));
+}
+
+template <>
+EIGEN_STRONG_INLINE bfloat16 predux_mul<Packet16bf>(const Packet16bf& from) {
+  return static_cast<bfloat16>(predux_mul<Packet16f>(Bf16ToF32(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE bfloat16 predux_min<Packet16bf>(const Packet16bf& from) {
+  return static_cast<bfloat16>(predux_min<Packet16f>(Bf16ToF32(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE bfloat16 predux_max<Packet16bf>(const Packet16bf& from) {
+  return static_cast<bfloat16>(predux_max<Packet16f>(Bf16ToF32(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf preverse(const Packet16bf& a) {
+  __m256i m = _mm256_setr_epi8(14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1,
+                               14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1);
+
+  Packet16bf res;
+  // Swap hi and lo first because shuffle is in 128-bit lanes.
+  res = _mm256_permute2x128_si256(a, a, 1);
+  // Shuffle 8-bit values in src within 2*128-bit lanes.
+  return _mm256_shuffle_epi8(res, m);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pgather<bfloat16, Packet16bf>(const bfloat16* from,
+                                                             Index stride) {
+  return _mm256_set_epi16(
+      from[15*stride].value, from[14*stride].value, from[13*stride].value, from[12*stride].value,
+      from[11*stride].value, from[10*stride].value, from[9*stride].value, from[8*stride].value,
+      from[7*stride].value, from[6*stride].value, from[5*stride].value, from[4*stride].value,
+      from[3*stride].value, from[2*stride].value, from[1*stride].value, from[0*stride].value);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pscatter<bfloat16, Packet16bf>(bfloat16* to,
+                                                        const Packet16bf& from,
+                                                        Index stride) {
+  EIGEN_ALIGN64 bfloat16 aux[16];
+  pstore(aux, from);
+  to[stride*0] = aux[0];
+  to[stride*1] = aux[1];
+  to[stride*2] = aux[2];
+  to[stride*3] = aux[3];
+  to[stride*4] = aux[4];
+  to[stride*5] = aux[5];
+  to[stride*6] = aux[6];
+  to[stride*7] = aux[7];
+  to[stride*8] = aux[8];
+  to[stride*9] = aux[9];
+  to[stride*10] = aux[10];
+  to[stride*11] = aux[11];
+  to[stride*12] = aux[12];
+  to[stride*13] = aux[13];
+  to[stride*14] = aux[14];
+  to[stride*15] = aux[15];
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16bf,16>& kernel) {
+  __m256i a = kernel.packet[0];
+  __m256i b = kernel.packet[1];
+  __m256i c = kernel.packet[2];
+  __m256i d = kernel.packet[3];
+  __m256i e = kernel.packet[4];
+  __m256i f = kernel.packet[5];
+  __m256i g = kernel.packet[6];
+  __m256i h = kernel.packet[7];
+  __m256i i = kernel.packet[8];
+  __m256i j = kernel.packet[9];
+  __m256i k = kernel.packet[10];
+  __m256i l = kernel.packet[11];
+  __m256i m = kernel.packet[12];
+  __m256i n = kernel.packet[13];
+  __m256i o = kernel.packet[14];
+  __m256i p = kernel.packet[15];
+
+  __m256i ab_07 = _mm256_unpacklo_epi16(a, b);
+  __m256i cd_07 = _mm256_unpacklo_epi16(c, d);
+  __m256i ef_07 = _mm256_unpacklo_epi16(e, f);
+  __m256i gh_07 = _mm256_unpacklo_epi16(g, h);
+  __m256i ij_07 = _mm256_unpacklo_epi16(i, j);
+  __m256i kl_07 = _mm256_unpacklo_epi16(k, l);
+  __m256i mn_07 = _mm256_unpacklo_epi16(m, n);
+  __m256i op_07 = _mm256_unpacklo_epi16(o, p);
+
+  __m256i ab_8f = _mm256_unpackhi_epi16(a, b);
+  __m256i cd_8f = _mm256_unpackhi_epi16(c, d);
+  __m256i ef_8f = _mm256_unpackhi_epi16(e, f);
+  __m256i gh_8f = _mm256_unpackhi_epi16(g, h);
+  __m256i ij_8f = _mm256_unpackhi_epi16(i, j);
+  __m256i kl_8f = _mm256_unpackhi_epi16(k, l);
+  __m256i mn_8f = _mm256_unpackhi_epi16(m, n);
+  __m256i op_8f = _mm256_unpackhi_epi16(o, p);
+
+  __m256i abcd_03 = _mm256_unpacklo_epi32(ab_07, cd_07);
+  __m256i abcd_47 = _mm256_unpackhi_epi32(ab_07, cd_07);
+  __m256i efgh_03 = _mm256_unpacklo_epi32(ef_07, gh_07);
+  __m256i efgh_47 = _mm256_unpackhi_epi32(ef_07, gh_07);
+  __m256i ijkl_03 = _mm256_unpacklo_epi32(ij_07, kl_07);
+  __m256i ijkl_47 = _mm256_unpackhi_epi32(ij_07, kl_07);
+  __m256i mnop_03 = _mm256_unpacklo_epi32(mn_07, op_07);
+  __m256i mnop_47 = _mm256_unpackhi_epi32(mn_07, op_07);
+
+  __m256i abcd_8b = _mm256_unpacklo_epi32(ab_8f, cd_8f);
+  __m256i abcd_cf = _mm256_unpackhi_epi32(ab_8f, cd_8f);
+  __m256i efgh_8b = _mm256_unpacklo_epi32(ef_8f, gh_8f);
+  __m256i efgh_cf = _mm256_unpackhi_epi32(ef_8f, gh_8f);
+  __m256i ijkl_8b = _mm256_unpacklo_epi32(ij_8f, kl_8f);
+  __m256i ijkl_cf = _mm256_unpackhi_epi32(ij_8f, kl_8f);
+  __m256i mnop_8b = _mm256_unpacklo_epi32(mn_8f, op_8f);
+  __m256i mnop_cf = _mm256_unpackhi_epi32(mn_8f, op_8f);
+
+  __m256i abcdefgh_01 = _mm256_unpacklo_epi64(abcd_03, efgh_03);
+  __m256i abcdefgh_23 = _mm256_unpackhi_epi64(abcd_03, efgh_03);
+  __m256i ijklmnop_01 = _mm256_unpacklo_epi64(ijkl_03, mnop_03);
+  __m256i ijklmnop_23 = _mm256_unpackhi_epi64(ijkl_03, mnop_03);
+  __m256i abcdefgh_45 = _mm256_unpacklo_epi64(abcd_47, efgh_47);
+  __m256i abcdefgh_67 = _mm256_unpackhi_epi64(abcd_47, efgh_47);
+  __m256i ijklmnop_45 = _mm256_unpacklo_epi64(ijkl_47, mnop_47);
+  __m256i ijklmnop_67 = _mm256_unpackhi_epi64(ijkl_47, mnop_47);
+  __m256i abcdefgh_89 = _mm256_unpacklo_epi64(abcd_8b, efgh_8b);
+  __m256i abcdefgh_ab = _mm256_unpackhi_epi64(abcd_8b, efgh_8b);
+  __m256i ijklmnop_89 = _mm256_unpacklo_epi64(ijkl_8b, mnop_8b);
+  __m256i ijklmnop_ab = _mm256_unpackhi_epi64(ijkl_8b, mnop_8b);
+  __m256i abcdefgh_cd = _mm256_unpacklo_epi64(abcd_cf, efgh_cf);
+  __m256i abcdefgh_ef = _mm256_unpackhi_epi64(abcd_cf, efgh_cf);
+  __m256i ijklmnop_cd = _mm256_unpacklo_epi64(ijkl_cf, mnop_cf);
+  __m256i ijklmnop_ef = _mm256_unpackhi_epi64(ijkl_cf, mnop_cf);
+
+  // NOTE: no unpacklo/hi instr in this case, so using permute instr.
+  kernel.packet[0] = _mm256_permute2x128_si256(abcdefgh_01, ijklmnop_01, 0x20);
+  kernel.packet[1] = _mm256_permute2x128_si256(abcdefgh_23, ijklmnop_23, 0x20);
+  kernel.packet[2] = _mm256_permute2x128_si256(abcdefgh_45, ijklmnop_45, 0x20);
+  kernel.packet[3] = _mm256_permute2x128_si256(abcdefgh_67, ijklmnop_67, 0x20);
+  kernel.packet[4] = _mm256_permute2x128_si256(abcdefgh_89, ijklmnop_89, 0x20);
+  kernel.packet[5] = _mm256_permute2x128_si256(abcdefgh_ab, ijklmnop_ab, 0x20);
+  kernel.packet[6] = _mm256_permute2x128_si256(abcdefgh_cd, ijklmnop_cd, 0x20);
+  kernel.packet[7] = _mm256_permute2x128_si256(abcdefgh_ef, ijklmnop_ef, 0x20);
+  kernel.packet[8] = _mm256_permute2x128_si256(abcdefgh_01, ijklmnop_01, 0x31);
+  kernel.packet[9] = _mm256_permute2x128_si256(abcdefgh_23, ijklmnop_23, 0x31);
+  kernel.packet[10] = _mm256_permute2x128_si256(abcdefgh_45, ijklmnop_45, 0x31);
+  kernel.packet[11] = _mm256_permute2x128_si256(abcdefgh_67, ijklmnop_67, 0x31);
+  kernel.packet[12] = _mm256_permute2x128_si256(abcdefgh_89, ijklmnop_89, 0x31);
+  kernel.packet[13] = _mm256_permute2x128_si256(abcdefgh_ab, ijklmnop_ab, 0x31);
+  kernel.packet[14] = _mm256_permute2x128_si256(abcdefgh_cd, ijklmnop_cd, 0x31);
+  kernel.packet[15] = _mm256_permute2x128_si256(abcdefgh_ef, ijklmnop_ef, 0x31);
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16bf,4>& kernel) {
+  __m256i a = kernel.packet[0];
+  __m256i b = kernel.packet[1];
+  __m256i c = kernel.packet[2];
+  __m256i d = kernel.packet[3];
+
+  __m256i ab_07 = _mm256_unpacklo_epi16(a, b);
+  __m256i cd_07 = _mm256_unpacklo_epi16(c, d);
+  __m256i ab_8f = _mm256_unpackhi_epi16(a, b);
+  __m256i cd_8f = _mm256_unpackhi_epi16(c, d);
+
+  __m256i abcd_03 = _mm256_unpacklo_epi32(ab_07, cd_07);
+  __m256i abcd_47 = _mm256_unpackhi_epi32(ab_07, cd_07);
+  __m256i abcd_8b = _mm256_unpacklo_epi32(ab_8f, cd_8f);
+  __m256i abcd_cf = _mm256_unpackhi_epi32(ab_8f, cd_8f);
+
+  // NOTE: no unpacklo/hi instr in this case, so using permute instr.
+  kernel.packet[0] = _mm256_permute2x128_si256(abcd_03, abcd_47, 0x20);
+  kernel.packet[1] = _mm256_permute2x128_si256(abcd_8b, abcd_cf, 0x20);
+  kernel.packet[2] = _mm256_permute2x128_si256(abcd_03, abcd_47, 0x31);
+  kernel.packet[3] = _mm256_permute2x128_si256(abcd_8b, abcd_cf, 0x31);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_AVX512_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/TypeCasting.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/TypeCasting.h
new file mode 100644
index 00000000..33041272
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AVX512/TypeCasting.h
@@ -0,0 +1,89 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2019 Rasmus Munk Larsen <rmlarsen@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_AVX512_H
+#define EIGEN_TYPE_CASTING_AVX512_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<> EIGEN_STRONG_INLINE Packet16i pcast<Packet16f, Packet16i>(const Packet16f& a) {
+  return _mm512_cvttps_epi32(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pcast<Packet16i, Packet16f>(const Packet16i& a) {
+  return _mm512_cvtepi32_ps(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16i preinterpret<Packet16i, Packet16f>(const Packet16f& a) {
+  return _mm512_castps_si512(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f preinterpret<Packet16f, Packet16i>(const Packet16i& a) {
+  return _mm512_castsi512_ps(a);
+}
+
+template <>
+struct type_casting_traits<half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet16f pcast<Packet16h, Packet16f>(const Packet16h& a) {
+  return half2float(a);
+}
+
+template <>
+struct type_casting_traits<float, half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet16h pcast<Packet16f, Packet16h>(const Packet16f& a) {
+  return float2half(a);
+}
+
+template <>
+struct type_casting_traits<bfloat16, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet16f pcast<Packet16bf, Packet16f>(const Packet16bf& a) {
+  return Bf16ToF32(a);
+}
+
+template <>
+struct type_casting_traits<float, bfloat16> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet16bf pcast<Packet16f, Packet16bf>(const Packet16f& a) {
+  return F32ToBf16(a);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_AVX512_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/Complex.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/Complex.h
new file mode 100644
index 00000000..f424f11c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/Complex.h
@@ -0,0 +1,417 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010-2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX32_ALTIVEC_H
+#define EIGEN_COMPLEX32_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+static Packet4ui  p4ui_CONJ_XOR = vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO);//{ 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
+#ifdef __VSX__
+#if defined(_BIG_ENDIAN)
+static Packet2ul  p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_MZERO, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+static Packet2ul  p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO,  (Packet4ui) p2d_MZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+#else
+static Packet2ul  p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO,  (Packet4ui) p2d_MZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+static Packet2ul  p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2d_MZERO, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+#endif
+#endif
+
+//---------- float ----------
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE explicit Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {}
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b)
+  {
+    Packet4f v1, v2;
+
+    // Permute and multiply the real parts of a and b
+    v1 = vec_perm(a.v, a.v, p16uc_PSET32_WODD);
+    // Get the imaginary parts of a
+    v2 = vec_perm(a.v, a.v, p16uc_PSET32_WEVEN);
+    // multiply a_re * b
+    v1 = vec_madd(v1, b.v, p4f_ZERO);
+    // multiply a_im * b and get the conjugate result
+    v2 = vec_madd(v2, b.v, p4f_ZERO);
+    v2 = reinterpret_cast<Packet4f>(pxor(v2, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR)));
+    // permute back to a proper order
+    v2 = vec_perm(v2, v2, p16uc_COMPLEX32_REV);
+
+    return Packet2cf(padd<Packet4f>(v1, v2));
+  }
+
+  EIGEN_STRONG_INLINE Packet2cf& operator*=(const Packet2cf& b) {
+    v = pmul(Packet2cf(*this), b).v;
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator*(const Packet2cf& b) const {
+    return Packet2cf(*this) *= b;
+  }
+
+  EIGEN_STRONG_INLINE Packet2cf& operator+=(const Packet2cf& b) {
+    v = padd(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator+(const Packet2cf& b) const {
+    return Packet2cf(*this) += b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator-=(const Packet2cf& b) {
+    v = psub(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator-(const Packet2cf& b) const {
+    return Packet2cf(*this) -= b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator-(void) const {
+    return Packet2cf(-v);
+  }
+
+  Packet4f  v;
+};
+
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  typedef Packet4f as_real;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+#ifdef __VSX__
+    HasBlend  = 1,
+#endif
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet2cf half; typedef Packet4f as_real; };
+
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+  if((std::ptrdiff_t(&from) % 16) == 0)
+    res.v = pload<Packet4f>((const float *)&from);
+  else
+    res.v = ploadu<Packet4f>((const float *)&from);
+  res.v = vec_perm(res.v, res.v, p16uc_PSET64_HI);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pload<Packet2cf>(const std::complex<float>*        from) { return Packet2cf(pload<Packet4f>((const float *) from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>*       from) { return Packet2cf(ploadu<Packet4f>((const float*) from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>*     from) { return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { pstore((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { pstoreu((float*)to, from.v); }
+
+EIGEN_STRONG_INLINE Packet2cf pload2(const std::complex<float>* from0, const std::complex<float>* from1)
+{
+  Packet4f res0, res1;
+#ifdef __VSX__
+  __asm__ ("lxsdx %x0,%y1" : "=wa" (res0) : "Z" (*from0));
+  __asm__ ("lxsdx %x0,%y1" : "=wa" (res1) : "Z" (*from1));
+#ifdef _BIG_ENDIAN
+  __asm__ ("xxpermdi %x0, %x1, %x2, 0" : "=wa" (res0) : "wa" (res0), "wa" (res1));
+#else
+  __asm__ ("xxpermdi %x0, %x2, %x1, 0" : "=wa" (res0) : "wa" (res0), "wa" (res1));
+#endif
+#else
+  *reinterpret_cast<std::complex<float> *>(&res0) = *from0;
+  *reinterpret_cast<std::complex<float> *>(&res1) = *from1;
+  res0 = vec_perm(res0, res1, p16uc_TRANSPOSE64_HI);
+#endif
+  return Packet2cf(res0);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
+{
+  EIGEN_ALIGN16 std::complex<float> af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+  return pload<Packet2cf>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  EIGEN_ALIGN16 std::complex<float> af[2];
+  pstore<std::complex<float> >((std::complex<float> *) af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(a.v + b.v); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(a.v - b.v); }
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a.v, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR))); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pand   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pand<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf por    <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(por<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pxor<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pandnot<Packet4f>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> * addr)    { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet2cf>(const Packet2cf& a)
+{
+  EIGEN_ALIGN16 std::complex<float> res[2];
+  pstore((float *)&res, a.v);
+
+  return res[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{
+  Packet4f rev_a;
+  rev_a = vec_perm(a.v, a.v, p16uc_COMPLEX32_REV2);
+  return Packet2cf(rev_a);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  Packet4f b;
+  b = vec_sld(a.v, a.v, 8);
+  b = padd<Packet4f>(a.v, b);
+  return pfirst<Packet2cf>(Packet2cf(b));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  Packet4f b;
+  Packet2cf prod;
+  b = vec_sld(a.v, a.v, 8);
+  prod = pmul<Packet2cf>(a, Packet2cf(b));
+
+  return pfirst<Packet2cf>(prod);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for AltiVec
+  Packet2cf res = pmul(a, pconj(b));
+  Packet4f s = pmul<Packet4f>(b.v, b.v);
+  return Packet2cf(pdiv(res.v, padd<Packet4f>(s, vec_perm(s, s, p16uc_COMPLEX32_REV))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& x)
+{
+  return Packet2cf(vec_perm(x.v, x.v, p16uc_COMPLEX32_REV));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel)
+{
+  Packet4f tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b) {
+  Packet4f eq = reinterpret_cast<Packet4f>(vec_cmpeq(a.v,b.v));
+  return Packet2cf(vec_and(eq, vec_perm(eq, eq, p16uc_COMPLEX32_REV)));
+}
+
+#ifdef __VSX__
+template<> EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  Packet2cf result;
+  result.v = reinterpret_cast<Packet4f>(pblend<Packet2d>(ifPacket, reinterpret_cast<Packet2d>(thenPacket.v), reinterpret_cast<Packet2d>(elsePacket.v)));
+  return result;
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2cf psqrt<Packet2cf>(const Packet2cf& a)
+{
+  return psqrt_complex<Packet2cf>(a);
+}
+
+//---------- double ----------
+#ifdef __VSX__
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {}
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b)
+  {
+    Packet2d a_re, a_im, v1, v2;
+
+    // Permute and multiply the real parts of a and b
+    a_re = vec_perm(a.v, a.v, p16uc_PSET64_HI);
+    // Get the imaginary parts of a
+    a_im = vec_perm(a.v, a.v, p16uc_PSET64_LO);
+    // multiply a_re * b
+    v1 = vec_madd(a_re, b.v, p2d_ZERO);
+    // multiply a_im * b and get the conjugate result
+    v2 = vec_madd(a_im, b.v, p2d_ZERO);
+    v2 = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(v2), reinterpret_cast<Packet4ui>(v2), 8));
+    v2 = pxor(v2, reinterpret_cast<Packet2d>(p2ul_CONJ_XOR1));
+
+    return Packet1cd(padd<Packet2d>(v1, v2));
+  }
+
+  EIGEN_STRONG_INLINE Packet1cd& operator*=(const Packet1cd& b) {
+    v = pmul(Packet1cd(*this), b).v;
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator*(const Packet1cd& b) const {
+    return Packet1cd(*this) *= b;
+  }
+
+  EIGEN_STRONG_INLINE Packet1cd& operator+=(const Packet1cd& b) {
+    v = padd(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator+(const Packet1cd& b) const {
+    return Packet1cd(*this) += b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator-=(const Packet1cd& b) {
+    v = psub(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator-(const Packet1cd& b) const {
+    return Packet1cd(*this) -= b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator-(void) const {
+    return Packet1cd(-v);
+  }
+
+  Packet2d v;
+};
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  typedef Packet2d as_real;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet1cd half; typedef Packet2d as_real; };
+
+template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from) { return Packet1cd(pload<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) { return Packet1cd(ploadu<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { pstoreu((double*)to, from.v); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>&  from)
+{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(const std::complex<double>* from, Index)
+{
+  return pload<Packet1cd>(from);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to, const Packet1cd& from, Index)
+{
+  pstore<std::complex<double> >(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v + b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v - b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) { return Packet1cd(pxor(a.v, reinterpret_cast<Packet2d>(p2ul_CONJ_XOR2))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pand   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(pand(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd por    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(por(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pxor   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(pxor(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(pandnot(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>*     from)  { return pset1<Packet1cd>(*from); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> * addr)    { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double>  pfirst<Packet1cd>(const Packet1cd& a)
+{
+  EIGEN_ALIGN16 std::complex<double> res[2];
+  pstore<std::complex<double> >(res, a);
+
+  return res[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for AltiVec
+  Packet1cd res = pmul(a,pconj(b));
+  Packet2d s = pmul<Packet2d>(b.v, b.v);
+  return Packet1cd(pdiv(res.v, padd<Packet2d>(s, vec_perm(s, s, p16uc_REVERSE64))));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
+{
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd,2>& kernel)
+{
+  Packet2d tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b) {
+  // Compare real and imaginary parts of a and b to get the mask vector:
+  // [re(a)==re(b), im(a)==im(b)]
+  Packet2d eq = reinterpret_cast<Packet2d>(vec_cmpeq(a.v,b.v));
+  // Swap real/imag elements in the mask in to get:
+  // [im(a)==im(b), re(a)==re(b)]
+  Packet2d eq_swapped = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(eq), reinterpret_cast<Packet4ui>(eq), 8));
+  // Return re(a)==re(b) & im(a)==im(b) by computing bitwise AND of eq and eq_swapped
+  return Packet1cd(vec_and(eq, eq_swapped));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd psqrt<Packet1cd>(const Packet1cd& a)
+{
+  return psqrt_complex<Packet1cd>(a);
+}
+
+#endif // __VSX__
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX32_ALTIVEC_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
new file mode 100644
index 00000000..3a7a3293
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
@@ -0,0 +1,90 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+#define EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f plog<Packet4f>(const Packet4f& _x)
+{
+  return plog_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexp<Packet4f>(const Packet4f& _x)
+{
+  return pexp_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psin<Packet4f>(const Packet4f& _x)
+{
+  return psin_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pcos<Packet4f>(const Packet4f& _x)
+{
+  return pcos_float(_x);
+}
+
+#ifndef EIGEN_COMP_CLANG
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& x)
+{
+  return  vec_rsqrt(x);
+}
+#endif
+
+#ifdef __VSX__
+#ifndef EIGEN_COMP_CLANG
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d prsqrt<Packet2d>(const Packet2d& x)
+{
+  return  vec_rsqrt(x);
+}
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& x)
+{
+  return  vec_sqrt(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d psqrt<Packet2d>(const Packet2d& x)
+{
+  return  vec_sqrt(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d pexp<Packet2d>(const Packet2d& _x)
+{
+  return pexp_double(_x);
+}
+#endif
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+ptanh<Packet4f>(const Packet4f& x) {
+  return internal::generic_fast_tanh_float(x);
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_ALTIVEC_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
new file mode 100644
index 00000000..3f79b97d
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
@@ -0,0 +1,2937 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020 Everton Constantino (everton.constantino@ibm.com)
+// Copyright (C) 2021 Chip Kerchner (chip.kerchner@ibm.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIX_PRODUCT_ALTIVEC_H
+#define EIGEN_MATRIX_PRODUCT_ALTIVEC_H
+
+#ifndef EIGEN_ALTIVEC_USE_CUSTOM_PACK
+#define EIGEN_ALTIVEC_USE_CUSTOM_PACK    1
+#endif
+
+#include "MatrixProductCommon.h"
+
+// Since LLVM doesn't support dynamic dispatching, force either always MMA or VSX
+#if EIGEN_COMP_LLVM
+#if !defined(EIGEN_ALTIVEC_DISABLE_MMA) && !defined(EIGEN_ALTIVEC_MMA_ONLY)
+#ifdef __MMA__
+#define EIGEN_ALTIVEC_MMA_ONLY
+#else
+#define EIGEN_ALTIVEC_DISABLE_MMA
+#endif
+#endif
+#endif
+
+#ifdef __has_builtin
+#if __has_builtin(__builtin_mma_assemble_acc)
+  #define ALTIVEC_MMA_SUPPORT
+#endif
+#endif
+
+#if defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+  #include "MatrixProductMMA.h"
+#endif
+
+/**************************************************************************************************
+ * TODO                                                                                           *
+ * - Check StorageOrder on dhs_pack (the innermost second loop seems unvectorized when it could). *
+ * - Check the possibility of transposing as GETREAL and GETIMAG when needed.                     *
+ **************************************************************************************************/
+namespace Eigen {
+
+namespace internal {
+
+/**************************
+ * Constants and typedefs *
+ **************************/
+template<typename Scalar>
+struct quad_traits
+{
+  typedef typename packet_traits<Scalar>::type    vectortype;
+  typedef PacketBlock<vectortype,4>                     type;
+  typedef vectortype                                 rhstype;
+  enum
+  {
+    vectorsize = packet_traits<Scalar>::size,
+    size = 4,
+    rows = 4
+  };
+};
+
+template<>
+struct quad_traits<double>
+{
+  typedef Packet2d                        vectortype;
+  typedef PacketBlock<vectortype,4>             type;
+  typedef PacketBlock<Packet2d,2>            rhstype;
+  enum
+  {
+    vectorsize = packet_traits<double>::size,
+    size = 2,
+    rows = 4
+  };
+};
+
+// MatrixProduct decomposes real/imaginary vectors into a real vector and an imaginary vector, this turned out
+// to be faster than Eigen's usual approach of having real/imaginary pairs on a single vector. This constants then
+// are responsible to extract from convert between Eigen's and MatrixProduct approach.
+
+const static Packet16uc p16uc_GETREAL32 = {  0,  1,  2,  3,
+                                             8,  9, 10, 11,
+                                            16, 17, 18, 19,
+                                            24, 25, 26, 27};
+
+const static Packet16uc p16uc_GETIMAG32 = {  4,  5,  6,  7,
+                                            12, 13, 14, 15,
+                                            20, 21, 22, 23,
+                                            28, 29, 30, 31};
+const static Packet16uc p16uc_GETREAL64 = {  0,  1,  2,  3,  4,  5,  6,  7,
+                                            16, 17, 18, 19, 20, 21, 22, 23};
+
+//[a,ai],[b,bi] = [ai,bi]
+const static Packet16uc p16uc_GETIMAG64 = {  8,  9, 10, 11, 12, 13, 14, 15,
+                                            24, 25, 26, 27, 28, 29, 30, 31};
+
+/*********************************************
+ * Single precision real and complex packing *
+ * *******************************************/
+
+/**
+ * Symm packing is related to packing of symmetric adjoint blocks, as expected the packing leaves
+ * the diagonal real, whatever is below it is copied from the respective upper diagonal element and 
+ * conjugated. There's no PanelMode available for symm packing.
+ *
+ * Packing in general is supposed to leave the lhs block and the rhs block easy to be read by gemm using 
+ * its respective rank-update instructions. The float32/64 versions are different because at this moment
+ * the size of the accumulator is fixed at 512-bits so you can't have a 4x4 accumulator of 64-bit elements.
+ * 
+ * As mentioned earlier MatrixProduct breaks complex numbers into a real vector and a complex vector so packing has
+ * to take that into account, at the moment, we run pack the real part and then the imaginary part, this is the main
+ * reason why packing for complex is broken down into several different parts, also the reason why we endup having a
+ * float32/64 and complex float32/64 version.
+ **/
+template<typename Scalar, typename Index, int StorageOrder>
+EIGEN_ALWAYS_INLINE std::complex<Scalar> getAdjointVal(Index i, Index j, const_blas_data_mapper<std::complex<Scalar>, Index, StorageOrder>& dt)
+{
+  std::complex<Scalar> v;
+  if(i < j)
+  {
+    v.real( dt(j,i).real());
+    v.imag(-dt(j,i).imag());
+  } else if(i > j)
+  {
+    v.real( dt(i,j).real());
+    v.imag( dt(i,j).imag());
+  } else {
+    v.real( dt(i,j).real());
+    v.imag((Scalar)0.0);
+  }
+  return v;
+}
+
+template<typename Scalar, typename Index, int StorageOrder, int N>
+EIGEN_STRONG_INLINE void symm_pack_complex_rhs_helper(std::complex<Scalar>* blockB, const std::complex<Scalar>* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+{
+  const Index depth = k2 + rows;
+  const_blas_data_mapper<std::complex<Scalar>, Index, StorageOrder> rhs(_rhs, rhsStride);
+  const Index vectorSize = N*quad_traits<Scalar>::vectorsize;
+  const Index vectorDelta = vectorSize * rows;
+  Scalar* blockBf = reinterpret_cast<Scalar *>(blockB);
+
+  Index rir = 0, rii, j = 0;
+  for(; j + vectorSize <= cols; j+=vectorSize)
+  {
+    rii = rir + vectorDelta;
+
+    for(Index i = k2; i < depth; i++)
+    {
+      for(Index k = 0; k < vectorSize; k++)
+      {
+        std::complex<Scalar> v = getAdjointVal<Scalar, Index, StorageOrder>(i, j + k, rhs);
+
+        blockBf[rir + k] = v.real();
+        blockBf[rii + k] = v.imag();
+      }
+      rir += vectorSize;
+      rii += vectorSize;
+    }
+
+    rir += vectorDelta;
+  }
+  if (j < cols)
+  {
+    rii = rir + ((cols - j) * rows);
+
+    for(Index i = k2; i < depth; i++)
+    {
+      Index k = j;
+      for(; k < cols; k++)
+      {
+        std::complex<Scalar> v = getAdjointVal<Scalar, Index, StorageOrder>(i, k, rhs);
+
+        blockBf[rir] = v.real();
+        blockBf[rii] = v.imag();
+
+        rir += 1;
+        rii += 1;
+      }
+    }
+  }
+}
+
+template<typename Scalar, typename Index, int StorageOrder>
+EIGEN_STRONG_INLINE void symm_pack_complex_lhs_helper(std::complex<Scalar>* blockA, const std::complex<Scalar>* _lhs, Index lhsStride, Index cols, Index rows)
+{
+  const Index depth = cols;
+  const_blas_data_mapper<std::complex<Scalar>, Index, StorageOrder> lhs(_lhs, lhsStride);
+  const Index vectorSize = quad_traits<Scalar>::vectorsize;
+  const Index vectorDelta = vectorSize * depth;
+  Scalar* blockAf = (Scalar *)(blockA);
+
+  Index rir = 0, rii, j = 0;
+  for(; j + vectorSize <= rows; j+=vectorSize)
+  {
+    rii = rir + vectorDelta;
+
+    for(Index i = 0; i < depth; i++)
+    {
+      for(Index k = 0; k < vectorSize; k++)
+      {
+        std::complex<Scalar> v = getAdjointVal<Scalar, Index, StorageOrder>(j+k, i, lhs);
+
+        blockAf[rir + k] = v.real();
+        blockAf[rii + k] = v.imag();
+      }
+      rir += vectorSize;
+      rii += vectorSize;
+    }
+
+    rir += vectorDelta;
+  }
+
+  if (j < rows)
+  {
+    rii = rir + ((rows - j) * depth);
+
+    for(Index i = 0; i < depth; i++)
+    {
+      Index k = j;
+      for(; k < rows; k++)
+      {
+        std::complex<Scalar> v = getAdjointVal<Scalar, Index, StorageOrder>(k, i, lhs);
+
+        blockAf[rir] = v.real();
+        blockAf[rii] = v.imag();
+
+        rir += 1;
+        rii += 1;
+      }
+    }
+  }
+}
+
+template<typename Scalar, typename Index, int StorageOrder, int N>
+EIGEN_STRONG_INLINE void symm_pack_rhs_helper(Scalar* blockB, const Scalar* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+{
+  const Index depth = k2 + rows;
+  const_blas_data_mapper<Scalar, Index, StorageOrder> rhs(_rhs, rhsStride);
+  const Index vectorSize = quad_traits<Scalar>::vectorsize;
+
+  Index ri = 0, j = 0;
+  for(; j + N*vectorSize <= cols; j+=N*vectorSize)
+  {
+    Index i = k2;
+    for(; i < depth; i++)
+    {
+      for(Index k = 0; k < N*vectorSize; k++)
+      {
+        if(i <= j+k)
+          blockB[ri + k] = rhs(j+k, i);
+        else
+          blockB[ri + k] = rhs(i, j+k);
+      }
+      ri += N*vectorSize;
+    }
+  }
+
+  if (j < cols)
+  {
+    for(Index i = k2; i < depth; i++)
+    {
+      Index k = j;
+      for(; k < cols; k++)
+      {
+        if(k <= i)
+          blockB[ri] = rhs(i, k);
+        else
+          blockB[ri] = rhs(k, i);
+        ri += 1;
+      }
+    }
+  }
+}
+
+template<typename Scalar, typename Index, int StorageOrder>
+EIGEN_STRONG_INLINE void symm_pack_lhs_helper(Scalar* blockA, const Scalar* _lhs, Index lhsStride, Index cols, Index rows)
+{
+  const Index depth = cols;
+  const_blas_data_mapper<Scalar, Index, StorageOrder> lhs(_lhs, lhsStride);
+  const Index vectorSize = quad_traits<Scalar>::vectorsize;
+
+  Index ri = 0, j = 0;
+  for(; j + vectorSize <= rows; j+=vectorSize)
+  {
+    Index i = 0;
+
+    for(; i < depth; i++)
+    {
+      for(Index k = 0; k < vectorSize; k++)
+      {
+        if(i <= j+k)
+          blockA[ri + k] = lhs(j+k, i);
+        else
+          blockA[ri + k] = lhs(i, j+k);
+      }
+      ri += vectorSize;
+    }
+  }
+
+  if (j < rows)
+  {
+    for(Index i = 0; i < depth; i++)
+    {
+      Index k = j;
+      for(; k < rows; k++)
+      {
+        if(i <= k)
+          blockA[ri] = lhs(k, i);
+        else
+          blockA[ri] = lhs(i, k);
+        ri += 1;
+      }
+    }
+  }
+}
+
+template<typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs<std::complex<float>, Index, nr, StorageOrder>
+{
+  void operator()(std::complex<float>* blockB, const std::complex<float>* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    symm_pack_complex_rhs_helper<float, Index, StorageOrder, 1>(blockB, _rhs, rhsStride, rows, cols, k2);
+  }
+};
+
+template<typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs<std::complex<float>, Index, Pack1, Pack2_dummy, StorageOrder>
+{
+  void operator()(std::complex<float>* blockA, const std::complex<float>* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    symm_pack_complex_lhs_helper<float, Index, StorageOrder>(blockA, _lhs, lhsStride, cols, rows);
+  }
+};
+
+// *********** symm_pack std::complex<float64> ***********
+
+template<typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs<std::complex<double>, Index, nr, StorageOrder>
+{
+  void operator()(std::complex<double>* blockB, const std::complex<double>* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    symm_pack_complex_rhs_helper<double, Index, StorageOrder, 2>(blockB, _rhs, rhsStride, rows, cols, k2);
+  }
+};
+
+template<typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs<std::complex<double>, Index, Pack1, Pack2_dummy, StorageOrder>
+{
+  void operator()(std::complex<double>* blockA, const std::complex<double>* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    symm_pack_complex_lhs_helper<double, Index, StorageOrder>(blockA, _lhs, lhsStride, cols, rows);
+  }
+};
+
+// *********** symm_pack float32 ***********
+template<typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs<float, Index, nr, StorageOrder>
+{
+  void operator()(float* blockB, const float* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    symm_pack_rhs_helper<float, Index, StorageOrder, 1>(blockB, _rhs, rhsStride, rows, cols, k2);
+  }
+};
+
+template<typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs<float, Index, Pack1, Pack2_dummy, StorageOrder>
+{
+  void operator()(float* blockA, const float* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    symm_pack_lhs_helper<float, Index, StorageOrder>(blockA, _lhs, lhsStride, cols, rows);
+  }
+};
+
+// *********** symm_pack float64 ***********
+template<typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs<double, Index, nr, StorageOrder>
+{
+  void operator()(double* blockB, const double* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    symm_pack_rhs_helper<double, Index, StorageOrder, 2>(blockB, _rhs, rhsStride, rows, cols, k2);
+  }
+};
+
+template<typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs<double, Index, Pack1, Pack2_dummy, StorageOrder>
+{
+  void operator()(double* blockA, const double* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    symm_pack_lhs_helper<double, Index, StorageOrder>(blockA, _lhs, lhsStride, cols, rows);
+  }
+};
+
+/**
+ * PanelMode
+ * Packing might be called several times before being multiplied by gebp_kernel, this happens because 
+ * on special occasions it fills part of block with other parts of the matrix. Two variables control
+ * how PanelMode should behave: offset and stride. The idea is that those variables represent whatever
+ * is going to be the real offset and stride in the future and this is what you should obey. The process
+ * is to behave as you would with normal packing but leave the start of each part with the correct offset
+ * and the end as well respecting the real stride the block will have. Gebp is aware of both blocks stride
+ * and offset and behaves accordingly.
+ **/
+
+template<typename Scalar, typename Packet, typename Index>
+EIGEN_ALWAYS_INLINE void storeBlock(Scalar* to, PacketBlock<Packet,4>& block)
+{
+  const Index size = 16 / sizeof(Scalar);
+  pstore<Scalar>(to + (0 * size), block.packet[0]);
+  pstore<Scalar>(to + (1 * size), block.packet[1]);
+  pstore<Scalar>(to + (2 * size), block.packet[2]);
+  pstore<Scalar>(to + (3 * size), block.packet[3]);
+}
+
+template<typename Scalar, typename Packet, typename Index>
+EIGEN_ALWAYS_INLINE void storeBlock(Scalar* to, PacketBlock<Packet,2>& block)
+{
+  const Index size = 16 / sizeof(Scalar);
+  pstore<Scalar>(to + (0 * size), block.packet[0]);
+  pstore<Scalar>(to + (1 * size), block.packet[1]);
+}
+
+// General template for lhs & rhs complex packing.
+template<typename Scalar, typename Index, typename DataMapper, typename Packet, typename PacketC, int StorageOrder, bool Conjugate, bool PanelMode, bool UseLhs>
+struct dhs_cpack {
+  EIGEN_STRONG_INLINE void operator()(std::complex<Scalar>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<Scalar>::vectorsize;
+    const Index vectorDelta = vectorSize * ((PanelMode) ? stride : depth);
+    Index rir = ((PanelMode) ? (vectorSize*offset) : 0), rii;
+    Scalar* blockAt = reinterpret_cast<Scalar *>(blockA);
+    Index j = 0;
+
+    for(; j + vectorSize <= rows; j+=vectorSize)
+    {
+      Index i = 0;
+
+      rii = rir + vectorDelta;
+
+      for(; i + vectorSize <= depth; i+=vectorSize)
+      {
+        PacketBlock<Packet,4> blockr, blocki;
+        PacketBlock<PacketC,8> cblock;
+
+        if (UseLhs) {
+          bload<DataMapper, PacketC, Index, 2, 0, StorageOrder>(cblock, lhs, j, i);
+        } else {
+          bload<DataMapper, PacketC, Index, 2, 0, StorageOrder>(cblock, lhs, i, j);
+        }
+
+        blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[4].v, p16uc_GETREAL32);
+        blockr.packet[1] = vec_perm(cblock.packet[1].v, cblock.packet[5].v, p16uc_GETREAL32);
+        blockr.packet[2] = vec_perm(cblock.packet[2].v, cblock.packet[6].v, p16uc_GETREAL32);
+        blockr.packet[3] = vec_perm(cblock.packet[3].v, cblock.packet[7].v, p16uc_GETREAL32);
+
+        blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[4].v, p16uc_GETIMAG32);
+        blocki.packet[1] = vec_perm(cblock.packet[1].v, cblock.packet[5].v, p16uc_GETIMAG32);
+        blocki.packet[2] = vec_perm(cblock.packet[2].v, cblock.packet[6].v, p16uc_GETIMAG32);
+        blocki.packet[3] = vec_perm(cblock.packet[3].v, cblock.packet[7].v, p16uc_GETIMAG32);
+
+        if(Conjugate)
+        {
+          blocki.packet[0] = -blocki.packet[0];
+          blocki.packet[1] = -blocki.packet[1];
+          blocki.packet[2] = -blocki.packet[2];
+          blocki.packet[3] = -blocki.packet[3];
+        }
+
+        if(((StorageOrder == RowMajor) && UseLhs) || (((StorageOrder == ColMajor) && !UseLhs)))
+        {
+          ptranspose(blockr);
+          ptranspose(blocki);
+        }
+
+        storeBlock<Scalar, Packet, Index>(blockAt + rir, blockr);
+        storeBlock<Scalar, Packet, Index>(blockAt + rii, blocki);
+
+        rir += 4*vectorSize;
+        rii += 4*vectorSize;
+      }
+      for(; i < depth; i++)
+      {
+        PacketBlock<Packet,1> blockr, blocki;
+        PacketBlock<PacketC,2> cblock;
+
+        if(((StorageOrder == ColMajor) && UseLhs) || (((StorageOrder == RowMajor) && !UseLhs)))
+        {
+          if (UseLhs) {
+            cblock.packet[0] = lhs.template loadPacket<PacketC>(j + 0, i);
+            cblock.packet[1] = lhs.template loadPacket<PacketC>(j + 2, i);
+          } else {
+            cblock.packet[0] = lhs.template loadPacket<PacketC>(i, j + 0);
+            cblock.packet[1] = lhs.template loadPacket<PacketC>(i, j + 2);
+          }
+        } else {
+          std::complex<Scalar> lhs0, lhs1;
+          if (UseLhs) {
+            lhs0 = lhs(j + 0, i);
+            lhs1 = lhs(j + 1, i);
+            cblock.packet[0] = pload2(&lhs0, &lhs1);
+            lhs0 = lhs(j + 2, i);
+            lhs1 = lhs(j + 3, i);
+            cblock.packet[1] = pload2(&lhs0, &lhs1);
+          } else {
+            lhs0 = lhs(i, j + 0);
+            lhs1 = lhs(i, j + 1);
+            cblock.packet[0] = pload2(&lhs0, &lhs1);
+            lhs0 = lhs(i, j + 2);
+            lhs1 = lhs(i, j + 3);
+            cblock.packet[1] = pload2(&lhs0, &lhs1);
+          }
+        }
+
+        blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETREAL32);
+        blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETIMAG32);
+
+        if(Conjugate)
+        {
+          blocki.packet[0] = -blocki.packet[0];
+        }
+
+        pstore<Scalar>(blockAt + rir, blockr.packet[0]);
+        pstore<Scalar>(blockAt + rii, blocki.packet[0]);
+
+        rir += vectorSize;
+        rii += vectorSize;
+      }
+
+      rir += ((PanelMode) ? (vectorSize*(2*stride - depth)) : vectorDelta);
+    }
+
+    if (j < rows)
+    {
+      if(PanelMode) rir += (offset*(rows - j - vectorSize));
+      rii = rir + (((PanelMode) ? stride : depth) * (rows - j));
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < rows; k++)
+        {
+          if (UseLhs) {
+            blockAt[rir] = lhs(k, i).real();
+
+            if(Conjugate)
+              blockAt[rii] = -lhs(k, i).imag();
+            else
+              blockAt[rii] =  lhs(k, i).imag();
+          } else {
+            blockAt[rir] = lhs(i, k).real();
+
+            if(Conjugate)
+              blockAt[rii] = -lhs(i, k).imag();
+            else
+              blockAt[rii] =  lhs(i, k).imag();
+          }
+
+          rir += 1;
+          rii += 1;
+        }
+      }
+    }
+  }
+};
+
+// General template for lhs & rhs packing.
+template<typename Scalar, typename Index, typename DataMapper, typename Packet, int StorageOrder, bool PanelMode, bool UseLhs>
+struct dhs_pack{
+  EIGEN_STRONG_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<Scalar>::vectorsize;
+    Index ri = 0, j = 0;
+
+    for(; j + vectorSize <= rows; j+=vectorSize)
+    {
+      Index i = 0;
+
+      if(PanelMode) ri += vectorSize*offset;
+
+      for(; i + vectorSize <= depth; i+=vectorSize)
+      {
+        PacketBlock<Packet,4> block;
+
+        if (UseLhs) {
+          bload<DataMapper, Packet, Index, 4, 0, StorageOrder>(block, lhs, j, i);
+        } else {
+          bload<DataMapper, Packet, Index, 4, 0, StorageOrder>(block, lhs, i, j);
+        }
+        if(((StorageOrder == RowMajor) && UseLhs) || ((StorageOrder == ColMajor) && !UseLhs))
+        {
+          ptranspose(block);
+        }
+
+        storeBlock<Scalar, Packet, Index>(blockA + ri, block);
+
+        ri += 4*vectorSize;
+      }
+      for(; i < depth; i++)
+      {
+        if(((StorageOrder == RowMajor) && UseLhs) || ((StorageOrder == ColMajor) && !UseLhs))
+        {
+          if (UseLhs) {
+            blockA[ri+0] = lhs(j+0, i);
+            blockA[ri+1] = lhs(j+1, i);
+            blockA[ri+2] = lhs(j+2, i);
+            blockA[ri+3] = lhs(j+3, i);
+          } else {
+            blockA[ri+0] = lhs(i, j+0);
+            blockA[ri+1] = lhs(i, j+1);
+            blockA[ri+2] = lhs(i, j+2);
+            blockA[ri+3] = lhs(i, j+3);
+          }
+        } else {
+          Packet lhsV;
+          if (UseLhs) {
+            lhsV = lhs.template loadPacket<Packet>(j, i);
+          } else {
+            lhsV = lhs.template loadPacket<Packet>(i, j);
+          }
+          pstore<Scalar>(blockA + ri, lhsV);
+        }
+
+        ri += vectorSize;
+      }
+
+      if(PanelMode) ri += vectorSize*(stride - offset - depth);
+    }
+
+    if (j < rows)
+    {
+      if(PanelMode) ri += offset*(rows - j);
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < rows; k++)
+        {
+          if (UseLhs) {
+            blockA[ri] = lhs(k, i);
+          } else {
+            blockA[ri] = lhs(i, k);
+          }
+          ri += 1;
+        }
+      }
+    }
+  }
+};
+
+// General template for lhs packing, float64 specialization.
+template<typename Index, typename DataMapper, int StorageOrder, bool PanelMode>
+struct dhs_pack<double, Index, DataMapper, Packet2d, StorageOrder, PanelMode, true>
+{
+  EIGEN_STRONG_INLINE void operator()(double* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<double>::vectorsize;
+    Index ri = 0, j = 0;
+
+    for(; j + vectorSize <= rows; j+=vectorSize)
+    {
+      Index i = 0;
+
+      if(PanelMode) ri += vectorSize*offset;
+
+      for(; i + vectorSize <= depth; i+=vectorSize)
+      {
+        PacketBlock<Packet2d,2> block;
+        if(StorageOrder == RowMajor)
+        {
+          block.packet[0] = lhs.template loadPacket<Packet2d>(j + 0, i);
+          block.packet[1] = lhs.template loadPacket<Packet2d>(j + 1, i);
+
+          ptranspose(block);
+        } else {
+          block.packet[0] = lhs.template loadPacket<Packet2d>(j, i + 0);
+          block.packet[1] = lhs.template loadPacket<Packet2d>(j, i + 1);
+        }
+
+        storeBlock<double, Packet2d, Index>(blockA + ri, block);
+
+        ri += 2*vectorSize;
+      }
+      for(; i < depth; i++)
+      {
+        if(StorageOrder == RowMajor)
+        {
+          blockA[ri+0] = lhs(j+0, i);
+          blockA[ri+1] = lhs(j+1, i);
+        } else {
+          Packet2d lhsV = lhs.template loadPacket<Packet2d>(j, i);
+          pstore<double>(blockA + ri, lhsV);
+        }
+
+        ri += vectorSize;
+      }
+
+      if(PanelMode) ri += vectorSize*(stride - offset - depth);
+    }
+
+    if (j < rows)
+    {
+      if(PanelMode) ri += offset*(rows - j);
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < rows; k++)
+        {
+          blockA[ri] = lhs(k, i);
+          ri += 1;
+        }
+      }
+    }
+  }
+};
+
+// General template for rhs packing, float64 specialization.
+template<typename Index, typename DataMapper, int StorageOrder, bool PanelMode>
+struct dhs_pack<double, Index, DataMapper, Packet2d, StorageOrder, PanelMode, false>
+{
+  EIGEN_STRONG_INLINE void operator()(double* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<double>::vectorsize;
+    Index ri = 0, j = 0;
+
+    for(; j + 2*vectorSize <= cols; j+=2*vectorSize)
+    {
+      Index i = 0;
+
+      if(PanelMode) ri += offset*(2*vectorSize);
+
+      for(; i + vectorSize <= depth; i+=vectorSize)
+      {
+        PacketBlock<Packet2d,4> block;
+        if(StorageOrder == ColMajor)
+        {
+          PacketBlock<Packet2d,2> block1, block2;
+          block1.packet[0] = rhs.template loadPacket<Packet2d>(i, j + 0);
+          block1.packet[1] = rhs.template loadPacket<Packet2d>(i, j + 1);
+          block2.packet[0] = rhs.template loadPacket<Packet2d>(i, j + 2);
+          block2.packet[1] = rhs.template loadPacket<Packet2d>(i, j + 3);
+
+          ptranspose(block1);
+          ptranspose(block2);
+
+          pstore<double>(blockB + ri    , block1.packet[0]);
+          pstore<double>(blockB + ri + 2, block2.packet[0]);
+          pstore<double>(blockB + ri + 4, block1.packet[1]);
+          pstore<double>(blockB + ri + 6, block2.packet[1]);
+        } else {
+          block.packet[0] = rhs.template loadPacket<Packet2d>(i + 0, j + 0); //[a1 a2]
+          block.packet[1] = rhs.template loadPacket<Packet2d>(i + 0, j + 2); //[a3 a4]
+          block.packet[2] = rhs.template loadPacket<Packet2d>(i + 1, j + 0); //[b1 b2]
+          block.packet[3] = rhs.template loadPacket<Packet2d>(i + 1, j + 2); //[b3 b4]
+
+          storeBlock<double, Packet2d, Index>(blockB + ri, block);
+        }
+
+        ri += 4*vectorSize;
+      }
+      for(; i < depth; i++)
+      {
+        if(StorageOrder == ColMajor)
+        {
+          blockB[ri+0] = rhs(i, j+0);
+          blockB[ri+1] = rhs(i, j+1);
+
+          ri += vectorSize;
+
+          blockB[ri+0] = rhs(i, j+2);
+          blockB[ri+1] = rhs(i, j+3);
+        } else {
+          Packet2d rhsV = rhs.template loadPacket<Packet2d>(i, j);
+          pstore<double>(blockB + ri, rhsV);
+
+          ri += vectorSize;
+
+          rhsV = rhs.template loadPacket<Packet2d>(i, j + 2);
+          pstore<double>(blockB + ri, rhsV);
+        }
+        ri += vectorSize;
+      }
+
+      if(PanelMode) ri += (2*vectorSize)*(stride - offset - depth);
+    }
+
+    if (j < cols)
+    {
+      if(PanelMode) ri += offset*(cols - j);
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < cols; k++)
+        {
+          blockB[ri] = rhs(i, k);
+          ri += 1;
+        }
+      }
+    }
+  }
+};
+
+// General template for lhs complex packing, float64 specialization.
+template<typename Index, typename DataMapper, typename Packet, typename PacketC, int StorageOrder, bool Conjugate, bool PanelMode>
+struct dhs_cpack<double, Index, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, true>
+{
+  EIGEN_STRONG_INLINE void operator()(std::complex<double>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<double>::vectorsize;
+    const Index vectorDelta = vectorSize * ((PanelMode) ? stride : depth);
+    Index rir = ((PanelMode) ? (vectorSize*offset) : 0), rii;
+    double* blockAt = reinterpret_cast<double *>(blockA);
+    Index j = 0;
+
+    for(; j + vectorSize <= rows; j+=vectorSize)
+    {
+      Index i = 0;
+
+      rii = rir + vectorDelta;
+
+      for(; i + vectorSize <= depth; i+=vectorSize)
+      {
+        PacketBlock<Packet,2> blockr, blocki;
+        PacketBlock<PacketC,4> cblock;
+
+        if(StorageOrder == ColMajor)
+        {
+          cblock.packet[0] = lhs.template loadPacket<PacketC>(j, i + 0); //[a1 a1i]
+          cblock.packet[1] = lhs.template loadPacket<PacketC>(j, i + 1); //[b1 b1i]
+
+          cblock.packet[2] = lhs.template loadPacket<PacketC>(j + 1, i + 0); //[a2 a2i]
+          cblock.packet[3] = lhs.template loadPacket<PacketC>(j + 1, i + 1); //[b2 b2i]
+
+          blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[2].v, p16uc_GETREAL64); //[a1 a2]
+          blockr.packet[1] = vec_perm(cblock.packet[1].v, cblock.packet[3].v, p16uc_GETREAL64); //[b1 b2]
+
+          blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[2].v, p16uc_GETIMAG64);
+          blocki.packet[1] = vec_perm(cblock.packet[1].v, cblock.packet[3].v, p16uc_GETIMAG64);
+        } else {
+          cblock.packet[0] = lhs.template loadPacket<PacketC>(j + 0, i); //[a1 a1i]
+          cblock.packet[1] = lhs.template loadPacket<PacketC>(j + 1, i); //[a2 a2i]
+
+          cblock.packet[2] = lhs.template loadPacket<PacketC>(j + 0, i + 1); //[b1 b1i]
+          cblock.packet[3] = lhs.template loadPacket<PacketC>(j + 1, i + 1); //[b2 b2i
+
+          blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETREAL64); //[a1 a2]
+          blockr.packet[1] = vec_perm(cblock.packet[2].v, cblock.packet[3].v, p16uc_GETREAL64); //[b1 b2]
+
+          blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETIMAG64);
+          blocki.packet[1] = vec_perm(cblock.packet[2].v, cblock.packet[3].v, p16uc_GETIMAG64);
+        }
+
+        if(Conjugate)
+        {
+          blocki.packet[0] = -blocki.packet[0];
+          blocki.packet[1] = -blocki.packet[1];
+        }
+
+        storeBlock<double, Packet, Index>(blockAt + rir, blockr);
+        storeBlock<double, Packet, Index>(blockAt + rii, blocki);
+
+        rir += 2*vectorSize;
+        rii += 2*vectorSize;
+      }
+      for(; i < depth; i++)
+      {
+        PacketBlock<Packet,1> blockr, blocki;
+        PacketBlock<PacketC,2> cblock;
+
+        cblock.packet[0] = lhs.template loadPacket<PacketC>(j + 0, i);
+        cblock.packet[1] = lhs.template loadPacket<PacketC>(j + 1, i);
+
+        blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETREAL64);
+        blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETIMAG64);
+
+        if(Conjugate)
+        {
+          blocki.packet[0] = -blocki.packet[0];
+        }
+
+        pstore<double>(blockAt + rir, blockr.packet[0]);
+        pstore<double>(blockAt + rii, blocki.packet[0]);
+
+        rir += vectorSize;
+        rii += vectorSize;
+      }
+
+      rir += ((PanelMode) ? (vectorSize*(2*stride - depth)) : vectorDelta);
+    }
+
+    if (j < rows)
+    {
+      if(PanelMode) rir += (offset*(rows - j - vectorSize));
+      rii = rir + (((PanelMode) ? stride : depth) * (rows - j));
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < rows; k++)
+        {
+          blockAt[rir] = lhs(k, i).real();
+
+          if(Conjugate)
+            blockAt[rii] = -lhs(k, i).imag();
+          else
+            blockAt[rii] =  lhs(k, i).imag();
+
+          rir += 1;
+          rii += 1;
+        }
+      }
+    }
+  }
+};
+
+// General template for rhs complex packing, float64 specialization.
+template<typename Index, typename DataMapper, typename Packet, typename PacketC, int StorageOrder, bool Conjugate, bool PanelMode>
+struct dhs_cpack<double, Index, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, false>
+{
+  EIGEN_STRONG_INLINE void operator()(std::complex<double>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<double>::vectorsize;
+    const Index vectorDelta = 2*vectorSize * ((PanelMode) ? stride : depth);
+    Index rir = ((PanelMode) ? (2*vectorSize*offset) : 0), rii;
+    double* blockBt = reinterpret_cast<double *>(blockB);
+    Index j = 0;
+
+    for(; j + 2*vectorSize <= cols; j+=2*vectorSize)
+    {
+      Index i = 0;
+
+      rii = rir + vectorDelta;
+
+      for(; i < depth; i++)
+      {
+        PacketBlock<PacketC,4> cblock;
+        PacketBlock<Packet,2> blockr, blocki;
+
+        bload<DataMapper, PacketC, Index, 2, 0, ColMajor>(cblock, rhs, i, j);
+
+        blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETREAL64);
+        blockr.packet[1] = vec_perm(cblock.packet[2].v, cblock.packet[3].v, p16uc_GETREAL64);
+
+        blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETIMAG64);
+        blocki.packet[1] = vec_perm(cblock.packet[2].v, cblock.packet[3].v, p16uc_GETIMAG64);
+
+        if(Conjugate)
+        {
+          blocki.packet[0] = -blocki.packet[0];
+          blocki.packet[1] = -blocki.packet[1];
+        }
+
+        storeBlock<double, Packet, Index>(blockBt + rir, blockr);
+        storeBlock<double, Packet, Index>(blockBt + rii, blocki);
+
+        rir += 2*vectorSize;
+        rii += 2*vectorSize;
+      }
+
+      rir += ((PanelMode) ? (2*vectorSize*(2*stride - depth)) : vectorDelta);
+    }
+
+    if (j < cols)
+    {
+      if(PanelMode) rir += (offset*(cols - j - 2*vectorSize));
+      rii = rir + (((PanelMode) ? stride : depth) * (cols - j));
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < cols; k++)
+        {
+          blockBt[rir] = rhs(i, k).real();
+
+          if(Conjugate)
+            blockBt[rii] = -rhs(i, k).imag();
+          else
+            blockBt[rii] =  rhs(i, k).imag();
+
+          rir += 1;
+          rii += 1;
+        }
+      }
+    }
+  }
+};
+
+/**************
+ * GEMM utils *
+ **************/
+
+// 512-bits rank1-update of acc. It can either positive or negative accumulate (useful for complex gemm).
+template<typename Packet, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pger_common(PacketBlock<Packet,4>* acc, const Packet& lhsV, const Packet* rhsV)
+{
+  if(NegativeAccumulate)
+  {
+    acc->packet[0] = vec_nmsub(lhsV, rhsV[0], acc->packet[0]);
+    acc->packet[1] = vec_nmsub(lhsV, rhsV[1], acc->packet[1]);
+    acc->packet[2] = vec_nmsub(lhsV, rhsV[2], acc->packet[2]);
+    acc->packet[3] = vec_nmsub(lhsV, rhsV[3], acc->packet[3]);
+  } else {
+    acc->packet[0] = vec_madd(lhsV, rhsV[0], acc->packet[0]);
+    acc->packet[1] = vec_madd(lhsV, rhsV[1], acc->packet[1]);
+    acc->packet[2] = vec_madd(lhsV, rhsV[2], acc->packet[2]);
+    acc->packet[3] = vec_madd(lhsV, rhsV[3], acc->packet[3]);
+  }
+}
+
+template<typename Packet, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pger_common(PacketBlock<Packet,1>* acc, const Packet& lhsV, const Packet* rhsV)
+{
+  if(NegativeAccumulate)
+  {
+    acc->packet[0] = vec_nmsub(lhsV, rhsV[0], acc->packet[0]);
+  } else {
+    acc->packet[0] = vec_madd(lhsV, rhsV[0], acc->packet[0]);
+  }
+}
+
+template<int N, typename Scalar, typename Packet, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pger(PacketBlock<Packet,N>* acc, const Scalar* lhs, const Packet* rhsV)
+{
+  Packet lhsV = pload<Packet>(lhs);
+
+  pger_common<Packet, NegativeAccumulate>(acc, lhsV, rhsV);
+}
+
+template<typename Scalar, typename Packet, typename Index>
+EIGEN_ALWAYS_INLINE void loadPacketRemaining(const Scalar* lhs, Packet &lhsV, Index remaining_rows)
+{
+#ifdef _ARCH_PWR9
+  lhsV = vec_xl_len((Scalar *)lhs, remaining_rows * sizeof(Scalar));
+#else
+  Index i = 0;
+  do {
+    lhsV[i] = lhs[i];
+  } while (++i < remaining_rows);
+#endif
+}
+
+template<int N, typename Scalar, typename Packet, typename Index, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pger(PacketBlock<Packet,N>* acc, const Scalar* lhs, const Packet* rhsV, Index remaining_rows)
+{
+  Packet lhsV;
+  loadPacketRemaining<Scalar, Packet, Index>(lhs, lhsV, remaining_rows);
+
+  pger_common<Packet, NegativeAccumulate>(acc, lhsV, rhsV);
+}
+
+// 512-bits rank1-update of complex acc. It takes decoupled accumulators as entries. It also takes cares of mixed types real * complex and complex * real.
+template<int N, typename Packet, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void pgerc_common(PacketBlock<Packet,N>* accReal, PacketBlock<Packet,N>* accImag, const Packet &lhsV, const Packet &lhsVi, const Packet* rhsV, const Packet* rhsVi)
+{
+  pger_common<Packet, false>(accReal, lhsV, rhsV);
+  if(LhsIsReal)
+  {
+    pger_common<Packet, ConjugateRhs>(accImag, lhsV, rhsVi);
+    EIGEN_UNUSED_VARIABLE(lhsVi);
+  } else {
+    if (!RhsIsReal) {
+      pger_common<Packet, ConjugateLhs == ConjugateRhs>(accReal, lhsVi, rhsVi);
+      pger_common<Packet, ConjugateRhs>(accImag, lhsV, rhsVi);
+    } else {
+      EIGEN_UNUSED_VARIABLE(rhsVi);
+    }
+    pger_common<Packet, ConjugateLhs>(accImag, lhsVi, rhsV);
+  }
+}
+
+template<int N, typename Scalar, typename Packet, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void pgerc(PacketBlock<Packet,N>* accReal, PacketBlock<Packet,N>* accImag, const Scalar* lhs_ptr, const Scalar* lhs_ptr_imag, const Packet* rhsV, const Packet* rhsVi)
+{
+  Packet lhsV = ploadLhs<Scalar, Packet>(lhs_ptr);
+  Packet lhsVi;
+  if(!LhsIsReal) lhsVi = ploadLhs<Scalar, Packet>(lhs_ptr_imag);
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+
+  pgerc_common<N, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(accReal, accImag, lhsV, lhsVi, rhsV, rhsVi);
+}
+
+template<typename Scalar, typename Packet, typename Index, bool LhsIsReal>
+EIGEN_ALWAYS_INLINE void loadPacketRemaining(const Scalar* lhs_ptr, const Scalar* lhs_ptr_imag, Packet &lhsV, Packet &lhsVi, Index remaining_rows)
+{
+#ifdef _ARCH_PWR9
+  lhsV = vec_xl_len((Scalar *)lhs_ptr, remaining_rows * sizeof(Scalar));
+  if(!LhsIsReal) lhsVi = vec_xl_len((Scalar *)lhs_ptr_imag, remaining_rows * sizeof(Scalar));
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+#else
+  Index i = 0;
+  do {
+    lhsV[i] = lhs_ptr[i];
+    if(!LhsIsReal) lhsVi[i] = lhs_ptr_imag[i];
+  } while (++i < remaining_rows);
+  if(LhsIsReal) EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+#endif
+}
+
+template<int N, typename Scalar, typename Packet, typename Index, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void pgerc(PacketBlock<Packet,N>* accReal, PacketBlock<Packet,N>* accImag, const Scalar* lhs_ptr, const Scalar* lhs_ptr_imag, const Packet* rhsV, const Packet* rhsVi, Index remaining_rows)
+{
+  Packet lhsV, lhsVi;
+  loadPacketRemaining<Scalar, Packet, Index, LhsIsReal>(lhs_ptr, lhs_ptr_imag, lhsV, lhsVi, remaining_rows);
+
+  pgerc_common<N, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(accReal, accImag, lhsV, lhsVi, rhsV, rhsVi);
+}
+
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE Packet ploadLhs(const Scalar* lhs)
+{
+  return ploadu<Packet>(lhs);
+}
+
+// Zero the accumulator on PacketBlock.
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE void bsetzero(PacketBlock<Packet,4>& acc)
+{
+  acc.packet[0] = pset1<Packet>((Scalar)0);
+  acc.packet[1] = pset1<Packet>((Scalar)0);
+  acc.packet[2] = pset1<Packet>((Scalar)0);
+  acc.packet[3] = pset1<Packet>((Scalar)0);
+}
+
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE void bsetzero(PacketBlock<Packet,1>& acc)
+{
+  acc.packet[0] = pset1<Packet>((Scalar)0);
+}
+
+// Scale the PacketBlock vectors by alpha.
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscale(PacketBlock<Packet,4>& acc, PacketBlock<Packet,4>& accZ, const Packet& pAlpha)
+{
+  acc.packet[0] = pmadd(pAlpha, accZ.packet[0], acc.packet[0]);
+  acc.packet[1] = pmadd(pAlpha, accZ.packet[1], acc.packet[1]);
+  acc.packet[2] = pmadd(pAlpha, accZ.packet[2], acc.packet[2]);
+  acc.packet[3] = pmadd(pAlpha, accZ.packet[3], acc.packet[3]);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscale(PacketBlock<Packet,1>& acc, PacketBlock<Packet,1>& accZ, const Packet& pAlpha)
+{
+  acc.packet[0] = pmadd(pAlpha, accZ.packet[0], acc.packet[0]);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscalec_common(PacketBlock<Packet,4>& acc, PacketBlock<Packet,4>& accZ, const Packet& pAlpha)
+{
+  acc.packet[0] = pmul<Packet>(accZ.packet[0], pAlpha);
+  acc.packet[1] = pmul<Packet>(accZ.packet[1], pAlpha);
+  acc.packet[2] = pmul<Packet>(accZ.packet[2], pAlpha);
+  acc.packet[3] = pmul<Packet>(accZ.packet[3], pAlpha);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscalec_common(PacketBlock<Packet,1>& acc, PacketBlock<Packet,1>& accZ, const Packet& pAlpha)
+{
+  acc.packet[0] = pmul<Packet>(accZ.packet[0], pAlpha);
+}
+
+// Complex version of PacketBlock scaling.
+template<typename Packet, int N>
+EIGEN_ALWAYS_INLINE void bscalec(PacketBlock<Packet,N>& aReal, PacketBlock<Packet,N>& aImag, const Packet& bReal, const Packet& bImag, PacketBlock<Packet,N>& cReal, PacketBlock<Packet,N>& cImag)
+{
+  bscalec_common<Packet>(cReal, aReal, bReal);
+
+  bscalec_common<Packet>(cImag, aImag, bReal);
+
+  pger_common<Packet, true>(&cReal, bImag, aImag.packet);
+
+  pger_common<Packet, false>(&cImag, bImag, aReal.packet);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void band(PacketBlock<Packet,4>& acc, const Packet& pMask)
+{
+  acc.packet[0] = pand(acc.packet[0], pMask);
+  acc.packet[1] = pand(acc.packet[1], pMask);
+  acc.packet[2] = pand(acc.packet[2], pMask);
+  acc.packet[3] = pand(acc.packet[3], pMask);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscalec(PacketBlock<Packet,4>& aReal, PacketBlock<Packet,4>& aImag, const Packet& bReal, const Packet& bImag, PacketBlock<Packet,4>& cReal, PacketBlock<Packet,4>& cImag, const Packet& pMask)
+{
+  band<Packet>(aReal, pMask);
+  band<Packet>(aImag, pMask);
+
+  bscalec<Packet,4>(aReal, aImag, bReal, bImag, cReal, cImag);
+}
+
+// Load a PacketBlock, the N parameters make tunning gemm easier so we can add more accumulators as needed.
+template<typename DataMapper, typename Packet, typename Index, const Index accCols, int N, int StorageOrder>
+EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet,4>& acc, const DataMapper& res, Index row, Index col)
+{
+  if (StorageOrder == RowMajor) {
+    acc.packet[0] = res.template loadPacket<Packet>(row + 0, col + N*accCols);
+    acc.packet[1] = res.template loadPacket<Packet>(row + 1, col + N*accCols);
+    acc.packet[2] = res.template loadPacket<Packet>(row + 2, col + N*accCols);
+    acc.packet[3] = res.template loadPacket<Packet>(row + 3, col + N*accCols);
+  } else {
+    acc.packet[0] = res.template loadPacket<Packet>(row + N*accCols, col + 0);
+    acc.packet[1] = res.template loadPacket<Packet>(row + N*accCols, col + 1);
+    acc.packet[2] = res.template loadPacket<Packet>(row + N*accCols, col + 2);
+    acc.packet[3] = res.template loadPacket<Packet>(row + N*accCols, col + 3);
+  }
+}
+
+// An overload of bload when you have a PacketBLock with 8 vectors.
+template<typename DataMapper, typename Packet, typename Index, const Index accCols, int N, int StorageOrder>
+EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet,8>& acc, const DataMapper& res, Index row, Index col)
+{
+  if (StorageOrder == RowMajor) {
+    acc.packet[0] = res.template loadPacket<Packet>(row + 0, col + N*accCols);
+    acc.packet[1] = res.template loadPacket<Packet>(row + 1, col + N*accCols);
+    acc.packet[2] = res.template loadPacket<Packet>(row + 2, col + N*accCols);
+    acc.packet[3] = res.template loadPacket<Packet>(row + 3, col + N*accCols);
+    acc.packet[4] = res.template loadPacket<Packet>(row + 0, col + (N+1)*accCols);
+    acc.packet[5] = res.template loadPacket<Packet>(row + 1, col + (N+1)*accCols);
+    acc.packet[6] = res.template loadPacket<Packet>(row + 2, col + (N+1)*accCols);
+    acc.packet[7] = res.template loadPacket<Packet>(row + 3, col + (N+1)*accCols);
+  } else {
+    acc.packet[0] = res.template loadPacket<Packet>(row + N*accCols, col + 0);
+    acc.packet[1] = res.template loadPacket<Packet>(row + N*accCols, col + 1);
+    acc.packet[2] = res.template loadPacket<Packet>(row + N*accCols, col + 2);
+    acc.packet[3] = res.template loadPacket<Packet>(row + N*accCols, col + 3);
+    acc.packet[4] = res.template loadPacket<Packet>(row + (N+1)*accCols, col + 0);
+    acc.packet[5] = res.template loadPacket<Packet>(row + (N+1)*accCols, col + 1);
+    acc.packet[6] = res.template loadPacket<Packet>(row + (N+1)*accCols, col + 2);
+    acc.packet[7] = res.template loadPacket<Packet>(row + (N+1)*accCols, col + 3);
+  }
+}
+
+template<typename DataMapper, typename Packet, typename Index, const Index accCols, int N, int StorageOrder>
+EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet,2>& acc, const DataMapper& res, Index row, Index col)
+{
+  acc.packet[0] = res.template loadPacket<Packet>(row + N*accCols, col + 0);
+  acc.packet[1] = res.template loadPacket<Packet>(row + (N+1)*accCols, col + 0);
+}
+
+const static Packet4i mask41 = { -1,  0,  0,  0 };
+const static Packet4i mask42 = { -1, -1,  0,  0 };
+const static Packet4i mask43 = { -1, -1, -1,  0 };
+
+const static Packet2l mask21 = { -1, 0 };
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE Packet bmask(const int remaining_rows)
+{
+  if (remaining_rows == 0) {
+    return pset1<Packet>(float(0.0));  // Not used
+  } else {
+    switch (remaining_rows) {
+      case 1:  return Packet(mask41);
+      case 2:  return Packet(mask42);
+      default: return Packet(mask43);
+    }
+  }
+}
+
+template<>
+EIGEN_ALWAYS_INLINE Packet2d bmask<Packet2d>(const int remaining_rows)
+{
+  if (remaining_rows == 0) {
+    return pset1<Packet2d>(double(0.0));  // Not used
+  } else {
+    return Packet2d(mask21);
+  }
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscale(PacketBlock<Packet,4>& acc, PacketBlock<Packet,4>& accZ, const Packet& pAlpha, const Packet& pMask)
+{
+  band<Packet>(accZ, pMask);
+
+  bscale<Packet>(acc, accZ, pAlpha);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void pbroadcast4_old(const __UNPACK_TYPE__(Packet)* a, Packet& a0, Packet& a1, Packet& a2, Packet& a3)
+{
+  pbroadcast4<Packet>(a, a0, a1, a2, a3);
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void pbroadcast4_old<Packet2d>(const double* a, Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+  a1 = pload<Packet2d>(a);
+  a3 = pload<Packet2d>(a + 2);
+  a0 = vec_splat(a1, 0);
+  a1 = vec_splat(a1, 1);
+  a2 = vec_splat(a3, 0);
+  a3 = vec_splat(a3, 1);
+}
+
+// PEEL loop factor.
+#define PEEL 7
+
+template<typename Scalar, typename Packet, typename Index>
+EIGEN_ALWAYS_INLINE void MICRO_EXTRA_COL(
+  const Scalar* &lhs_ptr,
+  const Scalar* &rhs_ptr,
+  PacketBlock<Packet,1> &accZero,
+  Index remaining_rows,
+  Index remaining_cols)
+{
+  Packet rhsV[1];
+  rhsV[0] = pset1<Packet>(rhs_ptr[0]);
+  pger<1,Scalar, Packet, false>(&accZero, lhs_ptr, rhsV);
+  lhs_ptr += remaining_rows;
+  rhs_ptr += remaining_cols;
+}
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accRows>
+EIGEN_STRONG_INLINE void gemm_extra_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index row,
+  Index col,
+  Index remaining_rows,
+  Index remaining_cols,
+  const Packet& pAlpha)
+{
+  const Scalar* rhs_ptr = rhs_base;
+  const Scalar* lhs_ptr = lhs_base + row*strideA + remaining_rows*offsetA;
+  PacketBlock<Packet,1> accZero;
+
+  bsetzero<Scalar, Packet>(accZero);
+
+  Index remaining_depth = (depth & -accRows);
+  Index k = 0;
+  for(; k + PEEL <= remaining_depth; k+= PEEL)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr);
+    EIGEN_POWER_PREFETCH(lhs_ptr);
+    for (int l = 0; l < PEEL; l++) {
+      MICRO_EXTRA_COL<Scalar, Packet, Index>(lhs_ptr, rhs_ptr, accZero, remaining_rows, remaining_cols);
+    }
+  }
+  for(; k < remaining_depth; k++)
+  {
+    MICRO_EXTRA_COL<Scalar, Packet, Index>(lhs_ptr, rhs_ptr, accZero, remaining_rows, remaining_cols);
+  }
+  for(; k < depth; k++)
+  {
+    Packet rhsV[1];
+    rhsV[0] = pset1<Packet>(rhs_ptr[0]);
+    pger<1, Scalar, Packet, Index, false>(&accZero, lhs_ptr, rhsV, remaining_rows);
+    lhs_ptr += remaining_rows;
+    rhs_ptr += remaining_cols;
+  }
+
+  accZero.packet[0] = vec_mul(pAlpha, accZero.packet[0]);
+  for(Index i = 0; i < remaining_rows; i++) {
+    res(row + i, col) += accZero.packet[0][i];
+  }
+}
+
+template<typename Scalar, typename Packet, typename Index, const Index accRows>
+EIGEN_ALWAYS_INLINE void MICRO_EXTRA_ROW(
+  const Scalar* &lhs_ptr,
+  const Scalar* &rhs_ptr,
+  PacketBlock<Packet,4> &accZero,
+  Index remaining_rows)
+{
+  Packet rhsV[4];
+  pbroadcast4<Packet>(rhs_ptr, rhsV[0], rhsV[1], rhsV[2], rhsV[3]);
+  pger<4, Scalar, Packet, false>(&accZero, lhs_ptr, rhsV);
+  lhs_ptr += remaining_rows;
+  rhs_ptr += accRows;
+}
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accRows, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_extra_row(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index row,
+  Index col,
+  Index rows,
+  Index cols,
+  Index remaining_rows,
+  const Packet& pAlpha,
+  const Packet& pMask)
+{
+  const Scalar* rhs_ptr = rhs_base;
+  const Scalar* lhs_ptr = lhs_base + row*strideA + remaining_rows*offsetA;
+  PacketBlock<Packet,4> accZero, acc;
+
+  bsetzero<Scalar, Packet>(accZero);
+
+  Index remaining_depth = (col + accRows < cols) ? depth : (depth & -accRows);
+  Index k = 0;
+  for(; k + PEEL <= remaining_depth; k+= PEEL)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr);
+    EIGEN_POWER_PREFETCH(lhs_ptr);
+    for (int l = 0; l < PEEL; l++) {
+      MICRO_EXTRA_ROW<Scalar, Packet, Index, accRows>(lhs_ptr, rhs_ptr, accZero, remaining_rows);
+    }
+  }
+  for(; k < remaining_depth; k++)
+  {
+    MICRO_EXTRA_ROW<Scalar, Packet, Index, accRows>(lhs_ptr, rhs_ptr, accZero, remaining_rows);
+  }
+
+  if ((remaining_depth == depth) && (rows >= accCols))
+  {
+    for(Index j = 0; j < 4; j++) {
+      acc.packet[j] = res.template loadPacket<Packet>(row, col + j);
+    }
+    bscale<Packet>(acc, accZero, pAlpha, pMask);
+    res.template storePacketBlock<Packet,4>(row, col, acc);
+  } else {
+    for(; k < depth; k++)
+    {
+      Packet rhsV[4];
+      pbroadcast4<Packet>(rhs_ptr, rhsV[0], rhsV[1], rhsV[2], rhsV[3]);
+      pger<4, Scalar, Packet, Index, false>(&accZero, lhs_ptr, rhsV, remaining_rows);
+      lhs_ptr += remaining_rows;
+      rhs_ptr += accRows;
+    }
+
+    for(Index j = 0; j < 4; j++) {
+      accZero.packet[j] = vec_mul(pAlpha, accZero.packet[j]);
+    }
+    for(Index j = 0; j < 4; j++) {
+      for(Index i = 0; i < remaining_rows; i++) {
+        res(row + i, col + j) += accZero.packet[j][i];
+      }
+    }
+  }
+}
+
+#define MICRO_UNROLL(func) \
+  func(0) func(1) func(2) func(3) func(4) func(5) func(6) func(7)
+
+#define MICRO_UNROLL_WORK(func, func2, peel) \
+    MICRO_UNROLL(func2); \
+    func(0,peel) func(1,peel) func(2,peel) func(3,peel) \
+    func(4,peel) func(5,peel) func(6,peel) func(7,peel)
+
+#define MICRO_LOAD_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhsV##iter = ploadLhs<Scalar, Packet>(lhs_ptr##iter); \
+    lhs_ptr##iter += accCols; \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhsV##iter); \
+  }
+
+#define MICRO_WORK_ONE(iter, peel) \
+  if (unroll_factor > iter) { \
+    pger_common<Packet, false>(&accZero##iter, lhsV##iter, rhsV##peel); \
+  }
+
+#define MICRO_TYPE_PEEL4(func, func2, peel) \
+  if (PEEL > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4, lhsV5, lhsV6, lhsV7; \
+    pbroadcast4<Packet>(rhs_ptr + (accRows * peel), rhsV##peel[0], rhsV##peel[1], rhsV##peel[2], rhsV##peel[3]); \
+    MICRO_UNROLL_WORK(func, func2, peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+  }
+
+#define MICRO_TYPE_PEEL1(func, func2, peel) \
+  if (PEEL > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4, lhsV5, lhsV6, lhsV7; \
+    rhsV##peel[0] = pset1<Packet>(rhs_ptr[remaining_cols * peel]); \
+    MICRO_UNROLL_WORK(func, func2, peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+  }
+
+#define MICRO_UNROLL_TYPE_PEEL(M, func, func1, func2) \
+  Packet rhsV0[M], rhsV1[M], rhsV2[M], rhsV3[M], rhsV4[M], rhsV5[M], rhsV6[M], rhsV7[M], rhsV8[M], rhsV9[M]; \
+  func(func1,func2,0); func(func1,func2,1); \
+  func(func1,func2,2); func(func1,func2,3); \
+  func(func1,func2,4); func(func1,func2,5); \
+  func(func1,func2,6); func(func1,func2,7); \
+  func(func1,func2,8); func(func1,func2,9);
+
+#define MICRO_UNROLL_TYPE_ONE(M, func, func1, func2) \
+  Packet rhsV0[M]; \
+  func(func1,func2,0);
+
+#define MICRO_ONE_PEEL4 \
+  MICRO_UNROLL_TYPE_PEEL(4, MICRO_TYPE_PEEL4, MICRO_WORK_ONE, MICRO_LOAD_ONE); \
+  rhs_ptr += (accRows * PEEL);
+
+#define MICRO_ONE4 \
+  MICRO_UNROLL_TYPE_ONE(4, MICRO_TYPE_PEEL4, MICRO_WORK_ONE, MICRO_LOAD_ONE); \
+  rhs_ptr += accRows;
+
+#define MICRO_ONE_PEEL1 \
+  MICRO_UNROLL_TYPE_PEEL(1, MICRO_TYPE_PEEL1, MICRO_WORK_ONE, MICRO_LOAD_ONE); \
+  rhs_ptr += (remaining_cols * PEEL);
+
+#define MICRO_ONE1 \
+  MICRO_UNROLL_TYPE_ONE(1, MICRO_TYPE_PEEL1, MICRO_WORK_ONE, MICRO_LOAD_ONE); \
+  rhs_ptr += remaining_cols;
+
+#define MICRO_DST_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bsetzero<Scalar, Packet>(accZero##iter); \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(accZero##iter); \
+  }
+
+#define MICRO_DST_PTR MICRO_UNROLL(MICRO_DST_PTR_ONE)
+
+#define MICRO_SRC_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhs_ptr##iter = lhs_base + ( (row/accCols) + iter )*strideA*accCols + accCols*offsetA; \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr##iter); \
+  }
+
+#define MICRO_SRC_PTR MICRO_UNROLL(MICRO_SRC_PTR_ONE)
+
+#define MICRO_PREFETCH_ONE(iter) \
+  if (unroll_factor > iter) { \
+    EIGEN_POWER_PREFETCH(lhs_ptr##iter); \
+  }
+
+#define MICRO_PREFETCH MICRO_UNROLL(MICRO_PREFETCH_ONE)
+
+#define MICRO_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    acc.packet[0] = res.template loadPacket<Packet>(row + iter*accCols, col + 0); \
+    acc.packet[1] = res.template loadPacket<Packet>(row + iter*accCols, col + 1); \
+    acc.packet[2] = res.template loadPacket<Packet>(row + iter*accCols, col + 2); \
+    acc.packet[3] = res.template loadPacket<Packet>(row + iter*accCols, col + 3); \
+    bscale<Packet>(acc, accZero##iter, pAlpha); \
+    res.template storePacketBlock<Packet,4>(row + iter*accCols, col, acc); \
+  }
+
+#define MICRO_STORE MICRO_UNROLL(MICRO_STORE_ONE)
+
+#define MICRO_COL_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    acc.packet[0] = res.template loadPacket<Packet>(row + iter*accCols, col + 0); \
+    bscale<Packet>(acc, accZero##iter, pAlpha); \
+    res.template storePacketBlock<Packet,1>(row + iter*accCols, col, acc); \
+  }
+
+#define MICRO_COL_STORE MICRO_UNROLL(MICRO_COL_STORE_ONE)
+
+template<int unroll_factor, typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accRows, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_unrolled_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index& row,
+  Index col,
+  const Packet& pAlpha)
+{
+  const Scalar* rhs_ptr = rhs_base;
+  const Scalar* lhs_ptr0 = NULL, *  lhs_ptr1 = NULL, * lhs_ptr2 = NULL, * lhs_ptr3 = NULL, * lhs_ptr4 = NULL, * lhs_ptr5 = NULL, * lhs_ptr6 = NULL, * lhs_ptr7 = NULL;
+  PacketBlock<Packet,4> accZero0, accZero1, accZero2, accZero3, accZero4, accZero5, accZero6, accZero7;
+  PacketBlock<Packet,4> acc;
+
+  MICRO_SRC_PTR
+  MICRO_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL <= depth; k+= PEEL)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr);
+    MICRO_PREFETCH
+    MICRO_ONE_PEEL4
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_ONE4
+  }
+  MICRO_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<int unroll_factor, typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_unrolled_col_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index& row,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlpha)
+{
+  const Scalar* rhs_ptr = rhs_base;
+  const Scalar* lhs_ptr0 = NULL, * lhs_ptr1 = NULL, * lhs_ptr2 = NULL, * lhs_ptr3 = NULL, * lhs_ptr4 = NULL, * lhs_ptr5 = NULL, * lhs_ptr6 = NULL, *lhs_ptr7 = NULL;
+  PacketBlock<Packet,1> accZero0, accZero1, accZero2, accZero3, accZero4, accZero5, accZero6, accZero7;
+  PacketBlock<Packet,1> acc;
+
+  MICRO_SRC_PTR
+  MICRO_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL <= depth; k+= PEEL)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr);
+    MICRO_PREFETCH
+    MICRO_ONE_PEEL1
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_ONE1
+  }
+  MICRO_COL_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_unrolled_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index& row,
+  Index rows,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlpha)
+{
+#define MAX_UNROLL 6
+  while(row + MAX_UNROLL*accCols <= rows) {
+    gemm_unrolled_col_iteration<MAX_UNROLL, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+  }
+  switch( (rows-row)/accCols ) {
+#if MAX_UNROLL > 7
+    case 7:
+      gemm_unrolled_col_iteration<7, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+      break;
+#endif
+#if MAX_UNROLL > 6
+    case 6:
+      gemm_unrolled_col_iteration<6, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+      break;
+#endif
+#if MAX_UNROLL > 5
+   case 5:
+      gemm_unrolled_col_iteration<5, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+      break;
+#endif
+#if MAX_UNROLL > 4
+   case 4:
+      gemm_unrolled_col_iteration<4, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+      break;
+#endif
+#if MAX_UNROLL > 3
+   case 3:
+     gemm_unrolled_col_iteration<3, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+     break;
+#endif
+#if MAX_UNROLL > 2
+   case 2:
+     gemm_unrolled_col_iteration<2, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+     break;
+#endif
+#if MAX_UNROLL > 1
+   case 1:
+     gemm_unrolled_col_iteration<1, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+     break;
+#endif
+   default:
+     break;
+  }
+#undef MAX_UNROLL
+}
+
+/****************
+ * GEMM kernels *
+ * **************/
+template<typename Scalar, typename Index, typename Packet, typename RhsPacket, typename DataMapper, const Index accRows, const Index accCols>
+EIGEN_STRONG_INLINE void gemm(const DataMapper& res, const Scalar* blockA, const Scalar* blockB, Index rows, Index depth, Index cols, Scalar alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
+{
+      const Index remaining_rows = rows % accCols;
+      const Index remaining_cols = cols % accRows;
+
+      if( strideA == -1 ) strideA = depth;
+      if( strideB == -1 ) strideB = depth;
+
+      const Packet pAlpha = pset1<Packet>(alpha);
+      const Packet pMask  = bmask<Packet>((const int)(remaining_rows));
+
+      Index col = 0;
+      for(; col + accRows <= cols; col += accRows)
+      {
+        const Scalar* rhs_base = blockB + col*strideB + accRows*offsetB;
+        const Scalar* lhs_base = blockA;
+        Index row = 0;
+
+#define MAX_UNROLL 6
+        while(row + MAX_UNROLL*accCols <= rows) {
+          gemm_unrolled_iteration<MAX_UNROLL, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+        }
+        switch( (rows-row)/accCols ) {
+#if MAX_UNROLL > 7
+          case 7:
+            gemm_unrolled_iteration<7, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 6
+          case 6:
+            gemm_unrolled_iteration<6, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 5
+          case 5:
+            gemm_unrolled_iteration<5, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 4
+          case 4:
+            gemm_unrolled_iteration<4, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 3
+          case 3:
+            gemm_unrolled_iteration<3, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 2
+          case 2:
+            gemm_unrolled_iteration<2, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 1
+          case 1:
+            gemm_unrolled_iteration<1, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+          default:
+            break;
+        }
+#undef MAX_UNROLL
+
+        if(remaining_rows > 0)
+        {
+          gemm_extra_row<Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, rows, cols, remaining_rows, pAlpha, pMask);
+        }
+    }
+
+    if(remaining_cols > 0)
+    {
+      const Scalar* rhs_base = blockB + col*strideB + remaining_cols*offsetB;
+      const Scalar* lhs_base = blockA;
+
+      for(; col < cols; col++)
+      {
+        Index row = 0;
+
+        gemm_unrolled_col<Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, rows, col, remaining_cols, pAlpha);
+
+        if (remaining_rows > 0)
+        {
+          gemm_extra_col<Scalar, Packet, DataMapper, Index, accRows>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_rows, remaining_cols, pAlpha);
+        }
+        rhs_base++;
+      }
+    }
+}
+
+#define accColsC (accCols / 2)
+#define advanceRows ((LhsIsReal) ? 1 : 2)
+#define advanceCols ((RhsIsReal) ? 1 : 2)
+
+// PEEL_COMPLEX loop factor.
+#define PEEL_COMPLEX 3
+
+template<typename Scalar, typename Packet, typename Index, const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void MICRO_COMPLEX_EXTRA_COL(
+  const Scalar* &lhs_ptr_real, const Scalar* &lhs_ptr_imag,
+  const Scalar* &rhs_ptr_real, const Scalar* &rhs_ptr_imag,
+  PacketBlock<Packet,1> &accReal, PacketBlock<Packet,1> &accImag,
+  Index remaining_rows,
+  Index remaining_cols)
+{
+  Packet rhsV[1], rhsVi[1];
+  rhsV[0] = pset1<Packet>(rhs_ptr_real[0]);
+  if(!RhsIsReal) rhsVi[0] = pset1<Packet>(rhs_ptr_imag[0]);
+  pgerc<1, Scalar, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal, &accImag, lhs_ptr_real, lhs_ptr_imag, rhsV, rhsVi);
+  lhs_ptr_real += remaining_rows;
+  if(!LhsIsReal) lhs_ptr_imag += remaining_rows;
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+  rhs_ptr_real += remaining_cols;
+  if(!RhsIsReal) rhs_ptr_imag += remaining_cols;
+  else EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+}
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_extra_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index row,
+  Index col,
+  Index remaining_rows,
+  Index remaining_cols,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag)
+{
+  const Scalar* rhs_ptr_real = rhs_base;
+  const Scalar* rhs_ptr_imag;
+  if(!RhsIsReal) rhs_ptr_imag = rhs_base + remaining_cols*strideB;
+  else EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+  const Scalar* lhs_ptr_real = lhs_base + advanceRows*row*strideA + remaining_rows*offsetA;
+  const Scalar* lhs_ptr_imag;
+  if(!LhsIsReal) lhs_ptr_imag = lhs_ptr_real + remaining_rows*strideA;
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+  PacketBlock<Packet,1> accReal, accImag;
+  PacketBlock<Packet,1> taccReal, taccImag;
+  PacketBlock<Packetc,1> acc0, acc1;
+
+  bsetzero<Scalar, Packet>(accReal);
+  bsetzero<Scalar, Packet>(accImag);
+
+  Index remaining_depth = (depth & -accRows);
+  Index k = 0;
+  for(; k + PEEL_COMPLEX <= remaining_depth; k+= PEEL_COMPLEX)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr_real);
+    if(!RhsIsReal) {
+      EIGEN_POWER_PREFETCH(rhs_ptr_imag);
+    }
+    EIGEN_POWER_PREFETCH(lhs_ptr_real);
+    if(!LhsIsReal) {
+      EIGEN_POWER_PREFETCH(lhs_ptr_imag);
+    }
+    for (int l = 0; l < PEEL_COMPLEX; l++) {
+      MICRO_COMPLEX_EXTRA_COL<Scalar, Packet, Index, accRows, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(lhs_ptr_real, lhs_ptr_imag, rhs_ptr_real, rhs_ptr_imag, accReal, accImag, remaining_rows, remaining_cols);
+    }
+  }
+  for(; k < remaining_depth; k++)
+  {
+    MICRO_COMPLEX_EXTRA_COL<Scalar, Packet, Index, accRows, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(lhs_ptr_real, lhs_ptr_imag, rhs_ptr_real, rhs_ptr_imag, accReal, accImag, remaining_rows, remaining_cols);
+  }
+
+  for(; k < depth; k++)
+  {
+    Packet rhsV[1], rhsVi[1];
+    rhsV[0] = pset1<Packet>(rhs_ptr_real[0]);
+    if(!RhsIsReal) rhsVi[0] = pset1<Packet>(rhs_ptr_imag[0]);
+    pgerc<1, Scalar, Packet, Index, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal, &accImag, lhs_ptr_real, lhs_ptr_imag, rhsV, rhsVi, remaining_rows);
+    lhs_ptr_real += remaining_rows;
+    if(!LhsIsReal) lhs_ptr_imag += remaining_rows;
+    rhs_ptr_real += remaining_cols;
+    if(!RhsIsReal) rhs_ptr_imag += remaining_cols;
+  }
+
+  bscalec<Packet,1>(accReal, accImag, pAlphaReal, pAlphaImag, taccReal, taccImag);
+  bcouple_common<Packet, Packetc>(taccReal, taccImag, acc0, acc1);
+
+  if ((sizeof(Scalar) == sizeof(float)) && (remaining_rows == 1))
+  {
+    res(row + 0, col + 0) += pfirst<Packetc>(acc0.packet[0]);
+  } else {
+    acc0.packet[0] += res.template loadPacket<Packetc>(row + 0, col + 0);
+    res.template storePacketBlock<Packetc,1>(row + 0, col + 0, acc0);
+    if(remaining_rows > accColsC) {
+      res(row + accColsC, col + 0) += pfirst<Packetc>(acc1.packet[0]);
+    }
+  }
+}
+
+template<typename Scalar, typename Packet, typename Index, const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void MICRO_COMPLEX_EXTRA_ROW(
+  const Scalar* &lhs_ptr_real, const Scalar* &lhs_ptr_imag,
+  const Scalar* &rhs_ptr_real, const Scalar* &rhs_ptr_imag,
+  PacketBlock<Packet,4> &accReal, PacketBlock<Packet,4> &accImag,
+  Index remaining_rows)
+{
+  Packet rhsV[4], rhsVi[4];
+  pbroadcast4_old<Packet>(rhs_ptr_real, rhsV[0], rhsV[1], rhsV[2], rhsV[3]);
+  if(!RhsIsReal) pbroadcast4_old<Packet>(rhs_ptr_imag, rhsVi[0], rhsVi[1], rhsVi[2], rhsVi[3]);
+  pgerc<4, Scalar, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal, &accImag, lhs_ptr_real, lhs_ptr_imag, rhsV, rhsVi);
+  lhs_ptr_real += remaining_rows;
+  if(!LhsIsReal) lhs_ptr_imag += remaining_rows;
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+  rhs_ptr_real += accRows;
+  if(!RhsIsReal) rhs_ptr_imag += accRows;
+  else EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+}
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_extra_row(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index row,
+  Index col,
+  Index rows,
+  Index cols,
+  Index remaining_rows,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag,
+  const Packet& pMask)
+{
+  const Scalar* rhs_ptr_real = rhs_base;
+  const Scalar* rhs_ptr_imag;
+  if(!RhsIsReal) rhs_ptr_imag = rhs_base + accRows*strideB;
+  else EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+  const Scalar* lhs_ptr_real = lhs_base + advanceRows*row*strideA + remaining_rows*offsetA;
+  const Scalar* lhs_ptr_imag;
+  if(!LhsIsReal) lhs_ptr_imag = lhs_ptr_real + remaining_rows*strideA;
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+  PacketBlock<Packet,4> accReal, accImag;
+  PacketBlock<Packet,4> taccReal, taccImag;
+  PacketBlock<Packetc,4> acc0, acc1;
+  PacketBlock<Packetc,8> tRes;
+
+  bsetzero<Scalar, Packet>(accReal);
+  bsetzero<Scalar, Packet>(accImag);
+
+  Index remaining_depth = (col + accRows < cols) ? depth : (depth & -accRows);
+  Index k = 0;
+  for(; k + PEEL_COMPLEX <= remaining_depth; k+= PEEL_COMPLEX)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr_real);
+    if(!RhsIsReal) {
+      EIGEN_POWER_PREFETCH(rhs_ptr_imag);
+    }
+    EIGEN_POWER_PREFETCH(lhs_ptr_real);
+    if(!LhsIsReal) {
+      EIGEN_POWER_PREFETCH(lhs_ptr_imag);
+    }
+    for (int l = 0; l < PEEL_COMPLEX; l++) {
+      MICRO_COMPLEX_EXTRA_ROW<Scalar, Packet, Index, accRows, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(lhs_ptr_real, lhs_ptr_imag, rhs_ptr_real, rhs_ptr_imag, accReal, accImag, remaining_rows);
+    }
+  }
+  for(; k < remaining_depth; k++)
+  {
+    MICRO_COMPLEX_EXTRA_ROW<Scalar, Packet, Index, accRows, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(lhs_ptr_real, lhs_ptr_imag, rhs_ptr_real, rhs_ptr_imag, accReal, accImag, remaining_rows);
+  }
+
+  if ((remaining_depth == depth) && (rows >= accCols))
+  {
+    bload<DataMapper, Packetc, Index, accColsC, 0, ColMajor>(tRes, res, row, col);
+    bscalec<Packet>(accReal, accImag, pAlphaReal, pAlphaImag, taccReal, taccImag, pMask);
+    bcouple<Packet, Packetc>(taccReal, taccImag, tRes, acc0, acc1);
+    res.template storePacketBlock<Packetc,4>(row + 0, col, acc0);
+    res.template storePacketBlock<Packetc,4>(row + accColsC, col, acc1);
+  } else {
+    for(; k < depth; k++)
+    {
+      Packet rhsV[4], rhsVi[4];
+      pbroadcast4_old<Packet>(rhs_ptr_real, rhsV[0], rhsV[1], rhsV[2], rhsV[3]);
+      if(!RhsIsReal) pbroadcast4_old<Packet>(rhs_ptr_imag, rhsVi[0], rhsVi[1], rhsVi[2], rhsVi[3]);
+      pgerc<4, Scalar, Packet, Index, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal, &accImag, lhs_ptr_real, lhs_ptr_imag, rhsV, rhsVi, remaining_rows);
+      lhs_ptr_real += remaining_rows;
+      if(!LhsIsReal) lhs_ptr_imag += remaining_rows;
+      rhs_ptr_real += accRows;
+      if(!RhsIsReal) rhs_ptr_imag += accRows;
+    }
+
+    bscalec<Packet,4>(accReal, accImag, pAlphaReal, pAlphaImag, taccReal, taccImag);
+    bcouple_common<Packet, Packetc>(taccReal, taccImag, acc0, acc1);
+
+    if ((sizeof(Scalar) == sizeof(float)) && (remaining_rows == 1))
+    {
+      for(Index j = 0; j < 4; j++) {
+        res(row + 0, col + j) += pfirst<Packetc>(acc0.packet[j]);
+      }
+    } else {
+      for(Index j = 0; j < 4; j++) {
+        PacketBlock<Packetc,1> acc2;
+        acc2.packet[0] = res.template loadPacket<Packetc>(row + 0, col + j) + acc0.packet[j];
+        res.template storePacketBlock<Packetc,1>(row + 0, col + j, acc2);
+        if(remaining_rows > accColsC) {
+          res(row + accColsC, col + j) += pfirst<Packetc>(acc1.packet[j]);
+        }
+      }
+    }
+  }
+}
+
+#define MICRO_COMPLEX_UNROLL(func) \
+  func(0) func(1) func(2) func(3) func(4)
+
+#define MICRO_COMPLEX_UNROLL_WORK(func, func2, peel) \
+    MICRO_COMPLEX_UNROLL(func2); \
+    func(0,peel) func(1,peel) func(2,peel) func(3,peel) func(4,peel)
+
+#define MICRO_COMPLEX_LOAD_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhsV##iter = ploadLhs<Scalar, Packet>(lhs_ptr_real##iter); \
+    lhs_ptr_real##iter += accCols; \
+    if(!LhsIsReal) { \
+      lhsVi##iter = ploadLhs<Scalar, Packet>(lhs_ptr_imag##iter); \
+      lhs_ptr_imag##iter += accCols; \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(lhsVi##iter); \
+    } \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhsV##iter); \
+    EIGEN_UNUSED_VARIABLE(lhsVi##iter); \
+  }
+
+#define MICRO_COMPLEX_WORK_ONE4(iter, peel) \
+  if (unroll_factor > iter) { \
+    pgerc_common<4, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal##iter, &accImag##iter, lhsV##iter, lhsVi##iter, rhsV##peel, rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_WORK_ONE1(iter, peel) \
+  if (unroll_factor > iter) { \
+    pgerc_common<1, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal##iter, &accImag##iter, lhsV##iter, lhsVi##iter, rhsV##peel, rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_TYPE_PEEL4(func, func2, peel) \
+  if (PEEL_COMPLEX > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4; \
+    Packet lhsVi0, lhsVi1, lhsVi2, lhsVi3, lhsVi4; \
+    pbroadcast4_old<Packet>(rhs_ptr_real + (accRows * peel), rhsV##peel[0], rhsV##peel[1], rhsV##peel[2], rhsV##peel[3]); \
+    if(!RhsIsReal) { \
+      pbroadcast4_old<Packet>(rhs_ptr_imag + (accRows * peel), rhsVi##peel[0], rhsVi##peel[1], rhsVi##peel[2], rhsVi##peel[3]); \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+    } \
+    MICRO_COMPLEX_UNROLL_WORK(func, func2, peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+    EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_TYPE_PEEL1(func, func2, peel) \
+  if (PEEL_COMPLEX > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4; \
+    Packet lhsVi0, lhsVi1, lhsVi2, lhsVi3, lhsVi4; \
+    rhsV##peel[0] = pset1<Packet>(rhs_ptr_real[remaining_cols * peel]); \
+    if(!RhsIsReal) { \
+      rhsVi##peel[0] = pset1<Packet>(rhs_ptr_imag[remaining_cols * peel]); \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+    } \
+    MICRO_COMPLEX_UNROLL_WORK(func, func2, peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+    EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_UNROLL_TYPE_PEEL(M, func, func1, func2) \
+  Packet rhsV0[M], rhsV1[M], rhsV2[M], rhsV3[M], rhsV4[M], rhsV5[M], rhsV6[M], rhsV7[M], rhsV8[M], rhsV9[M]; \
+  Packet rhsVi0[M], rhsVi1[M], rhsVi2[M], rhsVi3[M], rhsVi4[M], rhsVi5[M], rhsVi6[M], rhsVi7[M], rhsVi8[M], rhsVi9[M]; \
+  func(func1,func2,0); func(func1,func2,1); \
+  func(func1,func2,2); func(func1,func2,3); \
+  func(func1,func2,4); func(func1,func2,5); \
+  func(func1,func2,6); func(func1,func2,7); \
+  func(func1,func2,8); func(func1,func2,9);
+
+#define MICRO_COMPLEX_UNROLL_TYPE_ONE(M, func, func1, func2) \
+  Packet rhsV0[M], rhsVi0[M];\
+  func(func1,func2,0);
+
+#define MICRO_COMPLEX_ONE_PEEL4 \
+  MICRO_COMPLEX_UNROLL_TYPE_PEEL(4, MICRO_COMPLEX_TYPE_PEEL4, MICRO_COMPLEX_WORK_ONE4, MICRO_COMPLEX_LOAD_ONE); \
+  rhs_ptr_real += (accRows * PEEL_COMPLEX); \
+  if(!RhsIsReal) rhs_ptr_imag += (accRows * PEEL_COMPLEX);
+
+#define MICRO_COMPLEX_ONE4 \
+  MICRO_COMPLEX_UNROLL_TYPE_ONE(4, MICRO_COMPLEX_TYPE_PEEL4, MICRO_COMPLEX_WORK_ONE4, MICRO_COMPLEX_LOAD_ONE); \
+  rhs_ptr_real += accRows; \
+  if(!RhsIsReal) rhs_ptr_imag += accRows;
+
+#define MICRO_COMPLEX_ONE_PEEL1 \
+  MICRO_COMPLEX_UNROLL_TYPE_PEEL(1, MICRO_COMPLEX_TYPE_PEEL1, MICRO_COMPLEX_WORK_ONE1, MICRO_COMPLEX_LOAD_ONE); \
+  rhs_ptr_real += (remaining_cols * PEEL_COMPLEX); \
+  if(!RhsIsReal) rhs_ptr_imag += (remaining_cols * PEEL_COMPLEX);
+
+#define MICRO_COMPLEX_ONE1 \
+  MICRO_COMPLEX_UNROLL_TYPE_ONE(1, MICRO_COMPLEX_TYPE_PEEL1, MICRO_COMPLEX_WORK_ONE1, MICRO_COMPLEX_LOAD_ONE); \
+  rhs_ptr_real += remaining_cols; \
+  if(!RhsIsReal) rhs_ptr_imag += remaining_cols;
+
+#define MICRO_COMPLEX_DST_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bsetzero<Scalar, Packet>(accReal##iter); \
+    bsetzero<Scalar, Packet>(accImag##iter); \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(accReal##iter); \
+    EIGEN_UNUSED_VARIABLE(accImag##iter); \
+  }
+
+#define MICRO_COMPLEX_DST_PTR MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_DST_PTR_ONE)
+
+#define MICRO_COMPLEX_SRC_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhs_ptr_real##iter = lhs_base + ( ((advanceRows*row)/accCols) + iter*advanceRows )*strideA*accCols + accCols*offsetA; \
+    if(!LhsIsReal) { \
+      lhs_ptr_imag##iter = lhs_ptr_real##iter + accCols*strideA; \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(lhs_ptr_imag##iter); \
+    } \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr_real##iter); \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr_imag##iter); \
+  }
+
+#define MICRO_COMPLEX_SRC_PTR MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_SRC_PTR_ONE)
+
+#define MICRO_COMPLEX_PREFETCH_ONE(iter) \
+  if (unroll_factor > iter) { \
+    EIGEN_POWER_PREFETCH(lhs_ptr_real##iter); \
+    if(!LhsIsReal) { \
+      EIGEN_POWER_PREFETCH(lhs_ptr_imag##iter); \
+    } \
+  }
+
+#define MICRO_COMPLEX_PREFETCH MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_PREFETCH_ONE)
+
+#define MICRO_COMPLEX_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bload<DataMapper, Packetc, Index, accColsC, 0, ColMajor>(tRes, res, row + iter*accCols, col); \
+    bscalec<Packet,4>(accReal##iter, accImag##iter, pAlphaReal, pAlphaImag, taccReal, taccImag); \
+    bcouple<Packet, Packetc>(taccReal, taccImag, tRes, acc0, acc1); \
+    res.template storePacketBlock<Packetc,4>(row + iter*accCols + 0, col, acc0); \
+    res.template storePacketBlock<Packetc,4>(row + iter*accCols + accColsC, col, acc1); \
+  }
+
+#define MICRO_COMPLEX_STORE MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_STORE_ONE)
+
+#define MICRO_COMPLEX_COL_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bload<DataMapper, Packetc, Index, accColsC, 0, ColMajor>(tRes, res, row + iter*accCols, col); \
+    bscalec<Packet,1>(accReal##iter, accImag##iter, pAlphaReal, pAlphaImag, taccReal, taccImag); \
+    bcouple<Packet, Packetc>(taccReal, taccImag, tRes, acc0, acc1); \
+    res.template storePacketBlock<Packetc,1>(row + iter*accCols + 0, col, acc0); \
+    res.template storePacketBlock<Packetc,1>(row + iter*accCols + accColsC, col, acc1); \
+  }
+
+#define MICRO_COMPLEX_COL_STORE MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_COL_STORE_ONE)
+
+template<int unroll_factor, typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_unrolled_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index& row,
+  Index col,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag)
+{
+  const Scalar* rhs_ptr_real = rhs_base;
+  const Scalar* rhs_ptr_imag;
+  if(!RhsIsReal) {
+    rhs_ptr_imag = rhs_base + accRows*strideB;
+  } else {
+    EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+  }
+  const Scalar* lhs_ptr_real0 = NULL, * lhs_ptr_imag0 = NULL, * lhs_ptr_real1 = NULL, * lhs_ptr_imag1 = NULL;
+  const Scalar* lhs_ptr_real2 = NULL, * lhs_ptr_imag2 = NULL, * lhs_ptr_real3 = NULL, * lhs_ptr_imag3 = NULL;
+  const Scalar* lhs_ptr_real4 = NULL, * lhs_ptr_imag4 = NULL;
+  PacketBlock<Packet,4> accReal0, accImag0, accReal1, accImag1;
+  PacketBlock<Packet,4> accReal2, accImag2, accReal3, accImag3;
+  PacketBlock<Packet,4> accReal4, accImag4;
+  PacketBlock<Packet,4> taccReal, taccImag;
+  PacketBlock<Packetc,4> acc0, acc1;
+  PacketBlock<Packetc,8> tRes;
+
+  MICRO_COMPLEX_SRC_PTR
+  MICRO_COMPLEX_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL_COMPLEX <= depth; k+= PEEL_COMPLEX)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr_real);
+    if(!RhsIsReal) {
+      EIGEN_POWER_PREFETCH(rhs_ptr_imag);
+    }
+    MICRO_COMPLEX_PREFETCH
+    MICRO_COMPLEX_ONE_PEEL4
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_COMPLEX_ONE4
+  }
+  MICRO_COMPLEX_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<int unroll_factor, typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_unrolled_col_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index& row,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag)
+{
+  const Scalar* rhs_ptr_real = rhs_base;
+  const Scalar* rhs_ptr_imag;
+  if(!RhsIsReal) {
+    rhs_ptr_imag = rhs_base + remaining_cols*strideB;
+  } else {
+    EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+  }
+  const Scalar* lhs_ptr_real0 = NULL, * lhs_ptr_imag0 = NULL, * lhs_ptr_real1 = NULL, * lhs_ptr_imag1 = NULL;
+  const Scalar* lhs_ptr_real2 = NULL, * lhs_ptr_imag2 = NULL, * lhs_ptr_real3 = NULL, * lhs_ptr_imag3 = NULL;
+  const Scalar* lhs_ptr_real4 = NULL, * lhs_ptr_imag4 = NULL;
+  PacketBlock<Packet,1> accReal0, accImag0, accReal1, accImag1;
+  PacketBlock<Packet,1> accReal2, accImag2, accReal3, accImag3;
+  PacketBlock<Packet,1> accReal4, accImag4;
+  PacketBlock<Packet,1> taccReal, taccImag;
+  PacketBlock<Packetc,1> acc0, acc1;
+  PacketBlock<Packetc,2> tRes;
+
+  MICRO_COMPLEX_SRC_PTR
+  MICRO_COMPLEX_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL_COMPLEX <= depth; k+= PEEL_COMPLEX)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr_real);
+    if(!RhsIsReal) {
+      EIGEN_POWER_PREFETCH(rhs_ptr_imag);
+    }
+    MICRO_COMPLEX_PREFETCH
+    MICRO_COMPLEX_ONE_PEEL1
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_COMPLEX_ONE1
+  }
+  MICRO_COMPLEX_COL_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_unrolled_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index& row,
+  Index rows,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag)
+{
+#define MAX_COMPLEX_UNROLL 3
+  while(row + MAX_COMPLEX_UNROLL*accCols <= rows) {
+    gemm_complex_unrolled_col_iteration<MAX_COMPLEX_UNROLL, Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_cols, pAlphaReal, pAlphaImag);
+  }
+  switch( (rows-row)/accCols ) {
+#if MAX_COMPLEX_UNROLL > 4
+   case 4:
+     gemm_complex_unrolled_col_iteration<4, Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_cols, pAlphaReal, pAlphaImag);
+     break;
+#endif
+#if MAX_COMPLEX_UNROLL > 3
+   case 3:
+     gemm_complex_unrolled_col_iteration<3, Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_cols, pAlphaReal, pAlphaImag);
+     break;
+#endif
+#if MAX_COMPLEX_UNROLL > 2
+   case 2:
+     gemm_complex_unrolled_col_iteration<2, Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_cols, pAlphaReal, pAlphaImag);
+     break;
+#endif
+#if MAX_COMPLEX_UNROLL > 1
+   case 1:
+     gemm_complex_unrolled_col_iteration<1, Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_cols, pAlphaReal, pAlphaImag);
+     break;
+#endif
+   default:
+     break;
+  }
+#undef MAX_COMPLEX_UNROLL
+}
+
+template<typename LhsScalar, typename RhsScalar, typename Scalarc, typename Scalar, typename Index, typename Packet, typename Packetc, typename RhsPacket, typename DataMapper, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex(const DataMapper& res, const LhsScalar* blockAc, const RhsScalar* blockBc, Index rows, Index depth, Index cols, Scalarc alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
+{
+      const Index remaining_rows = rows % accCols;
+      const Index remaining_cols = cols % accRows;
+
+      if( strideA == -1 ) strideA = depth;
+      if( strideB == -1 ) strideB = depth;
+
+      const Packet pAlphaReal = pset1<Packet>(alpha.real());
+      const Packet pAlphaImag = pset1<Packet>(alpha.imag());
+      const Packet pMask = bmask<Packet>((const int)(remaining_rows));
+
+      const Scalar* blockA = (Scalar *) blockAc;
+      const Scalar* blockB = (Scalar *) blockBc;
+
+      Index col = 0;
+      for(; col + accRows <= cols; col += accRows)
+      {
+        const Scalar* rhs_base = blockB + advanceCols*col*strideB + accRows*offsetB;
+        const Scalar* lhs_base = blockA;
+        Index row = 0;
+
+#define MAX_COMPLEX_UNROLL 3
+        while(row + MAX_COMPLEX_UNROLL*accCols <= rows) {
+          gemm_complex_unrolled_iteration<MAX_COMPLEX_UNROLL, Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+        }
+        switch( (rows-row)/accCols ) {
+#if MAX_COMPLEX_UNROLL > 4
+          case 4:
+            gemm_complex_unrolled_iteration<4, Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_UNROLL > 3
+          case 3:
+            gemm_complex_unrolled_iteration<3, Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_UNROLL > 2
+          case 2:
+            gemm_complex_unrolled_iteration<2, Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_UNROLL > 1
+          case 1:
+            gemm_complex_unrolled_iteration<1, Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+          default:
+            break;
+        }
+#undef MAX_COMPLEX_UNROLL
+
+        if(remaining_rows > 0)
+        {
+          gemm_complex_extra_row<Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, rows, cols, remaining_rows, pAlphaReal, pAlphaImag, pMask);
+        }
+      }
+
+      if(remaining_cols > 0)
+      {
+        const Scalar* rhs_base = blockB + advanceCols*col*strideB + remaining_cols*offsetB;
+        const Scalar* lhs_base = blockA;
+
+        for(; col < cols; col++)
+        {
+          Index row = 0;
+
+          gemm_complex_unrolled_col<Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, rows, col, remaining_cols, pAlphaReal, pAlphaImag);
+
+          if (remaining_rows > 0)
+          {
+            gemm_complex_extra_col<Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_rows, remaining_cols, pAlphaReal, pAlphaImag);
+          }
+          rhs_base++;
+        }
+      }
+}
+
+#undef accColsC
+#undef advanceCols
+#undef advanceRows
+
+/************************************
+ * ppc64le template specializations *
+ * **********************************/
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<double, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(double* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<double, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+  ::operator()(double* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+    dhs_pack<double, Index, DataMapper, Packet2d, ColMajor, PanelMode, true> pack;
+    pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<double, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(double* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<double, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+  ::operator()(double* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+    dhs_pack<double, Index, DataMapper, Packet2d, RowMajor, PanelMode, true> pack;
+    pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+#if EIGEN_ALTIVEC_USE_CUSTOM_PACK
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<double, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(double* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<double, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(double* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_pack<double, Index, DataMapper, Packet2d, ColMajor, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<double, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(double* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<double, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+  ::operator()(double* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_pack<double, Index, DataMapper, Packet2d, RowMajor, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+#endif
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<float, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(float* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<float, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+  ::operator()(float* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_pack<float, Index, DataMapper, Packet4f, RowMajor, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<float, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(float* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<float, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+  ::operator()(float* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_pack<float, Index, DataMapper, Packet4f, ColMajor, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<std::complex<float>, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<float>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<std::complex<float>, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<float>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_cpack<float, Index, DataMapper, Packet4f, Packet2cf, RowMajor, Conjugate, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<std::complex<float>, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<float>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<std::complex<float>, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<float>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_cpack<float, Index, DataMapper, Packet4f, Packet2cf, ColMajor, Conjugate, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+#if EIGEN_ALTIVEC_USE_CUSTOM_PACK
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<float, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(float* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<float, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(float* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_pack<float, Index, DataMapper, Packet4f, ColMajor, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<float, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(float* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<float, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+  ::operator()(float* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_pack<float, Index, DataMapper, Packet4f, RowMajor, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+#endif
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<std::complex<float>, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<float>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<std::complex<float>, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<float>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_cpack<float, Index, DataMapper, Packet4f, Packet2cf, ColMajor, Conjugate, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<std::complex<float>, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<float>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<std::complex<float>, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<float>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_cpack<float, Index, DataMapper, Packet4f, Packet2cf, RowMajor, Conjugate, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<std::complex<double>, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<double>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<std::complex<double>, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<double>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_cpack<double, Index, DataMapper, Packet2d, Packet1cd, RowMajor, Conjugate, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<std::complex<double>, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<double>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<std::complex<double>, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<double>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_cpack<double, Index, DataMapper, Packet2d, Packet1cd, ColMajor, Conjugate, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<std::complex<double>, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<double>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<std::complex<double>, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<double>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_cpack<double, Index, DataMapper, Packet2d, Packet1cd, ColMajor, Conjugate, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<std::complex<double>, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<double>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<std::complex<double>, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<double>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_cpack<double, Index, DataMapper, Packet2d, Packet1cd, RowMajor, Conjugate, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+// ********* gebp specializations *********
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<float, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef typename quad_traits<float>::vectortype   Packet;
+  typedef typename quad_traits<float>::rhstype      RhsPacket;
+
+  void operator()(const DataMapper& res, const float* blockA, const float* blockB,
+                  Index rows, Index depth, Index cols, float alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<float, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const float* blockA, const float* blockB,
+               Index rows, Index depth, Index cols, float alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<float>::rows;
+    const Index accCols = quad_traits<float>::size;
+    void (*gemm_function)(const DataMapper&, const float*, const float*, Index, Index, Index, float, Index, Index, Index, Index);
+
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+      //generate with MMA only
+      gemm_function = &Eigen::internal::gemmMMA<float, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+    #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+      if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+        gemm_function = &Eigen::internal::gemmMMA<float, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+      }
+      else{
+        gemm_function = &Eigen::internal::gemm<float, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+      }
+    #else
+      gemm_function = &Eigen::internal::gemm<float, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+    #endif
+      gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<std::complex<float>, std::complex<float>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef Packet4f   Packet;
+  typedef Packet2cf  Packetc;
+  typedef Packet4f   RhsPacket;
+
+  void operator()(const DataMapper& res, const std::complex<float>* blockA, const std::complex<float>* blockB,
+                  Index rows, Index depth, Index cols, std::complex<float> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<std::complex<float>, std::complex<float>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const std::complex<float>* blockA, const std::complex<float>* blockB,
+               Index rows, Index depth, Index cols, std::complex<float> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<float>::rows;
+    const Index accCols = quad_traits<float>::size;
+    void (*gemm_function)(const DataMapper&, const std::complex<float>*, const std::complex<float>*,
+          Index, Index, Index, std::complex<float>, Index, Index, Index, Index);
+
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<float>, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<float>, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<std::complex<float>, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<std::complex<float>, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+     #endif
+      gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<float, std::complex<float>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef Packet4f   Packet;
+  typedef Packet2cf  Packetc;
+  typedef Packet4f   RhsPacket;
+
+  void operator()(const DataMapper& res, const float* blockA, const std::complex<float>* blockB,
+                  Index rows, Index depth, Index cols, std::complex<float> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<float, std::complex<float>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const float* blockA, const std::complex<float>* blockB,
+               Index rows, Index depth, Index cols, std::complex<float> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<float>::rows;
+    const Index accCols = quad_traits<float>::size;
+    void (*gemm_function)(const DataMapper&, const float*, const std::complex<float>*,
+          Index, Index, Index, std::complex<float>, Index, Index, Index, Index);
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<float, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<float, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<float, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<float, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+     #endif
+       gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<std::complex<float>, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef Packet4f   Packet;
+  typedef Packet2cf  Packetc;
+  typedef Packet4f   RhsPacket;
+
+  void operator()(const DataMapper& res, const std::complex<float>* blockA, const float* blockB,
+                  Index rows, Index depth, Index cols, std::complex<float> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<std::complex<float>, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const std::complex<float>* blockA, const float* blockB,
+               Index rows, Index depth, Index cols, std::complex<float> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<float>::rows;
+    const Index accCols = quad_traits<float>::size;
+    void (*gemm_function)(const DataMapper&, const std::complex<float>*, const float*,
+          Index, Index, Index, std::complex<float>, Index, Index, Index, Index);
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<float>, float, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<float>, float, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<std::complex<float>, float, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<std::complex<float>, float, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+     #endif
+       gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<double, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef typename quad_traits<double>::vectortype  Packet;
+  typedef typename quad_traits<double>::rhstype     RhsPacket;
+
+  void operator()(const DataMapper& res, const double* blockA, const double* blockB,
+                  Index rows, Index depth, Index cols, double alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<double, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const double* blockA, const double* blockB,
+               Index rows, Index depth, Index cols, double alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<double>::rows;
+    const Index accCols = quad_traits<double>::size;
+    void (*gemm_function)(const DataMapper&, const double*, const double*, Index, Index, Index, double, Index, Index, Index, Index);
+
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+      //generate with MMA only
+      gemm_function = &Eigen::internal::gemmMMA<double, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+    #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+      if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+        gemm_function = &Eigen::internal::gemmMMA<double, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+      }
+      else{
+        gemm_function = &Eigen::internal::gemm<double, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+      }
+    #else
+      gemm_function = &Eigen::internal::gemm<double, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+    #endif
+      gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<std::complex<double>, std::complex<double>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef quad_traits<double>::vectortype   Packet;
+  typedef Packet1cd  Packetc;
+  typedef quad_traits<double>::rhstype   RhsPacket;
+
+  void operator()(const DataMapper& res, const std::complex<double>* blockA, const std::complex<double>* blockB,
+                  Index rows, Index depth, Index cols, std::complex<double> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<std::complex<double>, std::complex<double>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const std::complex<double>* blockA, const std::complex<double>* blockB,
+               Index rows, Index depth, Index cols, std::complex<double> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<double>::rows;
+    const Index accCols = quad_traits<double>::size;
+    void (*gemm_function)(const DataMapper&, const std::complex<double>*, const std::complex<double>*,
+          Index, Index, Index, std::complex<double>, Index, Index, Index, Index);
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<double>, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<double>, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<std::complex<double>, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<std::complex<double>, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+     #endif
+       gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<std::complex<double>, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef quad_traits<double>::vectortype   Packet;
+  typedef Packet1cd  Packetc;
+  typedef quad_traits<double>::rhstype   RhsPacket;
+
+  void operator()(const DataMapper& res, const std::complex<double>* blockA, const double* blockB,
+                  Index rows, Index depth, Index cols, std::complex<double> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<std::complex<double>, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const std::complex<double>* blockA, const double* blockB,
+               Index rows, Index depth, Index cols, std::complex<double> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<double>::rows;
+    const Index accCols = quad_traits<double>::size;
+    void (*gemm_function)(const DataMapper&, const std::complex<double>*, const double*,
+          Index, Index, Index, std::complex<double>, Index, Index, Index, Index);
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<double>, double, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<double>, double, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<std::complex<double>, double, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<std::complex<double>, double, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+     #endif
+       gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<double, std::complex<double>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef quad_traits<double>::vectortype   Packet;
+  typedef Packet1cd  Packetc;
+  typedef quad_traits<double>::rhstype   RhsPacket;
+
+  void operator()(const DataMapper& res, const double* blockA, const std::complex<double>* blockB,
+                  Index rows, Index depth, Index cols, std::complex<double> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<double, std::complex<double>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const double* blockA, const std::complex<double>* blockB,
+               Index rows, Index depth, Index cols, std::complex<double> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<double>::rows;
+    const Index accCols = quad_traits<double>::size;
+    void (*gemm_function)(const DataMapper&, const double*, const std::complex<double>*,
+          Index, Index, Index, std::complex<double>, Index, Index, Index, Index);
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<double, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<double, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<double, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<double, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+     #endif
+       gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIX_PRODUCT_ALTIVEC_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
new file mode 100644
index 00000000..33d54349
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
@@ -0,0 +1,221 @@
+//#define EIGEN_POWER_USE_PREFETCH  // Use prefetching in gemm routines
+#ifdef EIGEN_POWER_USE_PREFETCH
+#define EIGEN_POWER_PREFETCH(p)  prefetch(p)
+#else
+#define EIGEN_POWER_PREFETCH(p)
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accRows>
+EIGEN_STRONG_INLINE void gemm_extra_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index row,
+  Index col,
+  Index remaining_rows,
+  Index remaining_cols,
+  const Packet& pAlpha);
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accRows, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_extra_row(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index row,
+  Index col,
+  Index rows,
+  Index cols,
+  Index remaining_rows,
+  const Packet& pAlpha,
+  const Packet& pMask);
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_unrolled_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index& row,
+  Index rows,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlpha);
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE Packet bmask(const int remaining_rows);
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_extra_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index row,
+  Index col,
+  Index remaining_rows,
+  Index remaining_cols,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag);
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_extra_row(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index row,
+  Index col,
+  Index rows,
+  Index cols,
+  Index remaining_rows,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag,
+  const Packet& pMask);
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_unrolled_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index& row,
+  Index rows,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag);
+
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE Packet ploadLhs(const Scalar* lhs);
+
+template<typename DataMapper, typename Packet, typename Index, const Index accCols, int N, int StorageOrder>
+EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet,4>& acc, const DataMapper& res, Index row, Index col);
+
+template<typename DataMapper, typename Packet, typename Index, const Index accCols, int N, int StorageOrder>
+EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet,8>& acc, const DataMapper& res, Index row, Index col);
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscale(PacketBlock<Packet,4>& acc, PacketBlock<Packet,4>& accZ, const Packet& pAlpha);
+
+template<typename Packet, int N>
+EIGEN_ALWAYS_INLINE void bscalec(PacketBlock<Packet,N>& aReal, PacketBlock<Packet,N>& aImag, const Packet& bReal, const Packet& bImag, PacketBlock<Packet,N>& cReal, PacketBlock<Packet,N>& cImag);
+
+const static Packet16uc p16uc_SETCOMPLEX32_FIRST = {  0,  1,  2,  3,
+                                                     16, 17, 18, 19,
+                                                      4,  5,  6,  7,
+                                                     20, 21, 22, 23};
+
+const static Packet16uc p16uc_SETCOMPLEX32_SECOND = {  8,  9, 10, 11,
+                                                      24, 25, 26, 27,
+                                                      12, 13, 14, 15,
+                                                      28, 29, 30, 31};
+//[a,b],[ai,bi] = [a,ai] - This is equivalent to p16uc_GETREAL64
+const static Packet16uc p16uc_SETCOMPLEX64_FIRST = {  0,  1,  2,  3,  4,  5,  6,  7,
+                                                     16, 17, 18, 19, 20, 21, 22, 23};
+
+//[a,b],[ai,bi] = [b,bi] - This is equivalent to p16uc_GETIMAG64
+const static Packet16uc p16uc_SETCOMPLEX64_SECOND = {  8,  9, 10, 11, 12, 13, 14, 15,
+                                                      24, 25, 26, 27, 28, 29, 30, 31};
+
+
+// Grab two decouples real/imaginary PacketBlocks and return two coupled (real/imaginary pairs) PacketBlocks.
+template<typename Packet, typename Packetc>
+EIGEN_ALWAYS_INLINE void bcouple_common(PacketBlock<Packet,4>& taccReal, PacketBlock<Packet,4>& taccImag, PacketBlock<Packetc, 4>& acc1, PacketBlock<Packetc, 4>& acc2)
+{
+  acc1.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX32_FIRST);
+  acc1.packet[1].v = vec_perm(taccReal.packet[1], taccImag.packet[1], p16uc_SETCOMPLEX32_FIRST);
+  acc1.packet[2].v = vec_perm(taccReal.packet[2], taccImag.packet[2], p16uc_SETCOMPLEX32_FIRST);
+  acc1.packet[3].v = vec_perm(taccReal.packet[3], taccImag.packet[3], p16uc_SETCOMPLEX32_FIRST);
+
+  acc2.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX32_SECOND);
+  acc2.packet[1].v = vec_perm(taccReal.packet[1], taccImag.packet[1], p16uc_SETCOMPLEX32_SECOND);
+  acc2.packet[2].v = vec_perm(taccReal.packet[2], taccImag.packet[2], p16uc_SETCOMPLEX32_SECOND);
+  acc2.packet[3].v = vec_perm(taccReal.packet[3], taccImag.packet[3], p16uc_SETCOMPLEX32_SECOND);
+}
+
+template<typename Packet, typename Packetc>
+EIGEN_ALWAYS_INLINE void bcouple(PacketBlock<Packet,4>& taccReal, PacketBlock<Packet,4>& taccImag, PacketBlock<Packetc,8>& tRes, PacketBlock<Packetc, 4>& acc1, PacketBlock<Packetc, 4>& acc2)
+{
+  bcouple_common<Packet, Packetc>(taccReal, taccImag, acc1, acc2);
+
+  acc1.packet[0] = padd<Packetc>(tRes.packet[0], acc1.packet[0]);
+  acc1.packet[1] = padd<Packetc>(tRes.packet[1], acc1.packet[1]);
+  acc1.packet[2] = padd<Packetc>(tRes.packet[2], acc1.packet[2]);
+  acc1.packet[3] = padd<Packetc>(tRes.packet[3], acc1.packet[3]);
+
+  acc2.packet[0] = padd<Packetc>(tRes.packet[4], acc2.packet[0]);
+  acc2.packet[1] = padd<Packetc>(tRes.packet[5], acc2.packet[1]);
+  acc2.packet[2] = padd<Packetc>(tRes.packet[6], acc2.packet[2]);
+  acc2.packet[3] = padd<Packetc>(tRes.packet[7], acc2.packet[3]);
+}
+
+template<typename Packet, typename Packetc>
+EIGEN_ALWAYS_INLINE void bcouple_common(PacketBlock<Packet,1>& taccReal, PacketBlock<Packet,1>& taccImag, PacketBlock<Packetc, 1>& acc1, PacketBlock<Packetc, 1>& acc2)
+{
+  acc1.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX32_FIRST);
+
+  acc2.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX32_SECOND);
+}
+
+template<typename Packet, typename Packetc>
+EIGEN_ALWAYS_INLINE void bcouple(PacketBlock<Packet,1>& taccReal, PacketBlock<Packet,1>& taccImag, PacketBlock<Packetc,2>& tRes, PacketBlock<Packetc, 1>& acc1, PacketBlock<Packetc, 1>& acc2)
+{
+  bcouple_common<Packet, Packetc>(taccReal, taccImag, acc1, acc2);
+
+  acc1.packet[0] = padd<Packetc>(tRes.packet[0], acc1.packet[0]);
+
+  acc2.packet[0] = padd<Packetc>(tRes.packet[1], acc2.packet[0]);
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void bcouple_common<Packet2d, Packet1cd>(PacketBlock<Packet2d,4>& taccReal, PacketBlock<Packet2d,4>& taccImag, PacketBlock<Packet1cd, 4>& acc1, PacketBlock<Packet1cd, 4>& acc2)
+{
+  acc1.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX64_FIRST);
+  acc1.packet[1].v = vec_perm(taccReal.packet[1], taccImag.packet[1], p16uc_SETCOMPLEX64_FIRST);
+  acc1.packet[2].v = vec_perm(taccReal.packet[2], taccImag.packet[2], p16uc_SETCOMPLEX64_FIRST);
+  acc1.packet[3].v = vec_perm(taccReal.packet[3], taccImag.packet[3], p16uc_SETCOMPLEX64_FIRST);
+
+  acc2.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX64_SECOND);
+  acc2.packet[1].v = vec_perm(taccReal.packet[1], taccImag.packet[1], p16uc_SETCOMPLEX64_SECOND);
+  acc2.packet[2].v = vec_perm(taccReal.packet[2], taccImag.packet[2], p16uc_SETCOMPLEX64_SECOND);
+  acc2.packet[3].v = vec_perm(taccReal.packet[3], taccImag.packet[3], p16uc_SETCOMPLEX64_SECOND);
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void bcouple_common<Packet2d, Packet1cd>(PacketBlock<Packet2d,1>& taccReal, PacketBlock<Packet2d,1>& taccImag, PacketBlock<Packet1cd, 1>& acc1, PacketBlock<Packet1cd, 1>& acc2)
+{
+  acc1.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX64_FIRST);
+
+  acc2.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX64_SECOND);
+}
+
+// This is necessary because ploadRhs for double returns a pair of vectors when MMA is enabled.
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE Packet ploadRhs(const Scalar* rhs)
+{
+  return ploadu<Packet>(rhs);
+}
+
+} // end namespace internal
+} // end namespace Eigen
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
new file mode 100644
index 00000000..6540c6fa
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
@@ -0,0 +1,629 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020 Everton Constantino (everton.constantino@ibm.com)
+// Copyright (C) 2021 Chip Kerchner (chip.kerchner@ibm.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
+#define EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
+
+#pragma GCC target("cpu=power10")
+
+#ifdef __has_builtin
+#if !__has_builtin(__builtin_vsx_assemble_pair)
+#define __builtin_vsx_assemble_pair __builtin_mma_assemble_pair
+#endif
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE void bsetzeroMMA(__vector_quad* acc)
+{
+  __builtin_mma_xxsetaccz(acc);
+}
+
+template<typename DataMapper, typename Index, typename Packet, const Index accCols>
+EIGEN_ALWAYS_INLINE void storeAccumulator(Index i, Index j, const DataMapper& data, const Packet& alpha, __vector_quad* acc)
+{
+  PacketBlock<Packet, 4> result;
+  __builtin_mma_disassemble_acc(&result.packet, acc);
+
+  PacketBlock<Packet, 4> tRes;
+  bload<DataMapper, Packet, Index, accCols, 0, ColMajor>(tRes, data, i, j);
+
+  bscale<Packet>(tRes, result, alpha);
+
+  data.template storePacketBlock<Packet, 4>(i, j, tRes);
+}
+
+template<typename DataMapper, typename Index, typename Packet, typename Packetc, const Index accColsC, int N>
+EIGEN_ALWAYS_INLINE void storeComplexAccumulator(Index i, Index j, const DataMapper& data, const Packet& alphaReal, const Packet& alphaImag, __vector_quad* accReal, __vector_quad* accImag)
+{
+  PacketBlock<Packet, 4> resultReal, resultImag;
+  __builtin_mma_disassemble_acc(&resultReal.packet, accReal);
+  __builtin_mma_disassemble_acc(&resultImag.packet, accImag);
+
+  PacketBlock<Packetc, 8> tRes;
+  bload<DataMapper, Packetc, Index, accColsC, N, ColMajor>(tRes, data, i, j);
+
+  PacketBlock<Packet,4> taccReal, taccImag;
+  bscalec<Packet,4>(resultReal, resultImag, alphaReal, alphaImag, taccReal, taccImag);
+
+  PacketBlock<Packetc, 4> acc1, acc2;
+  bcouple<Packet, Packetc>(taccReal, taccImag, tRes, acc1, acc2);
+
+  data.template storePacketBlock<Packetc, 4>(i + N*accColsC, j, acc1);
+  data.template storePacketBlock<Packetc, 4>(i + (N+1)*accColsC, j, acc2);
+}
+
+// Defaults to float32, since Eigen still supports C++03 we can't use default template arguments
+template<typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pgerMMA(__vector_quad* acc, const RhsPacket& a, const LhsPacket& b)
+{
+  if(NegativeAccumulate)
+  {
+    __builtin_mma_xvf32gernp(acc, (__vector unsigned char)a, (__vector unsigned char)b);
+  } else {
+    __builtin_mma_xvf32gerpp(acc, (__vector unsigned char)a, (__vector unsigned char)b);
+  }
+}
+
+template<typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pgerMMA(__vector_quad* acc, const PacketBlock<Packet2d,2>& a, const Packet2d& b)
+{
+  __vector_pair* a0 = (__vector_pair *)(&a.packet[0]);
+  if(NegativeAccumulate)
+  {
+    __builtin_mma_xvf64gernp(acc, *a0, (__vector unsigned char)b);
+  } else {
+    __builtin_mma_xvf64gerpp(acc, *a0, (__vector unsigned char)b);
+  }
+}
+
+template<typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pgerMMA(__vector_quad* acc, const __vector_pair& a, const Packet2d& b)
+{
+  if(NegativeAccumulate)
+  {
+    __builtin_mma_xvf64gernp(acc, (__vector_pair)a, (__vector unsigned char)b);
+  } else {
+    __builtin_mma_xvf64gerpp(acc, (__vector_pair)a, (__vector unsigned char)b);
+  }
+}
+
+template<typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pgerMMA(__vector_quad*, const __vector_pair&, const Packet4f&)
+{
+  // Just for compilation
+}
+
+template<typename Scalar, typename Packet, typename RhsPacket, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void pgercMMA(__vector_quad* accReal, __vector_quad* accImag, const Packet& lhsV, const Packet& lhsVi, const RhsPacket& rhsV, const RhsPacket& rhsVi)
+{
+  pgerMMA<Packet, RhsPacket, false>(accReal,  rhsV,  lhsV);
+  if(LhsIsReal) {
+    pgerMMA<Packet, RhsPacket, ConjugateRhs>(accImag, rhsVi,  lhsV);
+  } else {
+    if(!RhsIsReal) {
+      pgerMMA<Packet, RhsPacket, ConjugateLhs == ConjugateRhs>(accReal, rhsVi, lhsVi);
+      pgerMMA<Packet, RhsPacket, ConjugateRhs>(accImag, rhsVi,  lhsV);
+    } else {
+      EIGEN_UNUSED_VARIABLE(rhsVi);
+    }
+    pgerMMA<Packet, RhsPacket, ConjugateLhs>(accImag,  rhsV, lhsVi);
+  }
+}
+
+// This is necessary because ploadRhs for double returns a pair of vectors when MMA is enabled.
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE void ploadRhsMMA(const Scalar* rhs, Packet& rhsV)
+{
+  rhsV = ploadRhs<Scalar, Packet>((const Scalar*)(rhs));
+} 
+
+template<>
+EIGEN_ALWAYS_INLINE void ploadRhsMMA<double, PacketBlock<Packet2d, 2> >(const double* rhs, PacketBlock<Packet2d, 2>& rhsV)
+{
+  rhsV.packet[0] = ploadRhs<double, Packet2d>((const double *)((Packet2d *)rhs      ));
+  rhsV.packet[1] = ploadRhs<double, Packet2d>((const double *)(((Packet2d *)rhs) + 1));
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void ploadRhsMMA<double, __vector_pair>(const double* rhs, __vector_pair& rhsV)
+{
+#if EIGEN_COMP_LLVM
+  __builtin_vsx_assemble_pair(&rhsV,
+    (__vector unsigned char)(ploadRhs<double, Packet2d>((const double *)(((Packet2d *)rhs) + 1))),
+    (__vector unsigned char)(ploadRhs<double, Packet2d>((const double *)((Packet2d *)rhs      ))));
+#else
+  __asm__ ("lxvp %x0,%1" : "=wa" (rhsV) : "Y" (*rhs));
+#endif
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void ploadRhsMMA(const float*, __vector_pair&)
+{
+  // Just for compilation
+}
+
+// PEEL_MMA loop factor.
+#define PEEL_MMA 7
+
+#define MICRO_MMA_UNROLL(func) \
+  func(0) func(1) func(2) func(3) func(4) func(5) func(6) func(7)
+
+#define MICRO_MMA_LOAD_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhsV##iter = ploadLhs<Scalar, Packet>(lhs_ptr##iter); \
+    lhs_ptr##iter += accCols; \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhsV##iter); \
+  }
+
+#define MICRO_MMA_WORK_ONE(iter, type, peel) \
+  if (unroll_factor > iter) { \
+    pgerMMA<Packet, type, false>(&accZero##iter, rhsV##peel, lhsV##iter); \
+  }
+
+#define MICRO_MMA_TYPE_PEEL(func, func2, type, peel) \
+  if (PEEL_MMA > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4, lhsV5, lhsV6, lhsV7; \
+    ploadRhsMMA<Scalar, type>(rhs_ptr + (accRows * peel), rhsV##peel); \
+    MICRO_MMA_UNROLL(func2); \
+    func(0,type,peel) func(1,type,peel) func(2,type,peel) func(3,type,peel) \
+    func(4,type,peel) func(5,type,peel) func(6,type,peel) func(7,type,peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+  }
+
+#define MICRO_MMA_UNROLL_TYPE_PEEL(func, func2, type) \
+  type rhsV0, rhsV1, rhsV2, rhsV3, rhsV4, rhsV5, rhsV6, rhsV7, rhsV8, rhsV9; \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,0); MICRO_MMA_TYPE_PEEL(func,func2,type,1); \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,2); MICRO_MMA_TYPE_PEEL(func,func2,type,3); \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,4); MICRO_MMA_TYPE_PEEL(func,func2,type,5); \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,6); MICRO_MMA_TYPE_PEEL(func,func2,type,7); \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,8); MICRO_MMA_TYPE_PEEL(func,func2,type,9);
+
+#define MICRO_MMA_UNROLL_TYPE_ONE(func, func2, type) \
+  type rhsV0; \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,0);
+
+#define MICRO_MMA_ONE_PEEL \
+  if (sizeof(Scalar) == sizeof(float)) { \
+    MICRO_MMA_UNROLL_TYPE_PEEL(MICRO_MMA_WORK_ONE, MICRO_MMA_LOAD_ONE, RhsPacket); \
+  } else { \
+    MICRO_MMA_UNROLL_TYPE_PEEL(MICRO_MMA_WORK_ONE, MICRO_MMA_LOAD_ONE, __vector_pair); \
+  } \
+  rhs_ptr += (accRows * PEEL_MMA);
+
+#define MICRO_MMA_ONE \
+  if (sizeof(Scalar) == sizeof(float)) { \
+    MICRO_MMA_UNROLL_TYPE_ONE(MICRO_MMA_WORK_ONE, MICRO_MMA_LOAD_ONE, RhsPacket); \
+  } else { \
+    MICRO_MMA_UNROLL_TYPE_ONE(MICRO_MMA_WORK_ONE, MICRO_MMA_LOAD_ONE, __vector_pair); \
+  } \
+  rhs_ptr += accRows;
+
+#define MICRO_MMA_DST_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bsetzeroMMA<Scalar, Packet>(&accZero##iter); \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(accZero##iter); \
+  }
+
+#define MICRO_MMA_DST_PTR MICRO_MMA_UNROLL(MICRO_MMA_DST_PTR_ONE)
+
+#define MICRO_MMA_SRC_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhs_ptr##iter = lhs_base + ( (row/accCols) + iter )*strideA*accCols + accCols*offsetA; \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr##iter); \
+  }
+
+#define MICRO_MMA_SRC_PTR MICRO_MMA_UNROLL(MICRO_MMA_SRC_PTR_ONE)
+
+#define MICRO_MMA_PREFETCH_ONE(iter) \
+  if (unroll_factor > iter) { \
+    EIGEN_POWER_PREFETCH(lhs_ptr##iter); \
+  }
+
+#define MICRO_MMA_PREFETCH MICRO_MMA_UNROLL(MICRO_MMA_PREFETCH_ONE)
+
+#define MICRO_MMA_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    storeAccumulator<DataMapper, Index, Packet, accCols>(row + iter*accCols, col, res, pAlpha, &accZero##iter); \
+  }
+
+#define MICRO_MMA_STORE MICRO_MMA_UNROLL(MICRO_MMA_STORE_ONE)
+
+template<int unroll_factor, typename Scalar, typename Packet, typename RhsPacket, typename DataMapper, typename Index, const Index accRows, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_unrolled_MMA_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index& row,
+  Index col,
+  const Packet& pAlpha)
+{
+  const Scalar* rhs_ptr = rhs_base;
+  const Scalar* lhs_ptr0 = NULL, * lhs_ptr1 = NULL, * lhs_ptr2 = NULL, * lhs_ptr3 = NULL, * lhs_ptr4 = NULL, * lhs_ptr5 = NULL, * lhs_ptr6 = NULL, * lhs_ptr7 = NULL;
+  __vector_quad accZero0, accZero1, accZero2, accZero3, accZero4, accZero5, accZero6, accZero7;
+
+  MICRO_MMA_SRC_PTR
+  MICRO_MMA_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL_MMA <= depth; k+= PEEL_MMA)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr);
+    MICRO_MMA_PREFETCH
+    MICRO_MMA_ONE_PEEL
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_MMA_ONE
+  }
+  MICRO_MMA_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<typename Scalar, typename Index, typename Packet, typename RhsPacket, typename DataMapper, const Index accRows, const Index accCols>
+void gemmMMA(const DataMapper& res, const Scalar* blockA, const Scalar* blockB, Index rows, Index depth, Index cols, Scalar alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
+{
+      const Index remaining_rows = rows % accCols;
+      const Index remaining_cols = cols % accRows;
+
+      if( strideA == -1 ) strideA = depth;
+      if( strideB == -1 ) strideB = depth;
+
+      const Packet pAlpha = pset1<Packet>(alpha);
+      const Packet pMask  = bmask<Packet>((const int)(remaining_rows));
+
+      Index col = 0;
+      for(; col + accRows <= cols; col += accRows)
+      {
+        const Scalar* rhs_base = blockB + col*strideB + accRows*offsetB;
+        const Scalar* lhs_base = blockA;
+
+        Index row = 0;
+#define MAX_MMA_UNROLL 7
+        while(row + MAX_MMA_UNROLL*accCols <= rows) {
+          gemm_unrolled_MMA_iteration<MAX_MMA_UNROLL, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+        }
+        switch( (rows-row)/accCols ) {
+#if MAX_MMA_UNROLL > 7
+          case 7:
+            gemm_unrolled_MMA_iteration<7, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 6
+          case 6:
+            gemm_unrolled_MMA_iteration<6, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 5
+          case 5:
+            gemm_unrolled_MMA_iteration<5, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 4
+          case 4:
+            gemm_unrolled_MMA_iteration<4, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 3
+          case 3:
+            gemm_unrolled_MMA_iteration<3, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 2
+          case 2:
+            gemm_unrolled_MMA_iteration<2, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 1
+          case 1:
+            gemm_unrolled_MMA_iteration<1, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+          default:
+            break;
+        }
+#undef MAX_MMA_UNROLL
+
+        if(remaining_rows > 0)
+        {
+          gemm_extra_row<Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, rows, cols, remaining_rows, pAlpha, pMask);
+        }
+      }
+
+      if(remaining_cols > 0)
+      {
+        const Scalar* rhs_base = blockB + col*strideB + remaining_cols*offsetB;
+        const Scalar* lhs_base = blockA;
+
+        for(; col < cols; col++)
+        {
+          Index row = 0;
+
+          gemm_unrolled_col<Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, rows, col, remaining_cols, pAlpha);
+
+          if (remaining_rows > 0)
+          {
+            gemm_extra_col<Scalar, Packet, DataMapper, Index, accRows>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_rows, remaining_cols, pAlpha);
+          }
+          rhs_base++;
+        }
+      }
+}
+
+#define accColsC (accCols / 2)
+#define advanceRows ((LhsIsReal) ? 1 : 2)
+#define advanceCols ((RhsIsReal) ? 1 : 2)
+
+// PEEL_COMPLEX_MMA loop factor.
+#define PEEL_COMPLEX_MMA 7
+
+#define MICRO_COMPLEX_MMA_UNROLL(func) \
+  func(0) func(1) func(2) func(3) func(4)
+
+#define MICRO_COMPLEX_MMA_LOAD_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhsV##iter = ploadLhs<Scalar, Packet>(lhs_ptr_real##iter); \
+    lhs_ptr_real##iter += accCols; \
+    if(!LhsIsReal) { \
+      lhsVi##iter = ploadLhs<Scalar, Packet>(lhs_ptr_imag##iter); \
+      lhs_ptr_imag##iter += accCols; \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(lhsVi##iter); \
+    } \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhsV##iter); \
+    EIGEN_UNUSED_VARIABLE(lhsVi##iter); \
+  }
+
+#define MICRO_COMPLEX_MMA_WORK_ONE(iter, type, peel) \
+  if (unroll_factor > iter) { \
+    pgercMMA<Scalar, Packet, type, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal##iter, &accImag##iter, lhsV##iter, lhsVi##iter, rhsV##peel, rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_MMA_TYPE_PEEL(func, func2, type, peel) \
+  if (PEEL_COMPLEX_MMA > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4; \
+    Packet lhsVi0, lhsVi1, lhsVi2, lhsVi3, lhsVi4; \
+    ploadRhsMMA<Scalar, type>(rhs_ptr_real + (accRows * peel), rhsV##peel); \
+    if(!RhsIsReal) { \
+      ploadRhsMMA<Scalar, type>(rhs_ptr_imag + (accRows * peel), rhsVi##peel); \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+    } \
+    MICRO_COMPLEX_MMA_UNROLL(func2); \
+    func(0,type,peel) func(1,type,peel) func(2,type,peel) func(3,type,peel) func(4,type,peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+    EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_MMA_UNROLL_TYPE_PEEL(func, func2, type) \
+  type rhsV0, rhsV1, rhsV2, rhsV3, rhsV4, rhsV5, rhsV6, rhsV7, rhsV8, rhsV9; \
+  type rhsVi0, rhsVi1, rhsVi2, rhsVi3, rhsVi4, rhsVi5, rhsVi6, rhsVi7, rhsVi8, rhsVi9; \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,0); MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,1); \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,2); MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,3); \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,4); MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,5); \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,6); MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,7); \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,8); MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,9);
+
+#define MICRO_COMPLEX_MMA_UNROLL_TYPE_ONE(func, func2, type) \
+  type rhsV0, rhsVi0; \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,0);
+
+#define MICRO_COMPLEX_MMA_ONE_PEEL \
+  if (sizeof(Scalar) == sizeof(float)) { \
+    MICRO_COMPLEX_MMA_UNROLL_TYPE_PEEL(MICRO_COMPLEX_MMA_WORK_ONE, MICRO_COMPLEX_MMA_LOAD_ONE, RhsPacket); \
+  } else { \
+    MICRO_COMPLEX_MMA_UNROLL_TYPE_PEEL(MICRO_COMPLEX_MMA_WORK_ONE, MICRO_COMPLEX_MMA_LOAD_ONE, __vector_pair); \
+  } \
+  rhs_ptr_real += (accRows * PEEL_COMPLEX_MMA); \
+  if(!RhsIsReal) rhs_ptr_imag += (accRows * PEEL_COMPLEX_MMA);
+
+#define MICRO_COMPLEX_MMA_ONE \
+  if (sizeof(Scalar) == sizeof(float)) { \
+    MICRO_COMPLEX_MMA_UNROLL_TYPE_ONE(MICRO_COMPLEX_MMA_WORK_ONE, MICRO_COMPLEX_MMA_LOAD_ONE, RhsPacket); \
+  } else { \
+    MICRO_COMPLEX_MMA_UNROLL_TYPE_ONE(MICRO_COMPLEX_MMA_WORK_ONE, MICRO_COMPLEX_MMA_LOAD_ONE, __vector_pair); \
+  } \
+  rhs_ptr_real += accRows; \
+  if(!RhsIsReal) rhs_ptr_imag += accRows;
+
+#define MICRO_COMPLEX_MMA_DST_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bsetzeroMMA<Scalar, Packet>(&accReal##iter); \
+    bsetzeroMMA<Scalar, Packet>(&accImag##iter); \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(accReal##iter); \
+    EIGEN_UNUSED_VARIABLE(accImag##iter); \
+  }
+
+#define MICRO_COMPLEX_MMA_DST_PTR MICRO_COMPLEX_MMA_UNROLL(MICRO_COMPLEX_MMA_DST_PTR_ONE)
+
+#define MICRO_COMPLEX_MMA_SRC_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhs_ptr_real##iter = lhs_base + ( ((advanceRows*row)/accCols) + iter*advanceRows )*strideA*accCols + accCols*offsetA; \
+    if(!LhsIsReal) { \
+      lhs_ptr_imag##iter = lhs_ptr_real##iter + accCols*strideA; \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(lhs_ptr_imag##iter); \
+    } \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr_real##iter); \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr_imag##iter); \
+  }
+
+#define MICRO_COMPLEX_MMA_SRC_PTR MICRO_COMPLEX_MMA_UNROLL(MICRO_COMPLEX_MMA_SRC_PTR_ONE)
+
+#define MICRO_COMPLEX_MMA_PREFETCH_ONE(iter) \
+  if (unroll_factor > iter) { \
+    EIGEN_POWER_PREFETCH(lhs_ptr_real##iter); \
+    if(!LhsIsReal) { \
+      EIGEN_POWER_PREFETCH(lhs_ptr_imag##iter); \
+    } \
+  }
+
+#define MICRO_COMPLEX_MMA_PREFETCH MICRO_COMPLEX_MMA_UNROLL(MICRO_COMPLEX_MMA_PREFETCH_ONE)
+
+#define MICRO_COMPLEX_MMA_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    storeComplexAccumulator<DataMapper, Index, Packet, Packetc, accColsC, 0>(row + iter*accCols, col, res, pAlphaReal, pAlphaImag, &accReal##iter, &accImag##iter); \
+  }
+
+#define MICRO_COMPLEX_MMA_STORE MICRO_COMPLEX_MMA_UNROLL(MICRO_COMPLEX_MMA_STORE_ONE)
+
+template<int unroll_factor, typename Scalar, typename Packet, typename Packetc, typename RhsPacket, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_unrolled_MMA_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index& row,
+  Index col,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag)
+{
+  const Scalar* rhs_ptr_real = rhs_base;
+  const Scalar* rhs_ptr_imag;
+  if(!RhsIsReal) {
+    rhs_ptr_imag = rhs_base + accRows*strideB;
+  } else {
+    EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+  }
+  const Scalar* lhs_ptr_real0 = NULL, * lhs_ptr_imag0 = NULL, * lhs_ptr_real1 = NULL, * lhs_ptr_imag1 = NULL;
+  const Scalar* lhs_ptr_real2 = NULL, * lhs_ptr_imag2 = NULL, * lhs_ptr_real3 = NULL, * lhs_ptr_imag3 = NULL;
+  const Scalar* lhs_ptr_real4 = NULL, * lhs_ptr_imag4 = NULL;
+  __vector_quad accReal0, accImag0, accReal1, accImag1, accReal2, accImag2, accReal3, accImag3, accReal4, accImag4;
+
+  MICRO_COMPLEX_MMA_SRC_PTR
+  MICRO_COMPLEX_MMA_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL_COMPLEX_MMA <= depth; k+= PEEL_COMPLEX_MMA)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr_real);
+    if(!RhsIsReal) {
+      EIGEN_POWER_PREFETCH(rhs_ptr_imag);
+    }
+    MICRO_COMPLEX_MMA_PREFETCH
+    MICRO_COMPLEX_MMA_ONE_PEEL
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_COMPLEX_MMA_ONE
+  }
+  MICRO_COMPLEX_MMA_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<typename LhsScalar, typename RhsScalar, typename Scalarc, typename Scalar, typename Index, typename Packet, typename Packetc, typename RhsPacket, typename DataMapper, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+void gemm_complexMMA(const DataMapper& res, const LhsScalar* blockAc, const RhsScalar* blockBc, Index rows, Index depth, Index cols, Scalarc alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
+{
+      const Index remaining_rows = rows % accCols;
+      const Index remaining_cols = cols % accRows;
+
+      if( strideA == -1 ) strideA = depth;
+      if( strideB == -1 ) strideB = depth;
+
+      const Packet pAlphaReal = pset1<Packet>(alpha.real());
+      const Packet pAlphaImag = pset1<Packet>(alpha.imag());
+      const Packet pMask = bmask<Packet>((const int)(remaining_rows));
+
+      const Scalar* blockA = (Scalar *) blockAc;
+      const Scalar* blockB = (Scalar *) blockBc;
+
+      Index col = 0;
+      for(; col + accRows <= cols; col += accRows)
+      {
+        const Scalar* rhs_base = blockB + advanceCols*col*strideB + accRows*offsetB;
+        const Scalar* lhs_base = blockA;
+        Index row = 0;
+
+#define MAX_COMPLEX_MMA_UNROLL 4
+        while(row + MAX_COMPLEX_MMA_UNROLL*accCols <= rows) {
+          gemm_complex_unrolled_MMA_iteration<MAX_COMPLEX_MMA_UNROLL, Scalar, Packet, Packetc, RhsPacket, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+        }
+        switch( (rows-row)/accCols ) {
+#if MAX_COMPLEX_MMA_UNROLL > 4
+          case 4:
+            gemm_complex_unrolled_MMA_iteration<4, Scalar, Packet, Packetc, RhsPacket, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_MMA_UNROLL > 3
+          case 3:
+            gemm_complex_unrolled_MMA_iteration<3, Scalar, Packet, Packetc, RhsPacket, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_MMA_UNROLL > 2
+          case 2:
+            gemm_complex_unrolled_MMA_iteration<2, Scalar, Packet, Packetc, RhsPacket, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_MMA_UNROLL > 1
+          case 1:
+            gemm_complex_unrolled_MMA_iteration<1, Scalar, Packet, Packetc, RhsPacket, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+          default:
+            break;
+        }
+#undef MAX_COMPLEX_MMA_UNROLL
+
+        if(remaining_rows > 0)
+        {
+          gemm_complex_extra_row<Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, rows, cols, remaining_rows, pAlphaReal, pAlphaImag, pMask);
+        }
+      }
+
+      if(remaining_cols > 0)
+      {
+        const Scalar* rhs_base = blockB + advanceCols*col*strideB + remaining_cols*offsetB;
+        const Scalar* lhs_base = blockA;
+
+        for(; col < cols; col++)
+        {
+          Index row = 0;
+
+          gemm_complex_unrolled_col<Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, rows, col, remaining_cols, pAlphaReal, pAlphaImag);
+
+          if (remaining_rows > 0)
+          {
+            gemm_complex_extra_col<Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_rows, remaining_cols, pAlphaReal, pAlphaImag);
+          }
+          rhs_base++;
+        }
+      }
+}
+
+#undef accColsC
+#undef advanceRows
+#undef advanceCols
+
+#pragma GCC reset_options
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
+
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/PacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/PacketMath.h
new file mode 100644
index 00000000..2a440545
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/AltiVec/PacketMath.h
@@ -0,0 +1,2711 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_ALTIVEC_H
+#define EIGEN_PACKET_MATH_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 4
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+// NOTE Altivec has 32 registers, but Eigen only accepts a value of 8 or 16
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS  32
+#endif
+
+typedef __vector float                   Packet4f;
+typedef __vector int                     Packet4i;
+typedef __vector unsigned int            Packet4ui;
+typedef __vector __bool int              Packet4bi;
+typedef __vector short int               Packet8s;
+typedef __vector unsigned short int      Packet8us;
+typedef __vector signed char             Packet16c;
+typedef __vector unsigned char           Packet16uc;
+typedef eigen_packet_wrapper<__vector unsigned short int,0> Packet8bf;
+
+// We don't want to write the same code all the time, but we need to reuse the constants
+// and it doesn't really work to declare them global, so we define macros instead
+#define _EIGEN_DECLARE_CONST_FAST_Packet4f(NAME,X) \
+  Packet4f p4f_##NAME = {X, X, X, X}
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = vec_splat_s32(X)
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet4ui(NAME,X) \
+  Packet4ui p4ui_##NAME = {X, X, X, X}
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet8us(NAME,X) \
+  Packet8us p8us_##NAME = {X, X, X, X, X, X, X, X}
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet16uc(NAME,X) \
+  Packet16uc p16uc_##NAME = {X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X}
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME,X) \
+  Packet2d p2d_##NAME = pset1<Packet2d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2l(NAME,X) \
+  Packet2l p2l_##NAME = pset1<Packet2l>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = reinterpret_cast<Packet4f>(pset1<Packet4i>(X))
+
+#define DST_CHAN 1
+#define DST_CTRL(size, count, stride) (((size) << 24) | ((count) << 16) | (stride))
+#define __UNPACK_TYPE__(PACKETNAME) typename unpacket_traits<PACKETNAME>::type 
+
+// These constants are endian-agnostic
+static _EIGEN_DECLARE_CONST_FAST_Packet4f(ZERO, 0); //{ 0.0, 0.0, 0.0, 0.0}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ZERO, 0); //{ 0, 0, 0, 0,}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ONE,1); //{ 1, 1, 1, 1}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS16,-16); //{ -16, -16, -16, -16}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS1,-1); //{ -1, -1, -1, -1}
+static _EIGEN_DECLARE_CONST_FAST_Packet4ui(SIGN, 0x80000000u);
+static _EIGEN_DECLARE_CONST_FAST_Packet4ui(PREV0DOT5, 0x3EFFFFFFu);
+static _EIGEN_DECLARE_CONST_FAST_Packet8us(ONE,1); //{ 1, 1, 1, 1, 1, 1, 1, 1}
+static _EIGEN_DECLARE_CONST_FAST_Packet16uc(ONE,1);
+static Packet4f p4f_MZERO = (Packet4f) vec_sl((Packet4ui)p4i_MINUS1, (Packet4ui)p4i_MINUS1); //{ 0x80000000, 0x80000000, 0x80000000, 0x80000000}
+#ifndef __VSX__
+static Packet4f p4f_ONE = vec_ctf(p4i_ONE, 0); //{ 1.0, 1.0, 1.0, 1.0}
+#endif
+
+static Packet4f  p4f_COUNTDOWN  = { 0.0, 1.0, 2.0, 3.0 };
+static Packet4i  p4i_COUNTDOWN  = { 0, 1, 2, 3 };
+static Packet8s  p8s_COUNTDOWN  = { 0, 1, 2, 3, 4, 5, 6, 7 };
+static Packet8us p8us_COUNTDOWN = { 0, 1, 2, 3, 4, 5, 6, 7 };
+
+static Packet16c  p16c_COUNTDOWN = { 0, 1, 2, 3, 4, 5, 6, 7,
+                                    8, 9, 10, 11, 12, 13, 14, 15};
+static Packet16uc p16uc_COUNTDOWN = { 0, 1, 2, 3, 4, 5, 6, 7, 
+                                    8, 9, 10, 11, 12, 13, 14, 15};
+
+static Packet16uc p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 };
+static Packet16uc p16uc_REVERSE16 = { 14,15, 12,13, 10,11, 8,9, 6,7, 4,5, 2,3, 0,1 };
+static Packet16uc p16uc_REVERSE8 = { 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 };
+
+static Packet16uc p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 };
+static Packet16uc p16uc_DUPLICATE16_HI = { 0,1,0,1, 2,3,2,3, 4,5,4,5, 6,7,6,7 };
+static Packet16uc p16uc_DUPLICATE8_HI = { 0,0, 1,1, 2,2, 3,3, 4,4, 5,5, 6,6, 7,7 };
+static const Packet16uc p16uc_DUPLICATE16_EVEN= { 0,1 ,0,1, 4,5, 4,5, 8,9, 8,9, 12,13, 12,13 };
+static const Packet16uc p16uc_DUPLICATE16_ODD = { 2,3 ,2,3, 6,7, 6,7, 10,11, 10,11, 14,15, 14,15 };
+
+static Packet16uc p16uc_QUADRUPLICATE16_HI = { 0,1,0,1,0,1,0,1, 2,3,2,3,2,3,2,3 };
+
+// Handle endianness properly while loading constants
+// Define global static constants:
+#ifdef _BIG_ENDIAN
+static Packet16uc p16uc_FORWARD = vec_lvsl(0, (float*)0);
+#ifdef __VSX__
+static Packet16uc p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+#endif
+static Packet16uc p16uc_PSET32_WODD   = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
+static Packet16uc p16uc_PSET32_WEVEN  = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 };
+static Packet16uc p16uc_HALF64_0_16 = vec_sld((Packet16uc)p4i_ZERO, vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 3), 8);      //{ 0,0,0,0, 0,0,0,0, 16,16,16,16, 16,16,16,16};
+#else
+static Packet16uc p16uc_FORWARD = p16uc_REVERSE32;
+static Packet16uc p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+static Packet16uc p16uc_PSET32_WODD = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 1), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
+static Packet16uc p16uc_PSET32_WEVEN = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 };
+static Packet16uc p16uc_HALF64_0_16 = vec_sld(vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 0), (Packet16uc)p4i_ZERO, 8);      //{ 0,0,0,0, 0,0,0,0, 16,16,16,16, 16,16,16,16};
+#endif // _BIG_ENDIAN
+
+static Packet16uc p16uc_PSET64_HI = (Packet16uc) vec_mergeh((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 };
+static Packet16uc p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 8,9,10,11, 12,13,14,15, 8,9,10,11, 12,13,14,15 };
+static Packet16uc p16uc_TRANSPOSE64_HI = p16uc_PSET64_HI + p16uc_HALF64_0_16;                                         //{ 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23};
+static Packet16uc p16uc_TRANSPOSE64_LO = p16uc_PSET64_LO + p16uc_HALF64_0_16;                                         //{ 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31};
+
+static Packet16uc p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8);                                         //{ 4,5,6,7, 0,1,2,3, 12,13,14,15, 8,9,10,11 };
+
+#ifdef _BIG_ENDIAN
+static Packet16uc p16uc_COMPLEX32_REV2 = vec_sld(p16uc_FORWARD, p16uc_FORWARD, 8);                                            //{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+#else
+static Packet16uc p16uc_COMPLEX32_REV2 = vec_sld(p16uc_PSET64_HI, p16uc_PSET64_LO, 8);                                            //{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+#endif // _BIG_ENDIAN
+
+#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  #define EIGEN_PPC_PREFETCH(ADDR) __builtin_prefetch(ADDR);
+#else
+  #define EIGEN_PPC_PREFETCH(ADDR) asm( "   dcbt [%[addr]]\n" :: [addr] "r" (ADDR) : "cc" );
+#endif
+
+template <>
+struct packet_traits<float> : default_packet_traits {
+  typedef Packet4f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasAbs = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasExp = 1,
+#ifdef __VSX__
+    HasSqrt = 1,
+#if !EIGEN_COMP_CLANG
+    HasRsqrt = 1,
+#else
+    HasRsqrt = 0,
+#endif
+#else
+    HasSqrt = 0,
+    HasRsqrt = 0,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+#endif
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+template <>
+struct packet_traits<bfloat16> : default_packet_traits {
+  typedef Packet8bf type;
+  typedef Packet8bf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasAbs = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasExp = 1,
+#ifdef __VSX__
+    HasSqrt = 1,
+#if !EIGEN_COMP_CLANG
+    HasRsqrt = 1,
+#else
+    HasRsqrt = 0,
+#endif
+#else
+    HasSqrt = 0,
+    HasRsqrt = 0,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+#endif
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<int> : default_packet_traits {
+  typedef Packet4i type;
+  typedef Packet4i half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasAdd   = 1,
+    HasSub   = 1,
+    HasShift = 1,
+    HasMul   = 1,
+    HasDiv   = 0,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<short int> : default_packet_traits {
+  typedef Packet8s type;
+  typedef Packet8s half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 0,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<unsigned short int> : default_packet_traits {
+  typedef Packet8us type;
+  typedef Packet8us half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 0,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<signed char> : default_packet_traits {
+  typedef Packet16c type;
+  typedef Packet16c half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 0,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<unsigned char> : default_packet_traits {
+  typedef Packet16uc type;
+  typedef Packet16uc half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 0,
+    HasBlend = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet4f>
+{
+  typedef float     type;
+  typedef Packet4f  half;
+  typedef Packet4i  integer_packet;
+  enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet4i>
+{
+  typedef int       type;
+  typedef Packet4i  half;
+  enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet8s>
+{
+  typedef short int type;
+  typedef Packet8s  half;
+  enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet8us>
+{
+  typedef unsigned short int type;
+  typedef Packet8us          half;
+  enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+
+template<> struct unpacket_traits<Packet16c>
+{
+  typedef signed char type;
+  typedef Packet16c  half;
+  enum {size=16, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet16uc>
+{
+  typedef unsigned char type;
+  typedef Packet16uc  half;
+  enum {size=16, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+
+template<> struct unpacket_traits<Packet8bf>
+{
+  typedef bfloat16 type;
+  typedef Packet8bf          half;
+  enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+inline std::ostream & operator <<(std::ostream & s, const Packet16c & v)
+{
+  union {
+    Packet16c   v;
+    signed char n[16];
+  } vt;
+  vt.v = v;
+  for (int i=0; i< 16; i++)
+    s << vt.n[i] << ", ";
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet16uc & v)
+{
+  union {
+    Packet16uc   v;
+    unsigned char n[16];
+  } vt;
+  vt.v = v;
+  for (int i=0; i< 16; i++)
+    s << vt.n[i] << ", ";
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4f & v)
+{
+  union {
+    Packet4f   v;
+    float n[4];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4i & v)
+{
+  union {
+    Packet4i   v;
+    int n[4];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4ui & v)
+{
+  union {
+    Packet4ui   v;
+    unsigned int n[4];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
+  return s;
+}
+
+template <typename Packet>
+EIGEN_STRONG_INLINE Packet pload_common(const __UNPACK_TYPE__(Packet)* from)
+{
+  // some versions of GCC throw "unused-but-set-parameter".
+  // ignoring these warnings for now.
+  EIGEN_UNUSED_VARIABLE(from);
+  EIGEN_DEBUG_ALIGNED_LOAD
+#ifdef __VSX__
+  return vec_xl(0, const_cast<__UNPACK_TYPE__(Packet)*>(from));
+#else
+  return vec_ld(0, from);
+#endif
+}
+
+// Need to define them first or we get specialization after instantiation errors
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from)
+{
+  return pload_common<Packet4f>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int*     from)
+{
+  return pload_common<Packet4i>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8s pload<Packet8s>(const short int* from)
+{
+  return pload_common<Packet8s>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us pload<Packet8us>(const unsigned short int* from)
+{
+  return pload_common<Packet8us>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16c pload<Packet16c>(const signed char*     from)
+{
+  return pload_common<Packet16c>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16uc pload<Packet16uc>(const unsigned char*     from)
+{
+  return pload_common<Packet16uc>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pload<Packet8bf>(const bfloat16*     from)
+{
+  return pload_common<Packet8us>(reinterpret_cast<const unsigned short int*>(from));
+}
+
+template <typename Packet>
+EIGEN_STRONG_INLINE void pstore_common(__UNPACK_TYPE__(Packet)* to, const Packet& from){
+  // some versions of GCC throw "unused-but-set-parameter" (float *to).
+  // ignoring these warnings for now.
+  EIGEN_UNUSED_VARIABLE(to);
+  EIGEN_DEBUG_ALIGNED_STORE
+#ifdef __VSX__
+  vec_xst(from, 0, to);
+#else
+  vec_st(from, 0, to);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet4f& from)
+{
+  pstore_common<Packet4f>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet4i& from)
+{
+  pstore_common<Packet4i>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<short int>(short int*       to, const Packet8s& from)
+{
+  pstore_common<Packet8s>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<unsigned short int>(unsigned short int*       to, const Packet8us& from)
+{
+  pstore_common<Packet8us>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<bfloat16>(bfloat16*       to, const Packet8bf& from)
+{
+  pstore_common<Packet8us>(reinterpret_cast<unsigned short int*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<signed char>(signed char*       to, const Packet16c& from)
+{
+  pstore_common<Packet16c>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<unsigned char>(unsigned char*       to, const Packet16uc& from)
+{
+  pstore_common<Packet16uc>(to, from);
+}
+
+template<typename Packet>
+EIGEN_STRONG_INLINE Packet pset1_size4(const __UNPACK_TYPE__(Packet)& from)
+{
+  Packet v = {from, from, from, from};
+  return v;
+}
+
+template<typename Packet>
+EIGEN_STRONG_INLINE Packet pset1_size8(const __UNPACK_TYPE__(Packet)& from)
+{
+  Packet v = {from, from, from, from, from, from, from, from};
+  return v;
+}
+
+template<typename Packet>
+EIGEN_STRONG_INLINE Packet pset1_size16(const __UNPACK_TYPE__(Packet)& from)
+{
+  Packet v = {from, from, from, from, from, from, from, from, from, from, from, from, from, from, from, from};
+  return v;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) {
+  return pset1_size4<Packet4f>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from)   {
+  return pset1_size4<Packet4i>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8s pset1<Packet8s>(const short int&    from)   {
+  return pset1_size8<Packet8s>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us pset1<Packet8us>(const unsigned short int&    from)   {
+  return pset1_size8<Packet8us>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16c pset1<Packet16c>(const signed char&    from)   {
+  return pset1_size16<Packet16c>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16uc pset1<Packet16uc>(const unsigned char&    from)   {
+  return pset1_size16<Packet16uc>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1frombits<Packet4f>(unsigned int from) {
+  return reinterpret_cast<Packet4f>(pset1<Packet4i>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pset1<Packet8bf>(const bfloat16&    from)   {
+  return pset1_size8<Packet8us>(reinterpret_cast<const unsigned short int&>(from));
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE void
+pbroadcast4_common(const __UNPACK_TYPE__(Packet) *a,
+                      Packet& a0, Packet& a1, Packet& a2, Packet& a3)
+{
+  a3 = pload<Packet>(a);
+  a0 = vec_splat(a3, 0);
+  a1 = vec_splat(a3, 1);
+  a2 = vec_splat(a3, 2);
+  a3 = vec_splat(a3, 3);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  pbroadcast4_common<Packet4f>(a, a0, a1, a2, a3);
+}
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4i>(const int *a,
+                      Packet4i& a0, Packet4i& a1, Packet4i& a2, Packet4i& a3)
+{
+  pbroadcast4_common<Packet4i>(a, a0, a1, a2, a3);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather_common(const __UNPACK_TYPE__(Packet)* from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[4];
+  a[0] = from[0*stride];
+  a[1] = from[1*stride];
+  a[2] = from[2*stride];
+  a[3] = from[3*stride];
+  return pload<Packet>(a);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  return pgather_common<Packet4f>(from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int, Packet4i>(const int* from, Index stride)
+{
+  return pgather_common<Packet4i>(from, stride);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather_size8(const __UNPACK_TYPE__(Packet)* from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[8];
+  a[0] = from[0*stride];
+  a[1] = from[1*stride];
+  a[2] = from[2*stride];
+  a[3] = from[3*stride];
+  a[4] = from[4*stride];
+  a[5] = from[5*stride];
+  a[6] = from[6*stride];
+  a[7] = from[7*stride];
+  return pload<Packet>(a);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet8s pgather<short int, Packet8s>(const short int* from, Index stride)
+{
+  return pgather_size8<Packet8s>(from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet8us pgather<unsigned short int, Packet8us>(const unsigned short int* from, Index stride)
+{
+  return pgather_size8<Packet8us>(from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet8bf pgather<bfloat16, Packet8bf>(const bfloat16* from, Index stride)
+{
+  return pgather_size8<Packet8bf>(from, stride);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather_size16(const __UNPACK_TYPE__(Packet)* from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[16];
+  a[0] = from[0*stride];
+  a[1] = from[1*stride];
+  a[2] = from[2*stride];
+  a[3] = from[3*stride];
+  a[4] = from[4*stride];
+  a[5] = from[5*stride];
+  a[6] = from[6*stride];
+  a[7] = from[7*stride];
+  a[8] = from[8*stride];
+  a[9] = from[9*stride];
+  a[10] = from[10*stride];
+  a[11] = from[11*stride];
+  a[12] = from[12*stride];
+  a[13] = from[13*stride];
+  a[14] = from[14*stride];
+  a[15] = from[15*stride];
+  return pload<Packet>(a);
+}
+
+
+template<> EIGEN_DEVICE_FUNC inline Packet16c pgather<signed char, Packet16c>(const signed char* from, Index stride)
+{
+  return pgather_size16<Packet16c>(from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet16uc pgather<unsigned char, Packet16uc>(const unsigned char* from, Index stride)
+{
+  return pgather_size16<Packet16uc>(from, stride);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline void pscatter_size4(__UNPACK_TYPE__(Packet)* to, const Packet& from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[4];
+  pstore<__UNPACK_TYPE__(Packet)>(a, from);
+  to[0*stride] = a[0];
+  to[1*stride] = a[1];
+  to[2*stride] = a[2];
+  to[3*stride] = a[3];
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  pscatter_size4<Packet4f>(to, from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<int, Packet4i>(int* to, const Packet4i& from, Index stride)
+{
+  pscatter_size4<Packet4i>(to, from, stride);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline void pscatter_size8(__UNPACK_TYPE__(Packet)* to, const Packet& from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[8];
+  pstore<__UNPACK_TYPE__(Packet)>(a, from);
+  to[0*stride] = a[0];
+  to[1*stride] = a[1];
+  to[2*stride] = a[2];
+  to[3*stride] = a[3];
+  to[4*stride] = a[4];
+  to[5*stride] = a[5];
+  to[6*stride] = a[6];
+  to[7*stride] = a[7];
+}
+
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<short int, Packet8s>(short int* to, const Packet8s& from, Index stride)
+{
+  pscatter_size8<Packet8s>(to, from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<unsigned short int, Packet8us>(unsigned short int* to, const Packet8us& from, Index stride)
+{
+  pscatter_size8<Packet8us>(to, from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<bfloat16, Packet8bf>(bfloat16* to, const Packet8bf& from, Index stride)
+{
+  pscatter_size8<Packet8bf>(to, from, stride);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline void pscatter_size16(__UNPACK_TYPE__(Packet)* to, const Packet& from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[16];
+  pstore<__UNPACK_TYPE__(Packet)>(a, from);
+  to[0*stride] = a[0];
+  to[1*stride] = a[1];
+  to[2*stride] = a[2];
+  to[3*stride] = a[3];
+  to[4*stride] = a[4];
+  to[5*stride] = a[5];
+  to[6*stride] = a[6];
+  to[7*stride] = a[7];
+  to[8*stride] = a[8];
+  to[9*stride] = a[9];
+  to[10*stride] = a[10];
+  to[11*stride] = a[11];
+  to[12*stride] = a[12];
+  to[13*stride] = a[13];
+  to[14*stride] = a[14];
+  to[15*stride] = a[15];
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<signed char, Packet16c>(signed char* to, const Packet16c& from, Index stride)
+{
+  pscatter_size16<Packet16c>(to, from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<unsigned char, Packet16uc>(unsigned char* to, const Packet16uc& from, Index stride)
+{
+  pscatter_size16<Packet16uc>(to, from, stride);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f   plset<Packet4f>(const float&     a) { return pset1<Packet4f>(a) + p4f_COUNTDOWN;  }
+template<> EIGEN_STRONG_INLINE Packet4i   plset<Packet4i>(const int&       a) { return pset1<Packet4i>(a) + p4i_COUNTDOWN;  }
+template<> EIGEN_STRONG_INLINE Packet8s   plset<Packet8s>(const short int& a) { return pset1<Packet8s>(a) + p8s_COUNTDOWN; }
+template<> EIGEN_STRONG_INLINE Packet8us  plset<Packet8us>(const unsigned short int& a) { return pset1<Packet8us>(a) + p8us_COUNTDOWN; }
+template<> EIGEN_STRONG_INLINE Packet16c  plset<Packet16c>(const signed char& a)   { return pset1<Packet16c>(a) + p16c_COUNTDOWN; }
+template<> EIGEN_STRONG_INLINE Packet16uc plset<Packet16uc>(const unsigned char& a)   { return pset1<Packet16uc>(a) + p16uc_COUNTDOWN; }
+
+template<> EIGEN_STRONG_INLINE Packet4f   padd<Packet4f>  (const Packet4f&   a, const Packet4f&   b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet4i   padd<Packet4i>  (const Packet4i&   a, const Packet4i&   b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet4ui   padd<Packet4ui>  (const Packet4ui&   a, const Packet4ui&   b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet8s   padd<Packet8s>  (const Packet8s&   a, const Packet8s&   b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet8us  padd<Packet8us> (const Packet8us&  a, const Packet8us&  b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet16c  padd<Packet16c> (const Packet16c&  a, const Packet16c&  b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet16uc padd<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return a + b; }
+
+template<> EIGEN_STRONG_INLINE Packet4f   psub<Packet4f>  (const Packet4f&   a, const Packet4f&   b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet4i   psub<Packet4i>  (const Packet4i&   a, const Packet4i&   b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet8s   psub<Packet8s>  (const Packet8s&   a, const Packet8s&   b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet8us  psub<Packet8us> (const Packet8us&  a, const Packet8us&  b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet16c  psub<Packet16c> (const Packet16c&  a, const Packet16c&  b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet16uc psub<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return a - b; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return p4f_ZERO - a; }
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return p4i_ZERO - a; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4f   pmul<Packet4f>  (const Packet4f&   a, const Packet4f&   b) { return vec_madd(a,b, p4f_MZERO); }
+template<> EIGEN_STRONG_INLINE Packet4i   pmul<Packet4i>  (const Packet4i&   a, const Packet4i&   b) { return a * b; }
+template<> EIGEN_STRONG_INLINE Packet8s   pmul<Packet8s>  (const Packet8s&   a, const Packet8s&   b) { return vec_mul(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us  pmul<Packet8us> (const Packet8us&  a, const Packet8us&  b) { return vec_mul(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c  pmul<Packet16c> (const Packet16c&  a, const Packet16c&  b) { return vec_mul(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmul<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vec_mul(a,b); }
+
+
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+#ifndef __VSX__  // VSX actually provides a div instruction
+  Packet4f t, y_0, y_1;
+
+  // Altivec does not offer a divide instruction, we have to do a reciprocal approximation
+  y_0 = vec_re(b);
+
+  // Do one Newton-Raphson iteration to get the needed accuracy
+  t   = vec_nmsub(y_0, b, p4f_ONE);
+  y_1 = vec_madd(y_0, t, y_0);
+
+  return vec_madd(a, y_1, p4f_MZERO);
+#else
+  return vec_div(a, b);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/)
+{ eigen_assert(false && "packet integer division are not supported by AltiVec");
+  return pset1<Packet4i>(0);
+}
+
+// for some weird raisons, it has to be overloaded for packet of integers
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) { return vec_madd(a,b,c); }
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return a*b + c; }
+template<> EIGEN_STRONG_INLINE Packet8s pmadd(const Packet8s& a, const Packet8s& b, const Packet8s& c) { return vec_madd(a,b,c); }
+template<> EIGEN_STRONG_INLINE Packet8us pmadd(const Packet8us& a, const Packet8us& b, const Packet8us& c) { return vec_madd(a,b,c); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  #ifdef __VSX__
+  // NOTE: about 10% slower than vec_min, but consistent with std::min and SSE regarding NaN
+  Packet4f ret;
+  __asm__ ("xvcmpgesp %x0,%x1,%x2\n\txxsel %x0,%x1,%x2,%x0" : "=&wa" (ret) : "wa" (a), "wa" (b));
+  return ret;
+  #else
+  return vec_min(a, b);
+  #endif
+}
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmin<Packet8s>(const Packet8s& a, const Packet8s& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmin<Packet8us>(const Packet8us& a, const Packet8us& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmin<Packet16c>(const Packet16c& a, const Packet16c& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmin<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vec_min(a, b); }
+
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  #ifdef __VSX__
+  // NOTE: about 10% slower than vec_max, but consistent with std::max and SSE regarding NaN
+  Packet4f ret;
+  __asm__ ("xvcmpgtsp %x0,%x2,%x1\n\txxsel %x0,%x1,%x2,%x0" : "=&wa" (ret) : "wa" (a), "wa" (b));
+  return ret;
+  #else
+  return vec_max(a, b);
+  #endif
+}
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmax<Packet8s>(const Packet8s& a, const Packet8s& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmax<Packet8us>(const Packet8us& a, const Packet8us& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmax<Packet16c>(const Packet16c& a, const Packet16c& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmax<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vec_max(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_le(const Packet4f& a, const Packet4f& b) { return reinterpret_cast<Packet4f>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt(const Packet4f& a, const Packet4f& b) { return reinterpret_cast<Packet4f>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_eq(const Packet4f& a, const Packet4f& b) { return reinterpret_cast<Packet4f>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan(const Packet4f& a, const Packet4f& b) {
+  Packet4f c = reinterpret_cast<Packet4f>(vec_cmpge(a,b));
+  return vec_nor(c,c);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_le(const Packet4i& a, const Packet4i& b) { return reinterpret_cast<Packet4i>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_lt(const Packet4i& a, const Packet4i& b) { return reinterpret_cast<Packet4i>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_eq(const Packet4i& a, const Packet4i& b) { return reinterpret_cast<Packet4i>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_le(const Packet8s& a, const Packet8s& b) { return reinterpret_cast<Packet8s>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_lt(const Packet8s& a, const Packet8s& b) { return reinterpret_cast<Packet8s>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_eq(const Packet8s& a, const Packet8s& b) { return reinterpret_cast<Packet8s>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_le(const Packet8us& a, const Packet8us& b) { return reinterpret_cast<Packet8us>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_lt(const Packet8us& a, const Packet8us& b) { return reinterpret_cast<Packet8us>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_eq(const Packet8us& a, const Packet8us& b) { return reinterpret_cast<Packet8us>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_le(const Packet16c& a, const Packet16c& b) { return reinterpret_cast<Packet16c>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_lt(const Packet16c& a, const Packet16c& b) { return reinterpret_cast<Packet16c>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_eq(const Packet16c& a, const Packet16c& b) { return reinterpret_cast<Packet16c>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_le(const Packet16uc& a, const Packet16uc& b) { return reinterpret_cast<Packet16uc>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_lt(const Packet16uc& a, const Packet16uc& b) { return reinterpret_cast<Packet16uc>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_eq(const Packet16uc& a, const Packet16uc& b) { return reinterpret_cast<Packet16uc>(vec_cmpeq(a,b)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pand<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8us pand<Packet8us>(const Packet8us& a, const Packet8us& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8bf pand<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return pand<Packet8us>(a, b);
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8s por<Packet8s>(const Packet8s& a, const Packet8s& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8us por<Packet8us>(const Packet8us& a, const Packet8us& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8bf por<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return por<Packet8us>(a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8bf pxor<Packet8bf>(const Packet8bf& a, const Packet8bf& b) { 
+  return pxor<Packet8us>(a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_andc(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_andc(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pselect(const Packet4f& mask, const Packet4f& a, const Packet4f& b) {
+  return vec_sel(b, a, reinterpret_cast<Packet4ui>(mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a)
+{
+    Packet4f t = vec_add(reinterpret_cast<Packet4f>(vec_or(vec_and(reinterpret_cast<Packet4ui>(a), p4ui_SIGN), p4ui_PREV0DOT5)), a);
+    Packet4f res;
+
+#ifdef __VSX__
+    __asm__("xvrspiz %x0, %x1\n\t"
+        : "=&wa" (res)
+        : "wa" (t));
+#else
+    __asm__("vrfiz %0, %1\n\t"
+        : "=v" (res)
+        : "v" (t));
+#endif
+
+    return res;
+}
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const  Packet4f& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a) { return vec_floor(a); }
+template<> EIGEN_STRONG_INLINE Packet4f print<Packet4f>(const Packet4f& a)
+{
+    Packet4f res;
+
+    __asm__("xvrspic %x0, %x1\n\t"
+        : "=&wa" (res)
+        : "wa" (a));
+
+    return res;
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE Packet ploadu_common(const __UNPACK_TYPE__(Packet)* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD
+#ifdef _BIG_ENDIAN
+  Packet16uc MSQ, LSQ;
+  Packet16uc mask;
+  MSQ = vec_ld(0, (unsigned char *)from);          // most significant quadword
+  LSQ = vec_ld(15, (unsigned char *)from);         // least significant quadword
+  mask = vec_lvsl(0, from);                        // create the permute mask
+  //TODO: Add static_cast here
+  return (Packet) vec_perm(MSQ, LSQ, mask);           // align the data
+#else
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return vec_xl(0, const_cast<__UNPACK_TYPE__(Packet)*>(from));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from)
+{
+  return ploadu_common<Packet4f>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from)
+{
+  return ploadu_common<Packet4i>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet8s ploadu<Packet8s>(const short int* from)
+{
+  return ploadu_common<Packet8s>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet8us ploadu<Packet8us>(const unsigned short int* from)
+{
+  return ploadu_common<Packet8us>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf ploadu<Packet8bf>(const bfloat16* from)
+{
+  return ploadu_common<Packet8us>(reinterpret_cast<const unsigned short int*>(from));
+}
+template<> EIGEN_STRONG_INLINE Packet16c ploadu<Packet16c>(const signed char* from)
+{
+  return ploadu_common<Packet16c>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet16uc ploadu<Packet16uc>(const unsigned char* from)
+{
+  return ploadu_common<Packet16uc>(from);
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE Packet ploaddup_common(const __UNPACK_TYPE__(Packet)*   from)
+{
+  Packet p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet>(from);
+  else                                  p = ploadu<Packet>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
+}
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float*   from)
+{
+  return ploaddup_common<Packet4f>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int*     from)
+{
+  return ploaddup_common<Packet4i>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8s ploaddup<Packet8s>(const short int*     from)
+{
+  Packet8s p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet8s>(from);
+  else                                  p = ploadu<Packet8s>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE16_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us ploaddup<Packet8us>(const unsigned short int*     from)
+{
+  Packet8us p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet8us>(from);
+  else                                  p = ploadu<Packet8us>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE16_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8s ploadquad<Packet8s>(const short int*     from)
+{
+  Packet8s p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet8s>(from);
+  else                                  p = ploadu<Packet8s>(from);
+  return vec_perm(p, p, p16uc_QUADRUPLICATE16_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us ploadquad<Packet8us>(const unsigned short int*     from)
+{
+  Packet8us p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet8us>(from);
+  else                                  p = ploadu<Packet8us>(from);
+  return vec_perm(p, p, p16uc_QUADRUPLICATE16_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf ploadquad<Packet8bf>(const bfloat16*     from)
+{
+  return ploadquad<Packet8us>(reinterpret_cast<const unsigned short int*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16c ploaddup<Packet16c>(const signed char*     from)
+{
+  Packet16c p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet16c>(from);
+  else                                  p = ploadu<Packet16c>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE8_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16uc ploaddup<Packet16uc>(const unsigned char*     from)
+{
+  Packet16uc p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet16uc>(from);
+  else                                  p = ploadu<Packet16uc>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE8_HI);
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE void pstoreu_common(__UNPACK_TYPE__(Packet)*  to, const Packet& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE
+#ifdef _BIG_ENDIAN
+  // Taken from http://developer.apple.com/hardwaredrivers/ve/alignment.html
+  // Warning: not thread safe!
+  Packet16uc MSQ, LSQ, edges;
+  Packet16uc edgeAlign, align;
+
+  MSQ = vec_ld(0, (unsigned char *)to);                     // most significant quadword
+  LSQ = vec_ld(15, (unsigned char *)to);                    // least significant quadword
+  edgeAlign = vec_lvsl(0, to);                              // permute map to extract edges
+  edges=vec_perm(LSQ,MSQ,edgeAlign);                        // extract the edges
+  align = vec_lvsr( 0, to );                                // permute map to misalign data
+  MSQ = vec_perm(edges,(Packet16uc)from,align);             // misalign the data (MSQ)
+  LSQ = vec_perm((Packet16uc)from,edges,align);             // misalign the data (LSQ)
+  vec_st( LSQ, 15, (unsigned char *)to );                   // Store the LSQ part first
+  vec_st( MSQ, 0, (unsigned char *)to );                   // Store the MSQ part second
+#else
+  vec_xst(from, 0, to);
+#endif
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*  to, const Packet4f& from)
+{
+  pstoreu_common<Packet4f>(to, from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*      to, const Packet4i& from)
+{
+  pstoreu_common<Packet4i>(to, from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<short int>(short int*      to, const Packet8s& from)
+{
+  pstoreu_common<Packet8s>(to, from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<unsigned short int>(unsigned short int*      to, const Packet8us& from)
+{
+  pstoreu_common<Packet8us>(to, from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<bfloat16>(bfloat16*      to, const Packet8bf& from)
+{
+  pstoreu_common<Packet8us>(reinterpret_cast<unsigned short int*>(to), from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<signed char>(signed char*      to, const Packet16c& from)
+{
+  pstoreu_common<Packet16c>(to, from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<unsigned char>(unsigned char*      to, const Packet16uc& from)
+{
+  pstoreu_common<Packet16uc>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr)    { EIGEN_PPC_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*     addr)    { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { EIGEN_ALIGN16 float x; vec_ste(a, 0, &x); return x; }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { EIGEN_ALIGN16 int   x; vec_ste(a, 0, &x); return x; }
+
+template<typename Packet> EIGEN_STRONG_INLINE __UNPACK_TYPE__(Packet) pfirst_common(const Packet& a) {
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) x;
+  vec_ste(a, 0, &x);
+  return x;
+}
+
+template<> EIGEN_STRONG_INLINE short int pfirst<Packet8s>(const Packet8s& a) {
+  return pfirst_common<Packet8s>(a);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned short int pfirst<Packet8us>(const Packet8us& a) {
+  return pfirst_common<Packet8us>(a);
+}
+
+template<> EIGEN_STRONG_INLINE signed char pfirst<Packet16c>(const Packet16c& a)
+{
+  return pfirst_common<Packet16c>(a);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned char pfirst<Packet16uc>(const Packet16uc& a)
+{
+  return pfirst_common<Packet16uc>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{
+  return reinterpret_cast<Packet4f>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
+}
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a)
+{
+  return reinterpret_cast<Packet4i>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
+}
+template<> EIGEN_STRONG_INLINE Packet8s preverse(const Packet8s& a)
+{
+  return reinterpret_cast<Packet8s>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE16));
+}
+template<> EIGEN_STRONG_INLINE Packet8us preverse(const Packet8us& a)
+{
+  return reinterpret_cast<Packet8us>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE16));
+}
+template<> EIGEN_STRONG_INLINE Packet16c preverse(const Packet16c& a)
+{
+  return vec_perm(a, a, p16uc_REVERSE8);
+}
+template<> EIGEN_STRONG_INLINE Packet16uc preverse(const Packet16uc& a)
+{
+  return vec_perm(a, a, p16uc_REVERSE8);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf preverse(const Packet8bf& a)
+{
+  return preverse<Packet8us>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet8s pabs(const Packet8s& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet8us pabs(const Packet8us& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet16c pabs(const Packet16c& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet16uc pabs(const Packet16uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8bf  pabs(const Packet8bf& a) {
+  _EIGEN_DECLARE_CONST_FAST_Packet8us(abs_mask,0x7FFF);
+  return pand<Packet8us>(p8us_abs_mask, a);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(const Packet4i& a)
+{ return vec_sra(a,reinterpret_cast<Packet4ui>(pset1<Packet4i>(N))); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_right(const Packet4i& a)
+{ return vec_sr(a,reinterpret_cast<Packet4ui>(pset1<Packet4i>(N))); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_left(const Packet4i& a)
+{ return vec_sl(a,reinterpret_cast<Packet4ui>(pset1<Packet4i>(N))); }
+template<int N> EIGEN_STRONG_INLINE Packet4f plogical_shift_left(const Packet4f& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
+  Packet4ui r = vec_sl(reinterpret_cast<Packet4ui>(a), p4ui_mask);
+  return reinterpret_cast<Packet4f>(r);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet4f plogical_shift_right(const Packet4f& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
+  Packet4ui r = vec_sr(reinterpret_cast<Packet4ui>(a), p4ui_mask);
+  return reinterpret_cast<Packet4f>(r);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet4ui plogical_shift_right(const Packet4ui& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
+  return vec_sr(a, p4ui_mask);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet4ui plogical_shift_left(const Packet4ui& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
+  return vec_sl(a, p4ui_mask);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet8us plogical_shift_left(const Packet8us& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
+  return vec_sl(a, p8us_mask);
+}
+template<int N> EIGEN_STRONG_INLINE Packet8us plogical_shift_right(const Packet8us& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
+  return vec_sr(a, p8us_mask);
+}
+
+EIGEN_STRONG_INLINE Packet4f Bf16ToF32Even(const Packet8bf& bf){
+  return plogical_shift_left<16>(reinterpret_cast<Packet4f>(bf.m_val));
+}
+
+EIGEN_STRONG_INLINE Packet4f Bf16ToF32Odd(const Packet8bf& bf){
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(high_mask, 0xFFFF0000);
+  return pand<Packet4f>(
+    reinterpret_cast<Packet4f>(bf.m_val),
+    reinterpret_cast<Packet4f>(p4ui_high_mask)
+  );
+}
+
+// Simple interleaving of bool masks, prevents true values from being
+// converted to NaNs.
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16Bool(Packet4f even, Packet4f odd) {
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(high_mask, 0xFFFF0000);
+  Packet4f bf_odd, bf_even;
+  bf_odd = pand(reinterpret_cast<Packet4f>(p4ui_high_mask), odd);
+  bf_even = plogical_shift_right<16>(even);
+  return reinterpret_cast<Packet8us>(por<Packet4f>(bf_even, bf_odd));
+}
+
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16(Packet4f p4f){
+  Packet4ui input = reinterpret_cast<Packet4ui>(p4f);
+  Packet4ui lsb = plogical_shift_right<16>(input);
+  lsb = pand<Packet4ui>(lsb, reinterpret_cast<Packet4ui>(p4i_ONE));
+
+  _EIGEN_DECLARE_CONST_FAST_Packet4ui(BIAS,0x7FFFu);
+  Packet4ui rounding_bias = padd<Packet4ui>(lsb, p4ui_BIAS);
+  input = padd<Packet4ui>(input, rounding_bias);
+
+  //Test NaN and Subnormal - Begin
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(exp_mask, 0x7F800000);
+  Packet4ui exp = pand<Packet4ui>(p4ui_exp_mask, reinterpret_cast<Packet4ui>(p4f));
+
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(mantissa_mask, 0x7FFFFF);
+  Packet4ui mantissa = pand<Packet4ui>(p4ui_mantissa_mask, reinterpret_cast<Packet4ui>(p4f));
+
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(max_exp, 0x7F800000);
+  Packet4bi is_max_exp = vec_cmpeq(exp, p4ui_max_exp);
+  Packet4bi is_zero_exp = vec_cmpeq(exp, reinterpret_cast<Packet4ui>(p4i_ZERO));
+
+  Packet4bi is_mant_zero = vec_cmpeq(mantissa, reinterpret_cast<Packet4ui>(p4i_ZERO));
+  Packet4ui nan_selector = pandnot<Packet4ui>(
+      reinterpret_cast<Packet4ui>(is_max_exp),
+      reinterpret_cast<Packet4ui>(is_mant_zero)
+  );
+
+  Packet4ui subnormal_selector = pandnot<Packet4ui>(
+      reinterpret_cast<Packet4ui>(is_zero_exp),
+      reinterpret_cast<Packet4ui>(is_mant_zero)
+  );
+
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(nan, 0x7FC00000);
+  input = vec_sel(input, p4ui_nan, nan_selector);
+  input = vec_sel(input, reinterpret_cast<Packet4ui>(p4f), subnormal_selector);
+  //Test NaN and Subnormal - End
+
+  input = plogical_shift_right<16>(input);
+  return reinterpret_cast<Packet8us>(input);
+}
+
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16(Packet4f even, Packet4f odd){
+  Packet4f bf_odd, bf_even;
+  bf_odd = reinterpret_cast<Packet4f>(F32ToBf16(odd).m_val);
+  bf_odd = plogical_shift_left<16>(bf_odd);
+  bf_even = reinterpret_cast<Packet4f>(F32ToBf16(even).m_val);
+  return reinterpret_cast<Packet8us>(por<Packet4f>(bf_even, bf_odd));
+}
+#define BF16_TO_F32_UNARY_OP_WRAPPER(OP, A) \
+  Packet4f a_even = Bf16ToF32Even(A);\
+  Packet4f a_odd = Bf16ToF32Odd(A);\
+  Packet4f op_even = OP(a_even);\
+  Packet4f op_odd = OP(a_odd);\
+  return F32ToBf16(op_even, op_odd);\
+
+#define BF16_TO_F32_BINARY_OP_WRAPPER(OP, A, B) \
+  Packet4f a_even = Bf16ToF32Even(A);\
+  Packet4f a_odd = Bf16ToF32Odd(A);\
+  Packet4f b_even = Bf16ToF32Even(B);\
+  Packet4f b_odd = Bf16ToF32Odd(B);\
+  Packet4f op_even = OP(a_even, b_even);\
+  Packet4f op_odd = OP(a_odd, b_odd);\
+  return F32ToBf16(op_even, op_odd);\
+
+#define BF16_TO_F32_BINARY_OP_WRAPPER_BOOL(OP, A, B) \
+  Packet4f a_even = Bf16ToF32Even(A);\
+  Packet4f a_odd = Bf16ToF32Odd(A);\
+  Packet4f b_even = Bf16ToF32Even(B);\
+  Packet4f b_odd = Bf16ToF32Odd(B);\
+  Packet4f op_even = OP(a_even, b_even);\
+  Packet4f op_odd = OP(a_odd, b_odd);\
+  return F32ToBf16Bool(op_even, op_odd);\
+
+template<> EIGEN_STRONG_INLINE Packet8bf padd<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(padd<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pmul<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(pmul<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pdiv<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(pdiv<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pnegate<Packet8bf>(const Packet8bf& a) {
+  BF16_TO_F32_UNARY_OP_WRAPPER(pnegate<Packet4f>, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf psub<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(psub<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf psqrt<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(vec_sqrt, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf prsqrt<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(prsqrt<Packet4f>, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pexp<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(pexp_float, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pldexp<Packet4f>(const Packet4f& a, const Packet4f& exponent) {
+  return pldexp_generic(a,exponent);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pldexp<Packet8bf> (const Packet8bf& a, const Packet8bf& exponent){
+  BF16_TO_F32_BINARY_OP_WRAPPER(pldexp<Packet4f>, a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pfrexp<Packet4f>(const Packet4f& a, Packet4f& exponent) {
+  return pfrexp_generic(a,exponent);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pfrexp<Packet8bf> (const Packet8bf& a, Packet8bf& e){
+  Packet4f a_even = Bf16ToF32Even(a);
+  Packet4f a_odd = Bf16ToF32Odd(a);
+  Packet4f e_even;
+  Packet4f e_odd;
+  Packet4f op_even = pfrexp<Packet4f>(a_even, e_even);
+  Packet4f op_odd = pfrexp<Packet4f>(a_odd, e_odd);
+  e = F32ToBf16(e_even, e_odd);
+  return F32ToBf16(op_even, op_odd);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf psin<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(psin_float, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pcos<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(pcos_float, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf plog<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(plog_float, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pfloor<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(pfloor<Packet4f>, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pceil<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(pceil<Packet4f>, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pround<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(pround<Packet4f>, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf print<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(print<Packet4f>, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pmadd(const Packet8bf& a, const Packet8bf& b, const Packet8bf& c) {
+  Packet4f a_even = Bf16ToF32Even(a);
+  Packet4f a_odd = Bf16ToF32Odd(a);
+  Packet4f b_even = Bf16ToF32Even(b);
+  Packet4f b_odd = Bf16ToF32Odd(b);
+  Packet4f c_even = Bf16ToF32Even(c);
+  Packet4f c_odd = Bf16ToF32Odd(c);
+  Packet4f pmadd_even = pmadd<Packet4f>(a_even, b_even, c_even);
+  Packet4f pmadd_odd = pmadd<Packet4f>(a_odd, b_odd, c_odd);
+  return F32ToBf16(pmadd_even, pmadd_odd);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pmin<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(pmin<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pmax<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(pmax<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_lt(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER_BOOL(pcmp_lt<Packet4f>, a, b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_lt_or_nan(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER_BOOL(pcmp_lt_or_nan<Packet4f>, a, b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_le(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER_BOOL(pcmp_le<Packet4f>, a, b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_eq(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER_BOOL(pcmp_eq<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 pfirst(const Packet8bf& a) {
+  return Eigen::bfloat16_impl::raw_uint16_to_bfloat16((pfirst<Packet8us>(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf ploaddup<Packet8bf>(const  bfloat16*     from)
+{
+  return ploaddup<Packet8us>(reinterpret_cast<const unsigned short int*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf plset<Packet8bf>(const bfloat16& a) {
+  bfloat16 countdown[8] = { bfloat16(0), bfloat16(1), bfloat16(2), bfloat16(3),
+                            bfloat16(4), bfloat16(5), bfloat16(6), bfloat16(7) };
+  return padd<Packet8bf>(pset1<Packet8bf>(a), pload<Packet8bf>(countdown));
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, sum;
+  b   = vec_sld(a, a, 8);
+  sum = a + b;
+  b   = vec_sld(sum, sum, 4);
+  sum += b;
+  return pfirst(sum);
+}
+
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i sum;
+  sum = vec_sums(a, p4i_ZERO);
+#ifdef _BIG_ENDIAN
+  sum = vec_sld(sum, p4i_ZERO, 12);
+#else
+  sum = vec_sld(p4i_ZERO, sum, 4);
+#endif
+  return pfirst(sum);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux<Packet8bf>(const Packet8bf& a)
+{
+  float redux_even = predux<Packet4f>(Bf16ToF32Even(a));
+  float redux_odd  = predux<Packet4f>(Bf16ToF32Odd(a));
+  float f32_result = redux_even + redux_odd;
+  return bfloat16(f32_result);
+}
+template<typename Packet> EIGEN_STRONG_INLINE __UNPACK_TYPE__(Packet) predux_size8(const Packet& a)
+{
+  union{
+    Packet v;
+    __UNPACK_TYPE__(Packet) n[8];
+  } vt;
+  vt.v = a;
+
+  EIGEN_ALIGN16 int first_loader[4] = { vt.n[0], vt.n[1], vt.n[2], vt.n[3] };
+  EIGEN_ALIGN16 int second_loader[4] = { vt.n[4], vt.n[5], vt.n[6], vt.n[7] };
+  Packet4i first_half  = pload<Packet4i>(first_loader);
+  Packet4i second_half = pload<Packet4i>(second_loader);
+
+  return static_cast<__UNPACK_TYPE__(Packet)>(predux(first_half) + predux(second_half));
+}
+
+template<> EIGEN_STRONG_INLINE short int predux<Packet8s>(const Packet8s& a)
+{
+  return predux_size8<Packet8s>(a);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned short int predux<Packet8us>(const Packet8us& a)
+{
+  return predux_size8<Packet8us>(a);
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE __UNPACK_TYPE__(Packet) predux_size16(const Packet& a)
+{
+  union{
+    Packet v;
+    __UNPACK_TYPE__(Packet) n[16];
+  } vt;
+  vt.v = a;
+
+  EIGEN_ALIGN16 int first_loader[4] = { vt.n[0], vt.n[1], vt.n[2], vt.n[3] };
+  EIGEN_ALIGN16 int second_loader[4] = { vt.n[4], vt.n[5], vt.n[6], vt.n[7] };
+  EIGEN_ALIGN16 int third_loader[4] = { vt.n[8], vt.n[9], vt.n[10], vt.n[11] };
+  EIGEN_ALIGN16 int fourth_loader[4] = { vt.n[12], vt.n[13], vt.n[14], vt.n[15] };
+
+  Packet4i first_quarter = pload<Packet4i>(first_loader);
+  Packet4i second_quarter = pload<Packet4i>(second_loader);
+  Packet4i third_quarter = pload<Packet4i>(third_loader);
+  Packet4i fourth_quarter = pload<Packet4i>(fourth_loader);
+
+  return static_cast<__UNPACK_TYPE__(Packet)>(predux(first_quarter) + predux(second_quarter)
+		                  + predux(third_quarter) + predux(fourth_quarter));
+}
+
+template<> EIGEN_STRONG_INLINE signed char predux<Packet16c>(const Packet16c& a)
+{
+  return predux_size16<Packet16c>(a);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned char predux<Packet16uc>(const Packet16uc& a)
+{
+  return predux_size16<Packet16uc>(a);
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  Packet4f prod;
+  prod = pmul(a, vec_sld(a, a, 8));
+  return pfirst(pmul(prod, vec_sld(prod, prod, 4)));
+}
+
+template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
+{
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  return aux[0] * aux[1] * aux[2] * aux[3];
+}
+
+template<> EIGEN_STRONG_INLINE short int predux_mul<Packet8s>(const Packet8s& a)
+{
+  Packet8s pair, quad, octo;
+
+  pair = vec_mul(a, vec_sld(a, a, 8));
+  quad = vec_mul(pair, vec_sld(pair, pair, 4));
+  octo = vec_mul(quad, vec_sld(quad, quad, 2));
+
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned short int predux_mul<Packet8us>(const Packet8us& a)
+{
+  Packet8us pair, quad, octo;
+
+  pair = vec_mul(a, vec_sld(a, a, 8));
+  quad = vec_mul(pair, vec_sld(pair, pair, 4));
+  octo = vec_mul(quad, vec_sld(quad, quad, 2));
+
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_mul<Packet8bf>(const Packet8bf& a)
+{
+  float redux_even = predux_mul<Packet4f>(Bf16ToF32Even(a));
+  float redux_odd  = predux_mul<Packet4f>(Bf16ToF32Odd(a));
+  float f32_result = redux_even * redux_odd;
+  return bfloat16(f32_result);
+}
+
+
+template<> EIGEN_STRONG_INLINE signed char predux_mul<Packet16c>(const Packet16c& a)
+{
+  Packet16c pair, quad, octo, result;
+
+  pair = vec_mul(a, vec_sld(a, a, 8));
+  quad = vec_mul(pair, vec_sld(pair, pair, 4));
+  octo = vec_mul(quad, vec_sld(quad, quad, 2));
+  result = vec_mul(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned char predux_mul<Packet16uc>(const Packet16uc& a)
+{
+  Packet16uc pair, quad, octo, result;
+
+  pair = vec_mul(a, vec_sld(a, a, 8));
+  quad = vec_mul(pair, vec_sld(pair, pair, 4));
+  octo = vec_mul(quad, vec_sld(quad, quad, 2));
+  result = vec_mul(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+
+// min
+template<typename Packet> EIGEN_STRONG_INLINE
+__UNPACK_TYPE__(Packet) predux_min4(const Packet& a)
+{
+  Packet b, res;
+  b = vec_min(a, vec_sld(a, a, 8));
+  res = vec_min(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  return predux_min4<Packet4f>(a);
+}
+
+template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
+{
+  return predux_min4<Packet4i>(a);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_min<Packet8bf>(const Packet8bf& a)
+{
+  float redux_even = predux_min<Packet4f>(Bf16ToF32Even(a));
+  float redux_odd  = predux_min<Packet4f>(Bf16ToF32Odd(a));
+  float f32_result = (std::min)(redux_even, redux_odd);
+  return bfloat16(f32_result);
+}
+
+template<> EIGEN_STRONG_INLINE short int predux_min<Packet8s>(const Packet8s& a)
+{
+  Packet8s pair, quad, octo;
+  
+  //pair = { Min(a0,a4), Min(a1,a5), Min(a2,a6), Min(a3,a7) }
+  pair = vec_min(a, vec_sld(a, a, 8)); 
+
+  //quad = { Min(a0, a4, a2, a6), Min(a1, a5, a3, a7) }
+  quad = vec_min(pair, vec_sld(pair, pair, 4));
+
+  //octo = { Min(a0, a4, a2, a6, a1, a5, a3, a7) }
+  octo = vec_min(quad, vec_sld(quad, quad, 2));
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned short int predux_min<Packet8us>(const Packet8us& a)
+{
+  Packet8us pair, quad, octo;
+  
+  //pair = { Min(a0,a4), Min(a1,a5), Min(a2,a6), Min(a3,a7) }
+  pair = vec_min(a, vec_sld(a, a, 8)); 
+
+  //quad = { Min(a0, a4, a2, a6), Min(a1, a5, a3, a7) }
+  quad = vec_min(pair, vec_sld(pair, pair, 4));
+
+  //octo = { Min(a0, a4, a2, a6, a1, a5, a3, a7) }
+  octo = vec_min(quad, vec_sld(quad, quad, 2));
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE signed char predux_min<Packet16c>(const Packet16c& a)
+{
+  Packet16c pair, quad, octo, result;
+
+  pair = vec_min(a, vec_sld(a, a, 8));
+  quad = vec_min(pair, vec_sld(pair, pair, 4));
+  octo = vec_min(quad, vec_sld(quad, quad, 2));
+  result = vec_min(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned char predux_min<Packet16uc>(const Packet16uc& a)
+{
+  Packet16uc pair, quad, octo, result;
+
+  pair = vec_min(a, vec_sld(a, a, 8));
+  quad = vec_min(pair, vec_sld(pair, pair, 4));
+  octo = vec_min(quad, vec_sld(quad, quad, 2));
+  result = vec_min(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+// max
+template<typename Packet> EIGEN_STRONG_INLINE __UNPACK_TYPE__(Packet) predux_max4(const Packet& a)
+{
+  Packet b, res;
+  b = vec_max(a, vec_sld(a, a, 8));
+  res = vec_max(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  return predux_max4<Packet4f>(a);
+}
+
+template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
+{
+  return predux_max4<Packet4i>(a);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_max<Packet8bf>(const Packet8bf& a)
+{
+  float redux_even = predux_max<Packet4f>(Bf16ToF32Even(a));
+  float redux_odd  = predux_max<Packet4f>(Bf16ToF32Odd(a));
+  float f32_result = (std::max)(redux_even, redux_odd);
+  return bfloat16(f32_result);
+}
+
+template<> EIGEN_STRONG_INLINE short int predux_max<Packet8s>(const Packet8s& a)
+{
+  Packet8s pair, quad, octo;
+  
+  //pair = { Max(a0,a4), Max(a1,a5), Max(a2,a6), Max(a3,a7) }
+  pair = vec_max(a, vec_sld(a, a, 8)); 
+
+  //quad = { Max(a0, a4, a2, a6), Max(a1, a5, a3, a7) }
+  quad = vec_max(pair, vec_sld(pair, pair, 4));
+
+  //octo = { Max(a0, a4, a2, a6, a1, a5, a3, a7) }
+  octo = vec_max(quad, vec_sld(quad, quad, 2));
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned short int predux_max<Packet8us>(const Packet8us& a)
+{
+  Packet8us pair, quad, octo;
+  
+  //pair = { Max(a0,a4), Max(a1,a5), Max(a2,a6), Max(a3,a7) }
+  pair = vec_max(a, vec_sld(a, a, 8)); 
+
+  //quad = { Max(a0, a4, a2, a6), Max(a1, a5, a3, a7) }
+  quad = vec_max(pair, vec_sld(pair, pair, 4));
+
+  //octo = { Max(a0, a4, a2, a6, a1, a5, a3, a7) }
+  octo = vec_max(quad, vec_sld(quad, quad, 2));
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE signed char predux_max<Packet16c>(const Packet16c& a)
+{
+  Packet16c pair, quad, octo, result;
+
+  pair = vec_max(a, vec_sld(a, a, 8));
+  quad = vec_max(pair, vec_sld(pair, pair, 4));
+  octo = vec_max(quad, vec_sld(quad, quad, 2));
+  result = vec_max(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned char predux_max<Packet16uc>(const Packet16uc& a)
+{
+  Packet16uc pair, quad, octo, result;
+
+  pair = vec_max(a, vec_sld(a, a, 8));
+  quad = vec_max(pair, vec_sld(pair, pair, 4));
+  octo = vec_max(quad, vec_sld(quad, quad, 2));
+  result = vec_max(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+
+template<> EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x)
+{
+  return vec_any_ne(x, pzero(x));
+}
+
+template <typename T> EIGEN_DEVICE_FUNC inline void
+ptranpose_common(PacketBlock<T,4>& kernel){
+  T t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  ptranpose_common<Packet4f>(kernel);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4i,4>& kernel) {
+  ptranpose_common<Packet4i>(kernel);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8s,4>& kernel) {
+  Packet8s t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8us,4>& kernel) {
+  Packet8us t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8bf,4>& kernel) {
+  Packet8us t0, t1, t2, t3;
+
+  t0 = vec_mergeh(kernel.packet[0].m_val, kernel.packet[2].m_val);
+  t1 = vec_mergel(kernel.packet[0].m_val, kernel.packet[2].m_val);
+  t2 = vec_mergeh(kernel.packet[1].m_val, kernel.packet[3].m_val);
+  t3 = vec_mergel(kernel.packet[1].m_val, kernel.packet[3].m_val);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16c,4>& kernel) {
+  Packet16c t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16uc,4>& kernel) {
+  Packet16uc t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8s,8>& kernel) {
+  Packet8s v[8], sum[8];
+
+  v[0] = vec_mergeh(kernel.packet[0], kernel.packet[4]);
+  v[1] = vec_mergel(kernel.packet[0], kernel.packet[4]);
+  v[2] = vec_mergeh(kernel.packet[1], kernel.packet[5]);
+  v[3] = vec_mergel(kernel.packet[1], kernel.packet[5]);
+  v[4] = vec_mergeh(kernel.packet[2], kernel.packet[6]);
+  v[5] = vec_mergel(kernel.packet[2], kernel.packet[6]);
+  v[6] = vec_mergeh(kernel.packet[3], kernel.packet[7]);
+  v[7] = vec_mergel(kernel.packet[3], kernel.packet[7]);
+  sum[0] = vec_mergeh(v[0], v[4]);
+  sum[1] = vec_mergel(v[0], v[4]);
+  sum[2] = vec_mergeh(v[1], v[5]);
+  sum[3] = vec_mergel(v[1], v[5]);
+  sum[4] = vec_mergeh(v[2], v[6]);
+  sum[5] = vec_mergel(v[2], v[6]);
+  sum[6] = vec_mergeh(v[3], v[7]);
+  sum[7] = vec_mergel(v[3], v[7]);
+
+  kernel.packet[0] = vec_mergeh(sum[0], sum[4]);
+  kernel.packet[1] = vec_mergel(sum[0], sum[4]);
+  kernel.packet[2] = vec_mergeh(sum[1], sum[5]);
+  kernel.packet[3] = vec_mergel(sum[1], sum[5]);
+  kernel.packet[4] = vec_mergeh(sum[2], sum[6]);
+  kernel.packet[5] = vec_mergel(sum[2], sum[6]);
+  kernel.packet[6] = vec_mergeh(sum[3], sum[7]);
+  kernel.packet[7] = vec_mergel(sum[3], sum[7]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8us,8>& kernel) {
+  Packet8us v[8], sum[8];
+
+  v[0] = vec_mergeh(kernel.packet[0], kernel.packet[4]);
+  v[1] = vec_mergel(kernel.packet[0], kernel.packet[4]);
+  v[2] = vec_mergeh(kernel.packet[1], kernel.packet[5]);
+  v[3] = vec_mergel(kernel.packet[1], kernel.packet[5]);
+  v[4] = vec_mergeh(kernel.packet[2], kernel.packet[6]);
+  v[5] = vec_mergel(kernel.packet[2], kernel.packet[6]);
+  v[6] = vec_mergeh(kernel.packet[3], kernel.packet[7]);
+  v[7] = vec_mergel(kernel.packet[3], kernel.packet[7]);
+  sum[0] = vec_mergeh(v[0], v[4]);
+  sum[1] = vec_mergel(v[0], v[4]);
+  sum[2] = vec_mergeh(v[1], v[5]);
+  sum[3] = vec_mergel(v[1], v[5]);
+  sum[4] = vec_mergeh(v[2], v[6]);
+  sum[5] = vec_mergel(v[2], v[6]);
+  sum[6] = vec_mergeh(v[3], v[7]);
+  sum[7] = vec_mergel(v[3], v[7]);
+
+  kernel.packet[0] = vec_mergeh(sum[0], sum[4]);
+  kernel.packet[1] = vec_mergel(sum[0], sum[4]);
+  kernel.packet[2] = vec_mergeh(sum[1], sum[5]);
+  kernel.packet[3] = vec_mergel(sum[1], sum[5]);
+  kernel.packet[4] = vec_mergeh(sum[2], sum[6]);
+  kernel.packet[5] = vec_mergel(sum[2], sum[6]);
+  kernel.packet[6] = vec_mergeh(sum[3], sum[7]);
+  kernel.packet[7] = vec_mergel(sum[3], sum[7]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8bf,8>& kernel) {
+  Packet8bf v[8], sum[8];
+
+  v[0] = vec_mergeh(kernel.packet[0].m_val, kernel.packet[4].m_val);
+  v[1] = vec_mergel(kernel.packet[0].m_val, kernel.packet[4].m_val);
+  v[2] = vec_mergeh(kernel.packet[1].m_val, kernel.packet[5].m_val);
+  v[3] = vec_mergel(kernel.packet[1].m_val, kernel.packet[5].m_val);
+  v[4] = vec_mergeh(kernel.packet[2].m_val, kernel.packet[6].m_val);
+  v[5] = vec_mergel(kernel.packet[2].m_val, kernel.packet[6].m_val);
+  v[6] = vec_mergeh(kernel.packet[3].m_val, kernel.packet[7].m_val);
+  v[7] = vec_mergel(kernel.packet[3].m_val, kernel.packet[7].m_val);
+  sum[0] = vec_mergeh(v[0].m_val, v[4].m_val);
+  sum[1] = vec_mergel(v[0].m_val, v[4].m_val);
+  sum[2] = vec_mergeh(v[1].m_val, v[5].m_val);
+  sum[3] = vec_mergel(v[1].m_val, v[5].m_val);
+  sum[4] = vec_mergeh(v[2].m_val, v[6].m_val);
+  sum[5] = vec_mergel(v[2].m_val, v[6].m_val);
+  sum[6] = vec_mergeh(v[3].m_val, v[7].m_val);
+  sum[7] = vec_mergel(v[3].m_val, v[7].m_val);
+
+  kernel.packet[0] = vec_mergeh(sum[0].m_val, sum[4].m_val);
+  kernel.packet[1] = vec_mergel(sum[0].m_val, sum[4].m_val);
+  kernel.packet[2] = vec_mergeh(sum[1].m_val, sum[5].m_val);
+  kernel.packet[3] = vec_mergel(sum[1].m_val, sum[5].m_val);
+  kernel.packet[4] = vec_mergeh(sum[2].m_val, sum[6].m_val);
+  kernel.packet[5] = vec_mergel(sum[2].m_val, sum[6].m_val);
+  kernel.packet[6] = vec_mergeh(sum[3].m_val, sum[7].m_val);
+  kernel.packet[7] = vec_mergel(sum[3].m_val, sum[7].m_val);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16c,16>& kernel) {
+  Packet16c step1[16], step2[16], step3[16];
+
+  step1[0] = vec_mergeh(kernel.packet[0], kernel.packet[8]);
+  step1[1] = vec_mergel(kernel.packet[0], kernel.packet[8]);
+  step1[2] = vec_mergeh(kernel.packet[1], kernel.packet[9]);
+  step1[3] = vec_mergel(kernel.packet[1], kernel.packet[9]);
+  step1[4] = vec_mergeh(kernel.packet[2], kernel.packet[10]);
+  step1[5] = vec_mergel(kernel.packet[2], kernel.packet[10]);
+  step1[6] = vec_mergeh(kernel.packet[3], kernel.packet[11]);
+  step1[7] = vec_mergel(kernel.packet[3], kernel.packet[11]);
+  step1[8] = vec_mergeh(kernel.packet[4], kernel.packet[12]);
+  step1[9] = vec_mergel(kernel.packet[4], kernel.packet[12]);
+  step1[10] = vec_mergeh(kernel.packet[5], kernel.packet[13]);
+  step1[11] = vec_mergel(kernel.packet[5], kernel.packet[13]);
+  step1[12] = vec_mergeh(kernel.packet[6], kernel.packet[14]);
+  step1[13] = vec_mergel(kernel.packet[6], kernel.packet[14]);
+  step1[14] = vec_mergeh(kernel.packet[7], kernel.packet[15]);
+  step1[15] = vec_mergel(kernel.packet[7], kernel.packet[15]);
+
+  step2[0]  = vec_mergeh(step1[0], step1[8]);
+  step2[1]  = vec_mergel(step1[0], step1[8]);
+  step2[2]  = vec_mergeh(step1[1], step1[9]);
+  step2[3]  = vec_mergel(step1[1], step1[9]);
+  step2[4]  = vec_mergeh(step1[2], step1[10]);
+  step2[5]  = vec_mergel(step1[2], step1[10]);
+  step2[6]  = vec_mergeh(step1[3], step1[11]);
+  step2[7]  = vec_mergel(step1[3], step1[11]);
+  step2[8]  = vec_mergeh(step1[4], step1[12]);
+  step2[9]  = vec_mergel(step1[4], step1[12]);
+  step2[10] = vec_mergeh(step1[5], step1[13]);
+  step2[11] = vec_mergel(step1[5], step1[13]);
+  step2[12] = vec_mergeh(step1[6], step1[14]);
+  step2[13] = vec_mergel(step1[6], step1[14]);
+  step2[14] = vec_mergeh(step1[7], step1[15]);
+  step2[15] = vec_mergel(step1[7], step1[15]);
+
+  step3[0]  = vec_mergeh(step2[0], step2[8]);
+  step3[1]  = vec_mergel(step2[0], step2[8]);
+  step3[2]  = vec_mergeh(step2[1], step2[9]);
+  step3[3]  = vec_mergel(step2[1], step2[9]);
+  step3[4]  = vec_mergeh(step2[2], step2[10]);
+  step3[5]  = vec_mergel(step2[2], step2[10]);
+  step3[6]  = vec_mergeh(step2[3], step2[11]);
+  step3[7]  = vec_mergel(step2[3], step2[11]);
+  step3[8]  = vec_mergeh(step2[4], step2[12]);
+  step3[9]  = vec_mergel(step2[4], step2[12]);
+  step3[10] = vec_mergeh(step2[5], step2[13]);
+  step3[11] = vec_mergel(step2[5], step2[13]);
+  step3[12] = vec_mergeh(step2[6], step2[14]);
+  step3[13] = vec_mergel(step2[6], step2[14]);
+  step3[14] = vec_mergeh(step2[7], step2[15]);
+  step3[15] = vec_mergel(step2[7], step2[15]);
+
+  kernel.packet[0]  = vec_mergeh(step3[0], step3[8]);
+  kernel.packet[1]  = vec_mergel(step3[0], step3[8]);
+  kernel.packet[2]  = vec_mergeh(step3[1], step3[9]);
+  kernel.packet[3]  = vec_mergel(step3[1], step3[9]);
+  kernel.packet[4]  = vec_mergeh(step3[2], step3[10]);
+  kernel.packet[5]  = vec_mergel(step3[2], step3[10]);
+  kernel.packet[6]  = vec_mergeh(step3[3], step3[11]);
+  kernel.packet[7]  = vec_mergel(step3[3], step3[11]);
+  kernel.packet[8]  = vec_mergeh(step3[4], step3[12]);
+  kernel.packet[9]  = vec_mergel(step3[4], step3[12]);
+  kernel.packet[10] = vec_mergeh(step3[5], step3[13]);
+  kernel.packet[11] = vec_mergel(step3[5], step3[13]);
+  kernel.packet[12] = vec_mergeh(step3[6], step3[14]);
+  kernel.packet[13] = vec_mergel(step3[6], step3[14]);
+  kernel.packet[14] = vec_mergeh(step3[7], step3[15]);
+  kernel.packet[15] = vec_mergel(step3[7], step3[15]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16uc,16>& kernel) {
+  Packet16uc step1[16], step2[16], step3[16];
+
+  step1[0] = vec_mergeh(kernel.packet[0], kernel.packet[8]);
+  step1[1] = vec_mergel(kernel.packet[0], kernel.packet[8]);
+  step1[2] = vec_mergeh(kernel.packet[1], kernel.packet[9]);
+  step1[3] = vec_mergel(kernel.packet[1], kernel.packet[9]);
+  step1[4] = vec_mergeh(kernel.packet[2], kernel.packet[10]);
+  step1[5] = vec_mergel(kernel.packet[2], kernel.packet[10]);
+  step1[6] = vec_mergeh(kernel.packet[3], kernel.packet[11]);
+  step1[7] = vec_mergel(kernel.packet[3], kernel.packet[11]);
+  step1[8] = vec_mergeh(kernel.packet[4], kernel.packet[12]);
+  step1[9] = vec_mergel(kernel.packet[4], kernel.packet[12]);
+  step1[10] = vec_mergeh(kernel.packet[5], kernel.packet[13]);
+  step1[11] = vec_mergel(kernel.packet[5], kernel.packet[13]);
+  step1[12] = vec_mergeh(kernel.packet[6], kernel.packet[14]);
+  step1[13] = vec_mergel(kernel.packet[6], kernel.packet[14]);
+  step1[14] = vec_mergeh(kernel.packet[7], kernel.packet[15]);
+  step1[15] = vec_mergel(kernel.packet[7], kernel.packet[15]);
+
+  step2[0]  = vec_mergeh(step1[0], step1[8]);
+  step2[1]  = vec_mergel(step1[0], step1[8]);
+  step2[2]  = vec_mergeh(step1[1], step1[9]);
+  step2[3]  = vec_mergel(step1[1], step1[9]);
+  step2[4]  = vec_mergeh(step1[2], step1[10]);
+  step2[5]  = vec_mergel(step1[2], step1[10]);
+  step2[6]  = vec_mergeh(step1[3], step1[11]);
+  step2[7]  = vec_mergel(step1[3], step1[11]);
+  step2[8]  = vec_mergeh(step1[4], step1[12]);
+  step2[9]  = vec_mergel(step1[4], step1[12]);
+  step2[10] = vec_mergeh(step1[5], step1[13]);
+  step2[11] = vec_mergel(step1[5], step1[13]);
+  step2[12] = vec_mergeh(step1[6], step1[14]);
+  step2[13] = vec_mergel(step1[6], step1[14]);
+  step2[14] = vec_mergeh(step1[7], step1[15]);
+  step2[15] = vec_mergel(step1[7], step1[15]);
+
+  step3[0]  = vec_mergeh(step2[0], step2[8]);
+  step3[1]  = vec_mergel(step2[0], step2[8]);
+  step3[2]  = vec_mergeh(step2[1], step2[9]);
+  step3[3]  = vec_mergel(step2[1], step2[9]);
+  step3[4]  = vec_mergeh(step2[2], step2[10]);
+  step3[5]  = vec_mergel(step2[2], step2[10]);
+  step3[6]  = vec_mergeh(step2[3], step2[11]);
+  step3[7]  = vec_mergel(step2[3], step2[11]);
+  step3[8]  = vec_mergeh(step2[4], step2[12]);
+  step3[9]  = vec_mergel(step2[4], step2[12]);
+  step3[10] = vec_mergeh(step2[5], step2[13]);
+  step3[11] = vec_mergel(step2[5], step2[13]);
+  step3[12] = vec_mergeh(step2[6], step2[14]);
+  step3[13] = vec_mergel(step2[6], step2[14]);
+  step3[14] = vec_mergeh(step2[7], step2[15]);
+  step3[15] = vec_mergel(step2[7], step2[15]);
+
+  kernel.packet[0]  = vec_mergeh(step3[0], step3[8]);
+  kernel.packet[1]  = vec_mergel(step3[0], step3[8]);
+  kernel.packet[2]  = vec_mergeh(step3[1], step3[9]);
+  kernel.packet[3]  = vec_mergel(step3[1], step3[9]);
+  kernel.packet[4]  = vec_mergeh(step3[2], step3[10]);
+  kernel.packet[5]  = vec_mergel(step3[2], step3[10]);
+  kernel.packet[6]  = vec_mergeh(step3[3], step3[11]);
+  kernel.packet[7]  = vec_mergel(step3[3], step3[11]);
+  kernel.packet[8]  = vec_mergeh(step3[4], step3[12]);
+  kernel.packet[9]  = vec_mergel(step3[4], step3[12]);
+  kernel.packet[10] = vec_mergeh(step3[5], step3[13]);
+  kernel.packet[11] = vec_mergel(step3[5], step3[13]);
+  kernel.packet[12] = vec_mergeh(step3[6], step3[14]);
+  kernel.packet[13] = vec_mergel(step3[6], step3[14]);
+  kernel.packet[14] = vec_mergeh(step3[7], step3[15]);
+  kernel.packet[15] = vec_mergel(step3[7], step3[15]);
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE
+Packet pblend4(const Selector<4>& ifPacket, const Packet& thenPacket, const Packet& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
+  Packet4ui mask = reinterpret_cast<Packet4ui>(vec_cmpeq(reinterpret_cast<Packet4ui>(select), reinterpret_cast<Packet4ui>(p4i_ONE)));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket) {
+  return pblend4<Packet4i>(ifPacket, thenPacket, elsePacket);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  return pblend4<Packet4f>(ifPacket, thenPacket, elsePacket);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8s pblend(const Selector<8>& ifPacket, const Packet8s& thenPacket, const Packet8s& elsePacket) {
+  Packet8us select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3],
+                       ifPacket.select[4], ifPacket.select[5], ifPacket.select[6], ifPacket.select[7] };
+  Packet8us mask = reinterpret_cast<Packet8us>(vec_cmpeq(select, p8us_ONE));
+  Packet8s result = vec_sel(elsePacket, thenPacket, mask);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us pblend(const Selector<8>& ifPacket, const Packet8us& thenPacket, const Packet8us& elsePacket) {
+  Packet8us select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3],
+                       ifPacket.select[4], ifPacket.select[5], ifPacket.select[6], ifPacket.select[7] };
+  Packet8us mask = reinterpret_cast<Packet8us>(vec_cmpeq(reinterpret_cast<Packet8us>(select), p8us_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pblend(const Selector<8>& ifPacket, const Packet8bf& thenPacket, const Packet8bf& elsePacket) {
+  return pblend<Packet8us>(ifPacket, thenPacket, elsePacket);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16c pblend(const Selector<16>& ifPacket, const Packet16c& thenPacket, const Packet16c& elsePacket) {
+  Packet16uc select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3],
+                       ifPacket.select[4], ifPacket.select[5], ifPacket.select[6], ifPacket.select[7],
+                       ifPacket.select[8], ifPacket.select[9], ifPacket.select[10], ifPacket.select[11],
+                       ifPacket.select[12], ifPacket.select[13], ifPacket.select[14], ifPacket.select[15] };
+
+  Packet16uc mask = reinterpret_cast<Packet16uc>(vec_cmpeq(reinterpret_cast<Packet16uc>(select), p16uc_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16uc pblend(const Selector<16>& ifPacket, const Packet16uc& thenPacket, const Packet16uc& elsePacket) {
+  Packet16uc select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3],
+                       ifPacket.select[4], ifPacket.select[5], ifPacket.select[6], ifPacket.select[7],
+                       ifPacket.select[8], ifPacket.select[9], ifPacket.select[10], ifPacket.select[11],
+                       ifPacket.select[12], ifPacket.select[13], ifPacket.select[14], ifPacket.select[15] };
+
+  Packet16uc mask = reinterpret_cast<Packet16uc>(vec_cmpeq(reinterpret_cast<Packet16uc>(select), p16uc_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+template <>
+struct type_casting_traits<float, int> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<int, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<bfloat16, unsigned short int> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<unsigned short int, bfloat16> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4i pcast<Packet4f, Packet4i>(const Packet4f& a) {
+  return vec_cts(a,0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4ui pcast<Packet4f, Packet4ui>(const Packet4f& a) {
+  return vec_ctu(a,0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4i, Packet4f>(const Packet4i& a) {
+  return vec_ctf(a,0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4ui, Packet4f>(const Packet4ui& a) {
+  return vec_ctf(a,0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us pcast<Packet8bf, Packet8us>(const Packet8bf& a) {
+  Packet4f float_even = Bf16ToF32Even(a);
+  Packet4f float_odd = Bf16ToF32Odd(a);
+  Packet4ui int_even = pcast<Packet4f, Packet4ui>(float_even);
+  Packet4ui int_odd = pcast<Packet4f, Packet4ui>(float_odd);
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(low_mask, 0x0000FFFF);
+  Packet4ui low_even = pand<Packet4ui>(int_even, p4ui_low_mask);
+  Packet4ui low_odd = pand<Packet4ui>(int_odd, p4ui_low_mask);
+
+  //Check values that are bigger than USHRT_MAX (0xFFFF)
+  Packet4bi overflow_selector;
+  if(vec_any_gt(int_even, p4ui_low_mask)){
+    overflow_selector = vec_cmpgt(int_even, p4ui_low_mask);
+    low_even = vec_sel(low_even, p4ui_low_mask, overflow_selector);
+  }
+  if(vec_any_gt(int_odd, p4ui_low_mask)){
+    overflow_selector = vec_cmpgt(int_odd, p4ui_low_mask);
+    low_odd = vec_sel(low_even, p4ui_low_mask, overflow_selector);
+  }
+
+  low_odd = plogical_shift_left<16>(low_odd);
+
+  Packet4ui int_final = por<Packet4ui>(low_even, low_odd);
+  return reinterpret_cast<Packet8us>(int_final);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcast<Packet8us, Packet8bf>(const Packet8us& a) {
+  //short -> int -> float -> bfloat16
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(low_mask, 0x0000FFFF);
+  Packet4ui int_cast = reinterpret_cast<Packet4ui>(a);
+  Packet4ui int_even = pand<Packet4ui>(int_cast, p4ui_low_mask);
+  Packet4ui int_odd = plogical_shift_right<16>(int_cast);
+  Packet4f float_even = pcast<Packet4ui, Packet4f>(int_even);
+  Packet4f float_odd = pcast<Packet4ui, Packet4f>(int_odd);
+  return F32ToBf16(float_even, float_odd);
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i,Packet4f>(const Packet4f& a) {
+  return reinterpret_cast<Packet4i>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f,Packet4i>(const Packet4i& a) {
+  return reinterpret_cast<Packet4f>(a);
+}
+
+
+
+//---------- double ----------
+#ifdef __VSX__
+typedef __vector double              Packet2d;
+typedef __vector unsigned long long  Packet2ul;
+typedef __vector long long           Packet2l;
+#if EIGEN_COMP_CLANG
+typedef Packet2ul                    Packet2bl;
+#else
+typedef __vector __bool long         Packet2bl;
+#endif
+
+static Packet2l  p2l_ONE  = { 1, 1 };
+static Packet2l  p2l_ZERO = reinterpret_cast<Packet2l>(p4i_ZERO);
+static Packet2ul p2ul_SIGN = { 0x8000000000000000ull, 0x8000000000000000ull };
+static Packet2ul p2ul_PREV0DOT5 = { 0x3FDFFFFFFFFFFFFFull, 0x3FDFFFFFFFFFFFFFull };
+static Packet2d  p2d_ONE  = { 1.0, 1.0 };
+static Packet2d  p2d_ZERO = reinterpret_cast<Packet2d>(p4f_ZERO);
+static Packet2d  p2d_MZERO = { numext::bit_cast<double>(0x8000000000000000ull),
+                               numext::bit_cast<double>(0x8000000000000000ull) };
+
+#ifdef _BIG_ENDIAN
+static Packet2d p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(p2d_ZERO), reinterpret_cast<Packet4f>(p2d_ONE), 8));
+#else
+static Packet2d p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(p2d_ONE), reinterpret_cast<Packet4f>(p2d_ZERO), 8));
+#endif
+
+template<int index> Packet2d vec_splat_dbl(Packet2d& a)
+{
+  return vec_splat(a, index);
+}
+
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 1,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasMin  = 1,
+    HasMax  = 1,
+    HasAbs  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 0,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet2d half; };
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2l & v)
+{
+  union {
+    Packet2l   v;
+    int64_t n[2];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2d & v)
+{
+  union {
+    Packet2d   v;
+    double n[2];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1];
+  return s;
+}
+
+// Need to define them first or we get specialization after instantiation errors
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD
+  return vec_xl(0, const_cast<double *>(from)); // cast needed by Clang
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<double>(double*   to, const Packet2d& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE
+  vec_xst(from, 0, to);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double&  from) {
+  Packet2d v = {from, from};
+  return v;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pset1frombits<Packet2d>(unsigned long from) {
+  Packet2l v = {static_cast<long long>(from), static_cast<long long>(from)};
+  return reinterpret_cast<Packet2d>(v);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet2d>(const double *a,
+                      Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+  //This way is faster than vec_splat (at least for doubles in Power 9)
+  a0 = pset1<Packet2d>(a[0]);
+  a1 = pset1<Packet2d>(a[1]);
+  a2 = pset1<Packet2d>(a[2]);
+  a3 = pset1<Packet2d>(a[3]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+  EIGEN_ALIGN16 double af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+ return pload<Packet2d>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  EIGEN_ALIGN16 double af[2];
+  pstore<double>(af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) { return pset1<Packet2d>(a) + p2d_COUNTDOWN; }
+
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return a + b; }
+
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return a - b; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) { return p2d_ZERO - a; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_madd(a,b,p2d_MZERO); }
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_div(a,b); }
+
+// for some weird raisons, it has to be overloaded for packet of integers
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return vec_madd(a, b, c); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b)
+{
+  // NOTE: about 10% slower than vec_min, but consistent with std::min and SSE regarding NaN
+  Packet2d ret;
+  __asm__ ("xvcmpgedp %x0,%x1,%x2\n\txxsel %x0,%x1,%x2,%x0" : "=&wa" (ret) : "wa" (a), "wa" (b));
+  return ret;
+ }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b)
+{
+  // NOTE: about 10% slower than vec_max, but consistent with std::max and SSE regarding NaN
+  Packet2d ret;
+  __asm__ ("xvcmpgtdp %x0,%x2,%x1\n\txxsel %x0,%x1,%x2,%x0" : "=&wa" (ret) : "wa" (a), "wa" (b));
+  return ret;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_le(const Packet2d& a, const Packet2d& b) { return reinterpret_cast<Packet2d>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt(const Packet2d& a, const Packet2d& b) { return reinterpret_cast<Packet2d>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_eq(const Packet2d& a, const Packet2d& b) { return reinterpret_cast<Packet2d>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan(const Packet2d& a, const Packet2d& b) {
+  Packet2d c = reinterpret_cast<Packet2d>(vec_cmpge(a,b));
+  return vec_nor(c,c);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_or(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_xor(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, vec_nor(b, b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a)
+{
+    Packet2d t = vec_add(reinterpret_cast<Packet2d>(vec_or(vec_and(reinterpret_cast<Packet2ul>(a), p2ul_SIGN), p2ul_PREV0DOT5)), a);
+    Packet2d res;
+
+    __asm__("xvrdpiz %x0, %x1\n\t"
+        : "=&wa" (res)
+        : "wa" (t));
+
+    return res;
+}
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const  Packet2d& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) { return vec_floor(a); }
+template<> EIGEN_STRONG_INLINE Packet2d print<Packet2d>(const Packet2d& a)
+{
+    Packet2d res;
+
+    __asm__("xvrdpic %x0, %x1\n\t"
+        : "=&wa" (res)
+        : "wa" (a));
+
+    return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return vec_xl(0, const_cast<double*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double*   from)
+{
+  Packet2d p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet2d>(from);
+  else                                  p = ploadu<Packet2d>(from);
+  return vec_splat_dbl<0>(p);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double*  to, const Packet2d& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE
+  vec_xst(from, 0, to);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE double  pfirst<Packet2d>(const Packet2d& a) { EIGEN_ALIGN16 double x[2]; pstore<double>(x, a); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a)
+{
+  return reinterpret_cast<Packet2d>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE64));
+}
+template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a) { return vec_abs(a); }
+
+// VSX support varies between different compilers and even different
+// versions of the same compiler.  For gcc version >= 4.9.3, we can use
+// vec_cts to efficiently convert Packet2d to Packet2l.  Otherwise, use
+// a slow version that works with older compilers. 
+// Update: apparently vec_cts/vec_ctf intrinsics for 64-bit doubles
+// are buggy, https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70963
+template<>
+inline Packet2l pcast<Packet2d, Packet2l>(const Packet2d& x) {
+#if EIGEN_GNUC_AT_LEAST(5, 4) || \
+    (EIGEN_GNUC_AT(6, 1) && __GNUC_PATCHLEVEL__ >= 1)
+  return vec_cts(x, 0);    // TODO: check clang version.
+#else
+  double tmp[2];
+  memcpy(tmp, &x, sizeof(tmp));
+  Packet2l l = { static_cast<long long>(tmp[0]),
+                 static_cast<long long>(tmp[1]) };
+  return l;
+#endif
+}
+
+template<>
+inline Packet2d pcast<Packet2l, Packet2d>(const Packet2l& x) {
+  unsigned long long tmp[2];
+  memcpy(tmp, &x, sizeof(tmp));
+  Packet2d d = { static_cast<double>(tmp[0]),
+                 static_cast<double>(tmp[1]) };
+  return d;
+}
+
+
+// Packet2l shifts.
+// For POWER8 we simply use vec_sr/l. 
+//
+// Things are more complicated for POWER7. There is actually a
+// vec_xxsxdi intrinsic but it is not supported by some gcc versions.
+// So we need to shift by N % 32 and rearrage bytes.
+#ifdef __POWER8_VECTOR__
+
+template<int N>
+EIGEN_STRONG_INLINE Packet2l plogical_shift_left(const Packet2l& a) {
+  const Packet2ul shift = { N, N };
+  return vec_sl(a, shift); 
+}
+
+template<int N>
+EIGEN_STRONG_INLINE Packet2l plogical_shift_right(const Packet2l& a) {
+  const Packet2ul shift = { N, N };
+  return vec_sr(a, shift); 
+}
+
+#else
+
+// Shifts [A, B, C, D] to [B, 0, D, 0].
+// Used to implement left shifts for Packet2l.
+EIGEN_ALWAYS_INLINE Packet4i shift_even_left(const Packet4i& a) {
+  static const Packet16uc perm = {
+      0x14, 0x15, 0x16, 0x17, 0x00, 0x01, 0x02, 0x03, 
+      0x1c, 0x1d, 0x1e, 0x1f, 0x08, 0x09, 0x0a, 0x0b };
+  #ifdef  _BIG_ENDIAN
+    return vec_perm(p4i_ZERO, a, perm);
+  #else
+    return vec_perm(a, p4i_ZERO, perm);
+  #endif
+}
+
+// Shifts [A, B, C, D] to [0, A, 0, C].
+// Used to implement right shifts for Packet2l.
+EIGEN_ALWAYS_INLINE Packet4i shift_odd_right(const Packet4i& a) {
+  static const Packet16uc perm = {
+      0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13, 
+      0x0c, 0x0d, 0x0e, 0x0f, 0x18, 0x19, 0x1a, 0x1b };
+  #ifdef  _BIG_ENDIAN
+    return vec_perm(p4i_ZERO, a, perm);
+  #else
+    return vec_perm(a, p4i_ZERO, perm);
+  #endif
+}
+
+template<int N, typename EnableIf = void>
+struct plogical_shift_left_impl;
+
+template<int N>
+struct plogical_shift_left_impl<N, typename enable_if<(N < 32) && (N >= 0)>::type> {
+  static EIGEN_STRONG_INLINE Packet2l run(const Packet2l& a) {
+    static const unsigned n = static_cast<unsigned>(N);
+    const Packet4ui shift = {n, n, n, n};
+    const Packet4i ai = reinterpret_cast<Packet4i>(a);
+    static const unsigned m = static_cast<unsigned>(32 - N);
+    const Packet4ui shift_right = {m, m, m, m};
+    const Packet4i out_hi = vec_sl(ai, shift);
+    const Packet4i out_lo = shift_even_left(vec_sr(ai, shift_right));
+    return reinterpret_cast<Packet2l>(por<Packet4i>(out_hi, out_lo));
+  }
+};
+
+template<int N>
+struct plogical_shift_left_impl<N, typename enable_if<(N >= 32)>::type> {
+  static EIGEN_STRONG_INLINE Packet2l run(const Packet2l& a) {
+    static const unsigned m = static_cast<unsigned>(N - 32);
+    const Packet4ui shift = {m, m, m, m};
+    const Packet4i ai = reinterpret_cast<Packet4i>(a);
+    return reinterpret_cast<Packet2l>(shift_even_left(vec_sl(ai, shift)));
+  }
+};
+
+template<int N>
+EIGEN_STRONG_INLINE Packet2l plogical_shift_left(const Packet2l& a) {
+  return plogical_shift_left_impl<N>::run(a); 
+}
+
+template<int N, typename EnableIf = void>
+struct plogical_shift_right_impl;
+
+template<int N>
+struct plogical_shift_right_impl<N, typename enable_if<(N < 32) && (N >= 0)>::type> {
+  static EIGEN_STRONG_INLINE Packet2l run(const Packet2l& a) {
+    static const unsigned n = static_cast<unsigned>(N);
+    const Packet4ui shift = {n, n, n, n};
+    const Packet4i ai = reinterpret_cast<Packet4i>(a);
+    static const unsigned m = static_cast<unsigned>(32 - N);
+    const Packet4ui shift_left = {m, m, m, m};
+    const Packet4i out_lo = vec_sr(ai, shift);
+    const Packet4i out_hi = shift_odd_right(vec_sl(ai, shift_left));
+    return reinterpret_cast<Packet2l>(por<Packet4i>(out_hi, out_lo));
+  }
+};
+
+template<int N>
+struct plogical_shift_right_impl<N, typename enable_if<(N >= 32)>::type> {
+  static EIGEN_STRONG_INLINE Packet2l run(const Packet2l& a) {
+    static const unsigned m = static_cast<unsigned>(N - 32);
+    const Packet4ui shift = {m, m, m, m};
+    const Packet4i ai = reinterpret_cast<Packet4i>(a);
+    return reinterpret_cast<Packet2l>(shift_odd_right(vec_sr(ai, shift)));
+  }
+};
+
+template<int N>
+EIGEN_STRONG_INLINE Packet2l plogical_shift_right(const Packet2l& a) {
+  return plogical_shift_right_impl<N>::run(a); 
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d pldexp<Packet2d>(const Packet2d& a, const Packet2d& exponent) {
+  // Clamp exponent to [-2099, 2099]
+  const Packet2d max_exponent = pset1<Packet2d>(2099.0);
+  const Packet2l e = pcast<Packet2d, Packet2l>(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
+
+  // Split 2^e into four factors and multiply:
+  const Packet2l  bias = { 1023, 1023 };
+  Packet2l b = plogical_shift_right<2>(e);  // floor(e/4)
+  Packet2d c = reinterpret_cast<Packet2d>(plogical_shift_left<52>(b + bias));
+  Packet2d out = pmul(pmul(pmul(a, c), c), c); // a * 2^(3b)
+  b = psub(psub(psub(e, b), b), b);  // e - 3b
+  c = reinterpret_cast<Packet2d>(plogical_shift_left<52>(b + bias)); // 2^(e - 3b)
+  out = pmul(out, c); // a * 2^e
+  return out;
+}
+
+
+// Extract exponent without existence of Packet2l.
+template<>
+EIGEN_STRONG_INLINE  
+Packet2d pfrexp_generic_get_biased_exponent(const Packet2d& a) {
+  return pcast<Packet2l, Packet2d>(plogical_shift_right<52>(reinterpret_cast<Packet2l>(pabs(a))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pfrexp<Packet2d> (const Packet2d& a, Packet2d& exponent) {
+  return pfrexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{
+  Packet2d b, sum;
+  b   = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(a), reinterpret_cast<Packet4f>(a), 8));
+  sum = a + b;
+  return pfirst<Packet2d>(sum);
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmul(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(a), reinterpret_cast<Packet4ui>(a), 8))));
+}
+
+// min
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmin(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(a), reinterpret_cast<Packet4ui>(a), 8))));
+}
+
+// max
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmax(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(a), reinterpret_cast<Packet4ui>(a), 8))));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2d,2>& kernel) {
+  Packet2d t0, t1;
+  t0 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_HI);
+  t1 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_LO);
+  kernel.packet[0] = t0;
+  kernel.packet[1] = t1;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket) {
+  Packet2l select = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2bl mask = reinterpret_cast<Packet2bl>( vec_cmpeq(reinterpret_cast<Packet2d>(select), reinterpret_cast<Packet2d>(p2l_ONE)) );
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+
+#endif // __VSX__
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_ALTIVEC_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/CUDA/Complex.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/CUDA/Complex.h
new file mode 100644
index 00000000..deb4c869
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/CUDA/Complex.h
@@ -0,0 +1,258 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// Copyright (C) 2021 C. Antonio Sanchez <cantonios@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_CUDA_H
+#define EIGEN_COMPLEX_CUDA_H
+
+// clang-format off
+// Many std::complex methods such as operator+, operator-, operator* and
+// operator/ are not constexpr. Due to this, GCC and older versions of clang do
+// not treat them as device functions and thus Eigen functors making use of
+// these operators fail to compile. Here, we manually specialize these
+// operators and functors for complex types when building for CUDA to enable
+// their use on-device.
+
+#if defined(EIGEN_CUDACC) && defined(EIGEN_GPU_COMPILE_PHASE)
+    
+// ICC already specializes std::complex<float> and std::complex<double>
+// operators, preventing us from making them device functions here.
+// This will lead to silent runtime errors if the operators are used on device.
+//
+// To allow std::complex operator use on device, define _OVERRIDE_COMPLEX_SPECIALIZATION_
+// prior to first inclusion of <complex>.  This prevents ICC from adding
+// its own specializations, so our custom ones below can be used instead.
+#if !(defined(EIGEN_COMP_ICC) && defined(_USE_COMPLEX_SPECIALIZATION_))
+
+// Import Eigen's internal operator specializations.
+#define EIGEN_USING_STD_COMPLEX_OPERATORS           \
+  using Eigen::complex_operator_detail::operator+;  \
+  using Eigen::complex_operator_detail::operator-;  \
+  using Eigen::complex_operator_detail::operator*;  \
+  using Eigen::complex_operator_detail::operator/;  \
+  using Eigen::complex_operator_detail::operator+=; \
+  using Eigen::complex_operator_detail::operator-=; \
+  using Eigen::complex_operator_detail::operator*=; \
+  using Eigen::complex_operator_detail::operator/=; \
+  using Eigen::complex_operator_detail::operator==; \
+  using Eigen::complex_operator_detail::operator!=;
+
+namespace Eigen {
+
+// Specialized std::complex overloads.
+namespace complex_operator_detail {
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+std::complex<T> complex_multiply(const std::complex<T>& a, const std::complex<T>& b) {
+  const T a_real = numext::real(a);
+  const T a_imag = numext::imag(a);
+  const T b_real = numext::real(b);
+  const T b_imag = numext::imag(b);
+  return std::complex<T>(
+      a_real * b_real - a_imag * b_imag,
+      a_imag * b_real + a_real * b_imag);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+std::complex<T> complex_divide_fast(const std::complex<T>& a, const std::complex<T>& b) {
+  const T a_real = numext::real(a);
+  const T a_imag = numext::imag(a);
+  const T b_real = numext::real(b);
+  const T b_imag = numext::imag(b);
+  const T norm = (b_real * b_real + b_imag * b_imag);
+  return std::complex<T>((a_real * b_real + a_imag * b_imag) / norm,
+                          (a_imag * b_real - a_real * b_imag) / norm);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+std::complex<T> complex_divide_stable(const std::complex<T>& a, const std::complex<T>& b) {
+  const T a_real = numext::real(a);
+  const T a_imag = numext::imag(a);
+  const T b_real = numext::real(b);
+  const T b_imag = numext::imag(b);
+  // Smith's complex division (https://arxiv.org/pdf/1210.4539.pdf),
+  // guards against over/under-flow.
+  const bool scale_imag = numext::abs(b_imag) <= numext::abs(b_real);
+  const T rscale = scale_imag ? T(1) : b_real / b_imag;
+  const T iscale = scale_imag ? b_imag / b_real : T(1);
+  const T denominator = b_real * rscale + b_imag * iscale;
+  return std::complex<T>((a_real * rscale + a_imag * iscale) / denominator, 
+                         (a_imag * rscale - a_real * iscale) / denominator);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+std::complex<T> complex_divide(const std::complex<T>& a, const std::complex<T>& b) {
+#if EIGEN_FAST_MATH
+  return complex_divide_fast(a, b);
+#else
+  return complex_divide_stable(a, b);
+#endif
+}
+
+// NOTE: We cannot specialize compound assignment operators with Scalar T,
+//         (i.e.  operator@=(const T&), for @=+,-,*,/)
+//       since they are already specialized for float/double/long double within
+//       the standard <complex> header. We also do not specialize the stream
+//       operators.
+#define EIGEN_CREATE_STD_COMPLEX_OPERATOR_SPECIALIZATIONS(T)                                    \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator+(const std::complex<T>& a) { return a; }                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator-(const std::complex<T>& a) {                                           \
+  return std::complex<T>(-numext::real(a), -numext::imag(a));                                   \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator+(const std::complex<T>& a, const std::complex<T>& b) {                 \
+  return std::complex<T>(numext::real(a) + numext::real(b), numext::imag(a) + numext::imag(b)); \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator+(const std::complex<T>& a, const T& b) {                               \
+  return std::complex<T>(numext::real(a) + b, numext::imag(a));                                 \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator+(const T& a, const std::complex<T>& b) {                               \
+  return std::complex<T>(a + numext::real(b), numext::imag(b));                                 \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator-(const std::complex<T>& a, const std::complex<T>& b) {                 \
+  return std::complex<T>(numext::real(a) - numext::real(b), numext::imag(a) - numext::imag(b)); \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator-(const std::complex<T>& a, const T& b) {                               \
+  return std::complex<T>(numext::real(a) - b, numext::imag(a));                                 \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator-(const T& a, const std::complex<T>& b) {                               \
+  return std::complex<T>(a - numext::real(b), -numext::imag(b));                                \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator*(const std::complex<T>& a, const std::complex<T>& b) {                 \
+  return complex_multiply(a, b);                                                                \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator*(const std::complex<T>& a, const T& b) {                               \
+  return std::complex<T>(numext::real(a) * b, numext::imag(a) * b);                             \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator*(const T& a, const std::complex<T>& b) {                               \
+  return std::complex<T>(a * numext::real(b), a * numext::imag(b));                             \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator/(const std::complex<T>& a, const std::complex<T>& b) {                 \
+  return complex_divide(a, b);                                                                  \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator/(const std::complex<T>& a, const T& b) {                               \
+  return std::complex<T>(numext::real(a) / b, numext::imag(a) / b);                             \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator/(const T& a, const std::complex<T>& b) {                               \
+  return complex_divide(std::complex<T>(a, 0), b);                                              \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T>& operator+=(std::complex<T>& a, const std::complex<T>& b) {                     \
+  numext::real_ref(a) += numext::real(b);                                                       \
+  numext::imag_ref(a) += numext::imag(b);                                                       \
+  return a;                                                                                     \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T>& operator-=(std::complex<T>& a, const std::complex<T>& b) {                     \
+  numext::real_ref(a) -= numext::real(b);                                                       \
+  numext::imag_ref(a) -= numext::imag(b);                                                       \
+  return a;                                                                                     \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T>& operator*=(std::complex<T>& a, const std::complex<T>& b) {                     \
+  a = complex_multiply(a, b);                                                                   \
+  return a;                                                                                     \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T>& operator/=(std::complex<T>& a, const std::complex<T>& b) {                     \
+  a = complex_divide(a, b);                                                                     \
+  return  a;                                                                                    \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator==(const std::complex<T>& a, const std::complex<T>& b) {                           \
+  return numext::real(a) == numext::real(b) && numext::imag(a) == numext::imag(b);              \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator==(const std::complex<T>& a, const T& b) {                                         \
+  return numext::real(a) == b && numext::imag(a) == 0;                                          \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator==(const T& a, const std::complex<T>& b) {                                         \
+  return a  == numext::real(b) && 0 == numext::imag(b);                                         \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator!=(const std::complex<T>& a, const std::complex<T>& b) {                           \
+  return !(a == b);                                                                             \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator!=(const std::complex<T>& a, const T& b) {                                         \
+  return !(a == b);                                                                             \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator!=(const T& a, const std::complex<T>& b) {                                         \
+  return !(a == b);                                                                             \
+}
+
+// Do not specialize for long double, since that reduces to double on device.
+EIGEN_CREATE_STD_COMPLEX_OPERATOR_SPECIALIZATIONS(float)
+EIGEN_CREATE_STD_COMPLEX_OPERATOR_SPECIALIZATIONS(double)
+
+#undef EIGEN_CREATE_STD_COMPLEX_OPERATOR_SPECIALIZATIONS
+
+  
+}  // namespace complex_operator_detail
+
+EIGEN_USING_STD_COMPLEX_OPERATORS
+
+namespace numext {
+EIGEN_USING_STD_COMPLEX_OPERATORS
+}  // namespace numext
+
+namespace internal {
+EIGEN_USING_STD_COMPLEX_OPERATORS
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // !(EIGEN_COMP_ICC && _USE_COMPLEX_SPECIALIZATION_)
+
+#endif  // EIGEN_CUDACC && EIGEN_GPU_COMPILE_PHASE
+
+#endif  // EIGEN_COMPLEX_CUDA_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/BFloat16.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/BFloat16.h
new file mode 100644
index 00000000..1c28f4f9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/BFloat16.h
@@ -0,0 +1,700 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#ifndef EIGEN_BFLOAT16_H
+#define EIGEN_BFLOAT16_H
+
+#define BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, METHOD)         \
+  template <>                                                       \
+  EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED  \
+  PACKET_BF16 METHOD<PACKET_BF16>(const PACKET_BF16& _x) {          \
+    return F32ToBf16(METHOD<PACKET_F>(Bf16ToF32(_x)));              \
+  }
+
+namespace Eigen {
+
+struct bfloat16;
+
+namespace bfloat16_impl {
+
+// Make our own __bfloat16_raw definition.
+struct __bfloat16_raw {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __bfloat16_raw() : value(0) {}
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __bfloat16_raw(unsigned short raw) : value(raw) {}
+  unsigned short value;
+};
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __bfloat16_raw raw_uint16_to_bfloat16(unsigned short value);
+template <bool AssumeArgumentIsNormalOrInfinityOrZero>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw float_to_bfloat16_rtne(float ff);
+// Forward declarations of template specializations, to avoid Visual C++ 2019 errors, saying:
+// > error C2908: explicit specialization; 'float_to_bfloat16_rtne' has already been instantiated
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw float_to_bfloat16_rtne<false>(float ff);
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw float_to_bfloat16_rtne<true>(float ff);
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float bfloat16_to_float(__bfloat16_raw h);
+
+struct bfloat16_base : public __bfloat16_raw {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16_base() {}
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16_base(const __bfloat16_raw& h) : __bfloat16_raw(h) {}
+};
+
+} // namespace bfloat16_impl
+
+// Class definition.
+struct bfloat16 : public bfloat16_impl::bfloat16_base {
+
+  typedef bfloat16_impl::__bfloat16_raw __bfloat16_raw;
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16(const __bfloat16_raw& h) : bfloat16_impl::bfloat16_base(h) {}
+
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16(bool b)
+      : bfloat16_impl::bfloat16_base(bfloat16_impl::raw_uint16_to_bfloat16(b ? 0x3f80 : 0)) {}
+
+  template<class T>
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16(T val)
+      : bfloat16_impl::bfloat16_base(bfloat16_impl::float_to_bfloat16_rtne<internal::is_integral<T>::value>(static_cast<float>(val))) {}
+
+  explicit EIGEN_DEVICE_FUNC bfloat16(float f)
+      : bfloat16_impl::bfloat16_base(bfloat16_impl::float_to_bfloat16_rtne<false>(f)) {}
+
+  // Following the convention of numpy, converting between complex and
+  // float will lead to loss of imag value.
+  template<typename RealScalar>
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16(const std::complex<RealScalar>& val)
+      : bfloat16_impl::bfloat16_base(bfloat16_impl::float_to_bfloat16_rtne<false>(static_cast<float>(val.real()))) {}
+
+  EIGEN_DEVICE_FUNC operator float() const {  // NOLINT: Allow implicit conversion to float, because it is lossless.
+    return bfloat16_impl::bfloat16_to_float(*this);
+  }
+};
+} // namespace Eigen
+
+namespace std {
+template<>
+struct numeric_limits<Eigen::bfloat16> {
+  static const bool is_specialized = true;
+  static const bool is_signed = true;
+  static const bool is_integer = false;
+  static const bool is_exact = false;
+  static const bool has_infinity = true;
+  static const bool has_quiet_NaN = true;
+  static const bool has_signaling_NaN = true;
+  static const float_denorm_style has_denorm = std::denorm_absent;
+  static const bool has_denorm_loss = false;
+  static const std::float_round_style round_style = numeric_limits<float>::round_style;
+  static const bool is_iec559 = false;
+  static const bool is_bounded = true;
+  static const bool is_modulo = false;
+  static const int digits = 8;
+  static const int digits10 = 2;
+  static const int max_digits10 = 4;
+  static const int radix = 2;
+  static const int min_exponent = numeric_limits<float>::min_exponent;
+  static const int min_exponent10 = numeric_limits<float>::min_exponent10;
+  static const int max_exponent = numeric_limits<float>::max_exponent;
+  static const int max_exponent10 = numeric_limits<float>::max_exponent10;
+  static const bool traps = numeric_limits<float>::traps;
+  static const bool tinyness_before = numeric_limits<float>::tinyness_before;
+
+  static Eigen::bfloat16 (min)() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x0080); }
+  static Eigen::bfloat16 lowest() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0xff7f); }
+  static Eigen::bfloat16 (max)() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x7f7f); }
+  static Eigen::bfloat16 epsilon() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x3c00); }
+  static Eigen::bfloat16 round_error() { return Eigen::bfloat16(0x3f00); }
+  static Eigen::bfloat16 infinity() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x7f80); }
+  static Eigen::bfloat16 quiet_NaN() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x7fc0); }
+  static Eigen::bfloat16 signaling_NaN() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x7f81); }
+  static Eigen::bfloat16 denorm_min() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x0001); }
+};
+
+// If std::numeric_limits<T> is specialized, should also specialize
+// std::numeric_limits<const T>, std::numeric_limits<volatile T>, and
+// std::numeric_limits<const volatile T>
+// https://stackoverflow.com/a/16519653/
+template<>
+struct numeric_limits<const Eigen::bfloat16> : numeric_limits<Eigen::bfloat16> {};
+template<>
+struct numeric_limits<volatile Eigen::bfloat16> : numeric_limits<Eigen::bfloat16> {};
+template<>
+struct numeric_limits<const volatile Eigen::bfloat16> : numeric_limits<Eigen::bfloat16> {};
+} // namespace std
+
+namespace Eigen {
+
+namespace bfloat16_impl {
+
+// We need to distinguish ‘clang as the CUDA compiler’ from ‘clang as the host compiler,
+// invoked by NVCC’ (e.g. on MacOS). The former needs to see both host and device implementation
+// of the functions, while the latter can only deal with one of them.
+#if !defined(EIGEN_HAS_NATIVE_BF16) || (EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC) // Emulate support for bfloat16 floats
+
+#if EIGEN_COMP_CLANG && defined(EIGEN_CUDACC)
+// We need to provide emulated *host-side* BF16 operators for clang.
+#pragma push_macro("EIGEN_DEVICE_FUNC")
+#undef EIGEN_DEVICE_FUNC
+#if defined(EIGEN_HAS_CUDA_BF16) && defined(EIGEN_HAS_NATIVE_BF16)
+#define EIGEN_DEVICE_FUNC __host__
+#else // both host and device need emulated ops.
+#define EIGEN_DEVICE_FUNC __host__ __device__
+#endif
+#endif
+
+// Definitions for CPUs, mostly working through conversion
+// to/from fp32.
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator + (const bfloat16& a, const bfloat16& b) {
+  return bfloat16(float(a) + float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator + (const bfloat16& a, const int& b) {
+  return bfloat16(float(a) + static_cast<float>(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator + (const int& a, const bfloat16& b) {
+  return bfloat16(static_cast<float>(a) + float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator * (const bfloat16& a, const bfloat16& b) {
+  return bfloat16(float(a) * float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator - (const bfloat16& a, const bfloat16& b) {
+  return bfloat16(float(a) - float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator / (const bfloat16& a, const bfloat16& b) {
+  return bfloat16(float(a) / float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator - (const bfloat16& a) {
+  bfloat16 result;
+  result.value = a.value ^ 0x8000;
+  return result;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16& operator += (bfloat16& a, const bfloat16& b) {
+  a = bfloat16(float(a) + float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16& operator *= (bfloat16& a, const bfloat16& b) {
+  a = bfloat16(float(a) * float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16& operator -= (bfloat16& a, const bfloat16& b) {
+  a = bfloat16(float(a) - float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16& operator /= (bfloat16& a, const bfloat16& b) {
+  a = bfloat16(float(a) / float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator++(bfloat16& a) {
+  a += bfloat16(1);
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator--(bfloat16& a) {
+  a -= bfloat16(1);
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator++(bfloat16& a, int) {
+  bfloat16 original_value = a;
+  ++a;
+  return original_value;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator--(bfloat16& a, int) {
+  bfloat16 original_value = a;
+  --a;
+  return original_value;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator == (const bfloat16& a, const bfloat16& b) {
+  return numext::equal_strict(float(a),float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator != (const bfloat16& a, const bfloat16& b) {
+  return numext::not_equal_strict(float(a), float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator < (const bfloat16& a, const bfloat16& b) {
+  return float(a) < float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator <= (const bfloat16& a, const bfloat16& b) {
+  return float(a) <= float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator > (const bfloat16& a, const bfloat16& b) {
+  return float(a) > float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator >= (const bfloat16& a, const bfloat16& b) {
+  return float(a) >= float(b);
+}
+
+#if EIGEN_COMP_CLANG && defined(EIGEN_CUDACC)
+#pragma pop_macro("EIGEN_DEVICE_FUNC")
+#endif
+#endif  // Emulate support for bfloat16 floats
+
+// Division by an index. Do it in full float precision to avoid accuracy
+// issues in converting the denominator to bfloat16.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator / (const bfloat16& a, Index b) {
+  return bfloat16(static_cast<float>(a) / static_cast<float>(b));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw truncate_to_bfloat16(const float v) {
+  __bfloat16_raw output;
+  if (Eigen::numext::isnan EIGEN_NOT_A_MACRO(v)) {
+    output.value = std::signbit(v) ? 0xFFC0: 0x7FC0;
+    return output;
+  }
+  const uint16_t* p = reinterpret_cast<const uint16_t*>(&v);
+#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+  output.value = p[0];
+#else
+  output.value = p[1];
+#endif
+  return output;
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __bfloat16_raw raw_uint16_to_bfloat16(numext::uint16_t value) {
+  return __bfloat16_raw(value);
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR numext::uint16_t raw_bfloat16_as_uint16(const __bfloat16_raw& bf) {
+  return bf.value;
+}
+
+// float_to_bfloat16_rtne template specialization that does not make any
+// assumption about the value of its function argument (ff).
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw float_to_bfloat16_rtne<false>(float ff) {
+#if (defined(EIGEN_HAS_CUDA_BF16) && defined(EIGEN_HAS_HIP_BF16))
+  // Nothing to do here
+#else
+  __bfloat16_raw output;
+
+  if (Eigen::numext::isnan EIGEN_NOT_A_MACRO(ff)) {
+    // If the value is a NaN, squash it to a qNaN with msb of fraction set,
+    // this makes sure after truncation we don't end up with an inf.
+    //
+    // qNaN magic: All exponent bits set + most significant bit of fraction
+    // set.
+    output.value = std::signbit(ff) ? 0xFFC0: 0x7FC0;
+  } else {
+    // Fast rounding algorithm that rounds a half value to nearest even. This
+    // reduces expected error when we convert a large number of floats. Here
+    // is how it works:
+    //
+    // Definitions:
+    // To convert a float 32 to bfloat16, a float 32 can be viewed as 32 bits
+    // with the following tags:
+    //
+    // Sign |  Exp (8 bits) | Frac (23 bits)
+    //  S     EEEEEEEE         FFFFFFLRTTTTTTTTTTTTTTT
+    //
+    //  S: Sign bit.
+    //  E: Exponent bits.
+    //  F: First 6 bits of fraction.
+    //  L: Least significant bit of resulting bfloat16 if we truncate away the
+    //  rest of the float32. This is also the 7th bit of fraction
+    //  R: Rounding bit, 8th bit of fraction.
+    //  T: Sticky bits, rest of fraction, 15 bits.
+    //
+    // To round half to nearest even, there are 3 cases where we want to round
+    // down (simply truncate the result of the bits away, which consists of
+    // rounding bit and sticky bits) and two cases where we want to round up
+    // (truncate then add one to the result).
+    //
+    // The fast converting algorithm simply adds lsb (L) to 0x7fff (15 bits of
+    // 1s) as the rounding bias, adds the rounding bias to the input, then
+    // truncates the last 16 bits away.
+    //
+    // To understand how it works, we can analyze this algorithm case by case:
+    //
+    // 1. L = 0, R = 0:
+    //   Expect: round down, this is less than half value.
+    //
+    //   Algorithm:
+    //   - Rounding bias: 0x7fff + 0 = 0x7fff
+    //   - Adding rounding bias to input may create any carry, depending on
+    //   whether there is any value set to 1 in T bits.
+    //   - R may be set to 1 if there is a carry.
+    //   - L remains 0.
+    //   - Note that this case also handles Inf and -Inf, where all fraction
+    //   bits, including L, R and Ts are all 0. The output remains Inf after
+    //   this algorithm.
+    //
+    // 2. L = 1, R = 0:
+    //   Expect: round down, this is less than half value.
+    //
+    //   Algorithm:
+    //   - Rounding bias: 0x7fff + 1 = 0x8000
+    //   - Adding rounding bias to input doesn't change sticky bits but
+    //   adds 1 to rounding bit.
+    //   - L remains 1.
+    //
+    // 3. L = 0, R = 1, all of T are 0:
+    //   Expect: round down, this is exactly at half, the result is already
+    //   even (L=0).
+    //
+    //   Algorithm:
+    //   - Rounding bias: 0x7fff + 0 = 0x7fff
+    //   - Adding rounding bias to input sets all sticky bits to 1, but
+    //   doesn't create a carry.
+    //   - R remains 1.
+    //   - L remains 0.
+    //
+    // 4. L = 1, R = 1:
+    //   Expect: round up, this is exactly at half, the result needs to be
+    //   round to the next even number.
+    //
+    //   Algorithm:
+    //   - Rounding bias: 0x7fff + 1 = 0x8000
+    //   - Adding rounding bias to input doesn't change sticky bits, but
+    //   creates a carry from rounding bit.
+    //   - The carry sets L to 0, creates another carry bit and propagate
+    //   forward to F bits.
+    //   - If all the F bits are 1, a carry then propagates to the exponent
+    //   bits, which then creates the minimum value with the next exponent
+    //   value. Note that we won't have the case where exponents are all 1,
+    //   since that's either a NaN (handled in the other if condition) or inf
+    //   (handled in case 1).
+    //
+    // 5. L = 0, R = 1, any of T is 1:
+    //   Expect: round up, this is greater than half.
+    //
+    //   Algorithm:
+    //   - Rounding bias: 0x7fff + 0 = 0x7fff
+    //   - Adding rounding bias to input creates a carry from sticky bits,
+    //   sets rounding bit to 0, then create another carry.
+    //   - The second carry sets L to 1.
+    //
+    // Examples:
+    //
+    //  Exact half value that is already even:
+    //    Input:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit) | Frac (last 16 bit)
+    //     S     E E E E E E E E      F F F F F F L     RTTTTTTTTTTTTTTT
+    //     0     0 0 0 0 0 0 0 0      0 0 0 0 0 1 0     1000000000000000
+    //
+    //     This falls into case 3. We truncate the rest of 16 bits and no
+    //     carry is created into F and L:
+    //
+    //    Output:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit)
+    //     S     E E E E E E E E      F F F F F F L
+    //     0     0 0 0 0 0 0 0 0      0 0 0 0 0 1 0
+    //
+    //  Exact half value, round to next even number:
+    //    Input:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit) | Frac (last 16 bit)
+    //     S     E E E E E E E E      F F F F F F L     RTTTTTTTTTTTTTTT
+    //     0     0 0 0 0 0 0 0 0      0 0 0 0 0 0 1     1000000000000000
+    //
+    //     This falls into case 4. We create a carry from R and T,
+    //     which then propagates into L and F:
+    //
+    //    Output:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit)
+    //     S     E E E E E E E E      F F F F F F L
+    //     0     0 0 0 0 0 0 0 0      0 0 0 0 0 1 0
+    //
+    //
+    //  Max denormal value round to min normal value:
+    //    Input:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit) | Frac (last 16 bit)
+    //     S     E E E E E E E E      F F F F F F L     RTTTTTTTTTTTTTTT
+    //     0     0 0 0 0 0 0 0 0      1 1 1 1 1 1 1     1111111111111111
+    //
+    //     This falls into case 4. We create a carry from R and T,
+    //     propagate into L and F, which then propagates into exponent
+    //     bits:
+    //
+    //    Output:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit)
+    //     S     E E E E E E E E      F F F F F F L
+    //     0     0 0 0 0 0 0 0 1      0 0 0 0 0 0 0
+    //
+    //  Max normal value round to Inf:
+    //    Input:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit) | Frac (last 16 bit)
+    //     S     E E E E E E E E      F F F F F F L     RTTTTTTTTTTTTTTT
+    //     0     1 1 1 1 1 1 1 0      1 1 1 1 1 1 1     1111111111111111
+    //
+    //     This falls into case 4. We create a carry from R and T,
+    //     propagate into L and F, which then propagates into exponent
+    //     bits:
+    //
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit)
+    //     S     E E E E E E E E      F F F F F F L
+    //     0     1 1 1 1 1 1 1 1      0 0 0 0 0 0 0
+
+    // At this point, ff must be either a normal float, or +/-infinity.
+    output = float_to_bfloat16_rtne<true>(ff);
+  }
+  return output;
+#endif
+}
+
+// float_to_bfloat16_rtne template specialization that assumes that its function
+// argument (ff) is either a normal floating point number, or +/-infinity, or
+// zero. Used to improve the runtime performance of conversion from an integer
+// type to bfloat16.
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw float_to_bfloat16_rtne<true>(float ff) {
+#if (defined(EIGEN_HAS_CUDA_BF16) && defined(EIGEN_HAS_HIP_BF16))
+    // Nothing to do here
+#else
+    numext::uint32_t input = numext::bit_cast<numext::uint32_t>(ff);
+    __bfloat16_raw output;
+
+    // Least significant bit of resulting bfloat.
+    numext::uint32_t lsb = (input >> 16) & 1;
+    numext::uint32_t rounding_bias = 0x7fff + lsb;
+    input += rounding_bias;
+    output.value = static_cast<numext::uint16_t>(input >> 16);
+    return output;
+#endif
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float bfloat16_to_float(__bfloat16_raw h) {
+    float result = 0;
+    unsigned short* q = reinterpret_cast<unsigned short*>(&result);
+#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    q[0] = h.value;
+#else
+    q[1] = h.value;
+#endif
+    return result;
+}
+// --- standard functions ---
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isinf)(const bfloat16& a) {
+  EIGEN_USING_STD(isinf);
+  return (isinf)(float(a));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isnan)(const bfloat16& a) {
+  EIGEN_USING_STD(isnan);
+  return (isnan)(float(a));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isfinite)(const bfloat16& a) {
+  return !(isinf EIGEN_NOT_A_MACRO (a)) && !(isnan EIGEN_NOT_A_MACRO (a));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 abs(const bfloat16& a) {
+  bfloat16 result;
+  result.value = a.value & 0x7FFF;
+  return result;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 exp(const bfloat16& a) {
+   return bfloat16(::expf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 expm1(const bfloat16& a) {
+  return bfloat16(numext::expm1(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log(const bfloat16& a) {
+  return bfloat16(::logf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log1p(const bfloat16& a) {
+  return bfloat16(numext::log1p(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log10(const bfloat16& a) {
+  return bfloat16(::log10f(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log2(const bfloat16& a) {
+  return bfloat16(static_cast<float>(EIGEN_LOG2E) * ::logf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 sqrt(const bfloat16& a) {
+    return bfloat16(::sqrtf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 pow(const bfloat16& a, const bfloat16& b) {
+  return bfloat16(::powf(float(a), float(b)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 sin(const bfloat16& a) {
+  return bfloat16(::sinf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 cos(const bfloat16& a) {
+  return bfloat16(::cosf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 tan(const bfloat16& a) {
+  return bfloat16(::tanf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 asin(const bfloat16& a) {
+  return bfloat16(::asinf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 acos(const bfloat16& a) {
+  return bfloat16(::acosf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 atan(const bfloat16& a) {
+  return bfloat16(::atanf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 sinh(const bfloat16& a) {
+  return bfloat16(::sinhf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 cosh(const bfloat16& a) {
+  return bfloat16(::coshf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 tanh(const bfloat16& a) {
+  return bfloat16(::tanhf(float(a)));
+}
+#if EIGEN_HAS_CXX11_MATH
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 asinh(const bfloat16& a) {
+  return bfloat16(::asinhf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 acosh(const bfloat16& a) {
+  return bfloat16(::acoshf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 atanh(const bfloat16& a) {
+  return bfloat16(::atanhf(float(a)));
+}
+#endif
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 floor(const bfloat16& a) {
+  return bfloat16(::floorf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 ceil(const bfloat16& a) {
+  return bfloat16(::ceilf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 rint(const bfloat16& a) {
+  return bfloat16(::rintf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 round(const bfloat16& a) {
+  return bfloat16(::roundf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 fmod(const bfloat16& a, const bfloat16& b) {
+  return bfloat16(::fmodf(float(a), float(b)));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 (min)(const bfloat16& a, const bfloat16& b) {
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return f2 < f1 ? b : a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 (max)(const bfloat16& a, const bfloat16& b) {
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return f1 < f2 ? b : a;
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 fmin(const bfloat16& a, const bfloat16& b) {
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return bfloat16(::fminf(f1, f2));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 fmax(const bfloat16& a, const bfloat16& b) {
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return bfloat16(::fmaxf(f1, f2));
+}
+
+#ifndef EIGEN_NO_IO
+EIGEN_ALWAYS_INLINE std::ostream& operator << (std::ostream& os, const bfloat16& v) {
+  os << static_cast<float>(v);
+  return os;
+}
+#endif
+
+} // namespace bfloat16_impl
+
+namespace internal {
+
+template<>
+struct random_default_impl<bfloat16, false, false>
+{
+  static inline bfloat16 run(const bfloat16& x, const bfloat16& y)
+  {
+    return x + (y-x) * bfloat16(float(std::rand()) / float(RAND_MAX));
+  }
+  static inline bfloat16 run()
+  {
+    return run(bfloat16(-1.f), bfloat16(1.f));
+  }
+};
+
+template<> struct is_arithmetic<bfloat16> { enum { value = true }; };
+
+} // namespace internal
+
+template<> struct NumTraits<Eigen::bfloat16>
+    : GenericNumTraits<Eigen::bfloat16>
+{
+  enum {
+    IsSigned = true,
+    IsInteger = false,
+    IsComplex = false,
+    RequireInitialization = false
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 epsilon() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0x3c00);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 dummy_precision() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0x3D4D);  // bfloat16(5e-2f);
+
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 highest() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0x7F7F);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 lowest() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0xFF7F);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 infinity() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0x7f80);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 quiet_NaN() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0x7fc0);
+  }
+};
+
+} // namespace Eigen
+
+namespace Eigen {
+namespace numext {
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+bool (isnan)(const Eigen::bfloat16& h) {
+  return (bfloat16_impl::isnan)(h);
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+bool (isinf)(const Eigen::bfloat16& h) {
+  return (bfloat16_impl::isinf)(h);
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+bool (isfinite)(const Eigen::bfloat16& h) {
+  return (bfloat16_impl::isfinite)(h);
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bit_cast<Eigen::bfloat16, uint16_t>(const uint16_t& src) {
+  return Eigen::bfloat16(Eigen::bfloat16_impl::raw_uint16_to_bfloat16(src));
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC uint16_t bit_cast<uint16_t, Eigen::bfloat16>(const Eigen::bfloat16& src) {
+  return Eigen::bfloat16_impl::raw_bfloat16_as_uint16(src);
+}
+
+}  // namespace numext
+}  // namespace Eigen
+
+#if EIGEN_HAS_STD_HASH
+namespace std {
+template <>
+struct hash<Eigen::bfloat16> {
+  EIGEN_STRONG_INLINE std::size_t operator()(const Eigen::bfloat16& a) const {
+    return static_cast<std::size_t>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(a));
+  }
+};
+} // namespace std
+#endif
+
+
+#endif // EIGEN_BFLOAT16_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/ConjHelper.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/ConjHelper.h
new file mode 100644
index 00000000..53830b5a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/ConjHelper.h
@@ -0,0 +1,117 @@
+
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARCH_CONJ_HELPER_H
+#define EIGEN_ARCH_CONJ_HELPER_H
+
+#define EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(PACKET_CPLX, PACKET_REAL)      \
+  template <>                                                           \
+  struct conj_helper<PACKET_REAL, PACKET_CPLX, false, false> {          \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmadd(const PACKET_REAL& x,         \
+                                          const PACKET_CPLX& y,         \
+                                          const PACKET_CPLX& c) const { \
+      return padd(c, this->pmul(x, y));                                 \
+    }                                                                   \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmul(const PACKET_REAL& x,          \
+                                         const PACKET_CPLX& y) const {  \
+      return PACKET_CPLX(Eigen::internal::pmul<PACKET_REAL>(x, y.v));   \
+    }                                                                   \
+  };                                                                    \
+                                                                        \
+  template <>                                                           \
+  struct conj_helper<PACKET_CPLX, PACKET_REAL, false, false> {          \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmadd(const PACKET_CPLX& x,         \
+                                          const PACKET_REAL& y,         \
+                                          const PACKET_CPLX& c) const { \
+      return padd(c, this->pmul(x, y));                                 \
+    }                                                                   \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmul(const PACKET_CPLX& x,          \
+                                         const PACKET_REAL& y) const {  \
+      return PACKET_CPLX(Eigen::internal::pmul<PACKET_REAL>(x.v, y));   \
+    }                                                                   \
+  };
+
+namespace Eigen {
+namespace internal {
+
+template<bool Conjugate> struct conj_if;
+
+template<> struct conj_if<true> {
+  template<typename T>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x) const { return numext::conj(x); }
+  template<typename T>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T pconj(const T& x) const { return internal::pconj(x); }
+};
+
+template<> struct conj_if<false> {
+  template<typename T>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T& operator()(const T& x) const { return x; }
+  template<typename T>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T& pconj(const T& x) const { return x; }
+};
+
+// Generic Implementation, assume scalars since the packet-version is
+// specialized below.
+template<typename LhsType, typename RhsType, bool ConjLhs, bool ConjRhs>
+struct conj_helper {
+  typedef typename ScalarBinaryOpTraits<LhsType, RhsType>::ReturnType ResultType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType
+  pmadd(const LhsType& x, const RhsType& y, const ResultType& c) const
+  { return this->pmul(x, y) + c; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType
+  pmul(const LhsType& x, const RhsType& y) const
+  { return conj_if<ConjLhs>()(x) * conj_if<ConjRhs>()(y); }
+};
+
+template<typename LhsScalar, typename RhsScalar>
+struct conj_helper<LhsScalar, RhsScalar, true, true> {
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar>::ReturnType ResultType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType
+  pmadd(const LhsScalar& x, const RhsScalar& y, const ResultType& c) const
+  { return this->pmul(x, y) + c; }
+
+  // We save a conjuation by using the identity conj(a)*conj(b) = conj(a*b).
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType
+  pmul(const LhsScalar& x, const RhsScalar& y) const
+  { return numext::conj(x * y); }
+};
+
+// Implementation with equal type, use packet operations.
+template<typename Packet, bool ConjLhs, bool ConjRhs>
+struct conj_helper<Packet, Packet, ConjLhs, ConjRhs>
+{
+  typedef Packet ResultType;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmadd(const Packet& x, const Packet& y, const Packet& c) const
+  { return Eigen::internal::pmadd(conj_if<ConjLhs>().pconj(x), conj_if<ConjRhs>().pconj(y), c); }
+
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmul(const Packet& x, const Packet& y) const
+  { return Eigen::internal::pmul(conj_if<ConjLhs>().pconj(x), conj_if<ConjRhs>().pconj(y)); }
+};
+
+template<typename Packet>
+struct conj_helper<Packet, Packet, true, true>
+{
+  typedef Packet ResultType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmadd(const Packet& x, const Packet& y, const Packet& c) const
+  { return Eigen::internal::pmadd(pconj(x), pconj(y), c); }
+  // We save a conjuation by using the identity conj(a)*conj(b) = conj(a*b).
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmul(const Packet& x, const Packet& y) const
+  { return pconj(Eigen::internal::pmul(x, y)); }
+};
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_ARCH_CONJ_HELPER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
new file mode 100644
index 00000000..c9fbaf68
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
@@ -0,0 +1,1649 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+// Copyright (C) 2009-2019 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The exp and log functions of this file initially come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+#ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_H
+#define EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_H
+
+namespace Eigen {
+namespace internal {
+
+// Creates a Scalar integer type with same bit-width.
+template<typename T> struct make_integer;
+template<> struct make_integer<float>    { typedef numext::int32_t type; };
+template<> struct make_integer<double>   { typedef numext::int64_t type; };
+template<> struct make_integer<half>     { typedef numext::int16_t type; };
+template<> struct make_integer<bfloat16> { typedef numext::int16_t type; };
+
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC  
+Packet pfrexp_generic_get_biased_exponent(const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
+  enum { mantissa_bits = numext::numeric_limits<Scalar>::digits - 1};
+  return pcast<PacketI, Packet>(plogical_shift_right<mantissa_bits>(preinterpret<PacketI>(pabs(a))));
+}
+
+// Safely applies frexp, correctly handles denormals.
+// Assumes IEEE floating point format.
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+Packet pfrexp_generic(const Packet& a, Packet& exponent) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  typedef typename make_unsigned<typename make_integer<Scalar>::type>::type ScalarUI;
+  enum {
+    TotalBits = sizeof(Scalar) * CHAR_BIT,
+    MantissaBits = numext::numeric_limits<Scalar>::digits - 1,
+    ExponentBits = int(TotalBits) - int(MantissaBits) - 1
+  };
+
+  EIGEN_CONSTEXPR ScalarUI scalar_sign_mantissa_mask = 
+      ~(((ScalarUI(1) << int(ExponentBits)) - ScalarUI(1)) << int(MantissaBits)); // ~0x7f800000
+  const Packet sign_mantissa_mask = pset1frombits<Packet>(static_cast<ScalarUI>(scalar_sign_mantissa_mask)); 
+  const Packet half = pset1<Packet>(Scalar(0.5));
+  const Packet zero = pzero(a);
+  const Packet normal_min = pset1<Packet>((numext::numeric_limits<Scalar>::min)()); // Minimum normal value, 2^-126
+  
+  // To handle denormals, normalize by multiplying by 2^(int(MantissaBits)+1).
+  const Packet is_denormal = pcmp_lt(pabs(a), normal_min);
+  EIGEN_CONSTEXPR ScalarUI scalar_normalization_offset = ScalarUI(int(MantissaBits) + 1); // 24
+  // The following cannot be constexpr because bfloat16(uint16_t) is not constexpr.
+  const Scalar scalar_normalization_factor = Scalar(ScalarUI(1) << int(scalar_normalization_offset)); // 2^24
+  const Packet normalization_factor = pset1<Packet>(scalar_normalization_factor);  
+  const Packet normalized_a = pselect(is_denormal, pmul(a, normalization_factor), a);
+  
+  // Determine exponent offset: -126 if normal, -126-24 if denormal
+  const Scalar scalar_exponent_offset = -Scalar((ScalarUI(1)<<(int(ExponentBits)-1)) - ScalarUI(2)); // -126
+  Packet exponent_offset = pset1<Packet>(scalar_exponent_offset);
+  const Packet normalization_offset = pset1<Packet>(-Scalar(scalar_normalization_offset)); // -24
+  exponent_offset = pselect(is_denormal, padd(exponent_offset, normalization_offset), exponent_offset);
+  
+  // Determine exponent and mantissa from normalized_a.
+  exponent = pfrexp_generic_get_biased_exponent(normalized_a);
+  // Zero, Inf and NaN return 'a' unmodified, exponent is zero
+  // (technically the exponent is unspecified for inf/NaN, but GCC/Clang set it to zero)
+  const Scalar scalar_non_finite_exponent = Scalar((ScalarUI(1) << int(ExponentBits)) - ScalarUI(1));  // 255
+  const Packet non_finite_exponent = pset1<Packet>(scalar_non_finite_exponent);
+  const Packet is_zero_or_not_finite = por(pcmp_eq(a, zero), pcmp_eq(exponent, non_finite_exponent));
+  const Packet m = pselect(is_zero_or_not_finite, a, por(pand(normalized_a, sign_mantissa_mask), half));
+  exponent = pselect(is_zero_or_not_finite, zero, padd(exponent, exponent_offset));  
+  return m;
+}
+
+// Safely applies ldexp, correctly handles overflows, underflows and denormals.
+// Assumes IEEE floating point format.
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+Packet pldexp_generic(const Packet& a, const Packet& exponent) {
+  // We want to return a * 2^exponent, allowing for all possible integer
+  // exponents without overflowing or underflowing in intermediate
+  // computations.
+  //
+  // Since 'a' and the output can be denormal, the maximum range of 'exponent'
+  // to consider for a float is:
+  //   -255-23 -> 255+23
+  // Below -278 any finite float 'a' will become zero, and above +278 any
+  // finite float will become inf, including when 'a' is the smallest possible 
+  // denormal.
+  //
+  // Unfortunately, 2^(278) cannot be represented using either one or two
+  // finite normal floats, so we must split the scale factor into at least
+  // three parts. It turns out to be faster to split 'exponent' into four
+  // factors, since [exponent>>2] is much faster to compute that [exponent/3].
+  //
+  // Set e = min(max(exponent, -278), 278);
+  //     b = floor(e/4);
+  //   out = ((((a * 2^(b)) * 2^(b)) * 2^(b)) * 2^(e-3*b))
+  //
+  // This will avoid any intermediate overflows and correctly handle 0, inf,
+  // NaN cases.
+  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  typedef typename unpacket_traits<PacketI>::type ScalarI;
+  enum {
+    TotalBits = sizeof(Scalar) * CHAR_BIT,
+    MantissaBits = numext::numeric_limits<Scalar>::digits - 1,
+    ExponentBits = int(TotalBits) - int(MantissaBits) - 1
+  };
+
+  const Packet max_exponent = pset1<Packet>(Scalar((ScalarI(1)<<int(ExponentBits)) + ScalarI(int(MantissaBits) - 1)));  // 278
+  const PacketI bias = pset1<PacketI>((ScalarI(1)<<(int(ExponentBits)-1)) - ScalarI(1));  // 127
+  const PacketI e = pcast<Packet, PacketI>(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
+  PacketI b = parithmetic_shift_right<2>(e); // floor(e/4);
+  Packet c = preinterpret<Packet>(plogical_shift_left<int(MantissaBits)>(padd(b, bias)));  // 2^b
+  Packet out = pmul(pmul(pmul(a, c), c), c);  // a * 2^(3b)
+  b = psub(psub(psub(e, b), b), b); // e - 3b
+  c = preinterpret<Packet>(plogical_shift_left<int(MantissaBits)>(padd(b, bias)));  // 2^(e-3*b)
+  out = pmul(out, c);
+  return out;
+}
+
+// Explicitly multiplies 
+//    a * (2^e)
+// clamping e to the range
+// [NumTraits<Scalar>::min_exponent()-2, NumTraits<Scalar>::max_exponent()]
+//
+// This is approx 7x faster than pldexp_impl, but will prematurely over/underflow
+// if 2^e doesn't fit into a normal floating-point Scalar.
+//
+// Assumes IEEE floating point format
+template<typename Packet>
+struct pldexp_fast_impl {
+  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  typedef typename unpacket_traits<PacketI>::type ScalarI;
+  enum {
+    TotalBits = sizeof(Scalar) * CHAR_BIT,
+    MantissaBits = numext::numeric_limits<Scalar>::digits - 1,
+    ExponentBits = int(TotalBits) - int(MantissaBits) - 1
+  };
+  
+  static EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+  Packet run(const Packet& a, const Packet& exponent) {
+    const Packet bias = pset1<Packet>(Scalar((ScalarI(1)<<(int(ExponentBits)-1)) - ScalarI(1)));  // 127
+    const Packet limit = pset1<Packet>(Scalar((ScalarI(1)<<int(ExponentBits)) - ScalarI(1)));     // 255
+    // restrict biased exponent between 0 and 255 for float.
+    const PacketI e = pcast<Packet, PacketI>(pmin(pmax(padd(exponent, bias), pzero(limit)), limit)); // exponent + 127
+    // return a * (2^e)
+    return pmul(a, preinterpret<Packet>(plogical_shift_left<int(MantissaBits)>(e)));
+  }
+};
+
+// Natural or base 2 logarithm.
+// Computes log(x) as log(2^e * m) = C*e + log(m), where the constant C =log(2)
+// and m is in the range [sqrt(1/2),sqrt(2)). In this range, the logarithm can
+// be easily approximated by a polynomial centered on m=1 for stability.
+// TODO(gonnet): Further reduce the interval allowing for lower-degree
+//               polynomial interpolants -> ... -> profit!
+template <typename Packet, bool base2>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_impl_float(const Packet _x)
+{
+  Packet x = _x;
+
+  const Packet cst_1              = pset1<Packet>(1.0f);
+  const Packet cst_neg_half       = pset1<Packet>(-0.5f);
+  // The smallest non denormalized float number.
+  const Packet cst_min_norm_pos   = pset1frombits<Packet>( 0x00800000u);
+  const Packet cst_minus_inf      = pset1frombits<Packet>( 0xff800000u);
+  const Packet cst_pos_inf        = pset1frombits<Packet>( 0x7f800000u);
+
+  // Polynomial coefficients.
+  const Packet cst_cephes_SQRTHF = pset1<Packet>(0.707106781186547524f);
+  const Packet cst_cephes_log_p0 = pset1<Packet>(7.0376836292E-2f);
+  const Packet cst_cephes_log_p1 = pset1<Packet>(-1.1514610310E-1f);
+  const Packet cst_cephes_log_p2 = pset1<Packet>(1.1676998740E-1f);
+  const Packet cst_cephes_log_p3 = pset1<Packet>(-1.2420140846E-1f);
+  const Packet cst_cephes_log_p4 = pset1<Packet>(+1.4249322787E-1f);
+  const Packet cst_cephes_log_p5 = pset1<Packet>(-1.6668057665E-1f);
+  const Packet cst_cephes_log_p6 = pset1<Packet>(+2.0000714765E-1f);
+  const Packet cst_cephes_log_p7 = pset1<Packet>(-2.4999993993E-1f);
+  const Packet cst_cephes_log_p8 = pset1<Packet>(+3.3333331174E-1f);
+
+  // Truncate input values to the minimum positive normal.
+  x = pmax(x, cst_min_norm_pos);
+
+  Packet e;
+  // extract significant in the range [0.5,1) and exponent
+  x = pfrexp(x,e);
+
+  // part2: Shift the inputs from the range [0.5,1) to [sqrt(1/2),sqrt(2))
+  // and shift by -1. The values are then centered around 0, which improves
+  // the stability of the polynomial evaluation.
+  //   if( x < SQRTHF ) {
+  //     e -= 1;
+  //     x = x + x - 1.0;
+  //   } else { x = x - 1.0; }
+  Packet mask = pcmp_lt(x, cst_cephes_SQRTHF);
+  Packet tmp = pand(x, mask);
+  x = psub(x, cst_1);
+  e = psub(e, pand(cst_1, mask));
+  x = padd(x, tmp);
+
+  Packet x2 = pmul(x, x);
+  Packet x3 = pmul(x2, x);
+
+  // Evaluate the polynomial approximant of degree 8 in three parts, probably
+  // to improve instruction-level parallelism.
+  Packet y, y1, y2;
+  y  = pmadd(cst_cephes_log_p0, x, cst_cephes_log_p1);
+  y1 = pmadd(cst_cephes_log_p3, x, cst_cephes_log_p4);
+  y2 = pmadd(cst_cephes_log_p6, x, cst_cephes_log_p7);
+  y  = pmadd(y, x, cst_cephes_log_p2);
+  y1 = pmadd(y1, x, cst_cephes_log_p5);
+  y2 = pmadd(y2, x, cst_cephes_log_p8);
+  y  = pmadd(y, x3, y1);
+  y  = pmadd(y, x3, y2);
+  y  = pmul(y, x3);
+
+  y = pmadd(cst_neg_half, x2, y);
+  x = padd(x, y);
+
+  // Add the logarithm of the exponent back to the result of the interpolation.
+  if (base2) {
+    const Packet cst_log2e = pset1<Packet>(static_cast<float>(EIGEN_LOG2E));
+    x = pmadd(x, cst_log2e, e);
+  } else {
+    const Packet cst_ln2 = pset1<Packet>(static_cast<float>(EIGEN_LN2));
+    x = pmadd(e, cst_ln2, x);
+  }
+
+  Packet invalid_mask = pcmp_lt_or_nan(_x, pzero(_x));
+  Packet iszero_mask  = pcmp_eq(_x,pzero(_x));
+  Packet pos_inf_mask = pcmp_eq(_x,cst_pos_inf);
+  // Filter out invalid inputs, i.e.:
+  //  - negative arg will be NAN
+  //  - 0 will be -INF
+  //  - +INF will be +INF
+  return pselect(iszero_mask, cst_minus_inf,
+                              por(pselect(pos_inf_mask,cst_pos_inf,x), invalid_mask));
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_float(const Packet _x)
+{
+  return plog_impl_float<Packet, /* base2 */ false>(_x);
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog2_float(const Packet _x)
+{
+  return plog_impl_float<Packet, /* base2 */ true>(_x);
+}
+
+/* Returns the base e (2.718...) or base 2 logarithm of x.
+ * The argument is separated into its exponent and fractional parts.
+ * The logarithm of the fraction in the interval [sqrt(1/2), sqrt(2)],
+ * is approximated by
+ *
+ *     log(1+x) = x - 0.5 x**2 + x**3 P(x)/Q(x).
+ *
+ * for more detail see: http://www.netlib.org/cephes/
+ */
+template <typename Packet, bool base2>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_impl_double(const Packet _x)
+{
+  Packet x = _x;
+
+  const Packet cst_1              = pset1<Packet>(1.0);
+  const Packet cst_neg_half       = pset1<Packet>(-0.5);
+  // The smallest non denormalized double.
+  const Packet cst_min_norm_pos   = pset1frombits<Packet>( static_cast<uint64_t>(0x0010000000000000ull));
+  const Packet cst_minus_inf      = pset1frombits<Packet>( static_cast<uint64_t>(0xfff0000000000000ull));
+  const Packet cst_pos_inf        = pset1frombits<Packet>( static_cast<uint64_t>(0x7ff0000000000000ull));
+
+
+ // Polynomial Coefficients for log(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
+ //                             1/sqrt(2) <= x < sqrt(2)
+  const Packet cst_cephes_SQRTHF = pset1<Packet>(0.70710678118654752440E0);
+  const Packet cst_cephes_log_p0 = pset1<Packet>(1.01875663804580931796E-4);
+  const Packet cst_cephes_log_p1 = pset1<Packet>(4.97494994976747001425E-1);
+  const Packet cst_cephes_log_p2 = pset1<Packet>(4.70579119878881725854E0);
+  const Packet cst_cephes_log_p3 = pset1<Packet>(1.44989225341610930846E1);
+  const Packet cst_cephes_log_p4 = pset1<Packet>(1.79368678507819816313E1);
+  const Packet cst_cephes_log_p5 = pset1<Packet>(7.70838733755885391666E0);
+
+  const Packet cst_cephes_log_q0 = pset1<Packet>(1.0);
+  const Packet cst_cephes_log_q1 = pset1<Packet>(1.12873587189167450590E1);
+  const Packet cst_cephes_log_q2 = pset1<Packet>(4.52279145837532221105E1);
+  const Packet cst_cephes_log_q3 = pset1<Packet>(8.29875266912776603211E1);
+  const Packet cst_cephes_log_q4 = pset1<Packet>(7.11544750618563894466E1);
+  const Packet cst_cephes_log_q5 = pset1<Packet>(2.31251620126765340583E1);
+
+  // Truncate input values to the minimum positive normal.
+  x = pmax(x, cst_min_norm_pos);
+
+  Packet e;
+  // extract significant in the range [0.5,1) and exponent
+  x = pfrexp(x,e);
+  
+  // Shift the inputs from the range [0.5,1) to [sqrt(1/2),sqrt(2))
+  // and shift by -1. The values are then centered around 0, which improves
+  // the stability of the polynomial evaluation.
+  //   if( x < SQRTHF ) {
+  //     e -= 1;
+  //     x = x + x - 1.0;
+  //   } else { x = x - 1.0; }
+  Packet mask = pcmp_lt(x, cst_cephes_SQRTHF);
+  Packet tmp = pand(x, mask);
+  x = psub(x, cst_1);
+  e = psub(e, pand(cst_1, mask));
+  x = padd(x, tmp);
+
+  Packet x2 = pmul(x, x);
+  Packet x3 = pmul(x2, x);
+
+  // Evaluate the polynomial approximant , probably to improve instruction-level parallelism.
+  // y = x - 0.5*x^2 + x^3 * polevl( x, P, 5 ) / p1evl( x, Q, 5 ) );
+  Packet y, y1, y_;
+  y  = pmadd(cst_cephes_log_p0, x, cst_cephes_log_p1);
+  y1 = pmadd(cst_cephes_log_p3, x, cst_cephes_log_p4);
+  y  = pmadd(y, x, cst_cephes_log_p2);
+  y1 = pmadd(y1, x, cst_cephes_log_p5);
+  y_ = pmadd(y, x3, y1);
+
+  y  = pmadd(cst_cephes_log_q0, x, cst_cephes_log_q1);
+  y1 = pmadd(cst_cephes_log_q3, x, cst_cephes_log_q4);
+  y  = pmadd(y, x, cst_cephes_log_q2);
+  y1 = pmadd(y1, x, cst_cephes_log_q5);
+  y  = pmadd(y, x3, y1);
+
+  y_ = pmul(y_, x3);
+  y  = pdiv(y_, y);
+
+  y = pmadd(cst_neg_half, x2, y);
+  x = padd(x, y);
+
+  // Add the logarithm of the exponent back to the result of the interpolation.
+  if (base2) {
+    const Packet cst_log2e = pset1<Packet>(static_cast<double>(EIGEN_LOG2E));
+    x = pmadd(x, cst_log2e, e);
+  } else {
+    const Packet cst_ln2 = pset1<Packet>(static_cast<double>(EIGEN_LN2));
+    x = pmadd(e, cst_ln2, x);
+  }
+
+  Packet invalid_mask = pcmp_lt_or_nan(_x, pzero(_x));
+  Packet iszero_mask  = pcmp_eq(_x,pzero(_x));
+  Packet pos_inf_mask = pcmp_eq(_x,cst_pos_inf);
+  // Filter out invalid inputs, i.e.:
+  //  - negative arg will be NAN
+  //  - 0 will be -INF
+  //  - +INF will be +INF
+  return pselect(iszero_mask, cst_minus_inf,
+                              por(pselect(pos_inf_mask,cst_pos_inf,x), invalid_mask));
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_double(const Packet _x)
+{
+  return plog_impl_double<Packet, /* base2 */ false>(_x);
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog2_double(const Packet _x)
+{
+  return plog_impl_double<Packet, /* base2 */ true>(_x);
+}
+
+/** \internal \returns log(1 + x) computed using W. Kahan's formula.
+    See: http://www.plunk.org/~hatch/rightway.php
+ */
+template<typename Packet>
+Packet generic_plog1p(const Packet& x)
+{
+  typedef typename unpacket_traits<Packet>::type ScalarType;
+  const Packet one = pset1<Packet>(ScalarType(1));
+  Packet xp1 = padd(x, one);
+  Packet small_mask = pcmp_eq(xp1, one);
+  Packet log1 = plog(xp1);
+  Packet inf_mask = pcmp_eq(xp1, log1);
+  Packet log_large = pmul(x, pdiv(log1, psub(xp1, one)));
+  return pselect(por(small_mask, inf_mask), x, log_large);
+}
+
+/** \internal \returns exp(x)-1 computed using W. Kahan's formula.
+    See: http://www.plunk.org/~hatch/rightway.php
+ */
+template<typename Packet>
+Packet generic_expm1(const Packet& x)
+{
+  typedef typename unpacket_traits<Packet>::type ScalarType;
+  const Packet one = pset1<Packet>(ScalarType(1));
+  const Packet neg_one = pset1<Packet>(ScalarType(-1));
+  Packet u = pexp(x);
+  Packet one_mask = pcmp_eq(u, one);
+  Packet u_minus_one = psub(u, one);
+  Packet neg_one_mask = pcmp_eq(u_minus_one, neg_one);
+  Packet logu = plog(u);
+  // The following comparison is to catch the case where
+  // exp(x) = +inf. It is written in this way to avoid having
+  // to form the constant +inf, which depends on the packet
+  // type.
+  Packet pos_inf_mask = pcmp_eq(logu, u);
+  Packet expm1 = pmul(u_minus_one, pdiv(x, logu));
+  expm1 = pselect(pos_inf_mask, u, expm1);
+  return pselect(one_mask,
+                 x,
+                 pselect(neg_one_mask,
+                         neg_one,
+                         expm1));
+}
+
+
+// Exponential function. Works by writing "x = m*log(2) + r" where
+// "m = floor(x/log(2)+1/2)" and "r" is the remainder. The result is then
+// "exp(x) = 2^m*exp(r)" where exp(r) is in the range [-1,1).
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pexp_float(const Packet _x)
+{
+  const Packet cst_1      = pset1<Packet>(1.0f);
+  const Packet cst_half   = pset1<Packet>(0.5f);
+  const Packet cst_exp_hi = pset1<Packet>( 88.723f);
+  const Packet cst_exp_lo = pset1<Packet>(-88.723f);
+
+  const Packet cst_cephes_LOG2EF = pset1<Packet>(1.44269504088896341f);
+  const Packet cst_cephes_exp_p0 = pset1<Packet>(1.9875691500E-4f);
+  const Packet cst_cephes_exp_p1 = pset1<Packet>(1.3981999507E-3f);
+  const Packet cst_cephes_exp_p2 = pset1<Packet>(8.3334519073E-3f);
+  const Packet cst_cephes_exp_p3 = pset1<Packet>(4.1665795894E-2f);
+  const Packet cst_cephes_exp_p4 = pset1<Packet>(1.6666665459E-1f);
+  const Packet cst_cephes_exp_p5 = pset1<Packet>(5.0000001201E-1f);
+
+  // Clamp x.
+  Packet x = pmax(pmin(_x, cst_exp_hi), cst_exp_lo);
+
+  // Express exp(x) as exp(m*ln(2) + r), start by extracting
+  // m = floor(x/ln(2) + 0.5).
+  Packet m = pfloor(pmadd(x, cst_cephes_LOG2EF, cst_half));
+
+  // Get r = x - m*ln(2). If no FMA instructions are available, m*ln(2) is
+  // subtracted out in two parts, m*C1+m*C2 = m*ln(2), to avoid accumulating
+  // truncation errors.
+  const Packet cst_cephes_exp_C1 = pset1<Packet>(-0.693359375f);
+  const Packet cst_cephes_exp_C2 = pset1<Packet>(2.12194440e-4f);
+  Packet r = pmadd(m, cst_cephes_exp_C1, x);
+  r = pmadd(m, cst_cephes_exp_C2, r);
+
+  Packet r2 = pmul(r, r);
+  Packet r3 = pmul(r2, r);
+
+  // Evaluate the polynomial approximant,improved by instruction-level parallelism.
+  Packet y, y1, y2;
+  y  = pmadd(cst_cephes_exp_p0, r, cst_cephes_exp_p1);
+  y1 = pmadd(cst_cephes_exp_p3, r, cst_cephes_exp_p4);
+  y2 = padd(r, cst_1);
+  y  = pmadd(y, r, cst_cephes_exp_p2);
+  y1 = pmadd(y1, r, cst_cephes_exp_p5);
+  y  = pmadd(y, r3, y1);
+  y  = pmadd(y, r2, y2);
+
+  // Return 2^m * exp(r).
+  // TODO: replace pldexp with faster implementation since y in [-1, 1).
+  return pmax(pldexp(y,m), _x);
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pexp_double(const Packet _x)
+{
+  Packet x = _x;
+
+  const Packet cst_1 = pset1<Packet>(1.0);
+  const Packet cst_2 = pset1<Packet>(2.0);
+  const Packet cst_half = pset1<Packet>(0.5);
+
+  const Packet cst_exp_hi = pset1<Packet>(709.784);
+  const Packet cst_exp_lo = pset1<Packet>(-709.784);
+
+  const Packet cst_cephes_LOG2EF = pset1<Packet>(1.4426950408889634073599);
+  const Packet cst_cephes_exp_p0 = pset1<Packet>(1.26177193074810590878e-4);
+  const Packet cst_cephes_exp_p1 = pset1<Packet>(3.02994407707441961300e-2);
+  const Packet cst_cephes_exp_p2 = pset1<Packet>(9.99999999999999999910e-1);
+  const Packet cst_cephes_exp_q0 = pset1<Packet>(3.00198505138664455042e-6);
+  const Packet cst_cephes_exp_q1 = pset1<Packet>(2.52448340349684104192e-3);
+  const Packet cst_cephes_exp_q2 = pset1<Packet>(2.27265548208155028766e-1);
+  const Packet cst_cephes_exp_q3 = pset1<Packet>(2.00000000000000000009e0);
+  const Packet cst_cephes_exp_C1 = pset1<Packet>(0.693145751953125);
+  const Packet cst_cephes_exp_C2 = pset1<Packet>(1.42860682030941723212e-6);
+
+  Packet tmp, fx;
+
+  // clamp x
+  x = pmax(pmin(x, cst_exp_hi), cst_exp_lo);
+  // Express exp(x) as exp(g + n*log(2)).
+  fx = pmadd(cst_cephes_LOG2EF, x, cst_half);
+
+  // Get the integer modulus of log(2), i.e. the "n" described above.
+  fx = pfloor(fx);
+
+  // Get the remainder modulo log(2), i.e. the "g" described above. Subtract
+  // n*log(2) out in two steps, i.e. n*C1 + n*C2, C1+C2=log2 to get the last
+  // digits right.
+  tmp = pmul(fx, cst_cephes_exp_C1);
+  Packet z = pmul(fx, cst_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  Packet x2 = pmul(x, x);
+
+  // Evaluate the numerator polynomial of the rational interpolant.
+  Packet px = cst_cephes_exp_p0;
+  px = pmadd(px, x2, cst_cephes_exp_p1);
+  px = pmadd(px, x2, cst_cephes_exp_p2);
+  px = pmul(px, x);
+
+  // Evaluate the denominator polynomial of the rational interpolant.
+  Packet qx = cst_cephes_exp_q0;
+  qx = pmadd(qx, x2, cst_cephes_exp_q1);
+  qx = pmadd(qx, x2, cst_cephes_exp_q2);
+  qx = pmadd(qx, x2, cst_cephes_exp_q3);
+
+  // I don't really get this bit, copied from the SSE2 routines, so...
+  // TODO(gonnet): Figure out what is going on here, perhaps find a better
+  // rational interpolant?
+  x = pdiv(px, psub(qx, px));
+  x = pmadd(cst_2, x, cst_1);
+
+  // Construct the result 2^n * exp(g) = e * x. The max is used to catch
+  // non-finite values in the input.
+  // TODO: replace pldexp with faster implementation since x in [-1, 1).
+  return pmax(pldexp(x,fx), _x);
+}
+
+// The following code is inspired by the following stack-overflow answer:
+//   https://stackoverflow.com/questions/30463616/payne-hanek-algorithm-implementation-in-c/30465751#30465751
+// It has been largely optimized:
+//  - By-pass calls to frexp.
+//  - Aligned loads of required 96 bits of 2/pi. This is accomplished by
+//    (1) balancing the mantissa and exponent to the required bits of 2/pi are
+//    aligned on 8-bits, and (2) replicating the storage of the bits of 2/pi.
+//  - Avoid a branch in rounding and extraction of the remaining fractional part.
+// Overall, I measured a speed up higher than x2 on x86-64.
+inline float trig_reduce_huge (float xf, int *quadrant)
+{
+  using Eigen::numext::int32_t;
+  using Eigen::numext::uint32_t;
+  using Eigen::numext::int64_t;
+  using Eigen::numext::uint64_t;
+
+  const double pio2_62 = 3.4061215800865545e-19;    // pi/2 * 2^-62
+  const uint64_t zero_dot_five = uint64_t(1) << 61; // 0.5 in 2.62-bit fixed-point foramt
+
+  // 192 bits of 2/pi for Payne-Hanek reduction
+  // Bits are introduced by packet of 8 to enable aligned reads.
+  static const uint32_t two_over_pi [] = 
+  {
+    0x00000028, 0x000028be, 0x0028be60, 0x28be60db,
+    0xbe60db93, 0x60db9391, 0xdb939105, 0x9391054a,
+    0x91054a7f, 0x054a7f09, 0x4a7f09d5, 0x7f09d5f4,
+    0x09d5f47d, 0xd5f47d4d, 0xf47d4d37, 0x7d4d3770,
+    0x4d377036, 0x377036d8, 0x7036d8a5, 0x36d8a566,
+    0xd8a5664f, 0xa5664f10, 0x664f10e4, 0x4f10e410,
+    0x10e41000, 0xe4100000
+  };
+  
+  uint32_t xi = numext::bit_cast<uint32_t>(xf);
+  // Below, -118 = -126 + 8.
+  //   -126 is to get the exponent,
+  //   +8 is to enable alignment of 2/pi's bits on 8 bits.
+  // This is possible because the fractional part of x as only 24 meaningful bits.
+  uint32_t e = (xi >> 23) - 118;
+  // Extract the mantissa and shift it to align it wrt the exponent
+  xi = ((xi & 0x007fffffu)| 0x00800000u) << (e & 0x7);
+
+  uint32_t i = e >> 3;
+  uint32_t twoopi_1  = two_over_pi[i-1];
+  uint32_t twoopi_2  = two_over_pi[i+3];
+  uint32_t twoopi_3  = two_over_pi[i+7];
+
+  // Compute x * 2/pi in 2.62-bit fixed-point format.
+  uint64_t p;
+  p = uint64_t(xi) * twoopi_3;
+  p = uint64_t(xi) * twoopi_2 + (p >> 32);
+  p = (uint64_t(xi * twoopi_1) << 32) + p;
+
+  // Round to nearest: add 0.5 and extract integral part.
+  uint64_t q = (p + zero_dot_five) >> 62;
+  *quadrant = int(q);
+  // Now it remains to compute "r = x - q*pi/2" with high accuracy,
+  // since we have p=x/(pi/2) with high accuracy, we can more efficiently compute r as:
+  //   r = (p-q)*pi/2,
+  // where the product can be be carried out with sufficient accuracy using double precision.
+  p -= q<<62;
+  return float(double(int64_t(p)) * pio2_62);
+}
+
+template<bool ComputeSine,typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+#if EIGEN_GNUC_AT_LEAST(4,4) && EIGEN_COMP_GNUC_STRICT
+__attribute__((optimize("-fno-unsafe-math-optimizations")))
+#endif
+Packet psincos_float(const Packet& _x)
+{
+  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
+
+  const Packet  cst_2oPI            = pset1<Packet>(0.636619746685028076171875f); // 2/PI
+  const Packet  cst_rounding_magic  = pset1<Packet>(12582912); // 2^23 for rounding
+  const PacketI csti_1              = pset1<PacketI>(1);
+  const Packet  cst_sign_mask       = pset1frombits<Packet>(0x80000000u);
+
+  Packet x = pabs(_x);
+
+  // Scale x by 2/Pi to find x's octant.
+  Packet y = pmul(x, cst_2oPI);
+
+  // Rounding trick:
+  Packet y_round = padd(y, cst_rounding_magic);
+  EIGEN_OPTIMIZATION_BARRIER(y_round)
+  PacketI y_int = preinterpret<PacketI>(y_round); // last 23 digits represent integer (if abs(x)<2^24)
+  y = psub(y_round, cst_rounding_magic); // nearest integer to x*4/pi
+
+  // Reduce x by y octants to get: -Pi/4 <= x <= +Pi/4
+  // using "Extended precision modular arithmetic"
+  #if defined(EIGEN_HAS_SINGLE_INSTRUCTION_MADD)
+  // This version requires true FMA for high accuracy
+  // It provides a max error of 1ULP up to (with absolute_error < 5.9605e-08):
+  const float huge_th = ComputeSine ? 117435.992f : 71476.0625f;
+  x = pmadd(y, pset1<Packet>(-1.57079601287841796875f), x);
+  x = pmadd(y, pset1<Packet>(-3.1391647326017846353352069854736328125e-07f), x);
+  x = pmadd(y, pset1<Packet>(-5.390302529957764765544681040410068817436695098876953125e-15f), x);
+  #else
+  // Without true FMA, the previous set of coefficients maintain 1ULP accuracy
+  // up to x<15.7 (for sin), but accuracy is immediately lost for x>15.7.
+  // We thus use one more iteration to maintain 2ULPs up to reasonably large inputs.
+
+  // The following set of coefficients maintain 1ULP up to 9.43 and 14.16 for sin and cos respectively.
+  // and 2 ULP up to:
+  const float huge_th = ComputeSine ? 25966.f : 18838.f;
+  x = pmadd(y, pset1<Packet>(-1.5703125), x); // = 0xbfc90000
+  EIGEN_OPTIMIZATION_BARRIER(x)
+  x = pmadd(y, pset1<Packet>(-0.000483989715576171875), x); // = 0xb9fdc000
+  EIGEN_OPTIMIZATION_BARRIER(x)
+  x = pmadd(y, pset1<Packet>(1.62865035235881805419921875e-07), x); // = 0x342ee000
+  x = pmadd(y, pset1<Packet>(5.5644315544167710640977020375430583953857421875e-11), x); // = 0x2e74b9ee
+
+  // For the record, the following set of coefficients maintain 2ULP up
+  // to a slightly larger range:
+  // const float huge_th = ComputeSine ? 51981.f : 39086.125f;
+  // but it slightly fails to maintain 1ULP for two values of sin below pi.
+  // x = pmadd(y, pset1<Packet>(-3.140625/2.), x);
+  // x = pmadd(y, pset1<Packet>(-0.00048351287841796875), x);
+  // x = pmadd(y, pset1<Packet>(-3.13855707645416259765625e-07), x);
+  // x = pmadd(y, pset1<Packet>(-6.0771006282767103812147979624569416046142578125e-11), x);
+
+  // For the record, with only 3 iterations it is possible to maintain
+  // 1 ULP up to 3PI (maybe more) and 2ULP up to 255.
+  // The coefficients are: 0xbfc90f80, 0xb7354480, 0x2e74b9ee
+  #endif
+
+  if(predux_any(pcmp_le(pset1<Packet>(huge_th),pabs(_x))))
+  {
+    const int PacketSize = unpacket_traits<Packet>::size;
+    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) float vals[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) float x_cpy[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) int y_int2[PacketSize];
+    pstoreu(vals, pabs(_x));
+    pstoreu(x_cpy, x);
+    pstoreu(y_int2, y_int);
+    for(int k=0; k<PacketSize;++k)
+    {
+      float val = vals[k];
+      if(val>=huge_th && (numext::isfinite)(val))
+        x_cpy[k] = trig_reduce_huge(val,&y_int2[k]);
+    }
+    x = ploadu<Packet>(x_cpy);
+    y_int = ploadu<PacketI>(y_int2);
+  }
+
+  // Compute the sign to apply to the polynomial.
+  // sin: sign = second_bit(y_int) xor signbit(_x)
+  // cos: sign = second_bit(y_int+1)
+  Packet sign_bit = ComputeSine ? pxor(_x, preinterpret<Packet>(plogical_shift_left<30>(y_int)))
+                                : preinterpret<Packet>(plogical_shift_left<30>(padd(y_int,csti_1)));
+  sign_bit = pand(sign_bit, cst_sign_mask); // clear all but left most bit
+
+  // Get the polynomial selection mask from the second bit of y_int
+  // We'll calculate both (sin and cos) polynomials and then select from the two.
+  Packet poly_mask = preinterpret<Packet>(pcmp_eq(pand(y_int, csti_1), pzero(y_int)));
+
+  Packet x2 = pmul(x,x);
+
+  // Evaluate the cos(x) polynomial. (-Pi/4 <= x <= Pi/4)
+  Packet y1 =        pset1<Packet>(2.4372266125283204019069671630859375e-05f);
+  y1 = pmadd(y1, x2, pset1<Packet>(-0.00138865201734006404876708984375f     ));
+  y1 = pmadd(y1, x2, pset1<Packet>(0.041666619479656219482421875f           ));
+  y1 = pmadd(y1, x2, pset1<Packet>(-0.5f));
+  y1 = pmadd(y1, x2, pset1<Packet>(1.f));
+
+  // Evaluate the sin(x) polynomial. (Pi/4 <= x <= Pi/4)
+  // octave/matlab code to compute those coefficients:
+  //    x = (0:0.0001:pi/4)';
+  //    A = [x.^3 x.^5 x.^7];
+  //    w = ((1.-(x/(pi/4)).^2).^5)*2000+1;         # weights trading relative accuracy
+  //    c = (A'*diag(w)*A)\(A'*diag(w)*(sin(x)-x)); # weighted LS, linear coeff forced to 1
+  //    printf('%.64f\n %.64f\n%.64f\n', c(3), c(2), c(1))
+  //
+  Packet y2 =        pset1<Packet>(-0.0001959234114083702898469196984621021329076029360294342041015625f);
+  y2 = pmadd(y2, x2, pset1<Packet>( 0.0083326873655616851693794799871284340042620897293090820312500000f));
+  y2 = pmadd(y2, x2, pset1<Packet>(-0.1666666203982298255503735617821803316473960876464843750000000000f));
+  y2 = pmul(y2, x2);
+  y2 = pmadd(y2, x, x);
+
+  // Select the correct result from the two polynomials.
+  y = ComputeSine ? pselect(poly_mask,y2,y1)
+                  : pselect(poly_mask,y1,y2);
+
+  // Update the sign and filter huge inputs
+  return pxor(y, sign_bit);
+}
+
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet psin_float(const Packet& x)
+{
+  return psincos_float<true>(x);
+}
+
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pcos_float(const Packet& x)
+{
+  return psincos_float<false>(x);
+}
+
+
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet psqrt_complex(const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  typedef typename Scalar::value_type RealScalar;
+  typedef typename unpacket_traits<Packet>::as_real RealPacket;
+
+  // Computes the principal sqrt of the complex numbers in the input.
+  //
+  // For example, for packets containing 2 complex numbers stored in interleaved format
+  //    a = [a0, a1] = [x0, y0, x1, y1],
+  // where x0 = real(a0), y0 = imag(a0) etc., this function returns
+  //    b = [b0, b1] = [u0, v0, u1, v1],
+  // such that b0^2 = a0, b1^2 = a1.
+  //
+  // To derive the formula for the complex square roots, let's consider the equation for
+  // a single complex square root of the number x + i*y. We want to find real numbers
+  // u and v such that
+  //    (u + i*v)^2 = x + i*y  <=>
+  //    u^2 - v^2 + i*2*u*v = x + i*v.
+  // By equating the real and imaginary parts we get:
+  //    u^2 - v^2 = x
+  //    2*u*v = y.
+  //
+  // For x >= 0, this has the numerically stable solution
+  //    u = sqrt(0.5 * (x + sqrt(x^2 + y^2)))
+  //    v = 0.5 * (y / u)
+  // and for x < 0,
+  //    v = sign(y) * sqrt(0.5 * (-x + sqrt(x^2 + y^2)))
+  //    u = 0.5 * (y / v)
+  //
+  //  To avoid unnecessary over- and underflow, we compute sqrt(x^2 + y^2) as
+  //     l = max(|x|, |y|) * sqrt(1 + (min(|x|, |y|) / max(|x|, |y|))^2) ,
+
+  // In the following, without lack of generality, we have annotated the code, assuming
+  // that the input is a packet of 2 complex numbers.
+  //
+  // Step 1. Compute l = [l0, l0, l1, l1], where
+  //    l0 = sqrt(x0^2 + y0^2),  l1 = sqrt(x1^2 + y1^2)
+  // To avoid over- and underflow, we use the stable formula for each hypotenuse
+  //    l0 = (min0 == 0 ? max0 : max0 * sqrt(1 + (min0/max0)**2)),
+  // where max0 = max(|x0|, |y0|), min0 = min(|x0|, |y0|), and similarly for l1.
+
+  RealPacket a_abs = pabs(a.v);           // [|x0|, |y0|, |x1|, |y1|]
+  RealPacket a_abs_flip = pcplxflip(Packet(a_abs)).v; // [|y0|, |x0|, |y1|, |x1|]
+  RealPacket a_max = pmax(a_abs, a_abs_flip);
+  RealPacket a_min = pmin(a_abs, a_abs_flip);
+  RealPacket a_min_zero_mask = pcmp_eq(a_min, pzero(a_min));
+  RealPacket a_max_zero_mask = pcmp_eq(a_max, pzero(a_max));
+  RealPacket r = pdiv(a_min, a_max);
+  const RealPacket cst_one  = pset1<RealPacket>(RealScalar(1));
+  RealPacket l = pmul(a_max, psqrt(padd(cst_one, pmul(r, r))));  // [l0, l0, l1, l1]
+  // Set l to a_max if a_min is zero.
+  l = pselect(a_min_zero_mask, a_max, l);
+
+  // Step 2. Compute [rho0, *, rho1, *], where
+  // rho0 = sqrt(0.5 * (l0 + |x0|)), rho1 =  sqrt(0.5 * (l1 + |x1|))
+  // We don't care about the imaginary parts computed here. They will be overwritten later.
+  const RealPacket cst_half = pset1<RealPacket>(RealScalar(0.5));
+  Packet rho;
+  rho.v = psqrt(pmul(cst_half, padd(a_abs, l)));
+
+  // Step 3. Compute [rho0, eta0, rho1, eta1], where
+  // eta0 = (y0 / l0) / 2, and eta1 = (y1 / l1) / 2.
+  // set eta = 0 of input is 0 + i0.
+  RealPacket eta = pandnot(pmul(cst_half, pdiv(a.v, pcplxflip(rho).v)), a_max_zero_mask);
+  RealPacket real_mask = peven_mask(a.v);
+  Packet positive_real_result;
+  // Compute result for inputs with positive real part.
+  positive_real_result.v = pselect(real_mask, rho.v, eta);
+
+  // Step 4. Compute solution for inputs with negative real part:
+  //         [|eta0|, sign(y0)*rho0, |eta1|, sign(y1)*rho1]
+  const RealScalar neg_zero = RealScalar(numext::bit_cast<float>(0x80000000u));
+  const RealPacket cst_imag_sign_mask = pset1<Packet>(Scalar(RealScalar(0.0), neg_zero)).v;
+  RealPacket imag_signs = pand(a.v, cst_imag_sign_mask);
+  Packet negative_real_result;
+  // Notice that rho is positive, so taking it's absolute value is a noop.
+  negative_real_result.v = por(pabs(pcplxflip(positive_real_result).v), imag_signs);
+
+  // Step 5. Select solution branch based on the sign of the real parts.
+  Packet negative_real_mask;
+  negative_real_mask.v = pcmp_lt(pand(real_mask, a.v), pzero(a.v));
+  negative_real_mask.v = por(negative_real_mask.v, pcplxflip(negative_real_mask).v);
+  Packet result = pselect(negative_real_mask, negative_real_result, positive_real_result);
+
+  // Step 6. Handle special cases for infinities:
+  // * If z is (x,+∞), the result is (+∞,+∞) even if x is NaN
+  // * If z is (x,-∞), the result is (+∞,-∞) even if x is NaN
+  // * If z is (-∞,y), the result is (0*|y|,+∞) for finite or NaN y
+  // * If z is (+∞,y), the result is (+∞,0*|y|) for finite or NaN y
+  const RealPacket cst_pos_inf = pset1<RealPacket>(NumTraits<RealScalar>::infinity());
+  Packet is_inf;
+  is_inf.v = pcmp_eq(a_abs, cst_pos_inf);
+  Packet is_real_inf;
+  is_real_inf.v = pand(is_inf.v, real_mask);
+  is_real_inf = por(is_real_inf, pcplxflip(is_real_inf));
+  // prepare packet of (+∞,0*|y|) or (0*|y|,+∞), depending on the sign of the infinite real part.
+  Packet real_inf_result;
+  real_inf_result.v = pmul(a_abs, pset1<Packet>(Scalar(RealScalar(1.0), RealScalar(0.0))).v);
+  real_inf_result.v = pselect(negative_real_mask.v, pcplxflip(real_inf_result).v, real_inf_result.v);
+  // prepare packet of (+∞,+∞) or (+∞,-∞), depending on the sign of the infinite imaginary part.
+  Packet is_imag_inf;
+  is_imag_inf.v = pandnot(is_inf.v, real_mask);
+  is_imag_inf = por(is_imag_inf, pcplxflip(is_imag_inf));
+  Packet imag_inf_result;
+  imag_inf_result.v = por(pand(cst_pos_inf, real_mask), pandnot(a.v, real_mask));
+
+  return  pselect(is_imag_inf, imag_inf_result,
+                  pselect(is_real_inf, real_inf_result,result));
+}
+
+// TODO(rmlarsen): The following set of utilities for double word arithmetic
+// should perhaps be refactored as a separate file, since it would be generally
+// useful for special function implementation etc. Writing the algorithms in
+// terms if a double word type would also make the code more readable.
+
+// This function splits x into the nearest integer n and fractional part r,
+// such that x = n + r holds exactly.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void absolute_split(const Packet& x, Packet& n, Packet& r) {
+  n = pround(x);
+  r = psub(x, n);
+}
+
+// This function computes the sum {s, r}, such that x + y = s_hi + s_lo
+// holds exactly, and s_hi = fl(x+y), if |x| >= |y|.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void fast_twosum(const Packet& x, const Packet& y, Packet& s_hi, Packet& s_lo) {
+  s_hi = padd(x, y);
+  const Packet t = psub(s_hi, x);
+  s_lo = psub(y, t);
+}
+
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+// This function implements the extended precision product of
+// a pair of floating point numbers. Given {x, y}, it computes the pair
+// {p_hi, p_lo} such that x * y = p_hi + p_lo holds exactly and
+// p_hi = fl(x * y).
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void twoprod(const Packet& x, const Packet& y,
+             Packet& p_hi, Packet& p_lo) {
+  p_hi = pmul(x, y);
+  p_lo = pmadd(x, y, pnegate(p_hi));
+}
+
+#else
+
+// This function implements the Veltkamp splitting. Given a floating point
+// number x it returns the pair {x_hi, x_lo} such that x_hi + x_lo = x holds
+// exactly and that half of the significant of x fits in x_hi.
+// This is Algorithm 3 from Jean-Michel Muller, "Elementary Functions",
+// 3rd edition, Birkh\"auser, 2016.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void veltkamp_splitting(const Packet& x, Packet& x_hi, Packet& x_lo) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  EIGEN_CONSTEXPR int shift = (NumTraits<Scalar>::digits() + 1) / 2;
+  const Scalar shift_scale = Scalar(uint64_t(1) << shift);  // Scalar constructor not necessarily constexpr.
+  const Packet gamma = pmul(pset1<Packet>(shift_scale + Scalar(1)), x);
+  Packet rho = psub(x, gamma);
+  x_hi = padd(rho, gamma);
+  x_lo = psub(x, x_hi);
+}
+
+// This function implements Dekker's algorithm for products x * y.
+// Given floating point numbers {x, y} computes the pair
+// {p_hi, p_lo} such that x * y = p_hi + p_lo holds exactly and
+// p_hi = fl(x * y).
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void twoprod(const Packet& x, const Packet& y,
+             Packet& p_hi, Packet& p_lo) {
+  Packet x_hi, x_lo, y_hi, y_lo;
+  veltkamp_splitting(x, x_hi, x_lo);
+  veltkamp_splitting(y, y_hi, y_lo);
+
+  p_hi = pmul(x, y);
+  p_lo = pmadd(x_hi, y_hi, pnegate(p_hi));
+  p_lo = pmadd(x_hi, y_lo, p_lo);
+  p_lo = pmadd(x_lo, y_hi, p_lo);
+  p_lo = pmadd(x_lo, y_lo, p_lo);
+}
+
+#endif  // EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+
+
+// This function implements Dekker's algorithm for the addition
+// of two double word numbers represented by {x_hi, x_lo} and {y_hi, y_lo}.
+// It returns the result as a pair {s_hi, s_lo} such that
+// x_hi + x_lo + y_hi + y_lo = s_hi + s_lo holds exactly.
+// This is Algorithm 5 from Jean-Michel Muller, "Elementary Functions",
+// 3rd edition, Birkh\"auser, 2016.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+  void twosum(const Packet& x_hi, const Packet& x_lo,
+              const Packet& y_hi, const Packet& y_lo,
+              Packet& s_hi, Packet& s_lo) {
+  const Packet x_greater_mask = pcmp_lt(pabs(y_hi), pabs(x_hi));
+  Packet r_hi_1, r_lo_1;
+  fast_twosum(x_hi, y_hi,r_hi_1, r_lo_1);
+  Packet r_hi_2, r_lo_2;
+  fast_twosum(y_hi, x_hi,r_hi_2, r_lo_2);
+  const Packet r_hi = pselect(x_greater_mask, r_hi_1, r_hi_2);
+
+  const Packet s1 = padd(padd(y_lo, r_lo_1), x_lo);
+  const Packet s2 = padd(padd(x_lo, r_lo_2), y_lo);
+  const Packet s = pselect(x_greater_mask, s1, s2);
+
+  fast_twosum(r_hi, s, s_hi, s_lo);
+}
+
+// This is a version of twosum for double word numbers,
+// which assumes that |x_hi| >= |y_hi|.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+  void fast_twosum(const Packet& x_hi, const Packet& x_lo,
+              const Packet& y_hi, const Packet& y_lo,
+              Packet& s_hi, Packet& s_lo) {
+  Packet r_hi, r_lo;
+  fast_twosum(x_hi, y_hi, r_hi, r_lo);
+  const Packet s = padd(padd(y_lo, r_lo), x_lo);
+  fast_twosum(r_hi, s, s_hi, s_lo);
+}
+
+// This is a version of twosum for adding a floating point number x to
+// double word number {y_hi, y_lo} number, with the assumption
+// that |x| >= |y_hi|.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void fast_twosum(const Packet& x,
+                 const Packet& y_hi, const Packet& y_lo,
+                 Packet& s_hi, Packet& s_lo) {
+  Packet r_hi, r_lo;
+  fast_twosum(x, y_hi, r_hi, r_lo);
+  const Packet s = padd(y_lo, r_lo);
+  fast_twosum(r_hi, s, s_hi, s_lo);
+}
+
+// This function implements the multiplication of a double word
+// number represented by {x_hi, x_lo} by a floating point number y.
+// It returns the result as a pair {p_hi, p_lo} such that
+// (x_hi + x_lo) * y = p_hi + p_lo hold with a relative error
+// of less than 2*2^{-2p}, where p is the number of significand bit
+// in the floating point type.
+// This is Algorithm 7 from Jean-Michel Muller, "Elementary Functions",
+// 3rd edition, Birkh\"auser, 2016.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void twoprod(const Packet& x_hi, const Packet& x_lo, const Packet& y,
+             Packet& p_hi, Packet& p_lo) {
+  Packet c_hi, c_lo1;
+  twoprod(x_hi, y, c_hi, c_lo1);
+  const Packet c_lo2 = pmul(x_lo, y);
+  Packet t_hi, t_lo1;
+  fast_twosum(c_hi, c_lo2, t_hi, t_lo1);
+  const Packet t_lo2 = padd(t_lo1, c_lo1);
+  fast_twosum(t_hi, t_lo2, p_hi, p_lo);
+}
+
+// This function implements the multiplication of two double word
+// numbers represented by {x_hi, x_lo} and {y_hi, y_lo}.
+// It returns the result as a pair {p_hi, p_lo} such that
+// (x_hi + x_lo) * (y_hi + y_lo) = p_hi + p_lo holds with a relative error
+// of less than 2*2^{-2p}, where p is the number of significand bit
+// in the floating point type.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void twoprod(const Packet& x_hi, const Packet& x_lo,
+             const Packet& y_hi, const Packet& y_lo,
+             Packet& p_hi, Packet& p_lo) {
+  Packet p_hi_hi, p_hi_lo;
+  twoprod(x_hi, x_lo, y_hi, p_hi_hi, p_hi_lo);
+  Packet p_lo_hi, p_lo_lo;
+  twoprod(x_hi, x_lo, y_lo, p_lo_hi, p_lo_lo);
+  fast_twosum(p_hi_hi, p_hi_lo, p_lo_hi, p_lo_lo, p_hi, p_lo);
+}
+
+// This function computes the reciprocal of a floating point number
+// with extra precision and returns the result as a double word.
+template <typename Packet>
+void doubleword_reciprocal(const Packet& x, Packet& recip_hi, Packet& recip_lo) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  // 1. Approximate the reciprocal as the reciprocal of the high order element.
+  Packet approx_recip = prsqrt(x);
+  approx_recip = pmul(approx_recip, approx_recip);
+
+  // 2. Run one step of Newton-Raphson iteration in double word arithmetic
+  // to get the bottom half. The NR iteration for reciprocal of 'a' is
+  //    x_{i+1} = x_i * (2 - a * x_i)
+
+  // -a*x_i
+  Packet t1_hi, t1_lo;
+  twoprod(pnegate(x), approx_recip, t1_hi, t1_lo);
+  // 2 - a*x_i
+  Packet t2_hi, t2_lo;
+  fast_twosum(pset1<Packet>(Scalar(2)), t1_hi, t2_hi, t2_lo);
+  Packet t3_hi, t3_lo;
+  fast_twosum(t2_hi, padd(t2_lo, t1_lo), t3_hi, t3_lo);
+  // x_i * (2 - a * x_i)
+  twoprod(t3_hi, t3_lo, approx_recip, recip_hi, recip_lo);
+}
+
+
+// This function computes log2(x) and returns the result as a double word.
+template <typename Scalar>
+struct accurate_log2 {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  void operator()(const Packet& x, Packet& log2_x_hi, Packet& log2_x_lo) {
+    log2_x_hi = plog2(x);
+    log2_x_lo = pzero(x);
+  }
+};
+
+// This specialization uses a more accurate algorithm to compute log2(x) for
+// floats in [1/sqrt(2);sqrt(2)] with a relative accuracy of ~6.42e-10.
+// This additional accuracy is needed to counter the error-magnification
+// inherent in multiplying by a potentially large exponent in pow(x,y).
+// The minimax polynomial used was calculated using the Sollya tool.
+// See sollya.org.
+template <>
+struct accurate_log2<float> {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  void operator()(const Packet& z, Packet& log2_x_hi, Packet& log2_x_lo) {
+    // The function log(1+x)/x is approximated in the interval
+    // [1/sqrt(2)-1;sqrt(2)-1] by a degree 10 polynomial of the form
+    //  Q(x) = (C0 + x * (C1 + x * (C2 + x * (C3 + x * P(x))))),
+    // where the degree 6 polynomial P(x) is evaluated in single precision,
+    // while the remaining 4 terms of Q(x), as well as the final multiplication by x
+    // to reconstruct log(1+x) are evaluated in extra precision using
+    // double word arithmetic. C0 through C3 are extra precise constants
+    // stored as double words.
+    //
+    // The polynomial coefficients were calculated using Sollya commands:
+    // > n = 10;
+    // > f = log2(1+x)/x;
+    // > interval = [sqrt(0.5)-1;sqrt(2)-1];
+    // > p = fpminimax(f,n,[|double,double,double,double,single...|],interval,relative,floating);
+    
+    const Packet p6 = pset1<Packet>( 9.703654795885e-2f);
+    const Packet p5 = pset1<Packet>(-0.1690667718648f);
+    const Packet p4 = pset1<Packet>( 0.1720575392246f);
+    const Packet p3 = pset1<Packet>(-0.1789081543684f);
+    const Packet p2 = pset1<Packet>( 0.2050433009862f);
+    const Packet p1 = pset1<Packet>(-0.2404672354459f);
+    const Packet p0 = pset1<Packet>( 0.2885761857032f);
+
+    const Packet C3_hi = pset1<Packet>(-0.360674142838f);
+    const Packet C3_lo = pset1<Packet>(-6.13283912543e-09f);
+    const Packet C2_hi = pset1<Packet>(0.480897903442f);
+    const Packet C2_lo = pset1<Packet>(-1.44861207474e-08f);
+    const Packet C1_hi = pset1<Packet>(-0.721347510815f);
+    const Packet C1_lo = pset1<Packet>(-4.84483164698e-09f);
+    const Packet C0_hi = pset1<Packet>(1.44269502163f);
+    const Packet C0_lo = pset1<Packet>(2.01711713999e-08f);
+    const Packet one = pset1<Packet>(1.0f);
+
+    const Packet x = psub(z, one);
+    // Evaluate P(x) in working precision.
+    // We evaluate it in multiple parts to improve instruction level
+    // parallelism.
+    Packet x2 = pmul(x,x);
+    Packet p_even = pmadd(p6, x2, p4);
+    p_even = pmadd(p_even, x2, p2);
+    p_even = pmadd(p_even, x2, p0);
+    Packet p_odd = pmadd(p5, x2, p3);
+    p_odd = pmadd(p_odd, x2, p1);
+    Packet p = pmadd(p_odd, x, p_even);
+
+    // Now evaluate the low-order tems of Q(x) in double word precision.
+    // In the following, due to the alternating signs and the fact that
+    // |x| < sqrt(2)-1, we can assume that |C*_hi| >= q_i, and use
+    // fast_twosum instead of the slower twosum.
+    Packet q_hi, q_lo;
+    Packet t_hi, t_lo;
+    // C3 + x * p(x)
+    twoprod(p, x, t_hi, t_lo);
+    fast_twosum(C3_hi, C3_lo, t_hi, t_lo, q_hi, q_lo);
+    // C2 + x * p(x)
+    twoprod(q_hi, q_lo, x, t_hi, t_lo);
+    fast_twosum(C2_hi, C2_lo, t_hi, t_lo, q_hi, q_lo);
+    // C1 + x * p(x)
+    twoprod(q_hi, q_lo, x, t_hi, t_lo);
+    fast_twosum(C1_hi, C1_lo, t_hi, t_lo, q_hi, q_lo);
+    // C0 + x * p(x)
+    twoprod(q_hi, q_lo, x, t_hi, t_lo);
+    fast_twosum(C0_hi, C0_lo, t_hi, t_lo, q_hi, q_lo);
+
+    // log(z) ~= x * Q(x)
+    twoprod(q_hi, q_lo, x, log2_x_hi, log2_x_lo);
+  }
+};
+
+// This specialization uses a more accurate algorithm to compute log2(x) for
+// floats in [1/sqrt(2);sqrt(2)] with a relative accuracy of ~1.27e-18.
+// This additional accuracy is needed to counter the error-magnification
+// inherent in multiplying by a potentially large exponent in pow(x,y).
+// The minimax polynomial used was calculated using the Sollya tool.
+// See sollya.org.
+
+template <>
+struct accurate_log2<double> {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  void operator()(const Packet& x, Packet& log2_x_hi, Packet& log2_x_lo) {
+    // We use a transformation of variables:
+    //    r = c * (x-1) / (x+1),
+    // such that
+    //    log2(x) = log2((1 + r/c) / (1 - r/c)) = f(r).
+    // The function f(r) can be approximated well using an odd polynomial
+    // of the form
+    //   P(r) = ((Q(r^2) * r^2 + C) * r^2 + 1) * r,
+    // For the implementation of log2<double> here, Q is of degree 6 with
+    // coefficient represented in working precision (double), while C is a
+    // constant represented in extra precision as a double word to achieve
+    // full accuracy.
+    //
+    // The polynomial coefficients were computed by the Sollya script:
+    //
+    // c = 2 / log(2);
+    // trans = c * (x-1)/(x+1);
+    // itrans = (1+x/c)/(1-x/c);
+    // interval=[trans(sqrt(0.5)); trans(sqrt(2))];
+    // print(interval);
+    // f = log2(itrans(x));
+    // p=fpminimax(f,[|1,3,5,7,9,11,13,15,17|],[|1,DD,double...|],interval,relative,floating);
+    const Packet q12 = pset1<Packet>(2.87074255468000586e-9);
+    const Packet q10 = pset1<Packet>(2.38957980901884082e-8);
+    const Packet q8 = pset1<Packet>(2.31032094540014656e-7);
+    const Packet q6 = pset1<Packet>(2.27279857398537278e-6);
+    const Packet q4 = pset1<Packet>(2.31271023278625638e-5);
+    const Packet q2 = pset1<Packet>(2.47556738444535513e-4);
+    const Packet q0 = pset1<Packet>(2.88543873228900172e-3);
+    const Packet C_hi = pset1<Packet>(0.0400377511598501157);
+    const Packet C_lo = pset1<Packet>(-4.77726582251425391e-19);
+    const Packet one = pset1<Packet>(1.0);
+
+    const Packet cst_2_log2e_hi = pset1<Packet>(2.88539008177792677);
+    const Packet cst_2_log2e_lo = pset1<Packet>(4.07660016854549667e-17);
+    // c * (x - 1)
+    Packet num_hi, num_lo;
+    twoprod(cst_2_log2e_hi, cst_2_log2e_lo, psub(x, one), num_hi, num_lo);
+    // TODO(rmlarsen): Investigate if using the division algorithm by
+    // Muller et al. is faster/more accurate.
+    // 1 / (x + 1)
+    Packet denom_hi, denom_lo;
+    doubleword_reciprocal(padd(x, one), denom_hi, denom_lo);
+    // r =  c * (x-1) / (x+1),
+    Packet r_hi, r_lo;
+    twoprod(num_hi, num_lo, denom_hi, denom_lo, r_hi, r_lo);
+    // r2 = r * r
+    Packet r2_hi, r2_lo;
+    twoprod(r_hi, r_lo, r_hi, r_lo, r2_hi, r2_lo);
+    // r4 = r2 * r2
+    Packet r4_hi, r4_lo;
+    twoprod(r2_hi, r2_lo, r2_hi, r2_lo, r4_hi, r4_lo);
+
+    // Evaluate Q(r^2) in working precision. We evaluate it in two parts
+    // (even and odd in r^2) to improve instruction level parallelism.
+    Packet q_even = pmadd(q12, r4_hi, q8);
+    Packet q_odd = pmadd(q10, r4_hi, q6);
+    q_even = pmadd(q_even, r4_hi, q4);
+    q_odd = pmadd(q_odd, r4_hi, q2);
+    q_even = pmadd(q_even, r4_hi, q0);
+    Packet q = pmadd(q_odd, r2_hi, q_even);
+
+    // Now evaluate the low order terms of P(x) in double word precision.
+    // In the following, due to the increasing magnitude of the coefficients
+    // and r being constrained to [-0.5, 0.5] we can use fast_twosum instead
+    // of the slower twosum.
+    // Q(r^2) * r^2
+    Packet p_hi, p_lo;
+    twoprod(r2_hi, r2_lo, q, p_hi, p_lo);
+    // Q(r^2) * r^2 + C
+    Packet p1_hi, p1_lo;
+    fast_twosum(C_hi, C_lo, p_hi, p_lo, p1_hi, p1_lo);
+    // (Q(r^2) * r^2 + C) * r^2
+    Packet p2_hi, p2_lo;
+    twoprod(r2_hi, r2_lo, p1_hi, p1_lo, p2_hi, p2_lo);
+    // ((Q(r^2) * r^2 + C) * r^2 + 1)
+    Packet p3_hi, p3_lo;
+    fast_twosum(one, p2_hi, p2_lo, p3_hi, p3_lo);
+
+    // log(z) ~= ((Q(r^2) * r^2 + C) * r^2 + 1) * r
+    twoprod(p3_hi, p3_lo, r_hi, r_lo, log2_x_hi, log2_x_lo);
+  }
+};
+
+// This function computes exp2(x) (i.e. 2**x).
+template <typename Scalar>
+struct fast_accurate_exp2 {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  Packet operator()(const Packet& x) {
+    // TODO(rmlarsen): Add a pexp2 packetop.
+    return pexp(pmul(pset1<Packet>(Scalar(EIGEN_LN2)), x));
+  }
+};
+
+// This specialization uses a faster algorithm to compute exp2(x) for floats
+// in [-0.5;0.5] with a relative accuracy of 1 ulp.
+// The minimax polynomial used was calculated using the Sollya tool.
+// See sollya.org.
+template <>
+struct fast_accurate_exp2<float> {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  Packet operator()(const Packet& x) {
+    // This function approximates exp2(x) by a degree 6 polynomial of the form
+    // Q(x) = 1 + x * (C + x * P(x)), where the degree 4 polynomial P(x) is evaluated in
+    // single precision, and the remaining steps are evaluated with extra precision using
+    // double word arithmetic. C is an extra precise constant stored as a double word.
+    //
+    // The polynomial coefficients were calculated using Sollya commands:
+    // > n = 6;
+    // > f = 2^x;
+    // > interval = [-0.5;0.5];
+    // > p = fpminimax(f,n,[|1,double,single...|],interval,relative,floating);
+
+    const Packet p4 = pset1<Packet>(1.539513905e-4f);
+    const Packet p3 = pset1<Packet>(1.340007293e-3f);
+    const Packet p2 = pset1<Packet>(9.618283249e-3f);
+    const Packet p1 = pset1<Packet>(5.550328270e-2f);
+    const Packet p0 = pset1<Packet>(0.2402264923f);
+
+    const Packet C_hi = pset1<Packet>(0.6931471825f);
+    const Packet C_lo = pset1<Packet>(2.36836577e-08f);
+    const Packet one = pset1<Packet>(1.0f);
+
+    // Evaluate P(x) in working precision.
+    // We evaluate even and odd parts of the polynomial separately
+    // to gain some instruction level parallelism.
+    Packet x2 = pmul(x,x);
+    Packet p_even = pmadd(p4, x2, p2);
+    Packet p_odd = pmadd(p3, x2, p1);
+    p_even = pmadd(p_even, x2, p0);
+    Packet p = pmadd(p_odd, x, p_even);
+
+    // Evaluate the remaining terms of Q(x) with extra precision using
+    // double word arithmetic.
+    Packet p_hi, p_lo;
+    // x * p(x)
+    twoprod(p, x, p_hi, p_lo);
+    // C + x * p(x)
+    Packet q1_hi, q1_lo;
+    twosum(p_hi, p_lo, C_hi, C_lo, q1_hi, q1_lo);
+    // x * (C + x * p(x))
+    Packet q2_hi, q2_lo;
+    twoprod(q1_hi, q1_lo, x, q2_hi, q2_lo);
+    // 1 + x * (C + x * p(x))
+    Packet q3_hi, q3_lo;
+    // Since |q2_hi| <= sqrt(2)-1 < 1, we can use fast_twosum
+    // for adding it to unity here.
+    fast_twosum(one, q2_hi, q3_hi, q3_lo);
+    return padd(q3_hi, padd(q2_lo, q3_lo));
+  }
+};
+
+// in [-0.5;0.5] with a relative accuracy of 1 ulp.
+// The minimax polynomial used was calculated using the Sollya tool.
+// See sollya.org.
+template <>
+struct fast_accurate_exp2<double> {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  Packet operator()(const Packet& x) {
+    // This function approximates exp2(x) by a degree 10 polynomial of the form
+    // Q(x) = 1 + x * (C + x * P(x)), where the degree 8 polynomial P(x) is evaluated in
+    // single precision, and the remaining steps are evaluated with extra precision using
+    // double word arithmetic. C is an extra precise constant stored as a double word.
+    //
+    // The polynomial coefficients were calculated using Sollya commands:
+    // > n = 11;
+    // > f = 2^x;
+    // > interval = [-0.5;0.5];
+    // > p = fpminimax(f,n,[|1,DD,double...|],interval,relative,floating);
+
+    const Packet p9 = pset1<Packet>(4.431642109085495276e-10);
+    const Packet p8 = pset1<Packet>(7.073829923303358410e-9);
+    const Packet p7 = pset1<Packet>(1.017822306737031311e-7);
+    const Packet p6 = pset1<Packet>(1.321543498017646657e-6);
+    const Packet p5 = pset1<Packet>(1.525273342728892877e-5);
+    const Packet p4 = pset1<Packet>(1.540353045780084423e-4);
+    const Packet p3 = pset1<Packet>(1.333355814685869807e-3);
+    const Packet p2 = pset1<Packet>(9.618129107593478832e-3);
+    const Packet p1 = pset1<Packet>(5.550410866481961247e-2);
+    const Packet p0 = pset1<Packet>(0.240226506959101332);
+    const Packet C_hi = pset1<Packet>(0.693147180559945286); 
+    const Packet C_lo = pset1<Packet>(4.81927865669806721e-17);
+    const Packet one = pset1<Packet>(1.0);
+
+    // Evaluate P(x) in working precision.
+    // We evaluate even and odd parts of the polynomial separately
+    // to gain some instruction level parallelism.
+    Packet x2 = pmul(x,x);
+    Packet p_even = pmadd(p8, x2, p6);
+    Packet p_odd = pmadd(p9, x2, p7);
+    p_even = pmadd(p_even, x2, p4);
+    p_odd = pmadd(p_odd, x2, p5);
+    p_even = pmadd(p_even, x2, p2);
+    p_odd = pmadd(p_odd, x2, p3);
+    p_even = pmadd(p_even, x2, p0);
+    p_odd = pmadd(p_odd, x2, p1);
+    Packet p = pmadd(p_odd, x, p_even);
+
+    // Evaluate the remaining terms of Q(x) with extra precision using
+    // double word arithmetic.
+    Packet p_hi, p_lo;
+    // x * p(x)
+    twoprod(p, x, p_hi, p_lo);
+    // C + x * p(x)
+    Packet q1_hi, q1_lo;
+    twosum(p_hi, p_lo, C_hi, C_lo, q1_hi, q1_lo);
+    // x * (C + x * p(x))
+    Packet q2_hi, q2_lo;
+    twoprod(q1_hi, q1_lo, x, q2_hi, q2_lo);
+    // 1 + x * (C + x * p(x))
+    Packet q3_hi, q3_lo;
+    // Since |q2_hi| <= sqrt(2)-1 < 1, we can use fast_twosum
+    // for adding it to unity here.
+    fast_twosum(one, q2_hi, q3_hi, q3_lo);
+    return padd(q3_hi, padd(q2_lo, q3_lo));
+  }
+};
+
+// This function implements the non-trivial case of pow(x,y) where x is
+// positive and y is (possibly) non-integer.
+// Formally, pow(x,y) = exp2(y * log2(x)), where exp2(x) is shorthand for 2^x.
+// TODO(rmlarsen): We should probably add this as a packet up 'ppow', to make it
+// easier to specialize or turn off for specific types and/or backends.x
+template <typename Packet>
+EIGEN_STRONG_INLINE Packet generic_pow_impl(const Packet& x, const Packet& y) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  // Split x into exponent e_x and mantissa m_x.
+  Packet e_x;
+  Packet m_x = pfrexp(x, e_x);
+
+  // Adjust m_x to lie in [1/sqrt(2):sqrt(2)] to minimize absolute error in log2(m_x).
+  EIGEN_CONSTEXPR Scalar sqrt_half = Scalar(0.70710678118654752440);
+  const Packet m_x_scale_mask = pcmp_lt(m_x, pset1<Packet>(sqrt_half));
+  m_x = pselect(m_x_scale_mask, pmul(pset1<Packet>(Scalar(2)), m_x), m_x);
+  e_x = pselect(m_x_scale_mask, psub(e_x, pset1<Packet>(Scalar(1))), e_x);
+
+  // Compute log2(m_x) with 6 extra bits of accuracy.
+  Packet rx_hi, rx_lo;
+  accurate_log2<Scalar>()(m_x, rx_hi, rx_lo);
+
+  // Compute the two terms {y * e_x, y * r_x} in f = y * log2(x) with doubled
+  // precision using double word arithmetic.
+  Packet f1_hi, f1_lo, f2_hi, f2_lo;
+  twoprod(e_x, y, f1_hi, f1_lo);
+  twoprod(rx_hi, rx_lo, y, f2_hi, f2_lo);
+  // Sum the two terms in f using double word arithmetic. We know
+  // that |e_x| > |log2(m_x)|, except for the case where e_x==0.
+  // This means that we can use fast_twosum(f1,f2).
+  // In the case e_x == 0, e_x * y = f1 = 0, so we don't lose any
+  // accuracy by violating the assumption of fast_twosum, because
+  // it's a no-op.
+  Packet f_hi, f_lo;
+  fast_twosum(f1_hi, f1_lo, f2_hi, f2_lo, f_hi, f_lo);
+
+  // Split f into integer and fractional parts.
+  Packet n_z, r_z;
+  absolute_split(f_hi, n_z, r_z);
+  r_z = padd(r_z, f_lo);
+  Packet n_r;
+  absolute_split(r_z, n_r, r_z);
+  n_z = padd(n_z, n_r);
+
+  // We now have an accurate split of f = n_z + r_z and can compute
+  //   x^y = 2**{n_z + r_z) = exp2(r_z) * 2**{n_z}.
+  // Since r_z is in [-0.5;0.5], we compute the first factor to high accuracy
+  // using a specialized algorithm. Multiplication by the second factor can
+  // be done exactly using pldexp(), since it is an integer power of 2.
+  const Packet e_r = fast_accurate_exp2<Scalar>()(r_z);
+  return pldexp(e_r, n_z);
+}
+
+// Generic implementation of pow(x,y).
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet generic_pow(const Packet& x, const Packet& y) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+
+  const Packet cst_pos_inf = pset1<Packet>(NumTraits<Scalar>::infinity());
+  const Packet cst_zero = pset1<Packet>(Scalar(0));
+  const Packet cst_one = pset1<Packet>(Scalar(1));
+  const Packet cst_nan = pset1<Packet>(NumTraits<Scalar>::quiet_NaN());
+
+  const Packet abs_x = pabs(x);
+  // Predicates for sign and magnitude of x.
+  const Packet x_is_zero = pcmp_eq(x, cst_zero);
+  const Packet x_is_neg = pcmp_lt(x, cst_zero);
+  const Packet abs_x_is_inf = pcmp_eq(abs_x, cst_pos_inf);
+  const Packet abs_x_is_one =  pcmp_eq(abs_x, cst_one);
+  const Packet abs_x_is_gt_one = pcmp_lt(cst_one, abs_x);
+  const Packet abs_x_is_lt_one = pcmp_lt(abs_x, cst_one);
+  const Packet x_is_one =  pandnot(abs_x_is_one, x_is_neg);
+  const Packet x_is_neg_one =  pand(abs_x_is_one, x_is_neg);
+  const Packet x_is_nan = pandnot(ptrue(x), pcmp_eq(x, x));
+
+  // Predicates for sign and magnitude of y.
+  const Packet y_is_one = pcmp_eq(y, cst_one);
+  const Packet y_is_zero = pcmp_eq(y, cst_zero);
+  const Packet y_is_neg = pcmp_lt(y, cst_zero);
+  const Packet y_is_pos = pandnot(ptrue(y), por(y_is_zero, y_is_neg));
+  const Packet y_is_nan = pandnot(ptrue(y), pcmp_eq(y, y));
+  const Packet abs_y_is_inf = pcmp_eq(pabs(y), cst_pos_inf);
+  EIGEN_CONSTEXPR Scalar huge_exponent =
+      (NumTraits<Scalar>::max_exponent() * Scalar(EIGEN_LN2)) /
+       NumTraits<Scalar>::epsilon();
+  const Packet abs_y_is_huge = pcmp_le(pset1<Packet>(huge_exponent), pabs(y));
+
+  // Predicates for whether y is integer and/or even.
+  const Packet y_is_int = pcmp_eq(pfloor(y), y);
+  const Packet y_div_2 = pmul(y, pset1<Packet>(Scalar(0.5)));
+  const Packet y_is_even = pcmp_eq(pround(y_div_2), y_div_2);
+
+  // Predicates encoding special cases for the value of pow(x,y)
+  const Packet invalid_negative_x = pandnot(pandnot(pandnot(x_is_neg, abs_x_is_inf),
+                                                    y_is_int),
+                                            abs_y_is_inf);
+  const Packet pow_is_one = por(por(x_is_one, y_is_zero),
+                                pand(x_is_neg_one,
+                                     por(abs_y_is_inf, pandnot(y_is_even, invalid_negative_x))));
+  const Packet pow_is_nan = por(invalid_negative_x, por(x_is_nan, y_is_nan));
+  const Packet pow_is_zero = por(por(por(pand(x_is_zero, y_is_pos),
+                                         pand(abs_x_is_inf, y_is_neg)),
+                                     pand(pand(abs_x_is_lt_one, abs_y_is_huge),
+                                          y_is_pos)),
+                                 pand(pand(abs_x_is_gt_one, abs_y_is_huge),
+                                      y_is_neg));
+  const Packet pow_is_inf = por(por(por(pand(x_is_zero, y_is_neg),
+                                        pand(abs_x_is_inf, y_is_pos)),
+                                    pand(pand(abs_x_is_lt_one, abs_y_is_huge),
+                                         y_is_neg)),
+                                pand(pand(abs_x_is_gt_one, abs_y_is_huge),
+                                     y_is_pos));
+
+  // General computation of pow(x,y) for positive x or negative x and integer y.
+  const Packet negate_pow_abs = pandnot(x_is_neg, y_is_even);
+  const Packet pow_abs = generic_pow_impl(abs_x, y);
+  return pselect(y_is_one, x,
+                 pselect(pow_is_one, cst_one,
+                         pselect(pow_is_nan, cst_nan,
+                                 pselect(pow_is_inf, cst_pos_inf,
+                                         pselect(pow_is_zero, cst_zero,
+                                                 pselect(negate_pow_abs, pnegate(pow_abs), pow_abs))))));
+}
+
+
+
+/* polevl (modified for Eigen)
+ *
+ *      Evaluate polynomial
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * int N;
+ * Scalar x, y, coef[N+1];
+ *
+ * y = polevl<decltype(x), N>( x, coef);
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Evaluates polynomial of degree N:
+ *
+ *                     2          N
+ * y  =  C  + C x + C x  +...+ C x
+ *        0    1     2          N
+ *
+ * Coefficients are stored in reverse order:
+ *
+ * coef[0] = C  , ..., coef[N] = C  .
+ *            N                   0
+ *
+ *  The function p1evl() assumes that coef[N] = 1.0 and is
+ * omitted from the array.  Its calling arguments are
+ * otherwise the same as polevl().
+ *
+ *
+ * The Eigen implementation is templatized.  For best speed, store
+ * coef as a const array (constexpr), e.g.
+ *
+ * const double coef[] = {1.0, 2.0, 3.0, ...};
+ *
+ */
+template <typename Packet, int N>
+struct ppolevl {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& x, const typename unpacket_traits<Packet>::type coeff[]) {
+    EIGEN_STATIC_ASSERT((N > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return pmadd(ppolevl<Packet, N-1>::run(x, coeff), x, pset1<Packet>(coeff[N]));
+  }
+};
+
+template <typename Packet>
+struct ppolevl<Packet, 0> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& x, const typename unpacket_traits<Packet>::type coeff[]) {
+    EIGEN_UNUSED_VARIABLE(x);
+    return pset1<Packet>(coeff[0]);
+  }
+};
+
+/* chbevl (modified for Eigen)
+ *
+ *     Evaluate Chebyshev series
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * int N;
+ * Scalar x, y, coef[N], chebevl();
+ *
+ * y = chbevl( x, coef, N );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Evaluates the series
+ *
+ *        N-1
+ *         - '
+ *  y  =   >   coef[i] T (x/2)
+ *         -            i
+ *        i=0
+ *
+ * of Chebyshev polynomials Ti at argument x/2.
+ *
+ * Coefficients are stored in reverse order, i.e. the zero
+ * order term is last in the array.  Note N is the number of
+ * coefficients, not the order.
+ *
+ * If coefficients are for the interval a to b, x must
+ * have been transformed to x -> 2(2x - b - a)/(b-a) before
+ * entering the routine.  This maps x from (a, b) to (-1, 1),
+ * over which the Chebyshev polynomials are defined.
+ *
+ * If the coefficients are for the inverted interval, in
+ * which (a, b) is mapped to (1/b, 1/a), the transformation
+ * required is x -> 2(2ab/x - b - a)/(b-a).  If b is infinity,
+ * this becomes x -> 4a/x - 1.
+ *
+ *
+ *
+ * SPEED:
+ *
+ * Taking advantage of the recurrence properties of the
+ * Chebyshev polynomials, the routine requires one more
+ * addition per loop than evaluating a nested polynomial of
+ * the same degree.
+ *
+ */
+
+template <typename Packet, int N>
+struct pchebevl {
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Packet run(Packet x, const typename unpacket_traits<Packet>::type coef[]) {
+    typedef typename unpacket_traits<Packet>::type Scalar;
+    Packet b0 = pset1<Packet>(coef[0]);
+    Packet b1 = pset1<Packet>(static_cast<Scalar>(0.f));
+    Packet b2;
+
+    for (int i = 1; i < N; i++) {
+      b2 = b1;
+      b1 = b0;
+      b0 = psub(pmadd(x, b1, pset1<Packet>(coef[i])), b2);
+    }
+
+    return pmul(pset1<Packet>(static_cast<Scalar>(0.5f)), psub(b0, b2));
+  }
+};
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
new file mode 100644
index 00000000..177a04e9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
@@ -0,0 +1,110 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2019 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_FWD_H
+#define EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_FWD_H
+
+namespace Eigen {
+namespace internal {
+
+// Forward declarations of the generic math functions
+// implemented in GenericPacketMathFunctions.h
+// This is needed to workaround a circular dependency.
+
+/***************************************************************************
+ * Some generic implementations to be used by implementors
+***************************************************************************/
+
+/** Default implementation of pfrexp.
+  * It is expected to be called by implementers of template<> pfrexp.
+  */
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+Packet pfrexp_generic(const Packet& a, Packet& exponent);
+
+// Extracts the biased exponent value from Packet p, and casts the results to
+// a floating-point Packet type. Used by pfrexp_generic. Override this if
+// there is no unpacket_traits<Packet>::integer_packet.
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+Packet pfrexp_generic_get_biased_exponent(const Packet& p);
+
+/** Default implementation of pldexp.
+  * It is expected to be called by implementers of template<> pldexp.
+  */
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+Packet pldexp_generic(const Packet& a, const Packet& exponent);
+
+/** \internal \returns log(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_float(const Packet _x);
+
+/** \internal \returns log2(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog2_float(const Packet _x);
+
+/** \internal \returns log(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_double(const Packet _x);
+
+/** \internal \returns log2(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog2_double(const Packet _x);
+
+/** \internal \returns log(1 + x) */
+template<typename Packet>
+Packet generic_plog1p(const Packet& x);
+
+/** \internal \returns exp(x)-1 */
+template<typename Packet>
+Packet generic_expm1(const Packet& x);
+
+/** \internal \returns exp(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pexp_float(const Packet _x);
+
+/** \internal \returns exp(x) for double precision real numbers */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pexp_double(const Packet _x);
+
+/** \internal \returns sin(x) for single precision float */
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet psin_float(const Packet& x);
+
+/** \internal \returns cos(x) for single precision float */
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pcos_float(const Packet& x);
+
+/** \internal \returns sqrt(x) for complex types */
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet psqrt_complex(const Packet& a);
+
+template <typename Packet, int N> struct ppolevl;
+
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_FWD_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/Half.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/Half.h
new file mode 100644
index 00000000..9f8e8cc1
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/Half.h
@@ -0,0 +1,942 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// The conversion routines are Copyright (c) Fabian Giesen, 2016.
+// The original license follows:
+//
+// Copyright (c) Fabian Giesen, 2016
+// All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted.
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Standard 16-bit float type, mostly useful for GPUs. Defines a new
+// type Eigen::half (inheriting either from CUDA's or HIP's __half struct) with
+// operator overloads such that it behaves basically as an arithmetic
+// type. It will be quite slow on CPUs (so it is recommended to stay
+// in fp32 for CPUs, except for simple parameter conversions, I/O
+// to disk and the likes), but fast on GPUs.
+
+
+#ifndef EIGEN_HALF_H
+#define EIGEN_HALF_H
+
+#include <sstream>
+
+#if defined(EIGEN_HAS_GPU_FP16) || defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+// When compiling with GPU support, the "__half_raw" base class as well as
+// some other routines are defined in the GPU compiler header files
+// (cuda_fp16.h, hip_fp16.h), and they are not tagged constexpr
+// As a consequence, we get compile failures when compiling Eigen with
+// GPU support. Hence the need to disable EIGEN_CONSTEXPR when building
+// Eigen with GPU support
+  #pragma push_macro("EIGEN_CONSTEXPR")
+  #undef EIGEN_CONSTEXPR
+  #define EIGEN_CONSTEXPR
+#endif
+
+#define F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, METHOD)           \
+  template <>                                                       \
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_UNUSED                \
+  PACKET_F16 METHOD<PACKET_F16>(const PACKET_F16& _x) {             \
+    return float2half(METHOD<PACKET_F>(half2float(_x)));            \
+  }
+
+namespace Eigen {
+
+struct half;
+
+namespace half_impl {
+
+// We want to use the __half_raw struct from the HIP header file only during the device compile phase.
+// This is required because of a quirk in the way TensorFlow GPU builds are done.
+// When compiling TensorFlow source code with GPU support, files that
+//  * contain GPU kernels (i.e. *.cu.cc files) are compiled via hipcc
+//  * do not contain GPU kernels ( i.e. *.cc files) are compiled via gcc (typically)
+//
+// Tensorflow uses the Eigen::half type as its FP16 type, and there are functions that
+//  * are defined in a file that gets compiled via hipcc AND
+//  * have Eigen::half as a pass-by-value argument AND
+//  * are called in a file that gets compiled via gcc
+//
+// In the scenario described above the caller and callee will see different versions
+// of the Eigen::half base class __half_raw, and they will be compiled by different compilers
+//
+// There appears to be an ABI mismatch between gcc and clang (which is called by hipcc) that results in
+// the callee getting corrupted values for the Eigen::half argument.
+//
+// Making the host side compile phase of hipcc use the same Eigen::half impl, as the gcc compile, resolves
+// this error, and hence the following convoluted #if condition
+#if !defined(EIGEN_HAS_GPU_FP16) || !defined(EIGEN_GPU_COMPILE_PHASE)
+// Make our own __half_raw definition that is similar to CUDA's.
+struct __half_raw {
+#if (defined(EIGEN_HAS_GPU_FP16) && !defined(EIGEN_GPU_COMPILE_PHASE))
+  // Eigen::half can be used as the datatype for shared memory declarations (in Eigen and TF)
+  // The element type for shared memory cannot have non-trivial constructors
+  // and hence the following special casing (which skips the zero-initilization).
+  // Note that this check gets done even in the host compilation phase, and
+  // hence the need for this
+  EIGEN_DEVICE_FUNC __half_raw() {}
+#else
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw() : x(0) {}
+#endif
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw(numext::uint16_t raw) : x(numext::bit_cast<__fp16>(raw)) {
+  }
+  __fp16 x;
+#else
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw(numext::uint16_t raw) : x(raw) {}
+  numext::uint16_t x;
+#endif
+};
+
+#elif defined(EIGEN_HAS_HIP_FP16)
+  // Nothing to do here
+  // HIP fp16 header file has a definition for __half_raw
+#elif defined(EIGEN_HAS_CUDA_FP16)
+  #if EIGEN_CUDA_SDK_VER < 90000
+    // In CUDA < 9.0, __half is the equivalent of CUDA 9's __half_raw
+    typedef __half __half_raw;
+  #endif // defined(EIGEN_HAS_CUDA_FP16)
+#elif defined(SYCL_DEVICE_ONLY)
+  typedef cl::sycl::half __half_raw;
+#endif
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw raw_uint16_to_half(numext::uint16_t x);
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(float ff);
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float half_to_float(__half_raw h);
+
+struct half_base : public __half_raw {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half_base() {}
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half_base(const __half_raw& h) : __half_raw(h) {}
+
+#if defined(EIGEN_HAS_GPU_FP16)
+ #if defined(EIGEN_HAS_HIP_FP16)
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half_base(const __half& h) { x = __half_as_ushort(h); }
+ #elif defined(EIGEN_HAS_CUDA_FP16)
+  #if EIGEN_CUDA_SDK_VER >= 90000
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half_base(const __half& h) : __half_raw(*(__half_raw*)&h) {}
+  #endif
+ #endif
+#endif
+};
+
+} // namespace half_impl
+
+// Class definition.
+struct half : public half_impl::half_base {
+
+  // Writing this out as separate #if-else blocks to make the code easier to follow
+  // The same applies to most #if-else blocks in this file
+#if !defined(EIGEN_HAS_GPU_FP16) || !defined(EIGEN_GPU_COMPILE_PHASE)
+  // Use the same base class for the following two scenarios
+  // * when compiling without GPU support enabled
+  // * during host compile phase when compiling with GPU support enabled
+  typedef half_impl::__half_raw __half_raw;
+#elif defined(EIGEN_HAS_HIP_FP16)
+  // Nothing to do here
+  // HIP fp16 header file has a definition for __half_raw
+#elif defined(EIGEN_HAS_CUDA_FP16)
+  // Note that EIGEN_CUDA_SDK_VER is set to 0 even when compiling with HIP, so
+  // (EIGEN_CUDA_SDK_VER < 90000) is true even for HIP!  So keeping this within
+  // #if defined(EIGEN_HAS_CUDA_FP16) is needed
+  #if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000
+    typedef half_impl::__half_raw __half_raw;
+  #endif
+#endif
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half(const __half_raw& h) : half_impl::half_base(h) {}
+
+#if defined(EIGEN_HAS_GPU_FP16)
+ #if defined(EIGEN_HAS_HIP_FP16)
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half(const __half& h) : half_impl::half_base(h) {}
+ #elif defined(EIGEN_HAS_CUDA_FP16)
+  #if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER >= 90000
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half(const __half& h) : half_impl::half_base(h) {}
+  #endif
+ #endif
+#endif
+
+
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half(bool b)
+      : half_impl::half_base(half_impl::raw_uint16_to_half(b ? 0x3c00 : 0)) {}
+  template<class T>
+  explicit EIGEN_DEVICE_FUNC half(T val)
+      : half_impl::half_base(half_impl::float_to_half_rtne(static_cast<float>(val))) {}
+  explicit EIGEN_DEVICE_FUNC half(float f)
+      : half_impl::half_base(half_impl::float_to_half_rtne(f)) {}
+
+  // Following the convention of numpy, converting between complex and
+  // float will lead to loss of imag value.
+  template<typename RealScalar>
+  explicit EIGEN_DEVICE_FUNC half(std::complex<RealScalar> c)
+      : half_impl::half_base(half_impl::float_to_half_rtne(static_cast<float>(c.real()))) {}
+
+   EIGEN_DEVICE_FUNC operator float() const {  // NOLINT: Allow implicit conversion to float, because it is lossless.
+    return half_impl::half_to_float(*this);
+  }
+
+#if defined(EIGEN_HAS_GPU_FP16) && !defined(EIGEN_GPU_COMPILE_PHASE)
+  EIGEN_DEVICE_FUNC operator __half() const {
+    ::__half_raw hr;
+    hr.x = x;
+    return __half(hr);
+  }
+#endif
+};
+
+} // end namespace Eigen
+
+namespace std {
+template<>
+struct numeric_limits<Eigen::half> {
+  static const bool is_specialized = true;
+  static const bool is_signed = true;
+  static const bool is_integer = false;
+  static const bool is_exact = false;
+  static const bool has_infinity = true;
+  static const bool has_quiet_NaN = true;
+  static const bool has_signaling_NaN = true;
+  static const float_denorm_style has_denorm = denorm_present;
+  static const bool has_denorm_loss = false;
+  static const std::float_round_style round_style = std::round_to_nearest;
+  static const bool is_iec559 = false;
+  static const bool is_bounded = false;
+  static const bool is_modulo = false;
+  static const int digits = 11;
+  static const int digits10 = 3;      // according to http://half.sourceforge.net/structstd_1_1numeric__limits_3_01half__float_1_1half_01_4.html
+  static const int max_digits10 = 5;  // according to http://half.sourceforge.net/structstd_1_1numeric__limits_3_01half__float_1_1half_01_4.html
+  static const int radix = 2;
+  static const int min_exponent = -13;
+  static const int min_exponent10 = -4;
+  static const int max_exponent = 16;
+  static const int max_exponent10 = 4;
+  static const bool traps = true;
+  static const bool tinyness_before = false;
+
+  static Eigen::half (min)() { return Eigen::half_impl::raw_uint16_to_half(0x400); }
+  static Eigen::half lowest() { return Eigen::half_impl::raw_uint16_to_half(0xfbff); }
+  static Eigen::half (max)() { return Eigen::half_impl::raw_uint16_to_half(0x7bff); }
+  static Eigen::half epsilon() { return Eigen::half_impl::raw_uint16_to_half(0x0800); }
+  static Eigen::half round_error() { return Eigen::half(0.5); }
+  static Eigen::half infinity() { return Eigen::half_impl::raw_uint16_to_half(0x7c00); }
+  static Eigen::half quiet_NaN() { return Eigen::half_impl::raw_uint16_to_half(0x7e00); }
+  static Eigen::half signaling_NaN() { return Eigen::half_impl::raw_uint16_to_half(0x7d00); }
+  static Eigen::half denorm_min() { return Eigen::half_impl::raw_uint16_to_half(0x1); }
+};
+
+// If std::numeric_limits<T> is specialized, should also specialize
+// std::numeric_limits<const T>, std::numeric_limits<volatile T>, and
+// std::numeric_limits<const volatile T>
+// https://stackoverflow.com/a/16519653/
+template<>
+struct numeric_limits<const Eigen::half> : numeric_limits<Eigen::half> {};
+template<>
+struct numeric_limits<volatile Eigen::half> : numeric_limits<Eigen::half> {};
+template<>
+struct numeric_limits<const volatile Eigen::half> : numeric_limits<Eigen::half> {};
+} // end namespace std
+
+namespace Eigen {
+
+namespace half_impl {
+
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && \
+     EIGEN_CUDA_ARCH >= 530) ||                                  \
+    (defined(EIGEN_HAS_HIP_FP16) && defined(HIP_DEVICE_COMPILE))
+// Note: We deliberatly do *not* define this to 1 even if we have Arm's native
+// fp16 type since GPU halfs are rather different from native CPU halfs.
+// TODO: Rename to something like EIGEN_HAS_NATIVE_GPU_FP16
+#define EIGEN_HAS_NATIVE_FP16
+#endif
+
+// Intrinsics for native fp16 support. Note that on current hardware,
+// these are no faster than fp32 arithmetic (you need to use the half2
+// versions to get the ALU speed increased), but you do save the
+// conversion steps back and forth.
+
+#if defined(EIGEN_HAS_NATIVE_FP16)
+EIGEN_STRONG_INLINE __device__ half operator + (const half& a, const half& b) {
+#if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER >= 90000
+  return __hadd(::__half(a), ::__half(b));
+#else
+  return __hadd(a, b);
+#endif
+}
+EIGEN_STRONG_INLINE __device__ half operator * (const half& a, const half& b) {
+  return __hmul(a, b);
+}
+EIGEN_STRONG_INLINE __device__ half operator - (const half& a, const half& b) {
+  return __hsub(a, b);
+}
+EIGEN_STRONG_INLINE __device__ half operator / (const half& a, const half& b) {
+#if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER >= 90000
+  return __hdiv(a, b);
+#else
+  float num = __half2float(a);
+  float denom = __half2float(b);
+  return __float2half(num / denom);
+#endif
+}
+EIGEN_STRONG_INLINE __device__ half operator - (const half& a) {
+  return __hneg(a);
+}
+EIGEN_STRONG_INLINE __device__ half& operator += (half& a, const half& b) {
+  a = a + b;
+  return a;
+}
+EIGEN_STRONG_INLINE __device__ half& operator *= (half& a, const half& b) {
+  a = a * b;
+  return a;
+}
+EIGEN_STRONG_INLINE __device__ half& operator -= (half& a, const half& b) {
+  a = a - b;
+  return a;
+}
+EIGEN_STRONG_INLINE __device__ half& operator /= (half& a, const half& b) {
+  a = a / b;
+  return a;
+}
+EIGEN_STRONG_INLINE __device__ bool operator == (const half& a, const half& b) {
+  return __heq(a, b);
+}
+EIGEN_STRONG_INLINE __device__ bool operator != (const half& a, const half& b) {
+  return __hne(a, b);
+}
+EIGEN_STRONG_INLINE __device__ bool operator < (const half& a, const half& b) {
+  return __hlt(a, b);
+}
+EIGEN_STRONG_INLINE __device__ bool operator <= (const half& a, const half& b) {
+  return __hle(a, b);
+}
+EIGEN_STRONG_INLINE __device__ bool operator > (const half& a, const half& b) {
+  return __hgt(a, b);
+}
+EIGEN_STRONG_INLINE __device__ bool operator >= (const half& a, const half& b) {
+  return __hge(a, b);
+}
+#endif
+
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator + (const half& a, const half& b) {
+  return half(vaddh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator * (const half& a, const half& b) {
+  return half(vmulh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (const half& a, const half& b) {
+  return half(vsubh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator / (const half& a, const half& b) {
+  return half(vdivh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (const half& a) {
+  return half(vnegh_f16(a.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator += (half& a, const half& b) {
+  a = half(vaddh_f16(a.x, b.x));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator *= (half& a, const half& b) {
+  a = half(vmulh_f16(a.x, b.x));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator -= (half& a, const half& b) {
+  a = half(vsubh_f16(a.x, b.x));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator /= (half& a, const half& b) {
+  a = half(vdivh_f16(a.x, b.x));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator == (const half& a, const half& b) {
+  return vceqh_f16(a.x, b.x);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator != (const half& a, const half& b) {
+  return !vceqh_f16(a.x, b.x);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator < (const half& a, const half& b) {
+  return vclth_f16(a.x, b.x);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator <= (const half& a, const half& b) {
+  return vcleh_f16(a.x, b.x);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator > (const half& a, const half& b) {
+  return vcgth_f16(a.x, b.x);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator >= (const half& a, const half& b) {
+  return vcgeh_f16(a.x, b.x);
+}
+// We need to distinguish ‘clang as the CUDA compiler’ from ‘clang as the host compiler,
+// invoked by NVCC’ (e.g. on MacOS). The former needs to see both host and device implementation
+// of the functions, while the latter can only deal with one of them.
+#elif !defined(EIGEN_HAS_NATIVE_FP16) || (EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC) // Emulate support for half floats
+
+#if EIGEN_COMP_CLANG && defined(EIGEN_CUDACC)
+// We need to provide emulated *host-side* FP16 operators for clang.
+#pragma push_macro("EIGEN_DEVICE_FUNC")
+#undef EIGEN_DEVICE_FUNC
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_HAS_NATIVE_FP16)
+#define EIGEN_DEVICE_FUNC __host__
+#else // both host and device need emulated ops.
+#define EIGEN_DEVICE_FUNC __host__ __device__
+#endif
+#endif
+
+// Definitions for CPUs and older HIP+CUDA, mostly working through conversion
+// to/from fp32.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator + (const half& a, const half& b) {
+  return half(float(a) + float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator * (const half& a, const half& b) {
+  return half(float(a) * float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (const half& a, const half& b) {
+  return half(float(a) - float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator / (const half& a, const half& b) {
+  return half(float(a) / float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (const half& a) {
+  half result;
+  result.x = a.x ^ 0x8000;
+  return result;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator += (half& a, const half& b) {
+  a = half(float(a) + float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator *= (half& a, const half& b) {
+  a = half(float(a) * float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator -= (half& a, const half& b) {
+  a = half(float(a) - float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator /= (half& a, const half& b) {
+  a = half(float(a) / float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator == (const half& a, const half& b) {
+  return numext::equal_strict(float(a),float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator != (const half& a, const half& b) {
+  return numext::not_equal_strict(float(a), float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator < (const half& a, const half& b) {
+  return float(a) < float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator <= (const half& a, const half& b) {
+  return float(a) <= float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator > (const half& a, const half& b) {
+  return float(a) > float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator >= (const half& a, const half& b) {
+  return float(a) >= float(b);
+}
+
+#if defined(__clang__) && defined(__CUDA__)
+#pragma pop_macro("EIGEN_DEVICE_FUNC")
+#endif
+#endif  // Emulate support for half floats
+
+// Division by an index. Do it in full float precision to avoid accuracy
+// issues in converting the denominator to half.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator / (const half& a, Index b) {
+  return half(static_cast<float>(a) / static_cast<float>(b));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator++(half& a) {
+  a += half(1);
+  return a;
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator--(half& a) {
+  a -= half(1);
+  return a;
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator++(half& a, int) {
+  half original_value = a;
+  ++a;
+  return original_value;
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator--(half& a, int) {
+  half original_value = a;
+  --a;
+  return original_value;
+}
+
+// Conversion routines, including fallbacks for the host or older CUDA.
+// Note that newer Intel CPUs (Haswell or newer) have vectorized versions of
+// these in hardware. If we need more performance on older/other CPUs, they are
+// also possible to vectorize directly.
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw raw_uint16_to_half(numext::uint16_t x) {
+  // We cannot simply do a "return __half_raw(x)" here, because __half_raw is union type
+  // in the hip_fp16 header file, and that will trigger a compile error
+  // On the other hand, having anything but a return statement also triggers a compile error
+  // because this is constexpr function.
+  // Fortunately, since we need to disable EIGEN_CONSTEXPR for GPU anyway, we can get out
+  // of this catch22 by having separate bodies for GPU / non GPU
+#if defined(EIGEN_HAS_GPU_FP16)
+   __half_raw h;
+   h.x = x;
+  return h;
+#else
+  return __half_raw(x);
+#endif
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC numext::uint16_t raw_half_as_uint16(const __half_raw& h) {
+  // HIP/CUDA/Default have a member 'x' of type uint16_t.
+  // For ARM64 native half, the member 'x' is of type __fp16, so we need to bit-cast.
+  // For SYCL, cl::sycl::half is _Float16, so cast directly.
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  return numext::bit_cast<numext::uint16_t>(h.x);
+#elif defined(SYCL_DEVICE_ONLY)
+  return numext::bit_cast<numext::uint16_t>(h);
+#else
+  return h.x;
+#endif
+}
+
+union float32_bits {
+  unsigned int u;
+  float f;
+};
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(float ff) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  __half tmp_ff = __float2half(ff);
+  return *(__half_raw*)&tmp_ff;
+
+#elif defined(EIGEN_HAS_FP16_C)
+  __half_raw h;
+  h.x = _cvtss_sh(ff, 0);
+  return h;
+
+#elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  __half_raw h;
+  h.x = static_cast<__fp16>(ff);
+  return h;
+
+#else
+  float32_bits f; f.f = ff;
+
+  const float32_bits f32infty = { 255 << 23 };
+  const float32_bits f16max = { (127 + 16) << 23 };
+  const float32_bits denorm_magic = { ((127 - 15) + (23 - 10) + 1) << 23 };
+  unsigned int sign_mask = 0x80000000u;
+  __half_raw o;
+  o.x = static_cast<numext::uint16_t>(0x0u);
+
+  unsigned int sign = f.u & sign_mask;
+  f.u ^= sign;
+
+  // NOTE all the integer compares in this function can be safely
+  // compiled into signed compares since all operands are below
+  // 0x80000000. Important if you want fast straight SSE2 code
+  // (since there's no unsigned PCMPGTD).
+
+  if (f.u >= f16max.u) {  // result is Inf or NaN (all exponent bits set)
+    o.x = (f.u > f32infty.u) ? 0x7e00 : 0x7c00; // NaN->qNaN and Inf->Inf
+  } else {  // (De)normalized number or zero
+    if (f.u < (113 << 23)) {  // resulting FP16 is subnormal or zero
+      // use a magic value to align our 10 mantissa bits at the bottom of
+      // the float. as long as FP addition is round-to-nearest-even this
+      // just works.
+      f.f += denorm_magic.f;
+
+      // and one integer subtract of the bias later, we have our final float!
+      o.x = static_cast<numext::uint16_t>(f.u - denorm_magic.u);
+    } else {
+      unsigned int mant_odd = (f.u >> 13) & 1; // resulting mantissa is odd
+
+      // update exponent, rounding bias part 1
+      // Equivalent to `f.u += ((unsigned int)(15 - 127) << 23) + 0xfff`, but
+      // without arithmetic overflow.
+      f.u += 0xc8000fffU;
+      // rounding bias part 2
+      f.u += mant_odd;
+      // take the bits!
+      o.x = static_cast<numext::uint16_t>(f.u >> 13);
+    }
+  }
+
+  o.x |= static_cast<numext::uint16_t>(sign >> 16);
+  return o;
+#endif
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float half_to_float(__half_raw h) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  return __half2float(h);
+#elif defined(EIGEN_HAS_FP16_C)
+  return _cvtsh_ss(h.x);
+#elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  return static_cast<float>(h.x);
+#else
+  const float32_bits magic = { 113 << 23 };
+  const unsigned int shifted_exp = 0x7c00 << 13; // exponent mask after shift
+  float32_bits o;
+
+  o.u = (h.x & 0x7fff) << 13;             // exponent/mantissa bits
+  unsigned int exp = shifted_exp & o.u;   // just the exponent
+  o.u += (127 - 15) << 23;                // exponent adjust
+
+  // handle exponent special cases
+  if (exp == shifted_exp) {     // Inf/NaN?
+    o.u += (128 - 16) << 23;    // extra exp adjust
+  } else if (exp == 0) {        // Zero/Denormal?
+    o.u += 1 << 23;             // extra exp adjust
+    o.f -= magic.f;             // renormalize
+  }
+
+  o.u |= (h.x & 0x8000) << 16;    // sign bit
+  return o.f;
+#endif
+}
+
+// --- standard functions ---
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isinf)(const half& a) {
+#ifdef EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC
+  return (numext::bit_cast<numext::uint16_t>(a.x) & 0x7fff) == 0x7c00;
+#else
+  return (a.x & 0x7fff) == 0x7c00;
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isnan)(const half& a) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  return __hisnan(a);
+#elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  return (numext::bit_cast<numext::uint16_t>(a.x) & 0x7fff) > 0x7c00;
+#else
+  return (a.x & 0x7fff) > 0x7c00;
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isfinite)(const half& a) {
+  return !(isinf EIGEN_NOT_A_MACRO (a)) && !(isnan EIGEN_NOT_A_MACRO (a));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half abs(const half& a) {
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  return half(vabsh_f16(a.x));
+#else
+  half result;
+  result.x = a.x & 0x7FFF;
+  return result;
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half exp(const half& a) {
+#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530) || \
+  defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hexp(a));
+#else
+   return half(::expf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half expm1(const half& a) {
+  return half(numext::expm1(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log(const half& a) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && EIGEN_CUDA_SDK_VER >= 80000 && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  return half(::hlog(a));
+#else
+  return half(::logf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log1p(const half& a) {
+  return half(numext::log1p(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log10(const half& a) {
+  return half(::log10f(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log2(const half& a) {
+  return half(static_cast<float>(EIGEN_LOG2E) * ::logf(float(a)));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half sqrt(const half& a) {
+#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530) || \
+  defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hsqrt(a));
+#else
+    return half(::sqrtf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half pow(const half& a, const half& b) {
+  return half(::powf(float(a), float(b)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half sin(const half& a) {
+  return half(::sinf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half cos(const half& a) {
+  return half(::cosf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half tan(const half& a) {
+  return half(::tanf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half tanh(const half& a) {
+  return half(::tanhf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half asin(const half& a) {
+  return half(::asinf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half acos(const half& a) {
+  return half(::acosf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half floor(const half& a) {
+#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300) || \
+  defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hfloor(a));
+#else
+  return half(::floorf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half ceil(const half& a) {
+#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300) || \
+  defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hceil(a));
+#else
+  return half(::ceilf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half rint(const half& a) {
+  return half(::rintf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half round(const half& a) {
+  return half(::roundf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half fmod(const half& a, const half& b) {
+  return half(::fmodf(float(a), float(b)));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half (min)(const half& a, const half& b) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  return __hlt(b, a) ? b : a;
+#else
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return f2 < f1 ? b : a;
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half (max)(const half& a, const half& b) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  return __hlt(a, b) ? b : a;
+#else
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return f1 < f2 ? b : a;
+#endif
+}
+
+#ifndef EIGEN_NO_IO
+EIGEN_ALWAYS_INLINE std::ostream& operator << (std::ostream& os, const half& v) {
+  os << static_cast<float>(v);
+  return os;
+}
+#endif
+
+} // end namespace half_impl
+
+// import Eigen::half_impl::half into Eigen namespace
+// using half_impl::half;
+
+namespace internal {
+
+template<>
+struct random_default_impl<half, false, false>
+{
+  static inline half run(const half& x, const half& y)
+  {
+    return x + (y-x) * half(float(std::rand()) / float(RAND_MAX));
+  }
+  static inline half run()
+  {
+    return run(half(-1.f), half(1.f));
+  }
+};
+
+template<> struct is_arithmetic<half> { enum { value = true }; };
+
+} // end namespace internal
+
+template<> struct NumTraits<Eigen::half>
+    : GenericNumTraits<Eigen::half>
+{
+  enum {
+    IsSigned = true,
+    IsInteger = false,
+    IsComplex = false,
+    RequireInitialization = false
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half epsilon() {
+    return half_impl::raw_uint16_to_half(0x0800);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half dummy_precision() {
+    return half_impl::raw_uint16_to_half(0x211f); //  Eigen::half(1e-2f);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half highest() {
+    return half_impl::raw_uint16_to_half(0x7bff);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half lowest() {
+    return half_impl::raw_uint16_to_half(0xfbff);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half infinity() {
+    return half_impl::raw_uint16_to_half(0x7c00);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half quiet_NaN() {
+    return half_impl::raw_uint16_to_half(0x7e00);
+  }
+};
+
+} // end namespace Eigen
+
+#if defined(EIGEN_HAS_GPU_FP16) || defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  #pragma pop_macro("EIGEN_CONSTEXPR")
+#endif
+
+namespace Eigen {
+namespace numext {
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool(isnan)(const Eigen::half& h) {
+  return (half_impl::isnan)(h);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool(isinf)(const Eigen::half& h) {
+  return (half_impl::isinf)(h);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool(isfinite)(const Eigen::half& h) {
+  return (half_impl::isfinite)(h);
+}
+
+#endif
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bit_cast<Eigen::half, uint16_t>(const uint16_t& src) {
+  return Eigen::half(Eigen::half_impl::raw_uint16_to_half(src));
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC uint16_t bit_cast<uint16_t, Eigen::half>(const Eigen::half& src) {
+  return Eigen::half_impl::raw_half_as_uint16(src);
+}
+
+}  // namespace numext
+}  // namespace Eigen
+
+// Add the missing shfl* intrinsics.
+// The __shfl* functions are only valid on HIP or _CUDA_ARCH_ >= 300.
+//   CUDA defines them for (__CUDA_ARCH__ >= 300 || !defined(__CUDA_ARCH__))
+//
+// HIP and CUDA prior to SDK 9.0 define
+//    __shfl, __shfl_up, __shfl_down, __shfl_xor for int and float
+// CUDA since 9.0 deprecates those and instead defines
+//    __shfl_sync, __shfl_up_sync, __shfl_down_sync, __shfl_xor_sync,
+//    with native support for __half and __nv_bfloat16
+//
+// Note that the following are __device__ - only functions.
+#if (defined(EIGEN_CUDACC) && (!defined(EIGEN_CUDA_ARCH) || EIGEN_CUDA_ARCH >= 300)) \
+    || defined(EIGEN_HIPCC)
+
+#if defined(EIGEN_HAS_CUDA_FP16) && EIGEN_CUDA_SDK_VER >= 90000
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_sync(unsigned mask, Eigen::half var, int srcLane, int width=warpSize) {
+  const __half h = var;
+  return static_cast<Eigen::half>(__shfl_sync(mask, h, srcLane, width));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_up_sync(unsigned mask, Eigen::half var, unsigned int delta, int width=warpSize) {
+  const __half h = var;
+  return static_cast<Eigen::half>(__shfl_up_sync(mask, h, delta, width));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_down_sync(unsigned mask, Eigen::half var, unsigned int delta, int width=warpSize) {
+  const __half h = var;
+  return static_cast<Eigen::half>(__shfl_down_sync(mask, h, delta, width));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_xor_sync(unsigned mask, Eigen::half var, int laneMask, int width=warpSize) {
+  const __half h = var;
+  return static_cast<Eigen::half>(__shfl_xor_sync(mask, h, laneMask, width));
+}
+
+#else // HIP or CUDA SDK < 9.0
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl(Eigen::half var, int srcLane, int width=warpSize) {
+  const int ivar = static_cast<int>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(var));
+  return Eigen::numext::bit_cast<Eigen::half>(static_cast<Eigen::numext::uint16_t>(__shfl(ivar, srcLane, width)));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_up(Eigen::half var, unsigned int delta, int width=warpSize) {
+  const int ivar = static_cast<int>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(var));
+  return Eigen::numext::bit_cast<Eigen::half>(static_cast<Eigen::numext::uint16_t>(__shfl_up(ivar, delta, width)));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_down(Eigen::half var, unsigned int delta, int width=warpSize) {
+  const int ivar = static_cast<int>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(var));
+  return Eigen::numext::bit_cast<Eigen::half>(static_cast<Eigen::numext::uint16_t>(__shfl_down(ivar, delta, width)));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_xor(Eigen::half var, int laneMask, int width=warpSize) {
+  const int ivar = static_cast<int>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(var));
+  return Eigen::numext::bit_cast<Eigen::half>(static_cast<Eigen::numext::uint16_t>(__shfl_xor(ivar, laneMask, width)));
+}
+
+#endif // HIP vs CUDA
+#endif // __shfl*
+
+// ldg() has an overload for __half_raw, but we also need one for Eigen::half.
+#if (defined(EIGEN_CUDACC) && (!defined(EIGEN_CUDA_ARCH) || EIGEN_CUDA_ARCH >= 350)) \
+    || defined(EIGEN_HIPCC)
+EIGEN_STRONG_INLINE __device__ Eigen::half __ldg(const Eigen::half* ptr) {
+  return Eigen::half_impl::raw_uint16_to_half(__ldg(reinterpret_cast<const Eigen::numext::uint16_t*>(ptr)));
+}
+#endif // __ldg
+
+#if EIGEN_HAS_STD_HASH
+namespace std {
+template <>
+struct hash<Eigen::half> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::size_t operator()(const Eigen::half& a) const {
+    return static_cast<std::size_t>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(a));
+  }
+};
+} // end namespace std
+#endif
+
+#endif // EIGEN_HALF_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/Settings.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/Settings.h
new file mode 100644
index 00000000..a5c3ada4
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/Settings.h
@@ -0,0 +1,49 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+/* All the parameters defined in this file can be specialized in the
+ * architecture specific files, and/or by the user.
+ * More to come... */
+
+#ifndef EIGEN_DEFAULT_SETTINGS_H
+#define EIGEN_DEFAULT_SETTINGS_H
+
+/** Defines the maximal loop size to enable meta unrolling of loops.
+  * Note that the value here is expressed in Eigen's own notion of "number of FLOPS",
+  * it does not correspond to the number of iterations or the number of instructions
+  */
+#ifndef EIGEN_UNROLLING_LIMIT
+#define EIGEN_UNROLLING_LIMIT 110
+#endif
+
+/** Defines the threshold between a "small" and a "large" matrix.
+  * This threshold is mainly used to select the proper product implementation.
+  */
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+/** Defines the maximal width of the blocks used in the triangular product and solver
+  * for vectors (level 2 blas xTRMV and xTRSV). The default is 8.
+  */
+#ifndef EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH
+#define EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH 8
+#endif
+
+
+/** Defines the default number of registers available for that architecture.
+  * Currently it must be 8 or 16. Other values will fail.
+  */
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 8
+#endif
+
+#endif // EIGEN_DEFAULT_SETTINGS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/TypeCasting.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/TypeCasting.h
new file mode 100644
index 00000000..fb8183b7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/Default/TypeCasting.h
@@ -0,0 +1,120 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// Copyright (C) 2019 Rasmus Munk Larsen <rmlarsen@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERIC_TYPE_CASTING_H
+#define EIGEN_GENERIC_TYPE_CASTING_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<>
+struct scalar_cast_op<float, Eigen::half> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef Eigen::half result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half operator() (const float& a) const {
+    #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+      (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+      return __float2half(a);
+    #else
+      return Eigen::half(a);
+    #endif
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<float, Eigen::half> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<int, Eigen::half> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef Eigen::half result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half operator() (const int& a) const {
+    #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+      (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+      return __float2half(static_cast<float>(a));
+    #else
+      return Eigen::half(static_cast<float>(a));
+    #endif
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<int, Eigen::half> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<Eigen::half, float> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef float result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator() (const Eigen::half& a) const {
+    #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+      (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+      return __half2float(a);
+    #else
+      return static_cast<float>(a);
+    #endif
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<Eigen::half, float> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<float, Eigen::bfloat16> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef Eigen::bfloat16 result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16 operator() (const float& a) const {
+    return Eigen::bfloat16(a);
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<float, Eigen::bfloat16> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<int, Eigen::bfloat16> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef Eigen::bfloat16 result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16 operator() (const int& a) const {
+    return Eigen::bfloat16(static_cast<float>(a));
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<int, Eigen::bfloat16> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<Eigen::bfloat16, float> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef float result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator() (const Eigen::bfloat16& a) const {
+    return static_cast<float>(a);
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<Eigen::bfloat16, float> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+}
+}
+
+#endif  // EIGEN_GENERIC_TYPE_CASTING_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/GPU/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/GPU/MathFunctions.h
new file mode 100644
index 00000000..d2b3a256
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/GPU/MathFunctions.h
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_GPU_H
+#define EIGEN_MATH_FUNCTIONS_GPU_H
+
+namespace Eigen {
+
+namespace internal {
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#if defined(EIGEN_GPUCC) && defined(EIGEN_USE_GPU)
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 plog<float4>(const float4& a)
+{
+  return make_float4(logf(a.x), logf(a.y), logf(a.z), logf(a.w));
+}
+
+template<>  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 plog<double2>(const double2& a)
+{
+  using ::log;
+  return make_double2(log(a.x), log(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 plog1p<float4>(const float4& a)
+{
+  return make_float4(log1pf(a.x), log1pf(a.y), log1pf(a.z), log1pf(a.w));
+}
+
+template<>  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 plog1p<double2>(const double2& a)
+{
+  return make_double2(log1p(a.x), log1p(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 pexp<float4>(const float4& a)
+{
+  return make_float4(expf(a.x), expf(a.y), expf(a.z), expf(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 pexp<double2>(const double2& a)
+{
+  using ::exp;
+  return make_double2(exp(a.x), exp(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 pexpm1<float4>(const float4& a)
+{
+  return make_float4(expm1f(a.x), expm1f(a.y), expm1f(a.z), expm1f(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 pexpm1<double2>(const double2& a)
+{
+  return make_double2(expm1(a.x), expm1(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 psqrt<float4>(const float4& a)
+{
+  return make_float4(sqrtf(a.x), sqrtf(a.y), sqrtf(a.z), sqrtf(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 psqrt<double2>(const double2& a)
+{
+  using ::sqrt;
+  return make_double2(sqrt(a.x), sqrt(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 prsqrt<float4>(const float4& a)
+{
+  return make_float4(rsqrtf(a.x), rsqrtf(a.y), rsqrtf(a.z), rsqrtf(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 prsqrt<double2>(const double2& a)
+{
+  return make_double2(rsqrt(a.x), rsqrt(a.y));
+}
+
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATH_FUNCTIONS_GPU_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/GPU/PacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/GPU/PacketMath.h
new file mode 100644
index 00000000..689110de
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/GPU/PacketMath.h
@@ -0,0 +1,1685 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_GPU_H
+#define EIGEN_PACKET_MATH_GPU_H
+
+namespace Eigen {
+
+namespace internal {
+
+// Read-only data cached load available.
+#if defined(EIGEN_HIP_DEVICE_COMPILE) || (defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 350)
+#define EIGEN_GPU_HAS_LDG 1
+#endif
+
+// FP16 math available.
+#if (defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530)
+#define EIGEN_CUDA_HAS_FP16_ARITHMETIC 1
+#endif
+
+#if defined(EIGEN_HIP_DEVICE_COMPILE) || defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
+#define EIGEN_GPU_HAS_FP16_ARITHMETIC 1
+#endif
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#if defined(EIGEN_GPUCC) && defined(EIGEN_USE_GPU)
+
+template<> struct is_arithmetic<float4>  { enum { value = true }; };
+template<> struct is_arithmetic<double2> { enum { value = true }; };
+
+template<> struct packet_traits<float> : default_packet_traits
+{
+  typedef float4 type;
+  typedef float4 half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+    HasHalfPacket = 0,
+
+    HasDiv  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasLGamma = 1,
+    HasDiGamma = 1,
+    HasZeta = 1,
+    HasPolygamma = 1,
+    HasErf = 1,
+    HasErfc = 1,
+    HasNdtri = 1,
+    HasBessel = 1,
+    HasIGamma = 1,
+    HasIGammaDerA = 1,
+    HasGammaSampleDerAlpha = 1,
+    HasIGammac = 1,
+    HasBetaInc = 1,
+
+    HasBlend = 0,
+    HasFloor = 1,
+  };
+};
+
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef double2 type;
+  typedef double2 half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 0,
+
+    HasDiv  = 1,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasLGamma = 1,
+    HasDiGamma = 1,
+    HasZeta = 1,
+    HasPolygamma = 1,
+    HasErf = 1,
+    HasErfc = 1,
+    HasNdtri = 1,
+    HasBessel = 1,
+    HasIGamma = 1,
+    HasIGammaDerA = 1,
+    HasGammaSampleDerAlpha = 1,
+    HasIGammac = 1,
+    HasBetaInc = 1,
+
+    HasBlend = 0,
+    HasFloor = 1,
+  };
+};
+
+
+template<> struct unpacket_traits<float4>  { typedef float  type; enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef float4 half; };
+template<> struct unpacket_traits<double2> { typedef double type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef double2 half; };
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pset1<float4>(const float&  from) {
+  return make_float4(from, from, from, from);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pset1<double2>(const double& from) {
+  return make_double2(from, from);
+}
+
+// We need to distinguish ‘clang as the CUDA compiler’ from ‘clang as the host compiler,
+// invoked by NVCC’ (e.g. on MacOS). The former needs to see both host and device implementation
+// of the functions, while the latter can only deal with one of them.
+#if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIPCC) || (defined(EIGEN_CUDACC) && EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC)
+namespace {
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_and(const float& a,
+                                                        const float& b) {
+  return __int_as_float(__float_as_int(a) & __float_as_int(b));
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_and(const double& a,
+                                                         const double& b) {
+  return __longlong_as_double(__double_as_longlong(a) &
+                              __double_as_longlong(b));
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_or(const float& a,
+                                                       const float& b) {
+  return __int_as_float(__float_as_int(a) | __float_as_int(b));
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_or(const double& a,
+                                                        const double& b) {
+  return __longlong_as_double(__double_as_longlong(a) |
+                              __double_as_longlong(b));
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_xor(const float& a,
+                                                        const float& b) {
+  return __int_as_float(__float_as_int(a) ^ __float_as_int(b));
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_xor(const double& a,
+                                                         const double& b) {
+  return __longlong_as_double(__double_as_longlong(a) ^
+                              __double_as_longlong(b));
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_andnot(const float& a,
+                                                           const float& b) {
+  return __int_as_float(__float_as_int(a) & ~__float_as_int(b));
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_andnot(const double& a,
+                                                            const double& b) {
+  return __longlong_as_double(__double_as_longlong(a) &
+                              ~__double_as_longlong(b));
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float eq_mask(const float& a,
+                                                    const float& b) {
+  return __int_as_float(a == b ? 0xffffffffu : 0u);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double eq_mask(const double& a,
+                                                     const double& b) {
+  return __longlong_as_double(a == b ? 0xffffffffffffffffull : 0ull);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float lt_mask(const float& a,
+                                                    const float& b) {
+  return __int_as_float(a < b ? 0xffffffffu : 0u);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double lt_mask(const double& a,
+                                                     const double& b) {
+  return __longlong_as_double(a < b ? 0xffffffffffffffffull : 0ull);
+}
+
+}  // namespace
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pand<float4>(const float4& a,
+                                                          const float4& b) {
+  return make_float4(bitwise_and(a.x, b.x), bitwise_and(a.y, b.y),
+                     bitwise_and(a.z, b.z), bitwise_and(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pand<double2>(const double2& a,
+                                                            const double2& b) {
+  return make_double2(bitwise_and(a.x, b.x), bitwise_and(a.y, b.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 por<float4>(const float4& a,
+                                                         const float4& b) {
+  return make_float4(bitwise_or(a.x, b.x), bitwise_or(a.y, b.y),
+                     bitwise_or(a.z, b.z), bitwise_or(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 por<double2>(const double2& a,
+                                                           const double2& b) {
+  return make_double2(bitwise_or(a.x, b.x), bitwise_or(a.y, b.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pxor<float4>(const float4& a,
+                                                          const float4& b) {
+  return make_float4(bitwise_xor(a.x, b.x), bitwise_xor(a.y, b.y),
+                     bitwise_xor(a.z, b.z), bitwise_xor(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pxor<double2>(const double2& a,
+                                                            const double2& b) {
+  return make_double2(bitwise_xor(a.x, b.x), bitwise_xor(a.y, b.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pandnot<float4>(const float4& a,
+                                                             const float4& b) {
+  return make_float4(bitwise_andnot(a.x, b.x), bitwise_andnot(a.y, b.y),
+                     bitwise_andnot(a.z, b.z), bitwise_andnot(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
+pandnot<double2>(const double2& a, const double2& b) {
+  return make_double2(bitwise_andnot(a.x, b.x), bitwise_andnot(a.y, b.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcmp_eq<float4>(const float4& a,
+                                                             const float4& b) {
+  return make_float4(eq_mask(a.x, b.x), eq_mask(a.y, b.y), eq_mask(a.z, b.z),
+                     eq_mask(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcmp_lt<float4>(const float4& a,
+                                                             const float4& b) {
+  return make_float4(lt_mask(a.x, b.x), lt_mask(a.y, b.y), lt_mask(a.z, b.z),
+                     lt_mask(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
+pcmp_eq<double2>(const double2& a, const double2& b) {
+  return make_double2(eq_mask(a.x, b.x), eq_mask(a.y, b.y));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
+pcmp_lt<double2>(const double2& a, const double2& b) {
+  return make_double2(lt_mask(a.x, b.x), lt_mask(a.y, b.y));
+}
+#endif // defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIPCC) || (defined(EIGEN_CUDACC) && EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC)
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 plset<float4>(const float& a) {
+  return make_float4(a, a+1, a+2, a+3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 plset<double2>(const double& a) {
+  return make_double2(a, a+1);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 padd<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x+b.x, a.y+b.y, a.z+b.z, a.w+b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 padd<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x+b.x, a.y+b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 psub<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x-b.x, a.y-b.y, a.z-b.z, a.w-b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 psub<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x-b.x, a.y-b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pnegate(const float4& a) {
+  return make_float4(-a.x, -a.y, -a.z, -a.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pnegate(const double2& a) {
+  return make_double2(-a.x, -a.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pconj(const float4& a) { return a; }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pconj(const double2& a) { return a; }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pmul<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x*b.x, a.y*b.y, a.z*b.z, a.w*b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pmul<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x*b.x, a.y*b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pdiv<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x/b.x, a.y/b.y, a.z/b.z, a.w/b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pdiv<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x/b.x, a.y/b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pmin<float4>(const float4& a, const float4& b) {
+  return make_float4(fminf(a.x, b.x), fminf(a.y, b.y), fminf(a.z, b.z), fminf(a.w, b.w));
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pmin<double2>(const double2& a, const double2& b) {
+  return make_double2(fmin(a.x, b.x), fmin(a.y, b.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pmax<float4>(const float4& a, const float4& b) {
+  return make_float4(fmaxf(a.x, b.x), fmaxf(a.y, b.y), fmaxf(a.z, b.z), fmaxf(a.w, b.w));
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pmax<double2>(const double2& a, const double2& b) {
+  return make_double2(fmax(a.x, b.x), fmax(a.y, b.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pload<float4>(const float* from) {
+  return *reinterpret_cast<const float4*>(from);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pload<double2>(const double* from) {
+  return *reinterpret_cast<const double2*>(from);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 ploadu<float4>(const float* from) {
+  return make_float4(from[0], from[1], from[2], from[3]);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 ploadu<double2>(const double* from) {
+  return make_double2(from[0], from[1]);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 ploaddup<float4>(const float*   from) {
+  return make_float4(from[0], from[0], from[1], from[1]);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 ploaddup<double2>(const double*  from) {
+  return make_double2(from[0], from[0]);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore<float>(float*   to, const float4& from) {
+  *reinterpret_cast<float4*>(to) = from;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore<double>(double* to, const double2& from) {
+  *reinterpret_cast<double2*>(to) = from;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu<float>(float*  to, const float4& from) {
+  to[0] = from.x;
+  to[1] = from.y;
+  to[2] = from.z;
+  to[3] = from.w;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const double2& from) {
+  to[0] = from.x;
+  to[1] = from.y;
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float4 ploadt_ro<float4, Aligned>(const float* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  return __ldg((const float4*)from);
+#else
+  return make_float4(from[0], from[1], from[2], from[3]);
+#endif
+}
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double2 ploadt_ro<double2, Aligned>(const double* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  return __ldg((const double2*)from);
+#else
+  return make_double2(from[0], from[1]);
+#endif
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float4 ploadt_ro<float4, Unaligned>(const float* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  return make_float4(__ldg(from+0), __ldg(from+1), __ldg(from+2), __ldg(from+3));
+#else
+  return make_float4(from[0], from[1], from[2], from[3]);
+#endif
+}
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double2 ploadt_ro<double2, Unaligned>(const double* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  return make_double2(__ldg(from+0), __ldg(from+1));
+#else
+  return make_double2(from[0], from[1]);
+#endif
+}
+
+template<> EIGEN_DEVICE_FUNC inline float4 pgather<float, float4>(const float* from, Index stride) {
+  return make_float4(from[0*stride], from[1*stride], from[2*stride], from[3*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline double2 pgather<double, double2>(const double* from, Index stride) {
+  return make_double2(from[0*stride], from[1*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, float4>(float* to, const float4& from, Index stride) {
+  to[stride*0] = from.x;
+  to[stride*1] = from.y;
+  to[stride*2] = from.z;
+  to[stride*3] = from.w;
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, double2>(double* to, const double2& from, Index stride) {
+  to[stride*0] = from.x;
+  to[stride*1] = from.y;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  pfirst<float4>(const float4& a) {
+  return a.x;
+}
+template<> EIGEN_DEVICE_FUNC inline double pfirst<double2>(const double2& a) {
+  return a.x;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux<float4>(const float4& a) {
+  return a.x + a.y + a.z + a.w;
+}
+template<> EIGEN_DEVICE_FUNC inline double predux<double2>(const double2& a) {
+  return a.x + a.y;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux_max<float4>(const float4& a) {
+  return fmaxf(fmaxf(a.x, a.y), fmaxf(a.z, a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double predux_max<double2>(const double2& a) {
+  return fmax(a.x, a.y);
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux_min<float4>(const float4& a) {
+  return fminf(fminf(a.x, a.y), fminf(a.z, a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double predux_min<double2>(const double2& a) {
+  return fmin(a.x, a.y);
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux_mul<float4>(const float4& a) {
+  return a.x * a.y * a.z * a.w;
+}
+template<> EIGEN_DEVICE_FUNC inline double predux_mul<double2>(const double2& a) {
+  return a.x * a.y;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float4  pabs<float4>(const float4& a) {
+  return make_float4(fabsf(a.x), fabsf(a.y), fabsf(a.z), fabsf(a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double2 pabs<double2>(const double2& a) {
+  return make_double2(fabs(a.x), fabs(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC inline float4  pfloor<float4>(const float4& a) {
+  return make_float4(floorf(a.x), floorf(a.y), floorf(a.z), floorf(a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double2 pfloor<double2>(const double2& a) {
+  return make_double2(floor(a.x), floor(a.y));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<float4,4>& kernel) {
+  float tmp = kernel.packet[0].y;
+  kernel.packet[0].y = kernel.packet[1].x;
+  kernel.packet[1].x = tmp;
+
+  tmp = kernel.packet[0].z;
+  kernel.packet[0].z = kernel.packet[2].x;
+  kernel.packet[2].x = tmp;
+
+  tmp = kernel.packet[0].w;
+  kernel.packet[0].w = kernel.packet[3].x;
+  kernel.packet[3].x = tmp;
+
+  tmp = kernel.packet[1].z;
+  kernel.packet[1].z = kernel.packet[2].y;
+  kernel.packet[2].y = tmp;
+
+  tmp = kernel.packet[1].w;
+  kernel.packet[1].w = kernel.packet[3].y;
+  kernel.packet[3].y = tmp;
+
+  tmp = kernel.packet[2].w;
+  kernel.packet[2].w = kernel.packet[3].z;
+  kernel.packet[3].z = tmp;
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<double2,2>& kernel) {
+  double tmp = kernel.packet[0].y;
+  kernel.packet[0].y = kernel.packet[1].x;
+  kernel.packet[1].x = tmp;
+}
+
+#endif // defined(EIGEN_GPUCC) && defined(EIGEN_USE_GPU)
+
+// Packet4h2 must be defined in the macro without EIGEN_CUDA_ARCH, meaning
+// its corresponding packet_traits<Eigen::half> must be visible on host.
+#if defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)
+
+typedef ulonglong2 Packet4h2;
+template<> struct unpacket_traits<Packet4h2> { typedef Eigen::half type; enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet4h2 half; };
+template<> struct is_arithmetic<Packet4h2> { enum { value = true }; };
+
+template<> struct unpacket_traits<half2> { typedef Eigen::half type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef half2 half; };
+template<> struct is_arithmetic<half2> { enum { value = true }; };
+
+template<> struct packet_traits<Eigen::half> : default_packet_traits
+{
+  typedef Packet4h2 type;
+  typedef Packet4h2 half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=8,
+    HasHalfPacket = 0,
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasSqrt   = 1,
+    HasRsqrt  = 1,
+    HasExp    = 1,
+    HasExpm1  = 1,
+    HasLog    = 1,
+    HasLog1p  = 1
+  };
+};
+
+namespace {
+// This is equivalent to make_half2, which is undocumented and doesn't seem to always exist.
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 combine_half(const __half& a, const __half& b) {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return __halves2half2(a, b);
+#else
+  // Round-about way since __halves2half2 is a __device__ function.
+  return __floats2half2_rn(__half2float(a), __half2float(b));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE __half get_half2_low(const half2& a) {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return __low2half(a);
+#else
+  return __float2half(__low2float(a));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE __half get_half2_high(const half2& a) {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return __high2half(a);
+#else
+  return __float2half(__high2float(a));
+#endif
+}
+} // namespace
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pset1<half2>(const Eigen::half& from) {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return __half2half2(from);
+#else
+  const float f = __half2float(from);
+  return __floats2half2_rn(f, f);
+#endif
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pset1<Packet4h2>(const Eigen::half& from) {
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = pset1<half2>(from);
+  p_alias[1] = pset1<half2>(from);
+  p_alias[2] = pset1<half2>(from);
+  p_alias[3] = pset1<half2>(from);
+  return r;
+}
+
+// We now need this visible on both host and device.
+// #if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIPCC) || (defined(EIGEN_CUDACC) && EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC)
+namespace {
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pload(const Eigen::half* from) {
+  return *reinterpret_cast<const half2*>(from);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ploadu(const Eigen::half* from) {
+  return combine_half(from[0], from[1]);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ploaddup(const Eigen::half*  from) {
+  return combine_half(from[0], from[0]);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore(Eigen::half* to,
+                                                  const half2& from) {
+  *reinterpret_cast<half2*>(to) = from;
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu(Eigen::half* to,
+                                                   const half2& from) {
+  to[0] = get_half2_low(from);
+  to[1] = get_half2_high(from);
+}
+
+
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE half2 ploadt_ro_aligned(
+    const Eigen::half* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  // Input is guaranteed to be properly aligned.
+  return __ldg(reinterpret_cast<const half2*>(from));
+#else
+  return combine_half(*(from+0), *(from+1));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE half2 ploadt_ro_unaligned(
+    const Eigen::half* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  return __halves2half2(__ldg(from+0), __ldg(from+1));
+#else
+  return combine_half(*(from+0), *(from+1));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pgather(const Eigen::half* from,
+                                                    Index stride) {
+  return combine_half(from[0*stride], from[1*stride]);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter(
+    Eigen::half* to, const half2& from, Index stride) {
+  to[stride*0] = get_half2_low(from);
+  to[stride*1] = get_half2_high(from);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half pfirst(const half2& a) {
+  return get_half2_low(a);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pabs(const half2& a) {
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half result1 = half_impl::raw_uint16_to_half(a1.x & 0x7FFF);
+  half result2 = half_impl::raw_uint16_to_half(a2.x & 0x7FFF);
+  return combine_half(result1, result2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ptrue(const half2& /*a*/) {
+  half true_half = half_impl::raw_uint16_to_half(0xffffu);
+  return pset1<half2>(true_half);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pzero(const half2& /*a*/) {
+  half false_half = half_impl::raw_uint16_to_half(0x0000u);
+  return pset1<half2>(false_half);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<half2,2>& kernel) {
+  __half a1 = get_half2_low(kernel.packet[0]);
+  __half a2 = get_half2_high(kernel.packet[0]);
+  __half b1 = get_half2_low(kernel.packet[1]);
+  __half b2 = get_half2_high(kernel.packet[1]);
+  kernel.packet[0] = combine_half(a1, b1);
+  kernel.packet[1] = combine_half(a2, b2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plset(const Eigen::half& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __halves2half2(a, __hadd(a, __float2half(1.0f)));
+#else
+  float f = __half2float(a) + 1.0f;
+  return combine_half(a, __float2half(f));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pselect(const half2& mask,
+                                                    const half2& a,
+                                                    const half2& b) {
+  half mask_low = get_half2_low(mask);
+  half mask_high = get_half2_high(mask);
+  half result_low = mask_low == half(0) ? get_half2_low(b) : get_half2_low(a);
+  half result_high = mask_high == half(0) ? get_half2_high(b) : get_half2_high(a);
+  return combine_half(result_low, result_high);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcmp_eq(const half2& a,
+                                                    const half2& b) {
+  half true_half = half_impl::raw_uint16_to_half(0xffffu);
+  half false_half = half_impl::raw_uint16_to_half(0x0000u);
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half eq1 = __half2float(a1) == __half2float(b1) ? true_half : false_half;
+  half eq2 = __half2float(a2) == __half2float(b2) ? true_half : false_half;
+  return combine_half(eq1, eq2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcmp_lt(const half2& a,
+                                                    const half2& b) {
+  half true_half = half_impl::raw_uint16_to_half(0xffffu);
+  half false_half = half_impl::raw_uint16_to_half(0x0000u);
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half eq1 = __half2float(a1) < __half2float(b1) ? true_half : false_half;
+  half eq2 = __half2float(a2) < __half2float(b2) ? true_half : false_half;
+  return combine_half(eq1, eq2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pand(const half2& a,
+                                                 const half2& b) {
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half result1 = half_impl::raw_uint16_to_half(a1.x & b1.x);
+  half result2 = half_impl::raw_uint16_to_half(a2.x & b2.x);
+  return combine_half(result1, result2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 por(const half2& a,
+                                                const half2& b) {
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half result1 = half_impl::raw_uint16_to_half(a1.x | b1.x);
+  half result2 = half_impl::raw_uint16_to_half(a2.x | b2.x);
+  return combine_half(result1, result2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pxor(const half2& a,
+                                                 const half2& b) {
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half result1 = half_impl::raw_uint16_to_half(a1.x ^ b1.x);
+  half result2 = half_impl::raw_uint16_to_half(a2.x ^ b2.x);
+  return combine_half(result1, result2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pandnot(const half2& a,
+                                                    const half2& b) {
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half result1 = half_impl::raw_uint16_to_half(a1.x & ~b1.x);
+  half result2 = half_impl::raw_uint16_to_half(a2.x & ~b2.x);
+  return combine_half(result1, result2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 padd(const half2& a,
+                                                 const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hadd2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 + b1;
+  float r2 = a2 + b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 psub(const half2& a,
+                                                 const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hsub2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 - b1;
+  float r2 = a2 - b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pnegate(const half2& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hneg2(a);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return __floats2half2_rn(-a1, -a2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pconj(const half2& a) { return a; }
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmul(const half2& a,
+                                                 const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hmul2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 * b1;
+  float r2 = a2 * b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmadd(const half2& a,
+                                                  const half2& b,
+                                                  const half2& c) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+   return __hfma2(a, b, c);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float c1 = __low2float(c);
+  float c2 = __high2float(c);
+  float r1 = a1 * b1 + c1;
+  float r2 = a2 * b2 + c2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pdiv(const half2& a,
+                                                 const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __h2div(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 / b1;
+  float r2 = a2 / b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmin(const half2& a,
+                                                 const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  __half r1 = a1 < b1 ? get_half2_low(a) : get_half2_low(b);
+  __half r2 = a2 < b2 ? get_half2_high(a) : get_half2_high(b);
+  return combine_half(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmax(const half2& a,
+                                                 const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  __half r1 = a1 > b1 ? get_half2_low(a) : get_half2_low(b);
+  __half r2 = a2 > b2 ? get_half2_high(a) : get_half2_high(b);
+  return combine_half(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux(const half2& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hadd(__low2half(a), __high2half(a));
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return Eigen::half(__float2half(a1 + a2));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_max(const half2& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  __half first = __low2half(a);
+  __half second = __high2half(a);
+  return __hgt(first, second) ? first : second;
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return a1 > a2 ? get_half2_low(a) : get_half2_high(a);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_min(const half2& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  __half first = __low2half(a);
+  __half second = __high2half(a);
+  return __hlt(first, second) ? first : second;
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return a1 < a2 ? get_half2_low(a) : get_half2_high(a);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_mul(const half2& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hmul(__low2half(a), __high2half(a));
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return Eigen::half(__float2half(a1 * a2));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plog1p(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = log1pf(a1);
+  float r2 = log1pf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pexpm1(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = expm1f(a1);
+  float r2 = expm1f(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+#if (EIGEN_CUDA_SDK_VER >= 80000 && defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)) || \
+  defined(EIGEN_HIP_DEVICE_COMPILE)
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+half2 plog(const half2& a) {
+  return h2log(a);
+}
+
+ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+half2 pexp(const half2& a) {
+  return h2exp(a);
+}
+
+ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+half2 psqrt(const half2& a) {
+  return h2sqrt(a);
+}
+
+ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+half2 prsqrt(const half2& a) {
+  return h2rsqrt(a);
+}
+
+#else
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plog(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = logf(a1);
+  float r2 = logf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pexp(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = expf(a1);
+  float r2 = expf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 psqrt(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = sqrtf(a1);
+  float r2 = sqrtf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 prsqrt(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = rsqrtf(a1);
+  float r2 = rsqrtf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+#endif
+} // namespace
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pload<Packet4h2>(const Eigen::half* from) {
+  return *reinterpret_cast<const Packet4h2*>(from);
+}
+
+// unaligned load;
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+ploadu<Packet4h2>(const Eigen::half* from) {
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = ploadu(from + 0);
+  p_alias[1] = ploadu(from + 2);
+  p_alias[2] = ploadu(from + 4);
+  p_alias[3] = ploadu(from + 6);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+ploaddup<Packet4h2>(const Eigen::half* from) {
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = ploaddup(from + 0);
+  p_alias[1] = ploaddup(from + 1);
+  p_alias[2] = ploaddup(from + 2);
+  p_alias[3] = ploaddup(from + 3);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore<Eigen::half>(
+    Eigen::half* to, const Packet4h2& from) {
+  *reinterpret_cast<Packet4h2*>(to) = from;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(
+    Eigen::half* to, const Packet4h2& from) {
+  const half2* from_alias = reinterpret_cast<const half2*>(&from);
+  pstoreu(to + 0,from_alias[0]);
+  pstoreu(to + 2,from_alias[1]);
+  pstoreu(to + 4,from_alias[2]);
+  pstoreu(to + 6,from_alias[3]);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet4h2
+ploadt_ro<Packet4h2, Aligned>(const Eigen::half* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  Packet4h2 r;
+  r = __ldg(reinterpret_cast<const Packet4h2*>(from));
+  return r;
+#else
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  r_alias[0] = ploadt_ro_aligned(from + 0);
+  r_alias[1] = ploadt_ro_aligned(from + 2);
+  r_alias[2] = ploadt_ro_aligned(from + 4);
+  r_alias[3] = ploadt_ro_aligned(from + 6);
+  return r;
+#endif
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet4h2
+ploadt_ro<Packet4h2, Unaligned>(const Eigen::half* from) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  r_alias[0] = ploadt_ro_unaligned(from + 0);
+  r_alias[1] = ploadt_ro_unaligned(from + 2);
+  r_alias[2] = ploadt_ro_unaligned(from + 4);
+  r_alias[3] = ploadt_ro_unaligned(from + 6);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pgather<Eigen::half, Packet4h2>(const Eigen::half* from, Index stride) {
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = combine_half(from[0 * stride], from[1 * stride]);
+  p_alias[1] = combine_half(from[2 * stride], from[3 * stride]);
+  p_alias[2] = combine_half(from[4 * stride], from[5 * stride]);
+  p_alias[3] = combine_half(from[6 * stride], from[7 * stride]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet4h2>(
+    Eigen::half* to, const Packet4h2& from, Index stride) {
+  const half2* from_alias = reinterpret_cast<const half2*>(&from);
+  pscatter(to + stride * 0, from_alias[0], stride);
+  pscatter(to + stride * 2, from_alias[1], stride);
+  pscatter(to + stride * 4, from_alias[2], stride);
+  pscatter(to + stride * 6, from_alias[3], stride);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half pfirst<Packet4h2>(
+    const Packet4h2& a) {
+  return pfirst(*(reinterpret_cast<const half2*>(&a)));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pabs<Packet4h2>(
+    const Packet4h2& a) {
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  p_alias[0] = pabs(a_alias[0]);
+  p_alias[1] = pabs(a_alias[1]);
+  p_alias[2] = pabs(a_alias[2]);
+  p_alias[3] = pabs(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 ptrue<Packet4h2>(
+    const Packet4h2& /*a*/) {
+  half true_half = half_impl::raw_uint16_to_half(0xffffu);
+  return pset1<Packet4h2>(true_half);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pzero<Packet4h2>(const Packet4h2& /*a*/) {
+  half false_half = half_impl::raw_uint16_to_half(0x0000u);
+  return pset1<Packet4h2>(false_half);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose_double(
+    double* d_row0, double* d_row1, double* d_row2, double* d_row3,
+    double* d_row4, double* d_row5, double* d_row6, double* d_row7) {
+  double d_tmp;
+  d_tmp = d_row0[1];
+  d_row0[1] = d_row4[0];
+  d_row4[0] = d_tmp;
+
+  d_tmp = d_row1[1];
+  d_row1[1] = d_row5[0];
+  d_row5[0] = d_tmp;
+
+  d_tmp = d_row2[1];
+  d_row2[1] = d_row6[0];
+  d_row6[0] = d_tmp;
+
+  d_tmp = d_row3[1];
+  d_row3[1] = d_row7[0];
+  d_row7[0] = d_tmp;
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose_half2(
+    half2* f_row0, half2* f_row1, half2* f_row2, half2* f_row3) {
+  half2 f_tmp;
+  f_tmp = f_row0[1];
+  f_row0[1] = f_row2[0];
+  f_row2[0] = f_tmp;
+
+  f_tmp = f_row1[1];
+  f_row1[1] = f_row3[0];
+  f_row3[0] = f_tmp;
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose_half(half2& f0, half2& f1) {
+  __half a1 = get_half2_low(f0);
+  __half a2 = get_half2_high(f0);
+  __half b1 = get_half2_low(f1);
+  __half b2 = get_half2_high(f1);
+  f0 = combine_half(a1, b1);
+  f1 = combine_half(a2, b2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet4h2,8>& kernel) {
+  double* d_row0 = reinterpret_cast<double*>(&kernel.packet[0]);
+  double* d_row1 = reinterpret_cast<double*>(&kernel.packet[1]);
+  double* d_row2 = reinterpret_cast<double*>(&kernel.packet[2]);
+  double* d_row3 = reinterpret_cast<double*>(&kernel.packet[3]);
+  double* d_row4 = reinterpret_cast<double*>(&kernel.packet[4]);
+  double* d_row5 = reinterpret_cast<double*>(&kernel.packet[5]);
+  double* d_row6 = reinterpret_cast<double*>(&kernel.packet[6]);
+  double* d_row7 = reinterpret_cast<double*>(&kernel.packet[7]);
+  ptranspose_double(d_row0, d_row1, d_row2, d_row3,
+                    d_row4, d_row5, d_row6, d_row7);
+
+
+  half2* f_row0 = reinterpret_cast<half2*>(d_row0);
+  half2* f_row1 = reinterpret_cast<half2*>(d_row1);
+  half2* f_row2 = reinterpret_cast<half2*>(d_row2);
+  half2* f_row3 = reinterpret_cast<half2*>(d_row3);
+  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
+  ptranspose_half(f_row0[0], f_row1[0]);
+  ptranspose_half(f_row0[1], f_row1[1]);
+  ptranspose_half(f_row2[0], f_row3[0]);
+  ptranspose_half(f_row2[1], f_row3[1]);
+
+  f_row0 = reinterpret_cast<half2*>(d_row0 + 1);
+  f_row1 = reinterpret_cast<half2*>(d_row1 + 1);
+  f_row2 = reinterpret_cast<half2*>(d_row2 + 1);
+  f_row3 = reinterpret_cast<half2*>(d_row3 + 1);
+  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
+  ptranspose_half(f_row0[0], f_row1[0]);
+  ptranspose_half(f_row0[1], f_row1[1]);
+  ptranspose_half(f_row2[0], f_row3[0]);
+  ptranspose_half(f_row2[1], f_row3[1]);
+
+  f_row0 = reinterpret_cast<half2*>(d_row4);
+  f_row1 = reinterpret_cast<half2*>(d_row5);
+  f_row2 = reinterpret_cast<half2*>(d_row6);
+  f_row3 = reinterpret_cast<half2*>(d_row7);
+  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
+  ptranspose_half(f_row0[0], f_row1[0]);
+  ptranspose_half(f_row0[1], f_row1[1]);
+  ptranspose_half(f_row2[0], f_row3[0]);
+  ptranspose_half(f_row2[1], f_row3[1]);
+
+  f_row0 = reinterpret_cast<half2*>(d_row4 + 1);
+  f_row1 = reinterpret_cast<half2*>(d_row5 + 1);
+  f_row2 = reinterpret_cast<half2*>(d_row6 + 1);
+  f_row3 = reinterpret_cast<half2*>(d_row7 + 1);
+  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
+  ptranspose_half(f_row0[0], f_row1[0]);
+  ptranspose_half(f_row0[1], f_row1[1]);
+  ptranspose_half(f_row2[0], f_row3[0]);
+  ptranspose_half(f_row2[1], f_row3[1]);
+
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+plset<Packet4h2>(const Eigen::half& a) {
+#if defined(EIGEN_HIP_DEVICE_COMPILE)
+
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = __halves2half2(a, __hadd(a, __float2half(1.0f)));
+  p_alias[1] = __halves2half2(__hadd(a, __float2half(2.0f)),
+                              __hadd(a, __float2half(3.0f)));
+  p_alias[2] = __halves2half2(__hadd(a, __float2half(4.0f)),
+                              __hadd(a, __float2half(5.0f)));
+  p_alias[3] = __halves2half2(__hadd(a, __float2half(6.0f)),
+                              __hadd(a, __float2half(7.0f)));
+  return r;
+#elif defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+
+  half2 b = pset1<half2>(a);
+  half2 c;
+  half2 half_offset0 = __halves2half2(__float2half(0.0f),__float2half(2.0f));
+  half2 half_offset1 = __halves2half2(__float2half(4.0f),__float2half(6.0f));
+
+  c = __hadd2(b, half_offset0);
+  r_alias[0] = plset(__low2half(c));
+  r_alias[1] = plset(__high2half(c));
+
+  c = __hadd2(b, half_offset1);
+  r_alias[2] = plset(__low2half(c));
+  r_alias[3] = plset(__high2half(c));
+
+  return r;
+
+#else
+  float f = __half2float(a);
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = combine_half(a, __float2half(f + 1.0f));
+  p_alias[1] = combine_half(__float2half(f + 2.0f), __float2half(f + 3.0f));
+  p_alias[2] = combine_half(__float2half(f + 4.0f), __float2half(f + 5.0f));
+  p_alias[3] = combine_half(__float2half(f + 6.0f), __float2half(f + 7.0f));
+  return r;
+#endif
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pselect<Packet4h2>(const Packet4h2& mask, const Packet4h2& a,
+                   const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* mask_alias = reinterpret_cast<const half2*>(&mask);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pselect(mask_alias[0], a_alias[0], b_alias[0]);
+  r_alias[1] = pselect(mask_alias[1], a_alias[1], b_alias[1]);
+  r_alias[2] = pselect(mask_alias[2], a_alias[2], b_alias[2]);
+  r_alias[3] = pselect(mask_alias[3], a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pcmp_eq<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pcmp_eq(a_alias[0], b_alias[0]);
+  r_alias[1] = pcmp_eq(a_alias[1], b_alias[1]);
+  r_alias[2] = pcmp_eq(a_alias[2], b_alias[2]);
+  r_alias[3] = pcmp_eq(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pand<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pand(a_alias[0], b_alias[0]);
+  r_alias[1] = pand(a_alias[1], b_alias[1]);
+  r_alias[2] = pand(a_alias[2], b_alias[2]);
+  r_alias[3] = pand(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 por<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = por(a_alias[0], b_alias[0]);
+  r_alias[1] = por(a_alias[1], b_alias[1]);
+  r_alias[2] = por(a_alias[2], b_alias[2]);
+  r_alias[3] = por(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pxor<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pxor(a_alias[0], b_alias[0]);
+  r_alias[1] = pxor(a_alias[1], b_alias[1]);
+  r_alias[2] = pxor(a_alias[2], b_alias[2]);
+  r_alias[3] = pxor(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pandnot<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pandnot(a_alias[0], b_alias[0]);
+  r_alias[1] = pandnot(a_alias[1], b_alias[1]);
+  r_alias[2] = pandnot(a_alias[2], b_alias[2]);
+  r_alias[3] = pandnot(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 padd<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = padd(a_alias[0], b_alias[0]);
+  r_alias[1] = padd(a_alias[1], b_alias[1]);
+  r_alias[2] = padd(a_alias[2], b_alias[2]);
+  r_alias[3] = padd(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 psub<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = psub(a_alias[0], b_alias[0]);
+  r_alias[1] = psub(a_alias[1], b_alias[1]);
+  r_alias[2] = psub(a_alias[2], b_alias[2]);
+  r_alias[3] = psub(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pnegate(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = pnegate(a_alias[0]);
+  r_alias[1] = pnegate(a_alias[1]);
+  r_alias[2] = pnegate(a_alias[2]);
+  r_alias[3] = pnegate(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pconj(const Packet4h2& a) {
+  return a;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmul<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pmul(a_alias[0], b_alias[0]);
+  r_alias[1] = pmul(a_alias[1], b_alias[1]);
+  r_alias[2] = pmul(a_alias[2], b_alias[2]);
+  r_alias[3] = pmul(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmadd<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b, const Packet4h2& c) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  const half2* c_alias = reinterpret_cast<const half2*>(&c);
+  r_alias[0] = pmadd(a_alias[0], b_alias[0], c_alias[0]);
+  r_alias[1] = pmadd(a_alias[1], b_alias[1], c_alias[1]);
+  r_alias[2] = pmadd(a_alias[2], b_alias[2], c_alias[2]);
+  r_alias[3] = pmadd(a_alias[3], b_alias[3], c_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pdiv<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pdiv(a_alias[0], b_alias[0]);
+  r_alias[1] = pdiv(a_alias[1], b_alias[1]);
+  r_alias[2] = pdiv(a_alias[2], b_alias[2]);
+  r_alias[3] = pdiv(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmin<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pmin(a_alias[0], b_alias[0]);
+  r_alias[1] = pmin(a_alias[1], b_alias[1]);
+  r_alias[2] = pmin(a_alias[2], b_alias[2]);
+  r_alias[3] = pmin(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmax<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pmax(a_alias[0], b_alias[0]);
+  r_alias[1] = pmax(a_alias[1], b_alias[1]);
+  r_alias[2] = pmax(a_alias[2], b_alias[2]);
+  r_alias[3] = pmax(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux<Packet4h2>(
+    const Packet4h2& a) {
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+
+  return predux(a_alias[0]) + predux(a_alias[1]) +
+         predux(a_alias[2]) + predux(a_alias[3]);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_max<Packet4h2>(
+    const Packet4h2& a) {
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  half2 m0 = combine_half(predux_max(a_alias[0]),
+                            predux_max(a_alias[1]));
+  half2 m1 = combine_half(predux_max(a_alias[2]),
+                            predux_max(a_alias[3]));
+  __half first  = predux_max(m0);
+  __half second = predux_max(m1);
+#if defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
+  return (__hgt(first, second) ? first : second);
+#else
+  float ffirst  = __half2float(first);
+  float fsecond = __half2float(second);
+  return (ffirst > fsecond)? first: second;
+#endif
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_min<Packet4h2>(
+    const Packet4h2& a) {
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  half2 m0 = combine_half(predux_min(a_alias[0]),
+                            predux_min(a_alias[1]));
+  half2 m1 = combine_half(predux_min(a_alias[2]),
+                            predux_min(a_alias[3]));
+  __half first  = predux_min(m0);
+  __half second = predux_min(m1);
+#if defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
+  return (__hlt(first, second) ? first : second);
+#else
+  float ffirst  = __half2float(first);
+  float fsecond = __half2float(second);
+  return (ffirst < fsecond)? first: second;
+#endif
+}
+
+// likely overflow/underflow
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet4h2>(
+    const Packet4h2& a) {
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  return predux_mul(pmul(pmul(a_alias[0], a_alias[1]),
+                                       pmul(a_alias[2], a_alias[3])));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+plog1p<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = plog1p(a_alias[0]);
+  r_alias[1] = plog1p(a_alias[1]);
+  r_alias[2] = plog1p(a_alias[2]);
+  r_alias[3] = plog1p(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pexpm1<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = pexpm1(a_alias[0]);
+  r_alias[1] = pexpm1(a_alias[1]);
+  r_alias[2] = pexpm1(a_alias[2]);
+  r_alias[3] = pexpm1(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 plog<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = plog(a_alias[0]);
+  r_alias[1] = plog(a_alias[1]);
+  r_alias[2] = plog(a_alias[2]);
+  r_alias[3] = plog(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pexp<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = pexp(a_alias[0]);
+  r_alias[1] = pexp(a_alias[1]);
+  r_alias[2] = pexp(a_alias[2]);
+  r_alias[3] = pexp(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 psqrt<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = psqrt(a_alias[0]);
+  r_alias[1] = psqrt(a_alias[1]);
+  r_alias[2] = psqrt(a_alias[2]);
+  r_alias[3] = psqrt(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+prsqrt<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = prsqrt(a_alias[0]);
+  r_alias[1] = prsqrt(a_alias[1]);
+  r_alias[2] = prsqrt(a_alias[2]);
+  r_alias[3] = prsqrt(a_alias[3]);
+  return r;
+}
+
+// The following specialized padd, pmul, pdiv, pmin, pmax, pset1 are needed for
+// the implementation of GPU half reduction.
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 padd<half2>(const half2& a,
+                                                        const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hadd2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 + b1;
+  float r2 = a2 + b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmul<half2>(const half2& a,
+                                                        const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hmul2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 * b1;
+  float r2 = a2 * b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pdiv<half2>(const half2& a,
+                                                        const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __h2div(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 / b1;
+  float r2 = a2 / b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmin<half2>(const half2& a,
+                                                        const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  __half r1 = a1 < b1 ? get_half2_low(a) : get_half2_low(b);
+  __half r2 = a2 < b2 ? get_half2_high(a) : get_half2_high(b);
+  return combine_half(r1, r2);
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmax<half2>(const half2& a,
+                                                        const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  __half r1 = a1 > b1 ? get_half2_low(a) : get_half2_low(b);
+  __half r2 = a2 > b2 ? get_half2_high(a) : get_half2_high(b);
+  return combine_half(r1, r2);
+}
+
+// #endif // defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIPCC) || (defined(EIGEN_CUDACC) && EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC)
+
+#endif // defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)
+
+#undef EIGEN_GPU_HAS_LDG
+#undef EIGEN_CUDA_HAS_FP16_ARITHMETIC
+#undef EIGEN_GPU_HAS_FP16_ARITHMETIC
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+
+#endif // EIGEN_PACKET_MATH_GPU_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/GPU/TypeCasting.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/GPU/TypeCasting.h
new file mode 100644
index 00000000..75454622
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/GPU/TypeCasting.h
@@ -0,0 +1,80 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_GPU_H
+#define EIGEN_TYPE_CASTING_GPU_H
+
+namespace Eigen {
+
+namespace internal {
+
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+
+
+template <>
+struct type_casting_traits<Eigen::half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 2
+  };
+};
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcast<half2, float4>(const half2& a, const half2& b) {
+  float2 r1 = __half22float2(a);
+  float2 r2 = __half22float2(b);
+  return make_float4(r1.x, r1.y, r2.x, r2.y);
+}
+
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pcast<float4, Packet4h2>(const float4& a, const float4& b) {
+  Packet4h2 r;
+  half2* r_alias=reinterpret_cast<half2*>(&r);
+  r_alias[0]=__floats2half2_rn(a.x,a.y);
+  r_alias[1]=__floats2half2_rn(a.z,a.w);
+  r_alias[2]=__floats2half2_rn(b.x,b.y);
+  r_alias[3]=__floats2half2_rn(b.z,b.w);
+  return r;
+}
+
+template <>
+struct type_casting_traits<float, Eigen::half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 2,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcast<Packet4h2, float4>(const Packet4h2& a) {
+  // Simply discard the second half of the input
+  float4 r;
+  const half2* a_alias=reinterpret_cast<const half2*>(&a);
+  float2 r1 = __half22float2(a_alias[0]);
+  float2 r2 = __half22float2(a_alias[1]);
+  r.x=static_cast<float>(r1.x);
+  r.y=static_cast<float>(r1.y);
+  r.z=static_cast<float>(r2.x);
+  r.w=static_cast<float>(r2.y);
+  return r;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcast<float4, half2>(const float4& a) {
+  // Simply discard the second half of the input
+  return __floats2half2_rn(a.x, a.y);
+}
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_GPU_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/HIP/hcc/math_constants.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
new file mode 100644
index 00000000..25375a0a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
@@ -0,0 +1,23 @@
+/*
+ * math_constants.h - 
+ *  HIP equivalent of the CUDA header of the same name
+ */
+
+#ifndef __MATH_CONSTANTS_H__
+#define __MATH_CONSTANTS_H__
+
+/* single precision constants */
+
+#define HIPRT_INF_F        __int_as_float(0x7f800000)
+#define HIPRT_NAN_F        __int_as_float(0x7fffffff)
+#define HIPRT_MIN_DENORM_F __int_as_float(0x00000001)
+#define HIPRT_MAX_NORMAL_F __int_as_float(0x7f7fffff)
+#define HIPRT_NEG_ZERO_F   __int_as_float(0x80000000)
+#define HIPRT_ZERO_F       0.0f
+#define HIPRT_ONE_F        1.0f
+
+/* double precision constants */
+#define HIPRT_INF          __hiloint2double(0x7ff00000, 0x00000000)
+#define HIPRT_NAN          __hiloint2double(0xfff80000, 0x00000000)
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/MSA/Complex.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/MSA/Complex.h
new file mode 100644
index 00000000..53dacfa4
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/MSA/Complex.h
@@ -0,0 +1,648 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Wave Computing, Inc.
+// Written by:
+//   Chris Larsen
+//   Alexey Frunze (afrunze@wavecomp.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_MSA_H
+#define EIGEN_COMPLEX_MSA_H
+
+#include <iostream>
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- float ----------
+struct Packet2cf {
+  EIGEN_STRONG_INLINE Packet2cf() {
+  }
+  EIGEN_STRONG_INLINE explicit Packet2cf(const std::complex<float>& a,
+                                         const std::complex<float>& b) {
+    Packet4f t = { std::real(a), std::imag(a), std::real(b), std::imag(b) };
+    v = t;
+  }
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {
+  }
+  EIGEN_STRONG_INLINE Packet2cf(const Packet2cf& a) : v(a.v) {
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator=(const Packet2cf& b) {
+    v = b.v;
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf conjugate(void) const {
+    return Packet2cf((Packet4f)__builtin_msa_bnegi_d((v2u64)v, 63));
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator*=(const Packet2cf& b) {
+    Packet4f v1, v2;
+
+    // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
+    v1 = (Packet4f)__builtin_msa_ilvev_w((v4i32)v, (v4i32)v);
+    // Get the imag values of a | a1_im | a1_im | a2_im | a2_im |
+    v2 = (Packet4f)__builtin_msa_ilvod_w((v4i32)v, (v4i32)v);
+    // Multiply the real a with b
+    v1 = pmul(v1, b.v);
+    // Multiply the imag a with b
+    v2 = pmul(v2, b.v);
+    // Conjugate v2
+    v2 = Packet2cf(v2).conjugate().v;
+    // Swap real/imag elements in v2.
+    v2 = (Packet4f)__builtin_msa_shf_w((v4i32)v2, EIGEN_MSA_SHF_I8(1, 0, 3, 2));
+    // Add and return the result
+    v = padd(v1, v2);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator*(const Packet2cf& b) const {
+    return Packet2cf(*this) *= b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator+=(const Packet2cf& b) {
+    v = padd(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator+(const Packet2cf& b) const {
+    return Packet2cf(*this) += b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator-=(const Packet2cf& b) {
+    v = psub(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator-(const Packet2cf& b) const {
+    return Packet2cf(*this) -= b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator/=(const Packet2cf& b) {
+    *this *= b.conjugate();
+    Packet4f s = pmul<Packet4f>(b.v, b.v);
+    s = padd(s, (Packet4f)__builtin_msa_shf_w((v4i32)s, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+    v = pdiv(v, s);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator/(const Packet2cf& b) const {
+    return Packet2cf(*this) /= b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator-(void) const {
+    return Packet2cf(pnegate(v));
+  }
+
+  Packet4f v;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const Packet2cf& value) {
+  os << "[ (" << value.v[0] << ", " << value.v[1]
+     << "i),"
+        "  ("
+     << value.v[2] << ", " << value.v[3] << "i) ]";
+  return os;
+}
+
+template <>
+struct packet_traits<std::complex<float> > : default_packet_traits {
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasSetLinear = 0,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct unpacket_traits<Packet2cf> {
+  typedef std::complex<float> type;
+  enum { size = 2, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
+  typedef Packet2cf half;
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>& from) {
+  EIGEN_MSA_DEBUG;
+
+  float f0 = from.real(), f1 = from.imag();
+  Packet4f v0 = { f0, f0, f0, f0 };
+  Packet4f v1 = { f1, f1, f1, f1 };
+  return Packet2cf((Packet4f)__builtin_msa_ilvr_w((Packet4i)v1, (Packet4i)v0));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a + b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a - b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return -a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a.conjugate();
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a * b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pand<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf(pand(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf por<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf(por(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pxor<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf(pxor(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf(pandnot(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pload<Packet2cf>(const std::complex<float>* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from) {
+  EIGEN_MSA_DEBUG;
+
+  return pset1<Packet2cf>(*from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<float> >(std::complex<float>* to,
+                                                      const Packet2cf& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_STORE pstore<float>((float*)to, from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float>* to,
+                                                       const Packet2cf& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<float>((float*)to, from.v);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(
+    const std::complex<float>* from, Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf(from[0 * stride], from[1 * stride]);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to,
+                                                                       const Packet2cf& from,
+                                                                       Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  *to = std::complex<float>(from.v[0], from.v[1]);
+  to += stride;
+  *to = std::complex<float>(from.v[2], from.v[3]);
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float>* addr) {
+  EIGEN_MSA_DEBUG;
+
+  prefetch(reinterpret_cast<const float*>(addr));
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return std::complex<float>(a.v[0], a.v[1]);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf((Packet4f)__builtin_msa_shf_w((v4i32)a.v, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf((Packet4f)__builtin_msa_shf_w((v4i32)a.v, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4f value = (Packet4f)preverse((Packet2d)a.v);
+  value += a.v;
+  return std::complex<float>(value[0], value[1]);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return std::complex<float>((a.v[0] * a.v[2]) - (a.v[1] * a.v[3]),
+                             (a.v[0] * a.v[3]) + (a.v[1] * a.v[2]));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf, Packet4f)
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a / b;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet2cf, 2>& value) {
+  os << "[ " << value.packet[0] << ", " << std::endl << "  " << value.packet[1] << " ]";
+  return os;
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2cf, 2>& kernel) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4f tmp =
+      (Packet4f)__builtin_msa_ilvl_d((v2i64)kernel.packet[1].v, (v2i64)kernel.packet[0].v);
+  kernel.packet[0].v =
+      (Packet4f)__builtin_msa_ilvr_d((v2i64)kernel.packet[1].v, (v2i64)kernel.packet[0].v);
+  kernel.packet[1].v = tmp;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket,
+                                     const Packet2cf& elsePacket) {
+  return (Packet2cf)(Packet4f)pblend<Packet2d>(ifPacket, (Packet2d)thenPacket.v,
+                                               (Packet2d)elsePacket.v);
+}
+
+//---------- double ----------
+
+struct Packet1cd {
+  EIGEN_STRONG_INLINE Packet1cd() {
+  }
+  EIGEN_STRONG_INLINE explicit Packet1cd(const std::complex<double>& a) {
+    v[0] = std::real(a);
+    v[1] = std::imag(a);
+  }
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {
+  }
+  EIGEN_STRONG_INLINE Packet1cd(const Packet1cd& a) : v(a.v) {
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator=(const Packet1cd& b) {
+    v = b.v;
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd conjugate(void) const {
+    static const v2u64 p2ul_CONJ_XOR = { 0x0, 0x8000000000000000 };
+    return (Packet1cd)pxor(v, (Packet2d)p2ul_CONJ_XOR);
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator*=(const Packet1cd& b) {
+    Packet2d v1, v2;
+
+    // Get the real values of a | a1_re | a1_re
+    v1 = (Packet2d)__builtin_msa_ilvev_d((v2i64)v, (v2i64)v);
+    // Get the imag values of a | a1_im | a1_im
+    v2 = (Packet2d)__builtin_msa_ilvod_d((v2i64)v, (v2i64)v);
+    // Multiply the real a with b
+    v1 = pmul(v1, b.v);
+    // Multiply the imag a with b
+    v2 = pmul(v2, b.v);
+    // Conjugate v2
+    v2 = Packet1cd(v2).conjugate().v;
+    // Swap real/imag elements in v2.
+    v2 = (Packet2d)__builtin_msa_shf_w((v4i32)v2, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+    // Add and return the result
+    v = padd(v1, v2);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator*(const Packet1cd& b) const {
+    return Packet1cd(*this) *= b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator+=(const Packet1cd& b) {
+    v = padd(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator+(const Packet1cd& b) const {
+    return Packet1cd(*this) += b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator-=(const Packet1cd& b) {
+    v = psub(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator-(const Packet1cd& b) const {
+    return Packet1cd(*this) -= b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator/=(const Packet1cd& b) {
+    *this *= b.conjugate();
+    Packet2d s = pmul<Packet2d>(b.v, b.v);
+    s = padd(s, preverse<Packet2d>(s));
+    v = pdiv(v, s);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator/(const Packet1cd& b) const {
+    return Packet1cd(*this) /= b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator-(void) const {
+    return Packet1cd(pnegate(v));
+  }
+
+  Packet2d v;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const Packet1cd& value) {
+  os << "[ (" << value.v[0] << ", " << value.v[1] << "i) ]";
+  return os;
+}
+
+template <>
+struct packet_traits<std::complex<double> > : default_packet_traits {
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasSetLinear = 0
+  };
+};
+
+template <>
+struct unpacket_traits<Packet1cd> {
+  typedef std::complex<double> type;
+  enum { size = 1, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
+  typedef Packet1cd half;
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pload<Packet1cd>(const std::complex<double>* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>& from) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a + b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a - b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return -a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a.conjugate();
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a * b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pand<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(pand(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd por<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(por(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pxor<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(pxor(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(pandnot(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) {
+  EIGEN_MSA_DEBUG;
+
+  return pset1<Packet1cd>(*from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<double> >(std::complex<double>* to,
+                                                       const Packet1cd& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_STORE pstore<double>((double*)to, from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double>* to,
+                                                        const Packet1cd& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<double>((double*)to, from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double>* addr) {
+  EIGEN_MSA_DEBUG;
+
+  prefetch(reinterpret_cast<const double*>(addr));
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(
+    const std::complex<double>* from, Index stride __attribute__((unused))) {
+  EIGEN_MSA_DEBUG;
+
+  Packet1cd res;
+  res.v[0] = std::real(from[0]);
+  res.v[1] = std::imag(from[0]);
+  return res;
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to,
+                                                                        const Packet1cd& from,
+                                                                        Index stride
+                                                                        __attribute__((unused))) {
+  EIGEN_MSA_DEBUG;
+
+  pstore(to, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet1cd>(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return std::complex<double>(a.v[0], a.v[1]);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return pfirst(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return pfirst(a);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd, Packet2d)
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a / b;
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip /*<Packet1cd>*/ (const Packet1cd& x) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet1cd, 2>& value) {
+  os << "[ " << value.packet[0] << ", " << std::endl << "  " << value.packet[1] << " ]";
+  return os;
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd, 2>& kernel) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d v1, v2;
+
+  v1 = (Packet2d)__builtin_msa_ilvev_d((v2i64)kernel.packet[0].v, (v2i64)kernel.packet[1].v);
+  // Get the imag values of a
+  v2 = (Packet2d)__builtin_msa_ilvod_d((v2i64)kernel.packet[0].v, (v2i64)kernel.packet[1].v);
+
+  kernel.packet[0].v = v1;
+  kernel.packet[1].v = v2;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_COMPLEX_MSA_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/MSA/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/MSA/MathFunctions.h
new file mode 100644
index 00000000..f5181b90
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/MSA/MathFunctions.h
@@ -0,0 +1,387 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// Copyright (C) 2018 Wave Computing, Inc.
+// Written by:
+//   Chris Larsen
+//   Alexey Frunze (afrunze@wavecomp.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The sin, cos, exp, and log functions of this file come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+/* The tanh function of this file is an adaptation of
+ * template<typename T> T generic_fast_tanh_float(const T&)
+ * from MathFunctionsImpl.h.
+ */
+
+#ifndef EIGEN_MATH_FUNCTIONS_MSA_H
+#define EIGEN_MATH_FUNCTIONS_MSA_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+plog<Packet4f>(const Packet4f& _x) {
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_SQRTHF, 0.707106781186547524f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p0, 7.0376836292e-2f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p1, -1.1514610310e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p2, 1.1676998740e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p3, -1.2420140846e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p4, +1.4249322787e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p5, -1.6668057665e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p6, +2.0000714765e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p7, -2.4999993993e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p8, +3.3333331174e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q1, -2.12194440e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q2, 0.693359375f);
+  static _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+  static _EIGEN_DECLARE_CONST_Packet4f(1, 1.0f);
+
+  // Convert negative argument into NAN (quiet negative, to be specific).
+  Packet4f zero = (Packet4f)__builtin_msa_ldi_w(0);
+  Packet4i neg_mask = __builtin_msa_fclt_w(_x, zero);
+  Packet4i zero_mask = __builtin_msa_fceq_w(_x, zero);
+  Packet4f non_neg_x_or_nan = padd(_x, (Packet4f)neg_mask);  // Add 0.0 or NAN.
+  Packet4f x = non_neg_x_or_nan;
+
+  // Extract exponent from x = mantissa * 2**exponent, where 1.0 <= mantissa < 2.0.
+  // N.B. the exponent is one less of what frexpf() would return.
+  Packet4i e_int = __builtin_msa_ftint_s_w(__builtin_msa_flog2_w(x));
+  // Multiply x by 2**(-exponent-1) to get 0.5 <= x < 1.0 as from frexpf().
+  x = __builtin_msa_fexp2_w(x, (Packet4i)__builtin_msa_nori_b((v16u8)e_int, 0));
+
+  /*
+     if (x < SQRTHF) {
+       x = x + x - 1.0;
+     } else {
+       e += 1;
+       x = x - 1.0;
+     }
+  */
+  Packet4f xx = padd(x, x);
+  Packet4i ge_mask = __builtin_msa_fcle_w(p4f_cephes_SQRTHF, x);
+  e_int = psub(e_int, ge_mask);
+  x = (Packet4f)__builtin_msa_bsel_v((v16u8)ge_mask, (v16u8)xx, (v16u8)x);
+  x = psub(x, p4f_1);
+  Packet4f e = __builtin_msa_ffint_s_w(e_int);
+
+  Packet4f x2 = pmul(x, x);
+  Packet4f x3 = pmul(x2, x);
+
+  Packet4f y, y1, y2;
+  y = pmadd(p4f_cephes_log_p0, x, p4f_cephes_log_p1);
+  y1 = pmadd(p4f_cephes_log_p3, x, p4f_cephes_log_p4);
+  y2 = pmadd(p4f_cephes_log_p6, x, p4f_cephes_log_p7);
+  y = pmadd(y, x, p4f_cephes_log_p2);
+  y1 = pmadd(y1, x, p4f_cephes_log_p5);
+  y2 = pmadd(y2, x, p4f_cephes_log_p8);
+  y = pmadd(y, x3, y1);
+  y = pmadd(y, x3, y2);
+  y = pmul(y, x3);
+
+  y = pmadd(e, p4f_cephes_log_q1, y);
+  x = __builtin_msa_fmsub_w(x, x2, p4f_half);
+  x = padd(x, y);
+  x = pmadd(e, p4f_cephes_log_q2, x);
+
+  // x is now the logarithm result candidate. We still need to handle the
+  // extreme arguments of zero and positive infinity, though.
+  // N.B. if the argument is +INFINITY, x is NAN because the polynomial terms
+  // contain infinities of both signs (see the coefficients and code above).
+  // INFINITY - INFINITY is NAN.
+
+  // If the argument is +INFINITY, make it the new result candidate.
+  // To achieve that we choose the smaller of the result candidate and the
+  // argument.
+  // This is correct for all finite pairs of values (the logarithm is smaller
+  // than the argument).
+  // This is also correct in the special case when the argument is +INFINITY
+  // and the result candidate is NAN. This is because the fmin.df instruction
+  // prefers non-NANs to NANs.
+  x = __builtin_msa_fmin_w(x, non_neg_x_or_nan);
+
+  // If the argument is zero (including -0.0), the result becomes -INFINITY.
+  Packet4i neg_infs = __builtin_msa_slli_w(zero_mask, 23);
+  x = (Packet4f)__builtin_msa_bsel_v((v16u8)zero_mask, (v16u8)x, (v16u8)neg_infs);
+
+  return x;
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+pexp<Packet4f>(const Packet4f& _x) {
+  // Limiting single-precision pexp's argument to [-128, +128] lets pexp
+  // reach 0 and INFINITY naturally.
+  static _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -128.0f);
+  static _EIGEN_DECLARE_CONST_Packet4f(exp_hi, +128.0f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894e-2f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+  static _EIGEN_DECLARE_CONST_Packet4f(1, 1.0f);
+
+  Packet4f x = _x;
+
+  // Clamp x.
+  x = (Packet4f)__builtin_msa_bsel_v((v16u8)__builtin_msa_fclt_w(x, p4f_exp_lo), (v16u8)x,
+                                     (v16u8)p4f_exp_lo);
+  x = (Packet4f)__builtin_msa_bsel_v((v16u8)__builtin_msa_fclt_w(p4f_exp_hi, x), (v16u8)x,
+                                     (v16u8)p4f_exp_hi);
+
+  // Round to nearest integer by adding 0.5 (with x's sign) and truncating.
+  Packet4f x2_add = (Packet4f)__builtin_msa_binsli_w((v4u32)p4f_half, (v4u32)x, 0);
+  Packet4f x2 = pmadd(x, p4f_cephes_LOG2EF, x2_add);
+  Packet4i x2_int = __builtin_msa_ftrunc_s_w(x2);
+  Packet4f x2_int_f = __builtin_msa_ffint_s_w(x2_int);
+
+  x = __builtin_msa_fmsub_w(x, x2_int_f, p4f_cephes_exp_C1);
+  x = __builtin_msa_fmsub_w(x, x2_int_f, p4f_cephes_exp_C2);
+
+  Packet4f z = pmul(x, x);
+
+  Packet4f y = p4f_cephes_exp_p0;
+  y = pmadd(y, x, p4f_cephes_exp_p1);
+  y = pmadd(y, x, p4f_cephes_exp_p2);
+  y = pmadd(y, x, p4f_cephes_exp_p3);
+  y = pmadd(y, x, p4f_cephes_exp_p4);
+  y = pmadd(y, x, p4f_cephes_exp_p5);
+  y = pmadd(y, z, x);
+  y = padd(y, p4f_1);
+
+  // y *= 2**exponent.
+  y = __builtin_msa_fexp2_w(y, x2_int);
+
+  return y;
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+ptanh<Packet4f>(const Packet4f& _x) {
+  static _EIGEN_DECLARE_CONST_Packet4f(tanh_tiny, 1e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(tanh_hi, 9.0f);
+  // The monomial coefficients of the numerator polynomial (odd).
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_1, 4.89352455891786e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_3, 6.37261928875436e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_5, 1.48572235717979e-5f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_7, 5.12229709037114e-8f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_9, -8.60467152213735e-11f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_11, 2.00018790482477e-13f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_13, -2.76076847742355e-16f);
+  // The monomial coefficients of the denominator polynomial (even).
+  static _EIGEN_DECLARE_CONST_Packet4f(beta_0, 4.89352518554385e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(beta_2, 2.26843463243900e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(beta_4, 1.18534705686654e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(beta_6, 1.19825839466702e-6f);
+
+  Packet4f x = pabs(_x);
+  Packet4i tiny_mask = __builtin_msa_fclt_w(x, p4f_tanh_tiny);
+
+  // Clamp the inputs to the range [-9, 9] since anything outside
+  // this range is -/+1.0f in single-precision.
+  x = (Packet4f)__builtin_msa_bsel_v((v16u8)__builtin_msa_fclt_w(p4f_tanh_hi, x), (v16u8)x,
+                                     (v16u8)p4f_tanh_hi);
+
+  // Since the polynomials are odd/even, we need x**2.
+  Packet4f x2 = pmul(x, x);
+
+  // Evaluate the numerator polynomial p.
+  Packet4f p = pmadd(x2, p4f_alpha_13, p4f_alpha_11);
+  p = pmadd(x2, p, p4f_alpha_9);
+  p = pmadd(x2, p, p4f_alpha_7);
+  p = pmadd(x2, p, p4f_alpha_5);
+  p = pmadd(x2, p, p4f_alpha_3);
+  p = pmadd(x2, p, p4f_alpha_1);
+  p = pmul(x, p);
+
+  // Evaluate the denominator polynomial q.
+  Packet4f q = pmadd(x2, p4f_beta_6, p4f_beta_4);
+  q = pmadd(x2, q, p4f_beta_2);
+  q = pmadd(x2, q, p4f_beta_0);
+
+  // Divide the numerator by the denominator.
+  p = pdiv(p, q);
+
+  // Reinstate the sign.
+  p = (Packet4f)__builtin_msa_binsli_w((v4u32)p, (v4u32)_x, 0);
+
+  // When the argument is very small in magnitude it's more accurate to just return it.
+  p = (Packet4f)__builtin_msa_bsel_v((v16u8)tiny_mask, (v16u8)p, (v16u8)_x);
+
+  return p;
+}
+
+template <bool sine>
+Packet4f psincos_inner_msa_float(const Packet4f& _x) {
+  static _EIGEN_DECLARE_CONST_Packet4f(sincos_max_arg, 13176795.0f);  // Approx. (2**24) / (4/Pi).
+  static _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP1, -0.78515625f);
+  static _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP2, -2.4187564849853515625e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP3, -3.77489497744594108e-8f);
+  static _EIGEN_DECLARE_CONST_Packet4f(sincof_p0, -1.9515295891e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(sincof_p1, 8.3321608736e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(sincof_p2, -1.6666654611e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(coscof_p0, 2.443315711809948e-5f);
+  static _EIGEN_DECLARE_CONST_Packet4f(coscof_p1, -1.388731625493765e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(coscof_p2, 4.166664568298827e-2f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_FOPI, 1.27323954473516f);  // 4/Pi.
+  static _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+  static _EIGEN_DECLARE_CONST_Packet4f(1, 1.0f);
+
+  Packet4f x = pabs(_x);
+
+  // Translate infinite arguments into NANs.
+  Packet4f zero_or_nan_if_inf = psub(_x, _x);
+  x = padd(x, zero_or_nan_if_inf);
+  // Prevent sin/cos from generating values larger than 1.0 in magnitude
+  // for very large arguments by setting x to 0.0.
+  Packet4i small_or_nan_mask = __builtin_msa_fcult_w(x, p4f_sincos_max_arg);
+  x = pand(x, (Packet4f)small_or_nan_mask);
+
+  // Scale x by 4/Pi to find x's octant.
+  Packet4f y = pmul(x, p4f_cephes_FOPI);
+  // Get the octant. We'll reduce x by this number of octants or by one more than it.
+  Packet4i y_int = __builtin_msa_ftrunc_s_w(y);
+  // x's from even-numbered octants will translate to octant 0: [0, +Pi/4].
+  // x's from odd-numbered octants will translate to octant -1: [-Pi/4, 0].
+  // Adjustment for odd-numbered octants: octant = (octant + 1) & (~1).
+  Packet4i y_int1 = __builtin_msa_addvi_w(y_int, 1);
+  Packet4i y_int2 = (Packet4i)__builtin_msa_bclri_w((Packet4ui)y_int1, 0); // bclri = bit-clear
+  y = __builtin_msa_ffint_s_w(y_int2);
+
+  // Compute the sign to apply to the polynomial.
+  Packet4i sign_mask = sine ? pxor(__builtin_msa_slli_w(y_int1, 29), (Packet4i)_x)
+                            : __builtin_msa_slli_w(__builtin_msa_addvi_w(y_int, 3), 29);
+
+  // Get the polynomial selection mask.
+  // We'll calculate both (sin and cos) polynomials and then select from the two.
+  Packet4i poly_mask = __builtin_msa_ceqi_w(__builtin_msa_slli_w(y_int2, 30), 0);
+
+  // Reduce x by y octants to get: -Pi/4 <= x <= +Pi/4.
+  // The magic pass: "Extended precision modular arithmetic"
+  // x = ((x - y * DP1) - y * DP2) - y * DP3
+  Packet4f tmp1 = pmul(y, p4f_minus_cephes_DP1);
+  Packet4f tmp2 = pmul(y, p4f_minus_cephes_DP2);
+  Packet4f tmp3 = pmul(y, p4f_minus_cephes_DP3);
+  x = padd(x, tmp1);
+  x = padd(x, tmp2);
+  x = padd(x, tmp3);
+
+  // Evaluate the cos(x) polynomial.
+  y = p4f_coscof_p0;
+  Packet4f z = pmul(x, x);
+  y = pmadd(y, z, p4f_coscof_p1);
+  y = pmadd(y, z, p4f_coscof_p2);
+  y = pmul(y, z);
+  y = pmul(y, z);
+  y = __builtin_msa_fmsub_w(y, z, p4f_half);
+  y = padd(y, p4f_1);
+
+  // Evaluate the sin(x) polynomial.
+  Packet4f y2 = p4f_sincof_p0;
+  y2 = pmadd(y2, z, p4f_sincof_p1);
+  y2 = pmadd(y2, z, p4f_sincof_p2);
+  y2 = pmul(y2, z);
+  y2 = pmadd(y2, x, x);
+
+  // Select the correct result from the two polynomials.
+  y = sine ? (Packet4f)__builtin_msa_bsel_v((v16u8)poly_mask, (v16u8)y, (v16u8)y2)
+           : (Packet4f)__builtin_msa_bsel_v((v16u8)poly_mask, (v16u8)y2, (v16u8)y);
+
+  // Update the sign.
+  sign_mask = pxor(sign_mask, (Packet4i)y);
+  y = (Packet4f)__builtin_msa_binsli_w((v4u32)y, (v4u32)sign_mask, 0); // binsli = bit-insert-left
+  return y;
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+psin<Packet4f>(const Packet4f& x) {
+  return psincos_inner_msa_float</* sine */ true>(x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+pcos<Packet4f>(const Packet4f& x) {
+  return psincos_inner_msa_float</* sine */ false>(x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d
+pexp<Packet2d>(const Packet2d& _x) {
+  // Limiting double-precision pexp's argument to [-1024, +1024] lets pexp
+  // reach 0 and INFINITY naturally.
+  static _EIGEN_DECLARE_CONST_Packet2d(exp_lo, -1024.0);
+  static _EIGEN_DECLARE_CONST_Packet2d(exp_hi, +1024.0);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_LOG2EF, 1.4426950408889634073599);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C1, 0.693145751953125);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C2, 1.42860682030941723212e-6);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p0, 1.26177193074810590878e-4);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p1, 3.02994407707441961300e-2);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p2, 9.99999999999999999910e-1);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q0, 3.00198505138664455042e-6);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q1, 2.52448340349684104192e-3);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q2, 2.27265548208155028766e-1);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q3, 2.00000000000000000009e0);
+  static _EIGEN_DECLARE_CONST_Packet2d(half, 0.5);
+  static _EIGEN_DECLARE_CONST_Packet2d(1, 1.0);
+  static _EIGEN_DECLARE_CONST_Packet2d(2, 2.0);
+
+  Packet2d x = _x;
+
+  // Clamp x.
+  x = (Packet2d)__builtin_msa_bsel_v((v16u8)__builtin_msa_fclt_d(x, p2d_exp_lo), (v16u8)x,
+                                     (v16u8)p2d_exp_lo);
+  x = (Packet2d)__builtin_msa_bsel_v((v16u8)__builtin_msa_fclt_d(p2d_exp_hi, x), (v16u8)x,
+                                     (v16u8)p2d_exp_hi);
+
+  // Round to nearest integer by adding 0.5 (with x's sign) and truncating.
+  Packet2d x2_add = (Packet2d)__builtin_msa_binsli_d((v2u64)p2d_half, (v2u64)x, 0);
+  Packet2d x2 = pmadd(x, p2d_cephes_LOG2EF, x2_add);
+  Packet2l x2_long = __builtin_msa_ftrunc_s_d(x2);
+  Packet2d x2_long_d = __builtin_msa_ffint_s_d(x2_long);
+
+  x = __builtin_msa_fmsub_d(x, x2_long_d, p2d_cephes_exp_C1);
+  x = __builtin_msa_fmsub_d(x, x2_long_d, p2d_cephes_exp_C2);
+
+  x2 = pmul(x, x);
+
+  Packet2d px = p2d_cephes_exp_p0;
+  px = pmadd(px, x2, p2d_cephes_exp_p1);
+  px = pmadd(px, x2, p2d_cephes_exp_p2);
+  px = pmul(px, x);
+
+  Packet2d qx = p2d_cephes_exp_q0;
+  qx = pmadd(qx, x2, p2d_cephes_exp_q1);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q2);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q3);
+
+  x = pdiv(px, psub(qx, px));
+  x = pmadd(p2d_2, x, p2d_1);
+
+  // x *= 2**exponent.
+  x = __builtin_msa_fexp2_d(x, x2_long);
+
+  return x;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_MSA_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/MSA/PacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/MSA/PacketMath.h
new file mode 100644
index 00000000..afe8f337
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/MSA/PacketMath.h
@@ -0,0 +1,1233 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Wave Computing, Inc.
+// Written by:
+//   Chris Larsen
+//   Alexey Frunze (afrunze@wavecomp.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_MSA_H
+#define EIGEN_PACKET_MATH_MSA_H
+
+#include <iostream>
+#include <string>
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
+#endif
+
+#if 0
+#define EIGEN_MSA_DEBUG                                                             \
+  static bool firstTime = true;                                                     \
+  do {                                                                              \
+    if (firstTime) {                                                                \
+      std::cout << __FILE__ << ':' << __LINE__ << ':' << __FUNCTION__ << std::endl; \
+      firstTime = false;                                                            \
+    }                                                                               \
+  } while (0)
+#else
+#define EIGEN_MSA_DEBUG
+#endif
+
+#define EIGEN_MSA_SHF_I8(a, b, c, d) (((d) << 6) | ((c) << 4) | ((b) << 2) | (a))
+
+typedef v4f32 Packet4f;
+typedef v4i32 Packet4i;
+typedef v4u32 Packet4ui;
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME, X) const Packet4f p4f_##NAME = { X, X, X, X }
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME, X) const Packet4i p4i_##NAME = { X, X, X, X }
+#define _EIGEN_DECLARE_CONST_Packet4ui(NAME, X) const Packet4ui p4ui_##NAME = { X, X, X, X }
+
+inline std::ostream& operator<<(std::ostream& os, const Packet4f& value) {
+  os << "[ " << value[0] << ", " << value[1] << ", " << value[2] << ", " << value[3] << " ]";
+  return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Packet4i& value) {
+  os << "[ " << value[0] << ", " << value[1] << ", " << value[2] << ", " << value[3] << " ]";
+  return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Packet4ui& value) {
+  os << "[ " << value[0] << ", " << value[1] << ", " << value[2] << ", " << value[3] << " ]";
+  return os;
+}
+
+template <>
+struct packet_traits<float> : default_packet_traits {
+  typedef Packet4f type;
+  typedef Packet4f half;  // Packet2f intrinsics not implemented yet
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,  // Packet2f intrinsics not implemented yet
+    // FIXME check the Has*
+    HasDiv = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<int32_t> : default_packet_traits {
+  typedef Packet4i type;
+  typedef Packet4i half;  // Packet2i intrinsics not implemented yet
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,  // Packet2i intrinsics not implemented yet
+    // FIXME check the Has*
+    HasDiv = 1,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct unpacket_traits<Packet4f> {
+  typedef float type;
+  enum { size = 4, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
+  typedef Packet4f half;
+};
+
+template <>
+struct unpacket_traits<Packet4i> {
+  typedef int32_t type;
+  enum { size = 4, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
+  typedef Packet4i half;
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4f v = { from, from, from, from };
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int32_t& from) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fill_w(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pload1<Packet4f>(const float* from) {
+  EIGEN_MSA_DEBUG;
+
+  float f = *from;
+  Packet4f v = { f, f, f, f };
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pload1<Packet4i>(const int32_t* from) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fill_w(*from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fadd_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_addv_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a) {
+  EIGEN_MSA_DEBUG;
+
+  static const Packet4f countdown = { 0.0f, 1.0f, 2.0f, 3.0f };
+  return padd(pset1<Packet4f>(a), countdown);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int32_t& a) {
+  EIGEN_MSA_DEBUG;
+
+  static const Packet4i countdown = { 0, 1, 2, 3 };
+  return padd(pset1<Packet4i>(a), countdown);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fsub_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_subv_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_bnegi_w((v4u32)a, 31);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_addvi_w((v4i32)__builtin_msa_nori_b((v16u8)a, 0), 1);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fmul_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_mulv_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fdiv_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_div_s_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fmadd_w(c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) {
+  EIGEN_MSA_DEBUG;
+
+  // Use "asm" construct to avoid __builtin_msa_maddv_w GNU C bug.
+  Packet4i value = c;
+  __asm__("maddv.w %w[value], %w[a], %w[b]\n"
+          // Outputs
+          : [value] "+f"(value)
+          // Inputs
+          : [a] "f"(a), [b] "f"(b));
+  return value;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_and_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4i)__builtin_msa_and_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_or_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4i)__builtin_msa_or_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_xor_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4i)__builtin_msa_xor_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return pand(a, (Packet4f)__builtin_msa_xori_b((v16u8)b, 255));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return pand(a, (Packet4i)__builtin_msa_xori_b((v16u8)b, 255));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  // This prefers numbers to NaNs.
+  return __builtin_msa_fmin_w(a, b);
+#else
+  // This prefers NaNs to numbers.
+  Packet4i aNaN = __builtin_msa_fcun_w(a, a);
+  Packet4i aMinOrNaN = por(__builtin_msa_fclt_w(a, b), aNaN);
+  return (Packet4f)__builtin_msa_bsel_v((v16u8)aMinOrNaN, (v16u8)b, (v16u8)a);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_min_s_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  // This prefers numbers to NaNs.
+  return __builtin_msa_fmax_w(a, b);
+#else
+  // This prefers NaNs to numbers.
+  Packet4i aNaN = __builtin_msa_fcun_w(a, a);
+  Packet4i aMaxOrNaN = por(__builtin_msa_fclt_w(b, a), aNaN);
+  return (Packet4f)__builtin_msa_bsel_v((v16u8)aMaxOrNaN, (v16u8)b, (v16u8)a);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_max_s_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_LOAD return (Packet4f)__builtin_msa_ld_w(const_cast<float*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int32_t* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_LOAD return __builtin_msa_ld_w(const_cast<int32_t*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return (Packet4f)__builtin_msa_ld_w(const_cast<float*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int32_t* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return (Packet4i)__builtin_msa_ld_w(const_cast<int32_t*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float* from) {
+  EIGEN_MSA_DEBUG;
+
+  float f0 = from[0], f1 = from[1];
+  Packet4f v0 = { f0, f0, f0, f0 };
+  Packet4f v1 = { f1, f1, f1, f1 };
+  return (Packet4f)__builtin_msa_ilvr_d((v2i64)v1, (v2i64)v0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int32_t* from) {
+  EIGEN_MSA_DEBUG;
+
+  int32_t i0 = from[0], i1 = from[1];
+  Packet4i v0 = { i0, i0, i0, i0 };
+  Packet4i v1 = { i1, i1, i1, i1 };
+  return (Packet4i)__builtin_msa_ilvr_d((v2i64)v1, (v2i64)v0);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_STORE __builtin_msa_st_w((Packet4i)from, to, 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<int32_t>(int32_t* to, const Packet4i& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_STORE __builtin_msa_st_w(from, to, 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet4f& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_STORE __builtin_msa_st_w((Packet4i)from, to, 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<int32_t>(int32_t* to, const Packet4i& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_STORE __builtin_msa_st_w(from, to, 0);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  float f = *from;
+  Packet4f v = { f, f, f, f };
+  v[1] = from[stride];
+  v[2] = from[2 * stride];
+  v[3] = from[3 * stride];
+  return v;
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet4i pgather<int32_t, Packet4i>(const int32_t* from, Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  int32_t i = *from;
+  Packet4i v = { i, i, i, i };
+  v[1] = from[stride];
+  v[2] = from[2 * stride];
+  v[3] = from[3 * stride];
+  return v;
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from,
+                                                        Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  *to = from[0];
+  to += stride;
+  *to = from[1];
+  to += stride;
+  *to = from[2];
+  to += stride;
+  *to = from[3];
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<int32_t, Packet4i>(int32_t* to, const Packet4i& from,
+                                                          Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  *to = from[0];
+  to += stride;
+  *to = from[1];
+  to += stride;
+  *to = from[2];
+  to += stride;
+  *to = from[3];
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) {
+  EIGEN_MSA_DEBUG;
+
+  __builtin_prefetch(addr);
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<int32_t>(const int32_t* addr) {
+  EIGEN_MSA_DEBUG;
+
+  __builtin_prefetch(addr);
+}
+
+template <>
+EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE int32_t pfirst<Packet4i>(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_shf_w((v4i32)a, EIGEN_MSA_SHF_I8(3, 2, 1, 0));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_shf_w(a, EIGEN_MSA_SHF_I8(3, 2, 1, 0));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_bclri_w((v4u32)a, 31);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4i zero = __builtin_msa_ldi_w(0);
+  return __builtin_msa_add_a_w(zero, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4f s = padd(a, (Packet4f)__builtin_msa_shf_w((v4i32)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  s = padd(s, (Packet4f)__builtin_msa_shf_w((v4i32)s, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return s[0];
+}
+
+
+template <>
+EIGEN_STRONG_INLINE int32_t predux<Packet4i>(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4i s = padd(a, __builtin_msa_shf_w(a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  s = padd(s, __builtin_msa_shf_w(s, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return s[0];
+}
+
+// Other reduction functions:
+// mul
+template <>
+EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4f p = pmul(a, (Packet4f)__builtin_msa_shf_w((v4i32)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  p = pmul(p, (Packet4f)__builtin_msa_shf_w((v4i32)p, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return p[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE int32_t predux_mul<Packet4i>(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4i p = pmul(a, __builtin_msa_shf_w(a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  p = pmul(p, __builtin_msa_shf_w(p, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return p[0];
+}
+
+// min
+template <>
+EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  // Swap 64-bit halves of a.
+  Packet4f swapped = (Packet4f)__builtin_msa_shf_w((Packet4i)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+#if !EIGEN_FAST_MATH
+  // Detect presence of NaNs from pairs a[0]-a[2] and a[1]-a[3] as two 32-bit
+  // masks of all zeroes/ones in low 64 bits.
+  v16u8 unord = (v16u8)__builtin_msa_fcun_w(a, swapped);
+  // Combine the two masks into one: 64 ones if no NaNs, otherwise 64 zeroes.
+  unord = (v16u8)__builtin_msa_ceqi_d((v2i64)unord, 0);
+#endif
+  // Continue with min computation.
+  Packet4f v = __builtin_msa_fmin_w(a, swapped);
+  v = __builtin_msa_fmin_w(
+      v, (Packet4f)__builtin_msa_shf_w((Packet4i)v, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+#if !EIGEN_FAST_MATH
+  // Based on the mask select between v and 4 qNaNs.
+  v16u8 qnans = (v16u8)__builtin_msa_fill_w(0x7FC00000);
+  v = (Packet4f)__builtin_msa_bsel_v(unord, qnans, (v16u8)v);
+#endif
+  return v[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE int32_t predux_min<Packet4i>(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4i m = pmin(a, __builtin_msa_shf_w(a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  m = pmin(m, __builtin_msa_shf_w(m, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return m[0];
+}
+
+// max
+template <>
+EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  // Swap 64-bit halves of a.
+  Packet4f swapped = (Packet4f)__builtin_msa_shf_w((Packet4i)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+#if !EIGEN_FAST_MATH
+  // Detect presence of NaNs from pairs a[0]-a[2] and a[1]-a[3] as two 32-bit
+  // masks of all zeroes/ones in low 64 bits.
+  v16u8 unord = (v16u8)__builtin_msa_fcun_w(a, swapped);
+  // Combine the two masks into one: 64 ones if no NaNs, otherwise 64 zeroes.
+  unord = (v16u8)__builtin_msa_ceqi_d((v2i64)unord, 0);
+#endif
+  // Continue with max computation.
+  Packet4f v = __builtin_msa_fmax_w(a, swapped);
+  v = __builtin_msa_fmax_w(
+      v, (Packet4f)__builtin_msa_shf_w((Packet4i)v, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+#if !EIGEN_FAST_MATH
+  // Based on the mask select between v and 4 qNaNs.
+  v16u8 qnans = (v16u8)__builtin_msa_fill_w(0x7FC00000);
+  v = (Packet4f)__builtin_msa_bsel_v(unord, qnans, (v16u8)v);
+#endif
+  return v[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE int32_t predux_max<Packet4i>(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4i m = pmax(a, __builtin_msa_shf_w(a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  m = pmax(m, __builtin_msa_shf_w(m, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return m[0];
+}
+
+inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet4f, 4>& value) {
+  os << "[ " << value.packet[0] << "," << std::endl
+     << "  " << value.packet[1] << "," << std::endl
+     << "  " << value.packet[2] << "," << std::endl
+     << "  " << value.packet[3] << " ]";
+  return os;
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4f, 4>& kernel) {
+  EIGEN_MSA_DEBUG;
+
+  v4i32 tmp1, tmp2, tmp3, tmp4;
+
+  tmp1 = __builtin_msa_ilvr_w((v4i32)kernel.packet[1], (v4i32)kernel.packet[0]);
+  tmp2 = __builtin_msa_ilvr_w((v4i32)kernel.packet[3], (v4i32)kernel.packet[2]);
+  tmp3 = __builtin_msa_ilvl_w((v4i32)kernel.packet[1], (v4i32)kernel.packet[0]);
+  tmp4 = __builtin_msa_ilvl_w((v4i32)kernel.packet[3], (v4i32)kernel.packet[2]);
+
+  kernel.packet[0] = (Packet4f)__builtin_msa_ilvr_d((v2i64)tmp2, (v2i64)tmp1);
+  kernel.packet[1] = (Packet4f)__builtin_msa_ilvod_d((v2i64)tmp2, (v2i64)tmp1);
+  kernel.packet[2] = (Packet4f)__builtin_msa_ilvr_d((v2i64)tmp4, (v2i64)tmp3);
+  kernel.packet[3] = (Packet4f)__builtin_msa_ilvod_d((v2i64)tmp4, (v2i64)tmp3);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet4i, 4>& value) {
+  os << "[ " << value.packet[0] << "," << std::endl
+     << "  " << value.packet[1] << "," << std::endl
+     << "  " << value.packet[2] << "," << std::endl
+     << "  " << value.packet[3] << " ]";
+  return os;
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4i, 4>& kernel) {
+  EIGEN_MSA_DEBUG;
+
+  v4i32 tmp1, tmp2, tmp3, tmp4;
+
+  tmp1 = __builtin_msa_ilvr_w(kernel.packet[1], kernel.packet[0]);
+  tmp2 = __builtin_msa_ilvr_w(kernel.packet[3], kernel.packet[2]);
+  tmp3 = __builtin_msa_ilvl_w(kernel.packet[1], kernel.packet[0]);
+  tmp4 = __builtin_msa_ilvl_w(kernel.packet[3], kernel.packet[2]);
+
+  kernel.packet[0] = (Packet4i)__builtin_msa_ilvr_d((v2i64)tmp2, (v2i64)tmp1);
+  kernel.packet[1] = (Packet4i)__builtin_msa_ilvod_d((v2i64)tmp2, (v2i64)tmp1);
+  kernel.packet[2] = (Packet4i)__builtin_msa_ilvr_d((v2i64)tmp4, (v2i64)tmp3);
+  kernel.packet[3] = (Packet4i)__builtin_msa_ilvod_d((v2i64)tmp4, (v2i64)tmp3);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f psqrt(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fsqrt_w(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f prsqrt(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  return __builtin_msa_frsqrt_w(a);
+#else
+  Packet4f ones = __builtin_msa_ffint_s_w(__builtin_msa_ldi_w(1));
+  return pdiv(ones, psqrt(a));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a) {
+  Packet4f v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"  // 3 = round towards -INFINITY.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.w %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a) {
+  Packet4f v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"
+      "xori    %[new_mode], %[new_mode], 1\n"  // 2 = round towards +INFINITY.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.w %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a) {
+  Packet4f v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"
+      "xori    %[new_mode], %[new_mode], 3\n"  // 0 = round to nearest, ties to even.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.w %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,
+                                    const Packet4f& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2],
+                       ifPacket.select[3] };
+  Packet4i mask = __builtin_msa_ceqi_w((Packet4i)select, 0);
+  return (Packet4f)__builtin_msa_bsel_v((v16u8)mask, (v16u8)thenPacket, (v16u8)elsePacket);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,
+                                    const Packet4i& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2],
+                       ifPacket.select[3] };
+  Packet4i mask = __builtin_msa_ceqi_w((Packet4i)select, 0);
+  return (Packet4i)__builtin_msa_bsel_v((v16u8)mask, (v16u8)thenPacket, (v16u8)elsePacket);
+}
+
+//---------- double ----------
+
+typedef v2f64 Packet2d;
+typedef v2i64 Packet2l;
+typedef v2u64 Packet2ul;
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME, X) const Packet2d p2d_##NAME = { X, X }
+#define _EIGEN_DECLARE_CONST_Packet2l(NAME, X) const Packet2l p2l_##NAME = { X, X }
+#define _EIGEN_DECLARE_CONST_Packet2ul(NAME, X) const Packet2ul p2ul_##NAME = { X, X }
+
+inline std::ostream& operator<<(std::ostream& os, const Packet2d& value) {
+  os << "[ " << value[0] << ", " << value[1] << " ]";
+  return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Packet2l& value) {
+  os << "[ " << value[0] << ", " << value[1] << " ]";
+  return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Packet2ul& value) {
+  os << "[ " << value[0] << ", " << value[1] << " ]";
+  return os;
+}
+
+template <>
+struct packet_traits<double> : default_packet_traits {
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+    // FIXME check the Has*
+    HasDiv = 1,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct unpacket_traits<Packet2d> {
+  typedef double type;
+  enum { size = 2, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
+  typedef Packet2d half;
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d value = { from, from };
+  return value;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fadd_d(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) {
+  EIGEN_MSA_DEBUG;
+
+  static const Packet2d countdown = { 0.0, 1.0 };
+  return padd(pset1<Packet2d>(a), countdown);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fsub_d(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_bnegi_d((v2u64)a, 63);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fmul_d(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fdiv_d(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fmadd_d(c, a, b);
+}
+
+// Logical Operations are not supported for float, so we have to reinterpret casts using MSA
+// intrinsics
+template <>
+EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_and_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_or_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_xor_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return pand(a, (Packet2d)__builtin_msa_xori_b((v16u8)b, 255));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return (Packet2d)__builtin_msa_ld_d(const_cast<double*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  // This prefers numbers to NaNs.
+  return __builtin_msa_fmin_d(a, b);
+#else
+  // This prefers NaNs to numbers.
+  v2i64 aNaN = __builtin_msa_fcun_d(a, a);
+  v2i64 aMinOrNaN = por(__builtin_msa_fclt_d(a, b), aNaN);
+  return (Packet2d)__builtin_msa_bsel_v((v16u8)aMinOrNaN, (v16u8)b, (v16u8)a);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  // This prefers numbers to NaNs.
+  return __builtin_msa_fmax_d(a, b);
+#else
+  // This prefers NaNs to numbers.
+  v2i64 aNaN = __builtin_msa_fcun_d(a, a);
+  v2i64 aMaxOrNaN = por(__builtin_msa_fclt_d(b, a), aNaN);
+  return (Packet2d)__builtin_msa_bsel_v((v16u8)aMaxOrNaN, (v16u8)b, (v16u8)a);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return (Packet2d)__builtin_msa_ld_d(const_cast<double*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double* from) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d value = { *from, *from };
+  return value;
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet2d& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_STORE __builtin_msa_st_d((v2i64)from, to, 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet2d& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_STORE __builtin_msa_st_d((v2i64)from, to, 0);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d value;
+  value[0] = *from;
+  from += stride;
+  value[1] = *from;
+  return value;
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from,
+                                                         Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  *to = from[0];
+  to += stride;
+  *to = from[1];
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) {
+  EIGEN_MSA_DEBUG;
+
+  __builtin_prefetch(addr);
+}
+
+template <>
+EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_shf_w((v4i32)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_bclri_d((v2u64)a, 63);
+}
+
+template <>
+EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d s = padd(a, preverse(a));
+  return s[0];
+}
+
+// Other reduction functions:
+// mul
+template <>
+EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d p = pmul(a, preverse(a));
+  return p[0];
+}
+
+// min
+template <>
+EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  Packet2d swapped = (Packet2d)__builtin_msa_shf_w((Packet4i)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+  Packet2d v = __builtin_msa_fmin_d(a, swapped);
+  return v[0];
+#else
+  double a0 = a[0], a1 = a[1];
+  return ((numext::isnan)(a0) || a0 < a1) ? a0 : a1;
+#endif
+}
+
+// max
+template <>
+EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  Packet2d swapped = (Packet2d)__builtin_msa_shf_w((Packet4i)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+  Packet2d v = __builtin_msa_fmax_d(a, swapped);
+  return v[0];
+#else
+  double a0 = a[0], a1 = a[1];
+  return ((numext::isnan)(a0) || a0 > a1) ? a0 : a1;
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d psqrt(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fsqrt_d(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d prsqrt(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  return __builtin_msa_frsqrt_d(a);
+#else
+  Packet2d ones = __builtin_msa_ffint_s_d(__builtin_msa_ldi_d(1));
+  return pdiv(ones, psqrt(a));
+#endif
+}
+
+inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet2d, 2>& value) {
+  os << "[ " << value.packet[0] << "," << std::endl << "  " << value.packet[1] << " ]";
+  return os;
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2d, 2>& kernel) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d trn1 = (Packet2d)__builtin_msa_ilvev_d((v2i64)kernel.packet[1], (v2i64)kernel.packet[0]);
+  Packet2d trn2 = (Packet2d)__builtin_msa_ilvod_d((v2i64)kernel.packet[1], (v2i64)kernel.packet[0]);
+  kernel.packet[0] = trn1;
+  kernel.packet[1] = trn2;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) {
+  Packet2d v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"  // 3 = round towards -INFINITY.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.d %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a) {
+  Packet2d v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"
+      "xori    %[new_mode], %[new_mode], 1\n"  // 2 = round towards +INFINITY.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.d %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a) {
+  Packet2d v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"
+      "xori    %[new_mode], %[new_mode], 3\n"  // 0 = round to nearest, ties to even.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.d %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,
+                                    const Packet2d& elsePacket) {
+  Packet2ul select = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2l mask = __builtin_msa_ceqi_d((Packet2l)select, 0);
+  return (Packet2d)__builtin_msa_bsel_v((v16u8)mask, (v16u8)thenPacket, (v16u8)elsePacket);
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_PACKET_MATH_MSA_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/Complex.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/Complex.h
new file mode 100644
index 00000000..f40af7f8
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/Complex.h
@@ -0,0 +1,584 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_NEON_H
+#define EIGEN_COMPLEX_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+inline uint32x4_t p4ui_CONJ_XOR()
+{
+// See bug 1325, clang fails to call vld1q_u64.
+#if EIGEN_COMP_CLANG || EIGEN_COMP_CASTXML
+  uint32x4_t ret = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
+  return ret;
+#else
+  static const uint32_t conj_XOR_DATA[] = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
+  return vld1q_u32( conj_XOR_DATA );
+#endif
+}
+
+inline uint32x2_t p2ui_CONJ_XOR()
+{
+  static const uint32_t conj_XOR_DATA[] = { 0x00000000, 0x80000000 };
+  return vld1_u32( conj_XOR_DATA );
+}
+
+//---------- float ----------
+
+struct Packet1cf
+{
+  EIGEN_STRONG_INLINE Packet1cf() {}
+  EIGEN_STRONG_INLINE explicit Packet1cf(const Packet2f& a) : v(a) {}
+  Packet2f v;
+};
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {}
+  Packet4f v;
+};
+
+template<> struct packet_traits<std::complex<float> > : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet1cf half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasMul       = 1,
+    HasDiv       = 1,
+    HasNegate    = 1,
+    HasAbs       = 0,
+    HasAbs2      = 0,
+    HasMin       = 0,
+    HasMax       = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet1cf>
+{
+  typedef std::complex<float> type;
+  typedef Packet1cf half;
+  typedef Packet2f as_real;
+  enum
+  {
+    size = 1,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet2cf>
+{
+  typedef std::complex<float> type;
+  typedef Packet1cf half;
+  typedef Packet4f as_real;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet1cf pcast<float,Packet1cf>(const float& a)
+{ return Packet1cf(vset_lane_f32(a, vdup_n_f32(0.f), 0)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pcast<Packet2f,Packet2cf>(const Packet2f& a)
+{ return Packet2cf(vreinterpretq_f32_u64(vmovl_u32(vreinterpret_u32_f32(a)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pset1<Packet1cf>(const std::complex<float>& from)
+{ return Packet1cf(vld1_f32(reinterpret_cast<const float*>(&from))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>& from)
+{
+  const float32x2_t r64 = vld1_f32(reinterpret_cast<const float*>(&from));
+  return Packet2cf(vcombine_f32(r64, r64));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf padd<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(padd<Packet2f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(padd<Packet4f>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf psub<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(psub<Packet2f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(psub<Packet4f>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pnegate(const Packet1cf& a) { return Packet1cf(pnegate<Packet2f>(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate<Packet4f>(a.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pconj(const Packet1cf& a)
+{
+  const Packet2ui b = vreinterpret_u32_f32(a.v);
+  return Packet1cf(vreinterpret_f32_u32(veor_u32(b, p2ui_CONJ_XOR())));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a)
+{
+  const Packet4ui b = vreinterpretq_u32_f32(a.v);
+  return Packet2cf(vreinterpretq_f32_u32(veorq_u32(b, p4ui_CONJ_XOR())));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf pmul<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{
+  Packet2f v1, v2;
+
+  // Get the real values of a | a1_re | a1_re |
+  v1 = vdup_lane_f32(a.v, 0);
+  // Get the imag values of a | a1_im | a1_im |
+  v2 = vdup_lane_f32(a.v, 1);
+  // Multiply the real a with b
+  v1 = vmul_f32(v1, b.v);
+  // Multiply the imag a with b
+  v2 = vmul_f32(v2, b.v);
+  // Conjugate v2
+  v2 = vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(v2), p2ui_CONJ_XOR()));
+  // Swap real/imag elements in v2.
+  v2 = vrev64_f32(v2);
+  // Add and return the result
+  return Packet1cf(vadd_f32(v1, v2));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  Packet4f v1, v2;
+
+  // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
+  v1 = vcombine_f32(vdup_lane_f32(vget_low_f32(a.v), 0), vdup_lane_f32(vget_high_f32(a.v), 0));
+  // Get the imag values of a | a1_im | a1_im | a2_im | a2_im |
+  v2 = vcombine_f32(vdup_lane_f32(vget_low_f32(a.v), 1), vdup_lane_f32(vget_high_f32(a.v), 1));
+  // Multiply the real a with b
+  v1 = vmulq_f32(v1, b.v);
+  // Multiply the imag a with b
+  v2 = vmulq_f32(v2, b.v);
+  // Conjugate v2
+  v2 = vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(v2), p4ui_CONJ_XOR()));
+  // Swap real/imag elements in v2.
+  v2 = vrev64q_f32(v2);
+  // Add and return the result
+  return Packet2cf(vaddq_f32(v1, v2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf pcmp_eq(const Packet1cf& a, const Packet1cf& b)
+{
+  // Compare real and imaginary parts of a and b to get the mask vector:
+  // [re(a[0])==re(b[0]), im(a[0])==im(b[0])]
+  Packet2f eq = pcmp_eq<Packet2f>(a.v, b.v);
+  // Swap real/imag elements in the mask in to get:
+  // [im(a[0])==im(b[0]), re(a[0])==re(b[0])]
+  Packet2f eq_swapped = vrev64_f32(eq);
+  // Return re(a)==re(b) && im(a)==im(b) by computing bitwise AND of eq and eq_swapped
+  return Packet1cf(pand<Packet2f>(eq, eq_swapped));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b)
+{
+  // Compare real and imaginary parts of a and b to get the mask vector:
+  // [re(a[0])==re(b[0]), im(a[0])==im(b[0]), re(a[1])==re(b[1]), im(a[1])==im(b[1])]
+  Packet4f eq = pcmp_eq<Packet4f>(a.v, b.v);
+  // Swap real/imag elements in the mask in to get:
+  // [im(a[0])==im(b[0]), re(a[0])==re(b[0]), im(a[1])==im(b[1]), re(a[1])==re(b[1])]
+  Packet4f eq_swapped = vrev64q_f32(eq);
+  // Return re(a)==re(b) && im(a)==im(b) by computing bitwise AND of eq and eq_swapped
+  return Packet2cf(pand<Packet4f>(eq, eq_swapped));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf pand<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(vreinterpret_f32_u32(vand_u32(vreinterpret_u32_f32(a.v), vreinterpret_u32_f32(b.v)))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pand<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a.v), vreinterpretq_u32_f32(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf por<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(vreinterpret_f32_u32(vorr_u32(vreinterpret_u32_f32(a.v), vreinterpret_u32_f32(b.v)))); }
+template<> EIGEN_STRONG_INLINE Packet2cf por<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a.v), vreinterpretq_u32_f32(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pxor<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(a.v), vreinterpret_u32_f32(b.v)))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a.v), vreinterpretq_u32_f32(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pandnot<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(vreinterpret_f32_u32(vbic_u32(vreinterpret_u32_f32(a.v), vreinterpret_u32_f32(b.v)))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a.v), vreinterpretq_u32_f32(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pload<Packet1cf>(const std::complex<float>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cf(pload<Packet2f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pload<Packet2cf>(const std::complex<float>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>(reinterpret_cast<const float*>(from))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf ploadu<Packet1cf>(const std::complex<float>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cf(ploadu<Packet2f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>(reinterpret_cast<const float*>(from))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf ploaddup<Packet1cf>(const std::complex<float>* from)
+{ return pset1<Packet1cf>(*from); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from)
+{ return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *to, const Packet1cf& from)
+{ EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *to, const Packet2cf& from)
+{ EIGEN_DEBUG_ALIGNED_STORE pstore(reinterpret_cast<float*>(to), from.v); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *to, const Packet1cf& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *to, const Packet2cf& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu(reinterpret_cast<float*>(to), from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet1cf pgather<std::complex<float>, Packet1cf>(
+    const std::complex<float>* from, Index stride)
+{
+  const Packet2f tmp = vdup_n_f32(std::real(from[0*stride]));
+  return Packet1cf(vset_lane_f32(std::imag(from[0*stride]), tmp, 1));
+}
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(
+    const std::complex<float>* from, Index stride)
+{
+  Packet4f res = vdupq_n_f32(std::real(from[0*stride]));
+  res = vsetq_lane_f32(std::imag(from[0*stride]), res, 1);
+  res = vsetq_lane_f32(std::real(from[1*stride]), res, 2);
+  res = vsetq_lane_f32(std::imag(from[1*stride]), res, 3);
+  return Packet2cf(res);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet1cf>(
+    std::complex<float>* to, const Packet1cf& from, Index stride)
+{ to[stride*0] = std::complex<float>(vget_lane_f32(from.v, 0), vget_lane_f32(from.v, 1)); }
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(
+    std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  to[stride*0] = std::complex<float>(vgetq_lane_f32(from.v, 0), vgetq_lane_f32(from.v, 1));
+  to[stride*1] = std::complex<float>(vgetq_lane_f32(from.v, 2), vgetq_lane_f32(from.v, 3));
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> *addr)
+{ EIGEN_ARM_PREFETCH(reinterpret_cast<const float*>(addr)); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet1cf>(const Packet1cf& a)
+{
+  EIGEN_ALIGN16 std::complex<float> x;
+  vst1_f32(reinterpret_cast<float*>(&x), a.v);
+  return x;
+}
+template<> EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a)
+{
+  EIGEN_ALIGN16 std::complex<float> x[2];
+  vst1q_f32(reinterpret_cast<float*>(x), a.v);
+  return x[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf preverse(const Packet1cf& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{ return Packet2cf(vcombine_f32(vget_high_f32(a.v), vget_low_f32(a.v))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pcplxflip<Packet1cf>(const Packet1cf& a)
+{ return Packet1cf(vrev64_f32(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& a)
+{ return Packet2cf(vrev64q_f32(a.v)); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet1cf>(const Packet1cf& a)
+{
+  std::complex<float> s;
+  vst1_f32((float *)&s, a.v);
+  return s;
+}
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> s;
+  vst1_f32(reinterpret_cast<float*>(&s), vadd_f32(vget_low_f32(a.v), vget_high_f32(a.v)));
+  return s;
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet1cf>(const Packet1cf& a)
+{
+  std::complex<float> s;
+  vst1_f32((float *)&s, a.v);
+  return s;
+}
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  float32x2_t a1, a2, v1, v2, prod;
+  std::complex<float> s;
+
+  a1 = vget_low_f32(a.v);
+  a2 = vget_high_f32(a.v);
+   // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
+  v1 = vdup_lane_f32(a1, 0);
+  // Get the real values of a | a1_im | a1_im | a2_im | a2_im |
+  v2 = vdup_lane_f32(a1, 1);
+  // Multiply the real a with b
+  v1 = vmul_f32(v1, a2);
+  // Multiply the imag a with b
+  v2 = vmul_f32(v2, a2);
+  // Conjugate v2
+  v2 = vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(v2), p2ui_CONJ_XOR()));
+  // Swap real/imag elements in v2.
+  v2 = vrev64_f32(v2);
+  // Add v1, v2
+  prod = vadd_f32(v1, v2);
+
+  vst1_f32(reinterpret_cast<float*>(&s), prod);
+
+  return s;
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cf,Packet2f)
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet1cf pdiv<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{
+  // TODO optimize it for NEON
+  Packet1cf res = pmul(a, pconj(b));
+  Packet2f s, rev_s;
+
+  // this computes the norm
+  s = vmul_f32(b.v, b.v);
+  rev_s = vrev64_f32(s);
+
+  return Packet1cf(pdiv<Packet2f>(res.v, vadd_f32(s, rev_s)));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for NEON
+  Packet2cf res = pmul(a,pconj(b));
+  Packet4f s, rev_s;
+
+  // this computes the norm
+  s = vmulq_f32(b.v, b.v);
+  rev_s = vrev64q_f32(s);
+
+  return Packet2cf(pdiv<Packet4f>(res.v, vaddq_f32(s, rev_s)));
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1cf, 1>& /*kernel*/) {}
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2cf, 2>& kernel)
+{
+  Packet4f tmp = vcombine_f32(vget_high_f32(kernel.packet[0].v), vget_high_f32(kernel.packet[1].v));
+  kernel.packet[0].v = vcombine_f32(vget_low_f32(kernel.packet[0].v), vget_low_f32(kernel.packet[1].v));
+  kernel.packet[1].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf psqrt<Packet1cf>(const Packet1cf& a) {
+  return psqrt_complex<Packet1cf>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf psqrt<Packet2cf>(const Packet2cf& a) {
+  return psqrt_complex<Packet2cf>(a);
+}
+
+//---------- double ----------
+#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+
+// See bug 1325, clang fails to call vld1q_u64.
+#if EIGEN_COMP_CLANG || EIGEN_COMP_CASTXML
+  static uint64x2_t p2ul_CONJ_XOR = {0x0, 0x8000000000000000};
+#else
+  const uint64_t  p2ul_conj_XOR_DATA[] = { 0x0, 0x8000000000000000 };
+  static uint64x2_t p2ul_CONJ_XOR = vld1q_u64( p2ul_conj_XOR_DATA );
+#endif
+
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {}
+  Packet2d v;
+};
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet1cd>
+{
+  typedef std::complex<double> type;
+  typedef Packet1cd half;
+  typedef Packet2d as_real;
+  enum
+  {
+    size=1,
+    alignment=Aligned16,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet1cd pload<Packet1cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>(reinterpret_cast<const double*>(from))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>(reinterpret_cast<const double*>(from))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>& from)
+{
+  /* here we really have to use unaligned loads :( */
+  return ploadu<Packet1cd>(&from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(padd<Packet2d>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(psub<Packet2d>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a)
+{ return Packet1cd(pnegate<Packet2d>(a.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a)
+{ return Packet1cd(vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(a.v), p2ul_CONJ_XOR))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  Packet2d v1, v2;
+
+  // Get the real values of a
+  v1 = vdupq_lane_f64(vget_low_f64(a.v), 0);
+  // Get the imag values of a
+  v2 = vdupq_lane_f64(vget_high_f64(a.v), 0);
+  // Multiply the real a with b
+  v1 = vmulq_f64(v1, b.v);
+  // Multiply the imag a with b
+  v2 = vmulq_f64(v2, b.v);
+  // Conjugate v2
+  v2 = vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(v2), p2ul_CONJ_XOR));
+  // Swap real/imag elements in v2.
+  v2 = preverse<Packet2d>(v2);
+  // Add and return the result
+  return Packet1cd(vaddq_f64(v1, v2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b)
+{
+  // Compare real and imaginary parts of a and b to get the mask vector:
+  // [re(a)==re(b), im(a)==im(b)]
+  Packet2d eq = pcmp_eq<Packet2d>(a.v, b.v);
+  // Swap real/imag elements in the mask in to get:
+  // [im(a)==im(b), re(a)==re(b)]
+  Packet2d eq_swapped = vreinterpretq_f64_u32(vrev64q_u32(vreinterpretq_u32_f64(eq)));
+  // Return re(a)==re(b) & im(a)==im(b) by computing bitwise AND of eq and eq_swapped
+  return Packet1cd(pand<Packet2d>(eq, eq_swapped));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pand<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd por<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pxor<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(vreinterpretq_f64_u64(vbicq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from)
+{ return pset1<Packet1cd>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *to, const Packet1cd& from)
+{ EIGEN_DEBUG_ALIGNED_STORE pstore(reinterpret_cast<double*>(to), from.v); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *to, const Packet1cd& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu(reinterpret_cast<double*>(to), from.v); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> *addr)
+{ EIGEN_ARM_PREFETCH(reinterpret_cast<const double*>(addr)); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(
+    const std::complex<double>* from, Index stride)
+{
+  Packet2d res = pset1<Packet2d>(0.0);
+  res = vsetq_lane_f64(std::real(from[0*stride]), res, 0);
+  res = vsetq_lane_f64(std::imag(from[0*stride]), res, 1);
+  return Packet1cd(res);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(
+    std::complex<double>* to, const Packet1cd& from, Index stride)
+{ to[stride*0] = std::complex<double>(vgetq_lane_f64(from.v, 0), vgetq_lane_f64(from.v, 1)); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet1cd>(const Packet1cd& a)
+{
+  EIGEN_ALIGN16 std::complex<double> res;
+  pstore<std::complex<double> >(&res, a);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for NEON
+  Packet1cd res = pmul(a,pconj(b));
+  Packet2d s = pmul<Packet2d>(b.v, b.v);
+  Packet2d rev_s = preverse<Packet2d>(s);
+
+  return Packet1cd(pdiv(res.v, padd<Packet2d>(s,rev_s)));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
+{ return Packet1cd(preverse(Packet2d(x.v))); }
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd,2>& kernel)
+{
+  Packet2d tmp = vcombine_f64(vget_high_f64(kernel.packet[0].v), vget_high_f64(kernel.packet[1].v));
+  kernel.packet[0].v = vcombine_f64(vget_low_f64(kernel.packet[0].v), vget_low_f64(kernel.packet[1].v));
+  kernel.packet[1].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd psqrt<Packet1cd>(const Packet1cd& a) {
+  return psqrt_complex<Packet1cd>(a);
+}
+
+#endif // EIGEN_ARCH_ARM64
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_NEON_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
new file mode 100644
index 00000000..3481f337
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
@@ -0,0 +1,183 @@
+namespace Eigen {
+namespace internal {
+  
+#if EIGEN_ARCH_ARM && EIGEN_COMP_CLANG
+
+// Clang seems to excessively spill registers in the GEBP kernel on 32-bit arm.
+// Here we specialize gebp_traits to eliminate these register spills.
+// See #2138.
+template<>
+struct gebp_traits <float,float,false,false,Architecture::NEON,GEBPPacketFull>
+ : gebp_traits<float,float,false,false,Architecture::Generic,GEBPPacketFull>
+{
+  EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha, ResPacket& r) const
+  { 
+    // This volatile inline ASM both acts as a barrier to prevent reordering,
+    // as well as enforces strict register use.
+    asm volatile(
+      "vmla.f32 %q[r], %q[c], %q[alpha]"
+      : [r] "+w" (r)
+      : [c] "w" (c),
+        [alpha] "w" (alpha)
+      : );
+  }
+
+  template <typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const Packet4f& a, const Packet4f& b,
+                                Packet4f& c, Packet4f& tmp,
+                                const LaneIdType&) const {
+    acc(a, b, c);
+  }
+  
+  template <typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const Packet4f& a, const QuadPacket<Packet4f>& b,
+                                Packet4f& c, Packet4f& tmp,
+                                const LaneIdType& lane) const {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+};
+
+#endif // EIGEN_ARCH_ARM && EIGEN_COMP_CLANG
+
+#if EIGEN_ARCH_ARM64
+
+template<>
+struct gebp_traits <float,float,false,false,Architecture::NEON,GEBPPacketFull>
+ : gebp_traits<float,float,false,false,Architecture::Generic,GEBPPacketFull>
+{
+  typedef float RhsPacket;
+  typedef float32x4_t RhsPacketx4;
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = *b;
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    dest = vld1q_f32(b);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = *b;
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
+  {}
+
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    loadRhs(b,dest);
+  }
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<0>&) const
+  {
+    c = vfmaq_n_f32(c, a, b);
+  }
+
+  // NOTE: Template parameter inference failed when compiled with Android NDK:
+  // "candidate template ignored: could not match 'FixedInt<N>' against 'Eigen::internal::FixedInt<0>".
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<0>&) const
+  { madd_helper<0>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<1>&) const
+  { madd_helper<1>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<2>&) const
+  { madd_helper<2>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<3>&) const
+  { madd_helper<3>(a, b, c); }
+
+ private:
+  template<int LaneID>
+  EIGEN_STRONG_INLINE void madd_helper(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c) const
+  {
+    #if EIGEN_COMP_GNUC_STRICT && !(EIGEN_GNUC_AT_LEAST(9,0))
+    // workaround gcc issue https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89101
+    // vfmaq_laneq_f32 is implemented through a costly dup
+         if(LaneID==0)  asm("fmla %0.4s, %1.4s, %2.s[0]\n" : "+w" (c) : "w" (a), "w" (b) :  );
+    else if(LaneID==1)  asm("fmla %0.4s, %1.4s, %2.s[1]\n" : "+w" (c) : "w" (a), "w" (b) :  );
+    else if(LaneID==2)  asm("fmla %0.4s, %1.4s, %2.s[2]\n" : "+w" (c) : "w" (a), "w" (b) :  );
+    else if(LaneID==3)  asm("fmla %0.4s, %1.4s, %2.s[3]\n" : "+w" (c) : "w" (a), "w" (b) :  );
+    #else
+    c = vfmaq_laneq_f32(c, a, b, LaneID);
+    #endif
+  }
+};
+
+
+template<>
+struct gebp_traits <double,double,false,false,Architecture::NEON>
+ : gebp_traits<double,double,false,false,Architecture::Generic>
+{
+  typedef double RhsPacket;
+
+  struct RhsPacketx4 {
+    float64x2_t B_0, B_1;
+  };
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = *b;
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    dest.B_0 = vld1q_f64(b);
+    dest.B_1 = vld1q_f64(b+2);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacket& dest) const
+  {
+    loadRhs(b,dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
+  {}
+
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    loadRhs(b,dest);
+  }
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<0>&) const
+  {
+    c = vfmaq_n_f64(c, a, b);
+  }
+
+  // NOTE: Template parameter inference failed when compiled with Android NDK:
+  // "candidate template ignored: could not match 'FixedInt<N>' against 'Eigen::internal::FixedInt<0>".
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<0>&) const
+  { madd_helper<0>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<1>&) const
+  { madd_helper<1>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<2>&) const
+  { madd_helper<2>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<3>&) const
+  { madd_helper<3>(a, b, c); }
+
+ private:
+  template <int LaneID>
+  EIGEN_STRONG_INLINE void madd_helper(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c) const
+  {
+    #if EIGEN_COMP_GNUC_STRICT && !(EIGEN_GNUC_AT_LEAST(9,0))
+    // workaround gcc issue https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89101
+    // vfmaq_laneq_f64 is implemented through a costly dup
+         if(LaneID==0)  asm("fmla %0.2d, %1.2d, %2.d[0]\n" : "+w" (c) : "w" (a), "w" (b.B_0) :  );
+    else if(LaneID==1)  asm("fmla %0.2d, %1.2d, %2.d[1]\n" : "+w" (c) : "w" (a), "w" (b.B_0) :  );
+    else if(LaneID==2)  asm("fmla %0.2d, %1.2d, %2.d[0]\n" : "+w" (c) : "w" (a), "w" (b.B_1) :  );
+    else if(LaneID==3)  asm("fmla %0.2d, %1.2d, %2.d[1]\n" : "+w" (c) : "w" (a), "w" (b.B_1) :  );
+    #else
+         if(LaneID==0) c = vfmaq_laneq_f64(c, a, b.B_0, 0);
+    else if(LaneID==1) c = vfmaq_laneq_f64(c, a, b.B_0, 1);
+    else if(LaneID==2) c = vfmaq_laneq_f64(c, a, b.B_1, 0);
+    else if(LaneID==3) c = vfmaq_laneq_f64(c, a, b.B_1, 1);
+    #endif
+  }
+};
+
+#endif // EIGEN_ARCH_ARM64
+
+}  // namespace internal
+}  // namespace Eigen
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/MathFunctions.h
new file mode 100644
index 00000000..fa6615a8
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/MathFunctions.h
@@ -0,0 +1,75 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_NEON_H
+#define EIGEN_MATH_FUNCTIONS_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f pexp<Packet2f>(const Packet2f& x)
+{ return pexp_float(x); }
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f pexp<Packet4f>(const Packet4f& x)
+{ return pexp_float(x); }
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f plog<Packet2f>(const Packet2f& x)
+{ return plog_float(x); }
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f plog<Packet4f>(const Packet4f& x)
+{ return plog_float(x); }
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f psin<Packet2f>(const Packet2f& x)
+{ return psin_float(x); }
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f psin<Packet4f>(const Packet4f& x)
+{ return psin_float(x); }
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f pcos<Packet2f>(const Packet2f& x)
+{ return pcos_float(x); }
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f pcos<Packet4f>(const Packet4f& x)
+{ return pcos_float(x); }
+
+// Hyperbolic Tangent function.
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f ptanh<Packet2f>(const Packet2f& x)
+{ return internal::generic_fast_tanh_float(x); }
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f ptanh<Packet4f>(const Packet4f& x)
+{ return internal::generic_fast_tanh_float(x); }
+
+BF16_PACKET_FUNCTION(Packet4f, Packet4bf, psin)
+BF16_PACKET_FUNCTION(Packet4f, Packet4bf, pcos)
+BF16_PACKET_FUNCTION(Packet4f, Packet4bf, plog)
+BF16_PACKET_FUNCTION(Packet4f, Packet4bf, pexp)
+BF16_PACKET_FUNCTION(Packet4f, Packet4bf, ptanh)
+
+template <>
+EIGEN_STRONG_INLINE Packet4bf pfrexp(const Packet4bf& a, Packet4bf& exponent) {
+  Packet4f fexponent;
+  const Packet4bf out = F32ToBf16(pfrexp<Packet4f>(Bf16ToF32(a), fexponent));
+  exponent = F32ToBf16(fexponent);
+  return out;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4bf pldexp(const Packet4bf& a, const Packet4bf& exponent) {
+  return F32ToBf16(pldexp<Packet4f>(Bf16ToF32(a), Bf16ToF32(exponent)));
+}
+
+//---------- double ----------
+
+#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d pexp<Packet2d>(const Packet2d& x)
+{ return pexp_double(x); }
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d plog<Packet2d>(const Packet2d& x)
+{ return plog_double(x); }
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATH_FUNCTIONS_NEON_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/PacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/PacketMath.h
new file mode 100644
index 00000000..d2aeef43
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/PacketMath.h
@@ -0,0 +1,4587 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Konstantinos Margaritis <markos@freevec.org>
+// Heavily based on Gael's SSE version.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_NEON_H
+#define EIGEN_PACKET_MATH_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#if EIGEN_ARCH_ARM64
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
+#else
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 16
+#endif
+#endif
+
+#if EIGEN_COMP_MSVC_STRICT
+
+// In MSVC's arm_neon.h header file, all NEON vector types
+// are aliases to the same underlying type __n128.
+// We thus have to wrap them to make them different C++ types.
+// (See also bug 1428)
+typedef eigen_packet_wrapper<float32x2_t,0>  Packet2f;
+typedef eigen_packet_wrapper<float32x4_t,1>  Packet4f;
+typedef eigen_packet_wrapper<int32_t    ,2>  Packet4c;
+typedef eigen_packet_wrapper<int8x8_t   ,3>  Packet8c;
+typedef eigen_packet_wrapper<int8x16_t  ,4>  Packet16c;
+typedef eigen_packet_wrapper<uint32_t   ,5>  Packet4uc;
+typedef eigen_packet_wrapper<uint8x8_t  ,6>  Packet8uc;
+typedef eigen_packet_wrapper<uint8x16_t ,7>  Packet16uc;
+typedef eigen_packet_wrapper<int16x4_t  ,8>  Packet4s;
+typedef eigen_packet_wrapper<int16x8_t  ,9>  Packet8s;
+typedef eigen_packet_wrapper<uint16x4_t ,10> Packet4us;
+typedef eigen_packet_wrapper<uint16x8_t ,11> Packet8us;
+typedef eigen_packet_wrapper<int32x2_t  ,12> Packet2i;
+typedef eigen_packet_wrapper<int32x4_t  ,13> Packet4i;
+typedef eigen_packet_wrapper<uint32x2_t ,14> Packet2ui;
+typedef eigen_packet_wrapper<uint32x4_t ,15> Packet4ui;
+typedef eigen_packet_wrapper<int64x2_t  ,16> Packet2l;
+typedef eigen_packet_wrapper<uint64x2_t ,17> Packet2ul;
+
+#else
+
+typedef float32x2_t                          Packet2f;
+typedef float32x4_t                          Packet4f;
+typedef eigen_packet_wrapper<int32_t    ,2>  Packet4c;
+typedef int8x8_t                             Packet8c;
+typedef int8x16_t                            Packet16c;
+typedef eigen_packet_wrapper<uint32_t   ,5>  Packet4uc;
+typedef uint8x8_t                            Packet8uc;
+typedef uint8x16_t                           Packet16uc;
+typedef int16x4_t                            Packet4s;
+typedef int16x8_t                            Packet8s;
+typedef uint16x4_t                           Packet4us;
+typedef uint16x8_t                           Packet8us;
+typedef int32x2_t                            Packet2i;
+typedef int32x4_t                            Packet4i;
+typedef uint32x2_t                           Packet2ui;
+typedef uint32x4_t                           Packet4ui;
+typedef int64x2_t                            Packet2l;
+typedef uint64x2_t                           Packet2ul;
+
+#endif // EIGEN_COMP_MSVC_STRICT
+
+EIGEN_STRONG_INLINE Packet4f shuffle1(const Packet4f& m, int mask){
+  const float* a = reinterpret_cast<const float*>(&m);
+  Packet4f res = {*(a + (mask & 3)), *(a + ((mask >> 2) & 3)), *(a + ((mask >> 4) & 3 )), *(a + ((mask >> 6) & 3))};
+  return res;
+}
+
+// fuctionally equivalent to _mm_shuffle_ps in SSE when interleave
+// == false (i.e. shuffle<false>(m, n, mask) equals _mm_shuffle_ps(m, n, mask)),
+// interleave m and n when interleave == true. Currently used in LU/arch/InverseSize4.h
+// to enable a shared implementation for fast inversion of matrices of size 4. 
+template<bool interleave> 
+EIGEN_STRONG_INLINE Packet4f shuffle2(const Packet4f &m, const Packet4f &n, int mask)
+{
+  const float* a = reinterpret_cast<const float*>(&m);
+  const float* b = reinterpret_cast<const float*>(&n);
+  Packet4f res = {*(a + (mask & 3)), *(a + ((mask >> 2) & 3)), *(b + ((mask >> 4) & 3)), *(b + ((mask >> 6) & 3))};
+  return res;
+}
+
+template<> 
+EIGEN_STRONG_INLINE Packet4f shuffle2<true>(const Packet4f &m, const Packet4f &n, int mask) 
+{
+  const float* a = reinterpret_cast<const float*>(&m);
+  const float* b = reinterpret_cast<const float*>(&n);
+  Packet4f res = {*(a + (mask & 3)), *(b + ((mask >> 2) & 3)), *(a + ((mask >> 4) & 3)), *(b + ((mask >> 6) & 3))};
+  return res;
+}
+
+EIGEN_STRONG_INLINE static int eigen_neon_shuffle_mask(int p, int q, int r, int s) {return ((s)<<6|(r)<<4|(q)<<2|(p));}
+
+EIGEN_STRONG_INLINE Packet4f vec4f_swizzle1(const Packet4f& a, int p, int q, int r, int s)
+{ 
+  return shuffle1(a, eigen_neon_shuffle_mask(p, q, r, s));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_swizzle2(const Packet4f& a, const Packet4f& b, int p, int q, int r, int s)
+{ 
+  return shuffle2<false>(a,b,eigen_neon_shuffle_mask(p, q, r, s));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_movelh(const Packet4f& a, const Packet4f& b)
+{
+  return shuffle2<false>(a,b,eigen_neon_shuffle_mask(0, 1, 0, 1));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_movehl(const Packet4f& a, const Packet4f& b)
+{
+  return shuffle2<false>(b,a,eigen_neon_shuffle_mask(2, 3, 2, 3));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_unpacklo(const Packet4f& a, const Packet4f& b)
+{
+  return shuffle2<true>(a,b,eigen_neon_shuffle_mask(0, 0, 1, 1));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_unpackhi(const Packet4f& a, const Packet4f& b)
+{
+  return shuffle2<true>(a,b,eigen_neon_shuffle_mask(2, 2, 3, 3));
+}
+#define vec4f_duplane(a, p) \
+  vdupq_lane_f32(vget_low_f32(a), p)
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  const Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1<int32_t>(X))
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  const Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+#if EIGEN_ARCH_ARM64
+  // __builtin_prefetch tends to do nothing on ARM64 compilers because the
+  // prefetch instructions there are too detailed for __builtin_prefetch to map
+  // meaningfully to them.
+  #define EIGEN_ARM_PREFETCH(ADDR)  __asm__ __volatile__("prfm pldl1keep, [%[addr]]\n" ::[addr] "r"(ADDR) : );
+#elif EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  #define EIGEN_ARM_PREFETCH(ADDR) __builtin_prefetch(ADDR);
+#elif defined __pld
+  #define EIGEN_ARM_PREFETCH(ADDR) __pld(ADDR)
+#elif EIGEN_ARCH_ARM32
+  #define EIGEN_ARM_PREFETCH(ADDR) __asm__ __volatile__ ("pld [%[addr]]\n" :: [addr] "r" (ADDR) : );
+#else
+  // by default no explicit prefetching
+  #define EIGEN_ARM_PREFETCH(ADDR)
+#endif
+
+template <>
+struct packet_traits<float> : default_packet_traits
+{
+  typedef Packet4f type;
+  typedef Packet2f half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+
+    HasDiv   = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+
+    HasSin  = EIGEN_FAST_MATH,
+    HasCos  = EIGEN_FAST_MATH,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf  = EIGEN_FAST_MATH,
+    HasBessel = 0,  // Issues with accuracy.
+    HasNdtri = 0
+  };
+};
+
+template <>
+struct packet_traits<int8_t> : default_packet_traits
+{
+  typedef Packet16c type;
+  typedef Packet8c half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasAbsDiff   = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0
+  };
+};
+
+template <>
+struct packet_traits<uint8_t> : default_packet_traits
+{
+  typedef Packet16uc type;
+  typedef Packet8uc half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 0,
+    HasAbs       = 1,
+    HasAbsDiff   = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+
+    HasSqrt = 1
+  };
+};
+
+template <>
+struct packet_traits<int16_t> : default_packet_traits
+{
+  typedef Packet8s type;
+  typedef Packet4s half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasAbsDiff   = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0
+  };
+};
+
+template <>
+struct packet_traits<uint16_t> : default_packet_traits
+{
+  typedef Packet8us type;
+  typedef Packet4us half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 0,
+    HasAbs       = 0,
+    HasAbsDiff   = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+    HasSqrt = 1
+  };
+};
+
+template <>
+struct packet_traits<int32_t> : default_packet_traits
+{
+  typedef Packet4i type;
+  typedef Packet2i half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0
+  };
+};
+
+template <>
+struct packet_traits<uint32_t> : default_packet_traits
+{
+  typedef Packet4ui type;
+  typedef Packet2ui half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 0,
+    HasAbs       = 0,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+
+    HasSqrt = 1
+  };
+};
+
+template <>
+struct packet_traits<int64_t> : default_packet_traits
+{
+  typedef Packet2l type;
+  typedef Packet2l half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasCmp       = 1,
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0
+  };
+};
+
+template <>
+struct packet_traits<uint64_t> : default_packet_traits
+{
+  typedef Packet2ul type;
+  typedef Packet2ul half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasCmp       = 1,
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 0,
+    HasAbs       = 0,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0
+  };
+};
+
+#if EIGEN_GNUC_AT_MOST(4, 4) && !EIGEN_COMP_LLVM
+// workaround gcc 4.2, 4.3 and 4.4 compilation issue
+EIGEN_STRONG_INLINE float32x4_t vld1q_f32(const float* x) { return ::vld1q_f32((const float32_t*)x); }
+EIGEN_STRONG_INLINE float32x2_t vld1_f32(const float* x) { return ::vld1_f32 ((const float32_t*)x); }
+EIGEN_STRONG_INLINE float32x2_t vld1_dup_f32(const float* x) { return ::vld1_dup_f32 ((const float32_t*)x); }
+EIGEN_STRONG_INLINE void vst1q_f32(float* to, float32x4_t from) { ::vst1q_f32((float32_t*)to,from); }
+EIGEN_STRONG_INLINE void vst1_f32 (float* to, float32x2_t from) { ::vst1_f32 ((float32_t*)to,from); }
+#endif
+
+template<> struct unpacket_traits<Packet2f>
+{
+  typedef float type;
+  typedef Packet2f half;
+  typedef Packet2i integer_packet;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4f>
+{
+  typedef float type;
+  typedef Packet2f half;
+  typedef Packet4i integer_packet;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4c>
+{
+  typedef int8_t type;
+  typedef Packet4c half;
+  enum
+  {
+    size = 4,
+    alignment = Unaligned,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet8c>
+{
+  typedef int8_t type;
+  typedef Packet4c half;
+  enum
+  {
+    size = 8,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet16c>
+{
+  typedef int8_t type;
+  typedef Packet8c half;
+  enum
+  {
+    size = 16,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4uc>
+{
+  typedef uint8_t type;
+  typedef Packet4uc half;
+  enum
+  {
+    size = 4,
+    alignment = Unaligned,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet8uc>
+{
+  typedef uint8_t type;
+  typedef Packet4uc half;
+  enum
+  {
+    size = 8,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet16uc>
+{
+  typedef uint8_t type;
+  typedef Packet8uc half;
+  enum
+  {
+    size = 16,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false};
+};
+template<> struct unpacket_traits<Packet4s>
+{
+  typedef int16_t type;
+  typedef Packet4s half;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet8s>
+{
+  typedef int16_t type;
+  typedef Packet4s half;
+  enum
+  {
+    size = 8,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4us>
+{
+  typedef uint16_t type;
+  typedef Packet4us half;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet8us>
+{
+  typedef uint16_t type;
+  typedef Packet4us half;
+  enum
+  {
+    size = 8,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet2i>
+{
+  typedef int32_t type;
+  typedef Packet2i half;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4i>
+{
+  typedef int32_t type;
+  typedef Packet2i half;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet2ui>
+{
+  typedef uint32_t type;
+  typedef Packet2ui half;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4ui>
+{
+  typedef uint32_t type;
+  typedef Packet2ui half;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet2l>
+{
+  typedef int64_t type;
+  typedef Packet2l half;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet2ul>
+{
+  typedef uint64_t type;
+  typedef Packet2ul half;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet2f pset1<Packet2f>(const float& from) { return vdup_n_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) { return vdupq_n_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4c pset1<Packet4c>(const int8_t& from)
+{ return vget_lane_s32(vreinterpret_s32_s8(vdup_n_s8(from)), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c pset1<Packet8c>(const int8_t& from) { return vdup_n_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet16c pset1<Packet16c>(const int8_t& from) { return vdupq_n_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet4uc pset1<Packet4uc>(const uint8_t& from)
+{ return vget_lane_u32(vreinterpret_u32_u8(vdup_n_u8(from)), 0); }
+template<> EIGEN_STRONG_INLINE Packet8uc pset1<Packet8uc>(const uint8_t& from) { return vdup_n_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet16uc pset1<Packet16uc>(const uint8_t& from) { return vdupq_n_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet4s pset1<Packet4s>(const int16_t& from) { return vdup_n_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet8s pset1<Packet8s>(const int16_t& from) { return vdupq_n_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet4us pset1<Packet4us>(const uint16_t& from) { return vdup_n_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet8us pset1<Packet8us>(const uint16_t& from) { return vdupq_n_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet2i pset1<Packet2i>(const int32_t& from) { return vdup_n_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int32_t& from) { return vdupq_n_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet2ui pset1<Packet2ui>(const uint32_t& from) { return vdup_n_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet4ui pset1<Packet4ui>(const uint32_t& from) { return vdupq_n_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet2l pset1<Packet2l>(const int64_t& from) { return vdupq_n_s64(from); }
+template<> EIGEN_STRONG_INLINE Packet2ul pset1<Packet2ul>(const uint64_t& from) { return vdupq_n_u64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pset1frombits<Packet2f>(unsigned int from)
+{ return vreinterpret_f32_u32(vdup_n_u32(from)); }
+template<> EIGEN_STRONG_INLINE Packet4f pset1frombits<Packet4f>(unsigned int from)
+{ return vreinterpretq_f32_u32(vdupq_n_u32(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet2f plset<Packet2f>(const float& a)
+{
+  const float c[] = {0.0f,1.0f};
+  return vadd_f32(pset1<Packet2f>(a), vld1_f32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a)
+{
+  const float c[] = {0.0f,1.0f,2.0f,3.0f};
+  return vaddq_f32(pset1<Packet4f>(a), vld1q_f32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4c plset<Packet4c>(const int8_t& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vadd_s8(vreinterpret_s8_u32(vdup_n_u32(0x03020100)), vdup_n_s8(a))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c plset<Packet8c>(const int8_t& a)
+{
+  const int8_t c[] = {0,1,2,3,4,5,6,7};
+  return vadd_s8(pset1<Packet8c>(a), vld1_s8(c));
+}
+template<> EIGEN_STRONG_INLINE Packet16c plset<Packet16c>(const int8_t& a)
+{
+  const int8_t c[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+  return vaddq_s8(pset1<Packet16c>(a), vld1q_s8(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4uc plset<Packet4uc>(const uint8_t& a)
+{ return vget_lane_u32(vreinterpret_u32_u8(vadd_u8(vreinterpret_u8_u32(vdup_n_u32(0x03020100)), vdup_n_u8(a))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8uc plset<Packet8uc>(const uint8_t& a)
+{
+  const uint8_t c[] = {0,1,2,3,4,5,6,7};
+  return vadd_u8(pset1<Packet8uc>(a), vld1_u8(c));
+}
+template<> EIGEN_STRONG_INLINE Packet16uc plset<Packet16uc>(const uint8_t& a)
+{
+  const uint8_t c[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+  return vaddq_u8(pset1<Packet16uc>(a), vld1q_u8(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4s plset<Packet4s>(const int16_t& a)
+{
+  const int16_t c[] = {0,1,2,3};
+  return vadd_s16(pset1<Packet4s>(a), vld1_s16(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4us plset<Packet4us>(const uint16_t& a)
+{
+  const uint16_t c[] = {0,1,2,3};
+  return vadd_u16(pset1<Packet4us>(a), vld1_u16(c));
+}
+template<> EIGEN_STRONG_INLINE Packet8s plset<Packet8s>(const int16_t& a)
+{
+  const int16_t c[] = {0,1,2,3,4,5,6,7};
+  return vaddq_s16(pset1<Packet8s>(a), vld1q_s16(c));
+}
+template<> EIGEN_STRONG_INLINE Packet8us plset<Packet8us>(const uint16_t& a)
+{
+  const uint16_t c[] = {0,1,2,3,4,5,6,7};
+  return vaddq_u16(pset1<Packet8us>(a), vld1q_u16(c));
+}
+template<> EIGEN_STRONG_INLINE Packet2i plset<Packet2i>(const int32_t& a)
+{
+  const int32_t c[] = {0,1};
+  return vadd_s32(pset1<Packet2i>(a), vld1_s32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int32_t& a)
+{
+  const int32_t c[] = {0,1,2,3};
+  return vaddq_s32(pset1<Packet4i>(a), vld1q_s32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet2ui plset<Packet2ui>(const uint32_t& a)
+{
+  const uint32_t c[] = {0,1};
+  return vadd_u32(pset1<Packet2ui>(a), vld1_u32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4ui plset<Packet4ui>(const uint32_t& a)
+{
+  const uint32_t c[] = {0,1,2,3};
+  return vaddq_u32(pset1<Packet4ui>(a), vld1q_u32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet2l plset<Packet2l>(const int64_t& a)
+{
+  const int64_t c[] = {0,1};
+  return vaddq_s64(pset1<Packet2l>(a), vld1q_s64(c));
+}
+template<> EIGEN_STRONG_INLINE Packet2ul plset<Packet2ul>(const uint64_t& a)
+{
+  const uint64_t c[] = {0,1};
+  return vaddq_u64(pset1<Packet2ul>(a), vld1q_u64(c));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f padd<Packet2f>(const Packet2f& a, const Packet2f& b) { return vadd_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return vaddq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4c padd<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vadd_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c padd<Packet8c>(const Packet8c& a, const Packet8c& b) { return vadd_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c padd<Packet16c>(const Packet16c& a, const Packet16c& b) { return vaddq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc padd<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vadd_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc padd<Packet8uc>(const Packet8uc& a, const Packet8uc& b) { return vadd_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc padd<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vaddq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s padd<Packet4s>(const Packet4s& a, const Packet4s& b) { return vadd_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s padd<Packet8s>(const Packet8s& a, const Packet8s& b) { return vaddq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us padd<Packet4us>(const Packet4us& a, const Packet4us& b) { return vadd_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us padd<Packet8us>(const Packet8us& a, const Packet8us& b) { return vaddq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i padd<Packet2i>(const Packet2i& a, const Packet2i& b) { return vadd_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return vaddq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui padd<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vadd_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui padd<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vaddq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l padd<Packet2l>(const Packet2l& a, const Packet2l& b) { return vaddq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul padd<Packet2ul>(const Packet2ul& a, const Packet2ul& b) { return vaddq_u64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f psub<Packet2f>(const Packet2f& a, const Packet2f& b) { return vsub_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return vsubq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4c psub<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vsub_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c psub<Packet8c>(const Packet8c& a, const Packet8c& b) { return vsub_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c psub<Packet16c>(const Packet16c& a, const Packet16c& b) { return vsubq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc psub<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vsub_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc psub<Packet8uc>(const Packet8uc& a, const Packet8uc& b) { return vsub_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc psub<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vsubq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s psub<Packet4s>(const Packet4s& a, const Packet4s& b) { return vsub_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s psub<Packet8s>(const Packet8s& a, const Packet8s& b) { return vsubq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us psub<Packet4us>(const Packet4us& a, const Packet4us& b) { return vsub_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us psub<Packet8us>(const Packet8us& a, const Packet8us& b) { return vsubq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i psub<Packet2i>(const Packet2i& a, const Packet2i& b) { return vsub_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return vsubq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui psub<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vsub_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui psub<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vsubq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l psub<Packet2l>(const Packet2l& a, const Packet2l& b) { return vsubq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul psub<Packet2ul>(const Packet2ul& a, const Packet2ul& b) { return vsubq_u64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pxor<Packet2f>(const Packet2f& a, const Packet2f& b);
+template<> EIGEN_STRONG_INLINE Packet2f paddsub<Packet2f>(const Packet2f& a, const Packet2f & b) {
+  Packet2f mask = {numext::bit_cast<float>(0x80000000u), 0.0f};
+  return padd(a, pxor(mask, b));
+}
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b);
+template<> EIGEN_STRONG_INLINE Packet4f paddsub<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  Packet4f mask = {numext::bit_cast<float>(0x80000000u), 0.0f, numext::bit_cast<float>(0x80000000u), 0.0f};
+  return padd(a, pxor(mask, b));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pnegate(const Packet2f& a) { return vneg_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return vnegq_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4c pnegate(const Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vneg_s8(vreinterpret_s8_s32(vdup_n_s32(a)))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c pnegate(const Packet8c& a) { return vneg_s8(a); }
+template<> EIGEN_STRONG_INLINE Packet16c pnegate(const Packet16c& a) { return vnegq_s8(a); }
+template<> EIGEN_STRONG_INLINE Packet4s pnegate(const Packet4s& a) { return vneg_s16(a); }
+template<> EIGEN_STRONG_INLINE Packet8s pnegate(const Packet8s& a) { return vnegq_s16(a); }
+template<> EIGEN_STRONG_INLINE Packet2i pnegate(const Packet2i& a) { return vneg_s32(a); }
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return vnegq_s32(a); }
+template<> EIGEN_STRONG_INLINE Packet2l pnegate(const Packet2l& a) {
+#if EIGEN_ARCH_ARM64
+  return vnegq_s64(a);
+#else
+  return vcombine_s64(
+      vdup_n_s64(-vgetq_lane_s64(a, 0)),
+      vdup_n_s64(-vgetq_lane_s64(a, 1)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pconj(const Packet2f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4c pconj(const Packet4c& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8c pconj(const Packet8c& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet16c pconj(const Packet16c& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4uc pconj(const Packet4uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8uc pconj(const Packet8uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet16uc pconj(const Packet16uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4s pconj(const Packet4s& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8s pconj(const Packet8s& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4us pconj(const Packet4us& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8us pconj(const Packet8us& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2i pconj(const Packet2i& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2ui pconj(const Packet2ui& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4ui pconj(const Packet4ui& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2l pconj(const Packet2l& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2ul pconj(const Packet2ul& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet2f pmul<Packet2f>(const Packet2f& a, const Packet2f& b) { return vmul_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmulq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4c pmul<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vmul_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pmul<Packet8c>(const Packet8c& a, const Packet8c& b) { return vmul_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmul<Packet16c>(const Packet16c& a, const Packet16c& b) { return vmulq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pmul<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vmul_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pmul<Packet8uc>(const Packet8uc& a, const Packet8uc& b) { return vmul_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmul<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vmulq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pmul<Packet4s>(const Packet4s& a, const Packet4s& b) { return vmul_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmul<Packet8s>(const Packet8s& a, const Packet8s& b) { return vmulq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pmul<Packet4us>(const Packet4us& a, const Packet4us& b) { return vmul_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmul<Packet8us>(const Packet8us& a, const Packet8us& b) { return vmulq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pmul<Packet2i>(const Packet2i& a, const Packet2i& b) { return vmul_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmulq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pmul<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vmul_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pmul<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vmulq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pmul<Packet2l>(const Packet2l& a, const Packet2l& b) {
+  return vcombine_s64(
+    vdup_n_s64(vgetq_lane_s64(a, 0)*vgetq_lane_s64(b, 0)),
+    vdup_n_s64(vgetq_lane_s64(a, 1)*vgetq_lane_s64(b, 1)));
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pmul<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
+  return vcombine_u64(
+    vdup_n_u64(vgetq_lane_u64(a, 0)*vgetq_lane_u64(b, 0)),
+    vdup_n_u64(vgetq_lane_u64(a, 1)*vgetq_lane_u64(b, 1)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pdiv<Packet2f>(const Packet2f& a, const Packet2f& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vdiv_f32(a,b);
+#else
+  Packet2f inv, restep, div;
+
+  // NEON does not offer a divide instruction, we have to do a reciprocal approximation
+  // However NEON in contrast to other SIMD engines (AltiVec/SSE), offers
+  // a reciprocal estimate AND a reciprocal step -which saves a few instructions
+  // vrecpeq_f32() returns an estimate to 1/b, which we will finetune with
+  // Newton-Raphson and vrecpsq_f32()
+  inv = vrecpe_f32(b);
+
+  // This returns a differential, by which we will have to multiply inv to get a better
+  // approximation of 1/b.
+  restep = vrecps_f32(b, inv);
+  inv = vmul_f32(restep, inv);
+
+  // Finally, multiply a by 1/b and get the wanted result of the division.
+  div = vmul_f32(a, inv);
+
+  return div;
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vdivq_f32(a,b);
+#else
+  Packet4f inv, restep, div;
+
+  // NEON does not offer a divide instruction, we have to do a reciprocal approximation
+  // However NEON in contrast to other SIMD engines (AltiVec/SSE), offers
+  // a reciprocal estimate AND a reciprocal step -which saves a few instructions
+  // vrecpeq_f32() returns an estimate to 1/b, which we will finetune with
+  // Newton-Raphson and vrecpsq_f32()
+  inv = vrecpeq_f32(b);
+
+  // This returns a differential, by which we will have to multiply inv to get a better
+  // approximation of 1/b.
+  restep = vrecpsq_f32(b, inv);
+  inv = vmulq_f32(restep, inv);
+
+  // Finally, multiply a by 1/b and get the wanted result of the division.
+  div = vmulq_f32(a, inv);
+
+  return div;
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4c pdiv<Packet4c>(const Packet4c& /*a*/, const Packet4c& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4c>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pdiv<Packet8c>(const Packet8c& /*a*/, const Packet8c& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet8c>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet16c pdiv<Packet16c>(const Packet16c& /*a*/, const Packet16c& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet16c>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet4uc pdiv<Packet4uc>(const Packet4uc& /*a*/, const Packet4uc& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4uc>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pdiv<Packet8uc>(const Packet8uc& /*a*/, const Packet8uc& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet8uc>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet16uc pdiv<Packet16uc>(const Packet16uc& /*a*/, const Packet16uc& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet16uc>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet4s pdiv<Packet4s>(const Packet4s& /*a*/, const Packet4s& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4s>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet8s pdiv<Packet8s>(const Packet8s& /*a*/, const Packet8s& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet8s>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet4us pdiv<Packet4us>(const Packet4us& /*a*/, const Packet4us& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4us>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet8us pdiv<Packet8us>(const Packet8us& /*a*/, const Packet8us& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet8us>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet2i pdiv<Packet2i>(const Packet2i& /*a*/, const Packet2i& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet2i>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4i>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet2ui pdiv<Packet2ui>(const Packet2ui& /*a*/, const Packet2ui& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet2ui>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet4ui pdiv<Packet4ui>(const Packet4ui& /*a*/, const Packet4ui& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4ui>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet2l pdiv<Packet2l>(const Packet2l& /*a*/, const Packet2l& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet2l>(0LL);
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pdiv<Packet2ul>(const Packet2ul& /*a*/, const Packet2ul& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet2ul>(0ULL);
+}
+
+
+#ifdef __ARM_FEATURE_FMA
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
+{ return vfmaq_f32(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet2f pmadd(const Packet2f& a, const Packet2f& b, const Packet2f& c)
+{ return vfma_f32(c,a,b); }
+#else
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
+{
+  return vmlaq_f32(c,a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet2f pmadd(const Packet2f& a, const Packet2f& b, const Packet2f& c)
+{
+  return vmla_f32(c,a,b);
+}
+#endif
+
+// No FMA instruction for int, so use MLA unconditionally.
+template<> EIGEN_STRONG_INLINE Packet4c pmadd(const Packet4c& a, const Packet4c& b, const Packet4c& c)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vmla_s8(
+      vreinterpret_s8_s32(vdup_n_s32(c)),
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pmadd(const Packet8c& a, const Packet8c& b, const Packet8c& c)
+{ return vmla_s8(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmadd(const Packet16c& a, const Packet16c& b, const Packet16c& c)
+{ return vmlaq_s8(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pmadd(const Packet4uc& a, const Packet4uc& b, const Packet4uc& c)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vmla_u8(
+      vreinterpret_u8_u32(vdup_n_u32(c)),
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pmadd(const Packet8uc& a, const Packet8uc& b, const Packet8uc& c)
+{ return vmla_u8(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmadd(const Packet16uc& a, const Packet16uc& b, const Packet16uc& c)
+{ return vmlaq_u8(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pmadd(const Packet4s& a, const Packet4s& b, const Packet4s& c)
+{ return vmla_s16(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmadd(const Packet8s& a, const Packet8s& b, const Packet8s& c)
+{ return vmlaq_s16(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pmadd(const Packet4us& a, const Packet4us& b, const Packet4us& c)
+{ return vmla_u16(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmadd(const Packet8us& a, const Packet8us& b, const Packet8us& c)
+{ return vmlaq_u16(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pmadd(const Packet2i& a, const Packet2i& b, const Packet2i& c)
+{ return vmla_s32(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c)
+{ return vmlaq_s32(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pmadd(const Packet2ui& a, const Packet2ui& b, const Packet2ui& c)
+{ return vmla_u32(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pmadd(const Packet4ui& a, const Packet4ui& b, const Packet4ui& c)
+{ return vmlaq_u32(c,a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pabsdiff<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vabd_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pabsdiff<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vabdq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4c pabsdiff<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vabd_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pabsdiff<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return vabd_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pabsdiff<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vabdq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pabsdiff<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vabd_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pabsdiff<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vabd_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pabsdiff<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vabdq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pabsdiff<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vabd_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pabsdiff<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vabdq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pabsdiff<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vabd_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pabsdiff<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vabdq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pabsdiff<Packet2i>(const Packet2i& a, const Packet2i& b)
+{ return vabd_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pabsdiff<Packet4i>(const Packet4i& a, const Packet4i& b)
+{ return vabdq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pabsdiff<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vabd_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pabsdiff<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vabdq_u32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pmin<Packet2f>(const Packet2f& a, const Packet2f& b) { return vmin_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) { return vminq_f32(a,b); }
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+// numeric max and min are only available if ARM_FEATURE_NUMERIC_MAXMIN is defined (which can only be the case for Armv8 systems).
+template<> EIGEN_STRONG_INLINE Packet4f pmin<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) { return vminnmq_f32(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2f pmin<PropagateNumbers, Packet2f>(const Packet2f& a, const Packet2f& b) { return vminnm_f32(a, b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) { return pmin<Packet4f>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pmin<PropagateNaN, Packet2f>(const Packet2f& a, const Packet2f& b) { return pmin<Packet2f>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4c pmin<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vmin_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pmin<Packet8c>(const Packet8c& a, const Packet8c& b) { return vmin_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmin<Packet16c>(const Packet16c& a, const Packet16c& b) { return vminq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pmin<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vmin_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pmin<Packet8uc>(const Packet8uc& a, const Packet8uc& b) { return vmin_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmin<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vminq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pmin<Packet4s>(const Packet4s& a, const Packet4s& b) { return vmin_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmin<Packet8s>(const Packet8s& a, const Packet8s& b) { return vminq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pmin<Packet4us>(const Packet4us& a, const Packet4us& b) { return vmin_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmin<Packet8us>(const Packet8us& a, const Packet8us& b) { return vminq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pmin<Packet2i>(const Packet2i& a, const Packet2i& b) { return vmin_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vminq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pmin<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vmin_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pmin<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vminq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pmin<Packet2l>(const Packet2l& a, const Packet2l& b) {
+  return vcombine_s64(
+      vdup_n_s64((std::min)(vgetq_lane_s64(a, 0), vgetq_lane_s64(b, 0))),
+      vdup_n_s64((std::min)(vgetq_lane_s64(a, 1), vgetq_lane_s64(b, 1))));
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pmin<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
+  return vcombine_u64(
+      vdup_n_u64((std::min)(vgetq_lane_u64(a, 0), vgetq_lane_u64(b, 0))),
+      vdup_n_u64((std::min)(vgetq_lane_u64(a, 1), vgetq_lane_u64(b, 1))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pmax<Packet2f>(const Packet2f& a, const Packet2f& b) { return vmax_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmaxq_f32(a,b); }
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+// numeric max and min are only available if ARM_FEATURE_NUMERIC_MAXMIN is defined (which can only be the case for Armv8 systems).
+template<> EIGEN_STRONG_INLINE Packet4f pmax<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) { return vmaxnmq_f32(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2f pmax<PropagateNumbers, Packet2f>(const Packet2f& a, const Packet2f& b) { return vmaxnm_f32(a, b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) { return pmax<Packet4f>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pmax<PropagateNaN, Packet2f>(const Packet2f& a, const Packet2f& b) { return pmax<Packet2f>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4c pmax<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vmax_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pmax<Packet8c>(const Packet8c& a, const Packet8c& b) { return vmax_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmax<Packet16c>(const Packet16c& a, const Packet16c& b) { return vmaxq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pmax<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vmax_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pmax<Packet8uc>(const Packet8uc& a, const Packet8uc& b) { return vmax_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmax<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vmaxq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pmax<Packet4s>(const Packet4s& a, const Packet4s& b) { return vmax_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmax<Packet8s>(const Packet8s& a, const Packet8s& b) { return vmaxq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pmax<Packet4us>(const Packet4us& a, const Packet4us& b) { return vmax_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmax<Packet8us>(const Packet8us& a, const Packet8us& b) { return vmaxq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pmax<Packet2i>(const Packet2i& a, const Packet2i& b) { return vmax_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmaxq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pmax<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vmax_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pmax<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vmaxq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pmax<Packet2l>(const Packet2l& a, const Packet2l& b) {
+  return vcombine_s64(
+      vdup_n_s64((std::max)(vgetq_lane_s64(a, 0), vgetq_lane_s64(b, 0))),
+      vdup_n_s64((std::max)(vgetq_lane_s64(a, 1), vgetq_lane_s64(b, 1))));
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pmax<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
+  return vcombine_u64(
+      vdup_n_u64((std::max)(vgetq_lane_u64(a, 0), vgetq_lane_u64(b, 0))),
+      vdup_n_u64((std::max)(vgetq_lane_u64(a, 1), vgetq_lane_u64(b, 1))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pcmp_le<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vcle_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_le<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vcleq_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4c pcmp_le<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_u8(vcle_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pcmp_le<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return vreinterpret_s8_u8(vcle_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_le<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vreinterpretq_s8_u8(vcleq_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4uc pcmp_le<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vcle_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pcmp_le<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vcle_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_le<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vcleq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pcmp_le<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vreinterpret_s16_u16(vcle_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_le<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vreinterpretq_s16_u16(vcleq_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4us pcmp_le<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vcle_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_le<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vcleq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pcmp_le<Packet2i>(const Packet2i& a, const Packet2i& b)
+{ return vreinterpret_s32_u32(vcle_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_le<Packet4i>(const Packet4i& a, const Packet4i& b)
+{ return vreinterpretq_s32_u32(vcleq_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2ui pcmp_le<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vcle_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pcmp_le<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vcleq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pcmp_le<Packet2l>(const Packet2l& a, const Packet2l& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vreinterpretq_s64_u64(vcleq_s64(a,b));
+#else
+  return vcombine_s64(
+      vdup_n_s64(vgetq_lane_s64(a, 0) <= vgetq_lane_s64(b, 0) ? numext::int64_t(-1) : 0),
+      vdup_n_s64(vgetq_lane_s64(a, 1) <= vgetq_lane_s64(b, 1) ? numext::int64_t(-1) : 0));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pcmp_le<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vcleq_u64(a,b);
+#else
+  return vcombine_u64(
+      vdup_n_u64(vgetq_lane_u64(a, 0) <= vgetq_lane_u64(b, 0) ? numext::uint64_t(-1) : 0),
+      vdup_n_u64(vgetq_lane_u64(a, 1) <= vgetq_lane_u64(b, 1) ? numext::uint64_t(-1) : 0));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pcmp_lt<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vclt_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vcltq_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4c pcmp_lt<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_u8(vclt_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pcmp_lt<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return vreinterpret_s8_u8(vclt_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_lt<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vreinterpretq_s8_u8(vcltq_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4uc pcmp_lt<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vclt_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pcmp_lt<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vclt_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_lt<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vcltq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pcmp_lt<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vreinterpret_s16_u16(vclt_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_lt<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vreinterpretq_s16_u16(vcltq_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4us pcmp_lt<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vclt_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_lt<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vcltq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pcmp_lt<Packet2i>(const Packet2i& a, const Packet2i& b)
+{ return vreinterpret_s32_u32(vclt_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_lt<Packet4i>(const Packet4i& a, const Packet4i& b)
+{ return vreinterpretq_s32_u32(vcltq_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2ui pcmp_lt<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vclt_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pcmp_lt<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vcltq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pcmp_lt<Packet2l>(const Packet2l& a, const Packet2l& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vreinterpretq_s64_u64(vcltq_s64(a,b));
+#else
+  return vcombine_s64(
+      vdup_n_s64(vgetq_lane_s64(a, 0) < vgetq_lane_s64(b, 0) ? numext::int64_t(-1) : 0),
+      vdup_n_s64(vgetq_lane_s64(a, 1) < vgetq_lane_s64(b, 1) ? numext::int64_t(-1) : 0));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pcmp_lt<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vcltq_u64(a,b);
+#else
+  return vcombine_u64(
+      vdup_n_u64(vgetq_lane_u64(a, 0) < vgetq_lane_u64(b, 0) ? numext::uint64_t(-1) : 0),
+      vdup_n_u64(vgetq_lane_u64(a, 1) < vgetq_lane_u64(b, 1) ? numext::uint64_t(-1) : 0));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pcmp_eq<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vceq_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_eq<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vceqq_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4c pcmp_eq<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_u8(vceq_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pcmp_eq<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return vreinterpret_s8_u8(vceq_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_eq<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vreinterpretq_s8_u8(vceqq_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4uc pcmp_eq<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vceq_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pcmp_eq<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vceq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_eq<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vceqq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pcmp_eq<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vreinterpret_s16_u16(vceq_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_eq<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vreinterpretq_s16_u16(vceqq_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4us pcmp_eq<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vceq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_eq<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vceqq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pcmp_eq<Packet2i>(const Packet2i& a, const Packet2i& b)
+{ return vreinterpret_s32_u32(vceq_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_eq<Packet4i>(const Packet4i& a, const Packet4i& b)
+{ return vreinterpretq_s32_u32(vceqq_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2ui pcmp_eq<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vceq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pcmp_eq<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vceqq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pcmp_eq<Packet2l>(const Packet2l& a, const Packet2l& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vreinterpretq_s64_u64(vceqq_s64(a,b));
+#else
+  return vcombine_s64(
+      vdup_n_s64(vgetq_lane_s64(a, 0) == vgetq_lane_s64(b, 0) ? numext::int64_t(-1) : 0),
+      vdup_n_s64(vgetq_lane_s64(a, 1) == vgetq_lane_s64(b, 1) ? numext::int64_t(-1) : 0));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pcmp_eq<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vceqq_u64(a,b);
+#else
+  return vcombine_u64(
+      vdup_n_u64(vgetq_lane_u64(a, 0) == vgetq_lane_u64(b, 0) ? numext::uint64_t(-1) : 0),
+      vdup_n_u64(vgetq_lane_u64(a, 1) == vgetq_lane_u64(b, 1) ? numext::uint64_t(-1) : 0));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pcmp_lt_or_nan<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vmvn_u32(vcge_f32(a,b))); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vmvnq_u32(vcgeq_f32(a,b))); }
+
+// Logical Operations are not supported for float, so we have to reinterpret casts using NEON intrinsics
+template<> EIGEN_STRONG_INLINE Packet2f pand<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vand_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4c pand<Packet4c>(const Packet4c& a, const Packet4c& b)
+{ return a & b; }
+template<> EIGEN_STRONG_INLINE Packet8c pand<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return vand_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pand<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vandq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pand<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{ return a & b; }
+template<> EIGEN_STRONG_INLINE Packet8uc pand<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vand_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pand<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vandq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pand<Packet4s>(const Packet4s& a, const Packet4s& b) { return vand_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pand<Packet8s>(const Packet8s& a, const Packet8s& b) { return vandq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pand<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vand_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pand<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vandq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pand<Packet2i>(const Packet2i& a, const Packet2i& b) { return vand_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vandq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pand<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vand_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pand<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vandq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pand<Packet2l>(const Packet2l& a, const Packet2l& b) { return vandq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul pand<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{ return vandq_u64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f por<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vorr_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4c por<Packet4c>(const Packet4c& a, const Packet4c& b)
+{ return a | b; }
+template<> EIGEN_STRONG_INLINE Packet8c por<Packet8c>(const Packet8c& a, const Packet8c& b) { return vorr_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c por<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vorrq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc por<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{ return a | b; }
+template<> EIGEN_STRONG_INLINE Packet8uc por<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vorr_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc por<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vorrq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s por<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vorr_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s por<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vorrq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us por<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vorr_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us por<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vorrq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i por<Packet2i>(const Packet2i& a, const Packet2i& b) { return vorr_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vorrq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui por<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vorr_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui por<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vorrq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l por<Packet2l>(const Packet2l& a, const Packet2l& b)
+{ return vorrq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul por<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{ return vorrq_u64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pxor<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4c pxor<Packet4c>(const Packet4c& a, const Packet4c& b)
+{ return a ^ b; }
+template<> EIGEN_STRONG_INLINE Packet8c pxor<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return veor_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pxor<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return veorq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pxor<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{ return a ^ b; }
+template<> EIGEN_STRONG_INLINE Packet8uc pxor<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return veor_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pxor<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return veorq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pxor<Packet4s>(const Packet4s& a, const Packet4s& b) { return veor_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pxor<Packet8s>(const Packet8s& a, const Packet8s& b) { return veorq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pxor<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return veor_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pxor<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return veorq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pxor<Packet2i>(const Packet2i& a, const Packet2i& b) { return veor_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return veorq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pxor<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return veor_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pxor<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return veorq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pxor<Packet2l>(const Packet2l& a, const Packet2l& b)
+{ return veorq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul pxor<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{ return veorq_u64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pandnot<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vbic_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4c pandnot<Packet4c>(const Packet4c& a, const Packet4c& b)
+{ return a & ~b; }
+template<> EIGEN_STRONG_INLINE Packet8c pandnot<Packet8c>(const Packet8c& a, const Packet8c& b) { return vbic_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pandnot<Packet16c>(const Packet16c& a, const Packet16c& b) { return vbicq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pandnot<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{ return a & ~b; }
+template<> EIGEN_STRONG_INLINE Packet8uc pandnot<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vbic_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pandnot<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vbicq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pandnot<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vbic_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pandnot<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vbicq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pandnot<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vbic_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pandnot<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vbicq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pandnot<Packet2i>(const Packet2i& a, const Packet2i& b)
+{ return vbic_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b)
+{ return vbicq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pandnot<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vbic_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pandnot<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vbicq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pandnot<Packet2l>(const Packet2l& a, const Packet2l& b)
+{ return vbicq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul pandnot<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{ return vbicq_u64(a,b); }
+
+
+template<int N> EIGEN_STRONG_INLINE Packet4c parithmetic_shift_right(Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vshr_n_s8(vreinterpret_s8_s32(vdup_n_s32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8c parithmetic_shift_right(Packet8c a) { return vshr_n_s8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet16c parithmetic_shift_right(Packet16c a) { return vshrq_n_s8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4uc parithmetic_shift_right(Packet4uc& a)
+{ return vget_lane_u32(vreinterpret_u32_u8(vshr_n_u8(vreinterpret_u8_u32(vdup_n_u32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8uc parithmetic_shift_right(Packet8uc a) { return vshr_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet16uc parithmetic_shift_right(Packet16uc a) { return vshrq_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4s parithmetic_shift_right(Packet4s a) { return vshr_n_s16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet8s parithmetic_shift_right(Packet8s a) { return vshrq_n_s16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4us parithmetic_shift_right(Packet4us a) { return vshr_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet8us parithmetic_shift_right(Packet8us a) { return vshrq_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2i parithmetic_shift_right(Packet2i a) { return vshr_n_s32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(Packet4i a) { return vshrq_n_s32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2ui parithmetic_shift_right(Packet2ui a) { return vshr_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4ui parithmetic_shift_right(Packet4ui a) { return vshrq_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2l parithmetic_shift_right(Packet2l a) { return vshrq_n_s64(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2ul parithmetic_shift_right(Packet2ul a) { return vshrq_n_u64(a,N); }
+
+template<int N> EIGEN_STRONG_INLINE Packet4c plogical_shift_right(Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_u8(vshr_n_u8(vreinterpret_u8_s32(vdup_n_s32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8c plogical_shift_right(Packet8c a)
+{ return vreinterpret_s8_u8(vshr_n_u8(vreinterpret_u8_s8(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet16c plogical_shift_right(Packet16c a)
+{ return vreinterpretq_s8_u8(vshrq_n_u8(vreinterpretq_u8_s8(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet4uc plogical_shift_right(Packet4uc& a)
+{ return vget_lane_u32(vreinterpret_u32_s8(vshr_n_s8(vreinterpret_s8_u32(vdup_n_u32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8uc plogical_shift_right(Packet8uc a) { return vshr_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet16uc plogical_shift_right(Packet16uc a) { return vshrq_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4s plogical_shift_right(Packet4s a)
+{ return vreinterpret_s16_u16(vshr_n_u16(vreinterpret_u16_s16(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet8s plogical_shift_right(Packet8s a)
+{ return vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet4us plogical_shift_right(Packet4us a) { return vshr_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet8us plogical_shift_right(Packet8us a) { return vshrq_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2i plogical_shift_right(Packet2i a)
+{ return vreinterpret_s32_u32(vshr_n_u32(vreinterpret_u32_s32(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_right(Packet4i a)
+{ return vreinterpretq_s32_u32(vshrq_n_u32(vreinterpretq_u32_s32(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet2ui plogical_shift_right(Packet2ui a) { return vshr_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4ui plogical_shift_right(Packet4ui a) { return vshrq_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2l plogical_shift_right(Packet2l a)
+{ return vreinterpretq_s64_u64(vshrq_n_u64(vreinterpretq_u64_s64(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet2ul plogical_shift_right(Packet2ul a) { return vshrq_n_u64(a,N); }
+
+template<int N> EIGEN_STRONG_INLINE Packet4c plogical_shift_left(Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vshl_n_s8(vreinterpret_s8_s32(vdup_n_s32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8c plogical_shift_left(Packet8c a) { return vshl_n_s8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet16c plogical_shift_left(Packet16c a) { return vshlq_n_s8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4uc plogical_shift_left(Packet4uc& a)
+{ return vget_lane_u32(vreinterpret_u32_u8(vshl_n_u8(vreinterpret_u8_u32(vdup_n_u32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8uc plogical_shift_left(Packet8uc a) { return vshl_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet16uc plogical_shift_left(Packet16uc a) { return vshlq_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4s plogical_shift_left(Packet4s a) { return vshl_n_s16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet8s plogical_shift_left(Packet8s a) { return vshlq_n_s16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4us plogical_shift_left(Packet4us a) { return vshl_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet8us plogical_shift_left(Packet8us a) { return vshlq_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2i plogical_shift_left(Packet2i a) { return vshl_n_s32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_left(Packet4i a) { return vshlq_n_s32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2ui plogical_shift_left(Packet2ui a) { return vshl_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4ui plogical_shift_left(Packet4ui a) { return vshlq_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2l plogical_shift_left(Packet2l a) { return vshlq_n_s64(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2ul plogical_shift_left(Packet2ul a) { return vshlq_n_u64(a,N); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pload<Packet2f>(const float* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4c pload<Packet4c>(const int8_t* from)
+{
+  Packet4c res;
+  memcpy(&res, from, sizeof(Packet4c));
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet8c pload<Packet8c>(const int8_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet16c pload<Packet16c>(const int8_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet4uc pload<Packet4uc>(const uint8_t* from)
+{
+  Packet4uc res;
+  memcpy(&res, from, sizeof(Packet4uc));
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pload<Packet8uc>(const uint8_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet16uc pload<Packet16uc>(const uint8_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet4s pload<Packet4s>(const int16_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet8s pload<Packet8s>(const int16_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet4us pload<Packet4us>(const uint16_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet8us pload<Packet8us>(const uint16_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet2i pload<Packet2i>(const int32_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int32_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet2ui pload<Packet2ui>(const uint32_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet4ui pload<Packet4ui>(const uint32_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet2l pload<Packet2l>(const int64_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s64(from); }
+template<> EIGEN_STRONG_INLINE Packet2ul pload<Packet2ul>(const uint64_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_u64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2f ploadu<Packet2f>(const float* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4c ploadu<Packet4c>(const int8_t* from)
+{
+  Packet4c res;
+  memcpy(&res, from, sizeof(Packet4c));
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet8c ploadu<Packet8c>(const int8_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet16c ploadu<Packet16c>(const int8_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet4uc ploadu<Packet4uc>(const uint8_t* from)
+{
+  Packet4uc res;
+  memcpy(&res, from, sizeof(Packet4uc));
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet8uc ploadu<Packet8uc>(const uint8_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet16uc ploadu<Packet16uc>(const uint8_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet4s ploadu<Packet4s>(const int16_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet8s ploadu<Packet8s>(const int16_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet4us ploadu<Packet4us>(const uint16_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet8us ploadu<Packet8us>(const uint16_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet2i ploadu<Packet2i>(const int32_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int32_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet2ui ploadu<Packet2ui>(const uint32_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet4ui ploadu<Packet4ui>(const uint32_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet2l ploadu<Packet2l>(const int64_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s64(from); }
+template<> EIGEN_STRONG_INLINE Packet2ul ploadu<Packet2ul>(const uint64_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_u64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2f ploaddup<Packet2f>(const float* from)
+{ return vld1_dup_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float* from)
+{ return vcombine_f32(vld1_dup_f32(from), vld1_dup_f32(from+1)); }
+template<> EIGEN_STRONG_INLINE Packet4c ploaddup<Packet4c>(const int8_t* from)
+{
+  const int8x8_t a = vreinterpret_s8_s32(vdup_n_s32(pload<Packet4c>(from)));
+  return vget_lane_s32(vreinterpret_s32_s8(vzip_s8(a,a).val[0]), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c ploaddup<Packet8c>(const int8_t* from)
+{
+  const int8x8_t a = vld1_s8(from);
+  return vzip_s8(a,a).val[0];
+}
+template<> EIGEN_STRONG_INLINE Packet16c ploaddup<Packet16c>(const int8_t* from)
+{
+  const int8x8_t a = vld1_s8(from);
+  const int8x8x2_t b = vzip_s8(a,a);
+  return vcombine_s8(b.val[0], b.val[1]);
+}
+template<> EIGEN_STRONG_INLINE Packet4uc ploaddup<Packet4uc>(const uint8_t* from)
+{
+  const uint8x8_t a = vreinterpret_u8_u32(vdup_n_u32(pload<Packet4uc>(from)));
+  return vget_lane_u32(vreinterpret_u32_u8(vzip_u8(a,a).val[0]), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc ploaddup<Packet8uc>(const uint8_t* from)
+{
+  const uint8x8_t a = vld1_u8(from);
+  return vzip_u8(a,a).val[0];
+}
+template<> EIGEN_STRONG_INLINE Packet16uc ploaddup<Packet16uc>(const uint8_t* from)
+{
+  const uint8x8_t a = vld1_u8(from);
+  const uint8x8x2_t b = vzip_u8(a,a);
+  return vcombine_u8(b.val[0], b.val[1]);
+}
+template<> EIGEN_STRONG_INLINE Packet4s ploaddup<Packet4s>(const int16_t* from)
+{
+  return vreinterpret_s16_u32(vzip_u32(vreinterpret_u32_s16(vld1_dup_s16(from)),
+      vreinterpret_u32_s16(vld1_dup_s16(from+1))).val[0]);
+}
+template<> EIGEN_STRONG_INLINE Packet8s ploaddup<Packet8s>(const int16_t* from)
+{
+  const int16x4_t a = vld1_s16(from);
+  const int16x4x2_t b = vzip_s16(a,a);
+  return vcombine_s16(b.val[0], b.val[1]);
+}
+template<> EIGEN_STRONG_INLINE Packet4us ploaddup<Packet4us>(const uint16_t* from)
+{
+  return vreinterpret_u16_u32(vzip_u32(vreinterpret_u32_u16(vld1_dup_u16(from)),
+      vreinterpret_u32_u16(vld1_dup_u16(from+1))).val[0]);
+}
+template<> EIGEN_STRONG_INLINE Packet8us ploaddup<Packet8us>(const uint16_t* from)
+{
+  const uint16x4_t a = vld1_u16(from);
+  const uint16x4x2_t b = vzip_u16(a,a);
+  return vcombine_u16(b.val[0], b.val[1]);
+}
+template<> EIGEN_STRONG_INLINE Packet2i ploaddup<Packet2i>(const int32_t* from)
+{ return vld1_dup_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int32_t* from)
+{ return vcombine_s32(vld1_dup_s32(from), vld1_dup_s32(from+1)); }
+template<> EIGEN_STRONG_INLINE Packet2ui ploaddup<Packet2ui>(const uint32_t* from)
+{ return vld1_dup_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet4ui ploaddup<Packet4ui>(const uint32_t* from)
+{ return vcombine_u32(vld1_dup_u32(from), vld1_dup_u32(from+1)); }
+template<> EIGEN_STRONG_INLINE Packet2l ploaddup<Packet2l>(const int64_t* from)
+{ return vld1q_dup_s64(from); }
+template<> EIGEN_STRONG_INLINE Packet2ul ploaddup<Packet2ul>(const uint64_t* from)
+{ return vld1q_dup_u64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet4f ploadquad<Packet4f>(const float* from) { return vld1q_dup_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4c ploadquad<Packet4c>(const int8_t* from)
+{ return vget_lane_s32(vreinterpret_s32_s8(vld1_dup_s8(from)), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c ploadquad<Packet8c>(const int8_t* from)
+{
+  return vreinterpret_s8_u32(vzip_u32(
+      vreinterpret_u32_s8(vld1_dup_s8(from)),
+      vreinterpret_u32_s8(vld1_dup_s8(from+1))).val[0]);
+}
+template<> EIGEN_STRONG_INLINE Packet16c ploadquad<Packet16c>(const int8_t* from)
+{
+  const int8x8_t a = vreinterpret_s8_u32(vzip_u32(
+      vreinterpret_u32_s8(vld1_dup_s8(from)),
+      vreinterpret_u32_s8(vld1_dup_s8(from+1))).val[0]);
+  const int8x8_t b = vreinterpret_s8_u32(vzip_u32(
+      vreinterpret_u32_s8(vld1_dup_s8(from+2)),
+      vreinterpret_u32_s8(vld1_dup_s8(from+3))).val[0]);
+  return vcombine_s8(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet4uc ploadquad<Packet4uc>(const uint8_t* from)
+{ return vget_lane_u32(vreinterpret_u32_u8(vld1_dup_u8(from)), 0); }
+template<> EIGEN_STRONG_INLINE Packet8uc ploadquad<Packet8uc>(const uint8_t* from)
+{
+  return vreinterpret_u8_u32(vzip_u32(
+      vreinterpret_u32_u8(vld1_dup_u8(from)),
+      vreinterpret_u32_u8(vld1_dup_u8(from+1))).val[0]);
+}
+template<> EIGEN_STRONG_INLINE Packet16uc ploadquad<Packet16uc>(const uint8_t* from)
+{
+  const uint8x8_t a = vreinterpret_u8_u32(vzip_u32(
+      vreinterpret_u32_u8(vld1_dup_u8(from)),
+      vreinterpret_u32_u8(vld1_dup_u8(from+1))).val[0]);
+  const uint8x8_t b = vreinterpret_u8_u32(vzip_u32(
+      vreinterpret_u32_u8(vld1_dup_u8(from+2)),
+      vreinterpret_u32_u8(vld1_dup_u8(from+3))).val[0]);
+  return vcombine_u8(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8s ploadquad<Packet8s>(const int16_t* from)
+{ return vcombine_s16(vld1_dup_s16(from), vld1_dup_s16(from+1)); }
+template<> EIGEN_STRONG_INLINE Packet8us ploadquad<Packet8us>(const uint16_t* from)
+{ return vcombine_u16(vld1_dup_u16(from), vld1_dup_u16(from+1)); }
+template<> EIGEN_STRONG_INLINE Packet4i ploadquad<Packet4i>(const int32_t* from) { return vld1q_dup_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet4ui ploadquad<Packet4ui>(const uint32_t* from) { return vld1q_dup_u32(from); }
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet2f& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_f32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_f32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int8_t>(int8_t* to, const Packet4c& from)
+{ memcpy(to, &from, sizeof(from)); }
+template<> EIGEN_STRONG_INLINE void pstore<int8_t>(int8_t* to, const Packet8c& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_s8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int8_t>(int8_t* to, const Packet16c& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_s8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint8_t>(uint8_t* to, const Packet4uc& from)
+{ memcpy(to, &from, sizeof(from)); }
+template<> EIGEN_STRONG_INLINE void pstore<uint8_t>(uint8_t* to, const Packet8uc& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_u8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint8_t>(uint8_t* to, const Packet16uc& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_u8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int16_t>(int16_t* to, const Packet4s& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_s16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int16_t>(int16_t* to, const Packet8s& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_s16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint16_t>(uint16_t* to, const Packet4us& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_u16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint16_t>(uint16_t* to, const Packet8us& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_u16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int32_t>(int32_t* to, const Packet2i& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_s32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int32_t>(int32_t* to, const Packet4i& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint32_t>(uint32_t* to, const Packet2ui& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_u32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint32_t>(uint32_t* to, const Packet4ui& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_u32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int64_t>(int64_t* to, const Packet2l& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_s64(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint64_t>(uint64_t* to, const Packet2ul& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_u64(to,from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet2f& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_f32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet4f& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_f32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int8_t>(int8_t* to, const Packet4c& from)
+{ memcpy(to, &from, sizeof(from)); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int8_t>(int8_t* to, const Packet8c& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_s8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int8_t>(int8_t* to, const Packet16c& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_s8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint8_t>(uint8_t* to, const Packet4uc& from)
+{ memcpy(to, &from, sizeof(from)); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint8_t>(uint8_t* to, const Packet8uc& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_u8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint8_t>(uint8_t* to, const Packet16uc& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_u8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int16_t>(int16_t* to, const Packet4s& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_s16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int16_t>(int16_t* to, const Packet8s& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_s16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint16_t>(uint16_t* to, const Packet4us& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_u16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint16_t>(uint16_t* to, const Packet8us& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_u16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int32_t>(int32_t* to, const Packet2i& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_s32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int32_t>(int32_t* to, const Packet4i& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint32_t>(uint32_t* to, const Packet2ui& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_u32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint32_t>(uint32_t* to, const Packet4ui& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_u32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int64_t>(int64_t* to, const Packet2l& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_s64(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint64_t>(uint64_t* to, const Packet2ul& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_u64(to,from); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f pgather<float, Packet2f>(const float* from, Index stride)
+{
+  Packet2f res = vld1_dup_f32(from);
+  res = vld1_lane_f32(from + 1*stride, res, 1);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  Packet4f res = vld1q_dup_f32(from);
+  res = vld1q_lane_f32(from + 1*stride, res, 1);
+  res = vld1q_lane_f32(from + 2*stride, res, 2);
+  res = vld1q_lane_f32(from + 3*stride, res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c pgather<int8_t, Packet4c>(const int8_t* from, Index stride)
+{
+  Packet4c res;
+  for (int i = 0; i != 4; i++)
+    reinterpret_cast<int8_t*>(&res)[i] = *(from + i * stride);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c pgather<int8_t, Packet8c>(const int8_t* from, Index stride)
+{
+  Packet8c res = vld1_dup_s8(from);
+  res = vld1_lane_s8(from + 1*stride, res, 1);
+  res = vld1_lane_s8(from + 2*stride, res, 2);
+  res = vld1_lane_s8(from + 3*stride, res, 3);
+  res = vld1_lane_s8(from + 4*stride, res, 4);
+  res = vld1_lane_s8(from + 5*stride, res, 5);
+  res = vld1_lane_s8(from + 6*stride, res, 6);
+  res = vld1_lane_s8(from + 7*stride, res, 7);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c pgather<int8_t, Packet16c>(const int8_t* from, Index stride)
+{
+  Packet16c res = vld1q_dup_s8(from);
+  res = vld1q_lane_s8(from + 1*stride, res, 1);
+  res = vld1q_lane_s8(from + 2*stride, res, 2);
+  res = vld1q_lane_s8(from + 3*stride, res, 3);
+  res = vld1q_lane_s8(from + 4*stride, res, 4);
+  res = vld1q_lane_s8(from + 5*stride, res, 5);
+  res = vld1q_lane_s8(from + 6*stride, res, 6);
+  res = vld1q_lane_s8(from + 7*stride, res, 7);
+  res = vld1q_lane_s8(from + 8*stride, res, 8);
+  res = vld1q_lane_s8(from + 9*stride, res, 9);
+  res = vld1q_lane_s8(from + 10*stride, res, 10);
+  res = vld1q_lane_s8(from + 11*stride, res, 11);
+  res = vld1q_lane_s8(from + 12*stride, res, 12);
+  res = vld1q_lane_s8(from + 13*stride, res, 13);
+  res = vld1q_lane_s8(from + 14*stride, res, 14);
+  res = vld1q_lane_s8(from + 15*stride, res, 15);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc pgather<uint8_t, Packet4uc>(const uint8_t* from, Index stride)
+{
+  Packet4uc res;
+  for (int i = 0; i != 4; i++)
+    reinterpret_cast<uint8_t*>(&res)[i] = *(from + i * stride);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc pgather<uint8_t, Packet8uc>(const uint8_t* from, Index stride)
+{
+  Packet8uc res = vld1_dup_u8(from);
+  res = vld1_lane_u8(from + 1*stride, res, 1);
+  res = vld1_lane_u8(from + 2*stride, res, 2);
+  res = vld1_lane_u8(from + 3*stride, res, 3);
+  res = vld1_lane_u8(from + 4*stride, res, 4);
+  res = vld1_lane_u8(from + 5*stride, res, 5);
+  res = vld1_lane_u8(from + 6*stride, res, 6);
+  res = vld1_lane_u8(from + 7*stride, res, 7);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc pgather<uint8_t, Packet16uc>(const uint8_t* from, Index stride)
+{
+  Packet16uc res = vld1q_dup_u8(from);
+  res = vld1q_lane_u8(from + 1*stride, res, 1);
+  res = vld1q_lane_u8(from + 2*stride, res, 2);
+  res = vld1q_lane_u8(from + 3*stride, res, 3);
+  res = vld1q_lane_u8(from + 4*stride, res, 4);
+  res = vld1q_lane_u8(from + 5*stride, res, 5);
+  res = vld1q_lane_u8(from + 6*stride, res, 6);
+  res = vld1q_lane_u8(from + 7*stride, res, 7);
+  res = vld1q_lane_u8(from + 8*stride, res, 8);
+  res = vld1q_lane_u8(from + 9*stride, res, 9);
+  res = vld1q_lane_u8(from + 10*stride, res, 10);
+  res = vld1q_lane_u8(from + 11*stride, res, 11);
+  res = vld1q_lane_u8(from + 12*stride, res, 12);
+  res = vld1q_lane_u8(from + 13*stride, res, 13);
+  res = vld1q_lane_u8(from + 14*stride, res, 14);
+  res = vld1q_lane_u8(from + 15*stride, res, 15);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s pgather<int16_t, Packet4s>(const int16_t* from, Index stride)
+{
+  Packet4s res = vld1_dup_s16(from);
+  res = vld1_lane_s16(from + 1*stride, res, 1);
+  res = vld1_lane_s16(from + 2*stride, res, 2);
+  res = vld1_lane_s16(from + 3*stride, res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s pgather<int16_t, Packet8s>(const int16_t* from, Index stride)
+{
+  Packet8s res = vld1q_dup_s16(from);
+  res = vld1q_lane_s16(from + 1*stride, res, 1);
+  res = vld1q_lane_s16(from + 2*stride, res, 2);
+  res = vld1q_lane_s16(from + 3*stride, res, 3);
+  res = vld1q_lane_s16(from + 4*stride, res, 4);
+  res = vld1q_lane_s16(from + 5*stride, res, 5);
+  res = vld1q_lane_s16(from + 6*stride, res, 6);
+  res = vld1q_lane_s16(from + 7*stride, res, 7);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us pgather<uint16_t, Packet4us>(const uint16_t* from, Index stride)
+{
+  Packet4us res = vld1_dup_u16(from);
+  res = vld1_lane_u16(from + 1*stride, res, 1);
+  res = vld1_lane_u16(from + 2*stride, res, 2);
+  res = vld1_lane_u16(from + 3*stride, res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us pgather<uint16_t, Packet8us>(const uint16_t* from, Index stride)
+{
+  Packet8us res = vld1q_dup_u16(from);
+  res = vld1q_lane_u16(from + 1*stride, res, 1);
+  res = vld1q_lane_u16(from + 2*stride, res, 2);
+  res = vld1q_lane_u16(from + 3*stride, res, 3);
+  res = vld1q_lane_u16(from + 4*stride, res, 4);
+  res = vld1q_lane_u16(from + 5*stride, res, 5);
+  res = vld1q_lane_u16(from + 6*stride, res, 6);
+  res = vld1q_lane_u16(from + 7*stride, res, 7);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i pgather<int32_t, Packet2i>(const int32_t* from, Index stride)
+{
+  Packet2i res = vld1_dup_s32(from);
+  res = vld1_lane_s32(from + 1*stride, res, 1);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i pgather<int32_t, Packet4i>(const int32_t* from, Index stride)
+{
+  Packet4i res = vld1q_dup_s32(from);
+  res = vld1q_lane_s32(from + 1*stride, res, 1);
+  res = vld1q_lane_s32(from + 2*stride, res, 2);
+  res = vld1q_lane_s32(from + 3*stride, res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui pgather<uint32_t, Packet2ui>(const uint32_t* from, Index stride)
+{
+  Packet2ui res = vld1_dup_u32(from);
+  res = vld1_lane_u32(from + 1*stride, res, 1);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui pgather<uint32_t, Packet4ui>(const uint32_t* from, Index stride)
+{
+  Packet4ui res = vld1q_dup_u32(from);
+  res = vld1q_lane_u32(from + 1*stride, res, 1);
+  res = vld1q_lane_u32(from + 2*stride, res, 2);
+  res = vld1q_lane_u32(from + 3*stride, res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l pgather<int64_t, Packet2l>(const int64_t* from, Index stride)
+{
+  Packet2l res = vld1q_dup_s64(from);
+  res = vld1q_lane_s64(from + 1*stride, res, 1);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul pgather<uint64_t, Packet2ul>(const uint64_t* from, Index stride)
+{
+  Packet2ul res = vld1q_dup_u64(from);
+  res = vld1q_lane_u64(from + 1*stride, res, 1);
+  return res;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<float, Packet2f>(float* to, const Packet2f& from, Index stride)
+{
+  vst1_lane_f32(to + stride*0, from, 0);
+  vst1_lane_f32(to + stride*1, from, 1);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  vst1q_lane_f32(to + stride*0, from, 0);
+  vst1q_lane_f32(to + stride*1, from, 1);
+  vst1q_lane_f32(to + stride*2, from, 2);
+  vst1q_lane_f32(to + stride*3, from, 3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int8_t, Packet4c>(int8_t* to, const Packet4c& from, Index stride)
+{
+  for (int i = 0; i != 4; i++)
+    *(to + i * stride) = reinterpret_cast<const int8_t*>(&from)[i];
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int8_t, Packet8c>(int8_t* to, const Packet8c& from, Index stride)
+{
+  vst1_lane_s8(to + stride*0, from, 0);
+  vst1_lane_s8(to + stride*1, from, 1);
+  vst1_lane_s8(to + stride*2, from, 2);
+  vst1_lane_s8(to + stride*3, from, 3);
+  vst1_lane_s8(to + stride*4, from, 4);
+  vst1_lane_s8(to + stride*5, from, 5);
+  vst1_lane_s8(to + stride*6, from, 6);
+  vst1_lane_s8(to + stride*7, from, 7);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int8_t, Packet16c>(int8_t* to, const Packet16c& from, Index stride)
+{
+  vst1q_lane_s8(to + stride*0, from, 0);
+  vst1q_lane_s8(to + stride*1, from, 1);
+  vst1q_lane_s8(to + stride*2, from, 2);
+  vst1q_lane_s8(to + stride*3, from, 3);
+  vst1q_lane_s8(to + stride*4, from, 4);
+  vst1q_lane_s8(to + stride*5, from, 5);
+  vst1q_lane_s8(to + stride*6, from, 6);
+  vst1q_lane_s8(to + stride*7, from, 7);
+  vst1q_lane_s8(to + stride*8, from, 8);
+  vst1q_lane_s8(to + stride*9, from, 9);
+  vst1q_lane_s8(to + stride*10, from, 10);
+  vst1q_lane_s8(to + stride*11, from, 11);
+  vst1q_lane_s8(to + stride*12, from, 12);
+  vst1q_lane_s8(to + stride*13, from, 13);
+  vst1q_lane_s8(to + stride*14, from, 14);
+  vst1q_lane_s8(to + stride*15, from, 15);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint8_t, Packet4uc>(uint8_t* to, const Packet4uc& from, Index stride)
+{
+  for (int i = 0; i != 4; i++)
+    *(to + i * stride) = reinterpret_cast<const uint8_t*>(&from)[i];
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint8_t, Packet8uc>(uint8_t* to, const Packet8uc& from, Index stride)
+{
+  vst1_lane_u8(to + stride*0, from, 0);
+  vst1_lane_u8(to + stride*1, from, 1);
+  vst1_lane_u8(to + stride*2, from, 2);
+  vst1_lane_u8(to + stride*3, from, 3);
+  vst1_lane_u8(to + stride*4, from, 4);
+  vst1_lane_u8(to + stride*5, from, 5);
+  vst1_lane_u8(to + stride*6, from, 6);
+  vst1_lane_u8(to + stride*7, from, 7);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint8_t, Packet16uc>(uint8_t* to, const Packet16uc& from, Index stride)
+{
+  vst1q_lane_u8(to + stride*0, from, 0);
+  vst1q_lane_u8(to + stride*1, from, 1);
+  vst1q_lane_u8(to + stride*2, from, 2);
+  vst1q_lane_u8(to + stride*3, from, 3);
+  vst1q_lane_u8(to + stride*4, from, 4);
+  vst1q_lane_u8(to + stride*5, from, 5);
+  vst1q_lane_u8(to + stride*6, from, 6);
+  vst1q_lane_u8(to + stride*7, from, 7);
+  vst1q_lane_u8(to + stride*8, from, 8);
+  vst1q_lane_u8(to + stride*9, from, 9);
+  vst1q_lane_u8(to + stride*10, from, 10);
+  vst1q_lane_u8(to + stride*11, from, 11);
+  vst1q_lane_u8(to + stride*12, from, 12);
+  vst1q_lane_u8(to + stride*13, from, 13);
+  vst1q_lane_u8(to + stride*14, from, 14);
+  vst1q_lane_u8(to + stride*15, from, 15);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int16_t, Packet4s>(int16_t* to, const Packet4s& from, Index stride)
+{
+  vst1_lane_s16(to + stride*0, from, 0);
+  vst1_lane_s16(to + stride*1, from, 1);
+  vst1_lane_s16(to + stride*2, from, 2);
+  vst1_lane_s16(to + stride*3, from, 3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int16_t, Packet8s>(int16_t* to, const Packet8s& from, Index stride)
+{
+  vst1q_lane_s16(to + stride*0, from, 0);
+  vst1q_lane_s16(to + stride*1, from, 1);
+  vst1q_lane_s16(to + stride*2, from, 2);
+  vst1q_lane_s16(to + stride*3, from, 3);
+  vst1q_lane_s16(to + stride*4, from, 4);
+  vst1q_lane_s16(to + stride*5, from, 5);
+  vst1q_lane_s16(to + stride*6, from, 6);
+  vst1q_lane_s16(to + stride*7, from, 7);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint16_t, Packet4us>(uint16_t* to, const Packet4us& from, Index stride)
+{
+  vst1_lane_u16(to + stride*0, from, 0);
+  vst1_lane_u16(to + stride*1, from, 1);
+  vst1_lane_u16(to + stride*2, from, 2);
+  vst1_lane_u16(to + stride*3, from, 3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint16_t, Packet8us>(uint16_t* to, const Packet8us& from, Index stride)
+{
+  vst1q_lane_u16(to + stride*0, from, 0);
+  vst1q_lane_u16(to + stride*1, from, 1);
+  vst1q_lane_u16(to + stride*2, from, 2);
+  vst1q_lane_u16(to + stride*3, from, 3);
+  vst1q_lane_u16(to + stride*4, from, 4);
+  vst1q_lane_u16(to + stride*5, from, 5);
+  vst1q_lane_u16(to + stride*6, from, 6);
+  vst1q_lane_u16(to + stride*7, from, 7);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int32_t, Packet2i>(int32_t* to, const Packet2i& from, Index stride)
+{
+  vst1_lane_s32(to + stride*0, from, 0);
+  vst1_lane_s32(to + stride*1, from, 1);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int32_t, Packet4i>(int32_t* to, const Packet4i& from, Index stride)
+{
+  vst1q_lane_s32(to + stride*0, from, 0);
+  vst1q_lane_s32(to + stride*1, from, 1);
+  vst1q_lane_s32(to + stride*2, from, 2);
+  vst1q_lane_s32(to + stride*3, from, 3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint32_t, Packet2ui>(uint32_t* to, const Packet2ui& from, Index stride)
+{
+  vst1_lane_u32(to + stride*0, from, 0);
+  vst1_lane_u32(to + stride*1, from, 1);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint32_t, Packet4ui>(uint32_t* to, const Packet4ui& from, Index stride)
+{
+  vst1q_lane_u32(to + stride*0, from, 0);
+  vst1q_lane_u32(to + stride*1, from, 1);
+  vst1q_lane_u32(to + stride*2, from, 2);
+  vst1q_lane_u32(to + stride*3, from, 3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int64_t, Packet2l>(int64_t* to, const Packet2l& from, Index stride)
+{
+  vst1q_lane_s64(to + stride*0, from, 0);
+  vst1q_lane_s64(to + stride*1, from, 1);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint64_t, Packet2ul>(uint64_t* to, const Packet2ul& from, Index stride)
+{
+  vst1q_lane_u64(to + stride*0, from, 0);
+  vst1q_lane_u64(to + stride*1, from, 1);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int8_t>(const int8_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<uint8_t>(const uint8_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int16_t>(const int16_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<uint16_t>(const uint16_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int32_t>(const int32_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<uint32_t>(const uint32_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int64_t>(const int64_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<uint64_t>(const uint64_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE float pfirst<Packet2f>(const Packet2f& a) { return vget_lane_f32(a,0); }
+template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { return vgetq_lane_f32(a,0); }
+template<> EIGEN_STRONG_INLINE int8_t pfirst<Packet4c>(const Packet4c& a) { return static_cast<int8_t>(a & 0xff); }
+template<> EIGEN_STRONG_INLINE int8_t pfirst<Packet8c>(const Packet8c& a) { return vget_lane_s8(a,0); }
+template<> EIGEN_STRONG_INLINE int8_t pfirst<Packet16c>(const Packet16c& a) { return vgetq_lane_s8(a,0); }
+template<> EIGEN_STRONG_INLINE uint8_t pfirst<Packet4uc>(const Packet4uc& a) { return static_cast<uint8_t>(a & 0xff); }
+template<> EIGEN_STRONG_INLINE uint8_t pfirst<Packet8uc>(const Packet8uc& a) { return vget_lane_u8(a,0); }
+template<> EIGEN_STRONG_INLINE uint8_t pfirst<Packet16uc>(const Packet16uc& a) { return vgetq_lane_u8(a,0); }
+template<> EIGEN_STRONG_INLINE int16_t pfirst<Packet4s>(const Packet4s& a) { return vget_lane_s16(a,0); }
+template<> EIGEN_STRONG_INLINE int16_t pfirst<Packet8s>(const Packet8s& a) { return vgetq_lane_s16(a,0); }
+template<> EIGEN_STRONG_INLINE uint16_t pfirst<Packet4us>(const Packet4us& a) { return vget_lane_u16(a,0); }
+template<> EIGEN_STRONG_INLINE uint16_t pfirst<Packet8us>(const Packet8us& a) { return vgetq_lane_u16(a,0); }
+template<> EIGEN_STRONG_INLINE int32_t pfirst<Packet2i>(const Packet2i& a) { return vget_lane_s32(a,0); }
+template<> EIGEN_STRONG_INLINE int32_t pfirst<Packet4i>(const Packet4i& a) { return vgetq_lane_s32(a,0); }
+template<> EIGEN_STRONG_INLINE uint32_t pfirst<Packet2ui>(const Packet2ui& a) { return vget_lane_u32(a,0); }
+template<> EIGEN_STRONG_INLINE uint32_t pfirst<Packet4ui>(const Packet4ui& a) { return vgetq_lane_u32(a,0); }
+template<> EIGEN_STRONG_INLINE int64_t pfirst<Packet2l>(const Packet2l& a) { return vgetq_lane_s64(a,0); }
+template<> EIGEN_STRONG_INLINE uint64_t pfirst<Packet2ul>(const Packet2ul& a) { return vgetq_lane_u64(a,0); }
+
+template<> EIGEN_STRONG_INLINE Packet2f preverse(const Packet2f& a) { return vrev64_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{
+  const float32x4_t a_r64 = vrev64q_f32(a);
+  return vcombine_f32(vget_high_f32(a_r64), vget_low_f32(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet4c preverse(const Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vrev64_s8(vreinterpret_s8_s32(vdup_n_s32(a)))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c preverse(const Packet8c& a) { return vrev64_s8(a); }
+template<> EIGEN_STRONG_INLINE Packet16c preverse(const Packet16c& a)
+{
+  const int8x16_t a_r64 = vrev64q_s8(a);
+  return vcombine_s8(vget_high_s8(a_r64), vget_low_s8(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet4uc preverse(const Packet4uc& a)
+{ return vget_lane_u32(vreinterpret_u32_u8(vrev64_u8(vreinterpret_u8_u32(vdup_n_u32(a)))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8uc preverse(const Packet8uc& a) { return vrev64_u8(a); }
+template<> EIGEN_STRONG_INLINE Packet16uc preverse(const Packet16uc& a)
+{
+  const uint8x16_t a_r64 = vrev64q_u8(a);
+  return vcombine_u8(vget_high_u8(a_r64), vget_low_u8(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet4s preverse(const Packet4s& a) { return vrev64_s16(a); }
+template<> EIGEN_STRONG_INLINE Packet8s preverse(const Packet8s& a)
+{
+  const int16x8_t a_r64 = vrev64q_s16(a);
+  return vcombine_s16(vget_high_s16(a_r64), vget_low_s16(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet4us preverse(const Packet4us& a) { return vrev64_u16(a); }
+template<> EIGEN_STRONG_INLINE Packet8us preverse(const Packet8us& a)
+{
+  const uint16x8_t a_r64 = vrev64q_u16(a);
+  return vcombine_u16(vget_high_u16(a_r64), vget_low_u16(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet2i preverse(const Packet2i& a) { return vrev64_s32(a); }
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a)
+{
+  const int32x4_t a_r64 = vrev64q_s32(a);
+  return vcombine_s32(vget_high_s32(a_r64), vget_low_s32(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet2ui preverse(const Packet2ui& a) { return vrev64_u32(a); }
+template<> EIGEN_STRONG_INLINE Packet4ui preverse(const Packet4ui& a)
+{
+  const uint32x4_t a_r64 = vrev64q_u32(a);
+  return vcombine_u32(vget_high_u32(a_r64), vget_low_u32(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet2l preverse(const Packet2l& a)
+{ return vcombine_s64(vget_high_s64(a), vget_low_s64(a)); }
+template<> EIGEN_STRONG_INLINE Packet2ul preverse(const Packet2ul& a)
+{ return vcombine_u64(vget_high_u64(a), vget_low_u64(a)); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pabs(const Packet2f& a) { return vabs_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { return vabsq_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4c pabs<Packet4c>(const Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vabs_s8(vreinterpret_s8_s32(vdup_n_s32(a)))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c pabs(const Packet8c& a) { return vabs_s8(a); }
+template<> EIGEN_STRONG_INLINE Packet16c pabs(const Packet16c& a) { return vabsq_s8(a); }
+template<> EIGEN_STRONG_INLINE Packet4uc pabs(const Packet4uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8uc pabs(const Packet8uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet16uc pabs(const Packet16uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4s pabs(const Packet4s& a) { return vabs_s16(a); }
+template<> EIGEN_STRONG_INLINE Packet8s pabs(const Packet8s& a) { return vabsq_s16(a); }
+template<> EIGEN_STRONG_INLINE Packet4us pabs(const Packet4us& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8us pabs(const Packet8us& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2i pabs(const Packet2i& a) { return vabs_s32(a); }
+template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { return vabsq_s32(a); }
+template<> EIGEN_STRONG_INLINE Packet2ui pabs(const Packet2ui& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4ui pabs(const Packet4ui& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2l pabs(const Packet2l& a) {
+#if EIGEN_ARCH_ARM64
+  return vabsq_s64(a);
+#else
+  return vcombine_s64(
+      vdup_n_s64((std::abs)(vgetq_lane_s64(a, 0))),
+      vdup_n_s64((std::abs)(vgetq_lane_s64(a, 1))));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pabs(const Packet2ul& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet2f pfrexp<Packet2f>(const Packet2f& a, Packet2f& exponent)
+{ return pfrexp_generic(a,exponent); }
+template<> EIGEN_STRONG_INLINE Packet4f pfrexp<Packet4f>(const Packet4f& a, Packet4f& exponent)
+{ return pfrexp_generic(a,exponent); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pldexp<Packet2f>(const Packet2f& a, const Packet2f& exponent)
+{ return pldexp_generic(a,exponent); }
+template<> EIGEN_STRONG_INLINE Packet4f pldexp<Packet4f>(const Packet4f& a, const Packet4f& exponent)
+{ return pldexp_generic(a,exponent); }
+
+template<> EIGEN_STRONG_INLINE float predux<Packet2f>(const Packet2f& a) { return vget_lane_f32(vpadd_f32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  const float32x2_t sum = vadd_f32(vget_low_f32(a), vget_high_f32(a));
+  return vget_lane_f32(vpadd_f32(sum, sum), 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux<Packet4c>(const Packet4c& a)
+{
+  const int8x8_t a_dup = vreinterpret_s8_s32(vdup_n_s32(a));
+  int8x8_t sum = vpadd_s8(a_dup, a_dup);
+  sum = vpadd_s8(sum, sum);
+  return vget_lane_s8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux<Packet8c>(const Packet8c& a)
+{
+  int8x8_t sum = vpadd_s8(a,a);
+  sum = vpadd_s8(sum, sum);
+  sum = vpadd_s8(sum, sum);
+  return vget_lane_s8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux<Packet16c>(const Packet16c& a)
+{
+  int8x8_t sum = vadd_s8(vget_low_s8(a), vget_high_s8(a));
+  sum = vpadd_s8(sum, sum);
+  sum = vpadd_s8(sum, sum);
+  sum = vpadd_s8(sum, sum);
+  return vget_lane_s8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux<Packet4uc>(const Packet4uc& a)
+{
+  const uint8x8_t a_dup = vreinterpret_u8_u32(vdup_n_u32(a));
+  uint8x8_t sum = vpadd_u8(a_dup, a_dup);
+  sum = vpadd_u8(sum, sum);
+  return vget_lane_u8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux<Packet8uc>(const Packet8uc& a)
+{
+  uint8x8_t sum = vpadd_u8(a,a);
+  sum = vpadd_u8(sum, sum);
+  sum = vpadd_u8(sum, sum);
+  return vget_lane_u8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux<Packet16uc>(const Packet16uc& a)
+{
+  uint8x8_t sum = vadd_u8(vget_low_u8(a), vget_high_u8(a));
+  sum = vpadd_u8(sum, sum);
+  sum = vpadd_u8(sum, sum);
+  sum = vpadd_u8(sum, sum);
+  return vget_lane_u8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux<Packet4s>(const Packet4s& a)
+{
+  const int16x4_t sum = vpadd_s16(a,a);
+  return vget_lane_s16(vpadd_s16(sum, sum), 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux<Packet8s>(const Packet8s& a)
+{
+  int16x4_t sum = vadd_s16(vget_low_s16(a), vget_high_s16(a));
+  sum = vpadd_s16(sum, sum);
+  sum = vpadd_s16(sum, sum);
+  return vget_lane_s16(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux<Packet4us>(const Packet4us& a)
+{
+  const uint16x4_t sum = vpadd_u16(a,a);
+  return vget_lane_u16(vpadd_u16(sum, sum), 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux<Packet8us>(const Packet8us& a)
+{
+  uint16x4_t sum = vadd_u16(vget_low_u16(a), vget_high_u16(a));
+  sum = vpadd_u16(sum, sum);
+  sum = vpadd_u16(sum, sum);
+  return vget_lane_u16(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE int32_t predux<Packet2i>(const Packet2i& a) { return vget_lane_s32(vpadd_s32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE int32_t predux<Packet4i>(const Packet4i& a)
+{
+  const int32x2_t sum = vadd_s32(vget_low_s32(a), vget_high_s32(a));
+  return vget_lane_s32(vpadd_s32(sum, sum), 0);
+}
+template<> EIGEN_STRONG_INLINE uint32_t predux<Packet2ui>(const Packet2ui& a) { return vget_lane_u32(vpadd_u32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE uint32_t predux<Packet4ui>(const Packet4ui& a)
+{
+  const uint32x2_t sum = vadd_u32(vget_low_u32(a), vget_high_u32(a));
+  return vget_lane_u32(vpadd_u32(sum, sum), 0);
+}
+template<> EIGEN_STRONG_INLINE int64_t predux<Packet2l>(const Packet2l& a)
+{ return vgetq_lane_s64(a, 0) + vgetq_lane_s64(a, 1); }
+template<> EIGEN_STRONG_INLINE uint64_t predux<Packet2ul>(const Packet2ul& a)
+{ return vgetq_lane_u64(a, 0) + vgetq_lane_u64(a, 1); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c predux_half_dowto4(const Packet8c& a)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vadd_s8(a,
+      vreinterpret_s8_s32(vrev64_s32(vreinterpret_s32_s8(a))))), 0);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c predux_half_dowto4(const Packet16c& a)
+{ return vadd_s8(vget_high_s8(a), vget_low_s8(a)); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc predux_half_dowto4(const Packet8uc& a)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vadd_u8(a,
+      vreinterpret_u8_u32(vrev64_u32(vreinterpret_u32_u8(a))))), 0);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc predux_half_dowto4(const Packet16uc& a)
+{ return vadd_u8(vget_high_u8(a), vget_low_u8(a)); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s predux_half_dowto4(const Packet8s& a)
+{ return vadd_s16(vget_high_s16(a), vget_low_s16(a)); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us predux_half_dowto4(const Packet8us& a)
+{ return vadd_u16(vget_high_u16(a), vget_low_u16(a)); }
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet2f>(const Packet2f& a)
+{ return vget_lane_f32(a, 0) * vget_lane_f32(a, 1); }
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{ return predux_mul(vmul_f32(vget_low_f32(a), vget_high_f32(a))); }
+template<> EIGEN_STRONG_INLINE int8_t predux_mul<Packet4c>(const Packet4c& a)
+{
+  int8x8_t prod = vreinterpret_s8_s32(vdup_n_s32(a));
+  prod = vmul_s8(prod, vrev16_s8(prod));
+  return vget_lane_s8(prod, 0) * vget_lane_s8(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_mul<Packet8c>(const Packet8c& a)
+{
+  int8x8_t prod = vmul_s8(a, vrev16_s8(a));
+  prod = vmul_s8(prod, vrev32_s8(prod));
+  return vget_lane_s8(prod, 0) * vget_lane_s8(prod, 4);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_mul<Packet16c>(const Packet16c& a)
+{ return predux_mul(vmul_s8(vget_low_s8(a), vget_high_s8(a))); }
+template<> EIGEN_STRONG_INLINE uint8_t predux_mul<Packet4uc>(const Packet4uc& a)
+{
+  uint8x8_t prod = vreinterpret_u8_u32(vdup_n_u32(a));
+  prod = vmul_u8(prod, vrev16_u8(prod));
+  return vget_lane_u8(prod, 0) * vget_lane_u8(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_mul<Packet8uc>(const Packet8uc& a)
+{
+  uint8x8_t prod = vmul_u8(a, vrev16_u8(a));
+  prod = vmul_u8(prod, vrev32_u8(prod));
+  return vget_lane_u8(prod, 0) * vget_lane_u8(prod, 4);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_mul<Packet16uc>(const Packet16uc& a)
+{ return predux_mul(vmul_u8(vget_low_u8(a), vget_high_u8(a))); }
+template<> EIGEN_STRONG_INLINE int16_t predux_mul<Packet4s>(const Packet4s& a)
+{
+  const int16x4_t prod = vmul_s16(a, vrev32_s16(a));
+  return vget_lane_s16(prod, 0) * vget_lane_s16(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux_mul<Packet8s>(const Packet8s& a)
+{
+  int16x4_t prod;
+
+  // Get the product of a_lo * a_hi -> |a1*a5|a2*a6|a3*a7|a4*a8|
+  prod = vmul_s16(vget_low_s16(a), vget_high_s16(a));
+  // Swap and multiply |a1*a5*a2*a6|a3*a7*a4*a8|
+  prod = vmul_s16(prod, vrev32_s16(prod));
+  // Multiply |a1*a5*a2*a6*a3*a7*a4*a8|
+  return vget_lane_s16(prod, 0) * vget_lane_s16(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_mul<Packet4us>(const Packet4us& a)
+{
+  const uint16x4_t prod = vmul_u16(a, vrev32_u16(a));
+  return vget_lane_u16(prod, 0) * vget_lane_u16(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_mul<Packet8us>(const Packet8us& a)
+{
+  uint16x4_t prod;
+
+  // Get the product of a_lo * a_hi -> |a1*a5|a2*a6|a3*a7|a4*a8|
+  prod = vmul_u16(vget_low_u16(a), vget_high_u16(a));
+  // Swap and multiply |a1*a5*a2*a6|a3*a7*a4*a8|
+  prod = vmul_u16(prod, vrev32_u16(prod));
+  // Multiply |a1*a5*a2*a6*a3*a7*a4*a8|
+  return vget_lane_u16(prod, 0) * vget_lane_u16(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE int32_t predux_mul<Packet2i>(const Packet2i& a)
+{ return vget_lane_s32(a, 0) * vget_lane_s32(a, 1); }
+template<> EIGEN_STRONG_INLINE int32_t predux_mul<Packet4i>(const Packet4i& a)
+{ return predux_mul(vmul_s32(vget_low_s32(a), vget_high_s32(a))); }
+template<> EIGEN_STRONG_INLINE uint32_t predux_mul<Packet2ui>(const Packet2ui& a)
+{ return vget_lane_u32(a, 0) * vget_lane_u32(a, 1); }
+template<> EIGEN_STRONG_INLINE uint32_t predux_mul<Packet4ui>(const Packet4ui& a)
+{ return predux_mul(vmul_u32(vget_low_u32(a), vget_high_u32(a))); }
+template<> EIGEN_STRONG_INLINE int64_t predux_mul<Packet2l>(const Packet2l& a)
+{ return vgetq_lane_s64(a, 0) * vgetq_lane_s64(a, 1); }
+template<> EIGEN_STRONG_INLINE uint64_t predux_mul<Packet2ul>(const Packet2ul& a)
+{ return vgetq_lane_u64(a, 0) * vgetq_lane_u64(a, 1); }
+
+// min
+template<> EIGEN_STRONG_INLINE float predux_min<Packet2f>(const Packet2f& a)
+{ return vget_lane_f32(vpmin_f32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  const float32x2_t min = vmin_f32(vget_low_f32(a), vget_high_f32(a));
+  return vget_lane_f32(vpmin_f32(min, min), 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_min<Packet4c>(const Packet4c& a)
+{
+  const int8x8_t a_dup = vreinterpret_s8_s32(vdup_n_s32(a));
+  int8x8_t min = vpmin_s8(a_dup, a_dup);
+  min = vpmin_s8(min, min);
+  return vget_lane_s8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_min<Packet8c>(const Packet8c& a)
+{
+  int8x8_t min = vpmin_s8(a,a);
+  min = vpmin_s8(min, min);
+  min = vpmin_s8(min, min);
+  return vget_lane_s8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_min<Packet16c>(const Packet16c& a)
+{
+  int8x8_t min = vmin_s8(vget_low_s8(a), vget_high_s8(a));
+  min = vpmin_s8(min, min);
+  min = vpmin_s8(min, min);
+  min = vpmin_s8(min, min);
+  return vget_lane_s8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_min<Packet4uc>(const Packet4uc& a)
+{
+  const uint8x8_t a_dup = vreinterpret_u8_u32(vdup_n_u32(a));
+  uint8x8_t min = vpmin_u8(a_dup, a_dup);
+  min = vpmin_u8(min, min);
+  return vget_lane_u8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_min<Packet8uc>(const Packet8uc& a)
+{
+  uint8x8_t min = vpmin_u8(a,a);
+  min = vpmin_u8(min, min);
+  min = vpmin_u8(min, min);
+  return vget_lane_u8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_min<Packet16uc>(const Packet16uc& a)
+{
+  uint8x8_t min = vmin_u8(vget_low_u8(a), vget_high_u8(a));
+  min = vpmin_u8(min, min);
+  min = vpmin_u8(min, min);
+  min = vpmin_u8(min, min);
+  return vget_lane_u8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux_min<Packet4s>(const Packet4s& a)
+{
+  const int16x4_t min = vpmin_s16(a,a);
+  return vget_lane_s16(vpmin_s16(min, min), 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux_min<Packet8s>(const Packet8s& a)
+{
+  int16x4_t min = vmin_s16(vget_low_s16(a), vget_high_s16(a));
+  min = vpmin_s16(min, min);
+  min = vpmin_s16(min, min);
+  return vget_lane_s16(min, 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_min<Packet4us>(const Packet4us& a)
+{
+  const uint16x4_t min = vpmin_u16(a,a);
+  return vget_lane_u16(vpmin_u16(min, min), 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_min<Packet8us>(const Packet8us& a)
+{
+  uint16x4_t min = vmin_u16(vget_low_u16(a), vget_high_u16(a));
+  min = vpmin_u16(min, min);
+  min = vpmin_u16(min, min);
+  return vget_lane_u16(min, 0);
+}
+template<> EIGEN_STRONG_INLINE int32_t predux_min<Packet2i>(const Packet2i& a)
+{ return vget_lane_s32(vpmin_s32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE int32_t predux_min<Packet4i>(const Packet4i& a)
+{
+  const int32x2_t min = vmin_s32(vget_low_s32(a), vget_high_s32(a));
+  return vget_lane_s32(vpmin_s32(min, min), 0);
+}
+template<> EIGEN_STRONG_INLINE uint32_t predux_min<Packet2ui>(const Packet2ui& a)
+{ return vget_lane_u32(vpmin_u32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE uint32_t predux_min<Packet4ui>(const Packet4ui& a)
+{
+  const uint32x2_t min = vmin_u32(vget_low_u32(a), vget_high_u32(a));
+  return vget_lane_u32(vpmin_u32(min, min), 0);
+}
+template<> EIGEN_STRONG_INLINE int64_t predux_min<Packet2l>(const Packet2l& a)
+{ return (std::min)(vgetq_lane_s64(a, 0), vgetq_lane_s64(a, 1)); }
+template<> EIGEN_STRONG_INLINE uint64_t predux_min<Packet2ul>(const Packet2ul& a)
+{ return (std::min)(vgetq_lane_u64(a, 0), vgetq_lane_u64(a, 1)); }
+
+// max
+template<> EIGEN_STRONG_INLINE float predux_max<Packet2f>(const Packet2f& a)
+{ return vget_lane_f32(vpmax_f32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  const float32x2_t max = vmax_f32(vget_low_f32(a), vget_high_f32(a));
+  return vget_lane_f32(vpmax_f32(max, max), 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_max<Packet4c>(const Packet4c& a)
+{
+  const int8x8_t a_dup = vreinterpret_s8_s32(vdup_n_s32(a));
+  int8x8_t max = vpmax_s8(a_dup, a_dup);
+  max = vpmax_s8(max, max);
+  return vget_lane_s8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_max<Packet8c>(const Packet8c& a)
+{
+  int8x8_t max = vpmax_s8(a,a);
+  max = vpmax_s8(max, max);
+  max = vpmax_s8(max, max);
+  return vget_lane_s8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_max<Packet16c>(const Packet16c& a)
+{
+  int8x8_t max = vmax_s8(vget_low_s8(a), vget_high_s8(a));
+  max = vpmax_s8(max, max);
+  max = vpmax_s8(max, max);
+  max = vpmax_s8(max, max);
+  return vget_lane_s8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_max<Packet4uc>(const Packet4uc& a)
+{
+  const uint8x8_t a_dup = vreinterpret_u8_u32(vdup_n_u32(a));
+  uint8x8_t max = vpmax_u8(a_dup, a_dup);
+  max = vpmax_u8(max, max);
+  return vget_lane_u8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_max<Packet8uc>(const Packet8uc& a)
+{
+  uint8x8_t max = vpmax_u8(a,a);
+  max = vpmax_u8(max, max);
+  max = vpmax_u8(max, max);
+  return vget_lane_u8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_max<Packet16uc>(const Packet16uc& a)
+{
+  uint8x8_t max = vmax_u8(vget_low_u8(a), vget_high_u8(a));
+  max = vpmax_u8(max, max);
+  max = vpmax_u8(max, max);
+  max = vpmax_u8(max, max);
+  return vget_lane_u8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux_max<Packet4s>(const Packet4s& a)
+{
+  const int16x4_t max = vpmax_s16(a,a);
+  return vget_lane_s16(vpmax_s16(max, max), 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux_max<Packet8s>(const Packet8s& a)
+{
+  int16x4_t max = vmax_s16(vget_low_s16(a), vget_high_s16(a));
+  max = vpmax_s16(max, max);
+  max = vpmax_s16(max, max);
+  return vget_lane_s16(max, 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_max<Packet4us>(const Packet4us& a)
+{
+  const uint16x4_t max = vpmax_u16(a,a);
+  return vget_lane_u16(vpmax_u16(max, max), 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_max<Packet8us>(const Packet8us& a)
+{
+  uint16x4_t max = vmax_u16(vget_low_u16(a), vget_high_u16(a));
+  max = vpmax_u16(max, max);
+  max = vpmax_u16(max, max);
+  return vget_lane_u16(max, 0);
+}
+template<> EIGEN_STRONG_INLINE int32_t predux_max<Packet2i>(const Packet2i& a)
+{ return vget_lane_s32(vpmax_s32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE int32_t predux_max<Packet4i>(const Packet4i& a)
+{
+  const int32x2_t max = vmax_s32(vget_low_s32(a), vget_high_s32(a));
+  return vget_lane_s32(vpmax_s32(max, max), 0);
+}
+template<> EIGEN_STRONG_INLINE uint32_t predux_max<Packet2ui>(const Packet2ui& a)
+{ return vget_lane_u32(vpmax_u32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE uint32_t predux_max<Packet4ui>(const Packet4ui& a)
+{
+  const uint32x2_t max = vmax_u32(vget_low_u32(a), vget_high_u32(a));
+  return vget_lane_u32(vpmax_u32(max, max), 0);
+}
+template<> EIGEN_STRONG_INLINE int64_t predux_max<Packet2l>(const Packet2l& a)
+{ return (std::max)(vgetq_lane_s64(a, 0), vgetq_lane_s64(a, 1)); }
+template<> EIGEN_STRONG_INLINE uint64_t predux_max<Packet2ul>(const Packet2ul& a)
+{ return (std::max)(vgetq_lane_u64(a, 0), vgetq_lane_u64(a, 1)); }
+
+template<> EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x)
+{
+  uint32x2_t tmp = vorr_u32(vget_low_u32( vreinterpretq_u32_f32(x)),
+                            vget_high_u32(vreinterpretq_u32_f32(x)));
+  return vget_lane_u32(vpmax_u32(tmp, tmp), 0);
+}
+
+// Helpers for ptranspose.
+namespace detail {
+  
+template<typename Packet>
+void zip_in_place(Packet& p1, Packet& p2);
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet2f>(Packet2f& p1, Packet2f& p2) {
+  const float32x2x2_t tmp = vzip_f32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4f>(Packet4f& p1, Packet4f& p2) {
+  const float32x4x2_t tmp = vzipq_f32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet8c>(Packet8c& p1, Packet8c& p2) {
+  const int8x8x2_t tmp = vzip_s8(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet16c>(Packet16c& p1, Packet16c& p2) {
+  const int8x16x2_t tmp = vzipq_s8(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet8uc>(Packet8uc& p1, Packet8uc& p2) {
+  const uint8x8x2_t tmp = vzip_u8(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet16uc>(Packet16uc& p1, Packet16uc& p2) {
+  const uint8x16x2_t tmp = vzipq_u8(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet2i>(Packet2i& p1, Packet2i& p2) {
+  const int32x2x2_t tmp = vzip_s32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4i>(Packet4i& p1, Packet4i& p2) {
+  const int32x4x2_t tmp = vzipq_s32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet2ui>(Packet2ui& p1, Packet2ui& p2) {
+  const uint32x2x2_t tmp = vzip_u32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4ui>(Packet4ui& p1, Packet4ui& p2) {
+  const uint32x4x2_t tmp = vzipq_u32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4s>(Packet4s& p1, Packet4s& p2) {
+  const int16x4x2_t tmp = vzip_s16(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet8s>(Packet8s& p1, Packet8s& p2) {
+  const int16x8x2_t tmp = vzipq_s16(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4us>(Packet4us& p1, Packet4us& p2) {
+  const uint16x4x2_t tmp = vzip_u16(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet8us>(Packet8us& p1, Packet8us& p2) {
+  const uint16x8x2_t tmp = vzipq_u16(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void ptranspose_impl(PacketBlock<Packet, 2>& kernel) {
+  zip_in_place(kernel.packet[0], kernel.packet[1]);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void ptranspose_impl(PacketBlock<Packet, 4>& kernel) {
+  zip_in_place(kernel.packet[0], kernel.packet[2]);
+  zip_in_place(kernel.packet[1], kernel.packet[3]);
+  zip_in_place(kernel.packet[0], kernel.packet[1]);
+  zip_in_place(kernel.packet[2], kernel.packet[3]);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void ptranspose_impl(PacketBlock<Packet, 8>& kernel) {
+  zip_in_place(kernel.packet[0], kernel.packet[4]);
+  zip_in_place(kernel.packet[1], kernel.packet[5]);
+  zip_in_place(kernel.packet[2], kernel.packet[6]);
+  zip_in_place(kernel.packet[3], kernel.packet[7]);
+
+  zip_in_place(kernel.packet[0], kernel.packet[2]);
+  zip_in_place(kernel.packet[1], kernel.packet[3]);
+  zip_in_place(kernel.packet[4], kernel.packet[6]);
+  zip_in_place(kernel.packet[5], kernel.packet[7]);
+  
+  zip_in_place(kernel.packet[0], kernel.packet[1]);
+  zip_in_place(kernel.packet[2], kernel.packet[3]);
+  zip_in_place(kernel.packet[4], kernel.packet[5]);
+  zip_in_place(kernel.packet[6], kernel.packet[7]);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void ptranspose_impl(PacketBlock<Packet, 16>& kernel) {
+  EIGEN_UNROLL_LOOP
+  for (int i=0; i<4; ++i) {
+    const int m = (1 << i);
+    EIGEN_UNROLL_LOOP
+    for (int j=0; j<m; ++j) {
+      const int n = (1 << (3-i));
+      EIGEN_UNROLL_LOOP
+      for (int k=0; k<n; ++k) {
+        const int idx = 2*j*n+k;
+        zip_in_place(kernel.packet[idx], kernel.packet[idx + n]);
+      }
+    }
+  }
+}
+
+} // namespace detail
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2f, 2>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4f, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4c, 4>& kernel)
+{
+  const int8x8_t a = vreinterpret_s8_s32(vset_lane_s32(kernel.packet[2], vdup_n_s32(kernel.packet[0]), 1));
+  const int8x8_t b = vreinterpret_s8_s32(vset_lane_s32(kernel.packet[3], vdup_n_s32(kernel.packet[1]), 1));
+
+  const int8x8x2_t zip8 = vzip_s8(a,b);
+  const int16x4x2_t zip16 = vzip_s16(vreinterpret_s16_s8(zip8.val[0]), vreinterpret_s16_s8(zip8.val[1]));
+
+  kernel.packet[0] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[0]), 0);
+  kernel.packet[1] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[0]), 1);
+  kernel.packet[2] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[1]), 0);
+  kernel.packet[3] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[1]), 1);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8c, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8c, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16c, 16>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16c, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16c, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4uc, 4>& kernel)
+{
+  const uint8x8_t a = vreinterpret_u8_u32(vset_lane_u32(kernel.packet[2], vdup_n_u32(kernel.packet[0]), 1));
+  const uint8x8_t b = vreinterpret_u8_u32(vset_lane_u32(kernel.packet[3], vdup_n_u32(kernel.packet[1]), 1));
+
+  const uint8x8x2_t zip8 = vzip_u8(a,b);
+  const uint16x4x2_t zip16 = vzip_u16(vreinterpret_u16_u8(zip8.val[0]), vreinterpret_u16_u8(zip8.val[1]));
+
+  kernel.packet[0] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[0]), 0);
+  kernel.packet[1] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[0]), 1);
+  kernel.packet[2] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[1]), 0);
+  kernel.packet[3] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[1]), 1);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8uc, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8uc, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16uc, 16>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16uc, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16uc, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4s, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8s, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8s, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4us, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8us, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8us, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2i, 2>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4i, 4>& kernel) {
+    detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2ui, 2>& kernel) {
+  detail::zip_in_place(kernel.packet[0], kernel.packet[1]);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4ui, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet2l, 2>& kernel)
+{
+#if EIGEN_ARCH_ARM64
+  const int64x2_t tmp1 = vzip1q_s64(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[1] = vzip2q_s64(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[0] = tmp1;
+#else
+  const int64x1_t tmp[2][2] = {
+    { vget_low_s64(kernel.packet[0]), vget_high_s64(kernel.packet[0]) },
+    { vget_low_s64(kernel.packet[1]), vget_high_s64(kernel.packet[1]) }
+  };
+
+  kernel.packet[0] = vcombine_s64(tmp[0][0], tmp[1][0]);
+  kernel.packet[1] = vcombine_s64(tmp[0][1], tmp[1][1]);
+#endif
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet2ul, 2>& kernel)
+{
+#if EIGEN_ARCH_ARM64
+  const uint64x2_t tmp1 = vzip1q_u64(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[1] = vzip2q_u64(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[0] = tmp1;
+#else
+  const uint64x1_t tmp[2][2] = {
+    { vget_low_u64(kernel.packet[0]), vget_high_u64(kernel.packet[0]) },
+    { vget_low_u64(kernel.packet[1]), vget_high_u64(kernel.packet[1]) }
+  };
+
+  kernel.packet[0] = vcombine_u64(tmp[0][0], tmp[1][0]);
+  kernel.packet[1] = vcombine_u64(tmp[0][1], tmp[1][1]);
+#endif
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f pselect( const Packet2f& mask, const Packet2f& a, const Packet2f& b)
+{ return vbsl_f32(vreinterpret_u32_f32(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f pselect(const Packet4f& mask, const Packet4f& a, const Packet4f& b)
+{ return vbslq_f32(vreinterpretq_u32_f32(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c pselect(const Packet8c& mask, const Packet8c& a, const Packet8c& b)
+{ return vbsl_s8(vreinterpret_u8_s8(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c pselect(const Packet16c& mask, const Packet16c& a, const Packet16c& b)
+{ return vbslq_s8(vreinterpretq_u8_s8(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc pselect(const Packet8uc& mask, const Packet8uc& a, const Packet8uc& b)
+{ return vbsl_u8(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc pselect(const Packet16uc& mask, const Packet16uc& a, const Packet16uc& b)
+{ return vbslq_u8(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s pselect(const Packet4s& mask, const Packet4s& a, const Packet4s& b)
+{ return vbsl_s16(vreinterpret_u16_s16(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s pselect(const Packet8s& mask, const Packet8s& a, const Packet8s& b)
+{ return vbslq_s16(vreinterpretq_u16_s16(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us pselect(const Packet4us& mask, const Packet4us& a, const Packet4us& b)
+{ return vbsl_u16(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us pselect(const Packet8us& mask, const Packet8us& a, const Packet8us& b)
+{ return vbslq_u16(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i pselect(const Packet2i& mask, const Packet2i& a, const Packet2i& b)
+{ return vbsl_s32(vreinterpret_u32_s32(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i pselect(const Packet4i& mask, const Packet4i& a, const Packet4i& b)
+{ return vbslq_s32(vreinterpretq_u32_s32(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui pselect(const Packet2ui& mask, const Packet2ui& a, const Packet2ui& b)
+{ return vbsl_u32(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui pselect(const Packet4ui& mask, const Packet4ui& a, const Packet4ui& b)
+{ return vbslq_u32(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l pselect(const Packet2l& mask, const Packet2l& a, const Packet2l& b)
+{ return vbslq_s64(vreinterpretq_u64_s64(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul pselect(const Packet2ul& mask, const Packet2ul& a, const Packet2ul& b)
+{ return vbslq_u64(mask, a, b); }
+
+// Use armv8 rounding intinsics if available.
+#if EIGEN_ARCH_ARMV8
+template<> EIGEN_STRONG_INLINE Packet2f print<Packet2f>(const Packet2f& a)
+{ return vrndn_f32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f print<Packet4f>(const Packet4f& a)
+{ return vrndnq_f32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pfloor<Packet2f>(const Packet2f& a)
+{ return vrndm_f32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a)
+{ return vrndmq_f32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pceil<Packet2f>(const Packet2f& a)
+{ return vrndp_f32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a)
+{ return vrndpq_f32(a); }
+
+#else
+
+template<> EIGEN_STRONG_INLINE Packet4f print(const Packet4f& a) {
+  // Adds and subtracts signum(a) * 2^23 to force rounding.
+  const Packet4f limit = pset1<Packet4f>(static_cast<float>(1<<23));
+  const Packet4f abs_a = pabs(a);
+  Packet4f r = padd(abs_a, limit);
+  // Don't compile-away addition and subtraction.
+  EIGEN_OPTIMIZATION_BARRIER(r);
+  r = psub(r, limit);
+  // If greater than limit, simply return a.  Otherwise, account for sign.
+  r = pselect(pcmp_lt(abs_a, limit),
+              pselect(pcmp_lt(a, pzero(a)), pnegate(r), r), a);
+  return r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f print(const Packet2f& a) {
+  // Adds and subtracts signum(a) * 2^23 to force rounding.
+  const Packet2f limit = pset1<Packet2f>(static_cast<float>(1<<23));
+  const Packet2f abs_a = pabs(a);
+  Packet2f r = padd(abs_a, limit);
+  // Don't compile-away addition and subtraction.
+  EIGEN_OPTIMIZATION_BARRIER(r);
+  r = psub(r, limit);
+  // If greater than limit, simply return a.  Otherwise, account for sign.
+  r = pselect(pcmp_lt(abs_a, limit),
+              pselect(pcmp_lt(a, pzero(a)), pnegate(r), r), a);
+  return r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a)
+{
+  const Packet4f cst_1 = pset1<Packet4f>(1.0f);
+  Packet4f tmp  = print<Packet4f>(a);
+  // If greater, subtract one.
+  Packet4f mask = pcmp_lt(a, tmp);
+  mask = pand(mask, cst_1);
+  return psub(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pfloor<Packet2f>(const Packet2f& a)
+{
+  const Packet2f cst_1 = pset1<Packet2f>(1.0f);
+  Packet2f tmp  = print<Packet2f>(a);
+  // If greater, subtract one.
+  Packet2f mask = pcmp_lt(a, tmp);
+  mask = pand(mask, cst_1);
+  return psub(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a)
+{
+  const Packet4f cst_1 = pset1<Packet4f>(1.0f);
+  Packet4f tmp  = print<Packet4f>(a);
+  // If smaller, add one.
+  Packet4f mask = pcmp_lt(tmp, a);
+  mask = pand(mask, cst_1);
+  return padd(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pceil<Packet2f>(const Packet2f& a)
+{
+  const Packet2f cst_1 = pset1<Packet2f>(1.0);
+  Packet2f tmp  = print<Packet2f>(a);
+  // If smaller, add one.
+  Packet2f mask = pcmp_lt(tmp, a);
+  mask = pand(mask, cst_1);
+  return padd(tmp, mask);
+}
+
+#endif
+
+/**
+ * Computes the integer square root
+ * @remarks The calculation is performed using an algorithm which iterates through each binary digit of the result
+ *   and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument
+ *   value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .
+ */
+template<> EIGEN_STRONG_INLINE Packet4uc psqrt(const Packet4uc& a) {
+  uint8x8_t x = vreinterpret_u8_u32(vdup_n_u32(a));
+  uint8x8_t res = vdup_n_u8(0);
+  uint8x8_t add = vdup_n_u8(0x8);
+  for (int i = 0; i < 4; i++)
+  {
+    const uint8x8_t temp = vorr_u8(res, add);
+    res = vbsl_u8(vcge_u8(x, vmul_u8(temp, temp)), temp, res);
+    add = vshr_n_u8(add, 1);
+  }
+  return vget_lane_u32(vreinterpret_u32_u8(res), 0);
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet8uc psqrt(const Packet8uc& a) {
+  uint8x8_t res = vdup_n_u8(0);
+  uint8x8_t add = vdup_n_u8(0x8);
+  for (int i = 0; i < 4; i++)
+  {
+    const uint8x8_t temp = vorr_u8(res, add);
+    res = vbsl_u8(vcge_u8(a, vmul_u8(temp, temp)), temp, res);
+    add = vshr_n_u8(add, 1);
+  }
+  return res;
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet16uc psqrt(const Packet16uc& a) {
+  uint8x16_t res = vdupq_n_u8(0);
+  uint8x16_t add = vdupq_n_u8(0x8);
+  for (int i = 0; i < 4; i++)
+  {
+    const uint8x16_t temp = vorrq_u8(res, add);
+    res = vbslq_u8(vcgeq_u8(a, vmulq_u8(temp, temp)), temp, res);
+    add = vshrq_n_u8(add, 1);
+  }
+  return res;
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet4us psqrt(const Packet4us& a) {
+  uint16x4_t res = vdup_n_u16(0);
+  uint16x4_t add = vdup_n_u16(0x80);
+  for (int i = 0; i < 8; i++)
+  {
+    const uint16x4_t temp = vorr_u16(res, add);
+    res = vbsl_u16(vcge_u16(a, vmul_u16(temp, temp)), temp, res);
+    add = vshr_n_u16(add, 1);
+  }
+  return res;
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet8us psqrt(const Packet8us& a) {
+  uint16x8_t res = vdupq_n_u16(0);
+  uint16x8_t add = vdupq_n_u16(0x80);
+  for (int i = 0; i < 8; i++)
+  {
+    const uint16x8_t temp = vorrq_u16(res, add);
+    res = vbslq_u16(vcgeq_u16(a, vmulq_u16(temp, temp)), temp, res);
+    add = vshrq_n_u16(add, 1);
+  }
+  return res;
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet2ui psqrt(const Packet2ui& a) {
+  uint32x2_t res = vdup_n_u32(0);
+  uint32x2_t add = vdup_n_u32(0x8000);
+  for (int i = 0; i < 16; i++)
+  {
+    const uint32x2_t temp = vorr_u32(res, add);
+    res = vbsl_u32(vcge_u32(a, vmul_u32(temp, temp)), temp, res);
+    add = vshr_n_u32(add, 1);
+  }
+  return res;
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet4ui psqrt(const Packet4ui& a) {
+  uint32x4_t res = vdupq_n_u32(0);
+  uint32x4_t add = vdupq_n_u32(0x8000);
+  for (int i = 0; i < 16; i++)
+  {
+    const uint32x4_t temp = vorrq_u32(res, add);
+    res = vbslq_u32(vcgeq_u32(a, vmulq_u32(temp, temp)), temp, res);
+    add = vshrq_n_u32(add, 1);
+  }
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f prsqrt(const Packet4f& a) {
+  // Compute approximate reciprocal sqrt.
+  Packet4f x = vrsqrteq_f32(a);
+  // Do Newton iterations for 1/sqrt(x).
+  x = vmulq_f32(vrsqrtsq_f32(vmulq_f32(a, x), x), x);
+  x = vmulq_f32(vrsqrtsq_f32(vmulq_f32(a, x), x), x);
+  const Packet4f infinity = pset1<Packet4f>(NumTraits<float>::infinity());
+  return pselect(pcmp_eq(a, pzero(a)), infinity, x);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f prsqrt(const Packet2f& a) {
+  // Compute approximate reciprocal sqrt.
+  Packet2f x = vrsqrte_f32(a);
+  // Do Newton iterations for 1/sqrt(x).
+  x = vmul_f32(vrsqrts_f32(vmul_f32(a, x), x), x);
+  x = vmul_f32(vrsqrts_f32(vmul_f32(a, x), x), x);
+  const Packet2f infinity = pset1<Packet2f>(NumTraits<float>::infinity());
+  return pselect(pcmp_eq(a, pzero(a)), infinity, x);
+}
+
+// Unfortunately vsqrt_f32 is only available for A64.
+#if EIGEN_ARCH_ARM64
+template<> EIGEN_STRONG_INLINE Packet4f psqrt(const Packet4f& _x){return vsqrtq_f32(_x);}
+template<> EIGEN_STRONG_INLINE Packet2f psqrt(const Packet2f& _x){return vsqrt_f32(_x); }
+#else
+template<> EIGEN_STRONG_INLINE Packet4f psqrt(const Packet4f& a) {
+  const Packet4f infinity = pset1<Packet4f>(NumTraits<float>::infinity());
+  const Packet4f is_zero_or_inf = por(pcmp_eq(a, pzero(a)), pcmp_eq(a, infinity));
+  return pselect(is_zero_or_inf, a, pmul(a, prsqrt(a)));
+}
+template<> EIGEN_STRONG_INLINE Packet2f psqrt(const Packet2f& a) {
+  const Packet2f infinity = pset1<Packet2f>(NumTraits<float>::infinity());
+  const Packet2f is_zero_or_inf = por(pcmp_eq(a, pzero(a)), pcmp_eq(a, infinity));
+  return pselect(is_zero_or_inf, a, pmul(a, prsqrt(a)));
+}
+#endif
+
+//---------- bfloat16 ----------
+// TODO: Add support for native armv8.6-a bfloat16_t
+
+// TODO: Guard if we have native bfloat16 support
+typedef eigen_packet_wrapper<uint16x4_t, 19> Packet4bf;
+
+template<> struct is_arithmetic<Packet4bf> { enum { value = true }; };
+
+template<> struct packet_traits<bfloat16> : default_packet_traits
+{
+  typedef Packet4bf type;
+  typedef Packet4bf half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasCmp       = 1,
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+    HasDiv       = 1,
+    HasFloor     = 1,
+    HasCeil      = 1,
+    HasRint      = 1,
+
+    HasSin  = EIGEN_FAST_MATH,
+    HasCos  = EIGEN_FAST_MATH,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 0,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf  = EIGEN_FAST_MATH,
+    HasBessel = 0,  // Issues with accuracy.
+    HasNdtri = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet4bf>
+{
+  typedef bfloat16 type;
+  typedef Packet4bf half;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+namespace detail {  
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4bf>(Packet4bf& p1, Packet4bf& p2) {
+  const uint16x4x2_t tmp = vzip_u16(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+} // namespace detail
+
+EIGEN_STRONG_INLINE Packet4bf F32ToBf16(const Packet4f& p)
+{
+  // See the scalar implemention in BFloat16.h for a comprehensible explanation
+  // of this fast rounding algorithm
+  Packet4ui input = reinterpret_cast<Packet4ui>(p);
+
+  // lsb = (input >> 16) & 1
+  Packet4ui lsb =  vandq_u32(vshrq_n_u32(input, 16), vdupq_n_u32(1));
+
+  // rounding_bias = 0x7fff + lsb
+  Packet4ui rounding_bias = vaddq_u32(lsb, vdupq_n_u32(0x7fff));
+
+  // input += rounding_bias
+  input = vaddq_u32(input, rounding_bias);
+
+  // input = input >> 16
+  input = vshrq_n_u32(input, 16);
+
+  // Replace float-nans by bfloat16-nans, that is 0x7fc0
+  const Packet4ui bf16_nan = vdupq_n_u32(0x7fc0);
+  const Packet4ui mask = vceqq_f32(p, p);
+  input = vbslq_u32(mask, input, bf16_nan);
+
+  // output = static_cast<uint16_t>(input)
+  return vmovn_u32(input);
+}
+
+EIGEN_STRONG_INLINE Packet4f Bf16ToF32(const Packet4bf& p)
+{
+  return reinterpret_cast<Packet4f>(vshlq_n_u32(vmovl_u16(p), 16));
+}
+
+EIGEN_STRONG_INLINE Packet4bf F32MaskToBf16Mask(const Packet4f& p) {
+  return vmovn_u32(vreinterpretq_u32_f32(p));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pset1<Packet4bf>(const bfloat16& from) {
+  return pset1<Packet4us>(from.value);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 pfirst<Packet4bf>(const Packet4bf& from) {
+  return bfloat16_impl::raw_uint16_to_bfloat16(static_cast<uint16_t>(pfirst<Packet4us>(from)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pload<Packet4bf>(const bfloat16* from)
+{
+  return pload<Packet4us>(reinterpret_cast<const uint16_t*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf ploadu<Packet4bf>(const bfloat16* from)
+{
+  return ploadu<Packet4us>(reinterpret_cast<const uint16_t*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<bfloat16>(bfloat16* to, const Packet4bf& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE vst1_u16(reinterpret_cast<uint16_t*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<bfloat16>(bfloat16* to, const Packet4bf& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE vst1_u16(reinterpret_cast<uint16_t*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf ploaddup<Packet4bf>(const bfloat16* from)
+{
+  return ploaddup<Packet4us>(reinterpret_cast<const uint16_t*>(from));
+}
+
+template <> EIGEN_STRONG_INLINE Packet4bf pabs(const Packet4bf& a) {
+  return F32ToBf16(pabs<Packet4f>(Bf16ToF32(a)));
+}
+
+template <> EIGEN_STRONG_INLINE Packet4bf pmin<PropagateNumbers, Packet4bf>(const Packet4bf &a,
+                                                                            const Packet4bf &b)
+{
+  return F32ToBf16(pmin<PropagateNumbers, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+template <> EIGEN_STRONG_INLINE Packet4bf pmin<PropagateNaN, Packet4bf>(const Packet4bf &a,
+                                                                        const Packet4bf &b)
+{
+  return F32ToBf16(pmin<PropagateNaN, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <> EIGEN_STRONG_INLINE Packet4bf pmin<Packet4bf>(const Packet4bf &a,
+                                                          const Packet4bf &b)
+{
+  return F32ToBf16(pmin<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <> EIGEN_STRONG_INLINE Packet4bf pmax<PropagateNumbers, Packet4bf>(const Packet4bf &a,
+                                                                            const Packet4bf &b)
+{
+  return F32ToBf16(pmax<PropagateNumbers, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+template <> EIGEN_STRONG_INLINE Packet4bf pmax<PropagateNaN, Packet4bf>(const Packet4bf &a,
+                                                                        const Packet4bf &b)
+{
+  return F32ToBf16(pmax<PropagateNaN, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <> EIGEN_STRONG_INLINE Packet4bf pmax<Packet4bf>(const Packet4bf &a,
+                                                          const Packet4bf &b)
+{
+  return F32ToBf16(pmax<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf plset<Packet4bf>(const bfloat16& a)
+{
+  return F32ToBf16(plset<Packet4f>(static_cast<float>(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf por(const Packet4bf& a,const Packet4bf& b) {
+  return por<Packet4us>(a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pxor(const Packet4bf& a,const Packet4bf& b) {
+  return pxor<Packet4us>(a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pand(const Packet4bf& a,const Packet4bf& b) {
+  return pand<Packet4us>(a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pandnot(const Packet4bf& a,const Packet4bf& b) {
+  return pandnot<Packet4us>(a, b);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4bf pselect(const Packet4bf& mask, const Packet4bf& a,
+                                                      const Packet4bf& b)
+{
+  return pselect<Packet4us>(mask, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf print<Packet4bf>(const Packet4bf& a)
+{
+  return F32ToBf16(print<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pfloor<Packet4bf>(const Packet4bf& a)
+{
+  return F32ToBf16(pfloor<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pceil<Packet4bf>(const Packet4bf& a)
+{
+  return F32ToBf16(pceil<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pconj(const Packet4bf& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4bf padd<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
+  return F32ToBf16(padd<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf psub<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
+  return F32ToBf16(psub<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pmul<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
+  return F32ToBf16(pmul<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pdiv<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
+  return F32ToBf16(pdiv<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<>
+EIGEN_STRONG_INLINE Packet4bf pgather<bfloat16, Packet4bf>(const bfloat16* from, Index stride)
+{
+  return pgather<uint16_t, Packet4us>(reinterpret_cast<const uint16_t*>(from), stride);
+}
+
+template<>
+EIGEN_STRONG_INLINE void pscatter<bfloat16, Packet4bf>(bfloat16* to, const Packet4bf& from, Index stride)
+{
+  pscatter<uint16_t, Packet4us>(reinterpret_cast<uint16_t*>(to), from, stride);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux<Packet4bf>(const Packet4bf& a)
+{
+  return static_cast<bfloat16>(predux<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_max<Packet4bf>(const Packet4bf& a)
+{
+  return static_cast<bfloat16>(predux_max<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_min<Packet4bf>(const Packet4bf& a)
+{
+  return static_cast<bfloat16>(predux_min<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_mul<Packet4bf>(const Packet4bf& a)
+{
+  return static_cast<bfloat16>(predux_mul<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf preverse<Packet4bf>(const Packet4bf& a)
+{
+  return preverse<Packet4us>(a);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4bf, 4>& kernel)
+{
+  detail::ptranspose_impl(kernel);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pabsdiff<Packet4bf>(const Packet4bf& a, const Packet4bf& b)
+{
+  return F32ToBf16(pabsdiff<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pcmp_eq<Packet4bf>(const Packet4bf& a, const Packet4bf& b)
+{
+  return F32MaskToBf16Mask(pcmp_eq<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pcmp_lt<Packet4bf>(const Packet4bf& a, const Packet4bf& b)
+{
+  return F32MaskToBf16Mask(pcmp_lt<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pcmp_lt_or_nan<Packet4bf>(const Packet4bf& a, const Packet4bf& b)
+{
+  return F32MaskToBf16Mask(pcmp_lt_or_nan<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pcmp_le<Packet4bf>(const Packet4bf& a, const Packet4bf& b)
+{
+  return F32MaskToBf16Mask(pcmp_le<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pnegate<Packet4bf>(const Packet4bf& a)
+{
+  return pxor<Packet4us>(a, pset1<Packet4us>(static_cast<uint16_t>(0x8000)));
+}
+
+//---------- double ----------
+
+// Clang 3.5 in the iOS toolchain has an ICE triggered by NEON intrisics for double.
+// Confirmed at least with __apple_build_version__ = 6000054.
+#ifdef __apple_build_version__
+// Let's hope that by the time __apple_build_version__ hits the 601* range, the bug will be fixed.
+// https://gist.github.com/yamaya/2924292 suggests that the 3 first digits are only updated with
+// major toolchain updates.
+#define EIGEN_APPLE_DOUBLE_NEON_BUG (__apple_build_version__ < 6010000)
+#else
+#define EIGEN_APPLE_DOUBLE_NEON_BUG 0
+#endif
+
+#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+
+// Bug 907: workaround missing declarations of the following two functions in the ADK
+// Defining these functions as templates ensures that if these intrinsics are
+// already defined in arm_neon.h, then our workaround doesn't cause a conflict
+// and has lower priority in overload resolution.
+template <typename T> uint64x2_t vreinterpretq_u64_f64(T a) { return (uint64x2_t) a; }
+
+template <typename T> float64x2_t vreinterpretq_f64_u64(T a) { return (float64x2_t) a; }
+
+typedef float64x2_t Packet2d;
+typedef float64x1_t Packet1d;
+
+// fuctionally equivalent to _mm_shuffle_pd in SSE (i.e. shuffle(m, n, mask) equals _mm_shuffle_pd(m,n,mask))
+// Currently used in LU/arch/InverseSize4.h to enable a shared implementation
+// for fast inversion of matrices of size 4.
+EIGEN_STRONG_INLINE Packet2d shuffle(const Packet2d& m, const Packet2d& n, int mask)
+{
+  const double* a = reinterpret_cast<const double*>(&m);
+  const double* b = reinterpret_cast<const double*>(&n);
+  Packet2d res = {*(a + (mask & 1)), *(b + ((mask >> 1) & 1))};
+  return res;
+}
+
+EIGEN_STRONG_INLINE Packet2d vec2d_swizzle2(const Packet2d& a, const Packet2d& b, int mask)
+{
+  return shuffle(a, b, mask);
+}
+EIGEN_STRONG_INLINE Packet2d vec2d_unpacklo(const Packet2d& a,const Packet2d& b)
+{
+  return shuffle(a, b, 0);
+}
+EIGEN_STRONG_INLINE Packet2d vec2d_unpackhi(const Packet2d& a,const Packet2d& b)
+{
+  return shuffle(a, b, 3);
+}
+#define vec2d_duplane(a, p) \
+  vdupq_laneq_f64(a, p)
+
+template<> struct packet_traits<double>  : default_packet_traits
+{
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasCmp       = 1,
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+
+    HasDiv   = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = 0,
+    HasErf  = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2d>
+{
+  typedef double type;
+  typedef Packet2d half;
+  typedef Packet2l integer_packet;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double&  from) { return vdupq_n_f64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a)
+{
+  const double c[] = {0.0,1.0};
+  return vaddq_f64(pset1<Packet2d>(a), vld1q_f64(c));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return vaddq_f64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return vsubq_f64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& , const Packet2d& );
+template<> EIGEN_STRONG_INLINE Packet2d paddsub<Packet2d>(const Packet2d& a, const Packet2d& b){
+  const Packet2d mask = {numext::bit_cast<double>(0x8000000000000000ull),0.0};
+  return padd(a, pxor(mask, b));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) { return vnegq_f64(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return vmulq_f64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return vdivq_f64(a,b); }
+
+#ifdef __ARM_FEATURE_FMA
+// See bug 936. See above comment about FMA for float.
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c)
+{ return vfmaq_f64(c,a,b); }
+#else
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c)
+{ return vmlaq_f64(c,a,b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) { return vminq_f64(a,b); }
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+// numeric max and min are only available if ARM_FEATURE_NUMERIC_MAXMIN is defined (which can only be the case for Armv8 systems).
+template<> EIGEN_STRONG_INLINE Packet2d pmin<PropagateNumbers, Packet2d>(const Packet2d& a, const Packet2d& b) { return vminnmq_f64(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmax<PropagateNumbers, Packet2d>(const Packet2d& a, const Packet2d& b) { return vmaxnmq_f64(a, b); }
+
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d pmin<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) { return pmin<Packet2d>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) { return vmaxq_f64(a,b); }
+
+
+template<> EIGEN_STRONG_INLINE Packet2d pmax<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) { return pmax<Packet2d>(a, b); }
+
+// Logical Operations are not supported for float, so we have to reinterpret casts using NEON intrinsics
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b))); }
+
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b))); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b))); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vbicq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b))); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_le(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vcleq_f64(a,b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vcltq_f64(a,b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u32(vmvnq_u32(vreinterpretq_u32_u64(vcgeq_f64(a,b)))); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_eq(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vceqq_f64(a,b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double* from) { return vld1q_dup_f64(from); }
+template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet2d& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_f64(to,from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet2d& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_f64(to,from); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+  Packet2d res = pset1<Packet2d>(0.0);
+  res = vld1q_lane_f64(from + 0*stride, res, 0);
+  res = vld1q_lane_f64(from + 1*stride, res, 1);
+  return res;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  vst1q_lane_f64(to + stride*0, from, 0);
+  vst1q_lane_f64(to + stride*1, from, 1);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { EIGEN_ARM_PREFETCH(addr); }
+
+// FIXME only store the 2 first elements ?
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return vgetq_lane_f64(a,0); }
+
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a)
+{ return vcombine_f64(vget_high_f64(a), vget_low_f64(a)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a) { return vabsq_f64(a); }
+
+#if EIGEN_COMP_CLANG && defined(__apple_build_version__)
+// workaround ICE, see bug 907
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{ return (vget_low_f64(a) + vget_high_f64(a))[0]; }
+#else
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{ return vget_lane_f64(vget_low_f64(a) + vget_high_f64(a), 0); }
+#endif
+
+// Other reduction functions:
+// mul
+#if EIGEN_COMP_CLANG && defined(__apple_build_version__)
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{ return (vget_low_f64(a) * vget_high_f64(a))[0]; }
+#else
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{ return vget_lane_f64(vget_low_f64(a) * vget_high_f64(a), 0); }
+#endif
+
+// min
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{ return vgetq_lane_f64(vpminq_f64(a,a), 0); }
+
+// max
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{ return vgetq_lane_f64(vpmaxq_f64(a,a), 0); }
+
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet2d, 2>& kernel)
+{
+  const float64x2_t tmp1 = vzip1q_f64(kernel.packet[0], kernel.packet[1]);
+  const float64x2_t tmp2 = vzip2q_f64(kernel.packet[0], kernel.packet[1]);
+
+  kernel.packet[0] = tmp1;
+  kernel.packet[1] = tmp2;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2d pselect( const Packet2d& mask, const Packet2d& a, const Packet2d& b)
+{ return vbslq_f64(vreinterpretq_u64_f64(mask), a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d print<Packet2d>(const Packet2d& a)
+{ return vrndnq_f64(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a)
+{ return vrndmq_f64(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a)
+{ return vrndpq_f64(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pldexp<Packet2d>(const Packet2d& a, const Packet2d& exponent)
+{ return pldexp_generic(a, exponent); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pfrexp<Packet2d>(const Packet2d& a, Packet2d& exponent)
+{ return pfrexp_generic(a,exponent); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pset1frombits<Packet2d>(uint64_t from)
+{ return vreinterpretq_f64_u64(vdupq_n_u64(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d prsqrt(const Packet2d& a) {
+  // Compute approximate reciprocal sqrt.
+  Packet2d x = vrsqrteq_f64(a);
+  // Do Newton iterations for 1/sqrt(x).
+  x = vmulq_f64(vrsqrtsq_f64(vmulq_f64(a, x), x), x);
+  x = vmulq_f64(vrsqrtsq_f64(vmulq_f64(a, x), x), x);
+  x = vmulq_f64(vrsqrtsq_f64(vmulq_f64(a, x), x), x);
+  const Packet2d infinity = pset1<Packet2d>(NumTraits<double>::infinity());
+  return pselect(pcmp_eq(a, pzero(a)), infinity, x);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d psqrt(const Packet2d& _x){ return vsqrtq_f64(_x); }
+
+#endif // EIGEN_ARCH_ARM64
+
+// Do we have an fp16 types and supporting Neon intrinsics?
+#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+typedef float16x4_t Packet4hf;
+typedef float16x8_t Packet8hf;
+
+template <>
+struct packet_traits<Eigen::half> : default_packet_traits {
+  typedef Packet8hf type;
+  typedef Packet4hf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+
+    HasCmp = 1,
+    HasCast = 1,
+    HasAdd = 1,
+    HasSub = 1,
+    HasShift = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasAbs2 = 1,
+    HasAbsDiff = 0,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 1,
+    HasSetLinear = 0,
+    HasBlend = 0,
+    HasInsert = 1,
+    HasReduxp = 1,
+    HasDiv = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+    HasSin = 0,
+    HasCos = 0,
+    HasLog = 0,
+    HasExp = 0,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasErf = EIGEN_FAST_MATH,
+    HasBessel = 0,  // Issues with accuracy.
+    HasNdtri = 0
+  };
+};
+
+template <>
+struct unpacket_traits<Packet4hf> {
+  typedef Eigen::half type;
+  typedef Packet4hf half;
+  enum {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+struct unpacket_traits<Packet8hf> {
+  typedef Eigen::half type;
+  typedef Packet4hf half;
+  enum {
+    size = 8,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf predux_half_dowto4<Packet8hf>(const Packet8hf& a) {
+  return vadd_f16(vget_low_f16(a), vget_high_f16(a));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pset1<Packet8hf>(const Eigen::half& from) {
+  return vdupq_n_f16(from.x);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pset1<Packet4hf>(const Eigen::half& from) {
+  return vdup_n_f16(from.x);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf plset<Packet8hf>(const Eigen::half& a) {
+  const float16_t f[] = {0, 1, 2, 3, 4, 5, 6, 7};
+  Packet8hf countdown = vld1q_f16(f);
+  return vaddq_f16(pset1<Packet8hf>(a), countdown);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf plset<Packet4hf>(const Eigen::half& a) {
+  const float16_t f[] = {0, 1, 2, 3};
+  Packet4hf countdown = vld1_f16(f);
+  return vadd_f16(pset1<Packet4hf>(a), countdown);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf padd<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vaddq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf padd<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vadd_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf psub<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vsubq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf psub<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vsub_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pnegate(const Packet8hf& a) {
+  return vnegq_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pnegate(const Packet4hf& a) {
+  return vneg_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pconj(const Packet8hf& a) {
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pconj(const Packet4hf& a) {
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pmul<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vmulq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pmul<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vmul_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pdiv<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vdivq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pdiv<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vdiv_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pmadd(const Packet8hf& a, const Packet8hf& b, const Packet8hf& c) {
+  return vfmaq_f16(c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pmadd(const Packet4hf& a, const Packet4hf& b, const Packet4hf& c) {
+  return vfma_f16(c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pmin<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vminq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pmin<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vmin_f16(a, b);
+}
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+// numeric max and min are only available if ARM_FEATURE_NUMERIC_MAXMIN is defined (which can only be the case for Armv8 systems).
+template<> EIGEN_STRONG_INLINE Packet4hf pmin<PropagateNumbers, Packet4hf>(const Packet4hf& a, const Packet4hf& b) { return vminnm_f16(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8hf pmin<PropagateNumbers, Packet8hf>(const Packet8hf& a, const Packet8hf& b) { return vminnmq_f16(a, b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4hf pmin<PropagateNaN, Packet4hf>(const Packet4hf& a, const Packet4hf& b) { return pmin<Packet4hf>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet8hf pmin<PropagateNaN, Packet8hf>(const Packet8hf& a, const Packet8hf& b) { return pmin<Packet8hf>(a, b); }
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pmax<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vmaxq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pmax<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vmax_f16(a, b);
+}
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+// numeric max and min are only available if ARM_FEATURE_NUMERIC_MAXMIN is defined (which can only be the case for Armv8 systems).
+template<> EIGEN_STRONG_INLINE Packet4hf pmax<PropagateNumbers, Packet4hf>(const Packet4hf& a, const Packet4hf& b) { return vmaxnm_f16(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8hf pmax<PropagateNumbers, Packet8hf>(const Packet8hf& a, const Packet8hf& b) { return vmaxnmq_f16(a, b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4hf pmax<PropagateNaN, Packet4hf>(const Packet4hf& a, const Packet4hf& b) { return pmax<Packet4hf>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet8hf pmax<PropagateNaN, Packet8hf>(const Packet8hf& a, const Packet8hf& b) { return pmax<Packet8hf>(a, b); }
+
+#define EIGEN_MAKE_ARM_FP16_CMP_8(name)                                               \
+  template <>                                                                         \
+  EIGEN_STRONG_INLINE Packet8hf pcmp_##name(const Packet8hf& a, const Packet8hf& b) { \
+    return vreinterpretq_f16_u16(vc##name##q_f16(a, b));                              \
+  }
+
+#define EIGEN_MAKE_ARM_FP16_CMP_4(name)                                               \
+  template <>                                                                         \
+  EIGEN_STRONG_INLINE Packet4hf pcmp_##name(const Packet4hf& a, const Packet4hf& b) { \
+    return vreinterpret_f16_u16(vc##name##_f16(a, b));                                \
+  }
+
+EIGEN_MAKE_ARM_FP16_CMP_8(eq)
+EIGEN_MAKE_ARM_FP16_CMP_8(lt)
+EIGEN_MAKE_ARM_FP16_CMP_8(le)
+
+EIGEN_MAKE_ARM_FP16_CMP_4(eq)
+EIGEN_MAKE_ARM_FP16_CMP_4(lt)
+EIGEN_MAKE_ARM_FP16_CMP_4(le)
+
+#undef EIGEN_MAKE_ARM_FP16_CMP_8
+#undef EIGEN_MAKE_ARM_FP16_CMP_4
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pcmp_lt_or_nan<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vreinterpretq_f16_u16(vmvnq_u16(vcgeq_f16(a, b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pcmp_lt_or_nan<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(vmvn_u16(vcge_f16(a, b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf print<Packet8hf>(const Packet8hf& a)
+{ return vrndnq_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf print<Packet4hf>(const Packet4hf& a)
+{ return vrndn_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pfloor<Packet8hf>(const Packet8hf& a)
+{ return vrndmq_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pfloor<Packet4hf>(const Packet4hf& a)
+{ return vrndm_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pceil<Packet8hf>(const Packet8hf& a)
+{ return vrndpq_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pceil<Packet4hf>(const Packet4hf& a)
+{ return vrndp_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf psqrt<Packet8hf>(const Packet8hf& a) {
+  return vsqrtq_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf psqrt<Packet4hf>(const Packet4hf& a) {
+  return vsqrt_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pand<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vreinterpretq_f16_u16(vandq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pand<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(vand_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf por<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vreinterpretq_f16_u16(vorrq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf por<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(vorr_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pxor<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vreinterpretq_f16_u16(veorq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pxor<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(veor_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pandnot<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vreinterpretq_f16_u16(vbicq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pandnot<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(vbic_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pload<Packet8hf>(const Eigen::half* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f16(reinterpret_cast<const float16_t*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pload<Packet4hf>(const Eigen::half* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return vld1_f16(reinterpret_cast<const float16_t*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf ploadu<Packet8hf>(const Eigen::half* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f16(reinterpret_cast<const float16_t*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf ploadu<Packet4hf>(const Eigen::half* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return vld1_f16(reinterpret_cast<const float16_t*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf ploaddup<Packet8hf>(const Eigen::half* from) {
+  Packet8hf packet;
+  packet[0] = from[0].x;
+  packet[1] = from[0].x;
+  packet[2] = from[1].x;
+  packet[3] = from[1].x;
+  packet[4] = from[2].x;
+  packet[5] = from[2].x;
+  packet[6] = from[3].x;
+  packet[7] = from[3].x;
+  return packet;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf ploaddup<Packet4hf>(const Eigen::half* from) {
+  float16x4_t packet;
+  float16_t* tmp;
+  tmp = (float16_t*)&packet;
+  tmp[0] = from[0].x;
+  tmp[1] = from[0].x;
+  tmp[2] = from[1].x;
+  tmp[3] = from[1].x;
+  return packet;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf ploadquad<Packet8hf>(const Eigen::half* from) {
+  Packet4hf lo, hi;
+  lo = vld1_dup_f16(reinterpret_cast<const float16_t*>(from));
+  hi = vld1_dup_f16(reinterpret_cast<const float16_t*>(from+1));
+  return vcombine_f16(lo, hi);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pinsertfirst(const Packet8hf& a, Eigen::half b) { return vsetq_lane_f16(b.x, a, 0); }
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pinsertfirst(const Packet4hf& a, Eigen::half b) { return vset_lane_f16(b.x, a, 0); }
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pselect(const Packet8hf& mask, const Packet8hf& a, const Packet8hf& b) {
+  return vbslq_f16(vreinterpretq_u16_f16(mask), a, b);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pselect(const Packet4hf& mask, const Packet4hf& a, const Packet4hf& b) {
+  return vbsl_f16(vreinterpret_u16_f16(mask), a, b);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pinsertlast(const Packet8hf& a, Eigen::half b) { return vsetq_lane_f16(b.x, a, 7); }
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pinsertlast(const Packet4hf& a, Eigen::half b) { return vset_lane_f16(b.x, a, 3); }
+
+template <>
+EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet8hf& from) {
+  EIGEN_DEBUG_ALIGNED_STORE vst1q_f16(reinterpret_cast<float16_t*>(to), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet4hf& from) {
+  EIGEN_DEBUG_ALIGNED_STORE vst1_f16(reinterpret_cast<float16_t*>(to), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet8hf& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE vst1q_f16(reinterpret_cast<float16_t*>(to), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet4hf& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE vst1_f16(reinterpret_cast<float16_t*>(to), from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pgather<Eigen::half, Packet8hf>(const Eigen::half* from, Index stride) {
+  Packet8hf res = pset1<Packet8hf>(Eigen::half(0.f));
+  res = vsetq_lane_f16(from[0 * stride].x, res, 0);
+  res = vsetq_lane_f16(from[1 * stride].x, res, 1);
+  res = vsetq_lane_f16(from[2 * stride].x, res, 2);
+  res = vsetq_lane_f16(from[3 * stride].x, res, 3);
+  res = vsetq_lane_f16(from[4 * stride].x, res, 4);
+  res = vsetq_lane_f16(from[5 * stride].x, res, 5);
+  res = vsetq_lane_f16(from[6 * stride].x, res, 6);
+  res = vsetq_lane_f16(from[7 * stride].x, res, 7);
+  return res;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pgather<Eigen::half, Packet4hf>(const Eigen::half* from, Index stride) {
+  Packet4hf res = pset1<Packet4hf>(Eigen::half(0.f));
+  res = vset_lane_f16(from[0 * stride].x, res, 0);
+  res = vset_lane_f16(from[1 * stride].x, res, 1);
+  res = vset_lane_f16(from[2 * stride].x, res, 2);
+  res = vset_lane_f16(from[3 * stride].x, res, 3);
+  return res;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet8hf>(Eigen::half* to, const Packet8hf& from, Index stride) {
+  to[stride * 0].x = vgetq_lane_f16(from, 0);
+  to[stride * 1].x = vgetq_lane_f16(from, 1);
+  to[stride * 2].x = vgetq_lane_f16(from, 2);
+  to[stride * 3].x = vgetq_lane_f16(from, 3);
+  to[stride * 4].x = vgetq_lane_f16(from, 4);
+  to[stride * 5].x = vgetq_lane_f16(from, 5);
+  to[stride * 6].x = vgetq_lane_f16(from, 6);
+  to[stride * 7].x = vgetq_lane_f16(from, 7);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet4hf>(Eigen::half* to, const Packet4hf& from, Index stride) {
+  to[stride * 0].x = vget_lane_f16(from, 0);
+  to[stride * 1].x = vget_lane_f16(from, 1);
+  to[stride * 2].x = vget_lane_f16(from, 2);
+  to[stride * 3].x = vget_lane_f16(from, 3);
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<Eigen::half>(const Eigen::half* addr) {
+  EIGEN_ARM_PREFETCH(addr);
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half pfirst<Packet8hf>(const Packet8hf& a) {
+  float16_t x[8];
+  vst1q_f16(x, a);
+  Eigen::half h;
+  h.x = x[0];
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half pfirst<Packet4hf>(const Packet4hf& a) {
+  float16_t x[4];
+  vst1_f16(x, a);
+  Eigen::half h;
+  h.x = x[0];
+  return h;
+}
+
+template<> EIGEN_STRONG_INLINE Packet8hf preverse(const Packet8hf& a) {
+  float16x4_t a_lo, a_hi;
+  Packet8hf a_r64;
+
+  a_r64 = vrev64q_f16(a);
+  a_lo = vget_low_f16(a_r64);
+  a_hi = vget_high_f16(a_r64);
+  return vcombine_f16(a_hi, a_lo);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf preverse<Packet4hf>(const Packet4hf& a) {
+  return vrev64_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pabs<Packet8hf>(const Packet8hf& a) {
+  return vabsq_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pabs<Packet4hf>(const Packet4hf& a) {
+  return vabs_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux<Packet8hf>(const Packet8hf& a) {
+  float16x4_t a_lo, a_hi, sum;
+
+  a_lo = vget_low_f16(a);
+  a_hi = vget_high_f16(a);
+  sum = vpadd_f16(a_lo, a_hi);
+  sum = vpadd_f16(sum, sum);
+  sum = vpadd_f16(sum, sum);
+
+  Eigen::half h;
+  h.x = vget_lane_f16(sum, 0);
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux<Packet4hf>(const Packet4hf& a) {
+  float16x4_t sum;
+
+  sum = vpadd_f16(a, a);
+  sum = vpadd_f16(sum, sum);
+  Eigen::half h;
+  h.x = vget_lane_f16(sum, 0);
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet8hf>(const Packet8hf& a) {
+  float16x4_t a_lo, a_hi, prod;
+
+  a_lo = vget_low_f16(a);
+  a_hi = vget_high_f16(a);
+  prod = vmul_f16(a_lo, a_hi);
+  prod = vmul_f16(prod, vrev64_f16(prod));
+
+  Eigen::half h;
+  h.x = vmulh_f16(vget_lane_f16(prod, 0), vget_lane_f16(prod, 1));
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet4hf>(const Packet4hf& a) {
+  float16x4_t prod;
+  prod = vmul_f16(a, vrev64_f16(a));
+  Eigen::half h;
+  h.x = vmulh_f16(vget_lane_f16(prod, 0), vget_lane_f16(prod, 1));
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_min<Packet8hf>(const Packet8hf& a) {
+  float16x4_t a_lo, a_hi, min;
+
+  a_lo = vget_low_f16(a);
+  a_hi = vget_high_f16(a);
+  min = vpmin_f16(a_lo, a_hi);
+  min = vpmin_f16(min, min);
+  min = vpmin_f16(min, min);
+
+  Eigen::half h;
+  h.x = vget_lane_f16(min, 0);
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_min<Packet4hf>(const Packet4hf& a) {
+  Packet4hf tmp;
+  tmp = vpmin_f16(a, a);
+  tmp = vpmin_f16(tmp, tmp);
+  Eigen::half h;
+  h.x = vget_lane_f16(tmp, 0);
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_max<Packet8hf>(const Packet8hf& a) {
+  float16x4_t a_lo, a_hi, max;
+
+  a_lo = vget_low_f16(a);
+  a_hi = vget_high_f16(a);
+  max = vpmax_f16(a_lo, a_hi);
+  max = vpmax_f16(max, max);
+  max = vpmax_f16(max, max);
+
+  Eigen::half h;
+  h.x = vget_lane_f16(max, 0);
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_max<Packet4hf>(const Packet4hf& a) {
+  Packet4hf tmp;
+  tmp = vpmax_f16(a, a);
+  tmp = vpmax_f16(tmp, tmp);
+  Eigen::half h;
+  h.x = vget_lane_f16(tmp, 0);
+  return h;
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8hf, 4>& kernel)
+{
+  const float16x8x2_t zip16_1 = vzipq_f16(kernel.packet[0], kernel.packet[1]);
+  const float16x8x2_t zip16_2 = vzipq_f16(kernel.packet[2], kernel.packet[3]);
+
+  const float32x4x2_t zip32_1 = vzipq_f32(vreinterpretq_f32_f16(zip16_1.val[0]), vreinterpretq_f32_f16(zip16_2.val[0]));
+  const float32x4x2_t zip32_2 = vzipq_f32(vreinterpretq_f32_f16(zip16_1.val[1]), vreinterpretq_f32_f16(zip16_2.val[1]));
+
+  kernel.packet[0] = vreinterpretq_f16_f32(zip32_1.val[0]);
+  kernel.packet[1] = vreinterpretq_f16_f32(zip32_1.val[1]);
+  kernel.packet[2] = vreinterpretq_f16_f32(zip32_2.val[0]);
+  kernel.packet[3] = vreinterpretq_f16_f32(zip32_2.val[1]);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4hf, 4>& kernel) {
+  EIGEN_ALIGN16 float16x4x4_t tmp_x4;
+  float16_t* tmp = (float16_t*)&kernel;
+  tmp_x4 = vld4_f16(tmp);
+
+  kernel.packet[0] = tmp_x4.val[0];
+  kernel.packet[1] = tmp_x4.val[1];
+  kernel.packet[2] = tmp_x4.val[2];
+  kernel.packet[3] = tmp_x4.val[3];
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8hf, 8>& kernel) {
+  float16x8x2_t T_1[4];
+
+  T_1[0] = vuzpq_f16(kernel.packet[0], kernel.packet[1]);
+  T_1[1] = vuzpq_f16(kernel.packet[2], kernel.packet[3]);
+  T_1[2] = vuzpq_f16(kernel.packet[4], kernel.packet[5]);
+  T_1[3] = vuzpq_f16(kernel.packet[6], kernel.packet[7]);
+
+  float16x8x2_t T_2[4];
+  T_2[0] = vuzpq_f16(T_1[0].val[0], T_1[1].val[0]);
+  T_2[1] = vuzpq_f16(T_1[0].val[1], T_1[1].val[1]);
+  T_2[2] = vuzpq_f16(T_1[2].val[0], T_1[3].val[0]);
+  T_2[3] = vuzpq_f16(T_1[2].val[1], T_1[3].val[1]);
+
+  float16x8x2_t T_3[4];
+  T_3[0] = vuzpq_f16(T_2[0].val[0], T_2[2].val[0]);
+  T_3[1] = vuzpq_f16(T_2[0].val[1], T_2[2].val[1]);
+  T_3[2] = vuzpq_f16(T_2[1].val[0], T_2[3].val[0]);
+  T_3[3] = vuzpq_f16(T_2[1].val[1], T_2[3].val[1]);
+
+  kernel.packet[0] = T_3[0].val[0];
+  kernel.packet[1] = T_3[2].val[0];
+  kernel.packet[2] = T_3[1].val[0];
+  kernel.packet[3] = T_3[3].val[0];
+  kernel.packet[4] = T_3[0].val[1];
+  kernel.packet[5] = T_3[2].val[1];
+  kernel.packet[6] = T_3[1].val[1];
+  kernel.packet[7] = T_3[3].val[1];
+}
+#endif // end EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_NEON_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/TypeCasting.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/TypeCasting.h
new file mode 100644
index 00000000..54f97336
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/NEON/TypeCasting.h
@@ -0,0 +1,1419 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Rasmus Munk Larsen <rmlarsen@google.com>
+// Copyright (C) 2020 Antonio Sanchez <cantonios@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_NEON_H
+#define EIGEN_TYPE_CASTING_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+//==============================================================================
+// pcast, SrcType = float
+//==============================================================================
+template <>
+struct type_casting_traits<float, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet4f, Packet4f>(const Packet4f& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet2f, Packet2f>(const Packet2f& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<float, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+struct type_casting_traits<float, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+// If float64 exists, first convert to that to keep as much precision as possible.
+#if EIGEN_ARCH_ARM64
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet4f, Packet2l>(const Packet4f& a) {
+  // Discard second half of input.
+  return vcvtq_s64_f64(vcvt_f64_f32(vget_low_f32(a)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet4f, Packet2ul>(const Packet4f& a) {
+  // Discard second half of input.
+  return vcvtq_u64_f64(vcvt_f64_f32(vget_low_f32(a)));
+}
+#else
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet4f, Packet2l>(const Packet4f& a) {
+  // Discard second half of input.
+  return vmovl_s32(vget_low_s32(vcvtq_s32_f32(a)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet4f, Packet2ul>(const Packet4f& a) {
+  // Discard second half of input.
+  return vmovl_u32(vget_low_u32(vcvtq_u32_f32(a)));
+}
+#endif  // EIGEN_ARCH_ARM64
+
+template <>
+struct type_casting_traits<float, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet4f, Packet4i>(const Packet4f& a) {
+  return vcvtq_s32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet2f, Packet2i>(const Packet2f& a) {
+  return vcvt_s32_f32(a);
+}
+
+template <>
+struct type_casting_traits<float, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet4f, Packet4ui>(const Packet4f& a) {
+  return vcvtq_u32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet2f, Packet2ui>(const Packet2f& a) {
+  return vcvt_u32_f32(a);
+}
+
+template <>
+struct type_casting_traits<float, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet4f, Packet8s>(const Packet4f& a, const Packet4f& b) {
+  return vcombine_s16(vmovn_s32(vcvtq_s32_f32(a)), vmovn_s32(vcvtq_s32_f32(b)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet2f, Packet4s>(const Packet2f& a, const Packet2f& b) {
+  return vmovn_s32(vcombine_s32(vcvt_s32_f32(a), vcvt_s32_f32(b)));
+}
+
+template <>
+struct type_casting_traits<float, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet4f, Packet8us>(const Packet4f& a, const Packet4f& b) {
+  return vcombine_u16(vmovn_u32(vcvtq_u32_f32(a)), vmovn_u32(vcvtq_u32_f32(b)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet2f, Packet4us>(const Packet2f& a, const Packet2f& b) {
+  return vmovn_u32(vcombine_u32(vcvt_u32_f32(a), vcvt_u32_f32(b)));
+}
+
+template <>
+struct type_casting_traits<float, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet4f, Packet16c>(const Packet4f& a, const Packet4f& b, const Packet4f& c,
+                                                         const Packet4f& d) {
+  const int16x8_t ab_s16 = pcast<Packet4f, Packet8s>(a, b);
+  const int16x8_t cd_s16 = pcast<Packet4f, Packet8s>(c, d);
+  return vcombine_s8(vmovn_s16(ab_s16), vmovn_s16(cd_s16));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet2f, Packet8c>(const Packet2f& a, const Packet2f& b, const Packet2f& c,
+                                                       const Packet2f& d) {
+  const int16x4_t ab_s16 = pcast<Packet2f, Packet4s>(a, b);
+  const int16x4_t cd_s16 = pcast<Packet2f, Packet4s>(c, d);
+  return vmovn_s16(vcombine_s16(ab_s16, cd_s16));
+}
+
+template <>
+struct type_casting_traits<float, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet4f, Packet16uc>(const Packet4f& a, const Packet4f& b, const Packet4f& c,
+                                                           const Packet4f& d) {
+  const uint16x8_t ab_u16 = pcast<Packet4f, Packet8us>(a, b);
+  const uint16x8_t cd_u16 = pcast<Packet4f, Packet8us>(c, d);
+  return vcombine_u8(vmovn_u16(ab_u16), vmovn_u16(cd_u16));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet2f, Packet8uc>(const Packet2f& a, const Packet2f& b, const Packet2f& c,
+                                                         const Packet2f& d) {
+  const uint16x4_t ab_u16 = pcast<Packet2f, Packet4us>(a, b);
+  const uint16x4_t cd_u16 = pcast<Packet2f, Packet4us>(c, d);
+  return vmovn_u16(vcombine_u16(ab_u16, cd_u16));
+}
+
+//==============================================================================
+// pcast, SrcType = int8_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::int8_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet16c, Packet4f>(const Packet16c& a) {
+  // Discard all but first 4 bytes.
+  return vcvtq_f32_s32(vmovl_s16(vget_low_s16(vmovl_s8(vget_low_s8(a)))));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet8c, Packet2f>(const Packet8c& a) {
+  // Discard all but first 2 bytes.
+  return vcvt_f32_s32(vget_low_s32(vmovl_s16(vget_low_s16(vmovl_s8(a)))));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet16c, Packet2l>(const Packet16c& a) {
+  // Discard all but first two bytes.
+  return vmovl_s32(vget_low_s32(vmovl_s16(vget_low_s16(vmovl_s8(vget_low_s8(a))))));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet16c, Packet2ul>(const Packet16c& a) {
+  return vreinterpretq_u64_s64(pcast<Packet16c, Packet2l>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet16c, Packet4i>(const Packet16c& a) {
+  // Discard all but first 4 bytes.
+  return vmovl_s16(vget_low_s16(vmovl_s8(vget_low_s8(a))));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet8c, Packet2i>(const Packet8c& a) {
+  // Discard all but first 2 bytes.
+  return vget_low_s32(vmovl_s16(vget_low_s16(vmovl_s8(a))));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet16c, Packet4ui>(const Packet16c& a) {
+  return vreinterpretq_u32_s32(pcast<Packet16c, Packet4i>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet8c, Packet2ui>(const Packet8c& a) {
+  return vreinterpret_u32_s32(pcast<Packet8c, Packet2i>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet16c, Packet8s>(const Packet16c& a) {
+  // Discard second half of input.
+  return vmovl_s8(vget_low_s8(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet8c, Packet4s>(const Packet8c& a) {
+  // Discard second half of input.
+  return vget_low_s16(vmovl_s8(a));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet16c, Packet8us>(const Packet16c& a) {
+  return vreinterpretq_u16_s16(pcast<Packet16c, Packet8s>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet8c, Packet4us>(const Packet8c& a) {
+  return vreinterpret_u16_s16(pcast<Packet8c, Packet4s>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet16c, Packet16c>(const Packet16c& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet8c, Packet8c>(const Packet8c& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet4c pcast<Packet4c, Packet4c>(const Packet4c& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet16c, Packet16uc>(const Packet16c& a) {
+  return vreinterpretq_u8_s8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet8c, Packet8uc>(const Packet8c& a) {
+  return vreinterpret_u8_s8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4uc pcast<Packet4c, Packet4uc>(const Packet4c& a) {
+  return static_cast<Packet4uc>(a);
+}
+
+//==============================================================================
+// pcast, SrcType = uint8_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::uint8_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet16uc, Packet4f>(const Packet16uc& a) {
+  // Discard all but first 4 bytes.
+  return vcvtq_f32_u32(vmovl_u16(vget_low_u16(vmovl_u8(vget_low_u8(a)))));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet8uc, Packet2f>(const Packet8uc& a) {
+  // Discard all but first 2 bytes.
+  return vcvt_f32_u32(vget_low_u32(vmovl_u16(vget_low_u16(vmovl_u8(a)))));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet16uc, Packet2ul>(const Packet16uc& a) {
+  // Discard all but first two bytes.
+  return vmovl_u32(vget_low_u32(vmovl_u16(vget_low_u16(vmovl_u8(vget_low_u8(a))))));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet16uc, Packet2l>(const Packet16uc& a) {
+  return vreinterpretq_s64_u64(pcast<Packet16uc, Packet2ul>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet16uc, Packet4ui>(const Packet16uc& a) {
+  // Discard all but first 4 bytes.
+  return vmovl_u16(vget_low_u16(vmovl_u8(vget_low_u8(a))));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet8uc, Packet2ui>(const Packet8uc& a) {
+  // Discard all but first 2 bytes.
+  return vget_low_u32(vmovl_u16(vget_low_u16(vmovl_u8(a))));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet16uc, Packet4i>(const Packet16uc& a) {
+  return vreinterpretq_s32_u32(pcast<Packet16uc, Packet4ui>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet8uc, Packet2i>(const Packet8uc& a) {
+  return vreinterpret_s32_u32(pcast<Packet8uc, Packet2ui>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet16uc, Packet8us>(const Packet16uc& a) {
+  // Discard second half of input.
+  return vmovl_u8(vget_low_u8(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet8uc, Packet4us>(const Packet8uc& a) {
+  // Discard second half of input.
+  return vget_low_u16(vmovl_u8(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet16uc, Packet8s>(const Packet16uc& a) {
+  return vreinterpretq_s16_u16(pcast<Packet16uc, Packet8us>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet8uc, Packet4s>(const Packet8uc& a) {
+  return vreinterpret_s16_u16(pcast<Packet8uc, Packet4us>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet16uc, Packet16uc>(const Packet16uc& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet8uc, Packet8uc>(const Packet8uc& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet4uc pcast<Packet4uc, Packet4uc>(const Packet4uc& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet16uc, Packet16c>(const Packet16uc& a) {
+  return vreinterpretq_s8_u8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet8uc, Packet8c>(const Packet8uc& a) {
+  return vreinterpret_s8_u8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4c pcast<Packet4uc, Packet4c>(const Packet4uc& a) {
+  return static_cast<Packet4c>(a);
+}
+
+//==============================================================================
+// pcast, SrcType = int16_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::int16_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet8s, Packet4f>(const Packet8s& a) {
+  // Discard second half of input.
+  return vcvtq_f32_s32(vmovl_s16(vget_low_s16(a)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet4s, Packet2f>(const Packet4s& a) {
+  // Discard second half of input.
+  return vcvt_f32_s32(vget_low_s32(vmovl_s16(a)));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet8s, Packet2l>(const Packet8s& a) {
+  // Discard all but first two values.
+  return vmovl_s32(vget_low_s32(vmovl_s16(vget_low_s16(a))));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet8s, Packet2ul>(const Packet8s& a) {
+  return vreinterpretq_u64_s64(pcast<Packet8s, Packet2l>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet8s, Packet4i>(const Packet8s& a) {
+  // Discard second half of input.
+  return vmovl_s16(vget_low_s16(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet4s, Packet2i>(const Packet4s& a) {
+  // Discard second half of input.
+  return vget_low_s32(vmovl_s16(a));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet8s, Packet4ui>(const Packet8s& a) {
+  return vreinterpretq_u32_s32(pcast<Packet8s, Packet4i>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet4s, Packet2ui>(const Packet4s& a) {
+  return vreinterpret_u32_s32(pcast<Packet4s, Packet2i>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet8s, Packet8s>(const Packet8s& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet4s, Packet4s>(const Packet4s& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet8s, Packet8us>(const Packet8s& a) {
+  return vreinterpretq_u16_s16(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet4s, Packet4us>(const Packet4s& a) {
+  return vreinterpret_u16_s16(a);
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet8s, Packet16c>(const Packet8s& a, const Packet8s& b) {
+  return vcombine_s8(vmovn_s16(a), vmovn_s16(b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet4s, Packet8c>(const Packet4s& a, const Packet4s& b) {
+  return vmovn_s16(vcombine_s16(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet8s, Packet16uc>(const Packet8s& a, const Packet8s& b) {
+  return vcombine_u8(vmovn_u16(vreinterpretq_u16_s16(a)), vmovn_u16(vreinterpretq_u16_s16(b)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet4s, Packet8uc>(const Packet4s& a, const Packet4s& b) {
+  return vmovn_u16(vcombine_u16(vreinterpret_u16_s16(a), vreinterpret_u16_s16(b)));
+}
+
+//==============================================================================
+// pcast, SrcType = uint16_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::uint16_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet8us, Packet4f>(const Packet8us& a) {
+  // Discard second half of input.
+  return vcvtq_f32_u32(vmovl_u16(vget_low_u16(a)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet4us, Packet2f>(const Packet4us& a) {
+  // Discard second half of input.
+  return vcvt_f32_u32(vget_low_u32(vmovl_u16(a)));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet8us, Packet2ul>(const Packet8us& a) {
+  // Discard all but first two values.
+  return vmovl_u32(vget_low_u32(vmovl_u16(vget_low_u16(a))));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet8us, Packet2l>(const Packet8us& a) {
+  return vreinterpretq_s64_u64(pcast<Packet8us, Packet2ul>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet8us, Packet4ui>(const Packet8us& a) {
+  // Discard second half of input.
+  return vmovl_u16(vget_low_u16(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet4us, Packet2ui>(const Packet4us& a) {
+  // Discard second half of input.
+  return vget_low_u32(vmovl_u16(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet8us, Packet4i>(const Packet8us& a) {
+  return vreinterpretq_s32_u32(pcast<Packet8us, Packet4ui>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet4us, Packet2i>(const Packet4us& a) {
+  return vreinterpret_s32_u32(pcast<Packet4us, Packet2ui>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet8us, Packet8us>(const Packet8us& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet4us, Packet4us>(const Packet4us& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet8us, Packet8s>(const Packet8us& a) {
+  return vreinterpretq_s16_u16(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet4us, Packet4s>(const Packet4us& a) {
+  return vreinterpret_s16_u16(a);
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet8us, Packet16uc>(const Packet8us& a, const Packet8us& b) {
+  return vcombine_u8(vmovn_u16(a), vmovn_u16(b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet4us, Packet8uc>(const Packet4us& a, const Packet4us& b) {
+  return vmovn_u16(vcombine_u16(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet8us, Packet16c>(const Packet8us& a, const Packet8us& b) {
+  return vreinterpretq_s8_u8(pcast<Packet8us, Packet16uc>(a, b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet4us, Packet8c>(const Packet4us& a, const Packet4us& b) {
+  return vreinterpret_s8_u8(pcast<Packet4us, Packet8uc>(a, b));
+}
+
+//==============================================================================
+// pcast, SrcType = int32_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::int32_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet4i, Packet4f>(const Packet4i& a) {
+  return vcvtq_f32_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet2i, Packet2f>(const Packet2i& a) {
+  return vcvt_f32_s32(a);
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet4i, Packet2l>(const Packet4i& a) {
+  // Discard second half of input.
+  return vmovl_s32(vget_low_s32(a));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet4i, Packet2ul>(const Packet4i& a) {
+  return vreinterpretq_u64_s64(pcast<Packet4i, Packet2l>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet4i, Packet4i>(const Packet4i& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet2i, Packet2i>(const Packet2i& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet4i, Packet4ui>(const Packet4i& a) {
+  return vreinterpretq_u32_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet2i, Packet2ui>(const Packet2i& a) {
+  return vreinterpret_u32_s32(a);
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet4i, Packet8s>(const Packet4i& a, const Packet4i& b) {
+  return vcombine_s16(vmovn_s32(a), vmovn_s32(b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet2i, Packet4s>(const Packet2i& a, const Packet2i& b) {
+  return vmovn_s32(vcombine_s32(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet4i, Packet8us>(const Packet4i& a, const Packet4i& b) {
+  return vcombine_u16(vmovn_u32(vreinterpretq_u32_s32(a)), vmovn_u32(vreinterpretq_u32_s32(b)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet2i, Packet4us>(const Packet2i& a, const Packet2i& b) {
+  return vmovn_u32(vreinterpretq_u32_s32(vcombine_s32(a, b)));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet4i, Packet16c>(const Packet4i& a, const Packet4i& b, const Packet4i& c,
+                                                         const Packet4i& d) {
+  const int16x8_t ab_s16 = pcast<Packet4i, Packet8s>(a, b);
+  const int16x8_t cd_s16 = pcast<Packet4i, Packet8s>(c, d);
+  return vcombine_s8(vmovn_s16(ab_s16), vmovn_s16(cd_s16));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet2i, Packet8c>(const Packet2i& a, const Packet2i& b, const Packet2i& c,
+                                                       const Packet2i& d) {
+  const int16x4_t ab_s16 = vmovn_s32(vcombine_s32(a, b));
+  const int16x4_t cd_s16 = vmovn_s32(vcombine_s32(c, d));
+  return vmovn_s16(vcombine_s16(ab_s16, cd_s16));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet4i, Packet16uc>(const Packet4i& a, const Packet4i& b, const Packet4i& c,
+                                                           const Packet4i& d) {
+  const uint16x8_t ab_u16 = pcast<Packet4i, Packet8us>(a, b);
+  const uint16x8_t cd_u16 = pcast<Packet4i, Packet8us>(c, d);
+  return vcombine_u8(vmovn_u16(ab_u16), vmovn_u16(cd_u16));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet2i, Packet8uc>(const Packet2i& a, const Packet2i& b, const Packet2i& c,
+                                                         const Packet2i& d) {
+  const uint16x4_t ab_u16 = pcast<Packet2i, Packet4us>(a, b);
+  const uint16x4_t cd_u16 = pcast<Packet2i, Packet4us>(c, d);
+  return vmovn_u16(vcombine_u16(ab_u16, cd_u16));
+}
+
+//==============================================================================
+// pcast, SrcType = uint32_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::uint32_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet4ui, Packet4f>(const Packet4ui& a) {
+  return vcvtq_f32_u32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet2ui, Packet2f>(const Packet2ui& a) {
+  return vcvt_f32_u32(a);
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet4ui, Packet2ul>(const Packet4ui& a) {
+  // Discard second half of input.
+  return vmovl_u32(vget_low_u32(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet4ui, Packet2l>(const Packet4ui& a) {
+  return vreinterpretq_s64_u64(pcast<Packet4ui, Packet2ul>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet4ui, Packet4ui>(const Packet4ui& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet2ui, Packet2ui>(const Packet2ui& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet4ui, Packet4i>(const Packet4ui& a) {
+  return vreinterpretq_s32_u32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet2ui, Packet2i>(const Packet2ui& a) {
+  return vreinterpret_s32_u32(a);
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet4ui, Packet8us>(const Packet4ui& a, const Packet4ui& b) {
+  return vcombine_u16(vmovn_u32(a), vmovn_u32(b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet2ui, Packet4us>(const Packet2ui& a, const Packet2ui& b) {
+  return vmovn_u32(vcombine_u32(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet4ui, Packet8s>(const Packet4ui& a, const Packet4ui& b) {
+  return vreinterpretq_s16_u16(pcast<Packet4ui, Packet8us>(a, b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet2ui, Packet4s>(const Packet2ui& a, const Packet2ui& b) {
+  return vreinterpret_s16_u16(pcast<Packet2ui, Packet4us>(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet4ui, Packet16uc>(const Packet4ui& a, const Packet4ui& b, const Packet4ui& c,
+                                                            const Packet4ui& d) {
+  const uint16x8_t ab_u16 = vcombine_u16(vmovn_u32(a), vmovn_u32(b));
+  const uint16x8_t cd_u16 = vcombine_u16(vmovn_u32(c), vmovn_u32(d));
+  return vcombine_u8(vmovn_u16(ab_u16), vmovn_u16(cd_u16));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet2ui, Packet8uc>(const Packet2ui& a, const Packet2ui& b, const Packet2ui& c,
+                                                          const Packet2ui& d) {
+  const uint16x4_t ab_u16 = vmovn_u32(vcombine_u32(a, b));
+  const uint16x4_t cd_u16 = vmovn_u32(vcombine_u32(c, d));
+  return vmovn_u16(vcombine_u16(ab_u16, cd_u16));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet4ui, Packet16c>(const Packet4ui& a, const Packet4ui& b, const Packet4ui& c,
+                                                          const Packet4ui& d) {
+  return vreinterpretq_s8_u8(pcast<Packet4ui, Packet16uc>(a, b, c, d));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet2ui, Packet8c>(const Packet2ui& a, const Packet2ui& b, const Packet2ui& c,
+                                                        const Packet2ui& d) {
+  return vreinterpret_s8_u8(pcast<Packet2ui, Packet8uc>(a, b, c, d));
+}
+
+//==============================================================================
+// pcast, SrcType = int64_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::int64_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet2l, Packet4f>(const Packet2l& a, const Packet2l& b) {
+  return vcvtq_f32_s32(vcombine_s32(vmovn_s64(a), vmovn_s64(b)));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet2l, Packet2l>(const Packet2l& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet2l, Packet2ul>(const Packet2l& a) {
+  return vreinterpretq_u64_s64(a);
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet2l, Packet4i>(const Packet2l& a, const Packet2l& b) {
+  return vcombine_s32(vmovn_s64(a), vmovn_s64(b));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet2l, Packet4ui>(const Packet2l& a, const Packet2l& b) {
+  return vcombine_u32(vmovn_u64(vreinterpretq_u64_s64(a)), vmovn_u64(vreinterpretq_u64_s64(b)));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet2l, Packet8s>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
+                                                       const Packet2l& d) {
+  const int32x4_t ab_s32 = pcast<Packet2l, Packet4i>(a, b);
+  const int32x4_t cd_s32 = pcast<Packet2l, Packet4i>(c, d);
+  return vcombine_s16(vmovn_s32(ab_s32), vmovn_s32(cd_s32));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet2l, Packet8us>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
+                                                         const Packet2l& d) {
+  const uint32x4_t ab_u32 = pcast<Packet2l, Packet4ui>(a, b);
+  const uint32x4_t cd_u32 = pcast<Packet2l, Packet4ui>(c, d);
+  return vcombine_u16(vmovn_u32(ab_u32), vmovn_u32(cd_u32));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet2l, Packet16c>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
+                                                         const Packet2l& d, const Packet2l& e, const Packet2l& f,
+                                                         const Packet2l& g, const Packet2l& h) {
+  const int16x8_t abcd_s16 = pcast<Packet2l, Packet8s>(a, b, c, d);
+  const int16x8_t efgh_s16 = pcast<Packet2l, Packet8s>(e, f, g, h);
+  return vcombine_s8(vmovn_s16(abcd_s16), vmovn_s16(efgh_s16));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet2l, Packet16uc>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
+                                                           const Packet2l& d, const Packet2l& e, const Packet2l& f,
+                                                           const Packet2l& g, const Packet2l& h) {
+  const uint16x8_t abcd_u16 = pcast<Packet2l, Packet8us>(a, b, c, d);
+  const uint16x8_t efgh_u16 = pcast<Packet2l, Packet8us>(e, f, g, h);
+  return vcombine_u8(vmovn_u16(abcd_u16), vmovn_u16(efgh_u16));
+}
+
+//==============================================================================
+// pcast, SrcType = uint64_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::uint64_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet2ul, Packet4f>(const Packet2ul& a, const Packet2ul& b) {
+  return vcvtq_f32_u32(vcombine_u32(vmovn_u64(a), vmovn_u64(b)));
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet2ul, Packet2ul>(const Packet2ul& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet2ul, Packet2l>(const Packet2ul& a) {
+  return vreinterpretq_s64_u64(a);
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet2ul, Packet4ui>(const Packet2ul& a, const Packet2ul& b) {
+  return vcombine_u32(vmovn_u64(a), vmovn_u64(b));
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet2ul, Packet4i>(const Packet2ul& a, const Packet2ul& b) {
+  return vreinterpretq_s32_u32(pcast<Packet2ul, Packet4ui>(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet2ul, Packet8us>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
+                                                          const Packet2ul& d) {
+  const uint16x4_t ab_u16 = vmovn_u32(vcombine_u32(vmovn_u64(a), vmovn_u64(b)));
+  const uint16x4_t cd_u16 = vmovn_u32(vcombine_u32(vmovn_u64(c), vmovn_u64(d)));
+  return vcombine_u16(ab_u16, cd_u16);
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet2ul, Packet8s>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
+                                                        const Packet2ul& d) {
+  return vreinterpretq_s16_u16(pcast<Packet2ul, Packet8us>(a, b, c, d));
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet2ul, Packet16uc>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
+                                                            const Packet2ul& d, const Packet2ul& e, const Packet2ul& f,
+                                                            const Packet2ul& g, const Packet2ul& h) {
+  const uint16x8_t abcd_u16 = pcast<Packet2ul, Packet8us>(a, b, c, d);
+  const uint16x8_t efgh_u16 = pcast<Packet2ul, Packet8us>(e, f, g, h);
+  return vcombine_u8(vmovn_u16(abcd_u16), vmovn_u16(efgh_u16));
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet2ul, Packet16c>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
+                                                          const Packet2ul& d, const Packet2ul& e, const Packet2ul& f,
+                                                          const Packet2ul& g, const Packet2ul& h) {
+  return vreinterpretq_s8_u8(pcast<Packet2ul, Packet16uc>(a, b, c, d, e, f, g, h));
+}
+
+//==============================================================================
+// preinterpret
+//==============================================================================
+template <>
+EIGEN_STRONG_INLINE Packet2f preinterpret<Packet2f, Packet2i>(const Packet2i& a) {
+  return vreinterpret_f32_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f preinterpret<Packet2f, Packet2ui>(const Packet2ui& a) {
+  return vreinterpret_f32_u32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f, Packet4i>(const Packet4i& a) {
+  return vreinterpretq_f32_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f, Packet4ui>(const Packet4ui& a) {
+  return vreinterpretq_f32_u32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4c preinterpret<Packet4c, Packet4uc>(const Packet4uc& a) {
+  return static_cast<Packet4c>(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c preinterpret<Packet8c, Packet8uc>(const Packet8uc& a) {
+  return vreinterpret_s8_u8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16c preinterpret<Packet16c, Packet16uc>(const Packet16uc& a) {
+  return vreinterpretq_s8_u8(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4uc preinterpret<Packet4uc, Packet4c>(const Packet4c& a) {
+  return static_cast<Packet4uc>(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc preinterpret<Packet8uc, Packet8c>(const Packet8c& a) {
+  return vreinterpret_u8_s8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16uc preinterpret<Packet16uc, Packet16c>(const Packet16c& a) {
+  return vreinterpretq_u8_s8(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4s preinterpret<Packet4s, Packet4us>(const Packet4us& a) {
+  return vreinterpret_s16_u16(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8s preinterpret<Packet8s, Packet8us>(const Packet8us& a) {
+  return vreinterpretq_s16_u16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4us preinterpret<Packet4us, Packet4s>(const Packet4s& a) {
+  return vreinterpret_u16_s16(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8us preinterpret<Packet8us, Packet8s>(const Packet8s& a) {
+  return vreinterpretq_u16_s16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2i preinterpret<Packet2i, Packet2f>(const Packet2f& a) {
+  return vreinterpret_s32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i preinterpret<Packet2i, Packet2ui>(const Packet2ui& a) {
+  return vreinterpret_s32_u32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i, Packet4f>(const Packet4f& a) {
+  return vreinterpretq_s32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i, Packet4ui>(const Packet4ui& a) {
+  return vreinterpretq_s32_u32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2ui preinterpret<Packet2ui, Packet2f>(const Packet2f& a) {
+  return vreinterpret_u32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui preinterpret<Packet2ui, Packet2i>(const Packet2i& a) {
+  return vreinterpret_u32_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4ui preinterpret<Packet4ui, Packet4f>(const Packet4f& a) {
+  return vreinterpretq_u32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4ui preinterpret<Packet4ui, Packet4i>(const Packet4i& a) {
+  return vreinterpretq_u32_s32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2l preinterpret<Packet2l, Packet2ul>(const Packet2ul& a) {
+  return vreinterpretq_s64_u64(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ul preinterpret<Packet2ul, Packet2l>(const Packet2l& a) {
+  return vreinterpretq_u64_s64(a);
+}
+
+#if EIGEN_ARCH_ARM64
+
+//==============================================================================
+// pcast/preinterpret, Double
+//==============================================================================
+
+template <>
+struct type_casting_traits<double, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet2d, Packet2d>(const Packet2d& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<double, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet2d, Packet4f>(const Packet2d& a, const Packet2d& b) {
+  return vcombine_f32(vcvt_f32_f64(a), vcvt_f32_f64(b));
+}
+
+template <>
+struct type_casting_traits<double, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet2d, Packet2l>(const Packet2d& a) {
+  return vcvtq_s64_f64(a);
+}
+
+template <>
+struct type_casting_traits<double, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet2d, Packet2ul>(const Packet2d& a) {
+  return vcvtq_u64_f64(a);
+}
+
+template <>
+struct type_casting_traits<double, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet2d, Packet4i>(const Packet2d& a, const Packet2d& b) {
+  return vcombine_s32(vmovn_s64(vcvtq_s64_f64(a)), vmovn_s64(vcvtq_s64_f64(b)));
+}
+
+template <>
+struct type_casting_traits<double, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet2d, Packet4ui>(const Packet2d& a, const Packet2d& b) {
+  return vcombine_u32(vmovn_u64(vcvtq_u64_f64(a)), vmovn_u64(vcvtq_u64_f64(b)));
+}
+
+template <>
+struct type_casting_traits<double, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet2d, Packet8s>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
+                                                       const Packet2d& d) {
+  const int32x4_t ab_s32 = pcast<Packet2d, Packet4i>(a, b);
+  const int32x4_t cd_s32 = pcast<Packet2d, Packet4i>(c, d);
+  return vcombine_s16(vmovn_s32(ab_s32), vmovn_s32(cd_s32));
+}
+
+template <>
+struct type_casting_traits<double, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet2d, Packet8us>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
+                                                         const Packet2d& d) {
+  const uint32x4_t ab_u32 = pcast<Packet2d, Packet4ui>(a, b);
+  const uint32x4_t cd_u32 = pcast<Packet2d, Packet4ui>(c, d);
+  return vcombine_u16(vmovn_u32(ab_u32), vmovn_u32(cd_u32));
+}
+
+template <>
+struct type_casting_traits<double, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet2d, Packet16c>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
+                                                         const Packet2d& d, const Packet2d& e, const Packet2d& f,
+                                                         const Packet2d& g, const Packet2d& h) {
+  const int16x8_t abcd_s16 = pcast<Packet2d, Packet8s>(a, b, c, d);
+  const int16x8_t efgh_s16 = pcast<Packet2d, Packet8s>(e, f, g, h);
+  return vcombine_s8(vmovn_s16(abcd_s16), vmovn_s16(efgh_s16));
+}
+
+template <>
+struct type_casting_traits<double, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet2d, Packet16uc>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
+                                                           const Packet2d& d, const Packet2d& e, const Packet2d& f,
+                                                           const Packet2d& g, const Packet2d& h) {
+  const uint16x8_t abcd_u16 = pcast<Packet2d, Packet8us>(a, b, c, d);
+  const uint16x8_t efgh_u16 = pcast<Packet2d, Packet8us>(e, f, g, h);
+  return vcombine_u8(vmovn_u16(abcd_u16), vmovn_u16(efgh_u16));
+}
+
+template <>
+struct type_casting_traits<float, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet4f, Packet2d>(const Packet4f& a) {
+  // Discard second-half of input.
+  return vcvt_f64_f32(vget_low_f32(a));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet16c, Packet2d>(const Packet16c& a) {
+  // Discard all but first two values.
+  return vcvt_f64_f32(pcast<Packet8c, Packet2f>(vget_low_s8(a)));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet16uc, Packet2d>(const Packet16uc& a) {
+  // Discard all but first two values.
+  return vcvt_f64_f32(pcast<Packet8uc, Packet2f>(vget_low_u8(a)));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet8s, Packet2d>(const Packet8s& a) {
+  // Discard all but first two values.
+  return vcvt_f64_f32(pcast<Packet4s, Packet2f>(vget_low_s16(a)));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet8us, Packet2d>(const Packet8us& a) {
+  // Discard all but first two values.
+  return vcvt_f64_f32(pcast<Packet4us, Packet2f>(vget_low_u16(a)));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet4i, Packet2d>(const Packet4i& a) {
+  // Discard second half of input.
+  return vcvtq_f64_s64(vmovl_s32(vget_low_s32(a)));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet4ui, Packet2d>(const Packet4ui& a) {
+  // Discard second half of input.
+  return vcvtq_f64_u64(vmovl_u32(vget_low_u32(a)));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet2l, Packet2d>(const Packet2l& a) {
+  return vcvtq_f64_s64(a);
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet2ul, Packet2d>(const Packet2ul& a) {
+  return vcvtq_f64_u64(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d preinterpret<Packet2d, Packet2l>(const Packet2l& a) {
+  return vreinterpretq_f64_s64(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2d preinterpret<Packet2d, Packet2ul>(const Packet2ul& a) {
+  return vreinterpretq_f64_u64(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2l preinterpret<Packet2l, Packet2d>(const Packet2d& a) {
+  return vreinterpretq_s64_f64(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ul preinterpret<Packet2ul, Packet2d>(const Packet2d& a) {
+  return vreinterpretq_u64_f64(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2d preinterpret<Packet2d, Packet4i>(const Packet4i& a) {
+  return vreinterpretq_f64_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i, Packet2d>(const Packet2d& a) {
+  return vreinterpretq_s32_f64(a);
+}
+
+#endif  // EIGEN_ARCH_ARM64
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TYPE_CASTING_NEON_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/Complex.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/Complex.h
new file mode 100644
index 00000000..8fe22da4
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/Complex.h
@@ -0,0 +1,351 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_SSE_H
+#define EIGEN_COMPLEX_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- float ----------
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const __m128& a) : v(a) {}
+  Packet4f v;
+};
+
+// Use the packet_traits defined in AVX/PacketMath.h instead if we're going
+// to leverage AVX instructions.
+#ifndef EIGEN_VECTORIZE_AVX
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0,
+    HasBlend  = 1
+  };
+};
+#endif
+
+template<> struct unpacket_traits<Packet2cf> {
+  typedef std::complex<float> type;
+  typedef Packet2cf half;
+  typedef Packet4f as_real;
+  enum {
+    size=2,
+    alignment=Aligned16,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_add_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_sub_ps(a.v,b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a)
+{
+  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000));
+  return Packet2cf(_mm_xor_ps(a.v,mask));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a)
+{
+  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000));
+  return Packet2cf(_mm_xor_ps(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  #ifdef EIGEN_VECTORIZE_SSE3
+  return Packet2cf(_mm_addsub_ps(_mm_mul_ps(_mm_moveldup_ps(a.v), b.v),
+                                 _mm_mul_ps(_mm_movehdup_ps(a.v),
+                                            vec4f_swizzle1(b.v, 1, 0, 3, 2))));
+//   return Packet2cf(_mm_addsub_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v),
+//                                  _mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
+//                                             vec4f_swizzle1(b.v, 1, 0, 3, 2))));
+  #else
+  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x00000000,0x80000000,0x00000000));
+  return Packet2cf(_mm_add_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v),
+                              _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
+                                                    vec4f_swizzle1(b.v, 1, 0, 3, 2)), mask)));
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf ptrue  <Packet2cf>(const Packet2cf& a) { return Packet2cf(ptrue(Packet4f(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pand   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_and_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf por    <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_or_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_xor_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_andnot_ps(b.v,a.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pload <Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>(&numext::real_ref(*from))); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>(&numext::real_ref(*from))); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+#ifdef EIGEN_VECTORIZE_SSE3
+  res.v = _mm_castpd_ps(_mm_loaddup_pd(reinterpret_cast<double const*>(&from)));
+#else
+  res.v = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<double const*>(&from)));
+  res.v = _mm_movelh_ps(res.v, res.v);
+#endif
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from) { return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore(&numext::real_ref(*to), Packet4f(from.v)); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&numext::real_ref(*to), Packet4f(from.v)); }
+
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
+{
+  return Packet2cf(_mm_set_ps(std::imag(from[1*stride]), std::real(from[1*stride]),
+                              std::imag(from[0*stride]), std::real(from[0*stride])));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  to[stride*0] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 0)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 1)));
+  to[stride*1] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 2)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 3)));
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> *   addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet2cf>(const Packet2cf& a)
+{
+  #if EIGEN_GNUC_AT_MOST(4,3)
+  // Workaround gcc 4.2 ICE - this is not performance wise ideal, but who cares...
+  // This workaround also fix invalid code generation with gcc 4.3
+  EIGEN_ALIGN16 std::complex<float> res[2];
+  _mm_store_ps((float*)res, a.v);
+  return res[0];
+  #else
+  std::complex<float> res;
+  _mm_storel_pi((__m64*)&res, a.v);
+  return res;
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) { return Packet2cf(_mm_castpd_ps(preverse(Packet2d(_mm_castps_pd(a.v))))); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  return pfirst(Packet2cf(_mm_add_ps(a.v, _mm_movehl_ps(a.v,a.v))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  return pfirst(pmul(a, Packet2cf(_mm_movehl_ps(a.v,a.v))));
+}
+
+EIGEN_STRONG_INLINE Packet2cf pcplxflip/* <Packet2cf> */(const Packet2cf& x)
+{
+  return Packet2cf(vec4f_swizzle1(x.v, 1, 0, 3, 2));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for SSE3 and 4
+  Packet2cf res = pmul(a, pconj(b));
+  __m128 s = _mm_mul_ps(b.v,b.v);
+  return Packet2cf(_mm_div_ps(res.v,_mm_add_ps(s,vec4f_swizzle1(s, 1, 0, 3, 2))));
+}
+
+
+
+//---------- double ----------
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const __m128d& a) : v(a) {}
+  Packet2d v;
+};
+
+// Use the packet_traits defined in AVX/PacketMath.h instead if we're going
+// to leverage AVX instructions.
+#ifndef EIGEN_VECTORIZE_AVX
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+#endif
+
+template<> struct unpacket_traits<Packet1cd> {
+  typedef std::complex<double> type;
+  typedef Packet1cd half;
+  typedef Packet2d as_real;
+  enum {
+    size=1,
+    alignment=Aligned16,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_add_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_sub_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a)
+{
+  const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0));
+  return Packet1cd(_mm_xor_pd(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  #ifdef EIGEN_VECTORIZE_SSE3
+  return Packet1cd(_mm_addsub_pd(_mm_mul_pd(_mm_movedup_pd(a.v), b.v),
+                                 _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
+                                            vec2d_swizzle1(b.v, 1, 0))));
+  #else
+  const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x0,0x0,0x80000000,0x0));
+  return Packet1cd(_mm_add_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v),
+                              _mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
+                                                    vec2d_swizzle1(b.v, 1, 0)), mask)));
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd ptrue  <Packet1cd>(const Packet1cd& a) { return Packet1cd(ptrue(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pand   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_and_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd por    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_or_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pxor   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_xor_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_andnot_pd(b.v,a.v)); }
+
+// FIXME force unaligned load, this is a temporary fix
+template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>&  from)
+{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) { return pset1<Packet1cd>(*from); }
+
+// FIXME force unaligned store, this is a temporary fix
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, Packet2d(from.v)); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, Packet2d(from.v)); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> *   addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double>  pfirst<Packet1cd>(const Packet1cd& a)
+{
+  EIGEN_ALIGN16 double res[2];
+  _mm_store_pd(res, a.v);
+  return std::complex<double>(res[0],res[1]);
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for SSE3 and 4
+  Packet1cd res = pmul(a,pconj(b));
+  __m128d s = _mm_mul_pd(b.v,b.v);
+  return Packet1cd(_mm_div_pd(res.v, _mm_add_pd(s,_mm_shuffle_pd(s, s, 0x1))));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/* <Packet1cd> */(const Packet1cd& x)
+{
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2cf,2>& kernel) {
+  __m128d w1 = _mm_castps_pd(kernel.packet[0].v);
+  __m128d w2 = _mm_castps_pd(kernel.packet[1].v);
+
+  __m128 tmp = _mm_castpd_ps(_mm_unpackhi_pd(w1, w2));
+  kernel.packet[0].v = _mm_castpd_ps(_mm_unpacklo_pd(w1, w2));
+  kernel.packet[1].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b)
+{
+  __m128 eq = _mm_cmpeq_ps(a.v, b.v);
+  return Packet2cf(pand<Packet4f>(eq, vec4f_swizzle1(eq, 1, 0, 3, 2)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b)
+{
+  __m128d eq = _mm_cmpeq_pd(a.v, b.v);
+  return Packet1cd(pand<Packet2d>(eq, vec2d_swizzle1(eq, 1, 0)));
+}
+
+template<>  EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  __m128d result = pblend<Packet2d>(ifPacket, _mm_castps_pd(thenPacket.v), _mm_castps_pd(elsePacket.v));
+  return Packet2cf(_mm_castpd_ps(result));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd psqrt<Packet1cd>(const Packet1cd& a) {
+  return psqrt_complex<Packet1cd>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf psqrt<Packet2cf>(const Packet2cf& a) {
+  return psqrt_complex<Packet2cf>(a);
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_SSE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/MathFunctions.h
new file mode 100644
index 00000000..8736d0d6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/MathFunctions.h
@@ -0,0 +1,199 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The sin and cos and functions of this file come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+#ifndef EIGEN_MATH_FUNCTIONS_SSE_H
+#define EIGEN_MATH_FUNCTIONS_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f plog<Packet4f>(const Packet4f& _x) {
+  return plog_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d plog<Packet2d>(const Packet2d& _x) {
+  return plog_double(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f plog2<Packet4f>(const Packet4f& _x) {
+  return plog2_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d plog2<Packet2d>(const Packet2d& _x) {
+  return plog2_double(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f plog1p<Packet4f>(const Packet4f& _x) {
+  return generic_plog1p(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexpm1<Packet4f>(const Packet4f& _x) {
+  return generic_expm1(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexp<Packet4f>(const Packet4f& _x)
+{
+  return pexp_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d pexp<Packet2d>(const Packet2d& x)
+{
+  return pexp_double(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psin<Packet4f>(const Packet4f& _x)
+{
+  return psin_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pcos<Packet4f>(const Packet4f& _x)
+{
+  return pcos_float(_x);
+}
+
+#if EIGEN_FAST_MATH
+
+// Functions for sqrt.
+// The EIGEN_FAST_MATH version uses the _mm_rsqrt_ps approximation and one step
+// of Newton's method, at a cost of 1-2 bits of precision as opposed to the
+// exact solution. It does not handle +inf, or denormalized numbers correctly.
+// The main advantage of this approach is not just speed, but also the fact that
+// it can be inlined and pipelined with other computations, further reducing its
+// effective latency. This is similar to Quake3's fast inverse square root.
+// For detail see here: http://www.beyond3d.com/content/articles/8/
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& _x)
+{
+  Packet4f minus_half_x = pmul(_x, pset1<Packet4f>(-0.5f));
+  Packet4f denormal_mask = pandnot(
+      pcmp_lt(_x, pset1<Packet4f>((std::numeric_limits<float>::min)())),
+      pcmp_lt(_x, pzero(_x)));
+
+  // Compute approximate reciprocal sqrt.
+  Packet4f x = _mm_rsqrt_ps(_x);
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(minus_half_x, pmul(x,x), pset1<Packet4f>(1.5f)));
+  // Flush results for denormals to zero.
+  return pandnot(pmul(_x,x), denormal_mask);
+}
+
+#else
+
+template<>EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& x) { return _mm_sqrt_ps(x); }
+
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d psqrt<Packet2d>(const Packet2d& x) { return _mm_sqrt_pd(x); }
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet16b psqrt<Packet16b>(const Packet16b& x) { return x; }
+
+#if EIGEN_FAST_MATH
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& _x) {
+  _EIGEN_DECLARE_CONST_Packet4f(one_point_five, 1.5f);
+  _EIGEN_DECLARE_CONST_Packet4f(minus_half, -0.5f);
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(inf, 0x7f800000u);
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(flt_min, 0x00800000u);
+
+  Packet4f neg_half = pmul(_x, p4f_minus_half);
+
+  // Identity infinite, zero, negative and denormal arguments.
+  Packet4f lt_min_mask = _mm_cmplt_ps(_x, p4f_flt_min);
+  Packet4f inf_mask = _mm_cmpeq_ps(_x, p4f_inf);
+  Packet4f not_normal_finite_mask = _mm_or_ps(lt_min_mask, inf_mask);
+
+  // Compute an approximate result using the rsqrt intrinsic.
+  Packet4f y_approx = _mm_rsqrt_ps(_x);
+
+  // Do a single step of Newton-Raphson iteration to improve the approximation.
+  // This uses the formula y_{n+1} = y_n * (1.5 - y_n * (0.5 * x) * y_n).
+  // It is essential to evaluate the inner term like this because forming
+  // y_n^2 may over- or underflow.
+  Packet4f y_newton = pmul(
+      y_approx, pmadd(y_approx, pmul(neg_half, y_approx), p4f_one_point_five));
+
+  // Select the result of the Newton-Raphson step for positive normal arguments.
+  // For other arguments, choose the output of the intrinsic. This will
+  // return rsqrt(+inf) = 0, rsqrt(x) = NaN if x < 0, and rsqrt(x) = +inf if
+  // x is zero or a positive denormalized float (equivalent to flushing positive
+  // denormalized inputs to zero).
+  return pselect<Packet4f>(not_normal_finite_mask, y_approx, y_newton);
+}
+
+#else
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& x) {
+  // Unfortunately we can't use the much faster mm_rsqrt_ps since it only provides an approximation.
+  return _mm_div_ps(pset1<Packet4f>(1.0f), _mm_sqrt_ps(x));
+}
+
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d prsqrt<Packet2d>(const Packet2d& x) {
+  return _mm_div_pd(pset1<Packet2d>(1.0), _mm_sqrt_pd(x));
+}
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+ptanh<Packet4f>(const Packet4f& x) {
+  return internal::generic_fast_tanh_float(x);
+}
+
+} // end namespace internal
+
+namespace numext {
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float sqrt(const float &x)
+{
+  return internal::pfirst(internal::Packet4f(_mm_sqrt_ss(_mm_set_ss(x))));
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double sqrt(const double &x)
+{
+#if EIGEN_COMP_GNUC_STRICT
+  // This works around a GCC bug generating poor code for _mm_sqrt_pd
+  // See https://gitlab.com/libeigen/eigen/commit/8dca9f97e38970
+  return internal::pfirst(internal::Packet2d(__builtin_ia32_sqrtsd(_mm_set_sd(x))));
+#else
+  return internal::pfirst(internal::Packet2d(_mm_sqrt_pd(_mm_set_sd(x))));
+#endif
+}
+
+} // end namespace numex
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATH_FUNCTIONS_SSE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/PacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/PacketMath.h
new file mode 100644
index 00000000..db102c73
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/PacketMath.h
@@ -0,0 +1,1505 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_SSE_H
+#define EIGEN_PACKET_MATH_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#if !defined(EIGEN_VECTORIZE_AVX) && !defined(EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS)
+// 32 bits =>  8 registers
+// 64 bits => 16 registers
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS (2*sizeof(void*))
+#endif
+
+#ifdef EIGEN_VECTORIZE_FMA
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+#endif
+
+#if ((defined EIGEN_VECTORIZE_AVX) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_MINGW) && (__GXX_ABI_VERSION < 1004)) || EIGEN_OS_QNX
+// With GCC's default ABI version, a __m128 or __m256 are the same types and therefore we cannot
+// have overloads for both types without linking error.
+// One solution is to increase ABI version using -fabi-version=4 (or greater).
+// Otherwise, we workaround this inconvenience by wrapping 128bit types into the following helper
+// structure:
+typedef eigen_packet_wrapper<__m128>  Packet4f;
+typedef eigen_packet_wrapper<__m128d> Packet2d;
+#else
+typedef __m128  Packet4f;
+typedef __m128d Packet2d;
+#endif
+
+typedef eigen_packet_wrapper<__m128i, 0> Packet4i;
+typedef eigen_packet_wrapper<__m128i, 1> Packet16b;
+
+template<> struct is_arithmetic<__m128>  { enum { value = true }; };
+template<> struct is_arithmetic<__m128i> { enum { value = true }; };
+template<> struct is_arithmetic<__m128d> { enum { value = true }; };
+template<> struct is_arithmetic<Packet4i>  { enum { value = true }; };
+template<> struct is_arithmetic<Packet16b>  { enum { value = true }; };
+
+template<int p, int q, int r, int s>
+struct shuffle_mask{
+ enum { mask = (s)<<6|(r)<<4|(q)<<2|(p) };
+};
+
+// TODO: change the implementation of all swizzle* ops from macro to template,
+#define vec4f_swizzle1(v,p,q,r,s) \
+  Packet4f(_mm_castsi128_ps(_mm_shuffle_epi32( _mm_castps_si128(v), (shuffle_mask<p,q,r,s>::mask))))
+
+#define vec4i_swizzle1(v,p,q,r,s) \
+  Packet4i(_mm_shuffle_epi32( v, (shuffle_mask<p,q,r,s>::mask)))
+
+#define vec2d_swizzle1(v,p,q) \
+  Packet2d(_mm_castsi128_pd(_mm_shuffle_epi32( _mm_castpd_si128(v), (shuffle_mask<2*p,2*p+1,2*q,2*q+1>::mask))))
+
+#define vec4f_swizzle2(a,b,p,q,r,s) \
+  Packet4f(_mm_shuffle_ps( (a), (b), (shuffle_mask<p,q,r,s>::mask)))
+
+#define vec4i_swizzle2(a,b,p,q,r,s) \
+  Packet4i(_mm_castps_si128( (_mm_shuffle_ps( _mm_castsi128_ps(a), _mm_castsi128_ps(b), (shuffle_mask<p,q,r,s>::mask)))))
+
+EIGEN_STRONG_INLINE Packet4f vec4f_movelh(const Packet4f& a, const Packet4f& b)
+{
+  return Packet4f(_mm_movelh_ps(a,b));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_movehl(const Packet4f& a, const Packet4f& b)
+{
+  return Packet4f(_mm_movehl_ps(a,b));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_unpacklo(const Packet4f& a, const Packet4f& b)
+{
+  return Packet4f(_mm_unpacklo_ps(a,b));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_unpackhi(const Packet4f& a, const Packet4f& b)
+{
+  return Packet4f(_mm_unpackhi_ps(a,b));
+}
+#define vec4f_duplane(a,p) \
+  vec4f_swizzle2(a,a,p,p,p,p)
+
+#define vec2d_swizzle2(a,b,mask) \
+  Packet2d(_mm_shuffle_pd(a,b,mask))
+
+EIGEN_STRONG_INLINE Packet2d vec2d_unpacklo(const Packet2d& a, const Packet2d& b)
+{
+  return Packet2d(_mm_unpacklo_pd(a,b));
+}
+EIGEN_STRONG_INLINE Packet2d vec2d_unpackhi(const Packet2d& a, const Packet2d& b)
+{
+  return Packet2d(_mm_unpackhi_pd(a,b));
+}
+#define vec2d_duplane(a,p) \
+  vec2d_swizzle2(a,a,(p<<1)|p)
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  const Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME,X) \
+  const Packet2d p2d_##NAME = pset1<Packet2d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = pset1frombits<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  const Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+
+// Use the packet_traits defined in AVX/PacketMath.h instead if we're going
+// to leverage AVX instructions.
+#ifndef EIGEN_VECTORIZE_AVX
+template <>
+struct packet_traits<float> : default_packet_traits {
+  typedef Packet4f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasCmp  = 1,
+    HasDiv = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasLog1p = 1,
+    HasExpm1 = 1,
+    HasNdtri = 1,
+    HasExp = 1,
+    HasBessel = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+    HasBlend = 1,
+    HasCeil = 1,
+    HasFloor = 1,
+#ifdef EIGEN_VECTORIZE_SSE4_1
+    HasRound = 1,
+#endif
+    HasRint = 1
+  };
+};
+template <>
+struct packet_traits<double> : default_packet_traits {
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 0,
+
+    HasCmp  = 1,
+    HasDiv  = 1,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasBlend = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+#ifdef EIGEN_VECTORIZE_SSE4_1
+    HasRound = 1,
+#endif
+    HasRint = 1
+  };
+};
+#endif
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet4i type;
+  typedef Packet4i half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+
+    HasShift = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct packet_traits<bool> : default_packet_traits
+{
+  typedef Packet16b type;
+  typedef Packet16b half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    HasHalfPacket = 0,
+    size=16,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 0,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 0,
+    HasAbs2      = 0,
+    HasMin       = 0,
+    HasMax       = 0,
+    HasConj      = 0,
+    HasSqrt      = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet4f> {
+  typedef float     type;
+  typedef Packet4f  half;
+  typedef Packet4i  integer_packet;
+  enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet2d> {
+  typedef double    type;
+  typedef Packet2d  half;
+  enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet4i> {
+  typedef int       type;
+  typedef Packet4i  half;
+  enum {size=4, alignment=Aligned16, vectorizable=false, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet16b> {
+  typedef bool       type;
+  typedef Packet16b  half;
+  enum {size=16, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+
+#ifndef EIGEN_VECTORIZE_AVX
+template<> struct scalar_div_cost<float,true> { enum { value = 7 }; };
+template<> struct scalar_div_cost<double,true> { enum { value = 8 }; };
+#endif
+
+#if EIGEN_COMP_MSVC==1500
+// Workaround MSVC 9 internal compiler error.
+// TODO: It has been detected with win64 builds (amd64), so let's check whether it also happens in 32bits+SSE mode
+// TODO: let's check whether there does not exist a better fix, like adding a pset0() function. (it crashed on pset1(0)).
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) { return _mm_set_ps(from,from,from,from); }
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set_pd(from,from); }
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from) { return _mm_set_epi32(from,from,from,from); }
+#else
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) { return _mm_set_ps1(from); }
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set1_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from) { return _mm_set1_epi32(from); }
+#endif
+template<> EIGEN_STRONG_INLINE Packet16b pset1<Packet16b>(const bool&    from) { return _mm_set1_epi8(static_cast<char>(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1frombits<Packet4f>(unsigned int from) { return _mm_castsi128_ps(pset1<Packet4i>(from)); }
+template<> EIGEN_STRONG_INLINE Packet2d pset1frombits<Packet2d>(uint64_t from) { return _mm_castsi128_pd(_mm_set1_epi64x(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f peven_mask(const Packet4f& /*a*/) { return _mm_castsi128_ps(_mm_set_epi32(0, -1, 0, -1)); }
+template<> EIGEN_STRONG_INLINE Packet4i peven_mask(const Packet4i& /*a*/) { return _mm_set_epi32(0, -1, 0, -1); }
+template<> EIGEN_STRONG_INLINE Packet2d peven_mask(const Packet2d& /*a*/) { return _mm_castsi128_pd(_mm_set_epi32(0, 0, -1, -1)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pzero(const Packet4f& /*a*/) { return _mm_setzero_ps(); }
+template<> EIGEN_STRONG_INLINE Packet2d pzero(const Packet2d& /*a*/) { return _mm_setzero_pd(); }
+template<> EIGEN_STRONG_INLINE Packet4i pzero(const Packet4i& /*a*/) { return _mm_setzero_si128(); }
+
+// GCC generates a shufps instruction for _mm_set1_ps/_mm_load1_ps instead of the more efficient pshufd instruction.
+// However, using inrinsics for pset1 makes gcc to generate crappy code in some cases (see bug 203)
+// Using inline assembly is also not an option because then gcc fails to reorder properly the instructions.
+// Therefore, we introduced the pload1 functions to be used in product kernels for which bug 203 does not apply.
+// Also note that with AVX, we want it to generate a vbroadcastss.
+#if EIGEN_COMP_GNUC_STRICT && (!defined __AVX__)
+template<> EIGEN_STRONG_INLINE Packet4f pload1<Packet4f>(const float *from) {
+  return vec4f_swizzle1(_mm_load_ss(from),0,0,0,0);
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a) { return _mm_add_ps(pset1<Packet4f>(a), _mm_set_ps(3,2,1,0)); }
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) { return _mm_add_pd(pset1<Packet2d>(a),_mm_set_pd(1,0)); }
+template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int& a) { return _mm_add_epi32(pset1<Packet4i>(a),_mm_set_epi32(3,2,1,0)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_add_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_add_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_add_epi32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet16b padd<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_or_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_sub_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_sub_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_sub_epi32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16b psub<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_xor_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b);
+template<> EIGEN_STRONG_INLINE Packet4f paddsub<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE3
+  return _mm_addsub_ps(a,b);
+#else
+  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x0,0x80000000,0x0));
+  return padd(a, pxor(mask, b));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& , const Packet2d& );
+template<> EIGEN_STRONG_INLINE Packet2d paddsub<Packet2d>(const Packet2d& a, const Packet2d& b) 
+{
+#ifdef EIGEN_VECTORIZE_SSE3  
+  return _mm_addsub_pd(a,b); 
+#else
+  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x80000000,0x0,0x0)); 
+  return padd(a, pxor(mask, b));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a)
+{
+  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000));
+  return _mm_xor_ps(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a)
+{
+  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x80000000,0x0,0x80000000));
+  return _mm_xor_pd(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a)
+{
+  return psub(Packet4i(_mm_setr_epi32(0,0,0,0)), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16b pnegate(const Packet16b& a)
+{
+  return psub(pset1<Packet16b>(false), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_mul_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_mul_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_mullo_epi32(a,b);
+#else
+  // this version is slightly faster than 4 scalar products
+  return vec4i_swizzle1(
+            vec4i_swizzle2(
+              _mm_mul_epu32(a,b),
+              _mm_mul_epu32(vec4i_swizzle1(a,1,0,3,2),
+                            vec4i_swizzle1(b,1,0,3,2)),
+              0,2,0,2),
+            0,2,1,3);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet16b pmul<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_and_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_div_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_div_pd(a,b); }
+
+// for some weird raisons, it has to be overloaded for packet of integers
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd(pmul(a,b), c); }
+#ifdef EIGEN_VECTORIZE_FMA
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) { return _mm_fmadd_ps(a,b,c); }
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return _mm_fmadd_pd(a,b,c); }
+#endif
+
+#ifdef EIGEN_VECTORIZE_SSE4_1
+template<> EIGEN_DEVICE_FUNC inline Packet4f pselect(const Packet4f& mask, const Packet4f& a, const Packet4f& b) {
+  return _mm_blendv_ps(b,a,mask);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4i pselect(const Packet4i& mask, const Packet4i& a, const Packet4i& b) {
+  return _mm_castps_si128(_mm_blendv_ps(_mm_castsi128_ps(b),_mm_castsi128_ps(a),_mm_castsi128_ps(mask)));
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet2d pselect(const Packet2d& mask, const Packet2d& a, const Packet2d& b) {  return _mm_blendv_pd(b,a,mask); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet16b pselect(const Packet16b& mask, const Packet16b& a, const Packet16b& b) {
+  return _mm_blendv_epi8(b,a,mask);
+}
+#else
+template<> EIGEN_DEVICE_FUNC inline Packet16b pselect(const Packet16b& mask, const Packet16b& a, const Packet16b& b) {
+  Packet16b a_part = _mm_and_si128(mask, a);
+  Packet16b b_part = _mm_andnot_si128(mask, b);
+  return _mm_or_si128(a_part, b_part);
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4i ptrue<Packet4i>(const Packet4i& a) { return _mm_cmpeq_epi32(a, a); }
+template<> EIGEN_STRONG_INLINE Packet16b ptrue<Packet16b>(const Packet16b& a) { return _mm_cmpeq_epi8(a, a); }
+template<> EIGEN_STRONG_INLINE Packet4f
+ptrue<Packet4f>(const Packet4f& a) {
+  Packet4i b = _mm_castps_si128(a);
+  return _mm_castsi128_ps(_mm_cmpeq_epi32(b, b));
+}
+template<> EIGEN_STRONG_INLINE Packet2d
+ptrue<Packet2d>(const Packet2d& a) {
+  Packet4i b = _mm_castpd_si128(a);
+  return _mm_castsi128_pd(_mm_cmpeq_epi32(b, b));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_and_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_and_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_and_si128(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16b pand<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_and_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_or_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_or_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_or_si128(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16b por<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_or_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_xor_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_xor_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_xor_si128(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16b pxor<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_xor_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_andnot_ps(b,a); }
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_andnot_pd(b,a); }
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_andnot_si128(b,a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_le(const Packet4f& a, const Packet4f& b) { return _mm_cmple_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt(const Packet4f& a, const Packet4f& b) { return _mm_cmplt_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan(const Packet4f& a, const Packet4f& b) { return _mm_cmpnge_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_eq(const Packet4f& a, const Packet4f& b) { return _mm_cmpeq_ps(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_le(const Packet2d& a, const Packet2d& b) { return _mm_cmple_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt(const Packet2d& a, const Packet2d& b) { return _mm_cmplt_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan(const Packet2d& a, const Packet2d& b) { return _mm_cmpnge_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_eq(const Packet2d& a, const Packet2d& b) { return _mm_cmpeq_pd(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_lt(const Packet4i& a, const Packet4i& b) { return _mm_cmplt_epi32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_eq(const Packet4i& a, const Packet4i& b) { return _mm_cmpeq_epi32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16b pcmp_eq(const Packet16b& a, const Packet16b& b) { return _mm_cmpeq_epi8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_le(const Packet4i& a, const Packet4i& b) { return por(pcmp_lt(a,b), pcmp_eq(a,b)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_min_ps, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  #ifdef EIGEN_VECTORIZE_AVX
+  Packet4f res;
+  asm("vminps %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  #else
+  Packet4f res = b;
+  asm("minps %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  #endif
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm_min_ps(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_min_pd, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  #ifdef EIGEN_VECTORIZE_AVX
+  Packet2d res;
+  asm("vminpd %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  #else
+  Packet2d res = b;
+  asm("minpd %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  #endif
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm_min_pd(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_min_epi32(a,b);
+#else
+  // after some bench, this version *is* faster than a scalar implementation
+  Packet4i mask = _mm_cmplt_epi32(a,b);
+  return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b));
+#endif
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_max_ps, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  #ifdef EIGEN_VECTORIZE_AVX
+  Packet4f res;
+  asm("vmaxps %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  #else
+  Packet4f res = b;
+  asm("maxps %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  #endif
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm_max_ps(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_max_pd, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  #ifdef EIGEN_VECTORIZE_AVX
+  Packet2d res;
+  asm("vmaxpd %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  #else
+  Packet2d res = b;
+  asm("maxpd %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  #endif
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm_max_pd(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_max_epi32(a,b);
+#else
+  // after some bench, this version *is* faster than a scalar implementation
+  Packet4i mask = _mm_cmpgt_epi32(a,b);
+  return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b));
+#endif
+}
+
+template <typename Packet, typename Op>
+EIGEN_STRONG_INLINE Packet pminmax_propagate_numbers(const Packet& a, const Packet& b, Op op) {
+  // In this implementation, we take advantage of the fact that pmin/pmax for SSE
+  // always return a if either a or b is NaN.
+  Packet not_nan_mask_a = pcmp_eq(a, a);
+  Packet m = op(a, b);
+  return pselect<Packet>(not_nan_mask_a, m, b);
+}
+
+template <typename Packet, typename Op>
+EIGEN_STRONG_INLINE Packet pminmax_propagate_nan(const Packet& a, const Packet& b, Op op) {
+  // In this implementation, we take advantage of the fact that pmin/pmax for SSE
+  // always return a if either a or b is NaN.
+  Packet not_nan_mask_a = pcmp_eq(a, a);
+  Packet m = op(b, a);
+  return pselect<Packet>(not_nan_mask_a, m, a);
+}
+
+// Add specializations for min/max with prescribed NaN progation.
+template<>
+EIGEN_STRONG_INLINE Packet4f pmin<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet4f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet2d pmin<PropagateNumbers, Packet2d>(const Packet2d& a, const Packet2d& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet2d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4f pmax<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet4f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet2d pmax<PropagateNumbers, Packet2d>(const Packet2d& a, const Packet2d& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet2d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4f pmin<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet4f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet2d pmin<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet2d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4f pmax<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet4f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet2d pmax<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet2d>);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(const Packet4i& a) { return _mm_srai_epi32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_right   (const Packet4i& a) { return _mm_srli_epi32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_left    (const Packet4i& a) { return _mm_slli_epi32(a,N); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a)
+{
+  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF));
+  return _mm_and_ps(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a)
+{
+  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF));
+  return _mm_and_pd(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a)
+{
+  #ifdef EIGEN_VECTORIZE_SSSE3
+  return _mm_abs_epi32(a);
+  #else
+  Packet4i aux = _mm_srai_epi32(a,31);
+  return _mm_sub_epi32(_mm_xor_si128(a,aux),aux);
+  #endif
+}
+
+#ifdef EIGEN_VECTORIZE_SSE4_1
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a)
+{
+  // Unfortunatly _mm_round_ps doesn't have a rounding mode to implement numext::round.
+  const Packet4f mask = pset1frombits<Packet4f>(0x80000000u);
+  const Packet4f prev0dot5 = pset1frombits<Packet4f>(0x3EFFFFFFu);
+  return _mm_round_ps(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a)
+{
+  const Packet2d mask = _mm_castsi128_pd(_mm_set_epi64x(0x8000000000000000ull, 0x8000000000000000ull));
+  const Packet2d prev0dot5 = _mm_castsi128_pd(_mm_set_epi64x(0x3FDFFFFFFFFFFFFFull, 0x3FDFFFFFFFFFFFFFull));
+  return _mm_round_pd(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f print<Packet4f>(const Packet4f& a) { return _mm_round_ps(a, _MM_FROUND_CUR_DIRECTION); }
+template<> EIGEN_STRONG_INLINE Packet2d print<Packet2d>(const Packet2d& a) { return _mm_round_pd(a, _MM_FROUND_CUR_DIRECTION); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a) { return _mm_ceil_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a) { return _mm_ceil_pd(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a) { return _mm_floor_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) { return _mm_floor_pd(a); }
+#else
+template<> EIGEN_STRONG_INLINE Packet4f print(const Packet4f& a) {
+  // Adds and subtracts signum(a) * 2^23 to force rounding.
+  const Packet4f limit = pset1<Packet4f>(static_cast<float>(1<<23));
+  const Packet4f abs_a = pabs(a);
+  Packet4f r = padd(abs_a, limit);
+  // Don't compile-away addition and subtraction.
+  EIGEN_OPTIMIZATION_BARRIER(r);
+  r = psub(r, limit);
+  // If greater than limit, simply return a.  Otherwise, account for sign.
+  r = pselect(pcmp_lt(abs_a, limit),
+              pselect(pcmp_lt(a, pzero(a)), pnegate(r), r), a);
+  return r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d print(const Packet2d& a) {
+  // Adds and subtracts signum(a) * 2^52 to force rounding.
+  const Packet2d limit = pset1<Packet2d>(static_cast<double>(1ull<<52));
+  const Packet2d abs_a = pabs(a);
+  Packet2d r = padd(abs_a, limit);
+  // Don't compile-away addition and subtraction.
+  EIGEN_OPTIMIZATION_BARRIER(r);
+  r = psub(r, limit);
+  // If greater than limit, simply return a.  Otherwise, account for sign.
+  r = pselect(pcmp_lt(abs_a, limit),
+              pselect(pcmp_lt(a, pzero(a)), pnegate(r), r), a);
+  return r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a)
+{
+  const Packet4f cst_1 = pset1<Packet4f>(1.0f);
+  Packet4f tmp  = print<Packet4f>(a);
+  // If greater, subtract one.
+  Packet4f mask = _mm_cmpgt_ps(tmp, a);
+  mask = pand(mask, cst_1);
+  return psub(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a)
+{
+  const Packet2d cst_1 = pset1<Packet2d>(1.0);
+  Packet2d tmp  = print<Packet2d>(a);
+  // If greater, subtract one.
+  Packet2d mask = _mm_cmpgt_pd(tmp, a);
+  mask = pand(mask, cst_1);
+  return psub(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a)
+{
+  const Packet4f cst_1 = pset1<Packet4f>(1.0f);
+  Packet4f tmp  = print<Packet4f>(a);
+  // If smaller, add one.
+  Packet4f mask = _mm_cmplt_ps(tmp, a);
+  mask = pand(mask, cst_1);
+  return padd(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a)
+{
+  const Packet2d cst_1 = pset1<Packet2d>(1.0);
+  Packet2d tmp  = print<Packet2d>(a);
+  // If smaller, add one.
+  Packet2d mask = _mm_cmplt_pd(tmp, a);
+  mask = pand(mask, cst_1);
+  return padd(tmp, mask);
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float*   from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double*  from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int*     from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast<const __m128i*>(from)); }
+template<> EIGEN_STRONG_INLINE Packet16b pload<Packet16b>(const bool*     from) { EIGEN_DEBUG_ALIGNED_LOAD return  _mm_load_si128(reinterpret_cast<const __m128i*>(from)); }
+
+#if EIGEN_COMP_MSVC
+  template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float*  from) {
+    EIGEN_DEBUG_UNALIGNED_LOAD
+    #if (EIGEN_COMP_MSVC==1600)
+    // NOTE Some version of MSVC10 generates bad code when using _mm_loadu_ps
+    // (i.e., it does not generate an unaligned load!!
+    __m128 res = _mm_loadl_pi(_mm_set1_ps(0.0f), (const __m64*)(from));
+    res = _mm_loadh_pi(res, (const __m64*)(from+2));
+    return res;
+    #else
+    return _mm_loadu_ps(from);
+    #endif
+  }
+#else
+// NOTE: with the code below, MSVC's compiler crashes!
+
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_ps(from);
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_pd(from);
+}
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+}
+template<> EIGEN_STRONG_INLINE Packet16b ploadu<Packet16b>(const bool*     from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float*   from)
+{
+  return vec4f_swizzle1(_mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(from))), 0, 0, 1, 1);
+}
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double*  from)
+{ return pset1<Packet2d>(from[0]); }
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int*     from)
+{
+  Packet4i tmp;
+  tmp = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(from));
+  return vec4i_swizzle1(tmp, 0, 0, 1, 1);
+}
+
+// Loads 8 bools from memory and returns the packet
+// {b0, b0, b1, b1, b2, b2, b3, b3, b4, b4, b5, b5, b6, b6, b7, b7}
+template<> EIGEN_STRONG_INLINE Packet16b ploaddup<Packet16b>(const bool*     from)
+{
+  __m128i tmp = _mm_castpd_si128(pload1<Packet2d>(reinterpret_cast<const double*>(from)));
+  return  _mm_unpacklo_epi8(tmp, tmp);
+}
+
+// Loads 4 bools from memory and returns the packet
+// {b0, b0  b0, b0, b1, b1, b1, b1, b2, b2, b2, b2, b3, b3, b3, b3}
+template<> EIGEN_STRONG_INLINE Packet16b
+ploadquad<Packet16b>(const bool* from) {
+  __m128i tmp = _mm_castps_si128(pload1<Packet4f>(reinterpret_cast<const float*>(from)));
+  tmp = _mm_unpacklo_epi8(tmp, tmp);
+  return  _mm_unpacklo_epi16(tmp, tmp);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet2d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast<__m128i*>(to), from); }
+template<> EIGEN_STRONG_INLINE void pstore<bool>(bool*     to, const Packet16b& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast<__m128i*>(to), from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet2d& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*   to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*       to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<bool>(bool*     to, const Packet16b& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+ return _mm_set_ps(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+ return _mm_set_pd(from[1*stride], from[0*stride]);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int, Packet4i>(const int* from, Index stride)
+{
+ return _mm_set_epi32(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet16b pgather<bool, Packet16b>(const bool* from, Index stride)
+{
+  return _mm_set_epi8(from[15*stride], from[14*stride], from[13*stride], from[12*stride],
+                      from[11*stride], from[10*stride], from[9*stride], from[8*stride],
+                      from[7*stride], from[6*stride], from[5*stride], from[4*stride],
+                      from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  to[stride*0] = _mm_cvtss_f32(from);
+  to[stride*1] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 1));
+  to[stride*2] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 2));
+  to[stride*3] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 3));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  to[stride*0] = _mm_cvtsd_f64(from);
+  to[stride*1] = _mm_cvtsd_f64(_mm_shuffle_pd(from, from, 1));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<int, Packet4i>(int* to, const Packet4i& from, Index stride)
+{
+  to[stride*0] = _mm_cvtsi128_si32(from);
+  to[stride*1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 1));
+  to[stride*2] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 2));
+  to[stride*3] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 3));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<bool, Packet16b>(bool* to, const Packet16b& from, Index stride)
+{
+  to[4*stride*0] = _mm_cvtsi128_si32(from);
+  to[4*stride*1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 1));
+  to[4*stride*2] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 2));
+  to[4*stride*3] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 3));
+}
+
+
+// some compilers might be tempted to perform multiple moves instead of using a vector path.
+template<> EIGEN_STRONG_INLINE void pstore1<Packet4f>(float* to, const float& a)
+{
+  Packet4f pa = _mm_set_ss(a);
+  pstore(to, Packet4f(vec4f_swizzle1(pa,0,0,0,0)));
+}
+// some compilers might be tempted to perform multiple moves instead of using a vector path.
+template<> EIGEN_STRONG_INLINE void pstore1<Packet2d>(double* to, const double& a)
+{
+  Packet2d pa = _mm_set_sd(a);
+  pstore(to, Packet2d(vec2d_swizzle1(pa,0,0)));
+}
+
+#if EIGEN_COMP_PGI && EIGEN_COMP_PGI < 1900
+typedef const void * SsePrefetchPtrType;
+#else
+typedef const char * SsePrefetchPtrType;
+#endif
+
+#ifndef EIGEN_VECTORIZE_AVX
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+#endif
+
+#if EIGEN_COMP_MSVC_STRICT && EIGEN_OS_WIN64
+// The temporary variable fixes an internal compilation error in vs <= 2008 and a wrong-result bug in vs 2010
+// Direct of the struct members fixed bug #62.
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { return a.m128_f32[0]; }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return a.m128d_f64[0]; }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; }
+#elif EIGEN_COMP_MSVC_STRICT
+// The temporary variable fixes an internal compilation error in vs <= 2008 and a wrong-result bug in vs 2010
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { float x = _mm_cvtss_f32(a); return x; }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { double x = _mm_cvtsd_f64(a); return x; }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; }
+#else
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { return _mm_cvtss_f32(a); }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return _mm_cvtsd_f64(a); }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { return _mm_cvtsi128_si32(a); }
+#endif
+template<> EIGEN_STRONG_INLINE bool   pfirst<Packet16b>(const Packet16b& a) { int x = _mm_cvtsi128_si32(a); return static_cast<bool>(x & 1); }
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a) { return _mm_shuffle_ps(a,a,0x1B); }
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a) { return _mm_shuffle_pd(a,a,0x1); }
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a) { return _mm_shuffle_epi32(a,0x1B); }
+template<> EIGEN_STRONG_INLINE Packet16b preverse(const Packet16b& a) {
+#ifdef EIGEN_VECTORIZE_SSSE3
+  __m128i mask = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  return _mm_shuffle_epi8(a, mask);
+#else
+  Packet16b tmp = _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3));
+  tmp = _mm_shufflehi_epi16(_mm_shufflelo_epi16(tmp, _MM_SHUFFLE(2, 3, 0, 1)), _MM_SHUFFLE(2, 3, 0, 1));
+  return _mm_or_si128(_mm_slli_epi16(tmp, 8), _mm_srli_epi16(tmp, 8));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pfrexp<Packet4f>(const Packet4f& a, Packet4f& exponent) {
+  return pfrexp_generic(a,exponent);
+}
+
+// Extract exponent without existence of Packet2l.
+template<>
+EIGEN_STRONG_INLINE  
+Packet2d pfrexp_generic_get_biased_exponent(const Packet2d& a) {
+  const Packet2d cst_exp_mask  = pset1frombits<Packet2d>(static_cast<uint64_t>(0x7ff0000000000000ull));
+  __m128i a_expo = _mm_srli_epi64(_mm_castpd_si128(pand(a, cst_exp_mask)), 52);
+  return _mm_cvtepi32_pd(vec4i_swizzle1(a_expo, 0, 2, 1, 3));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pfrexp<Packet2d>(const Packet2d& a, Packet2d& exponent) {
+  return pfrexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pldexp<Packet4f>(const Packet4f& a, const Packet4f& exponent) {
+  return pldexp_generic(a,exponent);
+}
+
+// We specialize pldexp here, since the generic implementation uses Packet2l, which is not well
+// supported by SSE, and has more range than is needed for exponents.
+template<> EIGEN_STRONG_INLINE Packet2d pldexp<Packet2d>(const Packet2d& a, const Packet2d& exponent) {
+  // Clamp exponent to [-2099, 2099]
+  const Packet2d max_exponent = pset1<Packet2d>(2099.0);
+  const Packet2d e = pmin(pmax(exponent, pnegate(max_exponent)), max_exponent);
+  
+  // Convert e to integer and swizzle to low-order bits.
+  const Packet4i ei = vec4i_swizzle1(_mm_cvtpd_epi32(e), 0, 3, 1, 3);
+  
+  // Split 2^e into four factors and multiply:
+  const Packet4i bias = _mm_set_epi32(0, 1023, 0, 1023);
+  Packet4i b = parithmetic_shift_right<2>(ei);  // floor(e/4)
+  Packet2d c = _mm_castsi128_pd(_mm_slli_epi64(padd(b, bias), 52));  // 2^b
+  Packet2d out = pmul(pmul(pmul(a, c), c), c); // a * 2^(3b)
+  b = psub(psub(psub(ei, b), b), b);  // e - 3b
+  c = _mm_castsi128_pd(_mm_slli_epi64(padd(b, bias), 52));  // 2^(e - 3b)
+  out = pmul(out, c);  // a * 2^e
+  return out;
+}
+
+// with AVX, the default implementations based on pload1 are faster
+#ifndef __AVX__
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  a3 = pload<Packet4f>(a);
+  a0 = vec4f_swizzle1(a3, 0,0,0,0);
+  a1 = vec4f_swizzle1(a3, 1,1,1,1);
+  a2 = vec4f_swizzle1(a3, 2,2,2,2);
+  a3 = vec4f_swizzle1(a3, 3,3,3,3);
+}
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet2d>(const double *a,
+                      Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+#ifdef EIGEN_VECTORIZE_SSE3
+  a0 = _mm_loaddup_pd(a+0);
+  a1 = _mm_loaddup_pd(a+1);
+  a2 = _mm_loaddup_pd(a+2);
+  a3 = _mm_loaddup_pd(a+3);
+#else
+  a1 = pload<Packet2d>(a);
+  a0 = vec2d_swizzle1(a1, 0,0);
+  a1 = vec2d_swizzle1(a1, 1,1);
+  a3 = pload<Packet2d>(a+2);
+  a2 = vec2d_swizzle1(a3, 0,0);
+  a3 = vec2d_swizzle1(a3, 1,1);
+#endif
+}
+#endif
+
+EIGEN_STRONG_INLINE void punpackp(Packet4f* vecs)
+{
+  vecs[1] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x55));
+  vecs[2] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xAA));
+  vecs[3] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xFF));
+  vecs[0] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x00));
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  // Disable SSE3 _mm_hadd_pd that is extremely slow on all existing Intel's architectures
+  // (from Nehalem to Haswell)
+// #ifdef EIGEN_VECTORIZE_SSE3
+//   Packet4f tmp = _mm_add_ps(a, vec4f_swizzle1(a,2,3,2,3));
+//   return pfirst<Packet4f>(_mm_hadd_ps(tmp, tmp));
+// #else
+  Packet4f tmp = _mm_add_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_add_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+// #endif
+}
+
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{
+  // Disable SSE3 _mm_hadd_pd that is extremely slow on all existing Intel's architectures
+  // (from Nehalem to Haswell)
+// #ifdef EIGEN_VECTORIZE_SSE3
+//   return pfirst<Packet2d>(_mm_hadd_pd(a, a));
+// #else
+  return pfirst<Packet2d>(_mm_add_sd(a, _mm_unpackhi_pd(a,a)));
+// #endif
+}
+
+#ifdef EIGEN_VECTORIZE_SSSE3
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i tmp0 = _mm_hadd_epi32(a,a);
+  return pfirst<Packet4i>(_mm_hadd_epi32(tmp0,tmp0));
+}
+
+#else
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i tmp = _mm_add_epi32(a, _mm_unpackhi_epi64(a,a));
+  return pfirst(tmp) + pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1));
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE bool predux<Packet16b>(const Packet16b& a) {
+  Packet4i tmp = _mm_or_si128(a, _mm_unpackhi_epi64(a,a));
+  return (pfirst(tmp) != 0) || (pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1)) != 0);
+}
+
+// Other reduction functions:
+
+
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  Packet4f tmp = _mm_mul_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_mul_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{
+  return pfirst<Packet2d>(_mm_mul_sd(a, _mm_unpackhi_pd(a,a)));
+}
+template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
+{
+  // after some experiments, it is seems this is the fastest way to implement it
+  // for GCC (eg., reusing pmul is very slow !)
+  // TODO try to call _mm_mul_epu32 directly
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  return  (aux[0] * aux[1]) * (aux[2] * aux[3]);
+}
+
+template<> EIGEN_STRONG_INLINE bool predux_mul<Packet16b>(const Packet16b& a) {
+  Packet4i tmp = _mm_and_si128(a, _mm_unpackhi_epi64(a,a));
+  return ((pfirst<Packet4i>(tmp) == 0x01010101) &&
+          (pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1)) == 0x01010101));
+}
+
+// min
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  Packet4f tmp = _mm_min_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_min_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{
+  return pfirst<Packet2d>(_mm_min_sd(a, _mm_unpackhi_pd(a,a)));
+}
+template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  Packet4i tmp = _mm_min_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0,0,3,2)));
+  return pfirst<Packet4i>(_mm_min_epi32(tmp,_mm_shuffle_epi32(tmp, 1)));
+#else
+  // after some experiments, it is seems this is the fastest way to implement it
+  // for GCC (eg., it does not like using std::min after the pstore !!)
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  int aux0 = aux[0]<aux[1] ? aux[0] : aux[1];
+  int aux2 = aux[2]<aux[3] ? aux[2] : aux[3];
+  return aux0<aux2 ? aux0 : aux2;
+#endif // EIGEN_VECTORIZE_SSE4_1
+}
+
+// max
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  Packet4f tmp = _mm_max_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_max_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{
+  return pfirst<Packet2d>(_mm_max_sd(a, _mm_unpackhi_pd(a,a)));
+}
+template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  Packet4i tmp = _mm_max_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0,0,3,2)));
+  return pfirst<Packet4i>(_mm_max_epi32(tmp,_mm_shuffle_epi32(tmp, 1)));
+#else
+  // after some experiments, it is seems this is the fastest way to implement it
+  // for GCC (eg., it does not like using std::min after the pstore !!)
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  int aux0 = aux[0]>aux[1] ? aux[0] : aux[1];
+  int aux2 = aux[2]>aux[3] ? aux[2] : aux[3];
+  return aux0>aux2 ? aux0 : aux2;
+#endif // EIGEN_VECTORIZE_SSE4_1
+}
+
+// not needed yet
+// template<> EIGEN_STRONG_INLINE bool predux_all(const Packet4f& x)
+// {
+//   return _mm_movemask_ps(x) == 0xF;
+// }
+
+template<> EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x)
+{
+  return _mm_movemask_ps(x) != 0x0;
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  _MM_TRANSPOSE4_PS(kernel.packet[0], kernel.packet[1], kernel.packet[2], kernel.packet[3]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2d,2>& kernel) {
+  __m128d tmp = _mm_unpackhi_pd(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[0] = _mm_unpacklo_pd(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[1] = tmp;
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4i,4>& kernel) {
+  __m128i T0 = _mm_unpacklo_epi32(kernel.packet[0], kernel.packet[1]);
+  __m128i T1 = _mm_unpacklo_epi32(kernel.packet[2], kernel.packet[3]);
+  __m128i T2 = _mm_unpackhi_epi32(kernel.packet[0], kernel.packet[1]);
+  __m128i T3 = _mm_unpackhi_epi32(kernel.packet[2], kernel.packet[3]);
+
+  kernel.packet[0] = _mm_unpacklo_epi64(T0, T1);
+  kernel.packet[1] = _mm_unpackhi_epi64(T0, T1);
+  kernel.packet[2] = _mm_unpacklo_epi64(T2, T3);
+  kernel.packet[3] = _mm_unpackhi_epi64(T2, T3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16b,4>& kernel) {
+  __m128i T0 =  _mm_unpacklo_epi8(kernel.packet[0], kernel.packet[1]);
+  __m128i T1 =  _mm_unpackhi_epi8(kernel.packet[0], kernel.packet[1]);
+  __m128i T2 =  _mm_unpacklo_epi8(kernel.packet[2], kernel.packet[3]);
+  __m128i T3 =  _mm_unpackhi_epi8(kernel.packet[2], kernel.packet[3]);
+  kernel.packet[0] = _mm_unpacklo_epi16(T0, T2);
+  kernel.packet[1] = _mm_unpackhi_epi16(T0, T2);
+  kernel.packet[2] = _mm_unpacklo_epi16(T1, T3);
+  kernel.packet[3] = _mm_unpackhi_epi16(T1, T3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16b,16>& kernel) {
+  // If we number the elements in the input thus:
+  // kernel.packet[ 0] = {00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 0a, 0b, 0c, 0d, 0e, 0f}
+  // kernel.packet[ 1] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1a, 1b, 1c, 1d, 1e, 1f}
+  // ...
+  // kernel.packet[15] = {f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, fa, fb, fc, fd, fe, ff},
+  //
+  // the desired output is:
+  // kernel.packet[ 0] = {00, 10, 20, 30, 40, 50, 60, 70, 80, 90, a0, b0, c0, d0, e0, f0}
+  // kernel.packet[ 1] = {01, 11, 21, 31, 41, 51, 61, 71, 81, 91, a1, b1, c1, d1, e1, f1}
+  // ...
+  // kernel.packet[15] = {0f, 1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f, 9f, af, bf, cf, df, ef, ff},
+  __m128i t0 =  _mm_unpacklo_epi8(kernel.packet[0], kernel.packet[1]); // 00 10 01 11 02 12 03 13 04 14 05 15 06 16 07 17
+  __m128i t1 =  _mm_unpackhi_epi8(kernel.packet[0], kernel.packet[1]); // 08 18 09 19 0a 1a 0b 1b 0c 1c 0d 1d 0e 1e 0f 1f
+  __m128i t2 =  _mm_unpacklo_epi8(kernel.packet[2], kernel.packet[3]); // 20 30 21 31 22 32 ...                     27 37
+  __m128i t3 =  _mm_unpackhi_epi8(kernel.packet[2], kernel.packet[3]); // 28 38 29 39 2a 3a ...                     2f 3f
+  __m128i t4 =  _mm_unpacklo_epi8(kernel.packet[4], kernel.packet[5]); // 40 50 41 51 42 52                         47 57
+  __m128i t5 =  _mm_unpackhi_epi8(kernel.packet[4], kernel.packet[5]); // 48 58 49 59 4a 5a
+  __m128i t6 =  _mm_unpacklo_epi8(kernel.packet[6], kernel.packet[7]);
+  __m128i t7 =  _mm_unpackhi_epi8(kernel.packet[6], kernel.packet[7]);
+  __m128i t8 =  _mm_unpacklo_epi8(kernel.packet[8], kernel.packet[9]);
+  __m128i t9 =  _mm_unpackhi_epi8(kernel.packet[8], kernel.packet[9]);
+  __m128i ta =  _mm_unpacklo_epi8(kernel.packet[10], kernel.packet[11]);
+  __m128i tb =  _mm_unpackhi_epi8(kernel.packet[10], kernel.packet[11]);
+  __m128i tc =  _mm_unpacklo_epi8(kernel.packet[12], kernel.packet[13]);
+  __m128i td =  _mm_unpackhi_epi8(kernel.packet[12], kernel.packet[13]);
+  __m128i te =  _mm_unpacklo_epi8(kernel.packet[14], kernel.packet[15]);
+  __m128i tf =  _mm_unpackhi_epi8(kernel.packet[14], kernel.packet[15]);
+
+  __m128i s0 =  _mm_unpacklo_epi16(t0, t2); // 00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+  __m128i s1 =  _mm_unpackhi_epi16(t0, t2); // 04 14 24 34
+  __m128i s2 =  _mm_unpacklo_epi16(t1, t3); // 08 18 28 38 ...
+  __m128i s3 =  _mm_unpackhi_epi16(t1, t3); // 0c 1c 2c 3c ...
+  __m128i s4 =  _mm_unpacklo_epi16(t4, t6); // 40 50 60 70 41 51 61 71 42 52 62 72 43 53 63 73
+  __m128i s5 =  _mm_unpackhi_epi16(t4, t6); // 44 54 64 74 ...
+  __m128i s6 =  _mm_unpacklo_epi16(t5, t7);
+  __m128i s7 =  _mm_unpackhi_epi16(t5, t7);
+  __m128i s8 =  _mm_unpacklo_epi16(t8, ta);
+  __m128i s9 =  _mm_unpackhi_epi16(t8, ta);
+  __m128i sa =  _mm_unpacklo_epi16(t9, tb);
+  __m128i sb =  _mm_unpackhi_epi16(t9, tb);
+  __m128i sc =  _mm_unpacklo_epi16(tc, te);
+  __m128i sd =  _mm_unpackhi_epi16(tc, te);
+  __m128i se =  _mm_unpacklo_epi16(td, tf);
+  __m128i sf =  _mm_unpackhi_epi16(td, tf);
+
+  __m128i u0 =  _mm_unpacklo_epi32(s0, s4); // 00 10 20 30 40 50 60 70 01 11 21 31 41 51 61 71
+  __m128i u1 =  _mm_unpackhi_epi32(s0, s4); // 02 12 22 32 42 52 62 72 03 13 23 33 43 53 63 73
+  __m128i u2 =  _mm_unpacklo_epi32(s1, s5);
+  __m128i u3 =  _mm_unpackhi_epi32(s1, s5);
+  __m128i u4 =  _mm_unpacklo_epi32(s2, s6);
+  __m128i u5 =  _mm_unpackhi_epi32(s2, s6);
+  __m128i u6 =  _mm_unpacklo_epi32(s3, s7);
+  __m128i u7 =  _mm_unpackhi_epi32(s3, s7);
+  __m128i u8 =  _mm_unpacklo_epi32(s8, sc);
+  __m128i u9 =  _mm_unpackhi_epi32(s8, sc);
+  __m128i ua =  _mm_unpacklo_epi32(s9, sd);
+  __m128i ub =  _mm_unpackhi_epi32(s9, sd);
+  __m128i uc =  _mm_unpacklo_epi32(sa, se);
+  __m128i ud =  _mm_unpackhi_epi32(sa, se);
+  __m128i ue =  _mm_unpacklo_epi32(sb, sf);
+  __m128i uf =  _mm_unpackhi_epi32(sb, sf);
+
+  kernel.packet[0]  = _mm_unpacklo_epi64(u0, u8);
+  kernel.packet[1]  = _mm_unpackhi_epi64(u0, u8);
+  kernel.packet[2]  = _mm_unpacklo_epi64(u1, u9);
+  kernel.packet[3]  = _mm_unpackhi_epi64(u1, u9);
+  kernel.packet[4]  = _mm_unpacklo_epi64(u2, ua);
+  kernel.packet[5]  = _mm_unpackhi_epi64(u2, ua);
+  kernel.packet[6]  = _mm_unpacklo_epi64(u3, ub);
+  kernel.packet[7]  = _mm_unpackhi_epi64(u3, ub);
+  kernel.packet[8]  = _mm_unpacklo_epi64(u4, uc);
+  kernel.packet[9]  = _mm_unpackhi_epi64(u4, uc);
+  kernel.packet[10] = _mm_unpacklo_epi64(u5, ud);
+  kernel.packet[11] = _mm_unpackhi_epi64(u5, ud);
+  kernel.packet[12] = _mm_unpacklo_epi64(u6, ue);
+  kernel.packet[13] = _mm_unpackhi_epi64(u6, ue);
+  kernel.packet[14] = _mm_unpacklo_epi64(u7, uf);
+  kernel.packet[15] = _mm_unpackhi_epi64(u7, uf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket) {
+  const __m128i zero = _mm_setzero_si128();
+  const __m128i select = _mm_set_epi32(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m128i false_mask = _mm_cmpeq_epi32(select, zero);
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blendv_epi8(thenPacket, elsePacket, false_mask);
+#else
+  return _mm_or_si128(_mm_andnot_si128(false_mask, thenPacket), _mm_and_si128(false_mask, elsePacket));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  const __m128 zero = _mm_setzero_ps();
+  const __m128 select = _mm_set_ps(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m128 false_mask = _mm_cmpeq_ps(select, zero);
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blendv_ps(thenPacket, elsePacket, false_mask);
+#else
+  return _mm_or_ps(_mm_andnot_ps(false_mask, thenPacket), _mm_and_ps(false_mask, elsePacket));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket) {
+  const __m128d zero = _mm_setzero_pd();
+  const __m128d select = _mm_set_pd(ifPacket.select[1], ifPacket.select[0]);
+  __m128d false_mask = _mm_cmpeq_pd(select, zero);
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blendv_pd(thenPacket, elsePacket, false_mask);
+#else
+  return _mm_or_pd(_mm_andnot_pd(false_mask, thenPacket), _mm_and_pd(false_mask, elsePacket));
+#endif
+}
+
+// Scalar path for pmadd with FMA to ensure consistency with vectorized path.
+#ifdef EIGEN_VECTORIZE_FMA
+template<> EIGEN_STRONG_INLINE float pmadd(const float& a, const float& b, const float& c) {
+  return ::fmaf(a,b,c);
+}
+template<> EIGEN_STRONG_INLINE double pmadd(const double& a, const double& b, const double& c) {
+  return ::fma(a,b,c);
+}
+#endif
+
+
+// Packet math for Eigen::half
+// Disable the following code since it's broken on too many platforms / compilers.
+//#elif defined(EIGEN_VECTORIZE_SSE) && (!EIGEN_ARCH_x86_64) && (!EIGEN_COMP_MSVC)
+#if 0
+
+typedef struct {
+  __m64 x;
+} Packet4h;
+
+
+template<> struct is_arithmetic<Packet4h> { enum { value = true }; };
+
+template <>
+struct packet_traits<Eigen::half> : default_packet_traits {
+  typedef Packet4h type;
+  // There is no half-size packet for Packet4h.
+  typedef Packet4h half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 0,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasConj   = 0,
+    HasSetLinear = 0,
+    HasSqrt = 0,
+    HasRsqrt = 0,
+    HasExp = 0,
+    HasLog = 0,
+    HasBlend = 0
+  };
+};
+
+
+template<> struct unpacket_traits<Packet4h> { typedef Eigen::half type; enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet4h half; };
+
+template<> EIGEN_STRONG_INLINE Packet4h pset1<Packet4h>(const Eigen::half& from) {
+  Packet4h result;
+  result.x = _mm_set1_pi16(from.x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half pfirst<Packet4h>(const Packet4h& from) {
+  return half_impl::raw_uint16_to_half(static_cast<unsigned short>(_mm_cvtsi64_si32(from.x)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pconj(const Packet4h& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4h padd<Packet4h>(const Packet4h& a, const Packet4h& b) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  __int64_t b64 = _mm_cvtm64_si64(b.x);
+
+  Eigen::half h[4];
+
+  Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
+  Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
+  h[0] = ha + hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
+  h[1] = ha + hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
+  h[2] = ha + hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
+  h[3] = ha + hb;
+  Packet4h result;
+  result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h psub<Packet4h>(const Packet4h& a, const Packet4h& b) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  __int64_t b64 = _mm_cvtm64_si64(b.x);
+
+  Eigen::half h[4];
+
+  Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
+  Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
+  h[0] = ha - hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
+  h[1] = ha - hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
+  h[2] = ha - hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
+  h[3] = ha - hb;
+  Packet4h result;
+  result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pmul<Packet4h>(const Packet4h& a, const Packet4h& b) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  __int64_t b64 = _mm_cvtm64_si64(b.x);
+
+  Eigen::half h[4];
+
+  Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
+  Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
+  h[0] = ha * hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
+  h[1] = ha * hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
+  h[2] = ha * hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
+  h[3] = ha * hb;
+  Packet4h result;
+  result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pdiv<Packet4h>(const Packet4h& a, const Packet4h& b) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  __int64_t b64 = _mm_cvtm64_si64(b.x);
+
+  Eigen::half h[4];
+
+  Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
+  Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
+  h[0] = ha / hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
+  h[1] = ha / hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
+  h[2] = ha / hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
+  h[3] = ha / hb;
+  Packet4h result;
+  result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pload<Packet4h>(const Eigen::half* from) {
+  Packet4h result;
+  result.x = _mm_cvtsi64_m64(*reinterpret_cast<const __int64_t*>(from));
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h ploadu<Packet4h>(const Eigen::half* from) {
+  Packet4h result;
+  result.x = _mm_cvtsi64_m64(*reinterpret_cast<const __int64_t*>(from));
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet4h& from) {
+  __int64_t r = _mm_cvtm64_si64(from.x);
+  *(reinterpret_cast<__int64_t*>(to)) = r;
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet4h& from) {
+  __int64_t r = _mm_cvtm64_si64(from.x);
+  *(reinterpret_cast<__int64_t*>(to)) = r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h
+ploadquad<Packet4h>(const Eigen::half* from) {
+  return pset1<Packet4h>(*from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pgather<Eigen::half, Packet4h>(const Eigen::half* from, Index stride)
+{
+  Packet4h result;
+  result.x = _mm_set_pi16(from[3*stride].x, from[2*stride].x, from[1*stride].x, from[0*stride].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet4h>(Eigen::half* to, const Packet4h& from, Index stride)
+{
+  __int64_t a = _mm_cvtm64_si64(from.x);
+  to[stride*0].x = static_cast<unsigned short>(a);
+  to[stride*1].x = static_cast<unsigned short>(a >> 16);
+  to[stride*2].x = static_cast<unsigned short>(a >> 32);
+  to[stride*3].x = static_cast<unsigned short>(a >> 48);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet4h,4>& kernel) {
+  __m64 T0 = _mm_unpacklo_pi16(kernel.packet[0].x, kernel.packet[1].x);
+  __m64 T1 = _mm_unpacklo_pi16(kernel.packet[2].x, kernel.packet[3].x);
+  __m64 T2 = _mm_unpackhi_pi16(kernel.packet[0].x, kernel.packet[1].x);
+  __m64 T3 = _mm_unpackhi_pi16(kernel.packet[2].x, kernel.packet[3].x);
+
+  kernel.packet[0].x = _mm_unpacklo_pi32(T0, T1);
+  kernel.packet[1].x = _mm_unpackhi_pi32(T0, T1);
+  kernel.packet[2].x = _mm_unpacklo_pi32(T2, T3);
+  kernel.packet[3].x = _mm_unpackhi_pi32(T2, T3);
+}
+
+#endif
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#if EIGEN_COMP_PGI && EIGEN_COMP_PGI < 1900
+// PGI++ does not define the following intrinsics in C++ mode.
+static inline __m128  _mm_castpd_ps   (__m128d x) { return reinterpret_cast<__m128&>(x);  }
+static inline __m128i _mm_castpd_si128(__m128d x) { return reinterpret_cast<__m128i&>(x); }
+static inline __m128d _mm_castps_pd   (__m128  x) { return reinterpret_cast<__m128d&>(x); }
+static inline __m128i _mm_castps_si128(__m128  x) { return reinterpret_cast<__m128i&>(x); }
+static inline __m128  _mm_castsi128_ps(__m128i x) { return reinterpret_cast<__m128&>(x);  }
+static inline __m128d _mm_castsi128_pd(__m128i x) { return reinterpret_cast<__m128d&>(x); }
+#endif
+
+#endif // EIGEN_PACKET_MATH_SSE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/TypeCasting.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/TypeCasting.h
new file mode 100644
index 00000000..d2a0037e
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SSE/TypeCasting.h
@@ -0,0 +1,142 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_SSE_H
+#define EIGEN_TYPE_CASTING_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_VECTORIZE_AVX
+template <>
+struct type_casting_traits<float, int> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<int, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<double, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 2,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<float, double> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 2
+  };
+};
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4i pcast<Packet4f, Packet4i>(const Packet4f& a) {
+  return _mm_cvttps_epi32(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4i, Packet4f>(const Packet4i& a) {
+  return _mm_cvtepi32_ps(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet2d, Packet4f>(const Packet2d& a, const Packet2d& b) {
+  return _mm_shuffle_ps(_mm_cvtpd_ps(a), _mm_cvtpd_ps(b), (1 << 2) | (1 << 6));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pcast<Packet4f, Packet2d>(const Packet4f& a) {
+  // Simply discard the second half of the input
+  return _mm_cvtps_pd(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i,Packet4f>(const Packet4f& a) {
+  return _mm_castps_si128(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f,Packet4i>(const Packet4i& a) {
+  return _mm_castsi128_ps(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d preinterpret<Packet2d,Packet4i>(const Packet4i& a) {
+  return _mm_castsi128_pd(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i,Packet2d>(const Packet2d& a) {
+  return _mm_castpd_si128(a);
+}
+
+// Disable the following code since it's broken on too many platforms / compilers.
+//#elif defined(EIGEN_VECTORIZE_SSE) && (!EIGEN_ARCH_x86_64) && (!EIGEN_COMP_MSVC)
+#if 0
+
+template <>
+struct type_casting_traits<Eigen::half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4h, Packet4f>(const Packet4h& a) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  Eigen::half h = raw_uint16_to_half(static_cast<unsigned short>(a64));
+  float f1 = static_cast<float>(h);
+  h = raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  float f2 = static_cast<float>(h);
+  h = raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  float f3 = static_cast<float>(h);
+  h = raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  float f4 = static_cast<float>(h);
+  return _mm_set_ps(f4, f3, f2, f1);
+}
+
+template <>
+struct type_casting_traits<float, Eigen::half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4h pcast<Packet4f, Packet4h>(const Packet4f& a) {
+  EIGEN_ALIGN16 float aux[4];
+  pstore(aux, a);
+  Eigen::half h0(aux[0]);
+  Eigen::half h1(aux[1]);
+  Eigen::half h2(aux[2]);
+  Eigen::half h3(aux[3]);
+
+  Packet4h result;
+  result.x = _mm_set_pi16(h3.x, h2.x, h1.x, h0.x);
+  return result;
+}
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_SSE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SVE/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SVE/MathFunctions.h
new file mode 100644
index 00000000..b139ea2e
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SVE/MathFunctions.h
@@ -0,0 +1,44 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020, Arm Limited and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_SVE_H
+#define EIGEN_MATH_FUNCTIONS_SVE_H
+
+namespace Eigen {
+namespace internal {
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf pexp<PacketXf>(const PacketXf& x) {
+  return pexp_float(x);
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf plog<PacketXf>(const PacketXf& x) {
+  return plog_float(x);
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf psin<PacketXf>(const PacketXf& x) {
+  return psin_float(x);
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf pcos<PacketXf>(const PacketXf& x) {
+  return pcos_float(x);
+}
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf ptanh<PacketXf>(const PacketXf& x) {
+  return internal::generic_fast_tanh_float(x);
+}
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_SVE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SVE/PacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SVE/PacketMath.h
new file mode 100644
index 00000000..9060b372
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SVE/PacketMath.h
@@ -0,0 +1,752 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020, Arm Limited and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_SVE_H
+#define EIGEN_PACKET_MATH_SVE_H
+
+namespace Eigen
+{
+namespace internal
+{
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
+
+template <typename Scalar, int SVEVectorLength>
+struct sve_packet_size_selector {
+  enum { size = SVEVectorLength / (sizeof(Scalar) * CHAR_BIT) };
+};
+
+/********************************* int32 **************************************/
+typedef svint32_t PacketXi __attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)));
+
+template <>
+struct packet_traits<numext::int32_t> : default_packet_traits {
+  typedef PacketXi type;
+  typedef PacketXi half;  // Half not implemented yet
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = sve_packet_size_selector<numext::int32_t, EIGEN_ARM64_SVE_VL>::size,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasShift = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasAbs2 = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 1,
+    HasSetLinear = 0,
+    HasBlend = 0,
+    HasReduxp = 0  // Not implemented in SVE
+  };
+};
+
+template <>
+struct unpacket_traits<PacketXi> {
+  typedef numext::int32_t type;
+  typedef PacketXi half;  // Half not yet implemented
+  enum {
+    size = sve_packet_size_selector<numext::int32_t, EIGEN_ARM64_SVE_VL>::size,
+    alignment = Aligned64,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<numext::int32_t>(const numext::int32_t* addr)
+{
+  svprfw(svptrue_b32(), addr, SV_PLDL1KEEP);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pset1<PacketXi>(const numext::int32_t& from)
+{
+  return svdup_n_s32(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi plset<PacketXi>(const numext::int32_t& a)
+{
+  numext::int32_t c[packet_traits<numext::int32_t>::size];
+  for (int i = 0; i < packet_traits<numext::int32_t>::size; i++) c[i] = i;
+  return svadd_s32_z(svptrue_b32(), pset1<PacketXi>(a), svld1_s32(svptrue_b32(), c));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi padd<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svadd_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi psub<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svsub_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pnegate(const PacketXi& a)
+{
+  return svneg_s32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pconj(const PacketXi& a)
+{
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pmul<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svmul_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pdiv<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svdiv_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pmadd(const PacketXi& a, const PacketXi& b, const PacketXi& c)
+{
+  return svmla_s32_z(svptrue_b32(), c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pmin<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svmin_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pmax<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svmax_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pcmp_le<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svdup_n_s32_z(svcmplt_s32(svptrue_b32(), a, b), 0xffffffffu);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pcmp_lt<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svdup_n_s32_z(svcmplt_s32(svptrue_b32(), a, b), 0xffffffffu);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pcmp_eq<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svdup_n_s32_z(svcmpeq_s32(svptrue_b32(), a, b), 0xffffffffu);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi ptrue<PacketXi>(const PacketXi& /*a*/)
+{
+  return svdup_n_s32_z(svptrue_b32(), 0xffffffffu);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pzero<PacketXi>(const PacketXi& /*a*/)
+{
+  return svdup_n_s32_z(svptrue_b32(), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pand<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svand_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi por<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svorr_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pxor<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return sveor_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pandnot<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svbic_s32_z(svptrue_b32(), a, b);
+}
+
+template <int N>
+EIGEN_STRONG_INLINE PacketXi parithmetic_shift_right(PacketXi a)
+{
+  return svasrd_n_s32_z(svptrue_b32(), a, N);
+}
+
+template <int N>
+EIGEN_STRONG_INLINE PacketXi plogical_shift_right(PacketXi a)
+{
+  return svreinterpret_s32_u32(svlsr_u32_z(svptrue_b32(), svreinterpret_u32_s32(a), svdup_n_u32_z(svptrue_b32(), N)));
+}
+
+template <int N>
+EIGEN_STRONG_INLINE PacketXi plogical_shift_left(PacketXi a)
+{
+  return svlsl_s32_z(svptrue_b32(), a, svdup_n_u32_z(svptrue_b32(), N));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pload<PacketXi>(const numext::int32_t* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD return svld1_s32(svptrue_b32(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi ploadu<PacketXi>(const numext::int32_t* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD return svld1_s32(svptrue_b32(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi ploaddup<PacketXi>(const numext::int32_t* from)
+{
+  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
+  return svld1_gather_u32index_s32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi ploadquad<PacketXi>(const numext::int32_t* from)
+{
+  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a0, a0, a1, a1, a1, a1, ...}
+  return svld1_gather_u32index_s32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<numext::int32_t>(numext::int32_t* to, const PacketXi& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE svst1_s32(svptrue_b32(), to, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<numext::int32_t>(numext::int32_t* to, const PacketXi& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE svst1_s32(svptrue_b32(), to, from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline PacketXi pgather<numext::int32_t, PacketXi>(const numext::int32_t* from, Index stride)
+{
+  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint32_t indices = svindex_s32(0, stride);
+  return svld1_gather_s32index_s32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<numext::int32_t, PacketXi>(numext::int32_t* to, const PacketXi& from, Index stride)
+{
+  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint32_t indices = svindex_s32(0, stride);
+  svst1_scatter_s32index_s32(svptrue_b32(), to, indices, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int32_t pfirst<PacketXi>(const PacketXi& a)
+{
+  // svlasta returns the first element if all predicate bits are 0
+  return svlasta_s32(svpfalse_b(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi preverse(const PacketXi& a)
+{
+  return svrev_s32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pabs(const PacketXi& a)
+{
+  return svabs_s32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int32_t predux<PacketXi>(const PacketXi& a)
+{
+  return static_cast<numext::int32_t>(svaddv_s32(svptrue_b32(), a));
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int32_t predux_mul<PacketXi>(const PacketXi& a)
+{
+  EIGEN_STATIC_ASSERT((EIGEN_ARM64_SVE_VL % 128 == 0),
+                      EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
+
+  // Multiply the vector by its reverse
+  svint32_t prod = svmul_s32_z(svptrue_b32(), a, svrev_s32(a));
+  svint32_t half_prod;
+
+  // Extract the high half of the vector. Depending on the VL more reductions need to be done
+  if (EIGEN_ARM64_SVE_VL >= 2048) {
+    half_prod = svtbl_s32(prod, svindex_u32(32, 1));
+    prod = svmul_s32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 1024) {
+    half_prod = svtbl_s32(prod, svindex_u32(16, 1));
+    prod = svmul_s32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 512) {
+    half_prod = svtbl_s32(prod, svindex_u32(8, 1));
+    prod = svmul_s32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 256) {
+    half_prod = svtbl_s32(prod, svindex_u32(4, 1));
+    prod = svmul_s32_z(svptrue_b32(), prod, half_prod);
+  }
+  // Last reduction
+  half_prod = svtbl_s32(prod, svindex_u32(2, 1));
+  prod = svmul_s32_z(svptrue_b32(), prod, half_prod);
+
+  // The reduction is done to the first element.
+  return pfirst<PacketXi>(prod);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int32_t predux_min<PacketXi>(const PacketXi& a)
+{
+  return svminv_s32(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int32_t predux_max<PacketXi>(const PacketXi& a)
+{
+  return svmaxv_s32(svptrue_b32(), a);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<PacketXi, N>& kernel) {
+  int buffer[packet_traits<numext::int32_t>::size * N] = {0};
+  int i = 0;
+
+  PacketXi stride_index = svindex_s32(0, N);
+
+  for (i = 0; i < N; i++) {
+    svst1_scatter_s32index_s32(svptrue_b32(), buffer + i, stride_index, kernel.packet[i]);
+  }
+  for (i = 0; i < N; i++) {
+    kernel.packet[i] = svld1_s32(svptrue_b32(), buffer + i * packet_traits<numext::int32_t>::size);
+  }
+}
+
+/********************************* float32 ************************************/
+
+typedef svfloat32_t PacketXf __attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)));
+
+template <>
+struct packet_traits<float> : default_packet_traits {
+  typedef PacketXf type;
+  typedef PacketXf half;
+
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = sve_packet_size_selector<float, EIGEN_ARM64_SVE_VL>::size,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasShift = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasAbs2 = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 1,
+    HasSetLinear = 0,
+    HasBlend = 0,
+    HasReduxp = 0,  // Not implemented in SVE
+
+    HasDiv = 1,
+    HasFloor = 1,
+
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasExp = 1,
+    HasSqrt = 0,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH
+  };
+};
+
+template <>
+struct unpacket_traits<PacketXf> {
+  typedef float type;
+  typedef PacketXf half;  // Half not yet implemented
+  typedef PacketXi integer_packet;
+
+  enum {
+    size = sve_packet_size_selector<float, EIGEN_ARM64_SVE_VL>::size,
+    alignment = Aligned64,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pset1<PacketXf>(const float& from)
+{
+  return svdup_n_f32(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pset1frombits<PacketXf>(numext::uint32_t from)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svptrue_b32(), from));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf plset<PacketXf>(const float& a)
+{
+  float c[packet_traits<float>::size];
+  for (int i = 0; i < packet_traits<float>::size; i++) c[i] = i;
+  return svadd_f32_z(svptrue_b32(), pset1<PacketXf>(a), svld1_f32(svptrue_b32(), c));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf padd<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svadd_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf psub<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svsub_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pnegate(const PacketXf& a)
+{
+  return svneg_f32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pconj(const PacketXf& a)
+{
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmul<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svmul_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pdiv<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svdiv_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmadd(const PacketXf& a, const PacketXf& b, const PacketXf& c)
+{
+  return svmla_f32_z(svptrue_b32(), c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmin<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svmin_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmin<PropagateNaN, PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return pmin<PacketXf>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmin<PropagateNumbers, PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svminnm_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmax<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svmax_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmax<PropagateNaN, PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return pmax<PacketXf>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmax<PropagateNumbers, PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svmaxnm_f32_z(svptrue_b32(), a, b);
+}
+
+// Float comparisons in SVE return svbool (predicate). Use svdup to set active
+// lanes to 1 (0xffffffffu) and inactive lanes to 0.
+template <>
+EIGEN_STRONG_INLINE PacketXf pcmp_le<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svcmplt_f32(svptrue_b32(), a, b), 0xffffffffu));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pcmp_lt<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svcmplt_f32(svptrue_b32(), a, b), 0xffffffffu));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pcmp_eq<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svcmpeq_f32(svptrue_b32(), a, b), 0xffffffffu));
+}
+
+// Do a predicate inverse (svnot_b_z) on the predicate resulted from the
+// greater/equal comparison (svcmpge_f32). Then fill a float vector with the
+// active elements.
+template <>
+EIGEN_STRONG_INLINE PacketXf pcmp_lt_or_nan<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svnot_b_z(svptrue_b32(), svcmpge_f32(svptrue_b32(), a, b)), 0xffffffffu));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pfloor<PacketXf>(const PacketXf& a)
+{
+  return svrintm_f32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf ptrue<PacketXf>(const PacketXf& /*a*/)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svptrue_b32(), 0xffffffffu));
+}
+
+// Logical Operations are not supported for float, so reinterpret casts
+template <>
+EIGEN_STRONG_INLINE PacketXf pand<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svand_u32_z(svptrue_b32(), svreinterpret_u32_f32(a), svreinterpret_u32_f32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf por<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svorr_u32_z(svptrue_b32(), svreinterpret_u32_f32(a), svreinterpret_u32_f32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pxor<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(sveor_u32_z(svptrue_b32(), svreinterpret_u32_f32(a), svreinterpret_u32_f32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pandnot<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svbic_u32_z(svptrue_b32(), svreinterpret_u32_f32(a), svreinterpret_u32_f32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pload<PacketXf>(const float* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD return svld1_f32(svptrue_b32(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf ploadu<PacketXf>(const float* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD return svld1_f32(svptrue_b32(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf ploaddup<PacketXf>(const float* from)
+{
+  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
+  return svld1_gather_u32index_f32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf ploadquad<PacketXf>(const float* from)
+{
+  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a0, a0, a1, a1, a1, a1, ...}
+  return svld1_gather_u32index_f32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<float>(float* to, const PacketXf& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE svst1_f32(svptrue_b32(), to, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const PacketXf& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE svst1_f32(svptrue_b32(), to, from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline PacketXf pgather<float, PacketXf>(const float* from, Index stride)
+{
+  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint32_t indices = svindex_s32(0, stride);
+  return svld1_gather_s32index_f32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<float, PacketXf>(float* to, const PacketXf& from, Index stride)
+{
+  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint32_t indices = svindex_s32(0, stride);
+  svst1_scatter_s32index_f32(svptrue_b32(), to, indices, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE float pfirst<PacketXf>(const PacketXf& a)
+{
+  // svlasta returns the first element if all predicate bits are 0
+  return svlasta_f32(svpfalse_b(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf preverse(const PacketXf& a)
+{
+  return svrev_f32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pabs(const PacketXf& a)
+{
+  return svabs_f32_z(svptrue_b32(), a);
+}
+
+// TODO(tellenbach): Should this go into MathFunctions.h? If so, change for 
+// all vector extensions and the generic version.
+template <>
+EIGEN_STRONG_INLINE PacketXf pfrexp<PacketXf>(const PacketXf& a, PacketXf& exponent)
+{
+  return pfrexp_generic(a, exponent);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux<PacketXf>(const PacketXf& a)
+{
+  return svaddv_f32(svptrue_b32(), a);
+}
+
+// Other reduction functions:
+// mul
+// Only works for SVE Vls multiple of 128
+template <>
+EIGEN_STRONG_INLINE float predux_mul<PacketXf>(const PacketXf& a)
+{
+  EIGEN_STATIC_ASSERT((EIGEN_ARM64_SVE_VL % 128 == 0),
+                      EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
+  // Multiply the vector by its reverse
+  svfloat32_t prod = svmul_f32_z(svptrue_b32(), a, svrev_f32(a));
+  svfloat32_t half_prod;
+
+  // Extract the high half of the vector. Depending on the VL more reductions need to be done
+  if (EIGEN_ARM64_SVE_VL >= 2048) {
+    half_prod = svtbl_f32(prod, svindex_u32(32, 1));
+    prod = svmul_f32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 1024) {
+    half_prod = svtbl_f32(prod, svindex_u32(16, 1));
+    prod = svmul_f32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 512) {
+    half_prod = svtbl_f32(prod, svindex_u32(8, 1));
+    prod = svmul_f32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 256) {
+    half_prod = svtbl_f32(prod, svindex_u32(4, 1));
+    prod = svmul_f32_z(svptrue_b32(), prod, half_prod);
+  }
+  // Last reduction
+  half_prod = svtbl_f32(prod, svindex_u32(2, 1));
+  prod = svmul_f32_z(svptrue_b32(), prod, half_prod);
+
+  // The reduction is done to the first element.
+  return pfirst<PacketXf>(prod);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_min<PacketXf>(const PacketXf& a)
+{
+  return svminv_f32(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_max<PacketXf>(const PacketXf& a)
+{
+  return svmaxv_f32(svptrue_b32(), a);
+}
+
+template<int N>
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<PacketXf, N>& kernel)
+{
+  float buffer[packet_traits<float>::size * N] = {0};
+  int i = 0;
+
+  PacketXi stride_index = svindex_s32(0, N);
+
+  for (i = 0; i < N; i++) {
+    svst1_scatter_s32index_f32(svptrue_b32(), buffer + i, stride_index, kernel.packet[i]);
+  }
+
+  for (i = 0; i < N; i++) {
+    kernel.packet[i] = svld1_f32(svptrue_b32(), buffer + i * packet_traits<float>::size);
+  }
+}
+
+template<>
+EIGEN_STRONG_INLINE PacketXf pldexp<PacketXf>(const PacketXf& a, const PacketXf& exponent)
+{
+  return pldexp_generic(a, exponent);
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_PACKET_MATH_SVE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SVE/TypeCasting.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SVE/TypeCasting.h
new file mode 100644
index 00000000..7ba5d9cd
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SVE/TypeCasting.h
@@ -0,0 +1,49 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020, Arm Limited and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_SVE_H
+#define EIGEN_TYPE_CASTING_SVE_H
+
+namespace Eigen {
+namespace internal {
+
+template <>
+struct type_casting_traits<float, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+
+template <>
+struct type_casting_traits<numext::int32_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pcast<PacketXi, PacketXf>(const PacketXi& a) {
+  return svcvt_f32_s32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pcast<PacketXf, PacketXi>(const PacketXf& a) {
+  return svcvt_s32_f32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf preinterpret<PacketXf, PacketXi>(const PacketXi& a) {
+  return svreinterpret_f32_s32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi preinterpret<PacketXi, PacketXf>(const PacketXf& a) {
+  return svreinterpret_s32_f32(a);
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_SVE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/InteropHeaders.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
new file mode 100644
index 00000000..10856ff5
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
@@ -0,0 +1,232 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*****************************************************************
+ * InteropHeaders.h
+ *
+ * \brief:
+ *  InteropHeaders
+ *
+ *****************************************************************/
+
+#ifndef EIGEN_INTEROP_HEADERS_SYCL_H
+#define EIGEN_INTEROP_HEADERS_SYCL_H
+
+namespace Eigen {
+
+#if !defined(EIGEN_DONT_VECTORIZE_SYCL)
+
+namespace internal {
+
+template <int has_blend, int lengths>
+struct sycl_packet_traits : default_packet_traits {
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = lengths,
+    HasHalfPacket = 0,
+    HasDiv = 1,
+    HasLog = 1,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasSin = 1,
+    HasCos = 1,
+    HasTan = 1,
+    HasASin = 1,
+    HasACos = 1,
+    HasATan = 1,
+    HasSinh = 1,
+    HasCosh = 1,
+    HasTanh = 1,
+    HasLGamma = 0,
+    HasDiGamma = 0,
+    HasZeta = 0,
+    HasPolygamma = 0,
+    HasErf = 0,
+    HasErfc = 0,
+    HasNdtri = 0,
+    HasIGamma = 0,
+    HasIGammac = 0,
+    HasBetaInc = 0,
+    HasBlend = has_blend,
+    // This flag is used to indicate whether packet comparison is supported.
+    // pcmp_eq, pcmp_lt and pcmp_le should be defined for it to be true.
+    HasCmp = 1,
+    HasMax = 1,
+    HasMin = 1,
+    HasMul = 1,
+    HasAdd = 1,
+    HasFloor = 1,
+    HasRound = 1,
+    HasRint = 1,
+    HasLog1p = 1,
+    HasExpm1 = 1,
+    HasCeil = 1,
+  };
+};
+
+#ifdef SYCL_DEVICE_ONLY
+#define SYCL_PACKET_TRAITS(packet_type, has_blend, unpacket_type, lengths) \
+  template <>                                                              \
+  struct packet_traits<unpacket_type>                                      \
+      : sycl_packet_traits<has_blend, lengths> {                           \
+    typedef packet_type type;                                              \
+    typedef packet_type half;                                              \
+  };
+
+SYCL_PACKET_TRAITS(cl::sycl::cl_float4, 1, float, 4)
+SYCL_PACKET_TRAITS(cl::sycl::cl_float4, 1, const float, 4)
+SYCL_PACKET_TRAITS(cl::sycl::cl_double2, 0, double, 2)
+SYCL_PACKET_TRAITS(cl::sycl::cl_double2, 0, const double, 2)
+#undef SYCL_PACKET_TRAITS
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#define SYCL_ARITHMETIC(packet_type)  \
+  template <>                         \
+  struct is_arithmetic<packet_type> { \
+    enum { value = true };            \
+  };
+SYCL_ARITHMETIC(cl::sycl::cl_float4)
+SYCL_ARITHMETIC(cl::sycl::cl_double2)
+#undef SYCL_ARITHMETIC
+
+#define SYCL_UNPACKET_TRAITS(packet_type, unpacket_type, lengths)        \
+  template <>                                                            \
+  struct unpacket_traits<packet_type> {                                  \
+    typedef unpacket_type type;                                          \
+    enum { size = lengths, vectorizable = true, alignment = Aligned16 }; \
+    typedef packet_type half;                                            \
+  };
+SYCL_UNPACKET_TRAITS(cl::sycl::cl_float4, float, 4)
+SYCL_UNPACKET_TRAITS(cl::sycl::cl_double2, double, 2)
+
+#undef SYCL_UNPACKET_TRAITS
+#endif
+
+}  // end namespace internal
+
+#endif
+
+namespace TensorSycl {
+namespace internal {
+
+template <typename PacketReturnType, int PacketSize>
+struct PacketWrapper;
+// This function should never get called on the device
+#ifndef SYCL_DEVICE_ONLY
+template <typename PacketReturnType, int PacketSize>
+struct PacketWrapper {
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
+      Scalar;
+  template <typename Index>
+  EIGEN_DEVICE_FUNC static Scalar scalarize(Index, PacketReturnType &) {
+    eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR  THE CHOSEN TYPE");
+    abort();
+  }
+  EIGEN_DEVICE_FUNC static PacketReturnType convert_to_packet_type(Scalar in,
+                                                                   Scalar) {
+    return ::Eigen::internal::template plset<PacketReturnType>(in);
+  }
+  EIGEN_DEVICE_FUNC static void set_packet(PacketReturnType, Scalar *) {
+    eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR  THE CHOSEN TYPE");
+    abort();
+  }
+};
+
+#elif defined(SYCL_DEVICE_ONLY)
+template <typename PacketReturnType>
+struct PacketWrapper<PacketReturnType, 4> {
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
+      Scalar;
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, PacketReturnType &in) {
+    switch (index) {
+      case 0:
+        return in.x();
+      case 1:
+        return in.y();
+      case 2:
+        return in.z();
+      case 3:
+        return in.w();
+      default:
+      //INDEX MUST BE BETWEEN 0 and 3.There is no abort function in SYCL kernel. so we cannot use abort here. 
+      // The code will never reach here
+      __builtin_unreachable();
+    }
+    __builtin_unreachable();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(
+      Scalar in, Scalar other) {
+    return PacketReturnType(in, other, other, other);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
+    lhs = PacketReturnType(rhs[0], rhs[1], rhs[2], rhs[3]);
+  }
+};
+
+template <typename PacketReturnType>
+struct PacketWrapper<PacketReturnType, 1> {
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
+      Scalar;
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index, PacketReturnType &in) {
+    return in;
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(Scalar in,
+                                                                   Scalar) {
+    return PacketReturnType(in);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
+    lhs = rhs[0];
+  }
+};
+
+template <typename PacketReturnType>
+struct PacketWrapper<PacketReturnType, 2> {
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
+      Scalar;
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, PacketReturnType &in) {
+    switch (index) {
+      case 0:
+        return in.x();
+      case 1:
+        return in.y();
+      default:
+        //INDEX MUST BE BETWEEN 0 and 1.There is no abort function in SYCL kernel. so we cannot use abort here. 
+      // The code will never reach here
+        __builtin_unreachable();
+    }
+    __builtin_unreachable();
+  }
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(
+      Scalar in, Scalar other) {
+    return PacketReturnType(in, other);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
+    lhs = PacketReturnType(rhs[0], rhs[1]);
+  }
+};
+
+#endif
+
+}  // end namespace internal
+}  // end namespace TensorSycl
+}  // end namespace Eigen
+
+#endif  // EIGEN_INTEROP_HEADERS_SYCL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/MathFunctions.h
new file mode 100644
index 00000000..2ab0f2a7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/MathFunctions.h
@@ -0,0 +1,301 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*****************************************************************
+ * MathFunctions.h
+ *
+ * \brief:
+ *  MathFunctions
+ *
+ *****************************************************************/
+
+#ifndef EIGEN_MATH_FUNCTIONS_SYCL_H
+#define EIGEN_MATH_FUNCTIONS_SYCL_H
+namespace Eigen {
+
+namespace internal {
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#if defined(SYCL_DEVICE_ONLY)
+#define SYCL_PLOG(packet_type)                                         \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog<packet_type>( \
+      const packet_type& a) {                                          \
+    return cl::sycl::log(a);                                           \
+  }
+
+SYCL_PLOG(cl::sycl::cl_float4)
+SYCL_PLOG(cl::sycl::cl_double2)
+#undef SYCL_PLOG
+
+#define SYCL_PLOG1P(packet_type)                                         \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog1p<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::log1p(a);                                           \
+  }
+
+SYCL_PLOG1P(cl::sycl::cl_float4)
+SYCL_PLOG1P(cl::sycl::cl_double2)
+#undef SYCL_PLOG1P
+
+#define SYCL_PLOG10(packet_type)                                         \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog10<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::log10(a);                                           \
+  }
+
+SYCL_PLOG10(cl::sycl::cl_float4)
+SYCL_PLOG10(cl::sycl::cl_double2)
+#undef SYCL_PLOG10
+
+#define SYCL_PEXP(packet_type)                                         \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexp<packet_type>( \
+      const packet_type& a) {                                          \
+    return cl::sycl::exp(a);                                           \
+  }
+
+SYCL_PEXP(cl::sycl::cl_float4)
+SYCL_PEXP(cl::sycl::cl_float)
+SYCL_PEXP(cl::sycl::cl_double2)
+#undef SYCL_PEXP
+
+#define SYCL_PEXPM1(packet_type)                                         \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexpm1<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::expm1(a);                                           \
+  }
+
+SYCL_PEXPM1(cl::sycl::cl_float4)
+SYCL_PEXPM1(cl::sycl::cl_double2)
+#undef SYCL_PEXPM1
+
+#define SYCL_PSQRT(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psqrt<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::sqrt(a);                                           \
+  }
+
+SYCL_PSQRT(cl::sycl::cl_float4)
+SYCL_PSQRT(cl::sycl::cl_double2)
+#undef SYCL_PSQRT
+
+#define SYCL_PRSQRT(packet_type)                                         \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type prsqrt<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::rsqrt(a);                                           \
+  }
+
+SYCL_PRSQRT(cl::sycl::cl_float4)
+SYCL_PRSQRT(cl::sycl::cl_double2)
+#undef SYCL_PRSQRT
+
+/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
+#define SYCL_PSIN(packet_type)                                         \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psin<packet_type>( \
+      const packet_type& a) {                                          \
+    return cl::sycl::sin(a);                                           \
+  }
+
+SYCL_PSIN(cl::sycl::cl_float4)
+SYCL_PSIN(cl::sycl::cl_double2)
+#undef SYCL_PSIN
+
+/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
+#define SYCL_PCOS(packet_type)                                         \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcos<packet_type>( \
+      const packet_type& a) {                                          \
+    return cl::sycl::cos(a);                                           \
+  }
+
+SYCL_PCOS(cl::sycl::cl_float4)
+SYCL_PCOS(cl::sycl::cl_double2)
+#undef SYCL_PCOS
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
+#define SYCL_PTAN(packet_type)                                         \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptan<packet_type>( \
+      const packet_type& a) {                                          \
+    return cl::sycl::tan(a);                                           \
+  }
+
+SYCL_PTAN(cl::sycl::cl_float4)
+SYCL_PTAN(cl::sycl::cl_double2)
+#undef SYCL_PTAN
+
+/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
+#define SYCL_PASIN(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pasin<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::asin(a);                                           \
+  }
+
+SYCL_PASIN(cl::sycl::cl_float4)
+SYCL_PASIN(cl::sycl::cl_double2)
+#undef SYCL_PASIN
+
+/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
+#define SYCL_PACOS(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pacos<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::acos(a);                                           \
+  }
+
+SYCL_PACOS(cl::sycl::cl_float4)
+SYCL_PACOS(cl::sycl::cl_double2)
+#undef SYCL_PACOS
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
+#define SYCL_PATAN(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type patan<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::atan(a);                                           \
+  }
+
+SYCL_PATAN(cl::sycl::cl_float4)
+SYCL_PATAN(cl::sycl::cl_double2)
+#undef SYCL_PATAN
+
+/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
+#define SYCL_PSINH(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psinh<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::sinh(a);                                           \
+  }
+
+SYCL_PSINH(cl::sycl::cl_float4)
+SYCL_PSINH(cl::sycl::cl_double2)
+#undef SYCL_PSINH
+
+/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
+#define SYCL_PCOSH(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcosh<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::cosh(a);                                           \
+  }
+
+SYCL_PCOSH(cl::sycl::cl_float4)
+SYCL_PCOSH(cl::sycl::cl_double2)
+#undef SYCL_PCOSH
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
+#define SYCL_PTANH(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptanh<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::tanh(a);                                           \
+  }
+
+SYCL_PTANH(cl::sycl::cl_float4)
+SYCL_PTANH(cl::sycl::cl_double2)
+#undef SYCL_PTANH
+
+#define SYCL_PCEIL(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pceil<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::ceil(a);                                           \
+  }
+
+SYCL_PCEIL(cl::sycl::cl_float4)
+SYCL_PCEIL(cl::sycl::cl_double2)
+#undef SYCL_PCEIL
+
+#define SYCL_PROUND(packet_type)                                         \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pround<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::round(a);                                           \
+  }
+
+SYCL_PROUND(cl::sycl::cl_float4)
+SYCL_PROUND(cl::sycl::cl_double2)
+#undef SYCL_PROUND
+
+#define SYCL_PRINT(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type print<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::rint(a);                                           \
+  }
+
+SYCL_PRINT(cl::sycl::cl_float4)
+SYCL_PRINT(cl::sycl::cl_double2)
+#undef SYCL_PRINT
+
+#define SYCL_FLOOR(packet_type)                                          \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pfloor<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::floor(a);                                           \
+  }
+
+SYCL_FLOOR(cl::sycl::cl_float4)
+SYCL_FLOOR(cl::sycl::cl_double2)
+#undef SYCL_FLOOR
+
+#define SYCL_PMIN(packet_type, expr)                                   \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmin<packet_type>( \
+      const packet_type& a, const packet_type& b) {                    \
+    return expr;                                                       \
+  }
+
+SYCL_PMIN(cl::sycl::cl_float4, cl::sycl::fmin(a, b))
+SYCL_PMIN(cl::sycl::cl_double2, cl::sycl::fmin(a, b))
+#undef SYCL_PMIN
+
+#define SYCL_PMAX(packet_type, expr)                                   \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmax<packet_type>( \
+      const packet_type& a, const packet_type& b) {                    \
+    return expr;                                                       \
+  }
+
+SYCL_PMAX(cl::sycl::cl_float4, cl::sycl::fmax(a, b))
+SYCL_PMAX(cl::sycl::cl_double2, cl::sycl::fmax(a, b))
+#undef SYCL_PMAX
+
+#define SYCL_PLDEXP(packet_type)                                             \
+  template <>                                                                \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pldexp(                  \
+      const packet_type& a, const packet_type& exponent) {                   \
+    return cl::sycl::ldexp(                                                  \
+        a, exponent.template convert<cl::sycl::cl_int,                       \
+                                     cl::sycl::rounding_mode::automatic>()); \
+  }
+
+SYCL_PLDEXP(cl::sycl::cl_float4)
+SYCL_PLDEXP(cl::sycl::cl_double2)
+#undef SYCL_PLDEXP
+
+#endif
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_SYCL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/PacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/PacketMath.h
new file mode 100644
index 00000000..87badc07
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/PacketMath.h
@@ -0,0 +1,670 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*****************************************************************
+ * PacketMath.h
+ *
+ * \brief:
+ *  PacketMath
+ *
+ *****************************************************************/
+
+#ifndef EIGEN_PACKET_MATH_SYCL_H
+#define EIGEN_PACKET_MATH_SYCL_H
+#include <type_traits>
+namespace Eigen {
+
+namespace internal {
+#ifdef SYCL_DEVICE_ONLY
+
+#define SYCL_PLOADT_RO(address_space_target)                                 \
+  template <typename packet_type, int Alignment>                             \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type ploadt_ro(               \
+      typename cl::sycl::multi_ptr<                                          \
+          const typename unpacket_traits<packet_type>::type,                 \
+          cl::sycl::access::address_space::address_space_target>::pointer_t  \
+          from) {                                                            \
+    typedef typename unpacket_traits<packet_type>::type scalar;              \
+    typedef cl::sycl::multi_ptr<                                             \
+        scalar, cl::sycl::access::address_space::address_space_target>       \
+        multi_ptr;                                                           \
+    auto res = packet_type(                                                  \
+        static_cast<typename unpacket_traits<packet_type>::type>(0));        \
+    res.load(0, multi_ptr(const_cast<typename multi_ptr::pointer_t>(from))); \
+    return res;                                                              \
+  }
+
+SYCL_PLOADT_RO(global_space)
+SYCL_PLOADT_RO(local_space)
+#undef SYCL_PLOADT_RO
+#endif
+
+template <typename packet_type, int Alignment, typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type
+ploadt_ro(const Eigen::TensorSycl::internal::RangeAccess<
+          cl::sycl::access::mode::read_write, T>& from) {
+  return ploadt_ro<packet_type, Alignment>(from.get_pointer());
+}
+
+#ifdef SYCL_DEVICE_ONLY
+#define SYCL_PLOAD(address_space_target, Alignment, AlignedType)            \
+  template <typename packet_type>                                           \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type pload##AlignedType(     \
+      typename cl::sycl::multi_ptr<                                         \
+          const typename unpacket_traits<packet_type>::type,                \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          from) {                                                           \
+    return ploadt_ro<packet_type, Alignment>(from);                         \
+  }
+
+// global space
+SYCL_PLOAD(global_space, Unaligned, u)
+SYCL_PLOAD(global_space, Aligned, )
+// local space
+SYCL_PLOAD(local_space, Unaligned, u)
+SYCL_PLOAD(local_space, Aligned, )
+
+#undef SYCL_PLOAD
+#endif
+
+#define SYCL_PLOAD(Alignment, AlignedType)                              \
+  template <typename packet_type>                                       \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type pload##AlignedType( \
+      const Eigen::TensorSycl::internal::RangeAccess<                   \
+          cl::sycl::access::mode::read_write,                           \
+          typename unpacket_traits<packet_type>::type>                  \
+          from) {                                                       \
+    return ploadt_ro<packet_type, Alignment>(from);                     \
+  }
+SYCL_PLOAD(Unaligned, u)
+SYCL_PLOAD(Aligned, )
+#undef SYCL_PLOAD
+
+#ifdef SYCL_DEVICE_ONLY
+/** \internal \returns a packet version of \a *from.
+ * The pointer \a from must be aligned on a \a Alignment bytes boundary. */
+#define SYCL_PLOADT(address_space_target)                                   \
+  template <typename packet_type, int Alignment>                            \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type ploadt(                 \
+      typename cl::sycl::multi_ptr<                                         \
+          const typename unpacket_traits<packet_type>::type,                \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          from) {                                                           \
+    if (Alignment >= unpacket_traits<packet_type>::alignment)               \
+      return pload<packet_type>(from);                                      \
+    else                                                                    \
+      return ploadu<packet_type>(from);                                     \
+  }
+
+// global space
+SYCL_PLOADT(global_space)
+// local space
+SYCL_PLOADT(local_space)
+#undef SYCL_PLOADT
+#endif
+
+template <typename packet_type, int Alignment>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type
+ploadt(const Eigen::TensorSycl::internal::RangeAccess<
+       cl::sycl::access::mode::read_write,
+       typename unpacket_traits<packet_type>::type>& from) {
+  return ploadt<packet_type, Alignment>(from.get_pointer());
+}
+#ifdef SYCL_DEVICE_ONLY
+
+// private_space
+#define SYCL_PLOADT_RO_SPECIAL(packet_type, Alignment)                 \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type                    \
+  ploadt_ro<packet_type, Alignment>(                                   \
+      const typename unpacket_traits<packet_type>::type* from) {       \
+    typedef typename unpacket_traits<packet_type>::type scalar;        \
+    auto res = packet_type(static_cast<scalar>(0));                    \
+    res.template load<cl::sycl::access::address_space::private_space>( \
+        0, const_cast<scalar*>(from));                                 \
+    return res;                                                        \
+  }
+
+SYCL_PLOADT_RO_SPECIAL(cl::sycl::cl_float4, Aligned)
+SYCL_PLOADT_RO_SPECIAL(cl::sycl::cl_double2, Aligned)
+SYCL_PLOADT_RO_SPECIAL(cl::sycl::cl_float4, Unaligned)
+SYCL_PLOADT_RO_SPECIAL(cl::sycl::cl_double2, Unaligned)
+
+#define SYCL_PLOAD_SPECIAL(packet_type, alignment_type)                    \
+  template <>                                                              \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type pload##alignment_type( \
+      const typename unpacket_traits<packet_type>::type* from) {           \
+    typedef typename unpacket_traits<packet_type>::type scalar;            \
+    auto res = packet_type(static_cast<scalar>(0));                        \
+    res.template load<cl::sycl::access::address_space::private_space>(     \
+        0, const_cast<scalar*>(from));                                     \
+    return res;                                                            \
+  }
+SYCL_PLOAD_SPECIAL(cl::sycl::cl_float4, )
+SYCL_PLOAD_SPECIAL(cl::sycl::cl_double2, )
+SYCL_PLOAD_SPECIAL(cl::sycl::cl_float4, u)
+SYCL_PLOAD_SPECIAL(cl::sycl::cl_double2, u)
+
+#undef SYCL_PLOAD_SPECIAL
+
+#define SYCL_PSTORE(scalar, packet_type, address_space_target, alignment)   \
+  template <>                                                               \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstore##alignment(             \
+      typename cl::sycl::multi_ptr<                                         \
+          scalar,                                                           \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          to,                                                               \
+      const packet_type& from) {                                            \
+    typedef cl::sycl::multi_ptr<                                            \
+        scalar, cl::sycl::access::address_space::address_space_target>      \
+        multi_ptr;                                                          \
+    from.store(0, multi_ptr(to));                                           \
+  }
+
+// global space
+SYCL_PSTORE(float, cl::sycl::cl_float4, global_space, )
+SYCL_PSTORE(float, cl::sycl::cl_float4, global_space, u)
+SYCL_PSTORE(double, cl::sycl::cl_double2, global_space, )
+SYCL_PSTORE(double, cl::sycl::cl_double2, global_space, u)
+SYCL_PSTORE(float, cl::sycl::cl_float4, local_space, )
+SYCL_PSTORE(float, cl::sycl::cl_float4, local_space, u)
+SYCL_PSTORE(double, cl::sycl::cl_double2, local_space, )
+SYCL_PSTORE(double, cl::sycl::cl_double2, local_space, u)
+
+SYCL_PSTORE(float, cl::sycl::cl_float4, private_space, )
+SYCL_PSTORE(float, cl::sycl::cl_float4, private_space, u)
+SYCL_PSTORE(double, cl::sycl::cl_double2, private_space, )
+SYCL_PSTORE(double, cl::sycl::cl_double2, private_space, u)
+#undef SYCL_PSTORE
+
+#define SYCL_PSTORE_T(address_space_target)                                 \
+  template <typename scalar, typename packet_type, int Alignment>           \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(                       \
+      typename cl::sycl::multi_ptr<                                         \
+          scalar,                                                           \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          to,                                                               \
+      const packet_type& from) {                                            \
+    if (Alignment)                                                          \
+      pstore(to, from);                                                     \
+    else                                                                    \
+      pstoreu(to, from);                                                    \
+  }
+
+SYCL_PSTORE_T(global_space)
+
+SYCL_PSTORE_T(local_space)
+
+#undef SYCL_PSTORE_T
+
+#define SYCL_PSET1(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type pset1<packet_type>( \
+      const typename unpacket_traits<packet_type>::type& from) {        \
+    return packet_type(from);                                           \
+  }
+
+// global space
+SYCL_PSET1(cl::sycl::cl_float4)
+SYCL_PSET1(cl::sycl::cl_double2)
+
+#undef SYCL_PSET1
+
+template <typename packet_type>
+struct get_base_packet {
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type
+  get_ploaddup(sycl_multi_pointer) {}
+
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type
+  get_pgather(sycl_multi_pointer, Index) {}
+};
+
+template <>
+struct get_base_packet<cl::sycl::cl_float4> {
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_float4 get_ploaddup(
+      sycl_multi_pointer from) {
+    return cl::sycl::cl_float4(from[0], from[0], from[1], from[1]);
+  }
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_float4 get_pgather(
+      sycl_multi_pointer from, Index stride) {
+    return cl::sycl::cl_float4(from[0 * stride], from[1 * stride],
+                               from[2 * stride], from[3 * stride]);
+  }
+
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void set_pscatter(
+      sycl_multi_pointer to, const cl::sycl::cl_float4& from, Index stride) {
+    auto tmp = stride;
+    to[0] = from.x();
+    to[tmp] = from.y();
+    to[tmp += stride] = from.z();
+    to[tmp += stride] = from.w();
+  }
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_float4 set_plset(
+      const float& a) {
+    return cl::sycl::cl_float4(static_cast<float>(a), static_cast<float>(a + 1),
+                               static_cast<float>(a + 2),
+                               static_cast<float>(a + 3));
+  }
+};
+
+template <>
+struct get_base_packet<cl::sycl::cl_double2> {
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_double2
+  get_ploaddup(const sycl_multi_pointer from) {
+    return cl::sycl::cl_double2(from[0], from[0]);
+  }
+
+  template <typename sycl_multi_pointer, typename Index>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_double2 get_pgather(
+      const sycl_multi_pointer from, Index stride) {
+    return cl::sycl::cl_double2(from[0 * stride], from[1 * stride]);
+  }
+
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void set_pscatter(
+      sycl_multi_pointer to, const cl::sycl::cl_double2& from, Index stride) {
+    to[0] = from.x();
+    to[stride] = from.y();
+  }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_double2 set_plset(
+      const double& a) {
+    return cl::sycl::cl_double2(static_cast<double>(a),
+                                static_cast<double>(a + 1));
+  }
+};
+
+#define SYCL_PLOAD_DUP(address_space_target)                                \
+  template <typename packet_type>                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ploaddup(               \
+      typename cl::sycl::multi_ptr<                                         \
+          const typename unpacket_traits<packet_type>::type,                \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          from) {                                                           \
+    return get_base_packet<packet_type>::get_ploaddup(from);                \
+  }
+
+// global space
+SYCL_PLOAD_DUP(global_space)
+// local_space
+SYCL_PLOAD_DUP(local_space)
+#undef SYCL_PLOAD_DUP
+
+#define SYCL_PLOAD_DUP_SPECILIZE(packet_type)                              \
+  template <>                                                              \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ploaddup<packet_type>( \
+      const typename unpacket_traits<packet_type>::type* from) {           \
+    return get_base_packet<packet_type>::get_ploaddup(from);               \
+  }
+
+SYCL_PLOAD_DUP_SPECILIZE(cl::sycl::cl_float4)
+SYCL_PLOAD_DUP_SPECILIZE(cl::sycl::cl_double2)
+
+#undef SYCL_PLOAD_DUP_SPECILIZE
+
+#define SYCL_PLSET(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type plset<packet_type>( \
+      const typename unpacket_traits<packet_type>::type& a) {           \
+    return get_base_packet<packet_type>::set_plset(a);                  \
+  }
+
+SYCL_PLSET(cl::sycl::cl_float4)
+SYCL_PLSET(cl::sycl::cl_double2)
+
+#undef SYCL_PLSET
+
+#define SYCL_PGATHER(address_space_target)                                  \
+  template <typename Scalar, typename packet_type>                          \
+  EIGEN_DEVICE_FUNC inline packet_type pgather(                             \
+      typename cl::sycl::multi_ptr<                                         \
+          const typename unpacket_traits<packet_type>::type,                \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          from,                                                             \
+      Index stride) {                                                       \
+    return get_base_packet<packet_type>::get_pgather(from, stride);         \
+  }
+
+// global space
+SYCL_PGATHER(global_space)
+// local space
+SYCL_PGATHER(local_space)
+
+#undef SYCL_PGATHER
+
+#define SYCL_PGATHER_SPECILIZE(scalar, packet_type)                            \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type                            \
+  pgather<scalar, packet_type>(                                                \
+      const typename unpacket_traits<packet_type>::type* from, Index stride) { \
+    return get_base_packet<packet_type>::get_pgather(from, stride);            \
+  }
+
+SYCL_PGATHER_SPECILIZE(float, cl::sycl::cl_float4)
+SYCL_PGATHER_SPECILIZE(double, cl::sycl::cl_double2)
+
+#undef SYCL_PGATHER_SPECILIZE
+
+#define SYCL_PSCATTER(address_space_target)                                 \
+  template <typename Scalar, typename packet_type>                          \
+  EIGEN_DEVICE_FUNC inline void pscatter(                                   \
+      typename cl::sycl::multi_ptr<                                         \
+          typename unpacket_traits<packet_type>::type,                      \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          to,                                                               \
+      const packet_type& from, Index stride) {                              \
+    get_base_packet<packet_type>::set_pscatter(to, from, stride);           \
+  }
+
+// global space
+SYCL_PSCATTER(global_space)
+// local space
+SYCL_PSCATTER(local_space)
+
+#undef SYCL_PSCATTER
+
+#define SYCL_PSCATTER_SPECILIZE(scalar, packet_type)                        \
+  template <>                                                               \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<scalar, packet_type>( \
+      typename unpacket_traits<packet_type>::type * to,                     \
+      const packet_type& from, Index stride) {                              \
+    get_base_packet<packet_type>::set_pscatter(to, from, stride);           \
+  }
+
+SYCL_PSCATTER_SPECILIZE(float, cl::sycl::cl_float4)
+SYCL_PSCATTER_SPECILIZE(double, cl::sycl::cl_double2)
+
+#undef SYCL_PSCATTER_SPECILIZE
+
+#define SYCL_PMAD(packet_type)                                            \
+  template <>                                                             \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type pmadd(                \
+      const packet_type& a, const packet_type& b, const packet_type& c) { \
+    return cl::sycl::mad(a, b, c);                                        \
+  }
+
+SYCL_PMAD(cl::sycl::cl_float4)
+SYCL_PMAD(cl::sycl::cl_double2)
+#undef SYCL_PMAD
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float pfirst<cl::sycl::cl_float4>(
+    const cl::sycl::cl_float4& a) {
+  return a.x();
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double pfirst<cl::sycl::cl_double2>(
+    const cl::sycl::cl_double2& a) {
+  return a.x();
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float predux<cl::sycl::cl_float4>(
+    const cl::sycl::cl_float4& a) {
+  return a.x() + a.y() + a.z() + a.w();
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double predux<cl::sycl::cl_double2>(
+    const cl::sycl::cl_double2& a) {
+  return a.x() + a.y();
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float predux_max<cl::sycl::cl_float4>(
+    const cl::sycl::cl_float4& a) {
+  return cl::sycl::fmax(cl::sycl::fmax(a.x(), a.y()),
+                        cl::sycl::fmax(a.z(), a.w()));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double predux_max<cl::sycl::cl_double2>(
+    const cl::sycl::cl_double2& a) {
+  return cl::sycl::fmax(a.x(), a.y());
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float predux_min<cl::sycl::cl_float4>(
+    const cl::sycl::cl_float4& a) {
+  return cl::sycl::fmin(cl::sycl::fmin(a.x(), a.y()),
+                        cl::sycl::fmin(a.z(), a.w()));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double predux_min<cl::sycl::cl_double2>(
+    const cl::sycl::cl_double2& a) {
+  return cl::sycl::fmin(a.x(), a.y());
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float predux_mul<cl::sycl::cl_float4>(
+    const cl::sycl::cl_float4& a) {
+  return a.x() * a.y() * a.z() * a.w();
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double predux_mul<cl::sycl::cl_double2>(
+    const cl::sycl::cl_double2& a) {
+  return a.x() * a.y();
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_float4
+pabs<cl::sycl::cl_float4>(const cl::sycl::cl_float4& a) {
+  return cl::sycl::cl_float4(cl::sycl::fabs(a.x()), cl::sycl::fabs(a.y()),
+                             cl::sycl::fabs(a.z()), cl::sycl::fabs(a.w()));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_double2
+pabs<cl::sycl::cl_double2>(const cl::sycl::cl_double2& a) {
+  return cl::sycl::cl_double2(cl::sycl::fabs(a.x()), cl::sycl::fabs(a.y()));
+}
+
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet sycl_pcmp_le(const Packet &a,
+                                                          const Packet &b) {
+  return ((a <= b)
+              .template convert<typename unpacket_traits<Packet>::type,
+                                cl::sycl::rounding_mode::automatic>());
+}
+
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet sycl_pcmp_lt(const Packet &a,
+                                                          const Packet &b) {
+  return ((a < b)
+              .template convert<typename unpacket_traits<Packet>::type,
+                                cl::sycl::rounding_mode::automatic>());
+}
+
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet sycl_pcmp_eq(const Packet &a,
+                                                          const Packet &b) {
+  return ((a == b)
+              .template convert<typename unpacket_traits<Packet>::type,
+                                cl::sycl::rounding_mode::automatic>());
+}
+
+#define SYCL_PCMP(OP, TYPE)                                                    \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TYPE pcmp_##OP<TYPE>(const TYPE &a,    \
+                                                             const TYPE &b) {  \
+    return sycl_pcmp_##OP<TYPE>(a, b);                                         \
+  }
+
+SYCL_PCMP(le, cl::sycl::cl_float4)
+SYCL_PCMP(lt, cl::sycl::cl_float4)
+SYCL_PCMP(eq, cl::sycl::cl_float4)
+SYCL_PCMP(le, cl::sycl::cl_double2)
+SYCL_PCMP(lt, cl::sycl::cl_double2)
+SYCL_PCMP(eq, cl::sycl::cl_double2)
+#undef SYCL_PCMP
+
+template <typename T> struct convert_to_integer;
+
+template <> struct convert_to_integer<float> {
+  using type = std::int32_t;
+  using packet_type = cl::sycl::cl_int4;
+};
+template <> struct convert_to_integer<double> {
+  using type = std::int64_t;
+  using packet_type = cl::sycl::cl_long2;
+};
+
+template <typename PacketIn>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename convert_to_integer<
+    typename unpacket_traits<PacketIn>::type>::packet_type
+vector_as_int(const PacketIn &p) {
+  return (
+      p.template convert<typename convert_to_integer<
+                             typename unpacket_traits<PacketIn>::type>::type,
+                         cl::sycl::rounding_mode::automatic>());
+}
+
+template <typename packetOut, typename PacketIn>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packetOut
+convert_vector(const PacketIn &p) {
+  return (p.template convert<typename unpacket_traits<packetOut>::type,
+                             cl::sycl::rounding_mode::automatic>());
+}
+
+#define SYCL_PAND(TYPE)                                                        \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TYPE pand<TYPE>(const TYPE &a,         \
+                                                        const TYPE &b) {       \
+    return convert_vector<TYPE>(vector_as_int(a) & vector_as_int(b));          \
+  }
+SYCL_PAND(cl::sycl::cl_float4)
+SYCL_PAND(cl::sycl::cl_double2)
+#undef SYCL_PAND
+
+#define SYCL_POR(TYPE)                                                         \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TYPE por<TYPE>(const TYPE &a,          \
+                                                       const TYPE &b) {        \
+    return convert_vector<TYPE>(vector_as_int(a) | vector_as_int(b));          \
+  }
+
+SYCL_POR(cl::sycl::cl_float4)
+SYCL_POR(cl::sycl::cl_double2)
+#undef SYCL_POR
+
+#define SYCL_PXOR(TYPE)                                                        \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TYPE pxor<TYPE>(const TYPE &a,         \
+                                                        const TYPE &b) {       \
+    return convert_vector<TYPE>(vector_as_int(a) ^ vector_as_int(b));          \
+  }
+
+SYCL_PXOR(cl::sycl::cl_float4)
+SYCL_PXOR(cl::sycl::cl_double2)
+#undef SYCL_PXOR
+
+#define SYCL_PANDNOT(TYPE)                                                     \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TYPE pandnot<TYPE>(const TYPE &a,      \
+                                                           const TYPE &b) {    \
+    return convert_vector<TYPE>(vector_as_int(a) & (~vector_as_int(b)));       \
+  }
+SYCL_PANDNOT(cl::sycl::cl_float4)
+SYCL_PANDNOT(cl::sycl::cl_double2)
+#undef SYCL_PANDNOT
+
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(
+    PacketBlock<cl::sycl::cl_float4, 4>& kernel) {
+  float tmp = kernel.packet[0].y();
+  kernel.packet[0].y() = kernel.packet[1].x();
+  kernel.packet[1].x() = tmp;
+
+  tmp = kernel.packet[0].z();
+  kernel.packet[0].z() = kernel.packet[2].x();
+  kernel.packet[2].x() = tmp;
+
+  tmp = kernel.packet[0].w();
+  kernel.packet[0].w() = kernel.packet[3].x();
+  kernel.packet[3].x() = tmp;
+
+  tmp = kernel.packet[1].z();
+  kernel.packet[1].z() = kernel.packet[2].y();
+  kernel.packet[2].y() = tmp;
+
+  tmp = kernel.packet[1].w();
+  kernel.packet[1].w() = kernel.packet[3].y();
+  kernel.packet[3].y() = tmp;
+
+  tmp = kernel.packet[2].w();
+  kernel.packet[2].w() = kernel.packet[3].z();
+  kernel.packet[3].z() = tmp;
+}
+
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(
+    PacketBlock<cl::sycl::cl_double2, 2>& kernel) {
+  double tmp = kernel.packet[0].y();
+  kernel.packet[0].y() = kernel.packet[1].x();
+  kernel.packet[1].x() = tmp;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_float4 pblend(
+    const Selector<unpacket_traits<cl::sycl::cl_float4>::size>& ifPacket,
+    const cl::sycl::cl_float4& thenPacket,
+    const cl::sycl::cl_float4& elsePacket) {
+  cl::sycl::cl_int4 condition(
+      ifPacket.select[0] ? 0 : -1, ifPacket.select[1] ? 0 : -1,
+      ifPacket.select[2] ? 0 : -1, ifPacket.select[3] ? 0 : -1);
+  return cl::sycl::select(thenPacket, elsePacket, condition);
+}
+
+template <>
+inline cl::sycl::cl_double2 pblend(
+    const Selector<unpacket_traits<cl::sycl::cl_double2>::size>& ifPacket,
+    const cl::sycl::cl_double2& thenPacket,
+    const cl::sycl::cl_double2& elsePacket) {
+  cl::sycl::cl_long2 condition(ifPacket.select[0] ? 0 : -1,
+                               ifPacket.select[1] ? 0 : -1);
+  return cl::sycl::select(thenPacket, elsePacket, condition);
+}
+#endif  // SYCL_DEVICE_ONLY
+
+#define SYCL_PSTORE(alignment)                                  \
+  template <typename packet_type>                               \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstore##alignment( \
+      const Eigen::TensorSycl::internal::RangeAccess<           \
+          cl::sycl::access::mode::read_write,                   \
+          typename unpacket_traits<packet_type>::type>& to,     \
+      const packet_type& from) {                                \
+    pstore##alignment(to.get_pointer(), from);                  \
+  }
+
+// global space
+SYCL_PSTORE()
+SYCL_PSTORE(u)
+
+#undef SYCL_PSTORE
+
+template <typename scalar, typename packet_type, int Alignment>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(
+    Eigen::TensorSycl::internal::RangeAccess<
+        cl::sycl::access::mode::read_write,
+        typename unpacket_traits<packet_type>::type>
+        to,
+    const packet_type& from) {
+  pstoret<scalar, packet_type, Alignment>(to.get_pointer(), from);
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_PACKET_MATH_SYCL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
new file mode 100644
index 00000000..f81e59db
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
@@ -0,0 +1,694 @@
+/***************************************************************************
+ *  Copyright (C) 2017 Codeplay Software Limited
+ *  This Source Code Form is subject to the terms of the Mozilla
+ *  Public License v. 2.0. If a copy of the MPL was not distributed
+ *  with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ *
+ *  SyclMemoryModel.h
+ *
+ *  Description:
+ *    Interface for SYCL buffers to behave as a non-dereferenceable pointer
+ *    Interface for Placeholder accessor to behave as a pointer on both host
+ *    and device
+ *
+ * Authors:
+ *
+ *    Ruyman Reyes   Codeplay Software Ltd.
+ *    Mehdi Goli     Codeplay Software Ltd.
+ *    Vanya Yaneva   Codeplay Software Ltd.
+ *
+ **************************************************************************/
+
+#if defined(EIGEN_USE_SYCL) && \
+    !defined(EIGEN_CXX11_TENSOR_TENSOR_SYCL_STORAGE_MEMORY_H)
+#define EIGEN_CXX11_TENSOR_TENSOR_SYCL_STORAGE_MEMORY_H
+
+#include <CL/sycl.hpp>
+#ifdef EIGEN_EXCEPTIONS
+#include <stdexcept>
+#endif
+#include <cstddef>
+#include <queue>
+#include <set>
+#include <unordered_map>
+
+namespace Eigen {
+namespace TensorSycl {
+namespace internal {
+
+using sycl_acc_target = cl::sycl::access::target;
+using sycl_acc_mode = cl::sycl::access::mode;
+
+/**
+ * Default values for template arguments
+ */
+using buffer_data_type_t = uint8_t;
+const sycl_acc_target default_acc_target = sycl_acc_target::global_buffer;
+const sycl_acc_mode default_acc_mode = sycl_acc_mode::read_write;
+
+/**
+ * PointerMapper
+ *  Associates fake pointers with buffers.
+ *
+ */
+class PointerMapper {
+ public:
+  using base_ptr_t = std::intptr_t;
+
+  /* Structure of a virtual pointer
+   *
+   * |================================================|
+   * |               POINTER ADDRESS                  |
+   * |================================================|
+   */
+  struct virtual_pointer_t {
+    /* Type for the pointers
+     */
+    base_ptr_t m_contents;
+
+    /** Conversions from virtual_pointer_t to
+     * void * should just reinterpret_cast the integer number
+     */
+    operator void *() const { return reinterpret_cast<void *>(m_contents); }
+
+    /**
+     * Convert back to the integer number.
+     */
+    operator base_ptr_t() const { return m_contents; }
+
+    /**
+     * Add a certain value to the pointer to create a
+     * new pointer to that offset
+     */
+    virtual_pointer_t operator+(size_t off) { return m_contents + off; }
+
+    /* Numerical order for sorting pointers in containers. */
+    bool operator<(virtual_pointer_t rhs) const {
+      return (static_cast<base_ptr_t>(m_contents) <
+              static_cast<base_ptr_t>(rhs.m_contents));
+    }
+
+    bool operator>(virtual_pointer_t rhs) const {
+      return (static_cast<base_ptr_t>(m_contents) >
+              static_cast<base_ptr_t>(rhs.m_contents));
+    }
+
+    /**
+     * Numerical order for sorting pointers in containers
+     */
+    bool operator==(virtual_pointer_t rhs) const {
+      return (static_cast<base_ptr_t>(m_contents) ==
+              static_cast<base_ptr_t>(rhs.m_contents));
+    }
+
+    /**
+     * Simple forward to the equality overload.
+     */
+    bool operator!=(virtual_pointer_t rhs) const {
+      return !(this->operator==(rhs));
+    }
+
+    /**
+     * Converts a void * into a virtual pointer structure.
+     * Note that this will only work if the void * was
+     * already a virtual_pointer_t, but we have no way of
+     * checking
+     */
+    virtual_pointer_t(const void *ptr)
+        : m_contents(reinterpret_cast<base_ptr_t>(ptr)){};
+
+    /**
+     * Creates a virtual_pointer_t from the given integer
+     * number
+     */
+    virtual_pointer_t(base_ptr_t u) : m_contents(u){};
+  };
+
+  /* Definition of a null pointer
+   */
+  const virtual_pointer_t null_virtual_ptr = nullptr;
+
+  /**
+   * Whether if a pointer is null or not.
+   * A pointer is nullptr if the value is of null_virtual_ptr
+   */
+  static inline bool is_nullptr(virtual_pointer_t ptr) {
+    return (static_cast<void *>(ptr) == nullptr);
+  }
+
+  /* basic type for all buffers
+   */
+  using buffer_t = cl::sycl::buffer_mem;
+
+  /**
+   * Node that stores information about a device allocation.
+   * Nodes are sorted by size to organise a free list of nodes
+   * that can be recovered.
+   */
+  struct pMapNode_t {
+    buffer_t m_buffer;
+    size_t m_size;
+    bool m_free;
+
+    pMapNode_t(buffer_t b, size_t size, bool f)
+        : m_buffer{b}, m_size{size}, m_free{f} {
+      m_buffer.set_final_data(nullptr);
+    }
+
+    bool operator<=(const pMapNode_t &rhs) { return (m_size <= rhs.m_size); }
+  };
+
+  /** Storage of the pointer / buffer tree
+   */
+  using pointerMap_t = std::map<virtual_pointer_t, pMapNode_t>;
+
+  /**
+   * Obtain the insertion point in the pointer map for
+   * a pointer of the given size.
+   * \param requiredSize Size attemted to reclaim
+   */
+  typename pointerMap_t::iterator get_insertion_point(size_t requiredSize) {
+    typename pointerMap_t::iterator retVal;
+    bool reuse = false;
+    if (!m_freeList.empty()) {
+      // try to re-use an existing block
+      for (auto freeElem : m_freeList) {
+        if (freeElem->second.m_size >= requiredSize) {
+          retVal = freeElem;
+          reuse = true;
+          // Element is not going to be free anymore
+          m_freeList.erase(freeElem);
+          break;
+        }
+      }
+    }
+    if (!reuse) {
+      retVal = std::prev(m_pointerMap.end());
+    }
+    return retVal;
+  }
+
+  /**
+   * Returns an iterator to the node that stores the information
+   * of the given virtual pointer from the given pointer map structure.
+   * If pointer is not found, throws std::out_of_range.
+   * If the pointer map structure is empty, throws std::out_of_range
+   *
+   * \param pMap the pointerMap_t structure storing all the pointers
+   * \param virtual_pointer_ptr The virtual pointer to obtain the node of
+   * \throws std::out:of_range if the pointer is not found or pMap is empty
+   */
+  typename pointerMap_t::iterator get_node(const virtual_pointer_t ptr) {
+    if (this->count() == 0) {
+      m_pointerMap.clear();
+      EIGEN_THROW_X(std::out_of_range("There are no pointers allocated\n"));
+
+    }
+    if (is_nullptr(ptr)) {
+      m_pointerMap.clear();
+      EIGEN_THROW_X(std::out_of_range("Cannot access null pointer\n"));
+    }
+    // The previous element to the lower bound is the node that
+    // holds this memory address
+    auto node = m_pointerMap.lower_bound(ptr);
+    // If the value of the pointer is not the one of the node
+    // then we return the previous one
+    if (node == std::end(m_pointerMap)) {
+      --node;
+    } else if (node->first != ptr) {
+      if (node == std::begin(m_pointerMap)) {
+        m_pointerMap.clear();
+        EIGEN_THROW_X(
+            std::out_of_range("The pointer is not registered in the map\n"));
+
+      }
+      --node;
+    }
+
+    return node;
+  }
+
+  /* get_buffer.
+   * Returns a buffer from the map using the pointer address
+   */
+  template <typename buffer_data_type = buffer_data_type_t>
+  cl::sycl::buffer<buffer_data_type, 1> get_buffer(
+      const virtual_pointer_t ptr) {
+    using sycl_buffer_t = cl::sycl::buffer<buffer_data_type, 1>;
+
+    // get_node() returns a `buffer_mem`, so we need to cast it to a `buffer<>`.
+    // We can do this without the `buffer_mem` being a pointer, as we
+    // only declare member variables in the base class (`buffer_mem`) and not in
+    // the child class (`buffer<>).
+    auto node = get_node(ptr);
+    eigen_assert(node->first == ptr || node->first < ptr);
+    eigen_assert(ptr < static_cast<virtual_pointer_t>(node->second.m_size +
+                                                      node->first));
+    return *(static_cast<sycl_buffer_t *>(&node->second.m_buffer));
+  }
+
+  /**
+   * @brief Returns an accessor to the buffer of the given virtual pointer
+   * @param accessMode
+   * @param accessTarget
+   * @param ptr The virtual pointer
+   */
+  template <sycl_acc_mode access_mode = default_acc_mode,
+            sycl_acc_target access_target = default_acc_target,
+            typename buffer_data_type = buffer_data_type_t>
+  cl::sycl::accessor<buffer_data_type, 1, access_mode, access_target>
+  get_access(const virtual_pointer_t ptr) {
+    auto buf = get_buffer<buffer_data_type>(ptr);
+    return buf.template get_access<access_mode, access_target>();
+  }
+
+  /**
+   * @brief Returns an accessor to the buffer of the given virtual pointer
+   *        in the given command group scope
+   * @param accessMode
+   * @param accessTarget
+   * @param ptr The virtual pointer
+   * @param cgh Reference to the command group scope
+   */
+  template <sycl_acc_mode access_mode = default_acc_mode,
+            sycl_acc_target access_target = default_acc_target,
+            typename buffer_data_type = buffer_data_type_t>
+  cl::sycl::accessor<buffer_data_type, 1, access_mode, access_target>
+  get_access(const virtual_pointer_t ptr, cl::sycl::handler &cgh) {
+    auto buf = get_buffer<buffer_data_type>(ptr);
+    return buf.template get_access<access_mode, access_target>(cgh);
+  }
+
+  /*
+   * Returns the offset from the base address of this pointer.
+   */
+  inline std::ptrdiff_t get_offset(const virtual_pointer_t ptr) {
+    // The previous element to the lower bound is the node that
+    // holds this memory address
+    auto node = get_node(ptr);
+    auto start = node->first;
+    eigen_assert(start == ptr || start < ptr);
+    eigen_assert(ptr < start + node->second.m_size);
+    return (ptr - start);
+  }
+
+  /*
+   * Returns the number of elements by which the given pointer is offset from
+   * the base address.
+   */
+  template <typename buffer_data_type>
+  inline size_t get_element_offset(const virtual_pointer_t ptr) {
+    return get_offset(ptr) / sizeof(buffer_data_type);
+  }
+
+  /**
+   * Constructs the PointerMapper structure.
+   */
+  PointerMapper(base_ptr_t baseAddress = 4096)
+      : m_pointerMap{}, m_freeList{}, m_baseAddress{baseAddress} {
+    if (m_baseAddress == 0) {
+      EIGEN_THROW_X(std::invalid_argument("Base address cannot be zero\n"));
+    }
+  };
+
+  /**
+   * PointerMapper cannot be copied or moved
+   */
+  PointerMapper(const PointerMapper &) = delete;
+
+  /**
+   * Empty the pointer list
+   */
+  inline void clear() {
+    m_freeList.clear();
+    m_pointerMap.clear();
+  }
+
+  /* add_pointer.
+   * Adds an existing pointer to the map and returns the virtual pointer id.
+   */
+  inline virtual_pointer_t add_pointer(const buffer_t &b) {
+    return add_pointer_impl(b);
+  }
+
+  /* add_pointer.
+   * Adds a pointer to the map and returns the virtual pointer id.
+   */
+  inline virtual_pointer_t add_pointer(buffer_t &&b) {
+    return add_pointer_impl(b);
+  }
+
+  /**
+   * @brief Fuses the given node with the previous nodes in the
+   *        pointer map if they are free
+   *
+   * @param node A reference to the free node to be fused
+   */
+  void fuse_forward(typename pointerMap_t::iterator &node) {
+    while (node != std::prev(m_pointerMap.end())) {
+      // if following node is free
+      // remove it and extend the current node with its size
+      auto fwd_node = std::next(node);
+      if (!fwd_node->second.m_free) {
+        break;
+      }
+      auto fwd_size = fwd_node->second.m_size;
+      m_freeList.erase(fwd_node);
+      m_pointerMap.erase(fwd_node);
+
+      node->second.m_size += fwd_size;
+    }
+  }
+
+  /**
+   * @brief Fuses the given node with the following nodes in the
+   *        pointer map if they are free
+   *
+   * @param node A reference to the free node to be fused
+   */
+  void fuse_backward(typename pointerMap_t::iterator &node) {
+    while (node != m_pointerMap.begin()) {
+      // if previous node is free, extend it
+      // with the size of the current one
+      auto prev_node = std::prev(node);
+      if (!prev_node->second.m_free) {
+        break;
+      }
+      prev_node->second.m_size += node->second.m_size;
+
+      // remove the current node
+      m_freeList.erase(node);
+      m_pointerMap.erase(node);
+
+      // point to the previous node
+      node = prev_node;
+    }
+  }
+
+  /* remove_pointer.
+   * Removes the given pointer from the map.
+   * The pointer is allowed to be reused only if ReUse if true.
+   */
+  template <bool ReUse = true>
+  void remove_pointer(const virtual_pointer_t ptr) {
+    if (is_nullptr(ptr)) {
+      return;
+    }
+    auto node = this->get_node(ptr);
+
+    node->second.m_free = true;
+    m_freeList.emplace(node);
+
+    // Fuse the node
+    // with free nodes before and after it
+    fuse_forward(node);
+    fuse_backward(node);
+
+    // If after fusing the node is the last one
+    // simply remove it (since it is free)
+    if (node == std::prev(m_pointerMap.end())) {
+      m_freeList.erase(node);
+      m_pointerMap.erase(node);
+    }
+  }
+
+  /* count.
+   * Return the number of active pointers (i.e, pointers that
+   * have been malloc but not freed).
+   */
+  size_t count() const { return (m_pointerMap.size() - m_freeList.size()); }
+
+ private:
+  /* add_pointer_impl.
+   * Adds a pointer to the map and returns the virtual pointer id.
+   * BufferT is either a const buffer_t& or a buffer_t&&.
+   */
+  template <class BufferT>
+  virtual_pointer_t add_pointer_impl(BufferT b) {
+    virtual_pointer_t retVal = nullptr;
+    size_t bufSize = b.get_count();
+    pMapNode_t p{b, bufSize, false};
+    // If this is the first pointer:
+    if (m_pointerMap.empty()) {
+      virtual_pointer_t initialVal{m_baseAddress};
+      m_pointerMap.emplace(initialVal, p);
+      return initialVal;
+    }
+
+    auto lastElemIter = get_insertion_point(bufSize);
+    // We are recovering an existing free node
+    if (lastElemIter->second.m_free) {
+      lastElemIter->second.m_buffer = b;
+      lastElemIter->second.m_free = false;
+
+      // If the recovered node is bigger than the inserted one
+      // add a new free node with the remaining space
+      if (lastElemIter->second.m_size > bufSize) {
+        // create a new node with the remaining space
+        auto remainingSize = lastElemIter->second.m_size - bufSize;
+        pMapNode_t p2{b, remainingSize, true};
+
+        // update size of the current node
+        lastElemIter->second.m_size = bufSize;
+
+        // add the new free node
+        auto newFreePtr = lastElemIter->first + bufSize;
+        auto freeNode = m_pointerMap.emplace(newFreePtr, p2).first;
+        m_freeList.emplace(freeNode);
+      }
+
+      retVal = lastElemIter->first;
+    } else {
+      size_t lastSize = lastElemIter->second.m_size;
+      retVal = lastElemIter->first + lastSize;
+      m_pointerMap.emplace(retVal, p);
+    }
+    return retVal;
+  }
+
+  /**
+   * Compare two iterators to pointer map entries according to
+   * the size of the allocation on the device.
+   */
+  struct SortBySize {
+    bool operator()(typename pointerMap_t::iterator a,
+                    typename pointerMap_t::iterator b) const {
+      return ((a->first < b->first) && (a->second <= b->second)) ||
+             ((a->first < b->first) && (b->second <= a->second));
+    }
+  };
+
+  /* Maps the pointer addresses to buffer and size pairs.
+   */
+  pointerMap_t m_pointerMap;
+
+  /* List of free nodes available for re-using
+   */
+  std::set<typename pointerMap_t::iterator, SortBySize> m_freeList;
+
+  /* Base address used when issuing the first virtual pointer, allows users
+   * to specify alignment. Cannot be zero. */
+  std::intptr_t m_baseAddress;
+};
+
+/* remove_pointer.
+ * Removes the given pointer from the map.
+ * The pointer is allowed to be reused only if ReUse if true.
+ */
+template <>
+inline void PointerMapper::remove_pointer<false>(const virtual_pointer_t ptr) {
+  if (is_nullptr(ptr)) {
+    return;
+  }
+  m_pointerMap.erase(this->get_node(ptr));
+}
+
+/**
+ * Malloc-like interface to the pointer-mapper.
+ * Given a size, creates a byte-typed buffer and returns a
+ * fake pointer to keep track of it.
+ * \param size Size in bytes of the desired allocation
+ * \throw cl::sycl::exception if error while creating the buffer
+ */
+inline void *SYCLmalloc(size_t size, PointerMapper &pMap) {
+  if (size == 0) {
+    return nullptr;
+  }
+  // Create a generic buffer of the given size
+  using buffer_t = cl::sycl::buffer<buffer_data_type_t, 1>;
+  auto thePointer = pMap.add_pointer(buffer_t(cl::sycl::range<1>{size}));
+  // Store the buffer on the global list
+  return static_cast<void *>(thePointer);
+}
+
+/**
+ * Free-like interface to the pointer mapper.
+ * Given a fake-pointer created with the virtual-pointer malloc,
+ * destroys the buffer and remove it from the list.
+ * If ReUse is false, the pointer is not added to the freeList,
+ * it should be false only for sub-buffers.
+ */
+template <bool ReUse = true, typename PointerMapper>
+inline void SYCLfree(void *ptr, PointerMapper &pMap) {
+  pMap.template remove_pointer<ReUse>(ptr);
+}
+
+/**
+ * Clear all the memory allocated by SYCL.
+ */
+template <typename PointerMapper>
+inline void SYCLfreeAll(PointerMapper &pMap) {
+  pMap.clear();
+}
+
+template <cl::sycl::access::mode AcMd, typename T>
+struct RangeAccess {
+  static const auto global_access = cl::sycl::access::target::global_buffer;
+  static const auto is_place_holder = cl::sycl::access::placeholder::true_t;
+  typedef T scalar_t;
+  typedef scalar_t &ref_t;
+  typedef typename cl::sycl::global_ptr<scalar_t>::pointer_t ptr_t;
+
+  // the accessor type does not necessarily the same as T
+  typedef cl::sycl::accessor<scalar_t, 1, AcMd, global_access, is_place_holder>
+      accessor;
+
+  typedef RangeAccess<AcMd, T> self_t;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RangeAccess(accessor access,
+                                                    size_t offset,
+                                                    std::intptr_t virtual_ptr)
+      : access_(access), offset_(offset), virtual_ptr_(virtual_ptr) {}
+
+  RangeAccess(cl::sycl::buffer<scalar_t, 1> buff =
+                  cl::sycl::buffer<scalar_t, 1>(cl::sycl::range<1>(1)))
+      : access_{accessor{buff}}, offset_(0), virtual_ptr_(-1) {}
+
+  // This should be only used for null constructor on the host side
+  RangeAccess(std::nullptr_t) : RangeAccess() {}
+  // This template parameter must be removed and scalar_t should be replaced
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ptr_t get_pointer() const {
+    return (access_.get_pointer().get() + offset_);
+  }
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t &operator+=(Index offset) {
+    offset_ += (offset);
+    return *this;
+  }
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t operator+(Index offset) const {
+    return self_t(access_, offset_ + offset, virtual_ptr_);
+  }
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t operator-(Index offset) const {
+    return self_t(access_, offset_ - offset, virtual_ptr_);
+  }
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t &operator-=(Index offset) {
+    offset_ -= offset;
+    return *this;
+  }
+
+  // THIS IS FOR NULL COMPARISON ONLY
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend bool operator==(
+      const RangeAccess &lhs, std::nullptr_t) {
+    return ((lhs.virtual_ptr_ == -1));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend bool operator!=(
+      const RangeAccess &lhs, std::nullptr_t i) {
+    return !(lhs == i);
+  }
+
+  // THIS IS FOR NULL COMPARISON ONLY
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend bool operator==(
+      std::nullptr_t, const RangeAccess &rhs) {
+    return ((rhs.virtual_ptr_ == -1));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend bool operator!=(
+      std::nullptr_t i, const RangeAccess &rhs) {
+    return !(i == rhs);
+  }
+  // Prefix operator (Increment and return value)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t &operator++() {
+    offset_++;
+    return (*this);
+  }
+
+  // Postfix operator (Return value and increment)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t operator++(int i) {
+    EIGEN_UNUSED_VARIABLE(i);
+    self_t temp_iterator(*this);
+    offset_++;
+    return temp_iterator;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t get_size() const {
+    return (access_.get_count() - offset_);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t get_offset() const {
+    return offset_;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void set_offset(std::ptrdiff_t offset) {
+    offset_ = offset;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ref_t operator*() const {
+    return *get_pointer();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ref_t operator*() {
+    return *get_pointer();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ptr_t operator->() = delete;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ref_t operator[](int x) {
+    return *(get_pointer() + x);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ref_t operator[](int x) const {
+    return *(get_pointer() + x);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_t *get_virtual_pointer() const {
+    return reinterpret_cast<scalar_t *>(virtual_ptr_ +
+                                        (offset_ * sizeof(scalar_t)));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit operator bool() const {
+    return (virtual_ptr_ != -1);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE operator RangeAccess<AcMd, const T>() {
+    return RangeAccess<AcMd, const T>(access_, offset_, virtual_ptr_);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  operator RangeAccess<AcMd, const T>() const {
+    return RangeAccess<AcMd, const T>(access_, offset_, virtual_ptr_);
+  }
+  // binding placeholder accessors to a command group handler for SYCL
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void bind(
+      cl::sycl::handler &cgh) const {
+    cgh.require(access_);
+  }
+
+ private:
+  accessor access_;
+  size_t offset_;
+  std::intptr_t virtual_ptr_;  // the location of the buffer in the map
+};
+
+template <cl::sycl::access::mode AcMd, typename T>
+struct RangeAccess<AcMd, const T> : RangeAccess<AcMd, T> {
+  typedef RangeAccess<AcMd, T> Base;
+  using Base::Base;
+};
+
+}  // namespace internal
+}  // namespace TensorSycl
+}  // namespace Eigen
+
+#endif  // EIGEN_CXX11_TENSOR_TENSOR_SYCL_STORAGE_MEMORY_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/TypeCasting.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/TypeCasting.h
new file mode 100644
index 00000000..9208ab21
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/SYCL/TypeCasting.h
@@ -0,0 +1,85 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*****************************************************************
+ * TypeCasting.h
+ *
+ * \brief:
+ *  TypeCasting
+ *
+ *****************************************************************/
+
+#ifndef EIGEN_TYPE_CASTING_SYCL_H
+#define EIGEN_TYPE_CASTING_SYCL_H
+
+namespace Eigen {
+
+namespace internal {
+#ifdef SYCL_DEVICE_ONLY
+template <>
+struct type_casting_traits<float, int> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_int4
+pcast<cl::sycl::cl_float4, cl::sycl::cl_int4>(const cl::sycl::cl_float4& a) {
+  return a
+      .template convert<cl::sycl::cl_int, cl::sycl::rounding_mode::automatic>();
+}
+
+template <>
+struct type_casting_traits<int, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_float4
+pcast<cl::sycl::cl_int4, cl::sycl::cl_float4>(const cl::sycl::cl_int4& a) {
+  return a.template convert<cl::sycl::cl_float,
+                            cl::sycl::rounding_mode::automatic>();
+}
+
+template <>
+struct type_casting_traits<double, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_float4
+pcast<cl::sycl::cl_double2, cl::sycl::cl_float4>(
+    const cl::sycl::cl_double2& a, const cl::sycl::cl_double2& b) {
+  auto a1 = a.template convert<cl::sycl::cl_float,
+                               cl::sycl::rounding_mode::automatic>();
+  auto b1 = b.template convert<cl::sycl::cl_float,
+                               cl::sycl::rounding_mode::automatic>();
+  return cl::sycl::float4(a1.x(), a1.y(), b1.x(), b1.y());
+}
+
+template <>
+struct type_casting_traits<float, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_double2
+pcast<cl::sycl::cl_float4, cl::sycl::cl_double2>(const cl::sycl::cl_float4& a) {
+  // Simply discard the second half of the input
+  return cl::sycl::cl_double2(a.x(), a.y());
+}
+
+#endif
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TYPE_CASTING_SYCL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/ZVector/Complex.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/ZVector/Complex.h
new file mode 100644
index 00000000..0b9b33d9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/ZVector/Complex.h
@@ -0,0 +1,426 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX32_ALTIVEC_H
+#define EIGEN_COMPLEX32_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+static Packet4ui  p4ui_CONJ_XOR = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 }; //vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO);
+#endif
+
+static Packet2ul  p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_ZERO_, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+static Packet2ul  p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO,  (Packet4ui) p2d_ZERO_, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {}
+  Packet2d v;
+};
+
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {}
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ < 12)
+  union {
+    Packet4f v;
+    Packet1cd cd[2];
+  };
+#else
+  Packet4f v;
+#endif
+};
+
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasBlend  = 1,
+    HasSetLinear = 0
+  };
+};
+
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float>  type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet2cf half; };
+template<> struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet1cd half; };
+
+/* Forward declaration */
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel);
+
+/* complex<double> first */
+template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>&  from)
+{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(const std::complex<double>* from, Index stride EIGEN_UNUSED)
+{
+  return pload<Packet1cd>(from);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to, const Packet1cd& from, Index stride EIGEN_UNUSED)
+{
+  pstore<std::complex<double> >(to, from);
+}
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v + b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v - b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) { return Packet1cd((Packet2d)vec_xor((Packet2d)a.v, (Packet2d)p2ul_CONJ_XOR2)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  Packet2d a_re, a_im, v1, v2;
+
+  // Permute and multiply the real parts of a and b
+  a_re = vec_perm(a.v, a.v, p16uc_PSET64_HI);
+  // Get the imaginary parts of a
+  a_im = vec_perm(a.v, a.v, p16uc_PSET64_LO);
+  // multiply a_re * b
+  v1 = vec_madd(a_re, b.v, p2d_ZERO);
+  // multiply a_im * b and get the conjugate result
+  v2 = vec_madd(a_im, b.v, p2d_ZERO);
+  v2 = (Packet2d) vec_sld((Packet4ui)v2, (Packet4ui)v2, 8);
+  v2 = (Packet2d) vec_xor((Packet2d)v2, (Packet2d) p2ul_CONJ_XOR1);
+
+  return Packet1cd(v1 + v2);
+}
+template<> EIGEN_STRONG_INLINE Packet1cd pand    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_and(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd por     <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_or(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pxor    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_xor(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_and(a.v, vec_nor(b.v,b.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>*     from) {  return pset1<Packet1cd>(*from); }
+template<> EIGEN_STRONG_INLINE Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b) {
+  Packet2d eq = vec_cmpeq (a.v, b.v);
+  Packet2d tmp = { eq[1], eq[0] };
+  return (Packet1cd)pand<Packet2d>(eq, tmp);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> *   addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double>  pfirst<Packet1cd>(const Packet1cd& a)
+{
+  std::complex<double> EIGEN_ALIGN16 res;
+  pstore<std::complex<double> >(&res, a);
+
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for AltiVec
+  Packet1cd res = pmul(a,pconj(b));
+  Packet2d s = vec_madd(b.v, b.v, p2d_ZERO_);
+  return Packet1cd(pdiv(res.v, s + vec_perm(s, s, p16uc_REVERSE64)));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
+{
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd,2>& kernel)
+{
+  Packet2d tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+
+/* complex<float> follows */
+template<> EIGEN_STRONG_INLINE Packet2cf pload <Packet2cf>(const std::complex<float>* from)  { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from)  { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *     to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *     to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> EIGEN_ALIGN16 res[2];
+  pstore<std::complex<float> >(res, a);
+
+  return res[0];
+}
+
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ < 12)
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+  res.cd[0] = Packet1cd(vec_ld2f((const float *)&from));
+  res.cd[1] = res.cd[0];
+  return res;
+}
+#else
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+  if((std::ptrdiff_t(&from) % 16) == 0)
+    res.v = pload<Packet4f>((const float *)&from);
+  else
+    res.v = ploadu<Packet4f>((const float *)&from);
+  res.v = vec_perm(res.v, res.v, p16uc_PSET64_HI);
+  return res;
+}
+#endif
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
+{
+  std::complex<float> EIGEN_ALIGN16 af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+  return pload<Packet2cf>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  std::complex<float> EIGEN_ALIGN16 af[2];
+  pstore<std::complex<float> >((std::complex<float> *) af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(padd<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(psub<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(Packet4f(a.v))); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pand   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pand<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf por    <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(por<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pxor<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pandnot<Packet4f>(a.v,b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>*      from) {  return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> *     addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ < 12)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b) {
+  Packet4f eq = pcmp_eq<Packet4f> (a.v, b.v);
+  Packet2cf res;
+  Packet2d tmp1 = { eq.v4f[0][1], eq.v4f[0][0] };
+  Packet2d tmp2 = { eq.v4f[1][1], eq.v4f[1][0] };
+  res.v.v4f[0] = pand<Packet2d>(eq.v4f[0], tmp1);
+  res.v.v4f[1] = pand<Packet2d>(eq.v4f[1], tmp2);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a)
+{
+  Packet2cf res;
+  res.v.v4f[0] = pconj(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[0]))).v;
+  res.v.v4f[1] = pconj(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[1]))).v;
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  Packet2cf res;
+  res.v.v4f[0] = pmul(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[0])), Packet1cd(reinterpret_cast<Packet2d>(b.v.v4f[0]))).v;
+  res.v.v4f[1] = pmul(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[1])), Packet1cd(reinterpret_cast<Packet2d>(b.v.v4f[1]))).v;
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{
+  Packet2cf res;
+  res.cd[0] = a.cd[1];
+  res.cd[1] = a.cd[0];
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> res;
+  Packet1cd b = padd<Packet1cd>(a.cd[0], a.cd[1]);
+  vec_st2f(b.v, (float*)&res);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> res;
+  Packet1cd b = pmul<Packet1cd>(a.cd[0], a.cd[1]);
+  vec_st2f(b.v, (float*)&res);
+  return res;
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for AltiVec
+  Packet2cf res;
+  res.cd[0] = pdiv<Packet1cd>(a.cd[0], b.cd[0]);
+  res.cd[1] = pdiv<Packet1cd>(a.cd[1], b.cd[1]);
+  return res;
+}
+
+EIGEN_STRONG_INLINE Packet2cf pcplxflip/*<Packet2cf>*/(const Packet2cf& x)
+{
+  Packet2cf res;
+  res.cd[0] = pcplxflip(x.cd[0]);
+  res.cd[1] = pcplxflip(x.cd[1]);
+  return res;
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel)
+{
+  Packet1cd tmp = kernel.packet[0].cd[1];
+  kernel.packet[0].cd[1] = kernel.packet[1].cd[0];
+  kernel.packet[1].cd[0] = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  Packet2cf result;
+  const Selector<4> ifPacket4 = { ifPacket.select[0], ifPacket.select[0], ifPacket.select[1], ifPacket.select[1] };
+  result.v = pblend<Packet4f>(ifPacket4, thenPacket.v, elsePacket.v);
+  return result;
+}
+#else
+template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b) {
+  Packet4f eq = vec_cmpeq (a.v, b.v);
+  Packet4f tmp = { eq[1], eq[0], eq[3], eq[2] };
+  return (Packet2cf)pand<Packet4f>(eq, tmp);
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a.v, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  Packet4f a_re, a_im, prod, prod_im;
+
+  // Permute and multiply the real parts of a and b
+  a_re = vec_perm(a.v, a.v, p16uc_PSET32_WODD);
+  
+  // Get the imaginary parts of a
+  a_im = vec_perm(a.v, a.v, p16uc_PSET32_WEVEN);
+
+  // multiply a_im * b and get the conjugate result
+  prod_im = a_im * b.v;
+  prod_im = pxor<Packet4f>(prod_im, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR));
+  // permute back to a proper order
+  prod_im = vec_perm(prod_im, prod_im, p16uc_COMPLEX32_REV);
+
+  // multiply a_re * b, add prod_im
+  prod = pmadd<Packet4f>(a_re, b.v, prod_im);
+ 
+  return Packet2cf(prod);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{
+  Packet4f rev_a;
+  rev_a = vec_perm(a.v, a.v, p16uc_COMPLEX32_REV2);
+  return Packet2cf(rev_a);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  Packet4f b;
+  b = vec_sld(a.v, a.v, 8);
+  b = padd<Packet4f>(a.v, b);
+  return pfirst<Packet2cf>(Packet2cf(b));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  Packet4f b;
+  Packet2cf prod;
+  b = vec_sld(a.v, a.v, 8);
+  prod = pmul<Packet2cf>(a, Packet2cf(b));
+
+  return pfirst<Packet2cf>(prod);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for AltiVec
+  Packet2cf res = pmul(a, pconj(b));
+  Packet4f s = pmul<Packet4f>(b.v, b.v);
+  return Packet2cf(pdiv(res.v, padd<Packet4f>(s, vec_perm(s, s, p16uc_COMPLEX32_REV))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& x)
+{
+  return Packet2cf(vec_perm(x.v, x.v, p16uc_COMPLEX32_REV));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel)
+{
+  Packet4f tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  Packet2cf result;
+  result.v = reinterpret_cast<Packet4f>(pblend<Packet2d>(ifPacket, reinterpret_cast<Packet2d>(thenPacket.v), reinterpret_cast<Packet2d>(elsePacket.v)));
+  return result;
+}
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX32_ALTIVEC_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/ZVector/MathFunctions.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/ZVector/MathFunctions.h
new file mode 100644
index 00000000..1635e128
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/ZVector/MathFunctions.h
@@ -0,0 +1,233 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The sin, cos, exp, and log functions of this file come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+#ifndef EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+#define EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+static _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
+static _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+static _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
+static _EIGEN_DECLARE_CONST_Packet4i(23, 23);
+
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(inv_mant_mask, ~0x7f800000);
+
+/* the smallest non denormalized float number */
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(min_norm_pos,  0x00800000);
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(minus_inf,     0xff800000); // -1.f/0.f
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(minus_nan,     0xffffffff);
+  
+/* natural logarithm computed for 4 simultaneous float
+  return NaN for x <= 0
+*/
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_SQRTHF, 0.707106781186547524f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p0, 7.0376836292E-2f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p1, - 1.1514610310E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p2, 1.1676998740E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p3, - 1.2420140846E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p4, + 1.4249322787E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p5, - 1.6668057665E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p6, + 2.0000714765E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p7, - 2.4999993993E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p8, + 3.3333331174E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q1, -2.12194440e-4f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q2, 0.693359375f);
+
+static _EIGEN_DECLARE_CONST_Packet4f(exp_hi,  88.3762626647950f);
+static _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -88.3762626647949f);
+
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f);
+
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500E-4f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507E-3f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073E-3f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894E-2f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201E-1f);
+#endif
+
+static _EIGEN_DECLARE_CONST_Packet2d(1 , 1.0);
+static _EIGEN_DECLARE_CONST_Packet2d(2 , 2.0);
+static _EIGEN_DECLARE_CONST_Packet2d(half, 0.5);
+
+static _EIGEN_DECLARE_CONST_Packet2d(exp_hi,  709.437);
+static _EIGEN_DECLARE_CONST_Packet2d(exp_lo, -709.436139303);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_LOG2EF, 1.4426950408889634073599);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p0, 1.26177193074810590878e-4);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p1, 3.02994407707441961300e-2);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p2, 9.99999999999999999910e-1);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q0, 3.00198505138664455042e-6);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q1, 2.52448340349684104192e-3);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q2, 2.27265548208155028766e-1);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q3, 2.00000000000000000009e0);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C1, 0.693145751953125);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C2, 1.42860682030941723212e-6);
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d pexp<Packet2d>(const Packet2d& _x)
+{
+  Packet2d x = _x;
+
+  Packet2d tmp, fx;
+  Packet2l emm0;
+
+  // clamp x
+  x = pmax(pmin(x, p2d_exp_hi), p2d_exp_lo);
+  /* express exp(x) as exp(g + n*log(2)) */
+  fx = pmadd(p2d_cephes_LOG2EF, x, p2d_half);
+
+  fx = vec_floor(fx);
+
+  tmp = pmul(fx, p2d_cephes_exp_C1);
+  Packet2d z = pmul(fx, p2d_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  Packet2d x2 = pmul(x,x);
+
+  Packet2d px = p2d_cephes_exp_p0;
+  px = pmadd(px, x2, p2d_cephes_exp_p1);
+  px = pmadd(px, x2, p2d_cephes_exp_p2);
+  px = pmul (px, x);
+
+  Packet2d qx = p2d_cephes_exp_q0;
+  qx = pmadd(qx, x2, p2d_cephes_exp_q1);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q2);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q3);
+
+  x = pdiv(px,psub(qx,px));
+  x = pmadd(p2d_2,x,p2d_1);
+
+  // build 2^n
+  emm0 = vec_ctsl(fx, 0);
+
+  static const Packet2l p2l_1023 = { 1023, 1023 };
+  static const Packet2ul p2ul_52 = { 52, 52 };
+
+  emm0 = emm0 + p2l_1023;
+  emm0 = emm0 << reinterpret_cast<Packet2l>(p2ul_52);
+
+  // Altivec's max & min operators just drop silent NaNs. Check NaNs in 
+  // inputs and return them unmodified.
+  Packet2ul isnumber_mask = reinterpret_cast<Packet2ul>(vec_cmpeq(_x, _x));
+  return vec_sel(_x, pmax(pmul(x, reinterpret_cast<Packet2d>(emm0)), _x),
+                 isnumber_mask);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexp<Packet4f>(const Packet4f& _x)
+{
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+  Packet4f x = _x;
+
+  Packet4f tmp, fx;
+  Packet4i emm0;
+
+  // clamp x
+  x = pmax(pmin(x, p4f_exp_hi), p4f_exp_lo);
+
+  // express exp(x) as exp(g + n*log(2))
+  fx = pmadd(x, p4f_cephes_LOG2EF, p4f_half);
+
+  fx = pfloor(fx);
+
+  tmp = pmul(fx, p4f_cephes_exp_C1);
+  Packet4f z = pmul(fx, p4f_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  z = pmul(x,x);
+
+  Packet4f y = p4f_cephes_exp_p0;
+  y = pmadd(y, x, p4f_cephes_exp_p1);
+  y = pmadd(y, x, p4f_cephes_exp_p2);
+  y = pmadd(y, x, p4f_cephes_exp_p3);
+  y = pmadd(y, x, p4f_cephes_exp_p4);
+  y = pmadd(y, x, p4f_cephes_exp_p5);
+  y = pmadd(y, z, x);
+  y = padd(y, p4f_1);
+
+  // build 2^n
+  emm0 = (Packet4i){ (int)fx[0], (int)fx[1], (int)fx[2], (int)fx[3] };
+  emm0 = emm0 + p4i_0x7f;
+  emm0 = emm0 << reinterpret_cast<Packet4i>(p4i_23);
+
+  return pmax(pmul(y, reinterpret_cast<Packet4f>(emm0)), _x);
+#else
+  Packet4f res;
+  res.v4f[0] = pexp<Packet2d>(_x.v4f[0]);
+  res.v4f[1] = pexp<Packet2d>(_x.v4f[1]);
+  return res;
+#endif
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d psqrt<Packet2d>(const Packet2d& x)
+{
+  return vec_sqrt(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& x)
+{
+  Packet4f res;
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+  res = vec_sqrt(x);
+#else
+  res.v4f[0] = psqrt<Packet2d>(x.v4f[0]);
+  res.v4f[1] = psqrt<Packet2d>(x.v4f[1]);
+#endif
+  return res;
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d prsqrt<Packet2d>(const Packet2d& x) {
+  return pset1<Packet2d>(1.0) / psqrt<Packet2d>(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& x) {
+  Packet4f res;
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+  res = pset1<Packet4f>(1.0) / psqrt<Packet4f>(x);
+#else
+  res.v4f[0] = prsqrt<Packet2d>(x.v4f[0]);
+  res.v4f[1] = prsqrt<Packet2d>(x.v4f[1]);
+#endif
+  return res;
+}
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+ptanh<Packet4f>(const Packet4f& x) {
+  return internal::generic_fast_tanh_float(x);
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_ALTIVEC_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/arch/ZVector/PacketMath.h b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/ZVector/PacketMath.h
new file mode 100644
index 00000000..1f55a90a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/arch/ZVector/PacketMath.h
@@ -0,0 +1,1060 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_ZVECTOR_H
+#define EIGEN_PACKET_MATH_ZVECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 16
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS  32
+#endif
+
+typedef __vector int                 Packet4i;
+typedef __vector unsigned int        Packet4ui;
+typedef __vector __bool int          Packet4bi;
+typedef __vector short int           Packet8i;
+typedef __vector unsigned char       Packet16uc;
+typedef __vector double              Packet2d;
+typedef __vector unsigned long long  Packet2ul;
+typedef __vector long long           Packet2l;
+
+// Z14 has builtin support for float vectors
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+typedef __vector float               Packet4f;
+#else
+typedef struct {
+	Packet2d  v4f[2];
+} Packet4f;
+#endif
+
+typedef union {
+  numext::int32_t   i[4];
+  numext::uint32_t ui[4];
+  numext::int64_t   l[2];
+  numext::uint64_t ul[2];
+  double    d[2];
+  float     f[4];
+  Packet4i  v4i;
+  Packet4ui v4ui;
+  Packet2l  v2l;
+  Packet2ul v2ul;
+  Packet2d  v2d;
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+  Packet4f  v4f;
+#endif
+} Packet;
+
+// We don't want to write the same code all the time, but we need to reuse the constants
+// and it doesn't really work to declare them global, so we define macros instead
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = reinterpret_cast<Packet4i>(vec_splat_s32(X))
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet2d(NAME,X) \
+  Packet2d p2d_##NAME = reinterpret_cast<Packet2d>(vec_splat_s64(X))
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet2l(NAME,X) \
+  Packet2l p2l_##NAME = reinterpret_cast<Packet2l>(vec_splat_s64(X))
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME,X) \
+  Packet2d p2d_##NAME = pset1<Packet2d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2l(NAME,X) \
+  Packet2l p2l_##NAME = pset1<Packet2l>(X)
+
+// These constants are endian-agnostic
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ZERO, 0); //{ 0, 0, 0, 0,}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ONE, 1); //{ 1, 1, 1, 1}
+
+static _EIGEN_DECLARE_CONST_FAST_Packet2d(ZERO, 0);
+static _EIGEN_DECLARE_CONST_FAST_Packet2l(ZERO, 0);
+static _EIGEN_DECLARE_CONST_FAST_Packet2l(ONE, 1);
+
+static Packet2d p2d_ONE = { 1.0, 1.0 };
+static Packet2d p2d_ZERO_ = { numext::bit_cast<double>0x8000000000000000ull),
+                              numext::bit_cast<double>0x8000000000000000ull) };
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+#define _EIGEN_DECLARE_CONST_FAST_Packet4f(NAME,X) \
+  Packet4f p4f_##NAME = reinterpret_cast<Packet4f>(vec_splat_s32(X))
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = reinterpret_cast<Packet4f>(pset1<Packet4i>(X))
+
+static _EIGEN_DECLARE_CONST_FAST_Packet4f(ZERO, 0); //{ 0.0, 0.0, 0.0, 0.0}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS1,-1); //{ -1, -1, -1, -1}
+static Packet4f p4f_MZERO = { 0x80000000, 0x80000000, 0x80000000, 0x80000000};
+#endif
+
+static Packet4i p4i_COUNTDOWN = { 0, 1, 2, 3 };
+static Packet4f p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 };
+static Packet2d p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet16uc>(p2d_ZERO), reinterpret_cast<Packet16uc>(p2d_ONE), 8));
+
+static Packet16uc p16uc_PSET64_HI = { 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 };
+static Packet16uc p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 };
+
+// Mask alignment
+#define _EIGEN_MASK_ALIGNMENT	0xfffffffffffffff0
+
+#define _EIGEN_ALIGNED_PTR(x)	((std::ptrdiff_t)(x) & _EIGEN_MASK_ALIGNMENT)
+
+// Handle endianness properly while loading constants
+// Define global static constants:
+
+static Packet16uc p16uc_FORWARD =   { 0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15 };
+static Packet16uc p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 };
+static Packet16uc p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+
+static Packet16uc p16uc_PSET32_WODD   = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
+static Packet16uc p16uc_PSET32_WEVEN  = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 };
+/*static Packet16uc p16uc_HALF64_0_16 = vec_sld((Packet16uc)p4i_ZERO, vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 3), 8);      //{ 0,0,0,0, 0,0,0,0, 16,16,16,16, 16,16,16,16};
+
+static Packet16uc p16uc_PSET64_HI = (Packet16uc) vec_mergeh((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 };*/
+static Packet16uc p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 8,9,10,11, 12,13,14,15, 8,9,10,11, 12,13,14,15 };
+/*static Packet16uc p16uc_TRANSPOSE64_HI = vec_add(p16uc_PSET64_HI, p16uc_HALF64_0_16);                                         //{ 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23};
+static Packet16uc p16uc_TRANSPOSE64_LO = vec_add(p16uc_PSET64_LO, p16uc_HALF64_0_16);                                         //{ 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31};*/
+static Packet16uc p16uc_TRANSPOSE64_HI = { 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23};
+static Packet16uc p16uc_TRANSPOSE64_LO = { 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31};
+
+static Packet16uc p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8);                                         //{ 4,5,6,7, 0,1,2,3, 12,13,14,15, 8,9,10,11 };
+
+static Packet16uc p16uc_COMPLEX32_REV2 = vec_sld(p16uc_FORWARD, p16uc_FORWARD, 8);                                            //{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+
+
+#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  #define EIGEN_ZVECTOR_PREFETCH(ADDR) __builtin_prefetch(ADDR);
+#else
+  #define EIGEN_ZVECTOR_PREFETCH(ADDR) asm( "   pfd [%[addr]]\n" :: [addr] "r" (ADDR) : "cc" );
+#endif
+
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet4i type;
+  typedef Packet4i half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<float> : default_packet_traits {
+  typedef Packet4f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasAbs = 1,
+    HasSin = 0,
+    HasCos = 0,
+    HasLog = 0,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = 1,
+    HasErf = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 1,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasMin  = 1,
+    HasMax  = 1,
+    HasAbs  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 0,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet4i> { typedef int    type; enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet4i half; };
+template<> struct unpacket_traits<Packet4f> { typedef float  type; enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet4f half; };
+template<> struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet2d half; };
+
+/* Forward declaration */
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4f,4>& kernel);
+ 
+inline std::ostream & operator <<(std::ostream & s, const Packet4i & v)
+{
+  Packet vt;
+  vt.v4i = v;
+  s << vt.i[0] << ", " << vt.i[1] << ", " << vt.i[2] << ", " << vt.i[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4ui & v)
+{
+  Packet vt;
+  vt.v4ui = v;
+  s << vt.ui[0] << ", " << vt.ui[1] << ", " << vt.ui[2] << ", " << vt.ui[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2l & v)
+{
+  Packet vt;
+  vt.v2l = v;
+  s << vt.l[0] << ", " << vt.l[1];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2ul & v)
+{
+  Packet vt;
+  vt.v2ul = v;
+  s << vt.ul[0] << ", " << vt.ul[1] ;
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2d & v)
+{
+  Packet vt;
+  vt.v2d = v;
+  s << vt.d[0] << ", " << vt.d[1];
+  return s;
+}
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+inline std::ostream & operator <<(std::ostream & s, const Packet4f & v)
+{
+  Packet vt;
+  vt.v4f = v;
+  s << vt.f[0] << ", " << vt.f[1] << ", " << vt.f[2] << ", " << vt.f[3];
+  return s;
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int*     from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet *vfrom;
+  vfrom = (Packet *) from;
+  return vfrom->v4i;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet *vfrom;
+  vfrom = (Packet *) from;
+  return vfrom->v2d;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet4i& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  Packet *vto;
+  vto = (Packet *) to;
+  vto->v4i = from;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<double>(double*   to, const Packet2d& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  Packet *vto;
+  vto = (Packet *) to;
+  vto->v2d = from;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from)
+{
+  return vec_splats(from);
+}
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) {
+  return vec_splats(from);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4i>(const int *a,
+                      Packet4i& a0, Packet4i& a1, Packet4i& a2, Packet4i& a3)
+{
+  a3 = pload<Packet4i>(a);
+  a0 = vec_splat(a3, 0);
+  a1 = vec_splat(a3, 1);
+  a2 = vec_splat(a3, 2);
+  a3 = vec_splat(a3, 3);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet2d>(const double *a,
+                      Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+  a1 = pload<Packet2d>(a);
+  a0 = vec_splat(a1, 0);
+  a1 = vec_splat(a1, 1);
+  a3 = pload<Packet2d>(a+2);
+  a2 = vec_splat(a3, 0);
+  a3 = vec_splat(a3, 1);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int, Packet4i>(const int* from, Index stride)
+{
+  int EIGEN_ALIGN16 ai[4];
+  ai[0] = from[0*stride];
+  ai[1] = from[1*stride];
+  ai[2] = from[2*stride];
+  ai[3] = from[3*stride];
+ return pload<Packet4i>(ai);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+  double EIGEN_ALIGN16 af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+ return pload<Packet2d>(af);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<int, Packet4i>(int* to, const Packet4i& from, Index stride)
+{
+  int EIGEN_ALIGN16 ai[4];
+  pstore<int>((int *)ai, from);
+  to[0*stride] = ai[0];
+  to[1*stride] = ai[1];
+  to[2*stride] = ai[2];
+  to[3*stride] = ai[3];
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  double EIGEN_ALIGN16 af[2];
+  pstore<double>(af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a + b); }
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a + b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a - b); }
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a - b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a * b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a * b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a / b); }
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a / b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return (-a); }
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) { return (-a); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd<Packet4i>(pmul<Packet4i>(a, b), c); }
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return vec_madd(a, b, c); }
+
+template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int& a)    { return padd<Packet4i>(pset1<Packet4i>(a), p4i_COUNTDOWN); }
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) { return padd<Packet2d>(pset1<Packet2d>(a), p2d_COUNTDOWN); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_min(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_max(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_or(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_xor(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return pand<Packet4i>(a, vec_nor(b, b)); }
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, vec_nor(b, b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a) { return vec_round(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const  Packet2d& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) { return vec_floor(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int*       from) { return pload<Packet4i>(from); }
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double*    from) { return pload<Packet2d>(from); }
+
+
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int*     from)
+{
+  Packet4i p = pload<Packet4i>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double*   from)
+{
+  Packet2d p = pload<Packet2d>(from);
+  return vec_perm(p, p, p16uc_PSET64_HI);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*        to, const Packet4i& from) { pstore<int>(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double*  to, const Packet2d& from) { pstore<double>(to, from); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int    EIGEN_ALIGN16 x[4]; pstore(x, a); return x[0]; }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { double EIGEN_ALIGN16 x[2]; pstore(x, a); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a)
+{
+  return reinterpret_cast<Packet4i>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a)
+{
+  return reinterpret_cast<Packet2d>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE64));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pabs<Packet4i>(const Packet4i& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pabs<Packet2d>(const Packet2d& a) { return vec_abs(a); }
+
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, sum;
+  b   = vec_sld(a, a, 8);
+  sum = padd<Packet4i>(a, b);
+  b   = vec_sld(sum, sum, 4);
+  sum = padd<Packet4i>(sum, b);
+  return pfirst(sum);
+}
+
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{
+  Packet2d b, sum;
+  b   = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8));
+  sum = padd<Packet2d>(a, b);
+  return pfirst(sum);
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
+{
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  return aux[0] * aux[1] * aux[2] * aux[3];
+}
+
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmul(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
+}
+
+// min
+template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, res;
+  b   = pmin<Packet4i>(a, vec_sld(a, a, 8));
+  res = pmin<Packet4i>(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmin<Packet2d>(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
+}
+
+// max
+template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, res;
+  b = pmax<Packet4i>(a, vec_sld(a, a, 8));
+  res = pmax<Packet4i>(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+// max
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmax<Packet2d>(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4i,4>& kernel) {
+  Packet4i t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  Packet4i t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  Packet4i t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  Packet4i t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2d,2>& kernel) {
+  Packet2d t0 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_HI);
+  Packet2d t1 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_LO);
+  kernel.packet[0] = t0;
+  kernel.packet[1] = t1;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
+  Packet4ui mask = vec_cmpeq(select, reinterpret_cast<Packet4ui>(p4i_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket) {
+  Packet2ul select = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2ul mask = vec_cmpeq(select, reinterpret_cast<Packet2ul>(p2l_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+/* z13 has no vector float support so we emulate that with double
+   z14 has proper vector float support.
+*/
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ < 12)
+/* Helper function to simulate a vec_splat_packet4f
+ */
+template<int element> EIGEN_STRONG_INLINE Packet4f vec_splat_packet4f(const Packet4f&   from)
+{
+  Packet4f splat;
+  switch (element) {
+  case 0:
+    splat.v4f[0] = vec_splat(from.v4f[0], 0);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  case 1:
+    splat.v4f[0] = vec_splat(from.v4f[0], 1);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  case 2:
+    splat.v4f[0] = vec_splat(from.v4f[1], 0);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  case 3:
+    splat.v4f[0] = vec_splat(from.v4f[1], 1);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  }
+  return splat;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float*   from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet4f vfrom;
+  vfrom.v4f[0] = vec_ld2f(&from[0]);
+  vfrom.v4f[1] = vec_ld2f(&from[2]);
+  return vfrom;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet4f& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  vec_st2f(from.v4f[0], &to[0]);
+  vec_st2f(from.v4f[1], &to[2]);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&    from)
+{
+  Packet4f to;
+  to.v4f[0] = pset1<Packet2d>(static_cast<const double&>(from));
+  to.v4f[1] = to.v4f[0];
+  return to;
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  a3 = pload<Packet4f>(a);
+  a0 = vec_splat_packet4f<0>(a3);
+  a1 = vec_splat_packet4f<1>(a3);
+  a2 = vec_splat_packet4f<2>(a3);
+  a3 = vec_splat_packet4f<3>(a3);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  float EIGEN_ALIGN16 ai[4];
+  ai[0] = from[0*stride];
+  ai[1] = from[1*stride];
+  ai[2] = from[2*stride];
+  ai[3] = from[3*stride];
+ return pload<Packet4f>(ai);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  float EIGEN_ALIGN16 ai[4];
+  pstore<float>((float *)ai, from);
+  to[0*stride] = ai[0];
+  to[1*stride] = ai[1];
+  to[2*stride] = ai[2];
+  to[3*stride] = ai[3];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] + b.v4f[0];
+  c.v4f[1] = a.v4f[1] + b.v4f[1];
+  return c;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] - b.v4f[0];
+  c.v4f[1] = a.v4f[1] - b.v4f[1];
+  return c;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] * b.v4f[0];
+  c.v4f[1] = a.v4f[1] * b.v4f[1];
+  return c;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] / b.v4f[0];
+  c.v4f[1] = a.v4f[1] / b.v4f[1];
+  return c;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a)
+{
+  Packet4f c;
+  c.v4f[0] = -a.v4f[0];
+  c.v4f[1] = -a.v4f[1];
+  return c;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
+{
+  Packet4f res;
+  res.v4f[0] = vec_madd(a.v4f[0], b.v4f[0], c.v4f[0]);
+  res.v4f[1] = vec_madd(a.v4f[1], b.v4f[1], c.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pmin(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pmin(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pmax(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pmax(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pand(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pand(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = por(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = por(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pxor(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pxor(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pandnot(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pandnot(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = vec_round(a.v4f[0]);
+  res.v4f[1] = vec_round(a.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const  Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = vec_ceil(a.v4f[0]);
+  res.v4f[1] = vec_ceil(a.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = vec_floor(a.v4f[0]);
+  res.v4f[1] = vec_floor(a.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float*    from)
+{
+  Packet4f p = pload<Packet4f>(from);
+  p.v4f[1] = vec_splat(p.v4f[0], 1);
+  p.v4f[0] = vec_splat(p.v4f[0], 0);
+  return p;
+}
+
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { float  EIGEN_ALIGN16 x[2]; vec_st2f(a.v4f[0], &x[0]); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{
+  Packet4f rev;
+  rev.v4f[0] = preverse<Packet2d>(a.v4f[1]);
+  rev.v4f[1] = preverse<Packet2d>(a.v4f[0]);
+  return rev;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pabs<Packet4f>(const Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = pabs(a.v4f[0]);
+  res.v4f[1] = pabs(a.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  Packet2d sum;
+  sum = padd<Packet2d>(a.v4f[0], a.v4f[1]);
+  double first = predux<Packet2d>(sum);
+  return static_cast<float>(first);
+}
+
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  // Return predux_mul<Packet2d> of the subvectors product
+  return static_cast<float>(pfirst(predux_mul(pmul(a.v4f[0], a.v4f[1]))));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  Packet2d b, res;
+  b   = pmin<Packet2d>(a.v4f[0], a.v4f[1]);
+  res = pmin<Packet2d>(b, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(b), reinterpret_cast<Packet4i>(b), 8)));
+  return static_cast<float>(pfirst(res));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  Packet2d b, res;
+  b   = pmax<Packet2d>(a.v4f[0], a.v4f[1]);
+  res = pmax<Packet2d>(b, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(b), reinterpret_cast<Packet4i>(b), 8)));
+  return static_cast<float>(pfirst(res));
+}
+
+/* Split the Packet4f PacketBlock into 4 Packet2d PacketBlocks and transpose each one
+ */
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  PacketBlock<Packet2d,2> t0,t1,t2,t3;
+  // copy top-left 2x2 Packet2d block
+  t0.packet[0] = kernel.packet[0].v4f[0];
+  t0.packet[1] = kernel.packet[1].v4f[0];
+
+  // copy top-right 2x2 Packet2d block
+  t1.packet[0] = kernel.packet[0].v4f[1];
+  t1.packet[1] = kernel.packet[1].v4f[1];
+
+  // copy bottom-left 2x2 Packet2d block
+  t2.packet[0] = kernel.packet[2].v4f[0];
+  t2.packet[1] = kernel.packet[3].v4f[0];
+
+  // copy bottom-right 2x2 Packet2d block
+  t3.packet[0] = kernel.packet[2].v4f[1];
+  t3.packet[1] = kernel.packet[3].v4f[1];
+
+  // Transpose all 2x2 blocks
+  ptranspose(t0);
+  ptranspose(t1);
+  ptranspose(t2);
+  ptranspose(t3);
+
+  // Copy back transposed blocks, but exchange t1 and t2 due to transposition
+  kernel.packet[0].v4f[0] = t0.packet[0];
+  kernel.packet[0].v4f[1] = t2.packet[0];
+  kernel.packet[1].v4f[0] = t0.packet[1];
+  kernel.packet[1].v4f[1] = t2.packet[1];
+  kernel.packet[2].v4f[0] = t1.packet[0];
+  kernel.packet[2].v4f[1] = t3.packet[0];
+  kernel.packet[3].v4f[0] = t1.packet[1];
+  kernel.packet[3].v4f[1] = t3.packet[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  Packet2ul select_hi = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2ul select_lo = { ifPacket.select[2], ifPacket.select[3] };
+  Packet2ul mask_hi = vec_cmpeq(select_hi, reinterpret_cast<Packet2ul>(p2l_ONE));
+  Packet2ul mask_lo = vec_cmpeq(select_lo, reinterpret_cast<Packet2ul>(p2l_ONE));
+  Packet4f result;
+  result.v4f[0] = vec_sel(elsePacket.v4f[0], thenPacket.v4f[0], mask_hi);
+  result.v4f[1] = vec_sel(elsePacket.v4f[1], thenPacket.v4f[1], mask_lo);
+  return result;
+}
+
+template<> Packet4f EIGEN_STRONG_INLINE pcmp_le<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pcmp_le(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pcmp_le(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> Packet4f EIGEN_STRONG_INLINE pcmp_lt<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pcmp_lt(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pcmp_lt(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> Packet4f EIGEN_STRONG_INLINE pcmp_eq<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pcmp_eq(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pcmp_eq(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+#else
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet *vfrom;
+  vfrom = (Packet *) from;
+  return vfrom->v4f;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  Packet *vto;
+  vto = (Packet *) to;
+  vto->v4f = from;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from)
+{
+  return vec_splats(from);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  a3 = pload<Packet4f>(a);
+  a0 = vec_splat(a3, 0);
+  a1 = vec_splat(a3, 1);
+  a2 = vec_splat(a3, 2);
+  a3 = vec_splat(a3, 3);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  float EIGEN_ALIGN16 af[4];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+  af[2] = from[2*stride];
+  af[3] = from[3*stride];
+ return pload<Packet4f>(af);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  float EIGEN_ALIGN16 af[4];
+  pstore<float>((float*)af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+  to[2*stride] = af[2];
+  to[3*stride] = af[3];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return (a + b); }
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return (a - b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return (a * b); }
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) { return (a / b); }
+template<> EIGEN_STRONG_INLINE Packet4f pnegate<Packet4f>(const Packet4f& a) { return (-a); }
+template<> EIGEN_STRONG_INLINE Packet4f pconj<Packet4f>  (const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4f pmadd<Packet4f>  (const Packet4f& a, const Packet4f& b, const Packet4f& c) { return vec_madd(a, b, c); }
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>   (const Packet4f& a, const Packet4f& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>   (const Packet4f& a, const Packet4f& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>   (const Packet4f& a, const Packet4f& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>    (const Packet4f& a, const Packet4f& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>   (const Packet4f& a, const Packet4f& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_and(a, vec_nor(b, b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f> (const Packet4f& a) { return vec_round(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>  (const Packet4f& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f> (const Packet4f& a) { return vec_floor(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pabs<Packet4f>   (const Packet4f& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; pstore(x, a); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float* from)
+{
+  Packet4f p = pload<Packet4f>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{
+  return reinterpret_cast<Packet4f>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, sum;
+  b   = vec_sld(a, a, 8);
+  sum = padd<Packet4f>(a, b);
+  b   = vec_sld(sum, sum, 4);
+  sum = padd<Packet4f>(sum, b);
+  return pfirst(sum);
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  Packet4f prod;
+  prod = pmul(a, vec_sld(a, a, 8));
+  return pfirst(pmul(prod, vec_sld(prod, prod, 4)));
+}
+
+// min
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, res;
+  b   = pmin<Packet4f>(a, vec_sld(a, a, 8));
+  res = pmin<Packet4f>(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+// max
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, res;
+  b = pmax<Packet4f>(a, vec_sld(a, a, 8));
+  res = pmax<Packet4f>(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  Packet4f t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  Packet4f t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  Packet4f t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  Packet4f t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
+  Packet4ui mask = vec_cmpeq(select, reinterpret_cast<Packet4ui>(p4i_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+#endif
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f> (const float* from) { return pload<Packet4f>(from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet4f& from) { pstore<float>(to, from); }
+template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>  (const float& a)  { return padd<Packet4f>(pset1<Packet4f>(a), p4f_COUNTDOWN); }
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_ZVECTOR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/functors/AssignmentFunctors.h b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/AssignmentFunctors.h
new file mode 100644
index 00000000..bf64ef4e
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/AssignmentFunctors.h
@@ -0,0 +1,177 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ASSIGNMENT_FUNCTORS_H
+#define EIGEN_ASSIGNMENT_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+  
+/** \internal
+  * \brief Template functor for scalar/packet assignment
+  *
+  */
+template<typename DstScalar,typename SrcScalar> struct assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a = b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,b); }
+};
+
+// Empty overload for void type (used by PermutationMatrix)
+template<typename DstScalar> struct assign_op<DstScalar,void> {};
+
+template<typename DstScalar,typename SrcScalar>
+struct functor_traits<assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::Vectorizable && packet_traits<SrcScalar>::Vectorizable
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with addition
+  *
+  */
+template<typename DstScalar,typename SrcScalar> struct add_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(add_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a += b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::padd(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar,typename SrcScalar>
+struct functor_traits<add_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::AddCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasAdd
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with subtraction
+  *
+  */
+template<typename DstScalar,typename SrcScalar> struct sub_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(sub_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a -= b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::psub(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar,typename SrcScalar>
+struct functor_traits<sub_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::AddCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasSub
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with multiplication
+  *
+  */
+template<typename DstScalar, typename SrcScalar=DstScalar>
+struct mul_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(mul_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a *= b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::pmul(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar, typename SrcScalar>
+struct functor_traits<mul_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasMul
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with diviving
+  *
+  */
+template<typename DstScalar, typename SrcScalar=DstScalar> struct div_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(div_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a /= b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::pdiv(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar, typename SrcScalar>
+struct functor_traits<div_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasDiv
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with swapping
+  *
+  * It works as follow. For a non-vectorized evaluation loop, we have:
+  *   for(i) func(A.coeffRef(i), B.coeff(i));
+  * where B is a SwapWrapper expression. The trick is to make SwapWrapper::coeff behaves like a non-const coeffRef.
+  * Actually, SwapWrapper might not even be needed since even if B is a plain expression, since it has to be writable
+  * B.coeff already returns a const reference to the underlying scalar value.
+  * 
+  * The case of a vectorized loop is more tricky:
+  *   for(i,j) func.assignPacket<A_Align>(&A.coeffRef(i,j), B.packet<B_Align>(i,j));
+  * Here, B must be a SwapWrapper whose packet function actually returns a proxy object holding a Scalar*,
+  * the actual alignment and Packet type.
+  *
+  */
+template<typename Scalar> struct swap_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(swap_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Scalar& a, const Scalar& b) const
+  {
+#ifdef EIGEN_GPUCC
+    // FIXME is there some kind of cuda::swap?
+    Scalar t=b; const_cast<Scalar&>(b)=a; a=t;
+#else
+    using std::swap;
+    swap(a,const_cast<Scalar&>(b));
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<swap_assign_op<Scalar> > {
+  enum {
+    Cost = 3 * NumTraits<Scalar>::ReadCost,
+    PacketAccess = 
+    #if defined(EIGEN_VECTORIZE_AVX) && EIGEN_COMP_CLANG && (EIGEN_COMP_CLANG<800 || defined(__apple_build_version__))
+    // This is a partial workaround for a bug in clang generating bad code
+    // when mixing 256/512 bits loads and 128 bits moves.
+    // See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1684
+    //     https://bugs.llvm.org/show_bug.cgi?id=40815
+    0
+    #else
+    packet_traits<Scalar>::Vectorizable
+    #endif
+  };
+};
+
+} // namespace internal
+
+} // namespace Eigen
+
+#endif // EIGEN_ASSIGNMENT_FUNCTORS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/functors/BinaryFunctors.h b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/BinaryFunctors.h
new file mode 100644
index 00000000..63f09ab9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/BinaryFunctors.h
@@ -0,0 +1,541 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BINARY_FUNCTORS_H
+#define EIGEN_BINARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- associative binary functors ----------
+
+template<typename Arg1, typename Arg2>
+struct binary_op_base
+{
+  typedef Arg1 first_argument_type;
+  typedef Arg2 second_argument_type;
+};
+
+/** \internal
+  * \brief Template functor to compute the sum of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::operator+, class VectorwiseOp, DenseBase::sum()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_sum_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_sum_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op)
+#else
+  scalar_sum_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a + b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::padd(a,b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(const Packet& a) const
+  { return internal::predux(a); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_sum_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (int(NumTraits<LhsScalar>::AddCost) + int(NumTraits<RhsScalar>::AddCost)) / 2, // rough estimate!
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasAdd && packet_traits<RhsScalar>::HasAdd
+    // TODO vectorize mixed sum
+  };
+};
+
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool scalar_sum_op<bool,bool>::operator() (const bool& a, const bool& b) const { return a || b; }
+
+
+/** \internal
+  * \brief Template functor to compute the product of two scalars
+  *
+  * \sa class CwiseBinaryOp, Cwise::operator*(), class VectorwiseOp, MatrixBase::redux()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_product_op  : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_product_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op)
+#else
+  scalar_product_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a * b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pmul(a,b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(const Packet& a) const
+  { return internal::predux_mul(a); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_product_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (int(NumTraits<LhsScalar>::MulCost) + int(NumTraits<RhsScalar>::MulCost))/2, // rough estimate!
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul
+    // TODO vectorize mixed product
+  };
+};
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool scalar_product_op<bool,bool>::operator() (const bool& a, const bool& b) const { return a && b; }
+
+
+/** \internal
+  * \brief Template functor to compute the conjugate product of two scalars
+  *
+  * This is a short cut for conj(x) * y which is needed for optimization purpose; in Eigen2 support mode, this becomes x * conj(y)
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_conj_product_op  : binary_op_base<LhsScalar,RhsScalar>
+{
+
+  enum {
+    Conj = NumTraits<LhsScalar>::IsComplex
+  };
+  
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_conj_product_op>::ReturnType result_type;
+  
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_conj_product_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const RhsScalar& b) const
+  { return conj_helper<LhsScalar,RhsScalar,Conj,false>().pmul(a,b); }
+  
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
+  { return conj_helper<Packet,Packet,Conj,false>().pmul(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_conj_product_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = NumTraits<LhsScalar>::MulCost,
+    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the min of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::cwiseMin, class VectorwiseOp, MatrixBase::minCoeff()
+  */
+template<typename LhsScalar,typename RhsScalar, int NaNPropagation>
+struct scalar_min_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_min_op>::ReturnType result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_min_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const RhsScalar& b) const {
+    return internal::pmin<NaNPropagation>(a, b);
+  }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
+  {
+    return internal::pmin<NaNPropagation>(a,b);
+  }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(const Packet& a) const
+  {
+    return internal::predux_min<NaNPropagation>(a);
+  }
+};
+
+template<typename LhsScalar,typename RhsScalar, int NaNPropagation>
+struct functor_traits<scalar_min_op<LhsScalar,RhsScalar, NaNPropagation> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMin
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the max of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::cwiseMax, class VectorwiseOp, MatrixBase::maxCoeff()
+  */
+template<typename LhsScalar,typename RhsScalar, int NaNPropagation>
+struct scalar_max_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_max_op>::ReturnType result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_max_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const RhsScalar& b) const {
+    return internal::pmax<NaNPropagation>(a,b);
+  }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
+  {
+    return internal::pmax<NaNPropagation>(a,b);
+  }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(const Packet& a) const
+  {
+    return internal::predux_max<NaNPropagation>(a);
+  }
+};
+
+template<typename LhsScalar,typename RhsScalar, int NaNPropagation>
+struct functor_traits<scalar_max_op<LhsScalar,RhsScalar, NaNPropagation> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMax
+  };
+};
+
+/** \internal
+  * \brief Template functors for comparison of two scalars
+  * \todo Implement packet-comparisons
+  */
+template<typename LhsScalar, typename RhsScalar, ComparisonName cmp> struct scalar_cmp_op;
+
+template<typename LhsScalar, typename RhsScalar, ComparisonName cmp>
+struct functor_traits<scalar_cmp_op<LhsScalar,RhsScalar, cmp> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = false
+  };
+};
+
+template<ComparisonName Cmp, typename LhsScalar, typename RhsScalar>
+struct result_of<scalar_cmp_op<LhsScalar, RhsScalar, Cmp>(LhsScalar,RhsScalar)> {
+  typedef bool type;
+};
+
+
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_EQ> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a==b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_LT> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_LE> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<=b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_GT> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_GE> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>=b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_UNORD> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return !(a<=b || b<=a);}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_NEQ> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a!=b;}
+};
+
+/** \internal
+  * \brief Template functor to compute the hypot of two \b positive \b and \b real scalars
+  *
+  * \sa MatrixBase::stableNorm(), class Redux
+  */
+template<typename Scalar>
+struct scalar_hypot_op<Scalar,Scalar> : binary_op_base<Scalar,Scalar>
+{
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_hypot_op)
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar &x, const Scalar &y) const
+  {
+    // This functor is used by hypotNorm only for which it is faster to first apply abs
+    // on all coefficients prior to reduction through hypot.
+    // This way we avoid calling abs on positive and real entries, and this also permits
+    // to seamlessly handle complexes. Otherwise we would have to handle both real and complexes
+    // through the same functor...
+    return internal::positive_real_hypot(x,y);
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_hypot_op<Scalar,Scalar> > {
+  enum
+  {
+    Cost = 3 * NumTraits<Scalar>::AddCost +
+           2 * NumTraits<Scalar>::MulCost +
+           2 * scalar_div_cost<Scalar,false>::value,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the pow of two scalars
+  * See the specification of pow in https://en.cppreference.com/w/cpp/numeric/math/pow
+  */
+template<typename Scalar, typename Exponent>
+struct scalar_pow_op  : binary_op_base<Scalar,Exponent>
+{
+  typedef typename ScalarBinaryOpTraits<Scalar,Exponent,scalar_pow_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_pow_op)
+#else
+  scalar_pow_op() {
+    typedef Scalar LhsScalar;
+    typedef Exponent RhsScalar;
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+
+  EIGEN_DEVICE_FUNC
+  inline result_type operator() (const Scalar& a, const Exponent& b) const { return numext::pow(a, b); }
+
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  {
+    return generic_pow(a,b);
+  }
+};
+
+template<typename Scalar, typename Exponent>
+struct functor_traits<scalar_pow_op<Scalar,Exponent> > {
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = (!NumTraits<Scalar>::IsComplex && !NumTraits<Scalar>::IsInteger &&
+                    packet_traits<Scalar>::HasExp && packet_traits<Scalar>::HasLog &&
+                    packet_traits<Scalar>::HasRound && packet_traits<Scalar>::HasCmp &&
+                    // Temporarly disable packet access for half/bfloat16 until
+                    // accuracy is improved.
+                    !is_same<Scalar, half>::value && !is_same<Scalar, bfloat16>::value
+                    )
+  };
+};
+
+//---------- non associative binary functors ----------
+
+/** \internal
+  * \brief Template functor to compute the difference of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::operator-
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_difference_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_difference_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op)
+#else
+  scalar_difference_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a - b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::psub(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_difference_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (int(NumTraits<LhsScalar>::AddCost) + int(NumTraits<RhsScalar>::AddCost)) / 2,
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasSub && packet_traits<RhsScalar>::HasSub
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the quotient of two scalars
+  *
+  * \sa class CwiseBinaryOp, Cwise::operator/()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_quotient_op  : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_quotient_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op)
+#else
+  scalar_quotient_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a / b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pdiv(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_quotient_op<LhsScalar,RhsScalar> > {
+  typedef typename scalar_quotient_op<LhsScalar,RhsScalar>::result_type result_type;
+  enum {
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasDiv && packet_traits<RhsScalar>::HasDiv,
+    Cost = scalar_div_cost<result_type,PacketAccess>::value
+  };
+};
+
+
+
+/** \internal
+  * \brief Template functor to compute the and of two booleans
+  *
+  * \sa class CwiseBinaryOp, ArrayBase::operator&&
+  */
+struct scalar_boolean_and_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_and_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a && b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pand(a,b); }
+};
+template<> struct functor_traits<scalar_boolean_and_op> {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = true
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the or of two booleans
+  *
+  * \sa class CwiseBinaryOp, ArrayBase::operator||
+  */
+struct scalar_boolean_or_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_or_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a || b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::por(a,b); }
+};
+template<> struct functor_traits<scalar_boolean_or_op> {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = true
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the xor of two booleans
+ *
+ * \sa class CwiseBinaryOp, ArrayBase::operator^
+ */
+struct scalar_boolean_xor_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_xor_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a ^ b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pxor(a,b); }
+};
+template<> struct functor_traits<scalar_boolean_xor_op> {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = true
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the absolute difference of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::absolute_difference
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_absolute_difference_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_absolute_difference_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_absolute_difference_op)
+#else
+  scalar_absolute_difference_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const
+  { return numext::absdiff(a,b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pabsdiff(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_absolute_difference_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasAbsDiff
+  };
+};
+
+
+
+//---------- binary functors bound to a constant, thus appearing as a unary functor ----------
+
+// The following two classes permits to turn any binary functor into a unary one with one argument bound to a constant value.
+// They are analogues to std::binder1st/binder2nd but with the following differences:
+//  - they are compatible with packetOp
+//  - they are portable across C++ versions (the std::binder* are deprecated in C++11)
+template<typename BinaryOp> struct bind1st_op : BinaryOp {
+
+  typedef typename BinaryOp::first_argument_type  first_argument_type;
+  typedef typename BinaryOp::second_argument_type second_argument_type;
+  typedef typename BinaryOp::result_type          result_type;
+
+  EIGEN_DEVICE_FUNC explicit bind1st_op(const first_argument_type &val) : m_value(val) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const second_argument_type& b) const { return BinaryOp::operator()(m_value,b); }
+
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& b) const
+  { return BinaryOp::packetOp(internal::pset1<Packet>(m_value), b); }
+
+  first_argument_type m_value;
+};
+template<typename BinaryOp> struct functor_traits<bind1st_op<BinaryOp> > : functor_traits<BinaryOp> {};
+
+
+template<typename BinaryOp> struct bind2nd_op : BinaryOp {
+
+  typedef typename BinaryOp::first_argument_type  first_argument_type;
+  typedef typename BinaryOp::second_argument_type second_argument_type;
+  typedef typename BinaryOp::result_type          result_type;
+
+  EIGEN_DEVICE_FUNC explicit bind2nd_op(const second_argument_type &val) : m_value(val) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const first_argument_type& a) const { return BinaryOp::operator()(a,m_value); }
+
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return BinaryOp::packetOp(a,internal::pset1<Packet>(m_value)); }
+
+  second_argument_type m_value;
+};
+template<typename BinaryOp> struct functor_traits<bind2nd_op<BinaryOp> > : functor_traits<BinaryOp> {};
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BINARY_FUNCTORS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/functors/NullaryFunctors.h b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/NullaryFunctors.h
new file mode 100644
index 00000000..192f225d
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/NullaryFunctors.h
@@ -0,0 +1,189 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NULLARY_FUNCTORS_H
+#define EIGEN_NULLARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Scalar>
+struct scalar_constant_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_constant_op(const scalar_constant_op& other) : m_other(other.m_other) { }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_constant_op(const Scalar& other) : m_other(other) { }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() () const { return m_other; }
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const PacketType packetOp() const { return internal::pset1<PacketType>(m_other); }
+  const Scalar m_other;
+};
+template<typename Scalar>
+struct functor_traits<scalar_constant_op<Scalar> >
+{ enum { Cost = 0 /* as the constant value should be loaded in register only once for the whole expression */,
+         PacketAccess = packet_traits<Scalar>::Vectorizable, IsRepeatable = true }; };
+
+template<typename Scalar> struct scalar_identity_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op)
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType row, IndexType col) const { return row==col ? Scalar(1) : Scalar(0); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_identity_op<Scalar> >
+{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = false, IsRepeatable = true }; };
+
+template <typename Scalar, bool IsInteger> struct linspaced_op_impl;
+
+template <typename Scalar>
+struct linspaced_op_impl<Scalar,/*IsInteger*/false>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  EIGEN_DEVICE_FUNC linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps) :
+    m_low(low), m_high(high), m_size1(num_steps==1 ? 1 : num_steps-1), m_step(num_steps==1 ? Scalar() : Scalar((high-low)/RealScalar(num_steps-1))),
+    m_flip(numext::abs(high)<numext::abs(low))
+  {}
+
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType i) const {
+    if(m_flip)
+      return (i==0)? m_low : Scalar(m_high - RealScalar(m_size1-i)*m_step);
+    else
+      return (i==m_size1)? m_high : Scalar(m_low + RealScalar(i)*m_step);
+  }
+
+  template<typename Packet, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const
+  {
+    // Principle:
+    // [low, ..., low] + ( [step, ..., step] * ( [i, ..., i] + [0, ..., size] ) )
+    if(m_flip)
+    {
+      Packet pi = plset<Packet>(Scalar(i-m_size1));
+      Packet res = padd(pset1<Packet>(m_high), pmul(pset1<Packet>(m_step), pi));
+      if (EIGEN_PREDICT_TRUE(i != 0)) return res;
+      Packet mask = pcmp_lt(pset1<Packet>(0), plset<Packet>(0));
+      return pselect<Packet>(mask, res, pset1<Packet>(m_low));
+    }
+    else
+    {
+      Packet pi = plset<Packet>(Scalar(i));
+      Packet res = padd(pset1<Packet>(m_low), pmul(pset1<Packet>(m_step), pi));
+      if(EIGEN_PREDICT_TRUE(i != m_size1-unpacket_traits<Packet>::size+1)) return res;
+      Packet mask = pcmp_lt(plset<Packet>(0), pset1<Packet>(unpacket_traits<Packet>::size-1));
+      return pselect<Packet>(mask, res, pset1<Packet>(m_high));
+    }
+  }
+
+  const Scalar m_low;
+  const Scalar m_high;
+  const Index m_size1;
+  const Scalar m_step;
+  const bool m_flip;
+};
+
+template <typename Scalar>
+struct linspaced_op_impl<Scalar,/*IsInteger*/true>
+{
+  EIGEN_DEVICE_FUNC linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps) :
+    m_low(low),
+    m_multiplier((high-low)/convert_index<Scalar>(num_steps<=1 ? 1 : num_steps-1)),
+    m_divisor(convert_index<Scalar>((high>=low?num_steps:-num_steps)+(high-low))/((numext::abs(high-low)+1)==0?1:(numext::abs(high-low)+1))),
+    m_use_divisor(num_steps>1 && (numext::abs(high-low)+1)<num_steps)
+  {}
+
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar operator() (IndexType i) const
+  {
+    if(m_use_divisor) return m_low + convert_index<Scalar>(i)/m_divisor;
+    else              return m_low + convert_index<Scalar>(i)*m_multiplier;
+  }
+
+  const Scalar m_low;
+  const Scalar m_multiplier;
+  const Scalar m_divisor;
+  const bool m_use_divisor;
+};
+
+// ----- Linspace functor ----------------------------------------------------------------
+
+// Forward declaration (we default to random access which does not really give
+// us a speed gain when using packet access but it allows to use the functor in
+// nested expressions).
+template <typename Scalar> struct linspaced_op;
+template <typename Scalar> struct functor_traits< linspaced_op<Scalar> >
+{
+  enum
+  {
+    Cost = 1,
+    PacketAccess =   (!NumTraits<Scalar>::IsInteger) && packet_traits<Scalar>::HasSetLinear && packet_traits<Scalar>::HasBlend,
+                  /*&& ((!NumTraits<Scalar>::IsInteger) || packet_traits<Scalar>::HasDiv),*/ // <- vectorization for integer is currently disabled
+    IsRepeatable = true
+  };
+};
+template <typename Scalar> struct linspaced_op
+{
+  EIGEN_DEVICE_FUNC linspaced_op(const Scalar& low, const Scalar& high, Index num_steps)
+    : impl((num_steps==1 ? high : low),high,num_steps)
+  {}
+
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType i) const { return impl(i); }
+
+  template<typename Packet,typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const { return impl.template packetOp<Packet>(i); }
+
+  // This proxy object handles the actual required temporaries and the different
+  // implementations (integer vs. floating point).
+  const linspaced_op_impl<Scalar,NumTraits<Scalar>::IsInteger> impl;
+};
+
+// Linear access is automatically determined from the operator() prototypes available for the given functor.
+// If it exposes an operator()(i,j), then we assume the i and j coefficients are required independently
+// and linear access is not possible. In all other cases, linear access is enabled.
+// Users should not have to deal with this structure.
+template<typename Functor> struct functor_has_linear_access { enum { ret = !has_binary_operator<Functor>::value }; };
+
+// For unreliable compilers, let's specialize the has_*ary_operator
+// helpers so that at least built-in nullary functors work fine.
+#if !( (EIGEN_COMP_MSVC>1600) || (EIGEN_GNUC_AT_LEAST(4,8)) || (EIGEN_COMP_ICC>=1600))
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 1}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 0}; };
+
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 1}; };
+
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<linspaced_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<linspaced_op<Scalar>,IndexType> { enum { value = 1}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<linspaced_op<Scalar>,IndexType> { enum { value = 0}; };
+
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 1}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 0}; };
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_NULLARY_FUNCTORS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/functors/StlFunctors.h b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/StlFunctors.h
new file mode 100644
index 00000000..4570c9b6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/StlFunctors.h
@@ -0,0 +1,166 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STL_FUNCTORS_H
+#define EIGEN_STL_FUNCTORS_H
+
+namespace Eigen {
+
+// Portable replacements for certain functors.
+namespace numext {
+
+template<typename T = void>
+struct equal_to {
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC bool operator()(const T& lhs, const T& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+template<typename T = void>
+struct not_equal_to {
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC bool operator()(const T& lhs, const T& rhs) const {
+    return lhs != rhs;
+  }
+};
+
+}
+
+
+namespace internal {
+
+// default functor traits for STL functors:
+
+template<typename T>
+struct functor_traits<std::multiplies<T> >
+{ enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::divides<T> >
+{ enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::plus<T> >
+{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::minus<T> >
+{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::negate<T> >
+{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::logical_or<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::logical_and<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::logical_not<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::greater<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::less<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::greater_equal<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::less_equal<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::equal_to<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<numext::equal_to<T> >
+  : functor_traits<std::equal_to<T> > {};
+
+template<typename T>
+struct functor_traits<std::not_equal_to<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<numext::not_equal_to<T> >
+  : functor_traits<std::not_equal_to<T> > {};
+
+#if (EIGEN_COMP_CXXVER < 11)
+// std::binder* are deprecated since c++11 and will be removed in c++17
+template<typename T>
+struct functor_traits<std::binder2nd<T> >
+{ enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::binder1st<T> >
+{ enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; };
+#endif
+
+#if (EIGEN_COMP_CXXVER < 17)
+// std::unary_negate is deprecated since c++17 and will be removed in c++20
+template<typename T>
+struct functor_traits<std::unary_negate<T> >
+{ enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; };
+
+// std::binary_negate is deprecated since c++17 and will be removed in c++20
+template<typename T>
+struct functor_traits<std::binary_negate<T> >
+{ enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; };
+#endif
+
+#ifdef EIGEN_STDEXT_SUPPORT
+
+template<typename T0,typename T1>
+struct functor_traits<std::project1st<T0,T1> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::project2nd<T0,T1> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::select2nd<std::pair<T0,T1> > >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::select1st<std::pair<T0,T1> > >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::unary_compose<T0,T1> >
+{ enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost, PacketAccess = false }; };
+
+template<typename T0,typename T1,typename T2>
+struct functor_traits<std::binary_compose<T0,T1,T2> >
+{ enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost + functor_traits<T2>::Cost, PacketAccess = false }; };
+
+#endif // EIGEN_STDEXT_SUPPORT
+
+// allow to add new functors and specializations of functor_traits from outside Eigen.
+// this macro is really needed because functor_traits must be specialized after it is declared but before it is used...
+#ifdef EIGEN_FUNCTORS_PLUGIN
+#include EIGEN_FUNCTORS_PLUGIN
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_STL_FUNCTORS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/functors/TernaryFunctors.h b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/TernaryFunctors.h
new file mode 100644
index 00000000..b254e96c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/TernaryFunctors.h
@@ -0,0 +1,25 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TERNARY_FUNCTORS_H
+#define EIGEN_TERNARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- associative ternary functors ----------
+
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TERNARY_FUNCTORS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/functors/UnaryFunctors.h b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/UnaryFunctors.h
new file mode 100644
index 00000000..16136d18
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/functors/UnaryFunctors.h
@@ -0,0 +1,1131 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UNARY_FUNCTORS_H
+#define EIGEN_UNARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+  * \brief Template functor to compute the opposite of a scalar
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::operator-
+  */
+template<typename Scalar> struct scalar_opposite_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_opposite_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return -a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::pnegate(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_opposite_op<Scalar> >
+{ enum {
+    Cost = NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasNegate };
+};
+
+/** \internal
+  * \brief Template functor to compute the absolute value of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::abs
+  */
+template<typename Scalar> struct scalar_abs_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return numext::abs(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::pabs(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_abs_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasAbs
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the score of a scalar, to chose a pivot
+  *
+  * \sa class CwiseUnaryOp
+  */
+template<typename Scalar> struct scalar_score_coeff_op : scalar_abs_op<Scalar>
+{
+  typedef void Score_is_abs;
+};
+template<typename Scalar>
+struct functor_traits<scalar_score_coeff_op<Scalar> > : functor_traits<scalar_abs_op<Scalar> > {};
+
+/* Avoid recomputing abs when we know the score and they are the same. Not a true Eigen functor.  */
+template<typename Scalar, typename=void> struct abs_knowing_score
+{
+  EIGEN_EMPTY_STRUCT_CTOR(abs_knowing_score)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  template<typename Score>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a, const Score&) const { return numext::abs(a); }
+};
+template<typename Scalar> struct abs_knowing_score<Scalar, typename scalar_score_coeff_op<Scalar>::Score_is_abs>
+{
+  EIGEN_EMPTY_STRUCT_CTOR(abs_knowing_score)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  template<typename Scal>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scal&, const result_type& a) const { return a; }
+};
+
+/** \internal
+  * \brief Template functor to compute the squared absolute value of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::abs2
+  */
+template<typename Scalar> struct scalar_abs2_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return numext::abs2(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::pmul(a,a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_abs2_op<Scalar> >
+{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasAbs2 }; };
+
+/** \internal
+  * \brief Template functor to compute the conjugate of a complex value
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::conjugate()
+  */
+template<typename Scalar> struct scalar_conjugate_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_conjugate_op)
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::conj(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const { return internal::pconj(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_conjugate_op<Scalar> >
+{
+  enum {
+    Cost = 0,
+    // Yes the cost is zero even for complexes because in most cases for which
+    // the cost is used, conjugation turns to be a no-op. Some examples:
+    //   cost(a*conj(b)) == cost(a*b)
+    //   cost(a+conj(b)) == cost(a+b)
+    //   <etc.
+    // If we don't set it to zero, then:
+    //   A.conjugate().lazyProduct(B.conjugate())
+    // will bake its operands. We definitely don't want that!
+    PacketAccess = packet_traits<Scalar>::HasConj
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the phase angle of a complex
+  *
+  * \sa class CwiseUnaryOp, Cwise::arg
+  */
+template<typename Scalar> struct scalar_arg_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_arg_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return numext::arg(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::parg(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_arg_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::IsComplex ? 5 * NumTraits<Scalar>::MulCost : NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasArg
+  };
+};
+/** \internal
+  * \brief Template functor to cast a scalar to another type
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::cast()
+  */
+template<typename Scalar, typename NewType>
+struct scalar_cast_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef NewType result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return cast<Scalar, NewType>(a); }
+};
+template<typename Scalar, typename NewType>
+struct functor_traits<scalar_cast_op<Scalar,NewType> >
+{ enum { Cost = is_same<Scalar, NewType>::value ? 0 : NumTraits<NewType>::AddCost, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to arithmetically shift a scalar right by a number of bits
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::shift_right()
+  */
+template<typename Scalar, int N>
+struct scalar_shift_right_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_shift_right_op)
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const
+  { return a >> N; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::parithmetic_shift_right<N>(a); }
+};
+template<typename Scalar, int N>
+struct functor_traits<scalar_shift_right_op<Scalar,N> >
+{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasShift }; };
+
+/** \internal
+  * \brief Template functor to logically shift a scalar left by a number of bits
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::shift_left()
+  */
+template<typename Scalar, int N>
+struct scalar_shift_left_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_shift_left_op)
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const
+  { return a << N; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::plogical_shift_left<N>(a); }
+};
+template<typename Scalar, int N>
+struct functor_traits<scalar_shift_left_op<Scalar,N> >
+{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasShift }; };
+
+/** \internal
+  * \brief Template functor to extract the real part of a complex
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::real()
+  */
+template<typename Scalar>
+struct scalar_real_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_real_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::real(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_real_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to extract the imaginary part of a complex
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::imag()
+  */
+template<typename Scalar>
+struct scalar_imag_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::imag(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_imag_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to extract the real part of a complex as a reference
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::real()
+  */
+template<typename Scalar>
+struct scalar_real_ref_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_real_ref_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return numext::real_ref(*const_cast<Scalar*>(&a)); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_real_ref_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to extract the imaginary part of a complex as a reference
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::imag()
+  */
+template<typename Scalar>
+struct scalar_imag_ref_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_ref_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return numext::imag_ref(*const_cast<Scalar*>(&a)); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_imag_ref_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  *
+  * \brief Template functor to compute the exponential of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::exp()
+  */
+template<typename Scalar> struct scalar_exp_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::exp(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_exp_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasExp,
+    // The following numbers are based on the AVX implementation.
+#ifdef EIGEN_VECTORIZE_FMA
+    // Haswell can issue 2 add/mul/madd per cycle.
+    Cost =
+    (sizeof(Scalar) == 4
+     // float: 8 pmadd, 4 pmul, 2 padd/psub, 6 other
+     ? (8 * NumTraits<Scalar>::AddCost + 6 * NumTraits<Scalar>::MulCost)
+     // double: 7 pmadd, 5 pmul, 3 padd/psub, 1 div,  13 other
+     : (14 * NumTraits<Scalar>::AddCost +
+        6 * NumTraits<Scalar>::MulCost +
+        scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value))
+#else
+    Cost =
+    (sizeof(Scalar) == 4
+     // float: 7 pmadd, 6 pmul, 4 padd/psub, 10 other
+     ? (21 * NumTraits<Scalar>::AddCost + 13 * NumTraits<Scalar>::MulCost)
+     // double: 7 pmadd, 5 pmul, 3 padd/psub, 1 div,  13 other
+     : (23 * NumTraits<Scalar>::AddCost +
+        12 * NumTraits<Scalar>::MulCost +
+        scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value))
+#endif
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the exponential of a scalar - 1.
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::expm1()
+  */
+template<typename Scalar> struct scalar_expm1_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_expm1_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::expm1(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pexpm1(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_expm1_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasExpm1,
+    Cost = functor_traits<scalar_exp_op<Scalar> >::Cost // TODO measure cost of expm1
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the logarithm of a scalar
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::log()
+  */
+template<typename Scalar> struct scalar_log_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::log(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_log_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasLog,
+    Cost =
+    (PacketAccess
+     // The following numbers are based on the AVX implementation.
+#ifdef EIGEN_VECTORIZE_FMA
+     // 8 pmadd, 6 pmul, 8 padd/psub, 16 other, can issue 2 add/mul/madd per cycle.
+     ? (20 * NumTraits<Scalar>::AddCost + 7 * NumTraits<Scalar>::MulCost)
+#else
+     // 8 pmadd, 6 pmul, 8 padd/psub, 20 other
+     ? (36 * NumTraits<Scalar>::AddCost + 14 * NumTraits<Scalar>::MulCost)
+#endif
+     // Measured cost of std::log.
+     : sizeof(Scalar)==4 ? 40 : 85)
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the logarithm of 1 plus a scalar value
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::log1p()
+  */
+template<typename Scalar> struct scalar_log1p_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log1p_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::log1p(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog1p(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_log1p_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasLog1p,
+    Cost = functor_traits<scalar_log_op<Scalar> >::Cost // TODO measure cost of log1p
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the base-10 logarithm of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::log10()
+  */
+template<typename Scalar> struct scalar_log10_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log10_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { EIGEN_USING_STD(log10) return log10(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog10(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_log10_op<Scalar> >
+{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog10 }; };
+
+/** \internal
+  *
+  * \brief Template functor to compute the base-2 logarithm of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::log2()
+  */
+template<typename Scalar> struct scalar_log2_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log2_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return Scalar(EIGEN_LOG2E) * numext::log(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog2(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_log2_op<Scalar> >
+{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog }; };
+
+/** \internal
+  * \brief Template functor to compute the square root of a scalar
+  * \sa class CwiseUnaryOp, Cwise::sqrt()
+  */
+template<typename Scalar> struct scalar_sqrt_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::sqrt(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_sqrt_op<Scalar> > {
+  enum {
+#if EIGEN_FAST_MATH
+    // The following numbers are based on the AVX implementation.
+    Cost = (sizeof(Scalar) == 8 ? 28
+                                // 4 pmul, 1 pmadd, 3 other
+                                : (3 * NumTraits<Scalar>::AddCost +
+                                   5 * NumTraits<Scalar>::MulCost)),
+#else
+    // The following numbers are based on min VSQRT throughput on Haswell.
+    Cost = (sizeof(Scalar) == 8 ? 28 : 14),
+#endif
+    PacketAccess = packet_traits<Scalar>::HasSqrt
+  };
+};
+
+// Boolean specialization to eliminate -Wimplicit-conversion-floating-point-to-bool warnings.
+template<> struct scalar_sqrt_op<bool> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline bool operator() (const bool& a) const { return a; }
+  template <typename Packet>
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return a; }
+};
+template <>
+struct functor_traits<scalar_sqrt_op<bool> > {
+  enum { Cost = 1, PacketAccess = packet_traits<bool>::Vectorizable };
+};
+
+/** \internal
+  * \brief Template functor to compute the reciprocal square root of a scalar
+  * \sa class CwiseUnaryOp, Cwise::rsqrt()
+  */
+template<typename Scalar> struct scalar_rsqrt_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_rsqrt_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::rsqrt(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::prsqrt(a); }
+};
+
+template<typename Scalar>
+struct functor_traits<scalar_rsqrt_op<Scalar> >
+{ enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasRsqrt
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the cosine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::cos()
+  */
+template<typename Scalar> struct scalar_cos_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return numext::cos(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_cos_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasCos
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the sine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::sin()
+  */
+template<typename Scalar> struct scalar_sin_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::sin(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_sin_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasSin
+  };
+};
+
+
+/** \internal
+  * \brief Template functor to compute the tan of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::tan()
+  */
+template<typename Scalar> struct scalar_tan_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::tan(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_tan_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasTan
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the arc cosine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::acos()
+  */
+template<typename Scalar> struct scalar_acos_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::acos(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pacos(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_acos_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasACos
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the arc sine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::asin()
+  */
+template<typename Scalar> struct scalar_asin_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::asin(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pasin(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_asin_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasASin
+  };
+};
+
+
+/** \internal
+  * \brief Template functor to compute the atan of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::atan()
+  */
+template<typename Scalar> struct scalar_atan_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_atan_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::atan(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::patan(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_atan_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasATan
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the tanh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::tanh()
+  */
+template <typename Scalar>
+struct scalar_tanh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_tanh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator()(const Scalar& a) const { return numext::tanh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& x) const { return ptanh(x); }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_tanh_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasTanh,
+    Cost = ( (EIGEN_FAST_MATH && is_same<Scalar,float>::value)
+// The following numbers are based on the AVX implementation,
+#ifdef EIGEN_VECTORIZE_FMA
+                // Haswell can issue 2 add/mul/madd per cycle.
+                // 9 pmadd, 2 pmul, 1 div, 2 other
+                ? (2 * NumTraits<Scalar>::AddCost +
+                   6 * NumTraits<Scalar>::MulCost +
+                   scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value)
+#else
+                ? (11 * NumTraits<Scalar>::AddCost +
+                   11 * NumTraits<Scalar>::MulCost +
+                   scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value)
+#endif
+                // This number assumes a naive implementation of tanh
+                : (6 * NumTraits<Scalar>::AddCost +
+                   3 * NumTraits<Scalar>::MulCost +
+                   2 * scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value +
+                   functor_traits<scalar_exp_op<Scalar> >::Cost))
+  };
+};
+
+#if EIGEN_HAS_CXX11_MATH
+/** \internal
+  * \brief Template functor to compute the atanh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::atanh()
+  */
+template <typename Scalar>
+struct scalar_atanh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_atanh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator()(const Scalar& a) const { return numext::atanh(a); }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_atanh_op<Scalar> > {
+  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
+};
+#endif
+
+/** \internal
+  * \brief Template functor to compute the sinh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::sinh()
+  */
+template<typename Scalar> struct scalar_sinh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sinh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::sinh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psinh(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_sinh_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasSinh
+  };
+};
+
+#if EIGEN_HAS_CXX11_MATH
+/** \internal
+  * \brief Template functor to compute the asinh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::asinh()
+  */
+template <typename Scalar>
+struct scalar_asinh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_asinh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator()(const Scalar& a) const { return numext::asinh(a); }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_asinh_op<Scalar> > {
+  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
+};
+#endif
+
+/** \internal
+  * \brief Template functor to compute the cosh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::cosh()
+  */
+template<typename Scalar> struct scalar_cosh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cosh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::cosh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pcosh(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_cosh_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasCosh
+  };
+};
+
+#if EIGEN_HAS_CXX11_MATH
+/** \internal
+  * \brief Template functor to compute the acosh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::acosh()
+  */
+template <typename Scalar>
+struct scalar_acosh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_acosh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator()(const Scalar& a) const { return numext::acosh(a); }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_acosh_op<Scalar> > {
+  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
+};
+#endif
+
+/** \internal
+  * \brief Template functor to compute the inverse of a scalar
+  * \sa class CwiseUnaryOp, Cwise::inverse()
+  */
+template<typename Scalar>
+struct scalar_inverse_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_inverse_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return internal::pdiv(pset1<Packet>(Scalar(1)),a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_inverse_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasDiv,
+    Cost = scalar_div_cost<Scalar, PacketAccess>::value
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the square of a scalar
+  * \sa class CwiseUnaryOp, Cwise::square()
+  */
+template<typename Scalar>
+struct scalar_square_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return a*a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return internal::pmul(a,a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_square_op<Scalar> >
+{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
+
+// Boolean specialization to avoid -Wint-in-bool-context warnings on GCC.
+template<>
+struct scalar_square_op<bool> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op)
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline bool operator() (const bool& a) const { return a; }
+  template<typename Packet>
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return a; }
+};
+template<>
+struct functor_traits<scalar_square_op<bool> >
+{ enum { Cost = 0, PacketAccess = packet_traits<bool>::Vectorizable }; };
+
+/** \internal
+  * \brief Template functor to compute the cube of a scalar
+  * \sa class CwiseUnaryOp, Cwise::cube()
+  */
+template<typename Scalar>
+struct scalar_cube_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return a*a*a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return internal::pmul(a,pmul(a,a)); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_cube_op<Scalar> >
+{ enum { Cost = 2*NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
+
+// Boolean specialization to avoid -Wint-in-bool-context warnings on GCC.
+template<>
+struct scalar_cube_op<bool> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op)
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline bool operator() (const bool& a) const { return a; }
+  template<typename Packet>
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return a; }
+};
+template<>
+struct functor_traits<scalar_cube_op<bool> >
+{ enum { Cost = 0, PacketAccess = packet_traits<bool>::Vectorizable }; };
+
+/** \internal
+  * \brief Template functor to compute the rounded value of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::round()
+  */
+template<typename Scalar> struct scalar_round_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_round_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::round(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pround(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_round_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasRound
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the floor of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::floor()
+  */
+template<typename Scalar> struct scalar_floor_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_floor_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::floor(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pfloor(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_floor_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasFloor
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the rounded (with current rounding mode)  value of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::rint()
+  */
+template<typename Scalar> struct scalar_rint_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_rint_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::rint(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::print(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_rint_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasRint
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the ceil of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::ceil()
+  */
+template<typename Scalar> struct scalar_ceil_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_ceil_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::ceil(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pceil(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_ceil_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasCeil
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute whether a scalar is NaN
+  * \sa class CwiseUnaryOp, ArrayBase::isnan()
+  */
+template<typename Scalar> struct scalar_isnan_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isnan_op)
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const {
+#if defined(SYCL_DEVICE_ONLY)
+    return numext::isnan(a);
+#else
+    return (numext::isnan)(a);
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_isnan_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to check whether a scalar is +/-inf
+  * \sa class CwiseUnaryOp, ArrayBase::isinf()
+  */
+template<typename Scalar> struct scalar_isinf_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isinf_op)
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const {
+#if defined(SYCL_DEVICE_ONLY)
+    return numext::isinf(a);
+#else
+    return (numext::isinf)(a);
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_isinf_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to check whether a scalar has a finite value
+  * \sa class CwiseUnaryOp, ArrayBase::isfinite()
+  */
+template<typename Scalar> struct scalar_isfinite_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isfinite_op)
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const {
+#if defined(SYCL_DEVICE_ONLY)
+    return numext::isfinite(a);
+#else
+    return (numext::isfinite)(a);
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_isfinite_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the logical not of a boolean
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::operator!
+  */
+template<typename Scalar> struct scalar_boolean_not_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_not_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a) const { return !a; }
+};
+template<typename Scalar>
+struct functor_traits<scalar_boolean_not_op<Scalar> > {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the signum of a scalar
+  * \sa class CwiseUnaryOp, Cwise::sign()
+  */
+template<typename Scalar,bool is_complex=(NumTraits<Scalar>::IsComplex!=0), bool is_integer=(NumTraits<Scalar>::IsInteger!=0) > struct scalar_sign_op;
+template<typename Scalar>
+struct scalar_sign_op<Scalar, false, true> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sign_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
+  {
+      return Scalar( (a>Scalar(0)) - (a<Scalar(0)) );
+  }
+  //TODO
+  //template <typename Packet>
+  //EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psign(a); }
+};
+
+template<typename Scalar>
+struct scalar_sign_op<Scalar, false, false> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sign_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
+  {
+    return (numext::isnan)(a) ? a : Scalar( (a>Scalar(0)) - (a<Scalar(0)) );
+  }
+  //TODO
+  //template <typename Packet>
+  //EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psign(a); }
+};
+
+template<typename Scalar, bool is_integer>
+struct scalar_sign_op<Scalar,true, is_integer> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sign_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
+  {
+    typedef typename NumTraits<Scalar>::Real real_type;
+    real_type aa = numext::abs(a);
+    if (aa==real_type(0))
+      return Scalar(0);
+    aa = real_type(1)/aa;
+    return Scalar(a.real()*aa, a.imag()*aa );
+  }
+  //TODO
+  //template <typename Packet>
+  //EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psign(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_sign_op<Scalar> >
+{ enum {
+    Cost =
+        NumTraits<Scalar>::IsComplex
+        ? ( 8*NumTraits<Scalar>::MulCost  ) // roughly
+        : ( 3*NumTraits<Scalar>::AddCost),
+    PacketAccess = packet_traits<Scalar>::HasSign
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the logistic function of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::logistic()
+  */
+template <typename T>
+struct scalar_logistic_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_logistic_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x) const {
+    return packetOp(x);
+  }
+
+  template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Packet packetOp(const Packet& x) const {
+    const Packet one = pset1<Packet>(T(1));
+    return pdiv(one, padd(one, pexp(pnegate(x))));
+  }
+};
+
+#ifndef EIGEN_GPU_COMPILE_PHASE
+/** \internal
+  * \brief Template specialization of the logistic function for float.
+  *
+  *  Uses just a 9/10-degree rational interpolant which
+  *  interpolates 1/(1+exp(-x)) - 0.5 up to a couple of ulps in the range
+  *  [-9, 18]. Below -9 we use the more accurate approximation
+  *  1/(1+exp(-x)) ~= exp(x), and above 18 the logistic function is 1 withing
+  *  one ulp. The shifted logistic is interpolated because it was easier to
+  *  make the fit converge.
+  *
+  */
+template <>
+struct scalar_logistic_op<float> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_logistic_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator()(const float& x) const {
+    return packetOp(x);
+  }
+
+  template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Packet packetOp(const Packet& _x) const {
+    const Packet cutoff_lower = pset1<Packet>(-9.f);
+    const Packet lt_mask = pcmp_lt<Packet>(_x, cutoff_lower);
+    const bool any_small = predux_any(lt_mask);
+
+    // The upper cut-off is the smallest x for which the rational approximation evaluates to 1.
+    // Choosing this value saves us a few instructions clamping the results at the end.
+#ifdef EIGEN_VECTORIZE_FMA
+    const Packet cutoff_upper = pset1<Packet>(15.7243833541870117f);
+#else
+    const Packet cutoff_upper = pset1<Packet>(15.6437711715698242f);
+#endif
+    const Packet x = pmin(_x, cutoff_upper);
+
+    // The monomial coefficients of the numerator polynomial (odd).
+    const Packet alpha_1 = pset1<Packet>(2.48287947061529e-01f);
+    const Packet alpha_3 = pset1<Packet>(8.51377133304701e-03f);
+    const Packet alpha_5 = pset1<Packet>(6.08574864600143e-05f);
+    const Packet alpha_7 = pset1<Packet>(1.15627324459942e-07f);
+    const Packet alpha_9 = pset1<Packet>(4.37031012579801e-11f);
+
+    // The monomial coefficients of the denominator polynomial (even).
+    const Packet beta_0 = pset1<Packet>(9.93151921023180e-01f);
+    const Packet beta_2 = pset1<Packet>(1.16817656904453e-01f);
+    const Packet beta_4 = pset1<Packet>(1.70198817374094e-03f);
+    const Packet beta_6 = pset1<Packet>(6.29106785017040e-06f);
+    const Packet beta_8 = pset1<Packet>(5.76102136993427e-09f);
+    const Packet beta_10 = pset1<Packet>(6.10247389755681e-13f);
+
+    // Since the polynomials are odd/even, we need x^2.
+    const Packet x2 = pmul(x, x);
+
+    // Evaluate the numerator polynomial p.
+    Packet p = pmadd(x2, alpha_9, alpha_7);
+    p = pmadd(x2, p, alpha_5);
+    p = pmadd(x2, p, alpha_3);
+    p = pmadd(x2, p, alpha_1);
+    p = pmul(x, p);
+
+    // Evaluate the denominator polynomial q.
+    Packet q = pmadd(x2, beta_10, beta_8);
+    q = pmadd(x2, q, beta_6);
+    q = pmadd(x2, q, beta_4);
+    q = pmadd(x2, q, beta_2);
+    q = pmadd(x2, q, beta_0);
+    // Divide the numerator by the denominator and shift it up.
+    const Packet logistic = padd(pdiv(p, q), pset1<Packet>(0.5f));
+    if (EIGEN_PREDICT_FALSE(any_small)) {
+      const Packet exponential = pexp(_x);
+      return pselect(lt_mask, exponential, logistic);
+    } else {
+      return logistic;
+    }
+  }
+};
+#endif  // #ifndef EIGEN_GPU_COMPILE_PHASE
+
+template <typename T>
+struct functor_traits<scalar_logistic_op<T> > {
+  enum {
+    // The cost estimate for float here here is for the common(?) case where
+    // all arguments are greater than -9.
+    Cost = scalar_div_cost<T, packet_traits<T>::HasDiv>::value +
+           (internal::is_same<T, float>::value
+                ? NumTraits<T>::AddCost * 15 + NumTraits<T>::MulCost * 11
+                : NumTraits<T>::AddCost * 2 +
+                      functor_traits<scalar_exp_op<T> >::Cost),
+    PacketAccess =
+        packet_traits<T>::HasAdd && packet_traits<T>::HasDiv &&
+        (internal::is_same<T, float>::value
+             ? packet_traits<T>::HasMul && packet_traits<T>::HasMax &&
+                   packet_traits<T>::HasMin
+             : packet_traits<T>::HasNegate && packet_traits<T>::HasExp)
+  };
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_FUNCTORS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
new file mode 100644
index 00000000..f35b760c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
@@ -0,0 +1,2645 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_BLOCK_PANEL_H
+#define EIGEN_GENERAL_BLOCK_PANEL_H
+
+
+namespace Eigen {
+
+namespace internal {
+
+enum GEBPPacketSizeType {
+  GEBPPacketFull = 0,
+  GEBPPacketHalf,
+  GEBPPacketQuarter
+};
+
+template<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs=false, bool _ConjRhs=false, int Arch=Architecture::Target, int _PacketSize=GEBPPacketFull>
+class gebp_traits;
+
+
+/** \internal \returns b if a<=0, and returns a otherwise. */
+inline std::ptrdiff_t manage_caching_sizes_helper(std::ptrdiff_t a, std::ptrdiff_t b)
+{
+  return a<=0 ? b : a;
+}
+
+#if defined(EIGEN_DEFAULT_L1_CACHE_SIZE)
+#define EIGEN_SET_DEFAULT_L1_CACHE_SIZE(val) EIGEN_DEFAULT_L1_CACHE_SIZE
+#else
+#define EIGEN_SET_DEFAULT_L1_CACHE_SIZE(val) val
+#endif // defined(EIGEN_DEFAULT_L1_CACHE_SIZE)
+
+#if defined(EIGEN_DEFAULT_L2_CACHE_SIZE)
+#define EIGEN_SET_DEFAULT_L2_CACHE_SIZE(val) EIGEN_DEFAULT_L2_CACHE_SIZE
+#else
+#define EIGEN_SET_DEFAULT_L2_CACHE_SIZE(val) val
+#endif // defined(EIGEN_DEFAULT_L2_CACHE_SIZE)
+
+#if defined(EIGEN_DEFAULT_L3_CACHE_SIZE)
+#define EIGEN_SET_DEFAULT_L3_CACHE_SIZE(val) EIGEN_DEFAULT_L3_CACHE_SIZE
+#else
+#define EIGEN_SET_DEFAULT_L3_CACHE_SIZE(val) val
+#endif // defined(EIGEN_DEFAULT_L3_CACHE_SIZE)
+  
+#if EIGEN_ARCH_i386_OR_x86_64
+const std::ptrdiff_t defaultL1CacheSize = EIGEN_SET_DEFAULT_L1_CACHE_SIZE(32*1024);
+const std::ptrdiff_t defaultL2CacheSize = EIGEN_SET_DEFAULT_L2_CACHE_SIZE(256*1024);
+const std::ptrdiff_t defaultL3CacheSize = EIGEN_SET_DEFAULT_L3_CACHE_SIZE(2*1024*1024);
+#elif EIGEN_ARCH_PPC
+const std::ptrdiff_t defaultL1CacheSize = EIGEN_SET_DEFAULT_L1_CACHE_SIZE(64*1024);
+const std::ptrdiff_t defaultL2CacheSize = EIGEN_SET_DEFAULT_L2_CACHE_SIZE(512*1024);
+const std::ptrdiff_t defaultL3CacheSize = EIGEN_SET_DEFAULT_L3_CACHE_SIZE(4*1024*1024);
+#else
+const std::ptrdiff_t defaultL1CacheSize = EIGEN_SET_DEFAULT_L1_CACHE_SIZE(16*1024);
+const std::ptrdiff_t defaultL2CacheSize = EIGEN_SET_DEFAULT_L2_CACHE_SIZE(512*1024);
+const std::ptrdiff_t defaultL3CacheSize = EIGEN_SET_DEFAULT_L3_CACHE_SIZE(512*1024);
+#endif
+
+#undef EIGEN_SET_DEFAULT_L1_CACHE_SIZE
+#undef EIGEN_SET_DEFAULT_L2_CACHE_SIZE
+#undef EIGEN_SET_DEFAULT_L3_CACHE_SIZE
+
+/** \internal */
+struct CacheSizes {
+  CacheSizes(): m_l1(-1),m_l2(-1),m_l3(-1) {
+    int l1CacheSize, l2CacheSize, l3CacheSize;
+    queryCacheSizes(l1CacheSize, l2CacheSize, l3CacheSize);
+    m_l1 = manage_caching_sizes_helper(l1CacheSize, defaultL1CacheSize);
+    m_l2 = manage_caching_sizes_helper(l2CacheSize, defaultL2CacheSize);
+    m_l3 = manage_caching_sizes_helper(l3CacheSize, defaultL3CacheSize);
+  }
+
+  std::ptrdiff_t m_l1;
+  std::ptrdiff_t m_l2;
+  std::ptrdiff_t m_l3;
+};
+
+/** \internal */
+inline void manage_caching_sizes(Action action, std::ptrdiff_t* l1, std::ptrdiff_t* l2, std::ptrdiff_t* l3)
+{
+  static CacheSizes m_cacheSizes;
+
+  if(action==SetAction)
+  {
+    // set the cpu cache size and cache all block sizes from a global cache size in byte
+    eigen_internal_assert(l1!=0 && l2!=0);
+    m_cacheSizes.m_l1 = *l1;
+    m_cacheSizes.m_l2 = *l2;
+    m_cacheSizes.m_l3 = *l3;
+  }
+  else if(action==GetAction)
+  {
+    eigen_internal_assert(l1!=0 && l2!=0);
+    *l1 = m_cacheSizes.m_l1;
+    *l2 = m_cacheSizes.m_l2;
+    *l3 = m_cacheSizes.m_l3;
+  }
+  else
+  {
+    eigen_internal_assert(false);
+  }
+}
+
+/* Helper for computeProductBlockingSizes.
+ *
+ * Given a m x k times k x n matrix product of scalar types \c LhsScalar and \c RhsScalar,
+ * this function computes the blocking size parameters along the respective dimensions
+ * for matrix products and related algorithms. The blocking sizes depends on various
+ * parameters:
+ * - the L1 and L2 cache sizes,
+ * - the register level blocking sizes defined by gebp_traits,
+ * - the number of scalars that fit into a packet (when vectorization is enabled).
+ *
+ * \sa setCpuCacheSizes */
+
+template<typename LhsScalar, typename RhsScalar, int KcFactor, typename Index>
+void evaluateProductBlockingSizesHeuristic(Index& k, Index& m, Index& n, Index num_threads = 1)
+{
+  typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+  // Explanations:
+  // Let's recall that the product algorithms form mc x kc vertical panels A' on the lhs and
+  // kc x nc blocks B' on the rhs. B' has to fit into L2/L3 cache. Moreover, A' is processed
+  // per mr x kc horizontal small panels where mr is the blocking size along the m dimension
+  // at the register level. This small horizontal panel has to stay within L1 cache.
+  std::ptrdiff_t l1, l2, l3;
+  manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  #ifdef EIGEN_VECTORIZE_AVX512
+  // We need to find a rationale for that, but without this adjustment,
+  // performance with AVX512 is pretty bad, like -20% slower.
+  // One reason is that with increasing packet-size, the blocking size k
+  // has to become pretty small if we want that 1 lhs panel fit within L1.
+  // For instance, with the 3pX4 kernel and double, the size of the lhs+rhs panels are:
+  //   k*(3*64 + 4*8) Bytes, with l1=32kBytes, and k%8=0, we have k=144.
+  // This is quite small for a good reuse of the accumulation registers.
+  l1 *= 4;
+  #endif
+
+  if (num_threads > 1) {
+    typedef typename Traits::ResScalar ResScalar;
+    enum {
+      kdiv = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
+      ksub = Traits::mr * Traits::nr * sizeof(ResScalar),
+      kr = 8,
+      mr = Traits::mr,
+      nr = Traits::nr
+    };
+    // Increasing k gives us more time to prefetch the content of the "C"
+    // registers. However once the latency is hidden there is no point in
+    // increasing the value of k, so we'll cap it at 320 (value determined
+    // experimentally).
+    // To avoid that k vanishes, we make k_cache at least as big as kr
+    const Index k_cache = numext::maxi<Index>(kr, (numext::mini<Index>)((l1-ksub)/kdiv, 320));
+    if (k_cache < k) {
+      k = k_cache - (k_cache % kr);
+      eigen_internal_assert(k > 0);
+    }
+
+    const Index n_cache = (l2-l1) / (nr * sizeof(RhsScalar) * k);
+    const Index n_per_thread = numext::div_ceil(n, num_threads);
+    if (n_cache <= n_per_thread) {
+      // Don't exceed the capacity of the l2 cache.
+      eigen_internal_assert(n_cache >= static_cast<Index>(nr));
+      n = n_cache - (n_cache % nr);
+      eigen_internal_assert(n > 0);
+    } else {
+      n = (numext::mini<Index>)(n, (n_per_thread + nr - 1) - ((n_per_thread + nr - 1) % nr));
+    }
+
+    if (l3 > l2) {
+      // l3 is shared between all cores, so we'll give each thread its own chunk of l3.
+      const Index m_cache = (l3-l2) / (sizeof(LhsScalar) * k * num_threads);
+      const Index m_per_thread = numext::div_ceil(m, num_threads);
+      if(m_cache < m_per_thread && m_cache >= static_cast<Index>(mr)) {
+        m = m_cache - (m_cache % mr);
+        eigen_internal_assert(m > 0);
+      } else {
+        m = (numext::mini<Index>)(m, (m_per_thread + mr - 1) - ((m_per_thread + mr - 1) % mr));
+      }
+    }
+  }
+  else {
+    // In unit tests we do not want to use extra large matrices,
+    // so we reduce the cache size to check the blocking strategy is not flawed
+#ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
+    l1 = 9*1024;
+    l2 = 32*1024;
+    l3 = 512*1024;
+#endif
+
+    // Early return for small problems because the computation below are time consuming for small problems.
+    // Perhaps it would make more sense to consider k*n*m??
+    // Note that for very tiny problem, this function should be bypassed anyway
+    // because we use the coefficient-based implementation for them.
+    if((numext::maxi)(k,(numext::maxi)(m,n))<48)
+      return;
+
+    typedef typename Traits::ResScalar ResScalar;
+    enum {
+      k_peeling = 8,
+      k_div = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
+      k_sub = Traits::mr * Traits::nr * sizeof(ResScalar)
+    };
+
+    // ---- 1st level of blocking on L1, yields kc ----
+
+    // Blocking on the third dimension (i.e., k) is chosen so that an horizontal panel
+    // of size mr x kc of the lhs plus a vertical panel of kc x nr of the rhs both fits within L1 cache.
+    // We also include a register-level block of the result (mx x nr).
+    // (In an ideal world only the lhs panel would stay in L1)
+    // Moreover, kc has to be a multiple of 8 to be compatible with loop peeling, leading to a maximum blocking size of:
+    const Index max_kc = numext::maxi<Index>(((l1-k_sub)/k_div) & (~(k_peeling-1)),1);
+    const Index old_k = k;
+    if(k>max_kc)
+    {
+      // We are really blocking on the third dimension:
+      // -> reduce blocking size to make sure the last block is as large as possible
+      //    while keeping the same number of sweeps over the result.
+      k = (k%max_kc)==0 ? max_kc
+                        : max_kc - k_peeling * ((max_kc-1-(k%max_kc))/(k_peeling*(k/max_kc+1)));
+
+      eigen_internal_assert(((old_k/k) == (old_k/max_kc)) && "the number of sweeps has to remain the same");
+    }
+
+    // ---- 2nd level of blocking on max(L2,L3), yields nc ----
+
+    // TODO find a reliable way to get the actual amount of cache per core to use for 2nd level blocking, that is:
+    //      actual_l2 = max(l2, l3/nb_core_sharing_l3)
+    // The number below is quite conservative: it is better to underestimate the cache size rather than overestimating it)
+    // For instance, it corresponds to 6MB of L3 shared among 4 cores.
+    #ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
+    const Index actual_l2 = l3;
+    #else
+    const Index actual_l2 = 1572864; // == 1.5 MB
+    #endif
+
+    // Here, nc is chosen such that a block of kc x nc of the rhs fit within half of L2.
+    // The second half is implicitly reserved to access the result and lhs coefficients.
+    // When k<max_kc, then nc can arbitrarily growth. In practice, it seems to be fruitful
+    // to limit this growth: we bound nc to growth by a factor x1.5.
+    // However, if the entire lhs block fit within L1, then we are not going to block on the rows at all,
+    // and it becomes fruitful to keep the packed rhs blocks in L1 if there is enough remaining space.
+    Index max_nc;
+    const Index lhs_bytes = m * k * sizeof(LhsScalar);
+    const Index remaining_l1 = l1- k_sub - lhs_bytes;
+    if(remaining_l1 >= Index(Traits::nr*sizeof(RhsScalar))*k)
+    {
+      // L1 blocking
+      max_nc = remaining_l1 / (k*sizeof(RhsScalar));
+    }
+    else
+    {
+      // L2 blocking
+      max_nc = (3*actual_l2)/(2*2*max_kc*sizeof(RhsScalar));
+    }
+    // WARNING Below, we assume that Traits::nr is a power of two.
+    Index nc = numext::mini<Index>(actual_l2/(2*k*sizeof(RhsScalar)), max_nc) & (~(Traits::nr-1));
+    if(n>nc)
+    {
+      // We are really blocking over the columns:
+      // -> reduce blocking size to make sure the last block is as large as possible
+      //    while keeping the same number of sweeps over the packed lhs.
+      //    Here we allow one more sweep if this gives us a perfect match, thus the commented "-1"
+      n = (n%nc)==0 ? nc
+                    : (nc - Traits::nr * ((nc/*-1*/-(n%nc))/(Traits::nr*(n/nc+1))));
+    }
+    else if(old_k==k)
+    {
+      // So far, no blocking at all, i.e., kc==k, and nc==n.
+      // In this case, let's perform a blocking over the rows such that the packed lhs data is kept in cache L1/L2
+      // TODO: part of this blocking strategy is now implemented within the kernel itself, so the L1-based heuristic here should be obsolete.
+      Index problem_size = k*n*sizeof(LhsScalar);
+      Index actual_lm = actual_l2;
+      Index max_mc = m;
+      if(problem_size<=1024)
+      {
+        // problem is small enough to keep in L1
+        // Let's choose m such that lhs's block fit in 1/3 of L1
+        actual_lm = l1;
+      }
+      else if(l3!=0 && problem_size<=32768)
+      {
+        // we have both L2 and L3, and problem is small enough to be kept in L2
+        // Let's choose m such that lhs's block fit in 1/3 of L2
+        actual_lm = l2;
+        max_mc = (numext::mini<Index>)(576,max_mc);
+      }
+      Index mc = (numext::mini<Index>)(actual_lm/(3*k*sizeof(LhsScalar)), max_mc);
+      if (mc > Traits::mr) mc -= mc % Traits::mr;
+      else if (mc==0) return;
+      m = (m%mc)==0 ? mc
+                    : (mc - Traits::mr * ((mc/*-1*/-(m%mc))/(Traits::mr*(m/mc+1))));
+    }
+  }
+}
+
+template <typename Index>
+inline bool useSpecificBlockingSizes(Index& k, Index& m, Index& n)
+{
+#ifdef EIGEN_TEST_SPECIFIC_BLOCKING_SIZES
+  if (EIGEN_TEST_SPECIFIC_BLOCKING_SIZES) {
+    k = numext::mini<Index>(k, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_K);
+    m = numext::mini<Index>(m, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_M);
+    n = numext::mini<Index>(n, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_N);
+    return true;
+  }
+#else
+  EIGEN_UNUSED_VARIABLE(k)
+  EIGEN_UNUSED_VARIABLE(m)
+  EIGEN_UNUSED_VARIABLE(n)
+#endif
+  return false;
+}
+
+/** \brief Computes the blocking parameters for a m x k times k x n matrix product
+  *
+  * \param[in,out] k Input: the third dimension of the product. Output: the blocking size along the same dimension.
+  * \param[in,out] m Input: the number of rows of the left hand side. Output: the blocking size along the same dimension.
+  * \param[in,out] n Input: the number of columns of the right hand side. Output: the blocking size along the same dimension.
+  *
+  * Given a m x k times k x n matrix product of scalar types \c LhsScalar and \c RhsScalar,
+  * this function computes the blocking size parameters along the respective dimensions
+  * for matrix products and related algorithms.
+  *
+  * The blocking size parameters may be evaluated:
+  *   - either by a heuristic based on cache sizes;
+  *   - or using fixed prescribed values (for testing purposes).
+  *
+  * \sa setCpuCacheSizes */
+
+template<typename LhsScalar, typename RhsScalar, int KcFactor, typename Index>
+void computeProductBlockingSizes(Index& k, Index& m, Index& n, Index num_threads = 1)
+{
+  if (!useSpecificBlockingSizes(k, m, n)) {
+    evaluateProductBlockingSizesHeuristic<LhsScalar, RhsScalar, KcFactor, Index>(k, m, n, num_threads);
+  }
+}
+
+template<typename LhsScalar, typename RhsScalar, typename Index>
+inline void computeProductBlockingSizes(Index& k, Index& m, Index& n, Index num_threads = 1)
+{
+  computeProductBlockingSizes<LhsScalar,RhsScalar,1,Index>(k, m, n, num_threads);
+}
+
+template <typename RhsPacket, typename RhsPacketx4, int registers_taken>
+struct RhsPanelHelper {
+ private:
+  static const int remaining_registers = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS - registers_taken;
+ public:
+  typedef typename conditional<remaining_registers>=4, RhsPacketx4, RhsPacket>::type type;
+};
+
+template <typename Packet>
+struct QuadPacket
+{
+  Packet B_0, B1, B2, B3;
+  const Packet& get(const FixedInt<0>&) const { return B_0; }
+  const Packet& get(const FixedInt<1>&) const { return B1; }
+  const Packet& get(const FixedInt<2>&) const { return B2; }
+  const Packet& get(const FixedInt<3>&) const { return B3; }
+};
+
+template <int N, typename T1, typename T2, typename T3>
+struct packet_conditional { typedef T3 type; };
+
+template <typename T1, typename T2, typename T3>
+struct packet_conditional<GEBPPacketFull, T1, T2, T3> { typedef T1 type; };
+
+template <typename T1, typename T2, typename T3>
+struct packet_conditional<GEBPPacketHalf, T1, T2, T3> { typedef T2 type; };
+
+#define PACKET_DECL_COND_PREFIX(prefix, name, packet_size)         \
+  typedef typename packet_conditional<packet_size,                 \
+                                      typename packet_traits<name ## Scalar>::type, \
+                                      typename packet_traits<name ## Scalar>::half, \
+                                      typename unpacket_traits<typename packet_traits<name ## Scalar>::half>::half>::type \
+  prefix ## name ## Packet
+
+#define PACKET_DECL_COND(name, packet_size)                        \
+  typedef typename packet_conditional<packet_size,                 \
+                                      typename packet_traits<name ## Scalar>::type, \
+                                      typename packet_traits<name ## Scalar>::half, \
+                                      typename unpacket_traits<typename packet_traits<name ## Scalar>::half>::half>::type \
+  name ## Packet
+
+#define PACKET_DECL_COND_SCALAR_PREFIX(prefix, packet_size)        \
+  typedef typename packet_conditional<packet_size,                 \
+                                      typename packet_traits<Scalar>::type, \
+                                      typename packet_traits<Scalar>::half, \
+                                      typename unpacket_traits<typename packet_traits<Scalar>::half>::half>::type \
+  prefix ## ScalarPacket
+
+#define PACKET_DECL_COND_SCALAR(packet_size)                       \
+  typedef typename packet_conditional<packet_size,                 \
+                                      typename packet_traits<Scalar>::type, \
+                                      typename packet_traits<Scalar>::half, \
+                                      typename unpacket_traits<typename packet_traits<Scalar>::half>::half>::type \
+  ScalarPacket
+
+/* Vectorization logic
+ *  real*real: unpack rhs to constant packets, ...
+ * 
+ *  cd*cd : unpack rhs to (b_r,b_r), (b_i,b_i), mul to get (a_r b_r,a_i b_r) (a_r b_i,a_i b_i),
+ *          storing each res packet into two packets (2x2),
+ *          at the end combine them: swap the second and addsub them 
+ *  cf*cf : same but with 2x4 blocks
+ *  cplx*real : unpack rhs to constant packets, ...
+ *  real*cplx : load lhs as (a0,a0,a1,a1), and mul as usual
+ */
+template<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs, bool _ConjRhs, int Arch, int _PacketSize>
+class gebp_traits
+{
+public:
+  typedef _LhsScalar LhsScalar;
+  typedef _RhsScalar RhsScalar;
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  PACKET_DECL_COND_PREFIX(_, Lhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Rhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Res, _PacketSize);
+
+  enum {
+    ConjLhs = _ConjLhs,
+    ConjRhs = _ConjRhs,
+    Vectorizable = unpacket_traits<_LhsPacket>::vectorizable && unpacket_traits<_RhsPacket>::vectorizable,
+    LhsPacketSize = Vectorizable ? unpacket_traits<_LhsPacket>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<_RhsPacket>::size : 1,
+    ResPacketSize = Vectorizable ? unpacket_traits<_ResPacket>::size : 1,
+    
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+
+    // register block size along the N direction must be 1 or 4
+    nr = 4,
+
+    // register block size along the M direction (currently, this one cannot be modified)
+    default_mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*LhsPacketSize,
+#if defined(EIGEN_HAS_SINGLE_INSTRUCTION_MADD) && !defined(EIGEN_VECTORIZE_ALTIVEC) && !defined(EIGEN_VECTORIZE_VSX) \
+    && ((!EIGEN_COMP_MSVC) || (EIGEN_COMP_MSVC>=1914))
+    // we assume 16 registers or more
+    // See bug 992, if the scalar type is not vectorizable but that EIGEN_HAS_SINGLE_INSTRUCTION_MADD is defined,
+    // then using 3*LhsPacketSize triggers non-implemented paths in syrk.
+    // Bug 1515: MSVC prior to v19.14 yields to register spilling.
+    mr = Vectorizable ? 3*LhsPacketSize : default_mr,
+#else
+    mr = default_mr,
+#endif
+    
+    LhsProgress = LhsPacketSize,
+    RhsProgress = 1
+  };
+
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+  typedef LhsPacket LhsPacket4Packing;
+
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+  typedef ResPacket AccPacket;
+  
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p)
+  {
+    p = pset1<ResPacket>(ResScalar(0));
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    dest = pset1<RhsPacketType>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    pbroadcast4(b, dest.B_0, dest.B1, dest.B2, dest.B3);
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
+  {
+  }
+
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = ploadquad<RhsPacket>(b);
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = pload<LhsPacketType>(a);
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = ploadu<LhsPacketType>(a);
+  }
+
+  template<typename LhsPacketType, typename RhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp, const LaneIdType&) const
+  {
+    conj_helper<LhsPacketType,RhsPacketType,ConjLhs,ConjRhs> cj;
+    // It would be a lot cleaner to call pmadd all the time. Unfortunately if we
+    // let gcc allocate the register in which to store the result of the pmul
+    // (in the case where there is no FMA) gcc fails to figure out how to avoid
+    // spilling register.
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c = cj.pmadd(a,b,c);
+#else
+    tmp = b; tmp = cj.pmul(a,tmp); c = padd(c,tmp);
+#endif
+  }
+
+  template<typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp, const LaneIdType& lane) const
+  {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+
+  EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha, ResPacket& r) const
+  {
+    r = pmadd(c,alpha,r);
+  }
+  
+  template<typename ResPacketHalf>
+  EIGEN_STRONG_INLINE void acc(const ResPacketHalf& c, const ResPacketHalf& alpha, ResPacketHalf& r) const
+  {
+    r = pmadd(c,alpha,r);
+  }
+
+};
+
+template<typename RealScalar, bool _ConjLhs, int Arch, int _PacketSize>
+class gebp_traits<std::complex<RealScalar>, RealScalar, _ConjLhs, false, Arch, _PacketSize>
+{
+public:
+  typedef std::complex<RealScalar> LhsScalar;
+  typedef RealScalar RhsScalar;
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  PACKET_DECL_COND_PREFIX(_, Lhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Rhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Res, _PacketSize);
+
+  enum {
+    ConjLhs = _ConjLhs,
+    ConjRhs = false,
+    Vectorizable = unpacket_traits<_LhsPacket>::vectorizable && unpacket_traits<_RhsPacket>::vectorizable,
+    LhsPacketSize = Vectorizable ? unpacket_traits<_LhsPacket>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<_RhsPacket>::size : 1,
+    ResPacketSize = Vectorizable ? unpacket_traits<_ResPacket>::size : 1,
+    
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+    nr = 4,
+#if defined(EIGEN_HAS_SINGLE_INSTRUCTION_MADD) && !defined(EIGEN_VECTORIZE_ALTIVEC) && !defined(EIGEN_VECTORIZE_VSX)
+    // we assume 16 registers
+    mr = 3*LhsPacketSize,
+#else
+    mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*LhsPacketSize,
+#endif
+
+    LhsProgress = LhsPacketSize,
+    RhsProgress = 1
+  };
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+  typedef LhsPacket LhsPacket4Packing;
+
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+
+  typedef ResPacket AccPacket;
+
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p)
+  {
+    p = pset1<ResPacket>(ResScalar(0));
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    dest = pset1<RhsPacketType>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    pbroadcast4(b, dest.B_0, dest.B1, dest.B2, dest.B3);
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
+  {}
+  
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    loadRhsQuad_impl(b,dest, typename conditional<RhsPacketSize==16,true_type,false_type>::type());
+  }
+
+  EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket& dest, const true_type&) const
+  {
+    // FIXME we can do better!
+    // what we want here is a ploadheight
+    RhsScalar tmp[4] = {b[0],b[0],b[1],b[1]};
+    dest = ploadquad<RhsPacket>(tmp);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket& dest, const false_type&) const
+  {
+    eigen_internal_assert(RhsPacketSize<=8);
+    dest = pset1<RhsPacket>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = pload<LhsPacket>(a);
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = ploadu<LhsPacketType>(a);
+  }
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp, const LaneIdType&) const
+  {
+    madd_impl(a, b, c, tmp, typename conditional<Vectorizable,true_type,false_type>::type());
+  }
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void madd_impl(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp, const true_type&) const
+  {
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c.v = pmadd(a.v,b,c.v);
+#else
+    tmp = b; tmp = pmul(a.v,tmp); c.v = padd(c.v,tmp);
+#endif
+  }
+
+  EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/, const false_type&) const
+  {
+    c += a * b;
+  }
+
+  template<typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp, const LaneIdType& lane) const
+  {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+
+  template <typename ResPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void acc(const AccPacketType& c, const ResPacketType& alpha, ResPacketType& r) const
+  {
+    conj_helper<ResPacketType,ResPacketType,ConjLhs,false> cj;
+    r = cj.pmadd(c,alpha,r);
+  }
+
+protected:
+};
+
+template<typename Packet>
+struct DoublePacket
+{
+  Packet first;
+  Packet second;
+};
+
+template<typename Packet>
+DoublePacket<Packet> padd(const DoublePacket<Packet> &a, const DoublePacket<Packet> &b)
+{
+  DoublePacket<Packet> res;
+  res.first  = padd(a.first, b.first);
+  res.second = padd(a.second,b.second);
+  return res;
+}
+
+// note that for DoublePacket<RealPacket> the "4" in "downto4"
+// corresponds to the number of complexes, so it means "8"
+// it terms of real coefficients.
+
+template<typename Packet>
+const DoublePacket<Packet>&
+predux_half_dowto4(const DoublePacket<Packet> &a,
+                   typename enable_if<unpacket_traits<Packet>::size<=8>::type* = 0)
+{
+  return a;
+}
+
+template<typename Packet>
+DoublePacket<typename unpacket_traits<Packet>::half>
+predux_half_dowto4(const DoublePacket<Packet> &a,
+                   typename enable_if<unpacket_traits<Packet>::size==16>::type* = 0)
+{
+  // yes, that's pretty hackish :(
+  DoublePacket<typename unpacket_traits<Packet>::half> res;
+  typedef std::complex<typename unpacket_traits<Packet>::type> Cplx;
+  typedef typename packet_traits<Cplx>::type CplxPacket;
+  res.first  = predux_half_dowto4(CplxPacket(a.first)).v;
+  res.second = predux_half_dowto4(CplxPacket(a.second)).v;
+  return res;
+}
+
+// same here, "quad" actually means "8" in terms of real coefficients
+template<typename Scalar, typename RealPacket>
+void loadQuadToDoublePacket(const Scalar* b, DoublePacket<RealPacket>& dest,
+                            typename enable_if<unpacket_traits<RealPacket>::size<=8>::type* = 0)
+{
+  dest.first  = pset1<RealPacket>(numext::real(*b));
+  dest.second = pset1<RealPacket>(numext::imag(*b));
+}
+
+template<typename Scalar, typename RealPacket>
+void loadQuadToDoublePacket(const Scalar* b, DoublePacket<RealPacket>& dest,
+                            typename enable_if<unpacket_traits<RealPacket>::size==16>::type* = 0)
+{
+  // yes, that's pretty hackish too :(
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  RealScalar r[4] = {numext::real(b[0]), numext::real(b[0]), numext::real(b[1]), numext::real(b[1])};
+  RealScalar i[4] = {numext::imag(b[0]), numext::imag(b[0]), numext::imag(b[1]), numext::imag(b[1])};
+  dest.first  = ploadquad<RealPacket>(r);
+  dest.second = ploadquad<RealPacket>(i);
+}
+
+
+template<typename Packet> struct unpacket_traits<DoublePacket<Packet> > {
+  typedef DoublePacket<typename unpacket_traits<Packet>::half> half;
+};
+// template<typename Packet>
+// DoublePacket<Packet> pmadd(const DoublePacket<Packet> &a, const DoublePacket<Packet> &b)
+// {
+//   DoublePacket<Packet> res;
+//   res.first  = padd(a.first, b.first);
+//   res.second = padd(a.second,b.second);
+//   return res;
+// }
+
+template<typename RealScalar, bool _ConjLhs, bool _ConjRhs, int Arch, int _PacketSize>
+class gebp_traits<std::complex<RealScalar>, std::complex<RealScalar>, _ConjLhs, _ConjRhs, Arch, _PacketSize >
+{
+public:
+  typedef std::complex<RealScalar>  Scalar;
+  typedef std::complex<RealScalar>  LhsScalar;
+  typedef std::complex<RealScalar>  RhsScalar;
+  typedef std::complex<RealScalar>  ResScalar;
+  
+  PACKET_DECL_COND_PREFIX(_, Lhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Rhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Res, _PacketSize);
+  PACKET_DECL_COND(Real, _PacketSize);
+  PACKET_DECL_COND_SCALAR(_PacketSize);
+
+  enum {
+    ConjLhs = _ConjLhs,
+    ConjRhs = _ConjRhs,
+    Vectorizable = unpacket_traits<RealPacket>::vectorizable
+                && unpacket_traits<ScalarPacket>::vectorizable,
+    ResPacketSize   = Vectorizable ? unpacket_traits<_ResPacket>::size : 1,
+    LhsPacketSize = Vectorizable ? unpacket_traits<_LhsPacket>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<RhsScalar>::size : 1,
+    RealPacketSize  = Vectorizable ? unpacket_traits<RealPacket>::size : 1,
+
+    // FIXME: should depend on NumberOfRegisters
+    nr = 4,
+    mr = ResPacketSize,
+
+    LhsProgress = ResPacketSize,
+    RhsProgress = 1
+  };
+  
+  typedef DoublePacket<RealPacket>                 DoublePacketType;
+
+  typedef typename conditional<Vectorizable,ScalarPacket,Scalar>::type LhsPacket4Packing;
+  typedef typename conditional<Vectorizable,RealPacket,  Scalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,ScalarPacket,Scalar>::type ResPacket;
+  typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type AccPacket;
+
+  // this actualy holds 8 packets!
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+  
+  EIGEN_STRONG_INLINE void initAcc(Scalar& p) { p = Scalar(0); }
+
+  EIGEN_STRONG_INLINE void initAcc(DoublePacketType& p)
+  {
+    p.first   = pset1<RealPacket>(RealScalar(0));
+    p.second  = pset1<RealPacket>(RealScalar(0));
+  }
+
+  // Scalar path
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, ScalarPacket& dest) const
+  {
+    dest = pset1<ScalarPacket>(*b);
+  }
+
+  // Vectorized path
+  template<typename RealPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, DoublePacket<RealPacketType>& dest) const
+  {
+    dest.first  = pset1<RealPacketType>(numext::real(*b));
+    dest.second = pset1<RealPacketType>(numext::imag(*b));
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    loadRhs(b, dest.B_0);
+    loadRhs(b + 1, dest.B1);
+    loadRhs(b + 2, dest.B2);
+    loadRhs(b + 3, dest.B3);
+  }
+
+  // Scalar path
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, ScalarPacket& dest) const
+  {
+    loadRhs(b, dest);
+  }
+
+  // Vectorized path
+  template<typename RealPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, DoublePacket<RealPacketType>& dest) const
+  {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const {}
+  
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, ResPacket& dest) const
+  {
+    loadRhs(b,dest);
+  }
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, DoublePacketType& dest) const
+  {
+    loadQuadToDoublePacket(b,dest);
+  }
+
+  // nothing special here
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = pload<LhsPacket>((const typename unpacket_traits<LhsPacket>::type*)(a));
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = ploadu<LhsPacketType>((const typename unpacket_traits<LhsPacketType>::type*)(a));
+  }
+
+  template<typename LhsPacketType, typename RhsPacketType, typename ResPacketType, typename TmpType, typename LaneIdType>
+  EIGEN_STRONG_INLINE
+  typename enable_if<!is_same<RhsPacketType,RhsPacketx4>::value>::type
+  madd(const LhsPacketType& a, const RhsPacketType& b, DoublePacket<ResPacketType>& c, TmpType& /*tmp*/, const LaneIdType&) const
+  {
+    c.first   = padd(pmul(a,b.first), c.first);
+    c.second  = padd(pmul(a,b.second),c.second);
+  }
+
+  template<typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, ResPacket& c, RhsPacket& /*tmp*/, const LaneIdType&) const
+  {
+    c = cj.pmadd(a,b,c);
+  }
+
+  template<typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp, const LaneIdType& lane) const
+  {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+  
+  EIGEN_STRONG_INLINE void acc(const Scalar& c, const Scalar& alpha, Scalar& r) const { r += alpha * c; }
+  
+  template<typename RealPacketType, typename ResPacketType>
+  EIGEN_STRONG_INLINE void acc(const DoublePacket<RealPacketType>& c, const ResPacketType& alpha, ResPacketType& r) const
+  {
+    // assemble c
+    ResPacketType tmp;
+    if((!ConjLhs)&&(!ConjRhs))
+    {
+      tmp = pcplxflip(pconj(ResPacketType(c.second)));
+      tmp = padd(ResPacketType(c.first),tmp);
+    }
+    else if((!ConjLhs)&&(ConjRhs))
+    {
+      tmp = pconj(pcplxflip(ResPacketType(c.second)));
+      tmp = padd(ResPacketType(c.first),tmp);
+    }
+    else if((ConjLhs)&&(!ConjRhs))
+    {
+      tmp = pcplxflip(ResPacketType(c.second));
+      tmp = padd(pconj(ResPacketType(c.first)),tmp);
+    }
+    else if((ConjLhs)&&(ConjRhs))
+    {
+      tmp = pcplxflip(ResPacketType(c.second));
+      tmp = psub(pconj(ResPacketType(c.first)),tmp);
+    }
+    
+    r = pmadd(tmp,alpha,r);
+  }
+
+protected:
+  conj_helper<LhsScalar,RhsScalar,ConjLhs,ConjRhs> cj;
+};
+
+template<typename RealScalar, bool _ConjRhs, int Arch, int _PacketSize>
+class gebp_traits<RealScalar, std::complex<RealScalar>, false, _ConjRhs, Arch, _PacketSize >
+{
+public:
+  typedef std::complex<RealScalar>  Scalar;
+  typedef RealScalar  LhsScalar;
+  typedef Scalar      RhsScalar;
+  typedef Scalar      ResScalar;
+
+  PACKET_DECL_COND_PREFIX(_, Lhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Rhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Res, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Real, _PacketSize);
+  PACKET_DECL_COND_SCALAR_PREFIX(_, _PacketSize);
+
+#undef PACKET_DECL_COND_SCALAR_PREFIX
+#undef PACKET_DECL_COND_PREFIX
+#undef PACKET_DECL_COND_SCALAR
+#undef PACKET_DECL_COND
+
+  enum {
+    ConjLhs = false,
+    ConjRhs = _ConjRhs,
+    Vectorizable = unpacket_traits<_RealPacket>::vectorizable
+                && unpacket_traits<_ScalarPacket>::vectorizable,
+    LhsPacketSize = Vectorizable ? unpacket_traits<_LhsPacket>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<_RhsPacket>::size : 1,
+    ResPacketSize = Vectorizable ? unpacket_traits<_ResPacket>::size : 1,
+    
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+    // FIXME: should depend on NumberOfRegisters
+    nr = 4,
+    mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*ResPacketSize,
+
+    LhsProgress = ResPacketSize,
+    RhsProgress = 1
+  };
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+  typedef LhsPacket LhsPacket4Packing;
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+  typedef ResPacket AccPacket;
+
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p)
+  {
+    p = pset1<ResPacket>(ResScalar(0));
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    dest = pset1<RhsPacketType>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    pbroadcast4(b, dest.B_0, dest.B1, dest.B2, dest.B3);
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
+  {}
+
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = ploaddup<LhsPacket>(a);
+  }
+  
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = ploadquad<RhsPacket>(b);
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = ploaddup<LhsPacketType>(a);
+  }
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp, const LaneIdType&) const
+  {
+    madd_impl(a, b, c, tmp, typename conditional<Vectorizable,true_type,false_type>::type());
+  }
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void madd_impl(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp, const true_type&) const
+  {
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c.v = pmadd(a,b.v,c.v);
+#else
+    tmp = b; tmp.v = pmul(a,tmp.v); c = padd(c,tmp);
+#endif
+    
+  }
+
+  EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/, const false_type&) const
+  {
+    c += a * b;
+  }
+
+  template<typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp, const LaneIdType& lane) const
+  {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+
+  template <typename ResPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void acc(const AccPacketType& c, const ResPacketType& alpha, ResPacketType& r) const
+  {
+    conj_helper<ResPacketType,ResPacketType,false,ConjRhs> cj;
+    r = cj.pmadd(alpha,c,r);
+  }
+
+protected:
+
+};
+
+/* optimized General packed Block * packed Panel product kernel
+ *
+ * Mixing type logic: C += A * B
+ *  |  A  |  B  | comments
+ *  |real |cplx | no vectorization yet, would require to pack A with duplication
+ *  |cplx |real | easy vectorization
+ */
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel
+{
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Architecture::Target> Traits;
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Architecture::Target,GEBPPacketHalf> HalfTraits;
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Architecture::Target,GEBPPacketQuarter> QuarterTraits;
+  
+  typedef typename Traits::ResScalar ResScalar;
+  typedef typename Traits::LhsPacket LhsPacket;
+  typedef typename Traits::RhsPacket RhsPacket;
+  typedef typename Traits::ResPacket ResPacket;
+  typedef typename Traits::AccPacket AccPacket;
+  typedef typename Traits::RhsPacketx4 RhsPacketx4;
+
+  typedef typename RhsPanelHelper<RhsPacket, RhsPacketx4, 15>::type RhsPanel15;
+
+  typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Architecture::Target> SwappedTraits;
+
+  typedef typename SwappedTraits::ResScalar SResScalar;
+  typedef typename SwappedTraits::LhsPacket SLhsPacket;
+  typedef typename SwappedTraits::RhsPacket SRhsPacket;
+  typedef typename SwappedTraits::ResPacket SResPacket;
+  typedef typename SwappedTraits::AccPacket SAccPacket;
+
+  typedef typename HalfTraits::LhsPacket LhsPacketHalf;
+  typedef typename HalfTraits::RhsPacket RhsPacketHalf;
+  typedef typename HalfTraits::ResPacket ResPacketHalf;
+  typedef typename HalfTraits::AccPacket AccPacketHalf;
+
+  typedef typename QuarterTraits::LhsPacket LhsPacketQuarter;
+  typedef typename QuarterTraits::RhsPacket RhsPacketQuarter;
+  typedef typename QuarterTraits::ResPacket ResPacketQuarter;
+  typedef typename QuarterTraits::AccPacket AccPacketQuarter;
+
+  typedef typename DataMapper::LinearMapper LinearMapper;
+
+  enum {
+    Vectorizable  = Traits::Vectorizable,
+    LhsProgress   = Traits::LhsProgress,
+    LhsProgressHalf      = HalfTraits::LhsProgress,
+    LhsProgressQuarter   = QuarterTraits::LhsProgress,
+    RhsProgress   = Traits::RhsProgress,
+    RhsProgressHalf      = HalfTraits::RhsProgress,
+    RhsProgressQuarter   = QuarterTraits::RhsProgress,
+    ResPacketSize = Traits::ResPacketSize
+  };
+
+  EIGEN_DONT_INLINE
+  void operator()(const DataMapper& res, const LhsScalar* blockA, const RhsScalar* blockB,
+                  Index rows, Index depth, Index cols, ResScalar alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs,
+int SwappedLhsProgress = gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Architecture::Target>::LhsProgress>
+struct last_row_process_16_packets
+{
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Architecture::Target> Traits;
+  typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Architecture::Target> SwappedTraits;
+
+  typedef typename Traits::ResScalar ResScalar;
+  typedef typename SwappedTraits::LhsPacket SLhsPacket;
+  typedef typename SwappedTraits::RhsPacket SRhsPacket;
+  typedef typename SwappedTraits::ResPacket SResPacket;
+  typedef typename SwappedTraits::AccPacket SAccPacket;
+
+  EIGEN_STRONG_INLINE void operator()(const DataMapper& res, SwappedTraits &straits, const LhsScalar* blA,
+                  const RhsScalar* blB, Index depth, const Index endk, Index i, Index j2,
+                  ResScalar alpha, SAccPacket &C0)
+    {
+      EIGEN_UNUSED_VARIABLE(res);
+      EIGEN_UNUSED_VARIABLE(straits);
+      EIGEN_UNUSED_VARIABLE(blA);
+      EIGEN_UNUSED_VARIABLE(blB);
+      EIGEN_UNUSED_VARIABLE(depth);
+      EIGEN_UNUSED_VARIABLE(endk);
+      EIGEN_UNUSED_VARIABLE(i);
+      EIGEN_UNUSED_VARIABLE(j2);
+      EIGEN_UNUSED_VARIABLE(alpha);
+      EIGEN_UNUSED_VARIABLE(C0);
+    }
+};
+
+
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct last_row_process_16_packets<LhsScalar, RhsScalar, Index, DataMapper,  mr,  nr, ConjugateLhs,  ConjugateRhs, 16> {
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Architecture::Target> Traits;
+  typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Architecture::Target> SwappedTraits;
+
+  typedef typename Traits::ResScalar ResScalar;
+  typedef typename SwappedTraits::LhsPacket SLhsPacket;
+  typedef typename SwappedTraits::RhsPacket SRhsPacket;
+  typedef typename SwappedTraits::ResPacket SResPacket;
+  typedef typename SwappedTraits::AccPacket SAccPacket;
+
+  EIGEN_STRONG_INLINE void operator()(const DataMapper& res, SwappedTraits &straits, const LhsScalar* blA,
+                  const RhsScalar* blB, Index depth, const Index endk, Index i, Index j2,
+                  ResScalar alpha, SAccPacket &C0)
+  {
+    typedef typename unpacket_traits<typename unpacket_traits<SResPacket>::half>::half SResPacketQuarter;
+    typedef typename unpacket_traits<typename unpacket_traits<SLhsPacket>::half>::half SLhsPacketQuarter;
+    typedef typename unpacket_traits<typename unpacket_traits<SRhsPacket>::half>::half SRhsPacketQuarter;
+    typedef typename unpacket_traits<typename unpacket_traits<SAccPacket>::half>::half SAccPacketQuarter;
+
+    SResPacketQuarter R = res.template gatherPacket<SResPacketQuarter>(i, j2);
+    SResPacketQuarter alphav = pset1<SResPacketQuarter>(alpha);
+
+    if (depth - endk > 0)
+      {
+	// We have to handle the last row(s) of the rhs, which
+	// correspond to a half-packet
+	SAccPacketQuarter c0 = predux_half_dowto4(predux_half_dowto4(C0));
+
+	for (Index kk = endk; kk < depth; kk++)
+	  {
+	    SLhsPacketQuarter a0;
+	    SRhsPacketQuarter b0;
+	    straits.loadLhsUnaligned(blB, a0);
+	    straits.loadRhs(blA, b0);
+	    straits.madd(a0,b0,c0,b0, fix<0>);
+	    blB += SwappedTraits::LhsProgress/4;
+	    blA += 1;
+	  }
+	straits.acc(c0, alphav, R);
+      }
+    else
+      {
+	straits.acc(predux_half_dowto4(predux_half_dowto4(C0)), alphav, R);
+      }
+    res.scatterPacket(i, j2, R);
+  }
+};
+
+template<int nr, Index LhsProgress, Index RhsProgress, typename LhsScalar, typename RhsScalar, typename ResScalar, typename AccPacket, typename LhsPacket, typename RhsPacket, typename ResPacket, typename GEBPTraits, typename LinearMapper, typename DataMapper>
+struct lhs_process_one_packet
+{
+  typedef typename GEBPTraits::RhsPacketx4 RhsPacketx4;
+
+  EIGEN_STRONG_INLINE void peeled_kc_onestep(Index K, const LhsScalar* blA, const RhsScalar* blB, GEBPTraits traits, LhsPacket *A0, RhsPacketx4 *rhs_panel, RhsPacket *T0, AccPacket *C0, AccPacket *C1, AccPacket *C2, AccPacket *C3)
+  {
+    EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1X4");
+    EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!");
+    traits.loadLhs(&blA[(0+1*K)*LhsProgress], *A0);
+    traits.loadRhs(&blB[(0+4*K)*RhsProgress], *rhs_panel);
+    traits.madd(*A0, *rhs_panel, *C0, *T0, fix<0>);
+    traits.madd(*A0, *rhs_panel, *C1, *T0, fix<1>);
+    traits.madd(*A0, *rhs_panel, *C2, *T0, fix<2>);
+    traits.madd(*A0, *rhs_panel, *C3, *T0, fix<3>);
+    #if EIGEN_GNUC_AT_LEAST(6,0) && defined(EIGEN_VECTORIZE_SSE)
+    __asm__  ("" : "+x,m" (*A0));
+    #endif
+    EIGEN_ASM_COMMENT("end step of gebp micro kernel 1X4");
+  }
+
+  EIGEN_STRONG_INLINE void operator()(
+    const DataMapper& res, const LhsScalar* blockA, const RhsScalar* blockB, ResScalar alpha,
+    Index peelStart, Index peelEnd, Index strideA, Index strideB, Index offsetA, Index offsetB,
+    int prefetch_res_offset, Index peeled_kc, Index pk, Index cols, Index depth, Index packet_cols4)
+  {
+    GEBPTraits traits;
+
+    // loops on each largest micro horizontal panel of lhs
+    // (LhsProgress x depth)
+    for(Index i=peelStart; i<peelEnd; i+=LhsProgress)
+    {
+      // loops on each largest micro vertical panel of rhs (depth * nr)
+      for(Index j2=0; j2<packet_cols4; j2+=nr)
+      {
+        // We select a LhsProgress x nr micro block of res
+        // which is entirely stored into 1 x nr registers.
+
+        const LhsScalar* blA = &blockA[i*strideA+offsetA*(LhsProgress)];
+        prefetch(&blA[0]);
+
+        // gets res block as register
+        AccPacket C0, C1, C2, C3;
+        traits.initAcc(C0);
+        traits.initAcc(C1);
+        traits.initAcc(C2);
+        traits.initAcc(C3);
+        // To improve instruction pipelining, let's double the accumulation registers:
+        //  even k will accumulate in C*, while odd k will accumulate in D*.
+        // This trick is crutial to get good performance with FMA, otherwise it is 
+        // actually faster to perform separated MUL+ADD because of a naturally
+        // better instruction-level parallelism.
+        AccPacket D0, D1, D2, D3;
+        traits.initAcc(D0);
+        traits.initAcc(D1);
+        traits.initAcc(D2);
+        traits.initAcc(D3);
+
+        LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
+        LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
+        LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
+        LinearMapper r3 = res.getLinearMapper(i, j2 + 3);
+
+        r0.prefetch(prefetch_res_offset);
+        r1.prefetch(prefetch_res_offset);
+        r2.prefetch(prefetch_res_offset);
+        r3.prefetch(prefetch_res_offset);
+
+        // performs "inner" products
+        const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+        prefetch(&blB[0]);
+        LhsPacket A0, A1;
+
+        for(Index k=0; k<peeled_kc; k+=pk)
+        {
+          EIGEN_ASM_COMMENT("begin gebp micro kernel 1/half/quarterX4");
+          RhsPacketx4 rhs_panel;
+          RhsPacket T0;
+
+          internal::prefetch(blB+(48+0));
+          peeled_kc_onestep(0, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
+          peeled_kc_onestep(1, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
+          peeled_kc_onestep(2, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
+          peeled_kc_onestep(3, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
+          internal::prefetch(blB+(48+16));
+          peeled_kc_onestep(4, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
+          peeled_kc_onestep(5, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
+          peeled_kc_onestep(6, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
+          peeled_kc_onestep(7, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
+
+          blB += pk*4*RhsProgress;
+          blA += pk*LhsProgress;
+
+          EIGEN_ASM_COMMENT("end gebp micro kernel 1/half/quarterX4");
+        }
+        C0 = padd(C0,D0);
+        C1 = padd(C1,D1);
+        C2 = padd(C2,D2);
+        C3 = padd(C3,D3);
+
+        // process remaining peeled loop
+        for(Index k=peeled_kc; k<depth; k++)
+        {
+          RhsPacketx4 rhs_panel;
+          RhsPacket T0;
+          peeled_kc_onestep(0, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
+          blB += 4*RhsProgress;
+          blA += LhsProgress;
+        }
+
+        ResPacket R0, R1;
+        ResPacket alphav = pset1<ResPacket>(alpha);
+
+        R0 = r0.template loadPacket<ResPacket>(0);
+        R1 = r1.template loadPacket<ResPacket>(0);
+        traits.acc(C0, alphav, R0);
+        traits.acc(C1,  alphav, R1);
+        r0.storePacket(0, R0);
+        r1.storePacket(0, R1);
+
+        R0 = r2.template loadPacket<ResPacket>(0);
+        R1 = r3.template loadPacket<ResPacket>(0);
+        traits.acc(C2,  alphav, R0);
+        traits.acc(C3,  alphav, R1);
+        r2.storePacket(0, R0);
+        r3.storePacket(0, R1);
+      }
+
+      // Deal with remaining columns of the rhs
+      for(Index j2=packet_cols4; j2<cols; j2++)
+      {
+        // One column at a time
+        const LhsScalar* blA = &blockA[i*strideA+offsetA*(LhsProgress)];
+        prefetch(&blA[0]);
+
+        // gets res block as register
+        AccPacket C0;
+        traits.initAcc(C0);
+
+        LinearMapper r0 = res.getLinearMapper(i, j2);
+
+        // performs "inner" products
+        const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+        LhsPacket A0;
+
+        for(Index k= 0; k<peeled_kc; k+=pk)
+        {
+          EIGEN_ASM_COMMENT("begin gebp micro kernel 1/half/quarterX1");
+          RhsPacket B_0;
+
+#define EIGEN_GEBGP_ONESTEP(K)                                          \
+	      do {                                                      \
+		EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1/half/quarterX1"); \
+		EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+    /* FIXME: why unaligned???? */ \
+		traits.loadLhsUnaligned(&blA[(0+1*K)*LhsProgress], A0); \
+		traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);		\
+		traits.madd(A0, B_0, C0, B_0, fix<0>);				\
+		EIGEN_ASM_COMMENT("end step of gebp micro kernel 1/half/quarterX1"); \
+	      } while(false);
+
+          EIGEN_GEBGP_ONESTEP(0);
+          EIGEN_GEBGP_ONESTEP(1);
+          EIGEN_GEBGP_ONESTEP(2);
+          EIGEN_GEBGP_ONESTEP(3);
+          EIGEN_GEBGP_ONESTEP(4);
+          EIGEN_GEBGP_ONESTEP(5);
+          EIGEN_GEBGP_ONESTEP(6);
+          EIGEN_GEBGP_ONESTEP(7);
+
+          blB += pk*RhsProgress;
+          blA += pk*LhsProgress;
+
+          EIGEN_ASM_COMMENT("end gebp micro kernel 1/half/quarterX1");
+        }
+
+        // process remaining peeled loop
+        for(Index k=peeled_kc; k<depth; k++)
+        {
+          RhsPacket B_0;
+          EIGEN_GEBGP_ONESTEP(0);
+          blB += RhsProgress;
+          blA += LhsProgress;
+        }
+#undef EIGEN_GEBGP_ONESTEP
+        ResPacket R0;
+        ResPacket alphav = pset1<ResPacket>(alpha);
+        R0 = r0.template loadPacket<ResPacket>(0);
+        traits.acc(C0, alphav, R0);
+        r0.storePacket(0, R0);
+      }
+    }
+  }
+};
+
+template<int nr, Index LhsProgress, Index RhsProgress, typename LhsScalar, typename RhsScalar, typename ResScalar, typename AccPacket, typename LhsPacket, typename RhsPacket, typename ResPacket, typename GEBPTraits, typename LinearMapper, typename DataMapper>
+struct lhs_process_fraction_of_packet : lhs_process_one_packet<nr, LhsProgress, RhsProgress, LhsScalar, RhsScalar, ResScalar, AccPacket, LhsPacket, RhsPacket, ResPacket, GEBPTraits, LinearMapper, DataMapper>
+{
+
+EIGEN_STRONG_INLINE void peeled_kc_onestep(Index K, const LhsScalar* blA, const RhsScalar* blB, GEBPTraits traits, LhsPacket *A0, RhsPacket *B_0, RhsPacket *B1, RhsPacket *B2, RhsPacket *B3, AccPacket *C0, AccPacket *C1, AccPacket *C2, AccPacket *C3)
+  {
+        EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1X4");
+        EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!");
+        traits.loadLhsUnaligned(&blA[(0+1*K)*(LhsProgress)], *A0);
+        traits.broadcastRhs(&blB[(0+4*K)*RhsProgress], *B_0, *B1, *B2, *B3);
+        traits.madd(*A0, *B_0, *C0, *B_0);
+        traits.madd(*A0, *B1,  *C1, *B1);
+        traits.madd(*A0, *B2,  *C2, *B2);
+        traits.madd(*A0, *B3,  *C3, *B3);
+        EIGEN_ASM_COMMENT("end step of gebp micro kernel 1X4");
+  }
+};
+
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+EIGEN_DONT_INLINE
+void gebp_kernel<LhsScalar,RhsScalar,Index,DataMapper,mr,nr,ConjugateLhs,ConjugateRhs>
+  ::operator()(const DataMapper& res, const LhsScalar* blockA, const RhsScalar* blockB,
+               Index rows, Index depth, Index cols, ResScalar alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    Traits traits;
+    SwappedTraits straits;
+    
+    if(strideA==-1) strideA = depth;
+    if(strideB==-1) strideB = depth;
+    conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
+    Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+    const Index peeled_mc3 = mr>=3*Traits::LhsProgress ? (rows/(3*LhsProgress))*(3*LhsProgress) : 0;
+    const Index peeled_mc2 = mr>=2*Traits::LhsProgress ? peeled_mc3+((rows-peeled_mc3)/(2*LhsProgress))*(2*LhsProgress) : 0;
+    const Index peeled_mc1 = mr>=1*Traits::LhsProgress ? peeled_mc2+((rows-peeled_mc2)/(1*LhsProgress))*(1*LhsProgress) : 0;
+    const Index peeled_mc_half = mr>=LhsProgressHalf ? peeled_mc1+((rows-peeled_mc1)/(LhsProgressHalf))*(LhsProgressHalf) : 0;
+    const Index peeled_mc_quarter = mr>=LhsProgressQuarter ? peeled_mc_half+((rows-peeled_mc_half)/(LhsProgressQuarter))*(LhsProgressQuarter) : 0;
+    enum { pk = 8 }; // NOTE Such a large peeling factor is important for large matrices (~ +5% when >1000 on Haswell)
+    const Index peeled_kc  = depth & ~(pk-1);
+    const int prefetch_res_offset = 32/sizeof(ResScalar);    
+//     const Index depth2     = depth & ~1;
+
+    //---------- Process 3 * LhsProgress rows at once ----------
+    // This corresponds to 3*LhsProgress x nr register blocks.
+    // Usually, make sense only with FMA
+    if(mr>=3*Traits::LhsProgress)
+    {
+      // Here, the general idea is to loop on each largest micro horizontal panel of the lhs (3*Traits::LhsProgress x depth)
+      // and on each largest micro vertical panel of the rhs (depth * nr).
+      // Blocking sizes, i.e., 'depth' has been computed so that the micro horizontal panel of the lhs fit in L1.
+      // However, if depth is too small, we can extend the number of rows of these horizontal panels.
+      // This actual number of rows is computed as follow:
+      const Index l1 = defaultL1CacheSize; // in Bytes, TODO, l1 should be passed to this function.
+      // The max(1, ...) here is needed because we may be using blocking params larger than what our known l1 cache size
+      // suggests we should be using: either because our known l1 cache size is inaccurate (e.g. on Android, we can only guess),
+      // or because we are testing specific blocking sizes.
+      const Index actual_panel_rows = (3*LhsProgress) * std::max<Index>(1,( (l1 - sizeof(ResScalar)*mr*nr - depth*nr*sizeof(RhsScalar)) / (depth * sizeof(LhsScalar) * 3*LhsProgress) ));
+      for(Index i1=0; i1<peeled_mc3; i1+=actual_panel_rows)
+      {
+        const Index actual_panel_end = (std::min)(i1+actual_panel_rows, peeled_mc3);
+        for(Index j2=0; j2<packet_cols4; j2+=nr)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=3*LhsProgress)
+          {
+          
+          // We selected a 3*Traits::LhsProgress x nr micro block of res which is entirely
+          // stored into 3 x nr registers.
+          
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(3*LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C1, C2,  C3,
+                    C4, C5, C6,  C7,
+                    C8, C9, C10, C11;
+          traits.initAcc(C0);  traits.initAcc(C1);  traits.initAcc(C2);  traits.initAcc(C3);
+          traits.initAcc(C4);  traits.initAcc(C5);  traits.initAcc(C6);  traits.initAcc(C7);
+          traits.initAcc(C8);  traits.initAcc(C9);  traits.initAcc(C10); traits.initAcc(C11);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
+          LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
+          LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
+          LinearMapper r3 = res.getLinearMapper(i, j2 + 3);
+
+          r0.prefetch(0);
+          r1.prefetch(0);
+          r2.prefetch(0);
+          r3.prefetch(0);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+          prefetch(&blB[0]);
+          LhsPacket A0, A1;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 3pX4");
+            // 15 registers are taken (12 for acc, 2 for lhs).
+            RhsPanel15 rhs_panel;
+            RhsPacket T0;
+            LhsPacket A2;
+            #if EIGEN_COMP_GNUC_STRICT && EIGEN_ARCH_ARM64 && defined(EIGEN_VECTORIZE_NEON) && !(EIGEN_GNUC_AT_LEAST(9,0))
+            // see http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1633
+            // without this workaround A0, A1, and A2 are loaded in the same register,
+            // which is not good for pipelining
+            #define EIGEN_GEBP_3PX4_REGISTER_ALLOC_WORKAROUND __asm__  ("" : "+w,m" (A0), "+w,m" (A1), "+w,m" (A2));
+            #else
+            #define EIGEN_GEBP_3PX4_REGISTER_ALLOC_WORKAROUND
+            #endif
+#define EIGEN_GEBP_ONESTEP(K)                                                     \
+            do {                                                                  \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 3pX4");          \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              internal::prefetch(blA + (3 * K + 16) * LhsProgress);               \
+              if (EIGEN_ARCH_ARM || EIGEN_ARCH_MIPS) {                            \
+                internal::prefetch(blB + (4 * K + 16) * RhsProgress);             \
+              } /* Bug 953 */                                                     \
+              traits.loadLhs(&blA[(0 + 3 * K) * LhsProgress], A0);                \
+              traits.loadLhs(&blA[(1 + 3 * K) * LhsProgress], A1);                \
+              traits.loadLhs(&blA[(2 + 3 * K) * LhsProgress], A2);                \
+              EIGEN_GEBP_3PX4_REGISTER_ALLOC_WORKAROUND \
+              traits.loadRhs(blB + (0+4*K) * Traits::RhsProgress, rhs_panel);     \
+              traits.madd(A0, rhs_panel, C0, T0, fix<0>);                         \
+              traits.madd(A1, rhs_panel, C4, T0, fix<0>);                         \
+              traits.madd(A2, rhs_panel, C8, T0, fix<0>);                         \
+              traits.updateRhs(blB + (1+4*K) * Traits::RhsProgress, rhs_panel);   \
+              traits.madd(A0, rhs_panel, C1, T0, fix<1>);                         \
+              traits.madd(A1, rhs_panel, C5, T0, fix<1>);                         \
+              traits.madd(A2, rhs_panel, C9, T0, fix<1>);                         \
+              traits.updateRhs(blB + (2+4*K) * Traits::RhsProgress, rhs_panel);   \
+              traits.madd(A0, rhs_panel, C2, T0, fix<2>);                         \
+              traits.madd(A1, rhs_panel, C6, T0, fix<2>);                         \
+              traits.madd(A2, rhs_panel, C10, T0, fix<2>);                        \
+              traits.updateRhs(blB + (3+4*K) * Traits::RhsProgress, rhs_panel);   \
+              traits.madd(A0, rhs_panel, C3, T0, fix<3>);                         \
+              traits.madd(A1, rhs_panel, C7, T0, fix<3>);                         \
+              traits.madd(A2, rhs_panel, C11, T0, fix<3>);                        \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 3pX4");            \
+            } while (false)
+
+            internal::prefetch(blB);
+            EIGEN_GEBP_ONESTEP(0);
+            EIGEN_GEBP_ONESTEP(1);
+            EIGEN_GEBP_ONESTEP(2);
+            EIGEN_GEBP_ONESTEP(3);
+            EIGEN_GEBP_ONESTEP(4);
+            EIGEN_GEBP_ONESTEP(5);
+            EIGEN_GEBP_ONESTEP(6);
+            EIGEN_GEBP_ONESTEP(7);
+
+            blB += pk*4*RhsProgress;
+            blA += pk*3*Traits::LhsProgress;
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 3pX4");
+          }
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPanel15 rhs_panel;
+            RhsPacket T0;
+            LhsPacket A2;
+            EIGEN_GEBP_ONESTEP(0);
+            blB += 4*RhsProgress;
+            blA += 3*Traits::LhsProgress;
+          }
+
+#undef EIGEN_GEBP_ONESTEP
+
+          ResPacket R0, R1, R2;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r0.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r0.template loadPacket<ResPacket>(2 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          traits.acc(C8, alphav, R2);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          r0.storePacket(2 * Traits::ResPacketSize, R2);
+
+          R0 = r1.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r1.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r1.template loadPacket<ResPacket>(2 * Traits::ResPacketSize);
+          traits.acc(C1, alphav, R0);
+          traits.acc(C5, alphav, R1);
+          traits.acc(C9, alphav, R2);
+          r1.storePacket(0 * Traits::ResPacketSize, R0);
+          r1.storePacket(1 * Traits::ResPacketSize, R1);
+          r1.storePacket(2 * Traits::ResPacketSize, R2);
+
+          R0 = r2.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r2.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r2.template loadPacket<ResPacket>(2 * Traits::ResPacketSize);
+          traits.acc(C2, alphav, R0);
+          traits.acc(C6, alphav, R1);
+          traits.acc(C10, alphav, R2);
+          r2.storePacket(0 * Traits::ResPacketSize, R0);
+          r2.storePacket(1 * Traits::ResPacketSize, R1);
+          r2.storePacket(2 * Traits::ResPacketSize, R2);
+
+          R0 = r3.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r3.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r3.template loadPacket<ResPacket>(2 * Traits::ResPacketSize);
+          traits.acc(C3, alphav, R0);
+          traits.acc(C7, alphav, R1);
+          traits.acc(C11, alphav, R2);
+          r3.storePacket(0 * Traits::ResPacketSize, R0);
+          r3.storePacket(1 * Traits::ResPacketSize, R1);
+          r3.storePacket(2 * Traits::ResPacketSize, R2);          
+          }
+        }
+
+        // Deal with remaining columns of the rhs
+        for(Index j2=packet_cols4; j2<cols; j2++)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=3*LhsProgress)
+          {
+          // One column at a time
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(3*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C4, C8;
+          traits.initAcc(C0);
+          traits.initAcc(C4);
+          traits.initAcc(C8);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2);
+          r0.prefetch(0);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+          LhsPacket A0, A1, A2;
+          
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 3pX1");
+            RhsPacket B_0;
+#define EIGEN_GEBGP_ONESTEP(K)                                                    \
+            do {                                                                  \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 3pX1");          \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              traits.loadLhs(&blA[(0 + 3 * K) * LhsProgress], A0);                \
+              traits.loadLhs(&blA[(1 + 3 * K) * LhsProgress], A1);                \
+              traits.loadLhs(&blA[(2 + 3 * K) * LhsProgress], A2);                \
+              traits.loadRhs(&blB[(0 + K) * RhsProgress], B_0);                   \
+              traits.madd(A0, B_0, C0, B_0, fix<0>);                              \
+              traits.madd(A1, B_0, C4, B_0, fix<0>);                              \
+              traits.madd(A2, B_0, C8, B_0, fix<0>);                              \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 3pX1");            \
+            } while (false)
+
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += int(pk) * int(RhsProgress);
+            blA += int(pk) * 3 * int(Traits::LhsProgress);
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 3pX1");
+          }
+
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacket B_0;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += RhsProgress;
+            blA += 3*Traits::LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+          ResPacket R0, R1, R2;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r0.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r0.template loadPacket<ResPacket>(2 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          traits.acc(C8, alphav, R2);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          r0.storePacket(2 * Traits::ResPacketSize, R2);          
+          }
+        }
+      }
+    }
+
+    //---------- Process 2 * LhsProgress rows at once ----------
+    if(mr>=2*Traits::LhsProgress)
+    {
+      const Index l1 = defaultL1CacheSize; // in Bytes, TODO, l1 should be passed to this function.
+      // The max(1, ...) here is needed because we may be using blocking params larger than what our known l1 cache size
+      // suggests we should be using: either because our known l1 cache size is inaccurate (e.g. on Android, we can only guess),
+      // or because we are testing specific blocking sizes.
+      Index actual_panel_rows = (2*LhsProgress) * std::max<Index>(1,( (l1 - sizeof(ResScalar)*mr*nr - depth*nr*sizeof(RhsScalar)) / (depth * sizeof(LhsScalar) * 2*LhsProgress) ));
+
+      for(Index i1=peeled_mc3; i1<peeled_mc2; i1+=actual_panel_rows)
+      {
+        Index actual_panel_end = (std::min)(i1+actual_panel_rows, peeled_mc2);
+        for(Index j2=0; j2<packet_cols4; j2+=nr)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=2*LhsProgress)
+          {
+          
+          // We selected a 2*Traits::LhsProgress x nr micro block of res which is entirely
+          // stored into 2 x nr registers.
+          
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(2*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C1, C2, C3,
+                    C4, C5, C6, C7;
+          traits.initAcc(C0); traits.initAcc(C1); traits.initAcc(C2); traits.initAcc(C3);
+          traits.initAcc(C4); traits.initAcc(C5); traits.initAcc(C6); traits.initAcc(C7);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
+          LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
+          LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
+          LinearMapper r3 = res.getLinearMapper(i, j2 + 3);
+
+          r0.prefetch(prefetch_res_offset);
+          r1.prefetch(prefetch_res_offset);
+          r2.prefetch(prefetch_res_offset);
+          r3.prefetch(prefetch_res_offset);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+          prefetch(&blB[0]);
+          LhsPacket A0, A1;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 2pX4");
+            RhsPacketx4 rhs_panel;
+            RhsPacket T0;
+
+          // NOTE: the begin/end asm comments below work around bug 935!
+          // but they are not enough for gcc>=6 without FMA (bug 1637)
+          #if EIGEN_GNUC_AT_LEAST(6,0) && defined(EIGEN_VECTORIZE_SSE)
+            #define EIGEN_GEBP_2PX4_SPILLING_WORKAROUND __asm__  ("" : [a0] "+x,m" (A0),[a1] "+x,m" (A1));
+          #else
+            #define EIGEN_GEBP_2PX4_SPILLING_WORKAROUND
+          #endif
+#define EIGEN_GEBGP_ONESTEP(K)                                            \
+            do {                                                          \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 2pX4");  \
+              traits.loadLhs(&blA[(0 + 2 * K) * LhsProgress], A0);        \
+              traits.loadLhs(&blA[(1 + 2 * K) * LhsProgress], A1);        \
+              traits.loadRhs(&blB[(0 + 4 * K) * RhsProgress], rhs_panel); \
+              traits.madd(A0, rhs_panel, C0, T0, fix<0>);                 \
+              traits.madd(A1, rhs_panel, C4, T0, fix<0>);                 \
+              traits.madd(A0, rhs_panel, C1, T0, fix<1>);                 \
+              traits.madd(A1, rhs_panel, C5, T0, fix<1>);                 \
+              traits.madd(A0, rhs_panel, C2, T0, fix<2>);                 \
+              traits.madd(A1, rhs_panel, C6, T0, fix<2>);                 \
+              traits.madd(A0, rhs_panel, C3, T0, fix<3>);                 \
+              traits.madd(A1, rhs_panel, C7, T0, fix<3>);                 \
+              EIGEN_GEBP_2PX4_SPILLING_WORKAROUND                         \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 2pX4");    \
+            } while (false)
+
+            internal::prefetch(blB+(48+0));
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            internal::prefetch(blB+(48+16));
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += pk*4*RhsProgress;
+            blA += pk*(2*Traits::LhsProgress);
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 2pX4");
+          }
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacketx4 rhs_panel;
+            RhsPacket T0;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += 4*RhsProgress;
+            blA += 2*Traits::LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+
+          ResPacket R0, R1, R2, R3;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r0.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r1.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R3 = r1.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          traits.acc(C1, alphav, R2);
+          traits.acc(C5, alphav, R3);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          r1.storePacket(0 * Traits::ResPacketSize, R2);
+          r1.storePacket(1 * Traits::ResPacketSize, R3);
+
+          R0 = r2.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r2.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r3.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R3 = r3.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          traits.acc(C2,  alphav, R0);
+          traits.acc(C6,  alphav, R1);
+          traits.acc(C3,  alphav, R2);
+          traits.acc(C7,  alphav, R3);
+          r2.storePacket(0 * Traits::ResPacketSize, R0);
+          r2.storePacket(1 * Traits::ResPacketSize, R1);
+          r3.storePacket(0 * Traits::ResPacketSize, R2);
+          r3.storePacket(1 * Traits::ResPacketSize, R3);
+          }
+        }
+      
+        // Deal with remaining columns of the rhs
+        for(Index j2=packet_cols4; j2<cols; j2++)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=2*LhsProgress)
+          {
+          // One column at a time
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(2*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C4;
+          traits.initAcc(C0);
+          traits.initAcc(C4);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2);
+          r0.prefetch(prefetch_res_offset);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+          LhsPacket A0, A1;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 2pX1");
+            RhsPacket B_0, B1;
+        
+#define EIGEN_GEBGP_ONESTEP(K) \
+            do {                                                                  \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 2pX1");          \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              traits.loadLhs(&blA[(0+2*K)*LhsProgress], A0);                      \
+              traits.loadLhs(&blA[(1+2*K)*LhsProgress], A1);                      \
+              traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);                       \
+              traits.madd(A0, B_0, C0, B1, fix<0>);                               \
+              traits.madd(A1, B_0, C4, B_0, fix<0>);                              \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 2pX1");            \
+            } while(false)
+        
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += int(pk) * int(RhsProgress);
+            blA += int(pk) * 2 * int(Traits::LhsProgress);
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 2pX1");
+          }
+
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacket B_0, B1;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += RhsProgress;
+            blA += 2*Traits::LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+          ResPacket R0, R1;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r0.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          }
+        }
+      }
+    }
+    //---------- Process 1 * LhsProgress rows at once ----------
+    if(mr>=1*Traits::LhsProgress)
+    {
+      lhs_process_one_packet<nr, LhsProgress, RhsProgress, LhsScalar, RhsScalar, ResScalar, AccPacket, LhsPacket, RhsPacket, ResPacket, Traits, LinearMapper, DataMapper> p;
+      p(res, blockA, blockB, alpha, peeled_mc2, peeled_mc1, strideA, strideB, offsetA, offsetB, prefetch_res_offset, peeled_kc, pk, cols, depth, packet_cols4);
+    }
+    //---------- Process LhsProgressHalf rows at once ----------
+    if((LhsProgressHalf < LhsProgress) && mr>=LhsProgressHalf)
+    {
+      lhs_process_fraction_of_packet<nr, LhsProgressHalf, RhsProgressHalf, LhsScalar, RhsScalar, ResScalar, AccPacketHalf, LhsPacketHalf, RhsPacketHalf, ResPacketHalf, HalfTraits, LinearMapper, DataMapper> p;
+      p(res, blockA, blockB, alpha, peeled_mc1, peeled_mc_half, strideA, strideB, offsetA, offsetB, prefetch_res_offset, peeled_kc, pk, cols, depth, packet_cols4);
+    }
+    //---------- Process LhsProgressQuarter rows at once ----------
+    if((LhsProgressQuarter < LhsProgressHalf) && mr>=LhsProgressQuarter)
+    {
+      lhs_process_fraction_of_packet<nr, LhsProgressQuarter, RhsProgressQuarter, LhsScalar, RhsScalar, ResScalar, AccPacketQuarter, LhsPacketQuarter, RhsPacketQuarter, ResPacketQuarter, QuarterTraits, LinearMapper, DataMapper> p;
+      p(res, blockA, blockB, alpha, peeled_mc_half, peeled_mc_quarter, strideA, strideB, offsetA, offsetB, prefetch_res_offset, peeled_kc, pk, cols, depth, packet_cols4);
+    }
+    //---------- Process remaining rows, 1 at once ----------
+    if(peeled_mc_quarter<rows)
+    {
+      // loop on each panel of the rhs
+      for(Index j2=0; j2<packet_cols4; j2+=nr)
+      {
+        // loop on each row of the lhs (1*LhsProgress x depth)
+        for(Index i=peeled_mc_quarter; i<rows; i+=1)
+        {
+          const LhsScalar* blA = &blockA[i*strideA+offsetA];
+          prefetch(&blA[0]);
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+
+          // If LhsProgress is 8 or 16, it assumes that there is a
+          // half or quarter packet, respectively, of the same size as
+          // nr (which is currently 4) for the return type.
+          const int SResPacketHalfSize = unpacket_traits<typename unpacket_traits<SResPacket>::half>::size;
+          const int SResPacketQuarterSize = unpacket_traits<typename unpacket_traits<typename unpacket_traits<SResPacket>::half>::half>::size;
+          if ((SwappedTraits::LhsProgress % 4) == 0 &&
+              (SwappedTraits::LhsProgress<=16) &&
+              (SwappedTraits::LhsProgress!=8  || SResPacketHalfSize==nr) &&
+              (SwappedTraits::LhsProgress!=16 || SResPacketQuarterSize==nr))
+          {
+            SAccPacket C0, C1, C2, C3;
+            straits.initAcc(C0);
+            straits.initAcc(C1);
+            straits.initAcc(C2);
+            straits.initAcc(C3);
+
+            const Index spk   = (std::max)(1,SwappedTraits::LhsProgress/4);
+            const Index endk  = (depth/spk)*spk;
+            const Index endk4 = (depth/(spk*4))*(spk*4);
+
+            Index k=0;
+            for(; k<endk4; k+=4*spk)
+            {
+              SLhsPacket A0,A1;
+              SRhsPacket B_0,B_1;
+
+              straits.loadLhsUnaligned(blB+0*SwappedTraits::LhsProgress, A0);
+              straits.loadLhsUnaligned(blB+1*SwappedTraits::LhsProgress, A1);
+
+              straits.loadRhsQuad(blA+0*spk, B_0);
+              straits.loadRhsQuad(blA+1*spk, B_1);
+              straits.madd(A0,B_0,C0,B_0, fix<0>);
+              straits.madd(A1,B_1,C1,B_1, fix<0>);
+
+              straits.loadLhsUnaligned(blB+2*SwappedTraits::LhsProgress, A0);
+              straits.loadLhsUnaligned(blB+3*SwappedTraits::LhsProgress, A1);
+              straits.loadRhsQuad(blA+2*spk, B_0);
+              straits.loadRhsQuad(blA+3*spk, B_1);
+              straits.madd(A0,B_0,C2,B_0, fix<0>);
+              straits.madd(A1,B_1,C3,B_1, fix<0>);
+
+              blB += 4*SwappedTraits::LhsProgress;
+              blA += 4*spk;
+            }
+            C0 = padd(padd(C0,C1),padd(C2,C3));
+            for(; k<endk; k+=spk)
+            {
+              SLhsPacket A0;
+              SRhsPacket B_0;
+
+              straits.loadLhsUnaligned(blB, A0);
+              straits.loadRhsQuad(blA, B_0);
+              straits.madd(A0,B_0,C0,B_0, fix<0>);
+
+              blB += SwappedTraits::LhsProgress;
+              blA += spk;
+            }
+            if(SwappedTraits::LhsProgress==8)
+            {
+              // Special case where we have to first reduce the accumulation register C0
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SResPacket>::half,SResPacket>::type SResPacketHalf;
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SLhsPacket>::half,SLhsPacket>::type SLhsPacketHalf;
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SRhsPacket>::half,SRhsPacket>::type SRhsPacketHalf;
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SAccPacket>::half,SAccPacket>::type SAccPacketHalf;
+
+              SResPacketHalf R = res.template gatherPacket<SResPacketHalf>(i, j2);
+              SResPacketHalf alphav = pset1<SResPacketHalf>(alpha);
+
+              if(depth-endk>0)
+              {
+                // We have to handle the last row of the rhs which corresponds to a half-packet
+                SLhsPacketHalf a0;
+                SRhsPacketHalf b0;
+                straits.loadLhsUnaligned(blB, a0);
+                straits.loadRhs(blA, b0);
+                SAccPacketHalf c0 = predux_half_dowto4(C0);
+                straits.madd(a0,b0,c0,b0, fix<0>);
+                straits.acc(c0, alphav, R);
+              }
+              else
+              {
+                straits.acc(predux_half_dowto4(C0), alphav, R);
+              }
+              res.scatterPacket(i, j2, R);
+            }
+            else if (SwappedTraits::LhsProgress==16)
+            {
+              // Special case where we have to first reduce the
+              // accumulation register C0. We specialize the block in
+              // template form, so that LhsProgress < 16 paths don't
+              // fail to compile
+              last_row_process_16_packets<LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs> p;
+	            p(res, straits, blA, blB, depth, endk, i, j2,alpha, C0);
+            }
+            else
+            {
+              SResPacket R = res.template gatherPacket<SResPacket>(i, j2);
+              SResPacket alphav = pset1<SResPacket>(alpha);
+              straits.acc(C0, alphav, R);
+              res.scatterPacket(i, j2, R);
+            }
+          }
+          else // scalar path
+          {
+            // get a 1 x 4 res block as registers
+            ResScalar C0(0), C1(0), C2(0), C3(0);
+
+            for(Index k=0; k<depth; k++)
+            {
+              LhsScalar A0;
+              RhsScalar B_0, B_1;
+
+              A0 = blA[k];
+
+              B_0 = blB[0];
+              B_1 = blB[1];
+              C0 = cj.pmadd(A0,B_0,C0);
+              C1 = cj.pmadd(A0,B_1,C1);
+
+              B_0 = blB[2];
+              B_1 = blB[3];
+              C2 = cj.pmadd(A0,B_0,C2);
+              C3 = cj.pmadd(A0,B_1,C3);
+
+              blB += 4;
+            }
+            res(i, j2 + 0) += alpha * C0;
+            res(i, j2 + 1) += alpha * C1;
+            res(i, j2 + 2) += alpha * C2;
+            res(i, j2 + 3) += alpha * C3;
+          }
+        }
+      }
+      // remaining columns
+      for(Index j2=packet_cols4; j2<cols; j2++)
+      {
+        // loop on each row of the lhs (1*LhsProgress x depth)
+        for(Index i=peeled_mc_quarter; i<rows; i+=1)
+        {
+          const LhsScalar* blA = &blockA[i*strideA+offsetA];
+          prefetch(&blA[0]);
+          // gets a 1 x 1 res block as registers
+          ResScalar C0(0);
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+          for(Index k=0; k<depth; k++)
+          {
+            LhsScalar A0 = blA[k];
+            RhsScalar B_0 = blB[k];
+            C0 = cj.pmadd(A0, B_0, C0);
+          }
+          res(i, j2) += alpha * C0;
+        }
+      }
+    }
+  }
+
+
+// pack a block of the lhs
+// The traversal is as follow (mr==4):
+//   0  4  8 12 ...
+//   1  5  9 13 ...
+//   2  6 10 14 ...
+//   3  7 11 15 ...
+//
+//  16 20 24 28 ...
+//  17 21 25 29 ...
+//  18 22 26 30 ...
+//  19 23 27 31 ...
+//
+//  32 33 34 35 ...
+//  36 36 38 39 ...
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+{
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  EIGEN_DONT_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+  ::operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  typedef typename unpacket_traits<Packet>::half HalfPacket;
+  typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>::half QuarterPacket;
+  enum { PacketSize = unpacket_traits<Packet>::size,
+         HalfPacketSize = unpacket_traits<HalfPacket>::size,
+         QuarterPacketSize = unpacket_traits<QuarterPacket>::size,
+         HasHalf = (int)HalfPacketSize < (int)PacketSize,
+         HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize};
+
+  EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK LHS");
+  EIGEN_UNUSED_VARIABLE(stride);
+  EIGEN_UNUSED_VARIABLE(offset);
+  eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+  eigen_assert( ((Pack1%PacketSize)==0 && Pack1<=4*PacketSize) || (Pack1<=4) );
+  conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+  Index count = 0;
+
+  const Index peeled_mc3 = Pack1>=3*PacketSize ? (rows/(3*PacketSize))*(3*PacketSize) : 0;
+  const Index peeled_mc2 = Pack1>=2*PacketSize ? peeled_mc3+((rows-peeled_mc3)/(2*PacketSize))*(2*PacketSize) : 0;
+  const Index peeled_mc1 = Pack1>=1*PacketSize ? peeled_mc2+((rows-peeled_mc2)/(1*PacketSize))*(1*PacketSize) : 0;
+  const Index peeled_mc_half = Pack1>=HalfPacketSize ? peeled_mc1+((rows-peeled_mc1)/(HalfPacketSize))*(HalfPacketSize) : 0;
+  const Index peeled_mc_quarter = Pack1>=QuarterPacketSize ? (rows/(QuarterPacketSize))*(QuarterPacketSize) : 0;
+  const Index last_lhs_progress = rows > peeled_mc_quarter ? (rows - peeled_mc_quarter) & ~1 : 0;
+  const Index peeled_mc0 = Pack2>=PacketSize ? peeled_mc_quarter
+                         : Pack2>1 && last_lhs_progress ? (rows/last_lhs_progress)*last_lhs_progress : 0;
+
+  Index i=0;
+
+  // Pack 3 packets
+  if(Pack1>=3*PacketSize)
+  {
+    for(; i<peeled_mc3; i+=3*PacketSize)
+    {
+      if(PanelMode) count += (3*PacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        Packet A, B, C;
+        A = lhs.template loadPacket<Packet>(i+0*PacketSize, k);
+        B = lhs.template loadPacket<Packet>(i+1*PacketSize, k);
+        C = lhs.template loadPacket<Packet>(i+2*PacketSize, k);
+        pstore(blockA+count, cj.pconj(A)); count+=PacketSize;
+        pstore(blockA+count, cj.pconj(B)); count+=PacketSize;
+        pstore(blockA+count, cj.pconj(C)); count+=PacketSize;
+      }
+      if(PanelMode) count += (3*PacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack 2 packets
+  if(Pack1>=2*PacketSize)
+  {
+    for(; i<peeled_mc2; i+=2*PacketSize)
+    {
+      if(PanelMode) count += (2*PacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        Packet A, B;
+        A = lhs.template loadPacket<Packet>(i+0*PacketSize, k);
+        B = lhs.template loadPacket<Packet>(i+1*PacketSize, k);
+        pstore(blockA+count, cj.pconj(A)); count+=PacketSize;
+        pstore(blockA+count, cj.pconj(B)); count+=PacketSize;
+      }
+      if(PanelMode) count += (2*PacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack 1 packets
+  if(Pack1>=1*PacketSize)
+  {
+    for(; i<peeled_mc1; i+=1*PacketSize)
+    {
+      if(PanelMode) count += (1*PacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        Packet A;
+        A = lhs.template loadPacket<Packet>(i+0*PacketSize, k);
+        pstore(blockA+count, cj.pconj(A));
+        count+=PacketSize;
+      }
+      if(PanelMode) count += (1*PacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack half packets
+  if(HasHalf && Pack1>=HalfPacketSize)
+  {
+    for(; i<peeled_mc_half; i+=HalfPacketSize)
+    {
+      if(PanelMode) count += (HalfPacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        HalfPacket A;
+        A = lhs.template loadPacket<HalfPacket>(i+0*(HalfPacketSize), k);
+        pstoreu(blockA+count, cj.pconj(A));
+        count+=HalfPacketSize;
+      }
+      if(PanelMode) count += (HalfPacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack quarter packets
+  if(HasQuarter && Pack1>=QuarterPacketSize)
+  {
+    for(; i<peeled_mc_quarter; i+=QuarterPacketSize)
+    {
+      if(PanelMode) count += (QuarterPacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        QuarterPacket A;
+        A = lhs.template loadPacket<QuarterPacket>(i+0*(QuarterPacketSize), k);
+        pstoreu(blockA+count, cj.pconj(A));
+        count+=QuarterPacketSize;
+      }
+      if(PanelMode) count += (QuarterPacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack2 may be *smaller* than PacketSize—that happens for
+  // products like real * complex, where we have to go half the
+  // progress on the lhs in order to duplicate those operands to
+  // address both real & imaginary parts on the rhs. This portion will
+  // pack those half ones until they match the number expected on the
+  // last peeling loop at this point (for the rhs).
+  if(Pack2<PacketSize && Pack2>1)
+  {
+    for(; i<peeled_mc0; i+=last_lhs_progress)
+    {
+      if(PanelMode) count += last_lhs_progress * offset;
+
+      for(Index k=0; k<depth; k++)
+        for(Index w=0; w<last_lhs_progress; w++)
+          blockA[count++] = cj(lhs(i+w, k));
+
+      if(PanelMode) count += last_lhs_progress * (stride-offset-depth);
+    }
+  }
+  // Pack scalars
+  for(; i<rows; i++)
+  {
+    if(PanelMode) count += offset;
+    for(Index k=0; k<depth; k++)
+      blockA[count++] = cj(lhs(i, k));
+    if(PanelMode) count += (stride-offset-depth);
+  }
+}
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+{
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  EIGEN_DONT_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+  ::operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  typedef typename unpacket_traits<Packet>::half HalfPacket;
+  typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>::half QuarterPacket;
+  enum { PacketSize = unpacket_traits<Packet>::size,
+         HalfPacketSize = unpacket_traits<HalfPacket>::size,
+         QuarterPacketSize = unpacket_traits<QuarterPacket>::size,
+         HasHalf = (int)HalfPacketSize < (int)PacketSize,
+         HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize};
+
+  EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK LHS");
+  EIGEN_UNUSED_VARIABLE(stride);
+  EIGEN_UNUSED_VARIABLE(offset);
+  eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+  conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+  Index count = 0;
+  bool gone_half = false, gone_quarter = false, gone_last = false;
+
+  Index i = 0;
+  int pack = Pack1;
+  int psize = PacketSize;
+  while(pack>0)
+  {
+    Index remaining_rows = rows-i;
+    Index peeled_mc = gone_last ? Pack2>1 ? (rows/pack)*pack : 0 : i+(remaining_rows/pack)*pack;
+    Index starting_pos = i;
+    for(; i<peeled_mc; i+=pack)
+    {
+      if(PanelMode) count += pack * offset;
+
+      Index k=0;
+      if(pack>=psize && psize >= QuarterPacketSize)
+      {
+        const Index peeled_k = (depth/psize)*psize;
+        for(; k<peeled_k; k+=psize)
+        {
+          for (Index m = 0; m < pack; m += psize)
+          {
+            if (psize == PacketSize) {
+              PacketBlock<Packet> kernel;
+              for (int p = 0; p < psize; ++p) kernel.packet[p] = lhs.template loadPacket<Packet>(i+p+m, k);
+              ptranspose(kernel);
+              for (int p = 0; p < psize; ++p) pstore(blockA+count+m+(pack)*p, cj.pconj(kernel.packet[p]));
+            } else if (HasHalf && psize == HalfPacketSize) {
+              gone_half = true;
+              PacketBlock<HalfPacket> kernel_half;
+              for (int p = 0; p < psize; ++p) kernel_half.packet[p] = lhs.template loadPacket<HalfPacket>(i+p+m, k);
+              ptranspose(kernel_half);
+              for (int p = 0; p < psize; ++p) pstore(blockA+count+m+(pack)*p, cj.pconj(kernel_half.packet[p]));
+            } else if (HasQuarter && psize == QuarterPacketSize) {
+              gone_quarter = true;
+              PacketBlock<QuarterPacket> kernel_quarter;
+              for (int p = 0; p < psize; ++p) kernel_quarter.packet[p] = lhs.template loadPacket<QuarterPacket>(i+p+m, k);
+              ptranspose(kernel_quarter);
+              for (int p = 0; p < psize; ++p) pstore(blockA+count+m+(pack)*p, cj.pconj(kernel_quarter.packet[p]));
+	    }
+          }
+          count += psize*pack;
+        }
+      }
+
+      for(; k<depth; k++)
+      {
+        Index w=0;
+        for(; w<pack-3; w+=4)
+        {
+          Scalar a(cj(lhs(i+w+0, k))),
+                 b(cj(lhs(i+w+1, k))),
+                 c(cj(lhs(i+w+2, k))),
+                 d(cj(lhs(i+w+3, k)));
+          blockA[count++] = a;
+          blockA[count++] = b;
+          blockA[count++] = c;
+          blockA[count++] = d;
+        }
+        if(pack%4)
+          for(;w<pack;++w)
+            blockA[count++] = cj(lhs(i+w, k));
+      }
+
+      if(PanelMode) count += pack * (stride-offset-depth);
+    }
+
+    pack -= psize;
+    Index left = rows - i;
+    if (pack <= 0) {
+      if (!gone_last &&
+          (starting_pos == i || left >= psize/2 || left >= psize/4) &&
+          ((psize/2 == HalfPacketSize && HasHalf && !gone_half) ||
+           (psize/2 == QuarterPacketSize && HasQuarter && !gone_quarter))) {
+        psize /= 2;
+        pack = psize;
+        continue;
+      }
+      // Pack2 may be *smaller* than PacketSize—that happens for
+      // products like real * complex, where we have to go half the
+      // progress on the lhs in order to duplicate those operands to
+      // address both real & imaginary parts on the rhs. This portion will
+      // pack those half ones until they match the number expected on the
+      // last peeling loop at this point (for the rhs).
+      if (Pack2 < PacketSize && !gone_last) {
+        gone_last = true;
+        psize = pack = left & ~1;
+      }
+    }
+  }
+
+  for(; i<rows; i++)
+  {
+    if(PanelMode) count += offset;
+    for(Index k=0; k<depth; k++)
+      blockA[count++] = cj(lhs(i, k));
+    if(PanelMode) count += (stride-offset-depth);
+  }
+}
+
+// copy a complete panel of the rhs
+// this version is optimized for column major matrices
+// The traversal order is as follow: (nr==4):
+//  0  1  2  3   12 13 14 15   24 27
+//  4  5  6  7   16 17 18 19   25 28
+//  8  9 10 11   20 21 22 23   26 29
+//  .  .  .  .    .  .  .  .    .  .
+template<typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  enum { PacketSize = packet_traits<Scalar>::size };
+  EIGEN_DONT_INLINE void operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS COLMAJOR");
+  EIGEN_UNUSED_VARIABLE(stride);
+  EIGEN_UNUSED_VARIABLE(offset);
+  eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+  conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+  Index packet_cols8 = nr>=8 ? (cols/8) * 8 : 0;
+  Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+  Index count = 0;
+  const Index peeled_k = (depth/PacketSize)*PacketSize;
+//   if(nr>=8)
+//   {
+//     for(Index j2=0; j2<packet_cols8; j2+=8)
+//     {
+//       // skip what we have before
+//       if(PanelMode) count += 8 * offset;
+//       const Scalar* b0 = &rhs[(j2+0)*rhsStride];
+//       const Scalar* b1 = &rhs[(j2+1)*rhsStride];
+//       const Scalar* b2 = &rhs[(j2+2)*rhsStride];
+//       const Scalar* b3 = &rhs[(j2+3)*rhsStride];
+//       const Scalar* b4 = &rhs[(j2+4)*rhsStride];
+//       const Scalar* b5 = &rhs[(j2+5)*rhsStride];
+//       const Scalar* b6 = &rhs[(j2+6)*rhsStride];
+//       const Scalar* b7 = &rhs[(j2+7)*rhsStride];
+//       Index k=0;
+//       if(PacketSize==8) // TODO enable vectorized transposition for PacketSize==4
+//       {
+//         for(; k<peeled_k; k+=PacketSize) {
+//           PacketBlock<Packet> kernel;
+//           for (int p = 0; p < PacketSize; ++p) {
+//             kernel.packet[p] = ploadu<Packet>(&rhs[(j2+p)*rhsStride+k]);
+//           }
+//           ptranspose(kernel);
+//           for (int p = 0; p < PacketSize; ++p) {
+//             pstoreu(blockB+count, cj.pconj(kernel.packet[p]));
+//             count+=PacketSize;
+//           }
+//         }
+//       }
+//       for(; k<depth; k++)
+//       {
+//         blockB[count+0] = cj(b0[k]);
+//         blockB[count+1] = cj(b1[k]);
+//         blockB[count+2] = cj(b2[k]);
+//         blockB[count+3] = cj(b3[k]);
+//         blockB[count+4] = cj(b4[k]);
+//         blockB[count+5] = cj(b5[k]);
+//         blockB[count+6] = cj(b6[k]);
+//         blockB[count+7] = cj(b7[k]);
+//         count += 8;
+//       }
+//       // skip what we have after
+//       if(PanelMode) count += 8 * (stride-offset-depth);
+//     }
+//   }
+
+  if(nr>=4)
+  {
+    for(Index j2=packet_cols8; j2<packet_cols4; j2+=4)
+    {
+      // skip what we have before
+      if(PanelMode) count += 4 * offset;
+      const LinearMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
+      const LinearMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
+      const LinearMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
+      const LinearMapper dm3 = rhs.getLinearMapper(0, j2 + 3);
+
+      Index k=0;
+      if((PacketSize%4)==0) // TODO enable vectorized transposition for PacketSize==2 ??
+      {
+        for(; k<peeled_k; k+=PacketSize) {
+          PacketBlock<Packet,(PacketSize%4)==0?4:PacketSize> kernel;
+          kernel.packet[0           ] = dm0.template loadPacket<Packet>(k);
+          kernel.packet[1%PacketSize] = dm1.template loadPacket<Packet>(k);
+          kernel.packet[2%PacketSize] = dm2.template loadPacket<Packet>(k);
+          kernel.packet[3%PacketSize] = dm3.template loadPacket<Packet>(k);
+          ptranspose(kernel);
+          pstoreu(blockB+count+0*PacketSize, cj.pconj(kernel.packet[0]));
+          pstoreu(blockB+count+1*PacketSize, cj.pconj(kernel.packet[1%PacketSize]));
+          pstoreu(blockB+count+2*PacketSize, cj.pconj(kernel.packet[2%PacketSize]));
+          pstoreu(blockB+count+3*PacketSize, cj.pconj(kernel.packet[3%PacketSize]));
+          count+=4*PacketSize;
+        }
+      }
+      for(; k<depth; k++)
+      {
+        blockB[count+0] = cj(dm0(k));
+        blockB[count+1] = cj(dm1(k));
+        blockB[count+2] = cj(dm2(k));
+        blockB[count+3] = cj(dm3(k));
+        count += 4;
+      }
+      // skip what we have after
+      if(PanelMode) count += 4 * (stride-offset-depth);
+    }
+  }
+
+  // copy the remaining columns one at a time (nr==1)
+  for(Index j2=packet_cols4; j2<cols; ++j2)
+  {
+    if(PanelMode) count += offset;
+    const LinearMapper dm0 = rhs.getLinearMapper(0, j2);
+    for(Index k=0; k<depth; k++)
+    {
+      blockB[count] = cj(dm0(k));
+      count += 1;
+    }
+    if(PanelMode) count += (stride-offset-depth);
+  }
+}
+
+// this version is optimized for row major matrices
+template<typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<Scalar, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename unpacket_traits<Packet>::half HalfPacket;
+  typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>::half QuarterPacket;
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  enum { PacketSize = packet_traits<Scalar>::size,
+         HalfPacketSize = unpacket_traits<HalfPacket>::size,
+		 QuarterPacketSize = unpacket_traits<QuarterPacket>::size};
+  EIGEN_DONT_INLINE void operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0)
+  {
+    EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS ROWMAJOR");
+    EIGEN_UNUSED_VARIABLE(stride);
+    EIGEN_UNUSED_VARIABLE(offset);
+    eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+    const bool HasHalf = (int)HalfPacketSize < (int)PacketSize;
+    const bool HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize;
+    conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+    Index packet_cols8 = nr>=8 ? (cols/8) * 8 : 0;
+    Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+    Index count = 0;
+
+  //   if(nr>=8)
+  //   {
+  //     for(Index j2=0; j2<packet_cols8; j2+=8)
+  //     {
+  //       // skip what we have before
+  //       if(PanelMode) count += 8 * offset;
+  //       for(Index k=0; k<depth; k++)
+  //       {
+  //         if (PacketSize==8) {
+  //           Packet A = ploadu<Packet>(&rhs[k*rhsStride + j2]);
+  //           pstoreu(blockB+count, cj.pconj(A));
+  //         } else if (PacketSize==4) {
+  //           Packet A = ploadu<Packet>(&rhs[k*rhsStride + j2]);
+  //           Packet B = ploadu<Packet>(&rhs[k*rhsStride + j2 + PacketSize]);
+  //           pstoreu(blockB+count, cj.pconj(A));
+  //           pstoreu(blockB+count+PacketSize, cj.pconj(B));
+  //         } else {
+  //           const Scalar* b0 = &rhs[k*rhsStride + j2];
+  //           blockB[count+0] = cj(b0[0]);
+  //           blockB[count+1] = cj(b0[1]);
+  //           blockB[count+2] = cj(b0[2]);
+  //           blockB[count+3] = cj(b0[3]);
+  //           blockB[count+4] = cj(b0[4]);
+  //           blockB[count+5] = cj(b0[5]);
+  //           blockB[count+6] = cj(b0[6]);
+  //           blockB[count+7] = cj(b0[7]);
+  //         }
+  //         count += 8;
+  //       }
+  //       // skip what we have after
+  //       if(PanelMode) count += 8 * (stride-offset-depth);
+  //     }
+  //   }
+    if(nr>=4)
+    {
+      for(Index j2=packet_cols8; j2<packet_cols4; j2+=4)
+      {
+        // skip what we have before
+        if(PanelMode) count += 4 * offset;
+        for(Index k=0; k<depth; k++)
+        {
+          if (PacketSize==4) {
+            Packet A = rhs.template loadPacket<Packet>(k, j2);
+            pstoreu(blockB+count, cj.pconj(A));
+            count += PacketSize;
+          } else if (HasHalf && HalfPacketSize==4) {
+            HalfPacket A = rhs.template loadPacket<HalfPacket>(k, j2);
+            pstoreu(blockB+count, cj.pconj(A));
+            count += HalfPacketSize;
+          } else if (HasQuarter && QuarterPacketSize==4) {
+            QuarterPacket A = rhs.template loadPacket<QuarterPacket>(k, j2);
+            pstoreu(blockB+count, cj.pconj(A));
+            count += QuarterPacketSize;
+          } else {
+            const LinearMapper dm0 = rhs.getLinearMapper(k, j2);
+            blockB[count+0] = cj(dm0(0));
+            blockB[count+1] = cj(dm0(1));
+            blockB[count+2] = cj(dm0(2));
+            blockB[count+3] = cj(dm0(3));
+            count += 4;
+          }
+        }
+        // skip what we have after
+        if(PanelMode) count += 4 * (stride-offset-depth);
+      }
+    }
+    // copy the remaining columns one at a time (nr==1)
+    for(Index j2=packet_cols4; j2<cols; ++j2)
+    {
+      if(PanelMode) count += offset;
+      for(Index k=0; k<depth; k++)
+      {
+        blockB[count] = cj(rhs(k, j2));
+        count += 1;
+      }
+      if(PanelMode) count += stride-offset-depth;
+    }
+  }
+};
+
+} // end namespace internal
+
+/** \returns the currently set level 1 cpu cache size (in bytes) used to estimate the ideal blocking size parameters.
+  * \sa setCpuCacheSize */
+inline std::ptrdiff_t l1CacheSize()
+{
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  return l1;
+}
+
+/** \returns the currently set level 2 cpu cache size (in bytes) used to estimate the ideal blocking size parameters.
+  * \sa setCpuCacheSize */
+inline std::ptrdiff_t l2CacheSize()
+{
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  return l2;
+}
+
+/** \returns the currently set level 3 cpu cache size (in bytes) used to estimate the ideal blocking size paramete\
+rs.                                                                                                                
+* \sa setCpuCacheSize */
+inline std::ptrdiff_t l3CacheSize()
+{
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  return l3;
+}
+
+/** Set the cpu L1 and L2 cache sizes (in bytes).
+  * These values are use to adjust the size of the blocks
+  * for the algorithms working per blocks.
+  *
+  * \sa computeProductBlockingSizes */
+inline void setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)
+{
+  internal::manage_caching_sizes(SetAction, &l1, &l2, &l3);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_BLOCK_PANEL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrix.h
new file mode 100644
index 00000000..caa65fcc
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrix.h
@@ -0,0 +1,517 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename _LhsScalar, typename _RhsScalar> class level3_blocking;
+
+/* Specialization for a row-major destination matrix => simple transposition of the product */
+template<
+  typename Index,
+  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+  int ResInnerStride>
+struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor,ResInnerStride>
+{
+  typedef gebp_traits<RhsScalar,LhsScalar> Traits;
+
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  static EIGEN_STRONG_INLINE void run(
+    Index rows, Index cols, Index depth,
+    const LhsScalar* lhs, Index lhsStride,
+    const RhsScalar* rhs, Index rhsStride,
+    ResScalar* res, Index resIncr, Index resStride,
+    ResScalar alpha,
+    level3_blocking<RhsScalar,LhsScalar>& blocking,
+    GemmParallelInfo<Index>* info = 0)
+  {
+    // transpose the product such that the result is column major
+    general_matrix_matrix_product<Index,
+      RhsScalar, RhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateRhs,
+      LhsScalar, LhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateLhs,
+      ColMajor,ResInnerStride>
+    ::run(cols,rows,depth,rhs,rhsStride,lhs,lhsStride,res,resIncr,resStride,alpha,blocking,info);
+  }
+};
+
+/*  Specialization for a col-major destination matrix
+ *    => Blocking algorithm following Goto's paper */
+template<
+  typename Index,
+  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+  int ResInnerStride>
+struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride>
+{
+
+typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+static void run(Index rows, Index cols, Index depth,
+  const LhsScalar* _lhs, Index lhsStride,
+  const RhsScalar* _rhs, Index rhsStride,
+  ResScalar* _res, Index resIncr, Index resStride,
+  ResScalar alpha,
+  level3_blocking<LhsScalar,RhsScalar>& blocking,
+  GemmParallelInfo<Index>* info = 0)
+{
+  typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
+  typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;
+  typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor,Unaligned,ResInnerStride> ResMapper;
+  LhsMapper lhs(_lhs, lhsStride);
+  RhsMapper rhs(_rhs, rhsStride);
+  ResMapper res(_res, resStride, resIncr);
+
+  Index kc = blocking.kc();                   // cache block size along the K direction
+  Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+  Index nc = (std::min)(cols,blocking.nc());  // cache block size along the N direction
+
+  gemm_pack_lhs<LhsScalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder> pack_lhs;
+  gemm_pack_rhs<RhsScalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
+  gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp;
+
+#ifdef EIGEN_HAS_OPENMP
+  if(info)
+  {
+    // this is the parallel version!
+    int tid = omp_get_thread_num();
+    int threads = omp_get_num_threads();
+
+    LhsScalar* blockA = blocking.blockA();
+    eigen_internal_assert(blockA!=0);
+
+    std::size_t sizeB = kc*nc;
+    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, 0);
+
+    // For each horizontal panel of the rhs, and corresponding vertical panel of the lhs...
+    for(Index k=0; k<depth; k+=kc)
+    {
+      const Index actual_kc = (std::min)(k+kc,depth)-k; // => rows of B', and cols of the A'
+
+      // In order to reduce the chance that a thread has to wait for the other,
+      // let's start by packing B'.
+      pack_rhs(blockB, rhs.getSubMapper(k,0), actual_kc, nc);
+
+      // Pack A_k to A' in a parallel fashion:
+      // each thread packs the sub block A_k,i to A'_i where i is the thread id.
+
+      // However, before copying to A'_i, we have to make sure that no other thread is still using it,
+      // i.e., we test that info[tid].users equals 0.
+      // Then, we set info[tid].users to the number of threads to mark that all other threads are going to use it.
+      while(info[tid].users!=0) {}
+      info[tid].users = threads;
+
+      pack_lhs(blockA+info[tid].lhs_start*actual_kc, lhs.getSubMapper(info[tid].lhs_start,k), actual_kc, info[tid].lhs_length);
+
+      // Notify the other threads that the part A'_i is ready to go.
+      info[tid].sync = k;
+
+      // Computes C_i += A' * B' per A'_i
+      for(int shift=0; shift<threads; ++shift)
+      {
+        int i = (tid+shift)%threads;
+
+        // At this point we have to make sure that A'_i has been updated by the thread i,
+        // we use testAndSetOrdered to mimic a volatile access.
+        // However, no need to wait for the B' part which has been updated by the current thread!
+        if (shift>0) {
+          while(info[i].sync!=k) {
+          }
+        }
+
+        gebp(res.getSubMapper(info[i].lhs_start, 0), blockA+info[i].lhs_start*actual_kc, blockB, info[i].lhs_length, actual_kc, nc, alpha);
+      }
+
+      // Then keep going as usual with the remaining B'
+      for(Index j=nc; j<cols; j+=nc)
+      {
+        const Index actual_nc = (std::min)(j+nc,cols)-j;
+
+        // pack B_k,j to B'
+        pack_rhs(blockB, rhs.getSubMapper(k,j), actual_kc, actual_nc);
+
+        // C_j += A' * B'
+        gebp(res.getSubMapper(0, j), blockA, blockB, rows, actual_kc, actual_nc, alpha);
+      }
+
+      // Release all the sub blocks A'_i of A' for the current thread,
+      // i.e., we simply decrement the number of users by 1
+      for(Index i=0; i<threads; ++i)
+#if !EIGEN_HAS_CXX11_ATOMIC
+        #pragma omp atomic
+#endif
+        info[i].users -= 1;
+    }
+  }
+  else
+#endif // EIGEN_HAS_OPENMP
+  {
+    EIGEN_UNUSED_VARIABLE(info);
+
+    // this is the sequential version!
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*nc;
+
+    ei_declare_aligned_stack_constructed_variable(LhsScalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, blocking.blockB());
+
+    const bool pack_rhs_once = mc!=rows && kc==depth && nc==cols;
+
+    // For each horizontal panel of the rhs, and corresponding panel of the lhs...
+    for(Index i2=0; i2<rows; i2+=mc)
+    {
+      const Index actual_mc = (std::min)(i2+mc,rows)-i2;
+
+      for(Index k2=0; k2<depth; k2+=kc)
+      {
+        const Index actual_kc = (std::min)(k2+kc,depth)-k2;
+
+        // OK, here we have selected one horizontal panel of rhs and one vertical panel of lhs.
+        // => Pack lhs's panel into a sequential chunk of memory (L2/L3 caching)
+        // Note that this panel will be read as many times as the number of blocks in the rhs's
+        // horizontal panel which is, in practice, a very low number.
+        pack_lhs(blockA, lhs.getSubMapper(i2,k2), actual_kc, actual_mc);
+
+        // For each kc x nc block of the rhs's horizontal panel...
+        for(Index j2=0; j2<cols; j2+=nc)
+        {
+          const Index actual_nc = (std::min)(j2+nc,cols)-j2;
+
+          // We pack the rhs's block into a sequential chunk of memory (L2 caching)
+          // Note that this block will be read a very high number of times, which is equal to the number of
+          // micro horizontal panel of the large rhs's panel (e.g., rows/12 times).
+          if((!pack_rhs_once) || i2==0)
+            pack_rhs(blockB, rhs.getSubMapper(k2,j2), actual_kc, actual_nc);
+
+          // Everything is packed, we can now call the panel * block kernel:
+          gebp(res.getSubMapper(i2, j2), blockA, blockB, actual_mc, actual_kc, actual_nc, alpha);
+        }
+      }
+    }
+  }
+}
+
+};
+
+/*********************************************************************************
+*  Specialization of generic_product_impl for "large" GEMM, i.e.,
+*  implementation of the high level wrapper to general_matrix_matrix_product
+**********************************************************************************/
+
+template<typename Scalar, typename Index, typename Gemm, typename Lhs, typename Rhs, typename Dest, typename BlockingType>
+struct gemm_functor
+{
+  gemm_functor(const Lhs& lhs, const Rhs& rhs, Dest& dest, const Scalar& actualAlpha, BlockingType& blocking)
+    : m_lhs(lhs), m_rhs(rhs), m_dest(dest), m_actualAlpha(actualAlpha), m_blocking(blocking)
+  {}
+
+  void initParallelSession(Index num_threads) const
+  {
+    m_blocking.initParallel(m_lhs.rows(), m_rhs.cols(), m_lhs.cols(), num_threads);
+    m_blocking.allocateA();
+  }
+
+  void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
+  {
+    if(cols==-1)
+      cols = m_rhs.cols();
+
+    Gemm::run(rows, cols, m_lhs.cols(),
+              &m_lhs.coeffRef(row,0), m_lhs.outerStride(),
+              &m_rhs.coeffRef(0,col), m_rhs.outerStride(),
+              (Scalar*)&(m_dest.coeffRef(row,col)), m_dest.innerStride(), m_dest.outerStride(),
+              m_actualAlpha, m_blocking, info);
+  }
+
+  typedef typename Gemm::Traits Traits;
+
+  protected:
+    const Lhs& m_lhs;
+    const Rhs& m_rhs;
+    Dest& m_dest;
+    Scalar m_actualAlpha;
+    BlockingType& m_blocking;
+};
+
+template<int StorageOrder, typename LhsScalar, typename RhsScalar, int MaxRows, int MaxCols, int MaxDepth, int KcFactor=1,
+bool FiniteAtCompileTime = MaxRows!=Dynamic && MaxCols!=Dynamic && MaxDepth != Dynamic> class gemm_blocking_space;
+
+template<typename _LhsScalar, typename _RhsScalar>
+class level3_blocking
+{
+    typedef _LhsScalar LhsScalar;
+    typedef _RhsScalar RhsScalar;
+
+  protected:
+    LhsScalar* m_blockA;
+    RhsScalar* m_blockB;
+
+    Index m_mc;
+    Index m_nc;
+    Index m_kc;
+
+  public:
+
+    level3_blocking()
+      : m_blockA(0), m_blockB(0), m_mc(0), m_nc(0), m_kc(0)
+    {}
+
+    inline Index mc() const { return m_mc; }
+    inline Index nc() const { return m_nc; }
+    inline Index kc() const { return m_kc; }
+
+    inline LhsScalar* blockA() { return m_blockA; }
+    inline RhsScalar* blockB() { return m_blockB; }
+};
+
+template<int StorageOrder, typename _LhsScalar, typename _RhsScalar, int MaxRows, int MaxCols, int MaxDepth, int KcFactor>
+class gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols, MaxDepth, KcFactor, true /* == FiniteAtCompileTime */>
+  : public level3_blocking<
+      typename conditional<StorageOrder==RowMajor,_RhsScalar,_LhsScalar>::type,
+      typename conditional<StorageOrder==RowMajor,_LhsScalar,_RhsScalar>::type>
+{
+    enum {
+      Transpose = StorageOrder==RowMajor,
+      ActualRows = Transpose ? MaxCols : MaxRows,
+      ActualCols = Transpose ? MaxRows : MaxCols
+    };
+    typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsScalar;
+    typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsScalar;
+    typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+    enum {
+      SizeA = ActualRows * MaxDepth,
+      SizeB = ActualCols * MaxDepth
+    };
+
+#if EIGEN_MAX_STATIC_ALIGN_BYTES >= EIGEN_DEFAULT_ALIGN_BYTES
+    EIGEN_ALIGN_MAX LhsScalar m_staticA[SizeA];
+    EIGEN_ALIGN_MAX RhsScalar m_staticB[SizeB];
+#else
+    EIGEN_ALIGN_MAX char m_staticA[SizeA * sizeof(LhsScalar) + EIGEN_DEFAULT_ALIGN_BYTES-1];
+    EIGEN_ALIGN_MAX char m_staticB[SizeB * sizeof(RhsScalar) + EIGEN_DEFAULT_ALIGN_BYTES-1];
+#endif
+
+  public:
+
+    gemm_blocking_space(Index /*rows*/, Index /*cols*/, Index /*depth*/, Index /*num_threads*/, bool /*full_rows = false*/)
+    {
+      this->m_mc = ActualRows;
+      this->m_nc = ActualCols;
+      this->m_kc = MaxDepth;
+#if EIGEN_MAX_STATIC_ALIGN_BYTES >= EIGEN_DEFAULT_ALIGN_BYTES
+      this->m_blockA = m_staticA;
+      this->m_blockB = m_staticB;
+#else
+      this->m_blockA = reinterpret_cast<LhsScalar*>((internal::UIntPtr(m_staticA) + (EIGEN_DEFAULT_ALIGN_BYTES-1)) & ~std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1));
+      this->m_blockB = reinterpret_cast<RhsScalar*>((internal::UIntPtr(m_staticB) + (EIGEN_DEFAULT_ALIGN_BYTES-1)) & ~std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1));
+#endif
+    }
+
+    void initParallel(Index, Index, Index, Index)
+    {}
+
+    inline void allocateA() {}
+    inline void allocateB() {}
+    inline void allocateAll() {}
+};
+
+template<int StorageOrder, typename _LhsScalar, typename _RhsScalar, int MaxRows, int MaxCols, int MaxDepth, int KcFactor>
+class gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols, MaxDepth, KcFactor, false>
+  : public level3_blocking<
+      typename conditional<StorageOrder==RowMajor,_RhsScalar,_LhsScalar>::type,
+      typename conditional<StorageOrder==RowMajor,_LhsScalar,_RhsScalar>::type>
+{
+    enum {
+      Transpose = StorageOrder==RowMajor
+    };
+    typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsScalar;
+    typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsScalar;
+    typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+    Index m_sizeA;
+    Index m_sizeB;
+
+  public:
+
+    gemm_blocking_space(Index rows, Index cols, Index depth, Index num_threads, bool l3_blocking)
+    {
+      this->m_mc = Transpose ? cols : rows;
+      this->m_nc = Transpose ? rows : cols;
+      this->m_kc = depth;
+
+      if(l3_blocking)
+      {
+        computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, this->m_mc, this->m_nc, num_threads);
+      }
+      else  // no l3 blocking
+      {
+        Index n = this->m_nc;
+        computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, this->m_mc, n, num_threads);
+      }
+
+      m_sizeA = this->m_mc * this->m_kc;
+      m_sizeB = this->m_kc * this->m_nc;
+    }
+
+    void initParallel(Index rows, Index cols, Index depth, Index num_threads)
+    {
+      this->m_mc = Transpose ? cols : rows;
+      this->m_nc = Transpose ? rows : cols;
+      this->m_kc = depth;
+
+      eigen_internal_assert(this->m_blockA==0 && this->m_blockB==0);
+      Index m = this->m_mc;
+      computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, m, this->m_nc, num_threads);
+      m_sizeA = this->m_mc * this->m_kc;
+      m_sizeB = this->m_kc * this->m_nc;
+    }
+
+    void allocateA()
+    {
+      if(this->m_blockA==0)
+        this->m_blockA = aligned_new<LhsScalar>(m_sizeA);
+    }
+
+    void allocateB()
+    {
+      if(this->m_blockB==0)
+        this->m_blockB = aligned_new<RhsScalar>(m_sizeB);
+    }
+
+    void allocateAll()
+    {
+      allocateA();
+      allocateB();
+    }
+
+    ~gemm_blocking_space()
+    {
+      aligned_delete(this->m_blockA, m_sizeA);
+      aligned_delete(this->m_blockB, m_sizeB);
+    }
+};
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  typedef typename Lhs::Scalar LhsScalar;
+  typedef typename Rhs::Scalar RhsScalar;
+
+  typedef internal::blas_traits<Lhs> LhsBlasTraits;
+  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+  typedef typename internal::remove_all<ActualLhsType>::type ActualLhsTypeCleaned;
+
+  typedef internal::blas_traits<Rhs> RhsBlasTraits;
+  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+  enum {
+    MaxDepthAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(Lhs::MaxColsAtCompileTime,Rhs::MaxRowsAtCompileTime)
+  };
+
+  typedef generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,CoeffBasedProductMode> lazyproduct;
+
+  template<typename Dst>
+  static void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=404 for a discussion and helper program
+    // to determine the following heuristic.
+    // EIGEN_GEMM_TO_COEFFBASED_THRESHOLD is typically defined to 20 in GeneralProduct.h,
+    // unless it has been specialized by the user or for a given architecture.
+    // Note that the condition rhs.rows()>0 was required because lazy product is (was?) not happy with empty inputs.
+    // I'm not sure it is still required.
+    if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
+      lazyproduct::eval_dynamic(dst, lhs, rhs, internal::assign_op<typename Dst::Scalar,Scalar>());
+    else
+    {
+      dst.setZero();
+      scaleAndAddTo(dst, lhs, rhs, Scalar(1));
+    }
+  }
+
+  template<typename Dst>
+  static void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
+      lazyproduct::eval_dynamic(dst, lhs, rhs, internal::add_assign_op<typename Dst::Scalar,Scalar>());
+    else
+      scaleAndAddTo(dst,lhs, rhs, Scalar(1));
+  }
+
+  template<typename Dst>
+  static void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
+      lazyproduct::eval_dynamic(dst, lhs, rhs, internal::sub_assign_op<typename Dst::Scalar,Scalar>());
+    else
+      scaleAndAddTo(dst, lhs, rhs, Scalar(-1));
+  }
+
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& a_lhs, const Rhs& a_rhs, const Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==a_lhs.rows() && dst.cols()==a_rhs.cols());
+    if(a_lhs.cols()==0 || a_lhs.rows()==0 || a_rhs.cols()==0)
+      return;
+
+    if (dst.cols() == 1)
+    {
+      // Fallback to GEMV if either the lhs or rhs is a runtime vector
+      typename Dest::ColXpr dst_vec(dst.col(0));
+      return internal::generic_product_impl<Lhs,typename Rhs::ConstColXpr,DenseShape,DenseShape,GemvProduct>
+        ::scaleAndAddTo(dst_vec, a_lhs, a_rhs.col(0), alpha);
+    }
+    else if (dst.rows() == 1)
+    {
+      // Fallback to GEMV if either the lhs or rhs is a runtime vector
+      typename Dest::RowXpr dst_vec(dst.row(0));
+      return internal::generic_product_impl<typename Lhs::ConstRowXpr,Rhs,DenseShape,DenseShape,GemvProduct>
+        ::scaleAndAddTo(dst_vec, a_lhs.row(0), a_rhs, alpha);
+    }
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    Scalar actualAlpha = combine_scalar_factors(alpha, a_lhs, a_rhs);
+
+    typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,LhsScalar,RhsScalar,
+            Dest::MaxRowsAtCompileTime,Dest::MaxColsAtCompileTime,MaxDepthAtCompileTime> BlockingType;
+
+    typedef internal::gemm_functor<
+      Scalar, Index,
+      internal::general_matrix_matrix_product<
+        Index,
+        LhsScalar, (ActualLhsTypeCleaned::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(LhsBlasTraits::NeedToConjugate),
+        RhsScalar, (ActualRhsTypeCleaned::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(RhsBlasTraits::NeedToConjugate),
+        (Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,
+        Dest::InnerStrideAtCompileTime>,
+      ActualLhsTypeCleaned, ActualRhsTypeCleaned, Dest, BlockingType> GemmFunctor;
+
+    BlockingType blocking(dst.rows(), dst.cols(), lhs.cols(), 1, true);
+    internal::parallelize_gemm<(Dest::MaxRowsAtCompileTime>32 || Dest::MaxRowsAtCompileTime==Dynamic)>
+        (GemmFunctor(lhs, rhs, dst, actualAlpha, blocking), a_lhs.rows(), a_rhs.cols(), a_lhs.cols(), Dest::Flags&RowMajorBit);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
new file mode 100644
index 00000000..6ba0d9bd
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
@@ -0,0 +1,317 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
+
+namespace Eigen { 
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjLhs, bool ConjRhs>
+struct selfadjoint_rank1_update;
+
+namespace internal {
+
+/**********************************************************************
+* This file implements a general A * B product while
+* evaluating only one triangular part of the product.
+* This is a more general version of self adjoint product (C += A A^T)
+* as the level 3 SYRK Blas routine.
+**********************************************************************/
+
+// forward declarations (defined at the end of this file)
+template<typename LhsScalar, typename RhsScalar, typename Index, int mr, int nr, bool ConjLhs, bool ConjRhs, int ResInnerStride, int UpLo>
+struct tribb_kernel;
+  
+/* Optimized matrix-matrix product evaluating only one triangular half */
+template <typename Index,
+          typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+                              int ResStorageOrder, int ResInnerStride, int  UpLo, int Version = Specialized>
+struct general_matrix_matrix_triangular_product;
+
+// as usual if the result is row major => we transpose the product
+template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+                          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+                          int ResInnerStride, int  UpLo, int Version>
+struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor,ResInnerStride,UpLo,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* lhs, Index lhsStride,
+                                      const RhsScalar* rhs, Index rhsStride, ResScalar* res, Index resIncr, Index resStride,
+                                      const ResScalar& alpha, level3_blocking<RhsScalar,LhsScalar>& blocking)
+  {
+    general_matrix_matrix_triangular_product<Index,
+        RhsScalar, RhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateRhs,
+        LhsScalar, LhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateLhs,
+        ColMajor, ResInnerStride, UpLo==Lower?Upper:Lower>
+      ::run(size,depth,rhs,rhsStride,lhs,lhsStride,res,resIncr,resStride,alpha,blocking);
+  }
+};
+
+template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+                          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+                          int ResInnerStride, int  UpLo, int Version>
+struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride,UpLo,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* _lhs, Index lhsStride,
+                                      const RhsScalar* _rhs, Index rhsStride,
+                                      ResScalar* _res, Index resIncr, Index resStride,
+                                      const ResScalar& alpha, level3_blocking<LhsScalar,RhsScalar>& blocking)
+  {
+    typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+    typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride, resIncr);
+
+    Index kc = blocking.kc();
+    Index mc = (std::min)(size,blocking.mc());
+
+    // !!! mc must be a multiple of nr:
+    if(mc > Traits::nr)
+      mc = (mc/Traits::nr)*Traits::nr;
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*size;
+
+    ei_declare_aligned_stack_constructed_variable(LhsScalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, blocking.blockB());
+
+    gemm_pack_lhs<LhsScalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<RhsScalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
+    gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp;
+    tribb_kernel<LhsScalar, RhsScalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs, ResInnerStride, UpLo> sybb;
+
+    for(Index k2=0; k2<depth; k2+=kc)
+    {
+      const Index actual_kc = (std::min)(k2+kc,depth)-k2;
+
+      // note that the actual rhs is the transpose/adjoint of mat
+      pack_rhs(blockB, rhs.getSubMapper(k2,0), actual_kc, size);
+
+      for(Index i2=0; i2<size; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,size)-i2;
+
+        pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        // the selected actual_mc * size panel of res is split into three different part:
+        //  1 - before the diagonal => processed with gebp or skipped
+        //  2 - the actual_mc x actual_mc symmetric block => processed with a special kernel
+        //  3 - after the diagonal => processed with gebp or skipped
+        if (UpLo==Lower)
+          gebp(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc,
+               (std::min)(size,i2), alpha, -1, -1, 0, 0);
+
+        sybb(_res+resStride*i2 + resIncr*i2, resIncr, resStride, blockA, blockB + actual_kc*i2, actual_mc, actual_kc, alpha);
+
+        if (UpLo==Upper)
+        {
+          Index j2 = i2+actual_mc;
+          gebp(res.getSubMapper(i2, j2), blockA, blockB+actual_kc*j2, actual_mc,
+               actual_kc, (std::max)(Index(0), size-j2), alpha, -1, -1, 0, 0);
+        }
+      }
+    }
+  }
+};
+
+// Optimized packed Block * packed Block product kernel evaluating only one given triangular part
+// This kernel is built on top of the gebp kernel:
+// - the current destination block is processed per panel of actual_mc x BlockSize
+//   where BlockSize is set to the minimal value allowing gebp to be as fast as possible
+// - then, as usual, each panel is split into three parts along the diagonal,
+//   the sub blocks above and below the diagonal are processed as usual,
+//   while the triangular block overlapping the diagonal is evaluated into a
+//   small temporary buffer which is then accumulated into the result using a
+//   triangular traversal.
+template<typename LhsScalar, typename RhsScalar, typename Index, int mr, int nr, bool ConjLhs, bool ConjRhs, int ResInnerStride, int UpLo>
+struct tribb_kernel
+{
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjLhs,ConjRhs> Traits;
+  typedef typename Traits::ResScalar ResScalar;
+
+  enum {
+    BlockSize  = meta_least_common_multiple<EIGEN_PLAIN_ENUM_MAX(mr,nr),EIGEN_PLAIN_ENUM_MIN(mr,nr)>::ret
+  };
+  void operator()(ResScalar* _res, Index resIncr, Index resStride, const LhsScalar* blockA, const RhsScalar* blockB, Index size, Index depth, const ResScalar& alpha)
+  {
+    typedef blas_data_mapper<ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    typedef blas_data_mapper<ResScalar, Index, ColMajor, Unaligned> BufferMapper;
+    ResMapper res(_res, resStride, resIncr);
+    gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, mr, nr, ConjLhs, ConjRhs> gebp_kernel1;
+    gebp_kernel<LhsScalar, RhsScalar, Index, BufferMapper, mr, nr, ConjLhs, ConjRhs> gebp_kernel2;
+
+    Matrix<ResScalar,BlockSize,BlockSize,ColMajor> buffer((internal::constructor_without_unaligned_array_assert()));
+
+    // let's process the block per panel of actual_mc x BlockSize,
+    // again, each is split into three parts, etc.
+    for (Index j=0; j<size; j+=BlockSize)
+    {
+      Index actualBlockSize = std::min<Index>(BlockSize,size - j);
+      const RhsScalar* actual_b = blockB+j*depth;
+
+      if(UpLo==Upper)
+        gebp_kernel1(res.getSubMapper(0, j), blockA, actual_b, j, depth, actualBlockSize, alpha,
+                     -1, -1, 0, 0);
+      
+      // selfadjoint micro block
+      {
+        Index i = j;
+        buffer.setZero();
+        // 1 - apply the kernel on the temporary buffer
+        gebp_kernel2(BufferMapper(buffer.data(), BlockSize), blockA+depth*i, actual_b, actualBlockSize, depth, actualBlockSize, alpha,
+                     -1, -1, 0, 0);
+
+        // 2 - triangular accumulation
+        for(Index j1=0; j1<actualBlockSize; ++j1)
+        {
+          typename ResMapper::LinearMapper r = res.getLinearMapper(i,j+j1);
+          for(Index i1=UpLo==Lower ? j1 : 0;
+              UpLo==Lower ? i1<actualBlockSize : i1<=j1; ++i1)
+            r(i1) += buffer(i1,j1);
+        }
+      }
+
+      if(UpLo==Lower)
+      {
+        Index i = j+actualBlockSize;
+        gebp_kernel1(res.getSubMapper(i, j), blockA+depth*i, actual_b, size-i, 
+                     depth, actualBlockSize, alpha, -1, -1, 0, 0);
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+// high level API
+
+template<typename MatrixType, typename ProductType, int UpLo, bool IsOuterProduct>
+struct general_product_to_triangular_selector;
+
+
+template<typename MatrixType, typename ProductType, int UpLo>
+struct general_product_to_triangular_selector<MatrixType,ProductType,UpLo,true>
+{
+  static void run(MatrixType& mat, const ProductType& prod, const typename MatrixType::Scalar& alpha, bool beta)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    
+    typedef typename internal::remove_all<typename ProductType::LhsNested>::type Lhs;
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
+    typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
+    typename internal::add_const_on_value_type<ActualLhs>::type actualLhs = LhsBlasTraits::extract(prod.lhs());
+    
+    typedef typename internal::remove_all<typename ProductType::RhsNested>::type Rhs;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
+    typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
+    typename internal::add_const_on_value_type<ActualRhs>::type actualRhs = RhsBlasTraits::extract(prod.rhs());
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(prod.lhs().derived()) * RhsBlasTraits::extractScalarFactor(prod.rhs().derived());
+
+    if(!beta)
+      mat.template triangularView<UpLo>().setZero();
+
+    enum {
+      StorageOrder = (internal::traits<MatrixType>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+      UseLhsDirectly = _ActualLhs::InnerStrideAtCompileTime==1,
+      UseRhsDirectly = _ActualRhs::InnerStrideAtCompileTime==1
+    };
+    
+    internal::gemv_static_vector_if<Scalar,Lhs::SizeAtCompileTime,Lhs::MaxSizeAtCompileTime,!UseLhsDirectly> static_lhs;
+    ei_declare_aligned_stack_constructed_variable(Scalar, actualLhsPtr, actualLhs.size(),
+      (UseLhsDirectly ? const_cast<Scalar*>(actualLhs.data()) : static_lhs.data()));
+    if(!UseLhsDirectly) Map<typename _ActualLhs::PlainObject>(actualLhsPtr, actualLhs.size()) = actualLhs;
+    
+    internal::gemv_static_vector_if<Scalar,Rhs::SizeAtCompileTime,Rhs::MaxSizeAtCompileTime,!UseRhsDirectly> static_rhs;
+    ei_declare_aligned_stack_constructed_variable(Scalar, actualRhsPtr, actualRhs.size(),
+      (UseRhsDirectly ? const_cast<Scalar*>(actualRhs.data()) : static_rhs.data()));
+    if(!UseRhsDirectly) Map<typename _ActualRhs::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    
+    
+    selfadjoint_rank1_update<Scalar,Index,StorageOrder,UpLo,
+                              LhsBlasTraits::NeedToConjugate && NumTraits<Scalar>::IsComplex,
+                              RhsBlasTraits::NeedToConjugate && NumTraits<Scalar>::IsComplex>
+          ::run(actualLhs.size(), mat.data(), mat.outerStride(), actualLhsPtr, actualRhsPtr, actualAlpha);
+  }
+};
+
+template<typename MatrixType, typename ProductType, int UpLo>
+struct general_product_to_triangular_selector<MatrixType,ProductType,UpLo,false>
+{
+  static void run(MatrixType& mat, const ProductType& prod, const typename MatrixType::Scalar& alpha, bool beta)
+  {
+    typedef typename internal::remove_all<typename ProductType::LhsNested>::type Lhs;
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
+    typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
+    typename internal::add_const_on_value_type<ActualLhs>::type actualLhs = LhsBlasTraits::extract(prod.lhs());
+    
+    typedef typename internal::remove_all<typename ProductType::RhsNested>::type Rhs;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
+    typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
+    typename internal::add_const_on_value_type<ActualRhs>::type actualRhs = RhsBlasTraits::extract(prod.rhs());
+
+    typename ProductType::Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(prod.lhs().derived()) * RhsBlasTraits::extractScalarFactor(prod.rhs().derived());
+
+    if(!beta)
+      mat.template triangularView<UpLo>().setZero();
+
+    enum {
+      IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0,
+      LhsIsRowMajor = _ActualLhs::Flags&RowMajorBit ? 1 : 0,
+      RhsIsRowMajor = _ActualRhs::Flags&RowMajorBit ? 1 : 0,
+      SkipDiag = (UpLo&(UnitDiag|ZeroDiag))!=0
+    };
+
+    Index size = mat.cols();
+    if(SkipDiag)
+      size--;
+    Index depth = actualLhs.cols();
+
+    typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,typename Lhs::Scalar,typename Rhs::Scalar,
+          MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime, _ActualRhs::MaxColsAtCompileTime> BlockingType;
+
+    BlockingType blocking(size, size, depth, 1, false);
+
+    internal::general_matrix_matrix_triangular_product<Index,
+      typename Lhs::Scalar, LhsIsRowMajor ? RowMajor : ColMajor, LhsBlasTraits::NeedToConjugate,
+      typename Rhs::Scalar, RhsIsRowMajor ? RowMajor : ColMajor, RhsBlasTraits::NeedToConjugate,
+      IsRowMajor ? RowMajor : ColMajor, MatrixType::InnerStrideAtCompileTime, UpLo&(Lower|Upper)>
+      ::run(size, depth,
+            &actualLhs.coeffRef(SkipDiag&&(UpLo&Lower)==Lower ? 1 : 0,0), actualLhs.outerStride(),
+            &actualRhs.coeffRef(0,SkipDiag&&(UpLo&Upper)==Upper ? 1 : 0), actualRhs.outerStride(),
+            mat.data() + (SkipDiag ? (bool(IsRowMajor) != ((UpLo&Lower)==Lower) ? mat.innerStride() : mat.outerStride() ) : 0),
+            mat.innerStride(), mat.outerStride(), actualAlpha, blocking);
+  }
+};
+
+template<typename MatrixType, unsigned int UpLo>
+template<typename ProductType>
+EIGEN_DEVICE_FUNC TriangularView<MatrixType,UpLo>& TriangularViewImpl<MatrixType,UpLo,Dense>::_assignProduct(const ProductType& prod, const Scalar& alpha, bool beta)
+{
+  EIGEN_STATIC_ASSERT((UpLo&UnitDiag)==0, WRITING_TO_TRIANGULAR_PART_WITH_UNIT_DIAGONAL_IS_NOT_SUPPORTED);
+  eigen_assert(derived().nestedExpression().rows() == prod.rows() && derived().cols() == prod.cols());
+
+  general_product_to_triangular_selector<MatrixType, ProductType, UpLo, internal::traits<ProductType>::InnerSize==1>::run(derived().nestedExpression().const_cast_derived(), prod, alpha, beta);
+
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
new file mode 100644
index 00000000..9a650ec2
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
@@ -0,0 +1,145 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Level 3 BLAS SYRK/HERK implementation.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Index, typename Scalar, int AStorageOrder, bool ConjugateA, int ResStorageOrder, int UpLo>
+struct general_matrix_matrix_rankupdate :
+       general_matrix_matrix_triangular_product<
+         Index,Scalar,AStorageOrder,ConjugateA,Scalar,AStorageOrder,ConjugateA,ResStorageOrder,1,UpLo,BuiltIn> {};
+
+
+// try to go to BLAS specialization
+#define EIGEN_BLAS_RANKUPDATE_SPECIALIZE(Scalar) \
+template <typename Index, int LhsStorageOrder, bool ConjugateLhs, \
+                          int RhsStorageOrder, bool ConjugateRhs, int  UpLo> \
+struct general_matrix_matrix_triangular_product<Index,Scalar,LhsStorageOrder,ConjugateLhs, \
+               Scalar,RhsStorageOrder,ConjugateRhs,ColMajor,1,UpLo,Specialized> { \
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const Scalar* lhs, Index lhsStride, \
+                          const Scalar* rhs, Index rhsStride, Scalar* res, Index resIncr, Index resStride, Scalar alpha, level3_blocking<Scalar, Scalar>& blocking) \
+  { \
+    if ( lhs==rhs && ((UpLo&(Lower|Upper))==UpLo) ) { \
+      general_matrix_matrix_rankupdate<Index,Scalar,LhsStorageOrder,ConjugateLhs,ColMajor,UpLo> \
+      ::run(size,depth,lhs,lhsStride,rhs,rhsStride,res,resStride,alpha,blocking); \
+    } else { \
+      general_matrix_matrix_triangular_product<Index, \
+        Scalar, LhsStorageOrder, ConjugateLhs, \
+        Scalar, RhsStorageOrder, ConjugateRhs, \
+        ColMajor, 1, UpLo, BuiltIn> \
+      ::run(size,depth,lhs,lhsStride,rhs,rhsStride,res,resIncr,resStride,alpha,blocking); \
+    } \
+  } \
+};
+
+EIGEN_BLAS_RANKUPDATE_SPECIALIZE(double)
+EIGEN_BLAS_RANKUPDATE_SPECIALIZE(float)
+// TODO handle complex cases
+// EIGEN_BLAS_RANKUPDATE_SPECIALIZE(dcomplex)
+// EIGEN_BLAS_RANKUPDATE_SPECIALIZE(scomplex)
+
+// SYRK for float/double
+#define EIGEN_BLAS_RANKUPDATE_R(EIGTYPE, BLASTYPE, BLASFUNC) \
+template <typename Index, int AStorageOrder, bool ConjugateA, int  UpLo> \
+struct general_matrix_matrix_rankupdate<Index,EIGTYPE,AStorageOrder,ConjugateA,ColMajor,UpLo> { \
+  enum { \
+    IsLower = (UpLo&Lower) == Lower, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = ((AStorageOrder==ColMajor) && ConjugateA) ? 1 : 0 \
+  }; \
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const EIGTYPE* lhs, Index lhsStride, \
+                          const EIGTYPE* /*rhs*/, Index /*rhsStride*/, EIGTYPE* res, Index resStride, EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+  /* typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs;*/ \
+\
+   BlasIndex lda=convert_index<BlasIndex>(lhsStride), ldc=convert_index<BlasIndex>(resStride), n=convert_index<BlasIndex>(size), k=convert_index<BlasIndex>(depth); \
+   char uplo=((IsLower) ? 'L' : 'U'), trans=((AStorageOrder==RowMajor) ? 'T':'N'); \
+   EIGTYPE beta(1); \
+   BLASFUNC(&uplo, &trans, &n, &k, (const BLASTYPE*)&numext::real_ref(alpha), lhs, &lda, (const BLASTYPE*)&numext::real_ref(beta), res, &ldc); \
+  } \
+};
+
+// HERK for complex data
+#define EIGEN_BLAS_RANKUPDATE_C(EIGTYPE, BLASTYPE, RTYPE, BLASFUNC) \
+template <typename Index, int AStorageOrder, bool ConjugateA, int  UpLo> \
+struct general_matrix_matrix_rankupdate<Index,EIGTYPE,AStorageOrder,ConjugateA,ColMajor,UpLo> { \
+  enum { \
+    IsLower = (UpLo&Lower) == Lower, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = (((AStorageOrder==ColMajor) && ConjugateA) || ((AStorageOrder==RowMajor) && !ConjugateA)) ? 1 : 0 \
+  }; \
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const EIGTYPE* lhs, Index lhsStride, \
+                          const EIGTYPE* /*rhs*/, Index /*rhsStride*/, EIGTYPE* res, Index resStride, EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, AStorageOrder> MatrixType; \
+\
+   BlasIndex lda=convert_index<BlasIndex>(lhsStride), ldc=convert_index<BlasIndex>(resStride), n=convert_index<BlasIndex>(size), k=convert_index<BlasIndex>(depth); \
+   char uplo=((IsLower) ? 'L' : 'U'), trans=((AStorageOrder==RowMajor) ? 'C':'N'); \
+   RTYPE alpha_, beta_; \
+   const EIGTYPE* a_ptr; \
+\
+   alpha_ = alpha.real(); \
+   beta_ = 1.0; \
+/* Copy with conjugation in some cases*/ \
+   MatrixType a; \
+   if (conjA) { \
+     Map<const MatrixType, 0, OuterStride<> > mapA(lhs,n,k,OuterStride<>(lhsStride)); \
+     a = mapA.conjugate(); \
+     lda = a.outerStride(); \
+     a_ptr = a.data(); \
+   } else a_ptr=lhs; \
+   BLASFUNC(&uplo, &trans, &n, &k, &alpha_, (BLASTYPE*)a_ptr, &lda, &beta_, (BLASTYPE*)res, &ldc); \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_RANKUPDATE_R(double, double, dsyrk)
+EIGEN_BLAS_RANKUPDATE_R(float,  float,  ssyrk)
+#else
+EIGEN_BLAS_RANKUPDATE_R(double, double, dsyrk_)
+EIGEN_BLAS_RANKUPDATE_R(float,  float,  ssyrk_)
+#endif
+
+// TODO hanlde complex cases
+// EIGEN_BLAS_RANKUPDATE_C(dcomplex, double, double, zherk_)
+// EIGEN_BLAS_RANKUPDATE_C(scomplex, float,  float, cherk_)
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
new file mode 100644
index 00000000..71abf401
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
@@ -0,0 +1,124 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   General matrix-matrix product functionality based on ?GEMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements general matrix-matrix multiplication using BLAS
+* gemm function via partial specialization of
+* general_matrix_matrix_product::run(..) method for float, double,
+* std::complex<float> and std::complex<double> types
+**********************************************************************/
+
+// gemm specialization
+
+#define GEMM_SPECIALIZATION(EIGTYPE, EIGPREFIX, BLASTYPE, BLASFUNC) \
+template< \
+  typename Index, \
+  int LhsStorageOrder, bool ConjugateLhs, \
+  int RhsStorageOrder, bool ConjugateRhs> \
+struct general_matrix_matrix_product<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,RhsStorageOrder,ConjugateRhs,ColMajor,1> \
+{ \
+typedef gebp_traits<EIGTYPE,EIGTYPE> Traits; \
+\
+static void run(Index rows, Index cols, Index depth, \
+  const EIGTYPE* _lhs, Index lhsStride, \
+  const EIGTYPE* _rhs, Index rhsStride, \
+  EIGTYPE* res, Index resIncr, Index resStride, \
+  EIGTYPE alpha, \
+  level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/, \
+  GemmParallelInfo<Index>* /*info = 0*/) \
+{ \
+  using std::conj; \
+\
+  EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+  eigen_assert(resIncr == 1); \
+  char transa, transb; \
+  BlasIndex m, n, k, lda, ldb, ldc; \
+  const EIGTYPE *a, *b; \
+  EIGTYPE beta(1); \
+  MatrixX##EIGPREFIX a_tmp, b_tmp; \
+\
+/* Set transpose options */ \
+  transa = (LhsStorageOrder==RowMajor) ? ((ConjugateLhs) ? 'C' : 'T') : 'N'; \
+  transb = (RhsStorageOrder==RowMajor) ? ((ConjugateRhs) ? 'C' : 'T') : 'N'; \
+\
+/* Set m, n, k */ \
+  m = convert_index<BlasIndex>(rows);  \
+  n = convert_index<BlasIndex>(cols);  \
+  k = convert_index<BlasIndex>(depth); \
+\
+/* Set lda, ldb, ldc */ \
+  lda = convert_index<BlasIndex>(lhsStride); \
+  ldb = convert_index<BlasIndex>(rhsStride); \
+  ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+  if ((LhsStorageOrder==ColMajor) && (ConjugateLhs)) { \
+    Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,m,k,OuterStride<>(lhsStride)); \
+    a_tmp = lhs.conjugate(); \
+    a = a_tmp.data(); \
+    lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+  } else a = _lhs; \
+\
+  if ((RhsStorageOrder==ColMajor) && (ConjugateRhs)) { \
+    Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,k,n,OuterStride<>(rhsStride)); \
+    b_tmp = rhs.conjugate(); \
+    b = b_tmp.data(); \
+    ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+  } else b = _rhs; \
+\
+  BLASFUNC(&transa, &transb, &m, &n, &k, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+}};
+
+#ifdef EIGEN_USE_MKL
+GEMM_SPECIALIZATION(double,   d,  double, dgemm)
+GEMM_SPECIALIZATION(float,    f,  float,  sgemm)
+GEMM_SPECIALIZATION(dcomplex, cd, MKL_Complex16, zgemm)
+GEMM_SPECIALIZATION(scomplex, cf, MKL_Complex8,  cgemm)
+#else
+GEMM_SPECIALIZATION(double,   d,  double, dgemm_)
+GEMM_SPECIALIZATION(float,    f,  float,  sgemm_)
+GEMM_SPECIALIZATION(dcomplex, cd, double, zgemm_)
+GEMM_SPECIALIZATION(scomplex, cf, float,  cgemm_)
+#endif
+
+} // end namespase internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixVector.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixVector.h
new file mode 100644
index 00000000..dfb6aebc
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixVector.h
@@ -0,0 +1,518 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_MATRIX_VECTOR_H
+#define EIGEN_GENERAL_MATRIX_VECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+enum GEMVPacketSizeType {
+  GEMVPacketFull = 0,
+  GEMVPacketHalf,
+  GEMVPacketQuarter
+};
+
+template <int N, typename T1, typename T2, typename T3>
+struct gemv_packet_cond { typedef T3 type; };
+
+template <typename T1, typename T2, typename T3>
+struct gemv_packet_cond<GEMVPacketFull, T1, T2, T3> { typedef T1 type; };
+
+template <typename T1, typename T2, typename T3>
+struct gemv_packet_cond<GEMVPacketHalf, T1, T2, T3> { typedef T2 type; };
+
+template<typename LhsScalar, typename RhsScalar, int _PacketSize=GEMVPacketFull>
+class gemv_traits
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+#define PACKET_DECL_COND_PREFIX(prefix, name, packet_size)                        \
+  typedef typename gemv_packet_cond<packet_size,                                  \
+                                    typename packet_traits<name ## Scalar>::type, \
+                                    typename packet_traits<name ## Scalar>::half, \
+                                    typename unpacket_traits<typename packet_traits<name ## Scalar>::half>::half>::type \
+  prefix ## name ## Packet
+
+  PACKET_DECL_COND_PREFIX(_, Lhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Rhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Res, _PacketSize);
+#undef PACKET_DECL_COND_PREFIX
+
+public:
+  enum {
+        Vectorizable = unpacket_traits<_LhsPacket>::vectorizable &&
+        unpacket_traits<_RhsPacket>::vectorizable &&
+        int(unpacket_traits<_LhsPacket>::size)==int(unpacket_traits<_RhsPacket>::size),
+        LhsPacketSize = Vectorizable ? unpacket_traits<_LhsPacket>::size : 1,
+        RhsPacketSize = Vectorizable ? unpacket_traits<_RhsPacket>::size : 1,
+        ResPacketSize = Vectorizable ? unpacket_traits<_ResPacket>::size : 1
+  };
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+};
+
+
+/* Optimized col-major matrix * vector product:
+ * This algorithm processes the matrix per vertical panels,
+ * which are then processed horizontaly per chunck of 8*PacketSize x 1 vertical segments.
+ *
+ * Mixing type logic: C += alpha * A * B
+ *  |  A  |  B  |alpha| comments
+ *  |real |cplx |cplx | no vectorization
+ *  |real |cplx |real | alpha is converted to a cplx when calling the run function, no vectorization
+ *  |cplx |real |cplx | invalid, the caller has to do tmp: = A * B; C += alpha*tmp
+ *  |cplx |real |real | optimal case, vectorization possible via real-cplx mul
+ *
+ * The same reasoning apply for the transposed case.
+ */
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>
+{
+  typedef gemv_traits<LhsScalar,RhsScalar> Traits;
+  typedef gemv_traits<LhsScalar,RhsScalar,GEMVPacketHalf> HalfTraits;
+  typedef gemv_traits<LhsScalar,RhsScalar,GEMVPacketQuarter> QuarterTraits;
+
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  typedef typename Traits::LhsPacket LhsPacket;
+  typedef typename Traits::RhsPacket RhsPacket;
+  typedef typename Traits::ResPacket ResPacket;
+
+  typedef typename HalfTraits::LhsPacket LhsPacketHalf;
+  typedef typename HalfTraits::RhsPacket RhsPacketHalf;
+  typedef typename HalfTraits::ResPacket ResPacketHalf;
+
+  typedef typename QuarterTraits::LhsPacket LhsPacketQuarter;
+  typedef typename QuarterTraits::RhsPacket RhsPacketQuarter;
+  typedef typename QuarterTraits::ResPacket ResPacketQuarter;
+
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run(
+  Index rows, Index cols,
+  const LhsMapper& lhs,
+  const RhsMapper& rhs,
+        ResScalar* res, Index resIncr,
+  RhsScalar alpha);
+};
+
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>::run(
+  Index rows, Index cols,
+  const LhsMapper& alhs,
+  const RhsMapper& rhs,
+        ResScalar* res, Index resIncr,
+  RhsScalar alpha)
+{
+  EIGEN_UNUSED_VARIABLE(resIncr);
+  eigen_internal_assert(resIncr==1);
+
+  // The following copy tells the compiler that lhs's attributes are not modified outside this function
+  // This helps GCC to generate propoer code.
+  LhsMapper lhs(alhs);
+
+  conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
+  conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj;
+  conj_helper<LhsPacketHalf,RhsPacketHalf,ConjugateLhs,ConjugateRhs> pcj_half;
+  conj_helper<LhsPacketQuarter,RhsPacketQuarter,ConjugateLhs,ConjugateRhs> pcj_quarter;
+
+  const Index lhsStride = lhs.stride();
+  // TODO: for padded aligned inputs, we could enable aligned reads
+  enum { LhsAlignment = Unaligned,
+         ResPacketSize = Traits::ResPacketSize,
+         ResPacketSizeHalf = HalfTraits::ResPacketSize,
+         ResPacketSizeQuarter = QuarterTraits::ResPacketSize,
+         LhsPacketSize = Traits::LhsPacketSize,
+         HasHalf = (int)ResPacketSizeHalf < (int)ResPacketSize,
+         HasQuarter = (int)ResPacketSizeQuarter < (int)ResPacketSizeHalf
+  };
+
+  const Index n8 = rows-8*ResPacketSize+1;
+  const Index n4 = rows-4*ResPacketSize+1;
+  const Index n3 = rows-3*ResPacketSize+1;
+  const Index n2 = rows-2*ResPacketSize+1;
+  const Index n1 = rows-1*ResPacketSize+1;
+  const Index n_half = rows-1*ResPacketSizeHalf+1;
+  const Index n_quarter = rows-1*ResPacketSizeQuarter+1;
+
+  // TODO: improve the following heuristic:
+  const Index block_cols = cols<128 ? cols : (lhsStride*sizeof(LhsScalar)<32000?16:4);
+  ResPacket palpha = pset1<ResPacket>(alpha);
+  ResPacketHalf palpha_half = pset1<ResPacketHalf>(alpha);
+  ResPacketQuarter palpha_quarter = pset1<ResPacketQuarter>(alpha);
+
+  for(Index j2=0; j2<cols; j2+=block_cols)
+  {
+    Index jend = numext::mini(j2+block_cols,cols);
+    Index i=0;
+    for(; i<n8; i+=ResPacketSize*8)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0)),
+                c2 = pset1<ResPacket>(ResScalar(0)),
+                c3 = pset1<ResPacket>(ResScalar(0)),
+                c4 = pset1<ResPacket>(ResScalar(0)),
+                c5 = pset1<ResPacket>(ResScalar(0)),
+                c6 = pset1<ResPacket>(ResScalar(0)),
+                c7 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+        c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*2,j),b0,c2);
+        c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*3,j),b0,c3);
+        c4 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*4,j),b0,c4);
+        c5 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*5,j),b0,c5);
+        c6 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*6,j),b0,c6);
+        c7 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*7,j),b0,c7);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      pstoreu(res+i+ResPacketSize*2, pmadd(c2,palpha,ploadu<ResPacket>(res+i+ResPacketSize*2)));
+      pstoreu(res+i+ResPacketSize*3, pmadd(c3,palpha,ploadu<ResPacket>(res+i+ResPacketSize*3)));
+      pstoreu(res+i+ResPacketSize*4, pmadd(c4,palpha,ploadu<ResPacket>(res+i+ResPacketSize*4)));
+      pstoreu(res+i+ResPacketSize*5, pmadd(c5,palpha,ploadu<ResPacket>(res+i+ResPacketSize*5)));
+      pstoreu(res+i+ResPacketSize*6, pmadd(c6,palpha,ploadu<ResPacket>(res+i+ResPacketSize*6)));
+      pstoreu(res+i+ResPacketSize*7, pmadd(c7,palpha,ploadu<ResPacket>(res+i+ResPacketSize*7)));
+    }
+    if(i<n4)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0)),
+                c2 = pset1<ResPacket>(ResScalar(0)),
+                c3 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+        c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*2,j),b0,c2);
+        c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*3,j),b0,c3);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      pstoreu(res+i+ResPacketSize*2, pmadd(c2,palpha,ploadu<ResPacket>(res+i+ResPacketSize*2)));
+      pstoreu(res+i+ResPacketSize*3, pmadd(c3,palpha,ploadu<ResPacket>(res+i+ResPacketSize*3)));
+
+      i+=ResPacketSize*4;
+    }
+    if(i<n3)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0)),
+                c2 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+        c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*2,j),b0,c2);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      pstoreu(res+i+ResPacketSize*2, pmadd(c2,palpha,ploadu<ResPacket>(res+i+ResPacketSize*2)));
+
+      i+=ResPacketSize*3;
+    }
+    if(i<n2)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      i+=ResPacketSize*2;
+    }
+    if(i<n1)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0));
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      i+=ResPacketSize;
+    }
+    if(HasHalf && i<n_half)
+    {
+      ResPacketHalf c0 = pset1<ResPacketHalf>(ResScalar(0));
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacketHalf b0 = pset1<RhsPacketHalf>(rhs(j,0));
+        c0 = pcj_half.pmadd(lhs.template load<LhsPacketHalf,LhsAlignment>(i+0,j),b0,c0);
+      }
+      pstoreu(res+i+ResPacketSizeHalf*0, pmadd(c0,palpha_half,ploadu<ResPacketHalf>(res+i+ResPacketSizeHalf*0)));
+      i+=ResPacketSizeHalf;
+    }
+    if(HasQuarter && i<n_quarter)
+    {
+      ResPacketQuarter c0 = pset1<ResPacketQuarter>(ResScalar(0));
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacketQuarter b0 = pset1<RhsPacketQuarter>(rhs(j,0));
+        c0 = pcj_quarter.pmadd(lhs.template load<LhsPacketQuarter,LhsAlignment>(i+0,j),b0,c0);
+      }
+      pstoreu(res+i+ResPacketSizeQuarter*0, pmadd(c0,palpha_quarter,ploadu<ResPacketQuarter>(res+i+ResPacketSizeQuarter*0)));
+      i+=ResPacketSizeQuarter;
+    }
+    for(;i<rows;++i)
+    {
+      ResScalar c0(0);
+      for(Index j=j2; j<jend; j+=1)
+        c0 += cj.pmul(lhs(i,j), rhs(j,0));
+      res[i] += alpha*c0;
+    }
+  }
+}
+
+/* Optimized row-major matrix * vector product:
+ * This algorithm processes 4 rows at once that allows to both reduce
+ * the number of load/stores of the result by a factor 4 and to reduce
+ * the instruction dependency. Moreover, we know that all bands have the
+ * same alignment pattern.
+ *
+ * Mixing type logic:
+ *  - alpha is always a complex (or converted to a complex)
+ *  - no vectorization
+ */
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>
+{
+  typedef gemv_traits<LhsScalar,RhsScalar> Traits;
+  typedef gemv_traits<LhsScalar,RhsScalar,GEMVPacketHalf> HalfTraits;
+  typedef gemv_traits<LhsScalar,RhsScalar,GEMVPacketQuarter> QuarterTraits;
+
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  typedef typename Traits::LhsPacket LhsPacket;
+  typedef typename Traits::RhsPacket RhsPacket;
+  typedef typename Traits::ResPacket ResPacket;
+
+  typedef typename HalfTraits::LhsPacket LhsPacketHalf;
+  typedef typename HalfTraits::RhsPacket RhsPacketHalf;
+  typedef typename HalfTraits::ResPacket ResPacketHalf;
+
+  typedef typename QuarterTraits::LhsPacket LhsPacketQuarter;
+  typedef typename QuarterTraits::RhsPacket RhsPacketQuarter;
+  typedef typename QuarterTraits::ResPacket ResPacketQuarter;
+
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run(
+  Index rows, Index cols,
+  const LhsMapper& lhs,
+  const RhsMapper& rhs,
+        ResScalar* res, Index resIncr,
+  ResScalar alpha);
+};
+
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>::run(
+  Index rows, Index cols,
+  const LhsMapper& alhs,
+  const RhsMapper& rhs,
+  ResScalar* res, Index resIncr,
+  ResScalar alpha)
+{
+  // The following copy tells the compiler that lhs's attributes are not modified outside this function
+  // This helps GCC to generate propoer code.
+  LhsMapper lhs(alhs);
+
+  eigen_internal_assert(rhs.stride()==1);
+  conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
+  conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj;
+  conj_helper<LhsPacketHalf,RhsPacketHalf,ConjugateLhs,ConjugateRhs> pcj_half;
+  conj_helper<LhsPacketQuarter,RhsPacketQuarter,ConjugateLhs,ConjugateRhs> pcj_quarter;
+
+  // TODO: fine tune the following heuristic. The rationale is that if the matrix is very large,
+  //       processing 8 rows at once might be counter productive wrt cache.
+  const Index n8 = lhs.stride()*sizeof(LhsScalar)>32000 ? 0 : rows-7;
+  const Index n4 = rows-3;
+  const Index n2 = rows-1;
+
+  // TODO: for padded aligned inputs, we could enable aligned reads
+  enum { LhsAlignment = Unaligned,
+         ResPacketSize = Traits::ResPacketSize,
+         ResPacketSizeHalf = HalfTraits::ResPacketSize,
+         ResPacketSizeQuarter = QuarterTraits::ResPacketSize,
+         LhsPacketSize = Traits::LhsPacketSize,
+         LhsPacketSizeHalf = HalfTraits::LhsPacketSize,
+         LhsPacketSizeQuarter = QuarterTraits::LhsPacketSize,
+         HasHalf = (int)ResPacketSizeHalf < (int)ResPacketSize,
+         HasQuarter = (int)ResPacketSizeQuarter < (int)ResPacketSizeHalf
+  };
+
+  Index i=0;
+  for(; i<n8; i+=8)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+              c1 = pset1<ResPacket>(ResScalar(0)),
+              c2 = pset1<ResPacket>(ResScalar(0)),
+              c3 = pset1<ResPacket>(ResScalar(0)),
+              c4 = pset1<ResPacket>(ResScalar(0)),
+              c5 = pset1<ResPacket>(ResScalar(0)),
+              c6 = pset1<ResPacket>(ResScalar(0)),
+              c7 = pset1<ResPacket>(ResScalar(0));
+
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j,0);
+
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+1,j),b0,c1);
+      c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+2,j),b0,c2);
+      c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+3,j),b0,c3);
+      c4 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+4,j),b0,c4);
+      c5 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+5,j),b0,c5);
+      c6 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+6,j),b0,c6);
+      c7 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+7,j),b0,c7);
+    }
+    ResScalar cc0 = predux(c0);
+    ResScalar cc1 = predux(c1);
+    ResScalar cc2 = predux(c2);
+    ResScalar cc3 = predux(c3);
+    ResScalar cc4 = predux(c4);
+    ResScalar cc5 = predux(c5);
+    ResScalar cc6 = predux(c6);
+    ResScalar cc7 = predux(c7);
+    for(; j<cols; ++j)
+    {
+      RhsScalar b0 = rhs(j,0);
+
+      cc0 += cj.pmul(lhs(i+0,j), b0);
+      cc1 += cj.pmul(lhs(i+1,j), b0);
+      cc2 += cj.pmul(lhs(i+2,j), b0);
+      cc3 += cj.pmul(lhs(i+3,j), b0);
+      cc4 += cj.pmul(lhs(i+4,j), b0);
+      cc5 += cj.pmul(lhs(i+5,j), b0);
+      cc6 += cj.pmul(lhs(i+6,j), b0);
+      cc7 += cj.pmul(lhs(i+7,j), b0);
+    }
+    res[(i+0)*resIncr] += alpha*cc0;
+    res[(i+1)*resIncr] += alpha*cc1;
+    res[(i+2)*resIncr] += alpha*cc2;
+    res[(i+3)*resIncr] += alpha*cc3;
+    res[(i+4)*resIncr] += alpha*cc4;
+    res[(i+5)*resIncr] += alpha*cc5;
+    res[(i+6)*resIncr] += alpha*cc6;
+    res[(i+7)*resIncr] += alpha*cc7;
+  }
+  for(; i<n4; i+=4)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+              c1 = pset1<ResPacket>(ResScalar(0)),
+              c2 = pset1<ResPacket>(ResScalar(0)),
+              c3 = pset1<ResPacket>(ResScalar(0));
+
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j,0);
+
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+1,j),b0,c1);
+      c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+2,j),b0,c2);
+      c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+3,j),b0,c3);
+    }
+    ResScalar cc0 = predux(c0);
+    ResScalar cc1 = predux(c1);
+    ResScalar cc2 = predux(c2);
+    ResScalar cc3 = predux(c3);
+    for(; j<cols; ++j)
+    {
+      RhsScalar b0 = rhs(j,0);
+
+      cc0 += cj.pmul(lhs(i+0,j), b0);
+      cc1 += cj.pmul(lhs(i+1,j), b0);
+      cc2 += cj.pmul(lhs(i+2,j), b0);
+      cc3 += cj.pmul(lhs(i+3,j), b0);
+    }
+    res[(i+0)*resIncr] += alpha*cc0;
+    res[(i+1)*resIncr] += alpha*cc1;
+    res[(i+2)*resIncr] += alpha*cc2;
+    res[(i+3)*resIncr] += alpha*cc3;
+  }
+  for(; i<n2; i+=2)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+              c1 = pset1<ResPacket>(ResScalar(0));
+
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j,0);
+
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+1,j),b0,c1);
+    }
+    ResScalar cc0 = predux(c0);
+    ResScalar cc1 = predux(c1);
+    for(; j<cols; ++j)
+    {
+      RhsScalar b0 = rhs(j,0);
+
+      cc0 += cj.pmul(lhs(i+0,j), b0);
+      cc1 += cj.pmul(lhs(i+1,j), b0);
+    }
+    res[(i+0)*resIncr] += alpha*cc0;
+    res[(i+1)*resIncr] += alpha*cc1;
+  }
+  for(; i<rows; ++i)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0));
+    ResPacketHalf c0_h = pset1<ResPacketHalf>(ResScalar(0));
+    ResPacketQuarter c0_q = pset1<ResPacketQuarter>(ResScalar(0));
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket,Unaligned>(j,0);
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i,j),b0,c0);
+    }
+    ResScalar cc0 = predux(c0);
+    if (HasHalf) {
+      for(; j+LhsPacketSizeHalf<=cols; j+=LhsPacketSizeHalf)
+        {
+          RhsPacketHalf b0 = rhs.template load<RhsPacketHalf,Unaligned>(j,0);
+          c0_h = pcj_half.pmadd(lhs.template load<LhsPacketHalf,LhsAlignment>(i,j),b0,c0_h);
+        }
+      cc0 += predux(c0_h);
+    }
+    if (HasQuarter) {
+      for(; j+LhsPacketSizeQuarter<=cols; j+=LhsPacketSizeQuarter)
+        {
+          RhsPacketQuarter b0 = rhs.template load<RhsPacketQuarter,Unaligned>(j,0);
+          c0_q = pcj_quarter.pmadd(lhs.template load<LhsPacketQuarter,LhsAlignment>(i,j),b0,c0_q);
+        }
+      cc0 += predux(c0_q);
+    }
+    for(; j<cols; ++j)
+    {
+      cc0 += cj.pmul(lhs(i,j), rhs(j,0));
+    }
+    res[i*resIncr] += alpha*cc0;
+  }
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_VECTOR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
new file mode 100644
index 00000000..6e36c2b3
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
@@ -0,0 +1,136 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   General matrix-vector product functionality based on ?GEMV.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
+#define EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements general matrix-vector multiplication using BLAS
+* gemv function via partial specialization of
+* general_matrix_vector_product::run(..) method for float, double,
+* std::complex<float> and std::complex<double> types
+**********************************************************************/
+
+// gemv specialization
+
+template<typename Index, typename LhsScalar, int StorageOrder, bool ConjugateLhs, typename RhsScalar, bool ConjugateRhs>
+struct general_matrix_vector_product_gemv;
+
+#define EIGEN_BLAS_GEMV_SPECIALIZE(Scalar) \
+template<typename Index, bool ConjugateLhs, bool ConjugateRhs> \
+struct general_matrix_vector_product<Index,Scalar,const_blas_data_mapper<Scalar,Index,ColMajor>,ColMajor,ConjugateLhs,Scalar,const_blas_data_mapper<Scalar,Index,RowMajor>,ConjugateRhs,Specialized> { \
+static void run( \
+  Index rows, Index cols, \
+  const const_blas_data_mapper<Scalar,Index,ColMajor> &lhs, \
+  const const_blas_data_mapper<Scalar,Index,RowMajor> &rhs, \
+  Scalar* res, Index resIncr, Scalar alpha) \
+{ \
+  if (ConjugateLhs) { \
+    general_matrix_vector_product<Index,Scalar,const_blas_data_mapper<Scalar,Index,ColMajor>,ColMajor,ConjugateLhs,Scalar,const_blas_data_mapper<Scalar,Index,RowMajor>,ConjugateRhs,BuiltIn>::run( \
+      rows, cols, lhs, rhs, res, resIncr, alpha); \
+  } else { \
+    general_matrix_vector_product_gemv<Index,Scalar,ColMajor,ConjugateLhs,Scalar,ConjugateRhs>::run( \
+      rows, cols, lhs.data(), lhs.stride(), rhs.data(), rhs.stride(), res, resIncr, alpha); \
+  } \
+} \
+}; \
+template<typename Index, bool ConjugateLhs, bool ConjugateRhs> \
+struct general_matrix_vector_product<Index,Scalar,const_blas_data_mapper<Scalar,Index,RowMajor>,RowMajor,ConjugateLhs,Scalar,const_blas_data_mapper<Scalar,Index,ColMajor>,ConjugateRhs,Specialized> { \
+static void run( \
+  Index rows, Index cols, \
+  const const_blas_data_mapper<Scalar,Index,RowMajor> &lhs, \
+  const const_blas_data_mapper<Scalar,Index,ColMajor> &rhs, \
+  Scalar* res, Index resIncr, Scalar alpha) \
+{ \
+    general_matrix_vector_product_gemv<Index,Scalar,RowMajor,ConjugateLhs,Scalar,ConjugateRhs>::run( \
+      rows, cols, lhs.data(), lhs.stride(), rhs.data(), rhs.stride(), res, resIncr, alpha); \
+} \
+}; \
+
+EIGEN_BLAS_GEMV_SPECIALIZE(double)
+EIGEN_BLAS_GEMV_SPECIALIZE(float)
+EIGEN_BLAS_GEMV_SPECIALIZE(dcomplex)
+EIGEN_BLAS_GEMV_SPECIALIZE(scomplex)
+
+#define EIGEN_BLAS_GEMV_SPECIALIZATION(EIGTYPE,BLASTYPE,BLASFUNC) \
+template<typename Index, int LhsStorageOrder, bool ConjugateLhs, bool ConjugateRhs> \
+struct general_matrix_vector_product_gemv<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,ConjugateRhs> \
+{ \
+typedef Matrix<EIGTYPE,Dynamic,1,ColMajor> GEMVVector;\
+\
+static void run( \
+  Index rows, Index cols, \
+  const EIGTYPE* lhs, Index lhsStride, \
+  const EIGTYPE* rhs, Index rhsIncr, \
+  EIGTYPE* res, Index resIncr, EIGTYPE alpha) \
+{ \
+  BlasIndex m=convert_index<BlasIndex>(rows), n=convert_index<BlasIndex>(cols), \
+            lda=convert_index<BlasIndex>(lhsStride), incx=convert_index<BlasIndex>(rhsIncr), incy=convert_index<BlasIndex>(resIncr); \
+  const EIGTYPE beta(1); \
+  const EIGTYPE *x_ptr; \
+  char trans=(LhsStorageOrder==ColMajor) ? 'N' : (ConjugateLhs) ? 'C' : 'T'; \
+  if (LhsStorageOrder==RowMajor) { \
+    m = convert_index<BlasIndex>(cols); \
+    n = convert_index<BlasIndex>(rows); \
+  }\
+  GEMVVector x_tmp; \
+  if (ConjugateRhs) { \
+    Map<const GEMVVector, 0, InnerStride<> > map_x(rhs,cols,1,InnerStride<>(incx)); \
+    x_tmp=map_x.conjugate(); \
+    x_ptr=x_tmp.data(); \
+    incx=1; \
+  } else x_ptr=rhs; \
+  BLASFUNC(&trans, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)lhs, &lda, (const BLASTYPE*)x_ptr, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &incy); \
+}\
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_GEMV_SPECIALIZATION(double,   double, dgemv)
+EIGEN_BLAS_GEMV_SPECIALIZATION(float,    float,  sgemv)
+EIGEN_BLAS_GEMV_SPECIALIZATION(dcomplex, MKL_Complex16, zgemv)
+EIGEN_BLAS_GEMV_SPECIALIZATION(scomplex, MKL_Complex8 , cgemv)
+#else
+EIGEN_BLAS_GEMV_SPECIALIZATION(double,   double, dgemv_)
+EIGEN_BLAS_GEMV_SPECIALIZATION(float,    float,  sgemv_)
+EIGEN_BLAS_GEMV_SPECIALIZATION(dcomplex, double, zgemv_)
+EIGEN_BLAS_GEMV_SPECIALIZATION(scomplex, float,  cgemv_)
+#endif
+
+} // end namespase internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/Parallelizer.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/Parallelizer.h
new file mode 100644
index 00000000..8f91879e
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/Parallelizer.h
@@ -0,0 +1,180 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARALLELIZER_H
+#define EIGEN_PARALLELIZER_H
+
+#if EIGEN_HAS_CXX11_ATOMIC
+#include <atomic>
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal */
+inline void manage_multi_threading(Action action, int* v)
+{
+  static int m_maxThreads = -1;
+  EIGEN_UNUSED_VARIABLE(m_maxThreads)
+
+  if(action==SetAction)
+  {
+    eigen_internal_assert(v!=0);
+    m_maxThreads = *v;
+  }
+  else if(action==GetAction)
+  {
+    eigen_internal_assert(v!=0);
+    #ifdef EIGEN_HAS_OPENMP
+    if(m_maxThreads>0)
+      *v = m_maxThreads;
+    else
+      *v = omp_get_max_threads();
+    #else
+    *v = 1;
+    #endif
+  }
+  else
+  {
+    eigen_internal_assert(false);
+  }
+}
+
+}
+
+/** Must be call first when calling Eigen from multiple threads */
+inline void initParallel()
+{
+  int nbt;
+  internal::manage_multi_threading(GetAction, &nbt);
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+}
+
+/** \returns the max number of threads reserved for Eigen
+  * \sa setNbThreads */
+inline int nbThreads()
+{
+  int ret;
+  internal::manage_multi_threading(GetAction, &ret);
+  return ret;
+}
+
+/** Sets the max number of threads reserved for Eigen
+  * \sa nbThreads */
+inline void setNbThreads(int v)
+{
+  internal::manage_multi_threading(SetAction, &v);
+}
+
+namespace internal {
+
+template<typename Index> struct GemmParallelInfo
+{
+  GemmParallelInfo() : sync(-1), users(0), lhs_start(0), lhs_length(0) {}
+
+  // volatile is not enough on all architectures (see bug 1572)
+  // to guarantee that when thread A says to thread B that it is
+  // done with packing a block, then all writes have been really
+  // carried out... C++11 memory model+atomic guarantees this.
+#if EIGEN_HAS_CXX11_ATOMIC
+  std::atomic<Index> sync;
+  std::atomic<int> users;
+#else
+  Index volatile sync;
+  int volatile users;
+#endif
+
+  Index lhs_start;
+  Index lhs_length;
+};
+
+template<bool Condition, typename Functor, typename Index>
+void parallelize_gemm(const Functor& func, Index rows, Index cols, Index depth, bool transpose)
+{
+  // TODO when EIGEN_USE_BLAS is defined,
+  // we should still enable OMP for other scalar types
+  // Without C++11, we have to disable GEMM's parallelization on
+  // non x86 architectures because there volatile is not enough for our purpose.
+  // See bug 1572.
+#if (! defined(EIGEN_HAS_OPENMP)) || defined(EIGEN_USE_BLAS) || ((!EIGEN_HAS_CXX11_ATOMIC) && !(EIGEN_ARCH_i386_OR_x86_64))
+  // FIXME the transpose variable is only needed to properly split
+  // the matrix product when multithreading is enabled. This is a temporary
+  // fix to support row-major destination matrices. This whole
+  // parallelizer mechanism has to be redesigned anyway.
+  EIGEN_UNUSED_VARIABLE(depth);
+  EIGEN_UNUSED_VARIABLE(transpose);
+  func(0,rows, 0,cols);
+#else
+
+  // Dynamically check whether we should enable or disable OpenMP.
+  // The conditions are:
+  // - the max number of threads we can create is greater than 1
+  // - we are not already in a parallel code
+  // - the sizes are large enough
+
+  // compute the maximal number of threads from the size of the product:
+  // This first heuristic takes into account that the product kernel is fully optimized when working with nr columns at once.
+  Index size = transpose ? rows : cols;
+  Index pb_max_threads = std::max<Index>(1,size / Functor::Traits::nr);
+
+  // compute the maximal number of threads from the total amount of work:
+  double work = static_cast<double>(rows) * static_cast<double>(cols) *
+      static_cast<double>(depth);
+  double kMinTaskSize = 50000;  // FIXME improve this heuristic.
+  pb_max_threads = std::max<Index>(1, std::min<Index>(pb_max_threads, static_cast<Index>( work / kMinTaskSize ) ));
+
+  // compute the number of threads we are going to use
+  Index threads = std::min<Index>(nbThreads(), pb_max_threads);
+
+  // if multi-threading is explicitly disabled, not useful, or if we already are in a parallel session,
+  // then abort multi-threading
+  // FIXME omp_get_num_threads()>1 only works for openmp, what if the user does not use openmp?
+  if((!Condition) || (threads==1) || (omp_get_num_threads()>1))
+    return func(0,rows, 0,cols);
+
+  Eigen::initParallel();
+  func.initParallelSession(threads);
+
+  if(transpose)
+    std::swap(rows,cols);
+
+  ei_declare_aligned_stack_constructed_variable(GemmParallelInfo<Index>,info,threads,0);
+
+  #pragma omp parallel num_threads(threads)
+  {
+    Index i = omp_get_thread_num();
+    // Note that the actual number of threads might be lower than the number of request ones.
+    Index actual_threads = omp_get_num_threads();
+
+    Index blockCols = (cols / actual_threads) & ~Index(0x3);
+    Index blockRows = (rows / actual_threads);
+    blockRows = (blockRows/Functor::Traits::mr)*Functor::Traits::mr;
+
+    Index r0 = i*blockRows;
+    Index actualBlockRows = (i+1==actual_threads) ? rows-r0 : blockRows;
+
+    Index c0 = i*blockCols;
+    Index actualBlockCols = (i+1==actual_threads) ? cols-c0 : blockCols;
+
+    info[i].lhs_start = r0;
+    info[i].lhs_length = actualBlockRows;
+
+    if(transpose) func(c0, actualBlockCols, 0, rows, info);
+    else          func(0, rows, c0, actualBlockCols, info);
+  }
+#endif
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARALLELIZER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
new file mode 100644
index 00000000..33ecf10f
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
@@ -0,0 +1,544 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_MATRIX_H
+#define EIGEN_SELFADJOINT_MATRIX_MATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// pack a selfadjoint block diagonal for use with the gebp_kernel
+template<typename Scalar, typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs
+{
+  template<int BlockRows> inline
+  void pack(Scalar* blockA, const const_blas_data_mapper<Scalar,Index,StorageOrder>& lhs, Index cols, Index i, Index& count)
+  {
+    // normal copy
+    for(Index k=0; k<i; k++)
+      for(Index w=0; w<BlockRows; w++)
+        blockA[count++] = lhs(i+w,k);           // normal
+    // symmetric copy
+    Index h = 0;
+    for(Index k=i; k<i+BlockRows; k++)
+    {
+      for(Index w=0; w<h; w++)
+        blockA[count++] = numext::conj(lhs(k, i+w)); // transposed
+
+      blockA[count++] = numext::real(lhs(k,k));   // real (diagonal)
+
+      for(Index w=h+1; w<BlockRows; w++)
+        blockA[count++] = lhs(i+w, k);          // normal
+      ++h;
+    }
+    // transposed copy
+    for(Index k=i+BlockRows; k<cols; k++)
+      for(Index w=0; w<BlockRows; w++)
+        blockA[count++] = numext::conj(lhs(k, i+w)); // transposed
+  }
+  void operator()(Scalar* blockA, const Scalar* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    typedef typename unpacket_traits<typename packet_traits<Scalar>::type>::half HalfPacket;
+    typedef typename unpacket_traits<typename unpacket_traits<typename packet_traits<Scalar>::type>::half>::half QuarterPacket;
+    enum { PacketSize = packet_traits<Scalar>::size,
+           HalfPacketSize = unpacket_traits<HalfPacket>::size,
+           QuarterPacketSize = unpacket_traits<QuarterPacket>::size,
+           HasHalf = (int)HalfPacketSize < (int)PacketSize,
+           HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize};
+
+    const_blas_data_mapper<Scalar,Index,StorageOrder> lhs(_lhs,lhsStride);
+    Index count = 0;
+    //Index peeled_mc3 = (rows/Pack1)*Pack1;
+    
+    const Index peeled_mc3 = Pack1>=3*PacketSize ? (rows/(3*PacketSize))*(3*PacketSize) : 0;
+    const Index peeled_mc2 = Pack1>=2*PacketSize ? peeled_mc3+((rows-peeled_mc3)/(2*PacketSize))*(2*PacketSize) : 0;
+    const Index peeled_mc1 = Pack1>=1*PacketSize ? peeled_mc2+((rows-peeled_mc2)/(1*PacketSize))*(1*PacketSize) : 0;
+    const Index peeled_mc_half = Pack1>=HalfPacketSize ? peeled_mc1+((rows-peeled_mc1)/(HalfPacketSize))*(HalfPacketSize) : 0;
+    const Index peeled_mc_quarter = Pack1>=QuarterPacketSize ? peeled_mc_half+((rows-peeled_mc_half)/(QuarterPacketSize))*(QuarterPacketSize) : 0;
+    
+    if(Pack1>=3*PacketSize)
+      for(Index i=0; i<peeled_mc3; i+=3*PacketSize)
+        pack<3*PacketSize>(blockA, lhs, cols, i, count);
+    
+    if(Pack1>=2*PacketSize)
+      for(Index i=peeled_mc3; i<peeled_mc2; i+=2*PacketSize)
+        pack<2*PacketSize>(blockA, lhs, cols, i, count);
+    
+    if(Pack1>=1*PacketSize)
+      for(Index i=peeled_mc2; i<peeled_mc1; i+=1*PacketSize)
+        pack<1*PacketSize>(blockA, lhs, cols, i, count);
+
+    if(HasHalf && Pack1>=HalfPacketSize)
+      for(Index i=peeled_mc1; i<peeled_mc_half; i+=HalfPacketSize)
+        pack<HalfPacketSize>(blockA, lhs, cols, i, count);
+
+    if(HasQuarter && Pack1>=QuarterPacketSize)
+      for(Index i=peeled_mc_half; i<peeled_mc_quarter; i+=QuarterPacketSize)
+        pack<QuarterPacketSize>(blockA, lhs, cols, i, count);
+
+    // do the same with mr==1
+    for(Index i=peeled_mc_quarter; i<rows; i++)
+    {
+      for(Index k=0; k<i; k++)
+        blockA[count++] = lhs(i, k);                   // normal
+
+      blockA[count++] = numext::real(lhs(i, i));       // real (diagonal)
+
+      for(Index k=i+1; k<cols; k++)
+        blockA[count++] = numext::conj(lhs(k, i));     // transposed
+    }
+  }
+};
+
+template<typename Scalar, typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs
+{
+  enum { PacketSize = packet_traits<Scalar>::size };
+  void operator()(Scalar* blockB, const Scalar* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    Index end_k = k2 + rows;
+    Index count = 0;
+    const_blas_data_mapper<Scalar,Index,StorageOrder> rhs(_rhs,rhsStride);
+    Index packet_cols8 = nr>=8 ? (cols/8) * 8 : 0;
+    Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+
+    // first part: normal case
+    for(Index j2=0; j2<k2; j2+=nr)
+    {
+      for(Index k=k2; k<end_k; k++)
+      {
+        blockB[count+0] = rhs(k,j2+0);
+        blockB[count+1] = rhs(k,j2+1);
+        if (nr>=4)
+        {
+          blockB[count+2] = rhs(k,j2+2);
+          blockB[count+3] = rhs(k,j2+3);
+        }
+        if (nr>=8)
+        {
+          blockB[count+4] = rhs(k,j2+4);
+          blockB[count+5] = rhs(k,j2+5);
+          blockB[count+6] = rhs(k,j2+6);
+          blockB[count+7] = rhs(k,j2+7);
+        }
+        count += nr;
+      }
+    }
+
+    // second part: diagonal block
+    Index end8 = nr>=8 ? (std::min)(k2+rows,packet_cols8) : k2;
+    if(nr>=8)
+    {
+      for(Index j2=k2; j2<end8; j2+=8)
+      {
+        // again we can split vertically in three different parts (transpose, symmetric, normal)
+        // transpose
+        for(Index k=k2; k<j2; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          blockB[count+4] = numext::conj(rhs(j2+4,k));
+          blockB[count+5] = numext::conj(rhs(j2+5,k));
+          blockB[count+6] = numext::conj(rhs(j2+6,k));
+          blockB[count+7] = numext::conj(rhs(j2+7,k));
+          count += 8;
+        }
+        // symmetric
+        Index h = 0;
+        for(Index k=j2; k<j2+8; k++)
+        {
+          // normal
+          for (Index w=0 ; w<h; ++w)
+            blockB[count+w] = rhs(k,j2+w);
+
+          blockB[count+h] = numext::real(rhs(k,k));
+
+          // transpose
+          for (Index w=h+1 ; w<8; ++w)
+            blockB[count+w] = numext::conj(rhs(j2+w,k));
+          count += 8;
+          ++h;
+        }
+        // normal
+        for(Index k=j2+8; k<end_k; k++)
+        {
+          blockB[count+0] = rhs(k,j2+0);
+          blockB[count+1] = rhs(k,j2+1);
+          blockB[count+2] = rhs(k,j2+2);
+          blockB[count+3] = rhs(k,j2+3);
+          blockB[count+4] = rhs(k,j2+4);
+          blockB[count+5] = rhs(k,j2+5);
+          blockB[count+6] = rhs(k,j2+6);
+          blockB[count+7] = rhs(k,j2+7);
+          count += 8;
+        }
+      }
+    }
+    if(nr>=4)
+    {
+      for(Index j2=end8; j2<(std::min)(k2+rows,packet_cols4); j2+=4)
+      {
+        // again we can split vertically in three different parts (transpose, symmetric, normal)
+        // transpose
+        for(Index k=k2; k<j2; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          count += 4;
+        }
+        // symmetric
+        Index h = 0;
+        for(Index k=j2; k<j2+4; k++)
+        {
+          // normal
+          for (Index w=0 ; w<h; ++w)
+            blockB[count+w] = rhs(k,j2+w);
+
+          blockB[count+h] = numext::real(rhs(k,k));
+
+          // transpose
+          for (Index w=h+1 ; w<4; ++w)
+            blockB[count+w] = numext::conj(rhs(j2+w,k));
+          count += 4;
+          ++h;
+        }
+        // normal
+        for(Index k=j2+4; k<end_k; k++)
+        {
+          blockB[count+0] = rhs(k,j2+0);
+          blockB[count+1] = rhs(k,j2+1);
+          blockB[count+2] = rhs(k,j2+2);
+          blockB[count+3] = rhs(k,j2+3);
+          count += 4;
+        }
+      }
+    }
+
+    // third part: transposed
+    if(nr>=8)
+    {
+      for(Index j2=k2+rows; j2<packet_cols8; j2+=8)
+      {
+        for(Index k=k2; k<end_k; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          blockB[count+4] = numext::conj(rhs(j2+4,k));
+          blockB[count+5] = numext::conj(rhs(j2+5,k));
+          blockB[count+6] = numext::conj(rhs(j2+6,k));
+          blockB[count+7] = numext::conj(rhs(j2+7,k));
+          count += 8;
+        }
+      }
+    }
+    if(nr>=4)
+    {
+      for(Index j2=(std::max)(packet_cols8,k2+rows); j2<packet_cols4; j2+=4)
+      {
+        for(Index k=k2; k<end_k; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          count += 4;
+        }
+      }
+    }
+
+    // copy the remaining columns one at a time (=> the same with nr==1)
+    for(Index j2=packet_cols4; j2<cols; ++j2)
+    {
+      // transpose
+      Index half = (std::min)(end_k,j2);
+      for(Index k=k2; k<half; k++)
+      {
+        blockB[count] = numext::conj(rhs(j2,k));
+        count += 1;
+      }
+
+      if(half==j2 && half<k2+rows)
+      {
+        blockB[count] = numext::real(rhs(j2,j2));
+        count += 1;
+      }
+      else
+        half--;
+
+      // normal
+      for(Index k=half+1; k<k2+rows; k++)
+      {
+        blockB[count] = rhs(k,j2);
+        count += 1;
+      }
+    }
+  }
+};
+
+/* Optimized selfadjoint matrix * matrix (_SYMM) product built on top of
+ * the general matrix matrix product.
+ */
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs,
+          int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs,
+          int ResStorageOrder, int ResInnerStride>
+struct product_selfadjoint_matrix;
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs,
+          int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs,
+          int ResInnerStride>
+struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,LhsSelfAdjoint,ConjugateLhs, RhsStorageOrder,RhsSelfAdjoint,ConjugateRhs,RowMajor,ResInnerStride>
+{
+
+  static EIGEN_STRONG_INLINE void run(
+    Index rows, Index cols,
+    const Scalar* lhs, Index lhsStride,
+    const Scalar* rhs, Index rhsStride,
+    Scalar* res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    product_selfadjoint_matrix<Scalar, Index,
+      EIGEN_LOGICAL_XOR(RhsSelfAdjoint,RhsStorageOrder==RowMajor) ? ColMajor : RowMajor,
+      RhsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(RhsSelfAdjoint,ConjugateRhs),
+      EIGEN_LOGICAL_XOR(LhsSelfAdjoint,LhsStorageOrder==RowMajor) ? ColMajor : RowMajor,
+      LhsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(LhsSelfAdjoint,ConjugateLhs),
+      ColMajor,ResInnerStride>
+      ::run(cols, rows,  rhs, rhsStride,  lhs, lhsStride,  res, resIncr, resStride,  alpha, blocking);
+  }
+};
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride>
+struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,true,ConjugateLhs, RhsStorageOrder,false,ConjugateRhs,ColMajor,ResInnerStride>
+{
+
+  static EIGEN_DONT_INLINE void run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride>
+EIGEN_DONT_INLINE void product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,true,ConjugateLhs, RhsStorageOrder,false,ConjugateRhs,ColMajor,ResInnerStride>::run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index size = rows;
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, (LhsStorageOrder == RowMajor) ? ColMajor : RowMajor> LhsTransposeMapper;
+    typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    LhsTransposeMapper lhs_transpose(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride, resIncr);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+    // kc must be smaller than mc
+    kc = (std::min)(kc,mc);
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    symm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder> pack_rhs;
+    gemm_pack_lhs<Scalar, Index, LhsTransposeMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder==RowMajor?ColMajor:RowMajor, true> pack_lhs_transposed;
+
+    for(Index k2=0; k2<size; k2+=kc)
+    {
+      const Index actual_kc = (std::min)(k2+kc,size)-k2;
+
+      // we have selected one row panel of rhs and one column panel of lhs
+      // pack rhs's panel into a sequential chunk of memory
+      // and expand each coeff to a constant packet for further reuse
+      pack_rhs(blockB, rhs.getSubMapper(k2,0), actual_kc, cols);
+
+      // the select lhs's panel has to be split in three different parts:
+      //  1 - the transposed panel above the diagonal block => transposed packed copy
+      //  2 - the diagonal block => special packed copy
+      //  3 - the panel below the diagonal block => generic packed copy
+      for(Index i2=0; i2<k2; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,k2)-i2;
+        // transposed packed copy
+        pack_lhs_transposed(blockA, lhs_transpose.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+      // the block diagonal
+      {
+        const Index actual_mc = (std::min)(k2+kc,size)-k2;
+        // symmetric packed copy
+        pack_lhs(blockA, &lhs(k2,k2), lhsStride, actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(k2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+
+      for(Index i2=k2+kc; i2<size; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,size)-i2;
+        gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder,false>()
+          (blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+    }
+  }
+
+// matrix * selfadjoint product
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride>
+struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,false,ConjugateLhs, RhsStorageOrder,true,ConjugateRhs,ColMajor,ResInnerStride>
+{
+
+  static EIGEN_DONT_INLINE void run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride>
+EIGEN_DONT_INLINE void product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,false,ConjugateLhs, RhsStorageOrder,true,ConjugateRhs,ColMajor,ResInnerStride>::run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index size = cols;
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    ResMapper res(_res,resStride, resIncr);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder> pack_lhs;
+    symm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs;
+
+    for(Index k2=0; k2<size; k2+=kc)
+    {
+      const Index actual_kc = (std::min)(k2+kc,size)-k2;
+
+      pack_rhs(blockB, _rhs, rhsStride, actual_kc, cols, k2);
+
+      // => GEPP
+      for(Index i2=0; i2<rows; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,rows)-i2;
+        pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+    }
+  }
+
+} // end namespace internal
+
+/***************************************************************************
+* Wrapper to product_selfadjoint_matrix
+***************************************************************************/
+
+namespace internal {
+  
+template<typename Lhs, int LhsMode, typename Rhs, int RhsMode>
+struct selfadjoint_product_impl<Lhs,LhsMode,false,Rhs,RhsMode,false>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  typedef internal::blas_traits<Lhs> LhsBlasTraits;
+  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+  typedef internal::blas_traits<Rhs> RhsBlasTraits;
+  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  
+  enum {
+    LhsIsUpper = (LhsMode&(Upper|Lower))==Upper,
+    LhsIsSelfAdjoint = (LhsMode&SelfAdjoint)==SelfAdjoint,
+    RhsIsUpper = (RhsMode&(Upper|Lower))==Upper,
+    RhsIsSelfAdjoint = (RhsMode&SelfAdjoint)==SelfAdjoint
+  };
+  
+  template<typename Dest>
+  static void run(Dest &dst, const Lhs &a_lhs, const Rhs &a_rhs, const Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==a_lhs.rows() && dst.cols()==a_rhs.cols());
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs)
+                               * RhsBlasTraits::extractScalarFactor(a_rhs);
+
+    typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
+              Lhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxColsAtCompileTime,1> BlockingType;
+
+    BlockingType blocking(lhs.rows(), rhs.cols(), lhs.cols(), 1, false);
+
+    internal::product_selfadjoint_matrix<Scalar, Index,
+      EIGEN_LOGICAL_XOR(LhsIsUpper,internal::traits<Lhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, LhsIsSelfAdjoint,
+      NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(LhsIsUpper,bool(LhsBlasTraits::NeedToConjugate)),
+      EIGEN_LOGICAL_XOR(RhsIsUpper,internal::traits<Rhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, RhsIsSelfAdjoint,
+      NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(RhsIsUpper,bool(RhsBlasTraits::NeedToConjugate)),
+      internal::traits<Dest>::Flags&RowMajorBit  ? RowMajor : ColMajor,
+      Dest::InnerStrideAtCompileTime>
+      ::run(
+        lhs.rows(), rhs.cols(),                 // sizes
+        &lhs.coeffRef(0,0), lhs.outerStride(),  // lhs info
+        &rhs.coeffRef(0,0), rhs.outerStride(),  // rhs info
+        &dst.coeffRef(0,0), dst.innerStride(), dst.outerStride(),  // result info
+        actualAlpha, blocking                   // alpha
+      );
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_MATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
new file mode 100644
index 00000000..61396dbd
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
@@ -0,0 +1,295 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Self adjoint matrix * matrix product functionality based on ?SYMM/?HEMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
+#define EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+/* Optimized selfadjoint matrix * matrix (?SYMM/?HEMM) product */
+
+#define EIGEN_BLAS_SYMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,true,ConjugateLhs,RhsStorageOrder,false,ConjugateRhs,ColMajor,1> \
+{\
+\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resIncr, Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+    eigen_assert(resIncr == 1); \
+    char side='L', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+\
+/* Set transpose options */ \
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows);  \
+    n = convert_index<BlasIndex>(cols);  \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(lhsStride); \
+    ldb = convert_index<BlasIndex>(rhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (LhsStorageOrder==RowMajor) uplo='U'; \
+    a = _lhs; \
+\
+    if (RhsStorageOrder==RowMajor) { \
+      Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,n,m,OuterStride<>(rhsStride)); \
+      b_tmp = rhs.adjoint(); \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } else b = _rhs; \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+\
+  } \
+};
+
+
+#define EIGEN_BLAS_HEMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,true,ConjugateLhs,RhsStorageOrder,false,ConjugateRhs,ColMajor,1> \
+{\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resIncr, Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+    eigen_assert(resIncr == 1); \
+    char side='L', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+    Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> a_tmp; \
+\
+/* Set transpose options */ \
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows); \
+    n = convert_index<BlasIndex>(cols); \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(lhsStride); \
+    ldb = convert_index<BlasIndex>(rhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (((LhsStorageOrder==ColMajor) && ConjugateLhs) || ((LhsStorageOrder==RowMajor) && (!ConjugateLhs))) { \
+      Map<const Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder>, 0, OuterStride<> > lhs(_lhs,m,m,OuterStride<>(lhsStride)); \
+      a_tmp = lhs.conjugate(); \
+      a = a_tmp.data(); \
+      lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+    } else a = _lhs; \
+    if (LhsStorageOrder==RowMajor) uplo='U'; \
+\
+    if (RhsStorageOrder==ColMajor && (!ConjugateRhs)) { \
+       b = _rhs; } \
+    else { \
+      if (RhsStorageOrder==ColMajor && ConjugateRhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,m,n,OuterStride<>(rhsStride)); \
+        b_tmp = rhs.conjugate(); \
+      } else \
+      if (ConjugateRhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,n,m,OuterStride<>(rhsStride)); \
+        b_tmp = rhs.adjoint(); \
+      } else { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,n,m,OuterStride<>(rhsStride)); \
+        b_tmp = rhs.transpose(); \
+      } \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+\
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_SYMM_L(double, double, d, dsymm)
+EIGEN_BLAS_SYMM_L(float, float, f, ssymm)
+EIGEN_BLAS_HEMM_L(dcomplex, MKL_Complex16, cd, zhemm)
+EIGEN_BLAS_HEMM_L(scomplex, MKL_Complex8, cf, chemm)
+#else
+EIGEN_BLAS_SYMM_L(double, double, d, dsymm_)
+EIGEN_BLAS_SYMM_L(float, float, f, ssymm_)
+EIGEN_BLAS_HEMM_L(dcomplex, double, cd, zhemm_)
+EIGEN_BLAS_HEMM_L(scomplex, float, cf, chemm_)
+#endif
+
+/* Optimized matrix * selfadjoint matrix (?SYMM/?HEMM) product */
+
+#define EIGEN_BLAS_SYMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,false,ConjugateLhs,RhsStorageOrder,true,ConjugateRhs,ColMajor,1> \
+{\
+\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resIncr, Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+    eigen_assert(resIncr == 1); \
+    char side='R', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+\
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows);  \
+    n = convert_index<BlasIndex>(cols);  \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(rhsStride); \
+    ldb = convert_index<BlasIndex>(lhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (RhsStorageOrder==RowMajor) uplo='U'; \
+    a = _rhs; \
+\
+    if (LhsStorageOrder==RowMajor) { \
+      Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,n,m,OuterStride<>(rhsStride)); \
+      b_tmp = lhs.adjoint(); \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } else b = _lhs; \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+\
+  } \
+};
+
+
+#define EIGEN_BLAS_HEMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,false,ConjugateLhs,RhsStorageOrder,true,ConjugateRhs,ColMajor,1> \
+{\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resIncr, Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+    eigen_assert(resIncr == 1); \
+    char side='R', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+    Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> a_tmp; \
+\
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows); \
+    n = convert_index<BlasIndex>(cols); \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(rhsStride); \
+    ldb = convert_index<BlasIndex>(lhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (((RhsStorageOrder==ColMajor) && ConjugateRhs) || ((RhsStorageOrder==RowMajor) && (!ConjugateRhs))) { \
+      Map<const Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder>, 0, OuterStride<> > rhs(_rhs,n,n,OuterStride<>(rhsStride)); \
+      a_tmp = rhs.conjugate(); \
+      a = a_tmp.data(); \
+      lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+    } else a = _rhs; \
+    if (RhsStorageOrder==RowMajor) uplo='U'; \
+\
+    if (LhsStorageOrder==ColMajor && (!ConjugateLhs)) { \
+       b = _lhs; } \
+    else { \
+      if (LhsStorageOrder==ColMajor && ConjugateLhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,m,n,OuterStride<>(lhsStride)); \
+        b_tmp = lhs.conjugate(); \
+      } else \
+      if (ConjugateLhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,n,m,OuterStride<>(lhsStride)); \
+        b_tmp = lhs.adjoint(); \
+      } else { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,n,m,OuterStride<>(lhsStride)); \
+        b_tmp = lhs.transpose(); \
+      } \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_SYMM_R(double, double, d, dsymm)
+EIGEN_BLAS_SYMM_R(float, float, f, ssymm)
+EIGEN_BLAS_HEMM_R(dcomplex, MKL_Complex16, cd, zhemm)
+EIGEN_BLAS_HEMM_R(scomplex, MKL_Complex8, cf, chemm)
+#else
+EIGEN_BLAS_SYMM_R(double, double, d, dsymm_)
+EIGEN_BLAS_SYMM_R(float, float, f, ssymm_)
+EIGEN_BLAS_HEMM_R(dcomplex, double, cd, zhemm_)
+EIGEN_BLAS_HEMM_R(scomplex, float, cf, chemm_)
+#endif
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixVector.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixVector.h
new file mode 100644
index 00000000..d38fd72b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixVector.h
@@ -0,0 +1,262 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_VECTOR_H
+#define EIGEN_SELFADJOINT_MATRIX_VECTOR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/* Optimized selfadjoint matrix * vector product:
+ * This algorithm processes 2 columns at once that allows to both reduce
+ * the number of load/stores of the result by a factor 2 and to reduce
+ * the instruction dependency.
+ */
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs, int Version=Specialized>
+struct selfadjoint_matrix_vector_product;
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs, int Version>
+struct selfadjoint_matrix_vector_product
+
+{
+static EIGEN_DONT_INLINE EIGEN_DEVICE_FUNC
+void run(
+  Index size,
+  const Scalar*  lhs, Index lhsStride,
+  const Scalar*  rhs,
+  Scalar* res,
+  Scalar alpha);
+};
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs, int Version>
+EIGEN_DONT_INLINE EIGEN_DEVICE_FUNC
+void selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,Version>::run(
+  Index size,
+  const Scalar*  lhs, Index lhsStride,
+  const Scalar*  rhs,
+  Scalar* res,
+  Scalar alpha)
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  const Index PacketSize = sizeof(Packet)/sizeof(Scalar);
+
+  enum {
+    IsRowMajor = StorageOrder==RowMajor ? 1 : 0,
+    IsLower = UpLo == Lower ? 1 : 0,
+    FirstTriangular = IsRowMajor == IsLower
+  };
+
+  conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs,  IsRowMajor), ConjugateRhs> cj0;
+  conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> cj1;
+  conj_helper<RealScalar,Scalar,false, ConjugateRhs> cjd;
+
+  conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs,  IsRowMajor), ConjugateRhs> pcj0;
+  conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> pcj1;
+
+  Scalar cjAlpha = ConjugateRhs ? numext::conj(alpha) : alpha;
+
+  Index bound = numext::maxi(Index(0), size-8) & 0xfffffffe;
+  if (FirstTriangular)
+    bound = size - bound;
+
+  for (Index j=FirstTriangular ? bound : 0;
+       j<(FirstTriangular ? size : bound);j+=2)
+  {
+    const Scalar* EIGEN_RESTRICT A0 = lhs + j*lhsStride;
+    const Scalar* EIGEN_RESTRICT A1 = lhs + (j+1)*lhsStride;
+
+    Scalar t0 = cjAlpha * rhs[j];
+    Packet ptmp0 = pset1<Packet>(t0);
+    Scalar t1 = cjAlpha * rhs[j+1];
+    Packet ptmp1 = pset1<Packet>(t1);
+
+    Scalar t2(0);
+    Packet ptmp2 = pset1<Packet>(t2);
+    Scalar t3(0);
+    Packet ptmp3 = pset1<Packet>(t3);
+
+    Index starti = FirstTriangular ? 0 : j+2;
+    Index endi   = FirstTriangular ? j : size;
+    Index alignedStart = (starti) + internal::first_default_aligned(&res[starti], endi-starti);
+    Index alignedEnd = alignedStart + ((endi-alignedStart)/(PacketSize))*(PacketSize);
+
+    res[j]   += cjd.pmul(numext::real(A0[j]), t0);
+    res[j+1] += cjd.pmul(numext::real(A1[j+1]), t1);
+    if(FirstTriangular)
+    {
+      res[j]   += cj0.pmul(A1[j],   t1);
+      t3       += cj1.pmul(A1[j],   rhs[j]);
+    }
+    else
+    {
+      res[j+1] += cj0.pmul(A0[j+1],t0);
+      t2 += cj1.pmul(A0[j+1], rhs[j+1]);
+    }
+
+    for (Index i=starti; i<alignedStart; ++i)
+    {
+      res[i] += cj0.pmul(A0[i], t0) + cj0.pmul(A1[i],t1);
+      t2 += cj1.pmul(A0[i], rhs[i]);
+      t3 += cj1.pmul(A1[i], rhs[i]);
+    }
+    // Yes this an optimization for gcc 4.3 and 4.4 (=> huge speed up)
+    // gcc 4.2 does this optimization automatically.
+    const Scalar* EIGEN_RESTRICT a0It  = A0  + alignedStart;
+    const Scalar* EIGEN_RESTRICT a1It  = A1  + alignedStart;
+    const Scalar* EIGEN_RESTRICT rhsIt = rhs + alignedStart;
+          Scalar* EIGEN_RESTRICT resIt = res + alignedStart;
+    for (Index i=alignedStart; i<alignedEnd; i+=PacketSize)
+    {
+      Packet A0i = ploadu<Packet>(a0It);  a0It  += PacketSize;
+      Packet A1i = ploadu<Packet>(a1It);  a1It  += PacketSize;
+      Packet Bi  = ploadu<Packet>(rhsIt); rhsIt += PacketSize; // FIXME should be aligned in most cases
+      Packet Xi  = pload <Packet>(resIt);
+
+      Xi    = pcj0.pmadd(A0i,ptmp0, pcj0.pmadd(A1i,ptmp1,Xi));
+      ptmp2 = pcj1.pmadd(A0i,  Bi, ptmp2);
+      ptmp3 = pcj1.pmadd(A1i,  Bi, ptmp3);
+      pstore(resIt,Xi); resIt += PacketSize;
+    }
+    for (Index i=alignedEnd; i<endi; i++)
+    {
+      res[i] += cj0.pmul(A0[i], t0) + cj0.pmul(A1[i],t1);
+      t2 += cj1.pmul(A0[i], rhs[i]);
+      t3 += cj1.pmul(A1[i], rhs[i]);
+    }
+
+    res[j]   += alpha * (t2 + predux(ptmp2));
+    res[j+1] += alpha * (t3 + predux(ptmp3));
+  }
+  for (Index j=FirstTriangular ? 0 : bound;j<(FirstTriangular ? bound : size);j++)
+  {
+    const Scalar* EIGEN_RESTRICT A0 = lhs + j*lhsStride;
+
+    Scalar t1 = cjAlpha * rhs[j];
+    Scalar t2(0);
+    res[j] += cjd.pmul(numext::real(A0[j]), t1);
+    for (Index i=FirstTriangular ? 0 : j+1; i<(FirstTriangular ? j : size); i++)
+    {
+      res[i] += cj0.pmul(A0[i], t1);
+      t2 += cj1.pmul(A0[i], rhs[i]);
+    }
+    res[j] += alpha * t2;
+  }
+}
+
+} // end namespace internal 
+
+/***************************************************************************
+* Wrapper to product_selfadjoint_vector
+***************************************************************************/
+
+namespace internal {
+
+template<typename Lhs, int LhsMode, typename Rhs>
+struct selfadjoint_product_impl<Lhs,LhsMode,false,Rhs,0,true>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  typedef internal::blas_traits<Lhs> LhsBlasTraits;
+  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+  typedef typename internal::remove_all<ActualLhsType>::type ActualLhsTypeCleaned;
+  
+  typedef internal::blas_traits<Rhs> RhsBlasTraits;
+  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+  enum { LhsUpLo = LhsMode&(Upper|Lower) };
+
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC
+  void run(Dest& dest, const Lhs &a_lhs, const Rhs &a_rhs, const Scalar& alpha)
+  {
+    typedef typename Dest::Scalar ResScalar;
+    typedef typename Rhs::Scalar RhsScalar;
+    typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest;
+    
+    eigen_assert(dest.rows()==a_lhs.rows() && dest.cols()==a_rhs.cols());
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs)
+                               * RhsBlasTraits::extractScalarFactor(a_rhs);
+
+    enum {
+      EvalToDest = (Dest::InnerStrideAtCompileTime==1),
+      UseRhs = (ActualRhsTypeCleaned::InnerStrideAtCompileTime==1)
+    };
+    
+    internal::gemv_static_vector_if<ResScalar,Dest::SizeAtCompileTime,Dest::MaxSizeAtCompileTime,!EvalToDest> static_dest;
+    internal::gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!UseRhs> static_rhs;
+
+    ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(),
+                                                  EvalToDest ? dest.data() : static_dest.data());
+                                                  
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,rhs.size(),
+        UseRhs ? const_cast<RhsScalar*>(rhs.data()) : static_rhs.data());
+    
+    if(!EvalToDest)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = dest.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      MappedDest(actualDestPtr, dest.size()) = dest;
+    }
+      
+    if(!UseRhs)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = rhs.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, rhs.size()) = rhs;
+    }
+      
+      
+    internal::selfadjoint_matrix_vector_product<Scalar, Index, (internal::traits<ActualLhsTypeCleaned>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+                                                int(LhsUpLo), bool(LhsBlasTraits::NeedToConjugate), bool(RhsBlasTraits::NeedToConjugate)>::run
+      (
+        lhs.rows(),                             // size
+        &lhs.coeffRef(0,0),  lhs.outerStride(), // lhs info
+        actualRhsPtr,                           // rhs info
+        actualDestPtr,                          // result info
+        actualAlpha                             // scale factor
+      );
+    
+    if(!EvalToDest)
+      dest = MappedDest(actualDestPtr, dest.size());
+  }
+};
+
+template<typename Lhs, typename Rhs, int RhsMode>
+struct selfadjoint_product_impl<Lhs,0,true,Rhs,RhsMode,false>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  enum { RhsUpLo = RhsMode&(Upper|Lower)  };
+
+  template<typename Dest>
+  static void run(Dest& dest, const Lhs &a_lhs, const Rhs &a_rhs, const Scalar& alpha)
+  {
+    // let's simply transpose the product
+    Transpose<Dest> destT(dest);
+    selfadjoint_product_impl<Transpose<const Rhs>, int(RhsUpLo)==Upper ? Lower : Upper, false,
+                             Transpose<const Lhs>, 0, true>::run(destT, a_rhs.transpose(), a_lhs.transpose(), alpha);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_VECTOR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
new file mode 100644
index 00000000..1238345e
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
@@ -0,0 +1,118 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Selfadjoint matrix-vector product functionality based on ?SYMV/HEMV.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
+#define EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements selfadjoint matrix-vector multiplication using BLAS
+**********************************************************************/
+
+// symv/hemv specialization
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs>
+struct selfadjoint_matrix_vector_product_symv :
+  selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,BuiltIn> {};
+
+#define EIGEN_BLAS_SYMV_SPECIALIZE(Scalar) \
+template<typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs> \
+struct selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,Specialized> { \
+static void run( \
+  Index size, const Scalar*  lhs, Index lhsStride, \
+  const Scalar* _rhs, Scalar* res, Scalar alpha) { \
+    enum {\
+      IsColMajor = StorageOrder==ColMajor \
+    }; \
+    if (IsColMajor == ConjugateLhs) {\
+      selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,BuiltIn>::run( \
+        size, lhs, lhsStride, _rhs, res, alpha);  \
+    } else {\
+      selfadjoint_matrix_vector_product_symv<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs>::run( \
+        size, lhs, lhsStride, _rhs, res, alpha);  \
+    }\
+  } \
+}; \
+
+EIGEN_BLAS_SYMV_SPECIALIZE(double)
+EIGEN_BLAS_SYMV_SPECIALIZE(float)
+EIGEN_BLAS_SYMV_SPECIALIZE(dcomplex)
+EIGEN_BLAS_SYMV_SPECIALIZE(scomplex)
+
+#define EIGEN_BLAS_SYMV_SPECIALIZATION(EIGTYPE,BLASTYPE,BLASFUNC) \
+template<typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs> \
+struct selfadjoint_matrix_vector_product_symv<EIGTYPE,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs> \
+{ \
+typedef Matrix<EIGTYPE,Dynamic,1,ColMajor> SYMVVector;\
+\
+static void run( \
+Index size, const EIGTYPE*  lhs, Index lhsStride, \
+const EIGTYPE* _rhs, EIGTYPE* res, EIGTYPE alpha) \
+{ \
+  enum {\
+    IsRowMajor = StorageOrder==RowMajor ? 1 : 0, \
+    IsLower = UpLo == Lower ? 1 : 0 \
+  }; \
+  BlasIndex n=convert_index<BlasIndex>(size), lda=convert_index<BlasIndex>(lhsStride), incx=1, incy=1; \
+  EIGTYPE beta(1); \
+  const EIGTYPE *x_ptr; \
+  char uplo=(IsRowMajor) ? (IsLower ? 'U' : 'L') : (IsLower ? 'L' : 'U'); \
+  SYMVVector x_tmp; \
+  if (ConjugateRhs) { \
+    Map<const SYMVVector, 0 > map_x(_rhs,size,1); \
+    x_tmp=map_x.conjugate(); \
+    x_ptr=x_tmp.data(); \
+  } else x_ptr=_rhs; \
+  BLASFUNC(&uplo, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)lhs, &lda, (const BLASTYPE*)x_ptr, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &incy); \
+}\
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_SYMV_SPECIALIZATION(double,   double, dsymv)
+EIGEN_BLAS_SYMV_SPECIALIZATION(float,    float,  ssymv)
+EIGEN_BLAS_SYMV_SPECIALIZATION(dcomplex, MKL_Complex16, zhemv)
+EIGEN_BLAS_SYMV_SPECIALIZATION(scomplex, MKL_Complex8,  chemv)
+#else
+EIGEN_BLAS_SYMV_SPECIALIZATION(double,   double, dsymv_)
+EIGEN_BLAS_SYMV_SPECIALIZATION(float,    float,  ssymv_)
+EIGEN_BLAS_SYMV_SPECIALIZATION(dcomplex, double, zhemv_)
+EIGEN_BLAS_SYMV_SPECIALIZATION(scomplex, float,  chemv_)
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointProduct.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointProduct.h
new file mode 100644
index 00000000..a21be805
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointProduct.h
@@ -0,0 +1,133 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINT_PRODUCT_H
+#define EIGEN_SELFADJOINT_PRODUCT_H
+
+/**********************************************************************
+* This file implements a self adjoint product: C += A A^T updating only
+* half of the selfadjoint matrix C.
+* It corresponds to the level 3 SYRK and level 2 SYR Blas routines.
+**********************************************************************/
+
+namespace Eigen { 
+
+
+template<typename Scalar, typename Index, int UpLo, bool ConjLhs, bool ConjRhs>
+struct selfadjoint_rank1_update<Scalar,Index,ColMajor,UpLo,ConjLhs,ConjRhs>
+{
+  static void run(Index size, Scalar* mat, Index stride, const Scalar* vecX, const Scalar* vecY, const Scalar& alpha)
+  {
+    internal::conj_if<ConjRhs> cj;
+    typedef Map<const Matrix<Scalar,Dynamic,1> > OtherMap;
+    typedef typename internal::conditional<ConjLhs,typename OtherMap::ConjugateReturnType,const OtherMap&>::type ConjLhsType;
+    for (Index i=0; i<size; ++i)
+    {
+      Map<Matrix<Scalar,Dynamic,1> >(mat+stride*i+(UpLo==Lower ? i : 0), (UpLo==Lower ? size-i : (i+1)))
+          += (alpha * cj(vecY[i])) * ConjLhsType(OtherMap(vecX+(UpLo==Lower ? i : 0),UpLo==Lower ? size-i : (i+1)));
+    }
+  }
+};
+
+template<typename Scalar, typename Index, int UpLo, bool ConjLhs, bool ConjRhs>
+struct selfadjoint_rank1_update<Scalar,Index,RowMajor,UpLo,ConjLhs,ConjRhs>
+{
+  static void run(Index size, Scalar* mat, Index stride, const Scalar* vecX, const Scalar* vecY, const Scalar& alpha)
+  {
+    selfadjoint_rank1_update<Scalar,Index,ColMajor,UpLo==Lower?Upper:Lower,ConjRhs,ConjLhs>::run(size,mat,stride,vecY,vecX,alpha);
+  }
+};
+
+template<typename MatrixType, typename OtherType, int UpLo, bool OtherIsVector = OtherType::IsVectorAtCompileTime>
+struct selfadjoint_product_selector;
+
+template<typename MatrixType, typename OtherType, int UpLo>
+struct selfadjoint_product_selector<MatrixType,OtherType,UpLo,true>
+{
+  static void run(MatrixType& mat, const OtherType& other, const typename MatrixType::Scalar& alpha)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    typedef internal::blas_traits<OtherType> OtherBlasTraits;
+    typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
+    typedef typename internal::remove_all<ActualOtherType>::type _ActualOtherType;
+    typename internal::add_const_on_value_type<ActualOtherType>::type actualOther = OtherBlasTraits::extract(other.derived());
+
+    Scalar actualAlpha = alpha * OtherBlasTraits::extractScalarFactor(other.derived());
+
+    enum {
+      StorageOrder = (internal::traits<MatrixType>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+      UseOtherDirectly = _ActualOtherType::InnerStrideAtCompileTime==1
+    };
+    internal::gemv_static_vector_if<Scalar,OtherType::SizeAtCompileTime,OtherType::MaxSizeAtCompileTime,!UseOtherDirectly> static_other;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, actualOtherPtr, other.size(),
+      (UseOtherDirectly ? const_cast<Scalar*>(actualOther.data()) : static_other.data()));
+      
+    if(!UseOtherDirectly)
+      Map<typename _ActualOtherType::PlainObject>(actualOtherPtr, actualOther.size()) = actualOther;
+    
+    selfadjoint_rank1_update<Scalar,Index,StorageOrder,UpLo,
+                              OtherBlasTraits::NeedToConjugate  && NumTraits<Scalar>::IsComplex,
+                            (!OtherBlasTraits::NeedToConjugate) && NumTraits<Scalar>::IsComplex>
+          ::run(other.size(), mat.data(), mat.outerStride(), actualOtherPtr, actualOtherPtr, actualAlpha);
+  }
+};
+
+template<typename MatrixType, typename OtherType, int UpLo>
+struct selfadjoint_product_selector<MatrixType,OtherType,UpLo,false>
+{
+  static void run(MatrixType& mat, const OtherType& other, const typename MatrixType::Scalar& alpha)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    typedef internal::blas_traits<OtherType> OtherBlasTraits;
+    typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
+    typedef typename internal::remove_all<ActualOtherType>::type _ActualOtherType;
+    typename internal::add_const_on_value_type<ActualOtherType>::type actualOther = OtherBlasTraits::extract(other.derived());
+
+    Scalar actualAlpha = alpha * OtherBlasTraits::extractScalarFactor(other.derived());
+
+    enum {
+      IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0,
+      OtherIsRowMajor = _ActualOtherType::Flags&RowMajorBit ? 1 : 0
+    };
+
+    Index size = mat.cols();
+    Index depth = actualOther.cols();
+
+    typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,Scalar,Scalar,
+              MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime, _ActualOtherType::MaxColsAtCompileTime> BlockingType;
+
+    BlockingType blocking(size, size, depth, 1, false);
+
+
+    internal::general_matrix_matrix_triangular_product<Index,
+      Scalar, OtherIsRowMajor ? RowMajor : ColMajor,   OtherBlasTraits::NeedToConjugate  && NumTraits<Scalar>::IsComplex,
+      Scalar, OtherIsRowMajor ? ColMajor : RowMajor, (!OtherBlasTraits::NeedToConjugate) && NumTraits<Scalar>::IsComplex,
+      IsRowMajor ? RowMajor : ColMajor, MatrixType::InnerStrideAtCompileTime, UpLo>
+      ::run(size, depth,
+            actualOther.data(), actualOther.outerStride(), actualOther.data(), actualOther.outerStride(),
+            mat.data(), mat.innerStride(), mat.outerStride(), actualAlpha, blocking);
+  }
+};
+
+// high level API
+
+template<typename MatrixType, unsigned int UpLo>
+template<typename DerivedU>
+EIGEN_DEVICE_FUNC SelfAdjointView<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo>
+::rankUpdate(const MatrixBase<DerivedU>& u, const Scalar& alpha)
+{
+  selfadjoint_product_selector<MatrixType,DerivedU,UpLo>::run(_expression().const_cast_derived(), u.derived(), alpha);
+
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_PRODUCT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointRank2Update.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointRank2Update.h
new file mode 100644
index 00000000..f752a0bf
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/SelfadjointRank2Update.h
@@ -0,0 +1,94 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINTRANK2UPTADE_H
+#define EIGEN_SELFADJOINTRANK2UPTADE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/* Optimized selfadjoint matrix += alpha * uv' + conj(alpha)*vu'
+ * It corresponds to the Level2 syr2 BLAS routine
+ */
+
+template<typename Scalar, typename Index, typename UType, typename VType, int UpLo>
+struct selfadjoint_rank2_update_selector;
+
+template<typename Scalar, typename Index, typename UType, typename VType>
+struct selfadjoint_rank2_update_selector<Scalar,Index,UType,VType,Lower>
+{
+  static EIGEN_DEVICE_FUNC
+  void run(Scalar* mat, Index stride, const UType& u, const VType& v, const Scalar& alpha)
+  {
+    const Index size = u.size();
+    for (Index i=0; i<size; ++i)
+    {
+      Map<Matrix<Scalar,Dynamic,1> >(mat+stride*i+i, size-i) +=
+                        (numext::conj(alpha) * numext::conj(u.coeff(i))) * v.tail(size-i)
+                      + (alpha * numext::conj(v.coeff(i))) * u.tail(size-i);
+    }
+  }
+};
+
+template<typename Scalar, typename Index, typename UType, typename VType>
+struct selfadjoint_rank2_update_selector<Scalar,Index,UType,VType,Upper>
+{
+  static void run(Scalar* mat, Index stride, const UType& u, const VType& v, const Scalar& alpha)
+  {
+    const Index size = u.size();
+    for (Index i=0; i<size; ++i)
+      Map<Matrix<Scalar,Dynamic,1> >(mat+stride*i, i+1) +=
+                        (numext::conj(alpha)  * numext::conj(u.coeff(i))) * v.head(i+1)
+                      + (alpha * numext::conj(v.coeff(i))) * u.head(i+1);
+  }
+};
+
+template<bool Cond, typename T> struct conj_expr_if
+  : conditional<!Cond, const T&,
+      CwiseUnaryOp<scalar_conjugate_op<typename traits<T>::Scalar>,T> > {};
+
+} // end namespace internal
+
+template<typename MatrixType, unsigned int UpLo>
+template<typename DerivedU, typename DerivedV>
+EIGEN_DEVICE_FUNC SelfAdjointView<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo>
+::rankUpdate(const MatrixBase<DerivedU>& u, const MatrixBase<DerivedV>& v, const Scalar& alpha)
+{
+  typedef internal::blas_traits<DerivedU> UBlasTraits;
+  typedef typename UBlasTraits::DirectLinearAccessType ActualUType;
+  typedef typename internal::remove_all<ActualUType>::type _ActualUType;
+  typename internal::add_const_on_value_type<ActualUType>::type actualU = UBlasTraits::extract(u.derived());
+
+  typedef internal::blas_traits<DerivedV> VBlasTraits;
+  typedef typename VBlasTraits::DirectLinearAccessType ActualVType;
+  typedef typename internal::remove_all<ActualVType>::type _ActualVType;
+  typename internal::add_const_on_value_type<ActualVType>::type actualV = VBlasTraits::extract(v.derived());
+
+  // If MatrixType is row major, then we use the routine for lower triangular in the upper triangular case and
+  // vice versa, and take the complex conjugate of all coefficients and vector entries.
+
+  enum { IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0 };
+  Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived())
+                             * numext::conj(VBlasTraits::extractScalarFactor(v.derived()));
+  if (IsRowMajor)
+    actualAlpha = numext::conj(actualAlpha);
+
+  typedef typename internal::remove_all<typename internal::conj_expr_if<int(IsRowMajor) ^ int(UBlasTraits::NeedToConjugate), _ActualUType>::type>::type UType;
+  typedef typename internal::remove_all<typename internal::conj_expr_if<int(IsRowMajor) ^ int(VBlasTraits::NeedToConjugate), _ActualVType>::type>::type VType;
+  internal::selfadjoint_rank2_update_selector<Scalar, Index, UType, VType,
+    (IsRowMajor ? int(UpLo==Upper ? Lower : Upper) : UpLo)>
+    ::run(_expression().const_cast_derived().data(),_expression().outerStride(),UType(actualU),VType(actualV),actualAlpha);
+
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINTRANK2UPTADE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixMatrix.h
new file mode 100644
index 00000000..f0c60507
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixMatrix.h
@@ -0,0 +1,472 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULAR_MATRIX_MATRIX_H
+#define EIGEN_TRIANGULAR_MATRIX_MATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// template<typename Scalar, int mr, int StorageOrder, bool Conjugate, int Mode>
+// struct gemm_pack_lhs_triangular
+// {
+//   Matrix<Scalar,mr,mr,
+//   void operator()(Scalar* blockA, const EIGEN_RESTRICT Scalar* _lhs, int lhsStride, int depth, int rows)
+//   {
+//     conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+//     const_blas_data_mapper<Scalar, StorageOrder> lhs(_lhs,lhsStride);
+//     int count = 0;
+//     const int peeled_mc = (rows/mr)*mr;
+//     for(int i=0; i<peeled_mc; i+=mr)
+//     {
+//       for(int k=0; k<depth; k++)
+//         for(int w=0; w<mr; w++)
+//           blockA[count++] = cj(lhs(i+w, k));
+//     }
+//     for(int i=peeled_mc; i<rows; i++)
+//     {
+//       for(int k=0; k<depth; k++)
+//         blockA[count++] = cj(lhs(i, k));
+//     }
+//   }
+// };
+
+/* Optimized triangular matrix * matrix (_TRMM++) product built on top of
+ * the general matrix matrix product.
+ */
+template <typename Scalar, typename Index,
+          int Mode, bool LhsIsTriangular,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResStorageOrder, int ResInnerStride,
+          int Version = Specialized>
+struct product_triangular_matrix_matrix;
+
+template <typename Scalar, typename Index,
+          int Mode, bool LhsIsTriangular,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride, int Version>
+struct product_triangular_matrix_matrix<Scalar,Index,Mode,LhsIsTriangular,
+                                           LhsStorageOrder,ConjugateLhs,
+                                           RhsStorageOrder,ConjugateRhs,RowMajor,ResInnerStride,Version>
+{
+  static EIGEN_STRONG_INLINE void run(
+    Index rows, Index cols, Index depth,
+    const Scalar* lhs, Index lhsStride,
+    const Scalar* rhs, Index rhsStride,
+    Scalar* res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    product_triangular_matrix_matrix<Scalar, Index,
+      (Mode&(UnitDiag|ZeroDiag)) | ((Mode&Upper) ? Lower : Upper),
+      (!LhsIsTriangular),
+      RhsStorageOrder==RowMajor ? ColMajor : RowMajor,
+      ConjugateRhs,
+      LhsStorageOrder==RowMajor ? ColMajor : RowMajor,
+      ConjugateLhs,
+      ColMajor, ResInnerStride>
+      ::run(cols, rows, depth, rhs, rhsStride, lhs, lhsStride, res, resIncr, resStride, alpha, blocking);
+  }
+};
+
+// implements col-major += alpha * op(triangular) * op(general)
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride, int Version>
+struct product_triangular_matrix_matrix<Scalar,Index,Mode,true,
+                                           LhsStorageOrder,ConjugateLhs,
+                                           RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride,Version>
+{
+  
+  typedef gebp_traits<Scalar,Scalar> Traits;
+  enum {
+    SmallPanelWidth   = 2 * EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+    IsLower = (Mode&Lower) == Lower,
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1
+  };
+
+  static EIGEN_DONT_INLINE void run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride, int Version>
+EIGEN_DONT_INLINE void product_triangular_matrix_matrix<Scalar,Index,Mode,true,
+                                                        LhsStorageOrder,ConjugateLhs,
+                                                        RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride,Version>::run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    // strip zeros
+    Index diagSize  = (std::min)(_rows,_depth);
+    Index rows      = IsLower ? _rows : diagSize;
+    Index depth     = IsLower ? diagSize : _depth;
+    Index cols      = _cols;
+    
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride, resIncr);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+    // The small panel size must not be larger than blocking size.
+    // Usually this should never be the case because SmallPanelWidth^2 is very small
+    // compared to L2 cache size, but let's be safe:
+    Index panelWidth = (std::min)(Index(SmallPanelWidth),(std::min)(kc,mc));
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    // To work around an "error: member reference base type 'Matrix<...>
+    // (Eigen::internal::constructor_without_unaligned_array_assert (*)())' is
+    // not a structure or union" compilation error in nvcc (tested V8.0.61),
+    // create a dummy internal::constructor_without_unaligned_array_assert
+    // object to pass to the Matrix constructor.
+    internal::constructor_without_unaligned_array_assert a;
+    Matrix<Scalar,SmallPanelWidth,SmallPanelWidth,LhsStorageOrder> triangularBuffer(a);
+    triangularBuffer.setZero();
+    if((Mode&ZeroDiag)==ZeroDiag)
+      triangularBuffer.diagonal().setZero();
+    else
+      triangularBuffer.diagonal().setOnes();
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder> pack_rhs;
+
+    for(Index k2=IsLower ? depth : 0;
+        IsLower ? k2>0 : k2<depth;
+        IsLower ? k2-=kc : k2+=kc)
+    {
+      Index actual_kc = (std::min)(IsLower ? k2 : depth-k2, kc);
+      Index actual_k2 = IsLower ? k2-actual_kc : k2;
+
+      // align blocks with the end of the triangular part for trapezoidal lhs
+      if((!IsLower)&&(k2<rows)&&(k2+actual_kc>rows))
+      {
+        actual_kc = rows-k2;
+        k2 = k2+actual_kc-kc;
+      }
+
+      pack_rhs(blockB, rhs.getSubMapper(actual_k2,0), actual_kc, cols);
+
+      // the selected lhs's panel has to be split in three different parts:
+      //  1 - the part which is zero => skip it
+      //  2 - the diagonal block => special kernel
+      //  3 - the dense panel below (lower case) or above (upper case) the diagonal block => GEPP
+
+      // the block diagonal, if any:
+      if(IsLower || actual_k2<rows)
+      {
+        // for each small vertical panels of lhs
+        for (Index k1=0; k1<actual_kc; k1+=panelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-k1, panelWidth);
+          Index lengthTarget = IsLower ? actual_kc-k1-actualPanelWidth : k1;
+          Index startBlock   = actual_k2+k1;
+          Index blockBOffset = k1;
+
+          // => GEBP with the micro triangular block
+          // The trick is to pack this micro block while filling the opposite triangular part with zeros.
+          // To this end we do an extra triangular copy to a small temporary buffer
+          for (Index k=0;k<actualPanelWidth;++k)
+          {
+            if (SetDiag)
+              triangularBuffer.coeffRef(k,k) = lhs(startBlock+k,startBlock+k);
+            for (Index i=IsLower ? k+1 : 0; IsLower ? i<actualPanelWidth : i<k; ++i)
+              triangularBuffer.coeffRef(i,k) = lhs(startBlock+i,startBlock+k);
+          }
+          pack_lhs(blockA, LhsMapper(triangularBuffer.data(), triangularBuffer.outerStride()), actualPanelWidth, actualPanelWidth);
+
+          gebp_kernel(res.getSubMapper(startBlock, 0), blockA, blockB,
+                      actualPanelWidth, actualPanelWidth, cols, alpha,
+                      actualPanelWidth, actual_kc, 0, blockBOffset);
+
+          // GEBP with remaining micro panel
+          if (lengthTarget>0)
+          {
+            Index startTarget  = IsLower ? actual_k2+k1+actualPanelWidth : actual_k2;
+
+            pack_lhs(blockA, lhs.getSubMapper(startTarget,startBlock), actualPanelWidth, lengthTarget);
+
+            gebp_kernel(res.getSubMapper(startTarget, 0), blockA, blockB,
+                        lengthTarget, actualPanelWidth, cols, alpha,
+                        actualPanelWidth, actual_kc, 0, blockBOffset);
+          }
+        }
+      }
+      // the part below (lower case) or above (upper case) the diagonal => GEPP
+      {
+        Index start = IsLower ? k2 : 0;
+        Index end   = IsLower ? rows : (std::min)(actual_k2,rows);
+        for(Index i2=start; i2<end; i2+=mc)
+        {
+          const Index actual_mc = (std::min)(i2+mc,end)-i2;
+          gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr,Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder,false>()
+            (blockA, lhs.getSubMapper(i2, actual_k2), actual_kc, actual_mc);
+
+          gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc,
+                      actual_kc, cols, alpha, -1, -1, 0, 0);
+        }
+      }
+    }
+  }
+
+// implements col-major += alpha * op(general) * op(triangular)
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride, int Version>
+struct product_triangular_matrix_matrix<Scalar,Index,Mode,false,
+                                        LhsStorageOrder,ConjugateLhs,
+                                        RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride,Version>
+{
+  typedef gebp_traits<Scalar,Scalar> Traits;
+  enum {
+    SmallPanelWidth   = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+    IsLower = (Mode&Lower) == Lower,
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1
+  };
+
+  static EIGEN_DONT_INLINE void run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride, int Version>
+EIGEN_DONT_INLINE void product_triangular_matrix_matrix<Scalar,Index,Mode,false,
+                                                        LhsStorageOrder,ConjugateLhs,
+                                                        RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride,Version>::run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    const Index PacketBytes = packet_traits<Scalar>::size*sizeof(Scalar);
+    // strip zeros
+    Index diagSize  = (std::min)(_cols,_depth);
+    Index rows      = _rows;
+    Index depth     = IsLower ? _depth : diagSize;
+    Index cols      = IsLower ? diagSize : _cols;
+    
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride, resIncr);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols+EIGEN_MAX_ALIGN_BYTES/sizeof(Scalar);
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    internal::constructor_without_unaligned_array_assert a;
+    Matrix<Scalar,SmallPanelWidth,SmallPanelWidth,RhsStorageOrder> triangularBuffer(a);
+    triangularBuffer.setZero();
+    if((Mode&ZeroDiag)==ZeroDiag)
+      triangularBuffer.diagonal().setZero();
+    else
+      triangularBuffer.diagonal().setOnes();
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder> pack_rhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder,false,true> pack_rhs_panel;
+
+    for(Index k2=IsLower ? 0 : depth;
+        IsLower ? k2<depth  : k2>0;
+        IsLower ? k2+=kc   : k2-=kc)
+    {
+      Index actual_kc = (std::min)(IsLower ? depth-k2 : k2, kc);
+      Index actual_k2 = IsLower ? k2 : k2-actual_kc;
+
+      // align blocks with the end of the triangular part for trapezoidal rhs
+      if(IsLower && (k2<cols) && (actual_k2+actual_kc>cols))
+      {
+        actual_kc = cols-k2;
+        k2 = actual_k2 + actual_kc - kc;
+      }
+
+      // remaining size
+      Index rs = IsLower ? (std::min)(cols,actual_k2) : cols - k2;
+      // size of the triangular part
+      Index ts = (IsLower && actual_k2>=cols) ? 0 : actual_kc;
+
+      Scalar* geb = blockB+ts*ts;
+      geb = geb + internal::first_aligned<PacketBytes>(geb,PacketBytes/sizeof(Scalar));
+
+      pack_rhs(geb, rhs.getSubMapper(actual_k2,IsLower ? 0 : k2), actual_kc, rs);
+
+      // pack the triangular part of the rhs padding the unrolled blocks with zeros
+      if(ts>0)
+      {
+        for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+          Index actual_j2 = actual_k2 + j2;
+          Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
+          Index panelLength = IsLower ? actual_kc-j2-actualPanelWidth : j2;
+          // general part
+          pack_rhs_panel(blockB+j2*actual_kc,
+                         rhs.getSubMapper(actual_k2+panelOffset, actual_j2),
+                         panelLength, actualPanelWidth,
+                         actual_kc, panelOffset);
+
+          // append the triangular part via a temporary buffer
+          for (Index j=0;j<actualPanelWidth;++j)
+          {
+            if (SetDiag)
+              triangularBuffer.coeffRef(j,j) = rhs(actual_j2+j,actual_j2+j);
+            for (Index k=IsLower ? j+1 : 0; IsLower ? k<actualPanelWidth : k<j; ++k)
+              triangularBuffer.coeffRef(k,j) = rhs(actual_j2+k,actual_j2+j);
+          }
+
+          pack_rhs_panel(blockB+j2*actual_kc,
+                         RhsMapper(triangularBuffer.data(), triangularBuffer.outerStride()),
+                         actualPanelWidth, actualPanelWidth,
+                         actual_kc, j2);
+        }
+      }
+
+      for (Index i2=0; i2<rows; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(mc,rows-i2);
+        pack_lhs(blockA, lhs.getSubMapper(i2, actual_k2), actual_kc, actual_mc);
+
+        // triangular kernel
+        if(ts>0)
+        {
+          for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
+          {
+            Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+            Index panelLength = IsLower ? actual_kc-j2 : j2+actualPanelWidth;
+            Index blockOffset = IsLower ? j2 : 0;
+
+            gebp_kernel(res.getSubMapper(i2, actual_k2 + j2),
+                        blockA, blockB+j2*actual_kc,
+                        actual_mc, panelLength, actualPanelWidth,
+                        alpha,
+                        actual_kc, actual_kc,  // strides
+                        blockOffset, blockOffset);// offsets
+          }
+        }
+        gebp_kernel(res.getSubMapper(i2, IsLower ? 0 : k2),
+                    blockA, geb, actual_mc, actual_kc, rs,
+                    alpha,
+                    -1, -1, 0, 0);
+      }
+    }
+  }
+
+/***************************************************************************
+* Wrapper to product_triangular_matrix_matrix
+***************************************************************************/
+
+} // end namespace internal
+
+namespace internal {
+template<int Mode, bool LhsIsTriangular, typename Lhs, typename Rhs>
+struct triangular_product_impl<Mode,LhsIsTriangular,Lhs,false,Rhs,false>
+{
+  template<typename Dest> static void run(Dest& dst, const Lhs &a_lhs, const Rhs &a_rhs, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar  LhsScalar;
+    typedef typename Rhs::Scalar  RhsScalar;
+    typedef typename Dest::Scalar Scalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef typename internal::remove_all<ActualLhsType>::type ActualLhsTypeCleaned;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+    
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(a_lhs);
+    RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(a_rhs);
+    Scalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+
+    typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
+              Lhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxColsAtCompileTime,4> BlockingType;
+
+    enum { IsLower = (Mode&Lower) == Lower };
+    Index stripedRows  = ((!LhsIsTriangular) || (IsLower))  ? lhs.rows() : (std::min)(lhs.rows(),lhs.cols());
+    Index stripedCols  = ((LhsIsTriangular)  || (!IsLower)) ? rhs.cols() : (std::min)(rhs.cols(),rhs.rows());
+    Index stripedDepth = LhsIsTriangular ? ((!IsLower) ? lhs.cols() : (std::min)(lhs.cols(),lhs.rows()))
+                                         : ((IsLower)  ? rhs.rows() : (std::min)(rhs.rows(),rhs.cols()));
+
+    BlockingType blocking(stripedRows, stripedCols, stripedDepth, 1, false);
+
+    internal::product_triangular_matrix_matrix<Scalar, Index,
+      Mode, LhsIsTriangular,
+      (internal::traits<ActualLhsTypeCleaned>::Flags&RowMajorBit) ? RowMajor : ColMajor, LhsBlasTraits::NeedToConjugate,
+      (internal::traits<ActualRhsTypeCleaned>::Flags&RowMajorBit) ? RowMajor : ColMajor, RhsBlasTraits::NeedToConjugate,
+      (internal::traits<Dest          >::Flags&RowMajorBit) ? RowMajor : ColMajor, Dest::InnerStrideAtCompileTime>
+      ::run(
+        stripedRows, stripedCols, stripedDepth,   // sizes
+        &lhs.coeffRef(0,0), lhs.outerStride(),    // lhs info
+        &rhs.coeffRef(0,0), rhs.outerStride(),    // rhs info
+        &dst.coeffRef(0,0), dst.innerStride(), dst.outerStride(),    // result info
+        actualAlpha, blocking
+      );
+
+    // Apply correction if the diagonal is unit and a scalar factor was nested:
+    if ((Mode&UnitDiag)==UnitDiag)
+    {
+      if (LhsIsTriangular && lhs_alpha!=LhsScalar(1))
+      {
+        Index diagSize = (std::min)(lhs.rows(),lhs.cols());
+        dst.topRows(diagSize) -= ((lhs_alpha-LhsScalar(1))*a_rhs).topRows(diagSize);
+      }
+      else if ((!LhsIsTriangular) && rhs_alpha!=RhsScalar(1))
+      {
+        Index diagSize = (std::min)(rhs.rows(),rhs.cols());
+        dst.leftCols(diagSize) -= (rhs_alpha-RhsScalar(1))*a_lhs.leftCols(diagSize);
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_MATRIX_MATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
new file mode 100644
index 00000000..a98d12e4
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
@@ -0,0 +1,317 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Triangular matrix * matrix product functionality based on ?TRMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
+#define EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+template <typename Scalar, typename Index,
+          int Mode, bool LhsIsTriangular,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResStorageOrder>
+struct product_triangular_matrix_matrix_trmm :
+       product_triangular_matrix_matrix<Scalar,Index,Mode,
+          LhsIsTriangular,LhsStorageOrder,ConjugateLhs,
+          RhsStorageOrder, ConjugateRhs, ResStorageOrder, 1, BuiltIn> {};
+
+
+// try to go to BLAS specialization
+#define EIGEN_BLAS_TRMM_SPECIALIZE(Scalar, LhsIsTriangular) \
+template <typename Index, int Mode, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_triangular_matrix_matrix<Scalar,Index, Mode, LhsIsTriangular, \
+           LhsStorageOrder,ConjugateLhs, RhsStorageOrder,ConjugateRhs,ColMajor,1,Specialized> { \
+  static inline void run(Index _rows, Index _cols, Index _depth, const Scalar* _lhs, Index lhsStride,\
+    const Scalar* _rhs, Index rhsStride, Scalar* res, Index resIncr, Index resStride, Scalar alpha, level3_blocking<Scalar,Scalar>& blocking) { \
+      EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+      eigen_assert(resIncr == 1); \
+      product_triangular_matrix_matrix_trmm<Scalar,Index,Mode, \
+        LhsIsTriangular,LhsStorageOrder,ConjugateLhs, \
+        RhsStorageOrder, ConjugateRhs, ColMajor>::run( \
+          _rows, _cols, _depth, _lhs, lhsStride, _rhs, rhsStride, res, resStride, alpha, blocking); \
+  } \
+};
+
+EIGEN_BLAS_TRMM_SPECIALIZE(double, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(double, false)
+EIGEN_BLAS_TRMM_SPECIALIZE(dcomplex, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(dcomplex, false)
+EIGEN_BLAS_TRMM_SPECIALIZE(float, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(float, false)
+EIGEN_BLAS_TRMM_SPECIALIZE(scomplex, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(scomplex, false)
+
+// implements col-major += alpha * op(triangular) * op(general)
+#define EIGEN_BLAS_TRMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, int Mode, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_triangular_matrix_matrix_trmm<EIGTYPE,Index,Mode,true, \
+         LhsStorageOrder,ConjugateLhs,RhsStorageOrder,ConjugateRhs,ColMajor> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = ((LhsStorageOrder==ColMajor) && ConjugateLhs) ? 1 : 0 \
+  }; \
+\
+  static void run( \
+    Index _rows, Index _cols, Index _depth, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE,EIGTYPE>& blocking) \
+  { \
+   Index diagSize  = (std::min)(_rows,_depth); \
+   Index rows      = IsLower ? _rows : diagSize; \
+   Index depth     = IsLower ? diagSize : _depth; \
+   Index cols      = _cols; \
+\
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> MatrixLhs; \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs; \
+\
+/* Non-square case - doesn't fit to BLAS ?TRMM. Fall to default triangular product or call BLAS ?GEMM*/ \
+   if (rows != depth) { \
+\
+     /* FIXME handle mkl_domain_get_max_threads */ \
+     /*int nthr = mkl_domain_get_max_threads(EIGEN_BLAS_DOMAIN_BLAS);*/ int nthr = 1;\
+\
+     if (((nthr==1) && (((std::max)(rows,depth)-diagSize)/(double)diagSize < 0.5))) { \
+     /* Most likely no benefit to call TRMM or GEMM from BLAS */ \
+       product_triangular_matrix_matrix<EIGTYPE,Index,Mode,true, \
+       LhsStorageOrder,ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, 1, BuiltIn>::run( \
+           _rows, _cols, _depth, _lhs, lhsStride, _rhs, rhsStride, res, 1, resStride, alpha, blocking); \
+     /*std::cout << "TRMM_L: A is not square! Go to Eigen TRMM implementation!\n";*/ \
+     } else { \
+     /* Make sense to call GEMM */ \
+       Map<const MatrixLhs, 0, OuterStride<> > lhsMap(_lhs,rows,depth,OuterStride<>(lhsStride)); \
+       MatrixLhs aa_tmp=lhsMap.template triangularView<Mode>(); \
+       BlasIndex aStride = convert_index<BlasIndex>(aa_tmp.outerStride()); \
+       gemm_blocking_space<ColMajor,EIGTYPE,EIGTYPE,Dynamic,Dynamic,Dynamic> gemm_blocking(_rows,_cols,_depth, 1, true); \
+       general_matrix_matrix_product<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,RhsStorageOrder,ConjugateRhs,ColMajor,1>::run( \
+       rows, cols, depth, aa_tmp.data(), aStride, _rhs, rhsStride, res, 1, resStride, alpha, gemm_blocking, 0); \
+\
+     /*std::cout << "TRMM_L: A is not square! Go to BLAS GEMM implementation! " << nthr<<" \n";*/ \
+     } \
+     return; \
+   } \
+   char side = 'L', transa, uplo, diag = 'N'; \
+   EIGTYPE *b; \
+   const EIGTYPE *a; \
+   BlasIndex m, n, lda, ldb; \
+\
+/* Set m, n */ \
+   m = convert_index<BlasIndex>(diagSize); \
+   n = convert_index<BlasIndex>(cols); \
+\
+/* Set trans */ \
+   transa = (LhsStorageOrder==RowMajor) ? ((ConjugateLhs) ? 'C' : 'T') : 'N'; \
+\
+/* Set b, ldb */ \
+   Map<const MatrixRhs, 0, OuterStride<> > rhs(_rhs,depth,cols,OuterStride<>(rhsStride)); \
+   MatrixX##EIGPREFIX b_tmp; \
+\
+   if (ConjugateRhs) b_tmp = rhs.conjugate(); else b_tmp = rhs; \
+   b = b_tmp.data(); \
+   ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+\
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (LhsStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   Map<const MatrixLhs, 0, OuterStride<> > lhs(_lhs,rows,depth,OuterStride<>(lhsStride)); \
+   MatrixLhs a_tmp; \
+\
+   if ((conjA!=0) || (SetDiag==0)) { \
+     if (conjA) a_tmp = lhs.conjugate(); else a_tmp = lhs; \
+     if (IsZeroDiag) \
+       a_tmp.diagonal().setZero(); \
+     else if (IsUnitDiag) \
+       a_tmp.diagonal().setOnes();\
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _lhs; \
+     lda = convert_index<BlasIndex>(lhsStride); \
+   } \
+   /*std::cout << "TRMM_L: A is square! Go to BLAS TRMM implementation! \n";*/ \
+/* call ?trmm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)b, &ldb); \
+\
+/* Add op(a_triangular)*b into res*/ \
+   Map<MatrixX##EIGPREFIX, 0, OuterStride<> > res_tmp(res,rows,cols,OuterStride<>(resStride)); \
+   res_tmp=res_tmp+b_tmp; \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMM_L(double, double, d, dtrmm)
+EIGEN_BLAS_TRMM_L(dcomplex, MKL_Complex16, cd, ztrmm)
+EIGEN_BLAS_TRMM_L(float, float, f, strmm)
+EIGEN_BLAS_TRMM_L(scomplex, MKL_Complex8, cf, ctrmm)
+#else
+EIGEN_BLAS_TRMM_L(double, double, d, dtrmm_)
+EIGEN_BLAS_TRMM_L(dcomplex, double, cd, ztrmm_)
+EIGEN_BLAS_TRMM_L(float, float, f, strmm_)
+EIGEN_BLAS_TRMM_L(scomplex, float, cf, ctrmm_)
+#endif
+
+// implements col-major += alpha * op(general) * op(triangular)
+#define EIGEN_BLAS_TRMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, int Mode, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_triangular_matrix_matrix_trmm<EIGTYPE,Index,Mode,false, \
+         LhsStorageOrder,ConjugateLhs,RhsStorageOrder,ConjugateRhs,ColMajor> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = ((RhsStorageOrder==ColMajor) && ConjugateRhs) ? 1 : 0 \
+  }; \
+\
+  static void run( \
+    Index _rows, Index _cols, Index _depth, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE,EIGTYPE>& blocking) \
+  { \
+   Index diagSize  = (std::min)(_cols,_depth); \
+   Index rows      = _rows; \
+   Index depth     = IsLower ? _depth : diagSize; \
+   Index cols      = IsLower ? diagSize : _cols; \
+\
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> MatrixLhs; \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs; \
+\
+/* Non-square case - doesn't fit to BLAS ?TRMM. Fall to default triangular product or call BLAS ?GEMM*/ \
+   if (cols != depth) { \
+\
+     int nthr = 1 /*mkl_domain_get_max_threads(EIGEN_BLAS_DOMAIN_BLAS)*/; \
+\
+     if ((nthr==1) && (((std::max)(cols,depth)-diagSize)/(double)diagSize < 0.5)) { \
+     /* Most likely no benefit to call TRMM or GEMM from BLAS*/ \
+       product_triangular_matrix_matrix<EIGTYPE,Index,Mode,false, \
+       LhsStorageOrder,ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, 1, BuiltIn>::run( \
+           _rows, _cols, _depth, _lhs, lhsStride, _rhs, rhsStride, res, 1, resStride, alpha, blocking); \
+       /*std::cout << "TRMM_R: A is not square! Go to Eigen TRMM implementation!\n";*/ \
+     } else { \
+     /* Make sense to call GEMM */ \
+       Map<const MatrixRhs, 0, OuterStride<> > rhsMap(_rhs,depth,cols, OuterStride<>(rhsStride)); \
+       MatrixRhs aa_tmp=rhsMap.template triangularView<Mode>(); \
+       BlasIndex aStride = convert_index<BlasIndex>(aa_tmp.outerStride()); \
+       gemm_blocking_space<ColMajor,EIGTYPE,EIGTYPE,Dynamic,Dynamic,Dynamic> gemm_blocking(_rows,_cols,_depth, 1, true); \
+       general_matrix_matrix_product<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,RhsStorageOrder,ConjugateRhs,ColMajor,1>::run( \
+       rows, cols, depth, _lhs, lhsStride, aa_tmp.data(), aStride, res, 1, resStride, alpha, gemm_blocking, 0); \
+\
+     /*std::cout << "TRMM_R: A is not square! Go to BLAS GEMM implementation! " << nthr<<" \n";*/ \
+     } \
+     return; \
+   } \
+   char side = 'R', transa, uplo, diag = 'N'; \
+   EIGTYPE *b; \
+   const EIGTYPE *a; \
+   BlasIndex m, n, lda, ldb; \
+\
+/* Set m, n */ \
+   m = convert_index<BlasIndex>(rows); \
+   n = convert_index<BlasIndex>(diagSize); \
+\
+/* Set trans */ \
+   transa = (RhsStorageOrder==RowMajor) ? ((ConjugateRhs) ? 'C' : 'T') : 'N'; \
+\
+/* Set b, ldb */ \
+   Map<const MatrixLhs, 0, OuterStride<> > lhs(_lhs,rows,depth,OuterStride<>(lhsStride)); \
+   MatrixX##EIGPREFIX b_tmp; \
+\
+   if (ConjugateLhs) b_tmp = lhs.conjugate(); else b_tmp = lhs; \
+   b = b_tmp.data(); \
+   ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+\
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (RhsStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   Map<const MatrixRhs, 0, OuterStride<> > rhs(_rhs,depth,cols, OuterStride<>(rhsStride)); \
+   MatrixRhs a_tmp; \
+\
+   if ((conjA!=0) || (SetDiag==0)) { \
+     if (conjA) a_tmp = rhs.conjugate(); else a_tmp = rhs; \
+     if (IsZeroDiag) \
+       a_tmp.diagonal().setZero(); \
+     else if (IsUnitDiag) \
+       a_tmp.diagonal().setOnes();\
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _rhs; \
+     lda = convert_index<BlasIndex>(rhsStride); \
+   } \
+   /*std::cout << "TRMM_R: A is square! Go to BLAS TRMM implementation! \n";*/ \
+/* call ?trmm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)b, &ldb); \
+\
+/* Add op(a_triangular)*b into res*/ \
+   Map<MatrixX##EIGPREFIX, 0, OuterStride<> > res_tmp(res,rows,cols,OuterStride<>(resStride)); \
+   res_tmp=res_tmp+b_tmp; \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMM_R(double, double, d, dtrmm)
+EIGEN_BLAS_TRMM_R(dcomplex, MKL_Complex16, cd, ztrmm)
+EIGEN_BLAS_TRMM_R(float, float, f, strmm)
+EIGEN_BLAS_TRMM_R(scomplex, MKL_Complex8, cf, ctrmm)
+#else
+EIGEN_BLAS_TRMM_R(double, double, d, dtrmm_)
+EIGEN_BLAS_TRMM_R(dcomplex, double, cd, ztrmm_)
+EIGEN_BLAS_TRMM_R(float, float, f, strmm_)
+EIGEN_BLAS_TRMM_R(scomplex, float, cf, ctrmm_)
+#endif
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixVector.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixVector.h
new file mode 100644
index 00000000..76bfa159
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -0,0 +1,350 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULARMATRIXVECTOR_H
+#define EIGEN_TRIANGULARMATRIXVECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder, int Version=Specialized>
+struct triangular_matrix_vector_product;
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>
+struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,ColMajor,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  enum {
+    IsLower = ((Mode&Lower)==Lower),
+    HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
+    HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
+  };
+  static EIGEN_DONT_INLINE  void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+                                     const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const RhsScalar& alpha);
+};
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>
+EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,ColMajor,Version>
+  ::run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+        const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const RhsScalar& alpha)
+  {
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+    Index size = (std::min)(_rows,_cols);
+    Index rows = IsLower ? _rows : (std::min)(_rows,_cols);
+    Index cols = IsLower ? (std::min)(_rows,_cols) : _cols;
+
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,ColMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,rows,cols,OuterStride<>(lhsStride));
+    typename conj_expr_if<ConjLhs,LhsMap>::type cjLhs(lhs);
+
+    typedef Map<const Matrix<RhsScalar,Dynamic,1>, 0, InnerStride<> > RhsMap;
+    const RhsMap rhs(_rhs,cols,InnerStride<>(rhsIncr));
+    typename conj_expr_if<ConjRhs,RhsMap>::type cjRhs(rhs);
+
+    typedef Map<Matrix<ResScalar,Dynamic,1> > ResMap;
+    ResMap res(_res,rows);
+
+    typedef const_blas_data_mapper<LhsScalar,Index,ColMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,RowMajor> RhsMapper;
+
+    for (Index pi=0; pi<size; pi+=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(PanelWidth, size-pi);
+      for (Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = pi + k;
+        Index s = IsLower ? ((HasUnitDiag||HasZeroDiag) ? i+1 : i ) : pi;
+        Index r = IsLower ? actualPanelWidth-k : k+1;
+        if ((!(HasUnitDiag||HasZeroDiag)) || (--r)>0)
+          res.segment(s,r) += (alpha * cjRhs.coeff(i)) * cjLhs.col(i).segment(s,r);
+        if (HasUnitDiag)
+          res.coeffRef(i) += alpha * cjRhs.coeff(i);
+      }
+      Index r = IsLower ? rows - pi - actualPanelWidth : pi;
+      if (r>0)
+      {
+        Index s = IsLower ? pi+actualPanelWidth : 0;
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs,BuiltIn>::run(
+            r, actualPanelWidth,
+            LhsMapper(&lhs.coeffRef(s,pi), lhsStride),
+            RhsMapper(&rhs.coeffRef(pi), rhsIncr),
+            &res.coeffRef(s), resIncr, alpha);
+      }
+    }
+    if((!IsLower) && cols>size)
+    {
+      general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs>::run(
+          rows, cols-size,
+          LhsMapper(&lhs.coeffRef(0,size), lhsStride),
+          RhsMapper(&rhs.coeffRef(size), rhsIncr),
+          _res, resIncr, alpha);
+    }
+  }
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs,int Version>
+struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,RowMajor,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  enum {
+    IsLower = ((Mode&Lower)==Lower),
+    HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
+    HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
+  };
+  static EIGEN_DONT_INLINE void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+                                    const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const ResScalar& alpha);
+};
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs,int Version>
+EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,RowMajor,Version>
+  ::run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+        const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const ResScalar& alpha)
+  {
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+    Index diagSize = (std::min)(_rows,_cols);
+    Index rows = IsLower ? _rows : diagSize;
+    Index cols = IsLower ? diagSize : _cols;
+
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,rows,cols,OuterStride<>(lhsStride));
+    typename conj_expr_if<ConjLhs,LhsMap>::type cjLhs(lhs);
+
+    typedef Map<const Matrix<RhsScalar,Dynamic,1> > RhsMap;
+    const RhsMap rhs(_rhs,cols);
+    typename conj_expr_if<ConjRhs,RhsMap>::type cjRhs(rhs);
+
+    typedef Map<Matrix<ResScalar,Dynamic,1>, 0, InnerStride<> > ResMap;
+    ResMap res(_res,rows,InnerStride<>(resIncr));
+
+    typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,RowMajor> RhsMapper;
+
+    for (Index pi=0; pi<diagSize; pi+=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(PanelWidth, diagSize-pi);
+      for (Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = pi + k;
+        Index s = IsLower ? pi  : ((HasUnitDiag||HasZeroDiag) ? i+1 : i);
+        Index r = IsLower ? k+1 : actualPanelWidth-k;
+        if ((!(HasUnitDiag||HasZeroDiag)) || (--r)>0)
+          res.coeffRef(i) += alpha * (cjLhs.row(i).segment(s,r).cwiseProduct(cjRhs.segment(s,r).transpose())).sum();
+        if (HasUnitDiag)
+          res.coeffRef(i) += alpha * cjRhs.coeff(i);
+      }
+      Index r = IsLower ? pi : cols - pi - actualPanelWidth;
+      if (r>0)
+      {
+        Index s = IsLower ? 0 : pi + actualPanelWidth;
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs,BuiltIn>::run(
+            actualPanelWidth, r,
+            LhsMapper(&lhs.coeffRef(pi,s), lhsStride),
+            RhsMapper(&rhs.coeffRef(s), rhsIncr),
+            &res.coeffRef(pi), resIncr, alpha);
+      }
+    }
+    if(IsLower && rows>diagSize)
+    {
+      general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs>::run(
+            rows-diagSize, cols,
+            LhsMapper(&lhs.coeffRef(diagSize,0), lhsStride),
+            RhsMapper(&rhs.coeffRef(0), rhsIncr),
+            &res.coeffRef(diagSize), resIncr, alpha);
+    }
+  }
+
+/***************************************************************************
+* Wrapper to product_triangular_vector
+***************************************************************************/
+
+template<int Mode,int StorageOrder>
+struct trmv_selector;
+
+} // end namespace internal
+
+namespace internal {
+
+template<int Mode, typename Lhs, typename Rhs>
+struct triangular_product_impl<Mode,true,Lhs,false,Rhs,true>
+{
+  template<typename Dest> static void run(Dest& dst, const Lhs &lhs, const Rhs &rhs, const typename Dest::Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==lhs.rows() && dst.cols()==rhs.cols());
+  
+    internal::trmv_selector<Mode,(int(internal::traits<Lhs>::Flags)&RowMajorBit) ? RowMajor : ColMajor>::run(lhs, rhs, dst, alpha);
+  }
+};
+
+template<int Mode, typename Lhs, typename Rhs>
+struct triangular_product_impl<Mode,false,Lhs,true,Rhs,false>
+{
+  template<typename Dest> static void run(Dest& dst, const Lhs &lhs, const Rhs &rhs, const typename Dest::Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==lhs.rows() && dst.cols()==rhs.cols());
+
+    Transpose<Dest> dstT(dst);
+    internal::trmv_selector<(Mode & (UnitDiag|ZeroDiag)) | ((Mode & Lower) ? Upper : Lower),
+                            (int(internal::traits<Rhs>::Flags)&RowMajorBit) ? ColMajor : RowMajor>
+            ::run(rhs.transpose(),lhs.transpose(), dstT, alpha);
+  }
+};
+
+} // end namespace internal
+
+namespace internal {
+
+// TODO: find a way to factorize this piece of code with gemv_selector since the logic is exactly the same.
+  
+template<int Mode> struct trmv_selector<Mode,ColMajor>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar      LhsScalar;
+    typedef typename Rhs::Scalar      RhsScalar;
+    typedef typename Dest::Scalar     ResScalar;
+    typedef typename Dest::RealScalar RealScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    
+    typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest;
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
+
+    LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
+    RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
+    ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+
+    enum {
+      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
+      // on, the other hand it is good for the cache to pack the vector anyways...
+      EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime==1,
+      ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex),
+      MightCannotUseDest = (Dest::InnerStrideAtCompileTime!=1) || ComplexByReal
+    };
+
+    gemv_static_vector_if<ResScalar,Dest::SizeAtCompileTime,Dest::MaxSizeAtCompileTime,MightCannotUseDest> static_dest;
+
+    bool alphaIsCompatible = (!ComplexByReal) || (numext::imag(actualAlpha)==RealScalar(0));
+    bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
+
+    RhsScalar compatibleAlpha = get_factor<ResScalar,RhsScalar>::run(actualAlpha);
+
+    ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(),
+                                                  evalToDest ? dest.data() : static_dest.data());
+
+    if(!evalToDest)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = dest.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      if(!alphaIsCompatible)
+      {
+        MappedDest(actualDestPtr, dest.size()).setZero();
+        compatibleAlpha = RhsScalar(1);
+      }
+      else
+        MappedDest(actualDestPtr, dest.size()) = dest;
+    }
+
+    internal::triangular_matrix_vector_product
+      <Index,Mode,
+       LhsScalar, LhsBlasTraits::NeedToConjugate,
+       RhsScalar, RhsBlasTraits::NeedToConjugate,
+       ColMajor>
+      ::run(actualLhs.rows(),actualLhs.cols(),
+            actualLhs.data(),actualLhs.outerStride(),
+            actualRhs.data(),actualRhs.innerStride(),
+            actualDestPtr,1,compatibleAlpha);
+
+    if (!evalToDest)
+    {
+      if(!alphaIsCompatible)
+        dest += actualAlpha * MappedDest(actualDestPtr, dest.size());
+      else
+        dest = MappedDest(actualDestPtr, dest.size());
+    }
+
+    if ( ((Mode&UnitDiag)==UnitDiag) && (lhs_alpha!=LhsScalar(1)) )
+    {
+      Index diagSize = (std::min)(lhs.rows(),lhs.cols());
+      dest.head(diagSize) -= (lhs_alpha-LhsScalar(1))*rhs.head(diagSize);
+    }
+  }
+};
+
+template<int Mode> struct trmv_selector<Mode,RowMajor>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar      LhsScalar;
+    typedef typename Rhs::Scalar      RhsScalar;
+    typedef typename Dest::Scalar     ResScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+    typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
+    typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
+
+    LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
+    RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
+    ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+
+    enum {
+      DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1
+    };
+
+    gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;
+
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
+        DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
+
+    if(!DirectlyUseRhs)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = actualRhs.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    }
+
+    internal::triangular_matrix_vector_product
+      <Index,Mode,
+       LhsScalar, LhsBlasTraits::NeedToConjugate,
+       RhsScalar, RhsBlasTraits::NeedToConjugate,
+       RowMajor>
+      ::run(actualLhs.rows(),actualLhs.cols(),
+            actualLhs.data(),actualLhs.outerStride(),
+            actualRhsPtr,1,
+            dest.data(),dest.innerStride(),
+            actualAlpha);
+
+    if ( ((Mode&UnitDiag)==UnitDiag) && (lhs_alpha!=LhsScalar(1)) )
+    {
+      Index diagSize = (std::min)(lhs.rows(),lhs.cols());
+      dest.head(diagSize) -= (lhs_alpha-LhsScalar(1))*rhs.head(diagSize);
+    }
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULARMATRIXVECTOR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
new file mode 100644
index 00000000..3d47a2b9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
@@ -0,0 +1,255 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Triangular matrix-vector product functionality based on ?TRMV.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
+#define EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements triangular matrix-vector multiplication using BLAS
+**********************************************************************/
+
+// trmv/hemv specialization
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder>
+struct triangular_matrix_vector_product_trmv :
+  triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,StorageOrder,BuiltIn> {};
+
+#define EIGEN_BLAS_TRMV_SPECIALIZE(Scalar) \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,ColMajor,Specialized> { \
+ static void run(Index _rows, Index _cols, const Scalar* _lhs, Index lhsStride, \
+                                     const Scalar* _rhs, Index rhsIncr, Scalar* _res, Index resIncr, Scalar alpha) { \
+      triangular_matrix_vector_product_trmv<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,ColMajor>::run( \
+        _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+  } \
+}; \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,RowMajor,Specialized> { \
+ static void run(Index _rows, Index _cols, const Scalar* _lhs, Index lhsStride, \
+                                     const Scalar* _rhs, Index rhsIncr, Scalar* _res, Index resIncr, Scalar alpha) { \
+      triangular_matrix_vector_product_trmv<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,RowMajor>::run( \
+        _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+  } \
+};
+
+EIGEN_BLAS_TRMV_SPECIALIZE(double)
+EIGEN_BLAS_TRMV_SPECIALIZE(float)
+EIGEN_BLAS_TRMV_SPECIALIZE(dcomplex)
+EIGEN_BLAS_TRMV_SPECIALIZE(scomplex)
+
+// implements col-major: res += alpha * op(triangular) * vector
+#define EIGEN_BLAS_TRMV_CM(EIGTYPE, BLASTYPE, EIGPREFIX, BLASPREFIX, BLASPOSTFIX) \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product_trmv<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,ColMajor> { \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper \
+  }; \
+ static void run(Index _rows, Index _cols, const EIGTYPE* _lhs, Index lhsStride, \
+                 const EIGTYPE* _rhs, Index rhsIncr, EIGTYPE* _res, Index resIncr, EIGTYPE alpha) \
+ { \
+   if (ConjLhs || IsZeroDiag) { \
+     triangular_matrix_vector_product<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,ColMajor,BuiltIn>::run( \
+       _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+     return; \
+   }\
+   Index size = (std::min)(_rows,_cols); \
+   Index rows = IsLower ? _rows : size; \
+   Index cols = IsLower ? size : _cols; \
+\
+   typedef VectorX##EIGPREFIX VectorRhs; \
+   EIGTYPE *x, *y;\
+\
+/* Set x*/ \
+   Map<const VectorRhs, 0, InnerStride<> > rhs(_rhs,cols,InnerStride<>(rhsIncr)); \
+   VectorRhs x_tmp; \
+   if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+   x = x_tmp.data(); \
+\
+/* Square part handling */\
+\
+   char trans, uplo, diag; \
+   BlasIndex m, n, lda, incx, incy; \
+   EIGTYPE const *a; \
+   EIGTYPE beta(1); \
+\
+/* Set m, n */ \
+   n = convert_index<BlasIndex>(size); \
+   lda = convert_index<BlasIndex>(lhsStride); \
+   incx = 1; \
+   incy = convert_index<BlasIndex>(resIncr); \
+\
+/* Set uplo, trans and diag*/ \
+   trans = 'N'; \
+   uplo = IsLower ? 'L' : 'U'; \
+   diag = IsUnitDiag ? 'U' : 'N'; \
+\
+/* call ?TRMV*/ \
+   BLASPREFIX##trmv##BLASPOSTFIX(&uplo, &trans, &diag, &n, (const BLASTYPE*)_lhs, &lda, (BLASTYPE*)x, &incx); \
+\
+/* Add op(a_tr)rhs into res*/ \
+   BLASPREFIX##axpy##BLASPOSTFIX(&n, (const BLASTYPE*)&numext::real_ref(alpha),(const BLASTYPE*)x, &incx, (BLASTYPE*)_res, &incy); \
+/* Non-square case - doesn't fit to BLAS ?TRMV. Fall to default triangular product*/ \
+   if (size<(std::max)(rows,cols)) { \
+     if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+     x = x_tmp.data(); \
+     if (size<rows) { \
+       y = _res + size*resIncr; \
+       a = _lhs + size; \
+       m = convert_index<BlasIndex>(rows-size); \
+       n = convert_index<BlasIndex>(size); \
+     } \
+     else { \
+       x += size; \
+       y = _res; \
+       a = _lhs + size*lda; \
+       m = convert_index<BlasIndex>(size); \
+       n = convert_index<BlasIndex>(cols-size); \
+     } \
+     BLASPREFIX##gemv##BLASPOSTFIX(&trans, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)x, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)y, &incy); \
+   } \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMV_CM(double,   double, d,  d,)
+EIGEN_BLAS_TRMV_CM(dcomplex, MKL_Complex16, cd, z,)
+EIGEN_BLAS_TRMV_CM(float,    float,  f,  s,)
+EIGEN_BLAS_TRMV_CM(scomplex, MKL_Complex8,  cf, c,)
+#else
+EIGEN_BLAS_TRMV_CM(double,   double, d,  d, _)
+EIGEN_BLAS_TRMV_CM(dcomplex, double, cd, z, _)
+EIGEN_BLAS_TRMV_CM(float,    float,  f,  s, _)
+EIGEN_BLAS_TRMV_CM(scomplex, float,  cf, c, _)
+#endif
+
+// implements row-major: res += alpha * op(triangular) * vector
+#define EIGEN_BLAS_TRMV_RM(EIGTYPE, BLASTYPE, EIGPREFIX, BLASPREFIX, BLASPOSTFIX) \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product_trmv<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,RowMajor> { \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper \
+  }; \
+ static void run(Index _rows, Index _cols, const EIGTYPE* _lhs, Index lhsStride, \
+                 const EIGTYPE* _rhs, Index rhsIncr, EIGTYPE* _res, Index resIncr, EIGTYPE alpha) \
+ { \
+   if (IsZeroDiag) { \
+     triangular_matrix_vector_product<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,RowMajor,BuiltIn>::run( \
+       _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+     return; \
+   }\
+   Index size = (std::min)(_rows,_cols); \
+   Index rows = IsLower ? _rows : size; \
+   Index cols = IsLower ? size : _cols; \
+\
+   typedef VectorX##EIGPREFIX VectorRhs; \
+   EIGTYPE *x, *y;\
+\
+/* Set x*/ \
+   Map<const VectorRhs, 0, InnerStride<> > rhs(_rhs,cols,InnerStride<>(rhsIncr)); \
+   VectorRhs x_tmp; \
+   if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+   x = x_tmp.data(); \
+\
+/* Square part handling */\
+\
+   char trans, uplo, diag; \
+   BlasIndex m, n, lda, incx, incy; \
+   EIGTYPE const *a; \
+   EIGTYPE beta(1); \
+\
+/* Set m, n */ \
+   n = convert_index<BlasIndex>(size); \
+   lda = convert_index<BlasIndex>(lhsStride); \
+   incx = 1; \
+   incy = convert_index<BlasIndex>(resIncr); \
+\
+/* Set uplo, trans and diag*/ \
+   trans = ConjLhs ? 'C' : 'T'; \
+   uplo = IsLower ? 'U' : 'L'; \
+   diag = IsUnitDiag ? 'U' : 'N'; \
+\
+/* call ?TRMV*/ \
+   BLASPREFIX##trmv##BLASPOSTFIX(&uplo, &trans, &diag, &n, (const BLASTYPE*)_lhs, &lda, (BLASTYPE*)x, &incx); \
+\
+/* Add op(a_tr)rhs into res*/ \
+   BLASPREFIX##axpy##BLASPOSTFIX(&n, (const BLASTYPE*)&numext::real_ref(alpha),(const BLASTYPE*)x, &incx, (BLASTYPE*)_res, &incy); \
+/* Non-square case - doesn't fit to BLAS ?TRMV. Fall to default triangular product*/ \
+   if (size<(std::max)(rows,cols)) { \
+     if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+     x = x_tmp.data(); \
+     if (size<rows) { \
+       y = _res + size*resIncr; \
+       a = _lhs + size*lda; \
+       m = convert_index<BlasIndex>(rows-size); \
+       n = convert_index<BlasIndex>(size); \
+     } \
+     else { \
+       x += size; \
+       y = _res; \
+       a = _lhs + size; \
+       m = convert_index<BlasIndex>(size); \
+       n = convert_index<BlasIndex>(cols-size); \
+     } \
+     BLASPREFIX##gemv##BLASPOSTFIX(&trans, &n, &m, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)x, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)y, &incy); \
+   } \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMV_RM(double,   double, d,  d,)
+EIGEN_BLAS_TRMV_RM(dcomplex, MKL_Complex16, cd, z,)
+EIGEN_BLAS_TRMV_RM(float,    float,  f,  s,)
+EIGEN_BLAS_TRMV_RM(scomplex, MKL_Complex8,  cf, c,)
+#else
+EIGEN_BLAS_TRMV_RM(double,   double, d,  d,_)
+EIGEN_BLAS_TRMV_RM(dcomplex, double, cd, z,_)
+EIGEN_BLAS_TRMV_RM(float,    float,  f,  s,_)
+EIGEN_BLAS_TRMV_RM(scomplex, float,  cf, c,_)
+#endif
+
+} // end namespase internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularSolverMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularSolverMatrix.h
new file mode 100644
index 00000000..6d879ba0
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularSolverMatrix.h
@@ -0,0 +1,337 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULAR_SOLVER_MATRIX_H
+#define EIGEN_TRIANGULAR_SOLVER_MATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// if the rhs is row major, let's transpose the product
+template <typename Scalar, typename Index, int Side, int Mode, bool Conjugate, int TriStorageOrder, int OtherInnerStride>
+struct triangular_solve_matrix<Scalar,Index,Side,Mode,Conjugate,TriStorageOrder,RowMajor,OtherInnerStride>
+{
+  static void run(
+    Index size, Index cols,
+    const Scalar*  tri, Index triStride,
+    Scalar* _other, Index otherIncr, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking)
+  {
+    triangular_solve_matrix<
+      Scalar, Index, Side==OnTheLeft?OnTheRight:OnTheLeft,
+      (Mode&UnitDiag) | ((Mode&Upper) ? Lower : Upper),
+      NumTraits<Scalar>::IsComplex && Conjugate,
+      TriStorageOrder==RowMajor ? ColMajor : RowMajor, ColMajor, OtherInnerStride>
+      ::run(size, cols, tri, triStride, _other, otherIncr, otherStride, blocking);
+  }
+};
+
+/* Optimized triangular solver with multiple right hand side and the triangular matrix on the left
+ */
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder,int OtherInnerStride>
+struct triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>
+{
+  static EIGEN_DONT_INLINE void run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherIncr, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking);
+};
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder, int OtherInnerStride>
+EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>::run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherIncr, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index cols = otherSize;
+
+    typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
+    typedef blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride> OtherMapper;
+    TriMapper tri(_tri, triStride);
+    OtherMapper other(_other, otherStride, otherIncr);
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+
+    enum {
+      SmallPanelWidth   = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+      IsLower = (Mode&Lower) == Lower
+    };
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(size,blocking.mc());  // cache block size along the M direction
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    conj_if<Conjugate> conj;
+    gebp_kernel<Scalar, Scalar, Index, OtherMapper, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, TriMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, TriStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, OtherMapper, Traits::nr, ColMajor, false, true> pack_rhs;
+
+    // the goal here is to subdivise the Rhs panels such that we keep some cache
+    // coherence when accessing the rhs elements
+    std::ptrdiff_t l1, l2, l3;
+    manage_caching_sizes(GetAction, &l1, &l2, &l3);
+    Index subcols = cols>0 ? l2/(4 * sizeof(Scalar) * std::max<Index>(otherStride,size)) : 0;
+    subcols = std::max<Index>((subcols/Traits::nr)*Traits::nr, Traits::nr);
+
+    for(Index k2=IsLower ? 0 : size;
+        IsLower ? k2<size : k2>0;
+        IsLower ? k2+=kc : k2-=kc)
+    {
+      const Index actual_kc = (std::min)(IsLower ? size-k2 : k2, kc);
+
+      // We have selected and packed a big horizontal panel R1 of rhs. Let B be the packed copy of this panel,
+      // and R2 the remaining part of rhs. The corresponding vertical panel of lhs is split into
+      // A11 (the triangular part) and A21 the remaining rectangular part.
+      // Then the high level algorithm is:
+      //  - B = R1                    => general block copy (done during the next step)
+      //  - R1 = A11^-1 B             => tricky part
+      //  - update B from the new R1  => actually this has to be performed continuously during the above step
+      //  - R2 -= A21 * B             => GEPP
+
+      // The tricky part: compute R1 = A11^-1 B while updating B from R1
+      // The idea is to split A11 into multiple small vertical panels.
+      // Each panel can be split into a small triangular part T1k which is processed without optimization,
+      // and the remaining small part T2k which is processed using gebp with appropriate block strides
+      for(Index j2=0; j2<cols; j2+=subcols)
+      {
+        Index actual_cols = (std::min)(cols-j2,subcols);
+        // for each small vertical panels [T1k^T, T2k^T]^T of lhs
+        for (Index k1=0; k1<actual_kc; k1+=SmallPanelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-k1, SmallPanelWidth);
+          // tr solve
+          for (Index k=0; k<actualPanelWidth; ++k)
+          {
+            // TODO write a small kernel handling this (can be shared with trsv)
+            Index i  = IsLower ? k2+k1+k : k2-k1-k-1;
+            Index rs = actualPanelWidth - k - 1; // remaining size
+            Index s  = TriStorageOrder==RowMajor ? (IsLower ? k2+k1 : i+1)
+                                                 :  IsLower ? i+1 : i-rs;
+
+            Scalar a = (Mode & UnitDiag) ? Scalar(1) : Scalar(1)/conj(tri(i,i));
+            for (Index j=j2; j<j2+actual_cols; ++j)
+            {
+              if (TriStorageOrder==RowMajor)
+              {
+                Scalar b(0);
+                const Scalar* l = &tri(i,s);
+                typename OtherMapper::LinearMapper r = other.getLinearMapper(s,j);
+                for (Index i3=0; i3<k; ++i3)
+                  b += conj(l[i3]) * r(i3);
+
+                other(i,j) = (other(i,j) - b)*a;
+              }
+              else
+              {
+                Scalar& otherij = other(i,j);
+                otherij *= a;
+                Scalar b = otherij;
+                typename OtherMapper::LinearMapper r = other.getLinearMapper(s,j);
+                typename TriMapper::LinearMapper l = tri.getLinearMapper(s,i);
+                for (Index i3=0;i3<rs;++i3)
+                  r(i3) -= b * conj(l(i3));
+              }
+            }
+          }
+
+          Index lengthTarget = actual_kc-k1-actualPanelWidth;
+          Index startBlock   = IsLower ? k2+k1 : k2-k1-actualPanelWidth;
+          Index blockBOffset = IsLower ? k1 : lengthTarget;
+
+          // update the respective rows of B from other
+          pack_rhs(blockB+actual_kc*j2, other.getSubMapper(startBlock,j2), actualPanelWidth, actual_cols, actual_kc, blockBOffset);
+
+          // GEBP
+          if (lengthTarget>0)
+          {
+            Index startTarget  = IsLower ? k2+k1+actualPanelWidth : k2-actual_kc;
+
+            pack_lhs(blockA, tri.getSubMapper(startTarget,startBlock), actualPanelWidth, lengthTarget);
+
+            gebp_kernel(other.getSubMapper(startTarget,j2), blockA, blockB+actual_kc*j2, lengthTarget, actualPanelWidth, actual_cols, Scalar(-1),
+                        actualPanelWidth, actual_kc, 0, blockBOffset);
+          }
+        }
+      }
+      
+      // R2 -= A21 * B => GEPP
+      {
+        Index start = IsLower ? k2+kc : 0;
+        Index end   = IsLower ? size : k2-kc;
+        for(Index i2=start; i2<end; i2+=mc)
+        {
+          const Index actual_mc = (std::min)(mc,end-i2);
+          if (actual_mc>0)
+          {
+            pack_lhs(blockA, tri.getSubMapper(i2, IsLower ? k2 : k2-kc), actual_kc, actual_mc);
+
+            gebp_kernel(other.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0, 0);
+          }
+        }
+      }
+    }
+  }
+
+/* Optimized triangular solver with multiple left hand sides and the triangular matrix on the right
+ */
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder, int OtherInnerStride>
+struct triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>
+{
+  static EIGEN_DONT_INLINE void run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherIncr, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking);
+};
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder, int OtherInnerStride>
+EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>::run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherIncr, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index rows = otherSize;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    typedef blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> RhsMapper;
+    LhsMapper lhs(_other, otherStride, otherIncr);
+    RhsMapper rhs(_tri, triStride);
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+    enum {
+      RhsStorageOrder   = TriStorageOrder,
+      SmallPanelWidth   = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+      IsLower = (Mode&Lower) == Lower
+    };
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*size;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    conj_if<Conjugate> conj;
+    gebp_kernel<Scalar, Scalar, Index, LhsMapper, Traits::mr, Traits::nr, false, Conjugate> gebp_kernel;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr, RhsStorageOrder,false,true> pack_rhs_panel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, ColMajor, false, true> pack_lhs_panel;
+
+    for(Index k2=IsLower ? size : 0;
+        IsLower ? k2>0 : k2<size;
+        IsLower ? k2-=kc : k2+=kc)
+    {
+      const Index actual_kc = (std::min)(IsLower ? k2 : size-k2, kc);
+      Index actual_k2 = IsLower ? k2-actual_kc : k2 ;
+
+      Index startPanel = IsLower ? 0 : k2+actual_kc;
+      Index rs = IsLower ? actual_k2 : size - actual_k2 - actual_kc;
+      Scalar* geb = blockB+actual_kc*actual_kc;
+
+      if (rs>0) pack_rhs(geb, rhs.getSubMapper(actual_k2,startPanel), actual_kc, rs);
+
+      // triangular packing (we only pack the panels off the diagonal,
+      // neglecting the blocks overlapping the diagonal
+      {
+        for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+          Index actual_j2 = actual_k2 + j2;
+          Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
+          Index panelLength = IsLower ? actual_kc-j2-actualPanelWidth : j2;
+
+          if (panelLength>0)
+          pack_rhs_panel(blockB+j2*actual_kc,
+                         rhs.getSubMapper(actual_k2+panelOffset, actual_j2),
+                         panelLength, actualPanelWidth,
+                         actual_kc, panelOffset);
+        }
+      }
+
+      for(Index i2=0; i2<rows; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(mc,rows-i2);
+
+        // triangular solver kernel
+        {
+          // for each small block of the diagonal (=> vertical panels of rhs)
+          for (Index j2 = IsLower
+                      ? (actual_kc - ((actual_kc%SmallPanelWidth) ? Index(actual_kc%SmallPanelWidth)
+                                                                  : Index(SmallPanelWidth)))
+                      : 0;
+               IsLower ? j2>=0 : j2<actual_kc;
+               IsLower ? j2-=SmallPanelWidth : j2+=SmallPanelWidth)
+          {
+            Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+            Index absolute_j2 = actual_k2 + j2;
+            Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
+            Index panelLength = IsLower ? actual_kc - j2 - actualPanelWidth : j2;
+
+            // GEBP
+            if(panelLength>0)
+            {
+              gebp_kernel(lhs.getSubMapper(i2,absolute_j2),
+                          blockA, blockB+j2*actual_kc,
+                          actual_mc, panelLength, actualPanelWidth,
+                          Scalar(-1),
+                          actual_kc, actual_kc, // strides
+                          panelOffset, panelOffset); // offsets
+            }
+
+            // unblocked triangular solve
+            for (Index k=0; k<actualPanelWidth; ++k)
+            {
+              Index j = IsLower ? absolute_j2+actualPanelWidth-k-1 : absolute_j2+k;
+
+              typename LhsMapper::LinearMapper r = lhs.getLinearMapper(i2,j);
+              for (Index k3=0; k3<k; ++k3)
+              {
+                Scalar b = conj(rhs(IsLower ? j+1+k3 : absolute_j2+k3,j));
+                typename LhsMapper::LinearMapper a = lhs.getLinearMapper(i2,IsLower ? j+1+k3 : absolute_j2+k3);
+                for (Index i=0; i<actual_mc; ++i)
+                  r(i) -= a(i) * b;
+              }
+              if((Mode & UnitDiag)==0)
+              {
+                Scalar inv_rjj = RealScalar(1)/conj(rhs(j,j));
+                for (Index i=0; i<actual_mc; ++i)
+                  r(i) *= inv_rjj;
+              }
+            }
+
+            // pack the just computed part of lhs to A
+            pack_lhs_panel(blockA, lhs.getSubMapper(i2,absolute_j2),
+                           actualPanelWidth, actual_mc,
+                           actual_kc, j2);
+          }
+        }
+
+        if (rs>0)
+          gebp_kernel(lhs.getSubMapper(i2, startPanel), blockA, geb,
+                      actual_mc, actual_kc, rs, Scalar(-1),
+                      -1, -1, 0, 0);
+      }
+    }
+  }
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_SOLVER_MATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
new file mode 100644
index 00000000..621194ce
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
@@ -0,0 +1,167 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Triangular matrix * matrix product functionality based on ?TRMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
+#define EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
+
+namespace Eigen {
+
+namespace internal {
+
+// implements LeftSide op(triangular)^-1 * general
+#define EIGEN_BLAS_TRSM_L(EIGTYPE, BLASTYPE, BLASFUNC) \
+template <typename Index, int Mode, bool Conjugate, int TriStorageOrder> \
+struct triangular_solve_matrix<EIGTYPE,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor,1> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    conjA = ((TriStorageOrder==ColMajor) && Conjugate) ? 1 : 0 \
+  }; \
+  static void run( \
+      Index size, Index otherSize, \
+      const EIGTYPE* _tri, Index triStride, \
+      EIGTYPE* _other, Index otherIncr, Index otherStride, level3_blocking<EIGTYPE,EIGTYPE>& /*blocking*/) \
+  { \
+   EIGEN_ONLY_USED_FOR_DEBUG(otherIncr); \
+   eigen_assert(otherIncr == 1); \
+   BlasIndex m = convert_index<BlasIndex>(size), n = convert_index<BlasIndex>(otherSize), lda, ldb; \
+   char side = 'L', uplo, diag='N', transa; \
+   /* Set alpha_ */ \
+   EIGTYPE alpha(1); \
+   ldb = convert_index<BlasIndex>(otherStride);\
+\
+   const EIGTYPE *a; \
+/* Set trans */ \
+   transa = (TriStorageOrder==RowMajor) ? ((Conjugate) ? 'C' : 'T') : 'N'; \
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (TriStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, TriStorageOrder> MatrixTri; \
+   Map<const MatrixTri, 0, OuterStride<> > tri(_tri,size,size,OuterStride<>(triStride)); \
+   MatrixTri a_tmp; \
+\
+   if (conjA) { \
+     a_tmp = tri.conjugate(); \
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _tri; \
+     lda = convert_index<BlasIndex>(triStride); \
+   } \
+   if (IsUnitDiag) diag='U'; \
+/* call ?trsm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)_other, &ldb); \
+ } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRSM_L(double,   double, dtrsm)
+EIGEN_BLAS_TRSM_L(dcomplex, MKL_Complex16, ztrsm)
+EIGEN_BLAS_TRSM_L(float,    float,  strsm)
+EIGEN_BLAS_TRSM_L(scomplex, MKL_Complex8, ctrsm)
+#else
+EIGEN_BLAS_TRSM_L(double,   double, dtrsm_)
+EIGEN_BLAS_TRSM_L(dcomplex, double, ztrsm_)
+EIGEN_BLAS_TRSM_L(float,    float,  strsm_)
+EIGEN_BLAS_TRSM_L(scomplex, float,  ctrsm_)
+#endif
+
+// implements RightSide general * op(triangular)^-1
+#define EIGEN_BLAS_TRSM_R(EIGTYPE, BLASTYPE, BLASFUNC) \
+template <typename Index, int Mode, bool Conjugate, int TriStorageOrder> \
+struct triangular_solve_matrix<EIGTYPE,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor,1> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    conjA = ((TriStorageOrder==ColMajor) && Conjugate) ? 1 : 0 \
+  }; \
+  static void run( \
+      Index size, Index otherSize, \
+      const EIGTYPE* _tri, Index triStride, \
+      EIGTYPE* _other, Index otherIncr, Index otherStride, level3_blocking<EIGTYPE,EIGTYPE>& /*blocking*/) \
+  { \
+   EIGEN_ONLY_USED_FOR_DEBUG(otherIncr); \
+   eigen_assert(otherIncr == 1); \
+   BlasIndex m = convert_index<BlasIndex>(otherSize), n = convert_index<BlasIndex>(size), lda, ldb; \
+   char side = 'R', uplo, diag='N', transa; \
+   /* Set alpha_ */ \
+   EIGTYPE alpha(1); \
+   ldb = convert_index<BlasIndex>(otherStride);\
+\
+   const EIGTYPE *a; \
+/* Set trans */ \
+   transa = (TriStorageOrder==RowMajor) ? ((Conjugate) ? 'C' : 'T') : 'N'; \
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (TriStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, TriStorageOrder> MatrixTri; \
+   Map<const MatrixTri, 0, OuterStride<> > tri(_tri,size,size,OuterStride<>(triStride)); \
+   MatrixTri a_tmp; \
+\
+   if (conjA) { \
+     a_tmp = tri.conjugate(); \
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _tri; \
+     lda = convert_index<BlasIndex>(triStride); \
+   } \
+   if (IsUnitDiag) diag='U'; \
+/* call ?trsm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)_other, &ldb); \
+   /*std::cout << "TRMS_L specialization!\n";*/ \
+ } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRSM_R(double,   double, dtrsm)
+EIGEN_BLAS_TRSM_R(dcomplex, MKL_Complex16, ztrsm)
+EIGEN_BLAS_TRSM_R(float,    float,  strsm)
+EIGEN_BLAS_TRSM_R(scomplex, MKL_Complex8,  ctrsm)
+#else
+EIGEN_BLAS_TRSM_R(double,   double, dtrsm_)
+EIGEN_BLAS_TRSM_R(dcomplex, double, ztrsm_)
+EIGEN_BLAS_TRSM_R(float,    float,  strsm_)
+EIGEN_BLAS_TRSM_R(scomplex, float,  ctrsm_)
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularSolverVector.h b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularSolverVector.h
new file mode 100644
index 00000000..64731701
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/products/TriangularSolverVector.h
@@ -0,0 +1,148 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULAR_SOLVER_VECTOR_H
+#define EIGEN_TRIANGULAR_SOLVER_VECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename LhsScalar, typename RhsScalar, typename Index, int Mode, bool Conjugate, int StorageOrder>
+struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheRight, Mode, Conjugate, StorageOrder>
+{
+  static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs)
+  {
+    triangular_solve_vector<LhsScalar,RhsScalar,Index,OnTheLeft,
+        ((Mode&Upper)==Upper ? Lower : Upper) | (Mode&UnitDiag),
+        Conjugate,StorageOrder==RowMajor?ColMajor:RowMajor
+      >::run(size, _lhs, lhsStride, rhs);
+  }
+};
+
+// forward and backward substitution, row-major, rhs is a vector
+template<typename LhsScalar, typename RhsScalar, typename Index, int Mode, bool Conjugate>
+struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, RowMajor>
+{
+  enum {
+    IsLower = ((Mode&Lower)==Lower)
+  };
+  static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs)
+  {
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,size,size,OuterStride<>(lhsStride));
+
+    typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
+
+    typename internal::conditional<
+                          Conjugate,
+                          const CwiseUnaryOp<typename internal::scalar_conjugate_op<LhsScalar>,LhsMap>,
+                          const LhsMap&>
+                        ::type cjLhs(lhs);
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+    for(Index pi=IsLower ? 0 : size;
+        IsLower ? pi<size : pi>0;
+        IsLower ? pi+=PanelWidth : pi-=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(IsLower ? size - pi : pi, PanelWidth);
+
+      Index r = IsLower ? pi : size - pi; // remaining size
+      if (r > 0)
+      {
+        // let's directly call the low level product function because:
+        // 1 - it is faster to compile
+        // 2 - it is slightly faster at runtime
+        Index startRow = IsLower ? pi : pi-actualPanelWidth;
+        Index startCol = IsLower ? 0 : pi;
+
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,Conjugate,RhsScalar,RhsMapper,false>::run(
+          actualPanelWidth, r,
+          LhsMapper(&lhs.coeffRef(startRow,startCol), lhsStride),
+          RhsMapper(rhs + startCol, 1),
+          rhs + startRow, 1,
+          RhsScalar(-1));
+      }
+
+      for(Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = IsLower ? pi+k : pi-k-1;
+        Index s = IsLower ? pi   : i+1;
+        if (k>0)
+          rhs[i] -= (cjLhs.row(i).segment(s,k).transpose().cwiseProduct(Map<const Matrix<RhsScalar,Dynamic,1> >(rhs+s,k))).sum();
+
+        if((!(Mode & UnitDiag)) && numext::not_equal_strict(rhs[i],RhsScalar(0)))
+          rhs[i] /= cjLhs(i,i);
+      }
+    }
+  }
+};
+
+// forward and backward substitution, column-major, rhs is a vector
+template<typename LhsScalar, typename RhsScalar, typename Index, int Mode, bool Conjugate>
+struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, ColMajor>
+{
+  enum {
+    IsLower = ((Mode&Lower)==Lower)
+  };
+  static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs)
+  {
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,ColMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,size,size,OuterStride<>(lhsStride));
+    typedef const_blas_data_mapper<LhsScalar,Index,ColMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
+    typename internal::conditional<Conjugate,
+                                   const CwiseUnaryOp<typename internal::scalar_conjugate_op<LhsScalar>,LhsMap>,
+                                   const LhsMap&
+                                  >::type cjLhs(lhs);
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+
+    for(Index pi=IsLower ? 0 : size;
+        IsLower ? pi<size : pi>0;
+        IsLower ? pi+=PanelWidth : pi-=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(IsLower ? size - pi : pi, PanelWidth);
+      Index startBlock = IsLower ? pi : pi-actualPanelWidth;
+      Index endBlock = IsLower ? pi + actualPanelWidth : 0;
+
+      for(Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = IsLower ? pi+k : pi-k-1;
+        if(numext::not_equal_strict(rhs[i],RhsScalar(0)))
+        {
+          if(!(Mode & UnitDiag))
+            rhs[i] /= cjLhs.coeff(i,i);
+
+          Index r = actualPanelWidth - k - 1; // remaining size
+          Index s = IsLower ? i+1 : i-r;
+          if (r>0)
+            Map<Matrix<RhsScalar,Dynamic,1> >(rhs+s,r) -= rhs[i] * cjLhs.col(i).segment(s,r);
+        }
+      }
+      Index r = IsLower ? size - endBlock : startBlock; // remaining size
+      if (r > 0)
+      {
+        // let's directly call the low level product function because:
+        // 1 - it is faster to compile
+        // 2 - it is slightly faster at runtime
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,Conjugate,RhsScalar,RhsMapper,false>::run(
+            r, actualPanelWidth,
+            LhsMapper(&lhs.coeffRef(endBlock,startBlock), lhsStride),
+            RhsMapper(rhs+startBlock, 1),
+            rhs+endBlock, 1, RhsScalar(-1));
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_SOLVER_VECTOR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/BlasUtil.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/BlasUtil.h
new file mode 100644
index 00000000..e16a5649
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/BlasUtil.h
@@ -0,0 +1,583 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BLASUTIL_H
+#define EIGEN_BLASUTIL_H
+
+// This file contains many lightweight helper classes used to
+// implement and control fast level 2 and level 3 BLAS-like routines.
+
+namespace Eigen {
+
+namespace internal {
+
+// forward declarations
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs=false, bool ConjugateRhs=false>
+struct gebp_kernel;
+
+template<typename Scalar, typename Index, typename DataMapper, int nr, int StorageOrder, bool Conjugate = false, bool PanelMode=false>
+struct gemm_pack_rhs;
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, int StorageOrder, bool Conjugate = false, bool PanelMode = false>
+struct gemm_pack_lhs;
+
+template<
+  typename Index,
+  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+  int ResStorageOrder, int ResInnerStride>
+struct general_matrix_matrix_product;
+
+template<typename Index,
+         typename LhsScalar, typename LhsMapper, int LhsStorageOrder, bool ConjugateLhs,
+         typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version=Specialized>
+struct general_matrix_vector_product;
+
+template<typename From,typename To> struct get_factor {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE To run(const From& x) { return To(x); }
+};
+
+template<typename Scalar> struct get_factor<Scalar,typename NumTraits<Scalar>::Real> {
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE typename NumTraits<Scalar>::Real run(const Scalar& x) { return numext::real(x); }
+};
+
+
+template<typename Scalar, typename Index>
+class BlasVectorMapper {
+  public:
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE BlasVectorMapper(Scalar *data) : m_data(data) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar operator()(Index i) const {
+    return m_data[i];
+  }
+  template <typename Packet, int AlignmentType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet load(Index i) const {
+    return ploadt<Packet, AlignmentType>(m_data + i);
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC bool aligned(Index i) const {
+    return (UIntPtr(m_data+i)%sizeof(Packet))==0;
+  }
+
+  protected:
+  Scalar* m_data;
+};
+
+template<typename Scalar, typename Index, int AlignmentType, int Incr=1>
+class BlasLinearMapper;
+
+template<typename Scalar, typename Index, int AlignmentType>
+class BlasLinearMapper<Scalar,Index,AlignmentType>
+{
+public:
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE BlasLinearMapper(Scalar *data, Index incr=1)
+    : m_data(data)
+  {
+    EIGEN_ONLY_USED_FOR_DEBUG(incr);
+    eigen_assert(incr==1);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void prefetch(int i) const {
+    internal::prefetch(&operator()(i));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar& operator()(Index i) const {
+    return m_data[i];
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketType loadPacket(Index i) const {
+    return ploadt<PacketType, AlignmentType>(m_data + i);
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacket(Index i, const PacketType &p) const {
+    pstoret<Scalar, PacketType, AlignmentType>(m_data + i, p);
+  }
+
+protected:
+  Scalar *m_data;
+};
+
+// Lightweight helper class to access matrix coefficients.
+template<typename Scalar, typename Index, int StorageOrder, int AlignmentType = Unaligned, int Incr = 1>
+class blas_data_mapper;
+
+// TMP to help PacketBlock store implementation.
+// There's currently no known use case for PacketBlock load.
+// The default implementation assumes ColMajor order.
+// It always store each packet sequentially one `stride` apart.
+template<typename Index, typename Scalar, typename Packet, int n, int idx, int StorageOrder>
+struct PacketBlockManagement
+{
+  PacketBlockManagement<Index, Scalar, Packet, n, idx - 1, StorageOrder> pbm;
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(Scalar *to, const Index stride, Index i, Index j, const PacketBlock<Packet, n> &block) const {
+    pbm.store(to, stride, i, j, block);
+    pstoreu<Scalar>(to + i + (j + idx)*stride, block.packet[idx]);
+  }
+};
+
+// PacketBlockManagement specialization to take care of RowMajor order without ifs.
+template<typename Index, typename Scalar, typename Packet, int n, int idx>
+struct PacketBlockManagement<Index, Scalar, Packet, n, idx, RowMajor>
+{
+  PacketBlockManagement<Index, Scalar, Packet, n, idx - 1, RowMajor> pbm;
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(Scalar *to, const Index stride, Index i, Index j, const PacketBlock<Packet, n> &block) const {
+    pbm.store(to, stride, i, j, block);
+    pstoreu<Scalar>(to + j + (i + idx)*stride, block.packet[idx]);
+  }
+};
+
+template<typename Index, typename Scalar, typename Packet, int n, int StorageOrder>
+struct PacketBlockManagement<Index, Scalar, Packet, n, -1, StorageOrder>
+{
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(Scalar *to, const Index stride, Index i, Index j, const PacketBlock<Packet, n> &block) const {
+    EIGEN_UNUSED_VARIABLE(to);
+    EIGEN_UNUSED_VARIABLE(stride);
+    EIGEN_UNUSED_VARIABLE(i);
+    EIGEN_UNUSED_VARIABLE(j);
+    EIGEN_UNUSED_VARIABLE(block);
+  }
+};
+
+template<typename Index, typename Scalar, typename Packet, int n>
+struct PacketBlockManagement<Index, Scalar, Packet, n, -1, RowMajor>
+{
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(Scalar *to, const Index stride, Index i, Index j, const PacketBlock<Packet, n> &block) const {
+    EIGEN_UNUSED_VARIABLE(to);
+    EIGEN_UNUSED_VARIABLE(stride);
+    EIGEN_UNUSED_VARIABLE(i);
+    EIGEN_UNUSED_VARIABLE(j);
+    EIGEN_UNUSED_VARIABLE(block);
+  }
+};
+
+template<typename Scalar, typename Index, int StorageOrder, int AlignmentType>
+class blas_data_mapper<Scalar,Index,StorageOrder,AlignmentType,1>
+{
+public:
+  typedef BlasLinearMapper<Scalar, Index, AlignmentType> LinearMapper;
+  typedef BlasVectorMapper<Scalar, Index> VectorMapper;
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE blas_data_mapper(Scalar* data, Index stride, Index incr=1)
+   : m_data(data), m_stride(stride)
+  {
+    EIGEN_ONLY_USED_FOR_DEBUG(incr);
+    eigen_assert(incr==1);
+  }
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType>
+  getSubMapper(Index i, Index j) const {
+    return blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType>(&operator()(i, j), m_stride);
+  }
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE LinearMapper getLinearMapper(Index i, Index j) const {
+    return LinearMapper(&operator()(i, j));
+  }
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE VectorMapper getVectorMapper(Index i, Index j) const {
+    return VectorMapper(&operator()(i, j));
+  }
+
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Scalar& operator()(Index i, Index j) const {
+    return m_data[StorageOrder==RowMajor ? j + i*m_stride : i + j*m_stride];
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketType loadPacket(Index i, Index j) const {
+    return ploadt<PacketType, AlignmentType>(&operator()(i, j));
+  }
+
+  template <typename PacketT, int AlignmentT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT load(Index i, Index j) const {
+    return ploadt<PacketT, AlignmentT>(&operator()(i, j));
+  }
+
+  template<typename SubPacket>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void scatterPacket(Index i, Index j, const SubPacket &p) const {
+    pscatter<Scalar, SubPacket>(&operator()(i, j), p, m_stride);
+  }
+
+  template<typename SubPacket>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE SubPacket gatherPacket(Index i, Index j) const {
+    return pgather<Scalar, SubPacket>(&operator()(i, j), m_stride);
+  }
+
+  EIGEN_DEVICE_FUNC const Index stride() const { return m_stride; }
+  EIGEN_DEVICE_FUNC const Scalar* data() const { return m_data; }
+
+  EIGEN_DEVICE_FUNC Index firstAligned(Index size) const {
+    if (UIntPtr(m_data)%sizeof(Scalar)) {
+      return -1;
+    }
+    return internal::first_default_aligned(m_data, size);
+  }
+
+  template<typename SubPacket, int n>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacketBlock(Index i, Index j, const PacketBlock<SubPacket, n> &block) const {
+    PacketBlockManagement<Index, Scalar, SubPacket, n, n-1, StorageOrder> pbm;
+    pbm.store(m_data, m_stride, i, j, block);
+  }
+protected:
+  Scalar* EIGEN_RESTRICT m_data;
+  const Index m_stride;
+};
+
+// Implementation of non-natural increment (i.e. inner-stride != 1)
+// The exposed API is not complete yet compared to the Incr==1 case
+// because some features makes less sense in this case.
+template<typename Scalar, typename Index, int AlignmentType, int Incr>
+class BlasLinearMapper
+{
+public:
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE BlasLinearMapper(Scalar *data,Index incr) : m_data(data), m_incr(incr) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void prefetch(int i) const {
+    internal::prefetch(&operator()(i));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar& operator()(Index i) const {
+    return m_data[i*m_incr.value()];
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketType loadPacket(Index i) const {
+    return pgather<Scalar,PacketType>(m_data + i*m_incr.value(), m_incr.value());
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacket(Index i, const PacketType &p) const {
+    pscatter<Scalar, PacketType>(m_data + i*m_incr.value(), p, m_incr.value());
+  }
+
+protected:
+  Scalar *m_data;
+  const internal::variable_if_dynamic<Index,Incr> m_incr;
+};
+
+template<typename Scalar, typename Index, int StorageOrder, int AlignmentType,int Incr>
+class blas_data_mapper
+{
+public:
+  typedef BlasLinearMapper<Scalar, Index, AlignmentType,Incr> LinearMapper;
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE blas_data_mapper(Scalar* data, Index stride, Index incr) : m_data(data), m_stride(stride), m_incr(incr) {}
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE blas_data_mapper
+  getSubMapper(Index i, Index j) const {
+    return blas_data_mapper(&operator()(i, j), m_stride, m_incr.value());
+  }
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE LinearMapper getLinearMapper(Index i, Index j) const {
+    return LinearMapper(&operator()(i, j), m_incr.value());
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Scalar& operator()(Index i, Index j) const {
+    return m_data[StorageOrder==RowMajor ? j*m_incr.value() + i*m_stride : i*m_incr.value() + j*m_stride];
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketType loadPacket(Index i, Index j) const {
+    return pgather<Scalar,PacketType>(&operator()(i, j),m_incr.value());
+  }
+
+  template <typename PacketT, int AlignmentT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT load(Index i, Index j) const {
+    return pgather<Scalar,PacketT>(&operator()(i, j),m_incr.value());
+  }
+
+  template<typename SubPacket>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void scatterPacket(Index i, Index j, const SubPacket &p) const {
+    pscatter<Scalar, SubPacket>(&operator()(i, j), p, m_stride);
+  }
+
+  template<typename SubPacket>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE SubPacket gatherPacket(Index i, Index j) const {
+    return pgather<Scalar, SubPacket>(&operator()(i, j), m_stride);
+  }
+
+  // storePacketBlock_helper defines a way to access values inside the PacketBlock, this is essentially required by the Complex types.
+  template<typename SubPacket, typename ScalarT, int n, int idx>
+  struct storePacketBlock_helper
+  {
+    storePacketBlock_helper<SubPacket, ScalarT, n, idx-1> spbh;
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>* sup, Index i, Index j, const PacketBlock<SubPacket, n>& block) const {
+      spbh.store(sup, i,j,block);
+      for(int l = 0; l < unpacket_traits<SubPacket>::size; l++)
+      {
+        ScalarT *v = &sup->operator()(i+l, j+idx);
+        *v = block.packet[idx][l];
+      }
+    }
+  };
+
+  template<typename SubPacket, int n, int idx>
+  struct storePacketBlock_helper<SubPacket, std::complex<float>, n, idx>
+  {
+    storePacketBlock_helper<SubPacket, std::complex<float>, n, idx-1> spbh;
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>* sup, Index i, Index j, const PacketBlock<SubPacket, n>& block) const {
+      spbh.store(sup,i,j,block);
+      for(int l = 0; l < unpacket_traits<SubPacket>::size; l++)
+      {
+        std::complex<float> *v = &sup->operator()(i+l, j+idx);
+        v->real(block.packet[idx].v[2*l+0]);
+        v->imag(block.packet[idx].v[2*l+1]);
+      }
+    }
+  };
+
+  template<typename SubPacket, int n, int idx>
+  struct storePacketBlock_helper<SubPacket, std::complex<double>, n, idx>
+  {
+    storePacketBlock_helper<SubPacket, std::complex<double>, n, idx-1> spbh;
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>* sup, Index i, Index j, const PacketBlock<SubPacket, n>& block) const {
+      spbh.store(sup,i,j,block);
+      for(int l = 0; l < unpacket_traits<SubPacket>::size; l++)
+      {
+        std::complex<double> *v = &sup->operator()(i+l, j+idx);
+        v->real(block.packet[idx].v[2*l+0]);
+        v->imag(block.packet[idx].v[2*l+1]);
+      }
+    }
+  };
+
+  template<typename SubPacket, typename ScalarT, int n>
+  struct storePacketBlock_helper<SubPacket, ScalarT, n, -1>
+  {
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>*, Index, Index, const PacketBlock<SubPacket, n>& ) const {
+    }
+  };
+
+  template<typename SubPacket, int n>
+  struct storePacketBlock_helper<SubPacket, std::complex<float>, n, -1>
+  {
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>*, Index, Index, const PacketBlock<SubPacket, n>& ) const {
+    }
+  };
+
+  template<typename SubPacket, int n>
+  struct storePacketBlock_helper<SubPacket, std::complex<double>, n, -1>
+  {
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>*, Index, Index, const PacketBlock<SubPacket, n>& ) const {
+    }
+  };
+  // This function stores a PacketBlock on m_data, this approach is really quite slow compare to Incr=1 and should be avoided when possible.
+  template<typename SubPacket, int n>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacketBlock(Index i, Index j, const PacketBlock<SubPacket, n>&block) const {
+    storePacketBlock_helper<SubPacket, Scalar, n, n-1> spb;
+    spb.store(this, i,j,block);
+  }
+protected:
+  Scalar* EIGEN_RESTRICT m_data;
+  const Index m_stride;
+  const internal::variable_if_dynamic<Index,Incr> m_incr;
+};
+
+// lightweight helper class to access matrix coefficients (const version)
+template<typename Scalar, typename Index, int StorageOrder>
+class const_blas_data_mapper : public blas_data_mapper<const Scalar, Index, StorageOrder> {
+  public:
+  EIGEN_ALWAYS_INLINE const_blas_data_mapper(const Scalar *data, Index stride) : blas_data_mapper<const Scalar, Index, StorageOrder>(data, stride) {}
+
+  EIGEN_ALWAYS_INLINE const_blas_data_mapper<Scalar, Index, StorageOrder> getSubMapper(Index i, Index j) const {
+    return const_blas_data_mapper<Scalar, Index, StorageOrder>(&(this->operator()(i, j)), this->m_stride);
+  }
+};
+
+
+/* Helper class to analyze the factors of a Product expression.
+ * In particular it allows to pop out operator-, scalar multiples,
+ * and conjugate */
+template<typename XprType> struct blas_traits
+{
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef const XprType& ExtractType;
+  typedef XprType _ExtractType;
+  enum {
+    IsComplex = NumTraits<Scalar>::IsComplex,
+    IsTransposed = false,
+    NeedToConjugate = false,
+    HasUsableDirectAccess = (    (int(XprType::Flags)&DirectAccessBit)
+                              && (   bool(XprType::IsVectorAtCompileTime)
+                                  || int(inner_stride_at_compile_time<XprType>::ret) == 1)
+                             ) ?  1 : 0,
+    HasScalarFactor = false
+  };
+  typedef typename conditional<bool(HasUsableDirectAccess),
+    ExtractType,
+    typename _ExtractType::PlainObject
+    >::type DirectLinearAccessType;
+  static inline EIGEN_DEVICE_FUNC ExtractType extract(const XprType& x) { return x; }
+  static inline EIGEN_DEVICE_FUNC const Scalar extractScalarFactor(const XprType&) { return Scalar(1); }
+};
+
+// pop conjugate
+template<typename Scalar, typename NestedXpr>
+struct blas_traits<CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> XprType;
+  typedef typename Base::ExtractType ExtractType;
+
+  enum {
+    IsComplex = NumTraits<Scalar>::IsComplex,
+    NeedToConjugate = Base::NeedToConjugate ? 0 : IsComplex
+  };
+  static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); }
+  static inline Scalar extractScalarFactor(const XprType& x) { return conj(Base::extractScalarFactor(x.nestedExpression())); }
+};
+
+// pop scalar multiple
+template<typename Scalar, typename NestedXpr, typename Plain>
+struct blas_traits<CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain>, NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  enum {
+    HasScalarFactor = true
+  };
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain>, NestedXpr> XprType;
+  typedef typename Base::ExtractType ExtractType;
+  static inline EIGEN_DEVICE_FUNC ExtractType extract(const XprType& x) { return Base::extract(x.rhs()); }
+  static inline EIGEN_DEVICE_FUNC Scalar extractScalarFactor(const XprType& x)
+  { return x.lhs().functor().m_other * Base::extractScalarFactor(x.rhs()); }
+};
+template<typename Scalar, typename NestedXpr, typename Plain>
+struct blas_traits<CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain> > >
+ : blas_traits<NestedXpr>
+{
+  enum {
+    HasScalarFactor = true
+  };
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain> > XprType;
+  typedef typename Base::ExtractType ExtractType;
+  static inline ExtractType extract(const XprType& x) { return Base::extract(x.lhs()); }
+  static inline Scalar extractScalarFactor(const XprType& x)
+  { return Base::extractScalarFactor(x.lhs()) * x.rhs().functor().m_other; }
+};
+template<typename Scalar, typename Plain1, typename Plain2>
+struct blas_traits<CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain1>,
+                                                            const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain2> > >
+ : blas_traits<CwiseNullaryOp<scalar_constant_op<Scalar>,Plain1> >
+{};
+
+// pop opposite
+template<typename Scalar, typename NestedXpr>
+struct blas_traits<CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  enum {
+    HasScalarFactor = true
+  };
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> XprType;
+  typedef typename Base::ExtractType ExtractType;
+  static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); }
+  static inline Scalar extractScalarFactor(const XprType& x)
+  { return - Base::extractScalarFactor(x.nestedExpression()); }
+};
+
+// pop/push transpose
+template<typename NestedXpr>
+struct blas_traits<Transpose<NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  typedef typename NestedXpr::Scalar Scalar;
+  typedef blas_traits<NestedXpr> Base;
+  typedef Transpose<NestedXpr> XprType;
+  typedef Transpose<const typename Base::_ExtractType>  ExtractType; // const to get rid of a compile error; anyway blas traits are only used on the RHS
+  typedef Transpose<const typename Base::_ExtractType> _ExtractType;
+  typedef typename conditional<bool(Base::HasUsableDirectAccess),
+    ExtractType,
+    typename ExtractType::PlainObject
+    >::type DirectLinearAccessType;
+  enum {
+    IsTransposed = Base::IsTransposed ? 0 : 1
+  };
+  static inline ExtractType extract(const XprType& x) { return ExtractType(Base::extract(x.nestedExpression())); }
+  static inline Scalar extractScalarFactor(const XprType& x) { return Base::extractScalarFactor(x.nestedExpression()); }
+};
+
+template<typename T>
+struct blas_traits<const T>
+     : blas_traits<T>
+{};
+
+template<typename T, bool HasUsableDirectAccess=blas_traits<T>::HasUsableDirectAccess>
+struct extract_data_selector {
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static const typename T::Scalar* run(const T& m)
+  {
+    return blas_traits<T>::extract(m).data();
+  }
+};
+
+template<typename T>
+struct extract_data_selector<T,false> {
+  static typename T::Scalar* run(const T&) { return 0; }
+};
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const typename T::Scalar* extract_data(const T& m)
+{
+  return extract_data_selector<T>::run(m);
+}
+
+/**
+ * \c combine_scalar_factors extracts and multiplies factors from GEMM and GEMV products.
+ * There is a specialization for booleans
+ */
+template<typename ResScalar, typename Lhs, typename Rhs>
+struct combine_scalar_factors_impl
+{
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static ResScalar run(const Lhs& lhs, const Rhs& rhs)
+  {
+    return blas_traits<Lhs>::extractScalarFactor(lhs) * blas_traits<Rhs>::extractScalarFactor(rhs);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static ResScalar run(const ResScalar& alpha, const Lhs& lhs, const Rhs& rhs)
+  {
+    return alpha * blas_traits<Lhs>::extractScalarFactor(lhs) * blas_traits<Rhs>::extractScalarFactor(rhs);
+  }
+};
+template<typename Lhs, typename Rhs>
+struct combine_scalar_factors_impl<bool, Lhs, Rhs>
+{
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static bool run(const Lhs& lhs, const Rhs& rhs)
+  {
+    return blas_traits<Lhs>::extractScalarFactor(lhs) && blas_traits<Rhs>::extractScalarFactor(rhs);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static bool run(const bool& alpha, const Lhs& lhs, const Rhs& rhs)
+  {
+    return alpha && blas_traits<Lhs>::extractScalarFactor(lhs) && blas_traits<Rhs>::extractScalarFactor(rhs);
+  }
+};
+
+template<typename ResScalar, typename Lhs, typename Rhs>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar combine_scalar_factors(const ResScalar& alpha, const Lhs& lhs, const Rhs& rhs)
+{
+  return combine_scalar_factors_impl<ResScalar,Lhs,Rhs>::run(alpha, lhs, rhs);
+}
+template<typename ResScalar, typename Lhs, typename Rhs>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar combine_scalar_factors(const Lhs& lhs, const Rhs& rhs)
+{
+  return combine_scalar_factors_impl<ResScalar,Lhs,Rhs>::run(lhs, rhs);
+}
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BLASUTIL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/ConfigureVectorization.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/ConfigureVectorization.h
new file mode 100644
index 00000000..af4e6962
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/ConfigureVectorization.h
@@ -0,0 +1,512 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2018 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2020, Arm Limited and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONFIGURE_VECTORIZATION_H
+#define EIGEN_CONFIGURE_VECTORIZATION_H
+
+//------------------------------------------------------------------------------------------
+// Static and dynamic alignment control
+//
+// The main purpose of this section is to define EIGEN_MAX_ALIGN_BYTES and EIGEN_MAX_STATIC_ALIGN_BYTES
+// as the maximal boundary in bytes on which dynamically and statically allocated data may be alignment respectively.
+// The values of EIGEN_MAX_ALIGN_BYTES and EIGEN_MAX_STATIC_ALIGN_BYTES can be specified by the user. If not,
+// a default value is automatically computed based on architecture, compiler, and OS.
+//
+// This section also defines macros EIGEN_ALIGN_TO_BOUNDARY(N) and the shortcuts EIGEN_ALIGN{8,16,32,_MAX}
+// to be used to declare statically aligned buffers.
+//------------------------------------------------------------------------------------------
+
+
+/* EIGEN_ALIGN_TO_BOUNDARY(n) forces data to be n-byte aligned. This is used to satisfy SIMD requirements.
+ * However, we do that EVEN if vectorization (EIGEN_VECTORIZE) is disabled,
+ * so that vectorization doesn't affect binary compatibility.
+ *
+ * If we made alignment depend on whether or not EIGEN_VECTORIZE is defined, it would be impossible to link
+ * vectorized and non-vectorized code.
+ * 
+ * FIXME: this code can be cleaned up once we switch to proper C++11 only.
+ */
+#if (defined EIGEN_CUDACC)
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __align__(n)
+  #define EIGEN_ALIGNOF(x) __alignof(x)
+#elif EIGEN_HAS_ALIGNAS
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) alignas(n)
+  #define EIGEN_ALIGNOF(x) alignof(x)
+#elif EIGEN_COMP_GNUC || EIGEN_COMP_PGI || EIGEN_COMP_IBM || EIGEN_COMP_ARM
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n)))
+  #define EIGEN_ALIGNOF(x) __alignof(x)
+#elif EIGEN_COMP_MSVC
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __declspec(align(n))
+  #define EIGEN_ALIGNOF(x) __alignof(x)
+#elif EIGEN_COMP_SUNCC
+  // FIXME not sure about this one:
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n)))
+  #define EIGEN_ALIGNOF(x) __alignof(x)
+#else
+  #error Please tell me what is the equivalent of alignas(n) and alignof(x) for your compiler
+#endif
+
+// If the user explicitly disable vectorization, then we also disable alignment
+#if defined(EIGEN_DONT_VECTORIZE)
+  #if defined(EIGEN_GPUCC)
+    // GPU code is always vectorized and requires memory alignment for
+    // statically allocated buffers.
+    #define EIGEN_IDEAL_MAX_ALIGN_BYTES 16
+  #else
+    #define EIGEN_IDEAL_MAX_ALIGN_BYTES 0
+  #endif
+#elif defined(__AVX512F__)
+  // 64 bytes static alignment is preferred only if really required
+  #define EIGEN_IDEAL_MAX_ALIGN_BYTES 64
+#elif defined(__AVX__)
+  // 32 bytes static alignment is preferred only if really required
+  #define EIGEN_IDEAL_MAX_ALIGN_BYTES 32
+#else
+  #define EIGEN_IDEAL_MAX_ALIGN_BYTES 16
+#endif
+
+
+// EIGEN_MIN_ALIGN_BYTES defines the minimal value for which the notion of explicit alignment makes sense
+#define EIGEN_MIN_ALIGN_BYTES 16
+
+// Defined the boundary (in bytes) on which the data needs to be aligned. Note
+// that unless EIGEN_ALIGN is defined and not equal to 0, the data may not be
+// aligned at all regardless of the value of this #define.
+
+#if (defined(EIGEN_DONT_ALIGN_STATICALLY) || defined(EIGEN_DONT_ALIGN))  && defined(EIGEN_MAX_STATIC_ALIGN_BYTES) && EIGEN_MAX_STATIC_ALIGN_BYTES>0
+#error EIGEN_MAX_STATIC_ALIGN_BYTES and EIGEN_DONT_ALIGN[_STATICALLY] are both defined with EIGEN_MAX_STATIC_ALIGN_BYTES!=0. Use EIGEN_MAX_STATIC_ALIGN_BYTES=0 as a synonym of EIGEN_DONT_ALIGN_STATICALLY.
+#endif
+
+// EIGEN_DONT_ALIGN_STATICALLY and EIGEN_DONT_ALIGN are deprecated
+// They imply EIGEN_MAX_STATIC_ALIGN_BYTES=0
+#if defined(EIGEN_DONT_ALIGN_STATICALLY) || defined(EIGEN_DONT_ALIGN)
+  #ifdef EIGEN_MAX_STATIC_ALIGN_BYTES
+    #undef EIGEN_MAX_STATIC_ALIGN_BYTES
+  #endif
+  #define EIGEN_MAX_STATIC_ALIGN_BYTES 0
+#endif
+
+#ifndef EIGEN_MAX_STATIC_ALIGN_BYTES
+
+  // Try to automatically guess what is the best default value for EIGEN_MAX_STATIC_ALIGN_BYTES
+
+  // 16 byte alignment is only useful for vectorization. Since it affects the ABI, we need to enable
+  // 16 byte alignment on all platforms where vectorization might be enabled. In theory we could always
+  // enable alignment, but it can be a cause of problems on some platforms, so we just disable it in
+  // certain common platform (compiler+architecture combinations) to avoid these problems.
+  // Only static alignment is really problematic (relies on nonstandard compiler extensions),
+  // try to keep heap alignment even when we have to disable static alignment.
+  #if EIGEN_COMP_GNUC && !(EIGEN_ARCH_i386_OR_x86_64 || EIGEN_ARCH_ARM_OR_ARM64 || EIGEN_ARCH_PPC || EIGEN_ARCH_IA64 || EIGEN_ARCH_MIPS)
+  #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 1
+  #elif EIGEN_ARCH_ARM_OR_ARM64 && EIGEN_COMP_GNUC_STRICT && EIGEN_GNUC_AT_MOST(4, 6)
+  // Old versions of GCC on ARM, at least 4.4, were once seen to have buggy static alignment support.
+  // Not sure which version fixed it, hopefully it doesn't affect 4.7, which is still somewhat in use.
+  // 4.8 and newer seem definitely unaffected.
+  #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 1
+  #else
+  #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 0
+  #endif
+
+  // static alignment is completely disabled with GCC 3, Sun Studio, and QCC/QNX
+  #if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT \
+  && !EIGEN_GCC3_OR_OLDER \
+  && !EIGEN_COMP_SUNCC \
+  && !EIGEN_OS_QNX
+    #define EIGEN_ARCH_WANTS_STACK_ALIGNMENT 1
+  #else
+    #define EIGEN_ARCH_WANTS_STACK_ALIGNMENT 0
+  #endif
+
+  #if EIGEN_ARCH_WANTS_STACK_ALIGNMENT
+    #define EIGEN_MAX_STATIC_ALIGN_BYTES EIGEN_IDEAL_MAX_ALIGN_BYTES
+  #else
+    #define EIGEN_MAX_STATIC_ALIGN_BYTES 0
+  #endif
+
+#endif
+
+// If EIGEN_MAX_ALIGN_BYTES is defined, then it is considered as an upper bound for EIGEN_MAX_STATIC_ALIGN_BYTES
+#if defined(EIGEN_MAX_ALIGN_BYTES) && EIGEN_MAX_ALIGN_BYTES<EIGEN_MAX_STATIC_ALIGN_BYTES
+#undef EIGEN_MAX_STATIC_ALIGN_BYTES
+#define EIGEN_MAX_STATIC_ALIGN_BYTES EIGEN_MAX_ALIGN_BYTES
+#endif
+
+#if EIGEN_MAX_STATIC_ALIGN_BYTES==0 && !defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT)
+  #define EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT
+#endif
+
+// At this stage, EIGEN_MAX_STATIC_ALIGN_BYTES>0 is the true test whether we want to align arrays on the stack or not.
+// It takes into account both the user choice to explicitly enable/disable alignment (by setting EIGEN_MAX_STATIC_ALIGN_BYTES)
+// and the architecture config (EIGEN_ARCH_WANTS_STACK_ALIGNMENT).
+// Henceforth, only EIGEN_MAX_STATIC_ALIGN_BYTES should be used.
+
+
+// Shortcuts to EIGEN_ALIGN_TO_BOUNDARY
+#define EIGEN_ALIGN8  EIGEN_ALIGN_TO_BOUNDARY(8)
+#define EIGEN_ALIGN16 EIGEN_ALIGN_TO_BOUNDARY(16)
+#define EIGEN_ALIGN32 EIGEN_ALIGN_TO_BOUNDARY(32)
+#define EIGEN_ALIGN64 EIGEN_ALIGN_TO_BOUNDARY(64)
+#if EIGEN_MAX_STATIC_ALIGN_BYTES>0
+#define EIGEN_ALIGN_MAX EIGEN_ALIGN_TO_BOUNDARY(EIGEN_MAX_STATIC_ALIGN_BYTES)
+#else
+#define EIGEN_ALIGN_MAX
+#endif
+
+
+// Dynamic alignment control
+
+#if defined(EIGEN_DONT_ALIGN) && defined(EIGEN_MAX_ALIGN_BYTES) && EIGEN_MAX_ALIGN_BYTES>0
+#error EIGEN_MAX_ALIGN_BYTES and EIGEN_DONT_ALIGN are both defined with EIGEN_MAX_ALIGN_BYTES!=0. Use EIGEN_MAX_ALIGN_BYTES=0 as a synonym of EIGEN_DONT_ALIGN.
+#endif
+
+#ifdef EIGEN_DONT_ALIGN
+  #ifdef EIGEN_MAX_ALIGN_BYTES
+    #undef EIGEN_MAX_ALIGN_BYTES
+  #endif
+  #define EIGEN_MAX_ALIGN_BYTES 0
+#elif !defined(EIGEN_MAX_ALIGN_BYTES)
+  #define EIGEN_MAX_ALIGN_BYTES EIGEN_IDEAL_MAX_ALIGN_BYTES
+#endif
+
+#if EIGEN_IDEAL_MAX_ALIGN_BYTES > EIGEN_MAX_ALIGN_BYTES
+#define EIGEN_DEFAULT_ALIGN_BYTES EIGEN_IDEAL_MAX_ALIGN_BYTES
+#else
+#define EIGEN_DEFAULT_ALIGN_BYTES EIGEN_MAX_ALIGN_BYTES
+#endif
+
+
+#ifndef EIGEN_UNALIGNED_VECTORIZE
+#define EIGEN_UNALIGNED_VECTORIZE 1
+#endif
+
+//----------------------------------------------------------------------
+
+// if alignment is disabled, then disable vectorization. Note: EIGEN_MAX_ALIGN_BYTES is the proper check, it takes into
+// account both the user's will (EIGEN_MAX_ALIGN_BYTES,EIGEN_DONT_ALIGN) and our own platform checks
+#if EIGEN_MAX_ALIGN_BYTES==0
+  #ifndef EIGEN_DONT_VECTORIZE
+    #define EIGEN_DONT_VECTORIZE
+  #endif
+#endif
+
+
+// The following (except #include <malloc.h> and _M_IX86_FP ??) can likely be
+// removed as gcc 4.1 and msvc 2008 are not supported anyways.
+#if EIGEN_COMP_MSVC
+  #include <malloc.h> // for _aligned_malloc -- need it regardless of whether vectorization is enabled
+  #if (EIGEN_COMP_MSVC >= 1500) // 2008 or later
+    // a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP.
+    #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || EIGEN_ARCH_x86_64
+      #define EIGEN_SSE2_ON_MSVC_2008_OR_LATER
+    #endif
+  #endif
+#else
+  #if (defined __SSE2__) && ( (!EIGEN_COMP_GNUC) || EIGEN_COMP_ICC || EIGEN_GNUC_AT_LEAST(4,2) )
+    #define EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC
+  #endif
+#endif
+
+#if !(defined(EIGEN_DONT_VECTORIZE) || defined(EIGEN_GPUCC))
+
+  #if defined (EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER)
+
+    // Defines symbols for compile-time detection of which instructions are
+    // used.
+    // EIGEN_VECTORIZE_YY is defined if and only if the instruction set YY is used
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_SSE
+    #define EIGEN_VECTORIZE_SSE2
+
+    // Detect sse3/ssse3/sse4:
+    // gcc and icc defines __SSE3__, ...
+    // there is no way to know about this on msvc. You can define EIGEN_VECTORIZE_SSE* if you
+    // want to force the use of those instructions with msvc.
+    #ifdef __SSE3__
+      #define EIGEN_VECTORIZE_SSE3
+    #endif
+    #ifdef __SSSE3__
+      #define EIGEN_VECTORIZE_SSSE3
+    #endif
+    #ifdef __SSE4_1__
+      #define EIGEN_VECTORIZE_SSE4_1
+    #endif
+    #ifdef __SSE4_2__
+      #define EIGEN_VECTORIZE_SSE4_2
+    #endif
+    #ifdef __AVX__
+      #ifndef EIGEN_USE_SYCL 
+        #define EIGEN_VECTORIZE_AVX
+      #endif
+      #define EIGEN_VECTORIZE_SSE3
+      #define EIGEN_VECTORIZE_SSSE3
+      #define EIGEN_VECTORIZE_SSE4_1
+      #define EIGEN_VECTORIZE_SSE4_2
+    #endif
+    #ifdef __AVX2__
+      #ifndef EIGEN_USE_SYCL 
+        #define EIGEN_VECTORIZE_AVX2
+        #define EIGEN_VECTORIZE_AVX
+      #endif
+      #define EIGEN_VECTORIZE_SSE3
+      #define EIGEN_VECTORIZE_SSSE3
+      #define EIGEN_VECTORIZE_SSE4_1
+      #define EIGEN_VECTORIZE_SSE4_2
+    #endif
+    #if defined(__FMA__) || (EIGEN_COMP_MSVC && defined(__AVX2__))
+      // MSVC does not expose a switch dedicated for FMA
+      // For MSVC, AVX2 => FMA
+      #define EIGEN_VECTORIZE_FMA
+    #endif
+    #if defined(__AVX512F__)
+      #ifndef EIGEN_VECTORIZE_FMA
+      #if EIGEN_COMP_GNUC
+      #error Please add -mfma to your compiler flags: compiling with -mavx512f alone without SSE/AVX FMA is not supported (bug 1638).
+      #else
+      #error Please enable FMA in your compiler flags (e.g. -mfma): compiling with AVX512 alone without SSE/AVX FMA is not supported (bug 1638).
+      #endif
+      #endif
+      #ifndef EIGEN_USE_SYCL
+        #define EIGEN_VECTORIZE_AVX512
+        #define EIGEN_VECTORIZE_AVX2
+        #define EIGEN_VECTORIZE_AVX
+      #endif
+      #define EIGEN_VECTORIZE_FMA
+      #define EIGEN_VECTORIZE_SSE3
+      #define EIGEN_VECTORIZE_SSSE3
+      #define EIGEN_VECTORIZE_SSE4_1
+      #define EIGEN_VECTORIZE_SSE4_2
+      #ifndef EIGEN_USE_SYCL
+        #ifdef __AVX512DQ__
+          #define EIGEN_VECTORIZE_AVX512DQ
+        #endif
+        #ifdef __AVX512ER__
+          #define EIGEN_VECTORIZE_AVX512ER
+        #endif
+        #ifdef __AVX512BF16__
+          #define EIGEN_VECTORIZE_AVX512BF16
+        #endif
+      #endif
+    #endif
+
+    // Disable AVX support on broken xcode versions
+    #if defined(__apple_build_version__) && (__apple_build_version__ == 11000033 ) && ( __MAC_OS_X_VERSION_MIN_REQUIRED == 101500 )
+      // A nasty bug in the clang compiler shipped with xcode in a common compilation situation
+      // when XCode 11.0 and Mac deployment target macOS 10.15 is https://trac.macports.org/ticket/58776#no1
+      #ifdef EIGEN_VECTORIZE_AVX
+        #undef EIGEN_VECTORIZE_AVX
+        #warning "Disabling AVX support: clang compiler shipped with XCode 11.[012] generates broken assembly with -macosx-version-min=10.15 and AVX enabled. "
+        #ifdef EIGEN_VECTORIZE_AVX2
+          #undef EIGEN_VECTORIZE_AVX2
+        #endif
+        #ifdef EIGEN_VECTORIZE_FMA
+          #undef EIGEN_VECTORIZE_FMA
+        #endif
+        #ifdef EIGEN_VECTORIZE_AVX512
+          #undef EIGEN_VECTORIZE_AVX512
+        #endif
+        #ifdef EIGEN_VECTORIZE_AVX512DQ
+          #undef EIGEN_VECTORIZE_AVX512DQ
+        #endif
+        #ifdef EIGEN_VECTORIZE_AVX512ER
+          #undef EIGEN_VECTORIZE_AVX512ER
+        #endif
+      #endif
+      // NOTE: Confirmed test failures in XCode 11.0, and XCode 11.2 with  -macosx-version-min=10.15 and AVX
+      // NOTE using -macosx-version-min=10.15 with Xcode 11.0 results in runtime segmentation faults in many tests, 11.2 produce core dumps in 3 tests
+      // NOTE using -macosx-version-min=10.14 produces functioning and passing tests in all cases
+      // NOTE __clang_version__ "11.0.0 (clang-1100.0.33.8)"  XCode 11.0 <- Produces many segfault and core dumping tests
+      //                                                                    with  -macosx-version-min=10.15 and AVX
+      // NOTE __clang_version__ "11.0.0 (clang-1100.0.33.12)" XCode 11.2 <- Produces 3 core dumping tests with  
+      //                                                                    -macosx-version-min=10.15 and AVX
+    #endif
+
+    // include files
+
+    // This extern "C" works around a MINGW-w64 compilation issue
+    // https://sourceforge.net/tracker/index.php?func=detail&aid=3018394&group_id=202880&atid=983354
+    // In essence, intrin.h is included by windows.h and also declares intrinsics (just as emmintrin.h etc. below do).
+    // However, intrin.h uses an extern "C" declaration, and g++ thus complains of duplicate declarations
+    // with conflicting linkage.  The linkage for intrinsics doesn't matter, but at that stage the compiler doesn't know;
+    // so, to avoid compile errors when windows.h is included after Eigen/Core, ensure intrinsics are extern "C" here too.
+    // notice that since these are C headers, the extern "C" is theoretically needed anyways.
+    extern "C" {
+      // In theory we should only include immintrin.h and not the other *mmintrin.h header files directly.
+      // Doing so triggers some issues with ICC. However old gcc versions seems to not have this file, thus:
+      #if EIGEN_COMP_ICC >= 1110
+        #include <immintrin.h>
+      #else
+        #include <mmintrin.h>
+        #include <emmintrin.h>
+        #include <xmmintrin.h>
+        #ifdef  EIGEN_VECTORIZE_SSE3
+        #include <pmmintrin.h>
+        #endif
+        #ifdef EIGEN_VECTORIZE_SSSE3
+        #include <tmmintrin.h>
+        #endif
+        #ifdef EIGEN_VECTORIZE_SSE4_1
+        #include <smmintrin.h>
+        #endif
+        #ifdef EIGEN_VECTORIZE_SSE4_2
+        #include <nmmintrin.h>
+        #endif
+        #if defined(EIGEN_VECTORIZE_AVX) || defined(EIGEN_VECTORIZE_AVX512)
+        #include <immintrin.h>
+        #endif
+      #endif
+    } // end extern "C"
+
+  #elif defined __VSX__
+
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_VSX
+    #include <altivec.h>
+    // We need to #undef all these ugly tokens defined in <altivec.h>
+    // => use __vector instead of vector
+    #undef bool
+    #undef vector
+    #undef pixel
+
+  #elif defined __ALTIVEC__
+
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_ALTIVEC
+    #include <altivec.h>
+    // We need to #undef all these ugly tokens defined in <altivec.h>
+    // => use __vector instead of vector
+    #undef bool
+    #undef vector
+    #undef pixel
+
+  #elif ((defined  __ARM_NEON) || (defined __ARM_NEON__)) && !(defined EIGEN_ARM64_USE_SVE)
+
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_NEON
+    #include <arm_neon.h>
+
+  // We currently require SVE to be enabled explicitly via EIGEN_ARM64_USE_SVE and
+  // will not select the backend automatically
+  #elif (defined __ARM_FEATURE_SVE) && (defined EIGEN_ARM64_USE_SVE)
+
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_SVE
+    #include <arm_sve.h>
+
+    // Since we depend on knowing SVE vector lengths at compile-time, we need
+    // to ensure a fixed lengths is set
+    #if defined __ARM_FEATURE_SVE_BITS
+      #define EIGEN_ARM64_SVE_VL __ARM_FEATURE_SVE_BITS
+    #else
+#error "Eigen requires a fixed SVE lector length but EIGEN_ARM64_SVE_VL is not set."
+#endif
+
+#elif (defined __s390x__ && defined __VEC__)
+
+#define EIGEN_VECTORIZE
+#define EIGEN_VECTORIZE_ZVECTOR
+#include <vecintrin.h>
+
+#elif defined __mips_msa
+
+// Limit MSA optimizations to little-endian CPUs for now.
+// TODO: Perhaps, eventually support MSA optimizations on big-endian CPUs?
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#if defined(__LP64__)
+#define EIGEN_MIPS_64
+#else
+#define EIGEN_MIPS_32
+#endif
+#define EIGEN_VECTORIZE
+#define EIGEN_VECTORIZE_MSA
+#include <msa.h>
+#endif
+
+#endif
+#endif
+
+// Following the Arm ACLE arm_neon.h should also include arm_fp16.h but not all
+// compilers seem to follow this. We therefore include it explicitly.
+// See also: https://bugs.llvm.org/show_bug.cgi?id=47955
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  #include <arm_fp16.h>
+#endif
+
+#if defined(__F16C__) && (!defined(EIGEN_GPUCC) && (!defined(EIGEN_COMP_CLANG) || EIGEN_COMP_CLANG>=380))
+  // We can use the optimized fp16 to float and float to fp16 conversion routines
+  #define EIGEN_HAS_FP16_C
+
+  #if defined(EIGEN_COMP_CLANG)
+    // Workaround for clang: The FP16C intrinsics for clang are included by
+    // immintrin.h, as opposed to emmintrin.h as suggested by Intel:
+    // https://software.intel.com/sites/landingpage/IntrinsicsGuide/#othertechs=FP16C&expand=1711
+    #include <immintrin.h>
+  #endif
+#endif
+
+#if defined EIGEN_CUDACC
+  #define EIGEN_VECTORIZE_GPU
+  #include <vector_types.h>
+  #if EIGEN_CUDA_SDK_VER >= 70500
+    #define EIGEN_HAS_CUDA_FP16
+  #endif
+#endif
+
+#if defined(EIGEN_HAS_CUDA_FP16)
+  #include <cuda_runtime_api.h>
+  #include <cuda_fp16.h>
+#endif
+
+#if defined(EIGEN_HIPCC)
+  #define EIGEN_VECTORIZE_GPU
+  #include <hip/hip_vector_types.h>
+  #define EIGEN_HAS_HIP_FP16
+  #include <hip/hip_fp16.h>
+#endif
+
+
+/** \brief Namespace containing all symbols from the %Eigen library. */
+namespace Eigen {
+
+inline static const char *SimdInstructionSetsInUse(void) {
+#if defined(EIGEN_VECTORIZE_AVX512)
+  return "AVX512, FMA, AVX2, AVX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
+#elif defined(EIGEN_VECTORIZE_AVX)
+  return "AVX SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
+#elif defined(EIGEN_VECTORIZE_SSE4_2)
+  return "SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
+#elif defined(EIGEN_VECTORIZE_SSE4_1)
+  return "SSE, SSE2, SSE3, SSSE3, SSE4.1";
+#elif defined(EIGEN_VECTORIZE_SSSE3)
+  return "SSE, SSE2, SSE3, SSSE3";
+#elif defined(EIGEN_VECTORIZE_SSE3)
+  return "SSE, SSE2, SSE3";
+#elif defined(EIGEN_VECTORIZE_SSE2)
+  return "SSE, SSE2";
+#elif defined(EIGEN_VECTORIZE_ALTIVEC)
+  return "AltiVec";
+#elif defined(EIGEN_VECTORIZE_VSX)
+  return "VSX";
+#elif defined(EIGEN_VECTORIZE_NEON)
+  return "ARM NEON";
+#elif defined(EIGEN_VECTORIZE_SVE)
+  return "ARM SVE";
+#elif defined(EIGEN_VECTORIZE_ZVECTOR)
+  return "S390X ZVECTOR";
+#elif defined(EIGEN_VECTORIZE_MSA)
+  return "MIPS MSA";
+#else
+  return "None";
+#endif
+}
+
+} // end namespace Eigen
+
+
+#endif // EIGEN_CONFIGURE_VECTORIZATION_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/Constants.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/Constants.h
new file mode 100644
index 00000000..35dcaa7b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/Constants.h
@@ -0,0 +1,563 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2020, Arm Limited and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONSTANTS_H
+#define EIGEN_CONSTANTS_H
+
+namespace Eigen {
+
+/** This value means that a positive quantity (e.g., a size) is not known at compile-time, and that instead the value is
+  * stored in some runtime variable.
+  *
+  * Changing the value of Dynamic breaks the ABI, as Dynamic is often used as a template parameter for Matrix.
+  */
+const int Dynamic = -1;
+
+/** This value means that a signed quantity (e.g., a signed index) is not known at compile-time, and that instead its value
+  * has to be specified at runtime.
+  */
+const int DynamicIndex = 0xffffff;
+
+/** This value means that the increment to go from one value to another in a sequence is not constant for each step.
+  */
+const int UndefinedIncr = 0xfffffe;
+
+/** This value means +Infinity; it is currently used only as the p parameter to MatrixBase::lpNorm<int>().
+  * The value Infinity there means the L-infinity norm.
+  */
+const int Infinity = -1;
+
+/** This value means that the cost to evaluate an expression coefficient is either very expensive or
+  * cannot be known at compile time.
+  *
+  * This value has to be positive to (1) simplify cost computation, and (2) allow to distinguish between a very expensive and very very expensive expressions.
+  * It thus must also be large enough to make sure unrolling won't happen and that sub expressions will be evaluated, but not too large to avoid overflow.
+  */
+const int HugeCost = 10000;
+
+/** \defgroup flags Flags
+  * \ingroup Core_Module
+  *
+  * These are the possible bits which can be OR'ed to constitute the flags of a matrix or
+  * expression.
+  *
+  * It is important to note that these flags are a purely compile-time notion. They are a compile-time property of
+  * an expression type, implemented as enum's. They are not stored in memory at runtime, and they do not incur any
+  * runtime overhead.
+  *
+  * \sa MatrixBase::Flags
+  */
+
+/** \ingroup flags
+  *
+  * for a matrix, this means that the storage order is row-major.
+  * If this bit is not set, the storage order is column-major.
+  * For an expression, this determines the storage order of
+  * the matrix created by evaluation of that expression.
+  * \sa \blank  \ref TopicStorageOrders */
+const unsigned int RowMajorBit = 0x1;
+
+/** \ingroup flags
+  * means the expression should be evaluated by the calling expression */
+const unsigned int EvalBeforeNestingBit = 0x2;
+
+/** \ingroup flags
+  * \deprecated
+  * means the expression should be evaluated before any assignment */
+EIGEN_DEPRECATED
+const unsigned int EvalBeforeAssigningBit = 0x4; // FIXME deprecated
+
+/** \ingroup flags
+  *
+  * Short version: means the expression might be vectorized
+  *
+  * Long version: means that the coefficients can be handled by packets
+  * and start at a memory location whose alignment meets the requirements
+  * of the present CPU architecture for optimized packet access. In the fixed-size
+  * case, there is the additional condition that it be possible to access all the
+  * coefficients by packets (this implies the requirement that the size be a multiple of 16 bytes,
+  * and that any nontrivial strides don't break the alignment). In the dynamic-size case,
+  * there is no such condition on the total size and strides, so it might not be possible to access
+  * all coeffs by packets.
+  *
+  * \note This bit can be set regardless of whether vectorization is actually enabled.
+  *       To check for actual vectorizability, see \a ActualPacketAccessBit.
+  */
+const unsigned int PacketAccessBit = 0x8;
+
+#ifdef EIGEN_VECTORIZE
+/** \ingroup flags
+  *
+  * If vectorization is enabled (EIGEN_VECTORIZE is defined) this constant
+  * is set to the value \a PacketAccessBit.
+  *
+  * If vectorization is not enabled (EIGEN_VECTORIZE is not defined) this constant
+  * is set to the value 0.
+  */
+const unsigned int ActualPacketAccessBit = PacketAccessBit;
+#else
+const unsigned int ActualPacketAccessBit = 0x0;
+#endif
+
+/** \ingroup flags
+  *
+  * Short version: means the expression can be seen as 1D vector.
+  *
+  * Long version: means that one can access the coefficients
+  * of this expression by coeff(int), and coeffRef(int) in the case of a lvalue expression. These
+  * index-based access methods are guaranteed
+  * to not have to do any runtime computation of a (row, col)-pair from the index, so that it
+  * is guaranteed that whenever it is available, index-based access is at least as fast as
+  * (row,col)-based access. Expressions for which that isn't possible don't have the LinearAccessBit.
+  *
+  * If both PacketAccessBit and LinearAccessBit are set, then the
+  * packets of this expression can be accessed by packet(int), and writePacket(int) in the case of a
+  * lvalue expression.
+  *
+  * Typically, all vector expressions have the LinearAccessBit, but there is one exception:
+  * Product expressions don't have it, because it would be troublesome for vectorization, even when the
+  * Product is a vector expression. Thus, vector Product expressions allow index-based coefficient access but
+  * not index-based packet access, so they don't have the LinearAccessBit.
+  */
+const unsigned int LinearAccessBit = 0x10;
+
+/** \ingroup flags
+  *
+  * Means the expression has a coeffRef() method, i.e. is writable as its individual coefficients are directly addressable.
+  * This rules out read-only expressions.
+  *
+  * Note that DirectAccessBit and LvalueBit are mutually orthogonal, as there are examples of expression having one but note
+  * the other:
+  *   \li writable expressions that don't have a very simple memory layout as a strided array, have LvalueBit but not DirectAccessBit
+  *   \li Map-to-const expressions, for example Map<const Matrix>, have DirectAccessBit but not LvalueBit
+  *
+  * Expressions having LvalueBit also have their coeff() method returning a const reference instead of returning a new value.
+  */
+const unsigned int LvalueBit = 0x20;
+
+/** \ingroup flags
+  *
+  * Means that the underlying array of coefficients can be directly accessed as a plain strided array. The memory layout
+  * of the array of coefficients must be exactly the natural one suggested by rows(), cols(),
+  * outerStride(), innerStride(), and the RowMajorBit. This rules out expressions such as Diagonal, whose coefficients,
+  * though referencable, do not have such a regular memory layout.
+  *
+  * See the comment on LvalueBit for an explanation of how LvalueBit and DirectAccessBit are mutually orthogonal.
+  */
+const unsigned int DirectAccessBit = 0x40;
+
+/** \deprecated \ingroup flags
+  *
+  * means the first coefficient packet is guaranteed to be aligned.
+  * An expression cannot have the AlignedBit without the PacketAccessBit flag.
+  * In other words, this means we are allow to perform an aligned packet access to the first element regardless
+  * of the expression kind:
+  * \code
+  * expression.packet<Aligned>(0);
+  * \endcode
+  */
+EIGEN_DEPRECATED const unsigned int AlignedBit = 0x80;
+
+const unsigned int NestByRefBit = 0x100;
+
+/** \ingroup flags
+  *
+  * for an expression, this means that the storage order
+  * can be either row-major or column-major.
+  * The precise choice will be decided at evaluation time or when
+  * combined with other expressions.
+  * \sa \blank  \ref RowMajorBit, \ref TopicStorageOrders */
+const unsigned int NoPreferredStorageOrderBit = 0x200;
+
+/** \ingroup flags
+  *
+  * Means that the underlying coefficients can be accessed through pointers to the sparse (un)compressed storage format,
+  * that is, the expression provides:
+  * \code
+    inline const Scalar* valuePtr() const;
+    inline const Index* innerIndexPtr() const;
+    inline const Index* outerIndexPtr() const;
+    inline const Index* innerNonZeroPtr() const;
+    \endcode
+  */
+const unsigned int CompressedAccessBit = 0x400;
+
+
+// list of flags that are inherited by default
+const unsigned int HereditaryBits = RowMajorBit
+                                  | EvalBeforeNestingBit;
+
+/** \defgroup enums Enumerations
+  * \ingroup Core_Module
+  *
+  * Various enumerations used in %Eigen. Many of these are used as template parameters.
+  */
+
+/** \ingroup enums
+  * Enum containing possible values for the \c Mode or \c UpLo parameter of
+  * MatrixBase::selfadjointView() and MatrixBase::triangularView(), and selfadjoint solvers. */
+enum UpLoType {
+  /** View matrix as a lower triangular matrix. */
+  Lower=0x1,                      
+  /** View matrix as an upper triangular matrix. */
+  Upper=0x2,                      
+  /** %Matrix has ones on the diagonal; to be used in combination with #Lower or #Upper. */
+  UnitDiag=0x4, 
+  /** %Matrix has zeros on the diagonal; to be used in combination with #Lower or #Upper. */
+  ZeroDiag=0x8,
+  /** View matrix as a lower triangular matrix with ones on the diagonal. */
+  UnitLower=UnitDiag|Lower, 
+  /** View matrix as an upper triangular matrix with ones on the diagonal. */
+  UnitUpper=UnitDiag|Upper,
+  /** View matrix as a lower triangular matrix with zeros on the diagonal. */
+  StrictlyLower=ZeroDiag|Lower, 
+  /** View matrix as an upper triangular matrix with zeros on the diagonal. */
+  StrictlyUpper=ZeroDiag|Upper,
+  /** Used in BandMatrix and SelfAdjointView to indicate that the matrix is self-adjoint. */
+  SelfAdjoint=0x10,
+  /** Used to support symmetric, non-selfadjoint, complex matrices. */
+  Symmetric=0x20
+};
+
+/** \ingroup enums
+  * Enum for indicating whether a buffer is aligned or not. */
+enum AlignmentType {
+  Unaligned=0,        /**< Data pointer has no specific alignment. */
+  Aligned8=8,         /**< Data pointer is aligned on a 8 bytes boundary. */
+  Aligned16=16,       /**< Data pointer is aligned on a 16 bytes boundary. */
+  Aligned32=32,       /**< Data pointer is aligned on a 32 bytes boundary. */
+  Aligned64=64,       /**< Data pointer is aligned on a 64 bytes boundary. */
+  Aligned128=128,     /**< Data pointer is aligned on a 128 bytes boundary. */
+  AlignedMask=255,
+  Aligned=16,         /**< \deprecated Synonym for Aligned16. */
+#if EIGEN_MAX_ALIGN_BYTES==128
+  AlignedMax = Aligned128
+#elif EIGEN_MAX_ALIGN_BYTES==64
+  AlignedMax = Aligned64
+#elif EIGEN_MAX_ALIGN_BYTES==32
+  AlignedMax = Aligned32
+#elif EIGEN_MAX_ALIGN_BYTES==16
+  AlignedMax = Aligned16
+#elif EIGEN_MAX_ALIGN_BYTES==8
+  AlignedMax = Aligned8
+#elif EIGEN_MAX_ALIGN_BYTES==0
+  AlignedMax = Unaligned
+#else
+#error Invalid value for EIGEN_MAX_ALIGN_BYTES
+#endif
+};
+
+/** \ingroup enums
+  * Enum containing possible values for the \p Direction parameter of
+  * Reverse, PartialReduxExpr and VectorwiseOp. */
+enum DirectionType { 
+  /** For Reverse, all columns are reversed; 
+    * for PartialReduxExpr and VectorwiseOp, act on columns. */
+  Vertical, 
+  /** For Reverse, all rows are reversed; 
+    * for PartialReduxExpr and VectorwiseOp, act on rows. */
+  Horizontal, 
+  /** For Reverse, both rows and columns are reversed; 
+    * not used for PartialReduxExpr and VectorwiseOp. */
+  BothDirections 
+};
+
+/** \internal \ingroup enums
+  * Enum to specify how to traverse the entries of a matrix. */
+enum TraversalType {
+  /** \internal Default traversal, no vectorization, no index-based access */
+  DefaultTraversal,
+  /** \internal No vectorization, use index-based access to have only one for loop instead of 2 nested loops */
+  LinearTraversal,
+  /** \internal Equivalent to a slice vectorization for fixed-size matrices having good alignment
+    * and good size */
+  InnerVectorizedTraversal,
+  /** \internal Vectorization path using a single loop plus scalar loops for the
+    * unaligned boundaries */
+  LinearVectorizedTraversal,
+  /** \internal Generic vectorization path using one vectorized loop per row/column with some
+    * scalar loops to handle the unaligned boundaries */
+  SliceVectorizedTraversal,
+  /** \internal Special case to properly handle incompatible scalar types or other defecting cases*/
+  InvalidTraversal,
+  /** \internal Evaluate all entries at once */
+  AllAtOnceTraversal
+};
+
+/** \internal \ingroup enums
+  * Enum to specify whether to unroll loops when traversing over the entries of a matrix. */
+enum UnrollingType {
+  /** \internal Do not unroll loops. */
+  NoUnrolling,
+  /** \internal Unroll only the inner loop, but not the outer loop. */
+  InnerUnrolling,
+  /** \internal Unroll both the inner and the outer loop. If there is only one loop, 
+    * because linear traversal is used, then unroll that loop. */
+  CompleteUnrolling
+};
+
+/** \internal \ingroup enums
+  * Enum to specify whether to use the default (built-in) implementation or the specialization. */
+enum SpecializedType {
+  Specialized,
+  BuiltIn
+};
+
+/** \ingroup enums
+  * Enum containing possible values for the \p _Options template parameter of
+  * Matrix, Array and BandMatrix. */
+enum StorageOptions {
+  /** Storage order is column major (see \ref TopicStorageOrders). */
+  ColMajor = 0,
+  /** Storage order is row major (see \ref TopicStorageOrders). */
+  RowMajor = 0x1,  // it is only a coincidence that this is equal to RowMajorBit -- don't rely on that
+  /** Align the matrix itself if it is vectorizable fixed-size */
+  AutoAlign = 0,
+  /** Don't require alignment for the matrix itself (the array of coefficients, if dynamically allocated, may still be requested to be aligned) */ // FIXME --- clarify the situation
+  DontAlign = 0x2
+};
+
+/** \ingroup enums
+  * Enum for specifying whether to apply or solve on the left or right. */
+enum SideType {
+  /** Apply transformation on the left. */
+  OnTheLeft = 1,
+  /** Apply transformation on the right. */
+  OnTheRight = 2
+};
+
+/** \ingroup enums
+ * Enum for specifying NaN-propagation behavior, e.g. for coeff-wise min/max. */
+enum NaNPropagationOptions {
+  /**  Implementation defined behavior if NaNs are present. */
+  PropagateFast = 0,
+  /**  Always propagate NaNs. */
+  PropagateNaN,
+  /**  Always propagate not-NaNs. */
+  PropagateNumbers
+};
+
+/* the following used to be written as:
+ *
+ *   struct NoChange_t {};
+ *   namespace {
+ *     EIGEN_UNUSED NoChange_t NoChange;
+ *   }
+ *
+ * on the ground that it feels dangerous to disambiguate overloaded functions on enum/integer types.  
+ * However, this leads to "variable declared but never referenced" warnings on Intel Composer XE,
+ * and we do not know how to get rid of them (bug 450).
+ */
+
+enum NoChange_t   { NoChange };
+enum Sequential_t { Sequential };
+enum Default_t    { Default };
+
+/** \internal \ingroup enums
+  * Used in AmbiVector. */
+enum AmbiVectorMode {
+  IsDense         = 0,
+  IsSparse
+};
+
+/** \ingroup enums
+  * Used as template parameter in DenseCoeffBase and MapBase to indicate 
+  * which accessors should be provided. */
+enum AccessorLevels {
+  /** Read-only access via a member function. */
+  ReadOnlyAccessors, 
+  /** Read/write access via member functions. */
+  WriteAccessors, 
+  /** Direct read-only access to the coefficients. */
+  DirectAccessors, 
+  /** Direct read/write access to the coefficients. */
+  DirectWriteAccessors
+};
+
+/** \ingroup enums
+  * Enum with options to give to various decompositions. */
+enum DecompositionOptions {
+  /** \internal Not used (meant for LDLT?). */
+  Pivoting            = 0x01, 
+  /** \internal Not used (meant for LDLT?). */
+  NoPivoting          = 0x02, 
+  /** Used in JacobiSVD to indicate that the square matrix U is to be computed. */
+  ComputeFullU        = 0x04,
+  /** Used in JacobiSVD to indicate that the thin matrix U is to be computed. */
+  ComputeThinU        = 0x08,
+  /** Used in JacobiSVD to indicate that the square matrix V is to be computed. */
+  ComputeFullV        = 0x10,
+  /** Used in JacobiSVD to indicate that the thin matrix V is to be computed. */
+  ComputeThinV        = 0x20,
+  /** Used in SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver to specify
+    * that only the eigenvalues are to be computed and not the eigenvectors. */
+  EigenvaluesOnly     = 0x40,
+  /** Used in SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver to specify
+    * that both the eigenvalues and the eigenvectors are to be computed. */
+  ComputeEigenvectors = 0x80,
+  /** \internal */
+  EigVecMask = EigenvaluesOnly | ComputeEigenvectors,
+  /** Used in GeneralizedSelfAdjointEigenSolver to indicate that it should
+    * solve the generalized eigenproblem \f$ Ax = \lambda B x \f$. */
+  Ax_lBx              = 0x100,
+  /** Used in GeneralizedSelfAdjointEigenSolver to indicate that it should
+    * solve the generalized eigenproblem \f$ ABx = \lambda x \f$. */
+  ABx_lx              = 0x200,
+  /** Used in GeneralizedSelfAdjointEigenSolver to indicate that it should
+    * solve the generalized eigenproblem \f$ BAx = \lambda x \f$. */
+  BAx_lx              = 0x400,
+  /** \internal */
+  GenEigMask = Ax_lBx | ABx_lx | BAx_lx
+};
+
+/** \ingroup enums
+  * Possible values for the \p QRPreconditioner template parameter of JacobiSVD. */
+enum QRPreconditioners {
+  /** Do not specify what is to be done if the SVD of a non-square matrix is asked for. */
+  NoQRPreconditioner,
+  /** Use a QR decomposition without pivoting as the first step. */
+  HouseholderQRPreconditioner,
+  /** Use a QR decomposition with column pivoting as the first step. */
+  ColPivHouseholderQRPreconditioner,
+  /** Use a QR decomposition with full pivoting as the first step. */
+  FullPivHouseholderQRPreconditioner
+};
+
+#ifdef Success
+#error The preprocessor symbol 'Success' is defined, possibly by the X11 header file X.h
+#endif
+
+/** \ingroup enums
+  * Enum for reporting the status of a computation. */
+enum ComputationInfo {
+  /** Computation was successful. */
+  Success = 0,        
+  /** The provided data did not satisfy the prerequisites. */
+  NumericalIssue = 1, 
+  /** Iterative procedure did not converge. */
+  NoConvergence = 2,
+  /** The inputs are invalid, or the algorithm has been improperly called.
+    * When assertions are enabled, such errors trigger an assert. */
+  InvalidInput = 3
+};
+
+/** \ingroup enums
+  * Enum used to specify how a particular transformation is stored in a matrix.
+  * \sa Transform, Hyperplane::transform(). */
+enum TransformTraits {
+  /** Transformation is an isometry. */
+  Isometry      = 0x1,
+  /** Transformation is an affine transformation stored as a (Dim+1)^2 matrix whose last row is 
+    * assumed to be [0 ... 0 1]. */
+  Affine        = 0x2,
+  /** Transformation is an affine transformation stored as a (Dim) x (Dim+1) matrix. */
+  AffineCompact = 0x10 | Affine,
+  /** Transformation is a general projective transformation stored as a (Dim+1)^2 matrix. */
+  Projective    = 0x20
+};
+
+/** \internal \ingroup enums
+  * Enum used to choose between implementation depending on the computer architecture. */
+namespace Architecture
+{
+  enum Type {
+    Generic = 0x0,
+    SSE = 0x1,
+    AltiVec = 0x2,
+    VSX = 0x3,
+    NEON = 0x4,
+    MSA = 0x5,
+    SVE = 0x6,
+#if defined EIGEN_VECTORIZE_SSE
+    Target = SSE
+#elif defined EIGEN_VECTORIZE_ALTIVEC
+    Target = AltiVec
+#elif defined EIGEN_VECTORIZE_VSX
+    Target = VSX
+#elif defined EIGEN_VECTORIZE_NEON
+    Target = NEON
+#elif defined EIGEN_VECTORIZE_SVE
+    Target = SVE
+#elif defined EIGEN_VECTORIZE_MSA
+    Target = MSA
+#else
+    Target = Generic
+#endif
+  };
+}
+
+/** \internal \ingroup enums
+  * Enum used as template parameter in Product and product evaluators. */
+enum ProductImplType
+{ DefaultProduct=0, LazyProduct, AliasFreeProduct, CoeffBasedProductMode, LazyCoeffBasedProductMode, OuterProduct, InnerProduct, GemvProduct, GemmProduct };
+
+/** \internal \ingroup enums
+  * Enum used in experimental parallel implementation. */
+enum Action {GetAction, SetAction};
+
+/** The type used to identify a dense storage. */
+struct Dense {};
+
+/** The type used to identify a general sparse storage. */
+struct Sparse {};
+
+/** The type used to identify a general solver (factored) storage. */
+struct SolverStorage {};
+
+/** The type used to identify a permutation storage. */
+struct PermutationStorage {};
+
+/** The type used to identify a permutation storage. */
+struct TranspositionsStorage {};
+
+/** The type used to identify a matrix expression */
+struct MatrixXpr {};
+
+/** The type used to identify an array expression */
+struct ArrayXpr {};
+
+// An evaluator must define its shape. By default, it can be one of the following:
+struct DenseShape             { static std::string debugName() { return "DenseShape"; } };
+struct SolverShape            { static std::string debugName() { return "SolverShape"; } };
+struct HomogeneousShape       { static std::string debugName() { return "HomogeneousShape"; } };
+struct DiagonalShape          { static std::string debugName() { return "DiagonalShape"; } };
+struct BandShape              { static std::string debugName() { return "BandShape"; } };
+struct TriangularShape        { static std::string debugName() { return "TriangularShape"; } };
+struct SelfAdjointShape       { static std::string debugName() { return "SelfAdjointShape"; } };
+struct PermutationShape       { static std::string debugName() { return "PermutationShape"; } };
+struct TranspositionsShape    { static std::string debugName() { return "TranspositionsShape"; } };
+struct SparseShape            { static std::string debugName() { return "SparseShape"; } };
+
+namespace internal {
+
+  // random access iterators based on coeff*() accessors.
+struct IndexBased {};
+
+// evaluator based on iterators to access coefficients. 
+struct IteratorBased {};
+
+/** \internal
+ * Constants for comparison functors
+ */
+enum ComparisonName {
+  cmp_EQ = 0,
+  cmp_LT = 1,
+  cmp_LE = 2,
+  cmp_UNORD = 3,
+  cmp_NEQ = 4,
+  cmp_GT = 5,
+  cmp_GE = 6
+};
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_CONSTANTS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/DisableStupidWarnings.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/DisableStupidWarnings.h
new file mode 100644
index 00000000..fe0cfec0
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/DisableStupidWarnings.h
@@ -0,0 +1,106 @@
+#ifndef EIGEN_WARNINGS_DISABLED
+#define EIGEN_WARNINGS_DISABLED
+
+#ifdef _MSC_VER
+  // 4100 - unreferenced formal parameter (occurred e.g. in aligned_allocator::destroy(pointer p))
+  // 4101 - unreferenced local variable
+  // 4181 - qualifier applied to reference type ignored
+  // 4211 - nonstandard extension used : redefined extern to static
+  // 4244 - 'argument' : conversion from 'type1' to 'type2', possible loss of data
+  // 4273 - QtAlignedMalloc, inconsistent DLL linkage
+  // 4324 - structure was padded due to declspec(align())
+  // 4503 - decorated name length exceeded, name was truncated
+  // 4512 - assignment operator could not be generated
+  // 4522 - 'class' : multiple assignment operators specified
+  // 4700 - uninitialized local variable 'xyz' used
+  // 4714 - function marked as __forceinline not inlined
+  // 4717 - 'function' : recursive on all control paths, function will cause runtime stack overflow
+  // 4800 - 'type' : forcing value to bool 'true' or 'false' (performance warning)
+  #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+    #pragma warning( push )
+  #endif
+  #pragma warning( disable : 4100 4101 4181 4211 4244 4273 4324 4503 4512 4522 4700 4714 4717 4800)
+
+#elif defined __INTEL_COMPILER
+  // 2196 - routine is both "inline" and "noinline" ("noinline" assumed)
+  //        ICC 12 generates this warning even without any inline keyword, when defining class methods 'inline' i.e. inside of class body
+  //        typedef that may be a reference type.
+  // 279  - controlling expression is constant
+  //        ICC 12 generates this warning on assert(constant_expression_depending_on_template_params) and frankly this is a legitimate use case.
+  // 1684 - conversion from pointer to same-sized integral type (potential portability problem)
+  // 2259 - non-pointer conversion from "Eigen::Index={ptrdiff_t={long}}" to "int" may lose significant bits
+  #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+    #pragma warning push
+  #endif
+  #pragma warning disable 2196 279 1684 2259
+
+#elif defined __clang__
+  // -Wconstant-logical-operand - warning: use of logical && with constant operand; switch to bitwise & or remove constant
+  //     this is really a stupid warning as it warns on compile-time expressions involving enums
+  #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+    #pragma clang diagnostic push
+  #endif
+  #pragma clang diagnostic ignored "-Wconstant-logical-operand"
+  #if __clang_major__ >= 3 && __clang_minor__ >= 5
+    #pragma clang diagnostic ignored "-Wabsolute-value"
+  #endif
+  #if __clang_major__ >= 10
+    #pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
+  #endif
+  #if ( defined(__ALTIVEC__) || defined(__VSX__) ) && __cplusplus < 201103L
+    // warning: generic selections are a C11-specific feature
+    // ignoring warnings thrown at vec_ctf in Altivec/PacketMath.h
+    #pragma clang diagnostic ignored "-Wc11-extensions"
+  #endif
+
+#elif defined __GNUC__
+
+  #if (!defined(EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS)) &&  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+    #pragma GCC diagnostic push
+  #endif
+  // g++ warns about local variables shadowing member functions, which is too strict
+  #pragma GCC diagnostic ignored "-Wshadow"
+  #if __GNUC__ == 4 && __GNUC_MINOR__ < 8
+    // Until g++-4.7 there are warnings when comparing unsigned int vs 0, even in templated functions:
+    #pragma GCC diagnostic ignored "-Wtype-limits"
+  #endif
+  #if __GNUC__>=6
+    #pragma GCC diagnostic ignored "-Wignored-attributes"
+  #endif
+  #if __GNUC__==7
+    // See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89325
+    #pragma GCC diagnostic ignored "-Wattributes"
+  #endif
+#endif
+
+#if defined __NVCC__
+  #pragma diag_suppress boolean_controlling_expr_is_constant
+  // Disable the "statement is unreachable" message
+  #pragma diag_suppress code_is_unreachable
+  // Disable the "dynamic initialization in unreachable code" message
+  #pragma diag_suppress initialization_not_reachable
+  // Disable the "invalid error number" message that we get with older versions of nvcc
+  #pragma diag_suppress 1222
+  // Disable the "calling a __host__ function from a __host__ __device__ function is not allowed" messages (yes, there are many of them and they seem to change with every version of the compiler)
+  #pragma diag_suppress 2527
+  #pragma diag_suppress 2529
+  #pragma diag_suppress 2651
+  #pragma diag_suppress 2653
+  #pragma diag_suppress 2668
+  #pragma diag_suppress 2669
+  #pragma diag_suppress 2670
+  #pragma diag_suppress 2671
+  #pragma diag_suppress 2735
+  #pragma diag_suppress 2737
+  #pragma diag_suppress 2739
+#endif
+
+#else
+// warnings already disabled:
+# ifndef EIGEN_WARNINGS_DISABLED_2
+#  define EIGEN_WARNINGS_DISABLED_2
+# elif defined(EIGEN_INTERNAL_DEBUGGING)
+#  error "Do not include \"DisableStupidWarnings.h\" recursively more than twice!"
+# endif
+
+#endif // not EIGEN_WARNINGS_DISABLED
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/ForwardDeclarations.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/ForwardDeclarations.h
new file mode 100644
index 00000000..2f9cc449
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/ForwardDeclarations.h
@@ -0,0 +1,322 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FORWARDDECLARATIONS_H
+#define EIGEN_FORWARDDECLARATIONS_H
+
+namespace Eigen {
+namespace internal {
+
+template<typename T> struct traits;
+
+// here we say once and for all that traits<const T> == traits<T>
+// When constness must affect traits, it has to be constness on template parameters on which T itself depends.
+// For example, traits<Map<const T> > != traits<Map<T> >, but
+//              traits<const Map<T> > == traits<Map<T> >
+template<typename T> struct traits<const T> : traits<T> {};
+
+template<typename Derived> struct has_direct_access
+{
+  enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 };
+};
+
+template<typename Derived> struct accessors_level
+{
+  enum { has_direct_access = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0,
+         has_write_access = (traits<Derived>::Flags & LvalueBit) ? 1 : 0,
+         value = has_direct_access ? (has_write_access ? DirectWriteAccessors : DirectAccessors)
+                                   : (has_write_access ? WriteAccessors       : ReadOnlyAccessors)
+  };
+};
+
+template<typename T> struct evaluator_traits;
+
+template< typename T> struct evaluator;
+
+} // end namespace internal
+
+template<typename T> struct NumTraits;
+
+template<typename Derived> struct EigenBase;
+template<typename Derived> class DenseBase;
+template<typename Derived> class PlainObjectBase;
+template<typename Derived, int Level> class DenseCoeffsBase;
+
+template<typename _Scalar, int _Rows, int _Cols,
+         int _Options = AutoAlign |
+#if EIGEN_GNUC_AT(3,4)
+    // workaround a bug in at least gcc 3.4.6
+    // the innermost ?: ternary operator is misparsed. We write it slightly
+    // differently and this makes gcc 3.4.6 happy, but it's ugly.
+    // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
+    // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
+                          : Eigen::ColMajor ),
+#else
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor
+                          : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
+#endif
+         int _MaxRows = _Rows,
+         int _MaxCols = _Cols
+> class Matrix;
+
+template<typename Derived> class MatrixBase;
+template<typename Derived> class ArrayBase;
+
+template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged;
+template<typename ExpressionType, template <typename> class StorageBase > class NoAlias;
+template<typename ExpressionType> class NestByValue;
+template<typename ExpressionType> class ForceAlignedAccess;
+template<typename ExpressionType> class SwapWrapper;
+
+template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false> class Block;
+template<typename XprType, typename RowIndices, typename ColIndices> class IndexedView;
+template<typename XprType, int Rows=Dynamic, int Cols=Dynamic, int Order=0> class Reshaped;
+
+template<typename MatrixType, int Size=Dynamic> class VectorBlock;
+template<typename MatrixType> class Transpose;
+template<typename MatrixType> class Conjugate;
+template<typename NullaryOp, typename MatrixType>         class CwiseNullaryOp;
+template<typename UnaryOp,   typename MatrixType>         class CwiseUnaryOp;
+template<typename ViewOp,    typename MatrixType>         class CwiseUnaryView;
+template<typename BinaryOp,  typename Lhs, typename Rhs>  class CwiseBinaryOp;
+template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>  class CwiseTernaryOp;
+template<typename Decomposition, typename Rhstype>        class Solve;
+template<typename XprType>                                class Inverse;
+
+template<typename Lhs, typename Rhs, int Option = DefaultProduct> class Product;
+
+template<typename Derived> class DiagonalBase;
+template<typename _DiagonalVectorType> class DiagonalWrapper;
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
+template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
+template<typename MatrixType, int Index = 0> class Diagonal;
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix;
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions;
+template<typename Derived> class PermutationBase;
+template<typename Derived> class TranspositionsBase;
+template<typename _IndicesType> class PermutationWrapper;
+template<typename _IndicesType> class TranspositionsWrapper;
+
+template<typename Derived,
+         int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
+> class MapBase;
+template<int OuterStrideAtCompileTime, int InnerStrideAtCompileTime> class Stride;
+template<int Value = Dynamic> class InnerStride;
+template<int Value = Dynamic> class OuterStride;
+template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map;
+template<typename Derived> class RefBase;
+template<typename PlainObjectType, int Options = 0,
+         typename StrideType = typename internal::conditional<PlainObjectType::IsVectorAtCompileTime,InnerStride<1>,OuterStride<> >::type > class Ref;
+
+template<typename Derived> class TriangularBase;
+template<typename MatrixType, unsigned int Mode> class TriangularView;
+template<typename MatrixType, unsigned int Mode> class SelfAdjointView;
+template<typename MatrixType> class SparseView;
+template<typename ExpressionType> class WithFormat;
+template<typename MatrixType> struct CommaInitializer;
+template<typename Derived> class ReturnByValue;
+template<typename ExpressionType> class ArrayWrapper;
+template<typename ExpressionType> class MatrixWrapper;
+template<typename Derived> class SolverBase;
+template<typename XprType> class InnerIterator;
+
+namespace internal {
+template<typename XprType> class generic_randaccess_stl_iterator;
+template<typename XprType> class pointer_based_stl_iterator;
+template<typename XprType, DirectionType Direction> class subvector_stl_iterator;
+template<typename XprType, DirectionType Direction> class subvector_stl_reverse_iterator;
+template<typename DecompositionType> struct kernel_retval_base;
+template<typename DecompositionType> struct kernel_retval;
+template<typename DecompositionType> struct image_retval_base;
+template<typename DecompositionType> struct image_retval;
+} // end namespace internal
+
+namespace internal {
+template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix;
+}
+
+namespace internal {
+template<typename Lhs, typename Rhs> struct product_type;
+
+template<bool> struct EnableIf;
+
+/** \internal
+  * \class product_evaluator
+  * Products need their own evaluator with more template arguments allowing for
+  * easier partial template specializations.
+  */
+template< typename T,
+          int ProductTag = internal::product_type<typename T::Lhs,typename T::Rhs>::ret,
+          typename LhsShape = typename evaluator_traits<typename T::Lhs>::Shape,
+          typename RhsShape = typename evaluator_traits<typename T::Rhs>::Shape,
+          typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
+          typename RhsScalar = typename traits<typename T::Rhs>::Scalar
+        > struct product_evaluator;
+}
+
+template<typename Lhs, typename Rhs,
+         int ProductType = internal::product_type<Lhs,Rhs>::value>
+struct ProductReturnType;
+
+// this is a workaround for sun CC
+template<typename Lhs, typename Rhs> struct LazyProductReturnType;
+
+namespace internal {
+
+// Provides scalar/packet-wise product and product with accumulation
+// with optional conjugation of the arguments.
+template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
+
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_sum_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_difference_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_conj_product_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar, int NaNPropagation=PropagateFast> struct scalar_min_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar, int NaNPropagation=PropagateFast> struct scalar_max_op;
+template<typename Scalar> struct scalar_opposite_op;
+template<typename Scalar> struct scalar_conjugate_op;
+template<typename Scalar> struct scalar_real_op;
+template<typename Scalar> struct scalar_imag_op;
+template<typename Scalar> struct scalar_abs_op;
+template<typename Scalar> struct scalar_abs2_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_absolute_difference_op;
+template<typename Scalar> struct scalar_sqrt_op;
+template<typename Scalar> struct scalar_rsqrt_op;
+template<typename Scalar> struct scalar_exp_op;
+template<typename Scalar> struct scalar_log_op;
+template<typename Scalar> struct scalar_cos_op;
+template<typename Scalar> struct scalar_sin_op;
+template<typename Scalar> struct scalar_acos_op;
+template<typename Scalar> struct scalar_asin_op;
+template<typename Scalar> struct scalar_tan_op;
+template<typename Scalar> struct scalar_inverse_op;
+template<typename Scalar> struct scalar_square_op;
+template<typename Scalar> struct scalar_cube_op;
+template<typename Scalar, typename NewType> struct scalar_cast_op;
+template<typename Scalar> struct scalar_random_op;
+template<typename Scalar> struct scalar_constant_op;
+template<typename Scalar> struct scalar_identity_op;
+template<typename Scalar,bool is_complex, bool is_integer> struct scalar_sign_op;
+template<typename Scalar,typename ScalarExponent> struct scalar_pow_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_hypot_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_quotient_op;
+
+// SpecialFunctions module
+template<typename Scalar> struct scalar_lgamma_op;
+template<typename Scalar> struct scalar_digamma_op;
+template<typename Scalar> struct scalar_erf_op;
+template<typename Scalar> struct scalar_erfc_op;
+template<typename Scalar> struct scalar_ndtri_op;
+template<typename Scalar> struct scalar_igamma_op;
+template<typename Scalar> struct scalar_igammac_op;
+template<typename Scalar> struct scalar_zeta_op;
+template<typename Scalar> struct scalar_betainc_op;
+
+// Bessel functions in SpecialFunctions module
+template<typename Scalar> struct scalar_bessel_i0_op;
+template<typename Scalar> struct scalar_bessel_i0e_op;
+template<typename Scalar> struct scalar_bessel_i1_op;
+template<typename Scalar> struct scalar_bessel_i1e_op;
+template<typename Scalar> struct scalar_bessel_j0_op;
+template<typename Scalar> struct scalar_bessel_y0_op;
+template<typename Scalar> struct scalar_bessel_j1_op;
+template<typename Scalar> struct scalar_bessel_y1_op;
+template<typename Scalar> struct scalar_bessel_k0_op;
+template<typename Scalar> struct scalar_bessel_k0e_op;
+template<typename Scalar> struct scalar_bessel_k1_op;
+template<typename Scalar> struct scalar_bessel_k1e_op;
+
+
+} // end namespace internal
+
+struct IOFormat;
+
+// Array module
+template<typename _Scalar, int _Rows, int _Cols,
+         int _Options = AutoAlign |
+#if EIGEN_GNUC_AT(3,4)
+    // workaround a bug in at least gcc 3.4.6
+    // the innermost ?: ternary operator is misparsed. We write it slightly
+    // differently and this makes gcc 3.4.6 happy, but it's ugly.
+    // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
+    // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
+                          : Eigen::ColMajor ),
+#else
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor
+                          : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
+#endif
+         int _MaxRows = _Rows, int _MaxCols = _Cols> class Array;
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select;
+template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
+template<typename ExpressionType, int Direction> class VectorwiseOp;
+template<typename MatrixType,int RowFactor,int ColFactor> class Replicate;
+template<typename MatrixType, int Direction = BothDirections> class Reverse;
+
+template<typename MatrixType> class FullPivLU;
+template<typename MatrixType> class PartialPivLU;
+namespace internal {
+template<typename MatrixType> struct inverse_impl;
+}
+template<typename MatrixType> class HouseholderQR;
+template<typename MatrixType> class ColPivHouseholderQR;
+template<typename MatrixType> class FullPivHouseholderQR;
+template<typename MatrixType> class CompleteOrthogonalDecomposition;
+template<typename MatrixType> class SVDBase;
+template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD;
+template<typename MatrixType> class BDCSVD;
+template<typename MatrixType, int UpLo = Lower> class LLT;
+template<typename MatrixType, int UpLo = Lower> class LDLT;
+template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence;
+template<typename Scalar>     class JacobiRotation;
+
+// Geometry module:
+template<typename Derived, int _Dim> class RotationBase;
+template<typename Lhs, typename Rhs> class Cross;
+template<typename Derived> class QuaternionBase;
+template<typename Scalar> class Rotation2D;
+template<typename Scalar> class AngleAxis;
+template<typename Scalar,int Dim> class Translation;
+template<typename Scalar,int Dim> class AlignedBox;
+template<typename Scalar, int Options = AutoAlign> class Quaternion;
+template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform;
+template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine;
+template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane;
+template<typename Scalar> class UniformScaling;
+template<typename MatrixType,int Direction> class Homogeneous;
+
+// Sparse module:
+template<typename Derived> class SparseMatrixBase;
+
+// MatrixFunctions module
+template<typename Derived> struct MatrixExponentialReturnValue;
+template<typename Derived> class MatrixFunctionReturnValue;
+template<typename Derived> class MatrixSquareRootReturnValue;
+template<typename Derived> class MatrixLogarithmReturnValue;
+template<typename Derived> class MatrixPowerReturnValue;
+template<typename Derived> class MatrixComplexPowerReturnValue;
+
+namespace internal {
+template <typename Scalar>
+struct stem_function
+{
+  typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
+  typedef ComplexScalar type(ComplexScalar, int);
+};
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FORWARDDECLARATIONS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/IndexedViewHelper.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/IndexedViewHelper.h
new file mode 100644
index 00000000..f85de305
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/IndexedViewHelper.h
@@ -0,0 +1,186 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_INDEXED_VIEW_HELPER_H
+#define EIGEN_INDEXED_VIEW_HELPER_H
+
+namespace Eigen {
+
+namespace internal {
+struct symbolic_last_tag {};
+}
+
+/** \var last
+  * \ingroup Core_Module
+  *
+  * Can be used as a parameter to Eigen::seq and Eigen::seqN functions to symbolically reference the last element/row/columns
+  * of the underlying vector or matrix once passed to DenseBase::operator()(const RowIndices&, const ColIndices&).
+  *
+  * This symbolic placeholder supports standard arithmetic operations.
+  *
+  * A typical usage example would be:
+  * \code
+  * using namespace Eigen;
+  * using Eigen::last;
+  * VectorXd v(n);
+  * v(seq(2,last-2)).setOnes();
+  * \endcode
+  *
+  * \sa end
+  */
+static const symbolic::SymbolExpr<internal::symbolic_last_tag> last; // PLEASE use Eigen::last   instead of Eigen::placeholders::last
+
+/** \var lastp1
+  * \ingroup Core_Module
+  *
+  * Can be used as a parameter to Eigen::seq and Eigen::seqN functions to symbolically
+  * reference the last+1 element/row/columns of the underlying vector or matrix once
+  * passed to DenseBase::operator()(const RowIndices&, const ColIndices&).
+  *
+  * This symbolic placeholder supports standard arithmetic operations.
+  * It is essentially an alias to last+fix<1>.
+  *
+  * \sa last
+  */
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+static const auto lastp1 = last+fix<1>;
+#else
+// Using a FixedExpr<1> expression is important here to make sure the compiler
+// can fully optimize the computation starting indices with zero overhead.
+static const symbolic::AddExpr<symbolic::SymbolExpr<internal::symbolic_last_tag>,symbolic::ValueExpr<Eigen::internal::FixedInt<1> > > lastp1(last+fix<1>());
+#endif
+
+namespace internal {
+
+ // Replace symbolic last/end "keywords" by their true runtime value
+inline Index eval_expr_given_size(Index x, Index /* size */)   { return x; }
+
+template<int N>
+FixedInt<N> eval_expr_given_size(FixedInt<N> x, Index /*size*/)   { return x; }
+
+template<typename Derived>
+Index eval_expr_given_size(const symbolic::BaseExpr<Derived> &x, Index size)
+{
+  return x.derived().eval(last=size-1);
+}
+
+// Extract increment/step at compile time
+template<typename T, typename EnableIf = void> struct get_compile_time_incr {
+  enum { value = UndefinedIncr };
+};
+
+// Analogue of std::get<0>(x), but tailored for our needs.
+template<typename T>
+EIGEN_CONSTEXPR Index first(const T& x) EIGEN_NOEXCEPT { return x.first(); }
+
+// IndexedViewCompatibleType/makeIndexedViewCompatible turn an arbitrary object of type T into something usable by MatrixSlice
+// The generic implementation is a no-op
+template<typename T,int XprSize,typename EnableIf=void>
+struct IndexedViewCompatibleType {
+  typedef T type;
+};
+
+template<typename T,typename Q>
+const T& makeIndexedViewCompatible(const T& x, Index /*size*/, Q) { return x; }
+
+//--------------------------------------------------------------------------------
+// Handling of a single Index
+//--------------------------------------------------------------------------------
+
+struct SingleRange {
+  enum {
+    SizeAtCompileTime = 1
+  };
+  SingleRange(Index val) : m_value(val) {}
+  Index operator[](Index) const { return m_value; }
+  static EIGEN_CONSTEXPR Index size() EIGEN_NOEXCEPT { return 1; }
+  Index first() const EIGEN_NOEXCEPT { return m_value; }
+  Index m_value;
+};
+
+template<> struct get_compile_time_incr<SingleRange> {
+  enum { value = 1 }; // 1 or 0 ??
+};
+
+// Turn a single index into something that looks like an array (i.e., that exposes a .size(), and operator[](int) methods)
+template<typename T, int XprSize>
+struct IndexedViewCompatibleType<T,XprSize,typename internal::enable_if<internal::is_integral<T>::value>::type> {
+  // Here we could simply use Array, but maybe it's less work for the compiler to use
+  // a simpler wrapper as SingleRange
+  //typedef Eigen::Array<Index,1,1> type;
+  typedef SingleRange type;
+};
+
+template<typename T, int XprSize>
+struct IndexedViewCompatibleType<T, XprSize, typename enable_if<symbolic::is_symbolic<T>::value>::type> {
+  typedef SingleRange type;
+};
+
+
+template<typename T>
+typename enable_if<symbolic::is_symbolic<T>::value,SingleRange>::type
+makeIndexedViewCompatible(const T& id, Index size, SpecializedType) {
+  return eval_expr_given_size(id,size);
+}
+
+//--------------------------------------------------------------------------------
+// Handling of all
+//--------------------------------------------------------------------------------
+
+struct all_t { all_t() {} };
+
+// Convert a symbolic 'all' into a usable range type
+template<int XprSize>
+struct AllRange {
+  enum { SizeAtCompileTime = XprSize };
+  AllRange(Index size = XprSize) : m_size(size) {}
+  EIGEN_CONSTEXPR Index operator[](Index i) const EIGEN_NOEXCEPT { return i; }
+  EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT { return m_size.value(); }
+  EIGEN_CONSTEXPR Index first() const EIGEN_NOEXCEPT { return 0; }
+  variable_if_dynamic<Index,XprSize> m_size;
+};
+
+template<int XprSize>
+struct IndexedViewCompatibleType<all_t,XprSize> {
+  typedef AllRange<XprSize> type;
+};
+
+template<typename XprSizeType>
+inline AllRange<get_fixed_value<XprSizeType>::value> makeIndexedViewCompatible(all_t , XprSizeType size, SpecializedType) {
+  return AllRange<get_fixed_value<XprSizeType>::value>(size);
+}
+
+template<int Size> struct get_compile_time_incr<AllRange<Size> > {
+  enum { value = 1 };
+};
+
+} // end namespace internal
+
+
+/** \var all
+  * \ingroup Core_Module
+  * Can be used as a parameter to DenseBase::operator()(const RowIndices&, const ColIndices&) to index all rows or columns
+  */
+static const Eigen::internal::all_t all; // PLEASE use Eigen::all instead of Eigen::placeholders::all
+
+
+namespace placeholders {
+  typedef symbolic::SymbolExpr<internal::symbolic_last_tag> last_t;
+  typedef symbolic::AddExpr<symbolic::SymbolExpr<internal::symbolic_last_tag>,symbolic::ValueExpr<Eigen::internal::FixedInt<1> > > end_t;
+  typedef Eigen::internal::all_t all_t;
+
+  EIGEN_DEPRECATED static const all_t  all  = Eigen::all;    // PLEASE use Eigen::all    instead of Eigen::placeholders::all
+  EIGEN_DEPRECATED static const last_t last = Eigen::last;   // PLEASE use Eigen::last   instead of Eigen::placeholders::last
+  EIGEN_DEPRECATED static const end_t  end  = Eigen::lastp1; // PLEASE use Eigen::lastp1 instead of Eigen::placeholders::end
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_INDEXED_VIEW_HELPER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/IntegralConstant.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/IntegralConstant.h
new file mode 100644
index 00000000..945d426e
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/IntegralConstant.h
@@ -0,0 +1,272 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_INTEGRAL_CONSTANT_H
+#define EIGEN_INTEGRAL_CONSTANT_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<int N> class FixedInt;
+template<int N> class VariableAndFixedInt;
+
+/** \internal
+  * \class FixedInt
+  *
+  * This class embeds a compile-time integer \c N.
+  *
+  * It is similar to c++11 std::integral_constant<int,N> but with some additional features
+  * such as:
+  *  - implicit conversion to int
+  *  - arithmetic and some bitwise operators: -, +, *, /, %, &, |
+  *  - c++98/14 compatibility with fix<N> and fix<N>() syntax to define integral constants.
+  *
+  * It is strongly discouraged to directly deal with this class FixedInt. Instances are expcected to
+  * be created by the user using Eigen::fix<N> or Eigen::fix<N>(). In C++98-11, the former syntax does
+  * not create a FixedInt<N> instance but rather a point to function that needs to be \em cleaned-up
+  * using the generic helper:
+  * \code
+  * internal::cleanup_index_type<T>::type
+  * internal::cleanup_index_type<T,DynamicKey>::type
+  * \endcode
+  * where T can a FixedInt<N>, a pointer to function FixedInt<N> (*)(), or numerous other integer-like representations.
+  * \c DynamicKey is either Dynamic (default) or DynamicIndex and used to identify true compile-time values.
+  *
+  * For convenience, you can extract the compile-time value \c N in a generic way using the following helper:
+  * \code
+  * internal::get_fixed_value<T,DefaultVal>::value
+  * \endcode
+  * that will give you \c N if T equals FixedInt<N> or FixedInt<N> (*)(), and \c DefaultVal if T does not embed any compile-time value (e.g., T==int).
+  *
+  * \sa fix<N>, class VariableAndFixedInt
+  */
+template<int N> class FixedInt
+{
+public:
+  static const int value = N;
+  EIGEN_CONSTEXPR operator int() const { return value; }
+  FixedInt() {}
+  FixedInt( VariableAndFixedInt<N> other) {
+    #ifndef EIGEN_INTERNAL_DEBUGGING
+    EIGEN_UNUSED_VARIABLE(other);
+    #endif
+    eigen_internal_assert(int(other)==N);
+  }
+
+  FixedInt<-N> operator-() const { return FixedInt<-N>(); }
+  template<int M>
+  FixedInt<N+M> operator+( FixedInt<M>) const { return FixedInt<N+M>(); }
+  template<int M>
+  FixedInt<N-M> operator-( FixedInt<M>) const { return FixedInt<N-M>(); }
+  template<int M>
+  FixedInt<N*M> operator*( FixedInt<M>) const { return FixedInt<N*M>(); }
+  template<int M>
+  FixedInt<N/M> operator/( FixedInt<M>) const { return FixedInt<N/M>(); }
+  template<int M>
+  FixedInt<N%M> operator%( FixedInt<M>) const { return FixedInt<N%M>(); }
+  template<int M>
+  FixedInt<N|M> operator|( FixedInt<M>) const { return FixedInt<N|M>(); }
+  template<int M>
+  FixedInt<N&M> operator&( FixedInt<M>) const { return FixedInt<N&M>(); }
+
+#if EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
+  // Needed in C++14 to allow fix<N>():
+  FixedInt operator() () const { return *this; }
+
+  VariableAndFixedInt<N> operator() (int val) const { return VariableAndFixedInt<N>(val); }
+#else
+  FixedInt ( FixedInt<N> (*)() ) {}
+#endif
+
+#if EIGEN_HAS_CXX11
+  FixedInt(std::integral_constant<int,N>) {}
+#endif
+};
+
+/** \internal
+  * \class VariableAndFixedInt
+  *
+  * This class embeds both a compile-time integer \c N and a runtime integer.
+  * Both values are supposed to be equal unless the compile-time value \c N has a special
+  * value meaning that the runtime-value should be used. Depending on the context, this special
+  * value can be either Eigen::Dynamic (for positive quantities) or Eigen::DynamicIndex (for
+  * quantities that can be negative).
+  *
+  * It is the return-type of the function Eigen::fix<N>(int), and most of the time this is the only
+  * way it is used. It is strongly discouraged to directly deal with instances of VariableAndFixedInt.
+  * Indeed, in order to write generic code, it is the responsibility of the callee to properly convert
+  * it to either a true compile-time quantity (i.e. a FixedInt<N>), or to a runtime quantity (e.g., an Index)
+  * using the following generic helper:
+  * \code
+  * internal::cleanup_index_type<T>::type
+  * internal::cleanup_index_type<T,DynamicKey>::type
+  * \endcode
+  * where T can be a template instantiation of VariableAndFixedInt or numerous other integer-like representations.
+  * \c DynamicKey is either Dynamic (default) or DynamicIndex and used to identify true compile-time values.
+  *
+  * For convenience, you can also extract the compile-time value \c N using the following helper:
+  * \code
+  * internal::get_fixed_value<T,DefaultVal>::value
+  * \endcode
+  * that will give you \c N if T equals VariableAndFixedInt<N>, and \c DefaultVal if T does not embed any compile-time value (e.g., T==int).
+  *
+  * \sa fix<N>(int), class FixedInt
+  */
+template<int N> class VariableAndFixedInt
+{
+public:
+  static const int value = N;
+  operator int() const { return m_value; }
+  VariableAndFixedInt(int val) { m_value = val; }
+protected:
+  int m_value;
+};
+
+template<typename T, int Default=Dynamic> struct get_fixed_value {
+  static const int value = Default;
+};
+
+template<int N,int Default> struct get_fixed_value<FixedInt<N>,Default> {
+  static const int value = N;
+};
+
+#if !EIGEN_HAS_CXX14
+template<int N,int Default> struct get_fixed_value<FixedInt<N> (*)(),Default> {
+  static const int value = N;
+};
+#endif
+
+template<int N,int Default> struct get_fixed_value<VariableAndFixedInt<N>,Default> {
+  static const int value = N ;
+};
+
+template<typename T, int N, int Default>
+struct get_fixed_value<variable_if_dynamic<T,N>,Default> {
+  static const int value = N;
+};
+
+template<typename T> EIGEN_DEVICE_FUNC Index get_runtime_value(const T &x) { return x; }
+#if !EIGEN_HAS_CXX14
+template<int N> EIGEN_DEVICE_FUNC Index get_runtime_value(FixedInt<N> (*)()) { return N; }
+#endif
+
+// Cleanup integer/FixedInt/VariableAndFixedInt/etc types:
+
+// By default, no cleanup:
+template<typename T, int DynamicKey=Dynamic, typename EnableIf=void> struct cleanup_index_type { typedef T type; };
+
+// Convert any integral type (e.g., short, int, unsigned int, etc.) to Eigen::Index
+template<typename T, int DynamicKey> struct cleanup_index_type<T,DynamicKey,typename internal::enable_if<internal::is_integral<T>::value>::type> { typedef Index type; };
+
+#if !EIGEN_HAS_CXX14
+// In c++98/c++11, fix<N> is a pointer to function that we better cleanup to a true FixedInt<N>:
+template<int N, int DynamicKey> struct cleanup_index_type<FixedInt<N> (*)(), DynamicKey> { typedef FixedInt<N> type; };
+#endif
+
+// If VariableAndFixedInt does not match DynamicKey, then we turn it to a pure compile-time value:
+template<int N, int DynamicKey> struct cleanup_index_type<VariableAndFixedInt<N>, DynamicKey> { typedef FixedInt<N> type; };
+// If VariableAndFixedInt matches DynamicKey, then we turn it to a pure runtime-value (aka Index):
+template<int DynamicKey> struct cleanup_index_type<VariableAndFixedInt<DynamicKey>, DynamicKey> { typedef Index type; };
+
+#if EIGEN_HAS_CXX11
+template<int N, int DynamicKey> struct cleanup_index_type<std::integral_constant<int,N>, DynamicKey> { typedef FixedInt<N> type; };
+#endif
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+#if EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
+template<int N>
+static const internal::FixedInt<N> fix{};
+#else
+template<int N>
+inline internal::FixedInt<N> fix() { return internal::FixedInt<N>(); }
+
+// The generic typename T is mandatory. Otherwise, a code like fix<N> could refer to either the function above or this next overload.
+// This way a code like fix<N> can only refer to the previous function.
+template<int N,typename T>
+inline internal::VariableAndFixedInt<N> fix(T val) { return internal::VariableAndFixedInt<N>(internal::convert_index<int>(val)); }
+#endif
+
+#else // EIGEN_PARSED_BY_DOXYGEN
+
+/** \var fix<N>()
+  * \ingroup Core_Module
+  *
+  * This \em identifier permits to construct an object embedding a compile-time integer \c N.
+  *
+  * \tparam N the compile-time integer value
+  *
+  * It is typically used in conjunction with the Eigen::seq and Eigen::seqN functions to pass compile-time values to them:
+  * \code
+  * seqN(10,fix<4>,fix<-3>)   // <=> [10 7 4 1]
+  * \endcode
+  *
+  * See also the function fix(int) to pass both a compile-time and runtime value.
+  *
+  * In c++14, it is implemented as:
+  * \code
+  * template<int N> static const internal::FixedInt<N> fix{};
+  * \endcode
+  * where internal::FixedInt<N> is an internal template class similar to
+  * <a href="http://en.cppreference.com/w/cpp/types/integral_constant">\c std::integral_constant </a><tt> <int,N> </tt>
+  * Here, \c fix<N> is thus an object of type \c internal::FixedInt<N>.
+  *
+  * In c++98/11, it is implemented as a function:
+  * \code
+  * template<int N> inline internal::FixedInt<N> fix();
+  * \endcode
+  * Here internal::FixedInt<N> is thus a pointer to function.
+  *
+  * If for some reason you want a true object in c++98 then you can write: \code fix<N>() \endcode which is also valid in c++14.
+  *
+  * \sa fix<N>(int), seq, seqN
+  */
+template<int N>
+static const auto fix();
+
+/** \fn fix<N>(int)
+  * \ingroup Core_Module
+  *
+  * This function returns an object embedding both a compile-time integer \c N, and a fallback runtime value \a val.
+  *
+  * \tparam N the compile-time integer value
+  * \param  val the fallback runtime integer value
+  *
+  * This function is a more general version of the \ref fix identifier/function that can be used in template code
+  * where the compile-time value could turn out to actually mean "undefined at compile-time". For positive integers
+  * such as a size or a dimension, this case is identified by Eigen::Dynamic, whereas runtime signed integers
+  * (e.g., an increment/stride) are identified as Eigen::DynamicIndex. In such a case, the runtime value \a val
+  * will be used as a fallback.
+  *
+  * A typical use case would be:
+  * \code
+  * template<typename Derived> void foo(const MatrixBase<Derived> &mat) {
+  *   const int N = Derived::RowsAtCompileTime==Dynamic ? Dynamic : Derived::RowsAtCompileTime/2;
+  *   const int n = mat.rows()/2;
+  *   ... mat( seqN(0,fix<N>(n) ) ...;
+  * }
+  * \endcode
+  * In this example, the function Eigen::seqN knows that the second argument is expected to be a size.
+  * If the passed compile-time value N equals Eigen::Dynamic, then the proxy object returned by fix will be dissmissed, and converted to an Eigen::Index of value \c n.
+  * Otherwise, the runtime-value \c n will be dissmissed, and the returned ArithmeticSequence will be of the exact same type as <tt> seqN(0,fix<N>) </tt>.
+  *
+  * \sa fix, seqN, class ArithmeticSequence
+  */
+template<int N>
+static const auto fix(int val);
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+} // end namespace Eigen
+
+#endif // EIGEN_INTEGRAL_CONSTANT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/MKL_support.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/MKL_support.h
new file mode 100644
index 00000000..17963fad
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/MKL_support.h
@@ -0,0 +1,137 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to Intel(R) MKL
+ *   Include file with common MKL declarations
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_MKL_SUPPORT_H
+#define EIGEN_MKL_SUPPORT_H
+
+#ifdef EIGEN_USE_MKL_ALL
+  #ifndef EIGEN_USE_BLAS
+    #define EIGEN_USE_BLAS
+  #endif
+  #ifndef EIGEN_USE_LAPACKE
+    #define EIGEN_USE_LAPACKE
+  #endif
+  #ifndef EIGEN_USE_MKL_VML
+    #define EIGEN_USE_MKL_VML
+  #endif
+#endif
+
+#ifdef EIGEN_USE_LAPACKE_STRICT
+  #define EIGEN_USE_LAPACKE
+#endif
+
+#if defined(EIGEN_USE_MKL_VML) && !defined(EIGEN_USE_MKL)
+  #define EIGEN_USE_MKL
+#endif
+
+
+#if defined EIGEN_USE_MKL
+#   if (!defined MKL_DIRECT_CALL) && (!defined EIGEN_MKL_NO_DIRECT_CALL)
+#       define MKL_DIRECT_CALL
+#       define MKL_DIRECT_CALL_JUST_SET
+#   endif
+#   include <mkl.h>
+/*Check IMKL version for compatibility: < 10.3 is not usable with Eigen*/
+#   ifndef INTEL_MKL_VERSION
+#       undef EIGEN_USE_MKL /* INTEL_MKL_VERSION is not even defined on older versions */
+#   elif INTEL_MKL_VERSION < 100305    /* the intel-mkl-103-release-notes say this was when the lapacke.h interface was added*/
+#       undef EIGEN_USE_MKL
+#   endif
+#   ifndef EIGEN_USE_MKL
+    /*If the MKL version is too old, undef everything*/
+#       undef   EIGEN_USE_MKL_ALL
+#       undef   EIGEN_USE_LAPACKE
+#       undef   EIGEN_USE_MKL_VML
+#       undef   EIGEN_USE_LAPACKE_STRICT
+#       undef   EIGEN_USE_LAPACKE
+#       ifdef   MKL_DIRECT_CALL_JUST_SET
+#           undef MKL_DIRECT_CALL
+#       endif
+#   endif
+#endif
+
+#if defined EIGEN_USE_MKL
+
+#define EIGEN_MKL_VML_THRESHOLD 128
+
+/* MKL_DOMAIN_BLAS, etc are defined only in 10.3 update 7 */
+/* MKL_BLAS, etc are not defined in 11.2 */
+#ifdef MKL_DOMAIN_ALL
+#define EIGEN_MKL_DOMAIN_ALL MKL_DOMAIN_ALL
+#else
+#define EIGEN_MKL_DOMAIN_ALL MKL_ALL
+#endif
+
+#ifdef MKL_DOMAIN_BLAS
+#define EIGEN_MKL_DOMAIN_BLAS MKL_DOMAIN_BLAS
+#else
+#define EIGEN_MKL_DOMAIN_BLAS MKL_BLAS
+#endif
+
+#ifdef MKL_DOMAIN_FFT
+#define EIGEN_MKL_DOMAIN_FFT MKL_DOMAIN_FFT
+#else
+#define EIGEN_MKL_DOMAIN_FFT MKL_FFT
+#endif
+
+#ifdef MKL_DOMAIN_VML
+#define EIGEN_MKL_DOMAIN_VML MKL_DOMAIN_VML
+#else
+#define EIGEN_MKL_DOMAIN_VML MKL_VML
+#endif
+
+#ifdef MKL_DOMAIN_PARDISO
+#define EIGEN_MKL_DOMAIN_PARDISO MKL_DOMAIN_PARDISO
+#else
+#define EIGEN_MKL_DOMAIN_PARDISO MKL_PARDISO
+#endif
+#endif
+
+#if defined(EIGEN_USE_BLAS) && !defined(EIGEN_USE_MKL)
+#include "../../misc/blas.h"
+#endif
+
+namespace Eigen {
+
+typedef std::complex<double> dcomplex;
+typedef std::complex<float>  scomplex;
+
+#if defined(EIGEN_USE_MKL)
+typedef MKL_INT BlasIndex;
+#else
+typedef int BlasIndex;
+#endif
+
+} // end namespace Eigen
+
+
+#endif // EIGEN_MKL_SUPPORT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/Macros.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/Macros.h
new file mode 100644
index 00000000..986c3d44
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/Macros.h
@@ -0,0 +1,1464 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MACROS_H
+#define EIGEN_MACROS_H
+
+//------------------------------------------------------------------------------------------
+// Eigen version and basic defaults
+//------------------------------------------------------------------------------------------
+
+#define EIGEN_WORLD_VERSION 3
+#define EIGEN_MAJOR_VERSION 4
+#define EIGEN_MINOR_VERSION 0
+
+#define EIGEN_VERSION_AT_LEAST(x,y,z) (EIGEN_WORLD_VERSION>x || (EIGEN_WORLD_VERSION>=x && \
+                                      (EIGEN_MAJOR_VERSION>y || (EIGEN_MAJOR_VERSION>=y && \
+                                                                 EIGEN_MINOR_VERSION>=z))))
+
+#ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
+#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION Eigen::RowMajor
+#else
+#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION Eigen::ColMajor
+#endif
+
+#ifndef EIGEN_DEFAULT_DENSE_INDEX_TYPE
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE std::ptrdiff_t
+#endif
+
+// Upperbound on the C++ version to use.
+// Expected values are 03, 11, 14, 17, etc.
+// By default, let's use an arbitrarily large C++ version.
+#ifndef EIGEN_MAX_CPP_VER
+#define EIGEN_MAX_CPP_VER 99
+#endif
+
+/** Allows to disable some optimizations which might affect the accuracy of the result.
+  * Such optimization are enabled by default, and set EIGEN_FAST_MATH to 0 to disable them.
+  * They currently include:
+  *   - single precision ArrayBase::sin() and ArrayBase::cos() for SSE and AVX vectorization.
+  */
+#ifndef EIGEN_FAST_MATH
+#define EIGEN_FAST_MATH 1
+#endif
+
+#ifndef EIGEN_STACK_ALLOCATION_LIMIT
+// 131072 == 128 KB
+#define EIGEN_STACK_ALLOCATION_LIMIT 131072
+#endif
+
+//------------------------------------------------------------------------------------------
+// Compiler identification, EIGEN_COMP_*
+//------------------------------------------------------------------------------------------
+
+/// \internal EIGEN_COMP_GNUC set to 1 for all compilers compatible with GCC
+#ifdef __GNUC__
+  #define EIGEN_COMP_GNUC (__GNUC__*10+__GNUC_MINOR__)
+#else
+  #define EIGEN_COMP_GNUC 0
+#endif
+
+/// \internal EIGEN_COMP_CLANG set to major+minor version (e.g., 307 for clang 3.7) if the compiler is clang
+#if defined(__clang__)
+  #define EIGEN_COMP_CLANG (__clang_major__*100+__clang_minor__)
+#else
+  #define EIGEN_COMP_CLANG 0
+#endif
+
+/// \internal EIGEN_COMP_CASTXML set to 1 if being preprocessed by CastXML
+#if defined(__castxml__)
+  #define EIGEN_COMP_CASTXML 1
+#else
+  #define EIGEN_COMP_CASTXML 0
+#endif
+
+/// \internal EIGEN_COMP_LLVM set to 1 if the compiler backend is llvm
+#if defined(__llvm__)
+  #define EIGEN_COMP_LLVM 1
+#else
+  #define EIGEN_COMP_LLVM 0
+#endif
+
+/// \internal EIGEN_COMP_ICC set to __INTEL_COMPILER if the compiler is Intel compiler, 0 otherwise
+#if defined(__INTEL_COMPILER)
+  #define EIGEN_COMP_ICC __INTEL_COMPILER
+#else
+  #define EIGEN_COMP_ICC 0
+#endif
+
+/// \internal EIGEN_COMP_MINGW set to 1 if the compiler is mingw
+#if defined(__MINGW32__)
+  #define EIGEN_COMP_MINGW 1
+#else
+  #define EIGEN_COMP_MINGW 0
+#endif
+
+/// \internal EIGEN_COMP_SUNCC set to 1 if the compiler is Solaris Studio
+#if defined(__SUNPRO_CC)
+  #define EIGEN_COMP_SUNCC 1
+#else
+  #define EIGEN_COMP_SUNCC 0
+#endif
+
+/// \internal EIGEN_COMP_MSVC set to _MSC_VER if the compiler is Microsoft Visual C++, 0 otherwise.
+#if defined(_MSC_VER)
+  #define EIGEN_COMP_MSVC _MSC_VER
+#else
+  #define EIGEN_COMP_MSVC 0
+#endif
+
+#if defined(__NVCC__)
+#if defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 9)
+  #define EIGEN_COMP_NVCC  ((__CUDACC_VER_MAJOR__ * 10000) + (__CUDACC_VER_MINOR__ * 100))
+#elif defined(__CUDACC_VER__)
+  #define EIGEN_COMP_NVCC __CUDACC_VER__
+#else
+  #error "NVCC did not define compiler version."
+#endif
+#else
+  #define EIGEN_COMP_NVCC 0
+#endif
+
+// For the record, here is a table summarizing the possible values for EIGEN_COMP_MSVC:
+//  name        ver   MSC_VER
+//  2008         9      1500
+//  2010        10      1600
+//  2012        11      1700
+//  2013        12      1800
+//  2015        14      1900
+//  "15"        15      1900
+//  2017-14.1   15.0    1910
+//  2017-14.11  15.3    1911
+//  2017-14.12  15.5    1912
+//  2017-14.13  15.6    1913
+//  2017-14.14  15.7    1914
+
+/// \internal EIGEN_COMP_MSVC_LANG set to _MSVC_LANG if the compiler is Microsoft Visual C++, 0 otherwise.
+#if defined(_MSVC_LANG)
+  #define EIGEN_COMP_MSVC_LANG _MSVC_LANG
+#else
+  #define EIGEN_COMP_MSVC_LANG 0
+#endif
+
+// For the record, here is a table summarizing the possible values for EIGEN_COMP_MSVC_LANG:
+// MSVC option                          Standard  MSVC_LANG
+// /std:c++14 (default as of VS 2019)   C++14     201402L
+// /std:c++17                           C++17     201703L
+// /std:c++latest                       >C++17    >201703L
+
+/// \internal EIGEN_COMP_MSVC_STRICT set to 1 if the compiler is really Microsoft Visual C++ and not ,e.g., ICC or clang-cl
+#if EIGEN_COMP_MSVC && !(EIGEN_COMP_ICC || EIGEN_COMP_LLVM || EIGEN_COMP_CLANG)
+  #define EIGEN_COMP_MSVC_STRICT _MSC_VER
+#else
+  #define EIGEN_COMP_MSVC_STRICT 0
+#endif
+
+/// \internal EIGEN_COMP_IBM set to xlc version if the compiler is IBM XL C++
+// XLC   version
+// 3.1   0x0301
+// 4.5   0x0405
+// 5.0   0x0500
+// 12.1  0x0C01
+#if defined(__IBMCPP__) || defined(__xlc__) || defined(__ibmxl__)
+  #define EIGEN_COMP_IBM __xlC__
+#else
+  #define EIGEN_COMP_IBM 0
+#endif
+
+/// \internal EIGEN_COMP_PGI set to PGI version if the compiler is Portland Group Compiler
+#if defined(__PGI)
+  #define EIGEN_COMP_PGI (__PGIC__*100+__PGIC_MINOR__)
+#else
+  #define EIGEN_COMP_PGI 0
+#endif
+
+/// \internal EIGEN_COMP_ARM set to 1 if the compiler is ARM Compiler
+#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
+  #define EIGEN_COMP_ARM 1
+#else
+  #define EIGEN_COMP_ARM 0
+#endif
+
+/// \internal EIGEN_COMP_EMSCRIPTEN set to 1 if the compiler is Emscripten Compiler
+#if defined(__EMSCRIPTEN__)
+  #define EIGEN_COMP_EMSCRIPTEN 1
+#else
+  #define EIGEN_COMP_EMSCRIPTEN 0
+#endif
+
+
+/// \internal EIGEN_GNUC_STRICT set to 1 if the compiler is really GCC and not a compatible compiler (e.g., ICC, clang, mingw, etc.)
+#if EIGEN_COMP_GNUC && !(EIGEN_COMP_CLANG || EIGEN_COMP_ICC || EIGEN_COMP_MINGW || EIGEN_COMP_PGI || EIGEN_COMP_IBM || EIGEN_COMP_ARM || EIGEN_COMP_EMSCRIPTEN)
+  #define EIGEN_COMP_GNUC_STRICT 1
+#else
+  #define EIGEN_COMP_GNUC_STRICT 0
+#endif
+
+
+#if EIGEN_COMP_GNUC
+  #define EIGEN_GNUC_AT_LEAST(x,y) ((__GNUC__==x && __GNUC_MINOR__>=y) || __GNUC__>x)
+  #define EIGEN_GNUC_AT_MOST(x,y)  ((__GNUC__==x && __GNUC_MINOR__<=y) || __GNUC__<x)
+  #define EIGEN_GNUC_AT(x,y)       ( __GNUC__==x && __GNUC_MINOR__==y )
+#else
+  #define EIGEN_GNUC_AT_LEAST(x,y) 0
+  #define EIGEN_GNUC_AT_MOST(x,y)  0
+  #define EIGEN_GNUC_AT(x,y)       0
+#endif
+
+// FIXME: could probably be removed as we do not support gcc 3.x anymore
+#if EIGEN_COMP_GNUC && (__GNUC__ <= 3)
+#define EIGEN_GCC3_OR_OLDER 1
+#else
+#define EIGEN_GCC3_OR_OLDER 0
+#endif
+
+
+
+//------------------------------------------------------------------------------------------
+// Architecture identification, EIGEN_ARCH_*
+//------------------------------------------------------------------------------------------
+
+
+#if defined(__x86_64__) || (defined(_M_X64) && !defined(_M_ARM64EC)) || defined(__amd64)
+  #define EIGEN_ARCH_x86_64 1
+#else
+  #define EIGEN_ARCH_x86_64 0
+#endif
+
+#if defined(__i386__) || defined(_M_IX86) || defined(_X86_) || defined(__i386)
+  #define EIGEN_ARCH_i386 1
+#else
+  #define EIGEN_ARCH_i386 0
+#endif
+
+#if EIGEN_ARCH_x86_64 || EIGEN_ARCH_i386
+  #define EIGEN_ARCH_i386_OR_x86_64 1
+#else
+  #define EIGEN_ARCH_i386_OR_x86_64 0
+#endif
+
+/// \internal EIGEN_ARCH_ARM set to 1 if the architecture is ARM
+#if defined(__arm__)
+  #define EIGEN_ARCH_ARM 1
+#else
+  #define EIGEN_ARCH_ARM 0
+#endif
+
+/// \internal EIGEN_ARCH_ARM64 set to 1 if the architecture is ARM64
+#if defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC)
+  #define EIGEN_ARCH_ARM64 1
+#else
+  #define EIGEN_ARCH_ARM64 0
+#endif
+
+/// \internal EIGEN_ARCH_ARM_OR_ARM64 set to 1 if the architecture is ARM or ARM64
+#if EIGEN_ARCH_ARM || EIGEN_ARCH_ARM64
+  #define EIGEN_ARCH_ARM_OR_ARM64 1
+#else
+  #define EIGEN_ARCH_ARM_OR_ARM64 0
+#endif
+
+/// \internal EIGEN_ARCH_ARMV8 set to 1 if the architecture is armv8 or greater.
+#if EIGEN_ARCH_ARM_OR_ARM64 && defined(__ARM_ARCH) && __ARM_ARCH >= 8
+#define EIGEN_ARCH_ARMV8 1
+#else
+#define EIGEN_ARCH_ARMV8 0
+#endif
+
+
+/// \internal EIGEN_HAS_ARM64_FP16 set to 1 if the architecture provides an IEEE
+/// compliant Arm fp16 type
+#if EIGEN_ARCH_ARM64
+  #ifndef EIGEN_HAS_ARM64_FP16
+    #if defined(__ARM_FP16_FORMAT_IEEE)
+      #define EIGEN_HAS_ARM64_FP16 1
+    #else
+      #define EIGEN_HAS_ARM64_FP16 0
+    #endif
+  #endif
+#endif
+
+/// \internal EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC set to 1 if the architecture
+/// supports Neon vector intrinsics for fp16.
+#if EIGEN_ARCH_ARM64
+  #ifndef EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+    #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
+      #define EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC 1
+    #else
+      #define EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC 0
+    #endif
+  #endif
+#endif
+
+/// \internal EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC set to 1 if the architecture
+/// supports Neon scalar intrinsics for fp16.
+#if EIGEN_ARCH_ARM64
+  #ifndef EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC
+    #if defined(__ARM_FEATURE_FP16_SCALAR_ARITHMETIC)
+      #define EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC 1
+    #endif
+  #endif
+#endif
+
+/// \internal EIGEN_ARCH_MIPS set to 1 if the architecture is MIPS
+#if defined(__mips__) || defined(__mips)
+  #define EIGEN_ARCH_MIPS 1
+#else
+  #define EIGEN_ARCH_MIPS 0
+#endif
+
+/// \internal EIGEN_ARCH_SPARC set to 1 if the architecture is SPARC
+#if defined(__sparc__) || defined(__sparc)
+  #define EIGEN_ARCH_SPARC 1
+#else
+  #define EIGEN_ARCH_SPARC 0
+#endif
+
+/// \internal EIGEN_ARCH_IA64 set to 1 if the architecture is Intel Itanium
+#if defined(__ia64__)
+  #define EIGEN_ARCH_IA64 1
+#else
+  #define EIGEN_ARCH_IA64 0
+#endif
+
+/// \internal EIGEN_ARCH_PPC set to 1 if the architecture is PowerPC
+#if defined(__powerpc__) || defined(__ppc__) || defined(_M_PPC)
+  #define EIGEN_ARCH_PPC 1
+#else
+  #define EIGEN_ARCH_PPC 0
+#endif
+
+
+
+//------------------------------------------------------------------------------------------
+// Operating system identification, EIGEN_OS_*
+//------------------------------------------------------------------------------------------
+
+/// \internal EIGEN_OS_UNIX set to 1 if the OS is a unix variant
+#if defined(__unix__) || defined(__unix)
+  #define EIGEN_OS_UNIX 1
+#else
+  #define EIGEN_OS_UNIX 0
+#endif
+
+/// \internal EIGEN_OS_LINUX set to 1 if the OS is based on Linux kernel
+#if defined(__linux__)
+  #define EIGEN_OS_LINUX 1
+#else
+  #define EIGEN_OS_LINUX 0
+#endif
+
+/// \internal EIGEN_OS_ANDROID set to 1 if the OS is Android
+// note: ANDROID is defined when using ndk_build, __ANDROID__ is defined when using a standalone toolchain.
+#if defined(__ANDROID__) || defined(ANDROID)
+  #define EIGEN_OS_ANDROID 1
+#else
+  #define EIGEN_OS_ANDROID 0
+#endif
+
+/// \internal EIGEN_OS_GNULINUX set to 1 if the OS is GNU Linux and not Linux-based OS (e.g., not android)
+#if defined(__gnu_linux__) && !(EIGEN_OS_ANDROID)
+  #define EIGEN_OS_GNULINUX 1
+#else
+  #define EIGEN_OS_GNULINUX 0
+#endif
+
+/// \internal EIGEN_OS_BSD set to 1 if the OS is a BSD variant
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__)
+  #define EIGEN_OS_BSD 1
+#else
+  #define EIGEN_OS_BSD 0
+#endif
+
+/// \internal EIGEN_OS_MAC set to 1 if the OS is MacOS
+#if defined(__APPLE__)
+  #define EIGEN_OS_MAC 1
+#else
+  #define EIGEN_OS_MAC 0
+#endif
+
+/// \internal EIGEN_OS_QNX set to 1 if the OS is QNX
+#if defined(__QNX__)
+  #define EIGEN_OS_QNX 1
+#else
+  #define EIGEN_OS_QNX 0
+#endif
+
+/// \internal EIGEN_OS_WIN set to 1 if the OS is Windows based
+#if defined(_WIN32)
+  #define EIGEN_OS_WIN 1
+#else
+  #define EIGEN_OS_WIN 0
+#endif
+
+/// \internal EIGEN_OS_WIN64 set to 1 if the OS is Windows 64bits
+#if defined(_WIN64)
+  #define EIGEN_OS_WIN64 1
+#else
+  #define EIGEN_OS_WIN64 0
+#endif
+
+/// \internal EIGEN_OS_WINCE set to 1 if the OS is Windows CE
+#if defined(_WIN32_WCE)
+  #define EIGEN_OS_WINCE 1
+#else
+  #define EIGEN_OS_WINCE 0
+#endif
+
+/// \internal EIGEN_OS_CYGWIN set to 1 if the OS is Windows/Cygwin
+#if defined(__CYGWIN__)
+  #define EIGEN_OS_CYGWIN 1
+#else
+  #define EIGEN_OS_CYGWIN 0
+#endif
+
+/// \internal EIGEN_OS_WIN_STRICT set to 1 if the OS is really Windows and not some variants
+#if EIGEN_OS_WIN && !( EIGEN_OS_WINCE || EIGEN_OS_CYGWIN )
+  #define EIGEN_OS_WIN_STRICT 1
+#else
+  #define EIGEN_OS_WIN_STRICT 0
+#endif
+
+/// \internal EIGEN_OS_SUN set to __SUNPRO_C if the OS is SUN
+// compiler  solaris   __SUNPRO_C
+// version   studio
+// 5.7       10        0x570
+// 5.8       11        0x580
+// 5.9       12        0x590
+// 5.10	     12.1      0x5100
+// 5.11	     12.2      0x5110
+// 5.12	     12.3      0x5120
+#if (defined(sun) || defined(__sun)) && !(defined(__SVR4) || defined(__svr4__))
+  #define EIGEN_OS_SUN __SUNPRO_C
+#else
+  #define EIGEN_OS_SUN 0
+#endif
+
+/// \internal EIGEN_OS_SOLARIS set to 1 if the OS is Solaris
+#if (defined(sun) || defined(__sun)) && (defined(__SVR4) || defined(__svr4__))
+  #define EIGEN_OS_SOLARIS 1
+#else
+  #define EIGEN_OS_SOLARIS 0
+#endif
+
+
+//------------------------------------------------------------------------------------------
+// Detect GPU compilers and architectures
+//------------------------------------------------------------------------------------------
+
+// NVCC is not supported as the target platform for HIPCC
+// Note that this also makes EIGEN_CUDACC and EIGEN_HIPCC mutually exclusive
+#if defined(__NVCC__) && defined(__HIPCC__)
+  #error "NVCC as the target platform for HIPCC is currently not supported."
+#endif
+
+#if defined(__CUDACC__) && !defined(EIGEN_NO_CUDA)
+  // Means the compiler is either nvcc or clang with CUDA enabled
+  #define EIGEN_CUDACC __CUDACC__
+#endif
+
+#if defined(__CUDA_ARCH__) && !defined(EIGEN_NO_CUDA)
+  // Means we are generating code for the device
+  #define EIGEN_CUDA_ARCH __CUDA_ARCH__
+#endif
+
+#if defined(EIGEN_CUDACC)
+#include <cuda.h>
+  #define EIGEN_CUDA_SDK_VER (CUDA_VERSION * 10)
+#else
+  #define EIGEN_CUDA_SDK_VER 0
+#endif
+
+#if defined(__HIPCC__) && !defined(EIGEN_NO_HIP)
+  // Means the compiler is HIPCC (analogous to EIGEN_CUDACC, but for HIP)
+  #define EIGEN_HIPCC __HIPCC__
+
+  // We need to include hip_runtime.h here because it pulls in
+  // ++ hip_common.h which contains the define for  __HIP_DEVICE_COMPILE__
+  // ++ host_defines.h which contains the defines for the __host__ and __device__ macros
+  #include <hip/hip_runtime.h>
+
+  #if defined(__HIP_DEVICE_COMPILE__)
+    // analogous to EIGEN_CUDA_ARCH, but for HIP
+    #define EIGEN_HIP_DEVICE_COMPILE __HIP_DEVICE_COMPILE__
+  #endif
+
+  // For HIP (ROCm 3.5 and higher), we need to explicitly set the launch_bounds attribute
+  // value to 1024. The compiler assigns a default value of 256 when the attribute is not
+  // specified. This results in failures on the HIP platform, for cases when a GPU kernel
+  // without an explicit launch_bounds attribute is called with a threads_per_block value
+  // greater than 256.
+  //
+  // This is a regression in functioanlity and is expected to be fixed within the next
+  // couple of ROCm releases (compiler will go back to using 1024 value as the default)
+  //
+  // In the meantime, we will use a "only enabled for HIP" macro to set the launch_bounds
+  // attribute.
+
+  #define EIGEN_HIP_LAUNCH_BOUNDS_1024 __launch_bounds__(1024)
+
+#endif
+
+#if !defined(EIGEN_HIP_LAUNCH_BOUNDS_1024)
+#define EIGEN_HIP_LAUNCH_BOUNDS_1024
+#endif // !defined(EIGEN_HIP_LAUNCH_BOUNDS_1024)
+
+// Unify CUDA/HIPCC
+
+#if defined(EIGEN_CUDACC) || defined(EIGEN_HIPCC)
+//
+// If either EIGEN_CUDACC or EIGEN_HIPCC is defined, then define EIGEN_GPUCC
+//
+#define EIGEN_GPUCC
+//
+// EIGEN_HIPCC implies the HIP compiler and is used to tweak Eigen code for use in HIP kernels
+// EIGEN_CUDACC implies the CUDA compiler and is used to tweak Eigen code for use in CUDA kernels
+//
+// In most cases the same tweaks are required to the Eigen code to enable in both the HIP and CUDA kernels.
+// For those cases, the corresponding code should be guarded with
+//      #if defined(EIGEN_GPUCC)
+// instead of
+//      #if defined(EIGEN_CUDACC) || defined(EIGEN_HIPCC)
+//
+// For cases where the tweak is specific to HIP, the code should be guarded with
+//      #if defined(EIGEN_HIPCC)
+//
+// For cases where the tweak is specific to CUDA, the code should be guarded with
+//      #if defined(EIGEN_CUDACC)
+//
+#endif
+
+#if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIP_DEVICE_COMPILE)
+//
+// If either EIGEN_CUDA_ARCH or EIGEN_HIP_DEVICE_COMPILE is defined, then define EIGEN_GPU_COMPILE_PHASE
+//
+#define EIGEN_GPU_COMPILE_PHASE
+//
+// GPU compilers (HIPCC, NVCC) typically do two passes over the source code,
+//   + one to compile the source for the "host" (ie CPU)
+//   + another to compile the source for the "device" (ie. GPU)
+//
+// Code that needs to enabled only during the either the "host" or "device" compilation phase
+// needs to be guarded with a macro that indicates the current compilation phase
+//
+// EIGEN_HIP_DEVICE_COMPILE implies the device compilation phase in HIP
+// EIGEN_CUDA_ARCH implies the device compilation phase in CUDA
+//
+// In most cases, the "host" / "device" specific code is the same for both HIP and CUDA
+// For those cases, the code should be guarded with
+//       #if defined(EIGEN_GPU_COMPILE_PHASE)
+// instead of
+//       #if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIP_DEVICE_COMPILE)
+//
+// For cases where the tweak is specific to HIP, the code should be guarded with
+//      #if defined(EIGEN_HIP_DEVICE_COMPILE)
+//
+// For cases where the tweak is specific to CUDA, the code should be guarded with
+//      #if defined(EIGEN_CUDA_ARCH)
+//
+#endif
+
+#if defined(EIGEN_USE_SYCL) && defined(__SYCL_DEVICE_ONLY__)
+// EIGEN_USE_SYCL is a user-defined macro while __SYCL_DEVICE_ONLY__ is a compiler-defined macro.
+// In most cases we want to check if both macros are defined which can be done using the define below.
+#define SYCL_DEVICE_ONLY
+#endif
+
+//------------------------------------------------------------------------------------------
+// Detect Compiler/Architecture/OS specific features
+//------------------------------------------------------------------------------------------
+
+#if EIGEN_GNUC_AT_MOST(4,3) && !EIGEN_COMP_CLANG
+  // see bug 89
+  #define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO 0
+#else
+  #define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO 1
+#endif
+
+// Cross compiler wrapper around LLVM's __has_builtin
+#ifdef __has_builtin
+#  define EIGEN_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#  define EIGEN_HAS_BUILTIN(x) 0
+#endif
+
+// A Clang feature extension to determine compiler features.
+// We use it to determine 'cxx_rvalue_references'
+#ifndef __has_feature
+# define __has_feature(x) 0
+#endif
+
+// Some old compilers do not support template specializations like:
+// template<typename T,int N> void foo(const T x[N]);
+#if !(   EIGEN_COMP_CLANG && (   (EIGEN_COMP_CLANG<309)                                                       \
+                              || (defined(__apple_build_version__) && (__apple_build_version__ < 9000000)))  \
+      || EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC<49)
+#define EIGEN_HAS_STATIC_ARRAY_TEMPLATE 1
+#else
+#define EIGEN_HAS_STATIC_ARRAY_TEMPLATE 0
+#endif
+
+// The macro EIGEN_CPLUSPLUS is a replacement for __cplusplus/_MSVC_LANG that
+// works for both platforms, indicating the C++ standard version number.
+//
+// With MSVC, without defining /Zc:__cplusplus, the __cplusplus macro will
+// report 199711L regardless of the language standard specified via /std.
+// We need to rely on _MSVC_LANG instead, which is only available after
+// VS2015.3.
+#if EIGEN_COMP_MSVC_LANG > 0
+#define EIGEN_CPLUSPLUS EIGEN_COMP_MSVC_LANG
+#elif EIGEN_COMP_MSVC >= 1900
+#define EIGEN_CPLUSPLUS 201103L
+#elif defined(__cplusplus)
+#define EIGEN_CPLUSPLUS __cplusplus
+#else
+#define EIGEN_CPLUSPLUS 0
+#endif
+
+// The macro EIGEN_COMP_CXXVER defines the c++ verson expected by the compiler.
+// For instance, if compiling with gcc and -std=c++17, then EIGEN_COMP_CXXVER
+// is defined to 17.
+#if EIGEN_CPLUSPLUS > 201703L
+  #define EIGEN_COMP_CXXVER 20
+#elif EIGEN_CPLUSPLUS > 201402L
+  #define EIGEN_COMP_CXXVER 17
+#elif EIGEN_CPLUSPLUS > 201103L
+  #define EIGEN_COMP_CXXVER 14
+#elif EIGEN_CPLUSPLUS >= 201103L
+  #define EIGEN_COMP_CXXVER 11
+#else
+  #define EIGEN_COMP_CXXVER 03
+#endif
+
+#ifndef EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
+  #if defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304 && EIGEN_MAX_CPP_VER>=14
+    #define EIGEN_HAS_CXX14_VARIABLE_TEMPLATES 1
+  #else
+    #define EIGEN_HAS_CXX14_VARIABLE_TEMPLATES 0
+  #endif
+#endif
+
+
+// The macros EIGEN_HAS_CXX?? defines a rough estimate of available c++ features
+// but in practice we should not rely on them but rather on the availabilty of
+// individual features as defined later.
+// This is why there is no EIGEN_HAS_CXX17.
+// FIXME: get rid of EIGEN_HAS_CXX14 and maybe even EIGEN_HAS_CXX11.
+#if EIGEN_MAX_CPP_VER>=11 && EIGEN_COMP_CXXVER>=11
+#define EIGEN_HAS_CXX11 1
+#else
+#define EIGEN_HAS_CXX11 0
+#endif
+
+#if EIGEN_MAX_CPP_VER>=14 && EIGEN_COMP_CXXVER>=14
+#define EIGEN_HAS_CXX14 1
+#else
+#define EIGEN_HAS_CXX14 0
+#endif
+
+// Do we support r-value references?
+#ifndef EIGEN_HAS_RVALUE_REFERENCES
+#if EIGEN_MAX_CPP_VER>=11 && \
+    (__has_feature(cxx_rvalue_references) || \
+     (EIGEN_COMP_CXXVER >= 11) || (EIGEN_COMP_MSVC >= 1600))
+  #define EIGEN_HAS_RVALUE_REFERENCES 1
+#else
+  #define EIGEN_HAS_RVALUE_REFERENCES 0
+#endif
+#endif
+
+// Does the compiler support C99?
+// Need to include <cmath> to make sure _GLIBCXX_USE_C99 gets defined
+#include <cmath>
+#ifndef EIGEN_HAS_C99_MATH
+#if EIGEN_MAX_CPP_VER>=11 && \
+    ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901))       \
+  || (defined(__GNUC__) && defined(_GLIBCXX_USE_C99)) \
+  || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER)) \
+  || (EIGEN_COMP_MSVC >= 1900) || defined(SYCL_DEVICE_ONLY))
+  #define EIGEN_HAS_C99_MATH 1
+#else
+  #define EIGEN_HAS_C99_MATH 0
+#endif
+#endif
+
+// Does the compiler support result_of?
+// result_of was deprecated in c++17 and removed in c++ 20
+#ifndef EIGEN_HAS_STD_RESULT_OF
+#if EIGEN_HAS_CXX11 && EIGEN_COMP_CXXVER < 17
+#define EIGEN_HAS_STD_RESULT_OF 1
+#else
+#define EIGEN_HAS_STD_RESULT_OF 0
+#endif
+#endif
+
+// Does the compiler support std::hash?
+#ifndef EIGEN_HAS_STD_HASH
+// The std::hash struct is defined in C++11 but is not labelled as a __device__
+// function and is not constexpr, so cannot be used on device.
+#if EIGEN_HAS_CXX11 && !defined(EIGEN_GPU_COMPILE_PHASE)
+#define EIGEN_HAS_STD_HASH 1
+#else
+#define EIGEN_HAS_STD_HASH 0
+#endif
+#endif  // EIGEN_HAS_STD_HASH
+
+#ifndef EIGEN_HAS_STD_INVOKE_RESULT
+#if EIGEN_MAX_CPP_VER >= 17 && EIGEN_COMP_CXXVER >= 17
+#define EIGEN_HAS_STD_INVOKE_RESULT 1
+#else
+#define EIGEN_HAS_STD_INVOKE_RESULT 0
+#endif
+#endif
+
+#ifndef EIGEN_HAS_ALIGNAS
+#if EIGEN_MAX_CPP_VER>=11 && EIGEN_HAS_CXX11 &&   \
+      (     __has_feature(cxx_alignas)            \
+        ||  EIGEN_HAS_CXX14                       \
+        || (EIGEN_COMP_MSVC >= 1800)              \
+        || (EIGEN_GNUC_AT_LEAST(4,8))             \
+        || (EIGEN_COMP_CLANG>=305)                \
+        || (EIGEN_COMP_ICC>=1500)                 \
+        || (EIGEN_COMP_PGI>=1500)                 \
+        || (EIGEN_COMP_SUNCC>=0x5130))
+#define EIGEN_HAS_ALIGNAS 1
+#else
+#define EIGEN_HAS_ALIGNAS 0
+#endif
+#endif
+
+// Does the compiler support type_traits?
+// - full support of type traits was added only to GCC 5.1.0.
+// - 20150626 corresponds to the last release of 4.x libstdc++
+#ifndef EIGEN_HAS_TYPE_TRAITS
+#if EIGEN_MAX_CPP_VER>=11 && (EIGEN_HAS_CXX11 || EIGEN_COMP_MSVC >= 1700) \
+  && ((!EIGEN_COMP_GNUC_STRICT) || EIGEN_GNUC_AT_LEAST(5, 1)) \
+  && ((!defined(__GLIBCXX__))   || __GLIBCXX__ > 20150626)
+#define EIGEN_HAS_TYPE_TRAITS 1
+#define EIGEN_INCLUDE_TYPE_TRAITS
+#else
+#define EIGEN_HAS_TYPE_TRAITS 0
+#endif
+#endif
+
+// Does the compiler support variadic templates?
+#ifndef EIGEN_HAS_VARIADIC_TEMPLATES
+#if EIGEN_MAX_CPP_VER>=11 && (EIGEN_COMP_CXXVER >= 11) \
+  && (!defined(__NVCC__) || !EIGEN_ARCH_ARM_OR_ARM64 || (EIGEN_COMP_NVCC >= 80000) )
+    // ^^ Disable the use of variadic templates when compiling with versions of nvcc older than 8.0 on ARM devices:
+    //    this prevents nvcc from crashing when compiling Eigen on Tegra X1
+#define EIGEN_HAS_VARIADIC_TEMPLATES 1
+#elif  EIGEN_MAX_CPP_VER>=11 && (EIGEN_COMP_CXXVER >= 11) && defined(SYCL_DEVICE_ONLY)
+#define EIGEN_HAS_VARIADIC_TEMPLATES 1
+#else
+#define EIGEN_HAS_VARIADIC_TEMPLATES 0
+#endif
+#endif
+
+// Does the compiler fully support const expressions? (as in c++14)
+#ifndef EIGEN_HAS_CONSTEXPR
+  #if defined(EIGEN_CUDACC)
+  // Const expressions are supported provided that c++11 is enabled and we're using either clang or nvcc 7.5 or above
+    #if EIGEN_MAX_CPP_VER>=14 && (EIGEN_COMP_CXXVER >= 11 && (EIGEN_COMP_CLANG || EIGEN_COMP_NVCC >= 70500))
+      #define EIGEN_HAS_CONSTEXPR 1
+    #endif
+  #elif EIGEN_MAX_CPP_VER>=14 && (__has_feature(cxx_relaxed_constexpr) || (EIGEN_COMP_CXXVER >= 14) || \
+    (EIGEN_GNUC_AT_LEAST(4,8) && (EIGEN_COMP_CXXVER >= 11)) || \
+    (EIGEN_COMP_CLANG >= 306 && (EIGEN_COMP_CXXVER >= 11)))
+    #define EIGEN_HAS_CONSTEXPR 1
+  #endif
+
+  #ifndef EIGEN_HAS_CONSTEXPR
+    #define EIGEN_HAS_CONSTEXPR 0
+  #endif
+
+#endif // EIGEN_HAS_CONSTEXPR
+
+#if EIGEN_HAS_CONSTEXPR
+#define EIGEN_CONSTEXPR constexpr
+#else
+#define EIGEN_CONSTEXPR
+#endif
+
+// Does the compiler support C++11 math?
+// Let's be conservative and enable the default C++11 implementation only if we are sure it exists
+#ifndef EIGEN_HAS_CXX11_MATH
+  #if EIGEN_MAX_CPP_VER>=11 && ((EIGEN_COMP_CXXVER > 11) || (EIGEN_COMP_CXXVER == 11) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_CLANG || EIGEN_COMP_MSVC || EIGEN_COMP_ICC)  \
+      && (EIGEN_ARCH_i386_OR_x86_64) && (EIGEN_OS_GNULINUX || EIGEN_OS_WIN_STRICT || EIGEN_OS_MAC))
+    #define EIGEN_HAS_CXX11_MATH 1
+  #else
+    #define EIGEN_HAS_CXX11_MATH 0
+  #endif
+#endif
+
+// Does the compiler support proper C++11 containers?
+#ifndef EIGEN_HAS_CXX11_CONTAINERS
+  #if    EIGEN_MAX_CPP_VER>=11 && \
+         ((EIGEN_COMP_CXXVER > 11) \
+      || ((EIGEN_COMP_CXXVER == 11) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_CLANG || EIGEN_COMP_MSVC || EIGEN_COMP_ICC>=1400)))
+    #define EIGEN_HAS_CXX11_CONTAINERS 1
+  #else
+    #define EIGEN_HAS_CXX11_CONTAINERS 0
+  #endif
+#endif
+
+// Does the compiler support C++11 noexcept?
+#ifndef EIGEN_HAS_CXX11_NOEXCEPT
+  #if    EIGEN_MAX_CPP_VER>=11 && \
+         (__has_feature(cxx_noexcept) \
+      || (EIGEN_COMP_CXXVER > 11) \
+      || ((EIGEN_COMP_CXXVER == 11) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_CLANG || EIGEN_COMP_MSVC || EIGEN_COMP_ICC>=1400)))
+    #define EIGEN_HAS_CXX11_NOEXCEPT 1
+  #else
+    #define EIGEN_HAS_CXX11_NOEXCEPT 0
+  #endif
+#endif
+
+#ifndef EIGEN_HAS_CXX11_ATOMIC
+  #if    EIGEN_MAX_CPP_VER>=11 && \
+         (__has_feature(cxx_atomic) \
+      || (EIGEN_COMP_CXXVER > 11) \
+      || ((EIGEN_COMP_CXXVER == 11) && (EIGEN_COMP_MSVC==0 || EIGEN_COMP_MSVC >= 1700)))
+    #define EIGEN_HAS_CXX11_ATOMIC 1
+  #else
+    #define EIGEN_HAS_CXX11_ATOMIC 0
+  #endif
+#endif
+
+#ifndef EIGEN_HAS_CXX11_OVERRIDE_FINAL
+  #if    EIGEN_MAX_CPP_VER>=11 && \
+       (EIGEN_COMP_CXXVER >= 11 || EIGEN_COMP_MSVC >= 1700)
+    #define EIGEN_HAS_CXX11_OVERRIDE_FINAL 1
+  #else
+    #define EIGEN_HAS_CXX11_OVERRIDE_FINAL 0
+  #endif
+#endif
+
+// NOTE: the required Apple's clang version is very conservative
+//       and it could be that XCode 9 works just fine.
+// NOTE: the MSVC version is based on https://en.cppreference.com/w/cpp/compiler_support
+//       and not tested.
+#ifndef EIGEN_HAS_CXX17_OVERALIGN
+#if EIGEN_MAX_CPP_VER>=17 && EIGEN_COMP_CXXVER>=17 && (                                 \
+           (EIGEN_COMP_MSVC >= 1912)                                                    \
+        || (EIGEN_GNUC_AT_LEAST(7,0))                                                   \
+        || ((!defined(__apple_build_version__)) && (EIGEN_COMP_CLANG>=500))             \
+        || (( defined(__apple_build_version__)) && (__apple_build_version__>=10000000)) \
+      )
+#define EIGEN_HAS_CXX17_OVERALIGN 1
+#else
+#define EIGEN_HAS_CXX17_OVERALIGN 0
+#endif
+#endif
+
+#if defined(EIGEN_CUDACC) && EIGEN_HAS_CONSTEXPR
+  // While available already with c++11, this is useful mostly starting with c++14 and relaxed constexpr rules
+  #if defined(__NVCC__)
+    // nvcc considers constexpr functions as __host__ __device__ with the option --expt-relaxed-constexpr
+    #ifdef __CUDACC_RELAXED_CONSTEXPR__
+      #define EIGEN_CONSTEXPR_ARE_DEVICE_FUNC
+    #endif
+  #elif defined(__clang__) && defined(__CUDA__) && __has_feature(cxx_relaxed_constexpr)
+    // clang++ always considers constexpr functions as implicitly __host__ __device__
+    #define EIGEN_CONSTEXPR_ARE_DEVICE_FUNC
+  #endif
+#endif
+
+// Does the compiler support the __int128 and __uint128_t extensions for 128-bit
+// integer arithmetic?
+//
+// Clang and GCC define __SIZEOF_INT128__ when these extensions are supported,
+// but we avoid using them in certain cases:
+//
+// * Building using Clang for Windows, where the Clang runtime library has
+//   128-bit support only on LP64 architectures, but Windows is LLP64.
+#ifndef EIGEN_HAS_BUILTIN_INT128
+#if defined(__SIZEOF_INT128__) && !(EIGEN_OS_WIN && EIGEN_COMP_CLANG)
+#define EIGEN_HAS_BUILTIN_INT128 1
+#else
+#define EIGEN_HAS_BUILTIN_INT128 0
+#endif
+#endif
+
+//------------------------------------------------------------------------------------------
+// Preprocessor programming helpers
+//------------------------------------------------------------------------------------------
+
+// This macro can be used to prevent from macro expansion, e.g.:
+//   std::max EIGEN_NOT_A_MACRO(a,b)
+#define EIGEN_NOT_A_MACRO
+
+#define EIGEN_DEBUG_VAR(x) std::cerr << #x << " = " << x << std::endl;
+
+// concatenate two tokens
+#define EIGEN_CAT2(a,b) a ## b
+#define EIGEN_CAT(a,b) EIGEN_CAT2(a,b)
+
+#define EIGEN_COMMA ,
+
+// convert a token to a string
+#define EIGEN_MAKESTRING2(a) #a
+#define EIGEN_MAKESTRING(a) EIGEN_MAKESTRING2(a)
+
+// EIGEN_STRONG_INLINE is a stronger version of the inline, using __forceinline on MSVC,
+// but it still doesn't use GCC's always_inline. This is useful in (common) situations where MSVC needs forceinline
+// but GCC is still doing fine with just inline.
+#ifndef EIGEN_STRONG_INLINE
+#if (EIGEN_COMP_MSVC || EIGEN_COMP_ICC) && !defined(EIGEN_GPUCC)
+#define EIGEN_STRONG_INLINE __forceinline
+#else
+#define EIGEN_STRONG_INLINE inline
+#endif
+#endif
+
+// EIGEN_ALWAYS_INLINE is the stronget, it has the effect of making the function inline and adding every possible
+// attribute to maximize inlining. This should only be used when really necessary: in particular,
+// it uses __attribute__((always_inline)) on GCC, which most of the time is useless and can severely harm compile times.
+// FIXME with the always_inline attribute,
+// gcc 3.4.x and 4.1 reports the following compilation error:
+//   Eval.h:91: sorry, unimplemented: inlining failed in call to 'const Eigen::Eval<Derived> Eigen::MatrixBase<Scalar, Derived>::eval() const'
+//    : function body not available
+//   See also bug 1367
+#if EIGEN_GNUC_AT_LEAST(4,2) && !defined(SYCL_DEVICE_ONLY)
+#define EIGEN_ALWAYS_INLINE __attribute__((always_inline)) inline
+#else
+#define EIGEN_ALWAYS_INLINE EIGEN_STRONG_INLINE
+#endif
+
+#if EIGEN_COMP_GNUC
+#define EIGEN_DONT_INLINE __attribute__((noinline))
+#elif EIGEN_COMP_MSVC
+#define EIGEN_DONT_INLINE __declspec(noinline)
+#else
+#define EIGEN_DONT_INLINE
+#endif
+
+#if EIGEN_COMP_GNUC
+#define EIGEN_PERMISSIVE_EXPR __extension__
+#else
+#define EIGEN_PERMISSIVE_EXPR
+#endif
+
+// GPU stuff
+
+// Disable some features when compiling with GPU compilers (NVCC/clang-cuda/SYCL/HIPCC)
+#if defined(EIGEN_CUDACC) || defined(SYCL_DEVICE_ONLY) || defined(EIGEN_HIPCC)
+  // Do not try asserts on device code
+  #ifndef EIGEN_NO_DEBUG
+  #define EIGEN_NO_DEBUG
+  #endif
+
+  #ifdef EIGEN_INTERNAL_DEBUGGING
+  #undef EIGEN_INTERNAL_DEBUGGING
+  #endif
+
+  #ifdef EIGEN_EXCEPTIONS
+  #undef EIGEN_EXCEPTIONS
+  #endif
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+  #ifndef EIGEN_DONT_VECTORIZE
+    #define EIGEN_DONT_VECTORIZE
+  #endif
+  #define EIGEN_DEVICE_FUNC __attribute__((flatten)) __attribute__((always_inline))
+// All functions callable from CUDA/HIP code must be qualified with __device__
+#elif defined(EIGEN_GPUCC)
+    #define EIGEN_DEVICE_FUNC __host__ __device__
+#else
+  #define EIGEN_DEVICE_FUNC
+#endif
+
+
+// this macro allows to get rid of linking errors about multiply defined functions.
+//  - static is not very good because it prevents definitions from different object files to be merged.
+//           So static causes the resulting linked executable to be bloated with multiple copies of the same function.
+//  - inline is not perfect either as it unwantedly hints the compiler toward inlining the function.
+#define EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC
+#define EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC inline
+
+#ifdef NDEBUG
+# ifndef EIGEN_NO_DEBUG
+#  define EIGEN_NO_DEBUG
+# endif
+#endif
+
+// eigen_plain_assert is where we implement the workaround for the assert() bug in GCC <= 4.3, see bug 89
+#ifdef EIGEN_NO_DEBUG
+  #ifdef SYCL_DEVICE_ONLY // used to silence the warning on SYCL device
+    #define eigen_plain_assert(x) EIGEN_UNUSED_VARIABLE(x)
+  #else
+    #define eigen_plain_assert(x)
+  #endif
+#else
+  #if EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO
+    namespace Eigen {
+    namespace internal {
+    inline bool copy_bool(bool b) { return b; }
+    }
+    }
+    #define eigen_plain_assert(x) assert(x)
+  #else
+    // work around bug 89
+    #include <cstdlib>   // for abort
+    #include <iostream>  // for std::cerr
+
+    namespace Eigen {
+    namespace internal {
+    // trivial function copying a bool. Must be EIGEN_DONT_INLINE, so we implement it after including Eigen headers.
+    // see bug 89.
+    namespace {
+    EIGEN_DONT_INLINE bool copy_bool(bool b) { return b; }
+    }
+    inline void assert_fail(const char *condition, const char *function, const char *file, int line)
+    {
+      std::cerr << "assertion failed: " << condition << " in function " << function << " at " << file << ":" << line << std::endl;
+      abort();
+    }
+    }
+    }
+    #define eigen_plain_assert(x) \
+      do { \
+        if(!Eigen::internal::copy_bool(x)) \
+          Eigen::internal::assert_fail(EIGEN_MAKESTRING(x), __PRETTY_FUNCTION__, __FILE__, __LINE__); \
+      } while(false)
+  #endif
+#endif
+
+// eigen_assert can be overridden
+#ifndef eigen_assert
+#define eigen_assert(x) eigen_plain_assert(x)
+#endif
+
+#ifdef EIGEN_INTERNAL_DEBUGGING
+#define eigen_internal_assert(x) eigen_assert(x)
+#else
+#define eigen_internal_assert(x)
+#endif
+
+#ifdef EIGEN_NO_DEBUG
+#define EIGEN_ONLY_USED_FOR_DEBUG(x) EIGEN_UNUSED_VARIABLE(x)
+#else
+#define EIGEN_ONLY_USED_FOR_DEBUG(x)
+#endif
+
+#ifndef EIGEN_NO_DEPRECATED_WARNING
+  #if EIGEN_COMP_GNUC
+    #define EIGEN_DEPRECATED __attribute__((deprecated))
+  #elif EIGEN_COMP_MSVC
+    #define EIGEN_DEPRECATED __declspec(deprecated)
+  #else
+    #define EIGEN_DEPRECATED
+  #endif
+#else
+  #define EIGEN_DEPRECATED
+#endif
+
+#if EIGEN_COMP_GNUC
+#define EIGEN_UNUSED __attribute__((unused))
+#else
+#define EIGEN_UNUSED
+#endif
+
+// Suppresses 'unused variable' warnings.
+namespace Eigen {
+  namespace internal {
+    template<typename T> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ignore_unused_variable(const T&) {}
+  }
+}
+#define EIGEN_UNUSED_VARIABLE(var) Eigen::internal::ignore_unused_variable(var);
+
+#if !defined(EIGEN_ASM_COMMENT)
+  #if EIGEN_COMP_GNUC && (EIGEN_ARCH_i386_OR_x86_64 || EIGEN_ARCH_ARM_OR_ARM64)
+    #define EIGEN_ASM_COMMENT(X)  __asm__("#" X)
+  #else
+    #define EIGEN_ASM_COMMENT(X)
+  #endif
+#endif
+
+
+// Acts as a barrier preventing operations involving `X` from crossing. This
+// occurs, for example, in the fast rounding trick where a magic constant is
+// added then subtracted, which is otherwise compiled away with -ffast-math.
+//
+// See bug 1674
+#if !defined(EIGEN_OPTIMIZATION_BARRIER)
+  #if EIGEN_COMP_GNUC
+    // According to https://gcc.gnu.org/onlinedocs/gcc/Constraints.html:
+    //   X: Any operand whatsoever.
+    //   r: A register operand is allowed provided that it is in a general
+    //      register.
+    //   g: Any register, memory or immediate integer operand is allowed, except
+    //      for registers that are not general registers.
+    //   w: (AArch32/AArch64) Floating point register, Advanced SIMD vector
+    //      register or SVE vector register.
+    //   x: (SSE) Any SSE register.
+    //      (AArch64) Like w, but restricted to registers 0 to 15 inclusive.
+    //   v: (PowerPC) An Altivec vector register.
+    //   wa:(PowerPC) A VSX register.
+    //
+    // "X" (uppercase) should work for all cases, though this seems to fail for
+    // some versions of GCC for arm/aarch64 with
+    //   "error: inconsistent operand constraints in an 'asm'"
+    // Clang x86_64/arm/aarch64 seems to require "g" to support both scalars and
+    // vectors, otherwise
+    //   "error: non-trivial scalar-to-vector conversion, possible invalid
+    //    constraint for vector type"
+    //
+    // GCC for ppc64le generates an internal compiler error with x/X/g.
+    // GCC for AVX generates an internal compiler error with X.
+    //
+    // Tested on icc/gcc/clang for sse, avx, avx2, avx512dq
+    //           gcc for arm, aarch64,
+    //           gcc for ppc64le,
+    // both vectors and scalars.
+    //
+    // Note that this is restricted to plain types - this will not work
+    // directly for std::complex<T>, Eigen::half, Eigen::bfloat16. For these,
+    // you will need to apply to the underlying POD type.
+    #if EIGEN_ARCH_PPC && EIGEN_COMP_GNUC_STRICT
+      // This seems to be broken on clang.  Packet4f is loaded into a single
+      //   register rather than a vector, zeroing out some entries.  Integer
+      //   types also generate a compile error.
+      // General, Altivec, VSX.
+      #define EIGEN_OPTIMIZATION_BARRIER(X)  __asm__  ("" : "+r,v,wa" (X));
+    #elif EIGEN_ARCH_ARM_OR_ARM64
+      // General, NEON.
+      #define EIGEN_OPTIMIZATION_BARRIER(X)  __asm__  ("" : "+g,w" (X));
+    #elif EIGEN_ARCH_i386_OR_x86_64
+      // General, SSE.
+      #define EIGEN_OPTIMIZATION_BARRIER(X)  __asm__  ("" : "+g,x" (X));
+    #else
+      // Not implemented for other architectures.
+      #define EIGEN_OPTIMIZATION_BARRIER(X)
+    #endif
+  #else
+    // Not implemented for other compilers.
+    #define EIGEN_OPTIMIZATION_BARRIER(X)
+  #endif
+#endif
+
+#if EIGEN_COMP_MSVC
+  // NOTE MSVC often gives C4127 warnings with compiletime if statements. See bug 1362.
+  // This workaround is ugly, but it does the job.
+#  define EIGEN_CONST_CONDITIONAL(cond)  (void)0, cond
+#else
+#  define EIGEN_CONST_CONDITIONAL(cond)  cond
+#endif
+
+#ifdef EIGEN_DONT_USE_RESTRICT_KEYWORD
+  #define EIGEN_RESTRICT
+#endif
+#ifndef EIGEN_RESTRICT
+  #define EIGEN_RESTRICT __restrict
+#endif
+
+
+#ifndef EIGEN_DEFAULT_IO_FORMAT
+#ifdef EIGEN_MAKING_DOCS
+// format used in Eigen's documentation
+// needed to define it here as escaping characters in CMake add_definition's argument seems very problematic.
+#define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat(3, 0, " ", "\n", "", "")
+#else
+#define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat()
+#endif
+#endif
+
+// just an empty macro !
+#define EIGEN_EMPTY
+
+
+// When compiling CUDA/HIP device code with NVCC or HIPCC
+// pull in math functions from the global namespace.
+// In host mode, and when device code is compiled with clang,
+// use the std versions.
+#if (defined(EIGEN_CUDA_ARCH) && defined(__NVCC__)) || defined(EIGEN_HIP_DEVICE_COMPILE)
+  #define EIGEN_USING_STD(FUNC) using ::FUNC;
+#else
+  #define EIGEN_USING_STD(FUNC) using std::FUNC;
+#endif
+
+#if EIGEN_COMP_MSVC_STRICT && (EIGEN_COMP_MSVC < 1900 || (EIGEN_COMP_MSVC == 1900 && EIGEN_COMP_NVCC))
+  // For older MSVC versions, as well as 1900 && CUDA 8, using the base operator is necessary,
+  //   otherwise we get duplicate definition errors
+  // For later MSVC versions, we require explicit operator= definition, otherwise we get
+  //   use of implicitly deleted operator errors.
+  // (cf Bugs 920, 1000, 1324, 2291)
+  #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    using Base::operator =;
+#elif EIGEN_COMP_CLANG // workaround clang bug (see http://forum.kde.org/viewtopic.php?f=74&t=102653)
+  #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    using Base::operator =; \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) { Base::operator=(other); return *this; } \
+    template <typename OtherDerived> \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const DenseBase<OtherDerived>& other) { Base::operator=(other.derived()); return *this; }
+#else
+  #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    using Base::operator =; \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) \
+    { \
+      Base::operator=(other); \
+      return *this; \
+    }
+#endif
+
+
+/**
+ * \internal
+ * \brief Macro to explicitly define the default copy constructor.
+ * This is necessary, because the implicit definition is deprecated if the copy-assignment is overridden.
+ */
+#if EIGEN_HAS_CXX11
+#define EIGEN_DEFAULT_COPY_CONSTRUCTOR(CLASS) CLASS(const CLASS&) = default;
+#else
+#define EIGEN_DEFAULT_COPY_CONSTRUCTOR(CLASS)
+#endif
+
+
+
+/** \internal
+ * \brief Macro to manually inherit assignment operators.
+ * This is necessary, because the implicitly defined assignment operator gets deleted when a custom operator= is defined.
+ * With C++11 or later this also default-implements the copy-constructor
+ */
+#define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived)  \
+    EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(Derived)
+
+/** \internal
+ * \brief Macro to manually define default constructors and destructors.
+ * This is necessary when the copy constructor is re-defined.
+ * For empty helper classes this should usually be protected, to avoid accidentally creating empty objects.
+ *
+ * Hiding the default destructor lead to problems in C++03 mode together with boost::multiprecision
+ */
+#if EIGEN_HAS_CXX11
+#define EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(Derived)  \
+    Derived() = default; \
+    ~Derived() = default;
+#else
+#define EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(Derived)  \
+    Derived() {}; \
+    /* ~Derived() {}; */
+#endif
+
+
+
+
+
+/**
+* Just a side note. Commenting within defines works only by documenting
+* behind the object (via '!<'). Comments cannot be multi-line and thus
+* we have these extra long lines. What is confusing doxygen over here is
+* that we use '\' and basically have a bunch of typedefs with their
+* documentation in a single line.
+**/
+
+#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
+  typedef typename Eigen::internal::traits<Derived>::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex<float>. */ \
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; /*!< \brief The underlying numeric type for composed scalar types. \details In cases where Scalar is e.g. std::complex<T>, T were corresponding to RealScalar. */ \
+  typedef typename Base::CoeffReturnType CoeffReturnType; /*!< \brief The return type for coefficient access. \details Depending on whether the object allows direct coefficient access (e.g. for a MatrixXd), this type is either 'const Scalar&' or simply 'Scalar' for objects that do not allow direct coefficient access. */ \
+  typedef typename Eigen::internal::ref_selector<Derived>::type Nested; \
+  typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \
+  typedef typename Eigen::internal::traits<Derived>::StorageIndex StorageIndex; \
+  enum CompileTimeTraits \
+      { RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime, \
+        ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime, \
+        Flags = Eigen::internal::traits<Derived>::Flags, \
+        SizeAtCompileTime = Base::SizeAtCompileTime, \
+        MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \
+        IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \
+  using Base::derived; \
+  using Base::const_cast_derived;
+
+
+// FIXME Maybe the EIGEN_DENSE_PUBLIC_INTERFACE could be removed as importing PacketScalar is rarely needed
+#define EIGEN_DENSE_PUBLIC_INTERFACE(Derived) \
+  EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
+  typedef typename Base::PacketScalar PacketScalar;
+
+
+#define EIGEN_PLAIN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b)
+#define EIGEN_PLAIN_ENUM_MAX(a,b) (((int)a >= (int)b) ? (int)a : (int)b)
+
+// EIGEN_SIZE_MIN_PREFER_DYNAMIC gives the min between compile-time sizes. 0 has absolute priority, followed by 1,
+// followed by Dynamic, followed by other finite values. The reason for giving Dynamic the priority over
+// finite values is that min(3, Dynamic) should be Dynamic, since that could be anything between 0 and 3.
+#define EIGEN_SIZE_MIN_PREFER_DYNAMIC(a,b) (((int)a == 0 || (int)b == 0) ? 0 \
+                           : ((int)a == 1 || (int)b == 1) ? 1 \
+                           : ((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
+                           : ((int)a <= (int)b) ? (int)a : (int)b)
+
+// EIGEN_SIZE_MIN_PREFER_FIXED is a variant of EIGEN_SIZE_MIN_PREFER_DYNAMIC comparing MaxSizes. The difference is that finite values
+// now have priority over Dynamic, so that min(3, Dynamic) gives 3. Indeed, whatever the actual value is
+// (between 0 and 3), it is not more than 3.
+#define EIGEN_SIZE_MIN_PREFER_FIXED(a,b)  (((int)a == 0 || (int)b == 0) ? 0 \
+                           : ((int)a == 1 || (int)b == 1) ? 1 \
+                           : ((int)a == Dynamic && (int)b == Dynamic) ? Dynamic \
+                           : ((int)a == Dynamic) ? (int)b \
+                           : ((int)b == Dynamic) ? (int)a \
+                           : ((int)a <= (int)b) ? (int)a : (int)b)
+
+// see EIGEN_SIZE_MIN_PREFER_DYNAMIC. No need for a separate variant for MaxSizes here.
+#define EIGEN_SIZE_MAX(a,b) (((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
+                           : ((int)a >= (int)b) ? (int)a : (int)b)
+
+#define EIGEN_LOGICAL_XOR(a,b) (((a) || (b)) && !((a) && (b)))
+
+#define EIGEN_IMPLIES(a,b) (!(a) || (b))
+
+#if EIGEN_HAS_BUILTIN(__builtin_expect) || EIGEN_COMP_GNUC
+#define EIGEN_PREDICT_FALSE(x) (__builtin_expect(x, false))
+#define EIGEN_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
+#else
+#define EIGEN_PREDICT_FALSE(x) (x)
+#define EIGEN_PREDICT_TRUE(x) (x)
+#endif
+
+// the expression type of a standard coefficient wise binary operation
+#define EIGEN_CWISE_BINARY_RETURN_TYPE(LHS,RHS,OPNAME) \
+    CwiseBinaryOp< \
+      EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)< \
+          typename internal::traits<LHS>::Scalar, \
+          typename internal::traits<RHS>::Scalar \
+      >, \
+      const LHS, \
+      const RHS \
+    >
+
+#define EIGEN_MAKE_CWISE_BINARY_OP(METHOD,OPNAME) \
+  template<typename OtherDerived> \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,OPNAME) \
+  (METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
+  { \
+    return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,OPNAME)(derived(), other.derived()); \
+  }
+
+#define EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,TYPEA,TYPEB) \
+  (Eigen::internal::has_ReturnType<Eigen::ScalarBinaryOpTraits<TYPEA,TYPEB,EIGEN_CAT(EIGEN_CAT(Eigen::internal::scalar_,OPNAME),_op)<TYPEA,TYPEB>  > >::value)
+
+#define EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(EXPR,SCALAR,OPNAME) \
+  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)<typename internal::traits<EXPR>::Scalar,SCALAR>, const EXPR, \
+                const typename internal::plain_constant_type<EXPR,SCALAR>::type>
+
+#define EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(SCALAR,EXPR,OPNAME) \
+  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)<SCALAR,typename internal::traits<EXPR>::Scalar>, \
+                const typename internal::plain_constant_type<EXPR,SCALAR>::type, const EXPR>
+
+// Workaround for MSVC 2010 (see ML thread "patch with compile for for MSVC 2010")
+#if EIGEN_COMP_MSVC_STRICT && (EIGEN_COMP_MSVC_STRICT<=1600)
+#define EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(X) typename internal::enable_if<true,X>::type
+#else
+#define EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(X) X
+#endif
+
+#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD,OPNAME) \
+  template <typename T> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE \
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,Scalar,T)>::type,OPNAME))\
+  (METHOD)(const T& scalar) const { \
+    typedef typename internal::promote_scalar_arg<Scalar,T,EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,Scalar,T)>::type PromotedT; \
+    return EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,PromotedT,OPNAME)(derived(), \
+           typename internal::plain_constant_type<Derived,PromotedT>::type(derived().rows(), derived().cols(), internal::scalar_constant_op<PromotedT>(scalar))); \
+  }
+
+#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD,OPNAME) \
+  template <typename T> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend \
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,T,Scalar)>::type,Derived,OPNAME)) \
+  (METHOD)(const T& scalar, const StorageBaseType& matrix) { \
+    typedef typename internal::promote_scalar_arg<Scalar,T,EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,T,Scalar)>::type PromotedT; \
+    return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedT,Derived,OPNAME)( \
+           typename internal::plain_constant_type<Derived,PromotedT>::type(matrix.derived().rows(), matrix.derived().cols(), internal::scalar_constant_op<PromotedT>(scalar)), matrix.derived()); \
+  }
+
+#define EIGEN_MAKE_SCALAR_BINARY_OP(METHOD,OPNAME) \
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD,OPNAME) \
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD,OPNAME)
+
+
+#if (defined(_CPPUNWIND) || defined(__EXCEPTIONS)) && !defined(EIGEN_CUDA_ARCH) && !defined(EIGEN_EXCEPTIONS) && !defined(EIGEN_USE_SYCL) && !defined(EIGEN_HIP_DEVICE_COMPILE)
+  #define EIGEN_EXCEPTIONS
+#endif
+
+
+#ifdef EIGEN_EXCEPTIONS
+#  define EIGEN_THROW_X(X) throw X
+#  define EIGEN_THROW throw
+#  define EIGEN_TRY try
+#  define EIGEN_CATCH(X) catch (X)
+#else
+#  if defined(EIGEN_CUDA_ARCH)
+#    define EIGEN_THROW_X(X) asm("trap;")
+#    define EIGEN_THROW asm("trap;")
+#  elif defined(EIGEN_HIP_DEVICE_COMPILE)
+#    define EIGEN_THROW_X(X) asm("s_trap 0")
+#    define EIGEN_THROW asm("s_trap 0")
+#  else
+#    define EIGEN_THROW_X(X) std::abort()
+#    define EIGEN_THROW std::abort()
+#  endif
+#  define EIGEN_TRY if (true)
+#  define EIGEN_CATCH(X) else
+#endif
+
+
+#if EIGEN_HAS_CXX11_NOEXCEPT
+#   define EIGEN_INCLUDE_TYPE_TRAITS
+#   define EIGEN_NOEXCEPT noexcept
+#   define EIGEN_NOEXCEPT_IF(x) noexcept(x)
+#   define EIGEN_NO_THROW noexcept(true)
+#   define EIGEN_EXCEPTION_SPEC(X) noexcept(false)
+#else
+#   define EIGEN_NOEXCEPT
+#   define EIGEN_NOEXCEPT_IF(x)
+#   define EIGEN_NO_THROW throw()
+#   if EIGEN_COMP_MSVC || EIGEN_COMP_CXXVER>=17
+      // MSVC does not support exception specifications (warning C4290),
+      // and they are deprecated in c++11 anyway. This is even an error in c++17.
+#     define EIGEN_EXCEPTION_SPEC(X) throw()
+#   else
+#     define EIGEN_EXCEPTION_SPEC(X) throw(X)
+#   endif
+#endif
+
+#if EIGEN_HAS_VARIADIC_TEMPLATES
+// The all function is used to enable a variadic version of eigen_assert which can take a parameter pack as its input.
+namespace Eigen {
+namespace internal {
+
+inline bool all(){ return true; }
+
+template<typename T, typename ...Ts>
+bool all(T t, Ts ... ts){ return t && all(ts...); }
+
+}
+}
+#endif
+
+#if EIGEN_HAS_CXX11_OVERRIDE_FINAL
+// provide override and final specifiers if they are available:
+#   define EIGEN_OVERRIDE override
+#   define EIGEN_FINAL final
+#else
+#   define EIGEN_OVERRIDE
+#   define EIGEN_FINAL
+#endif
+
+// Wrapping #pragma unroll in a macro since it is required for SYCL
+#if defined(SYCL_DEVICE_ONLY)
+  #if defined(_MSC_VER)
+    #define EIGEN_UNROLL_LOOP __pragma(unroll)
+  #else
+    #define EIGEN_UNROLL_LOOP _Pragma("unroll")
+  #endif
+#else
+  #define EIGEN_UNROLL_LOOP
+#endif
+
+#endif // EIGEN_MACROS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/Memory.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/Memory.h
new file mode 100644
index 00000000..875318cd
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/Memory.h
@@ -0,0 +1,1163 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Kenneth Riddile <kfriddile@yahoo.com>
+// Copyright (C) 2010 Hauke Heibel <hauke.heibel@gmail.com>
+// Copyright (C) 2010 Thomas Capricelli <orzel@freehackers.org>
+// Copyright (C) 2013 Pavel Holoborodko <pavel@holoborodko.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+/*****************************************************************************
+*** Platform checks for aligned malloc functions                           ***
+*****************************************************************************/
+
+#ifndef EIGEN_MEMORY_H
+#define EIGEN_MEMORY_H
+
+#ifndef EIGEN_MALLOC_ALREADY_ALIGNED
+
+// Try to determine automatically if malloc is already aligned.
+
+// On 64-bit systems, glibc's malloc returns 16-byte-aligned pointers, see:
+//   http://www.gnu.org/s/libc/manual/html_node/Aligned-Memory-Blocks.html
+// This is true at least since glibc 2.8.
+// This leaves the question how to detect 64-bit. According to this document,
+//   http://gcc.fyxm.net/summit/2003/Porting%20to%2064%20bit.pdf
+// page 114, "[The] LP64 model [...] is used by all 64-bit UNIX ports" so it's indeed
+// quite safe, at least within the context of glibc, to equate 64-bit with LP64.
+#if defined(__GLIBC__) && ((__GLIBC__>=2 && __GLIBC_MINOR__ >= 8) || __GLIBC__>2) \
+ && defined(__LP64__) && ! defined( __SANITIZE_ADDRESS__ ) && (EIGEN_DEFAULT_ALIGN_BYTES == 16)
+  #define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED 1
+#else
+  #define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED 0
+#endif
+
+// FreeBSD 6 seems to have 16-byte aligned malloc
+//   See http://svn.freebsd.org/viewvc/base/stable/6/lib/libc/stdlib/malloc.c?view=markup
+// FreeBSD 7 seems to have 16-byte aligned malloc except on ARM and MIPS architectures
+//   See http://svn.freebsd.org/viewvc/base/stable/7/lib/libc/stdlib/malloc.c?view=markup
+#if defined(__FreeBSD__) && !(EIGEN_ARCH_ARM || EIGEN_ARCH_MIPS) && (EIGEN_DEFAULT_ALIGN_BYTES == 16)
+  #define EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED 1
+#else
+  #define EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED 0
+#endif
+
+#if (EIGEN_OS_MAC && (EIGEN_DEFAULT_ALIGN_BYTES == 16))     \
+ || (EIGEN_OS_WIN64 && (EIGEN_DEFAULT_ALIGN_BYTES == 16))   \
+ || EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED              \
+ || EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED
+  #define EIGEN_MALLOC_ALREADY_ALIGNED 1
+#else
+  #define EIGEN_MALLOC_ALREADY_ALIGNED 0
+#endif
+
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+EIGEN_DEVICE_FUNC
+inline void throw_std_bad_alloc()
+{
+  #ifdef EIGEN_EXCEPTIONS
+    throw std::bad_alloc();
+  #else
+    std::size_t huge = static_cast<std::size_t>(-1);
+    #if defined(EIGEN_HIPCC)
+    //
+    // calls to "::operator new" are to be treated as opaque function calls (i.e no inlining),
+    // and as a consequence the code in the #else block triggers the hipcc warning :
+    // "no overloaded function has restriction specifiers that are compatible with the ambient context"
+    //
+    // "throw_std_bad_alloc" has the EIGEN_DEVICE_FUNC attribute, so it seems that hipcc expects
+    // the same on "operator new"
+    // Reverting code back to the old version in this #if block for the hipcc compiler
+    //
+    new int[huge];
+    #else
+    void* unused = ::operator new(huge);
+    EIGEN_UNUSED_VARIABLE(unused);
+    #endif
+  #endif
+}
+
+/*****************************************************************************
+*** Implementation of handmade aligned functions                           ***
+*****************************************************************************/
+
+/* ----- Hand made implementations of aligned malloc/free and realloc ----- */
+
+/** \internal Like malloc, but the returned pointer is guaranteed to be 16-byte aligned.
+  * Fast, but wastes 16 additional bytes of memory. Does not throw any exception.
+  */
+EIGEN_DEVICE_FUNC inline void* handmade_aligned_malloc(std::size_t size, std::size_t alignment = EIGEN_DEFAULT_ALIGN_BYTES)
+{
+  eigen_assert(alignment >= sizeof(void*) && (alignment & (alignment-1)) == 0 && "Alignment must be at least sizeof(void*) and a power of 2");
+
+  EIGEN_USING_STD(malloc)
+  void *original = malloc(size+alignment);
+  
+  if (original == 0) return 0;
+  void *aligned = reinterpret_cast<void*>((reinterpret_cast<std::size_t>(original) & ~(std::size_t(alignment-1))) + alignment);
+  *(reinterpret_cast<void**>(aligned) - 1) = original;
+  return aligned;
+}
+
+/** \internal Frees memory allocated with handmade_aligned_malloc */
+EIGEN_DEVICE_FUNC inline void handmade_aligned_free(void *ptr)
+{
+  if (ptr) {
+    EIGEN_USING_STD(free)
+    free(*(reinterpret_cast<void**>(ptr) - 1));
+  }
+}
+
+/** \internal
+  * \brief Reallocates aligned memory.
+  * Since we know that our handmade version is based on std::malloc
+  * we can use std::realloc to implement efficient reallocation.
+  */
+inline void* handmade_aligned_realloc(void* ptr, std::size_t size, std::size_t = 0)
+{
+  if (ptr == 0) return handmade_aligned_malloc(size);
+  void *original = *(reinterpret_cast<void**>(ptr) - 1);
+  std::ptrdiff_t previous_offset = static_cast<char *>(ptr)-static_cast<char *>(original);
+  original = std::realloc(original,size+EIGEN_DEFAULT_ALIGN_BYTES);
+  if (original == 0) return 0;
+  void *aligned = reinterpret_cast<void*>((reinterpret_cast<std::size_t>(original) & ~(std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1))) + EIGEN_DEFAULT_ALIGN_BYTES);
+  void *previous_aligned = static_cast<char *>(original)+previous_offset;
+  if(aligned!=previous_aligned)
+    std::memmove(aligned, previous_aligned, size);
+
+  *(reinterpret_cast<void**>(aligned) - 1) = original;
+  return aligned;
+}
+
+/*****************************************************************************
+*** Implementation of portable aligned versions of malloc/free/realloc     ***
+*****************************************************************************/
+
+#ifdef EIGEN_NO_MALLOC
+EIGEN_DEVICE_FUNC inline void check_that_malloc_is_allowed()
+{
+  eigen_assert(false && "heap allocation is forbidden (EIGEN_NO_MALLOC is defined)");
+}
+#elif defined EIGEN_RUNTIME_NO_MALLOC
+EIGEN_DEVICE_FUNC inline bool is_malloc_allowed_impl(bool update, bool new_value = false)
+{
+  static bool value = true;
+  if (update == 1)
+    value = new_value;
+  return value;
+}
+EIGEN_DEVICE_FUNC inline bool is_malloc_allowed() { return is_malloc_allowed_impl(false); }
+EIGEN_DEVICE_FUNC inline bool set_is_malloc_allowed(bool new_value) { return is_malloc_allowed_impl(true, new_value); }
+EIGEN_DEVICE_FUNC inline void check_that_malloc_is_allowed()
+{
+  eigen_assert(is_malloc_allowed() && "heap allocation is forbidden (EIGEN_RUNTIME_NO_MALLOC is defined and g_is_malloc_allowed is false)");
+}
+#else
+EIGEN_DEVICE_FUNC inline void check_that_malloc_is_allowed()
+{}
+#endif
+
+/** \internal Allocates \a size bytes. The returned pointer is guaranteed to have 16 or 32 bytes alignment depending on the requirements.
+  * On allocation error, the returned pointer is null, and std::bad_alloc is thrown.
+  */
+EIGEN_DEVICE_FUNC inline void* aligned_malloc(std::size_t size)
+{
+  check_that_malloc_is_allowed();
+
+  void *result;
+  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
+
+    EIGEN_USING_STD(malloc)
+    result = malloc(size);
+
+    #if EIGEN_DEFAULT_ALIGN_BYTES==16
+    eigen_assert((size<16 || (std::size_t(result)%16)==0) && "System's malloc returned an unaligned pointer. Compile with EIGEN_MALLOC_ALREADY_ALIGNED=0 to fallback to handmade aligned memory allocator.");
+    #endif
+  #else
+    result = handmade_aligned_malloc(size);
+  #endif
+
+  if(!result && size)
+    throw_std_bad_alloc();
+
+  return result;
+}
+
+/** \internal Frees memory allocated with aligned_malloc. */
+EIGEN_DEVICE_FUNC inline void aligned_free(void *ptr)
+{
+  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
+
+    EIGEN_USING_STD(free)
+    free(ptr);
+
+  #else
+    handmade_aligned_free(ptr);
+  #endif
+}
+
+/**
+  * \internal
+  * \brief Reallocates an aligned block of memory.
+  * \throws std::bad_alloc on allocation failure
+  */
+inline void* aligned_realloc(void *ptr, std::size_t new_size, std::size_t old_size)
+{
+  EIGEN_UNUSED_VARIABLE(old_size)
+
+  void *result;
+#if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
+  result = std::realloc(ptr,new_size);
+#else
+  result = handmade_aligned_realloc(ptr,new_size,old_size);
+#endif
+
+  if (!result && new_size)
+    throw_std_bad_alloc();
+
+  return result;
+}
+
+/*****************************************************************************
+*** Implementation of conditionally aligned functions                      ***
+*****************************************************************************/
+
+/** \internal Allocates \a size bytes. If Align is true, then the returned ptr is 16-byte-aligned.
+  * On allocation error, the returned pointer is null, and a std::bad_alloc is thrown.
+  */
+template<bool Align> EIGEN_DEVICE_FUNC inline void* conditional_aligned_malloc(std::size_t size)
+{
+  return aligned_malloc(size);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void* conditional_aligned_malloc<false>(std::size_t size)
+{
+  check_that_malloc_is_allowed();
+
+  EIGEN_USING_STD(malloc)
+  void *result = malloc(size);
+
+  if(!result && size)
+    throw_std_bad_alloc();
+  return result;
+}
+
+/** \internal Frees memory allocated with conditional_aligned_malloc */
+template<bool Align> EIGEN_DEVICE_FUNC inline void conditional_aligned_free(void *ptr)
+{
+  aligned_free(ptr);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void conditional_aligned_free<false>(void *ptr)
+{
+  EIGEN_USING_STD(free)
+  free(ptr);
+}
+
+template<bool Align> inline void* conditional_aligned_realloc(void* ptr, std::size_t new_size, std::size_t old_size)
+{
+  return aligned_realloc(ptr, new_size, old_size);
+}
+
+template<> inline void* conditional_aligned_realloc<false>(void* ptr, std::size_t new_size, std::size_t)
+{
+  return std::realloc(ptr, new_size);
+}
+
+/*****************************************************************************
+*** Construction/destruction of array elements                             ***
+*****************************************************************************/
+
+/** \internal Destructs the elements of an array.
+  * The \a size parameters tells on how many objects to call the destructor of T.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline void destruct_elements_of_array(T *ptr, std::size_t size)
+{
+  // always destruct an array starting from the end.
+  if(ptr)
+    while(size) ptr[--size].~T();
+}
+
+/** \internal Constructs the elements of an array.
+  * The \a size parameter tells on how many objects to call the constructor of T.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline T* construct_elements_of_array(T *ptr, std::size_t size)
+{
+  std::size_t i;
+  EIGEN_TRY
+  {
+      for (i = 0; i < size; ++i) ::new (ptr + i) T;
+      return ptr;
+  }
+  EIGEN_CATCH(...)
+  {
+    destruct_elements_of_array(ptr, i);
+    EIGEN_THROW;
+  }
+  return NULL;
+}
+
+/*****************************************************************************
+*** Implementation of aligned new/delete-like functions                    ***
+*****************************************************************************/
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void check_size_for_overflow(std::size_t size)
+{
+  if(size > std::size_t(-1) / sizeof(T))
+    throw_std_bad_alloc();
+}
+
+/** \internal Allocates \a size objects of type T. The returned pointer is guaranteed to have 16 bytes alignment.
+  * On allocation error, the returned pointer is undefined, but a std::bad_alloc is thrown.
+  * The default constructor of T is called.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline T* aligned_new(std::size_t size)
+{
+  check_size_for_overflow<T>(size);
+  T *result = reinterpret_cast<T*>(aligned_malloc(sizeof(T)*size));
+  EIGEN_TRY
+  {
+    return construct_elements_of_array(result, size);
+  }
+  EIGEN_CATCH(...)
+  {
+    aligned_free(result);
+    EIGEN_THROW;
+  }
+  return result;
+}
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline T* conditional_aligned_new(std::size_t size)
+{
+  check_size_for_overflow<T>(size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
+  EIGEN_TRY
+  {
+    return construct_elements_of_array(result, size);
+  }
+  EIGEN_CATCH(...)
+  {
+    conditional_aligned_free<Align>(result);
+    EIGEN_THROW;
+  }
+  return result;
+}
+
+/** \internal Deletes objects constructed with aligned_new
+  * The \a size parameters tells on how many objects to call the destructor of T.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline void aligned_delete(T *ptr, std::size_t size)
+{
+  destruct_elements_of_array<T>(ptr, size);
+  Eigen::internal::aligned_free(ptr);
+}
+
+/** \internal Deletes objects constructed with conditional_aligned_new
+  * The \a size parameters tells on how many objects to call the destructor of T.
+  */
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline void conditional_aligned_delete(T *ptr, std::size_t size)
+{
+  destruct_elements_of_array<T>(ptr, size);
+  conditional_aligned_free<Align>(ptr);
+}
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline T* conditional_aligned_realloc_new(T* pts, std::size_t new_size, std::size_t old_size)
+{
+  check_size_for_overflow<T>(new_size);
+  check_size_for_overflow<T>(old_size);
+  if(new_size < old_size)
+    destruct_elements_of_array(pts+new_size, old_size-new_size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
+  if(new_size > old_size)
+  {
+    EIGEN_TRY
+    {
+      construct_elements_of_array(result+old_size, new_size-old_size);
+    }
+    EIGEN_CATCH(...)
+    {
+      conditional_aligned_free<Align>(result);
+      EIGEN_THROW;
+    }
+  }
+  return result;
+}
+
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline T* conditional_aligned_new_auto(std::size_t size)
+{
+  if(size==0)
+    return 0; // short-cut. Also fixes Bug 884
+  check_size_for_overflow<T>(size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
+  if(NumTraits<T>::RequireInitialization)
+  {
+    EIGEN_TRY
+    {
+      construct_elements_of_array(result, size);
+    }
+    EIGEN_CATCH(...)
+    {
+      conditional_aligned_free<Align>(result);
+      EIGEN_THROW;
+    }
+  }
+  return result;
+}
+
+template<typename T, bool Align> inline T* conditional_aligned_realloc_new_auto(T* pts, std::size_t new_size, std::size_t old_size)
+{
+  check_size_for_overflow<T>(new_size);
+  check_size_for_overflow<T>(old_size);
+  if(NumTraits<T>::RequireInitialization && (new_size < old_size))
+    destruct_elements_of_array(pts+new_size, old_size-new_size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
+  if(NumTraits<T>::RequireInitialization && (new_size > old_size))
+  {
+    EIGEN_TRY
+    {
+      construct_elements_of_array(result+old_size, new_size-old_size);
+    }
+    EIGEN_CATCH(...)
+    {
+      conditional_aligned_free<Align>(result);
+      EIGEN_THROW;
+    }
+  }
+  return result;
+}
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline void conditional_aligned_delete_auto(T *ptr, std::size_t size)
+{
+  if(NumTraits<T>::RequireInitialization)
+    destruct_elements_of_array<T>(ptr, size);
+  conditional_aligned_free<Align>(ptr);
+}
+
+/****************************************************************************/
+
+/** \internal Returns the index of the first element of the array that is well aligned with respect to the requested \a Alignment.
+  *
+  * \tparam Alignment requested alignment in Bytes.
+  * \param array the address of the start of the array
+  * \param size the size of the array
+  *
+  * \note If no element of the array is well aligned or the requested alignment is not a multiple of a scalar,
+  * the size of the array is returned. For example with SSE, the requested alignment is typically 16-bytes. If
+  * packet size for the given scalar type is 1, then everything is considered well-aligned.
+  *
+  * \note Otherwise, if the Alignment is larger that the scalar size, we rely on the assumptions that sizeof(Scalar) is a
+  * power of 2. On the other hand, we do not assume that the array address is a multiple of sizeof(Scalar), as that fails for
+  * example with Scalar=double on certain 32-bit platforms, see bug #79.
+  *
+  * There is also the variant first_aligned(const MatrixBase&) defined in DenseCoeffsBase.h.
+  * \sa first_default_aligned()
+  */
+template<int Alignment, typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC inline Index first_aligned(const Scalar* array, Index size)
+{
+  const Index ScalarSize = sizeof(Scalar);
+  const Index AlignmentSize = Alignment / ScalarSize;
+  const Index AlignmentMask = AlignmentSize-1;
+
+  if(AlignmentSize<=1)
+  {
+    // Either the requested alignment if smaller than a scalar, or it exactly match a 1 scalar
+    // so that all elements of the array have the same alignment.
+    return 0;
+  }
+  else if( (UIntPtr(array) & (sizeof(Scalar)-1)) || (Alignment%ScalarSize)!=0)
+  {
+    // The array is not aligned to the size of a single scalar, or the requested alignment is not a multiple of the scalar size.
+    // Consequently, no element of the array is well aligned.
+    return size;
+  }
+  else
+  {
+    Index first = (AlignmentSize - (Index((UIntPtr(array)/sizeof(Scalar))) & AlignmentMask)) & AlignmentMask;
+    return (first < size) ? first : size;
+  }
+}
+
+/** \internal Returns the index of the first element of the array that is well aligned with respect the largest packet requirement.
+   * \sa first_aligned(Scalar*,Index) and first_default_aligned(DenseBase<Derived>) */
+template<typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC inline Index first_default_aligned(const Scalar* array, Index size)
+{
+  typedef typename packet_traits<Scalar>::type DefaultPacketType;
+  return first_aligned<unpacket_traits<DefaultPacketType>::alignment>(array, size);
+}
+
+/** \internal Returns the smallest integer multiple of \a base and greater or equal to \a size
+  */
+template<typename Index>
+inline Index first_multiple(Index size, Index base)
+{
+  return ((size+base-1)/base)*base;
+}
+
+// std::copy is much slower than memcpy, so let's introduce a smart_copy which
+// use memcpy on trivial types, i.e., on types that does not require an initialization ctor.
+template<typename T, bool UseMemcpy> struct smart_copy_helper;
+
+template<typename T> EIGEN_DEVICE_FUNC void smart_copy(const T* start, const T* end, T* target)
+{
+  smart_copy_helper<T,!NumTraits<T>::RequireInitialization>::run(start, end, target);
+}
+
+template<typename T> struct smart_copy_helper<T,true> {
+  EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T* target)
+  {
+    IntPtr size = IntPtr(end)-IntPtr(start);
+    if(size==0) return;
+    eigen_internal_assert(start!=0 && end!=0 && target!=0);
+    EIGEN_USING_STD(memcpy)
+    memcpy(target, start, size);
+  }
+};
+
+template<typename T> struct smart_copy_helper<T,false> {
+  EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T* target)
+  { std::copy(start, end, target); }
+};
+
+// intelligent memmove. falls back to std::memmove for POD types, uses std::copy otherwise.
+template<typename T, bool UseMemmove> struct smart_memmove_helper;
+
+template<typename T> void smart_memmove(const T* start, const T* end, T* target)
+{
+  smart_memmove_helper<T,!NumTraits<T>::RequireInitialization>::run(start, end, target);
+}
+
+template<typename T> struct smart_memmove_helper<T,true> {
+  static inline void run(const T* start, const T* end, T* target)
+  {
+    IntPtr size = IntPtr(end)-IntPtr(start);
+    if(size==0) return;
+    eigen_internal_assert(start!=0 && end!=0 && target!=0);
+    std::memmove(target, start, size);
+  }
+};
+
+template<typename T> struct smart_memmove_helper<T,false> {
+  static inline void run(const T* start, const T* end, T* target)
+  {
+    if (UIntPtr(target) < UIntPtr(start))
+    {
+      std::copy(start, end, target);
+    }
+    else
+    {
+      std::ptrdiff_t count = (std::ptrdiff_t(end)-std::ptrdiff_t(start)) / sizeof(T);
+      std::copy_backward(start, end, target + count);
+    }
+  }
+};
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+template<typename T> EIGEN_DEVICE_FUNC T* smart_move(T* start, T* end, T* target)
+{
+  return std::move(start, end, target);
+}
+#else
+template<typename T> EIGEN_DEVICE_FUNC T* smart_move(T* start, T* end, T* target)
+{
+  return std::copy(start, end, target);
+}
+#endif
+
+/*****************************************************************************
+*** Implementation of runtime stack allocation (falling back to malloc)    ***
+*****************************************************************************/
+
+// you can overwrite Eigen's default behavior regarding alloca by defining EIGEN_ALLOCA
+// to the appropriate stack allocation function
+#if ! defined EIGEN_ALLOCA && ! defined EIGEN_GPU_COMPILE_PHASE
+  #if EIGEN_OS_LINUX || EIGEN_OS_MAC || (defined alloca)
+    #define EIGEN_ALLOCA alloca
+  #elif EIGEN_COMP_MSVC
+    #define EIGEN_ALLOCA _alloca
+  #endif
+#endif
+
+// With clang -Oz -mthumb, alloca changes the stack pointer in a way that is
+// not allowed in Thumb2. -DEIGEN_STACK_ALLOCATION_LIMIT=0 doesn't work because
+// the compiler still emits bad code because stack allocation checks use "<=".
+// TODO: Eliminate after https://bugs.llvm.org/show_bug.cgi?id=23772
+// is fixed.
+#if defined(__clang__) && defined(__thumb__)
+  #undef EIGEN_ALLOCA
+#endif
+
+// This helper class construct the allocated memory, and takes care of destructing and freeing the handled data
+// at destruction time. In practice this helper class is mainly useful to avoid memory leak in case of exceptions.
+template<typename T> class aligned_stack_memory_handler : noncopyable
+{
+  public:
+    /* Creates a stack_memory_handler responsible for the buffer \a ptr of size \a size.
+     * Note that \a ptr can be 0 regardless of the other parameters.
+     * This constructor takes care of constructing/initializing the elements of the buffer if required by the scalar type T (see NumTraits<T>::RequireInitialization).
+     * In this case, the buffer elements will also be destructed when this handler will be destructed.
+     * Finally, if \a dealloc is true, then the pointer \a ptr is freed.
+     **/
+    EIGEN_DEVICE_FUNC
+    aligned_stack_memory_handler(T* ptr, std::size_t size, bool dealloc)
+      : m_ptr(ptr), m_size(size), m_deallocate(dealloc)
+    {
+      if(NumTraits<T>::RequireInitialization && m_ptr)
+        Eigen::internal::construct_elements_of_array(m_ptr, size);
+    }
+    EIGEN_DEVICE_FUNC
+    ~aligned_stack_memory_handler()
+    {
+      if(NumTraits<T>::RequireInitialization && m_ptr)
+        Eigen::internal::destruct_elements_of_array<T>(m_ptr, m_size);
+      if(m_deallocate)
+        Eigen::internal::aligned_free(m_ptr);
+    }
+  protected:
+    T* m_ptr;
+    std::size_t m_size;
+    bool m_deallocate;
+};
+
+#ifdef EIGEN_ALLOCA
+
+template<typename Xpr, int NbEvaluations,
+         bool MapExternalBuffer = nested_eval<Xpr,NbEvaluations>::Evaluate && Xpr::MaxSizeAtCompileTime==Dynamic
+         >
+struct local_nested_eval_wrapper
+{
+  static const bool NeedExternalBuffer = false;
+  typedef typename Xpr::Scalar Scalar;
+  typedef typename nested_eval<Xpr,NbEvaluations>::type ObjectType;
+  ObjectType object;
+
+  EIGEN_DEVICE_FUNC
+  local_nested_eval_wrapper(const Xpr& xpr, Scalar* ptr) : object(xpr)
+  {
+    EIGEN_UNUSED_VARIABLE(ptr);
+    eigen_internal_assert(ptr==0);
+  }
+};
+
+template<typename Xpr, int NbEvaluations>
+struct local_nested_eval_wrapper<Xpr,NbEvaluations,true>
+{
+  static const bool NeedExternalBuffer = true;
+  typedef typename Xpr::Scalar Scalar;
+  typedef typename plain_object_eval<Xpr>::type PlainObject;
+  typedef Map<PlainObject,EIGEN_DEFAULT_ALIGN_BYTES> ObjectType;
+  ObjectType object;
+
+  EIGEN_DEVICE_FUNC
+  local_nested_eval_wrapper(const Xpr& xpr, Scalar* ptr)
+    : object(ptr==0 ? reinterpret_cast<Scalar*>(Eigen::internal::aligned_malloc(sizeof(Scalar)*xpr.size())) : ptr, xpr.rows(), xpr.cols()),
+      m_deallocate(ptr==0)
+  {
+    if(NumTraits<Scalar>::RequireInitialization && object.data())
+      Eigen::internal::construct_elements_of_array(object.data(), object.size());
+    object = xpr;
+  }
+
+  EIGEN_DEVICE_FUNC
+  ~local_nested_eval_wrapper()
+  {
+    if(NumTraits<Scalar>::RequireInitialization && object.data())
+      Eigen::internal::destruct_elements_of_array(object.data(), object.size());
+    if(m_deallocate)
+      Eigen::internal::aligned_free(object.data());
+  }
+
+private:
+  bool m_deallocate;
+};
+
+#endif // EIGEN_ALLOCA
+
+template<typename T> class scoped_array : noncopyable
+{
+  T* m_ptr;
+public:
+  explicit scoped_array(std::ptrdiff_t size)
+  {
+    m_ptr = new T[size];
+  }
+  ~scoped_array()
+  {
+    delete[] m_ptr;
+  }
+  T& operator[](std::ptrdiff_t i) { return m_ptr[i]; }
+  const T& operator[](std::ptrdiff_t i) const { return m_ptr[i]; }
+  T* &ptr() { return m_ptr; }
+  const T* ptr() const { return m_ptr; }
+  operator const T*() const { return m_ptr; }
+};
+
+template<typename T> void swap(scoped_array<T> &a,scoped_array<T> &b)
+{
+  std::swap(a.ptr(),b.ptr());
+}
+
+} // end namespace internal
+
+/** \internal
+  *
+  * The macro ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) declares, allocates,
+  * and construct an aligned buffer named NAME of SIZE elements of type TYPE on the stack
+  * if the size in bytes is smaller than EIGEN_STACK_ALLOCATION_LIMIT, and if stack allocation is supported by the platform
+  * (currently, this is Linux, OSX and Visual Studio only). Otherwise the memory is allocated on the heap.
+  * The allocated buffer is automatically deleted when exiting the scope of this declaration.
+  * If BUFFER is non null, then the declared variable is simply an alias for BUFFER, and no allocation/deletion occurs.
+  * Here is an example:
+  * \code
+  * {
+  *   ei_declare_aligned_stack_constructed_variable(float,data,size,0);
+  *   // use data[0] to data[size-1]
+  * }
+  * \endcode
+  * The underlying stack allocation function can controlled with the EIGEN_ALLOCA preprocessor token.
+  *
+  * The macro ei_declare_local_nested_eval(XPR_T,XPR,N,NAME) is analogue to
+  * \code
+  *   typename internal::nested_eval<XPRT_T,N>::type NAME(XPR);
+  * \endcode
+  * with the advantage of using aligned stack allocation even if the maximal size of XPR at compile time is unknown.
+  * This is accomplished through alloca if this later is supported and if the required number of bytes
+  * is below EIGEN_STACK_ALLOCATION_LIMIT.
+  */
+#ifdef EIGEN_ALLOCA
+
+  #if EIGEN_DEFAULT_ALIGN_BYTES>0
+    // We always manually re-align the result of EIGEN_ALLOCA.
+    // If alloca is already aligned, the compiler should be smart enough to optimize away the re-alignment.
+    #define EIGEN_ALIGNED_ALLOCA(SIZE) reinterpret_cast<void*>((internal::UIntPtr(EIGEN_ALLOCA(SIZE+EIGEN_DEFAULT_ALIGN_BYTES-1)) + EIGEN_DEFAULT_ALIGN_BYTES-1) & ~(std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1)))
+  #else
+    #define EIGEN_ALIGNED_ALLOCA(SIZE) EIGEN_ALLOCA(SIZE)
+  #endif
+
+  #define ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) \
+    Eigen::internal::check_size_for_overflow<TYPE>(SIZE); \
+    TYPE* NAME = (BUFFER)!=0 ? (BUFFER) \
+               : reinterpret_cast<TYPE*>( \
+                      (sizeof(TYPE)*SIZE<=EIGEN_STACK_ALLOCATION_LIMIT) ? EIGEN_ALIGNED_ALLOCA(sizeof(TYPE)*SIZE) \
+                    : Eigen::internal::aligned_malloc(sizeof(TYPE)*SIZE) );  \
+    Eigen::internal::aligned_stack_memory_handler<TYPE> EIGEN_CAT(NAME,_stack_memory_destructor)((BUFFER)==0 ? NAME : 0,SIZE,sizeof(TYPE)*SIZE>EIGEN_STACK_ALLOCATION_LIMIT)
+
+
+  #define ei_declare_local_nested_eval(XPR_T,XPR,N,NAME) \
+    Eigen::internal::local_nested_eval_wrapper<XPR_T,N> EIGEN_CAT(NAME,_wrapper)(XPR, reinterpret_cast<typename XPR_T::Scalar*>( \
+      ( (Eigen::internal::local_nested_eval_wrapper<XPR_T,N>::NeedExternalBuffer) && ((sizeof(typename XPR_T::Scalar)*XPR.size())<=EIGEN_STACK_ALLOCATION_LIMIT) ) \
+        ? EIGEN_ALIGNED_ALLOCA( sizeof(typename XPR_T::Scalar)*XPR.size() ) : 0 ) ) ; \
+    typename Eigen::internal::local_nested_eval_wrapper<XPR_T,N>::ObjectType NAME(EIGEN_CAT(NAME,_wrapper).object)
+
+#else
+
+  #define ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) \
+    Eigen::internal::check_size_for_overflow<TYPE>(SIZE); \
+    TYPE* NAME = (BUFFER)!=0 ? BUFFER : reinterpret_cast<TYPE*>(Eigen::internal::aligned_malloc(sizeof(TYPE)*SIZE));    \
+    Eigen::internal::aligned_stack_memory_handler<TYPE> EIGEN_CAT(NAME,_stack_memory_destructor)((BUFFER)==0 ? NAME : 0,SIZE,true)
+
+
+#define ei_declare_local_nested_eval(XPR_T,XPR,N,NAME) typename Eigen::internal::nested_eval<XPR_T,N>::type NAME(XPR)
+
+#endif
+
+
+/*****************************************************************************
+*** Implementation of EIGEN_MAKE_ALIGNED_OPERATOR_NEW [_IF]                ***
+*****************************************************************************/
+
+#if EIGEN_HAS_CXX17_OVERALIGN
+
+// C++17 -> no need to bother about alignment anymore :)
+
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign)
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar,Size)
+
+#else
+
+// HIP does not support new/delete on device.
+#if EIGEN_MAX_ALIGN_BYTES!=0 && !defined(EIGEN_HIP_DEVICE_COMPILE)
+  #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \
+      EIGEN_DEVICE_FUNC \
+      void* operator new(std::size_t size, const std::nothrow_t&) EIGEN_NO_THROW { \
+        EIGEN_TRY { return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); } \
+        EIGEN_CATCH (...) { return 0; } \
+      }
+  #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) \
+      EIGEN_DEVICE_FUNC \
+      void *operator new(std::size_t size) { \
+        return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \
+      } \
+      EIGEN_DEVICE_FUNC \
+      void *operator new[](std::size_t size) { \
+        return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \
+      } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete(void * ptr) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete[](void * ptr) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete(void * ptr, std::size_t /* sz */) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete[](void * ptr, std::size_t /* sz */) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      /* in-place new and delete. since (at least afaik) there is no actual   */ \
+      /* memory allocated we can safely let the default implementation handle */ \
+      /* this particular case. */ \
+      EIGEN_DEVICE_FUNC \
+      static void *operator new(std::size_t size, void *ptr) { return ::operator new(size,ptr); } \
+      EIGEN_DEVICE_FUNC \
+      static void *operator new[](std::size_t size, void* ptr) { return ::operator new[](size,ptr); } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete(void * memory, void *ptr) EIGEN_NO_THROW { return ::operator delete(memory,ptr); } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete[](void * memory, void *ptr) EIGEN_NO_THROW { return ::operator delete[](memory,ptr); } \
+      /* nothrow-new (returns zero instead of std::bad_alloc) */ \
+      EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \
+      EIGEN_DEVICE_FUNC \
+      void operator delete(void *ptr, const std::nothrow_t&) EIGEN_NO_THROW { \
+        Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); \
+      } \
+      typedef void eigen_aligned_operator_new_marker_type;
+#else
+  #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
+#endif
+
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar,Size)                        \
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(bool(                                                             \
+        ((Size)!=Eigen::Dynamic) &&                                                                    \
+        (((EIGEN_MAX_ALIGN_BYTES>=16) && ((sizeof(Scalar)*(Size))%(EIGEN_MAX_ALIGN_BYTES  )==0)) ||    \
+         ((EIGEN_MAX_ALIGN_BYTES>=32) && ((sizeof(Scalar)*(Size))%(EIGEN_MAX_ALIGN_BYTES/2)==0)) ||    \
+         ((EIGEN_MAX_ALIGN_BYTES>=64) && ((sizeof(Scalar)*(Size))%(EIGEN_MAX_ALIGN_BYTES/4)==0))   )))
+
+#endif
+
+/****************************************************************************/
+
+/** \class aligned_allocator
+* \ingroup Core_Module
+*
+* \brief STL compatible allocator to use with types requiring a non standrad alignment.
+*
+* The memory is aligned as for dynamically aligned matrix/array types such as MatrixXd.
+* By default, it will thus provide at least 16 bytes alignment and more in following cases:
+*  - 32 bytes alignment if AVX is enabled.
+*  - 64 bytes alignment if AVX512 is enabled.
+*
+* This can be controlled using the \c EIGEN_MAX_ALIGN_BYTES macro as documented
+* \link TopicPreprocessorDirectivesPerformance there \endlink.
+*
+* Example:
+* \code
+* // Matrix4f requires 16 bytes alignment:
+* std::map< int, Matrix4f, std::less<int>,
+*           aligned_allocator<std::pair<const int, Matrix4f> > > my_map_mat4;
+* // Vector3f does not require 16 bytes alignment, no need to use Eigen's allocator:
+* std::map< int, Vector3f > my_map_vec3;
+* \endcode
+*
+* \sa \blank \ref TopicStlContainers.
+*/
+template<class T>
+class aligned_allocator : public std::allocator<T>
+{
+public:
+  typedef std::size_t     size_type;
+  typedef std::ptrdiff_t  difference_type;
+  typedef T*              pointer;
+  typedef const T*        const_pointer;
+  typedef T&              reference;
+  typedef const T&        const_reference;
+  typedef T               value_type;
+
+  template<class U>
+  struct rebind
+  {
+    typedef aligned_allocator<U> other;
+  };
+
+  aligned_allocator() : std::allocator<T>() {}
+
+  aligned_allocator(const aligned_allocator& other) : std::allocator<T>(other) {}
+
+  template<class U>
+  aligned_allocator(const aligned_allocator<U>& other) : std::allocator<T>(other) {}
+
+  ~aligned_allocator() {}
+
+  #if EIGEN_COMP_GNUC_STRICT && EIGEN_GNUC_AT_LEAST(7,0)
+  // In gcc std::allocator::max_size() is bugged making gcc triggers a warning:
+  // eigen/Eigen/src/Core/util/Memory.h:189:12: warning: argument 1 value '18446744073709551612' exceeds maximum object size 9223372036854775807
+  // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87544
+  size_type max_size() const {
+    return (std::numeric_limits<std::ptrdiff_t>::max)()/sizeof(T);
+  }
+  #endif
+
+  pointer allocate(size_type num, const void* /*hint*/ = 0)
+  {
+    internal::check_size_for_overflow<T>(num);
+    return static_cast<pointer>( internal::aligned_malloc(num * sizeof(T)) );
+  }
+
+  void deallocate(pointer p, size_type /*num*/)
+  {
+    internal::aligned_free(p);
+  }
+};
+
+//---------- Cache sizes ----------
+
+#if !defined(EIGEN_NO_CPUID)
+#  if EIGEN_COMP_GNUC && EIGEN_ARCH_i386_OR_x86_64
+#    if defined(__PIC__) && EIGEN_ARCH_i386
+       // Case for x86 with PIC
+#      define EIGEN_CPUID(abcd,func,id) \
+         __asm__ __volatile__ ("xchgl %%ebx, %k1;cpuid; xchgl %%ebx,%k1": "=a" (abcd[0]), "=&r" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "a" (func), "c" (id));
+#    elif defined(__PIC__) && EIGEN_ARCH_x86_64
+       // Case for x64 with PIC. In theory this is only a problem with recent gcc and with medium or large code model, not with the default small code model.
+       // However, we cannot detect which code model is used, and the xchg overhead is negligible anyway.
+#      define EIGEN_CPUID(abcd,func,id) \
+        __asm__ __volatile__ ("xchg{q}\t{%%}rbx, %q1; cpuid; xchg{q}\t{%%}rbx, %q1": "=a" (abcd[0]), "=&r" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "0" (func), "2" (id));
+#    else
+       // Case for x86_64 or x86 w/o PIC
+#      define EIGEN_CPUID(abcd,func,id) \
+         __asm__ __volatile__ ("cpuid": "=a" (abcd[0]), "=b" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "0" (func), "2" (id) );
+#    endif
+#  elif EIGEN_COMP_MSVC
+#    if (EIGEN_COMP_MSVC > 1500) && EIGEN_ARCH_i386_OR_x86_64
+#      define EIGEN_CPUID(abcd,func,id) __cpuidex((int*)abcd,func,id)
+#    endif
+#  endif
+#endif
+
+namespace internal {
+
+#ifdef EIGEN_CPUID
+
+inline bool cpuid_is_vendor(int abcd[4], const int vendor[3])
+{
+  return abcd[1]==vendor[0] && abcd[3]==vendor[1] && abcd[2]==vendor[2];
+}
+
+inline void queryCacheSizes_intel_direct(int& l1, int& l2, int& l3)
+{
+  int abcd[4];
+  l1 = l2 = l3 = 0;
+  int cache_id = 0;
+  int cache_type = 0;
+  do {
+    abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+    EIGEN_CPUID(abcd,0x4,cache_id);
+    cache_type  = (abcd[0] & 0x0F) >> 0;
+    if(cache_type==1||cache_type==3) // data or unified cache
+    {
+      int cache_level = (abcd[0] & 0xE0) >> 5;  // A[7:5]
+      int ways        = (abcd[1] & 0xFFC00000) >> 22; // B[31:22]
+      int partitions  = (abcd[1] & 0x003FF000) >> 12; // B[21:12]
+      int line_size   = (abcd[1] & 0x00000FFF) >>  0; // B[11:0]
+      int sets        = (abcd[2]);                    // C[31:0]
+
+      int cache_size = (ways+1) * (partitions+1) * (line_size+1) * (sets+1);
+
+      switch(cache_level)
+      {
+        case 1: l1 = cache_size; break;
+        case 2: l2 = cache_size; break;
+        case 3: l3 = cache_size; break;
+        default: break;
+      }
+    }
+    cache_id++;
+  } while(cache_type>0 && cache_id<16);
+}
+
+inline void queryCacheSizes_intel_codes(int& l1, int& l2, int& l3)
+{
+  int abcd[4];
+  abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+  l1 = l2 = l3 = 0;
+  EIGEN_CPUID(abcd,0x00000002,0);
+  unsigned char * bytes = reinterpret_cast<unsigned char *>(abcd)+2;
+  bool check_for_p2_core2 = false;
+  for(int i=0; i<14; ++i)
+  {
+    switch(bytes[i])
+    {
+      case 0x0A: l1 = 8; break;   // 0Ah   data L1 cache, 8 KB, 2 ways, 32 byte lines
+      case 0x0C: l1 = 16; break;  // 0Ch   data L1 cache, 16 KB, 4 ways, 32 byte lines
+      case 0x0E: l1 = 24; break;  // 0Eh   data L1 cache, 24 KB, 6 ways, 64 byte lines
+      case 0x10: l1 = 16; break;  // 10h   data L1 cache, 16 KB, 4 ways, 32 byte lines (IA-64)
+      case 0x15: l1 = 16; break;  // 15h   code L1 cache, 16 KB, 4 ways, 32 byte lines (IA-64)
+      case 0x2C: l1 = 32; break;  // 2Ch   data L1 cache, 32 KB, 8 ways, 64 byte lines
+      case 0x30: l1 = 32; break;  // 30h   code L1 cache, 32 KB, 8 ways, 64 byte lines
+      case 0x60: l1 = 16; break;  // 60h   data L1 cache, 16 KB, 8 ways, 64 byte lines, sectored
+      case 0x66: l1 = 8; break;   // 66h   data L1 cache, 8 KB, 4 ways, 64 byte lines, sectored
+      case 0x67: l1 = 16; break;  // 67h   data L1 cache, 16 KB, 4 ways, 64 byte lines, sectored
+      case 0x68: l1 = 32; break;  // 68h   data L1 cache, 32 KB, 4 ways, 64 byte lines, sectored
+      case 0x1A: l2 = 96; break;   // code and data L2 cache, 96 KB, 6 ways, 64 byte lines (IA-64)
+      case 0x22: l3 = 512; break;   // code and data L3 cache, 512 KB, 4 ways (!), 64 byte lines, dual-sectored
+      case 0x23: l3 = 1024; break;   // code and data L3 cache, 1024 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x25: l3 = 2048; break;   // code and data L3 cache, 2048 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x29: l3 = 4096; break;   // code and data L3 cache, 4096 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x39: l2 = 128; break;   // code and data L2 cache, 128 KB, 4 ways, 64 byte lines, sectored
+      case 0x3A: l2 = 192; break;   // code and data L2 cache, 192 KB, 6 ways, 64 byte lines, sectored
+      case 0x3B: l2 = 128; break;   // code and data L2 cache, 128 KB, 2 ways, 64 byte lines, sectored
+      case 0x3C: l2 = 256; break;   // code and data L2 cache, 256 KB, 4 ways, 64 byte lines, sectored
+      case 0x3D: l2 = 384; break;   // code and data L2 cache, 384 KB, 6 ways, 64 byte lines, sectored
+      case 0x3E: l2 = 512; break;   // code and data L2 cache, 512 KB, 4 ways, 64 byte lines, sectored
+      case 0x40: l2 = 0; break;   // no integrated L2 cache (P6 core) or L3 cache (P4 core)
+      case 0x41: l2 = 128; break;   // code and data L2 cache, 128 KB, 4 ways, 32 byte lines
+      case 0x42: l2 = 256; break;   // code and data L2 cache, 256 KB, 4 ways, 32 byte lines
+      case 0x43: l2 = 512; break;   // code and data L2 cache, 512 KB, 4 ways, 32 byte lines
+      case 0x44: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 4 ways, 32 byte lines
+      case 0x45: l2 = 2048; break;   // code and data L2 cache, 2048 KB, 4 ways, 32 byte lines
+      case 0x46: l3 = 4096; break;   // code and data L3 cache, 4096 KB, 4 ways, 64 byte lines
+      case 0x47: l3 = 8192; break;   // code and data L3 cache, 8192 KB, 8 ways, 64 byte lines
+      case 0x48: l2 = 3072; break;   // code and data L2 cache, 3072 KB, 12 ways, 64 byte lines
+      case 0x49: if(l2!=0) l3 = 4096; else {check_for_p2_core2=true; l3 = l2 = 4096;} break;// code and data L3 cache, 4096 KB, 16 ways, 64 byte lines (P4) or L2 for core2
+      case 0x4A: l3 = 6144; break;   // code and data L3 cache, 6144 KB, 12 ways, 64 byte lines
+      case 0x4B: l3 = 8192; break;   // code and data L3 cache, 8192 KB, 16 ways, 64 byte lines
+      case 0x4C: l3 = 12288; break;   // code and data L3 cache, 12288 KB, 12 ways, 64 byte lines
+      case 0x4D: l3 = 16384; break;   // code and data L3 cache, 16384 KB, 16 ways, 64 byte lines
+      case 0x4E: l2 = 6144; break;   // code and data L2 cache, 6144 KB, 24 ways, 64 byte lines
+      case 0x78: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 4 ways, 64 byte lines
+      case 0x79: l2 = 128; break;   // code and data L2 cache, 128 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7A: l2 = 256; break;   // code and data L2 cache, 256 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7B: l2 = 512; break;   // code and data L2 cache, 512 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7C: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7D: l2 = 2048; break;   // code and data L2 cache, 2048 KB, 8 ways, 64 byte lines
+      case 0x7E: l2 = 256; break;   // code and data L2 cache, 256 KB, 8 ways, 128 byte lines, sect. (IA-64)
+      case 0x7F: l2 = 512; break;   // code and data L2 cache, 512 KB, 2 ways, 64 byte lines
+      case 0x80: l2 = 512; break;   // code and data L2 cache, 512 KB, 8 ways, 64 byte lines
+      case 0x81: l2 = 128; break;   // code and data L2 cache, 128 KB, 8 ways, 32 byte lines
+      case 0x82: l2 = 256; break;   // code and data L2 cache, 256 KB, 8 ways, 32 byte lines
+      case 0x83: l2 = 512; break;   // code and data L2 cache, 512 KB, 8 ways, 32 byte lines
+      case 0x84: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 8 ways, 32 byte lines
+      case 0x85: l2 = 2048; break;   // code and data L2 cache, 2048 KB, 8 ways, 32 byte lines
+      case 0x86: l2 = 512; break;   // code and data L2 cache, 512 KB, 4 ways, 64 byte lines
+      case 0x87: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 8 ways, 64 byte lines
+      case 0x88: l3 = 2048; break;   // code and data L3 cache, 2048 KB, 4 ways, 64 byte lines (IA-64)
+      case 0x89: l3 = 4096; break;   // code and data L3 cache, 4096 KB, 4 ways, 64 byte lines (IA-64)
+      case 0x8A: l3 = 8192; break;   // code and data L3 cache, 8192 KB, 4 ways, 64 byte lines (IA-64)
+      case 0x8D: l3 = 3072; break;   // code and data L3 cache, 3072 KB, 12 ways, 128 byte lines (IA-64)
+
+      default: break;
+    }
+  }
+  if(check_for_p2_core2 && l2 == l3)
+    l3 = 0;
+  l1 *= 1024;
+  l2 *= 1024;
+  l3 *= 1024;
+}
+
+inline void queryCacheSizes_intel(int& l1, int& l2, int& l3, int max_std_funcs)
+{
+  if(max_std_funcs>=4)
+    queryCacheSizes_intel_direct(l1,l2,l3);
+  else if(max_std_funcs>=2)
+    queryCacheSizes_intel_codes(l1,l2,l3);
+  else
+    l1 = l2 = l3 = 0;
+}
+
+inline void queryCacheSizes_amd(int& l1, int& l2, int& l3)
+{
+  int abcd[4];
+  abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+  
+  // First query the max supported function.
+  EIGEN_CPUID(abcd,0x80000000,0);
+  if(static_cast<numext::uint32_t>(abcd[0]) >= static_cast<numext::uint32_t>(0x80000006))
+  {
+    EIGEN_CPUID(abcd,0x80000005,0);
+    l1 = (abcd[2] >> 24) * 1024; // C[31:24] = L1 size in KB
+    abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+    EIGEN_CPUID(abcd,0x80000006,0);
+    l2 = (abcd[2] >> 16) * 1024; // C[31;16] = l2 cache size in KB
+    l3 = ((abcd[3] & 0xFFFC000) >> 18) * 512 * 1024; // D[31;18] = l3 cache size in 512KB
+  }
+  else
+  {
+    l1 = l2 = l3 = 0;
+  }
+}
+#endif
+
+/** \internal
+ * Queries and returns the cache sizes in Bytes of the L1, L2, and L3 data caches respectively */
+inline void queryCacheSizes(int& l1, int& l2, int& l3)
+{
+  #ifdef EIGEN_CPUID
+  int abcd[4];
+  const int GenuineIntel[] = {0x756e6547, 0x49656e69, 0x6c65746e};
+  const int AuthenticAMD[] = {0x68747541, 0x69746e65, 0x444d4163};
+  const int AMDisbetter_[] = {0x69444d41, 0x74656273, 0x21726574}; // "AMDisbetter!"
+
+  // identify the CPU vendor
+  EIGEN_CPUID(abcd,0x0,0);
+  int max_std_funcs = abcd[0];
+  if(cpuid_is_vendor(abcd,GenuineIntel))
+    queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
+  else if(cpuid_is_vendor(abcd,AuthenticAMD) || cpuid_is_vendor(abcd,AMDisbetter_))
+    queryCacheSizes_amd(l1,l2,l3);
+  else
+    // by default let's use Intel's API
+    queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
+
+  // here is the list of other vendors:
+//   ||cpuid_is_vendor(abcd,"VIA VIA VIA ")
+//   ||cpuid_is_vendor(abcd,"CyrixInstead")
+//   ||cpuid_is_vendor(abcd,"CentaurHauls")
+//   ||cpuid_is_vendor(abcd,"GenuineTMx86")
+//   ||cpuid_is_vendor(abcd,"TransmetaCPU")
+//   ||cpuid_is_vendor(abcd,"RiseRiseRise")
+//   ||cpuid_is_vendor(abcd,"Geode by NSC")
+//   ||cpuid_is_vendor(abcd,"SiS SiS SiS ")
+//   ||cpuid_is_vendor(abcd,"UMC UMC UMC ")
+//   ||cpuid_is_vendor(abcd,"NexGenDriven")
+  #else
+  l1 = l2 = l3 = -1;
+  #endif
+}
+
+/** \internal
+ * \returns the size in Bytes of the L1 data cache */
+inline int queryL1CacheSize()
+{
+  int l1(-1), l2, l3;
+  queryCacheSizes(l1,l2,l3);
+  return l1;
+}
+
+/** \internal
+ * \returns the size in Bytes of the L2 or L3 cache if this later is present */
+inline int queryTopLevelCacheSize()
+{
+  int l1, l2(-1), l3(-1);
+  queryCacheSizes(l1,l2,l3);
+  return (std::max)(l2,l3);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MEMORY_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/Meta.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/Meta.h
new file mode 100644
index 00000000..81ae2a32
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/Meta.h
@@ -0,0 +1,812 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_META_H
+#define EIGEN_META_H
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+
+ #include <cfloat>
+
+ #if defined(EIGEN_CUDA_ARCH)
+  #include <math_constants.h>
+ #endif
+
+ #if defined(EIGEN_HIP_DEVICE_COMPILE)
+  #include "Eigen/src/Core/arch/HIP/hcc/math_constants.h"
+  #endif
+
+#endif
+
+// Recent versions of ICC require <cstdint> for pointer types below.
+#define EIGEN_ICC_NEEDS_CSTDINT (EIGEN_COMP_ICC>=1600 && EIGEN_COMP_CXXVER >= 11)
+
+// Define portable (u)int{32,64} types
+#if EIGEN_HAS_CXX11 || EIGEN_ICC_NEEDS_CSTDINT
+#include <cstdint>
+namespace Eigen {
+namespace numext {
+typedef std::uint8_t  uint8_t;
+typedef std::int8_t   int8_t;
+typedef std::uint16_t uint16_t;
+typedef std::int16_t  int16_t;
+typedef std::uint32_t uint32_t;
+typedef std::int32_t  int32_t;
+typedef std::uint64_t uint64_t;
+typedef std::int64_t  int64_t;
+}
+}
+#else
+// Without c++11, all compilers able to compile Eigen also
+// provide the C99 stdint.h header file.
+#include <stdint.h>
+namespace Eigen {
+namespace numext {
+typedef ::uint8_t  uint8_t;
+typedef ::int8_t   int8_t;
+typedef ::uint16_t uint16_t;
+typedef ::int16_t  int16_t;
+typedef ::uint32_t uint32_t;
+typedef ::int32_t  int32_t;
+typedef ::uint64_t uint64_t;
+typedef ::int64_t  int64_t;
+}
+}
+#endif
+
+namespace Eigen {
+
+typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE DenseIndex;
+
+/**
+ * \brief The Index type as used for the API.
+ * \details To change this, \c \#define the preprocessor symbol \c EIGEN_DEFAULT_DENSE_INDEX_TYPE.
+ * \sa \blank \ref TopicPreprocessorDirectives, StorageIndex.
+ */
+
+typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Index;
+
+namespace internal {
+
+/** \internal
+  * \file Meta.h
+  * This file contains generic metaprogramming classes which are not specifically related to Eigen.
+  * \note In case you wonder, yes we're aware that Boost already provides all these features,
+  * we however don't want to add a dependency to Boost.
+  */
+
+// Only recent versions of ICC complain about using ptrdiff_t to hold pointers,
+// and older versions do not provide *intptr_t types.
+#if EIGEN_ICC_NEEDS_CSTDINT
+typedef std::intptr_t  IntPtr;
+typedef std::uintptr_t UIntPtr;
+#else
+typedef std::ptrdiff_t IntPtr;
+typedef std::size_t UIntPtr;
+#endif
+#undef EIGEN_ICC_NEEDS_CSTDINT
+
+struct true_type {  enum { value = 1 }; };
+struct false_type { enum { value = 0 }; };
+
+template<bool Condition>
+struct bool_constant;
+
+template<>
+struct bool_constant<true> : true_type {};
+
+template<>
+struct bool_constant<false> : false_type {};
+
+template<bool Condition, typename Then, typename Else>
+struct conditional { typedef Then type; };
+
+template<typename Then, typename Else>
+struct conditional <false, Then, Else> { typedef Else type; };
+
+template<typename T> struct remove_reference { typedef T type; };
+template<typename T> struct remove_reference<T&> { typedef T type; };
+
+template<typename T> struct remove_pointer { typedef T type; };
+template<typename T> struct remove_pointer<T*> { typedef T type; };
+template<typename T> struct remove_pointer<T*const> { typedef T type; };
+
+template <class T> struct remove_const { typedef T type; };
+template <class T> struct remove_const<const T> { typedef T type; };
+template <class T> struct remove_const<const T[]> { typedef T type[]; };
+template <class T, unsigned int Size> struct remove_const<const T[Size]> { typedef T type[Size]; };
+
+template<typename T> struct remove_all { typedef T type; };
+template<typename T> struct remove_all<const T>   { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T const&>  { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T&>        { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T const*>  { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T*>        { typedef typename remove_all<T>::type type; };
+
+template<typename T> struct is_arithmetic      { enum { value = false }; };
+template<> struct is_arithmetic<float>         { enum { value = true }; };
+template<> struct is_arithmetic<double>        { enum { value = true }; };
+template<> struct is_arithmetic<long double>   { enum { value = true }; };
+template<> struct is_arithmetic<bool>          { enum { value = true }; };
+template<> struct is_arithmetic<char>          { enum { value = true }; };
+template<> struct is_arithmetic<signed char>   { enum { value = true }; };
+template<> struct is_arithmetic<unsigned char> { enum { value = true }; };
+template<> struct is_arithmetic<signed short>  { enum { value = true }; };
+template<> struct is_arithmetic<unsigned short>{ enum { value = true }; };
+template<> struct is_arithmetic<signed int>    { enum { value = true }; };
+template<> struct is_arithmetic<unsigned int>  { enum { value = true }; };
+template<> struct is_arithmetic<signed long>   { enum { value = true }; };
+template<> struct is_arithmetic<unsigned long> { enum { value = true }; };
+
+template<typename T, typename U> struct is_same { enum { value = 0 }; };
+template<typename T> struct is_same<T,T> { enum { value = 1 }; };
+
+template< class T >
+struct is_void : is_same<void, typename remove_const<T>::type> {};
+
+#if EIGEN_HAS_CXX11
+template<> struct is_arithmetic<signed long long>   { enum { value = true }; };
+template<> struct is_arithmetic<unsigned long long> { enum { value = true }; };
+using std::is_integral;
+#else
+template<typename T> struct is_integral               { enum { value = false }; };
+template<> struct is_integral<bool>                   { enum { value = true }; };
+template<> struct is_integral<char>                   { enum { value = true }; };
+template<> struct is_integral<signed char>            { enum { value = true }; };
+template<> struct is_integral<unsigned char>          { enum { value = true }; };
+template<> struct is_integral<signed short>           { enum { value = true }; };
+template<> struct is_integral<unsigned short>         { enum { value = true }; };
+template<> struct is_integral<signed int>             { enum { value = true }; };
+template<> struct is_integral<unsigned int>           { enum { value = true }; };
+template<> struct is_integral<signed long>            { enum { value = true }; };
+template<> struct is_integral<unsigned long>          { enum { value = true }; };
+#if EIGEN_COMP_MSVC
+template<> struct is_integral<signed __int64>         { enum { value = true }; };
+template<> struct is_integral<unsigned __int64>       { enum { value = true }; };
+#endif
+#endif
+
+#if EIGEN_HAS_CXX11
+using std::make_unsigned;
+#else
+// TODO: Possibly improve this implementation of make_unsigned.
+// It is currently used only by
+// template<typename Scalar> struct random_default_impl<Scalar, false, true>.
+template<typename> struct make_unsigned;
+template<> struct make_unsigned<char>             { typedef unsigned char type; };
+template<> struct make_unsigned<signed char>      { typedef unsigned char type; };
+template<> struct make_unsigned<unsigned char>    { typedef unsigned char type; };
+template<> struct make_unsigned<signed short>     { typedef unsigned short type; };
+template<> struct make_unsigned<unsigned short>   { typedef unsigned short type; };
+template<> struct make_unsigned<signed int>       { typedef unsigned int type; };
+template<> struct make_unsigned<unsigned int>     { typedef unsigned int type; };
+template<> struct make_unsigned<signed long>      { typedef unsigned long type; };
+template<> struct make_unsigned<unsigned long>    { typedef unsigned long type; };
+#if EIGEN_COMP_MSVC
+template<> struct make_unsigned<signed __int64>   { typedef unsigned __int64 type; };
+template<> struct make_unsigned<unsigned __int64> { typedef unsigned __int64 type; };
+#endif
+
+// Some platforms define int64_t as `long long` even for C++03, where
+// `long long` is not guaranteed by the standard. In this case we are missing
+// the definition for make_unsigned. If we just define it, we run into issues
+// where `long long` doesn't exist in some compilers for C++03. We therefore add
+// the specialization for these platforms only.
+#if EIGEN_OS_MAC || EIGEN_COMP_MINGW
+template<> struct make_unsigned<unsigned long long> { typedef unsigned long long type; };
+template<> struct make_unsigned<long long>          { typedef unsigned long long type; };
+#endif
+#endif
+
+template <typename T> struct add_const { typedef const T type; };
+template <typename T> struct add_const<T&> { typedef T& type; };
+
+template <typename T> struct is_const { enum { value = 0 }; };
+template <typename T> struct is_const<T const> { enum { value = 1 }; };
+
+template<typename T> struct add_const_on_value_type            { typedef const T type;  };
+template<typename T> struct add_const_on_value_type<T&>        { typedef T const& type; };
+template<typename T> struct add_const_on_value_type<T*>        { typedef T const* type; };
+template<typename T> struct add_const_on_value_type<T* const>  { typedef T const* const type; };
+template<typename T> struct add_const_on_value_type<T const* const>  { typedef T const* const type; };
+
+#if EIGEN_HAS_CXX11
+
+using std::is_convertible;
+
+#else
+
+template<typename From, typename To>
+struct is_convertible_impl
+{
+private:
+  struct any_conversion
+  {
+    template <typename T> any_conversion(const volatile T&);
+    template <typename T> any_conversion(T&);
+  };
+  struct yes {int a[1];};
+  struct no  {int a[2];};
+
+  template<typename T>
+  static yes test(T, int);
+
+  template<typename T>
+  static no  test(any_conversion, ...);
+
+public:
+  static typename internal::remove_reference<From>::type* ms_from;
+#ifdef __INTEL_COMPILER
+  #pragma warning push
+  #pragma warning ( disable : 2259 )
+#endif
+  enum { value = sizeof(test<To>(*ms_from, 0))==sizeof(yes) };
+#ifdef __INTEL_COMPILER
+  #pragma warning pop
+#endif
+};
+
+template<typename From, typename To>
+struct is_convertible
+{
+  enum { value = is_convertible_impl<From,To>::value };
+};
+
+template<typename T>
+struct is_convertible<T,T&> { enum { value = false }; };
+
+template<typename T>
+struct is_convertible<const T,const T&> { enum { value = true }; };
+
+#endif
+
+/** \internal Allows to enable/disable an overload
+  * according to a compile time condition.
+  */
+template<bool Condition, typename T=void> struct enable_if;
+
+template<typename T> struct enable_if<true,T>
+{ typedef T type; };
+
+#if defined(EIGEN_GPU_COMPILE_PHASE) && !EIGEN_HAS_CXX11
+#if !defined(__FLT_EPSILON__)
+#define __FLT_EPSILON__ FLT_EPSILON
+#define __DBL_EPSILON__ DBL_EPSILON
+#endif
+
+namespace device {
+
+template<typename T> struct numeric_limits
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_CONSTEXPR T epsilon() { return 0; }
+  static T (max)() { assert(false && "Highest not supported for this type"); }
+  static T (min)() { assert(false && "Lowest not supported for this type"); }
+  static T infinity() { assert(false && "Infinity not supported for this type"); }
+  static T quiet_NaN() { assert(false && "quiet_NaN not supported for this type"); }
+};
+template<> struct numeric_limits<float>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static float epsilon() { return __FLT_EPSILON__; }
+  EIGEN_DEVICE_FUNC
+  static float (max)() {
+  #if defined(EIGEN_CUDA_ARCH)
+    return CUDART_MAX_NORMAL_F;
+  #else
+    return HIPRT_MAX_NORMAL_F;
+  #endif
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static float (min)() { return FLT_MIN; }
+  EIGEN_DEVICE_FUNC
+  static float infinity() {
+  #if defined(EIGEN_CUDA_ARCH)
+    return CUDART_INF_F;
+  #else
+    return HIPRT_INF_F;
+  #endif
+  }
+  EIGEN_DEVICE_FUNC
+  static float quiet_NaN() {
+  #if defined(EIGEN_CUDA_ARCH)
+    return CUDART_NAN_F;
+  #else
+    return HIPRT_NAN_F;
+  #endif
+  }
+};
+template<> struct numeric_limits<double>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static double epsilon() { return __DBL_EPSILON__; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static double (max)() { return DBL_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static double (min)() { return DBL_MIN; }
+  EIGEN_DEVICE_FUNC
+  static double infinity() {
+  #if defined(EIGEN_CUDA_ARCH)
+    return CUDART_INF;
+  #else
+    return HIPRT_INF;
+  #endif
+  }
+  EIGEN_DEVICE_FUNC
+  static double quiet_NaN() {
+  #if defined(EIGEN_CUDA_ARCH)
+    return CUDART_NAN;
+  #else
+    return HIPRT_NAN;
+  #endif
+  }
+};
+template<> struct numeric_limits<int>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int (max)() { return INT_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int (min)() { return INT_MIN; }
+};
+template<> struct numeric_limits<unsigned int>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned int epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned int (max)() { return UINT_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned int (min)() { return 0; }
+};
+template<> struct numeric_limits<long>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long (max)() { return LONG_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long (min)() { return LONG_MIN; }
+};
+template<> struct numeric_limits<unsigned long>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long (max)() { return ULONG_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long (min)() { return 0; }
+};
+template<> struct numeric_limits<long long>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long long (max)() { return LLONG_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long long (min)() { return LLONG_MIN; }
+};
+template<> struct numeric_limits<unsigned long long>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long long (max)() { return ULLONG_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long long (min)() { return 0; }
+};
+template<> struct numeric_limits<bool>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static bool epsilon() { return false; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static bool (max)() { return true; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR 
+  static bool (min)() { return false; }
+};
+
+}
+
+#endif // defined(EIGEN_GPU_COMPILE_PHASE) && !EIGEN_HAS_CXX11
+
+/** \internal
+  * A base class do disable default copy ctor and copy assignment operator.
+  */
+class noncopyable
+{
+  EIGEN_DEVICE_FUNC noncopyable(const noncopyable&);
+  EIGEN_DEVICE_FUNC const noncopyable& operator=(const noncopyable&);
+protected:
+  EIGEN_DEVICE_FUNC noncopyable() {}
+  EIGEN_DEVICE_FUNC ~noncopyable() {}
+};
+
+/** \internal
+  * Provides access to the number of elements in the object of as a compile-time constant expression.
+  * It "returns" Eigen::Dynamic if the size cannot be resolved at compile-time (default).
+  *
+  * Similar to std::tuple_size, but more general.
+  *
+  * It currently supports:
+  *  - any types T defining T::SizeAtCompileTime
+  *  - plain C arrays as T[N]
+  *  - std::array (c++11)
+  *  - some internal types such as SingleRange and AllRange
+  *
+  * The second template parameter eases SFINAE-based specializations.
+  */
+template<typename T, typename EnableIf = void> struct array_size {
+  enum { value = Dynamic };
+};
+
+template<typename T> struct array_size<T,typename internal::enable_if<((T::SizeAtCompileTime&0)==0)>::type> {
+  enum { value = T::SizeAtCompileTime };
+};
+
+template<typename T, int N> struct array_size<const T (&)[N]> {
+  enum { value = N };
+};
+template<typename T, int N> struct array_size<T (&)[N]> {
+  enum { value = N };
+};
+
+#if EIGEN_HAS_CXX11
+template<typename T, std::size_t N> struct array_size<const std::array<T,N> > {
+  enum { value = N };
+};
+template<typename T, std::size_t N> struct array_size<std::array<T,N> > {
+  enum { value = N };
+};
+#endif
+
+/** \internal
+  * Analogue of the std::size free function.
+  * It returns the size of the container or view \a x of type \c T
+  *
+  * It currently supports:
+  *  - any types T defining a member T::size() const
+  *  - plain C arrays as T[N]
+  *
+  */
+template<typename T>
+EIGEN_CONSTEXPR Index size(const T& x) { return x.size(); }
+
+template<typename T,std::size_t N>
+EIGEN_CONSTEXPR Index size(const T (&) [N]) { return N; }
+
+/** \internal
+  * Convenient struct to get the result type of a nullary, unary, binary, or
+  * ternary functor.
+  * 
+  * Pre C++11:
+  * Supports both a Func::result_type member and templated
+  * Func::result<Func(ArgTypes...)>::type member.
+  * 
+  * If none of these members is provided, then the type of the first
+  * argument is returned.
+  * 
+  * Post C++11:
+  * This uses std::result_of. However, note the `type` member removes
+  * const and converts references/pointers to their corresponding value type.
+  */
+#if EIGEN_HAS_STD_INVOKE_RESULT
+template<typename T> struct result_of;
+
+template<typename F, typename... ArgTypes>
+struct result_of<F(ArgTypes...)> {
+  typedef typename std::invoke_result<F, ArgTypes...>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#elif EIGEN_HAS_STD_RESULT_OF
+template<typename T> struct result_of {
+  typedef typename std::result_of<T>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#else
+template<typename T> struct result_of { };
+
+struct has_none {int a[1];};
+struct has_std_result_type {int a[2];};
+struct has_tr1_result {int a[3];};
+
+template<typename Func, int SizeOf>
+struct nullary_result_of_select {};
+
+template<typename Func>
+struct nullary_result_of_select<Func, sizeof(has_std_result_type)> {typedef typename Func::result_type type;};
+
+template<typename Func>
+struct nullary_result_of_select<Func, sizeof(has_tr1_result)> {typedef typename Func::template result<Func()>::type type;};
+
+template<typename Func>
+struct result_of<Func()> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T()>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename nullary_result_of_select<Func, FunctorType>::type type;
+};
+
+template<typename Func, typename ArgType, int SizeOf=sizeof(has_none)>
+struct unary_result_of_select {typedef typename internal::remove_all<ArgType>::type type;};
+
+template<typename Func, typename ArgType>
+struct unary_result_of_select<Func, ArgType, sizeof(has_std_result_type)> {typedef typename Func::result_type type;};
+
+template<typename Func, typename ArgType>
+struct unary_result_of_select<Func, ArgType, sizeof(has_tr1_result)> {typedef typename Func::template result<Func(ArgType)>::type type;};
+
+template<typename Func, typename ArgType>
+struct result_of<Func(ArgType)> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T(ArgType)>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename unary_result_of_select<Func, ArgType, FunctorType>::type type;
+};
+
+template<typename Func, typename ArgType0, typename ArgType1, int SizeOf=sizeof(has_none)>
+struct binary_result_of_select {typedef typename internal::remove_all<ArgType0>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1>
+struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_std_result_type)>
+{typedef typename Func::result_type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1>
+struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_tr1_result)>
+{typedef typename Func::template result<Func(ArgType0,ArgType1)>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1>
+struct result_of<Func(ArgType0,ArgType1)> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1)>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename binary_result_of_select<Func, ArgType0, ArgType1, FunctorType>::type type;
+};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2, int SizeOf=sizeof(has_none)>
+struct ternary_result_of_select {typedef typename internal::remove_all<ArgType0>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
+struct ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, sizeof(has_std_result_type)>
+{typedef typename Func::result_type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
+struct ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, sizeof(has_tr1_result)>
+{typedef typename Func::template result<Func(ArgType0,ArgType1,ArgType2)>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
+struct result_of<Func(ArgType0,ArgType1,ArgType2)> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1,ArgType2)>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, FunctorType>::type type;
+};
+
+#endif
+
+#if EIGEN_HAS_STD_INVOKE_RESULT
+template<typename F, typename... ArgTypes>
+struct invoke_result {
+  typedef typename std::invoke_result<F, ArgTypes...>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#elif EIGEN_HAS_CXX11
+template<typename F, typename... ArgTypes>
+struct invoke_result {
+  typedef typename result_of<F(ArgTypes...)>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#else
+template<typename F, typename ArgType0 = void, typename ArgType1 = void, typename ArgType2 = void>
+struct invoke_result {
+  typedef typename result_of<F(ArgType0, ArgType1, ArgType2)>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+
+template<typename F>
+struct invoke_result<F, void, void, void> {
+  typedef typename result_of<F()>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+
+template<typename F, typename ArgType0>
+struct invoke_result<F, ArgType0, void, void> {
+  typedef typename result_of<F(ArgType0)>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+
+template<typename F, typename ArgType0, typename ArgType1>
+struct invoke_result<F, ArgType0, ArgType1, void> {
+  typedef typename result_of<F(ArgType0, ArgType1)>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#endif
+
+struct meta_yes { char a[1]; };
+struct meta_no  { char a[2]; };
+
+// Check whether T::ReturnType does exist
+template <typename T>
+struct has_ReturnType
+{
+  template <typename C> static meta_yes testFunctor(C const *, typename C::ReturnType const * = 0);
+  template <typename C> static meta_no  testFunctor(...);
+
+  enum { value = sizeof(testFunctor<T>(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+template<typename T> const T* return_ptr();
+
+template <typename T, typename IndexType=Index>
+struct has_nullary_operator
+{
+  template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()())>0)>::type * = 0);
+  static meta_no testFunctor(...);
+
+  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+template <typename T, typename IndexType=Index>
+struct has_unary_operator
+{
+  template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()(IndexType(0)))>0)>::type * = 0);
+  static meta_no testFunctor(...);
+
+  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+template <typename T, typename IndexType=Index>
+struct has_binary_operator
+{
+  template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()(IndexType(0),IndexType(0)))>0)>::type * = 0);
+  static meta_no testFunctor(...);
+
+  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+/** \internal In short, it computes int(sqrt(\a Y)) with \a Y an integer.
+  * Usage example: \code meta_sqrt<1023>::ret \endcode
+  */
+template<int Y,
+         int InfX = 0,
+         int SupX = ((Y==1) ? 1 : Y/2),
+         bool Done = ((SupX-InfX)<=1 ? true : ((SupX*SupX <= Y) && ((SupX+1)*(SupX+1) > Y))) >
+                                // use ?: instead of || just to shut up a stupid gcc 4.3 warning
+class meta_sqrt
+{
+    enum {
+      MidX = (InfX+SupX)/2,
+      TakeInf = MidX*MidX > Y ? 1 : 0,
+      NewInf = int(TakeInf) ? InfX : int(MidX),
+      NewSup = int(TakeInf) ? int(MidX) : SupX
+    };
+  public:
+    enum { ret = meta_sqrt<Y,NewInf,NewSup>::ret };
+};
+
+template<int Y, int InfX, int SupX>
+class meta_sqrt<Y, InfX, SupX, true> { public:  enum { ret = (SupX*SupX <= Y) ? SupX : InfX }; };
+
+
+/** \internal Computes the least common multiple of two positive integer A and B
+  * at compile-time. 
+  */
+template<int A, int B, int K=1, bool Done = ((A*K)%B)==0, bool Big=(A>=B)>
+struct meta_least_common_multiple
+{
+  enum { ret = meta_least_common_multiple<A,B,K+1>::ret };
+};
+template<int A, int B, int K, bool Done>
+struct meta_least_common_multiple<A,B,K,Done,false>
+{
+  enum { ret = meta_least_common_multiple<B,A,K>::ret };
+};
+template<int A, int B, int K>
+struct meta_least_common_multiple<A,B,K,true,true>
+{
+  enum { ret = A*K };
+};
+
+
+/** \internal determines whether the product of two numeric types is allowed and what the return type is */
+template<typename T, typename U> struct scalar_product_traits
+{
+  enum { Defined = 0 };
+};
+
+// FIXME quick workaround around current limitation of result_of
+// template<typename Scalar, typename ArgType0, typename ArgType1>
+// struct result_of<scalar_product_op<Scalar>(ArgType0,ArgType1)> {
+// typedef typename scalar_product_traits<typename remove_all<ArgType0>::type, typename remove_all<ArgType1>::type>::ReturnType type;
+// };
+
+/** \internal Obtains a POD type suitable to use as storage for an object of a size
+  * of at most Len bytes, aligned as specified by \c Align.
+  */
+template<unsigned Len, unsigned Align>
+struct aligned_storage {
+  struct type {
+    EIGEN_ALIGN_TO_BOUNDARY(Align) unsigned char data[Len];
+  };
+};
+
+} // end namespace internal
+
+namespace numext {
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+template<typename T> EIGEN_DEVICE_FUNC   void swap(T &a, T &b) { T tmp = b; b = a; a = tmp; }
+#else
+template<typename T> EIGEN_STRONG_INLINE void swap(T &a, T &b) { std::swap(a,b); }
+#endif
+
+#if defined(EIGEN_GPU_COMPILE_PHASE) && !EIGEN_HAS_CXX11
+using internal::device::numeric_limits;
+#else
+using std::numeric_limits;
+#endif
+
+// Integer division with rounding up.
+// T is assumed to be an integer type with a>=0, and b>0
+template<typename T>
+EIGEN_DEVICE_FUNC
+T div_ceil(const T &a, const T &b)
+{
+  return (a+b-1) / b;
+}
+
+// The aim of the following functions is to bypass -Wfloat-equal warnings
+// when we really want a strict equality comparison on floating points.
+template<typename X, typename Y> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool equal_strict(const X& x,const Y& y) { return x == y; }
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE) || (!defined(EIGEN_CUDA_ARCH) && defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC))
+template<> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool equal_strict(const float& x,const float& y) { return std::equal_to<float>()(x,y); }
+
+template<> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool equal_strict(const double& x,const double& y) { return std::equal_to<double>()(x,y); }
+#endif
+
+template<typename X, typename Y> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool not_equal_strict(const X& x,const Y& y) { return x != y; }
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE) || (!defined(EIGEN_CUDA_ARCH) && defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC))
+template<> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool not_equal_strict(const float& x,const float& y) { return std::not_equal_to<float>()(x,y); }
+
+template<> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool not_equal_strict(const double& x,const double& y) { return std::not_equal_to<double>()(x,y); }
+#endif
+
+} // end namespace numext
+
+} // end namespace Eigen
+
+#endif // EIGEN_META_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/NonMPL2.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/NonMPL2.h
new file mode 100644
index 00000000..1af67cf1
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/NonMPL2.h
@@ -0,0 +1,3 @@
+#ifdef EIGEN_MPL2_ONLY
+#error Including non-MPL2 code in EIGEN_MPL2_ONLY mode
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/ReenableStupidWarnings.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/ReenableStupidWarnings.h
new file mode 100644
index 00000000..1ce6fd1b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/ReenableStupidWarnings.h
@@ -0,0 +1,31 @@
+#ifdef EIGEN_WARNINGS_DISABLED_2
+// "DisableStupidWarnings.h" was included twice recursively: Do not reenable warnings yet!
+#  undef EIGEN_WARNINGS_DISABLED_2
+
+#elif defined(EIGEN_WARNINGS_DISABLED)
+#undef EIGEN_WARNINGS_DISABLED
+
+#ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+  #ifdef _MSC_VER
+    #pragma warning( pop )
+  #elif defined __INTEL_COMPILER
+    #pragma warning pop
+  #elif defined __clang__
+    #pragma clang diagnostic pop
+  #elif defined __GNUC__  &&  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+    #pragma GCC diagnostic pop
+  #endif
+
+  #if defined __NVCC__
+//    Don't reenable the diagnostic messages, as it turns out these messages need
+//    to be disabled at the point of the template instantiation (i.e the user code)
+//    otherwise they'll be triggered by nvcc.
+//    #pragma diag_default code_is_unreachable
+//    #pragma diag_default initialization_not_reachable
+//    #pragma diag_default 2651
+//    #pragma diag_default 2653
+  #endif
+
+#endif
+
+#endif // EIGEN_WARNINGS_DISABLED
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/ReshapedHelper.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/ReshapedHelper.h
new file mode 100644
index 00000000..41243213
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/ReshapedHelper.h
@@ -0,0 +1,51 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_RESHAPED_HELPER_H
+#define EIGEN_RESHAPED_HELPER_H
+
+namespace Eigen {
+
+enum AutoSize_t   { AutoSize };
+const int AutoOrder = 2;
+
+namespace internal {
+
+template<typename SizeType,typename OtherSize, int TotalSize>
+struct get_compiletime_reshape_size {
+  enum { value = get_fixed_value<SizeType>::value };
+};
+
+template<typename SizeType>
+Index get_runtime_reshape_size(SizeType size, Index /*other*/, Index /*total*/) {
+  return internal::get_runtime_value(size);
+}
+
+template<typename OtherSize, int TotalSize>
+struct get_compiletime_reshape_size<AutoSize_t,OtherSize,TotalSize> {
+  enum {
+    other_size = get_fixed_value<OtherSize>::value,
+    value = (TotalSize==Dynamic || other_size==Dynamic) ? Dynamic : TotalSize / other_size };
+};
+
+inline Index get_runtime_reshape_size(AutoSize_t /*size*/, Index other, Index total) {
+  return total/other;
+}
+
+template<int Flags, int Order>
+struct get_compiletime_reshape_order {
+  enum { value = Order == AutoOrder ? Flags & RowMajorBit : Order };
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_RESHAPED_HELPER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/StaticAssert.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/StaticAssert.h
new file mode 100644
index 00000000..c45de590
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/StaticAssert.h
@@ -0,0 +1,221 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STATIC_ASSERT_H
+#define EIGEN_STATIC_ASSERT_H
+
+/* Some notes on Eigen's static assertion mechanism:
+ *
+ *  - in EIGEN_STATIC_ASSERT(CONDITION,MSG) the parameter CONDITION must be a compile time boolean
+ *    expression, and MSG an enum listed in struct internal::static_assertion<true>
+ *
+ *  - define EIGEN_NO_STATIC_ASSERT to disable them (and save compilation time)
+ *    in that case, the static assertion is converted to the following runtime assert:
+ *      eigen_assert(CONDITION && "MSG")
+ *
+ *  - currently EIGEN_STATIC_ASSERT can only be used in function scope
+ *
+ */
+
+#ifndef EIGEN_STATIC_ASSERT
+#ifndef EIGEN_NO_STATIC_ASSERT
+
+  #if EIGEN_MAX_CPP_VER>=11 && (__has_feature(cxx_static_assert) || (EIGEN_COMP_CXXVER >= 11) || (EIGEN_COMP_MSVC >= 1600))
+
+    // if native static_assert is enabled, let's use it
+    #define EIGEN_STATIC_ASSERT(X,MSG) static_assert(X,#MSG);
+
+  #else // not CXX0X
+
+    namespace Eigen {
+
+    namespace internal {
+
+    template<bool condition>
+    struct static_assertion {};
+
+    template<>
+    struct static_assertion<true>
+    {
+      enum {
+        YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX=1,
+        YOU_MIXED_VECTORS_OF_DIFFERENT_SIZES=1,
+        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES=1,
+        THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE=1,
+        THIS_METHOD_IS_ONLY_FOR_MATRICES_OF_A_SPECIFIC_SIZE=1,
+        THIS_METHOD_IS_ONLY_FOR_OBJECTS_OF_A_SPECIFIC_SIZE=1,
+        OUT_OF_RANGE_ACCESS=1,
+        YOU_MADE_A_PROGRAMMING_MISTAKE=1,
+        EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT=1,
+        EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE=1,
+        YOU_CALLED_A_FIXED_SIZE_METHOD_ON_A_DYNAMIC_SIZE_MATRIX_OR_VECTOR=1,
+        YOU_CALLED_A_DYNAMIC_SIZE_METHOD_ON_A_FIXED_SIZE_MATRIX_OR_VECTOR=1,
+        UNALIGNED_LOAD_AND_STORE_OPERATIONS_UNIMPLEMENTED_ON_ALTIVEC=1,
+        THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES=1,
+        FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED=1,
+        NUMERIC_TYPE_MUST_BE_REAL=1,
+        COEFFICIENT_WRITE_ACCESS_TO_SELFADJOINT_NOT_SUPPORTED=1,
+        WRITING_TO_TRIANGULAR_PART_WITH_UNIT_DIAGONAL_IS_NOT_SUPPORTED=1,
+        THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE=1,
+        INVALID_MATRIX_PRODUCT=1,
+        INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS=1,
+        INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION=1,
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY=1,
+        THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES=1,
+        THIS_METHOD_IS_ONLY_FOR_ROW_MAJOR_MATRICES=1,
+        INVALID_MATRIX_TEMPLATE_PARAMETERS=1,
+        INVALID_MATRIXBASE_TEMPLATE_PARAMETERS=1,
+        BOTH_MATRICES_MUST_HAVE_THE_SAME_STORAGE_ORDER=1,
+        THIS_METHOD_IS_ONLY_FOR_DIAGONAL_MATRIX=1,
+        THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE=1,
+        THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES=1,
+        YOU_ALREADY_SPECIFIED_THIS_STRIDE=1,
+        INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION=1,
+        THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD=1,
+        PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1=1,
+        THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS=1,
+        YOU_CANNOT_MIX_ARRAYS_AND_MATRICES=1,
+        YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION=1,
+        THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY=1,
+        YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT=1,
+        THIS_METHOD_IS_ONLY_FOR_1x1_EXPRESSIONS=1,
+        THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS=1,
+        THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL=1,
+        THIS_METHOD_IS_ONLY_FOR_ARRAYS_NOT_MATRICES=1,
+        YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED=1,
+        YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED=1,
+        THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE=1,
+        THE_STORAGE_ORDER_OF_BOTH_SIDES_MUST_MATCH=1,
+        OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG=1,
+        IMPLICIT_CONVERSION_TO_SCALAR_IS_FOR_INNER_PRODUCT_ONLY=1,
+        STORAGE_LAYOUT_DOES_NOT_MATCH=1,
+        EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT__INVALID_COST_VALUE=1,
+        THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS=1,
+        MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY=1,
+        THIS_TYPE_IS_NOT_SUPPORTED=1,
+        STORAGE_KIND_MUST_MATCH=1,
+        STORAGE_INDEX_MUST_MATCH=1,
+        CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY=1,
+        SELFADJOINTVIEW_ACCEPTS_UPPER_AND_LOWER_MODE_ONLY=1,
+        INVALID_TEMPLATE_PARAMETER=1,
+        GPU_TENSOR_CONTRACTION_DOES_NOT_SUPPORT_OUTPUT_KERNELS=1,
+        THE_ARRAY_SIZE_SHOULD_EQUAL_WITH_PACKET_SIZE=1
+      };
+    };
+
+    } // end namespace internal
+
+    } // end namespace Eigen
+
+    // Specialized implementation for MSVC to avoid "conditional
+    // expression is constant" warnings.  This implementation doesn't
+    // appear to work under GCC, hence the multiple implementations.
+    #if EIGEN_COMP_MSVC
+
+      #define EIGEN_STATIC_ASSERT(CONDITION,MSG) \
+        {Eigen::internal::static_assertion<bool(CONDITION)>::MSG;}
+
+    #else
+      // In some cases clang interprets bool(CONDITION) as function declaration
+      #define EIGEN_STATIC_ASSERT(CONDITION,MSG) \
+        if (Eigen::internal::static_assertion<static_cast<bool>(CONDITION)>::MSG) {}
+
+    #endif
+
+  #endif // not CXX0X
+
+#else // EIGEN_NO_STATIC_ASSERT
+
+  #define EIGEN_STATIC_ASSERT(CONDITION,MSG) eigen_assert((CONDITION) && #MSG);
+
+#endif // EIGEN_NO_STATIC_ASSERT
+#endif // EIGEN_STATIC_ASSERT
+
+// static assertion failing if the type \a TYPE is not a vector type
+#define EIGEN_STATIC_ASSERT_VECTOR_ONLY(TYPE) \
+  EIGEN_STATIC_ASSERT(TYPE::IsVectorAtCompileTime, \
+                      YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX)
+
+// static assertion failing if the type \a TYPE is not fixed-size
+#define EIGEN_STATIC_ASSERT_FIXED_SIZE(TYPE) \
+  EIGEN_STATIC_ASSERT(TYPE::SizeAtCompileTime!=Eigen::Dynamic, \
+                      YOU_CALLED_A_FIXED_SIZE_METHOD_ON_A_DYNAMIC_SIZE_MATRIX_OR_VECTOR)
+
+// static assertion failing if the type \a TYPE is not dynamic-size
+#define EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(TYPE) \
+  EIGEN_STATIC_ASSERT(TYPE::SizeAtCompileTime==Eigen::Dynamic, \
+                      YOU_CALLED_A_DYNAMIC_SIZE_METHOD_ON_A_FIXED_SIZE_MATRIX_OR_VECTOR)
+
+// static assertion failing if the type \a TYPE is not a vector type of the given size
+#define EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(TYPE, SIZE) \
+  EIGEN_STATIC_ASSERT(TYPE::IsVectorAtCompileTime && TYPE::SizeAtCompileTime==SIZE, \
+                      THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE)
+
+// static assertion failing if the type \a TYPE is not a vector type of the given size
+#define EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(TYPE, ROWS, COLS) \
+  EIGEN_STATIC_ASSERT(TYPE::RowsAtCompileTime==ROWS && TYPE::ColsAtCompileTime==COLS, \
+                      THIS_METHOD_IS_ONLY_FOR_MATRICES_OF_A_SPECIFIC_SIZE)
+
+// static assertion failing if the two vector expression types are not compatible (same fixed-size or dynamic size)
+#define EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(TYPE0,TYPE1) \
+  EIGEN_STATIC_ASSERT( \
+      (int(TYPE0::SizeAtCompileTime)==Eigen::Dynamic \
+    || int(TYPE1::SizeAtCompileTime)==Eigen::Dynamic \
+    || int(TYPE0::SizeAtCompileTime)==int(TYPE1::SizeAtCompileTime)),\
+    YOU_MIXED_VECTORS_OF_DIFFERENT_SIZES)
+
+#define EIGEN_PREDICATE_SAME_MATRIX_SIZE(TYPE0,TYPE1) \
+     ( \
+        (int(Eigen::internal::size_of_xpr_at_compile_time<TYPE0>::ret)==0 && int(Eigen::internal::size_of_xpr_at_compile_time<TYPE1>::ret)==0) \
+    || (\
+          (int(TYPE0::RowsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE1::RowsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE0::RowsAtCompileTime)==int(TYPE1::RowsAtCompileTime)) \
+      &&  (int(TYPE0::ColsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE1::ColsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE0::ColsAtCompileTime)==int(TYPE1::ColsAtCompileTime))\
+       ) \
+     )
+
+#define EIGEN_STATIC_ASSERT_NON_INTEGER(TYPE) \
+    EIGEN_STATIC_ASSERT(!Eigen::NumTraits<TYPE>::IsInteger, THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES)
+
+
+// static assertion failing if it is guaranteed at compile-time that the two matrix expression types have different sizes
+#define EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(TYPE0,TYPE1) \
+  EIGEN_STATIC_ASSERT( \
+     EIGEN_PREDICATE_SAME_MATRIX_SIZE(TYPE0,TYPE1),\
+    YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+
+#define EIGEN_STATIC_ASSERT_SIZE_1x1(TYPE) \
+      EIGEN_STATIC_ASSERT((TYPE::RowsAtCompileTime == 1 || TYPE::RowsAtCompileTime == Eigen::Dynamic) && \
+                          (TYPE::ColsAtCompileTime == 1 || TYPE::ColsAtCompileTime == Eigen::Dynamic), \
+                          THIS_METHOD_IS_ONLY_FOR_1x1_EXPRESSIONS)
+
+#define EIGEN_STATIC_ASSERT_LVALUE(Derived) \
+      EIGEN_STATIC_ASSERT(Eigen::internal::is_lvalue<Derived>::value, \
+                          THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY)
+
+#define EIGEN_STATIC_ASSERT_ARRAYXPR(Derived) \
+      EIGEN_STATIC_ASSERT((Eigen::internal::is_same<typename Eigen::internal::traits<Derived>::XprKind, ArrayXpr>::value), \
+                          THIS_METHOD_IS_ONLY_FOR_ARRAYS_NOT_MATRICES)
+
+#define EIGEN_STATIC_ASSERT_SAME_XPR_KIND(Derived1, Derived2) \
+      EIGEN_STATIC_ASSERT((Eigen::internal::is_same<typename Eigen::internal::traits<Derived1>::XprKind, \
+                                             typename Eigen::internal::traits<Derived2>::XprKind \
+                                            >::value), \
+                          YOU_CANNOT_MIX_ARRAYS_AND_MATRICES)
+
+// Check that a cost value is positive, and that is stay within a reasonable range
+// TODO this check could be enabled for internal debugging only
+#define EIGEN_INTERNAL_CHECK_COST_VALUE(C) \
+      EIGEN_STATIC_ASSERT((C)>=0 && (C)<=HugeCost*HugeCost, EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT__INVALID_COST_VALUE);
+
+#endif // EIGEN_STATIC_ASSERT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/SymbolicIndex.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/SymbolicIndex.h
new file mode 100644
index 00000000..354dd9ad
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/SymbolicIndex.h
@@ -0,0 +1,293 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SYMBOLIC_INDEX_H
+#define EIGEN_SYMBOLIC_INDEX_H
+
+namespace Eigen {
+
+/** \namespace Eigen::symbolic
+  * \ingroup Core_Module
+  *
+  * This namespace defines a set of classes and functions to build and evaluate symbolic expressions of scalar type Index.
+  * Here is a simple example:
+  *
+  * \code
+  * // First step, defines symbols:
+  * struct x_tag {};  static const symbolic::SymbolExpr<x_tag> x;
+  * struct y_tag {};  static const symbolic::SymbolExpr<y_tag> y;
+  * struct z_tag {};  static const symbolic::SymbolExpr<z_tag> z;
+  *
+  * // Defines an expression:
+  * auto expr = (x+3)/y+z;
+  *
+  * // And evaluate it: (c++14)
+  * std::cout << expr.eval(x=6,y=3,z=-13) << "\n";
+  *
+  * // In c++98/11, only one symbol per expression is supported for now:
+  * auto expr98 = (3-x)/2;
+  * std::cout << expr98.eval(x=6) << "\n";
+  * \endcode
+  *
+  * It is currently only used internally to define and manipulate the Eigen::last and Eigen::lastp1 symbols in Eigen::seq and Eigen::seqN.
+  *
+  */
+namespace symbolic {
+
+template<typename Tag> class Symbol;
+template<typename Arg0> class NegateExpr;
+template<typename Arg1,typename Arg2> class AddExpr;
+template<typename Arg1,typename Arg2> class ProductExpr;
+template<typename Arg1,typename Arg2> class QuotientExpr;
+
+// A simple wrapper around an integral value to provide the eval method.
+// We could also use a free-function symbolic_eval...
+template<typename IndexType=Index>
+class ValueExpr {
+public:
+  ValueExpr(IndexType val) : m_value(val) {}
+  template<typename T>
+  IndexType eval_impl(const T&) const { return m_value; }
+protected:
+  IndexType m_value;
+};
+
+// Specialization for compile-time value,
+// It is similar to ValueExpr(N) but this version helps the compiler to generate better code.
+template<int N>
+class ValueExpr<internal::FixedInt<N> > {
+public:
+  ValueExpr() {}
+  template<typename T>
+  EIGEN_CONSTEXPR Index eval_impl(const T&) const { return N; }
+};
+
+
+/** \class BaseExpr
+  * \ingroup Core_Module
+  * Common base class of any symbolic expressions
+  */
+template<typename Derived>
+class BaseExpr
+{
+public:
+  const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+  /** Evaluate the expression given the \a values of the symbols.
+    *
+    * \param values defines the values of the symbols, it can either be a SymbolValue or a std::tuple of SymbolValue
+    *               as constructed by SymbolExpr::operator= operator.
+    *
+    */
+  template<typename T>
+  Index eval(const T& values) const { return derived().eval_impl(values); }
+
+#if EIGEN_HAS_CXX14
+  template<typename... Types>
+  Index eval(Types&&... values) const { return derived().eval_impl(std::make_tuple(values...)); }
+#endif
+
+  NegateExpr<Derived> operator-() const { return NegateExpr<Derived>(derived()); }
+
+  AddExpr<Derived,ValueExpr<> > operator+(Index b) const
+  { return AddExpr<Derived,ValueExpr<> >(derived(),  b); }
+  AddExpr<Derived,ValueExpr<> > operator-(Index a) const
+  { return AddExpr<Derived,ValueExpr<> >(derived(), -a); }
+  ProductExpr<Derived,ValueExpr<> > operator*(Index a) const
+  { return ProductExpr<Derived,ValueExpr<> >(derived(),a); }
+  QuotientExpr<Derived,ValueExpr<> > operator/(Index a) const
+  { return QuotientExpr<Derived,ValueExpr<> >(derived(),a); }
+
+  friend AddExpr<Derived,ValueExpr<> > operator+(Index a, const BaseExpr& b)
+  { return AddExpr<Derived,ValueExpr<> >(b.derived(), a); }
+  friend AddExpr<NegateExpr<Derived>,ValueExpr<> > operator-(Index a, const BaseExpr& b)
+  { return AddExpr<NegateExpr<Derived>,ValueExpr<> >(-b.derived(), a); }
+  friend ProductExpr<ValueExpr<>,Derived> operator*(Index a, const BaseExpr& b)
+  { return ProductExpr<ValueExpr<>,Derived>(a,b.derived()); }
+  friend QuotientExpr<ValueExpr<>,Derived> operator/(Index a, const BaseExpr& b)
+  { return QuotientExpr<ValueExpr<>,Derived>(a,b.derived()); }
+
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N>) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > > operator-(internal::FixedInt<N>) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > >(derived(), ValueExpr<internal::FixedInt<-N> >()); }
+  template<int N>
+  ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator*(internal::FixedInt<N>) const
+  { return ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator/(internal::FixedInt<N>) const
+  { return QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+
+  template<int N>
+  friend AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N>, const BaseExpr& b)
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > > operator-(internal::FixedInt<N>, const BaseExpr& b)
+  { return AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > >(-b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator*(internal::FixedInt<N>, const BaseExpr& b)
+  { return ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+  template<int N>
+  friend QuotientExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator/(internal::FixedInt<N>, const BaseExpr& b)
+  { return QuotientExpr<ValueExpr<internal::FixedInt<N> > ,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+
+#if (!EIGEN_HAS_CXX14)
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N> (*)()) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > > operator-(internal::FixedInt<N> (*)()) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > >(derived(), ValueExpr<internal::FixedInt<-N> >()); }
+  template<int N>
+  ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator*(internal::FixedInt<N> (*)()) const
+  { return ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator/(internal::FixedInt<N> (*)()) const
+  { return QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+
+  template<int N>
+  friend AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > > operator-(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > >(-b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator*(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+  template<int N>
+  friend QuotientExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator/(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return QuotientExpr<ValueExpr<internal::FixedInt<N> > ,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+#endif
+
+
+  template<typename OtherDerived>
+  AddExpr<Derived,OtherDerived> operator+(const BaseExpr<OtherDerived> &b) const
+  { return AddExpr<Derived,OtherDerived>(derived(),  b.derived()); }
+
+  template<typename OtherDerived>
+  AddExpr<Derived,NegateExpr<OtherDerived> > operator-(const BaseExpr<OtherDerived> &b) const
+  { return AddExpr<Derived,NegateExpr<OtherDerived> >(derived(), -b.derived()); }
+
+  template<typename OtherDerived>
+  ProductExpr<Derived,OtherDerived> operator*(const BaseExpr<OtherDerived> &b) const
+  { return ProductExpr<Derived,OtherDerived>(derived(), b.derived()); }
+
+  template<typename OtherDerived>
+  QuotientExpr<Derived,OtherDerived> operator/(const BaseExpr<OtherDerived> &b) const
+  { return QuotientExpr<Derived,OtherDerived>(derived(), b.derived()); }
+};
+
+template<typename T>
+struct is_symbolic {
+  // BaseExpr has no conversion ctor, so we only have to check whether T can be statically cast to its base class BaseExpr<T>.
+  enum { value = internal::is_convertible<T,BaseExpr<T> >::value };
+};
+
+/** Represents the actual value of a symbol identified by its tag
+  *
+  * It is the return type of SymbolValue::operator=, and most of the time this is only way it is used.
+  */
+template<typename Tag>
+class SymbolValue
+{
+public:
+  /** Default constructor from the value \a val */
+  SymbolValue(Index val) : m_value(val) {}
+
+  /** \returns the stored value of the symbol */
+  Index value() const { return m_value; }
+protected:
+  Index m_value;
+};
+
+/** Expression of a symbol uniquely identified by the template parameter type \c tag */
+template<typename tag>
+class SymbolExpr : public BaseExpr<SymbolExpr<tag> >
+{
+public:
+  /** Alias to the template parameter \c tag */
+  typedef tag Tag;
+
+  SymbolExpr() {}
+
+  /** Associate the value \a val to the given symbol \c *this, uniquely identified by its \c Tag.
+    *
+    * The returned object should be passed to ExprBase::eval() to evaluate a given expression with this specified runtime-time value.
+    */
+  SymbolValue<Tag> operator=(Index val) const {
+    return SymbolValue<Tag>(val);
+  }
+
+  Index eval_impl(const SymbolValue<Tag> &values) const { return values.value(); }
+
+#if EIGEN_HAS_CXX14
+  // C++14 versions suitable for multiple symbols
+  template<typename... Types>
+  Index eval_impl(const std::tuple<Types...>& values) const { return std::get<SymbolValue<Tag> >(values).value(); }
+#endif
+};
+
+template<typename Arg0>
+class NegateExpr : public BaseExpr<NegateExpr<Arg0> >
+{
+public:
+  NegateExpr(const Arg0& arg0) : m_arg0(arg0) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return -m_arg0.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+};
+
+template<typename Arg0, typename Arg1>
+class AddExpr : public BaseExpr<AddExpr<Arg0,Arg1> >
+{
+public:
+  AddExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) + m_arg1.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+  Arg1 m_arg1;
+};
+
+template<typename Arg0, typename Arg1>
+class ProductExpr : public BaseExpr<ProductExpr<Arg0,Arg1> >
+{
+public:
+  ProductExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) * m_arg1.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+  Arg1 m_arg1;
+};
+
+template<typename Arg0, typename Arg1>
+class QuotientExpr : public BaseExpr<QuotientExpr<Arg0,Arg1> >
+{
+public:
+  QuotientExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) / m_arg1.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+  Arg1 m_arg1;
+};
+
+} // end namespace symbolic
+
+} // end namespace Eigen
+
+#endif // EIGEN_SYMBOLIC_INDEX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Core/util/XprHelper.h b/C++/yolo_bytetrack/include/Eigen/src/Core/util/XprHelper.h
new file mode 100644
index 00000000..71c32b8a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Core/util/XprHelper.h
@@ -0,0 +1,856 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_XPRHELPER_H
+#define EIGEN_XPRHELPER_H
+
+// just a workaround because GCC seems to not really like empty structs
+// FIXME: gcc 4.3 generates bad code when strict-aliasing is enabled
+// so currently we simply disable this optimization for gcc 4.3
+#if EIGEN_COMP_GNUC && !EIGEN_GNUC_AT(4,3)
+  #define EIGEN_EMPTY_STRUCT_CTOR(X) \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE X() {} \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE X(const X& ) {}
+#else
+  #define EIGEN_EMPTY_STRUCT_CTOR(X)
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename IndexDest, typename IndexSrc>
+EIGEN_DEVICE_FUNC
+inline IndexDest convert_index(const IndexSrc& idx) {
+  // for sizeof(IndexDest)>=sizeof(IndexSrc) compilers should be able to optimize this away:
+  eigen_internal_assert(idx <= NumTraits<IndexDest>::highest() && "Index value to big for target type");
+  return IndexDest(idx);
+}
+
+// true if T can be considered as an integral index (i.e., and integral type or enum)
+template<typename T> struct is_valid_index_type
+{
+  enum { value =
+#if EIGEN_HAS_TYPE_TRAITS
+    internal::is_integral<T>::value || std::is_enum<T>::value
+#elif EIGEN_COMP_MSVC
+    internal::is_integral<T>::value || __is_enum(T)
+#else
+    // without C++11, we use is_convertible to Index instead of is_integral in order to treat enums as Index.
+    internal::is_convertible<T,Index>::value && !internal::is_same<T,float>::value && !is_same<T,double>::value
+#endif
+  };
+};
+
+// true if both types are not valid index types
+template<typename RowIndices, typename ColIndices>
+struct valid_indexed_view_overload {
+  enum { value = !(internal::is_valid_index_type<RowIndices>::value && internal::is_valid_index_type<ColIndices>::value) };
+};
+
+// promote_scalar_arg is an helper used in operation between an expression and a scalar, like:
+//    expression * scalar
+// Its role is to determine how the type T of the scalar operand should be promoted given the scalar type ExprScalar of the given expression.
+// The IsSupported template parameter must be provided by the caller as: internal::has_ReturnType<ScalarBinaryOpTraits<ExprScalar,T,op> >::value using the proper order for ExprScalar and T.
+// Then the logic is as follows:
+//  - if the operation is natively supported as defined by IsSupported, then the scalar type is not promoted, and T is returned.
+//  - otherwise, NumTraits<ExprScalar>::Literal is returned if T is implicitly convertible to NumTraits<ExprScalar>::Literal AND that this does not imply a float to integer conversion.
+//  - otherwise, ExprScalar is returned if T is implicitly convertible to ExprScalar AND that this does not imply a float to integer conversion.
+//  - In all other cases, the promoted type is not defined, and the respective operation is thus invalid and not available (SFINAE).
+template<typename ExprScalar,typename T, bool IsSupported>
+struct promote_scalar_arg;
+
+template<typename S,typename T>
+struct promote_scalar_arg<S,T,true>
+{
+  typedef T type;
+};
+
+// Recursively check safe conversion to PromotedType, and then ExprScalar if they are different.
+template<typename ExprScalar,typename T,typename PromotedType,
+  bool ConvertibleToLiteral = internal::is_convertible<T,PromotedType>::value,
+  bool IsSafe = NumTraits<T>::IsInteger || !NumTraits<PromotedType>::IsInteger>
+struct promote_scalar_arg_unsupported;
+
+// Start recursion with NumTraits<ExprScalar>::Literal
+template<typename S,typename T>
+struct promote_scalar_arg<S,T,false> : promote_scalar_arg_unsupported<S,T,typename NumTraits<S>::Literal> {};
+
+// We found a match!
+template<typename S,typename T, typename PromotedType>
+struct promote_scalar_arg_unsupported<S,T,PromotedType,true,true>
+{
+  typedef PromotedType type;
+};
+
+// No match, but no real-to-integer issues, and ExprScalar and current PromotedType are different,
+// so let's try to promote to ExprScalar
+template<typename ExprScalar,typename T, typename PromotedType>
+struct promote_scalar_arg_unsupported<ExprScalar,T,PromotedType,false,true>
+   : promote_scalar_arg_unsupported<ExprScalar,T,ExprScalar>
+{};
+
+// Unsafe real-to-integer, let's stop.
+template<typename S,typename T, typename PromotedType, bool ConvertibleToLiteral>
+struct promote_scalar_arg_unsupported<S,T,PromotedType,ConvertibleToLiteral,false> {};
+
+// T is not even convertible to ExprScalar, let's stop.
+template<typename S,typename T>
+struct promote_scalar_arg_unsupported<S,T,S,false,true> {};
+
+//classes inheriting no_assignment_operator don't generate a default operator=.
+class no_assignment_operator
+{
+  private:
+    no_assignment_operator& operator=(const no_assignment_operator&);
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(no_assignment_operator)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(no_assignment_operator)
+};
+
+/** \internal return the index type with the largest number of bits */
+template<typename I1, typename I2>
+struct promote_index_type
+{
+  typedef typename conditional<(sizeof(I1)<sizeof(I2)), I2, I1>::type type;
+};
+
+/** \internal If the template parameter Value is Dynamic, this class is just a wrapper around a T variable that
+  * can be accessed using value() and setValue().
+  * Otherwise, this class is an empty structure and value() just returns the template parameter Value.
+  */
+template<typename T, int Value> class variable_if_dynamic
+{
+  public:
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(variable_if_dynamic)
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamic(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); eigen_assert(v == T(Value)); }
+    EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    T value() { return T(Value); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    operator T() const { return T(Value); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void setValue(T v) const { EIGEN_ONLY_USED_FOR_DEBUG(v); eigen_assert(v == T(Value)); }
+};
+
+template<typename T> class variable_if_dynamic<T, Dynamic>
+{
+    T m_value;
+  public:
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamic(T value = 0) EIGEN_NO_THROW : m_value(value) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T value() const { return m_value; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE operator T() const { return m_value; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void setValue(T value) { m_value = value; }
+};
+
+/** \internal like variable_if_dynamic but for DynamicIndex
+  */
+template<typename T, int Value> class variable_if_dynamicindex
+{
+  public:
+    EIGEN_EMPTY_STRUCT_CTOR(variable_if_dynamicindex)
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamicindex(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); eigen_assert(v == T(Value)); }
+    EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    T value() { return T(Value); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void setValue(T) {}
+};
+
+template<typename T> class variable_if_dynamicindex<T, DynamicIndex>
+{
+    T m_value;
+    EIGEN_DEVICE_FUNC variable_if_dynamicindex() { eigen_assert(false); }
+  public:
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamicindex(T value) : m_value(value) {}
+    EIGEN_DEVICE_FUNC T EIGEN_STRONG_INLINE value() const { return m_value; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void setValue(T value) { m_value = value; }
+};
+
+template<typename T> struct functor_traits
+{
+  enum
+  {
+    Cost = 10,
+    PacketAccess = false,
+    IsRepeatable = false
+  };
+};
+
+template<typename T> struct packet_traits;
+
+template<typename T> struct unpacket_traits;
+
+template<int Size, typename PacketType,
+         bool Stop = Size==Dynamic || (Size%unpacket_traits<PacketType>::size)==0 || is_same<PacketType,typename unpacket_traits<PacketType>::half>::value>
+struct find_best_packet_helper;
+
+template< int Size, typename PacketType>
+struct find_best_packet_helper<Size,PacketType,true>
+{
+  typedef PacketType type;
+};
+
+template<int Size, typename PacketType>
+struct find_best_packet_helper<Size,PacketType,false>
+{
+  typedef typename find_best_packet_helper<Size,typename unpacket_traits<PacketType>::half>::type type;
+};
+
+template<typename T, int Size>
+struct find_best_packet
+{
+  typedef typename find_best_packet_helper<Size,typename packet_traits<T>::type>::type type;
+};
+
+#if EIGEN_MAX_STATIC_ALIGN_BYTES>0
+template<int ArrayBytes, int AlignmentBytes,
+         bool Match     =  bool((ArrayBytes%AlignmentBytes)==0),
+         bool TryHalf   =  bool(EIGEN_MIN_ALIGN_BYTES<AlignmentBytes) >
+struct compute_default_alignment_helper
+{
+  enum { value = 0 };
+};
+
+template<int ArrayBytes, int AlignmentBytes, bool TryHalf>
+struct compute_default_alignment_helper<ArrayBytes, AlignmentBytes, true, TryHalf> // Match
+{
+  enum { value = AlignmentBytes };
+};
+
+template<int ArrayBytes, int AlignmentBytes>
+struct compute_default_alignment_helper<ArrayBytes, AlignmentBytes, false, true> // Try-half
+{
+  // current packet too large, try with an half-packet
+  enum { value = compute_default_alignment_helper<ArrayBytes, AlignmentBytes/2>::value };
+};
+#else
+// If static alignment is disabled, no need to bother.
+// This also avoids a division by zero in "bool Match =  bool((ArrayBytes%AlignmentBytes)==0)"
+template<int ArrayBytes, int AlignmentBytes>
+struct compute_default_alignment_helper
+{
+  enum { value = 0 };
+};
+#endif
+
+template<typename T, int Size> struct compute_default_alignment {
+  enum { value = compute_default_alignment_helper<Size*sizeof(T),EIGEN_MAX_STATIC_ALIGN_BYTES>::value };
+};
+
+template<typename T> struct compute_default_alignment<T,Dynamic> {
+  enum { value = EIGEN_MAX_ALIGN_BYTES };
+};
+
+template<typename _Scalar, int _Rows, int _Cols,
+         int _Options = AutoAlign |
+                          ( (_Rows==1 && _Cols!=1) ? RowMajor
+                          : (_Cols==1 && _Rows!=1) ? ColMajor
+                          : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
+         int _MaxRows = _Rows,
+         int _MaxCols = _Cols
+> class make_proper_matrix_type
+{
+    enum {
+      IsColVector = _Cols==1 && _Rows!=1,
+      IsRowVector = _Rows==1 && _Cols!=1,
+      Options = IsColVector ? (_Options | ColMajor) & ~RowMajor
+              : IsRowVector ? (_Options | RowMajor) & ~ColMajor
+              : _Options
+    };
+  public:
+    typedef Matrix<_Scalar, _Rows, _Cols, Options, _MaxRows, _MaxCols> type;
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+class compute_matrix_flags
+{
+    enum { row_major_bit = Options&RowMajor ? RowMajorBit : 0 };
+  public:
+    // FIXME currently we still have to handle DirectAccessBit at the expression level to handle DenseCoeffsBase<>
+    // and then propagate this information to the evaluator's flags.
+    // However, I (Gael) think that DirectAccessBit should only matter at the evaluation stage.
+    enum { ret = DirectAccessBit | LvalueBit | NestByRefBit | row_major_bit };
+};
+
+template<int _Rows, int _Cols> struct size_at_compile_time
+{
+  enum { ret = (_Rows==Dynamic || _Cols==Dynamic) ? Dynamic : _Rows * _Cols };
+};
+
+template<typename XprType> struct size_of_xpr_at_compile_time
+{
+  enum { ret = size_at_compile_time<traits<XprType>::RowsAtCompileTime,traits<XprType>::ColsAtCompileTime>::ret };
+};
+
+/* plain_matrix_type : the difference from eval is that plain_matrix_type is always a plain matrix type,
+ * whereas eval is a const reference in the case of a matrix
+ */
+
+template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct plain_matrix_type;
+template<typename T, typename BaseClassType, int Flags> struct plain_matrix_type_dense;
+template<typename T> struct plain_matrix_type<T,Dense>
+{
+  typedef typename plain_matrix_type_dense<T,typename traits<T>::XprKind, traits<T>::Flags>::type type;
+};
+template<typename T> struct plain_matrix_type<T,DiagonalShape>
+{
+  typedef typename T::PlainObject type;
+};
+
+template<typename T, int Flags> struct plain_matrix_type_dense<T,MatrixXpr,Flags>
+{
+  typedef Matrix<typename traits<T>::Scalar,
+                traits<T>::RowsAtCompileTime,
+                traits<T>::ColsAtCompileTime,
+                AutoAlign | (Flags&RowMajorBit ? RowMajor : ColMajor),
+                traits<T>::MaxRowsAtCompileTime,
+                traits<T>::MaxColsAtCompileTime
+          > type;
+};
+
+template<typename T, int Flags> struct plain_matrix_type_dense<T,ArrayXpr,Flags>
+{
+  typedef Array<typename traits<T>::Scalar,
+                traits<T>::RowsAtCompileTime,
+                traits<T>::ColsAtCompileTime,
+                AutoAlign | (Flags&RowMajorBit ? RowMajor : ColMajor),
+                traits<T>::MaxRowsAtCompileTime,
+                traits<T>::MaxColsAtCompileTime
+          > type;
+};
+
+/* eval : the return type of eval(). For matrices, this is just a const reference
+ * in order to avoid a useless copy
+ */
+
+template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct eval;
+
+template<typename T> struct eval<T,Dense>
+{
+  typedef typename plain_matrix_type<T>::type type;
+//   typedef typename T::PlainObject type;
+//   typedef T::Matrix<typename traits<T>::Scalar,
+//                 traits<T>::RowsAtCompileTime,
+//                 traits<T>::ColsAtCompileTime,
+//                 AutoAlign | (traits<T>::Flags&RowMajorBit ? RowMajor : ColMajor),
+//                 traits<T>::MaxRowsAtCompileTime,
+//                 traits<T>::MaxColsAtCompileTime
+//           > type;
+};
+
+template<typename T> struct eval<T,DiagonalShape>
+{
+  typedef typename plain_matrix_type<T>::type type;
+};
+
+// for matrices, no need to evaluate, just use a const reference to avoid a useless copy
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct eval<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Dense>
+{
+  typedef const Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& type;
+};
+
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct eval<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Dense>
+{
+  typedef const Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& type;
+};
+
+
+/* similar to plain_matrix_type, but using the evaluator's Flags */
+template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct plain_object_eval;
+
+template<typename T>
+struct plain_object_eval<T,Dense>
+{
+  typedef typename plain_matrix_type_dense<T,typename traits<T>::XprKind, evaluator<T>::Flags>::type type;
+};
+
+
+/* plain_matrix_type_column_major : same as plain_matrix_type but guaranteed to be column-major
+ */
+template<typename T> struct plain_matrix_type_column_major
+{
+  enum { Rows = traits<T>::RowsAtCompileTime,
+         Cols = traits<T>::ColsAtCompileTime,
+         MaxRows = traits<T>::MaxRowsAtCompileTime,
+         MaxCols = traits<T>::MaxColsAtCompileTime
+  };
+  typedef Matrix<typename traits<T>::Scalar,
+                Rows,
+                Cols,
+                (MaxRows==1&&MaxCols!=1) ? RowMajor : ColMajor,
+                MaxRows,
+                MaxCols
+          > type;
+};
+
+/* plain_matrix_type_row_major : same as plain_matrix_type but guaranteed to be row-major
+ */
+template<typename T> struct plain_matrix_type_row_major
+{
+  enum { Rows = traits<T>::RowsAtCompileTime,
+         Cols = traits<T>::ColsAtCompileTime,
+         MaxRows = traits<T>::MaxRowsAtCompileTime,
+         MaxCols = traits<T>::MaxColsAtCompileTime
+  };
+  typedef Matrix<typename traits<T>::Scalar,
+                Rows,
+                Cols,
+                (MaxCols==1&&MaxRows!=1) ? ColMajor : RowMajor,
+                MaxRows,
+                MaxCols
+          > type;
+};
+
+/** \internal The reference selector for template expressions. The idea is that we don't
+  * need to use references for expressions since they are light weight proxy
+  * objects which should generate no copying overhead. */
+template <typename T>
+struct ref_selector
+{
+  typedef typename conditional<
+    bool(traits<T>::Flags & NestByRefBit),
+    T const&,
+    const T
+  >::type type;
+
+  typedef typename conditional<
+    bool(traits<T>::Flags & NestByRefBit),
+    T &,
+    T
+  >::type non_const_type;
+};
+
+/** \internal Adds the const qualifier on the value-type of T2 if and only if T1 is a const type */
+template<typename T1, typename T2>
+struct transfer_constness
+{
+  typedef typename conditional<
+    bool(internal::is_const<T1>::value),
+    typename internal::add_const_on_value_type<T2>::type,
+    T2
+  >::type type;
+};
+
+
+// However, we still need a mechanism to detect whether an expression which is evaluated multiple time
+// has to be evaluated into a temporary.
+// That's the purpose of this new nested_eval helper:
+/** \internal Determines how a given expression should be nested when evaluated multiple times.
+  * For example, when you do a * (b+c), Eigen will determine how the expression b+c should be
+  * evaluated into the bigger product expression. The choice is between nesting the expression b+c as-is, or
+  * evaluating that expression b+c into a temporary variable d, and nest d so that the resulting expression is
+  * a*d. Evaluating can be beneficial for example if every coefficient access in the resulting expression causes
+  * many coefficient accesses in the nested expressions -- as is the case with matrix product for example.
+  *
+  * \tparam T the type of the expression being nested.
+  * \tparam n the number of coefficient accesses in the nested expression for each coefficient access in the bigger expression.
+  * \tparam PlainObject the type of the temporary if needed.
+  */
+template<typename T, int n, typename PlainObject = typename plain_object_eval<T>::type> struct nested_eval
+{
+  enum {
+    ScalarReadCost = NumTraits<typename traits<T>::Scalar>::ReadCost,
+    CoeffReadCost = evaluator<T>::CoeffReadCost,  // NOTE What if an evaluator evaluate itself into a temporary?
+                                                  //      Then CoeffReadCost will be small (e.g., 1) but we still have to evaluate, especially if n>1.
+                                                  //      This situation is already taken care by the EvalBeforeNestingBit flag, which is turned ON
+                                                  //      for all evaluator creating a temporary. This flag is then propagated by the parent evaluators.
+                                                  //      Another solution could be to count the number of temps?
+    NAsInteger = n == Dynamic ? HugeCost : n,
+    CostEval   = (NAsInteger+1) * ScalarReadCost + CoeffReadCost,
+    CostNoEval = NAsInteger * CoeffReadCost,
+    Evaluate = (int(evaluator<T>::Flags) & EvalBeforeNestingBit) || (int(CostEval) < int(CostNoEval))
+  };
+
+  typedef typename conditional<Evaluate, PlainObject, typename ref_selector<T>::type>::type type;
+};
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+inline T* const_cast_ptr(const T* ptr)
+{
+  return const_cast<T*>(ptr);
+}
+
+template<typename Derived, typename XprKind = typename traits<Derived>::XprKind>
+struct dense_xpr_base
+{
+  /* dense_xpr_base should only ever be used on dense expressions, thus falling either into the MatrixXpr or into the ArrayXpr cases */
+};
+
+template<typename Derived>
+struct dense_xpr_base<Derived, MatrixXpr>
+{
+  typedef MatrixBase<Derived> type;
+};
+
+template<typename Derived>
+struct dense_xpr_base<Derived, ArrayXpr>
+{
+  typedef ArrayBase<Derived> type;
+};
+
+template<typename Derived, typename XprKind = typename traits<Derived>::XprKind, typename StorageKind = typename traits<Derived>::StorageKind>
+struct generic_xpr_base;
+
+template<typename Derived, typename XprKind>
+struct generic_xpr_base<Derived, XprKind, Dense>
+{
+  typedef typename dense_xpr_base<Derived,XprKind>::type type;
+};
+
+template<typename XprType, typename CastType> struct cast_return_type
+{
+  typedef typename XprType::Scalar CurrentScalarType;
+  typedef typename remove_all<CastType>::type _CastType;
+  typedef typename _CastType::Scalar NewScalarType;
+  typedef typename conditional<is_same<CurrentScalarType,NewScalarType>::value,
+                              const XprType&,CastType>::type type;
+};
+
+template <typename A, typename B> struct promote_storage_type;
+
+template <typename A> struct promote_storage_type<A,A>
+{
+  typedef A ret;
+};
+template <typename A> struct promote_storage_type<A, const A>
+{
+  typedef A ret;
+};
+template <typename A> struct promote_storage_type<const A, A>
+{
+  typedef A ret;
+};
+
+/** \internal Specify the "storage kind" of applying a coefficient-wise
+  * binary operations between two expressions of kinds A and B respectively.
+  * The template parameter Functor permits to specialize the resulting storage kind wrt to
+  * the functor.
+  * The default rules are as follows:
+  * \code
+  * A      op A      -> A
+  * A      op dense  -> dense
+  * dense  op B      -> dense
+  * sparse op dense  -> sparse
+  * dense  op sparse -> sparse
+  * \endcode
+  */
+template <typename A, typename B, typename Functor> struct cwise_promote_storage_type;
+
+template <typename A, typename Functor>                   struct cwise_promote_storage_type<A,A,Functor>                                      { typedef A      ret; };
+template <typename Functor>                               struct cwise_promote_storage_type<Dense,Dense,Functor>                              { typedef Dense  ret; };
+template <typename A, typename Functor>                   struct cwise_promote_storage_type<A,Dense,Functor>                                  { typedef Dense  ret; };
+template <typename B, typename Functor>                   struct cwise_promote_storage_type<Dense,B,Functor>                                  { typedef Dense  ret; };
+template <typename Functor>                               struct cwise_promote_storage_type<Sparse,Dense,Functor>                             { typedef Sparse ret; };
+template <typename Functor>                               struct cwise_promote_storage_type<Dense,Sparse,Functor>                             { typedef Sparse ret; };
+
+template <typename LhsKind, typename RhsKind, int LhsOrder, int RhsOrder> struct cwise_promote_storage_order {
+  enum { value = LhsOrder };
+};
+
+template <typename LhsKind, int LhsOrder, int RhsOrder>   struct cwise_promote_storage_order<LhsKind,Sparse,LhsOrder,RhsOrder>                { enum { value = RhsOrder }; };
+template <typename RhsKind, int LhsOrder, int RhsOrder>   struct cwise_promote_storage_order<Sparse,RhsKind,LhsOrder,RhsOrder>                { enum { value = LhsOrder }; };
+template <int Order>                                      struct cwise_promote_storage_order<Sparse,Sparse,Order,Order>                       { enum { value = Order }; };
+
+
+/** \internal Specify the "storage kind" of multiplying an expression of kind A with kind B.
+  * The template parameter ProductTag permits to specialize the resulting storage kind wrt to
+  * some compile-time properties of the product: GemmProduct, GemvProduct, OuterProduct, InnerProduct.
+  * The default rules are as follows:
+  * \code
+  *  K * K            -> K
+  *  dense * K        -> dense
+  *  K * dense        -> dense
+  *  diag * K         -> K
+  *  K * diag         -> K
+  *  Perm * K         -> K
+  * K * Perm          -> K
+  * \endcode
+  */
+template <typename A, typename B, int ProductTag> struct product_promote_storage_type;
+
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  A,                  ProductTag> { typedef A     ret;};
+template <int ProductTag>             struct product_promote_storage_type<Dense,              Dense,              ProductTag> { typedef Dense ret;};
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  Dense,              ProductTag> { typedef Dense ret; };
+template <typename B, int ProductTag> struct product_promote_storage_type<Dense,              B,                  ProductTag> { typedef Dense ret; };
+
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  DiagonalShape,      ProductTag> { typedef A ret; };
+template <typename B, int ProductTag> struct product_promote_storage_type<DiagonalShape,      B,                  ProductTag> { typedef B ret; };
+template <int ProductTag>             struct product_promote_storage_type<Dense,              DiagonalShape,      ProductTag> { typedef Dense ret; };
+template <int ProductTag>             struct product_promote_storage_type<DiagonalShape,      Dense,              ProductTag> { typedef Dense ret; };
+
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  PermutationStorage, ProductTag> { typedef A ret; };
+template <typename B, int ProductTag> struct product_promote_storage_type<PermutationStorage, B,                  ProductTag> { typedef B ret; };
+template <int ProductTag>             struct product_promote_storage_type<Dense,              PermutationStorage, ProductTag> { typedef Dense ret; };
+template <int ProductTag>             struct product_promote_storage_type<PermutationStorage, Dense,              ProductTag> { typedef Dense ret; };
+
+/** \internal gives the plain matrix or array type to store a row/column/diagonal of a matrix type.
+  * \tparam Scalar optional parameter allowing to pass a different scalar type than the one of the MatrixType.
+  */
+template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
+struct plain_row_type
+{
+  typedef Matrix<Scalar, 1, ExpressionType::ColsAtCompileTime,
+                 int(ExpressionType::PlainObject::Options) | int(RowMajor), 1, ExpressionType::MaxColsAtCompileTime> MatrixRowType;
+  typedef Array<Scalar, 1, ExpressionType::ColsAtCompileTime,
+                 int(ExpressionType::PlainObject::Options) | int(RowMajor), 1, ExpressionType::MaxColsAtCompileTime> ArrayRowType;
+
+  typedef typename conditional<
+    is_same< typename traits<ExpressionType>::XprKind, MatrixXpr >::value,
+    MatrixRowType,
+    ArrayRowType
+  >::type type;
+};
+
+template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
+struct plain_col_type
+{
+  typedef Matrix<Scalar, ExpressionType::RowsAtCompileTime, 1,
+                 ExpressionType::PlainObject::Options & ~RowMajor, ExpressionType::MaxRowsAtCompileTime, 1> MatrixColType;
+  typedef Array<Scalar, ExpressionType::RowsAtCompileTime, 1,
+                 ExpressionType::PlainObject::Options & ~RowMajor, ExpressionType::MaxRowsAtCompileTime, 1> ArrayColType;
+
+  typedef typename conditional<
+    is_same< typename traits<ExpressionType>::XprKind, MatrixXpr >::value,
+    MatrixColType,
+    ArrayColType
+  >::type type;
+};
+
+template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
+struct plain_diag_type
+{
+  enum { diag_size = EIGEN_SIZE_MIN_PREFER_DYNAMIC(ExpressionType::RowsAtCompileTime, ExpressionType::ColsAtCompileTime),
+         max_diag_size = EIGEN_SIZE_MIN_PREFER_FIXED(ExpressionType::MaxRowsAtCompileTime, ExpressionType::MaxColsAtCompileTime)
+  };
+  typedef Matrix<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1> MatrixDiagType;
+  typedef Array<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1> ArrayDiagType;
+
+  typedef typename conditional<
+    is_same< typename traits<ExpressionType>::XprKind, MatrixXpr >::value,
+    MatrixDiagType,
+    ArrayDiagType
+  >::type type;
+};
+
+template<typename Expr,typename Scalar = typename Expr::Scalar>
+struct plain_constant_type
+{
+  enum { Options = (traits<Expr>::Flags&RowMajorBit)?RowMajor:0 };
+
+  typedef Array<Scalar,  traits<Expr>::RowsAtCompileTime,   traits<Expr>::ColsAtCompileTime,
+                Options, traits<Expr>::MaxRowsAtCompileTime,traits<Expr>::MaxColsAtCompileTime> array_type;
+
+  typedef Matrix<Scalar,  traits<Expr>::RowsAtCompileTime,   traits<Expr>::ColsAtCompileTime,
+                 Options, traits<Expr>::MaxRowsAtCompileTime,traits<Expr>::MaxColsAtCompileTime> matrix_type;
+
+  typedef CwiseNullaryOp<scalar_constant_op<Scalar>, const typename conditional<is_same< typename traits<Expr>::XprKind, MatrixXpr >::value, matrix_type, array_type>::type > type;
+};
+
+template<typename ExpressionType>
+struct is_lvalue
+{
+  enum { value = (!bool(is_const<ExpressionType>::value)) &&
+                 bool(traits<ExpressionType>::Flags & LvalueBit) };
+};
+
+template<typename T> struct is_diagonal
+{ enum { ret = false }; };
+
+template<typename T> struct is_diagonal<DiagonalBase<T> >
+{ enum { ret = true }; };
+
+template<typename T> struct is_diagonal<DiagonalWrapper<T> >
+{ enum { ret = true }; };
+
+template<typename T, int S> struct is_diagonal<DiagonalMatrix<T,S> >
+{ enum { ret = true }; };
+
+
+template<typename T> struct is_identity
+{ enum { value = false }; };
+
+template<typename T> struct is_identity<CwiseNullaryOp<internal::scalar_identity_op<typename T::Scalar>, T> >
+{ enum { value = true }; };
+
+
+template<typename S1, typename S2> struct glue_shapes;
+template<> struct glue_shapes<DenseShape,TriangularShape> { typedef TriangularShape type;  };
+
+template<typename T1, typename T2>
+struct possibly_same_dense {
+  enum { value = has_direct_access<T1>::ret && has_direct_access<T2>::ret && is_same<typename T1::Scalar,typename T2::Scalar>::value };
+};
+
+template<typename T1, typename T2>
+EIGEN_DEVICE_FUNC
+bool is_same_dense(const T1 &mat1, const T2 &mat2, typename enable_if<possibly_same_dense<T1,T2>::value>::type * = 0)
+{
+  return (mat1.data()==mat2.data()) && (mat1.innerStride()==mat2.innerStride()) && (mat1.outerStride()==mat2.outerStride());
+}
+
+template<typename T1, typename T2>
+EIGEN_DEVICE_FUNC
+bool is_same_dense(const T1 &, const T2 &, typename enable_if<!possibly_same_dense<T1,T2>::value>::type * = 0)
+{
+  return false;
+}
+
+// Internal helper defining the cost of a scalar division for the type T.
+// The default heuristic can be specialized for each scalar type and architecture.
+template<typename T,bool Vectorized=false,typename EnableIf = void>
+struct scalar_div_cost {
+  enum { value = 8*NumTraits<T>::MulCost };
+};
+
+template<typename T,bool Vectorized>
+struct scalar_div_cost<std::complex<T>, Vectorized> {
+  enum { value = 2*scalar_div_cost<T>::value
+               + 6*NumTraits<T>::MulCost
+               + 3*NumTraits<T>::AddCost
+  };
+};
+
+
+template<bool Vectorized>
+struct scalar_div_cost<signed long,Vectorized,typename conditional<sizeof(long)==8,void,false_type>::type> { enum { value = 24 }; };
+template<bool Vectorized>
+struct scalar_div_cost<unsigned long,Vectorized,typename conditional<sizeof(long)==8,void,false_type>::type> { enum { value = 21 }; };
+
+
+#ifdef EIGEN_DEBUG_ASSIGN
+std::string demangle_traversal(int t)
+{
+  if(t==DefaultTraversal) return "DefaultTraversal";
+  if(t==LinearTraversal) return "LinearTraversal";
+  if(t==InnerVectorizedTraversal) return "InnerVectorizedTraversal";
+  if(t==LinearVectorizedTraversal) return "LinearVectorizedTraversal";
+  if(t==SliceVectorizedTraversal) return "SliceVectorizedTraversal";
+  return "?";
+}
+std::string demangle_unrolling(int t)
+{
+  if(t==NoUnrolling) return "NoUnrolling";
+  if(t==InnerUnrolling) return "InnerUnrolling";
+  if(t==CompleteUnrolling) return "CompleteUnrolling";
+  return "?";
+}
+std::string demangle_flags(int f)
+{
+  std::string res;
+  if(f&RowMajorBit)                 res += " | RowMajor";
+  if(f&PacketAccessBit)             res += " | Packet";
+  if(f&LinearAccessBit)             res += " | Linear";
+  if(f&LvalueBit)                   res += " | Lvalue";
+  if(f&DirectAccessBit)             res += " | Direct";
+  if(f&NestByRefBit)                res += " | NestByRef";
+  if(f&NoPreferredStorageOrderBit)  res += " | NoPreferredStorageOrderBit";
+
+  return res;
+}
+#endif
+
+} // end namespace internal
+
+
+/** \class ScalarBinaryOpTraits
+  * \ingroup Core_Module
+  *
+  * \brief Determines whether the given binary operation of two numeric types is allowed and what the scalar return type is.
+  *
+  * This class permits to control the scalar return type of any binary operation performed on two different scalar types through (partial) template specializations.
+  *
+  * For instance, let \c U1, \c U2 and \c U3 be three user defined scalar types for which most operations between instances of \c U1 and \c U2 returns an \c U3.
+  * You can let %Eigen knows that by defining:
+    \code
+    template<typename BinaryOp>
+    struct ScalarBinaryOpTraits<U1,U2,BinaryOp> { typedef U3 ReturnType;  };
+    template<typename BinaryOp>
+    struct ScalarBinaryOpTraits<U2,U1,BinaryOp> { typedef U3 ReturnType;  };
+    \endcode
+  * You can then explicitly disable some particular operations to get more explicit error messages:
+    \code
+    template<>
+    struct ScalarBinaryOpTraits<U1,U2,internal::scalar_max_op<U1,U2> > {};
+    \endcode
+  * Or customize the return type for individual operation:
+    \code
+    template<>
+    struct ScalarBinaryOpTraits<U1,U2,internal::scalar_sum_op<U1,U2> > { typedef U1 ReturnType; };
+    \endcode
+  *
+  * By default, the following generic combinations are supported:
+  <table class="manual">
+  <tr><th>ScalarA</th><th>ScalarB</th><th>BinaryOp</th><th>ReturnType</th><th>Note</th></tr>
+  <tr            ><td>\c T </td><td>\c T </td><td>\c * </td><td>\c T </td><td></td></tr>
+  <tr class="alt"><td>\c NumTraits<T>::Real </td><td>\c T </td><td>\c * </td><td>\c T </td><td>Only if \c NumTraits<T>::IsComplex </td></tr>
+  <tr            ><td>\c T </td><td>\c NumTraits<T>::Real </td><td>\c * </td><td>\c T </td><td>Only if \c NumTraits<T>::IsComplex </td></tr>
+  </table>
+  *
+  * \sa CwiseBinaryOp
+  */
+template<typename ScalarA, typename ScalarB, typename BinaryOp=internal::scalar_product_op<ScalarA,ScalarB> >
+struct ScalarBinaryOpTraits
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  // for backward compatibility, use the hints given by the (deprecated) internal::scalar_product_traits class.
+  : internal::scalar_product_traits<ScalarA,ScalarB>
+#endif // EIGEN_PARSED_BY_DOXYGEN
+{};
+
+template<typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<T,T,BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+template <typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<T, typename NumTraits<typename internal::enable_if<NumTraits<T>::IsComplex,T>::type>::Real, BinaryOp>
+{
+  typedef T ReturnType;
+};
+template <typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<typename NumTraits<typename internal::enable_if<NumTraits<T>::IsComplex,T>::type>::Real, T, BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+// For Matrix * Permutation
+template<typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<T,void,BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+// For Permutation * Matrix
+template<typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<void,T,BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+// for Permutation*Permutation
+template<typename BinaryOp>
+struct ScalarBinaryOpTraits<void,void,BinaryOp>
+{
+  typedef void ReturnType;
+};
+
+// We require Lhs and Rhs to have "compatible" scalar types.
+// It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized paths.
+// So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user tries to
+// add together a float matrix and a double matrix.
+#define EIGEN_CHECK_BINARY_COMPATIBILIY(BINOP,LHS,RHS) \
+  EIGEN_STATIC_ASSERT((Eigen::internal::has_ReturnType<ScalarBinaryOpTraits<LHS, RHS,BINOP> >::value), \
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+} // end namespace Eigen
+
+#endif // EIGEN_XPRHELPER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/ComplexEigenSolver.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
new file mode 100644
index 00000000..081e918f
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
@@ -0,0 +1,346 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Claire Maurice
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_EIGEN_SOLVER_H
+#define EIGEN_COMPLEX_EIGEN_SOLVER_H
+
+#include "./ComplexSchur.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class ComplexEigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of general complex matrices
+  *
+  * \tparam _MatrixType the type of the matrix of which we are
+  * computing the eigendecomposition; this is expected to be an
+  * instantiation of the Matrix class template.
+  *
+  * The eigenvalues and eigenvectors of a matrix \f$ A \f$ are scalars
+  * \f$ \lambda \f$ and vectors \f$ v \f$ such that \f$ Av = \lambda v
+  * \f$.  If \f$ D \f$ is a diagonal matrix with the eigenvalues on
+  * the diagonal, and \f$ V \f$ is a matrix with the eigenvectors as
+  * its columns, then \f$ A V = V D \f$. The matrix \f$ V \f$ is
+  * almost always invertible, in which case we have \f$ A = V D V^{-1}
+  * \f$. This is called the eigendecomposition.
+  *
+  * The main function in this class is compute(), which computes the
+  * eigenvalues and eigenvectors of a given function. The
+  * documentation for that function contains an example showing the
+  * main features of the class.
+  *
+  * \sa class EigenSolver, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class ComplexEigenSolver
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for #MatrixType.
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for vector of eigenvalues as returned by eigenvalues().
+      *
+      * This is a column vector with entries of type #ComplexScalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options&(~RowMajor), MaxColsAtCompileTime, 1> EigenvalueType;
+
+    /** \brief Type for matrix of eigenvectors as returned by eigenvectors().
+      *
+      * This is a square matrix with entries of type #ComplexScalar.
+      * The size is the same as the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> EigenvectorType;
+
+    /** \brief Default constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().
+      */
+    ComplexEigenSolver()
+            : m_eivec(),
+              m_eivalues(),
+              m_schur(),
+              m_isInitialized(false),
+              m_eigenvectorsOk(false),
+              m_matX()
+    {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa ComplexEigenSolver()
+      */
+    explicit ComplexEigenSolver(Index size)
+            : m_eivec(size, size),
+              m_eivalues(size),
+              m_schur(size),
+              m_isInitialized(false),
+              m_eigenvectorsOk(false),
+              m_matX(size, size)
+    {}
+
+    /** \brief Constructor; computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed.
+      *
+      * This constructor calls compute() to compute the eigendecomposition.
+      */
+    template<typename InputType>
+    explicit ComplexEigenSolver(const EigenBase<InputType>& matrix, bool computeEigenvectors = true)
+            : m_eivec(matrix.rows(),matrix.cols()),
+              m_eivalues(matrix.cols()),
+              m_schur(matrix.rows()),
+              m_isInitialized(false),
+              m_eigenvectorsOk(false),
+              m_matX(matrix.rows(),matrix.cols())
+    {
+      compute(matrix.derived(), computeEigenvectors);
+    }
+
+    /** \brief Returns the eigenvectors of given matrix.
+      *
+      * \returns  A const reference to the matrix whose columns are the eigenvectors.
+      *
+      * \pre Either the constructor
+      * ComplexEigenSolver(const MatrixType& matrix, bool) or the member
+      * function compute(const MatrixType& matrix, bool) has been called before
+      * to compute the eigendecomposition of a matrix, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * This function returns a matrix whose columns are the eigenvectors. Column
+      * \f$ k \f$ is an eigenvector corresponding to eigenvalue number \f$ k
+      * \f$ as returned by eigenvalues().  The eigenvectors are normalized to
+      * have (Euclidean) norm equal to one. The matrix returned by this
+      * function is the matrix \f$ V \f$ in the eigendecomposition \f$ A = V D
+      * V^{-1} \f$, if it exists.
+      *
+      * Example: \include ComplexEigenSolver_eigenvectors.cpp
+      * Output: \verbinclude ComplexEigenSolver_eigenvectors.out
+      */
+    const EigenvectorType& eigenvectors() const
+    {
+      eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec;
+    }
+
+    /** \brief Returns the eigenvalues of given matrix.
+      *
+      * \returns A const reference to the column vector containing the eigenvalues.
+      *
+      * \pre Either the constructor
+      * ComplexEigenSolver(const MatrixType& matrix, bool) or the member
+      * function compute(const MatrixType& matrix, bool) has been called before
+      * to compute the eigendecomposition of a matrix.
+      *
+      * This function returns a column vector containing the
+      * eigenvalues. Eigenvalues are repeated according to their
+      * algebraic multiplicity, so there are as many eigenvalues as
+      * rows in the matrix. The eigenvalues are not sorted in any particular
+      * order.
+      *
+      * Example: \include ComplexEigenSolver_eigenvalues.cpp
+      * Output: \verbinclude ComplexEigenSolver_eigenvalues.out
+      */
+    const EigenvalueType& eigenvalues() const
+    {
+      eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
+      return m_eivalues;
+    }
+
+    /** \brief Computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed.
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of the complex matrix \p matrix.
+      * The eigenvalues() function can be used to retrieve them.  If
+      * \p computeEigenvectors is true, then the eigenvectors are also computed
+      * and can be retrieved by calling eigenvectors().
+      *
+      * The matrix is first reduced to Schur form using the
+      * ComplexSchur class. The Schur decomposition is then used to
+      * compute the eigenvalues and eigenvectors.
+      *
+      * The cost of the computation is dominated by the cost of the
+      * Schur decomposition, which is \f$ O(n^3) \f$ where \f$ n \f$
+      * is the size of the matrix.
+      *
+      * Example: \include ComplexEigenSolver_compute.cpp
+      * Output: \verbinclude ComplexEigenSolver_compute.out
+      */
+    template<typename InputType>
+    ComplexEigenSolver& compute(const EigenBase<InputType>& matrix, bool computeEigenvectors = true);
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
+      return m_schur.info();
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. */
+    ComplexEigenSolver& setMaxIterations(Index maxIters)
+    {
+      m_schur.setMaxIterations(maxIters);
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_schur.getMaxIterations();
+    }
+
+  protected:
+    
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+    
+    EigenvectorType m_eivec;
+    EigenvalueType m_eivalues;
+    ComplexSchur<MatrixType> m_schur;
+    bool m_isInitialized;
+    bool m_eigenvectorsOk;
+    EigenvectorType m_matX;
+
+  private:
+    void doComputeEigenvectors(RealScalar matrixnorm);
+    void sortEigenvalues(bool computeEigenvectors);
+};
+
+
+template<typename MatrixType>
+template<typename InputType>
+ComplexEigenSolver<MatrixType>& 
+ComplexEigenSolver<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeEigenvectors)
+{
+  check_template_parameters();
+  
+  // this code is inspired from Jampack
+  eigen_assert(matrix.cols() == matrix.rows());
+
+  // Do a complex Schur decomposition, A = U T U^*
+  // The eigenvalues are on the diagonal of T.
+  m_schur.compute(matrix.derived(), computeEigenvectors);
+
+  if(m_schur.info() == Success)
+  {
+    m_eivalues = m_schur.matrixT().diagonal();
+    if(computeEigenvectors)
+      doComputeEigenvectors(m_schur.matrixT().norm());
+    sortEigenvalues(computeEigenvectors);
+  }
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+  return *this;
+}
+
+
+template<typename MatrixType>
+void ComplexEigenSolver<MatrixType>::doComputeEigenvectors(RealScalar matrixnorm)
+{
+  const Index n = m_eivalues.size();
+
+  matrixnorm = numext::maxi(matrixnorm,(std::numeric_limits<RealScalar>::min)());
+
+  // Compute X such that T = X D X^(-1), where D is the diagonal of T.
+  // The matrix X is unit triangular.
+  m_matX = EigenvectorType::Zero(n, n);
+  for(Index k=n-1 ; k>=0 ; k--)
+  {
+    m_matX.coeffRef(k,k) = ComplexScalar(1.0,0.0);
+    // Compute X(i,k) using the (i,k) entry of the equation X T = D X
+    for(Index i=k-1 ; i>=0 ; i--)
+    {
+      m_matX.coeffRef(i,k) = -m_schur.matrixT().coeff(i,k);
+      if(k-i-1>0)
+        m_matX.coeffRef(i,k) -= (m_schur.matrixT().row(i).segment(i+1,k-i-1) * m_matX.col(k).segment(i+1,k-i-1)).value();
+      ComplexScalar z = m_schur.matrixT().coeff(i,i) - m_schur.matrixT().coeff(k,k);
+      if(z==ComplexScalar(0))
+      {
+        // If the i-th and k-th eigenvalue are equal, then z equals 0.
+        // Use a small value instead, to prevent division by zero.
+        numext::real_ref(z) = NumTraits<RealScalar>::epsilon() * matrixnorm;
+      }
+      m_matX.coeffRef(i,k) = m_matX.coeff(i,k) / z;
+    }
+  }
+
+  // Compute V as V = U X; now A = U T U^* = U X D X^(-1) U^* = V D V^(-1)
+  m_eivec.noalias() = m_schur.matrixU() * m_matX;
+  // .. and normalize the eigenvectors
+  for(Index k=0 ; k<n ; k++)
+  {
+    m_eivec.col(k).normalize();
+  }
+}
+
+
+template<typename MatrixType>
+void ComplexEigenSolver<MatrixType>::sortEigenvalues(bool computeEigenvectors)
+{
+  const Index n =  m_eivalues.size();
+  for (Index i=0; i<n; i++)
+  {
+    Index k;
+    m_eivalues.cwiseAbs().tail(n-i).minCoeff(&k);
+    if (k != 0)
+    {
+      k += i;
+      std::swap(m_eivalues[k],m_eivalues[i]);
+      if(computeEigenvectors)
+	m_eivec.col(i).swap(m_eivec.col(k));
+    }
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_EIGEN_SOLVER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/ComplexSchur.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/ComplexSchur.h
new file mode 100644
index 00000000..fc71468f
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/ComplexSchur.h
@@ -0,0 +1,462 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Claire Maurice
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_SCHUR_H
+#define EIGEN_COMPLEX_SCHUR_H
+
+#include "./HessenbergDecomposition.h"
+
+namespace Eigen { 
+
+namespace internal {
+template<typename MatrixType, bool IsComplex> struct complex_schur_reduce_to_hessenberg;
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class ComplexSchur
+  *
+  * \brief Performs a complex Schur decomposition of a real or complex square matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are
+  * computing the Schur decomposition; this is expected to be an
+  * instantiation of the Matrix class template.
+  *
+  * Given a real or complex square matrix A, this class computes the
+  * Schur decomposition: \f$ A = U T U^*\f$ where U is a unitary
+  * complex matrix, and T is a complex upper triangular matrix.  The
+  * diagonal of the matrix T corresponds to the eigenvalues of the
+  * matrix A.
+  *
+  * Call the function compute() to compute the Schur decomposition of
+  * a given matrix. Alternatively, you can use the 
+  * ComplexSchur(const MatrixType&, bool) constructor which computes
+  * the Schur decomposition at construction time. Once the
+  * decomposition is computed, you can use the matrixU() and matrixT()
+  * functions to retrieve the matrices U and V in the decomposition.
+  *
+  * \note This code is inspired from Jampack
+  *
+  * \sa class RealSchur, class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType> class ComplexSchur
+{
+  public:
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type \p _MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for \p _MatrixType. 
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for the matrices in the Schur decomposition.
+      *
+      * This is a square matrix with entries of type #ComplexScalar. 
+      * The size is the same as the size of \p _MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> ComplexMatrixType;
+
+    /** \brief Default constructor.
+      *
+      * \param [in] size  Positive integer, size of the matrix whose Schur decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user
+      * intends to perform decompositions via compute().  The \p size
+      * parameter is only used as a hint. It is not an error to give a
+      * wrong \p size, but it may impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit ComplexSchur(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime)
+      : m_matT(size,size),
+        m_matU(size,size),
+        m_hess(size),
+        m_isInitialized(false),
+        m_matUisUptodate(false),
+        m_maxIters(-1)
+    {}
+
+    /** \brief Constructor; computes Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix    Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+      *
+      * This constructor calls compute() to compute the Schur decomposition.
+      *
+      * \sa matrixT() and matrixU() for examples.
+      */
+    template<typename InputType>
+    explicit ComplexSchur(const EigenBase<InputType>& matrix, bool computeU = true)
+      : m_matT(matrix.rows(),matrix.cols()),
+        m_matU(matrix.rows(),matrix.cols()),
+        m_hess(matrix.rows()),
+        m_isInitialized(false),
+        m_matUisUptodate(false),
+        m_maxIters(-1)
+    {
+      compute(matrix.derived(), computeU);
+    }
+
+    /** \brief Returns the unitary matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix U.
+      *
+      * It is assumed that either the constructor
+      * ComplexSchur(const MatrixType& matrix, bool computeU) or the
+      * member function compute(const MatrixType& matrix, bool computeU)
+      * has been called before to compute the Schur decomposition of a
+      * matrix, and that \p computeU was set to true (the default
+      * value).
+      *
+      * Example: \include ComplexSchur_matrixU.cpp
+      * Output: \verbinclude ComplexSchur_matrixU.out
+      */
+    const ComplexMatrixType& matrixU() const
+    {
+      eigen_assert(m_isInitialized && "ComplexSchur is not initialized.");
+      eigen_assert(m_matUisUptodate && "The matrix U has not been computed during the ComplexSchur decomposition.");
+      return m_matU;
+    }
+
+    /** \brief Returns the triangular matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix T.
+      *
+      * It is assumed that either the constructor
+      * ComplexSchur(const MatrixType& matrix, bool computeU) or the
+      * member function compute(const MatrixType& matrix, bool computeU)
+      * has been called before to compute the Schur decomposition of a
+      * matrix.
+      *
+      * Note that this function returns a plain square matrix. If you want to reference
+      * only the upper triangular part, use:
+      * \code schur.matrixT().triangularView<Upper>() \endcode 
+      *
+      * Example: \include ComplexSchur_matrixT.cpp
+      * Output: \verbinclude ComplexSchur_matrixT.out
+      */
+    const ComplexMatrixType& matrixT() const
+    {
+      eigen_assert(m_isInitialized && "ComplexSchur is not initialized.");
+      return m_matT;
+    }
+
+    /** \brief Computes Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix  Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+
+      * \returns    Reference to \c *this
+      *
+      * The Schur decomposition is computed by first reducing the
+      * matrix to Hessenberg form using the class
+      * HessenbergDecomposition. The Hessenberg matrix is then reduced
+      * to triangular form by performing QR iterations with a single
+      * shift. The cost of computing the Schur decomposition depends
+      * on the number of iterations; as a rough guide, it may be taken
+      * on the number of iterations; as a rough guide, it may be taken
+      * to be \f$25n^3\f$ complex flops, or \f$10n^3\f$ complex flops
+      * if \a computeU is false.
+      *
+      * Example: \include ComplexSchur_compute.cpp
+      * Output: \verbinclude ComplexSchur_compute.out
+      *
+      * \sa compute(const MatrixType&, bool, Index)
+      */
+    template<typename InputType>
+    ComplexSchur& compute(const EigenBase<InputType>& matrix, bool computeU = true);
+    
+    /** \brief Compute Schur decomposition from a given Hessenberg matrix
+     *  \param[in] matrixH Matrix in Hessenberg form H
+     *  \param[in] matrixQ orthogonal matrix Q that transform a matrix A to H : A = Q H Q^T
+     *  \param computeU Computes the matriX U of the Schur vectors
+     * \return Reference to \c *this
+     * 
+     *  This routine assumes that the matrix is already reduced in Hessenberg form matrixH
+     *  using either the class HessenbergDecomposition or another mean. 
+     *  It computes the upper quasi-triangular matrix T of the Schur decomposition of H
+     *  When computeU is true, this routine computes the matrix U such that 
+     *  A = U T U^T =  (QZ) T (QZ)^T = Q H Q^T where A is the initial matrix
+     * 
+     * NOTE Q is referenced if computeU is true; so, if the initial orthogonal matrix
+     * is not available, the user should give an identity matrix (Q.setIdentity())
+     * 
+     * \sa compute(const MatrixType&, bool)
+     */
+    template<typename HessMatrixType, typename OrthMatrixType>
+    ComplexSchur& computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ,  bool computeU=true);
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "ComplexSchur is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. 
+      *
+      * If not specified by the user, the maximum number of iterations is m_maxIterationsPerRow times the size
+      * of the matrix.
+      */
+    ComplexSchur& setMaxIterations(Index maxIters)
+    {
+      m_maxIters = maxIters;
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_maxIters;
+    }
+
+    /** \brief Maximum number of iterations per row.
+      *
+      * If not otherwise specified, the maximum number of iterations is this number times the size of the
+      * matrix. It is currently set to 30.
+      */
+    static const int m_maxIterationsPerRow = 30;
+
+  protected:
+    ComplexMatrixType m_matT, m_matU;
+    HessenbergDecomposition<MatrixType> m_hess;
+    ComputationInfo m_info;
+    bool m_isInitialized;
+    bool m_matUisUptodate;
+    Index m_maxIters;
+
+  private:  
+    bool subdiagonalEntryIsNeglegible(Index i);
+    ComplexScalar computeShift(Index iu, Index iter);
+    void reduceToTriangularForm(bool computeU);
+    friend struct internal::complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>;
+};
+
+/** If m_matT(i+1,i) is neglegible in floating point arithmetic
+  * compared to m_matT(i,i) and m_matT(j,j), then set it to zero and
+  * return true, else return false. */
+template<typename MatrixType>
+inline bool ComplexSchur<MatrixType>::subdiagonalEntryIsNeglegible(Index i)
+{
+  RealScalar d = numext::norm1(m_matT.coeff(i,i)) + numext::norm1(m_matT.coeff(i+1,i+1));
+  RealScalar sd = numext::norm1(m_matT.coeff(i+1,i));
+  if (internal::isMuchSmallerThan(sd, d, NumTraits<RealScalar>::epsilon()))
+  {
+    m_matT.coeffRef(i+1,i) = ComplexScalar(0);
+    return true;
+  }
+  return false;
+}
+
+
+/** Compute the shift in the current QR iteration. */
+template<typename MatrixType>
+typename ComplexSchur<MatrixType>::ComplexScalar ComplexSchur<MatrixType>::computeShift(Index iu, Index iter)
+{
+  using std::abs;
+  if (iter == 10 || iter == 20) 
+  {
+    // exceptional shift, taken from http://www.netlib.org/eispack/comqr.f
+    return abs(numext::real(m_matT.coeff(iu,iu-1))) + abs(numext::real(m_matT.coeff(iu-1,iu-2)));
+  }
+
+  // compute the shift as one of the eigenvalues of t, the 2x2
+  // diagonal block on the bottom of the active submatrix
+  Matrix<ComplexScalar,2,2> t = m_matT.template block<2,2>(iu-1,iu-1);
+  RealScalar normt = t.cwiseAbs().sum();
+  t /= normt;     // the normalization by sf is to avoid under/overflow
+
+  ComplexScalar b = t.coeff(0,1) * t.coeff(1,0);
+  ComplexScalar c = t.coeff(0,0) - t.coeff(1,1);
+  ComplexScalar disc = sqrt(c*c + RealScalar(4)*b);
+  ComplexScalar det = t.coeff(0,0) * t.coeff(1,1) - b;
+  ComplexScalar trace = t.coeff(0,0) + t.coeff(1,1);
+  ComplexScalar eival1 = (trace + disc) / RealScalar(2);
+  ComplexScalar eival2 = (trace - disc) / RealScalar(2);
+  RealScalar eival1_norm = numext::norm1(eival1);
+  RealScalar eival2_norm = numext::norm1(eival2);
+  // A division by zero can only occur if eival1==eival2==0.
+  // In this case, det==0, and all we have to do is checking that eival2_norm!=0
+  if(eival1_norm > eival2_norm)
+    eival2 = det / eival1;
+  else if(eival2_norm!=RealScalar(0))
+    eival1 = det / eival2;
+
+  // choose the eigenvalue closest to the bottom entry of the diagonal
+  if(numext::norm1(eival1-t.coeff(1,1)) < numext::norm1(eival2-t.coeff(1,1)))
+    return normt * eival1;
+  else
+    return normt * eival2;
+}
+
+
+template<typename MatrixType>
+template<typename InputType>
+ComplexSchur<MatrixType>& ComplexSchur<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeU)
+{
+  m_matUisUptodate = false;
+  eigen_assert(matrix.cols() == matrix.rows());
+
+  if(matrix.cols() == 1)
+  {
+    m_matT = matrix.derived().template cast<ComplexScalar>();
+    if(computeU)  m_matU = ComplexMatrixType::Identity(1,1);
+    m_info = Success;
+    m_isInitialized = true;
+    m_matUisUptodate = computeU;
+    return *this;
+  }
+
+  internal::complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>::run(*this, matrix.derived(), computeU);
+  computeFromHessenberg(m_matT, m_matU, computeU);
+  return *this;
+}
+
+template<typename MatrixType>
+template<typename HessMatrixType, typename OrthMatrixType>
+ComplexSchur<MatrixType>& ComplexSchur<MatrixType>::computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ, bool computeU)
+{
+  m_matT = matrixH;
+  if(computeU)
+    m_matU = matrixQ;
+  reduceToTriangularForm(computeU);
+  return *this;
+}
+namespace internal {
+
+/* Reduce given matrix to Hessenberg form */
+template<typename MatrixType, bool IsComplex>
+struct complex_schur_reduce_to_hessenberg
+{
+  // this is the implementation for the case IsComplex = true
+  static void run(ComplexSchur<MatrixType>& _this, const MatrixType& matrix, bool computeU)
+  {
+    _this.m_hess.compute(matrix);
+    _this.m_matT = _this.m_hess.matrixH();
+    if(computeU)  _this.m_matU = _this.m_hess.matrixQ();
+  }
+};
+
+template<typename MatrixType>
+struct complex_schur_reduce_to_hessenberg<MatrixType, false>
+{
+  static void run(ComplexSchur<MatrixType>& _this, const MatrixType& matrix, bool computeU)
+  {
+    typedef typename ComplexSchur<MatrixType>::ComplexScalar ComplexScalar;
+
+    // Note: m_hess is over RealScalar; m_matT and m_matU is over ComplexScalar
+    _this.m_hess.compute(matrix);
+    _this.m_matT = _this.m_hess.matrixH().template cast<ComplexScalar>();
+    if(computeU)  
+    {
+      // This may cause an allocation which seems to be avoidable
+      MatrixType Q = _this.m_hess.matrixQ(); 
+      _this.m_matU = Q.template cast<ComplexScalar>();
+    }
+  }
+};
+
+} // end namespace internal
+
+// Reduce the Hessenberg matrix m_matT to triangular form by QR iteration.
+template<typename MatrixType>
+void ComplexSchur<MatrixType>::reduceToTriangularForm(bool computeU)
+{  
+  Index maxIters = m_maxIters;
+  if (maxIters == -1)
+    maxIters = m_maxIterationsPerRow * m_matT.rows();
+
+  // The matrix m_matT is divided in three parts. 
+  // Rows 0,...,il-1 are decoupled from the rest because m_matT(il,il-1) is zero. 
+  // Rows il,...,iu is the part we are working on (the active submatrix).
+  // Rows iu+1,...,end are already brought in triangular form.
+  Index iu = m_matT.cols() - 1;
+  Index il;
+  Index iter = 0; // number of iterations we are working on the (iu,iu) element
+  Index totalIter = 0; // number of iterations for whole matrix
+
+  while(true)
+  {
+    // find iu, the bottom row of the active submatrix
+    while(iu > 0)
+    {
+      if(!subdiagonalEntryIsNeglegible(iu-1)) break;
+      iter = 0;
+      --iu;
+    }
+
+    // if iu is zero then we are done; the whole matrix is triangularized
+    if(iu==0) break;
+
+    // if we spent too many iterations, we give up
+    iter++;
+    totalIter++;
+    if(totalIter > maxIters) break;
+
+    // find il, the top row of the active submatrix
+    il = iu-1;
+    while(il > 0 && !subdiagonalEntryIsNeglegible(il-1))
+    {
+      --il;
+    }
+
+    /* perform the QR step using Givens rotations. The first rotation
+       creates a bulge; the (il+2,il) element becomes nonzero. This
+       bulge is chased down to the bottom of the active submatrix. */
+
+    ComplexScalar shift = computeShift(iu, iter);
+    JacobiRotation<ComplexScalar> rot;
+    rot.makeGivens(m_matT.coeff(il,il) - shift, m_matT.coeff(il+1,il));
+    m_matT.rightCols(m_matT.cols()-il).applyOnTheLeft(il, il+1, rot.adjoint());
+    m_matT.topRows((std::min)(il+2,iu)+1).applyOnTheRight(il, il+1, rot);
+    if(computeU) m_matU.applyOnTheRight(il, il+1, rot);
+
+    for(Index i=il+1 ; i<iu ; i++)
+    {
+      rot.makeGivens(m_matT.coeffRef(i,i-1), m_matT.coeffRef(i+1,i-1), &m_matT.coeffRef(i,i-1));
+      m_matT.coeffRef(i+1,i-1) = ComplexScalar(0);
+      m_matT.rightCols(m_matT.cols()-i).applyOnTheLeft(i, i+1, rot.adjoint());
+      m_matT.topRows((std::min)(i+2,iu)+1).applyOnTheRight(i, i+1, rot);
+      if(computeU) m_matU.applyOnTheRight(i, i+1, rot);
+    }
+  }
+
+  if(totalIter <= maxIters)
+    m_info = Success;
+  else
+    m_info = NoConvergence;
+
+  m_isInitialized = true;
+  m_matUisUptodate = computeU;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_SCHUR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
new file mode 100644
index 00000000..4980a3ed
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
@@ -0,0 +1,91 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Complex Schur needed to complex unsymmetrical eigenvalues/eigenvectors.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_COMPLEX_SCHUR_LAPACKE_H
+#define EIGEN_COMPLEX_SCHUR_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_SCHUR_COMPLEX(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX, LAPACKE_PREFIX_U, EIGCOLROW, LAPACKE_COLROW) \
+template<> template<typename InputType> inline \
+ComplexSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >& \
+ComplexSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >::compute(const EigenBase<InputType>& matrix, bool computeU) \
+{ \
+  typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> MatrixType; \
+  typedef MatrixType::RealScalar RealScalar; \
+  typedef std::complex<RealScalar> ComplexScalar; \
+\
+  eigen_assert(matrix.cols() == matrix.rows()); \
+\
+  m_matUisUptodate = false; \
+  if(matrix.cols() == 1) \
+  { \
+    m_matT = matrix.derived().template cast<ComplexScalar>(); \
+    if(computeU)  m_matU = ComplexMatrixType::Identity(1,1); \
+      m_info = Success; \
+      m_isInitialized = true; \
+      m_matUisUptodate = computeU; \
+      return *this; \
+  } \
+  lapack_int n = internal::convert_index<lapack_int>(matrix.cols()), sdim, info; \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  char jobvs, sort='N'; \
+  LAPACK_##LAPACKE_PREFIX_U##_SELECT1 select = 0; \
+  jobvs = (computeU) ? 'V' : 'N'; \
+  m_matU.resize(n, n); \
+  lapack_int ldvs  = internal::convert_index<lapack_int>(m_matU.outerStride()); \
+  m_matT = matrix; \
+  lapack_int lda = internal::convert_index<lapack_int>(m_matT.outerStride()); \
+  Matrix<EIGTYPE, Dynamic, Dynamic> w; \
+  w.resize(n, 1);\
+  info = LAPACKE_##LAPACKE_PREFIX##gees( matrix_order, jobvs, sort, select, n, (LAPACKE_TYPE*)m_matT.data(), lda, &sdim, (LAPACKE_TYPE*)w.data(), (LAPACKE_TYPE*)m_matU.data(), ldvs ); \
+  if(info == 0) \
+    m_info = Success; \
+  else \
+    m_info = NoConvergence; \
+\
+  m_isInitialized = true; \
+  m_matUisUptodate = computeU; \
+  return *this; \
+\
+}
+
+EIGEN_LAPACKE_SCHUR_COMPLEX(dcomplex, lapack_complex_double, z, Z, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_COMPLEX(scomplex, lapack_complex_float,  c, C, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_COMPLEX(dcomplex, lapack_complex_double, z, Z, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SCHUR_COMPLEX(scomplex, lapack_complex_float,  c, C, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_SCHUR_LAPACKE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/EigenSolver.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/EigenSolver.h
new file mode 100644
index 00000000..572b29e4
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/EigenSolver.h
@@ -0,0 +1,622 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EIGENSOLVER_H
+#define EIGEN_EIGENSOLVER_H
+
+#include "./RealSchur.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class EigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of general matrices
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * eigendecomposition; this is expected to be an instantiation of the Matrix
+  * class template. Currently, only real matrices are supported.
+  *
+  * The eigenvalues and eigenvectors of a matrix \f$ A \f$ are scalars
+  * \f$ \lambda \f$ and vectors \f$ v \f$ such that \f$ Av = \lambda v \f$.  If
+  * \f$ D \f$ is a diagonal matrix with the eigenvalues on the diagonal, and
+  * \f$ V \f$ is a matrix with the eigenvectors as its columns, then \f$ A V =
+  * V D \f$. The matrix \f$ V \f$ is almost always invertible, in which case we
+  * have \f$ A = V D V^{-1} \f$. This is called the eigendecomposition.
+  *
+  * The eigenvalues and eigenvectors of a matrix may be complex, even when the
+  * matrix is real. However, we can choose real matrices \f$ V \f$ and \f$ D
+  * \f$ satisfying \f$ A V = V D \f$, just like the eigendecomposition, if the
+  * matrix \f$ D \f$ is not required to be diagonal, but if it is allowed to
+  * have blocks of the form
+  * \f[ \begin{bmatrix} u & v \\ -v & u \end{bmatrix} \f]
+  * (where \f$ u \f$ and \f$ v \f$ are real numbers) on the diagonal.  These
+  * blocks correspond to complex eigenvalue pairs \f$ u \pm iv \f$. We call
+  * this variant of the eigendecomposition the pseudo-eigendecomposition.
+  *
+  * Call the function compute() to compute the eigenvalues and eigenvectors of
+  * a given matrix. Alternatively, you can use the 
+  * EigenSolver(const MatrixType&, bool) constructor which computes the
+  * eigenvalues and eigenvectors at construction time. Once the eigenvalue and
+  * eigenvectors are computed, they can be retrieved with the eigenvalues() and
+  * eigenvectors() functions. The pseudoEigenvalueMatrix() and
+  * pseudoEigenvectors() methods allow the construction of the
+  * pseudo-eigendecomposition.
+  *
+  * The documentation for EigenSolver(const MatrixType&, bool) contains an
+  * example of the typical use of this class.
+  *
+  * \note The implementation is adapted from
+  * <a href="http://math.nist.gov/javanumerics/jama/">JAMA</a> (public domain).
+  * Their code is based on EISPACK.
+  *
+  * \sa MatrixBase::eigenvalues(), class ComplexEigenSolver, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class EigenSolver
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for #MatrixType. 
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for vector of eigenvalues as returned by eigenvalues(). 
+      *
+      * This is a column vector with entries of type #ComplexScalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
+
+    /** \brief Type for matrix of eigenvectors as returned by eigenvectors(). 
+      *
+      * This is a square matrix with entries of type #ComplexScalar. 
+      * The size is the same as the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> EigenvectorsType;
+
+    /** \brief Default constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via EigenSolver::compute(const MatrixType&, bool).
+      *
+      * \sa compute() for an example.
+      */
+    EigenSolver() : m_eivec(), m_eivalues(), m_isInitialized(false), m_eigenvectorsOk(false), m_realSchur(), m_matT(), m_tmp() {}
+
+    /** \brief Default constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa EigenSolver()
+      */
+    explicit EigenSolver(Index size)
+      : m_eivec(size, size),
+        m_eivalues(size),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false),
+        m_realSchur(size),
+        m_matT(size, size), 
+        m_tmp(size)
+    {}
+
+    /** \brief Constructor; computes eigendecomposition of given matrix. 
+      * 
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed. 
+      *
+      * This constructor calls compute() to compute the eigenvalues
+      * and eigenvectors.
+      *
+      * Example: \include EigenSolver_EigenSolver_MatrixType.cpp
+      * Output: \verbinclude EigenSolver_EigenSolver_MatrixType.out
+      *
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit EigenSolver(const EigenBase<InputType>& matrix, bool computeEigenvectors = true)
+      : m_eivec(matrix.rows(), matrix.cols()),
+        m_eivalues(matrix.cols()),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false),
+        m_realSchur(matrix.cols()),
+        m_matT(matrix.rows(), matrix.cols()), 
+        m_tmp(matrix.cols())
+    {
+      compute(matrix.derived(), computeEigenvectors);
+    }
+
+    /** \brief Returns the eigenvectors of given matrix. 
+      *
+      * \returns  %Matrix whose columns are the (possibly complex) eigenvectors.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * Column \f$ k \f$ of the returned matrix is an eigenvector corresponding
+      * to eigenvalue number \f$ k \f$ as returned by eigenvalues().  The
+      * eigenvectors are normalized to have (Euclidean) norm equal to one. The
+      * matrix returned by this function is the matrix \f$ V \f$ in the
+      * eigendecomposition \f$ A = V D V^{-1} \f$, if it exists.
+      *
+      * Example: \include EigenSolver_eigenvectors.cpp
+      * Output: \verbinclude EigenSolver_eigenvectors.out
+      *
+      * \sa eigenvalues(), pseudoEigenvectors()
+      */
+    EigenvectorsType eigenvectors() const;
+
+    /** \brief Returns the pseudo-eigenvectors of given matrix. 
+      *
+      * \returns  Const reference to matrix whose columns are the pseudo-eigenvectors.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * The real matrix \f$ V \f$ returned by this function and the
+      * block-diagonal matrix \f$ D \f$ returned by pseudoEigenvalueMatrix()
+      * satisfy \f$ AV = VD \f$.
+      *
+      * Example: \include EigenSolver_pseudoEigenvectors.cpp
+      * Output: \verbinclude EigenSolver_pseudoEigenvectors.out
+      *
+      * \sa pseudoEigenvalueMatrix(), eigenvectors()
+      */
+    const MatrixType& pseudoEigenvectors() const
+    {
+      eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec;
+    }
+
+    /** \brief Returns the block-diagonal matrix in the pseudo-eigendecomposition.
+      *
+      * \returns  A block-diagonal matrix.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before.
+      *
+      * The matrix \f$ D \f$ returned by this function is real and
+      * block-diagonal. The blocks on the diagonal are either 1-by-1 or 2-by-2
+      * blocks of the form
+      * \f$ \begin{bmatrix} u & v \\ -v & u \end{bmatrix} \f$.
+      * These blocks are not sorted in any particular order.
+      * The matrix \f$ D \f$ and the matrix \f$ V \f$ returned by
+      * pseudoEigenvectors() satisfy \f$ AV = VD \f$.
+      *
+      * \sa pseudoEigenvectors() for an example, eigenvalues()
+      */
+    MatrixType pseudoEigenvalueMatrix() const;
+
+    /** \brief Returns the eigenvalues of given matrix. 
+      *
+      * \returns A const reference to the column vector containing the eigenvalues.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before.
+      *
+      * The eigenvalues are repeated according to their algebraic multiplicity,
+      * so there are as many eigenvalues as rows in the matrix. The eigenvalues 
+      * are not sorted in any particular order.
+      *
+      * Example: \include EigenSolver_eigenvalues.cpp
+      * Output: \verbinclude EigenSolver_eigenvalues.out
+      *
+      * \sa eigenvectors(), pseudoEigenvalueMatrix(),
+      *     MatrixBase::eigenvalues()
+      */
+    const EigenvalueType& eigenvalues() const
+    {
+      eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+      return m_eivalues;
+    }
+
+    /** \brief Computes eigendecomposition of given matrix. 
+      * 
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed. 
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of the real matrix \p matrix.
+      * The eigenvalues() function can be used to retrieve them.  If 
+      * \p computeEigenvectors is true, then the eigenvectors are also computed
+      * and can be retrieved by calling eigenvectors().
+      *
+      * The matrix is first reduced to real Schur form using the RealSchur
+      * class. The Schur decomposition is then used to compute the eigenvalues
+      * and eigenvectors.
+      *
+      * The cost of the computation is dominated by the cost of the
+      * Schur decomposition, which is very approximately \f$ 25n^3 \f$
+      * (where \f$ n \f$ is the size of the matrix) if \p computeEigenvectors 
+      * is true, and \f$ 10n^3 \f$ if \p computeEigenvectors is false.
+      *
+      * This method reuses of the allocated data in the EigenSolver object.
+      *
+      * Example: \include EigenSolver_compute.cpp
+      * Output: \verbinclude EigenSolver_compute.out
+      */
+    template<typename InputType>
+    EigenSolver& compute(const EigenBase<InputType>& matrix, bool computeEigenvectors = true);
+
+    /** \returns NumericalIssue if the input contains INF or NaN values or overflow occurred. Returns Success otherwise. */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. */
+    EigenSolver& setMaxIterations(Index maxIters)
+    {
+      m_realSchur.setMaxIterations(maxIters);
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_realSchur.getMaxIterations();
+    }
+
+  private:
+    void doComputeEigenvectors();
+
+  protected:
+    
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+      EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL);
+    }
+    
+    MatrixType m_eivec;
+    EigenvalueType m_eivalues;
+    bool m_isInitialized;
+    bool m_eigenvectorsOk;
+    ComputationInfo m_info;
+    RealSchur<MatrixType> m_realSchur;
+    MatrixType m_matT;
+
+    typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+    ColumnVectorType m_tmp;
+};
+
+template<typename MatrixType>
+MatrixType EigenSolver<MatrixType>::pseudoEigenvalueMatrix() const
+{
+  eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+  const RealScalar precision = RealScalar(2)*NumTraits<RealScalar>::epsilon();
+  Index n = m_eivalues.rows();
+  MatrixType matD = MatrixType::Zero(n,n);
+  for (Index i=0; i<n; ++i)
+  {
+    if (internal::isMuchSmallerThan(numext::imag(m_eivalues.coeff(i)), numext::real(m_eivalues.coeff(i)), precision))
+      matD.coeffRef(i,i) = numext::real(m_eivalues.coeff(i));
+    else
+    {
+      matD.template block<2,2>(i,i) <<  numext::real(m_eivalues.coeff(i)), numext::imag(m_eivalues.coeff(i)),
+                                       -numext::imag(m_eivalues.coeff(i)), numext::real(m_eivalues.coeff(i));
+      ++i;
+    }
+  }
+  return matD;
+}
+
+template<typename MatrixType>
+typename EigenSolver<MatrixType>::EigenvectorsType EigenSolver<MatrixType>::eigenvectors() const
+{
+  eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+  eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+  const RealScalar precision = RealScalar(2)*NumTraits<RealScalar>::epsilon();
+  Index n = m_eivec.cols();
+  EigenvectorsType matV(n,n);
+  for (Index j=0; j<n; ++j)
+  {
+    if (internal::isMuchSmallerThan(numext::imag(m_eivalues.coeff(j)), numext::real(m_eivalues.coeff(j)), precision) || j+1==n)
+    {
+      // we have a real eigen value
+      matV.col(j) = m_eivec.col(j).template cast<ComplexScalar>();
+      matV.col(j).normalize();
+    }
+    else
+    {
+      // we have a pair of complex eigen values
+      for (Index i=0; i<n; ++i)
+      {
+        matV.coeffRef(i,j)   = ComplexScalar(m_eivec.coeff(i,j),  m_eivec.coeff(i,j+1));
+        matV.coeffRef(i,j+1) = ComplexScalar(m_eivec.coeff(i,j), -m_eivec.coeff(i,j+1));
+      }
+      matV.col(j).normalize();
+      matV.col(j+1).normalize();
+      ++j;
+    }
+  }
+  return matV;
+}
+
+template<typename MatrixType>
+template<typename InputType>
+EigenSolver<MatrixType>& 
+EigenSolver<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeEigenvectors)
+{
+  check_template_parameters();
+  
+  using std::sqrt;
+  using std::abs;
+  using numext::isfinite;
+  eigen_assert(matrix.cols() == matrix.rows());
+
+  // Reduce to real Schur form.
+  m_realSchur.compute(matrix.derived(), computeEigenvectors);
+  
+  m_info = m_realSchur.info();
+
+  if (m_info == Success)
+  {
+    m_matT = m_realSchur.matrixT();
+    if (computeEigenvectors)
+      m_eivec = m_realSchur.matrixU();
+  
+    // Compute eigenvalues from matT
+    m_eivalues.resize(matrix.cols());
+    Index i = 0;
+    while (i < matrix.cols()) 
+    {
+      if (i == matrix.cols() - 1 || m_matT.coeff(i+1, i) == Scalar(0)) 
+      {
+        m_eivalues.coeffRef(i) = m_matT.coeff(i, i);
+        if(!(isfinite)(m_eivalues.coeffRef(i)))
+        {
+          m_isInitialized = true;
+          m_eigenvectorsOk = false;
+          m_info = NumericalIssue;
+          return *this;
+        }
+        ++i;
+      }
+      else
+      {
+        Scalar p = Scalar(0.5) * (m_matT.coeff(i, i) - m_matT.coeff(i+1, i+1));
+        Scalar z;
+        // Compute z = sqrt(abs(p * p + m_matT.coeff(i+1, i) * m_matT.coeff(i, i+1)));
+        // without overflow
+        {
+          Scalar t0 = m_matT.coeff(i+1, i);
+          Scalar t1 = m_matT.coeff(i, i+1);
+          Scalar maxval = numext::maxi<Scalar>(abs(p),numext::maxi<Scalar>(abs(t0),abs(t1)));
+          t0 /= maxval;
+          t1 /= maxval;
+          Scalar p0 = p/maxval;
+          z = maxval * sqrt(abs(p0 * p0 + t0 * t1));
+        }
+        
+        m_eivalues.coeffRef(i)   = ComplexScalar(m_matT.coeff(i+1, i+1) + p, z);
+        m_eivalues.coeffRef(i+1) = ComplexScalar(m_matT.coeff(i+1, i+1) + p, -z);
+        if(!((isfinite)(m_eivalues.coeffRef(i)) && (isfinite)(m_eivalues.coeffRef(i+1))))
+        {
+          m_isInitialized = true;
+          m_eigenvectorsOk = false;
+          m_info = NumericalIssue;
+          return *this;
+        }
+        i += 2;
+      }
+    }
+    
+    // Compute eigenvectors.
+    if (computeEigenvectors)
+      doComputeEigenvectors();
+  }
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+
+  return *this;
+}
+
+
+template<typename MatrixType>
+void EigenSolver<MatrixType>::doComputeEigenvectors()
+{
+  using std::abs;
+  const Index size = m_eivec.cols();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+
+  // inefficient! this is already computed in RealSchur
+  Scalar norm(0);
+  for (Index j = 0; j < size; ++j)
+  {
+    norm += m_matT.row(j).segment((std::max)(j-1,Index(0)), size-(std::max)(j-1,Index(0))).cwiseAbs().sum();
+  }
+  
+  // Backsubstitute to find vectors of upper triangular form
+  if (norm == Scalar(0))
+  {
+    return;
+  }
+
+  for (Index n = size-1; n >= 0; n--)
+  {
+    Scalar p = m_eivalues.coeff(n).real();
+    Scalar q = m_eivalues.coeff(n).imag();
+
+    // Scalar vector
+    if (q == Scalar(0))
+    {
+      Scalar lastr(0), lastw(0);
+      Index l = n;
+
+      m_matT.coeffRef(n,n) = Scalar(1);
+      for (Index i = n-1; i >= 0; i--)
+      {
+        Scalar w = m_matT.coeff(i,i) - p;
+        Scalar r = m_matT.row(i).segment(l,n-l+1).dot(m_matT.col(n).segment(l, n-l+1));
+
+        if (m_eivalues.coeff(i).imag() < Scalar(0))
+        {
+          lastw = w;
+          lastr = r;
+        }
+        else
+        {
+          l = i;
+          if (m_eivalues.coeff(i).imag() == Scalar(0))
+          {
+            if (w != Scalar(0))
+              m_matT.coeffRef(i,n) = -r / w;
+            else
+              m_matT.coeffRef(i,n) = -r / (eps * norm);
+          }
+          else // Solve real equations
+          {
+            Scalar x = m_matT.coeff(i,i+1);
+            Scalar y = m_matT.coeff(i+1,i);
+            Scalar denom = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag();
+            Scalar t = (x * lastr - lastw * r) / denom;
+            m_matT.coeffRef(i,n) = t;
+            if (abs(x) > abs(lastw))
+              m_matT.coeffRef(i+1,n) = (-r - w * t) / x;
+            else
+              m_matT.coeffRef(i+1,n) = (-lastr - y * t) / lastw;
+          }
+
+          // Overflow control
+          Scalar t = abs(m_matT.coeff(i,n));
+          if ((eps * t) * t > Scalar(1))
+            m_matT.col(n).tail(size-i) /= t;
+        }
+      }
+    }
+    else if (q < Scalar(0) && n > 0) // Complex vector
+    {
+      Scalar lastra(0), lastsa(0), lastw(0);
+      Index l = n-1;
+
+      // Last vector component imaginary so matrix is triangular
+      if (abs(m_matT.coeff(n,n-1)) > abs(m_matT.coeff(n-1,n)))
+      {
+        m_matT.coeffRef(n-1,n-1) = q / m_matT.coeff(n,n-1);
+        m_matT.coeffRef(n-1,n) = -(m_matT.coeff(n,n) - p) / m_matT.coeff(n,n-1);
+      }
+      else
+      {
+        ComplexScalar cc = ComplexScalar(Scalar(0),-m_matT.coeff(n-1,n)) / ComplexScalar(m_matT.coeff(n-1,n-1)-p,q);
+        m_matT.coeffRef(n-1,n-1) = numext::real(cc);
+        m_matT.coeffRef(n-1,n) = numext::imag(cc);
+      }
+      m_matT.coeffRef(n,n-1) = Scalar(0);
+      m_matT.coeffRef(n,n) = Scalar(1);
+      for (Index i = n-2; i >= 0; i--)
+      {
+        Scalar ra = m_matT.row(i).segment(l, n-l+1).dot(m_matT.col(n-1).segment(l, n-l+1));
+        Scalar sa = m_matT.row(i).segment(l, n-l+1).dot(m_matT.col(n).segment(l, n-l+1));
+        Scalar w = m_matT.coeff(i,i) - p;
+
+        if (m_eivalues.coeff(i).imag() < Scalar(0))
+        {
+          lastw = w;
+          lastra = ra;
+          lastsa = sa;
+        }
+        else
+        {
+          l = i;
+          if (m_eivalues.coeff(i).imag() == RealScalar(0))
+          {
+            ComplexScalar cc = ComplexScalar(-ra,-sa) / ComplexScalar(w,q);
+            m_matT.coeffRef(i,n-1) = numext::real(cc);
+            m_matT.coeffRef(i,n) = numext::imag(cc);
+          }
+          else
+          {
+            // Solve complex equations
+            Scalar x = m_matT.coeff(i,i+1);
+            Scalar y = m_matT.coeff(i+1,i);
+            Scalar vr = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag() - q * q;
+            Scalar vi = (m_eivalues.coeff(i).real() - p) * Scalar(2) * q;
+            if ((vr == Scalar(0)) && (vi == Scalar(0)))
+              vr = eps * norm * (abs(w) + abs(q) + abs(x) + abs(y) + abs(lastw));
+
+            ComplexScalar cc = ComplexScalar(x*lastra-lastw*ra+q*sa,x*lastsa-lastw*sa-q*ra) / ComplexScalar(vr,vi);
+            m_matT.coeffRef(i,n-1) = numext::real(cc);
+            m_matT.coeffRef(i,n) = numext::imag(cc);
+            if (abs(x) > (abs(lastw) + abs(q)))
+            {
+              m_matT.coeffRef(i+1,n-1) = (-ra - w * m_matT.coeff(i,n-1) + q * m_matT.coeff(i,n)) / x;
+              m_matT.coeffRef(i+1,n) = (-sa - w * m_matT.coeff(i,n) - q * m_matT.coeff(i,n-1)) / x;
+            }
+            else
+            {
+              cc = ComplexScalar(-lastra-y*m_matT.coeff(i,n-1),-lastsa-y*m_matT.coeff(i,n)) / ComplexScalar(lastw,q);
+              m_matT.coeffRef(i+1,n-1) = numext::real(cc);
+              m_matT.coeffRef(i+1,n) = numext::imag(cc);
+            }
+          }
+
+          // Overflow control
+          Scalar t = numext::maxi<Scalar>(abs(m_matT.coeff(i,n-1)),abs(m_matT.coeff(i,n)));
+          if ((eps * t) * t > Scalar(1))
+            m_matT.block(i, n-1, size-i, 2) /= t;
+
+        }
+      }
+      
+      // We handled a pair of complex conjugate eigenvalues, so need to skip them both
+      n--;
+    }
+    else
+    {
+      eigen_assert(0 && "Internal bug in EigenSolver (INF or NaN has not been detected)"); // this should not happen
+    }
+  }
+
+  // Back transformation to get eigenvectors of original matrix
+  for (Index j = size-1; j >= 0; j--)
+  {
+    m_tmp.noalias() = m_eivec.leftCols(j+1) * m_matT.col(j).segment(0, j+1);
+    m_eivec.col(j) = m_tmp;
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_EIGENSOLVER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
new file mode 100644
index 00000000..87d789b3
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
@@ -0,0 +1,418 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+// Copyright (C) 2016 Tobias Wood <tobias@spinicist.org.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERALIZEDEIGENSOLVER_H
+#define EIGEN_GENERALIZEDEIGENSOLVER_H
+
+#include "./RealQZ.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class GeneralizedEigenSolver
+  *
+  * \brief Computes the generalized eigenvalues and eigenvectors of a pair of general matrices
+  *
+  * \tparam _MatrixType the type of the matrices of which we are computing the
+  * eigen-decomposition; this is expected to be an instantiation of the Matrix
+  * class template. Currently, only real matrices are supported.
+  *
+  * The generalized eigenvalues and eigenvectors of a matrix pair \f$ A \f$ and \f$ B \f$ are scalars
+  * \f$ \lambda \f$ and vectors \f$ v \f$ such that \f$ Av = \lambda Bv \f$.  If
+  * \f$ D \f$ is a diagonal matrix with the eigenvalues on the diagonal, and
+  * \f$ V \f$ is a matrix with the eigenvectors as its columns, then \f$ A V =
+  * B V D \f$. The matrix \f$ V \f$ is almost always invertible, in which case we
+  * have \f$ A = B V D V^{-1} \f$. This is called the generalized eigen-decomposition.
+  *
+  * The generalized eigenvalues and eigenvectors of a matrix pair may be complex, even when the
+  * matrices are real. Moreover, the generalized eigenvalue might be infinite if the matrix B is
+  * singular. To workaround this difficulty, the eigenvalues are provided as a pair of complex \f$ \alpha \f$
+  * and real \f$ \beta \f$ such that: \f$ \lambda_i = \alpha_i / \beta_i \f$. If \f$ \beta_i \f$ is (nearly) zero,
+  * then one can consider the well defined left eigenvalue \f$ \mu = \beta_i / \alpha_i\f$ such that:
+  * \f$ \mu_i A v_i = B v_i \f$, or even \f$ \mu_i u_i^T A  = u_i^T B \f$ where \f$ u_i \f$ is
+  * called the left eigenvector.
+  *
+  * Call the function compute() to compute the generalized eigenvalues and eigenvectors of
+  * a given matrix pair. Alternatively, you can use the
+  * GeneralizedEigenSolver(const MatrixType&, const MatrixType&, bool) constructor which computes the
+  * eigenvalues and eigenvectors at construction time. Once the eigenvalue and
+  * eigenvectors are computed, they can be retrieved with the eigenvalues() and
+  * eigenvectors() functions.
+  *
+  * Here is an usage example of this class:
+  * Example: \include GeneralizedEigenSolver.cpp
+  * Output: \verbinclude GeneralizedEigenSolver.out
+  *
+  * \sa MatrixBase::eigenvalues(), class ComplexEigenSolver, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class GeneralizedEigenSolver
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for #MatrixType. 
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for vector of real scalar values eigenvalues as returned by betas().
+      *
+      * This is a column vector with entries of type #Scalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> VectorType;
+
+    /** \brief Type for vector of complex scalar values eigenvalues as returned by alphas().
+      *
+      * This is a column vector with entries of type #ComplexScalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ComplexVectorType;
+
+    /** \brief Expression type for the eigenvalues as returned by eigenvalues().
+      */
+    typedef CwiseBinaryOp<internal::scalar_quotient_op<ComplexScalar,Scalar>,ComplexVectorType,VectorType> EigenvalueType;
+
+    /** \brief Type for matrix of eigenvectors as returned by eigenvectors(). 
+      *
+      * This is a square matrix with entries of type #ComplexScalar. 
+      * The size is the same as the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> EigenvectorsType;
+
+    /** \brief Default constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via EigenSolver::compute(const MatrixType&, bool).
+      *
+      * \sa compute() for an example.
+      */
+    GeneralizedEigenSolver()
+      : m_eivec(),
+        m_alphas(),
+        m_betas(),
+        m_valuesOkay(false),
+        m_vectorsOkay(false),
+        m_realQZ()
+    {}
+
+    /** \brief Default constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa GeneralizedEigenSolver()
+      */
+    explicit GeneralizedEigenSolver(Index size)
+      : m_eivec(size, size),
+        m_alphas(size),
+        m_betas(size),
+        m_valuesOkay(false),
+        m_vectorsOkay(false),
+        m_realQZ(size),
+        m_tmp(size)
+    {}
+
+    /** \brief Constructor; computes the generalized eigendecomposition of given matrix pair.
+      * 
+      * \param[in]  A  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  B  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are computed.
+      *
+      * This constructor calls compute() to compute the generalized eigenvalues
+      * and eigenvectors.
+      *
+      * \sa compute()
+      */
+    GeneralizedEigenSolver(const MatrixType& A, const MatrixType& B, bool computeEigenvectors = true)
+      : m_eivec(A.rows(), A.cols()),
+        m_alphas(A.cols()),
+        m_betas(A.cols()),
+        m_valuesOkay(false),
+        m_vectorsOkay(false),
+        m_realQZ(A.cols()),
+        m_tmp(A.cols())
+    {
+      compute(A, B, computeEigenvectors);
+    }
+
+    /* \brief Returns the computed generalized eigenvectors.
+      *
+      * \returns  %Matrix whose columns are the (possibly complex) right eigenvectors.
+      * i.e. the eigenvectors that solve (A - l*B)x = 0. The ordering matches the eigenvalues.
+      *
+      * \pre Either the constructor 
+      * GeneralizedEigenSolver(const MatrixType&,const MatrixType&, bool) or the member function
+      * compute(const MatrixType&, const MatrixType& bool) has been called before, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * \sa eigenvalues()
+      */
+    EigenvectorsType eigenvectors() const {
+      eigen_assert(m_vectorsOkay && "Eigenvectors for GeneralizedEigenSolver were not calculated.");
+      return m_eivec;
+    }
+
+    /** \brief Returns an expression of the computed generalized eigenvalues.
+      *
+      * \returns An expression of the column vector containing the eigenvalues.
+      *
+      * It is a shortcut for \code this->alphas().cwiseQuotient(this->betas()); \endcode
+      * Not that betas might contain zeros. It is therefore not recommended to use this function,
+      * but rather directly deal with the alphas and betas vectors.
+      *
+      * \pre Either the constructor 
+      * GeneralizedEigenSolver(const MatrixType&,const MatrixType&,bool) or the member function
+      * compute(const MatrixType&,const MatrixType&,bool) has been called before.
+      *
+      * The eigenvalues are repeated according to their algebraic multiplicity,
+      * so there are as many eigenvalues as rows in the matrix. The eigenvalues 
+      * are not sorted in any particular order.
+      *
+      * \sa alphas(), betas(), eigenvectors()
+      */
+    EigenvalueType eigenvalues() const
+    {
+      eigen_assert(m_valuesOkay && "GeneralizedEigenSolver is not initialized.");
+      return EigenvalueType(m_alphas,m_betas);
+    }
+
+    /** \returns A const reference to the vectors containing the alpha values
+      *
+      * This vector permits to reconstruct the j-th eigenvalues as alphas(i)/betas(j).
+      *
+      * \sa betas(), eigenvalues() */
+    ComplexVectorType alphas() const
+    {
+      eigen_assert(m_valuesOkay && "GeneralizedEigenSolver is not initialized.");
+      return m_alphas;
+    }
+
+    /** \returns A const reference to the vectors containing the beta values
+      *
+      * This vector permits to reconstruct the j-th eigenvalues as alphas(i)/betas(j).
+      *
+      * \sa alphas(), eigenvalues() */
+    VectorType betas() const
+    {
+      eigen_assert(m_valuesOkay && "GeneralizedEigenSolver is not initialized.");
+      return m_betas;
+    }
+
+    /** \brief Computes generalized eigendecomposition of given matrix.
+      * 
+      * \param[in]  A  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  B  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed. 
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of the real matrix \p matrix.
+      * The eigenvalues() function can be used to retrieve them.  If 
+      * \p computeEigenvectors is true, then the eigenvectors are also computed
+      * and can be retrieved by calling eigenvectors().
+      *
+      * The matrix is first reduced to real generalized Schur form using the RealQZ
+      * class. The generalized Schur decomposition is then used to compute the eigenvalues
+      * and eigenvectors.
+      *
+      * The cost of the computation is dominated by the cost of the
+      * generalized Schur decomposition.
+      *
+      * This method reuses of the allocated data in the GeneralizedEigenSolver object.
+      */
+    GeneralizedEigenSolver& compute(const MatrixType& A, const MatrixType& B, bool computeEigenvectors = true);
+
+    ComputationInfo info() const
+    {
+      eigen_assert(m_valuesOkay && "EigenSolver is not initialized.");
+      return m_realQZ.info();
+    }
+
+    /** Sets the maximal number of iterations allowed.
+    */
+    GeneralizedEigenSolver& setMaxIterations(Index maxIters)
+    {
+      m_realQZ.setMaxIterations(maxIters);
+      return *this;
+    }
+
+  protected:
+    
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+      EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL);
+    }
+    
+    EigenvectorsType m_eivec;
+    ComplexVectorType m_alphas;
+    VectorType m_betas;
+    bool m_valuesOkay, m_vectorsOkay;
+    RealQZ<MatrixType> m_realQZ;
+    ComplexVectorType m_tmp;
+};
+
+template<typename MatrixType>
+GeneralizedEigenSolver<MatrixType>&
+GeneralizedEigenSolver<MatrixType>::compute(const MatrixType& A, const MatrixType& B, bool computeEigenvectors)
+{
+  check_template_parameters();
+  
+  using std::sqrt;
+  using std::abs;
+  eigen_assert(A.cols() == A.rows() && B.cols() == A.rows() && B.cols() == B.rows());
+  Index size = A.cols();
+  m_valuesOkay = false;
+  m_vectorsOkay = false;
+  // Reduce to generalized real Schur form:
+  // A = Q S Z and B = Q T Z
+  m_realQZ.compute(A, B, computeEigenvectors);
+  if (m_realQZ.info() == Success)
+  {
+    // Resize storage
+    m_alphas.resize(size);
+    m_betas.resize(size);
+    if (computeEigenvectors)
+    {
+      m_eivec.resize(size,size);
+      m_tmp.resize(size);
+    }
+
+    // Aliases:
+    Map<VectorType> v(reinterpret_cast<Scalar*>(m_tmp.data()), size);
+    ComplexVectorType &cv = m_tmp;
+    const MatrixType &mS = m_realQZ.matrixS();
+    const MatrixType &mT = m_realQZ.matrixT();
+
+    Index i = 0;
+    while (i < size)
+    {
+      if (i == size - 1 || mS.coeff(i+1, i) == Scalar(0))
+      {
+        // Real eigenvalue
+        m_alphas.coeffRef(i) = mS.diagonal().coeff(i);
+        m_betas.coeffRef(i)  = mT.diagonal().coeff(i);
+        if (computeEigenvectors)
+        {
+          v.setConstant(Scalar(0.0));
+          v.coeffRef(i) = Scalar(1.0);
+          // For singular eigenvalues do nothing more
+          if(abs(m_betas.coeffRef(i)) >= (std::numeric_limits<RealScalar>::min)())
+          {
+            // Non-singular eigenvalue
+            const Scalar alpha = real(m_alphas.coeffRef(i));
+            const Scalar beta = m_betas.coeffRef(i);
+            for (Index j = i-1; j >= 0; j--)
+            {
+              const Index st = j+1;
+              const Index sz = i-j;
+              if (j > 0 && mS.coeff(j, j-1) != Scalar(0))
+              {
+                // 2x2 block
+                Matrix<Scalar, 2, 1> rhs = (alpha*mT.template block<2,Dynamic>(j-1,st,2,sz) - beta*mS.template block<2,Dynamic>(j-1,st,2,sz)) .lazyProduct( v.segment(st,sz) );
+                Matrix<Scalar, 2, 2> lhs = beta * mS.template block<2,2>(j-1,j-1) - alpha * mT.template block<2,2>(j-1,j-1);
+                v.template segment<2>(j-1) = lhs.partialPivLu().solve(rhs);
+                j--;
+              }
+              else
+              {
+                v.coeffRef(j) = -v.segment(st,sz).transpose().cwiseProduct(beta*mS.block(j,st,1,sz) - alpha*mT.block(j,st,1,sz)).sum() / (beta*mS.coeffRef(j,j) - alpha*mT.coeffRef(j,j));
+              }
+            }
+          }
+          m_eivec.col(i).real().noalias() = m_realQZ.matrixZ().transpose() * v;
+          m_eivec.col(i).real().normalize();
+          m_eivec.col(i).imag().setConstant(0);
+        }
+        ++i;
+      }
+      else
+      {
+        // We need to extract the generalized eigenvalues of the pair of a general 2x2 block S and a positive diagonal 2x2 block T
+        // Then taking beta=T_00*T_11, we can avoid any division, and alpha is the eigenvalues of A = (U^-1 * S * U) * diag(T_11,T_00):
+
+        // T =  [a 0]
+        //      [0 b]
+        RealScalar a = mT.diagonal().coeff(i),
+                   b = mT.diagonal().coeff(i+1);
+        const RealScalar beta = m_betas.coeffRef(i) = m_betas.coeffRef(i+1) = a*b;
+
+        // ^^ NOTE: using diagonal()(i) instead of coeff(i,i) workarounds a MSVC bug.
+        Matrix<RealScalar,2,2> S2 = mS.template block<2,2>(i,i) * Matrix<Scalar,2,1>(b,a).asDiagonal();
+
+        Scalar p = Scalar(0.5) * (S2.coeff(0,0) - S2.coeff(1,1));
+        Scalar z = sqrt(abs(p * p + S2.coeff(1,0) * S2.coeff(0,1)));
+        const ComplexScalar alpha = ComplexScalar(S2.coeff(1,1) + p, (beta > 0) ? z : -z);
+        m_alphas.coeffRef(i)   = conj(alpha);
+        m_alphas.coeffRef(i+1) = alpha;
+
+        if (computeEigenvectors) {
+          // Compute eigenvector in position (i+1) and then position (i) is just the conjugate
+          cv.setZero();
+          cv.coeffRef(i+1) = Scalar(1.0);
+          // here, the "static_cast" workaound expression template issues.
+          cv.coeffRef(i) = -(static_cast<Scalar>(beta*mS.coeffRef(i,i+1)) - alpha*mT.coeffRef(i,i+1))
+                          / (static_cast<Scalar>(beta*mS.coeffRef(i,i))   - alpha*mT.coeffRef(i,i));
+          for (Index j = i-1; j >= 0; j--)
+          {
+            const Index st = j+1;
+            const Index sz = i+1-j;
+            if (j > 0 && mS.coeff(j, j-1) != Scalar(0))
+            {
+              // 2x2 block
+              Matrix<ComplexScalar, 2, 1> rhs = (alpha*mT.template block<2,Dynamic>(j-1,st,2,sz) - beta*mS.template block<2,Dynamic>(j-1,st,2,sz)) .lazyProduct( cv.segment(st,sz) );
+              Matrix<ComplexScalar, 2, 2> lhs = beta * mS.template block<2,2>(j-1,j-1) - alpha * mT.template block<2,2>(j-1,j-1);
+              cv.template segment<2>(j-1) = lhs.partialPivLu().solve(rhs);
+              j--;
+            } else {
+              cv.coeffRef(j) =  cv.segment(st,sz).transpose().cwiseProduct(beta*mS.block(j,st,1,sz) - alpha*mT.block(j,st,1,sz)).sum()
+                              / (alpha*mT.coeffRef(j,j) - static_cast<Scalar>(beta*mS.coeffRef(j,j)));
+            }
+          }
+          m_eivec.col(i+1).noalias() = (m_realQZ.matrixZ().transpose() * cv);
+          m_eivec.col(i+1).normalize();
+          m_eivec.col(i) = m_eivec.col(i+1).conjugate();
+        }
+        i += 2;
+      }
+    }
+
+    m_valuesOkay = true;
+    m_vectorsOkay = computeEigenvectors;
+  }
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERALIZEDEIGENSOLVER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
new file mode 100644
index 00000000..d0f9091b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
+#define EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
+
+#include "./Tridiagonalization.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class GeneralizedSelfAdjointEigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of the generalized selfadjoint eigen problem
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * eigendecomposition; this is expected to be an instantiation of the Matrix
+  * class template.
+  *
+  * This class solves the generalized eigenvalue problem
+  * \f$ Av = \lambda Bv \f$. In this case, the matrix \f$ A \f$ should be
+  * selfadjoint and the matrix \f$ B \f$ should be positive definite.
+  *
+  * Only the \b lower \b triangular \b part of the input matrix is referenced.
+  *
+  * Call the function compute() to compute the eigenvalues and eigenvectors of
+  * a given matrix. Alternatively, you can use the
+  * GeneralizedSelfAdjointEigenSolver(const MatrixType&, const MatrixType&, int)
+  * constructor which computes the eigenvalues and eigenvectors at construction time.
+  * Once the eigenvalue and eigenvectors are computed, they can be retrieved with the eigenvalues()
+  * and eigenvectors() functions.
+  *
+  * The documentation for GeneralizedSelfAdjointEigenSolver(const MatrixType&, const MatrixType&, int)
+  * contains an example of the typical use of this class.
+  *
+  * \sa class SelfAdjointEigenSolver, class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType>
+class GeneralizedSelfAdjointEigenSolver : public SelfAdjointEigenSolver<_MatrixType>
+{
+    typedef SelfAdjointEigenSolver<_MatrixType> Base;
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    /** \brief Default constructor for fixed-size matrices.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute(). This constructor
+      * can only be used if \p _MatrixType is a fixed-size matrix; use
+      * GeneralizedSelfAdjointEigenSolver(Index) for dynamic-size matrices.
+      */
+    GeneralizedSelfAdjointEigenSolver() : Base() {}
+
+    /** \brief Constructor, pre-allocates memory for dynamic-size matrices.
+      *
+      * \param [in]  size  Positive integer, size of the matrix whose
+      * eigenvalues and eigenvectors will be computed.
+      *
+      * This constructor is useful for dynamic-size matrices, when the user
+      * intends to perform decompositions via compute(). The \p size
+      * parameter is only used as a hint. It is not an error to give a wrong
+      * \p size, but it may impair performance.
+      *
+      * \sa compute() for an example
+      */
+    explicit GeneralizedSelfAdjointEigenSolver(Index size)
+        : Base(size)
+    {}
+
+    /** \brief Constructor; computes generalized eigendecomposition of given matrix pencil.
+      *
+      * \param[in]  matA  Selfadjoint matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  matB  Positive-definite matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options A or-ed set of flags {#ComputeEigenvectors,#EigenvaluesOnly} | {#Ax_lBx,#ABx_lx,#BAx_lx}.
+      *                     Default is #ComputeEigenvectors|#Ax_lBx.
+      *
+      * This constructor calls compute(const MatrixType&, const MatrixType&, int)
+      * to compute the eigenvalues and (if requested) the eigenvectors of the
+      * generalized eigenproblem \f$ Ax = \lambda B x \f$ with \a matA the
+      * selfadjoint matrix \f$ A \f$ and \a matB the positive definite matrix
+      * \f$ B \f$. Each eigenvector \f$ x \f$ satisfies the property
+      * \f$ x^* B x = 1 \f$. The eigenvectors are computed if
+      * \a options contains ComputeEigenvectors.
+      *
+      * In addition, the two following variants can be solved via \p options:
+      * - \c ABx_lx: \f$ ABx = \lambda x \f$
+      * - \c BAx_lx: \f$ BAx = \lambda x \f$
+      *
+      * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.out
+      *
+      * \sa compute(const MatrixType&, const MatrixType&, int)
+      */
+    GeneralizedSelfAdjointEigenSolver(const MatrixType& matA, const MatrixType& matB,
+                                      int options = ComputeEigenvectors|Ax_lBx)
+      : Base(matA.cols())
+    {
+      compute(matA, matB, options);
+    }
+
+    /** \brief Computes generalized eigendecomposition of given matrix pencil.
+      *
+      * \param[in]  matA  Selfadjoint matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  matB  Positive-definite matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options A or-ed set of flags {#ComputeEigenvectors,#EigenvaluesOnly} | {#Ax_lBx,#ABx_lx,#BAx_lx}.
+      *                     Default is #ComputeEigenvectors|#Ax_lBx.
+      *
+      * \returns    Reference to \c *this
+      *
+      * According to \p options, this function computes eigenvalues and (if requested)
+      * the eigenvectors of one of the following three generalized eigenproblems:
+      * - \c Ax_lBx: \f$ Ax = \lambda B x \f$
+      * - \c ABx_lx: \f$ ABx = \lambda x \f$
+      * - \c BAx_lx: \f$ BAx = \lambda x \f$
+      * with \a matA the selfadjoint matrix \f$ A \f$ and \a matB the positive definite
+      * matrix \f$ B \f$.
+      * In addition, each eigenvector \f$ x \f$ satisfies the property \f$ x^* B x = 1 \f$.
+      *
+      * The eigenvalues() function can be used to retrieve
+      * the eigenvalues. If \p options contains ComputeEigenvectors, then the
+      * eigenvectors are also computed and can be retrieved by calling
+      * eigenvectors().
+      *
+      * The implementation uses LLT to compute the Cholesky decomposition
+      * \f$ B = LL^* \f$ and computes the classical eigendecomposition
+      * of the selfadjoint matrix \f$ L^{-1} A (L^*)^{-1} \f$ if \p options contains Ax_lBx
+      * and of \f$ L^{*} A L \f$ otherwise. This solves the
+      * generalized eigenproblem, because any solution of the generalized
+      * eigenproblem \f$ Ax = \lambda B x \f$ corresponds to a solution
+      * \f$ L^{-1} A (L^*)^{-1} (L^* x) = \lambda (L^* x) \f$ of the
+      * eigenproblem for \f$ L^{-1} A (L^*)^{-1} \f$. Similar statements
+      * can be made for the two other variants.
+      *
+      * Example: \include SelfAdjointEigenSolver_compute_MatrixType2.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_compute_MatrixType2.out
+      *
+      * \sa GeneralizedSelfAdjointEigenSolver(const MatrixType&, const MatrixType&, int)
+      */
+    GeneralizedSelfAdjointEigenSolver& compute(const MatrixType& matA, const MatrixType& matB,
+                                               int options = ComputeEigenvectors|Ax_lBx);
+
+  protected:
+
+};
+
+
+template<typename MatrixType>
+GeneralizedSelfAdjointEigenSolver<MatrixType>& GeneralizedSelfAdjointEigenSolver<MatrixType>::
+compute(const MatrixType& matA, const MatrixType& matB, int options)
+{
+  eigen_assert(matA.cols()==matA.rows() && matB.rows()==matA.rows() && matB.cols()==matB.rows());
+  eigen_assert((options&~(EigVecMask|GenEigMask))==0
+          && (options&EigVecMask)!=EigVecMask
+          && ((options&GenEigMask)==0 || (options&GenEigMask)==Ax_lBx
+           || (options&GenEigMask)==ABx_lx || (options&GenEigMask)==BAx_lx)
+          && "invalid option parameter");
+
+  bool computeEigVecs = ((options&EigVecMask)==0) || ((options&EigVecMask)==ComputeEigenvectors);
+
+  // Compute the cholesky decomposition of matB = L L' = U'U
+  LLT<MatrixType> cholB(matB);
+
+  int type = (options&GenEigMask);
+  if(type==0)
+    type = Ax_lBx;
+
+  if(type==Ax_lBx)
+  {
+    // compute C = inv(L) A inv(L')
+    MatrixType matC = matA.template selfadjointView<Lower>();
+    cholB.matrixL().template solveInPlace<OnTheLeft>(matC);
+    cholB.matrixU().template solveInPlace<OnTheRight>(matC);
+
+    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly );
+
+    // transform back the eigen vectors: evecs = inv(U) * evecs
+    if(computeEigVecs)
+      cholB.matrixU().solveInPlace(Base::m_eivec);
+  }
+  else if(type==ABx_lx)
+  {
+    // compute C = L' A L
+    MatrixType matC = matA.template selfadjointView<Lower>();
+    matC = matC * cholB.matrixL();
+    matC = cholB.matrixU() * matC;
+
+    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
+
+    // transform back the eigen vectors: evecs = inv(U) * evecs
+    if(computeEigVecs)
+      cholB.matrixU().solveInPlace(Base::m_eivec);
+  }
+  else if(type==BAx_lx)
+  {
+    // compute C = L' A L
+    MatrixType matC = matA.template selfadjointView<Lower>();
+    matC = matC * cholB.matrixL();
+    matC = cholB.matrixU() * matC;
+
+    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
+
+    // transform back the eigen vectors: evecs = L * evecs
+    if(computeEigVecs)
+      Base::m_eivec = cholB.matrixL() * Base::m_eivec;
+  }
+
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/HessenbergDecomposition.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
new file mode 100644
index 00000000..1f211393
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
@@ -0,0 +1,374 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HESSENBERGDECOMPOSITION_H
+#define EIGEN_HESSENBERGDECOMPOSITION_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<typename MatrixType> struct HessenbergDecompositionMatrixHReturnType;
+template<typename MatrixType>
+struct traits<HessenbergDecompositionMatrixHReturnType<MatrixType> >
+{
+  typedef MatrixType ReturnType;
+};
+
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class HessenbergDecomposition
+  *
+  * \brief Reduces a square matrix to Hessenberg form by an orthogonal similarity transformation
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the Hessenberg decomposition
+  *
+  * This class performs an Hessenberg decomposition of a matrix \f$ A \f$. In
+  * the real case, the Hessenberg decomposition consists of an orthogonal
+  * matrix \f$ Q \f$ and a Hessenberg matrix \f$ H \f$ such that \f$ A = Q H
+  * Q^T \f$. An orthogonal matrix is a matrix whose inverse equals its
+  * transpose (\f$ Q^{-1} = Q^T \f$). A Hessenberg matrix has zeros below the
+  * subdiagonal, so it is almost upper triangular. The Hessenberg decomposition
+  * of a complex matrix is \f$ A = Q H Q^* \f$ with \f$ Q \f$ unitary (that is,
+  * \f$ Q^{-1} = Q^* \f$).
+  *
+  * Call the function compute() to compute the Hessenberg decomposition of a
+  * given matrix. Alternatively, you can use the
+  * HessenbergDecomposition(const MatrixType&) constructor which computes the
+  * Hessenberg decomposition at construction time. Once the decomposition is
+  * computed, you can use the matrixH() and matrixQ() functions to construct
+  * the matrices H and Q in the decomposition.
+  *
+  * The documentation for matrixH() contains an example of the typical use of
+  * this class.
+  *
+  * \sa class ComplexSchur, class Tridiagonalization, \ref QR_Module "QR Module"
+  */
+template<typename _MatrixType> class HessenbergDecomposition
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      Size = MatrixType::RowsAtCompileTime,
+      SizeMinusOne = Size == Dynamic ? Dynamic : Size - 1,
+      Options = MatrixType::Options,
+      MaxSize = MatrixType::MaxRowsAtCompileTime,
+      MaxSizeMinusOne = MaxSize == Dynamic ? Dynamic : MaxSize - 1
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Type for vector of Householder coefficients.
+      *
+      * This is column vector with entries of type #Scalar. The length of the
+      * vector is one less than the size of #MatrixType, if it is a fixed-side
+      * type.
+      */
+    typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType;
+
+    /** \brief Return type of matrixQ() */
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename CoeffVectorType::ConjugateReturnType>::type> HouseholderSequenceType;
+    
+    typedef internal::HessenbergDecompositionMatrixHReturnType<MatrixType> MatrixHReturnType;
+
+    /** \brief Default constructor; the decomposition will be computed later.
+      *
+      * \param [in] size  The size of the matrix whose Hessenberg decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().  The \p size parameter is only
+      * used as a hint. It is not an error to give a wrong \p size, but it may
+      * impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit HessenbergDecomposition(Index size = Size==Dynamic ? 2 : Size)
+      : m_matrix(size,size),
+        m_temp(size),
+        m_isInitialized(false)
+    {
+      if(size>1)
+        m_hCoeffs.resize(size-1);
+    }
+
+    /** \brief Constructor; computes Hessenberg decomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose Hessenberg decomposition is to be computed.
+      *
+      * This constructor calls compute() to compute the Hessenberg
+      * decomposition.
+      *
+      * \sa matrixH() for an example.
+      */
+    template<typename InputType>
+    explicit HessenbergDecomposition(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_temp(matrix.rows()),
+        m_isInitialized(false)
+    {
+      if(matrix.rows()<2)
+      {
+        m_isInitialized = true;
+        return;
+      }
+      m_hCoeffs.resize(matrix.rows()-1,1);
+      _compute(m_matrix, m_hCoeffs, m_temp);
+      m_isInitialized = true;
+    }
+
+    /** \brief Computes Hessenberg decomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose Hessenberg decomposition is to be computed.
+      * \returns    Reference to \c *this
+      *
+      * The Hessenberg decomposition is computed by bringing the columns of the
+      * matrix successively in the required form using Householder reflections
+      * (see, e.g., Algorithm 7.4.2 in Golub \& Van Loan, <i>%Matrix
+      * Computations</i>). The cost is \f$ 10n^3/3 \f$ flops, where \f$ n \f$
+      * denotes the size of the given matrix.
+      *
+      * This method reuses of the allocated data in the HessenbergDecomposition
+      * object.
+      *
+      * Example: \include HessenbergDecomposition_compute.cpp
+      * Output: \verbinclude HessenbergDecomposition_compute.out
+      */
+    template<typename InputType>
+    HessenbergDecomposition& compute(const EigenBase<InputType>& matrix)
+    {
+      m_matrix = matrix.derived();
+      if(matrix.rows()<2)
+      {
+        m_isInitialized = true;
+        return *this;
+      }
+      m_hCoeffs.resize(matrix.rows()-1,1);
+      _compute(m_matrix, m_hCoeffs, m_temp);
+      m_isInitialized = true;
+      return *this;
+    }
+
+    /** \brief Returns the Householder coefficients.
+      *
+      * \returns a const reference to the vector of Householder coefficients
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * The Householder coefficients allow the reconstruction of the matrix
+      * \f$ Q \f$ in the Hessenberg decomposition from the packed data.
+      *
+      * \sa packedMatrix(), \ref Householder_Module "Householder module"
+      */
+    const CoeffVectorType& householderCoefficients() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return m_hCoeffs;
+    }
+
+    /** \brief Returns the internal representation of the decomposition
+      *
+      *	\returns a const reference to a matrix with the internal representation
+      *	         of the decomposition.
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * The returned matrix contains the following information:
+      *  - the upper part and lower sub-diagonal represent the Hessenberg matrix H
+      *  - the rest of the lower part contains the Householder vectors that, combined with
+      *    Householder coefficients returned by householderCoefficients(),
+      *    allows to reconstruct the matrix Q as
+      *       \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
+      *    Here, the matrices \f$ H_i \f$ are the Householder transformations
+      *       \f$ H_i = (I - h_i v_i v_i^T) \f$
+      *    where \f$ h_i \f$ is the \f$ i \f$th Householder coefficient and
+      *    \f$ v_i \f$ is the Householder vector defined by
+      *       \f$ v_i = [ 0, \ldots, 0, 1, M(i+2,i), \ldots, M(N-1,i) ]^T \f$
+      *    with M the matrix returned by this function.
+      *
+      * See LAPACK for further details on this packed storage.
+      *
+      * Example: \include HessenbergDecomposition_packedMatrix.cpp
+      * Output: \verbinclude HessenbergDecomposition_packedMatrix.out
+      *
+      * \sa householderCoefficients()
+      */
+    const MatrixType& packedMatrix() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return m_matrix;
+    }
+
+    /** \brief Reconstructs the orthogonal matrix Q in the decomposition
+      *
+      * \returns object representing the matrix Q
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * This function returns a light-weight object of template class
+      * HouseholderSequence. You can either apply it directly to a matrix or
+      * you can convert it to a matrix of type #MatrixType.
+      *
+      * \sa matrixH() for an example, class HouseholderSequence
+      */
+    HouseholderSequenceType matrixQ() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return HouseholderSequenceType(m_matrix, m_hCoeffs.conjugate())
+             .setLength(m_matrix.rows() - 1)
+             .setShift(1);
+    }
+
+    /** \brief Constructs the Hessenberg matrix H in the decomposition
+      *
+      * \returns expression object representing the matrix H
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * The object returned by this function constructs the Hessenberg matrix H
+      * when it is assigned to a matrix or otherwise evaluated. The matrix H is
+      * constructed from the packed matrix as returned by packedMatrix(): The
+      * upper part (including the subdiagonal) of the packed matrix contains
+      * the matrix H. It may sometimes be better to directly use the packed
+      * matrix instead of constructing the matrix H.
+      *
+      * Example: \include HessenbergDecomposition_matrixH.cpp
+      * Output: \verbinclude HessenbergDecomposition_matrixH.out
+      *
+      * \sa matrixQ(), packedMatrix()
+      */
+    MatrixHReturnType matrixH() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return MatrixHReturnType(*this);
+    }
+
+  private:
+
+    typedef Matrix<Scalar, 1, Size, int(Options) | int(RowMajor), 1, MaxSize> VectorType;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    static void _compute(MatrixType& matA, CoeffVectorType& hCoeffs, VectorType& temp);
+
+  protected:
+    MatrixType m_matrix;
+    CoeffVectorType m_hCoeffs;
+    VectorType m_temp;
+    bool m_isInitialized;
+};
+
+/** \internal
+  * Performs a tridiagonal decomposition of \a matA in place.
+  *
+  * \param matA the input selfadjoint matrix
+  * \param hCoeffs returned Householder coefficients
+  *
+  * The result is written in the lower triangular part of \a matA.
+  *
+  * Implemented from Golub's "%Matrix Computations", algorithm 8.3.1.
+  *
+  * \sa packedMatrix()
+  */
+template<typename MatrixType>
+void HessenbergDecomposition<MatrixType>::_compute(MatrixType& matA, CoeffVectorType& hCoeffs, VectorType& temp)
+{
+  eigen_assert(matA.rows()==matA.cols());
+  Index n = matA.rows();
+  temp.resize(n);
+  for (Index i = 0; i<n-1; ++i)
+  {
+    // let's consider the vector v = i-th column starting at position i+1
+    Index remainingSize = n-i-1;
+    RealScalar beta;
+    Scalar h;
+    matA.col(i).tail(remainingSize).makeHouseholderInPlace(h, beta);
+    matA.col(i).coeffRef(i+1) = beta;
+    hCoeffs.coeffRef(i) = h;
+
+    // Apply similarity transformation to remaining columns,
+    // i.e., compute A = H A H'
+
+    // A = H A
+    matA.bottomRightCorner(remainingSize, remainingSize)
+        .applyHouseholderOnTheLeft(matA.col(i).tail(remainingSize-1), h, &temp.coeffRef(0));
+
+    // A = A H'
+    matA.rightCols(remainingSize)
+        .applyHouseholderOnTheRight(matA.col(i).tail(remainingSize-1), numext::conj(h), &temp.coeffRef(0));
+  }
+}
+
+namespace internal {
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \brief Expression type for return value of HessenbergDecomposition::matrixH()
+  *
+  * \tparam MatrixType type of matrix in the Hessenberg decomposition
+  *
+  * Objects of this type represent the Hessenberg matrix in the Hessenberg
+  * decomposition of some matrix. The object holds a reference to the
+  * HessenbergDecomposition class until the it is assigned or evaluated for
+  * some other reason (the reference should remain valid during the life time
+  * of this object). This class is the return type of
+  * HessenbergDecomposition::matrixH(); there is probably no other use for this
+  * class.
+  */
+template<typename MatrixType> struct HessenbergDecompositionMatrixHReturnType
+: public ReturnByValue<HessenbergDecompositionMatrixHReturnType<MatrixType> >
+{
+  public:
+    /** \brief Constructor.
+      *
+      * \param[in] hess  Hessenberg decomposition
+      */
+    HessenbergDecompositionMatrixHReturnType(const HessenbergDecomposition<MatrixType>& hess) : m_hess(hess) { }
+
+    /** \brief Hessenberg matrix in decomposition.
+      *
+      * \param[out] result  Hessenberg matrix in decomposition \p hess which
+      *                     was passed to the constructor
+      */
+    template <typename ResultType>
+    inline void evalTo(ResultType& result) const
+    {
+      result = m_hess.packedMatrix();
+      Index n = result.rows();
+      if (n>2)
+        result.bottomLeftCorner(n-2, n-2).template triangularView<Lower>().setZero();
+    }
+
+    Index rows() const { return m_hess.packedMatrix().rows(); }
+    Index cols() const { return m_hess.packedMatrix().cols(); }
+
+  protected:
+    const HessenbergDecomposition<MatrixType>& m_hess;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_HESSENBERGDECOMPOSITION_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
new file mode 100644
index 00000000..66e5a3db
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
@@ -0,0 +1,158 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIXBASEEIGENVALUES_H
+#define EIGEN_MATRIXBASEEIGENVALUES_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Derived, bool IsComplex>
+struct eigenvalues_selector
+{
+  // this is the implementation for the case IsComplex = true
+  static inline typename MatrixBase<Derived>::EigenvaluesReturnType const
+  run(const MatrixBase<Derived>& m)
+  {
+    typedef typename Derived::PlainObject PlainObject;
+    PlainObject m_eval(m);
+    return ComplexEigenSolver<PlainObject>(m_eval, false).eigenvalues();
+  }
+};
+
+template<typename Derived>
+struct eigenvalues_selector<Derived, false>
+{
+  static inline typename MatrixBase<Derived>::EigenvaluesReturnType const
+  run(const MatrixBase<Derived>& m)
+  {
+    typedef typename Derived::PlainObject PlainObject;
+    PlainObject m_eval(m);
+    return EigenSolver<PlainObject>(m_eval, false).eigenvalues();
+  }
+};
+
+} // end namespace internal
+
+/** \brief Computes the eigenvalues of a matrix 
+  * \returns Column vector containing the eigenvalues.
+  *
+  * \eigenvalues_module
+  * This function computes the eigenvalues with the help of the EigenSolver
+  * class (for real matrices) or the ComplexEigenSolver class (for complex
+  * matrices). 
+  *
+  * The eigenvalues are repeated according to their algebraic multiplicity,
+  * so there are as many eigenvalues as rows in the matrix.
+  *
+  * The SelfAdjointView class provides a better algorithm for selfadjoint
+  * matrices.
+  *
+  * Example: \include MatrixBase_eigenvalues.cpp
+  * Output: \verbinclude MatrixBase_eigenvalues.out
+  *
+  * \sa EigenSolver::eigenvalues(), ComplexEigenSolver::eigenvalues(),
+  *     SelfAdjointView::eigenvalues()
+  */
+template<typename Derived>
+inline typename MatrixBase<Derived>::EigenvaluesReturnType
+MatrixBase<Derived>::eigenvalues() const
+{
+  return internal::eigenvalues_selector<Derived, NumTraits<Scalar>::IsComplex>::run(derived());
+}
+
+/** \brief Computes the eigenvalues of a matrix
+  * \returns Column vector containing the eigenvalues.
+  *
+  * \eigenvalues_module
+  * This function computes the eigenvalues with the help of the
+  * SelfAdjointEigenSolver class.  The eigenvalues are repeated according to
+  * their algebraic multiplicity, so there are as many eigenvalues as rows in
+  * the matrix.
+  *
+  * Example: \include SelfAdjointView_eigenvalues.cpp
+  * Output: \verbinclude SelfAdjointView_eigenvalues.out
+  *
+  * \sa SelfAdjointEigenSolver::eigenvalues(), MatrixBase::eigenvalues()
+  */
+template<typename MatrixType, unsigned int UpLo> 
+EIGEN_DEVICE_FUNC inline typename SelfAdjointView<MatrixType, UpLo>::EigenvaluesReturnType
+SelfAdjointView<MatrixType, UpLo>::eigenvalues() const
+{
+  PlainObject thisAsMatrix(*this);
+  return SelfAdjointEigenSolver<PlainObject>(thisAsMatrix, false).eigenvalues();
+}
+
+
+
+/** \brief Computes the L2 operator norm
+  * \returns Operator norm of the matrix.
+  *
+  * \eigenvalues_module
+  * This function computes the L2 operator norm of a matrix, which is also
+  * known as the spectral norm. The norm of a matrix \f$ A \f$ is defined to be
+  * \f[ \|A\|_2 = \max_x \frac{\|Ax\|_2}{\|x\|_2} \f]
+  * where the maximum is over all vectors and the norm on the right is the
+  * Euclidean vector norm. The norm equals the largest singular value, which is
+  * the square root of the largest eigenvalue of the positive semi-definite
+  * matrix \f$ A^*A \f$.
+  *
+  * The current implementation uses the eigenvalues of \f$ A^*A \f$, as computed
+  * by SelfAdjointView::eigenvalues(), to compute the operator norm of a
+  * matrix.  The SelfAdjointView class provides a better algorithm for
+  * selfadjoint matrices.
+  *
+  * Example: \include MatrixBase_operatorNorm.cpp
+  * Output: \verbinclude MatrixBase_operatorNorm.out
+  *
+  * \sa SelfAdjointView::eigenvalues(), SelfAdjointView::operatorNorm()
+  */
+template<typename Derived>
+inline typename MatrixBase<Derived>::RealScalar
+MatrixBase<Derived>::operatorNorm() const
+{
+  using std::sqrt;
+  typename Derived::PlainObject m_eval(derived());
+  // FIXME if it is really guaranteed that the eigenvalues are already sorted,
+  // then we don't need to compute a maxCoeff() here, comparing the 1st and last ones is enough.
+  return sqrt((m_eval*m_eval.adjoint())
+                 .eval()
+		 .template selfadjointView<Lower>()
+		 .eigenvalues()
+		 .maxCoeff()
+		 );
+}
+
+/** \brief Computes the L2 operator norm
+  * \returns Operator norm of the matrix.
+  *
+  * \eigenvalues_module
+  * This function computes the L2 operator norm of a self-adjoint matrix. For a
+  * self-adjoint matrix, the operator norm is the largest eigenvalue.
+  *
+  * The current implementation uses the eigenvalues of the matrix, as computed
+  * by eigenvalues(), to compute the operator norm of the matrix.
+  *
+  * Example: \include SelfAdjointView_operatorNorm.cpp
+  * Output: \verbinclude SelfAdjointView_operatorNorm.out
+  *
+  * \sa eigenvalues(), MatrixBase::operatorNorm()
+  */
+template<typename MatrixType, unsigned int UpLo>
+EIGEN_DEVICE_FUNC inline typename SelfAdjointView<MatrixType, UpLo>::RealScalar
+SelfAdjointView<MatrixType, UpLo>::operatorNorm() const
+{
+  return eigenvalues().cwiseAbs().maxCoeff();
+}
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/RealQZ.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/RealQZ.h
new file mode 100644
index 00000000..50913018
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/RealQZ.h
@@ -0,0 +1,657 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Alexey Korepanov <kaikaikai@yandex.ru>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REAL_QZ_H
+#define EIGEN_REAL_QZ_H
+
+namespace Eigen {
+
+  /** \eigenvalues_module \ingroup Eigenvalues_Module
+   *
+   *
+   * \class RealQZ
+   *
+   * \brief Performs a real QZ decomposition of a pair of square matrices
+   *
+   * \tparam _MatrixType the type of the matrix of which we are computing the
+   * real QZ decomposition; this is expected to be an instantiation of the
+   * Matrix class template.
+   *
+   * Given a real square matrices A and B, this class computes the real QZ
+   * decomposition: \f$ A = Q S Z \f$, \f$ B = Q T Z \f$ where Q and Z are
+   * real orthogonal matrixes, T is upper-triangular matrix, and S is upper
+   * quasi-triangular matrix. An orthogonal matrix is a matrix whose
+   * inverse is equal to its transpose, \f$ U^{-1} = U^T \f$. A quasi-triangular
+   * matrix is a block-triangular matrix whose diagonal consists of 1-by-1
+   * blocks and 2-by-2 blocks where further reduction is impossible due to
+   * complex eigenvalues. 
+   *
+   * The eigenvalues of the pencil \f$ A - z B \f$ can be obtained from
+   * 1x1 and 2x2 blocks on the diagonals of S and T.
+   *
+   * Call the function compute() to compute the real QZ decomposition of a
+   * given pair of matrices. Alternatively, you can use the 
+   * RealQZ(const MatrixType& B, const MatrixType& B, bool computeQZ)
+   * constructor which computes the real QZ decomposition at construction
+   * time. Once the decomposition is computed, you can use the matrixS(),
+   * matrixT(), matrixQ() and matrixZ() functions to retrieve the matrices
+   * S, T, Q and Z in the decomposition. If computeQZ==false, some time
+   * is saved by not computing matrices Q and Z.
+   *
+   * Example: \include RealQZ_compute.cpp
+   * Output: \include RealQZ_compute.out
+   *
+   * \note The implementation is based on the algorithm in "Matrix Computations"
+   * by Gene H. Golub and Charles F. Van Loan, and a paper "An algorithm for
+   * generalized eigenvalue problems" by C.B.Moler and G.W.Stewart.
+   *
+   * \sa class RealSchur, class ComplexSchur, class EigenSolver, class ComplexEigenSolver
+   */
+
+  template<typename _MatrixType> class RealQZ
+  {
+    public:
+      typedef _MatrixType MatrixType;
+      enum {
+        RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+        ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+        Options = MatrixType::Options,
+        MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+        MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+      };
+      typedef typename MatrixType::Scalar Scalar;
+      typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
+      typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+      typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
+      typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+
+      /** \brief Default constructor.
+       *
+       * \param [in] size  Positive integer, size of the matrix whose QZ decomposition will be computed.
+       *
+       * The default constructor is useful in cases in which the user intends to
+       * perform decompositions via compute().  The \p size parameter is only
+       * used as a hint. It is not an error to give a wrong \p size, but it may
+       * impair performance.
+       *
+       * \sa compute() for an example.
+       */
+      explicit RealQZ(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime) :
+        m_S(size, size),
+        m_T(size, size),
+        m_Q(size, size),
+        m_Z(size, size),
+        m_workspace(size*2),
+        m_maxIters(400),
+        m_isInitialized(false),
+        m_computeQZ(true)
+      {}
+
+      /** \brief Constructor; computes real QZ decomposition of given matrices
+       * 
+       * \param[in]  A          Matrix A.
+       * \param[in]  B          Matrix B.
+       * \param[in]  computeQZ  If false, A and Z are not computed.
+       *
+       * This constructor calls compute() to compute the QZ decomposition.
+       */
+      RealQZ(const MatrixType& A, const MatrixType& B, bool computeQZ = true) :
+        m_S(A.rows(),A.cols()),
+        m_T(A.rows(),A.cols()),
+        m_Q(A.rows(),A.cols()),
+        m_Z(A.rows(),A.cols()),
+        m_workspace(A.rows()*2),
+        m_maxIters(400),
+        m_isInitialized(false),
+        m_computeQZ(true)
+      {
+        compute(A, B, computeQZ);
+      }
+
+      /** \brief Returns matrix Q in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix Q.
+       */
+      const MatrixType& matrixQ() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
+        return m_Q;
+      }
+
+      /** \brief Returns matrix Z in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix Z.
+       */
+      const MatrixType& matrixZ() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
+        return m_Z;
+      }
+
+      /** \brief Returns matrix S in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix S.
+       */
+      const MatrixType& matrixS() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_S;
+      }
+
+      /** \brief Returns matrix S in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix S.
+       */
+      const MatrixType& matrixT() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_T;
+      }
+
+      /** \brief Computes QZ decomposition of given matrix. 
+       * 
+       * \param[in]  A          Matrix A.
+       * \param[in]  B          Matrix B.
+       * \param[in]  computeQZ  If false, A and Z are not computed.
+       * \returns    Reference to \c *this
+       */
+      RealQZ& compute(const MatrixType& A, const MatrixType& B, bool computeQZ = true);
+
+      /** \brief Reports whether previous computation was successful.
+       *
+       * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+       */
+      ComputationInfo info() const
+      {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_info;
+      }
+
+      /** \brief Returns number of performed QR-like iterations.
+      */
+      Index iterations() const
+      {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_global_iter;
+      }
+
+      /** Sets the maximal number of iterations allowed to converge to one eigenvalue
+       * or decouple the problem.
+      */
+      RealQZ& setMaxIterations(Index maxIters)
+      {
+        m_maxIters = maxIters;
+        return *this;
+      }
+
+    private:
+
+      MatrixType m_S, m_T, m_Q, m_Z;
+      Matrix<Scalar,Dynamic,1> m_workspace;
+      ComputationInfo m_info;
+      Index m_maxIters;
+      bool m_isInitialized;
+      bool m_computeQZ;
+      Scalar m_normOfT, m_normOfS;
+      Index m_global_iter;
+
+      typedef Matrix<Scalar,3,1> Vector3s;
+      typedef Matrix<Scalar,2,1> Vector2s;
+      typedef Matrix<Scalar,2,2> Matrix2s;
+      typedef JacobiRotation<Scalar> JRs;
+
+      void hessenbergTriangular();
+      void computeNorms();
+      Index findSmallSubdiagEntry(Index iu);
+      Index findSmallDiagEntry(Index f, Index l);
+      void splitOffTwoRows(Index i);
+      void pushDownZero(Index z, Index f, Index l);
+      void step(Index f, Index l, Index iter);
+
+  }; // RealQZ
+
+  /** \internal Reduces S and T to upper Hessenberg - triangular form */
+  template<typename MatrixType>
+    void RealQZ<MatrixType>::hessenbergTriangular()
+    {
+
+      const Index dim = m_S.cols();
+
+      // perform QR decomposition of T, overwrite T with R, save Q
+      HouseholderQR<MatrixType> qrT(m_T);
+      m_T = qrT.matrixQR();
+      m_T.template triangularView<StrictlyLower>().setZero();
+      m_Q = qrT.householderQ();
+      // overwrite S with Q* S
+      m_S.applyOnTheLeft(m_Q.adjoint());
+      // init Z as Identity
+      if (m_computeQZ)
+        m_Z = MatrixType::Identity(dim,dim);
+      // reduce S to upper Hessenberg with Givens rotations
+      for (Index j=0; j<=dim-3; j++) {
+        for (Index i=dim-1; i>=j+2; i--) {
+          JRs G;
+          // kill S(i,j)
+          if(m_S.coeff(i,j) != 0)
+          {
+            G.makeGivens(m_S.coeff(i-1,j), m_S.coeff(i,j), &m_S.coeffRef(i-1, j));
+            m_S.coeffRef(i,j) = Scalar(0.0);
+            m_S.rightCols(dim-j-1).applyOnTheLeft(i-1,i,G.adjoint());
+            m_T.rightCols(dim-i+1).applyOnTheLeft(i-1,i,G.adjoint());
+            // update Q
+            if (m_computeQZ)
+              m_Q.applyOnTheRight(i-1,i,G);
+          }
+          // kill T(i,i-1)
+          if(m_T.coeff(i,i-1)!=Scalar(0))
+          {
+            G.makeGivens(m_T.coeff(i,i), m_T.coeff(i,i-1), &m_T.coeffRef(i,i));
+            m_T.coeffRef(i,i-1) = Scalar(0.0);
+            m_S.applyOnTheRight(i,i-1,G);
+            m_T.topRows(i).applyOnTheRight(i,i-1,G);
+            // update Z
+            if (m_computeQZ)
+              m_Z.applyOnTheLeft(i,i-1,G.adjoint());
+          }
+        }
+      }
+    }
+
+  /** \internal Computes vector L1 norms of S and T when in Hessenberg-Triangular form already */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::computeNorms()
+    {
+      const Index size = m_S.cols();
+      m_normOfS = Scalar(0.0);
+      m_normOfT = Scalar(0.0);
+      for (Index j = 0; j < size; ++j)
+      {
+        m_normOfS += m_S.col(j).segment(0, (std::min)(size,j+2)).cwiseAbs().sum();
+        m_normOfT += m_T.row(j).segment(j, size - j).cwiseAbs().sum();
+      }
+    }
+
+
+  /** \internal Look for single small sub-diagonal element S(res, res-1) and return res (or 0) */
+  template<typename MatrixType>
+    inline Index RealQZ<MatrixType>::findSmallSubdiagEntry(Index iu)
+    {
+      using std::abs;
+      Index res = iu;
+      while (res > 0)
+      {
+        Scalar s = abs(m_S.coeff(res-1,res-1)) + abs(m_S.coeff(res,res));
+        if (s == Scalar(0.0))
+          s = m_normOfS;
+        if (abs(m_S.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s)
+          break;
+        res--;
+      }
+      return res;
+    }
+
+  /** \internal Look for single small diagonal element T(res, res) for res between f and l, and return res (or f-1)  */
+  template<typename MatrixType>
+    inline Index RealQZ<MatrixType>::findSmallDiagEntry(Index f, Index l)
+    {
+      using std::abs;
+      Index res = l;
+      while (res >= f) {
+        if (abs(m_T.coeff(res,res)) <= NumTraits<Scalar>::epsilon() * m_normOfT)
+          break;
+        res--;
+      }
+      return res;
+    }
+
+  /** \internal decouple 2x2 diagonal block in rows i, i+1 if eigenvalues are real */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::splitOffTwoRows(Index i)
+    {
+      using std::abs;
+      using std::sqrt;
+      const Index dim=m_S.cols();
+      if (abs(m_S.coeff(i+1,i))==Scalar(0))
+        return;
+      Index j = findSmallDiagEntry(i,i+1);
+      if (j==i-1)
+      {
+        // block of (S T^{-1})
+        Matrix2s STi = m_T.template block<2,2>(i,i).template triangularView<Upper>().
+          template solve<OnTheRight>(m_S.template block<2,2>(i,i));
+        Scalar p = Scalar(0.5)*(STi(0,0)-STi(1,1));
+        Scalar q = p*p + STi(1,0)*STi(0,1);
+        if (q>=0) {
+          Scalar z = sqrt(q);
+          // one QR-like iteration for ABi - lambda I
+          // is enough - when we know exact eigenvalue in advance,
+          // convergence is immediate
+          JRs G;
+          if (p>=0)
+            G.makeGivens(p + z, STi(1,0));
+          else
+            G.makeGivens(p - z, STi(1,0));
+          m_S.rightCols(dim-i).applyOnTheLeft(i,i+1,G.adjoint());
+          m_T.rightCols(dim-i).applyOnTheLeft(i,i+1,G.adjoint());
+          // update Q
+          if (m_computeQZ)
+            m_Q.applyOnTheRight(i,i+1,G);
+
+          G.makeGivens(m_T.coeff(i+1,i+1), m_T.coeff(i+1,i));
+          m_S.topRows(i+2).applyOnTheRight(i+1,i,G);
+          m_T.topRows(i+2).applyOnTheRight(i+1,i,G);
+          // update Z
+          if (m_computeQZ)
+            m_Z.applyOnTheLeft(i+1,i,G.adjoint());
+
+          m_S.coeffRef(i+1,i) = Scalar(0.0);
+          m_T.coeffRef(i+1,i) = Scalar(0.0);
+        }
+      }
+      else
+      {
+        pushDownZero(j,i,i+1);
+      }
+    }
+
+  /** \internal use zero in T(z,z) to zero S(l,l-1), working in block f..l */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::pushDownZero(Index z, Index f, Index l)
+    {
+      JRs G;
+      const Index dim = m_S.cols();
+      for (Index zz=z; zz<l; zz++)
+      {
+        // push 0 down
+        Index firstColS = zz>f ? (zz-1) : zz;
+        G.makeGivens(m_T.coeff(zz, zz+1), m_T.coeff(zz+1, zz+1));
+        m_S.rightCols(dim-firstColS).applyOnTheLeft(zz,zz+1,G.adjoint());
+        m_T.rightCols(dim-zz).applyOnTheLeft(zz,zz+1,G.adjoint());
+        m_T.coeffRef(zz+1,zz+1) = Scalar(0.0);
+        // update Q
+        if (m_computeQZ)
+          m_Q.applyOnTheRight(zz,zz+1,G);
+        // kill S(zz+1, zz-1)
+        if (zz>f)
+        {
+          G.makeGivens(m_S.coeff(zz+1, zz), m_S.coeff(zz+1,zz-1));
+          m_S.topRows(zz+2).applyOnTheRight(zz, zz-1,G);
+          m_T.topRows(zz+1).applyOnTheRight(zz, zz-1,G);
+          m_S.coeffRef(zz+1,zz-1) = Scalar(0.0);
+          // update Z
+          if (m_computeQZ)
+            m_Z.applyOnTheLeft(zz,zz-1,G.adjoint());
+        }
+      }
+      // finally kill S(l,l-1)
+      G.makeGivens(m_S.coeff(l,l), m_S.coeff(l,l-1));
+      m_S.applyOnTheRight(l,l-1,G);
+      m_T.applyOnTheRight(l,l-1,G);
+      m_S.coeffRef(l,l-1)=Scalar(0.0);
+      // update Z
+      if (m_computeQZ)
+        m_Z.applyOnTheLeft(l,l-1,G.adjoint());
+    }
+
+  /** \internal QR-like iterative step for block f..l */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::step(Index f, Index l, Index iter)
+    {
+      using std::abs;
+      const Index dim = m_S.cols();
+
+      // x, y, z
+      Scalar x, y, z;
+      if (iter==10)
+      {
+        // Wilkinson ad hoc shift
+        const Scalar
+          a11=m_S.coeff(f+0,f+0), a12=m_S.coeff(f+0,f+1),
+          a21=m_S.coeff(f+1,f+0), a22=m_S.coeff(f+1,f+1), a32=m_S.coeff(f+2,f+1),
+          b12=m_T.coeff(f+0,f+1),
+          b11i=Scalar(1.0)/m_T.coeff(f+0,f+0),
+          b22i=Scalar(1.0)/m_T.coeff(f+1,f+1),
+          a87=m_S.coeff(l-1,l-2),
+          a98=m_S.coeff(l-0,l-1),
+          b77i=Scalar(1.0)/m_T.coeff(l-2,l-2),
+          b88i=Scalar(1.0)/m_T.coeff(l-1,l-1);
+        Scalar ss = abs(a87*b77i) + abs(a98*b88i),
+               lpl = Scalar(1.5)*ss,
+               ll = ss*ss;
+        x = ll + a11*a11*b11i*b11i - lpl*a11*b11i + a12*a21*b11i*b22i
+          - a11*a21*b12*b11i*b11i*b22i;
+        y = a11*a21*b11i*b11i - lpl*a21*b11i + a21*a22*b11i*b22i 
+          - a21*a21*b12*b11i*b11i*b22i;
+        z = a21*a32*b11i*b22i;
+      }
+      else if (iter==16)
+      {
+        // another exceptional shift
+        x = m_S.coeff(f,f)/m_T.coeff(f,f)-m_S.coeff(l,l)/m_T.coeff(l,l) + m_S.coeff(l,l-1)*m_T.coeff(l-1,l) /
+          (m_T.coeff(l-1,l-1)*m_T.coeff(l,l));
+        y = m_S.coeff(f+1,f)/m_T.coeff(f,f);
+        z = 0;
+      }
+      else if (iter>23 && !(iter%8))
+      {
+        // extremely exceptional shift
+        x = internal::random<Scalar>(-1.0,1.0);
+        y = internal::random<Scalar>(-1.0,1.0);
+        z = internal::random<Scalar>(-1.0,1.0);
+      }
+      else
+      {
+        // Compute the shifts: (x,y,z,0...) = (AB^-1 - l1 I) (AB^-1 - l2 I) e1
+        // where l1 and l2 are the eigenvalues of the 2x2 matrix C = U V^-1 where
+        // U and V are 2x2 bottom right sub matrices of A and B. Thus:
+        //  = AB^-1AB^-1 + l1 l2 I - (l1+l2)(AB^-1)
+        //  = AB^-1AB^-1 + det(M) - tr(M)(AB^-1)
+        // Since we are only interested in having x, y, z with a correct ratio, we have:
+        const Scalar
+          a11 = m_S.coeff(f,f),     a12 = m_S.coeff(f,f+1),
+          a21 = m_S.coeff(f+1,f),   a22 = m_S.coeff(f+1,f+1),
+                                    a32 = m_S.coeff(f+2,f+1),
+
+          a88 = m_S.coeff(l-1,l-1), a89 = m_S.coeff(l-1,l),
+          a98 = m_S.coeff(l,l-1),   a99 = m_S.coeff(l,l),
+
+          b11 = m_T.coeff(f,f),     b12 = m_T.coeff(f,f+1),
+                                    b22 = m_T.coeff(f+1,f+1),
+
+          b88 = m_T.coeff(l-1,l-1), b89 = m_T.coeff(l-1,l),
+                                    b99 = m_T.coeff(l,l);
+
+        x = ( (a88/b88 - a11/b11)*(a99/b99 - a11/b11) - (a89/b99)*(a98/b88) + (a98/b88)*(b89/b99)*(a11/b11) ) * (b11/a21)
+          + a12/b22 - (a11/b11)*(b12/b22);
+        y = (a22/b22-a11/b11) - (a21/b11)*(b12/b22) - (a88/b88-a11/b11) - (a99/b99-a11/b11) + (a98/b88)*(b89/b99);
+        z = a32/b22;
+      }
+
+      JRs G;
+
+      for (Index k=f; k<=l-2; k++)
+      {
+        // variables for Householder reflections
+        Vector2s essential2;
+        Scalar tau, beta;
+
+        Vector3s hr(x,y,z);
+
+        // Q_k to annihilate S(k+1,k-1) and S(k+2,k-1)
+        hr.makeHouseholderInPlace(tau, beta);
+        essential2 = hr.template bottomRows<2>();
+        Index fc=(std::max)(k-1,Index(0));  // first col to update
+        m_S.template middleRows<3>(k).rightCols(dim-fc).applyHouseholderOnTheLeft(essential2, tau, m_workspace.data());
+        m_T.template middleRows<3>(k).rightCols(dim-fc).applyHouseholderOnTheLeft(essential2, tau, m_workspace.data());
+        if (m_computeQZ)
+          m_Q.template middleCols<3>(k).applyHouseholderOnTheRight(essential2, tau, m_workspace.data());
+        if (k>f)
+          m_S.coeffRef(k+2,k-1) = m_S.coeffRef(k+1,k-1) = Scalar(0.0);
+
+        // Z_{k1} to annihilate T(k+2,k+1) and T(k+2,k)
+        hr << m_T.coeff(k+2,k+2),m_T.coeff(k+2,k),m_T.coeff(k+2,k+1);
+        hr.makeHouseholderInPlace(tau, beta);
+        essential2 = hr.template bottomRows<2>();
+        {
+          Index lr = (std::min)(k+4,dim); // last row to update
+          Map<Matrix<Scalar,Dynamic,1> > tmp(m_workspace.data(),lr);
+          // S
+          tmp = m_S.template middleCols<2>(k).topRows(lr) * essential2;
+          tmp += m_S.col(k+2).head(lr);
+          m_S.col(k+2).head(lr) -= tau*tmp;
+          m_S.template middleCols<2>(k).topRows(lr) -= (tau*tmp) * essential2.adjoint();
+          // T
+          tmp = m_T.template middleCols<2>(k).topRows(lr) * essential2;
+          tmp += m_T.col(k+2).head(lr);
+          m_T.col(k+2).head(lr) -= tau*tmp;
+          m_T.template middleCols<2>(k).topRows(lr) -= (tau*tmp) * essential2.adjoint();
+        }
+        if (m_computeQZ)
+        {
+          // Z
+          Map<Matrix<Scalar,1,Dynamic> > tmp(m_workspace.data(),dim);
+          tmp = essential2.adjoint()*(m_Z.template middleRows<2>(k));
+          tmp += m_Z.row(k+2);
+          m_Z.row(k+2) -= tau*tmp;
+          m_Z.template middleRows<2>(k) -= essential2 * (tau*tmp);
+        }
+        m_T.coeffRef(k+2,k) = m_T.coeffRef(k+2,k+1) = Scalar(0.0);
+
+        // Z_{k2} to annihilate T(k+1,k)
+        G.makeGivens(m_T.coeff(k+1,k+1), m_T.coeff(k+1,k));
+        m_S.applyOnTheRight(k+1,k,G);
+        m_T.applyOnTheRight(k+1,k,G);
+        // update Z
+        if (m_computeQZ)
+          m_Z.applyOnTheLeft(k+1,k,G.adjoint());
+        m_T.coeffRef(k+1,k) = Scalar(0.0);
+
+        // update x,y,z
+        x = m_S.coeff(k+1,k);
+        y = m_S.coeff(k+2,k);
+        if (k < l-2)
+          z = m_S.coeff(k+3,k);
+      } // loop over k
+
+      // Q_{n-1} to annihilate y = S(l,l-2)
+      G.makeGivens(x,y);
+      m_S.applyOnTheLeft(l-1,l,G.adjoint());
+      m_T.applyOnTheLeft(l-1,l,G.adjoint());
+      if (m_computeQZ)
+        m_Q.applyOnTheRight(l-1,l,G);
+      m_S.coeffRef(l,l-2) = Scalar(0.0);
+
+      // Z_{n-1} to annihilate T(l,l-1)
+      G.makeGivens(m_T.coeff(l,l),m_T.coeff(l,l-1));
+      m_S.applyOnTheRight(l,l-1,G);
+      m_T.applyOnTheRight(l,l-1,G);
+      if (m_computeQZ)
+        m_Z.applyOnTheLeft(l,l-1,G.adjoint());
+      m_T.coeffRef(l,l-1) = Scalar(0.0);
+    }
+
+  template<typename MatrixType>
+    RealQZ<MatrixType>& RealQZ<MatrixType>::compute(const MatrixType& A_in, const MatrixType& B_in, bool computeQZ)
+    {
+
+      const Index dim = A_in.cols();
+
+      eigen_assert (A_in.rows()==dim && A_in.cols()==dim 
+          && B_in.rows()==dim && B_in.cols()==dim 
+          && "Need square matrices of the same dimension");
+
+      m_isInitialized = true;
+      m_computeQZ = computeQZ;
+      m_S = A_in; m_T = B_in;
+      m_workspace.resize(dim*2);
+      m_global_iter = 0;
+
+      // entrance point: hessenberg triangular decomposition
+      hessenbergTriangular();
+      // compute L1 vector norms of T, S into m_normOfS, m_normOfT
+      computeNorms();
+
+      Index l = dim-1, 
+            f, 
+            local_iter = 0;
+
+      while (l>0 && local_iter<m_maxIters)
+      {
+        f = findSmallSubdiagEntry(l);
+        // now rows and columns f..l (including) decouple from the rest of the problem
+        if (f>0) m_S.coeffRef(f,f-1) = Scalar(0.0);
+        if (f == l) // One root found
+        {
+          l--;
+          local_iter = 0;
+        }
+        else if (f == l-1) // Two roots found
+        {
+          splitOffTwoRows(f);
+          l -= 2;
+          local_iter = 0;
+        }
+        else // No convergence yet
+        {
+          // if there's zero on diagonal of T, we can isolate an eigenvalue with Givens rotations
+          Index z = findSmallDiagEntry(f,l);
+          if (z>=f)
+          {
+            // zero found
+            pushDownZero(z,f,l);
+          }
+          else
+          {
+            // We are sure now that S.block(f,f, l-f+1,l-f+1) is underuced upper-Hessenberg 
+            // and T.block(f,f, l-f+1,l-f+1) is invertible uper-triangular, which allows to
+            // apply a QR-like iteration to rows and columns f..l.
+            step(f,l, local_iter);
+            local_iter++;
+            m_global_iter++;
+          }
+        }
+      }
+      // check if we converged before reaching iterations limit
+      m_info = (local_iter<m_maxIters) ? Success : NoConvergence;
+
+      // For each non triangular 2x2 diagonal block of S,
+      //    reduce the respective 2x2 diagonal block of T to positive diagonal form using 2x2 SVD.
+      // This step is not mandatory for QZ, but it does help further extraction of eigenvalues/eigenvectors,
+      // and is in par with Lapack/Matlab QZ.
+      if(m_info==Success)
+      {
+        for(Index i=0; i<dim-1; ++i)
+        {
+          if(m_S.coeff(i+1, i) != Scalar(0))
+          {
+            JacobiRotation<Scalar> j_left, j_right;
+            internal::real_2x2_jacobi_svd(m_T, i, i+1, &j_left, &j_right);
+
+            // Apply resulting Jacobi rotations
+            m_S.applyOnTheLeft(i,i+1,j_left);
+            m_S.applyOnTheRight(i,i+1,j_right);
+            m_T.applyOnTheLeft(i,i+1,j_left);
+            m_T.applyOnTheRight(i,i+1,j_right);
+            m_T(i+1,i) = m_T(i,i+1) = Scalar(0);
+
+            if(m_computeQZ) {
+              m_Q.applyOnTheRight(i,i+1,j_left.transpose());
+              m_Z.applyOnTheLeft(i,i+1,j_right.transpose());
+            }
+
+            i++;
+          }
+        }
+      }
+
+      return *this;
+    } // end compute
+
+} // end namespace Eigen
+
+#endif //EIGEN_REAL_QZ
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/RealSchur.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/RealSchur.h
new file mode 100644
index 00000000..7304ef34
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/RealSchur.h
@@ -0,0 +1,558 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REAL_SCHUR_H
+#define EIGEN_REAL_SCHUR_H
+
+#include "./HessenbergDecomposition.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class RealSchur
+  *
+  * \brief Performs a real Schur decomposition of a square matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * real Schur decomposition; this is expected to be an instantiation of the
+  * Matrix class template.
+  *
+  * Given a real square matrix A, this class computes the real Schur
+  * decomposition: \f$ A = U T U^T \f$ where U is a real orthogonal matrix and
+  * T is a real quasi-triangular matrix. An orthogonal matrix is a matrix whose
+  * inverse is equal to its transpose, \f$ U^{-1} = U^T \f$. A quasi-triangular
+  * matrix is a block-triangular matrix whose diagonal consists of 1-by-1
+  * blocks and 2-by-2 blocks with complex eigenvalues. The eigenvalues of the
+  * blocks on the diagonal of T are the same as the eigenvalues of the matrix
+  * A, and thus the real Schur decomposition is used in EigenSolver to compute
+  * the eigendecomposition of a matrix.
+  *
+  * Call the function compute() to compute the real Schur decomposition of a
+  * given matrix. Alternatively, you can use the RealSchur(const MatrixType&, bool)
+  * constructor which computes the real Schur decomposition at construction
+  * time. Once the decomposition is computed, you can use the matrixU() and
+  * matrixT() functions to retrieve the matrices U and T in the decomposition.
+  *
+  * The documentation of RealSchur(const MatrixType&, bool) contains an example
+  * of the typical use of this class.
+  *
+  * \note The implementation is adapted from
+  * <a href="http://math.nist.gov/javanumerics/jama/">JAMA</a> (public domain).
+  * Their code is based on EISPACK.
+  *
+  * \sa class ComplexSchur, class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType> class RealSchur
+{
+  public:
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
+    typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+
+    /** \brief Default constructor.
+      *
+      * \param [in] size  Positive integer, size of the matrix whose Schur decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().  The \p size parameter is only
+      * used as a hint. It is not an error to give a wrong \p size, but it may
+      * impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit RealSchur(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime)
+            : m_matT(size, size),
+              m_matU(size, size),
+              m_workspaceVector(size),
+              m_hess(size),
+              m_isInitialized(false),
+              m_matUisUptodate(false),
+              m_maxIters(-1)
+    { }
+
+    /** \brief Constructor; computes real Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix    Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+      *
+      * This constructor calls compute() to compute the Schur decomposition.
+      *
+      * Example: \include RealSchur_RealSchur_MatrixType.cpp
+      * Output: \verbinclude RealSchur_RealSchur_MatrixType.out
+      */
+    template<typename InputType>
+    explicit RealSchur(const EigenBase<InputType>& matrix, bool computeU = true)
+            : m_matT(matrix.rows(),matrix.cols()),
+              m_matU(matrix.rows(),matrix.cols()),
+              m_workspaceVector(matrix.rows()),
+              m_hess(matrix.rows()),
+              m_isInitialized(false),
+              m_matUisUptodate(false),
+              m_maxIters(-1)
+    {
+      compute(matrix.derived(), computeU);
+    }
+
+    /** \brief Returns the orthogonal matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix U.
+      *
+      * \pre Either the constructor RealSchur(const MatrixType&, bool) or the
+      * member function compute(const MatrixType&, bool) has been called before
+      * to compute the Schur decomposition of a matrix, and \p computeU was set
+      * to true (the default value).
+      *
+      * \sa RealSchur(const MatrixType&, bool) for an example
+      */
+    const MatrixType& matrixU() const
+    {
+      eigen_assert(m_isInitialized && "RealSchur is not initialized.");
+      eigen_assert(m_matUisUptodate && "The matrix U has not been computed during the RealSchur decomposition.");
+      return m_matU;
+    }
+
+    /** \brief Returns the quasi-triangular matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix T.
+      *
+      * \pre Either the constructor RealSchur(const MatrixType&, bool) or the
+      * member function compute(const MatrixType&, bool) has been called before
+      * to compute the Schur decomposition of a matrix.
+      *
+      * \sa RealSchur(const MatrixType&, bool) for an example
+      */
+    const MatrixType& matrixT() const
+    {
+      eigen_assert(m_isInitialized && "RealSchur is not initialized.");
+      return m_matT;
+    }
+  
+    /** \brief Computes Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix    Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+      * \returns    Reference to \c *this
+      *
+      * The Schur decomposition is computed by first reducing the matrix to
+      * Hessenberg form using the class HessenbergDecomposition. The Hessenberg
+      * matrix is then reduced to triangular form by performing Francis QR
+      * iterations with implicit double shift. The cost of computing the Schur
+      * decomposition depends on the number of iterations; as a rough guide, it
+      * may be taken to be \f$25n^3\f$ flops if \a computeU is true and
+      * \f$10n^3\f$ flops if \a computeU is false.
+      *
+      * Example: \include RealSchur_compute.cpp
+      * Output: \verbinclude RealSchur_compute.out
+      *
+      * \sa compute(const MatrixType&, bool, Index)
+      */
+    template<typename InputType>
+    RealSchur& compute(const EigenBase<InputType>& matrix, bool computeU = true);
+
+    /** \brief Computes Schur decomposition of a Hessenberg matrix H = Z T Z^T
+     *  \param[in] matrixH Matrix in Hessenberg form H
+     *  \param[in] matrixQ orthogonal matrix Q that transform a matrix A to H : A = Q H Q^T
+     *  \param computeU Computes the matriX U of the Schur vectors
+     * \return Reference to \c *this
+     * 
+     *  This routine assumes that the matrix is already reduced in Hessenberg form matrixH
+     *  using either the class HessenbergDecomposition or another mean. 
+     *  It computes the upper quasi-triangular matrix T of the Schur decomposition of H
+     *  When computeU is true, this routine computes the matrix U such that 
+     *  A = U T U^T =  (QZ) T (QZ)^T = Q H Q^T where A is the initial matrix
+     * 
+     * NOTE Q is referenced if computeU is true; so, if the initial orthogonal matrix
+     * is not available, the user should give an identity matrix (Q.setIdentity())
+     * 
+     * \sa compute(const MatrixType&, bool)
+     */
+    template<typename HessMatrixType, typename OrthMatrixType>
+    RealSchur& computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ,  bool computeU);
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "RealSchur is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. 
+      *
+      * If not specified by the user, the maximum number of iterations is m_maxIterationsPerRow times the size
+      * of the matrix.
+      */
+    RealSchur& setMaxIterations(Index maxIters)
+    {
+      m_maxIters = maxIters;
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_maxIters;
+    }
+
+    /** \brief Maximum number of iterations per row.
+      *
+      * If not otherwise specified, the maximum number of iterations is this number times the size of the
+      * matrix. It is currently set to 40.
+      */
+    static const int m_maxIterationsPerRow = 40;
+
+  private:
+    
+    MatrixType m_matT;
+    MatrixType m_matU;
+    ColumnVectorType m_workspaceVector;
+    HessenbergDecomposition<MatrixType> m_hess;
+    ComputationInfo m_info;
+    bool m_isInitialized;
+    bool m_matUisUptodate;
+    Index m_maxIters;
+
+    typedef Matrix<Scalar,3,1> Vector3s;
+
+    Scalar computeNormOfT();
+    Index findSmallSubdiagEntry(Index iu, const Scalar& considerAsZero);
+    void splitOffTwoRows(Index iu, bool computeU, const Scalar& exshift);
+    void computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo);
+    void initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im, Vector3s& firstHouseholderVector);
+    void performFrancisQRStep(Index il, Index im, Index iu, bool computeU, const Vector3s& firstHouseholderVector, Scalar* workspace);
+};
+
+
+template<typename MatrixType>
+template<typename InputType>
+RealSchur<MatrixType>& RealSchur<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeU)
+{
+  const Scalar considerAsZero = (std::numeric_limits<Scalar>::min)();
+
+  eigen_assert(matrix.cols() == matrix.rows());
+  Index maxIters = m_maxIters;
+  if (maxIters == -1)
+    maxIters = m_maxIterationsPerRow * matrix.rows();
+
+  Scalar scale = matrix.derived().cwiseAbs().maxCoeff();
+  if(scale<considerAsZero)
+  {
+    m_matT.setZero(matrix.rows(),matrix.cols());
+    if(computeU)
+      m_matU.setIdentity(matrix.rows(),matrix.cols());
+    m_info = Success;
+    m_isInitialized = true;
+    m_matUisUptodate = computeU;
+    return *this;
+  }
+
+  // Step 1. Reduce to Hessenberg form
+  m_hess.compute(matrix.derived()/scale);
+
+  // Step 2. Reduce to real Schur form
+  // Note: we copy m_hess.matrixQ() into m_matU here and not in computeFromHessenberg
+  //       to be able to pass our working-space buffer for the Householder to Dense evaluation.
+  m_workspaceVector.resize(matrix.cols());
+  if(computeU)
+    m_hess.matrixQ().evalTo(m_matU, m_workspaceVector);
+  computeFromHessenberg(m_hess.matrixH(), m_matU, computeU);
+
+  m_matT *= scale;
+  
+  return *this;
+}
+template<typename MatrixType>
+template<typename HessMatrixType, typename OrthMatrixType>
+RealSchur<MatrixType>& RealSchur<MatrixType>::computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ,  bool computeU)
+{
+  using std::abs;
+
+  m_matT = matrixH;
+  m_workspaceVector.resize(m_matT.cols());
+  if(computeU && !internal::is_same_dense(m_matU,matrixQ))
+    m_matU = matrixQ;
+  
+  Index maxIters = m_maxIters;
+  if (maxIters == -1)
+    maxIters = m_maxIterationsPerRow * matrixH.rows();
+  Scalar* workspace = &m_workspaceVector.coeffRef(0);
+
+  // The matrix m_matT is divided in three parts. 
+  // Rows 0,...,il-1 are decoupled from the rest because m_matT(il,il-1) is zero. 
+  // Rows il,...,iu is the part we are working on (the active window).
+  // Rows iu+1,...,end are already brought in triangular form.
+  Index iu = m_matT.cols() - 1;
+  Index iter = 0;      // iteration count for current eigenvalue
+  Index totalIter = 0; // iteration count for whole matrix
+  Scalar exshift(0);   // sum of exceptional shifts
+  Scalar norm = computeNormOfT();
+  // sub-diagonal entries smaller than considerAsZero will be treated as zero.
+  // We use eps^2 to enable more precision in small eigenvalues.
+  Scalar considerAsZero = numext::maxi<Scalar>( norm * numext::abs2(NumTraits<Scalar>::epsilon()),
+                                                (std::numeric_limits<Scalar>::min)() );
+
+  if(norm!=Scalar(0))
+  {
+    while (iu >= 0)
+    {
+      Index il = findSmallSubdiagEntry(iu,considerAsZero);
+
+      // Check for convergence
+      if (il == iu) // One root found
+      {
+        m_matT.coeffRef(iu,iu) = m_matT.coeff(iu,iu) + exshift;
+        if (iu > 0)
+          m_matT.coeffRef(iu, iu-1) = Scalar(0);
+        iu--;
+        iter = 0;
+      }
+      else if (il == iu-1) // Two roots found
+      {
+        splitOffTwoRows(iu, computeU, exshift);
+        iu -= 2;
+        iter = 0;
+      }
+      else // No convergence yet
+      {
+        // The firstHouseholderVector vector has to be initialized to something to get rid of a silly GCC warning (-O1 -Wall -DNDEBUG )
+        Vector3s firstHouseholderVector = Vector3s::Zero(), shiftInfo;
+        computeShift(iu, iter, exshift, shiftInfo);
+        iter = iter + 1;
+        totalIter = totalIter + 1;
+        if (totalIter > maxIters) break;
+        Index im;
+        initFrancisQRStep(il, iu, shiftInfo, im, firstHouseholderVector);
+        performFrancisQRStep(il, im, iu, computeU, firstHouseholderVector, workspace);
+      }
+    }
+  }
+  if(totalIter <= maxIters)
+    m_info = Success;
+  else
+    m_info = NoConvergence;
+
+  m_isInitialized = true;
+  m_matUisUptodate = computeU;
+  return *this;
+}
+
+/** \internal Computes and returns vector L1 norm of T */
+template<typename MatrixType>
+inline typename MatrixType::Scalar RealSchur<MatrixType>::computeNormOfT()
+{
+  const Index size = m_matT.cols();
+  // FIXME to be efficient the following would requires a triangular reduxion code
+  // Scalar norm = m_matT.upper().cwiseAbs().sum() 
+  //               + m_matT.bottomLeftCorner(size-1,size-1).diagonal().cwiseAbs().sum();
+  Scalar norm(0);
+  for (Index j = 0; j < size; ++j)
+    norm += m_matT.col(j).segment(0, (std::min)(size,j+2)).cwiseAbs().sum();
+  return norm;
+}
+
+/** \internal Look for single small sub-diagonal element and returns its index */
+template<typename MatrixType>
+inline Index RealSchur<MatrixType>::findSmallSubdiagEntry(Index iu, const Scalar& considerAsZero)
+{
+  using std::abs;
+  Index res = iu;
+  while (res > 0)
+  {
+    Scalar s = abs(m_matT.coeff(res-1,res-1)) + abs(m_matT.coeff(res,res));
+
+    s = numext::maxi<Scalar>(s * NumTraits<Scalar>::epsilon(), considerAsZero);
+    
+    if (abs(m_matT.coeff(res,res-1)) <= s)
+      break;
+    res--;
+  }
+  return res;
+}
+
+/** \internal Update T given that rows iu-1 and iu decouple from the rest. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::splitOffTwoRows(Index iu, bool computeU, const Scalar& exshift)
+{
+  using std::sqrt;
+  using std::abs;
+  const Index size = m_matT.cols();
+
+  // The eigenvalues of the 2x2 matrix [a b; c d] are 
+  // trace +/- sqrt(discr/4) where discr = tr^2 - 4*det, tr = a + d, det = ad - bc
+  Scalar p = Scalar(0.5) * (m_matT.coeff(iu-1,iu-1) - m_matT.coeff(iu,iu));
+  Scalar q = p * p + m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu);   // q = tr^2 / 4 - det = discr/4
+  m_matT.coeffRef(iu,iu) += exshift;
+  m_matT.coeffRef(iu-1,iu-1) += exshift;
+
+  if (q >= Scalar(0)) // Two real eigenvalues
+  {
+    Scalar z = sqrt(abs(q));
+    JacobiRotation<Scalar> rot;
+    if (p >= Scalar(0))
+      rot.makeGivens(p + z, m_matT.coeff(iu, iu-1));
+    else
+      rot.makeGivens(p - z, m_matT.coeff(iu, iu-1));
+
+    m_matT.rightCols(size-iu+1).applyOnTheLeft(iu-1, iu, rot.adjoint());
+    m_matT.topRows(iu+1).applyOnTheRight(iu-1, iu, rot);
+    m_matT.coeffRef(iu, iu-1) = Scalar(0); 
+    if (computeU)
+      m_matU.applyOnTheRight(iu-1, iu, rot);
+  }
+
+  if (iu > 1) 
+    m_matT.coeffRef(iu-1, iu-2) = Scalar(0);
+}
+
+/** \internal Form shift in shiftInfo, and update exshift if an exceptional shift is performed. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo)
+{
+  using std::sqrt;
+  using std::abs;
+  shiftInfo.coeffRef(0) = m_matT.coeff(iu,iu);
+  shiftInfo.coeffRef(1) = m_matT.coeff(iu-1,iu-1);
+  shiftInfo.coeffRef(2) = m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu);
+
+  // Wilkinson's original ad hoc shift
+  if (iter == 10)
+  {
+    exshift += shiftInfo.coeff(0);
+    for (Index i = 0; i <= iu; ++i)
+      m_matT.coeffRef(i,i) -= shiftInfo.coeff(0);
+    Scalar s = abs(m_matT.coeff(iu,iu-1)) + abs(m_matT.coeff(iu-1,iu-2));
+    shiftInfo.coeffRef(0) = Scalar(0.75) * s;
+    shiftInfo.coeffRef(1) = Scalar(0.75) * s;
+    shiftInfo.coeffRef(2) = Scalar(-0.4375) * s * s;
+  }
+
+  // MATLAB's new ad hoc shift
+  if (iter == 30)
+  {
+    Scalar s = (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
+    s = s * s + shiftInfo.coeff(2);
+    if (s > Scalar(0))
+    {
+      s = sqrt(s);
+      if (shiftInfo.coeff(1) < shiftInfo.coeff(0))
+        s = -s;
+      s = s + (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
+      s = shiftInfo.coeff(0) - shiftInfo.coeff(2) / s;
+      exshift += s;
+      for (Index i = 0; i <= iu; ++i)
+        m_matT.coeffRef(i,i) -= s;
+      shiftInfo.setConstant(Scalar(0.964));
+    }
+  }
+}
+
+/** \internal Compute index im at which Francis QR step starts and the first Householder vector. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im, Vector3s& firstHouseholderVector)
+{
+  using std::abs;
+  Vector3s& v = firstHouseholderVector; // alias to save typing
+
+  for (im = iu-2; im >= il; --im)
+  {
+    const Scalar Tmm = m_matT.coeff(im,im);
+    const Scalar r = shiftInfo.coeff(0) - Tmm;
+    const Scalar s = shiftInfo.coeff(1) - Tmm;
+    v.coeffRef(0) = (r * s - shiftInfo.coeff(2)) / m_matT.coeff(im+1,im) + m_matT.coeff(im,im+1);
+    v.coeffRef(1) = m_matT.coeff(im+1,im+1) - Tmm - r - s;
+    v.coeffRef(2) = m_matT.coeff(im+2,im+1);
+    if (im == il) {
+      break;
+    }
+    const Scalar lhs = m_matT.coeff(im,im-1) * (abs(v.coeff(1)) + abs(v.coeff(2)));
+    const Scalar rhs = v.coeff(0) * (abs(m_matT.coeff(im-1,im-1)) + abs(Tmm) + abs(m_matT.coeff(im+1,im+1)));
+    if (abs(lhs) < NumTraits<Scalar>::epsilon() * rhs)
+      break;
+  }
+}
+
+/** \internal Perform a Francis QR step involving rows il:iu and columns im:iu. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::performFrancisQRStep(Index il, Index im, Index iu, bool computeU, const Vector3s& firstHouseholderVector, Scalar* workspace)
+{
+  eigen_assert(im >= il);
+  eigen_assert(im <= iu-2);
+
+  const Index size = m_matT.cols();
+
+  for (Index k = im; k <= iu-2; ++k)
+  {
+    bool firstIteration = (k == im);
+
+    Vector3s v;
+    if (firstIteration)
+      v = firstHouseholderVector;
+    else
+      v = m_matT.template block<3,1>(k,k-1);
+
+    Scalar tau, beta;
+    Matrix<Scalar, 2, 1> ess;
+    v.makeHouseholder(ess, tau, beta);
+    
+    if (beta != Scalar(0)) // if v is not zero
+    {
+      if (firstIteration && k > il)
+        m_matT.coeffRef(k,k-1) = -m_matT.coeff(k,k-1);
+      else if (!firstIteration)
+        m_matT.coeffRef(k,k-1) = beta;
+
+      // These Householder transformations form the O(n^3) part of the algorithm
+      m_matT.block(k, k, 3, size-k).applyHouseholderOnTheLeft(ess, tau, workspace);
+      m_matT.block(0, k, (std::min)(iu,k+3) + 1, 3).applyHouseholderOnTheRight(ess, tau, workspace);
+      if (computeU)
+        m_matU.block(0, k, size, 3).applyHouseholderOnTheRight(ess, tau, workspace);
+    }
+  }
+
+  Matrix<Scalar, 2, 1> v = m_matT.template block<2,1>(iu-1, iu-2);
+  Scalar tau, beta;
+  Matrix<Scalar, 1, 1> ess;
+  v.makeHouseholder(ess, tau, beta);
+
+  if (beta != Scalar(0)) // if v is not zero
+  {
+    m_matT.coeffRef(iu-1, iu-2) = beta;
+    m_matT.block(iu-1, iu-1, 2, size-iu+1).applyHouseholderOnTheLeft(ess, tau, workspace);
+    m_matT.block(0, iu-1, iu+1, 2).applyHouseholderOnTheRight(ess, tau, workspace);
+    if (computeU)
+      m_matU.block(0, iu-1, size, 2).applyHouseholderOnTheRight(ess, tau, workspace);
+  }
+
+  // clean up pollution due to round-off errors
+  for (Index i = im+2; i <= iu; ++i)
+  {
+    m_matT.coeffRef(i,i-2) = Scalar(0);
+    if (i > im+2)
+      m_matT.coeffRef(i,i-3) = Scalar(0);
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REAL_SCHUR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
new file mode 100644
index 00000000..2c225171
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
@@ -0,0 +1,77 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Real Schur needed to real unsymmetrical eigenvalues/eigenvectors.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_REAL_SCHUR_LAPACKE_H
+#define EIGEN_REAL_SCHUR_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_SCHUR_REAL(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX, LAPACKE_PREFIX_U, EIGCOLROW, LAPACKE_COLROW) \
+template<> template<typename InputType> inline \
+RealSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >& \
+RealSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >::compute(const EigenBase<InputType>& matrix, bool computeU) \
+{ \
+  eigen_assert(matrix.cols() == matrix.rows()); \
+\
+  lapack_int n = internal::convert_index<lapack_int>(matrix.cols()), sdim, info; \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  char jobvs, sort='N'; \
+  LAPACK_##LAPACKE_PREFIX_U##_SELECT2 select = 0; \
+  jobvs = (computeU) ? 'V' : 'N'; \
+  m_matU.resize(n, n); \
+  lapack_int ldvs  = internal::convert_index<lapack_int>(m_matU.outerStride()); \
+  m_matT = matrix; \
+  lapack_int lda = internal::convert_index<lapack_int>(m_matT.outerStride()); \
+  Matrix<EIGTYPE, Dynamic, Dynamic> wr, wi; \
+  wr.resize(n, 1); wi.resize(n, 1); \
+  info = LAPACKE_##LAPACKE_PREFIX##gees( matrix_order, jobvs, sort, select, n, (LAPACKE_TYPE*)m_matT.data(), lda, &sdim, (LAPACKE_TYPE*)wr.data(), (LAPACKE_TYPE*)wi.data(), (LAPACKE_TYPE*)m_matU.data(), ldvs ); \
+  if(info == 0) \
+    m_info = Success; \
+  else \
+    m_info = NoConvergence; \
+\
+  m_isInitialized = true; \
+  m_matUisUptodate = computeU; \
+  return *this; \
+\
+}
+
+EIGEN_LAPACKE_SCHUR_REAL(double,   double, d, D, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_REAL(float,    float,  s, S, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_REAL(double,   double, d, D, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SCHUR_REAL(float,    float,  s, S, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_REAL_SCHUR_LAPACKE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
new file mode 100644
index 00000000..14692365
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
@@ -0,0 +1,904 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINTEIGENSOLVER_H
+#define EIGEN_SELFADJOINTEIGENSOLVER_H
+
+#include "./Tridiagonalization.h"
+
+namespace Eigen { 
+
+template<typename _MatrixType>
+class GeneralizedSelfAdjointEigenSolver;
+
+namespace internal {
+template<typename SolverType,int Size,bool IsComplex> struct direct_selfadjoint_eigenvalues;
+
+template<typename MatrixType, typename DiagType, typename SubDiagType>
+EIGEN_DEVICE_FUNC
+ComputationInfo computeFromTridiagonal_impl(DiagType& diag, SubDiagType& subdiag, const Index maxIterations, bool computeEigenvectors, MatrixType& eivec);
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class SelfAdjointEigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of selfadjoint matrices
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * eigendecomposition; this is expected to be an instantiation of the Matrix
+  * class template.
+  *
+  * A matrix \f$ A \f$ is selfadjoint if it equals its adjoint. For real
+  * matrices, this means that the matrix is symmetric: it equals its
+  * transpose. This class computes the eigenvalues and eigenvectors of a
+  * selfadjoint matrix. These are the scalars \f$ \lambda \f$ and vectors
+  * \f$ v \f$ such that \f$ Av = \lambda v \f$.  The eigenvalues of a
+  * selfadjoint matrix are always real. If \f$ D \f$ is a diagonal matrix with
+  * the eigenvalues on the diagonal, and \f$ V \f$ is a matrix with the
+  * eigenvectors as its columns, then \f$ A = V D V^{-1} \f$. This is called the
+  * eigendecomposition.
+  *
+  * For a selfadjoint matrix, \f$ V \f$ is unitary, meaning its inverse is equal
+  * to its adjoint, \f$ V^{-1} = V^{\dagger} \f$. If \f$ A \f$ is real, then
+  * \f$ V \f$ is also real and therefore orthogonal, meaning its inverse is
+  * equal to its transpose, \f$ V^{-1} = V^T \f$.
+  *
+  * The algorithm exploits the fact that the matrix is selfadjoint, making it
+  * faster and more accurate than the general purpose eigenvalue algorithms
+  * implemented in EigenSolver and ComplexEigenSolver.
+  *
+  * Only the \b lower \b triangular \b part of the input matrix is referenced.
+  *
+  * Call the function compute() to compute the eigenvalues and eigenvectors of
+  * a given matrix. Alternatively, you can use the
+  * SelfAdjointEigenSolver(const MatrixType&, int) constructor which computes
+  * the eigenvalues and eigenvectors at construction time. Once the eigenvalue
+  * and eigenvectors are computed, they can be retrieved with the eigenvalues()
+  * and eigenvectors() functions.
+  *
+  * The documentation for SelfAdjointEigenSolver(const MatrixType&, int)
+  * contains an example of the typical use of this class.
+  *
+  * To solve the \em generalized eigenvalue problem \f$ Av = \lambda Bv \f$ and
+  * the likes, see the class GeneralizedSelfAdjointEigenSolver.
+  *
+  * \sa MatrixBase::eigenvalues(), class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType> class SelfAdjointEigenSolver
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    enum {
+      Size = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+    /** \brief Scalar type for matrices of type \p _MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    
+    typedef Matrix<Scalar,Size,Size,ColMajor,MaxColsAtCompileTime,MaxColsAtCompileTime> EigenvectorsType;
+
+    /** \brief Real scalar type for \p _MatrixType.
+      *
+      * This is just \c Scalar if #Scalar is real (e.g., \c float or
+      * \c double), and the type of the real part of \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    
+    friend struct internal::direct_selfadjoint_eigenvalues<SelfAdjointEigenSolver,Size,NumTraits<Scalar>::IsComplex>;
+
+    /** \brief Type for vector of eigenvalues as returned by eigenvalues().
+      *
+      * This is a column vector with entries of type #RealScalar.
+      * The length of the vector is the size of \p _MatrixType.
+      */
+    typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVectorType;
+    typedef Tridiagonalization<MatrixType> TridiagonalizationType;
+    typedef typename TridiagonalizationType::SubDiagonalType SubDiagonalType;
+
+    /** \brief Default constructor for fixed-size matrices.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute(). This constructor
+      * can only be used if \p _MatrixType is a fixed-size matrix; use
+      * SelfAdjointEigenSolver(Index) for dynamic-size matrices.
+      *
+      * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver.out
+      */
+    EIGEN_DEVICE_FUNC
+    SelfAdjointEigenSolver()
+        : m_eivec(),
+          m_eivalues(),
+          m_subdiag(),
+          m_hcoeffs(),
+          m_info(InvalidInput),
+          m_isInitialized(false),
+          m_eigenvectorsOk(false)
+    { }
+
+    /** \brief Constructor, pre-allocates memory for dynamic-size matrices.
+      *
+      * \param [in]  size  Positive integer, size of the matrix whose
+      * eigenvalues and eigenvectors will be computed.
+      *
+      * This constructor is useful for dynamic-size matrices, when the user
+      * intends to perform decompositions via compute(). The \p size
+      * parameter is only used as a hint. It is not an error to give a wrong
+      * \p size, but it may impair performance.
+      *
+      * \sa compute() for an example
+      */
+    EIGEN_DEVICE_FUNC
+    explicit SelfAdjointEigenSolver(Index size)
+        : m_eivec(size, size),
+          m_eivalues(size),
+          m_subdiag(size > 1 ? size - 1 : 1),
+          m_hcoeffs(size > 1 ? size - 1 : 1),
+          m_isInitialized(false),
+          m_eigenvectorsOk(false)
+    {}
+
+    /** \brief Constructor; computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose eigendecomposition is to
+      *    be computed. Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+      *
+      * This constructor calls compute(const MatrixType&, int) to compute the
+      * eigenvalues of the matrix \p matrix. The eigenvectors are computed if
+      * \p options equals #ComputeEigenvectors.
+      *
+      * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.out
+      *
+      * \sa compute(const MatrixType&, int)
+      */
+    template<typename InputType>
+    EIGEN_DEVICE_FUNC
+    explicit SelfAdjointEigenSolver(const EigenBase<InputType>& matrix, int options = ComputeEigenvectors)
+      : m_eivec(matrix.rows(), matrix.cols()),
+        m_eivalues(matrix.cols()),
+        m_subdiag(matrix.rows() > 1 ? matrix.rows() - 1 : 1),
+        m_hcoeffs(matrix.cols() > 1 ? matrix.cols() - 1 : 1),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false)
+    {
+      compute(matrix.derived(), options);
+    }
+
+    /** \brief Computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose eigendecomposition is to
+      *    be computed. Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of \p matrix.  The eigenvalues()
+      * function can be used to retrieve them.  If \p options equals #ComputeEigenvectors,
+      * then the eigenvectors are also computed and can be retrieved by
+      * calling eigenvectors().
+      *
+      * This implementation uses a symmetric QR algorithm. The matrix is first
+      * reduced to tridiagonal form using the Tridiagonalization class. The
+      * tridiagonal matrix is then brought to diagonal form with implicit
+      * symmetric QR steps with Wilkinson shift. Details can be found in
+      * Section 8.3 of Golub \& Van Loan, <i>%Matrix Computations</i>.
+      *
+      * The cost of the computation is about \f$ 9n^3 \f$ if the eigenvectors
+      * are required and \f$ 4n^3/3 \f$ if they are not required.
+      *
+      * This method reuses the memory in the SelfAdjointEigenSolver object that
+      * was allocated when the object was constructed, if the size of the
+      * matrix does not change.
+      *
+      * Example: \include SelfAdjointEigenSolver_compute_MatrixType.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_compute_MatrixType.out
+      *
+      * \sa SelfAdjointEigenSolver(const MatrixType&, int)
+      */
+    template<typename InputType>
+    EIGEN_DEVICE_FUNC
+    SelfAdjointEigenSolver& compute(const EigenBase<InputType>& matrix, int options = ComputeEigenvectors);
+    
+    /** \brief Computes eigendecomposition of given matrix using a closed-form algorithm
+      *
+      * This is a variant of compute(const MatrixType&, int options) which
+      * directly solves the underlying polynomial equation.
+      * 
+      * Currently only 2x2 and 3x3 matrices for which the sizes are known at compile time are supported (e.g., Matrix3d).
+      * 
+      * This method is usually significantly faster than the QR iterative algorithm
+      * but it might also be less accurate. It is also worth noting that
+      * for 3x3 matrices it involves trigonometric operations which are
+      * not necessarily available for all scalar types.
+      * 
+      * For the 3x3 case, we observed the following worst case relative error regarding the eigenvalues:
+      *   - double: 1e-8
+      *   - float:  1e-3
+      *
+      * \sa compute(const MatrixType&, int options)
+      */
+    EIGEN_DEVICE_FUNC
+    SelfAdjointEigenSolver& computeDirect(const MatrixType& matrix, int options = ComputeEigenvectors);
+
+    /**
+      *\brief Computes the eigen decomposition from a tridiagonal symmetric matrix
+      *
+      * \param[in] diag The vector containing the diagonal of the matrix.
+      * \param[in] subdiag The subdiagonal of the matrix.
+      * \param[in] options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+      * \returns Reference to \c *this
+      *
+      * This function assumes that the matrix has been reduced to tridiagonal form.
+      *
+      * \sa compute(const MatrixType&, int) for more information
+      */
+    SelfAdjointEigenSolver& computeFromTridiagonal(const RealVectorType& diag, const SubDiagonalType& subdiag , int options=ComputeEigenvectors);
+
+    /** \brief Returns the eigenvectors of given matrix.
+      *
+      * \returns  A const reference to the matrix whose columns are the eigenvectors.
+      *
+      * \pre The eigenvectors have been computed before.
+      *
+      * Column \f$ k \f$ of the returned matrix is an eigenvector corresponding
+      * to eigenvalue number \f$ k \f$ as returned by eigenvalues().  The
+      * eigenvectors are normalized to have (Euclidean) norm equal to one. If
+      * this object was used to solve the eigenproblem for the selfadjoint
+      * matrix \f$ A \f$, then the matrix returned by this function is the
+      * matrix \f$ V \f$ in the eigendecomposition \f$ A = V D V^{-1} \f$.
+      *
+      * For a selfadjoint matrix, \f$ V \f$ is unitary, meaning its inverse is equal
+      * to its adjoint, \f$ V^{-1} = V^{\dagger} \f$. If \f$ A \f$ is real, then
+      * \f$ V \f$ is also real and therefore orthogonal, meaning its inverse is
+      * equal to its transpose, \f$ V^{-1} = V^T \f$.
+      *
+      * Example: \include SelfAdjointEigenSolver_eigenvectors.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_eigenvectors.out
+      *
+      * \sa eigenvalues()
+      */
+    EIGEN_DEVICE_FUNC
+    const EigenvectorsType& eigenvectors() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec;
+    }
+
+    /** \brief Returns the eigenvalues of given matrix.
+      *
+      * \returns A const reference to the column vector containing the eigenvalues.
+      *
+      * \pre The eigenvalues have been computed before.
+      *
+      * The eigenvalues are repeated according to their algebraic multiplicity,
+      * so there are as many eigenvalues as rows in the matrix. The eigenvalues
+      * are sorted in increasing order.
+      *
+      * Example: \include SelfAdjointEigenSolver_eigenvalues.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_eigenvalues.out
+      *
+      * \sa eigenvectors(), MatrixBase::eigenvalues()
+      */
+    EIGEN_DEVICE_FUNC
+    const RealVectorType& eigenvalues() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      return m_eivalues;
+    }
+
+    /** \brief Computes the positive-definite square root of the matrix.
+      *
+      * \returns the positive-definite square root of the matrix
+      *
+      * \pre The eigenvalues and eigenvectors of a positive-definite matrix
+      * have been computed before.
+      *
+      * The square root of a positive-definite matrix \f$ A \f$ is the
+      * positive-definite matrix whose square equals \f$ A \f$. This function
+      * uses the eigendecomposition \f$ A = V D V^{-1} \f$ to compute the
+      * square root as \f$ A^{1/2} = V D^{1/2} V^{-1} \f$.
+      *
+      * Example: \include SelfAdjointEigenSolver_operatorSqrt.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_operatorSqrt.out
+      *
+      * \sa operatorInverseSqrt(), <a href="unsupported/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
+      */
+    EIGEN_DEVICE_FUNC
+    MatrixType operatorSqrt() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec * m_eivalues.cwiseSqrt().asDiagonal() * m_eivec.adjoint();
+    }
+
+    /** \brief Computes the inverse square root of the matrix.
+      *
+      * \returns the inverse positive-definite square root of the matrix
+      *
+      * \pre The eigenvalues and eigenvectors of a positive-definite matrix
+      * have been computed before.
+      *
+      * This function uses the eigendecomposition \f$ A = V D V^{-1} \f$ to
+      * compute the inverse square root as \f$ V D^{-1/2} V^{-1} \f$. This is
+      * cheaper than first computing the square root with operatorSqrt() and
+      * then its inverse with MatrixBase::inverse().
+      *
+      * Example: \include SelfAdjointEigenSolver_operatorInverseSqrt.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_operatorInverseSqrt.out
+      *
+      * \sa operatorSqrt(), MatrixBase::inverse(), <a href="unsupported/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
+      */
+    EIGEN_DEVICE_FUNC
+    MatrixType operatorInverseSqrt() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec * m_eivalues.cwiseInverse().cwiseSqrt().asDiagonal() * m_eivec.adjoint();
+    }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+      */
+    EIGEN_DEVICE_FUNC
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Maximum number of iterations.
+      *
+      * The algorithm terminates if it does not converge within m_maxIterations * n iterations, where n
+      * denotes the size of the matrix. This value is currently set to 30 (copied from LAPACK).
+      */
+    static const int m_maxIterations = 30;
+
+  protected:
+    static EIGEN_DEVICE_FUNC
+    void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+    
+    EigenvectorsType m_eivec;
+    RealVectorType m_eivalues;
+    typename TridiagonalizationType::SubDiagonalType m_subdiag;
+    typename TridiagonalizationType::CoeffVectorType m_hcoeffs;
+    ComputationInfo m_info;
+    bool m_isInitialized;
+    bool m_eigenvectorsOk;
+};
+
+namespace internal {
+/** \internal
+  *
+  * \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  * Performs a QR step on a tridiagonal symmetric matrix represented as a
+  * pair of two vectors \a diag and \a subdiag.
+  *
+  * \param diag the diagonal part of the input selfadjoint tridiagonal matrix
+  * \param subdiag the sub-diagonal part of the input selfadjoint tridiagonal matrix
+  * \param start starting index of the submatrix to work on
+  * \param end last+1 index of the submatrix to work on
+  * \param matrixQ pointer to the column-major matrix holding the eigenvectors, can be 0
+  * \param n size of the input matrix
+  *
+  * For compilation efficiency reasons, this procedure does not use eigen expression
+  * for its arguments.
+  *
+  * Implemented from Golub's "Matrix Computations", algorithm 8.3.2:
+  * "implicit symmetric QR step with Wilkinson shift"
+  */
+template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC
+static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n);
+}
+
+template<typename MatrixType>
+template<typename InputType>
+EIGEN_DEVICE_FUNC
+SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
+::compute(const EigenBase<InputType>& a_matrix, int options)
+{
+  check_template_parameters();
+  
+  const InputType &matrix(a_matrix.derived());
+  
+  EIGEN_USING_STD(abs);
+  eigen_assert(matrix.cols() == matrix.rows());
+  eigen_assert((options&~(EigVecMask|GenEigMask))==0
+          && (options&EigVecMask)!=EigVecMask
+          && "invalid option parameter");
+  bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+  Index n = matrix.cols();
+  m_eivalues.resize(n,1);
+
+  if(n==1)
+  {
+    m_eivec = matrix;
+    m_eivalues.coeffRef(0,0) = numext::real(m_eivec.coeff(0,0));
+    if(computeEigenvectors)
+      m_eivec.setOnes(n,n);
+    m_info = Success;
+    m_isInitialized = true;
+    m_eigenvectorsOk = computeEigenvectors;
+    return *this;
+  }
+
+  // declare some aliases
+  RealVectorType& diag = m_eivalues;
+  EigenvectorsType& mat = m_eivec;
+
+  // map the matrix coefficients to [-1:1] to avoid over- and underflow.
+  mat = matrix.template triangularView<Lower>();
+  RealScalar scale = mat.cwiseAbs().maxCoeff();
+  if(scale==RealScalar(0)) scale = RealScalar(1);
+  mat.template triangularView<Lower>() /= scale;
+  m_subdiag.resize(n-1);
+  m_hcoeffs.resize(n-1);
+  internal::tridiagonalization_inplace(mat, diag, m_subdiag, m_hcoeffs, computeEigenvectors);
+
+  m_info = internal::computeFromTridiagonal_impl(diag, m_subdiag, m_maxIterations, computeEigenvectors, m_eivec);
+  
+  // scale back the eigen values
+  m_eivalues *= scale;
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+  return *this;
+}
+
+template<typename MatrixType>
+SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
+::computeFromTridiagonal(const RealVectorType& diag, const SubDiagonalType& subdiag , int options)
+{
+  //TODO : Add an option to scale the values beforehand
+  bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+
+  m_eivalues = diag;
+  m_subdiag = subdiag;
+  if (computeEigenvectors)
+  {
+    m_eivec.setIdentity(diag.size(), diag.size());
+  }
+  m_info = internal::computeFromTridiagonal_impl(m_eivalues, m_subdiag, m_maxIterations, computeEigenvectors, m_eivec);
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+  return *this;
+}
+
+namespace internal {
+/**
+  * \internal
+  * \brief Compute the eigendecomposition from a tridiagonal matrix
+  *
+  * \param[in,out] diag : On input, the diagonal of the matrix, on output the eigenvalues
+  * \param[in,out] subdiag : The subdiagonal part of the matrix (entries are modified during the decomposition)
+  * \param[in] maxIterations : the maximum number of iterations
+  * \param[in] computeEigenvectors : whether the eigenvectors have to be computed or not
+  * \param[out] eivec : The matrix to store the eigenvectors if computeEigenvectors==true. Must be allocated on input.
+  * \returns \c Success or \c NoConvergence
+  */
+template<typename MatrixType, typename DiagType, typename SubDiagType>
+EIGEN_DEVICE_FUNC
+ComputationInfo computeFromTridiagonal_impl(DiagType& diag, SubDiagType& subdiag, const Index maxIterations, bool computeEigenvectors, MatrixType& eivec)
+{
+  ComputationInfo info;
+  typedef typename MatrixType::Scalar Scalar;
+
+  Index n = diag.size();
+  Index end = n-1;
+  Index start = 0;
+  Index iter = 0; // total number of iterations
+  
+  typedef typename DiagType::RealScalar RealScalar;
+  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar precision_inv = RealScalar(1)/NumTraits<RealScalar>::epsilon();
+  while (end>0)
+  {
+    for (Index i = start; i<end; ++i) {
+      if (numext::abs(subdiag[i]) < considerAsZero) {
+        subdiag[i] = RealScalar(0);
+      } else {
+        // abs(subdiag[i]) <= epsilon * sqrt(abs(diag[i]) + abs(diag[i+1]))
+        // Scaled to prevent underflows.
+        const RealScalar scaled_subdiag = precision_inv * subdiag[i];
+        if (scaled_subdiag * scaled_subdiag <= (numext::abs(diag[i])+numext::abs(diag[i+1]))) {
+          subdiag[i] = RealScalar(0);
+        }
+      }
+    }
+
+    // find the largest unreduced block at the end of the matrix.
+    while (end>0 && subdiag[end-1]==RealScalar(0))
+    {
+      end--;
+    }
+    if (end<=0)
+      break;
+
+    // if we spent too many iterations, we give up
+    iter++;
+    if(iter > maxIterations * n) break;
+
+    start = end - 1;
+    while (start>0 && subdiag[start-1]!=0)
+      start--;
+
+    internal::tridiagonal_qr_step<MatrixType::Flags&RowMajorBit ? RowMajor : ColMajor>(diag.data(), subdiag.data(), start, end, computeEigenvectors ? eivec.data() : (Scalar*)0, n);
+  }
+  if (iter <= maxIterations * n)
+    info = Success;
+  else
+    info = NoConvergence;
+
+  // Sort eigenvalues and corresponding vectors.
+  // TODO make the sort optional ?
+  // TODO use a better sort algorithm !!
+  if (info == Success)
+  {
+    for (Index i = 0; i < n-1; ++i)
+    {
+      Index k;
+      diag.segment(i,n-i).minCoeff(&k);
+      if (k > 0)
+      {
+        numext::swap(diag[i], diag[k+i]);
+        if(computeEigenvectors)
+          eivec.col(i).swap(eivec.col(k+i));
+      }
+    }
+  }
+  return info;
+}
+  
+template<typename SolverType,int Size,bool IsComplex> struct direct_selfadjoint_eigenvalues
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(SolverType& eig, const typename SolverType::MatrixType& A, int options)
+  { eig.compute(A,options); }
+};
+
+template<typename SolverType> struct direct_selfadjoint_eigenvalues<SolverType,3,false>
+{
+  typedef typename SolverType::MatrixType MatrixType;
+  typedef typename SolverType::RealVectorType VectorType;
+  typedef typename SolverType::Scalar Scalar;
+  typedef typename SolverType::EigenvectorsType EigenvectorsType;
+  
+
+  /** \internal
+   * Computes the roots of the characteristic polynomial of \a m.
+   * For numerical stability m.trace() should be near zero and to avoid over- or underflow m should be normalized.
+   */
+  EIGEN_DEVICE_FUNC
+  static inline void computeRoots(const MatrixType& m, VectorType& roots)
+  {
+    EIGEN_USING_STD(sqrt)
+    EIGEN_USING_STD(atan2)
+    EIGEN_USING_STD(cos)
+    EIGEN_USING_STD(sin)
+    const Scalar s_inv3 = Scalar(1)/Scalar(3);
+    const Scalar s_sqrt3 = sqrt(Scalar(3));
+
+    // The characteristic equation is x^3 - c2*x^2 + c1*x - c0 = 0.  The
+    // eigenvalues are the roots to this equation, all guaranteed to be
+    // real-valued, because the matrix is symmetric.
+    Scalar c0 = m(0,0)*m(1,1)*m(2,2) + Scalar(2)*m(1,0)*m(2,0)*m(2,1) - m(0,0)*m(2,1)*m(2,1) - m(1,1)*m(2,0)*m(2,0) - m(2,2)*m(1,0)*m(1,0);
+    Scalar c1 = m(0,0)*m(1,1) - m(1,0)*m(1,0) + m(0,0)*m(2,2) - m(2,0)*m(2,0) + m(1,1)*m(2,2) - m(2,1)*m(2,1);
+    Scalar c2 = m(0,0) + m(1,1) + m(2,2);
+
+    // Construct the parameters used in classifying the roots of the equation
+    // and in solving the equation for the roots in closed form.
+    Scalar c2_over_3 = c2*s_inv3;
+    Scalar a_over_3 = (c2*c2_over_3 - c1)*s_inv3;
+    a_over_3 = numext::maxi(a_over_3, Scalar(0));
+
+    Scalar half_b = Scalar(0.5)*(c0 + c2_over_3*(Scalar(2)*c2_over_3*c2_over_3 - c1));
+
+    Scalar q = a_over_3*a_over_3*a_over_3 - half_b*half_b;
+    q = numext::maxi(q, Scalar(0));
+
+    // Compute the eigenvalues by solving for the roots of the polynomial.
+    Scalar rho = sqrt(a_over_3);
+    Scalar theta = atan2(sqrt(q),half_b)*s_inv3;  // since sqrt(q) > 0, atan2 is in [0, pi] and theta is in [0, pi/3]
+    Scalar cos_theta = cos(theta);
+    Scalar sin_theta = sin(theta);
+    // roots are already sorted, since cos is monotonically decreasing on [0, pi]
+    roots(0) = c2_over_3 - rho*(cos_theta + s_sqrt3*sin_theta); // == 2*rho*cos(theta+2pi/3)
+    roots(1) = c2_over_3 - rho*(cos_theta - s_sqrt3*sin_theta); // == 2*rho*cos(theta+ pi/3)
+    roots(2) = c2_over_3 + Scalar(2)*rho*cos_theta;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline bool extract_kernel(MatrixType& mat, Ref<VectorType> res, Ref<VectorType> representative)
+  {
+    EIGEN_USING_STD(abs);
+    EIGEN_USING_STD(sqrt);
+    Index i0;
+    // Find non-zero column i0 (by construction, there must exist a non zero coefficient on the diagonal):
+    mat.diagonal().cwiseAbs().maxCoeff(&i0);
+    // mat.col(i0) is a good candidate for an orthogonal vector to the current eigenvector,
+    // so let's save it:
+    representative = mat.col(i0);
+    Scalar n0, n1;
+    VectorType c0, c1;
+    n0 = (c0 = representative.cross(mat.col((i0+1)%3))).squaredNorm();
+    n1 = (c1 = representative.cross(mat.col((i0+2)%3))).squaredNorm();
+    if(n0>n1) res = c0/sqrt(n0);
+    else      res = c1/sqrt(n1);
+
+    return true;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline void run(SolverType& solver, const MatrixType& mat, int options)
+  {
+    eigen_assert(mat.cols() == 3 && mat.cols() == mat.rows());
+    eigen_assert((options&~(EigVecMask|GenEigMask))==0
+            && (options&EigVecMask)!=EigVecMask
+            && "invalid option parameter");
+    bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+    
+    EigenvectorsType& eivecs = solver.m_eivec;
+    VectorType& eivals = solver.m_eivalues;
+  
+    // Shift the matrix to the mean eigenvalue and map the matrix coefficients to [-1:1] to avoid over- and underflow.
+    Scalar shift = mat.trace() / Scalar(3);
+    // TODO Avoid this copy. Currently it is necessary to suppress bogus values when determining maxCoeff and for computing the eigenvectors later
+    MatrixType scaledMat = mat.template selfadjointView<Lower>();
+    scaledMat.diagonal().array() -= shift;
+    Scalar scale = scaledMat.cwiseAbs().maxCoeff();
+    if(scale > 0) scaledMat /= scale;   // TODO for scale==0 we could save the remaining operations
+
+    // compute the eigenvalues
+    computeRoots(scaledMat,eivals);
+
+    // compute the eigenvectors
+    if(computeEigenvectors)
+    {
+      if((eivals(2)-eivals(0))<=Eigen::NumTraits<Scalar>::epsilon())
+      {
+        // All three eigenvalues are numerically the same
+        eivecs.setIdentity();
+      }
+      else
+      {
+        MatrixType tmp;
+        tmp = scaledMat;
+
+        // Compute the eigenvector of the most distinct eigenvalue
+        Scalar d0 = eivals(2) - eivals(1);
+        Scalar d1 = eivals(1) - eivals(0);
+        Index k(0), l(2);
+        if(d0 > d1)
+        {
+          numext::swap(k,l);
+          d0 = d1;
+        }
+
+        // Compute the eigenvector of index k
+        {
+          tmp.diagonal().array () -= eivals(k);
+          // By construction, 'tmp' is of rank 2, and its kernel corresponds to the respective eigenvector.
+          extract_kernel(tmp, eivecs.col(k), eivecs.col(l));
+        }
+
+        // Compute eigenvector of index l
+        if(d0<=2*Eigen::NumTraits<Scalar>::epsilon()*d1)
+        {
+          // If d0 is too small, then the two other eigenvalues are numerically the same,
+          // and thus we only have to ortho-normalize the near orthogonal vector we saved above.
+          eivecs.col(l) -= eivecs.col(k).dot(eivecs.col(l))*eivecs.col(l);
+          eivecs.col(l).normalize();
+        }
+        else
+        {
+          tmp = scaledMat;
+          tmp.diagonal().array () -= eivals(l);
+
+          VectorType dummy;
+          extract_kernel(tmp, eivecs.col(l), dummy);
+        }
+
+        // Compute last eigenvector from the other two
+        eivecs.col(1) = eivecs.col(2).cross(eivecs.col(0)).normalized();
+      }
+    }
+
+    // Rescale back to the original size.
+    eivals *= scale;
+    eivals.array() += shift;
+    
+    solver.m_info = Success;
+    solver.m_isInitialized = true;
+    solver.m_eigenvectorsOk = computeEigenvectors;
+  }
+};
+
+// 2x2 direct eigenvalues decomposition, code from Hauke Heibel
+template<typename SolverType> 
+struct direct_selfadjoint_eigenvalues<SolverType,2,false>
+{
+  typedef typename SolverType::MatrixType MatrixType;
+  typedef typename SolverType::RealVectorType VectorType;
+  typedef typename SolverType::Scalar Scalar;
+  typedef typename SolverType::EigenvectorsType EigenvectorsType;
+  
+  EIGEN_DEVICE_FUNC
+  static inline void computeRoots(const MatrixType& m, VectorType& roots)
+  {
+    EIGEN_USING_STD(sqrt);
+    const Scalar t0 = Scalar(0.5) * sqrt( numext::abs2(m(0,0)-m(1,1)) + Scalar(4)*numext::abs2(m(1,0)));
+    const Scalar t1 = Scalar(0.5) * (m(0,0) + m(1,1));
+    roots(0) = t1 - t0;
+    roots(1) = t1 + t0;
+  }
+  
+  EIGEN_DEVICE_FUNC
+  static inline void run(SolverType& solver, const MatrixType& mat, int options)
+  {
+    EIGEN_USING_STD(sqrt);
+    EIGEN_USING_STD(abs);
+    
+    eigen_assert(mat.cols() == 2 && mat.cols() == mat.rows());
+    eigen_assert((options&~(EigVecMask|GenEigMask))==0
+            && (options&EigVecMask)!=EigVecMask
+            && "invalid option parameter");
+    bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+    
+    EigenvectorsType& eivecs = solver.m_eivec;
+    VectorType& eivals = solver.m_eivalues;
+  
+    // Shift the matrix to the mean eigenvalue and map the matrix coefficients to [-1:1] to avoid over- and underflow.
+    Scalar shift = mat.trace() / Scalar(2);
+    MatrixType scaledMat = mat;
+    scaledMat.coeffRef(0,1) = mat.coeff(1,0);
+    scaledMat.diagonal().array() -= shift;
+    Scalar scale = scaledMat.cwiseAbs().maxCoeff();
+    if(scale > Scalar(0))
+      scaledMat /= scale;
+
+    // Compute the eigenvalues
+    computeRoots(scaledMat,eivals);
+
+    // compute the eigen vectors
+    if(computeEigenvectors)
+    {
+      if((eivals(1)-eivals(0))<=abs(eivals(1))*Eigen::NumTraits<Scalar>::epsilon())
+      {
+        eivecs.setIdentity();
+      }
+      else
+      {
+        scaledMat.diagonal().array () -= eivals(1);
+        Scalar a2 = numext::abs2(scaledMat(0,0));
+        Scalar c2 = numext::abs2(scaledMat(1,1));
+        Scalar b2 = numext::abs2(scaledMat(1,0));
+        if(a2>c2)
+        {
+          eivecs.col(1) << -scaledMat(1,0), scaledMat(0,0);
+          eivecs.col(1) /= sqrt(a2+b2);
+        }
+        else
+        {
+          eivecs.col(1) << -scaledMat(1,1), scaledMat(1,0);
+          eivecs.col(1) /= sqrt(c2+b2);
+        }
+
+        eivecs.col(0) << eivecs.col(1).unitOrthogonal();
+      }
+    }
+
+    // Rescale back to the original size.
+    eivals *= scale;
+    eivals.array() += shift;
+
+    solver.m_info = Success;
+    solver.m_isInitialized = true;
+    solver.m_eigenvectorsOk = computeEigenvectors;
+  }
+};
+
+}
+
+template<typename MatrixType>
+EIGEN_DEVICE_FUNC
+SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
+::computeDirect(const MatrixType& matrix, int options)
+{
+  internal::direct_selfadjoint_eigenvalues<SelfAdjointEigenSolver,Size,NumTraits<Scalar>::IsComplex>::run(*this,matrix,options);
+  return *this;
+}
+
+namespace internal {
+
+// Francis implicit QR step.
+template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC
+static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n)
+{
+  // Wilkinson Shift.
+  RealScalar td = (diag[end-1] - diag[end])*RealScalar(0.5);
+  RealScalar e = subdiag[end-1];
+  // Note that thanks to scaling, e^2 or td^2 cannot overflow, however they can still
+  // underflow thus leading to inf/NaN values when using the following commented code:
+  //   RealScalar e2 = numext::abs2(subdiag[end-1]);
+  //   RealScalar mu = diag[end] - e2 / (td + (td>0 ? 1 : -1) * sqrt(td*td + e2));
+  // This explain the following, somewhat more complicated, version:
+  RealScalar mu = diag[end];
+  if(td==RealScalar(0)) {
+    mu -= numext::abs(e);
+  } else if (e != RealScalar(0)) {
+    const RealScalar e2 = numext::abs2(e);
+    const RealScalar h = numext::hypot(td,e);
+    if(e2 == RealScalar(0)) {
+      mu -= e / ((td + (td>RealScalar(0) ? h : -h)) / e);
+    } else {
+      mu -= e2 / (td + (td>RealScalar(0) ? h : -h)); 
+    }
+  }
+
+  RealScalar x = diag[start] - mu;
+  RealScalar z = subdiag[start];
+  // If z ever becomes zero, the Givens rotation will be the identity and
+  // z will stay zero for all future iterations.
+  for (Index k = start; k < end && z != RealScalar(0); ++k)
+  {
+    JacobiRotation<RealScalar> rot;
+    rot.makeGivens(x, z);
+
+    // do T = G' T G
+    RealScalar sdk = rot.s() * diag[k] + rot.c() * subdiag[k];
+    RealScalar dkp1 = rot.s() * subdiag[k] + rot.c() * diag[k+1];
+
+    diag[k] = rot.c() * (rot.c() * diag[k] - rot.s() * subdiag[k]) - rot.s() * (rot.c() * subdiag[k] - rot.s() * diag[k+1]);
+    diag[k+1] = rot.s() * sdk + rot.c() * dkp1;
+    subdiag[k] = rot.c() * sdk - rot.s() * dkp1;
+    
+    if (k > start)
+      subdiag[k - 1] = rot.c() * subdiag[k-1] - rot.s() * z;
+
+    // "Chasing the bulge" to return to triangular form.
+    x = subdiag[k];
+    if (k < end - 1)
+    {
+      z = -rot.s() * subdiag[k+1];
+      subdiag[k + 1] = rot.c() * subdiag[k+1];
+    }
+    
+    // apply the givens rotation to the unit matrix Q = Q * G
+    if (matrixQ)
+    {
+      // FIXME if StorageOrder == RowMajor this operation is not very efficient
+      Map<Matrix<Scalar,Dynamic,Dynamic,StorageOrder> > q(matrixQ,n,n);
+      q.applyOnTheRight(k,k+1,rot);
+    }
+  }
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINTEIGENSOLVER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
new file mode 100644
index 00000000..b0c947dc
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
@@ -0,0 +1,87 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Self-adjoint eigenvalues/eigenvectors.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_SAEIGENSOLVER_LAPACKE_H
+#define EIGEN_SAEIGENSOLVER_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_EIG_SELFADJ_2(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_NAME, EIGCOLROW ) \
+template<> template<typename InputType> inline \
+SelfAdjointEigenSolver<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >& \
+SelfAdjointEigenSolver<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >::compute(const EigenBase<InputType>& matrix, int options) \
+{ \
+  eigen_assert(matrix.cols() == matrix.rows()); \
+  eigen_assert((options&~(EigVecMask|GenEigMask))==0 \
+          && (options&EigVecMask)!=EigVecMask \
+          && "invalid option parameter"); \
+  bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors; \
+  lapack_int n = internal::convert_index<lapack_int>(matrix.cols()), lda, info; \
+  m_eivalues.resize(n,1); \
+  m_subdiag.resize(n-1); \
+  m_eivec = matrix; \
+\
+  if(n==1) \
+  { \
+    m_eivalues.coeffRef(0,0) = numext::real(m_eivec.coeff(0,0)); \
+    if(computeEigenvectors) m_eivec.setOnes(n,n); \
+    m_info = Success; \
+    m_isInitialized = true; \
+    m_eigenvectorsOk = computeEigenvectors; \
+    return *this; \
+  } \
+\
+  lda = internal::convert_index<lapack_int>(m_eivec.outerStride()); \
+  char jobz, uplo='L'/*, range='A'*/; \
+  jobz = computeEigenvectors ? 'V' : 'N'; \
+\
+  info = LAPACKE_##LAPACKE_NAME( LAPACK_COL_MAJOR, jobz, uplo, n, (LAPACKE_TYPE*)m_eivec.data(), lda, (LAPACKE_RTYPE*)m_eivalues.data() ); \
+  m_info = (info==0) ? Success : NoConvergence; \
+  m_isInitialized = true; \
+  m_eigenvectorsOk = computeEigenvectors; \
+  return *this; \
+}
+
+#define EIGEN_LAPACKE_EIG_SELFADJ(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_NAME )              \
+        EIGEN_LAPACKE_EIG_SELFADJ_2(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_NAME, ColMajor )  \
+        EIGEN_LAPACKE_EIG_SELFADJ_2(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_NAME, RowMajor ) 
+
+EIGEN_LAPACKE_EIG_SELFADJ(double,   double,                double, dsyev)
+EIGEN_LAPACKE_EIG_SELFADJ(float,    float,                 float,  ssyev)
+EIGEN_LAPACKE_EIG_SELFADJ(dcomplex, lapack_complex_double, double, zheev)
+EIGEN_LAPACKE_EIG_SELFADJ(scomplex, lapack_complex_float,  float,  cheev)
+
+} // end namespace Eigen
+
+#endif // EIGEN_SAEIGENSOLVER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/Tridiagonalization.h b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/Tridiagonalization.h
new file mode 100644
index 00000000..674c92a3
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Eigenvalues/Tridiagonalization.h
@@ -0,0 +1,561 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIDIAGONALIZATION_H
+#define EIGEN_TRIDIAGONALIZATION_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatrixType> struct TridiagonalizationMatrixTReturnType;
+template<typename MatrixType>
+struct traits<TridiagonalizationMatrixTReturnType<MatrixType> >
+  : public traits<typename MatrixType::PlainObject>
+{
+  typedef typename MatrixType::PlainObject ReturnType; // FIXME shall it be a BandMatrix?
+  enum { Flags = 0 };
+};
+
+template<typename MatrixType, typename CoeffVectorType>
+EIGEN_DEVICE_FUNC
+void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs);
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class Tridiagonalization
+  *
+  * \brief Tridiagonal decomposition of a selfadjoint matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * tridiagonal decomposition; this is expected to be an instantiation of the
+  * Matrix class template.
+  *
+  * This class performs a tridiagonal decomposition of a selfadjoint matrix \f$ A \f$ such that:
+  * \f$ A = Q T Q^* \f$ where \f$ Q \f$ is unitary and \f$ T \f$ a real symmetric tridiagonal matrix.
+  *
+  * A tridiagonal matrix is a matrix which has nonzero elements only on the
+  * main diagonal and the first diagonal below and above it. The Hessenberg
+  * decomposition of a selfadjoint matrix is in fact a tridiagonal
+  * decomposition. This class is used in SelfAdjointEigenSolver to compute the
+  * eigenvalues and eigenvectors of a selfadjoint matrix.
+  *
+  * Call the function compute() to compute the tridiagonal decomposition of a
+  * given matrix. Alternatively, you can use the Tridiagonalization(const MatrixType&)
+  * constructor which computes the tridiagonal Schur decomposition at
+  * construction time. Once the decomposition is computed, you can use the
+  * matrixQ() and matrixT() functions to retrieve the matrices Q and T in the
+  * decomposition.
+  *
+  * The documentation of Tridiagonalization(const MatrixType&) contains an
+  * example of the typical use of this class.
+  *
+  * \sa class HessenbergDecomposition, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class Tridiagonalization
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    enum {
+      Size = MatrixType::RowsAtCompileTime,
+      SizeMinusOne = Size == Dynamic ? Dynamic : (Size > 1 ? Size - 1 : 1),
+      Options = MatrixType::Options,
+      MaxSize = MatrixType::MaxRowsAtCompileTime,
+      MaxSizeMinusOne = MaxSize == Dynamic ? Dynamic : (MaxSize > 1 ? MaxSize - 1 : 1)
+    };
+
+    typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType;
+    typedef typename internal::plain_col_type<MatrixType, RealScalar>::type DiagonalType;
+    typedef Matrix<RealScalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> SubDiagonalType;
+    typedef typename internal::remove_all<typename MatrixType::RealReturnType>::type MatrixTypeRealView;
+    typedef internal::TridiagonalizationMatrixTReturnType<MatrixTypeRealView> MatrixTReturnType;
+
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+              typename internal::add_const_on_value_type<typename Diagonal<const MatrixType>::RealReturnType>::type,
+              const Diagonal<const MatrixType>
+            >::type DiagonalReturnType;
+
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+              typename internal::add_const_on_value_type<typename Diagonal<const MatrixType, -1>::RealReturnType>::type,
+              const Diagonal<const MatrixType, -1>
+            >::type SubDiagonalReturnType;
+
+    /** \brief Return type of matrixQ() */
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename CoeffVectorType::ConjugateReturnType>::type> HouseholderSequenceType;
+
+    /** \brief Default constructor.
+      *
+      * \param [in]  size  Positive integer, size of the matrix whose tridiagonal
+      * decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().  The \p size parameter is only
+      * used as a hint. It is not an error to give a wrong \p size, but it may
+      * impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit Tridiagonalization(Index size = Size==Dynamic ? 2 : Size)
+      : m_matrix(size,size),
+        m_hCoeffs(size > 1 ? size-1 : 1),
+        m_isInitialized(false)
+    {}
+
+    /** \brief Constructor; computes tridiagonal decomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose tridiagonal decomposition
+      * is to be computed.
+      *
+      * This constructor calls compute() to compute the tridiagonal decomposition.
+      *
+      * Example: \include Tridiagonalization_Tridiagonalization_MatrixType.cpp
+      * Output: \verbinclude Tridiagonalization_Tridiagonalization_MatrixType.out
+      */
+    template<typename InputType>
+    explicit Tridiagonalization(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_hCoeffs(matrix.cols() > 1 ? matrix.cols()-1 : 1),
+        m_isInitialized(false)
+    {
+      internal::tridiagonalization_inplace(m_matrix, m_hCoeffs);
+      m_isInitialized = true;
+    }
+
+    /** \brief Computes tridiagonal decomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose tridiagonal decomposition
+      * is to be computed.
+      * \returns    Reference to \c *this
+      *
+      * The tridiagonal decomposition is computed by bringing the columns of
+      * the matrix successively in the required form using Householder
+      * reflections. The cost is \f$ 4n^3/3 \f$ flops, where \f$ n \f$ denotes
+      * the size of the given matrix.
+      *
+      * This method reuses of the allocated data in the Tridiagonalization
+      * object, if the size of the matrix does not change.
+      *
+      * Example: \include Tridiagonalization_compute.cpp
+      * Output: \verbinclude Tridiagonalization_compute.out
+      */
+    template<typename InputType>
+    Tridiagonalization& compute(const EigenBase<InputType>& matrix)
+    {
+      m_matrix = matrix.derived();
+      m_hCoeffs.resize(matrix.rows()-1, 1);
+      internal::tridiagonalization_inplace(m_matrix, m_hCoeffs);
+      m_isInitialized = true;
+      return *this;
+    }
+
+    /** \brief Returns the Householder coefficients.
+      *
+      * \returns a const reference to the vector of Householder coefficients
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * The Householder coefficients allow the reconstruction of the matrix
+      * \f$ Q \f$ in the tridiagonal decomposition from the packed data.
+      *
+      * Example: \include Tridiagonalization_householderCoefficients.cpp
+      * Output: \verbinclude Tridiagonalization_householderCoefficients.out
+      *
+      * \sa packedMatrix(), \ref Householder_Module "Householder module"
+      */
+    inline CoeffVectorType householderCoefficients() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return m_hCoeffs;
+    }
+
+    /** \brief Returns the internal representation of the decomposition
+      *
+      *	\returns a const reference to a matrix with the internal representation
+      *	         of the decomposition.
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * The returned matrix contains the following information:
+      *  - the strict upper triangular part is equal to the input matrix A.
+      *  - the diagonal and lower sub-diagonal represent the real tridiagonal
+      *    symmetric matrix T.
+      *  - the rest of the lower part contains the Householder vectors that,
+      *    combined with Householder coefficients returned by
+      *    householderCoefficients(), allows to reconstruct the matrix Q as
+      *       \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
+      *    Here, the matrices \f$ H_i \f$ are the Householder transformations
+      *       \f$ H_i = (I - h_i v_i v_i^T) \f$
+      *    where \f$ h_i \f$ is the \f$ i \f$th Householder coefficient and
+      *    \f$ v_i \f$ is the Householder vector defined by
+      *       \f$ v_i = [ 0, \ldots, 0, 1, M(i+2,i), \ldots, M(N-1,i) ]^T \f$
+      *    with M the matrix returned by this function.
+      *
+      * See LAPACK for further details on this packed storage.
+      *
+      * Example: \include Tridiagonalization_packedMatrix.cpp
+      * Output: \verbinclude Tridiagonalization_packedMatrix.out
+      *
+      * \sa householderCoefficients()
+      */
+    inline const MatrixType& packedMatrix() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return m_matrix;
+    }
+
+    /** \brief Returns the unitary matrix Q in the decomposition
+      *
+      * \returns object representing the matrix Q
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * This function returns a light-weight object of template class
+      * HouseholderSequence. You can either apply it directly to a matrix or
+      * you can convert it to a matrix of type #MatrixType.
+      *
+      * \sa Tridiagonalization(const MatrixType&) for an example,
+      *     matrixT(), class HouseholderSequence
+      */
+    HouseholderSequenceType matrixQ() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return HouseholderSequenceType(m_matrix, m_hCoeffs.conjugate())
+             .setLength(m_matrix.rows() - 1)
+             .setShift(1);
+    }
+
+    /** \brief Returns an expression of the tridiagonal matrix T in the decomposition
+      *
+      * \returns expression object representing the matrix T
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * Currently, this function can be used to extract the matrix T from internal
+      * data and copy it to a dense matrix object. In most cases, it may be
+      * sufficient to directly use the packed matrix or the vector expressions
+      * returned by diagonal() and subDiagonal() instead of creating a new
+      * dense copy matrix with this function.
+      *
+      * \sa Tridiagonalization(const MatrixType&) for an example,
+      * matrixQ(), packedMatrix(), diagonal(), subDiagonal()
+      */
+    MatrixTReturnType matrixT() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return MatrixTReturnType(m_matrix.real());
+    }
+
+    /** \brief Returns the diagonal of the tridiagonal matrix T in the decomposition.
+      *
+      * \returns expression representing the diagonal of T
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * Example: \include Tridiagonalization_diagonal.cpp
+      * Output: \verbinclude Tridiagonalization_diagonal.out
+      *
+      * \sa matrixT(), subDiagonal()
+      */
+    DiagonalReturnType diagonal() const;
+
+    /** \brief Returns the subdiagonal of the tridiagonal matrix T in the decomposition.
+      *
+      * \returns expression representing the subdiagonal of T
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * \sa diagonal() for an example, matrixT()
+      */
+    SubDiagonalReturnType subDiagonal() const;
+
+  protected:
+
+    MatrixType m_matrix;
+    CoeffVectorType m_hCoeffs;
+    bool m_isInitialized;
+};
+
+template<typename MatrixType>
+typename Tridiagonalization<MatrixType>::DiagonalReturnType
+Tridiagonalization<MatrixType>::diagonal() const
+{
+  eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+  return m_matrix.diagonal().real();
+}
+
+template<typename MatrixType>
+typename Tridiagonalization<MatrixType>::SubDiagonalReturnType
+Tridiagonalization<MatrixType>::subDiagonal() const
+{
+  eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+  return m_matrix.template diagonal<-1>().real();
+}
+
+namespace internal {
+
+/** \internal
+  * Performs a tridiagonal decomposition of the selfadjoint matrix \a matA in-place.
+  *
+  * \param[in,out] matA On input the selfadjoint matrix. Only the \b lower triangular part is referenced.
+  *                     On output, the strict upper part is left unchanged, and the lower triangular part
+  *                     represents the T and Q matrices in packed format has detailed below.
+  * \param[out]    hCoeffs returned Householder coefficients (see below)
+  *
+  * On output, the tridiagonal selfadjoint matrix T is stored in the diagonal
+  * and lower sub-diagonal of the matrix \a matA.
+  * The unitary matrix Q is represented in a compact way as a product of
+  * Householder reflectors \f$ H_i \f$ such that:
+  *       \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
+  * The Householder reflectors are defined as
+  *       \f$ H_i = (I - h_i v_i v_i^T) \f$
+  * where \f$ h_i = hCoeffs[i]\f$ is the \f$ i \f$th Householder coefficient and
+  * \f$ v_i \f$ is the Householder vector defined by
+  *       \f$ v_i = [ 0, \ldots, 0, 1, matA(i+2,i), \ldots, matA(N-1,i) ]^T \f$.
+  *
+  * Implemented from Golub's "Matrix Computations", algorithm 8.3.1.
+  *
+  * \sa Tridiagonalization::packedMatrix()
+  */
+template<typename MatrixType, typename CoeffVectorType>
+EIGEN_DEVICE_FUNC
+void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs)
+{
+  using numext::conj;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  Index n = matA.rows();
+  eigen_assert(n==matA.cols());
+  eigen_assert(n==hCoeffs.size()+1 || n==1);
+
+  for (Index i = 0; i<n-1; ++i)
+  {
+    Index remainingSize = n-i-1;
+    RealScalar beta;
+    Scalar h;
+    matA.col(i).tail(remainingSize).makeHouseholderInPlace(h, beta);
+
+    // Apply similarity transformation to remaining columns,
+    // i.e., A = H A H' where H = I - h v v' and v = matA.col(i).tail(n-i-1)
+    matA.col(i).coeffRef(i+1) = 1;
+
+    hCoeffs.tail(n-i-1).noalias() = (matA.bottomRightCorner(remainingSize,remainingSize).template selfadjointView<Lower>()
+                                  * (conj(h) * matA.col(i).tail(remainingSize)));
+
+    hCoeffs.tail(n-i-1) += (conj(h)*RealScalar(-0.5)*(hCoeffs.tail(remainingSize).dot(matA.col(i).tail(remainingSize)))) * matA.col(i).tail(n-i-1);
+
+    matA.bottomRightCorner(remainingSize, remainingSize).template selfadjointView<Lower>()
+      .rankUpdate(matA.col(i).tail(remainingSize), hCoeffs.tail(remainingSize), Scalar(-1));
+
+    matA.col(i).coeffRef(i+1) = beta;
+    hCoeffs.coeffRef(i) = h;
+  }
+}
+
+// forward declaration, implementation at the end of this file
+template<typename MatrixType,
+         int Size=MatrixType::ColsAtCompileTime,
+         bool IsComplex=NumTraits<typename MatrixType::Scalar>::IsComplex>
+struct tridiagonalization_inplace_selector;
+
+/** \brief Performs a full tridiagonalization in place
+  *
+  * \param[in,out]  mat  On input, the selfadjoint matrix whose tridiagonal
+  *    decomposition is to be computed. Only the lower triangular part referenced.
+  *    The rest is left unchanged. On output, the orthogonal matrix Q
+  *    in the decomposition if \p extractQ is true.
+  * \param[out]  diag  The diagonal of the tridiagonal matrix T in the
+  *    decomposition.
+  * \param[out]  subdiag  The subdiagonal of the tridiagonal matrix T in
+  *    the decomposition.
+  * \param[in]  extractQ  If true, the orthogonal matrix Q in the
+  *    decomposition is computed and stored in \p mat.
+  *
+  * Computes the tridiagonal decomposition of the selfadjoint matrix \p mat in place
+  * such that \f$ mat = Q T Q^* \f$ where \f$ Q \f$ is unitary and \f$ T \f$ a real
+  * symmetric tridiagonal matrix.
+  *
+  * The tridiagonal matrix T is passed to the output parameters \p diag and \p subdiag. If
+  * \p extractQ is true, then the orthogonal matrix Q is passed to \p mat. Otherwise the lower
+  * part of the matrix \p mat is destroyed.
+  *
+  * The vectors \p diag and \p subdiag are not resized. The function
+  * assumes that they are already of the correct size. The length of the
+  * vector \p diag should equal the number of rows in \p mat, and the
+  * length of the vector \p subdiag should be one left.
+  *
+  * This implementation contains an optimized path for 3-by-3 matrices
+  * which is especially useful for plane fitting.
+  *
+  * \note Currently, it requires two temporary vectors to hold the intermediate
+  * Householder coefficients, and to reconstruct the matrix Q from the Householder
+  * reflectors.
+  *
+  * Example (this uses the same matrix as the example in
+  *    Tridiagonalization::Tridiagonalization(const MatrixType&)):
+  *    \include Tridiagonalization_decomposeInPlace.cpp
+  * Output: \verbinclude Tridiagonalization_decomposeInPlace.out
+  *
+  * \sa class Tridiagonalization
+  */
+template<typename MatrixType, typename DiagonalType, typename SubDiagonalType, typename CoeffVectorType>
+EIGEN_DEVICE_FUNC
+void tridiagonalization_inplace(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag,
+                                CoeffVectorType& hcoeffs, bool extractQ)
+{
+  eigen_assert(mat.cols()==mat.rows() && diag.size()==mat.rows() && subdiag.size()==mat.rows()-1);
+  tridiagonalization_inplace_selector<MatrixType>::run(mat, diag, subdiag, hcoeffs, extractQ);
+}
+
+/** \internal
+  * General full tridiagonalization
+  */
+template<typename MatrixType, int Size, bool IsComplex>
+struct tridiagonalization_inplace_selector
+{
+  typedef typename Tridiagonalization<MatrixType>::CoeffVectorType CoeffVectorType;
+  typedef typename Tridiagonalization<MatrixType>::HouseholderSequenceType HouseholderSequenceType;
+  template<typename DiagonalType, typename SubDiagonalType>
+  static EIGEN_DEVICE_FUNC
+      void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, CoeffVectorType& hCoeffs, bool extractQ)
+  {
+    tridiagonalization_inplace(mat, hCoeffs);
+    diag = mat.diagonal().real();
+    subdiag = mat.template diagonal<-1>().real();
+    if(extractQ)
+      mat = HouseholderSequenceType(mat, hCoeffs.conjugate())
+            .setLength(mat.rows() - 1)
+            .setShift(1);
+  }
+};
+
+/** \internal
+  * Specialization for 3x3 real matrices.
+  * Especially useful for plane fitting.
+  */
+template<typename MatrixType>
+struct tridiagonalization_inplace_selector<MatrixType,3,false>
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  template<typename DiagonalType, typename SubDiagonalType, typename CoeffVectorType>
+  static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, CoeffVectorType&, bool extractQ)
+  {
+    using std::sqrt;
+    const RealScalar tol = (std::numeric_limits<RealScalar>::min)();
+    diag[0] = mat(0,0);
+    RealScalar v1norm2 = numext::abs2(mat(2,0));
+    if(v1norm2 <= tol)
+    {
+      diag[1] = mat(1,1);
+      diag[2] = mat(2,2);
+      subdiag[0] = mat(1,0);
+      subdiag[1] = mat(2,1);
+      if (extractQ)
+        mat.setIdentity();
+    }
+    else
+    {
+      RealScalar beta = sqrt(numext::abs2(mat(1,0)) + v1norm2);
+      RealScalar invBeta = RealScalar(1)/beta;
+      Scalar m01 = mat(1,0) * invBeta;
+      Scalar m02 = mat(2,0) * invBeta;
+      Scalar q = RealScalar(2)*m01*mat(2,1) + m02*(mat(2,2) - mat(1,1));
+      diag[1] = mat(1,1) + m02*q;
+      diag[2] = mat(2,2) - m02*q;
+      subdiag[0] = beta;
+      subdiag[1] = mat(2,1) - m01 * q;
+      if (extractQ)
+      {
+        mat << 1,   0,    0,
+               0, m01,  m02,
+               0, m02, -m01;
+      }
+    }
+  }
+};
+
+/** \internal
+  * Trivial specialization for 1x1 matrices
+  */
+template<typename MatrixType, bool IsComplex>
+struct tridiagonalization_inplace_selector<MatrixType,1,IsComplex>
+{
+  typedef typename MatrixType::Scalar Scalar;
+
+  template<typename DiagonalType, typename SubDiagonalType, typename CoeffVectorType>
+  static EIGEN_DEVICE_FUNC
+  void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType&, CoeffVectorType&, bool extractQ)
+  {
+    diag(0,0) = numext::real(mat(0,0));
+    if(extractQ)
+      mat(0,0) = Scalar(1);
+  }
+};
+
+/** \internal
+  * \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  * \brief Expression type for return value of Tridiagonalization::matrixT()
+  *
+  * \tparam MatrixType type of underlying dense matrix
+  */
+template<typename MatrixType> struct TridiagonalizationMatrixTReturnType
+: public ReturnByValue<TridiagonalizationMatrixTReturnType<MatrixType> >
+{
+  public:
+    /** \brief Constructor.
+      *
+      * \param[in] mat The underlying dense matrix
+      */
+    TridiagonalizationMatrixTReturnType(const MatrixType& mat) : m_matrix(mat) { }
+
+    template <typename ResultType>
+    inline void evalTo(ResultType& result) const
+    {
+      result.setZero();
+      result.template diagonal<1>() = m_matrix.template diagonal<-1>().conjugate();
+      result.diagonal() = m_matrix.diagonal();
+      result.template diagonal<-1>() = m_matrix.template diagonal<-1>();
+    }
+
+    EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIDIAGONALIZATION_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/AlignedBox.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/AlignedBox.h
new file mode 100644
index 00000000..55a9d0ae
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/AlignedBox.h
@@ -0,0 +1,486 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// Function void Eigen::AlignedBox::transform(const Transform& transform)
+// is provided under the following license agreement:
+//
+// Software License Agreement (BSD License)
+//
+// Copyright (c) 2011-2014, Willow Garage, Inc.
+// Copyright (c) 2014-2015, Open Source Robotics Foundation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//  * Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//  * Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//  * Neither the name of Open Source Robotics Foundation nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef EIGEN_ALIGNEDBOX_H
+#define EIGEN_ALIGNEDBOX_H
+
+namespace Eigen {
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  *
+  * \class AlignedBox
+  *
+  * \brief An axis aligned box
+  *
+  * \tparam _Scalar the type of the scalar coefficients
+  * \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
+  *
+  * This class represents an axis aligned box as a pair of the minimal and maximal corners.
+  * \warning The result of most methods is undefined when applied to an empty box. You can check for empty boxes using isEmpty().
+  * \sa alignedboxtypedefs
+  */
+template <typename _Scalar, int _AmbientDim>
+class AlignedBox
+{
+public:
+EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
+  enum { AmbientDimAtCompileTime = _AmbientDim };
+  typedef _Scalar                                   Scalar;
+  typedef NumTraits<Scalar>                         ScalarTraits;
+  typedef Eigen::Index                              Index; ///< \deprecated since Eigen 3.3
+  typedef typename ScalarTraits::Real               RealScalar;
+  typedef typename ScalarTraits::NonInteger         NonInteger;
+  typedef Matrix<Scalar,AmbientDimAtCompileTime,1>  VectorType;
+  typedef CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const VectorType, const VectorType> VectorTypeSum;
+
+  /** Define constants to name the corners of a 1D, 2D or 3D axis aligned bounding box */
+  enum CornerType
+  {
+    /** 1D names @{ */
+    Min=0, Max=1,
+    /** @} */
+
+    /** Identifier for 2D corner @{ */
+    BottomLeft=0, BottomRight=1,
+    TopLeft=2, TopRight=3,
+    /** @} */
+
+    /** Identifier for 3D corner  @{ */
+    BottomLeftFloor=0, BottomRightFloor=1,
+    TopLeftFloor=2, TopRightFloor=3,
+    BottomLeftCeil=4, BottomRightCeil=5,
+    TopLeftCeil=6, TopRightCeil=7
+    /** @} */
+  };
+
+
+  /** Default constructor initializing a null box. */
+  EIGEN_DEVICE_FUNC inline AlignedBox()
+  { if (EIGEN_CONST_CONDITIONAL(AmbientDimAtCompileTime!=Dynamic)) setEmpty(); }
+
+  /** Constructs a null box with \a _dim the dimension of the ambient space. */
+  EIGEN_DEVICE_FUNC inline explicit AlignedBox(Index _dim) : m_min(_dim), m_max(_dim)
+  { setEmpty(); }
+
+  /** Constructs a box with extremities \a _min and \a _max.
+   * \warning If either component of \a _min is larger than the same component of \a _max, the constructed box is empty. */
+  template<typename OtherVectorType1, typename OtherVectorType2>
+  EIGEN_DEVICE_FUNC inline AlignedBox(const OtherVectorType1& _min, const OtherVectorType2& _max) : m_min(_min), m_max(_max) {}
+
+  /** Constructs a box containing a single point \a p. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline explicit AlignedBox(const MatrixBase<Derived>& p) : m_min(p), m_max(m_min)
+  { }
+
+  EIGEN_DEVICE_FUNC ~AlignedBox() {}
+
+  /** \returns the dimension in which the box holds */
+  EIGEN_DEVICE_FUNC inline Index dim() const { return AmbientDimAtCompileTime==Dynamic ? m_min.size() : Index(AmbientDimAtCompileTime); }
+
+  /** \deprecated use isEmpty() */
+  EIGEN_DEVICE_FUNC inline bool isNull() const { return isEmpty(); }
+
+  /** \deprecated use setEmpty() */
+  EIGEN_DEVICE_FUNC inline void setNull() { setEmpty(); }
+
+  /** \returns true if the box is empty.
+   * \sa setEmpty */
+  EIGEN_DEVICE_FUNC inline bool isEmpty() const { return (m_min.array() > m_max.array()).any(); }
+
+  /** Makes \c *this an empty box.
+   * \sa isEmpty */
+  EIGEN_DEVICE_FUNC inline void setEmpty()
+  {
+    m_min.setConstant( ScalarTraits::highest() );
+    m_max.setConstant( ScalarTraits::lowest() );
+  }
+
+  /** \returns the minimal corner */
+  EIGEN_DEVICE_FUNC inline const VectorType& (min)() const { return m_min; }
+  /** \returns a non const reference to the minimal corner */
+  EIGEN_DEVICE_FUNC inline VectorType& (min)() { return m_min; }
+  /** \returns the maximal corner */
+  EIGEN_DEVICE_FUNC inline const VectorType& (max)() const { return m_max; }
+  /** \returns a non const reference to the maximal corner */
+  EIGEN_DEVICE_FUNC inline VectorType& (max)() { return m_max; }
+
+  /** \returns the center of the box */
+  EIGEN_DEVICE_FUNC inline const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(VectorTypeSum, RealScalar, quotient)
+  center() const
+  { return (m_min+m_max)/RealScalar(2); }
+
+  /** \returns the lengths of the sides of the bounding box.
+    * Note that this function does not get the same
+    * result for integral or floating scalar types: see
+    */
+  EIGEN_DEVICE_FUNC inline const CwiseBinaryOp< internal::scalar_difference_op<Scalar,Scalar>, const VectorType, const VectorType> sizes() const
+  { return m_max - m_min; }
+
+  /** \returns the volume of the bounding box */
+  EIGEN_DEVICE_FUNC inline Scalar volume() const
+  { return sizes().prod(); }
+
+  /** \returns an expression for the bounding box diagonal vector
+    * if the length of the diagonal is needed: diagonal().norm()
+    * will provide it.
+    */
+  EIGEN_DEVICE_FUNC inline CwiseBinaryOp< internal::scalar_difference_op<Scalar,Scalar>, const VectorType, const VectorType> diagonal() const
+  { return sizes(); }
+
+  /** \returns the vertex of the bounding box at the corner defined by
+    * the corner-id corner. It works only for a 1D, 2D or 3D bounding box.
+    * For 1D bounding boxes corners are named by 2 enum constants:
+    * BottomLeft and BottomRight.
+    * For 2D bounding boxes, corners are named by 4 enum constants:
+    * BottomLeft, BottomRight, TopLeft, TopRight.
+    * For 3D bounding boxes, the following names are added:
+    * BottomLeftCeil, BottomRightCeil, TopLeftCeil, TopRightCeil.
+    */
+  EIGEN_DEVICE_FUNC inline VectorType corner(CornerType corner) const
+  {
+    EIGEN_STATIC_ASSERT(_AmbientDim <= 3, THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE);
+
+    VectorType res;
+
+    Index mult = 1;
+    for(Index d=0; d<dim(); ++d)
+    {
+      if( mult & corner ) res[d] = m_max[d];
+      else                res[d] = m_min[d];
+      mult *= 2;
+    }
+    return res;
+  }
+
+  /** \returns a random point inside the bounding box sampled with
+   * a uniform distribution */
+  EIGEN_DEVICE_FUNC inline VectorType sample() const
+  {
+    VectorType r(dim());
+    for(Index d=0; d<dim(); ++d)
+    {
+      if(!ScalarTraits::IsInteger)
+      {
+        r[d] = m_min[d] + (m_max[d]-m_min[d])
+             * internal::random<Scalar>(Scalar(0), Scalar(1));
+      }
+      else
+        r[d] = internal::random(m_min[d], m_max[d]);
+    }
+    return r;
+  }
+
+  /** \returns true if the point \a p is inside the box \c *this. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline bool contains(const MatrixBase<Derived>& p) const
+  {
+    typename internal::nested_eval<Derived,2>::type p_n(p.derived());
+    return (m_min.array()<=p_n.array()).all() && (p_n.array()<=m_max.array()).all();
+  }
+
+  /** \returns true if the box \a b is entirely inside the box \c *this. */
+  EIGEN_DEVICE_FUNC inline bool contains(const AlignedBox& b) const
+  { return (m_min.array()<=(b.min)().array()).all() && ((b.max)().array()<=m_max.array()).all(); }
+
+  /** \returns true if the box \a b is intersecting the box \c *this.
+   * \sa intersection, clamp */
+  EIGEN_DEVICE_FUNC inline bool intersects(const AlignedBox& b) const
+  { return (m_min.array()<=(b.max)().array()).all() && ((b.min)().array()<=m_max.array()).all(); }
+
+  /** Extends \c *this such that it contains the point \a p and returns a reference to \c *this.
+   * \sa extend(const AlignedBox&) */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline AlignedBox& extend(const MatrixBase<Derived>& p)
+  {
+    typename internal::nested_eval<Derived,2>::type p_n(p.derived());
+    m_min = m_min.cwiseMin(p_n);
+    m_max = m_max.cwiseMax(p_n);
+    return *this;
+  }
+
+  /** Extends \c *this such that it contains the box \a b and returns a reference to \c *this.
+   * \sa merged, extend(const MatrixBase&) */
+  EIGEN_DEVICE_FUNC inline AlignedBox& extend(const AlignedBox& b)
+  {
+    m_min = m_min.cwiseMin(b.m_min);
+    m_max = m_max.cwiseMax(b.m_max);
+    return *this;
+  }
+
+  /** Clamps \c *this by the box \a b and returns a reference to \c *this.
+   * \note If the boxes don't intersect, the resulting box is empty.
+   * \sa intersection(), intersects() */
+  EIGEN_DEVICE_FUNC inline AlignedBox& clamp(const AlignedBox& b)
+  {
+    m_min = m_min.cwiseMax(b.m_min);
+    m_max = m_max.cwiseMin(b.m_max);
+    return *this;
+  }
+
+  /** Returns an AlignedBox that is the intersection of \a b and \c *this
+   * \note If the boxes don't intersect, the resulting box is empty.
+   * \sa intersects(), clamp, contains()  */
+  EIGEN_DEVICE_FUNC inline AlignedBox intersection(const AlignedBox& b) const
+  {return AlignedBox(m_min.cwiseMax(b.m_min), m_max.cwiseMin(b.m_max)); }
+
+  /** Returns an AlignedBox that is the union of \a b and \c *this.
+   * \note Merging with an empty box may result in a box bigger than \c *this.
+   * \sa extend(const AlignedBox&) */
+  EIGEN_DEVICE_FUNC inline AlignedBox merged(const AlignedBox& b) const
+  { return AlignedBox(m_min.cwiseMin(b.m_min), m_max.cwiseMax(b.m_max)); }
+
+  /** Translate \c *this by the vector \a t and returns a reference to \c *this. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline AlignedBox& translate(const MatrixBase<Derived>& a_t)
+  {
+    const typename internal::nested_eval<Derived,2>::type t(a_t.derived());
+    m_min += t;
+    m_max += t;
+    return *this;
+  }
+
+  /** \returns a copy of \c *this translated by the vector \a t. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline AlignedBox translated(const MatrixBase<Derived>& a_t) const
+  {
+    AlignedBox result(m_min, m_max);
+    result.translate(a_t);
+    return result;
+  }
+
+  /** \returns the squared distance between the point \a p and the box \c *this,
+    * and zero if \a p is inside the box.
+    * \sa exteriorDistance(const MatrixBase&), squaredExteriorDistance(const AlignedBox&)
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Scalar squaredExteriorDistance(const MatrixBase<Derived>& p) const;
+
+  /** \returns the squared distance between the boxes \a b and \c *this,
+    * and zero if the boxes intersect.
+    * \sa exteriorDistance(const AlignedBox&), squaredExteriorDistance(const MatrixBase&)
+    */
+  EIGEN_DEVICE_FUNC inline Scalar squaredExteriorDistance(const AlignedBox& b) const;
+
+  /** \returns the distance between the point \a p and the box \c *this,
+    * and zero if \a p is inside the box.
+    * \sa squaredExteriorDistance(const MatrixBase&), exteriorDistance(const AlignedBox&)
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline NonInteger exteriorDistance(const MatrixBase<Derived>& p) const
+  { EIGEN_USING_STD(sqrt) return sqrt(NonInteger(squaredExteriorDistance(p))); }
+
+  /** \returns the distance between the boxes \a b and \c *this,
+    * and zero if the boxes intersect.
+    * \sa squaredExteriorDistance(const AlignedBox&), exteriorDistance(const MatrixBase&)
+    */
+  EIGEN_DEVICE_FUNC inline NonInteger exteriorDistance(const AlignedBox& b) const
+  { EIGEN_USING_STD(sqrt) return sqrt(NonInteger(squaredExteriorDistance(b))); }
+
+  /**
+   * Specialization of transform for pure translation.
+   */
+  template<int Mode, int Options>
+  EIGEN_DEVICE_FUNC inline void transform(
+      const typename Transform<Scalar, AmbientDimAtCompileTime, Mode, Options>::TranslationType& translation)
+  {
+    this->translate(translation);
+  }
+
+  /**
+   * Transforms this box by \a transform and recomputes it to
+   * still be an axis-aligned box.
+   *
+   * \note This method is provided under BSD license (see the top of this file).
+   */
+  template<int Mode, int Options>
+  EIGEN_DEVICE_FUNC inline void transform(const Transform<Scalar, AmbientDimAtCompileTime, Mode, Options>& transform)
+  {
+    // Only Affine and Isometry transforms are currently supported.
+    EIGEN_STATIC_ASSERT(Mode == Affine || Mode == AffineCompact || Mode == Isometry, THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS);
+
+    // Method adapted from FCL src/shape/geometric_shapes_utility.cpp#computeBV<AABB, Box>(...)
+    // https://github.com/flexible-collision-library/fcl/blob/fcl-0.4/src/shape/geometric_shapes_utility.cpp#L292
+    //
+    // Here's a nice explanation why it works: https://zeuxcg.org/2010/10/17/aabb-from-obb-with-component-wise-abs/
+
+    // two times rotated extent
+    const VectorType rotated_extent_2 = transform.linear().cwiseAbs() * sizes();
+    // two times new center
+    const VectorType rotated_center_2 = transform.linear() * (this->m_max + this->m_min) +
+        Scalar(2) * transform.translation();
+
+    this->m_max = (rotated_center_2 + rotated_extent_2) / Scalar(2);
+    this->m_min = (rotated_center_2 - rotated_extent_2) / Scalar(2);
+  }
+
+  /**
+   * \returns a copy of \c *this transformed by \a transform and recomputed to
+   * still be an axis-aligned box.
+   */
+  template<int Mode, int Options>
+  EIGEN_DEVICE_FUNC AlignedBox transformed(const Transform<Scalar, AmbientDimAtCompileTime, Mode, Options>& transform) const
+  {
+    AlignedBox result(m_min, m_max);
+    result.transform(transform);
+    return result;
+  }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<AlignedBox,
+           AlignedBox<NewScalarType,AmbientDimAtCompileTime> >::type cast() const
+  {
+    return typename internal::cast_return_type<AlignedBox,
+                    AlignedBox<NewScalarType,AmbientDimAtCompileTime> >::type(*this);
+  }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit AlignedBox(const AlignedBox<OtherScalarType,AmbientDimAtCompileTime>& other)
+  {
+    m_min = (other.min)().template cast<Scalar>();
+    m_max = (other.max)().template cast<Scalar>();
+  }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const AlignedBox& other, const RealScalar& prec = ScalarTraits::dummy_precision()) const
+  { return m_min.isApprox(other.m_min, prec) && m_max.isApprox(other.m_max, prec); }
+
+protected:
+
+  VectorType m_min, m_max;
+};
+
+
+
+template<typename Scalar,int AmbientDim>
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Scalar AlignedBox<Scalar,AmbientDim>::squaredExteriorDistance(const MatrixBase<Derived>& a_p) const
+{
+  typename internal::nested_eval<Derived,2*AmbientDim>::type p(a_p.derived());
+  Scalar dist2(0);
+  Scalar aux;
+  for (Index k=0; k<dim(); ++k)
+  {
+    if( m_min[k] > p[k] )
+    {
+      aux = m_min[k] - p[k];
+      dist2 += aux*aux;
+    }
+    else if( p[k] > m_max[k] )
+    {
+      aux = p[k] - m_max[k];
+      dist2 += aux*aux;
+    }
+  }
+  return dist2;
+}
+
+template<typename Scalar,int AmbientDim>
+EIGEN_DEVICE_FUNC inline Scalar AlignedBox<Scalar,AmbientDim>::squaredExteriorDistance(const AlignedBox& b) const
+{
+  Scalar dist2(0);
+  Scalar aux;
+  for (Index k=0; k<dim(); ++k)
+  {
+    if( m_min[k] > b.m_max[k] )
+    {
+      aux = m_min[k] - b.m_max[k];
+      dist2 += aux*aux;
+    }
+    else if( b.m_min[k] > m_max[k] )
+    {
+      aux = b.m_min[k] - m_max[k];
+      dist2 += aux*aux;
+    }
+  }
+  return dist2;
+}
+
+/** \defgroup alignedboxtypedefs Global aligned box typedefs
+  *
+  * \ingroup Geometry_Module
+  *
+  * Eigen defines several typedef shortcuts for most common aligned box types.
+  *
+  * The general patterns are the following:
+  *
+  * \c AlignedBoxSizeType where \c Size can be \c 1, \c 2,\c 3,\c 4 for fixed size boxes or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double.
+  *
+  * For example, \c AlignedBox3d is a fixed-size 3x3 aligned box type of doubles, and \c AlignedBoxXf is a dynamic-size aligned box of floats.
+  *
+  * \sa class AlignedBox
+  */
+
+#define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix)    \
+/** \ingroup alignedboxtypedefs */                                 \
+typedef AlignedBox<Type, Size>   AlignedBox##SizeSuffix##TypeSuffix;
+
+#define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 1, 1) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Dynamic, X)
+
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(int,                  i)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(float,                f)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(double,               d)
+
+#undef EIGEN_MAKE_TYPEDEFS_ALL_SIZES
+#undef EIGEN_MAKE_TYPEDEFS
+
+} // end namespace Eigen
+
+#endif // EIGEN_ALIGNEDBOX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/AngleAxis.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/AngleAxis.h
new file mode 100644
index 00000000..78328b6b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/AngleAxis.h
@@ -0,0 +1,247 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ANGLEAXIS_H
+#define EIGEN_ANGLEAXIS_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class AngleAxis
+  *
+  * \brief Represents a 3D rotation as a rotation angle around an arbitrary 3D axis
+  *
+  * \param _Scalar the scalar type, i.e., the type of the coefficients.
+  *
+  * \warning When setting up an AngleAxis object, the axis vector \b must \b be \b normalized.
+  *
+  * The following two typedefs are provided for convenience:
+  * \li \c AngleAxisf for \c float
+  * \li \c AngleAxisd for \c double
+  *
+  * Combined with MatrixBase::Unit{X,Y,Z}, AngleAxis can be used to easily
+  * mimic Euler-angles. Here is an example:
+  * \include AngleAxis_mimic_euler.cpp
+  * Output: \verbinclude AngleAxis_mimic_euler.out
+  *
+  * \note This class is not aimed to be used to store a rotation transformation,
+  * but rather to make easier the creation of other rotation (Quaternion, rotation Matrix)
+  * and transformation objects.
+  *
+  * \sa class Quaternion, class Transform, MatrixBase::UnitX()
+  */
+
+namespace internal {
+template<typename _Scalar> struct traits<AngleAxis<_Scalar> >
+{
+  typedef _Scalar Scalar;
+};
+}
+
+template<typename _Scalar>
+class AngleAxis : public RotationBase<AngleAxis<_Scalar>,3>
+{
+  typedef RotationBase<AngleAxis<_Scalar>,3> Base;
+
+public:
+
+  using Base::operator*;
+
+  enum { Dim = 3 };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  typedef Matrix<Scalar,3,3> Matrix3;
+  typedef Matrix<Scalar,3,1> Vector3;
+  typedef Quaternion<Scalar> QuaternionType;
+
+protected:
+
+  Vector3 m_axis;
+  Scalar m_angle;
+
+public:
+
+  /** Default constructor without initialization. */
+  EIGEN_DEVICE_FUNC AngleAxis() {}
+  /** Constructs and initialize the angle-axis rotation from an \a angle in radian
+    * and an \a axis which \b must \b be \b normalized.
+    *
+    * \warning If the \a axis vector is not normalized, then the angle-axis object
+    *          represents an invalid rotation. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC 
+  inline AngleAxis(const Scalar& angle, const MatrixBase<Derived>& axis) : m_axis(axis), m_angle(angle) {}
+  /** Constructs and initialize the angle-axis rotation from a quaternion \a q.
+    * This function implicitly normalizes the quaternion \a q.
+    */
+  template<typename QuatDerived> 
+  EIGEN_DEVICE_FUNC inline explicit AngleAxis(const QuaternionBase<QuatDerived>& q) { *this = q; }
+  /** Constructs and initialize the angle-axis rotation from a 3x3 rotation matrix. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline explicit AngleAxis(const MatrixBase<Derived>& m) { *this = m; }
+
+  /** \returns the value of the rotation angle in radian */
+  EIGEN_DEVICE_FUNC Scalar angle() const { return m_angle; }
+  /** \returns a read-write reference to the stored angle in radian */
+  EIGEN_DEVICE_FUNC Scalar& angle() { return m_angle; }
+
+  /** \returns the rotation axis */
+  EIGEN_DEVICE_FUNC const Vector3& axis() const { return m_axis; }
+  /** \returns a read-write reference to the stored rotation axis.
+    *
+    * \warning The rotation axis must remain a \b unit vector.
+    */
+  EIGEN_DEVICE_FUNC Vector3& axis() { return m_axis; }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline QuaternionType operator* (const AngleAxis& other) const
+  { return QuaternionType(*this) * QuaternionType(other); }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline QuaternionType operator* (const QuaternionType& other) const
+  { return QuaternionType(*this) * other; }
+
+  /** Concatenates two rotations */
+  friend EIGEN_DEVICE_FUNC inline QuaternionType operator* (const QuaternionType& a, const AngleAxis& b)
+  { return a * QuaternionType(b); }
+
+  /** \returns the inverse rotation, i.e., an angle-axis with opposite rotation angle */
+  EIGEN_DEVICE_FUNC AngleAxis inverse() const
+  { return AngleAxis(-m_angle, m_axis); }
+
+  template<class QuatDerived>
+  EIGEN_DEVICE_FUNC AngleAxis& operator=(const QuaternionBase<QuatDerived>& q);
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC AngleAxis& operator=(const MatrixBase<Derived>& m);
+
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC AngleAxis& fromRotationMatrix(const MatrixBase<Derived>& m);
+  EIGEN_DEVICE_FUNC Matrix3 toRotationMatrix(void) const;
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<AngleAxis,AngleAxis<NewScalarType> >::type cast() const
+  { return typename internal::cast_return_type<AngleAxis,AngleAxis<NewScalarType> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit AngleAxis(const AngleAxis<OtherScalarType>& other)
+  {
+    m_axis = other.axis().template cast<Scalar>();
+    m_angle = Scalar(other.angle());
+  }
+
+  EIGEN_DEVICE_FUNC static inline const AngleAxis Identity() { return AngleAxis(Scalar(0), Vector3::UnitX()); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const AngleAxis& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_axis.isApprox(other.m_axis, prec) && internal::isApprox(m_angle,other.m_angle, prec); }
+};
+
+/** \ingroup Geometry_Module
+  * single precision angle-axis type */
+typedef AngleAxis<float> AngleAxisf;
+/** \ingroup Geometry_Module
+  * double precision angle-axis type */
+typedef AngleAxis<double> AngleAxisd;
+
+/** Set \c *this from a \b unit quaternion.
+  *
+  * The resulting axis is normalized, and the computed angle is in the [0,pi] range.
+  * 
+  * This function implicitly normalizes the quaternion \a q.
+  */
+template<typename Scalar>
+template<typename QuatDerived>
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const QuaternionBase<QuatDerived>& q)
+{
+  EIGEN_USING_STD(atan2)
+  EIGEN_USING_STD(abs)
+  Scalar n = q.vec().norm();
+  if(n<NumTraits<Scalar>::epsilon())
+    n = q.vec().stableNorm();
+
+  if (n != Scalar(0))
+  {
+    m_angle = Scalar(2)*atan2(n, abs(q.w()));
+    if(q.w() < Scalar(0))
+      n = -n;
+    m_axis  = q.vec() / n;
+  }
+  else
+  {
+    m_angle = Scalar(0);
+    m_axis << Scalar(1), Scalar(0), Scalar(0);
+  }
+  return *this;
+}
+
+/** Set \c *this from a 3x3 rotation matrix \a mat.
+  */
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const MatrixBase<Derived>& mat)
+{
+  // Since a direct conversion would not be really faster,
+  // let's use the robust Quaternion implementation:
+  return *this = QuaternionType(mat);
+}
+
+/**
+* \brief Sets \c *this from a 3x3 rotation matrix.
+**/
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
+{
+  return *this = QuaternionType(mat);
+}
+
+/** Constructs and \returns an equivalent 3x3 rotation matrix.
+  */
+template<typename Scalar>
+typename AngleAxis<Scalar>::Matrix3
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>::toRotationMatrix(void) const
+{
+  EIGEN_USING_STD(sin)
+  EIGEN_USING_STD(cos)
+  Matrix3 res;
+  Vector3 sin_axis  = sin(m_angle) * m_axis;
+  Scalar c = cos(m_angle);
+  Vector3 cos1_axis = (Scalar(1)-c) * m_axis;
+
+  Scalar tmp;
+  tmp = cos1_axis.x() * m_axis.y();
+  res.coeffRef(0,1) = tmp - sin_axis.z();
+  res.coeffRef(1,0) = tmp + sin_axis.z();
+
+  tmp = cos1_axis.x() * m_axis.z();
+  res.coeffRef(0,2) = tmp + sin_axis.y();
+  res.coeffRef(2,0) = tmp - sin_axis.y();
+
+  tmp = cos1_axis.y() * m_axis.z();
+  res.coeffRef(1,2) = tmp - sin_axis.x();
+  res.coeffRef(2,1) = tmp + sin_axis.x();
+
+  res.diagonal() = (cos1_axis.cwiseProduct(m_axis)).array() + c;
+
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ANGLEAXIS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/EulerAngles.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/EulerAngles.h
new file mode 100644
index 00000000..19b734ca
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/EulerAngles.h
@@ -0,0 +1,114 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EULERANGLES_H
+#define EIGEN_EULERANGLES_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  *
+  * \returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (\a a0,\a a1,\a a2)
+  *
+  * Each of the three parameters \a a0,\a a1,\a a2 represents the respective rotation axis as an integer in {0,1,2}.
+  * For instance, in:
+  * \code Vector3f ea = mat.eulerAngles(2, 0, 2); \endcode
+  * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
+  * we have the following equality:
+  * \code
+  * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
+  *      * AngleAxisf(ea[1], Vector3f::UnitX())
+  *      * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode
+  * This corresponds to the right-multiply conventions (with right hand side frames).
+  * 
+  * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].
+  * 
+  * \sa class AngleAxis
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Matrix<typename MatrixBase<Derived>::Scalar,3,1>
+MatrixBase<Derived>::eulerAngles(Index a0, Index a1, Index a2) const
+{
+  EIGEN_USING_STD(atan2)
+  EIGEN_USING_STD(sin)
+  EIGEN_USING_STD(cos)
+  /* Implemented from Graphics Gems IV */
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Derived,3,3)
+
+  Matrix<Scalar,3,1> res;
+  typedef Matrix<typename Derived::Scalar,2,1> Vector2;
+
+  const Index odd = ((a0+1)%3 == a1) ? 0 : 1;
+  const Index i = a0;
+  const Index j = (a0 + 1 + odd)%3;
+  const Index k = (a0 + 2 - odd)%3;
+  
+  if (a0==a2)
+  {
+    res[0] = atan2(coeff(j,i), coeff(k,i));
+    if((odd && res[0]<Scalar(0)) || ((!odd) && res[0]>Scalar(0)))
+    {
+      if(res[0] > Scalar(0)) {
+        res[0] -= Scalar(EIGEN_PI);
+      }
+      else {
+        res[0] += Scalar(EIGEN_PI);
+      }
+      Scalar s2 = Vector2(coeff(j,i), coeff(k,i)).norm();
+      res[1] = -atan2(s2, coeff(i,i));
+    }
+    else
+    {
+      Scalar s2 = Vector2(coeff(j,i), coeff(k,i)).norm();
+      res[1] = atan2(s2, coeff(i,i));
+    }
+    
+    // With a=(0,1,0), we have i=0; j=1; k=2, and after computing the first two angles,
+    // we can compute their respective rotation, and apply its inverse to M. Since the result must
+    // be a rotation around x, we have:
+    //
+    //  c2  s1.s2 c1.s2                   1  0   0 
+    //  0   c1    -s1       *    M    =   0  c3  s3
+    //  -s2 s1.c2 c1.c2                   0 -s3  c3
+    //
+    //  Thus:  m11.c1 - m21.s1 = c3  &   m12.c1 - m22.s1 = s3
+    
+    Scalar s1 = sin(res[0]);
+    Scalar c1 = cos(res[0]);
+    res[2] = atan2(c1*coeff(j,k)-s1*coeff(k,k), c1*coeff(j,j) - s1 * coeff(k,j));
+  } 
+  else
+  {
+    res[0] = atan2(coeff(j,k), coeff(k,k));
+    Scalar c2 = Vector2(coeff(i,i), coeff(i,j)).norm();
+    if((odd && res[0]<Scalar(0)) || ((!odd) && res[0]>Scalar(0))) {
+      if(res[0] > Scalar(0)) {
+        res[0] -= Scalar(EIGEN_PI);
+      }
+      else {
+        res[0] += Scalar(EIGEN_PI);
+      }
+      res[1] = atan2(-coeff(i,k), -c2);
+    }
+    else
+      res[1] = atan2(-coeff(i,k), c2);
+    Scalar s1 = sin(res[0]);
+    Scalar c1 = cos(res[0]);
+    res[2] = atan2(s1*coeff(k,i)-c1*coeff(j,i), c1*coeff(j,j) - s1 * coeff(k,j));
+  }
+  if (!odd)
+    res = -res;
+  
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_EULERANGLES_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/Homogeneous.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Homogeneous.h
new file mode 100644
index 00000000..94083ac5
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Homogeneous.h
@@ -0,0 +1,501 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOMOGENEOUS_H
+#define EIGEN_HOMOGENEOUS_H
+
+namespace Eigen {
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Homogeneous
+  *
+  * \brief Expression of one (or a set of) homogeneous vector(s)
+  *
+  * \param MatrixType the type of the object in which we are making homogeneous
+  *
+  * This class represents an expression of one (or a set of) homogeneous vector(s).
+  * It is the return type of MatrixBase::homogeneous() and most of the time
+  * this is the only way it is used.
+  *
+  * \sa MatrixBase::homogeneous()
+  */
+
+namespace internal {
+
+template<typename MatrixType,int Direction>
+struct traits<Homogeneous<MatrixType,Direction> >
+ : traits<MatrixType>
+{
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    RowsPlusOne = (MatrixType::RowsAtCompileTime != Dynamic) ?
+                  int(MatrixType::RowsAtCompileTime) + 1 : Dynamic,
+    ColsPlusOne = (MatrixType::ColsAtCompileTime != Dynamic) ?
+                  int(MatrixType::ColsAtCompileTime) + 1 : Dynamic,
+    RowsAtCompileTime = Direction==Vertical  ?  RowsPlusOne : MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = Direction==Horizontal ? ColsPlusOne : MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    TmpFlags = _MatrixTypeNested::Flags & HereditaryBits,
+    Flags = ColsAtCompileTime==1 ? (TmpFlags & ~RowMajorBit)
+          : RowsAtCompileTime==1 ? (TmpFlags | RowMajorBit)
+          : TmpFlags
+  };
+};
+
+template<typename MatrixType,typename Lhs> struct homogeneous_left_product_impl;
+template<typename MatrixType,typename Rhs> struct homogeneous_right_product_impl;
+
+} // end namespace internal
+
+template<typename MatrixType,int _Direction> class Homogeneous
+  : public MatrixBase<Homogeneous<MatrixType,_Direction> >, internal::no_assignment_operator
+{
+  public:
+
+    typedef MatrixType NestedExpression;
+    enum { Direction = _Direction };
+
+    typedef MatrixBase<Homogeneous> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Homogeneous)
+
+    EIGEN_DEVICE_FUNC explicit inline Homogeneous(const MatrixType& matrix)
+      : m_matrix(matrix)
+    {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows() + (int(Direction)==Vertical   ? 1 : 0); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols() + (int(Direction)==Horizontal ? 1 : 0); }
+
+    EIGEN_DEVICE_FUNC const NestedExpression& nestedExpression() const { return m_matrix; }
+
+    template<typename Rhs>
+    EIGEN_DEVICE_FUNC inline const Product<Homogeneous,Rhs>
+    operator* (const MatrixBase<Rhs>& rhs) const
+    {
+      eigen_assert(int(Direction)==Horizontal);
+      return Product<Homogeneous,Rhs>(*this,rhs.derived());
+    }
+
+    template<typename Lhs> friend
+    EIGEN_DEVICE_FUNC inline const Product<Lhs,Homogeneous>
+    operator* (const MatrixBase<Lhs>& lhs, const Homogeneous& rhs)
+    {
+      eigen_assert(int(Direction)==Vertical);
+      return Product<Lhs,Homogeneous>(lhs.derived(),rhs);
+    }
+
+    template<typename Scalar, int Dim, int Mode, int Options> friend
+    EIGEN_DEVICE_FUNC inline const Product<Transform<Scalar,Dim,Mode,Options>, Homogeneous >
+    operator* (const Transform<Scalar,Dim,Mode,Options>& lhs, const Homogeneous& rhs)
+    {
+      eigen_assert(int(Direction)==Vertical);
+      return Product<Transform<Scalar,Dim,Mode,Options>, Homogeneous>(lhs,rhs);
+    }
+
+    template<typename Func>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::result_of<Func(Scalar,Scalar)>::type
+    redux(const Func& func) const
+    {
+      return func(m_matrix.redux(func), Scalar(1));
+    }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+};
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns a vector expression that is one longer than the vector argument, with the value 1 symbolically appended as the last coefficient.
+  *
+  * This can be used to convert affine coordinates to homogeneous coordinates.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include MatrixBase_homogeneous.cpp
+  * Output: \verbinclude MatrixBase_homogeneous.out
+  *
+  * \sa VectorwiseOp::homogeneous(), class Homogeneous
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::HomogeneousReturnType
+MatrixBase<Derived>::homogeneous() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return HomogeneousReturnType(derived());
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns an expression where the value 1 is symbolically appended as the final coefficient to each column (or row) of the matrix.
+  *
+  * This can be used to convert affine coordinates to homogeneous coordinates.
+  *
+  * Example: \include VectorwiseOp_homogeneous.cpp
+  * Output: \verbinclude VectorwiseOp_homogeneous.out
+  *
+  * \sa MatrixBase::homogeneous(), class Homogeneous */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC inline Homogeneous<ExpressionType,Direction>
+VectorwiseOp<ExpressionType,Direction>::homogeneous() const
+{
+  return HomogeneousReturnType(_expression());
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \brief homogeneous normalization
+  *
+  * \returns a vector expression of the N-1 first coefficients of \c *this divided by that last coefficient.
+  *
+  * This can be used to convert homogeneous coordinates to affine coordinates.
+  *
+  * It is essentially a shortcut for:
+  * \code
+    this->head(this->size()-1)/this->coeff(this->size()-1);
+    \endcode
+  *
+  * Example: \include MatrixBase_hnormalized.cpp
+  * Output: \verbinclude MatrixBase_hnormalized.out
+  *
+  * \sa VectorwiseOp::hnormalized() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const typename MatrixBase<Derived>::HNormalizedReturnType
+MatrixBase<Derived>::hnormalized() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return ConstStartMinusOne(derived(),0,0,
+    ColsAtCompileTime==1?size()-1:1,
+    ColsAtCompileTime==1?1:size()-1) / coeff(size()-1);
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \brief column or row-wise homogeneous normalization
+  *
+  * \returns an expression of the first N-1 coefficients of each column (or row) of \c *this divided by the last coefficient of each column (or row).
+  *
+  * This can be used to convert homogeneous coordinates to affine coordinates.
+  *
+  * It is conceptually equivalent to calling MatrixBase::hnormalized() to each column (or row) of \c *this.
+  *
+  * Example: \include DirectionWise_hnormalized.cpp
+  * Output: \verbinclude DirectionWise_hnormalized.out
+  *
+  * \sa MatrixBase::hnormalized() */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC inline const typename VectorwiseOp<ExpressionType,Direction>::HNormalizedReturnType
+VectorwiseOp<ExpressionType,Direction>::hnormalized() const
+{
+  return HNormalized_Block(_expression(),0,0,
+      Direction==Vertical   ? _expression().rows()-1 : _expression().rows(),
+      Direction==Horizontal ? _expression().cols()-1 : _expression().cols()).cwiseQuotient(
+      Replicate<HNormalized_Factors,
+                Direction==Vertical   ? HNormalized_SizeMinusOne : 1,
+                Direction==Horizontal ? HNormalized_SizeMinusOne : 1>
+        (HNormalized_Factors(_expression(),
+          Direction==Vertical    ? _expression().rows()-1:0,
+          Direction==Horizontal  ? _expression().cols()-1:0,
+          Direction==Vertical    ? 1 : _expression().rows(),
+          Direction==Horizontal  ? 1 : _expression().cols()),
+         Direction==Vertical   ? _expression().rows()-1 : 1,
+         Direction==Horizontal ? _expression().cols()-1 : 1));
+}
+
+namespace internal {
+
+template<typename MatrixOrTransformType>
+struct take_matrix_for_product
+{
+  typedef MatrixOrTransformType type;
+  EIGEN_DEVICE_FUNC static const type& run(const type &x) { return x; }
+};
+
+template<typename Scalar, int Dim, int Mode,int Options>
+struct take_matrix_for_product<Transform<Scalar, Dim, Mode, Options> >
+{
+  typedef Transform<Scalar, Dim, Mode, Options> TransformType;
+  typedef typename internal::add_const<typename TransformType::ConstAffinePart>::type type;
+  EIGEN_DEVICE_FUNC static type run (const TransformType& x) { return x.affine(); }
+};
+
+template<typename Scalar, int Dim, int Options>
+struct take_matrix_for_product<Transform<Scalar, Dim, Projective, Options> >
+{
+  typedef Transform<Scalar, Dim, Projective, Options> TransformType;
+  typedef typename TransformType::MatrixType type;
+  EIGEN_DEVICE_FUNC static const type& run (const TransformType& x) { return x.matrix(); }
+};
+
+template<typename MatrixType,typename Lhs>
+struct traits<homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> >
+{
+  typedef typename take_matrix_for_product<Lhs>::type LhsMatrixType;
+  typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+  typedef typename remove_all<LhsMatrixType>::type LhsMatrixTypeCleaned;
+  typedef typename make_proper_matrix_type<
+                 typename traits<MatrixTypeCleaned>::Scalar,
+                 LhsMatrixTypeCleaned::RowsAtCompileTime,
+                 MatrixTypeCleaned::ColsAtCompileTime,
+                 MatrixTypeCleaned::PlainObject::Options,
+                 LhsMatrixTypeCleaned::MaxRowsAtCompileTime,
+                 MatrixTypeCleaned::MaxColsAtCompileTime>::type ReturnType;
+};
+
+template<typename MatrixType,typename Lhs>
+struct homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs>
+  : public ReturnByValue<homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> >
+{
+  typedef typename traits<homogeneous_left_product_impl>::LhsMatrixType LhsMatrixType;
+  typedef typename remove_all<LhsMatrixType>::type LhsMatrixTypeCleaned;
+  typedef typename remove_all<typename LhsMatrixTypeCleaned::Nested>::type LhsMatrixTypeNested;
+  EIGEN_DEVICE_FUNC homogeneous_left_product_impl(const Lhs& lhs, const MatrixType& rhs)
+    : m_lhs(take_matrix_for_product<Lhs>::run(lhs)),
+      m_rhs(rhs)
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  inline Index rows() const EIGEN_NOEXCEPT { return m_lhs.rows(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  inline Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+  template<typename Dest> EIGEN_DEVICE_FUNC void evalTo(Dest& dst) const
+  {
+    // FIXME investigate how to allow lazy evaluation of this product when possible
+    dst = Block<const LhsMatrixTypeNested,
+              LhsMatrixTypeNested::RowsAtCompileTime,
+              LhsMatrixTypeNested::ColsAtCompileTime==Dynamic?Dynamic:LhsMatrixTypeNested::ColsAtCompileTime-1>
+            (m_lhs,0,0,m_lhs.rows(),m_lhs.cols()-1) * m_rhs;
+    dst += m_lhs.col(m_lhs.cols()-1).rowwise()
+            .template replicate<MatrixType::ColsAtCompileTime>(m_rhs.cols());
+  }
+
+  typename LhsMatrixTypeCleaned::Nested m_lhs;
+  typename MatrixType::Nested m_rhs;
+};
+
+template<typename MatrixType,typename Rhs>
+struct traits<homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> >
+{
+  typedef typename make_proper_matrix_type<typename traits<MatrixType>::Scalar,
+                 MatrixType::RowsAtCompileTime,
+                 Rhs::ColsAtCompileTime,
+                 MatrixType::PlainObject::Options,
+                 MatrixType::MaxRowsAtCompileTime,
+                 Rhs::MaxColsAtCompileTime>::type ReturnType;
+};
+
+template<typename MatrixType,typename Rhs>
+struct homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs>
+  : public ReturnByValue<homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> >
+{
+  typedef typename remove_all<typename Rhs::Nested>::type RhsNested;
+  EIGEN_DEVICE_FUNC homogeneous_right_product_impl(const MatrixType& lhs, const Rhs& rhs)
+    : m_lhs(lhs), m_rhs(rhs)
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index rows() const EIGEN_NOEXCEPT { return m_lhs.rows(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+  template<typename Dest> EIGEN_DEVICE_FUNC void evalTo(Dest& dst) const
+  {
+    // FIXME investigate how to allow lazy evaluation of this product when possible
+    dst = m_lhs * Block<const RhsNested,
+                        RhsNested::RowsAtCompileTime==Dynamic?Dynamic:RhsNested::RowsAtCompileTime-1,
+                        RhsNested::ColsAtCompileTime>
+            (m_rhs,0,0,m_rhs.rows()-1,m_rhs.cols());
+    dst += m_rhs.row(m_rhs.rows()-1).colwise()
+            .template replicate<MatrixType::RowsAtCompileTime>(m_lhs.rows());
+  }
+
+  typename MatrixType::Nested m_lhs;
+  typename Rhs::Nested m_rhs;
+};
+
+template<typename ArgType,int Direction>
+struct evaluator_traits<Homogeneous<ArgType,Direction> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename ArgType::StorageKind>::Kind Kind;
+  typedef HomogeneousShape Shape;
+};
+
+template<> struct AssignmentKind<DenseShape,HomogeneousShape> { typedef Dense2Dense Kind; };
+
+
+template<typename ArgType,int Direction>
+struct unary_evaluator<Homogeneous<ArgType,Direction>, IndexBased>
+  : evaluator<typename Homogeneous<ArgType,Direction>::PlainObject >
+{
+  typedef Homogeneous<ArgType,Direction> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
+    : Base(), m_temp(op)
+  {
+    ::new (static_cast<Base*>(this)) Base(m_temp);
+  }
+
+protected:
+  PlainObject m_temp;
+};
+
+// dense = homogeneous
+template< typename DstXprType, typename ArgType, typename Scalar>
+struct Assignment<DstXprType, Homogeneous<ArgType,Vertical>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense>
+{
+  typedef Homogeneous<ArgType,Vertical> SrcXprType;
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst.template topRows<ArgType::RowsAtCompileTime>(src.nestedExpression().rows()) = src.nestedExpression();
+    dst.row(dst.rows()-1).setOnes();
+  }
+};
+
+// dense = homogeneous
+template< typename DstXprType, typename ArgType, typename Scalar>
+struct Assignment<DstXprType, Homogeneous<ArgType,Horizontal>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense>
+{
+  typedef Homogeneous<ArgType,Horizontal> SrcXprType;
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst.template leftCols<ArgType::ColsAtCompileTime>(src.nestedExpression().cols()) = src.nestedExpression();
+    dst.col(dst.cols()-1).setOnes();
+  }
+};
+
+template<typename LhsArg, typename Rhs, int ProductTag>
+struct generic_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs, HomogeneousShape, DenseShape, ProductTag>
+{
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const Homogeneous<LhsArg,Horizontal>& lhs, const Rhs& rhs)
+  {
+    homogeneous_right_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs>(lhs.nestedExpression(), rhs).evalTo(dst);
+  }
+};
+
+template<typename Lhs,typename Rhs>
+struct homogeneous_right_product_refactoring_helper
+{
+  enum {
+    Dim  = Lhs::ColsAtCompileTime,
+    Rows = Lhs::RowsAtCompileTime
+  };
+  typedef typename Rhs::template ConstNRowsBlockXpr<Dim>::Type          LinearBlockConst;
+  typedef typename remove_const<LinearBlockConst>::type                 LinearBlock;
+  typedef typename Rhs::ConstRowXpr                                     ConstantColumn;
+  typedef Replicate<const ConstantColumn,Rows,1>                        ConstantBlock;
+  typedef Product<Lhs,LinearBlock,LazyProduct>                          LinearProduct;
+  typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, HomogeneousShape, DenseShape>
+ : public evaluator<typename homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs>::Xpr>
+{
+  typedef Product<Lhs, Rhs, LazyProduct> XprType;
+  typedef homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs> helper;
+  typedef typename helper::ConstantBlock ConstantBlock;
+  typedef typename helper::Xpr RefactoredXpr;
+  typedef evaluator<RefactoredXpr> Base;
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(  xpr.lhs().nestedExpression() .lazyProduct(  xpr.rhs().template topRows<helper::Dim>(xpr.lhs().nestedExpression().cols()) )
+            + ConstantBlock(xpr.rhs().row(xpr.rhs().rows()-1),xpr.lhs().rows(), 1) )
+  {}
+};
+
+template<typename Lhs, typename RhsArg, int ProductTag>
+struct generic_product_impl<Lhs, Homogeneous<RhsArg,Vertical>, DenseShape, HomogeneousShape, ProductTag>
+{
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const Lhs& lhs, const Homogeneous<RhsArg,Vertical>& rhs)
+  {
+    homogeneous_left_product_impl<Homogeneous<RhsArg,Vertical>, Lhs>(lhs, rhs.nestedExpression()).evalTo(dst);
+  }
+};
+
+// TODO: the following specialization is to address a regression from 3.2 to 3.3
+// In the future, this path should be optimized.
+template<typename Lhs, typename RhsArg, int ProductTag>
+struct generic_product_impl<Lhs, Homogeneous<RhsArg,Vertical>, TriangularShape, HomogeneousShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Homogeneous<RhsArg,Vertical>& rhs)
+  {
+    dst.noalias() = lhs * rhs.eval();
+  }
+};
+
+template<typename Lhs,typename Rhs>
+struct homogeneous_left_product_refactoring_helper
+{
+  enum {
+    Dim = Rhs::RowsAtCompileTime,
+    Cols = Rhs::ColsAtCompileTime
+  };
+  typedef typename Lhs::template ConstNColsBlockXpr<Dim>::Type          LinearBlockConst;
+  typedef typename remove_const<LinearBlockConst>::type                 LinearBlock;
+  typedef typename Lhs::ConstColXpr                                     ConstantColumn;
+  typedef Replicate<const ConstantColumn,1,Cols>                        ConstantBlock;
+  typedef Product<LinearBlock,Rhs,LazyProduct>                          LinearProduct;
+  typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, HomogeneousShape>
+ : public evaluator<typename homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression>::Xpr>
+{
+  typedef Product<Lhs, Rhs, LazyProduct> XprType;
+  typedef homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression> helper;
+  typedef typename helper::ConstantBlock ConstantBlock;
+  typedef typename helper::Xpr RefactoredXpr;
+  typedef evaluator<RefactoredXpr> Base;
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(   xpr.lhs().template leftCols<helper::Dim>(xpr.rhs().nestedExpression().rows()) .lazyProduct( xpr.rhs().nestedExpression() )
+            + ConstantBlock(xpr.lhs().col(xpr.lhs().cols()-1),1,xpr.rhs().cols()) )
+  {}
+};
+
+template<typename Scalar, int Dim, int Mode,int Options, typename RhsArg, int ProductTag>
+struct generic_product_impl<Transform<Scalar,Dim,Mode,Options>, Homogeneous<RhsArg,Vertical>, DenseShape, HomogeneousShape, ProductTag>
+{
+  typedef Transform<Scalar,Dim,Mode,Options> TransformType;
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const TransformType& lhs, const Homogeneous<RhsArg,Vertical>& rhs)
+  {
+    homogeneous_left_product_impl<Homogeneous<RhsArg,Vertical>, TransformType>(lhs, rhs.nestedExpression()).evalTo(dst);
+  }
+};
+
+template<typename ExpressionType, int Side, bool Transposed>
+struct permutation_matrix_product<ExpressionType, Side, Transposed, HomogeneousShape>
+  : public permutation_matrix_product<ExpressionType, Side, Transposed, DenseShape>
+{};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_HOMOGENEOUS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/Hyperplane.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Hyperplane.h
new file mode 100644
index 00000000..cebe0355
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Hyperplane.h
@@ -0,0 +1,282 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HYPERPLANE_H
+#define EIGEN_HYPERPLANE_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Hyperplane
+  *
+  * \brief A hyperplane
+  *
+  * A hyperplane is an affine subspace of dimension n-1 in a space of dimension n.
+  * For example, a hyperplane in a plane is a line; a hyperplane in 3-space is a plane.
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
+  *             Notice that the dimension of the hyperplane is _AmbientDim-1.
+  *
+  * This class represents an hyperplane as the zero set of the implicit equation
+  * \f$ n \cdot x + d = 0 \f$ where \f$ n \f$ is a unit normal vector of the plane (linear part)
+  * and \f$ d \f$ is the distance (offset) to the origin.
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+class Hyperplane
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
+  enum {
+    AmbientDimAtCompileTime = _AmbientDim,
+    Options = _Options
+  };
+  typedef _Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  typedef Matrix<Scalar,AmbientDimAtCompileTime,1> VectorType;
+  typedef Matrix<Scalar,Index(AmbientDimAtCompileTime)==Dynamic
+                        ? Dynamic
+                        : Index(AmbientDimAtCompileTime)+1,1,Options> Coefficients;
+  typedef Block<Coefficients,AmbientDimAtCompileTime,1> NormalReturnType;
+  typedef const Block<const Coefficients,AmbientDimAtCompileTime,1> ConstNormalReturnType;
+
+  /** Default constructor without initialization */
+  EIGEN_DEVICE_FUNC inline Hyperplane() {}
+  
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC Hyperplane(const Hyperplane<Scalar,AmbientDimAtCompileTime,OtherOptions>& other)
+   : m_coeffs(other.coeffs())
+  {}
+
+  /** Constructs a dynamic-size hyperplane with \a _dim the dimension
+    * of the ambient space */
+  EIGEN_DEVICE_FUNC inline explicit Hyperplane(Index _dim) : m_coeffs(_dim+1) {}
+
+  /** Construct a plane from its normal \a n and a point \a e onto the plane.
+    * \warning the vector normal is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC inline Hyperplane(const VectorType& n, const VectorType& e)
+    : m_coeffs(n.size()+1)
+  {
+    normal() = n;
+    offset() = -n.dot(e);
+  }
+
+  /** Constructs a plane from its normal \a n and distance to the origin \a d
+    * such that the algebraic equation of the plane is \f$ n \cdot x + d = 0 \f$.
+    * \warning the vector normal is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC inline Hyperplane(const VectorType& n, const Scalar& d)
+    : m_coeffs(n.size()+1)
+  {
+    normal() = n;
+    offset() = d;
+  }
+
+  /** Constructs a hyperplane passing through the two points. If the dimension of the ambient space
+    * is greater than 2, then there isn't uniqueness, so an arbitrary choice is made.
+    */
+  EIGEN_DEVICE_FUNC static inline Hyperplane Through(const VectorType& p0, const VectorType& p1)
+  {
+    Hyperplane result(p0.size());
+    result.normal() = (p1 - p0).unitOrthogonal();
+    result.offset() = -p0.dot(result.normal());
+    return result;
+  }
+
+  /** Constructs a hyperplane passing through the three points. The dimension of the ambient space
+    * is required to be exactly 3.
+    */
+  EIGEN_DEVICE_FUNC static inline Hyperplane Through(const VectorType& p0, const VectorType& p1, const VectorType& p2)
+  {
+    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 3)
+    Hyperplane result(p0.size());
+    VectorType v0(p2 - p0), v1(p1 - p0);
+    result.normal() = v0.cross(v1);
+    RealScalar norm = result.normal().norm();
+    if(norm <= v0.norm() * v1.norm() * NumTraits<RealScalar>::epsilon())
+    {
+      Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();
+      JacobiSVD<Matrix<Scalar,2,3> > svd(m, ComputeFullV);
+      result.normal() = svd.matrixV().col(2);
+    }
+    else
+      result.normal() /= norm;
+    result.offset() = -p0.dot(result.normal());
+    return result;
+  }
+
+  /** Constructs a hyperplane passing through the parametrized line \a parametrized.
+    * If the dimension of the ambient space is greater than 2, then there isn't uniqueness,
+    * so an arbitrary choice is made.
+    */
+  // FIXME to be consistent with the rest this could be implemented as a static Through function ??
+  EIGEN_DEVICE_FUNC explicit Hyperplane(const ParametrizedLine<Scalar, AmbientDimAtCompileTime>& parametrized)
+  {
+    normal() = parametrized.direction().unitOrthogonal();
+    offset() = -parametrized.origin().dot(normal());
+  }
+
+  EIGEN_DEVICE_FUNC ~Hyperplane() {}
+
+  /** \returns the dimension in which the plane holds */
+  EIGEN_DEVICE_FUNC inline Index dim() const { return AmbientDimAtCompileTime==Dynamic ? m_coeffs.size()-1 : Index(AmbientDimAtCompileTime); }
+
+  /** normalizes \c *this */
+  EIGEN_DEVICE_FUNC void normalize(void)
+  {
+    m_coeffs /= normal().norm();
+  }
+
+  /** \returns the signed distance between the plane \c *this and a point \a p.
+    * \sa absDistance()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar signedDistance(const VectorType& p) const { return normal().dot(p) + offset(); }
+
+  /** \returns the absolute distance between the plane \c *this and a point \a p.
+    * \sa signedDistance()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar absDistance(const VectorType& p) const { return numext::abs(signedDistance(p)); }
+
+  /** \returns the projection of a point \a p onto the plane \c *this.
+    */
+  EIGEN_DEVICE_FUNC inline VectorType projection(const VectorType& p) const { return p - signedDistance(p) * normal(); }
+
+  /** \returns a constant reference to the unit normal vector of the plane, which corresponds
+    * to the linear part of the implicit equation.
+    */
+  EIGEN_DEVICE_FUNC inline ConstNormalReturnType normal() const { return ConstNormalReturnType(m_coeffs,0,0,dim(),1); }
+
+  /** \returns a non-constant reference to the unit normal vector of the plane, which corresponds
+    * to the linear part of the implicit equation.
+    */
+  EIGEN_DEVICE_FUNC inline NormalReturnType normal() { return NormalReturnType(m_coeffs,0,0,dim(),1); }
+
+  /** \returns the distance to the origin, which is also the "constant term" of the implicit equation
+    * \warning the vector normal is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC inline const Scalar& offset() const { return m_coeffs.coeff(dim()); }
+
+  /** \returns a non-constant reference to the distance to the origin, which is also the constant part
+    * of the implicit equation */
+  EIGEN_DEVICE_FUNC inline Scalar& offset() { return m_coeffs(dim()); }
+
+  /** \returns a constant reference to the coefficients c_i of the plane equation:
+    * \f$ c_0*x_0 + ... + c_{d-1}*x_{d-1} + c_d = 0 \f$
+    */
+  EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs; }
+
+  /** \returns a non-constant reference to the coefficients c_i of the plane equation:
+    * \f$ c_0*x_0 + ... + c_{d-1}*x_{d-1} + c_d = 0 \f$
+    */
+  EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
+
+  /** \returns the intersection of *this with \a other.
+    *
+    * \warning The ambient space must be a plane, i.e. have dimension 2, so that \c *this and \a other are lines.
+    *
+    * \note If \a other is approximately parallel to *this, this method will return any point on *this.
+    */
+  EIGEN_DEVICE_FUNC VectorType intersection(const Hyperplane& other) const
+  {
+    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)
+    Scalar det = coeffs().coeff(0) * other.coeffs().coeff(1) - coeffs().coeff(1) * other.coeffs().coeff(0);
+    // since the line equations ax+by=c are normalized with a^2+b^2=1, the following tests
+    // whether the two lines are approximately parallel.
+    if(internal::isMuchSmallerThan(det, Scalar(1)))
+    {   // special case where the two lines are approximately parallel. Pick any point on the first line.
+        if(numext::abs(coeffs().coeff(1))>numext::abs(coeffs().coeff(0)))
+            return VectorType(coeffs().coeff(1), -coeffs().coeff(2)/coeffs().coeff(1)-coeffs().coeff(0));
+        else
+            return VectorType(-coeffs().coeff(2)/coeffs().coeff(0)-coeffs().coeff(1), coeffs().coeff(0));
+    }
+    else
+    {   // general case
+        Scalar invdet = Scalar(1) / det;
+        return VectorType(invdet*(coeffs().coeff(1)*other.coeffs().coeff(2)-other.coeffs().coeff(1)*coeffs().coeff(2)),
+                          invdet*(other.coeffs().coeff(0)*coeffs().coeff(2)-coeffs().coeff(0)*other.coeffs().coeff(2)));
+    }
+  }
+
+  /** Applies the transformation matrix \a mat to \c *this and returns a reference to \c *this.
+    *
+    * \param mat the Dim x Dim transformation matrix
+    * \param traits specifies whether the matrix \a mat represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    */
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC inline Hyperplane& transform(const MatrixBase<XprType>& mat, TransformTraits traits = Affine)
+  {
+    if (traits==Affine)
+    {
+      normal() = mat.inverse().transpose() * normal();
+      m_coeffs /= normal().norm();
+    }
+    else if (traits==Isometry)
+      normal() = mat * normal();
+    else
+    {
+      eigen_assert(0 && "invalid traits value in Hyperplane::transform()");
+    }
+    return *this;
+  }
+
+  /** Applies the transformation \a t to \c *this and returns a reference to \c *this.
+    *
+    * \param t the transformation of dimension Dim
+    * \param traits specifies whether the transformation \a t represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    *               Other kind of transformations are not supported.
+    */
+  template<int TrOptions>
+  EIGEN_DEVICE_FUNC inline Hyperplane& transform(const Transform<Scalar,AmbientDimAtCompileTime,Affine,TrOptions>& t,
+                                TransformTraits traits = Affine)
+  {
+    transform(t.linear(), traits);
+    offset() -= normal().dot(t.translation());
+    return *this;
+  }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Hyperplane,
+           Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type cast() const
+  {
+    return typename internal::cast_return_type<Hyperplane,
+                    Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type(*this);
+  }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline explicit Hyperplane(const Hyperplane<OtherScalarType,AmbientDimAtCompileTime,OtherOptions>& other)
+  { m_coeffs = other.coeffs().template cast<Scalar>(); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC bool isApprox(const Hyperplane<Scalar,AmbientDimAtCompileTime,OtherOptions>& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_coeffs.isApprox(other.m_coeffs, prec); }
+
+protected:
+
+  Coefficients m_coeffs;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_HYPERPLANE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/OrthoMethods.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/OrthoMethods.h
new file mode 100644
index 00000000..524aebe1
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/OrthoMethods.h
@@ -0,0 +1,235 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ORTHOMETHODS_H
+#define EIGEN_ORTHOMETHODS_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns the cross product of \c *this and \a other
+  *
+  * Here is a very good explanation of cross-product: http://xkcd.com/199/
+  * 
+  * With complex numbers, the cross product is implemented as
+  * \f$ (\mathbf{a}+i\mathbf{b}) \times (\mathbf{c}+i\mathbf{d}) = (\mathbf{a} \times \mathbf{c} - \mathbf{b} \times \mathbf{d}) - i(\mathbf{a} \times \mathbf{d} - \mathbf{b} \times \mathbf{c})\f$
+  * 
+  * \sa MatrixBase::cross3()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename MatrixBase<Derived>::template cross_product_return_type<OtherDerived>::type
+#else
+typename MatrixBase<Derived>::PlainObject
+#endif
+MatrixBase<Derived>::cross(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived,3)
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3)
+
+  // Note that there is no need for an expression here since the compiler
+  // optimize such a small temporary very well (even within a complex expression)
+  typename internal::nested_eval<Derived,2>::type lhs(derived());
+  typename internal::nested_eval<OtherDerived,2>::type rhs(other.derived());
+  return typename cross_product_return_type<OtherDerived>::type(
+    numext::conj(lhs.coeff(1) * rhs.coeff(2) - lhs.coeff(2) * rhs.coeff(1)),
+    numext::conj(lhs.coeff(2) * rhs.coeff(0) - lhs.coeff(0) * rhs.coeff(2)),
+    numext::conj(lhs.coeff(0) * rhs.coeff(1) - lhs.coeff(1) * rhs.coeff(0))
+  );
+}
+
+namespace internal {
+
+template< int Arch,typename VectorLhs,typename VectorRhs,
+          typename Scalar = typename VectorLhs::Scalar,
+          bool Vectorizable = bool((VectorLhs::Flags&VectorRhs::Flags)&PacketAccessBit)>
+struct cross3_impl {
+  EIGEN_DEVICE_FUNC static inline typename internal::plain_matrix_type<VectorLhs>::type
+  run(const VectorLhs& lhs, const VectorRhs& rhs)
+  {
+    return typename internal::plain_matrix_type<VectorLhs>::type(
+      numext::conj(lhs.coeff(1) * rhs.coeff(2) - lhs.coeff(2) * rhs.coeff(1)),
+      numext::conj(lhs.coeff(2) * rhs.coeff(0) - lhs.coeff(0) * rhs.coeff(2)),
+      numext::conj(lhs.coeff(0) * rhs.coeff(1) - lhs.coeff(1) * rhs.coeff(0)),
+      0
+    );
+  }
+};
+
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns the cross product of \c *this and \a other using only the x, y, and z coefficients
+  *
+  * The size of \c *this and \a other must be four. This function is especially useful
+  * when using 4D vectors instead of 3D ones to get advantage of SSE/AltiVec vectorization.
+  *
+  * \sa MatrixBase::cross()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::cross3(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived,4)
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,4)
+
+  typedef typename internal::nested_eval<Derived,2>::type DerivedNested;
+  typedef typename internal::nested_eval<OtherDerived,2>::type OtherDerivedNested;
+  DerivedNested lhs(derived());
+  OtherDerivedNested rhs(other.derived());
+
+  return internal::cross3_impl<Architecture::Target,
+                        typename internal::remove_all<DerivedNested>::type,
+                        typename internal::remove_all<OtherDerivedNested>::type>::run(lhs,rhs);
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns a matrix expression of the cross product of each column or row
+  * of the referenced expression with the \a other vector.
+  *
+  * The referenced matrix must have one dimension equal to 3.
+  * The result matrix has the same dimensions than the referenced one.
+  *
+  * \sa MatrixBase::cross() */
+template<typename ExpressionType, int Direction>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC 
+const typename VectorwiseOp<ExpressionType,Direction>::CrossReturnType
+VectorwiseOp<ExpressionType,Direction>::cross(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  
+  typename internal::nested_eval<ExpressionType,2>::type mat(_expression());
+  typename internal::nested_eval<OtherDerived,2>::type vec(other.derived());
+
+  CrossReturnType res(_expression().rows(),_expression().cols());
+  if(Direction==Vertical)
+  {
+    eigen_assert(CrossReturnType::RowsAtCompileTime==3 && "the matrix must have exactly 3 rows");
+    res.row(0) = (mat.row(1) * vec.coeff(2) - mat.row(2) * vec.coeff(1)).conjugate();
+    res.row(1) = (mat.row(2) * vec.coeff(0) - mat.row(0) * vec.coeff(2)).conjugate();
+    res.row(2) = (mat.row(0) * vec.coeff(1) - mat.row(1) * vec.coeff(0)).conjugate();
+  }
+  else
+  {
+    eigen_assert(CrossReturnType::ColsAtCompileTime==3 && "the matrix must have exactly 3 columns");
+    res.col(0) = (mat.col(1) * vec.coeff(2) - mat.col(2) * vec.coeff(1)).conjugate();
+    res.col(1) = (mat.col(2) * vec.coeff(0) - mat.col(0) * vec.coeff(2)).conjugate();
+    res.col(2) = (mat.col(0) * vec.coeff(1) - mat.col(1) * vec.coeff(0)).conjugate();
+  }
+  return res;
+}
+
+namespace internal {
+
+template<typename Derived, int Size = Derived::SizeAtCompileTime>
+struct unitOrthogonal_selector
+{
+  typedef typename plain_matrix_type<Derived>::type VectorType;
+  typedef typename traits<Derived>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar,2,1> Vector2;
+  EIGEN_DEVICE_FUNC
+  static inline VectorType run(const Derived& src)
+  {
+    VectorType perp = VectorType::Zero(src.size());
+    Index maxi = 0;
+    Index sndi = 0;
+    src.cwiseAbs().maxCoeff(&maxi);
+    if (maxi==0)
+      sndi = 1;
+    RealScalar invnm = RealScalar(1)/(Vector2() << src.coeff(sndi),src.coeff(maxi)).finished().norm();
+    perp.coeffRef(maxi) = -numext::conj(src.coeff(sndi)) * invnm;
+    perp.coeffRef(sndi) =  numext::conj(src.coeff(maxi)) * invnm;
+
+    return perp;
+   }
+};
+
+template<typename Derived>
+struct unitOrthogonal_selector<Derived,3>
+{
+  typedef typename plain_matrix_type<Derived>::type VectorType;
+  typedef typename traits<Derived>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline VectorType run(const Derived& src)
+  {
+    VectorType perp;
+    /* Let us compute the crossed product of *this with a vector
+     * that is not too close to being colinear to *this.
+     */
+
+    /* unless the x and y coords are both close to zero, we can
+     * simply take ( -y, x, 0 ) and normalize it.
+     */
+    if((!isMuchSmallerThan(src.x(), src.z()))
+    || (!isMuchSmallerThan(src.y(), src.z())))
+    {
+      RealScalar invnm = RealScalar(1)/src.template head<2>().norm();
+      perp.coeffRef(0) = -numext::conj(src.y())*invnm;
+      perp.coeffRef(1) = numext::conj(src.x())*invnm;
+      perp.coeffRef(2) = 0;
+    }
+    /* if both x and y are close to zero, then the vector is close
+     * to the z-axis, so it's far from colinear to the x-axis for instance.
+     * So we take the crossed product with (1,0,0) and normalize it.
+     */
+    else
+    {
+      RealScalar invnm = RealScalar(1)/src.template tail<2>().norm();
+      perp.coeffRef(0) = 0;
+      perp.coeffRef(1) = -numext::conj(src.z())*invnm;
+      perp.coeffRef(2) = numext::conj(src.y())*invnm;
+    }
+
+    return perp;
+   }
+};
+
+template<typename Derived>
+struct unitOrthogonal_selector<Derived,2>
+{
+  typedef typename plain_matrix_type<Derived>::type VectorType;
+  EIGEN_DEVICE_FUNC
+  static inline VectorType run(const Derived& src)
+  { return VectorType(-numext::conj(src.y()), numext::conj(src.x())).normalized(); }
+};
+
+} // end namespace internal
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns a unit vector which is orthogonal to \c *this
+  *
+  * The size of \c *this must be at least 2. If the size is exactly 2,
+  * then the returned vector is a counter clock wise rotation of \c *this, i.e., (-y,x).normalized().
+  *
+  * \sa cross()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::unitOrthogonal() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return internal::unitOrthogonal_selector<Derived>::run(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ORTHOMETHODS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/ParametrizedLine.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/ParametrizedLine.h
new file mode 100644
index 00000000..584f5008
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/ParametrizedLine.h
@@ -0,0 +1,232 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARAMETRIZEDLINE_H
+#define EIGEN_PARAMETRIZEDLINE_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class ParametrizedLine
+  *
+  * \brief A parametrized line
+  *
+  * A parametrized line is defined by an origin point \f$ \mathbf{o} \f$ and a unit
+  * direction vector \f$ \mathbf{d} \f$ such that the line corresponds to
+  * the set \f$ l(t) = \mathbf{o} + t \mathbf{d} \f$, \f$ t \in \mathbf{R} \f$.
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+class ParametrizedLine
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
+  enum {
+    AmbientDimAtCompileTime = _AmbientDim,
+    Options = _Options
+  };
+  typedef _Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  typedef Matrix<Scalar,AmbientDimAtCompileTime,1,Options> VectorType;
+
+  /** Default constructor without initialization */
+  EIGEN_DEVICE_FUNC inline ParametrizedLine() {}
+  
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC ParametrizedLine(const ParametrizedLine<Scalar,AmbientDimAtCompileTime,OtherOptions>& other)
+   : m_origin(other.origin()), m_direction(other.direction())
+  {}
+
+  /** Constructs a dynamic-size line with \a _dim the dimension
+    * of the ambient space */
+  EIGEN_DEVICE_FUNC inline explicit ParametrizedLine(Index _dim) : m_origin(_dim), m_direction(_dim) {}
+
+  /** Initializes a parametrized line of direction \a direction and origin \a origin.
+    * \warning the vector direction is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC ParametrizedLine(const VectorType& origin, const VectorType& direction)
+    : m_origin(origin), m_direction(direction) {}
+
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC explicit ParametrizedLine(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane);
+
+  /** Constructs a parametrized line going from \a p0 to \a p1. */
+  EIGEN_DEVICE_FUNC static inline ParametrizedLine Through(const VectorType& p0, const VectorType& p1)
+  { return ParametrizedLine(p0, (p1-p0).normalized()); }
+
+  EIGEN_DEVICE_FUNC ~ParametrizedLine() {}
+
+  /** \returns the dimension in which the line holds */
+  EIGEN_DEVICE_FUNC inline Index dim() const { return m_direction.size(); }
+
+  EIGEN_DEVICE_FUNC const VectorType& origin() const { return m_origin; }
+  EIGEN_DEVICE_FUNC VectorType& origin() { return m_origin; }
+
+  EIGEN_DEVICE_FUNC const VectorType& direction() const { return m_direction; }
+  EIGEN_DEVICE_FUNC VectorType& direction() { return m_direction; }
+
+  /** \returns the squared distance of a point \a p to its projection onto the line \c *this.
+    * \sa distance()
+    */
+  EIGEN_DEVICE_FUNC RealScalar squaredDistance(const VectorType& p) const
+  {
+    VectorType diff = p - origin();
+    return (diff - direction().dot(diff) * direction()).squaredNorm();
+  }
+  /** \returns the distance of a point \a p to its projection onto the line \c *this.
+    * \sa squaredDistance()
+    */
+  EIGEN_DEVICE_FUNC RealScalar distance(const VectorType& p) const { EIGEN_USING_STD(sqrt) return sqrt(squaredDistance(p)); }
+
+  /** \returns the projection of a point \a p onto the line \c *this. */
+  EIGEN_DEVICE_FUNC VectorType projection(const VectorType& p) const
+  { return origin() + direction().dot(p-origin()) * direction(); }
+
+  EIGEN_DEVICE_FUNC VectorType pointAt(const Scalar& t) const;
+  
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC Scalar intersectionParameter(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
+ 
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC Scalar intersection(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
+  
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC VectorType intersectionPoint(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
+
+  /** Applies the transformation matrix \a mat to \c *this and returns a reference to \c *this.
+    *
+    * \param mat the Dim x Dim transformation matrix
+    * \param traits specifies whether the matrix \a mat represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    */
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC inline ParametrizedLine& transform(const MatrixBase<XprType>& mat, TransformTraits traits = Affine)
+  {
+    if (traits==Affine)
+      direction() = (mat * direction()).normalized();
+    else if (traits==Isometry)
+      direction() = mat * direction();
+    else
+    {
+      eigen_assert(0 && "invalid traits value in ParametrizedLine::transform()");
+    }
+    origin() = mat * origin();
+    return *this;
+  }
+
+  /** Applies the transformation \a t to \c *this and returns a reference to \c *this.
+    *
+    * \param t the transformation of dimension Dim
+    * \param traits specifies whether the transformation \a t represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    *               Other kind of transformations are not supported.
+    */
+  template<int TrOptions>
+  EIGEN_DEVICE_FUNC inline ParametrizedLine& transform(const Transform<Scalar,AmbientDimAtCompileTime,Affine,TrOptions>& t,
+                                                       TransformTraits traits = Affine)
+  {
+    transform(t.linear(), traits);
+    origin() += t.translation();
+    return *this;
+  }
+
+/** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<ParametrizedLine,
+           ParametrizedLine<NewScalarType,AmbientDimAtCompileTime,Options> >::type cast() const
+  {
+    return typename internal::cast_return_type<ParametrizedLine,
+                    ParametrizedLine<NewScalarType,AmbientDimAtCompileTime,Options> >::type(*this);
+  }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline explicit ParametrizedLine(const ParametrizedLine<OtherScalarType,AmbientDimAtCompileTime,OtherOptions>& other)
+  {
+    m_origin = other.origin().template cast<Scalar>();
+    m_direction = other.direction().template cast<Scalar>();
+  }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const ParametrizedLine& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_origin.isApprox(other.m_origin, prec) && m_direction.isApprox(other.m_direction, prec); }
+
+protected:
+
+  VectorType m_origin, m_direction;
+};
+
+/** Constructs a parametrized line from a 2D hyperplane
+  *
+  * \warning the ambient space must have dimension 2 such that the hyperplane actually describes a line
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline ParametrizedLine<_Scalar, _AmbientDim,_Options>::ParametrizedLine(const Hyperplane<_Scalar, _AmbientDim,OtherOptions>& hyperplane)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)
+  direction() = hyperplane.normal().unitOrthogonal();
+  origin() = -hyperplane.normal()*hyperplane.offset();
+}
+
+/** \returns the point at \a t along this line
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+EIGEN_DEVICE_FUNC inline typename ParametrizedLine<_Scalar, _AmbientDim,_Options>::VectorType
+ParametrizedLine<_Scalar, _AmbientDim,_Options>::pointAt(const _Scalar& t) const
+{
+  return origin() + (direction()*t); 
+}
+
+/** \returns the parameter value of the intersection between \c *this and the given \a hyperplane
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline _Scalar ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersectionParameter(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
+{
+  return -(hyperplane.offset()+hyperplane.normal().dot(origin()))
+          / hyperplane.normal().dot(direction());
+}
+
+
+/** \deprecated use intersectionParameter()
+  * \returns the parameter value of the intersection between \c *this and the given \a hyperplane
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline _Scalar ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersection(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
+{
+  return intersectionParameter(hyperplane);
+}
+
+/** \returns the point of the intersection between \c *this and the given hyperplane
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline typename ParametrizedLine<_Scalar, _AmbientDim,_Options>::VectorType
+ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersectionPoint(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
+{
+  return pointAt(intersectionParameter(hyperplane));
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARAMETRIZEDLINE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/Quaternion.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Quaternion.h
new file mode 100644
index 00000000..3259e592
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Quaternion.h
@@ -0,0 +1,870 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Mathieu Gautier <mathieu.gautier@cea.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_QUATERNION_H
+#define EIGEN_QUATERNION_H
+namespace Eigen { 
+
+
+/***************************************************************************
+* Definition of QuaternionBase<Derived>
+* The implementation is at the end of the file
+***************************************************************************/
+
+namespace internal {
+template<typename Other,
+         int OtherRows=Other::RowsAtCompileTime,
+         int OtherCols=Other::ColsAtCompileTime>
+struct quaternionbase_assign_impl;
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  * \class QuaternionBase
+  * \brief Base class for quaternion expressions
+  * \tparam Derived derived type (CRTP)
+  * \sa class Quaternion
+  */
+template<class Derived>
+class QuaternionBase : public RotationBase<Derived, 3>
+{
+ public:
+  typedef RotationBase<Derived, 3> Base;
+
+  using Base::operator*;
+  using Base::derived;
+
+  typedef typename internal::traits<Derived>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef typename internal::traits<Derived>::Coefficients Coefficients;
+  typedef typename Coefficients::CoeffReturnType CoeffReturnType;
+  typedef typename internal::conditional<bool(internal::traits<Derived>::Flags&LvalueBit),
+                                        Scalar&, CoeffReturnType>::type NonConstCoeffReturnType;
+
+
+  enum {
+    Flags = Eigen::internal::traits<Derived>::Flags
+  };
+
+ // typedef typename Matrix<Scalar,4,1> Coefficients;
+  /** the type of a 3D vector */
+  typedef Matrix<Scalar,3,1> Vector3;
+  /** the equivalent rotation matrix type */
+  typedef Matrix<Scalar,3,3> Matrix3;
+  /** the equivalent angle-axis type */
+  typedef AngleAxis<Scalar> AngleAxisType;
+
+
+
+  /** \returns the \c x coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType x() const { return this->derived().coeffs().coeff(0); }
+  /** \returns the \c y coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType y() const { return this->derived().coeffs().coeff(1); }
+  /** \returns the \c z coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType z() const { return this->derived().coeffs().coeff(2); }
+  /** \returns the \c w coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType w() const { return this->derived().coeffs().coeff(3); }
+
+  /** \returns a reference to the \c x coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType x() { return this->derived().coeffs().x(); }
+  /** \returns a reference to the \c y coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType y() { return this->derived().coeffs().y(); }
+  /** \returns a reference to the \c z coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType z() { return this->derived().coeffs().z(); }
+  /** \returns a reference to the \c w coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType w() { return this->derived().coeffs().w(); }
+
+  /** \returns a read-only vector expression of the imaginary part (x,y,z) */
+  EIGEN_DEVICE_FUNC inline const VectorBlock<const Coefficients,3> vec() const { return coeffs().template head<3>(); }
+
+  /** \returns a vector expression of the imaginary part (x,y,z) */
+  EIGEN_DEVICE_FUNC inline VectorBlock<Coefficients,3> vec() { return coeffs().template head<3>(); }
+
+  /** \returns a read-only vector expression of the coefficients (x,y,z,w) */
+  EIGEN_DEVICE_FUNC inline const typename internal::traits<Derived>::Coefficients& coeffs() const { return derived().coeffs(); }
+
+  /** \returns a vector expression of the coefficients (x,y,z,w) */
+  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Coefficients& coeffs() { return derived().coeffs(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE QuaternionBase<Derived>& operator=(const QuaternionBase<Derived>& other);
+  template<class OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const QuaternionBase<OtherDerived>& other);
+
+// disabled this copy operator as it is giving very strange compilation errors when compiling
+// test_stdvector with GCC 4.4.2. This looks like a GCC bug though, so feel free to re-enable it if it's
+// useful; however notice that we already have the templated operator= above and e.g. in MatrixBase
+// we didn't have to add, in addition to templated operator=, such a non-templated copy operator.
+//  Derived& operator=(const QuaternionBase& other)
+//  { return operator=<Derived>(other); }
+
+  EIGEN_DEVICE_FUNC Derived& operator=(const AngleAxisType& aa);
+  template<class OtherDerived> EIGEN_DEVICE_FUNC Derived& operator=(const MatrixBase<OtherDerived>& m);
+
+  /** \returns a quaternion representing an identity rotation
+    * \sa MatrixBase::Identity()
+    */
+  EIGEN_DEVICE_FUNC static inline Quaternion<Scalar> Identity() { return Quaternion<Scalar>(Scalar(1), Scalar(0), Scalar(0), Scalar(0)); }
+
+  /** \sa QuaternionBase::Identity(), MatrixBase::setIdentity()
+    */
+  EIGEN_DEVICE_FUNC inline QuaternionBase& setIdentity() { coeffs() << Scalar(0), Scalar(0), Scalar(0), Scalar(1); return *this; }
+
+  /** \returns the squared norm of the quaternion's coefficients
+    * \sa QuaternionBase::norm(), MatrixBase::squaredNorm()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar squaredNorm() const { return coeffs().squaredNorm(); }
+
+  /** \returns the norm of the quaternion's coefficients
+    * \sa QuaternionBase::squaredNorm(), MatrixBase::norm()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar norm() const { return coeffs().norm(); }
+
+  /** Normalizes the quaternion \c *this
+    * \sa normalized(), MatrixBase::normalize() */
+  EIGEN_DEVICE_FUNC inline void normalize() { coeffs().normalize(); }
+  /** \returns a normalized copy of \c *this
+    * \sa normalize(), MatrixBase::normalized() */
+  EIGEN_DEVICE_FUNC inline Quaternion<Scalar> normalized() const { return Quaternion<Scalar>(coeffs().normalized()); }
+
+    /** \returns the dot product of \c *this and \a other
+    * Geometrically speaking, the dot product of two unit quaternions
+    * corresponds to the cosine of half the angle between the two rotations.
+    * \sa angularDistance()
+    */
+  template<class OtherDerived> EIGEN_DEVICE_FUNC inline Scalar dot(const QuaternionBase<OtherDerived>& other) const { return coeffs().dot(other.coeffs()); }
+
+  template<class OtherDerived> EIGEN_DEVICE_FUNC Scalar angularDistance(const QuaternionBase<OtherDerived>& other) const;
+
+  /** \returns an equivalent 3x3 rotation matrix */
+  EIGEN_DEVICE_FUNC inline Matrix3 toRotationMatrix() const;
+
+  /** \returns the quaternion which transform \a a into \a b through a rotation */
+  template<typename Derived1, typename Derived2>
+  EIGEN_DEVICE_FUNC Derived& setFromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b);
+
+  template<class OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion<Scalar> operator* (const QuaternionBase<OtherDerived>& q) const;
+  template<class OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator*= (const QuaternionBase<OtherDerived>& q);
+
+  /** \returns the quaternion describing the inverse rotation */
+  EIGEN_DEVICE_FUNC Quaternion<Scalar> inverse() const;
+
+  /** \returns the conjugated quaternion */
+  EIGEN_DEVICE_FUNC Quaternion<Scalar> conjugate() const;
+
+  template<class OtherDerived> EIGEN_DEVICE_FUNC Quaternion<Scalar> slerp(const Scalar& t, const QuaternionBase<OtherDerived>& other) const;
+
+  /** \returns true if each coefficients of \c *this and \a other are all exactly equal.
+    * \warning When using floating point scalar values you probably should rather use a
+    *          fuzzy comparison such as isApprox()
+    * \sa isApprox(), operator!= */
+  template<class OtherDerived>
+  EIGEN_DEVICE_FUNC inline bool operator==(const QuaternionBase<OtherDerived>& other) const
+  { return coeffs() == other.coeffs(); }
+
+  /** \returns true if at least one pair of coefficients of \c *this and \a other are not exactly equal to each other.
+    * \warning When using floating point scalar values you probably should rather use a
+    *          fuzzy comparison such as isApprox()
+    * \sa isApprox(), operator== */
+  template<class OtherDerived>
+  EIGEN_DEVICE_FUNC inline bool operator!=(const QuaternionBase<OtherDerived>& other) const
+  { return coeffs() != other.coeffs(); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  template<class OtherDerived>
+  EIGEN_DEVICE_FUNC bool isApprox(const QuaternionBase<OtherDerived>& other, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return coeffs().isApprox(other.coeffs(), prec); }
+
+  /** return the result vector of \a v through the rotation*/
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Vector3 _transformVector(const Vector3& v) const;
+
+  #ifdef EIGEN_PARSED_BY_DOXYGEN
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Derived,Quaternion<NewScalarType> >::type cast() const;
+
+  #else
+
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline
+  typename internal::enable_if<internal::is_same<Scalar,NewScalarType>::value,const Derived&>::type cast() const
+  {
+    return derived();
+  }
+
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline
+  typename internal::enable_if<!internal::is_same<Scalar,NewScalarType>::value,Quaternion<NewScalarType> >::type cast() const
+  {
+    return Quaternion<NewScalarType>(coeffs().template cast<NewScalarType>());
+  }
+  #endif
+
+#ifndef EIGEN_NO_IO
+  friend std::ostream& operator<<(std::ostream& s, const QuaternionBase<Derived>& q) {
+    s << q.x() << "i + " << q.y() << "j + " << q.z() << "k" << " + " << q.w();
+    return s;
+  }
+#endif
+
+#ifdef EIGEN_QUATERNIONBASE_PLUGIN
+# include EIGEN_QUATERNIONBASE_PLUGIN
+#endif
+protected:
+  EIGEN_DEFAULT_COPY_CONSTRUCTOR(QuaternionBase)
+  EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(QuaternionBase)
+};
+
+/***************************************************************************
+* Definition/implementation of Quaternion<Scalar>
+***************************************************************************/
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Quaternion
+  *
+  * \brief The quaternion class used to represent 3D orientations and rotations
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _Options controls the memory alignment of the coefficients. Can be \# AutoAlign or \# DontAlign. Default is AutoAlign.
+  *
+  * This class represents a quaternion \f$ w+xi+yj+zk \f$ that is a convenient representation of
+  * orientations and rotations of objects in three dimensions. Compared to other representations
+  * like Euler angles or 3x3 matrices, quaternions offer the following advantages:
+  * \li \b compact storage (4 scalars)
+  * \li \b efficient to compose (28 flops),
+  * \li \b stable spherical interpolation
+  *
+  * The following two typedefs are provided for convenience:
+  * \li \c Quaternionf for \c float
+  * \li \c Quaterniond for \c double
+  *
+  * \warning Operations interpreting the quaternion as rotation have undefined behavior if the quaternion is not normalized.
+  *
+  * \sa  class AngleAxis, class Transform
+  */
+
+namespace internal {
+template<typename _Scalar,int _Options>
+struct traits<Quaternion<_Scalar,_Options> >
+{
+  typedef Quaternion<_Scalar,_Options> PlainObject;
+  typedef _Scalar Scalar;
+  typedef Matrix<_Scalar,4,1,_Options> Coefficients;
+  enum{
+    Alignment = internal::traits<Coefficients>::Alignment,
+    Flags = LvalueBit
+  };
+};
+}
+
+template<typename _Scalar, int _Options>
+class Quaternion : public QuaternionBase<Quaternion<_Scalar,_Options> >
+{
+public:
+  typedef QuaternionBase<Quaternion<_Scalar,_Options> > Base;
+  enum { NeedsAlignment = internal::traits<Quaternion>::Alignment>0 };
+
+  typedef _Scalar Scalar;
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Quaternion)
+  using Base::operator*=;
+
+  typedef typename internal::traits<Quaternion>::Coefficients Coefficients;
+  typedef typename Base::AngleAxisType AngleAxisType;
+
+  /** Default constructor leaving the quaternion uninitialized. */
+  EIGEN_DEVICE_FUNC inline Quaternion() {}
+
+  /** Constructs and initializes the quaternion \f$ w+xi+yj+zk \f$ from
+    * its four coefficients \a w, \a x, \a y and \a z.
+    *
+    * \warning Note the order of the arguments: the real \a w coefficient first,
+    * while internally the coefficients are stored in the following order:
+    * [\c x, \c y, \c z, \c w]
+    */
+  EIGEN_DEVICE_FUNC inline Quaternion(const Scalar& w, const Scalar& x, const Scalar& y, const Scalar& z) : m_coeffs(x, y, z, w){}
+
+  /** Constructs and initialize a quaternion from the array data */
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const Scalar* data) : m_coeffs(data) {}
+
+  /** Copy constructor */
+  template<class Derived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion(const QuaternionBase<Derived>& other) { this->Base::operator=(other); }
+
+  /** Constructs and initializes a quaternion from the angle-axis \a aa */
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const AngleAxisType& aa) { *this = aa; }
+
+  /** Constructs and initializes a quaternion from either:
+    *  - a rotation matrix expression,
+    *  - a 4D vector expression representing quaternion coefficients.
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const MatrixBase<Derived>& other) { *this = other; }
+
+  /** Explicit copy constructor with scalar conversion */
+  template<typename OtherScalar, int OtherOptions>
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const Quaternion<OtherScalar, OtherOptions>& other)
+  { m_coeffs = other.coeffs().template cast<Scalar>(); }
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+  // We define a copy constructor, which means we don't get an implicit move constructor or assignment operator.
+  /** Default move constructor */
+  EIGEN_DEVICE_FUNC inline Quaternion(Quaternion&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible<Scalar>::value)
+    : m_coeffs(std::move(other.coeffs()))
+  {}
+
+  /** Default move assignment operator */
+  EIGEN_DEVICE_FUNC Quaternion& operator=(Quaternion&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
+  {
+    m_coeffs = std::move(other.coeffs());
+    return *this;
+  }
+#endif
+
+  EIGEN_DEVICE_FUNC static Quaternion UnitRandom();
+
+  template<typename Derived1, typename Derived2>
+  EIGEN_DEVICE_FUNC static Quaternion FromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b);
+
+  EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs;}
+  EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs;}
+
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(bool(NeedsAlignment))
+  
+#ifdef EIGEN_QUATERNION_PLUGIN
+# include EIGEN_QUATERNION_PLUGIN
+#endif
+
+protected:
+  Coefficients m_coeffs;
+  
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    static EIGEN_STRONG_INLINE void _check_template_params()
+    {
+      EIGEN_STATIC_ASSERT( (_Options & DontAlign) == _Options,
+        INVALID_MATRIX_TEMPLATE_PARAMETERS)
+    }
+#endif
+};
+
+/** \ingroup Geometry_Module
+  * single precision quaternion type */
+typedef Quaternion<float> Quaternionf;
+/** \ingroup Geometry_Module
+  * double precision quaternion type */
+typedef Quaternion<double> Quaterniond;
+
+/***************************************************************************
+* Specialization of Map<Quaternion<Scalar>>
+***************************************************************************/
+
+namespace internal {
+  template<typename _Scalar, int _Options>
+  struct traits<Map<Quaternion<_Scalar>, _Options> > : traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> >
+  {
+    typedef Map<Matrix<_Scalar,4,1>, _Options> Coefficients;
+  };
+}
+
+namespace internal {
+  template<typename _Scalar, int _Options>
+  struct traits<Map<const Quaternion<_Scalar>, _Options> > : traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> >
+  {
+    typedef Map<const Matrix<_Scalar,4,1>, _Options> Coefficients;
+    typedef traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> > TraitsBase;
+    enum {
+      Flags = TraitsBase::Flags & ~LvalueBit
+    };
+  };
+}
+
+/** \ingroup Geometry_Module
+  * \brief Quaternion expression mapping a constant memory buffer
+  *
+  * \tparam _Scalar the type of the Quaternion coefficients
+  * \tparam _Options see class Map
+  *
+  * This is a specialization of class Map for Quaternion. This class allows to view
+  * a 4 scalar memory buffer as an Eigen's Quaternion object.
+  *
+  * \sa class Map, class Quaternion, class QuaternionBase
+  */
+template<typename _Scalar, int _Options>
+class Map<const Quaternion<_Scalar>, _Options >
+  : public QuaternionBase<Map<const Quaternion<_Scalar>, _Options> >
+{
+  public:
+    typedef QuaternionBase<Map<const Quaternion<_Scalar>, _Options> > Base;
+
+    typedef _Scalar Scalar;
+    typedef typename internal::traits<Map>::Coefficients Coefficients;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
+    using Base::operator*=;
+
+    /** Constructs a Mapped Quaternion object from the pointer \a coeffs
+      *
+      * The pointer \a coeffs must reference the four coefficients of Quaternion in the following order:
+      * \code *coeffs == {x, y, z, w} \endcode
+      *
+      * If the template parameter _Options is set to #Aligned, then the pointer coeffs must be aligned. */
+    EIGEN_DEVICE_FUNC explicit EIGEN_STRONG_INLINE Map(const Scalar* coeffs) : m_coeffs(coeffs) {}
+
+    EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs;}
+
+  protected:
+    const Coefficients m_coeffs;
+};
+
+/** \ingroup Geometry_Module
+  * \brief Expression of a quaternion from a memory buffer
+  *
+  * \tparam _Scalar the type of the Quaternion coefficients
+  * \tparam _Options see class Map
+  *
+  * This is a specialization of class Map for Quaternion. This class allows to view
+  * a 4 scalar memory buffer as an Eigen's  Quaternion object.
+  *
+  * \sa class Map, class Quaternion, class QuaternionBase
+  */
+template<typename _Scalar, int _Options>
+class Map<Quaternion<_Scalar>, _Options >
+  : public QuaternionBase<Map<Quaternion<_Scalar>, _Options> >
+{
+  public:
+    typedef QuaternionBase<Map<Quaternion<_Scalar>, _Options> > Base;
+
+    typedef _Scalar Scalar;
+    typedef typename internal::traits<Map>::Coefficients Coefficients;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
+    using Base::operator*=;
+
+    /** Constructs a Mapped Quaternion object from the pointer \a coeffs
+      *
+      * The pointer \a coeffs must reference the four coefficients of Quaternion in the following order:
+      * \code *coeffs == {x, y, z, w} \endcode
+      *
+      * If the template parameter _Options is set to #Aligned, then the pointer coeffs must be aligned. */
+    EIGEN_DEVICE_FUNC explicit EIGEN_STRONG_INLINE Map(Scalar* coeffs) : m_coeffs(coeffs) {}
+
+    EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
+    EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs; }
+
+  protected:
+    Coefficients m_coeffs;
+};
+
+/** \ingroup Geometry_Module
+  * Map an unaligned array of single precision scalars as a quaternion */
+typedef Map<Quaternion<float>, 0>         QuaternionMapf;
+/** \ingroup Geometry_Module
+  * Map an unaligned array of double precision scalars as a quaternion */
+typedef Map<Quaternion<double>, 0>        QuaternionMapd;
+/** \ingroup Geometry_Module
+  * Map a 16-byte aligned array of single precision scalars as a quaternion */
+typedef Map<Quaternion<float>, Aligned>   QuaternionMapAlignedf;
+/** \ingroup Geometry_Module
+  * Map a 16-byte aligned array of double precision scalars as a quaternion */
+typedef Map<Quaternion<double>, Aligned>  QuaternionMapAlignedd;
+
+/***************************************************************************
+* Implementation of QuaternionBase methods
+***************************************************************************/
+
+// Generic Quaternion * Quaternion product
+// This product can be specialized for a given architecture via the Arch template argument.
+namespace internal {
+template<int Arch, class Derived1, class Derived2, typename Scalar> struct quat_product
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Quaternion<Scalar> run(const QuaternionBase<Derived1>& a, const QuaternionBase<Derived2>& b){
+    return Quaternion<Scalar>
+    (
+      a.w() * b.w() - a.x() * b.x() - a.y() * b.y() - a.z() * b.z(),
+      a.w() * b.x() + a.x() * b.w() + a.y() * b.z() - a.z() * b.y(),
+      a.w() * b.y() + a.y() * b.w() + a.z() * b.x() - a.x() * b.z(),
+      a.w() * b.z() + a.z() * b.w() + a.x() * b.y() - a.y() * b.x()
+    );
+  }
+};
+}
+
+/** \returns the concatenation of two rotations as a quaternion-quaternion product */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion<typename internal::traits<Derived>::Scalar>
+QuaternionBase<Derived>::operator* (const QuaternionBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<typename Derived::Scalar, typename OtherDerived::Scalar>::value),
+   YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  return internal::quat_product<Architecture::Target, Derived, OtherDerived,
+                         typename internal::traits<Derived>::Scalar>::run(*this, other);
+}
+
+/** \sa operator*(Quaternion) */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator*= (const QuaternionBase<OtherDerived>& other)
+{
+  derived() = derived() * other.derived();
+  return derived();
+}
+
+/** Rotation of a vector by a quaternion.
+  * \remarks If the quaternion is used to rotate several points (>1)
+  * then it is much more efficient to first convert it to a 3x3 Matrix.
+  * Comparison of the operation cost for n transformations:
+  *   - Quaternion2:    30n
+  *   - Via a Matrix3: 24 + 15n
+  */
+template <class Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename QuaternionBase<Derived>::Vector3
+QuaternionBase<Derived>::_transformVector(const Vector3& v) const
+{
+    // Note that this algorithm comes from the optimization by hand
+    // of the conversion to a Matrix followed by a Matrix/Vector product.
+    // It appears to be much faster than the common algorithm found
+    // in the literature (30 versus 39 flops). It also requires two
+    // Vector3 as temporaries.
+    Vector3 uv = this->vec().cross(v);
+    uv += uv;
+    return v + this->w() * uv + this->vec().cross(uv);
+}
+
+template<class Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE QuaternionBase<Derived>& QuaternionBase<Derived>::operator=(const QuaternionBase<Derived>& other)
+{
+  coeffs() = other.coeffs();
+  return derived();
+}
+
+template<class Derived>
+template<class OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator=(const QuaternionBase<OtherDerived>& other)
+{
+  coeffs() = other.coeffs();
+  return derived();
+}
+
+/** Set \c *this from an angle-axis \a aa and returns a reference to \c *this
+  */
+template<class Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator=(const AngleAxisType& aa)
+{
+  EIGEN_USING_STD(cos)
+  EIGEN_USING_STD(sin)
+  Scalar ha = Scalar(0.5)*aa.angle(); // Scalar(0.5) to suppress precision loss warnings
+  this->w() = cos(ha);
+  this->vec() = sin(ha) * aa.axis();
+  return derived();
+}
+
+/** Set \c *this from the expression \a xpr:
+  *   - if \a xpr is a 4x1 vector, then \a xpr is assumed to be a quaternion
+  *   - if \a xpr is a 3x3 matrix, then \a xpr is assumed to be rotation matrix
+  *     and \a xpr is converted to a quaternion
+  */
+
+template<class Derived>
+template<class MatrixDerived>
+EIGEN_DEVICE_FUNC inline Derived& QuaternionBase<Derived>::operator=(const MatrixBase<MatrixDerived>& xpr)
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<typename Derived::Scalar, typename MatrixDerived::Scalar>::value),
+   YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  internal::quaternionbase_assign_impl<MatrixDerived>::run(*this, xpr.derived());
+  return derived();
+}
+
+/** Convert the quaternion to a 3x3 rotation matrix. The quaternion is required to
+  * be normalized, otherwise the result is undefined.
+  */
+template<class Derived>
+EIGEN_DEVICE_FUNC inline typename QuaternionBase<Derived>::Matrix3
+QuaternionBase<Derived>::toRotationMatrix(void) const
+{
+  // NOTE if inlined, then gcc 4.2 and 4.4 get rid of the temporary (not gcc 4.3 !!)
+  // if not inlined then the cost of the return by value is huge ~ +35%,
+  // however, not inlining this function is an order of magnitude slower, so
+  // it has to be inlined, and so the return by value is not an issue
+  Matrix3 res;
+
+  const Scalar tx  = Scalar(2)*this->x();
+  const Scalar ty  = Scalar(2)*this->y();
+  const Scalar tz  = Scalar(2)*this->z();
+  const Scalar twx = tx*this->w();
+  const Scalar twy = ty*this->w();
+  const Scalar twz = tz*this->w();
+  const Scalar txx = tx*this->x();
+  const Scalar txy = ty*this->x();
+  const Scalar txz = tz*this->x();
+  const Scalar tyy = ty*this->y();
+  const Scalar tyz = tz*this->y();
+  const Scalar tzz = tz*this->z();
+
+  res.coeffRef(0,0) = Scalar(1)-(tyy+tzz);
+  res.coeffRef(0,1) = txy-twz;
+  res.coeffRef(0,2) = txz+twy;
+  res.coeffRef(1,0) = txy+twz;
+  res.coeffRef(1,1) = Scalar(1)-(txx+tzz);
+  res.coeffRef(1,2) = tyz-twx;
+  res.coeffRef(2,0) = txz-twy;
+  res.coeffRef(2,1) = tyz+twx;
+  res.coeffRef(2,2) = Scalar(1)-(txx+tyy);
+
+  return res;
+}
+
+/** Sets \c *this to be a quaternion representing a rotation between
+  * the two arbitrary vectors \a a and \a b. In other words, the built
+  * rotation represent a rotation sending the line of direction \a a
+  * to the line of direction \a b, both lines passing through the origin.
+  *
+  * \returns a reference to \c *this.
+  *
+  * Note that the two input vectors do \b not have to be normalized, and
+  * do not need to have the same norm.
+  */
+template<class Derived>
+template<typename Derived1, typename Derived2>
+EIGEN_DEVICE_FUNC inline Derived& QuaternionBase<Derived>::setFromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b)
+{
+  EIGEN_USING_STD(sqrt)
+  Vector3 v0 = a.normalized();
+  Vector3 v1 = b.normalized();
+  Scalar c = v1.dot(v0);
+
+  // if dot == -1, vectors are nearly opposites
+  // => accurately compute the rotation axis by computing the
+  //    intersection of the two planes. This is done by solving:
+  //       x^T v0 = 0
+  //       x^T v1 = 0
+  //    under the constraint:
+  //       ||x|| = 1
+  //    which yields a singular value problem
+  if (c < Scalar(-1)+NumTraits<Scalar>::dummy_precision())
+  {
+    c = numext::maxi(c,Scalar(-1));
+    Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();
+    JacobiSVD<Matrix<Scalar,2,3> > svd(m, ComputeFullV);
+    Vector3 axis = svd.matrixV().col(2);
+
+    Scalar w2 = (Scalar(1)+c)*Scalar(0.5);
+    this->w() = sqrt(w2);
+    this->vec() = axis * sqrt(Scalar(1) - w2);
+    return derived();
+  }
+  Vector3 axis = v0.cross(v1);
+  Scalar s = sqrt((Scalar(1)+c)*Scalar(2));
+  Scalar invs = Scalar(1)/s;
+  this->vec() = axis * invs;
+  this->w() = s * Scalar(0.5);
+
+  return derived();
+}
+
+/** \returns a random unit quaternion following a uniform distribution law on SO(3)
+  *
+  * \note The implementation is based on http://planning.cs.uiuc.edu/node198.html
+  */
+template<typename Scalar, int Options>
+EIGEN_DEVICE_FUNC Quaternion<Scalar,Options> Quaternion<Scalar,Options>::UnitRandom()
+{
+  EIGEN_USING_STD(sqrt)
+  EIGEN_USING_STD(sin)
+  EIGEN_USING_STD(cos)
+  const Scalar u1 = internal::random<Scalar>(0, 1),
+               u2 = internal::random<Scalar>(0, 2*EIGEN_PI),
+               u3 = internal::random<Scalar>(0, 2*EIGEN_PI);
+  const Scalar a = sqrt(Scalar(1) - u1),
+               b = sqrt(u1);
+  return Quaternion (a * sin(u2), a * cos(u2), b * sin(u3), b * cos(u3));
+}
+
+
+/** Returns a quaternion representing a rotation between
+  * the two arbitrary vectors \a a and \a b. In other words, the built
+  * rotation represent a rotation sending the line of direction \a a
+  * to the line of direction \a b, both lines passing through the origin.
+  *
+  * \returns resulting quaternion
+  *
+  * Note that the two input vectors do \b not have to be normalized, and
+  * do not need to have the same norm.
+  */
+template<typename Scalar, int Options>
+template<typename Derived1, typename Derived2>
+EIGEN_DEVICE_FUNC Quaternion<Scalar,Options> Quaternion<Scalar,Options>::FromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b)
+{
+    Quaternion quat;
+    quat.setFromTwoVectors(a, b);
+    return quat;
+}
+
+
+/** \returns the multiplicative inverse of \c *this
+  * Note that in most cases, i.e., if you simply want the opposite rotation,
+  * and/or the quaternion is normalized, then it is enough to use the conjugate.
+  *
+  * \sa QuaternionBase::conjugate()
+  */
+template <class Derived>
+EIGEN_DEVICE_FUNC inline Quaternion<typename internal::traits<Derived>::Scalar> QuaternionBase<Derived>::inverse() const
+{
+  // FIXME should this function be called multiplicativeInverse and conjugate() be called inverse() or opposite()  ??
+  Scalar n2 = this->squaredNorm();
+  if (n2 > Scalar(0))
+    return Quaternion<Scalar>(conjugate().coeffs() / n2);
+  else
+  {
+    // return an invalid result to flag the error
+    return Quaternion<Scalar>(Coefficients::Zero());
+  }
+}
+
+// Generic conjugate of a Quaternion
+namespace internal {
+template<int Arch, class Derived, typename Scalar> struct quat_conj
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Quaternion<Scalar> run(const QuaternionBase<Derived>& q){
+    return Quaternion<Scalar>(q.w(),-q.x(),-q.y(),-q.z());
+  }
+};
+}
+                         
+/** \returns the conjugate of the \c *this which is equal to the multiplicative inverse
+  * if the quaternion is normalized.
+  * The conjugate of a quaternion represents the opposite rotation.
+  *
+  * \sa Quaternion2::inverse()
+  */
+template <class Derived>
+EIGEN_DEVICE_FUNC inline Quaternion<typename internal::traits<Derived>::Scalar>
+QuaternionBase<Derived>::conjugate() const
+{
+  return internal::quat_conj<Architecture::Target, Derived,
+                         typename internal::traits<Derived>::Scalar>::run(*this);
+                         
+}
+
+/** \returns the angle (in radian) between two rotations
+  * \sa dot()
+  */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar
+QuaternionBase<Derived>::angularDistance(const QuaternionBase<OtherDerived>& other) const
+{
+  EIGEN_USING_STD(atan2)
+  Quaternion<Scalar> d = (*this) * other.conjugate();
+  return Scalar(2) * atan2( d.vec().norm(), numext::abs(d.w()) );
+}
+
+ 
+    
+/** \returns the spherical linear interpolation between the two quaternions
+  * \c *this and \a other at the parameter \a t in [0;1].
+  * 
+  * This represents an interpolation for a constant motion between \c *this and \a other,
+  * see also http://en.wikipedia.org/wiki/Slerp.
+  */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar>
+QuaternionBase<Derived>::slerp(const Scalar& t, const QuaternionBase<OtherDerived>& other) const
+{
+  EIGEN_USING_STD(acos)
+  EIGEN_USING_STD(sin)
+  const Scalar one = Scalar(1) - NumTraits<Scalar>::epsilon();
+  Scalar d = this->dot(other);
+  Scalar absD = numext::abs(d);
+
+  Scalar scale0;
+  Scalar scale1;
+
+  if(absD>=one)
+  {
+    scale0 = Scalar(1) - t;
+    scale1 = t;
+  }
+  else
+  {
+    // theta is the angle between the 2 quaternions
+    Scalar theta = acos(absD);
+    Scalar sinTheta = sin(theta);
+
+    scale0 = sin( ( Scalar(1) - t ) * theta) / sinTheta;
+    scale1 = sin( ( t * theta) ) / sinTheta;
+  }
+  if(d<Scalar(0)) scale1 = -scale1;
+
+  return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());
+}
+
+namespace internal {
+
+// set from a rotation matrix
+template<typename Other>
+struct quaternionbase_assign_impl<Other,3,3>
+{
+  typedef typename Other::Scalar Scalar;
+  template<class Derived> EIGEN_DEVICE_FUNC static inline void run(QuaternionBase<Derived>& q, const Other& a_mat)
+  {
+    const typename internal::nested_eval<Other,2>::type mat(a_mat);
+    EIGEN_USING_STD(sqrt)
+    // This algorithm comes from  "Quaternion Calculus and Fast Animation",
+    // Ken Shoemake, 1987 SIGGRAPH course notes
+    Scalar t = mat.trace();
+    if (t > Scalar(0))
+    {
+      t = sqrt(t + Scalar(1.0));
+      q.w() = Scalar(0.5)*t;
+      t = Scalar(0.5)/t;
+      q.x() = (mat.coeff(2,1) - mat.coeff(1,2)) * t;
+      q.y() = (mat.coeff(0,2) - mat.coeff(2,0)) * t;
+      q.z() = (mat.coeff(1,0) - mat.coeff(0,1)) * t;
+    }
+    else
+    {
+      Index i = 0;
+      if (mat.coeff(1,1) > mat.coeff(0,0))
+        i = 1;
+      if (mat.coeff(2,2) > mat.coeff(i,i))
+        i = 2;
+      Index j = (i+1)%3;
+      Index k = (j+1)%3;
+
+      t = sqrt(mat.coeff(i,i)-mat.coeff(j,j)-mat.coeff(k,k) + Scalar(1.0));
+      q.coeffs().coeffRef(i) = Scalar(0.5) * t;
+      t = Scalar(0.5)/t;
+      q.w() = (mat.coeff(k,j)-mat.coeff(j,k))*t;
+      q.coeffs().coeffRef(j) = (mat.coeff(j,i)+mat.coeff(i,j))*t;
+      q.coeffs().coeffRef(k) = (mat.coeff(k,i)+mat.coeff(i,k))*t;
+    }
+  }
+};
+
+// set from a vector of coefficients assumed to be a quaternion
+template<typename Other>
+struct quaternionbase_assign_impl<Other,4,1>
+{
+  typedef typename Other::Scalar Scalar;
+  template<class Derived> EIGEN_DEVICE_FUNC static inline void run(QuaternionBase<Derived>& q, const Other& vec)
+  {
+    q.coeffs() = vec;
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_QUATERNION_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/Rotation2D.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Rotation2D.h
new file mode 100644
index 00000000..d0bd5756
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Rotation2D.h
@@ -0,0 +1,199 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ROTATION2D_H
+#define EIGEN_ROTATION2D_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Rotation2D
+  *
+  * \brief Represents a rotation/orientation in a 2 dimensional space.
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  *
+  * This class is equivalent to a single scalar representing a counter clock wise rotation
+  * as a single angle in radian. It provides some additional features such as the automatic
+  * conversion from/to a 2x2 rotation matrix. Moreover this class aims to provide a similar
+  * interface to Quaternion in order to facilitate the writing of generic algorithms
+  * dealing with rotations.
+  *
+  * \sa class Quaternion, class Transform
+  */
+
+namespace internal {
+
+template<typename _Scalar> struct traits<Rotation2D<_Scalar> >
+{
+  typedef _Scalar Scalar;
+};
+} // end namespace internal
+
+template<typename _Scalar>
+class Rotation2D : public RotationBase<Rotation2D<_Scalar>,2>
+{
+  typedef RotationBase<Rotation2D<_Scalar>,2> Base;
+
+public:
+
+  using Base::operator*;
+
+  enum { Dim = 2 };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  typedef Matrix<Scalar,2,1> Vector2;
+  typedef Matrix<Scalar,2,2> Matrix2;
+
+protected:
+
+  Scalar m_angle;
+
+public:
+
+  /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */
+  EIGEN_DEVICE_FUNC explicit inline Rotation2D(const Scalar& a) : m_angle(a) {}
+  
+  /** Default constructor wihtout initialization. The represented rotation is undefined. */
+  EIGEN_DEVICE_FUNC Rotation2D() {}
+
+  /** Construct a 2D rotation from a 2x2 rotation matrix \a mat.
+    *
+    * \sa fromRotationMatrix()
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC explicit Rotation2D(const MatrixBase<Derived>& m)
+  {
+    fromRotationMatrix(m.derived());
+  }
+
+  /** \returns the rotation angle */
+  EIGEN_DEVICE_FUNC inline Scalar angle() const { return m_angle; }
+
+  /** \returns a read-write reference to the rotation angle */
+  EIGEN_DEVICE_FUNC inline Scalar& angle() { return m_angle; }
+  
+  /** \returns the rotation angle in [0,2pi] */
+  EIGEN_DEVICE_FUNC inline Scalar smallestPositiveAngle() const {
+    Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
+    return tmp<Scalar(0) ? tmp + Scalar(2*EIGEN_PI) : tmp;
+  }
+  
+  /** \returns the rotation angle in [-pi,pi] */
+  EIGEN_DEVICE_FUNC inline Scalar smallestAngle() const {
+    Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
+    if(tmp>Scalar(EIGEN_PI))       tmp -= Scalar(2*EIGEN_PI);
+    else if(tmp<-Scalar(EIGEN_PI)) tmp += Scalar(2*EIGEN_PI);
+    return tmp;
+  }
+
+  /** \returns the inverse rotation */
+  EIGEN_DEVICE_FUNC inline Rotation2D inverse() const { return Rotation2D(-m_angle); }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline Rotation2D operator*(const Rotation2D& other) const
+  { return Rotation2D(m_angle + other.m_angle); }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline Rotation2D& operator*=(const Rotation2D& other)
+  { m_angle += other.m_angle; return *this; }
+
+  /** Applies the rotation to a 2D vector */
+  EIGEN_DEVICE_FUNC Vector2 operator* (const Vector2& vec) const
+  { return toRotationMatrix() * vec; }
+  
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC Rotation2D& fromRotationMatrix(const MatrixBase<Derived>& m);
+  EIGEN_DEVICE_FUNC Matrix2 toRotationMatrix() const;
+
+  /** Set \c *this from a 2x2 rotation matrix \a mat.
+    * In other words, this function extract the rotation angle from the rotation matrix.
+    *
+    * This method is an alias for fromRotationMatrix()
+    *
+    * \sa fromRotationMatrix()
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC Rotation2D& operator=(const  MatrixBase<Derived>& m)
+  { return fromRotationMatrix(m.derived()); }
+
+  /** \returns the spherical interpolation between \c *this and \a other using
+    * parameter \a t. It is in fact equivalent to a linear interpolation.
+    */
+  EIGEN_DEVICE_FUNC inline Rotation2D slerp(const Scalar& t, const Rotation2D& other) const
+  {
+    Scalar dist = Rotation2D(other.m_angle-m_angle).smallestAngle();
+    return Rotation2D(m_angle + dist*t);
+  }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type cast() const
+  { return typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other)
+  {
+    m_angle = Scalar(other.angle());
+  }
+
+  EIGEN_DEVICE_FUNC static inline Rotation2D Identity() { return Rotation2D(0); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Rotation2D& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return internal::isApprox(m_angle,other.m_angle, prec); }
+  
+};
+
+/** \ingroup Geometry_Module
+  * single precision 2D rotation type */
+typedef Rotation2D<float> Rotation2Df;
+/** \ingroup Geometry_Module
+  * double precision 2D rotation type */
+typedef Rotation2D<double> Rotation2Dd;
+
+/** Set \c *this from a 2x2 rotation matrix \a mat.
+  * In other words, this function extract the rotation angle
+  * from the rotation matrix.
+  */
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
+{
+  EIGEN_USING_STD(atan2)
+  EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
+  m_angle = atan2(mat.coeff(1,0), mat.coeff(0,0));
+  return *this;
+}
+
+/** Constructs and \returns an equivalent 2x2 rotation matrix.
+  */
+template<typename Scalar>
+typename Rotation2D<Scalar>::Matrix2
+EIGEN_DEVICE_FUNC Rotation2D<Scalar>::toRotationMatrix(void) const
+{
+  EIGEN_USING_STD(sin)
+  EIGEN_USING_STD(cos)
+  Scalar sinA = sin(m_angle);
+  Scalar cosA = cos(m_angle);
+  return (Matrix2() << cosA, -sinA, sinA, cosA).finished();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ROTATION2D_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/RotationBase.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/RotationBase.h
new file mode 100644
index 00000000..f0ee0bd0
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/RotationBase.h
@@ -0,0 +1,206 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ROTATIONBASE_H
+#define EIGEN_ROTATIONBASE_H
+
+namespace Eigen { 
+
+// forward declaration
+namespace internal {
+template<typename RotationDerived, typename MatrixType, bool IsVector=MatrixType::IsVectorAtCompileTime>
+struct rotation_base_generic_product_selector;
+}
+
+/** \class RotationBase
+  *
+  * \brief Common base class for compact rotation representations
+  *
+  * \tparam Derived is the derived type, i.e., a rotation type
+  * \tparam _Dim the dimension of the space
+  */
+template<typename Derived, int _Dim>
+class RotationBase
+{
+  public:
+    enum { Dim = _Dim };
+    /** the scalar type of the coefficients */
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+
+    /** corresponding linear transformation matrix type */
+    typedef Matrix<Scalar,Dim,Dim> RotationMatrixType;
+    typedef Matrix<Scalar,Dim,1> VectorType;
+
+  public:
+    EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    EIGEN_DEVICE_FUNC inline Derived& derived() { return *static_cast<Derived*>(this); }
+
+    /** \returns an equivalent rotation matrix */
+    EIGEN_DEVICE_FUNC inline RotationMatrixType toRotationMatrix() const { return derived().toRotationMatrix(); }
+
+    /** \returns an equivalent rotation matrix 
+      * This function is added to be conform with the Transform class' naming scheme.
+      */
+    EIGEN_DEVICE_FUNC inline RotationMatrixType matrix() const { return derived().toRotationMatrix(); }
+
+    /** \returns the inverse rotation */
+    EIGEN_DEVICE_FUNC inline Derived inverse() const { return derived().inverse(); }
+
+    /** \returns the concatenation of the rotation \c *this with a translation \a t */
+    EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Isometry> operator*(const Translation<Scalar,Dim>& t) const
+    { return Transform<Scalar,Dim,Isometry>(*this) * t; }
+
+    /** \returns the concatenation of the rotation \c *this with a uniform scaling \a s */
+    EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const UniformScaling<Scalar>& s) const
+    { return toRotationMatrix() * s.factor(); }
+
+    /** \returns the concatenation of the rotation \c *this with a generic expression \a e
+      * \a e can be:
+      *  - a DimxDim linear transformation matrix
+      *  - a DimxDim diagonal matrix (axis aligned scaling)
+      *  - a vector of size Dim
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::rotation_base_generic_product_selector<Derived,OtherDerived,OtherDerived::IsVectorAtCompileTime>::ReturnType
+    operator*(const EigenBase<OtherDerived>& e) const
+    { return internal::rotation_base_generic_product_selector<Derived,OtherDerived>::run(derived(), e.derived()); }
+
+    /** \returns the concatenation of a linear transformation \a l with the rotation \a r */
+    template<typename OtherDerived> friend
+    EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const EigenBase<OtherDerived>& l, const Derived& r)
+    { return l.derived() * r.toRotationMatrix(); }
+
+    /** \returns the concatenation of a scaling \a l with the rotation \a r */
+    EIGEN_DEVICE_FUNC friend inline Transform<Scalar,Dim,Affine> operator*(const DiagonalMatrix<Scalar,Dim>& l, const Derived& r)
+    { 
+      Transform<Scalar,Dim,Affine> res(r);
+      res.linear().applyOnTheLeft(l);
+      return res;
+    }
+
+    /** \returns the concatenation of the rotation \c *this with a transformation \a t */
+    template<int Mode, int Options>
+    EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode> operator*(const Transform<Scalar,Dim,Mode,Options>& t) const
+    { return toRotationMatrix() * t; }
+
+    template<typename OtherVectorType>
+    EIGEN_DEVICE_FUNC inline VectorType _transformVector(const OtherVectorType& v) const
+    { return toRotationMatrix() * v; }
+};
+
+namespace internal {
+
+// implementation of the generic product rotation * matrix
+template<typename RotationDerived, typename MatrixType>
+struct rotation_base_generic_product_selector<RotationDerived,MatrixType,false>
+{
+  enum { Dim = RotationDerived::Dim };
+  typedef Matrix<typename RotationDerived::Scalar,Dim,Dim> ReturnType;
+  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const MatrixType& m)
+  { return r.toRotationMatrix() * m; }
+};
+
+template<typename RotationDerived, typename Scalar, int Dim, int MaxDim>
+struct rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix<Scalar,Dim,MaxDim>, false >
+{
+  typedef Transform<Scalar,Dim,Affine> ReturnType;
+  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const DiagonalMatrix<Scalar,Dim,MaxDim>& m)
+  {
+    ReturnType res(r);
+    res.linear() *= m;
+    return res;
+  }
+};
+
+template<typename RotationDerived,typename OtherVectorType>
+struct rotation_base_generic_product_selector<RotationDerived,OtherVectorType,true>
+{
+  enum { Dim = RotationDerived::Dim };
+  typedef Matrix<typename RotationDerived::Scalar,Dim,1> ReturnType;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE ReturnType run(const RotationDerived& r, const OtherVectorType& v)
+  {
+    return r._transformVector(v);
+  }
+};
+
+} // end namespace internal
+
+/** \geometry_module
+  *
+  * \brief Constructs a Dim x Dim rotation matrix from the rotation \a r
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Storage, int _MaxRows, int _MaxCols>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
+::Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
+{
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix,int(OtherDerived::Dim),int(OtherDerived::Dim))
+  *this = r.toRotationMatrix();
+}
+
+/** \geometry_module
+  *
+  * \brief Set a Dim x Dim rotation matrix from the rotation \a r
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Storage, int _MaxRows, int _MaxCols>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
+::operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
+{
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix,int(OtherDerived::Dim),int(OtherDerived::Dim))
+  return *this = r.toRotationMatrix();
+}
+
+namespace internal {
+
+/** \internal
+  *
+  * Helper function to return an arbitrary rotation object to a rotation matrix.
+  *
+  * \tparam Scalar the numeric type of the matrix coefficients
+  * \tparam Dim the dimension of the current space
+  *
+  * It returns a Dim x Dim fixed size matrix.
+  *
+  * Default specializations are provided for:
+  *   - any scalar type (2D),
+  *   - any matrix expression,
+  *   - any type based on RotationBase (e.g., Quaternion, AngleAxis, Rotation2D)
+  *
+  * Currently toRotationMatrix is only used by Transform.
+  *
+  * \sa class Transform, class Rotation2D, class Quaternion, class AngleAxis
+  */
+template<typename Scalar, int Dim>
+EIGEN_DEVICE_FUNC static inline Matrix<Scalar,2,2> toRotationMatrix(const Scalar& s)
+{
+  EIGEN_STATIC_ASSERT(Dim==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
+  return Rotation2D<Scalar>(s).toRotationMatrix();
+}
+
+template<typename Scalar, int Dim, typename OtherDerived>
+EIGEN_DEVICE_FUNC static inline Matrix<Scalar,Dim,Dim> toRotationMatrix(const RotationBase<OtherDerived,Dim>& r)
+{
+  return r.toRotationMatrix();
+}
+
+template<typename Scalar, int Dim, typename OtherDerived>
+EIGEN_DEVICE_FUNC static inline const MatrixBase<OtherDerived>& toRotationMatrix(const MatrixBase<OtherDerived>& mat)
+{
+  EIGEN_STATIC_ASSERT(OtherDerived::RowsAtCompileTime==Dim && OtherDerived::ColsAtCompileTime==Dim,
+    YOU_MADE_A_PROGRAMMING_MISTAKE)
+  return mat;
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_ROTATIONBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/Scaling.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Scaling.h
new file mode 100644
index 00000000..d352f1f2
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Scaling.h
@@ -0,0 +1,188 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SCALING_H
+#define EIGEN_SCALING_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class UniformScaling
+  *
+  * \brief Represents a generic uniform scaling transformation
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients.
+  *
+  * This class represent a uniform scaling transformation. It is the return
+  * type of Scaling(Scalar), and most of the time this is the only way it
+  * is used. In particular, this class is not aimed to be used to store a scaling transformation,
+  * but rather to make easier the constructions and updates of Transform objects.
+  *
+  * To represent an axis aligned scaling, use the DiagonalMatrix class.
+  *
+  * \sa Scaling(), class DiagonalMatrix, MatrixBase::asDiagonal(), class Translation, class Transform
+  */
+
+namespace internal
+{
+  // This helper helps nvcc+MSVC to properly parse this file.
+  // See bug 1412.
+  template <typename Scalar, int Dim, int Mode>
+  struct uniformscaling_times_affine_returntype
+  {
+    enum
+    {
+      NewMode = int(Mode) == int(Isometry) ? Affine : Mode
+    };
+    typedef Transform <Scalar, Dim, NewMode> type;
+  };
+}
+
+template<typename _Scalar>
+class UniformScaling
+{
+public:
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+
+protected:
+
+  Scalar m_factor;
+
+public:
+
+  /** Default constructor without initialization. */
+  UniformScaling() {}
+  /** Constructs and initialize a uniform scaling transformation */
+  explicit inline UniformScaling(const Scalar& s) : m_factor(s) {}
+
+  inline const Scalar& factor() const { return m_factor; }
+  inline Scalar& factor() { return m_factor; }
+
+  /** Concatenates two uniform scaling */
+  inline UniformScaling operator* (const UniformScaling& other) const
+  { return UniformScaling(m_factor * other.factor()); }
+
+  /** Concatenates a uniform scaling and a translation */
+  template<int Dim>
+  inline Transform<Scalar,Dim,Affine> operator* (const Translation<Scalar,Dim>& t) const;
+
+  /** Concatenates a uniform scaling and an affine transformation */
+  template<int Dim, int Mode, int Options>
+  inline typename
+	internal::uniformscaling_times_affine_returntype<Scalar,Dim,Mode>::type
+	operator* (const Transform<Scalar, Dim, Mode, Options>& t) const
+  {
+    typename internal::uniformscaling_times_affine_returntype<Scalar,Dim,Mode>::type res = t;
+    res.prescale(factor());
+    return res;
+  }
+
+  /** Concatenates a uniform scaling and a linear transformation matrix */
+  // TODO returns an expression
+  template<typename Derived>
+  inline typename Eigen::internal::plain_matrix_type<Derived>::type operator* (const MatrixBase<Derived>& other) const
+  { return other * m_factor; }
+
+  template<typename Derived,int Dim>
+  inline Matrix<Scalar,Dim,Dim> operator*(const RotationBase<Derived,Dim>& r) const
+  { return r.toRotationMatrix() * m_factor; }
+
+  /** \returns the inverse scaling */
+  inline UniformScaling inverse() const
+  { return UniformScaling(Scalar(1)/m_factor); }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  inline UniformScaling<NewScalarType> cast() const
+  { return UniformScaling<NewScalarType>(NewScalarType(m_factor)); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  inline explicit UniformScaling(const UniformScaling<OtherScalarType>& other)
+  { m_factor = Scalar(other.factor()); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  bool isApprox(const UniformScaling& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return internal::isApprox(m_factor, other.factor(), prec); }
+
+};
+
+/** \addtogroup Geometry_Module */
+//@{
+
+/** Concatenates a linear transformation matrix and a uniform scaling
+  * \relates UniformScaling
+  */
+// NOTE this operator is defined in MatrixBase and not as a friend function
+// of UniformScaling to fix an internal crash of Intel's ICC
+template<typename Derived,typename Scalar>
+EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,Scalar,product)
+operator*(const MatrixBase<Derived>& matrix, const UniformScaling<Scalar>& s)
+{ return matrix.derived() * s.factor(); }
+
+/** Constructs a uniform scaling from scale factor \a s */
+inline UniformScaling<float> Scaling(float s) { return UniformScaling<float>(s); }
+/** Constructs a uniform scaling from scale factor \a s */
+inline UniformScaling<double> Scaling(double s) { return UniformScaling<double>(s); }
+/** Constructs a uniform scaling from scale factor \a s */
+template<typename RealScalar>
+inline UniformScaling<std::complex<RealScalar> > Scaling(const std::complex<RealScalar>& s)
+{ return UniformScaling<std::complex<RealScalar> >(s); }
+
+/** Constructs a 2D axis aligned scaling */
+template<typename Scalar>
+inline DiagonalMatrix<Scalar,2> Scaling(const Scalar& sx, const Scalar& sy)
+{ return DiagonalMatrix<Scalar,2>(sx, sy); }
+/** Constructs a 3D axis aligned scaling */
+template<typename Scalar>
+inline DiagonalMatrix<Scalar,3> Scaling(const Scalar& sx, const Scalar& sy, const Scalar& sz)
+{ return DiagonalMatrix<Scalar,3>(sx, sy, sz); }
+
+/** Constructs an axis aligned scaling expression from vector expression \a coeffs
+  * This is an alias for coeffs.asDiagonal()
+  */
+template<typename Derived>
+inline const DiagonalWrapper<const Derived> Scaling(const MatrixBase<Derived>& coeffs)
+{ return coeffs.asDiagonal(); }
+
+/** \deprecated */
+typedef DiagonalMatrix<float, 2> AlignedScaling2f;
+/** \deprecated */
+typedef DiagonalMatrix<double,2> AlignedScaling2d;
+/** \deprecated */
+typedef DiagonalMatrix<float, 3> AlignedScaling3f;
+/** \deprecated */
+typedef DiagonalMatrix<double,3> AlignedScaling3d;
+//@}
+
+template<typename Scalar>
+template<int Dim>
+inline Transform<Scalar,Dim,Affine>
+UniformScaling<Scalar>::operator* (const Translation<Scalar,Dim>& t) const
+{
+  Transform<Scalar,Dim,Affine> res;
+  res.matrix().setZero();
+  res.linear().diagonal().fill(factor());
+  res.translation() = factor() * t.vector();
+  res(Dim,Dim) = Scalar(1);
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SCALING_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/Transform.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Transform.h
new file mode 100644
index 00000000..52b8c2a4
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Transform.h
@@ -0,0 +1,1563 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2010 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSFORM_H
+#define EIGEN_TRANSFORM_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Transform>
+struct transform_traits
+{
+  enum
+  {
+    Dim = Transform::Dim,
+    HDim = Transform::HDim,
+    Mode = Transform::Mode,
+    IsProjective = (int(Mode)==int(Projective))
+  };
+};
+
+template< typename TransformType,
+          typename MatrixType,
+          int Case = transform_traits<TransformType>::IsProjective ? 0
+                   : int(MatrixType::RowsAtCompileTime) == int(transform_traits<TransformType>::HDim) ? 1
+                   : 2,
+          int RhsCols = MatrixType::ColsAtCompileTime>
+struct transform_right_product_impl;
+
+template< typename Other,
+          int Mode,
+          int Options,
+          int Dim,
+          int HDim,
+          int OtherRows=Other::RowsAtCompileTime,
+          int OtherCols=Other::ColsAtCompileTime>
+struct transform_left_product_impl;
+
+template< typename Lhs,
+          typename Rhs,
+          bool AnyProjective =
+            transform_traits<Lhs>::IsProjective ||
+            transform_traits<Rhs>::IsProjective>
+struct transform_transform_product_impl;
+
+template< typename Other,
+          int Mode,
+          int Options,
+          int Dim,
+          int HDim,
+          int OtherRows=Other::RowsAtCompileTime,
+          int OtherCols=Other::ColsAtCompileTime>
+struct transform_construct_from_matrix;
+
+template<typename TransformType> struct transform_take_affine_part;
+
+template<typename _Scalar, int _Dim, int _Mode, int _Options>
+struct traits<Transform<_Scalar,_Dim,_Mode,_Options> >
+{
+  typedef _Scalar Scalar;
+  typedef Eigen::Index StorageIndex;
+  typedef Dense StorageKind;
+  enum {
+    Dim1 = _Dim==Dynamic ? _Dim : _Dim + 1,
+    RowsAtCompileTime = _Mode==Projective ? Dim1 : _Dim,
+    ColsAtCompileTime = Dim1,
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    Flags = 0
+  };
+};
+
+template<int Mode> struct transform_make_affine;
+
+} // end namespace internal
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Transform
+  *
+  * \brief Represents an homogeneous transformation in a N dimensional space
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _Dim the dimension of the space
+  * \tparam _Mode the type of the transformation. Can be:
+  *              - #Affine: the transformation is stored as a (Dim+1)^2 matrix,
+  *                         where the last row is assumed to be [0 ... 0 1].
+  *              - #AffineCompact: the transformation is stored as a (Dim)x(Dim+1) matrix.
+  *              - #Projective: the transformation is stored as a (Dim+1)^2 matrix
+  *                             without any assumption.
+  *              - #Isometry: same as #Affine with the additional assumption that
+  *                           the linear part represents a rotation. This assumption is exploited
+  *                           to speed up some functions such as inverse() and rotation().
+  * \tparam _Options has the same meaning as in class Matrix. It allows to specify DontAlign and/or RowMajor.
+  *                  These Options are passed directly to the underlying matrix type.
+  *
+  * The homography is internally represented and stored by a matrix which
+  * is available through the matrix() method. To understand the behavior of
+  * this class you have to think a Transform object as its internal
+  * matrix representation. The chosen convention is right multiply:
+  *
+  * \code v' = T * v \endcode
+  *
+  * Therefore, an affine transformation matrix M is shaped like this:
+  *
+  * \f$ \left( \begin{array}{cc}
+  * linear & translation\\
+  * 0 ... 0 & 1
+  * \end{array} \right) \f$
+  *
+  * Note that for a projective transformation the last row can be anything,
+  * and then the interpretation of different parts might be slightly different.
+  *
+  * However, unlike a plain matrix, the Transform class provides many features
+  * simplifying both its assembly and usage. In particular, it can be composed
+  * with any other transformations (Transform,Translation,RotationBase,DiagonalMatrix)
+  * and can be directly used to transform implicit homogeneous vectors. All these
+  * operations are handled via the operator*. For the composition of transformations,
+  * its principle consists to first convert the right/left hand sides of the product
+  * to a compatible (Dim+1)^2 matrix and then perform a pure matrix product.
+  * Of course, internally, operator* tries to perform the minimal number of operations
+  * according to the nature of each terms. Likewise, when applying the transform
+  * to points, the latters are automatically promoted to homogeneous vectors
+  * before doing the matrix product. The conventions to homogeneous representations
+  * are performed as follow:
+  *
+  * \b Translation t (Dim)x(1):
+  * \f$ \left( \begin{array}{cc}
+  * I & t \\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *
+  * \b Rotation R (Dim)x(Dim):
+  * \f$ \left( \begin{array}{cc}
+  * R & 0\\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *<!--
+  * \b Linear \b Matrix L (Dim)x(Dim):
+  * \f$ \left( \begin{array}{cc}
+  * L & 0\\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *
+  * \b Affine \b Matrix A (Dim)x(Dim+1):
+  * \f$ \left( \begin{array}{c}
+  * A\\
+  * 0\,...\,0\,1
+  * \end{array} \right) \f$
+  *-->
+  * \b Scaling \b DiagonalMatrix S (Dim)x(Dim):
+  * \f$ \left( \begin{array}{cc}
+  * S & 0\\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *
+  * \b Column \b point v (Dim)x(1):
+  * \f$ \left( \begin{array}{c}
+  * v\\
+  * 1
+  * \end{array} \right) \f$
+  *
+  * \b Set \b of \b column \b points V1...Vn (Dim)x(n):
+  * \f$ \left( \begin{array}{ccc}
+  * v_1 & ... & v_n\\
+  * 1 & ... & 1
+  * \end{array} \right) \f$
+  *
+  * The concatenation of a Transform object with any kind of other transformation
+  * always returns a Transform object.
+  *
+  * A little exception to the "as pure matrix product" rule is the case of the
+  * transformation of non homogeneous vectors by an affine transformation. In
+  * that case the last matrix row can be ignored, and the product returns non
+  * homogeneous vectors.
+  *
+  * Since, for instance, a Dim x Dim matrix is interpreted as a linear transformation,
+  * it is not possible to directly transform Dim vectors stored in a Dim x Dim matrix.
+  * The solution is either to use a Dim x Dynamic matrix or explicitly request a
+  * vector transformation by making the vector homogeneous:
+  * \code
+  * m' = T * m.colwise().homogeneous();
+  * \endcode
+  * Note that there is zero overhead.
+  *
+  * Conversion methods from/to Qt's QMatrix and QTransform are available if the
+  * preprocessor token EIGEN_QT_SUPPORT is defined.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_TRANSFORM_PLUGIN.
+  *
+  * \sa class Matrix, class Quaternion
+  */
+template<typename _Scalar, int _Dim, int _Mode, int _Options>
+class Transform
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim==Dynamic ? Dynamic : (_Dim+1)*(_Dim+1))
+  enum {
+    Mode = _Mode,
+    Options = _Options,
+    Dim = _Dim,     ///< space dimension in which the transformation holds
+    HDim = _Dim+1,  ///< size of a respective homogeneous vector
+    Rows = int(Mode)==(AffineCompact) ? Dim : HDim
+  };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  typedef Eigen::Index StorageIndex;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  /** type of the matrix used to represent the transformation */
+  typedef typename internal::make_proper_matrix_type<Scalar,Rows,HDim,Options>::type MatrixType;
+  /** constified MatrixType */
+  typedef const MatrixType ConstMatrixType;
+  /** type of the matrix used to represent the linear part of the transformation */
+  typedef Matrix<Scalar,Dim,Dim,Options> LinearMatrixType;
+  /** type of read/write reference to the linear part of the transformation */
+  typedef Block<MatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (int(Options)&RowMajor)==0> LinearPart;
+  /** type of read reference to the linear part of the transformation */
+  typedef const Block<ConstMatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (int(Options)&RowMajor)==0> ConstLinearPart;
+  /** type of read/write reference to the affine part of the transformation */
+  typedef typename internal::conditional<int(Mode)==int(AffineCompact),
+                              MatrixType&,
+                              Block<MatrixType,Dim,HDim> >::type AffinePart;
+  /** type of read reference to the affine part of the transformation */
+  typedef typename internal::conditional<int(Mode)==int(AffineCompact),
+                              const MatrixType&,
+                              const Block<const MatrixType,Dim,HDim> >::type ConstAffinePart;
+  /** type of a vector */
+  typedef Matrix<Scalar,Dim,1> VectorType;
+  /** type of a read/write reference to the translation part of the rotation */
+  typedef Block<MatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & RowMajorBit)> TranslationPart;
+  /** type of a read reference to the translation part of the rotation */
+  typedef const Block<ConstMatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & RowMajorBit)> ConstTranslationPart;
+  /** corresponding translation type */
+  typedef Translation<Scalar,Dim> TranslationType;
+
+  // this intermediate enum is needed to avoid an ICE with gcc 3.4 and 4.0
+  enum { TransformTimeDiagonalMode = ((Mode==int(Isometry))?Affine:int(Mode)) };
+  /** The return type of the product between a diagonal matrix and a transform */
+  typedef Transform<Scalar,Dim,TransformTimeDiagonalMode> TransformTimeDiagonalReturnType;
+
+protected:
+
+  MatrixType m_matrix;
+
+public:
+
+  /** Default constructor without initialization of the meaningful coefficients.
+    * If Mode==Affine or Mode==Isometry, then the last row is set to [0 ... 0 1] */
+  EIGEN_DEVICE_FUNC inline Transform()
+  {
+    check_template_params();
+    internal::transform_make_affine<(int(Mode)==Affine || int(Mode)==Isometry) ? Affine : AffineCompact>::run(m_matrix);
+  }
+
+  EIGEN_DEVICE_FUNC inline explicit Transform(const TranslationType& t)
+  {
+    check_template_params();
+    *this = t;
+  }
+  EIGEN_DEVICE_FUNC inline explicit Transform(const UniformScaling<Scalar>& s)
+  {
+    check_template_params();
+    *this = s;
+  }
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline explicit Transform(const RotationBase<Derived, Dim>& r)
+  {
+    check_template_params();
+    *this = r;
+  }
+
+  typedef internal::transform_take_affine_part<Transform> take_affine_part;
+
+  /** Constructs and initializes a transformation from a Dim^2 or a (Dim+1)^2 matrix. */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline explicit Transform(const EigenBase<OtherDerived>& other)
+  {
+    EIGEN_STATIC_ASSERT((internal::is_same<Scalar,typename OtherDerived::Scalar>::value),
+      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY);
+
+    check_template_params();
+    internal::transform_construct_from_matrix<OtherDerived,Mode,Options,Dim,HDim>::run(this, other.derived());
+  }
+
+  /** Set \c *this from a Dim^2 or (Dim+1)^2 matrix. */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline Transform& operator=(const EigenBase<OtherDerived>& other)
+  {
+    EIGEN_STATIC_ASSERT((internal::is_same<Scalar,typename OtherDerived::Scalar>::value),
+      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY);
+
+    internal::transform_construct_from_matrix<OtherDerived,Mode,Options,Dim,HDim>::run(this, other.derived());
+    return *this;
+  }
+
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC inline Transform(const Transform<Scalar,Dim,Mode,OtherOptions>& other)
+  {
+    check_template_params();
+    // only the options change, we can directly copy the matrices
+    m_matrix = other.matrix();
+  }
+
+  template<int OtherMode,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline Transform(const Transform<Scalar,Dim,OtherMode,OtherOptions>& other)
+  {
+    check_template_params();
+    // prevent conversions as:
+    // Affine | AffineCompact | Isometry = Projective
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Projective), Mode==int(Projective)),
+                        YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION)
+
+    // prevent conversions as:
+    // Isometry = Affine | AffineCompact
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Affine)||OtherMode==int(AffineCompact), Mode!=int(Isometry)),
+                        YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION)
+
+    enum { ModeIsAffineCompact = Mode == int(AffineCompact),
+           OtherModeIsAffineCompact = OtherMode == int(AffineCompact)
+    };
+
+    if(EIGEN_CONST_CONDITIONAL(ModeIsAffineCompact == OtherModeIsAffineCompact))
+    {
+      // We need the block expression because the code is compiled for all
+      // combinations of transformations and will trigger a compile time error
+      // if one tries to assign the matrices directly
+      m_matrix.template block<Dim,Dim+1>(0,0) = other.matrix().template block<Dim,Dim+1>(0,0);
+      makeAffine();
+    }
+    else if(EIGEN_CONST_CONDITIONAL(OtherModeIsAffineCompact))
+    {
+      typedef typename Transform<Scalar,Dim,OtherMode,OtherOptions>::MatrixType OtherMatrixType;
+      internal::transform_construct_from_matrix<OtherMatrixType,Mode,Options,Dim,HDim>::run(this, other.matrix());
+    }
+    else
+    {
+      // here we know that Mode == AffineCompact and OtherMode != AffineCompact.
+      // if OtherMode were Projective, the static assert above would already have caught it.
+      // So the only possibility is that OtherMode == Affine
+      linear() = other.linear();
+      translation() = other.translation();
+    }
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC Transform(const ReturnByValue<OtherDerived>& other)
+  {
+    check_template_params();
+    other.evalTo(*this);
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC Transform& operator=(const ReturnByValue<OtherDerived>& other)
+  {
+    other.evalTo(*this);
+    return *this;
+  }
+
+  #ifdef EIGEN_QT_SUPPORT
+  inline Transform(const QMatrix& other);
+  inline Transform& operator=(const QMatrix& other);
+  inline QMatrix toQMatrix(void) const;
+  inline Transform(const QTransform& other);
+  inline Transform& operator=(const QTransform& other);
+  inline QTransform toQTransform(void) const;
+  #endif
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return int(Mode)==int(Projective) ? m_matrix.cols() : (m_matrix.cols()-1); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+  /** shortcut for m_matrix(row,col);
+    * \sa MatrixBase::operator(Index,Index) const */
+  EIGEN_DEVICE_FUNC inline Scalar operator() (Index row, Index col) const { return m_matrix(row,col); }
+  /** shortcut for m_matrix(row,col);
+    * \sa MatrixBase::operator(Index,Index) */
+  EIGEN_DEVICE_FUNC inline Scalar& operator() (Index row, Index col) { return m_matrix(row,col); }
+
+  /** \returns a read-only expression of the transformation matrix */
+  EIGEN_DEVICE_FUNC inline const MatrixType& matrix() const { return m_matrix; }
+  /** \returns a writable expression of the transformation matrix */
+  EIGEN_DEVICE_FUNC inline MatrixType& matrix() { return m_matrix; }
+
+  /** \returns a read-only expression of the linear part of the transformation */
+  EIGEN_DEVICE_FUNC inline ConstLinearPart linear() const { return ConstLinearPart(m_matrix,0,0); }
+  /** \returns a writable expression of the linear part of the transformation */
+  EIGEN_DEVICE_FUNC inline LinearPart linear() { return LinearPart(m_matrix,0,0); }
+
+  /** \returns a read-only expression of the Dim x HDim affine part of the transformation */
+  EIGEN_DEVICE_FUNC inline ConstAffinePart affine() const { return take_affine_part::run(m_matrix); }
+  /** \returns a writable expression of the Dim x HDim affine part of the transformation */
+  EIGEN_DEVICE_FUNC inline AffinePart affine() { return take_affine_part::run(m_matrix); }
+
+  /** \returns a read-only expression of the translation vector of the transformation */
+  EIGEN_DEVICE_FUNC inline ConstTranslationPart translation() const { return ConstTranslationPart(m_matrix,0,Dim); }
+  /** \returns a writable expression of the translation vector of the transformation */
+  EIGEN_DEVICE_FUNC inline TranslationPart translation() { return TranslationPart(m_matrix,0,Dim); }
+
+  /** \returns an expression of the product between the transform \c *this and a matrix expression \a other.
+    *
+    * The right-hand-side \a other can be either:
+    * \li an homogeneous vector of size Dim+1,
+    * \li a set of homogeneous vectors of size Dim+1 x N,
+    * \li a transformation matrix of size Dim+1 x Dim+1.
+    *
+    * Moreover, if \c *this represents an affine transformation (i.e., Mode!=Projective), then \a other can also be:
+    * \li a point of size Dim (computes: \code this->linear() * other + this->translation()\endcode),
+    * \li a set of N points as a Dim x N matrix (computes: \code (this->linear() * other).colwise() + this->translation()\endcode),
+    *
+    * In all cases, the return type is a matrix or vector of same sizes as the right-hand-side \a other.
+    *
+    * If you want to interpret \a other as a linear or affine transformation, then first convert it to a Transform<> type,
+    * or do your own cooking.
+    *
+    * Finally, if you want to apply Affine transformations to vectors, then explicitly apply the linear part only:
+    * \code
+    * Affine3f A;
+    * Vector3f v1, v2;
+    * v2 = A.linear() * v1;
+    * \endcode
+    *
+    */
+  // note: this function is defined here because some compilers cannot find the respective declaration
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename internal::transform_right_product_impl<Transform, OtherDerived>::ResultType
+  operator * (const EigenBase<OtherDerived> &other) const
+  { return internal::transform_right_product_impl<Transform, OtherDerived>::run(*this,other.derived()); }
+
+  /** \returns the product expression of a transformation matrix \a a times a transform \a b
+    *
+    * The left hand side \a other can be either:
+    * \li a linear transformation matrix of size Dim x Dim,
+    * \li an affine transformation matrix of size Dim x Dim+1,
+    * \li a general transformation matrix of size Dim+1 x Dim+1.
+    */
+  template<typename OtherDerived> friend
+  EIGEN_DEVICE_FUNC inline const typename internal::transform_left_product_impl<OtherDerived,Mode,Options,_Dim,_Dim+1>::ResultType
+    operator * (const EigenBase<OtherDerived> &a, const Transform &b)
+  { return internal::transform_left_product_impl<OtherDerived,Mode,Options,Dim,HDim>::run(a.derived(),b); }
+
+  /** \returns The product expression of a transform \a a times a diagonal matrix \a b
+    *
+    * The rhs diagonal matrix is interpreted as an affine scaling transformation. The
+    * product results in a Transform of the same type (mode) as the lhs only if the lhs
+    * mode is no isometry. In that case, the returned transform is an affinity.
+    */
+  template<typename DiagonalDerived>
+  EIGEN_DEVICE_FUNC inline const TransformTimeDiagonalReturnType
+    operator * (const DiagonalBase<DiagonalDerived> &b) const
+  {
+    TransformTimeDiagonalReturnType res(*this);
+    res.linearExt() *= b;
+    return res;
+  }
+
+  /** \returns The product expression of a diagonal matrix \a a times a transform \a b
+    *
+    * The lhs diagonal matrix is interpreted as an affine scaling transformation. The
+    * product results in a Transform of the same type (mode) as the lhs only if the lhs
+    * mode is no isometry. In that case, the returned transform is an affinity.
+    */
+  template<typename DiagonalDerived>
+  EIGEN_DEVICE_FUNC friend inline TransformTimeDiagonalReturnType
+    operator * (const DiagonalBase<DiagonalDerived> &a, const Transform &b)
+  {
+    TransformTimeDiagonalReturnType res;
+    res.linear().noalias() = a*b.linear();
+    res.translation().noalias() = a*b.translation();
+    if (EIGEN_CONST_CONDITIONAL(Mode!=int(AffineCompact)))
+      res.matrix().row(Dim) = b.matrix().row(Dim);
+    return res;
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline Transform& operator*=(const EigenBase<OtherDerived>& other) { return *this = *this * other; }
+
+  /** Concatenates two transformations */
+  EIGEN_DEVICE_FUNC inline const Transform operator * (const Transform& other) const
+  {
+    return internal::transform_transform_product_impl<Transform,Transform>::run(*this,other);
+  }
+
+  #if EIGEN_COMP_ICC
+private:
+  // this intermediate structure permits to workaround a bug in ICC 11:
+  //   error: template instantiation resulted in unexpected function type of "Eigen::Transform<double, 3, 32, 0>
+  //             (const Eigen::Transform<double, 3, 2, 0> &) const"
+  //  (the meaning of a name may have changed since the template declaration -- the type of the template is:
+  // "Eigen::internal::transform_transform_product_impl<Eigen::Transform<double, 3, 32, 0>,
+  //     Eigen::Transform<double, 3, Mode, Options>, <expression>>::ResultType (const Eigen::Transform<double, 3, Mode, Options> &) const")
+  //
+  template<int OtherMode,int OtherOptions> struct icc_11_workaround
+  {
+    typedef internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> > ProductType;
+    typedef typename ProductType::ResultType ResultType;
+  };
+
+public:
+  /** Concatenates two different transformations */
+  template<int OtherMode,int OtherOptions>
+  inline typename icc_11_workaround<OtherMode,OtherOptions>::ResultType
+    operator * (const Transform<Scalar,Dim,OtherMode,OtherOptions>& other) const
+  {
+    typedef typename icc_11_workaround<OtherMode,OtherOptions>::ProductType ProductType;
+    return ProductType::run(*this,other);
+  }
+  #else
+  /** Concatenates two different transformations */
+  template<int OtherMode,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline typename internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> >::ResultType
+    operator * (const Transform<Scalar,Dim,OtherMode,OtherOptions>& other) const
+  {
+    return internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> >::run(*this,other);
+  }
+  #endif
+
+  /** \sa MatrixBase::setIdentity() */
+  EIGEN_DEVICE_FUNC void setIdentity() { m_matrix.setIdentity(); }
+
+  /**
+   * \brief Returns an identity transformation.
+   * \todo In the future this function should be returning a Transform expression.
+   */
+  EIGEN_DEVICE_FUNC static const Transform Identity()
+  {
+    return Transform(MatrixType::Identity());
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& scale(const MatrixBase<OtherDerived> &other);
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& prescale(const MatrixBase<OtherDerived> &other);
+
+  EIGEN_DEVICE_FUNC inline Transform& scale(const Scalar& s);
+  EIGEN_DEVICE_FUNC inline Transform& prescale(const Scalar& s);
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& translate(const MatrixBase<OtherDerived> &other);
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& pretranslate(const MatrixBase<OtherDerived> &other);
+
+  template<typename RotationType>
+  EIGEN_DEVICE_FUNC
+  inline Transform& rotate(const RotationType& rotation);
+
+  template<typename RotationType>
+  EIGEN_DEVICE_FUNC
+  inline Transform& prerotate(const RotationType& rotation);
+
+  EIGEN_DEVICE_FUNC Transform& shear(const Scalar& sx, const Scalar& sy);
+  EIGEN_DEVICE_FUNC Transform& preshear(const Scalar& sx, const Scalar& sy);
+
+  EIGEN_DEVICE_FUNC inline Transform& operator=(const TranslationType& t);
+
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator*=(const TranslationType& t) { return translate(t.vector()); }
+
+  EIGEN_DEVICE_FUNC inline Transform operator*(const TranslationType& t) const;
+
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator=(const UniformScaling<Scalar>& t);
+
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator*=(const UniformScaling<Scalar>& s) { return scale(s.factor()); }
+
+  EIGEN_DEVICE_FUNC
+  inline TransformTimeDiagonalReturnType operator*(const UniformScaling<Scalar>& s) const
+  {
+    TransformTimeDiagonalReturnType res = *this;
+    res.scale(s.factor());
+    return res;
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator*=(const DiagonalMatrix<Scalar,Dim>& s) { linearExt() *= s; return *this; }
+
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Transform& operator=(const RotationBase<Derived,Dim>& r);
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Transform& operator*=(const RotationBase<Derived,Dim>& r) { return rotate(r.toRotationMatrix()); }
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Transform operator*(const RotationBase<Derived,Dim>& r) const;
+
+  typedef typename internal::conditional<int(Mode)==Isometry,ConstLinearPart,const LinearMatrixType>::type RotationReturnType;
+  EIGEN_DEVICE_FUNC RotationReturnType rotation() const;
+
+  template<typename RotationMatrixType, typename ScalingMatrixType>
+  EIGEN_DEVICE_FUNC
+  void computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const;
+  template<typename ScalingMatrixType, typename RotationMatrixType>
+  EIGEN_DEVICE_FUNC
+  void computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const;
+
+  template<typename PositionDerived, typename OrientationType, typename ScaleDerived>
+  EIGEN_DEVICE_FUNC
+  Transform& fromPositionOrientationScale(const MatrixBase<PositionDerived> &position,
+    const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale);
+
+  EIGEN_DEVICE_FUNC
+  inline Transform inverse(TransformTraits traits = (TransformTraits)Mode) const;
+
+  /** \returns a const pointer to the column major internal matrix */
+  EIGEN_DEVICE_FUNC const Scalar* data() const { return m_matrix.data(); }
+  /** \returns a non-const pointer to the column major internal matrix */
+  EIGEN_DEVICE_FUNC Scalar* data() { return m_matrix.data(); }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode,Options> >::type cast() const
+  { return typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode,Options> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Transform(const Transform<OtherScalarType,Dim,Mode,Options>& other)
+  {
+    check_template_params();
+    m_matrix = other.matrix().template cast<Scalar>();
+  }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Transform& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_matrix.isApprox(other.m_matrix, prec); }
+
+  /** Sets the last row to [0 ... 0 1]
+    */
+  EIGEN_DEVICE_FUNC void makeAffine()
+  {
+    internal::transform_make_affine<int(Mode)>::run(m_matrix);
+  }
+
+  /** \internal
+    * \returns the Dim x Dim linear part if the transformation is affine,
+    *          and the HDim x Dim part for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,Dim> linearExt()
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,Dim>(0,0); }
+  /** \internal
+    * \returns the Dim x Dim linear part if the transformation is affine,
+    *          and the HDim x Dim part for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline const Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,Dim> linearExt() const
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,Dim>(0,0); }
+
+  /** \internal
+    * \returns the translation part if the transformation is affine,
+    *          and the last column for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,1> translationExt()
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,1>(0,Dim); }
+  /** \internal
+    * \returns the translation part if the transformation is affine,
+    *          and the last column for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline const Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,1> translationExt() const
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,1>(0,Dim); }
+
+
+  #ifdef EIGEN_TRANSFORM_PLUGIN
+  #include EIGEN_TRANSFORM_PLUGIN
+  #endif
+
+protected:
+  #ifndef EIGEN_PARSED_BY_DOXYGEN
+    EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void check_template_params()
+    {
+      EIGEN_STATIC_ASSERT((Options & (DontAlign|RowMajor)) == Options, INVALID_MATRIX_TEMPLATE_PARAMETERS)
+    }
+  #endif
+
+};
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,Isometry> Isometry2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,Isometry> Isometry3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,Isometry> Isometry2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,Isometry> Isometry3d;
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,Affine> Affine2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,Affine> Affine3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,Affine> Affine2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,Affine> Affine3d;
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,AffineCompact> AffineCompact2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,AffineCompact> AffineCompact3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,AffineCompact> AffineCompact2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,AffineCompact> AffineCompact3d;
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,Projective> Projective2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,Projective> Projective3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,Projective> Projective2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,Projective> Projective3d;
+
+/**************************
+*** Optional QT support ***
+**************************/
+
+#ifdef EIGEN_QT_SUPPORT
+/** Initializes \c *this from a QMatrix assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode,int Options>
+Transform<Scalar,Dim,Mode,Options>::Transform(const QMatrix& other)
+{
+  check_template_params();
+  *this = other;
+}
+
+/** Set \c *this from a QMatrix assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode,int Options>
+Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const QMatrix& other)
+{
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy();
+  else
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy(),
+                0, 0, 1;
+  return *this;
+}
+
+/** \returns a QMatrix from \c *this assuming the dimension is 2.
+  *
+  * \warning this conversion might loss data if \c *this is not affine
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+QMatrix Transform<Scalar,Dim,Mode,Options>::toQMatrix(void) const
+{
+  check_template_params();
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  return QMatrix(m_matrix.coeff(0,0), m_matrix.coeff(1,0),
+                 m_matrix.coeff(0,1), m_matrix.coeff(1,1),
+                 m_matrix.coeff(0,2), m_matrix.coeff(1,2));
+}
+
+/** Initializes \c *this from a QTransform assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode,int Options>
+Transform<Scalar,Dim,Mode,Options>::Transform(const QTransform& other)
+{
+  check_template_params();
+  *this = other;
+}
+
+/** Set \c *this from a QTransform assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const QTransform& other)
+{
+  check_template_params();
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy();
+  else
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy(),
+                other.m13(), other.m23(), other.m33();
+  return *this;
+}
+
+/** \returns a QTransform from \c *this assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+QTransform Transform<Scalar,Dim,Mode,Options>::toQTransform(void) const
+{
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
+    return QTransform(m_matrix.coeff(0,0), m_matrix.coeff(1,0),
+                      m_matrix.coeff(0,1), m_matrix.coeff(1,1),
+                      m_matrix.coeff(0,2), m_matrix.coeff(1,2));
+  else
+    return QTransform(m_matrix.coeff(0,0), m_matrix.coeff(1,0), m_matrix.coeff(2,0),
+                      m_matrix.coeff(0,1), m_matrix.coeff(1,1), m_matrix.coeff(2,1),
+                      m_matrix.coeff(0,2), m_matrix.coeff(1,2), m_matrix.coeff(2,2));
+}
+#endif
+
+/*********************
+*** Procedural API ***
+*********************/
+
+/** Applies on the right the non uniform scale transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \sa prescale()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::scale(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  linearExt().noalias() = (linearExt() * other.asDiagonal());
+  return *this;
+}
+
+/** Applies on the right a uniform scale of a factor \a c to \c *this
+  * and returns a reference to \c *this.
+  * \sa prescale(Scalar)
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::scale(const Scalar& s)
+{
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  linearExt() *= s;
+  return *this;
+}
+
+/** Applies on the left the non uniform scale transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \sa scale()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::prescale(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  affine().noalias() = (other.asDiagonal() * affine());
+  return *this;
+}
+
+/** Applies on the left a uniform scale of a factor \a c to \c *this
+  * and returns a reference to \c *this.
+  * \sa scale(Scalar)
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::prescale(const Scalar& s)
+{
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  m_matrix.template topRows<Dim>() *= s;
+  return *this;
+}
+
+/** Applies on the right the translation matrix represented by the vector \a other
+  * to \c *this and returns a reference to \c *this.
+  * \sa pretranslate()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::translate(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  translationExt() += linearExt() * other;
+  return *this;
+}
+
+/** Applies on the left the translation matrix represented by the vector \a other
+  * to \c *this and returns a reference to \c *this.
+  * \sa translate()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::pretranslate(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  if(EIGEN_CONST_CONDITIONAL(int(Mode)==int(Projective)))
+    affine() += other * m_matrix.row(Dim);
+  else
+    translation() += other;
+  return *this;
+}
+
+/** Applies on the right the rotation represented by the rotation \a rotation
+  * to \c *this and returns a reference to \c *this.
+  *
+  * The template parameter \a RotationType is the type of the rotation which
+  * must be known by internal::toRotationMatrix<>.
+  *
+  * Natively supported types includes:
+  *   - any scalar (2D),
+  *   - a Dim x Dim matrix expression,
+  *   - a Quaternion (3D),
+  *   - a AngleAxis (3D)
+  *
+  * This mechanism is easily extendable to support user types such as Euler angles,
+  * or a pair of Quaternion for 4D rotations.
+  *
+  * \sa rotate(Scalar), class Quaternion, class AngleAxis, prerotate(RotationType)
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename RotationType>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::rotate(const RotationType& rotation)
+{
+  linearExt() *= internal::toRotationMatrix<Scalar,Dim>(rotation);
+  return *this;
+}
+
+/** Applies on the left the rotation represented by the rotation \a rotation
+  * to \c *this and returns a reference to \c *this.
+  *
+  * See rotate() for further details.
+  *
+  * \sa rotate()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename RotationType>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::prerotate(const RotationType& rotation)
+{
+  m_matrix.template block<Dim,HDim>(0,0) = internal::toRotationMatrix<Scalar,Dim>(rotation)
+                                         * m_matrix.template block<Dim,HDim>(0,0);
+  return *this;
+}
+
+/** Applies on the right the shear transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \warning 2D only.
+  * \sa preshear()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::shear(const Scalar& sx, const Scalar& sy)
+{
+  EIGEN_STATIC_ASSERT(int(Dim)==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  VectorType tmp = linear().col(0)*sy + linear().col(1);
+  linear() << linear().col(0) + linear().col(1)*sx, tmp;
+  return *this;
+}
+
+/** Applies on the left the shear transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \warning 2D only.
+  * \sa shear()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::preshear(const Scalar& sx, const Scalar& sy)
+{
+  EIGEN_STATIC_ASSERT(int(Dim)==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  m_matrix.template block<Dim,HDim>(0,0) = LinearMatrixType(1, sx, sy, 1) * m_matrix.template block<Dim,HDim>(0,0);
+  return *this;
+}
+
+/******************************************************
+*** Scaling, Translation and Rotation compatibility ***
+******************************************************/
+
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const TranslationType& t)
+{
+  linear().setIdentity();
+  translation() = t.vector();
+  makeAffine();
+  return *this;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const TranslationType& t) const
+{
+  Transform res = *this;
+  res.translate(t.vector());
+  return res;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const UniformScaling<Scalar>& s)
+{
+  m_matrix.setZero();
+  linear().diagonal().fill(s.factor());
+  makeAffine();
+  return *this;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const RotationBase<Derived,Dim>& r)
+{
+  linear() = internal::toRotationMatrix<Scalar,Dim>(r);
+  translation().setZero();
+  makeAffine();
+  return *this;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const RotationBase<Derived,Dim>& r) const
+{
+  Transform res = *this;
+  res.rotate(r.derived());
+  return res;
+}
+
+/************************
+*** Special functions ***
+************************/
+
+namespace internal {
+template<int Mode> struct transform_rotation_impl {
+  template<typename TransformType>
+  EIGEN_DEVICE_FUNC static inline
+  const typename TransformType::LinearMatrixType run(const TransformType& t)
+  {
+    typedef typename TransformType::LinearMatrixType LinearMatrixType;
+    LinearMatrixType result;
+    t.computeRotationScaling(&result, (LinearMatrixType*)0);
+    return result;
+  }
+};
+template<> struct transform_rotation_impl<Isometry> {
+  template<typename TransformType>
+  EIGEN_DEVICE_FUNC static inline
+  typename TransformType::ConstLinearPart run(const TransformType& t)
+  {
+    return t.linear();
+  }
+};
+}
+/** \returns the rotation part of the transformation
+  *
+  * If Mode==Isometry, then this method is an alias for linear(),
+  * otherwise it calls computeRotationScaling() to extract the rotation
+  * through a SVD decomposition.
+  *
+  * \svd_module
+  *
+  * \sa computeRotationScaling(), computeScalingRotation(), class SVD
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC
+typename Transform<Scalar,Dim,Mode,Options>::RotationReturnType
+Transform<Scalar,Dim,Mode,Options>::rotation() const
+{
+  return internal::transform_rotation_impl<Mode>::run(*this);
+}
+
+
+/** decomposes the linear part of the transformation as a product rotation x scaling, the scaling being
+  * not necessarily positive.
+  *
+  * If either pointer is zero, the corresponding computation is skipped.
+  *
+  *
+  *
+  * \svd_module
+  *
+  * \sa computeScalingRotation(), rotation(), class SVD
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename RotationMatrixType, typename ScalingMatrixType>
+EIGEN_DEVICE_FUNC void Transform<Scalar,Dim,Mode,Options>::computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const
+{
+  // Note that JacobiSVD is faster than BDCSVD for small matrices.
+  JacobiSVD<LinearMatrixType> svd(linear(), ComputeFullU | ComputeFullV);
+
+  Scalar x = (svd.matrixU() * svd.matrixV().adjoint()).determinant() < Scalar(0) ? Scalar(-1) : Scalar(1); // so x has absolute value 1
+  VectorType sv(svd.singularValues());
+  sv.coeffRef(Dim-1) *= x;
+  if(scaling) *scaling = svd.matrixV() * sv.asDiagonal() * svd.matrixV().adjoint();
+  if(rotation)
+  {
+    LinearMatrixType m(svd.matrixU());
+    m.col(Dim-1) *= x;
+    *rotation = m * svd.matrixV().adjoint();
+  }
+}
+
+/** decomposes the linear part of the transformation as a product scaling x rotation, the scaling being
+  * not necessarily positive.
+  *
+  * If either pointer is zero, the corresponding computation is skipped.
+  *
+  *
+  *
+  * \svd_module
+  *
+  * \sa computeRotationScaling(), rotation(), class SVD
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename ScalingMatrixType, typename RotationMatrixType>
+EIGEN_DEVICE_FUNC void Transform<Scalar,Dim,Mode,Options>::computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const
+{
+  // Note that JacobiSVD is faster than BDCSVD for small matrices.
+  JacobiSVD<LinearMatrixType> svd(linear(), ComputeFullU | ComputeFullV);
+
+  Scalar x = (svd.matrixU() * svd.matrixV().adjoint()).determinant() < Scalar(0) ? Scalar(-1) : Scalar(1); // so x has absolute value 1
+  VectorType sv(svd.singularValues());
+  sv.coeffRef(Dim-1) *= x;
+  if(scaling) *scaling = svd.matrixU() * sv.asDiagonal() * svd.matrixU().adjoint();
+  if(rotation)
+  {
+    LinearMatrixType m(svd.matrixU());
+    m.col(Dim-1) *= x;
+    *rotation = m * svd.matrixV().adjoint();
+  }
+}
+
+/** Convenient method to set \c *this from a position, orientation and scale
+  * of a 3D object.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename PositionDerived, typename OrientationType, typename ScaleDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::fromPositionOrientationScale(const MatrixBase<PositionDerived> &position,
+  const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale)
+{
+  linear() = internal::toRotationMatrix<Scalar,Dim>(orientation);
+  linear() *= scale.asDiagonal();
+  translation() = position;
+  makeAffine();
+  return *this;
+}
+
+namespace internal {
+
+template<int Mode>
+struct transform_make_affine
+{
+  template<typename MatrixType>
+  EIGEN_DEVICE_FUNC static void run(MatrixType &mat)
+  {
+    static const int Dim = MatrixType::ColsAtCompileTime-1;
+    mat.template block<1,Dim>(Dim,0).setZero();
+    mat.coeffRef(Dim,Dim) = typename MatrixType::Scalar(1);
+  }
+};
+
+template<>
+struct transform_make_affine<AffineCompact>
+{
+  template<typename MatrixType> EIGEN_DEVICE_FUNC static void run(MatrixType &) { }
+};
+
+// selector needed to avoid taking the inverse of a 3x4 matrix
+template<typename TransformType, int Mode=TransformType::Mode>
+struct projective_transform_inverse
+{
+  EIGEN_DEVICE_FUNC static inline void run(const TransformType&, TransformType&)
+  {}
+};
+
+template<typename TransformType>
+struct projective_transform_inverse<TransformType, Projective>
+{
+  EIGEN_DEVICE_FUNC static inline void run(const TransformType& m, TransformType& res)
+  {
+    res.matrix() = m.matrix().inverse();
+  }
+};
+
+} // end namespace internal
+
+
+/**
+  *
+  * \returns the inverse transformation according to some given knowledge
+  * on \c *this.
+  *
+  * \param hint allows to optimize the inversion process when the transformation
+  * is known to be not a general transformation (optional). The possible values are:
+  *  - #Projective if the transformation is not necessarily affine, i.e., if the
+  *    last row is not guaranteed to be [0 ... 0 1]
+  *  - #Affine if the last row can be assumed to be [0 ... 0 1]
+  *  - #Isometry if the transformation is only a concatenations of translations
+  *    and rotations.
+  *  The default is the template class parameter \c Mode.
+  *
+  * \warning unless \a traits is always set to NoShear or NoScaling, this function
+  * requires the generic inverse method of MatrixBase defined in the LU module. If
+  * you forget to include this module, then you will get hard to debug linking errors.
+  *
+  * \sa MatrixBase::inverse()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>
+Transform<Scalar,Dim,Mode,Options>::inverse(TransformTraits hint) const
+{
+  Transform res;
+  if (hint == Projective)
+  {
+    internal::projective_transform_inverse<Transform>::run(*this, res);
+  }
+  else
+  {
+    if (hint == Isometry)
+    {
+      res.matrix().template topLeftCorner<Dim,Dim>() = linear().transpose();
+    }
+    else if(hint&Affine)
+    {
+      res.matrix().template topLeftCorner<Dim,Dim>() = linear().inverse();
+    }
+    else
+    {
+      eigen_assert(false && "Invalid transform traits in Transform::Inverse");
+    }
+    // translation and remaining parts
+    res.matrix().template topRightCorner<Dim,1>()
+      = - res.matrix().template topLeftCorner<Dim,Dim>() * translation();
+    res.makeAffine(); // we do need this, because in the beginning res is uninitialized
+  }
+  return res;
+}
+
+namespace internal {
+
+/*****************************************************
+*** Specializations of take affine part            ***
+*****************************************************/
+
+template<typename TransformType> struct transform_take_affine_part {
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef typename TransformType::AffinePart AffinePart;
+  typedef typename TransformType::ConstAffinePart ConstAffinePart;
+  static inline AffinePart run(MatrixType& m)
+  { return m.template block<TransformType::Dim,TransformType::HDim>(0,0); }
+  static inline ConstAffinePart run(const MatrixType& m)
+  { return m.template block<TransformType::Dim,TransformType::HDim>(0,0); }
+};
+
+template<typename Scalar, int Dim, int Options>
+struct transform_take_affine_part<Transform<Scalar,Dim,AffineCompact, Options> > {
+  typedef typename Transform<Scalar,Dim,AffineCompact,Options>::MatrixType MatrixType;
+  static inline MatrixType& run(MatrixType& m) { return m; }
+  static inline const MatrixType& run(const MatrixType& m) { return m; }
+};
+
+/*****************************************************
+*** Specializations of construct from matrix       ***
+*****************************************************/
+
+template<typename Other, int Mode, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, Dim,Dim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
+  {
+    transform->linear() = other;
+    transform->translation().setZero();
+    transform->makeAffine();
+  }
+};
+
+template<typename Other, int Mode, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, Dim,HDim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
+  {
+    transform->affine() = other;
+    transform->makeAffine();
+  }
+};
+
+template<typename Other, int Mode, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, HDim,HDim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
+  { transform->matrix() = other; }
+};
+
+template<typename Other, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, AffineCompact,Options,Dim,HDim, HDim,HDim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,AffineCompact,Options> *transform, const Other& other)
+  { transform->matrix() = other.template block<Dim,HDim>(0,0); }
+};
+
+/**********************************************************
+***   Specializations of operator* with rhs EigenBase   ***
+**********************************************************/
+
+template<int LhsMode,int RhsMode>
+struct transform_product_result
+{
+  enum
+  {
+    Mode =
+      (LhsMode == (int)Projective    || RhsMode == (int)Projective    ) ? Projective :
+      (LhsMode == (int)Affine        || RhsMode == (int)Affine        ) ? Affine :
+      (LhsMode == (int)AffineCompact || RhsMode == (int)AffineCompact ) ? AffineCompact :
+      (LhsMode == (int)Isometry      || RhsMode == (int)Isometry      ) ? Isometry : Projective
+  };
+};
+
+template< typename TransformType, typename MatrixType, int RhsCols>
+struct transform_right_product_impl< TransformType, MatrixType, 0, RhsCols>
+{
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    return T.matrix() * other;
+  }
+};
+
+template< typename TransformType, typename MatrixType, int RhsCols>
+struct transform_right_product_impl< TransformType, MatrixType, 1, RhsCols>
+{
+  enum {
+    Dim = TransformType::Dim,
+    HDim = TransformType::HDim,
+    OtherRows = MatrixType::RowsAtCompileTime,
+    OtherCols = MatrixType::ColsAtCompileTime
+  };
+
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    EIGEN_STATIC_ASSERT(OtherRows==HDim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
+
+    typedef Block<ResultType, Dim, OtherCols, int(MatrixType::RowsAtCompileTime)==Dim> TopLeftLhs;
+
+    ResultType res(other.rows(),other.cols());
+    TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() = T.affine() * other;
+    res.row(OtherRows-1) = other.row(OtherRows-1);
+
+    return res;
+  }
+};
+
+template< typename TransformType, typename MatrixType, int RhsCols>
+struct transform_right_product_impl< TransformType, MatrixType, 2, RhsCols>
+{
+  enum {
+    Dim = TransformType::Dim,
+    HDim = TransformType::HDim,
+    OtherRows = MatrixType::RowsAtCompileTime,
+    OtherCols = MatrixType::ColsAtCompileTime
+  };
+
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    EIGEN_STATIC_ASSERT(OtherRows==Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
+
+    typedef Block<ResultType, Dim, OtherCols, true> TopLeftLhs;
+    ResultType res(Replicate<typename TransformType::ConstTranslationPart, 1, OtherCols>(T.translation(),1,other.cols()));
+    TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() += T.linear() * other;
+
+    return res;
+  }
+};
+
+template< typename TransformType, typename MatrixType >
+struct transform_right_product_impl< TransformType, MatrixType, 2, 1> // rhs is a vector of size Dim
+{
+  typedef typename TransformType::MatrixType TransformMatrix;
+  enum {
+    Dim = TransformType::Dim,
+    HDim = TransformType::HDim,
+    OtherRows = MatrixType::RowsAtCompileTime,
+    WorkingRows = EIGEN_PLAIN_ENUM_MIN(TransformMatrix::RowsAtCompileTime,HDim)
+  };
+
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    EIGEN_STATIC_ASSERT(OtherRows==Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
+
+    Matrix<typename ResultType::Scalar, Dim+1, 1> rhs;
+    rhs.template head<Dim>() = other; rhs[Dim] = typename ResultType::Scalar(1);
+    Matrix<typename ResultType::Scalar, WorkingRows, 1> res(T.matrix() * rhs);
+    return res.template head<Dim>();
+  }
+};
+
+/**********************************************************
+***   Specializations of operator* with lhs EigenBase   ***
+**********************************************************/
+
+// generic HDim x HDim matrix * T => Projective
+template<typename Other,int Mode, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, HDim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef Transform<typename Other::Scalar,Dim,Projective,Options> ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  { return ResultType(other * tr.matrix()); }
+};
+
+// generic HDim x HDim matrix * AffineCompact => Projective
+template<typename Other, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,AffineCompact,Options,Dim,HDim, HDim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,AffineCompact,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef Transform<typename Other::Scalar,Dim,Projective,Options> ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  {
+    ResultType res;
+    res.matrix().noalias() = other.template block<HDim,Dim>(0,0) * tr.matrix();
+    res.matrix().col(Dim) += other.col(Dim);
+    return res;
+  }
+};
+
+// affine matrix * T
+template<typename Other,int Mode, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, Dim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef TransformType ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  {
+    ResultType res;
+    res.affine().noalias() = other * tr.matrix();
+    res.matrix().row(Dim) = tr.matrix().row(Dim);
+    return res;
+  }
+};
+
+// affine matrix * AffineCompact
+template<typename Other, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,AffineCompact,Options,Dim,HDim, Dim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,AffineCompact,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef TransformType ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  {
+    ResultType res;
+    res.matrix().noalias() = other.template block<Dim,Dim>(0,0) * tr.matrix();
+    res.translation() += other.col(Dim);
+    return res;
+  }
+};
+
+// linear matrix * T
+template<typename Other,int Mode, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, Dim,Dim>
+{
+  typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef TransformType ResultType;
+  static ResultType run(const Other& other, const TransformType& tr)
+  {
+    TransformType res;
+    if(Mode!=int(AffineCompact))
+      res.matrix().row(Dim) = tr.matrix().row(Dim);
+    res.matrix().template topRows<Dim>().noalias()
+      = other * tr.matrix().template topRows<Dim>();
+    return res;
+  }
+};
+
+/**********************************************************
+*** Specializations of operator* with another Transform ***
+**********************************************************/
+
+template<typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode,LhsOptions>,Transform<Scalar,Dim,RhsMode,RhsOptions>,false >
+{
+  enum { ResultMode = transform_product_result<LhsMode,RhsMode>::Mode };
+  typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,ResultMode,LhsOptions> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    ResultType res;
+    res.linear() = lhs.linear() * rhs.linear();
+    res.translation() = lhs.linear() * rhs.translation() + lhs.translation();
+    res.makeAffine();
+    return res;
+  }
+};
+
+template<typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode,LhsOptions>,Transform<Scalar,Dim,RhsMode,RhsOptions>,true >
+{
+  typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,Projective> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    return ResultType( lhs.matrix() * rhs.matrix() );
+  }
+};
+
+template<typename Scalar, int Dim, int LhsOptions, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,AffineCompact,LhsOptions>,Transform<Scalar,Dim,Projective,RhsOptions>,true >
+{
+  typedef Transform<Scalar,Dim,AffineCompact,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,Projective,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,Projective> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    ResultType res;
+    res.matrix().template topRows<Dim>() = lhs.matrix() * rhs.matrix();
+    res.matrix().row(Dim) = rhs.matrix().row(Dim);
+    return res;
+  }
+};
+
+template<typename Scalar, int Dim, int LhsOptions, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,Projective,LhsOptions>,Transform<Scalar,Dim,AffineCompact,RhsOptions>,true >
+{
+  typedef Transform<Scalar,Dim,Projective,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,AffineCompact,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,Projective> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    ResultType res(lhs.matrix().template leftCols<Dim>() * rhs.matrix());
+    res.matrix().col(Dim) += lhs.matrix().col(Dim);
+    return res;
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSFORM_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/Translation.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Translation.h
new file mode 100644
index 00000000..8c229012
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Translation.h
@@ -0,0 +1,202 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSLATION_H
+#define EIGEN_TRANSLATION_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Translation
+  *
+  * \brief Represents a translation transformation
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients.
+  * \tparam _Dim the  dimension of the space, can be a compile time value or Dynamic
+  *
+  * \note This class is not aimed to be used to store a translation transformation,
+  * but rather to make easier the constructions and updates of Transform objects.
+  *
+  * \sa class Scaling, class Transform
+  */
+template<typename _Scalar, int _Dim>
+class Translation
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim)
+  /** dimension of the space */
+  enum { Dim = _Dim };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  /** corresponding vector type */
+  typedef Matrix<Scalar,Dim,1> VectorType;
+  /** corresponding linear transformation matrix type */
+  typedef Matrix<Scalar,Dim,Dim> LinearMatrixType;
+  /** corresponding affine transformation type */
+  typedef Transform<Scalar,Dim,Affine> AffineTransformType;
+  /** corresponding isometric transformation type */
+  typedef Transform<Scalar,Dim,Isometry> IsometryTransformType;
+
+protected:
+
+  VectorType m_coeffs;
+
+public:
+
+  /** Default constructor without initialization. */
+  EIGEN_DEVICE_FUNC Translation() {}
+  /**  */
+  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy)
+  {
+    eigen_assert(Dim==2);
+    m_coeffs.x() = sx;
+    m_coeffs.y() = sy;
+  }
+  /**  */
+  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy, const Scalar& sz)
+  {
+    eigen_assert(Dim==3);
+    m_coeffs.x() = sx;
+    m_coeffs.y() = sy;
+    m_coeffs.z() = sz;
+  }
+  /** Constructs and initialize the translation transformation from a vector of translation coefficients */
+  EIGEN_DEVICE_FUNC explicit inline Translation(const VectorType& vector) : m_coeffs(vector) {}
+
+  /** \brief Returns the x-translation by value. **/
+  EIGEN_DEVICE_FUNC inline Scalar x() const { return m_coeffs.x(); }
+  /** \brief Returns the y-translation by value. **/
+  EIGEN_DEVICE_FUNC inline Scalar y() const { return m_coeffs.y(); }
+  /** \brief Returns the z-translation by value. **/
+  EIGEN_DEVICE_FUNC inline Scalar z() const { return m_coeffs.z(); }
+
+  /** \brief Returns the x-translation as a reference. **/
+  EIGEN_DEVICE_FUNC inline Scalar& x() { return m_coeffs.x(); }
+  /** \brief Returns the y-translation as a reference. **/
+  EIGEN_DEVICE_FUNC inline Scalar& y() { return m_coeffs.y(); }
+  /** \brief Returns the z-translation as a reference. **/
+  EIGEN_DEVICE_FUNC inline Scalar& z() { return m_coeffs.z(); }
+
+  EIGEN_DEVICE_FUNC const VectorType& vector() const { return m_coeffs; }
+  EIGEN_DEVICE_FUNC VectorType& vector() { return m_coeffs; }
+
+  EIGEN_DEVICE_FUNC const VectorType& translation() const { return m_coeffs; }
+  EIGEN_DEVICE_FUNC VectorType& translation() { return m_coeffs; }
+
+  /** Concatenates two translation */
+  EIGEN_DEVICE_FUNC inline Translation operator* (const Translation& other) const
+  { return Translation(m_coeffs + other.m_coeffs); }
+
+  /** Concatenates a translation and a uniform scaling */
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator* (const UniformScaling<Scalar>& other) const;
+
+  /** Concatenates a translation and a linear transformation */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator* (const EigenBase<OtherDerived>& linear) const;
+
+  /** Concatenates a translation and a rotation */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline IsometryTransformType operator*(const RotationBase<Derived,Dim>& r) const
+  { return *this * IsometryTransformType(r); }
+
+  /** \returns the concatenation of a linear transformation \a l with the translation \a t */
+  // its a nightmare to define a templated friend function outside its declaration
+  template<typename OtherDerived> friend
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator*(const EigenBase<OtherDerived>& linear, const Translation& t)
+  {
+    AffineTransformType res;
+    res.matrix().setZero();
+    res.linear() = linear.derived();
+    res.translation() = linear.derived() * t.m_coeffs;
+    res.matrix().row(Dim).setZero();
+    res(Dim,Dim) = Scalar(1);
+    return res;
+  }
+
+  /** Concatenates a translation and a transformation */
+  template<int Mode, int Options>
+  EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode> operator* (const Transform<Scalar,Dim,Mode,Options>& t) const
+  {
+    Transform<Scalar,Dim,Mode> res = t;
+    res.pretranslate(m_coeffs);
+    return res;
+  }
+
+  /** Applies translation to vector */
+  template<typename Derived>
+  inline typename internal::enable_if<Derived::IsVectorAtCompileTime,VectorType>::type
+  operator* (const MatrixBase<Derived>& vec) const
+  { return m_coeffs + vec.derived(); }
+
+  /** \returns the inverse translation (opposite) */
+  Translation inverse() const { return Translation(-m_coeffs); }
+
+  static const Translation Identity() { return Translation(VectorType::Zero()); }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::type cast() const
+  { return typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Translation(const Translation<OtherScalarType,Dim>& other)
+  { m_coeffs = other.vector().template cast<Scalar>(); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Translation& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_coeffs.isApprox(other.m_coeffs, prec); }
+
+};
+
+/** \addtogroup Geometry_Module */
+//@{
+typedef Translation<float, 2> Translation2f;
+typedef Translation<double,2> Translation2d;
+typedef Translation<float, 3> Translation3f;
+typedef Translation<double,3> Translation3d;
+//@}
+
+template<typename Scalar, int Dim>
+EIGEN_DEVICE_FUNC inline typename Translation<Scalar,Dim>::AffineTransformType
+Translation<Scalar,Dim>::operator* (const UniformScaling<Scalar>& other) const
+{
+  AffineTransformType res;
+  res.matrix().setZero();
+  res.linear().diagonal().fill(other.factor());
+  res.translation() = m_coeffs;
+  res(Dim,Dim) = Scalar(1);
+  return res;
+}
+
+template<typename Scalar, int Dim>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline typename Translation<Scalar,Dim>::AffineTransformType
+Translation<Scalar,Dim>::operator* (const EigenBase<OtherDerived>& linear) const
+{
+  AffineTransformType res;
+  res.matrix().setZero();
+  res.linear() = linear.derived();
+  res.translation() = m_coeffs;
+  res.matrix().row(Dim).setZero();
+  res(Dim,Dim) = Scalar(1);
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSLATION_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/Umeyama.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Umeyama.h
new file mode 100644
index 00000000..6b755008
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/Umeyama.h
@@ -0,0 +1,166 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UMEYAMA_H
+#define EIGEN_UMEYAMA_H
+
+// This file requires the user to include 
+// * Eigen/Core
+// * Eigen/LU 
+// * Eigen/SVD
+// * Eigen/Array
+
+namespace Eigen { 
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+// These helpers are required since it allows to use mixed types as parameters
+// for the Umeyama. The problem with mixed parameters is that the return type
+// cannot trivially be deduced when float and double types are mixed.
+namespace internal {
+
+// Compile time return type deduction for different MatrixBase types.
+// Different means here different alignment and parameters but the same underlying
+// real scalar type.
+template<typename MatrixType, typename OtherMatrixType>
+struct umeyama_transform_matrix_type
+{
+  enum {
+    MinRowsAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(MatrixType::RowsAtCompileTime, OtherMatrixType::RowsAtCompileTime),
+
+    // When possible we want to choose some small fixed size value since the result
+    // is likely to fit on the stack. So here, EIGEN_SIZE_MIN_PREFER_DYNAMIC is not what we want.
+    HomogeneousDimension = int(MinRowsAtCompileTime) == Dynamic ? Dynamic : int(MinRowsAtCompileTime)+1
+  };
+
+  typedef Matrix<typename traits<MatrixType>::Scalar,
+    HomogeneousDimension,
+    HomogeneousDimension,
+    AutoAlign | (traits<MatrixType>::Flags & RowMajorBit ? RowMajor : ColMajor),
+    HomogeneousDimension,
+    HomogeneousDimension
+  > type;
+};
+
+}
+
+#endif
+
+/**
+* \geometry_module \ingroup Geometry_Module
+*
+* \brief Returns the transformation between two point sets.
+*
+* The algorithm is based on:
+* "Least-squares estimation of transformation parameters between two point patterns",
+* Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573
+*
+* It estimates parameters \f$ c, \mathbf{R}, \f$ and \f$ \mathbf{t} \f$ such that
+* \f{align*}
+*   \frac{1}{n} \sum_{i=1}^n \vert\vert y_i - (c\mathbf{R}x_i + \mathbf{t}) \vert\vert_2^2
+* \f}
+* is minimized.
+*
+* The algorithm is based on the analysis of the covariance matrix
+* \f$ \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \f$
+* of the input point sets \f$ \mathbf{x} \f$ and \f$ \mathbf{y} \f$ where 
+* \f$d\f$ is corresponding to the dimension (which is typically small).
+* The analysis is involving the SVD having a complexity of \f$O(d^3)\f$
+* though the actual computational effort lies in the covariance
+* matrix computation which has an asymptotic lower bound of \f$O(dm)\f$ when 
+* the input point sets have dimension \f$d \times m\f$.
+*
+* Currently the method is working only for floating point matrices.
+*
+* \todo Should the return type of umeyama() become a Transform?
+*
+* \param src Source points \f$ \mathbf{x} = \left( x_1, \hdots, x_n \right) \f$.
+* \param dst Destination points \f$ \mathbf{y} = \left( y_1, \hdots, y_n \right) \f$.
+* \param with_scaling Sets \f$ c=1 \f$ when <code>false</code> is passed.
+* \return The homogeneous transformation 
+* \f{align*}
+*   T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix}
+* \f}
+* minimizing the residual above. This transformation is always returned as an 
+* Eigen::Matrix.
+*/
+template <typename Derived, typename OtherDerived>
+typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type
+umeyama(const MatrixBase<Derived>& src, const MatrixBase<OtherDerived>& dst, bool with_scaling = true)
+{
+  typedef typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type TransformationMatrixType;
+  typedef typename internal::traits<TransformationMatrixType>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename internal::traits<OtherDerived>::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  enum { Dimension = EIGEN_SIZE_MIN_PREFER_DYNAMIC(Derived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime) };
+
+  typedef Matrix<Scalar, Dimension, 1> VectorType;
+  typedef Matrix<Scalar, Dimension, Dimension> MatrixType;
+  typedef typename internal::plain_matrix_type_row_major<Derived>::type RowMajorMatrixType;
+
+  const Index m = src.rows(); // dimension
+  const Index n = src.cols(); // number of measurements
+
+  // required for demeaning ...
+  const RealScalar one_over_n = RealScalar(1) / static_cast<RealScalar>(n);
+
+  // computation of mean
+  const VectorType src_mean = src.rowwise().sum() * one_over_n;
+  const VectorType dst_mean = dst.rowwise().sum() * one_over_n;
+
+  // demeaning of src and dst points
+  const RowMajorMatrixType src_demean = src.colwise() - src_mean;
+  const RowMajorMatrixType dst_demean = dst.colwise() - dst_mean;
+
+  // Eq. (36)-(37)
+  const Scalar src_var = src_demean.rowwise().squaredNorm().sum() * one_over_n;
+
+  // Eq. (38)
+  const MatrixType sigma = one_over_n * dst_demean * src_demean.transpose();
+
+  JacobiSVD<MatrixType> svd(sigma, ComputeFullU | ComputeFullV);
+
+  // Initialize the resulting transformation with an identity matrix...
+  TransformationMatrixType Rt = TransformationMatrixType::Identity(m+1,m+1);
+
+  // Eq. (39)
+  VectorType S = VectorType::Ones(m);
+
+  if  ( svd.matrixU().determinant() * svd.matrixV().determinant() < 0 )
+    S(m-1) = -1;
+
+  // Eq. (40) and (43)
+  Rt.block(0,0,m,m).noalias() = svd.matrixU() * S.asDiagonal() * svd.matrixV().transpose();
+
+  if (with_scaling)
+  {
+    // Eq. (42)
+    const Scalar c = Scalar(1)/src_var * svd.singularValues().dot(S);
+
+    // Eq. (41)
+    Rt.col(m).head(m) = dst_mean;
+    Rt.col(m).head(m).noalias() -= c*Rt.topLeftCorner(m,m)*src_mean;
+    Rt.block(0,0,m,m) *= c;
+  }
+  else
+  {
+    Rt.col(m).head(m) = dst_mean;
+    Rt.col(m).head(m).noalias() -= Rt.topLeftCorner(m,m)*src_mean;
+  }
+
+  return Rt;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_UMEYAMA_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Geometry/arch/Geometry_SIMD.h b/C++/yolo_bytetrack/include/Eigen/src/Geometry/arch/Geometry_SIMD.h
new file mode 100644
index 00000000..9af6a9af
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Geometry/arch/Geometry_SIMD.h
@@ -0,0 +1,168 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Rohit Garg <rpg.314@gmail.com>
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GEOMETRY_SIMD_H
+#define EIGEN_GEOMETRY_SIMD_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<class Derived, class OtherDerived>
+struct quat_product<Architecture::Target, Derived, OtherDerived, float>
+{
+  enum {
+    AAlignment = traits<Derived>::Alignment,
+    BAlignment = traits<OtherDerived>::Alignment,
+    ResAlignment = traits<Quaternion<float> >::Alignment
+  };
+  static inline Quaternion<float> run(const QuaternionBase<Derived>& _a, const QuaternionBase<OtherDerived>& _b)
+  {
+    evaluator<typename Derived::Coefficients> ae(_a.coeffs());
+    evaluator<typename OtherDerived::Coefficients> be(_b.coeffs());
+    Quaternion<float> res;
+    const float neg_zero = numext::bit_cast<float>(0x80000000u);
+    const float arr[4] = {0.f, 0.f, 0.f, neg_zero};
+    const Packet4f mask = ploadu<Packet4f>(arr);
+    Packet4f a = ae.template packet<AAlignment,Packet4f>(0);
+    Packet4f b = be.template packet<BAlignment,Packet4f>(0);
+    Packet4f s1 = pmul(vec4f_swizzle1(a,1,2,0,2),vec4f_swizzle1(b,2,0,1,2));
+    Packet4f s2 = pmul(vec4f_swizzle1(a,3,3,3,1),vec4f_swizzle1(b,0,1,2,1));
+    pstoret<float,Packet4f,ResAlignment>(
+              &res.x(),
+              padd(psub(pmul(a,vec4f_swizzle1(b,3,3,3,3)),
+                                    pmul(vec4f_swizzle1(a,2,0,1,0),
+                                               vec4f_swizzle1(b,1,2,0,0))),
+                         pxor(mask,padd(s1,s2))));
+    
+    return res;
+  }
+};
+
+template<class Derived>
+struct quat_conj<Architecture::Target, Derived, float>
+{
+  enum {
+    ResAlignment = traits<Quaternion<float> >::Alignment
+  };
+  static inline Quaternion<float> run(const QuaternionBase<Derived>& q)
+  {
+    evaluator<typename Derived::Coefficients> qe(q.coeffs());
+    Quaternion<float> res;
+    const float neg_zero = numext::bit_cast<float>(0x80000000u);
+    const float arr[4] = {neg_zero, neg_zero, neg_zero,0.f};
+    const Packet4f mask = ploadu<Packet4f>(arr);
+    pstoret<float,Packet4f,ResAlignment>(&res.x(), pxor(mask, qe.template packet<traits<Derived>::Alignment,Packet4f>(0)));
+    return res;
+  }
+};
+
+
+template<typename VectorLhs,typename VectorRhs>
+struct cross3_impl<Architecture::Target,VectorLhs,VectorRhs,float,true>
+{
+  enum {
+    ResAlignment = traits<typename plain_matrix_type<VectorLhs>::type>::Alignment
+  };
+  static inline typename plain_matrix_type<VectorLhs>::type
+  run(const VectorLhs& lhs, const VectorRhs& rhs)
+  {
+    evaluator<VectorLhs> lhs_eval(lhs);
+    evaluator<VectorRhs> rhs_eval(rhs);
+    Packet4f a = lhs_eval.template packet<traits<VectorLhs>::Alignment,Packet4f>(0);
+    Packet4f b = rhs_eval.template packet<traits<VectorRhs>::Alignment,Packet4f>(0);
+    Packet4f mul1 = pmul(vec4f_swizzle1(a,1,2,0,3),vec4f_swizzle1(b,2,0,1,3));
+    Packet4f mul2 = pmul(vec4f_swizzle1(a,2,0,1,3),vec4f_swizzle1(b,1,2,0,3));
+    typename plain_matrix_type<VectorLhs>::type res;
+    pstoret<float,Packet4f,ResAlignment>(&res.x(),psub(mul1,mul2));
+    return res;
+  }
+};
+
+
+
+#if (defined EIGEN_VECTORIZE_SSE) || (EIGEN_ARCH_ARM64)
+
+template<class Derived, class OtherDerived>
+struct quat_product<Architecture::Target, Derived, OtherDerived, double>
+{
+  enum {
+    BAlignment = traits<OtherDerived>::Alignment,
+    ResAlignment = traits<Quaternion<double> >::Alignment
+  };
+
+  static inline Quaternion<double> run(const QuaternionBase<Derived>& _a, const QuaternionBase<OtherDerived>& _b)
+  {
+  Quaternion<double> res;
+
+  evaluator<typename Derived::Coefficients> ae(_a.coeffs());
+  evaluator<typename OtherDerived::Coefficients> be(_b.coeffs());
+
+  const double* a = _a.coeffs().data();
+  Packet2d b_xy = be.template packet<BAlignment,Packet2d>(0);
+  Packet2d b_zw = be.template packet<BAlignment,Packet2d>(2);
+  Packet2d a_xx = pset1<Packet2d>(a[0]);
+  Packet2d a_yy = pset1<Packet2d>(a[1]);
+  Packet2d a_zz = pset1<Packet2d>(a[2]);
+  Packet2d a_ww = pset1<Packet2d>(a[3]);
+
+  // two temporaries:
+  Packet2d t1, t2;
+
+  /*
+   * t1 = ww*xy + yy*zw
+   * t2 = zz*xy - xx*zw
+   * res.xy = t1 +/- swap(t2)
+   */
+  t1 = padd(pmul(a_ww, b_xy), pmul(a_yy, b_zw));
+  t2 = psub(pmul(a_zz, b_xy), pmul(a_xx, b_zw));
+  pstoret<double,Packet2d,ResAlignment>(&res.x(), paddsub(t1, preverse(t2)));
+  
+  /*
+   * t1 = ww*zw - yy*xy
+   * t2 = zz*zw + xx*xy
+   * res.zw = t1 -/+ swap(t2) = swap( swap(t1) +/- t2)
+   */
+  t1 = psub(pmul(a_ww, b_zw), pmul(a_yy, b_xy));
+  t2 = padd(pmul(a_zz, b_zw), pmul(a_xx, b_xy));
+  pstoret<double,Packet2d,ResAlignment>(&res.z(), preverse(paddsub(preverse(t1), t2)));
+
+  return res;
+}
+};
+
+template<class Derived>
+struct quat_conj<Architecture::Target, Derived, double>
+{
+  enum {
+    ResAlignment = traits<Quaternion<double> >::Alignment
+  };
+  static inline Quaternion<double> run(const QuaternionBase<Derived>& q)
+  {
+    evaluator<typename Derived::Coefficients> qe(q.coeffs());
+    Quaternion<double> res;
+    const double neg_zero = numext::bit_cast<double>(0x8000000000000000ull);
+    const double arr1[2] = {neg_zero, neg_zero};
+    const double arr2[2] = {neg_zero,  0.0};
+    const Packet2d mask0 = ploadu<Packet2d>(arr1);
+    const Packet2d mask2 = ploadu<Packet2d>(arr2);
+    pstoret<double,Packet2d,ResAlignment>(&res.x(), pxor(mask0, qe.template packet<traits<Derived>::Alignment,Packet2d>(0)));
+    pstoret<double,Packet2d,ResAlignment>(&res.z(), pxor(mask2, qe.template packet<traits<Derived>::Alignment,Packet2d>(2)));
+    return res;
+  }
+};
+
+#endif // end EIGEN_VECTORIZE_SSE_OR_EIGEN_ARCH_ARM64
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GEOMETRY_SIMD_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Householder/BlockHouseholder.h b/C++/yolo_bytetrack/include/Eigen/src/Householder/BlockHouseholder.h
new file mode 100644
index 00000000..39ce1c2a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Householder/BlockHouseholder.h
@@ -0,0 +1,110 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Vincent Lejeune
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BLOCK_HOUSEHOLDER_H
+#define EIGEN_BLOCK_HOUSEHOLDER_H
+
+// This file contains some helper function to deal with block householder reflectors
+
+namespace Eigen { 
+
+namespace internal {
+  
+/** \internal */
+// template<typename TriangularFactorType,typename VectorsType,typename CoeffsType>
+// void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs)
+// {
+//   typedef typename VectorsType::Scalar Scalar;
+//   const Index nbVecs = vectors.cols();
+//   eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs);
+// 
+//   for(Index i = 0; i < nbVecs; i++)
+//   {
+//     Index rs = vectors.rows() - i;
+//     // Warning, note that hCoeffs may alias with vectors.
+//     // It is then necessary to copy it before modifying vectors(i,i). 
+//     typename CoeffsType::Scalar h = hCoeffs(i);
+//     // This hack permits to pass trough nested Block<> and Transpose<> expressions.
+//     Scalar *Vii_ptr = const_cast<Scalar*>(vectors.data() + vectors.outerStride()*i + vectors.innerStride()*i);
+//     Scalar Vii = *Vii_ptr;
+//     *Vii_ptr = Scalar(1);
+//     triFactor.col(i).head(i).noalias() = -h * vectors.block(i, 0, rs, i).adjoint()
+//                                        * vectors.col(i).tail(rs);
+//     *Vii_ptr = Vii;
+//     // FIXME add .noalias() once the triangular product can work inplace
+//     triFactor.col(i).head(i) = triFactor.block(0,0,i,i).template triangularView<Upper>()
+//                              * triFactor.col(i).head(i);
+//     triFactor(i,i) = hCoeffs(i);
+//   }
+// }
+
+/** \internal */
+// This variant avoid modifications in vectors
+template<typename TriangularFactorType,typename VectorsType,typename CoeffsType>
+void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs)
+{
+  const Index nbVecs = vectors.cols();
+  eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs);
+
+  for(Index i = nbVecs-1; i >=0 ; --i)
+  {
+    Index rs = vectors.rows() - i - 1;
+    Index rt = nbVecs-i-1;
+
+    if(rt>0)
+    {
+      triFactor.row(i).tail(rt).noalias() = -hCoeffs(i) * vectors.col(i).tail(rs).adjoint()
+                                                        * vectors.bottomRightCorner(rs, rt).template triangularView<UnitLower>();
+            
+      // FIXME use the following line with .noalias() once the triangular product can work inplace
+      // triFactor.row(i).tail(rt) = triFactor.row(i).tail(rt) * triFactor.bottomRightCorner(rt,rt).template triangularView<Upper>();
+      for(Index j=nbVecs-1; j>i; --j)
+      {
+        typename TriangularFactorType::Scalar z = triFactor(i,j);
+        triFactor(i,j) = z * triFactor(j,j);
+        if(nbVecs-j-1>0)
+          triFactor.row(i).tail(nbVecs-j-1) += z * triFactor.row(j).tail(nbVecs-j-1);
+      }
+      
+    }
+    triFactor(i,i) = hCoeffs(i);
+  }
+}
+
+/** \internal
+  * if forward then perform   mat = H0 * H1 * H2 * mat
+  * otherwise perform         mat = H2 * H1 * H0 * mat
+  */
+template<typename MatrixType,typename VectorsType,typename CoeffsType>
+void apply_block_householder_on_the_left(MatrixType& mat, const VectorsType& vectors, const CoeffsType& hCoeffs, bool forward)
+{
+  enum { TFactorSize = MatrixType::ColsAtCompileTime };
+  Index nbVecs = vectors.cols();
+  Matrix<typename MatrixType::Scalar, TFactorSize, TFactorSize, RowMajor> T(nbVecs,nbVecs);
+  
+  if(forward) make_block_householder_triangular_factor(T, vectors, hCoeffs);
+  else        make_block_householder_triangular_factor(T, vectors, hCoeffs.conjugate());  
+  const TriangularView<const VectorsType, UnitLower> V(vectors);
+
+  // A -= V T V^* A
+  Matrix<typename MatrixType::Scalar,VectorsType::ColsAtCompileTime,MatrixType::ColsAtCompileTime,
+         (VectorsType::MaxColsAtCompileTime==1 && MatrixType::MaxColsAtCompileTime!=1)?RowMajor:ColMajor,
+         VectorsType::MaxColsAtCompileTime,MatrixType::MaxColsAtCompileTime> tmp = V.adjoint() * mat;
+  // FIXME add .noalias() once the triangular product can work inplace
+  if(forward) tmp = T.template triangularView<Upper>()           * tmp;
+  else        tmp = T.template triangularView<Upper>().adjoint() * tmp;
+  mat.noalias() -= V * tmp;
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BLOCK_HOUSEHOLDER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Householder/Householder.h b/C++/yolo_bytetrack/include/Eigen/src/Householder/Householder.h
new file mode 100644
index 00000000..5bc037f0
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Householder/Householder.h
@@ -0,0 +1,176 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOUSEHOLDER_H
+#define EIGEN_HOUSEHOLDER_H
+
+namespace Eigen { 
+
+namespace internal {
+template<int n> struct decrement_size
+{
+  enum {
+    ret = n==Dynamic ? n : n-1
+  };
+};
+}
+
+/** Computes the elementary reflector H such that:
+  * \f$ H *this = [ beta 0 ... 0]^T \f$
+  * where the transformation H is:
+  * \f$ H = I - tau v v^*\f$
+  * and the vector v is:
+  * \f$ v^T = [1 essential^T] \f$
+  *
+  * The essential part of the vector \c v is stored in *this.
+  * 
+  * On output:
+  * \param tau the scaling factor of the Householder transformation
+  * \param beta the result of H * \c *this
+  *
+  * \sa MatrixBase::makeHouseholder(), MatrixBase::applyHouseholderOnTheLeft(),
+  *     MatrixBase::applyHouseholderOnTheRight()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+void MatrixBase<Derived>::makeHouseholderInPlace(Scalar& tau, RealScalar& beta)
+{
+  VectorBlock<Derived, internal::decrement_size<Base::SizeAtCompileTime>::ret> essentialPart(derived(), 1, size()-1);
+  makeHouseholder(essentialPart, tau, beta);
+}
+
+/** Computes the elementary reflector H such that:
+  * \f$ H *this = [ beta 0 ... 0]^T \f$
+  * where the transformation H is:
+  * \f$ H = I - tau v v^*\f$
+  * and the vector v is:
+  * \f$ v^T = [1 essential^T] \f$
+  *
+  * On output:
+  * \param essential the essential part of the vector \c v
+  * \param tau the scaling factor of the Householder transformation
+  * \param beta the result of H * \c *this
+  *
+  * \sa MatrixBase::makeHouseholderInPlace(), MatrixBase::applyHouseholderOnTheLeft(),
+  *     MatrixBase::applyHouseholderOnTheRight()
+  */
+template<typename Derived>
+template<typename EssentialPart>
+EIGEN_DEVICE_FUNC
+void MatrixBase<Derived>::makeHouseholder(
+  EssentialPart& essential,
+  Scalar& tau,
+  RealScalar& beta) const
+{
+  using std::sqrt;
+  using numext::conj;
+  
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(EssentialPart)
+  VectorBlock<const Derived, EssentialPart::SizeAtCompileTime> tail(derived(), 1, size()-1);
+  
+  RealScalar tailSqNorm = size()==1 ? RealScalar(0) : tail.squaredNorm();
+  Scalar c0 = coeff(0);
+  const RealScalar tol = (std::numeric_limits<RealScalar>::min)();
+
+  if(tailSqNorm <= tol && numext::abs2(numext::imag(c0))<=tol)
+  {
+    tau = RealScalar(0);
+    beta = numext::real(c0);
+    essential.setZero();
+  }
+  else
+  {
+    beta = sqrt(numext::abs2(c0) + tailSqNorm);
+    if (numext::real(c0)>=RealScalar(0))
+      beta = -beta;
+    essential = tail / (c0 - beta);
+    tau = conj((beta - c0) / beta);
+  }
+}
+
+/** Apply the elementary reflector H given by
+  * \f$ H = I - tau v v^*\f$
+  * with
+  * \f$ v^T = [1 essential^T] \f$
+  * from the left to a vector or matrix.
+  *
+  * On input:
+  * \param essential the essential part of the vector \c v
+  * \param tau the scaling factor of the Householder transformation
+  * \param workspace a pointer to working space with at least
+  *                  this->cols() entries
+  *
+  * \sa MatrixBase::makeHouseholder(), MatrixBase::makeHouseholderInPlace(), 
+  *     MatrixBase::applyHouseholderOnTheRight()
+  */
+template<typename Derived>
+template<typename EssentialPart>
+EIGEN_DEVICE_FUNC
+void MatrixBase<Derived>::applyHouseholderOnTheLeft(
+  const EssentialPart& essential,
+  const Scalar& tau,
+  Scalar* workspace)
+{
+  if(rows() == 1)
+  {
+    *this *= Scalar(1)-tau;
+  }
+  else if(tau!=Scalar(0))
+  {
+    Map<typename internal::plain_row_type<PlainObject>::type> tmp(workspace,cols());
+    Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(derived(), 1, 0, rows()-1, cols());
+    tmp.noalias() = essential.adjoint() * bottom;
+    tmp += this->row(0);
+    this->row(0) -= tau * tmp;
+    bottom.noalias() -= tau * essential * tmp;
+  }
+}
+
+/** Apply the elementary reflector H given by
+  * \f$ H = I - tau v v^*\f$
+  * with
+  * \f$ v^T = [1 essential^T] \f$
+  * from the right to a vector or matrix.
+  *
+  * On input:
+  * \param essential the essential part of the vector \c v
+  * \param tau the scaling factor of the Householder transformation
+  * \param workspace a pointer to working space with at least
+  *                  this->rows() entries
+  *
+  * \sa MatrixBase::makeHouseholder(), MatrixBase::makeHouseholderInPlace(), 
+  *     MatrixBase::applyHouseholderOnTheLeft()
+  */
+template<typename Derived>
+template<typename EssentialPart>
+EIGEN_DEVICE_FUNC
+void MatrixBase<Derived>::applyHouseholderOnTheRight(
+  const EssentialPart& essential,
+  const Scalar& tau,
+  Scalar* workspace)
+{
+  if(cols() == 1)
+  {
+    *this *= Scalar(1)-tau;
+  }
+  else if(tau!=Scalar(0))
+  {
+    Map<typename internal::plain_col_type<PlainObject>::type> tmp(workspace,rows());
+    Block<Derived, Derived::RowsAtCompileTime, EssentialPart::SizeAtCompileTime> right(derived(), 0, 1, rows(), cols()-1);
+    tmp.noalias() = right * essential;
+    tmp += this->col(0);
+    this->col(0) -= tau * tmp;
+    right.noalias() -= tau * tmp * essential.adjoint();
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_HOUSEHOLDER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Householder/HouseholderSequence.h b/C++/yolo_bytetrack/include/Eigen/src/Householder/HouseholderSequence.h
new file mode 100644
index 00000000..022f6c3d
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Householder/HouseholderSequence.h
@@ -0,0 +1,545 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOUSEHOLDER_SEQUENCE_H
+#define EIGEN_HOUSEHOLDER_SEQUENCE_H
+
+namespace Eigen {
+
+/** \ingroup Householder_Module
+  * \householder_module
+  * \class HouseholderSequence
+  * \brief Sequence of Householder reflections acting on subspaces with decreasing size
+  * \tparam VectorsType type of matrix containing the Householder vectors
+  * \tparam CoeffsType  type of vector containing the Householder coefficients
+  * \tparam Side        either OnTheLeft (the default) or OnTheRight
+  *
+  * This class represents a product sequence of Householder reflections where the first Householder reflection
+  * acts on the whole space, the second Householder reflection leaves the one-dimensional subspace spanned by
+  * the first unit vector invariant, the third Householder reflection leaves the two-dimensional subspace
+  * spanned by the first two unit vectors invariant, and so on up to the last reflection which leaves all but
+  * one dimensions invariant and acts only on the last dimension. Such sequences of Householder reflections
+  * are used in several algorithms to zero out certain parts of a matrix. Indeed, the methods
+  * HessenbergDecomposition::matrixQ(), Tridiagonalization::matrixQ(), HouseholderQR::householderQ(),
+  * and ColPivHouseholderQR::householderQ() all return a %HouseholderSequence.
+  *
+  * More precisely, the class %HouseholderSequence represents an \f$ n \times n \f$ matrix \f$ H \f$ of the
+  * form \f$ H = \prod_{i=0}^{n-1} H_i \f$ where the i-th Householder reflection is \f$ H_i = I - h_i v_i
+  * v_i^* \f$. The i-th Householder coefficient \f$ h_i \f$ is a scalar and the i-th Householder vector \f$
+  * v_i \f$ is a vector of the form
+  * \f[
+  * v_i = [\underbrace{0, \ldots, 0}_{i-1\mbox{ zeros}}, 1, \underbrace{*, \ldots,*}_{n-i\mbox{ arbitrary entries}} ].
+  * \f]
+  * The last \f$ n-i \f$ entries of \f$ v_i \f$ are called the essential part of the Householder vector.
+  *
+  * Typical usages are listed below, where H is a HouseholderSequence:
+  * \code
+  * A.applyOnTheRight(H);             // A = A * H
+  * A.applyOnTheLeft(H);              // A = H * A
+  * A.applyOnTheRight(H.adjoint());   // A = A * H^*
+  * A.applyOnTheLeft(H.adjoint());    // A = H^* * A
+  * MatrixXd Q = H;                   // conversion to a dense matrix
+  * \endcode
+  * In addition to the adjoint, you can also apply the inverse (=adjoint), the transpose, and the conjugate operators.
+  *
+  * See the documentation for HouseholderSequence(const VectorsType&, const CoeffsType&) for an example.
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+
+namespace internal {
+
+template<typename VectorsType, typename CoeffsType, int Side>
+struct traits<HouseholderSequence<VectorsType,CoeffsType,Side> >
+{
+  typedef typename VectorsType::Scalar Scalar;
+  typedef typename VectorsType::StorageIndex StorageIndex;
+  typedef typename VectorsType::StorageKind StorageKind;
+  enum {
+    RowsAtCompileTime = Side==OnTheLeft ? traits<VectorsType>::RowsAtCompileTime
+                                        : traits<VectorsType>::ColsAtCompileTime,
+    ColsAtCompileTime = RowsAtCompileTime,
+    MaxRowsAtCompileTime = Side==OnTheLeft ? traits<VectorsType>::MaxRowsAtCompileTime
+                                           : traits<VectorsType>::MaxColsAtCompileTime,
+    MaxColsAtCompileTime = MaxRowsAtCompileTime,
+    Flags = 0
+  };
+};
+
+struct HouseholderSequenceShape {};
+
+template<typename VectorsType, typename CoeffsType, int Side>
+struct evaluator_traits<HouseholderSequence<VectorsType,CoeffsType,Side> >
+  : public evaluator_traits_base<HouseholderSequence<VectorsType,CoeffsType,Side> >
+{
+  typedef HouseholderSequenceShape Shape;
+};
+
+template<typename VectorsType, typename CoeffsType, int Side>
+struct hseq_side_dependent_impl
+{
+  typedef Block<const VectorsType, Dynamic, 1> EssentialVectorType;
+  typedef HouseholderSequence<VectorsType, CoeffsType, OnTheLeft> HouseholderSequenceType;
+  static EIGEN_DEVICE_FUNC inline const EssentialVectorType essentialVector(const HouseholderSequenceType& h, Index k)
+  {
+    Index start = k+1+h.m_shift;
+    return Block<const VectorsType,Dynamic,1>(h.m_vectors, start, k, h.rows()-start, 1);
+  }
+};
+
+template<typename VectorsType, typename CoeffsType>
+struct hseq_side_dependent_impl<VectorsType, CoeffsType, OnTheRight>
+{
+  typedef Transpose<Block<const VectorsType, 1, Dynamic> > EssentialVectorType;
+  typedef HouseholderSequence<VectorsType, CoeffsType, OnTheRight> HouseholderSequenceType;
+  static inline const EssentialVectorType essentialVector(const HouseholderSequenceType& h, Index k)
+  {
+    Index start = k+1+h.m_shift;
+    return Block<const VectorsType,1,Dynamic>(h.m_vectors, k, start, 1, h.rows()-start).transpose();
+  }
+};
+
+template<typename OtherScalarType, typename MatrixType> struct matrix_type_times_scalar_type
+{
+  typedef typename ScalarBinaryOpTraits<OtherScalarType, typename MatrixType::Scalar>::ReturnType
+    ResultScalar;
+  typedef Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime,
+                 0, MatrixType::MaxRowsAtCompileTime, MatrixType::MaxColsAtCompileTime> Type;
+};
+
+} // end namespace internal
+
+template<typename VectorsType, typename CoeffsType, int Side> class HouseholderSequence
+  : public EigenBase<HouseholderSequence<VectorsType,CoeffsType,Side> >
+{
+    typedef typename internal::hseq_side_dependent_impl<VectorsType,CoeffsType,Side>::EssentialVectorType EssentialVectorType;
+
+  public:
+    enum {
+      RowsAtCompileTime = internal::traits<HouseholderSequence>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<HouseholderSequence>::ColsAtCompileTime,
+      MaxRowsAtCompileTime = internal::traits<HouseholderSequence>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<HouseholderSequence>::MaxColsAtCompileTime
+    };
+    typedef typename internal::traits<HouseholderSequence>::Scalar Scalar;
+
+    typedef HouseholderSequence<
+      typename internal::conditional<NumTraits<Scalar>::IsComplex,
+        typename internal::remove_all<typename VectorsType::ConjugateReturnType>::type,
+        VectorsType>::type,
+      typename internal::conditional<NumTraits<Scalar>::IsComplex,
+        typename internal::remove_all<typename CoeffsType::ConjugateReturnType>::type,
+        CoeffsType>::type,
+      Side
+    > ConjugateReturnType;
+
+    typedef HouseholderSequence<
+      VectorsType,
+      typename internal::conditional<NumTraits<Scalar>::IsComplex,
+        typename internal::remove_all<typename CoeffsType::ConjugateReturnType>::type,
+        CoeffsType>::type,
+      Side
+    > AdjointReturnType;
+
+    typedef HouseholderSequence<
+      typename internal::conditional<NumTraits<Scalar>::IsComplex,
+        typename internal::remove_all<typename VectorsType::ConjugateReturnType>::type,
+        VectorsType>::type,
+      CoeffsType,
+      Side
+    > TransposeReturnType;
+
+    typedef HouseholderSequence<
+      typename internal::add_const<VectorsType>::type,
+      typename internal::add_const<CoeffsType>::type,
+      Side
+    > ConstHouseholderSequence;
+
+    /** \brief Constructor.
+      * \param[in]  v      %Matrix containing the essential parts of the Householder vectors
+      * \param[in]  h      Vector containing the Householder coefficients
+      *
+      * Constructs the Householder sequence with coefficients given by \p h and vectors given by \p v. The
+      * i-th Householder coefficient \f$ h_i \f$ is given by \p h(i) and the essential part of the i-th
+      * Householder vector \f$ v_i \f$ is given by \p v(k,i) with \p k > \p i (the subdiagonal part of the
+      * i-th column). If \p v has fewer columns than rows, then the Householder sequence contains as many
+      * Householder reflections as there are columns.
+      *
+      * \note The %HouseholderSequence object stores \p v and \p h by reference.
+      *
+      * Example: \include HouseholderSequence_HouseholderSequence.cpp
+      * Output: \verbinclude HouseholderSequence_HouseholderSequence.out
+      *
+      * \sa setLength(), setShift()
+      */
+    EIGEN_DEVICE_FUNC
+    HouseholderSequence(const VectorsType& v, const CoeffsType& h)
+      : m_vectors(v), m_coeffs(h), m_reverse(false), m_length(v.diagonalSize()),
+        m_shift(0)
+    {
+    }
+
+    /** \brief Copy constructor. */
+    EIGEN_DEVICE_FUNC
+    HouseholderSequence(const HouseholderSequence& other)
+      : m_vectors(other.m_vectors),
+        m_coeffs(other.m_coeffs),
+        m_reverse(other.m_reverse),
+        m_length(other.m_length),
+        m_shift(other.m_shift)
+    {
+    }
+
+    /** \brief Number of rows of transformation viewed as a matrix.
+      * \returns Number of rows
+      * \details This equals the dimension of the space that the transformation acts on.
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return Side==OnTheLeft ? m_vectors.rows() : m_vectors.cols(); }
+
+    /** \brief Number of columns of transformation viewed as a matrix.
+      * \returns Number of columns
+      * \details This equals the dimension of the space that the transformation acts on.
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return rows(); }
+
+    /** \brief Essential part of a Householder vector.
+      * \param[in]  k  Index of Householder reflection
+      * \returns    Vector containing non-trivial entries of k-th Householder vector
+      *
+      * This function returns the essential part of the Householder vector \f$ v_i \f$. This is a vector of
+      * length \f$ n-i \f$ containing the last \f$ n-i \f$ entries of the vector
+      * \f[
+      * v_i = [\underbrace{0, \ldots, 0}_{i-1\mbox{ zeros}}, 1, \underbrace{*, \ldots,*}_{n-i\mbox{ arbitrary entries}} ].
+      * \f]
+      * The index \f$ i \f$ equals \p k + shift(), corresponding to the k-th column of the matrix \p v
+      * passed to the constructor.
+      *
+      * \sa setShift(), shift()
+      */
+    EIGEN_DEVICE_FUNC
+    const EssentialVectorType essentialVector(Index k) const
+    {
+      eigen_assert(k >= 0 && k < m_length);
+      return internal::hseq_side_dependent_impl<VectorsType,CoeffsType,Side>::essentialVector(*this, k);
+    }
+
+    /** \brief %Transpose of the Householder sequence. */
+    TransposeReturnType transpose() const
+    {
+      return TransposeReturnType(m_vectors.conjugate(), m_coeffs)
+              .setReverseFlag(!m_reverse)
+              .setLength(m_length)
+              .setShift(m_shift);
+    }
+
+    /** \brief Complex conjugate of the Householder sequence. */
+    ConjugateReturnType conjugate() const
+    {
+      return ConjugateReturnType(m_vectors.conjugate(), m_coeffs.conjugate())
+             .setReverseFlag(m_reverse)
+             .setLength(m_length)
+             .setShift(m_shift);
+    }
+
+    /** \returns an expression of the complex conjugate of \c *this if Cond==true,
+     *           returns \c *this otherwise.
+     */
+    template<bool Cond>
+    EIGEN_DEVICE_FUNC
+    inline typename internal::conditional<Cond,ConjugateReturnType,ConstHouseholderSequence>::type
+    conjugateIf() const
+    {
+      typedef typename internal::conditional<Cond,ConjugateReturnType,ConstHouseholderSequence>::type ReturnType;
+      return ReturnType(m_vectors.template conjugateIf<Cond>(), m_coeffs.template conjugateIf<Cond>());
+    }
+
+    /** \brief Adjoint (conjugate transpose) of the Householder sequence. */
+    AdjointReturnType adjoint() const
+    {
+      return AdjointReturnType(m_vectors, m_coeffs.conjugate())
+              .setReverseFlag(!m_reverse)
+              .setLength(m_length)
+              .setShift(m_shift);
+    }
+
+    /** \brief Inverse of the Householder sequence (equals the adjoint). */
+    AdjointReturnType inverse() const { return adjoint(); }
+
+    /** \internal */
+    template<typename DestType>
+    inline EIGEN_DEVICE_FUNC
+    void evalTo(DestType& dst) const
+    {
+      Matrix<Scalar, DestType::RowsAtCompileTime, 1,
+             AutoAlign|ColMajor, DestType::MaxRowsAtCompileTime, 1> workspace(rows());
+      evalTo(dst, workspace);
+    }
+
+    /** \internal */
+    template<typename Dest, typename Workspace>
+    EIGEN_DEVICE_FUNC
+    void evalTo(Dest& dst, Workspace& workspace) const
+    {
+      workspace.resize(rows());
+      Index vecs = m_length;
+      if(internal::is_same_dense(dst,m_vectors))
+      {
+        // in-place
+        dst.diagonal().setOnes();
+        dst.template triangularView<StrictlyUpper>().setZero();
+        for(Index k = vecs-1; k >= 0; --k)
+        {
+          Index cornerSize = rows() - k - m_shift;
+          if(m_reverse)
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheRight(essentialVector(k), m_coeffs.coeff(k), workspace.data());
+          else
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheLeft(essentialVector(k), m_coeffs.coeff(k), workspace.data());
+
+          // clear the off diagonal vector
+          dst.col(k).tail(rows()-k-1).setZero();
+        }
+        // clear the remaining columns if needed
+        for(Index k = 0; k<cols()-vecs ; ++k)
+          dst.col(k).tail(rows()-k-1).setZero();
+      }
+      else if(m_length>BlockSize)
+      {
+        dst.setIdentity(rows(), rows());
+        if(m_reverse)
+          applyThisOnTheLeft(dst,workspace,true);
+        else
+          applyThisOnTheLeft(dst,workspace,true);
+      }
+      else
+      {
+        dst.setIdentity(rows(), rows());
+        for(Index k = vecs-1; k >= 0; --k)
+        {
+          Index cornerSize = rows() - k - m_shift;
+          if(m_reverse)
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheRight(essentialVector(k), m_coeffs.coeff(k), workspace.data());
+          else
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheLeft(essentialVector(k), m_coeffs.coeff(k), workspace.data());
+        }
+      }
+    }
+
+    /** \internal */
+    template<typename Dest> inline void applyThisOnTheRight(Dest& dst) const
+    {
+      Matrix<Scalar,1,Dest::RowsAtCompileTime,RowMajor,1,Dest::MaxRowsAtCompileTime> workspace(dst.rows());
+      applyThisOnTheRight(dst, workspace);
+    }
+
+    /** \internal */
+    template<typename Dest, typename Workspace>
+    inline void applyThisOnTheRight(Dest& dst, Workspace& workspace) const
+    {
+      workspace.resize(dst.rows());
+      for(Index k = 0; k < m_length; ++k)
+      {
+        Index actual_k = m_reverse ? m_length-k-1 : k;
+        dst.rightCols(rows()-m_shift-actual_k)
+           .applyHouseholderOnTheRight(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
+      }
+    }
+
+    /** \internal */
+    template<typename Dest> inline void applyThisOnTheLeft(Dest& dst, bool inputIsIdentity = false) const
+    {
+      Matrix<Scalar,1,Dest::ColsAtCompileTime,RowMajor,1,Dest::MaxColsAtCompileTime> workspace;
+      applyThisOnTheLeft(dst, workspace, inputIsIdentity);
+    }
+
+    /** \internal */
+    template<typename Dest, typename Workspace>
+    inline void applyThisOnTheLeft(Dest& dst, Workspace& workspace, bool inputIsIdentity = false) const
+    {
+      if(inputIsIdentity && m_reverse)
+        inputIsIdentity = false;
+      // if the entries are large enough, then apply the reflectors by block
+      if(m_length>=BlockSize && dst.cols()>1)
+      {
+        // Make sure we have at least 2 useful blocks, otherwise it is point-less:
+        Index blockSize = m_length<Index(2*BlockSize) ? (m_length+1)/2 : Index(BlockSize);
+        for(Index i = 0; i < m_length; i+=blockSize)
+        {
+          Index end = m_reverse ? (std::min)(m_length,i+blockSize) : m_length-i;
+          Index k = m_reverse ? i : (std::max)(Index(0),end-blockSize);
+          Index bs = end-k;
+          Index start = k + m_shift;
+
+          typedef Block<typename internal::remove_all<VectorsType>::type,Dynamic,Dynamic> SubVectorsType;
+          SubVectorsType sub_vecs1(m_vectors.const_cast_derived(), Side==OnTheRight ? k : start,
+                                                                   Side==OnTheRight ? start : k,
+                                                                   Side==OnTheRight ? bs : m_vectors.rows()-start,
+                                                                   Side==OnTheRight ? m_vectors.cols()-start : bs);
+          typename internal::conditional<Side==OnTheRight, Transpose<SubVectorsType>, SubVectorsType&>::type sub_vecs(sub_vecs1);
+
+          Index dstStart = dst.rows()-rows()+m_shift+k;
+          Index dstRows  = rows()-m_shift-k;
+          Block<Dest,Dynamic,Dynamic> sub_dst(dst,
+                                              dstStart,
+                                              inputIsIdentity ? dstStart : 0,
+                                              dstRows,
+                                              inputIsIdentity ? dstRows : dst.cols());
+          apply_block_householder_on_the_left(sub_dst, sub_vecs, m_coeffs.segment(k, bs), !m_reverse);
+        }
+      }
+      else
+      {
+        workspace.resize(dst.cols());
+        for(Index k = 0; k < m_length; ++k)
+        {
+          Index actual_k = m_reverse ? k : m_length-k-1;
+          Index dstStart = rows()-m_shift-actual_k;
+          dst.bottomRightCorner(dstStart, inputIsIdentity ? dstStart : dst.cols())
+            .applyHouseholderOnTheLeft(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
+        }
+      }
+    }
+
+    /** \brief Computes the product of a Householder sequence with a matrix.
+      * \param[in]  other  %Matrix being multiplied.
+      * \returns    Expression object representing the product.
+      *
+      * This function computes \f$ HM \f$ where \f$ H \f$ is the Householder sequence represented by \p *this
+      * and \f$ M \f$ is the matrix \p other.
+      */
+    template<typename OtherDerived>
+    typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type operator*(const MatrixBase<OtherDerived>& other) const
+    {
+      typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type
+        res(other.template cast<typename internal::matrix_type_times_scalar_type<Scalar,OtherDerived>::ResultScalar>());
+      applyThisOnTheLeft(res, internal::is_identity<OtherDerived>::value && res.rows()==res.cols());
+      return res;
+    }
+
+    template<typename _VectorsType, typename _CoeffsType, int _Side> friend struct internal::hseq_side_dependent_impl;
+
+    /** \brief Sets the length of the Householder sequence.
+      * \param [in]  length  New value for the length.
+      *
+      * By default, the length \f$ n \f$ of the Householder sequence \f$ H = H_0 H_1 \ldots H_{n-1} \f$ is set
+      * to the number of columns of the matrix \p v passed to the constructor, or the number of rows if that
+      * is smaller. After this function is called, the length equals \p length.
+      *
+      * \sa length()
+      */
+    EIGEN_DEVICE_FUNC
+    HouseholderSequence& setLength(Index length)
+    {
+      m_length = length;
+      return *this;
+    }
+
+    /** \brief Sets the shift of the Householder sequence.
+      * \param [in]  shift  New value for the shift.
+      *
+      * By default, a %HouseholderSequence object represents \f$ H = H_0 H_1 \ldots H_{n-1} \f$ and the i-th
+      * column of the matrix \p v passed to the constructor corresponds to the i-th Householder
+      * reflection. After this function is called, the object represents \f$ H = H_{\mathrm{shift}}
+      * H_{\mathrm{shift}+1} \ldots H_{n-1} \f$ and the i-th column of \p v corresponds to the (shift+i)-th
+      * Householder reflection.
+      *
+      * \sa shift()
+      */
+    EIGEN_DEVICE_FUNC
+    HouseholderSequence& setShift(Index shift)
+    {
+      m_shift = shift;
+      return *this;
+    }
+
+    EIGEN_DEVICE_FUNC
+    Index length() const { return m_length; }  /**< \brief Returns the length of the Householder sequence. */
+
+    EIGEN_DEVICE_FUNC
+    Index shift() const { return m_shift; }    /**< \brief Returns the shift of the Householder sequence. */
+
+    /* Necessary for .adjoint() and .conjugate() */
+    template <typename VectorsType2, typename CoeffsType2, int Side2> friend class HouseholderSequence;
+
+  protected:
+
+    /** \internal
+      * \brief Sets the reverse flag.
+      * \param [in]  reverse  New value of the reverse flag.
+      *
+      * By default, the reverse flag is not set. If the reverse flag is set, then this object represents
+      * \f$ H^r = H_{n-1} \ldots H_1 H_0 \f$ instead of \f$ H = H_0 H_1 \ldots H_{n-1} \f$.
+      * \note For real valued HouseholderSequence this is equivalent to transposing \f$ H \f$.
+      *
+      * \sa reverseFlag(), transpose(), adjoint()
+      */
+    HouseholderSequence& setReverseFlag(bool reverse)
+    {
+      m_reverse = reverse;
+      return *this;
+    }
+
+    bool reverseFlag() const { return m_reverse; }     /**< \internal \brief Returns the reverse flag. */
+
+    typename VectorsType::Nested m_vectors;
+    typename CoeffsType::Nested m_coeffs;
+    bool m_reverse;
+    Index m_length;
+    Index m_shift;
+    enum { BlockSize = 48 };
+};
+
+/** \brief Computes the product of a matrix with a Householder sequence.
+  * \param[in]  other  %Matrix being multiplied.
+  * \param[in]  h      %HouseholderSequence being multiplied.
+  * \returns    Expression object representing the product.
+  *
+  * This function computes \f$ MH \f$ where \f$ M \f$ is the matrix \p other and \f$ H \f$ is the
+  * Householder sequence represented by \p h.
+  */
+template<typename OtherDerived, typename VectorsType, typename CoeffsType, int Side>
+typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::Type operator*(const MatrixBase<OtherDerived>& other, const HouseholderSequence<VectorsType,CoeffsType,Side>& h)
+{
+  typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::Type
+    res(other.template cast<typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::ResultScalar>());
+  h.applyThisOnTheRight(res);
+  return res;
+}
+
+/** \ingroup Householder_Module \householder_module
+  * \brief Convenience function for constructing a Householder sequence.
+  * \returns A HouseholderSequence constructed from the specified arguments.
+  */
+template<typename VectorsType, typename CoeffsType>
+HouseholderSequence<VectorsType,CoeffsType> householderSequence(const VectorsType& v, const CoeffsType& h)
+{
+  return HouseholderSequence<VectorsType,CoeffsType,OnTheLeft>(v, h);
+}
+
+/** \ingroup Householder_Module \householder_module
+  * \brief Convenience function for constructing a Householder sequence.
+  * \returns A HouseholderSequence constructed from the specified arguments.
+  * \details This function differs from householderSequence() in that the template argument \p OnTheSide of
+  * the constructed HouseholderSequence is set to OnTheRight, instead of the default OnTheLeft.
+  */
+template<typename VectorsType, typename CoeffsType>
+HouseholderSequence<VectorsType,CoeffsType,OnTheRight> rightHouseholderSequence(const VectorsType& v, const CoeffsType& h)
+{
+  return HouseholderSequence<VectorsType,CoeffsType,OnTheRight>(v, h);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_HOUSEHOLDER_SEQUENCE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
new file mode 100644
index 00000000..a117fc15
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BASIC_PRECONDITIONERS_H
+#define EIGEN_BASIC_PRECONDITIONERS_H
+
+namespace Eigen {
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A preconditioner based on the digonal entries
+  *
+  * This class allows to approximately solve for A.x = b problems assuming A is a diagonal matrix.
+  * In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for:
+    \code
+    A.diagonal().asDiagonal() . x = b
+    \endcode
+  *
+  * \tparam _Scalar the type of the scalar.
+  *
+  * \implsparsesolverconcept
+  *
+  * This preconditioner is suitable for both selfadjoint and general problems.
+  * The diagonal entries are pre-inverted and stored into a dense vector.
+  *
+  * \note A variant that has yet to be implemented would attempt to preserve the norm of each column.
+  *
+  * \sa class LeastSquareDiagonalPreconditioner, class ConjugateGradient
+  */
+template <typename _Scalar>
+class DiagonalPreconditioner
+{
+    typedef _Scalar Scalar;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+  public:
+    typedef typename Vector::StorageIndex StorageIndex;
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+
+    DiagonalPreconditioner() : m_isInitialized(false) {}
+
+    template<typename MatType>
+    explicit DiagonalPreconditioner(const MatType& mat) : m_invdiag(mat.cols())
+    {
+      compute(mat);
+    }
+
+    EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_invdiag.size(); }
+    EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_invdiag.size(); }
+
+    template<typename MatType>
+    DiagonalPreconditioner& analyzePattern(const MatType& )
+    {
+      return *this;
+    }
+
+    template<typename MatType>
+    DiagonalPreconditioner& factorize(const MatType& mat)
+    {
+      m_invdiag.resize(mat.cols());
+      for(int j=0; j<mat.outerSize(); ++j)
+      {
+        typename MatType::InnerIterator it(mat,j);
+        while(it && it.index()!=j) ++it;
+        if(it && it.index()==j && it.value()!=Scalar(0))
+          m_invdiag(j) = Scalar(1)/it.value();
+        else
+          m_invdiag(j) = Scalar(1);
+      }
+      m_isInitialized = true;
+      return *this;
+    }
+
+    template<typename MatType>
+    DiagonalPreconditioner& compute(const MatType& mat)
+    {
+      return factorize(mat);
+    }
+
+    /** \internal */
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const Rhs& b, Dest& x) const
+    {
+      x = m_invdiag.array() * b.array() ;
+    }
+
+    template<typename Rhs> inline const Solve<DiagonalPreconditioner, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "DiagonalPreconditioner is not initialized.");
+      eigen_assert(m_invdiag.size()==b.rows()
+                && "DiagonalPreconditioner::solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<DiagonalPreconditioner, Rhs>(*this, b.derived());
+    }
+
+    ComputationInfo info() { return Success; }
+
+  protected:
+    Vector m_invdiag;
+    bool m_isInitialized;
+};
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief Jacobi preconditioner for LeastSquaresConjugateGradient
+  *
+  * This class allows to approximately solve for A' A x  = A' b problems assuming A' A is a diagonal matrix.
+  * In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for:
+    \code
+    (A.adjoint() * A).diagonal().asDiagonal() * x = b
+    \endcode
+  *
+  * \tparam _Scalar the type of the scalar.
+  *
+  * \implsparsesolverconcept
+  *
+  * The diagonal entries are pre-inverted and stored into a dense vector.
+  *
+  * \sa class LeastSquaresConjugateGradient, class DiagonalPreconditioner
+  */
+template <typename _Scalar>
+class LeastSquareDiagonalPreconditioner : public DiagonalPreconditioner<_Scalar>
+{
+    typedef _Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef DiagonalPreconditioner<_Scalar> Base;
+    using Base::m_invdiag;
+  public:
+
+    LeastSquareDiagonalPreconditioner() : Base() {}
+
+    template<typename MatType>
+    explicit LeastSquareDiagonalPreconditioner(const MatType& mat) : Base()
+    {
+      compute(mat);
+    }
+
+    template<typename MatType>
+    LeastSquareDiagonalPreconditioner& analyzePattern(const MatType& )
+    {
+      return *this;
+    }
+
+    template<typename MatType>
+    LeastSquareDiagonalPreconditioner& factorize(const MatType& mat)
+    {
+      // Compute the inverse squared-norm of each column of mat
+      m_invdiag.resize(mat.cols());
+      if(MatType::IsRowMajor)
+      {
+        m_invdiag.setZero();
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          for(typename MatType::InnerIterator it(mat,j); it; ++it)
+            m_invdiag(it.index()) += numext::abs2(it.value());
+        }
+        for(Index j=0; j<mat.cols(); ++j)
+          if(numext::real(m_invdiag(j))>RealScalar(0))
+            m_invdiag(j) = RealScalar(1)/numext::real(m_invdiag(j));
+      }
+      else
+      {
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          RealScalar sum = mat.col(j).squaredNorm();
+          if(sum>RealScalar(0))
+            m_invdiag(j) = RealScalar(1)/sum;
+          else
+            m_invdiag(j) = RealScalar(1);
+        }
+      }
+      Base::m_isInitialized = true;
+      return *this;
+    }
+
+    template<typename MatType>
+    LeastSquareDiagonalPreconditioner& compute(const MatType& mat)
+    {
+      return factorize(mat);
+    }
+
+    ComputationInfo info() { return Success; }
+
+  protected:
+};
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A naive preconditioner which approximates any matrix as the identity matrix
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa class DiagonalPreconditioner
+  */
+class IdentityPreconditioner
+{
+  public:
+
+    IdentityPreconditioner() {}
+
+    template<typename MatrixType>
+    explicit IdentityPreconditioner(const MatrixType& ) {}
+
+    template<typename MatrixType>
+    IdentityPreconditioner& analyzePattern(const MatrixType& ) { return *this; }
+
+    template<typename MatrixType>
+    IdentityPreconditioner& factorize(const MatrixType& ) { return *this; }
+
+    template<typename MatrixType>
+    IdentityPreconditioner& compute(const MatrixType& ) { return *this; }
+
+    template<typename Rhs>
+    inline const Rhs& solve(const Rhs& b) const { return b; }
+
+    ComputationInfo info() { return Success; }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_BASIC_PRECONDITIONERS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
new file mode 100644
index 00000000..153acef6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
@@ -0,0 +1,212 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BICGSTAB_H
+#define EIGEN_BICGSTAB_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Low-level bi conjugate gradient stabilized algorithm
+  * \param mat The matrix A
+  * \param rhs The right hand side vector b
+  * \param x On input and initial solution, on output the computed solution.
+  * \param precond A preconditioner being able to efficiently solve for an
+  *                approximation of Ax=b (regardless of b)
+  * \param iters On input the max number of iteration, on output the number of performed iterations.
+  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
+  * \return false in the case of numerical issue, for example a break down of BiCGSTAB. 
+  */
+template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+bool bicgstab(const MatrixType& mat, const Rhs& rhs, Dest& x,
+              const Preconditioner& precond, Index& iters,
+              typename Dest::RealScalar& tol_error)
+{
+  using std::sqrt;
+  using std::abs;
+  typedef typename Dest::RealScalar RealScalar;
+  typedef typename Dest::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,1> VectorType;
+  RealScalar tol = tol_error;
+  Index maxIters = iters;
+
+  Index n = mat.cols();
+  VectorType r  = rhs - mat * x;
+  VectorType r0 = r;
+  
+  RealScalar r0_sqnorm = r0.squaredNorm();
+  RealScalar rhs_sqnorm = rhs.squaredNorm();
+  if(rhs_sqnorm == 0)
+  {
+    x.setZero();
+    return true;
+  }
+  Scalar rho    = 1;
+  Scalar alpha  = 1;
+  Scalar w      = 1;
+  
+  VectorType v = VectorType::Zero(n), p = VectorType::Zero(n);
+  VectorType y(n),  z(n);
+  VectorType kt(n), ks(n);
+
+  VectorType s(n), t(n);
+
+  RealScalar tol2 = tol*tol*rhs_sqnorm;
+  RealScalar eps2 = NumTraits<Scalar>::epsilon()*NumTraits<Scalar>::epsilon();
+  Index i = 0;
+  Index restarts = 0;
+
+  while ( r.squaredNorm() > tol2 && i<maxIters )
+  {
+    Scalar rho_old = rho;
+
+    rho = r0.dot(r);
+    if (abs(rho) < eps2*r0_sqnorm)
+    {
+      // The new residual vector became too orthogonal to the arbitrarily chosen direction r0
+      // Let's restart with a new r0:
+      r  = rhs - mat * x;
+      r0 = r;
+      rho = r0_sqnorm = r.squaredNorm();
+      if(restarts++ == 0)
+        i = 0;
+    }
+    Scalar beta = (rho/rho_old) * (alpha / w);
+    p = r + beta * (p - w * v);
+    
+    y = precond.solve(p);
+    
+    v.noalias() = mat * y;
+
+    alpha = rho / r0.dot(v);
+    s = r - alpha * v;
+
+    z = precond.solve(s);
+    t.noalias() = mat * z;
+
+    RealScalar tmp = t.squaredNorm();
+    if(tmp>RealScalar(0))
+      w = t.dot(s) / tmp;
+    else
+      w = Scalar(0);
+    x += alpha * y + w * z;
+    r = s - w * t;
+    ++i;
+  }
+  tol_error = sqrt(r.squaredNorm()/rhs_sqnorm);
+  iters = i;
+  return true; 
+}
+
+}
+
+template< typename _MatrixType,
+          typename _Preconditioner = DiagonalPreconditioner<typename _MatrixType::Scalar> >
+class BiCGSTAB;
+
+namespace internal {
+
+template< typename _MatrixType, typename _Preconditioner>
+struct traits<BiCGSTAB<_MatrixType,_Preconditioner> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Preconditioner Preconditioner;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A bi conjugate gradient stabilized solver for sparse square problems
+  *
+  * This class allows to solve for A.x = b sparse linear problems using a bi conjugate gradient
+  * stabilized algorithm. The vectors x and b can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, can be a dense or a sparse matrix.
+  * \tparam _Preconditioner the type of the preconditioner. Default is DiagonalPreconditioner
+  *
+  * \implsparsesolverconcept
+  *
+  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
+  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * 
+  * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
+  * 
+  * \b Performance: when using sparse matrices, best performance is achied for a row-major sparse matrix format.
+  * Moreover, in this case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
+  * See \ref TopicMultiThreading for details.
+  * 
+  * This class can be used as the direct solver classes. Here is a typical usage example:
+  * \include BiCGSTAB_simple.cpp
+  * 
+  * By default the iterations start with x=0 as an initial guess of the solution.
+  * One can control the start using the solveWithGuess() method.
+  * 
+  * BiCGSTAB can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
+  *
+  * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+  */
+template< typename _MatrixType, typename _Preconditioner>
+class BiCGSTAB : public IterativeSolverBase<BiCGSTAB<_MatrixType,_Preconditioner> >
+{
+  typedef IterativeSolverBase<BiCGSTAB> Base;
+  using Base::matrix;
+  using Base::m_error;
+  using Base::m_iterations;
+  using Base::m_info;
+  using Base::m_isInitialized;
+public:
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef _Preconditioner Preconditioner;
+
+public:
+
+  /** Default constructor. */
+  BiCGSTAB() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    * 
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    * 
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit BiCGSTAB(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  ~BiCGSTAB() {}
+
+  /** \internal */
+  template<typename Rhs,typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const
+  {    
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+    
+    bool ret = internal::bicgstab(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error);
+
+    m_info = (!ret) ? NumericalIssue
+           : m_error <= Base::m_tolerance ? Success
+           : NoConvergence;
+  }
+
+protected:
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_BICGSTAB_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
new file mode 100644
index 00000000..5d8c6b43
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
@@ -0,0 +1,229 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONJUGATE_GRADIENT_H
+#define EIGEN_CONJUGATE_GRADIENT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Low-level conjugate gradient algorithm
+  * \param mat The matrix A
+  * \param rhs The right hand side vector b
+  * \param x On input and initial solution, on output the computed solution.
+  * \param precond A preconditioner being able to efficiently solve for an
+  *                approximation of Ax=b (regardless of b)
+  * \param iters On input the max number of iteration, on output the number of performed iterations.
+  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
+  */
+template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+EIGEN_DONT_INLINE
+void conjugate_gradient(const MatrixType& mat, const Rhs& rhs, Dest& x,
+                        const Preconditioner& precond, Index& iters,
+                        typename Dest::RealScalar& tol_error)
+{
+  using std::sqrt;
+  using std::abs;
+  typedef typename Dest::RealScalar RealScalar;
+  typedef typename Dest::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,1> VectorType;
+  
+  RealScalar tol = tol_error;
+  Index maxIters = iters;
+  
+  Index n = mat.cols();
+
+  VectorType residual = rhs - mat * x; //initial residual
+
+  RealScalar rhsNorm2 = rhs.squaredNorm();
+  if(rhsNorm2 == 0) 
+  {
+    x.setZero();
+    iters = 0;
+    tol_error = 0;
+    return;
+  }
+  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+  RealScalar threshold = numext::maxi(RealScalar(tol*tol*rhsNorm2),considerAsZero);
+  RealScalar residualNorm2 = residual.squaredNorm();
+  if (residualNorm2 < threshold)
+  {
+    iters = 0;
+    tol_error = sqrt(residualNorm2 / rhsNorm2);
+    return;
+  }
+
+  VectorType p(n);
+  p = precond.solve(residual);      // initial search direction
+
+  VectorType z(n), tmp(n);
+  RealScalar absNew = numext::real(residual.dot(p));  // the square of the absolute value of r scaled by invM
+  Index i = 0;
+  while(i < maxIters)
+  {
+    tmp.noalias() = mat * p;                    // the bottleneck of the algorithm
+
+    Scalar alpha = absNew / p.dot(tmp);         // the amount we travel on dir
+    x += alpha * p;                             // update solution
+    residual -= alpha * tmp;                    // update residual
+    
+    residualNorm2 = residual.squaredNorm();
+    if(residualNorm2 < threshold)
+      break;
+    
+    z = precond.solve(residual);                // approximately solve for "A z = residual"
+
+    RealScalar absOld = absNew;
+    absNew = numext::real(residual.dot(z));     // update the absolute value of r
+    RealScalar beta = absNew / absOld;          // calculate the Gram-Schmidt value used to create the new search direction
+    p = z + beta * p;                           // update search direction
+    i++;
+  }
+  tol_error = sqrt(residualNorm2 / rhsNorm2);
+  iters = i;
+}
+
+}
+
+template< typename _MatrixType, int _UpLo=Lower,
+          typename _Preconditioner = DiagonalPreconditioner<typename _MatrixType::Scalar> >
+class ConjugateGradient;
+
+namespace internal {
+
+template< typename _MatrixType, int _UpLo, typename _Preconditioner>
+struct traits<ConjugateGradient<_MatrixType,_UpLo,_Preconditioner> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Preconditioner Preconditioner;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A conjugate gradient solver for sparse (or dense) self-adjoint problems
+  *
+  * This class allows to solve for A.x = b linear problems using an iterative conjugate gradient algorithm.
+  * The matrix A must be selfadjoint. The matrix A and the vectors x and b can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the matrix A, can be a dense or a sparse matrix.
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower,
+  *               \c Upper, or \c Lower|Upper in which the full matrix entries will be considered.
+  *               Default is \c Lower, best performance is \c Lower|Upper.
+  * \tparam _Preconditioner the type of the preconditioner. Default is DiagonalPreconditioner
+  *
+  * \implsparsesolverconcept
+  *
+  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
+  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * 
+  * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
+  * 
+  * \b Performance: Even though the default value of \c _UpLo is \c Lower, significantly higher performance is
+  * achieved when using a complete matrix and \b Lower|Upper as the \a _UpLo template parameter. Moreover, in this
+  * case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
+  * See \ref TopicMultiThreading for details.
+  * 
+  * This class can be used as the direct solver classes. Here is a typical usage example:
+    \code
+    int n = 10000;
+    VectorXd x(n), b(n);
+    SparseMatrix<double> A(n,n);
+    // fill A and b
+    ConjugateGradient<SparseMatrix<double>, Lower|Upper> cg;
+    cg.compute(A);
+    x = cg.solve(b);
+    std::cout << "#iterations:     " << cg.iterations() << std::endl;
+    std::cout << "estimated error: " << cg.error()      << std::endl;
+    // update b, and solve again
+    x = cg.solve(b);
+    \endcode
+  * 
+  * By default the iterations start with x=0 as an initial guess of the solution.
+  * One can control the start using the solveWithGuess() method.
+  * 
+  * ConjugateGradient can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
+  *
+  * \sa class LeastSquaresConjugateGradient, class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+  */
+template< typename _MatrixType, int _UpLo, typename _Preconditioner>
+class ConjugateGradient : public IterativeSolverBase<ConjugateGradient<_MatrixType,_UpLo,_Preconditioner> >
+{
+  typedef IterativeSolverBase<ConjugateGradient> Base;
+  using Base::matrix;
+  using Base::m_error;
+  using Base::m_iterations;
+  using Base::m_info;
+  using Base::m_isInitialized;
+public:
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef _Preconditioner Preconditioner;
+
+  enum {
+    UpLo = _UpLo
+  };
+
+public:
+
+  /** Default constructor. */
+  ConjugateGradient() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    * 
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    * 
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit ConjugateGradient(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  ~ConjugateGradient() {}
+
+  /** \internal */
+  template<typename Rhs,typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const
+  {
+    typedef typename Base::MatrixWrapper MatrixWrapper;
+    typedef typename Base::ActualMatrixType ActualMatrixType;
+    enum {
+      TransposeInput  =   (!MatrixWrapper::MatrixFree)
+                      &&  (UpLo==(Lower|Upper))
+                      &&  (!MatrixType::IsRowMajor)
+                      &&  (!NumTraits<Scalar>::IsComplex)
+    };
+    typedef typename internal::conditional<TransposeInput,Transpose<const ActualMatrixType>, ActualMatrixType const&>::type RowMajorWrapper;
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(MatrixWrapper::MatrixFree,UpLo==(Lower|Upper)),MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY);
+    typedef typename internal::conditional<UpLo==(Lower|Upper),
+                                           RowMajorWrapper,
+                                           typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type
+                                          >::type SelfAdjointWrapper;
+
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+
+    RowMajorWrapper row_mat(matrix());
+    internal::conjugate_gradient(SelfAdjointWrapper(row_mat), b, x, Base::m_preconditioner, m_iterations, m_error);
+    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
+  }
+
+protected:
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CONJUGATE_GRADIENT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
new file mode 100644
index 00000000..7803fd81
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
@@ -0,0 +1,394 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INCOMPLETE_CHOlESKY_H
+#define EIGEN_INCOMPLETE_CHOlESKY_H
+
+#include <vector>
+#include <list>
+
+namespace Eigen {
+/**
+  * \brief Modified Incomplete Cholesky with dual threshold
+  *
+  * References : C-J. Lin and J. J. Moré, Incomplete Cholesky Factorizations with
+  *              Limited memory, SIAM J. Sci. Comput.  21(1), pp. 24-45, 1999
+  *
+  * \tparam Scalar the scalar type of the input matrices
+  * \tparam _UpLo The triangular part that will be used for the computations. It can be Lower
+    *               or Upper. Default is Lower.
+  * \tparam _OrderingType The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<int>,
+  *                       unless EIGEN_MPL2_ONLY is defined, in which case the default is NaturalOrdering<int>.
+  *
+  * \implsparsesolverconcept
+  *
+  * It performs the following incomplete factorization: \f$ S P A P' S \approx L L' \f$
+  * where L is a lower triangular factor, S is a diagonal scaling matrix, and P is a
+  * fill-in reducing permutation as computed by the ordering method.
+  *
+  * \b Shifting \b strategy: Let \f$ B = S P A P' S \f$  be the scaled matrix on which the factorization is carried out,
+  * and \f$ \beta \f$ be the minimum value of the diagonal. If \f$ \beta > 0 \f$ then, the factorization is directly performed
+  * on the matrix B. Otherwise, the factorization is performed on the shifted matrix \f$ B + (\sigma+|\beta| I \f$ where
+  * \f$ \sigma \f$ is the initial shift value as returned and set by setInitialShift() method. The default value is \f$ \sigma = 10^{-3} \f$.
+  * If the factorization fails, then the shift in doubled until it succeed or a maximum of ten attempts. If it still fails, as returned by
+  * the info() method, then you can either increase the initial shift, or better use another preconditioning technique.
+  *
+  */
+template <typename Scalar, int _UpLo = Lower, typename _OrderingType = AMDOrdering<int> >
+class IncompleteCholesky : public SparseSolverBase<IncompleteCholesky<Scalar,_UpLo,_OrderingType> >
+{
+  protected:
+    typedef SparseSolverBase<IncompleteCholesky<Scalar,_UpLo,_OrderingType> > Base;
+    using Base::m_isInitialized;
+  public:
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef _OrderingType OrderingType;
+    typedef typename OrderingType::PermutationType PermutationType;
+    typedef typename PermutationType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> FactorType;
+    typedef Matrix<Scalar,Dynamic,1> VectorSx;
+    typedef Matrix<RealScalar,Dynamic,1> VectorRx;
+    typedef Matrix<StorageIndex,Dynamic, 1> VectorIx;
+    typedef std::vector<std::list<StorageIndex> > VectorList;
+    enum { UpLo = _UpLo };
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+  public:
+
+    /** Default constructor leaving the object in a partly non-initialized stage.
+      *
+      * You must call compute() or the pair analyzePattern()/factorize() to make it valid.
+      *
+      * \sa IncompleteCholesky(const MatrixType&)
+      */
+    IncompleteCholesky() : m_initialShift(1e-3),m_analysisIsOk(false),m_factorizationIsOk(false) {}
+
+    /** Constructor computing the incomplete factorization for the given matrix \a matrix.
+      */
+    template<typename MatrixType>
+    IncompleteCholesky(const MatrixType& matrix) : m_initialShift(1e-3),m_analysisIsOk(false),m_factorizationIsOk(false)
+    {
+      compute(matrix);
+    }
+
+    /** \returns number of rows of the factored matrix */
+    EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_L.rows(); }
+
+    /** \returns number of columns of the factored matrix */
+    EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_L.cols(); }
+
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * It triggers an assertion if \c *this has not been initialized through the respective constructor,
+      * or a call to compute() or analyzePattern().
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "IncompleteCholesky is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Set the initial shift parameter \f$ \sigma \f$.
+      */
+    void setInitialShift(RealScalar shift) { m_initialShift = shift; }
+
+    /** \brief Computes the fill reducing permutation vector using the sparsity pattern of \a mat
+      */
+    template<typename MatrixType>
+    void analyzePattern(const MatrixType& mat)
+    {
+      OrderingType ord;
+      PermutationType pinv;
+      ord(mat.template selfadjointView<UpLo>(), pinv);
+      if(pinv.size()>0) m_perm = pinv.inverse();
+      else              m_perm.resize(0);
+      m_L.resize(mat.rows(), mat.cols());
+      m_analysisIsOk = true;
+      m_isInitialized = true;
+      m_info = Success;
+    }
+
+    /** \brief Performs the numerical factorization of the input matrix \a mat
+      *
+      * The method analyzePattern() or compute() must have been called beforehand
+      * with a matrix having the same pattern.
+      *
+      * \sa compute(), analyzePattern()
+      */
+    template<typename MatrixType>
+    void factorize(const MatrixType& mat);
+
+    /** Computes or re-computes the incomplete Cholesky factorization of the input matrix \a mat
+      *
+      * It is a shortcut for a sequential call to the analyzePattern() and factorize() methods.
+      *
+      * \sa analyzePattern(), factorize()
+      */
+    template<typename MatrixType>
+    void compute(const MatrixType& mat)
+    {
+      analyzePattern(mat);
+      factorize(mat);
+    }
+
+    // internal
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const Rhs& b, Dest& x) const
+    {
+      eigen_assert(m_factorizationIsOk && "factorize() should be called first");
+      if (m_perm.rows() == b.rows())  x = m_perm * b;
+      else                            x = b;
+      x = m_scale.asDiagonal() * x;
+      x = m_L.template triangularView<Lower>().solve(x);
+      x = m_L.adjoint().template triangularView<Upper>().solve(x);
+      x = m_scale.asDiagonal() * x;
+      if (m_perm.rows() == b.rows())
+        x = m_perm.inverse() * x;
+    }
+
+    /** \returns the sparse lower triangular factor L */
+    const FactorType& matrixL() const { eigen_assert("m_factorizationIsOk"); return m_L; }
+
+    /** \returns a vector representing the scaling factor S */
+    const VectorRx& scalingS() const { eigen_assert("m_factorizationIsOk"); return m_scale; }
+
+    /** \returns the fill-in reducing permutation P (can be empty for a natural ordering) */
+    const PermutationType& permutationP() const { eigen_assert("m_analysisIsOk"); return m_perm; }
+
+  protected:
+    FactorType m_L;              // The lower part stored in CSC
+    VectorRx m_scale;            // The vector for scaling the matrix
+    RealScalar m_initialShift;   // The initial shift parameter
+    bool m_analysisIsOk;
+    bool m_factorizationIsOk;
+    ComputationInfo m_info;
+    PermutationType m_perm;
+
+  private:
+    inline void updateList(Ref<const VectorIx> colPtr, Ref<VectorIx> rowIdx, Ref<VectorSx> vals, const Index& col, const Index& jk, VectorIx& firstElt, VectorList& listCol);
+};
+
+// Based on the following paper:
+//   C-J. Lin and J. J. Moré, Incomplete Cholesky Factorizations with
+//   Limited memory, SIAM J. Sci. Comput.  21(1), pp. 24-45, 1999
+//   http://ftp.mcs.anl.gov/pub/tech_reports/reports/P682.pdf
+template<typename Scalar, int _UpLo, typename OrderingType>
+template<typename _MatrixType>
+void IncompleteCholesky<Scalar,_UpLo, OrderingType>::factorize(const _MatrixType& mat)
+{
+  using std::sqrt;
+  eigen_assert(m_analysisIsOk && "analyzePattern() should be called first");
+
+  // Dropping strategy : Keep only the p largest elements per column, where p is the number of elements in the column of the original matrix. Other strategies will be added
+
+  // Apply the fill-reducing permutation computed in analyzePattern()
+  if (m_perm.rows() == mat.rows() ) // To detect the null permutation
+  {
+    // The temporary is needed to make sure that the diagonal entry is properly sorted
+    FactorType tmp(mat.rows(), mat.cols());
+    tmp = mat.template selfadjointView<_UpLo>().twistedBy(m_perm);
+    m_L.template selfadjointView<Lower>() = tmp.template selfadjointView<Lower>();
+  }
+  else
+  {
+    m_L.template selfadjointView<Lower>() = mat.template selfadjointView<_UpLo>();
+  }
+
+  Index n = m_L.cols();
+  Index nnz = m_L.nonZeros();
+  Map<VectorSx> vals(m_L.valuePtr(), nnz);         //values
+  Map<VectorIx> rowIdx(m_L.innerIndexPtr(), nnz);  //Row indices
+  Map<VectorIx> colPtr( m_L.outerIndexPtr(), n+1); // Pointer to the beginning of each row
+  VectorIx firstElt(n-1); // for each j, points to the next entry in vals that will be used in the factorization
+  VectorList listCol(n);  // listCol(j) is a linked list of columns to update column j
+  VectorSx col_vals(n);   // Store a  nonzero values in each column
+  VectorIx col_irow(n);   // Row indices of nonzero elements in each column
+  VectorIx col_pattern(n);
+  col_pattern.fill(-1);
+  StorageIndex col_nnz;
+
+
+  // Computes the scaling factors
+  m_scale.resize(n);
+  m_scale.setZero();
+  for (Index j = 0; j < n; j++)
+    for (Index k = colPtr[j]; k < colPtr[j+1]; k++)
+    {
+      m_scale(j) += numext::abs2(vals(k));
+      if(rowIdx[k]!=j)
+        m_scale(rowIdx[k]) += numext::abs2(vals(k));
+    }
+
+  m_scale = m_scale.cwiseSqrt().cwiseSqrt();
+
+  for (Index j = 0; j < n; ++j)
+    if(m_scale(j)>(std::numeric_limits<RealScalar>::min)())
+      m_scale(j) = RealScalar(1)/m_scale(j);
+    else
+      m_scale(j) = 1;
+
+  // TODO disable scaling if not needed, i.e., if it is roughly uniform? (this will make solve() faster)
+
+  // Scale and compute the shift for the matrix
+  RealScalar mindiag = NumTraits<RealScalar>::highest();
+  for (Index j = 0; j < n; j++)
+  {
+    for (Index k = colPtr[j]; k < colPtr[j+1]; k++)
+      vals[k] *= (m_scale(j)*m_scale(rowIdx[k]));
+    eigen_internal_assert(rowIdx[colPtr[j]]==j && "IncompleteCholesky: only the lower triangular part must be stored");
+    mindiag = numext::mini(numext::real(vals[colPtr[j]]), mindiag);
+  }
+
+  FactorType L_save = m_L;
+
+  RealScalar shift = 0;
+  if(mindiag <= RealScalar(0.))
+    shift = m_initialShift - mindiag;
+
+  m_info = NumericalIssue;
+
+  // Try to perform the incomplete factorization using the current shift
+  int iter = 0;
+  do
+  {
+    // Apply the shift to the diagonal elements of the matrix
+    for (Index j = 0; j < n; j++)
+      vals[colPtr[j]] += shift;
+
+    // jki version of the Cholesky factorization
+    Index j=0;
+    for (; j < n; ++j)
+    {
+      // Left-looking factorization of the j-th column
+      // First, load the j-th column into col_vals
+      Scalar diag = vals[colPtr[j]];  // It is assumed that only the lower part is stored
+      col_nnz = 0;
+      for (Index i = colPtr[j] + 1; i < colPtr[j+1]; i++)
+      {
+        StorageIndex l = rowIdx[i];
+        col_vals(col_nnz) = vals[i];
+        col_irow(col_nnz) = l;
+        col_pattern(l) = col_nnz;
+        col_nnz++;
+      }
+      {
+        typename std::list<StorageIndex>::iterator k;
+        // Browse all previous columns that will update column j
+        for(k = listCol[j].begin(); k != listCol[j].end(); k++)
+        {
+          Index jk = firstElt(*k); // First element to use in the column
+          eigen_internal_assert(rowIdx[jk]==j);
+          Scalar v_j_jk = numext::conj(vals[jk]);
+
+          jk += 1;
+          for (Index i = jk; i < colPtr[*k+1]; i++)
+          {
+            StorageIndex l = rowIdx[i];
+            if(col_pattern[l]<0)
+            {
+              col_vals(col_nnz) = vals[i] * v_j_jk;
+              col_irow[col_nnz] = l;
+              col_pattern(l) = col_nnz;
+              col_nnz++;
+            }
+            else
+              col_vals(col_pattern[l]) -= vals[i] * v_j_jk;
+          }
+          updateList(colPtr,rowIdx,vals, *k, jk, firstElt, listCol);
+        }
+      }
+
+      // Scale the current column
+      if(numext::real(diag) <= 0)
+      {
+        if(++iter>=10)
+          return;
+
+        // increase shift
+        shift = numext::maxi(m_initialShift,RealScalar(2)*shift);
+        // restore m_L, col_pattern, and listCol
+        vals = Map<const VectorSx>(L_save.valuePtr(), nnz);
+        rowIdx = Map<const VectorIx>(L_save.innerIndexPtr(), nnz);
+        colPtr = Map<const VectorIx>(L_save.outerIndexPtr(), n+1);
+        col_pattern.fill(-1);
+        for(Index i=0; i<n; ++i)
+          listCol[i].clear();
+
+        break;
+      }
+
+      RealScalar rdiag = sqrt(numext::real(diag));
+      vals[colPtr[j]] = rdiag;
+      for (Index k = 0; k<col_nnz; ++k)
+      {
+        Index i = col_irow[k];
+        //Scale
+        col_vals(k) /= rdiag;
+        //Update the remaining diagonals with col_vals
+        vals[colPtr[i]] -= numext::abs2(col_vals(k));
+      }
+      // Select the largest p elements
+      // p is the original number of elements in the column (without the diagonal)
+      Index p = colPtr[j+1] - colPtr[j] - 1 ;
+      Ref<VectorSx> cvals = col_vals.head(col_nnz);
+      Ref<VectorIx> cirow = col_irow.head(col_nnz);
+      internal::QuickSplit(cvals,cirow, p);
+      // Insert the largest p elements in the matrix
+      Index cpt = 0;
+      for (Index i = colPtr[j]+1; i < colPtr[j+1]; i++)
+      {
+        vals[i] = col_vals(cpt);
+        rowIdx[i] = col_irow(cpt);
+        // restore col_pattern:
+        col_pattern(col_irow(cpt)) = -1;
+        cpt++;
+      }
+      // Get the first smallest row index and put it after the diagonal element
+      Index jk = colPtr(j)+1;
+      updateList(colPtr,rowIdx,vals,j,jk,firstElt,listCol);
+    }
+
+    if(j==n)
+    {
+      m_factorizationIsOk = true;
+      m_info = Success;
+    }
+  } while(m_info!=Success);
+}
+
+template<typename Scalar, int _UpLo, typename OrderingType>
+inline void IncompleteCholesky<Scalar,_UpLo, OrderingType>::updateList(Ref<const VectorIx> colPtr, Ref<VectorIx> rowIdx, Ref<VectorSx> vals, const Index& col, const Index& jk, VectorIx& firstElt, VectorList& listCol)
+{
+  if (jk < colPtr(col+1) )
+  {
+    Index p = colPtr(col+1) - jk;
+    Index minpos;
+    rowIdx.segment(jk,p).minCoeff(&minpos);
+    minpos += jk;
+    if (rowIdx(minpos) != rowIdx(jk))
+    {
+      //Swap
+      std::swap(rowIdx(jk),rowIdx(minpos));
+      std::swap(vals(jk),vals(minpos));
+    }
+    firstElt(col) = internal::convert_index<StorageIndex,Index>(jk);
+    listCol[rowIdx(jk)].push_back(internal::convert_index<StorageIndex,Index>(col));
+  }
+}
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
new file mode 100644
index 00000000..cdcf709e
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
@@ -0,0 +1,453 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INCOMPLETE_LUT_H
+#define EIGEN_INCOMPLETE_LUT_H
+
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+  * Compute a quick-sort split of a vector
+  * On output, the vector row is permuted such that its elements satisfy
+  * abs(row(i)) >= abs(row(ncut)) if i<ncut
+  * abs(row(i)) <= abs(row(ncut)) if i>ncut
+  * \param row The vector of values
+  * \param ind The array of index for the elements in @p row
+  * \param ncut  The number of largest elements to keep
+  **/
+template <typename VectorV, typename VectorI>
+Index QuickSplit(VectorV &row, VectorI &ind, Index ncut)
+{
+  typedef typename VectorV::RealScalar RealScalar;
+  using std::swap;
+  using std::abs;
+  Index mid;
+  Index n = row.size(); /* length of the vector */
+  Index first, last ;
+
+  ncut--; /* to fit the zero-based indices */
+  first = 0;
+  last = n-1;
+  if (ncut < first || ncut > last ) return 0;
+
+  do {
+    mid = first;
+    RealScalar abskey = abs(row(mid));
+    for (Index j = first + 1; j <= last; j++) {
+      if ( abs(row(j)) > abskey) {
+        ++mid;
+        swap(row(mid), row(j));
+        swap(ind(mid), ind(j));
+      }
+    }
+    /* Interchange for the pivot element */
+    swap(row(mid), row(first));
+    swap(ind(mid), ind(first));
+
+    if (mid > ncut) last = mid - 1;
+    else if (mid < ncut ) first = mid + 1;
+  } while (mid != ncut );
+
+  return 0; /* mid is equal to ncut */
+}
+
+}// end namespace internal
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \class IncompleteLUT
+  * \brief Incomplete LU factorization with dual-threshold strategy
+  *
+  * \implsparsesolverconcept
+  *
+  * During the numerical factorization, two dropping rules are used :
+  *  1) any element whose magnitude is less than some tolerance is dropped.
+  *    This tolerance is obtained by multiplying the input tolerance @p droptol
+  *    by the average magnitude of all the original elements in the current row.
+  *  2) After the elimination of the row, only the @p fill largest elements in
+  *    the L part and the @p fill largest elements in the U part are kept
+  *    (in addition to the diagonal element ). Note that @p fill is computed from
+  *    the input parameter @p fillfactor which is used the ratio to control the fill_in
+  *    relatively to the initial number of nonzero elements.
+  *
+  * The two extreme cases are when @p droptol=0 (to keep all the @p fill*2 largest elements)
+  * and when @p fill=n/2 with @p droptol being different to zero.
+  *
+  * References : Yousef Saad, ILUT: A dual threshold incomplete LU factorization,
+  *              Numerical Linear Algebra with Applications, 1(4), pp 387-402, 1994.
+  *
+  * NOTE : The following implementation is derived from the ILUT implementation
+  * in the SPARSKIT package, Copyright (C) 2005, the Regents of the University of Minnesota
+  *  released under the terms of the GNU LGPL:
+  *    http://www-users.cs.umn.edu/~saad/software/SPARSKIT/README
+  * However, Yousef Saad gave us permission to relicense his ILUT code to MPL2.
+  * See the Eigen mailing list archive, thread: ILUT, date: July 8, 2012:
+  *   http://listengine.tuxfamily.org/lists.tuxfamily.org/eigen/2012/07/msg00064.html
+  * alternatively, on GMANE:
+  *   http://comments.gmane.org/gmane.comp.lib.eigen/3302
+  */
+template <typename _Scalar, typename _StorageIndex = int>
+class IncompleteLUT : public SparseSolverBase<IncompleteLUT<_Scalar, _StorageIndex> >
+{
+  protected:
+    typedef SparseSolverBase<IncompleteLUT> Base;
+    using Base::m_isInitialized;
+  public:
+    typedef _Scalar Scalar;
+    typedef _StorageIndex StorageIndex;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+    typedef SparseMatrix<Scalar,RowMajor,StorageIndex> FactorType;
+
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+
+  public:
+
+    IncompleteLUT()
+      : m_droptol(NumTraits<Scalar>::dummy_precision()), m_fillfactor(10),
+        m_analysisIsOk(false), m_factorizationIsOk(false)
+    {}
+
+    template<typename MatrixType>
+    explicit IncompleteLUT(const MatrixType& mat, const RealScalar& droptol=NumTraits<Scalar>::dummy_precision(), int fillfactor = 10)
+      : m_droptol(droptol),m_fillfactor(fillfactor),
+        m_analysisIsOk(false),m_factorizationIsOk(false)
+    {
+      eigen_assert(fillfactor != 0);
+      compute(mat);
+    }
+
+    EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_lu.rows(); }
+
+    EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_lu.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "IncompleteLUT is not initialized.");
+      return m_info;
+    }
+
+    template<typename MatrixType>
+    void analyzePattern(const MatrixType& amat);
+
+    template<typename MatrixType>
+    void factorize(const MatrixType& amat);
+
+    /**
+      * Compute an incomplete LU factorization with dual threshold on the matrix mat
+      * No pivoting is done in this version
+      *
+      **/
+    template<typename MatrixType>
+    IncompleteLUT& compute(const MatrixType& amat)
+    {
+      analyzePattern(amat);
+      factorize(amat);
+      return *this;
+    }
+
+    void setDroptol(const RealScalar& droptol);
+    void setFillfactor(int fillfactor);
+
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const Rhs& b, Dest& x) const
+    {
+      x = m_Pinv * b;
+      x = m_lu.template triangularView<UnitLower>().solve(x);
+      x = m_lu.template triangularView<Upper>().solve(x);
+      x = m_P * x;
+    }
+
+protected:
+
+    /** keeps off-diagonal entries; drops diagonal entries */
+    struct keep_diag {
+      inline bool operator() (const Index& row, const Index& col, const Scalar&) const
+      {
+        return row!=col;
+      }
+    };
+
+protected:
+
+    FactorType m_lu;
+    RealScalar m_droptol;
+    int m_fillfactor;
+    bool m_analysisIsOk;
+    bool m_factorizationIsOk;
+    ComputationInfo m_info;
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_P;     // Fill-reducing permutation
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_Pinv;  // Inverse permutation
+};
+
+/**
+ * Set control parameter droptol
+ *  \param droptol   Drop any element whose magnitude is less than this tolerance
+ **/
+template<typename Scalar, typename StorageIndex>
+void IncompleteLUT<Scalar,StorageIndex>::setDroptol(const RealScalar& droptol)
+{
+  this->m_droptol = droptol;
+}
+
+/**
+ * Set control parameter fillfactor
+ * \param fillfactor  This is used to compute the  number @p fill_in of largest elements to keep on each row.
+ **/
+template<typename Scalar, typename StorageIndex>
+void IncompleteLUT<Scalar,StorageIndex>::setFillfactor(int fillfactor)
+{
+  this->m_fillfactor = fillfactor;
+}
+
+template <typename Scalar, typename StorageIndex>
+template<typename _MatrixType>
+void IncompleteLUT<Scalar,StorageIndex>::analyzePattern(const _MatrixType& amat)
+{
+  // Compute the Fill-reducing permutation
+  // Since ILUT does not perform any numerical pivoting,
+  // it is highly preferable to keep the diagonal through symmetric permutations.
+  // To this end, let's symmetrize the pattern and perform AMD on it.
+  SparseMatrix<Scalar,ColMajor, StorageIndex> mat1 = amat;
+  SparseMatrix<Scalar,ColMajor, StorageIndex> mat2 = amat.transpose();
+  // FIXME for a matrix with nearly symmetric pattern, mat2+mat1 is the appropriate choice.
+  //       on the other hand for a really non-symmetric pattern, mat2*mat1 should be preferred...
+  SparseMatrix<Scalar,ColMajor, StorageIndex> AtA = mat2 + mat1;
+  AMDOrdering<StorageIndex> ordering;
+  ordering(AtA,m_P);
+  m_Pinv  = m_P.inverse(); // cache the inverse permutation
+  m_analysisIsOk = true;
+  m_factorizationIsOk = false;
+  m_isInitialized = true;
+}
+
+template <typename Scalar, typename StorageIndex>
+template<typename _MatrixType>
+void IncompleteLUT<Scalar,StorageIndex>::factorize(const _MatrixType& amat)
+{
+  using std::sqrt;
+  using std::swap;
+  using std::abs;
+  using internal::convert_index;
+
+  eigen_assert((amat.rows() == amat.cols()) && "The factorization should be done on a square matrix");
+  Index n = amat.cols();  // Size of the matrix
+  m_lu.resize(n,n);
+  // Declare Working vectors and variables
+  Vector u(n) ;     // real values of the row -- maximum size is n --
+  VectorI ju(n);   // column position of the values in u -- maximum size  is n
+  VectorI jr(n);   // Indicate the position of the nonzero elements in the vector u -- A zero location is indicated by -1
+
+  // Apply the fill-reducing permutation
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  SparseMatrix<Scalar,RowMajor, StorageIndex> mat;
+  mat = amat.twistedBy(m_Pinv);
+
+  // Initialization
+  jr.fill(-1);
+  ju.fill(0);
+  u.fill(0);
+
+  // number of largest elements to keep in each row:
+  Index fill_in = (amat.nonZeros()*m_fillfactor)/n + 1;
+  if (fill_in > n) fill_in = n;
+
+  // number of largest nonzero elements to keep in the L and the U part of the current row:
+  Index nnzL = fill_in/2;
+  Index nnzU = nnzL;
+  m_lu.reserve(n * (nnzL + nnzU + 1));
+
+  // global loop over the rows of the sparse matrix
+  for (Index ii = 0; ii < n; ii++)
+  {
+    // 1 - copy the lower and the upper part of the row i of mat in the working vector u
+
+    Index sizeu = 1; // number of nonzero elements in the upper part of the current row
+    Index sizel = 0; // number of nonzero elements in the lower part of the current row
+    ju(ii)    = convert_index<StorageIndex>(ii);
+    u(ii)     = 0;
+    jr(ii)    = convert_index<StorageIndex>(ii);
+    RealScalar rownorm = 0;
+
+    typename FactorType::InnerIterator j_it(mat, ii); // Iterate through the current row ii
+    for (; j_it; ++j_it)
+    {
+      Index k = j_it.index();
+      if (k < ii)
+      {
+        // copy the lower part
+        ju(sizel) = convert_index<StorageIndex>(k);
+        u(sizel) = j_it.value();
+        jr(k) = convert_index<StorageIndex>(sizel);
+        ++sizel;
+      }
+      else if (k == ii)
+      {
+        u(ii) = j_it.value();
+      }
+      else
+      {
+        // copy the upper part
+        Index jpos = ii + sizeu;
+        ju(jpos) = convert_index<StorageIndex>(k);
+        u(jpos) = j_it.value();
+        jr(k) = convert_index<StorageIndex>(jpos);
+        ++sizeu;
+      }
+      rownorm += numext::abs2(j_it.value());
+    }
+
+    // 2 - detect possible zero row
+    if(rownorm==0)
+    {
+      m_info = NumericalIssue;
+      return;
+    }
+    // Take the 2-norm of the current row as a relative tolerance
+    rownorm = sqrt(rownorm);
+
+    // 3 - eliminate the previous nonzero rows
+    Index jj = 0;
+    Index len = 0;
+    while (jj < sizel)
+    {
+      // In order to eliminate in the correct order,
+      // we must select first the smallest column index among  ju(jj:sizel)
+      Index k;
+      Index minrow = ju.segment(jj,sizel-jj).minCoeff(&k); // k is relative to the segment
+      k += jj;
+      if (minrow != ju(jj))
+      {
+        // swap the two locations
+        Index j = ju(jj);
+        swap(ju(jj), ju(k));
+        jr(minrow) = convert_index<StorageIndex>(jj);
+        jr(j) = convert_index<StorageIndex>(k);
+        swap(u(jj), u(k));
+      }
+      // Reset this location
+      jr(minrow) = -1;
+
+      // Start elimination
+      typename FactorType::InnerIterator ki_it(m_lu, minrow);
+      while (ki_it && ki_it.index() < minrow) ++ki_it;
+      eigen_internal_assert(ki_it && ki_it.col()==minrow);
+      Scalar fact = u(jj) / ki_it.value();
+
+      // drop too small elements
+      if(abs(fact) <= m_droptol)
+      {
+        jj++;
+        continue;
+      }
+
+      // linear combination of the current row ii and the row minrow
+      ++ki_it;
+      for (; ki_it; ++ki_it)
+      {
+        Scalar prod = fact * ki_it.value();
+        Index j     = ki_it.index();
+        Index jpos  = jr(j);
+        if (jpos == -1) // fill-in element
+        {
+          Index newpos;
+          if (j >= ii) // dealing with the upper part
+          {
+            newpos = ii + sizeu;
+            sizeu++;
+            eigen_internal_assert(sizeu<=n);
+          }
+          else // dealing with the lower part
+          {
+            newpos = sizel;
+            sizel++;
+            eigen_internal_assert(sizel<=ii);
+          }
+          ju(newpos) = convert_index<StorageIndex>(j);
+          u(newpos) = -prod;
+          jr(j) = convert_index<StorageIndex>(newpos);
+        }
+        else
+          u(jpos) -= prod;
+      }
+      // store the pivot element
+      u(len)  = fact;
+      ju(len) = convert_index<StorageIndex>(minrow);
+      ++len;
+
+      jj++;
+    } // end of the elimination on the row ii
+
+    // reset the upper part of the pointer jr to zero
+    for(Index k = 0; k <sizeu; k++) jr(ju(ii+k)) = -1;
+
+    // 4 - partially sort and insert the elements in the m_lu matrix
+
+    // sort the L-part of the row
+    sizel = len;
+    len = (std::min)(sizel, nnzL);
+    typename Vector::SegmentReturnType ul(u.segment(0, sizel));
+    typename VectorI::SegmentReturnType jul(ju.segment(0, sizel));
+    internal::QuickSplit(ul, jul, len);
+
+    // store the largest m_fill elements of the L part
+    m_lu.startVec(ii);
+    for(Index k = 0; k < len; k++)
+      m_lu.insertBackByOuterInnerUnordered(ii,ju(k)) = u(k);
+
+    // store the diagonal element
+    // apply a shifting rule to avoid zero pivots (we are doing an incomplete factorization)
+    if (u(ii) == Scalar(0))
+      u(ii) = sqrt(m_droptol) * rownorm;
+    m_lu.insertBackByOuterInnerUnordered(ii, ii) = u(ii);
+
+    // sort the U-part of the row
+    // apply the dropping rule first
+    len = 0;
+    for(Index k = 1; k < sizeu; k++)
+    {
+      if(abs(u(ii+k)) > m_droptol * rownorm )
+      {
+        ++len;
+        u(ii + len)  = u(ii + k);
+        ju(ii + len) = ju(ii + k);
+      }
+    }
+    sizeu = len + 1; // +1 to take into account the diagonal element
+    len = (std::min)(sizeu, nnzU);
+    typename Vector::SegmentReturnType uu(u.segment(ii+1, sizeu-1));
+    typename VectorI::SegmentReturnType juu(ju.segment(ii+1, sizeu-1));
+    internal::QuickSplit(uu, juu, len);
+
+    // store the largest elements of the U part
+    for(Index k = ii + 1; k < ii + len; k++)
+      m_lu.insertBackByOuterInnerUnordered(ii,ju(k)) = u(k);
+  }
+  m_lu.finalize();
+  m_lu.makeCompressed();
+
+  m_factorizationIsOk = true;
+  m_info = Success;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_INCOMPLETE_LUT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
new file mode 100644
index 00000000..28a0c510
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
@@ -0,0 +1,444 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ITERATIVE_SOLVER_BASE_H
+#define EIGEN_ITERATIVE_SOLVER_BASE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatrixType>
+struct is_ref_compatible_impl
+{
+private:
+  template <typename T0>
+  struct any_conversion
+  {
+    template <typename T> any_conversion(const volatile T&);
+    template <typename T> any_conversion(T&);
+  };
+  struct yes {int a[1];};
+  struct no  {int a[2];};
+
+  template<typename T>
+  static yes test(const Ref<const T>&, int);
+  template<typename T>
+  static no  test(any_conversion<T>, ...);
+
+public:
+  static MatrixType ms_from;
+  enum { value = sizeof(test<MatrixType>(ms_from, 0))==sizeof(yes) };
+};
+
+template<typename MatrixType>
+struct is_ref_compatible
+{
+  enum { value = is_ref_compatible_impl<typename remove_all<MatrixType>::type>::value };
+};
+
+template<typename MatrixType, bool MatrixFree = !internal::is_ref_compatible<MatrixType>::value>
+class generic_matrix_wrapper;
+
+// We have an explicit matrix at hand, compatible with Ref<>
+template<typename MatrixType>
+class generic_matrix_wrapper<MatrixType,false>
+{
+public:
+  typedef Ref<const MatrixType> ActualMatrixType;
+  template<int UpLo> struct ConstSelfAdjointViewReturnType {
+    typedef typename ActualMatrixType::template ConstSelfAdjointViewReturnType<UpLo>::Type Type;
+  };
+
+  enum {
+    MatrixFree = false
+  };
+
+  generic_matrix_wrapper()
+    : m_dummy(0,0), m_matrix(m_dummy)
+  {}
+
+  template<typename InputType>
+  generic_matrix_wrapper(const InputType &mat)
+    : m_matrix(mat)
+  {}
+
+  const ActualMatrixType& matrix() const
+  {
+    return m_matrix;
+  }
+
+  template<typename MatrixDerived>
+  void grab(const EigenBase<MatrixDerived> &mat)
+  {
+    m_matrix.~Ref<const MatrixType>();
+    ::new (&m_matrix) Ref<const MatrixType>(mat.derived());
+  }
+
+  void grab(const Ref<const MatrixType> &mat)
+  {
+    if(&(mat.derived()) != &m_matrix)
+    {
+      m_matrix.~Ref<const MatrixType>();
+      ::new (&m_matrix) Ref<const MatrixType>(mat);
+    }
+  }
+
+protected:
+  MatrixType m_dummy; // used to default initialize the Ref<> object
+  ActualMatrixType m_matrix;
+};
+
+// MatrixType is not compatible with Ref<> -> matrix-free wrapper
+template<typename MatrixType>
+class generic_matrix_wrapper<MatrixType,true>
+{
+public:
+  typedef MatrixType ActualMatrixType;
+  template<int UpLo> struct ConstSelfAdjointViewReturnType
+  {
+    typedef ActualMatrixType Type;
+  };
+
+  enum {
+    MatrixFree = true
+  };
+
+  generic_matrix_wrapper()
+    : mp_matrix(0)
+  {}
+
+  generic_matrix_wrapper(const MatrixType &mat)
+    : mp_matrix(&mat)
+  {}
+
+  const ActualMatrixType& matrix() const
+  {
+    return *mp_matrix;
+  }
+
+  void grab(const MatrixType &mat)
+  {
+    mp_matrix = &mat;
+  }
+
+protected:
+  const ActualMatrixType *mp_matrix;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief Base class for linear iterative solvers
+  *
+  * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+  */
+template< typename Derived>
+class IterativeSolverBase : public SparseSolverBase<Derived>
+{
+protected:
+  typedef SparseSolverBase<Derived> Base;
+  using Base::m_isInitialized;
+
+public:
+  typedef typename internal::traits<Derived>::MatrixType MatrixType;
+  typedef typename internal::traits<Derived>::Preconditioner Preconditioner;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  enum {
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+  };
+
+public:
+
+  using Base::derived;
+
+  /** Default constructor. */
+  IterativeSolverBase()
+  {
+    init();
+  }
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    *
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    *
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit IterativeSolverBase(const EigenBase<MatrixDerived>& A)
+    : m_matrixWrapper(A.derived())
+  {
+    init();
+    compute(matrix());
+  }
+
+  ~IterativeSolverBase() {}
+
+  /** Initializes the iterative solver for the sparsity pattern of the matrix \a A for further solving \c Ax=b problems.
+    *
+    * Currently, this function mostly calls analyzePattern on the preconditioner. In the future
+    * we might, for instance, implement column reordering for faster matrix vector products.
+    */
+  template<typename MatrixDerived>
+  Derived& analyzePattern(const EigenBase<MatrixDerived>& A)
+  {
+    grab(A.derived());
+    m_preconditioner.analyzePattern(matrix());
+    m_isInitialized = true;
+    m_analysisIsOk = true;
+    m_info = m_preconditioner.info();
+    return derived();
+  }
+
+  /** Initializes the iterative solver with the numerical values of the matrix \a A for further solving \c Ax=b problems.
+    *
+    * Currently, this function mostly calls factorize on the preconditioner.
+    *
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  Derived& factorize(const EigenBase<MatrixDerived>& A)
+  {
+    eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+    grab(A.derived());
+    m_preconditioner.factorize(matrix());
+    m_factorizationIsOk = true;
+    m_info = m_preconditioner.info();
+    return derived();
+  }
+
+  /** Initializes the iterative solver with the matrix \a A for further solving \c Ax=b problems.
+    *
+    * Currently, this function mostly initializes/computes the preconditioner. In the future
+    * we might, for instance, implement column reordering for faster matrix vector products.
+    *
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  Derived& compute(const EigenBase<MatrixDerived>& A)
+  {
+    grab(A.derived());
+    m_preconditioner.compute(matrix());
+    m_isInitialized = true;
+    m_analysisIsOk = true;
+    m_factorizationIsOk = true;
+    m_info = m_preconditioner.info();
+    return derived();
+  }
+
+  /** \internal */
+  EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return matrix().rows(); }
+
+  /** \internal */
+  EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return matrix().cols(); }
+
+  /** \returns the tolerance threshold used by the stopping criteria.
+    * \sa setTolerance()
+    */
+  RealScalar tolerance() const { return m_tolerance; }
+
+  /** Sets the tolerance threshold used by the stopping criteria.
+    *
+    * This value is used as an upper bound to the relative residual error: |Ax-b|/|b|.
+    * The default value is the machine precision given by NumTraits<Scalar>::epsilon()
+    */
+  Derived& setTolerance(const RealScalar& tolerance)
+  {
+    m_tolerance = tolerance;
+    return derived();
+  }
+
+  /** \returns a read-write reference to the preconditioner for custom configuration. */
+  Preconditioner& preconditioner() { return m_preconditioner; }
+
+  /** \returns a read-only reference to the preconditioner. */
+  const Preconditioner& preconditioner() const { return m_preconditioner; }
+
+  /** \returns the max number of iterations.
+    * It is either the value set by setMaxIterations or, by default,
+    * twice the number of columns of the matrix.
+    */
+  Index maxIterations() const
+  {
+    return (m_maxIterations<0) ? 2*matrix().cols() : m_maxIterations;
+  }
+
+  /** Sets the max number of iterations.
+    * Default is twice the number of columns of the matrix.
+    */
+  Derived& setMaxIterations(Index maxIters)
+  {
+    m_maxIterations = maxIters;
+    return derived();
+  }
+
+  /** \returns the number of iterations performed during the last solve */
+  Index iterations() const
+  {
+    eigen_assert(m_isInitialized && "ConjugateGradient is not initialized.");
+    return m_iterations;
+  }
+
+  /** \returns the tolerance error reached during the last solve.
+    * It is a close approximation of the true relative residual error |Ax-b|/|b|.
+    */
+  RealScalar error() const
+  {
+    eigen_assert(m_isInitialized && "ConjugateGradient is not initialized.");
+    return m_error;
+  }
+
+  /** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A
+    * and \a x0 as an initial solution.
+    *
+    * \sa solve(), compute()
+    */
+  template<typename Rhs,typename Guess>
+  inline const SolveWithGuess<Derived, Rhs, Guess>
+  solveWithGuess(const MatrixBase<Rhs>& b, const Guess& x0) const
+  {
+    eigen_assert(m_isInitialized && "Solver is not initialized.");
+    eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
+    return SolveWithGuess<Derived, Rhs, Guess>(derived(), b.derived(), x0);
+  }
+
+  /** \returns Success if the iterations converged, and NoConvergence otherwise. */
+  ComputationInfo info() const
+  {
+    eigen_assert(m_isInitialized && "IterativeSolverBase is not initialized.");
+    return m_info;
+  }
+
+  /** \internal */
+  template<typename Rhs, typename DestDerived>
+  void _solve_with_guess_impl(const Rhs& b, SparseMatrixBase<DestDerived> &aDest) const
+  {
+    eigen_assert(rows()==b.rows());
+
+    Index rhsCols = b.cols();
+    Index size = b.rows();
+    DestDerived& dest(aDest.derived());
+    typedef typename DestDerived::Scalar DestScalar;
+    Eigen::Matrix<DestScalar,Dynamic,1> tb(size);
+    Eigen::Matrix<DestScalar,Dynamic,1> tx(cols());
+    // We do not directly fill dest because sparse expressions have to be free of aliasing issue.
+    // For non square least-square problems, b and dest might not have the same size whereas they might alias each-other.
+    typename DestDerived::PlainObject tmp(cols(),rhsCols);
+    ComputationInfo global_info = Success;
+    for(Index k=0; k<rhsCols; ++k)
+    {
+      tb = b.col(k);
+      tx = dest.col(k);
+      derived()._solve_vector_with_guess_impl(tb,tx);
+      tmp.col(k) = tx.sparseView(0);
+
+      // The call to _solve_vector_with_guess_impl updates m_info, so if it failed for a previous column
+      // we need to restore it to the worst value.
+      if(m_info==NumericalIssue)
+        global_info = NumericalIssue;
+      else if(m_info==NoConvergence)
+        global_info = NoConvergence;
+    }
+    m_info = global_info;
+    dest.swap(tmp);
+  }
+
+  template<typename Rhs, typename DestDerived>
+  typename internal::enable_if<Rhs::ColsAtCompileTime!=1 && DestDerived::ColsAtCompileTime!=1>::type
+  _solve_with_guess_impl(const Rhs& b, MatrixBase<DestDerived> &aDest) const
+  {
+    eigen_assert(rows()==b.rows());
+
+    Index rhsCols = b.cols();
+    DestDerived& dest(aDest.derived());
+    ComputationInfo global_info = Success;
+    for(Index k=0; k<rhsCols; ++k)
+    {
+      typename DestDerived::ColXpr xk(dest,k);
+      typename Rhs::ConstColXpr bk(b,k);
+      derived()._solve_vector_with_guess_impl(bk,xk);
+
+      // The call to _solve_vector_with_guess updates m_info, so if it failed for a previous column
+      // we need to restore it to the worst value.
+      if(m_info==NumericalIssue)
+        global_info = NumericalIssue;
+      else if(m_info==NoConvergence)
+        global_info = NoConvergence;
+    }
+    m_info = global_info;
+  }
+
+  template<typename Rhs, typename DestDerived>
+  typename internal::enable_if<Rhs::ColsAtCompileTime==1 || DestDerived::ColsAtCompileTime==1>::type
+  _solve_with_guess_impl(const Rhs& b, MatrixBase<DestDerived> &dest) const
+  {
+    derived()._solve_vector_with_guess_impl(b,dest.derived());
+  }
+
+  /** \internal default initial guess = 0 */
+  template<typename Rhs,typename Dest>
+  void _solve_impl(const Rhs& b, Dest& x) const
+  {
+    x.setZero();
+    derived()._solve_with_guess_impl(b,x);
+  }
+
+protected:
+  void init()
+  {
+    m_isInitialized = false;
+    m_analysisIsOk = false;
+    m_factorizationIsOk = false;
+    m_maxIterations = -1;
+    m_tolerance = NumTraits<Scalar>::epsilon();
+  }
+
+  typedef internal::generic_matrix_wrapper<MatrixType> MatrixWrapper;
+  typedef typename MatrixWrapper::ActualMatrixType ActualMatrixType;
+
+  const ActualMatrixType& matrix() const
+  {
+    return m_matrixWrapper.matrix();
+  }
+
+  template<typename InputType>
+  void grab(const InputType &A)
+  {
+    m_matrixWrapper.grab(A);
+  }
+
+  MatrixWrapper m_matrixWrapper;
+  Preconditioner m_preconditioner;
+
+  Index m_maxIterations;
+  RealScalar m_tolerance;
+
+  mutable RealScalar m_error;
+  mutable Index m_iterations;
+  mutable ComputationInfo m_info;
+  mutable bool m_analysisIsOk, m_factorizationIsOk;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_ITERATIVE_SOLVER_BASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
new file mode 100644
index 00000000..203fd0ec
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
@@ -0,0 +1,198 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
+#define EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Low-level conjugate gradient algorithm for least-square problems
+  * \param mat The matrix A
+  * \param rhs The right hand side vector b
+  * \param x On input and initial solution, on output the computed solution.
+  * \param precond A preconditioner being able to efficiently solve for an
+  *                approximation of A'Ax=b (regardless of b)
+  * \param iters On input the max number of iteration, on output the number of performed iterations.
+  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
+  */
+template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+EIGEN_DONT_INLINE
+void least_square_conjugate_gradient(const MatrixType& mat, const Rhs& rhs, Dest& x,
+                                     const Preconditioner& precond, Index& iters,
+                                     typename Dest::RealScalar& tol_error)
+{
+  using std::sqrt;
+  using std::abs;
+  typedef typename Dest::RealScalar RealScalar;
+  typedef typename Dest::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,1> VectorType;
+  
+  RealScalar tol = tol_error;
+  Index maxIters = iters;
+  
+  Index m = mat.rows(), n = mat.cols();
+
+  VectorType residual        = rhs - mat * x;
+  VectorType normal_residual = mat.adjoint() * residual;
+
+  RealScalar rhsNorm2 = (mat.adjoint()*rhs).squaredNorm();
+  if(rhsNorm2 == 0) 
+  {
+    x.setZero();
+    iters = 0;
+    tol_error = 0;
+    return;
+  }
+  RealScalar threshold = tol*tol*rhsNorm2;
+  RealScalar residualNorm2 = normal_residual.squaredNorm();
+  if (residualNorm2 < threshold)
+  {
+    iters = 0;
+    tol_error = sqrt(residualNorm2 / rhsNorm2);
+    return;
+  }
+  
+  VectorType p(n);
+  p = precond.solve(normal_residual);                         // initial search direction
+
+  VectorType z(n), tmp(m);
+  RealScalar absNew = numext::real(normal_residual.dot(p));  // the square of the absolute value of r scaled by invM
+  Index i = 0;
+  while(i < maxIters)
+  {
+    tmp.noalias() = mat * p;
+
+    Scalar alpha = absNew / tmp.squaredNorm();      // the amount we travel on dir
+    x += alpha * p;                                 // update solution
+    residual -= alpha * tmp;                        // update residual
+    normal_residual = mat.adjoint() * residual;     // update residual of the normal equation
+    
+    residualNorm2 = normal_residual.squaredNorm();
+    if(residualNorm2 < threshold)
+      break;
+    
+    z = precond.solve(normal_residual);             // approximately solve for "A'A z = normal_residual"
+
+    RealScalar absOld = absNew;
+    absNew = numext::real(normal_residual.dot(z));  // update the absolute value of r
+    RealScalar beta = absNew / absOld;              // calculate the Gram-Schmidt value used to create the new search direction
+    p = z + beta * p;                               // update search direction
+    i++;
+  }
+  tol_error = sqrt(residualNorm2 / rhsNorm2);
+  iters = i;
+}
+
+}
+
+template< typename _MatrixType,
+          typename _Preconditioner = LeastSquareDiagonalPreconditioner<typename _MatrixType::Scalar> >
+class LeastSquaresConjugateGradient;
+
+namespace internal {
+
+template< typename _MatrixType, typename _Preconditioner>
+struct traits<LeastSquaresConjugateGradient<_MatrixType,_Preconditioner> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Preconditioner Preconditioner;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A conjugate gradient solver for sparse (or dense) least-square problems
+  *
+  * This class allows to solve for A x = b linear problems using an iterative conjugate gradient algorithm.
+  * The matrix A can be non symmetric and rectangular, but the matrix A' A should be positive-definite to guaranty stability.
+  * Otherwise, the SparseLU or SparseQR classes might be preferable.
+  * The matrix A and the vectors x and b can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the matrix A, can be a dense or a sparse matrix.
+  * \tparam _Preconditioner the type of the preconditioner. Default is LeastSquareDiagonalPreconditioner
+  *
+  * \implsparsesolverconcept
+  * 
+  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
+  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * 
+  * This class can be used as the direct solver classes. Here is a typical usage example:
+    \code
+    int m=1000000, n = 10000;
+    VectorXd x(n), b(m);
+    SparseMatrix<double> A(m,n);
+    // fill A and b
+    LeastSquaresConjugateGradient<SparseMatrix<double> > lscg;
+    lscg.compute(A);
+    x = lscg.solve(b);
+    std::cout << "#iterations:     " << lscg.iterations() << std::endl;
+    std::cout << "estimated error: " << lscg.error()      << std::endl;
+    // update b, and solve again
+    x = lscg.solve(b);
+    \endcode
+  * 
+  * By default the iterations start with x=0 as an initial guess of the solution.
+  * One can control the start using the solveWithGuess() method.
+  * 
+  * \sa class ConjugateGradient, SparseLU, SparseQR
+  */
+template< typename _MatrixType, typename _Preconditioner>
+class LeastSquaresConjugateGradient : public IterativeSolverBase<LeastSquaresConjugateGradient<_MatrixType,_Preconditioner> >
+{
+  typedef IterativeSolverBase<LeastSquaresConjugateGradient> Base;
+  using Base::matrix;
+  using Base::m_error;
+  using Base::m_iterations;
+  using Base::m_info;
+  using Base::m_isInitialized;
+public:
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef _Preconditioner Preconditioner;
+
+public:
+
+  /** Default constructor. */
+  LeastSquaresConjugateGradient() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    * 
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    * 
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit LeastSquaresConjugateGradient(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  ~LeastSquaresConjugateGradient() {}
+
+  /** \internal */
+  template<typename Rhs,typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const
+  {
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+
+    internal::least_square_conjugate_gradient(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error);
+    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
+  }
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
new file mode 100644
index 00000000..7b896575
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
@@ -0,0 +1,117 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVEWITHGUESS_H
+#define EIGEN_SOLVEWITHGUESS_H
+
+namespace Eigen {
+
+template<typename Decomposition, typename RhsType, typename GuessType> class SolveWithGuess;
+
+/** \class SolveWithGuess
+  * \ingroup IterativeLinearSolvers_Module
+  *
+  * \brief Pseudo expression representing a solving operation
+  *
+  * \tparam Decomposition the type of the matrix or decomposion object
+  * \tparam Rhstype the type of the right-hand side
+  *
+  * This class represents an expression of A.solve(B)
+  * and most of the time this is the only way it is used.
+  *
+  */
+namespace internal {
+
+
+template<typename Decomposition, typename RhsType, typename GuessType>
+struct traits<SolveWithGuess<Decomposition, RhsType, GuessType> >
+  : traits<Solve<Decomposition,RhsType> >
+{};
+
+}
+
+
+template<typename Decomposition, typename RhsType, typename GuessType>
+class SolveWithGuess : public internal::generic_xpr_base<SolveWithGuess<Decomposition,RhsType,GuessType>, MatrixXpr, typename internal::traits<RhsType>::StorageKind>::type
+{
+public:
+  typedef typename internal::traits<SolveWithGuess>::Scalar Scalar;
+  typedef typename internal::traits<SolveWithGuess>::PlainObject PlainObject;
+  typedef typename internal::generic_xpr_base<SolveWithGuess<Decomposition,RhsType,GuessType>, MatrixXpr, typename internal::traits<RhsType>::StorageKind>::type Base;
+  typedef typename internal::ref_selector<SolveWithGuess>::type Nested;
+
+  SolveWithGuess(const Decomposition &dec, const RhsType &rhs, const GuessType &guess)
+    : m_dec(dec), m_rhs(rhs), m_guess(guess)
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  Index rows() const EIGEN_NOEXCEPT { return m_dec.cols(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+  EIGEN_DEVICE_FUNC const Decomposition& dec()   const { return m_dec; }
+  EIGEN_DEVICE_FUNC const RhsType&       rhs()   const { return m_rhs; }
+  EIGEN_DEVICE_FUNC const GuessType&     guess() const { return m_guess; }
+
+protected:
+  const Decomposition &m_dec;
+  const RhsType       &m_rhs;
+  const GuessType     &m_guess;
+
+private:
+  Scalar coeff(Index row, Index col) const;
+  Scalar coeff(Index i) const;
+};
+
+namespace internal {
+
+// Evaluator of SolveWithGuess -> eval into a temporary
+template<typename Decomposition, typename RhsType, typename GuessType>
+struct evaluator<SolveWithGuess<Decomposition,RhsType, GuessType> >
+  : public evaluator<typename SolveWithGuess<Decomposition,RhsType,GuessType>::PlainObject>
+{
+  typedef SolveWithGuess<Decomposition,RhsType,GuessType> SolveType;
+  typedef typename SolveType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  evaluator(const SolveType& solve)
+    : m_result(solve.rows(), solve.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    m_result = solve.guess();
+    solve.dec()._solve_with_guess_impl(solve.rhs(), m_result);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+// Specialization for "dst = dec.solveWithGuess(rhs)"
+// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere
+template<typename DstXprType, typename DecType, typename RhsType, typename GuessType, typename Scalar>
+struct Assignment<DstXprType, SolveWithGuess<DecType,RhsType,GuessType>, internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef SolveWithGuess<DecType,RhsType,GuessType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst = src.guess();
+    src.dec()._solve_with_guess_impl(src.rhs(), dst/*, src.guess()*/);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVEWITHGUESS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/Jacobi/Jacobi.h b/C++/yolo_bytetrack/include/Eigen/src/Jacobi/Jacobi.h
new file mode 100644
index 00000000..76668a57
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/Jacobi/Jacobi.h
@@ -0,0 +1,483 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_JACOBI_H
+#define EIGEN_JACOBI_H
+
+namespace Eigen {
+
+/** \ingroup Jacobi_Module
+  * \jacobi_module
+  * \class JacobiRotation
+  * \brief Rotation given by a cosine-sine pair.
+  *
+  * This class represents a Jacobi or Givens rotation.
+  * This is a 2D rotation in the plane \c J of angle \f$ \theta \f$ defined by
+  * its cosine \c c and sine \c s as follow:
+  * \f$ J = \left ( \begin{array}{cc} c & \overline s \\ -s  & \overline c \end{array} \right ) \f$
+  *
+  * You can apply the respective counter-clockwise rotation to a column vector \c v by
+  * applying its adjoint on the left: \f$ v = J^* v \f$ that translates to the following Eigen code:
+  * \code
+  * v.applyOnTheLeft(J.adjoint());
+  * \endcode
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar> class JacobiRotation
+{
+  public:
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    /** Default constructor without any initialization. */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation() {}
+
+    /** Construct a planar rotation from a cosine-sine pair (\a c, \c s). */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation(const Scalar& c, const Scalar& s) : m_c(c), m_s(s) {}
+
+    EIGEN_DEVICE_FUNC Scalar& c() { return m_c; }
+    EIGEN_DEVICE_FUNC Scalar c() const { return m_c; }
+    EIGEN_DEVICE_FUNC Scalar& s() { return m_s; }
+    EIGEN_DEVICE_FUNC Scalar s() const { return m_s; }
+
+    /** Concatenates two planar rotation */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation operator*(const JacobiRotation& other)
+    {
+      using numext::conj;
+      return JacobiRotation(m_c * other.m_c - conj(m_s) * other.m_s,
+                            conj(m_c * conj(other.m_s) + conj(m_s) * conj(other.m_c)));
+    }
+
+    /** Returns the transposed transformation */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation transpose() const { using numext::conj; return JacobiRotation(m_c, -conj(m_s)); }
+
+    /** Returns the adjoint transformation */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation adjoint() const { using numext::conj; return JacobiRotation(conj(m_c), -m_s); }
+
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC
+    bool makeJacobi(const MatrixBase<Derived>&, Index p, Index q);
+    EIGEN_DEVICE_FUNC
+    bool makeJacobi(const RealScalar& x, const Scalar& y, const RealScalar& z);
+
+    EIGEN_DEVICE_FUNC
+    void makeGivens(const Scalar& p, const Scalar& q, Scalar* r=0);
+
+  protected:
+    EIGEN_DEVICE_FUNC
+    void makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::true_type);
+    EIGEN_DEVICE_FUNC
+    void makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type);
+
+    Scalar m_c, m_s;
+};
+
+/** Makes \c *this as a Jacobi rotation \a J such that applying \a J on both the right and left sides of the selfadjoint 2x2 matrix
+  * \f$ B = \left ( \begin{array}{cc} x & y \\ \overline y & z \end{array} \right )\f$ yields a diagonal matrix \f$ A = J^* B J \f$
+  *
+  * \sa MatrixBase::makeJacobi(const MatrixBase<Derived>&, Index, Index), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+bool JacobiRotation<Scalar>::makeJacobi(const RealScalar& x, const Scalar& y, const RealScalar& z)
+{
+  using std::sqrt;
+  using std::abs;
+
+  RealScalar deno = RealScalar(2)*abs(y);
+  if(deno < (std::numeric_limits<RealScalar>::min)())
+  {
+    m_c = Scalar(1);
+    m_s = Scalar(0);
+    return false;
+  }
+  else
+  {
+    RealScalar tau = (x-z)/deno;
+    RealScalar w = sqrt(numext::abs2(tau) + RealScalar(1));
+    RealScalar t;
+    if(tau>RealScalar(0))
+    {
+      t = RealScalar(1) / (tau + w);
+    }
+    else
+    {
+      t = RealScalar(1) / (tau - w);
+    }
+    RealScalar sign_t = t > RealScalar(0) ? RealScalar(1) : RealScalar(-1);
+    RealScalar n = RealScalar(1) / sqrt(numext::abs2(t)+RealScalar(1));
+    m_s = - sign_t * (numext::conj(y) / abs(y)) * abs(t) * n;
+    m_c = n;
+    return true;
+  }
+}
+
+/** Makes \c *this as a Jacobi rotation \c J such that applying \a J on both the right and left sides of the 2x2 selfadjoint matrix
+  * \f$ B = \left ( \begin{array}{cc} \text{this}_{pp} & \text{this}_{pq} \\ (\text{this}_{pq})^* & \text{this}_{qq} \end{array} \right )\f$ yields
+  * a diagonal matrix \f$ A = J^* B J \f$
+  *
+  * Example: \include Jacobi_makeJacobi.cpp
+  * Output: \verbinclude Jacobi_makeJacobi.out
+  *
+  * \sa JacobiRotation::makeJacobi(RealScalar, Scalar, RealScalar), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+inline bool JacobiRotation<Scalar>::makeJacobi(const MatrixBase<Derived>& m, Index p, Index q)
+{
+  return makeJacobi(numext::real(m.coeff(p,p)), m.coeff(p,q), numext::real(m.coeff(q,q)));
+}
+
+/** Makes \c *this as a Givens rotation \c G such that applying \f$ G^* \f$ to the left of the vector
+  * \f$ V = \left ( \begin{array}{c} p \\ q \end{array} \right )\f$ yields:
+  * \f$ G^* V = \left ( \begin{array}{c} r \\ 0 \end{array} \right )\f$.
+  *
+  * The value of \a r is returned if \a r is not null (the default is null).
+  * Also note that G is built such that the cosine is always real.
+  *
+  * Example: \include Jacobi_makeGivens.cpp
+  * Output: \verbinclude Jacobi_makeGivens.out
+  *
+  * This function implements the continuous Givens rotation generation algorithm
+  * found in Anderson (2000), Discontinuous Plane Rotations and the Symmetric Eigenvalue Problem.
+  * LAPACK Working Note 150, University of Tennessee, UT-CS-00-454, December 4, 2000.
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r)
+{
+  makeGivens(p, q, r, typename internal::conditional<NumTraits<Scalar>::IsComplex, internal::true_type, internal::false_type>::type());
+}
+
+
+// specialization for complexes
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::true_type)
+{
+  using std::sqrt;
+  using std::abs;
+  using numext::conj;
+
+  if(q==Scalar(0))
+  {
+    m_c = numext::real(p)<0 ? Scalar(-1) : Scalar(1);
+    m_s = 0;
+    if(r) *r = m_c * p;
+  }
+  else if(p==Scalar(0))
+  {
+    m_c = 0;
+    m_s = -q/abs(q);
+    if(r) *r = abs(q);
+  }
+  else
+  {
+    RealScalar p1 = numext::norm1(p);
+    RealScalar q1 = numext::norm1(q);
+    if(p1>=q1)
+    {
+      Scalar ps = p / p1;
+      RealScalar p2 = numext::abs2(ps);
+      Scalar qs = q / p1;
+      RealScalar q2 = numext::abs2(qs);
+
+      RealScalar u = sqrt(RealScalar(1) + q2/p2);
+      if(numext::real(p)<RealScalar(0))
+        u = -u;
+
+      m_c = Scalar(1)/u;
+      m_s = -qs*conj(ps)*(m_c/p2);
+      if(r) *r = p * u;
+    }
+    else
+    {
+      Scalar ps = p / q1;
+      RealScalar p2 = numext::abs2(ps);
+      Scalar qs = q / q1;
+      RealScalar q2 = numext::abs2(qs);
+
+      RealScalar u = q1 * sqrt(p2 + q2);
+      if(numext::real(p)<RealScalar(0))
+        u = -u;
+
+      p1 = abs(p);
+      ps = p/p1;
+      m_c = p1/u;
+      m_s = -conj(ps) * (q/u);
+      if(r) *r = ps * u;
+    }
+  }
+}
+
+// specialization for reals
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type)
+{
+  using std::sqrt;
+  using std::abs;
+  if(q==Scalar(0))
+  {
+    m_c = p<Scalar(0) ? Scalar(-1) : Scalar(1);
+    m_s = Scalar(0);
+    if(r) *r = abs(p);
+  }
+  else if(p==Scalar(0))
+  {
+    m_c = Scalar(0);
+    m_s = q<Scalar(0) ? Scalar(1) : Scalar(-1);
+    if(r) *r = abs(q);
+  }
+  else if(abs(p) > abs(q))
+  {
+    Scalar t = q/p;
+    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
+    if(p<Scalar(0))
+      u = -u;
+    m_c = Scalar(1)/u;
+    m_s = -t * m_c;
+    if(r) *r = p * u;
+  }
+  else
+  {
+    Scalar t = p/q;
+    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
+    if(q<Scalar(0))
+      u = -u;
+    m_s = -Scalar(1)/u;
+    m_c = -t * m_s;
+    if(r) *r = q * u;
+  }
+
+}
+
+/****************************************************************************************
+*   Implementation of MatrixBase methods
+****************************************************************************************/
+
+namespace internal {
+/** \jacobi_module
+  * Applies the clock wise 2D rotation \a j to the set of 2D vectors of coordinates \a x and \a y:
+  * \f$ \left ( \begin{array}{cc} x \\ y \end{array} \right )  =  J \left ( \begin{array}{cc} x \\ y \end{array} \right ) \f$
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename VectorX, typename VectorY, typename OtherScalar>
+EIGEN_DEVICE_FUNC
+void apply_rotation_in_the_plane(DenseBase<VectorX>& xpr_x, DenseBase<VectorY>& xpr_y, const JacobiRotation<OtherScalar>& j);
+}
+
+/** \jacobi_module
+  * Applies the rotation in the plane \a j to the rows \a p and \a q of \c *this, i.e., it computes B = J * B,
+  * with \f$ B = \left ( \begin{array}{cc} \text{*this.row}(p) \\ \text{*this.row}(q) \end{array} \right ) \f$.
+  *
+  * \sa class JacobiRotation, MatrixBase::applyOnTheRight(), internal::apply_rotation_in_the_plane()
+  */
+template<typename Derived>
+template<typename OtherScalar>
+EIGEN_DEVICE_FUNC
+inline void MatrixBase<Derived>::applyOnTheLeft(Index p, Index q, const JacobiRotation<OtherScalar>& j)
+{
+  RowXpr x(this->row(p));
+  RowXpr y(this->row(q));
+  internal::apply_rotation_in_the_plane(x, y, j);
+}
+
+/** \ingroup Jacobi_Module
+  * Applies the rotation in the plane \a j to the columns \a p and \a q of \c *this, i.e., it computes B = B * J
+  * with \f$ B = \left ( \begin{array}{cc} \text{*this.col}(p) & \text{*this.col}(q) \end{array} \right ) \f$.
+  *
+  * \sa class JacobiRotation, MatrixBase::applyOnTheLeft(), internal::apply_rotation_in_the_plane()
+  */
+template<typename Derived>
+template<typename OtherScalar>
+EIGEN_DEVICE_FUNC
+inline void MatrixBase<Derived>::applyOnTheRight(Index p, Index q, const JacobiRotation<OtherScalar>& j)
+{
+  ColXpr x(this->col(p));
+  ColXpr y(this->col(q));
+  internal::apply_rotation_in_the_plane(x, y, j.transpose());
+}
+
+namespace internal {
+
+template<typename Scalar, typename OtherScalar,
+         int SizeAtCompileTime, int MinAlignment, bool Vectorizable>
+struct apply_rotation_in_the_plane_selector
+{
+  static EIGEN_DEVICE_FUNC
+  inline void run(Scalar *x, Index incrx, Scalar *y, Index incry, Index size, OtherScalar c, OtherScalar s)
+  {
+    for(Index i=0; i<size; ++i)
+    {
+      Scalar xi = *x;
+      Scalar yi = *y;
+      *x =  c * xi + numext::conj(s) * yi;
+      *y = -s * xi + numext::conj(c) * yi;
+      x += incrx;
+      y += incry;
+    }
+  }
+};
+
+template<typename Scalar, typename OtherScalar,
+         int SizeAtCompileTime, int MinAlignment>
+struct apply_rotation_in_the_plane_selector<Scalar,OtherScalar,SizeAtCompileTime,MinAlignment,true /* vectorizable */>
+{
+  static inline void run(Scalar *x, Index incrx, Scalar *y, Index incry, Index size, OtherScalar c, OtherScalar s)
+  {
+    enum {
+      PacketSize = packet_traits<Scalar>::size,
+      OtherPacketSize = packet_traits<OtherScalar>::size
+    };
+    typedef typename packet_traits<Scalar>::type Packet;
+    typedef typename packet_traits<OtherScalar>::type OtherPacket;
+
+    /*** dynamic-size vectorized paths ***/
+    if(SizeAtCompileTime == Dynamic && ((incrx==1 && incry==1) || PacketSize == 1))
+    {
+      // both vectors are sequentially stored in memory => vectorization
+      enum { Peeling = 2 };
+
+      Index alignedStart = internal::first_default_aligned(y, size);
+      Index alignedEnd = alignedStart + ((size-alignedStart)/PacketSize)*PacketSize;
+
+      const OtherPacket pc = pset1<OtherPacket>(c);
+      const OtherPacket ps = pset1<OtherPacket>(s);
+      conj_helper<OtherPacket,Packet,NumTraits<OtherScalar>::IsComplex,false> pcj;
+      conj_helper<OtherPacket,Packet,false,false> pm;
+
+      for(Index i=0; i<alignedStart; ++i)
+      {
+        Scalar xi = x[i];
+        Scalar yi = y[i];
+        x[i] =  c * xi + numext::conj(s) * yi;
+        y[i] = -s * xi + numext::conj(c) * yi;
+      }
+
+      Scalar* EIGEN_RESTRICT px = x + alignedStart;
+      Scalar* EIGEN_RESTRICT py = y + alignedStart;
+
+      if(internal::first_default_aligned(x, size)==alignedStart)
+      {
+        for(Index i=alignedStart; i<alignedEnd; i+=PacketSize)
+        {
+          Packet xi = pload<Packet>(px);
+          Packet yi = pload<Packet>(py);
+          pstore(px, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+          pstore(py, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+          px += PacketSize;
+          py += PacketSize;
+        }
+      }
+      else
+      {
+        Index peelingEnd = alignedStart + ((size-alignedStart)/(Peeling*PacketSize))*(Peeling*PacketSize);
+        for(Index i=alignedStart; i<peelingEnd; i+=Peeling*PacketSize)
+        {
+          Packet xi   = ploadu<Packet>(px);
+          Packet xi1  = ploadu<Packet>(px+PacketSize);
+          Packet yi   = pload <Packet>(py);
+          Packet yi1  = pload <Packet>(py+PacketSize);
+          pstoreu(px, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+          pstoreu(px+PacketSize, padd(pm.pmul(pc,xi1),pcj.pmul(ps,yi1)));
+          pstore (py, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+          pstore (py+PacketSize, psub(pcj.pmul(pc,yi1),pm.pmul(ps,xi1)));
+          px += Peeling*PacketSize;
+          py += Peeling*PacketSize;
+        }
+        if(alignedEnd!=peelingEnd)
+        {
+          Packet xi = ploadu<Packet>(x+peelingEnd);
+          Packet yi = pload <Packet>(y+peelingEnd);
+          pstoreu(x+peelingEnd, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+          pstore (y+peelingEnd, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+        }
+      }
+
+      for(Index i=alignedEnd; i<size; ++i)
+      {
+        Scalar xi = x[i];
+        Scalar yi = y[i];
+        x[i] =  c * xi + numext::conj(s) * yi;
+        y[i] = -s * xi + numext::conj(c) * yi;
+      }
+    }
+
+    /*** fixed-size vectorized path ***/
+    else if(SizeAtCompileTime != Dynamic && MinAlignment>0) // FIXME should be compared to the required alignment
+    {
+      const OtherPacket pc = pset1<OtherPacket>(c);
+      const OtherPacket ps = pset1<OtherPacket>(s);
+      conj_helper<OtherPacket,Packet,NumTraits<OtherPacket>::IsComplex,false> pcj;
+      conj_helper<OtherPacket,Packet,false,false> pm;
+      Scalar* EIGEN_RESTRICT px = x;
+      Scalar* EIGEN_RESTRICT py = y;
+      for(Index i=0; i<size; i+=PacketSize)
+      {
+        Packet xi = pload<Packet>(px);
+        Packet yi = pload<Packet>(py);
+        pstore(px, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+        pstore(py, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+        px += PacketSize;
+        py += PacketSize;
+      }
+    }
+
+    /*** non-vectorized path ***/
+    else
+    {
+      apply_rotation_in_the_plane_selector<Scalar,OtherScalar,SizeAtCompileTime,MinAlignment,false>::run(x,incrx,y,incry,size,c,s);
+    }
+  }
+};
+
+template<typename VectorX, typename VectorY, typename OtherScalar>
+EIGEN_DEVICE_FUNC
+void /*EIGEN_DONT_INLINE*/ apply_rotation_in_the_plane(DenseBase<VectorX>& xpr_x, DenseBase<VectorY>& xpr_y, const JacobiRotation<OtherScalar>& j)
+{
+  typedef typename VectorX::Scalar Scalar;
+  const bool Vectorizable =    (int(VectorX::Flags) & int(VectorY::Flags) & PacketAccessBit)
+                            && (int(packet_traits<Scalar>::size) == int(packet_traits<OtherScalar>::size));
+
+  eigen_assert(xpr_x.size() == xpr_y.size());
+  Index size = xpr_x.size();
+  Index incrx = xpr_x.derived().innerStride();
+  Index incry = xpr_y.derived().innerStride();
+
+  Scalar* EIGEN_RESTRICT x = &xpr_x.derived().coeffRef(0);
+  Scalar* EIGEN_RESTRICT y = &xpr_y.derived().coeffRef(0);
+
+  OtherScalar c = j.c();
+  OtherScalar s = j.s();
+  if (c==OtherScalar(1) && s==OtherScalar(0))
+    return;
+
+  apply_rotation_in_the_plane_selector<
+    Scalar,OtherScalar,
+    VectorX::SizeAtCompileTime,
+    EIGEN_PLAIN_ENUM_MIN(evaluator<VectorX>::Alignment, evaluator<VectorY>::Alignment),
+    Vectorizable>::run(x,incrx,y,incry,size,c,s);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_JACOBI_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/KLUSupport/KLUSupport.h b/C++/yolo_bytetrack/include/Eigen/src/KLUSupport/KLUSupport.h
new file mode 100644
index 00000000..215db35b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/KLUSupport/KLUSupport.h
@@ -0,0 +1,358 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Kyle Macfarlan <kyle.macfarlan@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_KLUSUPPORT_H
+#define EIGEN_KLUSUPPORT_H
+
+namespace Eigen {
+
+/* TODO extract L, extract U, compute det, etc... */
+
+/** \ingroup KLUSupport_Module
+  * \brief A sparse LU factorization and solver based on KLU
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LU factorization
+  * using the KLU library. The sparse matrix A must be squared and full rank.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * \warning The input matrix A should be in a \b compressed and \b column-major form.
+  * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class UmfPackLU, class SparseLU
+  */
+
+
+inline int klu_solve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B [ ], klu_common *Common, double) {
+   return klu_solve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), B, Common);
+}
+
+inline int klu_solve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex<double>B[], klu_common *Common, std::complex<double>) {
+   return klu_z_solve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), &numext::real_ref(B[0]), Common);
+}
+
+inline int klu_tsolve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B[], klu_common *Common, double) {
+   return klu_tsolve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), B, Common);
+}
+
+inline int klu_tsolve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex<double>B[], klu_common *Common, std::complex<double>) {
+   return klu_z_tsolve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), &numext::real_ref(B[0]), 0, Common);
+}
+
+inline klu_numeric* klu_factor(int Ap [ ], int Ai [ ], double Ax [ ], klu_symbolic *Symbolic, klu_common *Common, double) {
+   return klu_factor(Ap, Ai, Ax, Symbolic, Common);
+}
+
+inline klu_numeric* klu_factor(int Ap[], int Ai[], std::complex<double> Ax[], klu_symbolic *Symbolic, klu_common *Common, std::complex<double>) {
+   return klu_z_factor(Ap, Ai, &numext::real_ref(Ax[0]), Symbolic, Common);
+}
+
+
+template<typename _MatrixType>
+class KLU : public SparseSolverBase<KLU<_MatrixType> >
+{
+  protected:
+    typedef SparseSolverBase<KLU<_MatrixType> > Base;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
+    typedef SparseMatrix<Scalar> LUMatrixType;
+    typedef SparseMatrix<Scalar,ColMajor,int> KLUMatrixType;
+    typedef Ref<const KLUMatrixType, StandardCompressedFormat> KLUMatrixRef;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    KLU()
+      : m_dummy(0,0), mp_matrix(m_dummy)
+    {
+      init();
+    }
+
+    template<typename InputMatrixType>
+    explicit KLU(const InputMatrixType& matrix)
+      : mp_matrix(matrix)
+    {
+      init();
+      compute(matrix);
+    }
+
+    ~KLU()
+    {
+      if(m_symbolic) klu_free_symbolic(&m_symbolic,&m_common);
+      if(m_numeric)  klu_free_numeric(&m_numeric,&m_common);
+    }
+
+    EIGEN_CONSTEXPR inline Index rows() const EIGEN_NOEXCEPT { return mp_matrix.rows(); }
+    EIGEN_CONSTEXPR inline Index cols() const EIGEN_NOEXCEPT { return mp_matrix.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+#if 0 // not implemented yet
+    inline const LUMatrixType& matrixL() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_l;
+    }
+
+    inline const LUMatrixType& matrixU() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_u;
+    }
+
+    inline const IntColVectorType& permutationP() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_p;
+    }
+
+    inline const IntRowVectorType& permutationQ() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_q;
+    }
+#endif
+    /** Computes the sparse Cholesky decomposition of \a matrix
+     *  Note that the matrix should be column-major, and in compressed format for best performance.
+     *  \sa SparseMatrix::makeCompressed().
+     */
+    template<typename InputMatrixType>
+    void compute(const InputMatrixType& matrix)
+    {
+      if(m_symbolic) klu_free_symbolic(&m_symbolic, &m_common);
+      if(m_numeric)  klu_free_numeric(&m_numeric, &m_common);
+      grab(matrix.derived());
+      analyzePattern_impl();
+      factorize_impl();
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize(), compute()
+      */
+    template<typename InputMatrixType>
+    void analyzePattern(const InputMatrixType& matrix)
+    {
+      if(m_symbolic) klu_free_symbolic(&m_symbolic, &m_common);
+      if(m_numeric)  klu_free_numeric(&m_numeric, &m_common);
+
+      grab(matrix.derived());
+
+      analyzePattern_impl();
+    }
+
+
+    /** Provides access to the control settings array used by KLU.
+      *
+      * See KLU documentation for details.
+      */
+    inline const klu_common& kluCommon() const
+    {
+      return m_common;
+    }
+
+    /** Provides access to the control settings array used by UmfPack.
+      *
+      * If this array contains NaN's, the default values are used.
+      *
+      * See KLU documentation for details.
+      */
+    inline klu_common& kluCommon()
+    {
+      return m_common;
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the pattern anylysis has been performed.
+      *
+      * \sa analyzePattern(), compute()
+      */
+    template<typename InputMatrixType>
+    void factorize(const InputMatrixType& matrix)
+    {
+      eigen_assert(m_analysisIsOk && "KLU: you must first call analyzePattern()");
+      if(m_numeric)
+        klu_free_numeric(&m_numeric,&m_common);
+
+      grab(matrix.derived());
+
+      factorize_impl();
+    }
+
+    /** \internal */
+    template<typename BDerived,typename XDerived>
+    bool _solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const;
+
+#if 0 // not implemented yet
+    Scalar determinant() const;
+
+    void extractData() const;
+#endif
+
+  protected:
+
+    void init()
+    {
+      m_info                  = InvalidInput;
+      m_isInitialized         = false;
+      m_numeric               = 0;
+      m_symbolic              = 0;
+      m_extractedDataAreDirty = true;
+
+      klu_defaults(&m_common);
+    }
+
+    void analyzePattern_impl()
+    {
+      m_info = InvalidInput;
+      m_analysisIsOk = false;
+      m_factorizationIsOk = false;
+      m_symbolic = klu_analyze(internal::convert_index<int>(mp_matrix.rows()),
+                                     const_cast<StorageIndex*>(mp_matrix.outerIndexPtr()), const_cast<StorageIndex*>(mp_matrix.innerIndexPtr()),
+                                     &m_common);
+      if (m_symbolic) {
+         m_isInitialized = true;
+         m_info = Success;
+         m_analysisIsOk = true;
+         m_extractedDataAreDirty = true;
+      }
+    }
+
+    void factorize_impl()
+    {
+
+      m_numeric = klu_factor(const_cast<StorageIndex*>(mp_matrix.outerIndexPtr()), const_cast<StorageIndex*>(mp_matrix.innerIndexPtr()), const_cast<Scalar*>(mp_matrix.valuePtr()),
+                                    m_symbolic, &m_common, Scalar());
+
+
+      m_info = m_numeric ? Success : NumericalIssue;
+      m_factorizationIsOk = m_numeric ? 1 : 0;
+      m_extractedDataAreDirty = true;
+    }
+
+    template<typename MatrixDerived>
+    void grab(const EigenBase<MatrixDerived> &A)
+    {
+      mp_matrix.~KLUMatrixRef();
+      ::new (&mp_matrix) KLUMatrixRef(A.derived());
+    }
+
+    void grab(const KLUMatrixRef &A)
+    {
+      if(&(A.derived()) != &mp_matrix)
+      {
+        mp_matrix.~KLUMatrixRef();
+        ::new (&mp_matrix) KLUMatrixRef(A);
+      }
+    }
+
+    // cached data to reduce reallocation, etc.
+#if 0 // not implemented yet
+    mutable LUMatrixType m_l;
+    mutable LUMatrixType m_u;
+    mutable IntColVectorType m_p;
+    mutable IntRowVectorType m_q;
+#endif
+
+    KLUMatrixType m_dummy;
+    KLUMatrixRef mp_matrix;
+
+    klu_numeric* m_numeric;
+    klu_symbolic* m_symbolic;
+    klu_common m_common;
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+    mutable bool m_extractedDataAreDirty;
+
+  private:
+    KLU(const KLU& ) { }
+};
+
+#if 0 // not implemented yet
+template<typename MatrixType>
+void KLU<MatrixType>::extractData() const
+{
+  if (m_extractedDataAreDirty)
+  {
+     eigen_assert(false && "KLU: extractData Not Yet Implemented");
+
+    // get size of the data
+    int lnz, unz, rows, cols, nz_udiag;
+    umfpack_get_lunz(&lnz, &unz, &rows, &cols, &nz_udiag, m_numeric, Scalar());
+
+    // allocate data
+    m_l.resize(rows,(std::min)(rows,cols));
+    m_l.resizeNonZeros(lnz);
+
+    m_u.resize((std::min)(rows,cols),cols);
+    m_u.resizeNonZeros(unz);
+
+    m_p.resize(rows);
+    m_q.resize(cols);
+
+    // extract
+    umfpack_get_numeric(m_l.outerIndexPtr(), m_l.innerIndexPtr(), m_l.valuePtr(),
+                        m_u.outerIndexPtr(), m_u.innerIndexPtr(), m_u.valuePtr(),
+                        m_p.data(), m_q.data(), 0, 0, 0, m_numeric);
+
+    m_extractedDataAreDirty = false;
+  }
+}
+
+template<typename MatrixType>
+typename KLU<MatrixType>::Scalar KLU<MatrixType>::determinant() const
+{
+  eigen_assert(false && "KLU: extractData Not Yet Implemented");
+  return Scalar();
+}
+#endif
+
+template<typename MatrixType>
+template<typename BDerived,typename XDerived>
+bool KLU<MatrixType>::_solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const
+{
+  Index rhsCols = b.cols();
+  EIGEN_STATIC_ASSERT((XDerived::Flags&RowMajorBit)==0, THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or analyzePattern()/factorize()");
+
+  x = b;
+  int info = klu_solve(m_symbolic, m_numeric, b.rows(), rhsCols, x.const_cast_derived().data(), const_cast<klu_common*>(&m_common), Scalar());
+
+  m_info = info!=0 ? Success : NumericalIssue;
+  return true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_KLUSUPPORT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/LU/Determinant.h b/C++/yolo_bytetrack/include/Eigen/src/LU/Determinant.h
new file mode 100644
index 00000000..3a41e6fc
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/LU/Determinant.h
@@ -0,0 +1,117 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DETERMINANT_H
+#define EIGEN_DETERMINANT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+inline const typename Derived::Scalar bruteforce_det3_helper
+(const MatrixBase<Derived>& matrix, int a, int b, int c)
+{
+  return matrix.coeff(0,a)
+         * (matrix.coeff(1,b) * matrix.coeff(2,c) - matrix.coeff(1,c) * matrix.coeff(2,b));
+}
+
+template<typename Derived,
+         int DeterminantType = Derived::RowsAtCompileTime
+> struct determinant_impl
+{
+  static inline typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    if(Derived::ColsAtCompileTime==Dynamic && m.rows()==0)
+      return typename traits<Derived>::Scalar(1);
+    return m.partialPivLu().determinant();
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 1>
+{
+  static inline EIGEN_DEVICE_FUNC
+  typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    return m.coeff(0,0);
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 2>
+{
+  static inline EIGEN_DEVICE_FUNC
+  typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    return m.coeff(0,0) * m.coeff(1,1) - m.coeff(1,0) * m.coeff(0,1);
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 3>
+{
+  static inline EIGEN_DEVICE_FUNC
+  typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    return bruteforce_det3_helper(m,0,1,2)
+          - bruteforce_det3_helper(m,1,0,2)
+          + bruteforce_det3_helper(m,2,0,1);
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 4>
+{
+  typedef typename traits<Derived>::Scalar Scalar;
+  static EIGEN_DEVICE_FUNC
+  Scalar run(const Derived& m)
+  {
+    Scalar d2_01 = det2(m, 0, 1);
+    Scalar d2_02 = det2(m, 0, 2);
+    Scalar d2_03 = det2(m, 0, 3);
+    Scalar d2_12 = det2(m, 1, 2);
+    Scalar d2_13 = det2(m, 1, 3);
+    Scalar d2_23 = det2(m, 2, 3);
+    Scalar d3_0 = det3(m, 1,d2_23, 2,d2_13, 3,d2_12);
+    Scalar d3_1 = det3(m, 0,d2_23, 2,d2_03, 3,d2_02);
+    Scalar d3_2 = det3(m, 0,d2_13, 1,d2_03, 3,d2_01);
+    Scalar d3_3 = det3(m, 0,d2_12, 1,d2_02, 2,d2_01);
+    return internal::pmadd(-m(0,3),d3_0, m(1,3)*d3_1) +
+           internal::pmadd(-m(2,3),d3_2, m(3,3)*d3_3);
+  }
+protected:
+  static EIGEN_DEVICE_FUNC
+  Scalar det2(const Derived& m, Index i0, Index i1)
+  {
+    return m(i0,0) * m(i1,1) - m(i1,0) * m(i0,1);
+  }
+
+  static EIGEN_DEVICE_FUNC
+  Scalar det3(const Derived& m, Index i0, const Scalar& d0, Index i1, const Scalar& d1, Index i2, const Scalar& d2)
+  {
+    return internal::pmadd(m(i0,2), d0, internal::pmadd(-m(i1,2), d1, m(i2,2)*d2));
+  }
+};
+
+} // end namespace internal
+
+/** \lu_module
+  *
+  * \returns the determinant of this matrix
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+inline typename internal::traits<Derived>::Scalar MatrixBase<Derived>::determinant() const
+{
+  eigen_assert(rows() == cols());
+  typedef typename internal::nested_eval<Derived,Base::RowsAtCompileTime>::type Nested;
+  return internal::determinant_impl<typename internal::remove_all<Nested>::type>::run(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DETERMINANT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/LU/FullPivLU.h b/C++/yolo_bytetrack/include/Eigen/src/LU/FullPivLU.h
new file mode 100644
index 00000000..ba1749fa
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/LU/FullPivLU.h
@@ -0,0 +1,877 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LU_H
+#define EIGEN_LU_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _MatrixType> struct traits<FullPivLU<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+} // end namespace internal
+
+/** \ingroup LU_Module
+  *
+  * \class FullPivLU
+  *
+  * \brief LU decomposition of a matrix with complete pivoting, and related features
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the LU decomposition
+  *
+  * This class represents a LU decomposition of any matrix, with complete pivoting: the matrix A is
+  * decomposed as \f$ A = P^{-1} L U Q^{-1} \f$ where L is unit-lower-triangular, U is
+  * upper-triangular, and P and Q are permutation matrices. This is a rank-revealing LU
+  * decomposition. The eigenvalues (diagonal coefficients) of U are sorted in such a way that any
+  * zeros are at the end.
+  *
+  * This decomposition provides the generic approach to solving systems of linear equations, computing
+  * the rank, invertibility, inverse, kernel, and determinant.
+  *
+  * This LU decomposition is very stable and well tested with large matrices. However there are use cases where the SVD
+  * decomposition is inherently more stable and/or flexible. For example, when computing the kernel of a matrix,
+  * working with the SVD allows to select the smallest singular values of the matrix, something that
+  * the LU decomposition doesn't see.
+  *
+  * The data of the LU decomposition can be directly accessed through the methods matrixLU(),
+  * permutationP(), permutationQ().
+  *
+  * As an example, here is how the original matrix can be retrieved:
+  * \include class_FullPivLU.cpp
+  * Output: \verbinclude class_FullPivLU.out
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * \sa MatrixBase::fullPivLu(), MatrixBase::determinant(), MatrixBase::inverse()
+  */
+template<typename _MatrixType> class FullPivLU
+  : public SolverBase<FullPivLU<_MatrixType> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<FullPivLU> Base;
+    friend class SolverBase<FullPivLU>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(FullPivLU)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename internal::plain_row_type<MatrixType, StorageIndex>::type IntRowVectorType;
+    typedef typename internal::plain_col_type<MatrixType, StorageIndex>::type IntColVectorType;
+    typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationQType;
+    typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationPType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via LU::compute(const MatrixType&).
+      */
+    FullPivLU();
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa FullPivLU()
+      */
+    FullPivLU(Index rows, Index cols);
+
+    /** Constructor.
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *               It is required to be nonzero.
+      */
+    template<typename InputType>
+    explicit FullPivLU(const EigenBase<InputType>& matrix);
+
+    /** \brief Constructs a LU factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa FullPivLU(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit FullPivLU(EigenBase<InputType>& matrix);
+
+    /** Computes the LU decomposition of the given matrix.
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *               It is required to be nonzero.
+      *
+      * \returns a reference to *this
+      */
+    template<typename InputType>
+    FullPivLU& compute(const EigenBase<InputType>& matrix) {
+      m_lu = matrix.derived();
+      computeInPlace();
+      return *this;
+    }
+
+    /** \returns the LU decomposition matrix: the upper-triangular part is U, the
+      * unit-lower-triangular part is L (at least for square matrices; in the non-square
+      * case, special care is needed, see the documentation of class FullPivLU).
+      *
+      * \sa matrixL(), matrixU()
+      */
+    inline const MatrixType& matrixLU() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_lu;
+    }
+
+    /** \returns the number of nonzero pivots in the LU decomposition.
+      * Here nonzero is meant in the exact sense, not in a fuzzy sense.
+      * So that notion isn't really intrinsically interesting, but it is
+      * still useful when implementing algorithms.
+      *
+      * \sa rank()
+      */
+    inline Index nonzeroPivots() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_nonzero_pivots;
+    }
+
+    /** \returns the absolute value of the biggest pivot, i.e. the biggest
+      *          diagonal coefficient of U.
+      */
+    RealScalar maxPivot() const { return m_maxpivot; }
+
+    /** \returns the permutation matrix P
+      *
+      * \sa permutationQ()
+      */
+    EIGEN_DEVICE_FUNC inline const PermutationPType& permutationP() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_p;
+    }
+
+    /** \returns the permutation matrix Q
+      *
+      * \sa permutationP()
+      */
+    inline const PermutationQType& permutationQ() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_q;
+    }
+
+    /** \returns the kernel of the matrix, also called its null-space. The columns of the returned matrix
+      * will form a basis of the kernel.
+      *
+      * \note If the kernel has dimension zero, then the returned matrix is a column-vector filled with zeros.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      *
+      * Example: \include FullPivLU_kernel.cpp
+      * Output: \verbinclude FullPivLU_kernel.out
+      *
+      * \sa image()
+      */
+    inline const internal::kernel_retval<FullPivLU> kernel() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return internal::kernel_retval<FullPivLU>(*this);
+    }
+
+    /** \returns the image of the matrix, also called its column-space. The columns of the returned matrix
+      * will form a basis of the image (column-space).
+      *
+      * \param originalMatrix the original matrix, of which *this is the LU decomposition.
+      *                       The reason why it is needed to pass it here, is that this allows
+      *                       a large optimization, as otherwise this method would need to reconstruct it
+      *                       from the LU decomposition.
+      *
+      * \note If the image has dimension zero, then the returned matrix is a column-vector filled with zeros.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      *
+      * Example: \include FullPivLU_image.cpp
+      * Output: \verbinclude FullPivLU_image.out
+      *
+      * \sa kernel()
+      */
+    inline const internal::image_retval<FullPivLU>
+      image(const MatrixType& originalMatrix) const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return internal::image_retval<FullPivLU>(*this, originalMatrix);
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \return a solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the LU decomposition.
+      *
+      * \param b the right-hand-side of the equation to solve. Can be a vector or a matrix,
+      *          the only requirement in order for the equation to make sense is that
+      *          b.rows()==A.rows(), where A is the matrix of which *this is the LU decomposition.
+      *
+      * \returns a solution.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      * \note_about_using_kernel_to_study_multiple_solutions
+      *
+      * Example: \include FullPivLU_solve.cpp
+      * Output: \verbinclude FullPivLU_solve.out
+      *
+      * \sa TriangularView::solve(), kernel(), inverse()
+      */
+    template<typename Rhs>
+    inline const Solve<FullPivLU, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of which \c *this is
+        the LU decomposition.
+      */
+    inline RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    /** \returns the determinant of the matrix of which
+      * *this is the LU decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the LU decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note For fixed-size matrices of size up to 4, MatrixBase::determinant() offers
+      *       optimized paths.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      *
+      * \sa MatrixBase::determinant()
+      */
+    typename internal::traits<MatrixType>::Scalar determinant() const;
+
+    /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
+      * who need to determine when pivots are to be considered nonzero. This is not used for the
+      * LU decomposition itself.
+      *
+      * When it needs to get the threshold value, Eigen calls threshold(). By default, this
+      * uses a formula to automatically determine a reasonable threshold.
+      * Once you have called the present method setThreshold(const RealScalar&),
+      * your value is used instead.
+      *
+      * \param threshold The new value to use as the threshold.
+      *
+      * A pivot will be considered nonzero if its absolute value is strictly greater than
+      *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+      * where maxpivot is the biggest pivot.
+      *
+      * If you want to come back to the default behavior, call setThreshold(Default_t)
+      */
+    FullPivLU& setThreshold(const RealScalar& threshold)
+    {
+      m_usePrescribedThreshold = true;
+      m_prescribedThreshold = threshold;
+      return *this;
+    }
+
+    /** Allows to come back to the default behavior, letting Eigen use its default formula for
+      * determining the threshold.
+      *
+      * You should pass the special object Eigen::Default as parameter here.
+      * \code lu.setThreshold(Eigen::Default); \endcode
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    FullPivLU& setThreshold(Default_t)
+    {
+      m_usePrescribedThreshold = false;
+      return *this;
+    }
+
+    /** Returns the threshold that will be used by certain methods such as rank().
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    RealScalar threshold() const
+    {
+      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+      return m_usePrescribedThreshold ? m_prescribedThreshold
+      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
+      // and turns out to be identical to Higham's formula used already in LDLt.
+          : NumTraits<Scalar>::epsilon() * RealScalar(m_lu.diagonalSize());
+    }
+
+    /** \returns the rank of the matrix of which *this is the LU decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index rank() const
+    {
+      using std::abs;
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
+      Index result = 0;
+      for(Index i = 0; i < m_nonzero_pivots; ++i)
+        result += (abs(m_lu.coeff(i,i)) > premultiplied_threshold);
+      return result;
+    }
+
+    /** \returns the dimension of the kernel of the matrix of which *this is the LU decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index dimensionOfKernel() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return cols() - rank();
+    }
+
+    /** \returns true if the matrix of which *this is the LU decomposition represents an injective
+      *          linear map, i.e. has trivial kernel; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInjective() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return rank() == cols();
+    }
+
+    /** \returns true if the matrix of which *this is the LU decomposition represents a surjective
+      *          linear map; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isSurjective() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return rank() == rows();
+    }
+
+    /** \returns true if the matrix of which *this is the LU decomposition is invertible.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInvertible() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return isInjective() && (m_lu.rows() == m_lu.cols());
+    }
+
+    /** \returns the inverse of the matrix of which *this is the LU decomposition.
+      *
+      * \note If this matrix is not invertible, the returned matrix has undefined coefficients.
+      *       Use isInvertible() to first determine whether this matrix is invertible.
+      *
+      * \sa MatrixBase::inverse()
+      */
+    inline const Inverse<FullPivLU> inverse() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the inverse of a non-square matrix!");
+      return Inverse<FullPivLU>(*this);
+    }
+
+    MatrixType reconstructedMatrix() const;
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_lu.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_lu.cols(); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_lu;
+    PermutationPType m_p;
+    PermutationQType m_q;
+    IntColVectorType m_rowsTranspositions;
+    IntRowVectorType m_colsTranspositions;
+    Index m_nonzero_pivots;
+    RealScalar m_l1_norm;
+    RealScalar m_maxpivot, m_prescribedThreshold;
+    signed char m_det_pq;
+    bool m_isInitialized, m_usePrescribedThreshold;
+};
+
+template<typename MatrixType>
+FullPivLU<MatrixType>::FullPivLU()
+  : m_isInitialized(false), m_usePrescribedThreshold(false)
+{
+}
+
+template<typename MatrixType>
+FullPivLU<MatrixType>::FullPivLU(Index rows, Index cols)
+  : m_lu(rows, cols),
+    m_p(rows),
+    m_q(cols),
+    m_rowsTranspositions(rows),
+    m_colsTranspositions(cols),
+    m_isInitialized(false),
+    m_usePrescribedThreshold(false)
+{
+}
+
+template<typename MatrixType>
+template<typename InputType>
+FullPivLU<MatrixType>::FullPivLU(const EigenBase<InputType>& matrix)
+  : m_lu(matrix.rows(), matrix.cols()),
+    m_p(matrix.rows()),
+    m_q(matrix.cols()),
+    m_rowsTranspositions(matrix.rows()),
+    m_colsTranspositions(matrix.cols()),
+    m_isInitialized(false),
+    m_usePrescribedThreshold(false)
+{
+  compute(matrix.derived());
+}
+
+template<typename MatrixType>
+template<typename InputType>
+FullPivLU<MatrixType>::FullPivLU(EigenBase<InputType>& matrix)
+  : m_lu(matrix.derived()),
+    m_p(matrix.rows()),
+    m_q(matrix.cols()),
+    m_rowsTranspositions(matrix.rows()),
+    m_colsTranspositions(matrix.cols()),
+    m_isInitialized(false),
+    m_usePrescribedThreshold(false)
+{
+  computeInPlace();
+}
+
+template<typename MatrixType>
+void FullPivLU<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  // the permutations are stored as int indices, so just to be sure:
+  eigen_assert(m_lu.rows()<=NumTraits<int>::highest() && m_lu.cols()<=NumTraits<int>::highest());
+
+  m_l1_norm = m_lu.cwiseAbs().colwise().sum().maxCoeff();
+
+  const Index size = m_lu.diagonalSize();
+  const Index rows = m_lu.rows();
+  const Index cols = m_lu.cols();
+
+  // will store the transpositions, before we accumulate them at the end.
+  // can't accumulate on-the-fly because that will be done in reverse order for the rows.
+  m_rowsTranspositions.resize(m_lu.rows());
+  m_colsTranspositions.resize(m_lu.cols());
+  Index number_of_transpositions = 0; // number of NONTRIVIAL transpositions, i.e. m_rowsTranspositions[i]!=i
+
+  m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case)
+  m_maxpivot = RealScalar(0);
+
+  for(Index k = 0; k < size; ++k)
+  {
+    // First, we need to find the pivot.
+
+    // biggest coefficient in the remaining bottom-right corner (starting at row k, col k)
+    Index row_of_biggest_in_corner, col_of_biggest_in_corner;
+    typedef internal::scalar_score_coeff_op<Scalar> Scoring;
+    typedef typename Scoring::result_type Score;
+    Score biggest_in_corner;
+    biggest_in_corner = m_lu.bottomRightCorner(rows-k, cols-k)
+                        .unaryExpr(Scoring())
+                        .maxCoeff(&row_of_biggest_in_corner, &col_of_biggest_in_corner);
+    row_of_biggest_in_corner += k; // correct the values! since they were computed in the corner,
+    col_of_biggest_in_corner += k; // need to add k to them.
+
+    if(biggest_in_corner==Score(0))
+    {
+      // before exiting, make sure to initialize the still uninitialized transpositions
+      // in a sane state without destroying what we already have.
+      m_nonzero_pivots = k;
+      for(Index i = k; i < size; ++i)
+      {
+        m_rowsTranspositions.coeffRef(i) = internal::convert_index<StorageIndex>(i);
+        m_colsTranspositions.coeffRef(i) = internal::convert_index<StorageIndex>(i);
+      }
+      break;
+    }
+
+    RealScalar abs_pivot = internal::abs_knowing_score<Scalar>()(m_lu(row_of_biggest_in_corner, col_of_biggest_in_corner), biggest_in_corner);
+    if(abs_pivot > m_maxpivot) m_maxpivot = abs_pivot;
+
+    // Now that we've found the pivot, we need to apply the row/col swaps to
+    // bring it to the location (k,k).
+
+    m_rowsTranspositions.coeffRef(k) = internal::convert_index<StorageIndex>(row_of_biggest_in_corner);
+    m_colsTranspositions.coeffRef(k) = internal::convert_index<StorageIndex>(col_of_biggest_in_corner);
+    if(k != row_of_biggest_in_corner) {
+      m_lu.row(k).swap(m_lu.row(row_of_biggest_in_corner));
+      ++number_of_transpositions;
+    }
+    if(k != col_of_biggest_in_corner) {
+      m_lu.col(k).swap(m_lu.col(col_of_biggest_in_corner));
+      ++number_of_transpositions;
+    }
+
+    // Now that the pivot is at the right location, we update the remaining
+    // bottom-right corner by Gaussian elimination.
+
+    if(k<rows-1)
+      m_lu.col(k).tail(rows-k-1) /= m_lu.coeff(k,k);
+    if(k<size-1)
+      m_lu.block(k+1,k+1,rows-k-1,cols-k-1).noalias() -= m_lu.col(k).tail(rows-k-1) * m_lu.row(k).tail(cols-k-1);
+  }
+
+  // the main loop is over, we still have to accumulate the transpositions to find the
+  // permutations P and Q
+
+  m_p.setIdentity(rows);
+  for(Index k = size-1; k >= 0; --k)
+    m_p.applyTranspositionOnTheRight(k, m_rowsTranspositions.coeff(k));
+
+  m_q.setIdentity(cols);
+  for(Index k = 0; k < size; ++k)
+    m_q.applyTranspositionOnTheRight(k, m_colsTranspositions.coeff(k));
+
+  m_det_pq = (number_of_transpositions%2) ? -1 : 1;
+
+  m_isInitialized = true;
+}
+
+template<typename MatrixType>
+typename internal::traits<MatrixType>::Scalar FullPivLU<MatrixType>::determinant() const
+{
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the determinant of a non-square matrix!");
+  return Scalar(m_det_pq) * Scalar(m_lu.diagonal().prod());
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: \f$ P^{-1} L U Q^{-1} \f$.
+ * This function is provided for debug purposes. */
+template<typename MatrixType>
+MatrixType FullPivLU<MatrixType>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  const Index smalldim = (std::min)(m_lu.rows(), m_lu.cols());
+  // LU
+  MatrixType res(m_lu.rows(),m_lu.cols());
+  // FIXME the .toDenseMatrix() should not be needed...
+  res = m_lu.leftCols(smalldim)
+            .template triangularView<UnitLower>().toDenseMatrix()
+      * m_lu.topRows(smalldim)
+            .template triangularView<Upper>().toDenseMatrix();
+
+  // P^{-1}(LU)
+  res = m_p.inverse() * res;
+
+  // (P^{-1}LU)Q^{-1}
+  res = res * m_q.inverse();
+
+  return res;
+}
+
+/********* Implementation of kernel() **************************************************/
+
+namespace internal {
+template<typename _MatrixType>
+struct kernel_retval<FullPivLU<_MatrixType> >
+  : kernel_retval_base<FullPivLU<_MatrixType> >
+{
+  EIGEN_MAKE_KERNEL_HELPERS(FullPivLU<_MatrixType>)
+
+  enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(
+            MatrixType::MaxColsAtCompileTime,
+            MatrixType::MaxRowsAtCompileTime)
+  };
+
+  template<typename Dest> void evalTo(Dest& dst) const
+  {
+    using std::abs;
+    const Index cols = dec().matrixLU().cols(), dimker = cols - rank();
+    if(dimker == 0)
+    {
+      // The Kernel is just {0}, so it doesn't have a basis properly speaking, but let's
+      // avoid crashing/asserting as that depends on floating point calculations. Let's
+      // just return a single column vector filled with zeros.
+      dst.setZero();
+      return;
+    }
+
+    /* Let us use the following lemma:
+      *
+      * Lemma: If the matrix A has the LU decomposition PAQ = LU,
+      * then Ker A = Q(Ker U).
+      *
+      * Proof: trivial: just keep in mind that P, Q, L are invertible.
+      */
+
+    /* Thus, all we need to do is to compute Ker U, and then apply Q.
+      *
+      * U is upper triangular, with eigenvalues sorted so that any zeros appear at the end.
+      * Thus, the diagonal of U ends with exactly
+      * dimKer zero's. Let us use that to construct dimKer linearly
+      * independent vectors in Ker U.
+      */
+
+    Matrix<Index, Dynamic, 1, 0, MaxSmallDimAtCompileTime, 1> pivots(rank());
+    RealScalar premultiplied_threshold = dec().maxPivot() * dec().threshold();
+    Index p = 0;
+    for(Index i = 0; i < dec().nonzeroPivots(); ++i)
+      if(abs(dec().matrixLU().coeff(i,i)) > premultiplied_threshold)
+        pivots.coeffRef(p++) = i;
+    eigen_internal_assert(p == rank());
+
+    // we construct a temporaty trapezoid matrix m, by taking the U matrix and
+    // permuting the rows and cols to bring the nonnegligible pivots to the top of
+    // the main diagonal. We need that to be able to apply our triangular solvers.
+    // FIXME when we get triangularView-for-rectangular-matrices, this can be simplified
+    Matrix<typename MatrixType::Scalar, Dynamic, Dynamic, MatrixType::Options,
+           MaxSmallDimAtCompileTime, MatrixType::MaxColsAtCompileTime>
+      m(dec().matrixLU().block(0, 0, rank(), cols));
+    for(Index i = 0; i < rank(); ++i)
+    {
+      if(i) m.row(i).head(i).setZero();
+      m.row(i).tail(cols-i) = dec().matrixLU().row(pivots.coeff(i)).tail(cols-i);
+    }
+    m.block(0, 0, rank(), rank());
+    m.block(0, 0, rank(), rank()).template triangularView<StrictlyLower>().setZero();
+    for(Index i = 0; i < rank(); ++i)
+      m.col(i).swap(m.col(pivots.coeff(i)));
+
+    // ok, we have our trapezoid matrix, we can apply the triangular solver.
+    // notice that the math behind this suggests that we should apply this to the
+    // negative of the RHS, but for performance we just put the negative sign elsewhere, see below.
+    m.topLeftCorner(rank(), rank())
+     .template triangularView<Upper>().solveInPlace(
+        m.topRightCorner(rank(), dimker)
+      );
+
+    // now we must undo the column permutation that we had applied!
+    for(Index i = rank()-1; i >= 0; --i)
+      m.col(i).swap(m.col(pivots.coeff(i)));
+
+    // see the negative sign in the next line, that's what we were talking about above.
+    for(Index i = 0; i < rank(); ++i) dst.row(dec().permutationQ().indices().coeff(i)) = -m.row(i).tail(dimker);
+    for(Index i = rank(); i < cols; ++i) dst.row(dec().permutationQ().indices().coeff(i)).setZero();
+    for(Index k = 0; k < dimker; ++k) dst.coeffRef(dec().permutationQ().indices().coeff(rank()+k), k) = Scalar(1);
+  }
+};
+
+/***** Implementation of image() *****************************************************/
+
+template<typename _MatrixType>
+struct image_retval<FullPivLU<_MatrixType> >
+  : image_retval_base<FullPivLU<_MatrixType> >
+{
+  EIGEN_MAKE_IMAGE_HELPERS(FullPivLU<_MatrixType>)
+
+  enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(
+            MatrixType::MaxColsAtCompileTime,
+            MatrixType::MaxRowsAtCompileTime)
+  };
+
+  template<typename Dest> void evalTo(Dest& dst) const
+  {
+    using std::abs;
+    if(rank() == 0)
+    {
+      // The Image is just {0}, so it doesn't have a basis properly speaking, but let's
+      // avoid crashing/asserting as that depends on floating point calculations. Let's
+      // just return a single column vector filled with zeros.
+      dst.setZero();
+      return;
+    }
+
+    Matrix<Index, Dynamic, 1, 0, MaxSmallDimAtCompileTime, 1> pivots(rank());
+    RealScalar premultiplied_threshold = dec().maxPivot() * dec().threshold();
+    Index p = 0;
+    for(Index i = 0; i < dec().nonzeroPivots(); ++i)
+      if(abs(dec().matrixLU().coeff(i,i)) > premultiplied_threshold)
+        pivots.coeffRef(p++) = i;
+    eigen_internal_assert(p == rank());
+
+    for(Index i = 0; i < rank(); ++i)
+      dst.col(i) = originalMatrix().col(dec().permutationQ().indices().coeff(pivots.coeff(i)));
+  }
+};
+
+/***** Implementation of solve() *****************************************************/
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void FullPivLU<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  /* The decomposition PAQ = LU can be rewritten as A = P^{-1} L U Q^{-1}.
+  * So we proceed as follows:
+  * Step 1: compute c = P * rhs.
+  * Step 2: replace c by the solution x to Lx = c. Exists because L is invertible.
+  * Step 3: replace c by the solution x to Ux = c. May or may not exist.
+  * Step 4: result = Q * c;
+  */
+
+  const Index rows = this->rows(),
+              cols = this->cols(),
+              nonzero_pivots = this->rank();
+  const Index smalldim = (std::min)(rows, cols);
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs.rows(), rhs.cols());
+
+  // Step 1
+  c = permutationP() * rhs;
+
+  // Step 2
+  m_lu.topLeftCorner(smalldim,smalldim)
+      .template triangularView<UnitLower>()
+      .solveInPlace(c.topRows(smalldim));
+  if(rows>cols)
+    c.bottomRows(rows-cols) -= m_lu.bottomRows(rows-cols) * c.topRows(cols);
+
+  // Step 3
+  m_lu.topLeftCorner(nonzero_pivots, nonzero_pivots)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(nonzero_pivots));
+
+  // Step 4
+  for(Index i = 0; i < nonzero_pivots; ++i)
+    dst.row(permutationQ().indices().coeff(i)) = c.row(i);
+  for(Index i = nonzero_pivots; i < m_lu.cols(); ++i)
+    dst.row(permutationQ().indices().coeff(i)).setZero();
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void FullPivLU<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  /* The decomposition PAQ = LU can be rewritten as A = P^{-1} L U Q^{-1},
+   * and since permutations are real and unitary, we can write this
+   * as   A^T = Q U^T L^T P,
+   * So we proceed as follows:
+   * Step 1: compute c = Q^T rhs.
+   * Step 2: replace c by the solution x to U^T x = c. May or may not exist.
+   * Step 3: replace c by the solution x to L^T x = c.
+   * Step 4: result = P^T c.
+   * If Conjugate is true, replace "^T" by "^*" above.
+   */
+
+  const Index rows = this->rows(), cols = this->cols(),
+    nonzero_pivots = this->rank();
+  const Index smalldim = (std::min)(rows, cols);
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs.rows(), rhs.cols());
+
+  // Step 1
+  c = permutationQ().inverse() * rhs;
+
+  // Step 2
+  m_lu.topLeftCorner(nonzero_pivots, nonzero_pivots)
+      .template triangularView<Upper>()
+      .transpose()
+      .template conjugateIf<Conjugate>()
+      .solveInPlace(c.topRows(nonzero_pivots));
+
+  // Step 3
+  m_lu.topLeftCorner(smalldim, smalldim)
+      .template triangularView<UnitLower>()
+      .transpose()
+      .template conjugateIf<Conjugate>()
+      .solveInPlace(c.topRows(smalldim));
+
+  // Step 4
+  PermutationPType invp = permutationP().inverse().eval();
+  for(Index i = 0; i < smalldim; ++i)
+    dst.row(invp.indices().coeff(i)) = c.row(i);
+  for(Index i = smalldim; i < rows; ++i)
+    dst.row(invp.indices().coeff(i)).setZero();
+}
+
+#endif
+
+namespace internal {
+
+
+/***** Implementation of inverse() *****************************************************/
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<FullPivLU<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename FullPivLU<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef FullPivLU<MatrixType> LuType;
+  typedef Inverse<LuType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename MatrixType::Scalar> &)
+  {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+} // end namespace internal
+
+/******* MatrixBase methods *****************************************************************/
+
+/** \lu_module
+  *
+  * \return the full-pivoting LU decomposition of \c *this.
+  *
+  * \sa class FullPivLU
+  */
+template<typename Derived>
+inline const FullPivLU<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::fullPivLu() const
+{
+  return FullPivLU<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_LU_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/LU/InverseImpl.h b/C++/yolo_bytetrack/include/Eigen/src/LU/InverseImpl.h
new file mode 100644
index 00000000..a40cefa9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/LU/InverseImpl.h
@@ -0,0 +1,432 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INVERSE_IMPL_H
+#define EIGEN_INVERSE_IMPL_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************
+*** General case implementation ***
+**********************************/
+
+template<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime>
+struct compute_inverse
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    result = matrix.partialPivLu().inverse();
+  }
+};
+
+template<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime>
+struct compute_inverse_and_det_with_check { /* nothing! general case not supported. */ };
+
+/****************************
+*** Size 1 implementation ***
+****************************/
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    internal::evaluator<MatrixType> matrixEval(matrix);
+    result.coeffRef(0,0) = Scalar(1) / matrixEval.coeff(0,0);
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& result,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    using std::abs;
+    determinant = matrix.coeff(0,0);
+    invertible = abs(determinant) > absDeterminantThreshold;
+    if(invertible) result.coeffRef(0,0) = typename ResultType::Scalar(1) / determinant;
+  }
+};
+
+/****************************
+*** Size 2 implementation ***
+****************************/
+
+template<typename MatrixType, typename ResultType>
+EIGEN_DEVICE_FUNC 
+inline void compute_inverse_size2_helper(
+    const MatrixType& matrix, const typename ResultType::Scalar& invdet,
+    ResultType& result)
+{
+  typename ResultType::Scalar temp = matrix.coeff(0,0);
+  result.coeffRef(0,0) =  matrix.coeff(1,1) * invdet;
+  result.coeffRef(1,0) = -matrix.coeff(1,0) * invdet;
+  result.coeffRef(0,1) = -matrix.coeff(0,1) * invdet;
+  result.coeffRef(1,1) =  temp * invdet;
+}
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 2>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    typedef typename ResultType::Scalar Scalar;
+    const Scalar invdet = typename MatrixType::Scalar(1) / matrix.determinant();
+    compute_inverse_size2_helper(matrix, invdet, result);
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 2>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    using std::abs;
+    typedef typename ResultType::Scalar Scalar;
+    determinant = matrix.determinant();
+    invertible = abs(determinant) > absDeterminantThreshold;
+    if(!invertible) return;
+    const Scalar invdet = Scalar(1) / determinant;
+    compute_inverse_size2_helper(matrix, invdet, inverse);
+  }
+};
+
+/****************************
+*** Size 3 implementation ***
+****************************/
+
+template<typename MatrixType, int i, int j>
+EIGEN_DEVICE_FUNC 
+inline typename MatrixType::Scalar cofactor_3x3(const MatrixType& m)
+{
+  enum {
+    i1 = (i+1) % 3,
+    i2 = (i+2) % 3,
+    j1 = (j+1) % 3,
+    j2 = (j+2) % 3
+  };
+  return m.coeff(i1, j1) * m.coeff(i2, j2)
+       - m.coeff(i1, j2) * m.coeff(i2, j1);
+}
+
+template<typename MatrixType, typename ResultType>
+EIGEN_DEVICE_FUNC
+inline void compute_inverse_size3_helper(
+    const MatrixType& matrix,
+    const typename ResultType::Scalar& invdet,
+    const Matrix<typename ResultType::Scalar,3,1>& cofactors_col0,
+    ResultType& result)
+{
+  // Compute cofactors in a way that avoids aliasing issues.
+  typedef typename ResultType::Scalar Scalar;
+  const Scalar c01 = cofactor_3x3<MatrixType,0,1>(matrix) * invdet;
+  const Scalar c11 = cofactor_3x3<MatrixType,1,1>(matrix) * invdet;
+  const Scalar c02 = cofactor_3x3<MatrixType,0,2>(matrix) * invdet;
+  result.coeffRef(1,2) =  cofactor_3x3<MatrixType,2,1>(matrix) * invdet;
+  result.coeffRef(2,1) =  cofactor_3x3<MatrixType,1,2>(matrix) * invdet;
+  result.coeffRef(2,2) =  cofactor_3x3<MatrixType,2,2>(matrix) * invdet;
+  result.coeffRef(1,0) =  c01;
+  result.coeffRef(1,1) =  c11;
+  result.coeffRef(2,0) =  c02;  
+  result.row(0) = cofactors_col0 * invdet;
+}
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 3>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    typedef typename ResultType::Scalar Scalar;
+    Matrix<typename MatrixType::Scalar,3,1> cofactors_col0;
+    cofactors_col0.coeffRef(0) =  cofactor_3x3<MatrixType,0,0>(matrix);
+    cofactors_col0.coeffRef(1) =  cofactor_3x3<MatrixType,1,0>(matrix);
+    cofactors_col0.coeffRef(2) =  cofactor_3x3<MatrixType,2,0>(matrix);
+    const Scalar det = (cofactors_col0.cwiseProduct(matrix.col(0))).sum();
+    const Scalar invdet = Scalar(1) / det;
+    compute_inverse_size3_helper(matrix, invdet, cofactors_col0, result);
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 3>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    typedef typename ResultType::Scalar Scalar;
+    Matrix<Scalar,3,1> cofactors_col0;
+    cofactors_col0.coeffRef(0) =  cofactor_3x3<MatrixType,0,0>(matrix);
+    cofactors_col0.coeffRef(1) =  cofactor_3x3<MatrixType,1,0>(matrix);
+    cofactors_col0.coeffRef(2) =  cofactor_3x3<MatrixType,2,0>(matrix);
+    determinant = (cofactors_col0.cwiseProduct(matrix.col(0))).sum();
+    invertible = Eigen::numext::abs(determinant) > absDeterminantThreshold;
+    if(!invertible) return;
+    const Scalar invdet = Scalar(1) / determinant;
+    compute_inverse_size3_helper(matrix, invdet, cofactors_col0, inverse);
+  }
+};
+
+/****************************
+*** Size 4 implementation ***
+****************************/
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC 
+inline const typename Derived::Scalar general_det3_helper
+(const MatrixBase<Derived>& matrix, int i1, int i2, int i3, int j1, int j2, int j3)
+{
+  return matrix.coeff(i1,j1)
+         * (matrix.coeff(i2,j2) * matrix.coeff(i3,j3) - matrix.coeff(i2,j3) * matrix.coeff(i3,j2));
+}
+
+template<typename MatrixType, int i, int j>
+EIGEN_DEVICE_FUNC 
+inline typename MatrixType::Scalar cofactor_4x4(const MatrixType& matrix)
+{
+  enum {
+    i1 = (i+1) % 4,
+    i2 = (i+2) % 4,
+    i3 = (i+3) % 4,
+    j1 = (j+1) % 4,
+    j2 = (j+2) % 4,
+    j3 = (j+3) % 4
+  };
+  return general_det3_helper(matrix, i1, i2, i3, j1, j2, j3)
+       + general_det3_helper(matrix, i2, i3, i1, j1, j2, j3)
+       + general_det3_helper(matrix, i3, i1, i2, j1, j2, j3);
+}
+
+template<int Arch, typename Scalar, typename MatrixType, typename ResultType>
+struct compute_inverse_size4
+{
+  EIGEN_DEVICE_FUNC
+  static void run(const MatrixType& matrix, ResultType& result)
+  {
+    result.coeffRef(0,0) =  cofactor_4x4<MatrixType,0,0>(matrix);
+    result.coeffRef(1,0) = -cofactor_4x4<MatrixType,0,1>(matrix);
+    result.coeffRef(2,0) =  cofactor_4x4<MatrixType,0,2>(matrix);
+    result.coeffRef(3,0) = -cofactor_4x4<MatrixType,0,3>(matrix);
+    result.coeffRef(0,2) =  cofactor_4x4<MatrixType,2,0>(matrix);
+    result.coeffRef(1,2) = -cofactor_4x4<MatrixType,2,1>(matrix);
+    result.coeffRef(2,2) =  cofactor_4x4<MatrixType,2,2>(matrix);
+    result.coeffRef(3,2) = -cofactor_4x4<MatrixType,2,3>(matrix);
+    result.coeffRef(0,1) = -cofactor_4x4<MatrixType,1,0>(matrix);
+    result.coeffRef(1,1) =  cofactor_4x4<MatrixType,1,1>(matrix);
+    result.coeffRef(2,1) = -cofactor_4x4<MatrixType,1,2>(matrix);
+    result.coeffRef(3,1) =  cofactor_4x4<MatrixType,1,3>(matrix);
+    result.coeffRef(0,3) = -cofactor_4x4<MatrixType,3,0>(matrix);
+    result.coeffRef(1,3) =  cofactor_4x4<MatrixType,3,1>(matrix);
+    result.coeffRef(2,3) = -cofactor_4x4<MatrixType,3,2>(matrix);
+    result.coeffRef(3,3) =  cofactor_4x4<MatrixType,3,3>(matrix);
+    result /= (matrix.col(0).cwiseProduct(result.row(0).transpose())).sum();
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 4>
+ : compute_inverse_size4<Architecture::Target, typename MatrixType::Scalar,
+                            MatrixType, ResultType>
+{
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 4>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    using std::abs;
+    determinant = matrix.determinant();
+    invertible = abs(determinant) > absDeterminantThreshold;
+    if(invertible && extract_data(matrix) != extract_data(inverse)) {
+      compute_inverse<MatrixType, ResultType>::run(matrix, inverse);
+    }
+    else if(invertible) {
+      MatrixType matrix_t = matrix;
+      compute_inverse<MatrixType, ResultType>::run(matrix_t, inverse);
+    }
+  }
+};
+
+/*************************
+*** MatrixBase methods ***
+*************************/
+
+} // end namespace internal
+
+namespace internal {
+
+// Specialization for "dense = dense_xpr.inverse()"
+template<typename DstXprType, typename XprType>
+struct Assignment<DstXprType, Inverse<XprType>, internal::assign_op<typename DstXprType::Scalar,typename XprType::Scalar>, Dense2Dense>
+{
+  typedef Inverse<XprType> SrcXprType;
+  EIGEN_DEVICE_FUNC
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename XprType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    
+    const int Size = EIGEN_PLAIN_ENUM_MIN(XprType::ColsAtCompileTime,DstXprType::ColsAtCompileTime);
+    EIGEN_ONLY_USED_FOR_DEBUG(Size);
+    eigen_assert(( (Size<=1) || (Size>4) || (extract_data(src.nestedExpression())!=extract_data(dst)))
+              && "Aliasing problem detected in inverse(), you need to do inverse().eval() here.");
+
+    typedef typename internal::nested_eval<XprType,XprType::ColsAtCompileTime>::type  ActualXprType;
+    typedef typename internal::remove_all<ActualXprType>::type                        ActualXprTypeCleanded;
+    
+    ActualXprType actual_xpr(src.nestedExpression());
+    
+    compute_inverse<ActualXprTypeCleanded, DstXprType>::run(actual_xpr, dst);
+  }
+};
+
+  
+} // end namespace internal
+
+/** \lu_module
+  *
+  * \returns the matrix inverse of this matrix.
+  *
+  * For small fixed sizes up to 4x4, this method uses cofactors.
+  * In the general case, this method uses class PartialPivLU.
+  *
+  * \note This matrix must be invertible, otherwise the result is undefined. If you need an
+  * invertibility check, do the following:
+  * \li for fixed sizes up to 4x4, use computeInverseAndDetWithCheck().
+  * \li for the general case, use class FullPivLU.
+  *
+  * Example: \include MatrixBase_inverse.cpp
+  * Output: \verbinclude MatrixBase_inverse.out
+  *
+  * \sa computeInverseAndDetWithCheck()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+inline const Inverse<Derived> MatrixBase<Derived>::inverse() const
+{
+  EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsInteger,THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES)
+  eigen_assert(rows() == cols());
+  return Inverse<Derived>(derived());
+}
+
+/** \lu_module
+  *
+  * Computation of matrix inverse and determinant, with invertibility check.
+  *
+  * This is only for fixed-size square matrices of size up to 4x4.
+  *
+  * Notice that it will trigger a copy of input matrix when trying to do the inverse in place.
+  *
+  * \param inverse Reference to the matrix in which to store the inverse.
+  * \param determinant Reference to the variable in which to store the determinant.
+  * \param invertible Reference to the bool variable in which to store whether the matrix is invertible.
+  * \param absDeterminantThreshold Optional parameter controlling the invertibility check.
+  *                                The matrix will be declared invertible if the absolute value of its
+  *                                determinant is greater than this threshold.
+  *
+  * Example: \include MatrixBase_computeInverseAndDetWithCheck.cpp
+  * Output: \verbinclude MatrixBase_computeInverseAndDetWithCheck.out
+  *
+  * \sa inverse(), computeInverseWithCheck()
+  */
+template<typename Derived>
+template<typename ResultType>
+inline void MatrixBase<Derived>::computeInverseAndDetWithCheck(
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible,
+    const RealScalar& absDeterminantThreshold
+  ) const
+{
+  // i'd love to put some static assertions there, but SFINAE means that they have no effect...
+  eigen_assert(rows() == cols());
+  // for 2x2, it's worth giving a chance to avoid evaluating.
+  // for larger sizes, evaluating has negligible cost and limits code size.
+  typedef typename internal::conditional<
+    RowsAtCompileTime == 2,
+    typename internal::remove_all<typename internal::nested_eval<Derived, 2>::type>::type,
+    PlainObject
+  >::type MatrixType;
+  internal::compute_inverse_and_det_with_check<MatrixType, ResultType>::run
+    (derived(), absDeterminantThreshold, inverse, determinant, invertible);
+}
+
+/** \lu_module
+  *
+  * Computation of matrix inverse, with invertibility check.
+  *
+  * This is only for fixed-size square matrices of size up to 4x4.
+  *
+  * Notice that it will trigger a copy of input matrix when trying to do the inverse in place.
+  *
+  * \param inverse Reference to the matrix in which to store the inverse.
+  * \param invertible Reference to the bool variable in which to store whether the matrix is invertible.
+  * \param absDeterminantThreshold Optional parameter controlling the invertibility check.
+  *                                The matrix will be declared invertible if the absolute value of its
+  *                                determinant is greater than this threshold.
+  *
+  * Example: \include MatrixBase_computeInverseWithCheck.cpp
+  * Output: \verbinclude MatrixBase_computeInverseWithCheck.out
+  *
+  * \sa inverse(), computeInverseAndDetWithCheck()
+  */
+template<typename Derived>
+template<typename ResultType>
+inline void MatrixBase<Derived>::computeInverseWithCheck(
+    ResultType& inverse,
+    bool& invertible,
+    const RealScalar& absDeterminantThreshold
+  ) const
+{
+  Scalar determinant;
+  // i'd love to put some static assertions there, but SFINAE means that they have no effect...
+  eigen_assert(rows() == cols());
+  computeInverseAndDetWithCheck(inverse,determinant,invertible,absDeterminantThreshold);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_INVERSE_IMPL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/LU/PartialPivLU.h b/C++/yolo_bytetrack/include/Eigen/src/LU/PartialPivLU.h
new file mode 100644
index 00000000..34aed724
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/LU/PartialPivLU.h
@@ -0,0 +1,624 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARTIALLU_H
+#define EIGEN_PARTIALLU_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _MatrixType> struct traits<PartialPivLU<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  typedef traits<_MatrixType> BaseTraits;
+  enum {
+    Flags = BaseTraits::Flags & RowMajorBit,
+    CoeffReadCost = Dynamic
+  };
+};
+
+template<typename T,typename Derived>
+struct enable_if_ref;
+// {
+//   typedef Derived type;
+// };
+
+template<typename T,typename Derived>
+struct enable_if_ref<Ref<T>,Derived> {
+  typedef Derived type;
+};
+
+} // end namespace internal
+
+/** \ingroup LU_Module
+  *
+  * \class PartialPivLU
+  *
+  * \brief LU decomposition of a matrix with partial pivoting, and related features
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the LU decomposition
+  *
+  * This class represents a LU decomposition of a \b square \b invertible matrix, with partial pivoting: the matrix A
+  * is decomposed as A = PLU where L is unit-lower-triangular, U is upper-triangular, and P
+  * is a permutation matrix.
+  *
+  * Typically, partial pivoting LU decomposition is only considered numerically stable for square invertible
+  * matrices. Thus LAPACK's dgesv and dgesvx require the matrix to be square and invertible. The present class
+  * does the same. It will assert that the matrix is square, but it won't (actually it can't) check that the
+  * matrix is invertible: it is your task to check that you only use this decomposition on invertible matrices.
+  *
+  * The guaranteed safe alternative, working for all matrices, is the full pivoting LU decomposition, provided
+  * by class FullPivLU.
+  *
+  * This is \b not a rank-revealing LU decomposition. Many features are intentionally absent from this class,
+  * such as rank computation. If you need these features, use class FullPivLU.
+  *
+  * This LU decomposition is suitable to invert invertible matrices. It is what MatrixBase::inverse() uses
+  * in the general case.
+  * On the other hand, it is \b not suitable to determine whether a given matrix is invertible.
+  *
+  * The data of the LU decomposition can be directly accessed through the methods matrixLU(), permutationP().
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * \sa MatrixBase::partialPivLu(), MatrixBase::determinant(), MatrixBase::inverse(), MatrixBase::computeInverse(), class FullPivLU
+  */
+template<typename _MatrixType> class PartialPivLU
+  : public SolverBase<PartialPivLU<_MatrixType> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<PartialPivLU> Base;
+    friend class SolverBase<PartialPivLU>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(PartialPivLU)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType;
+    typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via PartialPivLU::compute(const MatrixType&).
+      */
+    PartialPivLU();
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa PartialPivLU()
+      */
+    explicit PartialPivLU(Index size);
+
+    /** Constructor.
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *
+      * \warning The matrix should have full rank (e.g. if it's square, it should be invertible).
+      * If you need to deal with non-full rank, use class FullPivLU instead.
+      */
+    template<typename InputType>
+    explicit PartialPivLU(const EigenBase<InputType>& matrix);
+
+    /** Constructor for \link InplaceDecomposition inplace decomposition \endlink
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *
+      * \warning The matrix should have full rank (e.g. if it's square, it should be invertible).
+      * If you need to deal with non-full rank, use class FullPivLU instead.
+      */
+    template<typename InputType>
+    explicit PartialPivLU(EigenBase<InputType>& matrix);
+
+    template<typename InputType>
+    PartialPivLU& compute(const EigenBase<InputType>& matrix) {
+      m_lu = matrix.derived();
+      compute();
+      return *this;
+    }
+
+    /** \returns the LU decomposition matrix: the upper-triangular part is U, the
+      * unit-lower-triangular part is L (at least for square matrices; in the non-square
+      * case, special care is needed, see the documentation of class FullPivLU).
+      *
+      * \sa matrixL(), matrixU()
+      */
+    inline const MatrixType& matrixLU() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return m_lu;
+    }
+
+    /** \returns the permutation matrix P.
+      */
+    inline const PermutationType& permutationP() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return m_p;
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** This method returns the solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the LU decomposition.
+      *
+      * \param b the right-hand-side of the equation to solve. Can be a vector or a matrix,
+      *          the only requirement in order for the equation to make sense is that
+      *          b.rows()==A.rows(), where A is the matrix of which *this is the LU decomposition.
+      *
+      * \returns the solution.
+      *
+      * Example: \include PartialPivLU_solve.cpp
+      * Output: \verbinclude PartialPivLU_solve.out
+      *
+      * Since this PartialPivLU class assumes anyway that the matrix A is invertible, the solution
+      * theoretically exists and is unique regardless of b.
+      *
+      * \sa TriangularView::solve(), inverse(), computeInverse()
+      */
+    template<typename Rhs>
+    inline const Solve<PartialPivLU, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of which \c *this is
+        the LU decomposition.
+      */
+    inline RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    /** \returns the inverse of the matrix of which *this is the LU decomposition.
+      *
+      * \warning The matrix being decomposed here is assumed to be invertible. If you need to check for
+      *          invertibility, use class FullPivLU instead.
+      *
+      * \sa MatrixBase::inverse(), LU::inverse()
+      */
+    inline const Inverse<PartialPivLU> inverse() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return Inverse<PartialPivLU>(*this);
+    }
+
+    /** \returns the determinant of the matrix of which
+      * *this is the LU decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the LU decomposition has already been computed.
+      *
+      * \note For fixed-size matrices of size up to 4, MatrixBase::determinant() offers
+      *       optimized paths.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      *
+      * \sa MatrixBase::determinant()
+      */
+    Scalar determinant() const;
+
+    MatrixType reconstructedMatrix() const;
+
+    EIGEN_CONSTEXPR inline Index rows() const EIGEN_NOEXCEPT { return m_lu.rows(); }
+    EIGEN_CONSTEXPR inline Index cols() const EIGEN_NOEXCEPT { return m_lu.cols(); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    void _solve_impl(const RhsType &rhs, DstType &dst) const {
+     /* The decomposition PA = LU can be rewritten as A = P^{-1} L U.
+      * So we proceed as follows:
+      * Step 1: compute c = Pb.
+      * Step 2: replace c by the solution x to Lx = c.
+      * Step 3: replace c by the solution x to Ux = c.
+      */
+
+      // Step 1
+      dst = permutationP() * rhs;
+
+      // Step 2
+      m_lu.template triangularView<UnitLower>().solveInPlace(dst);
+
+      // Step 3
+      m_lu.template triangularView<Upper>().solveInPlace(dst);
+    }
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const {
+     /* The decomposition PA = LU can be rewritten as A^T = U^T L^T P.
+      * So we proceed as follows:
+      * Step 1: compute c as the solution to L^T c = b
+      * Step 2: replace c by the solution x to U^T x = c.
+      * Step 3: update  c = P^-1 c.
+      */
+
+      eigen_assert(rhs.rows() == m_lu.cols());
+
+      // Step 1
+      dst = m_lu.template triangularView<Upper>().transpose()
+                .template conjugateIf<Conjugate>().solve(rhs);
+      // Step 2
+      m_lu.template triangularView<UnitLower>().transpose()
+          .template conjugateIf<Conjugate>().solveInPlace(dst);
+      // Step 3
+      dst = permutationP().transpose() * dst;
+    }
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void compute();
+
+    MatrixType m_lu;
+    PermutationType m_p;
+    TranspositionType m_rowsTranspositions;
+    RealScalar m_l1_norm;
+    signed char m_det_p;
+    bool m_isInitialized;
+};
+
+template<typename MatrixType>
+PartialPivLU<MatrixType>::PartialPivLU()
+  : m_lu(),
+    m_p(),
+    m_rowsTranspositions(),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+}
+
+template<typename MatrixType>
+PartialPivLU<MatrixType>::PartialPivLU(Index size)
+  : m_lu(size, size),
+    m_p(size),
+    m_rowsTranspositions(size),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+}
+
+template<typename MatrixType>
+template<typename InputType>
+PartialPivLU<MatrixType>::PartialPivLU(const EigenBase<InputType>& matrix)
+  : m_lu(matrix.rows(),matrix.cols()),
+    m_p(matrix.rows()),
+    m_rowsTranspositions(matrix.rows()),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+  compute(matrix.derived());
+}
+
+template<typename MatrixType>
+template<typename InputType>
+PartialPivLU<MatrixType>::PartialPivLU(EigenBase<InputType>& matrix)
+  : m_lu(matrix.derived()),
+    m_p(matrix.rows()),
+    m_rowsTranspositions(matrix.rows()),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+  compute();
+}
+
+namespace internal {
+
+/** \internal This is the blocked version of fullpivlu_unblocked() */
+template<typename Scalar, int StorageOrder, typename PivIndex, int SizeAtCompileTime=Dynamic>
+struct partial_lu_impl
+{
+  static const int UnBlockedBound = 16;
+  static const bool UnBlockedAtCompileTime = SizeAtCompileTime!=Dynamic && SizeAtCompileTime<=UnBlockedBound;
+  static const int ActualSizeAtCompileTime = UnBlockedAtCompileTime ? SizeAtCompileTime : Dynamic;
+  // Remaining rows and columns at compile-time:
+  static const int RRows = SizeAtCompileTime==2 ? 1 : Dynamic;
+  static const int RCols = SizeAtCompileTime==2 ? 1 : Dynamic;
+  typedef Matrix<Scalar, ActualSizeAtCompileTime, ActualSizeAtCompileTime, StorageOrder> MatrixType;
+  typedef Ref<MatrixType> MatrixTypeRef;
+  typedef Ref<Matrix<Scalar, Dynamic, Dynamic, StorageOrder> > BlockType;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  /** \internal performs the LU decomposition in-place of the matrix \a lu
+    * using an unblocked algorithm.
+    *
+    * In addition, this function returns the row transpositions in the
+    * vector \a row_transpositions which must have a size equal to the number
+    * of columns of the matrix \a lu, and an integer \a nb_transpositions
+    * which returns the actual number of transpositions.
+    *
+    * \returns The index of the first pivot which is exactly zero if any, or a negative number otherwise.
+    */
+  static Index unblocked_lu(MatrixTypeRef& lu, PivIndex* row_transpositions, PivIndex& nb_transpositions)
+  {
+    typedef scalar_score_coeff_op<Scalar> Scoring;
+    typedef typename Scoring::result_type Score;
+    const Index rows = lu.rows();
+    const Index cols = lu.cols();
+    const Index size = (std::min)(rows,cols);
+    // For small compile-time matrices it is worth processing the last row separately:
+    //  speedup: +100% for 2x2, +10% for others.
+    const Index endk = UnBlockedAtCompileTime ? size-1 : size;
+    nb_transpositions = 0;
+    Index first_zero_pivot = -1;
+    for(Index k = 0; k < endk; ++k)
+    {
+      int rrows = internal::convert_index<int>(rows-k-1);
+      int rcols = internal::convert_index<int>(cols-k-1);
+
+      Index row_of_biggest_in_col;
+      Score biggest_in_corner
+        = lu.col(k).tail(rows-k).unaryExpr(Scoring()).maxCoeff(&row_of_biggest_in_col);
+      row_of_biggest_in_col += k;
+
+      row_transpositions[k] = PivIndex(row_of_biggest_in_col);
+
+      if(biggest_in_corner != Score(0))
+      {
+        if(k != row_of_biggest_in_col)
+        {
+          lu.row(k).swap(lu.row(row_of_biggest_in_col));
+          ++nb_transpositions;
+        }
+
+        lu.col(k).tail(fix<RRows>(rrows)) /= lu.coeff(k,k);
+      }
+      else if(first_zero_pivot==-1)
+      {
+        // the pivot is exactly zero, we record the index of the first pivot which is exactly 0,
+        // and continue the factorization such we still have A = PLU
+        first_zero_pivot = k;
+      }
+
+      if(k<rows-1)
+        lu.bottomRightCorner(fix<RRows>(rrows),fix<RCols>(rcols)).noalias() -= lu.col(k).tail(fix<RRows>(rrows)) * lu.row(k).tail(fix<RCols>(rcols));
+    }
+
+    // special handling of the last entry
+    if(UnBlockedAtCompileTime)
+    {
+      Index k = endk;
+      row_transpositions[k] = PivIndex(k);
+      if (Scoring()(lu(k, k)) == Score(0) && first_zero_pivot == -1)
+        first_zero_pivot = k;
+    }
+
+    return first_zero_pivot;
+  }
+
+  /** \internal performs the LU decomposition in-place of the matrix represented
+    * by the variables \a rows, \a cols, \a lu_data, and \a lu_stride using a
+    * recursive, blocked algorithm.
+    *
+    * In addition, this function returns the row transpositions in the
+    * vector \a row_transpositions which must have a size equal to the number
+    * of columns of the matrix \a lu, and an integer \a nb_transpositions
+    * which returns the actual number of transpositions.
+    *
+    * \returns The index of the first pivot which is exactly zero if any, or a negative number otherwise.
+    *
+    * \note This very low level interface using pointers, etc. is to:
+    *   1 - reduce the number of instantiations to the strict minimum
+    *   2 - avoid infinite recursion of the instantiations with Block<Block<Block<...> > >
+    */
+  static Index blocked_lu(Index rows, Index cols, Scalar* lu_data, Index luStride, PivIndex* row_transpositions, PivIndex& nb_transpositions, Index maxBlockSize=256)
+  {
+    MatrixTypeRef lu = MatrixType::Map(lu_data,rows, cols, OuterStride<>(luStride));
+
+    const Index size = (std::min)(rows,cols);
+
+    // if the matrix is too small, no blocking:
+    if(UnBlockedAtCompileTime || size<=UnBlockedBound)
+    {
+      return unblocked_lu(lu, row_transpositions, nb_transpositions);
+    }
+
+    // automatically adjust the number of subdivisions to the size
+    // of the matrix so that there is enough sub blocks:
+    Index blockSize;
+    {
+      blockSize = size/8;
+      blockSize = (blockSize/16)*16;
+      blockSize = (std::min)((std::max)(blockSize,Index(8)), maxBlockSize);
+    }
+
+    nb_transpositions = 0;
+    Index first_zero_pivot = -1;
+    for(Index k = 0; k < size; k+=blockSize)
+    {
+      Index bs = (std::min)(size-k,blockSize); // actual size of the block
+      Index trows = rows - k - bs; // trailing rows
+      Index tsize = size - k - bs; // trailing size
+
+      // partition the matrix:
+      //                          A00 | A01 | A02
+      // lu  = A_0 | A_1 | A_2 =  A10 | A11 | A12
+      //                          A20 | A21 | A22
+      BlockType A_0 = lu.block(0,0,rows,k);
+      BlockType A_2 = lu.block(0,k+bs,rows,tsize);
+      BlockType A11 = lu.block(k,k,bs,bs);
+      BlockType A12 = lu.block(k,k+bs,bs,tsize);
+      BlockType A21 = lu.block(k+bs,k,trows,bs);
+      BlockType A22 = lu.block(k+bs,k+bs,trows,tsize);
+
+      PivIndex nb_transpositions_in_panel;
+      // recursively call the blocked LU algorithm on [A11^T A21^T]^T
+      // with a very small blocking size:
+      Index ret = blocked_lu(trows+bs, bs, &lu.coeffRef(k,k), luStride,
+                   row_transpositions+k, nb_transpositions_in_panel, 16);
+      if(ret>=0 && first_zero_pivot==-1)
+        first_zero_pivot = k+ret;
+
+      nb_transpositions += nb_transpositions_in_panel;
+      // update permutations and apply them to A_0
+      for(Index i=k; i<k+bs; ++i)
+      {
+        Index piv = (row_transpositions[i] += internal::convert_index<PivIndex>(k));
+        A_0.row(i).swap(A_0.row(piv));
+      }
+
+      if(trows)
+      {
+        // apply permutations to A_2
+        for(Index i=k;i<k+bs; ++i)
+          A_2.row(i).swap(A_2.row(row_transpositions[i]));
+
+        // A12 = A11^-1 A12
+        A11.template triangularView<UnitLower>().solveInPlace(A12);
+
+        A22.noalias() -= A21 * A12;
+      }
+    }
+    return first_zero_pivot;
+  }
+};
+
+/** \internal performs the LU decomposition with partial pivoting in-place.
+  */
+template<typename MatrixType, typename TranspositionType>
+void partial_lu_inplace(MatrixType& lu, TranspositionType& row_transpositions, typename TranspositionType::StorageIndex& nb_transpositions)
+{
+  // Special-case of zero matrix.
+  if (lu.rows() == 0 || lu.cols() == 0) {
+    nb_transpositions = 0;
+    return;
+  }
+  eigen_assert(lu.cols() == row_transpositions.size());
+  eigen_assert(row_transpositions.size() < 2 || (&row_transpositions.coeffRef(1)-&row_transpositions.coeffRef(0)) == 1);
+
+  partial_lu_impl
+    < typename MatrixType::Scalar, MatrixType::Flags&RowMajorBit?RowMajor:ColMajor,
+      typename TranspositionType::StorageIndex,
+      EIGEN_SIZE_MIN_PREFER_FIXED(MatrixType::RowsAtCompileTime,MatrixType::ColsAtCompileTime)>
+    ::blocked_lu(lu.rows(), lu.cols(), &lu.coeffRef(0,0), lu.outerStride(), &row_transpositions.coeffRef(0), nb_transpositions);
+}
+
+} // end namespace internal
+
+template<typename MatrixType>
+void PartialPivLU<MatrixType>::compute()
+{
+  check_template_parameters();
+
+  // the row permutation is stored as int indices, so just to be sure:
+  eigen_assert(m_lu.rows()<NumTraits<int>::highest());
+
+  if(m_lu.cols()>0)
+    m_l1_norm = m_lu.cwiseAbs().colwise().sum().maxCoeff();
+  else
+    m_l1_norm = RealScalar(0);
+
+  eigen_assert(m_lu.rows() == m_lu.cols() && "PartialPivLU is only for square (and moreover invertible) matrices");
+  const Index size = m_lu.rows();
+
+  m_rowsTranspositions.resize(size);
+
+  typename TranspositionType::StorageIndex nb_transpositions;
+  internal::partial_lu_inplace(m_lu, m_rowsTranspositions, nb_transpositions);
+  m_det_p = (nb_transpositions%2) ? -1 : 1;
+
+  m_p = m_rowsTranspositions;
+
+  m_isInitialized = true;
+}
+
+template<typename MatrixType>
+typename PartialPivLU<MatrixType>::Scalar PartialPivLU<MatrixType>::determinant() const
+{
+  eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+  return Scalar(m_det_p) * m_lu.diagonal().prod();
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: P^{-1} L U.
+ * This function is provided for debug purpose. */
+template<typename MatrixType>
+MatrixType PartialPivLU<MatrixType>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  // LU
+  MatrixType res = m_lu.template triangularView<UnitLower>().toDenseMatrix()
+                 * m_lu.template triangularView<Upper>();
+
+  // P^{-1}(LU)
+  res = m_p.inverse() * res;
+
+  return res;
+}
+
+/***** Implementation details *****************************************************/
+
+namespace internal {
+
+/***** Implementation of inverse() *****************************************************/
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<PartialPivLU<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename PartialPivLU<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef PartialPivLU<MatrixType> LuType;
+  typedef Inverse<LuType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename LuType::Scalar> &)
+  {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+} // end namespace internal
+
+/******** MatrixBase methods *******/
+
+/** \lu_module
+  *
+  * \return the partial-pivoting LU decomposition of \c *this.
+  *
+  * \sa class PartialPivLU
+  */
+template<typename Derived>
+inline const PartialPivLU<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::partialPivLu() const
+{
+  return PartialPivLU<PlainObject>(eval());
+}
+
+/** \lu_module
+  *
+  * Synonym of partialPivLu().
+  *
+  * \return the partial-pivoting LU decomposition of \c *this.
+  *
+  * \sa class PartialPivLU
+  */
+template<typename Derived>
+inline const PartialPivLU<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::lu() const
+{
+  return PartialPivLU<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIALLU_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/LU/PartialPivLU_LAPACKE.h b/C++/yolo_bytetrack/include/Eigen/src/LU/PartialPivLU_LAPACKE.h
new file mode 100644
index 00000000..755168a9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/LU/PartialPivLU_LAPACKE.h
@@ -0,0 +1,83 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *     LU decomposition with partial pivoting based on LAPACKE_?getrf function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_PARTIALLU_LAPACK_H
+#define EIGEN_PARTIALLU_LAPACK_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_LU_PARTPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX) \
+template<int StorageOrder> \
+struct partial_lu_impl<EIGTYPE, StorageOrder, lapack_int> \
+{ \
+  /* \internal performs the LU decomposition in-place of the matrix represented */ \
+  static lapack_int blocked_lu(Index rows, Index cols, EIGTYPE* lu_data, Index luStride, lapack_int* row_transpositions, lapack_int& nb_transpositions, lapack_int maxBlockSize=256) \
+  { \
+    EIGEN_UNUSED_VARIABLE(maxBlockSize);\
+    lapack_int matrix_order, first_zero_pivot; \
+    lapack_int m, n, lda, *ipiv, info; \
+    EIGTYPE* a; \
+/* Set up parameters for ?getrf */ \
+    matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
+    lda = convert_index<lapack_int>(luStride); \
+    a = lu_data; \
+    ipiv = row_transpositions; \
+    m = convert_index<lapack_int>(rows); \
+    n = convert_index<lapack_int>(cols); \
+    nb_transpositions = 0; \
+\
+    info = LAPACKE_##LAPACKE_PREFIX##getrf( matrix_order, m, n, (LAPACKE_TYPE*)a, lda, ipiv ); \
+\
+    for(int i=0;i<m;i++) { ipiv[i]--; if (ipiv[i]!=i) nb_transpositions++; } \
+\
+    eigen_assert(info >= 0); \
+/* something should be done with nb_transpositions */ \
+\
+    first_zero_pivot = info; \
+    return first_zero_pivot; \
+  } \
+};
+
+EIGEN_LAPACKE_LU_PARTPIV(double, double, d)
+EIGEN_LAPACKE_LU_PARTPIV(float, float, s)
+EIGEN_LAPACKE_LU_PARTPIV(dcomplex, lapack_complex_double, z)
+EIGEN_LAPACKE_LU_PARTPIV(scomplex, lapack_complex_float,  c)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIALLU_LAPACK_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/LU/arch/InverseSize4.h b/C++/yolo_bytetrack/include/Eigen/src/LU/arch/InverseSize4.h
new file mode 100644
index 00000000..a232ffc0
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/LU/arch/InverseSize4.h
@@ -0,0 +1,351 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2001 Intel Corporation
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// The algorithm below is a reimplementation of former \src\LU\Inverse_SSE.h using PacketMath.
+// inv(M) = M#/|M|, where inv(M), M# and |M| denote the inverse of M,
+// adjugate of M and determinant of M respectively. M# is computed block-wise
+// using specific formulae. For proof, see:
+// https://lxjk.github.io/2017/09/03/Fast-4x4-Matrix-Inverse-with-SSE-SIMD-Explained.html
+// Variable names are adopted from \src\LU\Inverse_SSE.h.
+//
+// The SSE code for the 4x4 float and double matrix inverse in former (deprecated) \src\LU\Inverse_SSE.h
+// comes from the following Intel's library:
+// http://software.intel.com/en-us/articles/optimized-matrix-library-for-use-with-the-intel-pentiumr-4-processors-sse2-instructions/
+//
+// Here is the respective copyright and license statement:
+//
+//   Copyright (c) 2001 Intel Corporation.
+//
+// Permition is granted to use, copy, distribute and prepare derivative works
+// of this library for any purpose and without fee, provided, that the above
+// copyright notice and this statement appear in all copies.
+// Intel makes no representations about the suitability of this software for
+// any purpose, and specifically disclaims all warranties.
+// See LEGAL.TXT for all the legal information.
+//
+// TODO: Unify implementations of different data types (i.e. float and double).
+#ifndef EIGEN_INVERSE_SIZE_4_H
+#define EIGEN_INVERSE_SIZE_4_H
+
+namespace Eigen
+{
+namespace internal
+{
+template <typename MatrixType, typename ResultType>
+struct compute_inverse_size4<Architecture::Target, float, MatrixType, ResultType>
+{
+  enum
+  {
+    MatrixAlignment = traits<MatrixType>::Alignment,
+    ResultAlignment = traits<ResultType>::Alignment,
+    StorageOrdersMatch = (MatrixType::Flags & RowMajorBit) == (ResultType::Flags & RowMajorBit)
+  };
+  typedef typename conditional<(MatrixType::Flags & LinearAccessBit), MatrixType const &, typename MatrixType::PlainObject>::type ActualMatrixType;
+
+  static void run(const MatrixType &mat, ResultType &result)
+  {
+    ActualMatrixType matrix(mat);
+
+    const float* data = matrix.data();
+    const Index stride = matrix.innerStride();
+    Packet4f _L1 = ploadt<Packet4f,MatrixAlignment>(data);
+    Packet4f _L2 = ploadt<Packet4f,MatrixAlignment>(data + stride*4);
+    Packet4f _L3 = ploadt<Packet4f,MatrixAlignment>(data + stride*8);
+    Packet4f _L4 = ploadt<Packet4f,MatrixAlignment>(data + stride*12);
+
+    // Four 2x2 sub-matrices of the input matrix
+    // input = [[A, B],
+    //          [C, D]]
+    Packet4f A, B, C, D;
+
+    if (!StorageOrdersMatch)
+    {
+      A = vec4f_unpacklo(_L1, _L2);
+      B = vec4f_unpacklo(_L3, _L4);
+      C = vec4f_unpackhi(_L1, _L2);
+      D = vec4f_unpackhi(_L3, _L4);
+    }
+    else
+    {
+      A = vec4f_movelh(_L1, _L2);
+      B = vec4f_movehl(_L2, _L1);
+      C = vec4f_movelh(_L3, _L4);
+      D = vec4f_movehl(_L4, _L3);
+    }
+
+    Packet4f AB, DC;
+
+    // AB = A# * B, where A# denotes the adjugate of A, and * denotes matrix product.
+    AB = pmul(vec4f_swizzle2(A, A, 3, 3, 0, 0), B);
+    AB = psub(AB, pmul(vec4f_swizzle2(A, A, 1, 1, 2, 2), vec4f_swizzle2(B, B, 2, 3, 0, 1)));
+
+    // DC = D#*C
+    DC = pmul(vec4f_swizzle2(D, D, 3, 3, 0, 0), C);
+    DC = psub(DC, pmul(vec4f_swizzle2(D, D, 1, 1, 2, 2), vec4f_swizzle2(C, C, 2, 3, 0, 1)));
+
+    // determinants of the sub-matrices
+    Packet4f dA, dB, dC, dD;
+
+    dA = pmul(vec4f_swizzle2(A, A, 3, 3, 1, 1), A);
+    dA = psub(dA, vec4f_movehl(dA, dA));
+
+    dB = pmul(vec4f_swizzle2(B, B, 3, 3, 1, 1), B);
+    dB = psub(dB, vec4f_movehl(dB, dB));
+
+    dC = pmul(vec4f_swizzle2(C, C, 3, 3, 1, 1), C);
+    dC = psub(dC, vec4f_movehl(dC, dC));
+
+    dD = pmul(vec4f_swizzle2(D, D, 3, 3, 1, 1), D);
+    dD = psub(dD, vec4f_movehl(dD, dD));
+
+    Packet4f d, d1, d2;
+
+    d = pmul(vec4f_swizzle2(DC, DC, 0, 2, 1, 3), AB);
+    d = padd(d, vec4f_movehl(d, d));
+    d = padd(d, vec4f_swizzle2(d, d, 1, 0, 0, 0));
+    d1 = pmul(dA, dD);
+    d2 = pmul(dB, dC);
+
+    // determinant of the input matrix, det = |A||D| + |B||C| - trace(A#*B*D#*C)
+    Packet4f det = vec4f_duplane(psub(padd(d1, d2), d), 0);
+
+    // reciprocal of the determinant of the input matrix, rd = 1/det
+    Packet4f rd = pdiv(pset1<Packet4f>(1.0f), det);
+
+    // Four sub-matrices of the inverse
+    Packet4f iA, iB, iC, iD;
+
+    // iD = D*|A| - C*A#*B
+    iD = pmul(vec4f_swizzle2(C, C, 0, 0, 2, 2), vec4f_movelh(AB, AB));
+    iD = padd(iD, pmul(vec4f_swizzle2(C, C, 1, 1, 3, 3), vec4f_movehl(AB, AB)));
+    iD = psub(pmul(D, vec4f_duplane(dA, 0)), iD);
+
+    // iA = A*|D| - B*D#*C
+    iA = pmul(vec4f_swizzle2(B, B, 0, 0, 2, 2), vec4f_movelh(DC, DC));
+    iA = padd(iA, pmul(vec4f_swizzle2(B, B, 1, 1, 3, 3), vec4f_movehl(DC, DC)));
+    iA = psub(pmul(A, vec4f_duplane(dD, 0)), iA);
+
+    // iB = C*|B| - D * (A#B)# = C*|B| - D*B#*A
+    iB = pmul(D, vec4f_swizzle2(AB, AB, 3, 0, 3, 0));
+    iB = psub(iB, pmul(vec4f_swizzle2(D, D, 1, 0, 3, 2), vec4f_swizzle2(AB, AB, 2, 1, 2, 1)));
+    iB = psub(pmul(C, vec4f_duplane(dB, 0)), iB);
+
+    // iC = B*|C| - A * (D#C)# = B*|C| - A*C#*D
+    iC = pmul(A, vec4f_swizzle2(DC, DC, 3, 0, 3, 0));
+    iC = psub(iC, pmul(vec4f_swizzle2(A, A, 1, 0, 3, 2), vec4f_swizzle2(DC, DC, 2, 1, 2, 1)));
+    iC = psub(pmul(B, vec4f_duplane(dC, 0)), iC);
+
+    const float sign_mask[4] = {0.0f, numext::bit_cast<float>(0x80000000u), numext::bit_cast<float>(0x80000000u), 0.0f};
+    const Packet4f p4f_sign_PNNP = ploadu<Packet4f>(sign_mask);
+    rd = pxor(rd, p4f_sign_PNNP);
+    iA = pmul(iA, rd);
+    iB = pmul(iB, rd);
+    iC = pmul(iC, rd);
+    iD = pmul(iD, rd);
+
+    Index res_stride = result.outerStride();
+    float *res = result.data();
+
+    pstoret<float, Packet4f, ResultAlignment>(res + 0, vec4f_swizzle2(iA, iB, 3, 1, 3, 1));
+    pstoret<float, Packet4f, ResultAlignment>(res + res_stride, vec4f_swizzle2(iA, iB, 2, 0, 2, 0));
+    pstoret<float, Packet4f, ResultAlignment>(res + 2 * res_stride, vec4f_swizzle2(iC, iD, 3, 1, 3, 1));
+    pstoret<float, Packet4f, ResultAlignment>(res + 3 * res_stride, vec4f_swizzle2(iC, iD, 2, 0, 2, 0));
+  }
+};
+
+#if !(defined EIGEN_VECTORIZE_NEON && !(EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG))
+// same algorithm as above, except that each operand is split into
+// halves for two registers to hold.
+template <typename MatrixType, typename ResultType>
+struct compute_inverse_size4<Architecture::Target, double, MatrixType, ResultType>
+{
+  enum
+  {
+    MatrixAlignment = traits<MatrixType>::Alignment,
+    ResultAlignment = traits<ResultType>::Alignment,
+    StorageOrdersMatch = (MatrixType::Flags & RowMajorBit) == (ResultType::Flags & RowMajorBit)
+  };
+  typedef typename conditional<(MatrixType::Flags & LinearAccessBit),
+                               MatrixType const &,
+                               typename MatrixType::PlainObject>::type
+      ActualMatrixType;
+
+  static void run(const MatrixType &mat, ResultType &result)
+  {
+    ActualMatrixType matrix(mat);
+
+    // Four 2x2 sub-matrices of the input matrix, each is further divided into upper and lower
+    // row e.g. A1, upper row of A, A2, lower row of A
+    // input = [[A, B],  =  [[[A1, [B1,
+    //          [C, D]]        A2], B2]],
+    //                       [[C1, [D1,
+    //                         C2], D2]]]
+
+    Packet2d A1, A2, B1, B2, C1, C2, D1, D2;
+
+    const double* data = matrix.data();
+    const Index stride = matrix.innerStride();
+    if (StorageOrdersMatch)
+    {
+      A1 = ploadt<Packet2d,MatrixAlignment>(data + stride*0);
+      B1 = ploadt<Packet2d,MatrixAlignment>(data + stride*2);
+      A2 = ploadt<Packet2d,MatrixAlignment>(data + stride*4);
+      B2 = ploadt<Packet2d,MatrixAlignment>(data + stride*6);
+      C1 = ploadt<Packet2d,MatrixAlignment>(data + stride*8);
+      D1 = ploadt<Packet2d,MatrixAlignment>(data + stride*10);
+      C2 = ploadt<Packet2d,MatrixAlignment>(data + stride*12);
+      D2 = ploadt<Packet2d,MatrixAlignment>(data + stride*14);
+    }
+    else
+    {
+      Packet2d temp;
+      A1 = ploadt<Packet2d,MatrixAlignment>(data + stride*0);
+      C1 = ploadt<Packet2d,MatrixAlignment>(data + stride*2);
+      A2 = ploadt<Packet2d,MatrixAlignment>(data + stride*4);
+      C2 = ploadt<Packet2d,MatrixAlignment>(data + stride*6);
+      temp = A1;
+      A1 = vec2d_unpacklo(A1, A2);
+      A2 = vec2d_unpackhi(temp, A2);
+
+      temp = C1;
+      C1 = vec2d_unpacklo(C1, C2);
+      C2 = vec2d_unpackhi(temp, C2);
+
+      B1 = ploadt<Packet2d,MatrixAlignment>(data + stride*8);
+      D1 = ploadt<Packet2d,MatrixAlignment>(data + stride*10);
+      B2 = ploadt<Packet2d,MatrixAlignment>(data + stride*12);
+      D2 = ploadt<Packet2d,MatrixAlignment>(data + stride*14);
+
+      temp = B1;
+      B1 = vec2d_unpacklo(B1, B2);
+      B2 = vec2d_unpackhi(temp, B2);
+
+      temp = D1;
+      D1 = vec2d_unpacklo(D1, D2);
+      D2 = vec2d_unpackhi(temp, D2);
+    }
+
+    // determinants of the sub-matrices
+    Packet2d dA, dB, dC, dD;
+
+    dA = vec2d_swizzle2(A2, A2, 1);
+    dA = pmul(A1, dA);
+    dA = psub(dA, vec2d_duplane(dA, 1));
+
+    dB = vec2d_swizzle2(B2, B2, 1);
+    dB = pmul(B1, dB);
+    dB = psub(dB, vec2d_duplane(dB, 1));
+
+    dC = vec2d_swizzle2(C2, C2, 1);
+    dC = pmul(C1, dC);
+    dC = psub(dC, vec2d_duplane(dC, 1));
+
+    dD = vec2d_swizzle2(D2, D2, 1);
+    dD = pmul(D1, dD);
+    dD = psub(dD, vec2d_duplane(dD, 1));
+
+    Packet2d DC1, DC2, AB1, AB2;
+
+    // AB = A# * B, where A# denotes the adjugate of A, and * denotes matrix product.
+    AB1 = pmul(B1, vec2d_duplane(A2, 1));
+    AB2 = pmul(B2, vec2d_duplane(A1, 0));
+    AB1 = psub(AB1, pmul(B2, vec2d_duplane(A1, 1)));
+    AB2 = psub(AB2, pmul(B1, vec2d_duplane(A2, 0)));
+
+    // DC = D#*C
+    DC1 = pmul(C1, vec2d_duplane(D2, 1));
+    DC2 = pmul(C2, vec2d_duplane(D1, 0));
+    DC1 = psub(DC1, pmul(C2, vec2d_duplane(D1, 1)));
+    DC2 = psub(DC2, pmul(C1, vec2d_duplane(D2, 0)));
+
+    Packet2d d1, d2;
+
+    // determinant of the input matrix, det = |A||D| + |B||C| - trace(A#*B*D#*C)
+    Packet2d det;
+
+    // reciprocal of the determinant of the input matrix, rd = 1/det
+    Packet2d rd;
+
+    d1 = pmul(AB1, vec2d_swizzle2(DC1, DC2, 0));
+    d2 = pmul(AB2, vec2d_swizzle2(DC1, DC2, 3));
+    rd = padd(d1, d2);
+    rd = padd(rd, vec2d_duplane(rd, 1));
+
+    d1 = pmul(dA, dD);
+    d2 = pmul(dB, dC);
+
+    det = padd(d1, d2);
+    det = psub(det, rd);
+    det = vec2d_duplane(det, 0);
+    rd = pdiv(pset1<Packet2d>(1.0), det);
+
+    // rows of four sub-matrices of the inverse
+    Packet2d iA1, iA2, iB1, iB2, iC1, iC2, iD1, iD2;
+
+    // iD = D*|A| - C*A#*B
+    iD1 = pmul(AB1, vec2d_duplane(C1, 0));
+    iD2 = pmul(AB1, vec2d_duplane(C2, 0));
+    iD1 = padd(iD1, pmul(AB2, vec2d_duplane(C1, 1)));
+    iD2 = padd(iD2, pmul(AB2, vec2d_duplane(C2, 1)));
+    dA = vec2d_duplane(dA, 0);
+    iD1 = psub(pmul(D1, dA), iD1);
+    iD2 = psub(pmul(D2, dA), iD2);
+
+    // iA = A*|D| - B*D#*C
+    iA1 = pmul(DC1, vec2d_duplane(B1, 0));
+    iA2 = pmul(DC1, vec2d_duplane(B2, 0));
+    iA1 = padd(iA1, pmul(DC2, vec2d_duplane(B1, 1)));
+    iA2 = padd(iA2, pmul(DC2, vec2d_duplane(B2, 1)));
+    dD = vec2d_duplane(dD, 0);
+    iA1 = psub(pmul(A1, dD), iA1);
+    iA2 = psub(pmul(A2, dD), iA2);
+
+    // iB = C*|B| - D * (A#B)# = C*|B| - D*B#*A
+    iB1 = pmul(D1, vec2d_swizzle2(AB2, AB1, 1));
+    iB2 = pmul(D2, vec2d_swizzle2(AB2, AB1, 1));
+    iB1 = psub(iB1, pmul(vec2d_swizzle2(D1, D1, 1), vec2d_swizzle2(AB2, AB1, 2)));
+    iB2 = psub(iB2, pmul(vec2d_swizzle2(D2, D2, 1), vec2d_swizzle2(AB2, AB1, 2)));
+    dB = vec2d_duplane(dB, 0);
+    iB1 = psub(pmul(C1, dB), iB1);
+    iB2 = psub(pmul(C2, dB), iB2);
+
+    // iC = B*|C| - A * (D#C)# = B*|C| - A*C#*D
+    iC1 = pmul(A1, vec2d_swizzle2(DC2, DC1, 1));
+    iC2 = pmul(A2, vec2d_swizzle2(DC2, DC1, 1));
+    iC1 = psub(iC1, pmul(vec2d_swizzle2(A1, A1, 1), vec2d_swizzle2(DC2, DC1, 2)));
+    iC2 = psub(iC2, pmul(vec2d_swizzle2(A2, A2, 1), vec2d_swizzle2(DC2, DC1, 2)));
+    dC = vec2d_duplane(dC, 0);
+    iC1 = psub(pmul(B1, dC), iC1);
+    iC2 = psub(pmul(B2, dC), iC2);
+
+    const double sign_mask1[2] = {0.0, numext::bit_cast<double>(0x8000000000000000ull)};
+    const double sign_mask2[2] = {numext::bit_cast<double>(0x8000000000000000ull), 0.0};
+    const Packet2d sign_PN = ploadu<Packet2d>(sign_mask1);
+    const Packet2d sign_NP = ploadu<Packet2d>(sign_mask2);
+    d1 = pxor(rd, sign_PN);
+    d2 = pxor(rd, sign_NP);
+
+    Index res_stride = result.outerStride();
+    double *res = result.data();
+    pstoret<double, Packet2d, ResultAlignment>(res + 0, pmul(vec2d_swizzle2(iA2, iA1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res + res_stride, pmul(vec2d_swizzle2(iA2, iA1, 0), d2));
+    pstoret<double, Packet2d, ResultAlignment>(res + 2, pmul(vec2d_swizzle2(iB2, iB1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res + res_stride + 2, pmul(vec2d_swizzle2(iB2, iB1, 0), d2));
+    pstoret<double, Packet2d, ResultAlignment>(res + 2 * res_stride, pmul(vec2d_swizzle2(iC2, iC1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res + 3 * res_stride, pmul(vec2d_swizzle2(iC2, iC1, 0), d2));
+    pstoret<double, Packet2d, ResultAlignment>(res + 2 * res_stride + 2, pmul(vec2d_swizzle2(iD2, iD1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res + 3 * res_stride + 2, pmul(vec2d_swizzle2(iD2, iD1, 0), d2));
+  }
+};
+#endif
+} // namespace internal
+} // namespace Eigen
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/MetisSupport/MetisSupport.h b/C++/yolo_bytetrack/include/Eigen/src/MetisSupport/MetisSupport.h
new file mode 100644
index 00000000..4c15304a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/MetisSupport/MetisSupport.h
@@ -0,0 +1,137 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#ifndef METIS_SUPPORT_H
+#define METIS_SUPPORT_H
+
+namespace Eigen {
+/**
+ * Get the fill-reducing ordering from the METIS package
+ * 
+ * If A is the original matrix and Ap is the permuted matrix, 
+ * the fill-reducing permutation is defined as follows :
+ * Row (column) i of A is the matperm(i) row (column) of Ap. 
+ * WARNING: As computed by METIS, this corresponds to the vector iperm (instead of perm)
+ */
+template <typename StorageIndex>
+class MetisOrdering
+{
+public:
+  typedef PermutationMatrix<Dynamic,Dynamic,StorageIndex> PermutationType;
+  typedef Matrix<StorageIndex,Dynamic,1> IndexVector; 
+  
+  template <typename MatrixType>
+  void get_symmetrized_graph(const MatrixType& A)
+  {
+    Index m = A.cols(); 
+    eigen_assert((A.rows() == A.cols()) && "ONLY FOR SQUARED MATRICES");
+    // Get the transpose of the input matrix 
+    MatrixType At = A.transpose(); 
+    // Get the number of nonzeros elements in each row/col of At+A
+    Index TotNz = 0; 
+    IndexVector visited(m); 
+    visited.setConstant(-1); 
+    for (StorageIndex j = 0; j < m; j++)
+    {
+      // Compute the union structure of of A(j,:) and At(j,:)
+      visited(j) = j; // Do not include the diagonal element
+      // Get the nonzeros in row/column j of A
+      for (typename MatrixType::InnerIterator it(A, j); it; ++it)
+      {
+        Index idx = it.index(); // Get the row index (for column major) or column index (for row major)
+        if (visited(idx) != j ) 
+        {
+          visited(idx) = j; 
+          ++TotNz; 
+        }
+      }
+      //Get the nonzeros in row/column j of At
+      for (typename MatrixType::InnerIterator it(At, j); it; ++it)
+      {
+        Index idx = it.index(); 
+        if(visited(idx) != j)
+        {
+          visited(idx) = j; 
+          ++TotNz; 
+        }
+      }
+    }
+    // Reserve place for A + At
+    m_indexPtr.resize(m+1);
+    m_innerIndices.resize(TotNz); 
+
+    // Now compute the real adjacency list of each column/row 
+    visited.setConstant(-1); 
+    StorageIndex CurNz = 0; 
+    for (StorageIndex j = 0; j < m; j++)
+    {
+      m_indexPtr(j) = CurNz; 
+      
+      visited(j) = j; // Do not include the diagonal element
+      // Add the pattern of row/column j of A to A+At
+      for (typename MatrixType::InnerIterator it(A,j); it; ++it)
+      {
+        StorageIndex idx = it.index(); // Get the row index (for column major) or column index (for row major)
+        if (visited(idx) != j ) 
+        {
+          visited(idx) = j; 
+          m_innerIndices(CurNz) = idx; 
+          CurNz++; 
+        }
+      }
+      //Add the pattern of row/column j of At to A+At
+      for (typename MatrixType::InnerIterator it(At, j); it; ++it)
+      {
+        StorageIndex idx = it.index(); 
+        if(visited(idx) != j)
+        {
+          visited(idx) = j; 
+          m_innerIndices(CurNz) = idx; 
+          ++CurNz; 
+        }
+      }
+    }
+    m_indexPtr(m) = CurNz;    
+  }
+  
+  template <typename MatrixType>
+  void operator() (const MatrixType& A, PermutationType& matperm)
+  {
+     StorageIndex m = internal::convert_index<StorageIndex>(A.cols()); // must be StorageIndex, because it is passed by address to METIS
+     IndexVector perm(m),iperm(m); 
+    // First, symmetrize the matrix graph. 
+     get_symmetrized_graph(A); 
+     int output_error;
+     
+     // Call the fill-reducing routine from METIS 
+     output_error = METIS_NodeND(&m, m_indexPtr.data(), m_innerIndices.data(), NULL, NULL, perm.data(), iperm.data());
+     
+    if(output_error != METIS_OK) 
+    {
+      //FIXME The ordering interface should define a class of possible errors 
+     std::cerr << "ERROR WHILE CALLING THE METIS PACKAGE \n"; 
+     return; 
+    }
+    
+    // Get the fill-reducing permutation 
+    //NOTE:  If Ap is the permuted matrix then perm and iperm vectors are defined as follows 
+    // Row (column) i of Ap is the perm(i) row(column) of A, and row (column) i of A is the iperm(i) row(column) of Ap
+    
+     matperm.resize(m);
+     for (int j = 0; j < m; j++)
+       matperm.indices()(iperm(j)) = j;
+   
+  }
+  
+  protected:
+    IndexVector m_indexPtr; // Pointer to the adjacenccy list of each row/column
+    IndexVector m_innerIndices; // Adjacency list 
+};
+
+}// end namespace eigen 
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/OrderingMethods/Amd.h b/C++/yolo_bytetrack/include/Eigen/src/OrderingMethods/Amd.h
new file mode 100644
index 00000000..7ca3f33b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/OrderingMethods/Amd.h
@@ -0,0 +1,435 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*
+NOTE: this routine has been adapted from the CSparse library:
+
+Copyright (c) 2006, Timothy A. Davis.
+http://www.suitesparse.com
+
+The author of CSparse, Timothy A. Davis., has executed a license with Google LLC
+to permit distribution of this code and derivative works as part of Eigen under
+the Mozilla Public License v. 2.0, as stated at the top of this file.
+*/
+
+#ifndef EIGEN_SPARSE_AMD_H
+#define EIGEN_SPARSE_AMD_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<typename T> inline T amd_flip(const T& i) { return -i-2; }
+template<typename T> inline T amd_unflip(const T& i) { return i<0 ? amd_flip(i) : i; }
+template<typename T0, typename T1> inline bool amd_marked(const T0* w, const T1& j) { return w[j]<0; }
+template<typename T0, typename T1> inline void amd_mark(const T0* w, const T1& j) { return w[j] = amd_flip(w[j]); }
+
+/* clear w */
+template<typename StorageIndex>
+static StorageIndex cs_wclear (StorageIndex mark, StorageIndex lemax, StorageIndex *w, StorageIndex n)
+{
+  StorageIndex k;
+  if(mark < 2 || (mark + lemax < 0))
+  {
+    for(k = 0; k < n; k++)
+      if(w[k] != 0)
+        w[k] = 1;
+    mark = 2;
+  }
+  return (mark);     /* at this point, w[0..n-1] < mark holds */
+}
+
+/* depth-first search and postorder of a tree rooted at node j */
+template<typename StorageIndex>
+StorageIndex cs_tdfs(StorageIndex j, StorageIndex k, StorageIndex *head, const StorageIndex *next, StorageIndex *post, StorageIndex *stack)
+{
+  StorageIndex i, p, top = 0;
+  if(!head || !next || !post || !stack) return (-1);    /* check inputs */
+  stack[0] = j;                 /* place j on the stack */
+  while (top >= 0)                /* while (stack is not empty) */
+  {
+    p = stack[top];           /* p = top of stack */
+    i = head[p];              /* i = youngest child of p */
+    if(i == -1)
+    {
+      top--;                 /* p has no unordered children left */
+      post[k++] = p;        /* node p is the kth postordered node */
+    }
+    else
+    {
+      head[p] = next[i];   /* remove i from children of p */
+      stack[++top] = i;     /* start dfs on child node i */
+    }
+  }
+  return k;
+}
+
+
+/** \internal
+  * \ingroup OrderingMethods_Module 
+  * Approximate minimum degree ordering algorithm.
+  *
+  * \param[in] C the input selfadjoint matrix stored in compressed column major format.
+  * \param[out] perm the permutation P reducing the fill-in of the input matrix \a C
+  *
+  * Note that the input matrix \a C must be complete, that is both the upper and lower parts have to be stored, as well as the diagonal entries.
+  * On exit the values of C are destroyed */
+template<typename Scalar, typename StorageIndex>
+void minimum_degree_ordering(SparseMatrix<Scalar,ColMajor,StorageIndex>& C, PermutationMatrix<Dynamic,Dynamic,StorageIndex>& perm)
+{
+  using std::sqrt;
+  
+  StorageIndex d, dk, dext, lemax = 0, e, elenk, eln, i, j, k, k1,
+                k2, k3, jlast, ln, dense, nzmax, mindeg = 0, nvi, nvj, nvk, mark, wnvi,
+                ok, nel = 0, p, p1, p2, p3, p4, pj, pk, pk1, pk2, pn, q, t, h;
+  
+  StorageIndex n = StorageIndex(C.cols());
+  dense = std::max<StorageIndex> (16, StorageIndex(10 * sqrt(double(n))));   /* find dense threshold */
+  dense = (std::min)(n-2, dense);
+  
+  StorageIndex cnz = StorageIndex(C.nonZeros());
+  perm.resize(n+1);
+  t = cnz + cnz/5 + 2*n;                 /* add elbow room to C */
+  C.resizeNonZeros(t);
+  
+  // get workspace
+  ei_declare_aligned_stack_constructed_variable(StorageIndex,W,8*(n+1),0);
+  StorageIndex* len     = W;
+  StorageIndex* nv      = W +   (n+1);
+  StorageIndex* next    = W + 2*(n+1);
+  StorageIndex* head    = W + 3*(n+1);
+  StorageIndex* elen    = W + 4*(n+1);
+  StorageIndex* degree  = W + 5*(n+1);
+  StorageIndex* w       = W + 6*(n+1);
+  StorageIndex* hhead   = W + 7*(n+1);
+  StorageIndex* last    = perm.indices().data();                              /* use P as workspace for last */
+  
+  /* --- Initialize quotient graph ---------------------------------------- */
+  StorageIndex* Cp = C.outerIndexPtr();
+  StorageIndex* Ci = C.innerIndexPtr();
+  for(k = 0; k < n; k++)
+    len[k] = Cp[k+1] - Cp[k];
+  len[n] = 0;
+  nzmax = t;
+  
+  for(i = 0; i <= n; i++)
+  {
+    head[i]   = -1;                     // degree list i is empty
+    last[i]   = -1;
+    next[i]   = -1;
+    hhead[i]  = -1;                     // hash list i is empty 
+    nv[i]     = 1;                      // node i is just one node
+    w[i]      = 1;                      // node i is alive
+    elen[i]   = 0;                      // Ek of node i is empty
+    degree[i] = len[i];                 // degree of node i
+  }
+  mark = internal::cs_wclear<StorageIndex>(0, 0, w, n);         /* clear w */
+  
+  /* --- Initialize degree lists ------------------------------------------ */
+  for(i = 0; i < n; i++)
+  {
+    bool has_diag = false;
+    for(p = Cp[i]; p<Cp[i+1]; ++p)
+      if(Ci[p]==i)
+      {
+        has_diag = true;
+        break;
+      }
+   
+    d = degree[i];
+    if(d == 1 && has_diag)           /* node i is empty */
+    {
+      elen[i] = -2;                 /* element i is dead */
+      nel++;
+      Cp[i] = -1;                   /* i is a root of assembly tree */
+      w[i] = 0;
+    }
+    else if(d > dense || !has_diag)  /* node i is dense or has no structural diagonal element */
+    {
+      nv[i] = 0;                    /* absorb i into element n */
+      elen[i] = -1;                 /* node i is dead */
+      nel++;
+      Cp[i] = amd_flip (n);
+      nv[n]++;
+    }
+    else
+    {
+      if(head[d] != -1) last[head[d]] = i;
+      next[i] = head[d];           /* put node i in degree list d */
+      head[d] = i;
+    }
+  }
+  
+  elen[n] = -2;                         /* n is a dead element */
+  Cp[n] = -1;                           /* n is a root of assembly tree */
+  w[n] = 0;                             /* n is a dead element */
+  
+  while (nel < n)                         /* while (selecting pivots) do */
+  {
+    /* --- Select node of minimum approximate degree -------------------- */
+    for(k = -1; mindeg < n && (k = head[mindeg]) == -1; mindeg++) {}
+    if(next[k] != -1) last[next[k]] = -1;
+    head[mindeg] = next[k];          /* remove k from degree list */
+    elenk = elen[k];                  /* elenk = |Ek| */
+    nvk = nv[k];                      /* # of nodes k represents */
+    nel += nvk;                        /* nv[k] nodes of A eliminated */
+    
+    /* --- Garbage collection ------------------------------------------- */
+    if(elenk > 0 && cnz + mindeg >= nzmax)
+    {
+      for(j = 0; j < n; j++)
+      {
+        if((p = Cp[j]) >= 0)      /* j is a live node or element */
+        {
+          Cp[j] = Ci[p];          /* save first entry of object */
+          Ci[p] = amd_flip (j);    /* first entry is now amd_flip(j) */
+        }
+      }
+      for(q = 0, p = 0; p < cnz; ) /* scan all of memory */
+      {
+        if((j = amd_flip (Ci[p++])) >= 0)  /* found object j */
+        {
+          Ci[q] = Cp[j];       /* restore first entry of object */
+          Cp[j] = q++;          /* new pointer to object j */
+          for(k3 = 0; k3 < len[j]-1; k3++) Ci[q++] = Ci[p++];
+        }
+      }
+      cnz = q;                       /* Ci[cnz...nzmax-1] now free */
+    }
+    
+    /* --- Construct new element ---------------------------------------- */
+    dk = 0;
+    nv[k] = -nvk;                     /* flag k as in Lk */
+    p = Cp[k];
+    pk1 = (elenk == 0) ? p : cnz;      /* do in place if elen[k] == 0 */
+    pk2 = pk1;
+    for(k1 = 1; k1 <= elenk + 1; k1++)
+    {
+      if(k1 > elenk)
+      {
+        e = k;                     /* search the nodes in k */
+        pj = p;                    /* list of nodes starts at Ci[pj]*/
+        ln = len[k] - elenk;      /* length of list of nodes in k */
+      }
+      else
+      {
+        e = Ci[p++];              /* search the nodes in e */
+        pj = Cp[e];
+        ln = len[e];              /* length of list of nodes in e */
+      }
+      for(k2 = 1; k2 <= ln; k2++)
+      {
+        i = Ci[pj++];
+        if((nvi = nv[i]) <= 0) continue; /* node i dead, or seen */
+        dk += nvi;                 /* degree[Lk] += size of node i */
+        nv[i] = -nvi;             /* negate nv[i] to denote i in Lk*/
+        Ci[pk2++] = i;            /* place i in Lk */
+        if(next[i] != -1) last[next[i]] = last[i];
+        if(last[i] != -1)         /* remove i from degree list */
+        {
+          next[last[i]] = next[i];
+        }
+        else
+        {
+          head[degree[i]] = next[i];
+        }
+      }
+      if(e != k)
+      {
+        Cp[e] = amd_flip (k);      /* absorb e into k */
+        w[e] = 0;                 /* e is now a dead element */
+      }
+    }
+    if(elenk != 0) cnz = pk2;         /* Ci[cnz...nzmax] is free */
+    degree[k] = dk;                   /* external degree of k - |Lk\i| */
+    Cp[k] = pk1;                      /* element k is in Ci[pk1..pk2-1] */
+    len[k] = pk2 - pk1;
+    elen[k] = -2;                     /* k is now an element */
+    
+    /* --- Find set differences ----------------------------------------- */
+    mark = internal::cs_wclear<StorageIndex>(mark, lemax, w, n);  /* clear w if necessary */
+    for(pk = pk1; pk < pk2; pk++)    /* scan 1: find |Le\Lk| */
+    {
+      i = Ci[pk];
+      if((eln = elen[i]) <= 0) continue;/* skip if elen[i] empty */
+      nvi = -nv[i];                      /* nv[i] was negated */
+      wnvi = mark - nvi;
+      for(p = Cp[i]; p <= Cp[i] + eln - 1; p++)  /* scan Ei */
+      {
+        e = Ci[p];
+        if(w[e] >= mark)
+        {
+          w[e] -= nvi;          /* decrement |Le\Lk| */
+        }
+        else if(w[e] != 0)        /* ensure e is a live element */
+        {
+          w[e] = degree[e] + wnvi; /* 1st time e seen in scan 1 */
+        }
+      }
+    }
+    
+    /* --- Degree update ------------------------------------------------ */
+    for(pk = pk1; pk < pk2; pk++)    /* scan2: degree update */
+    {
+      i = Ci[pk];                   /* consider node i in Lk */
+      p1 = Cp[i];
+      p2 = p1 + elen[i] - 1;
+      pn = p1;
+      for(h = 0, d = 0, p = p1; p <= p2; p++)    /* scan Ei */
+      {
+        e = Ci[p];
+        if(w[e] != 0)             /* e is an unabsorbed element */
+        {
+          dext = w[e] - mark;   /* dext = |Le\Lk| */
+          if(dext > 0)
+          {
+            d += dext;         /* sum up the set differences */
+            Ci[pn++] = e;     /* keep e in Ei */
+            h += e;            /* compute the hash of node i */
+          }
+          else
+          {
+            Cp[e] = amd_flip (k);  /* aggressive absorb. e->k */
+            w[e] = 0;             /* e is a dead element */
+          }
+        }
+      }
+      elen[i] = pn - p1 + 1;        /* elen[i] = |Ei| */
+      p3 = pn;
+      p4 = p1 + len[i];
+      for(p = p2 + 1; p < p4; p++) /* prune edges in Ai */
+      {
+        j = Ci[p];
+        if((nvj = nv[j]) <= 0) continue; /* node j dead or in Lk */
+        d += nvj;                  /* degree(i) += |j| */
+        Ci[pn++] = j;             /* place j in node list of i */
+        h += j;                    /* compute hash for node i */
+      }
+      if(d == 0)                     /* check for mass elimination */
+      {
+        Cp[i] = amd_flip (k);      /* absorb i into k */
+        nvi = -nv[i];
+        dk -= nvi;                 /* |Lk| -= |i| */
+        nvk += nvi;                /* |k| += nv[i] */
+        nel += nvi;
+        nv[i] = 0;
+        elen[i] = -1;             /* node i is dead */
+      }
+      else
+      {
+        degree[i] = std::min<StorageIndex> (degree[i], d);   /* update degree(i) */
+        Ci[pn] = Ci[p3];         /* move first node to end */
+        Ci[p3] = Ci[p1];         /* move 1st el. to end of Ei */
+        Ci[p1] = k;               /* add k as 1st element in of Ei */
+        len[i] = pn - p1 + 1;     /* new len of adj. list of node i */
+        h %= n;                    /* finalize hash of i */
+        next[i] = hhead[h];      /* place i in hash bucket */
+        hhead[h] = i;
+        last[i] = h;      /* save hash of i in last[i] */
+      }
+    }                                   /* scan2 is done */
+    degree[k] = dk;                   /* finalize |Lk| */
+    lemax = std::max<StorageIndex>(lemax, dk);
+    mark = internal::cs_wclear<StorageIndex>(mark+lemax, lemax, w, n);    /* clear w */
+    
+    /* --- Supernode detection ------------------------------------------ */
+    for(pk = pk1; pk < pk2; pk++)
+    {
+      i = Ci[pk];
+      if(nv[i] >= 0) continue;         /* skip if i is dead */
+      h = last[i];                      /* scan hash bucket of node i */
+      i = hhead[h];
+      hhead[h] = -1;                    /* hash bucket will be empty */
+      for(; i != -1 && next[i] != -1; i = next[i], mark++)
+      {
+        ln = len[i];
+        eln = elen[i];
+        for(p = Cp[i]+1; p <= Cp[i] + ln-1; p++) w[Ci[p]] = mark;
+        jlast = i;
+        for(j = next[i]; j != -1; ) /* compare i with all j */
+        {
+          ok = (len[j] == ln) && (elen[j] == eln);
+          for(p = Cp[j] + 1; ok && p <= Cp[j] + ln - 1; p++)
+          {
+            if(w[Ci[p]] != mark) ok = 0;    /* compare i and j*/
+          }
+          if(ok)                     /* i and j are identical */
+          {
+            Cp[j] = amd_flip (i);  /* absorb j into i */
+            nv[i] += nv[j];
+            nv[j] = 0;
+            elen[j] = -1;         /* node j is dead */
+            j = next[j];          /* delete j from hash bucket */
+            next[jlast] = j;
+          }
+          else
+          {
+            jlast = j;             /* j and i are different */
+            j = next[j];
+          }
+        }
+      }
+    }
+    
+    /* --- Finalize new element------------------------------------------ */
+    for(p = pk1, pk = pk1; pk < pk2; pk++)   /* finalize Lk */
+    {
+      i = Ci[pk];
+      if((nvi = -nv[i]) <= 0) continue;/* skip if i is dead */
+      nv[i] = nvi;                      /* restore nv[i] */
+      d = degree[i] + dk - nvi;         /* compute external degree(i) */
+      d = std::min<StorageIndex> (d, n - nel - nvi);
+      if(head[d] != -1) last[head[d]] = i;
+      next[i] = head[d];               /* put i back in degree list */
+      last[i] = -1;
+      head[d] = i;
+      mindeg = std::min<StorageIndex> (mindeg, d);       /* find new minimum degree */
+      degree[i] = d;
+      Ci[p++] = i;                      /* place i in Lk */
+    }
+    nv[k] = nvk;                      /* # nodes absorbed into k */
+    if((len[k] = p-pk1) == 0)         /* length of adj list of element k*/
+    {
+      Cp[k] = -1;                   /* k is a root of the tree */
+      w[k] = 0;                     /* k is now a dead element */
+    }
+    if(elenk != 0) cnz = p;           /* free unused space in Lk */
+  }
+  
+  /* --- Postordering ----------------------------------------------------- */
+  for(i = 0; i < n; i++) Cp[i] = amd_flip (Cp[i]);/* fix assembly tree */
+  for(j = 0; j <= n; j++) head[j] = -1;
+  for(j = n; j >= 0; j--)              /* place unordered nodes in lists */
+  {
+    if(nv[j] > 0) continue;          /* skip if j is an element */
+    next[j] = head[Cp[j]];          /* place j in list of its parent */
+    head[Cp[j]] = j;
+  }
+  for(e = n; e >= 0; e--)              /* place elements in lists */
+  {
+    if(nv[e] <= 0) continue;         /* skip unless e is an element */
+    if(Cp[e] != -1)
+    {
+      next[e] = head[Cp[e]];      /* place e in list of its parent */
+      head[Cp[e]] = e;
+    }
+  }
+  for(k = 0, i = 0; i <= n; i++)       /* postorder the assembly tree */
+  {
+    if(Cp[i] == -1) k = internal::cs_tdfs<StorageIndex>(i, k, head, next, perm.indices().data(), w);
+  }
+  
+  perm.indices().conservativeResize(n);
+}
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_AMD_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/OrderingMethods/Eigen_Colamd.h b/C++/yolo_bytetrack/include/Eigen/src/OrderingMethods/Eigen_Colamd.h
new file mode 100644
index 00000000..8e339a70
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/OrderingMethods/Eigen_Colamd.h
@@ -0,0 +1,1863 @@
+// // This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Desire Nuentsa Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is modified from the colamd/symamd library. The copyright is below
+
+//   The authors of the code itself are Stefan I. Larimore and Timothy A.
+//   Davis (davis@cise.ufl.edu), University of Florida.  The algorithm was
+//   developed in collaboration with John Gilbert, Xerox PARC, and Esmond
+//   Ng, Oak Ridge National Laboratory.
+//
+//     Date:
+//
+//   September 8, 2003.  Version 2.3.
+//
+//     Acknowledgements:
+//
+//   This work was supported by the National Science Foundation, under
+//   grants DMS-9504974 and DMS-9803599.
+//
+//     Notice:
+//
+//   Copyright (c) 1998-2003 by the University of Florida.
+//   All Rights Reserved.
+//
+//   THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+//   EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+//
+//   Permission is hereby granted to use, copy, modify, and/or distribute
+//   this program, provided that the Copyright, this License, and the
+//   Availability of the original version is retained on all copies and made
+//   accessible to the end-user of any code or package that includes COLAMD
+//   or any modified version of COLAMD.
+//
+//     Availability:
+//
+//   The colamd/symamd library is available at
+//
+//       http://www.suitesparse.com
+
+
+#ifndef EIGEN_COLAMD_H
+#define EIGEN_COLAMD_H
+
+namespace internal {
+
+namespace Colamd {
+
+/* Ensure that debugging is turned off: */
+#ifndef COLAMD_NDEBUG
+#define COLAMD_NDEBUG
+#endif /* NDEBUG */
+
+
+/* ========================================================================== */
+/* === Knob and statistics definitions ====================================== */
+/* ========================================================================== */
+
+/* size of the knobs [ ] array.  Only knobs [0..1] are currently used. */
+const int NKnobs = 20;
+
+/* number of output statistics.  Only stats [0..6] are currently used. */
+const int NStats = 20;
+
+/* Indices into knobs and stats array. */
+enum KnobsStatsIndex {
+  /* knobs [0] and stats [0]: dense row knob and output statistic. */
+  DenseRow = 0,
+
+  /* knobs [1] and stats [1]: dense column knob and output statistic. */
+  DenseCol = 1,
+
+  /* stats [2]: memory defragmentation count output statistic */
+  DefragCount = 2,
+
+  /* stats [3]: colamd status:  zero OK, > 0 warning or notice, < 0 error */
+  Status = 3,
+
+  /* stats [4..6]: error info, or info on jumbled columns */
+  Info1 = 4,
+  Info2 = 5,
+  Info3 = 6
+};
+
+/* error codes returned in stats [3]: */
+enum Status {
+  Ok = 0,
+  OkButJumbled = 1,
+  ErrorANotPresent = -1,
+  ErrorPNotPresent = -2,
+  ErrorNrowNegative = -3,
+  ErrorNcolNegative = -4,
+  ErrorNnzNegative = -5,
+  ErrorP0Nonzero = -6,
+  ErrorATooSmall = -7,
+  ErrorColLengthNegative = -8,
+  ErrorRowIndexOutOfBounds = -9,
+  ErrorOutOfMemory = -10,
+  ErrorInternalError = -999
+};
+/* ========================================================================== */
+/* === Definitions ========================================================== */
+/* ========================================================================== */
+
+template <typename IndexType>
+IndexType ones_complement(const IndexType r) {
+  return (-(r)-1);
+}
+
+/* -------------------------------------------------------------------------- */
+const int Empty = -1;
+
+/* Row and column status */
+enum RowColumnStatus {
+  Alive = 0,
+  Dead = -1
+};
+
+/* Column status */
+enum ColumnStatus {
+  DeadPrincipal = -1,
+  DeadNonPrincipal = -2
+};
+
+/* ========================================================================== */
+/* === Colamd reporting mechanism =========================================== */
+/* ========================================================================== */
+
+// == Row and Column structures ==
+template <typename IndexType>
+struct ColStructure
+{
+  IndexType start ;   /* index for A of first row in this column, or Dead */
+  /* if column is dead */
+  IndexType length ;  /* number of rows in this column */
+  union
+  {
+    IndexType thickness ; /* number of original columns represented by this */
+    /* col, if the column is alive */
+    IndexType parent ;  /* parent in parent tree super-column structure, if */
+    /* the column is dead */
+  } shared1 ;
+  union
+  {
+    IndexType score ; /* the score used to maintain heap, if col is alive */
+    IndexType order ; /* pivot ordering of this column, if col is dead */
+  } shared2 ;
+  union
+  {
+    IndexType headhash ;  /* head of a hash bucket, if col is at the head of */
+    /* a degree list */
+    IndexType hash ;  /* hash value, if col is not in a degree list */
+    IndexType prev ;  /* previous column in degree list, if col is in a */
+    /* degree list (but not at the head of a degree list) */
+  } shared3 ;
+  union
+  {
+    IndexType degree_next ; /* next column, if col is in a degree list */
+    IndexType hash_next ;   /* next column, if col is in a hash list */
+  } shared4 ;
+
+  inline bool is_dead() const { return start < Alive; }
+
+  inline bool is_alive() const { return start >= Alive; }
+
+  inline bool is_dead_principal() const { return start == DeadPrincipal; }
+
+  inline void kill_principal() { start = DeadPrincipal; }
+
+  inline void kill_non_principal() { start = DeadNonPrincipal; }
+
+};
+
+template <typename IndexType>
+struct RowStructure
+{
+  IndexType start ;   /* index for A of first col in this row */
+  IndexType length ;  /* number of principal columns in this row */
+  union
+  {
+    IndexType degree ;  /* number of principal & non-principal columns in row */
+    IndexType p ;   /* used as a row pointer in init_rows_cols () */
+  } shared1 ;
+  union
+  {
+    IndexType mark ;  /* for computing set differences and marking dead rows*/
+    IndexType first_column ;/* first column in row (used in garbage collection) */
+  } shared2 ;
+
+  inline bool is_dead() const { return shared2.mark < Alive; }
+
+  inline bool is_alive() const { return shared2.mark >= Alive; }
+
+  inline void kill() { shared2.mark = Dead; }
+
+};
+
+/* ========================================================================== */
+/* === Colamd recommended memory size ======================================= */
+/* ========================================================================== */
+
+/*
+  The recommended length Alen of the array A passed to colamd is given by
+  the COLAMD_RECOMMENDED (nnz, n_row, n_col) macro.  It returns -1 if any
+  argument is negative.  2*nnz space is required for the row and column
+  indices of the matrix. colamd_c (n_col) + colamd_r (n_row) space is
+  required for the Col and Row arrays, respectively, which are internal to
+  colamd.  An additional n_col space is the minimal amount of "elbow room",
+  and nnz/5 more space is recommended for run time efficiency.
+
+  This macro is not needed when using symamd.
+
+  Explicit typecast to IndexType added Sept. 23, 2002, COLAMD version 2.2, to avoid
+  gcc -pedantic warning messages.
+*/
+template <typename IndexType>
+inline IndexType colamd_c(IndexType n_col)
+{ return IndexType( ((n_col) + 1) * sizeof (ColStructure<IndexType>) / sizeof (IndexType) ) ; }
+
+template <typename IndexType>
+inline IndexType  colamd_r(IndexType n_row)
+{ return IndexType(((n_row) + 1) * sizeof (RowStructure<IndexType>) / sizeof (IndexType)); }
+
+// Prototypes of non-user callable routines
+template <typename IndexType>
+static IndexType init_rows_cols (IndexType n_row, IndexType n_col, RowStructure<IndexType> Row [], ColStructure<IndexType> col [], IndexType A [], IndexType p [], IndexType stats[NStats] );
+
+template <typename IndexType>
+static void init_scoring (IndexType n_row, IndexType n_col, RowStructure<IndexType> Row [], ColStructure<IndexType> Col [], IndexType A [], IndexType head [], double knobs[NKnobs], IndexType *p_n_row2, IndexType *p_n_col2, IndexType *p_max_deg);
+
+template <typename IndexType>
+static IndexType find_ordering (IndexType n_row, IndexType n_col, IndexType Alen, RowStructure<IndexType> Row [], ColStructure<IndexType> Col [], IndexType A [], IndexType head [], IndexType n_col2, IndexType max_deg, IndexType pfree);
+
+template <typename IndexType>
+static void order_children (IndexType n_col, ColStructure<IndexType> Col [], IndexType p []);
+
+template <typename IndexType>
+static void detect_super_cols (ColStructure<IndexType> Col [], IndexType A [], IndexType head [], IndexType row_start, IndexType row_length ) ;
+
+template <typename IndexType>
+static IndexType garbage_collection (IndexType n_row, IndexType n_col, RowStructure<IndexType> Row [], ColStructure<IndexType> Col [], IndexType A [], IndexType *pfree) ;
+
+template <typename IndexType>
+static inline  IndexType clear_mark (IndexType n_row, RowStructure<IndexType> Row [] ) ;
+
+/* === No debugging ========================================================= */
+
+#define COLAMD_DEBUG0(params) ;
+#define COLAMD_DEBUG1(params) ;
+#define COLAMD_DEBUG2(params) ;
+#define COLAMD_DEBUG3(params) ;
+#define COLAMD_DEBUG4(params) ;
+
+#define COLAMD_ASSERT(expression) ((void) 0)
+
+
+/**
+ * \brief Returns the recommended value of Alen
+ *
+ * Returns recommended value of Alen for use by colamd.
+ * Returns -1 if any input argument is negative.
+ * The use of this routine or macro is optional.
+ * Note that the macro uses its arguments   more than once,
+ * so be careful for side effects, if you pass expressions as arguments to COLAMD_RECOMMENDED.
+ *
+ * \param nnz nonzeros in A
+ * \param n_row number of rows in A
+ * \param n_col number of columns in A
+ * \return recommended value of Alen for use by colamd
+ */
+template <typename IndexType>
+inline IndexType recommended ( IndexType nnz, IndexType n_row, IndexType n_col)
+{
+  if ((nnz) < 0 || (n_row) < 0 || (n_col) < 0)
+    return (-1);
+  else
+    return (2 * (nnz) + colamd_c (n_col) + colamd_r (n_row) + (n_col) + ((nnz) / 5));
+}
+
+/**
+ * \brief set default parameters  The use of this routine is optional.
+ *
+ * Colamd: rows with more than (knobs [DenseRow] * n_col)
+ * entries are removed prior to ordering.  Columns with more than
+ * (knobs [DenseCol] * n_row) entries are removed prior to
+ * ordering, and placed last in the output column ordering.
+ *
+ * DenseRow and DenseCol are defined as 0 and 1,
+ * respectively, in colamd.h.  Default values of these two knobs
+ * are both 0.5.  Currently, only knobs [0] and knobs [1] are
+ * used, but future versions may use more knobs.  If so, they will
+ * be properly set to their defaults by the future version of
+ * colamd_set_defaults, so that the code that calls colamd will
+ * not need to change, assuming that you either use
+ * colamd_set_defaults, or pass a (double *) NULL pointer as the
+ * knobs array to colamd or symamd.
+ *
+ * \param knobs parameter settings for colamd
+ */
+
+static inline void set_defaults(double knobs[NKnobs])
+{
+  /* === Local variables ================================================== */
+
+  int i ;
+
+  if (!knobs)
+  {
+    return ;      /* no knobs to initialize */
+  }
+  for (i = 0 ; i < NKnobs ; i++)
+  {
+    knobs [i] = 0 ;
+  }
+  knobs [Colamd::DenseRow] = 0.5 ;  /* ignore rows over 50% dense */
+  knobs [Colamd::DenseCol] = 0.5 ;  /* ignore columns over 50% dense */
+}
+
+/**
+ * \brief  Computes a column ordering using the column approximate minimum degree ordering
+ *
+ * Computes a column ordering (Q) of A such that P(AQ)=LU or
+ * (AQ)'AQ=LL' have less fill-in and require fewer floating point
+ * operations than factorizing the unpermuted matrix A or A'A,
+ * respectively.
+ *
+ *
+ * \param n_row number of rows in A
+ * \param n_col number of columns in A
+ * \param Alen, size of the array A
+ * \param A row indices of the matrix, of size ALen
+ * \param p column pointers of A, of size n_col+1
+ * \param knobs parameter settings for colamd
+ * \param stats colamd output statistics and error codes
+ */
+template <typename IndexType>
+static bool compute_ordering(IndexType n_row, IndexType n_col, IndexType Alen, IndexType *A, IndexType *p, double knobs[NKnobs], IndexType stats[NStats])
+{
+  /* === Local variables ================================================== */
+
+  IndexType i ;     /* loop index */
+  IndexType nnz ;     /* nonzeros in A */
+  IndexType Row_size ;    /* size of Row [], in integers */
+  IndexType Col_size ;    /* size of Col [], in integers */
+  IndexType need ;      /* minimum required length of A */
+  Colamd::RowStructure<IndexType> *Row ;   /* pointer into A of Row [0..n_row] array */
+  Colamd::ColStructure<IndexType> *Col ;   /* pointer into A of Col [0..n_col] array */
+  IndexType n_col2 ;    /* number of non-dense, non-empty columns */
+  IndexType n_row2 ;    /* number of non-dense, non-empty rows */
+  IndexType ngarbage ;    /* number of garbage collections performed */
+  IndexType max_deg ;   /* maximum row degree */
+  double default_knobs [NKnobs] ; /* default knobs array */
+
+
+  /* === Check the input arguments ======================================== */
+
+  if (!stats)
+  {
+    COLAMD_DEBUG0 (("colamd: stats not present\n")) ;
+    return (false) ;
+  }
+  for (i = 0 ; i < NStats ; i++)
+  {
+    stats [i] = 0 ;
+  }
+  stats [Colamd::Status] = Colamd::Ok ;
+  stats [Colamd::Info1] = -1 ;
+  stats [Colamd::Info2] = -1 ;
+
+  if (!A)   /* A is not present */
+  {
+    stats [Colamd::Status] = Colamd::ErrorANotPresent ;
+    COLAMD_DEBUG0 (("colamd: A not present\n")) ;
+    return (false) ;
+  }
+
+  if (!p)   /* p is not present */
+  {
+    stats [Colamd::Status] = Colamd::ErrorPNotPresent ;
+    COLAMD_DEBUG0 (("colamd: p not present\n")) ;
+    return (false) ;
+  }
+
+  if (n_row < 0)  /* n_row must be >= 0 */
+  {
+    stats [Colamd::Status] = Colamd::ErrorNrowNegative ;
+    stats [Colamd::Info1] = n_row ;
+    COLAMD_DEBUG0 (("colamd: nrow negative %d\n", n_row)) ;
+    return (false) ;
+  }
+
+  if (n_col < 0)  /* n_col must be >= 0 */
+  {
+    stats [Colamd::Status] = Colamd::ErrorNcolNegative ;
+    stats [Colamd::Info1] = n_col ;
+    COLAMD_DEBUG0 (("colamd: ncol negative %d\n", n_col)) ;
+    return (false) ;
+  }
+
+  nnz = p [n_col] ;
+  if (nnz < 0)  /* nnz must be >= 0 */
+  {
+    stats [Colamd::Status] = Colamd::ErrorNnzNegative ;
+    stats [Colamd::Info1] = nnz ;
+    COLAMD_DEBUG0 (("colamd: number of entries negative %d\n", nnz)) ;
+    return (false) ;
+  }
+
+  if (p [0] != 0)
+  {
+    stats [Colamd::Status] = Colamd::ErrorP0Nonzero ;
+    stats [Colamd::Info1] = p [0] ;
+    COLAMD_DEBUG0 (("colamd: p[0] not zero %d\n", p [0])) ;
+    return (false) ;
+  }
+
+  /* === If no knobs, set default knobs =================================== */
+
+  if (!knobs)
+  {
+    set_defaults (default_knobs) ;
+    knobs = default_knobs ;
+  }
+
+  /* === Allocate the Row and Col arrays from array A ===================== */
+
+  Col_size = colamd_c (n_col) ;
+  Row_size = colamd_r (n_row) ;
+  need = 2*nnz + n_col + Col_size + Row_size ;
+
+  if (need > Alen)
+  {
+    /* not enough space in array A to perform the ordering */
+    stats [Colamd::Status] = Colamd::ErrorATooSmall ;
+    stats [Colamd::Info1] = need ;
+    stats [Colamd::Info2] = Alen ;
+    COLAMD_DEBUG0 (("colamd: Need Alen >= %d, given only Alen = %d\n", need,Alen));
+    return (false) ;
+  }
+
+  Alen -= Col_size + Row_size ;
+  Col = (ColStructure<IndexType> *) &A [Alen] ;
+  Row = (RowStructure<IndexType> *) &A [Alen + Col_size] ;
+
+  /* === Construct the row and column data structures ===================== */
+
+  if (!Colamd::init_rows_cols (n_row, n_col, Row, Col, A, p, stats))
+  {
+    /* input matrix is invalid */
+    COLAMD_DEBUG0 (("colamd: Matrix invalid\n")) ;
+    return (false) ;
+  }
+
+  /* === Initialize scores, kill dense rows/columns ======================= */
+
+  Colamd::init_scoring (n_row, n_col, Row, Col, A, p, knobs,
+		&n_row2, &n_col2, &max_deg) ;
+
+  /* === Order the supercolumns =========================================== */
+
+  ngarbage = Colamd::find_ordering (n_row, n_col, Alen, Row, Col, A, p,
+			    n_col2, max_deg, 2*nnz) ;
+
+  /* === Order the non-principal columns ================================== */
+
+  Colamd::order_children (n_col, Col, p) ;
+
+  /* === Return statistics in stats ======================================= */
+
+  stats [Colamd::DenseRow] = n_row - n_row2 ;
+  stats [Colamd::DenseCol] = n_col - n_col2 ;
+  stats [Colamd::DefragCount] = ngarbage ;
+  COLAMD_DEBUG0 (("colamd: done.\n")) ;
+  return (true) ;
+}
+
+/* ========================================================================== */
+/* === NON-USER-CALLABLE ROUTINES: ========================================== */
+/* ========================================================================== */
+
+/* There are no user-callable routines beyond this point in the file */
+
+/* ========================================================================== */
+/* === init_rows_cols ======================================================= */
+/* ========================================================================== */
+
+/*
+  Takes the column form of the matrix in A and creates the row form of the
+  matrix.  Also, row and column attributes are stored in the Col and Row
+  structs.  If the columns are un-sorted or contain duplicate row indices,
+  this routine will also sort and remove duplicate row indices from the
+  column form of the matrix.  Returns false if the matrix is invalid,
+  true otherwise.  Not user-callable.
+*/
+template <typename IndexType>
+static IndexType init_rows_cols  /* returns true if OK, or false otherwise */
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows of A */
+    IndexType n_col,      /* number of columns of A */
+    RowStructure<IndexType> Row [],    /* of size n_row+1 */
+    ColStructure<IndexType> Col [],    /* of size n_col+1 */
+    IndexType A [],     /* row indices of A, of size Alen */
+    IndexType p [],     /* pointers to columns in A, of size n_col+1 */
+    IndexType stats [NStats]  /* colamd statistics */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType col ;     /* a column index */
+  IndexType row ;     /* a row index */
+  IndexType *cp ;     /* a column pointer */
+  IndexType *cp_end ;   /* a pointer to the end of a column */
+  IndexType *rp ;     /* a row pointer */
+  IndexType *rp_end ;   /* a pointer to the end of a row */
+  IndexType last_row ;    /* previous row */
+
+  /* === Initialize columns, and check column pointers ==================== */
+
+  for (col = 0 ; col < n_col ; col++)
+  {
+    Col [col].start = p [col] ;
+    Col [col].length = p [col+1] - p [col] ;
+
+    if ((Col [col].length) < 0) // extra parentheses to work-around gcc bug 10200
+    {
+      /* column pointers must be non-decreasing */
+      stats [Colamd::Status] = Colamd::ErrorColLengthNegative ;
+      stats [Colamd::Info1] = col ;
+      stats [Colamd::Info2] = Col [col].length ;
+      COLAMD_DEBUG0 (("colamd: col %d length %d < 0\n", col, Col [col].length)) ;
+      return (false) ;
+    }
+
+    Col [col].shared1.thickness = 1 ;
+    Col [col].shared2.score = 0 ;
+    Col [col].shared3.prev = Empty ;
+    Col [col].shared4.degree_next = Empty ;
+  }
+
+  /* p [0..n_col] no longer needed, used as "head" in subsequent routines */
+
+  /* === Scan columns, compute row degrees, and check row indices ========= */
+
+  stats [Info3] = 0 ;  /* number of duplicate or unsorted row indices*/
+
+  for (row = 0 ; row < n_row ; row++)
+  {
+    Row [row].length = 0 ;
+    Row [row].shared2.mark = -1 ;
+  }
+
+  for (col = 0 ; col < n_col ; col++)
+  {
+    last_row = -1 ;
+
+    cp = &A [p [col]] ;
+    cp_end = &A [p [col+1]] ;
+
+    while (cp < cp_end)
+    {
+      row = *cp++ ;
+
+      /* make sure row indices within range */
+      if (row < 0 || row >= n_row)
+      {
+	stats [Colamd::Status] = Colamd::ErrorRowIndexOutOfBounds ;
+	stats [Colamd::Info1] = col ;
+	stats [Colamd::Info2] = row ;
+	stats [Colamd::Info3] = n_row ;
+	COLAMD_DEBUG0 (("colamd: row %d col %d out of bounds\n", row, col)) ;
+	return (false) ;
+      }
+
+      if (row <= last_row || Row [row].shared2.mark == col)
+      {
+	/* row index are unsorted or repeated (or both), thus col */
+	/* is jumbled.  This is a notice, not an error condition. */
+	stats [Colamd::Status] = Colamd::OkButJumbled ;
+	stats [Colamd::Info1] = col ;
+	stats [Colamd::Info2] = row ;
+	(stats [Colamd::Info3]) ++ ;
+	COLAMD_DEBUG1 (("colamd: row %d col %d unsorted/duplicate\n",row,col));
+      }
+
+      if (Row [row].shared2.mark != col)
+      {
+	Row [row].length++ ;
+      }
+      else
+      {
+	/* this is a repeated entry in the column, */
+	/* it will be removed */
+	Col [col].length-- ;
+      }
+
+      /* mark the row as having been seen in this column */
+      Row [row].shared2.mark = col ;
+
+      last_row = row ;
+    }
+  }
+
+  /* === Compute row pointers ============================================= */
+
+  /* row form of the matrix starts directly after the column */
+  /* form of matrix in A */
+  Row [0].start = p [n_col] ;
+  Row [0].shared1.p = Row [0].start ;
+  Row [0].shared2.mark = -1 ;
+  for (row = 1 ; row < n_row ; row++)
+  {
+    Row [row].start = Row [row-1].start + Row [row-1].length ;
+    Row [row].shared1.p = Row [row].start ;
+    Row [row].shared2.mark = -1 ;
+  }
+
+  /* === Create row form ================================================== */
+
+  if (stats [Status] == OkButJumbled)
+  {
+    /* if cols jumbled, watch for repeated row indices */
+    for (col = 0 ; col < n_col ; col++)
+    {
+      cp = &A [p [col]] ;
+      cp_end = &A [p [col+1]] ;
+      while (cp < cp_end)
+      {
+	row = *cp++ ;
+	if (Row [row].shared2.mark != col)
+	{
+	  A [(Row [row].shared1.p)++] = col ;
+	  Row [row].shared2.mark = col ;
+	}
+      }
+    }
+  }
+  else
+  {
+    /* if cols not jumbled, we don't need the mark (this is faster) */
+    for (col = 0 ; col < n_col ; col++)
+    {
+      cp = &A [p [col]] ;
+      cp_end = &A [p [col+1]] ;
+      while (cp < cp_end)
+      {
+	A [(Row [*cp++].shared1.p)++] = col ;
+      }
+    }
+  }
+
+  /* === Clear the row marks and set row degrees ========================== */
+
+  for (row = 0 ; row < n_row ; row++)
+  {
+    Row [row].shared2.mark = 0 ;
+    Row [row].shared1.degree = Row [row].length ;
+  }
+
+  /* === See if we need to re-create columns ============================== */
+
+  if (stats [Status] == OkButJumbled)
+  {
+    COLAMD_DEBUG0 (("colamd: reconstructing column form, matrix jumbled\n")) ;
+
+
+    /* === Compute col pointers ========================================= */
+
+    /* col form of the matrix starts at A [0]. */
+    /* Note, we may have a gap between the col form and the row */
+    /* form if there were duplicate entries, if so, it will be */
+    /* removed upon the first garbage collection */
+    Col [0].start = 0 ;
+    p [0] = Col [0].start ;
+    for (col = 1 ; col < n_col ; col++)
+    {
+      /* note that the lengths here are for pruned columns, i.e. */
+      /* no duplicate row indices will exist for these columns */
+      Col [col].start = Col [col-1].start + Col [col-1].length ;
+      p [col] = Col [col].start ;
+    }
+
+    /* === Re-create col form =========================================== */
+
+    for (row = 0 ; row < n_row ; row++)
+    {
+      rp = &A [Row [row].start] ;
+      rp_end = rp + Row [row].length ;
+      while (rp < rp_end)
+      {
+	A [(p [*rp++])++] = row ;
+      }
+    }
+  }
+
+  /* === Done.  Matrix is not (or no longer) jumbled ====================== */
+
+  return (true) ;
+}
+
+
+/* ========================================================================== */
+/* === init_scoring ========================================================= */
+/* ========================================================================== */
+
+/*
+  Kills dense or empty columns and rows, calculates an initial score for
+  each column, and places all columns in the degree lists.  Not user-callable.
+*/
+template <typename IndexType>
+static void init_scoring
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows of A */
+    IndexType n_col,      /* number of columns of A */
+    RowStructure<IndexType> Row [],    /* of size n_row+1 */
+    ColStructure<IndexType> Col [],    /* of size n_col+1 */
+    IndexType A [],     /* column form and row form of A */
+    IndexType head [],    /* of size n_col+1 */
+    double knobs [NKnobs],/* parameters */
+    IndexType *p_n_row2,    /* number of non-dense, non-empty rows */
+    IndexType *p_n_col2,    /* number of non-dense, non-empty columns */
+    IndexType *p_max_deg    /* maximum row degree */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType c ;     /* a column index */
+  IndexType r, row ;    /* a row index */
+  IndexType *cp ;     /* a column pointer */
+  IndexType deg ;     /* degree of a row or column */
+  IndexType *cp_end ;   /* a pointer to the end of a column */
+  IndexType *new_cp ;   /* new column pointer */
+  IndexType col_length ;    /* length of pruned column */
+  IndexType score ;     /* current column score */
+  IndexType n_col2 ;    /* number of non-dense, non-empty columns */
+  IndexType n_row2 ;    /* number of non-dense, non-empty rows */
+  IndexType dense_row_count ; /* remove rows with more entries than this */
+  IndexType dense_col_count ; /* remove cols with more entries than this */
+  IndexType min_score ;   /* smallest column score */
+  IndexType max_deg ;   /* maximum row degree */
+  IndexType next_col ;    /* Used to add to degree list.*/
+
+
+  /* === Extract knobs ==================================================== */
+
+  dense_row_count = numext::maxi(IndexType(0), numext::mini(IndexType(knobs [Colamd::DenseRow] * n_col), n_col)) ;
+  dense_col_count = numext::maxi(IndexType(0), numext::mini(IndexType(knobs [Colamd::DenseCol] * n_row), n_row)) ;
+  COLAMD_DEBUG1 (("colamd: densecount: %d %d\n", dense_row_count, dense_col_count)) ;
+  max_deg = 0 ;
+  n_col2 = n_col ;
+  n_row2 = n_row ;
+
+  /* === Kill empty columns =============================================== */
+
+  /* Put the empty columns at the end in their natural order, so that LU */
+  /* factorization can proceed as far as possible. */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    deg = Col [c].length ;
+    if (deg == 0)
+    {
+      /* this is a empty column, kill and order it last */
+      Col [c].shared2.order = --n_col2 ;
+      Col[c].kill_principal() ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: null columns killed: %d\n", n_col - n_col2)) ;
+
+  /* === Kill dense columns =============================================== */
+
+  /* Put the dense columns at the end, in their natural order */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    /* skip any dead columns */
+    if (Col[c].is_dead())
+    {
+      continue ;
+    }
+    deg = Col [c].length ;
+    if (deg > dense_col_count)
+    {
+      /* this is a dense column, kill and order it last */
+      Col [c].shared2.order = --n_col2 ;
+      /* decrement the row degrees */
+      cp = &A [Col [c].start] ;
+      cp_end = cp + Col [c].length ;
+      while (cp < cp_end)
+      {
+	Row [*cp++].shared1.degree-- ;
+      }
+      Col[c].kill_principal() ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: Dense and null columns killed: %d\n", n_col - n_col2)) ;
+
+  /* === Kill dense and empty rows ======================================== */
+
+  for (r = 0 ; r < n_row ; r++)
+  {
+    deg = Row [r].shared1.degree ;
+    COLAMD_ASSERT (deg >= 0 && deg <= n_col) ;
+    if (deg > dense_row_count || deg == 0)
+    {
+      /* kill a dense or empty row */
+      Row[r].kill() ;
+      --n_row2 ;
+    }
+    else
+    {
+      /* keep track of max degree of remaining rows */
+      max_deg = numext::maxi(max_deg, deg) ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: Dense and null rows killed: %d\n", n_row - n_row2)) ;
+
+  /* === Compute initial column scores ==================================== */
+
+  /* At this point the row degrees are accurate.  They reflect the number */
+  /* of "live" (non-dense) columns in each row.  No empty rows exist. */
+  /* Some "live" columns may contain only dead rows, however.  These are */
+  /* pruned in the code below. */
+
+  /* now find the initial matlab score for each column */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    /* skip dead column */
+    if (Col[c].is_dead())
+    {
+      continue ;
+    }
+    score = 0 ;
+    cp = &A [Col [c].start] ;
+    new_cp = cp ;
+    cp_end = cp + Col [c].length ;
+    while (cp < cp_end)
+    {
+      /* get a row */
+      row = *cp++ ;
+      /* skip if dead */
+      if (Row[row].is_dead())
+      {
+	continue ;
+      }
+      /* compact the column */
+      *new_cp++ = row ;
+      /* add row's external degree */
+      score += Row [row].shared1.degree - 1 ;
+      /* guard against integer overflow */
+      score = numext::mini(score, n_col) ;
+    }
+    /* determine pruned column length */
+    col_length = (IndexType) (new_cp - &A [Col [c].start]) ;
+    if (col_length == 0)
+    {
+      /* a newly-made null column (all rows in this col are "dense" */
+      /* and have already been killed) */
+      COLAMD_DEBUG2 (("Newly null killed: %d\n", c)) ;
+      Col [c].shared2.order = --n_col2 ;
+      Col[c].kill_principal() ;
+    }
+    else
+    {
+      /* set column length and set score */
+      COLAMD_ASSERT (score >= 0) ;
+      COLAMD_ASSERT (score <= n_col) ;
+      Col [c].length = col_length ;
+      Col [c].shared2.score = score ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: Dense, null, and newly-null columns killed: %d\n",
+		  n_col-n_col2)) ;
+
+  /* At this point, all empty rows and columns are dead.  All live columns */
+  /* are "clean" (containing no dead rows) and simplicial (no supercolumns */
+  /* yet).  Rows may contain dead columns, but all live rows contain at */
+  /* least one live column. */
+
+  /* === Initialize degree lists ========================================== */
+
+
+  /* clear the hash buckets */
+  for (c = 0 ; c <= n_col ; c++)
+  {
+    head [c] = Empty ;
+  }
+  min_score = n_col ;
+  /* place in reverse order, so low column indices are at the front */
+  /* of the lists.  This is to encourage natural tie-breaking */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    /* only add principal columns to degree lists */
+    if (Col[c].is_alive())
+    {
+      COLAMD_DEBUG4 (("place %d score %d minscore %d ncol %d\n",
+		      c, Col [c].shared2.score, min_score, n_col)) ;
+
+      /* === Add columns score to DList =============================== */
+
+      score = Col [c].shared2.score ;
+
+      COLAMD_ASSERT (min_score >= 0) ;
+      COLAMD_ASSERT (min_score <= n_col) ;
+      COLAMD_ASSERT (score >= 0) ;
+      COLAMD_ASSERT (score <= n_col) ;
+      COLAMD_ASSERT (head [score] >= Empty) ;
+
+      /* now add this column to dList at proper score location */
+      next_col = head [score] ;
+      Col [c].shared3.prev = Empty ;
+      Col [c].shared4.degree_next = next_col ;
+
+      /* if there already was a column with the same score, set its */
+      /* previous pointer to this new column */
+      if (next_col != Empty)
+      {
+	Col [next_col].shared3.prev = c ;
+      }
+      head [score] = c ;
+
+      /* see if this score is less than current min */
+      min_score = numext::mini(min_score, score) ;
+
+
+    }
+  }
+
+
+  /* === Return number of remaining columns, and max row degree =========== */
+
+  *p_n_col2 = n_col2 ;
+  *p_n_row2 = n_row2 ;
+  *p_max_deg = max_deg ;
+}
+
+
+/* ========================================================================== */
+/* === find_ordering ======================================================== */
+/* ========================================================================== */
+
+/*
+  Order the principal columns of the supercolumn form of the matrix
+  (no supercolumns on input).  Uses a minimum approximate column minimum
+  degree ordering method.  Not user-callable.
+*/
+template <typename IndexType>
+static IndexType find_ordering /* return the number of garbage collections */
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows of A */
+    IndexType n_col,      /* number of columns of A */
+    IndexType Alen,     /* size of A, 2*nnz + n_col or larger */
+    RowStructure<IndexType> Row [],    /* of size n_row+1 */
+    ColStructure<IndexType> Col [],    /* of size n_col+1 */
+    IndexType A [],     /* column form and row form of A */
+    IndexType head [],    /* of size n_col+1 */
+    IndexType n_col2,     /* Remaining columns to order */
+    IndexType max_deg,    /* Maximum row degree */
+    IndexType pfree     /* index of first free slot (2*nnz on entry) */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType k ;     /* current pivot ordering step */
+  IndexType pivot_col ;   /* current pivot column */
+  IndexType *cp ;     /* a column pointer */
+  IndexType *rp ;     /* a row pointer */
+  IndexType pivot_row ;   /* current pivot row */
+  IndexType *new_cp ;   /* modified column pointer */
+  IndexType *new_rp ;   /* modified row pointer */
+  IndexType pivot_row_start ; /* pointer to start of pivot row */
+  IndexType pivot_row_degree ;  /* number of columns in pivot row */
+  IndexType pivot_row_length ;  /* number of supercolumns in pivot row */
+  IndexType pivot_col_score ; /* score of pivot column */
+  IndexType needed_memory ;   /* free space needed for pivot row */
+  IndexType *cp_end ;   /* pointer to the end of a column */
+  IndexType *rp_end ;   /* pointer to the end of a row */
+  IndexType row ;     /* a row index */
+  IndexType col ;     /* a column index */
+  IndexType max_score ;   /* maximum possible score */
+  IndexType cur_score ;   /* score of current column */
+  unsigned int hash ;   /* hash value for supernode detection */
+  IndexType head_column ;   /* head of hash bucket */
+  IndexType first_col ;   /* first column in hash bucket */
+  IndexType tag_mark ;    /* marker value for mark array */
+  IndexType row_mark ;    /* Row [row].shared2.mark */
+  IndexType set_difference ;  /* set difference size of row with pivot row */
+  IndexType min_score ;   /* smallest column score */
+  IndexType col_thickness ;   /* "thickness" (no. of columns in a supercol) */
+  IndexType max_mark ;    /* maximum value of tag_mark */
+  IndexType pivot_col_thickness ; /* number of columns represented by pivot col */
+  IndexType prev_col ;    /* Used by Dlist operations. */
+  IndexType next_col ;    /* Used by Dlist operations. */
+  IndexType ngarbage ;    /* number of garbage collections performed */
+
+
+  /* === Initialization and clear mark ==================================== */
+
+  max_mark = INT_MAX - n_col ;  /* INT_MAX defined in <limits.h> */
+  tag_mark = Colamd::clear_mark (n_row, Row) ;
+  min_score = 0 ;
+  ngarbage = 0 ;
+  COLAMD_DEBUG1 (("colamd: Ordering, n_col2=%d\n", n_col2)) ;
+
+  /* === Order the columns ================================================ */
+
+  for (k = 0 ; k < n_col2 ; /* 'k' is incremented below */)
+  {
+
+    /* === Select pivot column, and order it ============================ */
+
+    /* make sure degree list isn't empty */
+    COLAMD_ASSERT (min_score >= 0) ;
+    COLAMD_ASSERT (min_score <= n_col) ;
+    COLAMD_ASSERT (head [min_score] >= Empty) ;
+
+    /* get pivot column from head of minimum degree list */
+    while (min_score < n_col && head [min_score] == Empty)
+    {
+      min_score++ ;
+    }
+    pivot_col = head [min_score] ;
+    COLAMD_ASSERT (pivot_col >= 0 && pivot_col <= n_col) ;
+    next_col = Col [pivot_col].shared4.degree_next ;
+    head [min_score] = next_col ;
+    if (next_col != Empty)
+    {
+      Col [next_col].shared3.prev = Empty ;
+    }
+
+    COLAMD_ASSERT (Col[pivot_col].is_alive()) ;
+    COLAMD_DEBUG3 (("Pivot col: %d\n", pivot_col)) ;
+
+    /* remember score for defrag check */
+    pivot_col_score = Col [pivot_col].shared2.score ;
+
+    /* the pivot column is the kth column in the pivot order */
+    Col [pivot_col].shared2.order = k ;
+
+    /* increment order count by column thickness */
+    pivot_col_thickness = Col [pivot_col].shared1.thickness ;
+    k += pivot_col_thickness ;
+    COLAMD_ASSERT (pivot_col_thickness > 0) ;
+
+    /* === Garbage_collection, if necessary ============================= */
+
+    needed_memory = numext::mini(pivot_col_score, n_col - k) ;
+    if (pfree + needed_memory >= Alen)
+    {
+      pfree = Colamd::garbage_collection (n_row, n_col, Row, Col, A, &A [pfree]) ;
+      ngarbage++ ;
+      /* after garbage collection we will have enough */
+      COLAMD_ASSERT (pfree + needed_memory < Alen) ;
+      /* garbage collection has wiped out the Row[].shared2.mark array */
+      tag_mark = Colamd::clear_mark (n_row, Row) ;
+
+    }
+
+    /* === Compute pivot row pattern ==================================== */
+
+    /* get starting location for this new merged row */
+    pivot_row_start = pfree ;
+
+    /* initialize new row counts to zero */
+    pivot_row_degree = 0 ;
+
+    /* tag pivot column as having been visited so it isn't included */
+    /* in merged pivot row */
+    Col [pivot_col].shared1.thickness = -pivot_col_thickness ;
+
+    /* pivot row is the union of all rows in the pivot column pattern */
+    cp = &A [Col [pivot_col].start] ;
+    cp_end = cp + Col [pivot_col].length ;
+    while (cp < cp_end)
+    {
+      /* get a row */
+      row = *cp++ ;
+      COLAMD_DEBUG4 (("Pivot col pattern %d %d\n", Row[row].is_alive(), row)) ;
+      /* skip if row is dead */
+      if (Row[row].is_dead())
+      {
+	continue ;
+      }
+      rp = &A [Row [row].start] ;
+      rp_end = rp + Row [row].length ;
+      while (rp < rp_end)
+      {
+	/* get a column */
+	col = *rp++ ;
+	/* add the column, if alive and untagged */
+	col_thickness = Col [col].shared1.thickness ;
+	if (col_thickness > 0 && Col[col].is_alive())
+	{
+	  /* tag column in pivot row */
+	  Col [col].shared1.thickness = -col_thickness ;
+	  COLAMD_ASSERT (pfree < Alen) ;
+	  /* place column in pivot row */
+	  A [pfree++] = col ;
+	  pivot_row_degree += col_thickness ;
+	}
+      }
+    }
+
+    /* clear tag on pivot column */
+    Col [pivot_col].shared1.thickness = pivot_col_thickness ;
+    max_deg = numext::maxi(max_deg, pivot_row_degree) ;
+
+
+    /* === Kill all rows used to construct pivot row ==================== */
+
+    /* also kill pivot row, temporarily */
+    cp = &A [Col [pivot_col].start] ;
+    cp_end = cp + Col [pivot_col].length ;
+    while (cp < cp_end)
+    {
+      /* may be killing an already dead row */
+      row = *cp++ ;
+      COLAMD_DEBUG3 (("Kill row in pivot col: %d\n", row)) ;
+      Row[row].kill() ;
+    }
+
+    /* === Select a row index to use as the new pivot row =============== */
+
+    pivot_row_length = pfree - pivot_row_start ;
+    if (pivot_row_length > 0)
+    {
+      /* pick the "pivot" row arbitrarily (first row in col) */
+      pivot_row = A [Col [pivot_col].start] ;
+      COLAMD_DEBUG3 (("Pivotal row is %d\n", pivot_row)) ;
+    }
+    else
+    {
+      /* there is no pivot row, since it is of zero length */
+      pivot_row = Empty ;
+      COLAMD_ASSERT (pivot_row_length == 0) ;
+    }
+    COLAMD_ASSERT (Col [pivot_col].length > 0 || pivot_row_length == 0) ;
+
+    /* === Approximate degree computation =============================== */
+
+    /* Here begins the computation of the approximate degree.  The column */
+    /* score is the sum of the pivot row "length", plus the size of the */
+    /* set differences of each row in the column minus the pattern of the */
+    /* pivot row itself.  The column ("thickness") itself is also */
+    /* excluded from the column score (we thus use an approximate */
+    /* external degree). */
+
+    /* The time taken by the following code (compute set differences, and */
+    /* add them up) is proportional to the size of the data structure */
+    /* being scanned - that is, the sum of the sizes of each column in */
+    /* the pivot row.  Thus, the amortized time to compute a column score */
+    /* is proportional to the size of that column (where size, in this */
+    /* context, is the column "length", or the number of row indices */
+    /* in that column).  The number of row indices in a column is */
+    /* monotonically non-decreasing, from the length of the original */
+    /* column on input to colamd. */
+
+    /* === Compute set differences ====================================== */
+
+    COLAMD_DEBUG3 (("** Computing set differences phase. **\n")) ;
+
+    /* pivot row is currently dead - it will be revived later. */
+
+    COLAMD_DEBUG3 (("Pivot row: ")) ;
+    /* for each column in pivot row */
+    rp = &A [pivot_row_start] ;
+    rp_end = rp + pivot_row_length ;
+    while (rp < rp_end)
+    {
+      col = *rp++ ;
+      COLAMD_ASSERT (Col[col].is_alive() && col != pivot_col) ;
+      COLAMD_DEBUG3 (("Col: %d\n", col)) ;
+
+      /* clear tags used to construct pivot row pattern */
+      col_thickness = -Col [col].shared1.thickness ;
+      COLAMD_ASSERT (col_thickness > 0) ;
+      Col [col].shared1.thickness = col_thickness ;
+
+      /* === Remove column from degree list =========================== */
+
+      cur_score = Col [col].shared2.score ;
+      prev_col = Col [col].shared3.prev ;
+      next_col = Col [col].shared4.degree_next ;
+      COLAMD_ASSERT (cur_score >= 0) ;
+      COLAMD_ASSERT (cur_score <= n_col) ;
+      COLAMD_ASSERT (cur_score >= Empty) ;
+      if (prev_col == Empty)
+      {
+	head [cur_score] = next_col ;
+      }
+      else
+      {
+	Col [prev_col].shared4.degree_next = next_col ;
+      }
+      if (next_col != Empty)
+      {
+	Col [next_col].shared3.prev = prev_col ;
+      }
+
+      /* === Scan the column ========================================== */
+
+      cp = &A [Col [col].start] ;
+      cp_end = cp + Col [col].length ;
+      while (cp < cp_end)
+      {
+	/* get a row */
+	row = *cp++ ;
+	/* skip if dead */
+	if (Row[row].is_dead())
+	{
+	  continue ;
+	}
+  row_mark = Row [row].shared2.mark ;
+	COLAMD_ASSERT (row != pivot_row) ;
+	set_difference = row_mark - tag_mark ;
+	/* check if the row has been seen yet */
+	if (set_difference < 0)
+	{
+	  COLAMD_ASSERT (Row [row].shared1.degree <= max_deg) ;
+	  set_difference = Row [row].shared1.degree ;
+	}
+	/* subtract column thickness from this row's set difference */
+	set_difference -= col_thickness ;
+	COLAMD_ASSERT (set_difference >= 0) ;
+	/* absorb this row if the set difference becomes zero */
+	if (set_difference == 0)
+	{
+	  COLAMD_DEBUG3 (("aggressive absorption. Row: %d\n", row)) ;
+	  Row[row].kill() ;
+	}
+	else
+	{
+	  /* save the new mark */
+	  Row [row].shared2.mark = set_difference + tag_mark ;
+	}
+      }
+    }
+
+
+    /* === Add up set differences for each column ======================= */
+
+    COLAMD_DEBUG3 (("** Adding set differences phase. **\n")) ;
+
+    /* for each column in pivot row */
+    rp = &A [pivot_row_start] ;
+    rp_end = rp + pivot_row_length ;
+    while (rp < rp_end)
+    {
+      /* get a column */
+      col = *rp++ ;
+      COLAMD_ASSERT (Col[col].is_alive() && col != pivot_col) ;
+      hash = 0 ;
+      cur_score = 0 ;
+      cp = &A [Col [col].start] ;
+      /* compact the column */
+      new_cp = cp ;
+      cp_end = cp + Col [col].length ;
+
+      COLAMD_DEBUG4 (("Adding set diffs for Col: %d.\n", col)) ;
+
+      while (cp < cp_end)
+      {
+	/* get a row */
+	row = *cp++ ;
+	COLAMD_ASSERT(row >= 0 && row < n_row) ;
+	/* skip if dead */
+	if (Row [row].is_dead())
+	{
+	  continue ;
+	}
+  row_mark = Row [row].shared2.mark ;
+	COLAMD_ASSERT (row_mark > tag_mark) ;
+	/* compact the column */
+	*new_cp++ = row ;
+	/* compute hash function */
+	hash += row ;
+	/* add set difference */
+	cur_score += row_mark - tag_mark ;
+	/* integer overflow... */
+	cur_score = numext::mini(cur_score, n_col) ;
+      }
+
+      /* recompute the column's length */
+      Col [col].length = (IndexType) (new_cp - &A [Col [col].start]) ;
+
+      /* === Further mass elimination ================================= */
+
+      if (Col [col].length == 0)
+      {
+	COLAMD_DEBUG4 (("further mass elimination. Col: %d\n", col)) ;
+	/* nothing left but the pivot row in this column */
+	Col[col].kill_principal() ;
+	pivot_row_degree -= Col [col].shared1.thickness ;
+	COLAMD_ASSERT (pivot_row_degree >= 0) ;
+	/* order it */
+	Col [col].shared2.order = k ;
+	/* increment order count by column thickness */
+	k += Col [col].shared1.thickness ;
+      }
+      else
+      {
+	/* === Prepare for supercolumn detection ==================== */
+
+	COLAMD_DEBUG4 (("Preparing supercol detection for Col: %d.\n", col)) ;
+
+	/* save score so far */
+	Col [col].shared2.score = cur_score ;
+
+	/* add column to hash table, for supercolumn detection */
+	hash %= n_col + 1 ;
+
+	COLAMD_DEBUG4 ((" Hash = %d, n_col = %d.\n", hash, n_col)) ;
+	COLAMD_ASSERT (hash <= n_col) ;
+
+	head_column = head [hash] ;
+	if (head_column > Empty)
+	{
+	  /* degree list "hash" is non-empty, use prev (shared3) of */
+	  /* first column in degree list as head of hash bucket */
+	  first_col = Col [head_column].shared3.headhash ;
+	  Col [head_column].shared3.headhash = col ;
+	}
+	else
+	{
+	  /* degree list "hash" is empty, use head as hash bucket */
+	  first_col = - (head_column + 2) ;
+	  head [hash] = - (col + 2) ;
+	}
+	Col [col].shared4.hash_next = first_col ;
+
+	/* save hash function in Col [col].shared3.hash */
+	Col [col].shared3.hash = (IndexType) hash ;
+	COLAMD_ASSERT (Col[col].is_alive()) ;
+      }
+    }
+
+    /* The approximate external column degree is now computed.  */
+
+    /* === Supercolumn detection ======================================== */
+
+    COLAMD_DEBUG3 (("** Supercolumn detection phase. **\n")) ;
+
+    Colamd::detect_super_cols (Col, A, head, pivot_row_start, pivot_row_length) ;
+
+    /* === Kill the pivotal column ====================================== */
+
+    Col[pivot_col].kill_principal() ;
+
+    /* === Clear mark =================================================== */
+
+    tag_mark += (max_deg + 1) ;
+    if (tag_mark >= max_mark)
+    {
+      COLAMD_DEBUG2 (("clearing tag_mark\n")) ;
+      tag_mark = Colamd::clear_mark (n_row, Row) ;
+    }
+
+    /* === Finalize the new pivot row, and column scores ================ */
+
+    COLAMD_DEBUG3 (("** Finalize scores phase. **\n")) ;
+
+    /* for each column in pivot row */
+    rp = &A [pivot_row_start] ;
+    /* compact the pivot row */
+    new_rp = rp ;
+    rp_end = rp + pivot_row_length ;
+    while (rp < rp_end)
+    {
+      col = *rp++ ;
+      /* skip dead columns */
+      if (Col[col].is_dead())
+      {
+	continue ;
+      }
+      *new_rp++ = col ;
+      /* add new pivot row to column */
+      A [Col [col].start + (Col [col].length++)] = pivot_row ;
+
+      /* retrieve score so far and add on pivot row's degree. */
+      /* (we wait until here for this in case the pivot */
+      /* row's degree was reduced due to mass elimination). */
+      cur_score = Col [col].shared2.score + pivot_row_degree ;
+
+      /* calculate the max possible score as the number of */
+      /* external columns minus the 'k' value minus the */
+      /* columns thickness */
+      max_score = n_col - k - Col [col].shared1.thickness ;
+
+      /* make the score the external degree of the union-of-rows */
+      cur_score -= Col [col].shared1.thickness ;
+
+      /* make sure score is less or equal than the max score */
+      cur_score = numext::mini(cur_score, max_score) ;
+      COLAMD_ASSERT (cur_score >= 0) ;
+
+      /* store updated score */
+      Col [col].shared2.score = cur_score ;
+
+      /* === Place column back in degree list ========================= */
+
+      COLAMD_ASSERT (min_score >= 0) ;
+      COLAMD_ASSERT (min_score <= n_col) ;
+      COLAMD_ASSERT (cur_score >= 0) ;
+      COLAMD_ASSERT (cur_score <= n_col) ;
+      COLAMD_ASSERT (head [cur_score] >= Empty) ;
+      next_col = head [cur_score] ;
+      Col [col].shared4.degree_next = next_col ;
+      Col [col].shared3.prev = Empty ;
+      if (next_col != Empty)
+      {
+	Col [next_col].shared3.prev = col ;
+      }
+      head [cur_score] = col ;
+
+      /* see if this score is less than current min */
+      min_score = numext::mini(min_score, cur_score) ;
+
+    }
+
+    /* === Resurrect the new pivot row ================================== */
+
+    if (pivot_row_degree > 0)
+    {
+      /* update pivot row length to reflect any cols that were killed */
+      /* during super-col detection and mass elimination */
+      Row [pivot_row].start  = pivot_row_start ;
+      Row [pivot_row].length = (IndexType) (new_rp - &A[pivot_row_start]) ;
+      Row [pivot_row].shared1.degree = pivot_row_degree ;
+      Row [pivot_row].shared2.mark = 0 ;
+      /* pivot row is no longer dead */
+    }
+  }
+
+  /* === All principal columns have now been ordered ====================== */
+
+  return (ngarbage) ;
+}
+
+
+/* ========================================================================== */
+/* === order_children ======================================================= */
+/* ========================================================================== */
+
+/*
+  The find_ordering routine has ordered all of the principal columns (the
+  representatives of the supercolumns).  The non-principal columns have not
+  yet been ordered.  This routine orders those columns by walking up the
+  parent tree (a column is a child of the column which absorbed it).  The
+  final permutation vector is then placed in p [0 ... n_col-1], with p [0]
+  being the first column, and p [n_col-1] being the last.  It doesn't look
+  like it at first glance, but be assured that this routine takes time linear
+  in the number of columns.  Although not immediately obvious, the time
+  taken by this routine is O (n_col), that is, linear in the number of
+  columns.  Not user-callable.
+*/
+template <typename IndexType>
+static inline  void order_children
+(
+  /* === Parameters ======================================================= */
+
+  IndexType n_col,      /* number of columns of A */
+  ColStructure<IndexType> Col [],    /* of size n_col+1 */
+  IndexType p []      /* p [0 ... n_col-1] is the column permutation*/
+  )
+{
+  /* === Local variables ================================================== */
+
+  IndexType i ;     /* loop counter for all columns */
+  IndexType c ;     /* column index */
+  IndexType parent ;    /* index of column's parent */
+  IndexType order ;     /* column's order */
+
+  /* === Order each non-principal column ================================== */
+
+  for (i = 0 ; i < n_col ; i++)
+  {
+    /* find an un-ordered non-principal column */
+    COLAMD_ASSERT (col_is_dead(Col, i)) ;
+    if (!Col[i].is_dead_principal() && Col [i].shared2.order == Empty)
+    {
+      parent = i ;
+      /* once found, find its principal parent */
+      do
+      {
+	parent = Col [parent].shared1.parent ;
+      } while (!Col[parent].is_dead_principal()) ;
+
+      /* now, order all un-ordered non-principal columns along path */
+      /* to this parent.  collapse tree at the same time */
+      c = i ;
+      /* get order of parent */
+      order = Col [parent].shared2.order ;
+
+      do
+      {
+	COLAMD_ASSERT (Col [c].shared2.order == Empty) ;
+
+	/* order this column */
+	Col [c].shared2.order = order++ ;
+	/* collaps tree */
+	Col [c].shared1.parent = parent ;
+
+	/* get immediate parent of this column */
+	c = Col [c].shared1.parent ;
+
+	/* continue until we hit an ordered column.  There are */
+	/* guaranteed not to be anymore unordered columns */
+	/* above an ordered column */
+      } while (Col [c].shared2.order == Empty) ;
+
+      /* re-order the super_col parent to largest order for this group */
+      Col [parent].shared2.order = order ;
+    }
+  }
+
+  /* === Generate the permutation ========================================= */
+
+  for (c = 0 ; c < n_col ; c++)
+  {
+    p [Col [c].shared2.order] = c ;
+  }
+}
+
+
+/* ========================================================================== */
+/* === detect_super_cols ==================================================== */
+/* ========================================================================== */
+
+/*
+  Detects supercolumns by finding matches between columns in the hash buckets.
+  Check amongst columns in the set A [row_start ... row_start + row_length-1].
+  The columns under consideration are currently *not* in the degree lists,
+  and have already been placed in the hash buckets.
+
+  The hash bucket for columns whose hash function is equal to h is stored
+  as follows:
+
+  if head [h] is >= 0, then head [h] contains a degree list, so:
+
+  head [h] is the first column in degree bucket h.
+  Col [head [h]].headhash gives the first column in hash bucket h.
+
+  otherwise, the degree list is empty, and:
+
+  -(head [h] + 2) is the first column in hash bucket h.
+
+  For a column c in a hash bucket, Col [c].shared3.prev is NOT a "previous
+  column" pointer.  Col [c].shared3.hash is used instead as the hash number
+  for that column.  The value of Col [c].shared4.hash_next is the next column
+  in the same hash bucket.
+
+  Assuming no, or "few" hash collisions, the time taken by this routine is
+  linear in the sum of the sizes (lengths) of each column whose score has
+  just been computed in the approximate degree computation.
+  Not user-callable.
+*/
+template <typename IndexType>
+static void detect_super_cols
+(
+  /* === Parameters ======================================================= */
+
+  ColStructure<IndexType> Col [],    /* of size n_col+1 */
+  IndexType A [],     /* row indices of A */
+  IndexType head [],    /* head of degree lists and hash buckets */
+  IndexType row_start,    /* pointer to set of columns to check */
+  IndexType row_length    /* number of columns to check */
+)
+{
+  /* === Local variables ================================================== */
+
+  IndexType hash ;      /* hash value for a column */
+  IndexType *rp ;     /* pointer to a row */
+  IndexType c ;     /* a column index */
+  IndexType super_c ;   /* column index of the column to absorb into */
+  IndexType *cp1 ;      /* column pointer for column super_c */
+  IndexType *cp2 ;      /* column pointer for column c */
+  IndexType length ;    /* length of column super_c */
+  IndexType prev_c ;    /* column preceding c in hash bucket */
+  IndexType i ;     /* loop counter */
+  IndexType *rp_end ;   /* pointer to the end of the row */
+  IndexType col ;     /* a column index in the row to check */
+  IndexType head_column ;   /* first column in hash bucket or degree list */
+  IndexType first_col ;   /* first column in hash bucket */
+
+  /* === Consider each column in the row ================================== */
+
+  rp = &A [row_start] ;
+  rp_end = rp + row_length ;
+  while (rp < rp_end)
+  {
+    col = *rp++ ;
+    if (Col[col].is_dead())
+    {
+      continue ;
+    }
+
+    /* get hash number for this column */
+    hash = Col [col].shared3.hash ;
+    COLAMD_ASSERT (hash <= n_col) ;
+
+    /* === Get the first column in this hash bucket ===================== */
+
+    head_column = head [hash] ;
+    if (head_column > Empty)
+    {
+      first_col = Col [head_column].shared3.headhash ;
+    }
+    else
+    {
+      first_col = - (head_column + 2) ;
+    }
+
+    /* === Consider each column in the hash bucket ====================== */
+
+    for (super_c = first_col ; super_c != Empty ;
+	 super_c = Col [super_c].shared4.hash_next)
+    {
+      COLAMD_ASSERT (Col [super_c].is_alive()) ;
+      COLAMD_ASSERT (Col [super_c].shared3.hash == hash) ;
+      length = Col [super_c].length ;
+
+      /* prev_c is the column preceding column c in the hash bucket */
+      prev_c = super_c ;
+
+      /* === Compare super_c with all columns after it ================ */
+
+      for (c = Col [super_c].shared4.hash_next ;
+	   c != Empty ; c = Col [c].shared4.hash_next)
+      {
+	COLAMD_ASSERT (c != super_c) ;
+	COLAMD_ASSERT (Col[c].is_alive()) ;
+	COLAMD_ASSERT (Col [c].shared3.hash == hash) ;
+
+	/* not identical if lengths or scores are different */
+	if (Col [c].length != length ||
+	    Col [c].shared2.score != Col [super_c].shared2.score)
+	{
+	  prev_c = c ;
+	  continue ;
+	}
+
+	/* compare the two columns */
+	cp1 = &A [Col [super_c].start] ;
+	cp2 = &A [Col [c].start] ;
+
+	for (i = 0 ; i < length ; i++)
+	{
+	  /* the columns are "clean" (no dead rows) */
+	  COLAMD_ASSERT ( cp1->is_alive() );
+	  COLAMD_ASSERT ( cp2->is_alive() );
+	  /* row indices will same order for both supercols, */
+	  /* no gather scatter necessary */
+	  if (*cp1++ != *cp2++)
+	  {
+	    break ;
+	  }
+	}
+
+	/* the two columns are different if the for-loop "broke" */
+	if (i != length)
+	{
+	  prev_c = c ;
+	  continue ;
+	}
+
+	/* === Got it!  two columns are identical =================== */
+
+	COLAMD_ASSERT (Col [c].shared2.score == Col [super_c].shared2.score) ;
+
+	Col [super_c].shared1.thickness += Col [c].shared1.thickness ;
+	Col [c].shared1.parent = super_c ;
+	Col[c].kill_non_principal() ;
+	/* order c later, in order_children() */
+	Col [c].shared2.order = Empty ;
+	/* remove c from hash bucket */
+	Col [prev_c].shared4.hash_next = Col [c].shared4.hash_next ;
+      }
+    }
+
+    /* === Empty this hash bucket ======================================= */
+
+    if (head_column > Empty)
+    {
+      /* corresponding degree list "hash" is not empty */
+      Col [head_column].shared3.headhash = Empty ;
+    }
+    else
+    {
+      /* corresponding degree list "hash" is empty */
+      head [hash] = Empty ;
+    }
+  }
+}
+
+
+/* ========================================================================== */
+/* === garbage_collection =================================================== */
+/* ========================================================================== */
+
+/*
+  Defragments and compacts columns and rows in the workspace A.  Used when
+  all available memory has been used while performing row merging.  Returns
+  the index of the first free position in A, after garbage collection.  The
+  time taken by this routine is linear is the size of the array A, which is
+  itself linear in the number of nonzeros in the input matrix.
+  Not user-callable.
+*/
+template <typename IndexType>
+static IndexType garbage_collection  /* returns the new value of pfree */
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows */
+    IndexType n_col,      /* number of columns */
+    RowStructure<IndexType> Row [],    /* row info */
+    ColStructure<IndexType> Col [],    /* column info */
+    IndexType A [],     /* A [0 ... Alen-1] holds the matrix */
+    IndexType *pfree      /* &A [0] ... pfree is in use */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType *psrc ;     /* source pointer */
+  IndexType *pdest ;    /* destination pointer */
+  IndexType j ;     /* counter */
+  IndexType r ;     /* a row index */
+  IndexType c ;     /* a column index */
+  IndexType length ;    /* length of a row or column */
+
+  /* === Defragment the columns =========================================== */
+
+  pdest = &A[0] ;
+  for (c = 0 ; c < n_col ; c++)
+  {
+    if (Col[c].is_alive())
+    {
+      psrc = &A [Col [c].start] ;
+
+      /* move and compact the column */
+      COLAMD_ASSERT (pdest <= psrc) ;
+      Col [c].start = (IndexType) (pdest - &A [0]) ;
+      length = Col [c].length ;
+      for (j = 0 ; j < length ; j++)
+      {
+	r = *psrc++ ;
+	if (Row[r].is_alive())
+	{
+	  *pdest++ = r ;
+	}
+      }
+      Col [c].length = (IndexType) (pdest - &A [Col [c].start]) ;
+    }
+  }
+
+  /* === Prepare to defragment the rows =================================== */
+
+  for (r = 0 ; r < n_row ; r++)
+  {
+    if (Row[r].is_alive())
+    {
+      if (Row [r].length == 0)
+      {
+        /* this row is of zero length.  cannot compact it, so kill it */
+        COLAMD_DEBUG3 (("Defrag row kill\n")) ;
+        Row[r].kill() ;
+      }
+      else
+      {
+        /* save first column index in Row [r].shared2.first_column */
+        psrc = &A [Row [r].start] ;
+        Row [r].shared2.first_column = *psrc ;
+        COLAMD_ASSERT (Row[r].is_alive()) ;
+        /* flag the start of the row with the one's complement of row */
+        *psrc = ones_complement(r) ;
+
+      }
+    }
+  }
+
+  /* === Defragment the rows ============================================== */
+
+  psrc = pdest ;
+  while (psrc < pfree)
+  {
+    /* find a negative number ... the start of a row */
+    if (*psrc++ < 0)
+    {
+      psrc-- ;
+      /* get the row index */
+      r = ones_complement(*psrc) ;
+      COLAMD_ASSERT (r >= 0 && r < n_row) ;
+      /* restore first column index */
+      *psrc = Row [r].shared2.first_column ;
+      COLAMD_ASSERT (Row[r].is_alive()) ;
+
+      /* move and compact the row */
+      COLAMD_ASSERT (pdest <= psrc) ;
+      Row [r].start = (IndexType) (pdest - &A [0]) ;
+      length = Row [r].length ;
+      for (j = 0 ; j < length ; j++)
+      {
+	c = *psrc++ ;
+	if (Col[c].is_alive())
+	{
+	  *pdest++ = c ;
+	}
+      }
+      Row [r].length = (IndexType) (pdest - &A [Row [r].start]) ;
+
+    }
+  }
+  /* ensure we found all the rows */
+  COLAMD_ASSERT (debug_rows == 0) ;
+
+  /* === Return the new value of pfree ==================================== */
+
+  return ((IndexType) (pdest - &A [0])) ;
+}
+
+
+/* ========================================================================== */
+/* === clear_mark =========================================================== */
+/* ========================================================================== */
+
+/*
+  Clears the Row [].shared2.mark array, and returns the new tag_mark.
+  Return value is the new tag_mark.  Not user-callable.
+*/
+template <typename IndexType>
+static inline  IndexType clear_mark  /* return the new value for tag_mark */
+  (
+      /* === Parameters ======================================================= */
+
+    IndexType n_row,    /* number of rows in A */
+    RowStructure<IndexType> Row [] /* Row [0 ... n_row-1].shared2.mark is set to zero */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType r ;
+
+  for (r = 0 ; r < n_row ; r++)
+  {
+    if (Row[r].is_alive())
+    {
+      Row [r].shared2.mark = 0 ;
+    }
+  }
+  return (1) ;
+}
+
+} // namespace Colamd
+
+} // namespace internal
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/OrderingMethods/Ordering.h b/C++/yolo_bytetrack/include/Eigen/src/OrderingMethods/Ordering.h
new file mode 100644
index 00000000..c5789701
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/OrderingMethods/Ordering.h
@@ -0,0 +1,153 @@
+ 
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012  Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ORDERING_H
+#define EIGEN_ORDERING_H
+
+namespace Eigen {
+  
+#include "Eigen_Colamd.h"
+
+namespace internal {
+    
+/** \internal
+  * \ingroup OrderingMethods_Module
+  * \param[in] A the input non-symmetric matrix
+  * \param[out] symmat the symmetric pattern A^T+A from the input matrix \a A.
+  * FIXME: The values should not be considered here
+  */
+template<typename MatrixType> 
+void ordering_helper_at_plus_a(const MatrixType& A, MatrixType& symmat)
+{
+  MatrixType C;
+  C = A.transpose(); // NOTE: Could be  costly
+  for (int i = 0; i < C.rows(); i++) 
+  {
+      for (typename MatrixType::InnerIterator it(C, i); it; ++it)
+        it.valueRef() = typename MatrixType::Scalar(0);
+  }
+  symmat = C + A;
+}
+    
+}
+
+/** \ingroup OrderingMethods_Module
+  * \class AMDOrdering
+  *
+  * Functor computing the \em approximate \em minimum \em degree ordering
+  * If the matrix is not structurally symmetric, an ordering of A^T+A is computed
+  * \tparam  StorageIndex The type of indices of the matrix 
+  * \sa COLAMDOrdering
+  */
+template <typename StorageIndex>
+class AMDOrdering
+{
+  public:
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+    
+    /** Compute the permutation vector from a sparse matrix
+     * This routine is much faster if the input matrix is column-major     
+     */
+    template <typename MatrixType>
+    void operator()(const MatrixType& mat, PermutationType& perm)
+    {
+      // Compute the symmetric pattern
+      SparseMatrix<typename MatrixType::Scalar, ColMajor, StorageIndex> symm;
+      internal::ordering_helper_at_plus_a(mat,symm); 
+    
+      // Call the AMD routine 
+      //m_mat.prune(keep_diag());
+      internal::minimum_degree_ordering(symm, perm);
+    }
+    
+    /** Compute the permutation with a selfadjoint matrix */
+    template <typename SrcType, unsigned int SrcUpLo> 
+    void operator()(const SparseSelfAdjointView<SrcType, SrcUpLo>& mat, PermutationType& perm)
+    { 
+      SparseMatrix<typename SrcType::Scalar, ColMajor, StorageIndex> C; C = mat;
+      
+      // Call the AMD routine 
+      // m_mat.prune(keep_diag()); //Remove the diagonal elements 
+      internal::minimum_degree_ordering(C, perm);
+    }
+};
+
+/** \ingroup OrderingMethods_Module
+  * \class NaturalOrdering
+  *
+  * Functor computing the natural ordering (identity)
+  * 
+  * \note Returns an empty permutation matrix
+  * \tparam  StorageIndex The type of indices of the matrix 
+  */
+template <typename StorageIndex>
+class NaturalOrdering
+{
+  public:
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+    
+    /** Compute the permutation vector from a column-major sparse matrix */
+    template <typename MatrixType>
+    void operator()(const MatrixType& /*mat*/, PermutationType& perm)
+    {
+      perm.resize(0); 
+    }
+    
+};
+
+/** \ingroup OrderingMethods_Module
+  * \class COLAMDOrdering
+  *
+  * \tparam  StorageIndex The type of indices of the matrix 
+  * 
+  * Functor computing the \em column \em approximate \em minimum \em degree ordering 
+  * The matrix should be in column-major and \b compressed format (see SparseMatrix::makeCompressed()).
+  */
+template<typename StorageIndex>
+class COLAMDOrdering
+{
+  public:
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType; 
+    typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
+    
+    /** Compute the permutation vector \a perm form the sparse matrix \a mat
+      * \warning The input sparse matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+      */
+    template <typename MatrixType>
+    void operator() (const MatrixType& mat, PermutationType& perm)
+    {
+      eigen_assert(mat.isCompressed() && "COLAMDOrdering requires a sparse matrix in compressed mode. Call .makeCompressed() before passing it to COLAMDOrdering");
+      
+      StorageIndex m = StorageIndex(mat.rows());
+      StorageIndex n = StorageIndex(mat.cols());
+      StorageIndex nnz = StorageIndex(mat.nonZeros());
+      // Get the recommended value of Alen to be used by colamd
+      StorageIndex Alen = internal::Colamd::recommended(nnz, m, n); 
+      // Set the default parameters
+      double knobs [internal::Colamd::NKnobs]; 
+      StorageIndex stats [internal::Colamd::NStats];
+      internal::Colamd::set_defaults(knobs);
+      
+      IndexVector p(n+1), A(Alen); 
+      for(StorageIndex i=0; i <= n; i++)   p(i) = mat.outerIndexPtr()[i];
+      for(StorageIndex i=0; i < nnz; i++)  A(i) = mat.innerIndexPtr()[i];
+      // Call Colamd routine to compute the ordering 
+      StorageIndex info = internal::Colamd::compute_ordering(m, n, Alen, A.data(), p.data(), knobs, stats); 
+      EIGEN_UNUSED_VARIABLE(info);
+      eigen_assert( info && "COLAMD failed " );
+      
+      perm.resize(n);
+      for (StorageIndex i = 0; i < n; i++) perm.indices()(p(i)) = i;
+    }
+};
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/PaStiXSupport/PaStiXSupport.h b/C++/yolo_bytetrack/include/Eigen/src/PaStiXSupport/PaStiXSupport.h
new file mode 100644
index 00000000..37426877
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/PaStiXSupport/PaStiXSupport.h
@@ -0,0 +1,678 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PASTIXSUPPORT_H
+#define EIGEN_PASTIXSUPPORT_H
+
+namespace Eigen { 
+
+#if defined(DCOMPLEX)
+  #define PASTIX_COMPLEX  COMPLEX
+  #define PASTIX_DCOMPLEX DCOMPLEX
+#else
+  #define PASTIX_COMPLEX  std::complex<float>
+  #define PASTIX_DCOMPLEX std::complex<double>
+#endif
+
+/** \ingroup PaStiXSupport_Module
+  * \brief Interface to the PaStix solver
+  * 
+  * This class is used to solve the linear systems A.X = B via the PaStix library. 
+  * The matrix can be either real or complex, symmetric or not.
+  *
+  * \sa TutorialSparseDirectSolvers
+  */
+template<typename _MatrixType, bool IsStrSym = false> class PastixLU;
+template<typename _MatrixType, int Options> class PastixLLT;
+template<typename _MatrixType, int Options> class PastixLDLT;
+
+namespace internal
+{
+    
+  template<class Pastix> struct pastix_traits;
+
+  template<typename _MatrixType>
+  struct pastix_traits< PastixLU<_MatrixType> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pastix_traits< PastixLLT<_MatrixType,Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pastix_traits< PastixLDLT<_MatrixType,Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+  
+  inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, float *vals, int *perm, int * invp, float *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    s_pastix(pastix_data, pastix_comm, n, ptr, idx, vals, perm, invp, x, nbrhs, iparm, dparm); 
+  }
+  
+  inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, double *vals, int *perm, int * invp, double *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    d_pastix(pastix_data, pastix_comm, n, ptr, idx, vals, perm, invp, x, nbrhs, iparm, dparm); 
+  }
+  
+  inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, std::complex<float> *vals, int *perm, int * invp, std::complex<float> *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    c_pastix(pastix_data, pastix_comm, n, ptr, idx, reinterpret_cast<PASTIX_COMPLEX*>(vals), perm, invp, reinterpret_cast<PASTIX_COMPLEX*>(x), nbrhs, iparm, dparm); 
+  }
+  
+  inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, std::complex<double> *vals, int *perm, int * invp, std::complex<double> *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    z_pastix(pastix_data, pastix_comm, n, ptr, idx, reinterpret_cast<PASTIX_DCOMPLEX*>(vals), perm, invp, reinterpret_cast<PASTIX_DCOMPLEX*>(x), nbrhs, iparm, dparm); 
+  }
+
+  // Convert the matrix  to Fortran-style Numbering
+  template <typename MatrixType>
+  void c_to_fortran_numbering (MatrixType& mat)
+  {
+    if ( !(mat.outerIndexPtr()[0]) ) 
+    { 
+      int i;
+      for(i = 0; i <= mat.rows(); ++i)
+        ++mat.outerIndexPtr()[i];
+      for(i = 0; i < mat.nonZeros(); ++i)
+        ++mat.innerIndexPtr()[i];
+    }
+  }
+  
+  // Convert to C-style Numbering
+  template <typename MatrixType>
+  void fortran_to_c_numbering (MatrixType& mat)
+  {
+    // Check the Numbering
+    if ( mat.outerIndexPtr()[0] == 1 ) 
+    { // Convert to C-style numbering
+      int i;
+      for(i = 0; i <= mat.rows(); ++i)
+        --mat.outerIndexPtr()[i];
+      for(i = 0; i < mat.nonZeros(); ++i)
+        --mat.innerIndexPtr()[i];
+    }
+  }
+}
+
+// This is the base class to interface with PaStiX functions. 
+// Users should not used this class directly. 
+template <class Derived>
+class PastixBase : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    
+    typedef typename internal::pastix_traits<Derived>::MatrixType _MatrixType;
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef SparseMatrix<Scalar, ColMajor> ColSpMatrix;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+  public:
+    
+    PastixBase() : m_initisOk(false), m_analysisIsOk(false), m_factorizationIsOk(false), m_pastixdata(0), m_size(0)
+    {
+      init();
+    }
+    
+    ~PastixBase() 
+    {
+      clean();
+    }
+    
+    template<typename Rhs,typename Dest>
+    bool _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &x) const;
+    
+    /** Returns a reference to the integer vector IPARM of PaStiX parameters
+      * to modify the default parameters. 
+      * The statistics related to the different phases of factorization and solve are saved here as well
+      * \sa analyzePattern() factorize()
+      */
+    Array<StorageIndex,IPARM_SIZE,1>& iparm()
+    {
+      return m_iparm; 
+    }
+    
+    /** Return a reference to a particular index parameter of the IPARM vector 
+     * \sa iparm()
+     */
+    
+    int& iparm(int idxparam)
+    {
+      return m_iparm(idxparam);
+    }
+    
+     /** Returns a reference to the double vector DPARM of PaStiX parameters 
+      * The statistics related to the different phases of factorization and solve are saved here as well
+      * \sa analyzePattern() factorize()
+      */
+    Array<double,DPARM_SIZE,1>& dparm()
+    {
+      return m_dparm; 
+    }
+    
+    
+    /** Return a reference to a particular index parameter of the DPARM vector 
+     * \sa dparm()
+     */
+    double& dparm(int idxparam)
+    {
+      return m_dparm(idxparam);
+    }
+    
+    inline Index cols() const { return m_size; }
+    inline Index rows() const { return m_size; }
+    
+     /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the PaStiX reports a problem
+      *          \c InvalidInput if the input matrix is invalid
+      *
+      * \sa iparm()          
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+    
+  protected:
+
+    // Initialize the Pastix data structure, check the matrix
+    void init(); 
+    
+    // Compute the ordering and the symbolic factorization
+    void analyzePattern(ColSpMatrix& mat);
+    
+    // Compute the numerical factorization
+    void factorize(ColSpMatrix& mat);
+    
+    // Free all the data allocated by Pastix
+    void clean()
+    {
+      eigen_assert(m_initisOk && "The Pastix structure should be allocated first"); 
+      m_iparm(IPARM_START_TASK) = API_TASK_CLEAN;
+      m_iparm(IPARM_END_TASK) = API_TASK_CLEAN;
+      internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, 0, 0, 0, (Scalar*)0,
+                             m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
+    }
+    
+    void compute(ColSpMatrix& mat);
+    
+    int m_initisOk; 
+    int m_analysisIsOk;
+    int m_factorizationIsOk;
+    mutable ComputationInfo m_info; 
+    mutable pastix_data_t *m_pastixdata; // Data structure for pastix
+    mutable int m_comm; // The MPI communicator identifier
+    mutable Array<int,IPARM_SIZE,1> m_iparm; // integer vector for the input parameters
+    mutable Array<double,DPARM_SIZE,1> m_dparm; // Scalar vector for the input parameters
+    mutable Matrix<StorageIndex,Dynamic,1> m_perm;  // Permutation vector
+    mutable Matrix<StorageIndex,Dynamic,1> m_invp;  // Inverse permutation vector
+    mutable int m_size; // Size of the matrix 
+}; 
+
+ /** Initialize the PaStiX data structure. 
+   *A first call to this function fills iparm and dparm with the default PaStiX parameters
+   * \sa iparm() dparm()
+   */
+template <class Derived>
+void PastixBase<Derived>::init()
+{
+  m_size = 0; 
+  m_iparm.setZero(IPARM_SIZE);
+  m_dparm.setZero(DPARM_SIZE);
+  
+  m_iparm(IPARM_MODIFY_PARAMETER) = API_NO;
+  pastix(&m_pastixdata, MPI_COMM_WORLD,
+         0, 0, 0, 0,
+         0, 0, 0, 1, m_iparm.data(), m_dparm.data());
+  
+  m_iparm[IPARM_MATRIX_VERIFICATION] = API_NO;
+  m_iparm[IPARM_VERBOSE]             = API_VERBOSE_NOT;
+  m_iparm[IPARM_ORDERING]            = API_ORDER_SCOTCH;
+  m_iparm[IPARM_INCOMPLETE]          = API_NO;
+  m_iparm[IPARM_OOC_LIMIT]           = 2000;
+  m_iparm[IPARM_RHS_MAKING]          = API_RHS_B;
+  m_iparm(IPARM_MATRIX_VERIFICATION) = API_NO;
+  
+  m_iparm(IPARM_START_TASK) = API_TASK_INIT;
+  m_iparm(IPARM_END_TASK) = API_TASK_INIT;
+  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, 0, 0, 0, (Scalar*)0,
+                         0, 0, 0, 0, m_iparm.data(), m_dparm.data());
+  
+  // Check the returned error
+  if(m_iparm(IPARM_ERROR_NUMBER)) {
+    m_info = InvalidInput;
+    m_initisOk = false;
+  }
+  else { 
+    m_info = Success;
+    m_initisOk = true;
+  }
+}
+
+template <class Derived>
+void PastixBase<Derived>::compute(ColSpMatrix& mat)
+{
+  eigen_assert(mat.rows() == mat.cols() && "The input matrix should be squared");
+  
+  analyzePattern(mat);  
+  factorize(mat);
+  
+  m_iparm(IPARM_MATRIX_VERIFICATION) = API_NO;
+}
+
+
+template <class Derived>
+void PastixBase<Derived>::analyzePattern(ColSpMatrix& mat)
+{                         
+  eigen_assert(m_initisOk && "The initialization of PaSTiX failed");
+  
+  // clean previous calls
+  if(m_size>0)
+    clean();
+  
+  m_size = internal::convert_index<int>(mat.rows());
+  m_perm.resize(m_size);
+  m_invp.resize(m_size);
+  
+  m_iparm(IPARM_START_TASK) = API_TASK_ORDERING;
+  m_iparm(IPARM_END_TASK) = API_TASK_ANALYSE;
+  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, m_size, mat.outerIndexPtr(), mat.innerIndexPtr(),
+               mat.valuePtr(), m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
+  
+  // Check the returned error
+  if(m_iparm(IPARM_ERROR_NUMBER))
+  {
+    m_info = NumericalIssue;
+    m_analysisIsOk = false;
+  }
+  else
+  { 
+    m_info = Success;
+    m_analysisIsOk = true;
+  }
+}
+
+template <class Derived>
+void PastixBase<Derived>::factorize(ColSpMatrix& mat)
+{
+//   if(&m_cpyMat != &mat) m_cpyMat = mat;
+  eigen_assert(m_analysisIsOk && "The analysis phase should be called before the factorization phase");
+  m_iparm(IPARM_START_TASK) = API_TASK_NUMFACT;
+  m_iparm(IPARM_END_TASK) = API_TASK_NUMFACT;
+  m_size = internal::convert_index<int>(mat.rows());
+  
+  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, m_size, mat.outerIndexPtr(), mat.innerIndexPtr(),
+               mat.valuePtr(), m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
+  
+  // Check the returned error
+  if(m_iparm(IPARM_ERROR_NUMBER))
+  {
+    m_info = NumericalIssue;
+    m_factorizationIsOk = false;
+    m_isInitialized = false;
+  }
+  else
+  {
+    m_info = Success;
+    m_factorizationIsOk = true;
+    m_isInitialized = true;
+  }
+}
+
+/* Solve the system */
+template<typename Base>
+template<typename Rhs,typename Dest>
+bool PastixBase<Base>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &x) const
+{
+  eigen_assert(m_isInitialized && "The matrix should be factorized first");
+  EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
+                     THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  int rhs = 1;
+  
+  x = b; /* on return, x is overwritten by the computed solution */
+  
+  for (int i = 0; i < b.cols(); i++){
+    m_iparm[IPARM_START_TASK]          = API_TASK_SOLVE;
+    m_iparm[IPARM_END_TASK]            = API_TASK_REFINE;
+  
+    internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, internal::convert_index<int>(x.rows()), 0, 0, 0,
+                           m_perm.data(), m_invp.data(), &x(0, i), rhs, m_iparm.data(), m_dparm.data());
+  }
+  
+  // Check the returned error
+  m_info = m_iparm(IPARM_ERROR_NUMBER)==0 ? Success : NumericalIssue;
+  
+  return m_iparm(IPARM_ERROR_NUMBER)==0;
+}
+
+/** \ingroup PaStiXSupport_Module
+  * \class PastixLU
+  * \brief Sparse direct LU solver based on PaStiX library
+  * 
+  * This class is used to solve the linear systems A.X = B with a supernodal LU 
+  * factorization in the PaStiX library. The matrix A should be squared and nonsingular
+  * PaStiX requires that the matrix A has a symmetric structural pattern. 
+  * This interface can symmetrize the input matrix otherwise. 
+  * The vectors or matrices X and B can be either dense or sparse.
+  * 
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam IsStrSym Indicates if the input matrix has a symmetric pattern, default is false
+  * NOTE : Note that if the analysis and factorization phase are called separately, 
+  * the input matrix will be symmetrized at each call, hence it is advised to 
+  * symmetrize the matrix in a end-user program and set \p IsStrSym to true
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  * 
+  */
+template<typename _MatrixType, bool IsStrSym>
+class PastixLU : public PastixBase< PastixLU<_MatrixType> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef PastixBase<PastixLU<MatrixType> > Base;
+    typedef typename Base::ColSpMatrix ColSpMatrix;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    
+  public:
+    PastixLU() : Base()
+    {
+      init();
+    }
+    
+    explicit PastixLU(const MatrixType& matrix):Base()
+    {
+      init();
+      compute(matrix);
+    }
+    /** Compute the LU supernodal factorization of \p matrix. 
+      * iparm and dparm can be used to tune the PaStiX parameters. 
+      * see the PaStiX user's manual
+      * \sa analyzePattern() factorize()
+      */
+    void compute (const MatrixType& matrix)
+    {
+      m_structureIsUptodate = false;
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::compute(temp);
+    }
+    /** Compute the LU symbolic factorization of \p matrix using its sparsity pattern. 
+      * Several ordering methods can be used at this step. See the PaStiX user's manual. 
+      * The result of this operation can be used with successive matrices having the same pattern as \p matrix
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      m_structureIsUptodate = false;
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::analyzePattern(temp);
+    }
+
+    /** Compute the LU supernodal factorization of \p matrix
+      * WARNING The matrix \p matrix should have the same structural pattern 
+      * as the same used in the analysis phase.
+      * \sa analyzePattern()
+      */ 
+    void factorize(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::factorize(temp);
+    }
+  protected:
+    
+    void init()
+    {
+      m_structureIsUptodate = false;
+      m_iparm(IPARM_SYM) = API_SYM_NO;
+      m_iparm(IPARM_FACTORIZATION) = API_FACT_LU;
+    }
+    
+    void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
+    {
+      if(IsStrSym)
+        out = matrix;
+      else
+      {
+        if(!m_structureIsUptodate)
+        {
+          // update the transposed structure
+          m_transposedStructure = matrix.transpose();
+          
+          // Set the elements of the matrix to zero 
+          for (Index j=0; j<m_transposedStructure.outerSize(); ++j) 
+            for(typename ColSpMatrix::InnerIterator it(m_transposedStructure, j); it; ++it)
+              it.valueRef() = 0.0;
+
+          m_structureIsUptodate = true;
+        }
+        
+        out = m_transposedStructure + matrix;
+      }
+      internal::c_to_fortran_numbering(out);
+    }
+    
+    using Base::m_iparm;
+    using Base::m_dparm;
+    
+    ColSpMatrix m_transposedStructure;
+    bool m_structureIsUptodate;
+};
+
+/** \ingroup PaStiXSupport_Module
+  * \class PastixLLT
+  * \brief A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library
+  * 
+  * This class is used to solve the linear systems A.X = B via a LL^T supernodal Cholesky factorization
+  * available in the PaStiX library. The matrix A should be symmetric and positive definite
+  * WARNING Selfadjoint complex matrices are not supported in the current version of PaStiX
+  * The vectors or matrices X and B can be either dense or sparse
+  * 
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam UpLo The part of the matrix to use : Lower or Upper. The default is Lower as required by PaStiX
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo>
+class PastixLLT : public PastixBase< PastixLLT<_MatrixType, _UpLo> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef PastixBase<PastixLLT<MatrixType, _UpLo> > Base;
+    typedef typename Base::ColSpMatrix ColSpMatrix;
+    
+  public:
+    enum { UpLo = _UpLo };
+    PastixLLT() : Base()
+    {
+      init();
+    }
+    
+    explicit PastixLLT(const MatrixType& matrix):Base()
+    {
+      init();
+      compute(matrix);
+    }
+
+    /** Compute the L factor of the LL^T supernodal factorization of \p matrix 
+      * \sa analyzePattern() factorize()
+      */
+    void compute (const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::compute(temp);
+    }
+
+     /** Compute the LL^T symbolic factorization of \p matrix using its sparsity pattern
+      * The result of this operation can be used with successive matrices having the same pattern as \p matrix
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::analyzePattern(temp);
+    }
+      /** Compute the LL^T supernodal numerical factorization of \p matrix 
+        * \sa analyzePattern()
+        */
+    void factorize(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::factorize(temp);
+    }
+  protected:
+    using Base::m_iparm;
+    
+    void init()
+    {
+      m_iparm(IPARM_SYM) = API_SYM_YES;
+      m_iparm(IPARM_FACTORIZATION) = API_FACT_LLT;
+    }
+    
+    void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
+    {
+      out.resize(matrix.rows(), matrix.cols());
+      // Pastix supports only lower, column-major matrices 
+      out.template selfadjointView<Lower>() = matrix.template selfadjointView<UpLo>();
+      internal::c_to_fortran_numbering(out);
+    }
+};
+
+/** \ingroup PaStiXSupport_Module
+  * \class PastixLDLT
+  * \brief A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library
+  * 
+  * This class is used to solve the linear systems A.X = B via a LDL^T supernodal Cholesky factorization
+  * available in the PaStiX library. The matrix A should be symmetric and positive definite
+  * WARNING Selfadjoint complex matrices are not supported in the current version of PaStiX
+  * The vectors or matrices X and B can be either dense or sparse
+  * 
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam UpLo The part of the matrix to use : Lower or Upper. The default is Lower as required by PaStiX
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLDLT
+  */
+template<typename _MatrixType, int _UpLo>
+class PastixLDLT : public PastixBase< PastixLDLT<_MatrixType, _UpLo> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef PastixBase<PastixLDLT<MatrixType, _UpLo> > Base; 
+    typedef typename Base::ColSpMatrix ColSpMatrix;
+    
+  public:
+    enum { UpLo = _UpLo };
+    PastixLDLT():Base()
+    {
+      init();
+    }
+    
+    explicit PastixLDLT(const MatrixType& matrix):Base()
+    {
+      init();
+      compute(matrix);
+    }
+
+    /** Compute the L and D factors of the LDL^T factorization of \p matrix 
+      * \sa analyzePattern() factorize()
+      */
+    void compute (const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::compute(temp);
+    }
+
+    /** Compute the LDL^T symbolic factorization of \p matrix using its sparsity pattern
+      * The result of this operation can be used with successive matrices having the same pattern as \p matrix
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    { 
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::analyzePattern(temp);
+    }
+    /** Compute the LDL^T supernodal numerical factorization of \p matrix 
+      * 
+      */
+    void factorize(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::factorize(temp);
+    }
+
+  protected:
+    using Base::m_iparm;
+    
+    void init()
+    {
+      m_iparm(IPARM_SYM) = API_SYM_YES;
+      m_iparm(IPARM_FACTORIZATION) = API_FACT_LDLT;
+    }
+    
+    void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
+    {
+      // Pastix supports only lower, column-major matrices 
+      out.resize(matrix.rows(), matrix.cols());
+      out.template selfadjointView<Lower>() = matrix.template selfadjointView<UpLo>();
+      internal::c_to_fortran_numbering(out);
+    }
+};
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/PardisoSupport/PardisoSupport.h b/C++/yolo_bytetrack/include/Eigen/src/PardisoSupport/PardisoSupport.h
new file mode 100644
index 00000000..f89b79bd
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/PardisoSupport/PardisoSupport.h
@@ -0,0 +1,545 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to Intel(R) MKL PARDISO
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_PARDISOSUPPORT_H
+#define EIGEN_PARDISOSUPPORT_H
+
+namespace Eigen { 
+
+template<typename _MatrixType> class PardisoLU;
+template<typename _MatrixType, int Options=Upper> class PardisoLLT;
+template<typename _MatrixType, int Options=Upper> class PardisoLDLT;
+
+namespace internal
+{
+  template<typename IndexType>
+  struct pardiso_run_selector
+  {
+    static IndexType run( _MKL_DSS_HANDLE_t pt, IndexType maxfct, IndexType mnum, IndexType type, IndexType phase, IndexType n, void *a,
+                      IndexType *ia, IndexType *ja, IndexType *perm, IndexType nrhs, IndexType *iparm, IndexType msglvl, void *b, void *x)
+    {
+      IndexType error = 0;
+      ::pardiso(pt, &maxfct, &mnum, &type, &phase, &n, a, ia, ja, perm, &nrhs, iparm, &msglvl, b, x, &error);
+      return error;
+    }
+  };
+  template<>
+  struct pardiso_run_selector<long long int>
+  {
+    typedef long long int IndexType;
+    static IndexType run( _MKL_DSS_HANDLE_t pt, IndexType maxfct, IndexType mnum, IndexType type, IndexType phase, IndexType n, void *a,
+                      IndexType *ia, IndexType *ja, IndexType *perm, IndexType nrhs, IndexType *iparm, IndexType msglvl, void *b, void *x)
+    {
+      IndexType error = 0;
+      ::pardiso_64(pt, &maxfct, &mnum, &type, &phase, &n, a, ia, ja, perm, &nrhs, iparm, &msglvl, b, x, &error);
+      return error;
+    }
+  };
+
+  template<class Pardiso> struct pardiso_traits;
+
+  template<typename _MatrixType>
+  struct pardiso_traits< PardisoLU<_MatrixType> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pardiso_traits< PardisoLLT<_MatrixType, Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pardiso_traits< PardisoLDLT<_MatrixType, Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;    
+  };
+
+} // end namespace internal
+
+template<class Derived>
+class PardisoImpl : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+    
+    typedef internal::pardiso_traits<Derived> Traits;
+  public:
+    using Base::_solve_impl;
+    
+    typedef typename Traits::MatrixType MatrixType;
+    typedef typename Traits::Scalar Scalar;
+    typedef typename Traits::RealScalar RealScalar;
+    typedef typename Traits::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,RowMajor,StorageIndex> SparseMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef Matrix<StorageIndex, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<StorageIndex, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
+    typedef Array<StorageIndex,64,1,DontAlign> ParameterType;
+    enum {
+      ScalarIsComplex = NumTraits<Scalar>::IsComplex,
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+
+    PardisoImpl()
+      : m_analysisIsOk(false), m_factorizationIsOk(false)
+    {
+      eigen_assert((sizeof(StorageIndex) >= sizeof(_INTEGER_t) && sizeof(StorageIndex) <= 8) && "Non-supported index type");
+      m_iparm.setZero();
+      m_msglvl = 0; // No output
+      m_isInitialized = false;
+    }
+
+    ~PardisoImpl()
+    {
+      pardisoRelease();
+    }
+
+    inline Index cols() const { return m_size; }
+    inline Index rows() const { return m_size; }
+  
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    /** \warning for advanced usage only.
+      * \returns a reference to the parameter array controlling PARDISO.
+      * See the PARDISO manual to know how to use it. */
+    ParameterType& pardisoParameterArray()
+    {
+      return m_iparm;
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    Derived& analyzePattern(const MatrixType& matrix);
+    
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    Derived& factorize(const MatrixType& matrix);
+
+    Derived& compute(const MatrixType& matrix);
+
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
+
+  protected:
+    void pardisoRelease()
+    {
+      if(m_isInitialized) // Factorization ran at least once
+      {
+        internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, -1, internal::convert_index<StorageIndex>(m_size),0, 0, 0, m_perm.data(), 0,
+                                                          m_iparm.data(), m_msglvl, NULL, NULL);
+        m_isInitialized = false;
+      }
+    }
+
+    void pardisoInit(int type)
+    {
+      m_type = type;
+      bool symmetric = std::abs(m_type) < 10;
+      m_iparm[0] = 1;   // No solver default
+      m_iparm[1] = 2;   // use Metis for the ordering
+      m_iparm[2] = 0;   // Reserved. Set to zero. (??Numbers of processors, value of OMP_NUM_THREADS??)
+      m_iparm[3] = 0;   // No iterative-direct algorithm
+      m_iparm[4] = 0;   // No user fill-in reducing permutation
+      m_iparm[5] = 0;   // Write solution into x, b is left unchanged
+      m_iparm[6] = 0;   // Not in use
+      m_iparm[7] = 2;   // Max numbers of iterative refinement steps
+      m_iparm[8] = 0;   // Not in use
+      m_iparm[9] = 13;  // Perturb the pivot elements with 1E-13
+      m_iparm[10] = symmetric ? 0 : 1; // Use nonsymmetric permutation and scaling MPS
+      m_iparm[11] = 0;  // Not in use
+      m_iparm[12] = symmetric ? 0 : 1;  // Maximum weighted matching algorithm is switched-off (default for symmetric).
+                                        // Try m_iparm[12] = 1 in case of inappropriate accuracy
+      m_iparm[13] = 0;  // Output: Number of perturbed pivots
+      m_iparm[14] = 0;  // Not in use
+      m_iparm[15] = 0;  // Not in use
+      m_iparm[16] = 0;  // Not in use
+      m_iparm[17] = -1; // Output: Number of nonzeros in the factor LU
+      m_iparm[18] = -1; // Output: Mflops for LU factorization
+      m_iparm[19] = 0;  // Output: Numbers of CG Iterations
+      
+      m_iparm[20] = 0;  // 1x1 pivoting
+      m_iparm[26] = 0;  // No matrix checker
+      m_iparm[27] = (sizeof(RealScalar) == 4) ? 1 : 0;
+      m_iparm[34] = 1;  // C indexing
+      m_iparm[36] = 0;  // CSR
+      m_iparm[59] = 0;  // 0 - In-Core ; 1 - Automatic switch between In-Core and Out-of-Core modes ; 2 - Out-of-Core
+      
+      memset(m_pt, 0, sizeof(m_pt));
+    }
+
+  protected:
+    // cached data to reduce reallocation, etc.
+    
+    void manageErrorCode(Index error) const
+    {
+      switch(error)
+      {
+        case 0:
+          m_info = Success;
+          break;
+        case -4:
+        case -7:
+          m_info = NumericalIssue;
+          break;
+        default:
+          m_info = InvalidInput;
+      }
+    }
+
+    mutable SparseMatrixType m_matrix;
+    mutable ComputationInfo m_info;
+    bool m_analysisIsOk, m_factorizationIsOk;
+    StorageIndex m_type, m_msglvl;
+    mutable void *m_pt[64];
+    mutable ParameterType m_iparm;
+    mutable IntColVectorType m_perm;
+    Index m_size;
+    
+};
+
+template<class Derived>
+Derived& PardisoImpl<Derived>::compute(const MatrixType& a)
+{
+  m_size = a.rows();
+  eigen_assert(a.rows() == a.cols());
+
+  pardisoRelease();
+  m_perm.setZero(m_size);
+  derived().getMatrix(a);
+  
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 12, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+  manageErrorCode(error);
+  m_analysisIsOk = true;
+  m_factorizationIsOk = true;
+  m_isInitialized = true;
+  return derived();
+}
+
+template<class Derived>
+Derived& PardisoImpl<Derived>::analyzePattern(const MatrixType& a)
+{
+  m_size = a.rows();
+  eigen_assert(m_size == a.cols());
+
+  pardisoRelease();
+  m_perm.setZero(m_size);
+  derived().getMatrix(a);
+  
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 11, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+  
+  manageErrorCode(error);
+  m_analysisIsOk = true;
+  m_factorizationIsOk = false;
+  m_isInitialized = true;
+  return derived();
+}
+
+template<class Derived>
+Derived& PardisoImpl<Derived>::factorize(const MatrixType& a)
+{
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  eigen_assert(m_size == a.rows() && m_size == a.cols());
+  
+  derived().getMatrix(a);
+
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 22, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+  
+  manageErrorCode(error);
+  m_factorizationIsOk = true;
+  return derived();
+}
+
+template<class Derived>
+template<typename BDerived,typename XDerived>
+void PardisoImpl<Derived>::_solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived>& x) const
+{
+  if(m_iparm[0] == 0) // Factorization was not computed
+  {
+    m_info = InvalidInput;
+    return;
+  }
+
+  //Index n = m_matrix.rows();
+  Index nrhs = Index(b.cols());
+  eigen_assert(m_size==b.rows());
+  eigen_assert(((MatrixBase<BDerived>::Flags & RowMajorBit) == 0 || nrhs == 1) && "Row-major right hand sides are not supported");
+  eigen_assert(((MatrixBase<XDerived>::Flags & RowMajorBit) == 0 || nrhs == 1) && "Row-major matrices of unknowns are not supported");
+  eigen_assert(((nrhs == 1) || b.outerStride() == b.rows()));
+
+
+//  switch (transposed) {
+//    case SvNoTrans    : m_iparm[11] = 0 ; break;
+//    case SvTranspose  : m_iparm[11] = 2 ; break;
+//    case SvAdjoint    : m_iparm[11] = 1 ; break;
+//    default:
+//      //std::cerr << "Eigen: transposition  option \"" << transposed << "\" not supported by the PARDISO backend\n";
+//      m_iparm[11] = 0;
+//  }
+
+  Scalar* rhs_ptr = const_cast<Scalar*>(b.derived().data());
+  Matrix<Scalar,Dynamic,Dynamic,ColMajor> tmp;
+  
+  // Pardiso cannot solve in-place
+  if(rhs_ptr == x.derived().data())
+  {
+    tmp = b;
+    rhs_ptr = tmp.data();
+  }
+  
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 33, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), internal::convert_index<StorageIndex>(nrhs), m_iparm.data(), m_msglvl,
+                                                            rhs_ptr, x.derived().data());
+
+  manageErrorCode(error);
+}
+
+
+/** \ingroup PardisoSupport_Module
+  * \class PardisoLU
+  * \brief A sparse direct LU factorization and solver based on the PARDISO library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a direct LU factorization
+  * using the Intel MKL PARDISO library. The sparse matrix A must be squared and invertible.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:
+  * \code solver.pardisoParameterArray()[59] = 1; \endcode
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  */
+template<typename MatrixType>
+class PardisoLU : public PardisoImpl< PardisoLU<MatrixType> >
+{
+  protected:
+    typedef PardisoImpl<PardisoLU> Base;
+    using Base::pardisoInit;
+    using Base::m_matrix;
+    friend class PardisoImpl< PardisoLU<MatrixType> >;
+
+  public:
+
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+
+    using Base::compute;
+    using Base::solve;
+
+    PardisoLU()
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 13 : 11);
+    }
+
+    explicit PardisoLU(const MatrixType& matrix)
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 13 : 11);
+      compute(matrix);
+    }
+  protected:
+    void getMatrix(const MatrixType& matrix)
+    {
+      m_matrix = matrix;
+      m_matrix.makeCompressed();
+    }
+};
+
+/** \ingroup PardisoSupport_Module
+  * \class PardisoLLT
+  * \brief A sparse direct Cholesky (LLT) factorization and solver based on the PARDISO library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LL^T Cholesky factorization
+  * using the Intel MKL PARDISO library. The sparse matrix A must be selfajoint and positive definite.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:
+  * \code solver.pardisoParameterArray()[59] = 1; \endcode
+  *
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam UpLo can be any bitwise combination of Upper, Lower. The default is Upper, meaning only the upper triangular part has to be used.
+  *         Upper|Lower can be used to tell both triangular parts can be used as input.
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLLT
+  */
+template<typename MatrixType, int _UpLo>
+class PardisoLLT : public PardisoImpl< PardisoLLT<MatrixType,_UpLo> >
+{
+  protected:
+    typedef PardisoImpl< PardisoLLT<MatrixType,_UpLo> > Base;
+    using Base::pardisoInit;
+    using Base::m_matrix;
+    friend class PardisoImpl< PardisoLLT<MatrixType,_UpLo> >;
+
+  public:
+
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    enum { UpLo = _UpLo };
+    using Base::compute;
+
+    PardisoLLT()
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 4 : 2);
+    }
+
+    explicit PardisoLLT(const MatrixType& matrix)
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 4 : 2);
+      compute(matrix);
+    }
+    
+  protected:
+    
+    void getMatrix(const MatrixType& matrix)
+    {
+      // PARDISO supports only upper, row-major matrices
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> p_null;
+      m_matrix.resize(matrix.rows(), matrix.cols());
+      m_matrix.template selfadjointView<Upper>() = matrix.template selfadjointView<UpLo>().twistedBy(p_null);
+      m_matrix.makeCompressed();
+    }
+};
+
+/** \ingroup PardisoSupport_Module
+  * \class PardisoLDLT
+  * \brief A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LDL^T Cholesky factorization
+  * using the Intel MKL PARDISO library. The sparse matrix A is assumed to be selfajoint and positive definite.
+  * For complex matrices, A can also be symmetric only, see the \a Options template parameter.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:
+  * \code solver.pardisoParameterArray()[59] = 1; \endcode
+  *
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam Options can be any bitwise combination of Upper, Lower, and Symmetric. The default is Upper, meaning only the upper triangular part has to be used.
+  *         Symmetric can be used for symmetric, non-selfadjoint complex matrices, the default being to assume a selfadjoint matrix.
+  *         Upper|Lower can be used to tell both triangular parts can be used as input.
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLDLT
+  */
+template<typename MatrixType, int Options>
+class PardisoLDLT : public PardisoImpl< PardisoLDLT<MatrixType,Options> >
+{
+  protected:
+    typedef PardisoImpl< PardisoLDLT<MatrixType,Options> > Base;
+    using Base::pardisoInit;
+    using Base::m_matrix;
+    friend class PardisoImpl< PardisoLDLT<MatrixType,Options> >;
+
+  public:
+
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    using Base::compute;
+    enum { UpLo = Options&(Upper|Lower) };
+
+    PardisoLDLT()
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? ( bool(Options&Symmetric) ? 6 : -4 ) : -2);
+    }
+
+    explicit PardisoLDLT(const MatrixType& matrix)
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? ( bool(Options&Symmetric) ? 6 : -4 ) : -2);
+      compute(matrix);
+    }
+    
+    void getMatrix(const MatrixType& matrix)
+    {
+      // PARDISO supports only upper, row-major matrices
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> p_null;
+      m_matrix.resize(matrix.rows(), matrix.cols());
+      m_matrix.template selfadjointView<Upper>() = matrix.template selfadjointView<UpLo>().twistedBy(p_null);
+      m_matrix.makeCompressed();
+    }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARDISOSUPPORT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/QR/ColPivHouseholderQR.h b/C++/yolo_bytetrack/include/Eigen/src/QR/ColPivHouseholderQR.h
new file mode 100644
index 00000000..9b677e9b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/QR/ColPivHouseholderQR.h
@@ -0,0 +1,674 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
+#define EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _MatrixType> struct traits<ColPivHouseholderQR<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+} // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  * \class ColPivHouseholderQR
+  *
+  * \brief Householder rank-revealing QR decomposition of a matrix with column-pivoting
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the QR decomposition
+  *
+  * This class performs a rank-revealing QR decomposition of a matrix \b A into matrices \b P, \b Q and \b R
+  * such that
+  * \f[
+  *  \mathbf{A} \, \mathbf{P} = \mathbf{Q} \, \mathbf{R}
+  * \f]
+  * by using Householder transformations. Here, \b P is a permutation matrix, \b Q a unitary matrix and \b R an
+  * upper triangular matrix.
+  *
+  * This decomposition performs column pivoting in order to be rank-revealing and improve
+  * numerical stability. It is slower than HouseholderQR, and faster than FullPivHouseholderQR.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::colPivHouseholderQr()
+  */
+template<typename _MatrixType> class ColPivHouseholderQR
+        : public SolverBase<ColPivHouseholderQR<_MatrixType> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<ColPivHouseholderQR> Base;
+    friend class SolverBase<ColPivHouseholderQR>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(ColPivHouseholderQR)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+    typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationType;
+    typedef typename internal::plain_row_type<MatrixType, Index>::type IntRowVectorType;
+    typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+    typedef typename internal::plain_row_type<MatrixType, RealScalar>::type RealRowVectorType;
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename HCoeffsType::ConjugateReturnType>::type> HouseholderSequenceType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+  private:
+
+    typedef typename PermutationType::StorageIndex PermIndexType;
+
+  public:
+
+    /**
+    * \brief Default Constructor.
+    *
+    * The default constructor is useful in cases in which the user intends to
+    * perform decompositions via ColPivHouseholderQR::compute(const MatrixType&).
+    */
+    ColPivHouseholderQR()
+      : m_qr(),
+        m_hCoeffs(),
+        m_colsPermutation(),
+        m_colsTranspositions(),
+        m_temp(),
+        m_colNormsUpdated(),
+        m_colNormsDirect(),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa ColPivHouseholderQR()
+      */
+    ColPivHouseholderQR(Index rows, Index cols)
+      : m_qr(rows, cols),
+        m_hCoeffs((std::min)(rows,cols)),
+        m_colsPermutation(PermIndexType(cols)),
+        m_colsTranspositions(cols),
+        m_temp(cols),
+        m_colNormsUpdated(cols),
+        m_colNormsDirect(cols),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This constructor computes the QR factorization of the matrix \a matrix by calling
+      * the method compute(). It is a short cut for:
+      *
+      * \code
+      * ColPivHouseholderQR<MatrixType> qr(matrix.rows(), matrix.cols());
+      * qr.compute(matrix);
+      * \endcode
+      *
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit ColPivHouseholderQR(const EigenBase<InputType>& matrix)
+      : m_qr(matrix.rows(), matrix.cols()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_colsPermutation(PermIndexType(matrix.cols())),
+        m_colsTranspositions(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_colNormsUpdated(matrix.cols()),
+        m_colNormsDirect(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa ColPivHouseholderQR(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit ColPivHouseholderQR(EigenBase<InputType>& matrix)
+      : m_qr(matrix.derived()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_colsPermutation(PermIndexType(matrix.cols())),
+        m_colsTranspositions(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_colNormsUpdated(matrix.cols()),
+        m_colNormsDirect(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      computeInPlace();
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** This method finds a solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the QR decomposition, if any exists.
+      *
+      * \param b the right-hand-side of the equation to solve.
+      *
+      * \returns a solution.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      *
+      * Example: \include ColPivHouseholderQR_solve.cpp
+      * Output: \verbinclude ColPivHouseholderQR_solve.out
+      */
+    template<typename Rhs>
+    inline const Solve<ColPivHouseholderQR, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    HouseholderSequenceType householderQ() const;
+    HouseholderSequenceType matrixQ() const
+    {
+      return householderQ();
+    }
+
+    /** \returns a reference to the matrix where the Householder QR decomposition is stored
+      */
+    const MatrixType& matrixQR() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_qr;
+    }
+
+    /** \returns a reference to the matrix where the result Householder QR is stored
+     * \warning The strict lower part of this matrix contains internal values.
+     * Only the upper triangular part should be referenced. To get it, use
+     * \code matrixR().template triangularView<Upper>() \endcode
+     * For rank-deficient matrices, use
+     * \code
+     * matrixR().topLeftCorner(rank(), rank()).template triangularView<Upper>()
+     * \endcode
+     */
+    const MatrixType& matrixR() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_qr;
+    }
+
+    template<typename InputType>
+    ColPivHouseholderQR& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns a const reference to the column permutation matrix */
+    const PermutationType& colsPermutation() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_colsPermutation;
+    }
+
+    /** \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar absDeterminant() const;
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's inherent
+      * to determinant computation.
+      *
+      * \sa absDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar logAbsDeterminant() const;
+
+    /** \returns the rank of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index rank() const
+    {
+      using std::abs;
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
+      Index result = 0;
+      for(Index i = 0; i < m_nonzero_pivots; ++i)
+        result += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);
+      return result;
+    }
+
+    /** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index dimensionOfKernel() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return cols() - rank();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents an injective
+      *          linear map, i.e. has trivial kernel; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInjective() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return rank() == cols();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents a surjective
+      *          linear map; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isSurjective() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return rank() == rows();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition is invertible.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInvertible() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return isInjective() && isSurjective();
+    }
+
+    /** \returns the inverse of the matrix of which *this is the QR decomposition.
+      *
+      * \note If this matrix is not invertible, the returned matrix has undefined coefficients.
+      *       Use isInvertible() to first determine whether this matrix is invertible.
+      */
+    inline const Inverse<ColPivHouseholderQR> inverse() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return Inverse<ColPivHouseholderQR>(*this);
+    }
+
+    inline Index rows() const { return m_qr.rows(); }
+    inline Index cols() const { return m_qr.cols(); }
+
+    /** \returns a const reference to the vector of Householder coefficients used to represent the factor \c Q.
+      *
+      * For advanced uses only.
+      */
+    const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
+
+    /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
+      * who need to determine when pivots are to be considered nonzero. This is not used for the
+      * QR decomposition itself.
+      *
+      * When it needs to get the threshold value, Eigen calls threshold(). By default, this
+      * uses a formula to automatically determine a reasonable threshold.
+      * Once you have called the present method setThreshold(const RealScalar&),
+      * your value is used instead.
+      *
+      * \param threshold The new value to use as the threshold.
+      *
+      * A pivot will be considered nonzero if its absolute value is strictly greater than
+      *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+      * where maxpivot is the biggest pivot.
+      *
+      * If you want to come back to the default behavior, call setThreshold(Default_t)
+      */
+    ColPivHouseholderQR& setThreshold(const RealScalar& threshold)
+    {
+      m_usePrescribedThreshold = true;
+      m_prescribedThreshold = threshold;
+      return *this;
+    }
+
+    /** Allows to come back to the default behavior, letting Eigen use its default formula for
+      * determining the threshold.
+      *
+      * You should pass the special object Eigen::Default as parameter here.
+      * \code qr.setThreshold(Eigen::Default); \endcode
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    ColPivHouseholderQR& setThreshold(Default_t)
+    {
+      m_usePrescribedThreshold = false;
+      return *this;
+    }
+
+    /** Returns the threshold that will be used by certain methods such as rank().
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    RealScalar threshold() const
+    {
+      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+      return m_usePrescribedThreshold ? m_prescribedThreshold
+      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
+      // and turns out to be identical to Higham's formula used already in LDLt.
+                                      : NumTraits<Scalar>::epsilon() * RealScalar(m_qr.diagonalSize());
+    }
+
+    /** \returns the number of nonzero pivots in the QR decomposition.
+      * Here nonzero is meant in the exact sense, not in a fuzzy sense.
+      * So that notion isn't really intrinsically interesting, but it is
+      * still useful when implementing algorithms.
+      *
+      * \sa rank()
+      */
+    inline Index nonzeroPivots() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_nonzero_pivots;
+    }
+
+    /** \returns the absolute value of the biggest pivot, i.e. the biggest
+      *          diagonal coefficient of R.
+      */
+    RealScalar maxPivot() const { return m_maxpivot; }
+
+    /** \brief Reports whether the QR factorization was successful.
+      *
+      * \note This function always returns \c Success. It is provided for compatibility
+      * with other factorization routines.
+      * \returns \c Success
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return Success;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    friend class CompleteOrthogonalDecomposition<MatrixType>;
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_qr;
+    HCoeffsType m_hCoeffs;
+    PermutationType m_colsPermutation;
+    IntRowVectorType m_colsTranspositions;
+    RowVectorType m_temp;
+    RealRowVectorType m_colNormsUpdated;
+    RealRowVectorType m_colNormsDirect;
+    bool m_isInitialized, m_usePrescribedThreshold;
+    RealScalar m_prescribedThreshold, m_maxpivot;
+    Index m_nonzero_pivots;
+    Index m_det_pq;
+};
+
+template<typename MatrixType>
+typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::absDeterminant() const
+{
+  using std::abs;
+  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return abs(m_qr.diagonal().prod());
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::logAbsDeterminant() const
+{
+  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return m_qr.diagonal().cwiseAbs().array().log().sum();
+}
+
+/** Performs the QR factorization of the given matrix \a matrix. The result of
+  * the factorization is stored into \c *this, and a reference to \c *this
+  * is returned.
+  *
+  * \sa class ColPivHouseholderQR, ColPivHouseholderQR(const MatrixType&)
+  */
+template<typename MatrixType>
+template<typename InputType>
+ColPivHouseholderQR<MatrixType>& ColPivHouseholderQR<MatrixType>::compute(const EigenBase<InputType>& matrix)
+{
+  m_qr = matrix.derived();
+  computeInPlace();
+  return *this;
+}
+
+template<typename MatrixType>
+void ColPivHouseholderQR<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  // the column permutation is stored as int indices, so just to be sure:
+  eigen_assert(m_qr.cols()<=NumTraits<int>::highest());
+
+  using std::abs;
+
+  Index rows = m_qr.rows();
+  Index cols = m_qr.cols();
+  Index size = m_qr.diagonalSize();
+
+  m_hCoeffs.resize(size);
+
+  m_temp.resize(cols);
+
+  m_colsTranspositions.resize(m_qr.cols());
+  Index number_of_transpositions = 0;
+
+  m_colNormsUpdated.resize(cols);
+  m_colNormsDirect.resize(cols);
+  for (Index k = 0; k < cols; ++k) {
+    // colNormsDirect(k) caches the most recent directly computed norm of
+    // column k.
+    m_colNormsDirect.coeffRef(k) = m_qr.col(k).norm();
+    m_colNormsUpdated.coeffRef(k) = m_colNormsDirect.coeffRef(k);
+  }
+
+  RealScalar threshold_helper =  numext::abs2<RealScalar>(m_colNormsUpdated.maxCoeff() * NumTraits<RealScalar>::epsilon()) / RealScalar(rows);
+  RealScalar norm_downdate_threshold = numext::sqrt(NumTraits<RealScalar>::epsilon());
+
+  m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case)
+  m_maxpivot = RealScalar(0);
+
+  for(Index k = 0; k < size; ++k)
+  {
+    // first, we look up in our table m_colNormsUpdated which column has the biggest norm
+    Index biggest_col_index;
+    RealScalar biggest_col_sq_norm = numext::abs2(m_colNormsUpdated.tail(cols-k).maxCoeff(&biggest_col_index));
+    biggest_col_index += k;
+
+    // Track the number of meaningful pivots but do not stop the decomposition to make
+    // sure that the initial matrix is properly reproduced. See bug 941.
+    if(m_nonzero_pivots==size && biggest_col_sq_norm < threshold_helper * RealScalar(rows-k))
+      m_nonzero_pivots = k;
+
+    // apply the transposition to the columns
+    m_colsTranspositions.coeffRef(k) = biggest_col_index;
+    if(k != biggest_col_index) {
+      m_qr.col(k).swap(m_qr.col(biggest_col_index));
+      std::swap(m_colNormsUpdated.coeffRef(k), m_colNormsUpdated.coeffRef(biggest_col_index));
+      std::swap(m_colNormsDirect.coeffRef(k), m_colNormsDirect.coeffRef(biggest_col_index));
+      ++number_of_transpositions;
+    }
+
+    // generate the householder vector, store it below the diagonal
+    RealScalar beta;
+    m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);
+
+    // apply the householder transformation to the diagonal coefficient
+    m_qr.coeffRef(k,k) = beta;
+
+    // remember the maximum absolute value of diagonal coefficients
+    if(abs(beta) > m_maxpivot) m_maxpivot = abs(beta);
+
+    // apply the householder transformation
+    m_qr.bottomRightCorner(rows-k, cols-k-1)
+        .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));
+
+    // update our table of norms of the columns
+    for (Index j = k + 1; j < cols; ++j) {
+      // The following implements the stable norm downgrade step discussed in
+      // http://www.netlib.org/lapack/lawnspdf/lawn176.pdf
+      // and used in LAPACK routines xGEQPF and xGEQP3.
+      // See lines 278-297 in http://www.netlib.org/lapack/explore-html/dc/df4/sgeqpf_8f_source.html
+      if (m_colNormsUpdated.coeffRef(j) != RealScalar(0)) {
+        RealScalar temp = abs(m_qr.coeffRef(k, j)) / m_colNormsUpdated.coeffRef(j);
+        temp = (RealScalar(1) + temp) * (RealScalar(1) - temp);
+        temp = temp <  RealScalar(0) ? RealScalar(0) : temp;
+        RealScalar temp2 = temp * numext::abs2<RealScalar>(m_colNormsUpdated.coeffRef(j) /
+                                                           m_colNormsDirect.coeffRef(j));
+        if (temp2 <= norm_downdate_threshold) {
+          // The updated norm has become too inaccurate so re-compute the column
+          // norm directly.
+          m_colNormsDirect.coeffRef(j) = m_qr.col(j).tail(rows - k - 1).norm();
+          m_colNormsUpdated.coeffRef(j) = m_colNormsDirect.coeffRef(j);
+        } else {
+          m_colNormsUpdated.coeffRef(j) *= numext::sqrt(temp);
+        }
+      }
+    }
+  }
+
+  m_colsPermutation.setIdentity(PermIndexType(cols));
+  for(PermIndexType k = 0; k < size/*m_nonzero_pivots*/; ++k)
+    m_colsPermutation.applyTranspositionOnTheRight(k, PermIndexType(m_colsTranspositions.coeff(k)));
+
+  m_det_pq = (number_of_transpositions%2) ? -1 : 1;
+  m_isInitialized = true;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void ColPivHouseholderQR<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  const Index nonzero_pivots = nonzeroPivots();
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs);
+
+  c.applyOnTheLeft(householderQ().setLength(nonzero_pivots).adjoint() );
+
+  m_qr.topLeftCorner(nonzero_pivots, nonzero_pivots)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(nonzero_pivots));
+
+  for(Index i = 0; i < nonzero_pivots; ++i) dst.row(m_colsPermutation.indices().coeff(i)) = c.row(i);
+  for(Index i = nonzero_pivots; i < cols(); ++i) dst.row(m_colsPermutation.indices().coeff(i)).setZero();
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void ColPivHouseholderQR<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  const Index nonzero_pivots = nonzeroPivots();
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(m_colsPermutation.transpose()*rhs);
+
+  m_qr.topLeftCorner(nonzero_pivots, nonzero_pivots)
+        .template triangularView<Upper>()
+        .transpose().template conjugateIf<Conjugate>()
+        .solveInPlace(c.topRows(nonzero_pivots));
+
+  dst.topRows(nonzero_pivots) = c.topRows(nonzero_pivots);
+  dst.bottomRows(rows()-nonzero_pivots).setZero();
+
+  dst.applyOnTheLeft(householderQ().setLength(nonzero_pivots).template conjugateIf<!Conjugate>() );
+}
+#endif
+
+namespace internal {
+
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<ColPivHouseholderQR<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename ColPivHouseholderQR<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef ColPivHouseholderQR<MatrixType> QrType;
+  typedef Inverse<QrType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename QrType::Scalar> &)
+  {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+
+} // end namespace internal
+
+/** \returns the matrix Q as a sequence of householder transformations.
+  * You can extract the meaningful part only by using:
+  * \code qr.householderQ().setLength(qr.nonzeroPivots()) \endcode*/
+template<typename MatrixType>
+typename ColPivHouseholderQR<MatrixType>::HouseholderSequenceType ColPivHouseholderQR<MatrixType>
+  ::householderQ() const
+{
+  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+  return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate());
+}
+
+/** \return the column-pivoting Householder QR decomposition of \c *this.
+  *
+  * \sa class ColPivHouseholderQR
+  */
+template<typename Derived>
+const ColPivHouseholderQR<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::colPivHouseholderQr() const
+{
+  return ColPivHouseholderQR<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h b/C++/yolo_bytetrack/include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
new file mode 100644
index 00000000..4e9651f8
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
@@ -0,0 +1,97 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Householder QR decomposition of a matrix with column pivoting based on
+ *    LAPACKE_?geqp3 function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
+#define EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_QR_COLPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX, EIGCOLROW, LAPACKE_COLROW) \
+template<> template<typename InputType> inline \
+ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >& \
+ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >::compute( \
+              const EigenBase<InputType>& matrix) \
+\
+{ \
+  using std::abs; \
+  typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> MatrixType; \
+  typedef MatrixType::RealScalar RealScalar; \
+  Index rows = matrix.rows();\
+  Index cols = matrix.cols();\
+\
+  m_qr = matrix;\
+  Index size = m_qr.diagonalSize();\
+  m_hCoeffs.resize(size);\
+\
+  m_colsTranspositions.resize(cols);\
+  /*Index number_of_transpositions = 0;*/ \
+\
+  m_nonzero_pivots = 0; \
+  m_maxpivot = RealScalar(0);\
+  m_colsPermutation.resize(cols); \
+  m_colsPermutation.indices().setZero(); \
+\
+  lapack_int lda = internal::convert_index<lapack_int,Index>(m_qr.outerStride()); \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  LAPACKE_##LAPACKE_PREFIX##geqp3( matrix_order, internal::convert_index<lapack_int,Index>(rows), internal::convert_index<lapack_int,Index>(cols), \
+                              (LAPACKE_TYPE*)m_qr.data(), lda, (lapack_int*)m_colsPermutation.indices().data(), (LAPACKE_TYPE*)m_hCoeffs.data()); \
+  m_isInitialized = true; \
+  m_maxpivot=m_qr.diagonal().cwiseAbs().maxCoeff(); \
+  m_hCoeffs.adjointInPlace(); \
+  RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold(); \
+  lapack_int *perm = m_colsPermutation.indices().data(); \
+  for(Index i=0;i<size;i++) { \
+    m_nonzero_pivots += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);\
+  } \
+  for(Index i=0;i<cols;i++) perm[i]--;\
+\
+  /*m_det_pq = (number_of_transpositions%2) ? -1 : 1;  // TODO: It's not needed now; fix upon availability in Eigen */ \
+\
+  return *this; \
+}
+
+EIGEN_LAPACKE_QR_COLPIV(double,   double,        d, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(float,    float,         s, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(dcomplex, lapack_complex_double, z, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(scomplex, lapack_complex_float,  c, ColMajor, LAPACK_COL_MAJOR)
+
+EIGEN_LAPACKE_QR_COLPIV(double,   double,        d, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(float,    float,         s, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(dcomplex, lapack_complex_double, z, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(scomplex, lapack_complex_float,  c, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/QR/CompleteOrthogonalDecomposition.h b/C++/yolo_bytetrack/include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
new file mode 100644
index 00000000..486d3373
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
@@ -0,0 +1,635 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Rasmus Munk Larsen <rmlarsen@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
+#define EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
+
+namespace Eigen {
+
+namespace internal {
+template <typename _MatrixType>
+struct traits<CompleteOrthogonalDecomposition<_MatrixType> >
+    : traits<_MatrixType> {
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+}  // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  * \class CompleteOrthogonalDecomposition
+  *
+  * \brief Complete orthogonal decomposition (COD) of a matrix.
+  *
+  * \param MatrixType the type of the matrix of which we are computing the COD.
+  *
+  * This class performs a rank-revealing complete orthogonal decomposition of a
+  * matrix  \b A into matrices \b P, \b Q, \b T, and \b Z such that
+  * \f[
+  *  \mathbf{A} \, \mathbf{P} = \mathbf{Q} \,
+  *                     \begin{bmatrix} \mathbf{T} &  \mathbf{0} \\
+  *                                     \mathbf{0} & \mathbf{0} \end{bmatrix} \, \mathbf{Z}
+  * \f]
+  * by using Householder transformations. Here, \b P is a permutation matrix,
+  * \b Q and \b Z are unitary matrices and \b T an upper triangular matrix of
+  * size rank-by-rank. \b A may be rank deficient.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::completeOrthogonalDecomposition()
+  */
+template <typename _MatrixType> class CompleteOrthogonalDecomposition
+          : public SolverBase<CompleteOrthogonalDecomposition<_MatrixType> >
+{
+ public:
+  typedef _MatrixType MatrixType;
+  typedef SolverBase<CompleteOrthogonalDecomposition> Base;
+
+  template<typename Derived>
+  friend struct internal::solve_assertion;
+
+  EIGEN_GENERIC_PUBLIC_INTERFACE(CompleteOrthogonalDecomposition)
+  enum {
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+  };
+  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+  typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime>
+      PermutationType;
+  typedef typename internal::plain_row_type<MatrixType, Index>::type
+      IntRowVectorType;
+  typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+  typedef typename internal::plain_row_type<MatrixType, RealScalar>::type
+      RealRowVectorType;
+  typedef HouseholderSequence<
+      MatrixType, typename internal::remove_all<
+                      typename HCoeffsType::ConjugateReturnType>::type>
+      HouseholderSequenceType;
+  typedef typename MatrixType::PlainObject PlainObject;
+
+ private:
+  typedef typename PermutationType::Index PermIndexType;
+
+ public:
+  /**
+   * \brief Default Constructor.
+   *
+   * The default constructor is useful in cases in which the user intends to
+   * perform decompositions via
+   * \c CompleteOrthogonalDecomposition::compute(const* MatrixType&).
+   */
+  CompleteOrthogonalDecomposition() : m_cpqr(), m_zCoeffs(), m_temp() {}
+
+  /** \brief Default Constructor with memory preallocation
+   *
+   * Like the default constructor but with preallocation of the internal data
+   * according to the specified problem \a size.
+   * \sa CompleteOrthogonalDecomposition()
+   */
+  CompleteOrthogonalDecomposition(Index rows, Index cols)
+      : m_cpqr(rows, cols), m_zCoeffs((std::min)(rows, cols)), m_temp(cols) {}
+
+  /** \brief Constructs a complete orthogonal decomposition from a given
+   * matrix.
+   *
+   * This constructor computes the complete orthogonal decomposition of the
+   * matrix \a matrix by calling the method compute(). The default
+   * threshold for rank determination will be used. It is a short cut for:
+   *
+   * \code
+   * CompleteOrthogonalDecomposition<MatrixType> cod(matrix.rows(),
+   *                                                 matrix.cols());
+   * cod.setThreshold(Default);
+   * cod.compute(matrix);
+   * \endcode
+   *
+   * \sa compute()
+   */
+  template <typename InputType>
+  explicit CompleteOrthogonalDecomposition(const EigenBase<InputType>& matrix)
+      : m_cpqr(matrix.rows(), matrix.cols()),
+        m_zCoeffs((std::min)(matrix.rows(), matrix.cols())),
+        m_temp(matrix.cols())
+  {
+    compute(matrix.derived());
+  }
+
+  /** \brief Constructs a complete orthogonal decomposition from a given matrix
+    *
+    * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+    *
+    * \sa CompleteOrthogonalDecomposition(const EigenBase&)
+    */
+  template<typename InputType>
+  explicit CompleteOrthogonalDecomposition(EigenBase<InputType>& matrix)
+    : m_cpqr(matrix.derived()),
+      m_zCoeffs((std::min)(matrix.rows(), matrix.cols())),
+      m_temp(matrix.cols())
+  {
+    computeInPlace();
+  } 
+
+  #ifdef EIGEN_PARSED_BY_DOXYGEN
+  /** This method computes the minimum-norm solution X to a least squares
+   * problem \f[\mathrm{minimize} \|A X - B\|, \f] where \b A is the matrix of
+   * which \c *this is the complete orthogonal decomposition.
+   *
+   * \param b the right-hand sides of the problem to solve.
+   *
+   * \returns a solution.
+   *
+   */
+  template <typename Rhs>
+  inline const Solve<CompleteOrthogonalDecomposition, Rhs> solve(
+      const MatrixBase<Rhs>& b) const;
+  #endif
+
+  HouseholderSequenceType householderQ(void) const;
+  HouseholderSequenceType matrixQ(void) const { return m_cpqr.householderQ(); }
+
+  /** \returns the matrix \b Z.
+   */
+  MatrixType matrixZ() const {
+    MatrixType Z = MatrixType::Identity(m_cpqr.cols(), m_cpqr.cols());
+    applyZOnTheLeftInPlace<false>(Z);
+    return Z;
+  }
+
+  /** \returns a reference to the matrix where the complete orthogonal
+   * decomposition is stored
+   */
+  const MatrixType& matrixQTZ() const { return m_cpqr.matrixQR(); }
+
+  /** \returns a reference to the matrix where the complete orthogonal
+   * decomposition is stored.
+   * \warning The strict lower part and \code cols() - rank() \endcode right
+   * columns of this matrix contains internal values.
+   * Only the upper triangular part should be referenced. To get it, use
+   * \code matrixT().template triangularView<Upper>() \endcode
+   * For rank-deficient matrices, use
+   * \code
+   * matrixR().topLeftCorner(rank(), rank()).template triangularView<Upper>()
+   * \endcode
+   */
+  const MatrixType& matrixT() const { return m_cpqr.matrixQR(); }
+
+  template <typename InputType>
+  CompleteOrthogonalDecomposition& compute(const EigenBase<InputType>& matrix) {
+    // Compute the column pivoted QR factorization A P = Q R.
+    m_cpqr.compute(matrix);
+    computeInPlace();
+    return *this;
+  }
+
+  /** \returns a const reference to the column permutation matrix */
+  const PermutationType& colsPermutation() const {
+    return m_cpqr.colsPermutation();
+  }
+
+  /** \returns the absolute value of the determinant of the matrix of which
+   * *this is the complete orthogonal decomposition. It has only linear
+   * complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the complete orthogonal decomposition has already been computed.
+   *
+   * \note This is only for square matrices.
+   *
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() instead.
+   *
+   * \sa logAbsDeterminant(), MatrixBase::determinant()
+   */
+  typename MatrixType::RealScalar absDeterminant() const;
+
+  /** \returns the natural log of the absolute value of the determinant of the
+   * matrix of which *this is the complete orthogonal decomposition. It has
+   * only linear complexity (that is, O(n) where n is the dimension of the
+   * square matrix) as the complete orthogonal decomposition has already been
+   * computed.
+   *
+   * \note This is only for square matrices.
+   *
+   * \note This method is useful to work around the risk of overflow/underflow
+   * that's inherent to determinant computation.
+   *
+   * \sa absDeterminant(), MatrixBase::determinant()
+   */
+  typename MatrixType::RealScalar logAbsDeterminant() const;
+
+  /** \returns the rank of the matrix of which *this is the complete orthogonal
+   * decomposition.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline Index rank() const { return m_cpqr.rank(); }
+
+  /** \returns the dimension of the kernel of the matrix of which *this is the
+   * complete orthogonal decomposition.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline Index dimensionOfKernel() const { return m_cpqr.dimensionOfKernel(); }
+
+  /** \returns true if the matrix of which *this is the decomposition represents
+   * an injective linear map, i.e. has trivial kernel; false otherwise.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline bool isInjective() const { return m_cpqr.isInjective(); }
+
+  /** \returns true if the matrix of which *this is the decomposition represents
+   * a surjective linear map; false otherwise.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline bool isSurjective() const { return m_cpqr.isSurjective(); }
+
+  /** \returns true if the matrix of which *this is the complete orthogonal
+   * decomposition is invertible.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline bool isInvertible() const { return m_cpqr.isInvertible(); }
+
+  /** \returns the pseudo-inverse of the matrix of which *this is the complete
+   * orthogonal decomposition.
+   * \warning: Do not compute \c this->pseudoInverse()*rhs to solve a linear systems.
+   * It is more efficient and numerically stable to call \c this->solve(rhs).
+   */
+  inline const Inverse<CompleteOrthogonalDecomposition> pseudoInverse() const
+  {
+    eigen_assert(m_cpqr.m_isInitialized && "CompleteOrthogonalDecomposition is not initialized.");
+    return Inverse<CompleteOrthogonalDecomposition>(*this);
+  }
+
+  inline Index rows() const { return m_cpqr.rows(); }
+  inline Index cols() const { return m_cpqr.cols(); }
+
+  /** \returns a const reference to the vector of Householder coefficients used
+   * to represent the factor \c Q.
+   *
+   * For advanced uses only.
+   */
+  inline const HCoeffsType& hCoeffs() const { return m_cpqr.hCoeffs(); }
+
+  /** \returns a const reference to the vector of Householder coefficients
+   * used to represent the factor \c Z.
+   *
+   * For advanced uses only.
+   */
+  const HCoeffsType& zCoeffs() const { return m_zCoeffs; }
+
+  /** Allows to prescribe a threshold to be used by certain methods, such as
+   * rank(), who need to determine when pivots are to be considered nonzero.
+   * Most be called before calling compute().
+   *
+   * When it needs to get the threshold value, Eigen calls threshold(). By
+   * default, this uses a formula to automatically determine a reasonable
+   * threshold. Once you have called the present method
+   * setThreshold(const RealScalar&), your value is used instead.
+   *
+   * \param threshold The new value to use as the threshold.
+   *
+   * A pivot will be considered nonzero if its absolute value is strictly
+   * greater than
+   *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+   * where maxpivot is the biggest pivot.
+   *
+   * If you want to come back to the default behavior, call
+   * setThreshold(Default_t)
+   */
+  CompleteOrthogonalDecomposition& setThreshold(const RealScalar& threshold) {
+    m_cpqr.setThreshold(threshold);
+    return *this;
+  }
+
+  /** Allows to come back to the default behavior, letting Eigen use its default
+   * formula for determining the threshold.
+   *
+   * You should pass the special object Eigen::Default as parameter here.
+   * \code qr.setThreshold(Eigen::Default); \endcode
+   *
+   * See the documentation of setThreshold(const RealScalar&).
+   */
+  CompleteOrthogonalDecomposition& setThreshold(Default_t) {
+    m_cpqr.setThreshold(Default);
+    return *this;
+  }
+
+  /** Returns the threshold that will be used by certain methods such as rank().
+   *
+   * See the documentation of setThreshold(const RealScalar&).
+   */
+  RealScalar threshold() const { return m_cpqr.threshold(); }
+
+  /** \returns the number of nonzero pivots in the complete orthogonal
+   * decomposition. Here nonzero is meant in the exact sense, not in a
+   * fuzzy sense. So that notion isn't really intrinsically interesting,
+   * but it is still useful when implementing algorithms.
+   *
+   * \sa rank()
+   */
+  inline Index nonzeroPivots() const { return m_cpqr.nonzeroPivots(); }
+
+  /** \returns the absolute value of the biggest pivot, i.e. the biggest
+   *          diagonal coefficient of R.
+   */
+  inline RealScalar maxPivot() const { return m_cpqr.maxPivot(); }
+
+  /** \brief Reports whether the complete orthogonal decomposition was
+   * successful.
+   *
+   * \note This function always returns \c Success. It is provided for
+   * compatibility
+   * with other factorization routines.
+   * \returns \c Success
+   */
+  ComputationInfo info() const {
+    eigen_assert(m_cpqr.m_isInitialized && "Decomposition is not initialized.");
+    return Success;
+  }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  template <typename RhsType, typename DstType>
+  void _solve_impl(const RhsType& rhs, DstType& dst) const;
+
+  template<bool Conjugate, typename RhsType, typename DstType>
+  void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+#endif
+
+ protected:
+  static void check_template_parameters() {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+  }
+
+  template<bool Transpose_, typename Rhs>
+  void _check_solve_assertion(const Rhs& b) const {
+      EIGEN_ONLY_USED_FOR_DEBUG(b);
+      eigen_assert(m_cpqr.m_isInitialized && "CompleteOrthogonalDecomposition is not initialized.");
+      eigen_assert((Transpose_?derived().cols():derived().rows())==b.rows() && "CompleteOrthogonalDecomposition::solve(): invalid number of rows of the right hand side matrix b");
+  }
+
+  void computeInPlace();
+
+  /** Overwrites \b rhs with \f$ \mathbf{Z} * \mathbf{rhs} \f$ or
+   *  \f$ \mathbf{\overline Z} * \mathbf{rhs} \f$ if \c Conjugate 
+   *  is set to \c true.
+   */
+  template <bool Conjugate, typename Rhs>
+  void applyZOnTheLeftInPlace(Rhs& rhs) const;
+
+  /** Overwrites \b rhs with \f$ \mathbf{Z}^* * \mathbf{rhs} \f$.
+   */
+  template <typename Rhs>
+  void applyZAdjointOnTheLeftInPlace(Rhs& rhs) const;
+
+  ColPivHouseholderQR<MatrixType> m_cpqr;
+  HCoeffsType m_zCoeffs;
+  RowVectorType m_temp;
+};
+
+template <typename MatrixType>
+typename MatrixType::RealScalar
+CompleteOrthogonalDecomposition<MatrixType>::absDeterminant() const {
+  return m_cpqr.absDeterminant();
+}
+
+template <typename MatrixType>
+typename MatrixType::RealScalar
+CompleteOrthogonalDecomposition<MatrixType>::logAbsDeterminant() const {
+  return m_cpqr.logAbsDeterminant();
+}
+
+/** Performs the complete orthogonal decomposition of the given matrix \a
+ * matrix. The result of the factorization is stored into \c *this, and a
+ * reference to \c *this is returned.
+ *
+ * \sa class CompleteOrthogonalDecomposition,
+ * CompleteOrthogonalDecomposition(const MatrixType&)
+ */
+template <typename MatrixType>
+void CompleteOrthogonalDecomposition<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  // the column permutation is stored as int indices, so just to be sure:
+  eigen_assert(m_cpqr.cols() <= NumTraits<int>::highest());
+
+  const Index rank = m_cpqr.rank();
+  const Index cols = m_cpqr.cols();
+  const Index rows = m_cpqr.rows();
+  m_zCoeffs.resize((std::min)(rows, cols));
+  m_temp.resize(cols);
+
+  if (rank < cols) {
+    // We have reduced the (permuted) matrix to the form
+    //   [R11 R12]
+    //   [ 0  R22]
+    // where R11 is r-by-r (r = rank) upper triangular, R12 is
+    // r-by-(n-r), and R22 is empty or the norm of R22 is negligible.
+    // We now compute the complete orthogonal decomposition by applying
+    // Householder transformations from the right to the upper trapezoidal
+    // matrix X = [R11 R12] to zero out R12 and obtain the factorization
+    // [R11 R12] = [T11 0] * Z, where T11 is r-by-r upper triangular and
+    // Z = Z(0) * Z(1) ... Z(r-1) is an n-by-n orthogonal matrix.
+    // We store the data representing Z in R12 and m_zCoeffs.
+    for (Index k = rank - 1; k >= 0; --k) {
+      if (k != rank - 1) {
+        // Given the API for Householder reflectors, it is more convenient if
+        // we swap the leading parts of columns k and r-1 (zero-based) to form
+        // the matrix X_k = [X(0:k, k), X(0:k, r:n)]
+        m_cpqr.m_qr.col(k).head(k + 1).swap(
+            m_cpqr.m_qr.col(rank - 1).head(k + 1));
+      }
+      // Construct Householder reflector Z(k) to zero out the last row of X_k,
+      // i.e. choose Z(k) such that
+      // [X(k, k), X(k, r:n)] * Z(k) = [beta, 0, .., 0].
+      RealScalar beta;
+      m_cpqr.m_qr.row(k)
+          .tail(cols - rank + 1)
+          .makeHouseholderInPlace(m_zCoeffs(k), beta);
+      m_cpqr.m_qr(k, rank - 1) = beta;
+      if (k > 0) {
+        // Apply Z(k) to the first k rows of X_k
+        m_cpqr.m_qr.topRightCorner(k, cols - rank + 1)
+            .applyHouseholderOnTheRight(
+                m_cpqr.m_qr.row(k).tail(cols - rank).adjoint(), m_zCoeffs(k),
+                &m_temp(0));
+      }
+      if (k != rank - 1) {
+        // Swap X(0:k,k) back to its proper location.
+        m_cpqr.m_qr.col(k).head(k + 1).swap(
+            m_cpqr.m_qr.col(rank - 1).head(k + 1));
+      }
+    }
+  }
+}
+
+template <typename MatrixType>
+template <bool Conjugate, typename Rhs>
+void CompleteOrthogonalDecomposition<MatrixType>::applyZOnTheLeftInPlace(
+    Rhs& rhs) const {
+  const Index cols = this->cols();
+  const Index nrhs = rhs.cols();
+  const Index rank = this->rank();
+  Matrix<typename Rhs::Scalar, Dynamic, 1> temp((std::max)(cols, nrhs));
+  for (Index k = rank-1; k >= 0; --k) {
+    if (k != rank - 1) {
+      rhs.row(k).swap(rhs.row(rank - 1));
+    }
+    rhs.middleRows(rank - 1, cols - rank + 1)
+        .applyHouseholderOnTheLeft(
+            matrixQTZ().row(k).tail(cols - rank).transpose().template conjugateIf<!Conjugate>(), zCoeffs().template conjugateIf<Conjugate>()(k),
+            &temp(0));
+    if (k != rank - 1) {
+      rhs.row(k).swap(rhs.row(rank - 1));
+    }
+  }
+}
+
+template <typename MatrixType>
+template <typename Rhs>
+void CompleteOrthogonalDecomposition<MatrixType>::applyZAdjointOnTheLeftInPlace(
+    Rhs& rhs) const {
+  const Index cols = this->cols();
+  const Index nrhs = rhs.cols();
+  const Index rank = this->rank();
+  Matrix<typename Rhs::Scalar, Dynamic, 1> temp((std::max)(cols, nrhs));
+  for (Index k = 0; k < rank; ++k) {
+    if (k != rank - 1) {
+      rhs.row(k).swap(rhs.row(rank - 1));
+    }
+    rhs.middleRows(rank - 1, cols - rank + 1)
+        .applyHouseholderOnTheLeft(
+            matrixQTZ().row(k).tail(cols - rank).adjoint(), zCoeffs()(k),
+            &temp(0));
+    if (k != rank - 1) {
+      rhs.row(k).swap(rhs.row(rank - 1));
+    }
+  }
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template <typename _MatrixType>
+template <typename RhsType, typename DstType>
+void CompleteOrthogonalDecomposition<_MatrixType>::_solve_impl(
+    const RhsType& rhs, DstType& dst) const {
+  const Index rank = this->rank();
+  if (rank == 0) {
+    dst.setZero();
+    return;
+  }
+
+  // Compute c = Q^* * rhs
+  typename RhsType::PlainObject c(rhs);
+  c.applyOnTheLeft(matrixQ().setLength(rank).adjoint());
+
+  // Solve T z = c(1:rank, :)
+  dst.topRows(rank) = matrixT()
+                          .topLeftCorner(rank, rank)
+                          .template triangularView<Upper>()
+                          .solve(c.topRows(rank));
+
+  const Index cols = this->cols();
+  if (rank < cols) {
+    // Compute y = Z^* * [ z ]
+    //                   [ 0 ]
+    dst.bottomRows(cols - rank).setZero();
+    applyZAdjointOnTheLeftInPlace(dst);
+  }
+
+  // Undo permutation to get x = P^{-1} * y.
+  dst = colsPermutation() * dst;
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void CompleteOrthogonalDecomposition<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  const Index rank = this->rank();
+
+  if (rank == 0) {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(colsPermutation().transpose()*rhs);
+
+  if (rank < cols()) {
+    applyZOnTheLeftInPlace<!Conjugate>(c);
+  }
+
+  matrixT().topLeftCorner(rank, rank)
+           .template triangularView<Upper>()
+           .transpose().template conjugateIf<Conjugate>()
+           .solveInPlace(c.topRows(rank));
+
+  dst.topRows(rank) = c.topRows(rank);
+  dst.bottomRows(rows()-rank).setZero();
+
+  dst.applyOnTheLeft(householderQ().setLength(rank).template conjugateIf<!Conjugate>() );
+}
+#endif
+
+namespace internal {
+
+template<typename MatrixType>
+struct traits<Inverse<CompleteOrthogonalDecomposition<MatrixType> > >
+  : traits<typename Transpose<typename MatrixType::PlainObject>::PlainObject>
+{
+  enum { Flags = 0 };
+};
+
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<CompleteOrthogonalDecomposition<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename CompleteOrthogonalDecomposition<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef CompleteOrthogonalDecomposition<MatrixType> CodType;
+  typedef Inverse<CodType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename CodType::Scalar> &)
+  {
+    typedef Matrix<typename CodType::Scalar, CodType::RowsAtCompileTime, CodType::RowsAtCompileTime, 0, CodType::MaxRowsAtCompileTime, CodType::MaxRowsAtCompileTime> IdentityMatrixType;
+    dst = src.nestedExpression().solve(IdentityMatrixType::Identity(src.cols(), src.cols()));
+  }
+};
+
+} // end namespace internal
+
+/** \returns the matrix Q as a sequence of householder transformations */
+template <typename MatrixType>
+typename CompleteOrthogonalDecomposition<MatrixType>::HouseholderSequenceType
+CompleteOrthogonalDecomposition<MatrixType>::householderQ() const {
+  return m_cpqr.householderQ();
+}
+
+/** \return the complete orthogonal decomposition of \c *this.
+  *
+  * \sa class CompleteOrthogonalDecomposition
+  */
+template <typename Derived>
+const CompleteOrthogonalDecomposition<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::completeOrthogonalDecomposition() const {
+  return CompleteOrthogonalDecomposition<PlainObject>(eval());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/QR/FullPivHouseholderQR.h b/C++/yolo_bytetrack/include/Eigen/src/QR/FullPivHouseholderQR.h
new file mode 100644
index 00000000..d0664a1d
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/QR/FullPivHouseholderQR.h
@@ -0,0 +1,713 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
+#define EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename _MatrixType> struct traits<FullPivHouseholderQR<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+template<typename MatrixType> struct FullPivHouseholderQRMatrixQReturnType;
+
+template<typename MatrixType>
+struct traits<FullPivHouseholderQRMatrixQReturnType<MatrixType> >
+{
+  typedef typename MatrixType::PlainObject ReturnType;
+};
+
+} // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  * \class FullPivHouseholderQR
+  *
+  * \brief Householder rank-revealing QR decomposition of a matrix with full pivoting
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the QR decomposition
+  *
+  * This class performs a rank-revealing QR decomposition of a matrix \b A into matrices \b P, \b P', \b Q and \b R
+  * such that 
+  * \f[
+  *  \mathbf{P} \, \mathbf{A} \, \mathbf{P}' = \mathbf{Q} \, \mathbf{R}
+  * \f]
+  * by using Householder transformations. Here, \b P and \b P' are permutation matrices, \b Q a unitary matrix 
+  * and \b R an upper triangular matrix.
+  *
+  * This decomposition performs a very prudent full pivoting in order to be rank-revealing and achieve optimal
+  * numerical stability. The trade-off is that it is slower than HouseholderQR and ColPivHouseholderQR.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::fullPivHouseholderQr()
+  */
+template<typename _MatrixType> class FullPivHouseholderQR
+        : public SolverBase<FullPivHouseholderQR<_MatrixType> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<FullPivHouseholderQR> Base;
+    friend class SolverBase<FullPivHouseholderQR>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(FullPivHouseholderQR)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef internal::FullPivHouseholderQRMatrixQReturnType<MatrixType> MatrixQReturnType;
+    typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+    typedef Matrix<StorageIndex, 1,
+                   EIGEN_SIZE_MIN_PREFER_DYNAMIC(ColsAtCompileTime,RowsAtCompileTime), RowMajor, 1,
+                   EIGEN_SIZE_MIN_PREFER_FIXED(MaxColsAtCompileTime,MaxRowsAtCompileTime)> IntDiagSizeVectorType;
+    typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationType;
+    typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+    typedef typename internal::plain_col_type<MatrixType>::type ColVectorType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    /** \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via FullPivHouseholderQR::compute(const MatrixType&).
+      */
+    FullPivHouseholderQR()
+      : m_qr(),
+        m_hCoeffs(),
+        m_rows_transpositions(),
+        m_cols_transpositions(),
+        m_cols_permutation(),
+        m_temp(),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa FullPivHouseholderQR()
+      */
+    FullPivHouseholderQR(Index rows, Index cols)
+      : m_qr(rows, cols),
+        m_hCoeffs((std::min)(rows,cols)),
+        m_rows_transpositions((std::min)(rows,cols)),
+        m_cols_transpositions((std::min)(rows,cols)),
+        m_cols_permutation(cols),
+        m_temp(cols),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This constructor computes the QR factorization of the matrix \a matrix by calling
+      * the method compute(). It is a short cut for:
+      * 
+      * \code
+      * FullPivHouseholderQR<MatrixType> qr(matrix.rows(), matrix.cols());
+      * qr.compute(matrix);
+      * \endcode
+      * 
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit FullPivHouseholderQR(const EigenBase<InputType>& matrix)
+      : m_qr(matrix.rows(), matrix.cols()),
+        m_hCoeffs((std::min)(matrix.rows(), matrix.cols())),
+        m_rows_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_permutation(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa FullPivHouseholderQR(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit FullPivHouseholderQR(EigenBase<InputType>& matrix)
+      : m_qr(matrix.derived()),
+        m_hCoeffs((std::min)(matrix.rows(), matrix.cols())),
+        m_rows_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_permutation(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      computeInPlace();
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** This method finds a solution x to the equation Ax=b, where A is the matrix of which
+      * \c *this is the QR decomposition.
+      *
+      * \param b the right-hand-side of the equation to solve.
+      *
+      * \returns the exact or least-square solution if the rank is greater or equal to the number of columns of A,
+      * and an arbitrary solution otherwise.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      *
+      * Example: \include FullPivHouseholderQR_solve.cpp
+      * Output: \verbinclude FullPivHouseholderQR_solve.out
+      */
+    template<typename Rhs>
+    inline const Solve<FullPivHouseholderQR, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    /** \returns Expression object representing the matrix Q
+      */
+    MatrixQReturnType matrixQ(void) const;
+
+    /** \returns a reference to the matrix where the Householder QR decomposition is stored
+      */
+    const MatrixType& matrixQR() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return m_qr;
+    }
+
+    template<typename InputType>
+    FullPivHouseholderQR& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns a const reference to the column permutation matrix */
+    const PermutationType& colsPermutation() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return m_cols_permutation;
+    }
+
+    /** \returns a const reference to the vector of indices representing the rows transpositions */
+    const IntDiagSizeVectorType& rowsTranspositions() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return m_rows_transpositions;
+    }
+
+    /** \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar absDeterminant() const;
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's inherent
+      * to determinant computation.
+      *
+      * \sa absDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar logAbsDeterminant() const;
+
+    /** \returns the rank of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index rank() const
+    {
+      using std::abs;
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
+      Index result = 0;
+      for(Index i = 0; i < m_nonzero_pivots; ++i)
+        result += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);
+      return result;
+    }
+
+    /** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index dimensionOfKernel() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return cols() - rank();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents an injective
+      *          linear map, i.e. has trivial kernel; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInjective() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return rank() == cols();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents a surjective
+      *          linear map; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isSurjective() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return rank() == rows();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition is invertible.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInvertible() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return isInjective() && isSurjective();
+    }
+
+    /** \returns the inverse of the matrix of which *this is the QR decomposition.
+      *
+      * \note If this matrix is not invertible, the returned matrix has undefined coefficients.
+      *       Use isInvertible() to first determine whether this matrix is invertible.
+      */
+    inline const Inverse<FullPivHouseholderQR> inverse() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return Inverse<FullPivHouseholderQR>(*this);
+    }
+
+    inline Index rows() const { return m_qr.rows(); }
+    inline Index cols() const { return m_qr.cols(); }
+    
+    /** \returns a const reference to the vector of Householder coefficients used to represent the factor \c Q.
+      * 
+      * For advanced uses only.
+      */
+    const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
+
+    /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
+      * who need to determine when pivots are to be considered nonzero. This is not used for the
+      * QR decomposition itself.
+      *
+      * When it needs to get the threshold value, Eigen calls threshold(). By default, this
+      * uses a formula to automatically determine a reasonable threshold.
+      * Once you have called the present method setThreshold(const RealScalar&),
+      * your value is used instead.
+      *
+      * \param threshold The new value to use as the threshold.
+      *
+      * A pivot will be considered nonzero if its absolute value is strictly greater than
+      *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+      * where maxpivot is the biggest pivot.
+      *
+      * If you want to come back to the default behavior, call setThreshold(Default_t)
+      */
+    FullPivHouseholderQR& setThreshold(const RealScalar& threshold)
+    {
+      m_usePrescribedThreshold = true;
+      m_prescribedThreshold = threshold;
+      return *this;
+    }
+
+    /** Allows to come back to the default behavior, letting Eigen use its default formula for
+      * determining the threshold.
+      *
+      * You should pass the special object Eigen::Default as parameter here.
+      * \code qr.setThreshold(Eigen::Default); \endcode
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    FullPivHouseholderQR& setThreshold(Default_t)
+    {
+      m_usePrescribedThreshold = false;
+      return *this;
+    }
+
+    /** Returns the threshold that will be used by certain methods such as rank().
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    RealScalar threshold() const
+    {
+      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+      return m_usePrescribedThreshold ? m_prescribedThreshold
+      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
+      // and turns out to be identical to Higham's formula used already in LDLt.
+                                      : NumTraits<Scalar>::epsilon() * RealScalar(m_qr.diagonalSize());
+    }
+
+    /** \returns the number of nonzero pivots in the QR decomposition.
+      * Here nonzero is meant in the exact sense, not in a fuzzy sense.
+      * So that notion isn't really intrinsically interesting, but it is
+      * still useful when implementing algorithms.
+      *
+      * \sa rank()
+      */
+    inline Index nonzeroPivots() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_nonzero_pivots;
+    }
+
+    /** \returns the absolute value of the biggest pivot, i.e. the biggest
+      *          diagonal coefficient of U.
+      */
+    RealScalar maxPivot() const { return m_maxpivot; }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_qr;
+    HCoeffsType m_hCoeffs;
+    IntDiagSizeVectorType m_rows_transpositions;
+    IntDiagSizeVectorType m_cols_transpositions;
+    PermutationType m_cols_permutation;
+    RowVectorType m_temp;
+    bool m_isInitialized, m_usePrescribedThreshold;
+    RealScalar m_prescribedThreshold, m_maxpivot;
+    Index m_nonzero_pivots;
+    RealScalar m_precision;
+    Index m_det_pq;
+};
+
+template<typename MatrixType>
+typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::absDeterminant() const
+{
+  using std::abs;
+  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return abs(m_qr.diagonal().prod());
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::logAbsDeterminant() const
+{
+  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return m_qr.diagonal().cwiseAbs().array().log().sum();
+}
+
+/** Performs the QR factorization of the given matrix \a matrix. The result of
+  * the factorization is stored into \c *this, and a reference to \c *this
+  * is returned.
+  *
+  * \sa class FullPivHouseholderQR, FullPivHouseholderQR(const MatrixType&)
+  */
+template<typename MatrixType>
+template<typename InputType>
+FullPivHouseholderQR<MatrixType>& FullPivHouseholderQR<MatrixType>::compute(const EigenBase<InputType>& matrix)
+{
+  m_qr = matrix.derived();
+  computeInPlace();
+  return *this;
+}
+
+template<typename MatrixType>
+void FullPivHouseholderQR<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  using std::abs;
+  Index rows = m_qr.rows();
+  Index cols = m_qr.cols();
+  Index size = (std::min)(rows,cols);
+
+  
+  m_hCoeffs.resize(size);
+
+  m_temp.resize(cols);
+
+  m_precision = NumTraits<Scalar>::epsilon() * RealScalar(size);
+
+  m_rows_transpositions.resize(size);
+  m_cols_transpositions.resize(size);
+  Index number_of_transpositions = 0;
+
+  RealScalar biggest(0);
+
+  m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case)
+  m_maxpivot = RealScalar(0);
+
+  for (Index k = 0; k < size; ++k)
+  {
+    Index row_of_biggest_in_corner, col_of_biggest_in_corner;
+    typedef internal::scalar_score_coeff_op<Scalar> Scoring;
+    typedef typename Scoring::result_type Score;
+
+    Score score = m_qr.bottomRightCorner(rows-k, cols-k)
+                      .unaryExpr(Scoring())
+                      .maxCoeff(&row_of_biggest_in_corner, &col_of_biggest_in_corner);
+    row_of_biggest_in_corner += k;
+    col_of_biggest_in_corner += k;
+    RealScalar biggest_in_corner = internal::abs_knowing_score<Scalar>()(m_qr(row_of_biggest_in_corner, col_of_biggest_in_corner), score);
+    if(k==0) biggest = biggest_in_corner;
+
+    // if the corner is negligible, then we have less than full rank, and we can finish early
+    if(internal::isMuchSmallerThan(biggest_in_corner, biggest, m_precision))
+    {
+      m_nonzero_pivots = k;
+      for(Index i = k; i < size; i++)
+      {
+        m_rows_transpositions.coeffRef(i) = internal::convert_index<StorageIndex>(i);
+        m_cols_transpositions.coeffRef(i) = internal::convert_index<StorageIndex>(i);
+        m_hCoeffs.coeffRef(i) = Scalar(0);
+      }
+      break;
+    }
+
+    m_rows_transpositions.coeffRef(k) = internal::convert_index<StorageIndex>(row_of_biggest_in_corner);
+    m_cols_transpositions.coeffRef(k) = internal::convert_index<StorageIndex>(col_of_biggest_in_corner);
+    if(k != row_of_biggest_in_corner) {
+      m_qr.row(k).tail(cols-k).swap(m_qr.row(row_of_biggest_in_corner).tail(cols-k));
+      ++number_of_transpositions;
+    }
+    if(k != col_of_biggest_in_corner) {
+      m_qr.col(k).swap(m_qr.col(col_of_biggest_in_corner));
+      ++number_of_transpositions;
+    }
+
+    RealScalar beta;
+    m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);
+    m_qr.coeffRef(k,k) = beta;
+
+    // remember the maximum absolute value of diagonal coefficients
+    if(abs(beta) > m_maxpivot) m_maxpivot = abs(beta);
+
+    m_qr.bottomRightCorner(rows-k, cols-k-1)
+        .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));
+  }
+
+  m_cols_permutation.setIdentity(cols);
+  for(Index k = 0; k < size; ++k)
+    m_cols_permutation.applyTranspositionOnTheRight(k, m_cols_transpositions.coeff(k));
+
+  m_det_pq = (number_of_transpositions%2) ? -1 : 1;
+  m_isInitialized = true;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void FullPivHouseholderQR<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  const Index l_rank = rank();
+
+  // FIXME introduce nonzeroPivots() and use it here. and more generally,
+  // make the same improvements in this dec as in FullPivLU.
+  if(l_rank==0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs);
+
+  Matrix<typename RhsType::Scalar,1,RhsType::ColsAtCompileTime> temp(rhs.cols());
+  for (Index k = 0; k < l_rank; ++k)
+  {
+    Index remainingSize = rows()-k;
+    c.row(k).swap(c.row(m_rows_transpositions.coeff(k)));
+    c.bottomRightCorner(remainingSize, rhs.cols())
+      .applyHouseholderOnTheLeft(m_qr.col(k).tail(remainingSize-1),
+                               m_hCoeffs.coeff(k), &temp.coeffRef(0));
+  }
+
+  m_qr.topLeftCorner(l_rank, l_rank)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(l_rank));
+
+  for(Index i = 0; i < l_rank; ++i) dst.row(m_cols_permutation.indices().coeff(i)) = c.row(i);
+  for(Index i = l_rank; i < cols(); ++i) dst.row(m_cols_permutation.indices().coeff(i)).setZero();
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void FullPivHouseholderQR<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  const Index l_rank = rank();
+
+  if(l_rank == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(m_cols_permutation.transpose()*rhs);
+
+  m_qr.topLeftCorner(l_rank, l_rank)
+         .template triangularView<Upper>()
+         .transpose().template conjugateIf<Conjugate>()
+         .solveInPlace(c.topRows(l_rank));
+
+  dst.topRows(l_rank) = c.topRows(l_rank);
+  dst.bottomRows(rows()-l_rank).setZero();
+
+  Matrix<Scalar, 1, DstType::ColsAtCompileTime> temp(dst.cols());
+  const Index size = (std::min)(rows(), cols());
+  for (Index k = size-1; k >= 0; --k)
+  {
+    Index remainingSize = rows()-k;
+
+    dst.bottomRightCorner(remainingSize, dst.cols())
+       .applyHouseholderOnTheLeft(m_qr.col(k).tail(remainingSize-1).template conjugateIf<!Conjugate>(),
+                                  m_hCoeffs.template conjugateIf<Conjugate>().coeff(k), &temp.coeffRef(0));
+
+    dst.row(k).swap(dst.row(m_rows_transpositions.coeff(k)));
+  }
+}
+#endif
+
+namespace internal {
+  
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<FullPivHouseholderQR<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename FullPivHouseholderQR<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef FullPivHouseholderQR<MatrixType> QrType;
+  typedef Inverse<QrType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename QrType::Scalar> &)
+  {    
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+
+/** \ingroup QR_Module
+  *
+  * \brief Expression type for return value of FullPivHouseholderQR::matrixQ()
+  *
+  * \tparam MatrixType type of underlying dense matrix
+  */
+template<typename MatrixType> struct FullPivHouseholderQRMatrixQReturnType
+  : public ReturnByValue<FullPivHouseholderQRMatrixQReturnType<MatrixType> >
+{
+public:
+  typedef typename FullPivHouseholderQR<MatrixType>::IntDiagSizeVectorType IntDiagSizeVectorType;
+  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+  typedef Matrix<typename MatrixType::Scalar, 1, MatrixType::RowsAtCompileTime, RowMajor, 1,
+                 MatrixType::MaxRowsAtCompileTime> WorkVectorType;
+
+  FullPivHouseholderQRMatrixQReturnType(const MatrixType&       qr,
+                                        const HCoeffsType&      hCoeffs,
+                                        const IntDiagSizeVectorType& rowsTranspositions)
+    : m_qr(qr),
+      m_hCoeffs(hCoeffs),
+      m_rowsTranspositions(rowsTranspositions)
+  {}
+
+  template <typename ResultType>
+  void evalTo(ResultType& result) const
+  {
+    const Index rows = m_qr.rows();
+    WorkVectorType workspace(rows);
+    evalTo(result, workspace);
+  }
+
+  template <typename ResultType>
+  void evalTo(ResultType& result, WorkVectorType& workspace) const
+  {
+    using numext::conj;
+    // compute the product H'_0 H'_1 ... H'_n-1,
+    // where H_k is the k-th Householder transformation I - h_k v_k v_k'
+    // and v_k is the k-th Householder vector [1,m_qr(k+1,k), m_qr(k+2,k), ...]
+    const Index rows = m_qr.rows();
+    const Index cols = m_qr.cols();
+    const Index size = (std::min)(rows, cols);
+    workspace.resize(rows);
+    result.setIdentity(rows, rows);
+    for (Index k = size-1; k >= 0; k--)
+    {
+      result.block(k, k, rows-k, rows-k)
+            .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), conj(m_hCoeffs.coeff(k)), &workspace.coeffRef(k));
+      result.row(k).swap(result.row(m_rowsTranspositions.coeff(k)));
+    }
+  }
+
+  Index rows() const { return m_qr.rows(); }
+  Index cols() const { return m_qr.rows(); }
+
+protected:
+  typename MatrixType::Nested m_qr;
+  typename HCoeffsType::Nested m_hCoeffs;
+  typename IntDiagSizeVectorType::Nested m_rowsTranspositions;
+};
+
+// template<typename MatrixType>
+// struct evaluator<FullPivHouseholderQRMatrixQReturnType<MatrixType> >
+//  : public evaluator<ReturnByValue<FullPivHouseholderQRMatrixQReturnType<MatrixType> > >
+// {};
+
+} // end namespace internal
+
+template<typename MatrixType>
+inline typename FullPivHouseholderQR<MatrixType>::MatrixQReturnType FullPivHouseholderQR<MatrixType>::matrixQ() const
+{
+  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+  return MatrixQReturnType(m_qr, m_hCoeffs, m_rows_transpositions);
+}
+
+/** \return the full-pivoting Householder QR decomposition of \c *this.
+  *
+  * \sa class FullPivHouseholderQR
+  */
+template<typename Derived>
+const FullPivHouseholderQR<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::fullPivHouseholderQr() const
+{
+  return FullPivHouseholderQR<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/QR/HouseholderQR.h b/C++/yolo_bytetrack/include/Eigen/src/QR/HouseholderQR.h
new file mode 100644
index 00000000..801739fb
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/QR/HouseholderQR.h
@@ -0,0 +1,434 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2010 Vincent Lejeune
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_QR_H
+#define EIGEN_QR_H
+
+namespace Eigen { 
+
+namespace internal {
+template<typename _MatrixType> struct traits<HouseholderQR<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+} // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  *
+  * \class HouseholderQR
+  *
+  * \brief Householder QR decomposition of a matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the QR decomposition
+  *
+  * This class performs a QR decomposition of a matrix \b A into matrices \b Q and \b R
+  * such that 
+  * \f[
+  *  \mathbf{A} = \mathbf{Q} \, \mathbf{R}
+  * \f]
+  * by using Householder transformations. Here, \b Q a unitary matrix and \b R an upper triangular matrix.
+  * The result is stored in a compact way compatible with LAPACK.
+  *
+  * Note that no pivoting is performed. This is \b not a rank-revealing decomposition.
+  * If you want that feature, use FullPivHouseholderQR or ColPivHouseholderQR instead.
+  *
+  * This Householder QR decomposition is faster, but less numerically stable and less feature-full than
+  * FullPivHouseholderQR or ColPivHouseholderQR.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * \sa MatrixBase::householderQr()
+  */
+template<typename _MatrixType> class HouseholderQR
+        : public SolverBase<HouseholderQR<_MatrixType> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<HouseholderQR> Base;
+    friend class SolverBase<HouseholderQR>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(HouseholderQR)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, (MatrixType::Flags&RowMajorBit) ? RowMajor : ColMajor, MaxRowsAtCompileTime, MaxRowsAtCompileTime> MatrixQType;
+    typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+    typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename HCoeffsType::ConjugateReturnType>::type> HouseholderSequenceType;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via HouseholderQR::compute(const MatrixType&).
+      */
+    HouseholderQR() : m_qr(), m_hCoeffs(), m_temp(), m_isInitialized(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa HouseholderQR()
+      */
+    HouseholderQR(Index rows, Index cols)
+      : m_qr(rows, cols),
+        m_hCoeffs((std::min)(rows,cols)),
+        m_temp(cols),
+        m_isInitialized(false) {}
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This constructor computes the QR factorization of the matrix \a matrix by calling
+      * the method compute(). It is a short cut for:
+      * 
+      * \code
+      * HouseholderQR<MatrixType> qr(matrix.rows(), matrix.cols());
+      * qr.compute(matrix);
+      * \endcode
+      * 
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit HouseholderQR(const EigenBase<InputType>& matrix)
+      : m_qr(matrix.rows(), matrix.cols()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_temp(matrix.cols()),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when
+      * \c MatrixType is a Eigen::Ref.
+      *
+      * \sa HouseholderQR(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit HouseholderQR(EigenBase<InputType>& matrix)
+      : m_qr(matrix.derived()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_temp(matrix.cols()),
+        m_isInitialized(false)
+    {
+      computeInPlace();
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** This method finds a solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the QR decomposition, if any exists.
+      *
+      * \param b the right-hand-side of the equation to solve.
+      *
+      * \returns a solution.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      *
+      * Example: \include HouseholderQR_solve.cpp
+      * Output: \verbinclude HouseholderQR_solve.out
+      */
+    template<typename Rhs>
+    inline const Solve<HouseholderQR, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    /** This method returns an expression of the unitary matrix Q as a sequence of Householder transformations.
+      *
+      * The returned expression can directly be used to perform matrix products. It can also be assigned to a dense Matrix object.
+      * Here is an example showing how to recover the full or thin matrix Q, as well as how to perform matrix products using operator*:
+      *
+      * Example: \include HouseholderQR_householderQ.cpp
+      * Output: \verbinclude HouseholderQR_householderQ.out
+      */
+    HouseholderSequenceType householderQ() const
+    {
+      eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+      return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate());
+    }
+
+    /** \returns a reference to the matrix where the Householder QR decomposition is stored
+      * in a LAPACK-compatible way.
+      */
+    const MatrixType& matrixQR() const
+    {
+        eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+        return m_qr;
+    }
+
+    template<typename InputType>
+    HouseholderQR& compute(const EigenBase<InputType>& matrix) {
+      m_qr = matrix.derived();
+      computeInPlace();
+      return *this;
+    }
+
+    /** \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar absDeterminant() const;
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's inherent
+      * to determinant computation.
+      *
+      * \sa absDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar logAbsDeterminant() const;
+
+    inline Index rows() const { return m_qr.rows(); }
+    inline Index cols() const { return m_qr.cols(); }
+
+    /** \returns a const reference to the vector of Householder coefficients used to represent the factor \c Q.
+      * 
+      * For advanced uses only.
+      */
+    const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_qr;
+    HCoeffsType m_hCoeffs;
+    RowVectorType m_temp;
+    bool m_isInitialized;
+};
+
+template<typename MatrixType>
+typename MatrixType::RealScalar HouseholderQR<MatrixType>::absDeterminant() const
+{
+  using std::abs;
+  eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return abs(m_qr.diagonal().prod());
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar HouseholderQR<MatrixType>::logAbsDeterminant() const
+{
+  eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return m_qr.diagonal().cwiseAbs().array().log().sum();
+}
+
+namespace internal {
+
+/** \internal */
+template<typename MatrixQR, typename HCoeffs>
+void householder_qr_inplace_unblocked(MatrixQR& mat, HCoeffs& hCoeffs, typename MatrixQR::Scalar* tempData = 0)
+{
+  typedef typename MatrixQR::Scalar Scalar;
+  typedef typename MatrixQR::RealScalar RealScalar;
+  Index rows = mat.rows();
+  Index cols = mat.cols();
+  Index size = (std::min)(rows,cols);
+
+  eigen_assert(hCoeffs.size() == size);
+
+  typedef Matrix<Scalar,MatrixQR::ColsAtCompileTime,1> TempType;
+  TempType tempVector;
+  if(tempData==0)
+  {
+    tempVector.resize(cols);
+    tempData = tempVector.data();
+  }
+
+  for(Index k = 0; k < size; ++k)
+  {
+    Index remainingRows = rows - k;
+    Index remainingCols = cols - k - 1;
+
+    RealScalar beta;
+    mat.col(k).tail(remainingRows).makeHouseholderInPlace(hCoeffs.coeffRef(k), beta);
+    mat.coeffRef(k,k) = beta;
+
+    // apply H to remaining part of m_qr from the left
+    mat.bottomRightCorner(remainingRows, remainingCols)
+        .applyHouseholderOnTheLeft(mat.col(k).tail(remainingRows-1), hCoeffs.coeffRef(k), tempData+k+1);
+  }
+}
+
+/** \internal */
+template<typename MatrixQR, typename HCoeffs,
+  typename MatrixQRScalar = typename MatrixQR::Scalar,
+  bool InnerStrideIsOne = (MatrixQR::InnerStrideAtCompileTime == 1 && HCoeffs::InnerStrideAtCompileTime == 1)>
+struct householder_qr_inplace_blocked
+{
+  // This is specialized for LAPACK-supported Scalar types in HouseholderQR_LAPACKE.h
+  static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index maxBlockSize=32,
+      typename MatrixQR::Scalar* tempData = 0)
+  {
+    typedef typename MatrixQR::Scalar Scalar;
+    typedef Block<MatrixQR,Dynamic,Dynamic> BlockType;
+
+    Index rows = mat.rows();
+    Index cols = mat.cols();
+    Index size = (std::min)(rows, cols);
+
+    typedef Matrix<Scalar,Dynamic,1,ColMajor,MatrixQR::MaxColsAtCompileTime,1> TempType;
+    TempType tempVector;
+    if(tempData==0)
+    {
+      tempVector.resize(cols);
+      tempData = tempVector.data();
+    }
+
+    Index blockSize = (std::min)(maxBlockSize,size);
+
+    Index k = 0;
+    for (k = 0; k < size; k += blockSize)
+    {
+      Index bs = (std::min)(size-k,blockSize);  // actual size of the block
+      Index tcols = cols - k - bs;              // trailing columns
+      Index brows = rows-k;                     // rows of the block
+
+      // partition the matrix:
+      //        A00 | A01 | A02
+      // mat  = A10 | A11 | A12
+      //        A20 | A21 | A22
+      // and performs the qr dec of [A11^T A12^T]^T
+      // and update [A21^T A22^T]^T using level 3 operations.
+      // Finally, the algorithm continue on A22
+
+      BlockType A11_21 = mat.block(k,k,brows,bs);
+      Block<HCoeffs,Dynamic,1> hCoeffsSegment = hCoeffs.segment(k,bs);
+
+      householder_qr_inplace_unblocked(A11_21, hCoeffsSegment, tempData);
+
+      if(tcols)
+      {
+        BlockType A21_22 = mat.block(k,k+bs,brows,tcols);
+        apply_block_householder_on_the_left(A21_22,A11_21,hCoeffsSegment, false); // false == backward
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void HouseholderQR<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  const Index rank = (std::min)(rows(), cols());
+
+  typename RhsType::PlainObject c(rhs);
+
+  c.applyOnTheLeft(householderQ().setLength(rank).adjoint() );
+
+  m_qr.topLeftCorner(rank, rank)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(rank));
+
+  dst.topRows(rank) = c.topRows(rank);
+  dst.bottomRows(cols()-rank).setZero();
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void HouseholderQR<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  const Index rank = (std::min)(rows(), cols());
+
+  typename RhsType::PlainObject c(rhs);
+
+  m_qr.topLeftCorner(rank, rank)
+      .template triangularView<Upper>()
+      .transpose().template conjugateIf<Conjugate>()
+      .solveInPlace(c.topRows(rank));
+
+  dst.topRows(rank) = c.topRows(rank);
+  dst.bottomRows(rows()-rank).setZero();
+
+  dst.applyOnTheLeft(householderQ().setLength(rank).template conjugateIf<!Conjugate>() );
+}
+#endif
+
+/** Performs the QR factorization of the given matrix \a matrix. The result of
+  * the factorization is stored into \c *this, and a reference to \c *this
+  * is returned.
+  *
+  * \sa class HouseholderQR, HouseholderQR(const MatrixType&)
+  */
+template<typename MatrixType>
+void HouseholderQR<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+  
+  Index rows = m_qr.rows();
+  Index cols = m_qr.cols();
+  Index size = (std::min)(rows,cols);
+
+  m_hCoeffs.resize(size);
+
+  m_temp.resize(cols);
+
+  internal::householder_qr_inplace_blocked<MatrixType, HCoeffsType>::run(m_qr, m_hCoeffs, 48, m_temp.data());
+
+  m_isInitialized = true;
+}
+
+/** \return the Householder QR decomposition of \c *this.
+  *
+  * \sa class HouseholderQR
+  */
+template<typename Derived>
+const HouseholderQR<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::householderQr() const
+{
+  return HouseholderQR<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_QR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/QR/HouseholderQR_LAPACKE.h b/C++/yolo_bytetrack/include/Eigen/src/QR/HouseholderQR_LAPACKE.h
new file mode 100644
index 00000000..1dc7d536
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/QR/HouseholderQR_LAPACKE.h
@@ -0,0 +1,68 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Householder QR decomposition of a matrix w/o pivoting based on
+ *    LAPACKE_?geqrf function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_QR_LAPACKE_H
+#define EIGEN_QR_LAPACKE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_QR_NOPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX) \
+template<typename MatrixQR, typename HCoeffs> \
+struct householder_qr_inplace_blocked<MatrixQR, HCoeffs, EIGTYPE, true> \
+{ \
+  static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index = 32, \
+      typename MatrixQR::Scalar* = 0) \
+  { \
+    lapack_int m = (lapack_int) mat.rows(); \
+    lapack_int n = (lapack_int) mat.cols(); \
+    lapack_int lda = (lapack_int) mat.outerStride(); \
+    lapack_int matrix_order = (MatrixQR::IsRowMajor) ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
+    LAPACKE_##LAPACKE_PREFIX##geqrf( matrix_order, m, n, (LAPACKE_TYPE*)mat.data(), lda, (LAPACKE_TYPE*)hCoeffs.data()); \
+    hCoeffs.adjointInPlace(); \
+  } \
+};
+
+EIGEN_LAPACKE_QR_NOPIV(double, double, d)
+EIGEN_LAPACKE_QR_NOPIV(float, float, s)
+EIGEN_LAPACKE_QR_NOPIV(dcomplex, lapack_complex_double, z)
+EIGEN_LAPACKE_QR_NOPIV(scomplex, lapack_complex_float, c)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_QR_LAPACKE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h b/C++/yolo_bytetrack/include/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
new file mode 100644
index 00000000..013c7ae7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
@@ -0,0 +1,335 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SUITESPARSEQRSUPPORT_H
+#define EIGEN_SUITESPARSEQRSUPPORT_H
+
+namespace Eigen {
+  
+  template<typename MatrixType> class SPQR; 
+  template<typename SPQRType> struct SPQRMatrixQReturnType; 
+  template<typename SPQRType> struct SPQRMatrixQTransposeReturnType; 
+  template <typename SPQRType, typename Derived> struct SPQR_QProduct;
+  namespace internal {
+    template <typename SPQRType> struct traits<SPQRMatrixQReturnType<SPQRType> >
+    {
+      typedef typename SPQRType::MatrixType ReturnType;
+    };
+    template <typename SPQRType> struct traits<SPQRMatrixQTransposeReturnType<SPQRType> >
+    {
+      typedef typename SPQRType::MatrixType ReturnType;
+    };
+    template <typename SPQRType, typename Derived> struct traits<SPQR_QProduct<SPQRType, Derived> >
+    {
+      typedef typename Derived::PlainObject ReturnType;
+    };
+  } // End namespace internal
+  
+/**
+  * \ingroup SPQRSupport_Module
+  * \class SPQR
+  * \brief Sparse QR factorization based on SuiteSparseQR library
+  *
+  * This class is used to perform a multithreaded and multifrontal rank-revealing QR decomposition
+  * of sparse matrices. The result is then used to solve linear leasts_square systems.
+  * Clearly, a QR factorization is returned such that A*P = Q*R where :
+  *
+  * P is the column permutation. Use colsPermutation() to get it.
+  *
+  * Q is the orthogonal matrix represented as Householder reflectors.
+  * Use matrixQ() to get an expression and matrixQ().transpose() to get the transpose.
+  * You can then apply it to a vector.
+  *
+  * R is the sparse triangular factor. Use matrixQR() to get it as SparseMatrix.
+  * NOTE : The Index type of R is always SuiteSparse_long. You can get it with SPQR::Index
+  *
+  * \tparam _MatrixType The type of the sparse matrix A, must be a column-major SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  *
+  */
+template<typename _MatrixType>
+class SPQR : public SparseSolverBase<SPQR<_MatrixType> >
+{
+  protected:
+    typedef SparseSolverBase<SPQR<_MatrixType> > Base;
+    using Base::m_isInitialized;
+  public:
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef SuiteSparse_long StorageIndex ;
+    typedef SparseMatrix<Scalar, ColMajor, StorageIndex> MatrixType;
+    typedef Map<PermutationMatrix<Dynamic, Dynamic, StorageIndex> > PermutationType;
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+  public:
+    SPQR() 
+      : m_analysisIsOk(false),
+        m_factorizationIsOk(false),
+        m_isRUpToDate(false),
+        m_ordering(SPQR_ORDERING_DEFAULT),
+        m_allow_tol(SPQR_DEFAULT_TOL),
+        m_tolerance (NumTraits<Scalar>::epsilon()),
+        m_cR(0),
+        m_E(0),
+        m_H(0),
+        m_HPinv(0),
+        m_HTau(0),
+        m_useDefaultThreshold(true)
+    { 
+      cholmod_l_start(&m_cc);
+    }
+    
+    explicit SPQR(const _MatrixType& matrix)
+      : m_analysisIsOk(false),
+        m_factorizationIsOk(false),
+        m_isRUpToDate(false),
+        m_ordering(SPQR_ORDERING_DEFAULT),
+        m_allow_tol(SPQR_DEFAULT_TOL),
+        m_tolerance (NumTraits<Scalar>::epsilon()),
+        m_cR(0),
+        m_E(0),
+        m_H(0),
+        m_HPinv(0),
+        m_HTau(0),
+        m_useDefaultThreshold(true)
+    {
+      cholmod_l_start(&m_cc);
+      compute(matrix);
+    }
+    
+    ~SPQR()
+    {
+      SPQR_free();
+      cholmod_l_finish(&m_cc);
+    }
+    void SPQR_free()
+    {
+      cholmod_l_free_sparse(&m_H, &m_cc);
+      cholmod_l_free_sparse(&m_cR, &m_cc);
+      cholmod_l_free_dense(&m_HTau, &m_cc);
+      std::free(m_E);
+      std::free(m_HPinv);
+    }
+
+    void compute(const _MatrixType& matrix)
+    {
+      if(m_isInitialized) SPQR_free();
+
+      MatrixType mat(matrix);
+      
+      /* Compute the default threshold as in MatLab, see:
+       * Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
+       * Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011, Page 8:3 
+       */
+      RealScalar pivotThreshold = m_tolerance;
+      if(m_useDefaultThreshold) 
+      {
+        RealScalar max2Norm = 0.0;
+        for (int j = 0; j < mat.cols(); j++) max2Norm = numext::maxi(max2Norm, mat.col(j).norm());
+        if(max2Norm==RealScalar(0))
+          max2Norm = RealScalar(1);
+        pivotThreshold = 20 * (mat.rows() + mat.cols()) * max2Norm * NumTraits<RealScalar>::epsilon();
+      }
+      cholmod_sparse A; 
+      A = viewAsCholmod(mat);
+      m_rows = matrix.rows();
+      Index col = matrix.cols();
+      m_rank = SuiteSparseQR<Scalar>(m_ordering, pivotThreshold, col, &A, 
+                             &m_cR, &m_E, &m_H, &m_HPinv, &m_HTau, &m_cc);
+
+      if (!m_cR)
+      {
+        m_info = NumericalIssue;
+        m_isInitialized = false;
+        return;
+      }
+      m_info = Success;
+      m_isInitialized = true;
+      m_isRUpToDate = false;
+    }
+    /** 
+     * Get the number of rows of the input matrix and the Q matrix
+     */
+    inline Index rows() const {return m_rows; }
+    
+    /** 
+     * Get the number of columns of the input matrix. 
+     */
+    inline Index cols() const { return m_cR->ncol; }
+    
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_isInitialized && " The QR factorization should be computed first, call compute()");
+      eigen_assert(b.cols()==1 && "This method is for vectors only");
+
+      //Compute Q^T * b
+      typename Dest::PlainObject y, y2;
+      y = matrixQ().transpose() * b;
+      
+      // Solves with the triangular matrix R
+      Index rk = this->rank();
+      y2 = y;
+      y.resize((std::max)(cols(),Index(y.rows())),y.cols());
+      y.topRows(rk) = this->matrixR().topLeftCorner(rk, rk).template triangularView<Upper>().solve(y2.topRows(rk));
+
+      // Apply the column permutation 
+      // colsPermutation() performs a copy of the permutation,
+      // so let's apply it manually:
+      for(Index i = 0; i < rk; ++i) dest.row(m_E[i]) = y.row(i);
+      for(Index i = rk; i < cols(); ++i) dest.row(m_E[i]).setZero();
+      
+//       y.bottomRows(y.rows()-rk).setZero();
+//       dest = colsPermutation() * y.topRows(cols());
+      
+      m_info = Success;
+    }
+    
+    /** \returns the sparse triangular factor R. It is a sparse matrix
+     */
+    const MatrixType matrixR() const
+    {
+      eigen_assert(m_isInitialized && " The QR factorization should be computed first, call compute()");
+      if(!m_isRUpToDate) {
+        m_R = viewAsEigen<Scalar,ColMajor, typename MatrixType::StorageIndex>(*m_cR);
+        m_isRUpToDate = true;
+      }
+      return m_R;
+    }
+    /// Get an expression of the matrix Q
+    SPQRMatrixQReturnType<SPQR> matrixQ() const
+    {
+      return SPQRMatrixQReturnType<SPQR>(*this);
+    }
+    /// Get the permutation that was applied to columns of A
+    PermutationType colsPermutation() const
+    { 
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return PermutationType(m_E, m_cR->ncol);
+    }
+    /**
+     * Gets the rank of the matrix. 
+     * It should be equal to matrixQR().cols if the matrix is full-rank
+     */
+    Index rank() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_cc.SPQR_istat[4];
+    }
+    /// Set the fill-reducing ordering method to be used
+    void setSPQROrdering(int ord) { m_ordering = ord;}
+    /// Set the tolerance tol to treat columns with 2-norm < =tol as zero
+    void setPivotThreshold(const RealScalar& tol)
+    {
+      m_useDefaultThreshold = false;
+      m_tolerance = tol;
+    }
+    
+    /** \returns a pointer to the SPQR workspace */
+    cholmod_common *cholmodCommon() const { return &m_cc; }
+    
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the sparse QR can not be computed
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+  protected:
+    bool m_analysisIsOk;
+    bool m_factorizationIsOk;
+    mutable bool m_isRUpToDate;
+    mutable ComputationInfo m_info;
+    int m_ordering; // Ordering method to use, see SPQR's manual
+    int m_allow_tol; // Allow to use some tolerance during numerical factorization.
+    RealScalar m_tolerance; // treat columns with 2-norm below this tolerance as zero
+    mutable cholmod_sparse *m_cR; // The sparse R factor in cholmod format
+    mutable MatrixType m_R; // The sparse matrix R in Eigen format
+    mutable StorageIndex *m_E; // The permutation applied to columns
+    mutable cholmod_sparse *m_H;  //The householder vectors
+    mutable StorageIndex *m_HPinv; // The row permutation of H
+    mutable cholmod_dense *m_HTau; // The Householder coefficients
+    mutable Index m_rank; // The rank of the matrix
+    mutable cholmod_common m_cc; // Workspace and parameters
+    bool m_useDefaultThreshold;     // Use default threshold
+    Index m_rows;
+    template<typename ,typename > friend struct SPQR_QProduct;
+};
+
+template <typename SPQRType, typename Derived>
+struct SPQR_QProduct : ReturnByValue<SPQR_QProduct<SPQRType,Derived> >
+{
+  typedef typename SPQRType::Scalar Scalar;
+  typedef typename SPQRType::StorageIndex StorageIndex;
+  //Define the constructor to get reference to argument types
+  SPQR_QProduct(const SPQRType& spqr, const Derived& other, bool transpose) : m_spqr(spqr),m_other(other),m_transpose(transpose) {}
+  
+  inline Index rows() const { return m_transpose ? m_spqr.rows() : m_spqr.cols(); }
+  inline Index cols() const { return m_other.cols(); }
+  // Assign to a vector
+  template<typename ResType>
+  void evalTo(ResType& res) const
+  {
+    cholmod_dense y_cd;
+    cholmod_dense *x_cd; 
+    int method = m_transpose ? SPQR_QTX : SPQR_QX; 
+    cholmod_common *cc = m_spqr.cholmodCommon();
+    y_cd = viewAsCholmod(m_other.const_cast_derived());
+    x_cd = SuiteSparseQR_qmult<Scalar>(method, m_spqr.m_H, m_spqr.m_HTau, m_spqr.m_HPinv, &y_cd, cc);
+    res = Matrix<Scalar,ResType::RowsAtCompileTime,ResType::ColsAtCompileTime>::Map(reinterpret_cast<Scalar*>(x_cd->x), x_cd->nrow, x_cd->ncol);
+    cholmod_l_free_dense(&x_cd, cc);
+  }
+  const SPQRType& m_spqr; 
+  const Derived& m_other; 
+  bool m_transpose; 
+  
+};
+template<typename SPQRType>
+struct SPQRMatrixQReturnType{
+  
+  SPQRMatrixQReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
+  template<typename Derived>
+  SPQR_QProduct<SPQRType, Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SPQR_QProduct<SPQRType,Derived>(m_spqr,other.derived(),false);
+  }
+  SPQRMatrixQTransposeReturnType<SPQRType> adjoint() const
+  {
+    return SPQRMatrixQTransposeReturnType<SPQRType>(m_spqr);
+  }
+  // To use for operations with the transpose of Q
+  SPQRMatrixQTransposeReturnType<SPQRType> transpose() const
+  {
+    return SPQRMatrixQTransposeReturnType<SPQRType>(m_spqr);
+  }
+  const SPQRType& m_spqr;
+};
+
+template<typename SPQRType>
+struct SPQRMatrixQTransposeReturnType{
+  SPQRMatrixQTransposeReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
+  template<typename Derived>
+  SPQR_QProduct<SPQRType,Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SPQR_QProduct<SPQRType,Derived>(m_spqr,other.derived(), true);
+  }
+  const SPQRType& m_spqr;
+};
+
+}// End namespace Eigen
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SVD/BDCSVD.h b/C++/yolo_bytetrack/include/Eigen/src/SVD/BDCSVD.h
new file mode 100644
index 00000000..17f8e443
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SVD/BDCSVD.h
@@ -0,0 +1,1366 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+// 
+// We used the "A Divide-And-Conquer Algorithm for the Bidiagonal SVD"
+// research report written by Ming Gu and Stanley C.Eisenstat
+// The code variable names correspond to the names they used in their 
+// report
+//
+// Copyright (C) 2013 Gauthier Brun <brun.gauthier@gmail.com>
+// Copyright (C) 2013 Nicolas Carre <nicolas.carre@ensimag.fr>
+// Copyright (C) 2013 Jean Ceccato <jean.ceccato@ensimag.fr>
+// Copyright (C) 2013 Pierre Zoppitelli <pierre.zoppitelli@ensimag.fr>
+// Copyright (C) 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
+// Copyright (C) 2014-2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BDCSVD_H
+#define EIGEN_BDCSVD_H
+// #define EIGEN_BDCSVD_DEBUG_VERBOSE
+// #define EIGEN_BDCSVD_SANITY_CHECKS
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+#undef eigen_internal_assert
+#define eigen_internal_assert(X) assert(X);
+#endif
+
+namespace Eigen {
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+IOFormat bdcsvdfmt(8, 0, ", ", "\n", "  [", "]");
+#endif
+  
+template<typename _MatrixType> class BDCSVD;
+
+namespace internal {
+
+template<typename _MatrixType> 
+struct traits<BDCSVD<_MatrixType> >
+        : traits<_MatrixType>
+{
+  typedef _MatrixType MatrixType;
+};  
+
+} // end namespace internal
+  
+  
+/** \ingroup SVD_Module
+ *
+ *
+ * \class BDCSVD
+ *
+ * \brief class Bidiagonal Divide and Conquer SVD
+ *
+ * \tparam _MatrixType the type of the matrix of which we are computing the SVD decomposition
+ *
+ * This class first reduces the input matrix to bi-diagonal form using class UpperBidiagonalization,
+ * and then performs a divide-and-conquer diagonalization. Small blocks are diagonalized using class JacobiSVD.
+ * You can control the switching size with the setSwitchSize() method, default is 16.
+ * For small matrice (<16), it is thus preferable to directly use JacobiSVD. For larger ones, BDCSVD is highly
+ * recommended and can several order of magnitude faster.
+ *
+ * \warning this algorithm is unlikely to provide accurate result when compiled with unsafe math optimizations.
+ * For instance, this concerns Intel's compiler (ICC), which performs such optimization by default unless
+ * you compile with the \c -fp-model \c precise option. Likewise, the \c -ffast-math option of GCC or clang will
+ * significantly degrade the accuracy.
+ *
+ * \sa class JacobiSVD
+ */
+template<typename _MatrixType> 
+class BDCSVD : public SVDBase<BDCSVD<_MatrixType> >
+{
+  typedef SVDBase<BDCSVD> Base;
+    
+public:
+  using Base::rows;
+  using Base::cols;
+  using Base::computeU;
+  using Base::computeV;
+  
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+  typedef typename NumTraits<RealScalar>::Literal Literal;
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime, 
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime, 
+    DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime), 
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime, 
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime, 
+    MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime, MaxColsAtCompileTime), 
+    MatrixOptions = MatrixType::Options
+  };
+
+  typedef typename Base::MatrixUType MatrixUType;
+  typedef typename Base::MatrixVType MatrixVType;
+  typedef typename Base::SingularValuesType SingularValuesType;
+  
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> MatrixX;
+  typedef Matrix<RealScalar, Dynamic, Dynamic, ColMajor> MatrixXr;
+  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
+  typedef Array<RealScalar, Dynamic, 1> ArrayXr;
+  typedef Array<Index,1,Dynamic> ArrayXi;
+  typedef Ref<ArrayXr> ArrayRef;
+  typedef Ref<ArrayXi> IndicesRef;
+
+  /** \brief Default Constructor.
+   *
+   * The default constructor is useful in cases in which the user intends to
+   * perform decompositions via BDCSVD::compute(const MatrixType&).
+   */
+  BDCSVD() : m_algoswap(16), m_isTranspose(false), m_compU(false), m_compV(false), m_numIters(0)
+  {}
+
+
+  /** \brief Default Constructor with memory preallocation
+   *
+   * Like the default constructor but with preallocation of the internal data
+   * according to the specified problem size.
+   * \sa BDCSVD()
+   */
+  BDCSVD(Index rows, Index cols, unsigned int computationOptions = 0)
+    : m_algoswap(16), m_numIters(0)
+  {
+    allocate(rows, cols, computationOptions);
+  }
+
+  /** \brief Constructor performing the decomposition of given matrix.
+   *
+   * \param matrix the matrix to decompose
+   * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+   *                           By default, none is computed. This is a bit - field, the possible bits are #ComputeFullU, #ComputeThinU, 
+   *                           #ComputeFullV, #ComputeThinV.
+   *
+   * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+   * available with the (non - default) FullPivHouseholderQR preconditioner.
+   */
+  BDCSVD(const MatrixType& matrix, unsigned int computationOptions = 0)
+    : m_algoswap(16), m_numIters(0)
+  {
+    compute(matrix, computationOptions);
+  }
+
+  ~BDCSVD() 
+  {
+  }
+  
+  /** \brief Method performing the decomposition of given matrix using custom options.
+   *
+   * \param matrix the matrix to decompose
+   * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+   *                           By default, none is computed. This is a bit - field, the possible bits are #ComputeFullU, #ComputeThinU, 
+   *                           #ComputeFullV, #ComputeThinV.
+   *
+   * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+   * available with the (non - default) FullPivHouseholderQR preconditioner.
+   */
+  BDCSVD& compute(const MatrixType& matrix, unsigned int computationOptions);
+
+  /** \brief Method performing the decomposition of given matrix using current options.
+   *
+   * \param matrix the matrix to decompose
+   *
+   * This method uses the current \a computationOptions, as already passed to the constructor or to compute(const MatrixType&, unsigned int).
+   */
+  BDCSVD& compute(const MatrixType& matrix)
+  {
+    return compute(matrix, this->m_computationOptions);
+  }
+
+  void setSwitchSize(int s) 
+  {
+    eigen_assert(s>3 && "BDCSVD the size of the algo switch has to be greater than 3");
+    m_algoswap = s;
+  }
+ 
+private:
+  void allocate(Index rows, Index cols, unsigned int computationOptions);
+  void divide(Index firstCol, Index lastCol, Index firstRowW, Index firstColW, Index shift);
+  void computeSVDofM(Index firstCol, Index n, MatrixXr& U, VectorType& singVals, MatrixXr& V);
+  void computeSingVals(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm, VectorType& singVals, ArrayRef shifts, ArrayRef mus);
+  void perturbCol0(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm, const VectorType& singVals, const ArrayRef& shifts, const ArrayRef& mus, ArrayRef zhat);
+  void computeSingVecs(const ArrayRef& zhat, const ArrayRef& diag, const IndicesRef& perm, const VectorType& singVals, const ArrayRef& shifts, const ArrayRef& mus, MatrixXr& U, MatrixXr& V);
+  void deflation43(Index firstCol, Index shift, Index i, Index size);
+  void deflation44(Index firstColu , Index firstColm, Index firstRowW, Index firstColW, Index i, Index j, Index size);
+  void deflation(Index firstCol, Index lastCol, Index k, Index firstRowW, Index firstColW, Index shift);
+  template<typename HouseholderU, typename HouseholderV, typename NaiveU, typename NaiveV>
+  void copyUV(const HouseholderU &householderU, const HouseholderV &householderV, const NaiveU &naiveU, const NaiveV &naivev);
+  void structured_update(Block<MatrixXr,Dynamic,Dynamic> A, const MatrixXr &B, Index n1);
+  static RealScalar secularEq(RealScalar x, const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm, const ArrayRef& diagShifted, RealScalar shift);
+
+protected:
+  MatrixXr m_naiveU, m_naiveV;
+  MatrixXr m_computed;
+  Index m_nRec;
+  ArrayXr m_workspace;
+  ArrayXi m_workspaceI;
+  int m_algoswap;
+  bool m_isTranspose, m_compU, m_compV;
+  
+  using Base::m_singularValues;
+  using Base::m_diagSize;
+  using Base::m_computeFullU;
+  using Base::m_computeFullV;
+  using Base::m_computeThinU;
+  using Base::m_computeThinV;
+  using Base::m_matrixU;
+  using Base::m_matrixV;
+  using Base::m_info;
+  using Base::m_isInitialized;
+  using Base::m_nonzeroSingularValues;
+
+public:  
+  int m_numIters;
+}; //end class BDCSVD
+
+
+// Method to allocate and initialize matrix and attributes
+template<typename MatrixType>
+void BDCSVD<MatrixType>::allocate(Eigen::Index rows, Eigen::Index cols, unsigned int computationOptions)
+{
+  m_isTranspose = (cols > rows);
+
+  if (Base::allocate(rows, cols, computationOptions))
+    return;
+  
+  m_computed = MatrixXr::Zero(m_diagSize + 1, m_diagSize );
+  m_compU = computeV();
+  m_compV = computeU();
+  if (m_isTranspose)
+    std::swap(m_compU, m_compV);
+  
+  if (m_compU) m_naiveU = MatrixXr::Zero(m_diagSize + 1, m_diagSize + 1 );
+  else         m_naiveU = MatrixXr::Zero(2, m_diagSize + 1 );
+  
+  if (m_compV) m_naiveV = MatrixXr::Zero(m_diagSize, m_diagSize);
+  
+  m_workspace.resize((m_diagSize+1)*(m_diagSize+1)*3);
+  m_workspaceI.resize(3*m_diagSize);
+}// end allocate
+
+template<typename MatrixType>
+BDCSVD<MatrixType>& BDCSVD<MatrixType>::compute(const MatrixType& matrix, unsigned int computationOptions) 
+{
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "\n\n\n======================================================================================================================\n\n\n";
+#endif
+  allocate(matrix.rows(), matrix.cols(), computationOptions);
+  using std::abs;
+
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  
+  //**** step -1 - If the problem is too small, directly falls back to JacobiSVD and return
+  if(matrix.cols() < m_algoswap)
+  {
+    // FIXME this line involves temporaries
+    JacobiSVD<MatrixType> jsvd(matrix,computationOptions);
+    m_isInitialized = true;
+    m_info = jsvd.info();
+    if (m_info == Success || m_info == NoConvergence) {
+      if(computeU()) m_matrixU = jsvd.matrixU();
+      if(computeV()) m_matrixV = jsvd.matrixV();
+      m_singularValues = jsvd.singularValues();
+      m_nonzeroSingularValues = jsvd.nonzeroSingularValues();
+    }
+    return *this;
+  }
+  
+  //**** step 0 - Copy the input matrix and apply scaling to reduce over/under-flows
+  RealScalar scale = matrix.cwiseAbs().template maxCoeff<PropagateNaN>();
+  if (!(numext::isfinite)(scale)) {
+    m_isInitialized = true;
+    m_info = InvalidInput;
+    return *this;
+  }
+
+  if(scale==Literal(0)) scale = Literal(1);
+  MatrixX copy;
+  if (m_isTranspose) copy = matrix.adjoint()/scale;
+  else               copy = matrix/scale;
+  
+  //**** step 1 - Bidiagonalization
+  // FIXME this line involves temporaries
+  internal::UpperBidiagonalization<MatrixX> bid(copy);
+
+  //**** step 2 - Divide & Conquer
+  m_naiveU.setZero();
+  m_naiveV.setZero();
+  // FIXME this line involves a temporary matrix
+  m_computed.topRows(m_diagSize) = bid.bidiagonal().toDenseMatrix().transpose();
+  m_computed.template bottomRows<1>().setZero();
+  divide(0, m_diagSize - 1, 0, 0, 0);
+  if (m_info != Success && m_info != NoConvergence) {
+    m_isInitialized = true;
+    return *this;
+  }
+    
+  //**** step 3 - Copy singular values and vectors
+  for (int i=0; i<m_diagSize; i++)
+  {
+    RealScalar a = abs(m_computed.coeff(i, i));
+    m_singularValues.coeffRef(i) = a * scale;
+    if (a<considerZero)
+    {
+      m_nonzeroSingularValues = i;
+      m_singularValues.tail(m_diagSize - i - 1).setZero();
+      break;
+    }
+    else if (i == m_diagSize - 1)
+    {
+      m_nonzeroSingularValues = i + 1;
+      break;
+    }
+  }
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+//   std::cout << "m_naiveU\n" << m_naiveU << "\n\n";
+//   std::cout << "m_naiveV\n" << m_naiveV << "\n\n";
+#endif
+  if(m_isTranspose) copyUV(bid.householderV(), bid.householderU(), m_naiveV, m_naiveU);
+  else              copyUV(bid.householderU(), bid.householderV(), m_naiveU, m_naiveV);
+
+  m_isInitialized = true;
+  return *this;
+}// end compute
+
+
+template<typename MatrixType>
+template<typename HouseholderU, typename HouseholderV, typename NaiveU, typename NaiveV>
+void BDCSVD<MatrixType>::copyUV(const HouseholderU &householderU, const HouseholderV &householderV, const NaiveU &naiveU, const NaiveV &naiveV)
+{
+  // Note exchange of U and V: m_matrixU is set from m_naiveV and vice versa
+  if (computeU())
+  {
+    Index Ucols = m_computeThinU ? m_diagSize : householderU.cols();
+    m_matrixU = MatrixX::Identity(householderU.cols(), Ucols);
+    m_matrixU.topLeftCorner(m_diagSize, m_diagSize) = naiveV.template cast<Scalar>().topLeftCorner(m_diagSize, m_diagSize);
+    householderU.applyThisOnTheLeft(m_matrixU); // FIXME this line involves a temporary buffer
+  }
+  if (computeV())
+  {
+    Index Vcols = m_computeThinV ? m_diagSize : householderV.cols();
+    m_matrixV = MatrixX::Identity(householderV.cols(), Vcols);
+    m_matrixV.topLeftCorner(m_diagSize, m_diagSize) = naiveU.template cast<Scalar>().topLeftCorner(m_diagSize, m_diagSize);
+    householderV.applyThisOnTheLeft(m_matrixV); // FIXME this line involves a temporary buffer
+  }
+}
+
+/** \internal
+  * Performs A = A * B exploiting the special structure of the matrix A. Splitting A as:
+  *  A = [A1]
+  *      [A2]
+  * such that A1.rows()==n1, then we assume that at least half of the columns of A1 and A2 are zeros.
+  * We can thus pack them prior to the the matrix product. However, this is only worth the effort if the matrix is large
+  * enough.
+  */
+template<typename MatrixType>
+void BDCSVD<MatrixType>::structured_update(Block<MatrixXr,Dynamic,Dynamic> A, const MatrixXr &B, Index n1)
+{
+  Index n = A.rows();
+  if(n>100)
+  {
+    // If the matrices are large enough, let's exploit the sparse structure of A by
+    // splitting it in half (wrt n1), and packing the non-zero columns.
+    Index n2 = n - n1;
+    Map<MatrixXr> A1(m_workspace.data()      , n1, n);
+    Map<MatrixXr> A2(m_workspace.data()+ n1*n, n2, n);
+    Map<MatrixXr> B1(m_workspace.data()+  n*n, n,  n);
+    Map<MatrixXr> B2(m_workspace.data()+2*n*n, n,  n);
+    Index k1=0, k2=0;
+    for(Index j=0; j<n; ++j)
+    {
+      if( (A.col(j).head(n1).array()!=Literal(0)).any() )
+      {
+        A1.col(k1) = A.col(j).head(n1);
+        B1.row(k1) = B.row(j);
+        ++k1;
+      }
+      if( (A.col(j).tail(n2).array()!=Literal(0)).any() )
+      {
+        A2.col(k2) = A.col(j).tail(n2);
+        B2.row(k2) = B.row(j);
+        ++k2;
+      }
+    }
+  
+    A.topRows(n1).noalias()    = A1.leftCols(k1) * B1.topRows(k1);
+    A.bottomRows(n2).noalias() = A2.leftCols(k2) * B2.topRows(k2);
+  }
+  else
+  {
+    Map<MatrixXr,Aligned> tmp(m_workspace.data(),n,n);
+    tmp.noalias() = A*B;
+    A = tmp;
+  }
+}
+
+// The divide algorithm is done "in place", we are always working on subsets of the same matrix. The divide methods takes as argument the 
+// place of the submatrix we are currently working on.
+
+//@param firstCol : The Index of the first column of the submatrix of m_computed and for m_naiveU;
+//@param lastCol : The Index of the last column of the submatrix of m_computed and for m_naiveU; 
+// lastCol + 1 - firstCol is the size of the submatrix.
+//@param firstRowW : The Index of the first row of the matrix W that we are to change. (see the reference paper section 1 for more information on W)
+//@param firstRowW : Same as firstRowW with the column.
+//@param shift : Each time one takes the left submatrix, one must add 1 to the shift. Why? Because! We actually want the last column of the U submatrix 
+// to become the first column (*coeff) and to shift all the other columns to the right. There are more details on the reference paper.
+template<typename MatrixType>
+void BDCSVD<MatrixType>::divide(Eigen::Index firstCol, Eigen::Index lastCol, Eigen::Index firstRowW, Eigen::Index firstColW, Eigen::Index shift)
+{
+  // requires rows = cols + 1;
+  using std::pow;
+  using std::sqrt;
+  using std::abs;
+  const Index n = lastCol - firstCol + 1;
+  const Index k = n/2;
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  RealScalar alphaK;
+  RealScalar betaK; 
+  RealScalar r0; 
+  RealScalar lambda, phi, c0, s0;
+  VectorType l, f;
+  // We use the other algorithm which is more efficient for small 
+  // matrices.
+  if (n < m_algoswap)
+  {
+    // FIXME this line involves temporaries
+    JacobiSVD<MatrixXr> b(m_computed.block(firstCol, firstCol, n + 1, n), ComputeFullU | (m_compV ? ComputeFullV : 0));
+    m_info = b.info();
+    if (m_info != Success && m_info != NoConvergence) return;
+    if (m_compU)
+      m_naiveU.block(firstCol, firstCol, n + 1, n + 1).real() = b.matrixU();
+    else 
+    {
+      m_naiveU.row(0).segment(firstCol, n + 1).real() = b.matrixU().row(0);
+      m_naiveU.row(1).segment(firstCol, n + 1).real() = b.matrixU().row(n);
+    }
+    if (m_compV) m_naiveV.block(firstRowW, firstColW, n, n).real() = b.matrixV();
+    m_computed.block(firstCol + shift, firstCol + shift, n + 1, n).setZero();
+    m_computed.diagonal().segment(firstCol + shift, n) = b.singularValues().head(n);
+    return;
+  }
+  // We use the divide and conquer algorithm
+  alphaK =  m_computed(firstCol + k, firstCol + k);
+  betaK = m_computed(firstCol + k + 1, firstCol + k);
+  // The divide must be done in that order in order to have good results. Divide change the data inside the submatrices
+  // and the divide of the right submatrice reads one column of the left submatrice. That's why we need to treat the 
+  // right submatrix before the left one. 
+  divide(k + 1 + firstCol, lastCol, k + 1 + firstRowW, k + 1 + firstColW, shift);
+  if (m_info != Success && m_info != NoConvergence) return;
+  divide(firstCol, k - 1 + firstCol, firstRowW, firstColW + 1, shift + 1);
+  if (m_info != Success && m_info != NoConvergence) return;
+
+  if (m_compU)
+  {
+    lambda = m_naiveU(firstCol + k, firstCol + k);
+    phi = m_naiveU(firstCol + k + 1, lastCol + 1);
+  } 
+  else 
+  {
+    lambda = m_naiveU(1, firstCol + k);
+    phi = m_naiveU(0, lastCol + 1);
+  }
+  r0 = sqrt((abs(alphaK * lambda) * abs(alphaK * lambda)) + abs(betaK * phi) * abs(betaK * phi));
+  if (m_compU)
+  {
+    l = m_naiveU.row(firstCol + k).segment(firstCol, k);
+    f = m_naiveU.row(firstCol + k + 1).segment(firstCol + k + 1, n - k - 1);
+  } 
+  else 
+  {
+    l = m_naiveU.row(1).segment(firstCol, k);
+    f = m_naiveU.row(0).segment(firstCol + k + 1, n - k - 1);
+  }
+  if (m_compV) m_naiveV(firstRowW+k, firstColW) = Literal(1);
+  if (r0<considerZero)
+  {
+    c0 = Literal(1);
+    s0 = Literal(0);
+  }
+  else
+  {
+    c0 = alphaK * lambda / r0;
+    s0 = betaK * phi / r0;
+  }
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+  
+  if (m_compU)
+  {
+    MatrixXr q1 (m_naiveU.col(firstCol + k).segment(firstCol, k + 1));     
+    // we shiftW Q1 to the right
+    for (Index i = firstCol + k - 1; i >= firstCol; i--) 
+      m_naiveU.col(i + 1).segment(firstCol, k + 1) = m_naiveU.col(i).segment(firstCol, k + 1);
+    // we shift q1 at the left with a factor c0
+    m_naiveU.col(firstCol).segment( firstCol, k + 1) = (q1 * c0);
+    // last column = q1 * - s0
+    m_naiveU.col(lastCol + 1).segment(firstCol, k + 1) = (q1 * ( - s0));
+    // first column = q2 * s0
+    m_naiveU.col(firstCol).segment(firstCol + k + 1, n - k) = m_naiveU.col(lastCol + 1).segment(firstCol + k + 1, n - k) * s0; 
+    // q2 *= c0
+    m_naiveU.col(lastCol + 1).segment(firstCol + k + 1, n - k) *= c0;
+  } 
+  else 
+  {
+    RealScalar q1 = m_naiveU(0, firstCol + k);
+    // we shift Q1 to the right
+    for (Index i = firstCol + k - 1; i >= firstCol; i--) 
+      m_naiveU(0, i + 1) = m_naiveU(0, i);
+    // we shift q1 at the left with a factor c0
+    m_naiveU(0, firstCol) = (q1 * c0);
+    // last column = q1 * - s0
+    m_naiveU(0, lastCol + 1) = (q1 * ( - s0));
+    // first column = q2 * s0
+    m_naiveU(1, firstCol) = m_naiveU(1, lastCol + 1) *s0; 
+    // q2 *= c0
+    m_naiveU(1, lastCol + 1) *= c0;
+    m_naiveU.row(1).segment(firstCol + 1, k).setZero();
+    m_naiveU.row(0).segment(firstCol + k + 1, n - k - 1).setZero();
+  }
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+  
+  m_computed(firstCol + shift, firstCol + shift) = r0;
+  m_computed.col(firstCol + shift).segment(firstCol + shift + 1, k) = alphaK * l.transpose().real();
+  m_computed.col(firstCol + shift).segment(firstCol + shift + k + 1, n - k - 1) = betaK * f.transpose().real();
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  ArrayXr tmp1 = (m_computed.block(firstCol+shift, firstCol+shift, n, n)).jacobiSvd().singularValues();
+#endif
+  // Second part: try to deflate singular values in combined matrix
+  deflation(firstCol, lastCol, k, firstRowW, firstColW, shift);
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  ArrayXr tmp2 = (m_computed.block(firstCol+shift, firstCol+shift, n, n)).jacobiSvd().singularValues();
+  std::cout << "\n\nj1 = " << tmp1.transpose().format(bdcsvdfmt) << "\n";
+  std::cout << "j2 = " << tmp2.transpose().format(bdcsvdfmt) << "\n\n";
+  std::cout << "err:      " << ((tmp1-tmp2).abs()>1e-12*tmp2.abs()).transpose() << "\n";
+  static int count = 0;
+  std::cout << "# " << ++count << "\n\n";
+  assert((tmp1-tmp2).matrix().norm() < 1e-14*tmp2.matrix().norm());
+//   assert(count<681);
+//   assert(((tmp1-tmp2).abs()<1e-13*tmp2.abs()).all());
+#endif
+  
+  // Third part: compute SVD of combined matrix
+  MatrixXr UofSVD, VofSVD;
+  VectorType singVals;
+  computeSVDofM(firstCol + shift, n, UofSVD, singVals, VofSVD);
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(UofSVD.allFinite());
+  assert(VofSVD.allFinite());
+#endif
+  
+  if (m_compU)
+    structured_update(m_naiveU.block(firstCol, firstCol, n + 1, n + 1), UofSVD, (n+2)/2);
+  else
+  {
+    Map<Matrix<RealScalar,2,Dynamic>,Aligned> tmp(m_workspace.data(),2,n+1);
+    tmp.noalias() = m_naiveU.middleCols(firstCol, n+1) * UofSVD;
+    m_naiveU.middleCols(firstCol, n + 1) = tmp;
+  }
+  
+  if (m_compV)  structured_update(m_naiveV.block(firstRowW, firstColW, n, n), VofSVD, (n+1)/2);
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+  
+  m_computed.block(firstCol + shift, firstCol + shift, n, n).setZero();
+  m_computed.block(firstCol + shift, firstCol + shift, n, n).diagonal() = singVals;
+}// end divide
+
+// Compute SVD of m_computed.block(firstCol, firstCol, n + 1, n); this block only has non-zeros in
+// the first column and on the diagonal and has undergone deflation, so diagonal is in increasing
+// order except for possibly the (0,0) entry. The computed SVD is stored U, singVals and V, except
+// that if m_compV is false, then V is not computed. Singular values are sorted in decreasing order.
+//
+// TODO Opportunities for optimization: better root finding algo, better stopping criterion, better
+// handling of round-off errors, be consistent in ordering
+// For instance, to solve the secular equation using FMM, see http://www.stat.uchicago.edu/~lekheng/courses/302/classics/greengard-rokhlin.pdf
+template <typename MatrixType>
+void BDCSVD<MatrixType>::computeSVDofM(Eigen::Index firstCol, Eigen::Index n, MatrixXr& U, VectorType& singVals, MatrixXr& V)
+{
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  using std::abs;
+  ArrayRef col0 = m_computed.col(firstCol).segment(firstCol, n);
+  m_workspace.head(n) =  m_computed.block(firstCol, firstCol, n, n).diagonal();
+  ArrayRef diag = m_workspace.head(n);
+  diag(0) = Literal(0);
+
+  // Allocate space for singular values and vectors
+  singVals.resize(n);
+  U.resize(n+1, n+1);
+  if (m_compV) V.resize(n, n);
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  if (col0.hasNaN() || diag.hasNaN())
+    std::cout << "\n\nHAS NAN\n\n";
+#endif
+  
+  // Many singular values might have been deflated, the zero ones have been moved to the end,
+  // but others are interleaved and we must ignore them at this stage.
+  // To this end, let's compute a permutation skipping them:
+  Index actual_n = n;
+  while(actual_n>1 && diag(actual_n-1)==Literal(0)) {--actual_n; eigen_internal_assert(col0(actual_n)==Literal(0)); }
+  Index m = 0; // size of the deflated problem
+  for(Index k=0;k<actual_n;++k)
+    if(abs(col0(k))>considerZero)
+      m_workspaceI(m++) = k;
+  Map<ArrayXi> perm(m_workspaceI.data(),m);
+  
+  Map<ArrayXr> shifts(m_workspace.data()+1*n, n);
+  Map<ArrayXr> mus(m_workspace.data()+2*n, n);
+  Map<ArrayXr> zhat(m_workspace.data()+3*n, n);
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "computeSVDofM using:\n";
+  std::cout << "  z: " << col0.transpose() << "\n";
+  std::cout << "  d: " << diag.transpose() << "\n";
+#endif
+  
+  // Compute singVals, shifts, and mus
+  computeSingVals(col0, diag, perm, singVals, shifts, mus);
+  
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "  j:        " << (m_computed.block(firstCol, firstCol, n, n)).jacobiSvd().singularValues().transpose().reverse() << "\n\n";
+  std::cout << "  sing-val: " << singVals.transpose() << "\n";
+  std::cout << "  mu:       " << mus.transpose() << "\n";
+  std::cout << "  shift:    " << shifts.transpose() << "\n";
+  
+  {
+    std::cout << "\n\n    mus:    " << mus.head(actual_n).transpose() << "\n\n";
+    std::cout << "    check1 (expect0) : " << ((singVals.array()-(shifts+mus)) / singVals.array()).head(actual_n).transpose() << "\n\n";
+    assert((((singVals.array()-(shifts+mus)) / singVals.array()).head(actual_n) >= 0).all());
+    std::cout << "    check2 (>0)      : " << ((singVals.array()-diag) / singVals.array()).head(actual_n).transpose() << "\n\n";
+    assert((((singVals.array()-diag) / singVals.array()).head(actual_n) >= 0).all());
+  }
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(singVals.allFinite());
+  assert(mus.allFinite());
+  assert(shifts.allFinite());
+#endif
+  
+  // Compute zhat
+  perturbCol0(col0, diag, perm, singVals, shifts, mus, zhat);
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "  zhat: " << zhat.transpose() << "\n";
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(zhat.allFinite());
+#endif
+  
+  computeSingVecs(zhat, diag, perm, singVals, shifts, mus, U, V);
+  
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "U^T U: " << (U.transpose() * U - MatrixXr(MatrixXr::Identity(U.cols(),U.cols()))).norm() << "\n";
+  std::cout << "V^T V: " << (V.transpose() * V - MatrixXr(MatrixXr::Identity(V.cols(),V.cols()))).norm() << "\n";
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+  assert(U.allFinite());
+  assert(V.allFinite());
+//   assert((U.transpose() * U - MatrixXr(MatrixXr::Identity(U.cols(),U.cols()))).norm() < 100*NumTraits<RealScalar>::epsilon() * n);
+//   assert((V.transpose() * V - MatrixXr(MatrixXr::Identity(V.cols(),V.cols()))).norm() < 100*NumTraits<RealScalar>::epsilon() * n);
+#endif
+  
+  // Because of deflation, the singular values might not be completely sorted.
+  // Fortunately, reordering them is a O(n) problem
+  for(Index i=0; i<actual_n-1; ++i)
+  {
+    if(singVals(i)>singVals(i+1))
+    {
+      using std::swap;
+      swap(singVals(i),singVals(i+1));
+      U.col(i).swap(U.col(i+1));
+      if(m_compV) V.col(i).swap(V.col(i+1));
+    }
+  }
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  {
+    bool singular_values_sorted = (((singVals.segment(1,actual_n-1)-singVals.head(actual_n-1))).array() >= 0).all();
+    if(!singular_values_sorted)
+      std::cout << "Singular values are not sorted: " << singVals.segment(1,actual_n).transpose() << "\n";
+    assert(singular_values_sorted);
+  }
+#endif
+  
+  // Reverse order so that singular values in increased order
+  // Because of deflation, the zeros singular-values are already at the end
+  singVals.head(actual_n).reverseInPlace();
+  U.leftCols(actual_n).rowwise().reverseInPlace();
+  if (m_compV) V.leftCols(actual_n).rowwise().reverseInPlace();
+  
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  JacobiSVD<MatrixXr> jsvd(m_computed.block(firstCol, firstCol, n, n) );
+  std::cout << "  * j:        " << jsvd.singularValues().transpose() << "\n\n";
+  std::cout << "  * sing-val: " << singVals.transpose() << "\n";
+//   std::cout << "  * err:      " << ((jsvd.singularValues()-singVals)>1e-13*singVals.norm()).transpose() << "\n";
+#endif
+}
+
+template <typename MatrixType>
+typename BDCSVD<MatrixType>::RealScalar BDCSVD<MatrixType>::secularEq(RealScalar mu, const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm, const ArrayRef& diagShifted, RealScalar shift)
+{
+  Index m = perm.size();
+  RealScalar res = Literal(1);
+  for(Index i=0; i<m; ++i)
+  {
+    Index j = perm(i);
+    // The following expression could be rewritten to involve only a single division,
+    // but this would make the expression more sensitive to overflow.
+    res += (col0(j) / (diagShifted(j) - mu)) * (col0(j) / (diag(j) + shift + mu));
+  }
+  return res;
+
+}
+
+template <typename MatrixType>
+void BDCSVD<MatrixType>::computeSingVals(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm,
+                                         VectorType& singVals, ArrayRef shifts, ArrayRef mus)
+{
+  using std::abs;
+  using std::swap;
+  using std::sqrt;
+
+  Index n = col0.size();
+  Index actual_n = n;
+  // Note that here actual_n is computed based on col0(i)==0 instead of diag(i)==0 as above
+  // because 1) we have diag(i)==0 => col0(i)==0 and 2) if col0(i)==0, then diag(i) is already a singular value.
+  while(actual_n>1 && col0(actual_n-1)==Literal(0)) --actual_n;
+
+  for (Index k = 0; k < n; ++k)
+  {
+    if (col0(k) == Literal(0) || actual_n==1)
+    {
+      // if col0(k) == 0, then entry is deflated, so singular value is on diagonal
+      // if actual_n==1, then the deflated problem is already diagonalized
+      singVals(k) = k==0 ? col0(0) : diag(k);
+      mus(k) = Literal(0);
+      shifts(k) = k==0 ? col0(0) : diag(k);
+      continue;
+    } 
+
+    // otherwise, use secular equation to find singular value
+    RealScalar left = diag(k);
+    RealScalar right; // was: = (k != actual_n-1) ? diag(k+1) : (diag(actual_n-1) + col0.matrix().norm());
+    if(k==actual_n-1)
+      right = (diag(actual_n-1) + col0.matrix().norm());
+    else
+    {
+      // Skip deflated singular values,
+      // recall that at this stage we assume that z[j]!=0 and all entries for which z[j]==0 have been put aside.
+      // This should be equivalent to using perm[]
+      Index l = k+1;
+      while(col0(l)==Literal(0)) { ++l; eigen_internal_assert(l<actual_n); }
+      right = diag(l);
+    }
+
+    // first decide whether it's closer to the left end or the right end
+    RealScalar mid = left + (right-left) / Literal(2);
+    RealScalar fMid = secularEq(mid, col0, diag, perm, diag, Literal(0));
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+    std::cout << "right-left = " << right-left << "\n";
+//     std::cout << "fMid = " << fMid << " " << secularEq(mid-left, col0, diag, perm, ArrayXr(diag-left), left)
+//                            << " " << secularEq(mid-right, col0, diag, perm, ArrayXr(diag-right), right)   << "\n";
+    std::cout << "     = " << secularEq(left+RealScalar(0.000001)*(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.1)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.2)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.3)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.4)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.49)    *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.5)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.51)    *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.6)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.7)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.8)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.9)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.999999)*(right-left), col0, diag, perm, diag, 0) << "\n";
+#endif
+    RealScalar shift = (k == actual_n-1 || fMid > Literal(0)) ? left : right;
+    
+    // measure everything relative to shift
+    Map<ArrayXr> diagShifted(m_workspace.data()+4*n, n);
+    diagShifted = diag - shift;
+
+    if(k!=actual_n-1)
+    {
+      // check that after the shift, f(mid) is still negative:
+      RealScalar midShifted = (right - left) / RealScalar(2);
+      if(shift==right)
+        midShifted = -midShifted;
+      RealScalar fMidShifted = secularEq(midShifted, col0, diag, perm, diagShifted, shift);
+      if(fMidShifted>0)
+      {
+        // fMid was erroneous, fix it:
+        shift =  fMidShifted > Literal(0) ? left : right;
+        diagShifted = diag - shift;
+      }
+    }
+    
+    // initial guess
+    RealScalar muPrev, muCur;
+    if (shift == left)
+    {
+      muPrev = (right - left) * RealScalar(0.1);
+      if (k == actual_n-1) muCur = right - left;
+      else                 muCur = (right - left) * RealScalar(0.5);
+    }
+    else
+    {
+      muPrev = -(right - left) * RealScalar(0.1);
+      muCur = -(right - left) * RealScalar(0.5);
+    }
+
+    RealScalar fPrev = secularEq(muPrev, col0, diag, perm, diagShifted, shift);
+    RealScalar fCur = secularEq(muCur, col0, diag, perm, diagShifted, shift);
+    if (abs(fPrev) < abs(fCur))
+    {
+      swap(fPrev, fCur);
+      swap(muPrev, muCur);
+    }
+
+    // rational interpolation: fit a function of the form a / mu + b through the two previous
+    // iterates and use its zero to compute the next iterate
+    bool useBisection = fPrev*fCur>Literal(0);
+    while (fCur!=Literal(0) && abs(muCur - muPrev) > Literal(8) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(abs(muCur), abs(muPrev)) && abs(fCur - fPrev)>NumTraits<RealScalar>::epsilon() && !useBisection)
+    {
+      ++m_numIters;
+
+      // Find a and b such that the function f(mu) = a / mu + b matches the current and previous samples.
+      RealScalar a = (fCur - fPrev) / (Literal(1)/muCur - Literal(1)/muPrev);
+      RealScalar b = fCur - a / muCur;
+      // And find mu such that f(mu)==0:
+      RealScalar muZero = -a/b;
+      RealScalar fZero = secularEq(muZero, col0, diag, perm, diagShifted, shift);
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+      assert((numext::isfinite)(fZero));
+#endif
+      
+      muPrev = muCur;
+      fPrev = fCur;
+      muCur = muZero;
+      fCur = fZero;
+      
+      if (shift == left  && (muCur < Literal(0) || muCur > right - left)) useBisection = true;
+      if (shift == right && (muCur < -(right - left) || muCur > Literal(0))) useBisection = true;
+      if (abs(fCur)>abs(fPrev)) useBisection = true;
+    }
+
+    // fall back on bisection method if rational interpolation did not work
+    if (useBisection)
+    {
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "useBisection for k = " << k << ", actual_n = " << actual_n << "\n";
+#endif
+      RealScalar leftShifted, rightShifted;
+      if (shift == left)
+      {
+        // to avoid overflow, we must have mu > max(real_min, |z(k)|/sqrt(real_max)),
+        // the factor 2 is to be more conservative
+        leftShifted = numext::maxi<RealScalar>( (std::numeric_limits<RealScalar>::min)(), Literal(2) * abs(col0(k)) / sqrt((std::numeric_limits<RealScalar>::max)()) );
+
+        // check that we did it right:
+        eigen_internal_assert( (numext::isfinite)( (col0(k)/leftShifted)*(col0(k)/(diag(k)+shift+leftShifted)) ) );
+        // I don't understand why the case k==0 would be special there:
+        // if (k == 0) rightShifted = right - left; else
+        rightShifted = (k==actual_n-1) ? right : ((right - left) * RealScalar(0.51)); // theoretically we can take 0.5, but let's be safe
+      }
+      else
+      {
+        leftShifted = -(right - left) * RealScalar(0.51);
+        if(k+1<n)
+          rightShifted = -numext::maxi<RealScalar>( (std::numeric_limits<RealScalar>::min)(), abs(col0(k+1)) / sqrt((std::numeric_limits<RealScalar>::max)()) );
+        else
+          rightShifted = -(std::numeric_limits<RealScalar>::min)();
+      }
+
+      RealScalar fLeft = secularEq(leftShifted, col0, diag, perm, diagShifted, shift);
+      eigen_internal_assert(fLeft<Literal(0));
+
+#if defined EIGEN_INTERNAL_DEBUGGING || defined EIGEN_BDCSVD_SANITY_CHECKS
+      RealScalar fRight = secularEq(rightShifted, col0, diag, perm, diagShifted, shift);
+#endif
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+      if(!(numext::isfinite)(fLeft))
+        std::cout << "f(" << leftShifted << ") =" << fLeft << " ; " << left << " " << shift << " " << right << "\n";
+      assert((numext::isfinite)(fLeft));
+
+      if(!(numext::isfinite)(fRight))
+        std::cout << "f(" << rightShifted << ") =" << fRight << " ; " << left << " " << shift << " " << right << "\n";
+      // assert((numext::isfinite)(fRight));
+#endif
+    
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      if(!(fLeft * fRight<0))
+      {
+        std::cout << "f(leftShifted) using  leftShifted=" << leftShifted << " ;  diagShifted(1:10):" << diagShifted.head(10).transpose()  << "\n ; "
+                  << "left==shift=" << bool(left==shift) << " ; left-shift = " << (left-shift) << "\n";
+        std::cout << "k=" << k << ", " <<  fLeft << " * " << fRight << " == " << fLeft * fRight << "  ;  "
+                  << "[" << left << " .. " << right << "] -> [" << leftShifted << " " << rightShifted << "], shift=" << shift
+                  << " ,  f(right)=" << secularEq(0,     col0, diag, perm, diagShifted, shift)
+                           << " == " << secularEq(right, col0, diag, perm, diag, 0) << " == " << fRight << "\n";
+      }
+#endif
+      eigen_internal_assert(fLeft * fRight < Literal(0));
+
+      if(fLeft<Literal(0))
+      {
+        while (rightShifted - leftShifted > Literal(2) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(abs(leftShifted), abs(rightShifted)))
+        {
+          RealScalar midShifted = (leftShifted + rightShifted) / Literal(2);
+          fMid = secularEq(midShifted, col0, diag, perm, diagShifted, shift);
+          eigen_internal_assert((numext::isfinite)(fMid));
+
+          if (fLeft * fMid < Literal(0))
+          {
+            rightShifted = midShifted;
+          }
+          else
+          {
+            leftShifted = midShifted;
+            fLeft = fMid;
+          }
+        }
+        muCur = (leftShifted + rightShifted) / Literal(2);
+      }
+      else 
+      {
+        // We have a problem as shifting on the left or right give either a positive or negative value
+        // at the middle of [left,right]...
+        // Instead fo abbording or entering an infinite loop,
+        // let's just use the middle as the estimated zero-crossing:
+        muCur = (right - left) * RealScalar(0.5);
+        if(shift == right)
+          muCur = -muCur;
+      }
+    }
+      
+    singVals[k] = shift + muCur;
+    shifts[k] = shift;
+    mus[k] = muCur;
+
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+    if(k+1<n)
+      std::cout << "found " << singVals[k] << " == " << shift << " + " << muCur << " from " << diag(k) << " .. "  << diag(k+1) << "\n";
+#endif
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+    assert(k==0 || singVals[k]>=singVals[k-1]);
+    assert(singVals[k]>=diag(k));
+#endif
+
+    // perturb singular value slightly if it equals diagonal entry to avoid division by zero later
+    // (deflation is supposed to avoid this from happening)
+    // - this does no seem to be necessary anymore -
+//     if (singVals[k] == left) singVals[k] *= 1 + NumTraits<RealScalar>::epsilon();
+//     if (singVals[k] == right) singVals[k] *= 1 - NumTraits<RealScalar>::epsilon();
+  }
+}
+
+
+// zhat is perturbation of col0 for which singular vectors can be computed stably (see Section 3.1)
+template <typename MatrixType>
+void BDCSVD<MatrixType>::perturbCol0
+   (const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm, const VectorType& singVals,
+    const ArrayRef& shifts, const ArrayRef& mus, ArrayRef zhat)
+{
+  using std::sqrt;
+  Index n = col0.size();
+  Index m = perm.size();
+  if(m==0)
+  {
+    zhat.setZero();
+    return;
+  }
+  Index lastIdx = perm(m-1);
+  // The offset permits to skip deflated entries while computing zhat
+  for (Index k = 0; k < n; ++k)
+  {
+    if (col0(k) == Literal(0)) // deflated
+      zhat(k) = Literal(0);
+    else
+    {
+      // see equation (3.6)
+      RealScalar dk = diag(k);
+      RealScalar prod = (singVals(lastIdx) + dk) * (mus(lastIdx) + (shifts(lastIdx) - dk));
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+      if(prod<0) {
+        std::cout << "k = " << k << " ;  z(k)=" << col0(k) << ", diag(k)=" << dk << "\n";
+        std::cout << "prod = " << "(" << singVals(lastIdx) << " + " << dk << ") * (" << mus(lastIdx) << " + (" << shifts(lastIdx) << " - " << dk << "))" << "\n";
+        std::cout << "     = " << singVals(lastIdx) + dk << " * " << mus(lastIdx) + (shifts(lastIdx) - dk) <<  "\n";
+      }
+      assert(prod>=0);
+#endif
+
+      for(Index l = 0; l<m; ++l)
+      {
+        Index i = perm(l);
+        if(i!=k)
+        {
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+          if(i>=k && (l==0 || l-1>=m))
+          {
+            std::cout << "Error in perturbCol0\n";
+            std::cout << "  " << k << "/" << n << " "  << l << "/" << m << " " << i << "/" << n << " ; " << col0(k) << " " << diag(k) << " "  <<  "\n";
+            std::cout << "  " <<diag(i) << "\n";
+            Index j = (i<k /*|| l==0*/) ? i : perm(l-1);
+            std::cout << "  " << "j=" << j << "\n";
+          }
+#endif
+          Index j = i<k ? i : perm(l-1);
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+          if(!(dk!=Literal(0) || diag(i)!=Literal(0)))
+          {
+            std::cout << "k=" << k << ", i=" << i << ", l=" << l << ", perm.size()=" << perm.size() << "\n";
+          }
+          assert(dk!=Literal(0) || diag(i)!=Literal(0));
+#endif
+          prod *= ((singVals(j)+dk) / ((diag(i)+dk))) * ((mus(j)+(shifts(j)-dk)) / ((diag(i)-dk)));
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+          assert(prod>=0);
+#endif
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+          if(i!=k && numext::abs(((singVals(j)+dk)*(mus(j)+(shifts(j)-dk)))/((diag(i)+dk)*(diag(i)-dk)) - 1) > 0.9 )
+            std::cout << "     " << ((singVals(j)+dk)*(mus(j)+(shifts(j)-dk)))/((diag(i)+dk)*(diag(i)-dk)) << " == (" << (singVals(j)+dk) << " * " << (mus(j)+(shifts(j)-dk))
+                       << ") / (" << (diag(i)+dk) << " * " << (diag(i)-dk) << ")\n";
+#endif
+        }
+      }
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "zhat(" << k << ") =  sqrt( " << prod << ")  ;  " << (singVals(lastIdx) + dk) << " * " << mus(lastIdx) + shifts(lastIdx) << " - " << dk << "\n";
+#endif
+      RealScalar tmp = sqrt(prod);
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+      assert((numext::isfinite)(tmp));
+#endif
+      zhat(k) = col0(k) > Literal(0) ? RealScalar(tmp) : RealScalar(-tmp);
+    }
+  }
+}
+
+// compute singular vectors
+template <typename MatrixType>
+void BDCSVD<MatrixType>::computeSingVecs
+   (const ArrayRef& zhat, const ArrayRef& diag, const IndicesRef &perm, const VectorType& singVals,
+    const ArrayRef& shifts, const ArrayRef& mus, MatrixXr& U, MatrixXr& V)
+{
+  Index n = zhat.size();
+  Index m = perm.size();
+  
+  for (Index k = 0; k < n; ++k)
+  {
+    if (zhat(k) == Literal(0))
+    {
+      U.col(k) = VectorType::Unit(n+1, k);
+      if (m_compV) V.col(k) = VectorType::Unit(n, k);
+    }
+    else
+    {
+      U.col(k).setZero();
+      for(Index l=0;l<m;++l)
+      {
+        Index i = perm(l);
+        U(i,k) = zhat(i)/(((diag(i) - shifts(k)) - mus(k)) )/( (diag(i) + singVals[k]));
+      }
+      U(n,k) = Literal(0);
+      U.col(k).normalize();
+    
+      if (m_compV)
+      {
+        V.col(k).setZero();
+        for(Index l=1;l<m;++l)
+        {
+          Index i = perm(l);
+          V(i,k) = diag(i) * zhat(i) / (((diag(i) - shifts(k)) - mus(k)) )/( (diag(i) + singVals[k]));
+        }
+        V(0,k) = Literal(-1);
+        V.col(k).normalize();
+      }
+    }
+  }
+  U.col(n) = VectorType::Unit(n+1, n);
+}
+
+
+// page 12_13
+// i >= 1, di almost null and zi non null.
+// We use a rotation to zero out zi applied to the left of M
+template <typename MatrixType>
+void BDCSVD<MatrixType>::deflation43(Eigen::Index firstCol, Eigen::Index shift, Eigen::Index i, Eigen::Index size)
+{
+  using std::abs;
+  using std::sqrt;
+  using std::pow;
+  Index start = firstCol + shift;
+  RealScalar c = m_computed(start, start);
+  RealScalar s = m_computed(start+i, start);
+  RealScalar r = numext::hypot(c,s);
+  if (r == Literal(0))
+  {
+    m_computed(start+i, start+i) = Literal(0);
+    return;
+  }
+  m_computed(start,start) = r;  
+  m_computed(start+i, start) = Literal(0);
+  m_computed(start+i, start+i) = Literal(0);
+  
+  JacobiRotation<RealScalar> J(c/r,-s/r);
+  if (m_compU)  m_naiveU.middleRows(firstCol, size+1).applyOnTheRight(firstCol, firstCol+i, J);
+  else          m_naiveU.applyOnTheRight(firstCol, firstCol+i, J);
+}// end deflation 43
+
+
+// page 13
+// i,j >= 1, i!=j and |di - dj| < epsilon * norm2(M)
+// We apply two rotations to have zj = 0;
+// TODO deflation44 is still broken and not properly tested
+template <typename MatrixType>
+void BDCSVD<MatrixType>::deflation44(Eigen::Index firstColu , Eigen::Index firstColm, Eigen::Index firstRowW, Eigen::Index firstColW, Eigen::Index i, Eigen::Index j, Eigen::Index size)
+{
+  using std::abs;
+  using std::sqrt;
+  using std::conj;
+  using std::pow;
+  RealScalar c = m_computed(firstColm+i, firstColm);
+  RealScalar s = m_computed(firstColm+j, firstColm);
+  RealScalar r = sqrt(numext::abs2(c) + numext::abs2(s));
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "deflation 4.4: " << i << "," << j << " -> " << c << " " << s << " " << r << " ; "
+    << m_computed(firstColm + i-1, firstColm)  << " "
+    << m_computed(firstColm + i, firstColm)  << " "
+    << m_computed(firstColm + i+1, firstColm) << " "
+    << m_computed(firstColm + i+2, firstColm) << "\n";
+  std::cout << m_computed(firstColm + i-1, firstColm + i-1)  << " "
+    << m_computed(firstColm + i, firstColm+i)  << " "
+    << m_computed(firstColm + i+1, firstColm+i+1) << " "
+    << m_computed(firstColm + i+2, firstColm+i+2) << "\n";
+#endif
+  if (r==Literal(0))
+  {
+    m_computed(firstColm + i, firstColm + i) = m_computed(firstColm + j, firstColm + j);
+    return;
+  }
+  c/=r;
+  s/=r;
+  m_computed(firstColm + i, firstColm) = r;
+  m_computed(firstColm + j, firstColm + j) = m_computed(firstColm + i, firstColm + i);
+  m_computed(firstColm + j, firstColm) = Literal(0);
+
+  JacobiRotation<RealScalar> J(c,-s);
+  if (m_compU)  m_naiveU.middleRows(firstColu, size+1).applyOnTheRight(firstColu + i, firstColu + j, J);
+  else          m_naiveU.applyOnTheRight(firstColu+i, firstColu+j, J);
+  if (m_compV)  m_naiveV.middleRows(firstRowW, size).applyOnTheRight(firstColW + i, firstColW + j, J);
+}// end deflation 44
+
+
+// acts on block from (firstCol+shift, firstCol+shift) to (lastCol+shift, lastCol+shift) [inclusive]
+template <typename MatrixType>
+void BDCSVD<MatrixType>::deflation(Eigen::Index firstCol, Eigen::Index lastCol, Eigen::Index k, Eigen::Index firstRowW, Eigen::Index firstColW, Eigen::Index shift)
+{
+  using std::sqrt;
+  using std::abs;
+  const Index length = lastCol + 1 - firstCol;
+  
+  Block<MatrixXr,Dynamic,1> col0(m_computed, firstCol+shift, firstCol+shift, length, 1);
+  Diagonal<MatrixXr> fulldiag(m_computed);
+  VectorBlock<Diagonal<MatrixXr>,Dynamic> diag(fulldiag, firstCol+shift, length);
+  
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  RealScalar maxDiag = diag.tail((std::max)(Index(1),length-1)).cwiseAbs().maxCoeff();
+  RealScalar epsilon_strict = numext::maxi<RealScalar>(considerZero,NumTraits<RealScalar>::epsilon() * maxDiag);
+  RealScalar epsilon_coarse = Literal(8) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(col0.cwiseAbs().maxCoeff(), maxDiag);
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE  
+  std::cout << "\ndeflate:" << diag.head(k+1).transpose() << "  |  " << diag.segment(k+1,length-k-1).transpose() << "\n";
+#endif
+  
+  //condition 4.1
+  if (diag(0) < epsilon_coarse)
+  { 
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+    std::cout << "deflation 4.1, because " << diag(0) << " < " << epsilon_coarse << "\n";
+#endif
+    diag(0) = epsilon_coarse;
+  }
+
+  //condition 4.2
+  for (Index i=1;i<length;++i)
+    if (abs(col0(i)) < epsilon_strict)
+    {
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "deflation 4.2, set z(" << i << ") to zero because " << abs(col0(i)) << " < " << epsilon_strict << "  (diag(" << i << ")=" << diag(i) << ")\n";
+#endif
+      col0(i) = Literal(0);
+    }
+
+  //condition 4.3
+  for (Index i=1;i<length; i++)
+    if (diag(i) < epsilon_coarse)
+    {
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "deflation 4.3, cancel z(" << i << ")=" << col0(i) << " because diag(" << i << ")=" << diag(i) << " < " << epsilon_coarse << "\n";
+#endif
+      deflation43(firstCol, shift, i, length);
+    }
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "to be sorted: " << diag.transpose() << "\n\n";
+  std::cout << "            : " << col0.transpose() << "\n\n";
+#endif
+  {
+    // Check for total deflation
+    // If we have a total deflation, then we have to consider col0(0)==diag(0) as a singular value during sorting
+    bool total_deflation = (col0.tail(length-1).array()<considerZero).all();
+    
+    // Sort the diagonal entries, since diag(1:k-1) and diag(k:length) are already sorted, let's do a sorted merge.
+    // First, compute the respective permutation.
+    Index *permutation = m_workspaceI.data();
+    {
+      permutation[0] = 0;
+      Index p = 1;
+      
+      // Move deflated diagonal entries at the end.
+      for(Index i=1; i<length; ++i)
+        if(abs(diag(i))<considerZero)
+          permutation[p++] = i;
+        
+      Index i=1, j=k+1;
+      for( ; p < length; ++p)
+      {
+             if (i > k)             permutation[p] = j++;
+        else if (j >= length)       permutation[p] = i++;
+        else if (diag(i) < diag(j)) permutation[p] = j++;
+        else                        permutation[p] = i++;
+      }
+    }
+    
+    // If we have a total deflation, then we have to insert diag(0) at the right place
+    if(total_deflation)
+    {
+      for(Index i=1; i<length; ++i)
+      {
+        Index pi = permutation[i];
+        if(abs(diag(pi))<considerZero || diag(0)<diag(pi))
+          permutation[i-1] = permutation[i];
+        else
+        {
+          permutation[i-1] = 0;
+          break;
+        }
+      }
+    }
+    
+    // Current index of each col, and current column of each index
+    Index *realInd = m_workspaceI.data()+length;
+    Index *realCol = m_workspaceI.data()+2*length;
+    
+    for(int pos = 0; pos< length; pos++)
+    {
+      realCol[pos] = pos;
+      realInd[pos] = pos;
+    }
+    
+    for(Index i = total_deflation?0:1; i < length; i++)
+    {
+      const Index pi = permutation[length - (total_deflation ? i+1 : i)];
+      const Index J = realCol[pi];
+      
+      using std::swap;
+      // swap diagonal and first column entries:
+      swap(diag(i), diag(J));
+      if(i!=0 && J!=0) swap(col0(i), col0(J));
+
+      // change columns
+      if (m_compU) m_naiveU.col(firstCol+i).segment(firstCol, length + 1).swap(m_naiveU.col(firstCol+J).segment(firstCol, length + 1));
+      else         m_naiveU.col(firstCol+i).segment(0, 2)                .swap(m_naiveU.col(firstCol+J).segment(0, 2));
+      if (m_compV) m_naiveV.col(firstColW + i).segment(firstRowW, length).swap(m_naiveV.col(firstColW + J).segment(firstRowW, length));
+
+      //update real pos
+      const Index realI = realInd[i];
+      realCol[realI] = J;
+      realCol[pi] = i;
+      realInd[J] = realI;
+      realInd[i] = pi;
+    }
+  }
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "sorted: " << diag.transpose().format(bdcsvdfmt) << "\n";
+  std::cout << "      : " << col0.transpose() << "\n\n";
+#endif
+    
+  //condition 4.4
+  {
+    Index i = length-1;
+    while(i>0 && (abs(diag(i))<considerZero || abs(col0(i))<considerZero)) --i;
+    for(; i>1;--i)
+       if( (diag(i) - diag(i-1)) < NumTraits<RealScalar>::epsilon()*maxDiag )
+      {
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+        std::cout << "deflation 4.4 with i = " << i << " because " << diag(i) << " - " << diag(i-1) << " == " << (diag(i) - diag(i-1)) << " < " << NumTraits<RealScalar>::epsilon()*/*diag(i)*/maxDiag << "\n";
+#endif
+        eigen_internal_assert(abs(diag(i) - diag(i-1))<epsilon_coarse && " diagonal entries are not properly sorted");
+        deflation44(firstCol, firstCol + shift, firstRowW, firstColW, i-1, i, length);
+      }
+  }
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  for(Index j=2;j<length;++j)
+    assert(diag(j-1)<=diag(j) || abs(diag(j))<considerZero);
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+}//end deflation
+
+/** \svd_module
+  *
+  * \return the singular value decomposition of \c *this computed by Divide & Conquer algorithm
+  *
+  * \sa class BDCSVD
+  */
+template<typename Derived>
+BDCSVD<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::bdcSvd(unsigned int computationOptions) const
+{
+  return BDCSVD<PlainObject>(*this, computationOptions);
+}
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SVD/JacobiSVD.h b/C++/yolo_bytetrack/include/Eigen/src/SVD/JacobiSVD.h
new file mode 100644
index 00000000..9d95acdf
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SVD/JacobiSVD.h
@@ -0,0 +1,812 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2013-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_JACOBISVD_H
+#define EIGEN_JACOBISVD_H
+
+namespace Eigen { 
+
+namespace internal {
+// forward declaration (needed by ICC)
+// the empty body is required by MSVC
+template<typename MatrixType, int QRPreconditioner,
+         bool IsComplex = NumTraits<typename MatrixType::Scalar>::IsComplex>
+struct svd_precondition_2x2_block_to_be_real {};
+
+/*** QR preconditioners (R-SVD)
+ ***
+ *** Their role is to reduce the problem of computing the SVD to the case of a square matrix.
+ *** This approach, known as R-SVD, is an optimization for rectangular-enough matrices, and is a requirement for
+ *** JacobiSVD which by itself is only able to work on square matrices.
+ ***/
+
+enum { PreconditionIfMoreColsThanRows, PreconditionIfMoreRowsThanCols };
+
+template<typename MatrixType, int QRPreconditioner, int Case>
+struct qr_preconditioner_should_do_anything
+{
+  enum { a = MatrixType::RowsAtCompileTime != Dynamic &&
+             MatrixType::ColsAtCompileTime != Dynamic &&
+             MatrixType::ColsAtCompileTime <= MatrixType::RowsAtCompileTime,
+         b = MatrixType::RowsAtCompileTime != Dynamic &&
+             MatrixType::ColsAtCompileTime != Dynamic &&
+             MatrixType::RowsAtCompileTime <= MatrixType::ColsAtCompileTime,
+         ret = !( (QRPreconditioner == NoQRPreconditioner) ||
+                  (Case == PreconditionIfMoreColsThanRows && bool(a)) ||
+                  (Case == PreconditionIfMoreRowsThanCols && bool(b)) )
+  };
+};
+
+template<typename MatrixType, int QRPreconditioner, int Case,
+         bool DoAnything = qr_preconditioner_should_do_anything<MatrixType, QRPreconditioner, Case>::ret
+> struct qr_preconditioner_impl {};
+
+template<typename MatrixType, int QRPreconditioner, int Case>
+class qr_preconditioner_impl<MatrixType, QRPreconditioner, Case, false>
+{
+public:
+  void allocate(const JacobiSVD<MatrixType, QRPreconditioner>&) {}
+  bool run(JacobiSVD<MatrixType, QRPreconditioner>&, const MatrixType&)
+  {
+    return false;
+  }
+};
+
+/*** preconditioner using FullPivHouseholderQR ***/
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime
+  };
+  typedef Matrix<Scalar, 1, RowsAtCompileTime, RowMajor, 1, MaxRowsAtCompileTime> WorkspaceType;
+
+  void allocate(const JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.rows(), svd.cols());
+    }
+    if (svd.m_computeFullU) m_workspace.resize(svd.rows());
+  }
+
+  bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.rows() > matrix.cols())
+    {
+      m_qr.compute(matrix);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).template triangularView<Upper>();
+      if(svd.m_computeFullU) m_qr.matrixQ().evalTo(svd.m_matrixU, m_workspace);
+      if(svd.computeV()) svd.m_matrixV = m_qr.colsPermutation();
+      return true;
+    }
+    return false;
+  }
+private:
+  typedef FullPivHouseholderQR<MatrixType> QRType;
+  QRType m_qr;
+  WorkspaceType m_workspace;
+};
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    Options = MatrixType::Options
+  };
+
+  typedef typename internal::make_proper_matrix_type<
+    Scalar, ColsAtCompileTime, RowsAtCompileTime, Options, MaxColsAtCompileTime, MaxRowsAtCompileTime
+  >::type TransposeTypeWithSameStorageOrder;
+
+  void allocate(const JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.cols(), svd.rows());
+    }
+    m_adjoint.resize(svd.cols(), svd.rows());
+    if (svd.m_computeFullV) m_workspace.resize(svd.cols());
+  }
+
+  bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.cols() > matrix.rows())
+    {
+      m_adjoint = matrix.adjoint();
+      m_qr.compute(m_adjoint);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).template triangularView<Upper>().adjoint();
+      if(svd.m_computeFullV) m_qr.matrixQ().evalTo(svd.m_matrixV, m_workspace);
+      if(svd.computeU()) svd.m_matrixU = m_qr.colsPermutation();
+      return true;
+    }
+    else return false;
+  }
+private:
+  typedef FullPivHouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  QRType m_qr;
+  TransposeTypeWithSameStorageOrder m_adjoint;
+  typename internal::plain_row_type<MatrixType>::type m_workspace;
+};
+
+/*** preconditioner using ColPivHouseholderQR ***/
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true>
+{
+public:
+  void allocate(const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.rows(), svd.cols());
+    }
+    if (svd.m_computeFullU) m_workspace.resize(svd.rows());
+    else if (svd.m_computeThinU) m_workspace.resize(svd.cols());
+  }
+
+  bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.rows() > matrix.cols())
+    {
+      m_qr.compute(matrix);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).template triangularView<Upper>();
+      if(svd.m_computeFullU) m_qr.householderQ().evalTo(svd.m_matrixU, m_workspace);
+      else if(svd.m_computeThinU)
+      {
+        svd.m_matrixU.setIdentity(matrix.rows(), matrix.cols());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixU, m_workspace);
+      }
+      if(svd.computeV()) svd.m_matrixV = m_qr.colsPermutation();
+      return true;
+    }
+    return false;
+  }
+
+private:
+  typedef ColPivHouseholderQR<MatrixType> QRType;
+  QRType m_qr;
+  typename internal::plain_col_type<MatrixType>::type m_workspace;
+};
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    Options = MatrixType::Options
+  };
+
+  typedef typename internal::make_proper_matrix_type<
+    Scalar, ColsAtCompileTime, RowsAtCompileTime, Options, MaxColsAtCompileTime, MaxRowsAtCompileTime
+  >::type TransposeTypeWithSameStorageOrder;
+
+  void allocate(const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.cols(), svd.rows());
+    }
+    if (svd.m_computeFullV) m_workspace.resize(svd.cols());
+    else if (svd.m_computeThinV) m_workspace.resize(svd.rows());
+    m_adjoint.resize(svd.cols(), svd.rows());
+  }
+
+  bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.cols() > matrix.rows())
+    {
+      m_adjoint = matrix.adjoint();
+      m_qr.compute(m_adjoint);
+
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).template triangularView<Upper>().adjoint();
+      if(svd.m_computeFullV) m_qr.householderQ().evalTo(svd.m_matrixV, m_workspace);
+      else if(svd.m_computeThinV)
+      {
+        svd.m_matrixV.setIdentity(matrix.cols(), matrix.rows());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixV, m_workspace);
+      }
+      if(svd.computeU()) svd.m_matrixU = m_qr.colsPermutation();
+      return true;
+    }
+    else return false;
+  }
+
+private:
+  typedef ColPivHouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  QRType m_qr;
+  TransposeTypeWithSameStorageOrder m_adjoint;
+  typename internal::plain_row_type<MatrixType>::type m_workspace;
+};
+
+/*** preconditioner using HouseholderQR ***/
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true>
+{
+public:
+  void allocate(const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd)
+  {
+    if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.rows(), svd.cols());
+    }
+    if (svd.m_computeFullU) m_workspace.resize(svd.rows());
+    else if (svd.m_computeThinU) m_workspace.resize(svd.cols());
+  }
+
+  bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.rows() > matrix.cols())
+    {
+      m_qr.compute(matrix);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).template triangularView<Upper>();
+      if(svd.m_computeFullU) m_qr.householderQ().evalTo(svd.m_matrixU, m_workspace);
+      else if(svd.m_computeThinU)
+      {
+        svd.m_matrixU.setIdentity(matrix.rows(), matrix.cols());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixU, m_workspace);
+      }
+      if(svd.computeV()) svd.m_matrixV.setIdentity(matrix.cols(), matrix.cols());
+      return true;
+    }
+    return false;
+  }
+private:
+  typedef HouseholderQR<MatrixType> QRType;
+  QRType m_qr;
+  typename internal::plain_col_type<MatrixType>::type m_workspace;
+};
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    Options = MatrixType::Options
+  };
+
+  typedef typename internal::make_proper_matrix_type<
+    Scalar, ColsAtCompileTime, RowsAtCompileTime, Options, MaxColsAtCompileTime, MaxRowsAtCompileTime
+  >::type TransposeTypeWithSameStorageOrder;
+
+  void allocate(const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd)
+  {
+    if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.cols(), svd.rows());
+    }
+    if (svd.m_computeFullV) m_workspace.resize(svd.cols());
+    else if (svd.m_computeThinV) m_workspace.resize(svd.rows());
+    m_adjoint.resize(svd.cols(), svd.rows());
+  }
+
+  bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.cols() > matrix.rows())
+    {
+      m_adjoint = matrix.adjoint();
+      m_qr.compute(m_adjoint);
+
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).template triangularView<Upper>().adjoint();
+      if(svd.m_computeFullV) m_qr.householderQ().evalTo(svd.m_matrixV, m_workspace);
+      else if(svd.m_computeThinV)
+      {
+        svd.m_matrixV.setIdentity(matrix.cols(), matrix.rows());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixV, m_workspace);
+      }
+      if(svd.computeU()) svd.m_matrixU.setIdentity(matrix.rows(), matrix.rows());
+      return true;
+    }
+    else return false;
+  }
+
+private:
+  typedef HouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  QRType m_qr;
+  TransposeTypeWithSameStorageOrder m_adjoint;
+  typename internal::plain_row_type<MatrixType>::type m_workspace;
+};
+
+/*** 2x2 SVD implementation
+ ***
+ *** JacobiSVD consists in performing a series of 2x2 SVD subproblems
+ ***/
+
+template<typename MatrixType, int QRPreconditioner>
+struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, false>
+{
+  typedef JacobiSVD<MatrixType, QRPreconditioner> SVD;
+  typedef typename MatrixType::RealScalar RealScalar;
+  static bool run(typename SVD::WorkMatrixType&, SVD&, Index, Index, RealScalar&) { return true; }
+};
+
+template<typename MatrixType, int QRPreconditioner>
+struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, true>
+{
+  typedef JacobiSVD<MatrixType, QRPreconditioner> SVD;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  static bool run(typename SVD::WorkMatrixType& work_matrix, SVD& svd, Index p, Index q, RealScalar& maxDiagEntry)
+  {
+    using std::sqrt;
+    using std::abs;
+    Scalar z;
+    JacobiRotation<Scalar> rot;
+    RealScalar n = sqrt(numext::abs2(work_matrix.coeff(p,p)) + numext::abs2(work_matrix.coeff(q,p)));
+
+    const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+    const RealScalar precision = NumTraits<Scalar>::epsilon();
+
+    if(n==0)
+    {
+      // make sure first column is zero
+      work_matrix.coeffRef(p,p) = work_matrix.coeffRef(q,p) = Scalar(0);
+
+      if(abs(numext::imag(work_matrix.coeff(p,q)))>considerAsZero)
+      {
+        // work_matrix.coeff(p,q) can be zero if work_matrix.coeff(q,p) is not zero but small enough to underflow when computing n
+        z = abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q);
+        work_matrix.row(p) *= z;
+        if(svd.computeU()) svd.m_matrixU.col(p) *= conj(z);
+      }
+      if(abs(numext::imag(work_matrix.coeff(q,q)))>considerAsZero)
+      {
+        z = abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q);
+        work_matrix.row(q) *= z;
+        if(svd.computeU()) svd.m_matrixU.col(q) *= conj(z);
+      }
+      // otherwise the second row is already zero, so we have nothing to do.
+    }
+    else
+    {
+      rot.c() = conj(work_matrix.coeff(p,p)) / n;
+      rot.s() = work_matrix.coeff(q,p) / n;
+      work_matrix.applyOnTheLeft(p,q,rot);
+      if(svd.computeU()) svd.m_matrixU.applyOnTheRight(p,q,rot.adjoint());
+      if(abs(numext::imag(work_matrix.coeff(p,q)))>considerAsZero)
+      {
+        z = abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q);
+        work_matrix.col(q) *= z;
+        if(svd.computeV()) svd.m_matrixV.col(q) *= z;
+      }
+      if(abs(numext::imag(work_matrix.coeff(q,q)))>considerAsZero)
+      {
+        z = abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q);
+        work_matrix.row(q) *= z;
+        if(svd.computeU()) svd.m_matrixU.col(q) *= conj(z);
+      }
+    }
+
+    // update largest diagonal entry
+    maxDiagEntry = numext::maxi<RealScalar>(maxDiagEntry,numext::maxi<RealScalar>(abs(work_matrix.coeff(p,p)), abs(work_matrix.coeff(q,q))));
+    // and check whether the 2x2 block is already diagonal
+    RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
+    return abs(work_matrix.coeff(p,q))>threshold || abs(work_matrix.coeff(q,p)) > threshold;
+  }
+};
+
+template<typename _MatrixType, int QRPreconditioner> 
+struct traits<JacobiSVD<_MatrixType,QRPreconditioner> >
+        : traits<_MatrixType>
+{
+  typedef _MatrixType MatrixType;
+};
+
+} // end namespace internal
+
+/** \ingroup SVD_Module
+  *
+  *
+  * \class JacobiSVD
+  *
+  * \brief Two-sided Jacobi SVD decomposition of a rectangular matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the SVD decomposition
+  * \tparam QRPreconditioner this optional parameter allows to specify the type of QR decomposition that will be used internally
+  *                        for the R-SVD step for non-square matrices. See discussion of possible values below.
+  *
+  * SVD decomposition consists in decomposing any n-by-p matrix \a A as a product
+  *   \f[ A = U S V^* \f]
+  * where \a U is a n-by-n unitary, \a V is a p-by-p unitary, and \a S is a n-by-p real positive matrix which is zero outside of its main diagonal;
+  * the diagonal entries of S are known as the \em singular \em values of \a A and the columns of \a U and \a V are known as the left
+  * and right \em singular \em vectors of \a A respectively.
+  *
+  * Singular values are always sorted in decreasing order.
+  *
+  * This JacobiSVD decomposition computes only the singular values by default. If you want \a U or \a V, you need to ask for them explicitly.
+  *
+  * You can ask for only \em thin \a U or \a V to be computed, meaning the following. In case of a rectangular n-by-p matrix, letting \a m be the
+  * smaller value among \a n and \a p, there are only \a m singular vectors; the remaining columns of \a U and \a V do not correspond to actual
+  * singular vectors. Asking for \em thin \a U or \a V means asking for only their \a m first columns to be formed. So \a U is then a n-by-m matrix,
+  * and \a V is then a p-by-m matrix. Notice that thin \a U and \a V are all you need for (least squares) solving.
+  *
+  * Here's an example demonstrating basic usage:
+  * \include JacobiSVD_basic.cpp
+  * Output: \verbinclude JacobiSVD_basic.out
+  *
+  * This JacobiSVD class is a two-sided Jacobi R-SVD decomposition, ensuring optimal reliability and accuracy. The downside is that it's slower than
+  * bidiagonalizing SVD algorithms for large square matrices; however its complexity is still \f$ O(n^2p) \f$ where \a n is the smaller dimension and
+  * \a p is the greater dimension, meaning that it is still of the same order of complexity as the faster bidiagonalizing R-SVD algorithms.
+  * In particular, like any R-SVD, it takes advantage of non-squareness in that its complexity is only linear in the greater dimension.
+  *
+  * If the input matrix has inf or nan coefficients, the result of the computation is undefined, but the computation is guaranteed to
+  * terminate in finite (and reasonable) time.
+  *
+  * The possible values for QRPreconditioner are:
+  * \li ColPivHouseholderQRPreconditioner is the default. In practice it's very safe. It uses column-pivoting QR.
+  * \li FullPivHouseholderQRPreconditioner, is the safest and slowest. It uses full-pivoting QR.
+  *     Contrary to other QRs, it doesn't allow computing thin unitaries.
+  * \li HouseholderQRPreconditioner is the fastest, and less safe and accurate than the pivoting variants. It uses non-pivoting QR.
+  *     This is very similar in safety and accuracy to the bidiagonalization process used by bidiagonalizing SVD algorithms (since bidiagonalization
+  *     is inherently non-pivoting). However the resulting SVD is still more reliable than bidiagonalizing SVDs because the Jacobi-based iterarive
+  *     process is more reliable than the optimized bidiagonal SVD iterations.
+  * \li NoQRPreconditioner allows not to use a QR preconditioner at all. This is useful if you know that you will only be computing
+  *     JacobiSVD decompositions of square matrices. Non-square matrices require a QR preconditioner. Using this option will result in
+  *     faster compilation and smaller executable code. It won't significantly speed up computation, since JacobiSVD is always checking
+  *     if QR preconditioning is needed before applying it anyway.
+  *
+  * \sa MatrixBase::jacobiSvd()
+  */
+template<typename _MatrixType, int QRPreconditioner> class JacobiSVD
+ : public SVDBase<JacobiSVD<_MatrixType,QRPreconditioner> >
+{
+    typedef SVDBase<JacobiSVD> Base;
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime),
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+      MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime,MaxColsAtCompileTime),
+      MatrixOptions = MatrixType::Options
+    };
+
+    typedef typename Base::MatrixUType MatrixUType;
+    typedef typename Base::MatrixVType MatrixVType;
+    typedef typename Base::SingularValuesType SingularValuesType;
+    
+    typedef typename internal::plain_row_type<MatrixType>::type RowType;
+    typedef typename internal::plain_col_type<MatrixType>::type ColType;
+    typedef Matrix<Scalar, DiagSizeAtCompileTime, DiagSizeAtCompileTime,
+                   MatrixOptions, MaxDiagSizeAtCompileTime, MaxDiagSizeAtCompileTime>
+            WorkMatrixType;
+
+    /** \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via JacobiSVD::compute(const MatrixType&).
+      */
+    JacobiSVD()
+    {}
+
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem size.
+      * \sa JacobiSVD()
+      */
+    JacobiSVD(Index rows, Index cols, unsigned int computationOptions = 0)
+    {
+      allocate(rows, cols, computationOptions);
+    }
+
+    /** \brief Constructor performing the decomposition of given matrix.
+     *
+     * \param matrix the matrix to decompose
+     * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+     *                           By default, none is computed. This is a bit-field, the possible bits are #ComputeFullU, #ComputeThinU,
+     *                           #ComputeFullV, #ComputeThinV.
+     *
+     * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+     * available with the (non-default) FullPivHouseholderQR preconditioner.
+     */
+    explicit JacobiSVD(const MatrixType& matrix, unsigned int computationOptions = 0)
+    {
+      compute(matrix, computationOptions);
+    }
+
+    /** \brief Method performing the decomposition of given matrix using custom options.
+     *
+     * \param matrix the matrix to decompose
+     * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+     *                           By default, none is computed. This is a bit-field, the possible bits are #ComputeFullU, #ComputeThinU,
+     *                           #ComputeFullV, #ComputeThinV.
+     *
+     * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+     * available with the (non-default) FullPivHouseholderQR preconditioner.
+     */
+    JacobiSVD& compute(const MatrixType& matrix, unsigned int computationOptions);
+
+    /** \brief Method performing the decomposition of given matrix using current options.
+     *
+     * \param matrix the matrix to decompose
+     *
+     * This method uses the current \a computationOptions, as already passed to the constructor or to compute(const MatrixType&, unsigned int).
+     */
+    JacobiSVD& compute(const MatrixType& matrix)
+    {
+      return compute(matrix, m_computationOptions);
+    }
+
+    using Base::computeU;
+    using Base::computeV;
+    using Base::rows;
+    using Base::cols;
+    using Base::rank;
+
+  private:
+    void allocate(Index rows, Index cols, unsigned int computationOptions);
+
+  protected:
+    using Base::m_matrixU;
+    using Base::m_matrixV;
+    using Base::m_singularValues;
+    using Base::m_info;
+    using Base::m_isInitialized;
+    using Base::m_isAllocated;
+    using Base::m_usePrescribedThreshold;
+    using Base::m_computeFullU;
+    using Base::m_computeThinU;
+    using Base::m_computeFullV;
+    using Base::m_computeThinV;
+    using Base::m_computationOptions;
+    using Base::m_nonzeroSingularValues;
+    using Base::m_rows;
+    using Base::m_cols;
+    using Base::m_diagSize;
+    using Base::m_prescribedThreshold;
+    WorkMatrixType m_workMatrix;
+
+    template<typename __MatrixType, int _QRPreconditioner, bool _IsComplex>
+    friend struct internal::svd_precondition_2x2_block_to_be_real;
+    template<typename __MatrixType, int _QRPreconditioner, int _Case, bool _DoAnything>
+    friend struct internal::qr_preconditioner_impl;
+
+    internal::qr_preconditioner_impl<MatrixType, QRPreconditioner, internal::PreconditionIfMoreColsThanRows> m_qr_precond_morecols;
+    internal::qr_preconditioner_impl<MatrixType, QRPreconditioner, internal::PreconditionIfMoreRowsThanCols> m_qr_precond_morerows;
+    MatrixType m_scaledMatrix;
+};
+
+template<typename MatrixType, int QRPreconditioner>
+void JacobiSVD<MatrixType, QRPreconditioner>::allocate(Eigen::Index rows, Eigen::Index cols, unsigned int computationOptions)
+{
+  eigen_assert(rows >= 0 && cols >= 0);
+
+  if (m_isAllocated &&
+      rows == m_rows &&
+      cols == m_cols &&
+      computationOptions == m_computationOptions)
+  {
+    return;
+  }
+
+  m_rows = rows;
+  m_cols = cols;
+  m_info = Success;
+  m_isInitialized = false;
+  m_isAllocated = true;
+  m_computationOptions = computationOptions;
+  m_computeFullU = (computationOptions & ComputeFullU) != 0;
+  m_computeThinU = (computationOptions & ComputeThinU) != 0;
+  m_computeFullV = (computationOptions & ComputeFullV) != 0;
+  m_computeThinV = (computationOptions & ComputeThinV) != 0;
+  eigen_assert(!(m_computeFullU && m_computeThinU) && "JacobiSVD: you can't ask for both full and thin U");
+  eigen_assert(!(m_computeFullV && m_computeThinV) && "JacobiSVD: you can't ask for both full and thin V");
+  eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) &&
+              "JacobiSVD: thin U and V are only available when your matrix has a dynamic number of columns.");
+  if (QRPreconditioner == FullPivHouseholderQRPreconditioner)
+  {
+      eigen_assert(!(m_computeThinU || m_computeThinV) &&
+              "JacobiSVD: can't compute thin U or thin V with the FullPivHouseholderQR preconditioner. "
+              "Use the ColPivHouseholderQR preconditioner instead.");
+  }
+  m_diagSize = (std::min)(m_rows, m_cols);
+  m_singularValues.resize(m_diagSize);
+  if(RowsAtCompileTime==Dynamic)
+    m_matrixU.resize(m_rows, m_computeFullU ? m_rows
+                            : m_computeThinU ? m_diagSize
+                            : 0);
+  if(ColsAtCompileTime==Dynamic)
+    m_matrixV.resize(m_cols, m_computeFullV ? m_cols
+                            : m_computeThinV ? m_diagSize
+                            : 0);
+  m_workMatrix.resize(m_diagSize, m_diagSize);
+  
+  if(m_cols>m_rows)   m_qr_precond_morecols.allocate(*this);
+  if(m_rows>m_cols)   m_qr_precond_morerows.allocate(*this);
+  if(m_rows!=m_cols)  m_scaledMatrix.resize(rows,cols);
+}
+
+template<typename MatrixType, int QRPreconditioner>
+JacobiSVD<MatrixType, QRPreconditioner>&
+JacobiSVD<MatrixType, QRPreconditioner>::compute(const MatrixType& matrix, unsigned int computationOptions)
+{
+  using std::abs;
+  allocate(matrix.rows(), matrix.cols(), computationOptions);
+
+  // currently we stop when we reach precision 2*epsilon as the last bit of precision can require an unreasonable number of iterations,
+  // only worsening the precision of U and V as we accumulate more rotations
+  const RealScalar precision = RealScalar(2) * NumTraits<Scalar>::epsilon();
+
+  // limit for denormal numbers to be considered zero in order to avoid infinite loops (see bug 286)
+  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+
+  // Scaling factor to reduce over/under-flows
+  RealScalar scale = matrix.cwiseAbs().template maxCoeff<PropagateNaN>();
+  if (!(numext::isfinite)(scale)) {
+    m_isInitialized = true;
+    m_info = InvalidInput;
+    return *this;
+  }
+  if(scale==RealScalar(0)) scale = RealScalar(1);
+  
+  /*** step 1. The R-SVD step: we use a QR decomposition to reduce to the case of a square matrix */
+
+  if(m_rows!=m_cols)
+  {
+    m_scaledMatrix = matrix / scale;
+    m_qr_precond_morecols.run(*this, m_scaledMatrix);
+    m_qr_precond_morerows.run(*this, m_scaledMatrix);
+  }
+  else
+  {
+    m_workMatrix = matrix.block(0,0,m_diagSize,m_diagSize) / scale;
+    if(m_computeFullU) m_matrixU.setIdentity(m_rows,m_rows);
+    if(m_computeThinU) m_matrixU.setIdentity(m_rows,m_diagSize);
+    if(m_computeFullV) m_matrixV.setIdentity(m_cols,m_cols);
+    if(m_computeThinV) m_matrixV.setIdentity(m_cols, m_diagSize);
+  }
+
+  /*** step 2. The main Jacobi SVD iteration. ***/
+  RealScalar maxDiagEntry = m_workMatrix.cwiseAbs().diagonal().maxCoeff();
+
+  bool finished = false;
+  while(!finished)
+  {
+    finished = true;
+
+    // do a sweep: for all index pairs (p,q), perform SVD of the corresponding 2x2 sub-matrix
+
+    for(Index p = 1; p < m_diagSize; ++p)
+    {
+      for(Index q = 0; q < p; ++q)
+      {
+        // if this 2x2 sub-matrix is not diagonal already...
+        // notice that this comparison will evaluate to false if any NaN is involved, ensuring that NaN's don't
+        // keep us iterating forever. Similarly, small denormal numbers are considered zero.
+        RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
+        if(abs(m_workMatrix.coeff(p,q))>threshold || abs(m_workMatrix.coeff(q,p)) > threshold)
+        {
+          finished = false;
+          // perform SVD decomposition of 2x2 sub-matrix corresponding to indices p,q to make it diagonal
+          // the complex to real operation returns true if the updated 2x2 block is not already diagonal
+          if(internal::svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner>::run(m_workMatrix, *this, p, q, maxDiagEntry))
+          {
+            JacobiRotation<RealScalar> j_left, j_right;
+            internal::real_2x2_jacobi_svd(m_workMatrix, p, q, &j_left, &j_right);
+
+            // accumulate resulting Jacobi rotations
+            m_workMatrix.applyOnTheLeft(p,q,j_left);
+            if(computeU()) m_matrixU.applyOnTheRight(p,q,j_left.transpose());
+
+            m_workMatrix.applyOnTheRight(p,q,j_right);
+            if(computeV()) m_matrixV.applyOnTheRight(p,q,j_right);
+
+            // keep track of the largest diagonal coefficient
+            maxDiagEntry = numext::maxi<RealScalar>(maxDiagEntry,numext::maxi<RealScalar>(abs(m_workMatrix.coeff(p,p)), abs(m_workMatrix.coeff(q,q))));
+          }
+        }
+      }
+    }
+  }
+
+  /*** step 3. The work matrix is now diagonal, so ensure it's positive so its diagonal entries are the singular values ***/
+
+  for(Index i = 0; i < m_diagSize; ++i)
+  {
+    // For a complex matrix, some diagonal coefficients might note have been
+    // treated by svd_precondition_2x2_block_to_be_real, and the imaginary part
+    // of some diagonal entry might not be null.
+    if(NumTraits<Scalar>::IsComplex && abs(numext::imag(m_workMatrix.coeff(i,i)))>considerAsZero)
+    {
+      RealScalar a = abs(m_workMatrix.coeff(i,i));
+      m_singularValues.coeffRef(i) = abs(a);
+      if(computeU()) m_matrixU.col(i) *= m_workMatrix.coeff(i,i)/a;
+    }
+    else
+    {
+      // m_workMatrix.coeff(i,i) is already real, no difficulty:
+      RealScalar a = numext::real(m_workMatrix.coeff(i,i));
+      m_singularValues.coeffRef(i) = abs(a);
+      if(computeU() && (a<RealScalar(0))) m_matrixU.col(i) = -m_matrixU.col(i);
+    }
+  }
+  
+  m_singularValues *= scale;
+
+  /*** step 4. Sort singular values in descending order and compute the number of nonzero singular values ***/
+
+  m_nonzeroSingularValues = m_diagSize;
+  for(Index i = 0; i < m_diagSize; i++)
+  {
+    Index pos;
+    RealScalar maxRemainingSingularValue = m_singularValues.tail(m_diagSize-i).maxCoeff(&pos);
+    if(maxRemainingSingularValue == RealScalar(0))
+    {
+      m_nonzeroSingularValues = i;
+      break;
+    }
+    if(pos)
+    {
+      pos += i;
+      std::swap(m_singularValues.coeffRef(i), m_singularValues.coeffRef(pos));
+      if(computeU()) m_matrixU.col(pos).swap(m_matrixU.col(i));
+      if(computeV()) m_matrixV.col(pos).swap(m_matrixV.col(i));
+    }
+  }
+
+  m_isInitialized = true;
+  return *this;
+}
+
+/** \svd_module
+  *
+  * \return the singular value decomposition of \c *this computed by two-sided
+  * Jacobi transformations.
+  *
+  * \sa class JacobiSVD
+  */
+template<typename Derived>
+JacobiSVD<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::jacobiSvd(unsigned int computationOptions) const
+{
+  return JacobiSVD<PlainObject>(*this, computationOptions);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_JACOBISVD_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SVD/JacobiSVD_LAPACKE.h b/C++/yolo_bytetrack/include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
new file mode 100644
index 00000000..ff0516f6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
@@ -0,0 +1,91 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Singular Value Decomposition - SVD.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_JACOBISVD_LAPACKE_H
+#define EIGEN_JACOBISVD_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_SVD(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_PREFIX, EIGCOLROW, LAPACKE_COLROW) \
+template<> inline \
+JacobiSVD<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>, ColPivHouseholderQRPreconditioner>& \
+JacobiSVD<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>, ColPivHouseholderQRPreconditioner>::compute(const Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>& matrix, unsigned int computationOptions) \
+{ \
+  typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> MatrixType; \
+  /*typedef MatrixType::Scalar Scalar;*/ \
+  /*typedef MatrixType::RealScalar RealScalar;*/ \
+  allocate(matrix.rows(), matrix.cols(), computationOptions); \
+\
+  /*const RealScalar precision = RealScalar(2) * NumTraits<Scalar>::epsilon();*/ \
+  m_nonzeroSingularValues = m_diagSize; \
+\
+  lapack_int lda = internal::convert_index<lapack_int>(matrix.outerStride()), ldu, ldvt; \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  char jobu, jobvt; \
+  LAPACKE_TYPE *u, *vt, dummy; \
+  jobu  = (m_computeFullU) ? 'A' : (m_computeThinU) ? 'S' : 'N'; \
+  jobvt = (m_computeFullV) ? 'A' : (m_computeThinV) ? 'S' : 'N'; \
+  if (computeU()) { \
+    ldu  = internal::convert_index<lapack_int>(m_matrixU.outerStride()); \
+    u    = (LAPACKE_TYPE*)m_matrixU.data(); \
+  } else { ldu=1; u=&dummy; }\
+  MatrixType localV; \
+  lapack_int vt_rows = (m_computeFullV) ? internal::convert_index<lapack_int>(m_cols) : (m_computeThinV) ? internal::convert_index<lapack_int>(m_diagSize) : 1; \
+  if (computeV()) { \
+    localV.resize(vt_rows, m_cols); \
+    ldvt  = internal::convert_index<lapack_int>(localV.outerStride()); \
+    vt   = (LAPACKE_TYPE*)localV.data(); \
+  } else { ldvt=1; vt=&dummy; }\
+  Matrix<LAPACKE_RTYPE, Dynamic, Dynamic> superb; superb.resize(m_diagSize, 1); \
+  MatrixType m_temp; m_temp = matrix; \
+  LAPACKE_##LAPACKE_PREFIX##gesvd( matrix_order, jobu, jobvt, internal::convert_index<lapack_int>(m_rows), internal::convert_index<lapack_int>(m_cols), (LAPACKE_TYPE*)m_temp.data(), lda, (LAPACKE_RTYPE*)m_singularValues.data(), u, ldu, vt, ldvt, superb.data()); \
+  if (computeV()) m_matrixV = localV.adjoint(); \
+ /* for(int i=0;i<m_diagSize;i++) if (m_singularValues.coeffRef(i) < precision) { m_nonzeroSingularValues--; m_singularValues.coeffRef(i)=RealScalar(0);}*/ \
+  m_isInitialized = true; \
+  return *this; \
+}
+
+EIGEN_LAPACKE_SVD(double,   double,                double, d, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SVD(float,    float,                 float , s, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SVD(dcomplex, lapack_complex_double, double, z, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SVD(scomplex, lapack_complex_float,  float , c, ColMajor, LAPACK_COL_MAJOR)
+
+EIGEN_LAPACKE_SVD(double,   double,                double, d, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SVD(float,    float,                 float , s, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SVD(dcomplex, lapack_complex_double, double, z, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SVD(scomplex, lapack_complex_float,  float , c, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_JACOBISVD_LAPACKE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SVD/SVDBase.h b/C++/yolo_bytetrack/include/Eigen/src/SVD/SVDBase.h
new file mode 100644
index 00000000..bc7ab88b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SVD/SVDBase.h
@@ -0,0 +1,376 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// Copyright (C) 2013 Gauthier Brun <brun.gauthier@gmail.com>
+// Copyright (C) 2013 Nicolas Carre <nicolas.carre@ensimag.fr>
+// Copyright (C) 2013 Jean Ceccato <jean.ceccato@ensimag.fr>
+// Copyright (C) 2013 Pierre Zoppitelli <pierre.zoppitelli@ensimag.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SVDBASE_H
+#define EIGEN_SVDBASE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename Derived> struct traits<SVDBase<Derived> >
+ : traits<Derived>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+}
+
+/** \ingroup SVD_Module
+ *
+ *
+ * \class SVDBase
+ *
+ * \brief Base class of SVD algorithms
+ *
+ * \tparam Derived the type of the actual SVD decomposition
+ *
+ * SVD decomposition consists in decomposing any n-by-p matrix \a A as a product
+ *   \f[ A = U S V^* \f]
+ * where \a U is a n-by-n unitary, \a V is a p-by-p unitary, and \a S is a n-by-p real positive matrix which is zero outside of its main diagonal;
+ * the diagonal entries of S are known as the \em singular \em values of \a A and the columns of \a U and \a V are known as the left
+ * and right \em singular \em vectors of \a A respectively.
+ *
+ * Singular values are always sorted in decreasing order.
+ *
+ * 
+ * You can ask for only \em thin \a U or \a V to be computed, meaning the following. In case of a rectangular n-by-p matrix, letting \a m be the
+ * smaller value among \a n and \a p, there are only \a m singular vectors; the remaining columns of \a U and \a V do not correspond to actual
+ * singular vectors. Asking for \em thin \a U or \a V means asking for only their \a m first columns to be formed. So \a U is then a n-by-m matrix,
+ * and \a V is then a p-by-m matrix. Notice that thin \a U and \a V are all you need for (least squares) solving.
+ * 
+ * The status of the computation can be retrived using the \a info() method. Unless \a info() returns \a Success, the results should be not
+ * considered well defined.
+ *  
+ * If the input matrix has inf or nan coefficients, the result of the computation is undefined, and \a info() will return \a InvalidInput, but the computation is guaranteed to
+ * terminate in finite (and reasonable) time.
+ * \sa class BDCSVD, class JacobiSVD
+ */
+template<typename Derived> class SVDBase
+ : public SolverBase<SVDBase<Derived> >
+{
+public: 
+   
+  template<typename Derived_>
+  friend struct internal::solve_assertion;
+
+  typedef typename internal::traits<Derived>::MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+  typedef typename Eigen::internal::traits<SVDBase>::StorageIndex StorageIndex;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime),
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime,MaxColsAtCompileTime),
+    MatrixOptions = MatrixType::Options
+  };
+
+  typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, MatrixOptions, MaxRowsAtCompileTime, MaxRowsAtCompileTime> MatrixUType;
+  typedef Matrix<Scalar, ColsAtCompileTime, ColsAtCompileTime, MatrixOptions, MaxColsAtCompileTime, MaxColsAtCompileTime> MatrixVType;
+  typedef typename internal::plain_diag_type<MatrixType, RealScalar>::type SingularValuesType;
+  
+  Derived& derived() { return *static_cast<Derived*>(this); }
+  const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+  /** \returns the \a U matrix.
+   *
+   * For the SVD decomposition of a n-by-p matrix, letting \a m be the minimum of \a n and \a p,
+   * the U matrix is n-by-n if you asked for \link Eigen::ComputeFullU ComputeFullU \endlink, and is n-by-m if you asked for \link Eigen::ComputeThinU ComputeThinU \endlink.
+   *
+   * The \a m first columns of \a U are the left singular vectors of the matrix being decomposed.
+   *
+   * This method asserts that you asked for \a U to be computed.
+   */
+  const MatrixUType& matrixU() const
+  {
+    _check_compute_assertions();
+    eigen_assert(computeU() && "This SVD decomposition didn't compute U. Did you ask for it?");
+    return m_matrixU;
+  }
+
+  /** \returns the \a V matrix.
+   *
+   * For the SVD decomposition of a n-by-p matrix, letting \a m be the minimum of \a n and \a p,
+   * the V matrix is p-by-p if you asked for \link Eigen::ComputeFullV ComputeFullV \endlink, and is p-by-m if you asked for \link Eigen::ComputeThinV ComputeThinV \endlink.
+   *
+   * The \a m first columns of \a V are the right singular vectors of the matrix being decomposed.
+   *
+   * This method asserts that you asked for \a V to be computed.
+   */
+  const MatrixVType& matrixV() const
+  {
+    _check_compute_assertions();
+    eigen_assert(computeV() && "This SVD decomposition didn't compute V. Did you ask for it?");
+    return m_matrixV;
+  }
+
+  /** \returns the vector of singular values.
+   *
+   * For the SVD decomposition of a n-by-p matrix, letting \a m be the minimum of \a n and \a p, the
+   * returned vector has size \a m.  Singular values are always sorted in decreasing order.
+   */
+  const SingularValuesType& singularValues() const
+  {
+    _check_compute_assertions();
+    return m_singularValues;
+  }
+
+  /** \returns the number of singular values that are not exactly 0 */
+  Index nonzeroSingularValues() const
+  {
+    _check_compute_assertions();
+    return m_nonzeroSingularValues;
+  }
+  
+  /** \returns the rank of the matrix of which \c *this is the SVD.
+    *
+    * \note This method has to determine which singular values should be considered nonzero.
+    *       For that, it uses the threshold value that you can control by calling
+    *       setThreshold(const RealScalar&).
+    */
+  inline Index rank() const
+  {
+    using std::abs;
+    _check_compute_assertions();
+    if(m_singularValues.size()==0) return 0;
+    RealScalar premultiplied_threshold = numext::maxi<RealScalar>(m_singularValues.coeff(0) * threshold(), (std::numeric_limits<RealScalar>::min)());
+    Index i = m_nonzeroSingularValues-1;
+    while(i>=0 && m_singularValues.coeff(i) < premultiplied_threshold) --i;
+    return i+1;
+  }
+  
+  /** Allows to prescribe a threshold to be used by certain methods, such as rank() and solve(),
+    * which need to determine when singular values are to be considered nonzero.
+    * This is not used for the SVD decomposition itself.
+    *
+    * When it needs to get the threshold value, Eigen calls threshold().
+    * The default is \c NumTraits<Scalar>::epsilon()
+    *
+    * \param threshold The new value to use as the threshold.
+    *
+    * A singular value will be considered nonzero if its value is strictly greater than
+    *  \f$ \vert singular value \vert \leqslant threshold \times \vert max singular value \vert \f$.
+    *
+    * If you want to come back to the default behavior, call setThreshold(Default_t)
+    */
+  Derived& setThreshold(const RealScalar& threshold)
+  {
+    m_usePrescribedThreshold = true;
+    m_prescribedThreshold = threshold;
+    return derived();
+  }
+
+  /** Allows to come back to the default behavior, letting Eigen use its default formula for
+    * determining the threshold.
+    *
+    * You should pass the special object Eigen::Default as parameter here.
+    * \code svd.setThreshold(Eigen::Default); \endcode
+    *
+    * See the documentation of setThreshold(const RealScalar&).
+    */
+  Derived& setThreshold(Default_t)
+  {
+    m_usePrescribedThreshold = false;
+    return derived();
+  }
+
+  /** Returns the threshold that will be used by certain methods such as rank().
+    *
+    * See the documentation of setThreshold(const RealScalar&).
+    */
+  RealScalar threshold() const
+  {
+    eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+    // this temporary is needed to workaround a MSVC issue
+    Index diagSize = (std::max<Index>)(1,m_diagSize);
+    return m_usePrescribedThreshold ? m_prescribedThreshold
+                                    : RealScalar(diagSize)*NumTraits<Scalar>::epsilon();
+  }
+
+  /** \returns true if \a U (full or thin) is asked for in this SVD decomposition */
+  inline bool computeU() const { return m_computeFullU || m_computeThinU; }
+  /** \returns true if \a V (full or thin) is asked for in this SVD decomposition */
+  inline bool computeV() const { return m_computeFullV || m_computeThinV; }
+
+  inline Index rows() const { return m_rows; }
+  inline Index cols() const { return m_cols; }
+  
+  #ifdef EIGEN_PARSED_BY_DOXYGEN
+  /** \returns a (least squares) solution of \f$ A x = b \f$ using the current SVD decomposition of A.
+    *
+    * \param b the right-hand-side of the equation to solve.
+    *
+    * \note Solving requires both U and V to be computed. Thin U and V are enough, there is no need for full U or V.
+    *
+    * \note SVD solving is implicitly least-squares. Thus, this method serves both purposes of exact solving and least-squares solving.
+    * In other words, the returned solution is guaranteed to minimize the Euclidean norm \f$ \Vert A x - b \Vert \f$.
+    */
+  template<typename Rhs>
+  inline const Solve<Derived, Rhs>
+  solve(const MatrixBase<Rhs>& b) const;
+  #endif
+
+
+  /** \brief Reports whether previous computation was successful.
+   *
+   * \returns \c Success if computation was successful.
+   */
+  EIGEN_DEVICE_FUNC
+  ComputationInfo info() const
+  {
+    eigen_assert(m_isInitialized && "SVD is not initialized.");
+    return m_info;
+  }
+
+  #ifndef EIGEN_PARSED_BY_DOXYGEN
+  template<typename RhsType, typename DstType>
+  void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+  template<bool Conjugate, typename RhsType, typename DstType>
+  void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+  #endif
+
+protected:
+
+  static void check_template_parameters()
+  {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+  }
+
+  void _check_compute_assertions() const {
+    eigen_assert(m_isInitialized && "SVD is not initialized.");
+  }
+
+  template<bool Transpose_, typename Rhs>
+  void _check_solve_assertion(const Rhs& b) const {
+      EIGEN_ONLY_USED_FOR_DEBUG(b);
+      _check_compute_assertions();
+      eigen_assert(computeU() && computeV() && "SVDBase::solve(): Both unitaries U and V are required to be computed (thin unitaries suffice).");
+      eigen_assert((Transpose_?cols():rows())==b.rows() && "SVDBase::solve(): invalid number of rows of the right hand side matrix b");
+  }
+
+  // return true if already allocated
+  bool allocate(Index rows, Index cols, unsigned int computationOptions) ;
+
+  MatrixUType m_matrixU;
+  MatrixVType m_matrixV;
+  SingularValuesType m_singularValues;
+  ComputationInfo m_info;
+  bool m_isInitialized, m_isAllocated, m_usePrescribedThreshold;
+  bool m_computeFullU, m_computeThinU;
+  bool m_computeFullV, m_computeThinV;
+  unsigned int m_computationOptions;
+  Index m_nonzeroSingularValues, m_rows, m_cols, m_diagSize;
+  RealScalar m_prescribedThreshold;
+
+  /** \brief Default Constructor.
+   *
+   * Default constructor of SVDBase
+   */
+  SVDBase()
+    : m_info(Success),
+      m_isInitialized(false),
+      m_isAllocated(false),
+      m_usePrescribedThreshold(false),
+      m_computeFullU(false),
+      m_computeThinU(false),
+      m_computeFullV(false),
+      m_computeThinV(false),
+      m_computationOptions(0),
+      m_rows(-1), m_cols(-1), m_diagSize(0)
+  {
+    check_template_parameters();
+  }
+
+
+};
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename Derived>
+template<typename RhsType, typename DstType>
+void SVDBase<Derived>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  // A = U S V^*
+  // So A^{-1} = V S^{-1} U^*
+
+  Matrix<typename RhsType::Scalar, Dynamic, RhsType::ColsAtCompileTime, 0, MatrixType::MaxRowsAtCompileTime, RhsType::MaxColsAtCompileTime> tmp;
+  Index l_rank = rank();
+  tmp.noalias() =  m_matrixU.leftCols(l_rank).adjoint() * rhs;
+  tmp = m_singularValues.head(l_rank).asDiagonal().inverse() * tmp;
+  dst = m_matrixV.leftCols(l_rank) * tmp;
+}
+
+template<typename Derived>
+template<bool Conjugate, typename RhsType, typename DstType>
+void SVDBase<Derived>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  // A = U S V^*
+  // So  A^{-*} = U S^{-1} V^*
+  // And A^{-T} = U_conj S^{-1} V^T
+  Matrix<typename RhsType::Scalar, Dynamic, RhsType::ColsAtCompileTime, 0, MatrixType::MaxRowsAtCompileTime, RhsType::MaxColsAtCompileTime> tmp;
+  Index l_rank = rank();
+
+  tmp.noalias() =  m_matrixV.leftCols(l_rank).transpose().template conjugateIf<Conjugate>() * rhs;
+  tmp = m_singularValues.head(l_rank).asDiagonal().inverse() * tmp;
+  dst = m_matrixU.template conjugateIf<!Conjugate>().leftCols(l_rank) * tmp;
+}
+#endif
+
+template<typename MatrixType>
+bool SVDBase<MatrixType>::allocate(Index rows, Index cols, unsigned int computationOptions)
+{
+  eigen_assert(rows >= 0 && cols >= 0);
+
+  if (m_isAllocated &&
+      rows == m_rows &&
+      cols == m_cols &&
+      computationOptions == m_computationOptions)
+  {
+    return true;
+  }
+
+  m_rows = rows;
+  m_cols = cols;
+  m_info = Success;
+  m_isInitialized = false;
+  m_isAllocated = true;
+  m_computationOptions = computationOptions;
+  m_computeFullU = (computationOptions & ComputeFullU) != 0;
+  m_computeThinU = (computationOptions & ComputeThinU) != 0;
+  m_computeFullV = (computationOptions & ComputeFullV) != 0;
+  m_computeThinV = (computationOptions & ComputeThinV) != 0;
+  eigen_assert(!(m_computeFullU && m_computeThinU) && "SVDBase: you can't ask for both full and thin U");
+  eigen_assert(!(m_computeFullV && m_computeThinV) && "SVDBase: you can't ask for both full and thin V");
+  eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) &&
+	       "SVDBase: thin U and V are only available when your matrix has a dynamic number of columns.");
+
+  m_diagSize = (std::min)(m_rows, m_cols);
+  m_singularValues.resize(m_diagSize);
+  if(RowsAtCompileTime==Dynamic)
+    m_matrixU.resize(m_rows, m_computeFullU ? m_rows : m_computeThinU ? m_diagSize : 0);
+  if(ColsAtCompileTime==Dynamic)
+    m_matrixV.resize(m_cols, m_computeFullV ? m_cols : m_computeThinV ? m_diagSize : 0);
+
+  return false;
+}
+
+}// end namespace
+
+#endif // EIGEN_SVDBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SVD/UpperBidiagonalization.h b/C++/yolo_bytetrack/include/Eigen/src/SVD/UpperBidiagonalization.h
new file mode 100644
index 00000000..997defc4
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SVD/UpperBidiagonalization.h
@@ -0,0 +1,414 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2013-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BIDIAGONALIZATION_H
+#define EIGEN_BIDIAGONALIZATION_H
+
+namespace Eigen { 
+
+namespace internal {
+// UpperBidiagonalization will probably be replaced by a Bidiagonalization class, don't want to make it stable API.
+// At the same time, it's useful to keep for now as it's about the only thing that is testing the BandMatrix class.
+
+template<typename _MatrixType> class UpperBidiagonalization
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      ColsAtCompileTimeMinusOne = internal::decrement_size<ColsAtCompileTime>::ret
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    typedef Matrix<Scalar, 1, ColsAtCompileTime> RowVectorType;
+    typedef Matrix<Scalar, RowsAtCompileTime, 1> ColVectorType;
+    typedef BandMatrix<RealScalar, ColsAtCompileTime, ColsAtCompileTime, 1, 0, RowMajor> BidiagonalType;
+    typedef Matrix<Scalar, ColsAtCompileTime, 1> DiagVectorType;
+    typedef Matrix<Scalar, ColsAtCompileTimeMinusOne, 1> SuperDiagVectorType;
+    typedef HouseholderSequence<
+              const MatrixType,
+              const typename internal::remove_all<typename Diagonal<const MatrixType,0>::ConjugateReturnType>::type
+            > HouseholderUSequenceType;
+    typedef HouseholderSequence<
+              const typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type,
+              Diagonal<const MatrixType,1>,
+              OnTheRight
+            > HouseholderVSequenceType;
+    
+    /**
+    * \brief Default Constructor.
+    *
+    * The default constructor is useful in cases in which the user intends to
+    * perform decompositions via Bidiagonalization::compute(const MatrixType&).
+    */
+    UpperBidiagonalization() : m_householder(), m_bidiagonal(), m_isInitialized(false) {}
+
+    explicit UpperBidiagonalization(const MatrixType& matrix)
+      : m_householder(matrix.rows(), matrix.cols()),
+        m_bidiagonal(matrix.cols(), matrix.cols()),
+        m_isInitialized(false)
+    {
+      compute(matrix);
+    }
+    
+    UpperBidiagonalization& compute(const MatrixType& matrix);
+    UpperBidiagonalization& computeUnblocked(const MatrixType& matrix);
+    
+    const MatrixType& householder() const { return m_householder; }
+    const BidiagonalType& bidiagonal() const { return m_bidiagonal; }
+    
+    const HouseholderUSequenceType householderU() const
+    {
+      eigen_assert(m_isInitialized && "UpperBidiagonalization is not initialized.");
+      return HouseholderUSequenceType(m_householder, m_householder.diagonal().conjugate());
+    }
+
+    const HouseholderVSequenceType householderV() // const here gives nasty errors and i'm lazy
+    {
+      eigen_assert(m_isInitialized && "UpperBidiagonalization is not initialized.");
+      return HouseholderVSequenceType(m_householder.conjugate(), m_householder.const_derived().template diagonal<1>())
+             .setLength(m_householder.cols()-1)
+             .setShift(1);
+    }
+    
+  protected:
+    MatrixType m_householder;
+    BidiagonalType m_bidiagonal;
+    bool m_isInitialized;
+};
+
+// Standard upper bidiagonalization without fancy optimizations
+// This version should be faster for small matrix size
+template<typename MatrixType>
+void upperbidiagonalization_inplace_unblocked(MatrixType& mat,
+                                              typename MatrixType::RealScalar *diagonal,
+                                              typename MatrixType::RealScalar *upper_diagonal,
+                                              typename MatrixType::Scalar* tempData = 0)
+{
+  typedef typename MatrixType::Scalar Scalar;
+
+  Index rows = mat.rows();
+  Index cols = mat.cols();
+
+  typedef Matrix<Scalar,Dynamic,1,ColMajor,MatrixType::MaxRowsAtCompileTime,1> TempType;
+  TempType tempVector;
+  if(tempData==0)
+  {
+    tempVector.resize(rows);
+    tempData = tempVector.data();
+  }
+
+  for (Index k = 0; /* breaks at k==cols-1 below */ ; ++k)
+  {
+    Index remainingRows = rows - k;
+    Index remainingCols = cols - k - 1;
+
+    // construct left householder transform in-place in A
+    mat.col(k).tail(remainingRows)
+       .makeHouseholderInPlace(mat.coeffRef(k,k), diagonal[k]);
+    // apply householder transform to remaining part of A on the left
+    mat.bottomRightCorner(remainingRows, remainingCols)
+       .applyHouseholderOnTheLeft(mat.col(k).tail(remainingRows-1), mat.coeff(k,k), tempData);
+
+    if(k == cols-1) break;
+
+    // construct right householder transform in-place in mat
+    mat.row(k).tail(remainingCols)
+       .makeHouseholderInPlace(mat.coeffRef(k,k+1), upper_diagonal[k]);
+    // apply householder transform to remaining part of mat on the left
+    mat.bottomRightCorner(remainingRows-1, remainingCols)
+       .applyHouseholderOnTheRight(mat.row(k).tail(remainingCols-1).adjoint(), mat.coeff(k,k+1), tempData);
+  }
+}
+
+/** \internal
+  * Helper routine for the block reduction to upper bidiagonal form.
+  *
+  * Let's partition the matrix A:
+  * 
+  *      | A00 A01 |
+  *  A = |         |
+  *      | A10 A11 |
+  *
+  * This function reduces to bidiagonal form the left \c rows x \a blockSize vertical panel [A00/A10]
+  * and the \a blockSize x \c cols horizontal panel [A00 A01] of the matrix \a A. The bottom-right block A11
+  * is updated using matrix-matrix products:
+  *   A22 -= V * Y^T - X * U^T
+  * where V and U contains the left and right Householder vectors. U and V are stored in A10, and A01
+  * respectively, and the update matrices X and Y are computed during the reduction.
+  * 
+  */
+template<typename MatrixType>
+void upperbidiagonalization_blocked_helper(MatrixType& A,
+                                           typename MatrixType::RealScalar *diagonal,
+                                           typename MatrixType::RealScalar *upper_diagonal,
+                                           Index bs,
+                                           Ref<Matrix<typename MatrixType::Scalar, Dynamic, Dynamic,
+                                                      traits<MatrixType>::Flags & RowMajorBit> > X,
+                                           Ref<Matrix<typename MatrixType::Scalar, Dynamic, Dynamic,
+                                                      traits<MatrixType>::Flags & RowMajorBit> > Y)
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename NumTraits<RealScalar>::Literal Literal;
+  enum { StorageOrder = traits<MatrixType>::Flags & RowMajorBit };
+  typedef InnerStride<int(StorageOrder) == int(ColMajor) ? 1 : Dynamic> ColInnerStride;
+  typedef InnerStride<int(StorageOrder) == int(ColMajor) ? Dynamic : 1> RowInnerStride;
+  typedef Ref<Matrix<Scalar, Dynamic, 1>, 0, ColInnerStride>    SubColumnType;
+  typedef Ref<Matrix<Scalar, 1, Dynamic>, 0, RowInnerStride>    SubRowType;
+  typedef Ref<Matrix<Scalar, Dynamic, Dynamic, StorageOrder > > SubMatType;
+  
+  Index brows = A.rows();
+  Index bcols = A.cols();
+
+  Scalar tau_u, tau_u_prev(0), tau_v;
+
+  for(Index k = 0; k < bs; ++k)
+  {
+    Index remainingRows = brows - k;
+    Index remainingCols = bcols - k - 1;
+
+    SubMatType X_k1( X.block(k,0, remainingRows,k) );
+    SubMatType V_k1( A.block(k,0, remainingRows,k) );
+
+    // 1 - update the k-th column of A
+    SubColumnType v_k = A.col(k).tail(remainingRows);
+          v_k -= V_k1 * Y.row(k).head(k).adjoint();
+    if(k) v_k -= X_k1 * A.col(k).head(k);
+    
+    // 2 - construct left Householder transform in-place
+    v_k.makeHouseholderInPlace(tau_v, diagonal[k]);
+       
+    if(k+1<bcols)
+    {
+      SubMatType Y_k  ( Y.block(k+1,0, remainingCols, k+1) );
+      SubMatType U_k1 ( A.block(0,k+1, k,remainingCols) );
+      
+      // this eases the application of Householder transforAions
+      // A(k,k) will store tau_v later
+      A(k,k) = Scalar(1);
+
+      // 3 - Compute y_k^T = tau_v * ( A^T*v_k - Y_k-1*V_k-1^T*v_k - U_k-1*X_k-1^T*v_k )
+      {
+        SubColumnType y_k( Y.col(k).tail(remainingCols) );
+        
+        // let's use the beginning of column k of Y as a temporary vector
+        SubColumnType tmp( Y.col(k).head(k) );
+        y_k.noalias()  = A.block(k,k+1, remainingRows,remainingCols).adjoint() * v_k; // bottleneck
+        tmp.noalias()  = V_k1.adjoint()  * v_k;
+        y_k.noalias() -= Y_k.leftCols(k) * tmp;
+        tmp.noalias()  = X_k1.adjoint()  * v_k;
+        y_k.noalias() -= U_k1.adjoint()  * tmp;
+        y_k *= numext::conj(tau_v);
+      }
+
+      // 4 - update k-th row of A (it will become u_k)
+      SubRowType u_k( A.row(k).tail(remainingCols) );
+      u_k = u_k.conjugate();
+      {
+        u_k -= Y_k * A.row(k).head(k+1).adjoint();
+        if(k) u_k -= U_k1.adjoint() * X.row(k).head(k).adjoint();
+      }
+
+      // 5 - construct right Householder transform in-place
+      u_k.makeHouseholderInPlace(tau_u, upper_diagonal[k]);
+
+      // this eases the application of Householder transformations
+      // A(k,k+1) will store tau_u later
+      A(k,k+1) = Scalar(1);
+
+      // 6 - Compute x_k = tau_u * ( A*u_k - X_k-1*U_k-1^T*u_k - V_k*Y_k^T*u_k )
+      {
+        SubColumnType x_k ( X.col(k).tail(remainingRows-1) );
+        
+        // let's use the beginning of column k of X as a temporary vectors
+        // note that tmp0 and tmp1 overlaps
+        SubColumnType tmp0 ( X.col(k).head(k) ),
+                      tmp1 ( X.col(k).head(k+1) );
+                    
+        x_k.noalias()   = A.block(k+1,k+1, remainingRows-1,remainingCols) * u_k.transpose(); // bottleneck
+        tmp0.noalias()  = U_k1 * u_k.transpose();
+        x_k.noalias()  -= X_k1.bottomRows(remainingRows-1) * tmp0;
+        tmp1.noalias()  = Y_k.adjoint() * u_k.transpose();
+        x_k.noalias()  -= A.block(k+1,0, remainingRows-1,k+1) * tmp1;
+        x_k *= numext::conj(tau_u);
+        tau_u = numext::conj(tau_u);
+        u_k = u_k.conjugate();
+      }
+
+      if(k>0) A.coeffRef(k-1,k) = tau_u_prev;
+      tau_u_prev = tau_u;
+    }
+    else
+      A.coeffRef(k-1,k) = tau_u_prev;
+
+    A.coeffRef(k,k) = tau_v;
+  }
+  
+  if(bs<bcols)
+    A.coeffRef(bs-1,bs) = tau_u_prev;
+
+  // update A22
+  if(bcols>bs && brows>bs)
+  {
+    SubMatType A11( A.bottomRightCorner(brows-bs,bcols-bs) );
+    SubMatType A10( A.block(bs,0, brows-bs,bs) );
+    SubMatType A01( A.block(0,bs, bs,bcols-bs) );
+    Scalar tmp = A01(bs-1,0);
+    A01(bs-1,0) = Literal(1);
+    A11.noalias() -= A10 * Y.topLeftCorner(bcols,bs).bottomRows(bcols-bs).adjoint();
+    A11.noalias() -= X.topLeftCorner(brows,bs).bottomRows(brows-bs) * A01;
+    A01(bs-1,0) = tmp;
+  }
+}
+
+/** \internal
+  *
+  * Implementation of a block-bidiagonal reduction.
+  * It is based on the following paper:
+  *   The Design of a Parallel Dense Linear Algebra Software Library: Reduction to Hessenberg, Tridiagonal, and Bidiagonal Form.
+  *   by Jaeyoung Choi, Jack J. Dongarra, David W. Walker. (1995)
+  *   section 3.3
+  */
+template<typename MatrixType, typename BidiagType>
+void upperbidiagonalization_inplace_blocked(MatrixType& A, BidiagType& bidiagonal,
+                                            Index maxBlockSize=32,
+                                            typename MatrixType::Scalar* /*tempData*/ = 0)
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Block<MatrixType,Dynamic,Dynamic> BlockType;
+
+  Index rows = A.rows();
+  Index cols = A.cols();
+  Index size = (std::min)(rows, cols);
+
+  // X and Y are work space
+  enum { StorageOrder = traits<MatrixType>::Flags & RowMajorBit };
+  Matrix<Scalar,
+         MatrixType::RowsAtCompileTime,
+         Dynamic,
+         StorageOrder,
+         MatrixType::MaxRowsAtCompileTime> X(rows,maxBlockSize);
+  Matrix<Scalar,
+         MatrixType::ColsAtCompileTime,
+         Dynamic,
+         StorageOrder,
+         MatrixType::MaxColsAtCompileTime> Y(cols,maxBlockSize);
+  Index blockSize = (std::min)(maxBlockSize,size);
+
+  Index k = 0;
+  for(k = 0; k < size; k += blockSize)
+  {
+    Index bs = (std::min)(size-k,blockSize);  // actual size of the block
+    Index brows = rows - k;                   // rows of the block
+    Index bcols = cols - k;                   // columns of the block
+
+    // partition the matrix A:
+    // 
+    //      | A00 A01 A02 |
+    //      |             |
+    // A  = | A10 A11 A12 |
+    //      |             |
+    //      | A20 A21 A22 |
+    //
+    // where A11 is a bs x bs diagonal block,
+    // and let:
+    //      | A11 A12 |
+    //  B = |         |
+    //      | A21 A22 |
+
+    BlockType B = A.block(k,k,brows,bcols);
+    
+    // This stage performs the bidiagonalization of A11, A21, A12, and updating of A22.
+    // Finally, the algorithm continue on the updated A22.
+    //
+    // However, if B is too small, or A22 empty, then let's use an unblocked strategy
+    if(k+bs==cols || bcols<48) // somewhat arbitrary threshold
+    {
+      upperbidiagonalization_inplace_unblocked(B,
+                                               &(bidiagonal.template diagonal<0>().coeffRef(k)),
+                                               &(bidiagonal.template diagonal<1>().coeffRef(k)),
+                                               X.data()
+                                              );
+      break; // We're done
+    }
+    else
+    {
+      upperbidiagonalization_blocked_helper<BlockType>( B,
+                                                        &(bidiagonal.template diagonal<0>().coeffRef(k)),
+                                                        &(bidiagonal.template diagonal<1>().coeffRef(k)),
+                                                        bs,
+                                                        X.topLeftCorner(brows,bs),
+                                                        Y.topLeftCorner(bcols,bs)
+                                                      );
+    }
+  }
+}
+
+template<typename _MatrixType>
+UpperBidiagonalization<_MatrixType>& UpperBidiagonalization<_MatrixType>::computeUnblocked(const _MatrixType& matrix)
+{
+  Index rows = matrix.rows();
+  Index cols = matrix.cols();
+  EIGEN_ONLY_USED_FOR_DEBUG(cols);
+
+  eigen_assert(rows >= cols && "UpperBidiagonalization is only for Arices satisfying rows>=cols.");
+
+  m_householder = matrix;
+
+  ColVectorType temp(rows);
+
+  upperbidiagonalization_inplace_unblocked(m_householder,
+                                           &(m_bidiagonal.template diagonal<0>().coeffRef(0)),
+                                           &(m_bidiagonal.template diagonal<1>().coeffRef(0)),
+                                           temp.data());
+
+  m_isInitialized = true;
+  return *this;
+}
+
+template<typename _MatrixType>
+UpperBidiagonalization<_MatrixType>& UpperBidiagonalization<_MatrixType>::compute(const _MatrixType& matrix)
+{
+  Index rows = matrix.rows();
+  Index cols = matrix.cols();
+  EIGEN_ONLY_USED_FOR_DEBUG(rows);
+  EIGEN_ONLY_USED_FOR_DEBUG(cols);
+
+  eigen_assert(rows >= cols && "UpperBidiagonalization is only for Arices satisfying rows>=cols.");
+
+  m_householder = matrix;
+  upperbidiagonalization_inplace_blocked(m_householder, m_bidiagonal);
+            
+  m_isInitialized = true;
+  return *this;
+}
+
+#if 0
+/** \return the Householder QR decomposition of \c *this.
+  *
+  * \sa class Bidiagonalization
+  */
+template<typename Derived>
+const UpperBidiagonalization<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::bidiagonalization() const
+{
+  return UpperBidiagonalization<PlainObject>(eval());
+}
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BIDIAGONALIZATION_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCholesky/SimplicialCholesky.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCholesky/SimplicialCholesky.h
new file mode 100644
index 00000000..9f93e325
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCholesky/SimplicialCholesky.h
@@ -0,0 +1,697 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SIMPLICIAL_CHOLESKY_H
+#define EIGEN_SIMPLICIAL_CHOLESKY_H
+
+namespace Eigen { 
+
+enum SimplicialCholeskyMode {
+  SimplicialCholeskyLLT,
+  SimplicialCholeskyLDLT
+};
+
+namespace internal {
+  template<typename CholMatrixType, typename InputMatrixType>
+  struct simplicial_cholesky_grab_input {
+    typedef CholMatrixType const * ConstCholMatrixPtr;
+    static void run(const InputMatrixType& input, ConstCholMatrixPtr &pmat, CholMatrixType &tmp)
+    {
+      tmp = input;
+      pmat = &tmp;
+    }
+  };
+  
+  template<typename MatrixType>
+  struct simplicial_cholesky_grab_input<MatrixType,MatrixType> {
+    typedef MatrixType const * ConstMatrixPtr;
+    static void run(const MatrixType& input, ConstMatrixPtr &pmat, MatrixType &/*tmp*/)
+    {
+      pmat = &input;
+    }
+  };
+} // end namespace internal
+
+/** \ingroup SparseCholesky_Module
+  * \brief A base class for direct sparse Cholesky factorizations
+  *
+  * This is a base class for LL^T and LDL^T Cholesky factorizations of sparse matrices that are
+  * selfadjoint and positive definite. These factorizations allow for solving A.X = B where
+  * X and B can be either dense or sparse.
+  * 
+  * In order to reduce the fill-in, a symmetric permutation P is applied prior to the factorization
+  * such that the factorized matrix is P A P^-1.
+  *
+  * \tparam Derived the type of the derived class, that is the actual factorization type.
+  *
+  */
+template<typename Derived>
+class SimplicialCholeskyBase : public SparseSolverBase<Derived>
+{
+    typedef SparseSolverBase<Derived> Base;
+    using Base::m_isInitialized;
+    
+  public:
+    typedef typename internal::traits<Derived>::MatrixType MatrixType;
+    typedef typename internal::traits<Derived>::OrderingType OrderingType;
+    enum { UpLo = internal::traits<Derived>::UpLo };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> CholMatrixType;
+    typedef CholMatrixType const * ConstCholMatrixPtr;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+    
+    using Base::derived;
+
+    /** Default constructor */
+    SimplicialCholeskyBase()
+      : m_info(Success),
+        m_factorizationIsOk(false),
+        m_analysisIsOk(false),
+        m_shiftOffset(0),
+        m_shiftScale(1)
+    {}
+
+    explicit SimplicialCholeskyBase(const MatrixType& matrix)
+      : m_info(Success),
+        m_factorizationIsOk(false),
+        m_analysisIsOk(false),
+        m_shiftOffset(0),
+        m_shiftScale(1)
+    {
+      derived().compute(matrix);
+    }
+
+    ~SimplicialCholeskyBase()
+    {
+    }
+
+    Derived& derived() { return *static_cast<Derived*>(this); }
+    const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    
+    inline Index cols() const { return m_matrix.cols(); }
+    inline Index rows() const { return m_matrix.rows(); }
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+    
+    /** \returns the permutation P
+      * \sa permutationPinv() */
+    const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& permutationP() const
+    { return m_P; }
+    
+    /** \returns the inverse P^-1 of the permutation P
+      * \sa permutationP() */
+    const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& permutationPinv() const
+    { return m_Pinv; }
+
+    /** Sets the shift parameters that will be used to adjust the diagonal coefficients during the numerical factorization.
+      *
+      * During the numerical factorization, the diagonal coefficients are transformed by the following linear model:\n
+      * \c d_ii = \a offset + \a scale * \c d_ii
+      *
+      * The default is the identity transformation with \a offset=0, and \a scale=1.
+      *
+      * \returns a reference to \c *this.
+      */
+    Derived& setShift(const RealScalar& offset, const RealScalar& scale = 1)
+    {
+      m_shiftOffset = offset;
+      m_shiftScale = scale;
+      return derived();
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal */
+    template<typename Stream>
+    void dumpMemory(Stream& s)
+    {
+      int total = 0;
+      s << "  L:        " << ((total+=(m_matrix.cols()+1) * sizeof(int) + m_matrix.nonZeros()*(sizeof(int)+sizeof(Scalar))) >> 20) << "Mb" << "\n";
+      s << "  diag:     " << ((total+=m_diag.size() * sizeof(Scalar)) >> 20) << "Mb" << "\n";
+      s << "  tree:     " << ((total+=m_parent.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  nonzeros: " << ((total+=m_nonZerosPerCol.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  perm:     " << ((total+=m_P.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  perm^-1:  " << ((total+=m_Pinv.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  TOTAL:    " << (total>> 20) << "Mb" << "\n";
+    }
+
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      eigen_assert(m_matrix.rows()==b.rows());
+
+      if(m_info!=Success)
+        return;
+
+      if(m_P.size()>0)
+        dest = m_P * b;
+      else
+        dest = b;
+
+      if(m_matrix.nonZeros()>0) // otherwise L==I
+        derived().matrixL().solveInPlace(dest);
+
+      if(m_diag.size()>0)
+        dest = m_diag.asDiagonal().inverse() * dest;
+
+      if (m_matrix.nonZeros()>0) // otherwise U==I
+        derived().matrixU().solveInPlace(dest);
+
+      if(m_P.size()>0)
+        dest = m_Pinv * dest;
+    }
+    
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const SparseMatrixBase<Rhs> &b, SparseMatrixBase<Dest> &dest) const
+    {
+      internal::solve_sparse_through_dense_panels(derived(), b, dest);
+    }
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+  protected:
+    
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    template<bool DoLDLT>
+    void compute(const MatrixType& matrix)
+    {
+      eigen_assert(matrix.rows()==matrix.cols());
+      Index size = matrix.cols();
+      CholMatrixType tmp(size,size);
+      ConstCholMatrixPtr pmat;
+      ordering(matrix, pmat, tmp);
+      analyzePattern_preordered(*pmat, DoLDLT);
+      factorize_preordered<DoLDLT>(*pmat);
+    }
+    
+    template<bool DoLDLT>
+    void factorize(const MatrixType& a)
+    {
+      eigen_assert(a.rows()==a.cols());
+      Index size = a.cols();
+      CholMatrixType tmp(size,size);
+      ConstCholMatrixPtr pmat;
+      
+      if(m_P.size() == 0 && (int(UpLo) & int(Upper)) == Upper)
+      {
+        // If there is no ordering, try to directly use the input matrix without any copy
+        internal::simplicial_cholesky_grab_input<CholMatrixType,MatrixType>::run(a, pmat, tmp);
+      }
+      else
+      {
+        tmp.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>().twistedBy(m_P);
+        pmat = &tmp;
+      }
+      
+      factorize_preordered<DoLDLT>(*pmat);
+    }
+
+    template<bool DoLDLT>
+    void factorize_preordered(const CholMatrixType& a);
+
+    void analyzePattern(const MatrixType& a, bool doLDLT)
+    {
+      eigen_assert(a.rows()==a.cols());
+      Index size = a.cols();
+      CholMatrixType tmp(size,size);
+      ConstCholMatrixPtr pmat;
+      ordering(a, pmat, tmp);
+      analyzePattern_preordered(*pmat,doLDLT);
+    }
+    void analyzePattern_preordered(const CholMatrixType& a, bool doLDLT);
+    
+    void ordering(const MatrixType& a, ConstCholMatrixPtr &pmat, CholMatrixType& ap);
+
+    /** keeps off-diagonal entries; drops diagonal entries */
+    struct keep_diag {
+      inline bool operator() (const Index& row, const Index& col, const Scalar&) const
+      {
+        return row!=col;
+      }
+    };
+
+    mutable ComputationInfo m_info;
+    bool m_factorizationIsOk;
+    bool m_analysisIsOk;
+    
+    CholMatrixType m_matrix;
+    VectorType m_diag;                                // the diagonal coefficients (LDLT mode)
+    VectorI m_parent;                                 // elimination tree
+    VectorI m_nonZerosPerCol;
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_P;     // the permutation
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_Pinv;  // the inverse permutation
+
+    RealScalar m_shiftOffset;
+    RealScalar m_shiftScale;
+};
+
+template<typename _MatrixType, int _UpLo = Lower, typename _Ordering = AMDOrdering<typename _MatrixType::StorageIndex> > class SimplicialLLT;
+template<typename _MatrixType, int _UpLo = Lower, typename _Ordering = AMDOrdering<typename _MatrixType::StorageIndex> > class SimplicialLDLT;
+template<typename _MatrixType, int _UpLo = Lower, typename _Ordering = AMDOrdering<typename _MatrixType::StorageIndex> > class SimplicialCholesky;
+
+namespace internal {
+
+template<typename _MatrixType, int _UpLo, typename _Ordering> struct traits<SimplicialLLT<_MatrixType,_UpLo,_Ordering> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Ordering OrderingType;
+  enum { UpLo = _UpLo };
+  typedef typename MatrixType::Scalar                         Scalar;
+  typedef typename MatrixType::StorageIndex                   StorageIndex;
+  typedef SparseMatrix<Scalar, ColMajor, StorageIndex>        CholMatrixType;
+  typedef TriangularView<const CholMatrixType, Eigen::Lower>  MatrixL;
+  typedef TriangularView<const typename CholMatrixType::AdjointReturnType, Eigen::Upper>   MatrixU;
+  static inline MatrixL getL(const CholMatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const CholMatrixType& m) { return MatrixU(m.adjoint()); }
+};
+
+template<typename _MatrixType,int _UpLo, typename _Ordering> struct traits<SimplicialLDLT<_MatrixType,_UpLo,_Ordering> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Ordering OrderingType;
+  enum { UpLo = _UpLo };
+  typedef typename MatrixType::Scalar                             Scalar;
+  typedef typename MatrixType::StorageIndex                       StorageIndex;
+  typedef SparseMatrix<Scalar, ColMajor, StorageIndex>            CholMatrixType;
+  typedef TriangularView<const CholMatrixType, Eigen::UnitLower>  MatrixL;
+  typedef TriangularView<const typename CholMatrixType::AdjointReturnType, Eigen::UnitUpper> MatrixU;
+  static inline MatrixL getL(const CholMatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const CholMatrixType& m) { return MatrixU(m.adjoint()); }
+};
+
+template<typename _MatrixType, int _UpLo, typename _Ordering> struct traits<SimplicialCholesky<_MatrixType,_UpLo,_Ordering> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Ordering OrderingType;
+  enum { UpLo = _UpLo };
+};
+
+}
+
+/** \ingroup SparseCholesky_Module
+  * \class SimplicialLLT
+  * \brief A direct sparse LLT Cholesky factorizations
+  *
+  * This class provides a LL^T Cholesky factorizations of sparse matrices that are
+  * selfadjoint and positive definite. The factorization allows for solving A.X = B where
+  * X and B can be either dense or sparse.
+  * 
+  * In order to reduce the fill-in, a symmetric permutation P is applied prior to the factorization
+  * such that the factorized matrix is P A P^-1.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  * \tparam _Ordering The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa class SimplicialLDLT, class AMDOrdering, class NaturalOrdering
+  */
+template<typename _MatrixType, int _UpLo, typename _Ordering>
+    class SimplicialLLT : public SimplicialCholeskyBase<SimplicialLLT<_MatrixType,_UpLo,_Ordering> >
+{
+public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef SimplicialCholeskyBase<SimplicialLLT> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,Index> CholMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef internal::traits<SimplicialLLT> Traits;
+    typedef typename Traits::MatrixL  MatrixL;
+    typedef typename Traits::MatrixU  MatrixU;
+public:
+    /** Default constructor */
+    SimplicialLLT() : Base() {}
+    /** Constructs and performs the LLT factorization of \a matrix */
+    explicit SimplicialLLT(const MatrixType& matrix)
+        : Base(matrix) {}
+
+    /** \returns an expression of the factor L */
+    inline const MatrixL matrixL() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LLT not factorized");
+        return Traits::getL(Base::m_matrix);
+    }
+
+    /** \returns an expression of the factor U (= L^*) */
+    inline const MatrixU matrixU() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LLT not factorized");
+        return Traits::getU(Base::m_matrix);
+    }
+    
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    SimplicialLLT& compute(const MatrixType& matrix)
+    {
+      Base::template compute<false>(matrix);
+      return *this;
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& a)
+    {
+      Base::analyzePattern(a, false);
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& a)
+    {
+      Base::template factorize<false>(a);
+    }
+
+    /** \returns the determinant of the underlying matrix from the current factorization */
+    Scalar determinant() const
+    {
+      Scalar detL = Base::m_matrix.diagonal().prod();
+      return numext::abs2(detL);
+    }
+};
+
+/** \ingroup SparseCholesky_Module
+  * \class SimplicialLDLT
+  * \brief A direct sparse LDLT Cholesky factorizations without square root.
+  *
+  * This class provides a LDL^T Cholesky factorizations without square root of sparse matrices that are
+  * selfadjoint and positive definite. The factorization allows for solving A.X = B where
+  * X and B can be either dense or sparse.
+  * 
+  * In order to reduce the fill-in, a symmetric permutation P is applied prior to the factorization
+  * such that the factorized matrix is P A P^-1.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  * \tparam _Ordering The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa class SimplicialLLT, class AMDOrdering, class NaturalOrdering
+  */
+template<typename _MatrixType, int _UpLo, typename _Ordering>
+    class SimplicialLDLT : public SimplicialCholeskyBase<SimplicialLDLT<_MatrixType,_UpLo,_Ordering> >
+{
+public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef SimplicialCholeskyBase<SimplicialLDLT> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> CholMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef internal::traits<SimplicialLDLT> Traits;
+    typedef typename Traits::MatrixL  MatrixL;
+    typedef typename Traits::MatrixU  MatrixU;
+public:
+    /** Default constructor */
+    SimplicialLDLT() : Base() {}
+
+    /** Constructs and performs the LLT factorization of \a matrix */
+    explicit SimplicialLDLT(const MatrixType& matrix)
+        : Base(matrix) {}
+
+    /** \returns a vector expression of the diagonal D */
+    inline const VectorType vectorD() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LDLT not factorized");
+        return Base::m_diag;
+    }
+    /** \returns an expression of the factor L */
+    inline const MatrixL matrixL() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LDLT not factorized");
+        return Traits::getL(Base::m_matrix);
+    }
+
+    /** \returns an expression of the factor U (= L^*) */
+    inline const MatrixU matrixU() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LDLT not factorized");
+        return Traits::getU(Base::m_matrix);
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    SimplicialLDLT& compute(const MatrixType& matrix)
+    {
+      Base::template compute<true>(matrix);
+      return *this;
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& a)
+    {
+      Base::analyzePattern(a, true);
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& a)
+    {
+      Base::template factorize<true>(a);
+    }
+
+    /** \returns the determinant of the underlying matrix from the current factorization */
+    Scalar determinant() const
+    {
+      return Base::m_diag.prod();
+    }
+};
+
+/** \deprecated use SimplicialLDLT or class SimplicialLLT
+  * \ingroup SparseCholesky_Module
+  * \class SimplicialCholesky
+  *
+  * \sa class SimplicialLDLT, class SimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo, typename _Ordering>
+    class SimplicialCholesky : public SimplicialCholeskyBase<SimplicialCholesky<_MatrixType,_UpLo,_Ordering> >
+{
+public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef SimplicialCholeskyBase<SimplicialCholesky> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> CholMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef internal::traits<SimplicialCholesky> Traits;
+    typedef internal::traits<SimplicialLDLT<MatrixType,UpLo> > LDLTTraits;
+    typedef internal::traits<SimplicialLLT<MatrixType,UpLo>  > LLTTraits;
+  public:
+    SimplicialCholesky() : Base(), m_LDLT(true) {}
+
+    explicit SimplicialCholesky(const MatrixType& matrix)
+      : Base(), m_LDLT(true)
+    {
+      compute(matrix);
+    }
+
+    SimplicialCholesky& setMode(SimplicialCholeskyMode mode)
+    {
+      switch(mode)
+      {
+      case SimplicialCholeskyLLT:
+        m_LDLT = false;
+        break;
+      case SimplicialCholeskyLDLT:
+        m_LDLT = true;
+        break;
+      default:
+        break;
+      }
+
+      return *this;
+    }
+
+    inline const VectorType vectorD() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial Cholesky not factorized");
+        return Base::m_diag;
+    }
+    inline const CholMatrixType rawMatrix() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial Cholesky not factorized");
+        return Base::m_matrix;
+    }
+    
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    SimplicialCholesky& compute(const MatrixType& matrix)
+    {
+      if(m_LDLT)
+        Base::template compute<true>(matrix);
+      else
+        Base::template compute<false>(matrix);
+      return *this;
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& a)
+    {
+      Base::analyzePattern(a, m_LDLT);
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& a)
+    {
+      if(m_LDLT)
+        Base::template factorize<true>(a);
+      else
+        Base::template factorize<false>(a);
+    }
+
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(Base::m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      eigen_assert(Base::m_matrix.rows()==b.rows());
+
+      if(Base::m_info!=Success)
+        return;
+
+      if(Base::m_P.size()>0)
+        dest = Base::m_P * b;
+      else
+        dest = b;
+
+      if(Base::m_matrix.nonZeros()>0) // otherwise L==I
+      {
+        if(m_LDLT)
+          LDLTTraits::getL(Base::m_matrix).solveInPlace(dest);
+        else
+          LLTTraits::getL(Base::m_matrix).solveInPlace(dest);
+      }
+
+      if(Base::m_diag.size()>0)
+        dest = Base::m_diag.real().asDiagonal().inverse() * dest;
+
+      if (Base::m_matrix.nonZeros()>0) // otherwise I==I
+      {
+        if(m_LDLT)
+          LDLTTraits::getU(Base::m_matrix).solveInPlace(dest);
+        else
+          LLTTraits::getU(Base::m_matrix).solveInPlace(dest);
+      }
+
+      if(Base::m_P.size()>0)
+        dest = Base::m_Pinv * dest;
+    }
+    
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const SparseMatrixBase<Rhs> &b, SparseMatrixBase<Dest> &dest) const
+    {
+      internal::solve_sparse_through_dense_panels(*this, b, dest);
+    }
+    
+    Scalar determinant() const
+    {
+      if(m_LDLT)
+      {
+        return Base::m_diag.prod();
+      }
+      else
+      {
+        Scalar detL = Diagonal<const CholMatrixType>(Base::m_matrix).prod();
+        return numext::abs2(detL);
+      }
+    }
+    
+  protected:
+    bool m_LDLT;
+};
+
+template<typename Derived>
+void SimplicialCholeskyBase<Derived>::ordering(const MatrixType& a, ConstCholMatrixPtr &pmat, CholMatrixType& ap)
+{
+  eigen_assert(a.rows()==a.cols());
+  const Index size = a.rows();
+  pmat = &ap;
+  // Note that ordering methods compute the inverse permutation
+  if(!internal::is_same<OrderingType,NaturalOrdering<Index> >::value)
+  {
+    {
+      CholMatrixType C;
+      C = a.template selfadjointView<UpLo>();
+      
+      OrderingType ordering;
+      ordering(C,m_Pinv);
+    }
+
+    if(m_Pinv.size()>0) m_P = m_Pinv.inverse();
+    else                m_P.resize(0);
+    
+    ap.resize(size,size);
+    ap.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>().twistedBy(m_P);
+  }
+  else
+  {
+    m_Pinv.resize(0);
+    m_P.resize(0);
+    if(int(UpLo)==int(Lower) || MatrixType::IsRowMajor)
+    {
+      // we have to transpose the lower part to to the upper one
+      ap.resize(size,size);
+      ap.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>();
+    }
+    else
+      internal::simplicial_cholesky_grab_input<CholMatrixType,MatrixType>::run(a, pmat, ap);
+  }  
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SIMPLICIAL_CHOLESKY_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
new file mode 100644
index 00000000..72e1740c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
@@ -0,0 +1,174 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*
+NOTE: these functions have been adapted from the LDL library:
+
+LDL Copyright (c) 2005 by Timothy A. Davis.  All Rights Reserved.
+
+The author of LDL, Timothy A. Davis., has executed a license with Google LLC
+to permit distribution of this code and derivative works as part of Eigen under
+the Mozilla Public License v. 2.0, as stated at the top of this file.
+ */
+
+#ifndef EIGEN_SIMPLICIAL_CHOLESKY_IMPL_H
+#define EIGEN_SIMPLICIAL_CHOLESKY_IMPL_H
+
+namespace Eigen {
+
+template<typename Derived>
+void SimplicialCholeskyBase<Derived>::analyzePattern_preordered(const CholMatrixType& ap, bool doLDLT)
+{
+  const StorageIndex size = StorageIndex(ap.rows());
+  m_matrix.resize(size, size);
+  m_parent.resize(size);
+  m_nonZerosPerCol.resize(size);
+
+  ei_declare_aligned_stack_constructed_variable(StorageIndex, tags, size, 0);
+
+  for(StorageIndex k = 0; k < size; ++k)
+  {
+    /* L(k,:) pattern: all nodes reachable in etree from nz in A(0:k-1,k) */
+    m_parent[k] = -1;             /* parent of k is not yet known */
+    tags[k] = k;                  /* mark node k as visited */
+    m_nonZerosPerCol[k] = 0;      /* count of nonzeros in column k of L */
+    for(typename CholMatrixType::InnerIterator it(ap,k); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if(i < k)
+      {
+        /* follow path from i to root of etree, stop at flagged node */
+        for(; tags[i] != k; i = m_parent[i])
+        {
+          /* find parent of i if not yet determined */
+          if (m_parent[i] == -1)
+            m_parent[i] = k;
+          m_nonZerosPerCol[i]++;        /* L (k,i) is nonzero */
+          tags[i] = k;                  /* mark i as visited */
+        }
+      }
+    }
+  }
+
+  /* construct Lp index array from m_nonZerosPerCol column counts */
+  StorageIndex* Lp = m_matrix.outerIndexPtr();
+  Lp[0] = 0;
+  for(StorageIndex k = 0; k < size; ++k)
+    Lp[k+1] = Lp[k] + m_nonZerosPerCol[k] + (doLDLT ? 0 : 1);
+
+  m_matrix.resizeNonZeros(Lp[size]);
+
+  m_isInitialized     = true;
+  m_info              = Success;
+  m_analysisIsOk      = true;
+  m_factorizationIsOk = false;
+}
+
+
+template<typename Derived>
+template<bool DoLDLT>
+void SimplicialCholeskyBase<Derived>::factorize_preordered(const CholMatrixType& ap)
+{
+  using std::sqrt;
+
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  eigen_assert(ap.rows()==ap.cols());
+  eigen_assert(m_parent.size()==ap.rows());
+  eigen_assert(m_nonZerosPerCol.size()==ap.rows());
+
+  const StorageIndex size = StorageIndex(ap.rows());
+  const StorageIndex* Lp = m_matrix.outerIndexPtr();
+  StorageIndex* Li = m_matrix.innerIndexPtr();
+  Scalar* Lx = m_matrix.valuePtr();
+
+  ei_declare_aligned_stack_constructed_variable(Scalar, y, size, 0);
+  ei_declare_aligned_stack_constructed_variable(StorageIndex,  pattern, size, 0);
+  ei_declare_aligned_stack_constructed_variable(StorageIndex,  tags, size, 0);
+
+  bool ok = true;
+  m_diag.resize(DoLDLT ? size : 0);
+
+  for(StorageIndex k = 0; k < size; ++k)
+  {
+    // compute nonzero pattern of kth row of L, in topological order
+    y[k] = Scalar(0);                     // Y(0:k) is now all zero
+    StorageIndex top = size;               // stack for pattern is empty
+    tags[k] = k;                    // mark node k as visited
+    m_nonZerosPerCol[k] = 0;        // count of nonzeros in column k of L
+    for(typename CholMatrixType::InnerIterator it(ap,k); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if(i <= k)
+      {
+        y[i] += numext::conj(it.value());            /* scatter A(i,k) into Y (sum duplicates) */
+        Index len;
+        for(len = 0; tags[i] != k; i = m_parent[i])
+        {
+          pattern[len++] = i;     /* L(k,i) is nonzero */
+          tags[i] = k;            /* mark i as visited */
+        }
+        while(len > 0)
+          pattern[--top] = pattern[--len];
+      }
+    }
+
+    /* compute numerical values kth row of L (a sparse triangular solve) */
+
+    RealScalar d = numext::real(y[k]) * m_shiftScale + m_shiftOffset;    // get D(k,k), apply the shift function, and clear Y(k)
+    y[k] = Scalar(0);
+    for(; top < size; ++top)
+    {
+      Index i = pattern[top];       /* pattern[top:n-1] is pattern of L(:,k) */
+      Scalar yi = y[i];             /* get and clear Y(i) */
+      y[i] = Scalar(0);
+
+      /* the nonzero entry L(k,i) */
+      Scalar l_ki;
+      if(DoLDLT)
+        l_ki = yi / numext::real(m_diag[i]);
+      else
+        yi = l_ki = yi / Lx[Lp[i]];
+
+      Index p2 = Lp[i] + m_nonZerosPerCol[i];
+      Index p;
+      for(p = Lp[i] + (DoLDLT ? 0 : 1); p < p2; ++p)
+        y[Li[p]] -= numext::conj(Lx[p]) * yi;
+      d -= numext::real(l_ki * numext::conj(yi));
+      Li[p] = k;                          /* store L(k,i) in column form of L */
+      Lx[p] = l_ki;
+      ++m_nonZerosPerCol[i];              /* increment count of nonzeros in col i */
+    }
+    if(DoLDLT)
+    {
+      m_diag[k] = d;
+      if(d == RealScalar(0))
+      {
+        ok = false;                         /* failure, D(k,k) is zero */
+        break;
+      }
+    }
+    else
+    {
+      Index p = Lp[k] + m_nonZerosPerCol[k]++;
+      Li[p] = k ;                /* store L(k,k) = sqrt (d) in column k */
+      if(d <= RealScalar(0)) {
+        ok = false;              /* failure, matrix is not positive definite */
+        break;
+      }
+      Lx[p] = sqrt(d) ;
+    }
+  }
+
+  m_info = ok ? Success : NumericalIssue;
+  m_factorizationIsOk = true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SIMPLICIAL_CHOLESKY_IMPL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/AmbiVector.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/AmbiVector.h
new file mode 100644
index 00000000..2cb7747c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/AmbiVector.h
@@ -0,0 +1,378 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_AMBIVECTOR_H
+#define EIGEN_AMBIVECTOR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal
+  * Hybrid sparse/dense vector class designed for intensive read-write operations.
+  *
+  * See BasicSparseLLT and SparseProduct for usage examples.
+  */
+template<typename _Scalar, typename _StorageIndex>
+class AmbiVector
+{
+  public:
+    typedef _Scalar Scalar;
+    typedef _StorageIndex StorageIndex;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    explicit AmbiVector(Index size)
+      : m_buffer(0), m_zero(0), m_size(0), m_end(0), m_allocatedSize(0), m_allocatedElements(0), m_mode(-1)
+    {
+      resize(size);
+    }
+
+    void init(double estimatedDensity);
+    void init(int mode);
+
+    Index nonZeros() const;
+
+    /** Specifies a sub-vector to work on */
+    void setBounds(Index start, Index end) { m_start = convert_index(start); m_end = convert_index(end); }
+
+    void setZero();
+
+    void restart();
+    Scalar& coeffRef(Index i);
+    Scalar& coeff(Index i);
+
+    class Iterator;
+
+    ~AmbiVector() { delete[] m_buffer; }
+
+    void resize(Index size)
+    {
+      if (m_allocatedSize < size)
+        reallocate(size);
+      m_size = convert_index(size);
+    }
+
+    StorageIndex size() const { return m_size; }
+
+  protected:
+    StorageIndex convert_index(Index idx)
+    {
+      return internal::convert_index<StorageIndex>(idx);
+    }
+
+    void reallocate(Index size)
+    {
+      // if the size of the matrix is not too large, let's allocate a bit more than needed such
+      // that we can handle dense vector even in sparse mode.
+      delete[] m_buffer;
+      if (size<1000)
+      {
+        Index allocSize = (size * sizeof(ListEl) + sizeof(Scalar) - 1)/sizeof(Scalar);
+        m_allocatedElements = convert_index((allocSize*sizeof(Scalar))/sizeof(ListEl));
+        m_buffer = new Scalar[allocSize];
+      }
+      else
+      {
+        m_allocatedElements = convert_index((size*sizeof(Scalar))/sizeof(ListEl));
+        m_buffer = new Scalar[size];
+      }
+      m_size = convert_index(size);
+      m_start = 0;
+      m_end = m_size;
+    }
+
+    void reallocateSparse()
+    {
+      Index copyElements = m_allocatedElements;
+      m_allocatedElements = (std::min)(StorageIndex(m_allocatedElements*1.5),m_size);
+      Index allocSize = m_allocatedElements * sizeof(ListEl);
+      allocSize = (allocSize + sizeof(Scalar) - 1)/sizeof(Scalar);
+      Scalar* newBuffer = new Scalar[allocSize];
+      std::memcpy(newBuffer,  m_buffer,  copyElements * sizeof(ListEl));
+      delete[] m_buffer;
+      m_buffer = newBuffer;
+    }
+
+  protected:
+    // element type of the linked list
+    struct ListEl
+    {
+      StorageIndex next;
+      StorageIndex index;
+      Scalar value;
+    };
+
+    // used to store data in both mode
+    Scalar* m_buffer;
+    Scalar m_zero;
+    StorageIndex m_size;
+    StorageIndex m_start;
+    StorageIndex m_end;
+    StorageIndex m_allocatedSize;
+    StorageIndex m_allocatedElements;
+    StorageIndex m_mode;
+
+    // linked list mode
+    StorageIndex m_llStart;
+    StorageIndex m_llCurrent;
+    StorageIndex m_llSize;
+};
+
+/** \returns the number of non zeros in the current sub vector */
+template<typename _Scalar,typename _StorageIndex>
+Index AmbiVector<_Scalar,_StorageIndex>::nonZeros() const
+{
+  if (m_mode==IsSparse)
+    return m_llSize;
+  else
+    return m_end - m_start;
+}
+
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::init(double estimatedDensity)
+{
+  if (estimatedDensity>0.1)
+    init(IsDense);
+  else
+    init(IsSparse);
+}
+
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::init(int mode)
+{
+  m_mode = mode;
+  // This is only necessary in sparse mode, but we set these unconditionally to avoid some maybe-uninitialized warnings
+  // if (m_mode==IsSparse)
+  {
+    m_llSize = 0;
+    m_llStart = -1;
+  }
+}
+
+/** Must be called whenever we might perform a write access
+  * with an index smaller than the previous one.
+  *
+  * Don't worry, this function is extremely cheap.
+  */
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::restart()
+{
+  m_llCurrent = m_llStart;
+}
+
+/** Set all coefficients of current subvector to zero */
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::setZero()
+{
+  if (m_mode==IsDense)
+  {
+    for (Index i=m_start; i<m_end; ++i)
+      m_buffer[i] = Scalar(0);
+  }
+  else
+  {
+    eigen_assert(m_mode==IsSparse);
+    m_llSize = 0;
+    m_llStart = -1;
+  }
+}
+
+template<typename _Scalar,typename _StorageIndex>
+_Scalar& AmbiVector<_Scalar,_StorageIndex>::coeffRef(Index i)
+{
+  if (m_mode==IsDense)
+    return m_buffer[i];
+  else
+  {
+    ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer);
+    // TODO factorize the following code to reduce code generation
+    eigen_assert(m_mode==IsSparse);
+    if (m_llSize==0)
+    {
+      // this is the first element
+      m_llStart = 0;
+      m_llCurrent = 0;
+      ++m_llSize;
+      llElements[0].value = Scalar(0);
+      llElements[0].index = convert_index(i);
+      llElements[0].next = -1;
+      return llElements[0].value;
+    }
+    else if (i<llElements[m_llStart].index)
+    {
+      // this is going to be the new first element of the list
+      ListEl& el = llElements[m_llSize];
+      el.value = Scalar(0);
+      el.index = convert_index(i);
+      el.next = m_llStart;
+      m_llStart = m_llSize;
+      ++m_llSize;
+      m_llCurrent = m_llStart;
+      return el.value;
+    }
+    else
+    {
+      StorageIndex nextel = llElements[m_llCurrent].next;
+      eigen_assert(i>=llElements[m_llCurrent].index && "you must call restart() before inserting an element with lower or equal index");
+      while (nextel >= 0 && llElements[nextel].index<=i)
+      {
+        m_llCurrent = nextel;
+        nextel = llElements[nextel].next;
+      }
+
+      if (llElements[m_llCurrent].index==i)
+      {
+        // the coefficient already exists and we found it !
+        return llElements[m_llCurrent].value;
+      }
+      else
+      {
+        if (m_llSize>=m_allocatedElements)
+        {
+          reallocateSparse();
+          llElements = reinterpret_cast<ListEl*>(m_buffer);
+        }
+        eigen_internal_assert(m_llSize<m_allocatedElements && "internal error: overflow in sparse mode");
+        // let's insert a new coefficient
+        ListEl& el = llElements[m_llSize];
+        el.value = Scalar(0);
+        el.index = convert_index(i);
+        el.next = llElements[m_llCurrent].next;
+        llElements[m_llCurrent].next = m_llSize;
+        ++m_llSize;
+        return el.value;
+      }
+    }
+  }
+}
+
+template<typename _Scalar,typename _StorageIndex>
+_Scalar& AmbiVector<_Scalar,_StorageIndex>::coeff(Index i)
+{
+  if (m_mode==IsDense)
+    return m_buffer[i];
+  else
+  {
+    ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer);
+    eigen_assert(m_mode==IsSparse);
+    if ((m_llSize==0) || (i<llElements[m_llStart].index))
+    {
+      return m_zero;
+    }
+    else
+    {
+      Index elid = m_llStart;
+      while (elid >= 0 && llElements[elid].index<i)
+        elid = llElements[elid].next;
+
+      if (llElements[elid].index==i)
+        return llElements[m_llCurrent].value;
+      else
+        return m_zero;
+    }
+  }
+}
+
+/** Iterator over the nonzero coefficients */
+template<typename _Scalar,typename _StorageIndex>
+class AmbiVector<_Scalar,_StorageIndex>::Iterator
+{
+  public:
+    typedef _Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    /** Default constructor
+      * \param vec the vector on which we iterate
+      * \param epsilon the minimal value used to prune zero coefficients.
+      * In practice, all coefficients having a magnitude smaller than \a epsilon
+      * are skipped.
+      */
+    explicit Iterator(const AmbiVector& vec, const RealScalar& epsilon = 0)
+      : m_vector(vec)
+    {
+      using std::abs;
+      m_epsilon = epsilon;
+      m_isDense = m_vector.m_mode==IsDense;
+      if (m_isDense)
+      {
+        m_currentEl = 0;   // this is to avoid a compilation warning
+        m_cachedValue = 0; // this is to avoid a compilation warning
+        m_cachedIndex = m_vector.m_start-1;
+        ++(*this);
+      }
+      else
+      {
+        ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer);
+        m_currentEl = m_vector.m_llStart;
+        while (m_currentEl>=0 && abs(llElements[m_currentEl].value)<=m_epsilon)
+          m_currentEl = llElements[m_currentEl].next;
+        if (m_currentEl<0)
+        {
+          m_cachedValue = 0; // this is to avoid a compilation warning
+          m_cachedIndex = -1;
+        }
+        else
+        {
+          m_cachedIndex = llElements[m_currentEl].index;
+          m_cachedValue = llElements[m_currentEl].value;
+        }
+      }
+    }
+
+    StorageIndex index() const { return m_cachedIndex; }
+    Scalar value() const { return m_cachedValue; }
+
+    operator bool() const { return m_cachedIndex>=0; }
+
+    Iterator& operator++()
+    {
+      using std::abs;
+      if (m_isDense)
+      {
+        do {
+          ++m_cachedIndex;
+        } while (m_cachedIndex<m_vector.m_end && abs(m_vector.m_buffer[m_cachedIndex])<=m_epsilon);
+        if (m_cachedIndex<m_vector.m_end)
+          m_cachedValue = m_vector.m_buffer[m_cachedIndex];
+        else
+          m_cachedIndex=-1;
+      }
+      else
+      {
+        ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer);
+        do {
+          m_currentEl = llElements[m_currentEl].next;
+        } while (m_currentEl>=0 && abs(llElements[m_currentEl].value)<=m_epsilon);
+        if (m_currentEl<0)
+        {
+          m_cachedIndex = -1;
+        }
+        else
+        {
+          m_cachedIndex = llElements[m_currentEl].index;
+          m_cachedValue = llElements[m_currentEl].value;
+        }
+      }
+      return *this;
+    }
+
+  protected:
+    const AmbiVector& m_vector; // the target vector
+    StorageIndex m_currentEl;   // the current element in sparse/linked-list mode
+    RealScalar m_epsilon;       // epsilon used to prune zero coefficients
+    StorageIndex m_cachedIndex; // current coordinate
+    Scalar m_cachedValue;       // current value
+    bool m_isDense;             // mode of the vector
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_AMBIVECTOR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/CompressedStorage.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/CompressedStorage.h
new file mode 100644
index 00000000..acd986fa
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/CompressedStorage.h
@@ -0,0 +1,274 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPRESSED_STORAGE_H
+#define EIGEN_COMPRESSED_STORAGE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal
+  * Stores a sparse set of values as a list of values and a list of indices.
+  *
+  */
+template<typename _Scalar,typename _StorageIndex>
+class CompressedStorage
+{
+  public:
+
+    typedef _Scalar Scalar;
+    typedef _StorageIndex StorageIndex;
+
+  protected:
+
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  public:
+
+    CompressedStorage()
+      : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
+    {}
+
+    explicit CompressedStorage(Index size)
+      : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
+    {
+      resize(size);
+    }
+
+    CompressedStorage(const CompressedStorage& other)
+      : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
+    {
+      *this = other;
+    }
+
+    CompressedStorage& operator=(const CompressedStorage& other)
+    {
+      resize(other.size());
+      if(other.size()>0)
+      {
+        internal::smart_copy(other.m_values,  other.m_values  + m_size, m_values);
+        internal::smart_copy(other.m_indices, other.m_indices + m_size, m_indices);
+      }
+      return *this;
+    }
+
+    void swap(CompressedStorage& other)
+    {
+      std::swap(m_values, other.m_values);
+      std::swap(m_indices, other.m_indices);
+      std::swap(m_size, other.m_size);
+      std::swap(m_allocatedSize, other.m_allocatedSize);
+    }
+
+    ~CompressedStorage()
+    {
+      delete[] m_values;
+      delete[] m_indices;
+    }
+
+    void reserve(Index size)
+    {
+      Index newAllocatedSize = m_size + size;
+      if (newAllocatedSize > m_allocatedSize)
+        reallocate(newAllocatedSize);
+    }
+
+    void squeeze()
+    {
+      if (m_allocatedSize>m_size)
+        reallocate(m_size);
+    }
+
+    void resize(Index size, double reserveSizeFactor = 0)
+    {
+      if (m_allocatedSize<size)
+      {
+        Index realloc_size = (std::min<Index>)(NumTraits<StorageIndex>::highest(),  size + Index(reserveSizeFactor*double(size)));
+        if(realloc_size<size)
+          internal::throw_std_bad_alloc();
+        reallocate(realloc_size);
+      }
+      m_size = size;
+    }
+
+    void append(const Scalar& v, Index i)
+    {
+      Index id = m_size;
+      resize(m_size+1, 1);
+      m_values[id] = v;
+      m_indices[id] = internal::convert_index<StorageIndex>(i);
+    }
+
+    inline Index size() const { return m_size; }
+    inline Index allocatedSize() const { return m_allocatedSize; }
+    inline void clear() { m_size = 0; }
+
+    const Scalar* valuePtr() const { return m_values; }
+    Scalar* valuePtr() { return m_values; }
+    const StorageIndex* indexPtr() const { return m_indices; }
+    StorageIndex* indexPtr() { return m_indices; }
+
+    inline Scalar& value(Index i) { eigen_internal_assert(m_values!=0); return m_values[i]; }
+    inline const Scalar& value(Index i) const { eigen_internal_assert(m_values!=0); return m_values[i]; }
+
+    inline StorageIndex& index(Index i) { eigen_internal_assert(m_indices!=0); return m_indices[i]; }
+    inline const StorageIndex& index(Index i) const { eigen_internal_assert(m_indices!=0); return m_indices[i]; }
+
+    /** \returns the largest \c k such that for all \c j in [0,k) index[\c j]\<\a key */
+    inline Index searchLowerIndex(Index key) const
+    {
+      return searchLowerIndex(0, m_size, key);
+    }
+
+    /** \returns the largest \c k in [start,end) such that for all \c j in [start,k) index[\c j]\<\a key */
+    inline Index searchLowerIndex(Index start, Index end, Index key) const
+    {
+      while(end>start)
+      {
+        Index mid = (end+start)>>1;
+        if (m_indices[mid]<key)
+          start = mid+1;
+        else
+          end = mid;
+      }
+      return start;
+    }
+
+    /** \returns the stored value at index \a key
+      * If the value does not exist, then the value \a defaultValue is returned without any insertion. */
+    inline Scalar at(Index key, const Scalar& defaultValue = Scalar(0)) const
+    {
+      if (m_size==0)
+        return defaultValue;
+      else if (key==m_indices[m_size-1])
+        return m_values[m_size-1];
+      // ^^  optimization: let's first check if it is the last coefficient
+      // (very common in high level algorithms)
+      const Index id = searchLowerIndex(0,m_size-1,key);
+      return ((id<m_size) && (m_indices[id]==key)) ? m_values[id] : defaultValue;
+    }
+
+    /** Like at(), but the search is performed in the range [start,end) */
+    inline Scalar atInRange(Index start, Index end, Index key, const Scalar &defaultValue = Scalar(0)) const
+    {
+      if (start>=end)
+        return defaultValue;
+      else if (end>start && key==m_indices[end-1])
+        return m_values[end-1];
+      // ^^  optimization: let's first check if it is the last coefficient
+      // (very common in high level algorithms)
+      const Index id = searchLowerIndex(start,end-1,key);
+      return ((id<end) && (m_indices[id]==key)) ? m_values[id] : defaultValue;
+    }
+
+    /** \returns a reference to the value at index \a key
+      * If the value does not exist, then the value \a defaultValue is inserted
+      * such that the keys are sorted. */
+    inline Scalar& atWithInsertion(Index key, const Scalar& defaultValue = Scalar(0))
+    {
+      Index id = searchLowerIndex(0,m_size,key);
+      if (id>=m_size || m_indices[id]!=key)
+      {
+        if (m_allocatedSize<m_size+1)
+        {
+          m_allocatedSize = 2*(m_size+1);
+          internal::scoped_array<Scalar> newValues(m_allocatedSize);
+          internal::scoped_array<StorageIndex> newIndices(m_allocatedSize);
+
+          // copy first chunk
+          internal::smart_copy(m_values,  m_values +id, newValues.ptr());
+          internal::smart_copy(m_indices, m_indices+id, newIndices.ptr());
+
+          // copy the rest
+          if(m_size>id)
+          {
+            internal::smart_copy(m_values +id,  m_values +m_size, newValues.ptr() +id+1);
+            internal::smart_copy(m_indices+id,  m_indices+m_size, newIndices.ptr()+id+1);
+          }
+          std::swap(m_values,newValues.ptr());
+          std::swap(m_indices,newIndices.ptr());
+        }
+        else if(m_size>id)
+        {
+          internal::smart_memmove(m_values +id, m_values +m_size, m_values +id+1);
+          internal::smart_memmove(m_indices+id, m_indices+m_size, m_indices+id+1);
+        }
+        m_size++;
+        m_indices[id] = internal::convert_index<StorageIndex>(key);
+        m_values[id] = defaultValue;
+      }
+      return m_values[id];
+    }
+
+    void moveChunk(Index from, Index to, Index chunkSize)
+    {
+      eigen_internal_assert(to+chunkSize <= m_size);
+      if(to>from && from+chunkSize>to)
+      {
+        // move backward
+        internal::smart_memmove(m_values+from,  m_values+from+chunkSize,  m_values+to);
+        internal::smart_memmove(m_indices+from, m_indices+from+chunkSize, m_indices+to);
+      }
+      else
+      {
+        internal::smart_copy(m_values+from,  m_values+from+chunkSize,  m_values+to);
+        internal::smart_copy(m_indices+from, m_indices+from+chunkSize, m_indices+to);
+      }
+    }
+
+    void prune(const Scalar& reference, const RealScalar& epsilon = NumTraits<RealScalar>::dummy_precision())
+    {
+      Index k = 0;
+      Index n = size();
+      for (Index i=0; i<n; ++i)
+      {
+        if (!internal::isMuchSmallerThan(value(i), reference, epsilon))
+        {
+          value(k) = value(i);
+          index(k) = index(i);
+          ++k;
+        }
+      }
+      resize(k,0);
+    }
+
+  protected:
+
+    inline void reallocate(Index size)
+    {
+      #ifdef EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN
+        EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN
+      #endif
+      eigen_internal_assert(size!=m_allocatedSize);
+      internal::scoped_array<Scalar> newValues(size);
+      internal::scoped_array<StorageIndex> newIndices(size);
+      Index copySize = (std::min)(size, m_size);
+      if (copySize>0) {
+        internal::smart_copy(m_values, m_values+copySize, newValues.ptr());
+        internal::smart_copy(m_indices, m_indices+copySize, newIndices.ptr());
+      }
+      std::swap(m_values,newValues.ptr());
+      std::swap(m_indices,newIndices.ptr());
+      m_allocatedSize = size;
+    }
+
+  protected:
+    Scalar* m_values;
+    StorageIndex* m_indices;
+    Index m_size;
+    Index m_allocatedSize;
+
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPRESSED_STORAGE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h
new file mode 100644
index 00000000..94865025
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h
@@ -0,0 +1,352 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
+#define EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType>
+static void conservative_sparse_sparse_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res, bool sortedInsertion = false)
+{
+  typedef typename remove_all<Lhs>::type::Scalar LhsScalar;
+  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
+  typedef typename remove_all<ResultType>::type::Scalar ResScalar;
+
+  // make sure to call innerSize/outerSize since we fake the storage order.
+  Index rows = lhs.innerSize();
+  Index cols = rhs.outerSize();
+  eigen_assert(lhs.outerSize() == rhs.innerSize());
+
+  ei_declare_aligned_stack_constructed_variable(bool,   mask,     rows, 0);
+  ei_declare_aligned_stack_constructed_variable(ResScalar, values,   rows, 0);
+  ei_declare_aligned_stack_constructed_variable(Index,  indices,  rows, 0);
+
+  std::memset(mask,0,sizeof(bool)*rows);
+
+  evaluator<Lhs> lhsEval(lhs);
+  evaluator<Rhs> rhsEval(rhs);
+
+  // estimate the number of non zero entries
+  // given a rhs column containing Y non zeros, we assume that the respective Y columns
+  // of the lhs differs in average of one non zeros, thus the number of non zeros for
+  // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
+  // per column of the lhs.
+  // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
+  Index estimated_nnz_prod = lhsEval.nonZerosEstimate() + rhsEval.nonZerosEstimate();
+
+  res.setZero();
+  res.reserve(Index(estimated_nnz_prod));
+  // we compute each column of the result, one after the other
+  for (Index j=0; j<cols; ++j)
+  {
+
+    res.startVec(j);
+    Index nnz = 0;
+    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
+    {
+      RhsScalar y = rhsIt.value();
+      Index k = rhsIt.index();
+      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, k); lhsIt; ++lhsIt)
+      {
+        Index i = lhsIt.index();
+        LhsScalar x = lhsIt.value();
+        if(!mask[i])
+        {
+          mask[i] = true;
+          values[i] = x * y;
+          indices[nnz] = i;
+          ++nnz;
+        }
+        else
+          values[i] += x * y;
+      }
+    }
+    if(!sortedInsertion)
+    {
+      // unordered insertion
+      for(Index k=0; k<nnz; ++k)
+      {
+        Index i = indices[k];
+        res.insertBackByOuterInnerUnordered(j,i) = values[i];
+        mask[i] = false;
+      }
+    }
+    else
+    {
+      // alternative ordered insertion code:
+      const Index t200 = rows/11; // 11 == (log2(200)*1.39)
+      const Index t = (rows*100)/139;
+
+      // FIXME reserve nnz non zeros
+      // FIXME implement faster sorting algorithms for very small nnz
+      // if the result is sparse enough => use a quick sort
+      // otherwise => loop through the entire vector
+      // In order to avoid to perform an expensive log2 when the
+      // result is clearly very sparse we use a linear bound up to 200.
+      if((nnz<200 && nnz<t200) || nnz * numext::log2(int(nnz)) < t)
+      {
+        if(nnz>1) std::sort(indices,indices+nnz);
+        for(Index k=0; k<nnz; ++k)
+        {
+          Index i = indices[k];
+          res.insertBackByOuterInner(j,i) = values[i];
+          mask[i] = false;
+        }
+      }
+      else
+      {
+        // dense path
+        for(Index i=0; i<rows; ++i)
+        {
+          if(mask[i])
+          {
+            mask[i] = false;
+            res.insertBackByOuterInner(j,i) = values[i];
+          }
+        }
+      }
+    }
+  }
+  res.finalize();
+}
+
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType,
+  int LhsStorageOrder = (traits<Lhs>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+  int RhsStorageOrder = (traits<Rhs>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+  int ResStorageOrder = (traits<ResultType>::Flags&RowMajorBit) ? RowMajor : ColMajor>
+struct conservative_sparse_sparse_product_selector;
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor>
+{
+  typedef typename remove_all<Lhs>::type LhsCleaned;
+  typedef typename LhsCleaned::Scalar Scalar;
+
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorMatrix;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorMatrixAux;
+    typedef typename sparse_eval<ColMajorMatrixAux,ResultType::RowsAtCompileTime,ResultType::ColsAtCompileTime,ColMajorMatrixAux::Flags>::type ColMajorMatrix;
+
+    // If the result is tall and thin (in the extreme case a column vector)
+    // then it is faster to sort the coefficients inplace instead of transposing twice.
+    // FIXME, the following heuristic is probably not very good.
+    if(lhs.rows()>rhs.cols())
+    {
+      ColMajorMatrix resCol(lhs.rows(),rhs.cols());
+      // perform sorted insertion
+      internal::conservative_sparse_sparse_product_impl<Lhs,Rhs,ColMajorMatrix>(lhs, rhs, resCol, true);
+      res = resCol.markAsRValue();
+    }
+    else
+    {
+      ColMajorMatrixAux resCol(lhs.rows(),rhs.cols());
+      // resort to transpose to sort the entries
+      internal::conservative_sparse_sparse_product_impl<Lhs,Rhs,ColMajorMatrixAux>(lhs, rhs, resCol, false);
+      RowMajorMatrix resRow(resCol);
+      res = resRow.markAsRValue();
+    }
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorRhs;
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorRes;
+    RowMajorRhs rhsRow = rhs;
+    RowMajorRes resRow(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<RowMajorRhs,Lhs,RowMajorRes>(rhsRow, lhs, resRow);
+    res = resRow;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorLhs;
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorRes;
+    RowMajorLhs lhsRow = lhs;
+    RowMajorRes resRow(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Rhs,RowMajorLhs,RowMajorRes>(rhs, lhsRow, resRow);
+    res = resRow;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorMatrix;
+    RowMajorMatrix resRow(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Rhs,Lhs,RowMajorMatrix>(rhs, lhs, resRow);
+    res = resRow;
+  }
+};
+
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor>
+{
+  typedef typename traits<typename remove_all<Lhs>::type>::Scalar Scalar;
+
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorMatrix;
+    ColMajorMatrix resCol(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Lhs,Rhs,ColMajorMatrix>(lhs, rhs, resCol);
+    res = resCol;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorLhs;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRes;
+    ColMajorLhs lhsCol = lhs;
+    ColMajorRes resCol(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<ColMajorLhs,Rhs,ColMajorRes>(lhsCol, rhs, resCol);
+    res = resCol;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRhs;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRes;
+    ColMajorRhs rhsCol = rhs;
+    ColMajorRes resCol(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Lhs,ColMajorRhs,ColMajorRes>(lhs, rhsCol, resCol);
+    res = resCol;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorMatrix;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorMatrix;
+    RowMajorMatrix resRow(lhs.rows(),rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Rhs,Lhs,RowMajorMatrix>(rhs, lhs, resRow);
+    // sort the non zeros:
+    ColMajorMatrix resCol(resRow);
+    res = resCol;
+  }
+};
+
+} // end namespace internal
+
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType>
+static void sparse_sparse_to_dense_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+{
+  typedef typename remove_all<Lhs>::type::Scalar LhsScalar;
+  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
+  Index cols = rhs.outerSize();
+  eigen_assert(lhs.outerSize() == rhs.innerSize());
+
+  evaluator<Lhs> lhsEval(lhs);
+  evaluator<Rhs> rhsEval(rhs);
+
+  for (Index j=0; j<cols; ++j)
+  {
+    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
+    {
+      RhsScalar y = rhsIt.value();
+      Index k = rhsIt.index();
+      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, k); lhsIt; ++lhsIt)
+      {
+        Index i = lhsIt.index();
+        LhsScalar x = lhsIt.value();
+        res.coeffRef(i,j) += x * y;
+      }
+    }
+  }
+}
+
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType,
+  int LhsStorageOrder = (traits<Lhs>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+  int RhsStorageOrder = (traits<Rhs>::Flags&RowMajorBit) ? RowMajor : ColMajor>
+struct sparse_sparse_to_dense_product_selector;
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    internal::sparse_sparse_to_dense_product_impl<Lhs,Rhs,ResultType>(lhs, rhs, res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorLhs;
+    ColMajorLhs lhsCol(lhs);
+    internal::sparse_sparse_to_dense_product_impl<ColMajorLhs,Rhs,ResultType>(lhsCol, rhs, res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRhs;
+    ColMajorRhs rhsCol(rhs);
+    internal::sparse_sparse_to_dense_product_impl<Lhs,ColMajorRhs,ResultType>(lhs, rhsCol, res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    Transpose<ResultType> trRes(res);
+    internal::sparse_sparse_to_dense_product_impl<Rhs,Lhs,Transpose<ResultType> >(rhs, lhs, trRes);
+  }
+};
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/MappedSparseMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/MappedSparseMatrix.h
new file mode 100644
index 00000000..67718c85
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/MappedSparseMatrix.h
@@ -0,0 +1,67 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MAPPED_SPARSEMATRIX_H
+#define EIGEN_MAPPED_SPARSEMATRIX_H
+
+namespace Eigen {
+
+/** \deprecated Use Map<SparseMatrix<> >
+  * \class MappedSparseMatrix
+  *
+  * \brief Sparse matrix
+  *
+  * \param _Scalar the scalar type, i.e. the type of the coefficients
+  *
+  * See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme.
+  *
+  */
+namespace internal {
+template<typename _Scalar, int _Flags, typename _StorageIndex>
+struct traits<MappedSparseMatrix<_Scalar, _Flags, _StorageIndex> > : traits<SparseMatrix<_Scalar, _Flags, _StorageIndex> >
+{};
+} // end namespace internal
+
+template<typename _Scalar, int _Flags, typename _StorageIndex>
+class MappedSparseMatrix
+  : public Map<SparseMatrix<_Scalar, _Flags, _StorageIndex> >
+{
+    typedef Map<SparseMatrix<_Scalar, _Flags, _StorageIndex> > Base;
+
+  public:
+    
+    typedef typename Base::StorageIndex StorageIndex;
+    typedef typename Base::Scalar Scalar;
+
+    inline MappedSparseMatrix(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr, StorageIndex* innerIndexPtr, Scalar* valuePtr, StorageIndex* innerNonZeroPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZeroPtr)
+    {}
+
+    /** Empty destructor */
+    inline ~MappedSparseMatrix() {}
+};
+
+namespace internal {
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct evaluator<MappedSparseMatrix<_Scalar,_Options,_StorageIndex> >
+  : evaluator<SparseCompressedBase<MappedSparseMatrix<_Scalar,_Options,_StorageIndex> > >
+{
+  typedef MappedSparseMatrix<_Scalar,_Options,_StorageIndex> XprType;
+  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MAPPED_SPARSEMATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseAssign.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseAssign.h
new file mode 100644
index 00000000..905485c8
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseAssign.h
@@ -0,0 +1,270 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEASSIGN_H
+#define EIGEN_SPARSEASSIGN_H
+
+namespace Eigen { 
+
+template<typename Derived>    
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator=(const EigenBase<OtherDerived> &other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  // TODO use the evaluator mechanism
+  other.evalTo(derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+inline Derived& SparseMatrixBase<Derived>::operator=(const SparseMatrixBase<OtherDerived>& other)
+{
+  // by default sparse evaluation do not alias, so we can safely bypass the generic call_assignment routine
+  internal::Assignment<Derived,OtherDerived,internal::assign_op<Scalar,typename OtherDerived::Scalar> >
+          ::run(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+inline Derived& SparseMatrixBase<Derived>::operator=(const Derived& other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived());
+  return derived();
+}
+
+namespace internal {
+
+template<>
+struct storage_kind_to_evaluator_kind<Sparse> {
+  typedef IteratorBased Kind;
+};
+
+template<>
+struct storage_kind_to_shape<Sparse> {
+  typedef SparseShape Shape;
+};
+
+struct Sparse2Sparse {};
+struct Sparse2Dense  {};
+
+template<> struct AssignmentKind<SparseShape, SparseShape>           { typedef Sparse2Sparse Kind; };
+template<> struct AssignmentKind<SparseShape, SparseTriangularShape> { typedef Sparse2Sparse Kind; };
+template<> struct AssignmentKind<DenseShape,  SparseShape>           { typedef Sparse2Dense  Kind; };
+template<> struct AssignmentKind<DenseShape,  SparseTriangularShape> { typedef Sparse2Dense  Kind; };
+
+
+template<typename DstXprType, typename SrcXprType>
+void assign_sparse_to_sparse(DstXprType &dst, const SrcXprType &src)
+{
+  typedef typename DstXprType::Scalar Scalar;
+  typedef internal::evaluator<DstXprType> DstEvaluatorType;
+  typedef internal::evaluator<SrcXprType> SrcEvaluatorType;
+
+  SrcEvaluatorType srcEvaluator(src);
+
+  const bool transpose = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit);
+  const Index outerEvaluationSize = (SrcEvaluatorType::Flags&RowMajorBit) ? src.rows() : src.cols();
+  if ((!transpose) && src.isRValue())
+  {
+    // eval without temporary
+    dst.resize(src.rows(), src.cols());
+    dst.setZero();
+    dst.reserve((std::min)(src.rows()*src.cols(), (std::max)(src.rows(),src.cols())*2));
+    for (Index j=0; j<outerEvaluationSize; ++j)
+    {
+      dst.startVec(j);
+      for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it)
+      {
+        Scalar v = it.value();
+        dst.insertBackByOuterInner(j,it.index()) = v;
+      }
+    }
+    dst.finalize();
+  }
+  else
+  {
+    // eval through a temporary
+    eigen_assert(( ((internal::traits<DstXprType>::SupportedAccessPatterns & OuterRandomAccessPattern)==OuterRandomAccessPattern) ||
+              (!((DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit)))) &&
+              "the transpose operation is supposed to be handled in SparseMatrix::operator=");
+
+    enum { Flip = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit) };
+
+    
+    DstXprType temp(src.rows(), src.cols());
+
+    temp.reserve((std::min)(src.rows()*src.cols(), (std::max)(src.rows(),src.cols())*2));
+    for (Index j=0; j<outerEvaluationSize; ++j)
+    {
+      temp.startVec(j);
+      for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it)
+      {
+        Scalar v = it.value();
+        temp.insertBackByOuterInner(Flip?it.index():j,Flip?j:it.index()) = v;
+      }
+    }
+    temp.finalize();
+
+    dst = temp.markAsRValue();
+  }
+}
+
+// Generic Sparse to Sparse assignment
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Sparse>
+{
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    assign_sparse_to_sparse(dst.derived(), src.derived());
+  }
+};
+
+// Generic Sparse to Dense assignment
+template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
+struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Dense, Weak>
+{
+  static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    if(internal::is_same<Functor,internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> >::value)
+      dst.setZero();
+    
+    internal::evaluator<SrcXprType> srcEval(src);
+    resize_if_allowed(dst, src, func);
+    internal::evaluator<DstXprType> dstEval(dst);
+    
+    const Index outerEvaluationSize = (internal::evaluator<SrcXprType>::Flags&RowMajorBit) ? src.rows() : src.cols();
+    for (Index j=0; j<outerEvaluationSize; ++j)
+      for (typename internal::evaluator<SrcXprType>::InnerIterator i(srcEval,j); i; ++i)
+        func.assignCoeff(dstEval.coeffRef(i.row(),i.col()), i.value());
+  }
+};
+
+// Specialization for dense ?= dense +/- sparse and dense ?= sparse +/- dense
+template<typename DstXprType, typename Func1, typename Func2>
+struct assignment_from_dense_op_sparse
+{
+  template<typename SrcXprType, typename InitialFunc>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const InitialFunc& /*func*/)
+  {
+    #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_DENSE_OP_SPARSE_PLUGIN
+    EIGEN_SPARSE_ASSIGNMENT_FROM_DENSE_OP_SPARSE_PLUGIN
+    #endif
+
+    call_assignment_no_alias(dst, src.lhs(), Func1());
+    call_assignment_no_alias(dst, src.rhs(), Func2());
+  }
+
+  // Specialization for dense1 = sparse + dense2; -> dense1 = dense2; dense1 += sparse;
+  template<typename Lhs, typename Rhs, typename Scalar>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  typename internal::enable_if<internal::is_same<typename internal::evaluator_traits<Rhs>::Shape,DenseShape>::value>::type
+  run(DstXprType &dst, const CwiseBinaryOp<internal::scalar_sum_op<Scalar,Scalar>, const Lhs, const Rhs> &src,
+      const internal::assign_op<typename DstXprType::Scalar,Scalar>& /*func*/)
+  {
+    #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_ADD_DENSE_PLUGIN
+    EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_ADD_DENSE_PLUGIN
+    #endif
+
+    // Apply the dense matrix first, then the sparse one.
+    call_assignment_no_alias(dst, src.rhs(), Func1());
+    call_assignment_no_alias(dst, src.lhs(), Func2());
+  }
+
+  // Specialization for dense1 = sparse - dense2; -> dense1 = -dense2; dense1 += sparse;
+  template<typename Lhs, typename Rhs, typename Scalar>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  typename internal::enable_if<internal::is_same<typename internal::evaluator_traits<Rhs>::Shape,DenseShape>::value>::type
+  run(DstXprType &dst, const CwiseBinaryOp<internal::scalar_difference_op<Scalar,Scalar>, const Lhs, const Rhs> &src,
+      const internal::assign_op<typename DstXprType::Scalar,Scalar>& /*func*/)
+  {
+    #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_SUB_DENSE_PLUGIN
+    EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_SUB_DENSE_PLUGIN
+    #endif
+
+    // Apply the dense matrix first, then the sparse one.
+    call_assignment_no_alias(dst, -src.rhs(), Func1());
+    call_assignment_no_alias(dst,  src.lhs(), add_assign_op<typename DstXprType::Scalar,typename Lhs::Scalar>());
+  }
+};
+
+#define EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(ASSIGN_OP,BINOP,ASSIGN_OP2) \
+  template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar> \
+  struct Assignment<DstXprType, CwiseBinaryOp<internal::BINOP<Scalar,Scalar>, const Lhs, const Rhs>, internal::ASSIGN_OP<typename DstXprType::Scalar,Scalar>, \
+                    Sparse2Dense, \
+                    typename internal::enable_if<   internal::is_same<typename internal::evaluator_traits<Lhs>::Shape,DenseShape>::value \
+                                                 || internal::is_same<typename internal::evaluator_traits<Rhs>::Shape,DenseShape>::value>::type> \
+    : assignment_from_dense_op_sparse<DstXprType, internal::ASSIGN_OP<typename DstXprType::Scalar,typename Lhs::Scalar>, internal::ASSIGN_OP2<typename DstXprType::Scalar,typename Rhs::Scalar> > \
+  {}
+
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(assign_op,    scalar_sum_op,add_assign_op);
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(add_assign_op,scalar_sum_op,add_assign_op);
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(sub_assign_op,scalar_sum_op,sub_assign_op);
+
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(assign_op,    scalar_difference_op,sub_assign_op);
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(add_assign_op,scalar_difference_op,sub_assign_op);
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(sub_assign_op,scalar_difference_op,add_assign_op);
+
+
+// Specialization for "dst = dec.solve(rhs)"
+// NOTE we need to specialize it for Sparse2Sparse to avoid ambiguous specialization error
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar,Scalar>, Sparse2Sparse>
+{
+  typedef Solve<DecType,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec()._solve_impl(src.rhs(), dst);
+  }
+};
+
+struct Diagonal2Sparse {};
+
+template<> struct AssignmentKind<SparseShape,DiagonalShape> { typedef Diagonal2Sparse Kind; };
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Sparse>
+{
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  typedef typename DstXprType::Scalar Scalar;
+
+  template<int Options, typename AssignFunc>
+  static void run(SparseMatrix<Scalar,Options,StorageIndex> &dst, const SrcXprType &src, const AssignFunc &func)
+  { dst.assignDiagonal(src.diagonal(), func); }
+  
+  template<typename DstDerived>
+  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.derived().diagonal() = src.diagonal(); }
+  
+  template<typename DstDerived>
+  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.derived().diagonal() += src.diagonal(); }
+  
+  template<typename DstDerived>
+  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.derived().diagonal() -= src.diagonal(); }
+};
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEASSIGN_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseBlock.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseBlock.h
new file mode 100644
index 00000000..5b4f6cc9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseBlock.h
@@ -0,0 +1,571 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_BLOCK_H
+#define EIGEN_SPARSE_BLOCK_H
+
+namespace Eigen {
+
+// Subset of columns or rows
+template<typename XprType, int BlockRows, int BlockCols>
+class BlockImpl<XprType,BlockRows,BlockCols,true,Sparse>
+  : public SparseMatrixBase<Block<XprType,BlockRows,BlockCols,true> >
+{
+    typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested;
+    typedef Block<XprType, BlockRows, BlockCols, true> BlockType;
+public:
+    enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
+protected:
+    enum { OuterSize = IsRowMajor ? BlockRows : BlockCols };
+    typedef SparseMatrixBase<BlockType> Base;
+    using Base::convert_index;
+public:
+    EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
+
+    inline BlockImpl(XprType& xpr, Index i)
+      : m_matrix(xpr), m_outerStart(convert_index(i)), m_outerSize(OuterSize)
+    {}
+
+    inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : m_matrix(xpr), m_outerStart(convert_index(IsRowMajor ? startRow : startCol)), m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols))
+    {}
+
+    EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+    Index nonZeros() const
+    {
+      typedef internal::evaluator<XprType> EvaluatorType;
+      EvaluatorType matEval(m_matrix);
+      Index nnz = 0;
+      Index end = m_outerStart + m_outerSize.value();
+      for(Index j=m_outerStart; j<end; ++j)
+        for(typename EvaluatorType::InnerIterator it(matEval, j); it; ++it)
+          ++nnz;
+      return nnz;
+    }
+
+    inline const Scalar coeff(Index row, Index col) const
+    {
+      return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 :  m_outerStart));
+    }
+
+    inline const Scalar coeff(Index index) const
+    {
+      return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index :  m_outerStart);
+    }
+
+    inline const XprType& nestedExpression() const { return m_matrix; }
+    inline XprType& nestedExpression() { return m_matrix; }
+    Index startRow() const { return IsRowMajor ? m_outerStart : 0; }
+    Index startCol() const { return IsRowMajor ? 0 : m_outerStart; }
+    Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+  protected:
+
+    typename internal::ref_selector<XprType>::non_const_type m_matrix;
+    Index m_outerStart;
+    const internal::variable_if_dynamic<Index, OuterSize> m_outerSize;
+
+  protected:
+    // Disable assignment with clear error message.
+    // Note that simply removing operator= yields compilation errors with ICC+MSVC
+    template<typename T>
+    BlockImpl& operator=(const T&)
+    {
+      EIGEN_STATIC_ASSERT(sizeof(T)==0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY);
+      return *this;
+    }
+};
+
+
+/***************************************************************************
+* specialization for SparseMatrix
+***************************************************************************/
+
+namespace internal {
+
+template<typename SparseMatrixType, int BlockRows, int BlockCols>
+class sparse_matrix_block_impl
+  : public SparseCompressedBase<Block<SparseMatrixType,BlockRows,BlockCols,true> >
+{
+    typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _MatrixTypeNested;
+    typedef Block<SparseMatrixType, BlockRows, BlockCols, true> BlockType;
+    typedef SparseCompressedBase<Block<SparseMatrixType,BlockRows,BlockCols,true> > Base;
+    using Base::convert_index;
+public:
+    enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
+    EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
+protected:
+    typedef typename Base::IndexVector IndexVector;
+    enum { OuterSize = IsRowMajor ? BlockRows : BlockCols };
+public:
+
+    inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index i)
+      : m_matrix(xpr), m_outerStart(convert_index(i)), m_outerSize(OuterSize)
+    {}
+
+    inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : m_matrix(xpr), m_outerStart(convert_index(IsRowMajor ? startRow : startCol)), m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols))
+    {}
+
+    template<typename OtherDerived>
+    inline BlockType& operator=(const SparseMatrixBase<OtherDerived>& other)
+    {
+      typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _NestedMatrixType;
+      _NestedMatrixType& matrix = m_matrix;
+      // This assignment is slow if this vector set is not empty
+      // and/or it is not at the end of the nonzeros of the underlying matrix.
+
+      // 1 - eval to a temporary to avoid transposition and/or aliasing issues
+      Ref<const SparseMatrix<Scalar, IsRowMajor ? RowMajor : ColMajor, StorageIndex> > tmp(other.derived());
+      eigen_internal_assert(tmp.outerSize()==m_outerSize.value());
+
+      // 2 - let's check whether there is enough allocated memory
+      Index nnz           = tmp.nonZeros();
+      Index start         = m_outerStart==0 ? 0 : m_matrix.outerIndexPtr()[m_outerStart]; // starting position of the current block
+      Index end           = m_matrix.outerIndexPtr()[m_outerStart+m_outerSize.value()]; // ending position of the current block
+      Index block_size    = end - start;                                                // available room in the current block
+      Index tail_size     = m_matrix.outerIndexPtr()[m_matrix.outerSize()] - end;
+
+      Index free_size     = m_matrix.isCompressed()
+                          ? Index(matrix.data().allocatedSize()) + block_size
+                          : block_size;
+
+      Index tmp_start = tmp.outerIndexPtr()[0];
+
+      bool update_trailing_pointers = false;
+      if(nnz>free_size)
+      {
+        // realloc manually to reduce copies
+        typename SparseMatrixType::Storage newdata(m_matrix.data().allocatedSize() - block_size + nnz);
+
+        internal::smart_copy(m_matrix.valuePtr(),       m_matrix.valuePtr() + start,      newdata.valuePtr());
+        internal::smart_copy(m_matrix.innerIndexPtr(),  m_matrix.innerIndexPtr() + start, newdata.indexPtr());
+
+        internal::smart_copy(tmp.valuePtr() + tmp_start,      tmp.valuePtr() + tmp_start + nnz,       newdata.valuePtr() + start);
+        internal::smart_copy(tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz,  newdata.indexPtr() + start);
+
+        internal::smart_copy(matrix.valuePtr()+end,       matrix.valuePtr()+end + tail_size,      newdata.valuePtr()+start+nnz);
+        internal::smart_copy(matrix.innerIndexPtr()+end,  matrix.innerIndexPtr()+end + tail_size, newdata.indexPtr()+start+nnz);
+
+        newdata.resize(m_matrix.outerIndexPtr()[m_matrix.outerSize()] - block_size + nnz);
+
+        matrix.data().swap(newdata);
+
+        update_trailing_pointers = true;
+      }
+      else
+      {
+        if(m_matrix.isCompressed() && nnz!=block_size)
+        {
+          // no need to realloc, simply copy the tail at its respective position and insert tmp
+          matrix.data().resize(start + nnz + tail_size);
+
+          internal::smart_memmove(matrix.valuePtr()+end,      matrix.valuePtr() + end+tail_size,      matrix.valuePtr() + start+nnz);
+          internal::smart_memmove(matrix.innerIndexPtr()+end, matrix.innerIndexPtr() + end+tail_size, matrix.innerIndexPtr() + start+nnz);
+
+          update_trailing_pointers = true;
+        }
+
+        internal::smart_copy(tmp.valuePtr() + tmp_start,      tmp.valuePtr() + tmp_start + nnz,       matrix.valuePtr() + start);
+        internal::smart_copy(tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz,  matrix.innerIndexPtr() + start);
+      }
+
+      // update outer index pointers and innerNonZeros
+      if(IsVectorAtCompileTime)
+      {
+        if(!m_matrix.isCompressed())
+          matrix.innerNonZeroPtr()[m_outerStart] = StorageIndex(nnz);
+        matrix.outerIndexPtr()[m_outerStart] = StorageIndex(start);
+      }
+      else
+      {
+        StorageIndex p = StorageIndex(start);
+        for(Index k=0; k<m_outerSize.value(); ++k)
+        {
+          StorageIndex nnz_k = internal::convert_index<StorageIndex>(tmp.innerVector(k).nonZeros());
+          if(!m_matrix.isCompressed())
+            matrix.innerNonZeroPtr()[m_outerStart+k] = nnz_k;
+          matrix.outerIndexPtr()[m_outerStart+k] = p;
+          p += nnz_k;
+        }
+      }
+
+      if(update_trailing_pointers)
+      {
+        StorageIndex offset = internal::convert_index<StorageIndex>(nnz - block_size);
+        for(Index k = m_outerStart + m_outerSize.value(); k<=matrix.outerSize(); ++k)
+        {
+          matrix.outerIndexPtr()[k] += offset;
+        }
+      }
+
+      return derived();
+    }
+
+    inline BlockType& operator=(const BlockType& other)
+    {
+      return operator=<BlockType>(other);
+    }
+
+    inline const Scalar* valuePtr() const
+    { return m_matrix.valuePtr(); }
+    inline Scalar* valuePtr()
+    { return m_matrix.valuePtr(); }
+
+    inline const StorageIndex* innerIndexPtr() const
+    { return m_matrix.innerIndexPtr(); }
+    inline StorageIndex* innerIndexPtr()
+    { return m_matrix.innerIndexPtr(); }
+
+    inline const StorageIndex* outerIndexPtr() const
+    { return m_matrix.outerIndexPtr() + m_outerStart; }
+    inline StorageIndex* outerIndexPtr()
+    { return m_matrix.outerIndexPtr() + m_outerStart; }
+
+    inline const StorageIndex* innerNonZeroPtr() const
+    { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr()+m_outerStart); }
+    inline StorageIndex* innerNonZeroPtr()
+    { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr()+m_outerStart); }
+
+    bool isCompressed() const { return m_matrix.innerNonZeroPtr()==0; }
+
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      return m_matrix.coeffRef(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 :  m_outerStart));
+    }
+
+    inline const Scalar coeff(Index row, Index col) const
+    {
+      return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 :  m_outerStart));
+    }
+
+    inline const Scalar coeff(Index index) const
+    {
+      return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index :  m_outerStart);
+    }
+
+    const Scalar& lastCoeff() const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(sparse_matrix_block_impl);
+      eigen_assert(Base::nonZeros()>0);
+      if(m_matrix.isCompressed())
+        return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart+1]-1];
+      else
+        return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart]+m_matrix.innerNonZeroPtr()[m_outerStart]-1];
+    }
+
+    EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+    inline const SparseMatrixType& nestedExpression() const { return m_matrix; }
+    inline SparseMatrixType& nestedExpression() { return m_matrix; }
+    Index startRow() const { return IsRowMajor ? m_outerStart : 0; }
+    Index startCol() const { return IsRowMajor ? 0 : m_outerStart; }
+    Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+  protected:
+
+    typename internal::ref_selector<SparseMatrixType>::non_const_type m_matrix;
+    Index m_outerStart;
+    const internal::variable_if_dynamic<Index, OuterSize> m_outerSize;
+
+};
+
+} // namespace internal
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+class BlockImpl<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true,Sparse>
+  : public internal::sparse_matrix_block_impl<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols>
+{
+public:
+  typedef _StorageIndex StorageIndex;
+  typedef SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType;
+  typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,BlockCols> Base;
+  inline BlockImpl(SparseMatrixType& xpr, Index i)
+    : Base(xpr, i)
+  {}
+
+  inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+    : Base(xpr, startRow, startCol, blockRows, blockCols)
+  {}
+
+  using Base::operator=;
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+class BlockImpl<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true,Sparse>
+  : public internal::sparse_matrix_block_impl<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols>
+{
+public:
+  typedef _StorageIndex StorageIndex;
+  typedef const SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType;
+  typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,BlockCols> Base;
+  inline BlockImpl(SparseMatrixType& xpr, Index i)
+    : Base(xpr, i)
+  {}
+
+  inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+    : Base(xpr, startRow, startCol, blockRows, blockCols)
+  {}
+
+  using Base::operator=;
+private:
+  template<typename Derived> BlockImpl(const SparseMatrixBase<Derived>& xpr, Index i);
+  template<typename Derived> BlockImpl(const SparseMatrixBase<Derived>& xpr);
+};
+
+//----------
+
+/** Generic implementation of sparse Block expression.
+  * Real-only.
+  */
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+class BlockImpl<XprType,BlockRows,BlockCols,InnerPanel,Sparse>
+  : public SparseMatrixBase<Block<XprType,BlockRows,BlockCols,InnerPanel> >, internal::no_assignment_operator
+{
+    typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
+    typedef SparseMatrixBase<BlockType> Base;
+    using Base::convert_index;
+public:
+    enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
+    EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
+
+    typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested;
+
+    /** Column or Row constructor
+      */
+    inline BlockImpl(XprType& xpr, Index i)
+      : m_matrix(xpr),
+        m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? convert_index(i) : 0),
+        m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? convert_index(i) : 0),
+        m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
+        m_blockCols(BlockCols==1 ? 1 : xpr.cols())
+    {}
+
+    /** Dynamic-size constructor
+      */
+    inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : m_matrix(xpr), m_startRow(convert_index(startRow)), m_startCol(convert_index(startCol)), m_blockRows(convert_index(blockRows)), m_blockCols(convert_index(blockCols))
+    {}
+
+    inline Index rows() const { return m_blockRows.value(); }
+    inline Index cols() const { return m_blockCols.value(); }
+
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      return m_matrix.coeffRef(row + m_startRow.value(), col + m_startCol.value());
+    }
+
+    inline const Scalar coeff(Index row, Index col) const
+    {
+      return m_matrix.coeff(row + m_startRow.value(), col + m_startCol.value());
+    }
+
+    inline Scalar& coeffRef(Index index)
+    {
+      return m_matrix.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                               m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    inline const Scalar coeff(Index index) const
+    {
+      return m_matrix.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                            m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    inline const XprType& nestedExpression() const { return m_matrix; }
+    inline XprType& nestedExpression() { return m_matrix; }
+    Index startRow() const { return m_startRow.value(); }
+    Index startCol() const { return m_startCol.value(); }
+    Index blockRows() const { return m_blockRows.value(); }
+    Index blockCols() const { return m_blockCols.value(); }
+
+  protected:
+//     friend class internal::GenericSparseBlockInnerIteratorImpl<XprType,BlockRows,BlockCols,InnerPanel>;
+    friend struct internal::unary_evaluator<Block<XprType,BlockRows,BlockCols,InnerPanel>, internal::IteratorBased, Scalar >;
+
+    Index nonZeros() const { return Dynamic; }
+
+    typename internal::ref_selector<XprType>::non_const_type m_matrix;
+    const internal::variable_if_dynamic<Index, XprType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
+    const internal::variable_if_dynamic<Index, XprType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
+    const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_blockRows;
+    const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_blockCols;
+
+  protected:
+    // Disable assignment with clear error message.
+    // Note that simply removing operator= yields compilation errors with ICC+MSVC
+    template<typename T>
+    BlockImpl& operator=(const T&)
+    {
+      EIGEN_STATIC_ASSERT(sizeof(T)==0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY);
+      return *this;
+    }
+
+};
+
+namespace internal {
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased >
+ : public evaluator_base<Block<ArgType,BlockRows,BlockCols,InnerPanel> >
+{
+    class InnerVectorInnerIterator;
+    class OuterVectorInnerIterator;
+  public:
+    typedef Block<ArgType,BlockRows,BlockCols,InnerPanel> XprType;
+    typedef typename XprType::StorageIndex StorageIndex;
+    typedef typename XprType::Scalar Scalar;
+
+    enum {
+      IsRowMajor = XprType::IsRowMajor,
+
+      OuterVector =  (BlockCols==1 && ArgType::IsRowMajor)
+                    | // FIXME | instead of || to please GCC 4.4.0 stupid warning "suggest parentheses around &&".
+                      // revert to || as soon as not needed anymore.
+                     (BlockRows==1 && !ArgType::IsRowMajor),
+
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+
+    typedef typename internal::conditional<OuterVector,OuterVectorInnerIterator,InnerVectorInnerIterator>::type InnerIterator;
+
+    explicit unary_evaluator(const XprType& op)
+      : m_argImpl(op.nestedExpression()), m_block(op)
+    {}
+
+    inline Index nonZerosEstimate() const {
+      const Index nnz = m_block.nonZeros();
+      if(nnz < 0) {
+        // Scale the non-zero estimate for the underlying expression linearly with block size.
+        // Return zero if the underlying block is empty.
+        const Index nested_sz = m_block.nestedExpression().size();        
+        return nested_sz == 0 ? 0 : m_argImpl.nonZerosEstimate() * m_block.size() / nested_sz;
+      }
+      return nnz;
+    }
+
+  protected:
+    typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+
+    evaluator<ArgType> m_argImpl;
+    const XprType &m_block;
+};
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+class unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased>::InnerVectorInnerIterator
+ : public EvalIterator
+{
+  // NOTE MSVC fails to compile if we don't explicitely "import" IsRowMajor from unary_evaluator
+  //      because the base class EvalIterator has a private IsRowMajor enum too. (bug #1786)
+  // NOTE We cannot call it IsRowMajor because it would shadow unary_evaluator::IsRowMajor
+  enum { XprIsRowMajor = unary_evaluator::IsRowMajor };
+  const XprType& m_block;
+  Index m_end;
+public:
+
+  EIGEN_STRONG_INLINE InnerVectorInnerIterator(const unary_evaluator& aEval, Index outer)
+    : EvalIterator(aEval.m_argImpl, outer + (XprIsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol())),
+      m_block(aEval.m_block),
+      m_end(XprIsRowMajor ? aEval.m_block.startCol()+aEval.m_block.blockCols() : aEval.m_block.startRow()+aEval.m_block.blockRows())
+  {
+    while( (EvalIterator::operator bool()) && (EvalIterator::index() < (XprIsRowMajor ? m_block.startCol() : m_block.startRow())) )
+      EvalIterator::operator++();
+  }
+
+  inline StorageIndex index() const { return EvalIterator::index() - convert_index<StorageIndex>(XprIsRowMajor ? m_block.startCol() : m_block.startRow()); }
+  inline Index outer()  const { return EvalIterator::outer() - (XprIsRowMajor ? m_block.startRow() : m_block.startCol()); }
+  inline Index row()    const { return EvalIterator::row()   - m_block.startRow(); }
+  inline Index col()    const { return EvalIterator::col()   - m_block.startCol(); }
+
+  inline operator bool() const { return EvalIterator::operator bool() && EvalIterator::index() < m_end; }
+};
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+class unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased>::OuterVectorInnerIterator
+{
+  // NOTE see above
+  enum { XprIsRowMajor = unary_evaluator::IsRowMajor };
+  const unary_evaluator& m_eval;
+  Index m_outerPos;
+  const Index m_innerIndex;
+  Index m_end;
+  EvalIterator m_it;
+public:
+
+  EIGEN_STRONG_INLINE OuterVectorInnerIterator(const unary_evaluator& aEval, Index outer)
+    : m_eval(aEval),
+      m_outerPos( (XprIsRowMajor ? aEval.m_block.startCol() : aEval.m_block.startRow()) ),
+      m_innerIndex(XprIsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol()),
+      m_end(XprIsRowMajor ? aEval.m_block.startCol()+aEval.m_block.blockCols() : aEval.m_block.startRow()+aEval.m_block.blockRows()),
+      m_it(m_eval.m_argImpl, m_outerPos)
+  {
+    EIGEN_UNUSED_VARIABLE(outer);
+    eigen_assert(outer==0);
+
+    while(m_it && m_it.index() < m_innerIndex) ++m_it;
+    if((!m_it) || (m_it.index()!=m_innerIndex))
+      ++(*this);
+  }
+
+  inline StorageIndex index() const { return convert_index<StorageIndex>(m_outerPos - (XprIsRowMajor ? m_eval.m_block.startCol() : m_eval.m_block.startRow())); }
+  inline Index outer()  const { return 0; }
+  inline Index row()    const { return XprIsRowMajor ? 0 : index(); }
+  inline Index col()    const { return XprIsRowMajor ? index() : 0; }
+
+  inline Scalar value() const { return m_it.value(); }
+  inline Scalar& valueRef() { return m_it.valueRef(); }
+
+  inline OuterVectorInnerIterator& operator++()
+  {
+    // search next non-zero entry
+    while(++m_outerPos<m_end)
+    {
+      // Restart iterator at the next inner-vector:
+      m_it.~EvalIterator();
+      ::new (&m_it) EvalIterator(m_eval.m_argImpl, m_outerPos);
+      // search for the key m_innerIndex in the current outer-vector
+      while(m_it && m_it.index() < m_innerIndex) ++m_it;
+      if(m_it && m_it.index()==m_innerIndex) break;
+    }
+    return *this;
+  }
+
+  inline operator bool() const { return m_outerPos < m_end; }
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+struct unary_evaluator<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true>, IteratorBased>
+  : evaluator<SparseCompressedBase<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> > >
+{
+  typedef Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> XprType;
+  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  explicit unary_evaluator(const XprType &xpr) : Base(xpr) {}
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+struct unary_evaluator<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true>, IteratorBased>
+  : evaluator<SparseCompressedBase<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> > >
+{
+  typedef Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> XprType;
+  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  explicit unary_evaluator(const XprType &xpr) : Base(xpr) {}
+};
+
+} // end namespace internal
+
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_BLOCK_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseColEtree.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseColEtree.h
new file mode 100644
index 00000000..ebe02d1a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseColEtree.h
@@ -0,0 +1,206 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+/* 
+ 
+ * NOTE: This file is the modified version of sp_coletree.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.1) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * August 1, 2008
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSE_COLETREE_H
+#define SPARSE_COLETREE_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** Find the root of the tree/set containing the vertex i : Use Path halving */ 
+template<typename Index, typename IndexVector>
+Index etree_find (Index i, IndexVector& pp)
+{
+  Index p = pp(i); // Parent 
+  Index gp = pp(p); // Grand parent 
+  while (gp != p) 
+  {
+    pp(i) = gp; // Parent pointer on find path is changed to former grand parent
+    i = gp; 
+    p = pp(i);
+    gp = pp(p);
+  }
+  return p; 
+}
+
+/** Compute the column elimination tree of a sparse matrix
+  * \param mat The matrix in column-major format. 
+  * \param parent The elimination tree
+  * \param firstRowElt The column index of the first element in each row
+  * \param perm The permutation to apply to the column of \b mat
+  */
+template <typename MatrixType, typename IndexVector>
+int coletree(const MatrixType& mat, IndexVector& parent, IndexVector& firstRowElt, typename MatrixType::StorageIndex *perm=0)
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  StorageIndex nc = convert_index<StorageIndex>(mat.cols()); // Number of columns
+  StorageIndex m = convert_index<StorageIndex>(mat.rows());
+  StorageIndex diagSize = (std::min)(nc,m);
+  IndexVector root(nc); // root of subtree of etree 
+  root.setZero();
+  IndexVector pp(nc); // disjoint sets 
+  pp.setZero(); // Initialize disjoint sets 
+  parent.resize(mat.cols());
+  //Compute first nonzero column in each row 
+  firstRowElt.resize(m);
+  firstRowElt.setConstant(nc);
+  firstRowElt.segment(0, diagSize).setLinSpaced(diagSize, 0, diagSize-1);
+  bool found_diag;
+  for (StorageIndex col = 0; col < nc; col++)
+  {
+    StorageIndex pcol = col;
+    if(perm) pcol  = perm[col];
+    for (typename MatrixType::InnerIterator it(mat, pcol); it; ++it)
+    { 
+      Index row = it.row();
+      firstRowElt(row) = (std::min)(firstRowElt(row), col);
+    }
+  }
+  /* Compute etree by Liu's algorithm for symmetric matrices,
+          except use (firstRowElt[r],c) in place of an edge (r,c) of A.
+    Thus each row clique in A'*A is replaced by a star
+    centered at its first vertex, which has the same fill. */
+  StorageIndex rset, cset, rroot;
+  for (StorageIndex col = 0; col < nc; col++) 
+  {
+    found_diag = col>=m;
+    pp(col) = col; 
+    cset = col; 
+    root(cset) = col; 
+    parent(col) = nc; 
+    /* The diagonal element is treated here even if it does not exist in the matrix
+     * hence the loop is executed once more */ 
+    StorageIndex pcol = col;
+    if(perm) pcol  = perm[col];
+    for (typename MatrixType::InnerIterator it(mat, pcol); it||!found_diag; ++it)
+    { //  A sequence of interleaved find and union is performed 
+      Index i = col;
+      if(it) i = it.index();
+      if (i == col) found_diag = true;
+      
+      StorageIndex row = firstRowElt(i);
+      if (row >= col) continue; 
+      rset = internal::etree_find(row, pp); // Find the name of the set containing row
+      rroot = root(rset);
+      if (rroot != col) 
+      {
+        parent(rroot) = col; 
+        pp(cset) = rset; 
+        cset = rset; 
+        root(cset) = col; 
+      }
+    }
+  }
+  return 0;  
+}
+
+/** 
+  * Depth-first search from vertex n.  No recursion.
+  * This routine was contributed by Cédric Doucet, CEDRAT Group, Meylan, France.
+*/
+template <typename IndexVector>
+void nr_etdfs (typename IndexVector::Scalar n, IndexVector& parent, IndexVector& first_kid, IndexVector& next_kid, IndexVector& post, typename IndexVector::Scalar postnum)
+{
+  typedef typename IndexVector::Scalar StorageIndex;
+  StorageIndex current = n, first, next;
+  while (postnum != n) 
+  {
+    // No kid for the current node
+    first = first_kid(current);
+    
+    // no kid for the current node
+    if (first == -1) 
+    {
+      // Numbering this node because it has no kid 
+      post(current) = postnum++;
+      
+      // looking for the next kid 
+      next = next_kid(current); 
+      while (next == -1) 
+      {
+        // No more kids : back to the parent node
+        current = parent(current); 
+        // numbering the parent node 
+        post(current) = postnum++;
+        
+        // Get the next kid 
+        next = next_kid(current); 
+      }
+      // stopping criterion 
+      if (postnum == n+1) return; 
+      
+      // Updating current node 
+      current = next; 
+    }
+    else 
+    {
+      current = first; 
+    }
+  }
+}
+
+
+/**
+  * \brief Post order a tree 
+  * \param n the number of nodes
+  * \param parent Input tree
+  * \param post postordered tree
+  */
+template <typename IndexVector>
+void treePostorder(typename IndexVector::Scalar n, IndexVector& parent, IndexVector& post)
+{
+  typedef typename IndexVector::Scalar StorageIndex;
+  IndexVector first_kid, next_kid; // Linked list of children 
+  StorageIndex postnum; 
+  // Allocate storage for working arrays and results 
+  first_kid.resize(n+1); 
+  next_kid.setZero(n+1);
+  post.setZero(n+1);
+  
+  // Set up structure describing children
+  first_kid.setConstant(-1); 
+  for (StorageIndex v = n-1; v >= 0; v--) 
+  {
+    StorageIndex dad = parent(v);
+    next_kid(v) = first_kid(dad); 
+    first_kid(dad) = v; 
+  }
+  
+  // Depth-first search from dummy root vertex #n
+  postnum = 0; 
+  internal::nr_etdfs(n, parent, first_kid, next_kid, post, postnum);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // SPARSE_COLETREE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseCompressedBase.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseCompressedBase.h
new file mode 100644
index 00000000..6a2c7a8c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseCompressedBase.h
@@ -0,0 +1,370 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_COMPRESSED_BASE_H
+#define EIGEN_SPARSE_COMPRESSED_BASE_H
+
+namespace Eigen { 
+
+template<typename Derived> class SparseCompressedBase;
+  
+namespace internal {
+
+template<typename Derived>
+struct traits<SparseCompressedBase<Derived> > : traits<Derived>
+{};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  * \class SparseCompressedBase
+  * \brief Common base class for sparse [compressed]-{row|column}-storage format.
+  *
+  * This class defines the common interface for all derived classes implementing the compressed sparse storage format, such as:
+  *  - SparseMatrix
+  *  - Ref<SparseMatrixType,Options>
+  *  - Map<SparseMatrixType>
+  *
+  */
+template<typename Derived>
+class SparseCompressedBase
+  : public SparseMatrixBase<Derived>
+{
+  public:
+    typedef SparseMatrixBase<Derived> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(SparseCompressedBase)
+    using Base::operator=;
+    using Base::IsRowMajor;
+    
+    class InnerIterator;
+    class ReverseInnerIterator;
+    
+  protected:
+    typedef typename Base::IndexVector IndexVector;
+    Eigen::Map<IndexVector> innerNonZeros() { return Eigen::Map<IndexVector>(innerNonZeroPtr(), isCompressed()?0:derived().outerSize()); }
+    const  Eigen::Map<const IndexVector> innerNonZeros() const { return Eigen::Map<const IndexVector>(innerNonZeroPtr(), isCompressed()?0:derived().outerSize()); }
+        
+  public:
+    
+    /** \returns the number of non zero coefficients */
+    inline Index nonZeros() const
+    {
+      if(Derived::IsVectorAtCompileTime && outerIndexPtr()==0)
+        return derived().nonZeros();
+      else if(isCompressed())
+        return outerIndexPtr()[derived().outerSize()]-outerIndexPtr()[0];
+      else if(derived().outerSize()==0)
+        return 0;
+      else
+        return innerNonZeros().sum();
+    }
+    
+    /** \returns a const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline const Scalar* valuePtr() const { return derived().valuePtr(); }
+    /** \returns a non-const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline Scalar* valuePtr() { return derived().valuePtr(); }
+
+    /** \returns a const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline const StorageIndex* innerIndexPtr() const { return derived().innerIndexPtr(); }
+    /** \returns a non-const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline StorageIndex* innerIndexPtr() { return derived().innerIndexPtr(); }
+
+    /** \returns a const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 for SparseVector
+      * \sa valuePtr(), innerIndexPtr() */
+    inline const StorageIndex* outerIndexPtr() const { return derived().outerIndexPtr(); }
+    /** \returns a non-const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 for SparseVector
+      * \sa valuePtr(), innerIndexPtr() */
+    inline StorageIndex* outerIndexPtr() { return derived().outerIndexPtr(); }
+
+    /** \returns a const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline const StorageIndex* innerNonZeroPtr() const { return derived().innerNonZeroPtr(); }
+    /** \returns a non-const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline StorageIndex* innerNonZeroPtr() { return derived().innerNonZeroPtr(); }
+    
+    /** \returns whether \c *this is in compressed form. */
+    inline bool isCompressed() const { return innerNonZeroPtr()==0; }
+
+    /** \returns a read-only view of the stored coefficients as a 1D array expression.
+      *
+      * \warning this method is for \b compressed \b storage \b only, and it will trigger an assertion otherwise.
+      *
+      * \sa valuePtr(), isCompressed() */
+    const Map<const Array<Scalar,Dynamic,1> > coeffs() const { eigen_assert(isCompressed()); return Array<Scalar,Dynamic,1>::Map(valuePtr(),nonZeros()); }
+
+    /** \returns a read-write view of the stored coefficients as a 1D array expression
+      *
+      * \warning this method is for \b compressed \b storage \b only, and it will trigger an assertion otherwise.
+      *
+      * Here is an example:
+      * \include SparseMatrix_coeffs.cpp
+      * and the output is:
+      * \include SparseMatrix_coeffs.out
+      *
+      * \sa valuePtr(), isCompressed() */
+    Map<Array<Scalar,Dynamic,1> > coeffs() { eigen_assert(isCompressed()); return Array<Scalar,Dynamic,1>::Map(valuePtr(),nonZeros()); }
+
+  protected:
+    /** Default constructor. Do nothing. */
+    SparseCompressedBase() {}
+
+    /** \internal return the index of the coeff at (row,col) or just before if it does not exist.
+      * This is an analogue of std::lower_bound.
+      */
+    internal::LowerBoundIndex lower_bound(Index row, Index col) const
+    {
+      eigen_internal_assert(row>=0 && row<this->rows() && col>=0 && col<this->cols());
+
+      const Index outer = Derived::IsRowMajor ? row : col;
+      const Index inner = Derived::IsRowMajor ? col : row;
+
+      Index start = this->outerIndexPtr()[outer];
+      Index end = this->isCompressed() ? this->outerIndexPtr()[outer+1] : this->outerIndexPtr()[outer] + this->innerNonZeroPtr()[outer];
+      eigen_assert(end>=start && "you are using a non finalized sparse matrix or written coefficient does not exist");
+      internal::LowerBoundIndex p;
+      p.value = std::lower_bound(this->innerIndexPtr()+start, this->innerIndexPtr()+end,inner) - this->innerIndexPtr();
+      p.found = (p.value<end) && (this->innerIndexPtr()[p.value]==inner);
+      return p;
+    }
+
+    friend struct internal::evaluator<SparseCompressedBase<Derived> >;
+
+  private:
+    template<typename OtherDerived> explicit SparseCompressedBase(const SparseCompressedBase<OtherDerived>&);
+};
+
+template<typename Derived>
+class SparseCompressedBase<Derived>::InnerIterator
+{
+  public:
+    InnerIterator()
+      : m_values(0), m_indices(0), m_outer(0), m_id(0), m_end(0)
+    {}
+
+    InnerIterator(const InnerIterator& other)
+      : m_values(other.m_values), m_indices(other.m_indices), m_outer(other.m_outer), m_id(other.m_id), m_end(other.m_end)
+    {}
+
+    InnerIterator& operator=(const InnerIterator& other)
+    {
+      m_values = other.m_values;
+      m_indices = other.m_indices;
+      const_cast<OuterType&>(m_outer).setValue(other.m_outer.value());
+      m_id = other.m_id;
+      m_end = other.m_end;
+      return *this;
+    }
+
+    InnerIterator(const SparseCompressedBase& mat, Index outer)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer)
+    {
+      if(Derived::IsVectorAtCompileTime && mat.outerIndexPtr()==0)
+      {
+        m_id = 0;
+        m_end = mat.nonZeros();
+      }
+      else
+      {
+        m_id = mat.outerIndexPtr()[outer];
+        if(mat.isCompressed())
+          m_end = mat.outerIndexPtr()[outer+1];
+        else
+          m_end = m_id + mat.innerNonZeroPtr()[outer];
+      }
+    }
+
+    explicit InnerIterator(const SparseCompressedBase& mat)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(0), m_id(0), m_end(mat.nonZeros())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    explicit InnerIterator(const internal::CompressedStorage<Scalar,StorageIndex>& data)
+      : m_values(data.valuePtr()), m_indices(data.indexPtr()), m_outer(0), m_id(0), m_end(data.size())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    inline InnerIterator& operator++() { m_id++; return *this; }
+    inline InnerIterator& operator+=(Index i) { m_id += i ; return *this; }
+
+    inline InnerIterator operator+(Index i) 
+    { 
+        InnerIterator result = *this;
+        result += i;
+        return result;
+    }
+
+    inline const Scalar& value() const { return m_values[m_id]; }
+    inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id]); }
+
+    inline StorageIndex index() const { return m_indices[m_id]; }
+    inline Index outer() const { return m_outer.value(); }
+    inline Index row() const { return IsRowMajor ? m_outer.value() : index(); }
+    inline Index col() const { return IsRowMajor ? index() : m_outer.value(); }
+
+    inline operator bool() const { return (m_id < m_end); }
+
+  protected:
+    const Scalar* m_values;
+    const StorageIndex* m_indices;
+    typedef internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTime?0:Dynamic> OuterType;
+    const OuterType m_outer;
+    Index m_id;
+    Index m_end;
+  private:
+    // If you get here, then you're not using the right InnerIterator type, e.g.:
+    //   SparseMatrix<double,RowMajor> A;
+    //   SparseMatrix<double>::InnerIterator it(A,0);
+    template<typename T> InnerIterator(const SparseMatrixBase<T>&, Index outer);
+};
+
+template<typename Derived>
+class SparseCompressedBase<Derived>::ReverseInnerIterator
+{
+  public:
+    ReverseInnerIterator(const SparseCompressedBase& mat, Index outer)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer)
+    {
+      if(Derived::IsVectorAtCompileTime && mat.outerIndexPtr()==0)
+      {
+        m_start = 0;
+        m_id = mat.nonZeros();
+      }
+      else
+      {
+        m_start = mat.outerIndexPtr()[outer];
+        if(mat.isCompressed())
+          m_id = mat.outerIndexPtr()[outer+1];
+        else
+          m_id = m_start + mat.innerNonZeroPtr()[outer];
+      }
+    }
+
+    explicit ReverseInnerIterator(const SparseCompressedBase& mat)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(0), m_start(0), m_id(mat.nonZeros())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    explicit ReverseInnerIterator(const internal::CompressedStorage<Scalar,StorageIndex>& data)
+      : m_values(data.valuePtr()), m_indices(data.indexPtr()), m_outer(0), m_start(0), m_id(data.size())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    inline ReverseInnerIterator& operator--() { --m_id; return *this; }
+    inline ReverseInnerIterator& operator-=(Index i) { m_id -= i; return *this; }
+
+    inline ReverseInnerIterator operator-(Index i) 
+    {
+        ReverseInnerIterator result = *this;
+        result -= i;
+        return result;
+    }
+
+    inline const Scalar& value() const { return m_values[m_id-1]; }
+    inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id-1]); }
+
+    inline StorageIndex index() const { return m_indices[m_id-1]; }
+    inline Index outer() const { return m_outer.value(); }
+    inline Index row() const { return IsRowMajor ? m_outer.value() : index(); }
+    inline Index col() const { return IsRowMajor ? index() : m_outer.value(); }
+
+    inline operator bool() const { return (m_id > m_start); }
+
+  protected:
+    const Scalar* m_values;
+    const StorageIndex* m_indices;
+    typedef internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTime?0:Dynamic> OuterType;
+    const OuterType m_outer;
+    Index m_start;
+    Index m_id;
+};
+
+namespace internal {
+
+template<typename Derived>
+struct evaluator<SparseCompressedBase<Derived> >
+  : evaluator_base<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  typedef typename Derived::InnerIterator InnerIterator;
+  
+  enum {
+    CoeffReadCost = NumTraits<Scalar>::ReadCost,
+    Flags = Derived::Flags
+  };
+  
+  evaluator() : m_matrix(0), m_zero(0)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  explicit evaluator(const Derived &mat) : m_matrix(&mat), m_zero(0)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_matrix->nonZeros();
+  }
+  
+  operator Derived&() { return m_matrix->const_cast_derived(); }
+  operator const Derived&() const { return *m_matrix; }
+  
+  typedef typename DenseCoeffsBase<Derived,ReadOnlyAccessors>::CoeffReturnType CoeffReturnType;
+  const Scalar& coeff(Index row, Index col) const
+  {
+    Index p = find(row,col);
+
+    if(p==Dynamic)
+      return m_zero;
+    else
+      return m_matrix->const_cast_derived().valuePtr()[p];
+  }
+
+  Scalar& coeffRef(Index row, Index col)
+  {
+    Index p = find(row,col);
+    eigen_assert(p!=Dynamic && "written coefficient does not exist");
+    return m_matrix->const_cast_derived().valuePtr()[p];
+  }
+
+protected:
+
+  Index find(Index row, Index col) const
+  {
+    internal::LowerBoundIndex p = m_matrix->lower_bound(row,col);
+    return p.found ? p.value : Dynamic;
+  }
+
+  const Derived *m_matrix;
+  const Scalar m_zero;
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_COMPRESSED_BASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseCwiseBinaryOp.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
new file mode 100644
index 00000000..9b0d3f98
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
@@ -0,0 +1,722 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_CWISE_BINARY_OP_H
+#define EIGEN_SPARSE_CWISE_BINARY_OP_H
+
+namespace Eigen { 
+
+// Here we have to handle 3 cases:
+//  1 - sparse op dense
+//  2 - dense op sparse
+//  3 - sparse op sparse
+// We also need to implement a 4th iterator for:
+//  4 - dense op dense
+// Finally, we also need to distinguish between the product and other operations :
+//                configuration      returned mode
+//  1 - sparse op dense    product      sparse
+//                         generic      dense
+//  2 - dense op sparse    product      sparse
+//                         generic      dense
+//  3 - sparse op sparse   product      sparse
+//                         generic      sparse
+//  4 - dense op dense     product      dense
+//                         generic      dense
+//
+// TODO to ease compiler job, we could specialize product/quotient with a scalar
+//      and fallback to cwise-unary evaluator using bind1st_op and bind2nd_op.
+
+template<typename BinaryOp, typename Lhs, typename Rhs>
+class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Sparse>
+  : public SparseMatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  public:
+    typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived;
+    typedef SparseMatrixBase<Derived> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Derived)
+    CwiseBinaryOpImpl()
+    {
+      EIGEN_STATIC_ASSERT((
+                (!internal::is_same<typename internal::traits<Lhs>::StorageKind,
+                                    typename internal::traits<Rhs>::StorageKind>::value)
+            ||  ((internal::evaluator<Lhs>::Flags&RowMajorBit) == (internal::evaluator<Rhs>::Flags&RowMajorBit))),
+            THE_STORAGE_ORDER_OF_BOTH_SIDES_MUST_MATCH);
+    }
+};
+
+namespace internal {
+
+  
+// Generic "sparse OP sparse"
+template<typename XprType> struct binary_sparse_evaluator;
+
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IteratorBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+protected:
+  typedef typename evaluator<Lhs>::InnerIterator  LhsIterator;
+  typedef typename evaluator<Rhs>::InnerIterator  RhsIterator;
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+public:
+
+  class InnerIterator
+  {
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor)
+    {
+      this->operator++();
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      if (m_lhsIter && m_rhsIter && (m_lhsIter.index() == m_rhsIter.index()))
+      {
+        m_id = m_lhsIter.index();
+        m_value = m_functor(m_lhsIter.value(), m_rhsIter.value());
+        ++m_lhsIter;
+        ++m_rhsIter;
+      }
+      else if (m_lhsIter && (!m_rhsIter || (m_lhsIter.index() < m_rhsIter.index())))
+      {
+        m_id = m_lhsIter.index();
+        m_value = m_functor(m_lhsIter.value(), Scalar(0));
+        ++m_lhsIter;
+      }
+      else if (m_rhsIter && (!m_lhsIter || (m_lhsIter.index() > m_rhsIter.index())))
+      {
+        m_id = m_rhsIter.index();
+        m_value = m_functor(Scalar(0), m_rhsIter.value());
+        ++m_rhsIter;
+      }
+      else
+      {
+        m_value = Scalar(0); // this is to avoid a compilation warning
+        m_id = -1;
+      }
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return m_value; }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return Lhs::IsRowMajor ? m_lhsIter.row() : index(); }
+    EIGEN_STRONG_INLINE Index col() const { return Lhs::IsRowMajor ? index() : m_lhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_id>=0; }
+
+  protected:
+    LhsIterator m_lhsIter;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+    Scalar m_value;
+    StorageIndex m_id;
+  };
+  
+  
+  enum {
+    CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluator<Rhs>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+  
+  explicit binary_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_lhsImpl.nonZerosEstimate() + m_rhsImpl.nonZerosEstimate();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<Lhs> m_lhsImpl;
+  evaluator<Rhs> m_rhsImpl;
+};
+
+// dense op sparse
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IteratorBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+protected:
+  typedef typename evaluator<Rhs>::InnerIterator  RhsIterator;
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(Rhs::Flags)&RowMajorBit)==RowMajorBit };
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
+      : m_lhsEval(aEval.m_lhsImpl), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor), m_value(0), m_id(-1), m_innerSize(aEval.m_expr.rhs().innerSize())
+    {
+      this->operator++();
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_id;
+      if(m_id<m_innerSize)
+      {
+        Scalar lhsVal = m_lhsEval.coeff(IsRowMajor?m_rhsIter.outer():m_id,
+                                        IsRowMajor?m_id:m_rhsIter.outer());
+        if(m_rhsIter && m_rhsIter.index()==m_id)
+        {
+          m_value = m_functor(lhsVal, m_rhsIter.value());
+          ++m_rhsIter;
+        }
+        else
+          m_value = m_functor(lhsVal, Scalar(0));
+      }
+
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const { eigen_internal_assert(m_id<m_innerSize); return m_value; }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
+    EIGEN_STRONG_INLINE Index outer() const { return m_rhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return IsRowMajor ? m_rhsIter.outer() : m_id; }
+    EIGEN_STRONG_INLINE Index col() const { return IsRowMajor ? m_id : m_rhsIter.outer(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_id<m_innerSize; }
+
+  protected:
+    const evaluator<Lhs> &m_lhsEval;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+    Scalar m_value;
+    StorageIndex m_id;
+    StorageIndex m_innerSize;
+  };
+
+
+  enum {
+    CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluator<Rhs>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+
+  explicit binary_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()),
+      m_rhsImpl(xpr.rhs()),
+      m_expr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  inline Index nonZerosEstimate() const {
+    return m_expr.size();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<Lhs> m_lhsImpl;
+  evaluator<Rhs> m_rhsImpl;
+  const XprType &m_expr;
+};
+
+// sparse op dense
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IndexBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+protected:
+  typedef typename evaluator<Lhs>::InnerIterator  LhsIterator;
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(Lhs::Flags)&RowMajorBit)==RowMajorBit };
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsEval(aEval.m_rhsImpl), m_functor(aEval.m_functor), m_value(0), m_id(-1), m_innerSize(aEval.m_expr.lhs().innerSize())
+    {
+      this->operator++();
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_id;
+      if(m_id<m_innerSize)
+      {
+        Scalar rhsVal = m_rhsEval.coeff(IsRowMajor?m_lhsIter.outer():m_id,
+                                        IsRowMajor?m_id:m_lhsIter.outer());
+        if(m_lhsIter && m_lhsIter.index()==m_id)
+        {
+          m_value = m_functor(m_lhsIter.value(), rhsVal);
+          ++m_lhsIter;
+        }
+        else
+          m_value = m_functor(Scalar(0),rhsVal);
+      }
+
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const { eigen_internal_assert(m_id<m_innerSize); return m_value; }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return IsRowMajor ? m_lhsIter.outer() : m_id; }
+    EIGEN_STRONG_INLINE Index col() const { return IsRowMajor ? m_id : m_lhsIter.outer(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_id<m_innerSize; }
+
+  protected:
+    LhsIterator m_lhsIter;
+    const evaluator<Rhs> &m_rhsEval;
+    const BinaryOp& m_functor;
+    Scalar m_value;
+    StorageIndex m_id;
+    StorageIndex m_innerSize;
+  };
+
+
+  enum {
+    CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluator<Rhs>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+
+  explicit binary_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()),
+      m_rhsImpl(xpr.rhs()),
+      m_expr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  inline Index nonZerosEstimate() const {
+    return m_expr.size();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<Lhs> m_lhsImpl;
+  evaluator<Rhs> m_rhsImpl;
+  const XprType &m_expr;
+};
+
+template<typename T,
+         typename LhsKind   = typename evaluator_traits<typename T::Lhs>::Kind,
+         typename RhsKind   = typename evaluator_traits<typename T::Rhs>::Kind,
+         typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
+         typename RhsScalar = typename traits<typename T::Rhs>::Scalar> struct sparse_conjunction_evaluator;
+
+// "sparse .* sparse"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IteratorBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "dense .* sparse"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IndexBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "sparse .* dense"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IteratorBased, IndexBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// "sparse ./ dense"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_quotient_op<T1,T2>, Lhs, Rhs>, IteratorBased, IndexBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_quotient_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_quotient_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// "sparse && sparse"
+template<typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IteratorBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "dense && sparse"
+template<typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IndexBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "sparse && dense"
+template<typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IteratorBased, IndexBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// "sparse ^ sparse"
+template<typename XprType>
+struct sparse_conjunction_evaluator<XprType, IteratorBased, IteratorBased>
+  : evaluator_base<XprType>
+{
+protected:
+  typedef typename XprType::Functor BinaryOp;
+  typedef typename XprType::Lhs LhsArg;
+  typedef typename XprType::Rhs RhsArg;
+  typedef typename evaluator<LhsArg>::InnerIterator  LhsIterator;
+  typedef typename evaluator<RhsArg>::InnerIterator  RhsIterator;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename traits<XprType>::Scalar Scalar;
+public:
+
+  class InnerIterator
+  {
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor)
+    {
+      while (m_lhsIter && m_rhsIter && (m_lhsIter.index() != m_rhsIter.index()))
+      {
+        if (m_lhsIter.index() < m_rhsIter.index())
+          ++m_lhsIter;
+        else
+          ++m_rhsIter;
+      }
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_lhsIter;
+      ++m_rhsIter;
+      while (m_lhsIter && m_rhsIter && (m_lhsIter.index() != m_rhsIter.index()))
+      {
+        if (m_lhsIter.index() < m_rhsIter.index())
+          ++m_lhsIter;
+        else
+          ++m_rhsIter;
+      }
+      return *this;
+    }
+    
+    EIGEN_STRONG_INLINE Scalar value() const { return m_functor(m_lhsIter.value(), m_rhsIter.value()); }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_lhsIter.index(); }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return m_lhsIter.row(); }
+    EIGEN_STRONG_INLINE Index col() const { return m_lhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return (m_lhsIter && m_rhsIter); }
+
+  protected:
+    LhsIterator m_lhsIter;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+  };
+  
+  
+  enum {
+    CoeffReadCost = int(evaluator<LhsArg>::CoeffReadCost) + int(evaluator<RhsArg>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+  
+  explicit sparse_conjunction_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return (std::min)(m_lhsImpl.nonZerosEstimate(), m_rhsImpl.nonZerosEstimate());
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<LhsArg> m_lhsImpl;
+  evaluator<RhsArg> m_rhsImpl;
+};
+
+// "dense ^ sparse"
+template<typename XprType>
+struct sparse_conjunction_evaluator<XprType, IndexBased, IteratorBased>
+  : evaluator_base<XprType>
+{
+protected:
+  typedef typename XprType::Functor BinaryOp;
+  typedef typename XprType::Lhs LhsArg;
+  typedef typename XprType::Rhs RhsArg;
+  typedef evaluator<LhsArg> LhsEvaluator;
+  typedef typename evaluator<RhsArg>::InnerIterator  RhsIterator;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename traits<XprType>::Scalar Scalar;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(RhsArg::Flags)&RowMajorBit)==RowMajorBit };
+
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
+      : m_lhsEval(aEval.m_lhsImpl), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor), m_outer(outer)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_rhsIter;
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const
+    { return m_functor(m_lhsEval.coeff(IsRowMajor?m_outer:m_rhsIter.index(),IsRowMajor?m_rhsIter.index():m_outer), m_rhsIter.value()); }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_rhsIter.index(); }
+    EIGEN_STRONG_INLINE Index outer() const { return m_rhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return m_rhsIter.row(); }
+    EIGEN_STRONG_INLINE Index col() const { return m_rhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_rhsIter; }
+    
+  protected:
+    const LhsEvaluator &m_lhsEval;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+    const Index m_outer;
+  };
+  
+  
+  enum {
+    CoeffReadCost = int(evaluator<LhsArg>::CoeffReadCost) + int(evaluator<RhsArg>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+  
+  explicit sparse_conjunction_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_rhsImpl.nonZerosEstimate();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<LhsArg> m_lhsImpl;
+  evaluator<RhsArg> m_rhsImpl;
+};
+
+// "sparse ^ dense"
+template<typename XprType>
+struct sparse_conjunction_evaluator<XprType, IteratorBased, IndexBased>
+  : evaluator_base<XprType>
+{
+protected:
+  typedef typename XprType::Functor BinaryOp;
+  typedef typename XprType::Lhs LhsArg;
+  typedef typename XprType::Rhs RhsArg;
+  typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
+  typedef evaluator<RhsArg> RhsEvaluator;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename traits<XprType>::Scalar Scalar;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(LhsArg::Flags)&RowMajorBit)==RowMajorBit };
+
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsEval(aEval.m_rhsImpl), m_functor(aEval.m_functor), m_outer(outer)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_lhsIter;
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const
+    { return m_functor(m_lhsIter.value(),
+                       m_rhsEval.coeff(IsRowMajor?m_outer:m_lhsIter.index(),IsRowMajor?m_lhsIter.index():m_outer)); }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_lhsIter.index(); }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return m_lhsIter.row(); }
+    EIGEN_STRONG_INLINE Index col() const { return m_lhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_lhsIter; }
+    
+  protected:
+    LhsIterator m_lhsIter;
+    const evaluator<RhsArg> &m_rhsEval;
+    const BinaryOp& m_functor;
+    const Index m_outer;
+  };
+  
+  
+  enum {
+    CoeffReadCost = int(evaluator<LhsArg>::CoeffReadCost) + int(evaluator<RhsArg>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+  
+  explicit sparse_conjunction_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_lhsImpl.nonZerosEstimate();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<LhsArg> m_lhsImpl;
+  evaluator<RhsArg> m_rhsImpl;
+};
+
+}
+
+/***************************************************************************
+* Implementation of SparseMatrixBase and SparseCwise functions/operators
+***************************************************************************/
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator+=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator-=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_STRONG_INLINE Derived &
+SparseMatrixBase<Derived>::operator-=(const SparseMatrixBase<OtherDerived> &other)
+{
+  return derived() = derived() - other.derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_STRONG_INLINE Derived &
+SparseMatrixBase<Derived>::operator+=(const SparseMatrixBase<OtherDerived>& other)
+{
+  return derived() = derived() + other.derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator+=(const DiagonalBase<OtherDerived>& other)
+{
+  call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator-=(const DiagonalBase<OtherDerived>& other)
+{
+  call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+    
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_STRONG_INLINE const typename SparseMatrixBase<Derived>::template CwiseProductDenseReturnType<OtherDerived>::Type
+SparseMatrixBase<Derived>::cwiseProduct(const MatrixBase<OtherDerived> &other) const
+{
+  return typename CwiseProductDenseReturnType<OtherDerived>::Type(derived(), other.derived());
+}
+
+template<typename DenseDerived, typename SparseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>
+operator+(const MatrixBase<DenseDerived> &a, const SparseMatrixBase<SparseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
+}
+
+template<typename SparseDerived, typename DenseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>
+operator+(const SparseMatrixBase<SparseDerived> &a, const MatrixBase<DenseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
+}
+
+template<typename DenseDerived, typename SparseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>
+operator-(const MatrixBase<DenseDerived> &a, const SparseMatrixBase<SparseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
+}
+
+template<typename SparseDerived, typename DenseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>
+operator-(const SparseMatrixBase<SparseDerived> &a, const MatrixBase<DenseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_CWISE_BINARY_OP_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseCwiseUnaryOp.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseCwiseUnaryOp.h
new file mode 100644
index 00000000..32dac0f7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseCwiseUnaryOp.h
@@ -0,0 +1,150 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_CWISE_UNARY_OP_H
+#define EIGEN_SPARSE_CWISE_UNARY_OP_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<typename UnaryOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>
+  : public evaluator_base<CwiseUnaryOp<UnaryOp,ArgType> >
+{
+  public:
+    typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;
+
+    class InnerIterator;
+    
+    enum {
+      CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<UnaryOp>::Cost),
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression())
+    {
+      EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
+      EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+    }
+    
+    inline Index nonZerosEstimate() const {
+      return m_argImpl.nonZerosEstimate();
+    }
+
+  protected:
+    typedef typename evaluator<ArgType>::InnerIterator        EvalIterator;
+    
+    const UnaryOp m_functor;
+    evaluator<ArgType> m_argImpl;
+};
+
+template<typename UnaryOp, typename ArgType>
+class unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>::InnerIterator
+    : public unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>::EvalIterator
+{
+  protected:
+    typedef typename XprType::Scalar Scalar;
+    typedef typename unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>::EvalIterator Base;
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
+      : Base(unaryOp.m_argImpl,outer), m_functor(unaryOp.m_functor)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    { Base::operator++(); return *this; }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return m_functor(Base::value()); }
+
+  protected:
+    const UnaryOp m_functor;
+  private:
+    Scalar& valueRef();
+};
+
+template<typename ViewOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>
+  : public evaluator_base<CwiseUnaryView<ViewOp,ArgType> >
+{
+  public:
+    typedef CwiseUnaryView<ViewOp, ArgType> XprType;
+
+    class InnerIterator;
+    
+    enum {
+      CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<ViewOp>::Cost),
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression())
+    {
+      EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<ViewOp>::Cost);
+      EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+    }
+
+  protected:
+    typedef typename evaluator<ArgType>::InnerIterator        EvalIterator;
+    
+    const ViewOp m_functor;
+    evaluator<ArgType> m_argImpl;
+};
+
+template<typename ViewOp, typename ArgType>
+class unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>::InnerIterator
+    : public unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>::EvalIterator
+{
+  protected:
+    typedef typename XprType::Scalar Scalar;
+    typedef typename unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>::EvalIterator Base;
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
+      : Base(unaryOp.m_argImpl,outer), m_functor(unaryOp.m_functor)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    { Base::operator++(); return *this; }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return m_functor(Base::value()); }
+    EIGEN_STRONG_INLINE Scalar& valueRef() { return m_functor(Base::valueRef()); }
+
+  protected:
+    const ViewOp m_functor;
+};
+
+} // end namespace internal
+
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+SparseMatrixBase<Derived>::operator*=(const Scalar& other)
+{
+  typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
+  internal::evaluator<Derived> thisEval(derived());
+  for (Index j=0; j<outerSize(); ++j)
+    for (EvalIterator i(thisEval,j); i; ++i)
+      i.valueRef() *= other;
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+SparseMatrixBase<Derived>::operator/=(const Scalar& other)
+{
+  typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
+  internal::evaluator<Derived> thisEval(derived());
+  for (Index j=0; j<outerSize(); ++j)
+    for (EvalIterator i(thisEval,j); i; ++i)
+      i.valueRef() /= other;
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_CWISE_UNARY_OP_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseDenseProduct.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseDenseProduct.h
new file mode 100644
index 00000000..f005a18a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseDenseProduct.h
@@ -0,0 +1,342 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEDENSEPRODUCT_H
+#define EIGEN_SPARSEDENSEPRODUCT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template <> struct product_promote_storage_type<Sparse,Dense, OuterProduct> { typedef Sparse ret; };
+template <> struct product_promote_storage_type<Dense,Sparse, OuterProduct> { typedef Sparse ret; };
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType,
+         typename AlphaType,
+         int LhsStorageOrder = ((SparseLhsType::Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor,
+         bool ColPerCol = ((DenseRhsType::Flags&RowMajorBit)==0) || DenseRhsType::ColsAtCompileTime==1>
+struct sparse_time_dense_product_impl;
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, typename DenseResType::Scalar, RowMajor, true>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef typename evaluator<Lhs>::InnerIterator LhsInnerIterator;
+  typedef evaluator<Lhs> LhsEval;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
+  {
+    LhsEval lhsEval(lhs);
+    
+    Index n = lhs.outerSize();
+#ifdef EIGEN_HAS_OPENMP
+    Eigen::initParallel();
+    Index threads = Eigen::nbThreads();
+#endif
+    
+    for(Index c=0; c<rhs.cols(); ++c)
+    {
+#ifdef EIGEN_HAS_OPENMP
+      // This 20000 threshold has been found experimentally on 2D and 3D Poisson problems.
+      // It basically represents the minimal amount of work to be done to be worth it.
+      if(threads>1 && lhsEval.nonZerosEstimate() > 20000)
+      {
+        #pragma omp parallel for schedule(dynamic,(n+threads*4-1)/(threads*4)) num_threads(threads)
+        for(Index i=0; i<n; ++i)
+          processRow(lhsEval,rhs,res,alpha,i,c);
+      }
+      else
+#endif
+      {
+        for(Index i=0; i<n; ++i)
+          processRow(lhsEval,rhs,res,alpha,i,c);
+      }
+    }
+  }
+  
+  static void processRow(const LhsEval& lhsEval, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha, Index i, Index col)
+  {
+    typename Res::Scalar tmp(0);
+    for(LhsInnerIterator it(lhsEval,i); it ;++it)
+      tmp += it.value() * rhs.coeff(it.index(),col);
+    res.coeffRef(i,col) += alpha * tmp;
+  }
+  
+};
+
+// FIXME: what is the purpose of the following specialization? Is it for the BlockedSparse format?
+// -> let's disable it for now as it is conflicting with generic scalar*matrix and matrix*scalar operators
+// template<typename T1, typename T2/*, int _Options, typename _StrideType*/>
+// struct ScalarBinaryOpTraits<T1, Ref<T2/*, _Options, _StrideType*/> >
+// {
+//   enum {
+//     Defined = 1
+//   };
+//   typedef typename CwiseUnaryOp<scalar_multiple2_op<T1, typename T2::Scalar>, T2>::PlainObject ReturnType;
+// };
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, AlphaType, ColMajor, true>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename LhsEval::InnerIterator LhsInnerIterator;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index c=0; c<rhs.cols(); ++c)
+    {
+      for(Index j=0; j<lhs.outerSize(); ++j)
+      {
+//        typename Res::Scalar rhs_j = alpha * rhs.coeff(j,c);
+        typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha * rhs.coeff(j,c));
+        for(LhsInnerIterator it(lhsEval,j); it ;++it)
+          res.coeffRef(it.index(),c) += it.value() * rhs_j;
+      }
+    }
+  }
+};
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, typename DenseResType::Scalar, RowMajor, false>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename LhsEval::InnerIterator LhsInnerIterator;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
+  {
+    Index n = lhs.rows();
+    LhsEval lhsEval(lhs);
+
+#ifdef EIGEN_HAS_OPENMP
+    Eigen::initParallel();
+    Index threads = Eigen::nbThreads();
+    // This 20000 threshold has been found experimentally on 2D and 3D Poisson problems.
+    // It basically represents the minimal amount of work to be done to be worth it.
+    if(threads>1 && lhsEval.nonZerosEstimate()*rhs.cols() > 20000)
+    {
+      #pragma omp parallel for schedule(dynamic,(n+threads*4-1)/(threads*4)) num_threads(threads)
+      for(Index i=0; i<n; ++i)
+        processRow(lhsEval,rhs,res,alpha,i);
+    }
+    else
+#endif
+    {
+      for(Index i=0; i<n; ++i)
+        processRow(lhsEval, rhs, res, alpha, i);
+    }
+  }
+
+  static void processRow(const LhsEval& lhsEval, const DenseRhsType& rhs, Res& res, const typename Res::Scalar& alpha, Index i)
+  {
+    typename Res::RowXpr res_i(res.row(i));
+    for(LhsInnerIterator it(lhsEval,i); it ;++it)
+      res_i += (alpha*it.value()) * rhs.row(it.index());
+  }
+};
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, typename DenseResType::Scalar, ColMajor, false>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef typename evaluator<Lhs>::InnerIterator LhsInnerIterator;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
+  {
+    evaluator<Lhs> lhsEval(lhs);
+    for(Index j=0; j<lhs.outerSize(); ++j)
+    {
+      typename Rhs::ConstRowXpr rhs_j(rhs.row(j));
+      for(LhsInnerIterator it(lhsEval,j); it ;++it)
+        res.row(it.index()) += (alpha*it.value()) * rhs_j;
+    }
+  }
+};
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType,typename AlphaType>
+inline void sparse_time_dense_product(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
+{
+  sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, AlphaType>::run(lhs, rhs, res, alpha);
+}
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseShape, DenseShape, ProductType>
+ : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,SparseShape,DenseShape,ProductType> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    typedef typename nested_eval<Lhs,((Rhs::Flags&RowMajorBit)==0) ? 1 : Rhs::ColsAtCompileTime>::type LhsNested;
+    typedef typename nested_eval<Rhs,((Lhs::Flags&RowMajorBit)==0) ? 1 : Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    internal::sparse_time_dense_product(lhsNested, rhsNested, dst, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseTriangularShape, DenseShape, ProductType>
+  : generic_product_impl<Lhs, Rhs, SparseShape, DenseShape, ProductType>
+{};
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, DenseShape, SparseShape, ProductType>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,SparseShape,ProductType> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dst>
+  static void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    typedef typename nested_eval<Lhs,((Rhs::Flags&RowMajorBit)==0) ? Dynamic : 1>::type LhsNested;
+    typedef typename nested_eval<Rhs,((Lhs::Flags&RowMajorBit)==RowMajorBit) ? 1 : Lhs::RowsAtCompileTime>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    
+    // transpose everything
+    Transpose<Dst> dstT(dst);
+    internal::sparse_time_dense_product(rhsNested.transpose(), lhsNested.transpose(), dstT, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, DenseShape, SparseTriangularShape, ProductType>
+  : generic_product_impl<Lhs, Rhs, DenseShape, SparseShape, ProductType>
+{};
+
+template<typename LhsT, typename RhsT, bool NeedToTranspose>
+struct sparse_dense_outer_product_evaluator
+{
+protected:
+  typedef typename conditional<NeedToTranspose,RhsT,LhsT>::type Lhs1;
+  typedef typename conditional<NeedToTranspose,LhsT,RhsT>::type ActualRhs;
+  typedef Product<LhsT,RhsT,DefaultProduct> ProdXprType;
+  
+  // if the actual left-hand side is a dense vector,
+  // then build a sparse-view so that we can seamlessly iterate over it.
+  typedef typename conditional<is_same<typename internal::traits<Lhs1>::StorageKind,Sparse>::value,
+            Lhs1, SparseView<Lhs1> >::type ActualLhs;
+  typedef typename conditional<is_same<typename internal::traits<Lhs1>::StorageKind,Sparse>::value,
+            Lhs1 const&, SparseView<Lhs1> >::type LhsArg;
+            
+  typedef evaluator<ActualLhs> LhsEval;
+  typedef evaluator<ActualRhs> RhsEval;
+  typedef typename evaluator<ActualLhs>::InnerIterator LhsIterator;
+  typedef typename ProdXprType::Scalar Scalar;
+  
+public:
+  enum {
+    Flags = NeedToTranspose ? RowMajorBit : 0,
+    CoeffReadCost = HugeCost
+  };
+  
+  class InnerIterator : public LhsIterator
+  {
+  public:
+    InnerIterator(const sparse_dense_outer_product_evaluator &xprEval, Index outer)
+      : LhsIterator(xprEval.m_lhsXprImpl, 0),
+        m_outer(outer),
+        m_empty(false),
+        m_factor(get(xprEval.m_rhsXprImpl, outer, typename internal::traits<ActualRhs>::StorageKind() ))
+    {}
+    
+    EIGEN_STRONG_INLINE Index outer() const { return m_outer; }
+    EIGEN_STRONG_INLINE Index row()   const { return NeedToTranspose ? m_outer : LhsIterator::index(); }
+    EIGEN_STRONG_INLINE Index col()   const { return NeedToTranspose ? LhsIterator::index() : m_outer; }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return LhsIterator::value() * m_factor; }
+    EIGEN_STRONG_INLINE operator bool() const { return LhsIterator::operator bool() && (!m_empty); }
+    
+  protected:
+    Scalar get(const RhsEval &rhs, Index outer, Dense = Dense()) const
+    {
+      return rhs.coeff(outer);
+    }
+    
+    Scalar get(const RhsEval &rhs, Index outer, Sparse = Sparse())
+    {
+      typename RhsEval::InnerIterator it(rhs, outer);
+      if (it && it.index()==0 && it.value()!=Scalar(0))
+        return it.value();
+      m_empty = true;
+      return Scalar(0);
+    }
+    
+    Index m_outer;
+    bool m_empty;
+    Scalar m_factor;
+  };
+  
+  sparse_dense_outer_product_evaluator(const Lhs1 &lhs, const ActualRhs &rhs)
+     : m_lhs(lhs), m_lhsXprImpl(m_lhs), m_rhsXprImpl(rhs)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  // transpose case
+  sparse_dense_outer_product_evaluator(const ActualRhs &rhs, const Lhs1 &lhs)
+     : m_lhs(lhs), m_lhsXprImpl(m_lhs), m_rhsXprImpl(rhs)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+    
+protected:
+  const LhsArg m_lhs;
+  evaluator<ActualLhs> m_lhsXprImpl;
+  evaluator<ActualRhs> m_rhsXprImpl;
+};
+
+// sparse * dense outer product
+template<typename Lhs, typename Rhs>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, OuterProduct, SparseShape, DenseShape>
+  : sparse_dense_outer_product_evaluator<Lhs,Rhs, Lhs::IsRowMajor>
+{
+  typedef sparse_dense_outer_product_evaluator<Lhs,Rhs, Lhs::IsRowMajor> Base;
+  
+  typedef Product<Lhs, Rhs> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+
+  explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.lhs(), xpr.rhs())
+  {}
+  
+};
+
+template<typename Lhs, typename Rhs>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, OuterProduct, DenseShape, SparseShape>
+  : sparse_dense_outer_product_evaluator<Lhs,Rhs, Rhs::IsRowMajor>
+{
+  typedef sparse_dense_outer_product_evaluator<Lhs,Rhs, Rhs::IsRowMajor> Base;
+  
+  typedef Product<Lhs, Rhs> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+
+  explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.lhs(), xpr.rhs())
+  {}
+  
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEDENSEPRODUCT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseDiagonalProduct.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseDiagonalProduct.h
new file mode 100644
index 00000000..941c03be
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseDiagonalProduct.h
@@ -0,0 +1,138 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_DIAGONAL_PRODUCT_H
+#define EIGEN_SPARSE_DIAGONAL_PRODUCT_H
+
+namespace Eigen { 
+
+// The product of a diagonal matrix with a sparse matrix can be easily
+// implemented using expression template.
+// We have two consider very different cases:
+// 1 - diag * row-major sparse
+//     => each inner vector <=> scalar * sparse vector product
+//     => so we can reuse CwiseUnaryOp::InnerIterator
+// 2 - diag * col-major sparse
+//     => each inner vector <=> densevector * sparse vector cwise product
+//     => again, we can reuse specialization of CwiseBinaryOp::InnerIterator
+//        for that particular case
+// The two other cases are symmetric.
+
+namespace internal {
+
+enum {
+  SDP_AsScalarProduct,
+  SDP_AsCwiseProduct
+};
+  
+template<typename SparseXprType, typename DiagonalCoeffType, int SDP_Tag>
+struct sparse_diagonal_product_evaluator;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, DiagonalShape, SparseShape>
+  : public sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType, Rhs::Flags&RowMajorBit?SDP_AsScalarProduct:SDP_AsCwiseProduct>
+{
+  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  enum { CoeffReadCost = HugeCost, Flags = Rhs::Flags&RowMajorBit, Alignment = 0 }; // FIXME CoeffReadCost & Flags
+  
+  typedef sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType, Rhs::Flags&RowMajorBit?SDP_AsScalarProduct:SDP_AsCwiseProduct> Base;
+  explicit product_evaluator(const XprType& xpr) : Base(xpr.rhs(), xpr.lhs().diagonal()) {}
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, SparseShape, DiagonalShape>
+  : public sparse_diagonal_product_evaluator<Lhs, Transpose<const typename Rhs::DiagonalVectorType>, Lhs::Flags&RowMajorBit?SDP_AsCwiseProduct:SDP_AsScalarProduct>
+{
+  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  enum { CoeffReadCost = HugeCost, Flags = Lhs::Flags&RowMajorBit, Alignment = 0 }; // FIXME CoeffReadCost & Flags
+  
+  typedef sparse_diagonal_product_evaluator<Lhs, Transpose<const typename Rhs::DiagonalVectorType>, Lhs::Flags&RowMajorBit?SDP_AsCwiseProduct:SDP_AsScalarProduct> Base;
+  explicit product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs().diagonal().transpose()) {}
+};
+
+template<typename SparseXprType, typename DiagonalCoeffType>
+struct sparse_diagonal_product_evaluator<SparseXprType, DiagonalCoeffType, SDP_AsScalarProduct>
+{
+protected:
+  typedef typename evaluator<SparseXprType>::InnerIterator SparseXprInnerIterator;
+  typedef typename SparseXprType::Scalar Scalar;
+  
+public:
+  class InnerIterator : public SparseXprInnerIterator
+  {
+  public:
+    InnerIterator(const sparse_diagonal_product_evaluator &xprEval, Index outer)
+      : SparseXprInnerIterator(xprEval.m_sparseXprImpl, outer),
+        m_coeff(xprEval.m_diagCoeffImpl.coeff(outer))
+    {}
+    
+    EIGEN_STRONG_INLINE Scalar value() const { return m_coeff * SparseXprInnerIterator::value(); }
+  protected:
+    typename DiagonalCoeffType::Scalar m_coeff;
+  };
+  
+  sparse_diagonal_product_evaluator(const SparseXprType &sparseXpr, const DiagonalCoeffType &diagCoeff)
+    : m_sparseXprImpl(sparseXpr), m_diagCoeffImpl(diagCoeff)
+  {}
+
+  Index nonZerosEstimate() const { return m_sparseXprImpl.nonZerosEstimate(); }
+    
+protected:
+  evaluator<SparseXprType> m_sparseXprImpl;
+  evaluator<DiagonalCoeffType> m_diagCoeffImpl;
+};
+
+
+template<typename SparseXprType, typename DiagCoeffType>
+struct sparse_diagonal_product_evaluator<SparseXprType, DiagCoeffType, SDP_AsCwiseProduct>
+{
+  typedef typename SparseXprType::Scalar Scalar;
+  typedef typename SparseXprType::StorageIndex StorageIndex;
+  
+  typedef typename nested_eval<DiagCoeffType,SparseXprType::IsRowMajor ? SparseXprType::RowsAtCompileTime
+                                                                       : SparseXprType::ColsAtCompileTime>::type DiagCoeffNested;
+  
+  class InnerIterator
+  {
+    typedef typename evaluator<SparseXprType>::InnerIterator SparseXprIter;
+  public:
+    InnerIterator(const sparse_diagonal_product_evaluator &xprEval, Index outer)
+      : m_sparseIter(xprEval.m_sparseXprEval, outer), m_diagCoeffNested(xprEval.m_diagCoeffNested)
+    {}
+    
+    inline Scalar value() const { return m_sparseIter.value() * m_diagCoeffNested.coeff(index()); }
+    inline StorageIndex index() const  { return m_sparseIter.index(); }
+    inline Index outer() const  { return m_sparseIter.outer(); }
+    inline Index col() const    { return SparseXprType::IsRowMajor ? m_sparseIter.index() : m_sparseIter.outer(); }
+    inline Index row() const    { return SparseXprType::IsRowMajor ? m_sparseIter.outer() : m_sparseIter.index(); }
+    
+    EIGEN_STRONG_INLINE InnerIterator& operator++() { ++m_sparseIter; return *this; }
+    inline operator bool() const  { return m_sparseIter; }
+    
+  protected:
+    SparseXprIter m_sparseIter;
+    DiagCoeffNested m_diagCoeffNested;
+  };
+  
+  sparse_diagonal_product_evaluator(const SparseXprType &sparseXpr, const DiagCoeffType &diagCoeff)
+    : m_sparseXprEval(sparseXpr), m_diagCoeffNested(diagCoeff)
+  {}
+
+  Index nonZerosEstimate() const { return m_sparseXprEval.nonZerosEstimate(); }
+    
+protected:
+  evaluator<SparseXprType> m_sparseXprEval;
+  DiagCoeffNested m_diagCoeffNested;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_DIAGONAL_PRODUCT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseDot.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseDot.h
new file mode 100644
index 00000000..38bc4aa9
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseDot.h
@@ -0,0 +1,98 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_DOT_H
+#define EIGEN_SPARSE_DOT_H
+
+namespace Eigen { 
+
+template<typename Derived>
+template<typename OtherDerived>
+typename internal::traits<Derived>::Scalar
+SparseMatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  eigen_assert(size() == other.size());
+  eigen_assert(other.size()>0 && "you are using a non initialized vector");
+
+  internal::evaluator<Derived> thisEval(derived());
+  typename internal::evaluator<Derived>::InnerIterator i(thisEval, 0);
+  Scalar res(0);
+  while (i)
+  {
+    res += numext::conj(i.value()) * other.coeff(i.index());
+    ++i;
+  }
+  return res;
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+typename internal::traits<Derived>::Scalar
+SparseMatrixBase<Derived>::dot(const SparseMatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  eigen_assert(size() == other.size());
+
+  internal::evaluator<Derived> thisEval(derived());
+  typename internal::evaluator<Derived>::InnerIterator i(thisEval, 0);
+  
+  internal::evaluator<OtherDerived>  otherEval(other.derived());
+  typename internal::evaluator<OtherDerived>::InnerIterator j(otherEval, 0);
+
+  Scalar res(0);
+  while (i && j)
+  {
+    if (i.index()==j.index())
+    {
+      res += numext::conj(i.value()) * j.value();
+      ++i; ++j;
+    }
+    else if (i.index()<j.index())
+      ++i;
+    else
+      ++j;
+  }
+  return res;
+}
+
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+SparseMatrixBase<Derived>::squaredNorm() const
+{
+  return numext::real((*this).cwiseAbs2().sum());
+}
+
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+SparseMatrixBase<Derived>::norm() const
+{
+  using std::sqrt;
+  return sqrt(squaredNorm());
+}
+
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+SparseMatrixBase<Derived>::blueNorm() const
+{
+  return internal::blueNorm_impl(*this);
+}
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_DOT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseFuzzy.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseFuzzy.h
new file mode 100644
index 00000000..7d47eb94
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseFuzzy.h
@@ -0,0 +1,29 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_FUZZY_H
+#define EIGEN_SPARSE_FUZZY_H
+
+namespace Eigen {
+  
+template<typename Derived>
+template<typename OtherDerived>
+bool SparseMatrixBase<Derived>::isApprox(const SparseMatrixBase<OtherDerived>& other, const RealScalar &prec) const
+{
+  const typename internal::nested_eval<Derived,2,PlainObject>::type actualA(derived());
+  typename internal::conditional<bool(IsRowMajor)==bool(OtherDerived::IsRowMajor),
+    const typename internal::nested_eval<OtherDerived,2,PlainObject>::type,
+    const PlainObject>::type actualB(other.derived());
+
+  return (actualA - actualB).squaredNorm() <= prec * prec * numext::mini(actualA.squaredNorm(), actualB.squaredNorm());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_FUZZY_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseMap.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseMap.h
new file mode 100644
index 00000000..f99be337
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseMap.h
@@ -0,0 +1,305 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_MAP_H
+#define EIGEN_SPARSE_MAP_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct traits<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  typedef traits<PlainObjectType> TraitsBase;
+  enum {
+    Flags = TraitsBase::Flags & (~NestByRefBit)
+  };
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct traits<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  typedef traits<PlainObjectType> TraitsBase;
+  enum {
+    Flags = TraitsBase::Flags & (~ (NestByRefBit | LvalueBit))
+  };
+};
+
+} // end namespace internal
+
+template<typename Derived,
+         int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
+> class SparseMapBase;
+
+/** \ingroup SparseCore_Module
+  * class SparseMapBase
+  * \brief Common base class for Map and Ref instance of sparse matrix and vector.
+  */
+template<typename Derived>
+class SparseMapBase<Derived,ReadOnlyAccessors>
+  : public SparseCompressedBase<Derived>
+{
+  public:
+    typedef SparseCompressedBase<Derived> Base;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    enum { IsRowMajor = Base::IsRowMajor };
+    using Base::operator=;
+  protected:
+    
+    typedef typename internal::conditional<
+                         bool(internal::is_lvalue<Derived>::value),
+                         Scalar *, const Scalar *>::type ScalarPointer;
+    typedef typename internal::conditional<
+                         bool(internal::is_lvalue<Derived>::value),
+                         StorageIndex *, const StorageIndex *>::type IndexPointer;
+
+    Index   m_outerSize;
+    Index   m_innerSize;
+    Array<StorageIndex,2,1>  m_zero_nnz;
+    IndexPointer  m_outerIndex;
+    IndexPointer  m_innerIndices;
+    ScalarPointer m_values;
+    IndexPointer  m_innerNonZeros;
+
+  public:
+
+    /** \copydoc SparseMatrixBase::rows() */
+    inline Index rows() const { return IsRowMajor ? m_outerSize : m_innerSize; }
+    /** \copydoc SparseMatrixBase::cols() */
+    inline Index cols() const { return IsRowMajor ? m_innerSize : m_outerSize; }
+    /** \copydoc SparseMatrixBase::innerSize() */
+    inline Index innerSize() const { return m_innerSize; }
+    /** \copydoc SparseMatrixBase::outerSize() */
+    inline Index outerSize() const { return m_outerSize; }
+    /** \copydoc SparseCompressedBase::nonZeros */
+    inline Index nonZeros() const { return m_zero_nnz[1]; }
+    
+    /** \copydoc SparseCompressedBase::isCompressed */
+    bool isCompressed() const { return m_innerNonZeros==0; }
+
+    //----------------------------------------
+    // direct access interface
+    /** \copydoc SparseMatrix::valuePtr */
+    inline const Scalar* valuePtr() const { return m_values; }
+    /** \copydoc SparseMatrix::innerIndexPtr */
+    inline const StorageIndex* innerIndexPtr() const { return m_innerIndices; }
+    /** \copydoc SparseMatrix::outerIndexPtr */
+    inline const StorageIndex* outerIndexPtr() const { return m_outerIndex; }
+    /** \copydoc SparseMatrix::innerNonZeroPtr */
+    inline const StorageIndex* innerNonZeroPtr() const { return m_innerNonZeros; }
+    //----------------------------------------
+
+    /** \copydoc SparseMatrix::coeff */
+    inline Scalar coeff(Index row, Index col) const
+    {
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      Index start = m_outerIndex[outer];
+      Index end = isCompressed() ? m_outerIndex[outer+1] : start + m_innerNonZeros[outer];
+      if (start==end)
+        return Scalar(0);
+      else if (end>0 && inner==m_innerIndices[end-1])
+        return m_values[end-1];
+      // ^^  optimization: let's first check if it is the last coefficient
+      // (very common in high level algorithms)
+
+      const StorageIndex* r = std::lower_bound(&m_innerIndices[start],&m_innerIndices[end-1],inner);
+      const Index id = r-&m_innerIndices[0];
+      return ((*r==inner) && (id<end)) ? m_values[id] : Scalar(0);
+    }
+
+    inline SparseMapBase(Index rows, Index cols, Index nnz, IndexPointer outerIndexPtr, IndexPointer innerIndexPtr,
+                              ScalarPointer valuePtr, IndexPointer innerNonZerosPtr = 0)
+      : m_outerSize(IsRowMajor?rows:cols), m_innerSize(IsRowMajor?cols:rows), m_zero_nnz(0,internal::convert_index<StorageIndex>(nnz)), m_outerIndex(outerIndexPtr),
+        m_innerIndices(innerIndexPtr), m_values(valuePtr), m_innerNonZeros(innerNonZerosPtr)
+    {}
+
+    // for vectors
+    inline SparseMapBase(Index size, Index nnz, IndexPointer innerIndexPtr, ScalarPointer valuePtr)
+      : m_outerSize(1), m_innerSize(size), m_zero_nnz(0,internal::convert_index<StorageIndex>(nnz)), m_outerIndex(m_zero_nnz.data()),
+        m_innerIndices(innerIndexPtr), m_values(valuePtr), m_innerNonZeros(0)
+    {}
+
+    /** Empty destructor */
+    inline ~SparseMapBase() {}
+
+  protected:
+    inline SparseMapBase() {}
+};
+
+/** \ingroup SparseCore_Module
+  * class SparseMapBase
+  * \brief Common base class for writable Map and Ref instance of sparse matrix and vector.
+  */
+template<typename Derived>
+class SparseMapBase<Derived,WriteAccessors>
+  : public SparseMapBase<Derived,ReadOnlyAccessors>
+{
+    typedef MapBase<Derived, ReadOnlyAccessors> ReadOnlyMapBase;
+    
+  public:
+    typedef SparseMapBase<Derived, ReadOnlyAccessors> Base;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    enum { IsRowMajor = Base::IsRowMajor };
+    
+    using Base::operator=;
+
+  public:
+    
+    //----------------------------------------
+    // direct access interface
+    using Base::valuePtr;
+    using Base::innerIndexPtr;
+    using Base::outerIndexPtr;
+    using Base::innerNonZeroPtr;
+    /** \copydoc SparseMatrix::valuePtr */
+    inline Scalar* valuePtr()              { return Base::m_values; }
+    /** \copydoc SparseMatrix::innerIndexPtr */
+    inline StorageIndex* innerIndexPtr()   { return Base::m_innerIndices; }
+    /** \copydoc SparseMatrix::outerIndexPtr */
+    inline StorageIndex* outerIndexPtr()   { return Base::m_outerIndex; }
+    /** \copydoc SparseMatrix::innerNonZeroPtr */
+    inline StorageIndex* innerNonZeroPtr() { return Base::m_innerNonZeros; }
+    //----------------------------------------
+
+    /** \copydoc SparseMatrix::coeffRef */
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      Index start = Base::m_outerIndex[outer];
+      Index end = Base::isCompressed() ? Base::m_outerIndex[outer+1] : start + Base::m_innerNonZeros[outer];
+      eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix");
+      eigen_assert(end>start && "coeffRef cannot be called on a zero coefficient");
+      StorageIndex* r = std::lower_bound(&Base::m_innerIndices[start],&Base::m_innerIndices[end],inner);
+      const Index id = r - &Base::m_innerIndices[0];
+      eigen_assert((*r==inner) && (id<end) && "coeffRef cannot be called on a zero coefficient");
+      return const_cast<Scalar*>(Base::m_values)[id];
+    }
+    
+    inline SparseMapBase(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr, StorageIndex* innerIndexPtr,
+                         Scalar* valuePtr, StorageIndex* innerNonZerosPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
+    {}
+
+    // for vectors
+    inline SparseMapBase(Index size, Index nnz, StorageIndex* innerIndexPtr, Scalar* valuePtr)
+      : Base(size, nnz, innerIndexPtr, valuePtr)
+    {}
+
+    /** Empty destructor */
+    inline ~SparseMapBase() {}
+
+  protected:
+    inline SparseMapBase() {}
+};
+
+/** \ingroup SparseCore_Module
+  *
+  * \brief Specialization of class Map for SparseMatrix-like storage.
+  *
+  * \tparam SparseMatrixType the equivalent sparse matrix type of the referenced data, it must be a template instance of class SparseMatrix.
+  *
+  * \sa class Map, class SparseMatrix, class Ref<SparseMatrixType,Options>
+  */
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public SparseMapBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+#else
+template<typename SparseMatrixType>
+class Map<SparseMatrixType>
+  : public SparseMapBase<Derived,WriteAccessors>
+#endif
+{
+  public:
+    typedef SparseMapBase<Map> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Map)
+    enum { IsRowMajor = Base::IsRowMajor };
+
+  public:
+
+    /** Constructs a read-write Map to a sparse matrix of size \a rows x \a cols, containing \a nnz non-zero coefficients,
+      * stored as a sparse format as defined by the pointers \a outerIndexPtr, \a innerIndexPtr, and \a valuePtr.
+      * If the optional parameter \a innerNonZerosPtr is the null pointer, then a standard compressed format is assumed.
+      *
+      * This constructor is available only if \c SparseMatrixType is non-const.
+      *
+      * More details on the expected storage schemes are given in the \ref TutorialSparse "manual pages".
+      */
+    inline Map(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr,
+               StorageIndex* innerIndexPtr, Scalar* valuePtr, StorageIndex* innerNonZerosPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
+    {}
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** Empty destructor */
+    inline ~Map() {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public SparseMapBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+{
+  public:
+    typedef SparseMapBase<Map> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Map)
+    enum { IsRowMajor = Base::IsRowMajor };
+
+  public:
+#endif
+    /** This is the const version of the above constructor.
+      *
+      * This constructor is available only if \c SparseMatrixType is const, e.g.:
+      * \code Map<const SparseMatrix<double> >  \endcode
+      */
+    inline Map(Index rows, Index cols, Index nnz, const StorageIndex* outerIndexPtr,
+               const StorageIndex* innerIndexPtr, const Scalar* valuePtr, const StorageIndex* innerNonZerosPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
+    {}
+
+    /** Empty destructor */
+    inline ~Map() {}
+};
+
+namespace internal {
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_MAP_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseMatrix.h
new file mode 100644
index 00000000..616b4a0c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseMatrix.h
@@ -0,0 +1,1518 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEMATRIX_H
+#define EIGEN_SPARSEMATRIX_H
+
+namespace Eigen { 
+
+/** \ingroup SparseCore_Module
+  *
+  * \class SparseMatrix
+  *
+  * \brief A versatible sparse matrix representation
+  *
+  * This class implements a more versatile variants of the common \em compressed row/column storage format.
+  * Each colmun's (resp. row) non zeros are stored as a pair of value with associated row (resp. colmiun) index.
+  * All the non zeros are stored in a single large buffer. Unlike the \em compressed format, there might be extra
+  * space in between the nonzeros of two successive colmuns (resp. rows) such that insertion of new non-zero
+  * can be done with limited memory reallocation and copies.
+  *
+  * A call to the function makeCompressed() turns the matrix into the standard \em compressed format
+  * compatible with many library.
+  *
+  * More details on this storage sceheme are given in the \ref TutorialSparse "manual pages".
+  *
+  * \tparam _Scalar the scalar type, i.e. the type of the coefficients
+  * \tparam _Options Union of bit flags controlling the storage scheme. Currently the only possibility
+  *                 is ColMajor or RowMajor. The default is 0 which means column-major.
+  * \tparam _StorageIndex the type of the indices. It has to be a \b signed type (e.g., short, int, std::ptrdiff_t). Default is \c int.
+  *
+  * \warning In %Eigen 3.2, the undocumented type \c SparseMatrix::Index was improperly defined as the storage index type (e.g., int),
+  *          whereas it is now (starting from %Eigen 3.3) deprecated and always defined as Eigen::Index.
+  *          Codes making use of \c SparseMatrix::Index, might thus likely have to be changed to use \c SparseMatrix::StorageIndex instead.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_SPARSEMATRIX_PLUGIN.
+  */
+
+namespace internal {
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct traits<SparseMatrix<_Scalar, _Options, _StorageIndex> >
+{
+  typedef _Scalar Scalar;
+  typedef _StorageIndex StorageIndex;
+  typedef Sparse StorageKind;
+  typedef MatrixXpr XprKind;
+  enum {
+    RowsAtCompileTime = Dynamic,
+    ColsAtCompileTime = Dynamic,
+    MaxRowsAtCompileTime = Dynamic,
+    MaxColsAtCompileTime = Dynamic,
+    Flags = _Options | NestByRefBit | LvalueBit | CompressedAccessBit,
+    SupportedAccessPatterns = InnerRandomAccessPattern
+  };
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int DiagIndex>
+struct traits<Diagonal<SparseMatrix<_Scalar, _Options, _StorageIndex>, DiagIndex> >
+{
+  typedef SparseMatrix<_Scalar, _Options, _StorageIndex> MatrixType;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+
+  typedef _Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef _StorageIndex StorageIndex;
+  typedef MatrixXpr XprKind;
+
+  enum {
+    RowsAtCompileTime = Dynamic,
+    ColsAtCompileTime = 1,
+    MaxRowsAtCompileTime = Dynamic,
+    MaxColsAtCompileTime = 1,
+    Flags = LvalueBit
+  };
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int DiagIndex>
+struct traits<Diagonal<const SparseMatrix<_Scalar, _Options, _StorageIndex>, DiagIndex> >
+ : public traits<Diagonal<SparseMatrix<_Scalar, _Options, _StorageIndex>, DiagIndex> >
+{
+  enum {
+    Flags = 0
+  };
+};
+
+} // end namespace internal
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+class SparseMatrix
+  : public SparseCompressedBase<SparseMatrix<_Scalar, _Options, _StorageIndex> >
+{
+    typedef SparseCompressedBase<SparseMatrix> Base;
+    using Base::convert_index;
+    friend class SparseVector<_Scalar,0,_StorageIndex>;
+    template<typename, typename, typename, typename, typename>
+    friend struct internal::Assignment;
+  public:
+    using Base::isCompressed;
+    using Base::nonZeros;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(SparseMatrix)
+    using Base::operator+=;
+    using Base::operator-=;
+
+    typedef MappedSparseMatrix<Scalar,Flags> Map;
+    typedef Diagonal<SparseMatrix> DiagonalReturnType;
+    typedef Diagonal<const SparseMatrix> ConstDiagonalReturnType;
+    typedef typename Base::InnerIterator InnerIterator;
+    typedef typename Base::ReverseInnerIterator ReverseInnerIterator;
+    
+
+    using Base::IsRowMajor;
+    typedef internal::CompressedStorage<Scalar,StorageIndex> Storage;
+    enum {
+      Options = _Options
+    };
+
+    typedef typename Base::IndexVector IndexVector;
+    typedef typename Base::ScalarVector ScalarVector;
+  protected:
+    typedef SparseMatrix<Scalar,(Flags&~RowMajorBit)|(IsRowMajor?RowMajorBit:0)> TransposedSparseMatrix;
+
+    Index m_outerSize;
+    Index m_innerSize;
+    StorageIndex* m_outerIndex;
+    StorageIndex* m_innerNonZeros;     // optional, if null then the data is compressed
+    Storage m_data;
+
+  public:
+    
+    /** \returns the number of rows of the matrix */
+    inline Index rows() const { return IsRowMajor ? m_outerSize : m_innerSize; }
+    /** \returns the number of columns of the matrix */
+    inline Index cols() const { return IsRowMajor ? m_innerSize : m_outerSize; }
+
+    /** \returns the number of rows (resp. columns) of the matrix if the storage order column major (resp. row major) */
+    inline Index innerSize() const { return m_innerSize; }
+    /** \returns the number of columns (resp. rows) of the matrix if the storage order column major (resp. row major) */
+    inline Index outerSize() const { return m_outerSize; }
+    
+    /** \returns a const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline const Scalar* valuePtr() const { return m_data.valuePtr(); }
+    /** \returns a non-const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline Scalar* valuePtr() { return m_data.valuePtr(); }
+
+    /** \returns a const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline const StorageIndex* innerIndexPtr() const { return m_data.indexPtr(); }
+    /** \returns a non-const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline StorageIndex* innerIndexPtr() { return m_data.indexPtr(); }
+
+    /** \returns a const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), innerIndexPtr() */
+    inline const StorageIndex* outerIndexPtr() const { return m_outerIndex; }
+    /** \returns a non-const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), innerIndexPtr() */
+    inline StorageIndex* outerIndexPtr() { return m_outerIndex; }
+
+    /** \returns a const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline const StorageIndex* innerNonZeroPtr() const { return m_innerNonZeros; }
+    /** \returns a non-const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline StorageIndex* innerNonZeroPtr() { return m_innerNonZeros; }
+
+    /** \internal */
+    inline Storage& data() { return m_data; }
+    /** \internal */
+    inline const Storage& data() const { return m_data; }
+
+    /** \returns the value of the matrix at position \a i, \a j
+      * This function returns Scalar(0) if the element is an explicit \em zero */
+    inline Scalar coeff(Index row, Index col) const
+    {
+      eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
+      
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+      Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
+      return m_data.atInRange(m_outerIndex[outer], end, StorageIndex(inner));
+    }
+
+    /** \returns a non-const reference to the value of the matrix at position \a i, \a j
+      *
+      * If the element does not exist then it is inserted via the insert(Index,Index) function
+      * which itself turns the matrix into a non compressed form if that was not the case.
+      *
+      * This is a O(log(nnz_j)) operation (binary search) plus the cost of insert(Index,Index)
+      * function if the element does not already exist.
+      */
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
+      
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      Index start = m_outerIndex[outer];
+      Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
+      eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix");
+      if(end<=start)
+        return insert(row,col);
+      const Index p = m_data.searchLowerIndex(start,end-1,StorageIndex(inner));
+      if((p<end) && (m_data.index(p)==inner))
+        return m_data.value(p);
+      else
+        return insert(row,col);
+    }
+
+    /** \returns a reference to a novel non zero coefficient with coordinates \a row x \a col.
+      * The non zero coefficient must \b not already exist.
+      *
+      * If the matrix \c *this is in compressed mode, then \c *this is turned into uncompressed
+      * mode while reserving room for 2 x this->innerSize() non zeros if reserve(Index) has not been called earlier.
+      * In this case, the insertion procedure is optimized for a \e sequential insertion mode where elements are assumed to be
+      * inserted by increasing outer-indices.
+      * 
+      * If that's not the case, then it is strongly recommended to either use a triplet-list to assemble the matrix, or to first
+      * call reserve(const SizesType &) to reserve the appropriate number of non-zero elements per inner vector.
+      *
+      * Assuming memory has been appropriately reserved, this function performs a sorted insertion in O(1)
+      * if the elements of each inner vector are inserted in increasing inner index order, and in O(nnz_j) for a random insertion.
+      *
+      */
+    Scalar& insert(Index row, Index col);
+
+  public:
+
+    /** Removes all non zeros but keep allocated memory
+      *
+      * This function does not free the currently allocated memory. To release as much as memory as possible,
+      * call \code mat.data().squeeze(); \endcode after resizing it.
+      * 
+      * \sa resize(Index,Index), data()
+      */
+    inline void setZero()
+    {
+      m_data.clear();
+      memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(StorageIndex));
+      if(m_innerNonZeros)
+        memset(m_innerNonZeros, 0, (m_outerSize)*sizeof(StorageIndex));
+    }
+
+    /** Preallocates \a reserveSize non zeros.
+      *
+      * Precondition: the matrix must be in compressed mode. */
+    inline void reserve(Index reserveSize)
+    {
+      eigen_assert(isCompressed() && "This function does not make sense in non compressed mode.");
+      m_data.reserve(reserveSize);
+    }
+    
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** Preallocates \a reserveSize[\c j] non zeros for each column (resp. row) \c j.
+      *
+      * This function turns the matrix in non-compressed mode.
+      * 
+      * The type \c SizesType must expose the following interface:
+        \code
+        typedef value_type;
+        const value_type& operator[](i) const;
+        \endcode
+      * for \c i in the [0,this->outerSize()[ range.
+      * Typical choices include std::vector<int>, Eigen::VectorXi, Eigen::VectorXi::Constant, etc.
+      */
+    template<class SizesType>
+    inline void reserve(const SizesType& reserveSizes);
+    #else
+    template<class SizesType>
+    inline void reserve(const SizesType& reserveSizes, const typename SizesType::value_type& enableif =
+    #if (!EIGEN_COMP_MSVC) || (EIGEN_COMP_MSVC>=1500) // MSVC 2005 fails to compile with this typename
+        typename
+    #endif
+        SizesType::value_type())
+    {
+      EIGEN_UNUSED_VARIABLE(enableif);
+      reserveInnerVectors(reserveSizes);
+    }
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+  protected:
+    template<class SizesType>
+    inline void reserveInnerVectors(const SizesType& reserveSizes)
+    {
+      if(isCompressed())
+      {
+        Index totalReserveSize = 0;
+        // turn the matrix into non-compressed mode
+        m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+        if (!m_innerNonZeros) internal::throw_std_bad_alloc();
+        
+        // temporarily use m_innerSizes to hold the new starting points.
+        StorageIndex* newOuterIndex = m_innerNonZeros;
+        
+        StorageIndex count = 0;
+        for(Index j=0; j<m_outerSize; ++j)
+        {
+          newOuterIndex[j] = count;
+          count += reserveSizes[j] + (m_outerIndex[j+1]-m_outerIndex[j]);
+          totalReserveSize += reserveSizes[j];
+        }
+        m_data.reserve(totalReserveSize);
+        StorageIndex previousOuterIndex = m_outerIndex[m_outerSize];
+        for(Index j=m_outerSize-1; j>=0; --j)
+        {
+          StorageIndex innerNNZ = previousOuterIndex - m_outerIndex[j];
+          for(Index i=innerNNZ-1; i>=0; --i)
+          {
+            m_data.index(newOuterIndex[j]+i) = m_data.index(m_outerIndex[j]+i);
+            m_data.value(newOuterIndex[j]+i) = m_data.value(m_outerIndex[j]+i);
+          }
+          previousOuterIndex = m_outerIndex[j];
+          m_outerIndex[j] = newOuterIndex[j];
+          m_innerNonZeros[j] = innerNNZ;
+        }
+        if(m_outerSize>0)
+          m_outerIndex[m_outerSize] = m_outerIndex[m_outerSize-1] + m_innerNonZeros[m_outerSize-1] + reserveSizes[m_outerSize-1];
+        
+        m_data.resize(m_outerIndex[m_outerSize]);
+      }
+      else
+      {
+        StorageIndex* newOuterIndex = static_cast<StorageIndex*>(std::malloc((m_outerSize+1)*sizeof(StorageIndex)));
+        if (!newOuterIndex) internal::throw_std_bad_alloc();
+        
+        StorageIndex count = 0;
+        for(Index j=0; j<m_outerSize; ++j)
+        {
+          newOuterIndex[j] = count;
+          StorageIndex alreadyReserved = (m_outerIndex[j+1]-m_outerIndex[j]) - m_innerNonZeros[j];
+          StorageIndex toReserve = std::max<StorageIndex>(reserveSizes[j], alreadyReserved);
+          count += toReserve + m_innerNonZeros[j];
+        }
+        newOuterIndex[m_outerSize] = count;
+        
+        m_data.resize(count);
+        for(Index j=m_outerSize-1; j>=0; --j)
+        {
+          Index offset = newOuterIndex[j] - m_outerIndex[j];
+          if(offset>0)
+          {
+            StorageIndex innerNNZ = m_innerNonZeros[j];
+            for(Index i=innerNNZ-1; i>=0; --i)
+            {
+              m_data.index(newOuterIndex[j]+i) = m_data.index(m_outerIndex[j]+i);
+              m_data.value(newOuterIndex[j]+i) = m_data.value(m_outerIndex[j]+i);
+            }
+          }
+        }
+        
+        std::swap(m_outerIndex, newOuterIndex);
+        std::free(newOuterIndex);
+      }
+      
+    }
+  public:
+
+    //--- low level purely coherent filling ---
+
+    /** \internal
+      * \returns a reference to the non zero coefficient at position \a row, \a col assuming that:
+      * - the nonzero does not already exist
+      * - the new coefficient is the last one according to the storage order
+      *
+      * Before filling a given inner vector you must call the statVec(Index) function.
+      *
+      * After an insertion session, you should call the finalize() function.
+      *
+      * \sa insert, insertBackByOuterInner, startVec */
+    inline Scalar& insertBack(Index row, Index col)
+    {
+      return insertBackByOuterInner(IsRowMajor?row:col, IsRowMajor?col:row);
+    }
+
+    /** \internal
+      * \sa insertBack, startVec */
+    inline Scalar& insertBackByOuterInner(Index outer, Index inner)
+    {
+      eigen_assert(Index(m_outerIndex[outer+1]) == m_data.size() && "Invalid ordered insertion (invalid outer index)");
+      eigen_assert( (m_outerIndex[outer+1]-m_outerIndex[outer]==0 || m_data.index(m_data.size()-1)<inner) && "Invalid ordered insertion (invalid inner index)");
+      Index p = m_outerIndex[outer+1];
+      ++m_outerIndex[outer+1];
+      m_data.append(Scalar(0), inner);
+      return m_data.value(p);
+    }
+
+    /** \internal
+      * \warning use it only if you know what you are doing */
+    inline Scalar& insertBackByOuterInnerUnordered(Index outer, Index inner)
+    {
+      Index p = m_outerIndex[outer+1];
+      ++m_outerIndex[outer+1];
+      m_data.append(Scalar(0), inner);
+      return m_data.value(p);
+    }
+
+    /** \internal
+      * \sa insertBack, insertBackByOuterInner */
+    inline void startVec(Index outer)
+    {
+      eigen_assert(m_outerIndex[outer]==Index(m_data.size()) && "You must call startVec for each inner vector sequentially");
+      eigen_assert(m_outerIndex[outer+1]==0 && "You must call startVec for each inner vector sequentially");
+      m_outerIndex[outer+1] = m_outerIndex[outer];
+    }
+
+    /** \internal
+      * Must be called after inserting a set of non zero entries using the low level compressed API.
+      */
+    inline void finalize()
+    {
+      if(isCompressed())
+      {
+        StorageIndex size = internal::convert_index<StorageIndex>(m_data.size());
+        Index i = m_outerSize;
+        // find the last filled column
+        while (i>=0 && m_outerIndex[i]==0)
+          --i;
+        ++i;
+        while (i<=m_outerSize)
+        {
+          m_outerIndex[i] = size;
+          ++i;
+        }
+      }
+    }
+
+    //---
+
+    template<typename InputIterators>
+    void setFromTriplets(const InputIterators& begin, const InputIterators& end);
+
+    template<typename InputIterators,typename DupFunctor>
+    void setFromTriplets(const InputIterators& begin, const InputIterators& end, DupFunctor dup_func);
+
+    void sumupDuplicates() { collapseDuplicates(internal::scalar_sum_op<Scalar,Scalar>()); }
+
+    template<typename DupFunctor>
+    void collapseDuplicates(DupFunctor dup_func = DupFunctor());
+
+    //---
+    
+    /** \internal
+      * same as insert(Index,Index) except that the indices are given relative to the storage order */
+    Scalar& insertByOuterInner(Index j, Index i)
+    {
+      return insert(IsRowMajor ? j : i, IsRowMajor ? i : j);
+    }
+
+    /** Turns the matrix into the \em compressed format.
+      */
+    void makeCompressed()
+    {
+      if(isCompressed())
+        return;
+      
+      eigen_internal_assert(m_outerIndex!=0 && m_outerSize>0);
+      
+      Index oldStart = m_outerIndex[1];
+      m_outerIndex[1] = m_innerNonZeros[0];
+      for(Index j=1; j<m_outerSize; ++j)
+      {
+        Index nextOldStart = m_outerIndex[j+1];
+        Index offset = oldStart - m_outerIndex[j];
+        if(offset>0)
+        {
+          for(Index k=0; k<m_innerNonZeros[j]; ++k)
+          {
+            m_data.index(m_outerIndex[j]+k) = m_data.index(oldStart+k);
+            m_data.value(m_outerIndex[j]+k) = m_data.value(oldStart+k);
+          }
+        }
+        m_outerIndex[j+1] = m_outerIndex[j] + m_innerNonZeros[j];
+        oldStart = nextOldStart;
+      }
+      std::free(m_innerNonZeros);
+      m_innerNonZeros = 0;
+      m_data.resize(m_outerIndex[m_outerSize]);
+      m_data.squeeze();
+    }
+
+    /** Turns the matrix into the uncompressed mode */
+    void uncompress()
+    {
+      if(m_innerNonZeros != 0)
+        return; 
+      m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+      for (Index i = 0; i < m_outerSize; i++)
+      {
+        m_innerNonZeros[i] = m_outerIndex[i+1] - m_outerIndex[i]; 
+      }
+    }
+
+    /** Suppresses all nonzeros which are \b much \b smaller \b than \a reference under the tolerance \a epsilon */
+    void prune(const Scalar& reference, const RealScalar& epsilon = NumTraits<RealScalar>::dummy_precision())
+    {
+      prune(default_prunning_func(reference,epsilon));
+    }
+    
+    /** Turns the matrix into compressed format, and suppresses all nonzeros which do not satisfy the predicate \a keep.
+      * The functor type \a KeepFunc must implement the following function:
+      * \code
+      * bool operator() (const Index& row, const Index& col, const Scalar& value) const;
+      * \endcode
+      * \sa prune(Scalar,RealScalar)
+      */
+    template<typename KeepFunc>
+    void prune(const KeepFunc& keep = KeepFunc())
+    {
+      // TODO optimize the uncompressed mode to avoid moving and allocating the data twice
+      makeCompressed();
+
+      StorageIndex k = 0;
+      for(Index j=0; j<m_outerSize; ++j)
+      {
+        Index previousStart = m_outerIndex[j];
+        m_outerIndex[j] = k;
+        Index end = m_outerIndex[j+1];
+        for(Index i=previousStart; i<end; ++i)
+        {
+          if(keep(IsRowMajor?j:m_data.index(i), IsRowMajor?m_data.index(i):j, m_data.value(i)))
+          {
+            m_data.value(k) = m_data.value(i);
+            m_data.index(k) = m_data.index(i);
+            ++k;
+          }
+        }
+      }
+      m_outerIndex[m_outerSize] = k;
+      m_data.resize(k,0);
+    }
+
+    /** Resizes the matrix to a \a rows x \a cols matrix leaving old values untouched.
+      *
+      * If the sizes of the matrix are decreased, then the matrix is turned to \b uncompressed-mode
+      * and the storage of the out of bounds coefficients is kept and reserved.
+      * Call makeCompressed() to pack the entries and squeeze extra memory.
+      *
+      * \sa reserve(), setZero(), makeCompressed()
+      */
+    void conservativeResize(Index rows, Index cols) 
+    {
+      // No change
+      if (this->rows() == rows && this->cols() == cols) return;
+      
+      // If one dimension is null, then there is nothing to be preserved
+      if(rows==0 || cols==0) return resize(rows,cols);
+
+      Index innerChange = IsRowMajor ? cols - this->cols() : rows - this->rows();
+      Index outerChange = IsRowMajor ? rows - this->rows() : cols - this->cols();
+      StorageIndex newInnerSize = convert_index(IsRowMajor ? cols : rows);
+
+      // Deals with inner non zeros
+      if (m_innerNonZeros)
+      {
+        // Resize m_innerNonZeros
+        StorageIndex *newInnerNonZeros = static_cast<StorageIndex*>(std::realloc(m_innerNonZeros, (m_outerSize + outerChange) * sizeof(StorageIndex)));
+        if (!newInnerNonZeros) internal::throw_std_bad_alloc();
+        m_innerNonZeros = newInnerNonZeros;
+        
+        for(Index i=m_outerSize; i<m_outerSize+outerChange; i++)          
+          m_innerNonZeros[i] = 0;
+      } 
+      else if (innerChange < 0) 
+      {
+        // Inner size decreased: allocate a new m_innerNonZeros
+        m_innerNonZeros = static_cast<StorageIndex*>(std::malloc((m_outerSize + outerChange) * sizeof(StorageIndex)));
+        if (!m_innerNonZeros) internal::throw_std_bad_alloc();
+        for(Index i = 0; i < m_outerSize + (std::min)(outerChange, Index(0)); i++)
+          m_innerNonZeros[i] = m_outerIndex[i+1] - m_outerIndex[i];
+        for(Index i = m_outerSize; i < m_outerSize + outerChange; i++)
+          m_innerNonZeros[i] = 0;
+      }
+      
+      // Change the m_innerNonZeros in case of a decrease of inner size
+      if (m_innerNonZeros && innerChange < 0)
+      {
+        for(Index i = 0; i < m_outerSize + (std::min)(outerChange, Index(0)); i++)
+        {
+          StorageIndex &n = m_innerNonZeros[i];
+          StorageIndex start = m_outerIndex[i];
+          while (n > 0 && m_data.index(start+n-1) >= newInnerSize) --n; 
+        }
+      }
+      
+      m_innerSize = newInnerSize;
+
+      // Re-allocate outer index structure if necessary
+      if (outerChange == 0)
+        return;
+          
+      StorageIndex *newOuterIndex = static_cast<StorageIndex*>(std::realloc(m_outerIndex, (m_outerSize + outerChange + 1) * sizeof(StorageIndex)));
+      if (!newOuterIndex) internal::throw_std_bad_alloc();
+      m_outerIndex = newOuterIndex;
+      if (outerChange > 0)
+      {
+        StorageIndex lastIdx = m_outerSize == 0 ? 0 : m_outerIndex[m_outerSize];
+        for(Index i=m_outerSize; i<m_outerSize+outerChange+1; i++)          
+          m_outerIndex[i] = lastIdx; 
+      }
+      m_outerSize += outerChange;
+    }
+    
+    /** Resizes the matrix to a \a rows x \a cols matrix and initializes it to zero.
+      * 
+      * This function does not free the currently allocated memory. To release as much as memory as possible,
+      * call \code mat.data().squeeze(); \endcode after resizing it.
+      * 
+      * \sa reserve(), setZero()
+      */
+    void resize(Index rows, Index cols)
+    {
+      const Index outerSize = IsRowMajor ? rows : cols;
+      m_innerSize = IsRowMajor ? cols : rows;
+      m_data.clear();
+      if (m_outerSize != outerSize || m_outerSize==0)
+      {
+        std::free(m_outerIndex);
+        m_outerIndex = static_cast<StorageIndex*>(std::malloc((outerSize + 1) * sizeof(StorageIndex)));
+        if (!m_outerIndex) internal::throw_std_bad_alloc();
+        
+        m_outerSize = outerSize;
+      }
+      if(m_innerNonZeros)
+      {
+        std::free(m_innerNonZeros);
+        m_innerNonZeros = 0;
+      }
+      memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(StorageIndex));
+    }
+
+    /** \internal
+      * Resize the nonzero vector to \a size */
+    void resizeNonZeros(Index size)
+    {
+      m_data.resize(size);
+    }
+
+    /** \returns a const expression of the diagonal coefficients. */
+    const ConstDiagonalReturnType diagonal() const { return ConstDiagonalReturnType(*this); }
+    
+    /** \returns a read-write expression of the diagonal coefficients.
+      * \warning If the diagonal entries are written, then all diagonal
+      * entries \b must already exist, otherwise an assertion will be raised.
+      */
+    DiagonalReturnType diagonal() { return DiagonalReturnType(*this); }
+
+    /** Default constructor yielding an empty \c 0 \c x \c 0 matrix */
+    inline SparseMatrix()
+      : m_outerSize(-1), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      resize(0, 0);
+    }
+
+    /** Constructs a \a rows \c x \a cols empty matrix */
+    inline SparseMatrix(Index rows, Index cols)
+      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      resize(rows, cols);
+    }
+
+    /** Constructs a sparse matrix from the sparse expression \a other */
+    template<typename OtherDerived>
+    inline SparseMatrix(const SparseMatrixBase<OtherDerived>& other)
+      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+      check_template_parameters();
+      const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
+      if (needToTranspose)
+        *this = other.derived();
+      else
+      {
+        #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+          EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+        #endif
+        internal::call_assignment_no_alias(*this, other.derived());
+      }
+    }
+    
+    /** Constructs a sparse matrix from the sparse selfadjoint view \a other */
+    template<typename OtherDerived, unsigned int UpLo>
+    inline SparseMatrix(const SparseSelfAdjointView<OtherDerived, UpLo>& other)
+      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      Base::operator=(other);
+    }
+
+    /** Copy constructor (it performs a deep copy) */
+    inline SparseMatrix(const SparseMatrix& other)
+      : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    /** \brief Copy constructor with in-place evaluation */
+    template<typename OtherDerived>
+    SparseMatrix(const ReturnByValue<OtherDerived>& other)
+      : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      initAssignment(other);
+      other.evalTo(*this);
+    }
+    
+    /** \brief Copy constructor with in-place evaluation */
+    template<typename OtherDerived>
+    explicit SparseMatrix(const DiagonalBase<OtherDerived>& other)
+      : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    /** Swaps the content of two sparse matrices of the same type.
+      * This is a fast operation that simply swaps the underlying pointers and parameters. */
+    inline void swap(SparseMatrix& other)
+    {
+      //EIGEN_DBG_SPARSE(std::cout << "SparseMatrix:: swap\n");
+      std::swap(m_outerIndex, other.m_outerIndex);
+      std::swap(m_innerSize, other.m_innerSize);
+      std::swap(m_outerSize, other.m_outerSize);
+      std::swap(m_innerNonZeros, other.m_innerNonZeros);
+      m_data.swap(other.m_data);
+    }
+
+    /** Sets *this to the identity matrix.
+      * This function also turns the matrix into compressed mode, and drop any reserved memory. */
+    inline void setIdentity()
+    {
+      eigen_assert(rows() == cols() && "ONLY FOR SQUARED MATRICES");
+      this->m_data.resize(rows());
+      Eigen::Map<IndexVector>(this->m_data.indexPtr(), rows()).setLinSpaced(0, StorageIndex(rows()-1));
+      Eigen::Map<ScalarVector>(this->m_data.valuePtr(), rows()).setOnes();
+      Eigen::Map<IndexVector>(this->m_outerIndex, rows()+1).setLinSpaced(0, StorageIndex(rows()));
+      std::free(m_innerNonZeros);
+      m_innerNonZeros = 0;
+    }
+    inline SparseMatrix& operator=(const SparseMatrix& other)
+    {
+      if (other.isRValue())
+      {
+        swap(other.const_cast_derived());
+      }
+      else if(this!=&other)
+      {
+        #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+          EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+        #endif
+        initAssignment(other);
+        if(other.isCompressed())
+        {
+          internal::smart_copy(other.m_outerIndex, other.m_outerIndex + m_outerSize + 1, m_outerIndex);
+          m_data = other.m_data;
+        }
+        else
+        {
+          Base::operator=(other);
+        }
+      }
+      return *this;
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename OtherDerived>
+    inline SparseMatrix& operator=(const EigenBase<OtherDerived>& other)
+    { return Base::operator=(other.derived()); }
+
+    template<typename Lhs, typename Rhs>
+    inline SparseMatrix& operator=(const Product<Lhs,Rhs,AliasFreeProduct>& other);
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+    template<typename OtherDerived>
+    EIGEN_DONT_INLINE SparseMatrix& operator=(const SparseMatrixBase<OtherDerived>& other);
+
+    friend std::ostream & operator << (std::ostream & s, const SparseMatrix& m)
+    {
+      EIGEN_DBG_SPARSE(
+        s << "Nonzero entries:\n";
+        if(m.isCompressed())
+        {
+          for (Index i=0; i<m.nonZeros(); ++i)
+            s << "(" << m.m_data.value(i) << "," << m.m_data.index(i) << ") ";
+        }
+        else
+        {
+          for (Index i=0; i<m.outerSize(); ++i)
+          {
+            Index p = m.m_outerIndex[i];
+            Index pe = m.m_outerIndex[i]+m.m_innerNonZeros[i];
+            Index k=p;
+            for (; k<pe; ++k) {
+              s << "(" << m.m_data.value(k) << "," << m.m_data.index(k) << ") ";
+            }
+            for (; k<m.m_outerIndex[i+1]; ++k) {
+              s << "(_,_) ";
+            }
+          }
+        }
+        s << std::endl;
+        s << std::endl;
+        s << "Outer pointers:\n";
+        for (Index i=0; i<m.outerSize(); ++i) {
+          s << m.m_outerIndex[i] << " ";
+        }
+        s << " $" << std::endl;
+        if(!m.isCompressed())
+        {
+          s << "Inner non zeros:\n";
+          for (Index i=0; i<m.outerSize(); ++i) {
+            s << m.m_innerNonZeros[i] << " ";
+          }
+          s << " $" << std::endl;
+        }
+        s << std::endl;
+      );
+      s << static_cast<const SparseMatrixBase<SparseMatrix>&>(m);
+      return s;
+    }
+
+    /** Destructor */
+    inline ~SparseMatrix()
+    {
+      std::free(m_outerIndex);
+      std::free(m_innerNonZeros);
+    }
+
+    /** Overloaded for performance */
+    Scalar sum() const;
+    
+#   ifdef EIGEN_SPARSEMATRIX_PLUGIN
+#     include EIGEN_SPARSEMATRIX_PLUGIN
+#   endif
+
+protected:
+
+    template<typename Other>
+    void initAssignment(const Other& other)
+    {
+      resize(other.rows(), other.cols());
+      if(m_innerNonZeros)
+      {
+        std::free(m_innerNonZeros);
+        m_innerNonZeros = 0;
+      }
+    }
+
+    /** \internal
+      * \sa insert(Index,Index) */
+    EIGEN_DONT_INLINE Scalar& insertCompressed(Index row, Index col);
+
+    /** \internal
+      * A vector object that is equal to 0 everywhere but v at the position i */
+    class SingletonVector
+    {
+        StorageIndex m_index;
+        StorageIndex m_value;
+      public:
+        typedef StorageIndex value_type;
+        SingletonVector(Index i, Index v)
+          : m_index(convert_index(i)), m_value(convert_index(v))
+        {}
+
+        StorageIndex operator[](Index i) const { return i==m_index ? m_value : 0; }
+    };
+
+    /** \internal
+      * \sa insert(Index,Index) */
+    EIGEN_DONT_INLINE Scalar& insertUncompressed(Index row, Index col);
+
+public:
+    /** \internal
+      * \sa insert(Index,Index) */
+    EIGEN_STRONG_INLINE Scalar& insertBackUncompressed(Index row, Index col)
+    {
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      eigen_assert(!isCompressed());
+      eigen_assert(m_innerNonZeros[outer]<=(m_outerIndex[outer+1] - m_outerIndex[outer]));
+
+      Index p = m_outerIndex[outer] + m_innerNonZeros[outer]++;
+      m_data.index(p) = convert_index(inner);
+      return (m_data.value(p) = Scalar(0));
+    }
+protected:
+    struct IndexPosPair {
+      IndexPosPair(Index a_i, Index a_p) : i(a_i), p(a_p) {}
+      Index i;
+      Index p;
+    };
+
+    /** \internal assign \a diagXpr to the diagonal of \c *this
+      * There are different strategies:
+      *   1 - if *this is overwritten (Func==assign_op) or *this is empty, then we can work treat *this as a dense vector expression.
+      *   2 - otherwise, for each diagonal coeff,
+      *     2.a - if it already exists, then we update it,
+      *     2.b - otherwise, if *this is uncompressed and that the current inner-vector has empty room for at least 1 element, then we perform an in-place insertion.
+      *     2.c - otherwise, we'll have to reallocate and copy everything, so instead of doing so for each new element, it is recorded in a std::vector.
+      *   3 - at the end, if some entries failed to be inserted in-place, then we alloc a new buffer, copy each chunk at the right position, and insert the new elements.
+      * 
+      * TODO: some piece of code could be isolated and reused for a general in-place update strategy.
+      * TODO: if we start to defer the insertion of some elements (i.e., case 2.c executed once),
+      *       then it *might* be better to disable case 2.b since they will have to be copied anyway.
+      */
+    template<typename DiagXpr, typename Func>
+    void assignDiagonal(const DiagXpr diagXpr, const Func& assignFunc)
+    {
+      Index n = diagXpr.size();
+
+      const bool overwrite = internal::is_same<Func, internal::assign_op<Scalar,Scalar> >::value;
+      if(overwrite)
+      {
+        if((this->rows()!=n) || (this->cols()!=n))
+          this->resize(n, n);
+      }
+
+      if(m_data.size()==0 || overwrite)
+      {
+        typedef Array<StorageIndex,Dynamic,1> ArrayXI;  
+        this->makeCompressed();
+        this->resizeNonZeros(n);
+        Eigen::Map<ArrayXI>(this->innerIndexPtr(), n).setLinSpaced(0,StorageIndex(n)-1);
+        Eigen::Map<ArrayXI>(this->outerIndexPtr(), n+1).setLinSpaced(0,StorageIndex(n));
+        Eigen::Map<Array<Scalar,Dynamic,1> > values = this->coeffs();
+        values.setZero();
+        internal::call_assignment_no_alias(values, diagXpr, assignFunc);
+      }
+      else
+      {
+        bool isComp = isCompressed();
+        internal::evaluator<DiagXpr> diaEval(diagXpr);
+        std::vector<IndexPosPair> newEntries;
+
+        // 1 - try in-place update and record insertion failures
+        for(Index i = 0; i<n; ++i)
+        {
+          internal::LowerBoundIndex lb = this->lower_bound(i,i);
+          Index p = lb.value;
+          if(lb.found)
+          {
+            // the coeff already exists
+            assignFunc.assignCoeff(m_data.value(p), diaEval.coeff(i));
+          }
+          else if((!isComp) && m_innerNonZeros[i] < (m_outerIndex[i+1]-m_outerIndex[i]))
+          {
+            // non compressed mode with local room for inserting one element
+            m_data.moveChunk(p, p+1, m_outerIndex[i]+m_innerNonZeros[i]-p);
+            m_innerNonZeros[i]++;
+            m_data.value(p) = Scalar(0);
+            m_data.index(p) = StorageIndex(i);
+            assignFunc.assignCoeff(m_data.value(p), diaEval.coeff(i));
+          }
+          else
+          {
+            // defer insertion
+            newEntries.push_back(IndexPosPair(i,p));
+          }
+        }
+        // 2 - insert deferred entries
+        Index n_entries = Index(newEntries.size());
+        if(n_entries>0)
+        {
+          Storage newData(m_data.size()+n_entries);
+          Index prev_p = 0;
+          Index prev_i = 0;
+          for(Index k=0; k<n_entries;++k)
+          {
+            Index i = newEntries[k].i;
+            Index p = newEntries[k].p;
+            internal::smart_copy(m_data.valuePtr()+prev_p, m_data.valuePtr()+p, newData.valuePtr()+prev_p+k);
+            internal::smart_copy(m_data.indexPtr()+prev_p, m_data.indexPtr()+p, newData.indexPtr()+prev_p+k);
+            for(Index j=prev_i;j<i;++j)
+              m_outerIndex[j+1] += k;
+            if(!isComp)
+              m_innerNonZeros[i]++;
+            prev_p = p;
+            prev_i = i;
+            newData.value(p+k) = Scalar(0);
+            newData.index(p+k) = StorageIndex(i);
+            assignFunc.assignCoeff(newData.value(p+k), diaEval.coeff(i));
+          }
+          {
+            internal::smart_copy(m_data.valuePtr()+prev_p, m_data.valuePtr()+m_data.size(), newData.valuePtr()+prev_p+n_entries);
+            internal::smart_copy(m_data.indexPtr()+prev_p, m_data.indexPtr()+m_data.size(), newData.indexPtr()+prev_p+n_entries);
+            for(Index j=prev_i+1;j<=m_outerSize;++j)
+              m_outerIndex[j] += n_entries;
+          }
+          m_data.swap(newData);
+        }
+      }
+    }
+
+private:
+  static void check_template_parameters()
+  {
+    EIGEN_STATIC_ASSERT(NumTraits<StorageIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE);
+    EIGEN_STATIC_ASSERT((Options&(ColMajor|RowMajor))==Options,INVALID_MATRIX_TEMPLATE_PARAMETERS);
+  }
+
+  struct default_prunning_func {
+    default_prunning_func(const Scalar& ref, const RealScalar& eps) : reference(ref), epsilon(eps) {}
+    inline bool operator() (const Index&, const Index&, const Scalar& value) const
+    {
+      return !internal::isMuchSmallerThan(value, reference, epsilon);
+    }
+    Scalar reference;
+    RealScalar epsilon;
+  };
+};
+
+namespace internal {
+
+template<typename InputIterator, typename SparseMatrixType, typename DupFunctor>
+void set_from_triplets(const InputIterator& begin, const InputIterator& end, SparseMatrixType& mat, DupFunctor dup_func)
+{
+  enum { IsRowMajor = SparseMatrixType::IsRowMajor };
+  typedef typename SparseMatrixType::Scalar Scalar;
+  typedef typename SparseMatrixType::StorageIndex StorageIndex;
+  SparseMatrix<Scalar,IsRowMajor?ColMajor:RowMajor,StorageIndex> trMat(mat.rows(),mat.cols());
+
+  if(begin!=end)
+  {
+    // pass 1: count the nnz per inner-vector
+    typename SparseMatrixType::IndexVector wi(trMat.outerSize());
+    wi.setZero();
+    for(InputIterator it(begin); it!=end; ++it)
+    {
+      eigen_assert(it->row()>=0 && it->row()<mat.rows() && it->col()>=0 && it->col()<mat.cols());
+      wi(IsRowMajor ? it->col() : it->row())++;
+    }
+
+    // pass 2: insert all the elements into trMat
+    trMat.reserve(wi);
+    for(InputIterator it(begin); it!=end; ++it)
+      trMat.insertBackUncompressed(it->row(),it->col()) = it->value();
+
+    // pass 3:
+    trMat.collapseDuplicates(dup_func);
+  }
+
+  // pass 4: transposed copy -> implicit sorting
+  mat = trMat;
+}
+
+}
+
+
+/** Fill the matrix \c *this with the list of \em triplets defined by the iterator range \a begin - \a end.
+  *
+  * A \em triplet is a tuple (i,j,value) defining a non-zero element.
+  * The input list of triplets does not have to be sorted, and can contains duplicated elements.
+  * In any case, the result is a \b sorted and \b compressed sparse matrix where the duplicates have been summed up.
+  * This is a \em O(n) operation, with \em n the number of triplet elements.
+  * The initial contents of \c *this is destroyed.
+  * The matrix \c *this must be properly resized beforehand using the SparseMatrix(Index,Index) constructor,
+  * or the resize(Index,Index) method. The sizes are not extracted from the triplet list.
+  *
+  * The \a InputIterators value_type must provide the following interface:
+  * \code
+  * Scalar value() const; // the value
+  * Scalar row() const;   // the row index i
+  * Scalar col() const;   // the column index j
+  * \endcode
+  * See for instance the Eigen::Triplet template class.
+  *
+  * Here is a typical usage example:
+  * \code
+    typedef Triplet<double> T;
+    std::vector<T> tripletList;
+    tripletList.reserve(estimation_of_entries);
+    for(...)
+    {
+      // ...
+      tripletList.push_back(T(i,j,v_ij));
+    }
+    SparseMatrixType m(rows,cols);
+    m.setFromTriplets(tripletList.begin(), tripletList.end());
+    // m is ready to go!
+  * \endcode
+  *
+  * \warning The list of triplets is read multiple times (at least twice). Therefore, it is not recommended to define
+  * an abstract iterator over a complex data-structure that would be expensive to evaluate. The triplets should rather
+  * be explicitly stored into a std::vector for instance.
+  */
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename InputIterators>
+void SparseMatrix<Scalar,_Options,_StorageIndex>::setFromTriplets(const InputIterators& begin, const InputIterators& end)
+{
+  internal::set_from_triplets<InputIterators, SparseMatrix<Scalar,_Options,_StorageIndex> >(begin, end, *this, internal::scalar_sum_op<Scalar,Scalar>());
+}
+
+/** The same as setFromTriplets but when duplicates are met the functor \a dup_func is applied:
+  * \code
+  * value = dup_func(OldValue, NewValue)
+  * \endcode 
+  * Here is a C++11 example keeping the latest entry only:
+  * \code
+  * mat.setFromTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });
+  * \endcode
+  */
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename InputIterators,typename DupFunctor>
+void SparseMatrix<Scalar,_Options,_StorageIndex>::setFromTriplets(const InputIterators& begin, const InputIterators& end, DupFunctor dup_func)
+{
+  internal::set_from_triplets<InputIterators, SparseMatrix<Scalar,_Options,_StorageIndex>, DupFunctor>(begin, end, *this, dup_func);
+}
+
+/** \internal */
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename DupFunctor>
+void SparseMatrix<Scalar,_Options,_StorageIndex>::collapseDuplicates(DupFunctor dup_func)
+{
+  eigen_assert(!isCompressed());
+  // TODO, in practice we should be able to use m_innerNonZeros for that task
+  IndexVector wi(innerSize());
+  wi.fill(-1);
+  StorageIndex count = 0;
+  // for each inner-vector, wi[inner_index] will hold the position of first element into the index/value buffers
+  for(Index j=0; j<outerSize(); ++j)
+  {
+    StorageIndex start   = count;
+    Index oldEnd  = m_outerIndex[j]+m_innerNonZeros[j];
+    for(Index k=m_outerIndex[j]; k<oldEnd; ++k)
+    {
+      Index i = m_data.index(k);
+      if(wi(i)>=start)
+      {
+        // we already meet this entry => accumulate it
+        m_data.value(wi(i)) = dup_func(m_data.value(wi(i)), m_data.value(k));
+      }
+      else
+      {
+        m_data.value(count) = m_data.value(k);
+        m_data.index(count) = m_data.index(k);
+        wi(i) = count;
+        ++count;
+      }
+    }
+    m_outerIndex[j] = start;
+  }
+  m_outerIndex[m_outerSize] = count;
+
+  // turn the matrix into compressed form
+  std::free(m_innerNonZeros);
+  m_innerNonZeros = 0;
+  m_data.resize(m_outerIndex[m_outerSize]);
+}
+
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename OtherDerived>
+EIGEN_DONT_INLINE SparseMatrix<Scalar,_Options,_StorageIndex>& SparseMatrix<Scalar,_Options,_StorageIndex>::operator=(const SparseMatrixBase<OtherDerived>& other)
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+    EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+  #endif
+      
+  const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
+  if (needToTranspose)
+  {
+    #ifdef EIGEN_SPARSE_TRANSPOSED_COPY_PLUGIN
+      EIGEN_SPARSE_TRANSPOSED_COPY_PLUGIN
+    #endif
+    // two passes algorithm:
+    //  1 - compute the number of coeffs per dest inner vector
+    //  2 - do the actual copy/eval
+    // Since each coeff of the rhs has to be evaluated twice, let's evaluate it if needed
+    typedef typename internal::nested_eval<OtherDerived,2,typename internal::plain_matrix_type<OtherDerived>::type >::type OtherCopy;
+    typedef typename internal::remove_all<OtherCopy>::type _OtherCopy;
+    typedef internal::evaluator<_OtherCopy> OtherCopyEval;
+    OtherCopy otherCopy(other.derived());
+    OtherCopyEval otherCopyEval(otherCopy);
+
+    SparseMatrix dest(other.rows(),other.cols());
+    Eigen::Map<IndexVector> (dest.m_outerIndex,dest.outerSize()).setZero();
+
+    // pass 1
+    // FIXME the above copy could be merged with that pass
+    for (Index j=0; j<otherCopy.outerSize(); ++j)
+      for (typename OtherCopyEval::InnerIterator it(otherCopyEval, j); it; ++it)
+        ++dest.m_outerIndex[it.index()];
+
+    // prefix sum
+    StorageIndex count = 0;
+    IndexVector positions(dest.outerSize());
+    for (Index j=0; j<dest.outerSize(); ++j)
+    {
+      StorageIndex tmp = dest.m_outerIndex[j];
+      dest.m_outerIndex[j] = count;
+      positions[j] = count;
+      count += tmp;
+    }
+    dest.m_outerIndex[dest.outerSize()] = count;
+    // alloc
+    dest.m_data.resize(count);
+    // pass 2
+    for (StorageIndex j=0; j<otherCopy.outerSize(); ++j)
+    {
+      for (typename OtherCopyEval::InnerIterator it(otherCopyEval, j); it; ++it)
+      {
+        Index pos = positions[it.index()]++;
+        dest.m_data.index(pos) = j;
+        dest.m_data.value(pos) = it.value();
+      }
+    }
+    this->swap(dest);
+    return *this;
+  }
+  else
+  {
+    if(other.isRValue())
+    {
+      initAssignment(other.derived());
+    }
+    // there is no special optimization
+    return Base::operator=(other.derived());
+  }
+}
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+typename SparseMatrix<_Scalar,_Options,_StorageIndex>::Scalar& SparseMatrix<_Scalar,_Options,_StorageIndex>::insert(Index row, Index col)
+{
+  eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
+  
+  const Index outer = IsRowMajor ? row : col;
+  const Index inner = IsRowMajor ? col : row;
+  
+  if(isCompressed())
+  {
+    if(nonZeros()==0)
+    {
+      // reserve space if not already done
+      if(m_data.allocatedSize()==0)
+        m_data.reserve(2*m_innerSize);
+      
+      // turn the matrix into non-compressed mode
+      m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+      if(!m_innerNonZeros) internal::throw_std_bad_alloc();
+      
+      memset(m_innerNonZeros, 0, (m_outerSize)*sizeof(StorageIndex));
+      
+      // pack all inner-vectors to the end of the pre-allocated space
+      // and allocate the entire free-space to the first inner-vector
+      StorageIndex end = convert_index(m_data.allocatedSize());
+      for(Index j=1; j<=m_outerSize; ++j)
+        m_outerIndex[j] = end;
+    }
+    else
+    {
+      // turn the matrix into non-compressed mode
+      m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+      if(!m_innerNonZeros) internal::throw_std_bad_alloc();
+      for(Index j=0; j<m_outerSize; ++j)
+        m_innerNonZeros[j] = m_outerIndex[j+1]-m_outerIndex[j];
+    }
+  }
+  
+  // check whether we can do a fast "push back" insertion
+  Index data_end = m_data.allocatedSize();
+  
+  // First case: we are filling a new inner vector which is packed at the end.
+  // We assume that all remaining inner-vectors are also empty and packed to the end.
+  if(m_outerIndex[outer]==data_end)
+  {
+    eigen_internal_assert(m_innerNonZeros[outer]==0);
+    
+    // pack previous empty inner-vectors to end of the used-space
+    // and allocate the entire free-space to the current inner-vector.
+    StorageIndex p = convert_index(m_data.size());
+    Index j = outer;
+    while(j>=0 && m_innerNonZeros[j]==0)
+      m_outerIndex[j--] = p;
+    
+    // push back the new element
+    ++m_innerNonZeros[outer];
+    m_data.append(Scalar(0), inner);
+    
+    // check for reallocation
+    if(data_end != m_data.allocatedSize())
+    {
+      // m_data has been reallocated
+      //  -> move remaining inner-vectors back to the end of the free-space
+      //     so that the entire free-space is allocated to the current inner-vector.
+      eigen_internal_assert(data_end < m_data.allocatedSize());
+      StorageIndex new_end = convert_index(m_data.allocatedSize());
+      for(Index k=outer+1; k<=m_outerSize; ++k)
+        if(m_outerIndex[k]==data_end)
+          m_outerIndex[k] = new_end;
+    }
+    return m_data.value(p);
+  }
+  
+  // Second case: the next inner-vector is packed to the end
+  // and the current inner-vector end match the used-space.
+  if(m_outerIndex[outer+1]==data_end && m_outerIndex[outer]+m_innerNonZeros[outer]==m_data.size())
+  {
+    eigen_internal_assert(outer+1==m_outerSize || m_innerNonZeros[outer+1]==0);
+    
+    // add space for the new element
+    ++m_innerNonZeros[outer];
+    m_data.resize(m_data.size()+1);
+    
+    // check for reallocation
+    if(data_end != m_data.allocatedSize())
+    {
+      // m_data has been reallocated
+      //  -> move remaining inner-vectors back to the end of the free-space
+      //     so that the entire free-space is allocated to the current inner-vector.
+      eigen_internal_assert(data_end < m_data.allocatedSize());
+      StorageIndex new_end = convert_index(m_data.allocatedSize());
+      for(Index k=outer+1; k<=m_outerSize; ++k)
+        if(m_outerIndex[k]==data_end)
+          m_outerIndex[k] = new_end;
+    }
+    
+    // and insert it at the right position (sorted insertion)
+    Index startId = m_outerIndex[outer];
+    Index p = m_outerIndex[outer]+m_innerNonZeros[outer]-1;
+    while ( (p > startId) && (m_data.index(p-1) > inner) )
+    {
+      m_data.index(p) = m_data.index(p-1);
+      m_data.value(p) = m_data.value(p-1);
+      --p;
+    }
+    
+    m_data.index(p) = convert_index(inner);
+    return (m_data.value(p) = Scalar(0));
+  }
+  
+  if(m_data.size() != m_data.allocatedSize())
+  {
+    // make sure the matrix is compatible to random un-compressed insertion:
+    m_data.resize(m_data.allocatedSize());
+    this->reserveInnerVectors(Array<StorageIndex,Dynamic,1>::Constant(m_outerSize, 2));
+  }
+  
+  return insertUncompressed(row,col);
+}
+    
+template<typename _Scalar, int _Options, typename _StorageIndex>
+EIGEN_DONT_INLINE typename SparseMatrix<_Scalar,_Options,_StorageIndex>::Scalar& SparseMatrix<_Scalar,_Options,_StorageIndex>::insertUncompressed(Index row, Index col)
+{
+  eigen_assert(!isCompressed());
+
+  const Index outer = IsRowMajor ? row : col;
+  const StorageIndex inner = convert_index(IsRowMajor ? col : row);
+
+  Index room = m_outerIndex[outer+1] - m_outerIndex[outer];
+  StorageIndex innerNNZ = m_innerNonZeros[outer];
+  if(innerNNZ>=room)
+  {
+    // this inner vector is full, we need to reallocate the whole buffer :(
+    reserve(SingletonVector(outer,std::max<StorageIndex>(2,innerNNZ)));
+  }
+
+  Index startId = m_outerIndex[outer];
+  Index p = startId + m_innerNonZeros[outer];
+  while ( (p > startId) && (m_data.index(p-1) > inner) )
+  {
+    m_data.index(p) = m_data.index(p-1);
+    m_data.value(p) = m_data.value(p-1);
+    --p;
+  }
+  eigen_assert((p<=startId || m_data.index(p-1)!=inner) && "you cannot insert an element that already exists, you must call coeffRef to this end");
+
+  m_innerNonZeros[outer]++;
+
+  m_data.index(p) = inner;
+  return (m_data.value(p) = Scalar(0));
+}
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+EIGEN_DONT_INLINE typename SparseMatrix<_Scalar,_Options,_StorageIndex>::Scalar& SparseMatrix<_Scalar,_Options,_StorageIndex>::insertCompressed(Index row, Index col)
+{
+  eigen_assert(isCompressed());
+
+  const Index outer = IsRowMajor ? row : col;
+  const Index inner = IsRowMajor ? col : row;
+
+  Index previousOuter = outer;
+  if (m_outerIndex[outer+1]==0)
+  {
+    // we start a new inner vector
+    while (previousOuter>=0 && m_outerIndex[previousOuter]==0)
+    {
+      m_outerIndex[previousOuter] = convert_index(m_data.size());
+      --previousOuter;
+    }
+    m_outerIndex[outer+1] = m_outerIndex[outer];
+  }
+
+  // here we have to handle the tricky case where the outerIndex array
+  // starts with: [ 0 0 0 0 0 1 ...] and we are inserted in, e.g.,
+  // the 2nd inner vector...
+  bool isLastVec = (!(previousOuter==-1 && m_data.size()!=0))
+                && (std::size_t(m_outerIndex[outer+1]) == m_data.size());
+
+  std::size_t startId = m_outerIndex[outer];
+  // FIXME let's make sure sizeof(long int) == sizeof(std::size_t)
+  std::size_t p = m_outerIndex[outer+1];
+  ++m_outerIndex[outer+1];
+
+  double reallocRatio = 1;
+  if (m_data.allocatedSize()<=m_data.size())
+  {
+    // if there is no preallocated memory, let's reserve a minimum of 32 elements
+    if (m_data.size()==0)
+    {
+      m_data.reserve(32);
+    }
+    else
+    {
+      // we need to reallocate the data, to reduce multiple reallocations
+      // we use a smart resize algorithm based on the current filling ratio
+      // in addition, we use double to avoid integers overflows
+      double nnzEstimate = double(m_outerIndex[outer])*double(m_outerSize)/double(outer+1);
+      reallocRatio = (nnzEstimate-double(m_data.size()))/double(m_data.size());
+      // furthermore we bound the realloc ratio to:
+      //   1) reduce multiple minor realloc when the matrix is almost filled
+      //   2) avoid to allocate too much memory when the matrix is almost empty
+      reallocRatio = (std::min)((std::max)(reallocRatio,1.5),8.);
+    }
+  }
+  m_data.resize(m_data.size()+1,reallocRatio);
+
+  if (!isLastVec)
+  {
+    if (previousOuter==-1)
+    {
+      // oops wrong guess.
+      // let's correct the outer offsets
+      for (Index k=0; k<=(outer+1); ++k)
+        m_outerIndex[k] = 0;
+      Index k=outer+1;
+      while(m_outerIndex[k]==0)
+        m_outerIndex[k++] = 1;
+      while (k<=m_outerSize && m_outerIndex[k]!=0)
+        m_outerIndex[k++]++;
+      p = 0;
+      --k;
+      k = m_outerIndex[k]-1;
+      while (k>0)
+      {
+        m_data.index(k) = m_data.index(k-1);
+        m_data.value(k) = m_data.value(k-1);
+        k--;
+      }
+    }
+    else
+    {
+      // we are not inserting into the last inner vec
+      // update outer indices:
+      Index j = outer+2;
+      while (j<=m_outerSize && m_outerIndex[j]!=0)
+        m_outerIndex[j++]++;
+      --j;
+      // shift data of last vecs:
+      Index k = m_outerIndex[j]-1;
+      while (k>=Index(p))
+      {
+        m_data.index(k) = m_data.index(k-1);
+        m_data.value(k) = m_data.value(k-1);
+        k--;
+      }
+    }
+  }
+
+  while ( (p > startId) && (m_data.index(p-1) > inner) )
+  {
+    m_data.index(p) = m_data.index(p-1);
+    m_data.value(p) = m_data.value(p-1);
+    --p;
+  }
+
+  m_data.index(p) = inner;
+  return (m_data.value(p) = Scalar(0));
+}
+
+namespace internal {
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct evaluator<SparseMatrix<_Scalar,_Options,_StorageIndex> >
+  : evaluator<SparseCompressedBase<SparseMatrix<_Scalar,_Options,_StorageIndex> > >
+{
+  typedef evaluator<SparseCompressedBase<SparseMatrix<_Scalar,_Options,_StorageIndex> > > Base;
+  typedef SparseMatrix<_Scalar,_Options,_StorageIndex> SparseMatrixType;
+  evaluator() : Base() {}
+  explicit evaluator(const SparseMatrixType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEMATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseMatrixBase.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseMatrixBase.h
new file mode 100644
index 00000000..229449f0
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -0,0 +1,398 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEMATRIXBASE_H
+#define EIGEN_SPARSEMATRIXBASE_H
+
+namespace Eigen { 
+
+/** \ingroup SparseCore_Module
+  *
+  * \class SparseMatrixBase
+  *
+  * \brief Base class of any sparse matrices or sparse expressions
+  *
+  * \tparam Derived is the derived type, e.g. a sparse matrix type, or an expression, etc.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_SPARSEMATRIXBASE_PLUGIN.
+  */
+template<typename Derived> class SparseMatrixBase
+  : public EigenBase<Derived>
+{
+  public:
+
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    
+    /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.
+      *
+      * It is an alias for the Scalar type */
+    typedef Scalar value_type;
+    
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+
+    /** The integer type used to \b store indices within a SparseMatrix.
+      * For a \c SparseMatrix<Scalar,Options,IndexType> it an alias of the third template parameter \c IndexType. */
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+
+    typedef typename internal::add_const_on_value_type_if_arithmetic<
+                         typename internal::packet_traits<Scalar>::type
+                     >::type PacketReturnType;
+
+    typedef SparseMatrixBase StorageBaseType;
+
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+    
+    template<typename OtherDerived>
+    Derived& operator=(const EigenBase<OtherDerived> &other);
+
+    enum {
+
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+        /**< The number of rows at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
+
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+        /**< The number of columns at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
+
+
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                   internal::traits<Derived>::ColsAtCompileTime>::ret),
+        /**< This is equal to the number of coefficients, i.e. the number of
+          * rows times the number of columns, or to \a Dynamic if this is not
+          * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
+
+      MaxRowsAtCompileTime = RowsAtCompileTime,
+      MaxColsAtCompileTime = ColsAtCompileTime,
+
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<MaxRowsAtCompileTime,
+                                                      MaxColsAtCompileTime>::ret),
+
+      IsVectorAtCompileTime = RowsAtCompileTime == 1 || ColsAtCompileTime == 1,
+        /**< This is set to true if either the number of rows or the number of
+          * columns is known at compile-time to be equal to 1. Indeed, in that case,
+          * we are dealing with a column-vector (if there is only one column) or with
+          * a row-vector (if there is only one row). */
+
+      NumDimensions = int(MaxSizeAtCompileTime) == 1 ? 0 : bool(IsVectorAtCompileTime) ? 1 : 2,
+        /**< This value is equal to Tensor::NumDimensions, i.e. 0 for scalars, 1 for vectors,
+         * and 2 for matrices.
+         */
+
+      Flags = internal::traits<Derived>::Flags,
+        /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
+          * constructed from this one. See the \ref flags "list of flags".
+          */
+
+      IsRowMajor = Flags&RowMajorBit ? 1 : 0,
+      
+      InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime)
+                             : int(IsRowMajor) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+
+      #ifndef EIGEN_PARSED_BY_DOXYGEN
+      _HasDirectAccess = (int(Flags)&DirectAccessBit) ? 1 : 0 // workaround sunCC
+      #endif
+    };
+
+    /** \internal the return type of MatrixBase::adjoint() */
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Eigen::Transpose<const Derived> >,
+                        Transpose<const Derived>
+                     >::type AdjointReturnType;
+    typedef Transpose<Derived> TransposeReturnType;
+    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
+
+    // FIXME storage order do not match evaluator storage order
+    typedef SparseMatrix<Scalar, Flags&RowMajorBit ? RowMajor : ColMajor, StorageIndex> PlainObject;
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is the "real scalar" type; if the \a Scalar type is already real numbers
+      * (e.g. int, float or double) then \a RealScalar is just the same as \a Scalar. If
+      * \a Scalar is \a std::complex<T> then RealScalar is \a T.
+      *
+      * \sa class NumTraits
+      */
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    /** \internal the return type of coeff()
+      */
+    typedef typename internal::conditional<_HasDirectAccess, const Scalar&, Scalar>::type CoeffReturnType;
+
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Matrix<Scalar,Dynamic,Dynamic> > ConstantReturnType;
+
+    /** type of the equivalent dense matrix */
+    typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> DenseMatrixType;
+    /** type of the equivalent square matrix */
+    typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime),
+                          EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
+
+    inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    inline Derived& derived() { return *static_cast<Derived*>(this); }
+    inline Derived& const_cast_derived() const
+    { return *static_cast<Derived*>(const_cast<SparseMatrixBase*>(this)); }
+
+    typedef EigenBase<Derived> Base;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::SparseMatrixBase
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+#define EIGEN_DOC_UNARY_ADDONS(METHOD,OP)           /** <p>This method does not change the sparsity of \c *this: the OP is applied to explicitly stored coefficients only. \sa SparseCompressedBase::coeffs() </p> */
+#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL      /** <p> \warning This method returns a read-only expression for any sparse matrices. \sa \ref TutorialSparse_SubMatrices "Sparse block operations" </p> */
+#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND) /** <p> \warning This method returns a read-write expression for COND sparse matrices only. Otherwise, the returned expression is read-only. \sa \ref TutorialSparse_SubMatrices "Sparse block operations" </p> */
+#else
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND)
+#endif
+#   include "../plugins/CommonCwiseUnaryOps.h"
+#   include "../plugins/CommonCwiseBinaryOps.h"
+#   include "../plugins/MatrixCwiseUnaryOps.h"
+#   include "../plugins/MatrixCwiseBinaryOps.h"
+#   include "../plugins/BlockMethods.h"
+#   ifdef EIGEN_SPARSEMATRIXBASE_PLUGIN
+#     include EIGEN_SPARSEMATRIXBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_UNARY_ADDONS
+#undef EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#undef EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF
+
+    /** \returns the number of rows. \sa cols() */
+    inline Index rows() const { return derived().rows(); }
+    /** \returns the number of columns. \sa rows() */
+    inline Index cols() const { return derived().cols(); }
+    /** \returns the number of coefficients, which is \a rows()*cols().
+      * \sa rows(), cols(). */
+    inline Index size() const { return rows() * cols(); }
+    /** \returns true if either the number of rows or the number of columns is equal to 1.
+      * In other words, this function returns
+      * \code rows()==1 || cols()==1 \endcode
+      * \sa rows(), cols(), IsVectorAtCompileTime. */
+    inline bool isVector() const { return rows()==1 || cols()==1; }
+    /** \returns the size of the storage major dimension,
+      * i.e., the number of columns for a columns major matrix, and the number of rows otherwise */
+    Index outerSize() const { return (int(Flags)&RowMajorBit) ? this->rows() : this->cols(); }
+    /** \returns the size of the inner dimension according to the storage order,
+      * i.e., the number of rows for a columns major matrix, and the number of cols otherwise */
+    Index innerSize() const { return (int(Flags)&RowMajorBit) ? this->cols() : this->rows(); }
+
+    bool isRValue() const { return m_isRValue; }
+    Derived& markAsRValue() { m_isRValue = true; return derived(); }
+
+    SparseMatrixBase() : m_isRValue(false) { /* TODO check flags */ }
+
+    
+    template<typename OtherDerived>
+    Derived& operator=(const ReturnByValue<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    inline Derived& operator=(const SparseMatrixBase<OtherDerived>& other);
+
+    inline Derived& operator=(const Derived& other);
+
+  protected:
+
+    template<typename OtherDerived>
+    inline Derived& assign(const OtherDerived& other);
+
+    template<typename OtherDerived>
+    inline void assignGeneric(const OtherDerived& other);
+
+  public:
+
+    friend std::ostream & operator << (std::ostream & s, const SparseMatrixBase& m)
+    {
+      typedef typename Derived::Nested Nested;
+      typedef typename internal::remove_all<Nested>::type NestedCleaned;
+
+      if (Flags&RowMajorBit)
+      {
+        Nested nm(m.derived());
+        internal::evaluator<NestedCleaned> thisEval(nm);
+        for (Index row=0; row<nm.outerSize(); ++row)
+        {
+          Index col = 0;
+          for (typename internal::evaluator<NestedCleaned>::InnerIterator it(thisEval, row); it; ++it)
+          {
+            for ( ; col<it.index(); ++col)
+              s << "0 ";
+            s << it.value() << " ";
+            ++col;
+          }
+          for ( ; col<m.cols(); ++col)
+            s << "0 ";
+          s << std::endl;
+        }
+      }
+      else
+      {
+        Nested nm(m.derived());
+        internal::evaluator<NestedCleaned> thisEval(nm);
+        if (m.cols() == 1) {
+          Index row = 0;
+          for (typename internal::evaluator<NestedCleaned>::InnerIterator it(thisEval, 0); it; ++it)
+          {
+            for ( ; row<it.index(); ++row)
+              s << "0" << std::endl;
+            s << it.value() << std::endl;
+            ++row;
+          }
+          for ( ; row<m.rows(); ++row)
+            s << "0" << std::endl;
+        }
+        else
+        {
+          SparseMatrix<Scalar, RowMajorBit, StorageIndex> trans = m;
+          s << static_cast<const SparseMatrixBase<SparseMatrix<Scalar, RowMajorBit, StorageIndex> >&>(trans);
+        }
+      }
+      return s;
+    }
+
+    template<typename OtherDerived>
+    Derived& operator+=(const SparseMatrixBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    Derived& operator-=(const SparseMatrixBase<OtherDerived>& other);
+    
+    template<typename OtherDerived>
+    Derived& operator+=(const DiagonalBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    Derived& operator-=(const DiagonalBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    Derived& operator+=(const EigenBase<OtherDerived> &other);
+    template<typename OtherDerived>
+    Derived& operator-=(const EigenBase<OtherDerived> &other);
+
+    Derived& operator*=(const Scalar& other);
+    Derived& operator/=(const Scalar& other);
+
+    template<typename OtherDerived> struct CwiseProductDenseReturnType {
+      typedef CwiseBinaryOp<internal::scalar_product_op<typename ScalarBinaryOpTraits<
+                                                          typename internal::traits<Derived>::Scalar,
+                                                          typename internal::traits<OtherDerived>::Scalar
+                                                        >::ReturnType>,
+                            const Derived,
+                            const OtherDerived
+                          > Type;
+    };
+
+    template<typename OtherDerived>
+    EIGEN_STRONG_INLINE const typename CwiseProductDenseReturnType<OtherDerived>::Type
+    cwiseProduct(const MatrixBase<OtherDerived> &other) const;
+
+    // sparse * diagonal
+    template<typename OtherDerived>
+    const Product<Derived,OtherDerived>
+    operator*(const DiagonalBase<OtherDerived> &other) const
+    { return Product<Derived,OtherDerived>(derived(), other.derived()); }
+
+    // diagonal * sparse
+    template<typename OtherDerived> friend
+    const Product<OtherDerived,Derived>
+    operator*(const DiagonalBase<OtherDerived> &lhs, const SparseMatrixBase& rhs)
+    { return Product<OtherDerived,Derived>(lhs.derived(), rhs.derived()); }
+    
+    // sparse * sparse
+    template<typename OtherDerived>
+    const Product<Derived,OtherDerived,AliasFreeProduct>
+    operator*(const SparseMatrixBase<OtherDerived> &other) const;
+    
+    // sparse * dense
+    template<typename OtherDerived>
+    const Product<Derived,OtherDerived>
+    operator*(const MatrixBase<OtherDerived> &other) const
+    { return Product<Derived,OtherDerived>(derived(), other.derived()); }
+    
+    // dense * sparse
+    template<typename OtherDerived> friend
+    const Product<OtherDerived,Derived>
+    operator*(const MatrixBase<OtherDerived> &lhs, const SparseMatrixBase& rhs)
+    { return Product<OtherDerived,Derived>(lhs.derived(), rhs.derived()); }
+    
+     /** \returns an expression of P H P^-1 where H is the matrix represented by \c *this */
+    SparseSymmetricPermutationProduct<Derived,Upper|Lower> twistedBy(const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& perm) const
+    {
+      return SparseSymmetricPermutationProduct<Derived,Upper|Lower>(derived(), perm);
+    }
+
+    template<typename OtherDerived>
+    Derived& operator*=(const SparseMatrixBase<OtherDerived>& other);
+
+    template<int Mode>
+    inline const TriangularView<const Derived, Mode> triangularView() const;
+    
+    template<unsigned int UpLo> struct SelfAdjointViewReturnType { typedef SparseSelfAdjointView<Derived, UpLo> Type; };
+    template<unsigned int UpLo> struct ConstSelfAdjointViewReturnType { typedef const SparseSelfAdjointView<const Derived, UpLo> Type; };
+
+    template<unsigned int UpLo> inline 
+    typename ConstSelfAdjointViewReturnType<UpLo>::Type selfadjointView() const;
+    template<unsigned int UpLo> inline
+    typename SelfAdjointViewReturnType<UpLo>::Type selfadjointView();
+
+    template<typename OtherDerived> Scalar dot(const MatrixBase<OtherDerived>& other) const;
+    template<typename OtherDerived> Scalar dot(const SparseMatrixBase<OtherDerived>& other) const;
+    RealScalar squaredNorm() const;
+    RealScalar norm()  const;
+    RealScalar blueNorm() const;
+
+    TransposeReturnType transpose() { return TransposeReturnType(derived()); }
+    const ConstTransposeReturnType transpose() const { return ConstTransposeReturnType(derived()); }
+    const AdjointReturnType adjoint() const { return AdjointReturnType(transpose()); }
+
+    DenseMatrixType toDense() const
+    {
+      return DenseMatrixType(derived());
+    }
+
+    template<typename OtherDerived>
+    bool isApprox(const SparseMatrixBase<OtherDerived>& other,
+                  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    template<typename OtherDerived>
+    bool isApprox(const MatrixBase<OtherDerived>& other,
+                  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const
+    { return toDense().isApprox(other,prec); }
+
+    /** \returns the matrix or vector obtained by evaluating this expression.
+      *
+      * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
+      * a const reference, in order to avoid a useless copy.
+      */
+    inline const typename internal::eval<Derived>::type eval() const
+    { return typename internal::eval<Derived>::type(derived()); }
+
+    Scalar sum() const;
+    
+    inline const SparseView<Derived>
+    pruned(const Scalar& reference = Scalar(0), const RealScalar& epsilon = NumTraits<Scalar>::dummy_precision()) const;
+
+  protected:
+
+    bool m_isRValue;
+
+    static inline StorageIndex convert_index(const Index idx) {
+      return internal::convert_index<StorageIndex>(idx);
+    }
+  private:
+    template<typename Dest> void evalTo(Dest &) const;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEMATRIXBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparsePermutation.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparsePermutation.h
new file mode 100644
index 00000000..ef38357a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparsePermutation.h
@@ -0,0 +1,178 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_PERMUTATION_H
+#define EIGEN_SPARSE_PERMUTATION_H
+
+// This file implements sparse * permutation products
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename ExpressionType, int Side, bool Transposed>
+struct permutation_matrix_product<ExpressionType, Side, Transposed, SparseShape>
+{
+    typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
+    typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+
+    typedef typename MatrixTypeCleaned::Scalar Scalar;
+    typedef typename MatrixTypeCleaned::StorageIndex StorageIndex;
+
+    enum {
+      SrcStorageOrder = MatrixTypeCleaned::Flags&RowMajorBit ? RowMajor : ColMajor,
+      MoveOuter = SrcStorageOrder==RowMajor ? Side==OnTheLeft : Side==OnTheRight
+    };
+    
+    typedef typename internal::conditional<MoveOuter,
+        SparseMatrix<Scalar,SrcStorageOrder,StorageIndex>,
+        SparseMatrix<Scalar,int(SrcStorageOrder)==RowMajor?ColMajor:RowMajor,StorageIndex> >::type ReturnType;
+
+    template<typename Dest,typename PermutationType>
+    static inline void run(Dest& dst, const PermutationType& perm, const ExpressionType& xpr)
+    {
+      MatrixType mat(xpr);
+      if(MoveOuter)
+      {
+        SparseMatrix<Scalar,SrcStorageOrder,StorageIndex> tmp(mat.rows(), mat.cols());
+        Matrix<StorageIndex,Dynamic,1> sizes(mat.outerSize());
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          Index jp = perm.indices().coeff(j);
+          sizes[((Side==OnTheLeft) ^ Transposed) ? jp : j] = StorageIndex(mat.innerVector(((Side==OnTheRight) ^ Transposed) ? jp : j).nonZeros());
+        }
+        tmp.reserve(sizes);
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          Index jp = perm.indices().coeff(j);
+          Index jsrc = ((Side==OnTheRight) ^ Transposed) ? jp : j;
+          Index jdst = ((Side==OnTheLeft) ^ Transposed) ? jp : j;
+          for(typename MatrixTypeCleaned::InnerIterator it(mat,jsrc); it; ++it)
+            tmp.insertByOuterInner(jdst,it.index()) = it.value();
+        }
+        dst = tmp;
+      }
+      else
+      {
+        SparseMatrix<Scalar,int(SrcStorageOrder)==RowMajor?ColMajor:RowMajor,StorageIndex> tmp(mat.rows(), mat.cols());
+        Matrix<StorageIndex,Dynamic,1> sizes(tmp.outerSize());
+        sizes.setZero();
+        PermutationMatrix<Dynamic,Dynamic,StorageIndex> perm_cpy;
+        if((Side==OnTheLeft) ^ Transposed)
+          perm_cpy = perm;
+        else
+          perm_cpy = perm.transpose();
+
+        for(Index j=0; j<mat.outerSize(); ++j)
+          for(typename MatrixTypeCleaned::InnerIterator it(mat,j); it; ++it)
+            sizes[perm_cpy.indices().coeff(it.index())]++;
+        tmp.reserve(sizes);
+        for(Index j=0; j<mat.outerSize(); ++j)
+          for(typename MatrixTypeCleaned::InnerIterator it(mat,j); it; ++it)
+            tmp.insertByOuterInner(perm_cpy.indices().coeff(it.index()),j) = it.value();
+        dst = tmp;
+      }
+    }
+};
+
+}
+
+namespace internal {
+
+template <int ProductTag> struct product_promote_storage_type<Sparse,             PermutationStorage, ProductTag> { typedef Sparse ret; };
+template <int ProductTag> struct product_promote_storage_type<PermutationStorage, Sparse,             ProductTag> { typedef Sparse ret; };
+
+// TODO, the following two overloads are only needed to define the right temporary type through 
+// typename traits<permutation_sparse_matrix_product<Rhs,Lhs,OnTheRight,false> >::ReturnType
+// whereas it should be correctly handled by traits<Product<> >::PlainObject
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, AliasFreeProduct>, ProductTag, PermutationShape, SparseShape>
+  : public evaluator<typename permutation_matrix_product<Rhs,OnTheLeft,false,SparseShape>::ReturnType>
+{
+  typedef Product<Lhs, Rhs, AliasFreeProduct> XprType;
+  typedef typename permutation_matrix_product<Rhs,OnTheLeft,false,SparseShape>::ReturnType PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+
+  explicit product_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<Lhs, Rhs, PermutationShape, SparseShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, AliasFreeProduct>, ProductTag, SparseShape, PermutationShape >
+  : public evaluator<typename permutation_matrix_product<Lhs,OnTheRight,false,SparseShape>::ReturnType>
+{
+  typedef Product<Lhs, Rhs, AliasFreeProduct> XprType;
+  typedef typename permutation_matrix_product<Lhs,OnTheRight,false,SparseShape>::ReturnType PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+
+  explicit product_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<Lhs, Rhs, SparseShape, PermutationShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+/** \returns the matrix with the permutation applied to the columns
+  */
+template<typename SparseDerived, typename PermDerived>
+inline const Product<SparseDerived, PermDerived, AliasFreeProduct>
+operator*(const SparseMatrixBase<SparseDerived>& matrix, const PermutationBase<PermDerived>& perm)
+{ return Product<SparseDerived, PermDerived, AliasFreeProduct>(matrix.derived(), perm.derived()); }
+
+/** \returns the matrix with the permutation applied to the rows
+  */
+template<typename SparseDerived, typename PermDerived>
+inline const Product<PermDerived, SparseDerived, AliasFreeProduct>
+operator*( const PermutationBase<PermDerived>& perm, const SparseMatrixBase<SparseDerived>& matrix)
+{ return  Product<PermDerived, SparseDerived, AliasFreeProduct>(perm.derived(), matrix.derived()); }
+
+
+/** \returns the matrix with the inverse permutation applied to the columns.
+  */
+template<typename SparseDerived, typename PermutationType>
+inline const Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>
+operator*(const SparseMatrixBase<SparseDerived>& matrix, const InverseImpl<PermutationType, PermutationStorage>& tperm)
+{
+  return Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>(matrix.derived(), tperm.derived());
+}
+
+/** \returns the matrix with the inverse permutation applied to the rows.
+  */
+template<typename SparseDerived, typename PermutationType>
+inline const Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>
+operator*(const InverseImpl<PermutationType,PermutationStorage>& tperm, const SparseMatrixBase<SparseDerived>& matrix)
+{
+  return Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>(tperm.derived(), matrix.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_SELFADJOINTVIEW_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseProduct.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseProduct.h
new file mode 100644
index 00000000..af8a7744
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseProduct.h
@@ -0,0 +1,181 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEPRODUCT_H
+#define EIGEN_SPARSEPRODUCT_H
+
+namespace Eigen { 
+
+/** \returns an expression of the product of two sparse matrices.
+  * By default a conservative product preserving the symbolic non zeros is performed.
+  * The automatic pruning of the small values can be achieved by calling the pruned() function
+  * in which case a totally different product algorithm is employed:
+  * \code
+  * C = (A*B).pruned();             // suppress numerical zeros (exact)
+  * C = (A*B).pruned(ref);
+  * C = (A*B).pruned(ref,epsilon);
+  * \endcode
+  * where \c ref is a meaningful non zero reference value.
+  * */
+template<typename Derived>
+template<typename OtherDerived>
+inline const Product<Derived,OtherDerived,AliasFreeProduct>
+SparseMatrixBase<Derived>::operator*(const SparseMatrixBase<OtherDerived> &other) const
+{
+  return Product<Derived,OtherDerived,AliasFreeProduct>(derived(), other.derived());
+}
+
+namespace internal {
+
+// sparse * sparse
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    evalTo(dst, lhs, rhs, typename evaluator_traits<Dest>::Shape());
+  }
+
+  // dense += sparse * sparse
+  template<typename Dest,typename ActualLhs>
+  static void addTo(Dest& dst, const ActualLhs& lhs, const Rhs& rhs, typename enable_if<is_same<typename evaluator_traits<Dest>::Shape,DenseShape>::value,int*>::type* = 0)
+  {
+    typedef typename nested_eval<ActualLhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    internal::sparse_sparse_to_dense_product_selector<typename remove_all<LhsNested>::type,
+                                                      typename remove_all<RhsNested>::type, Dest>::run(lhsNested,rhsNested,dst);
+  }
+
+  // dense -= sparse * sparse
+  template<typename Dest>
+  static void subTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, typename enable_if<is_same<typename evaluator_traits<Dest>::Shape,DenseShape>::value,int*>::type* = 0)
+  {
+    addTo(dst, -lhs, rhs);
+  }
+
+protected:
+
+  // sparse = sparse * sparse
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, SparseShape)
+  {
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    internal::conservative_sparse_sparse_product_selector<typename remove_all<LhsNested>::type,
+                                                          typename remove_all<RhsNested>::type, Dest>::run(lhsNested,rhsNested,dst);
+  }
+
+  // dense = sparse * sparse
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, DenseShape)
+  {
+    dst.setZero();
+    addTo(dst, lhs, rhs);
+  }
+};
+
+// sparse * sparse-triangular
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseShape, SparseTriangularShape, ProductType>
+ : public generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
+{};
+
+// sparse-triangular * sparse
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseTriangularShape, SparseShape, ProductType>
+ : public generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
+{};
+
+// dense = sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template< typename DstXprType, typename Lhs, typename Rhs>
+struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
+{
+  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    
+    generic_product_impl<Lhs, Rhs>::evalTo(dst,src.lhs(),src.rhs());
+  }
+};
+
+// dense += sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template< typename DstXprType, typename Lhs, typename Rhs>
+struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::add_assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
+{
+  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
+  {
+    generic_product_impl<Lhs, Rhs>::addTo(dst,src.lhs(),src.rhs());
+  }
+};
+
+// dense -= sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template< typename DstXprType, typename Lhs, typename Rhs>
+struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::sub_assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
+{
+  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
+  {
+    generic_product_impl<Lhs, Rhs>::subTo(dst,src.lhs(),src.rhs());
+  }
+};
+
+template<typename Lhs, typename Rhs, int Options>
+struct unary_evaluator<SparseView<Product<Lhs, Rhs, Options> >, IteratorBased>
+ : public evaluator<typename Product<Lhs, Rhs, DefaultProduct>::PlainObject>
+{
+  typedef SparseView<Product<Lhs, Rhs, Options> > XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  explicit unary_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    using std::abs;
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(xpr.nestedExpression().lhs());
+    RhsNested rhsNested(xpr.nestedExpression().rhs());
+
+    internal::sparse_sparse_product_with_pruning_selector<typename remove_all<LhsNested>::type,
+                                                          typename remove_all<RhsNested>::type, PlainObject>::run(lhsNested,rhsNested,m_result,
+                                                                                                                  abs(xpr.reference())*xpr.epsilon());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+// sparse matrix = sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename Lhs, typename Rhs>
+SparseMatrix<Scalar,_Options,_StorageIndex>& SparseMatrix<Scalar,_Options,_StorageIndex>::operator=(const Product<Lhs,Rhs,AliasFreeProduct>& src)
+{
+  // std::cout << "in Assignment : " << DstOptions << "\n";
+  SparseMatrix dst(src.rows(),src.cols());
+  internal::generic_product_impl<Lhs, Rhs>::evalTo(dst,src.lhs(),src.rhs());
+  this->swap(dst);
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEPRODUCT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseRedux.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseRedux.h
new file mode 100644
index 00000000..45877496
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseRedux.h
@@ -0,0 +1,49 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEREDUX_H
+#define EIGEN_SPARSEREDUX_H
+
+namespace Eigen { 
+
+template<typename Derived>
+typename internal::traits<Derived>::Scalar
+SparseMatrixBase<Derived>::sum() const
+{
+  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
+  Scalar res(0);
+  internal::evaluator<Derived> thisEval(derived());
+  for (Index j=0; j<outerSize(); ++j)
+    for (typename internal::evaluator<Derived>::InnerIterator iter(thisEval,j); iter; ++iter)
+      res += iter.value();
+  return res;
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+typename internal::traits<SparseMatrix<_Scalar,_Options,_Index> >::Scalar
+SparseMatrix<_Scalar,_Options,_Index>::sum() const
+{
+  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
+  if(this->isCompressed())
+    return Matrix<Scalar,1,Dynamic>::Map(m_data.valuePtr(), m_data.size()).sum();
+  else
+    return Base::sum();
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+typename internal::traits<SparseVector<_Scalar,_Options, _Index> >::Scalar
+SparseVector<_Scalar,_Options,_Index>::sum() const
+{
+  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
+  return Matrix<Scalar,1,Dynamic>::Map(m_data.valuePtr(), m_data.size()).sum();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEREDUX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseRef.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseRef.h
new file mode 100644
index 00000000..748f87d6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseRef.h
@@ -0,0 +1,397 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_REF_H
+#define EIGEN_SPARSE_REF_H
+
+namespace Eigen {
+
+enum {
+  StandardCompressedFormat = 2 /**< used by Ref<SparseMatrix> to specify whether the input storage must be in standard compressed form */
+};
+  
+namespace internal {
+
+template<typename Derived> class SparseRefBase;
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  enum {
+    Options = _Options,
+    Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit
+  };
+
+  template<typename Derived> struct match {
+    enum {
+      StorageOrderMatch = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime || ((PlainObjectType::Flags&RowMajorBit)==(Derived::Flags&RowMajorBit)),
+      MatchAtCompileTime = (Derived::Flags&CompressedAccessBit) && StorageOrderMatch
+    };
+    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
+  };
+  
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+{
+  enum {
+    Flags = (traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >::Flags | CompressedAccessBit | NestByRefBit) & ~LvalueBit
+  };
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<SparseVector<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseVector<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  enum {
+    Options = _Options,
+    Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit
+  };
+
+  template<typename Derived> struct match {
+    enum {
+      MatchAtCompileTime = (Derived::Flags&CompressedAccessBit) && Derived::IsVectorAtCompileTime
+    };
+    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
+  };
+
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+{
+  enum {
+    Flags = (traits<SparseVector<MatScalar,MatOptions,MatIndex> >::Flags | CompressedAccessBit | NestByRefBit) & ~LvalueBit
+  };
+};
+
+template<typename Derived>
+struct traits<SparseRefBase<Derived> > : public traits<Derived> {};
+
+template<typename Derived> class SparseRefBase
+  : public SparseMapBase<Derived>
+{
+public:
+
+  typedef SparseMapBase<Derived> Base;
+  EIGEN_SPARSE_PUBLIC_INTERFACE(SparseRefBase)
+
+  SparseRefBase()
+    : Base(RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime, 0, 0, 0, 0, 0)
+  {}
+  
+protected:
+
+  template<typename Expression>
+  void construct(Expression& expr)
+  {
+    if(expr.outerIndexPtr()==0)
+      ::new (static_cast<Base*>(this)) Base(expr.size(), expr.nonZeros(), expr.innerIndexPtr(), expr.valuePtr());
+    else
+      ::new (static_cast<Base*>(this)) Base(expr.rows(), expr.cols(), expr.nonZeros(), expr.outerIndexPtr(), expr.innerIndexPtr(), expr.valuePtr(), expr.innerNonZeroPtr());
+  }
+};
+
+} // namespace internal
+
+
+/** 
+  * \ingroup SparseCore_Module
+  *
+  * \brief A sparse matrix expression referencing an existing sparse expression
+  *
+  * \tparam SparseMatrixType the equivalent sparse matrix type of the referenced data, it must be a template instance of class SparseMatrix.
+  * \tparam Options specifies whether the a standard compressed format is required \c Options is  \c #StandardCompressedFormat, or \c 0.
+  *                The default is \c 0.
+  *
+  * \sa class Ref
+  */
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType >
+  : public internal::SparseRefBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType > >
+#else
+template<typename SparseMatrixType, int Options>
+class Ref<SparseMatrixType, Options>
+  : public SparseMapBase<Derived,WriteAccessors> // yes, that's weird to use Derived here, but that works!
+#endif
+{
+    typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+    typedef internal::traits<Ref> Traits;
+    template<int OtherOptions>
+    inline Ref(const SparseMatrix<MatScalar,OtherOptions,MatIndex>& expr);
+    template<int OtherOptions>
+    inline Ref(const MappedSparseMatrix<MatScalar,OtherOptions,MatIndex>& expr);
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<int OtherOptions>
+    inline Ref(SparseMatrix<MatScalar,OtherOptions,MatIndex>& expr)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseMatrix<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
+      Base::construct(expr.derived());
+    }
+    
+    template<int OtherOptions>
+    inline Ref(MappedSparseMatrix<MatScalar,OtherOptions,MatIndex>& expr)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseMatrix<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
+      Base::construct(expr.derived());
+    }
+    
+    template<typename Derived>
+    inline Ref(const SparseCompressedBase<Derived>& expr)
+    #else
+    /** Implicit constructor from any sparse expression (2D matrix or 1D vector) */
+    template<typename Derived>
+    inline Ref(SparseCompressedBase<Derived>& expr)
+    #endif
+    {
+      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
+      Base::construct(expr.const_cast_derived());
+    }
+};
+
+// this is the const ref version
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public internal::SparseRefBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+{
+    typedef SparseMatrix<MatScalar,MatOptions,MatIndex> TPlainObjectType;
+    typedef internal::traits<Ref> Traits;
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+    template<typename Derived>
+    inline Ref(const SparseMatrixBase<Derived>& expr) : m_hasCopy(false)
+    {
+      construct(expr.derived(), typename Traits::template match<Derived>::type());
+    }
+
+    inline Ref(const Ref& other) : Base(other), m_hasCopy(false) {
+      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
+    }
+
+    template<typename OtherRef>
+    inline Ref(const RefBase<OtherRef>& other) : m_hasCopy(false) {
+      construct(other.derived(), typename Traits::template match<OtherRef>::type());
+    }
+
+    ~Ref() {
+      if(m_hasCopy) {
+        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
+        obj->~TPlainObjectType();
+      }
+    }
+
+  protected:
+
+    template<typename Expression>
+    void construct(const Expression& expr,internal::true_type)
+    {
+      if((Options & int(StandardCompressedFormat)) && (!expr.isCompressed()))
+      {
+        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
+        ::new (obj) TPlainObjectType(expr);
+        m_hasCopy = true;
+        Base::construct(*obj);
+      }
+      else
+      {
+        Base::construct(expr);
+      }
+    }
+
+    template<typename Expression>
+    void construct(const Expression& expr, internal::false_type)
+    {
+      TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
+      ::new (obj) TPlainObjectType(expr);
+      m_hasCopy = true;
+      Base::construct(*obj);
+    }
+
+  protected:
+    typename internal::aligned_storage<sizeof(TPlainObjectType), EIGEN_ALIGNOF(TPlainObjectType)>::type m_storage;
+    bool m_hasCopy;
+};
+
+
+
+/**
+  * \ingroup SparseCore_Module
+  *
+  * \brief A sparse vector expression referencing an existing sparse vector expression
+  *
+  * \tparam SparseVectorType the equivalent sparse vector type of the referenced data, it must be a template instance of class SparseVector.
+  *
+  * \sa class Ref
+  */
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType >
+  : public internal::SparseRefBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType > >
+#else
+template<typename SparseVectorType>
+class Ref<SparseVectorType>
+  : public SparseMapBase<Derived,WriteAccessors>
+#endif
+{
+    typedef SparseVector<MatScalar,MatOptions,MatIndex> PlainObjectType;
+    typedef internal::traits<Ref> Traits;
+    template<int OtherOptions>
+    inline Ref(const SparseVector<MatScalar,OtherOptions,MatIndex>& expr);
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<int OtherOptions>
+    inline Ref(SparseVector<MatScalar,OtherOptions,MatIndex>& expr)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseVector<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      Base::construct(expr.derived());
+    }
+
+    template<typename Derived>
+    inline Ref(const SparseCompressedBase<Derived>& expr)
+    #else
+    /** Implicit constructor from any 1D sparse vector expression */
+    template<typename Derived>
+    inline Ref(SparseCompressedBase<Derived>& expr)
+    #endif
+    {
+      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      Base::construct(expr.const_cast_derived());
+    }
+};
+
+// this is the const ref version
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public internal::SparseRefBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+{
+    typedef SparseVector<MatScalar,MatOptions,MatIndex> TPlainObjectType;
+    typedef internal::traits<Ref> Traits;
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+    template<typename Derived>
+    inline Ref(const SparseMatrixBase<Derived>& expr) : m_hasCopy(false)
+    {
+      construct(expr.derived(), typename Traits::template match<Derived>::type());
+    }
+
+    inline Ref(const Ref& other) : Base(other), m_hasCopy(false) {
+      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
+    }
+
+    template<typename OtherRef>
+    inline Ref(const RefBase<OtherRef>& other) : m_hasCopy(false) {
+      construct(other.derived(), typename Traits::template match<OtherRef>::type());
+    }
+
+    ~Ref() {
+      if(m_hasCopy) {
+        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
+        obj->~TPlainObjectType();
+      }
+    }
+
+  protected:
+
+    template<typename Expression>
+    void construct(const Expression& expr,internal::true_type)
+    {
+      Base::construct(expr);
+    }
+
+    template<typename Expression>
+    void construct(const Expression& expr, internal::false_type)
+    {
+      TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
+      ::new (obj) TPlainObjectType(expr);
+      m_hasCopy = true;
+      Base::construct(*obj);
+    }
+
+  protected:
+    typename internal::aligned_storage<sizeof(TPlainObjectType), EIGEN_ALIGNOF(TPlainObjectType)>::type m_storage;
+    bool m_hasCopy;
+};
+
+namespace internal {
+
+// FIXME shall we introduce a general evaluatior_ref that we can specialize for any sparse object once, and thus remove this copy-pasta thing...
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_REF_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseSelfAdjointView.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseSelfAdjointView.h
new file mode 100644
index 00000000..85b00e10
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseSelfAdjointView.h
@@ -0,0 +1,659 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_SELFADJOINTVIEW_H
+#define EIGEN_SPARSE_SELFADJOINTVIEW_H
+
+namespace Eigen { 
+  
+/** \ingroup SparseCore_Module
+  * \class SparseSelfAdjointView
+  *
+  * \brief Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix.
+  *
+  * \param MatrixType the type of the dense matrix storing the coefficients
+  * \param Mode can be either \c #Lower or \c #Upper
+  *
+  * This class is an expression of a sefladjoint matrix from a triangular part of a matrix
+  * with given dense storage of the coefficients. It is the return type of MatrixBase::selfadjointView()
+  * and most of the time this is the only way that it is used.
+  *
+  * \sa SparseMatrixBase::selfadjointView()
+  */
+namespace internal {
+  
+template<typename MatrixType, unsigned int Mode>
+struct traits<SparseSelfAdjointView<MatrixType,Mode> > : traits<MatrixType> {
+};
+
+template<int SrcMode,int DstMode,typename MatrixType,int DestOrder>
+void permute_symm_to_symm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm = 0);
+
+template<int Mode,typename MatrixType,int DestOrder>
+void permute_symm_to_fullsymm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm = 0);
+
+}
+
+template<typename MatrixType, unsigned int _Mode> class SparseSelfAdjointView
+  : public EigenBase<SparseSelfAdjointView<MatrixType,_Mode> >
+{
+  public:
+    
+    enum {
+      Mode = _Mode,
+      TransposeMode = ((Mode & Upper) ? Lower : 0) | ((Mode & Lower) ? Upper : 0),
+      RowsAtCompileTime = internal::traits<SparseSelfAdjointView>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<SparseSelfAdjointView>::ColsAtCompileTime
+    };
+
+    typedef EigenBase<SparseSelfAdjointView> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+    typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+    typedef typename internal::remove_all<MatrixTypeNested>::type _MatrixTypeNested;
+    
+    explicit inline SparseSelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
+    {
+      eigen_assert(rows()==cols() && "SelfAdjointView is only for squared matrices");
+    }
+
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+
+    /** \internal \returns a reference to the nested matrix */
+    const _MatrixTypeNested& matrix() const { return m_matrix; }
+    typename internal::remove_reference<MatrixTypeNested>::type& matrix() { return m_matrix; }
+
+    /** \returns an expression of the matrix product between a sparse self-adjoint matrix \c *this and a sparse matrix \a rhs.
+      *
+      * Note that there is no algorithmic advantage of performing such a product compared to a general sparse-sparse matrix product.
+      * Indeed, the SparseSelfadjointView operand is first copied into a temporary SparseMatrix before computing the product.
+      */
+    template<typename OtherDerived>
+    Product<SparseSelfAdjointView, OtherDerived>
+    operator*(const SparseMatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<SparseSelfAdjointView, OtherDerived>(*this, rhs.derived());
+    }
+
+    /** \returns an expression of the matrix product between a sparse matrix \a lhs and a sparse self-adjoint matrix \a rhs.
+      *
+      * Note that there is no algorithmic advantage of performing such a product compared to a general sparse-sparse matrix product.
+      * Indeed, the SparseSelfadjointView operand is first copied into a temporary SparseMatrix before computing the product.
+      */
+    template<typename OtherDerived> friend
+    Product<OtherDerived, SparseSelfAdjointView>
+    operator*(const SparseMatrixBase<OtherDerived>& lhs, const SparseSelfAdjointView& rhs)
+    {
+      return Product<OtherDerived, SparseSelfAdjointView>(lhs.derived(), rhs);
+    }
+    
+    /** Efficient sparse self-adjoint matrix times dense vector/matrix product */
+    template<typename OtherDerived>
+    Product<SparseSelfAdjointView,OtherDerived>
+    operator*(const MatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<SparseSelfAdjointView,OtherDerived>(*this, rhs.derived());
+    }
+
+    /** Efficient dense vector/matrix times sparse self-adjoint matrix product */
+    template<typename OtherDerived> friend
+    Product<OtherDerived,SparseSelfAdjointView>
+    operator*(const MatrixBase<OtherDerived>& lhs, const SparseSelfAdjointView& rhs)
+    {
+      return Product<OtherDerived,SparseSelfAdjointView>(lhs.derived(), rhs);
+    }
+
+    /** Perform a symmetric rank K update of the selfadjoint matrix \c *this:
+      * \f$ this = this + \alpha ( u u^* ) \f$ where \a u is a vector or matrix.
+      *
+      * \returns a reference to \c *this
+      *
+      * To perform \f$ this = this + \alpha ( u^* u ) \f$ you can simply
+      * call this function with u.adjoint().
+      */
+    template<typename DerivedU>
+    SparseSelfAdjointView& rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha = Scalar(1));
+    
+    /** \returns an expression of P H P^-1 */
+    // TODO implement twists in a more evaluator friendly fashion
+    SparseSymmetricPermutationProduct<_MatrixTypeNested,Mode> twistedBy(const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& perm) const
+    {
+      return SparseSymmetricPermutationProduct<_MatrixTypeNested,Mode>(m_matrix, perm);
+    }
+
+    template<typename SrcMatrixType,int SrcMode>
+    SparseSelfAdjointView& operator=(const SparseSymmetricPermutationProduct<SrcMatrixType,SrcMode>& permutedMatrix)
+    {
+      internal::call_assignment_no_alias_no_transpose(*this, permutedMatrix);
+      return *this;
+    }
+
+    SparseSelfAdjointView& operator=(const SparseSelfAdjointView& src)
+    {
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> pnull;
+      return *this = src.twistedBy(pnull);
+    }
+
+    // Since we override the copy-assignment operator, we need to explicitly re-declare the copy-constructor
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(SparseSelfAdjointView)
+
+    template<typename SrcMatrixType,unsigned int SrcMode>
+    SparseSelfAdjointView& operator=(const SparseSelfAdjointView<SrcMatrixType,SrcMode>& src)
+    {
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> pnull;
+      return *this = src.twistedBy(pnull);
+    }
+    
+    void resize(Index rows, Index cols)
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(rows);
+      EIGEN_ONLY_USED_FOR_DEBUG(cols);
+      eigen_assert(rows == this->rows() && cols == this->cols()
+                && "SparseSelfadjointView::resize() does not actually allow to resize.");
+    }
+    
+  protected:
+
+    MatrixTypeNested m_matrix;
+    //mutable VectorI m_countPerRow;
+    //mutable VectorI m_countPerCol;
+  private:
+    template<typename Dest> void evalTo(Dest &) const;
+};
+
+/***************************************************************************
+* Implementation of SparseMatrixBase methods
+***************************************************************************/
+
+template<typename Derived>
+template<unsigned int UpLo>
+typename SparseMatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type SparseMatrixBase<Derived>::selfadjointView() const
+{
+  return SparseSelfAdjointView<const Derived, UpLo>(derived());
+}
+
+template<typename Derived>
+template<unsigned int UpLo>
+typename SparseMatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type SparseMatrixBase<Derived>::selfadjointView()
+{
+  return SparseSelfAdjointView<Derived, UpLo>(derived());
+}
+
+/***************************************************************************
+* Implementation of SparseSelfAdjointView methods
+***************************************************************************/
+
+template<typename MatrixType, unsigned int Mode>
+template<typename DerivedU>
+SparseSelfAdjointView<MatrixType,Mode>&
+SparseSelfAdjointView<MatrixType,Mode>::rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha)
+{
+  SparseMatrix<Scalar,(MatrixType::Flags&RowMajorBit)?RowMajor:ColMajor> tmp = u * u.adjoint();
+  if(alpha==Scalar(0))
+    m_matrix = tmp.template triangularView<Mode>();
+  else
+    m_matrix += alpha * tmp.template triangularView<Mode>();
+
+  return *this;
+}
+
+namespace internal {
+  
+// TODO currently a selfadjoint expression has the form SelfAdjointView<.,.>
+//      in the future selfadjoint-ness should be defined by the expression traits
+//      such that Transpose<SelfAdjointView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
+template<typename MatrixType, unsigned int Mode>
+struct evaluator_traits<SparseSelfAdjointView<MatrixType,Mode> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef SparseSelfAdjointShape Shape;
+};
+
+struct SparseSelfAdjoint2Sparse {};
+
+template<> struct AssignmentKind<SparseShape,SparseSelfAdjointShape> { typedef SparseSelfAdjoint2Sparse Kind; };
+template<> struct AssignmentKind<SparseSelfAdjointShape,SparseShape> { typedef Sparse2Sparse Kind; };
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse>
+{
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  typedef internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> AssignOpType;
+
+  template<typename DestScalar,int StorageOrder>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const AssignOpType&/*func*/)
+  {
+    internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), dst);
+  }
+
+  // FIXME: the handling of += and -= in sparse matrices should be cleanup so that next two overloads could be reduced to:
+  template<typename DestScalar,int StorageOrder,typename AssignFunc>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const AssignFunc& func)
+  {
+    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
+    run(tmp, src, AssignOpType());
+    call_assignment_no_alias_no_transpose(dst, tmp, func);
+  }
+
+  template<typename DestScalar,int StorageOrder>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src,
+                  const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>& /* func */)
+  {
+    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
+    run(tmp, src, AssignOpType());
+    dst += tmp;
+  }
+
+  template<typename DestScalar,int StorageOrder>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src,
+                  const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>& /* func */)
+  {
+    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
+    run(tmp, src, AssignOpType());
+    dst -= tmp;
+  }
+  
+  template<typename DestScalar>
+  static void run(DynamicSparseMatrix<DestScalar,ColMajor,StorageIndex>& dst, const SrcXprType &src, const AssignOpType&/*func*/)
+  {
+    // TODO directly evaluate into dst;
+    SparseMatrix<DestScalar,ColMajor,StorageIndex> tmp(dst.rows(),dst.cols());
+    internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), tmp);
+    dst = tmp;
+  }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Implementation of sparse self-adjoint time dense matrix
+***************************************************************************/
+
+namespace internal {
+
+template<int Mode, typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>
+inline void sparse_selfadjoint_time_dense_product(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
+{
+  EIGEN_ONLY_USED_FOR_DEBUG(alpha);
+  
+  typedef typename internal::nested_eval<SparseLhsType,DenseRhsType::MaxColsAtCompileTime>::type SparseLhsTypeNested;
+  typedef typename internal::remove_all<SparseLhsTypeNested>::type SparseLhsTypeNestedCleaned;
+  typedef evaluator<SparseLhsTypeNestedCleaned> LhsEval;
+  typedef typename LhsEval::InnerIterator LhsIterator;
+  typedef typename SparseLhsType::Scalar LhsScalar;
+  
+  enum {
+    LhsIsRowMajor = (LhsEval::Flags&RowMajorBit)==RowMajorBit,
+    ProcessFirstHalf =
+              ((Mode&(Upper|Lower))==(Upper|Lower))
+          || ( (Mode&Upper) && !LhsIsRowMajor)
+          || ( (Mode&Lower) && LhsIsRowMajor),
+    ProcessSecondHalf = !ProcessFirstHalf
+  };
+  
+  SparseLhsTypeNested lhs_nested(lhs);
+  LhsEval lhsEval(lhs_nested);
+
+  // work on one column at once
+  for (Index k=0; k<rhs.cols(); ++k)
+  {
+    for (Index j=0; j<lhs.outerSize(); ++j)
+    {
+      LhsIterator i(lhsEval,j);
+      // handle diagonal coeff
+      if (ProcessSecondHalf)
+      {
+        while (i && i.index()<j) ++i;
+        if(i && i.index()==j)
+        {
+          res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
+          ++i;
+        }
+      }
+
+      // premultiplied rhs for scatters
+      typename ScalarBinaryOpTraits<AlphaType, typename DenseRhsType::Scalar>::ReturnType rhs_j(alpha*rhs(j,k));
+      // accumulator for partial scalar product
+      typename DenseResType::Scalar res_j(0);
+      for(; (ProcessFirstHalf ? i && i.index() < j : i) ; ++i)
+      {
+        LhsScalar lhs_ij = i.value();
+        if(!LhsIsRowMajor) lhs_ij = numext::conj(lhs_ij);
+        res_j += lhs_ij * rhs.coeff(i.index(),k);
+        res(i.index(),k) += numext::conj(lhs_ij) * rhs_j;
+      }
+      res.coeffRef(j,k) += alpha * res_j;
+
+      // handle diagonal coeff
+      if (ProcessFirstHalf && i && (i.index()==j))
+        res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
+    }
+  }
+}
+
+
+template<typename LhsView, typename Rhs, int ProductType>
+struct generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType>
+: generic_product_impl_base<LhsView, Rhs, generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType> >
+{
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const LhsView& lhsView, const Rhs& rhs, const typename Dest::Scalar& alpha)
+  {
+    typedef typename LhsView::_MatrixTypeNested Lhs;
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhsView.matrix());
+    RhsNested rhsNested(rhs);
+    
+    internal::sparse_selfadjoint_time_dense_product<LhsView::Mode>(lhsNested, rhsNested, dst, alpha);
+  }
+};
+
+template<typename Lhs, typename RhsView, int ProductType>
+struct generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType>
+: generic_product_impl_base<Lhs, RhsView, generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType> >
+{
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const RhsView& rhsView, const typename Dest::Scalar& alpha)
+  {
+    typedef typename RhsView::_MatrixTypeNested Rhs;
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhsView.matrix());
+    
+    // transpose everything
+    Transpose<Dest> dstT(dst);
+    internal::sparse_selfadjoint_time_dense_product<RhsView::TransposeMode>(rhsNested.transpose(), lhsNested.transpose(), dstT, alpha);
+  }
+};
+
+// NOTE: these two overloads are needed to evaluate the sparse selfadjoint view into a full sparse matrix
+// TODO: maybe the copy could be handled by generic_product_impl so that these overloads would not be needed anymore
+
+template<typename LhsView, typename Rhs, int ProductTag>
+struct product_evaluator<Product<LhsView, Rhs, DefaultProduct>, ProductTag, SparseSelfAdjointShape, SparseShape>
+  : public evaluator<typename Product<typename Rhs::PlainObject, Rhs, DefaultProduct>::PlainObject>
+{
+  typedef Product<LhsView, Rhs, DefaultProduct> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  product_evaluator(const XprType& xpr)
+    : m_lhs(xpr.lhs()), m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<typename Rhs::PlainObject, Rhs, SparseShape, SparseShape, ProductTag>::evalTo(m_result, m_lhs, xpr.rhs());
+  }
+  
+protected:
+  typename Rhs::PlainObject m_lhs;
+  PlainObject m_result;
+};
+
+template<typename Lhs, typename RhsView, int ProductTag>
+struct product_evaluator<Product<Lhs, RhsView, DefaultProduct>, ProductTag, SparseShape, SparseSelfAdjointShape>
+  : public evaluator<typename Product<Lhs, typename Lhs::PlainObject, DefaultProduct>::PlainObject>
+{
+  typedef Product<Lhs, RhsView, DefaultProduct> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  product_evaluator(const XprType& xpr)
+    : m_rhs(xpr.rhs()), m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<Lhs, typename Lhs::PlainObject, SparseShape, SparseShape, ProductTag>::evalTo(m_result, xpr.lhs(), m_rhs);
+  }
+  
+protected:
+  typename Lhs::PlainObject m_rhs;
+  PlainObject m_result;
+};
+
+} // namespace internal
+
+/***************************************************************************
+* Implementation of symmetric copies and permutations
+***************************************************************************/
+namespace internal {
+
+template<int Mode,typename MatrixType,int DestOrder>
+void permute_symm_to_fullsymm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm)
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef SparseMatrix<Scalar,DestOrder,StorageIndex> Dest;
+  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+  typedef evaluator<MatrixType> MatEval;
+  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
+  
+  MatEval matEval(mat);
+  Dest& dest(_dest.derived());
+  enum {
+    StorageOrderMatch = int(Dest::IsRowMajor) == int(MatrixType::IsRowMajor)
+  };
+  
+  Index size = mat.rows();
+  VectorI count;
+  count.resize(size);
+  count.setZero();
+  dest.resize(size,size);
+  for(Index j = 0; j<size; ++j)
+  {
+    Index jp = perm ? perm[j] : j;
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      Index i = it.index();
+      Index r = it.row();
+      Index c = it.col();
+      Index ip = perm ? perm[i] : i;
+      if(Mode==int(Upper|Lower))
+        count[StorageOrderMatch ? jp : ip]++;
+      else if(r==c)
+        count[ip]++;
+      else if(( Mode==Lower && r>c) || ( Mode==Upper && r<c))
+      {
+        count[ip]++;
+        count[jp]++;
+      }
+    }
+  }
+  Index nnz = count.sum();
+  
+  // reserve space
+  dest.resizeNonZeros(nnz);
+  dest.outerIndexPtr()[0] = 0;
+  for(Index j=0; j<size; ++j)
+    dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
+  for(Index j=0; j<size; ++j)
+    count[j] = dest.outerIndexPtr()[j];
+  
+  // copy data
+  for(StorageIndex j = 0; j<size; ++j)
+  {
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      StorageIndex i = internal::convert_index<StorageIndex>(it.index());
+      Index r = it.row();
+      Index c = it.col();
+      
+      StorageIndex jp = perm ? perm[j] : j;
+      StorageIndex ip = perm ? perm[i] : i;
+      
+      if(Mode==int(Upper|Lower))
+      {
+        Index k = count[StorageOrderMatch ? jp : ip]++;
+        dest.innerIndexPtr()[k] = StorageOrderMatch ? ip : jp;
+        dest.valuePtr()[k] = it.value();
+      }
+      else if(r==c)
+      {
+        Index k = count[ip]++;
+        dest.innerIndexPtr()[k] = ip;
+        dest.valuePtr()[k] = it.value();
+      }
+      else if(( (Mode&Lower)==Lower && r>c) || ( (Mode&Upper)==Upper && r<c))
+      {
+        if(!StorageOrderMatch)
+          std::swap(ip,jp);
+        Index k = count[jp]++;
+        dest.innerIndexPtr()[k] = ip;
+        dest.valuePtr()[k] = it.value();
+        k = count[ip]++;
+        dest.innerIndexPtr()[k] = jp;
+        dest.valuePtr()[k] = numext::conj(it.value());
+      }
+    }
+  }
+}
+
+template<int _SrcMode,int _DstMode,typename MatrixType,int DstOrder>
+void permute_symm_to_symm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DstOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm)
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef typename MatrixType::Scalar Scalar;
+  SparseMatrix<Scalar,DstOrder,StorageIndex>& dest(_dest.derived());
+  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+  typedef evaluator<MatrixType> MatEval;
+  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
+
+  enum {
+    SrcOrder = MatrixType::IsRowMajor ? RowMajor : ColMajor,
+    StorageOrderMatch = int(SrcOrder) == int(DstOrder),
+    DstMode = DstOrder==RowMajor ? (_DstMode==Upper ? Lower : Upper) : _DstMode,
+    SrcMode = SrcOrder==RowMajor ? (_SrcMode==Upper ? Lower : Upper) : _SrcMode
+  };
+
+  MatEval matEval(mat);
+  
+  Index size = mat.rows();
+  VectorI count(size);
+  count.setZero();
+  dest.resize(size,size);
+  for(StorageIndex j = 0; j<size; ++j)
+  {
+    StorageIndex jp = perm ? perm[j] : j;
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
+        continue;
+                  
+      StorageIndex ip = perm ? perm[i] : i;
+      count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
+    }
+  }
+  dest.outerIndexPtr()[0] = 0;
+  for(Index j=0; j<size; ++j)
+    dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
+  dest.resizeNonZeros(dest.outerIndexPtr()[size]);
+  for(Index j=0; j<size; ++j)
+    count[j] = dest.outerIndexPtr()[j];
+  
+  for(StorageIndex j = 0; j<size; ++j)
+  {
+    
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
+        continue;
+                  
+      StorageIndex jp = perm ? perm[j] : j;
+      StorageIndex ip = perm? perm[i] : i;
+      
+      Index k = count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
+      dest.innerIndexPtr()[k] = int(DstMode)==int(Lower) ? (std::max)(ip,jp) : (std::min)(ip,jp);
+      
+      if(!StorageOrderMatch) std::swap(ip,jp);
+      if( ((int(DstMode)==int(Lower) && ip<jp) || (int(DstMode)==int(Upper) && ip>jp)))
+        dest.valuePtr()[k] = numext::conj(it.value());
+      else
+        dest.valuePtr()[k] = it.value();
+    }
+  }
+}
+
+}
+
+// TODO implement twists in a more evaluator friendly fashion
+
+namespace internal {
+
+template<typename MatrixType, int Mode>
+struct traits<SparseSymmetricPermutationProduct<MatrixType,Mode> > : traits<MatrixType> {
+};
+
+}
+
+template<typename MatrixType,int Mode>
+class SparseSymmetricPermutationProduct
+  : public EigenBase<SparseSymmetricPermutationProduct<MatrixType,Mode> >
+{
+  public:
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    enum {
+      RowsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::ColsAtCompileTime
+    };
+  protected:
+    typedef PermutationMatrix<Dynamic,Dynamic,StorageIndex> Perm;
+  public:
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+    typedef typename MatrixType::Nested MatrixTypeNested;
+    typedef typename internal::remove_all<MatrixTypeNested>::type NestedExpression;
+    
+    SparseSymmetricPermutationProduct(const MatrixType& mat, const Perm& perm)
+      : m_matrix(mat), m_perm(perm)
+    {}
+    
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+        
+    const NestedExpression& matrix() const { return m_matrix; }
+    const Perm& perm() const { return m_perm; }
+    
+  protected:
+    MatrixTypeNested m_matrix;
+    const Perm& m_perm;
+
+};
+
+namespace internal {
+  
+template<typename DstXprType, typename MatrixType, int Mode, typename Scalar>
+struct Assignment<DstXprType, SparseSymmetricPermutationProduct<MatrixType,Mode>, internal::assign_op<Scalar,typename MatrixType::Scalar>, Sparse2Sparse>
+{
+  typedef SparseSymmetricPermutationProduct<MatrixType,Mode> SrcXprType;
+  typedef typename DstXprType::StorageIndex DstIndex;
+  template<int Options>
+  static void run(SparseMatrix<Scalar,Options,DstIndex> &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename MatrixType::Scalar> &)
+  {
+    // internal::permute_symm_to_fullsymm<Mode>(m_matrix,_dest,m_perm.indices().data());
+    SparseMatrix<Scalar,(Options&RowMajor)==RowMajor ? ColMajor : RowMajor, DstIndex> tmp;
+    internal::permute_symm_to_fullsymm<Mode>(src.matrix(),tmp,src.perm().indices().data());
+    dst = tmp;
+  }
+  
+  template<typename DestType,unsigned int DestMode>
+  static void run(SparseSelfAdjointView<DestType,DestMode>& dst, const SrcXprType &src, const internal::assign_op<Scalar,typename MatrixType::Scalar> &)
+  {
+    internal::permute_symm_to_symm<Mode,DestMode>(src.matrix(),dst.matrix(),src.perm().indices().data());
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_SELFADJOINTVIEW_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseSolverBase.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseSolverBase.h
new file mode 100644
index 00000000..b4c9a422
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseSolverBase.h
@@ -0,0 +1,124 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSESOLVERBASE_H
+#define EIGEN_SPARSESOLVERBASE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+  /** \internal
+  * Helper functions to solve with a sparse right-hand-side and result.
+  * The rhs is decomposed into small vertical panels which are solved through dense temporaries.
+  */
+template<typename Decomposition, typename Rhs, typename Dest>
+typename enable_if<Rhs::ColsAtCompileTime!=1 && Dest::ColsAtCompileTime!=1>::type
+solve_sparse_through_dense_panels(const Decomposition &dec, const Rhs& rhs, Dest &dest)
+{
+  EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  typedef typename Dest::Scalar DestScalar;
+  // we process the sparse rhs per block of NbColsAtOnce columns temporarily stored into a dense matrix.
+  static const Index NbColsAtOnce = 4;
+  Index rhsCols = rhs.cols();
+  Index size = rhs.rows();
+  // the temporary matrices do not need more columns than NbColsAtOnce:
+  Index tmpCols = (std::min)(rhsCols, NbColsAtOnce); 
+  Eigen::Matrix<DestScalar,Dynamic,Dynamic> tmp(size,tmpCols);
+  Eigen::Matrix<DestScalar,Dynamic,Dynamic> tmpX(size,tmpCols);
+  for(Index k=0; k<rhsCols; k+=NbColsAtOnce)
+  {
+    Index actualCols = std::min<Index>(rhsCols-k, NbColsAtOnce);
+    tmp.leftCols(actualCols) = rhs.middleCols(k,actualCols);
+    tmpX.leftCols(actualCols) = dec.solve(tmp.leftCols(actualCols));
+    dest.middleCols(k,actualCols) = tmpX.leftCols(actualCols).sparseView();
+  }
+}
+
+// Overload for vector as rhs
+template<typename Decomposition, typename Rhs, typename Dest>
+typename enable_if<Rhs::ColsAtCompileTime==1 || Dest::ColsAtCompileTime==1>::type
+solve_sparse_through_dense_panels(const Decomposition &dec, const Rhs& rhs, Dest &dest)
+{
+  typedef typename Dest::Scalar DestScalar;
+  Index size = rhs.rows();
+  Eigen::Matrix<DestScalar,Dynamic,1> rhs_dense(rhs);
+  Eigen::Matrix<DestScalar,Dynamic,1> dest_dense(size);
+  dest_dense = dec.solve(rhs_dense);
+  dest = dest_dense.sparseView();
+}
+
+} // end namespace internal
+
+/** \class SparseSolverBase
+  * \ingroup SparseCore_Module
+  * \brief A base class for sparse solvers
+  *
+  * \tparam Derived the actual type of the solver.
+  *
+  */
+template<typename Derived>
+class SparseSolverBase : internal::noncopyable
+{
+  public:
+
+    /** Default constructor */
+    SparseSolverBase()
+      : m_isInitialized(false)
+    {}
+
+    ~SparseSolverBase()
+    {}
+
+    Derived& derived() { return *static_cast<Derived*>(this); }
+    const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    
+    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<Derived, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "Solver is not initialized.");
+      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<Derived, Rhs>(derived(), b.derived());
+    }
+    
+    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<Derived, Rhs>
+    solve(const SparseMatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "Solver is not initialized.");
+      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<Derived, Rhs>(derived(), b.derived());
+    }
+    
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal default implementation of solving with a sparse rhs */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const SparseMatrixBase<Rhs> &b, SparseMatrixBase<Dest> &dest) const
+    {
+      internal::solve_sparse_through_dense_panels(derived(), b.derived(), dest.derived());
+    }
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+
+  protected:
+    
+    mutable bool m_isInitialized;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSESOLVERBASE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseSparseProductWithPruning.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseSparseProductWithPruning.h
new file mode 100644
index 00000000..88820a48
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseSparseProductWithPruning.h
@@ -0,0 +1,198 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
+#define EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+// perform a pseudo in-place sparse * sparse product assuming all matrices are col major
+template<typename Lhs, typename Rhs, typename ResultType>
+static void sparse_sparse_product_with_pruning_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res, const typename ResultType::RealScalar& tolerance)
+{
+  // return sparse_sparse_product_with_pruning_impl2(lhs,rhs,res);
+
+  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
+  typedef typename remove_all<ResultType>::type::Scalar ResScalar;
+  typedef typename remove_all<Lhs>::type::StorageIndex StorageIndex;
+
+  // make sure to call innerSize/outerSize since we fake the storage order.
+  Index rows = lhs.innerSize();
+  Index cols = rhs.outerSize();
+  //Index size = lhs.outerSize();
+  eigen_assert(lhs.outerSize() == rhs.innerSize());
+
+  // allocate a temporary buffer
+  AmbiVector<ResScalar,StorageIndex> tempVector(rows);
+
+  // mimics a resizeByInnerOuter:
+  if(ResultType::IsRowMajor)
+    res.resize(cols, rows);
+  else
+    res.resize(rows, cols);
+  
+  evaluator<Lhs> lhsEval(lhs);
+  evaluator<Rhs> rhsEval(rhs);
+  
+  // estimate the number of non zero entries
+  // given a rhs column containing Y non zeros, we assume that the respective Y columns
+  // of the lhs differs in average of one non zeros, thus the number of non zeros for
+  // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
+  // per column of the lhs.
+  // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
+  Index estimated_nnz_prod = lhsEval.nonZerosEstimate() + rhsEval.nonZerosEstimate();
+
+  res.reserve(estimated_nnz_prod);
+  double ratioColRes = double(estimated_nnz_prod)/(double(lhs.rows())*double(rhs.cols()));
+  for (Index j=0; j<cols; ++j)
+  {
+    // FIXME:
+    //double ratioColRes = (double(rhs.innerVector(j).nonZeros()) + double(lhs.nonZeros())/double(lhs.cols()))/double(lhs.rows());
+    // let's do a more accurate determination of the nnz ratio for the current column j of res
+    tempVector.init(ratioColRes);
+    tempVector.setZero();
+    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
+    {
+      // FIXME should be written like this: tmp += rhsIt.value() * lhs.col(rhsIt.index())
+      tempVector.restart();
+      RhsScalar x = rhsIt.value();
+      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, rhsIt.index()); lhsIt; ++lhsIt)
+      {
+        tempVector.coeffRef(lhsIt.index()) += lhsIt.value() * x;
+      }
+    }
+    res.startVec(j);
+    for (typename AmbiVector<ResScalar,StorageIndex>::Iterator it(tempVector,tolerance); it; ++it)
+      res.insertBackByOuterInner(j,it.index()) = it.value();
+  }
+  res.finalize();
+}
+
+template<typename Lhs, typename Rhs, typename ResultType,
+  int LhsStorageOrder = traits<Lhs>::Flags&RowMajorBit,
+  int RhsStorageOrder = traits<Rhs>::Flags&RowMajorBit,
+  int ResStorageOrder = traits<ResultType>::Flags&RowMajorBit>
+struct sparse_sparse_product_with_pruning_selector;
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typename remove_all<ResultType>::type _res(res.rows(), res.cols());
+    internal::sparse_sparse_product_with_pruning_impl<Lhs,Rhs,ResultType>(lhs, rhs, _res, tolerance);
+    res.swap(_res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    // we need a col-major matrix to hold the result
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> SparseTemporaryType;
+    SparseTemporaryType _res(res.rows(), res.cols());
+    internal::sparse_sparse_product_with_pruning_impl<Lhs,Rhs,SparseTemporaryType>(lhs, rhs, _res, tolerance);
+    res = _res;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    // let's transpose the product to get a column x column product
+    typename remove_all<ResultType>::type _res(res.rows(), res.cols());
+    internal::sparse_sparse_product_with_pruning_impl<Rhs,Lhs,ResultType>(rhs, lhs, _res, tolerance);
+    res.swap(_res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixLhs;
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixRhs;
+    ColMajorMatrixLhs colLhs(lhs);
+    ColMajorMatrixRhs colRhs(rhs);
+    internal::sparse_sparse_product_with_pruning_impl<ColMajorMatrixLhs,ColMajorMatrixRhs,ResultType>(colLhs, colRhs, res, tolerance);
+
+    // let's transpose the product to get a column x column product
+//     typedef SparseMatrix<typename ResultType::Scalar> SparseTemporaryType;
+//     SparseTemporaryType _res(res.cols(), res.rows());
+//     sparse_sparse_product_with_pruning_impl<Rhs,Lhs,SparseTemporaryType>(rhs, lhs, _res);
+//     res = _res.transpose();
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,RowMajor,typename Lhs::StorageIndex> RowMajorMatrixLhs;
+    RowMajorMatrixLhs rowLhs(lhs);
+    sparse_sparse_product_with_pruning_selector<RowMajorMatrixLhs,Rhs,ResultType,RowMajor,RowMajor>(rowLhs,rhs,res,tolerance);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,RowMajor,typename Lhs::StorageIndex> RowMajorMatrixRhs;
+    RowMajorMatrixRhs rowRhs(rhs);
+    sparse_sparse_product_with_pruning_selector<Lhs,RowMajorMatrixRhs,ResultType,RowMajor,RowMajor,RowMajor>(lhs,rowRhs,res,tolerance);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixRhs;
+    ColMajorMatrixRhs colRhs(rhs);
+    internal::sparse_sparse_product_with_pruning_impl<Lhs,ColMajorMatrixRhs,ResultType>(lhs, colRhs, res, tolerance);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixLhs;
+    ColMajorMatrixLhs colLhs(lhs);
+    internal::sparse_sparse_product_with_pruning_impl<ColMajorMatrixLhs,Rhs,ResultType>(colLhs, rhs, res, tolerance);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseTranspose.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseTranspose.h
new file mode 100644
index 00000000..3757d4c6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseTranspose.h
@@ -0,0 +1,92 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSETRANSPOSE_H
+#define EIGEN_SPARSETRANSPOSE_H
+
+namespace Eigen { 
+
+namespace internal {
+  template<typename MatrixType,int CompressedAccess=int(MatrixType::Flags&CompressedAccessBit)>
+  class SparseTransposeImpl
+    : public SparseMatrixBase<Transpose<MatrixType> >
+  {};
+  
+  template<typename MatrixType>
+  class SparseTransposeImpl<MatrixType,CompressedAccessBit>
+    : public SparseCompressedBase<Transpose<MatrixType> >
+  {
+    typedef SparseCompressedBase<Transpose<MatrixType> > Base;
+  public:
+    using Base::derived;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::StorageIndex StorageIndex;
+
+    inline Index nonZeros() const { return derived().nestedExpression().nonZeros(); }
+    
+    inline const Scalar* valuePtr() const { return derived().nestedExpression().valuePtr(); }
+    inline const StorageIndex* innerIndexPtr() const { return derived().nestedExpression().innerIndexPtr(); }
+    inline const StorageIndex* outerIndexPtr() const { return derived().nestedExpression().outerIndexPtr(); }
+    inline const StorageIndex* innerNonZeroPtr() const { return derived().nestedExpression().innerNonZeroPtr(); }
+
+    inline Scalar* valuePtr() { return derived().nestedExpression().valuePtr(); }
+    inline StorageIndex* innerIndexPtr() { return derived().nestedExpression().innerIndexPtr(); }
+    inline StorageIndex* outerIndexPtr() { return derived().nestedExpression().outerIndexPtr(); }
+    inline StorageIndex* innerNonZeroPtr() { return derived().nestedExpression().innerNonZeroPtr(); }
+  };
+}
+  
+template<typename MatrixType> class TransposeImpl<MatrixType,Sparse>
+  : public internal::SparseTransposeImpl<MatrixType>
+{
+  protected:
+    typedef internal::SparseTransposeImpl<MatrixType> Base;
+};
+
+namespace internal {
+  
+template<typename ArgType>
+struct unary_evaluator<Transpose<ArgType>, IteratorBased>
+  : public evaluator_base<Transpose<ArgType> >
+{
+    typedef typename evaluator<ArgType>::InnerIterator        EvalIterator;
+  public:
+    typedef Transpose<ArgType> XprType;
+    
+    inline Index nonZerosEstimate() const {
+      return m_argImpl.nonZerosEstimate();
+    }
+
+    class InnerIterator : public EvalIterator
+    {
+    public:
+      EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
+        : EvalIterator(unaryOp.m_argImpl,outer)
+      {}
+      
+      Index row() const { return EvalIterator::col(); }
+      Index col() const { return EvalIterator::row(); }
+    };
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& op) :m_argImpl(op.nestedExpression()) {}
+
+  protected:
+    evaluator<ArgType> m_argImpl;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSETRANSPOSE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseTriangularView.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseTriangularView.h
new file mode 100644
index 00000000..9ac12026
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseTriangularView.h
@@ -0,0 +1,189 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_TRIANGULARVIEW_H
+#define EIGEN_SPARSE_TRIANGULARVIEW_H
+
+namespace Eigen {
+
+/** \ingroup SparseCore_Module
+  *
+  * \brief Base class for a triangular part in a \b sparse matrix
+  *
+  * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be instantiated.
+  * It extends class TriangularView with additional methods which are available for sparse expressions only.
+  *
+  * \sa class TriangularView, SparseMatrixBase::triangularView()
+  */
+template<typename MatrixType, unsigned int Mode> class TriangularViewImpl<MatrixType,Mode,Sparse>
+  : public SparseMatrixBase<TriangularView<MatrixType,Mode> >
+{
+    enum { SkipFirst = ((Mode&Lower) && !(MatrixType::Flags&RowMajorBit))
+                    || ((Mode&Upper) &&  (MatrixType::Flags&RowMajorBit)),
+           SkipLast = !SkipFirst,
+           SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
+           HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
+    };
+    
+    typedef TriangularView<MatrixType,Mode> TriangularViewType;
+    
+  protected:
+    // dummy solve function to make TriangularView happy.
+    void solve() const;
+
+    typedef SparseMatrixBase<TriangularViewType> Base;
+  public:
+    
+    EIGEN_SPARSE_PUBLIC_INTERFACE(TriangularViewType)
+    
+    typedef typename MatrixType::Nested MatrixTypeNested;
+    typedef typename internal::remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
+    typedef typename internal::remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
+
+    template<typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _solve_impl(const RhsType &rhs, DstType &dst) const {
+      if(!(internal::is_same<RhsType,DstType>::value && internal::extract_data(dst) == internal::extract_data(rhs)))
+        dst = rhs;
+      this->solveInPlace(dst);
+    }
+
+    /** Applies the inverse of \c *this to the dense vector or matrix \a other, "in-place" */
+    template<typename OtherDerived> void solveInPlace(MatrixBase<OtherDerived>& other) const;
+
+    /** Applies the inverse of \c *this to the sparse vector or matrix \a other, "in-place" */
+    template<typename OtherDerived> void solveInPlace(SparseMatrixBase<OtherDerived>& other) const;
+  
+};
+
+namespace internal {
+
+template<typename ArgType, unsigned int Mode>
+struct unary_evaluator<TriangularView<ArgType,Mode>, IteratorBased>
+ : evaluator_base<TriangularView<ArgType,Mode> >
+{
+  typedef TriangularView<ArgType,Mode> XprType;
+  
+protected:
+  
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  
+  enum { SkipFirst = ((Mode&Lower) && !(ArgType::Flags&RowMajorBit))
+                    || ((Mode&Upper) &&  (ArgType::Flags&RowMajorBit)),
+         SkipLast = !SkipFirst,
+         SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
+         HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
+  };
+  
+public:
+  
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    Flags = XprType::Flags
+  };
+    
+  explicit unary_evaluator(const XprType &xpr) : m_argImpl(xpr.nestedExpression()), m_arg(xpr.nestedExpression()) {}
+  
+  inline Index nonZerosEstimate() const {
+    return m_argImpl.nonZerosEstimate();
+  }
+  
+  class InnerIterator : public EvalIterator
+  {
+      typedef EvalIterator Base;
+    public:
+
+      EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& xprEval, Index outer)
+        : Base(xprEval.m_argImpl,outer), m_returnOne(false), m_containsDiag(Base::outer()<xprEval.m_arg.innerSize())
+      {
+        if(SkipFirst)
+        {
+          while((*this) && ((HasUnitDiag||SkipDiag)  ? this->index()<=outer : this->index()<outer))
+            Base::operator++();
+          if(HasUnitDiag)
+            m_returnOne = m_containsDiag;
+        }
+        else if(HasUnitDiag && ((!Base::operator bool()) || Base::index()>=Base::outer()))
+        {
+          if((!SkipFirst) && Base::operator bool())
+            Base::operator++();
+          m_returnOne = m_containsDiag;
+        }
+      }
+
+      EIGEN_STRONG_INLINE InnerIterator& operator++()
+      {
+        if(HasUnitDiag && m_returnOne)
+          m_returnOne = false;
+        else
+        {
+          Base::operator++();
+          if(HasUnitDiag && (!SkipFirst) && ((!Base::operator bool()) || Base::index()>=Base::outer()))
+          {
+            if((!SkipFirst) && Base::operator bool())
+              Base::operator++();
+            m_returnOne = m_containsDiag;
+          }
+        }
+        return *this;
+      }
+      
+      EIGEN_STRONG_INLINE operator bool() const
+      {
+        if(HasUnitDiag && m_returnOne)
+          return true;
+        if(SkipFirst) return  Base::operator bool();
+        else
+        {
+          if (SkipDiag) return (Base::operator bool() && this->index() < this->outer());
+          else return (Base::operator bool() && this->index() <= this->outer());
+        }
+      }
+
+//       inline Index row() const { return (ArgType::Flags&RowMajorBit ? Base::outer() : this->index()); }
+//       inline Index col() const { return (ArgType::Flags&RowMajorBit ? this->index() : Base::outer()); }
+      inline StorageIndex index() const
+      {
+        if(HasUnitDiag && m_returnOne)  return internal::convert_index<StorageIndex>(Base::outer());
+        else                            return Base::index();
+      }
+      inline Scalar value() const
+      {
+        if(HasUnitDiag && m_returnOne)  return Scalar(1);
+        else                            return Base::value();
+      }
+
+    protected:
+      bool m_returnOne;
+      bool m_containsDiag;
+    private:
+      Scalar& valueRef();
+  };
+  
+protected:
+  evaluator<ArgType> m_argImpl;
+  const ArgType& m_arg;
+};
+
+} // end namespace internal
+
+template<typename Derived>
+template<int Mode>
+inline const TriangularView<const Derived, Mode>
+SparseMatrixBase<Derived>::triangularView() const
+{
+  return TriangularView<const Derived, Mode>(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_TRIANGULARVIEW_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseUtil.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseUtil.h
new file mode 100644
index 00000000..ceb93688
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseUtil.h
@@ -0,0 +1,186 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEUTIL_H
+#define EIGEN_SPARSEUTIL_H
+
+namespace Eigen { 
+
+#ifdef NDEBUG
+#define EIGEN_DBG_SPARSE(X)
+#else
+#define EIGEN_DBG_SPARSE(X) X
+#endif
+
+#define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, Op) \
+template<typename OtherDerived> \
+EIGEN_STRONG_INLINE Derived& operator Op(const Eigen::SparseMatrixBase<OtherDerived>& other) \
+{ \
+  return Base::operator Op(other.derived()); \
+} \
+EIGEN_STRONG_INLINE Derived& operator Op(const Derived& other) \
+{ \
+  return Base::operator Op(other); \
+}
+
+#define EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, Op) \
+template<typename Other> \
+EIGEN_STRONG_INLINE Derived& operator Op(const Other& scalar) \
+{ \
+  return Base::operator Op(scalar); \
+}
+
+#define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATORS(Derived) \
+EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, =)
+
+
+#define EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) \
+  EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)
+
+  
+const int CoherentAccessPattern     = 0x1;
+const int InnerRandomAccessPattern  = 0x2 | CoherentAccessPattern;
+const int OuterRandomAccessPattern  = 0x4 | CoherentAccessPattern;
+const int RandomAccessPattern       = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern;
+
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class SparseMatrix;
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class DynamicSparseMatrix;
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class SparseVector;
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class MappedSparseMatrix;
+
+template<typename MatrixType, unsigned int UpLo>  class SparseSelfAdjointView;
+template<typename Lhs, typename Rhs>              class SparseDiagonalProduct;
+template<typename MatrixType> class SparseView;
+
+template<typename Lhs, typename Rhs>        class SparseSparseProduct;
+template<typename Lhs, typename Rhs>        class SparseTimeDenseProduct;
+template<typename Lhs, typename Rhs>        class DenseTimeSparseProduct;
+template<typename Lhs, typename Rhs, bool Transpose> class SparseDenseOuterProduct;
+
+template<typename Lhs, typename Rhs> struct SparseSparseProductReturnType;
+template<typename Lhs, typename Rhs,
+         int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct DenseSparseProductReturnType;
+         
+template<typename Lhs, typename Rhs,
+         int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct SparseDenseProductReturnType;
+template<typename MatrixType,int UpLo> class SparseSymmetricPermutationProduct;
+
+namespace internal {
+
+template<typename T,int Rows,int Cols,int Flags> struct sparse_eval;
+
+template<typename T> struct eval<T,Sparse>
+  : sparse_eval<T, traits<T>::RowsAtCompileTime,traits<T>::ColsAtCompileTime,traits<T>::Flags>
+{};
+
+template<typename T,int Cols,int Flags> struct sparse_eval<T,1,Cols,Flags> {
+    typedef typename traits<T>::Scalar _Scalar;
+    typedef typename traits<T>::StorageIndex _StorageIndex;
+  public:
+    typedef SparseVector<_Scalar, RowMajor, _StorageIndex> type;
+};
+
+template<typename T,int Rows,int Flags> struct sparse_eval<T,Rows,1,Flags> {
+    typedef typename traits<T>::Scalar _Scalar;
+    typedef typename traits<T>::StorageIndex _StorageIndex;
+  public:
+    typedef SparseVector<_Scalar, ColMajor, _StorageIndex> type;
+};
+
+// TODO this seems almost identical to plain_matrix_type<T, Sparse>
+template<typename T,int Rows,int Cols,int Flags> struct sparse_eval {
+    typedef typename traits<T>::Scalar _Scalar;
+    typedef typename traits<T>::StorageIndex _StorageIndex;
+    enum { _Options = ((Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor };
+  public:
+    typedef SparseMatrix<_Scalar, _Options, _StorageIndex> type;
+};
+
+template<typename T,int Flags> struct sparse_eval<T,1,1,Flags> {
+    typedef typename traits<T>::Scalar _Scalar;
+  public:
+    typedef Matrix<_Scalar, 1, 1> type;
+};
+
+template<typename T> struct plain_matrix_type<T,Sparse>
+{
+  typedef typename traits<T>::Scalar _Scalar;
+  typedef typename traits<T>::StorageIndex _StorageIndex;
+  enum { _Options = ((evaluator<T>::Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor };
+  public:
+    typedef SparseMatrix<_Scalar, _Options, _StorageIndex> type;
+};
+
+template<typename T>
+struct plain_object_eval<T,Sparse>
+  : sparse_eval<T, traits<T>::RowsAtCompileTime,traits<T>::ColsAtCompileTime, evaluator<T>::Flags>
+{};
+
+template<typename Decomposition, typename RhsType>
+struct solve_traits<Decomposition,RhsType,Sparse>
+{
+  typedef typename sparse_eval<RhsType, RhsType::RowsAtCompileTime, RhsType::ColsAtCompileTime,traits<RhsType>::Flags>::type PlainObject;
+};
+
+template<typename Derived>
+struct generic_xpr_base<Derived, MatrixXpr, Sparse>
+{
+  typedef SparseMatrixBase<Derived> type;
+};
+
+struct SparseTriangularShape  { static std::string debugName() { return "SparseTriangularShape"; } };
+struct SparseSelfAdjointShape { static std::string debugName() { return "SparseSelfAdjointShape"; } };
+
+template<> struct glue_shapes<SparseShape,SelfAdjointShape> { typedef SparseSelfAdjointShape type;  };
+template<> struct glue_shapes<SparseShape,TriangularShape > { typedef SparseTriangularShape  type;  };
+
+// return type of SparseCompressedBase::lower_bound;
+struct LowerBoundIndex {
+  LowerBoundIndex() : value(-1), found(false) {}
+  LowerBoundIndex(Index val, bool ok) : value(val), found(ok) {}
+  Index value;
+  bool found;
+};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  *
+  * \class Triplet
+  *
+  * \brief A small structure to hold a non zero as a triplet (i,j,value).
+  *
+  * \sa SparseMatrix::setFromTriplets()
+  */
+template<typename Scalar, typename StorageIndex=typename SparseMatrix<Scalar>::StorageIndex >
+class Triplet
+{
+public:
+  Triplet() : m_row(0), m_col(0), m_value(0) {}
+
+  Triplet(const StorageIndex& i, const StorageIndex& j, const Scalar& v = Scalar(0))
+    : m_row(i), m_col(j), m_value(v)
+  {}
+
+  /** \returns the row index of the element */
+  const StorageIndex& row() const { return m_row; }
+
+  /** \returns the column index of the element */
+  const StorageIndex& col() const { return m_col; }
+
+  /** \returns the value of the element */
+  const Scalar& value() const { return m_value; }
+protected:
+  StorageIndex m_row, m_col;
+  Scalar m_value;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEUTIL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseVector.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseVector.h
new file mode 100644
index 00000000..05779be6
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseVector.h
@@ -0,0 +1,478 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEVECTOR_H
+#define EIGEN_SPARSEVECTOR_H
+
+namespace Eigen { 
+
+/** \ingroup SparseCore_Module
+  * \class SparseVector
+  *
+  * \brief a sparse vector class
+  *
+  * \tparam _Scalar the scalar type, i.e. the type of the coefficients
+  *
+  * See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_SPARSEVECTOR_PLUGIN.
+  */
+
+namespace internal {
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct traits<SparseVector<_Scalar, _Options, _StorageIndex> >
+{
+  typedef _Scalar Scalar;
+  typedef _StorageIndex StorageIndex;
+  typedef Sparse StorageKind;
+  typedef MatrixXpr XprKind;
+  enum {
+    IsColVector = (_Options & RowMajorBit) ? 0 : 1,
+
+    RowsAtCompileTime = IsColVector ? Dynamic : 1,
+    ColsAtCompileTime = IsColVector ? 1 : Dynamic,
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    Flags = _Options | NestByRefBit | LvalueBit | (IsColVector ? 0 : RowMajorBit) | CompressedAccessBit,
+    SupportedAccessPatterns = InnerRandomAccessPattern
+  };
+};
+
+// Sparse-Vector-Assignment kinds:
+enum {
+  SVA_RuntimeSwitch,
+  SVA_Inner,
+  SVA_Outer
+};
+
+template< typename Dest, typename Src,
+          int AssignmentKind = !bool(Src::IsVectorAtCompileTime) ? SVA_RuntimeSwitch
+                             : Src::InnerSizeAtCompileTime==1 ? SVA_Outer
+                             : SVA_Inner>
+struct sparse_vector_assign_selector;
+
+}
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+class SparseVector
+  : public SparseCompressedBase<SparseVector<_Scalar, _Options, _StorageIndex> >
+{
+    typedef SparseCompressedBase<SparseVector> Base;
+    using Base::convert_index;
+  public:
+    EIGEN_SPARSE_PUBLIC_INTERFACE(SparseVector)
+    EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(SparseVector, +=)
+    EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(SparseVector, -=)
+    
+    typedef internal::CompressedStorage<Scalar,StorageIndex> Storage;
+    enum { IsColVector = internal::traits<SparseVector>::IsColVector };
+    
+    enum {
+      Options = _Options
+    };
+    
+    EIGEN_STRONG_INLINE Index rows() const { return IsColVector ? m_size : 1; }
+    EIGEN_STRONG_INLINE Index cols() const { return IsColVector ? 1 : m_size; }
+    EIGEN_STRONG_INLINE Index innerSize() const { return m_size; }
+    EIGEN_STRONG_INLINE Index outerSize() const { return 1; }
+
+    EIGEN_STRONG_INLINE const Scalar* valuePtr() const { return m_data.valuePtr(); }
+    EIGEN_STRONG_INLINE Scalar* valuePtr() { return m_data.valuePtr(); }
+
+    EIGEN_STRONG_INLINE const StorageIndex* innerIndexPtr() const { return m_data.indexPtr(); }
+    EIGEN_STRONG_INLINE StorageIndex* innerIndexPtr() { return m_data.indexPtr(); }
+
+    inline const StorageIndex* outerIndexPtr() const { return 0; }
+    inline StorageIndex* outerIndexPtr() { return 0; }
+    inline const StorageIndex* innerNonZeroPtr() const { return 0; }
+    inline StorageIndex* innerNonZeroPtr() { return 0; }
+    
+    /** \internal */
+    inline Storage& data() { return m_data; }
+    /** \internal */
+    inline const Storage& data() const { return m_data; }
+
+    inline Scalar coeff(Index row, Index col) const
+    {
+      eigen_assert(IsColVector ? (col==0 && row>=0 && row<m_size) : (row==0 && col>=0 && col<m_size));
+      return coeff(IsColVector ? row : col);
+    }
+    inline Scalar coeff(Index i) const
+    {
+      eigen_assert(i>=0 && i<m_size);
+      return m_data.at(StorageIndex(i));
+    }
+
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      eigen_assert(IsColVector ? (col==0 && row>=0 && row<m_size) : (row==0 && col>=0 && col<m_size));
+      return coeffRef(IsColVector ? row : col);
+    }
+
+    /** \returns a reference to the coefficient value at given index \a i
+      * This operation involes a log(rho*size) binary search. If the coefficient does not
+      * exist yet, then a sorted insertion into a sequential buffer is performed.
+      *
+      * This insertion might be very costly if the number of nonzeros above \a i is large.
+      */
+    inline Scalar& coeffRef(Index i)
+    {
+      eigen_assert(i>=0 && i<m_size);
+
+      return m_data.atWithInsertion(StorageIndex(i));
+    }
+
+  public:
+
+    typedef typename Base::InnerIterator InnerIterator;
+    typedef typename Base::ReverseInnerIterator ReverseInnerIterator;
+
+    inline void setZero() { m_data.clear(); }
+
+    /** \returns the number of non zero coefficients */
+    inline Index nonZeros() const  { return m_data.size(); }
+
+    inline void startVec(Index outer)
+    {
+      EIGEN_UNUSED_VARIABLE(outer);
+      eigen_assert(outer==0);
+    }
+
+    inline Scalar& insertBackByOuterInner(Index outer, Index inner)
+    {
+      EIGEN_UNUSED_VARIABLE(outer);
+      eigen_assert(outer==0);
+      return insertBack(inner);
+    }
+    inline Scalar& insertBack(Index i)
+    {
+      m_data.append(0, i);
+      return m_data.value(m_data.size()-1);
+    }
+    
+    Scalar& insertBackByOuterInnerUnordered(Index outer, Index inner)
+    {
+      EIGEN_UNUSED_VARIABLE(outer);
+      eigen_assert(outer==0);
+      return insertBackUnordered(inner);
+    }
+    inline Scalar& insertBackUnordered(Index i)
+    {
+      m_data.append(0, i);
+      return m_data.value(m_data.size()-1);
+    }
+
+    inline Scalar& insert(Index row, Index col)
+    {
+      eigen_assert(IsColVector ? (col==0 && row>=0 && row<m_size) : (row==0 && col>=0 && col<m_size));
+      
+      Index inner = IsColVector ? row : col;
+      Index outer = IsColVector ? col : row;
+      EIGEN_ONLY_USED_FOR_DEBUG(outer);
+      eigen_assert(outer==0);
+      return insert(inner);
+    }
+    Scalar& insert(Index i)
+    {
+      eigen_assert(i>=0 && i<m_size);
+      
+      Index startId = 0;
+      Index p = Index(m_data.size()) - 1;
+      // TODO smart realloc
+      m_data.resize(p+2,1);
+
+      while ( (p >= startId) && (m_data.index(p) > i) )
+      {
+        m_data.index(p+1) = m_data.index(p);
+        m_data.value(p+1) = m_data.value(p);
+        --p;
+      }
+      m_data.index(p+1) = convert_index(i);
+      m_data.value(p+1) = 0;
+      return m_data.value(p+1);
+    }
+
+    /**
+      */
+    inline void reserve(Index reserveSize) { m_data.reserve(reserveSize); }
+
+
+    inline void finalize() {}
+
+    /** \copydoc SparseMatrix::prune(const Scalar&,const RealScalar&) */
+    void prune(const Scalar& reference, const RealScalar& epsilon = NumTraits<RealScalar>::dummy_precision())
+    {
+      m_data.prune(reference,epsilon);
+    }
+
+    /** Resizes the sparse vector to \a rows x \a cols
+      *
+      * This method is provided for compatibility with matrices.
+      * For a column vector, \a cols must be equal to 1.
+      * For a row vector, \a rows must be equal to 1.
+      *
+      * \sa resize(Index)
+      */
+    void resize(Index rows, Index cols)
+    {
+      eigen_assert((IsColVector ? cols : rows)==1 && "Outer dimension must equal 1");
+      resize(IsColVector ? rows : cols);
+    }
+
+    /** Resizes the sparse vector to \a newSize
+      * This method deletes all entries, thus leaving an empty sparse vector
+      *
+      * \sa  conservativeResize(), setZero() */
+    void resize(Index newSize)
+    {
+      m_size = newSize;
+      m_data.clear();
+    }
+
+    /** Resizes the sparse vector to \a newSize, while leaving old values untouched.
+      *
+      * If the size of the vector is decreased, then the storage of the out-of bounds coefficients is kept and reserved.
+      * Call .data().squeeze() to free extra memory.
+      *
+      * \sa reserve(), setZero()
+      */
+    void conservativeResize(Index newSize)
+    {
+      if (newSize < m_size)
+      {
+        Index i = 0;
+        while (i<m_data.size() && m_data.index(i)<newSize) ++i;
+        m_data.resize(i);
+      }
+      m_size = newSize;
+    }
+
+    void resizeNonZeros(Index size) { m_data.resize(size); }
+
+    inline SparseVector() : m_size(0) { check_template_parameters(); resize(0); }
+
+    explicit inline SparseVector(Index size) : m_size(0) { check_template_parameters(); resize(size); }
+
+    inline SparseVector(Index rows, Index cols) : m_size(0) { check_template_parameters(); resize(rows,cols); }
+
+    template<typename OtherDerived>
+    inline SparseVector(const SparseMatrixBase<OtherDerived>& other)
+      : m_size(0)
+    {
+      #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+        EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+      #endif
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    inline SparseVector(const SparseVector& other)
+      : Base(other), m_size(0)
+    {
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    /** Swaps the values of \c *this and \a other.
+      * Overloaded for performance: this version performs a \em shallow swap by swapping pointers and attributes only.
+      * \sa SparseMatrixBase::swap()
+      */
+    inline void swap(SparseVector& other)
+    {
+      std::swap(m_size, other.m_size);
+      m_data.swap(other.m_data);
+    }
+
+    template<int OtherOptions>
+    inline void swap(SparseMatrix<Scalar,OtherOptions,StorageIndex>& other)
+    {
+      eigen_assert(other.outerSize()==1);
+      std::swap(m_size, other.m_innerSize);
+      m_data.swap(other.m_data);
+    }
+
+    inline SparseVector& operator=(const SparseVector& other)
+    {
+      if (other.isRValue())
+      {
+        swap(other.const_cast_derived());
+      }
+      else
+      {
+        resize(other.size());
+        m_data = other.m_data;
+      }
+      return *this;
+    }
+
+    template<typename OtherDerived>
+    inline SparseVector& operator=(const SparseMatrixBase<OtherDerived>& other)
+    {
+      SparseVector tmp(other.size());
+      internal::sparse_vector_assign_selector<SparseVector,OtherDerived>::run(tmp,other.derived());
+      this->swap(tmp);
+      return *this;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename Lhs, typename Rhs>
+    inline SparseVector& operator=(const SparseSparseProduct<Lhs,Rhs>& product)
+    {
+      return Base::operator=(product);
+    }
+    #endif
+
+    friend std::ostream & operator << (std::ostream & s, const SparseVector& m)
+    {
+      for (Index i=0; i<m.nonZeros(); ++i)
+        s << "(" << m.m_data.value(i) << "," << m.m_data.index(i) << ") ";
+      s << std::endl;
+      return s;
+    }
+
+    /** Destructor */
+    inline ~SparseVector() {}
+
+    /** Overloaded for performance */
+    Scalar sum() const;
+
+  public:
+
+    /** \internal \deprecated use setZero() and reserve() */
+    EIGEN_DEPRECATED void startFill(Index reserve)
+    {
+      setZero();
+      m_data.reserve(reserve);
+    }
+
+    /** \internal \deprecated use insertBack(Index,Index) */
+    EIGEN_DEPRECATED Scalar& fill(Index r, Index c)
+    {
+      eigen_assert(r==0 || c==0);
+      return fill(IsColVector ? r : c);
+    }
+
+    /** \internal \deprecated use insertBack(Index) */
+    EIGEN_DEPRECATED Scalar& fill(Index i)
+    {
+      m_data.append(0, i);
+      return m_data.value(m_data.size()-1);
+    }
+
+    /** \internal \deprecated use insert(Index,Index) */
+    EIGEN_DEPRECATED Scalar& fillrand(Index r, Index c)
+    {
+      eigen_assert(r==0 || c==0);
+      return fillrand(IsColVector ? r : c);
+    }
+
+    /** \internal \deprecated use insert(Index) */
+    EIGEN_DEPRECATED Scalar& fillrand(Index i)
+    {
+      return insert(i);
+    }
+
+    /** \internal \deprecated use finalize() */
+    EIGEN_DEPRECATED void endFill() {}
+    
+    // These two functions were here in the 3.1 release, so let's keep them in case some code rely on them.
+    /** \internal \deprecated use data() */
+    EIGEN_DEPRECATED Storage& _data() { return m_data; }
+    /** \internal \deprecated use data() */
+    EIGEN_DEPRECATED const Storage& _data() const { return m_data; }
+    
+#   ifdef EIGEN_SPARSEVECTOR_PLUGIN
+#     include EIGEN_SPARSEVECTOR_PLUGIN
+#   endif
+
+protected:
+  
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT(NumTraits<StorageIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE);
+      EIGEN_STATIC_ASSERT((_Options&(ColMajor|RowMajor))==Options,INVALID_MATRIX_TEMPLATE_PARAMETERS);
+    }
+    
+    Storage m_data;
+    Index m_size;
+};
+
+namespace internal {
+
+template<typename _Scalar, int _Options, typename _Index>
+struct evaluator<SparseVector<_Scalar,_Options,_Index> >
+  : evaluator_base<SparseVector<_Scalar,_Options,_Index> >
+{
+  typedef SparseVector<_Scalar,_Options,_Index> SparseVectorType;
+  typedef evaluator_base<SparseVectorType> Base;
+  typedef typename SparseVectorType::InnerIterator InnerIterator;
+  typedef typename SparseVectorType::ReverseInnerIterator ReverseInnerIterator;
+  
+  enum {
+    CoeffReadCost = NumTraits<_Scalar>::ReadCost,
+    Flags = SparseVectorType::Flags
+  };
+
+  evaluator() : Base() {}
+  
+  explicit evaluator(const SparseVectorType &mat) : m_matrix(&mat)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_matrix->nonZeros();
+  }
+  
+  operator SparseVectorType&() { return m_matrix->const_cast_derived(); }
+  operator const SparseVectorType&() const { return *m_matrix; }
+  
+  const SparseVectorType *m_matrix;
+};
+
+template< typename Dest, typename Src>
+struct sparse_vector_assign_selector<Dest,Src,SVA_Inner> {
+  static void run(Dest& dst, const Src& src) {
+    eigen_internal_assert(src.innerSize()==src.size());
+    typedef internal::evaluator<Src> SrcEvaluatorType;
+    SrcEvaluatorType srcEval(src);
+    for(typename SrcEvaluatorType::InnerIterator it(srcEval, 0); it; ++it)
+      dst.insert(it.index()) = it.value();
+  }
+};
+
+template< typename Dest, typename Src>
+struct sparse_vector_assign_selector<Dest,Src,SVA_Outer> {
+  static void run(Dest& dst, const Src& src) {
+    eigen_internal_assert(src.outerSize()==src.size());
+    typedef internal::evaluator<Src> SrcEvaluatorType;
+    SrcEvaluatorType srcEval(src);
+    for(Index i=0; i<src.size(); ++i)
+    {
+      typename SrcEvaluatorType::InnerIterator it(srcEval, i);
+      if(it)
+        dst.insert(i) = it.value();
+    }
+  }
+};
+
+template< typename Dest, typename Src>
+struct sparse_vector_assign_selector<Dest,Src,SVA_RuntimeSwitch> {
+  static void run(Dest& dst, const Src& src) {
+    if(src.outerSize()==1)  sparse_vector_assign_selector<Dest,Src,SVA_Inner>::run(dst, src);
+    else                    sparse_vector_assign_selector<Dest,Src,SVA_Outer>::run(dst, src);
+  }
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEVECTOR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseView.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseView.h
new file mode 100644
index 00000000..92b3d1f7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/SparseView.h
@@ -0,0 +1,254 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Daniel Lowengrub <lowdanie@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEVIEW_H
+#define EIGEN_SPARSEVIEW_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename MatrixType>
+struct traits<SparseView<MatrixType> > : traits<MatrixType>
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef Sparse StorageKind;
+  enum {
+    Flags = int(traits<MatrixType>::Flags) & (RowMajorBit)
+  };
+};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  * \class SparseView
+  *
+  * \brief Expression of a dense or sparse matrix with zero or too small values removed
+  *
+  * \tparam MatrixType the type of the object of which we are removing the small entries
+  *
+  * This class represents an expression of a given dense or sparse matrix with
+  * entries smaller than \c reference * \c epsilon are removed.
+  * It is the return type of MatrixBase::sparseView() and SparseMatrixBase::pruned()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::sparseView(), SparseMatrixBase::pruned()
+  */
+template<typename MatrixType>
+class SparseView : public SparseMatrixBase<SparseView<MatrixType> >
+{
+  typedef typename MatrixType::Nested MatrixTypeNested;
+  typedef typename internal::remove_all<MatrixTypeNested>::type _MatrixTypeNested;
+  typedef SparseMatrixBase<SparseView > Base;
+public:
+  EIGEN_SPARSE_PUBLIC_INTERFACE(SparseView)
+  typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+  explicit SparseView(const MatrixType& mat, const Scalar& reference = Scalar(0),
+                      const RealScalar &epsilon = NumTraits<Scalar>::dummy_precision())
+    : m_matrix(mat), m_reference(reference), m_epsilon(epsilon) {}
+
+  inline Index rows() const { return m_matrix.rows(); }
+  inline Index cols() const { return m_matrix.cols(); }
+
+  inline Index innerSize() const { return m_matrix.innerSize(); }
+  inline Index outerSize() const { return m_matrix.outerSize(); }
+  
+  /** \returns the nested expression */
+  const typename internal::remove_all<MatrixTypeNested>::type&
+  nestedExpression() const { return m_matrix; }
+  
+  Scalar reference() const { return m_reference; }
+  RealScalar epsilon() const { return m_epsilon; }
+  
+protected:
+  MatrixTypeNested m_matrix;
+  Scalar m_reference;
+  RealScalar m_epsilon;
+};
+
+namespace internal {
+
+// TODO find a way to unify the two following variants
+// This is tricky because implementing an inner iterator on top of an IndexBased evaluator is
+// not easy because the evaluators do not expose the sizes of the underlying expression.
+  
+template<typename ArgType>
+struct unary_evaluator<SparseView<ArgType>, IteratorBased>
+  : public evaluator_base<SparseView<ArgType> >
+{
+    typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  public:
+    typedef SparseView<ArgType> XprType;
+    
+    class InnerIterator : public EvalIterator
+    {
+      protected:
+        typedef typename XprType::Scalar Scalar;
+      public:
+
+        EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& sve, Index outer)
+          : EvalIterator(sve.m_argImpl,outer), m_view(sve.m_view)
+        {
+          incrementToNonZero();
+        }
+
+        EIGEN_STRONG_INLINE InnerIterator& operator++()
+        {
+          EvalIterator::operator++();
+          incrementToNonZero();
+          return *this;
+        }
+
+        using EvalIterator::value;
+
+      protected:
+        const XprType &m_view;
+
+      private:
+        void incrementToNonZero()
+        {
+          while((bool(*this)) && internal::isMuchSmallerThan(value(), m_view.reference(), m_view.epsilon()))
+          {
+            EvalIterator::operator++();
+          }
+        }
+    };
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_view(xpr) {}
+
+  protected:
+    evaluator<ArgType> m_argImpl;
+    const XprType &m_view;
+};
+
+template<typename ArgType>
+struct unary_evaluator<SparseView<ArgType>, IndexBased>
+  : public evaluator_base<SparseView<ArgType> >
+{
+  public:
+    typedef SparseView<ArgType> XprType;
+  protected:
+    enum { IsRowMajor = (XprType::Flags&RowMajorBit)==RowMajorBit };
+    typedef typename XprType::Scalar Scalar;
+    typedef typename XprType::StorageIndex StorageIndex;
+  public:
+    
+    class InnerIterator
+    {
+      public:
+
+        EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& sve, Index outer)
+          : m_sve(sve), m_inner(0), m_outer(outer), m_end(sve.m_view.innerSize())
+        {
+          incrementToNonZero();
+        }
+
+        EIGEN_STRONG_INLINE InnerIterator& operator++()
+        {
+          m_inner++;
+          incrementToNonZero();
+          return *this;
+        }
+
+        EIGEN_STRONG_INLINE Scalar value() const
+        {
+          return (IsRowMajor) ? m_sve.m_argImpl.coeff(m_outer, m_inner)
+                              : m_sve.m_argImpl.coeff(m_inner, m_outer);
+        }
+
+        EIGEN_STRONG_INLINE StorageIndex index() const { return m_inner; }
+        inline Index row() const { return IsRowMajor ? m_outer : index(); }
+        inline Index col() const { return IsRowMajor ? index() : m_outer; }
+
+        EIGEN_STRONG_INLINE operator bool() const { return m_inner < m_end && m_inner>=0; }
+
+      protected:
+        const unary_evaluator &m_sve;
+        Index m_inner;
+        const Index m_outer;
+        const Index m_end;
+
+      private:
+        void incrementToNonZero()
+        {
+          while((bool(*this)) && internal::isMuchSmallerThan(value(), m_sve.m_view.reference(), m_sve.m_view.epsilon()))
+          {
+            m_inner++;
+          }
+        }
+    };
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_view(xpr) {}
+
+  protected:
+    evaluator<ArgType> m_argImpl;
+    const XprType &m_view;
+};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  *
+  * \returns a sparse expression of the dense expression \c *this with values smaller than
+  * \a reference * \a epsilon removed.
+  *
+  * This method is typically used when prototyping to convert a quickly assembled dense Matrix \c D to a SparseMatrix \c S:
+  * \code
+  * MatrixXd D(n,m);
+  * SparseMatrix<double> S;
+  * S = D.sparseView();             // suppress numerical zeros (exact)
+  * S = D.sparseView(reference);
+  * S = D.sparseView(reference,epsilon);
+  * \endcode
+  * where \a reference is a meaningful non zero reference value,
+  * and \a epsilon is a tolerance factor defaulting to NumTraits<Scalar>::dummy_precision().
+  *
+  * \sa SparseMatrixBase::pruned(), class SparseView */
+template<typename Derived>
+const SparseView<Derived> MatrixBase<Derived>::sparseView(const Scalar& reference,
+                                                          const typename NumTraits<Scalar>::Real& epsilon) const
+{
+  return SparseView<Derived>(derived(), reference, epsilon);
+}
+
+/** \returns an expression of \c *this with values smaller than
+  * \a reference * \a epsilon removed.
+  *
+  * This method is typically used in conjunction with the product of two sparse matrices
+  * to automatically prune the smallest values as follows:
+  * \code
+  * C = (A*B).pruned();             // suppress numerical zeros (exact)
+  * C = (A*B).pruned(ref);
+  * C = (A*B).pruned(ref,epsilon);
+  * \endcode
+  * where \c ref is a meaningful non zero reference value.
+  * */
+template<typename Derived>
+const SparseView<Derived>
+SparseMatrixBase<Derived>::pruned(const Scalar& reference,
+                                  const RealScalar& epsilon) const
+{
+  return SparseView<Derived>(derived(), reference, epsilon);
+}
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseCore/TriangularSolver.h b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/TriangularSolver.h
new file mode 100644
index 00000000..f9c56ba7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseCore/TriangularSolver.h
@@ -0,0 +1,315 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSETRIANGULARSOLVER_H
+#define EIGEN_SPARSETRIANGULARSOLVER_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Mode,
+  int UpLo = (Mode & Lower)
+           ? Lower
+           : (Mode & Upper)
+           ? Upper
+           : -1,
+  int StorageOrder = int(traits<Lhs>::Flags) & RowMajorBit>
+struct sparse_solve_triangular_selector;
+
+// forward substitution, row-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,RowMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=0; i<lhs.rows(); ++i)
+      {
+        Scalar tmp = other.coeff(i,col);
+        Scalar lastVal(0);
+        Index lastIndex = 0;
+        for(LhsIterator it(lhsEval, i); it; ++it)
+        {
+          lastVal = it.value();
+          lastIndex = it.index();
+          if(lastIndex==i)
+            break;
+          tmp -= lastVal * other.coeff(lastIndex,col);
+        }
+        if (Mode & UnitDiag)
+          other.coeffRef(i,col) = tmp;
+        else
+        {
+          eigen_assert(lastIndex==i);
+          other.coeffRef(i,col) = tmp/lastVal;
+        }
+      }
+    }
+  }
+};
+
+// backward substitution, row-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,RowMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=lhs.rows()-1 ; i>=0 ; --i)
+      {
+        Scalar tmp = other.coeff(i,col);
+        Scalar l_ii(0);
+        LhsIterator it(lhsEval, i);
+        while(it && it.index()<i)
+          ++it;
+        if(!(Mode & UnitDiag))
+        {
+          eigen_assert(it && it.index()==i);
+          l_ii = it.value();
+          ++it;
+        }
+        else if (it && it.index() == i)
+          ++it;
+        for(; it; ++it)
+        {
+          tmp -= it.value() * other.coeff(it.index(),col);
+        }
+
+        if (Mode & UnitDiag)  other.coeffRef(i,col) = tmp;
+        else                  other.coeffRef(i,col) = tmp/l_ii;
+      }
+    }
+  }
+};
+
+// forward substitution, col-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,ColMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=0; i<lhs.cols(); ++i)
+      {
+        Scalar& tmp = other.coeffRef(i,col);
+        if (tmp!=Scalar(0)) // optimization when other is actually sparse
+        {
+          LhsIterator it(lhsEval, i);
+          while(it && it.index()<i)
+            ++it;
+          if(!(Mode & UnitDiag))
+          {
+            eigen_assert(it && it.index()==i);
+            tmp /= it.value();
+          }
+          if (it && it.index()==i)
+            ++it;
+          for(; it; ++it)
+            other.coeffRef(it.index(), col) -= tmp * it.value();
+        }
+      }
+    }
+  }
+};
+
+// backward substitution, col-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,ColMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=lhs.cols()-1; i>=0; --i)
+      {
+        Scalar& tmp = other.coeffRef(i,col);
+        if (tmp!=Scalar(0)) // optimization when other is actually sparse
+        {
+          if(!(Mode & UnitDiag))
+          {
+            // TODO replace this by a binary search. make sure the binary search is safe for partially sorted elements
+            LhsIterator it(lhsEval, i);
+            while(it && it.index()!=i)
+              ++it;
+            eigen_assert(it && it.index()==i);
+            other.coeffRef(i,col) /= it.value();
+          }
+          LhsIterator it(lhsEval, i);
+          for(; it && it.index()<i; ++it)
+            other.coeffRef(it.index(), col) -= tmp * it.value();
+        }
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+template<typename ExpressionType,unsigned int Mode>
+template<typename OtherDerived>
+void TriangularViewImpl<ExpressionType,Mode,Sparse>::solveInPlace(MatrixBase<OtherDerived>& other) const
+{
+  eigen_assert(derived().cols() == derived().rows() && derived().cols() == other.rows());
+  eigen_assert((!(Mode & ZeroDiag)) && bool(Mode & (Upper|Lower)));
+
+  enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit };
+
+  typedef typename internal::conditional<copy,
+    typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
+  OtherCopy otherCopy(other.derived());
+
+  internal::sparse_solve_triangular_selector<ExpressionType, typename internal::remove_reference<OtherCopy>::type, Mode>::run(derived().nestedExpression(), otherCopy);
+
+  if (copy)
+    other = otherCopy;
+}
+#endif
+
+// pure sparse path
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Mode,
+  int UpLo = (Mode & Lower)
+           ? Lower
+           : (Mode & Upper)
+           ? Upper
+           : -1,
+  int StorageOrder = int(Lhs::Flags) & (RowMajorBit)>
+struct sparse_solve_triangular_sparse_selector;
+
+// forward substitution, col-major
+template<typename Lhs, typename Rhs, int Mode, int UpLo>
+struct sparse_solve_triangular_sparse_selector<Lhs,Rhs,Mode,UpLo,ColMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef typename promote_index_type<typename traits<Lhs>::StorageIndex,
+                                      typename traits<Rhs>::StorageIndex>::type StorageIndex;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    const bool IsLower = (UpLo==Lower);
+    AmbiVector<Scalar,StorageIndex> tempVector(other.rows()*2);
+    tempVector.setBounds(0,other.rows());
+
+    Rhs res(other.rows(), other.cols());
+    res.reserve(other.nonZeros());
+
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      // FIXME estimate number of non zeros
+      tempVector.init(.99/*float(other.col(col).nonZeros())/float(other.rows())*/);
+      tempVector.setZero();
+      tempVector.restart();
+      for (typename Rhs::InnerIterator rhsIt(other, col); rhsIt; ++rhsIt)
+      {
+        tempVector.coeffRef(rhsIt.index()) = rhsIt.value();
+      }
+
+      for(Index i=IsLower?0:lhs.cols()-1;
+          IsLower?i<lhs.cols():i>=0;
+          i+=IsLower?1:-1)
+      {
+        tempVector.restart();
+        Scalar& ci = tempVector.coeffRef(i);
+        if (ci!=Scalar(0))
+        {
+          // find
+          typename Lhs::InnerIterator it(lhs, i);
+          if(!(Mode & UnitDiag))
+          {
+            if (IsLower)
+            {
+              eigen_assert(it.index()==i);
+              ci /= it.value();
+            }
+            else
+              ci /= lhs.coeff(i,i);
+          }
+          tempVector.restart();
+          if (IsLower)
+          {
+            if (it.index()==i)
+              ++it;
+            for(; it; ++it)
+              tempVector.coeffRef(it.index()) -= ci * it.value();
+          }
+          else
+          {
+            for(; it && it.index()<i; ++it)
+              tempVector.coeffRef(it.index()) -= ci * it.value();
+          }
+        }
+      }
+
+
+      Index count = 0;
+      // FIXME compute a reference value to filter zeros
+      for (typename AmbiVector<Scalar,StorageIndex>::Iterator it(tempVector/*,1e-12*/); it; ++it)
+      {
+        ++ count;
+//         std::cerr << "fill " << it.index() << ", " << col << "\n";
+//         std::cout << it.value() << "  ";
+        // FIXME use insertBack
+        res.insert(it.index(), col) = it.value();
+      }
+//       std::cout << "tempVector.nonZeros() == " << int(count) << " / " << (other.rows()) << "\n";
+    }
+    res.finalize();
+    other = res.markAsRValue();
+  }
+};
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename ExpressionType,unsigned int Mode>
+template<typename OtherDerived>
+void TriangularViewImpl<ExpressionType,Mode,Sparse>::solveInPlace(SparseMatrixBase<OtherDerived>& other) const
+{
+  eigen_assert(derived().cols() == derived().rows() && derived().cols() == other.rows());
+  eigen_assert( (!(Mode & ZeroDiag)) && bool(Mode & (Upper|Lower)));
+
+//   enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit };
+
+//   typedef typename internal::conditional<copy,
+//     typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
+//   OtherCopy otherCopy(other.derived());
+
+  internal::sparse_solve_triangular_sparse_selector<ExpressionType, OtherDerived, Mode>::run(derived().nestedExpression(), other.derived());
+
+//   if (copy)
+//     other = otherCopy;
+}
+#endif
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSETRIANGULARSOLVER_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU.h
new file mode 100644
index 00000000..0c8d8939
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU.h
@@ -0,0 +1,923 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_SPARSE_LU_H
+#define EIGEN_SPARSE_LU_H
+
+namespace Eigen {
+
+template <typename _MatrixType, typename _OrderingType = COLAMDOrdering<typename _MatrixType::StorageIndex> > class SparseLU;
+template <typename MappedSparseMatrixType> struct SparseLUMatrixLReturnType;
+template <typename MatrixLType, typename MatrixUType> struct SparseLUMatrixUReturnType;
+
+template <bool Conjugate,class SparseLUType>
+class SparseLUTransposeView : public SparseSolverBase<SparseLUTransposeView<Conjugate,SparseLUType> >
+{
+protected:
+  typedef SparseSolverBase<SparseLUTransposeView<Conjugate,SparseLUType> > APIBase;
+  using APIBase::m_isInitialized;
+public:
+  typedef typename SparseLUType::Scalar Scalar;
+  typedef typename SparseLUType::StorageIndex StorageIndex;
+  typedef typename SparseLUType::MatrixType MatrixType;
+  typedef typename SparseLUType::OrderingType OrderingType;
+
+  enum {
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+  };
+
+  SparseLUTransposeView() : m_sparseLU(NULL) {}
+  SparseLUTransposeView(const SparseLUTransposeView& view) {
+    this->m_sparseLU = view.m_sparseLU;
+  }
+  void setIsInitialized(const bool isInitialized) {this->m_isInitialized = isInitialized;}
+  void setSparseLU(SparseLUType* sparseLU) {m_sparseLU = sparseLU;}
+  using APIBase::_solve_impl;
+  template<typename Rhs, typename Dest>
+  bool _solve_impl(const MatrixBase<Rhs> &B, MatrixBase<Dest> &X_base) const
+  {
+    Dest& X(X_base.derived());
+    eigen_assert(m_sparseLU->info() == Success && "The matrix should be factorized first");
+    EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
+                        THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+
+
+    // this ugly const_cast_derived() helps to detect aliasing when applying the permutations
+    for(Index j = 0; j < B.cols(); ++j){
+      X.col(j) = m_sparseLU->colsPermutation() * B.const_cast_derived().col(j);
+    }
+    //Forward substitution with transposed or adjoint of U
+    m_sparseLU->matrixU().template solveTransposedInPlace<Conjugate>(X);
+
+    //Backward substitution with transposed or adjoint of L
+    m_sparseLU->matrixL().template solveTransposedInPlace<Conjugate>(X);
+
+    // Permute back the solution
+    for (Index j = 0; j < B.cols(); ++j)
+      X.col(j) = m_sparseLU->rowsPermutation().transpose() * X.col(j);
+    return true;
+  }
+  inline Index rows() const { return m_sparseLU->rows(); }
+  inline Index cols() const { return m_sparseLU->cols(); }
+
+private:
+  SparseLUType *m_sparseLU;
+  SparseLUTransposeView& operator=(const SparseLUTransposeView&);
+};
+
+
+/** \ingroup SparseLU_Module
+  * \class SparseLU
+  * 
+  * \brief Sparse supernodal LU factorization for general matrices
+  * 
+  * This class implements the supernodal LU factorization for general matrices.
+  * It uses the main techniques from the sequential SuperLU package 
+  * (http://crd-legacy.lbl.gov/~xiaoye/SuperLU/). It handles transparently real 
+  * and complex arithmetic with single and double precision, depending on the 
+  * scalar type of your input matrix. 
+  * The code has been optimized to provide BLAS-3 operations during supernode-panel updates. 
+  * It benefits directly from the built-in high-performant Eigen BLAS routines. 
+  * Moreover, when the size of a supernode is very small, the BLAS calls are avoided to 
+  * enable a better optimization from the compiler. For best performance, 
+  * you should compile it with NDEBUG flag to avoid the numerous bounds checking on vectors. 
+  * 
+  * An important parameter of this class is the ordering method. It is used to reorder the columns 
+  * (and eventually the rows) of the matrix to reduce the number of new elements that are created during 
+  * numerical factorization. The cheapest method available is COLAMD. 
+  * See  \link OrderingMethods_Module the OrderingMethods module \endlink for the list of 
+  * built-in and external ordering methods. 
+  *
+  * Simple example with key steps 
+  * \code
+  * VectorXd x(n), b(n);
+  * SparseMatrix<double> A;
+  * SparseLU<SparseMatrix<double>, COLAMDOrdering<int> >   solver;
+  * // fill A and b;
+  * // Compute the ordering permutation vector from the structural pattern of A
+  * solver.analyzePattern(A); 
+  * // Compute the numerical factorization 
+  * solver.factorize(A); 
+  * //Use the factors to solve the linear system 
+  * x = solver.solve(b); 
+  * \endcode
+  * 
+  * \warning The input matrix A should be in a \b compressed and \b column-major form.
+  * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
+  * 
+  * \note Unlike the initial SuperLU implementation, there is no step to equilibrate the matrix. 
+  * For badly scaled matrices, this step can be useful to reduce the pivoting during factorization. 
+  * If this is the case for your matrices, you can try the basic scaling method at
+  *  "unsupported/Eigen/src/IterativeSolvers/Scaling.h"
+  * 
+  * \tparam _MatrixType The type of the sparse matrix. It must be a column-major SparseMatrix<>
+  * \tparam _OrderingType The ordering method to use, either AMD, COLAMD or METIS. Default is COLMAD
+  *
+  * \implsparsesolverconcept
+  * 
+  * \sa \ref TutorialSparseSolverConcept
+  * \sa \ref OrderingMethods_Module
+  */
+template <typename _MatrixType, typename _OrderingType>
+class SparseLU : public SparseSolverBase<SparseLU<_MatrixType,_OrderingType> >, public internal::SparseLUImpl<typename _MatrixType::Scalar, typename _MatrixType::StorageIndex>
+{
+  protected:
+    typedef SparseSolverBase<SparseLU<_MatrixType,_OrderingType> > APIBase;
+    using APIBase::m_isInitialized;
+  public:
+    using APIBase::_solve_impl;
+    
+    typedef _MatrixType MatrixType; 
+    typedef _OrderingType OrderingType;
+    typedef typename MatrixType::Scalar Scalar; 
+    typedef typename MatrixType::RealScalar RealScalar; 
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> NCMatrix;
+    typedef internal::MappedSuperNodalMatrix<Scalar, StorageIndex> SCMatrix;
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+    typedef internal::SparseLUImpl<Scalar, StorageIndex> Base;
+
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+  public:
+
+    SparseLU():m_lastError(""),m_Ustore(0,0,0,0,0,0),m_symmetricmode(false),m_diagpivotthresh(1.0),m_detPermR(1)
+    {
+      initperfvalues(); 
+    }
+    explicit SparseLU(const MatrixType& matrix)
+      : m_lastError(""),m_Ustore(0,0,0,0,0,0),m_symmetricmode(false),m_diagpivotthresh(1.0),m_detPermR(1)
+    {
+      initperfvalues(); 
+      compute(matrix);
+    }
+    
+    ~SparseLU()
+    {
+      // Free all explicit dynamic pointers 
+    }
+    
+    void analyzePattern (const MatrixType& matrix);
+    void factorize (const MatrixType& matrix);
+    void simplicialfactorize(const MatrixType& matrix);
+    
+    /**
+      * Compute the symbolic and numeric factorization of the input sparse matrix.
+      * The input matrix should be in column-major storage. 
+      */
+    void compute (const MatrixType& matrix)
+    {
+      // Analyze 
+      analyzePattern(matrix); 
+      //Factorize
+      factorize(matrix);
+    } 
+
+    /** \returns an expression of the transposed of the factored matrix.
+      *
+      * A typical usage is to solve for the transposed problem A^T x = b:
+      * \code
+      * solver.compute(A);
+      * x = solver.transpose().solve(b);
+      * \endcode
+      *
+      * \sa adjoint(), solve()
+      */
+    const SparseLUTransposeView<false,SparseLU<_MatrixType,_OrderingType> > transpose()
+    {
+      SparseLUTransposeView<false,  SparseLU<_MatrixType,_OrderingType> > transposeView;
+      transposeView.setSparseLU(this);
+      transposeView.setIsInitialized(this->m_isInitialized);
+      return transposeView;
+    }
+
+
+    /** \returns an expression of the adjoint of the factored matrix
+      *
+      * A typical usage is to solve for the adjoint problem A' x = b:
+      * \code
+      * solver.compute(A);
+      * x = solver.adjoint().solve(b);
+      * \endcode
+      *
+      * For real scalar types, this function is equivalent to transpose().
+      *
+      * \sa transpose(), solve()
+      */
+    const SparseLUTransposeView<true, SparseLU<_MatrixType,_OrderingType> > adjoint()
+    {
+      SparseLUTransposeView<true,  SparseLU<_MatrixType,_OrderingType> > adjointView;
+      adjointView.setSparseLU(this);
+      adjointView.setIsInitialized(this->m_isInitialized);
+      return adjointView;
+    }
+    
+    inline Index rows() const { return m_mat.rows(); }
+    inline Index cols() const { return m_mat.cols(); }
+    /** Indicate that the pattern of the input matrix is symmetric */
+    void isSymmetric(bool sym)
+    {
+      m_symmetricmode = sym;
+    }
+    
+    /** \returns an expression of the matrix L, internally stored as supernodes
+      * The only operation available with this expression is the triangular solve
+      * \code
+      * y = b; matrixL().solveInPlace(y);
+      * \endcode
+      */
+    SparseLUMatrixLReturnType<SCMatrix> matrixL() const
+    {
+      return SparseLUMatrixLReturnType<SCMatrix>(m_Lstore);
+    }
+    /** \returns an expression of the matrix U,
+      * The only operation available with this expression is the triangular solve
+      * \code
+      * y = b; matrixU().solveInPlace(y);
+      * \endcode
+      */
+    SparseLUMatrixUReturnType<SCMatrix,MappedSparseMatrix<Scalar,ColMajor,StorageIndex> > matrixU() const
+    {
+      return SparseLUMatrixUReturnType<SCMatrix, MappedSparseMatrix<Scalar,ColMajor,StorageIndex> >(m_Lstore, m_Ustore);
+    }
+
+    /**
+      * \returns a reference to the row matrix permutation \f$ P_r \f$ such that \f$P_r A P_c^T = L U\f$
+      * \sa colsPermutation()
+      */
+    inline const PermutationType& rowsPermutation() const
+    {
+      return m_perm_r;
+    }
+    /**
+      * \returns a reference to the column matrix permutation\f$ P_c^T \f$ such that \f$P_r A P_c^T = L U\f$
+      * \sa rowsPermutation()
+      */
+    inline const PermutationType& colsPermutation() const
+    {
+      return m_perm_c;
+    }
+    /** Set the threshold used for a diagonal entry to be an acceptable pivot. */
+    void setPivotThreshold(const RealScalar& thresh)
+    {
+      m_diagpivotthresh = thresh; 
+    }
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \returns the solution X of \f$ A X = B \f$ using the current decomposition of A.
+      *
+      * \warning the destination matrix X in X = this->solve(B) must be colmun-major.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<SparseLU, Rhs> solve(const MatrixBase<Rhs>& B) const;
+#endif // EIGEN_PARSED_BY_DOXYGEN
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the LU factorization reports a problem, zero diagonal for instance
+      *          \c InvalidInput if the input matrix is invalid
+      *
+      * \sa iparm()          
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+    
+    /**
+      * \returns A string describing the type of error
+      */
+    std::string lastErrorMessage() const
+    {
+      return m_lastError; 
+    }
+
+    template<typename Rhs, typename Dest>
+    bool _solve_impl(const MatrixBase<Rhs> &B, MatrixBase<Dest> &X_base) const
+    {
+      Dest& X(X_base.derived());
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first");
+      EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
+                        THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+      
+      // Permute the right hand side to form X = Pr*B
+      // on return, X is overwritten by the computed solution
+      X.resize(B.rows(),B.cols());
+
+      // this ugly const_cast_derived() helps to detect aliasing when applying the permutations
+      for(Index j = 0; j < B.cols(); ++j)
+        X.col(j) = rowsPermutation() * B.const_cast_derived().col(j);
+      
+      //Forward substitution with L
+      this->matrixL().solveInPlace(X);
+      this->matrixU().solveInPlace(X);
+      
+      // Permute back the solution 
+      for (Index j = 0; j < B.cols(); ++j)
+        X.col(j) = colsPermutation().inverse() * X.col(j);
+      
+      return true; 
+    }
+    
+    /**
+      * \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), signDeterminant()
+      */
+    Scalar absDeterminant()
+    {
+      using std::abs;
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      // Initialize with the determinant of the row matrix
+      Scalar det = Scalar(1.);
+      // Note that the diagonal blocks of U are stored in supernodes,
+      // which are available in the  L part :)
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.index() == j)
+          {
+            det *= abs(it.value());
+            break;
+          }
+        }
+      }
+      return det;
+    }
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix
+      * of which **this is the QR decomposition
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's
+      * inherent to the determinant computation.
+      *
+      * \sa absDeterminant(), signDeterminant()
+      */
+    Scalar logAbsDeterminant() const
+    {
+      using std::log;
+      using std::abs;
+
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      Scalar det = Scalar(0.);
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.row() < j) continue;
+          if(it.row() == j)
+          {
+            det += log(abs(it.value()));
+            break;
+          }
+        }
+      }
+      return det;
+    }
+
+    /** \returns A number representing the sign of the determinant
+      *
+      * \sa absDeterminant(), logAbsDeterminant()
+      */
+    Scalar signDeterminant()
+    {
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      // Initialize with the determinant of the row matrix
+      Index det = 1;
+      // Note that the diagonal blocks of U are stored in supernodes,
+      // which are available in the  L part :)
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.index() == j)
+          {
+            if(it.value()<0)
+              det = -det;
+            else if(it.value()==0)
+              return 0;
+            break;
+          }
+        }
+      }
+      return det * m_detPermR * m_detPermC;
+    }
+    
+    /** \returns The determinant of the matrix.
+      *
+      * \sa absDeterminant(), logAbsDeterminant()
+      */
+    Scalar determinant()
+    {
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      // Initialize with the determinant of the row matrix
+      Scalar det = Scalar(1.);
+      // Note that the diagonal blocks of U are stored in supernodes,
+      // which are available in the  L part :)
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.index() == j)
+          {
+            det *= it.value();
+            break;
+          }
+        }
+      }
+      return (m_detPermR * m_detPermC) > 0 ? det : -det;
+    }
+
+    Index nnzL() const { return m_nnzL; };
+    Index nnzU() const { return m_nnzU; };
+
+  protected:
+    // Functions 
+    void initperfvalues()
+    {
+      m_perfv.panel_size = 16;
+      m_perfv.relax = 1; 
+      m_perfv.maxsuper = 128; 
+      m_perfv.rowblk = 16; 
+      m_perfv.colblk = 8; 
+      m_perfv.fillfactor = 20;  
+    }
+      
+    // Variables 
+    mutable ComputationInfo m_info;
+    bool m_factorizationIsOk;
+    bool m_analysisIsOk;
+    std::string m_lastError;
+    NCMatrix m_mat; // The input (permuted ) matrix 
+    SCMatrix m_Lstore; // The lower triangular matrix (supernodal)
+    MappedSparseMatrix<Scalar,ColMajor,StorageIndex> m_Ustore; // The upper triangular matrix
+    PermutationType m_perm_c; // Column permutation 
+    PermutationType m_perm_r ; // Row permutation
+    IndexVector m_etree; // Column elimination tree 
+    
+    typename Base::GlobalLU_t m_glu; 
+                               
+    // SparseLU options 
+    bool m_symmetricmode;
+    // values for performance 
+    internal::perfvalues m_perfv;
+    RealScalar m_diagpivotthresh; // Specifies the threshold used for a diagonal entry to be an acceptable pivot
+    Index m_nnzL, m_nnzU; // Nonzeros in L and U factors
+    Index m_detPermR, m_detPermC; // Determinants of the permutation matrices
+  private:
+    // Disable copy constructor 
+    SparseLU (const SparseLU& );
+}; // End class SparseLU
+
+
+
+// Functions needed by the anaysis phase
+/** 
+  * Compute the column permutation to minimize the fill-in
+  * 
+  *  - Apply this permutation to the input matrix - 
+  * 
+  *  - Compute the column elimination tree on the permuted matrix 
+  * 
+  *  - Postorder the elimination tree and the column permutation
+  * 
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseLU<MatrixType, OrderingType>::analyzePattern(const MatrixType& mat)
+{
+  
+  //TODO  It is possible as in SuperLU to compute row and columns scaling vectors to equilibrate the matrix mat.
+  
+  // Firstly, copy the whole input matrix. 
+  m_mat = mat;
+  
+  // Compute fill-in ordering
+  OrderingType ord; 
+  ord(m_mat,m_perm_c);
+  
+  // Apply the permutation to the column of the input  matrix
+  if (m_perm_c.size())
+  {
+    m_mat.uncompress(); //NOTE: The effect of this command is only to create the InnerNonzeros pointers. FIXME : This vector is filled but not subsequently used.  
+    // Then, permute only the column pointers
+    ei_declare_aligned_stack_constructed_variable(StorageIndex,outerIndexPtr,mat.cols()+1,mat.isCompressed()?const_cast<StorageIndex*>(mat.outerIndexPtr()):0);
+    
+    // If the input matrix 'mat' is uncompressed, then the outer-indices do not match the ones of m_mat, and a copy is thus needed.
+    if(!mat.isCompressed()) 
+      IndexVector::Map(outerIndexPtr, mat.cols()+1) = IndexVector::Map(m_mat.outerIndexPtr(),mat.cols()+1);
+    
+    // Apply the permutation and compute the nnz per column.
+    for (Index i = 0; i < mat.cols(); i++)
+    {
+      m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
+      m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i+1] - outerIndexPtr[i];
+    }
+  }
+  
+  // Compute the column elimination tree of the permuted matrix 
+  IndexVector firstRowElt;
+  internal::coletree(m_mat, m_etree,firstRowElt); 
+     
+  // In symmetric mode, do not do postorder here
+  if (!m_symmetricmode) {
+    IndexVector post, iwork; 
+    // Post order etree
+    internal::treePostorder(StorageIndex(m_mat.cols()), m_etree, post); 
+      
+   
+    // Renumber etree in postorder 
+    Index m = m_mat.cols(); 
+    iwork.resize(m+1);
+    for (Index i = 0; i < m; ++i) iwork(post(i)) = post(m_etree(i));
+    m_etree = iwork;
+    
+    // Postmultiply A*Pc by post, i.e reorder the matrix according to the postorder of the etree
+    PermutationType post_perm(m); 
+    for (Index i = 0; i < m; i++) 
+      post_perm.indices()(i) = post(i); 
+        
+    // Combine the two permutations : postorder the permutation for future use
+    if(m_perm_c.size()) {
+      m_perm_c = post_perm * m_perm_c;
+    }
+    
+  } // end postordering 
+  
+  m_analysisIsOk = true; 
+}
+
+// Functions needed by the numerical factorization phase
+
+
+/** 
+  *  - Numerical factorization 
+  *  - Interleaved with the symbolic factorization 
+  * On exit,  info is 
+  * 
+  *    = 0: successful factorization
+  * 
+  *    > 0: if info = i, and i is
+  * 
+  *       <= A->ncol: U(i,i) is exactly zero. The factorization has
+  *          been completed, but the factor U is exactly singular,
+  *          and division by zero will occur if it is used to solve a
+  *          system of equations.
+  * 
+  *       > A->ncol: number of bytes allocated when memory allocation
+  *         failure occurred, plus A->ncol. If lwork = -1, it is
+  *         the estimated amount of space needed, plus A->ncol.  
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseLU<MatrixType, OrderingType>::factorize(const MatrixType& matrix)
+{
+  using internal::emptyIdxLU;
+  eigen_assert(m_analysisIsOk && "analyzePattern() should be called first"); 
+  eigen_assert((matrix.rows() == matrix.cols()) && "Only for squared matrices");
+  
+  m_isInitialized = true;
+  
+  // Apply the column permutation computed in analyzepattern()
+  //   m_mat = matrix * m_perm_c.inverse(); 
+  m_mat = matrix;
+  if (m_perm_c.size()) 
+  {
+    m_mat.uncompress(); //NOTE: The effect of this command is only to create the InnerNonzeros pointers.
+    //Then, permute only the column pointers
+    const StorageIndex * outerIndexPtr;
+    if (matrix.isCompressed()) outerIndexPtr = matrix.outerIndexPtr();
+    else
+    {
+      StorageIndex* outerIndexPtr_t = new StorageIndex[matrix.cols()+1];
+      for(Index i = 0; i <= matrix.cols(); i++) outerIndexPtr_t[i] = m_mat.outerIndexPtr()[i];
+      outerIndexPtr = outerIndexPtr_t;
+    }
+    for (Index i = 0; i < matrix.cols(); i++)
+    {
+      m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
+      m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i+1] - outerIndexPtr[i];
+    }
+    if(!matrix.isCompressed()) delete[] outerIndexPtr;
+  } 
+  else 
+  { //FIXME This should not be needed if the empty permutation is handled transparently
+    m_perm_c.resize(matrix.cols());
+    for(StorageIndex i = 0; i < matrix.cols(); ++i) m_perm_c.indices()(i) = i;
+  }
+  
+  Index m = m_mat.rows();
+  Index n = m_mat.cols();
+  Index nnz = m_mat.nonZeros();
+  Index maxpanel = m_perfv.panel_size * m;
+  // Allocate working storage common to the factor routines
+  Index lwork = 0;
+  Index info = Base::memInit(m, n, nnz, lwork, m_perfv.fillfactor, m_perfv.panel_size, m_glu); 
+  if (info) 
+  {
+    m_lastError = "UNABLE TO ALLOCATE WORKING MEMORY\n\n" ;
+    m_factorizationIsOk = false;
+    return ; 
+  }
+  
+  // Set up pointers for integer working arrays 
+  IndexVector segrep(m); segrep.setZero();
+  IndexVector parent(m); parent.setZero();
+  IndexVector xplore(m); xplore.setZero();
+  IndexVector repfnz(maxpanel);
+  IndexVector panel_lsub(maxpanel);
+  IndexVector xprune(n); xprune.setZero();
+  IndexVector marker(m*internal::LUNoMarker); marker.setZero();
+  
+  repfnz.setConstant(-1); 
+  panel_lsub.setConstant(-1);
+  
+  // Set up pointers for scalar working arrays 
+  ScalarVector dense; 
+  dense.setZero(maxpanel);
+  ScalarVector tempv; 
+  tempv.setZero(internal::LUnumTempV(m, m_perfv.panel_size, m_perfv.maxsuper, /*m_perfv.rowblk*/m) );
+  
+  // Compute the inverse of perm_c
+  PermutationType iperm_c(m_perm_c.inverse()); 
+  
+  // Identify initial relaxed snodes
+  IndexVector relax_end(n);
+  if ( m_symmetricmode == true ) 
+    Base::heap_relax_snode(n, m_etree, m_perfv.relax, marker, relax_end);
+  else
+    Base::relax_snode(n, m_etree, m_perfv.relax, marker, relax_end);
+  
+  
+  m_perm_r.resize(m); 
+  m_perm_r.indices().setConstant(-1);
+  marker.setConstant(-1);
+  m_detPermR = 1; // Record the determinant of the row permutation
+  
+  m_glu.supno(0) = emptyIdxLU; m_glu.xsup.setConstant(0);
+  m_glu.xsup(0) = m_glu.xlsub(0) = m_glu.xusub(0) = m_glu.xlusup(0) = Index(0);
+  
+  // Work on one 'panel' at a time. A panel is one of the following :
+  //  (a) a relaxed supernode at the bottom of the etree, or
+  //  (b) panel_size contiguous columns, <panel_size> defined by the user
+  Index jcol; 
+  Index pivrow; // Pivotal row number in the original row matrix
+  Index nseg1; // Number of segments in U-column above panel row jcol
+  Index nseg; // Number of segments in each U-column 
+  Index irep; 
+  Index i, k, jj; 
+  for (jcol = 0; jcol < n; )
+  {
+    // Adjust panel size so that a panel won't overlap with the next relaxed snode. 
+    Index panel_size = m_perfv.panel_size; // upper bound on panel width
+    for (k = jcol + 1; k < (std::min)(jcol+panel_size, n); k++)
+    {
+      if (relax_end(k) != emptyIdxLU) 
+      {
+        panel_size = k - jcol; 
+        break; 
+      }
+    }
+    if (k == n) 
+      panel_size = n - jcol; 
+      
+    // Symbolic outer factorization on a panel of columns 
+    Base::panel_dfs(m, panel_size, jcol, m_mat, m_perm_r.indices(), nseg1, dense, panel_lsub, segrep, repfnz, xprune, marker, parent, xplore, m_glu); 
+    
+    // Numeric sup-panel updates in topological order 
+    Base::panel_bmod(m, panel_size, jcol, nseg1, dense, tempv, segrep, repfnz, m_glu); 
+    
+    // Sparse LU within the panel, and below the panel diagonal 
+    for ( jj = jcol; jj< jcol + panel_size; jj++) 
+    {
+      k = (jj - jcol) * m; // Column index for w-wide arrays 
+      
+      nseg = nseg1; // begin after all the panel segments
+      //Depth-first-search for the current column
+      VectorBlock<IndexVector> panel_lsubk(panel_lsub, k, m);
+      VectorBlock<IndexVector> repfnz_k(repfnz, k, m); 
+      info = Base::column_dfs(m, jj, m_perm_r.indices(), m_perfv.maxsuper, nseg, panel_lsubk, segrep, repfnz_k, xprune, marker, parent, xplore, m_glu); 
+      if ( info ) 
+      {
+        m_lastError =  "UNABLE TO EXPAND MEMORY IN COLUMN_DFS() ";
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      // Numeric updates to this column 
+      VectorBlock<ScalarVector> dense_k(dense, k, m); 
+      VectorBlock<IndexVector> segrep_k(segrep, nseg1, m-nseg1); 
+      info = Base::column_bmod(jj, (nseg - nseg1), dense_k, tempv, segrep_k, repfnz_k, jcol, m_glu); 
+      if ( info ) 
+      {
+        m_lastError = "UNABLE TO EXPAND MEMORY IN COLUMN_BMOD() ";
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      
+      // Copy the U-segments to ucol(*)
+      info = Base::copy_to_ucol(jj, nseg, segrep, repfnz_k ,m_perm_r.indices(), dense_k, m_glu); 
+      if ( info ) 
+      {
+        m_lastError = "UNABLE TO EXPAND MEMORY IN COPY_TO_UCOL() ";
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      
+      // Form the L-segment 
+      info = Base::pivotL(jj, m_diagpivotthresh, m_perm_r.indices(), iperm_c.indices(), pivrow, m_glu);
+      if ( info ) 
+      {
+        m_lastError = "THE MATRIX IS STRUCTURALLY SINGULAR ... ZERO COLUMN AT ";
+        std::ostringstream returnInfo;
+        returnInfo << info; 
+        m_lastError += returnInfo.str();
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      
+      // Update the determinant of the row permutation matrix
+      // FIXME: the following test is not correct, we should probably take iperm_c into account and pivrow is not directly the row pivot.
+      if (pivrow != jj) m_detPermR = -m_detPermR;
+
+      // Prune columns (0:jj-1) using column jj
+      Base::pruneL(jj, m_perm_r.indices(), pivrow, nseg, segrep, repfnz_k, xprune, m_glu); 
+      
+      // Reset repfnz for this column 
+      for (i = 0; i < nseg; i++)
+      {
+        irep = segrep(i); 
+        repfnz_k(irep) = emptyIdxLU; 
+      }
+    } // end SparseLU within the panel  
+    jcol += panel_size;  // Move to the next panel
+  } // end for -- end elimination 
+  
+  m_detPermR = m_perm_r.determinant();
+  m_detPermC = m_perm_c.determinant();
+  
+  // Count the number of nonzeros in factors 
+  Base::countnz(n, m_nnzL, m_nnzU, m_glu); 
+  // Apply permutation  to the L subscripts 
+  Base::fixupL(n, m_perm_r.indices(), m_glu);
+  
+  // Create supernode matrix L 
+  m_Lstore.setInfos(m, n, m_glu.lusup, m_glu.xlusup, m_glu.lsub, m_glu.xlsub, m_glu.supno, m_glu.xsup); 
+  // Create the column major upper sparse matrix  U; 
+  new (&m_Ustore) MappedSparseMatrix<Scalar, ColMajor, StorageIndex> ( m, n, m_nnzU, m_glu.xusub.data(), m_glu.usub.data(), m_glu.ucol.data() );
+  
+  m_info = Success;
+  m_factorizationIsOk = true;
+}
+
+template<typename MappedSupernodalType>
+struct SparseLUMatrixLReturnType : internal::no_assignment_operator
+{
+  typedef typename MappedSupernodalType::Scalar Scalar;
+  explicit SparseLUMatrixLReturnType(const MappedSupernodalType& mapL) : m_mapL(mapL)
+  { }
+  Index rows() const { return m_mapL.rows(); }
+  Index cols() const { return m_mapL.cols(); }
+  template<typename Dest>
+  void solveInPlace( MatrixBase<Dest> &X) const
+  {
+    m_mapL.solveInPlace(X);
+  }
+  template<bool Conjugate, typename Dest>
+  void solveTransposedInPlace( MatrixBase<Dest> &X) const
+  {
+    m_mapL.template solveTransposedInPlace<Conjugate>(X);
+  }
+
+  const MappedSupernodalType& m_mapL;
+};
+
+template<typename MatrixLType, typename MatrixUType>
+struct SparseLUMatrixUReturnType : internal::no_assignment_operator
+{
+  typedef typename MatrixLType::Scalar Scalar;
+  SparseLUMatrixUReturnType(const MatrixLType& mapL, const MatrixUType& mapU)
+  : m_mapL(mapL),m_mapU(mapU)
+  { }
+  Index rows() const { return m_mapL.rows(); }
+  Index cols() const { return m_mapL.cols(); }
+
+  template<typename Dest>   void solveInPlace(MatrixBase<Dest> &X) const
+  {
+    Index nrhs = X.cols();
+    Index n    = X.rows();
+    // Backward solve with U
+    for (Index k = m_mapL.nsuper(); k >= 0; k--)
+    {
+      Index fsupc = m_mapL.supToCol()[k];
+      Index lda = m_mapL.colIndexPtr()[fsupc+1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
+      Index nsupc = m_mapL.supToCol()[k+1] - fsupc;
+      Index luptr = m_mapL.colIndexPtr()[fsupc];
+
+      if (nsupc == 1)
+      {
+        for (Index j = 0; j < nrhs; j++)
+        {
+          X(fsupc, j) /= m_mapL.valuePtr()[luptr];
+        }
+      }
+      else
+      {
+        // FIXME: the following lines should use Block expressions and not Map!
+        Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(m_mapL.valuePtr()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+        Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X.coeffRef(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
+        U = A.template triangularView<Upper>().solve(U);
+      }
+
+      for (Index j = 0; j < nrhs; ++j)
+      {
+        for (Index jcol = fsupc; jcol < fsupc + nsupc; jcol++)
+        {
+          typename MatrixUType::InnerIterator it(m_mapU, jcol);
+          for ( ; it; ++it)
+          {
+            Index irow = it.index();
+            X(irow, j) -= X(jcol, j) * it.value();
+          }
+        }
+      }
+    } // End For U-solve
+  }
+
+  template<bool Conjugate, typename Dest>   void solveTransposedInPlace(MatrixBase<Dest> &X) const
+  {
+    using numext::conj;
+    Index nrhs = X.cols();
+    Index n    = X.rows();
+    // Forward solve with U
+    for (Index k = 0; k <=  m_mapL.nsuper(); k++)
+    {
+      Index fsupc = m_mapL.supToCol()[k];
+      Index lda = m_mapL.colIndexPtr()[fsupc+1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
+      Index nsupc = m_mapL.supToCol()[k+1] - fsupc;
+      Index luptr = m_mapL.colIndexPtr()[fsupc];
+
+      for (Index j = 0; j < nrhs; ++j)
+      {
+        for (Index jcol = fsupc; jcol < fsupc + nsupc; jcol++)
+        {
+          typename MatrixUType::InnerIterator it(m_mapU, jcol);
+          for ( ; it; ++it)
+          {
+            Index irow = it.index();
+            X(jcol, j) -= X(irow, j) * (Conjugate? conj(it.value()): it.value());
+          }
+        }
+      }
+      if (nsupc == 1)
+      {
+        for (Index j = 0; j < nrhs; j++)
+        {
+          X(fsupc, j) /= (Conjugate? conj(m_mapL.valuePtr()[luptr]) : m_mapL.valuePtr()[luptr]);
+        }
+      }
+      else
+      {
+        Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(m_mapL.valuePtr()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+        Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
+        if(Conjugate)
+          U = A.adjoint().template triangularView<Lower>().solve(U);
+        else
+          U = A.transpose().template triangularView<Lower>().solve(U);
+      }
+    }// End For U-solve
+  }
+
+
+  const MatrixLType& m_mapL;
+  const MatrixUType& m_mapU;
+};
+
+} // End namespace Eigen 
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLUImpl.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLUImpl.h
new file mode 100644
index 00000000..fc0cfc4d
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLUImpl.h
@@ -0,0 +1,66 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#ifndef SPARSELU_IMPL_H
+#define SPARSELU_IMPL_H
+
+namespace Eigen {
+namespace internal {
+  
+/** \ingroup SparseLU_Module
+  * \class SparseLUImpl
+  * Base class for sparseLU
+  */
+template <typename Scalar, typename StorageIndex>
+class SparseLUImpl
+{
+  public:
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector; 
+    typedef Matrix<Scalar,Dynamic,Dynamic,ColMajor> ScalarMatrix;
+    typedef Map<ScalarMatrix, 0,  OuterStride<> > MappedMatrixBlock;
+    typedef typename ScalarVector::RealScalar RealScalar; 
+    typedef Ref<Matrix<Scalar,Dynamic,1> > BlockScalarVector;
+    typedef Ref<Matrix<StorageIndex,Dynamic,1> > BlockIndexVector;
+    typedef LU_GlobalLU_t<IndexVector, ScalarVector> GlobalLU_t; 
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> MatrixType; 
+    
+  protected:
+     template <typename VectorType>
+     Index expand(VectorType& vec, Index& length, Index nbElts, Index keep_prev, Index& num_expansions);
+     Index memInit(Index m, Index n, Index annz, Index lwork, Index fillratio, Index panel_size,  GlobalLU_t& glu); 
+     template <typename VectorType>
+     Index memXpand(VectorType& vec, Index& maxlen, Index nbElts, MemType memtype, Index& num_expansions);
+     void heap_relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end); 
+     void relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end); 
+     Index snode_dfs(const Index jcol, const Index kcol,const MatrixType& mat,  IndexVector& xprune, IndexVector& marker, GlobalLU_t& glu); 
+     Index snode_bmod (const Index jcol, const Index fsupc, ScalarVector& dense, GlobalLU_t& glu);
+     Index pivotL(const Index jcol, const RealScalar& diagpivotthresh, IndexVector& perm_r, IndexVector& iperm_c, Index& pivrow, GlobalLU_t& glu);
+     template <typename Traits>
+     void dfs_kernel(const StorageIndex jj, IndexVector& perm_r,
+                    Index& nseg, IndexVector& panel_lsub, IndexVector& segrep,
+                    Ref<IndexVector> repfnz_col, IndexVector& xprune, Ref<IndexVector> marker, IndexVector& parent,
+                    IndexVector& xplore, GlobalLU_t& glu, Index& nextl_col, Index krow, Traits& traits);
+     void panel_dfs(const Index m, const Index w, const Index jcol, MatrixType& A, IndexVector& perm_r, Index& nseg, ScalarVector& dense, IndexVector& panel_lsub, IndexVector& segrep, IndexVector& repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu);
+    
+     void panel_bmod(const Index m, const Index w, const Index jcol, const Index nseg, ScalarVector& dense, ScalarVector& tempv, IndexVector& segrep, IndexVector& repfnz, GlobalLU_t& glu);
+     Index column_dfs(const Index m, const Index jcol, IndexVector& perm_r, Index maxsuper, Index& nseg,  BlockIndexVector lsub_col, IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu);
+     Index column_bmod(const Index jcol, const Index nseg, BlockScalarVector dense, ScalarVector& tempv, BlockIndexVector segrep, BlockIndexVector repfnz, Index fpanelc, GlobalLU_t& glu); 
+     Index copy_to_ucol(const Index jcol, const Index nseg, IndexVector& segrep, BlockIndexVector repfnz ,IndexVector& perm_r, BlockScalarVector dense, GlobalLU_t& glu); 
+     void pruneL(const Index jcol, const IndexVector& perm_r, const Index pivrow, const Index nseg, const IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, GlobalLU_t& glu);
+     void countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu); 
+     void fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu); 
+     
+     template<typename , typename >
+     friend struct column_dfs_traits;
+}; 
+
+} // end namespace internal
+} // namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_Memory.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_Memory.h
new file mode 100644
index 00000000..349bfd58
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_Memory.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]memory.c files in SuperLU 
+ 
+ * -- SuperLU routine (version 3.1) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * August 1, 2008
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+
+#ifndef EIGEN_SPARSELU_MEMORY
+#define EIGEN_SPARSELU_MEMORY
+
+namespace Eigen {
+namespace internal {
+  
+enum { LUNoMarker = 3 };
+enum {emptyIdxLU = -1};
+inline Index LUnumTempV(Index& m, Index& w, Index& t, Index& b)
+{
+  return (std::max)(m, (t+b)*w);
+}
+
+template< typename Scalar>
+inline Index LUTempSpace(Index&m, Index& w)
+{
+  return (2*w + 4 + LUNoMarker) * m * sizeof(Index) + (w + 1) * m * sizeof(Scalar);
+}
+
+
+
+
+/** 
+  * Expand the existing storage to accommodate more fill-ins
+  * \param vec Valid pointer to the vector to allocate or expand
+  * \param[in,out] length  At input, contain the current length of the vector that is to be increased. At output, length of the newly allocated vector
+  * \param[in] nbElts Current number of elements in the factors
+  * \param keep_prev  1: use length  and do not expand the vector; 0: compute new_len and expand
+  * \param[in,out] num_expansions Number of times the memory has been expanded
+  */
+template <typename Scalar, typename StorageIndex>
+template <typename VectorType>
+Index  SparseLUImpl<Scalar,StorageIndex>::expand(VectorType& vec, Index& length, Index nbElts, Index keep_prev, Index& num_expansions) 
+{
+  
+  float alpha = 1.5; // Ratio of the memory increase 
+  Index new_len; // New size of the allocated memory
+  
+  if(num_expansions == 0 || keep_prev) 
+    new_len = length ; // First time allocate requested
+  else 
+    new_len = (std::max)(length+1,Index(alpha * length));
+  
+  VectorType old_vec; // Temporary vector to hold the previous values   
+  if (nbElts > 0 )
+    old_vec = vec.segment(0,nbElts); 
+  
+  //Allocate or expand the current vector
+#ifdef EIGEN_EXCEPTIONS
+  try
+#endif
+  {
+    vec.resize(new_len); 
+  }
+#ifdef EIGEN_EXCEPTIONS
+  catch(std::bad_alloc& )
+#else
+  if(!vec.size())
+#endif
+  {
+    if (!num_expansions)
+    {
+      // First time to allocate from LUMemInit()
+      // Let LUMemInit() deals with it.
+      return -1;
+    }
+    if (keep_prev)
+    {
+      // In this case, the memory length should not not be reduced
+      return new_len;
+    }
+    else 
+    {
+      // Reduce the size and increase again 
+      Index tries = 0; // Number of attempts
+      do 
+      {
+        alpha = (alpha + 1)/2;
+        new_len = (std::max)(length+1,Index(alpha * length));
+#ifdef EIGEN_EXCEPTIONS
+        try
+#endif
+        {
+          vec.resize(new_len); 
+        }
+#ifdef EIGEN_EXCEPTIONS
+        catch(std::bad_alloc& )
+#else
+        if (!vec.size())
+#endif
+        {
+          tries += 1; 
+          if ( tries > 10) return new_len; 
+        }
+      } while (!vec.size());
+    }
+  }
+  //Copy the previous values to the newly allocated space 
+  if (nbElts > 0)
+    vec.segment(0, nbElts) = old_vec;   
+   
+  
+  length  = new_len;
+  if(num_expansions) ++num_expansions;
+  return 0; 
+}
+
+/**
+ * \brief  Allocate various working space for the numerical factorization phase.
+ * \param m number of rows of the input matrix 
+ * \param n number of columns 
+ * \param annz number of initial nonzeros in the matrix 
+ * \param lwork  if lwork=-1, this routine returns an estimated size of the required memory
+ * \param glu persistent data to facilitate multiple factors : will be deleted later ??
+ * \param fillratio estimated ratio of fill in the factors
+ * \param panel_size Size of a panel
+ * \return an estimated size of the required memory if lwork = -1; otherwise, return the size of actually allocated memory when allocation failed, and 0 on success
+ * \note Unlike SuperLU, this routine does not support successive factorization with the same pattern and the same row permutation
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::memInit(Index m, Index n, Index annz, Index lwork, Index fillratio, Index panel_size,  GlobalLU_t& glu)
+{
+  Index& num_expansions = glu.num_expansions; //No memory expansions so far
+  num_expansions = 0;
+  glu.nzumax = glu.nzlumax = (std::min)(fillratio * (annz+1) / n, m) * n; // estimated number of nonzeros in U 
+  glu.nzlmax = (std::max)(Index(4), fillratio) * (annz+1) / 4; // estimated  nnz in L factor
+  // Return the estimated size to the user if necessary
+  Index tempSpace;
+  tempSpace = (2*panel_size + 4 + LUNoMarker) * m * sizeof(Index) + (panel_size + 1) * m * sizeof(Scalar);
+  if (lwork == emptyIdxLU) 
+  {
+    Index estimated_size;
+    estimated_size = (5 * n + 5) * sizeof(Index)  + tempSpace
+                    + (glu.nzlmax + glu.nzumax) * sizeof(Index) + (glu.nzlumax+glu.nzumax) *  sizeof(Scalar) + n; 
+    return estimated_size;
+  }
+  
+  // Setup the required space 
+  
+  // First allocate Integer pointers for L\U factors
+  glu.xsup.resize(n+1);
+  glu.supno.resize(n+1);
+  glu.xlsub.resize(n+1);
+  glu.xlusup.resize(n+1);
+  glu.xusub.resize(n+1);
+
+  // Reserve memory for L/U factors
+  do 
+  {
+    if(     (expand<ScalarVector>(glu.lusup, glu.nzlumax, 0, 0, num_expansions)<0)
+        ||  (expand<ScalarVector>(glu.ucol,  glu.nzumax,  0, 0, num_expansions)<0)
+        ||  (expand<IndexVector> (glu.lsub,  glu.nzlmax,  0, 0, num_expansions)<0)
+        ||  (expand<IndexVector> (glu.usub,  glu.nzumax,  0, 1, num_expansions)<0) )
+    {
+      //Reduce the estimated size and retry
+      glu.nzlumax /= 2;
+      glu.nzumax /= 2;
+      glu.nzlmax /= 2;
+      if (glu.nzlumax < annz ) return glu.nzlumax; 
+    }
+  } while (!glu.lusup.size() || !glu.ucol.size() || !glu.lsub.size() || !glu.usub.size());
+  
+  ++num_expansions;
+  return 0;
+  
+} // end LuMemInit
+
+/** 
+ * \brief Expand the existing storage 
+ * \param vec vector to expand 
+ * \param[in,out] maxlen On input, previous size of vec (Number of elements to copy ). on output, new size
+ * \param nbElts current number of elements in the vector.
+ * \param memtype Type of the element to expand
+ * \param num_expansions Number of expansions 
+ * \return 0 on success, > 0 size of the memory allocated so far
+ */
+template <typename Scalar, typename StorageIndex>
+template <typename VectorType>
+Index SparseLUImpl<Scalar,StorageIndex>::memXpand(VectorType& vec, Index& maxlen, Index nbElts, MemType memtype, Index& num_expansions)
+{
+  Index failed_size; 
+  if (memtype == USUB)
+     failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 1, num_expansions);
+  else
+    failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 0, num_expansions);
+
+  if (failed_size)
+    return failed_size; 
+  
+  return 0 ;  
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // EIGEN_SPARSELU_MEMORY
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_Structs.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_Structs.h
new file mode 100644
index 00000000..cf5ec449
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_Structs.h
@@ -0,0 +1,110 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ * NOTE: This file comes from a partly modified version of files slu_[s,d,c,z]defs.h
+ * -- SuperLU routine (version 4.1) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November, 2010
+ * 
+ * Global data structures used in LU factorization -
+ * 
+ *   nsuper: #supernodes = nsuper + 1, numbered [0, nsuper].
+ *   (xsup,supno): supno[i] is the supernode no to which i belongs;
+ *  xsup(s) points to the beginning of the s-th supernode.
+ *  e.g.   supno 0 1 2 2 3 3 3 4 4 4 4 4   (n=12)
+ *          xsup 0 1 2 4 7 12
+ *  Note: dfs will be performed on supernode rep. relative to the new 
+ *        row pivoting ordering
+ *
+ *   (xlsub,lsub): lsub[*] contains the compressed subscript of
+ *  rectangular supernodes; xlsub[j] points to the starting
+ *  location of the j-th column in lsub[*]. Note that xlsub 
+ *  is indexed by column.
+ *  Storage: original row subscripts
+ *
+ *      During the course of sparse LU factorization, we also use
+ *  (xlsub,lsub) for the purpose of symmetric pruning. For each
+ *  supernode {s,s+1,...,t=s+r} with first column s and last
+ *  column t, the subscript set
+ *    lsub[j], j=xlsub[s], .., xlsub[s+1]-1
+ *  is the structure of column s (i.e. structure of this supernode).
+ *  It is used for the storage of numerical values.
+ *  Furthermore,
+ *    lsub[j], j=xlsub[t], .., xlsub[t+1]-1
+ *  is the structure of the last column t of this supernode.
+ *  It is for the purpose of symmetric pruning. Therefore, the
+ *  structural subscripts can be rearranged without making physical
+ *  interchanges among the numerical values.
+ *
+ *  However, if the supernode has only one column, then we
+ *  only keep one set of subscripts. For any subscript interchange
+ *  performed, similar interchange must be done on the numerical
+ *  values.
+ *
+ *  The last column structures (for pruning) will be removed
+ *  after the numercial LU factorization phase.
+ *
+ *   (xlusup,lusup): lusup[*] contains the numerical values of the
+ *  rectangular supernodes; xlusup[j] points to the starting
+ *  location of the j-th column in storage vector lusup[*]
+ *  Note: xlusup is indexed by column.
+ *  Each rectangular supernode is stored by column-major
+ *  scheme, consistent with Fortran 2-dim array storage.
+ *
+ *   (xusub,ucol,usub): ucol[*] stores the numerical values of
+ *  U-columns outside the rectangular supernodes. The row
+ *  subscript of nonzero ucol[k] is stored in usub[k].
+ *  xusub[i] points to the starting location of column i in ucol.
+ *  Storage: new row subscripts; that is subscripts of PA.
+ */
+
+#ifndef EIGEN_LU_STRUCTS
+#define EIGEN_LU_STRUCTS
+namespace Eigen {
+namespace internal {
+  
+typedef enum {LUSUP, UCOL, LSUB, USUB, LLVL, ULVL} MemType; 
+
+template <typename IndexVector, typename ScalarVector>
+struct LU_GlobalLU_t {
+  typedef typename IndexVector::Scalar StorageIndex; 
+  IndexVector xsup; //First supernode column ... xsup(s) points to the beginning of the s-th supernode
+  IndexVector supno; // Supernode number corresponding to this column (column to supernode mapping)
+  ScalarVector  lusup; // nonzero values of L ordered by columns 
+  IndexVector lsub; // Compressed row indices of L rectangular supernodes. 
+  IndexVector xlusup; // pointers to the beginning of each column in lusup
+  IndexVector xlsub; // pointers to the beginning of each column in lsub
+  Index   nzlmax; // Current max size of lsub
+  Index   nzlumax; // Current max size of lusup
+  ScalarVector  ucol; // nonzero values of U ordered by columns 
+  IndexVector usub; // row indices of U columns in ucol
+  IndexVector xusub; // Pointers to the beginning of each column of U in ucol 
+  Index   nzumax; // Current max size of ucol
+  Index   n; // Number of columns in the matrix  
+  Index   num_expansions; 
+};
+
+// Values to set for performance
+struct perfvalues {
+  Index panel_size; // a panel consists of at most <panel_size> consecutive columns
+  Index relax; // To control degree of relaxing supernodes. If the number of nodes (columns) 
+                // in a subtree of the elimination tree is less than relax, this subtree is considered 
+                // as one supernode regardless of the row structures of those columns
+  Index maxsuper; // The maximum size for a supernode in complete LU
+  Index rowblk; // The minimum row dimension for 2-D blocking to be used;
+  Index colblk; // The minimum column dimension for 2-D blocking to be used;
+  Index fillfactor; // The estimated fills factors for L and U, compared with A
+}; 
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // EIGEN_LU_STRUCTS
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h
new file mode 100644
index 00000000..0be293d1
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h
@@ -0,0 +1,375 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
+#define EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
+
+namespace Eigen {
+namespace internal {
+
+/** \ingroup SparseLU_Module
+ * \brief a class to manipulate the L supernodal factor from the SparseLU factorization
+ * 
+ * This class  contain the data to easily store 
+ * and manipulate the supernodes during the factorization and solution phase of Sparse LU. 
+ * Only the lower triangular matrix has supernodes.
+ * 
+ * NOTE : This class corresponds to the SCformat structure in SuperLU
+ * 
+ */
+/* TODO
+ * InnerIterator as for sparsematrix 
+ * SuperInnerIterator to iterate through all supernodes 
+ * Function for triangular solve
+ */
+template <typename _Scalar, typename _StorageIndex>
+class MappedSuperNodalMatrix
+{
+  public:
+    typedef _Scalar Scalar; 
+    typedef _StorageIndex StorageIndex;
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+  public:
+    MappedSuperNodalMatrix()
+    {
+      
+    }
+    MappedSuperNodalMatrix(Index m, Index n,  ScalarVector& nzval, IndexVector& nzval_colptr, IndexVector& rowind,
+             IndexVector& rowind_colptr, IndexVector& col_to_sup, IndexVector& sup_to_col )
+    {
+      setInfos(m, n, nzval, nzval_colptr, rowind, rowind_colptr, col_to_sup, sup_to_col);
+    }
+    
+    ~MappedSuperNodalMatrix()
+    {
+      
+    }
+    /**
+     * Set appropriate pointers for the lower triangular supernodal matrix
+     * These infos are available at the end of the numerical factorization
+     * FIXME This class will be modified such that it can be use in the course 
+     * of the factorization.
+     */
+    void setInfos(Index m, Index n, ScalarVector& nzval, IndexVector& nzval_colptr, IndexVector& rowind,
+             IndexVector& rowind_colptr, IndexVector& col_to_sup, IndexVector& sup_to_col )
+    {
+      m_row = m;
+      m_col = n; 
+      m_nzval = nzval.data(); 
+      m_nzval_colptr = nzval_colptr.data(); 
+      m_rowind = rowind.data(); 
+      m_rowind_colptr = rowind_colptr.data(); 
+      m_nsuper = col_to_sup(n); 
+      m_col_to_sup = col_to_sup.data(); 
+      m_sup_to_col = sup_to_col.data(); 
+    }
+    
+    /**
+     * Number of rows
+     */
+    Index rows() const { return m_row; }
+    
+    /**
+     * Number of columns
+     */
+    Index cols() const { return m_col; }
+    
+    /**
+     * Return the array of nonzero values packed by column
+     * 
+     * The size is nnz
+     */
+    Scalar* valuePtr() {  return m_nzval; }
+    
+    const Scalar* valuePtr() const 
+    {
+      return m_nzval; 
+    }
+    /**
+     * Return the pointers to the beginning of each column in \ref valuePtr()
+     */
+    StorageIndex* colIndexPtr()
+    {
+      return m_nzval_colptr; 
+    }
+    
+    const StorageIndex* colIndexPtr() const
+    {
+      return m_nzval_colptr; 
+    }
+    
+    /**
+     * Return the array of compressed row indices of all supernodes
+     */
+    StorageIndex* rowIndex()  { return m_rowind; }
+    
+    const StorageIndex* rowIndex() const
+    {
+      return m_rowind; 
+    }
+    
+    /**
+     * Return the location in \em rowvaluePtr() which starts each column
+     */
+    StorageIndex* rowIndexPtr() { return m_rowind_colptr; }
+    
+    const StorageIndex* rowIndexPtr() const
+    {
+      return m_rowind_colptr; 
+    }
+    
+    /** 
+     * Return the array of column-to-supernode mapping 
+     */
+    StorageIndex* colToSup()  { return m_col_to_sup; }
+    
+    const StorageIndex* colToSup() const
+    {
+      return m_col_to_sup;       
+    }
+    /**
+     * Return the array of supernode-to-column mapping
+     */
+    StorageIndex* supToCol() { return m_sup_to_col; }
+    
+    const StorageIndex* supToCol() const
+    {
+      return m_sup_to_col;
+    }
+    
+    /**
+     * Return the number of supernodes
+     */
+    Index nsuper() const
+    {
+      return m_nsuper; 
+    }
+    
+    class InnerIterator; 
+    template<typename Dest>
+    void solveInPlace( MatrixBase<Dest>&X) const;
+    template<bool Conjugate, typename Dest>
+    void solveTransposedInPlace( MatrixBase<Dest>&X) const;
+
+    
+      
+      
+    
+  protected:
+    Index m_row; // Number of rows
+    Index m_col; // Number of columns
+    Index m_nsuper; // Number of supernodes
+    Scalar* m_nzval; //array of nonzero values packed by column
+    StorageIndex* m_nzval_colptr; //nzval_colptr[j] Stores the location in nzval[] which starts column j
+    StorageIndex* m_rowind; // Array of compressed row indices of rectangular supernodes
+    StorageIndex* m_rowind_colptr; //rowind_colptr[j] stores the location in rowind[] which starts column j
+    StorageIndex* m_col_to_sup; // col_to_sup[j] is the supernode number to which column j belongs
+    StorageIndex* m_sup_to_col; //sup_to_col[s] points to the starting column of the s-th supernode
+    
+  private :
+};
+
+/**
+  * \brief InnerIterator class to iterate over nonzero values of the current column in the supernodal matrix L
+  * 
+  */
+template<typename Scalar, typename StorageIndex>
+class MappedSuperNodalMatrix<Scalar,StorageIndex>::InnerIterator
+{
+  public:
+     InnerIterator(const MappedSuperNodalMatrix& mat, Index outer)
+      : m_matrix(mat),
+        m_outer(outer),
+        m_supno(mat.colToSup()[outer]),
+        m_idval(mat.colIndexPtr()[outer]),
+        m_startidval(m_idval),
+        m_endidval(mat.colIndexPtr()[outer+1]),
+        m_idrow(mat.rowIndexPtr()[mat.supToCol()[mat.colToSup()[outer]]]),
+        m_endidrow(mat.rowIndexPtr()[mat.supToCol()[mat.colToSup()[outer]]+1])
+    {}
+    inline InnerIterator& operator++()
+    { 
+      m_idval++; 
+      m_idrow++;
+      return *this;
+    }
+    inline Scalar value() const { return m_matrix.valuePtr()[m_idval]; }
+    
+    inline Scalar& valueRef() { return const_cast<Scalar&>(m_matrix.valuePtr()[m_idval]); }
+    
+    inline Index index() const { return m_matrix.rowIndex()[m_idrow]; }
+    inline Index row() const { return index(); }
+    inline Index col() const { return m_outer; }
+    
+    inline Index supIndex() const { return m_supno; }
+    
+    inline operator bool() const 
+    { 
+      return ( (m_idval < m_endidval) && (m_idval >= m_startidval)
+                && (m_idrow < m_endidrow) );
+    }
+    
+  protected:
+    const MappedSuperNodalMatrix& m_matrix; // Supernodal lower triangular matrix 
+    const Index m_outer;                    // Current column 
+    const Index m_supno;                    // Current SuperNode number
+    Index m_idval;                          // Index to browse the values in the current column
+    const Index m_startidval;               // Start of the column value
+    const Index m_endidval;                 // End of the column value
+    Index m_idrow;                          // Index to browse the row indices 
+    Index m_endidrow;                       // End index of row indices of the current column
+};
+
+/**
+ * \brief Solve with the supernode triangular matrix
+ * 
+ */
+template<typename Scalar, typename Index_>
+template<typename Dest>
+void MappedSuperNodalMatrix<Scalar,Index_>::solveInPlace( MatrixBase<Dest>&X) const
+{
+    /* Explicit type conversion as the Index type of MatrixBase<Dest> may be wider than Index */
+//    eigen_assert(X.rows() <= NumTraits<Index>::highest());
+//    eigen_assert(X.cols() <= NumTraits<Index>::highest());
+    Index n    = int(X.rows());
+    Index nrhs = Index(X.cols());
+    const Scalar * Lval = valuePtr();                 // Nonzero values 
+    Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor> work(n, nrhs);     // working vector
+    work.setZero();
+    for (Index k = 0; k <= nsuper(); k ++)
+    {
+      Index fsupc = supToCol()[k];                    // First column of the current supernode 
+      Index istart = rowIndexPtr()[fsupc];            // Pointer index to the subscript of the current column
+      Index nsupr = rowIndexPtr()[fsupc+1] - istart;  // Number of rows in the current supernode
+      Index nsupc = supToCol()[k+1] - fsupc;          // Number of columns in the current supernode
+      Index nrow = nsupr - nsupc;                     // Number of rows in the non-diagonal part of the supernode
+      Index irow;                                     //Current index row
+      
+      if (nsupc == 1 )
+      {
+        for (Index j = 0; j < nrhs; j++)
+        {
+          InnerIterator it(*this, fsupc);
+          ++it; // Skip the diagonal element
+          for (; it; ++it)
+          {
+            irow = it.row();
+            X(irow, j) -= X(fsupc, j) * it.value();
+          }
+        }
+      }
+      else
+      {
+        // The supernode has more than one column 
+        Index luptr = colIndexPtr()[fsupc]; 
+        Index lda = colIndexPtr()[fsupc+1] - luptr;
+        
+        // Triangular solve 
+        Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(Lval[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+        Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
+        U = A.template triangularView<UnitLower>().solve(U); 
+        
+        // Matrix-vector product 
+        new (&A) Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > ( &(Lval[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
+        work.topRows(nrow).noalias() = A * U;
+        
+        //Begin Scatter 
+        for (Index j = 0; j < nrhs; j++)
+        {
+          Index iptr = istart + nsupc; 
+          for (Index i = 0; i < nrow; i++)
+          {
+            irow = rowIndex()[iptr]; 
+            X(irow, j) -= work(i, j); // Scatter operation
+            work(i, j) = Scalar(0); 
+            iptr++;
+          }
+        }
+      }
+    } 
+}
+
+template<typename Scalar, typename Index_>
+template<bool Conjugate, typename Dest>
+void MappedSuperNodalMatrix<Scalar,Index_>::solveTransposedInPlace( MatrixBase<Dest>&X) const
+{
+    using numext::conj;
+  Index n    = int(X.rows());
+  Index nrhs = Index(X.cols());
+  const Scalar * Lval = valuePtr();                 // Nonzero values
+  Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor> work(n, nrhs);     // working vector
+  work.setZero();
+  for (Index k = nsuper(); k >= 0; k--)
+  {
+    Index fsupc = supToCol()[k];                    // First column of the current supernode
+    Index istart = rowIndexPtr()[fsupc];            // Pointer index to the subscript of the current column
+    Index nsupr = rowIndexPtr()[fsupc+1] - istart;  // Number of rows in the current supernode
+    Index nsupc = supToCol()[k+1] - fsupc;          // Number of columns in the current supernode
+    Index nrow = nsupr - nsupc;                     // Number of rows in the non-diagonal part of the supernode
+    Index irow;                                     //Current index row
+
+    if (nsupc == 1 )
+    {
+      for (Index j = 0; j < nrhs; j++)
+      {
+        InnerIterator it(*this, fsupc);
+        ++it; // Skip the diagonal element
+        for (; it; ++it)
+        {
+          irow = it.row();
+          X(fsupc,j) -= X(irow, j) * (Conjugate?conj(it.value()):it.value());
+        }
+      }
+    }
+    else
+    {
+      // The supernode has more than one column
+      Index luptr = colIndexPtr()[fsupc];
+      Index lda = colIndexPtr()[fsupc+1] - luptr;
+
+      //Begin Gather
+      for (Index j = 0; j < nrhs; j++)
+      {
+        Index iptr = istart + nsupc;
+        for (Index i = 0; i < nrow; i++)
+        {
+          irow = rowIndex()[iptr];
+          work.topRows(nrow)(i,j)= X(irow,j); // Gather operation
+          iptr++;
+        }
+      }
+
+      // Matrix-vector product with transposed submatrix
+      Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(Lval[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
+      Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
+      if(Conjugate)
+        U = U - A.adjoint() * work.topRows(nrow);
+      else
+        U = U - A.transpose() * work.topRows(nrow);
+
+      // Triangular solve (of transposed diagonal block)
+      new (&A) Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > ( &(Lval[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+      if(Conjugate)
+        U = A.adjoint().template triangularView<UnitUpper>().solve(U);
+      else
+        U = A.transpose().template triangularView<UnitUpper>().solve(U);
+
+    }
+
+  }
+}
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSELU_MATRIX_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_Utils.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_Utils.h
new file mode 100644
index 00000000..9e3dab44
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_Utils.h
@@ -0,0 +1,80 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_SPARSELU_UTILS_H
+#define EIGEN_SPARSELU_UTILS_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Count Nonzero elements in the factors
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu)
+{
+ nnzL = 0; 
+ nnzU = (glu.xusub)(n); 
+ Index nsuper = (glu.supno)(n); 
+ Index jlen; 
+ Index i, j, fsupc;
+ if (n <= 0 ) return; 
+ // For each supernode
+ for (i = 0; i <= nsuper; i++)
+ {
+   fsupc = glu.xsup(i); 
+   jlen = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
+   
+   for (j = fsupc; j < glu.xsup(i+1); j++)
+   {
+     nnzL += jlen; 
+     nnzU += j - fsupc + 1; 
+     jlen--; 
+   }
+ }
+}
+
+/**
+ * \brief Fix up the data storage lsub for L-subscripts. 
+ * 
+ * It removes the subscripts sets for structural pruning, 
+ * and applies permutation to the remaining subscripts
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu)
+{
+  Index fsupc, i, j, k, jstart; 
+  
+  StorageIndex nextl = 0; 
+  Index nsuper = (glu.supno)(n); 
+  
+  // For each supernode 
+  for (i = 0; i <= nsuper; i++)
+  {
+    fsupc = glu.xsup(i); 
+    jstart = glu.xlsub(fsupc); 
+    glu.xlsub(fsupc) = nextl; 
+    for (j = jstart; j < glu.xlsub(fsupc + 1); j++)
+    {
+      glu.lsub(nextl) = perm_r(glu.lsub(j)); // Now indexed into P*A
+      nextl++;
+    }
+    for (k = fsupc+1; k < glu.xsup(i+1); k++)
+      glu.xlsub(k) = nextl; // other columns in supernode i
+  }
+  
+  glu.xlsub(n) = nextl; 
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // EIGEN_SPARSELU_UTILS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_column_bmod.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_column_bmod.h
new file mode 100644
index 00000000..b57f0680
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_column_bmod.h
@@ -0,0 +1,181 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of xcolumn_bmod.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_COLUMN_BMOD_H
+#define SPARSELU_COLUMN_BMOD_H
+
+namespace Eigen {
+
+namespace internal {
+/**
+ * \brief Performs numeric block updates (sup-col) in topological order
+ * 
+ * \param jcol current column to update
+ * \param nseg Number of segments in the U part
+ * \param dense Store the full representation of the column
+ * \param tempv working array 
+ * \param segrep segment representative ...
+ * \param repfnz ??? First nonzero column in each row ???  ...
+ * \param fpanelc First column in the current panel
+ * \param glu Global LU data. 
+ * \return 0 - successful return 
+ *         > 0 - number of bytes allocated when run out of space
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::column_bmod(const Index jcol, const Index nseg, BlockScalarVector dense, ScalarVector& tempv,
+                                                     BlockIndexVector segrep, BlockIndexVector repfnz, Index fpanelc, GlobalLU_t& glu)
+{
+  Index  jsupno, k, ksub, krep, ksupno; 
+  Index lptr, nrow, isub, irow, nextlu, new_next, ufirst; 
+  Index fsupc, nsupc, nsupr, luptr, kfnz, no_zeros; 
+  /* krep = representative of current k-th supernode
+    * fsupc =  first supernodal column
+    * nsupc = number of columns in a supernode
+    * nsupr = number of rows in a supernode
+    * luptr = location of supernodal LU-block in storage
+    * kfnz = first nonz in the k-th supernodal segment
+    * no_zeros = no lf leading zeros in a supernodal U-segment
+    */
+  
+  jsupno = glu.supno(jcol);
+  // For each nonzero supernode segment of U[*,j] in topological order 
+  k = nseg - 1; 
+  Index d_fsupc; // distance between the first column of the current panel and the 
+               // first column of the current snode
+  Index fst_col; // First column within small LU update
+  Index segsize; 
+  for (ksub = 0; ksub < nseg; ksub++)
+  {
+    krep = segrep(k); k--; 
+    ksupno = glu.supno(krep); 
+    if (jsupno != ksupno )
+    {
+      // outside the rectangular supernode 
+      fsupc = glu.xsup(ksupno); 
+      fst_col = (std::max)(fsupc, fpanelc); 
+      
+      // Distance from the current supernode to the current panel; 
+      // d_fsupc = 0 if fsupc > fpanelc
+      d_fsupc = fst_col - fsupc; 
+      
+      luptr = glu.xlusup(fst_col) + d_fsupc; 
+      lptr = glu.xlsub(fsupc) + d_fsupc; 
+      
+      kfnz = repfnz(krep); 
+      kfnz = (std::max)(kfnz, fpanelc); 
+      
+      segsize = krep - kfnz + 1; 
+      nsupc = krep - fst_col + 1; 
+      nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
+      nrow = nsupr - d_fsupc - nsupc;
+      Index lda = glu.xlusup(fst_col+1) - glu.xlusup(fst_col);
+      
+      
+      // Perform a triangular solver and block update, 
+      // then scatter the result of sup-col update to dense
+      no_zeros = kfnz - fst_col; 
+      if(segsize==1)
+        LU_kernel_bmod<1>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+      else
+        LU_kernel_bmod<Dynamic>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+    } // end if jsupno 
+  } // end for each segment
+  
+  // Process the supernodal portion of  L\U[*,j]
+  nextlu = glu.xlusup(jcol); 
+  fsupc = glu.xsup(jsupno);
+  
+  // copy the SPA dense into L\U[*,j]
+  Index mem; 
+  new_next = nextlu + glu.xlsub(fsupc + 1) - glu.xlsub(fsupc); 
+  Index offset = internal::first_multiple<Index>(new_next, internal::packet_traits<Scalar>::size) - new_next;
+  if(offset)
+    new_next += offset;
+  while (new_next > glu.nzlumax )
+  {
+    mem = memXpand<ScalarVector>(glu.lusup, glu.nzlumax, nextlu, LUSUP, glu.num_expansions);  
+    if (mem) return mem; 
+  }
+  
+  for (isub = glu.xlsub(fsupc); isub < glu.xlsub(fsupc+1); isub++)
+  {
+    irow = glu.lsub(isub);
+    glu.lusup(nextlu) = dense(irow);
+    dense(irow) = Scalar(0.0); 
+    ++nextlu; 
+  }
+  
+  if(offset)
+  {
+    glu.lusup.segment(nextlu,offset).setZero();
+    nextlu += offset;
+  }
+  glu.xlusup(jcol + 1) = StorageIndex(nextlu);  // close L\U(*,jcol); 
+  
+  /* For more updates within the panel (also within the current supernode),
+   * should start from the first column of the panel, or the first column
+   * of the supernode, whichever is bigger. There are two cases:
+   *  1) fsupc < fpanelc, then fst_col <-- fpanelc
+   *  2) fsupc >= fpanelc, then fst_col <-- fsupc
+   */
+  fst_col = (std::max)(fsupc, fpanelc); 
+  
+  if (fst_col  < jcol)
+  {
+    // Distance between the current supernode and the current panel
+    // d_fsupc = 0 if fsupc >= fpanelc
+    d_fsupc = fst_col - fsupc; 
+    
+    lptr = glu.xlsub(fsupc) + d_fsupc; 
+    luptr = glu.xlusup(fst_col) + d_fsupc; 
+    nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); // leading dimension
+    nsupc = jcol - fst_col; // excluding jcol 
+    nrow = nsupr - d_fsupc - nsupc; 
+    
+    // points to the beginning of jcol in snode L\U(jsupno) 
+    ufirst = glu.xlusup(jcol) + d_fsupc; 
+    Index lda = glu.xlusup(jcol+1) - glu.xlusup(jcol);
+    MappedMatrixBlock A( &(glu.lusup.data()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+    VectorBlock<ScalarVector> u(glu.lusup, ufirst, nsupc); 
+    u = A.template triangularView<UnitLower>().solve(u); 
+    
+    new (&A) MappedMatrixBlock ( &(glu.lusup.data()[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
+    VectorBlock<ScalarVector> l(glu.lusup, ufirst+nsupc, nrow); 
+    l.noalias() -= A * u;
+    
+  } // End if fst_col
+  return 0; 
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_COLUMN_BMOD_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_column_dfs.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_column_dfs.h
new file mode 100644
index 00000000..5a2c941b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_column_dfs.h
@@ -0,0 +1,179 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]column_dfs.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_COLUMN_DFS_H
+#define SPARSELU_COLUMN_DFS_H
+
+template <typename Scalar, typename StorageIndex> class SparseLUImpl;
+namespace Eigen {
+
+namespace internal {
+
+template<typename IndexVector, typename ScalarVector>
+struct column_dfs_traits : no_assignment_operator
+{
+  typedef typename ScalarVector::Scalar Scalar;
+  typedef typename IndexVector::Scalar StorageIndex;
+  column_dfs_traits(Index jcol, Index& jsuper, typename SparseLUImpl<Scalar, StorageIndex>::GlobalLU_t& glu, SparseLUImpl<Scalar, StorageIndex>& luImpl)
+   : m_jcol(jcol), m_jsuper_ref(jsuper), m_glu(glu), m_luImpl(luImpl)
+ {}
+  bool update_segrep(Index /*krep*/, Index /*jj*/)
+  {
+    return true;
+  }
+  void mem_expand(IndexVector& lsub, Index& nextl, Index chmark)
+  {
+    if (nextl >= m_glu.nzlmax)
+      m_luImpl.memXpand(lsub, m_glu.nzlmax, nextl, LSUB, m_glu.num_expansions); 
+    if (chmark != (m_jcol-1)) m_jsuper_ref = emptyIdxLU;
+  }
+  enum { ExpandMem = true };
+  
+  Index m_jcol;
+  Index& m_jsuper_ref;
+  typename SparseLUImpl<Scalar, StorageIndex>::GlobalLU_t& m_glu;
+  SparseLUImpl<Scalar, StorageIndex>& m_luImpl;
+};
+
+
+/**
+ * \brief Performs a symbolic factorization on column jcol and decide the supernode boundary
+ * 
+ * A supernode representative is the last column of a supernode.
+ * The nonzeros in U[*,j] are segments that end at supernodes representatives. 
+ * The routine returns a list of the supernodal representatives 
+ * in topological order of the dfs that generates them. 
+ * The location of the first nonzero in each supernodal segment 
+ * (supernodal entry location) is also returned. 
+ * 
+ * \param m number of rows in the matrix
+ * \param jcol Current column 
+ * \param perm_r Row permutation
+ * \param maxsuper  Maximum number of column allowed in a supernode
+ * \param [in,out] nseg Number of segments in current U[*,j] - new segments appended
+ * \param lsub_col defines the rhs vector to start the dfs
+ * \param [in,out] segrep Segment representatives - new segments appended 
+ * \param repfnz  First nonzero location in each row
+ * \param xprune 
+ * \param marker  marker[i] == jj, if i was visited during dfs of current column jj;
+ * \param parent
+ * \param xplore working array
+ * \param glu global LU data 
+ * \return 0 success
+ *         > 0 number of bytes allocated when run out of space
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::column_dfs(const Index m, const Index jcol, IndexVector& perm_r, Index maxsuper, Index& nseg,
+                                                    BlockIndexVector lsub_col, IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune,
+                                                    IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu)
+{
+  
+  Index jsuper = glu.supno(jcol); 
+  Index nextl = glu.xlsub(jcol); 
+  VectorBlock<IndexVector> marker2(marker, 2*m, m); 
+  
+  
+  column_dfs_traits<IndexVector, ScalarVector> traits(jcol, jsuper, glu, *this);
+  
+  // For each nonzero in A(*,jcol) do dfs 
+  for (Index k = 0; ((k < m) ? lsub_col[k] != emptyIdxLU : false) ; k++)
+  {
+    Index krow = lsub_col(k); 
+    lsub_col(k) = emptyIdxLU; 
+    Index kmark = marker2(krow); 
+    
+    // krow was visited before, go to the next nonz; 
+    if (kmark == jcol) continue;
+    
+    dfs_kernel(StorageIndex(jcol), perm_r, nseg, glu.lsub, segrep, repfnz, xprune, marker2, parent,
+                   xplore, glu, nextl, krow, traits);
+  } // for each nonzero ... 
+  
+  Index fsupc;
+  StorageIndex nsuper = glu.supno(jcol);
+  StorageIndex jcolp1 = StorageIndex(jcol) + 1;
+  Index jcolm1 = jcol - 1;
+  
+  // check to see if j belongs in the same supernode as j-1
+  if ( jcol == 0 )
+  { // Do nothing for column 0 
+    nsuper = glu.supno(0) = 0 ;
+  }
+  else 
+  {
+    fsupc = glu.xsup(nsuper); 
+    StorageIndex jptr = glu.xlsub(jcol); // Not yet compressed
+    StorageIndex jm1ptr = glu.xlsub(jcolm1); 
+    
+    // Use supernodes of type T2 : see SuperLU paper
+    if ( (nextl-jptr != jptr-jm1ptr-1) ) jsuper = emptyIdxLU;
+    
+    // Make sure the number of columns in a supernode doesn't
+    // exceed threshold
+    if ( (jcol - fsupc) >= maxsuper) jsuper = emptyIdxLU; 
+    
+    /* If jcol starts a new supernode, reclaim storage space in
+     * glu.lsub from previous supernode. Note we only store 
+     * the subscript set of the first and last columns of 
+     * a supernode. (first for num values, last for pruning)
+     */
+    if (jsuper == emptyIdxLU)
+    { // starts a new supernode 
+      if ( (fsupc < jcolm1-1) ) 
+      { // >= 3 columns in nsuper
+        StorageIndex ito = glu.xlsub(fsupc+1);
+        glu.xlsub(jcolm1) = ito; 
+        StorageIndex istop = ito + jptr - jm1ptr; 
+        xprune(jcolm1) = istop; // initialize xprune(jcol-1)
+        glu.xlsub(jcol) = istop; 
+        
+        for (StorageIndex ifrom = jm1ptr; ifrom < nextl; ++ifrom, ++ito)
+          glu.lsub(ito) = glu.lsub(ifrom); 
+        nextl = ito;  // = istop + length(jcol)
+      }
+      nsuper++; 
+      glu.supno(jcol) = nsuper; 
+    } // if a new supernode 
+  } // end else:  jcol > 0
+  
+  // Tidy up the pointers before exit
+  glu.xsup(nsuper+1) = jcolp1; 
+  glu.supno(jcolp1) = nsuper; 
+  xprune(jcol) = StorageIndex(nextl);  // Initialize upper bound for pruning
+  glu.xlsub(jcolp1) = StorageIndex(nextl); 
+  
+  return 0; 
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h
new file mode 100644
index 00000000..c32d8d8b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h
@@ -0,0 +1,107 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]copy_to_ucol.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_COPY_TO_UCOL_H
+#define SPARSELU_COPY_TO_UCOL_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Performs numeric block updates (sup-col) in topological order
+ * 
+ * \param jcol current column to update
+ * \param nseg Number of segments in the U part
+ * \param segrep segment representative ...
+ * \param repfnz First nonzero column in each row  ...
+ * \param perm_r Row permutation 
+ * \param dense Store the full representation of the column
+ * \param glu Global LU data. 
+ * \return 0 - successful return 
+ *         > 0 - number of bytes allocated when run out of space
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::copy_to_ucol(const Index jcol, const Index nseg, IndexVector& segrep,
+                                                      BlockIndexVector repfnz ,IndexVector& perm_r, BlockScalarVector dense, GlobalLU_t& glu)
+{  
+  Index ksub, krep, ksupno; 
+    
+  Index jsupno = glu.supno(jcol);
+  
+  // For each nonzero supernode segment of U[*,j] in topological order 
+  Index k = nseg - 1, i; 
+  StorageIndex nextu = glu.xusub(jcol); 
+  Index kfnz, isub, segsize; 
+  Index new_next,irow; 
+  Index fsupc, mem; 
+  for (ksub = 0; ksub < nseg; ksub++)
+  {
+    krep = segrep(k); k--; 
+    ksupno = glu.supno(krep); 
+    if (jsupno != ksupno ) // should go into ucol(); 
+    {
+      kfnz = repfnz(krep); 
+      if (kfnz != emptyIdxLU)
+      { // Nonzero U-segment 
+        fsupc = glu.xsup(ksupno); 
+        isub = glu.xlsub(fsupc) + kfnz - fsupc; 
+        segsize = krep - kfnz + 1; 
+        new_next = nextu + segsize; 
+        while (new_next > glu.nzumax) 
+        {
+          mem = memXpand<ScalarVector>(glu.ucol, glu.nzumax, nextu, UCOL, glu.num_expansions); 
+          if (mem) return mem; 
+          mem = memXpand<IndexVector>(glu.usub, glu.nzumax, nextu, USUB, glu.num_expansions); 
+          if (mem) return mem; 
+          
+        }
+        
+        for (i = 0; i < segsize; i++)
+        {
+          irow = glu.lsub(isub); 
+          glu.usub(nextu) = perm_r(irow); // Unlike the L part, the U part is stored in its final order
+          glu.ucol(nextu) = dense(irow); 
+          dense(irow) = Scalar(0.0); 
+          nextu++;
+          isub++;
+        }
+        
+      } // end nonzero U-segment 
+      
+    } // end if jsupno 
+    
+  } // end for each segment
+  glu.xusub(jcol + 1) = nextu; // close U(*,jcol)
+  return 0; 
+}
+
+} // namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_COPY_TO_UCOL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_gemm_kernel.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_gemm_kernel.h
new file mode 100644
index 00000000..e37c2fe0
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_gemm_kernel.h
@@ -0,0 +1,280 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSELU_GEMM_KERNEL_H
+#define EIGEN_SPARSELU_GEMM_KERNEL_H
+
+namespace Eigen {
+
+namespace internal {
+
+
+/** \internal
+  * A general matrix-matrix product kernel optimized for the SparseLU factorization.
+  *  - A, B, and C must be column major
+  *  - lda and ldc must be multiples of the respective packet size
+  *  - C must have the same alignment as A
+  */
+template<typename Scalar>
+EIGEN_DONT_INLINE
+void sparselu_gemm(Index m, Index n, Index d, const Scalar* A, Index lda, const Scalar* B, Index ldb, Scalar* C, Index ldc)
+{
+  using namespace Eigen::internal;
+  
+  typedef typename packet_traits<Scalar>::type Packet;
+  enum {
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+    PacketSize = packet_traits<Scalar>::size,
+    PM = 8,                             // peeling in M
+    RN = 2,                             // register blocking
+    RK = NumberOfRegisters>=16 ? 4 : 2, // register blocking
+    BM = 4096/sizeof(Scalar),           // number of rows of A-C per chunk
+    SM = PM*PacketSize                  // step along M
+  };
+  Index d_end = (d/RK)*RK;    // number of columns of A (rows of B) suitable for full register blocking
+  Index n_end = (n/RN)*RN;    // number of columns of B-C suitable for processing RN columns at once
+  Index i0 = internal::first_default_aligned(A,m);
+  
+  eigen_internal_assert(((lda%PacketSize)==0) && ((ldc%PacketSize)==0) && (i0==internal::first_default_aligned(C,m)));
+  
+  // handle the non aligned rows of A and C without any optimization:
+  for(Index i=0; i<i0; ++i)
+  {
+    for(Index j=0; j<n; ++j)
+    {
+      Scalar c = C[i+j*ldc];
+      for(Index k=0; k<d; ++k)
+        c += B[k+j*ldb] * A[i+k*lda];
+      C[i+j*ldc] = c;
+    }
+  }
+  // process the remaining rows per chunk of BM rows
+  for(Index ib=i0; ib<m; ib+=BM)
+  {
+    Index actual_b = std::min<Index>(BM, m-ib);                 // actual number of rows
+    Index actual_b_end1 = (actual_b/SM)*SM;                   // actual number of rows suitable for peeling
+    Index actual_b_end2 = (actual_b/PacketSize)*PacketSize;   // actual number of rows suitable for vectorization
+    
+    // Let's process two columns of B-C at once
+    for(Index j=0; j<n_end; j+=RN)
+    {
+      const Scalar* Bc0 = B+(j+0)*ldb;
+      const Scalar* Bc1 = B+(j+1)*ldb;
+      
+      for(Index k=0; k<d_end; k+=RK)
+      {
+        
+        // load and expand a RN x RK block of B
+        Packet b00, b10, b20, b30, b01, b11, b21, b31;
+                  { b00 = pset1<Packet>(Bc0[0]); }
+                  { b10 = pset1<Packet>(Bc0[1]); }
+        if(RK==4) { b20 = pset1<Packet>(Bc0[2]); }
+        if(RK==4) { b30 = pset1<Packet>(Bc0[3]); }
+                  { b01 = pset1<Packet>(Bc1[0]); }
+                  { b11 = pset1<Packet>(Bc1[1]); }
+        if(RK==4) { b21 = pset1<Packet>(Bc1[2]); }
+        if(RK==4) { b31 = pset1<Packet>(Bc1[3]); }
+        
+        Packet a0, a1, a2, a3, c0, c1, t0, t1;
+        
+        const Scalar* A0 = A+ib+(k+0)*lda;
+        const Scalar* A1 = A+ib+(k+1)*lda;
+        const Scalar* A2 = A+ib+(k+2)*lda;
+        const Scalar* A3 = A+ib+(k+3)*lda;
+        
+        Scalar* C0 = C+ib+(j+0)*ldc;
+        Scalar* C1 = C+ib+(j+1)*ldc;
+        
+                  a0 = pload<Packet>(A0);
+                  a1 = pload<Packet>(A1);
+        if(RK==4)
+        {
+          a2 = pload<Packet>(A2);
+          a3 = pload<Packet>(A3);
+        }
+        else
+        {
+          // workaround "may be used uninitialized in this function" warning
+          a2 = a3 = a0;
+        }
+        
+#define KMADD(c, a, b, tmp) {tmp = b; tmp = pmul(a,tmp); c = padd(c,tmp);}
+#define WORK(I)  \
+                     c0 = pload<Packet>(C0+i+(I)*PacketSize);    \
+                     c1 = pload<Packet>(C1+i+(I)*PacketSize);    \
+                     KMADD(c0, a0, b00, t0)                      \
+                     KMADD(c1, a0, b01, t1)                      \
+                     a0 = pload<Packet>(A0+i+(I+1)*PacketSize);  \
+                     KMADD(c0, a1, b10, t0)                      \
+                     KMADD(c1, a1, b11, t1)                      \
+                     a1 = pload<Packet>(A1+i+(I+1)*PacketSize);  \
+          if(RK==4){ KMADD(c0, a2, b20, t0)                     }\
+          if(RK==4){ KMADD(c1, a2, b21, t1)                     }\
+          if(RK==4){ a2 = pload<Packet>(A2+i+(I+1)*PacketSize); }\
+          if(RK==4){ KMADD(c0, a3, b30, t0)                     }\
+          if(RK==4){ KMADD(c1, a3, b31, t1)                     }\
+          if(RK==4){ a3 = pload<Packet>(A3+i+(I+1)*PacketSize); }\
+                     pstore(C0+i+(I)*PacketSize, c0);            \
+                     pstore(C1+i+(I)*PacketSize, c1)
+        
+        // process rows of A' - C' with aggressive vectorization and peeling 
+        for(Index i=0; i<actual_b_end1; i+=PacketSize*8)
+        {
+          EIGEN_ASM_COMMENT("SPARSELU_GEMML_KERNEL1");
+                    prefetch((A0+i+(5)*PacketSize));
+                    prefetch((A1+i+(5)*PacketSize));
+          if(RK==4) prefetch((A2+i+(5)*PacketSize));
+          if(RK==4) prefetch((A3+i+(5)*PacketSize));
+
+          WORK(0);
+          WORK(1);
+          WORK(2);
+          WORK(3);
+          WORK(4);
+          WORK(5);
+          WORK(6);
+          WORK(7);
+        }
+        // process the remaining rows with vectorization only
+        for(Index i=actual_b_end1; i<actual_b_end2; i+=PacketSize)
+        {
+          WORK(0);
+        }
+#undef WORK
+        // process the remaining rows without vectorization
+        for(Index i=actual_b_end2; i<actual_b; ++i)
+        {
+          if(RK==4)
+          {
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1]+A2[i]*Bc0[2]+A3[i]*Bc0[3];
+            C1[i] += A0[i]*Bc1[0]+A1[i]*Bc1[1]+A2[i]*Bc1[2]+A3[i]*Bc1[3];
+          }
+          else
+          {
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1];
+            C1[i] += A0[i]*Bc1[0]+A1[i]*Bc1[1];
+          }
+        }
+        
+        Bc0 += RK;
+        Bc1 += RK;
+      } // peeled loop on k
+    } // peeled loop on the columns j
+    // process the last column (we now perform a matrix-vector product)
+    if((n-n_end)>0)
+    {
+      const Scalar* Bc0 = B+(n-1)*ldb;
+      
+      for(Index k=0; k<d_end; k+=RK)
+      {
+        
+        // load and expand a 1 x RK block of B
+        Packet b00, b10, b20, b30;
+                  b00 = pset1<Packet>(Bc0[0]);
+                  b10 = pset1<Packet>(Bc0[1]);
+        if(RK==4) b20 = pset1<Packet>(Bc0[2]);
+        if(RK==4) b30 = pset1<Packet>(Bc0[3]);
+        
+        Packet a0, a1, a2, a3, c0, t0/*, t1*/;
+        
+        const Scalar* A0 = A+ib+(k+0)*lda;
+        const Scalar* A1 = A+ib+(k+1)*lda;
+        const Scalar* A2 = A+ib+(k+2)*lda;
+        const Scalar* A3 = A+ib+(k+3)*lda;
+        
+        Scalar* C0 = C+ib+(n_end)*ldc;
+        
+                  a0 = pload<Packet>(A0);
+                  a1 = pload<Packet>(A1);
+        if(RK==4)
+        {
+          a2 = pload<Packet>(A2);
+          a3 = pload<Packet>(A3);
+        }
+        else
+        {
+          // workaround "may be used uninitialized in this function" warning
+          a2 = a3 = a0;
+        }
+        
+#define WORK(I) \
+                   c0 = pload<Packet>(C0+i+(I)*PacketSize);     \
+                   KMADD(c0, a0, b00, t0)                       \
+                   a0 = pload<Packet>(A0+i+(I+1)*PacketSize);   \
+                   KMADD(c0, a1, b10, t0)                       \
+                   a1 = pload<Packet>(A1+i+(I+1)*PacketSize);   \
+        if(RK==4){ KMADD(c0, a2, b20, t0)                      }\
+        if(RK==4){ a2 = pload<Packet>(A2+i+(I+1)*PacketSize);  }\
+        if(RK==4){ KMADD(c0, a3, b30, t0)                      }\
+        if(RK==4){ a3 = pload<Packet>(A3+i+(I+1)*PacketSize);  }\
+                   pstore(C0+i+(I)*PacketSize, c0);
+        
+        // aggressive vectorization and peeling
+        for(Index i=0; i<actual_b_end1; i+=PacketSize*8)
+        {
+          EIGEN_ASM_COMMENT("SPARSELU_GEMML_KERNEL2");
+          WORK(0);
+          WORK(1);
+          WORK(2);
+          WORK(3);
+          WORK(4);
+          WORK(5);
+          WORK(6);
+          WORK(7);
+        }
+        // vectorization only
+        for(Index i=actual_b_end1; i<actual_b_end2; i+=PacketSize)
+        {
+          WORK(0);
+        }
+        // remaining scalars
+        for(Index i=actual_b_end2; i<actual_b; ++i)
+        {
+          if(RK==4) 
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1]+A2[i]*Bc0[2]+A3[i]*Bc0[3];
+          else
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1];
+        }
+        
+        Bc0 += RK;
+#undef WORK
+      }
+    }
+    
+    // process the last columns of A, corresponding to the last rows of B
+    Index rd = d-d_end;
+    if(rd>0)
+    {
+      for(Index j=0; j<n; ++j)
+      {
+        enum {
+          Alignment = PacketSize>1 ? Aligned : 0
+        };
+        typedef Map<Matrix<Scalar,Dynamic,1>, Alignment > MapVector;
+        typedef Map<const Matrix<Scalar,Dynamic,1>, Alignment > ConstMapVector;
+        if(rd==1)       MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b);
+        
+        else if(rd==2)  MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b)
+                                                        + B[1+d_end+j*ldb] * ConstMapVector(A+(d_end+1)*lda+ib, actual_b);
+        
+        else            MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b)
+                                                        + B[1+d_end+j*ldb] * ConstMapVector(A+(d_end+1)*lda+ib, actual_b)
+                                                        + B[2+d_end+j*ldb] * ConstMapVector(A+(d_end+2)*lda+ib, actual_b);
+      }
+    }
+  
+  } // blocking on the rows of A and C
+}
+#undef KMADD
+
+} // namespace internal
+
+} // namespace Eigen
+
+#endif // EIGEN_SPARSELU_GEMM_KERNEL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h
new file mode 100644
index 00000000..6f75d500
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h
@@ -0,0 +1,126 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* This file is a modified version of heap_relax_snode.c file in SuperLU
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+
+#ifndef SPARSELU_HEAP_RELAX_SNODE_H
+#define SPARSELU_HEAP_RELAX_SNODE_H
+
+namespace Eigen {
+namespace internal {
+
+/** 
+ * \brief Identify the initial relaxed supernodes
+ * 
+ * This routine applied to a symmetric elimination tree. 
+ * It assumes that the matrix has been reordered according to the postorder of the etree
+ * \param n The number of columns
+ * \param et elimination tree 
+ * \param relax_columns Maximum number of columns allowed in a relaxed snode 
+ * \param descendants Number of descendants of each node in the etree
+ * \param relax_end last column in a supernode
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::heap_relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end)
+{
+  
+  // The etree may not be postordered, but its heap ordered  
+  IndexVector post;
+  internal::treePostorder(StorageIndex(n), et, post); // Post order etree
+  IndexVector inv_post(n+1); 
+  for (StorageIndex i = 0; i < n+1; ++i) inv_post(post(i)) = i; // inv_post = post.inverse()???
+  
+  // Renumber etree in postorder 
+  IndexVector iwork(n);
+  IndexVector et_save(n+1);
+  for (Index i = 0; i < n; ++i)
+  {
+    iwork(post(i)) = post(et(i));
+  }
+  et_save = et; // Save the original etree
+  et = iwork; 
+  
+  // compute the number of descendants of each node in the etree
+  relax_end.setConstant(emptyIdxLU);
+  Index j, parent; 
+  descendants.setZero();
+  for (j = 0; j < n; j++) 
+  {
+    parent = et(j);
+    if (parent != n) // not the dummy root
+      descendants(parent) += descendants(j) + 1;
+  }
+  // Identify the relaxed supernodes by postorder traversal of the etree
+  Index snode_start; // beginning of a snode 
+  StorageIndex k;
+  Index nsuper_et_post = 0; // Number of relaxed snodes in postordered etree 
+  Index nsuper_et = 0; // Number of relaxed snodes in the original etree 
+  StorageIndex l; 
+  for (j = 0; j < n; )
+  {
+    parent = et(j);
+    snode_start = j; 
+    while ( parent != n && descendants(parent) < relax_columns ) 
+    {
+      j = parent; 
+      parent = et(j);
+    }
+    // Found a supernode in postordered etree, j is the last column 
+    ++nsuper_et_post;
+    k = StorageIndex(n);
+    for (Index i = snode_start; i <= j; ++i)
+      k = (std::min)(k, inv_post(i));
+    l = inv_post(j);
+    if ( (l - k) == (j - snode_start) )  // Same number of columns in the snode
+    {
+      // This is also a supernode in the original etree
+      relax_end(k) = l; // Record last column 
+      ++nsuper_et; 
+    }
+    else 
+    {
+      for (Index i = snode_start; i <= j; ++i) 
+      {
+        l = inv_post(i);
+        if (descendants(i) == 0) 
+        {
+          relax_end(l) = l;
+          ++nsuper_et;
+        }
+      }
+    }
+    j++;
+    // Search for a new leaf
+    while (descendants(j) != 0 && j < n) j++;
+  } // End postorder traversal of the etree
+  
+  // Recover the original etree
+  et = et_save; 
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // SPARSELU_HEAP_RELAX_SNODE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_kernel_bmod.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_kernel_bmod.h
new file mode 100644
index 00000000..8c1b3e8b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_kernel_bmod.h
@@ -0,0 +1,130 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef SPARSELU_KERNEL_BMOD_H
+#define SPARSELU_KERNEL_BMOD_H
+
+namespace Eigen {
+namespace internal {
+  
+template <int SegSizeAtCompileTime> struct LU_kernel_bmod
+{
+  /** \internal
+    * \brief Performs numeric block updates from a given supernode to a single column
+    *
+    * \param segsize Size of the segment (and blocks ) to use for updates
+    * \param[in,out] dense Packed values of the original matrix
+    * \param tempv temporary vector to use for updates
+    * \param lusup array containing the supernodes
+    * \param lda Leading dimension in the supernode
+    * \param nrow Number of rows in the rectangular part of the supernode
+    * \param lsub compressed row subscripts of supernodes
+    * \param lptr pointer to the first column of the current supernode in lsub
+    * \param no_zeros Number of nonzeros elements before the diagonal part of the supernode
+    */
+  template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+  static EIGEN_DONT_INLINE void run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv, ScalarVector& lusup, Index& luptr, const Index lda,
+                                    const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros);
+};
+
+template <int SegSizeAtCompileTime>
+template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+EIGEN_DONT_INLINE void LU_kernel_bmod<SegSizeAtCompileTime>::run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv, ScalarVector& lusup, Index& luptr, const Index lda,
+                                                                  const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros)
+{
+  typedef typename ScalarVector::Scalar Scalar;
+  // First, copy U[*,j] segment from dense(*) to tempv(*)
+  // The result of triangular solve is in tempv[*]; 
+    // The result of matric-vector update is in dense[*]
+  Index isub = lptr + no_zeros; 
+  Index i;
+  Index irow;
+  for (i = 0; i < ((SegSizeAtCompileTime==Dynamic)?segsize:SegSizeAtCompileTime); i++)
+  {
+    irow = lsub(isub); 
+    tempv(i) = dense(irow); 
+    ++isub; 
+  }
+  // Dense triangular solve -- start effective triangle
+  luptr += lda * no_zeros + no_zeros; 
+  // Form Eigen matrix and vector 
+  Map<Matrix<Scalar,SegSizeAtCompileTime,SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > A( &(lusup.data()[luptr]), segsize, segsize, OuterStride<>(lda) );
+  Map<Matrix<Scalar,SegSizeAtCompileTime,1> > u(tempv.data(), segsize);
+  
+  u = A.template triangularView<UnitLower>().solve(u); 
+  
+  // Dense matrix-vector product y <-- B*x 
+  luptr += segsize;
+  const Index PacketSize = internal::packet_traits<Scalar>::size;
+  Index ldl = internal::first_multiple(nrow, PacketSize);
+  Map<Matrix<Scalar,Dynamic,SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > B( &(lusup.data()[luptr]), nrow, segsize, OuterStride<>(lda) );
+  Index aligned_offset = internal::first_default_aligned(tempv.data()+segsize, PacketSize);
+  Index aligned_with_B_offset = (PacketSize-internal::first_default_aligned(B.data(), PacketSize))%PacketSize;
+  Map<Matrix<Scalar,Dynamic,1>, 0, OuterStride<> > l(tempv.data()+segsize+aligned_offset+aligned_with_B_offset, nrow, OuterStride<>(ldl) );
+  
+  l.setZero();
+  internal::sparselu_gemm<Scalar>(l.rows(), l.cols(), B.cols(), B.data(), B.outerStride(), u.data(), u.outerStride(), l.data(), l.outerStride());
+  
+  // Scatter tempv[] into SPA dense[] as a temporary storage 
+  isub = lptr + no_zeros;
+  for (i = 0; i < ((SegSizeAtCompileTime==Dynamic)?segsize:SegSizeAtCompileTime); i++)
+  {
+    irow = lsub(isub++); 
+    dense(irow) = tempv(i);
+  }
+  
+  // Scatter l into SPA dense[]
+  for (i = 0; i < nrow; i++)
+  {
+    irow = lsub(isub++); 
+    dense(irow) -= l(i);
+  } 
+}
+
+template <> struct LU_kernel_bmod<1>
+{
+  template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+  static EIGEN_DONT_INLINE void run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr,
+                                    const Index lda, const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros);
+};
+
+
+template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+EIGEN_DONT_INLINE void LU_kernel_bmod<1>::run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr,
+                                              const Index lda, const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros)
+{
+  typedef typename ScalarVector::Scalar Scalar;
+  typedef typename IndexVector::Scalar StorageIndex;
+  Scalar f = dense(lsub(lptr + no_zeros));
+  luptr += lda * no_zeros + no_zeros + 1;
+  const Scalar* a(lusup.data() + luptr);
+  const StorageIndex*  irow(lsub.data()+lptr + no_zeros + 1);
+  Index i = 0;
+  for (; i+1 < nrow; i+=2)
+  {
+    Index i0 = *(irow++);
+    Index i1 = *(irow++);
+    Scalar a0 = *(a++);
+    Scalar a1 = *(a++);
+    Scalar d0 = dense.coeff(i0);
+    Scalar d1 = dense.coeff(i1);
+    d0 -= f*a0;
+    d1 -= f*a1;
+    dense.coeffRef(i0) = d0;
+    dense.coeffRef(i1) = d1;
+  }
+  if(i<nrow)
+    dense.coeffRef(*(irow++)) -= f * *(a++);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // SPARSELU_KERNEL_BMOD_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_panel_bmod.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_panel_bmod.h
new file mode 100644
index 00000000..f052001c
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_panel_bmod.h
@@ -0,0 +1,223 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]panel_bmod.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PANEL_BMOD_H
+#define SPARSELU_PANEL_BMOD_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Performs numeric block updates (sup-panel) in topological order.
+ * 
+ * Before entering this routine, the original nonzeros in the panel
+ * were already copied into the spa[m,w]
+ * 
+ * \param m number of rows in the matrix
+ * \param w Panel size
+ * \param jcol Starting  column of the panel
+ * \param nseg Number of segments in the U part
+ * \param dense Store the full representation of the panel 
+ * \param tempv working array 
+ * \param segrep segment representative... first row in the segment
+ * \param repfnz First nonzero rows
+ * \param glu Global LU data. 
+ * 
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::panel_bmod(const Index m, const Index w, const Index jcol, 
+                                            const Index nseg, ScalarVector& dense, ScalarVector& tempv,
+                                            IndexVector& segrep, IndexVector& repfnz, GlobalLU_t& glu)
+{
+  
+  Index ksub,jj,nextl_col; 
+  Index fsupc, nsupc, nsupr, nrow; 
+  Index krep, kfnz; 
+  Index lptr; // points to the row subscripts of a supernode 
+  Index luptr; // ...
+  Index segsize,no_zeros ; 
+  // For each nonz supernode segment of U[*,j] in topological order
+  Index k = nseg - 1; 
+  const Index PacketSize = internal::packet_traits<Scalar>::size;
+  
+  for (ksub = 0; ksub < nseg; ksub++)
+  { // For each updating supernode
+    /* krep = representative of current k-th supernode
+     * fsupc =  first supernodal column
+     * nsupc = number of columns in a supernode
+     * nsupr = number of rows in a supernode
+     */
+    krep = segrep(k); k--; 
+    fsupc = glu.xsup(glu.supno(krep)); 
+    nsupc = krep - fsupc + 1; 
+    nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
+    nrow = nsupr - nsupc; 
+    lptr = glu.xlsub(fsupc); 
+    
+    // loop over the panel columns to detect the actual number of columns and rows
+    Index u_rows = 0;
+    Index u_cols = 0;
+    for (jj = jcol; jj < jcol + w; jj++)
+    {
+      nextl_col = (jj-jcol) * m; 
+      VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+      
+      kfnz = repfnz_col(krep); 
+      if ( kfnz == emptyIdxLU ) 
+        continue; // skip any zero segment
+      
+      segsize = krep - kfnz + 1;
+      u_cols++;
+      u_rows = (std::max)(segsize,u_rows);
+    }
+    
+    if(nsupc >= 2)
+    { 
+      Index ldu = internal::first_multiple<Index>(u_rows, PacketSize);
+      Map<ScalarMatrix, Aligned,  OuterStride<> > U(tempv.data(), u_rows, u_cols, OuterStride<>(ldu));
+      
+      // gather U
+      Index u_col = 0;
+      for (jj = jcol; jj < jcol + w; jj++)
+      {
+        nextl_col = (jj-jcol) * m; 
+        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
+        
+        kfnz = repfnz_col(krep); 
+        if ( kfnz == emptyIdxLU ) 
+          continue; // skip any zero segment
+        
+        segsize = krep - kfnz + 1;
+        luptr = glu.xlusup(fsupc);    
+        no_zeros = kfnz - fsupc; 
+        
+        Index isub = lptr + no_zeros;
+        Index off = u_rows-segsize;
+        for (Index i = 0; i < off; i++) U(i,u_col) = 0;
+        for (Index i = 0; i < segsize; i++)
+        {
+          Index irow = glu.lsub(isub); 
+          U(i+off,u_col) = dense_col(irow); 
+          ++isub; 
+        }
+        u_col++;
+      }
+      // solve U = A^-1 U
+      luptr = glu.xlusup(fsupc);
+      Index lda = glu.xlusup(fsupc+1) - glu.xlusup(fsupc);
+      no_zeros = (krep - u_rows + 1) - fsupc;
+      luptr += lda * no_zeros + no_zeros;
+      MappedMatrixBlock A(glu.lusup.data()+luptr, u_rows, u_rows, OuterStride<>(lda) );
+      U = A.template triangularView<UnitLower>().solve(U);
+      
+      // update
+      luptr += u_rows;
+      MappedMatrixBlock B(glu.lusup.data()+luptr, nrow, u_rows, OuterStride<>(lda) );
+      eigen_assert(tempv.size()>w*ldu + nrow*w + 1);
+      
+      Index ldl = internal::first_multiple<Index>(nrow, PacketSize);
+      Index offset = (PacketSize-internal::first_default_aligned(B.data(), PacketSize)) % PacketSize;
+      MappedMatrixBlock L(tempv.data()+w*ldu+offset, nrow, u_cols, OuterStride<>(ldl));
+      
+      L.setZero();
+      internal::sparselu_gemm<Scalar>(L.rows(), L.cols(), B.cols(), B.data(), B.outerStride(), U.data(), U.outerStride(), L.data(), L.outerStride());
+      
+      // scatter U and L
+      u_col = 0;
+      for (jj = jcol; jj < jcol + w; jj++)
+      {
+        nextl_col = (jj-jcol) * m; 
+        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
+        
+        kfnz = repfnz_col(krep); 
+        if ( kfnz == emptyIdxLU ) 
+          continue; // skip any zero segment
+        
+        segsize = krep - kfnz + 1;
+        no_zeros = kfnz - fsupc; 
+        Index isub = lptr + no_zeros;
+        
+        Index off = u_rows-segsize;
+        for (Index i = 0; i < segsize; i++)
+        {
+          Index irow = glu.lsub(isub++); 
+          dense_col(irow) = U.coeff(i+off,u_col);
+          U.coeffRef(i+off,u_col) = 0;
+        }
+        
+        // Scatter l into SPA dense[]
+        for (Index i = 0; i < nrow; i++)
+        {
+          Index irow = glu.lsub(isub++); 
+          dense_col(irow) -= L.coeff(i,u_col);
+          L.coeffRef(i,u_col) = 0;
+        }
+        u_col++;
+      }
+    }
+    else // level 2 only
+    {
+      // Sequence through each column in the panel
+      for (jj = jcol; jj < jcol + w; jj++)
+      {
+        nextl_col = (jj-jcol) * m; 
+        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
+        
+        kfnz = repfnz_col(krep); 
+        if ( kfnz == emptyIdxLU ) 
+          continue; // skip any zero segment
+        
+        segsize = krep - kfnz + 1;
+        luptr = glu.xlusup(fsupc);
+        
+        Index lda = glu.xlusup(fsupc+1)-glu.xlusup(fsupc);// nsupr
+        
+        // Perform a trianglar solve and block update, 
+        // then scatter the result of sup-col update to dense[]
+        no_zeros = kfnz - fsupc; 
+              if(segsize==1)  LU_kernel_bmod<1>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+        else  if(segsize==2)  LU_kernel_bmod<2>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+        else  if(segsize==3)  LU_kernel_bmod<3>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+        else                  LU_kernel_bmod<Dynamic>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros); 
+      } // End for each column in the panel 
+    }
+    
+  } // End for each updating supernode
+} // end panel bmod
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // SPARSELU_PANEL_BMOD_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_panel_dfs.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_panel_dfs.h
new file mode 100644
index 00000000..155df733
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_panel_dfs.h
@@ -0,0 +1,258 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]panel_dfs.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PANEL_DFS_H
+#define SPARSELU_PANEL_DFS_H
+
+namespace Eigen {
+
+namespace internal {
+  
+template<typename IndexVector>
+struct panel_dfs_traits
+{
+  typedef typename IndexVector::Scalar StorageIndex;
+  panel_dfs_traits(Index jcol, StorageIndex* marker)
+    : m_jcol(jcol), m_marker(marker)
+  {}
+  bool update_segrep(Index krep, StorageIndex jj)
+  {
+    if(m_marker[krep]<m_jcol)
+    {
+      m_marker[krep] = jj; 
+      return true;
+    }
+    return false;
+  }
+  void mem_expand(IndexVector& /*glu.lsub*/, Index /*nextl*/, Index /*chmark*/) {}
+  enum { ExpandMem = false };
+  Index m_jcol;
+  StorageIndex* m_marker;
+};
+
+
+template <typename Scalar, typename StorageIndex>
+template <typename Traits>
+void SparseLUImpl<Scalar,StorageIndex>::dfs_kernel(const StorageIndex jj, IndexVector& perm_r,
+                   Index& nseg, IndexVector& panel_lsub, IndexVector& segrep,
+                   Ref<IndexVector> repfnz_col, IndexVector& xprune, Ref<IndexVector> marker, IndexVector& parent,
+                   IndexVector& xplore, GlobalLU_t& glu,
+                   Index& nextl_col, Index krow, Traits& traits
+                  )
+{
+  
+  StorageIndex kmark = marker(krow);
+      
+  // For each unmarked krow of jj
+  marker(krow) = jj; 
+  StorageIndex kperm = perm_r(krow); 
+  if (kperm == emptyIdxLU ) {
+    // krow is in L : place it in structure of L(*, jj)
+    panel_lsub(nextl_col++) = StorageIndex(krow);  // krow is indexed into A
+    
+    traits.mem_expand(panel_lsub, nextl_col, kmark);
+  }
+  else 
+  {
+    // krow is in U : if its supernode-representative krep
+    // has been explored, update repfnz(*)
+    // krep = supernode representative of the current row
+    StorageIndex krep = glu.xsup(glu.supno(kperm)+1) - 1; 
+    // First nonzero element in the current column:
+    StorageIndex myfnz = repfnz_col(krep); 
+    
+    if (myfnz != emptyIdxLU )
+    {
+      // Representative visited before
+      if (myfnz > kperm ) repfnz_col(krep) = kperm; 
+      
+    }
+    else 
+    {
+      // Otherwise, perform dfs starting at krep
+      StorageIndex oldrep = emptyIdxLU; 
+      parent(krep) = oldrep; 
+      repfnz_col(krep) = kperm; 
+      StorageIndex xdfs =  glu.xlsub(krep); 
+      Index maxdfs = xprune(krep); 
+      
+      StorageIndex kpar;
+      do 
+      {
+        // For each unmarked kchild of krep
+        while (xdfs < maxdfs) 
+        {
+          StorageIndex kchild = glu.lsub(xdfs); 
+          xdfs++; 
+          StorageIndex chmark = marker(kchild); 
+          
+          if (chmark != jj ) 
+          {
+            marker(kchild) = jj; 
+            StorageIndex chperm = perm_r(kchild); 
+            
+            if (chperm == emptyIdxLU) 
+            {
+              // case kchild is in L: place it in L(*, j)
+              panel_lsub(nextl_col++) = kchild;
+              traits.mem_expand(panel_lsub, nextl_col, chmark);
+            }
+            else
+            {
+              // case kchild is in U :
+              // chrep = its supernode-rep. If its rep has been explored, 
+              // update its repfnz(*)
+              StorageIndex chrep = glu.xsup(glu.supno(chperm)+1) - 1; 
+              myfnz = repfnz_col(chrep); 
+              
+              if (myfnz != emptyIdxLU) 
+              { // Visited before 
+                if (myfnz > chperm) 
+                  repfnz_col(chrep) = chperm; 
+              }
+              else 
+              { // Cont. dfs at snode-rep of kchild
+                xplore(krep) = xdfs; 
+                oldrep = krep; 
+                krep = chrep; // Go deeper down G(L)
+                parent(krep) = oldrep; 
+                repfnz_col(krep) = chperm; 
+                xdfs = glu.xlsub(krep); 
+                maxdfs = xprune(krep); 
+                
+              } // end if myfnz != -1
+            } // end if chperm == -1 
+                
+          } // end if chmark !=jj
+        } // end while xdfs < maxdfs
+        
+        // krow has no more unexplored nbrs :
+        //    Place snode-rep krep in postorder DFS, if this 
+        //    segment is seen for the first time. (Note that 
+        //    "repfnz(krep)" may change later.)
+        //    Baktrack dfs to its parent
+        if(traits.update_segrep(krep,jj))
+        //if (marker1(krep) < jcol )
+        {
+          segrep(nseg) = krep; 
+          ++nseg; 
+          //marker1(krep) = jj; 
+        }
+        
+        kpar = parent(krep); // Pop recursion, mimic recursion 
+        if (kpar == emptyIdxLU) 
+          break; // dfs done 
+        krep = kpar; 
+        xdfs = xplore(krep); 
+        maxdfs = xprune(krep); 
+
+      } while (kpar != emptyIdxLU); // Do until empty stack 
+      
+    } // end if (myfnz = -1)
+
+  } // end if (kperm == -1)   
+}
+
+/**
+ * \brief Performs a symbolic factorization on a panel of columns [jcol, jcol+w)
+ * 
+ * A supernode representative is the last column of a supernode.
+ * The nonzeros in U[*,j] are segments that end at supernodes representatives
+ * 
+ * The routine returns a list of the supernodal representatives 
+ * in topological order of the dfs that generates them. This list is 
+ * a superset of the topological order of each individual column within 
+ * the panel.
+ * The location of the first nonzero in each supernodal segment 
+ * (supernodal entry location) is also returned. Each column has 
+ * a separate list for this purpose. 
+ * 
+ * Two markers arrays are used for dfs :
+ *    marker[i] == jj, if i was visited during dfs of current column jj;
+ *    marker1[i] >= jcol, if i was visited by earlier columns in this panel; 
+ * 
+ * \param[in] m number of rows in the matrix
+ * \param[in] w Panel size
+ * \param[in] jcol Starting  column of the panel
+ * \param[in] A Input matrix in column-major storage
+ * \param[in] perm_r Row permutation
+ * \param[out] nseg Number of U segments
+ * \param[out] dense Accumulate the column vectors of the panel
+ * \param[out] panel_lsub Subscripts of the row in the panel 
+ * \param[out] segrep Segment representative i.e first nonzero row of each segment
+ * \param[out] repfnz First nonzero location in each row
+ * \param[out] xprune The pruned elimination tree
+ * \param[out] marker work vector
+ * \param  parent The elimination tree
+ * \param xplore work vector
+ * \param glu The global data structure
+ * 
+ */
+
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::panel_dfs(const Index m, const Index w, const Index jcol, MatrixType& A, IndexVector& perm_r, Index& nseg, ScalarVector& dense, IndexVector& panel_lsub, IndexVector& segrep, IndexVector& repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu)
+{
+  Index nextl_col; // Next available position in panel_lsub[*,jj] 
+  
+  // Initialize pointers 
+  VectorBlock<IndexVector> marker1(marker, m, m); 
+  nseg = 0; 
+  
+  panel_dfs_traits<IndexVector> traits(jcol, marker1.data());
+  
+  // For each column in the panel 
+  for (StorageIndex jj = StorageIndex(jcol); jj < jcol + w; jj++) 
+  {
+    nextl_col = (jj - jcol) * m; 
+    
+    VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero location in each row
+    VectorBlock<ScalarVector> dense_col(dense,nextl_col, m); // Accumulate a column vector here
+    
+    
+    // For each nnz in A[*, jj] do depth first search
+    for (typename MatrixType::InnerIterator it(A, jj); it; ++it)
+    {
+      Index krow = it.row(); 
+      dense_col(krow) = it.value();
+      
+      StorageIndex kmark = marker(krow); 
+      if (kmark == jj) 
+        continue; // krow visited before, go to the next nonzero
+      
+      dfs_kernel(jj, perm_r, nseg, panel_lsub, segrep, repfnz_col, xprune, marker, parent,
+                   xplore, glu, nextl_col, krow, traits);
+    }// end for nonzeros in column jj
+    
+  } // end for column jj
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_PANEL_DFS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_pivotL.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_pivotL.h
new file mode 100644
index 00000000..a86dac93
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_pivotL.h
@@ -0,0 +1,137 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of xpivotL.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PIVOTL_H
+#define SPARSELU_PIVOTL_H
+
+namespace Eigen {
+namespace internal {
+  
+/**
+ * \brief Performs the numerical pivotin on the current column of L, and the CDIV operation.
+ * 
+ * Pivot policy :
+ * (1) Compute thresh = u * max_(i>=j) abs(A_ij);
+ * (2) IF user specifies pivot row k and abs(A_kj) >= thresh THEN
+ *           pivot row = k;
+ *       ELSE IF abs(A_jj) >= thresh THEN
+ *           pivot row = j;
+ *       ELSE
+ *           pivot row = m;
+ * 
+ *   Note: If you absolutely want to use a given pivot order, then set u=0.0.
+ * 
+ * \param jcol The current column of L
+ * \param diagpivotthresh diagonal pivoting threshold
+ * \param[in,out] perm_r Row permutation (threshold pivoting)
+ * \param[in] iperm_c column permutation - used to finf diagonal of Pc*A*Pc'
+ * \param[out] pivrow  The pivot row
+ * \param glu Global LU data
+ * \return 0 if success, i > 0 if U(i,i) is exactly zero 
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::pivotL(const Index jcol, const RealScalar& diagpivotthresh, IndexVector& perm_r, IndexVector& iperm_c, Index& pivrow, GlobalLU_t& glu)
+{
+  
+  Index fsupc = (glu.xsup)((glu.supno)(jcol)); // First column in the supernode containing the column jcol
+  Index nsupc = jcol - fsupc; // Number of columns in the supernode portion, excluding jcol; nsupc >=0
+  Index lptr = glu.xlsub(fsupc); // pointer to the starting location of the row subscripts for this supernode portion
+  Index nsupr = glu.xlsub(fsupc+1) - lptr; // Number of rows in the supernode
+  Index lda = glu.xlusup(fsupc+1) - glu.xlusup(fsupc); // leading dimension
+  Scalar* lu_sup_ptr = &(glu.lusup.data()[glu.xlusup(fsupc)]); // Start of the current supernode
+  Scalar* lu_col_ptr = &(glu.lusup.data()[glu.xlusup(jcol)]); // Start of jcol in the supernode
+  StorageIndex* lsub_ptr = &(glu.lsub.data()[lptr]); // Start of row indices of the supernode
+  
+  // Determine the largest abs numerical value for partial pivoting 
+  Index diagind = iperm_c(jcol); // diagonal index 
+  RealScalar pivmax(-1.0);
+  Index pivptr = nsupc; 
+  Index diag = emptyIdxLU; 
+  RealScalar rtemp;
+  Index isub, icol, itemp, k; 
+  for (isub = nsupc; isub < nsupr; ++isub) {
+    using std::abs;
+    rtemp = abs(lu_col_ptr[isub]);
+    if (rtemp > pivmax) {
+      pivmax = rtemp; 
+      pivptr = isub;
+    } 
+    if (lsub_ptr[isub] == diagind) diag = isub;
+  }
+  
+  // Test for singularity
+  if ( pivmax <= RealScalar(0.0) ) {
+    // if pivmax == -1, the column is structurally empty, otherwise it is only numerically zero
+    pivrow = pivmax < RealScalar(0.0) ? diagind : lsub_ptr[pivptr];
+    perm_r(pivrow) = StorageIndex(jcol);
+    return (jcol+1);
+  }
+  
+  RealScalar thresh = diagpivotthresh * pivmax; 
+  
+  // Choose appropriate pivotal element 
+  
+  {
+    // Test if the diagonal element can be used as a pivot (given the threshold value)
+    if (diag >= 0 ) 
+    {
+      // Diagonal element exists
+      using std::abs;
+      rtemp = abs(lu_col_ptr[diag]);
+      if (rtemp != RealScalar(0.0) && rtemp >= thresh) pivptr = diag;
+    }
+    pivrow = lsub_ptr[pivptr];
+  }
+  
+  // Record pivot row
+  perm_r(pivrow) = StorageIndex(jcol);
+  // Interchange row subscripts
+  if (pivptr != nsupc )
+  {
+    std::swap( lsub_ptr[pivptr], lsub_ptr[nsupc] );
+    // Interchange numerical values as well, for the two rows in the whole snode
+    // such that L is indexed the same way as A
+    for (icol = 0; icol <= nsupc; icol++)
+    {
+      itemp = pivptr + icol * lda; 
+      std::swap(lu_sup_ptr[itemp], lu_sup_ptr[nsupc + icol * lda]);
+    }
+  }
+  // cdiv operations
+  Scalar temp = Scalar(1.0) / lu_col_ptr[nsupc];
+  for (k = nsupc+1; k < nsupr; k++)
+    lu_col_ptr[k] *= temp; 
+  return 0;
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_PIVOTL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_pruneL.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_pruneL.h
new file mode 100644
index 00000000..ad32fed5
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_pruneL.h
@@ -0,0 +1,136 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]pruneL.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PRUNEL_H
+#define SPARSELU_PRUNEL_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Prunes the L-structure.
+ *
+ * It prunes the L-structure  of supernodes whose L-structure contains the current pivot row "pivrow"
+ * 
+ * 
+ * \param jcol The current column of L
+ * \param[in] perm_r Row permutation
+ * \param[out] pivrow  The pivot row
+ * \param nseg Number of segments
+ * \param segrep 
+ * \param repfnz
+ * \param[out] xprune 
+ * \param glu Global LU data
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::pruneL(const Index jcol, const IndexVector& perm_r, const Index pivrow, const Index nseg,
+                                               const IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, GlobalLU_t& glu)
+{
+  // For each supernode-rep irep in U(*,j]
+  Index jsupno = glu.supno(jcol); 
+  Index i,irep,irep1; 
+  bool movnum, do_prune = false; 
+  Index kmin = 0, kmax = 0, minloc, maxloc,krow; 
+  for (i = 0; i < nseg; i++)
+  {
+    irep = segrep(i); 
+    irep1 = irep + 1; 
+    do_prune = false; 
+    
+    // Don't prune with a zero U-segment 
+    if (repfnz(irep) == emptyIdxLU) continue; 
+    
+    // If a snode overlaps with the next panel, then the U-segment
+    // is fragmented into two parts -- irep and irep1. We should let 
+    // pruning occur at the rep-column in irep1s snode. 
+    if (glu.supno(irep) == glu.supno(irep1) ) continue; // don't prune 
+    
+    // If it has not been pruned & it has a nonz in row L(pivrow,i)
+    if (glu.supno(irep) != jsupno )
+    {
+      if ( xprune (irep) >= glu.xlsub(irep1) )
+      {
+        kmin = glu.xlsub(irep);
+        kmax = glu.xlsub(irep1) - 1; 
+        for (krow = kmin; krow <= kmax; krow++)
+        {
+          if (glu.lsub(krow) == pivrow) 
+          {
+            do_prune = true; 
+            break; 
+          }
+        }
+      }
+      
+      if (do_prune) 
+      {
+        // do a quicksort-type partition
+        // movnum=true means that the num values have to be exchanged
+        movnum = false; 
+        if (irep == glu.xsup(glu.supno(irep)) ) // Snode of size 1 
+          movnum = true; 
+        
+        while (kmin <= kmax)
+        {
+          if (perm_r(glu.lsub(kmax)) == emptyIdxLU)
+            kmax--; 
+          else if ( perm_r(glu.lsub(kmin)) != emptyIdxLU)
+            kmin++;
+          else 
+          {
+            // kmin below pivrow (not yet pivoted), and kmax
+            // above pivrow: interchange the two suscripts
+            std::swap(glu.lsub(kmin), glu.lsub(kmax)); 
+            
+            // If the supernode has only one column, then we 
+            // only keep one set of subscripts. For any subscript
+            // intercnahge performed, similar interchange must be 
+            // done on the numerical values. 
+            if (movnum) 
+            {
+              minloc = glu.xlusup(irep) + ( kmin - glu.xlsub(irep) ); 
+              maxloc = glu.xlusup(irep) + ( kmax - glu.xlsub(irep) ); 
+              std::swap(glu.lusup(minloc), glu.lusup(maxloc)); 
+            }
+            kmin++;
+            kmax--;
+          }
+        } // end while 
+        
+        xprune(irep) = StorageIndex(kmin);  //Pruning 
+      } // end if do_prune 
+    } // end pruning 
+  } // End for each U-segment
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_PRUNEL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_relax_snode.h b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_relax_snode.h
new file mode 100644
index 00000000..c408d01b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseLU/SparseLU_relax_snode.h
@@ -0,0 +1,83 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* This file is a modified version of heap_relax_snode.c file in SuperLU
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+
+#ifndef SPARSELU_RELAX_SNODE_H
+#define SPARSELU_RELAX_SNODE_H
+
+namespace Eigen {
+
+namespace internal {
+ 
+/** 
+ * \brief Identify the initial relaxed supernodes
+ * 
+ * This routine is applied to a column elimination tree. 
+ * It assumes that the matrix has been reordered according to the postorder of the etree
+ * \param n  the number of columns
+ * \param et elimination tree 
+ * \param relax_columns Maximum number of columns allowed in a relaxed snode 
+ * \param descendants Number of descendants of each node in the etree
+ * \param relax_end last column in a supernode
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end)
+{
+  
+  // compute the number of descendants of each node in the etree
+  Index parent; 
+  relax_end.setConstant(emptyIdxLU);
+  descendants.setZero();
+  for (Index j = 0; j < n; j++) 
+  {
+    parent = et(j);
+    if (parent != n) // not the dummy root
+      descendants(parent) += descendants(j) + 1;
+  }
+  // Identify the relaxed supernodes by postorder traversal of the etree
+  Index snode_start; // beginning of a snode 
+  for (Index j = 0; j < n; )
+  {
+    parent = et(j);
+    snode_start = j; 
+    while ( parent != n && descendants(parent) < relax_columns ) 
+    {
+      j = parent; 
+      parent = et(j);
+    }
+    // Found a supernode in postordered etree, j is the last column 
+    relax_end(snode_start) = StorageIndex(j); // Record last column
+    j++;
+    // Search for a new leaf
+    while (descendants(j) != 0 && j < n) j++;
+  } // End postorder traversal of the etree
+  
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SparseQR/SparseQR.h b/C++/yolo_bytetrack/include/Eigen/src/SparseQR/SparseQR.h
new file mode 100644
index 00000000..d1fb96f5
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SparseQR/SparseQR.h
@@ -0,0 +1,758 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012-2013 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_QR_H
+#define EIGEN_SPARSE_QR_H
+
+namespace Eigen {
+
+template<typename MatrixType, typename OrderingType> class SparseQR;
+template<typename SparseQRType> struct SparseQRMatrixQReturnType;
+template<typename SparseQRType> struct SparseQRMatrixQTransposeReturnType;
+template<typename SparseQRType, typename Derived> struct SparseQR_QProduct;
+namespace internal {
+  template <typename SparseQRType> struct traits<SparseQRMatrixQReturnType<SparseQRType> >
+  {
+    typedef typename SparseQRType::MatrixType ReturnType;
+    typedef typename ReturnType::StorageIndex StorageIndex;
+    typedef typename ReturnType::StorageKind StorageKind;
+    enum {
+      RowsAtCompileTime = Dynamic,
+      ColsAtCompileTime = Dynamic
+    };
+  };
+  template <typename SparseQRType> struct traits<SparseQRMatrixQTransposeReturnType<SparseQRType> >
+  {
+    typedef typename SparseQRType::MatrixType ReturnType;
+  };
+  template <typename SparseQRType, typename Derived> struct traits<SparseQR_QProduct<SparseQRType, Derived> >
+  {
+    typedef typename Derived::PlainObject ReturnType;
+  };
+} // End namespace internal
+
+/**
+  * \ingroup SparseQR_Module
+  * \class SparseQR
+  * \brief Sparse left-looking QR factorization with numerical column pivoting
+  * 
+  * This class implements a left-looking QR decomposition of sparse matrices
+  * with numerical column pivoting.
+  * When a column has a norm less than a given tolerance
+  * it is implicitly permuted to the end. The QR factorization thus obtained is 
+  * given by A*P = Q*R where R is upper triangular or trapezoidal. 
+  * 
+  * P is the column permutation which is the product of the fill-reducing and the
+  * numerical permutations. Use colsPermutation() to get it.
+  * 
+  * Q is the orthogonal matrix represented as products of Householder reflectors. 
+  * Use matrixQ() to get an expression and matrixQ().adjoint() to get the adjoint.
+  * You can then apply it to a vector.
+  * 
+  * R is the sparse triangular or trapezoidal matrix. The later occurs when A is rank-deficient.
+  * matrixR().topLeftCorner(rank(), rank()) always returns a triangular factor of full rank.
+  * 
+  * \tparam _MatrixType The type of the sparse matrix A, must be a column-major SparseMatrix<>
+  * \tparam _OrderingType The fill-reducing ordering method. See the \link OrderingMethods_Module 
+  *  OrderingMethods \endlink module for the list of built-in and external ordering methods.
+  * 
+  * \implsparsesolverconcept
+  *
+  * The numerical pivoting strategy and default threshold are the same as in SuiteSparse QR, and
+  * detailed in the following paper:
+  * <i>
+  * Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
+  * Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011.
+  * </i>
+  * Even though it is qualified as "rank-revealing", this strategy might fail for some 
+  * rank deficient problems. When this class is used to solve linear or least-square problems
+  * it is thus strongly recommended to check the accuracy of the computed solution. If it
+  * failed, it usually helps to increase the threshold with setPivotThreshold.
+  * 
+  * \warning The input sparse matrix A must be in compressed mode (see SparseMatrix::makeCompressed()).
+  * \warning For complex matrices matrixQ().transpose() will actually return the adjoint matrix.
+  * 
+  */
+template<typename _MatrixType, typename _OrderingType>
+class SparseQR : public SparseSolverBase<SparseQR<_MatrixType,_OrderingType> >
+{
+  protected:
+    typedef SparseSolverBase<SparseQR<_MatrixType,_OrderingType> > Base;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    typedef _MatrixType MatrixType;
+    typedef _OrderingType OrderingType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> QRMatrixType;
+    typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
+    typedef Matrix<Scalar, Dynamic, 1> ScalarVector;
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+  public:
+    SparseQR () :  m_analysisIsok(false), m_lastError(""), m_useDefaultThreshold(true),m_isQSorted(false),m_isEtreeOk(false)
+    { }
+    
+    /** Construct a QR factorization of the matrix \a mat.
+      * 
+      * \warning The matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+      * 
+      * \sa compute()
+      */
+    explicit SparseQR(const MatrixType& mat) : m_analysisIsok(false), m_lastError(""), m_useDefaultThreshold(true),m_isQSorted(false),m_isEtreeOk(false)
+    {
+      compute(mat);
+    }
+    
+    /** Computes the QR factorization of the sparse matrix \a mat.
+      * 
+      * \warning The matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+      * 
+      * \sa analyzePattern(), factorize()
+      */
+    void compute(const MatrixType& mat)
+    {
+      analyzePattern(mat);
+      factorize(mat);
+    }
+    void analyzePattern(const MatrixType& mat);
+    void factorize(const MatrixType& mat);
+    
+    /** \returns the number of rows of the represented matrix. 
+      */
+    inline Index rows() const { return m_pmat.rows(); }
+    
+    /** \returns the number of columns of the represented matrix. 
+      */
+    inline Index cols() const { return m_pmat.cols();}
+    
+    /** \returns a const reference to the \b sparse upper triangular matrix R of the QR factorization.
+      * \warning The entries of the returned matrix are not sorted. This means that using it in algorithms
+      *          expecting sorted entries will fail. This include random coefficient accesses (SpaseMatrix::coeff()),
+      *          and coefficient-wise operations. Matrix products and triangular solves are fine though.
+      *
+      * To sort the entries, you can assign it to a row-major matrix, and if a column-major matrix
+      * is required, you can copy it again:
+      * \code
+      * SparseMatrix<double>          R  = qr.matrixR();  // column-major, not sorted!
+      * SparseMatrix<double,RowMajor> Rr = qr.matrixR();  // row-major, sorted
+      * SparseMatrix<double>          Rc = Rr;            // column-major, sorted
+      * \endcode
+      */
+    const QRMatrixType& matrixR() const { return m_R; }
+    
+    /** \returns the number of non linearly dependent columns as determined by the pivoting threshold.
+      *
+      * \sa setPivotThreshold()
+      */
+    Index rank() const
+    {
+      eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+      return m_nonzeropivots; 
+    }
+    
+    /** \returns an expression of the matrix Q as products of sparse Householder reflectors.
+    * The common usage of this function is to apply it to a dense matrix or vector
+    * \code
+    * VectorXd B1, B2;
+    * // Initialize B1
+    * B2 = matrixQ() * B1;
+    * \endcode
+    *
+    * To get a plain SparseMatrix representation of Q:
+    * \code
+    * SparseMatrix<double> Q;
+    * Q = SparseQR<SparseMatrix<double> >(A).matrixQ();
+    * \endcode
+    * Internally, this call simply performs a sparse product between the matrix Q
+    * and a sparse identity matrix. However, due to the fact that the sparse
+    * reflectors are stored unsorted, two transpositions are needed to sort
+    * them before performing the product.
+    */
+    SparseQRMatrixQReturnType<SparseQR> matrixQ() const 
+    { return SparseQRMatrixQReturnType<SparseQR>(*this); }
+    
+    /** \returns a const reference to the column permutation P that was applied to A such that A*P = Q*R
+      * It is the combination of the fill-in reducing permutation and numerical column pivoting.
+      */
+    const PermutationType& colsPermutation() const
+    { 
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_outputPerm_c;
+    }
+    
+    /** \returns A string describing the type of error.
+      * This method is provided to ease debugging, not to handle errors.
+      */
+    std::string lastErrorMessage() const { return m_lastError; }
+    
+    /** \internal */
+    template<typename Rhs, typename Dest>
+    bool _solve_impl(const MatrixBase<Rhs> &B, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+      eigen_assert(this->rows() == B.rows() && "SparseQR::solve() : invalid number of rows in the right hand side matrix");
+
+      Index rank = this->rank();
+      
+      // Compute Q^* * b;
+      typename Dest::PlainObject y, b;
+      y = this->matrixQ().adjoint() * B;
+      b = y;
+      
+      // Solve with the triangular matrix R
+      y.resize((std::max<Index>)(cols(),y.rows()),y.cols());
+      y.topRows(rank) = this->matrixR().topLeftCorner(rank, rank).template triangularView<Upper>().solve(b.topRows(rank));
+      y.bottomRows(y.rows()-rank).setZero();
+      
+      // Apply the column permutation
+      if (m_perm_c.size())  dest = colsPermutation() * y.topRows(cols());
+      else                  dest = y.topRows(cols());
+      
+      m_info = Success;
+      return true;
+    }
+
+    /** Sets the threshold that is used to determine linearly dependent columns during the factorization.
+      *
+      * In practice, if during the factorization the norm of the column that has to be eliminated is below
+      * this threshold, then the entire column is treated as zero, and it is moved at the end.
+      */
+    void setPivotThreshold(const RealScalar& threshold)
+    {
+      m_useDefaultThreshold = false;
+      m_threshold = threshold;
+    }
+    
+    /** \returns the solution X of \f$ A X = B \f$ using the current decomposition of A.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<SparseQR, Rhs> solve(const MatrixBase<Rhs>& B) const 
+    {
+      eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+      eigen_assert(this->rows() == B.rows() && "SparseQR::solve() : invalid number of rows in the right hand side matrix");
+      return Solve<SparseQR, Rhs>(*this, B.derived());
+    }
+    template<typename Rhs>
+    inline const Solve<SparseQR, Rhs> solve(const SparseMatrixBase<Rhs>& B) const
+    {
+          eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+          eigen_assert(this->rows() == B.rows() && "SparseQR::solve() : invalid number of rows in the right hand side matrix");
+          return Solve<SparseQR, Rhs>(*this, B.derived());
+    }
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the QR factorization reports a numerical problem
+      *          \c InvalidInput if the input matrix is invalid
+      *
+      * \sa iparm()          
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+
+    /** \internal */
+    inline void _sort_matrix_Q()
+    {
+      if(this->m_isQSorted) return;
+      // The matrix Q is sorted during the transposition
+      SparseMatrix<Scalar, RowMajor, Index> mQrm(this->m_Q);
+      this->m_Q = mQrm;
+      this->m_isQSorted = true;
+    }
+
+    
+  protected:
+    bool m_analysisIsok;
+    bool m_factorizationIsok;
+    mutable ComputationInfo m_info;
+    std::string m_lastError;
+    QRMatrixType m_pmat;            // Temporary matrix
+    QRMatrixType m_R;               // The triangular factor matrix
+    QRMatrixType m_Q;               // The orthogonal reflectors
+    ScalarVector m_hcoeffs;         // The Householder coefficients
+    PermutationType m_perm_c;       // Fill-reducing  Column  permutation
+    PermutationType m_pivotperm;    // The permutation for rank revealing
+    PermutationType m_outputPerm_c; // The final column permutation
+    RealScalar m_threshold;         // Threshold to determine null Householder reflections
+    bool m_useDefaultThreshold;     // Use default threshold
+    Index m_nonzeropivots;          // Number of non zero pivots found
+    IndexVector m_etree;            // Column elimination tree
+    IndexVector m_firstRowElt;      // First element in each row
+    bool m_isQSorted;               // whether Q is sorted or not
+    bool m_isEtreeOk;               // whether the elimination tree match the initial input matrix
+    
+    template <typename, typename > friend struct SparseQR_QProduct;
+    
+};
+
+/** \brief Preprocessing step of a QR factorization 
+  * 
+  * \warning The matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+  * 
+  * In this step, the fill-reducing permutation is computed and applied to the columns of A
+  * and the column elimination tree is computed as well. Only the sparsity pattern of \a mat is exploited.
+  * 
+  * \note In this step it is assumed that there is no empty row in the matrix \a mat.
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseQR<MatrixType,OrderingType>::analyzePattern(const MatrixType& mat)
+{
+  eigen_assert(mat.isCompressed() && "SparseQR requires a sparse matrix in compressed mode. Call .makeCompressed() before passing it to SparseQR");
+  // Copy to a column major matrix if the input is rowmajor
+  typename internal::conditional<MatrixType::IsRowMajor,QRMatrixType,const MatrixType&>::type matCpy(mat);
+  // Compute the column fill reducing ordering
+  OrderingType ord; 
+  ord(matCpy, m_perm_c); 
+  Index n = mat.cols();
+  Index m = mat.rows();
+  Index diagSize = (std::min)(m,n);
+  
+  if (!m_perm_c.size())
+  {
+    m_perm_c.resize(n);
+    m_perm_c.indices().setLinSpaced(n, 0,StorageIndex(n-1));
+  }
+  
+  // Compute the column elimination tree of the permuted matrix
+  m_outputPerm_c = m_perm_c.inverse();
+  internal::coletree(matCpy, m_etree, m_firstRowElt, m_outputPerm_c.indices().data());
+  m_isEtreeOk = true;
+  
+  m_R.resize(m, n);
+  m_Q.resize(m, diagSize);
+  
+  // Allocate space for nonzero elements: rough estimation
+  m_R.reserve(2*mat.nonZeros()); //FIXME Get a more accurate estimation through symbolic factorization with the etree
+  m_Q.reserve(2*mat.nonZeros());
+  m_hcoeffs.resize(diagSize);
+  m_analysisIsok = true;
+}
+
+/** \brief Performs the numerical QR factorization of the input matrix
+  * 
+  * The function SparseQR::analyzePattern(const MatrixType&) must have been called beforehand with
+  * a matrix having the same sparsity pattern than \a mat.
+  * 
+  * \param mat The sparse column-major matrix
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseQR<MatrixType,OrderingType>::factorize(const MatrixType& mat)
+{
+  using std::abs;
+  
+  eigen_assert(m_analysisIsok && "analyzePattern() should be called before this step");
+  StorageIndex m = StorageIndex(mat.rows());
+  StorageIndex n = StorageIndex(mat.cols());
+  StorageIndex diagSize = (std::min)(m,n);
+  IndexVector mark((std::max)(m,n)); mark.setConstant(-1);  // Record the visited nodes
+  IndexVector Ridx(n), Qidx(m);                             // Store temporarily the row indexes for the current column of R and Q
+  Index nzcolR, nzcolQ;                                     // Number of nonzero for the current column of R and Q
+  ScalarVector tval(m);                                     // The dense vector used to compute the current column
+  RealScalar pivotThreshold = m_threshold;
+  
+  m_R.setZero();
+  m_Q.setZero();
+  m_pmat = mat;
+  if(!m_isEtreeOk)
+  {
+    m_outputPerm_c = m_perm_c.inverse();
+    internal::coletree(m_pmat, m_etree, m_firstRowElt, m_outputPerm_c.indices().data());
+    m_isEtreeOk = true;
+  }
+
+  m_pmat.uncompress(); // To have the innerNonZeroPtr allocated
+  
+  // Apply the fill-in reducing permutation lazily:
+  {
+    // If the input is row major, copy the original column indices,
+    // otherwise directly use the input matrix
+    // 
+    IndexVector originalOuterIndicesCpy;
+    const StorageIndex *originalOuterIndices = mat.outerIndexPtr();
+    if(MatrixType::IsRowMajor)
+    {
+      originalOuterIndicesCpy = IndexVector::Map(m_pmat.outerIndexPtr(),n+1);
+      originalOuterIndices = originalOuterIndicesCpy.data();
+    }
+    
+    for (int i = 0; i < n; i++)
+    {
+      Index p = m_perm_c.size() ? m_perm_c.indices()(i) : i;
+      m_pmat.outerIndexPtr()[p] = originalOuterIndices[i]; 
+      m_pmat.innerNonZeroPtr()[p] = originalOuterIndices[i+1] - originalOuterIndices[i]; 
+    }
+  }
+  
+  /* Compute the default threshold as in MatLab, see:
+   * Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
+   * Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011, Page 8:3 
+   */
+  if(m_useDefaultThreshold) 
+  {
+    RealScalar max2Norm = 0.0;
+    for (int j = 0; j < n; j++) max2Norm = numext::maxi(max2Norm, m_pmat.col(j).norm());
+    if(max2Norm==RealScalar(0))
+      max2Norm = RealScalar(1);
+    pivotThreshold = 20 * (m + n) * max2Norm * NumTraits<RealScalar>::epsilon();
+  }
+  
+  // Initialize the numerical permutation
+  m_pivotperm.setIdentity(n);
+  
+  StorageIndex nonzeroCol = 0; // Record the number of valid pivots
+  m_Q.startVec(0);
+
+  // Left looking rank-revealing QR factorization: compute a column of R and Q at a time
+  for (StorageIndex col = 0; col < n; ++col)
+  {
+    mark.setConstant(-1);
+    m_R.startVec(col);
+    mark(nonzeroCol) = col;
+    Qidx(0) = nonzeroCol;
+    nzcolR = 0; nzcolQ = 1;
+    bool found_diag = nonzeroCol>=m;
+    tval.setZero(); 
+    
+    // Symbolic factorization: find the nonzero locations of the column k of the factors R and Q, i.e.,
+    // all the nodes (with indexes lower than rank) reachable through the column elimination tree (etree) rooted at node k.
+    // Note: if the diagonal entry does not exist, then its contribution must be explicitly added,
+    // thus the trick with found_diag that permits to do one more iteration on the diagonal element if this one has not been found.
+    for (typename QRMatrixType::InnerIterator itp(m_pmat, col); itp || !found_diag; ++itp)
+    {
+      StorageIndex curIdx = nonzeroCol;
+      if(itp) curIdx = StorageIndex(itp.row());
+      if(curIdx == nonzeroCol) found_diag = true;
+      
+      // Get the nonzeros indexes of the current column of R
+      StorageIndex st = m_firstRowElt(curIdx); // The traversal of the etree starts here
+      if (st < 0 )
+      {
+        m_lastError = "Empty row found during numerical factorization";
+        m_info = InvalidInput;
+        return;
+      }
+
+      // Traverse the etree 
+      Index bi = nzcolR;
+      for (; mark(st) != col; st = m_etree(st))
+      {
+        Ridx(nzcolR) = st;  // Add this row to the list,
+        mark(st) = col;     // and mark this row as visited
+        nzcolR++;
+      }
+
+      // Reverse the list to get the topological ordering
+      Index nt = nzcolR-bi;
+      for(Index i = 0; i < nt/2; i++) std::swap(Ridx(bi+i), Ridx(nzcolR-i-1));
+       
+      // Copy the current (curIdx,pcol) value of the input matrix
+      if(itp) tval(curIdx) = itp.value();
+      else    tval(curIdx) = Scalar(0);
+      
+      // Compute the pattern of Q(:,k)
+      if(curIdx > nonzeroCol && mark(curIdx) != col ) 
+      {
+        Qidx(nzcolQ) = curIdx;  // Add this row to the pattern of Q,
+        mark(curIdx) = col;     // and mark it as visited
+        nzcolQ++;
+      }
+    }
+
+    // Browse all the indexes of R(:,col) in reverse order
+    for (Index i = nzcolR-1; i >= 0; i--)
+    {
+      Index curIdx = Ridx(i);
+      
+      // Apply the curIdx-th householder vector to the current column (temporarily stored into tval)
+      Scalar tdot(0);
+      
+      // First compute q' * tval
+      tdot = m_Q.col(curIdx).dot(tval);
+
+      tdot *= m_hcoeffs(curIdx);
+      
+      // Then update tval = tval - q * tau
+      // FIXME: tval -= tdot * m_Q.col(curIdx) should amount to the same (need to check/add support for efficient "dense ?= sparse")
+      for (typename QRMatrixType::InnerIterator itq(m_Q, curIdx); itq; ++itq)
+        tval(itq.row()) -= itq.value() * tdot;
+
+      // Detect fill-in for the current column of Q
+      if(m_etree(Ridx(i)) == nonzeroCol)
+      {
+        for (typename QRMatrixType::InnerIterator itq(m_Q, curIdx); itq; ++itq)
+        {
+          StorageIndex iQ = StorageIndex(itq.row());
+          if (mark(iQ) != col)
+          {
+            Qidx(nzcolQ++) = iQ;  // Add this row to the pattern of Q,
+            mark(iQ) = col;       // and mark it as visited
+          }
+        }
+      }
+    } // End update current column
+    
+    Scalar tau = RealScalar(0);
+    RealScalar beta = 0;
+    
+    if(nonzeroCol < diagSize)
+    {
+      // Compute the Householder reflection that eliminate the current column
+      // FIXME this step should call the Householder module.
+      Scalar c0 = nzcolQ ? tval(Qidx(0)) : Scalar(0);
+      
+      // First, the squared norm of Q((col+1):m, col)
+      RealScalar sqrNorm = 0.;
+      for (Index itq = 1; itq < nzcolQ; ++itq) sqrNorm += numext::abs2(tval(Qidx(itq)));
+      if(sqrNorm == RealScalar(0) && numext::imag(c0) == RealScalar(0))
+      {
+        beta = numext::real(c0);
+        tval(Qidx(0)) = 1;
+      }
+      else
+      {
+        using std::sqrt;
+        beta = sqrt(numext::abs2(c0) + sqrNorm);
+        if(numext::real(c0) >= RealScalar(0))
+          beta = -beta;
+        tval(Qidx(0)) = 1;
+        for (Index itq = 1; itq < nzcolQ; ++itq)
+          tval(Qidx(itq)) /= (c0 - beta);
+        tau = numext::conj((beta-c0) / beta);
+          
+      }
+    }
+
+    // Insert values in R
+    for (Index  i = nzcolR-1; i >= 0; i--)
+    {
+      Index curIdx = Ridx(i);
+      if(curIdx < nonzeroCol) 
+      {
+        m_R.insertBackByOuterInnerUnordered(col, curIdx) = tval(curIdx);
+        tval(curIdx) = Scalar(0.);
+      }
+    }
+
+    if(nonzeroCol < diagSize && abs(beta) >= pivotThreshold)
+    {
+      m_R.insertBackByOuterInner(col, nonzeroCol) = beta;
+      // The householder coefficient
+      m_hcoeffs(nonzeroCol) = tau;
+      // Record the householder reflections
+      for (Index itq = 0; itq < nzcolQ; ++itq)
+      {
+        Index iQ = Qidx(itq);
+        m_Q.insertBackByOuterInnerUnordered(nonzeroCol,iQ) = tval(iQ);
+        tval(iQ) = Scalar(0.);
+      }
+      nonzeroCol++;
+      if(nonzeroCol<diagSize)
+        m_Q.startVec(nonzeroCol);
+    }
+    else
+    {
+      // Zero pivot found: move implicitly this column to the end
+      for (Index j = nonzeroCol; j < n-1; j++) 
+        std::swap(m_pivotperm.indices()(j), m_pivotperm.indices()[j+1]);
+      
+      // Recompute the column elimination tree
+      internal::coletree(m_pmat, m_etree, m_firstRowElt, m_pivotperm.indices().data());
+      m_isEtreeOk = false;
+    }
+  }
+  
+  m_hcoeffs.tail(diagSize-nonzeroCol).setZero();
+  
+  // Finalize the column pointers of the sparse matrices R and Q
+  m_Q.finalize();
+  m_Q.makeCompressed();
+  m_R.finalize();
+  m_R.makeCompressed();
+  m_isQSorted = false;
+
+  m_nonzeropivots = nonzeroCol;
+  
+  if(nonzeroCol<n)
+  {
+    // Permute the triangular factor to put the 'dead' columns to the end
+    QRMatrixType tempR(m_R);
+    m_R = tempR * m_pivotperm;
+    
+    // Update the column permutation
+    m_outputPerm_c = m_outputPerm_c * m_pivotperm;
+  }
+  
+  m_isInitialized = true; 
+  m_factorizationIsok = true;
+  m_info = Success;
+}
+
+template <typename SparseQRType, typename Derived>
+struct SparseQR_QProduct : ReturnByValue<SparseQR_QProduct<SparseQRType, Derived> >
+{
+  typedef typename SparseQRType::QRMatrixType MatrixType;
+  typedef typename SparseQRType::Scalar Scalar;
+  // Get the references 
+  SparseQR_QProduct(const SparseQRType& qr, const Derived& other, bool transpose) : 
+  m_qr(qr),m_other(other),m_transpose(transpose) {}
+  inline Index rows() const { return m_qr.matrixQ().rows(); }
+  inline Index cols() const { return m_other.cols(); }
+  
+  // Assign to a vector
+  template<typename DesType>
+  void evalTo(DesType& res) const
+  {
+    Index m = m_qr.rows();
+    Index n = m_qr.cols();
+    Index diagSize = (std::min)(m,n);
+    res = m_other;
+    if (m_transpose)
+    {
+      eigen_assert(m_qr.m_Q.rows() == m_other.rows() && "Non conforming object sizes");
+      //Compute res = Q' * other column by column
+      for(Index j = 0; j < res.cols(); j++){
+        for (Index k = 0; k < diagSize; k++)
+        {
+          Scalar tau = Scalar(0);
+          tau = m_qr.m_Q.col(k).dot(res.col(j));
+          if(tau==Scalar(0)) continue;
+          tau = tau * m_qr.m_hcoeffs(k);
+          res.col(j) -= tau * m_qr.m_Q.col(k);
+        }
+      }
+    }
+    else
+    {
+      eigen_assert(m_qr.matrixQ().cols() == m_other.rows() && "Non conforming object sizes");
+
+      res.conservativeResize(rows(), cols());
+
+      // Compute res = Q * other column by column
+      for(Index j = 0; j < res.cols(); j++)
+      {
+        Index start_k = internal::is_identity<Derived>::value ? numext::mini(j,diagSize-1) : diagSize-1;
+        for (Index k = start_k; k >=0; k--)
+        {
+          Scalar tau = Scalar(0);
+          tau = m_qr.m_Q.col(k).dot(res.col(j));
+          if(tau==Scalar(0)) continue;
+          tau = tau * numext::conj(m_qr.m_hcoeffs(k));
+          res.col(j) -= tau * m_qr.m_Q.col(k);
+        }
+      }
+    }
+  }
+  
+  const SparseQRType& m_qr;
+  const Derived& m_other;
+  bool m_transpose; // TODO this actually means adjoint
+};
+
+template<typename SparseQRType>
+struct SparseQRMatrixQReturnType : public EigenBase<SparseQRMatrixQReturnType<SparseQRType> >
+{  
+  typedef typename SparseQRType::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
+  enum {
+    RowsAtCompileTime = Dynamic,
+    ColsAtCompileTime = Dynamic
+  };
+  explicit SparseQRMatrixQReturnType(const SparseQRType& qr) : m_qr(qr) {}
+  template<typename Derived>
+  SparseQR_QProduct<SparseQRType, Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SparseQR_QProduct<SparseQRType,Derived>(m_qr,other.derived(),false);
+  }
+  // To use for operations with the adjoint of Q
+  SparseQRMatrixQTransposeReturnType<SparseQRType> adjoint() const
+  {
+    return SparseQRMatrixQTransposeReturnType<SparseQRType>(m_qr);
+  }
+  inline Index rows() const { return m_qr.rows(); }
+  inline Index cols() const { return m_qr.rows(); }
+  // To use for operations with the transpose of Q FIXME this is the same as adjoint at the moment
+  SparseQRMatrixQTransposeReturnType<SparseQRType> transpose() const
+  {
+    return SparseQRMatrixQTransposeReturnType<SparseQRType>(m_qr);
+  }
+  const SparseQRType& m_qr;
+};
+
+// TODO this actually represents the adjoint of Q
+template<typename SparseQRType>
+struct SparseQRMatrixQTransposeReturnType
+{
+  explicit SparseQRMatrixQTransposeReturnType(const SparseQRType& qr) : m_qr(qr) {}
+  template<typename Derived>
+  SparseQR_QProduct<SparseQRType,Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SparseQR_QProduct<SparseQRType,Derived>(m_qr,other.derived(), true);
+  }
+  const SparseQRType& m_qr;
+};
+
+namespace internal {
+  
+template<typename SparseQRType>
+struct evaluator_traits<SparseQRMatrixQReturnType<SparseQRType> >
+{
+  typedef typename SparseQRType::MatrixType MatrixType;
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef SparseShape Shape;
+};
+
+template< typename DstXprType, typename SparseQRType>
+struct Assignment<DstXprType, SparseQRMatrixQReturnType<SparseQRType>, internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>, Sparse2Sparse>
+{
+  typedef SparseQRMatrixQReturnType<SparseQRType> SrcXprType;
+  typedef typename DstXprType::Scalar Scalar;
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &/*func*/)
+  {
+    typename DstXprType::PlainObject idMat(src.rows(), src.cols());
+    idMat.setIdentity();
+    // Sort the sparse householder reflectors if needed
+    const_cast<SparseQRType *>(&src.m_qr)->_sort_matrix_Q();
+    dst = SparseQR_QProduct<SparseQRType, DstXprType>(src.m_qr, idMat, false);
+  }
+};
+
+template< typename DstXprType, typename SparseQRType>
+struct Assignment<DstXprType, SparseQRMatrixQReturnType<SparseQRType>, internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>, Sparse2Dense>
+{
+  typedef SparseQRMatrixQReturnType<SparseQRType> SrcXprType;
+  typedef typename DstXprType::Scalar Scalar;
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &/*func*/)
+  {
+    dst = src.m_qr.matrixQ() * DstXprType::Identity(src.m_qr.rows(), src.m_qr.rows());
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/StlSupport/StdDeque.h b/C++/yolo_bytetrack/include/Eigen/src/StlSupport/StdDeque.h
new file mode 100644
index 00000000..6d47e757
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/StlSupport/StdDeque.h
@@ -0,0 +1,116 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDDEQUE_H
+#define EIGEN_STDDEQUE_H
+
+#include "details.h"
+
+/**
+ * This section contains a convenience MACRO which allows an easy specialization of
+ * std::deque such that for data types with alignment issues the correct allocator
+ * is used automatically.
+ */
+#define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...) \
+namespace std \
+{ \
+  template<> \
+  class deque<__VA_ARGS__, std::allocator<__VA_ARGS__> >           \
+    : public deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \
+  { \
+    typedef deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > deque_base; \
+  public: \
+    typedef __VA_ARGS__ value_type; \
+    typedef deque_base::allocator_type allocator_type; \
+    typedef deque_base::size_type size_type;  \
+    typedef deque_base::iterator iterator;  \
+    explicit deque(const allocator_type& a = allocator_type()) : deque_base(a) {}  \
+    template<typename InputIterator> \
+    deque(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : deque_base(first, last, a) {} \
+    deque(const deque& c) : deque_base(c) {}  \
+    explicit deque(size_type num, const value_type& val = value_type()) : deque_base(num, val) {} \
+    deque(iterator start_, iterator end_) : deque_base(start_, end_) {}  \
+    deque& operator=(const deque& x) {  \
+      deque_base::operator=(x);  \
+      return *this;  \
+    } \
+  }; \
+}
+
+// check whether we really need the std::deque specialization
+#if !EIGEN_HAS_CXX11_CONTAINERS && !(defined(_GLIBCXX_DEQUE) && (!EIGEN_GNUC_AT_LEAST(4,1))) /* Note that before gcc-4.1 we already have: std::deque::resize(size_type,const T&). */
+
+namespace std {
+
+#define EIGEN_STD_DEQUE_SPECIALIZATION_BODY \
+  public:  \
+    typedef T value_type; \
+    typedef typename deque_base::allocator_type allocator_type; \
+    typedef typename deque_base::size_type size_type;  \
+    typedef typename deque_base::iterator iterator;  \
+    typedef typename deque_base::const_iterator const_iterator;  \
+    explicit deque(const allocator_type& a = allocator_type()) : deque_base(a) {}  \
+    template<typename InputIterator> \
+    deque(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
+    : deque_base(first, last, a) {} \
+    deque(const deque& c) : deque_base(c) {}  \
+    explicit deque(size_type num, const value_type& val = value_type()) : deque_base(num, val) {} \
+    deque(iterator start_, iterator end_) : deque_base(start_, end_) {}  \
+    deque& operator=(const deque& x) {  \
+      deque_base::operator=(x);  \
+      return *this;  \
+    }
+
+  template<typename T>
+  class deque<T,EIGEN_ALIGNED_ALLOCATOR<T> >
+    : public deque<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                   Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> >
+{
+  typedef deque<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > deque_base;
+  EIGEN_STD_DEQUE_SPECIALIZATION_BODY
+
+  void resize(size_type new_size)
+  { resize(new_size, T()); }
+
+#if defined(_DEQUE_)
+  // workaround MSVC std::deque implementation
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (deque_base::size() < new_size)
+      deque_base::_Insert_n(deque_base::end(), new_size - deque_base::size(), x);
+    else if (new_size < deque_base::size())
+      deque_base::erase(deque_base::begin() + new_size, deque_base::end());
+  }
+  void push_back(const value_type& x)
+  { deque_base::push_back(x); } 
+  void push_front(const value_type& x)
+  { deque_base::push_front(x); }
+  using deque_base::insert;  
+  iterator insert(const_iterator position, const value_type& x)
+  { return deque_base::insert(position,x); }
+  void insert(const_iterator position, size_type new_size, const value_type& x)
+  { deque_base::insert(position, new_size, x); }
+#else
+  // default implementation which should always work.
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (new_size < deque_base::size())
+      deque_base::erase(deque_base::begin() + new_size, deque_base::end());
+    else if (new_size > deque_base::size())
+      deque_base::insert(deque_base::end(), new_size - deque_base::size(), x);
+  }
+#endif
+  };
+}
+
+#endif // check whether specialization is actually required
+
+#endif // EIGEN_STDDEQUE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/StlSupport/StdList.h b/C++/yolo_bytetrack/include/Eigen/src/StlSupport/StdList.h
new file mode 100644
index 00000000..8ba3fada
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/StlSupport/StdList.h
@@ -0,0 +1,106 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDLIST_H
+#define EIGEN_STDLIST_H
+
+#include "details.h"
+
+/**
+ * This section contains a convenience MACRO which allows an easy specialization of
+ * std::list such that for data types with alignment issues the correct allocator
+ * is used automatically.
+ */
+#define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...) \
+namespace std \
+{ \
+  template<> \
+  class list<__VA_ARGS__, std::allocator<__VA_ARGS__> >           \
+    : public list<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \
+  { \
+    typedef list<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > list_base; \
+  public: \
+    typedef __VA_ARGS__ value_type; \
+    typedef list_base::allocator_type allocator_type; \
+    typedef list_base::size_type size_type;  \
+    typedef list_base::iterator iterator;  \
+    explicit list(const allocator_type& a = allocator_type()) : list_base(a) {}  \
+    template<typename InputIterator> \
+    list(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : list_base(first, last, a) {} \
+    list(const list& c) : list_base(c) {}  \
+    explicit list(size_type num, const value_type& val = value_type()) : list_base(num, val) {} \
+    list(iterator start_, iterator end_) : list_base(start_, end_) {}  \
+    list& operator=(const list& x) {  \
+      list_base::operator=(x);  \
+      return *this;  \
+    } \
+  }; \
+}
+
+// check whether we really need the std::list specialization
+#if !EIGEN_HAS_CXX11_CONTAINERS && !(defined(_GLIBCXX_LIST) && (!EIGEN_GNUC_AT_LEAST(4,1))) /* Note that before gcc-4.1 we already have: std::list::resize(size_type,const T&). */
+
+namespace std
+{
+
+#define EIGEN_STD_LIST_SPECIALIZATION_BODY \
+  public:  \
+    typedef T value_type; \
+    typedef typename list_base::allocator_type allocator_type; \
+    typedef typename list_base::size_type size_type;  \
+    typedef typename list_base::iterator iterator;  \
+    typedef typename list_base::const_iterator const_iterator;  \
+    explicit list(const allocator_type& a = allocator_type()) : list_base(a) {}  \
+    template<typename InputIterator> \
+    list(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
+    : list_base(first, last, a) {} \
+    list(const list& c) : list_base(c) {}  \
+    explicit list(size_type num, const value_type& val = value_type()) : list_base(num, val) {} \
+    list(iterator start_, iterator end_) : list_base(start_, end_) {}  \
+    list& operator=(const list& x) {  \
+    list_base::operator=(x);  \
+    return *this; \
+  }
+
+  template<typename T>
+  class list<T,EIGEN_ALIGNED_ALLOCATOR<T> >
+    : public list<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                  Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> >
+  {
+    typedef list<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                 Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > list_base;
+    EIGEN_STD_LIST_SPECIALIZATION_BODY
+
+    void resize(size_type new_size)
+    { resize(new_size, T()); }
+
+    void resize(size_type new_size, const value_type& x)
+    {
+      if (list_base::size() < new_size)
+        list_base::insert(list_base::end(), new_size - list_base::size(), x);
+      else
+        while (new_size < list_base::size()) list_base::pop_back();
+    }
+
+#if defined(_LIST_)
+    // workaround MSVC std::list implementation
+    void push_back(const value_type& x)
+    { list_base::push_back(x); } 
+    using list_base::insert;  
+    iterator insert(const_iterator position, const value_type& x)
+    { return list_base::insert(position,x); }
+    void insert(const_iterator position, size_type new_size, const value_type& x)
+    { list_base::insert(position, new_size, x); }
+#endif
+  };
+}
+
+#endif // check whether specialization is actually required
+
+#endif // EIGEN_STDLIST_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/StlSupport/StdVector.h b/C++/yolo_bytetrack/include/Eigen/src/StlSupport/StdVector.h
new file mode 100644
index 00000000..9fcf19bc
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/StlSupport/StdVector.h
@@ -0,0 +1,131 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDVECTOR_H
+#define EIGEN_STDVECTOR_H
+
+#include "details.h"
+
+/**
+ * This section contains a convenience MACRO which allows an easy specialization of
+ * std::vector such that for data types with alignment issues the correct allocator
+ * is used automatically.
+ */
+#define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...) \
+namespace std \
+{ \
+  template<> \
+  class vector<__VA_ARGS__, std::allocator<__VA_ARGS__> >  \
+    : public vector<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \
+  { \
+    typedef vector<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > vector_base; \
+  public: \
+    typedef __VA_ARGS__ value_type; \
+    typedef vector_base::allocator_type allocator_type; \
+    typedef vector_base::size_type size_type;  \
+    typedef vector_base::iterator iterator;  \
+    explicit vector(const allocator_type& a = allocator_type()) : vector_base(a) {}  \
+    template<typename InputIterator> \
+    vector(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : vector_base(first, last, a) {} \
+    vector(const vector& c) : vector_base(c) {}  \
+    explicit vector(size_type num, const value_type& val = value_type()) : vector_base(num, val) {} \
+    vector(iterator start_, iterator end_) : vector_base(start_, end_) {}  \
+    vector& operator=(const vector& x) {  \
+      vector_base::operator=(x);  \
+      return *this;  \
+    } \
+  }; \
+}
+
+// Don't specialize if containers are implemented according to C++11
+#if !EIGEN_HAS_CXX11_CONTAINERS
+
+namespace std {
+
+#define EIGEN_STD_VECTOR_SPECIALIZATION_BODY \
+  public:  \
+    typedef T value_type; \
+    typedef typename vector_base::allocator_type allocator_type; \
+    typedef typename vector_base::size_type size_type;  \
+    typedef typename vector_base::iterator iterator;  \
+    typedef typename vector_base::const_iterator const_iterator;  \
+    explicit vector(const allocator_type& a = allocator_type()) : vector_base(a) {}  \
+    template<typename InputIterator> \
+    vector(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
+    : vector_base(first, last, a) {} \
+    vector(const vector& c) : vector_base(c) {}  \
+    explicit vector(size_type num, const value_type& val = value_type()) : vector_base(num, val) {} \
+    vector(iterator start_, iterator end_) : vector_base(start_, end_) {}  \
+    vector& operator=(const vector& x) {  \
+      vector_base::operator=(x);  \
+      return *this;  \
+    }
+
+  template<typename T>
+  class vector<T,EIGEN_ALIGNED_ALLOCATOR<T> >
+    : public vector<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                    Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> >
+{
+  typedef vector<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                 Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > vector_base;
+  EIGEN_STD_VECTOR_SPECIALIZATION_BODY
+
+  void resize(size_type new_size)
+  { resize(new_size, T()); }
+
+#if defined(_VECTOR_)
+  // workaround MSVC std::vector implementation
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (vector_base::size() < new_size)
+      vector_base::_Insert_n(vector_base::end(), new_size - vector_base::size(), x);
+    else if (new_size < vector_base::size())
+      vector_base::erase(vector_base::begin() + new_size, vector_base::end());
+  }
+  void push_back(const value_type& x)
+  { vector_base::push_back(x); } 
+  using vector_base::insert;  
+  iterator insert(const_iterator position, const value_type& x)
+  { return vector_base::insert(position,x); }
+  void insert(const_iterator position, size_type new_size, const value_type& x)
+  { vector_base::insert(position, new_size, x); }
+#elif defined(_GLIBCXX_VECTOR) && (!(EIGEN_GNUC_AT_LEAST(4,1)))
+  /* Note that before gcc-4.1 we already have: std::vector::resize(size_type,const T&).
+   * However, this specialization is still needed to make the above EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION trick to work. */
+  void resize(size_type new_size, const value_type& x)
+  {
+    vector_base::resize(new_size,x);
+  }
+#elif defined(_GLIBCXX_VECTOR) && EIGEN_GNUC_AT_LEAST(4,2)
+  // workaround GCC std::vector implementation
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (new_size < vector_base::size())
+      vector_base::_M_erase_at_end(this->_M_impl._M_start + new_size);
+    else
+      vector_base::insert(vector_base::end(), new_size - vector_base::size(), x);
+  }
+#else
+  // either GCC 4.1 or non-GCC
+  // default implementation which should always work.
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (new_size < vector_base::size())
+      vector_base::erase(vector_base::begin() + new_size, vector_base::end());
+    else if (new_size > vector_base::size())
+      vector_base::insert(vector_base::end(), new_size - vector_base::size(), x);
+  }
+#endif
+  };
+}
+#endif // !EIGEN_HAS_CXX11_CONTAINERS
+
+
+#endif // EIGEN_STDVECTOR_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/StlSupport/details.h b/C++/yolo_bytetrack/include/Eigen/src/StlSupport/details.h
new file mode 100644
index 00000000..2cfd13e0
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/StlSupport/details.h
@@ -0,0 +1,84 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STL_DETAILS_H
+#define EIGEN_STL_DETAILS_H
+
+#ifndef EIGEN_ALIGNED_ALLOCATOR
+  #define EIGEN_ALIGNED_ALLOCATOR Eigen::aligned_allocator
+#endif
+
+namespace Eigen {
+
+  // This one is needed to prevent reimplementing the whole std::vector.
+  template <class T>
+  class aligned_allocator_indirection : public EIGEN_ALIGNED_ALLOCATOR<T>
+  {
+  public:
+    typedef std::size_t     size_type;
+    typedef std::ptrdiff_t  difference_type;
+    typedef T*              pointer;
+    typedef const T*        const_pointer;
+    typedef T&              reference;
+    typedef const T&        const_reference;
+    typedef T               value_type;
+
+    template<class U>
+    struct rebind
+    {
+      typedef aligned_allocator_indirection<U> other;
+    };
+
+    aligned_allocator_indirection() {}
+    aligned_allocator_indirection(const aligned_allocator_indirection& ) : EIGEN_ALIGNED_ALLOCATOR<T>() {}
+    aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<T>& ) {}
+    template<class U>
+    aligned_allocator_indirection(const aligned_allocator_indirection<U>& ) {}
+    template<class U>
+    aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<U>& ) {}
+    ~aligned_allocator_indirection() {}
+  };
+
+#if EIGEN_COMP_MSVC
+
+  // sometimes, MSVC detects, at compile time, that the argument x
+  // in std::vector::resize(size_t s,T x) won't be aligned and generate an error
+  // even if this function is never called. Whence this little wrapper.
+#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) \
+  typename Eigen::internal::conditional< \
+    Eigen::internal::is_arithmetic<T>::value, \
+    T, \
+    Eigen::internal::workaround_msvc_stl_support<T> \
+  >::type
+
+  namespace internal {
+  template<typename T> struct workaround_msvc_stl_support : public T
+  {
+    inline workaround_msvc_stl_support() : T() {}
+    inline workaround_msvc_stl_support(const T& other) : T(other) {}
+    inline operator T& () { return *static_cast<T*>(this); }
+    inline operator const T& () const { return *static_cast<const T*>(this); }
+    template<typename OtherT>
+    inline T& operator=(const OtherT& other)
+    { T::operator=(other); return *this; }
+    inline workaround_msvc_stl_support& operator=(const workaround_msvc_stl_support& other)
+    { T::operator=(other); return *this; }
+  };
+  }
+
+#else
+
+#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) T
+
+#endif
+
+}
+
+#endif // EIGEN_STL_DETAILS_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/SuperLUSupport/SuperLUSupport.h b/C++/yolo_bytetrack/include/Eigen/src/SuperLUSupport/SuperLUSupport.h
new file mode 100644
index 00000000..d1d3ad7f
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/SuperLUSupport/SuperLUSupport.h
@@ -0,0 +1,1025 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SUPERLUSUPPORT_H
+#define EIGEN_SUPERLUSUPPORT_H
+
+namespace Eigen {
+
+#if defined(SUPERLU_MAJOR_VERSION) && (SUPERLU_MAJOR_VERSION >= 5)
+#define DECL_GSSVX(PREFIX,FLOATTYPE,KEYTYPE)		\
+    extern "C" {                                                                                          \
+      extern void PREFIX##gssvx(superlu_options_t *, SuperMatrix *, int *, int *, int *,                  \
+                                char *, FLOATTYPE *, FLOATTYPE *, SuperMatrix *, SuperMatrix *,           \
+                                void *, int, SuperMatrix *, SuperMatrix *,                                \
+                                FLOATTYPE *, FLOATTYPE *, FLOATTYPE *, FLOATTYPE *,                       \
+                                GlobalLU_t *, mem_usage_t *, SuperLUStat_t *, int *);                     \
+    }                                                                                                     \
+    inline float SuperLU_gssvx(superlu_options_t *options, SuperMatrix *A,                                \
+         int *perm_c, int *perm_r, int *etree, char *equed,                                               \
+         FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L,                                                      \
+         SuperMatrix *U, void *work, int lwork,                                                           \
+         SuperMatrix *B, SuperMatrix *X,                                                                  \
+         FLOATTYPE *recip_pivot_growth,                                                                   \
+         FLOATTYPE *rcond, FLOATTYPE *ferr, FLOATTYPE *berr,                                              \
+         SuperLUStat_t *stats, int *info, KEYTYPE) {                                                      \
+    mem_usage_t mem_usage;                                                                                \
+    GlobalLU_t gLU;                                                                                       \
+    PREFIX##gssvx(options, A, perm_c, perm_r, etree, equed, R, C, L,                                      \
+         U, work, lwork, B, X, recip_pivot_growth, rcond,                                                 \
+         ferr, berr, &gLU, &mem_usage, stats, info);                                                      \
+    return mem_usage.for_lu; /* bytes used by the factor storage */                                       \
+  }
+#else // version < 5.0
+#define DECL_GSSVX(PREFIX,FLOATTYPE,KEYTYPE)		\
+    extern "C" {                                                                                          \
+      extern void PREFIX##gssvx(superlu_options_t *, SuperMatrix *, int *, int *, int *,                  \
+                                char *, FLOATTYPE *, FLOATTYPE *, SuperMatrix *, SuperMatrix *,           \
+                                void *, int, SuperMatrix *, SuperMatrix *,                                \
+                                FLOATTYPE *, FLOATTYPE *, FLOATTYPE *, FLOATTYPE *,                       \
+                                mem_usage_t *, SuperLUStat_t *, int *);                                   \
+    }                                                                                                     \
+    inline float SuperLU_gssvx(superlu_options_t *options, SuperMatrix *A,                                \
+         int *perm_c, int *perm_r, int *etree, char *equed,                                               \
+         FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L,                                                      \
+         SuperMatrix *U, void *work, int lwork,                                                           \
+         SuperMatrix *B, SuperMatrix *X,                                                                  \
+         FLOATTYPE *recip_pivot_growth,                                                                   \
+         FLOATTYPE *rcond, FLOATTYPE *ferr, FLOATTYPE *berr,                                              \
+         SuperLUStat_t *stats, int *info, KEYTYPE) {                                                      \
+    mem_usage_t mem_usage;                                                                                \
+    PREFIX##gssvx(options, A, perm_c, perm_r, etree, equed, R, C, L,                                      \
+         U, work, lwork, B, X, recip_pivot_growth, rcond,                                                 \
+         ferr, berr, &mem_usage, stats, info);                                                            \
+    return mem_usage.for_lu; /* bytes used by the factor storage */                                       \
+  }
+#endif
+
+DECL_GSSVX(s,float,float)
+DECL_GSSVX(c,float,std::complex<float>)
+DECL_GSSVX(d,double,double)
+DECL_GSSVX(z,double,std::complex<double>)
+
+#ifdef MILU_ALPHA
+#define EIGEN_SUPERLU_HAS_ILU
+#endif
+
+#ifdef EIGEN_SUPERLU_HAS_ILU
+
+// similarly for the incomplete factorization using gsisx
+#define DECL_GSISX(PREFIX,FLOATTYPE,KEYTYPE)                                                    \
+    extern "C" {                                                                                \
+      extern void PREFIX##gsisx(superlu_options_t *, SuperMatrix *, int *, int *, int *,        \
+                         char *, FLOATTYPE *, FLOATTYPE *, SuperMatrix *, SuperMatrix *,        \
+                         void *, int, SuperMatrix *, SuperMatrix *, FLOATTYPE *, FLOATTYPE *,   \
+                         mem_usage_t *, SuperLUStat_t *, int *);                        \
+    }                                                                                           \
+    inline float SuperLU_gsisx(superlu_options_t *options, SuperMatrix *A,                      \
+         int *perm_c, int *perm_r, int *etree, char *equed,                                     \
+         FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L,                                            \
+         SuperMatrix *U, void *work, int lwork,                                                 \
+         SuperMatrix *B, SuperMatrix *X,                                                        \
+         FLOATTYPE *recip_pivot_growth,                                                         \
+         FLOATTYPE *rcond,                                                                      \
+         SuperLUStat_t *stats, int *info, KEYTYPE) {                                            \
+    mem_usage_t mem_usage;                                                              \
+    PREFIX##gsisx(options, A, perm_c, perm_r, etree, equed, R, C, L,                            \
+         U, work, lwork, B, X, recip_pivot_growth, rcond,                                       \
+         &mem_usage, stats, info);                                                              \
+    return mem_usage.for_lu; /* bytes used by the factor storage */                             \
+  }
+
+DECL_GSISX(s,float,float)
+DECL_GSISX(c,float,std::complex<float>)
+DECL_GSISX(d,double,double)
+DECL_GSISX(z,double,std::complex<double>)
+
+#endif
+
+template<typename MatrixType>
+struct SluMatrixMapHelper;
+
+/** \internal
+  *
+  * A wrapper class for SuperLU matrices. It supports only compressed sparse matrices
+  * and dense matrices. Supernodal and other fancy format are not supported by this wrapper.
+  *
+  * This wrapper class mainly aims to avoids the need of dynamic allocation of the storage structure.
+  */
+struct SluMatrix : SuperMatrix
+{
+  SluMatrix()
+  {
+    Store = &storage;
+  }
+
+  SluMatrix(const SluMatrix& other)
+    : SuperMatrix(other)
+  {
+    Store = &storage;
+    storage = other.storage;
+  }
+
+  SluMatrix& operator=(const SluMatrix& other)
+  {
+    SuperMatrix::operator=(static_cast<const SuperMatrix&>(other));
+    Store = &storage;
+    storage = other.storage;
+    return *this;
+  }
+
+  struct
+  {
+    union {int nnz;int lda;};
+    void *values;
+    int *innerInd;
+    int *outerInd;
+  } storage;
+
+  void setStorageType(Stype_t t)
+  {
+    Stype = t;
+    if (t==SLU_NC || t==SLU_NR || t==SLU_DN)
+      Store = &storage;
+    else
+    {
+      eigen_assert(false && "storage type not supported");
+      Store = 0;
+    }
+  }
+
+  template<typename Scalar>
+  void setScalarType()
+  {
+    if (internal::is_same<Scalar,float>::value)
+      Dtype = SLU_S;
+    else if (internal::is_same<Scalar,double>::value)
+      Dtype = SLU_D;
+    else if (internal::is_same<Scalar,std::complex<float> >::value)
+      Dtype = SLU_C;
+    else if (internal::is_same<Scalar,std::complex<double> >::value)
+      Dtype = SLU_Z;
+    else
+    {
+      eigen_assert(false && "Scalar type not supported by SuperLU");
+    }
+  }
+
+  template<typename MatrixType>
+  static SluMatrix Map(MatrixBase<MatrixType>& _mat)
+  {
+    MatrixType& mat(_mat.derived());
+    eigen_assert( ((MatrixType::Flags&RowMajorBit)!=RowMajorBit) && "row-major dense matrices are not supported by SuperLU");
+    SluMatrix res;
+    res.setStorageType(SLU_DN);
+    res.setScalarType<typename MatrixType::Scalar>();
+    res.Mtype     = SLU_GE;
+
+    res.nrow      = internal::convert_index<int>(mat.rows());
+    res.ncol      = internal::convert_index<int>(mat.cols());
+
+    res.storage.lda       = internal::convert_index<int>(MatrixType::IsVectorAtCompileTime ? mat.size() : mat.outerStride());
+    res.storage.values    = (void*)(mat.data());
+    return res;
+  }
+
+  template<typename MatrixType>
+  static SluMatrix Map(SparseMatrixBase<MatrixType>& a_mat)
+  {
+    MatrixType &mat(a_mat.derived());
+    SluMatrix res;
+    if ((MatrixType::Flags&RowMajorBit)==RowMajorBit)
+    {
+      res.setStorageType(SLU_NR);
+      res.nrow      = internal::convert_index<int>(mat.cols());
+      res.ncol      = internal::convert_index<int>(mat.rows());
+    }
+    else
+    {
+      res.setStorageType(SLU_NC);
+      res.nrow      = internal::convert_index<int>(mat.rows());
+      res.ncol      = internal::convert_index<int>(mat.cols());
+    }
+
+    res.Mtype       = SLU_GE;
+
+    res.storage.nnz       = internal::convert_index<int>(mat.nonZeros());
+    res.storage.values    = mat.valuePtr();
+    res.storage.innerInd  = mat.innerIndexPtr();
+    res.storage.outerInd  = mat.outerIndexPtr();
+
+    res.setScalarType<typename MatrixType::Scalar>();
+
+    // FIXME the following is not very accurate
+    if (int(MatrixType::Flags) & int(Upper))
+      res.Mtype = SLU_TRU;
+    if (int(MatrixType::Flags) & int(Lower))
+      res.Mtype = SLU_TRL;
+
+    eigen_assert(((int(MatrixType::Flags) & int(SelfAdjoint))==0) && "SelfAdjoint matrix shape not supported by SuperLU");
+
+    return res;
+  }
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MRows, int MCols>
+struct SluMatrixMapHelper<Matrix<Scalar,Rows,Cols,Options,MRows,MCols> >
+{
+  typedef Matrix<Scalar,Rows,Cols,Options,MRows,MCols> MatrixType;
+  static void run(MatrixType& mat, SluMatrix& res)
+  {
+    eigen_assert( ((Options&RowMajor)!=RowMajor) && "row-major dense matrices is not supported by SuperLU");
+    res.setStorageType(SLU_DN);
+    res.setScalarType<Scalar>();
+    res.Mtype     = SLU_GE;
+
+    res.nrow      = mat.rows();
+    res.ncol      = mat.cols();
+
+    res.storage.lda       = mat.outerStride();
+    res.storage.values    = mat.data();
+  }
+};
+
+template<typename Derived>
+struct SluMatrixMapHelper<SparseMatrixBase<Derived> >
+{
+  typedef Derived MatrixType;
+  static void run(MatrixType& mat, SluMatrix& res)
+  {
+    if ((MatrixType::Flags&RowMajorBit)==RowMajorBit)
+    {
+      res.setStorageType(SLU_NR);
+      res.nrow      = mat.cols();
+      res.ncol      = mat.rows();
+    }
+    else
+    {
+      res.setStorageType(SLU_NC);
+      res.nrow      = mat.rows();
+      res.ncol      = mat.cols();
+    }
+
+    res.Mtype       = SLU_GE;
+
+    res.storage.nnz       = mat.nonZeros();
+    res.storage.values    = mat.valuePtr();
+    res.storage.innerInd  = mat.innerIndexPtr();
+    res.storage.outerInd  = mat.outerIndexPtr();
+
+    res.setScalarType<typename MatrixType::Scalar>();
+
+    // FIXME the following is not very accurate
+    if (MatrixType::Flags & Upper)
+      res.Mtype = SLU_TRU;
+    if (MatrixType::Flags & Lower)
+      res.Mtype = SLU_TRL;
+
+    eigen_assert(((MatrixType::Flags & SelfAdjoint)==0) && "SelfAdjoint matrix shape not supported by SuperLU");
+  }
+};
+
+namespace internal {
+
+template<typename MatrixType>
+SluMatrix asSluMatrix(MatrixType& mat)
+{
+  return SluMatrix::Map(mat);
+}
+
+/** View a Super LU matrix as an Eigen expression */
+template<typename Scalar, int Flags, typename Index>
+MappedSparseMatrix<Scalar,Flags,Index> map_superlu(SluMatrix& sluMat)
+{
+  eigen_assert(((Flags&RowMajor)==RowMajor && sluMat.Stype == SLU_NR)
+         || ((Flags&ColMajor)==ColMajor && sluMat.Stype == SLU_NC));
+
+  Index outerSize = (Flags&RowMajor)==RowMajor ? sluMat.ncol : sluMat.nrow;
+
+  return MappedSparseMatrix<Scalar,Flags,Index>(
+    sluMat.nrow, sluMat.ncol, sluMat.storage.outerInd[outerSize],
+    sluMat.storage.outerInd, sluMat.storage.innerInd, reinterpret_cast<Scalar*>(sluMat.storage.values) );
+}
+
+} // end namespace internal
+
+/** \ingroup SuperLUSupport_Module
+  * \class SuperLUBase
+  * \brief The base class for the direct and incomplete LU factorization of SuperLU
+  */
+template<typename _MatrixType, typename Derived>
+class SuperLUBase : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+  public:
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;    
+    typedef Map<PermutationMatrix<Dynamic,Dynamic,int> > PermutationMap;
+    typedef SparseMatrix<Scalar> LUMatrixType;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    SuperLUBase() {}
+
+    ~SuperLUBase()
+    {
+      clearFactors();
+    }
+    
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+    
+    /** \returns a reference to the Super LU option object to configure the  Super LU algorithms. */
+    inline superlu_options_t& options() { return m_sluOptions; }
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    void compute(const MatrixType& matrix)
+    {
+      derived().analyzePattern(matrix);
+      derived().factorize(matrix);
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& /*matrix*/)
+    {
+      m_isInitialized = true;
+      m_info = Success;
+      m_analysisIsOk = true;
+      m_factorizationIsOk = false;
+    }
+    
+    template<typename Stream>
+    void dumpMemory(Stream& /*s*/)
+    {}
+    
+  protected:
+    
+    void initFactorization(const MatrixType& a)
+    {
+      set_default_options(&this->m_sluOptions);
+      
+      const Index size = a.rows();
+      m_matrix = a;
+
+      m_sluA = internal::asSluMatrix(m_matrix);
+      clearFactors();
+
+      m_p.resize(size);
+      m_q.resize(size);
+      m_sluRscale.resize(size);
+      m_sluCscale.resize(size);
+      m_sluEtree.resize(size);
+
+      // set empty B and X
+      m_sluB.setStorageType(SLU_DN);
+      m_sluB.setScalarType<Scalar>();
+      m_sluB.Mtype          = SLU_GE;
+      m_sluB.storage.values = 0;
+      m_sluB.nrow           = 0;
+      m_sluB.ncol           = 0;
+      m_sluB.storage.lda    = internal::convert_index<int>(size);
+      m_sluX                = m_sluB;
+      
+      m_extractedDataAreDirty = true;
+    }
+    
+    void init()
+    {
+      m_info = InvalidInput;
+      m_isInitialized = false;
+      m_sluL.Store = 0;
+      m_sluU.Store = 0;
+    }
+    
+    void extractData() const;
+
+    void clearFactors()
+    {
+      if(m_sluL.Store)
+        Destroy_SuperNode_Matrix(&m_sluL);
+      if(m_sluU.Store)
+        Destroy_CompCol_Matrix(&m_sluU);
+
+      m_sluL.Store = 0;
+      m_sluU.Store = 0;
+
+      memset(&m_sluL,0,sizeof m_sluL);
+      memset(&m_sluU,0,sizeof m_sluU);
+    }
+
+    // cached data to reduce reallocation, etc.
+    mutable LUMatrixType m_l;
+    mutable LUMatrixType m_u;
+    mutable IntColVectorType m_p;
+    mutable IntRowVectorType m_q;
+
+    mutable LUMatrixType m_matrix;  // copy of the factorized matrix
+    mutable SluMatrix m_sluA;
+    mutable SuperMatrix m_sluL, m_sluU;
+    mutable SluMatrix m_sluB, m_sluX;
+    mutable SuperLUStat_t m_sluStat;
+    mutable superlu_options_t m_sluOptions;
+    mutable std::vector<int> m_sluEtree;
+    mutable Matrix<RealScalar,Dynamic,1> m_sluRscale, m_sluCscale;
+    mutable Matrix<RealScalar,Dynamic,1> m_sluFerr, m_sluBerr;
+    mutable char m_sluEqued;
+
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+    mutable bool m_extractedDataAreDirty;
+    
+  private:
+    SuperLUBase(SuperLUBase& ) { }
+};
+
+
+/** \ingroup SuperLUSupport_Module
+  * \class SuperLU
+  * \brief A sparse direct LU factorization and solver based on the SuperLU library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a direct LU factorization
+  * using the SuperLU library. The sparse matrix A must be squared and invertible. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \warning This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  */
+template<typename _MatrixType>
+class SuperLU : public SuperLUBase<_MatrixType,SuperLU<_MatrixType> >
+{
+  public:
+    typedef SuperLUBase<_MatrixType,SuperLU> Base;
+    typedef _MatrixType MatrixType;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    typedef typename Base::IntRowVectorType IntRowVectorType;
+    typedef typename Base::IntColVectorType IntColVectorType;   
+    typedef typename Base::PermutationMap PermutationMap;
+    typedef typename Base::LUMatrixType LUMatrixType;
+    typedef TriangularView<LUMatrixType, Lower|UnitDiag>  LMatrixType;
+    typedef TriangularView<LUMatrixType,  Upper>          UMatrixType;
+
+  public:
+    using Base::_solve_impl;
+
+    SuperLU() : Base() { init(); }
+
+    explicit SuperLU(const MatrixType& matrix) : Base()
+    {
+      init();
+      Base::compute(matrix);
+    }
+
+    ~SuperLU()
+    {
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      m_info = InvalidInput;
+      m_isInitialized = false;
+      Base::analyzePattern(matrix);
+    }
+    
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& matrix);
+    
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
+    
+    inline const LMatrixType& matrixL() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_l;
+    }
+
+    inline const UMatrixType& matrixU() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_u;
+    }
+
+    inline const IntColVectorType& permutationP() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_p;
+    }
+
+    inline const IntRowVectorType& permutationQ() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_q;
+    }
+    
+    Scalar determinant() const;
+    
+  protected:
+    
+    using Base::m_matrix;
+    using Base::m_sluOptions;
+    using Base::m_sluA;
+    using Base::m_sluB;
+    using Base::m_sluX;
+    using Base::m_p;
+    using Base::m_q;
+    using Base::m_sluEtree;
+    using Base::m_sluEqued;
+    using Base::m_sluRscale;
+    using Base::m_sluCscale;
+    using Base::m_sluL;
+    using Base::m_sluU;
+    using Base::m_sluStat;
+    using Base::m_sluFerr;
+    using Base::m_sluBerr;
+    using Base::m_l;
+    using Base::m_u;
+    
+    using Base::m_analysisIsOk;
+    using Base::m_factorizationIsOk;
+    using Base::m_extractedDataAreDirty;
+    using Base::m_isInitialized;
+    using Base::m_info;
+    
+    void init()
+    {
+      Base::init();
+      
+      set_default_options(&this->m_sluOptions);
+      m_sluOptions.PrintStat        = NO;
+      m_sluOptions.ConditionNumber  = NO;
+      m_sluOptions.Trans            = NOTRANS;
+      m_sluOptions.ColPerm          = COLAMD;
+    }
+    
+    
+  private:
+    SuperLU(SuperLU& ) { }
+};
+
+template<typename MatrixType>
+void SuperLU<MatrixType>::factorize(const MatrixType& a)
+{
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  if(!m_analysisIsOk)
+  {
+    m_info = InvalidInput;
+    return;
+  }
+  
+  this->initFactorization(a);
+  
+  m_sluOptions.ColPerm = COLAMD;
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+  RealScalar ferr, berr;
+
+  StatInit(&m_sluStat);
+  SuperLU_gssvx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0],
+                &m_sluEqued, &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &ferr, &berr,
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+
+  m_extractedDataAreDirty = true;
+
+  // FIXME how to better check for errors ???
+  m_info = info == 0 ? Success : NumericalIssue;
+  m_factorizationIsOk = true;
+}
+
+template<typename MatrixType>
+template<typename Rhs,typename Dest>
+void SuperLU<MatrixType>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest>& x) const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or analyzePattern()/factorize()");
+
+  const Index rhsCols = b.cols();
+  eigen_assert(m_matrix.rows()==b.rows());
+
+  m_sluOptions.Trans = NOTRANS;
+  m_sluOptions.Fact = FACTORED;
+  m_sluOptions.IterRefine = NOREFINE;
+  
+
+  m_sluFerr.resize(rhsCols);
+  m_sluBerr.resize(rhsCols);
+  
+  Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b);
+  Ref<const Matrix<typename Dest::Scalar,Dynamic,Dynamic,ColMajor> > x_ref(x);
+  
+  m_sluB = SluMatrix::Map(b_ref.const_cast_derived());
+  m_sluX = SluMatrix::Map(x_ref.const_cast_derived());
+  
+  typename Rhs::PlainObject b_cpy;
+  if(m_sluEqued!='N')
+  {
+    b_cpy = b;
+    m_sluB = SluMatrix::Map(b_cpy.const_cast_derived());  
+  }
+
+  StatInit(&m_sluStat);
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+  SuperLU_gssvx(&m_sluOptions, &m_sluA,
+                m_q.data(), m_p.data(),
+                &m_sluEtree[0], &m_sluEqued,
+                &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &m_sluFerr[0], &m_sluBerr[0],
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+  
+  if(x.derived().data() != x_ref.data())
+    x = x_ref;
+  
+  m_info = info==0 ? Success : NumericalIssue;
+}
+
+// the code of this extractData() function has been adapted from the SuperLU's Matlab support code,
+//
+//  Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+//
+//  THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+//  EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+//
+template<typename MatrixType, typename Derived>
+void SuperLUBase<MatrixType,Derived>::extractData() const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for extracting factors, you must first call either compute() or analyzePattern()/factorize()");
+  if (m_extractedDataAreDirty)
+  {
+    int         upper;
+    int         fsupc, istart, nsupr;
+    int         lastl = 0, lastu = 0;
+    SCformat    *Lstore = static_cast<SCformat*>(m_sluL.Store);
+    NCformat    *Ustore = static_cast<NCformat*>(m_sluU.Store);
+    Scalar      *SNptr;
+
+    const Index size = m_matrix.rows();
+    m_l.resize(size,size);
+    m_l.resizeNonZeros(Lstore->nnz);
+    m_u.resize(size,size);
+    m_u.resizeNonZeros(Ustore->nnz);
+
+    int* Lcol = m_l.outerIndexPtr();
+    int* Lrow = m_l.innerIndexPtr();
+    Scalar* Lval = m_l.valuePtr();
+
+    int* Ucol = m_u.outerIndexPtr();
+    int* Urow = m_u.innerIndexPtr();
+    Scalar* Uval = m_u.valuePtr();
+
+    Ucol[0] = 0;
+    Ucol[0] = 0;
+
+    /* for each supernode */
+    for (int k = 0; k <= Lstore->nsuper; ++k)
+    {
+      fsupc   = L_FST_SUPC(k);
+      istart  = L_SUB_START(fsupc);
+      nsupr   = L_SUB_START(fsupc+1) - istart;
+      upper   = 1;
+
+      /* for each column in the supernode */
+      for (int j = fsupc; j < L_FST_SUPC(k+1); ++j)
+      {
+        SNptr = &((Scalar*)Lstore->nzval)[L_NZ_START(j)];
+
+        /* Extract U */
+        for (int i = U_NZ_START(j); i < U_NZ_START(j+1); ++i)
+        {
+          Uval[lastu] = ((Scalar*)Ustore->nzval)[i];
+          /* Matlab doesn't like explicit zero. */
+          if (Uval[lastu] != 0.0)
+            Urow[lastu++] = U_SUB(i);
+        }
+        for (int i = 0; i < upper; ++i)
+        {
+          /* upper triangle in the supernode */
+          Uval[lastu] = SNptr[i];
+          /* Matlab doesn't like explicit zero. */
+          if (Uval[lastu] != 0.0)
+            Urow[lastu++] = L_SUB(istart+i);
+        }
+        Ucol[j+1] = lastu;
+
+        /* Extract L */
+        Lval[lastl] = 1.0; /* unit diagonal */
+        Lrow[lastl++] = L_SUB(istart + upper - 1);
+        for (int i = upper; i < nsupr; ++i)
+        {
+          Lval[lastl] = SNptr[i];
+          /* Matlab doesn't like explicit zero. */
+          if (Lval[lastl] != 0.0)
+            Lrow[lastl++] = L_SUB(istart+i);
+        }
+        Lcol[j+1] = lastl;
+
+        ++upper;
+      } /* for j ... */
+
+    } /* for k ... */
+
+    // squeeze the matrices :
+    m_l.resizeNonZeros(lastl);
+    m_u.resizeNonZeros(lastu);
+
+    m_extractedDataAreDirty = false;
+  }
+}
+
+template<typename MatrixType>
+typename SuperLU<MatrixType>::Scalar SuperLU<MatrixType>::determinant() const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for computing the determinant, you must first call either compute() or analyzePattern()/factorize()");
+  
+  if (m_extractedDataAreDirty)
+    this->extractData();
+
+  Scalar det = Scalar(1);
+  for (int j=0; j<m_u.cols(); ++j)
+  {
+    if (m_u.outerIndexPtr()[j+1]-m_u.outerIndexPtr()[j] > 0)
+    {
+      int lastId = m_u.outerIndexPtr()[j+1]-1;
+      eigen_assert(m_u.innerIndexPtr()[lastId]<=j);
+      if (m_u.innerIndexPtr()[lastId]==j)
+        det *= m_u.valuePtr()[lastId];
+    }
+  }
+  if(PermutationMap(m_p.data(),m_p.size()).determinant()*PermutationMap(m_q.data(),m_q.size()).determinant()<0)
+    det = -det;
+  if(m_sluEqued!='N')
+    return det/m_sluRscale.prod()/m_sluCscale.prod();
+  else
+    return det;
+}
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+#define EIGEN_SUPERLU_HAS_ILU
+#endif
+
+#ifdef EIGEN_SUPERLU_HAS_ILU
+
+/** \ingroup SuperLUSupport_Module
+  * \class SuperILU
+  * \brief A sparse direct \b incomplete LU factorization and solver based on the SuperLU library
+  *
+  * This class allows to solve for an approximate solution of A.X = B sparse linear problems via an incomplete LU factorization
+  * using the SuperLU library. This class is aimed to be used as a preconditioner of the iterative linear solvers.
+  *
+  * \warning This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class IncompleteLUT, class ConjugateGradient, class BiCGSTAB
+  */
+
+template<typename _MatrixType>
+class SuperILU : public SuperLUBase<_MatrixType,SuperILU<_MatrixType> >
+{
+  public:
+    typedef SuperLUBase<_MatrixType,SuperILU> Base;
+    typedef _MatrixType MatrixType;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+
+  public:
+    using Base::_solve_impl;
+
+    SuperILU() : Base() { init(); }
+
+    SuperILU(const MatrixType& matrix) : Base()
+    {
+      init();
+      Base::compute(matrix);
+    }
+
+    ~SuperILU()
+    {
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      Base::analyzePattern(matrix);
+    }
+    
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& matrix);
+    
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+    
+  protected:
+    
+    using Base::m_matrix;
+    using Base::m_sluOptions;
+    using Base::m_sluA;
+    using Base::m_sluB;
+    using Base::m_sluX;
+    using Base::m_p;
+    using Base::m_q;
+    using Base::m_sluEtree;
+    using Base::m_sluEqued;
+    using Base::m_sluRscale;
+    using Base::m_sluCscale;
+    using Base::m_sluL;
+    using Base::m_sluU;
+    using Base::m_sluStat;
+    using Base::m_sluFerr;
+    using Base::m_sluBerr;
+    using Base::m_l;
+    using Base::m_u;
+    
+    using Base::m_analysisIsOk;
+    using Base::m_factorizationIsOk;
+    using Base::m_extractedDataAreDirty;
+    using Base::m_isInitialized;
+    using Base::m_info;
+
+    void init()
+    {
+      Base::init();
+      
+      ilu_set_default_options(&m_sluOptions);
+      m_sluOptions.PrintStat        = NO;
+      m_sluOptions.ConditionNumber  = NO;
+      m_sluOptions.Trans            = NOTRANS;
+      m_sluOptions.ColPerm          = MMD_AT_PLUS_A;
+      
+      // no attempt to preserve column sum
+      m_sluOptions.ILU_MILU = SILU;
+      // only basic ILU(k) support -- no direct control over memory consumption
+      // better to use ILU_DropRule = DROP_BASIC | DROP_AREA
+      // and set ILU_FillFactor to max memory growth
+      m_sluOptions.ILU_DropRule = DROP_BASIC;
+      m_sluOptions.ILU_DropTol = NumTraits<Scalar>::dummy_precision()*10;
+    }
+    
+  private:
+    SuperILU(SuperILU& ) { }
+};
+
+template<typename MatrixType>
+void SuperILU<MatrixType>::factorize(const MatrixType& a)
+{
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  if(!m_analysisIsOk)
+  {
+    m_info = InvalidInput;
+    return;
+  }
+  
+  this->initFactorization(a);
+
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+
+  StatInit(&m_sluStat);
+  SuperLU_gsisx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0],
+                &m_sluEqued, &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+
+  // FIXME how to better check for errors ???
+  m_info = info == 0 ? Success : NumericalIssue;
+  m_factorizationIsOk = true;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatrixType>
+template<typename Rhs,typename Dest>
+void SuperILU<MatrixType>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest>& x) const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or analyzePattern()/factorize()");
+
+  const int rhsCols = b.cols();
+  eigen_assert(m_matrix.rows()==b.rows());
+
+  m_sluOptions.Trans = NOTRANS;
+  m_sluOptions.Fact = FACTORED;
+  m_sluOptions.IterRefine = NOREFINE;
+
+  m_sluFerr.resize(rhsCols);
+  m_sluBerr.resize(rhsCols);
+  
+  Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b);
+  Ref<const Matrix<typename Dest::Scalar,Dynamic,Dynamic,ColMajor> > x_ref(x);
+  
+  m_sluB = SluMatrix::Map(b_ref.const_cast_derived());
+  m_sluX = SluMatrix::Map(x_ref.const_cast_derived());
+
+  typename Rhs::PlainObject b_cpy;
+  if(m_sluEqued!='N')
+  {
+    b_cpy = b;
+    m_sluB = SluMatrix::Map(b_cpy.const_cast_derived());  
+  }
+  
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+
+  StatInit(&m_sluStat);
+  SuperLU_gsisx(&m_sluOptions, &m_sluA,
+                m_q.data(), m_p.data(),
+                &m_sluEtree[0], &m_sluEqued,
+                &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+  
+  if(x.derived().data() != x_ref.data())
+    x = x_ref;
+
+  m_info = info==0 ? Success : NumericalIssue;
+}
+#endif
+
+#endif
+
+} // end namespace Eigen
+
+#endif // EIGEN_SUPERLUSUPPORT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/UmfPackSupport/UmfPackSupport.h b/C++/yolo_bytetrack/include/Eigen/src/UmfPackSupport/UmfPackSupport.h
new file mode 100644
index 00000000..e3a333f8
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/UmfPackSupport/UmfPackSupport.h
@@ -0,0 +1,642 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UMFPACKSUPPORT_H
+#define EIGEN_UMFPACKSUPPORT_H
+
+// for compatibility with super old version of umfpack,
+// not sure this is really needed, but this is harmless.
+#ifndef SuiteSparse_long
+#ifdef UF_long
+#define SuiteSparse_long UF_long
+#else
+#error neither SuiteSparse_long nor UF_long are defined
+#endif
+#endif
+
+namespace Eigen {
+
+/* TODO extract L, extract U, compute det, etc... */
+
+// generic double/complex<double> wrapper functions:
+
+
+ // Defaults
+inline void umfpack_defaults(double control[UMFPACK_CONTROL], double, int)
+{ umfpack_di_defaults(control); }
+
+inline void umfpack_defaults(double control[UMFPACK_CONTROL], std::complex<double>, int)
+{ umfpack_zi_defaults(control); }
+
+inline void umfpack_defaults(double control[UMFPACK_CONTROL], double, SuiteSparse_long)
+{ umfpack_dl_defaults(control); }
+
+inline void umfpack_defaults(double control[UMFPACK_CONTROL], std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_defaults(control); }
+
+// Report info
+inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, int)
+{ umfpack_di_report_info(control, info);}
+
+inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex<double>, int)
+{ umfpack_zi_report_info(control, info);}
+
+inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, SuiteSparse_long)
+{ umfpack_dl_report_info(control, info);}
+
+inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_report_info(control, info);}
+
+// Report status
+inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, double, int)
+{ umfpack_di_report_status(control, status);}
+
+inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, std::complex<double>, int)
+{ umfpack_zi_report_status(control, status);}
+
+inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, double, SuiteSparse_long)
+{ umfpack_dl_report_status(control, status);}
+
+inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_report_status(control, status);}
+
+// report control
+inline void umfpack_report_control(double control[UMFPACK_CONTROL], double, int)
+{ umfpack_di_report_control(control);}
+
+inline void umfpack_report_control(double control[UMFPACK_CONTROL], std::complex<double>, int)
+{ umfpack_zi_report_control(control);}
+
+inline void umfpack_report_control(double control[UMFPACK_CONTROL], double, SuiteSparse_long)
+{ umfpack_dl_report_control(control);}
+
+inline void umfpack_report_control(double control[UMFPACK_CONTROL], std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_report_control(control);}
+
+// Free numeric
+inline void umfpack_free_numeric(void **Numeric, double, int)
+{ umfpack_di_free_numeric(Numeric); *Numeric = 0; }
+
+inline void umfpack_free_numeric(void **Numeric, std::complex<double>, int)
+{ umfpack_zi_free_numeric(Numeric); *Numeric = 0; }
+
+inline void umfpack_free_numeric(void **Numeric, double, SuiteSparse_long)
+{ umfpack_dl_free_numeric(Numeric); *Numeric = 0; }
+
+inline void umfpack_free_numeric(void **Numeric, std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_free_numeric(Numeric); *Numeric = 0; }
+
+// Free symbolic
+inline void umfpack_free_symbolic(void **Symbolic, double, int)
+{ umfpack_di_free_symbolic(Symbolic); *Symbolic = 0; }
+
+inline void umfpack_free_symbolic(void **Symbolic, std::complex<double>, int)
+{ umfpack_zi_free_symbolic(Symbolic); *Symbolic = 0; }
+
+inline void umfpack_free_symbolic(void **Symbolic, double, SuiteSparse_long)
+{ umfpack_dl_free_symbolic(Symbolic); *Symbolic = 0; }
+
+inline void umfpack_free_symbolic(void **Symbolic, std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_free_symbolic(Symbolic); *Symbolic = 0; }
+
+// Symbolic
+inline int umfpack_symbolic(int n_row,int n_col,
+                            const int Ap[], const int Ai[], const double Ax[], void **Symbolic,
+                            const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
+{
+  return umfpack_di_symbolic(n_row,n_col,Ap,Ai,Ax,Symbolic,Control,Info);
+}
+
+inline int umfpack_symbolic(int n_row,int n_col,
+                            const int Ap[], const int Ai[], const std::complex<double> Ax[], void **Symbolic,
+                            const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
+{
+  return umfpack_zi_symbolic(n_row,n_col,Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Control,Info);
+}
+inline SuiteSparse_long umfpack_symbolic( SuiteSparse_long n_row,SuiteSparse_long n_col,
+                                          const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], void **Symbolic,
+                                          const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
+{
+  return umfpack_dl_symbolic(n_row,n_col,Ap,Ai,Ax,Symbolic,Control,Info);
+}
+
+inline SuiteSparse_long umfpack_symbolic( SuiteSparse_long n_row,SuiteSparse_long n_col,
+                                          const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex<double> Ax[], void **Symbolic,
+                                          const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
+{
+  return umfpack_zl_symbolic(n_row,n_col,Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Control,Info);
+}
+
+// Numeric
+inline int umfpack_numeric( const int Ap[], const int Ai[], const double Ax[],
+                            void *Symbolic, void **Numeric,
+                            const double Control[UMFPACK_CONTROL],double Info [UMFPACK_INFO])
+{
+  return umfpack_di_numeric(Ap,Ai,Ax,Symbolic,Numeric,Control,Info);
+}
+
+inline int umfpack_numeric( const int Ap[], const int Ai[], const std::complex<double> Ax[],
+                            void *Symbolic, void **Numeric,
+                            const double Control[UMFPACK_CONTROL],double Info [UMFPACK_INFO])
+{
+  return umfpack_zi_numeric(Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Numeric,Control,Info);
+}
+inline SuiteSparse_long umfpack_numeric(const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[],
+                                        void *Symbolic, void **Numeric,
+                                        const double Control[UMFPACK_CONTROL],double Info [UMFPACK_INFO])
+{
+  return umfpack_dl_numeric(Ap,Ai,Ax,Symbolic,Numeric,Control,Info);
+}
+
+inline SuiteSparse_long umfpack_numeric(const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex<double> Ax[],
+                                        void *Symbolic, void **Numeric,
+                                        const double Control[UMFPACK_CONTROL],double Info [UMFPACK_INFO])
+{
+  return umfpack_zl_numeric(Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Numeric,Control,Info);
+}
+
+// solve
+inline int umfpack_solve( int sys, const int Ap[], const int Ai[], const double Ax[],
+                          double X[], const double B[], void *Numeric,
+                          const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
+{
+  return umfpack_di_solve(sys,Ap,Ai,Ax,X,B,Numeric,Control,Info);
+}
+
+inline int umfpack_solve( int sys, const int Ap[], const int Ai[], const std::complex<double> Ax[],
+                          std::complex<double> X[], const std::complex<double> B[], void *Numeric,
+                          const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
+{
+  return umfpack_zi_solve(sys,Ap,Ai,&numext::real_ref(Ax[0]),0,&numext::real_ref(X[0]),0,&numext::real_ref(B[0]),0,Numeric,Control,Info);
+}
+
+inline SuiteSparse_long umfpack_solve(int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[],
+                                      double X[], const double B[], void *Numeric,
+                                      const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
+{
+  return umfpack_dl_solve(sys,Ap,Ai,Ax,X,B,Numeric,Control,Info);
+}
+
+inline SuiteSparse_long umfpack_solve(int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex<double> Ax[],
+                                      std::complex<double> X[], const std::complex<double> B[], void *Numeric,
+                                      const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
+{
+  return umfpack_zl_solve(sys,Ap,Ai,&numext::real_ref(Ax[0]),0,&numext::real_ref(X[0]),0,&numext::real_ref(B[0]),0,Numeric,Control,Info);
+}
+
+// Get Lunz
+inline int umfpack_get_lunz(int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, double)
+{
+  return umfpack_di_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
+}
+
+inline int umfpack_get_lunz(int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, std::complex<double>)
+{
+  return umfpack_zi_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
+}
+
+inline SuiteSparse_long umfpack_get_lunz( SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row, SuiteSparse_long *n_col,
+                                          SuiteSparse_long *nz_udiag, void *Numeric, double)
+{
+  return umfpack_dl_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
+}
+
+inline SuiteSparse_long umfpack_get_lunz( SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row, SuiteSparse_long *n_col,
+                                          SuiteSparse_long *nz_udiag, void *Numeric, std::complex<double>)
+{
+  return umfpack_zl_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
+}
+
+// Get Numeric
+inline int umfpack_get_numeric(int Lp[], int Lj[], double Lx[], int Up[], int Ui[], double Ux[],
+                               int P[], int Q[], double Dx[], int *do_recip, double Rs[], void *Numeric)
+{
+  return umfpack_di_get_numeric(Lp,Lj,Lx,Up,Ui,Ux,P,Q,Dx,do_recip,Rs,Numeric);
+}
+
+inline int umfpack_get_numeric(int Lp[], int Lj[], std::complex<double> Lx[], int Up[], int Ui[], std::complex<double> Ux[],
+                               int P[], int Q[], std::complex<double> Dx[], int *do_recip, double Rs[], void *Numeric)
+{
+  double& lx0_real = numext::real_ref(Lx[0]);
+  double& ux0_real = numext::real_ref(Ux[0]);
+  double& dx0_real = numext::real_ref(Dx[0]);
+  return umfpack_zi_get_numeric(Lp,Lj,Lx?&lx0_real:0,0,Up,Ui,Ux?&ux0_real:0,0,P,Q,
+                                Dx?&dx0_real:0,0,do_recip,Rs,Numeric);
+}
+inline SuiteSparse_long umfpack_get_numeric(SuiteSparse_long Lp[], SuiteSparse_long Lj[], double Lx[], SuiteSparse_long Up[], SuiteSparse_long Ui[], double Ux[],
+                                            SuiteSparse_long P[], SuiteSparse_long Q[], double Dx[], SuiteSparse_long *do_recip, double Rs[], void *Numeric)
+{
+  return umfpack_dl_get_numeric(Lp,Lj,Lx,Up,Ui,Ux,P,Q,Dx,do_recip,Rs,Numeric);
+}
+
+inline SuiteSparse_long umfpack_get_numeric(SuiteSparse_long Lp[], SuiteSparse_long Lj[], std::complex<double> Lx[], SuiteSparse_long Up[], SuiteSparse_long Ui[], std::complex<double> Ux[],
+                                            SuiteSparse_long P[], SuiteSparse_long Q[], std::complex<double> Dx[], SuiteSparse_long *do_recip, double Rs[], void *Numeric)
+{
+  double& lx0_real = numext::real_ref(Lx[0]);
+  double& ux0_real = numext::real_ref(Ux[0]);
+  double& dx0_real = numext::real_ref(Dx[0]);
+  return umfpack_zl_get_numeric(Lp,Lj,Lx?&lx0_real:0,0,Up,Ui,Ux?&ux0_real:0,0,P,Q,
+                                Dx?&dx0_real:0,0,do_recip,Rs,Numeric);
+}
+
+// Get Determinant
+inline int umfpack_get_determinant(double *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], int)
+{
+  return umfpack_di_get_determinant(Mx,Ex,NumericHandle,User_Info);
+}
+
+inline int umfpack_get_determinant(std::complex<double> *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], int)
+{
+  double& mx_real = numext::real_ref(*Mx);
+  return umfpack_zi_get_determinant(&mx_real,0,Ex,NumericHandle,User_Info);
+}
+
+inline SuiteSparse_long umfpack_get_determinant(double *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], SuiteSparse_long)
+{
+  return umfpack_dl_get_determinant(Mx,Ex,NumericHandle,User_Info);
+}
+
+inline SuiteSparse_long umfpack_get_determinant(std::complex<double> *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], SuiteSparse_long)
+{
+  double& mx_real = numext::real_ref(*Mx);
+  return umfpack_zl_get_determinant(&mx_real,0,Ex,NumericHandle,User_Info);
+}
+
+
+/** \ingroup UmfPackSupport_Module
+  * \brief A sparse LU factorization and solver based on UmfPack
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LU factorization
+  * using the UmfPack library. The sparse matrix A must be squared and full rank.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * \warning The input matrix A should be in a \b compressed and \b column-major form.
+  * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  */
+template<typename _MatrixType>
+class UmfPackLU : public SparseSolverBase<UmfPackLU<_MatrixType> >
+{
+  protected:
+    typedef SparseSolverBase<UmfPackLU<_MatrixType> > Base;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
+    typedef SparseMatrix<Scalar> LUMatrixType;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> UmfpackMatrixType;
+    typedef Ref<const UmfpackMatrixType, StandardCompressedFormat> UmfpackMatrixRef;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    typedef Array<double, UMFPACK_CONTROL, 1> UmfpackControl;
+    typedef Array<double, UMFPACK_INFO, 1> UmfpackInfo;
+
+    UmfPackLU()
+      : m_dummy(0,0), mp_matrix(m_dummy)
+    {
+      init();
+    }
+
+    template<typename InputMatrixType>
+    explicit UmfPackLU(const InputMatrixType& matrix)
+      : mp_matrix(matrix)
+    {
+      init();
+      compute(matrix);
+    }
+
+    ~UmfPackLU()
+    {
+      if(m_symbolic) umfpack_free_symbolic(&m_symbolic,Scalar(), StorageIndex());
+      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar(), StorageIndex());
+    }
+
+    inline Index rows() const { return mp_matrix.rows(); }
+    inline Index cols() const { return mp_matrix.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    inline const LUMatrixType& matrixL() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_l;
+    }
+
+    inline const LUMatrixType& matrixU() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_u;
+    }
+
+    inline const IntColVectorType& permutationP() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_p;
+    }
+
+    inline const IntRowVectorType& permutationQ() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_q;
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix
+     *  Note that the matrix should be column-major, and in compressed format for best performance.
+     *  \sa SparseMatrix::makeCompressed().
+     */
+    template<typename InputMatrixType>
+    void compute(const InputMatrixType& matrix)
+    {
+      if(m_symbolic) umfpack_free_symbolic(&m_symbolic,Scalar(),StorageIndex());
+      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar(),StorageIndex());
+      grab(matrix.derived());
+      analyzePattern_impl();
+      factorize_impl();
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize(), compute()
+      */
+    template<typename InputMatrixType>
+    void analyzePattern(const InputMatrixType& matrix)
+    {
+      if(m_symbolic) umfpack_free_symbolic(&m_symbolic,Scalar(),StorageIndex());
+      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar(),StorageIndex());
+
+      grab(matrix.derived());
+
+      analyzePattern_impl();
+    }
+
+    /** Provides the return status code returned by UmfPack during the numeric
+      * factorization.
+      *
+      * \sa factorize(), compute()
+      */
+    inline int umfpackFactorizeReturncode() const
+    {
+      eigen_assert(m_numeric && "UmfPackLU: you must first call factorize()");
+      return m_fact_errorCode;
+    }
+
+    /** Provides access to the control settings array used by UmfPack.
+      *
+      * If this array contains NaN's, the default values are used.
+      *
+      * See UMFPACK documentation for details.
+      */
+    inline const UmfpackControl& umfpackControl() const
+    {
+      return m_control;
+    }
+
+    /** Provides access to the control settings array used by UmfPack.
+      *
+      * If this array contains NaN's, the default values are used.
+      *
+      * See UMFPACK documentation for details.
+      */
+    inline UmfpackControl& umfpackControl()
+    {
+      return m_control;
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the pattern anylysis has been performed.
+      *
+      * \sa analyzePattern(), compute()
+      */
+    template<typename InputMatrixType>
+    void factorize(const InputMatrixType& matrix)
+    {
+      eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
+      if(m_numeric)
+        umfpack_free_numeric(&m_numeric,Scalar(),StorageIndex());
+
+      grab(matrix.derived());
+
+      factorize_impl();
+    }
+
+    /** Prints the current UmfPack control settings.
+      *
+      * \sa umfpackControl()
+      */
+    void printUmfpackControl()
+    {
+      umfpack_report_control(m_control.data(), Scalar(),StorageIndex());
+    }
+
+    /** Prints statistics collected by UmfPack.
+      *
+      * \sa analyzePattern(), compute()
+      */
+    void printUmfpackInfo()
+    {
+      eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
+      umfpack_report_info(m_control.data(), m_umfpackInfo.data(), Scalar(),StorageIndex());
+    }
+
+    /** Prints the status of the previous factorization operation performed by UmfPack (symbolic or numerical factorization).
+      *
+      * \sa analyzePattern(), compute()
+      */
+    void printUmfpackStatus() {
+      eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
+      umfpack_report_status(m_control.data(), m_fact_errorCode, Scalar(),StorageIndex());
+    }
+
+    /** \internal */
+    template<typename BDerived,typename XDerived>
+    bool _solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const;
+
+    Scalar determinant() const;
+
+    void extractData() const;
+
+  protected:
+
+    void init()
+    {
+      m_info                  = InvalidInput;
+      m_isInitialized         = false;
+      m_numeric               = 0;
+      m_symbolic              = 0;
+      m_extractedDataAreDirty = true;
+
+      umfpack_defaults(m_control.data(), Scalar(),StorageIndex());
+    }
+
+    void analyzePattern_impl()
+    {
+      m_fact_errorCode = umfpack_symbolic(internal::convert_index<StorageIndex>(mp_matrix.rows()),
+                                          internal::convert_index<StorageIndex>(mp_matrix.cols()),
+                                          mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
+                                          &m_symbolic, m_control.data(), m_umfpackInfo.data());
+
+      m_isInitialized = true;
+      m_info = m_fact_errorCode ? InvalidInput : Success;
+      m_analysisIsOk = true;
+      m_factorizationIsOk = false;
+      m_extractedDataAreDirty = true;
+    }
+
+    void factorize_impl()
+    {
+
+      m_fact_errorCode = umfpack_numeric(mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
+                                         m_symbolic, &m_numeric, m_control.data(), m_umfpackInfo.data());
+
+      m_info = m_fact_errorCode == UMFPACK_OK ? Success : NumericalIssue;
+      m_factorizationIsOk = true;
+      m_extractedDataAreDirty = true;
+    }
+
+    template<typename MatrixDerived>
+    void grab(const EigenBase<MatrixDerived> &A)
+    {
+      mp_matrix.~UmfpackMatrixRef();
+      ::new (&mp_matrix) UmfpackMatrixRef(A.derived());
+    }
+
+    void grab(const UmfpackMatrixRef &A)
+    {
+      if(&(A.derived()) != &mp_matrix)
+      {
+        mp_matrix.~UmfpackMatrixRef();
+        ::new (&mp_matrix) UmfpackMatrixRef(A);
+      }
+    }
+
+    // cached data to reduce reallocation, etc.
+    mutable LUMatrixType m_l;
+    StorageIndex m_fact_errorCode;
+    UmfpackControl m_control;
+    mutable UmfpackInfo m_umfpackInfo;
+
+    mutable LUMatrixType m_u;
+    mutable IntColVectorType m_p;
+    mutable IntRowVectorType m_q;
+
+    UmfpackMatrixType m_dummy;
+    UmfpackMatrixRef mp_matrix;
+
+    void* m_numeric;
+    void* m_symbolic;
+
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+    mutable bool m_extractedDataAreDirty;
+
+  private:
+    UmfPackLU(const UmfPackLU& ) { }
+};
+
+
+template<typename MatrixType>
+void UmfPackLU<MatrixType>::extractData() const
+{
+  if (m_extractedDataAreDirty)
+  {
+    // get size of the data
+    StorageIndex lnz, unz, rows, cols, nz_udiag;
+    umfpack_get_lunz(&lnz, &unz, &rows, &cols, &nz_udiag, m_numeric, Scalar());
+
+    // allocate data
+    m_l.resize(rows,(std::min)(rows,cols));
+    m_l.resizeNonZeros(lnz);
+
+    m_u.resize((std::min)(rows,cols),cols);
+    m_u.resizeNonZeros(unz);
+
+    m_p.resize(rows);
+    m_q.resize(cols);
+
+    // extract
+    umfpack_get_numeric(m_l.outerIndexPtr(), m_l.innerIndexPtr(), m_l.valuePtr(),
+                        m_u.outerIndexPtr(), m_u.innerIndexPtr(), m_u.valuePtr(),
+                        m_p.data(), m_q.data(), 0, 0, 0, m_numeric);
+
+    m_extractedDataAreDirty = false;
+  }
+}
+
+template<typename MatrixType>
+typename UmfPackLU<MatrixType>::Scalar UmfPackLU<MatrixType>::determinant() const
+{
+  Scalar det;
+  umfpack_get_determinant(&det, 0, m_numeric, 0, StorageIndex());
+  return det;
+}
+
+template<typename MatrixType>
+template<typename BDerived,typename XDerived>
+bool UmfPackLU<MatrixType>::_solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const
+{
+  Index rhsCols = b.cols();
+  eigen_assert((BDerived::Flags&RowMajorBit)==0 && "UmfPackLU backend does not support non col-major rhs yet");
+  eigen_assert((XDerived::Flags&RowMajorBit)==0 && "UmfPackLU backend does not support non col-major result yet");
+  eigen_assert(b.derived().data() != x.derived().data() && " Umfpack does not support inplace solve");
+
+  Scalar* x_ptr = 0;
+  Matrix<Scalar,Dynamic,1> x_tmp;
+  if(x.innerStride()!=1)
+  {
+    x_tmp.resize(x.rows());
+    x_ptr = x_tmp.data();
+  }
+  for (int j=0; j<rhsCols; ++j)
+  {
+    if(x.innerStride()==1)
+      x_ptr = &x.col(j).coeffRef(0);
+    StorageIndex errorCode = umfpack_solve(UMFPACK_A,
+                                mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
+                                x_ptr, &b.const_cast_derived().col(j).coeffRef(0),
+                                m_numeric, m_control.data(), m_umfpackInfo.data());
+    if(x.innerStride()!=1)
+      x.col(j) = x_tmp;
+    if (errorCode!=0)
+      return false;
+  }
+
+  return true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_UMFPACKSUPPORT_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/misc/Image.h b/C++/yolo_bytetrack/include/Eigen/src/misc/Image.h
new file mode 100644
index 00000000..b8b8a045
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/misc/Image.h
@@ -0,0 +1,82 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MISC_IMAGE_H
+#define EIGEN_MISC_IMAGE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \class image_retval_base
+  *
+  */
+template<typename DecompositionType>
+struct traits<image_retval_base<DecompositionType> >
+{
+  typedef typename DecompositionType::MatrixType MatrixType;
+  typedef Matrix<
+    typename MatrixType::Scalar,
+    MatrixType::RowsAtCompileTime, // the image is a subspace of the destination space, whose
+                                   // dimension is the number of rows of the original matrix
+    Dynamic,                       // we don't know at compile time the dimension of the image (the rank)
+    MatrixType::Options,
+    MatrixType::MaxRowsAtCompileTime, // the image matrix will consist of columns from the original matrix,
+    MatrixType::MaxColsAtCompileTime  // so it has the same number of rows and at most as many columns.
+  > ReturnType;
+};
+
+template<typename _DecompositionType> struct image_retval_base
+ : public ReturnByValue<image_retval_base<_DecompositionType> >
+{
+  typedef _DecompositionType DecompositionType;
+  typedef typename DecompositionType::MatrixType MatrixType;
+  typedef ReturnByValue<image_retval_base> Base;
+
+  image_retval_base(const DecompositionType& dec, const MatrixType& originalMatrix)
+    : m_dec(dec), m_rank(dec.rank()),
+      m_cols(m_rank == 0 ? 1 : m_rank),
+      m_originalMatrix(originalMatrix)
+  {}
+
+  inline Index rows() const { return m_dec.rows(); }
+  inline Index cols() const { return m_cols; }
+  inline Index rank() const { return m_rank; }
+  inline const DecompositionType& dec() const { return m_dec; }
+  inline const MatrixType& originalMatrix() const { return m_originalMatrix; }
+
+  template<typename Dest> inline void evalTo(Dest& dst) const
+  {
+    static_cast<const image_retval<DecompositionType>*>(this)->evalTo(dst);
+  }
+
+  protected:
+    const DecompositionType& m_dec;
+    Index m_rank, m_cols;
+    const MatrixType& m_originalMatrix;
+};
+
+} // end namespace internal
+
+#define EIGEN_MAKE_IMAGE_HELPERS(DecompositionType) \
+  typedef typename DecompositionType::MatrixType MatrixType; \
+  typedef typename MatrixType::Scalar Scalar; \
+  typedef typename MatrixType::RealScalar RealScalar; \
+  typedef Eigen::internal::image_retval_base<DecompositionType> Base; \
+  using Base::dec; \
+  using Base::originalMatrix; \
+  using Base::rank; \
+  using Base::rows; \
+  using Base::cols; \
+  image_retval(const DecompositionType& dec, const MatrixType& originalMatrix) \
+    : Base(dec, originalMatrix) {}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MISC_IMAGE_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/misc/Kernel.h b/C++/yolo_bytetrack/include/Eigen/src/misc/Kernel.h
new file mode 100644
index 00000000..bef5d6ff
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/misc/Kernel.h
@@ -0,0 +1,79 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MISC_KERNEL_H
+#define EIGEN_MISC_KERNEL_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \class kernel_retval_base
+  *
+  */
+template<typename DecompositionType>
+struct traits<kernel_retval_base<DecompositionType> >
+{
+  typedef typename DecompositionType::MatrixType MatrixType;
+  typedef Matrix<
+    typename MatrixType::Scalar,
+    MatrixType::ColsAtCompileTime, // the number of rows in the "kernel matrix"
+                                   // is the number of cols of the original matrix
+                                   // so that the product "matrix * kernel = zero" makes sense
+    Dynamic,                       // we don't know at compile-time the dimension of the kernel
+    MatrixType::Options,
+    MatrixType::MaxColsAtCompileTime, // see explanation for 2nd template parameter
+    MatrixType::MaxColsAtCompileTime // the kernel is a subspace of the domain space,
+                                     // whose dimension is the number of columns of the original matrix
+  > ReturnType;
+};
+
+template<typename _DecompositionType> struct kernel_retval_base
+ : public ReturnByValue<kernel_retval_base<_DecompositionType> >
+{
+  typedef _DecompositionType DecompositionType;
+  typedef ReturnByValue<kernel_retval_base> Base;
+
+  explicit kernel_retval_base(const DecompositionType& dec)
+    : m_dec(dec),
+      m_rank(dec.rank()),
+      m_cols(m_rank==dec.cols() ? 1 : dec.cols() - m_rank)
+  {}
+
+  inline Index rows() const { return m_dec.cols(); }
+  inline Index cols() const { return m_cols; }
+  inline Index rank() const { return m_rank; }
+  inline const DecompositionType& dec() const { return m_dec; }
+
+  template<typename Dest> inline void evalTo(Dest& dst) const
+  {
+    static_cast<const kernel_retval<DecompositionType>*>(this)->evalTo(dst);
+  }
+
+  protected:
+    const DecompositionType& m_dec;
+    Index m_rank, m_cols;
+};
+
+} // end namespace internal
+
+#define EIGEN_MAKE_KERNEL_HELPERS(DecompositionType) \
+  typedef typename DecompositionType::MatrixType MatrixType; \
+  typedef typename MatrixType::Scalar Scalar; \
+  typedef typename MatrixType::RealScalar RealScalar; \
+  typedef Eigen::internal::kernel_retval_base<DecompositionType> Base; \
+  using Base::dec; \
+  using Base::rank; \
+  using Base::rows; \
+  using Base::cols; \
+  kernel_retval(const DecompositionType& dec) : Base(dec) {}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MISC_KERNEL_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/misc/RealSvd2x2.h b/C++/yolo_bytetrack/include/Eigen/src/misc/RealSvd2x2.h
new file mode 100644
index 00000000..abb4d3c2
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/misc/RealSvd2x2.h
@@ -0,0 +1,55 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2013-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REALSVD2X2_H
+#define EIGEN_REALSVD2X2_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatrixType, typename RealScalar, typename Index>
+void real_2x2_jacobi_svd(const MatrixType& matrix, Index p, Index q,
+                         JacobiRotation<RealScalar> *j_left,
+                         JacobiRotation<RealScalar> *j_right)
+{
+  using std::sqrt;
+  using std::abs;
+  Matrix<RealScalar,2,2> m;
+  m << numext::real(matrix.coeff(p,p)), numext::real(matrix.coeff(p,q)),
+       numext::real(matrix.coeff(q,p)), numext::real(matrix.coeff(q,q));
+  JacobiRotation<RealScalar> rot1;
+  RealScalar t = m.coeff(0,0) + m.coeff(1,1);
+  RealScalar d = m.coeff(1,0) - m.coeff(0,1);
+
+  if(abs(d) < (std::numeric_limits<RealScalar>::min)())
+  {
+    rot1.s() = RealScalar(0);
+    rot1.c() = RealScalar(1);
+  }
+  else
+  {
+    // If d!=0, then t/d cannot overflow because the magnitude of the
+    // entries forming d are not too small compared to the ones forming t.
+    RealScalar u = t / d;
+    RealScalar tmp = sqrt(RealScalar(1) + numext::abs2(u));
+    rot1.s() = RealScalar(1) / tmp;
+    rot1.c() = u / tmp;
+  }
+  m.applyOnTheLeft(0,1,rot1);
+  j_right->makeJacobi(m,0,1);
+  *j_left = rot1 * j_right->transpose();
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_REALSVD2X2_H
diff --git a/C++/yolo_bytetrack/include/Eigen/src/misc/blas.h b/C++/yolo_bytetrack/include/Eigen/src/misc/blas.h
new file mode 100644
index 00000000..25215b15
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/misc/blas.h
@@ -0,0 +1,440 @@
+#ifndef BLAS_H
+#define BLAS_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define BLASFUNC(FUNC) FUNC##_
+
+#ifdef __WIN64__
+typedef long long BLASLONG;
+typedef unsigned long long BLASULONG;
+#else
+typedef long BLASLONG;
+typedef unsigned long BLASULONG;
+#endif
+
+int    BLASFUNC(xerbla)(const char *, int *info, int);
+
+float  BLASFUNC(sdot)  (int *, float  *, int *, float  *, int *);
+float  BLASFUNC(sdsdot)(int *, float  *,        float  *, int *, float  *, int *);
+
+double BLASFUNC(dsdot) (int *, float  *, int *, float  *, int *);
+double BLASFUNC(ddot)  (int *, double *, int *, double *, int *);
+double BLASFUNC(qdot)  (int *, double *, int *, double *, int *);
+
+int  BLASFUNC(cdotuw)  (int *, float  *, int *, float  *, int *, float*);
+int  BLASFUNC(cdotcw)  (int *, float  *, int *, float  *, int *, float*);
+int  BLASFUNC(zdotuw)  (int *, double  *, int *, double  *, int *, double*);
+int  BLASFUNC(zdotcw)  (int *, double  *, int *, double  *, int *, double*);
+
+int    BLASFUNC(saxpy) (const int *, const float  *, const float  *, const int *, float  *, const int *);
+int    BLASFUNC(daxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(qaxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(caxpy) (const int *, const float  *, const float  *, const int *, float  *, const int *);
+int    BLASFUNC(zaxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(xaxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(caxpyc)(const int *, const float  *, const float  *, const int *, float  *, const int *);
+int    BLASFUNC(zaxpyc)(const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(xaxpyc)(const int *, const double *, const double *, const int *, double *, const int *);
+
+int    BLASFUNC(scopy) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(dcopy) (int *, double *, int *, double *, int *);
+int    BLASFUNC(qcopy) (int *, double *, int *, double *, int *);
+int    BLASFUNC(ccopy) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(zcopy) (int *, double *, int *, double *, int *);
+int    BLASFUNC(xcopy) (int *, double *, int *, double *, int *);
+
+int    BLASFUNC(sswap) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(dswap) (int *, double *, int *, double *, int *);
+int    BLASFUNC(qswap) (int *, double *, int *, double *, int *);
+int    BLASFUNC(cswap) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(zswap) (int *, double *, int *, double *, int *);
+int    BLASFUNC(xswap) (int *, double *, int *, double *, int *);
+
+float  BLASFUNC(sasum) (int *, float  *, int *);
+float  BLASFUNC(scasum)(int *, float  *, int *);
+double BLASFUNC(dasum) (int *, double *, int *);
+double BLASFUNC(qasum) (int *, double *, int *);
+double BLASFUNC(dzasum)(int *, double *, int *);
+double BLASFUNC(qxasum)(int *, double *, int *);
+
+int    BLASFUNC(isamax)(int *, float  *, int *);
+int    BLASFUNC(idamax)(int *, double *, int *);
+int    BLASFUNC(iqamax)(int *, double *, int *);
+int    BLASFUNC(icamax)(int *, float  *, int *);
+int    BLASFUNC(izamax)(int *, double *, int *);
+int    BLASFUNC(ixamax)(int *, double *, int *);
+
+int    BLASFUNC(ismax) (int *, float  *, int *);
+int    BLASFUNC(idmax) (int *, double *, int *);
+int    BLASFUNC(iqmax) (int *, double *, int *);
+int    BLASFUNC(icmax) (int *, float  *, int *);
+int    BLASFUNC(izmax) (int *, double *, int *);
+int    BLASFUNC(ixmax) (int *, double *, int *);
+
+int    BLASFUNC(isamin)(int *, float  *, int *);
+int    BLASFUNC(idamin)(int *, double *, int *);
+int    BLASFUNC(iqamin)(int *, double *, int *);
+int    BLASFUNC(icamin)(int *, float  *, int *);
+int    BLASFUNC(izamin)(int *, double *, int *);
+int    BLASFUNC(ixamin)(int *, double *, int *);
+
+int    BLASFUNC(ismin)(int *, float  *, int *);
+int    BLASFUNC(idmin)(int *, double *, int *);
+int    BLASFUNC(iqmin)(int *, double *, int *);
+int    BLASFUNC(icmin)(int *, float  *, int *);
+int    BLASFUNC(izmin)(int *, double *, int *);
+int    BLASFUNC(ixmin)(int *, double *, int *);
+
+float  BLASFUNC(samax) (int *, float  *, int *);
+double BLASFUNC(damax) (int *, double *, int *);
+double BLASFUNC(qamax) (int *, double *, int *);
+float  BLASFUNC(scamax)(int *, float  *, int *);
+double BLASFUNC(dzamax)(int *, double *, int *);
+double BLASFUNC(qxamax)(int *, double *, int *);
+
+float  BLASFUNC(samin) (int *, float  *, int *);
+double BLASFUNC(damin) (int *, double *, int *);
+double BLASFUNC(qamin) (int *, double *, int *);
+float  BLASFUNC(scamin)(int *, float  *, int *);
+double BLASFUNC(dzamin)(int *, double *, int *);
+double BLASFUNC(qxamin)(int *, double *, int *);
+
+float  BLASFUNC(smax)  (int *, float  *, int *);
+double BLASFUNC(dmax)  (int *, double *, int *);
+double BLASFUNC(qmax)  (int *, double *, int *);
+float  BLASFUNC(scmax) (int *, float  *, int *);
+double BLASFUNC(dzmax) (int *, double *, int *);
+double BLASFUNC(qxmax) (int *, double *, int *);
+
+float  BLASFUNC(smin)  (int *, float  *, int *);
+double BLASFUNC(dmin)  (int *, double *, int *);
+double BLASFUNC(qmin)  (int *, double *, int *);
+float  BLASFUNC(scmin) (int *, float  *, int *);
+double BLASFUNC(dzmin) (int *, double *, int *);
+double BLASFUNC(qxmin) (int *, double *, int *);
+
+int    BLASFUNC(sscal) (int *,  float  *, float  *, int *);
+int    BLASFUNC(dscal) (int *,  double *, double *, int *);
+int    BLASFUNC(qscal) (int *,  double *, double *, int *);
+int    BLASFUNC(cscal) (int *,  float  *, float  *, int *);
+int    BLASFUNC(zscal) (int *,  double *, double *, int *);
+int    BLASFUNC(xscal) (int *,  double *, double *, int *);
+int    BLASFUNC(csscal)(int *,  float  *, float  *, int *);
+int    BLASFUNC(zdscal)(int *,  double *, double *, int *);
+int    BLASFUNC(xqscal)(int *,  double *, double *, int *);
+
+float  BLASFUNC(snrm2) (int *, float  *, int *);
+float  BLASFUNC(scnrm2)(int *, float  *, int *);
+
+double BLASFUNC(dnrm2) (int *, double *, int *);
+double BLASFUNC(qnrm2) (int *, double *, int *);
+double BLASFUNC(dznrm2)(int *, double *, int *);
+double BLASFUNC(qxnrm2)(int *, double *, int *);
+
+int    BLASFUNC(srot)  (int *, float  *, int *, float  *, int *, float  *, float  *);
+int    BLASFUNC(drot)  (int *, double *, int *, double *, int *, double *, double *);
+int    BLASFUNC(qrot)  (int *, double *, int *, double *, int *, double *, double *);
+int    BLASFUNC(csrot) (int *, float  *, int *, float  *, int *, float  *, float  *);
+int    BLASFUNC(zdrot) (int *, double *, int *, double *, int *, double *, double *);
+int    BLASFUNC(xqrot) (int *, double *, int *, double *, int *, double *, double *);
+
+int    BLASFUNC(srotg) (float  *, float  *, float  *, float  *);
+int    BLASFUNC(drotg) (double *, double *, double *, double *);
+int    BLASFUNC(qrotg) (double *, double *, double *, double *);
+int    BLASFUNC(crotg) (float  *, float  *, float  *, float  *);
+int    BLASFUNC(zrotg) (double *, double *, double *, double *);
+int    BLASFUNC(xrotg) (double *, double *, double *, double *);
+
+int    BLASFUNC(srotmg)(float  *, float  *, float  *, float  *, float  *);
+int    BLASFUNC(drotmg)(double *, double *, double *, double *, double *);
+
+int    BLASFUNC(srotm) (int *, float  *, int *, float  *, int *, float  *);
+int    BLASFUNC(drotm) (int *, double *, int *, double *, int *, double *);
+int    BLASFUNC(qrotm) (int *, double *, int *, double *, int *, double *);
+
+/* Level 2 routines */
+
+int BLASFUNC(sger)(int *,    int *, float *,  float *, int *,
+		   float *,  int *, float *,  int *);
+int BLASFUNC(dger)(int *,    int *, double *, double *, int *,
+		   double *, int *, double *, int *);
+int BLASFUNC(qger)(int *,    int *, double *, double *, int *,
+		   double *, int *, double *, int *);
+int BLASFUNC(cgeru)(int *,    int *, float *,  float *, int *,
+		    float *,  int *, float *,  int *);
+int BLASFUNC(cgerc)(int *,    int *, float *,  float *, int *,
+		    float *,  int *, float *,  int *);
+int BLASFUNC(zgeru)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+int BLASFUNC(zgerc)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+int BLASFUNC(xgeru)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+int BLASFUNC(xgerc)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+
+int BLASFUNC(sgemv)(const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(cgemv)(const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(strsv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dtrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrsv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(ztrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(stpsv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(dtpsv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(qtpsv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(ctpsv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(ztpsv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(xtpsv) (char *, char *, char *, int *, double *, double *, int *);
+
+int BLASFUNC(strmv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dtrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrmv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(ztrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(stpmv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(dtpmv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(qtpmv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(ctpmv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(ztpmv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(xtpmv) (char *, char *, char *, int *, double *, double *, int *);
+
+int BLASFUNC(stbmv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(dtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(qtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(ctbmv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(ztbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(xtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+
+int BLASFUNC(stbsv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(dtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(qtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(ctbsv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(ztbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(xtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+
+int BLASFUNC(ssymv) (const char *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(sspmv) (char *, int *, float  *, float *,
+		     float  *, int *, float *, float *, int *);
+int BLASFUNC(dspmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+int BLASFUNC(qspmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+
+int BLASFUNC(ssyr) (const char *, const int *, const float   *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dsyr) (const char *, const int *, const double  *, const double *, const int *, double *, const int *);
+int BLASFUNC(qsyr) (const char *, const int *, const double  *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(ssyr2) (const char *, const int *, const float   *, const float  *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(qsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(csyr2) (const char *, const int *, const float   *, const float  *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(zsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(xsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(sspr) (char *, int *, float   *, float  *, int *,
+		    float  *);
+int BLASFUNC(dspr) (char *, int *, double  *, double *, int *,
+		    double *);
+int BLASFUNC(qspr) (char *, int *, double  *, double *, int *,
+		    double *);
+
+int BLASFUNC(sspr2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *);
+int BLASFUNC(dspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(qspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(cspr2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *);
+int BLASFUNC(zspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(xspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+
+int BLASFUNC(cher) (char *, int *, float   *, float  *, int *,
+		    float  *, int *);
+int BLASFUNC(zher) (char *, int *, double  *, double *, int *,
+		    double *, int *);
+int BLASFUNC(xher) (char *, int *, double  *, double *, int *,
+		    double *, int *);
+
+int BLASFUNC(chpr) (char *, int *, float   *, float  *, int *, float  *);
+int BLASFUNC(zhpr) (char *, int *, double  *, double *, int *, double *);
+int BLASFUNC(xhpr) (char *, int *, double  *, double *, int *, double *);
+
+int BLASFUNC(cher2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(zher2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *, int *);
+int BLASFUNC(xher2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *, int *);
+
+int BLASFUNC(chpr2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *);
+int BLASFUNC(zhpr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(xhpr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+
+int BLASFUNC(chemv) (const char *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zhemv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xhemv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(chpmv) (char *, int *, float  *, float *,
+		     float  *, int *, float *, float *, int *);
+int BLASFUNC(zhpmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+int BLASFUNC(xhpmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+
+int BLASFUNC(snorm)(char *, int *, int *, float  *, int *);
+int BLASFUNC(dnorm)(char *, int *, int *, double *, int *);
+int BLASFUNC(cnorm)(char *, int *, int *, float  *, int *);
+int BLASFUNC(znorm)(char *, int *, int *, double *, int *);
+
+int BLASFUNC(sgbmv)(char *, int *, int *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(dgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(qgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(cgbmv)(char *, int *, int *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(xgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+
+int BLASFUNC(ssbmv)(char *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(dsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(qsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(csbmv)(char *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(xsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+
+int BLASFUNC(chbmv)(char *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zhbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(xhbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+
+/* Level 3 routines */
+
+int BLASFUNC(sgemm)(const char *, const char *, const int *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(cgemm)(const char *, const char *, const int *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(cgemm3m)(char *, char *, int *, int *, int *, float *,
+	   float  *, int *, float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zgemm3m)(char *, char *, int *, int *, int *, double *,
+	   double *, int *, double *, int *, double *, double *, int *);
+int BLASFUNC(xgemm3m)(char *, char *, int *, int *, int *, double *,
+	   double *, int *, double *, int *, double *, double *, int *);
+
+int BLASFUNC(sge2mm)(char *, char *, char *, int *, int *,
+		     float *, float  *, int *, float  *, int *,
+		     float *, float  *, int *);
+int BLASFUNC(dge2mm)(char *, char *, char *, int *, int *,
+		     double *, double  *, int *, double  *, int *,
+		     double *, double  *, int *);
+int BLASFUNC(cge2mm)(char *, char *, char *, int *, int *,
+		     float *, float  *, int *, float  *, int *,
+		     float *, float  *, int *);
+int BLASFUNC(zge2mm)(char *, char *, char *, int *, int *,
+		     double *, double  *, int *, double  *, int *,
+		     double *, double  *, int *);
+
+int BLASFUNC(strsm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(dtrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(ztrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(strmm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(dtrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(ztrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(ssymm)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(csymm)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(csymm3m)(char *, char *, int *, int *, float  *, float  *, int *, float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zsymm3m)(char *, char *, int *, int *, double *, double *, int *, double *, int *, double *, double *, int *);
+int BLASFUNC(xsymm3m)(char *, char *, int *, int *, double *, double *, int *, double *, int *, double *, double *, int *);
+
+int BLASFUNC(ssyrk)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(csyrk)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(ssyr2k)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(qsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(csyr2k)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(xsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+
+int BLASFUNC(chemm)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zhemm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xhemm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(chemm3m)(char *, char *, int *, int *, float  *, float  *, int *,
+	   float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zhemm3m)(char *, char *, int *, int *, double *, double *, int *,
+	   double *, int *, double *, double *, int *);
+int BLASFUNC(xhemm3m)(char *, char *, int *, int *, double *, double *, int *,
+	   double *, int *, double *, double *, int *);
+
+int BLASFUNC(cherk)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zherk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xherk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(cher2k)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zher2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xher2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(cher2m)(const char *, const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zher2m)(const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(xher2m)(const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/misc/lapack.h b/C++/yolo_bytetrack/include/Eigen/src/misc/lapack.h
new file mode 100644
index 00000000..249f3575
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/misc/lapack.h
@@ -0,0 +1,152 @@
+#ifndef LAPACK_H
+#define LAPACK_H
+
+#include "blas.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+int BLASFUNC(csymv) (const char *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+
+int BLASFUNC(cspmv) (char *, int *, float  *, float *,
+         float  *, int *, float *, float *, int *);
+int BLASFUNC(zspmv) (char *, int *, double  *, double *,
+         double  *, int *, double *, double *, int *);
+int BLASFUNC(xspmv) (char *, int *, double  *, double *,
+         double  *, int *, double *, double *, int *);
+
+int BLASFUNC(csyr) (char *, int *, float   *, float  *, int *,
+        float  *, int *);
+int BLASFUNC(zsyr) (char *, int *, double  *, double *, int *,
+        double *, int *);
+int BLASFUNC(xsyr) (char *, int *, double  *, double *, int *,
+        double *, int *);
+
+int BLASFUNC(cspr) (char *, int *, float   *, float  *, int *,
+        float  *);
+int BLASFUNC(zspr) (char *, int *, double  *, double *, int *,
+        double *);
+int BLASFUNC(xspr) (char *, int *, double  *, double *, int *,
+        double *);
+
+int BLASFUNC(sgemt)(char *, int *, int *, float  *, float  *, int *,
+        float  *, int *);
+int BLASFUNC(dgemt)(char *, int *, int *, double *, double *, int *,
+        double *, int *);
+int BLASFUNC(cgemt)(char *, int *, int *, float  *, float  *, int *,
+        float  *, int *);
+int BLASFUNC(zgemt)(char *, int *, int *, double *, double *, int *,
+        double *, int *);
+
+int BLASFUNC(sgema)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(dgema)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+int BLASFUNC(cgema)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(zgema)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+
+int BLASFUNC(sgems)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(dgems)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+int BLASFUNC(cgems)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(zgems)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+
+int BLASFUNC(sgetf2)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(dgetf2)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(qgetf2)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(cgetf2)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(zgetf2)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(xgetf2)(int *, int *, double *, int *, int *, int *);
+
+int BLASFUNC(sgetrf)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(dgetrf)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(qgetrf)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(cgetrf)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(zgetrf)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(xgetrf)(int *, int *, double *, int *, int *, int *);
+
+int BLASFUNC(slaswp)(int *, float  *, int *, int *, int *, int *, int *);
+int BLASFUNC(dlaswp)(int *, double *, int *, int *, int *, int *, int *);
+int BLASFUNC(qlaswp)(int *, double *, int *, int *, int *, int *, int *);
+int BLASFUNC(claswp)(int *, float  *, int *, int *, int *, int *, int *);
+int BLASFUNC(zlaswp)(int *, double *, int *, int *, int *, int *, int *);
+int BLASFUNC(xlaswp)(int *, double *, int *, int *, int *, int *, int *);
+
+int BLASFUNC(sgetrs)(char *, int *, int *, float  *, int *, int *, float  *, int *, int *);
+int BLASFUNC(dgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+int BLASFUNC(qgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+int BLASFUNC(cgetrs)(char *, int *, int *, float  *, int *, int *, float  *, int *, int *);
+int BLASFUNC(zgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+int BLASFUNC(xgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+
+int BLASFUNC(sgesv)(int *, int *, float  *, int *, int *, float *, int *, int *);
+int BLASFUNC(dgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+int BLASFUNC(qgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+int BLASFUNC(cgesv)(int *, int *, float  *, int *, int *, float *, int *, int *);
+int BLASFUNC(zgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+int BLASFUNC(xgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+
+int BLASFUNC(spotf2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dpotf2)(char *, int *, double *, int *, int *);
+int BLASFUNC(qpotf2)(char *, int *, double *, int *, int *);
+int BLASFUNC(cpotf2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zpotf2)(char *, int *, double *, int *, int *);
+int BLASFUNC(xpotf2)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(spotrf)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dpotrf)(char *, int *, double *, int *, int *);
+int BLASFUNC(qpotrf)(char *, int *, double *, int *, int *);
+int BLASFUNC(cpotrf)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zpotrf)(char *, int *, double *, int *, int *);
+int BLASFUNC(xpotrf)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(slauu2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dlauu2)(char *, int *, double *, int *, int *);
+int BLASFUNC(qlauu2)(char *, int *, double *, int *, int *);
+int BLASFUNC(clauu2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zlauu2)(char *, int *, double *, int *, int *);
+int BLASFUNC(xlauu2)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(slauum)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dlauum)(char *, int *, double *, int *, int *);
+int BLASFUNC(qlauum)(char *, int *, double *, int *, int *);
+int BLASFUNC(clauum)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zlauum)(char *, int *, double *, int *, int *);
+int BLASFUNC(xlauum)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(strti2)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(dtrti2)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(qtrti2)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(ctrti2)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(ztrti2)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(xtrti2)(char *, char *, int *, double *, int *, int *);
+
+int BLASFUNC(strtri)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(dtrtri)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(qtrtri)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(ctrtri)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(ztrtri)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(xtrtri)(char *, char *, int *, double *, int *, int *);
+
+int BLASFUNC(spotri)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dpotri)(char *, int *, double *, int *, int *);
+int BLASFUNC(qpotri)(char *, int *, double *, int *, int *);
+int BLASFUNC(cpotri)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zpotri)(char *, int *, double *, int *, int *);
+int BLASFUNC(xpotri)(char *, int *, double *, int *, int *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C++/yolo_bytetrack/include/Eigen/src/misc/lapacke.h b/C++/yolo_bytetrack/include/Eigen/src/misc/lapacke.h
new file mode 100644
index 00000000..3d8e24f5
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/misc/lapacke.h
@@ -0,0 +1,16292 @@
+/*****************************************************************************
+  Copyright (c) 2010, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************
+* Contents: Native C interface to LAPACK
+* Author: Intel Corporation
+* Generated November, 2011
+*****************************************************************************/
+
+#ifndef _MKL_LAPACKE_H_
+
+#ifndef _LAPACKE_H_
+#define _LAPACKE_H_
+
+/*
+*  Turn on HAVE_LAPACK_CONFIG_H to redefine C-LAPACK datatypes
+*/
+#ifdef HAVE_LAPACK_CONFIG_H
+#include "lapacke_config.h"
+#endif
+
+#include <stdlib.h>
+
+#ifndef lapack_int
+#define lapack_int     int
+#endif
+
+#ifndef lapack_logical
+#define lapack_logical lapack_int
+#endif
+
+/* Complex types are structures equivalent to the
+* Fortran complex types COMPLEX(4) and COMPLEX(8).
+*
+* One can also redefine the types with his own types
+* for example by including in the code definitions like
+*
+* #define lapack_complex_float std::complex<float>
+* #define lapack_complex_double std::complex<double>
+*
+* or define these types in the command line:
+*
+* -Dlapack_complex_float="std::complex<float>"
+* -Dlapack_complex_double="std::complex<double>"
+*/
+
+#ifndef LAPACK_COMPLEX_CUSTOM
+
+/* Complex type (single precision) */
+#ifndef lapack_complex_float
+#include <complex.h>
+#define lapack_complex_float    float _Complex
+#endif
+
+#ifndef lapack_complex_float_real
+#define lapack_complex_float_real(z)       (creal(z))
+#endif
+
+#ifndef lapack_complex_float_imag
+#define lapack_complex_float_imag(z)       (cimag(z))
+#endif
+
+lapack_complex_float lapack_make_complex_float( float re, float im );
+
+/* Complex type (double precision) */
+#ifndef lapack_complex_double
+#include <complex.h>
+#define lapack_complex_double   double _Complex
+#endif
+
+#ifndef lapack_complex_double_real
+#define lapack_complex_double_real(z)      (creal(z))
+#endif
+
+#ifndef lapack_complex_double_imag
+#define lapack_complex_double_imag(z)       (cimag(z))
+#endif
+
+lapack_complex_double lapack_make_complex_double( double re, double im );
+
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifndef LAPACKE_malloc
+#define LAPACKE_malloc( size ) malloc( size )
+#endif
+#ifndef LAPACKE_free
+#define LAPACKE_free( p )      free( p )
+#endif
+
+#define LAPACK_C2INT( x ) (lapack_int)(*((float*)&x ))
+#define LAPACK_Z2INT( x ) (lapack_int)(*((double*)&x ))
+
+#define LAPACK_ROW_MAJOR               101
+#define LAPACK_COL_MAJOR               102
+
+#define LAPACK_WORK_MEMORY_ERROR       -1010
+#define LAPACK_TRANSPOSE_MEMORY_ERROR  -1011
+
+/* Callback logical functions of one, two, or three arguments are used
+*  to select eigenvalues to sort to the top left of the Schur form.
+*  The value is selected if function returns TRUE (non-zero). */
+
+typedef lapack_logical (*LAPACK_S_SELECT2) ( const float*, const float* );
+typedef lapack_logical (*LAPACK_S_SELECT3)
+    ( const float*, const float*, const float* );
+typedef lapack_logical (*LAPACK_D_SELECT2) ( const double*, const double* );
+typedef lapack_logical (*LAPACK_D_SELECT3)
+    ( const double*, const double*, const double* );
+
+typedef lapack_logical (*LAPACK_C_SELECT1) ( const lapack_complex_float* );
+typedef lapack_logical (*LAPACK_C_SELECT2)
+    ( const lapack_complex_float*, const lapack_complex_float* );
+typedef lapack_logical (*LAPACK_Z_SELECT1) ( const lapack_complex_double* );
+typedef lapack_logical (*LAPACK_Z_SELECT2)
+    ( const lapack_complex_double*, const lapack_complex_double* );
+
+#include "lapacke_mangling.h"
+
+#define LAPACK_lsame LAPACK_GLOBAL(lsame,LSAME)
+lapack_logical LAPACK_lsame( char* ca,  char* cb,
+                              lapack_int lca, lapack_int lcb );
+
+/* C-LAPACK function prototypes */
+
+lapack_int LAPACKE_sbdsdc( int matrix_order, char uplo, char compq,
+                           lapack_int n, float* d, float* e, float* u,
+                           lapack_int ldu, float* vt, lapack_int ldvt, float* q,
+                           lapack_int* iq );
+lapack_int LAPACKE_dbdsdc( int matrix_order, char uplo, char compq,
+                           lapack_int n, double* d, double* e, double* u,
+                           lapack_int ldu, double* vt, lapack_int ldvt,
+                           double* q, lapack_int* iq );
+
+lapack_int LAPACKE_sbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           float* d, float* e, float* vt, lapack_int ldvt,
+                           float* u, lapack_int ldu, float* c, lapack_int ldc );
+lapack_int LAPACKE_dbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           double* d, double* e, double* vt, lapack_int ldvt,
+                           double* u, lapack_int ldu, double* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_cbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           float* d, float* e, lapack_complex_float* vt,
+                           lapack_int ldvt, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_zbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           double* d, double* e, lapack_complex_double* vt,
+                           lapack_int ldvt, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* c,
+                           lapack_int ldc );
+
+lapack_int LAPACKE_sdisna( char job, lapack_int m, lapack_int n, const float* d,
+                           float* sep );
+lapack_int LAPACKE_ddisna( char job, lapack_int m, lapack_int n,
+                           const double* d, double* sep );
+
+lapack_int LAPACKE_sgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, float* ab, lapack_int ldab, float* d,
+                           float* e, float* q, lapack_int ldq, float* pt,
+                           lapack_int ldpt, float* c, lapack_int ldc );
+lapack_int LAPACKE_dgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, double* ab, lapack_int ldab,
+                           double* d, double* e, double* q, lapack_int ldq,
+                           double* pt, lapack_int ldpt, double* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_cgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, lapack_complex_float* ab,
+                           lapack_int ldab, float* d, float* e,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* pt, lapack_int ldpt,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, lapack_complex_double* ab,
+                           lapack_int ldab, double* d, double* e,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* pt, lapack_int ldpt,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* ab,
+                           lapack_int ldab, const lapack_int* ipiv, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* ab,
+                           lapack_int ldab, const lapack_int* ipiv,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* ab,
+                           lapack_int ldab, float* r, float* c, float* rowcnd,
+                           float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* ab,
+                           lapack_int ldab, double* r, double* c,
+                           double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           float* r, float* c, float* rowcnd, float* colcnd,
+                           float* amax );
+lapack_int LAPACKE_zgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           double* r, double* c, double* rowcnd, double* colcnd,
+                           double* amax );
+
+lapack_int LAPACKE_sgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku, const float* ab,
+                            lapack_int ldab, float* r, float* c, float* rowcnd,
+                            float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku, const double* ab,
+                            lapack_int ldab, double* r, double* c,
+                            double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku,
+                            const lapack_complex_float* ab, lapack_int ldab,
+                            float* r, float* c, float* rowcnd, float* colcnd,
+                            float* amax );
+lapack_int LAPACKE_zgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku,
+                            const lapack_complex_double* ab, lapack_int ldab,
+                            double* r, double* c, double* rowcnd,
+                            double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const float* ab, lapack_int ldab, const float* afb,
+                           lapack_int ldafb, const lapack_int* ipiv,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const double* ab, lapack_int ldab, const double* afb,
+                           lapack_int ldafb, const lapack_int* ipiv,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* afb, lapack_int ldafb,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* afb, lapack_int ldafb,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const float* ab, lapack_int ldab,
+                            const float* afb, lapack_int ldafb,
+                            const lapack_int* ipiv, const float* r,
+                            const float* c, const float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const double* ab, lapack_int ldab,
+                            const double* afb, lapack_int ldafb,
+                            const lapack_int* ipiv, const double* r,
+                            const double* c, const double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const lapack_complex_float* ab,
+                            lapack_int ldab, const lapack_complex_float* afb,
+                            lapack_int ldafb, const lapack_int* ipiv,
+                            const float* r, const float* c,
+                            const lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const lapack_complex_double* ab,
+                            lapack_int ldab, const lapack_complex_double* afb,
+                            lapack_int ldafb, const lapack_int* ipiv,
+                            const double* r, const double* c,
+                            const lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_sgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs, float* ab,
+                          lapack_int ldab, lapack_int* ipiv, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs, double* ab,
+                          lapack_int ldab, lapack_int* ipiv, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs,
+                          lapack_complex_float* ab, lapack_int ldab,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs,
+                          lapack_complex_double* ab, lapack_int ldab,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_sgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, float* ab, lapack_int ldab,
+                           float* afb, lapack_int ldafb, lapack_int* ipiv,
+                           char* equed, float* r, float* c, float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr,
+                           float* rpivot );
+lapack_int LAPACKE_dgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, double* ab, lapack_int ldab,
+                           double* afb, lapack_int ldafb, lapack_int* ipiv,
+                           char* equed, double* r, double* c, double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr,
+                           double* rpivot );
+lapack_int LAPACKE_cgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, lapack_complex_float* ab,
+                           lapack_int ldab, lapack_complex_float* afb,
+                           lapack_int ldafb, lapack_int* ipiv, char* equed,
+                           float* r, float* c, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr, float* rpivot );
+lapack_int LAPACKE_zgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, lapack_complex_double* ab,
+                           lapack_int ldab, lapack_complex_double* afb,
+                           lapack_int ldafb, lapack_int* ipiv, char* equed,
+                           double* r, double* c, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, double* rcond, double* ferr,
+                           double* berr, double* rpivot );
+
+lapack_int LAPACKE_sgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, float* ab, lapack_int ldab,
+                            float* afb, lapack_int ldafb, lapack_int* ipiv,
+                            char* equed, float* r, float* c, float* b,
+                            lapack_int ldb, float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, double* ab, lapack_int ldab,
+                            double* afb, lapack_int ldafb, lapack_int* ipiv,
+                            char* equed, double* r, double* c, double* b,
+                            lapack_int ldb, double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+lapack_int LAPACKE_cgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, lapack_complex_float* ab,
+                            lapack_int ldab, lapack_complex_float* afb,
+                            lapack_int ldafb, lapack_int* ipiv, char* equed,
+                            float* r, float* c, lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* rpvgrw,
+                            float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, lapack_complex_double* ab,
+                            lapack_int ldab, lapack_complex_double* afb,
+                            lapack_int ldafb, lapack_int* ipiv, char* equed,
+                            double* r, double* c, lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* rpvgrw,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_sgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, float* ab,
+                           lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_dgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, double* ab,
+                           lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_cgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_sgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const float* ab, lapack_int ldab,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const double* ab, lapack_int ldab,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_sgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* scale,
+                           lapack_int m, float* v, lapack_int ldv );
+lapack_int LAPACKE_dgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* scale,
+                           lapack_int m, double* v, lapack_int ldv );
+lapack_int LAPACKE_cgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* scale,
+                           lapack_int m, lapack_complex_float* v,
+                           lapack_int ldv );
+lapack_int LAPACKE_zgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* scale,
+                           lapack_int m, lapack_complex_double* v,
+                           lapack_int ldv );
+
+lapack_int LAPACKE_sgebal( int matrix_order, char job, lapack_int n, float* a,
+                           lapack_int lda, lapack_int* ilo, lapack_int* ihi,
+                           float* scale );
+lapack_int LAPACKE_dgebal( int matrix_order, char job, lapack_int n, double* a,
+                           lapack_int lda, lapack_int* ilo, lapack_int* ihi,
+                           double* scale );
+lapack_int LAPACKE_cgebal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ilo, lapack_int* ihi, float* scale );
+lapack_int LAPACKE_zgebal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ilo, lapack_int* ihi, double* scale );
+
+lapack_int LAPACKE_sgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* d, float* e,
+                           float* tauq, float* taup );
+lapack_int LAPACKE_dgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* d, double* e,
+                           double* tauq, double* taup );
+lapack_int LAPACKE_cgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda, float* d,
+                           float* e, lapack_complex_float* tauq,
+                           lapack_complex_float* taup );
+lapack_int LAPACKE_zgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda, double* d,
+                           double* e, lapack_complex_double* tauq,
+                           lapack_complex_double* taup );
+
+lapack_int LAPACKE_sgecon( int matrix_order, char norm, lapack_int n,
+                           const float* a, lapack_int lda, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dgecon( int matrix_order, char norm, lapack_int n,
+                           const double* a, lapack_int lda, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_cgecon( int matrix_order, char norm, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_zgecon( int matrix_order, char norm, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double anorm, double* rcond );
+
+lapack_int LAPACKE_sgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const float* a, lapack_int lda, float* r, float* c,
+                           float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const double* a, lapack_int lda, double* r,
+                           double* c, double* rowcnd, double* colcnd,
+                           double* amax );
+lapack_int LAPACKE_cgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float* r, float* c, float* rowcnd, float* colcnd,
+                           float* amax );
+lapack_int LAPACKE_zgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double* r, double* c, double* rowcnd, double* colcnd,
+                           double* amax );
+
+lapack_int LAPACKE_sgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const float* a, lapack_int lda, float* r, float* c,
+                            float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const double* a, lapack_int lda, double* r,
+                            double* c, double* rowcnd, double* colcnd,
+                            double* amax );
+lapack_int LAPACKE_cgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* r, float* c, float* rowcnd, float* colcnd,
+                            float* amax );
+lapack_int LAPACKE_zgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* r, double* c, double* rowcnd,
+                            double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_S_SELECT2 select, lapack_int n, float* a,
+                          lapack_int lda, lapack_int* sdim, float* wr,
+                          float* wi, float* vs, lapack_int ldvs );
+lapack_int LAPACKE_dgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_D_SELECT2 select, lapack_int n, double* a,
+                          lapack_int lda, lapack_int* sdim, double* wr,
+                          double* wi, double* vs, lapack_int ldvs );
+lapack_int LAPACKE_cgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_C_SELECT1 select, lapack_int n,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_int* sdim, lapack_complex_float* w,
+                          lapack_complex_float* vs, lapack_int ldvs );
+lapack_int LAPACKE_zgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_Z_SELECT1 select, lapack_int n,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_int* sdim, lapack_complex_double* w,
+                          lapack_complex_double* vs, lapack_int ldvs );
+
+lapack_int LAPACKE_sgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_S_SELECT2 select, char sense, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* sdim,
+                           float* wr, float* wi, float* vs, lapack_int ldvs,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_dgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_D_SELECT2 select, char sense, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* sdim,
+                           double* wr, double* wi, double* vs, lapack_int ldvs,
+                           double* rconde, double* rcondv );
+lapack_int LAPACKE_cgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_C_SELECT1 select, char sense, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* sdim, lapack_complex_float* w,
+                           lapack_complex_float* vs, lapack_int ldvs,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_zgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_Z_SELECT1 select, char sense, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* sdim, lapack_complex_double* w,
+                           lapack_complex_double* vs, lapack_int ldvs,
+                           double* rconde, double* rcondv );
+
+lapack_int LAPACKE_sgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, float* a, lapack_int lda, float* wr,
+                          float* wi, float* vl, lapack_int ldvl, float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_dgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, double* a, lapack_int lda, double* wr,
+                          double* wi, double* vl, lapack_int ldvl, double* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_cgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* w, lapack_complex_float* vl,
+                          lapack_int ldvl, lapack_complex_float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_zgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* w,
+                          lapack_complex_double* vl, lapack_int ldvl,
+                          lapack_complex_double* vr, lapack_int ldvr );
+
+lapack_int LAPACKE_sgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, float* a,
+                           lapack_int lda, float* wr, float* wi, float* vl,
+                           lapack_int ldvl, float* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, float* scale,
+                           float* abnrm, float* rconde, float* rcondv );
+lapack_int LAPACKE_dgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, double* a,
+                           lapack_int lda, double* wr, double* wi, double* vl,
+                           lapack_int ldvl, double* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, double* scale,
+                           double* abnrm, double* rconde, double* rcondv );
+lapack_int LAPACKE_cgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* w, lapack_complex_float* vl,
+                           lapack_int ldvl, lapack_complex_float* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           float* scale, float* abnrm, float* rconde,
+                           float* rcondv );
+lapack_int LAPACKE_zgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* w, lapack_complex_double* vl,
+                           lapack_int ldvl, lapack_complex_double* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           double* scale, double* abnrm, double* rconde,
+                           double* rcondv );
+
+lapack_int LAPACKE_sgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, float* a, lapack_int lda,
+                           float* tau );
+lapack_int LAPACKE_dgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, double* a, lapack_int lda,
+                           double* tau );
+lapack_int LAPACKE_cgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* tau );
+lapack_int LAPACKE_zgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgejsv( int matrix_order, char joba, char jobu, char jobv,
+                           char jobr, char jobt, char jobp, lapack_int m,
+                           lapack_int n, float* a, lapack_int lda, float* sva,
+                           float* u, lapack_int ldu, float* v, lapack_int ldv,
+                           float* stat, lapack_int* istat );
+lapack_int LAPACKE_dgejsv( int matrix_order, char joba, char jobu, char jobv,
+                           char jobr, char jobt, char jobp, lapack_int m,
+                           lapack_int n, double* a, lapack_int lda, double* sva,
+                           double* u, lapack_int ldu, double* v, lapack_int ldv,
+                           double* stat, lapack_int* istat );
+
+lapack_int LAPACKE_sgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs, float* a,
+                          lapack_int lda, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs, double* a,
+                          lapack_int lda, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_dgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_cgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_zgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+
+lapack_int LAPACKE_sgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_dgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_cgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_zgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+
+lapack_int LAPACKE_sgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, lapack_int* jpvt, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_dgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, lapack_int* jpvt,
+                           double rcond, lapack_int* rank );
+lapack_int LAPACKE_cgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_int* jpvt, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_zgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_int* jpvt, double rcond,
+                           lapack_int* rank );
+
+lapack_int LAPACKE_sgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* jpvt,
+                           float* tau );
+lapack_int LAPACKE_dgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* jpvt,
+                           double* tau );
+lapack_int LAPACKE_cgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* jpvt,
+                           float* tau );
+lapack_int LAPACKE_dgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* jpvt,
+                           double* tau );
+lapack_int LAPACKE_cgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const float* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const double* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs, const float* a,
+                            lapack_int lda, const float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* r,
+                            const float* c, const float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs, const double* a,
+                            lapack_int lda, const double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* r,
+                            const double* c, const double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* r,
+                            const float* c, const lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* r,
+                            const double* c, const lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_sgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, float* a, lapack_int lda, float* s,
+                           float* u, lapack_int ldu, float* vt,
+                           lapack_int ldvt );
+lapack_int LAPACKE_dgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, double* a, lapack_int lda, double* s,
+                           double* u, lapack_int ldu, double* vt,
+                           lapack_int ldvt );
+lapack_int LAPACKE_cgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float* s, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* vt,
+                           lapack_int ldvt );
+lapack_int LAPACKE_zgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double* s, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* vt,
+                           lapack_int ldvt );
+
+lapack_int LAPACKE_sgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* a, lapack_int lda, lapack_int* ipiv, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* a, lapack_int lda, lapack_int* ipiv,
+                          double* b, lapack_int ldb );
+lapack_int LAPACKE_cgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dsgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                           double* a, lapack_int lda, lapack_int* ipiv,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           lapack_int* iter );
+lapack_int LAPACKE_zcgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, lapack_int* iter );
+
+lapack_int LAPACKE_sgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, float* a, lapack_int lda,
+                           float* s, float* u, lapack_int ldu, float* vt,
+                           lapack_int ldvt, float* superb );
+lapack_int LAPACKE_dgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, double* a,
+                           lapack_int lda, double* s, double* u, lapack_int ldu,
+                           double* vt, lapack_int ldvt, double* superb );
+lapack_int LAPACKE_cgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float* s, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* vt,
+                           lapack_int ldvt, float* superb );
+lapack_int LAPACKE_zgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double* s, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* vt,
+                           lapack_int ldvt, double* superb );
+
+lapack_int LAPACKE_sgesvj( int matrix_order, char joba, char jobu, char jobv,
+                           lapack_int m, lapack_int n, float* a, lapack_int lda,
+                           float* sva, lapack_int mv, float* v, lapack_int ldv,
+                           float* stat );
+lapack_int LAPACKE_dgesvj( int matrix_order, char joba, char jobu, char jobv,
+                           lapack_int m, lapack_int n, double* a,
+                           lapack_int lda, double* sva, lapack_int mv,
+                           double* v, lapack_int ldv, double* stat );
+
+lapack_int LAPACKE_sgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, float* a,
+                           lapack_int lda, float* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, float* r, float* c,
+                           float* b, lapack_int ldb, float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr,
+                           float* rpivot );
+lapack_int LAPACKE_dgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, double* a,
+                           lapack_int lda, double* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, double* r, double* c,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr,
+                           double* rpivot );
+lapack_int LAPACKE_cgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, float* r, float* c,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr,
+                           float* rpivot );
+lapack_int LAPACKE_zgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, double* r, double* c,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr,
+                           double* rpivot );
+
+lapack_int LAPACKE_sgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs, float* a,
+                            lapack_int lda, float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* r, float* c,
+                            float* b, lapack_int ldb, float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs, double* a,
+                            lapack_int lda, double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* r, double* c,
+                            double* b, lapack_int ldb, double* x,
+                            lapack_int ldx, double* rcond, double* rpvgrw,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* r, float* c,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* r, double* c,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_sgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetri( int matrix_order, lapack_int n, float* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dgetri( int matrix_order, lapack_int n, double* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_cgetri( int matrix_order, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_zgetri( int matrix_order, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* lscale,
+                           const float* rscale, lapack_int m, float* v,
+                           lapack_int ldv );
+lapack_int LAPACKE_dggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* lscale,
+                           const double* rscale, lapack_int m, double* v,
+                           lapack_int ldv );
+lapack_int LAPACKE_cggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* lscale,
+                           const float* rscale, lapack_int m,
+                           lapack_complex_float* v, lapack_int ldv );
+lapack_int LAPACKE_zggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* lscale,
+                           const double* rscale, lapack_int m,
+                           lapack_complex_double* v, lapack_int ldv );
+
+lapack_int LAPACKE_sggbal( int matrix_order, char job, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, float* lscale,
+                           float* rscale );
+lapack_int LAPACKE_dggbal( int matrix_order, char job, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, double* lscale,
+                           double* rscale );
+lapack_int LAPACKE_cggbal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, float* lscale,
+                           float* rscale );
+lapack_int LAPACKE_zggbal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, double* lscale,
+                           double* rscale );
+
+lapack_int LAPACKE_sgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_S_SELECT3 selctg, lapack_int n, float* a,
+                          lapack_int lda, float* b, lapack_int ldb,
+                          lapack_int* sdim, float* alphar, float* alphai,
+                          float* beta, float* vsl, lapack_int ldvsl, float* vsr,
+                          lapack_int ldvsr );
+lapack_int LAPACKE_dgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_D_SELECT3 selctg, lapack_int n, double* a,
+                          lapack_int lda, double* b, lapack_int ldb,
+                          lapack_int* sdim, double* alphar, double* alphai,
+                          double* beta, double* vsl, lapack_int ldvsl,
+                          double* vsr, lapack_int ldvsr );
+lapack_int LAPACKE_cgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_C_SELECT2 selctg, lapack_int n,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* b, lapack_int ldb,
+                          lapack_int* sdim, lapack_complex_float* alpha,
+                          lapack_complex_float* beta, lapack_complex_float* vsl,
+                          lapack_int ldvsl, lapack_complex_float* vsr,
+                          lapack_int ldvsr );
+lapack_int LAPACKE_zgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_Z_SELECT2 selctg, lapack_int n,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_complex_double* b, lapack_int ldb,
+                          lapack_int* sdim, lapack_complex_double* alpha,
+                          lapack_complex_double* beta,
+                          lapack_complex_double* vsl, lapack_int ldvsl,
+                          lapack_complex_double* vsr, lapack_int ldvsr );
+
+lapack_int LAPACKE_sggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_S_SELECT3 selctg, char sense,
+                           lapack_int n, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, lapack_int* sdim, float* alphar,
+                           float* alphai, float* beta, float* vsl,
+                           lapack_int ldvsl, float* vsr, lapack_int ldvsr,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_dggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_D_SELECT3 selctg, char sense,
+                           lapack_int n, double* a, lapack_int lda, double* b,
+                           lapack_int ldb, lapack_int* sdim, double* alphar,
+                           double* alphai, double* beta, double* vsl,
+                           lapack_int ldvsl, double* vsr, lapack_int ldvsr,
+                           double* rconde, double* rcondv );
+lapack_int LAPACKE_cggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_C_SELECT2 selctg, char sense,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_int* sdim,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta,
+                           lapack_complex_float* vsl, lapack_int ldvsl,
+                           lapack_complex_float* vsr, lapack_int ldvsr,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_zggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_Z_SELECT2 selctg, char sense,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_int* sdim,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* vsl, lapack_int ldvsl,
+                           lapack_complex_double* vsr, lapack_int ldvsr,
+                           double* rconde, double* rcondv );
+
+lapack_int LAPACKE_sggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, float* a, lapack_int lda, float* b,
+                          lapack_int ldb, float* alphar, float* alphai,
+                          float* beta, float* vl, lapack_int ldvl, float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_dggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, double* a, lapack_int lda, double* b,
+                          lapack_int ldb, double* alphar, double* alphai,
+                          double* beta, double* vl, lapack_int ldvl, double* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_cggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* b, lapack_int ldb,
+                          lapack_complex_float* alpha,
+                          lapack_complex_float* beta, lapack_complex_float* vl,
+                          lapack_int ldvl, lapack_complex_float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_zggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* b,
+                          lapack_int ldb, lapack_complex_double* alpha,
+                          lapack_complex_double* beta,
+                          lapack_complex_double* vl, lapack_int ldvl,
+                          lapack_complex_double* vr, lapack_int ldvr );
+
+lapack_int LAPACKE_sggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           float* alphar, float* alphai, float* beta, float* vl,
+                           lapack_int ldvl, float* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, float* lscale,
+                           float* rscale, float* abnrm, float* bbnrm,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_dggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double* alphar, double* alphai, double* beta,
+                           double* vl, lapack_int ldvl, double* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           double* lscale, double* rscale, double* abnrm,
+                           double* bbnrm, double* rconde, double* rcondv );
+lapack_int LAPACKE_cggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta, lapack_complex_float* vl,
+                           lapack_int ldvl, lapack_complex_float* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           float* lscale, float* rscale, float* abnrm,
+                           float* bbnrm, float* rconde, float* rcondv );
+lapack_int LAPACKE_zggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* vl, lapack_int ldvl,
+                           lapack_complex_double* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, double* lscale,
+                           double* rscale, double* abnrm, double* bbnrm,
+                           double* rconde, double* rcondv );
+
+lapack_int LAPACKE_sggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* d, float* x, float* y );
+lapack_int LAPACKE_dggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, double* a, lapack_int lda, double* b,
+                           lapack_int ldb, double* d, double* x, double* y );
+lapack_int LAPACKE_cggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* d,
+                           lapack_complex_float* x, lapack_complex_float* y );
+lapack_int LAPACKE_zggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* d,
+                           lapack_complex_double* x, lapack_complex_double* y );
+
+lapack_int LAPACKE_sgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           float* a, lapack_int lda, float* b, lapack_int ldb,
+                           float* q, lapack_int ldq, float* z, lapack_int ldz );
+lapack_int LAPACKE_dgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           double* a, lapack_int lda, double* b, lapack_int ldb,
+                           double* q, lapack_int ldq, double* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_cgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* c, float* d, float* x );
+lapack_int LAPACKE_dgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, double* a, lapack_int lda, double* b,
+                           lapack_int ldb, double* c, double* d, double* x );
+lapack_int LAPACKE_cgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* c,
+                           lapack_complex_float* d, lapack_complex_float* x );
+lapack_int LAPACKE_zgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* c,
+                           lapack_complex_double* d, lapack_complex_double* x );
+
+lapack_int LAPACKE_sggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, float* a, lapack_int lda, float* taua,
+                           float* b, lapack_int ldb, float* taub );
+lapack_int LAPACKE_dggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, double* a, lapack_int lda,
+                           double* taua, double* b, lapack_int ldb,
+                           double* taub );
+lapack_int LAPACKE_cggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* taua,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* taub );
+lapack_int LAPACKE_zggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* taua,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* taub );
+
+lapack_int LAPACKE_sggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, float* a, lapack_int lda, float* taua,
+                           float* b, lapack_int ldb, float* taub );
+lapack_int LAPACKE_dggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, double* a, lapack_int lda,
+                           double* taua, double* b, lapack_int ldb,
+                           double* taub );
+lapack_int LAPACKE_cggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* taua,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* taub );
+lapack_int LAPACKE_zggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* taua,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* taub );
+
+lapack_int LAPACKE_sggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           float* alpha, float* beta, float* u, lapack_int ldu,
+                           float* v, lapack_int ldv, float* q, lapack_int ldq,
+                           lapack_int* iwork );
+lapack_int LAPACKE_dggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double* alpha, double* beta, double* u,
+                           lapack_int ldu, double* v, lapack_int ldv, double* q,
+                           lapack_int ldq, lapack_int* iwork );
+lapack_int LAPACKE_cggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           float* alpha, float* beta, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* v,
+                           lapack_int ldv, lapack_complex_float* q,
+                           lapack_int ldq, lapack_int* iwork );
+lapack_int LAPACKE_zggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           double* alpha, double* beta,
+                           lapack_complex_double* u, lapack_int ldu,
+                           lapack_complex_double* v, lapack_int ldv,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_int* iwork );
+
+lapack_int LAPACKE_sggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb, float tola,
+                           float tolb, lapack_int* k, lapack_int* l, float* u,
+                           lapack_int ldu, float* v, lapack_int ldv, float* q,
+                           lapack_int ldq );
+lapack_int LAPACKE_dggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double tola, double tolb, lapack_int* k,
+                           lapack_int* l, double* u, lapack_int ldu, double* v,
+                           lapack_int ldv, double* q, lapack_int ldq );
+lapack_int LAPACKE_cggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb, float tola,
+                           float tolb, lapack_int* k, lapack_int* l,
+                           lapack_complex_float* u, lapack_int ldu,
+                           lapack_complex_float* v, lapack_int ldv,
+                           lapack_complex_float* q, lapack_int ldq );
+lapack_int LAPACKE_zggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           double tola, double tolb, lapack_int* k,
+                           lapack_int* l, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* v,
+                           lapack_int ldv, lapack_complex_double* q,
+                           lapack_int ldq );
+
+lapack_int LAPACKE_sgtcon( char norm, lapack_int n, const float* dl,
+                           const float* d, const float* du, const float* du2,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_dgtcon( char norm, lapack_int n, const double* dl,
+                           const double* d, const double* du, const double* du2,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_cgtcon( char norm, lapack_int n,
+                           const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           const lapack_complex_float* du2,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zgtcon( char norm, lapack_int n,
+                           const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           const lapack_complex_double* du2,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* dl, const float* d,
+                           const float* du, const float* dlf, const float* df,
+                           const float* duf, const float* du2,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* dl, const double* d,
+                           const double* du, const double* dlf,
+                           const double* df, const double* duf,
+                           const double* du2, const lapack_int* ipiv,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           const lapack_complex_float* dlf,
+                           const lapack_complex_float* df,
+                           const lapack_complex_float* duf,
+                           const lapack_complex_float* du2,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           const lapack_complex_double* dlf,
+                           const lapack_complex_double* df,
+                           const lapack_complex_double* duf,
+                           const lapack_complex_double* du2,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* dl, float* d, float* du, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* dl, double* d, double* du, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_float* dl, lapack_complex_float* d,
+                          lapack_complex_float* du, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_double* dl, lapack_complex_double* d,
+                          lapack_complex_double* du, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_sgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, const float* dl,
+                           const float* d, const float* du, float* dlf,
+                           float* df, float* duf, float* du2, lapack_int* ipiv,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, const double* dl,
+                           const double* d, const double* du, double* dlf,
+                           double* df, double* duf, double* du2,
+                           lapack_int* ipiv, const double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           lapack_complex_float* dlf, lapack_complex_float* df,
+                           lapack_complex_float* duf, lapack_complex_float* du2,
+                           lapack_int* ipiv, const lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           lapack_complex_double* dlf,
+                           lapack_complex_double* df,
+                           lapack_complex_double* duf,
+                           lapack_complex_double* du2, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_sgttrf( lapack_int n, float* dl, float* d, float* du,
+                           float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_dgttrf( lapack_int n, double* dl, double* d, double* du,
+                           double* du2, lapack_int* ipiv );
+lapack_int LAPACKE_cgttrf( lapack_int n, lapack_complex_float* dl,
+                           lapack_complex_float* d, lapack_complex_float* du,
+                           lapack_complex_float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_zgttrf( lapack_int n, lapack_complex_double* dl,
+                           lapack_complex_double* d, lapack_complex_double* du,
+                           lapack_complex_double* du2, lapack_int* ipiv );
+
+lapack_int LAPACKE_sgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* dl, const float* d,
+                           const float* du, const float* du2,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* dl, const double* d,
+                           const double* du, const double* du2,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           const lapack_complex_float* du2,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           const lapack_complex_double* du2,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_chbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, lapack_complex_float* ab,
+                          lapack_int ldab, float* w, lapack_complex_float* z,
+                          lapack_int ldz );
+lapack_int LAPACKE_zhbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, lapack_complex_double* ab,
+                          lapack_int ldab, double* w, lapack_complex_double* z,
+                          lapack_int ldz );
+
+lapack_int LAPACKE_chbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_float* ab,
+                           lapack_int ldab, float* w, lapack_complex_float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_zhbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_double* ab,
+                           lapack_int ldab, double* w, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_chbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* q, lapack_int ldq, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* bb, lapack_int ldbb,
+                           lapack_complex_float* x, lapack_int ldx );
+lapack_int LAPACKE_zhbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* bb, lapack_int ldbb,
+                           lapack_complex_double* x, lapack_int ldx );
+
+lapack_int LAPACKE_chbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb,
+                          lapack_complex_float* ab, lapack_int ldab,
+                          lapack_complex_float* bb, lapack_int ldbb, float* w,
+                          lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb,
+                          lapack_complex_double* ab, lapack_int ldab,
+                          lapack_complex_double* bb, lapack_int ldbb, double* w,
+                          lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* bb, lapack_int ldbb, float* w,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* bb, lapack_int ldbb,
+                           double* w, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_chbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* bb, lapack_int ldbb,
+                           lapack_complex_float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* bb, lapack_int ldbb,
+                           lapack_complex_double* q, lapack_int ldq, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_float* ab,
+                           lapack_int ldab, float* d, float* e,
+                           lapack_complex_float* q, lapack_int ldq );
+lapack_int LAPACKE_zhbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_double* ab,
+                           lapack_int ldab, double* d, double* e,
+                           lapack_complex_double* q, lapack_int ldq );
+
+lapack_int LAPACKE_checon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zhecon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_cheequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* s, float* scond, float* amax );
+lapack_int LAPACKE_zheequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_cheev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_zheev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_double* a, lapack_int lda, double* w );
+
+lapack_int LAPACKE_cheevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_zheevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           double* w );
+
+lapack_int LAPACKE_cheevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float vl, float vu, lapack_int il,
+                           lapack_int iu, float abstol, lapack_int* m, float* w,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_zheevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double vl, double vu, lapack_int il,
+                           lapack_int iu, double abstol, lapack_int* m,
+                           double* w, lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* isuppz );
+
+lapack_int LAPACKE_cheevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float vl, float vu, lapack_int il,
+                           lapack_int iu, float abstol, lapack_int* m, float* w,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_zheevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double vl, double vu, lapack_int il,
+                           lapack_int iu, double abstol, lapack_int* m,
+                           double* w, lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chegst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zhegst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_chegv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_float* a,
+                          lapack_int lda, lapack_complex_float* b,
+                          lapack_int ldb, float* w );
+lapack_int LAPACKE_zhegv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* b,
+                          lapack_int ldb, double* w );
+
+lapack_int LAPACKE_chegvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float* w );
+lapack_int LAPACKE_zhegvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double* w );
+
+lapack_int LAPACKE_chegvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhegvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_cherfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zherfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_cherfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* s,
+                            const lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zherfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* s,
+                            const lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_chesv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zhesv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chesvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zhesvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_chesvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* s,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zhesvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* s,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_chetrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda, float* d,
+                           float* e, lapack_complex_float* tau );
+lapack_int LAPACKE_zhetrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda, double* d,
+                           double* e, lapack_complex_double* tau );
+
+lapack_int LAPACKE_chetrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zhetrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_chetri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_zhetri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv );
+
+lapack_int LAPACKE_chetrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zhetrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, float alpha,
+                          const lapack_complex_float* a, lapack_int lda,
+                          float beta, lapack_complex_float* c );
+lapack_int LAPACKE_zhfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, double alpha,
+                          const lapack_complex_double* a, lapack_int lda,
+                          double beta, lapack_complex_double* c );
+
+lapack_int LAPACKE_shgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           float* h, lapack_int ldh, float* t, lapack_int ldt,
+                           float* alphar, float* alphai, float* beta, float* q,
+                           lapack_int ldq, float* z, lapack_int ldz );
+lapack_int LAPACKE_dhgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           double* h, lapack_int ldh, double* t, lapack_int ldt,
+                           double* alphar, double* alphai, double* beta,
+                           double* q, lapack_int ldq, double* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_chgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_float* h, lapack_int ldh,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta, lapack_complex_float* q,
+                           lapack_int ldq, lapack_complex_float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_zhgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_double* h, lapack_int ldh,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zhpcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_chpev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_float* ap, float* w,
+                          lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_double* ap, double* w,
+                          lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_float* ap, float* w,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_double* ap, double* w,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_float* ap, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhpevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_double* ap, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chpgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_float* ap,
+                           const lapack_complex_float* bp );
+lapack_int LAPACKE_zhpgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_double* ap,
+                           const lapack_complex_double* bp );
+
+lapack_int LAPACKE_chpgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_float* ap,
+                          lapack_complex_float* bp, float* w,
+                          lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_double* ap,
+                          lapack_complex_double* bp, double* w,
+                          lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_float* ap,
+                           lapack_complex_float* bp, float* w,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_double* ap,
+                           lapack_complex_double* bp, double* w,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_float* ap, lapack_complex_float* bp,
+                           float vl, float vu, lapack_int il, lapack_int iu,
+                           float abstol, lapack_int* m, float* w,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_zhpgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_double* ap, lapack_complex_double* bp,
+                           double vl, double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_complex_float* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zhprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_complex_double* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_chpsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* ap,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zhpsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* ap,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_chpsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           lapack_complex_float* afp, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zhpsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           lapack_complex_double* afp, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_chptrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, float* d, float* e,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zhptrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, double* d, double* e,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_chptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zhptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_chptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, const lapack_int* ipiv );
+lapack_int LAPACKE_zhptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, const lapack_int* ipiv );
+
+lapack_int LAPACKE_chptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zhptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_shsein( int matrix_order, char job, char eigsrc, char initv,
+                           lapack_logical* select, lapack_int n, const float* h,
+                           lapack_int ldh, float* wr, const float* wi,
+                           float* vl, lapack_int ldvl, float* vr,
+                           lapack_int ldvr, lapack_int mm, lapack_int* m,
+                           lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_dhsein( int matrix_order, char job, char eigsrc, char initv,
+                           lapack_logical* select, lapack_int n,
+                           const double* h, lapack_int ldh, double* wr,
+                           const double* wi, double* vl, lapack_int ldvl,
+                           double* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m, lapack_int* ifaill,
+                           lapack_int* ifailr );
+lapack_int LAPACKE_chsein( int matrix_order, char job, char eigsrc, char initv,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* h, lapack_int ldh,
+                           lapack_complex_float* w, lapack_complex_float* vl,
+                           lapack_int ldvl, lapack_complex_float* vr,
+                           lapack_int ldvr, lapack_int mm, lapack_int* m,
+                           lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_zhsein( int matrix_order, char job, char eigsrc, char initv,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* h, lapack_int ldh,
+                           lapack_complex_double* w, lapack_complex_double* vl,
+                           lapack_int ldvl, lapack_complex_double* vr,
+                           lapack_int ldvr, lapack_int mm, lapack_int* m,
+                           lapack_int* ifaill, lapack_int* ifailr );
+
+lapack_int LAPACKE_shseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, float* h,
+                           lapack_int ldh, float* wr, float* wi, float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_dhseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, double* h,
+                           lapack_int ldh, double* wr, double* wi, double* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_chseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi,
+                           lapack_complex_float* h, lapack_int ldh,
+                           lapack_complex_float* w, lapack_complex_float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_zhseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi,
+                           lapack_complex_double* h, lapack_int ldh,
+                           lapack_complex_double* w, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_clacgv( lapack_int n, lapack_complex_float* x,
+                           lapack_int incx );
+lapack_int LAPACKE_zlacgv( lapack_int n, lapack_complex_double* x,
+                           lapack_int incx );
+
+lapack_int LAPACKE_slacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const float* a, lapack_int lda, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dlacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const double* a, lapack_int lda, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_clacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zlacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_zlag2c( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_float* sa, lapack_int ldsa );
+
+lapack_int LAPACKE_slag2d( int matrix_order, lapack_int m, lapack_int n,
+                           const float* sa, lapack_int ldsa, double* a,
+                           lapack_int lda );
+
+lapack_int LAPACKE_dlag2s( int matrix_order, lapack_int m, lapack_int n,
+                           const double* a, lapack_int lda, float* sa,
+                           lapack_int ldsa );
+
+lapack_int LAPACKE_clag2z( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_float* sa, lapack_int ldsa,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* d,
+                           float* a, lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_dlagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* d,
+                           double* a, lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_clagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* d,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* iseed );
+lapack_int LAPACKE_zlagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* d,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* iseed );
+
+float LAPACKE_slamch( char cmach );
+double LAPACKE_dlamch( char cmach );
+
+float LAPACKE_slange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const float* a, lapack_int lda );
+double LAPACKE_dlange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const double* a, lapack_int lda );
+float LAPACKE_clange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda );
+double LAPACKE_zlange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda );
+
+float LAPACKE_clanhe( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda );
+double LAPACKE_zlanhe( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda );
+
+float LAPACKE_slansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const float* a, lapack_int lda );
+double LAPACKE_dlansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const double* a, lapack_int lda );
+float LAPACKE_clansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda );
+double LAPACKE_zlansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda );
+
+float LAPACKE_slantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const float* a,
+                           lapack_int lda );
+double LAPACKE_dlantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const double* a,
+                           lapack_int lda );
+float LAPACKE_clantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda );
+double LAPACKE_zlantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda );
+
+
+lapack_int LAPACKE_slarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const float* v, lapack_int ldv,
+                           const float* t, lapack_int ldt, float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_dlarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const double* v, lapack_int ldv,
+                           const double* t, lapack_int ldt, double* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_clarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const lapack_complex_float* v,
+                           lapack_int ldv, const lapack_complex_float* t,
+                           lapack_int ldt, lapack_complex_float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_zlarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const lapack_complex_double* v,
+                           lapack_int ldv, const lapack_complex_double* t,
+                           lapack_int ldt, lapack_complex_double* c,
+                           lapack_int ldc );
+
+lapack_int LAPACKE_slarfg( lapack_int n, float* alpha, float* x,
+                           lapack_int incx, float* tau );
+lapack_int LAPACKE_dlarfg( lapack_int n, double* alpha, double* x,
+                           lapack_int incx, double* tau );
+lapack_int LAPACKE_clarfg( lapack_int n, lapack_complex_float* alpha,
+                           lapack_complex_float* x, lapack_int incx,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zlarfg( lapack_int n, lapack_complex_double* alpha,
+                           lapack_complex_double* x, lapack_int incx,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_slarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k, const float* v,
+                           lapack_int ldv, const float* tau, float* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_dlarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k, const double* v,
+                           lapack_int ldv, const double* tau, double* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_clarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k,
+                           const lapack_complex_float* v, lapack_int ldv,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zlarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k,
+                           const lapack_complex_double* v, lapack_int ldv,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_slarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const float* v, float tau, float* c,
+                           lapack_int ldc, float* work );
+lapack_int LAPACKE_dlarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const double* v, double tau, double* c,
+                           lapack_int ldc, double* work );
+lapack_int LAPACKE_clarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const lapack_complex_float* v,
+                           lapack_complex_float tau, lapack_complex_float* c,
+                           lapack_int ldc, lapack_complex_float* work );
+lapack_int LAPACKE_zlarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const lapack_complex_double* v,
+                           lapack_complex_double tau, lapack_complex_double* c,
+                           lapack_int ldc, lapack_complex_double* work );
+
+lapack_int LAPACKE_slarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           float* x );
+lapack_int LAPACKE_dlarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           double* x );
+lapack_int LAPACKE_clarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           lapack_complex_float* x );
+lapack_int LAPACKE_zlarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           lapack_complex_double* x );
+
+lapack_int LAPACKE_slaset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, float alpha, float beta, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dlaset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, double alpha, double beta, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_claset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, lapack_complex_float alpha,
+                           lapack_complex_float beta, lapack_complex_float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_zlaset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, lapack_complex_double alpha,
+                           lapack_complex_double beta, lapack_complex_double* a,
+                           lapack_int lda );
+
+lapack_int LAPACKE_slasrt( char id, lapack_int n, float* d );
+lapack_int LAPACKE_dlasrt( char id, lapack_int n, double* d );
+
+lapack_int LAPACKE_slaswp( int matrix_order, lapack_int n, float* a,
+                           lapack_int lda, lapack_int k1, lapack_int k2,
+                           const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_dlaswp( int matrix_order, lapack_int n, double* a,
+                           lapack_int lda, lapack_int k1, lapack_int k2,
+                           const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_claswp( int matrix_order, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int k1, lapack_int k2, const lapack_int* ipiv,
+                           lapack_int incx );
+lapack_int LAPACKE_zlaswp( int matrix_order, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int k1, lapack_int k2, const lapack_int* ipiv,
+                           lapack_int incx );
+
+lapack_int LAPACKE_slatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, float* d,
+                           lapack_int mode, float cond, float dmax,
+                           lapack_int kl, lapack_int ku, char pack, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dlatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, double* d,
+                           lapack_int mode, double cond, double dmax,
+                           lapack_int kl, lapack_int ku, char pack, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_clatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, float* d,
+                           lapack_int mode, float cond, float dmax,
+                           lapack_int kl, lapack_int ku, char pack,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, double* d,
+                           lapack_int mode, double cond, double dmax,
+                           lapack_int kl, lapack_int ku, char pack,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slauum( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dlauum( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_clauum( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlauum( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_sopgtr( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, const float* tau, float* q,
+                           lapack_int ldq );
+lapack_int LAPACKE_dopgtr( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, const double* tau, double* q,
+                           lapack_int ldq );
+
+lapack_int LAPACKE_sopmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const float* ap,
+                           const float* tau, float* c, lapack_int ldc );
+lapack_int LAPACKE_dopmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const double* ap,
+                           const double* tau, double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sorgbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, double* a,
+                           lapack_int lda, const double* tau );
+
+lapack_int LAPACKE_sorghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgtr( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, const float* tau );
+lapack_int LAPACKE_dorgtr( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, const double* tau );
+
+lapack_int LAPACKE_sormbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const float* a, lapack_int lda,
+                           const float* tau, float* c, lapack_int ldc );
+lapack_int LAPACKE_dormhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const double* a, lapack_int lda,
+                           const double* tau, double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const float* a, lapack_int lda,
+                           const float* tau, float* c, lapack_int ldc );
+lapack_int LAPACKE_dormrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const double* a, lapack_int lda,
+                           const double* tau, double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const float* a,
+                           lapack_int lda, const float* tau, float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_dormtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const double* a,
+                           lapack_int lda, const double* tau, double* c,
+                           lapack_int ldc );
+
+lapack_int LAPACKE_spbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const float* ab, lapack_int ldab,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_dpbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const double* ab, lapack_int ldab,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cpbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_float* ab,
+                           lapack_int ldab, float anorm, float* rcond );
+lapack_int LAPACKE_zpbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_double* ab,
+                           lapack_int ldab, double anorm, double* rcond );
+
+lapack_int LAPACKE_spbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const float* ab, lapack_int ldab,
+                           float* s, float* scond, float* amax );
+lapack_int LAPACKE_dpbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const double* ab, lapack_int ldab,
+                           double* s, double* scond, double* amax );
+lapack_int LAPACKE_cpbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_float* ab,
+                           lapack_int ldab, float* s, float* scond,
+                           float* amax );
+lapack_int LAPACKE_zpbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_double* ab,
+                           lapack_int ldab, double* s, double* scond,
+                           double* amax );
+
+lapack_int LAPACKE_spbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const float* ab,
+                           lapack_int ldab, const float* afb, lapack_int ldafb,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dpbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const double* ab,
+                           lapack_int ldab, const double* afb, lapack_int ldafb,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cpbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* afb, lapack_int ldafb,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zpbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* afb, lapack_int ldafb,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_spbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, float* bb, lapack_int ldbb );
+lapack_int LAPACKE_dpbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, double* bb, lapack_int ldbb );
+lapack_int LAPACKE_cpbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, lapack_complex_float* bb,
+                           lapack_int ldbb );
+lapack_int LAPACKE_zpbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, lapack_complex_double* bb,
+                           lapack_int ldbb );
+
+lapack_int LAPACKE_spbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs, float* ab,
+                          lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs, double* ab,
+                          lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs,
+                          lapack_complex_float* ab, lapack_int ldab,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs,
+                          lapack_complex_double* ab, lapack_int ldab,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, float* ab,
+                           lapack_int ldab, float* afb, lapack_int ldafb,
+                           char* equed, float* s, float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, double* ab,
+                           lapack_int ldab, double* afb, lapack_int ldafb,
+                           char* equed, double* s, double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* afb, lapack_int ldafb,
+                           char* equed, float* s, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* afb, lapack_int ldafb,
+                           char* equed, double* s, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, double* rcond, double* ferr,
+                           double* berr );
+
+lapack_int LAPACKE_spbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, float* ab, lapack_int ldab );
+lapack_int LAPACKE_dpbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, double* ab, lapack_int ldab );
+lapack_int LAPACKE_cpbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_float* ab,
+                           lapack_int ldab );
+lapack_int LAPACKE_zpbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_double* ab,
+                           lapack_int ldab );
+
+lapack_int LAPACKE_spbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const float* ab,
+                           lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const double* ab,
+                           lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, float* a );
+lapack_int LAPACKE_dpftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, double* a );
+lapack_int LAPACKE_cpftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, float* a );
+lapack_int LAPACKE_dpftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, double* a );
+lapack_int LAPACKE_cpftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs, const float* a,
+                           float* b, lapack_int ldb );
+lapack_int LAPACKE_dpftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs, const double* a,
+                           double* b, lapack_int ldb );
+lapack_int LAPACKE_cpftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* a,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* a,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spocon( int matrix_order, char uplo, lapack_int n,
+                           const float* a, lapack_int lda, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dpocon( int matrix_order, char uplo, lapack_int n,
+                           const double* a, lapack_int lda, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_cpocon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_zpocon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double anorm, double* rcond );
+
+lapack_int LAPACKE_spoequ( int matrix_order, lapack_int n, const float* a,
+                           lapack_int lda, float* s, float* scond,
+                           float* amax );
+lapack_int LAPACKE_dpoequ( int matrix_order, lapack_int n, const double* a,
+                           lapack_int lda, double* s, double* scond,
+                           double* amax );
+lapack_int LAPACKE_cpoequ( int matrix_order, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequ( int matrix_order, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_spoequb( int matrix_order, lapack_int n, const float* a,
+                            lapack_int lda, float* s, float* scond,
+                            float* amax );
+lapack_int LAPACKE_dpoequb( int matrix_order, lapack_int n, const double* a,
+                            lapack_int lda, double* s, double* scond,
+                            double* amax );
+lapack_int LAPACKE_cpoequb( int matrix_order, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequb( int matrix_order, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_sporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const float* af, lapack_int ldaf, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const double* af, lapack_int ldaf, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_zporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+
+lapack_int LAPACKE_sporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const float* a,
+                            lapack_int lda, const float* af, lapack_int ldaf,
+                            const float* s, const float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const double* a,
+                            lapack_int lda, const double* af, lapack_int ldaf,
+                            const double* s, const double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const float* s, const lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const double* s, const lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_sposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* a, lapack_int lda, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* a, lapack_int lda, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* a,
+                          lapack_int lda, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dsposv( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           lapack_int* iter );
+lapack_int LAPACKE_zcposv( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, lapack_int* iter );
+
+lapack_int LAPACKE_sposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* af,
+                           lapack_int ldaf, char* equed, float* s, float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_dposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* af, lapack_int ldaf, char* equed, double* s,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+lapack_int LAPACKE_cposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* af,
+                           lapack_int ldaf, char* equed, float* s,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* af,
+                           lapack_int ldaf, char* equed, double* s,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_sposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, float* a,
+                            lapack_int lda, float* af, lapack_int ldaf,
+                            char* equed, float* s, float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond,
+                            float* rpvgrw, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_dposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, double* a,
+                            lapack_int lda, double* af, lapack_int ldaf,
+                            char* equed, double* s, double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* rpvgrw, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            char* equed, float* s, lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* rpvgrw,
+                            float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            char* equed, double* s, lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* rpvgrw,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_spotrf( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dpotrf( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_cpotrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotri( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dpotri( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_cpotri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           float* b, lapack_int ldb );
+lapack_int LAPACKE_dpotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           double* b, lapack_int ldb );
+lapack_int LAPACKE_cpotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zpotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_sppcon( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, float anorm, float* rcond );
+lapack_int LAPACKE_dppcon( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, double anorm, double* rcond );
+lapack_int LAPACKE_cppcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_zppcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sppequ( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, float* s, float* scond,
+                           float* amax );
+lapack_int LAPACKE_dppequ( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, double* s, double* scond,
+                           double* amax );
+lapack_int LAPACKE_cppequ( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap, float* s,
+                           float* scond, float* amax );
+lapack_int LAPACKE_zppequ( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap, double* s,
+                           double* scond, double* amax );
+
+lapack_int LAPACKE_spprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, const float* afp,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dpprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, const double* afp,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cpprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_complex_float* afp,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zpprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_complex_double* afp,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* ap, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* ap, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* ap,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* ap,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, float* ap, float* afp, char* equed,
+                           float* s, float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, double* ap, double* afp,
+                           char* equed, double* s, double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* ap,
+                           lapack_complex_float* afp, char* equed, float* s,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* ap,
+                           lapack_complex_double* afp, char* equed, double* s,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_spptrf( int matrix_order, char uplo, lapack_int n,
+                           float* ap );
+lapack_int LAPACKE_dpptrf( int matrix_order, char uplo, lapack_int n,
+                           double* ap );
+lapack_int LAPACKE_cpptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_zpptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptri( int matrix_order, char uplo, lapack_int n,
+                           float* ap );
+lapack_int LAPACKE_dpptri( int matrix_order, char uplo, lapack_int n,
+                           double* ap );
+lapack_int LAPACKE_cpptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_zpptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dpptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_cpptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spstrf( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, lapack_int* piv, lapack_int* rank,
+                           float tol );
+lapack_int LAPACKE_dpstrf( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, lapack_int* piv, lapack_int* rank,
+                           double tol );
+lapack_int LAPACKE_cpstrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* piv, lapack_int* rank, float tol );
+lapack_int LAPACKE_zpstrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* piv, lapack_int* rank, double tol );
+
+lapack_int LAPACKE_sptcon( lapack_int n, const float* d, const float* e,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_dptcon( lapack_int n, const double* d, const double* e,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cptcon( lapack_int n, const float* d,
+                           const lapack_complex_float* e, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_zptcon( lapack_int n, const double* d,
+                           const lapack_complex_double* e, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_spteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dpteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, double* z, lapack_int ldz );
+lapack_int LAPACKE_cpteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zpteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_sptrfs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const float* d, const float* e, const float* df,
+                           const float* ef, const float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dptrfs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const double* d, const double* e, const double* df,
+                           const double* ef, const double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* ferr,
+                           double* berr );
+lapack_int LAPACKE_cptrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* d,
+                           const lapack_complex_float* e, const float* df,
+                           const lapack_complex_float* ef,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zptrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* d,
+                           const lapack_complex_double* e, const double* df,
+                           const lapack_complex_double* ef,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* d, float* e, float* b, lapack_int ldb );
+lapack_int LAPACKE_dptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* d, double* e, double* b, lapack_int ldb );
+lapack_int LAPACKE_cptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* d, lapack_complex_float* e,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* d, lapack_complex_double* e,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const float* d, const float* e,
+                           float* df, float* ef, const float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const double* d, const double* e,
+                           double* df, double* ef, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+lapack_int LAPACKE_cptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const float* d,
+                           const lapack_complex_float* e, float* df,
+                           lapack_complex_float* ef,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const double* d,
+                           const lapack_complex_double* e, double* df,
+                           lapack_complex_double* ef,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_spttrf( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dpttrf( lapack_int n, double* d, double* e );
+lapack_int LAPACKE_cpttrf( lapack_int n, float* d, lapack_complex_float* e );
+lapack_int LAPACKE_zpttrf( lapack_int n, double* d, lapack_complex_double* e );
+
+lapack_int LAPACKE_spttrs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const float* d, const float* e, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dpttrs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const double* d, const double* e, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_cpttrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* d,
+                           const lapack_complex_float* e,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpttrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* d,
+                           const lapack_complex_double* e,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, float* ab, lapack_int ldab, float* w,
+                          float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, double* ab, lapack_int ldab, double* w,
+                          double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, float* ab, lapack_int ldab, float* w,
+                           float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, double* ab, lapack_int ldab,
+                           double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd, float* ab,
+                           lapack_int ldab, float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd, double* ab,
+                           lapack_int ldab, double* q, lapack_int ldq,
+                           double vl, double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, float* ab,
+                           lapack_int ldab, const float* bb, lapack_int ldbb,
+                           float* x, lapack_int ldx );
+lapack_int LAPACKE_dsbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, double* ab,
+                           lapack_int ldab, const double* bb, lapack_int ldbb,
+                           double* x, lapack_int ldx );
+
+lapack_int LAPACKE_ssbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb, float* ab,
+                          lapack_int ldab, float* bb, lapack_int ldbb, float* w,
+                          float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb, double* ab,
+                          lapack_int ldab, double* bb, lapack_int ldbb,
+                          double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, float* ab,
+                           lapack_int ldab, float* bb, lapack_int ldbb,
+                           float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, double* ab,
+                           lapack_int ldab, double* bb, lapack_int ldbb,
+                           double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           float* ab, lapack_int ldab, float* bb,
+                           lapack_int ldbb, float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           double* ab, lapack_int ldab, double* bb,
+                           lapack_int ldbb, double* q, lapack_int ldq,
+                           double vl, double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, float* ab, lapack_int ldab, float* d,
+                           float* e, float* q, lapack_int ldq );
+lapack_int LAPACKE_dsbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, double* ab, lapack_int ldab,
+                           double* d, double* e, double* q, lapack_int ldq );
+
+lapack_int LAPACKE_ssfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, float alpha,
+                          const float* a, lapack_int lda, float beta,
+                          float* c );
+lapack_int LAPACKE_dsfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, double alpha,
+                          const double* a, lapack_int lda, double beta,
+                          double* c );
+
+lapack_int LAPACKE_sspcon( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, const lapack_int* ipiv, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dspcon( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, const lapack_int* ipiv,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cspcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zspcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sspev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          float* ap, float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          double* ap, double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           float* ap, float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           double* ap, double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, float* ap, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dspevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, double* ap, double vl, double vu,
+                           lapack_int il, lapack_int iu, double abstol,
+                           lapack_int* m, double* w, double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_sspgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, float* ap, const float* bp );
+lapack_int LAPACKE_dspgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, double* ap, const double* bp );
+
+lapack_int LAPACKE_sspgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, float* ap, float* bp,
+                          float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, double* ap, double* bp,
+                          double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, float* ap, float* bp,
+                           float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, double* ap, double* bp,
+                           double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, float* ap,
+                           float* bp, float vl, float vu, lapack_int il,
+                           lapack_int iu, float abstol, lapack_int* m, float* w,
+                           float* z, lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_dspgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, double* ap,
+                           double* bp, double vl, double vu, lapack_int il,
+                           lapack_int iu, double abstol, lapack_int* m,
+                           double* w, double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_ssprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, const float* afp,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dsprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, const double* afp,
+                           const lapack_int* ipiv, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_csprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_complex_float* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zsprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_complex_double* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* ap, lapack_int* ipiv,
+                          float* b, lapack_int ldb );
+lapack_int LAPACKE_dspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* ap, lapack_int* ipiv,
+                          double* b, lapack_int ldb );
+lapack_int LAPACKE_cspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* ap,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* ap,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_sspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, float* afp,
+                           lapack_int* ipiv, const float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, double* afp,
+                           lapack_int* ipiv, const double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           lapack_complex_float* afp, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           lapack_complex_double* afp, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_ssptrd( int matrix_order, char uplo, lapack_int n, float* ap,
+                           float* d, float* e, float* tau );
+lapack_int LAPACKE_dsptrd( int matrix_order, char uplo, lapack_int n,
+                           double* ap, double* d, double* e, double* tau );
+
+lapack_int LAPACKE_ssptrf( int matrix_order, char uplo, lapack_int n, float* ap,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_dsptrf( int matrix_order, char uplo, lapack_int n,
+                           double* ap, lapack_int* ipiv );
+lapack_int LAPACKE_csptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zsptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_ssptri( int matrix_order, char uplo, lapack_int n, float* ap,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_dsptri( int matrix_order, char uplo, lapack_int n,
+                           double* ap, const lapack_int* ipiv );
+lapack_int LAPACKE_csptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, const lapack_int* ipiv );
+lapack_int LAPACKE_zsptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, const lapack_int* ipiv );
+
+lapack_int LAPACKE_ssptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dsptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_csptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zsptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_sstebz( char range, char order, lapack_int n, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           const float* d, const float* e, lapack_int* m,
+                           lapack_int* nsplit, float* w, lapack_int* iblock,
+                           lapack_int* isplit );
+lapack_int LAPACKE_dstebz( char range, char order, lapack_int n, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, const double* d, const double* e,
+                           lapack_int* m, lapack_int* nsplit, double* w,
+                           lapack_int* iblock, lapack_int* isplit );
+
+lapack_int LAPACKE_sstedc( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dstedc( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, double* z, lapack_int ldz );
+lapack_int LAPACKE_cstedc( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zstedc( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_sstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_dstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* isuppz );
+lapack_int LAPACKE_cstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* isuppz );
+lapack_int LAPACKE_zstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* isuppz );
+
+lapack_int LAPACKE_sstein( int matrix_order, lapack_int n, const float* d,
+                           const float* e, lapack_int m, const float* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           float* z, lapack_int ldz, lapack_int* ifailv );
+lapack_int LAPACKE_dstein( int matrix_order, lapack_int n, const double* d,
+                           const double* e, lapack_int m, const double* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           double* z, lapack_int ldz, lapack_int* ifailv );
+lapack_int LAPACKE_cstein( int matrix_order, lapack_int n, const float* d,
+                           const float* e, lapack_int m, const float* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* ifailv );
+lapack_int LAPACKE_zstein( int matrix_order, lapack_int n, const double* d,
+                           const double* e, lapack_int m, const double* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifailv );
+
+lapack_int LAPACKE_sstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, lapack_int* m,
+                           float* w, float* z, lapack_int ldz, lapack_int nzc,
+                           lapack_int* isuppz, lapack_logical* tryrac );
+lapack_int LAPACKE_dstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           lapack_int* m, double* w, double* z, lapack_int ldz,
+                           lapack_int nzc, lapack_int* isuppz,
+                           lapack_logical* tryrac );
+lapack_int LAPACKE_cstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, lapack_int* m,
+                           float* w, lapack_complex_float* z, lapack_int ldz,
+                           lapack_int nzc, lapack_int* isuppz,
+                           lapack_logical* tryrac );
+lapack_int LAPACKE_zstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           lapack_int* m, double* w, lapack_complex_double* z,
+                           lapack_int ldz, lapack_int nzc, lapack_int* isuppz,
+                           lapack_logical* tryrac );
+
+lapack_int LAPACKE_ssteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dsteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, double* z, lapack_int ldz );
+lapack_int LAPACKE_csteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zsteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_ssterf( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dsterf( lapack_int n, double* d, double* e );
+
+lapack_int LAPACKE_sstev( int matrix_order, char jobz, lapack_int n, float* d,
+                          float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dstev( int matrix_order, char jobz, lapack_int n, double* d,
+                          double* e, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sstevd( int matrix_order, char jobz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dstevd( int matrix_order, char jobz, lapack_int n, double* d,
+                           double* e, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sstevr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_dstevr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* isuppz );
+
+lapack_int LAPACKE_sstevx( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dstevx( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssycon( int matrix_order, char uplo, lapack_int n,
+                           const float* a, lapack_int lda,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_dsycon( int matrix_order, char uplo, lapack_int n,
+                           const double* a, lapack_int lda,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_csycon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zsycon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_ssyequb( int matrix_order, char uplo, lapack_int n,
+                            const float* a, lapack_int lda, float* s,
+                            float* scond, float* amax );
+lapack_int LAPACKE_dsyequb( int matrix_order, char uplo, lapack_int n,
+                            const double* a, lapack_int lda, double* s,
+                            double* scond, double* amax );
+lapack_int LAPACKE_csyequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* s, float* scond, float* amax );
+lapack_int LAPACKE_zsyequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_ssyev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_dsyev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          double* a, lapack_int lda, double* w );
+
+lapack_int LAPACKE_ssyevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_dsyevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           double* a, lapack_int lda, double* w );
+
+lapack_int LAPACKE_ssyevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, float* a, lapack_int lda, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_dsyevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, double* a, lapack_int lda, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* isuppz );
+
+lapack_int LAPACKE_ssyevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, float* a, lapack_int lda, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsyevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, double* a, lapack_int lda, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssygst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, float* a, lapack_int lda,
+                           const float* b, lapack_int ldb );
+lapack_int LAPACKE_dsygst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, double* a, lapack_int lda,
+                           const double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssygv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, float* a, lapack_int lda,
+                          float* b, lapack_int ldb, float* w );
+lapack_int LAPACKE_dsygv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, double* a, lapack_int lda,
+                          double* b, lapack_int ldb, double* w );
+
+lapack_int LAPACKE_ssygvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, float* a, lapack_int lda,
+                           float* b, lapack_int ldb, float* w );
+lapack_int LAPACKE_dsygvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* w );
+
+lapack_int LAPACKE_ssygvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsygvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const float* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dsyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const double* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_csyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zsyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_ssyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const float* a,
+                            lapack_int lda, const float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* s,
+                            const float* b, lapack_int ldb, float* x,
+                            lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dsyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const double* a,
+                            lapack_int lda, const double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* s,
+                            const double* b, lapack_int ldb, double* x,
+                            lapack_int ldx, double* rcond, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+lapack_int LAPACKE_csyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* s,
+                            const lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zsyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* s,
+                            const lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_ssysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* a, lapack_int lda,
+                          lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dsysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* a, lapack_int lda,
+                          lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_csysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zsysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           float* af, lapack_int ldaf, lapack_int* ipiv,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dsysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           double* af, lapack_int ldaf, lapack_int* ipiv,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* rcond, double* ferr,
+                           double* berr );
+lapack_int LAPACKE_csysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zsysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_ssysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, float* a,
+                            lapack_int lda, float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* s, float* b,
+                            lapack_int ldb, float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dsysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, double* a,
+                            lapack_int lda, double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* s, double* b,
+                            lapack_int ldb, double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+lapack_int LAPACKE_csysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* s,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zsysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* s,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_ssytrd( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, float* d, float* e, float* tau );
+lapack_int LAPACKE_dsytrd( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, double* d, double* e, double* tau );
+
+lapack_int LAPACKE_ssytrf( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dsytrf( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_csytrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zsytrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_ssytri( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dsytri( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_csytri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_zsytri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv );
+
+lapack_int LAPACKE_ssytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dsytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_csytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zsytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd, const float* ab,
+                           lapack_int ldab, float* rcond );
+lapack_int LAPACKE_dtbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd, const double* ab,
+                           lapack_int ldab, double* rcond );
+lapack_int LAPACKE_ctbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           float* rcond );
+lapack_int LAPACKE_ztbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           double* rcond );
+
+lapack_int LAPACKE_stbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const float* ab, lapack_int ldab, const float* b,
+                           lapack_int ldb, const float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dtbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const double* ab, lapack_int ldab, const double* b,
+                           lapack_int ldb, const double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_ctbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_ztbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_stbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const float* ab, lapack_int ldab, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dtbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const double* ab, lapack_int ldab, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_ctbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          float alpha, const float* a, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dtfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          double alpha, const double* a, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_ctfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          lapack_complex_float alpha,
+                          const lapack_complex_float* a,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          lapack_complex_double alpha,
+                          const lapack_complex_double* a,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, float* a );
+lapack_int LAPACKE_dtftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, double* a );
+lapack_int LAPACKE_ctftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_ztftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_stfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* arf, float* ap );
+lapack_int LAPACKE_dtfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* arf, double* ap );
+lapack_int LAPACKE_ctfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* arf,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_ztfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* arf,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_stfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* arf, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dtfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* arf, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_ctfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* arf,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* arf,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_stgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const float* s, lapack_int lds, const float* p,
+                           lapack_int ldp, float* vl, lapack_int ldvl,
+                           float* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_dtgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const double* s, lapack_int lds, const double* p,
+                           lapack_int ldp, double* vl, lapack_int ldvl,
+                           double* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_ctgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* s, lapack_int lds,
+                           const lapack_complex_float* p, lapack_int ldp,
+                           lapack_complex_float* vl, lapack_int ldvl,
+                           lapack_complex_float* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* s, lapack_int lds,
+                           const lapack_complex_double* p, lapack_int ldp,
+                           lapack_complex_double* vl, lapack_int ldvl,
+                           lapack_complex_double* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+
+lapack_int LAPACKE_stgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb, float* q,
+                           lapack_int ldq, float* z, lapack_int ldz,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_dtgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb, double* q,
+                           lapack_int ldq, double* z, lapack_int ldz,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_ctgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_stgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           float* alphar, float* alphai, float* beta, float* q,
+                           lapack_int ldq, float* z, lapack_int ldz,
+                           lapack_int* m, float* pl, float* pr, float* dif );
+lapack_int LAPACKE_dtgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n,
+                           double* a, lapack_int lda, double* b, lapack_int ldb,
+                           double* alphar, double* alphai, double* beta,
+                           double* q, lapack_int ldq, double* z, lapack_int ldz,
+                           lapack_int* m, double* pl, double* pr, double* dif );
+lapack_int LAPACKE_ctgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta, lapack_complex_float* q,
+                           lapack_int ldq, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* m, float* pl, float* pr,
+                           float* dif );
+lapack_int LAPACKE_ztgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* m, double* pl, double* pr, double* dif );
+
+lapack_int LAPACKE_stgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, float* a, lapack_int lda,
+                           float* b, lapack_int ldb, float tola, float tolb,
+                           float* alpha, float* beta, float* u, lapack_int ldu,
+                           float* v, lapack_int ldv, float* q, lapack_int ldq,
+                           lapack_int* ncycle );
+lapack_int LAPACKE_dtgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double tola, double tolb, double* alpha,
+                           double* beta, double* u, lapack_int ldu, double* v,
+                           lapack_int ldv, double* q, lapack_int ldq,
+                           lapack_int* ncycle );
+lapack_int LAPACKE_ctgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float tola, float tolb, float* alpha,
+                           float* beta, lapack_complex_float* u, lapack_int ldu,
+                           lapack_complex_float* v, lapack_int ldv,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_int* ncycle );
+lapack_int LAPACKE_ztgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double tola, double tolb,
+                           double* alpha, double* beta,
+                           lapack_complex_double* u, lapack_int ldu,
+                           lapack_complex_double* v, lapack_int ldv,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_int* ncycle );
+
+lapack_int LAPACKE_stgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const float* a, lapack_int lda, const float* b,
+                           lapack_int ldb, const float* vl, lapack_int ldvl,
+                           const float* vr, lapack_int ldvr, float* s,
+                           float* dif, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_dtgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const double* a, lapack_int lda, const double* b,
+                           lapack_int ldb, const double* vl, lapack_int ldvl,
+                           const double* vr, lapack_int ldvr, double* s,
+                           double* dif, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ctgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* vl, lapack_int ldvl,
+                           const lapack_complex_float* vr, lapack_int ldvr,
+                           float* s, float* dif, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* vl, lapack_int ldvl,
+                           const lapack_complex_double* vr, lapack_int ldvr,
+                           double* s, double* dif, lapack_int mm,
+                           lapack_int* m );
+
+lapack_int LAPACKE_stgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n, const float* a,
+                           lapack_int lda, const float* b, lapack_int ldb,
+                           float* c, lapack_int ldc, const float* d,
+                           lapack_int ldd, const float* e, lapack_int lde,
+                           float* f, lapack_int ldf, float* scale, float* dif );
+lapack_int LAPACKE_dtgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n, const double* a,
+                           lapack_int lda, const double* b, lapack_int ldb,
+                           double* c, lapack_int ldc, const double* d,
+                           lapack_int ldd, const double* e, lapack_int lde,
+                           double* f, lapack_int ldf, double* scale,
+                           double* dif );
+lapack_int LAPACKE_ctgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* c, lapack_int ldc,
+                           const lapack_complex_float* d, lapack_int ldd,
+                           const lapack_complex_float* e, lapack_int lde,
+                           lapack_complex_float* f, lapack_int ldf,
+                           float* scale, float* dif );
+lapack_int LAPACKE_ztgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* c, lapack_int ldc,
+                           const lapack_complex_double* d, lapack_int ldd,
+                           const lapack_complex_double* e, lapack_int lde,
+                           lapack_complex_double* f, lapack_int ldf,
+                           double* scale, double* dif );
+
+lapack_int LAPACKE_stpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const float* ap, float* rcond );
+lapack_int LAPACKE_dtpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const double* ap, double* rcond );
+lapack_int LAPACKE_ctpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_float* ap,
+                           float* rcond );
+lapack_int LAPACKE_ztpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_double* ap,
+                           double* rcond );
+
+lapack_int LAPACKE_stprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* ap,
+                           const float* b, lapack_int ldb, const float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dtprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* ap,
+                           const double* b, lapack_int ldb, const double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_ctprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* ap,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_ztprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* ap,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_stptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           float* ap );
+lapack_int LAPACKE_dtptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           double* ap );
+lapack_int LAPACKE_ctptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_ztptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_stptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* ap,
+                           float* b, lapack_int ldb );
+lapack_int LAPACKE_dtptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* ap,
+                           double* b, lapack_int ldb );
+lapack_int LAPACKE_ctptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* ap,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* ap,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* ap, float* arf );
+lapack_int LAPACKE_dtpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* ap, double* arf );
+lapack_int LAPACKE_ctpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* ap,
+                           lapack_complex_float* arf );
+lapack_int LAPACKE_ztpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* ap,
+                           lapack_complex_double* arf );
+
+lapack_int LAPACKE_stpttr( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, float* a, lapack_int lda );
+lapack_int LAPACKE_dtpttr( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, double* a, lapack_int lda );
+lapack_int LAPACKE_ctpttr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztpttr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_strcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const float* a, lapack_int lda,
+                           float* rcond );
+lapack_int LAPACKE_dtrcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const double* a, lapack_int lda,
+                           double* rcond );
+lapack_int LAPACKE_ctrcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda, float* rcond );
+lapack_int LAPACKE_ztrcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda, double* rcond );
+
+lapack_int LAPACKE_strevc( int matrix_order, char side, char howmny,
+                           lapack_logical* select, lapack_int n, const float* t,
+                           lapack_int ldt, float* vl, lapack_int ldvl,
+                           float* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_dtrevc( int matrix_order, char side, char howmny,
+                           lapack_logical* select, lapack_int n,
+                           const double* t, lapack_int ldt, double* vl,
+                           lapack_int ldvl, double* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ctrevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* vl, lapack_int ldvl,
+                           lapack_complex_float* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztrevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* vl, lapack_int ldvl,
+                           lapack_complex_double* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+
+lapack_int LAPACKE_strexc( int matrix_order, char compq, lapack_int n, float* t,
+                           lapack_int ldt, float* q, lapack_int ldq,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_dtrexc( int matrix_order, char compq, lapack_int n,
+                           double* t, lapack_int ldt, double* q, lapack_int ldq,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_ctrexc( int matrix_order, char compq, lapack_int n,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztrexc( int matrix_order, char compq, lapack_int n,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_strrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* a,
+                           lapack_int lda, const float* b, lapack_int ldb,
+                           const float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dtrrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* a,
+                           lapack_int lda, const double* b, lapack_int ldb,
+                           const double* x, lapack_int ldx, double* ferr,
+                           double* berr );
+lapack_int LAPACKE_ctrrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_ztrrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_strsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n, float* t,
+                           lapack_int ldt, float* q, lapack_int ldq, float* wr,
+                           float* wi, lapack_int* m, float* s, float* sep );
+lapack_int LAPACKE_dtrsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n,
+                           double* t, lapack_int ldt, double* q, lapack_int ldq,
+                           double* wr, double* wi, lapack_int* m, double* s,
+                           double* sep );
+lapack_int LAPACKE_ctrsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* w, lapack_int* m, float* s,
+                           float* sep );
+lapack_int LAPACKE_ztrsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* w, lapack_int* m, double* s,
+                           double* sep );
+
+lapack_int LAPACKE_strsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const float* t, lapack_int ldt, const float* vl,
+                           lapack_int ldvl, const float* vr, lapack_int ldvr,
+                           float* s, float* sep, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_dtrsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const double* t, lapack_int ldt, const double* vl,
+                           lapack_int ldvl, const double* vr, lapack_int ldvr,
+                           double* s, double* sep, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_ctrsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* t, lapack_int ldt,
+                           const lapack_complex_float* vl, lapack_int ldvl,
+                           const lapack_complex_float* vr, lapack_int ldvr,
+                           float* s, float* sep, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztrsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* t, lapack_int ldt,
+                           const lapack_complex_double* vl, lapack_int ldvl,
+                           const lapack_complex_double* vr, lapack_int ldvr,
+                           double* s, double* sep, lapack_int mm,
+                           lapack_int* m );
+
+lapack_int LAPACKE_strsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const float* a, lapack_int lda, const float* b,
+                           lapack_int ldb, float* c, lapack_int ldc,
+                           float* scale );
+lapack_int LAPACKE_dtrsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const double* a, lapack_int lda, const double* b,
+                           lapack_int ldb, double* c, lapack_int ldc,
+                           double* scale );
+lapack_int LAPACKE_ctrsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* c, lapack_int ldc,
+                           float* scale );
+lapack_int LAPACKE_ztrsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* c, lapack_int ldc,
+                           double* scale );
+
+lapack_int LAPACKE_strtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           float* a, lapack_int lda );
+lapack_int LAPACKE_dtrtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           double* a, lapack_int lda );
+lapack_int LAPACKE_ctrtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztrtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_strtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* a,
+                           lapack_int lda, float* b, lapack_int ldb );
+lapack_int LAPACKE_dtrtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* a,
+                           lapack_int lda, double* b, lapack_int ldb );
+lapack_int LAPACKE_ctrtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztrtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_strttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* a, lapack_int lda,
+                           float* arf );
+lapack_int LAPACKE_dtrttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* a, lapack_int lda,
+                           double* arf );
+lapack_int LAPACKE_ctrttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* arf );
+lapack_int LAPACKE_ztrttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* arf );
+
+lapack_int LAPACKE_strttp( int matrix_order, char uplo, lapack_int n,
+                           const float* a, lapack_int lda, float* ap );
+lapack_int LAPACKE_dtrttp( int matrix_order, char uplo, lapack_int n,
+                           const double* a, lapack_int lda, double* ap );
+lapack_int LAPACKE_ctrttp( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_ztrttp( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_stzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dtzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_ctzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_ztzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cunghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zunghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cunglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zunglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungtr( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau );
+lapack_int LAPACKE_zungtr( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cunmbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cupgtr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* q, lapack_int ldq );
+lapack_int LAPACKE_zupgtr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* q, lapack_int ldq );
+
+lapack_int LAPACKE_cupmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zupmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sbdsdc_work( int matrix_order, char uplo, char compq,
+                                lapack_int n, float* d, float* e, float* u,
+                                lapack_int ldu, float* vt, lapack_int ldvt,
+                                float* q, lapack_int* iq, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dbdsdc_work( int matrix_order, char uplo, char compq,
+                                lapack_int n, double* d, double* e, double* u,
+                                lapack_int ldu, double* vt, lapack_int ldvt,
+                                double* q, lapack_int* iq, double* work,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                float* d, float* e, float* vt, lapack_int ldvt,
+                                float* u, lapack_int ldu, float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_dbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                double* d, double* e, double* vt,
+                                lapack_int ldvt, double* u, lapack_int ldu,
+                                double* c, lapack_int ldc, double* work );
+lapack_int LAPACKE_cbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                float* d, float* e, lapack_complex_float* vt,
+                                lapack_int ldvt, lapack_complex_float* u,
+                                lapack_int ldu, lapack_complex_float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_zbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                double* d, double* e, lapack_complex_double* vt,
+                                lapack_int ldvt, lapack_complex_double* u,
+                                lapack_int ldu, lapack_complex_double* c,
+                                lapack_int ldc, double* work );
+
+lapack_int LAPACKE_sdisna_work( char job, lapack_int m, lapack_int n,
+                                const float* d, float* sep );
+lapack_int LAPACKE_ddisna_work( char job, lapack_int m, lapack_int n,
+                                const double* d, double* sep );
+
+lapack_int LAPACKE_sgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, float* ab, lapack_int ldab,
+                                float* d, float* e, float* q, lapack_int ldq,
+                                float* pt, lapack_int ldpt, float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_dgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, double* ab, lapack_int ldab,
+                                double* d, double* e, double* q, lapack_int ldq,
+                                double* pt, lapack_int ldpt, double* c,
+                                lapack_int ldc, double* work );
+lapack_int LAPACKE_cgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, lapack_complex_float* ab,
+                                lapack_int ldab, float* d, float* e,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* pt, lapack_int ldpt,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, lapack_complex_double* ab,
+                                lapack_int ldab, double* d, double* e,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* pt, lapack_int ldpt,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                double anorm, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* ab,
+                                lapack_int ldab, float* r, float* c,
+                                float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* ab,
+                                lapack_int ldab, double* r, double* c,
+                                double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                float* r, float* c, float* rowcnd,
+                                float* colcnd, float* amax );
+lapack_int LAPACKE_zgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, double* r, double* c,
+                                double* rowcnd, double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku, const float* ab,
+                                 lapack_int ldab, float* r, float* c,
+                                 float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku, const double* ab,
+                                 lapack_int ldab, double* r, double* c,
+                                 double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku,
+                                 const lapack_complex_float* ab,
+                                 lapack_int ldab, float* r, float* c,
+                                 float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_zgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku,
+                                 const lapack_complex_double* ab,
+                                 lapack_int ldab, double* r, double* c,
+                                 double* rowcnd, double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const float* ab, lapack_int ldab,
+                                const float* afb, lapack_int ldafb,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const double* ab, lapack_int ldab,
+                                const double* afb, lapack_int ldafb,
+                                const lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_complex_float* afb,
+                                lapack_int ldafb, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab,
+                                const lapack_complex_double* afb,
+                                lapack_int ldafb, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, const float* ab,
+                                 lapack_int ldab, const float* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const float* r, const float* c, const float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, const double* ab,
+                                 lapack_int ldab, const double* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs,
+                                 const lapack_complex_float* ab,
+                                 lapack_int ldab,
+                                 const lapack_complex_float* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const float* r, const float* c,
+                                 const lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs,
+                                 const lapack_complex_double* ab,
+                                 lapack_int ldab,
+                                 const lapack_complex_double* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs, float* ab,
+                               lapack_int ldab, lapack_int* ipiv, float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs, double* ab,
+                               lapack_int ldab, lapack_int* ipiv, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+
+lapack_int LAPACKE_sgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, float* ab, lapack_int ldab,
+                                float* afb, lapack_int ldafb, lapack_int* ipiv,
+                                char* equed, float* r, float* c, float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, double* ab, lapack_int ldab,
+                                double* afb, lapack_int ldafb, lapack_int* ipiv,
+                                char* equed, double* r, double* c, double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, lapack_complex_float* ab,
+                                lapack_int ldab, lapack_complex_float* afb,
+                                lapack_int ldafb, lapack_int* ipiv, char* equed,
+                                float* r, float* c, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* afb,
+                                lapack_int ldafb, lapack_int* ipiv, char* equed,
+                                double* r, double* c, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_sgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, float* ab, lapack_int ldab,
+                                 float* afb, lapack_int ldafb, lapack_int* ipiv,
+                                 char* equed, float* r, float* c, float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, double* ab, lapack_int ldab,
+                                 double* afb, lapack_int ldafb,
+                                 lapack_int* ipiv, char* equed, double* r,
+                                 double* c, double* b, lapack_int ldb,
+                                 double* x, lapack_int ldx, double* rcond,
+                                 double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, lapack_complex_float* ab,
+                                 lapack_int ldab, lapack_complex_float* afb,
+                                 lapack_int ldafb, lapack_int* ipiv,
+                                 char* equed, float* r, float* c,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, lapack_complex_double* ab,
+                                 lapack_int ldab, lapack_complex_double* afb,
+                                 lapack_int ldafb, lapack_int* ipiv,
+                                 char* equed, double* r, double* c,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, float* ab,
+                                lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_dgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, double* ab,
+                                lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_cgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_int* ipiv );
+lapack_int LAPACKE_zgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_int* ipiv );
+
+lapack_int LAPACKE_sgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const float* ab, lapack_int ldab,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const double* ab, lapack_int ldab,
+                                const lapack_int* ipiv, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* scale, lapack_int m, float* v,
+                                lapack_int ldv );
+lapack_int LAPACKE_dgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* scale, lapack_int m, double* v,
+                                lapack_int ldv );
+lapack_int LAPACKE_cgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* scale, lapack_int m,
+                                lapack_complex_float* v, lapack_int ldv );
+lapack_int LAPACKE_zgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* scale, lapack_int m,
+                                lapack_complex_double* v, lapack_int ldv );
+
+lapack_int LAPACKE_sgebal_work( int matrix_order, char job, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ilo,
+                                lapack_int* ihi, float* scale );
+lapack_int LAPACKE_dgebal_work( int matrix_order, char job, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ilo,
+                                lapack_int* ihi, double* scale );
+lapack_int LAPACKE_cgebal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ilo, lapack_int* ihi,
+                                float* scale );
+lapack_int LAPACKE_zgebal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ilo, lapack_int* ihi,
+                                double* scale );
+
+lapack_int LAPACKE_sgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* d, float* e,
+                                float* tauq, float* taup, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* d, double* e,
+                                double* tauq, double* taup, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_cgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float* d, float* e, lapack_complex_float* tauq,
+                                lapack_complex_float* taup,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double* d, double* e,
+                                lapack_complex_double* tauq,
+                                lapack_complex_double* taup,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgecon_work( int matrix_order, char norm, lapack_int n,
+                                const float* a, lapack_int lda, float anorm,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgecon_work( int matrix_order, char norm, lapack_int n,
+                                const double* a, lapack_int lda, double anorm,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgecon_work( int matrix_order, char norm, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float anorm, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgecon_work( int matrix_order, char norm, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const float* a, lapack_int lda, float* r,
+                                float* c, float* rowcnd, float* colcnd,
+                                float* amax );
+lapack_int LAPACKE_dgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda, double* r,
+                                double* c, double* rowcnd, double* colcnd,
+                                double* amax );
+lapack_int LAPACKE_cgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* r, float* c, float* rowcnd,
+                                float* colcnd, float* amax );
+lapack_int LAPACKE_zgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* r, double* c, double* rowcnd,
+                                double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const float* a, lapack_int lda, float* r,
+                                 float* c, float* rowcnd, float* colcnd,
+                                 float* amax );
+lapack_int LAPACKE_dgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const double* a, lapack_int lda, double* r,
+                                 double* c, double* rowcnd, double* colcnd,
+                                 double* amax );
+lapack_int LAPACKE_cgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* r, float* c, float* rowcnd,
+                                 float* colcnd, float* amax );
+lapack_int LAPACKE_zgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* r, double* c, double* rowcnd,
+                                 double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_S_SELECT2 select, lapack_int n, float* a,
+                               lapack_int lda, lapack_int* sdim, float* wr,
+                               float* wi, float* vs, lapack_int ldvs,
+                               float* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_dgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_D_SELECT2 select, lapack_int n, double* a,
+                               lapack_int lda, lapack_int* sdim, double* wr,
+                               double* wi, double* vs, lapack_int ldvs,
+                               double* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_cgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_C_SELECT1 select, lapack_int n,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_int* sdim, lapack_complex_float* w,
+                               lapack_complex_float* vs, lapack_int ldvs,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork, lapack_logical* bwork );
+lapack_int LAPACKE_zgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_Z_SELECT1 select, lapack_int n,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_int* sdim, lapack_complex_double* w,
+                               lapack_complex_double* vs, lapack_int ldvs,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_S_SELECT2 select, char sense,
+                                lapack_int n, float* a, lapack_int lda,
+                                lapack_int* sdim, float* wr, float* wi,
+                                float* vs, lapack_int ldvs, float* rconde,
+                                float* rcondv, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_dgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_D_SELECT2 select, char sense,
+                                lapack_int n, double* a, lapack_int lda,
+                                lapack_int* sdim, double* wr, double* wi,
+                                double* vs, lapack_int ldvs, double* rconde,
+                                double* rcondv, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_cgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_C_SELECT1 select, char sense,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_int* sdim,
+                                lapack_complex_float* w,
+                                lapack_complex_float* vs, lapack_int ldvs,
+                                float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_logical* bwork );
+lapack_int LAPACKE_zgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_Z_SELECT1 select, char sense,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_int* sdim,
+                                lapack_complex_double* w,
+                                lapack_complex_double* vs, lapack_int ldvs,
+                                double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, float* a, lapack_int lda,
+                               float* wr, float* wi, float* vl, lapack_int ldvl,
+                               float* vr, lapack_int ldvr, float* work,
+                               lapack_int lwork );
+lapack_int LAPACKE_dgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, double* a, lapack_int lda,
+                               double* wr, double* wi, double* vl,
+                               lapack_int ldvl, double* vr, lapack_int ldvr,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* w,
+                               lapack_complex_float* vl, lapack_int ldvl,
+                               lapack_complex_float* vr, lapack_int ldvr,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_double* a,
+                               lapack_int lda, lapack_complex_double* w,
+                               lapack_complex_double* vl, lapack_int ldvl,
+                               lapack_complex_double* vr, lapack_int ldvr,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork );
+
+lapack_int LAPACKE_sgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, float* a,
+                                lapack_int lda, float* wr, float* wi, float* vl,
+                                lapack_int ldvl, float* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, float* scale,
+                                float* abnrm, float* rconde, float* rcondv,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, double* a,
+                                lapack_int lda, double* wr, double* wi,
+                                double* vl, lapack_int ldvl, double* vr,
+                                lapack_int ldvr, lapack_int* ilo,
+                                lapack_int* ihi, double* scale, double* abnrm,
+                                double* rconde, double* rcondv, double* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_cgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* w,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, float* scale,
+                                float* abnrm, float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork );
+lapack_int LAPACKE_zgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* w,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, double* scale,
+                                double* abnrm, double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_sgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, float* a, lapack_int lda,
+                                float* tau, float* work, lapack_int lwork );
+lapack_int LAPACKE_dgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, double* a, lapack_int lda,
+                                double* tau, double* work, lapack_int lwork );
+lapack_int LAPACKE_cgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgejsv_work( int matrix_order, char joba, char jobu,
+                                char jobv, char jobr, char jobt, char jobp,
+                                lapack_int m, lapack_int n, float* a,
+                                lapack_int lda, float* sva, float* u,
+                                lapack_int ldu, float* v, lapack_int ldv,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgejsv_work( int matrix_order, char joba, char jobu,
+                                char jobv, char jobr, char jobt, char jobp,
+                                lapack_int m, lapack_int n, double* a,
+                                lapack_int lda, double* sva, double* u,
+                                lapack_int ldu, double* v, lapack_int ldv,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work );
+lapack_int LAPACKE_dgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work );
+lapack_int LAPACKE_cgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_sgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs, float* a,
+                               lapack_int lda, float* b, lapack_int ldb,
+                               float* work, lapack_int lwork );
+lapack_int LAPACKE_dgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs, double* a,
+                               lapack_int lda, double* b, lapack_int ldb,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_cgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* s,
+                                double rcond, lapack_int* rank, double* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_cgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_zgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, double* s, double rcond,
+                                lapack_int* rank, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* s,
+                                double rcond, lapack_int* rank, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_cgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, double* s, double rcond,
+                                lapack_int* rank, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_sgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, lapack_int* jpvt,
+                                float rcond, lapack_int* rank, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, lapack_int* jpvt,
+                                double rcond, lapack_int* rank, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_cgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_int* jpvt, float rcond,
+                                lapack_int* rank, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_int* jpvt, double rcond,
+                                lapack_int* rank, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_sgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* jpvt,
+                                float* tau, float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* jpvt,
+                                double* tau, double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork );
+lapack_int LAPACKE_zgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_sgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* jpvt,
+                                float* tau, float* work );
+lapack_int LAPACKE_dgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* jpvt,
+                                double* tau, double* work );
+lapack_int LAPACKE_cgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_float* tau,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_double* tau,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work );
+lapack_int LAPACKE_dgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work );
+lapack_int LAPACKE_cgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_sgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* tau,
+                                 float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* tau,
+                                 double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* tau,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* tau,
+                                 lapack_complex_double* work,
+                                 lapack_int lwork );
+
+lapack_int LAPACKE_sgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const float* af, lapack_int ldaf,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs, const float* a,
+                                 lapack_int lda, const float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* r, const float* c, const float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs, const double* a,
+                                 lapack_int lda, const double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* r, const float* c,
+                                 const lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* s, float* u, lapack_int ldu, float* vt,
+                                lapack_int ldvt, float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* s, double* u, lapack_int ldu,
+                                double* vt, lapack_int ldvt, double* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_cgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, float* s,
+                                lapack_complex_float* u, lapack_int ldu,
+                                lapack_complex_float* vt, lapack_int ldvt,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int* iwork );
+lapack_int LAPACKE_zgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, double* s,
+                                lapack_complex_double* u, lapack_int ldu,
+                                lapack_complex_double* vt, lapack_int ldvt,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int* iwork );
+
+lapack_int LAPACKE_sgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* a, lapack_int lda, lapack_int* ipiv,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* a, lapack_int lda, lapack_int* ipiv,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_cgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dsgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                double* a, lapack_int lda, lapack_int* ipiv,
+                                double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* work, float* swork,
+                                lapack_int* iter );
+lapack_int LAPACKE_zcgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, lapack_complex_double* work,
+                                lapack_complex_float* swork, double* rwork,
+                                lapack_int* iter );
+
+lapack_int LAPACKE_sgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n, float* a,
+                                lapack_int lda, float* s, float* u,
+                                lapack_int ldu, float* vt, lapack_int ldvt,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n, double* a,
+                                lapack_int lda, double* s, double* u,
+                                lapack_int ldu, double* vt, lapack_int ldvt,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float* s, lapack_complex_float* u,
+                                lapack_int ldu, lapack_complex_float* vt,
+                                lapack_int ldvt, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double* s, lapack_complex_double* u,
+                                lapack_int ldu, lapack_complex_double* vt,
+                                lapack_int ldvt, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_sgesvj_work( int matrix_order, char joba, char jobu,
+                                char jobv, lapack_int m, lapack_int n, float* a,
+                                lapack_int lda, float* sva, lapack_int mv,
+                                float* v, lapack_int ldv, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgesvj_work( int matrix_order, char joba, char jobu,
+                                char jobv, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* sva,
+                                lapack_int mv, double* v, lapack_int ldv,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, float* a,
+                                lapack_int lda, float* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, float* r,
+                                float* c, float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, double* a,
+                                lapack_int lda, double* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, double* r,
+                                double* c, double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, float* r,
+                                float* c, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, double* r,
+                                double* c, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_sgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs, float* a,
+                                 lapack_int lda, float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* r,
+                                 float* c, float* b, lapack_int ldb, float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs, double* a,
+                                 lapack_int lda, double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* r,
+                                 double* c, double* b, lapack_int ldb,
+                                 double* x, lapack_int ldx, double* rcond,
+                                 double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* r,
+                                 float* c, lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params,
+                                 lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* r,
+                                 double* c, lapack_complex_double* b,
+                                 lapack_int ldb, lapack_complex_double* x,
+                                 lapack_int ldx, double* rcond, double* rpvgrw,
+                                 double* berr, lapack_int n_err_bnds,
+                                 double* err_bnds_norm, double* err_bnds_comp,
+                                 lapack_int nparams, double* params,
+                                 lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv );
+lapack_int LAPACKE_zgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv );
+lapack_int LAPACKE_zgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetri_work( int matrix_order, lapack_int n, float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgetri_work( int matrix_order, lapack_int n, double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgetri_work( int matrix_order, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgetri_work( int matrix_order, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_cgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* lscale, const float* rscale,
+                                lapack_int m, float* v, lapack_int ldv );
+lapack_int LAPACKE_dggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* lscale, const double* rscale,
+                                lapack_int m, double* v, lapack_int ldv );
+lapack_int LAPACKE_cggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* lscale, const float* rscale,
+                                lapack_int m, lapack_complex_float* v,
+                                lapack_int ldv );
+lapack_int LAPACKE_zggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* lscale, const double* rscale,
+                                lapack_int m, lapack_complex_double* v,
+                                lapack_int ldv );
+
+lapack_int LAPACKE_sggbal_work( int matrix_order, char job, lapack_int n,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, lapack_int* ilo,
+                                lapack_int* ihi, float* lscale, float* rscale,
+                                float* work );
+lapack_int LAPACKE_dggbal_work( int matrix_order, char job, lapack_int n,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, lapack_int* ilo,
+                                lapack_int* ihi, double* lscale, double* rscale,
+                                double* work );
+lapack_int LAPACKE_cggbal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_int* ilo, lapack_int* ihi, float* lscale,
+                                float* rscale, float* work );
+lapack_int LAPACKE_zggbal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_int* ilo, lapack_int* ihi,
+                                double* lscale, double* rscale, double* work );
+
+lapack_int LAPACKE_sgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_S_SELECT3 selctg, lapack_int n,
+                               float* a, lapack_int lda, float* b,
+                               lapack_int ldb, lapack_int* sdim, float* alphar,
+                               float* alphai, float* beta, float* vsl,
+                               lapack_int ldvsl, float* vsr, lapack_int ldvsr,
+                               float* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_dgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_D_SELECT3 selctg, lapack_int n,
+                               double* a, lapack_int lda, double* b,
+                               lapack_int ldb, lapack_int* sdim, double* alphar,
+                               double* alphai, double* beta, double* vsl,
+                               lapack_int ldvsl, double* vsr, lapack_int ldvsr,
+                               double* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_cgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_C_SELECT2 selctg, lapack_int n,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_int* sdim, lapack_complex_float* alpha,
+                               lapack_complex_float* beta,
+                               lapack_complex_float* vsl, lapack_int ldvsl,
+                               lapack_complex_float* vsr, lapack_int ldvsr,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork, lapack_logical* bwork );
+lapack_int LAPACKE_zgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_Z_SELECT2 selctg, lapack_int n,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_int* sdim, lapack_complex_double* alpha,
+                               lapack_complex_double* beta,
+                               lapack_complex_double* vsl, lapack_int ldvsl,
+                               lapack_complex_double* vsr, lapack_int ldvsr,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_S_SELECT3 selctg, char sense,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, lapack_int* sdim,
+                                float* alphar, float* alphai, float* beta,
+                                float* vsl, lapack_int ldvsl, float* vsr,
+                                lapack_int ldvsr, float* rconde, float* rcondv,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_dggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_D_SELECT3 selctg, char sense,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, lapack_int* sdim,
+                                double* alphar, double* alphai, double* beta,
+                                double* vsl, lapack_int ldvsl, double* vsr,
+                                lapack_int ldvsr, double* rconde,
+                                double* rcondv, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_cggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_C_SELECT2 selctg, char sense,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_int* sdim,
+                                lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* vsl, lapack_int ldvsl,
+                                lapack_complex_float* vsr, lapack_int ldvsr,
+                                float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int* iwork,
+                                lapack_int liwork, lapack_logical* bwork );
+lapack_int LAPACKE_zggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_Z_SELECT2 selctg, char sense,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_int* sdim,
+                                lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* vsl, lapack_int ldvsl,
+                                lapack_complex_double* vsr, lapack_int ldvsr,
+                                double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int* iwork,
+                                lapack_int liwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, float* a, lapack_int lda, float* b,
+                               lapack_int ldb, float* alphar, float* alphai,
+                               float* beta, float* vl, lapack_int ldvl,
+                               float* vr, lapack_int ldvr, float* work,
+                               lapack_int lwork );
+lapack_int LAPACKE_dggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, double* a, lapack_int lda,
+                               double* b, lapack_int ldb, double* alphar,
+                               double* alphai, double* beta, double* vl,
+                               lapack_int ldvl, double* vr, lapack_int ldvr,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_cggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* b,
+                               lapack_int ldb, lapack_complex_float* alpha,
+                               lapack_complex_float* beta,
+                               lapack_complex_float* vl, lapack_int ldvl,
+                               lapack_complex_float* vr, lapack_int ldvr,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_double* a,
+                               lapack_int lda, lapack_complex_double* b,
+                               lapack_int ldb, lapack_complex_double* alpha,
+                               lapack_complex_double* beta,
+                               lapack_complex_double* vl, lapack_int ldvl,
+                               lapack_complex_double* vr, lapack_int ldvr,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork );
+
+lapack_int LAPACKE_sggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float* alphar, float* alphai, float* beta,
+                                float* vl, lapack_int ldvl, float* vr,
+                                lapack_int ldvr, lapack_int* ilo,
+                                lapack_int* ihi, float* lscale, float* rscale,
+                                float* abnrm, float* bbnrm, float* rconde,
+                                float* rcondv, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_logical* bwork );
+lapack_int LAPACKE_dggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* alphar, double* alphai, double* beta,
+                                double* vl, lapack_int ldvl, double* vr,
+                                lapack_int ldvr, lapack_int* ilo,
+                                lapack_int* ihi, double* lscale, double* rscale,
+                                double* abnrm, double* bbnrm, double* rconde,
+                                double* rcondv, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_logical* bwork );
+lapack_int LAPACKE_cggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, float* lscale,
+                                float* rscale, float* abnrm, float* bbnrm,
+                                float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int* iwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_zggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi,
+                                double* lscale, double* rscale, double* abnrm,
+                                double* bbnrm, double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int* iwork,
+                                lapack_logical* bwork );
+
+lapack_int LAPACKE_sggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* d, float* x,
+                                float* y, float* work, lapack_int lwork );
+lapack_int LAPACKE_dggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* d, double* x,
+                                double* y, double* work, lapack_int lwork );
+lapack_int LAPACKE_cggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* d,
+                                lapack_complex_float* x,
+                                lapack_complex_float* y,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* d,
+                                lapack_complex_double* x,
+                                lapack_complex_double* y,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float* q, lapack_int ldq,
+                                float* z, lapack_int ldz );
+lapack_int LAPACKE_dgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double* q, lapack_int ldq,
+                                double* z, lapack_int ldz );
+lapack_int LAPACKE_cgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* c, float* d,
+                                float* x, float* work, lapack_int lwork );
+lapack_int LAPACKE_dgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* c, double* d,
+                                double* x, double* work, lapack_int lwork );
+lapack_int LAPACKE_cgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* c,
+                                lapack_complex_float* d,
+                                lapack_complex_float* x,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* c,
+                                lapack_complex_double* d,
+                                lapack_complex_double* x,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, float* a, lapack_int lda,
+                                float* taua, float* b, lapack_int ldb,
+                                float* taub, float* work, lapack_int lwork );
+lapack_int LAPACKE_dggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, double* a, lapack_int lda,
+                                double* taua, double* b, lapack_int ldb,
+                                double* taub, double* work, lapack_int lwork );
+lapack_int LAPACKE_cggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* taua,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* taub,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* taua,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* taub,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* taua, float* b, lapack_int ldb,
+                                float* taub, float* work, lapack_int lwork );
+lapack_int LAPACKE_dggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* taua, double* b, lapack_int ldb,
+                                double* taub, double* work, lapack_int lwork );
+lapack_int LAPACKE_cggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* taua,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* taub,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* taua,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* taub,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float* alpha, float* beta,
+                                float* u, lapack_int ldu, float* v,
+                                lapack_int ldv, float* q, lapack_int ldq,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double* alpha, double* beta,
+                                double* u, lapack_int ldu, double* v,
+                                lapack_int ldv, double* q, lapack_int ldq,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float* alpha, float* beta,
+                                lapack_complex_float* u, lapack_int ldu,
+                                lapack_complex_float* v, lapack_int ldv,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_zggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double* alpha, double* beta,
+                                lapack_complex_double* u, lapack_int ldu,
+                                lapack_complex_double* v, lapack_int ldv,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float tola,
+                                float tolb, lapack_int* k, lapack_int* l,
+                                float* u, lapack_int ldu, float* v,
+                                lapack_int ldv, float* q, lapack_int ldq,
+                                lapack_int* iwork, float* tau, float* work );
+lapack_int LAPACKE_dggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double tola,
+                                double tolb, lapack_int* k, lapack_int* l,
+                                double* u, lapack_int ldu, double* v,
+                                lapack_int ldv, double* q, lapack_int ldq,
+                                lapack_int* iwork, double* tau, double* work );
+lapack_int LAPACKE_cggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, float tola, float tolb,
+                                lapack_int* k, lapack_int* l,
+                                lapack_complex_float* u, lapack_int ldu,
+                                lapack_complex_float* v, lapack_int ldv,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_int* iwork, float* rwork,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, double tola, double tolb,
+                                lapack_int* k, lapack_int* l,
+                                lapack_complex_double* u, lapack_int ldu,
+                                lapack_complex_double* v, lapack_int ldv,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_int* iwork, double* rwork,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_sgtcon_work( char norm, lapack_int n, const float* dl,
+                                const float* d, const float* du,
+                                const float* du2, const lapack_int* ipiv,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgtcon_work( char norm, lapack_int n, const double* dl,
+                                const double* d, const double* du,
+                                const double* du2, const lapack_int* ipiv,
+                                double anorm, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgtcon_work( char norm, lapack_int n,
+                                const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                const lapack_complex_float* du2,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zgtcon_work( char norm, lapack_int n,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                const lapack_complex_double* du2,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_sgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* dl,
+                                const float* d, const float* du,
+                                const float* dlf, const float* df,
+                                const float* duf, const float* du2,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* dl,
+                                const double* d, const double* du,
+                                const double* dlf, const double* df,
+                                const double* duf, const double* du2,
+                                const lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                const lapack_complex_float* dlf,
+                                const lapack_complex_float* df,
+                                const lapack_complex_float* duf,
+                                const lapack_complex_float* du2,
+                                const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                const lapack_complex_double* dlf,
+                                const lapack_complex_double* df,
+                                const lapack_complex_double* duf,
+                                const lapack_complex_double* du2,
+                                const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* dl, float* d, float* du, float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* dl, double* d, double* du, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_float* dl,
+                               lapack_complex_float* d,
+                               lapack_complex_float* du,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_double* dl,
+                               lapack_complex_double* d,
+                               lapack_complex_double* du,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, const float* dl,
+                                const float* d, const float* du, float* dlf,
+                                float* df, float* duf, float* du2,
+                                lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, const double* dl,
+                                const double* d, const double* du, double* dlf,
+                                double* df, double* duf, double* du2,
+                                lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                lapack_complex_float* dlf,
+                                lapack_complex_float* df,
+                                lapack_complex_float* duf,
+                                lapack_complex_float* du2, lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                lapack_complex_double* dlf,
+                                lapack_complex_double* df,
+                                lapack_complex_double* duf,
+                                lapack_complex_double* du2, lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgttrf_work( lapack_int n, float* dl, float* d, float* du,
+                                float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_dgttrf_work( lapack_int n, double* dl, double* d, double* du,
+                                double* du2, lapack_int* ipiv );
+lapack_int LAPACKE_cgttrf_work( lapack_int n, lapack_complex_float* dl,
+                                lapack_complex_float* d,
+                                lapack_complex_float* du,
+                                lapack_complex_float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_zgttrf_work( lapack_int n, lapack_complex_double* dl,
+                                lapack_complex_double* d,
+                                lapack_complex_double* du,
+                                lapack_complex_double* du2, lapack_int* ipiv );
+
+lapack_int LAPACKE_sgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* dl,
+                                const float* d, const float* du,
+                                const float* du2, const lapack_int* ipiv,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* dl,
+                                const double* d, const double* du,
+                                const double* du2, const lapack_int* ipiv,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_cgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                const lapack_complex_float* du2,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                const lapack_complex_double* du2,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               float* w, lapack_complex_float* z,
+                               lapack_int ldz, lapack_complex_float* work,
+                               float* rwork );
+lapack_int LAPACKE_zhbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               double* w, lapack_complex_double* z,
+                               lapack_int ldz, lapack_complex_double* work,
+                               double* rwork );
+
+lapack_int LAPACKE_chbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* q, lapack_int ldq,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                float* rwork, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_zhbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_complex_double* q, lapack_int ldq,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                double* rwork, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_chbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_complex_float* bb, lapack_int ldbb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                const lapack_complex_double* bb,
+                                lapack_int ldbb, lapack_complex_double* x,
+                                lapack_int ldx, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_chbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               lapack_complex_float* bb, lapack_int ldbb,
+                               float* w, lapack_complex_float* z,
+                               lapack_int ldz, lapack_complex_float* work,
+                               float* rwork );
+lapack_int LAPACKE_zhbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               lapack_complex_double* bb, lapack_int ldbb,
+                               double* w, lapack_complex_double* z,
+                               lapack_int ldz, lapack_complex_double* work,
+                               double* rwork );
+
+lapack_int LAPACKE_chbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* bb, lapack_int ldbb,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_complex_double* bb, lapack_int ldbb,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, lapack_complex_float* ab,
+                                lapack_int ldab, lapack_complex_float* bb,
+                                lapack_int ldbb, lapack_complex_float* q,
+                                lapack_int ldq, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* bb,
+                                lapack_int ldbb, lapack_complex_double* q,
+                                lapack_int ldq, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                float* d, float* e, lapack_complex_float* q,
+                                lapack_int ldq, lapack_complex_float* work );
+lapack_int LAPACKE_zhbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                double* d, double* e, lapack_complex_double* q,
+                                lapack_int ldq, lapack_complex_double* work );
+
+lapack_int LAPACKE_checon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zhecon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_cheequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* s, float* scond, float* amax,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_zheequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* s, double* scond, double* amax,
+                                 lapack_complex_double* work );
+
+lapack_int LAPACKE_cheev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, float* w,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zheev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_double* a,
+                               lapack_int lda, double* w,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork );
+
+lapack_int LAPACKE_cheevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, float* w,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_zheevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, double* w,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_cheevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_int* isuppz,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_zheevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_int* isuppz,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_cheevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zheevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chegst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zhegst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_chegv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* b,
+                               lapack_int ldb, float* w,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zhegv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_complex_double* b, lapack_int ldb,
+                               double* w, lapack_complex_double* work,
+                               lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_chegvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float* w, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhegvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double* w, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chegvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhegvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_cherfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zherfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_cherfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* s, const lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zherfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* s,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_chesv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zhesv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_chesvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                lapack_int* ipiv, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zhesvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_chesvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* s,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zhesvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* s,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_chetrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float* d, float* e, lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zhetrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double* d, double* e,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_chetrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_zhetrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_chetri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zhetri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_chetrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zhetrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               float alpha, const lapack_complex_float* a,
+                               lapack_int lda, float beta,
+                               lapack_complex_float* c );
+lapack_int LAPACKE_zhfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               double alpha, const lapack_complex_double* a,
+                               lapack_int lda, double beta,
+                               lapack_complex_double* c );
+
+lapack_int LAPACKE_shgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, float* h, lapack_int ldh,
+                                float* t, lapack_int ldt, float* alphar,
+                                float* alphai, float* beta, float* q,
+                                lapack_int ldq, float* z, lapack_int ldz,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dhgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, double* h, lapack_int ldh,
+                                double* t, lapack_int ldt, double* alphar,
+                                double* alphai, double* beta, double* q,
+                                lapack_int ldq, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_chgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_float* h,
+                                lapack_int ldh, lapack_complex_float* t,
+                                lapack_int ldt, lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork );
+lapack_int LAPACKE_zhgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_double* h,
+                                lapack_int ldh, lapack_complex_double* t,
+                                lapack_int ldt, lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_chpcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zhpcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_chpev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_float* ap, float* w,
+                               lapack_complex_float* z, lapack_int ldz,
+                               lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhpev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_double* ap,
+                               double* w, lapack_complex_double* z,
+                               lapack_int ldz, lapack_complex_double* work,
+                               double* rwork );
+
+lapack_int LAPACKE_chpevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_float* ap,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhpevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_double* ap,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chpevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* ap, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhpevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* ap, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chpgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_float* ap,
+                                const lapack_complex_float* bp );
+lapack_int LAPACKE_zhpgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_double* ap,
+                                const lapack_complex_double* bp );
+
+lapack_int LAPACKE_chpgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n,
+                               lapack_complex_float* ap,
+                               lapack_complex_float* bp, float* w,
+                               lapack_complex_float* z, lapack_int ldz,
+                               lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhpgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n,
+                               lapack_complex_double* ap,
+                               lapack_complex_double* bp, double* w,
+                               lapack_complex_double* z, lapack_int ldz,
+                               lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_chpgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                lapack_complex_float* bp, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_zhpgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                lapack_complex_double* bp, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_chpgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                lapack_complex_float* bp, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhpgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                lapack_complex_double* bp, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_complex_float* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_chpsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* ap,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zhpsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* ap,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+
+lapack_int LAPACKE_chpsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* afp, lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhpsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* afp, lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_chptrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap, float* d, float* e,
+                                lapack_complex_float* tau );
+lapack_int LAPACKE_zhptrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap, double* d, double* e,
+                                lapack_complex_double* tau );
+
+lapack_int LAPACKE_chptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zhptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_chptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zhptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_chptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zhptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_shsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, lapack_logical* select,
+                                lapack_int n, const float* h, lapack_int ldh,
+                                float* wr, const float* wi, float* vl,
+                                lapack_int ldvl, float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, float* work,
+                                lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_dhsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, lapack_logical* select,
+                                lapack_int n, const double* h, lapack_int ldh,
+                                double* wr, const double* wi, double* vl,
+                                lapack_int ldvl, double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, double* work,
+                                lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_chsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, const lapack_logical* select,
+                                lapack_int n, const lapack_complex_float* h,
+                                lapack_int ldh, lapack_complex_float* w,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_zhsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, const lapack_logical* select,
+                                lapack_int n, const lapack_complex_double* h,
+                                lapack_int ldh, lapack_complex_double* w,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* ifaill, lapack_int* ifailr );
+
+lapack_int LAPACKE_shseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                float* h, lapack_int ldh, float* wr, float* wi,
+                                float* z, lapack_int ldz, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dhseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                double* h, lapack_int ldh, double* wr,
+                                double* wi, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_chseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_float* h, lapack_int ldh,
+                                lapack_complex_float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zhseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_double* h, lapack_int ldh,
+                                lapack_complex_double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_clacgv_work( lapack_int n, lapack_complex_float* x,
+                                lapack_int incx );
+lapack_int LAPACKE_zlacgv_work( lapack_int n, lapack_complex_double* x,
+                                lapack_int incx );
+
+lapack_int LAPACKE_slacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dlacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_clacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zlacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_zlag2c_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_float* sa, lapack_int ldsa );
+
+lapack_int LAPACKE_slag2d_work( int matrix_order, lapack_int m, lapack_int n,
+                                const float* sa, lapack_int ldsa, double* a,
+                                lapack_int lda );
+
+lapack_int LAPACKE_dlag2s_work( int matrix_order, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda, float* sa,
+                                lapack_int ldsa );
+
+lapack_int LAPACKE_clag2z_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_float* sa, lapack_int ldsa,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* d,
+                                float* a, lapack_int lda, lapack_int* iseed,
+                                float* work );
+lapack_int LAPACKE_dlagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* d,
+                                double* a, lapack_int lda, lapack_int* iseed,
+                                double* work );
+lapack_int LAPACKE_clagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* d,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* iseed, lapack_complex_float* work );
+lapack_int LAPACKE_zlagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* d,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* iseed,
+                                lapack_complex_double* work );
+                                
+lapack_int LAPACKE_claghe_work( int matrix_order, lapack_int n, lapack_int k,
+                                const float* d, lapack_complex_float* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zlaghe_work( int matrix_order, lapack_int n, lapack_int k,
+                                const double* d, lapack_complex_double* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_slagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const float* d, float* a, lapack_int lda,
+                                lapack_int* iseed, float* work );
+lapack_int LAPACKE_dlagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const double* d, double* a, lapack_int lda,
+                                lapack_int* iseed, double* work );
+lapack_int LAPACKE_clagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const float* d, lapack_complex_float* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zlagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const double* d, lapack_complex_double* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_slapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n, float* x,
+                                lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_dlapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n, double* x,
+                                lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_clapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_float* x, lapack_int ldx,
+                                lapack_int* k );
+lapack_int LAPACKE_zlapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_double* x, lapack_int ldx,
+                                lapack_int* k );
+
+lapack_int LAPACKE_slartgp_work( float f, float g, float* cs, float* sn,
+                                 float* r );
+lapack_int LAPACKE_dlartgp_work( double f, double g, double* cs, double* sn,
+                                 double* r );
+
+lapack_int LAPACKE_slartgs_work( float x, float y, float sigma, float* cs,
+                                 float* sn );
+lapack_int LAPACKE_dlartgs_work( double x, double y, double sigma, double* cs,
+                                 double* sn );
+                                
+float LAPACKE_slapy2_work( float x, float y );
+double LAPACKE_dlapy2_work( double x, double y );
+
+float LAPACKE_slapy3_work( float x, float y, float z );
+double LAPACKE_dlapy3_work( double x, double y, double z );
+
+float LAPACKE_slamch_work( char cmach );
+double LAPACKE_dlamch_work( char cmach );
+
+float LAPACKE_slange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* work );
+double LAPACKE_dlange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* work );
+float LAPACKE_clange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_zlange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, double* work );
+
+float LAPACKE_clanhe_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_zlanhe_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, double* work );
+
+float LAPACKE_slansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* work );
+double LAPACKE_dlansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* work );
+float LAPACKE_clansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_zlansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, double* work );
+
+float LAPACKE_slantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n, const float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_dlantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda, double* work );
+float LAPACKE_clantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* work );
+double LAPACKE_zlantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* work );
+
+lapack_int LAPACKE_slarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, const float* v,
+                                lapack_int ldv, const float* t, lapack_int ldt,
+                                float* c, lapack_int ldc, float* work,
+                                lapack_int ldwork );
+lapack_int LAPACKE_dlarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, const double* v,
+                                lapack_int ldv, const double* t, lapack_int ldt,
+                                double* c, lapack_int ldc, double* work,
+                                lapack_int ldwork );
+lapack_int LAPACKE_clarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_float* v, lapack_int ldv,
+                                const lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int ldwork );
+lapack_int LAPACKE_zlarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_double* v, lapack_int ldv,
+                                const lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work,
+                                lapack_int ldwork );
+
+lapack_int LAPACKE_slarfg_work( lapack_int n, float* alpha, float* x,
+                                lapack_int incx, float* tau );
+lapack_int LAPACKE_dlarfg_work( lapack_int n, double* alpha, double* x,
+                                lapack_int incx, double* tau );
+lapack_int LAPACKE_clarfg_work( lapack_int n, lapack_complex_float* alpha,
+                                lapack_complex_float* x, lapack_int incx,
+                                lapack_complex_float* tau );
+lapack_int LAPACKE_zlarfg_work( lapack_int n, lapack_complex_double* alpha,
+                                lapack_complex_double* x, lapack_int incx,
+                                lapack_complex_double* tau );
+
+lapack_int LAPACKE_slarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k, const float* v,
+                                lapack_int ldv, const float* tau, float* t,
+                                lapack_int ldt );
+lapack_int LAPACKE_dlarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k, const double* v,
+                                lapack_int ldv, const double* tau, double* t,
+                                lapack_int ldt );
+lapack_int LAPACKE_clarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_float* v, lapack_int ldv,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zlarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_double* v, lapack_int ldv,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_slarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const float* v, float tau,
+                                float* c, lapack_int ldc, float* work );
+lapack_int LAPACKE_dlarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const double* v, double tau,
+                                double* c, lapack_int ldc, double* work );
+lapack_int LAPACKE_clarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const lapack_complex_float* v,
+                                lapack_complex_float tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zlarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const lapack_complex_double* v,
+                                lapack_complex_double tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_slarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, float* x );
+lapack_int LAPACKE_dlarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, double* x );
+lapack_int LAPACKE_clarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, lapack_complex_float* x );
+lapack_int LAPACKE_zlarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, lapack_complex_double* x );
+
+lapack_int LAPACKE_slaset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, float alpha, float beta, float* a,
+                                lapack_int lda );
+lapack_int LAPACKE_dlaset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, double alpha, double beta,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_claset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, lapack_complex_float alpha,
+                                lapack_complex_float beta,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlaset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, lapack_complex_double alpha,
+                                lapack_complex_double beta,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slasrt_work( char id, lapack_int n, float* d );
+lapack_int LAPACKE_dlasrt_work( char id, lapack_int n, double* d );
+
+lapack_int LAPACKE_slaswp_work( int matrix_order, lapack_int n, float* a,
+                                lapack_int lda, lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_dlaswp_work( int matrix_order, lapack_int n, double* a,
+                                lapack_int lda, lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_claswp_work( int matrix_order, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_zlaswp_work( int matrix_order, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+
+lapack_int LAPACKE_slatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                float* d, lapack_int mode, float cond,
+                                float dmax, lapack_int kl, lapack_int ku,
+                                char pack, float* a, lapack_int lda,
+                                float* work );
+lapack_int LAPACKE_dlatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                double* d, lapack_int mode, double cond,
+                                double dmax, lapack_int kl, lapack_int ku,
+                                char pack, double* a, lapack_int lda,
+                                double* work );
+lapack_int LAPACKE_clatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                float* d, lapack_int mode, float cond,
+                                float dmax, lapack_int kl, lapack_int ku,
+                                char pack, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* work );
+lapack_int LAPACKE_zlatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                double* d, lapack_int mode, double cond,
+                                double dmax, lapack_int kl, lapack_int ku,
+                                char pack, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* work );
+
+lapack_int LAPACKE_slauum_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda );
+lapack_int LAPACKE_dlauum_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_clauum_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlauum_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_sopgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, const float* tau, float* q,
+                                lapack_int ldq, float* work );
+lapack_int LAPACKE_dopgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, const double* tau, double* q,
+                                lapack_int ldq, double* work );
+
+lapack_int LAPACKE_sopmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const float* ap, const float* tau, float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_dopmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const double* ap, const double* tau, double* c,
+                                lapack_int ldc, double* work );
+
+lapack_int LAPACKE_sorgbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k, float* a,
+                                lapack_int lda, const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k, double* a,
+                                lapack_int lda, const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgtr_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, const float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dorgtr_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, const double* tau,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_spbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const float* ab, lapack_int ldab,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dpbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const double* ab,
+                                lapack_int ldab, double anorm, double* rcond,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cpbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_float* ab,
+                                lapack_int ldab, float anorm, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_double* ab,
+                                lapack_int ldab, double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const float* ab, lapack_int ldab,
+                                float* s, float* scond, float* amax );
+lapack_int LAPACKE_dpbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const double* ab,
+                                lapack_int ldab, double* s, double* scond,
+                                double* amax );
+lapack_int LAPACKE_cpbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_float* ab,
+                                lapack_int ldab, float* s, float* scond,
+                                float* amax );
+lapack_int LAPACKE_zpbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_double* ab,
+                                lapack_int ldab, double* s, double* scond,
+                                double* amax );
+
+lapack_int LAPACKE_spbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs, const float* ab,
+                                lapack_int ldab, const float* afb,
+                                lapack_int ldafb, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dpbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const double* ab, lapack_int ldab,
+                                const double* afb, lapack_int ldafb,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cpbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_complex_float* afb,
+                                lapack_int ldafb, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab,
+                                const lapack_complex_double* afb,
+                                lapack_int ldafb,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, float* bb, lapack_int ldbb );
+lapack_int LAPACKE_dpbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, double* bb, lapack_int ldbb );
+lapack_int LAPACKE_cpbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, lapack_complex_float* bb,
+                                lapack_int ldbb );
+lapack_int LAPACKE_zpbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, lapack_complex_double* bb,
+                                lapack_int ldbb );
+
+lapack_int LAPACKE_spbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs, float* ab,
+                               lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs, double* ab,
+                               lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                float* ab, lapack_int ldab, float* afb,
+                                lapack_int ldafb, char* equed, float* s,
+                                float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dpbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                double* ab, lapack_int ldab, double* afb,
+                                lapack_int ldafb, char* equed, double* s,
+                                double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, double* work, lapack_int* iwork );
+lapack_int LAPACKE_cpbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* afb, lapack_int ldafb,
+                                char* equed, float* s, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zpbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_complex_double* afb, lapack_int ldafb,
+                                char* equed, double* s,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, float* ab, lapack_int ldab );
+lapack_int LAPACKE_dpbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, double* ab, lapack_int ldab );
+lapack_int LAPACKE_cpbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_complex_float* ab,
+                                lapack_int ldab );
+lapack_int LAPACKE_zpbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_complex_double* ab,
+                                lapack_int ldab );
+
+lapack_int LAPACKE_spbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs, const float* ab,
+                                lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const double* ab, lapack_int ldab, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cpbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_spftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, float* a );
+lapack_int LAPACKE_dpftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, double* a );
+lapack_int LAPACKE_cpftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, float* a );
+lapack_int LAPACKE_dpftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, double* a );
+lapack_int LAPACKE_cpftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs, const float* a,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dpftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs, const double* a,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_cpftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spocon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* a, lapack_int lda, float anorm,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dpocon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* a, lapack_int lda, double anorm,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cpocon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float anorm, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpocon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spoequ_work( int matrix_order, lapack_int n, const float* a,
+                                lapack_int lda, float* s, float* scond,
+                                float* amax );
+lapack_int LAPACKE_dpoequ_work( int matrix_order, lapack_int n, const double* a,
+                                lapack_int lda, double* s, double* scond,
+                                double* amax );
+lapack_int LAPACKE_cpoequ_work( int matrix_order, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequ_work( int matrix_order, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_spoequb_work( int matrix_order, lapack_int n, const float* a,
+                                 lapack_int lda, float* s, float* scond,
+                                 float* amax );
+lapack_int LAPACKE_dpoequb_work( int matrix_order, lapack_int n,
+                                 const double* a, lapack_int lda, double* s,
+                                 double* scond, double* amax );
+lapack_int LAPACKE_cpoequb_work( int matrix_order, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequb_work( int matrix_order, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_sporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const float* af, lapack_int ldaf,
+                                const float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const double* af,
+                                lapack_int ldaf, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const float* a,
+                                 lapack_int lda, const float* af,
+                                 lapack_int ldaf, const float* s,
+                                 const float* b, lapack_int ldb, float* x,
+                                 lapack_int ldx, float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const double* a,
+                                 lapack_int lda, const double* af,
+                                 lapack_int ldaf, const double* s,
+                                 const double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const float* s,
+                                 const lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const double* s,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* a, lapack_int lda,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* a, lapack_int lda,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_cposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* a,
+                               lapack_int lda, lapack_complex_double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dsposv_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* work, float* swork,
+                                lapack_int* iter );
+lapack_int LAPACKE_zcposv_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, lapack_complex_double* work,
+                                lapack_complex_float* swork, double* rwork,
+                                lapack_int* iter );
+
+lapack_int LAPACKE_sposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, float* a,
+                                lapack_int lda, float* af, lapack_int ldaf,
+                                char* equed, float* s, float* b, lapack_int ldb,
+                                float* x, lapack_int ldx, float* rcond,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, double* a,
+                                lapack_int lda, double* af, lapack_int ldaf,
+                                char* equed, double* s, double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                char* equed, float* s, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                char* equed, double* s,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, float* a,
+                                 lapack_int lda, float* af, lapack_int ldaf,
+                                 char* equed, float* s, float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, double* a,
+                                 lapack_int lda, double* af, lapack_int ldaf,
+                                 char* equed, double* s, double* b,
+                                 lapack_int ldb, double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 char* equed, float* s, lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params,
+                                 lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 char* equed, double* s,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_spotrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda );
+lapack_int LAPACKE_dpotrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_cpotrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotri_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda );
+lapack_int LAPACKE_dpotri_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_cpotri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dpotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zpotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_sppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, float anorm, float* rcond,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, double anorm, double* rcond,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap, float anorm,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap, double anorm,
+                                double* rcond, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_sppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, float* s, float* scond,
+                                float* amax );
+lapack_int LAPACKE_dppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, double* s, double* scond,
+                                double* amax );
+lapack_int LAPACKE_cppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap, float* s,
+                                float* scond, float* amax );
+lapack_int LAPACKE_zppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap, double* s,
+                                double* scond, double* amax );
+
+lapack_int LAPACKE_spprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap,
+                                const float* afp, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dpprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap,
+                                const double* afp, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cpprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_complex_float* afp,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* afp,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* ap, float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* ap, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* ap,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* ap,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, float* ap,
+                                float* afp, char* equed, float* s, float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, double* ap,
+                                double* afp, char* equed, double* s, double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_float* ap,
+                                lapack_complex_float* afp, char* equed,
+                                float* s, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* ap,
+                                lapack_complex_double* afp, char* equed,
+                                double* s, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_spptrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap );
+lapack_int LAPACKE_dpptrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap );
+lapack_int LAPACKE_cpptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_zpptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptri_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap );
+lapack_int LAPACKE_dpptri_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap );
+lapack_int LAPACKE_cpptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_zpptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dpptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cpptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spstrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* piv,
+                                lapack_int* rank, float tol, float* work );
+lapack_int LAPACKE_dpstrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* piv,
+                                lapack_int* rank, double tol, double* work );
+lapack_int LAPACKE_cpstrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* piv, lapack_int* rank, float tol,
+                                float* work );
+lapack_int LAPACKE_zpstrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* piv, lapack_int* rank, double tol,
+                                double* work );
+
+lapack_int LAPACKE_sptcon_work( lapack_int n, const float* d, const float* e,
+                                float anorm, float* rcond, float* work );
+lapack_int LAPACKE_dptcon_work( lapack_int n, const double* d, const double* e,
+                                double anorm, double* rcond, double* work );
+lapack_int LAPACKE_cptcon_work( lapack_int n, const float* d,
+                                const lapack_complex_float* e, float anorm,
+                                float* rcond, float* work );
+lapack_int LAPACKE_zptcon_work( lapack_int n, const double* d,
+                                const lapack_complex_double* e, double anorm,
+                                double* rcond, double* work );
+
+lapack_int LAPACKE_spteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work );
+lapack_int LAPACKE_dpteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work );
+lapack_int LAPACKE_cpteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, lapack_complex_float* z,
+                                lapack_int ldz, float* work );
+lapack_int LAPACKE_zpteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, lapack_complex_double* z,
+                                lapack_int ldz, double* work );
+
+lapack_int LAPACKE_sptrfs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const float* d, const float* e, const float* df,
+                                const float* ef, const float* b, lapack_int ldb,
+                                float* x, lapack_int ldx, float* ferr,
+                                float* berr, float* work );
+lapack_int LAPACKE_dptrfs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const double* d, const double* e,
+                                const double* df, const double* ef,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work );
+lapack_int LAPACKE_cptrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* d,
+                                const lapack_complex_float* e, const float* df,
+                                const lapack_complex_float* ef,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zptrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const lapack_complex_double* e,
+                                const double* df,
+                                const lapack_complex_double* ef,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* d, float* e, float* b, lapack_int ldb );
+lapack_int LAPACKE_dptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* d, double* e, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* d, lapack_complex_float* e,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* d, lapack_complex_double* e,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const float* d, const float* e,
+                                float* df, float* ef, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work );
+lapack_int LAPACKE_dptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const double* e, double* df, double* ef,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, double* work );
+lapack_int LAPACKE_cptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const float* d,
+                                const lapack_complex_float* e, float* df,
+                                lapack_complex_float* ef,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const lapack_complex_double* e, double* df,
+                                lapack_complex_double* ef,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spttrf_work( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dpttrf_work( lapack_int n, double* d, double* e );
+lapack_int LAPACKE_cpttrf_work( lapack_int n, float* d,
+                                lapack_complex_float* e );
+lapack_int LAPACKE_zpttrf_work( lapack_int n, double* d,
+                                lapack_complex_double* e );
+
+lapack_int LAPACKE_spttrs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const float* d, const float* e, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dpttrs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const double* d, const double* e, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cpttrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* d,
+                                const lapack_complex_float* e,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpttrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const lapack_complex_double* e,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd, float* ab,
+                               lapack_int ldab, float* w, float* z,
+                               lapack_int ldz, float* work );
+lapack_int LAPACKE_dsbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd, double* ab,
+                               lapack_int ldab, double* w, double* z,
+                               lapack_int ldz, double* work );
+
+lapack_int LAPACKE_ssbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd, float* ab,
+                                lapack_int ldab, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd, double* ab,
+                                lapack_int ldab, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                float* ab, lapack_int ldab, float* q,
+                                lapack_int ldq, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dsbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                double* ab, lapack_int ldab, double* q,
+                                lapack_int ldq, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_ssbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                float* ab, lapack_int ldab, const float* bb,
+                                lapack_int ldbb, float* x, lapack_int ldx,
+                                float* work );
+lapack_int LAPACKE_dsbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                double* ab, lapack_int ldab, const double* bb,
+                                lapack_int ldbb, double* x, lapack_int ldx,
+                                double* work );
+
+lapack_int LAPACKE_ssbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               float* ab, lapack_int ldab, float* bb,
+                               lapack_int ldbb, float* w, float* z,
+                               lapack_int ldz, float* work );
+lapack_int LAPACKE_dsbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               double* ab, lapack_int ldab, double* bb,
+                               lapack_int ldbb, double* w, double* z,
+                               lapack_int ldz, double* work );
+
+lapack_int LAPACKE_ssbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                float* ab, lapack_int ldab, float* bb,
+                                lapack_int ldbb, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                double* ab, lapack_int ldab, double* bb,
+                                lapack_int ldbb, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, float* ab, lapack_int ldab,
+                                float* bb, lapack_int ldbb, float* q,
+                                lapack_int ldq, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dsbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, double* ab, lapack_int ldab,
+                                double* bb, lapack_int ldbb, double* q,
+                                lapack_int ldq, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_ssbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd, float* ab,
+                                lapack_int ldab, float* d, float* e, float* q,
+                                lapack_int ldq, float* work );
+lapack_int LAPACKE_dsbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd, double* ab,
+                                lapack_int ldab, double* d, double* e,
+                                double* q, lapack_int ldq, double* work );
+
+lapack_int LAPACKE_ssfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               float alpha, const float* a, lapack_int lda,
+                               float beta, float* c );
+lapack_int LAPACKE_dsfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               double alpha, const double* a, lapack_int lda,
+                               double beta, double* c );
+
+lapack_int LAPACKE_sspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, const lapack_int* ipiv,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, const lapack_int* ipiv,
+                                double anorm, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_sspev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, float* ap, float* w, float* z,
+                               lapack_int ldz, float* work );
+lapack_int LAPACKE_dspev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, double* ap, double* w, double* z,
+                               lapack_int ldz, double* work );
+
+lapack_int LAPACKE_sspevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, float* ap, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dspevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, double* ap, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sspevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, float* ap, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dspevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, double* ap, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, double* work,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_sspgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, float* ap, const float* bp );
+lapack_int LAPACKE_dspgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, double* ap, const double* bp );
+
+lapack_int LAPACKE_sspgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, float* ap, float* bp,
+                               float* w, float* z, lapack_int ldz,
+                               float* work );
+lapack_int LAPACKE_dspgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, double* ap, double* bp,
+                               double* w, double* z, lapack_int ldz,
+                               double* work );
+
+lapack_int LAPACKE_sspgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, float* ap, float* bp,
+                                float* w, float* z, lapack_int ldz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dspgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, double* ap, double* bp,
+                                double* w, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sspgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, float* ap,
+                                float* bp, float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, float* z, lapack_int ldz, float* work,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_dspgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, double* ap,
+                                double* bp, double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, double* z, lapack_int ldz,
+                                double* work, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_ssprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap,
+                                const float* afp, const lapack_int* ipiv,
+                                const float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dsprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap,
+                                const double* afp, const lapack_int* ipiv,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_csprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_complex_float* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zsprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* ap, lapack_int* ipiv,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* ap, lapack_int* ipiv,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_cspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* ap,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* ap,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+
+lapack_int LAPACKE_sspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const float* ap,
+                                float* afp, lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const double* ap,
+                                double* afp, lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* afp, lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* afp, lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_ssptrd_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap, float* d, float* e, float* tau );
+lapack_int LAPACKE_dsptrd_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap, double* d, double* e, double* tau );
+
+lapack_int LAPACKE_ssptrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_dsptrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap, lapack_int* ipiv );
+lapack_int LAPACKE_csptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zsptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_ssptri_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap, const lapack_int* ipiv,
+                                float* work );
+lapack_int LAPACKE_dsptri_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap, const lapack_int* ipiv,
+                                double* work );
+lapack_int LAPACKE_csptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zsptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_ssptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dsptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap,
+                                const lapack_int* ipiv, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_csptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zsptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sstebz_work( char range, char order, lapack_int n, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, const float* d, const float* e,
+                                lapack_int* m, lapack_int* nsplit, float* w,
+                                lapack_int* iblock, lapack_int* isplit,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dstebz_work( char range, char order, lapack_int n, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, const double* d, const double* e,
+                                lapack_int* m, lapack_int* nsplit, double* w,
+                                lapack_int* iblock, lapack_int* isplit,
+                                double* work, lapack_int* iwork );
+
+lapack_int LAPACKE_sstedc_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dstedc_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_cstedc_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zstedc_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_sstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, lapack_int* isuppz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_cstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int* isuppz, double* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_sstein_work( int matrix_order, lapack_int n, const float* d,
+                                const float* e, lapack_int m, const float* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+lapack_int LAPACKE_dstein_work( int matrix_order, lapack_int n, const double* d,
+                                const double* e, lapack_int m, const double* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit, double* z,
+                                lapack_int ldz, double* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+lapack_int LAPACKE_cstein_work( int matrix_order, lapack_int n, const float* d,
+                                const float* e, lapack_int m, const float* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit,
+                                lapack_complex_float* z, lapack_int ldz,
+                                float* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+lapack_int LAPACKE_zstein_work( int matrix_order, lapack_int n, const double* d,
+                                const double* e, lapack_int m, const double* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit,
+                                lapack_complex_double* z, lapack_int ldz,
+                                double* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+
+lapack_int LAPACKE_sstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int nzc,
+                                lapack_int* isuppz, lapack_logical* tryrac,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, lapack_int nzc,
+                                lapack_int* isuppz, lapack_logical* tryrac,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_cstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int nzc, lapack_int* isuppz,
+                                lapack_logical* tryrac, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int nzc, lapack_int* isuppz,
+                                lapack_logical* tryrac, double* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_ssteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work );
+lapack_int LAPACKE_dsteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work );
+lapack_int LAPACKE_csteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, lapack_complex_float* z,
+                                lapack_int ldz, float* work );
+lapack_int LAPACKE_zsteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, lapack_complex_double* z,
+                                lapack_int ldz, double* work );
+
+lapack_int LAPACKE_ssterf_work( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dsterf_work( lapack_int n, double* d, double* e );
+
+lapack_int LAPACKE_sstev_work( int matrix_order, char jobz, lapack_int n,
+                               float* d, float* e, float* z, lapack_int ldz,
+                               float* work );
+lapack_int LAPACKE_dstev_work( int matrix_order, char jobz, lapack_int n,
+                               double* d, double* e, double* z, lapack_int ldz,
+                               double* work );
+
+lapack_int LAPACKE_sstevd_work( int matrix_order, char jobz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dstevd_work( int matrix_order, char jobz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sstevr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dstevr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, lapack_int* isuppz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sstevx_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dstevx_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, double* work,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_ssycon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* a, lapack_int lda,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dsycon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_csycon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zsycon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_ssyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const float* a, lapack_int lda, float* s,
+                                 float* scond, float* amax, float* work );
+lapack_int LAPACKE_dsyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const double* a, lapack_int lda, double* s,
+                                 double* scond, double* amax, double* work );
+lapack_int LAPACKE_csyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* s, float* scond, float* amax,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_zsyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* s, double* scond, double* amax,
+                                 lapack_complex_double* work );
+
+lapack_int LAPACKE_ssyev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, float* a, lapack_int lda, float* w,
+                               float* work, lapack_int lwork );
+lapack_int LAPACKE_dsyev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, double* a, lapack_int lda,
+                               double* w, double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssyevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* w, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsyevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* w, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssyevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, float* a,
+                                lapack_int lda, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dsyevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, double* a,
+                                lapack_int lda, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, lapack_int* isuppz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssyevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, float* a,
+                                lapack_int lda, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_dsyevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, double* a,
+                                lapack_int lda, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_ssygst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, float* a, lapack_int lda,
+                                const float* b, lapack_int ldb );
+lapack_int LAPACKE_dsygst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, double* a, lapack_int lda,
+                                const double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssygv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, float* a,
+                               lapack_int lda, float* b, lapack_int ldb,
+                               float* w, float* work, lapack_int lwork );
+lapack_int LAPACKE_dsygv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, double* a,
+                               lapack_int lda, double* b, lapack_int ldb,
+                               double* w, double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssygvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float* w, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsygvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* w, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssygvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, float* z, lapack_int ldz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dsygvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_ssyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const float* af, lapack_int ldaf,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dsyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_csyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zsyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_ssyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const float* a,
+                                 lapack_int lda, const float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* s, const float* b, lapack_int ldb,
+                                 float* x, lapack_int ldx, float* rcond,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dsyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const double* a,
+                                 lapack_int lda, const double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* s, const double* b,
+                                 lapack_int ldb, double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_csyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* s, const lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zsyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* s,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_ssysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* a, lapack_int lda,
+                               lapack_int* ipiv, float* b, lapack_int ldb,
+                               float* work, lapack_int lwork );
+lapack_int LAPACKE_dsysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* a, lapack_int lda,
+                               lapack_int* ipiv, double* b, lapack_int ldb,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_csysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zsysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const float* a,
+                                lapack_int lda, float* af, lapack_int ldaf,
+                                lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dsysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const double* a,
+                                lapack_int lda, double* af, lapack_int ldaf,
+                                lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_csysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                lapack_int* ipiv, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zsysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_ssysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, float* a,
+                                 lapack_int lda, float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* s,
+                                 float* b, lapack_int ldb, float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dsysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, double* a,
+                                 lapack_int lda, double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* s,
+                                 double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* rpvgrw,
+                                 double* berr, lapack_int n_err_bnds,
+                                 double* err_bnds_norm, double* err_bnds_comp,
+                                 lapack_int nparams, double* params,
+                                 double* work, lapack_int* iwork );
+lapack_int LAPACKE_csysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* s,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zsysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* s,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_ssytrd_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, float* d, float* e,
+                                float* tau, float* work, lapack_int lwork );
+lapack_int LAPACKE_dsytrd_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, double* d, double* e,
+                                double* tau, double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssytrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ipiv,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dsytrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ipiv,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_csytrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_zsytrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_ssytri_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda,
+                                const lapack_int* ipiv, float* work );
+lapack_int LAPACKE_dsytri_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda,
+                                const lapack_int* ipiv, double* work );
+lapack_int LAPACKE_csytri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zsytri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_ssytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dsytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_csytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zsytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const float* ab, lapack_int ldab, float* rcond,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const double* ab, lapack_int ldab,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_ztbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const float* ab,
+                                lapack_int ldab, const float* b, lapack_int ldb,
+                                const float* x, lapack_int ldx, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const double* ab,
+                                lapack_int ldab, const double* b,
+                                lapack_int ldb, const double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const lapack_complex_float* ab,
+                                lapack_int ldab, const lapack_complex_float* b,
+                                lapack_int ldb, const lapack_complex_float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, const lapack_complex_double* b,
+                                lapack_int ldb, const lapack_complex_double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const float* ab,
+                                lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dtbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const double* ab,
+                                lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_ctbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const lapack_complex_float* ab,
+                                lapack_int ldab, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_ztbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_stfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, float alpha, const float* a,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dtfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, double alpha, const double* a,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_ctfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, lapack_complex_float alpha,
+                               const lapack_complex_float* a,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, lapack_complex_double alpha,
+                               const lapack_complex_double* a,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n, float* a );
+lapack_int LAPACKE_dtftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n, double* a );
+lapack_int LAPACKE_ctftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n,
+                                lapack_complex_float* a );
+lapack_int LAPACKE_ztftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n,
+                                lapack_complex_double* a );
+
+lapack_int LAPACKE_stfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* arf, float* ap );
+lapack_int LAPACKE_dtfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* arf, double* ap );
+lapack_int LAPACKE_ctfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* arf,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_ztfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* arf,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_stfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* arf, float* a,
+                                lapack_int lda );
+lapack_int LAPACKE_dtfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* arf, double* a,
+                                lapack_int lda );
+lapack_int LAPACKE_ctfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* arf,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* arf,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_stgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const float* s, lapack_int lds, const float* p,
+                                lapack_int ldp, float* vl, lapack_int ldvl,
+                                float* vr, lapack_int ldvr, lapack_int mm,
+                                lapack_int* m, float* work );
+lapack_int LAPACKE_dtgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const double* s, lapack_int lds,
+                                const double* p, lapack_int ldp, double* vl,
+                                lapack_int ldvl, double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, double* work );
+lapack_int LAPACKE_ctgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_float* s, lapack_int lds,
+                                const lapack_complex_float* p, lapack_int ldp,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_double* s, lapack_int lds,
+                                const lapack_complex_double* p, lapack_int ldp,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float* q, lapack_int ldq, float* z,
+                                lapack_int ldz, lapack_int* ifst,
+                                lapack_int* ilst, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dtgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* q, lapack_int ldq, double* z,
+                                lapack_int ldz, lapack_int* ifst,
+                                lapack_int* ilst, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_ctgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_stgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float* alphar, float* alphai,
+                                float* beta, float* q, lapack_int ldq, float* z,
+                                lapack_int ldz, lapack_int* m, float* pl,
+                                float* pr, float* dif, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dtgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double* alphar, double* alphai,
+                                double* beta, double* q, lapack_int ldq,
+                                double* z, lapack_int ldz, lapack_int* m,
+                                double* pl, double* pr, double* dif,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_ctgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int* m, float* pl, float* pr, float* dif,
+                                lapack_complex_float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_ztgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int* m, double* pl, double* pr,
+                                double* dif, lapack_complex_double* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_stgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float tola, float tolb,
+                                float* alpha, float* beta, float* u,
+                                lapack_int ldu, float* v, lapack_int ldv,
+                                float* q, lapack_int ldq, float* work,
+                                lapack_int* ncycle );
+lapack_int LAPACKE_dtgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double tola, double tolb,
+                                double* alpha, double* beta, double* u,
+                                lapack_int ldu, double* v, lapack_int ldv,
+                                double* q, lapack_int ldq, double* work,
+                                lapack_int* ncycle );
+lapack_int LAPACKE_ctgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float tola, float tolb, float* alpha,
+                                float* beta, lapack_complex_float* u,
+                                lapack_int ldu, lapack_complex_float* v,
+                                lapack_int ldv, lapack_complex_float* q,
+                                lapack_int ldq, lapack_complex_float* work,
+                                lapack_int* ncycle );
+lapack_int LAPACKE_ztgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double tola, double tolb, double* alpha,
+                                double* beta, lapack_complex_double* u,
+                                lapack_int ldu, lapack_complex_double* v,
+                                lapack_int ldv, lapack_complex_double* q,
+                                lapack_int ldq, lapack_complex_double* work,
+                                lapack_int* ncycle );
+
+lapack_int LAPACKE_stgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const float* a, lapack_int lda, const float* b,
+                                lapack_int ldb, const float* vl,
+                                lapack_int ldvl, const float* vr,
+                                lapack_int ldvr, float* s, float* dif,
+                                lapack_int mm, lapack_int* m, float* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_dtgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const double* b, lapack_int ldb,
+                                const double* vl, lapack_int ldvl,
+                                const double* vr, lapack_int ldvr, double* s,
+                                double* dif, lapack_int mm, lapack_int* m,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                const lapack_complex_float* vl, lapack_int ldvl,
+                                const lapack_complex_float* vr, lapack_int ldvr,
+                                float* s, float* dif, lapack_int mm,
+                                lapack_int* m, lapack_complex_float* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_ztgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                const lapack_complex_double* vl,
+                                lapack_int ldvl,
+                                const lapack_complex_double* vr,
+                                lapack_int ldvr, double* s, double* dif,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, lapack_int lwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_stgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n, const float* a,
+                                lapack_int lda, const float* b, lapack_int ldb,
+                                float* c, lapack_int ldc, const float* d,
+                                lapack_int ldd, const float* e, lapack_int lde,
+                                float* f, lapack_int ldf, float* scale,
+                                float* dif, float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dtgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n, const double* a,
+                                lapack_int lda, const double* b, lapack_int ldb,
+                                double* c, lapack_int ldc, const double* d,
+                                lapack_int ldd, const double* e, lapack_int lde,
+                                double* f, lapack_int ldf, double* scale,
+                                double* dif, double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* c, lapack_int ldc,
+                                const lapack_complex_float* d, lapack_int ldd,
+                                const lapack_complex_float* e, lapack_int lde,
+                                lapack_complex_float* f, lapack_int ldf,
+                                float* scale, float* dif,
+                                lapack_complex_float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ztgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* c, lapack_int ldc,
+                                const lapack_complex_double* d, lapack_int ldd,
+                                const lapack_complex_double* e, lapack_int lde,
+                                lapack_complex_double* f, lapack_int ldf,
+                                double* scale, double* dif,
+                                lapack_complex_double* work, lapack_int lwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_stpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const float* ap,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const double* ap,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_float* ap, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_double* ap, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* ap, const float* b, lapack_int ldb,
+                                const float* x, lapack_int ldx, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* ap, const double* b,
+                                lapack_int ldb, const double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                const lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                const lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, float* ap );
+lapack_int LAPACKE_dtptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, double* ap );
+lapack_int LAPACKE_ctptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_float* ap );
+lapack_int LAPACKE_ztptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_double* ap );
+
+lapack_int LAPACKE_stptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* ap, float* b, lapack_int ldb );
+lapack_int LAPACKE_dtptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* ap, double* b, lapack_int ldb );
+lapack_int LAPACKE_ctptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* ap, float* arf );
+lapack_int LAPACKE_dtpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* ap, double* arf );
+lapack_int LAPACKE_ctpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* ap,
+                                lapack_complex_float* arf );
+lapack_int LAPACKE_ztpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* ap,
+                                lapack_complex_double* arf );
+
+lapack_int LAPACKE_stpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, float* a, lapack_int lda );
+lapack_int LAPACKE_dtpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, double* a, lapack_int lda );
+lapack_int LAPACKE_ctpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_strcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const float* a,
+                                lapack_int lda, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dtrcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const double* a,
+                                lapack_int lda, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctrcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_ztrcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* rcond, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_strevc_work( int matrix_order, char side, char howmny,
+                                lapack_logical* select, lapack_int n,
+                                const float* t, lapack_int ldt, float* vl,
+                                lapack_int ldvl, float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, float* work );
+lapack_int LAPACKE_dtrevc_work( int matrix_order, char side, char howmny,
+                                lapack_logical* select, lapack_int n,
+                                const double* t, lapack_int ldt, double* vl,
+                                lapack_int ldvl, double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, double* work );
+lapack_int LAPACKE_ctrevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztrevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_strexc_work( int matrix_order, char compq, lapack_int n,
+                                float* t, lapack_int ldt, float* q,
+                                lapack_int ldq, lapack_int* ifst,
+                                lapack_int* ilst, float* work );
+lapack_int LAPACKE_dtrexc_work( int matrix_order, char compq, lapack_int n,
+                                double* t, lapack_int ldt, double* q,
+                                lapack_int ldq, lapack_int* ifst,
+                                lapack_int* ilst, double* work );
+lapack_int LAPACKE_ctrexc_work( int matrix_order, char compq, lapack_int n,
+                                lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztrexc_work( int matrix_order, char compq, lapack_int n,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_strrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* a, lapack_int lda, const float* b,
+                                lapack_int ldb, const float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dtrrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* a, lapack_int lda,
+                                const double* b, lapack_int ldb,
+                                const double* x, lapack_int ldx, double* ferr,
+                                double* berr, double* work, lapack_int* iwork );
+lapack_int LAPACKE_ctrrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                const lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztrrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                const lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_strsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                float* t, lapack_int ldt, float* q,
+                                lapack_int ldq, float* wr, float* wi,
+                                lapack_int* m, float* s, float* sep,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dtrsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                double* t, lapack_int ldt, double* q,
+                                lapack_int ldq, double* wr, double* wi,
+                                lapack_int* m, double* s, double* sep,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_ctrsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* w, lapack_int* m,
+                                float* s, float* sep,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_ztrsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* w, lapack_int* m,
+                                double* s, double* sep,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_strsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const float* t, lapack_int ldt, const float* vl,
+                                lapack_int ldvl, const float* vr,
+                                lapack_int ldvr, float* s, float* sep,
+                                lapack_int mm, lapack_int* m, float* work,
+                                lapack_int ldwork, lapack_int* iwork );
+lapack_int LAPACKE_dtrsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const double* t, lapack_int ldt,
+                                const double* vl, lapack_int ldvl,
+                                const double* vr, lapack_int ldvr, double* s,
+                                double* sep, lapack_int mm, lapack_int* m,
+                                double* work, lapack_int ldwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctrsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_float* t, lapack_int ldt,
+                                const lapack_complex_float* vl, lapack_int ldvl,
+                                const lapack_complex_float* vr, lapack_int ldvr,
+                                float* s, float* sep, lapack_int mm,
+                                lapack_int* m, lapack_complex_float* work,
+                                lapack_int ldwork, float* rwork );
+lapack_int LAPACKE_ztrsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_double* t, lapack_int ldt,
+                                const lapack_complex_double* vl,
+                                lapack_int ldvl,
+                                const lapack_complex_double* vr,
+                                lapack_int ldvr, double* s, double* sep,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, lapack_int ldwork,
+                                double* rwork );
+
+lapack_int LAPACKE_strsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const float* a, lapack_int lda, const float* b,
+                                lapack_int ldb, float* c, lapack_int ldc,
+                                float* scale );
+lapack_int LAPACKE_dtrsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const double* b, lapack_int ldb, double* c,
+                                lapack_int ldc, double* scale );
+lapack_int LAPACKE_ctrsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* c, lapack_int ldc,
+                                float* scale );
+lapack_int LAPACKE_ztrsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* c, lapack_int ldc,
+                                double* scale );
+
+lapack_int LAPACKE_strtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, float* a, lapack_int lda );
+lapack_int LAPACKE_dtrtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, double* a, lapack_int lda );
+lapack_int LAPACKE_ctrtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda );
+lapack_int LAPACKE_ztrtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda );
+
+lapack_int LAPACKE_strtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* a, lapack_int lda, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dtrtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* a, lapack_int lda, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_ctrtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztrtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_strttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* arf );
+lapack_int LAPACKE_dtrttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* arf );
+lapack_int LAPACKE_ctrttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* arf );
+lapack_int LAPACKE_ztrttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* arf );
+
+lapack_int LAPACKE_strttp_work( int matrix_order, char uplo, lapack_int n,
+                                const float* a, lapack_int lda, float* ap );
+lapack_int LAPACKE_dtrttp_work( int matrix_order, char uplo, lapack_int n,
+                                const double* a, lapack_int lda, double* ap );
+lapack_int LAPACKE_ctrttp_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_ztrttp_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_stzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dtzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_ctzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_ztzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungtr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungtr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cupgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zupgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_cupmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zupmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_claghe( int matrix_order, lapack_int n, lapack_int k,
+                           const float* d, lapack_complex_float* a,
+                           lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_zlaghe( int matrix_order, lapack_int n, lapack_int k,
+                           const double* d, lapack_complex_double* a,
+                           lapack_int lda, lapack_int* iseed );
+
+lapack_int LAPACKE_slagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const float* d, float* a, lapack_int lda,
+                           lapack_int* iseed );
+lapack_int LAPACKE_dlagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const double* d, double* a, lapack_int lda,
+                           lapack_int* iseed );
+lapack_int LAPACKE_clagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const float* d, lapack_complex_float* a,
+                           lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_zlagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const double* d, lapack_complex_double* a,
+                           lapack_int lda, lapack_int* iseed );
+
+lapack_int LAPACKE_slapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, float* x, lapack_int ldx,
+                           lapack_int* k );
+lapack_int LAPACKE_dlapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, double* x,
+                           lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_clapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, lapack_complex_float* x,
+                           lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_zlapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, lapack_complex_double* x,
+                           lapack_int ldx, lapack_int* k );
+
+
+float LAPACKE_slapy2( float x, float y );
+double LAPACKE_dlapy2( double x, double y );
+
+float LAPACKE_slapy3( float x, float y, float z );
+double LAPACKE_dlapy3( double x, double y, double z );
+
+lapack_int LAPACKE_slartgp( float f, float g, float* cs, float* sn, float* r );
+lapack_int LAPACKE_dlartgp( double f, double g, double* cs, double* sn,
+                            double* r );
+
+lapack_int LAPACKE_slartgs( float x, float y, float sigma, float* cs,
+                            float* sn );
+lapack_int LAPACKE_dlartgs( double x, double y, double sigma, double* cs,
+                            double* sn );
+
+
+//LAPACK 3.3.0
+lapack_int LAPACKE_cbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, float* theta, float* phi,
+                           lapack_complex_float* u1, lapack_int ldu1,
+                           lapack_complex_float* u2, lapack_int ldu2,
+                           lapack_complex_float* v1t, lapack_int ldv1t,
+                           lapack_complex_float* v2t, lapack_int ldv2t,
+                           float* b11d, float* b11e, float* b12d, float* b12e,
+                           float* b21d, float* b21e, float* b22d, float* b22e );
+lapack_int LAPACKE_cbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                float* theta, float* phi,
+                                lapack_complex_float* u1, lapack_int ldu1,
+                                lapack_complex_float* u2, lapack_int ldu2,
+                                lapack_complex_float* v1t, lapack_int ldv1t,
+                                lapack_complex_float* v2t, lapack_int ldv2t,
+                                float* b11d, float* b11e, float* b12d,
+                                float* b12e, float* b21d, float* b21e,
+                                float* b22d, float* b22e, float* rwork,
+                                lapack_int lrwork );
+lapack_int LAPACKE_cheswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_cheswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_chetri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_chetri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_chetri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_chetri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_float* work, lapack_int nb );
+lapack_int LAPACKE_chetrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_float* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_chetrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_csyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_csyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, lapack_complex_float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_csyswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_csyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_csytri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_csytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_csytri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_csytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_float* work, lapack_int nb );
+lapack_int LAPACKE_csytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_float* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_csytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_cunbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_float* x11, lapack_int ldx11,
+                           lapack_complex_float* x12, lapack_int ldx12,
+                           lapack_complex_float* x21, lapack_int ldx21,
+                           lapack_complex_float* x22, lapack_int ldx22,
+                           float* theta, float* phi,
+                           lapack_complex_float* taup1,
+                           lapack_complex_float* taup2,
+                           lapack_complex_float* tauq1,
+                           lapack_complex_float* tauq2 );
+lapack_int LAPACKE_cunbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                lapack_complex_float* x11, lapack_int ldx11,
+                                lapack_complex_float* x12, lapack_int ldx12,
+                                lapack_complex_float* x21, lapack_int ldx21,
+                                lapack_complex_float* x22, lapack_int ldx22,
+                                float* theta, float* phi,
+                                lapack_complex_float* taup1,
+                                lapack_complex_float* taup2,
+                                lapack_complex_float* tauq1,
+                                lapack_complex_float* tauq2,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_cuncsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_float* x11, lapack_int ldx11,
+                           lapack_complex_float* x12, lapack_int ldx12,
+                           lapack_complex_float* x21, lapack_int ldx21,
+                           lapack_complex_float* x22, lapack_int ldx22,
+                           float* theta, lapack_complex_float* u1,
+                           lapack_int ldu1, lapack_complex_float* u2,
+                           lapack_int ldu2, lapack_complex_float* v1t,
+                           lapack_int ldv1t, lapack_complex_float* v2t,
+                           lapack_int ldv2t );
+lapack_int LAPACKE_cuncsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, lapack_complex_float* x11,
+                                lapack_int ldx11, lapack_complex_float* x12,
+                                lapack_int ldx12, lapack_complex_float* x21,
+                                lapack_int ldx21, lapack_complex_float* x22,
+                                lapack_int ldx22, float* theta,
+                                lapack_complex_float* u1, lapack_int ldu1,
+                                lapack_complex_float* u2, lapack_int ldu2,
+                                lapack_complex_float* v1t, lapack_int ldv1t,
+                                lapack_complex_float* v2t, lapack_int ldv2t,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, double* theta,
+                           double* phi, double* u1, lapack_int ldu1, double* u2,
+                           lapack_int ldu2, double* v1t, lapack_int ldv1t,
+                           double* v2t, lapack_int ldv2t, double* b11d,
+                           double* b11e, double* b12d, double* b12e,
+                           double* b21d, double* b21e, double* b22d,
+                           double* b22e );
+lapack_int LAPACKE_dbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                double* theta, double* phi, double* u1,
+                                lapack_int ldu1, double* u2, lapack_int ldu2,
+                                double* v1t, lapack_int ldv1t, double* v2t,
+                                lapack_int ldv2t, double* b11d, double* b11e,
+                                double* b12d, double* b12e, double* b21d,
+                                double* b21e, double* b22d, double* b22e,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_dorbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           double* x11, lapack_int ldx11, double* x12,
+                           lapack_int ldx12, double* x21, lapack_int ldx21,
+                           double* x22, lapack_int ldx22, double* theta,
+                           double* phi, double* taup1, double* taup2,
+                           double* tauq1, double* tauq2 );
+lapack_int LAPACKE_dorbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                double* x11, lapack_int ldx11, double* x12,
+                                lapack_int ldx12, double* x21, lapack_int ldx21,
+                                double* x22, lapack_int ldx22, double* theta,
+                                double* phi, double* taup1, double* taup2,
+                                double* tauq1, double* tauq2, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           double* x11, lapack_int ldx11, double* x12,
+                           lapack_int ldx12, double* x21, lapack_int ldx21,
+                           double* x22, lapack_int ldx22, double* theta,
+                           double* u1, lapack_int ldu1, double* u2,
+                           lapack_int ldu2, double* v1t, lapack_int ldv1t,
+                           double* v2t, lapack_int ldv2t );
+lapack_int LAPACKE_dorcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, double* x11, lapack_int ldx11,
+                                double* x12, lapack_int ldx12, double* x21,
+                                lapack_int ldx21, double* x22, lapack_int ldx22,
+                                double* theta, double* u1, lapack_int ldu1,
+                                double* u2, lapack_int ldu2, double* v1t,
+                                lapack_int ldv1t, double* v2t, lapack_int ldv2t,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dsyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            double* a, lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dsyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, double* a, lapack_int lda,
+                                 const lapack_int* ipiv, double* work );
+lapack_int LAPACKE_dsyswapr( int matrix_order, char uplo, lapack_int n,
+                             double* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_dsyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  double* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_dsytri2( int matrix_order, char uplo, lapack_int n,
+                            double* a, lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dsytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 double* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_dsytri2x( int matrix_order, char uplo, lapack_int n,
+                             double* a, lapack_int lda, const lapack_int* ipiv,
+                             lapack_int nb );
+lapack_int LAPACKE_dsytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  double* a, lapack_int lda,
+                                  const lapack_int* ipiv, double* work,
+                                  lapack_int nb );
+lapack_int LAPACKE_dsytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const double* a, lapack_int lda,
+                            const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_dsytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 double* b, lapack_int ldb, double* work );
+lapack_int LAPACKE_sbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, float* theta, float* phi,
+                           float* u1, lapack_int ldu1, float* u2,
+                           lapack_int ldu2, float* v1t, lapack_int ldv1t,
+                           float* v2t, lapack_int ldv2t, float* b11d,
+                           float* b11e, float* b12d, float* b12e, float* b21d,
+                           float* b21e, float* b22d, float* b22e );
+lapack_int LAPACKE_sbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                float* theta, float* phi, float* u1,
+                                lapack_int ldu1, float* u2, lapack_int ldu2,
+                                float* v1t, lapack_int ldv1t, float* v2t,
+                                lapack_int ldv2t, float* b11d, float* b11e,
+                                float* b12d, float* b12e, float* b21d,
+                                float* b21e, float* b22d, float* b22e,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_sorbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q, float* x11,
+                           lapack_int ldx11, float* x12, lapack_int ldx12,
+                           float* x21, lapack_int ldx21, float* x22,
+                           lapack_int ldx22, float* theta, float* phi,
+                           float* taup1, float* taup2, float* tauq1,
+                           float* tauq2 );
+lapack_int LAPACKE_sorbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                float* x11, lapack_int ldx11, float* x12,
+                                lapack_int ldx12, float* x21, lapack_int ldx21,
+                                float* x22, lapack_int ldx22, float* theta,
+                                float* phi, float* taup1, float* taup2,
+                                float* tauq1, float* tauq2, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_sorcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q, float* x11,
+                           lapack_int ldx11, float* x12, lapack_int ldx12,
+                           float* x21, lapack_int ldx21, float* x22,
+                           lapack_int ldx22, float* theta, float* u1,
+                           lapack_int ldu1, float* u2, lapack_int ldu2,
+                           float* v1t, lapack_int ldv1t, float* v2t,
+                           lapack_int ldv2t );
+lapack_int LAPACKE_sorcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, float* x11, lapack_int ldx11,
+                                float* x12, lapack_int ldx12, float* x21,
+                                lapack_int ldx21, float* x22, lapack_int ldx22,
+                                float* theta, float* u1, lapack_int ldu1,
+                                float* u2, lapack_int ldu2, float* v1t,
+                                lapack_int ldv1t, float* v2t, lapack_int ldv2t,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ssyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            float* a, lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_ssyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, float* a, lapack_int lda,
+                                 const lapack_int* ipiv, float* work );
+lapack_int LAPACKE_ssyswapr( int matrix_order, char uplo, lapack_int n,
+                             float* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_ssyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  float* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_ssytri2( int matrix_order, char uplo, lapack_int n, float* a,
+                            lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_ssytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 float* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_ssytri2x( int matrix_order, char uplo, lapack_int n,
+                             float* a, lapack_int lda, const lapack_int* ipiv,
+                             lapack_int nb );
+lapack_int LAPACKE_ssytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  float* a, lapack_int lda,
+                                  const lapack_int* ipiv, float* work,
+                                  lapack_int nb );
+lapack_int LAPACKE_ssytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const float* a, lapack_int lda,
+                            const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_ssytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 float* b, lapack_int ldb, float* work );
+lapack_int LAPACKE_zbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, double* theta,
+                           double* phi, lapack_complex_double* u1,
+                           lapack_int ldu1, lapack_complex_double* u2,
+                           lapack_int ldu2, lapack_complex_double* v1t,
+                           lapack_int ldv1t, lapack_complex_double* v2t,
+                           lapack_int ldv2t, double* b11d, double* b11e,
+                           double* b12d, double* b12e, double* b21d,
+                           double* b21e, double* b22d, double* b22e );
+lapack_int LAPACKE_zbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                double* theta, double* phi,
+                                lapack_complex_double* u1, lapack_int ldu1,
+                                lapack_complex_double* u2, lapack_int ldu2,
+                                lapack_complex_double* v1t, lapack_int ldv1t,
+                                lapack_complex_double* v2t, lapack_int ldv2t,
+                                double* b11d, double* b11e, double* b12d,
+                                double* b12e, double* b21d, double* b21e,
+                                double* b22d, double* b22e, double* rwork,
+                                lapack_int lrwork );
+lapack_int LAPACKE_zheswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_zheswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_zhetri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_zhetri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_zhetri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_zhetri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_double* work, lapack_int nb );
+lapack_int LAPACKE_zhetrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_double* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_double* b, lapack_int ldb );
+lapack_int LAPACKE_zhetrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* work );
+lapack_int LAPACKE_zsyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_zsyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, lapack_complex_double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_double* work );
+lapack_int LAPACKE_zsyswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_zsyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_zsytri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_zsytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_zsytri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_zsytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_double* work, lapack_int nb );
+lapack_int LAPACKE_zsytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_double* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_double* b, lapack_int ldb );
+lapack_int LAPACKE_zsytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* work );
+lapack_int LAPACKE_zunbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_double* x11, lapack_int ldx11,
+                           lapack_complex_double* x12, lapack_int ldx12,
+                           lapack_complex_double* x21, lapack_int ldx21,
+                           lapack_complex_double* x22, lapack_int ldx22,
+                           double* theta, double* phi,
+                           lapack_complex_double* taup1,
+                           lapack_complex_double* taup2,
+                           lapack_complex_double* tauq1,
+                           lapack_complex_double* tauq2 );
+lapack_int LAPACKE_zunbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                lapack_complex_double* x11, lapack_int ldx11,
+                                lapack_complex_double* x12, lapack_int ldx12,
+                                lapack_complex_double* x21, lapack_int ldx21,
+                                lapack_complex_double* x22, lapack_int ldx22,
+                                double* theta, double* phi,
+                                lapack_complex_double* taup1,
+                                lapack_complex_double* taup2,
+                                lapack_complex_double* tauq1,
+                                lapack_complex_double* tauq2,
+                                lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_zuncsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_double* x11, lapack_int ldx11,
+                           lapack_complex_double* x12, lapack_int ldx12,
+                           lapack_complex_double* x21, lapack_int ldx21,
+                           lapack_complex_double* x22, lapack_int ldx22,
+                           double* theta, lapack_complex_double* u1,
+                           lapack_int ldu1, lapack_complex_double* u2,
+                           lapack_int ldu2, lapack_complex_double* v1t,
+                           lapack_int ldv1t, lapack_complex_double* v2t,
+                           lapack_int ldv2t );
+lapack_int LAPACKE_zuncsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, lapack_complex_double* x11,
+                                lapack_int ldx11, lapack_complex_double* x12,
+                                lapack_int ldx12, lapack_complex_double* x21,
+                                lapack_int ldx21, lapack_complex_double* x22,
+                                lapack_int ldx22, double* theta,
+                                lapack_complex_double* u1, lapack_int ldu1,
+                                lapack_complex_double* u2, lapack_int ldu2,
+                                lapack_complex_double* v1t, lapack_int ldv1t,
+                                lapack_complex_double* v2t, lapack_int ldv2t,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork );
+//LAPACK 3.4.0
+lapack_int LAPACKE_sgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const float* v, lapack_int ldv,
+                            const float* t, lapack_int ldt, float* c,
+                            lapack_int ldc );
+lapack_int LAPACKE_dgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const double* v, lapack_int ldv,
+                            const double* t, lapack_int ldt, double* c,
+                            lapack_int ldc );
+lapack_int LAPACKE_cgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const lapack_complex_float* v,
+                            lapack_int ldv, const lapack_complex_float* t,
+                            lapack_int ldt, lapack_complex_float* c,
+                            lapack_int ldc );
+lapack_int LAPACKE_zgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const lapack_complex_double* v,
+                            lapack_int ldv, const lapack_complex_double* t,
+                            lapack_int ldt, lapack_complex_double* c,
+                            lapack_int ldc );
+
+lapack_int LAPACKE_sgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, float* a, lapack_int lda, float* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_dgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, double* a, lapack_int lda, double* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_cgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_zgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* t,
+                           lapack_int ldt );
+
+lapack_int LAPACKE_sgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_dgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_cgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_sgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_dgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_cgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb, const float* v,
+                            lapack_int ldv, const float* t, lapack_int ldt,
+                            float* a, lapack_int lda, float* b,
+                            lapack_int ldb );
+lapack_int LAPACKE_dtpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb, const double* v,
+                            lapack_int ldv, const double* t, lapack_int ldt,
+                            double* a, lapack_int lda, double* b,
+                            lapack_int ldb );
+lapack_int LAPACKE_ctpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb,
+                            const lapack_complex_float* v, lapack_int ldv,
+                            const lapack_complex_float* t, lapack_int ldt,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb,
+                            const lapack_complex_double* v, lapack_int ldv,
+                            const lapack_complex_double* t, lapack_int ldt,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_dtpqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int l, lapack_int nb, double* a,
+                           lapack_int lda, double* b, lapack_int ldb, double* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_ctpqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int l, lapack_int nb, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* t,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_int ldt );
+lapack_int LAPACKE_ztpqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int l, lapack_int nb,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* b, lapack_int ldb,
+                            float* t, lapack_int ldt );
+lapack_int LAPACKE_dtpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* b,
+                            lapack_int ldb, double* t, lapack_int ldt );
+lapack_int LAPACKE_ctpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_ztpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l, const float* v,
+                           lapack_int ldv, const float* t, lapack_int ldt,
+                           float* a, lapack_int lda, float* b, lapack_int ldb,
+                           lapack_int myldwork );
+lapack_int LAPACKE_dtprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l, const double* v,
+                           lapack_int ldv, const double* t, lapack_int ldt,
+                           double* a, lapack_int lda, double* b, lapack_int ldb,
+                           lapack_int myldwork );
+lapack_int LAPACKE_ctprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l,
+                           const lapack_complex_float* v, lapack_int ldv,
+                           const lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_int myldwork );
+lapack_int LAPACKE_ztprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l,
+                           const lapack_complex_double* v, lapack_int ldv,
+                           const lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_int myldwork );
+
+lapack_int LAPACKE_sgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const float* v, lapack_int ldv,
+                                 const float* t, lapack_int ldt, float* c,
+                                 lapack_int ldc, float* work );
+lapack_int LAPACKE_dgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const double* v, lapack_int ldv,
+                                 const double* t, lapack_int ldt, double* c,
+                                 lapack_int ldc, double* work );
+lapack_int LAPACKE_cgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const lapack_complex_float* v,
+                                 lapack_int ldv, const lapack_complex_float* t,
+                                 lapack_int ldt, lapack_complex_float* c,
+                                 lapack_int ldc, lapack_complex_float* work );
+lapack_int LAPACKE_zgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const lapack_complex_double* v,
+                                 lapack_int ldv, const lapack_complex_double* t,
+                                 lapack_int ldt, lapack_complex_double* c,
+                                 lapack_int ldc, lapack_complex_double* work );
+
+lapack_int LAPACKE_sgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, float* a, lapack_int lda,
+                                float* t, lapack_int ldt, float* work );
+lapack_int LAPACKE_dgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, double* a, lapack_int lda,
+                                double* t, lapack_int ldt, double* work );
+lapack_int LAPACKE_cgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* t,
+                                lapack_int ldt, lapack_complex_float* work );
+lapack_int LAPACKE_zgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* t,
+                                lapack_int ldt, lapack_complex_double* work );
+
+lapack_int LAPACKE_sgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_dgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_cgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_sgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_dgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_cgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb, const float* v,
+                                 lapack_int ldv, const float* t, lapack_int ldt,
+                                 float* a, lapack_int lda, float* b,
+                                 lapack_int ldb, float* work );
+lapack_int LAPACKE_dtpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb, const double* v,
+                                 lapack_int ldv, const double* t,
+                                 lapack_int ldt, double* a, lapack_int lda,
+                                 double* b, lapack_int ldb, double* work );
+lapack_int LAPACKE_ctpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb,
+                                 const lapack_complex_float* v, lapack_int ldv,
+                                 const lapack_complex_float* t, lapack_int ldt,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_ztpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb,
+                                 const lapack_complex_double* v, lapack_int ldv,
+                                 const lapack_complex_double* t, lapack_int ldt,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* work );
+
+lapack_int LAPACKE_dtpqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int l, lapack_int nb, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* t, lapack_int ldt, double* work );
+lapack_int LAPACKE_ctpqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int l, lapack_int nb,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* t,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_int ldt, lapack_complex_float* work );
+lapack_int LAPACKE_ztpqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int l, lapack_int nb,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_stpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* b,
+                                 lapack_int ldb, float* t, lapack_int ldt );
+lapack_int LAPACKE_dtpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* b,
+                                 lapack_int ldb, double* t, lapack_int ldt );
+lapack_int LAPACKE_ctpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_ztpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const float* v, lapack_int ldv, const float* t,
+                                lapack_int ldt, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, const float* mywork,
+                                lapack_int myldwork );
+lapack_int LAPACKE_dtprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const double* v, lapack_int ldv,
+                                const double* t, lapack_int ldt, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                const double* mywork, lapack_int myldwork );
+lapack_int LAPACKE_ctprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const lapack_complex_float* v, lapack_int ldv,
+                                const lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                const float* mywork, lapack_int myldwork );
+lapack_int LAPACKE_ztprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const lapack_complex_double* v, lapack_int ldv,
+                                const lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                const double* mywork, lapack_int myldwork );
+//LAPACK 3.X.X
+lapack_int LAPACKE_csyr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float alpha,
+                             const lapack_complex_float* x, lapack_int incx,
+                             lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zsyr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double alpha,
+                             const lapack_complex_double* x, lapack_int incx,
+                             lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_csyr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float alpha,
+                                  const lapack_complex_float* x,
+                                  lapack_int incx, lapack_complex_float* a,
+                                  lapack_int lda );
+lapack_int LAPACKE_zsyr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double alpha,
+                                  const lapack_complex_double* x,
+                                  lapack_int incx, lapack_complex_double* a,
+                                  lapack_int lda );
+
+
+
+#define LAPACK_sgetrf LAPACK_GLOBAL(sgetrf,SGETRF)
+#define LAPACK_dgetrf LAPACK_GLOBAL(dgetrf,DGETRF)
+#define LAPACK_cgetrf LAPACK_GLOBAL(cgetrf,CGETRF)
+#define LAPACK_zgetrf LAPACK_GLOBAL(zgetrf,ZGETRF)
+#define LAPACK_sgbtrf LAPACK_GLOBAL(sgbtrf,SGBTRF)
+#define LAPACK_dgbtrf LAPACK_GLOBAL(dgbtrf,DGBTRF)
+#define LAPACK_cgbtrf LAPACK_GLOBAL(cgbtrf,CGBTRF)
+#define LAPACK_zgbtrf LAPACK_GLOBAL(zgbtrf,ZGBTRF)
+#define LAPACK_sgttrf LAPACK_GLOBAL(sgttrf,SGTTRF)
+#define LAPACK_dgttrf LAPACK_GLOBAL(dgttrf,DGTTRF)
+#define LAPACK_cgttrf LAPACK_GLOBAL(cgttrf,CGTTRF)
+#define LAPACK_zgttrf LAPACK_GLOBAL(zgttrf,ZGTTRF)
+#define LAPACK_spotrf LAPACK_GLOBAL(spotrf,SPOTRF)
+#define LAPACK_dpotrf LAPACK_GLOBAL(dpotrf,DPOTRF)
+#define LAPACK_cpotrf LAPACK_GLOBAL(cpotrf,CPOTRF)
+#define LAPACK_zpotrf LAPACK_GLOBAL(zpotrf,ZPOTRF)
+#define LAPACK_dpstrf LAPACK_GLOBAL(dpstrf,DPSTRF)
+#define LAPACK_spstrf LAPACK_GLOBAL(spstrf,SPSTRF)
+#define LAPACK_zpstrf LAPACK_GLOBAL(zpstrf,ZPSTRF)
+#define LAPACK_cpstrf LAPACK_GLOBAL(cpstrf,CPSTRF)
+#define LAPACK_dpftrf LAPACK_GLOBAL(dpftrf,DPFTRF)
+#define LAPACK_spftrf LAPACK_GLOBAL(spftrf,SPFTRF)
+#define LAPACK_zpftrf LAPACK_GLOBAL(zpftrf,ZPFTRF)
+#define LAPACK_cpftrf LAPACK_GLOBAL(cpftrf,CPFTRF)
+#define LAPACK_spptrf LAPACK_GLOBAL(spptrf,SPPTRF)
+#define LAPACK_dpptrf LAPACK_GLOBAL(dpptrf,DPPTRF)
+#define LAPACK_cpptrf LAPACK_GLOBAL(cpptrf,CPPTRF)
+#define LAPACK_zpptrf LAPACK_GLOBAL(zpptrf,ZPPTRF)
+#define LAPACK_spbtrf LAPACK_GLOBAL(spbtrf,SPBTRF)
+#define LAPACK_dpbtrf LAPACK_GLOBAL(dpbtrf,DPBTRF)
+#define LAPACK_cpbtrf LAPACK_GLOBAL(cpbtrf,CPBTRF)
+#define LAPACK_zpbtrf LAPACK_GLOBAL(zpbtrf,ZPBTRF)
+#define LAPACK_spttrf LAPACK_GLOBAL(spttrf,SPTTRF)
+#define LAPACK_dpttrf LAPACK_GLOBAL(dpttrf,DPTTRF)
+#define LAPACK_cpttrf LAPACK_GLOBAL(cpttrf,CPTTRF)
+#define LAPACK_zpttrf LAPACK_GLOBAL(zpttrf,ZPTTRF)
+#define LAPACK_ssytrf LAPACK_GLOBAL(ssytrf,SSYTRF)
+#define LAPACK_dsytrf LAPACK_GLOBAL(dsytrf,DSYTRF)
+#define LAPACK_csytrf LAPACK_GLOBAL(csytrf,CSYTRF)
+#define LAPACK_zsytrf LAPACK_GLOBAL(zsytrf,ZSYTRF)
+#define LAPACK_chetrf LAPACK_GLOBAL(chetrf,CHETRF)
+#define LAPACK_zhetrf LAPACK_GLOBAL(zhetrf,ZHETRF)
+#define LAPACK_ssptrf LAPACK_GLOBAL(ssptrf,SSPTRF)
+#define LAPACK_dsptrf LAPACK_GLOBAL(dsptrf,DSPTRF)
+#define LAPACK_csptrf LAPACK_GLOBAL(csptrf,CSPTRF)
+#define LAPACK_zsptrf LAPACK_GLOBAL(zsptrf,ZSPTRF)
+#define LAPACK_chptrf LAPACK_GLOBAL(chptrf,CHPTRF)
+#define LAPACK_zhptrf LAPACK_GLOBAL(zhptrf,ZHPTRF)
+#define LAPACK_sgetrs LAPACK_GLOBAL(sgetrs,SGETRS)
+#define LAPACK_dgetrs LAPACK_GLOBAL(dgetrs,DGETRS)
+#define LAPACK_cgetrs LAPACK_GLOBAL(cgetrs,CGETRS)
+#define LAPACK_zgetrs LAPACK_GLOBAL(zgetrs,ZGETRS)
+#define LAPACK_sgbtrs LAPACK_GLOBAL(sgbtrs,SGBTRS)
+#define LAPACK_dgbtrs LAPACK_GLOBAL(dgbtrs,DGBTRS)
+#define LAPACK_cgbtrs LAPACK_GLOBAL(cgbtrs,CGBTRS)
+#define LAPACK_zgbtrs LAPACK_GLOBAL(zgbtrs,ZGBTRS)
+#define LAPACK_sgttrs LAPACK_GLOBAL(sgttrs,SGTTRS)
+#define LAPACK_dgttrs LAPACK_GLOBAL(dgttrs,DGTTRS)
+#define LAPACK_cgttrs LAPACK_GLOBAL(cgttrs,CGTTRS)
+#define LAPACK_zgttrs LAPACK_GLOBAL(zgttrs,ZGTTRS)
+#define LAPACK_spotrs LAPACK_GLOBAL(spotrs,SPOTRS)
+#define LAPACK_dpotrs LAPACK_GLOBAL(dpotrs,DPOTRS)
+#define LAPACK_cpotrs LAPACK_GLOBAL(cpotrs,CPOTRS)
+#define LAPACK_zpotrs LAPACK_GLOBAL(zpotrs,ZPOTRS)
+#define LAPACK_dpftrs LAPACK_GLOBAL(dpftrs,DPFTRS)
+#define LAPACK_spftrs LAPACK_GLOBAL(spftrs,SPFTRS)
+#define LAPACK_zpftrs LAPACK_GLOBAL(zpftrs,ZPFTRS)
+#define LAPACK_cpftrs LAPACK_GLOBAL(cpftrs,CPFTRS)
+#define LAPACK_spptrs LAPACK_GLOBAL(spptrs,SPPTRS)
+#define LAPACK_dpptrs LAPACK_GLOBAL(dpptrs,DPPTRS)
+#define LAPACK_cpptrs LAPACK_GLOBAL(cpptrs,CPPTRS)
+#define LAPACK_zpptrs LAPACK_GLOBAL(zpptrs,ZPPTRS)
+#define LAPACK_spbtrs LAPACK_GLOBAL(spbtrs,SPBTRS)
+#define LAPACK_dpbtrs LAPACK_GLOBAL(dpbtrs,DPBTRS)
+#define LAPACK_cpbtrs LAPACK_GLOBAL(cpbtrs,CPBTRS)
+#define LAPACK_zpbtrs LAPACK_GLOBAL(zpbtrs,ZPBTRS)
+#define LAPACK_spttrs LAPACK_GLOBAL(spttrs,SPTTRS)
+#define LAPACK_dpttrs LAPACK_GLOBAL(dpttrs,DPTTRS)
+#define LAPACK_cpttrs LAPACK_GLOBAL(cpttrs,CPTTRS)
+#define LAPACK_zpttrs LAPACK_GLOBAL(zpttrs,ZPTTRS)
+#define LAPACK_ssytrs LAPACK_GLOBAL(ssytrs,SSYTRS)
+#define LAPACK_dsytrs LAPACK_GLOBAL(dsytrs,DSYTRS)
+#define LAPACK_csytrs LAPACK_GLOBAL(csytrs,CSYTRS)
+#define LAPACK_zsytrs LAPACK_GLOBAL(zsytrs,ZSYTRS)
+#define LAPACK_chetrs LAPACK_GLOBAL(chetrs,CHETRS)
+#define LAPACK_zhetrs LAPACK_GLOBAL(zhetrs,ZHETRS)
+#define LAPACK_ssptrs LAPACK_GLOBAL(ssptrs,SSPTRS)
+#define LAPACK_dsptrs LAPACK_GLOBAL(dsptrs,DSPTRS)
+#define LAPACK_csptrs LAPACK_GLOBAL(csptrs,CSPTRS)
+#define LAPACK_zsptrs LAPACK_GLOBAL(zsptrs,ZSPTRS)
+#define LAPACK_chptrs LAPACK_GLOBAL(chptrs,CHPTRS)
+#define LAPACK_zhptrs LAPACK_GLOBAL(zhptrs,ZHPTRS)
+#define LAPACK_strtrs LAPACK_GLOBAL(strtrs,STRTRS)
+#define LAPACK_dtrtrs LAPACK_GLOBAL(dtrtrs,DTRTRS)
+#define LAPACK_ctrtrs LAPACK_GLOBAL(ctrtrs,CTRTRS)
+#define LAPACK_ztrtrs LAPACK_GLOBAL(ztrtrs,ZTRTRS)
+#define LAPACK_stptrs LAPACK_GLOBAL(stptrs,STPTRS)
+#define LAPACK_dtptrs LAPACK_GLOBAL(dtptrs,DTPTRS)
+#define LAPACK_ctptrs LAPACK_GLOBAL(ctptrs,CTPTRS)
+#define LAPACK_ztptrs LAPACK_GLOBAL(ztptrs,ZTPTRS)
+#define LAPACK_stbtrs LAPACK_GLOBAL(stbtrs,STBTRS)
+#define LAPACK_dtbtrs LAPACK_GLOBAL(dtbtrs,DTBTRS)
+#define LAPACK_ctbtrs LAPACK_GLOBAL(ctbtrs,CTBTRS)
+#define LAPACK_ztbtrs LAPACK_GLOBAL(ztbtrs,ZTBTRS)
+#define LAPACK_sgecon LAPACK_GLOBAL(sgecon,SGECON)
+#define LAPACK_dgecon LAPACK_GLOBAL(dgecon,DGECON)
+#define LAPACK_cgecon LAPACK_GLOBAL(cgecon,CGECON)
+#define LAPACK_zgecon LAPACK_GLOBAL(zgecon,ZGECON)
+#define LAPACK_sgbcon LAPACK_GLOBAL(sgbcon,SGBCON)
+#define LAPACK_dgbcon LAPACK_GLOBAL(dgbcon,DGBCON)
+#define LAPACK_cgbcon LAPACK_GLOBAL(cgbcon,CGBCON)
+#define LAPACK_zgbcon LAPACK_GLOBAL(zgbcon,ZGBCON)
+#define LAPACK_sgtcon LAPACK_GLOBAL(sgtcon,SGTCON)
+#define LAPACK_dgtcon LAPACK_GLOBAL(dgtcon,DGTCON)
+#define LAPACK_cgtcon LAPACK_GLOBAL(cgtcon,CGTCON)
+#define LAPACK_zgtcon LAPACK_GLOBAL(zgtcon,ZGTCON)
+#define LAPACK_spocon LAPACK_GLOBAL(spocon,SPOCON)
+#define LAPACK_dpocon LAPACK_GLOBAL(dpocon,DPOCON)
+#define LAPACK_cpocon LAPACK_GLOBAL(cpocon,CPOCON)
+#define LAPACK_zpocon LAPACK_GLOBAL(zpocon,ZPOCON)
+#define LAPACK_sppcon LAPACK_GLOBAL(sppcon,SPPCON)
+#define LAPACK_dppcon LAPACK_GLOBAL(dppcon,DPPCON)
+#define LAPACK_cppcon LAPACK_GLOBAL(cppcon,CPPCON)
+#define LAPACK_zppcon LAPACK_GLOBAL(zppcon,ZPPCON)
+#define LAPACK_spbcon LAPACK_GLOBAL(spbcon,SPBCON)
+#define LAPACK_dpbcon LAPACK_GLOBAL(dpbcon,DPBCON)
+#define LAPACK_cpbcon LAPACK_GLOBAL(cpbcon,CPBCON)
+#define LAPACK_zpbcon LAPACK_GLOBAL(zpbcon,ZPBCON)
+#define LAPACK_sptcon LAPACK_GLOBAL(sptcon,SPTCON)
+#define LAPACK_dptcon LAPACK_GLOBAL(dptcon,DPTCON)
+#define LAPACK_cptcon LAPACK_GLOBAL(cptcon,CPTCON)
+#define LAPACK_zptcon LAPACK_GLOBAL(zptcon,ZPTCON)
+#define LAPACK_ssycon LAPACK_GLOBAL(ssycon,SSYCON)
+#define LAPACK_dsycon LAPACK_GLOBAL(dsycon,DSYCON)
+#define LAPACK_csycon LAPACK_GLOBAL(csycon,CSYCON)
+#define LAPACK_zsycon LAPACK_GLOBAL(zsycon,ZSYCON)
+#define LAPACK_checon LAPACK_GLOBAL(checon,CHECON)
+#define LAPACK_zhecon LAPACK_GLOBAL(zhecon,ZHECON)
+#define LAPACK_sspcon LAPACK_GLOBAL(sspcon,SSPCON)
+#define LAPACK_dspcon LAPACK_GLOBAL(dspcon,DSPCON)
+#define LAPACK_cspcon LAPACK_GLOBAL(cspcon,CSPCON)
+#define LAPACK_zspcon LAPACK_GLOBAL(zspcon,ZSPCON)
+#define LAPACK_chpcon LAPACK_GLOBAL(chpcon,CHPCON)
+#define LAPACK_zhpcon LAPACK_GLOBAL(zhpcon,ZHPCON)
+#define LAPACK_strcon LAPACK_GLOBAL(strcon,STRCON)
+#define LAPACK_dtrcon LAPACK_GLOBAL(dtrcon,DTRCON)
+#define LAPACK_ctrcon LAPACK_GLOBAL(ctrcon,CTRCON)
+#define LAPACK_ztrcon LAPACK_GLOBAL(ztrcon,ZTRCON)
+#define LAPACK_stpcon LAPACK_GLOBAL(stpcon,STPCON)
+#define LAPACK_dtpcon LAPACK_GLOBAL(dtpcon,DTPCON)
+#define LAPACK_ctpcon LAPACK_GLOBAL(ctpcon,CTPCON)
+#define LAPACK_ztpcon LAPACK_GLOBAL(ztpcon,ZTPCON)
+#define LAPACK_stbcon LAPACK_GLOBAL(stbcon,STBCON)
+#define LAPACK_dtbcon LAPACK_GLOBAL(dtbcon,DTBCON)
+#define LAPACK_ctbcon LAPACK_GLOBAL(ctbcon,CTBCON)
+#define LAPACK_ztbcon LAPACK_GLOBAL(ztbcon,ZTBCON)
+#define LAPACK_sgerfs LAPACK_GLOBAL(sgerfs,SGERFS)
+#define LAPACK_dgerfs LAPACK_GLOBAL(dgerfs,DGERFS)
+#define LAPACK_cgerfs LAPACK_GLOBAL(cgerfs,CGERFS)
+#define LAPACK_zgerfs LAPACK_GLOBAL(zgerfs,ZGERFS)
+#define LAPACK_dgerfsx LAPACK_GLOBAL(dgerfsx,DGERFSX)
+#define LAPACK_sgerfsx LAPACK_GLOBAL(sgerfsx,SGERFSX)
+#define LAPACK_zgerfsx LAPACK_GLOBAL(zgerfsx,ZGERFSX)
+#define LAPACK_cgerfsx LAPACK_GLOBAL(cgerfsx,CGERFSX)
+#define LAPACK_sgbrfs LAPACK_GLOBAL(sgbrfs,SGBRFS)
+#define LAPACK_dgbrfs LAPACK_GLOBAL(dgbrfs,DGBRFS)
+#define LAPACK_cgbrfs LAPACK_GLOBAL(cgbrfs,CGBRFS)
+#define LAPACK_zgbrfs LAPACK_GLOBAL(zgbrfs,ZGBRFS)
+#define LAPACK_dgbrfsx LAPACK_GLOBAL(dgbrfsx,DGBRFSX)
+#define LAPACK_sgbrfsx LAPACK_GLOBAL(sgbrfsx,SGBRFSX)
+#define LAPACK_zgbrfsx LAPACK_GLOBAL(zgbrfsx,ZGBRFSX)
+#define LAPACK_cgbrfsx LAPACK_GLOBAL(cgbrfsx,CGBRFSX)
+#define LAPACK_sgtrfs LAPACK_GLOBAL(sgtrfs,SGTRFS)
+#define LAPACK_dgtrfs LAPACK_GLOBAL(dgtrfs,DGTRFS)
+#define LAPACK_cgtrfs LAPACK_GLOBAL(cgtrfs,CGTRFS)
+#define LAPACK_zgtrfs LAPACK_GLOBAL(zgtrfs,ZGTRFS)
+#define LAPACK_sporfs LAPACK_GLOBAL(sporfs,SPORFS)
+#define LAPACK_dporfs LAPACK_GLOBAL(dporfs,DPORFS)
+#define LAPACK_cporfs LAPACK_GLOBAL(cporfs,CPORFS)
+#define LAPACK_zporfs LAPACK_GLOBAL(zporfs,ZPORFS)
+#define LAPACK_dporfsx LAPACK_GLOBAL(dporfsx,DPORFSX)
+#define LAPACK_sporfsx LAPACK_GLOBAL(sporfsx,SPORFSX)
+#define LAPACK_zporfsx LAPACK_GLOBAL(zporfsx,ZPORFSX)
+#define LAPACK_cporfsx LAPACK_GLOBAL(cporfsx,CPORFSX)
+#define LAPACK_spprfs LAPACK_GLOBAL(spprfs,SPPRFS)
+#define LAPACK_dpprfs LAPACK_GLOBAL(dpprfs,DPPRFS)
+#define LAPACK_cpprfs LAPACK_GLOBAL(cpprfs,CPPRFS)
+#define LAPACK_zpprfs LAPACK_GLOBAL(zpprfs,ZPPRFS)
+#define LAPACK_spbrfs LAPACK_GLOBAL(spbrfs,SPBRFS)
+#define LAPACK_dpbrfs LAPACK_GLOBAL(dpbrfs,DPBRFS)
+#define LAPACK_cpbrfs LAPACK_GLOBAL(cpbrfs,CPBRFS)
+#define LAPACK_zpbrfs LAPACK_GLOBAL(zpbrfs,ZPBRFS)
+#define LAPACK_sptrfs LAPACK_GLOBAL(sptrfs,SPTRFS)
+#define LAPACK_dptrfs LAPACK_GLOBAL(dptrfs,DPTRFS)
+#define LAPACK_cptrfs LAPACK_GLOBAL(cptrfs,CPTRFS)
+#define LAPACK_zptrfs LAPACK_GLOBAL(zptrfs,ZPTRFS)
+#define LAPACK_ssyrfs LAPACK_GLOBAL(ssyrfs,SSYRFS)
+#define LAPACK_dsyrfs LAPACK_GLOBAL(dsyrfs,DSYRFS)
+#define LAPACK_csyrfs LAPACK_GLOBAL(csyrfs,CSYRFS)
+#define LAPACK_zsyrfs LAPACK_GLOBAL(zsyrfs,ZSYRFS)
+#define LAPACK_dsyrfsx LAPACK_GLOBAL(dsyrfsx,DSYRFSX)
+#define LAPACK_ssyrfsx LAPACK_GLOBAL(ssyrfsx,SSYRFSX)
+#define LAPACK_zsyrfsx LAPACK_GLOBAL(zsyrfsx,ZSYRFSX)
+#define LAPACK_csyrfsx LAPACK_GLOBAL(csyrfsx,CSYRFSX)
+#define LAPACK_cherfs LAPACK_GLOBAL(cherfs,CHERFS)
+#define LAPACK_zherfs LAPACK_GLOBAL(zherfs,ZHERFS)
+#define LAPACK_zherfsx LAPACK_GLOBAL(zherfsx,ZHERFSX)
+#define LAPACK_cherfsx LAPACK_GLOBAL(cherfsx,CHERFSX)
+#define LAPACK_ssprfs LAPACK_GLOBAL(ssprfs,SSPRFS)
+#define LAPACK_dsprfs LAPACK_GLOBAL(dsprfs,DSPRFS)
+#define LAPACK_csprfs LAPACK_GLOBAL(csprfs,CSPRFS)
+#define LAPACK_zsprfs LAPACK_GLOBAL(zsprfs,ZSPRFS)
+#define LAPACK_chprfs LAPACK_GLOBAL(chprfs,CHPRFS)
+#define LAPACK_zhprfs LAPACK_GLOBAL(zhprfs,ZHPRFS)
+#define LAPACK_strrfs LAPACK_GLOBAL(strrfs,STRRFS)
+#define LAPACK_dtrrfs LAPACK_GLOBAL(dtrrfs,DTRRFS)
+#define LAPACK_ctrrfs LAPACK_GLOBAL(ctrrfs,CTRRFS)
+#define LAPACK_ztrrfs LAPACK_GLOBAL(ztrrfs,ZTRRFS)
+#define LAPACK_stprfs LAPACK_GLOBAL(stprfs,STPRFS)
+#define LAPACK_dtprfs LAPACK_GLOBAL(dtprfs,DTPRFS)
+#define LAPACK_ctprfs LAPACK_GLOBAL(ctprfs,CTPRFS)
+#define LAPACK_ztprfs LAPACK_GLOBAL(ztprfs,ZTPRFS)
+#define LAPACK_stbrfs LAPACK_GLOBAL(stbrfs,STBRFS)
+#define LAPACK_dtbrfs LAPACK_GLOBAL(dtbrfs,DTBRFS)
+#define LAPACK_ctbrfs LAPACK_GLOBAL(ctbrfs,CTBRFS)
+#define LAPACK_ztbrfs LAPACK_GLOBAL(ztbrfs,ZTBRFS)
+#define LAPACK_sgetri LAPACK_GLOBAL(sgetri,SGETRI)
+#define LAPACK_dgetri LAPACK_GLOBAL(dgetri,DGETRI)
+#define LAPACK_cgetri LAPACK_GLOBAL(cgetri,CGETRI)
+#define LAPACK_zgetri LAPACK_GLOBAL(zgetri,ZGETRI)
+#define LAPACK_spotri LAPACK_GLOBAL(spotri,SPOTRI)
+#define LAPACK_dpotri LAPACK_GLOBAL(dpotri,DPOTRI)
+#define LAPACK_cpotri LAPACK_GLOBAL(cpotri,CPOTRI)
+#define LAPACK_zpotri LAPACK_GLOBAL(zpotri,ZPOTRI)
+#define LAPACK_dpftri LAPACK_GLOBAL(dpftri,DPFTRI)
+#define LAPACK_spftri LAPACK_GLOBAL(spftri,SPFTRI)
+#define LAPACK_zpftri LAPACK_GLOBAL(zpftri,ZPFTRI)
+#define LAPACK_cpftri LAPACK_GLOBAL(cpftri,CPFTRI)
+#define LAPACK_spptri LAPACK_GLOBAL(spptri,SPPTRI)
+#define LAPACK_dpptri LAPACK_GLOBAL(dpptri,DPPTRI)
+#define LAPACK_cpptri LAPACK_GLOBAL(cpptri,CPPTRI)
+#define LAPACK_zpptri LAPACK_GLOBAL(zpptri,ZPPTRI)
+#define LAPACK_ssytri LAPACK_GLOBAL(ssytri,SSYTRI)
+#define LAPACK_dsytri LAPACK_GLOBAL(dsytri,DSYTRI)
+#define LAPACK_csytri LAPACK_GLOBAL(csytri,CSYTRI)
+#define LAPACK_zsytri LAPACK_GLOBAL(zsytri,ZSYTRI)
+#define LAPACK_chetri LAPACK_GLOBAL(chetri,CHETRI)
+#define LAPACK_zhetri LAPACK_GLOBAL(zhetri,ZHETRI)
+#define LAPACK_ssptri LAPACK_GLOBAL(ssptri,SSPTRI)
+#define LAPACK_dsptri LAPACK_GLOBAL(dsptri,DSPTRI)
+#define LAPACK_csptri LAPACK_GLOBAL(csptri,CSPTRI)
+#define LAPACK_zsptri LAPACK_GLOBAL(zsptri,ZSPTRI)
+#define LAPACK_chptri LAPACK_GLOBAL(chptri,CHPTRI)
+#define LAPACK_zhptri LAPACK_GLOBAL(zhptri,ZHPTRI)
+#define LAPACK_strtri LAPACK_GLOBAL(strtri,STRTRI)
+#define LAPACK_dtrtri LAPACK_GLOBAL(dtrtri,DTRTRI)
+#define LAPACK_ctrtri LAPACK_GLOBAL(ctrtri,CTRTRI)
+#define LAPACK_ztrtri LAPACK_GLOBAL(ztrtri,ZTRTRI)
+#define LAPACK_dtftri LAPACK_GLOBAL(dtftri,DTFTRI)
+#define LAPACK_stftri LAPACK_GLOBAL(stftri,STFTRI)
+#define LAPACK_ztftri LAPACK_GLOBAL(ztftri,ZTFTRI)
+#define LAPACK_ctftri LAPACK_GLOBAL(ctftri,CTFTRI)
+#define LAPACK_stptri LAPACK_GLOBAL(stptri,STPTRI)
+#define LAPACK_dtptri LAPACK_GLOBAL(dtptri,DTPTRI)
+#define LAPACK_ctptri LAPACK_GLOBAL(ctptri,CTPTRI)
+#define LAPACK_ztptri LAPACK_GLOBAL(ztptri,ZTPTRI)
+#define LAPACK_sgeequ LAPACK_GLOBAL(sgeequ,SGEEQU)
+#define LAPACK_dgeequ LAPACK_GLOBAL(dgeequ,DGEEQU)
+#define LAPACK_cgeequ LAPACK_GLOBAL(cgeequ,CGEEQU)
+#define LAPACK_zgeequ LAPACK_GLOBAL(zgeequ,ZGEEQU)
+#define LAPACK_dgeequb LAPACK_GLOBAL(dgeequb,DGEEQUB)
+#define LAPACK_sgeequb LAPACK_GLOBAL(sgeequb,SGEEQUB)
+#define LAPACK_zgeequb LAPACK_GLOBAL(zgeequb,ZGEEQUB)
+#define LAPACK_cgeequb LAPACK_GLOBAL(cgeequb,CGEEQUB)
+#define LAPACK_sgbequ LAPACK_GLOBAL(sgbequ,SGBEQU)
+#define LAPACK_dgbequ LAPACK_GLOBAL(dgbequ,DGBEQU)
+#define LAPACK_cgbequ LAPACK_GLOBAL(cgbequ,CGBEQU)
+#define LAPACK_zgbequ LAPACK_GLOBAL(zgbequ,ZGBEQU)
+#define LAPACK_dgbequb LAPACK_GLOBAL(dgbequb,DGBEQUB)
+#define LAPACK_sgbequb LAPACK_GLOBAL(sgbequb,SGBEQUB)
+#define LAPACK_zgbequb LAPACK_GLOBAL(zgbequb,ZGBEQUB)
+#define LAPACK_cgbequb LAPACK_GLOBAL(cgbequb,CGBEQUB)
+#define LAPACK_spoequ LAPACK_GLOBAL(spoequ,SPOEQU)
+#define LAPACK_dpoequ LAPACK_GLOBAL(dpoequ,DPOEQU)
+#define LAPACK_cpoequ LAPACK_GLOBAL(cpoequ,CPOEQU)
+#define LAPACK_zpoequ LAPACK_GLOBAL(zpoequ,ZPOEQU)
+#define LAPACK_dpoequb LAPACK_GLOBAL(dpoequb,DPOEQUB)
+#define LAPACK_spoequb LAPACK_GLOBAL(spoequb,SPOEQUB)
+#define LAPACK_zpoequb LAPACK_GLOBAL(zpoequb,ZPOEQUB)
+#define LAPACK_cpoequb LAPACK_GLOBAL(cpoequb,CPOEQUB)
+#define LAPACK_sppequ LAPACK_GLOBAL(sppequ,SPPEQU)
+#define LAPACK_dppequ LAPACK_GLOBAL(dppequ,DPPEQU)
+#define LAPACK_cppequ LAPACK_GLOBAL(cppequ,CPPEQU)
+#define LAPACK_zppequ LAPACK_GLOBAL(zppequ,ZPPEQU)
+#define LAPACK_spbequ LAPACK_GLOBAL(spbequ,SPBEQU)
+#define LAPACK_dpbequ LAPACK_GLOBAL(dpbequ,DPBEQU)
+#define LAPACK_cpbequ LAPACK_GLOBAL(cpbequ,CPBEQU)
+#define LAPACK_zpbequ LAPACK_GLOBAL(zpbequ,ZPBEQU)
+#define LAPACK_dsyequb LAPACK_GLOBAL(dsyequb,DSYEQUB)
+#define LAPACK_ssyequb LAPACK_GLOBAL(ssyequb,SSYEQUB)
+#define LAPACK_zsyequb LAPACK_GLOBAL(zsyequb,ZSYEQUB)
+#define LAPACK_csyequb LAPACK_GLOBAL(csyequb,CSYEQUB)
+#define LAPACK_zheequb LAPACK_GLOBAL(zheequb,ZHEEQUB)
+#define LAPACK_cheequb LAPACK_GLOBAL(cheequb,CHEEQUB)
+#define LAPACK_sgesv LAPACK_GLOBAL(sgesv,SGESV)
+#define LAPACK_dgesv LAPACK_GLOBAL(dgesv,DGESV)
+#define LAPACK_cgesv LAPACK_GLOBAL(cgesv,CGESV)
+#define LAPACK_zgesv LAPACK_GLOBAL(zgesv,ZGESV)
+#define LAPACK_dsgesv LAPACK_GLOBAL(dsgesv,DSGESV)
+#define LAPACK_zcgesv LAPACK_GLOBAL(zcgesv,ZCGESV)
+#define LAPACK_sgesvx LAPACK_GLOBAL(sgesvx,SGESVX)
+#define LAPACK_dgesvx LAPACK_GLOBAL(dgesvx,DGESVX)
+#define LAPACK_cgesvx LAPACK_GLOBAL(cgesvx,CGESVX)
+#define LAPACK_zgesvx LAPACK_GLOBAL(zgesvx,ZGESVX)
+#define LAPACK_dgesvxx LAPACK_GLOBAL(dgesvxx,DGESVXX)
+#define LAPACK_sgesvxx LAPACK_GLOBAL(sgesvxx,SGESVXX)
+#define LAPACK_zgesvxx LAPACK_GLOBAL(zgesvxx,ZGESVXX)
+#define LAPACK_cgesvxx LAPACK_GLOBAL(cgesvxx,CGESVXX)
+#define LAPACK_sgbsv LAPACK_GLOBAL(sgbsv,SGBSV)
+#define LAPACK_dgbsv LAPACK_GLOBAL(dgbsv,DGBSV)
+#define LAPACK_cgbsv LAPACK_GLOBAL(cgbsv,CGBSV)
+#define LAPACK_zgbsv LAPACK_GLOBAL(zgbsv,ZGBSV)
+#define LAPACK_sgbsvx LAPACK_GLOBAL(sgbsvx,SGBSVX)
+#define LAPACK_dgbsvx LAPACK_GLOBAL(dgbsvx,DGBSVX)
+#define LAPACK_cgbsvx LAPACK_GLOBAL(cgbsvx,CGBSVX)
+#define LAPACK_zgbsvx LAPACK_GLOBAL(zgbsvx,ZGBSVX)
+#define LAPACK_dgbsvxx LAPACK_GLOBAL(dgbsvxx,DGBSVXX)
+#define LAPACK_sgbsvxx LAPACK_GLOBAL(sgbsvxx,SGBSVXX)
+#define LAPACK_zgbsvxx LAPACK_GLOBAL(zgbsvxx,ZGBSVXX)
+#define LAPACK_cgbsvxx LAPACK_GLOBAL(cgbsvxx,CGBSVXX)
+#define LAPACK_sgtsv LAPACK_GLOBAL(sgtsv,SGTSV)
+#define LAPACK_dgtsv LAPACK_GLOBAL(dgtsv,DGTSV)
+#define LAPACK_cgtsv LAPACK_GLOBAL(cgtsv,CGTSV)
+#define LAPACK_zgtsv LAPACK_GLOBAL(zgtsv,ZGTSV)
+#define LAPACK_sgtsvx LAPACK_GLOBAL(sgtsvx,SGTSVX)
+#define LAPACK_dgtsvx LAPACK_GLOBAL(dgtsvx,DGTSVX)
+#define LAPACK_cgtsvx LAPACK_GLOBAL(cgtsvx,CGTSVX)
+#define LAPACK_zgtsvx LAPACK_GLOBAL(zgtsvx,ZGTSVX)
+#define LAPACK_sposv LAPACK_GLOBAL(sposv,SPOSV)
+#define LAPACK_dposv LAPACK_GLOBAL(dposv,DPOSV)
+#define LAPACK_cposv LAPACK_GLOBAL(cposv,CPOSV)
+#define LAPACK_zposv LAPACK_GLOBAL(zposv,ZPOSV)
+#define LAPACK_dsposv LAPACK_GLOBAL(dsposv,DSPOSV)
+#define LAPACK_zcposv LAPACK_GLOBAL(zcposv,ZCPOSV)
+#define LAPACK_sposvx LAPACK_GLOBAL(sposvx,SPOSVX)
+#define LAPACK_dposvx LAPACK_GLOBAL(dposvx,DPOSVX)
+#define LAPACK_cposvx LAPACK_GLOBAL(cposvx,CPOSVX)
+#define LAPACK_zposvx LAPACK_GLOBAL(zposvx,ZPOSVX)
+#define LAPACK_dposvxx LAPACK_GLOBAL(dposvxx,DPOSVXX)
+#define LAPACK_sposvxx LAPACK_GLOBAL(sposvxx,SPOSVXX)
+#define LAPACK_zposvxx LAPACK_GLOBAL(zposvxx,ZPOSVXX)
+#define LAPACK_cposvxx LAPACK_GLOBAL(cposvxx,CPOSVXX)
+#define LAPACK_sppsv LAPACK_GLOBAL(sppsv,SPPSV)
+#define LAPACK_dppsv LAPACK_GLOBAL(dppsv,DPPSV)
+#define LAPACK_cppsv LAPACK_GLOBAL(cppsv,CPPSV)
+#define LAPACK_zppsv LAPACK_GLOBAL(zppsv,ZPPSV)
+#define LAPACK_sppsvx LAPACK_GLOBAL(sppsvx,SPPSVX)
+#define LAPACK_dppsvx LAPACK_GLOBAL(dppsvx,DPPSVX)
+#define LAPACK_cppsvx LAPACK_GLOBAL(cppsvx,CPPSVX)
+#define LAPACK_zppsvx LAPACK_GLOBAL(zppsvx,ZPPSVX)
+#define LAPACK_spbsv LAPACK_GLOBAL(spbsv,SPBSV)
+#define LAPACK_dpbsv LAPACK_GLOBAL(dpbsv,DPBSV)
+#define LAPACK_cpbsv LAPACK_GLOBAL(cpbsv,CPBSV)
+#define LAPACK_zpbsv LAPACK_GLOBAL(zpbsv,ZPBSV)
+#define LAPACK_spbsvx LAPACK_GLOBAL(spbsvx,SPBSVX)
+#define LAPACK_dpbsvx LAPACK_GLOBAL(dpbsvx,DPBSVX)
+#define LAPACK_cpbsvx LAPACK_GLOBAL(cpbsvx,CPBSVX)
+#define LAPACK_zpbsvx LAPACK_GLOBAL(zpbsvx,ZPBSVX)
+#define LAPACK_sptsv LAPACK_GLOBAL(sptsv,SPTSV)
+#define LAPACK_dptsv LAPACK_GLOBAL(dptsv,DPTSV)
+#define LAPACK_cptsv LAPACK_GLOBAL(cptsv,CPTSV)
+#define LAPACK_zptsv LAPACK_GLOBAL(zptsv,ZPTSV)
+#define LAPACK_sptsvx LAPACK_GLOBAL(sptsvx,SPTSVX)
+#define LAPACK_dptsvx LAPACK_GLOBAL(dptsvx,DPTSVX)
+#define LAPACK_cptsvx LAPACK_GLOBAL(cptsvx,CPTSVX)
+#define LAPACK_zptsvx LAPACK_GLOBAL(zptsvx,ZPTSVX)
+#define LAPACK_ssysv LAPACK_GLOBAL(ssysv,SSYSV)
+#define LAPACK_dsysv LAPACK_GLOBAL(dsysv,DSYSV)
+#define LAPACK_csysv LAPACK_GLOBAL(csysv,CSYSV)
+#define LAPACK_zsysv LAPACK_GLOBAL(zsysv,ZSYSV)
+#define LAPACK_ssysvx LAPACK_GLOBAL(ssysvx,SSYSVX)
+#define LAPACK_dsysvx LAPACK_GLOBAL(dsysvx,DSYSVX)
+#define LAPACK_csysvx LAPACK_GLOBAL(csysvx,CSYSVX)
+#define LAPACK_zsysvx LAPACK_GLOBAL(zsysvx,ZSYSVX)
+#define LAPACK_dsysvxx LAPACK_GLOBAL(dsysvxx,DSYSVXX)
+#define LAPACK_ssysvxx LAPACK_GLOBAL(ssysvxx,SSYSVXX)
+#define LAPACK_zsysvxx LAPACK_GLOBAL(zsysvxx,ZSYSVXX)
+#define LAPACK_csysvxx LAPACK_GLOBAL(csysvxx,CSYSVXX)
+#define LAPACK_chesv LAPACK_GLOBAL(chesv,CHESV)
+#define LAPACK_zhesv LAPACK_GLOBAL(zhesv,ZHESV)
+#define LAPACK_chesvx LAPACK_GLOBAL(chesvx,CHESVX)
+#define LAPACK_zhesvx LAPACK_GLOBAL(zhesvx,ZHESVX)
+#define LAPACK_zhesvxx LAPACK_GLOBAL(zhesvxx,ZHESVXX)
+#define LAPACK_chesvxx LAPACK_GLOBAL(chesvxx,CHESVXX)
+#define LAPACK_sspsv LAPACK_GLOBAL(sspsv,SSPSV)
+#define LAPACK_dspsv LAPACK_GLOBAL(dspsv,DSPSV)
+#define LAPACK_cspsv LAPACK_GLOBAL(cspsv,CSPSV)
+#define LAPACK_zspsv LAPACK_GLOBAL(zspsv,ZSPSV)
+#define LAPACK_sspsvx LAPACK_GLOBAL(sspsvx,SSPSVX)
+#define LAPACK_dspsvx LAPACK_GLOBAL(dspsvx,DSPSVX)
+#define LAPACK_cspsvx LAPACK_GLOBAL(cspsvx,CSPSVX)
+#define LAPACK_zspsvx LAPACK_GLOBAL(zspsvx,ZSPSVX)
+#define LAPACK_chpsv LAPACK_GLOBAL(chpsv,CHPSV)
+#define LAPACK_zhpsv LAPACK_GLOBAL(zhpsv,ZHPSV)
+#define LAPACK_chpsvx LAPACK_GLOBAL(chpsvx,CHPSVX)
+#define LAPACK_zhpsvx LAPACK_GLOBAL(zhpsvx,ZHPSVX)
+#define LAPACK_sgeqrf LAPACK_GLOBAL(sgeqrf,SGEQRF)
+#define LAPACK_dgeqrf LAPACK_GLOBAL(dgeqrf,DGEQRF)
+#define LAPACK_cgeqrf LAPACK_GLOBAL(cgeqrf,CGEQRF)
+#define LAPACK_zgeqrf LAPACK_GLOBAL(zgeqrf,ZGEQRF)
+#define LAPACK_sgeqpf LAPACK_GLOBAL(sgeqpf,SGEQPF)
+#define LAPACK_dgeqpf LAPACK_GLOBAL(dgeqpf,DGEQPF)
+#define LAPACK_cgeqpf LAPACK_GLOBAL(cgeqpf,CGEQPF)
+#define LAPACK_zgeqpf LAPACK_GLOBAL(zgeqpf,ZGEQPF)
+#define LAPACK_sgeqp3 LAPACK_GLOBAL(sgeqp3,SGEQP3)
+#define LAPACK_dgeqp3 LAPACK_GLOBAL(dgeqp3,DGEQP3)
+#define LAPACK_cgeqp3 LAPACK_GLOBAL(cgeqp3,CGEQP3)
+#define LAPACK_zgeqp3 LAPACK_GLOBAL(zgeqp3,ZGEQP3)
+#define LAPACK_sorgqr LAPACK_GLOBAL(sorgqr,SORGQR)
+#define LAPACK_dorgqr LAPACK_GLOBAL(dorgqr,DORGQR)
+#define LAPACK_sormqr LAPACK_GLOBAL(sormqr,SORMQR)
+#define LAPACK_dormqr LAPACK_GLOBAL(dormqr,DORMQR)
+#define LAPACK_cungqr LAPACK_GLOBAL(cungqr,CUNGQR)
+#define LAPACK_zungqr LAPACK_GLOBAL(zungqr,ZUNGQR)
+#define LAPACK_cunmqr LAPACK_GLOBAL(cunmqr,CUNMQR)
+#define LAPACK_zunmqr LAPACK_GLOBAL(zunmqr,ZUNMQR)
+#define LAPACK_sgelqf LAPACK_GLOBAL(sgelqf,SGELQF)
+#define LAPACK_dgelqf LAPACK_GLOBAL(dgelqf,DGELQF)
+#define LAPACK_cgelqf LAPACK_GLOBAL(cgelqf,CGELQF)
+#define LAPACK_zgelqf LAPACK_GLOBAL(zgelqf,ZGELQF)
+#define LAPACK_sorglq LAPACK_GLOBAL(sorglq,SORGLQ)
+#define LAPACK_dorglq LAPACK_GLOBAL(dorglq,DORGLQ)
+#define LAPACK_sormlq LAPACK_GLOBAL(sormlq,SORMLQ)
+#define LAPACK_dormlq LAPACK_GLOBAL(dormlq,DORMLQ)
+#define LAPACK_cunglq LAPACK_GLOBAL(cunglq,CUNGLQ)
+#define LAPACK_zunglq LAPACK_GLOBAL(zunglq,ZUNGLQ)
+#define LAPACK_cunmlq LAPACK_GLOBAL(cunmlq,CUNMLQ)
+#define LAPACK_zunmlq LAPACK_GLOBAL(zunmlq,ZUNMLQ)
+#define LAPACK_sgeqlf LAPACK_GLOBAL(sgeqlf,SGEQLF)
+#define LAPACK_dgeqlf LAPACK_GLOBAL(dgeqlf,DGEQLF)
+#define LAPACK_cgeqlf LAPACK_GLOBAL(cgeqlf,CGEQLF)
+#define LAPACK_zgeqlf LAPACK_GLOBAL(zgeqlf,ZGEQLF)
+#define LAPACK_sorgql LAPACK_GLOBAL(sorgql,SORGQL)
+#define LAPACK_dorgql LAPACK_GLOBAL(dorgql,DORGQL)
+#define LAPACK_cungql LAPACK_GLOBAL(cungql,CUNGQL)
+#define LAPACK_zungql LAPACK_GLOBAL(zungql,ZUNGQL)
+#define LAPACK_sormql LAPACK_GLOBAL(sormql,SORMQL)
+#define LAPACK_dormql LAPACK_GLOBAL(dormql,DORMQL)
+#define LAPACK_cunmql LAPACK_GLOBAL(cunmql,CUNMQL)
+#define LAPACK_zunmql LAPACK_GLOBAL(zunmql,ZUNMQL)
+#define LAPACK_sgerqf LAPACK_GLOBAL(sgerqf,SGERQF)
+#define LAPACK_dgerqf LAPACK_GLOBAL(dgerqf,DGERQF)
+#define LAPACK_cgerqf LAPACK_GLOBAL(cgerqf,CGERQF)
+#define LAPACK_zgerqf LAPACK_GLOBAL(zgerqf,ZGERQF)
+#define LAPACK_sorgrq LAPACK_GLOBAL(sorgrq,SORGRQ)
+#define LAPACK_dorgrq LAPACK_GLOBAL(dorgrq,DORGRQ)
+#define LAPACK_cungrq LAPACK_GLOBAL(cungrq,CUNGRQ)
+#define LAPACK_zungrq LAPACK_GLOBAL(zungrq,ZUNGRQ)
+#define LAPACK_sormrq LAPACK_GLOBAL(sormrq,SORMRQ)
+#define LAPACK_dormrq LAPACK_GLOBAL(dormrq,DORMRQ)
+#define LAPACK_cunmrq LAPACK_GLOBAL(cunmrq,CUNMRQ)
+#define LAPACK_zunmrq LAPACK_GLOBAL(zunmrq,ZUNMRQ)
+#define LAPACK_stzrzf LAPACK_GLOBAL(stzrzf,STZRZF)
+#define LAPACK_dtzrzf LAPACK_GLOBAL(dtzrzf,DTZRZF)
+#define LAPACK_ctzrzf LAPACK_GLOBAL(ctzrzf,CTZRZF)
+#define LAPACK_ztzrzf LAPACK_GLOBAL(ztzrzf,ZTZRZF)
+#define LAPACK_sormrz LAPACK_GLOBAL(sormrz,SORMRZ)
+#define LAPACK_dormrz LAPACK_GLOBAL(dormrz,DORMRZ)
+#define LAPACK_cunmrz LAPACK_GLOBAL(cunmrz,CUNMRZ)
+#define LAPACK_zunmrz LAPACK_GLOBAL(zunmrz,ZUNMRZ)
+#define LAPACK_sggqrf LAPACK_GLOBAL(sggqrf,SGGQRF)
+#define LAPACK_dggqrf LAPACK_GLOBAL(dggqrf,DGGQRF)
+#define LAPACK_cggqrf LAPACK_GLOBAL(cggqrf,CGGQRF)
+#define LAPACK_zggqrf LAPACK_GLOBAL(zggqrf,ZGGQRF)
+#define LAPACK_sggrqf LAPACK_GLOBAL(sggrqf,SGGRQF)
+#define LAPACK_dggrqf LAPACK_GLOBAL(dggrqf,DGGRQF)
+#define LAPACK_cggrqf LAPACK_GLOBAL(cggrqf,CGGRQF)
+#define LAPACK_zggrqf LAPACK_GLOBAL(zggrqf,ZGGRQF)
+#define LAPACK_sgebrd LAPACK_GLOBAL(sgebrd,SGEBRD)
+#define LAPACK_dgebrd LAPACK_GLOBAL(dgebrd,DGEBRD)
+#define LAPACK_cgebrd LAPACK_GLOBAL(cgebrd,CGEBRD)
+#define LAPACK_zgebrd LAPACK_GLOBAL(zgebrd,ZGEBRD)
+#define LAPACK_sgbbrd LAPACK_GLOBAL(sgbbrd,SGBBRD)
+#define LAPACK_dgbbrd LAPACK_GLOBAL(dgbbrd,DGBBRD)
+#define LAPACK_cgbbrd LAPACK_GLOBAL(cgbbrd,CGBBRD)
+#define LAPACK_zgbbrd LAPACK_GLOBAL(zgbbrd,ZGBBRD)
+#define LAPACK_sorgbr LAPACK_GLOBAL(sorgbr,SORGBR)
+#define LAPACK_dorgbr LAPACK_GLOBAL(dorgbr,DORGBR)
+#define LAPACK_sormbr LAPACK_GLOBAL(sormbr,SORMBR)
+#define LAPACK_dormbr LAPACK_GLOBAL(dormbr,DORMBR)
+#define LAPACK_cungbr LAPACK_GLOBAL(cungbr,CUNGBR)
+#define LAPACK_zungbr LAPACK_GLOBAL(zungbr,ZUNGBR)
+#define LAPACK_cunmbr LAPACK_GLOBAL(cunmbr,CUNMBR)
+#define LAPACK_zunmbr LAPACK_GLOBAL(zunmbr,ZUNMBR)
+#define LAPACK_sbdsqr LAPACK_GLOBAL(sbdsqr,SBDSQR)
+#define LAPACK_dbdsqr LAPACK_GLOBAL(dbdsqr,DBDSQR)
+#define LAPACK_cbdsqr LAPACK_GLOBAL(cbdsqr,CBDSQR)
+#define LAPACK_zbdsqr LAPACK_GLOBAL(zbdsqr,ZBDSQR)
+#define LAPACK_sbdsdc LAPACK_GLOBAL(sbdsdc,SBDSDC)
+#define LAPACK_dbdsdc LAPACK_GLOBAL(dbdsdc,DBDSDC)
+#define LAPACK_ssytrd LAPACK_GLOBAL(ssytrd,SSYTRD)
+#define LAPACK_dsytrd LAPACK_GLOBAL(dsytrd,DSYTRD)
+#define LAPACK_sorgtr LAPACK_GLOBAL(sorgtr,SORGTR)
+#define LAPACK_dorgtr LAPACK_GLOBAL(dorgtr,DORGTR)
+#define LAPACK_sormtr LAPACK_GLOBAL(sormtr,SORMTR)
+#define LAPACK_dormtr LAPACK_GLOBAL(dormtr,DORMTR)
+#define LAPACK_chetrd LAPACK_GLOBAL(chetrd,CHETRD)
+#define LAPACK_zhetrd LAPACK_GLOBAL(zhetrd,ZHETRD)
+#define LAPACK_cungtr LAPACK_GLOBAL(cungtr,CUNGTR)
+#define LAPACK_zungtr LAPACK_GLOBAL(zungtr,ZUNGTR)
+#define LAPACK_cunmtr LAPACK_GLOBAL(cunmtr,CUNMTR)
+#define LAPACK_zunmtr LAPACK_GLOBAL(zunmtr,ZUNMTR)
+#define LAPACK_ssptrd LAPACK_GLOBAL(ssptrd,SSPTRD)
+#define LAPACK_dsptrd LAPACK_GLOBAL(dsptrd,DSPTRD)
+#define LAPACK_sopgtr LAPACK_GLOBAL(sopgtr,SOPGTR)
+#define LAPACK_dopgtr LAPACK_GLOBAL(dopgtr,DOPGTR)
+#define LAPACK_sopmtr LAPACK_GLOBAL(sopmtr,SOPMTR)
+#define LAPACK_dopmtr LAPACK_GLOBAL(dopmtr,DOPMTR)
+#define LAPACK_chptrd LAPACK_GLOBAL(chptrd,CHPTRD)
+#define LAPACK_zhptrd LAPACK_GLOBAL(zhptrd,ZHPTRD)
+#define LAPACK_cupgtr LAPACK_GLOBAL(cupgtr,CUPGTR)
+#define LAPACK_zupgtr LAPACK_GLOBAL(zupgtr,ZUPGTR)
+#define LAPACK_cupmtr LAPACK_GLOBAL(cupmtr,CUPMTR)
+#define LAPACK_zupmtr LAPACK_GLOBAL(zupmtr,ZUPMTR)
+#define LAPACK_ssbtrd LAPACK_GLOBAL(ssbtrd,SSBTRD)
+#define LAPACK_dsbtrd LAPACK_GLOBAL(dsbtrd,DSBTRD)
+#define LAPACK_chbtrd LAPACK_GLOBAL(chbtrd,CHBTRD)
+#define LAPACK_zhbtrd LAPACK_GLOBAL(zhbtrd,ZHBTRD)
+#define LAPACK_ssterf LAPACK_GLOBAL(ssterf,SSTERF)
+#define LAPACK_dsterf LAPACK_GLOBAL(dsterf,DSTERF)
+#define LAPACK_ssteqr LAPACK_GLOBAL(ssteqr,SSTEQR)
+#define LAPACK_dsteqr LAPACK_GLOBAL(dsteqr,DSTEQR)
+#define LAPACK_csteqr LAPACK_GLOBAL(csteqr,CSTEQR)
+#define LAPACK_zsteqr LAPACK_GLOBAL(zsteqr,ZSTEQR)
+#define LAPACK_sstemr LAPACK_GLOBAL(sstemr,SSTEMR)
+#define LAPACK_dstemr LAPACK_GLOBAL(dstemr,DSTEMR)
+#define LAPACK_cstemr LAPACK_GLOBAL(cstemr,CSTEMR)
+#define LAPACK_zstemr LAPACK_GLOBAL(zstemr,ZSTEMR)
+#define LAPACK_sstedc LAPACK_GLOBAL(sstedc,SSTEDC)
+#define LAPACK_dstedc LAPACK_GLOBAL(dstedc,DSTEDC)
+#define LAPACK_cstedc LAPACK_GLOBAL(cstedc,CSTEDC)
+#define LAPACK_zstedc LAPACK_GLOBAL(zstedc,ZSTEDC)
+#define LAPACK_sstegr LAPACK_GLOBAL(sstegr,SSTEGR)
+#define LAPACK_dstegr LAPACK_GLOBAL(dstegr,DSTEGR)
+#define LAPACK_cstegr LAPACK_GLOBAL(cstegr,CSTEGR)
+#define LAPACK_zstegr LAPACK_GLOBAL(zstegr,ZSTEGR)
+#define LAPACK_spteqr LAPACK_GLOBAL(spteqr,SPTEQR)
+#define LAPACK_dpteqr LAPACK_GLOBAL(dpteqr,DPTEQR)
+#define LAPACK_cpteqr LAPACK_GLOBAL(cpteqr,CPTEQR)
+#define LAPACK_zpteqr LAPACK_GLOBAL(zpteqr,ZPTEQR)
+#define LAPACK_sstebz LAPACK_GLOBAL(sstebz,SSTEBZ)
+#define LAPACK_dstebz LAPACK_GLOBAL(dstebz,DSTEBZ)
+#define LAPACK_sstein LAPACK_GLOBAL(sstein,SSTEIN)
+#define LAPACK_dstein LAPACK_GLOBAL(dstein,DSTEIN)
+#define LAPACK_cstein LAPACK_GLOBAL(cstein,CSTEIN)
+#define LAPACK_zstein LAPACK_GLOBAL(zstein,ZSTEIN)
+#define LAPACK_sdisna LAPACK_GLOBAL(sdisna,SDISNA)
+#define LAPACK_ddisna LAPACK_GLOBAL(ddisna,DDISNA)
+#define LAPACK_ssygst LAPACK_GLOBAL(ssygst,SSYGST)
+#define LAPACK_dsygst LAPACK_GLOBAL(dsygst,DSYGST)
+#define LAPACK_chegst LAPACK_GLOBAL(chegst,CHEGST)
+#define LAPACK_zhegst LAPACK_GLOBAL(zhegst,ZHEGST)
+#define LAPACK_sspgst LAPACK_GLOBAL(sspgst,SSPGST)
+#define LAPACK_dspgst LAPACK_GLOBAL(dspgst,DSPGST)
+#define LAPACK_chpgst LAPACK_GLOBAL(chpgst,CHPGST)
+#define LAPACK_zhpgst LAPACK_GLOBAL(zhpgst,ZHPGST)
+#define LAPACK_ssbgst LAPACK_GLOBAL(ssbgst,SSBGST)
+#define LAPACK_dsbgst LAPACK_GLOBAL(dsbgst,DSBGST)
+#define LAPACK_chbgst LAPACK_GLOBAL(chbgst,CHBGST)
+#define LAPACK_zhbgst LAPACK_GLOBAL(zhbgst,ZHBGST)
+#define LAPACK_spbstf LAPACK_GLOBAL(spbstf,SPBSTF)
+#define LAPACK_dpbstf LAPACK_GLOBAL(dpbstf,DPBSTF)
+#define LAPACK_cpbstf LAPACK_GLOBAL(cpbstf,CPBSTF)
+#define LAPACK_zpbstf LAPACK_GLOBAL(zpbstf,ZPBSTF)
+#define LAPACK_sgehrd LAPACK_GLOBAL(sgehrd,SGEHRD)
+#define LAPACK_dgehrd LAPACK_GLOBAL(dgehrd,DGEHRD)
+#define LAPACK_cgehrd LAPACK_GLOBAL(cgehrd,CGEHRD)
+#define LAPACK_zgehrd LAPACK_GLOBAL(zgehrd,ZGEHRD)
+#define LAPACK_sorghr LAPACK_GLOBAL(sorghr,SORGHR)
+#define LAPACK_dorghr LAPACK_GLOBAL(dorghr,DORGHR)
+#define LAPACK_sormhr LAPACK_GLOBAL(sormhr,SORMHR)
+#define LAPACK_dormhr LAPACK_GLOBAL(dormhr,DORMHR)
+#define LAPACK_cunghr LAPACK_GLOBAL(cunghr,CUNGHR)
+#define LAPACK_zunghr LAPACK_GLOBAL(zunghr,ZUNGHR)
+#define LAPACK_cunmhr LAPACK_GLOBAL(cunmhr,CUNMHR)
+#define LAPACK_zunmhr LAPACK_GLOBAL(zunmhr,ZUNMHR)
+#define LAPACK_sgebal LAPACK_GLOBAL(sgebal,SGEBAL)
+#define LAPACK_dgebal LAPACK_GLOBAL(dgebal,DGEBAL)
+#define LAPACK_cgebal LAPACK_GLOBAL(cgebal,CGEBAL)
+#define LAPACK_zgebal LAPACK_GLOBAL(zgebal,ZGEBAL)
+#define LAPACK_sgebak LAPACK_GLOBAL(sgebak,SGEBAK)
+#define LAPACK_dgebak LAPACK_GLOBAL(dgebak,DGEBAK)
+#define LAPACK_cgebak LAPACK_GLOBAL(cgebak,CGEBAK)
+#define LAPACK_zgebak LAPACK_GLOBAL(zgebak,ZGEBAK)
+#define LAPACK_shseqr LAPACK_GLOBAL(shseqr,SHSEQR)
+#define LAPACK_dhseqr LAPACK_GLOBAL(dhseqr,DHSEQR)
+#define LAPACK_chseqr LAPACK_GLOBAL(chseqr,CHSEQR)
+#define LAPACK_zhseqr LAPACK_GLOBAL(zhseqr,ZHSEQR)
+#define LAPACK_shsein LAPACK_GLOBAL(shsein,SHSEIN)
+#define LAPACK_dhsein LAPACK_GLOBAL(dhsein,DHSEIN)
+#define LAPACK_chsein LAPACK_GLOBAL(chsein,CHSEIN)
+#define LAPACK_zhsein LAPACK_GLOBAL(zhsein,ZHSEIN)
+#define LAPACK_strevc LAPACK_GLOBAL(strevc,STREVC)
+#define LAPACK_dtrevc LAPACK_GLOBAL(dtrevc,DTREVC)
+#define LAPACK_ctrevc LAPACK_GLOBAL(ctrevc,CTREVC)
+#define LAPACK_ztrevc LAPACK_GLOBAL(ztrevc,ZTREVC)
+#define LAPACK_strsna LAPACK_GLOBAL(strsna,STRSNA)
+#define LAPACK_dtrsna LAPACK_GLOBAL(dtrsna,DTRSNA)
+#define LAPACK_ctrsna LAPACK_GLOBAL(ctrsna,CTRSNA)
+#define LAPACK_ztrsna LAPACK_GLOBAL(ztrsna,ZTRSNA)
+#define LAPACK_strexc LAPACK_GLOBAL(strexc,STREXC)
+#define LAPACK_dtrexc LAPACK_GLOBAL(dtrexc,DTREXC)
+#define LAPACK_ctrexc LAPACK_GLOBAL(ctrexc,CTREXC)
+#define LAPACK_ztrexc LAPACK_GLOBAL(ztrexc,ZTREXC)
+#define LAPACK_strsen LAPACK_GLOBAL(strsen,STRSEN)
+#define LAPACK_dtrsen LAPACK_GLOBAL(dtrsen,DTRSEN)
+#define LAPACK_ctrsen LAPACK_GLOBAL(ctrsen,CTRSEN)
+#define LAPACK_ztrsen LAPACK_GLOBAL(ztrsen,ZTRSEN)
+#define LAPACK_strsyl LAPACK_GLOBAL(strsyl,STRSYL)
+#define LAPACK_dtrsyl LAPACK_GLOBAL(dtrsyl,DTRSYL)
+#define LAPACK_ctrsyl LAPACK_GLOBAL(ctrsyl,CTRSYL)
+#define LAPACK_ztrsyl LAPACK_GLOBAL(ztrsyl,ZTRSYL)
+#define LAPACK_sgghrd LAPACK_GLOBAL(sgghrd,SGGHRD)
+#define LAPACK_dgghrd LAPACK_GLOBAL(dgghrd,DGGHRD)
+#define LAPACK_cgghrd LAPACK_GLOBAL(cgghrd,CGGHRD)
+#define LAPACK_zgghrd LAPACK_GLOBAL(zgghrd,ZGGHRD)
+#define LAPACK_sggbal LAPACK_GLOBAL(sggbal,SGGBAL)
+#define LAPACK_dggbal LAPACK_GLOBAL(dggbal,DGGBAL)
+#define LAPACK_cggbal LAPACK_GLOBAL(cggbal,CGGBAL)
+#define LAPACK_zggbal LAPACK_GLOBAL(zggbal,ZGGBAL)
+#define LAPACK_sggbak LAPACK_GLOBAL(sggbak,SGGBAK)
+#define LAPACK_dggbak LAPACK_GLOBAL(dggbak,DGGBAK)
+#define LAPACK_cggbak LAPACK_GLOBAL(cggbak,CGGBAK)
+#define LAPACK_zggbak LAPACK_GLOBAL(zggbak,ZGGBAK)
+#define LAPACK_shgeqz LAPACK_GLOBAL(shgeqz,SHGEQZ)
+#define LAPACK_dhgeqz LAPACK_GLOBAL(dhgeqz,DHGEQZ)
+#define LAPACK_chgeqz LAPACK_GLOBAL(chgeqz,CHGEQZ)
+#define LAPACK_zhgeqz LAPACK_GLOBAL(zhgeqz,ZHGEQZ)
+#define LAPACK_stgevc LAPACK_GLOBAL(stgevc,STGEVC)
+#define LAPACK_dtgevc LAPACK_GLOBAL(dtgevc,DTGEVC)
+#define LAPACK_ctgevc LAPACK_GLOBAL(ctgevc,CTGEVC)
+#define LAPACK_ztgevc LAPACK_GLOBAL(ztgevc,ZTGEVC)
+#define LAPACK_stgexc LAPACK_GLOBAL(stgexc,STGEXC)
+#define LAPACK_dtgexc LAPACK_GLOBAL(dtgexc,DTGEXC)
+#define LAPACK_ctgexc LAPACK_GLOBAL(ctgexc,CTGEXC)
+#define LAPACK_ztgexc LAPACK_GLOBAL(ztgexc,ZTGEXC)
+#define LAPACK_stgsen LAPACK_GLOBAL(stgsen,STGSEN)
+#define LAPACK_dtgsen LAPACK_GLOBAL(dtgsen,DTGSEN)
+#define LAPACK_ctgsen LAPACK_GLOBAL(ctgsen,CTGSEN)
+#define LAPACK_ztgsen LAPACK_GLOBAL(ztgsen,ZTGSEN)
+#define LAPACK_stgsyl LAPACK_GLOBAL(stgsyl,STGSYL)
+#define LAPACK_dtgsyl LAPACK_GLOBAL(dtgsyl,DTGSYL)
+#define LAPACK_ctgsyl LAPACK_GLOBAL(ctgsyl,CTGSYL)
+#define LAPACK_ztgsyl LAPACK_GLOBAL(ztgsyl,ZTGSYL)
+#define LAPACK_stgsna LAPACK_GLOBAL(stgsna,STGSNA)
+#define LAPACK_dtgsna LAPACK_GLOBAL(dtgsna,DTGSNA)
+#define LAPACK_ctgsna LAPACK_GLOBAL(ctgsna,CTGSNA)
+#define LAPACK_ztgsna LAPACK_GLOBAL(ztgsna,ZTGSNA)
+#define LAPACK_sggsvp LAPACK_GLOBAL(sggsvp,SGGSVP)
+#define LAPACK_dggsvp LAPACK_GLOBAL(dggsvp,DGGSVP)
+#define LAPACK_cggsvp LAPACK_GLOBAL(cggsvp,CGGSVP)
+#define LAPACK_zggsvp LAPACK_GLOBAL(zggsvp,ZGGSVP)
+#define LAPACK_stgsja LAPACK_GLOBAL(stgsja,STGSJA)
+#define LAPACK_dtgsja LAPACK_GLOBAL(dtgsja,DTGSJA)
+#define LAPACK_ctgsja LAPACK_GLOBAL(ctgsja,CTGSJA)
+#define LAPACK_ztgsja LAPACK_GLOBAL(ztgsja,ZTGSJA)
+#define LAPACK_sgels LAPACK_GLOBAL(sgels,SGELS)
+#define LAPACK_dgels LAPACK_GLOBAL(dgels,DGELS)
+#define LAPACK_cgels LAPACK_GLOBAL(cgels,CGELS)
+#define LAPACK_zgels LAPACK_GLOBAL(zgels,ZGELS)
+#define LAPACK_sgelsy LAPACK_GLOBAL(sgelsy,SGELSY)
+#define LAPACK_dgelsy LAPACK_GLOBAL(dgelsy,DGELSY)
+#define LAPACK_cgelsy LAPACK_GLOBAL(cgelsy,CGELSY)
+#define LAPACK_zgelsy LAPACK_GLOBAL(zgelsy,ZGELSY)
+#define LAPACK_sgelss LAPACK_GLOBAL(sgelss,SGELSS)
+#define LAPACK_dgelss LAPACK_GLOBAL(dgelss,DGELSS)
+#define LAPACK_cgelss LAPACK_GLOBAL(cgelss,CGELSS)
+#define LAPACK_zgelss LAPACK_GLOBAL(zgelss,ZGELSS)
+#define LAPACK_sgelsd LAPACK_GLOBAL(sgelsd,SGELSD)
+#define LAPACK_dgelsd LAPACK_GLOBAL(dgelsd,DGELSD)
+#define LAPACK_cgelsd LAPACK_GLOBAL(cgelsd,CGELSD)
+#define LAPACK_zgelsd LAPACK_GLOBAL(zgelsd,ZGELSD)
+#define LAPACK_sgglse LAPACK_GLOBAL(sgglse,SGGLSE)
+#define LAPACK_dgglse LAPACK_GLOBAL(dgglse,DGGLSE)
+#define LAPACK_cgglse LAPACK_GLOBAL(cgglse,CGGLSE)
+#define LAPACK_zgglse LAPACK_GLOBAL(zgglse,ZGGLSE)
+#define LAPACK_sggglm LAPACK_GLOBAL(sggglm,SGGGLM)
+#define LAPACK_dggglm LAPACK_GLOBAL(dggglm,DGGGLM)
+#define LAPACK_cggglm LAPACK_GLOBAL(cggglm,CGGGLM)
+#define LAPACK_zggglm LAPACK_GLOBAL(zggglm,ZGGGLM)
+#define LAPACK_ssyev LAPACK_GLOBAL(ssyev,SSYEV)
+#define LAPACK_dsyev LAPACK_GLOBAL(dsyev,DSYEV)
+#define LAPACK_cheev LAPACK_GLOBAL(cheev,CHEEV)
+#define LAPACK_zheev LAPACK_GLOBAL(zheev,ZHEEV)
+#define LAPACK_ssyevd LAPACK_GLOBAL(ssyevd,SSYEVD)
+#define LAPACK_dsyevd LAPACK_GLOBAL(dsyevd,DSYEVD)
+#define LAPACK_cheevd LAPACK_GLOBAL(cheevd,CHEEVD)
+#define LAPACK_zheevd LAPACK_GLOBAL(zheevd,ZHEEVD)
+#define LAPACK_ssyevx LAPACK_GLOBAL(ssyevx,SSYEVX)
+#define LAPACK_dsyevx LAPACK_GLOBAL(dsyevx,DSYEVX)
+#define LAPACK_cheevx LAPACK_GLOBAL(cheevx,CHEEVX)
+#define LAPACK_zheevx LAPACK_GLOBAL(zheevx,ZHEEVX)
+#define LAPACK_ssyevr LAPACK_GLOBAL(ssyevr,SSYEVR)
+#define LAPACK_dsyevr LAPACK_GLOBAL(dsyevr,DSYEVR)
+#define LAPACK_cheevr LAPACK_GLOBAL(cheevr,CHEEVR)
+#define LAPACK_zheevr LAPACK_GLOBAL(zheevr,ZHEEVR)
+#define LAPACK_sspev LAPACK_GLOBAL(sspev,SSPEV)
+#define LAPACK_dspev LAPACK_GLOBAL(dspev,DSPEV)
+#define LAPACK_chpev LAPACK_GLOBAL(chpev,CHPEV)
+#define LAPACK_zhpev LAPACK_GLOBAL(zhpev,ZHPEV)
+#define LAPACK_sspevd LAPACK_GLOBAL(sspevd,SSPEVD)
+#define LAPACK_dspevd LAPACK_GLOBAL(dspevd,DSPEVD)
+#define LAPACK_chpevd LAPACK_GLOBAL(chpevd,CHPEVD)
+#define LAPACK_zhpevd LAPACK_GLOBAL(zhpevd,ZHPEVD)
+#define LAPACK_sspevx LAPACK_GLOBAL(sspevx,SSPEVX)
+#define LAPACK_dspevx LAPACK_GLOBAL(dspevx,DSPEVX)
+#define LAPACK_chpevx LAPACK_GLOBAL(chpevx,CHPEVX)
+#define LAPACK_zhpevx LAPACK_GLOBAL(zhpevx,ZHPEVX)
+#define LAPACK_ssbev LAPACK_GLOBAL(ssbev,SSBEV)
+#define LAPACK_dsbev LAPACK_GLOBAL(dsbev,DSBEV)
+#define LAPACK_chbev LAPACK_GLOBAL(chbev,CHBEV)
+#define LAPACK_zhbev LAPACK_GLOBAL(zhbev,ZHBEV)
+#define LAPACK_ssbevd LAPACK_GLOBAL(ssbevd,SSBEVD)
+#define LAPACK_dsbevd LAPACK_GLOBAL(dsbevd,DSBEVD)
+#define LAPACK_chbevd LAPACK_GLOBAL(chbevd,CHBEVD)
+#define LAPACK_zhbevd LAPACK_GLOBAL(zhbevd,ZHBEVD)
+#define LAPACK_ssbevx LAPACK_GLOBAL(ssbevx,SSBEVX)
+#define LAPACK_dsbevx LAPACK_GLOBAL(dsbevx,DSBEVX)
+#define LAPACK_chbevx LAPACK_GLOBAL(chbevx,CHBEVX)
+#define LAPACK_zhbevx LAPACK_GLOBAL(zhbevx,ZHBEVX)
+#define LAPACK_sstev LAPACK_GLOBAL(sstev,SSTEV)
+#define LAPACK_dstev LAPACK_GLOBAL(dstev,DSTEV)
+#define LAPACK_sstevd LAPACK_GLOBAL(sstevd,SSTEVD)
+#define LAPACK_dstevd LAPACK_GLOBAL(dstevd,DSTEVD)
+#define LAPACK_sstevx LAPACK_GLOBAL(sstevx,SSTEVX)
+#define LAPACK_dstevx LAPACK_GLOBAL(dstevx,DSTEVX)
+#define LAPACK_sstevr LAPACK_GLOBAL(sstevr,SSTEVR)
+#define LAPACK_dstevr LAPACK_GLOBAL(dstevr,DSTEVR)
+#define LAPACK_sgees LAPACK_GLOBAL(sgees,SGEES)
+#define LAPACK_dgees LAPACK_GLOBAL(dgees,DGEES)
+#define LAPACK_cgees LAPACK_GLOBAL(cgees,CGEES)
+#define LAPACK_zgees LAPACK_GLOBAL(zgees,ZGEES)
+#define LAPACK_sgeesx LAPACK_GLOBAL(sgeesx,SGEESX)
+#define LAPACK_dgeesx LAPACK_GLOBAL(dgeesx,DGEESX)
+#define LAPACK_cgeesx LAPACK_GLOBAL(cgeesx,CGEESX)
+#define LAPACK_zgeesx LAPACK_GLOBAL(zgeesx,ZGEESX)
+#define LAPACK_sgeev LAPACK_GLOBAL(sgeev,SGEEV)
+#define LAPACK_dgeev LAPACK_GLOBAL(dgeev,DGEEV)
+#define LAPACK_cgeev LAPACK_GLOBAL(cgeev,CGEEV)
+#define LAPACK_zgeev LAPACK_GLOBAL(zgeev,ZGEEV)
+#define LAPACK_sgeevx LAPACK_GLOBAL(sgeevx,SGEEVX)
+#define LAPACK_dgeevx LAPACK_GLOBAL(dgeevx,DGEEVX)
+#define LAPACK_cgeevx LAPACK_GLOBAL(cgeevx,CGEEVX)
+#define LAPACK_zgeevx LAPACK_GLOBAL(zgeevx,ZGEEVX)
+#define LAPACK_sgesvd LAPACK_GLOBAL(sgesvd,SGESVD)
+#define LAPACK_dgesvd LAPACK_GLOBAL(dgesvd,DGESVD)
+#define LAPACK_cgesvd LAPACK_GLOBAL(cgesvd,CGESVD)
+#define LAPACK_zgesvd LAPACK_GLOBAL(zgesvd,ZGESVD)
+#define LAPACK_sgesdd LAPACK_GLOBAL(sgesdd,SGESDD)
+#define LAPACK_dgesdd LAPACK_GLOBAL(dgesdd,DGESDD)
+#define LAPACK_cgesdd LAPACK_GLOBAL(cgesdd,CGESDD)
+#define LAPACK_zgesdd LAPACK_GLOBAL(zgesdd,ZGESDD)
+#define LAPACK_dgejsv LAPACK_GLOBAL(dgejsv,DGEJSV)
+#define LAPACK_sgejsv LAPACK_GLOBAL(sgejsv,SGEJSV)
+#define LAPACK_dgesvj LAPACK_GLOBAL(dgesvj,DGESVJ)
+#define LAPACK_sgesvj LAPACK_GLOBAL(sgesvj,SGESVJ)
+#define LAPACK_sggsvd LAPACK_GLOBAL(sggsvd,SGGSVD)
+#define LAPACK_dggsvd LAPACK_GLOBAL(dggsvd,DGGSVD)
+#define LAPACK_cggsvd LAPACK_GLOBAL(cggsvd,CGGSVD)
+#define LAPACK_zggsvd LAPACK_GLOBAL(zggsvd,ZGGSVD)
+#define LAPACK_ssygv LAPACK_GLOBAL(ssygv,SSYGV)
+#define LAPACK_dsygv LAPACK_GLOBAL(dsygv,DSYGV)
+#define LAPACK_chegv LAPACK_GLOBAL(chegv,CHEGV)
+#define LAPACK_zhegv LAPACK_GLOBAL(zhegv,ZHEGV)
+#define LAPACK_ssygvd LAPACK_GLOBAL(ssygvd,SSYGVD)
+#define LAPACK_dsygvd LAPACK_GLOBAL(dsygvd,DSYGVD)
+#define LAPACK_chegvd LAPACK_GLOBAL(chegvd,CHEGVD)
+#define LAPACK_zhegvd LAPACK_GLOBAL(zhegvd,ZHEGVD)
+#define LAPACK_ssygvx LAPACK_GLOBAL(ssygvx,SSYGVX)
+#define LAPACK_dsygvx LAPACK_GLOBAL(dsygvx,DSYGVX)
+#define LAPACK_chegvx LAPACK_GLOBAL(chegvx,CHEGVX)
+#define LAPACK_zhegvx LAPACK_GLOBAL(zhegvx,ZHEGVX)
+#define LAPACK_sspgv LAPACK_GLOBAL(sspgv,SSPGV)
+#define LAPACK_dspgv LAPACK_GLOBAL(dspgv,DSPGV)
+#define LAPACK_chpgv LAPACK_GLOBAL(chpgv,CHPGV)
+#define LAPACK_zhpgv LAPACK_GLOBAL(zhpgv,ZHPGV)
+#define LAPACK_sspgvd LAPACK_GLOBAL(sspgvd,SSPGVD)
+#define LAPACK_dspgvd LAPACK_GLOBAL(dspgvd,DSPGVD)
+#define LAPACK_chpgvd LAPACK_GLOBAL(chpgvd,CHPGVD)
+#define LAPACK_zhpgvd LAPACK_GLOBAL(zhpgvd,ZHPGVD)
+#define LAPACK_sspgvx LAPACK_GLOBAL(sspgvx,SSPGVX)
+#define LAPACK_dspgvx LAPACK_GLOBAL(dspgvx,DSPGVX)
+#define LAPACK_chpgvx LAPACK_GLOBAL(chpgvx,CHPGVX)
+#define LAPACK_zhpgvx LAPACK_GLOBAL(zhpgvx,ZHPGVX)
+#define LAPACK_ssbgv LAPACK_GLOBAL(ssbgv,SSBGV)
+#define LAPACK_dsbgv LAPACK_GLOBAL(dsbgv,DSBGV)
+#define LAPACK_chbgv LAPACK_GLOBAL(chbgv,CHBGV)
+#define LAPACK_zhbgv LAPACK_GLOBAL(zhbgv,ZHBGV)
+#define LAPACK_ssbgvd LAPACK_GLOBAL(ssbgvd,SSBGVD)
+#define LAPACK_dsbgvd LAPACK_GLOBAL(dsbgvd,DSBGVD)
+#define LAPACK_chbgvd LAPACK_GLOBAL(chbgvd,CHBGVD)
+#define LAPACK_zhbgvd LAPACK_GLOBAL(zhbgvd,ZHBGVD)
+#define LAPACK_ssbgvx LAPACK_GLOBAL(ssbgvx,SSBGVX)
+#define LAPACK_dsbgvx LAPACK_GLOBAL(dsbgvx,DSBGVX)
+#define LAPACK_chbgvx LAPACK_GLOBAL(chbgvx,CHBGVX)
+#define LAPACK_zhbgvx LAPACK_GLOBAL(zhbgvx,ZHBGVX)
+#define LAPACK_sgges LAPACK_GLOBAL(sgges,SGGES)
+#define LAPACK_dgges LAPACK_GLOBAL(dgges,DGGES)
+#define LAPACK_cgges LAPACK_GLOBAL(cgges,CGGES)
+#define LAPACK_zgges LAPACK_GLOBAL(zgges,ZGGES)
+#define LAPACK_sggesx LAPACK_GLOBAL(sggesx,SGGESX)
+#define LAPACK_dggesx LAPACK_GLOBAL(dggesx,DGGESX)
+#define LAPACK_cggesx LAPACK_GLOBAL(cggesx,CGGESX)
+#define LAPACK_zggesx LAPACK_GLOBAL(zggesx,ZGGESX)
+#define LAPACK_sggev LAPACK_GLOBAL(sggev,SGGEV)
+#define LAPACK_dggev LAPACK_GLOBAL(dggev,DGGEV)
+#define LAPACK_cggev LAPACK_GLOBAL(cggev,CGGEV)
+#define LAPACK_zggev LAPACK_GLOBAL(zggev,ZGGEV)
+#define LAPACK_sggevx LAPACK_GLOBAL(sggevx,SGGEVX)
+#define LAPACK_dggevx LAPACK_GLOBAL(dggevx,DGGEVX)
+#define LAPACK_cggevx LAPACK_GLOBAL(cggevx,CGGEVX)
+#define LAPACK_zggevx LAPACK_GLOBAL(zggevx,ZGGEVX)
+#define LAPACK_dsfrk LAPACK_GLOBAL(dsfrk,DSFRK)
+#define LAPACK_ssfrk LAPACK_GLOBAL(ssfrk,SSFRK)
+#define LAPACK_zhfrk LAPACK_GLOBAL(zhfrk,ZHFRK)
+#define LAPACK_chfrk LAPACK_GLOBAL(chfrk,CHFRK)
+#define LAPACK_dtfsm LAPACK_GLOBAL(dtfsm,DTFSM)
+#define LAPACK_stfsm LAPACK_GLOBAL(stfsm,STFSM)
+#define LAPACK_ztfsm LAPACK_GLOBAL(ztfsm,ZTFSM)
+#define LAPACK_ctfsm LAPACK_GLOBAL(ctfsm,CTFSM)
+#define LAPACK_dtfttp LAPACK_GLOBAL(dtfttp,DTFTTP)
+#define LAPACK_stfttp LAPACK_GLOBAL(stfttp,STFTTP)
+#define LAPACK_ztfttp LAPACK_GLOBAL(ztfttp,ZTFTTP)
+#define LAPACK_ctfttp LAPACK_GLOBAL(ctfttp,CTFTTP)
+#define LAPACK_dtfttr LAPACK_GLOBAL(dtfttr,DTFTTR)
+#define LAPACK_stfttr LAPACK_GLOBAL(stfttr,STFTTR)
+#define LAPACK_ztfttr LAPACK_GLOBAL(ztfttr,ZTFTTR)
+#define LAPACK_ctfttr LAPACK_GLOBAL(ctfttr,CTFTTR)
+#define LAPACK_dtpttf LAPACK_GLOBAL(dtpttf,DTPTTF)
+#define LAPACK_stpttf LAPACK_GLOBAL(stpttf,STPTTF)
+#define LAPACK_ztpttf LAPACK_GLOBAL(ztpttf,ZTPTTF)
+#define LAPACK_ctpttf LAPACK_GLOBAL(ctpttf,CTPTTF)
+#define LAPACK_dtpttr LAPACK_GLOBAL(dtpttr,DTPTTR)
+#define LAPACK_stpttr LAPACK_GLOBAL(stpttr,STPTTR)
+#define LAPACK_ztpttr LAPACK_GLOBAL(ztpttr,ZTPTTR)
+#define LAPACK_ctpttr LAPACK_GLOBAL(ctpttr,CTPTTR)
+#define LAPACK_dtrttf LAPACK_GLOBAL(dtrttf,DTRTTF)
+#define LAPACK_strttf LAPACK_GLOBAL(strttf,STRTTF)
+#define LAPACK_ztrttf LAPACK_GLOBAL(ztrttf,ZTRTTF)
+#define LAPACK_ctrttf LAPACK_GLOBAL(ctrttf,CTRTTF)
+#define LAPACK_dtrttp LAPACK_GLOBAL(dtrttp,DTRTTP)
+#define LAPACK_strttp LAPACK_GLOBAL(strttp,STRTTP)
+#define LAPACK_ztrttp LAPACK_GLOBAL(ztrttp,ZTRTTP)
+#define LAPACK_ctrttp LAPACK_GLOBAL(ctrttp,CTRTTP)
+#define LAPACK_sgeqrfp LAPACK_GLOBAL(sgeqrfp,SGEQRFP)
+#define LAPACK_dgeqrfp LAPACK_GLOBAL(dgeqrfp,DGEQRFP)
+#define LAPACK_cgeqrfp LAPACK_GLOBAL(cgeqrfp,CGEQRFP)
+#define LAPACK_zgeqrfp LAPACK_GLOBAL(zgeqrfp,ZGEQRFP)
+#define LAPACK_clacgv LAPACK_GLOBAL(clacgv,CLACGV)
+#define LAPACK_zlacgv LAPACK_GLOBAL(zlacgv,ZLACGV)
+#define LAPACK_slarnv LAPACK_GLOBAL(slarnv,SLARNV)
+#define LAPACK_dlarnv LAPACK_GLOBAL(dlarnv,DLARNV)
+#define LAPACK_clarnv LAPACK_GLOBAL(clarnv,CLARNV)
+#define LAPACK_zlarnv LAPACK_GLOBAL(zlarnv,ZLARNV)
+#define LAPACK_sgeqr2 LAPACK_GLOBAL(sgeqr2,SGEQR2)
+#define LAPACK_dgeqr2 LAPACK_GLOBAL(dgeqr2,DGEQR2)
+#define LAPACK_cgeqr2 LAPACK_GLOBAL(cgeqr2,CGEQR2)
+#define LAPACK_zgeqr2 LAPACK_GLOBAL(zgeqr2,ZGEQR2)
+#define LAPACK_slacpy LAPACK_GLOBAL(slacpy,SLACPY)
+#define LAPACK_dlacpy LAPACK_GLOBAL(dlacpy,DLACPY)
+#define LAPACK_clacpy LAPACK_GLOBAL(clacpy,CLACPY)
+#define LAPACK_zlacpy LAPACK_GLOBAL(zlacpy,ZLACPY)
+#define LAPACK_sgetf2 LAPACK_GLOBAL(sgetf2,SGETF2)
+#define LAPACK_dgetf2 LAPACK_GLOBAL(dgetf2,DGETF2)
+#define LAPACK_cgetf2 LAPACK_GLOBAL(cgetf2,CGETF2)
+#define LAPACK_zgetf2 LAPACK_GLOBAL(zgetf2,ZGETF2)
+#define LAPACK_slaswp LAPACK_GLOBAL(slaswp,SLASWP)
+#define LAPACK_dlaswp LAPACK_GLOBAL(dlaswp,DLASWP)
+#define LAPACK_claswp LAPACK_GLOBAL(claswp,CLASWP)
+#define LAPACK_zlaswp LAPACK_GLOBAL(zlaswp,ZLASWP)
+#define LAPACK_slange LAPACK_GLOBAL(slange,SLANGE)
+#define LAPACK_dlange LAPACK_GLOBAL(dlange,DLANGE)
+#define LAPACK_clange LAPACK_GLOBAL(clange,CLANGE)
+#define LAPACK_zlange LAPACK_GLOBAL(zlange,ZLANGE)
+#define LAPACK_clanhe LAPACK_GLOBAL(clanhe,CLANHE)
+#define LAPACK_zlanhe LAPACK_GLOBAL(zlanhe,ZLANHE)
+#define LAPACK_slansy LAPACK_GLOBAL(slansy,SLANSY)
+#define LAPACK_dlansy LAPACK_GLOBAL(dlansy,DLANSY)
+#define LAPACK_clansy LAPACK_GLOBAL(clansy,CLANSY)
+#define LAPACK_zlansy LAPACK_GLOBAL(zlansy,ZLANSY)
+#define LAPACK_slantr LAPACK_GLOBAL(slantr,SLANTR)
+#define LAPACK_dlantr LAPACK_GLOBAL(dlantr,DLANTR)
+#define LAPACK_clantr LAPACK_GLOBAL(clantr,CLANTR)
+#define LAPACK_zlantr LAPACK_GLOBAL(zlantr,ZLANTR)
+#define LAPACK_slamch LAPACK_GLOBAL(slamch,SLAMCH)
+#define LAPACK_dlamch LAPACK_GLOBAL(dlamch,DLAMCH)
+#define LAPACK_sgelq2 LAPACK_GLOBAL(sgelq2,SGELQ2)
+#define LAPACK_dgelq2 LAPACK_GLOBAL(dgelq2,DGELQ2)
+#define LAPACK_cgelq2 LAPACK_GLOBAL(cgelq2,CGELQ2)
+#define LAPACK_zgelq2 LAPACK_GLOBAL(zgelq2,ZGELQ2)
+#define LAPACK_slarfb LAPACK_GLOBAL(slarfb,SLARFB)
+#define LAPACK_dlarfb LAPACK_GLOBAL(dlarfb,DLARFB)
+#define LAPACK_clarfb LAPACK_GLOBAL(clarfb,CLARFB)
+#define LAPACK_zlarfb LAPACK_GLOBAL(zlarfb,ZLARFB)
+#define LAPACK_slarfg LAPACK_GLOBAL(slarfg,SLARFG)
+#define LAPACK_dlarfg LAPACK_GLOBAL(dlarfg,DLARFG)
+#define LAPACK_clarfg LAPACK_GLOBAL(clarfg,CLARFG)
+#define LAPACK_zlarfg LAPACK_GLOBAL(zlarfg,ZLARFG)
+#define LAPACK_slarft LAPACK_GLOBAL(slarft,SLARFT)
+#define LAPACK_dlarft LAPACK_GLOBAL(dlarft,DLARFT)
+#define LAPACK_clarft LAPACK_GLOBAL(clarft,CLARFT)
+#define LAPACK_zlarft LAPACK_GLOBAL(zlarft,ZLARFT)
+#define LAPACK_slarfx LAPACK_GLOBAL(slarfx,SLARFX)
+#define LAPACK_dlarfx LAPACK_GLOBAL(dlarfx,DLARFX)
+#define LAPACK_clarfx LAPACK_GLOBAL(clarfx,CLARFX)
+#define LAPACK_zlarfx LAPACK_GLOBAL(zlarfx,ZLARFX)
+#define LAPACK_slatms LAPACK_GLOBAL(slatms,SLATMS)
+#define LAPACK_dlatms LAPACK_GLOBAL(dlatms,DLATMS)
+#define LAPACK_clatms LAPACK_GLOBAL(clatms,CLATMS)
+#define LAPACK_zlatms LAPACK_GLOBAL(zlatms,ZLATMS)
+#define LAPACK_slag2d LAPACK_GLOBAL(slag2d,SLAG2D)
+#define LAPACK_dlag2s LAPACK_GLOBAL(dlag2s,DLAG2S)
+#define LAPACK_clag2z LAPACK_GLOBAL(clag2z,CLAG2Z)
+#define LAPACK_zlag2c LAPACK_GLOBAL(zlag2c,ZLAG2C)
+#define LAPACK_slauum LAPACK_GLOBAL(slauum,SLAUUM)
+#define LAPACK_dlauum LAPACK_GLOBAL(dlauum,DLAUUM)
+#define LAPACK_clauum LAPACK_GLOBAL(clauum,CLAUUM)
+#define LAPACK_zlauum LAPACK_GLOBAL(zlauum,ZLAUUM)
+#define LAPACK_slagge LAPACK_GLOBAL(slagge,SLAGGE)
+#define LAPACK_dlagge LAPACK_GLOBAL(dlagge,DLAGGE)
+#define LAPACK_clagge LAPACK_GLOBAL(clagge,CLAGGE)
+#define LAPACK_zlagge LAPACK_GLOBAL(zlagge,ZLAGGE)
+#define LAPACK_slaset LAPACK_GLOBAL(slaset,SLASET)
+#define LAPACK_dlaset LAPACK_GLOBAL(dlaset,DLASET)
+#define LAPACK_claset LAPACK_GLOBAL(claset,CLASET)
+#define LAPACK_zlaset LAPACK_GLOBAL(zlaset,ZLASET)
+#define LAPACK_slasrt LAPACK_GLOBAL(slasrt,SLASRT)
+#define LAPACK_dlasrt LAPACK_GLOBAL(dlasrt,DLASRT)
+#define LAPACK_slagsy LAPACK_GLOBAL(slagsy,SLAGSY)
+#define LAPACK_dlagsy LAPACK_GLOBAL(dlagsy,DLAGSY)
+#define LAPACK_clagsy LAPACK_GLOBAL(clagsy,CLAGSY)
+#define LAPACK_zlagsy LAPACK_GLOBAL(zlagsy,ZLAGSY)
+#define LAPACK_claghe LAPACK_GLOBAL(claghe,CLAGHE)
+#define LAPACK_zlaghe LAPACK_GLOBAL(zlaghe,ZLAGHE)
+#define LAPACK_slapmr LAPACK_GLOBAL(slapmr,SLAPMR)
+#define LAPACK_dlapmr LAPACK_GLOBAL(dlapmr,DLAPMR)
+#define LAPACK_clapmr LAPACK_GLOBAL(clapmr,CLAPMR)
+#define LAPACK_zlapmr LAPACK_GLOBAL(zlapmr,ZLAPMR)
+#define LAPACK_slapy2 LAPACK_GLOBAL(slapy2,SLAPY2)
+#define LAPACK_dlapy2 LAPACK_GLOBAL(dlapy2,DLAPY2)
+#define LAPACK_slapy3 LAPACK_GLOBAL(slapy3,SLAPY3)
+#define LAPACK_dlapy3 LAPACK_GLOBAL(dlapy3,DLAPY3)
+#define LAPACK_slartgp LAPACK_GLOBAL(slartgp,SLARTGP)
+#define LAPACK_dlartgp LAPACK_GLOBAL(dlartgp,DLARTGP)
+#define LAPACK_slartgs LAPACK_GLOBAL(slartgs,SLARTGS)
+#define LAPACK_dlartgs LAPACK_GLOBAL(dlartgs,DLARTGS)
+// LAPACK 3.3.0
+#define LAPACK_cbbcsd LAPACK_GLOBAL(cbbcsd,CBBCSD)
+#define LAPACK_cheswapr LAPACK_GLOBAL(cheswapr,CHESWAPR)
+#define LAPACK_chetri2 LAPACK_GLOBAL(chetri2,CHETRI2)
+#define LAPACK_chetri2x LAPACK_GLOBAL(chetri2x,CHETRI2X)
+#define LAPACK_chetrs2 LAPACK_GLOBAL(chetrs2,CHETRS2)
+#define LAPACK_csyconv LAPACK_GLOBAL(csyconv,CSYCONV)
+#define LAPACK_csyswapr LAPACK_GLOBAL(csyswapr,CSYSWAPR)
+#define LAPACK_csytri2 LAPACK_GLOBAL(csytri2,CSYTRI2)
+#define LAPACK_csytri2x LAPACK_GLOBAL(csytri2x,CSYTRI2X)
+#define LAPACK_csytrs2 LAPACK_GLOBAL(csytrs2,CSYTRS2)
+#define LAPACK_cunbdb LAPACK_GLOBAL(cunbdb,CUNBDB)
+#define LAPACK_cuncsd LAPACK_GLOBAL(cuncsd,CUNCSD)
+#define LAPACK_dbbcsd LAPACK_GLOBAL(dbbcsd,DBBCSD)
+#define LAPACK_dorbdb LAPACK_GLOBAL(dorbdb,DORBDB)
+#define LAPACK_dorcsd LAPACK_GLOBAL(dorcsd,DORCSD)
+#define LAPACK_dsyconv LAPACK_GLOBAL(dsyconv,DSYCONV)
+#define LAPACK_dsyswapr LAPACK_GLOBAL(dsyswapr,DSYSWAPR)
+#define LAPACK_dsytri2 LAPACK_GLOBAL(dsytri2,DSYTRI2)
+#define LAPACK_dsytri2x LAPACK_GLOBAL(dsytri2x,DSYTRI2X)
+#define LAPACK_dsytrs2 LAPACK_GLOBAL(dsytrs2,DSYTRS2)
+#define LAPACK_sbbcsd LAPACK_GLOBAL(sbbcsd,SBBCSD)
+#define LAPACK_sorbdb LAPACK_GLOBAL(sorbdb,SORBDB)
+#define LAPACK_sorcsd LAPACK_GLOBAL(sorcsd,SORCSD)
+#define LAPACK_ssyconv LAPACK_GLOBAL(ssyconv,SSYCONV)
+#define LAPACK_ssyswapr LAPACK_GLOBAL(ssyswapr,SSYSWAPR)
+#define LAPACK_ssytri2 LAPACK_GLOBAL(ssytri2,SSYTRI2)
+#define LAPACK_ssytri2x LAPACK_GLOBAL(ssytri2x,SSYTRI2X)
+#define LAPACK_ssytrs2 LAPACK_GLOBAL(ssytrs2,SSYTRS2)
+#define LAPACK_zbbcsd LAPACK_GLOBAL(zbbcsd,ZBBCSD)
+#define LAPACK_zheswapr LAPACK_GLOBAL(zheswapr,ZHESWAPR)
+#define LAPACK_zhetri2 LAPACK_GLOBAL(zhetri2,ZHETRI2)
+#define LAPACK_zhetri2x LAPACK_GLOBAL(zhetri2x,ZHETRI2X)
+#define LAPACK_zhetrs2 LAPACK_GLOBAL(zhetrs2,ZHETRS2)
+#define LAPACK_zsyconv LAPACK_GLOBAL(zsyconv,ZSYCONV)
+#define LAPACK_zsyswapr LAPACK_GLOBAL(zsyswapr,ZSYSWAPR)
+#define LAPACK_zsytri2 LAPACK_GLOBAL(zsytri2,ZSYTRI2)
+#define LAPACK_zsytri2x LAPACK_GLOBAL(zsytri2x,ZSYTRI2X)
+#define LAPACK_zsytrs2 LAPACK_GLOBAL(zsytrs2,ZSYTRS2)
+#define LAPACK_zunbdb LAPACK_GLOBAL(zunbdb,ZUNBDB)
+#define LAPACK_zuncsd LAPACK_GLOBAL(zuncsd,ZUNCSD)
+// LAPACK 3.4.0
+#define LAPACK_sgemqrt LAPACK_GLOBAL(sgemqrt,SGEMQRT)
+#define LAPACK_dgemqrt LAPACK_GLOBAL(dgemqrt,DGEMQRT)
+#define LAPACK_cgemqrt LAPACK_GLOBAL(cgemqrt,CGEMQRT)
+#define LAPACK_zgemqrt LAPACK_GLOBAL(zgemqrt,ZGEMQRT)
+#define LAPACK_sgeqrt LAPACK_GLOBAL(sgeqrt,SGEQRT)
+#define LAPACK_dgeqrt LAPACK_GLOBAL(dgeqrt,DGEQRT)
+#define LAPACK_cgeqrt LAPACK_GLOBAL(cgeqrt,CGEQRT)
+#define LAPACK_zgeqrt LAPACK_GLOBAL(zgeqrt,ZGEQRT)
+#define LAPACK_sgeqrt2 LAPACK_GLOBAL(sgeqrt2,SGEQRT2)
+#define LAPACK_dgeqrt2 LAPACK_GLOBAL(dgeqrt2,DGEQRT2)
+#define LAPACK_cgeqrt2 LAPACK_GLOBAL(cgeqrt2,CGEQRT2)
+#define LAPACK_zgeqrt2 LAPACK_GLOBAL(zgeqrt2,ZGEQRT2)
+#define LAPACK_sgeqrt3 LAPACK_GLOBAL(sgeqrt3,SGEQRT3)
+#define LAPACK_dgeqrt3 LAPACK_GLOBAL(dgeqrt3,DGEQRT3)
+#define LAPACK_cgeqrt3 LAPACK_GLOBAL(cgeqrt3,CGEQRT3)
+#define LAPACK_zgeqrt3 LAPACK_GLOBAL(zgeqrt3,ZGEQRT3)
+#define LAPACK_stpmqrt LAPACK_GLOBAL(stpmqrt,STPMQRT)
+#define LAPACK_dtpmqrt LAPACK_GLOBAL(dtpmqrt,DTPMQRT)
+#define LAPACK_ctpmqrt LAPACK_GLOBAL(ctpmqrt,CTPMQRT)
+#define LAPACK_ztpmqrt LAPACK_GLOBAL(ztpmqrt,ZTPMQRT)
+#define LAPACK_dtpqrt LAPACK_GLOBAL(dtpqrt,DTPQRT)
+#define LAPACK_ctpqrt LAPACK_GLOBAL(ctpqrt,CTPQRT)
+#define LAPACK_ztpqrt LAPACK_GLOBAL(ztpqrt,ZTPQRT)
+#define LAPACK_stpqrt2 LAPACK_GLOBAL(stpqrt2,STPQRT2)
+#define LAPACK_dtpqrt2 LAPACK_GLOBAL(dtpqrt2,DTPQRT2)
+#define LAPACK_ctpqrt2 LAPACK_GLOBAL(ctpqrt2,CTPQRT2)
+#define LAPACK_ztpqrt2 LAPACK_GLOBAL(ztpqrt2,ZTPQRT2)
+#define LAPACK_stprfb LAPACK_GLOBAL(stprfb,STPRFB)
+#define LAPACK_dtprfb LAPACK_GLOBAL(dtprfb,DTPRFB)
+#define LAPACK_ctprfb LAPACK_GLOBAL(ctprfb,CTPRFB)
+#define LAPACK_ztprfb LAPACK_GLOBAL(ztprfb,ZTPRFB)
+// LAPACK 3.X.X
+#define LAPACK_csyr LAPACK_GLOBAL(csyr,CSYR)
+#define LAPACK_zsyr LAPACK_GLOBAL(zsyr,ZSYR)
+
+
+void LAPACK_sgetrf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgetrf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgetrf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_zgetrf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_sgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, float* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, double* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_zgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_sgttrf( lapack_int* n, float* dl, float* d, float* du, float* du2,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgttrf( lapack_int* n, double* dl, double* d, double* du,
+                    double* du2, lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgttrf( lapack_int* n, lapack_complex_float* dl,
+                    lapack_complex_float* d, lapack_complex_float* du,
+                    lapack_complex_float* du2, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_zgttrf( lapack_int* n, lapack_complex_double* dl,
+                    lapack_complex_double* d, lapack_complex_double* du,
+                    lapack_complex_double* du2, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_spotrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dpotrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_cpotrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_zpotrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dpstrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* piv, lapack_int* rank, double* tol,
+                    double* work, lapack_int *info );
+void LAPACK_spstrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* piv, lapack_int* rank, float* tol, float* work,
+                    lapack_int *info );
+void LAPACK_zpstrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* piv, lapack_int* rank,
+                    double* tol, double* work, lapack_int *info );
+void LAPACK_cpstrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* piv, lapack_int* rank,
+                    float* tol, float* work, lapack_int *info );
+void LAPACK_dpftrf( char* transr, char* uplo, lapack_int* n, double* a,
+                    lapack_int *info );
+void LAPACK_spftrf( char* transr, char* uplo, lapack_int* n, float* a,
+                    lapack_int *info );
+void LAPACK_zpftrf( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int *info );
+void LAPACK_cpftrf( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int *info );
+void LAPACK_spptrf( char* uplo, lapack_int* n, float* ap, lapack_int *info );
+void LAPACK_dpptrf( char* uplo, lapack_int* n, double* ap, lapack_int *info );
+void LAPACK_cpptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_zpptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_spbtrf( char* uplo, lapack_int* n, lapack_int* kd, float* ab,
+                    lapack_int* ldab, lapack_int *info );
+void LAPACK_dpbtrf( char* uplo, lapack_int* n, lapack_int* kd, double* ab,
+                    lapack_int* ldab, lapack_int *info );
+void LAPACK_cpbtrf( char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_int *info );
+void LAPACK_zpbtrf( char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_int *info );
+void LAPACK_spttrf( lapack_int* n, float* d, float* e, lapack_int *info );
+void LAPACK_dpttrf( lapack_int* n, double* d, double* e, lapack_int *info );
+void LAPACK_cpttrf( lapack_int* n, float* d, lapack_complex_float* e,
+                    lapack_int *info );
+void LAPACK_zpttrf( lapack_int* n, double* d, lapack_complex_double* e,
+                    lapack_int *info );
+void LAPACK_ssytrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ipiv, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dsytrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ipiv, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_csytrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zsytrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_chetrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zhetrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ssptrf( char* uplo, lapack_int* n, float* ap, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_dsptrf( char* uplo, lapack_int* n, double* ap, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_csptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_zsptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_chptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_zhptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_sgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* a, lapack_int* lda, const lapack_int* ipiv,
+                    float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const lapack_int* ipiv,
+                    double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_sgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const float* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const double* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_cgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_float* ab,
+                    lapack_int* ldab, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_double* ab,
+                    lapack_int* ldab, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_sgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* dl, const float* d, const float* du,
+                    const float* du2, const lapack_int* ipiv, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* dl, const double* d, const double* du,
+                    const double* du2, const lapack_int* ipiv, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du,
+                    const lapack_complex_float* du2, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du,
+                    const lapack_complex_double* du2, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_spotrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_spftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* a, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_spptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_cpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_spbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const float* ab, lapack_int* ldab, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const double* ab, lapack_int* ldab, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_spttrs( lapack_int* n, lapack_int* nrhs, const float* d,
+                    const float* e, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpttrs( lapack_int* n, lapack_int* nrhs, const double* d,
+                    const double* e, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_cpttrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const lapack_complex_float* e, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zpttrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const lapack_complex_double* e,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ssytrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, const lapack_int* ipiv, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dsytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const lapack_int* ipiv,
+                    double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_csytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zsytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_chetrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zhetrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_ssptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, const lapack_int* ipiv, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dsptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, const lapack_int* ipiv, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_csptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zsptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_chptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zhptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_strtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dtrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* a, lapack_int* lda,
+                    double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_ctrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ztrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_stptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* ap, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dtptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* ap, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_ctptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* ap,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ztptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* ap,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_stbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const float* ab,
+                    lapack_int* ldab, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dtbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const double* ab,
+                    lapack_int* ldab, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ctbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ztbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_sgecon( char* norm, lapack_int* n, const float* a, lapack_int* lda,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgecon( char* norm, lapack_int* n, const double* a, lapack_int* lda,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgecon( char* norm, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* anorm, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgecon( char* norm, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, double* anorm, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const float* ab, lapack_int* ldab, const lapack_int* ipiv,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const double* ab, lapack_int* ldab, const lapack_int* ipiv,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgtcon( char* norm, lapack_int* n, const float* dl, const float* d,
+                    const float* du, const float* du2, const lapack_int* ipiv,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgtcon( char* norm, lapack_int* n, const double* dl,
+                    const double* d, const double* du, const double* du2,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgtcon( char* norm, lapack_int* n, const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du,
+                    const lapack_complex_float* du2, const lapack_int* ipiv,
+                    float* anorm, float* rcond, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zgtcon( char* norm, lapack_int* n, const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du,
+                    const lapack_complex_double* du2, const lapack_int* ipiv,
+                    double* anorm, double* rcond, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_spocon( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dpocon( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cpocon( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* anorm, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zpocon( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, double* anorm, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sppcon( char* uplo, lapack_int* n, const float* ap, float* anorm,
+                    float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dppcon( char* uplo, lapack_int* n, const double* ap, double* anorm,
+                    double* rcond, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cppcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    float* anorm, float* rcond, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zppcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    double* anorm, double* rcond, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_spbcon( char* uplo, lapack_int* n, lapack_int* kd, const float* ab,
+                    lapack_int* ldab, float* anorm, float* rcond, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dpbcon( char* uplo, lapack_int* n, lapack_int* kd, const double* ab,
+                    lapack_int* ldab, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cpbcon( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    float* anorm, float* rcond, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zpbcon( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    double* anorm, double* rcond, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sptcon( lapack_int* n, const float* d, const float* e, float* anorm,
+                    float* rcond, float* work, lapack_int *info );
+void LAPACK_dptcon( lapack_int* n, const double* d, const double* e,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int *info );
+void LAPACK_cptcon( lapack_int* n, const float* d,
+                    const lapack_complex_float* e, float* anorm, float* rcond,
+                    float* work, lapack_int *info );
+void LAPACK_zptcon( lapack_int* n, const double* d,
+                    const lapack_complex_double* e, double* anorm,
+                    double* rcond, double* work, lapack_int *info );
+void LAPACK_ssycon( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dsycon( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_csycon( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv, float* anorm,
+                    float* rcond, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zsycon( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv, double* anorm,
+                    double* rcond, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_checon( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv, float* anorm,
+                    float* rcond, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zhecon( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv, double* anorm,
+                    double* rcond, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_sspcon( char* uplo, lapack_int* n, const float* ap,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dspcon( char* uplo, lapack_int* n, const double* ap,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cspcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zspcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_chpcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zhpcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_strcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const float* a, lapack_int* lda, float* rcond, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtrcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const double* a, lapack_int* lda, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_ctrcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    float* rcond, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztrcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    double* rcond, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const float* ap, float* rcond, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const double* ap, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_float* ap, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_double* ap, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const float* ab, lapack_int* ldab,
+                    float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dtbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const double* ab, lapack_int* ldab,
+                    double* rcond, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const lapack_complex_float* ab,
+                    lapack_int* ldab, float* rcond, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_ztbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const lapack_complex_double* ab,
+                    lapack_int* ldab, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* a, lapack_int* lda, const float* af,
+                    lapack_int* ldaf, const lapack_int* ipiv, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
+                    float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const double* af,
+                    lapack_int* ldaf, const lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const double* a, lapack_int* lda, const double* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const double* r,
+                     const double* c, const double* b, lapack_int* ldb,
+                     double* x, lapack_int* ldx, double* rcond, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const float* a, lapack_int* lda, const float* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const float* r,
+                     const float* c, const float* b, lapack_int* ldb, float* x,
+                     lapack_int* ldx, float* rcond, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const double* r, const double* c,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const float* r, const float* c,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const float* ab, lapack_int* ldab,
+                    const float* afb, lapack_int* ldafb, const lapack_int* ipiv,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const double* ab, lapack_int* ldab,
+                    const double* afb, lapack_int* ldafb,
+                    const lapack_int* ipiv, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_float* ab,
+                    lapack_int* ldab, const lapack_complex_float* afb,
+                    lapack_int* ldafb, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_double* ab,
+                    lapack_int* ldab, const lapack_complex_double* afb,
+                    lapack_int* ldafb, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_dgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, const double* ab,
+                     lapack_int* ldab, const double* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const double* r, const double* c,
+                     const double* b, lapack_int* ldb, double* x,
+                     lapack_int* ldx, double* rcond, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, const float* ab,
+                     lapack_int* ldab, const float* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const float* r, const float* c,
+                     const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params, float* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_zgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs,
+                     const lapack_complex_double* ab, lapack_int* ldab,
+                     const lapack_complex_double* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const double* r, const double* c,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs,
+                     const lapack_complex_float* ab, lapack_int* ldab,
+                     const lapack_complex_float* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const float* r, const float* c,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* dl, const float* d, const float* du,
+                    const float* dlf, const float* df, const float* duf,
+                    const float* du2, const lapack_int* ipiv, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
+                    float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* dl, const double* d, const double* du,
+                    const double* dlf, const double* df, const double* duf,
+                    const double* du2, const lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du,
+                    const lapack_complex_float* dlf,
+                    const lapack_complex_float* df,
+                    const lapack_complex_float* duf,
+                    const lapack_complex_float* du2, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du,
+                    const lapack_complex_double* dlf,
+                    const lapack_complex_double* df,
+                    const lapack_complex_double* duf,
+                    const lapack_complex_double* du2, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sporfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, const float* af, lapack_int* ldaf,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const double* af,
+                    lapack_int* ldaf, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_dporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const double* a, lapack_int* lda, const double* af,
+                     lapack_int* ldaf, const double* s, const double* b,
+                     lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params, double* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_sporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const float* a, lapack_int* lda, const float* af,
+                     lapack_int* ldaf, const float* s, const float* b,
+                     lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const double* s, const lapack_complex_double* b,
+                     lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                     double* rcond, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const float* s, const lapack_complex_float* b,
+                     lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                     float* rcond, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_spprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, const float* afp, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
+                    float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, const double* afp, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap,
+                    const lapack_complex_float* afp,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap,
+                    const lapack_complex_double* afp,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_spbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const float* ab, lapack_int* ldab, const float* afb,
+                    lapack_int* ldafb, const float* b, lapack_int* ldb,
+                    float* x, lapack_int* ldx, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const double* ab, lapack_int* ldab, const double* afb,
+                    lapack_int* ldafb, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_complex_float* afb, lapack_int* ldafb,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_complex_double* afb, lapack_int* ldafb,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sptrfs( lapack_int* n, lapack_int* nrhs, const float* d,
+                    const float* e, const float* df, const float* ef,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int *info );
+void LAPACK_dptrfs( lapack_int* n, lapack_int* nrhs, const double* d,
+                    const double* e, const double* df, const double* ef,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* ferr, double* berr, double* work,
+                    lapack_int *info );
+void LAPACK_cptrfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const lapack_complex_float* e, const float* df,
+                    const lapack_complex_float* ef,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zptrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const lapack_complex_double* e,
+                    const double* df, const lapack_complex_double* ef,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_ssyrfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, const float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const float* b, lapack_int* ldb,
+                    float* x, lapack_int* ldx, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dsyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const double* af,
+                    lapack_int* ldaf, const lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_csyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zsyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dsyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const double* a, lapack_int* lda, const double* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const double* s,
+                     const double* b, lapack_int* ldb, double* x,
+                     lapack_int* ldx, double* rcond, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_ssyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const float* a, lapack_int* lda, const float* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const float* s,
+                     const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params, float* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_zsyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const double* s,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_csyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const float* s,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_cherfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zherfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_zherfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const double* s,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cherfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const float* s,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_ssprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, const float* afp, const lapack_int* ipiv,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dsprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, const double* afp, const lapack_int* ipiv,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_csprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap,
+                    const lapack_complex_float* afp, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zsprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap,
+                    const lapack_complex_double* afp, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_chprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap,
+                    const lapack_complex_float* afp, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap,
+                    const lapack_complex_double* afp, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_strrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* a, lapack_int* lda,
+                    const float* b, lapack_int* ldb, const float* x,
+                    lapack_int* ldx, float* ferr, float* berr, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* a, lapack_int* lda,
+                    const double* b, lapack_int* ldb, const double* x,
+                    lapack_int* ldx, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* b,
+                    lapack_int* ldb, const lapack_complex_float* x,
+                    lapack_int* ldx, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* b,
+                    lapack_int* ldb, const lapack_complex_double* x,
+                    lapack_int* ldx, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* ap, const float* b,
+                    lapack_int* ldb, const float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dtprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* ap, const double* b,
+                    lapack_int* ldb, const double* x, lapack_int* ldx,
+                    double* ferr, double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* ap,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    const lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* ap,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    const lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_stbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const float* ab,
+                    lapack_int* ldab, const float* b, lapack_int* ldb,
+                    const float* x, lapack_int* ldx, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dtbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const double* ab,
+                    lapack_int* ldab, const double* b, lapack_int* ldb,
+                    const double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    const lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    const lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgetri( lapack_int* n, float* a, lapack_int* lda,
+                    const lapack_int* ipiv, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgetri( lapack_int* n, double* a, lapack_int* lda,
+                    const lapack_int* ipiv, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgetri( lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zgetri( lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_spotri( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dpotri( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_cpotri( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_zpotri( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dpftri( char* transr, char* uplo, lapack_int* n, double* a,
+                    lapack_int *info );
+void LAPACK_spftri( char* transr, char* uplo, lapack_int* n, float* a,
+                    lapack_int *info );
+void LAPACK_zpftri( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int *info );
+void LAPACK_cpftri( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int *info );
+void LAPACK_spptri( char* uplo, lapack_int* n, float* ap, lapack_int *info );
+void LAPACK_dpptri( char* uplo, lapack_int* n, double* ap, lapack_int *info );
+void LAPACK_cpptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_zpptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_ssytri( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    const lapack_int* ipiv, float* work, lapack_int *info );
+void LAPACK_dsytri( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    const lapack_int* ipiv, double* work, lapack_int *info );
+void LAPACK_csytri( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zsytri( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_chetri( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zhetri( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_ssptri( char* uplo, lapack_int* n, float* ap,
+                    const lapack_int* ipiv, float* work, lapack_int *info );
+void LAPACK_dsptri( char* uplo, lapack_int* n, double* ap,
+                    const lapack_int* ipiv, double* work, lapack_int *info );
+void LAPACK_csptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    const lapack_int* ipiv, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zsptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    const lapack_int* ipiv, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_chptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    const lapack_int* ipiv, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zhptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    const lapack_int* ipiv, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_strtri( char* uplo, char* diag, lapack_int* n, float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dtrtri( char* uplo, char* diag, lapack_int* n, double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_ctrtri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_ztrtri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dtftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    double* a, lapack_int *info );
+void LAPACK_stftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    float* a, lapack_int *info );
+void LAPACK_ztftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_double* a, lapack_int *info );
+void LAPACK_ctftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_float* a, lapack_int *info );
+void LAPACK_stptri( char* uplo, char* diag, lapack_int* n, float* ap,
+                    lapack_int *info );
+void LAPACK_dtptri( char* uplo, char* diag, lapack_int* n, double* ap,
+                    lapack_int *info );
+void LAPACK_ctptri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_float* ap, lapack_int *info );
+void LAPACK_ztptri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_double* ap, lapack_int *info );
+void LAPACK_sgeequ( lapack_int* m, lapack_int* n, const float* a,
+                    lapack_int* lda, float* r, float* c, float* rowcnd,
+                    float* colcnd, float* amax, lapack_int *info );
+void LAPACK_dgeequ( lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, double* r, double* c, double* rowcnd,
+                    double* colcnd, double* amax, lapack_int *info );
+void LAPACK_cgeequ( lapack_int* m, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* r, float* c, float* rowcnd,
+                    float* colcnd, float* amax, lapack_int *info );
+void LAPACK_zgeequ( lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* r,
+                    double* c, double* rowcnd, double* colcnd, double* amax,
+                    lapack_int *info );
+void LAPACK_dgeequb( lapack_int* m, lapack_int* n, const double* a,
+                     lapack_int* lda, double* r, double* c, double* rowcnd,
+                     double* colcnd, double* amax, lapack_int *info );
+void LAPACK_sgeequb( lapack_int* m, lapack_int* n, const float* a,
+                     lapack_int* lda, float* r, float* c, float* rowcnd,
+                     float* colcnd, float* amax, lapack_int *info );
+void LAPACK_zgeequb( lapack_int* m, lapack_int* n,
+                     const lapack_complex_double* a, lapack_int* lda, double* r,
+                     double* c, double* rowcnd, double* colcnd, double* amax,
+                     lapack_int *info );
+void LAPACK_cgeequb( lapack_int* m, lapack_int* n,
+                     const lapack_complex_float* a, lapack_int* lda, float* r,
+                     float* c, float* rowcnd, float* colcnd, float* amax,
+                     lapack_int *info );
+void LAPACK_sgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const float* ab, lapack_int* ldab, float* r,
+                    float* c, float* rowcnd, float* colcnd, float* amax,
+                    lapack_int *info );
+void LAPACK_dgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const double* ab, lapack_int* ldab,
+                    double* r, double* c, double* rowcnd, double* colcnd,
+                    double* amax, lapack_int *info );
+void LAPACK_cgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const lapack_complex_float* ab,
+                    lapack_int* ldab, float* r, float* c, float* rowcnd,
+                    float* colcnd, float* amax, lapack_int *info );
+void LAPACK_zgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const lapack_complex_double* ab,
+                    lapack_int* ldab, double* r, double* c, double* rowcnd,
+                    double* colcnd, double* amax, lapack_int *info );
+void LAPACK_dgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const double* ab, lapack_int* ldab,
+                     double* r, double* c, double* rowcnd, double* colcnd,
+                     double* amax, lapack_int *info );
+void LAPACK_sgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const float* ab, lapack_int* ldab,
+                     float* r, float* c, float* rowcnd, float* colcnd,
+                     float* amax, lapack_int *info );
+void LAPACK_zgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const lapack_complex_double* ab,
+                     lapack_int* ldab, double* r, double* c, double* rowcnd,
+                     double* colcnd, double* amax, lapack_int *info );
+void LAPACK_cgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const lapack_complex_float* ab,
+                     lapack_int* ldab, float* r, float* c, float* rowcnd,
+                     float* colcnd, float* amax, lapack_int *info );
+void LAPACK_spoequ( lapack_int* n, const float* a, lapack_int* lda, float* s,
+                    float* scond, float* amax, lapack_int *info );
+void LAPACK_dpoequ( lapack_int* n, const double* a, lapack_int* lda, double* s,
+                    double* scond, double* amax, lapack_int *info );
+void LAPACK_cpoequ( lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* s, float* scond, float* amax,
+                    lapack_int *info );
+void LAPACK_zpoequ( lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, double* s, double* scond, double* amax,
+                    lapack_int *info );
+void LAPACK_dpoequb( lapack_int* n, const double* a, lapack_int* lda, double* s,
+                     double* scond, double* amax, lapack_int *info );
+void LAPACK_spoequb( lapack_int* n, const float* a, lapack_int* lda, float* s,
+                     float* scond, float* amax, lapack_int *info );
+void LAPACK_zpoequb( lapack_int* n, const lapack_complex_double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     lapack_int *info );
+void LAPACK_cpoequb( lapack_int* n, const lapack_complex_float* a,
+                     lapack_int* lda, float* s, float* scond, float* amax,
+                     lapack_int *info );
+void LAPACK_sppequ( char* uplo, lapack_int* n, const float* ap, float* s,
+                    float* scond, float* amax, lapack_int *info );
+void LAPACK_dppequ( char* uplo, lapack_int* n, const double* ap, double* s,
+                    double* scond, double* amax, lapack_int *info );
+void LAPACK_cppequ( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    float* s, float* scond, float* amax, lapack_int *info );
+void LAPACK_zppequ( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    double* s, double* scond, double* amax, lapack_int *info );
+void LAPACK_spbequ( char* uplo, lapack_int* n, lapack_int* kd, const float* ab,
+                    lapack_int* ldab, float* s, float* scond, float* amax,
+                    lapack_int *info );
+void LAPACK_dpbequ( char* uplo, lapack_int* n, lapack_int* kd, const double* ab,
+                    lapack_int* ldab, double* s, double* scond, double* amax,
+                    lapack_int *info );
+void LAPACK_cpbequ( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_float* ab, lapack_int* ldab, float* s,
+                    float* scond, float* amax, lapack_int *info );
+void LAPACK_zpbequ( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    double* s, double* scond, double* amax, lapack_int *info );
+void LAPACK_dsyequb( char* uplo, lapack_int* n, const double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     double* work, lapack_int *info );
+void LAPACK_ssyequb( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                     float* s, float* scond, float* amax, float* work,
+                     lapack_int *info );
+void LAPACK_zsyequb( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_csyequb( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                     lapack_int* lda, float* s, float* scond, float* amax,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_zheequb( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_cheequb( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                     lapack_int* lda, float* s, float* scond, float* amax,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_sgesv( lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda,
+                   lapack_int* ipiv, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dgesv( lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda,
+                   lapack_int* ipiv, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_float* a,
+                   lapack_int* lda, lapack_int* ipiv, lapack_complex_float* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_zgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* a,
+                   lapack_int* lda, lapack_int* ipiv, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_dsgesv( lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda,
+                    lapack_int* ipiv, double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* work, float* swork,
+                    lapack_int* iter, lapack_int *info );
+void LAPACK_zcgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    lapack_complex_double* work, lapack_complex_float* swork,
+                    double* rwork, lapack_int* iter, lapack_int *info );
+void LAPACK_sgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, float* r, float* c, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, double* r, double* c,
+                    double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, float* r, float* c,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, double* r, double* c,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                     double* rcond, double* rpvgrw, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* r, float* c,
+                     float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* rpvgrw, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* r, float* c,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, float* ab, lapack_int* ldab,
+                   lapack_int* ipiv, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, double* ab, lapack_int* ldab,
+                   lapack_int* ipiv, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, lapack_complex_float* ab, lapack_int* ldab,
+                   lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_zgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, lapack_complex_double* ab,
+                   lapack_int* ldab, lapack_int* ipiv, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_sgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, float* ab,
+                    lapack_int* ldab, float* afb, lapack_int* ldafb,
+                    lapack_int* ipiv, char* equed, float* r, float* c, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, double* ab,
+                    lapack_int* ldab, double* afb, lapack_int* ldafb,
+                    lapack_int* ipiv, char* equed, double* r, double* c,
+                    double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, lapack_complex_float* ab,
+                    lapack_int* ldab, lapack_complex_float* afb,
+                    lapack_int* ldafb, lapack_int* ipiv, char* equed, float* r,
+                    float* c, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, lapack_complex_double* ab,
+                    lapack_int* ldab, lapack_complex_double* afb,
+                    lapack_int* ldafb, lapack_int* ipiv, char* equed, double* r,
+                    double* c, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, double* ab,
+                     lapack_int* ldab, double* afb, lapack_int* ldafb,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                     double* rcond, double* rpvgrw, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, float* ab,
+                     lapack_int* ldab, float* afb, lapack_int* ldafb,
+                     lapack_int* ipiv, char* equed, float* r, float* c,
+                     float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* rpvgrw, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs,
+                     lapack_complex_double* ab, lapack_int* ldab,
+                     lapack_complex_double* afb, lapack_int* ldafb,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, lapack_complex_float* ab,
+                     lapack_int* ldab, lapack_complex_float* afb,
+                     lapack_int* ldafb, lapack_int* ipiv, char* equed, float* r,
+                     float* c, lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgtsv( lapack_int* n, lapack_int* nrhs, float* dl, float* d,
+                   float* du, float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dgtsv( lapack_int* n, lapack_int* nrhs, double* dl, double* d,
+                   double* du, double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cgtsv( lapack_int* n, lapack_int* nrhs, lapack_complex_float* dl,
+                   lapack_complex_float* d, lapack_complex_float* du,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zgtsv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* dl,
+                   lapack_complex_double* d, lapack_complex_double* du,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_sgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* dl, const float* d, const float* du,
+                    float* dlf, float* df, float* duf, float* du2,
+                    lapack_int* ipiv, const float* b, lapack_int* ldb, float* x,
+                    lapack_int* ldx, float* rcond, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* dl, const double* d, const double* du,
+                    double* dlf, double* df, double* duf, double* du2,
+                    lapack_int* ipiv, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* rcond, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du, lapack_complex_float* dlf,
+                    lapack_complex_float* df, lapack_complex_float* duf,
+                    lapack_complex_float* du2, lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du, lapack_complex_double* dlf,
+                    lapack_complex_double* df, lapack_complex_double* duf,
+                    lapack_complex_double* du2, lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sposv( char* uplo, lapack_int* n, lapack_int* nrhs, float* a,
+                   lapack_int* lda, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dposv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
+                   lapack_int* lda, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cposv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zposv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dsposv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* work, float* swork,
+                    lapack_int* iter, lapack_int *info );
+void LAPACK_zcposv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx,
+                    lapack_complex_double* work, lapack_complex_float* swork,
+                    double* rwork, lapack_int* iter, lapack_int *info );
+void LAPACK_sposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                    char* equed, float* s, float* b, lapack_int* ldb, float* x,
+                    lapack_int* ldx, float* rcond, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                    char* equed, double* s, double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* rcond, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf, char* equed,
+                    float* s, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf, char* equed,
+                    double* s, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                     char* equed, double* s, double* b, lapack_int* ldb,
+                     double* x, lapack_int* ldx, double* rcond, double* rpvgrw,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params, double* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_sposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                     char* equed, float* s, float* b, lapack_int* ldb, float* x,
+                     lapack_int* ldx, float* rcond, float* rpvgrw, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf, char* equed,
+                     double* s, lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf, char* equed,
+                     float* s, lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sppsv( char* uplo, lapack_int* n, lapack_int* nrhs, float* ap,
+                   float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dppsv( char* uplo, lapack_int* n, lapack_int* nrhs, double* ap,
+                   double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cppsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* ap, lapack_complex_float* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_zppsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* ap, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_sppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    float* ap, float* afp, char* equed, float* s, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    double* ap, double* afp, char* equed, double* s, double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* ap, lapack_complex_float* afp,
+                    char* equed, float* s, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* ap, lapack_complex_double* afp,
+                    char* equed, double* s, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_spbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   float* ab, lapack_int* ldab, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   double* ab, lapack_int* ldab, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   lapack_complex_float* ab, lapack_int* ldab,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   lapack_complex_double* ab, lapack_int* ldab,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_spbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, float* ab, lapack_int* ldab, float* afb,
+                    lapack_int* ldafb, char* equed, float* s, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, double* ab, lapack_int* ldab, double* afb,
+                    lapack_int* ldafb, char* equed, double* s, double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, lapack_complex_float* ab,
+                    lapack_int* ldab, lapack_complex_float* afb,
+                    lapack_int* ldafb, char* equed, float* s,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, lapack_complex_double* ab,
+                    lapack_int* ldab, lapack_complex_double* afb,
+                    lapack_int* ldafb, char* equed, double* s,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sptsv( lapack_int* n, lapack_int* nrhs, float* d, float* e,
+                   float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dptsv( lapack_int* n, lapack_int* nrhs, double* d, double* e,
+                   double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cptsv( lapack_int* n, lapack_int* nrhs, float* d,
+                   lapack_complex_float* e, lapack_complex_float* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_zptsv( lapack_int* n, lapack_int* nrhs, double* d,
+                   lapack_complex_double* e, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_sptsvx( char* fact, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const float* e, float* df, float* ef, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int *info );
+void LAPACK_dptsvx( char* fact, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const double* e, double* df, double* ef,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* rcond, double* ferr, double* berr,
+                    double* work, lapack_int *info );
+void LAPACK_cptsvx( char* fact, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const lapack_complex_float* e, float* df,
+                    lapack_complex_float* ef, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zptsvx( char* fact, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const lapack_complex_double* e, double* df,
+                    lapack_complex_double* ef, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_ssysv( char* uplo, lapack_int* n, lapack_int* nrhs, float* a,
+                   lapack_int* lda, lapack_int* ipiv, float* b, lapack_int* ldb,
+                   float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dsysv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
+                   lapack_int* lda, lapack_int* ipiv, double* b,
+                   lapack_int* ldb, double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_csysv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_zsysv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_ssysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* a, lapack_int* lda, float* af,
+                    lapack_int* ldaf, lapack_int* ipiv, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dsysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, double* af,
+                    lapack_int* ldaf, lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_csysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zsysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_dsysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* s, double* b,
+                     lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params, double* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_ssysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* s, float* b,
+                     lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params, float* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_zsysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* s,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_csysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* s,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_chesv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_zhesv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_chesvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhesvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_zhesvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* s,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_chesvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* s,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sspsv( char* uplo, lapack_int* n, lapack_int* nrhs, float* ap,
+                   lapack_int* ipiv, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dspsv( char* uplo, lapack_int* n, lapack_int* nrhs, double* ap,
+                   lapack_int* ipiv, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cspsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* ap, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zspsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* ap, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_sspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, float* afp, lapack_int* ipiv,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, double* afp, lapack_int* ipiv,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* rcond, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, lapack_complex_float* afp,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, lapack_complex_double* afp,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_chpsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* ap, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zhpsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* ap, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_chpsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, lapack_complex_float* afp,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhpsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, lapack_complex_double* afp,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgeqrf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgeqrf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgeqrf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgeqrf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgeqpf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* jpvt, float* tau, float* work,
+                    lapack_int *info );
+void LAPACK_dgeqpf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* jpvt, double* tau, double* work,
+                    lapack_int *info );
+void LAPACK_cgeqpf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgeqpf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgeqp3( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* jpvt, float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgeqp3( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* jpvt, double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgeqp3( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int *info );
+void LAPACK_zgeqp3( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int *info );
+void LAPACK_sorgqr( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgqr( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungqr( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungqr( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgelqf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgelqf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgelqf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgelqf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sorglq( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorglq( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cunglq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zunglq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgeqlf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgeqlf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgeqlf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgeqlf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sorgql( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgql( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungql( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungql( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cunmql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgerqf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgerqf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgerqf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgerqf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sorgrq( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgrq( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungrq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungrq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cunmrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_stzrzf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dtzrzf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ctzrzf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ztzrzf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l, const float* a,
+                    lapack_int* lda, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dormrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l, const double* a,
+                    lapack_int* lda, const double* tau, double* c,
+                    lapack_int* ldc, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sggqrf( lapack_int* n, lapack_int* m, lapack_int* p, float* a,
+                    lapack_int* lda, float* taua, float* b, lapack_int* ldb,
+                    float* taub, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dggqrf( lapack_int* n, lapack_int* m, lapack_int* p, double* a,
+                    lapack_int* lda, double* taua, double* b, lapack_int* ldb,
+                    double* taub, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cggqrf( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* taua, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* taub,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zggqrf( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* taua, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* taub,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sggrqf( lapack_int* m, lapack_int* p, lapack_int* n, float* a,
+                    lapack_int* lda, float* taua, float* b, lapack_int* ldb,
+                    float* taub, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dggrqf( lapack_int* m, lapack_int* p, lapack_int* n, double* a,
+                    lapack_int* lda, double* taua, double* b, lapack_int* ldb,
+                    double* taub, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cggrqf( lapack_int* m, lapack_int* p, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* taua, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* taub,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zggrqf( lapack_int* m, lapack_int* p, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* taua, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* taub,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgebrd( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* d, float* e, float* tauq, float* taup, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgebrd( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* d, double* e, double* tauq, double* taup,
+                    double* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_cgebrd( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, float* d, float* e,
+                    lapack_complex_float* tauq, lapack_complex_float* taup,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgebrd( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, double* d, double* e,
+                    lapack_complex_double* tauq, lapack_complex_double* taup,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, float* ab, lapack_int* ldab,
+                    float* d, float* e, float* q, lapack_int* ldq, float* pt,
+                    lapack_int* ldpt, float* c, lapack_int* ldc, float* work,
+                    lapack_int *info );
+void LAPACK_dgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, double* ab,
+                    lapack_int* ldab, double* d, double* e, double* q,
+                    lapack_int* ldq, double* pt, lapack_int* ldpt, double* c,
+                    lapack_int* ldc, double* work, lapack_int *info );
+void LAPACK_cgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, lapack_complex_float* ab,
+                    lapack_int* ldab, float* d, float* e,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* pt, lapack_int* ldpt,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, lapack_complex_double* ab,
+                    lapack_int* ldab, double* d, double* e,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* pt, lapack_int* ldpt,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sorgbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    float* a, lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    double* a, lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k, const float* a,
+                    lapack_int* lda, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dormbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k, const double* a,
+                    lapack_int* lda, const double* tau, double* c,
+                    lapack_int* ldc, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cungbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, float* d, float* e,
+                    float* vt, lapack_int* ldvt, float* u, lapack_int* ldu,
+                    float* c, lapack_int* ldc, float* work, lapack_int *info );
+void LAPACK_dbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, double* d, double* e,
+                    double* vt, lapack_int* ldvt, double* u, lapack_int* ldu,
+                    double* c, lapack_int* ldc, double* work,
+                    lapack_int *info );
+void LAPACK_cbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, float* d, float* e,
+                    lapack_complex_float* vt, lapack_int* ldvt,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* c, lapack_int* ldc, float* work,
+                    lapack_int *info );
+void LAPACK_zbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, double* d, double* e,
+                    lapack_complex_double* vt, lapack_int* ldvt,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* c, lapack_int* ldc, double* work,
+                    lapack_int *info );
+void LAPACK_sbdsdc( char* uplo, char* compq, lapack_int* n, float* d, float* e,
+                    float* u, lapack_int* ldu, float* vt, lapack_int* ldvt,
+                    float* q, lapack_int* iq, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dbdsdc( char* uplo, char* compq, lapack_int* n, double* d,
+                    double* e, double* u, lapack_int* ldu, double* vt,
+                    lapack_int* ldvt, double* q, lapack_int* iq, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ssytrd( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    float* d, float* e, float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dsytrd( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    double* d, double* e, double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sorgtr( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    const float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dorgtr( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    const double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_chetrd( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, float* d, float* e,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zhetrd( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, double* d, double* e,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungtr( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zungtr( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ssptrd( char* uplo, lapack_int* n, float* ap, float* d, float* e,
+                    float* tau, lapack_int *info );
+void LAPACK_dsptrd( char* uplo, lapack_int* n, double* ap, double* d, double* e,
+                    double* tau, lapack_int *info );
+void LAPACK_sopgtr( char* uplo, lapack_int* n, const float* ap,
+                    const float* tau, float* q, lapack_int* ldq, float* work,
+                    lapack_int *info );
+void LAPACK_dopgtr( char* uplo, lapack_int* n, const double* ap,
+                    const double* tau, double* q, lapack_int* ldq, double* work,
+                    lapack_int *info );
+void LAPACK_sopmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const float* ap, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int *info );
+void LAPACK_dopmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const double* ap, const double* tau,
+                    double* c, lapack_int* ldc, double* work,
+                    lapack_int *info );
+void LAPACK_chptrd( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    float* d, float* e, lapack_complex_float* tau,
+                    lapack_int *info );
+void LAPACK_zhptrd( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    double* d, double* e, lapack_complex_double* tau,
+                    lapack_int *info );
+void LAPACK_cupgtr( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_complex_float* tau, lapack_complex_float* q,
+                    lapack_int* ldq, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zupgtr( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_complex_double* tau, lapack_complex_double* q,
+                    lapack_int* ldq, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_cupmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_complex_float* tau, lapack_complex_float* c,
+                    lapack_int* ldc, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zupmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_ssbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    float* ab, lapack_int* ldab, float* d, float* e, float* q,
+                    lapack_int* ldq, float* work, lapack_int *info );
+void LAPACK_dsbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    double* ab, lapack_int* ldab, double* d, double* e,
+                    double* q, lapack_int* ldq, double* work,
+                    lapack_int *info );
+void LAPACK_chbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_float* ab, lapack_int* ldab, float* d,
+                    float* e, lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zhbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_double* ab, lapack_int* ldab, double* d,
+                    double* e, lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_ssterf( lapack_int* n, float* d, float* e, lapack_int *info );
+void LAPACK_dsterf( lapack_int* n, double* d, double* e, lapack_int *info );
+void LAPACK_ssteqr( char* compz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dsteqr( char* compz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_csteqr( char* compz, lapack_int* n, float* d, float* e,
+                    lapack_complex_float* z, lapack_int* ldz, float* work,
+                    lapack_int *info );
+void LAPACK_zsteqr( char* compz, lapack_int* n, double* d, double* e,
+                    lapack_complex_double* z, lapack_int* ldz, double* work,
+                    lapack_int *info );
+void LAPACK_sstemr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    lapack_int* nzc, lapack_int* isuppz, lapack_logical* tryrac,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dstemr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, lapack_int* m, double* w, double* z,
+                    lapack_int* ldz, lapack_int* nzc, lapack_int* isuppz,
+                    lapack_logical* tryrac, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cstemr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_int* nzc, lapack_int* isuppz,
+                    lapack_logical* tryrac, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_zstemr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, lapack_int* m, double* w,
+                    lapack_complex_double* z, lapack_int* ldz, lapack_int* nzc,
+                    lapack_int* isuppz, lapack_logical* tryrac, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_sstedc( char* compz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dstedc( char* compz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cstedc( char* compz, lapack_int* n, float* d, float* e,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zstedc( char* compz, lapack_int* n, double* d, double* e,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sstegr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, lapack_int* isuppz, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_dstegr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, lapack_int* isuppz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_cstegr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_int* isuppz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_zstegr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_int* isuppz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_spteqr( char* compz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dpteqr( char* compz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_cpteqr( char* compz, lapack_int* n, float* d, float* e,
+                    lapack_complex_float* z, lapack_int* ldz, float* work,
+                    lapack_int *info );
+void LAPACK_zpteqr( char* compz, lapack_int* n, double* d, double* e,
+                    lapack_complex_double* z, lapack_int* ldz, double* work,
+                    lapack_int *info );
+void LAPACK_sstebz( char* range, char* order, lapack_int* n, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    const float* d, const float* e, lapack_int* m,
+                    lapack_int* nsplit, float* w, lapack_int* iblock,
+                    lapack_int* isplit, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dstebz( char* range, char* order, lapack_int* n, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    const double* d, const double* e, lapack_int* m,
+                    lapack_int* nsplit, double* w, lapack_int* iblock,
+                    lapack_int* isplit, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_sstein( lapack_int* n, const float* d, const float* e,
+                    lapack_int* m, const float* w, const lapack_int* iblock,
+                    const lapack_int* isplit, float* z, lapack_int* ldz,
+                    float* work, lapack_int* iwork, lapack_int* ifailv,
+                    lapack_int *info );
+void LAPACK_dstein( lapack_int* n, const double* d, const double* e,
+                    lapack_int* m, const double* w, const lapack_int* iblock,
+                    const lapack_int* isplit, double* z, lapack_int* ldz,
+                    double* work, lapack_int* iwork, lapack_int* ifailv,
+                    lapack_int *info );
+void LAPACK_cstein( lapack_int* n, const float* d, const float* e,
+                    lapack_int* m, const float* w, const lapack_int* iblock,
+                    const lapack_int* isplit, lapack_complex_float* z,
+                    lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifailv, lapack_int *info );
+void LAPACK_zstein( lapack_int* n, const double* d, const double* e,
+                    lapack_int* m, const double* w, const lapack_int* iblock,
+                    const lapack_int* isplit, lapack_complex_double* z,
+                    lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifailv, lapack_int *info );
+void LAPACK_sdisna( char* job, lapack_int* m, lapack_int* n, const float* d,
+                    float* sep, lapack_int *info );
+void LAPACK_ddisna( char* job, lapack_int* m, lapack_int* n, const double* d,
+                    double* sep, lapack_int *info );
+void LAPACK_ssygst( lapack_int* itype, char* uplo, lapack_int* n, float* a,
+                    lapack_int* lda, const float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dsygst( lapack_int* itype, char* uplo, lapack_int* n, double* a,
+                    lapack_int* lda, const double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_chegst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zhegst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_sspgst( lapack_int* itype, char* uplo, lapack_int* n, float* ap,
+                    const float* bp, lapack_int *info );
+void LAPACK_dspgst( lapack_int* itype, char* uplo, lapack_int* n, double* ap,
+                    const double* bp, lapack_int *info );
+void LAPACK_chpgst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, const lapack_complex_float* bp,
+                    lapack_int *info );
+void LAPACK_zhpgst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, const lapack_complex_double* bp,
+                    lapack_int *info );
+void LAPACK_ssbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, float* ab, lapack_int* ldab,
+                    const float* bb, lapack_int* ldbb, float* x,
+                    lapack_int* ldx, float* work, lapack_int *info );
+void LAPACK_dsbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, double* ab, lapack_int* ldab,
+                    const double* bb, lapack_int* ldbb, double* x,
+                    lapack_int* ldx, double* work, lapack_int *info );
+void LAPACK_chbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_complex_float* bb, lapack_int* ldbb,
+                    lapack_complex_float* x, lapack_int* ldx,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_complex_double* bb, lapack_int* ldbb,
+                    lapack_complex_double* x, lapack_int* ldx,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_spbstf( char* uplo, lapack_int* n, lapack_int* kb, float* bb,
+                    lapack_int* ldbb, lapack_int *info );
+void LAPACK_dpbstf( char* uplo, lapack_int* n, lapack_int* kb, double* bb,
+                    lapack_int* ldbb, lapack_int *info );
+void LAPACK_cpbstf( char* uplo, lapack_int* n, lapack_int* kb,
+                    lapack_complex_float* bb, lapack_int* ldbb,
+                    lapack_int *info );
+void LAPACK_zpbstf( char* uplo, lapack_int* n, lapack_int* kb,
+                    lapack_complex_double* bb, lapack_int* ldbb,
+                    lapack_int *info );
+void LAPACK_sgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a,
+                    lapack_int* lda, float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a,
+                    lapack_int* lda, double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sorghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, const float* a,
+                    lapack_int* lda, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dormhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, const double* a,
+                    lapack_int* lda, const double* tau, double* c,
+                    lapack_int* ldc, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zunghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* c,
+                    lapack_int* ldc, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zunmhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sgebal( char* job, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ilo, lapack_int* ihi, float* scale,
+                    lapack_int *info );
+void LAPACK_dgebal( char* job, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ilo, lapack_int* ihi, double* scale,
+                    lapack_int *info );
+void LAPACK_cgebal( char* job, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ilo, lapack_int* ihi,
+                    float* scale, lapack_int *info );
+void LAPACK_zgebal( char* job, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ilo, lapack_int* ihi,
+                    double* scale, lapack_int *info );
+void LAPACK_sgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* scale, lapack_int* m,
+                    float* v, lapack_int* ldv, lapack_int *info );
+void LAPACK_dgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* scale, lapack_int* m,
+                    double* v, lapack_int* ldv, lapack_int *info );
+void LAPACK_cgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* scale, lapack_int* m,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_zgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* scale, lapack_int* m,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_shseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, float* h, lapack_int* ldh, float* wr,
+                    float* wi, float* z, lapack_int* ldz, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dhseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, double* h, lapack_int* ldh, double* wr,
+                    double* wi, double* z, lapack_int* ldz, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_chseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_float* h, lapack_int* ldh,
+                    lapack_complex_float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zhseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_double* h, lapack_int* ldh,
+                    lapack_complex_double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_shsein( char* job, char* eigsrc, char* initv,
+                    lapack_logical* select, lapack_int* n, const float* h,
+                    lapack_int* ldh, float* wr, const float* wi, float* vl,
+                    lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, float* work,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_dhsein( char* job, char* eigsrc, char* initv,
+                    lapack_logical* select, lapack_int* n, const double* h,
+                    lapack_int* ldh, double* wr, const double* wi, double* vl,
+                    lapack_int* ldvl, double* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, double* work,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_chsein( char* job, char* eigsrc, char* initv,
+                    const lapack_logical* select, lapack_int* n,
+                    const lapack_complex_float* h, lapack_int* ldh,
+                    lapack_complex_float* w, lapack_complex_float* vl,
+                    lapack_int* ldvl, lapack_complex_float* vr,
+                    lapack_int* ldvr, lapack_int* mm, lapack_int* m,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_zhsein( char* job, char* eigsrc, char* initv,
+                    const lapack_logical* select, lapack_int* n,
+                    const lapack_complex_double* h, lapack_int* ldh,
+                    lapack_complex_double* w, lapack_complex_double* vl,
+                    lapack_int* ldvl, lapack_complex_double* vr,
+                    lapack_int* ldvr, lapack_int* mm, lapack_int* m,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_strevc( char* side, char* howmny, lapack_logical* select,
+                    lapack_int* n, const float* t, lapack_int* ldt, float* vl,
+                    lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, float* work,
+                    lapack_int *info );
+void LAPACK_dtrevc( char* side, char* howmny, lapack_logical* select,
+                    lapack_int* n, const double* t, lapack_int* ldt, double* vl,
+                    lapack_int* ldvl, double* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, double* work,
+                    lapack_int *info );
+void LAPACK_ctrevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* vl, lapack_int* ldvl,
+                    lapack_complex_float* vr, lapack_int* ldvr, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztrevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* vl, lapack_int* ldvl,
+                    lapack_complex_double* vr, lapack_int* ldvr, lapack_int* mm,
+                    lapack_int* m, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_strsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const float* t, lapack_int* ldt,
+                    const float* vl, lapack_int* ldvl, const float* vr,
+                    lapack_int* ldvr, float* s, float* sep, lapack_int* mm,
+                    lapack_int* m, float* work, lapack_int* ldwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtrsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const double* t, lapack_int* ldt,
+                    const double* vl, lapack_int* ldvl, const double* vr,
+                    lapack_int* ldvr, double* s, double* sep, lapack_int* mm,
+                    lapack_int* m, double* work, lapack_int* ldwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctrsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_float* t,
+                    lapack_int* ldt, const lapack_complex_float* vl,
+                    lapack_int* ldvl, const lapack_complex_float* vr,
+                    lapack_int* ldvr, float* s, float* sep, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work,
+                    lapack_int* ldwork, float* rwork, lapack_int *info );
+void LAPACK_ztrsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_double* t,
+                    lapack_int* ldt, const lapack_complex_double* vl,
+                    lapack_int* ldvl, const lapack_complex_double* vr,
+                    lapack_int* ldvr, double* s, double* sep, lapack_int* mm,
+                    lapack_int* m, lapack_complex_double* work,
+                    lapack_int* ldwork, double* rwork, lapack_int *info );
+void LAPACK_strexc( char* compq, lapack_int* n, float* t, lapack_int* ldt,
+                    float* q, lapack_int* ldq, lapack_int* ifst,
+                    lapack_int* ilst, float* work, lapack_int *info );
+void LAPACK_dtrexc( char* compq, lapack_int* n, double* t, lapack_int* ldt,
+                    double* q, lapack_int* ldq, lapack_int* ifst,
+                    lapack_int* ilst, double* work, lapack_int *info );
+void LAPACK_ctrexc( char* compq, lapack_int* n, lapack_complex_float* t,
+                    lapack_int* ldt, lapack_complex_float* q, lapack_int* ldq,
+                    lapack_int* ifst, lapack_int* ilst, lapack_int *info );
+void LAPACK_ztrexc( char* compq, lapack_int* n, lapack_complex_double* t,
+                    lapack_int* ldt, lapack_complex_double* q, lapack_int* ldq,
+                    lapack_int* ifst, lapack_int* ilst, lapack_int *info );
+void LAPACK_strsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, float* t, lapack_int* ldt, float* q,
+                    lapack_int* ldq, float* wr, float* wi, lapack_int* m,
+                    float* s, float* sep, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dtrsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, double* t, lapack_int* ldt, double* q,
+                    lapack_int* ldq, double* wr, double* wi, lapack_int* m,
+                    double* s, double* sep, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_ctrsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* w, lapack_int* m, float* s,
+                    float* sep, lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ztrsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* w, lapack_int* m, double* s,
+                    double* sep, lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_strsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const float* a, lapack_int* lda,
+                    const float* b, lapack_int* ldb, float* c, lapack_int* ldc,
+                    float* scale, lapack_int *info );
+void LAPACK_dtrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const double* a, lapack_int* lda,
+                    const double* b, lapack_int* ldb, double* c,
+                    lapack_int* ldc, double* scale, lapack_int *info );
+void LAPACK_ctrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* c, lapack_int* ldc,
+                    float* scale, lapack_int *info );
+void LAPACK_ztrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* c, lapack_int* ldc,
+                    double* scale, lapack_int *info );
+void LAPACK_sgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* q, lapack_int* ldq, float* z,
+                    lapack_int* ldz, lapack_int *info );
+void LAPACK_dgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* q, lapack_int* ldq, double* z,
+                    lapack_int* ldz, lapack_int *info );
+void LAPACK_cgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_int *info );
+void LAPACK_zgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_int *info );
+void LAPACK_sggbal( char* job, lapack_int* n, float* a, lapack_int* lda,
+                    float* b, lapack_int* ldb, lapack_int* ilo, lapack_int* ihi,
+                    float* lscale, float* rscale, float* work,
+                    lapack_int *info );
+void LAPACK_dggbal( char* job, lapack_int* n, double* a, lapack_int* lda,
+                    double* b, lapack_int* ldb, lapack_int* ilo,
+                    lapack_int* ihi, double* lscale, double* rscale,
+                    double* work, lapack_int *info );
+void LAPACK_cggbal( char* job, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int* ilo, lapack_int* ihi, float* lscale,
+                    float* rscale, float* work, lapack_int *info );
+void LAPACK_zggbal( char* job, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int* ilo, lapack_int* ihi, double* lscale,
+                    double* rscale, double* work, lapack_int *info );
+void LAPACK_sggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* lscale, const float* rscale,
+                    lapack_int* m, float* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_dggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* lscale, const double* rscale,
+                    lapack_int* m, double* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_cggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* lscale, const float* rscale,
+                    lapack_int* m, lapack_complex_float* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_zggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* lscale, const double* rscale,
+                    lapack_int* m, lapack_complex_double* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_shgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, float* h, lapack_int* ldh,
+                    float* t, lapack_int* ldt, float* alphar, float* alphai,
+                    float* beta, float* q, lapack_int* ldq, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dhgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, double* h,
+                    lapack_int* ldh, double* t, lapack_int* ldt, double* alphar,
+                    double* alphai, double* beta, double* q, lapack_int* ldq,
+                    double* z, lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_chgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, lapack_complex_float* h,
+                    lapack_int* ldh, lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, lapack_complex_double* h,
+                    lapack_int* ldh, lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_stgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const float* s, lapack_int* lds,
+                    const float* p, lapack_int* ldp, float* vl,
+                    lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, float* work,
+                    lapack_int *info );
+void LAPACK_dtgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const double* s, lapack_int* lds,
+                    const double* p, lapack_int* ldp, double* vl,
+                    lapack_int* ldvl, double* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, double* work,
+                    lapack_int *info );
+void LAPACK_ctgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_float* s,
+                    lapack_int* lds, const lapack_complex_float* p,
+                    lapack_int* ldp, lapack_complex_float* vl, lapack_int* ldvl,
+                    lapack_complex_float* vr, lapack_int* ldvr, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_double* s,
+                    lapack_int* lds, const lapack_complex_double* p,
+                    lapack_int* ldp, lapack_complex_double* vl,
+                    lapack_int* ldvl, lapack_complex_double* vr,
+                    lapack_int* ldvr, lapack_int* mm, lapack_int* m,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* q, lapack_int* ldq, float* z, lapack_int* ldz,
+                    lapack_int* ifst, lapack_int* ilst, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dtgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* q, lapack_int* ldq, double* z, lapack_int* ldz,
+                    lapack_int* ifst, lapack_int* ilst, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_ctgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz, lapack_int* ifst,
+                    lapack_int* ilst, lapack_int *info );
+void LAPACK_ztgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz, lapack_int* ifst,
+                    lapack_int* ilst, lapack_int *info );
+void LAPACK_stgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* alphar, float* alphai, float* beta,
+                    float* q, lapack_int* ldq, float* z, lapack_int* ldz,
+                    lapack_int* m, float* pl, float* pr, float* dif,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dtgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* alphar, double* alphai,
+                    double* beta, double* q, lapack_int* ldq, double* z,
+                    lapack_int* ldz, lapack_int* m, double* pl, double* pr,
+                    double* dif, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_ctgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz, lapack_int* m,
+                    float* pl, float* pr, float* dif,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_ztgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz, lapack_int* m,
+                    double* pl, double* pr, double* dif,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_stgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const float* a, lapack_int* lda, const float* b,
+                    lapack_int* ldb, float* c, lapack_int* ldc, const float* d,
+                    lapack_int* ldd, const float* e, lapack_int* lde, float* f,
+                    lapack_int* ldf, float* scale, float* dif, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_dtgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const double* a, lapack_int* lda, const double* b,
+                    lapack_int* ldb, double* c, lapack_int* ldc,
+                    const double* d, lapack_int* ldd, const double* e,
+                    lapack_int* lde, double* f, lapack_int* ldf, double* scale,
+                    double* dif, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    const lapack_complex_float* d, lapack_int* ldd,
+                    const lapack_complex_float* e, lapack_int* lde,
+                    lapack_complex_float* f, lapack_int* ldf, float* scale,
+                    float* dif, lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ztgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    const lapack_complex_double* d, lapack_int* ldd,
+                    const lapack_complex_double* e, lapack_int* lde,
+                    lapack_complex_double* f, lapack_int* ldf, double* scale,
+                    double* dif, lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_stgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const float* a, lapack_int* lda,
+                    const float* b, lapack_int* ldb, const float* vl,
+                    lapack_int* ldvl, const float* vr, lapack_int* ldvr,
+                    float* s, float* dif, lapack_int* mm, lapack_int* m,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dtgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const double* a, lapack_int* lda,
+                    const double* b, lapack_int* ldb, const double* vl,
+                    lapack_int* ldvl, const double* vr, lapack_int* ldvr,
+                    double* s, double* dif, lapack_int* mm, lapack_int* m,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* b,
+                    lapack_int* ldb, const lapack_complex_float* vl,
+                    lapack_int* ldvl, const lapack_complex_float* vr,
+                    lapack_int* ldvr, float* s, float* dif, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_ztgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* b,
+                    lapack_int* ldb, const lapack_complex_double* vl,
+                    lapack_int* ldvl, const lapack_complex_double* vr,
+                    lapack_int* ldvr, double* s, double* dif, lapack_int* mm,
+                    lapack_int* m, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_sggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, float* a, lapack_int* lda,
+                    float* b, lapack_int* ldb, float* tola, float* tolb,
+                    lapack_int* k, lapack_int* l, float* u, lapack_int* ldu,
+                    float* v, lapack_int* ldv, float* q, lapack_int* ldq,
+                    lapack_int* iwork, float* tau, float* work,
+                    lapack_int *info );
+void LAPACK_dggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, double* a, lapack_int* lda,
+                    double* b, lapack_int* ldb, double* tola, double* tolb,
+                    lapack_int* k, lapack_int* l, double* u, lapack_int* ldu,
+                    double* v, lapack_int* ldv, double* q, lapack_int* ldq,
+                    lapack_int* iwork, double* tau, double* work,
+                    lapack_int *info );
+void LAPACK_cggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                    float* tola, float* tolb, lapack_int* k, lapack_int* l,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_complex_float* q, lapack_int* ldq, lapack_int* iwork,
+                    float* rwork, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                    double* tola, double* tolb, lapack_int* k, lapack_int* l,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_int* iwork, double* rwork,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_stgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* tola, float* tolb, float* alpha, float* beta,
+                    float* u, lapack_int* ldu, float* v, lapack_int* ldv,
+                    float* q, lapack_int* ldq, float* work, lapack_int* ncycle,
+                    lapack_int *info );
+void LAPACK_dtgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* tola, double* tolb, double* alpha, double* beta,
+                    double* u, lapack_int* ldu, double* v, lapack_int* ldv,
+                    double* q, lapack_int* ldq, double* work,
+                    lapack_int* ncycle, lapack_int *info );
+void LAPACK_ctgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* tola,
+                    float* tolb, float* alpha, float* beta,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* work, lapack_int* ncycle,
+                    lapack_int *info );
+void LAPACK_ztgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* tola,
+                    double* tolb, double* alpha, double* beta,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* work, lapack_int* ncycle,
+                    lapack_int *info );
+void LAPACK_sgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                   float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                   double* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_cgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_zgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_sgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb,
+                    lapack_int* jpvt, float* rcond, lapack_int* rank,
+                    float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb,
+                    lapack_int* jpvt, double* rcond, lapack_int* rank,
+                    double* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_cgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, lapack_int* jpvt,
+                    float* rcond, lapack_int* rank, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int *info );
+void LAPACK_zgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, lapack_int* jpvt,
+                    double* rcond, lapack_int* rank,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int *info );
+void LAPACK_zgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_dgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_zgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgglse( lapack_int* m, lapack_int* n, lapack_int* p, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* c,
+                    float* d, float* x, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgglse( lapack_int* m, lapack_int* n, lapack_int* p, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* c,
+                    double* d, double* x, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgglse( lapack_int* m, lapack_int* n, lapack_int* p,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* c, lapack_complex_float* d,
+                    lapack_complex_float* x, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zgglse( lapack_int* m, lapack_int* n, lapack_int* p,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* c, lapack_complex_double* d,
+                    lapack_complex_double* x, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sggglm( lapack_int* n, lapack_int* m, lapack_int* p, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* d,
+                    float* x, float* y, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dggglm( lapack_int* n, lapack_int* m, lapack_int* p, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* d,
+                    double* x, double* y, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cggglm( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* d, lapack_complex_float* x,
+                    lapack_complex_float* y, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zggglm( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* d, lapack_complex_double* x,
+                    lapack_complex_double* y, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_ssyev( char* jobz, char* uplo, lapack_int* n, float* a,
+                   lapack_int* lda, float* w, float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_dsyev( char* jobz, char* uplo, lapack_int* n, double* a,
+                   lapack_int* lda, double* w, double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_cheev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda, float* w,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zheev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda, double* w,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_int *info );
+void LAPACK_ssyevd( char* jobz, char* uplo, lapack_int* n, float* a,
+                    lapack_int* lda, float* w, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dsyevd( char* jobz, char* uplo, lapack_int* n, double* a,
+                    lapack_int* lda, double* w, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cheevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* w,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zheevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* w,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssyevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    float* a, lapack_int* lda, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dsyevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    double* a, lapack_int* lda, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, double* z, lapack_int* ldz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_cheevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_zheevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_ssyevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    float* a, lapack_int* lda, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    lapack_int* isuppz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dsyevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    double* a, lapack_int* lda, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, double* z, lapack_int* ldz,
+                    lapack_int* isuppz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cheevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_int* isuppz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zheevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_int* isuppz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sspev( char* jobz, char* uplo, lapack_int* n, float* ap, float* w,
+                   float* z, lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dspev( char* jobz, char* uplo, lapack_int* n, double* ap, double* w,
+                   double* z, lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_chpev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* ap, float* w, lapack_complex_float* z,
+                   lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                   lapack_int *info );
+void LAPACK_zhpev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* ap, double* w,
+                   lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_sspevd( char* jobz, char* uplo, lapack_int* n, float* ap, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dspevd( char* jobz, char* uplo, lapack_int* n, double* ap,
+                    double* w, double* z, lapack_int* ldz, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_chpevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* lrwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_zhpevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sspevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    float* ap, float* vl, float* vu, lapack_int* il,
+                    lapack_int* iu, float* abstol, lapack_int* m, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dspevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    double* ap, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_chpevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_zhpevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_ssbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   float* ab, lapack_int* ldab, float* w, float* z,
+                   lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dsbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   double* ab, lapack_int* ldab, double* w, double* z,
+                   lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_chbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   lapack_complex_float* ab, lapack_int* ldab, float* w,
+                   lapack_complex_float* z, lapack_int* ldz,
+                   lapack_complex_float* work, float* rwork, lapack_int *info );
+void LAPACK_zhbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   lapack_complex_double* ab, lapack_int* ldab, double* w,
+                   lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_ssbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    float* ab, lapack_int* ldab, float* w, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dsbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    double* ab, lapack_int* ldab, double* w, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_chbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_float* ab, lapack_int* ldab, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_double* ab, lapack_int* ldab, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, float* ab, lapack_int* ldab, float* q,
+                    lapack_int* ldq, float* vl, float* vu, lapack_int* il,
+                    lapack_int* iu, float* abstol, lapack_int* m, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dsbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, double* ab, lapack_int* ldab, double* q,
+                    lapack_int* ldq, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_chbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* q, lapack_int* ldq, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_zhbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* q, lapack_int* ldq, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_sstev( char* jobz, lapack_int* n, float* d, float* e, float* z,
+                   lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dstev( char* jobz, lapack_int* n, double* d, double* e, double* z,
+                   lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_sstevd( char* jobz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dstevd( char* jobz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_sstevx( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dstevx( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_sstevr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, lapack_int* isuppz, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_dstevr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, lapack_int* isuppz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sgees( char* jobvs, char* sort, LAPACK_S_SELECT2 select,
+                   lapack_int* n, float* a, lapack_int* lda, lapack_int* sdim,
+                   float* wr, float* wi, float* vs, lapack_int* ldvs,
+                   float* work, lapack_int* lwork, lapack_logical* bwork,
+                   lapack_int *info );
+void LAPACK_dgees( char* jobvs, char* sort, LAPACK_D_SELECT2 select,
+                   lapack_int* n, double* a, lapack_int* lda, lapack_int* sdim,
+                   double* wr, double* wi, double* vs, lapack_int* ldvs,
+                   double* work, lapack_int* lwork, lapack_logical* bwork,
+                   lapack_int *info );
+void LAPACK_cgees( char* jobvs, char* sort, LAPACK_C_SELECT1 select,
+                   lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                   lapack_int* sdim, lapack_complex_float* w,
+                   lapack_complex_float* vs, lapack_int* ldvs,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_logical* bwork, lapack_int *info );
+void LAPACK_zgees( char* jobvs, char* sort, LAPACK_Z_SELECT1 select,
+                   lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                   lapack_int* sdim, lapack_complex_double* w,
+                   lapack_complex_double* vs, lapack_int* ldvs,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_logical* bwork, lapack_int *info );
+void LAPACK_sgeesx( char* jobvs, char* sort, LAPACK_S_SELECT2 select,
+                    char* sense, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* sdim, float* wr, float* wi, float* vs,
+                    lapack_int* ldvs, float* rconde, float* rcondv, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_logical* bwork, lapack_int *info );
+void LAPACK_dgeesx( char* jobvs, char* sort, LAPACK_D_SELECT2 select,
+                    char* sense, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* sdim, double* wr, double* wi, double* vs,
+                    lapack_int* ldvs, double* rconde, double* rcondv,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_cgeesx( char* jobvs, char* sort, LAPACK_C_SELECT1 select,
+                    char* sense, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* sdim, lapack_complex_float* w,
+                    lapack_complex_float* vs, lapack_int* ldvs, float* rconde,
+                    float* rcondv, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_zgeesx( char* jobvs, char* sort, LAPACK_Z_SELECT1 select,
+                    char* sense, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* sdim, lapack_complex_double* w,
+                    lapack_complex_double* vs, lapack_int* ldvs, double* rconde,
+                    double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_sgeev( char* jobvl, char* jobvr, lapack_int* n, float* a,
+                   lapack_int* lda, float* wr, float* wi, float* vl,
+                   lapack_int* ldvl, float* vr, lapack_int* ldvr, float* work,
+                   lapack_int* lwork, lapack_int *info );
+void LAPACK_dgeev( char* jobvl, char* jobvr, lapack_int* n, double* a,
+                   lapack_int* lda, double* wr, double* wi, double* vl,
+                   lapack_int* ldvl, double* vr, lapack_int* ldvr, double* work,
+                   lapack_int* lwork, lapack_int *info );
+void LAPACK_cgeev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* w, lapack_complex_float* vl,
+                   lapack_int* ldvl, lapack_complex_float* vr, lapack_int* ldvr,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zgeev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* w, lapack_complex_double* vl,
+                   lapack_int* ldvl, lapack_complex_double* vr,
+                   lapack_int* ldvr, lapack_complex_double* work,
+                   lapack_int* lwork, double* rwork, lapack_int *info );
+void LAPACK_sgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, float* a, lapack_int* lda, float* wr,
+                    float* wi, float* vl, lapack_int* ldvl, float* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    float* scale, float* abnrm, float* rconde, float* rcondv,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, double* a, lapack_int* lda, double* wr,
+                    double* wi, double* vl, lapack_int* ldvl, double* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    double* scale, double* abnrm, double* rconde,
+                    double* rcondv, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* w, lapack_complex_float* vl,
+                    lapack_int* ldvl, lapack_complex_float* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    float* scale, float* abnrm, float* rconde, float* rcondv,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* w, lapack_complex_double* vl,
+                    lapack_int* ldvl, lapack_complex_double* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    double* scale, double* abnrm, double* rconde,
+                    double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int *info );
+void LAPACK_sgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    float* a, lapack_int* lda, float* s, float* u,
+                    lapack_int* ldu, float* vt, lapack_int* ldvt, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    double* a, lapack_int* lda, double* s, double* u,
+                    lapack_int* ldu, double* vt, lapack_int* ldvt, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* s,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* vt, lapack_int* ldvt,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* s,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* vt, lapack_int* ldvt,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgesdd( char* jobz, lapack_int* m, lapack_int* n, float* a,
+                    lapack_int* lda, float* s, float* u, lapack_int* ldu,
+                    float* vt, lapack_int* ldvt, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dgesdd( char* jobz, lapack_int* m, lapack_int* n, double* a,
+                    lapack_int* lda, double* s, double* u, lapack_int* ldu,
+                    double* vt, lapack_int* ldvt, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgesdd( char* jobz, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* s,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* vt, lapack_int* ldvt,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_zgesdd( char* jobz, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* s,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* vt, lapack_int* ldvt,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_dgejsv( char* joba, char* jobu, char* jobv, char* jobr, char* jobt,
+                    char* jobp, lapack_int* m, lapack_int* n, double* a,
+                    lapack_int* lda, double* sva, double* u, lapack_int* ldu,
+                    double* v, lapack_int* ldv, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_sgejsv( char* joba, char* jobu, char* jobv, char* jobr, char* jobt,
+                    char* jobp, lapack_int* m, lapack_int* n, float* a,
+                    lapack_int* lda, float* sva, float* u, lapack_int* ldu,
+                    float* v, lapack_int* ldv, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dgesvj( char* joba, char* jobu, char* jobv, lapack_int* m,
+                    lapack_int* n, double* a, lapack_int* lda, double* sva,
+                    lapack_int* mv, double* v, lapack_int* ldv, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sgesvj( char* joba, char* jobu, char* jobv, lapack_int* m,
+                    lapack_int* n, float* a, lapack_int* lda, float* sva,
+                    lapack_int* mv, float* v, lapack_int* ldv, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* alpha, float* beta, float* u, lapack_int* ldu,
+                    float* v, lapack_int* ldv, float* q, lapack_int* ldq,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* alpha, double* beta, double* u, lapack_int* ldu,
+                    double* v, lapack_int* ldv, double* q, lapack_int* ldq,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* alpha,
+                    float* beta, lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* work, float* rwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_zggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* alpha,
+                    double* beta, lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ssygv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                   float* w, float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dsygv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                   double* w, double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_chegv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb, float* w,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zhegv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb, double* w,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_int *info );
+void LAPACK_ssygvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* w, float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dsygvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* w, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_chegvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* w,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhegvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* w,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssygvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* vl, float* vu, lapack_int* il,
+                    lapack_int* iu, float* abstol, lapack_int* m, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_dsygvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_chegvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_zhegvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_sspgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   float* ap, float* bp, float* w, float* z, lapack_int* ldz,
+                   float* work, lapack_int *info );
+void LAPACK_dspgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   double* ap, double* bp, double* w, double* z,
+                   lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_chpgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* ap, lapack_complex_float* bp, float* w,
+                   lapack_complex_float* z, lapack_int* ldz,
+                   lapack_complex_float* work, float* rwork, lapack_int *info );
+void LAPACK_zhpgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* ap, lapack_complex_double* bp,
+                   double* w, lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_sspgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    float* ap, float* bp, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dspgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    double* ap, double* bp, double* w, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_chpgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, lapack_complex_float* bp,
+                    float* w, lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhpgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, lapack_complex_double* bp,
+                    double* w, lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sspgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, float* ap, float* bp, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* iwork, lapack_int* ifail,
+                    lapack_int *info );
+void LAPACK_dspgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, double* ap, double* bp, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, double* z, lapack_int* ldz,
+                    double* work, lapack_int* iwork, lapack_int* ifail,
+                    lapack_int *info );
+void LAPACK_chpgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_float* ap,
+                    lapack_complex_float* bp, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_zhpgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_double* ap,
+                    lapack_complex_double* bp, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_ssbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, float* ab, lapack_int* ldab, float* bb,
+                   lapack_int* ldbb, float* w, float* z, lapack_int* ldz,
+                   float* work, lapack_int *info );
+void LAPACK_dsbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, double* ab, lapack_int* ldab, double* bb,
+                   lapack_int* ldbb, double* w, double* z, lapack_int* ldz,
+                   double* work, lapack_int *info );
+void LAPACK_chbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
+                   lapack_complex_float* bb, lapack_int* ldbb, float* w,
+                   lapack_complex_float* z, lapack_int* ldz,
+                   lapack_complex_float* work, float* rwork, lapack_int *info );
+void LAPACK_zhbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
+                   lapack_complex_double* bb, lapack_int* ldbb, double* w,
+                   lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_ssbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, float* ab, lapack_int* ldab, float* bb,
+                    lapack_int* ldbb, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dsbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, double* ab, lapack_int* ldab, double* bb,
+                    lapack_int* ldbb, double* w, double* z, lapack_int* ldz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_chbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* bb, lapack_int* ldbb, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* bb, lapack_int* ldbb, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, float* ab, lapack_int* ldab,
+                    float* bb, lapack_int* ldbb, float* q, lapack_int* ldq,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dsbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, double* ab,
+                    lapack_int* ldab, double* bb, lapack_int* ldbb, double* q,
+                    lapack_int* ldq, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_chbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, lapack_complex_float* ab,
+                    lapack_int* ldab, lapack_complex_float* bb,
+                    lapack_int* ldbb, lapack_complex_float* q, lapack_int* ldq,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, float* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_zhbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, lapack_complex_double* ab,
+                    lapack_int* ldab, lapack_complex_double* bb,
+                    lapack_int* ldbb, lapack_complex_double* q, lapack_int* ldq,
+                    double* vl, double* vu, lapack_int* il, lapack_int* iu,
+                    double* abstol, lapack_int* m, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_sgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_S_SELECT3 selctg, lapack_int* n, float* a,
+                   lapack_int* lda, float* b, lapack_int* ldb, lapack_int* sdim,
+                   float* alphar, float* alphai, float* beta, float* vsl,
+                   lapack_int* ldvsl, float* vsr, lapack_int* ldvsr,
+                   float* work, lapack_int* lwork, lapack_logical* bwork,
+                   lapack_int *info );
+void LAPACK_dgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_D_SELECT3 selctg, lapack_int* n, double* a,
+                   lapack_int* lda, double* b, lapack_int* ldb,
+                   lapack_int* sdim, double* alphar, double* alphai,
+                   double* beta, double* vsl, lapack_int* ldvsl, double* vsr,
+                   lapack_int* ldvsr, double* work, lapack_int* lwork,
+                   lapack_logical* bwork, lapack_int *info );
+void LAPACK_cgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_C_SELECT2 selctg, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int* sdim,
+                   lapack_complex_float* alpha, lapack_complex_float* beta,
+                   lapack_complex_float* vsl, lapack_int* ldvsl,
+                   lapack_complex_float* vsr, lapack_int* ldvsr,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_logical* bwork, lapack_int *info );
+void LAPACK_zgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_Z_SELECT2 selctg, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb, lapack_int* sdim,
+                   lapack_complex_double* alpha, lapack_complex_double* beta,
+                   lapack_complex_double* vsl, lapack_int* ldvsl,
+                   lapack_complex_double* vsr, lapack_int* ldvsr,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_logical* bwork, lapack_int *info );
+void LAPACK_sggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_S_SELECT3 selctg, char* sense, lapack_int* n,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    lapack_int* sdim, float* alphar, float* alphai, float* beta,
+                    float* vsl, lapack_int* ldvsl, float* vsr,
+                    lapack_int* ldvsr, float* rconde, float* rcondv,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_dggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_D_SELECT3 selctg, char* sense, lapack_int* n,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    lapack_int* sdim, double* alphar, double* alphai,
+                    double* beta, double* vsl, lapack_int* ldvsl, double* vsr,
+                    lapack_int* ldvsr, double* rconde, double* rcondv,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_cggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_C_SELECT2 selctg, char* sense, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, lapack_int* sdim,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* vsl, lapack_int* ldvsl,
+                    lapack_complex_float* vsr, lapack_int* ldvsr, float* rconde,
+                    float* rcondv, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_zggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_Z_SELECT2 selctg, char* sense, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, lapack_int* sdim,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* vsl, lapack_int* ldvsl,
+                    lapack_complex_double* vsr, lapack_int* ldvsr,
+                    double* rconde, double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_sggev( char* jobvl, char* jobvr, lapack_int* n, float* a,
+                   lapack_int* lda, float* b, lapack_int* ldb, float* alphar,
+                   float* alphai, float* beta, float* vl, lapack_int* ldvl,
+                   float* vr, lapack_int* ldvr, float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_dggev( char* jobvl, char* jobvr, lapack_int* n, double* a,
+                   lapack_int* lda, double* b, lapack_int* ldb, double* alphar,
+                   double* alphai, double* beta, double* vl, lapack_int* ldvl,
+                   double* vr, lapack_int* ldvr, double* work,
+                   lapack_int* lwork, lapack_int *info );
+void LAPACK_cggev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* alpha, lapack_complex_float* beta,
+                   lapack_complex_float* vl, lapack_int* ldvl,
+                   lapack_complex_float* vr, lapack_int* ldvr,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zggev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* alpha, lapack_complex_double* beta,
+                   lapack_complex_double* vl, lapack_int* ldvl,
+                   lapack_complex_double* vr, lapack_int* ldvr,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_int *info );
+void LAPACK_sggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* alphar, float* alphai, float* beta,
+                    float* vl, lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* ilo, lapack_int* ihi, float* lscale,
+                    float* rscale, float* abnrm, float* bbnrm, float* rconde,
+                    float* rcondv, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_dggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* alphar, double* alphai,
+                    double* beta, double* vl, lapack_int* ldvl, double* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    double* lscale, double* rscale, double* abnrm,
+                    double* bbnrm, double* rconde, double* rcondv, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_cggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* vl, lapack_int* ldvl,
+                    lapack_complex_float* vr, lapack_int* ldvr, lapack_int* ilo,
+                    lapack_int* ihi, float* lscale, float* rscale, float* abnrm,
+                    float* bbnrm, float* rconde, float* rcondv,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* iwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_zggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* vl, lapack_int* ldvl,
+                    lapack_complex_double* vr, lapack_int* ldvr,
+                    lapack_int* ilo, lapack_int* ihi, double* lscale,
+                    double* rscale, double* abnrm, double* bbnrm,
+                    double* rconde, double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_logical* bwork, lapack_int *info );
+void LAPACK_dsfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, double* alpha, const double* a,
+                   lapack_int* lda, double* beta, double* c );
+void LAPACK_ssfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, float* alpha, const float* a, lapack_int* lda,
+                   float* beta, float* c );
+void LAPACK_zhfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, double* alpha, const lapack_complex_double* a,
+                   lapack_int* lda, double* beta, lapack_complex_double* c );
+void LAPACK_chfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, float* alpha, const lapack_complex_float* a,
+                   lapack_int* lda, float* beta, lapack_complex_float* c );
+void LAPACK_dtfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n, double* alpha,
+                   const double* a, double* b, lapack_int* ldb );
+void LAPACK_stfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n, float* alpha,
+                   const float* a, float* b, lapack_int* ldb );
+void LAPACK_ztfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n,
+                   lapack_complex_double* alpha, const lapack_complex_double* a,
+                   lapack_complex_double* b, lapack_int* ldb );
+void LAPACK_ctfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n,
+                   lapack_complex_float* alpha, const lapack_complex_float* a,
+                   lapack_complex_float* b, lapack_int* ldb );
+void LAPACK_dtfttp( char* transr, char* uplo, lapack_int* n, const double* arf,
+                    double* ap, lapack_int *info );
+void LAPACK_stfttp( char* transr, char* uplo, lapack_int* n, const float* arf,
+                    float* ap, lapack_int *info );
+void LAPACK_ztfttp( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* arf, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_ctfttp( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* arf, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_dtfttr( char* transr, char* uplo, lapack_int* n, const double* arf,
+                    double* a, lapack_int* lda, lapack_int *info );
+void LAPACK_stfttr( char* transr, char* uplo, lapack_int* n, const float* arf,
+                    float* a, lapack_int* lda, lapack_int *info );
+void LAPACK_ztfttr( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* arf, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_ctfttr( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* arf, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dtpttf( char* transr, char* uplo, lapack_int* n, const double* ap,
+                    double* arf, lapack_int *info );
+void LAPACK_stpttf( char* transr, char* uplo, lapack_int* n, const float* ap,
+                    float* arf, lapack_int *info );
+void LAPACK_ztpttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* ap, lapack_complex_double* arf,
+                    lapack_int *info );
+void LAPACK_ctpttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* ap, lapack_complex_float* arf,
+                    lapack_int *info );
+void LAPACK_dtpttr( char* uplo, lapack_int* n, const double* ap, double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_stpttr( char* uplo, lapack_int* n, const float* ap, float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_ztpttr( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_ctpttr( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dtrttf( char* transr, char* uplo, lapack_int* n, const double* a,
+                    lapack_int* lda, double* arf, lapack_int *info );
+void LAPACK_strttf( char* transr, char* uplo, lapack_int* n, const float* a,
+                    lapack_int* lda, float* arf, lapack_int *info );
+void LAPACK_ztrttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* arf, lapack_int *info );
+void LAPACK_ctrttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* arf, lapack_int *info );
+void LAPACK_dtrttp( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
+                    double* ap, lapack_int *info );
+void LAPACK_strttp( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                    float* ap, lapack_int *info );
+void LAPACK_ztrttp( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_ctrttp( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_sgeqrfp( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* tau, float* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_dgeqrfp( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* tau, double* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_cgeqrfp( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* tau,
+                     lapack_complex_float* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_zgeqrfp( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* tau,
+                     lapack_complex_double* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_clacgv( lapack_int* n, lapack_complex_float* x, lapack_int* incx );
+void LAPACK_zlacgv( lapack_int* n, lapack_complex_double* x, lapack_int* incx );
+void LAPACK_slarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    float* x );
+void LAPACK_dlarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    double* x );
+void LAPACK_clarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    lapack_complex_float* x );
+void LAPACK_zlarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    lapack_complex_double* x );
+void LAPACK_sgeqr2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int *info );
+void LAPACK_dgeqr2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int *info );
+void LAPACK_cgeqr2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgeqr2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slacpy( char* uplo, lapack_int* m, lapack_int* n, const float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb );
+void LAPACK_dlacpy( char* uplo, lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb );
+void LAPACK_clacpy( char* uplo, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb );
+void LAPACK_zlacpy( char* uplo, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb );
+void LAPACK_sgetf2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgetf2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgetf2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_zgetf2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_slaswp( lapack_int* n, float* a, lapack_int* lda, lapack_int* k1,
+                    lapack_int* k2, const lapack_int* ipiv, lapack_int* incx );
+void LAPACK_dlaswp( lapack_int* n, double* a, lapack_int* lda, lapack_int* k1,
+                    lapack_int* k2, const lapack_int* ipiv, lapack_int* incx );
+void LAPACK_claswp( lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_int* k1, lapack_int* k2, const lapack_int* ipiv,
+                    lapack_int* incx );
+void LAPACK_zlaswp( lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_int* k1, lapack_int* k2, const lapack_int* ipiv,
+                    lapack_int* incx );
+float LAPACK_slange( char* norm, lapack_int* m, lapack_int* n, const float* a,
+                    lapack_int* lda, float* work );
+double LAPACK_dlange( char* norm, lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, double* work );
+float LAPACK_clange( char* norm, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda, float* work );
+double LAPACK_zlange( char* norm, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* work );
+float LAPACK_clanhe( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda, float* work );
+double LAPACK_zlanhe( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* work );
+float LAPACK_slansy( char* norm, char* uplo, lapack_int* n, const float* a,
+                    lapack_int* lda, float* work );
+double LAPACK_dlansy( char* norm, char* uplo, lapack_int* n, const double* a,
+                    lapack_int* lda, double* work );
+float LAPACK_clansy( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda, float* work );
+double LAPACK_zlansy( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* work );
+float LAPACK_slantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const float* a, lapack_int* lda, float* work );
+double LAPACK_dlantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const double* a, lapack_int* lda, double* work );
+float LAPACK_clantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* a, lapack_int* lda,
+                    float* work );
+double LAPACK_zlantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
+                    double* work );
+float LAPACK_slamch( char* cmach );
+double LAPACK_dlamch( char* cmach );
+void LAPACK_sgelq2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int *info );
+void LAPACK_dgelq2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int *info );
+void LAPACK_cgelq2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgelq2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, const float* v,
+                    lapack_int* ldv, const float* t, lapack_int* ldt, float* c,
+                    lapack_int* ldc, float* work, lapack_int* ldwork );
+void LAPACK_dlarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k,
+                    const double* v, lapack_int* ldv, const double* t,
+                    lapack_int* ldt, double* c, lapack_int* ldc, double* work,
+                    lapack_int* ldwork );
+void LAPACK_clarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k,
+                    const lapack_complex_float* v, lapack_int* ldv,
+                    const lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* ldwork );
+void LAPACK_zlarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k,
+                    const lapack_complex_double* v, lapack_int* ldv,
+                    const lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* ldwork );
+void LAPACK_slarfg( lapack_int* n, float* alpha, float* x, lapack_int* incx,
+                    float* tau );
+void LAPACK_dlarfg( lapack_int* n, double* alpha, double* x, lapack_int* incx,
+                    double* tau );
+void LAPACK_clarfg( lapack_int* n, lapack_complex_float* alpha,
+                    lapack_complex_float* x, lapack_int* incx,
+                    lapack_complex_float* tau );
+void LAPACK_zlarfg( lapack_int* n, lapack_complex_double* alpha,
+                    lapack_complex_double* x, lapack_int* incx,
+                    lapack_complex_double* tau );
+void LAPACK_slarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const float* v, lapack_int* ldv, const float* tau, float* t,
+                    lapack_int* ldt );
+void LAPACK_dlarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const double* v, lapack_int* ldv, const double* tau,
+                    double* t, lapack_int* ldt );
+void LAPACK_clarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const lapack_complex_float* v, lapack_int* ldv,
+                    const lapack_complex_float* tau, lapack_complex_float* t,
+                    lapack_int* ldt );
+void LAPACK_zlarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const lapack_complex_double* v, lapack_int* ldv,
+                    const lapack_complex_double* tau, lapack_complex_double* t,
+                    lapack_int* ldt );
+void LAPACK_slarfx( char* side, lapack_int* m, lapack_int* n, const float* v,
+                    float* tau, float* c, lapack_int* ldc, float* work );
+void LAPACK_dlarfx( char* side, lapack_int* m, lapack_int* n, const double* v,
+                    double* tau, double* c, lapack_int* ldc, double* work );
+void LAPACK_clarfx( char* side, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* v, lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work );
+void LAPACK_zlarfx( char* side, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* v, lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work );
+void LAPACK_slatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, float* d, lapack_int* mode, float* cond,
+                    float* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    float* a, lapack_int* lda, float* work, lapack_int *info );
+void LAPACK_dlatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, double* d, lapack_int* mode, double* cond,
+                    double* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    double* a, lapack_int* lda, double* work,
+                    lapack_int *info );
+void LAPACK_clatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, float* d, lapack_int* mode, float* cond,
+                    float* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, double* d, lapack_int* mode, double* cond,
+                    double* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slag2d( lapack_int* m, lapack_int* n, const float* sa,
+                    lapack_int* ldsa, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dlag2s( lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, float* sa, lapack_int* ldsa,
+                    lapack_int *info );
+void LAPACK_clag2z( lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* sa, lapack_int* ldsa,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_zlag2c( lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_float* sa, lapack_int* ldsa,
+                    lapack_int *info );
+void LAPACK_slauum( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dlauum( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_clauum( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_zlauum( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_slagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const float* d, float* a, lapack_int* lda,
+                    lapack_int* iseed, float* work, lapack_int *info );
+void LAPACK_dlagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const double* d, double* a, lapack_int* lda,
+                    lapack_int* iseed, double* work, lapack_int *info );
+void LAPACK_clagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const float* d, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const double* d, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slaset( char* uplo, lapack_int* m, lapack_int* n, float* alpha,
+                    float* beta, float* a, lapack_int* lda );
+void LAPACK_dlaset( char* uplo, lapack_int* m, lapack_int* n, double* alpha,
+                    double* beta, double* a, lapack_int* lda );
+void LAPACK_claset( char* uplo, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* a, lapack_int* lda );
+void LAPACK_zlaset( char* uplo, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* a, lapack_int* lda );
+void LAPACK_slasrt( char* id, lapack_int* n, float* d, lapack_int *info );
+void LAPACK_dlasrt( char* id, lapack_int* n, double* d, lapack_int *info );
+void LAPACK_claghe( lapack_int* n, lapack_int* k, const float* d,
+                    lapack_complex_float* a, lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlaghe( lapack_int* n, lapack_int* k, const double* d,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int* iseed, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_slagsy( lapack_int* n, lapack_int* k, const float* d, float* a,
+                    lapack_int* lda, lapack_int* iseed, float* work,
+                    lapack_int *info );
+void LAPACK_dlagsy( lapack_int* n, lapack_int* k, const double* d, double* a,
+                    lapack_int* lda, lapack_int* iseed, double* work,
+                    lapack_int *info );
+void LAPACK_clagsy( lapack_int* n, lapack_int* k, const float* d,
+                    lapack_complex_float* a, lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlagsy( lapack_int* n, lapack_int* k, const double* d,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int* iseed, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_slapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    float* x, lapack_int* ldx, lapack_int* k );
+void LAPACK_dlapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    double* x, lapack_int* ldx, lapack_int* k );
+void LAPACK_clapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* x, lapack_int* ldx, lapack_int* k );
+void LAPACK_zlapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* x, lapack_int* ldx, lapack_int* k );
+float LAPACK_slapy2( float* x, float* y );
+double LAPACK_dlapy2( double* x, double* y );
+float LAPACK_slapy3( float* x, float* y, float* z );
+double LAPACK_dlapy3( double* x, double* y, double* z );
+void LAPACK_slartgp( float* f, float* g, float* cs, float* sn, float* r );
+void LAPACK_dlartgp( double* f, double* g, double* cs, double* sn, double* r );
+void LAPACK_slartgs( float* x, float* y, float* sigma, float* cs, float* sn );
+void LAPACK_dlartgs( double* x, double* y, double* sigma, double* cs,
+                     double* sn );
+// LAPACK 3.3.0
+void LAPACK_cbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    float* theta, float* phi,
+                    lapack_complex_float* u1, lapack_int* ldu1,
+                    lapack_complex_float* u2, lapack_int* ldu2,
+                    lapack_complex_float* v1t, lapack_int* ldv1t,
+                    lapack_complex_float* v2t, lapack_int* ldv2t,
+                    float* b11d, float* b11e, float* b12d,
+                    float* b12e, float* b21d, float* b21e,
+                    float* b22d, float* b22e, float* rwork,
+                    lapack_int* lrwork , lapack_int *info );
+void LAPACK_cheswapr( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_chetri2( char* uplo, lapack_int* n,
+                     lapack_complex_float* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_chetri2x( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_float* work, lapack_int* nb , lapack_int *info );
+void LAPACK_chetrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const lapack_complex_float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* work , lapack_int *info );
+void LAPACK_csyconv( char* uplo, char* way,
+                     lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_float* work , lapack_int *info );
+void LAPACK_csyswapr( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_csytri2( char* uplo, lapack_int* n,
+                     lapack_complex_float* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_csytri2x( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_float* work, lapack_int* nb , lapack_int *info );
+void LAPACK_csytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const lapack_complex_float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* work , lapack_int *info );
+void LAPACK_cunbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    lapack_complex_float* x11, lapack_int* ldx11,
+                    lapack_complex_float* x12, lapack_int* ldx12,
+                    lapack_complex_float* x21, lapack_int* ldx21,
+                    lapack_complex_float* x22, lapack_int* ldx22,
+                    float* theta, float* phi,
+                    lapack_complex_float* taup1,
+                    lapack_complex_float* taup2,
+                    lapack_complex_float* tauq1,
+                    lapack_complex_float* tauq2,
+                    lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_cuncsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, lapack_complex_float* x11,
+                    lapack_int* ldx11, lapack_complex_float* x12,
+                    lapack_int* ldx12, lapack_complex_float* x21,
+                    lapack_int* ldx21, lapack_complex_float* x22,
+                    lapack_int* ldx22, float* theta,
+                    lapack_complex_float* u1, lapack_int* ldu1,
+                    lapack_complex_float* u2, lapack_int* ldu2,
+                    lapack_complex_float* v1t, lapack_int* ldv1t,
+                    lapack_complex_float* v2t, lapack_int* ldv2t,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    float* rwork, lapack_int* lrwork,
+                    lapack_int* iwork , lapack_int *info );
+void LAPACK_dbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    double* theta, double* phi, double* u1,
+                    lapack_int* ldu1, double* u2, lapack_int* ldu2,
+                    double* v1t, lapack_int* ldv1t, double* v2t,
+                    lapack_int* ldv2t, double* b11d, double* b11e,
+                    double* b12d, double* b12e, double* b21d,
+                    double* b21e, double* b22d, double* b22e,
+                    double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_dorbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    double* x11, lapack_int* ldx11, double* x12,
+                    lapack_int* ldx12, double* x21, lapack_int* ldx21,
+                    double* x22, lapack_int* ldx22, double* theta,
+                    double* phi, double* taup1, double* taup2,
+                    double* tauq1, double* tauq2, double* work,
+                    lapack_int* lwork , lapack_int *info );
+void LAPACK_dorcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, double* x11, lapack_int* ldx11,
+                    double* x12, lapack_int* ldx12, double* x21,
+                    lapack_int* ldx21, double* x22, lapack_int* ldx22,
+                    double* theta, double* u1, lapack_int* ldu1,
+                    double* u2, lapack_int* ldu2, double* v1t,
+                    lapack_int* ldv1t, double* v2t, lapack_int* ldv2t,
+                    double* work, lapack_int* lwork,
+                    lapack_int* iwork , lapack_int *info );
+void LAPACK_dsyconv( char* uplo, char* way,
+                     lapack_int* n, double* a, lapack_int* lda,
+                     const lapack_int* ipiv, double* work , lapack_int *info );
+void LAPACK_dsyswapr( char* uplo, lapack_int* n,
+                      double* a, lapack_int* i1, lapack_int* i2 );
+void LAPACK_dsytri2( char* uplo, lapack_int* n,
+                     double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_dsytri2x( char* uplo, lapack_int* n,
+                      double* a, lapack_int* lda,
+                      const lapack_int* ipiv, double* work,
+                      lapack_int* nb , lapack_int *info );
+void LAPACK_dsytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const double* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     double* b, lapack_int* ldb, double* work , lapack_int *info );
+void LAPACK_sbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    float* theta, float* phi, float* u1,
+                    lapack_int* ldu1, float* u2, lapack_int* ldu2,
+                    float* v1t, lapack_int* ldv1t, float* v2t,
+                    lapack_int* ldv2t, float* b11d, float* b11e,
+                    float* b12d, float* b12e, float* b21d,
+                    float* b21e, float* b22d, float* b22e,
+                    float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_sorbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    float* x11, lapack_int* ldx11, float* x12,
+                    lapack_int* ldx12, float* x21, lapack_int* ldx21,
+                    float* x22, lapack_int* ldx22, float* theta,
+                    float* phi, float* taup1, float* taup2,
+                    float* tauq1, float* tauq2, float* work,
+                    lapack_int* lwork , lapack_int *info );
+void LAPACK_sorcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, float* x11, lapack_int* ldx11,
+                    float* x12, lapack_int* ldx12, float* x21,
+                    lapack_int* ldx21, float* x22, lapack_int* ldx22,
+                    float* theta, float* u1, lapack_int* ldu1,
+                    float* u2, lapack_int* ldu2, float* v1t,
+                    lapack_int* ldv1t, float* v2t, lapack_int* ldv2t,
+                    float* work, lapack_int* lwork,
+                    lapack_int* iwork , lapack_int *info );
+void LAPACK_ssyconv( char* uplo, char* way,
+                     lapack_int* n, float* a, lapack_int* lda,
+                     const lapack_int* ipiv, float* work , lapack_int *info );
+void LAPACK_ssyswapr( char* uplo, lapack_int* n,
+                      float* a, lapack_int* i1, lapack_int* i2 );
+void LAPACK_ssytri2( char* uplo, lapack_int* n,
+                     float* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_ssytri2x( char* uplo, lapack_int* n,
+                      float* a, lapack_int* lda,
+                      const lapack_int* ipiv, float* work,
+                      lapack_int* nb , lapack_int *info );
+void LAPACK_ssytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     float* b, lapack_int* ldb, float* work , lapack_int *info );
+void LAPACK_zbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    double* theta, double* phi,
+                    lapack_complex_double* u1, lapack_int* ldu1,
+                    lapack_complex_double* u2, lapack_int* ldu2,
+                    lapack_complex_double* v1t, lapack_int* ldv1t,
+                    lapack_complex_double* v2t, lapack_int* ldv2t,
+                    double* b11d, double* b11e, double* b12d,
+                    double* b12e, double* b21d, double* b21e,
+                    double* b22d, double* b22e, double* rwork,
+                    lapack_int* lrwork , lapack_int *info );
+void LAPACK_zheswapr( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_zhetri2( char* uplo, lapack_int* n,
+                     lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_zhetri2x( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_double* work, lapack_int* nb , lapack_int *info );
+void LAPACK_zhetrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* work , lapack_int *info );
+void LAPACK_zsyconv( char* uplo, char* way,
+                     lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_double* work , lapack_int *info );
+void LAPACK_zsyswapr( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_zsytri2( char* uplo, lapack_int* n,
+                     lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_zsytri2x( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_double* work, lapack_int* nb , lapack_int *info );
+void LAPACK_zsytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* work , lapack_int *info );
+void LAPACK_zunbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    lapack_complex_double* x11, lapack_int* ldx11,
+                    lapack_complex_double* x12, lapack_int* ldx12,
+                    lapack_complex_double* x21, lapack_int* ldx21,
+                    lapack_complex_double* x22, lapack_int* ldx22,
+                    double* theta, double* phi,
+                    lapack_complex_double* taup1,
+                    lapack_complex_double* taup2,
+                    lapack_complex_double* tauq1,
+                    lapack_complex_double* tauq2,
+                    lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_zuncsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, lapack_complex_double* x11,
+                    lapack_int* ldx11, lapack_complex_double* x12,
+                    lapack_int* ldx12, lapack_complex_double* x21,
+                    lapack_int* ldx21, lapack_complex_double* x22,
+                    lapack_int* ldx22, double* theta,
+                    lapack_complex_double* u1, lapack_int* ldu1,
+                    lapack_complex_double* u2, lapack_int* ldu2,
+                    lapack_complex_double* v1t, lapack_int* ldv1t,
+                    lapack_complex_double* v2t, lapack_int* ldv2t,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork,
+                    lapack_int* iwork , lapack_int *info );
+// LAPACK 3.4.0
+void LAPACK_sgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb, const float* v,
+                     lapack_int* ldv, const float* t, lapack_int* ldt, float* c,
+                     lapack_int* ldc, float* work, lapack_int *info );
+void LAPACK_dgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb, const double* v,
+                     lapack_int* ldv, const double* t, lapack_int* ldt,
+                     double* c, lapack_int* ldc, double* work,
+                     lapack_int *info );
+void LAPACK_cgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb,
+                     const lapack_complex_float* v, lapack_int* ldv,
+                     const lapack_complex_float* t, lapack_int* ldt,
+                     lapack_complex_float* c, lapack_int* ldc,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb,
+                     const lapack_complex_double* v, lapack_int* ldv,
+                     const lapack_complex_double* t, lapack_int* ldt,
+                     lapack_complex_double* c, lapack_int* ldc,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_sgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb, float* a,
+                    lapack_int* lda, float* t, lapack_int* ldt, float* work,
+                    lapack_int *info );
+void LAPACK_dgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb, double* a,
+                    lapack_int* lda, double* t, lapack_int* ldt, double* work,
+                    lapack_int *info );
+void LAPACK_cgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_sgeqrt2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_dgeqrt2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_cgeqrt2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_zgeqrt2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_sgeqrt3( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_dgeqrt3( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_cgeqrt3( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_zgeqrt3( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_stpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const float* v, lapack_int* ldv, const float* t,
+                     lapack_int* ldt, float* a, lapack_int* lda, float* b,
+                     lapack_int* ldb, float* work, lapack_int *info );
+void LAPACK_dtpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const double* v, lapack_int* ldv, const double* t,
+                     lapack_int* ldt, double* a, lapack_int* lda, double* b,
+                     lapack_int* ldb, double* work, lapack_int *info );
+void LAPACK_ctpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const lapack_complex_float* v, lapack_int* ldv,
+                     const lapack_complex_float* t, lapack_int* ldt,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_ztpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const lapack_complex_double* v, lapack_int* ldv,
+                     const lapack_complex_double* t, lapack_int* ldt,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_dtpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* t, lapack_int* ldt, double* work,
+                    lapack_int *info );
+void LAPACK_ctpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* t, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int* ldt,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_ztpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_stpqrt2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* b, lapack_int* ldb, float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_dtpqrt2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* b, lapack_int* ldb, double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_ctpqrt2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_ztpqrt2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_stprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const float* v, lapack_int* ldv, const float* t,
+                    lapack_int* ldt, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, const float* mywork,
+                    lapack_int* myldwork );
+void LAPACK_dtprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const double* v, lapack_int* ldv, const double* t,
+                    lapack_int* ldt, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, const double* mywork,
+                    lapack_int* myldwork );
+void LAPACK_ctprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const lapack_complex_float* v, lapack_int* ldv,
+                    const lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    const float* mywork, lapack_int* myldwork );
+void LAPACK_ztprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const lapack_complex_double* v, lapack_int* ldv,
+                    const lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    const double* mywork, lapack_int* myldwork );
+// LAPACK 3.X.X
+void LAPACK_csyr( char* uplo, lapack_int* n, lapack_complex_float* alpha,
+                      const lapack_complex_float* x, lapack_int* incx,
+                      lapack_complex_float* a, lapack_int* lda );
+void LAPACK_zsyr( char* uplo, lapack_int* n, lapack_complex_double* alpha,
+                      const lapack_complex_double* x, lapack_int* incx,
+                      lapack_complex_double* a, lapack_int* lda );
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _LAPACKE_H_ */
+
+#endif /* _MKL_LAPACKE_H_ */
diff --git a/C++/yolo_bytetrack/include/Eigen/src/misc/lapacke_mangling.h b/C++/yolo_bytetrack/include/Eigen/src/misc/lapacke_mangling.h
new file mode 100644
index 00000000..6211fd14
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/misc/lapacke_mangling.h
@@ -0,0 +1,17 @@
+#ifndef LAPACK_HEADER_INCLUDED
+#define LAPACK_HEADER_INCLUDED
+
+#ifndef LAPACK_GLOBAL
+#if defined(LAPACK_GLOBAL_PATTERN_LC) || defined(ADD_)
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname##_
+#elif defined(LAPACK_GLOBAL_PATTERN_UC) || defined(UPPER)
+#define LAPACK_GLOBAL(lcname,UCNAME)  UCNAME
+#elif defined(LAPACK_GLOBAL_PATTERN_MC) || defined(NOCHANGE)
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname
+#else
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname##_
+#endif
+#endif
+
+#endif
+
diff --git a/C++/yolo_bytetrack/include/Eigen/src/plugins/ArrayCwiseBinaryOps.h b/C++/yolo_bytetrack/include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
new file mode 100644
index 00000000..0e5d5445
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
@@ -0,0 +1,358 @@
+
+/** \returns an expression of the coefficient wise product of \c *this and \a other
+  *
+  * \sa MatrixBase::cwiseProduct
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)
+operator*(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient wise quotient of \c *this and \a other
+  *
+  * \sa MatrixBase::cwiseQuotient
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar,typename OtherDerived::Scalar>, const Derived, const OtherDerived>
+operator/(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_quotient_op<Scalar,typename OtherDerived::Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise min of \c *this and \a other
+  *
+  * Example: \include Cwise_min.cpp
+  * Output: \verbinclude Cwise_min.out
+  *
+  * \sa max()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(min,min)
+
+/** \returns an expression of the coefficient-wise min of \c *this and scalar \a other
+  *
+  * \sa max()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived,
+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+min
+#else
+(min)
+#endif
+(const Scalar &other) const
+{
+  return (min)(Derived::PlainObject::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise max of \c *this and \a other
+  *
+  * Example: \include Cwise_max.cpp
+  * Output: \verbinclude Cwise_max.out
+  *
+  * \sa min()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(max,max)
+
+/** \returns an expression of the coefficient-wise max of \c *this and scalar \a other
+  *
+  * \sa min()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived,
+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+max
+#else
+(max)
+#endif
+(const Scalar &other) const
+{
+  return (max)(Derived::PlainObject::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise absdiff of \c *this and \a other
+  *
+  * Example: \include Cwise_absolute_difference.cpp
+  * Output: \verbinclude Cwise_absolute_difference.out
+  *
+  * \sa absolute_difference()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(absolute_difference,absolute_difference)
+
+/** \returns an expression of the coefficient-wise absolute_difference of \c *this and scalar \a other
+  *
+  * \sa absolute_difference()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_absolute_difference_op<Scalar,Scalar>, const Derived,
+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+absolute_difference
+#else
+(absolute_difference)
+#endif
+(const Scalar &other) const
+{
+  return (absolute_difference)(Derived::PlainObject::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise power of \c *this to the given array of \a exponents.
+  *
+  * This function computes the coefficient-wise power.
+  *
+  * Example: \include Cwise_array_power_array.cpp
+  * Output: \verbinclude Cwise_array_power_array.out
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(pow,pow)
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(pow,pow)
+#else
+/** \returns an expression of the coefficients of \c *this rasied to the constant power \a exponent
+  *
+  * \tparam T is the scalar type of \a exponent. It must be compatible with the scalar type of the given expression.
+  *
+  * This function computes the coefficient-wise power. The function MatrixBase::pow() in the
+  * unsupported module MatrixFunctions computes the matrix power.
+  *
+  * Example: \include Cwise_pow.cpp
+  * Output: \verbinclude Cwise_pow.out
+  *
+  * \sa ArrayBase::pow(ArrayBase), square(), cube(), exp(), log()
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_pow_op<Scalar,T>,Derived,Constant<T> > pow(const T& exponent) const;
+#endif
+
+
+// TODO code generating macros could be moved to Macros.h and could include generation of documentation
+#define EIGEN_MAKE_CWISE_COMP_OP(OP, COMPARATOR) \
+template<typename OtherDerived> \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_cmp_op<Scalar, typename OtherDerived::Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const OtherDerived> \
+OP(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
+{ \
+  return CwiseBinaryOp<internal::scalar_cmp_op<Scalar, typename OtherDerived::Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const OtherDerived>(derived(), other.derived()); \
+}\
+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> > Cmp ## COMPARATOR ## ReturnType; \
+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar, internal::cmp_ ## COMPARATOR>, const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject>, const Derived > RCmp ## COMPARATOR ## ReturnType; \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Cmp ## COMPARATOR ## ReturnType \
+OP(const Scalar& s) const { \
+  return this->OP(Derived::PlainObject::Constant(rows(), cols(), s)); \
+} \
+EIGEN_DEVICE_FUNC friend EIGEN_STRONG_INLINE const RCmp ## COMPARATOR ## ReturnType \
+OP(const Scalar& s, const EIGEN_CURRENT_STORAGE_BASE_CLASS<Derived>& d) { \
+  return Derived::PlainObject::Constant(d.rows(), d.cols(), s).OP(d); \
+}
+
+#define EIGEN_MAKE_CWISE_COMP_R_OP(OP, R_OP, RCOMPARATOR) \
+template<typename OtherDerived> \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_cmp_op<typename OtherDerived::Scalar, Scalar, internal::cmp_##RCOMPARATOR>, const OtherDerived, const Derived> \
+OP(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
+{ \
+  return CwiseBinaryOp<internal::scalar_cmp_op<typename OtherDerived::Scalar, Scalar, internal::cmp_##RCOMPARATOR>, const OtherDerived, const Derived>(other.derived(), derived()); \
+} \
+EIGEN_DEVICE_FUNC \
+inline const RCmp ## RCOMPARATOR ## ReturnType \
+OP(const Scalar& s) const { \
+  return Derived::PlainObject::Constant(rows(), cols(), s).R_OP(*this); \
+} \
+friend inline const Cmp ## RCOMPARATOR ## ReturnType \
+OP(const Scalar& s, const Derived& d) { \
+  return d.R_OP(Derived::PlainObject::Constant(d.rows(), d.cols(), s)); \
+}
+
+
+
+/** \returns an expression of the coefficient-wise \< operator of *this and \a other
+  *
+  * Example: \include Cwise_less.cpp
+  * Output: \verbinclude Cwise_less.out
+  *
+  * \sa all(), any(), operator>(), operator<=()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator<, LT)
+
+/** \returns an expression of the coefficient-wise \<= operator of *this and \a other
+  *
+  * Example: \include Cwise_less_equal.cpp
+  * Output: \verbinclude Cwise_less_equal.out
+  *
+  * \sa all(), any(), operator>=(), operator<()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator<=, LE)
+
+/** \returns an expression of the coefficient-wise \> operator of *this and \a other
+  *
+  * Example: \include Cwise_greater.cpp
+  * Output: \verbinclude Cwise_greater.out
+  *
+  * \sa all(), any(), operator>=(), operator<()
+  */
+EIGEN_MAKE_CWISE_COMP_R_OP(operator>, operator<, LT)
+
+/** \returns an expression of the coefficient-wise \>= operator of *this and \a other
+  *
+  * Example: \include Cwise_greater_equal.cpp
+  * Output: \verbinclude Cwise_greater_equal.out
+  *
+  * \sa all(), any(), operator>(), operator<=()
+  */
+EIGEN_MAKE_CWISE_COMP_R_OP(operator>=, operator<=, LE)
+
+/** \returns an expression of the coefficient-wise == operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include Cwise_equal_equal.cpp
+  * Output: \verbinclude Cwise_equal_equal.out
+  *
+  * \sa all(), any(), isApprox(), isMuchSmallerThan()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator==, EQ)
+
+/** \returns an expression of the coefficient-wise != operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include Cwise_not_equal.cpp
+  * Output: \verbinclude Cwise_not_equal.out
+  *
+  * \sa all(), any(), isApprox(), isMuchSmallerThan()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator!=, NEQ)
+
+
+#undef EIGEN_MAKE_CWISE_COMP_OP
+#undef EIGEN_MAKE_CWISE_COMP_R_OP
+
+// scalar addition
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP(operator+,sum)
+#else
+/** \returns an expression of \c *this with each coeff incremented by the constant \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  *
+  * Example: \include Cwise_plus.cpp
+  * Output: \verbinclude Cwise_plus.out
+  *
+  * \sa operator+=(), operator-()
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_sum_op<Scalar,T>,Derived,Constant<T> > operator+(const T& scalar) const;
+/** \returns an expression of \a expr with each coeff incremented by the constant \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T> friend
+const CwiseBinaryOp<internal::scalar_sum_op<T,Scalar>,Constant<T>,Derived> operator+(const T& scalar, const StorageBaseType& expr);
+#endif
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP(operator-,difference)
+#else
+/** \returns an expression of \c *this with each coeff decremented by the constant \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  *
+  * Example: \include Cwise_minus.cpp
+  * Output: \verbinclude Cwise_minus.out
+  *
+  * \sa operator+=(), operator-()
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_difference_op<Scalar,T>,Derived,Constant<T> > operator-(const T& scalar) const;
+/** \returns an expression of the constant matrix of value \a scalar decremented by the coefficients of \a expr
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T> friend
+const CwiseBinaryOp<internal::scalar_difference_op<T,Scalar>,Constant<T>,Derived> operator-(const T& scalar, const StorageBaseType& expr);
+#endif
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(operator/,quotient)
+#else
+  /**
+    * \brief Component-wise division of the scalar \a s by array elements of \a a.
+    *
+    * \tparam Scalar is the scalar type of \a x. It must be compatible with the scalar type of the given array expression (\c Derived::Scalar).
+    */
+  template<typename T> friend
+  inline const CwiseBinaryOp<internal::scalar_quotient_op<T,Scalar>,Constant<T>,Derived>
+  operator/(const T& s,const StorageBaseType& a);
+#endif
+
+/** \returns an expression of the coefficient-wise ^ operator of *this and \a other
+ *
+ * \warning this operator is for expression of bool only.
+ *
+ * Example: \include Cwise_boolean_xor.cpp
+ * Output: \verbinclude Cwise_boolean_xor.out
+ *
+ * \sa operator&&(), select()
+ */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<internal::scalar_boolean_xor_op, const Derived, const OtherDerived>
+operator^(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return CwiseBinaryOp<internal::scalar_boolean_xor_op, const Derived, const OtherDerived>(derived(),other.derived());
+}
+
+// NOTE disabled until we agree on argument order
+#if 0
+/** \cpp11 \returns an expression of the coefficient-wise polygamma function.
+  *
+  * \specialfunctions_module
+  *
+  * It returns the \a n -th derivative of the digamma(psi) evaluated at \c *this.
+  *
+  * \warning Be careful with the order of the parameters: x.polygamma(n) is equivalent to polygamma(n,x)
+  *
+  * \sa Eigen::polygamma()
+  */
+template<typename DerivedN>
+inline const CwiseBinaryOp<internal::scalar_polygamma_op<Scalar>, const DerivedN, const Derived>
+polygamma(const EIGEN_CURRENT_STORAGE_BASE_CLASS<DerivedN> &n) const
+{
+  return CwiseBinaryOp<internal::scalar_polygamma_op<Scalar>, const DerivedN, const Derived>(n.derived(), this->derived());
+}
+#endif
+
+/** \returns an expression of the coefficient-wise zeta function.
+  *
+  * \specialfunctions_module
+  *
+  * It returns the Riemann zeta function of two arguments \c *this and \a q:
+  *
+  * \param q is the shift, it must be > 0
+  *
+  * \note *this is the exponent, it must be > 1.
+  * \note This function supports only float and double scalar types. To support other scalar types, the user has
+  * to provide implementations of zeta(T,T) for any scalar type T to be supported.
+  *
+  * This method is an alias for zeta(*this,q);
+  *
+  * \sa Eigen::zeta()
+  */
+template<typename DerivedQ>
+inline const CwiseBinaryOp<internal::scalar_zeta_op<Scalar>, const Derived, const DerivedQ>
+zeta(const EIGEN_CURRENT_STORAGE_BASE_CLASS<DerivedQ> &q) const
+{
+  return CwiseBinaryOp<internal::scalar_zeta_op<Scalar>, const Derived, const DerivedQ>(this->derived(), q.derived());
+}
diff --git a/C++/yolo_bytetrack/include/Eigen/src/plugins/ArrayCwiseUnaryOps.h b/C++/yolo_bytetrack/include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
new file mode 100644
index 00000000..13c55f4b
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
@@ -0,0 +1,696 @@
+
+
+typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> AbsReturnType;
+typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> ArgReturnType;
+typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> Abs2ReturnType;
+typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> SqrtReturnType;
+typedef CwiseUnaryOp<internal::scalar_rsqrt_op<Scalar>, const Derived> RsqrtReturnType;
+typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> SignReturnType;
+typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> InverseReturnType;
+typedef CwiseUnaryOp<internal::scalar_boolean_not_op<Scalar>, const Derived> BooleanNotReturnType;
+
+typedef CwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived> ExpReturnType;
+typedef CwiseUnaryOp<internal::scalar_expm1_op<Scalar>, const Derived> Expm1ReturnType;
+typedef CwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived> LogReturnType;
+typedef CwiseUnaryOp<internal::scalar_log1p_op<Scalar>, const Derived> Log1pReturnType;
+typedef CwiseUnaryOp<internal::scalar_log10_op<Scalar>, const Derived> Log10ReturnType;
+typedef CwiseUnaryOp<internal::scalar_log2_op<Scalar>, const Derived> Log2ReturnType;
+typedef CwiseUnaryOp<internal::scalar_cos_op<Scalar>, const Derived> CosReturnType;
+typedef CwiseUnaryOp<internal::scalar_sin_op<Scalar>, const Derived> SinReturnType;
+typedef CwiseUnaryOp<internal::scalar_tan_op<Scalar>, const Derived> TanReturnType;
+typedef CwiseUnaryOp<internal::scalar_acos_op<Scalar>, const Derived> AcosReturnType;
+typedef CwiseUnaryOp<internal::scalar_asin_op<Scalar>, const Derived> AsinReturnType;
+typedef CwiseUnaryOp<internal::scalar_atan_op<Scalar>, const Derived> AtanReturnType;
+typedef CwiseUnaryOp<internal::scalar_tanh_op<Scalar>, const Derived> TanhReturnType;
+typedef CwiseUnaryOp<internal::scalar_logistic_op<Scalar>, const Derived> LogisticReturnType;
+typedef CwiseUnaryOp<internal::scalar_sinh_op<Scalar>, const Derived> SinhReturnType;
+#if EIGEN_HAS_CXX11_MATH
+typedef CwiseUnaryOp<internal::scalar_atanh_op<Scalar>, const Derived> AtanhReturnType;
+typedef CwiseUnaryOp<internal::scalar_asinh_op<Scalar>, const Derived> AsinhReturnType;
+typedef CwiseUnaryOp<internal::scalar_acosh_op<Scalar>, const Derived> AcoshReturnType;
+#endif
+typedef CwiseUnaryOp<internal::scalar_cosh_op<Scalar>, const Derived> CoshReturnType;
+typedef CwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived> SquareReturnType;
+typedef CwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived> CubeReturnType;
+typedef CwiseUnaryOp<internal::scalar_round_op<Scalar>, const Derived> RoundReturnType;
+typedef CwiseUnaryOp<internal::scalar_rint_op<Scalar>, const Derived> RintReturnType;
+typedef CwiseUnaryOp<internal::scalar_floor_op<Scalar>, const Derived> FloorReturnType;
+typedef CwiseUnaryOp<internal::scalar_ceil_op<Scalar>, const Derived> CeilReturnType;
+typedef CwiseUnaryOp<internal::scalar_isnan_op<Scalar>, const Derived> IsNaNReturnType;
+typedef CwiseUnaryOp<internal::scalar_isinf_op<Scalar>, const Derived> IsInfReturnType;
+typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar>, const Derived> IsFiniteReturnType;
+
+/** \returns an expression of the coefficient-wise absolute value of \c *this
+  *
+  * Example: \include Cwise_abs.cpp
+  * Output: \verbinclude Cwise_abs.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs">Math functions</a>, abs2()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const AbsReturnType
+abs() const
+{
+  return AbsReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise phase angle of \c *this
+  *
+  * Example: \include Cwise_arg.cpp
+  * Output: \verbinclude Cwise_arg.out
+  *
+  * \sa abs()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const ArgReturnType
+arg() const
+{
+  return ArgReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise squared absolute value of \c *this
+  *
+  * Example: \include Cwise_abs2.cpp
+  * Output: \verbinclude Cwise_abs2.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs2">Math functions</a>, abs(), square()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const Abs2ReturnType
+abs2() const
+{
+  return Abs2ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise exponential of *this.
+  *
+  * This function computes the coefficient-wise exponential. The function MatrixBase::exp() in the
+  * unsupported module MatrixFunctions computes the matrix exponential.
+  *
+  * Example: \include Cwise_exp.cpp
+  * Output: \verbinclude Cwise_exp.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_exp">Math functions</a>, pow(), log(), sin(), cos()
+  */
+EIGEN_DEVICE_FUNC
+inline const ExpReturnType
+exp() const
+{
+  return ExpReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise exponential of *this minus 1.
+  *
+  * In exact arithmetic, \c x.expm1() is equivalent to \c x.exp() - 1,
+  * however, with finite precision, this function is much more accurate when \c x is close to zero.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_expm1">Math functions</a>, exp()
+  */
+EIGEN_DEVICE_FUNC
+inline const Expm1ReturnType
+expm1() const
+{
+  return Expm1ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise logarithm of *this.
+  *
+  * This function computes the coefficient-wise logarithm. The function MatrixBase::log() in the
+  * unsupported module MatrixFunctions computes the matrix logarithm.
+  *
+  * Example: \include Cwise_log.cpp
+  * Output: \verbinclude Cwise_log.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log">Math functions</a>, log()
+  */
+EIGEN_DEVICE_FUNC
+inline const LogReturnType
+log() const
+{
+  return LogReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise logarithm of 1 plus \c *this.
+  *
+  * In exact arithmetic, \c x.log() is equivalent to \c (x+1).log(),
+  * however, with finite precision, this function is much more accurate when \c x is close to zero.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log1p">Math functions</a>, log()
+  */
+EIGEN_DEVICE_FUNC
+inline const Log1pReturnType
+log1p() const
+{
+  return Log1pReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise base-10 logarithm of *this.
+  *
+  * This function computes the coefficient-wise base-10 logarithm.
+  *
+  * Example: \include Cwise_log10.cpp
+  * Output: \verbinclude Cwise_log10.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log10">Math functions</a>, log()
+  */
+EIGEN_DEVICE_FUNC
+inline const Log10ReturnType
+log10() const
+{
+  return Log10ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise base-2 logarithm of *this.
+  *
+  * This function computes the coefficient-wise base-2 logarithm.
+  *
+  */
+EIGEN_DEVICE_FUNC
+inline const Log2ReturnType
+log2() const
+{
+  return Log2ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise square root of *this.
+  *
+  * This function computes the coefficient-wise square root. The function MatrixBase::sqrt() in the
+  * unsupported module MatrixFunctions computes the matrix square root.
+  *
+  * Example: \include Cwise_sqrt.cpp
+  * Output: \verbinclude Cwise_sqrt.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sqrt">Math functions</a>, pow(), square()
+  */
+EIGEN_DEVICE_FUNC
+inline const SqrtReturnType
+sqrt() const
+{
+  return SqrtReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse square root of *this.
+  *
+  * This function computes the coefficient-wise inverse square root.
+  *
+  * Example: \include Cwise_sqrt.cpp
+  * Output: \verbinclude Cwise_sqrt.out
+  *
+  * \sa pow(), square()
+  */
+EIGEN_DEVICE_FUNC
+inline const RsqrtReturnType
+rsqrt() const
+{
+  return RsqrtReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise signum of *this.
+  *
+  * This function computes the coefficient-wise signum.
+  *
+  * Example: \include Cwise_sign.cpp
+  * Output: \verbinclude Cwise_sign.out
+  *
+  * \sa pow(), square()
+  */
+EIGEN_DEVICE_FUNC
+inline const SignReturnType
+sign() const
+{
+  return SignReturnType(derived());
+}
+
+
+/** \returns an expression of the coefficient-wise cosine of *this.
+  *
+  * This function computes the coefficient-wise cosine. The function MatrixBase::cos() in the
+  * unsupported module MatrixFunctions computes the matrix cosine.
+  *
+  * Example: \include Cwise_cos.cpp
+  * Output: \verbinclude Cwise_cos.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cos">Math functions</a>, sin(), acos()
+  */
+EIGEN_DEVICE_FUNC
+inline const CosReturnType
+cos() const
+{
+  return CosReturnType(derived());
+}
+
+
+/** \returns an expression of the coefficient-wise sine of *this.
+  *
+  * This function computes the coefficient-wise sine. The function MatrixBase::sin() in the
+  * unsupported module MatrixFunctions computes the matrix sine.
+  *
+  * Example: \include Cwise_sin.cpp
+  * Output: \verbinclude Cwise_sin.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sin">Math functions</a>, cos(), asin()
+  */
+EIGEN_DEVICE_FUNC
+inline const SinReturnType
+sin() const
+{
+  return SinReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise tan of *this.
+  *
+  * Example: \include Cwise_tan.cpp
+  * Output: \verbinclude Cwise_tan.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tan">Math functions</a>, cos(), sin()
+  */
+EIGEN_DEVICE_FUNC
+inline const TanReturnType
+tan() const
+{
+  return TanReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise arc tan of *this.
+  *
+  * Example: \include Cwise_atan.cpp
+  * Output: \verbinclude Cwise_atan.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atan">Math functions</a>, tan(), asin(), acos()
+  */
+EIGEN_DEVICE_FUNC
+inline const AtanReturnType
+atan() const
+{
+  return AtanReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise arc cosine of *this.
+  *
+  * Example: \include Cwise_acos.cpp
+  * Output: \verbinclude Cwise_acos.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acos">Math functions</a>, cos(), asin()
+  */
+EIGEN_DEVICE_FUNC
+inline const AcosReturnType
+acos() const
+{
+  return AcosReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise arc sine of *this.
+  *
+  * Example: \include Cwise_asin.cpp
+  * Output: \verbinclude Cwise_asin.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asin">Math functions</a>, sin(), acos()
+  */
+EIGEN_DEVICE_FUNC
+inline const AsinReturnType
+asin() const
+{
+  return AsinReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise hyperbolic tan of *this.
+  *
+  * Example: \include Cwise_tanh.cpp
+  * Output: \verbinclude Cwise_tanh.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tanh">Math functions</a>, tan(), sinh(), cosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const TanhReturnType
+tanh() const
+{
+  return TanhReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise hyperbolic sin of *this.
+  *
+  * Example: \include Cwise_sinh.cpp
+  * Output: \verbinclude Cwise_sinh.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sinh">Math functions</a>, sin(), tanh(), cosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const SinhReturnType
+sinh() const
+{
+  return SinhReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise hyperbolic cos of *this.
+  *
+  * Example: \include Cwise_cosh.cpp
+  * Output: \verbinclude Cwise_cosh.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cosh">Math functions</a>, tanh(), sinh(), cosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const CoshReturnType
+cosh() const
+{
+  return CoshReturnType(derived());
+}
+
+#if EIGEN_HAS_CXX11_MATH
+/** \returns an expression of the coefficient-wise inverse hyperbolic tan of *this.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atanh">Math functions</a>, atanh(), asinh(), acosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const AtanhReturnType
+atanh() const
+{
+  return AtanhReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse hyperbolic sin of *this.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asinh">Math functions</a>, atanh(), asinh(), acosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const AsinhReturnType
+asinh() const
+{
+  return AsinhReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse hyperbolic cos of *this.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acosh">Math functions</a>, atanh(), asinh(), acosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const AcoshReturnType
+acosh() const
+{
+  return AcoshReturnType(derived());
+}
+#endif
+
+/** \returns an expression of the coefficient-wise logistic of *this.
+  */
+EIGEN_DEVICE_FUNC
+inline const LogisticReturnType
+logistic() const
+{
+  return LogisticReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse of *this.
+  *
+  * Example: \include Cwise_inverse.cpp
+  * Output: \verbinclude Cwise_inverse.out
+  *
+  * \sa operator/(), operator*()
+  */
+EIGEN_DEVICE_FUNC
+inline const InverseReturnType
+inverse() const
+{
+  return InverseReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise square of *this.
+  *
+  * Example: \include Cwise_square.cpp
+  * Output: \verbinclude Cwise_square.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_squareE">Math functions</a>, abs2(), cube(), pow()
+  */
+EIGEN_DEVICE_FUNC
+inline const SquareReturnType
+square() const
+{
+  return SquareReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise cube of *this.
+  *
+  * Example: \include Cwise_cube.cpp
+  * Output: \verbinclude Cwise_cube.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cube">Math functions</a>, square(), pow()
+  */
+EIGEN_DEVICE_FUNC
+inline const CubeReturnType
+cube() const
+{
+  return CubeReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise rint of *this.
+  *
+  * Example: \include Cwise_rint.cpp
+  * Output: \verbinclude Cwise_rint.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_rint">Math functions</a>, ceil(), floor()
+  */
+EIGEN_DEVICE_FUNC
+inline const RintReturnType
+rint() const
+{
+  return RintReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise round of *this.
+  *
+  * Example: \include Cwise_round.cpp
+  * Output: \verbinclude Cwise_round.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_round">Math functions</a>, ceil(), floor()
+  */
+EIGEN_DEVICE_FUNC
+inline const RoundReturnType
+round() const
+{
+  return RoundReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise floor of *this.
+  *
+  * Example: \include Cwise_floor.cpp
+  * Output: \verbinclude Cwise_floor.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_floor">Math functions</a>, ceil(), round()
+  */
+EIGEN_DEVICE_FUNC
+inline const FloorReturnType
+floor() const
+{
+  return FloorReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise ceil of *this.
+  *
+  * Example: \include Cwise_ceil.cpp
+  * Output: \verbinclude Cwise_ceil.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ceil">Math functions</a>, floor(), round()
+  */
+EIGEN_DEVICE_FUNC
+inline const CeilReturnType
+ceil() const
+{
+  return CeilReturnType(derived());
+}
+
+template<int N> struct ShiftRightXpr {
+  typedef CwiseUnaryOp<internal::scalar_shift_right_op<Scalar, N>, const Derived> Type;
+};
+
+/** \returns an expression of \c *this with the \a Scalar type arithmetically
+  * shifted right by \a N bit positions.
+  *
+  * The template parameter \a N specifies the number of bit positions to shift.
+  * 
+  * \sa shiftLeft()
+  */
+template<int N>
+EIGEN_DEVICE_FUNC
+typename ShiftRightXpr<N>::Type
+shiftRight() const
+{
+  return typename ShiftRightXpr<N>::Type(derived());
+}
+
+
+template<int N> struct ShiftLeftXpr {
+  typedef CwiseUnaryOp<internal::scalar_shift_left_op<Scalar, N>, const Derived> Type;
+};
+
+/** \returns an expression of \c *this with the \a Scalar type logically
+  * shifted left by \a N bit positions.
+  *
+  * The template parameter \a N specifies the number of bit positions to shift.
+  *
+  * \sa shiftRight()
+  */
+template<int N>
+EIGEN_DEVICE_FUNC
+typename ShiftLeftXpr<N>::Type
+shiftLeft() const
+{
+  return typename ShiftLeftXpr<N>::Type(derived());
+}
+
+/** \returns an expression of the coefficient-wise isnan of *this.
+  *
+  * Example: \include Cwise_isNaN.cpp
+  * Output: \verbinclude Cwise_isNaN.out
+  *
+  * \sa isfinite(), isinf()
+  */
+EIGEN_DEVICE_FUNC
+inline const IsNaNReturnType
+isNaN() const
+{
+  return IsNaNReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise isinf of *this.
+  *
+  * Example: \include Cwise_isInf.cpp
+  * Output: \verbinclude Cwise_isInf.out
+  *
+  * \sa isnan(), isfinite()
+  */
+EIGEN_DEVICE_FUNC
+inline const IsInfReturnType
+isInf() const
+{
+  return IsInfReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise isfinite of *this.
+  *
+  * Example: \include Cwise_isFinite.cpp
+  * Output: \verbinclude Cwise_isFinite.out
+  *
+  * \sa isnan(), isinf()
+  */
+EIGEN_DEVICE_FUNC
+inline const IsFiniteReturnType
+isFinite() const
+{
+  return IsFiniteReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise ! operator of *this
+  *
+  * \warning this operator is for expression of bool only.
+  *
+  * Example: \include Cwise_boolean_not.cpp
+  * Output: \verbinclude Cwise_boolean_not.out
+  *
+  * \sa operator!=()
+  */
+EIGEN_DEVICE_FUNC
+inline const BooleanNotReturnType
+operator!() const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return BooleanNotReturnType(derived());
+}
+
+
+// --- SpecialFunctions module ---
+
+typedef CwiseUnaryOp<internal::scalar_lgamma_op<Scalar>, const Derived> LgammaReturnType;
+typedef CwiseUnaryOp<internal::scalar_digamma_op<Scalar>, const Derived> DigammaReturnType;
+typedef CwiseUnaryOp<internal::scalar_erf_op<Scalar>, const Derived> ErfReturnType;
+typedef CwiseUnaryOp<internal::scalar_erfc_op<Scalar>, const Derived> ErfcReturnType;
+typedef CwiseUnaryOp<internal::scalar_ndtri_op<Scalar>, const Derived> NdtriReturnType;
+
+/** \cpp11 \returns an expression of the coefficient-wise ln(|gamma(*this)|).
+  *
+  * \specialfunctions_module
+  *
+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
+  * or float/double in non c++11 mode, the user has to provide implementations of lgamma(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_lgamma">Math functions</a>, digamma()
+  */
+EIGEN_DEVICE_FUNC
+inline const LgammaReturnType
+lgamma() const
+{
+  return LgammaReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise digamma (psi, derivative of lgamma).
+  *
+  * \specialfunctions_module
+  *
+  * \note This function supports only float and double scalar types. To support other scalar types,
+  * the user has to provide implementations of digamma(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_digamma">Math functions</a>, Eigen::digamma(), Eigen::polygamma(), lgamma()
+  */
+EIGEN_DEVICE_FUNC
+inline const DigammaReturnType
+digamma() const
+{
+  return DigammaReturnType(derived());
+}
+
+/** \cpp11 \returns an expression of the coefficient-wise Gauss error
+  * function of *this.
+  *
+  * \specialfunctions_module
+  *
+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
+  * or float/double in non c++11 mode, the user has to provide implementations of erf(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erf">Math functions</a>, erfc()
+  */
+EIGEN_DEVICE_FUNC
+inline const ErfReturnType
+erf() const
+{
+  return ErfReturnType(derived());
+}
+
+/** \cpp11 \returns an expression of the coefficient-wise Complementary error
+  * function of *this.
+  *
+  * \specialfunctions_module
+  *
+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
+  * or float/double in non c++11 mode, the user has to provide implementations of erfc(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erfc">Math functions</a>, erf()
+  */
+EIGEN_DEVICE_FUNC
+inline const ErfcReturnType
+erfc() const
+{
+  return ErfcReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse of the CDF of the Normal distribution function
+  * function of *this.
+  *
+  * \specialfunctions_module
+  * 
+  * In other words, considering `x = ndtri(y)`, it returns the argument, x, for which the area under the
+  * Gaussian probability density function (integrated from minus infinity to x) is equal to y.
+  *
+  * \note This function supports only float and double scalar types. To support other scalar types,
+  * the user has to provide implementations of ndtri(T) for any scalar type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ndtri">Math functions</a>
+  */
+EIGEN_DEVICE_FUNC
+inline const NdtriReturnType
+ndtri() const
+{
+  return NdtriReturnType(derived());
+}
diff --git a/C++/yolo_bytetrack/include/Eigen/src/plugins/BlockMethods.h b/C++/yolo_bytetrack/include/Eigen/src/plugins/BlockMethods.h
new file mode 100644
index 00000000..63a52a6f
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/plugins/BlockMethods.h
@@ -0,0 +1,1442 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+/// \internal expression type of a column */
+typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr;
+typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ConstColXpr;
+/// \internal expression type of a row */
+typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr;
+typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr;
+/// \internal expression type of a block of whole columns */
+typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr;
+typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ConstColsBlockXpr;
+/// \internal expression type of a block of whole rows */
+typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr;
+typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr;
+/// \internal expression type of a block of whole columns */
+template<int N> struct NColsBlockXpr { typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };
+template<int N> struct ConstNColsBlockXpr { typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };
+/// \internal expression type of a block of whole rows */
+template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };
+template<int N> struct ConstNRowsBlockXpr { typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };
+/// \internal expression of a block */
+typedef Block<Derived> BlockXpr;
+typedef const Block<const Derived> ConstBlockXpr;
+/// \internal expression of a block of fixed sizes */
+template<int Rows, int Cols> struct FixedBlockXpr { typedef Block<Derived,Rows,Cols> Type; };
+template<int Rows, int Cols> struct ConstFixedBlockXpr { typedef Block<const Derived,Rows,Cols> Type; };
+
+typedef VectorBlock<Derived> SegmentReturnType;
+typedef const VectorBlock<const Derived> ConstSegmentReturnType;
+template<int Size> struct FixedSegmentReturnType { typedef VectorBlock<Derived, Size> Type; };
+template<int Size> struct ConstFixedSegmentReturnType { typedef const VectorBlock<const Derived, Size> Type; };
+
+/// \internal inner-vector
+typedef Block<Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true>       InnerVectorReturnType;
+typedef Block<const Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true> ConstInnerVectorReturnType;
+
+/// \internal set of inner-vectors
+typedef Block<Derived,Dynamic,Dynamic,true> InnerVectorsReturnType;
+typedef Block<const Derived,Dynamic,Dynamic,true> ConstInnerVectorsReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+/// \returns an expression of a block in \c *this with either dynamic or fixed sizes.
+///
+/// \param  startRow  the first row in the block
+/// \param  startCol  the first column in the block
+/// \param  blockRows number of rows in the block, specified at either run-time or compile-time
+/// \param  blockCols number of columns in the block, specified at either run-time or compile-time
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example using runtime (aka dynamic) sizes: \include MatrixBase_block_int_int_int_int.cpp
+/// Output: \verbinclude MatrixBase_block_int_int_int_int.out
+///
+/// \newin{3.4}:
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. In the later case, \c n plays the role of a runtime fallback value in case \c N equals Eigen::Dynamic.
+/// Here is an example with a fixed number of rows \c NRows and dynamic number of columns \c cols:
+/// \code
+/// mat.block(i,j,fix<NRows>,cols)
+/// \endcode
+///
+/// This function thus fully covers the features offered by the following overloads block<NRows,NCols>(Index, Index),
+/// and block<NRows,NCols>(Index, Index, Index, Index) that are thus obsolete. Indeed, this generic version avoids
+/// redundancy, it preserves the argument order, and prevents the need to rely on the template keyword in templated code.
+///
+/// but with less redundancy and more consistency as it does not modify the argument order
+/// and seamlessly enable hybrid fixed/dynamic sizes.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size matrix, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block, fix, fix<N>(int)
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename FixedBlockXpr<...,...>::Type
+#endif
+block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type(
+            derived(), startRow, startCol, internal::get_runtime_value(blockRows), internal::get_runtime_value(blockCols));
+}
+
+/// This is the const version of block(Index,Index,NRowsType,NColsType)
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type(
+            derived(), startRow, startCol, internal::get_runtime_value(blockRows), internal::get_runtime_value(blockCols));
+}
+
+
+
+/// \returns a expression of a top-right corner of \c *this with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example with dynamic sizes: \include MatrixBase_topRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_topRightCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename FixedBlockXpr<...,...>::Type
+#endif
+topRightCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of topRightCorner(NRowsType, NColsType).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+topRightCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size top-right corner of \c *this.
+///
+/// \tparam CRows the number of rows in the corner
+/// \tparam CCols the number of columns in the corner
+///
+/// Example: \include MatrixBase_template_int_int_topRightCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topRightCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block, block<int,int>(Index,Index)
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type topRightCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
+}
+
+/// This is the const version of topRightCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
+}
+
+/// \returns an expression of a top-right corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_topRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topRightCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
+}
+
+/// This is the const version of topRightCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
+}
+
+
+
+/// \returns an expression of a top-left corner of \c *this  with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_topLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_topLeftCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename FixedBlockXpr<...,...>::Type
+#endif
+topLeftCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of topLeftCorner(Index, Index).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+topLeftCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size top-left corner of \c *this.
+///
+/// The template parameters CRows and CCols are the number of rows and columns in the corner.
+///
+/// Example: \include MatrixBase_template_int_int_topLeftCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topLeftCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
+}
+
+/// This is the const version of topLeftCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
+}
+
+/// \returns an expression of a top-left corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_topLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topLeftCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);
+}
+
+/// This is the const version of topLeftCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);
+}
+
+
+
+/// \returns an expression of a bottom-right corner of \c *this  with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_bottomRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename FixedBlockXpr<...,...>::Type
+#endif
+bottomRightCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of bottomRightCorner(NRowsType, NColsType).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+bottomRightCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size bottom-right corner of \c *this.
+///
+/// The template parameters CRows and CCols are the number of rows and columns in the corner.
+///
+/// Example: \include MatrixBase_template_int_int_bottomRightCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
+}
+
+/// This is the const version of bottomRightCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
+}
+
+/// \returns an expression of a bottom-right corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
+}
+
+/// This is the const version of bottomRightCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
+}
+
+
+
+/// \returns an expression of a bottom-left corner of \c *this  with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_bottomLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename FixedBlockXpr<...,...>::Type
+#endif
+bottomLeftCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), 0,
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of bottomLeftCorner(NRowsType, NColsType).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename ConstFixedBlockXpr<...,...>::Type
+#endif
+bottomLeftCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), 0,
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size bottom-left corner of \c *this.
+///
+/// The template parameters CRows and CCols are the number of rows and columns in the corner.
+///
+/// Example: \include MatrixBase_template_int_int_bottomLeftCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
+}
+
+/// This is the const version of bottomLeftCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
+}
+
+/// \returns an expression of a bottom-left corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
+}
+
+/// This is the const version of bottomLeftCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
+}
+
+
+
+/// \returns a block consisting of the top rows of \c *this.
+///
+/// \param n the number of rows in the block
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+///
+/// Example: \include MatrixBase_topRows_int.cpp
+/// Output: \verbinclude MatrixBase_topRows_int.out
+///
+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+typename NRowsBlockXpr<...>::Type
+#endif
+topRows(NRowsType n)
+{
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(n), cols());
+}
+
+/// This is the const version of topRows(NRowsType).
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+const typename ConstNRowsBlockXpr<...>::Type
+#endif
+topRows(NRowsType n) const
+{
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(n), cols());
+}
+
+/// \returns a block consisting of the top rows of \c *this.
+///
+/// \tparam N the number of rows in the block as specified at compile-time
+/// \param n the number of rows in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_topRows.cpp
+/// Output: \verbinclude MatrixBase_template_int_topRows.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NRowsBlockXpr<N>::Type topRows(Index n = N)
+{
+  return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
+}
+
+/// This is the const version of topRows<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const
+{
+  return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
+}
+
+
+
+/// \returns a block consisting of the bottom rows of \c *this.
+///
+/// \param n the number of rows in the block
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+///
+/// Example: \include MatrixBase_bottomRows_int.cpp
+/// Output: \verbinclude MatrixBase_bottomRows_int.out
+///
+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+typename NRowsBlockXpr<...>::Type
+#endif
+bottomRows(NRowsType n)
+{
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
+}
+
+/// This is the const version of bottomRows(NRowsType).
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+const typename ConstNRowsBlockXpr<...>::Type
+#endif
+bottomRows(NRowsType n) const
+{
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
+}
+
+/// \returns a block consisting of the bottom rows of \c *this.
+///
+/// \tparam N the number of rows in the block as specified at compile-time
+/// \param n the number of rows in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_bottomRows.cpp
+/// Output: \verbinclude MatrixBase_template_int_bottomRows.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NRowsBlockXpr<N>::Type bottomRows(Index n = N)
+{
+  return typename NRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
+}
+
+/// This is the const version of bottomRows<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const
+{
+  return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
+}
+
+
+
+/// \returns a block consisting of a range of rows of \c *this.
+///
+/// \param startRow the index of the first row in the block
+/// \param n the number of rows in the block
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+///
+/// Example: \include DenseBase_middleRows_int.cpp
+/// Output: \verbinclude DenseBase_middleRows_int.out
+///
+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+typename NRowsBlockXpr<...>::Type
+#endif
+middleRows(Index startRow, NRowsType n)
+{
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), startRow, 0, internal::get_runtime_value(n), cols());
+}
+
+/// This is the const version of middleRows(Index,NRowsType).
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+const typename ConstNRowsBlockXpr<...>::Type
+#endif
+middleRows(Index startRow, NRowsType n) const
+{
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), startRow, 0, internal::get_runtime_value(n), cols());
+}
+
+/// \returns a block consisting of a range of rows of \c *this.
+///
+/// \tparam N the number of rows in the block as specified at compile-time
+/// \param startRow the index of the first row in the block
+/// \param n the number of rows in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include DenseBase_template_int_middleRows.cpp
+/// Output: \verbinclude DenseBase_template_int_middleRows.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N)
+{
+  return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
+}
+
+/// This is the const version of middleRows<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) const
+{
+  return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
+}
+
+
+
+/// \returns a block consisting of the left columns of \c *this.
+///
+/// \param n the number of columns in the block
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_leftCols_int.cpp
+/// Output: \verbinclude MatrixBase_leftCols_int.out
+///
+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename NColsBlockXpr<...>::Type
+#endif
+leftCols(NColsType n)
+{
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, rows(), internal::get_runtime_value(n));
+}
+
+/// This is the const version of leftCols(NColsType).
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstNColsBlockXpr<...>::Type
+#endif
+leftCols(NColsType n) const
+{
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, rows(), internal::get_runtime_value(n));
+}
+
+/// \returns a block consisting of the left columns of \c *this.
+///
+/// \tparam N the number of columns in the block as specified at compile-time
+/// \param n the number of columns in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_leftCols.cpp
+/// Output: \verbinclude MatrixBase_template_int_leftCols.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NColsBlockXpr<N>::Type leftCols(Index n = N)
+{
+  return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
+}
+
+/// This is the const version of leftCols<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const
+{
+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
+}
+
+
+
+/// \returns a block consisting of the right columns of \c *this.
+///
+/// \param n the number of columns in the block
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_rightCols_int.cpp
+/// Output: \verbinclude MatrixBase_rightCols_int.out
+///
+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename NColsBlockXpr<...>::Type
+#endif
+rightCols(NColsType n)
+{
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
+}
+
+/// This is the const version of rightCols(NColsType).
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstNColsBlockXpr<...>::Type
+#endif
+rightCols(NColsType n) const
+{
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
+}
+
+/// \returns a block consisting of the right columns of \c *this.
+///
+/// \tparam N the number of columns in the block as specified at compile-time
+/// \param n the number of columns in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_rightCols.cpp
+/// Output: \verbinclude MatrixBase_template_int_rightCols.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NColsBlockXpr<N>::Type rightCols(Index n = N)
+{
+  return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
+}
+
+/// This is the const version of rightCols<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const
+{
+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
+}
+
+
+
+/// \returns a block consisting of a range of columns of \c *this.
+///
+/// \param startCol the index of the first column in the block
+/// \param numCols the number of columns in the block
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include DenseBase_middleCols_int.cpp
+/// Output: \verbinclude DenseBase_middleCols_int.out
+///
+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename NColsBlockXpr<...>::Type
+#endif
+middleCols(Index startCol, NColsType numCols)
+{
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
+}
+
+/// This is the const version of middleCols(Index,NColsType).
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstNColsBlockXpr<...>::Type
+#endif
+middleCols(Index startCol, NColsType numCols) const
+{
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
+}
+
+/// \returns a block consisting of a range of columns of \c *this.
+///
+/// \tparam N the number of columns in the block as specified at compile-time
+/// \param startCol the index of the first column in the block
+/// \param n the number of columns in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include DenseBase_template_int_middleCols.cpp
+/// Output: \verbinclude DenseBase_template_int_middleCols.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N)
+{
+  return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
+}
+
+/// This is the const version of middleCols<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) const
+{
+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
+}
+
+
+
+/// \returns a fixed-size expression of a block of \c *this.
+///
+/// The template parameters \a NRows and \a NCols are the number of
+/// rows and columns in the block.
+///
+/// \param startRow the first row in the block
+/// \param startCol the first column in the block
+///
+/// Example: \include MatrixBase_block_int_int.cpp
+/// Output: \verbinclude MatrixBase_block_int_int.out
+///
+/// \note The usage of of this overload is discouraged from %Eigen 3.4, better used the generic
+/// block(Index,Index,NRowsType,NColsType), here is the one-to-one equivalence:
+/// \code
+/// mat.template block<NRows,NCols>(i,j)  <-->  mat.block(i,j,fix<NRows>,fix<NCols>)
+/// \endcode
+///
+/// \note since block is a templated member, the keyword template has to be used
+/// if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol)
+{
+  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
+}
+
+/// This is the const version of block<>(Index, Index). */
+template<int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol) const
+{
+  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
+}
+
+/// \returns an expression of a block of \c *this.
+///
+/// \tparam NRows number of rows in block as specified at compile-time
+/// \tparam NCols number of columns in block as specified at compile-time
+/// \param  startRow  the first row in the block
+/// \param  startCol  the first column in the block
+/// \param  blockRows number of rows in block as specified at run-time
+/// \param  blockCols number of columns in block as specified at run-time
+///
+/// This function is mainly useful for blocks where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a blockRows should equal \a NRows unless
+/// \a NRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_block_int_int_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_block_int_int_int_int.out
+///
+/// \note The usage of of this overload is discouraged from %Eigen 3.4, better used the generic
+/// block(Index,Index,NRowsType,NColsType), here is the one-to-one complete equivalence:
+/// \code
+/// mat.template block<NRows,NCols>(i,j,rows,cols)     <-->  mat.block(i,j,fix<NRows>(rows),fix<NCols>(cols))
+/// \endcode
+/// If we known that, e.g., NRows==Dynamic and NCols!=Dynamic, then the equivalence becomes:
+/// \code
+/// mat.template block<Dynamic,NCols>(i,j,rows,NCols)  <-->  mat.block(i,j,rows,fix<NCols>)
+/// \endcode
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
+                                                  Index blockRows, Index blockCols)
+{
+  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
+}
+
+/// This is the const version of block<>(Index, Index, Index, Index).
+template<int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
+                                                              Index blockRows, Index blockCols) const
+{
+  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
+}
+
+/// \returns an expression of the \a i-th column of \c *this. Note that the numbering starts at 0.
+///
+/// Example: \include MatrixBase_col.cpp
+/// Output: \verbinclude MatrixBase_col.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+/**
+  * \sa row(), class Block */
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+ColXpr col(Index i)
+{
+  return ColXpr(derived(), i);
+}
+
+/// This is the const version of col().
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+ConstColXpr col(Index i) const
+{
+  return ConstColXpr(derived(), i);
+}
+
+/// \returns an expression of the \a i-th row of \c *this. Note that the numbering starts at 0.
+///
+/// Example: \include MatrixBase_row.cpp
+/// Output: \verbinclude MatrixBase_row.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+/**
+  * \sa col(), class Block */
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+RowXpr row(Index i)
+{
+  return RowXpr(derived(), i);
+}
+
+/// This is the const version of row(). */
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+ConstRowXpr row(Index i) const
+{
+  return ConstRowXpr(derived(), i);
+}
+
+/// \returns an expression of a segment (i.e. a vector block) in \c *this with either dynamic or fixed sizes.
+///
+/// \only_for_vectors
+///
+/// \param start the first coefficient in the segment
+/// \param n the number of coefficients in the segment
+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
+///
+/// Example: \include MatrixBase_segment_int_int.cpp
+/// Output: \verbinclude MatrixBase_segment_int_int.out
+///
+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+/// \sa block(Index,Index,NRowsType,NColsType), fix<N>, fix<N>(int), class Block
+///
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+typename FixedSegmentReturnType<...>::Type
+#endif
+segment(Index start, NType n)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), start, internal::get_runtime_value(n));
+}
+
+
+/// This is the const version of segment(Index,NType).
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+const typename ConstFixedSegmentReturnType<...>::Type
+#endif
+segment(Index start, NType n) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), start, internal::get_runtime_value(n));
+}
+
+/// \returns an expression of the first coefficients of \c *this with either dynamic or fixed sizes.
+///
+/// \only_for_vectors
+///
+/// \param n the number of coefficients in the segment
+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
+///
+/// Example: \include MatrixBase_start_int.cpp
+/// Output: \verbinclude MatrixBase_start_int.out
+///
+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+/// \sa class Block, block(Index,Index)
+///
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+typename FixedSegmentReturnType<...>::Type
+#endif
+head(NType n)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+              (derived(), 0, internal::get_runtime_value(n));
+}
+
+/// This is the const version of head(NType).
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+const typename ConstFixedSegmentReturnType<...>::Type
+#endif
+head(NType n) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), 0, internal::get_runtime_value(n));
+}
+
+/// \returns an expression of a last coefficients of \c *this with either dynamic or fixed sizes.
+///
+/// \only_for_vectors
+///
+/// \param n the number of coefficients in the segment
+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
+///
+/// Example: \include MatrixBase_end_int.cpp
+/// Output: \verbinclude MatrixBase_end_int.out
+///
+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+/// \sa class Block, block(Index,Index)
+///
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+typename FixedSegmentReturnType<...>::Type
+#endif
+tail(NType n)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
+}
+
+/// This is the const version of tail(Index).
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+const typename ConstFixedSegmentReturnType<...>::Type
+#endif
+tail(NType n) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
+}
+
+/// \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this
+///
+/// \only_for_vectors
+///
+/// \tparam N the number of coefficients in the segment as specified at compile-time
+/// \param start the index of the first element in the segment
+/// \param n the number of coefficients in the segment as specified at compile-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_segment.cpp
+/// Output: \verbinclude MatrixBase_template_int_segment.out
+///
+/// \sa segment(Index,NType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<N>::Type(derived(), start, n);
+}
+
+/// This is the const version of segment<int>(Index).
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n);
+}
+
+/// \returns a fixed-size expression of the first coefficients of \c *this.
+///
+/// \only_for_vectors
+///
+/// \tparam N the number of coefficients in the segment as specified at compile-time
+/// \param  n the number of coefficients in the segment as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_start.cpp
+/// Output: \verbinclude MatrixBase_template_int_start.out
+///
+/// \sa head(NType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedSegmentReturnType<N>::Type head(Index n = N)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<N>::Type(derived(), 0, n);
+}
+
+/// This is the const version of head<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n);
+}
+
+/// \returns a fixed-size expression of the last coefficients of \c *this.
+///
+/// \only_for_vectors
+///
+/// \tparam N the number of coefficients in the segment as specified at compile-time
+/// \param  n the number of coefficients in the segment as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_end.cpp
+/// Output: \verbinclude MatrixBase_template_int_end.out
+///
+/// \sa tail(NType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedSegmentReturnType<N>::Type tail(Index n = N)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<N>::Type(derived(), size() - n);
+}
+
+/// This is the const version of tail<int>.
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n);
+}
+
+/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+/// is col-major (resp. row-major).
+///
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+InnerVectorReturnType innerVector(Index outer)
+{ return InnerVectorReturnType(derived(), outer); }
+
+/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+/// is col-major (resp. row-major). Read-only.
+///
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const ConstInnerVectorReturnType innerVector(Index outer) const
+{ return ConstInnerVectorReturnType(derived(), outer); }
+
+/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+/// is col-major (resp. row-major).
+///
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+InnerVectorsReturnType
+innerVectors(Index outerStart, Index outerSize)
+{
+  return Block<Derived,Dynamic,Dynamic,true>(derived(),
+                                             IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
+                                             IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
+
+}
+
+/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+/// is col-major (resp. row-major). Read-only.
+///
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const ConstInnerVectorsReturnType
+innerVectors(Index outerStart, Index outerSize) const
+{
+  return Block<const Derived,Dynamic,Dynamic,true>(derived(),
+                                                  IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
+                                                  IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
+
+}
+
+/** \returns the i-th subvector (column or vector) according to the \c Direction
+  * \sa subVectors()
+  */
+template<DirectionType Direction>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename internal::conditional<Direction==Vertical,ColXpr,RowXpr>::type
+subVector(Index i)
+{
+  return typename internal::conditional<Direction==Vertical,ColXpr,RowXpr>::type(derived(),i);
+}
+
+/** This is the const version of subVector(Index) */
+template<DirectionType Direction>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename internal::conditional<Direction==Vertical,ConstColXpr,ConstRowXpr>::type
+subVector(Index i) const
+{
+  return typename internal::conditional<Direction==Vertical,ConstColXpr,ConstRowXpr>::type(derived(),i);
+}
+
+/** \returns the number of subvectors (rows or columns) in the direction \c Direction
+  * \sa subVector(Index)
+  */
+template<DirectionType Direction>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+Index subVectors() const
+{ return (Direction==Vertical)?cols():rows(); }
diff --git a/C++/yolo_bytetrack/include/Eigen/src/plugins/CommonCwiseBinaryOps.h b/C++/yolo_bytetrack/include/Eigen/src/plugins/CommonCwiseBinaryOps.h
new file mode 100644
index 00000000..8b6730ed
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/plugins/CommonCwiseBinaryOps.h
@@ -0,0 +1,115 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is a base class plugin containing common coefficient wise functions.
+
+/** \returns an expression of the difference of \c *this and \a other
+  *
+  * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-().
+  *
+  * \sa class CwiseBinaryOp, operator-=()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(operator-,difference)
+
+/** \returns an expression of the sum of \c *this and \a other
+  *
+  * \note If you want to add a given scalar to all coefficients, see Cwise::operator+().
+  *
+  * \sa class CwiseBinaryOp, operator+=()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(operator+,sum)
+
+/** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
+  *
+  * The template parameter \a CustomBinaryOp is the type of the functor
+  * of the custom operator (see class CwiseBinaryOp for an example)
+  *
+  * Here is an example illustrating the use of custom functors:
+  * \include class_CwiseBinaryOp.cpp
+  * Output: \verbinclude class_CwiseBinaryOp.out
+  *
+  * \sa class CwiseBinaryOp, operator+(), operator-(), cwiseProduct()
+  */
+template<typename CustomBinaryOp, typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>
+binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other, const CustomBinaryOp& func = CustomBinaryOp()) const
+{
+  return CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>(derived(), other.derived(), func);
+}
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP(operator*,product)
+#else
+/** \returns an expression of \c *this scaled by the scalar factor \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_product_op<Scalar,T>,Derived,Constant<T> > operator*(const T& scalar) const;
+/** \returns an expression of \a expr scaled by the scalar factor \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T> friend
+const CwiseBinaryOp<internal::scalar_product_op<T,Scalar>,Constant<T>,Derived> operator*(const T& scalar, const StorageBaseType& expr);
+#endif
+
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(operator/,quotient)
+#else
+/** \returns an expression of \c *this divided by the scalar value \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_quotient_op<Scalar,T>,Derived,Constant<T> > operator/(const T& scalar) const;
+#endif
+
+/** \returns an expression of the coefficient-wise boolean \b and operator of \c *this and \a other
+  *
+  * \warning this operator is for expression of bool only.
+  *
+  * Example: \include Cwise_boolean_and.cpp
+  * Output: \verbinclude Cwise_boolean_and.out
+  *
+  * \sa operator||(), select()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<internal::scalar_boolean_and_op, const Derived, const OtherDerived>
+operator&&(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return CwiseBinaryOp<internal::scalar_boolean_and_op, const Derived, const OtherDerived>(derived(),other.derived());
+}
+
+/** \returns an expression of the coefficient-wise boolean \b or operator of \c *this and \a other
+  *
+  * \warning this operator is for expression of bool only.
+  *
+  * Example: \include Cwise_boolean_or.cpp
+  * Output: \verbinclude Cwise_boolean_or.out
+  *
+  * \sa operator&&(), select()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<internal::scalar_boolean_or_op, const Derived, const OtherDerived>
+operator||(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return CwiseBinaryOp<internal::scalar_boolean_or_op, const Derived, const OtherDerived>(derived(),other.derived());
+}
diff --git a/C++/yolo_bytetrack/include/Eigen/src/plugins/CommonCwiseUnaryOps.h b/C++/yolo_bytetrack/include/Eigen/src/plugins/CommonCwiseUnaryOps.h
new file mode 100644
index 00000000..5418dc41
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/plugins/CommonCwiseUnaryOps.h
@@ -0,0 +1,177 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is a base class plugin containing common coefficient wise functions.
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+/** \internal the return type of conjugate() */
+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                    const CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const Derived>,
+                    const Derived&
+                  >::type ConjugateReturnType;
+/** \internal the return type of real() const */
+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                    const CwiseUnaryOp<internal::scalar_real_op<Scalar>, const Derived>,
+                    const Derived&
+                  >::type RealReturnType;
+/** \internal the return type of real() */
+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                    CwiseUnaryView<internal::scalar_real_ref_op<Scalar>, Derived>,
+                    Derived&
+                  >::type NonConstRealReturnType;
+/** \internal the return type of imag() const */
+typedef CwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived> ImagReturnType;
+/** \internal the return type of imag() */
+typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> NonConstImagReturnType;
+
+typedef CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const Derived> NegativeReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+/// \returns an expression of the opposite of \c *this
+///
+EIGEN_DOC_UNARY_ADDONS(operator-,opposite)
+///
+EIGEN_DEVICE_FUNC
+inline const NegativeReturnType
+operator-() const { return NegativeReturnType(derived()); }
+
+
+template<class NewType> struct CastXpr { typedef typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<Scalar, NewType>, const Derived> >::type Type; };
+
+/// \returns an expression of \c *this with the \a Scalar type casted to
+/// \a NewScalar.
+///
+/// The template parameter \a NewScalar is the type we are casting the scalars to.
+///
+EIGEN_DOC_UNARY_ADDONS(cast,conversion function)
+///
+/// \sa class CwiseUnaryOp
+///
+template<typename NewType>
+EIGEN_DEVICE_FUNC
+typename CastXpr<NewType>::Type
+cast() const
+{
+  return typename CastXpr<NewType>::Type(derived());
+}
+
+/// \returns an expression of the complex conjugate of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(conjugate,complex conjugate)
+///
+/// \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_conj">Math functions</a>, MatrixBase::adjoint()
+EIGEN_DEVICE_FUNC
+inline ConjugateReturnType
+conjugate() const
+{
+  return ConjugateReturnType(derived());
+}
+
+/// \returns an expression of the complex conjugate of \c *this if Cond==true, returns derived() otherwise.
+///
+EIGEN_DOC_UNARY_ADDONS(conjugate,complex conjugate)
+///
+/// \sa conjugate()
+template<bool Cond>
+EIGEN_DEVICE_FUNC
+inline typename internal::conditional<Cond,ConjugateReturnType,const Derived&>::type
+conjugateIf() const
+{
+  typedef typename internal::conditional<Cond,ConjugateReturnType,const Derived&>::type ReturnType;
+  return ReturnType(derived());
+}
+
+/// \returns a read-only expression of the real part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(real,real part function)
+///
+/// \sa imag()
+EIGEN_DEVICE_FUNC
+inline RealReturnType
+real() const { return RealReturnType(derived()); }
+
+/// \returns an read-only expression of the imaginary part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(imag,imaginary part function)
+///
+/// \sa real()
+EIGEN_DEVICE_FUNC
+inline const ImagReturnType
+imag() const { return ImagReturnType(derived()); }
+
+/// \brief Apply a unary operator coefficient-wise
+/// \param[in]  func  Functor implementing the unary operator
+/// \tparam  CustomUnaryOp Type of \a func
+/// \returns An expression of a custom coefficient-wise unary operator \a func of *this
+///
+/// The function \c ptr_fun() from the C++ standard library can be used to make functors out of normal functions.
+///
+/// Example:
+/// \include class_CwiseUnaryOp_ptrfun.cpp
+/// Output: \verbinclude class_CwiseUnaryOp_ptrfun.out
+///
+/// Genuine functors allow for more possibilities, for instance it may contain a state.
+///
+/// Example:
+/// \include class_CwiseUnaryOp.cpp
+/// Output: \verbinclude class_CwiseUnaryOp.out
+///
+EIGEN_DOC_UNARY_ADDONS(unaryExpr,unary function)
+///
+/// \sa unaryViewExpr, binaryExpr, class CwiseUnaryOp
+///
+template<typename CustomUnaryOp>
+EIGEN_DEVICE_FUNC
+inline const CwiseUnaryOp<CustomUnaryOp, const Derived>
+unaryExpr(const CustomUnaryOp& func = CustomUnaryOp()) const
+{
+  return CwiseUnaryOp<CustomUnaryOp, const Derived>(derived(), func);
+}
+
+/// \returns an expression of a custom coefficient-wise unary operator \a func of *this
+///
+/// The template parameter \a CustomUnaryOp is the type of the functor
+/// of the custom unary operator.
+///
+/// Example:
+/// \include class_CwiseUnaryOp.cpp
+/// Output: \verbinclude class_CwiseUnaryOp.out
+///
+EIGEN_DOC_UNARY_ADDONS(unaryViewExpr,unary function)
+///
+/// \sa unaryExpr, binaryExpr class CwiseUnaryOp
+///
+template<typename CustomViewOp>
+EIGEN_DEVICE_FUNC
+inline const CwiseUnaryView<CustomViewOp, const Derived>
+unaryViewExpr(const CustomViewOp& func = CustomViewOp()) const
+{
+  return CwiseUnaryView<CustomViewOp, const Derived>(derived(), func);
+}
+
+/// \returns a non const expression of the real part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(real,real part function)
+///
+/// \sa imag()
+EIGEN_DEVICE_FUNC
+inline NonConstRealReturnType
+real() { return NonConstRealReturnType(derived()); }
+
+/// \returns a non const expression of the imaginary part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(imag,imaginary part function)
+///
+/// \sa real()
+EIGEN_DEVICE_FUNC
+inline NonConstImagReturnType
+imag() { return NonConstImagReturnType(derived()); }
diff --git a/C++/yolo_bytetrack/include/Eigen/src/plugins/IndexedViewMethods.h b/C++/yolo_bytetrack/include/Eigen/src/plugins/IndexedViewMethods.h
new file mode 100644
index 00000000..5bfb19ac
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/plugins/IndexedViewMethods.h
@@ -0,0 +1,262 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#if !defined(EIGEN_PARSED_BY_DOXYGEN)
+
+// This file is automatically included twice to generate const and non-const versions
+
+#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#define EIGEN_INDEXED_VIEW_METHOD_CONST const
+#define EIGEN_INDEXED_VIEW_METHOD_TYPE  ConstIndexedViewType
+#else
+#define EIGEN_INDEXED_VIEW_METHOD_CONST
+#define EIGEN_INDEXED_VIEW_METHOD_TYPE IndexedViewType
+#endif
+
+#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+protected:
+
+// define some aliases to ease readability
+
+template<typename Indices>
+struct IvcRowType : public internal::IndexedViewCompatibleType<Indices,RowsAtCompileTime> {};
+
+template<typename Indices>
+struct IvcColType : public internal::IndexedViewCompatibleType<Indices,ColsAtCompileTime> {};
+
+template<typename Indices>
+struct IvcType : public internal::IndexedViewCompatibleType<Indices,SizeAtCompileTime> {};
+
+typedef typename internal::IndexedViewCompatibleType<Index,1>::type IvcIndex;
+
+template<typename Indices>
+typename IvcRowType<Indices>::type
+ivcRow(const Indices& indices) const {
+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,RowsAtCompileTime>(derived().rows()),Specialized);
+}
+
+template<typename Indices>
+typename IvcColType<Indices>::type
+ivcCol(const Indices& indices) const {
+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,ColsAtCompileTime>(derived().cols()),Specialized);
+}
+
+template<typename Indices>
+typename IvcColType<Indices>::type
+ivcSize(const Indices& indices) const {
+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,SizeAtCompileTime>(derived().size()),Specialized);
+}
+
+public:
+
+#endif
+
+template<typename RowIndices, typename ColIndices>
+struct EIGEN_INDEXED_VIEW_METHOD_TYPE {
+  typedef IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,
+                      typename IvcRowType<RowIndices>::type,
+                      typename IvcColType<ColIndices>::type> type;
+};
+
+// This is the generic version
+
+template<typename RowIndices, typename ColIndices>
+typename internal::enable_if<internal::valid_indexed_view_overload<RowIndices,ColIndices>::value
+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsIndexedView,
+  typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type >::type
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type
+            (derived(), ivcRow(rowIndices), ivcCol(colIndices));
+}
+
+// The following overload returns a Block<> object
+
+template<typename RowIndices, typename ColIndices>
+typename internal::enable_if<internal::valid_indexed_view_overload<RowIndices,ColIndices>::value
+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsBlock,
+  typename internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::BlockType>::type
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  typedef typename internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::BlockType BlockType;
+  typename IvcRowType<RowIndices>::type actualRowIndices = ivcRow(rowIndices);
+  typename IvcColType<ColIndices>::type actualColIndices = ivcCol(colIndices);
+  return BlockType(derived(),
+                   internal::first(actualRowIndices),
+                   internal::first(actualColIndices),
+                   internal::size(actualRowIndices),
+                   internal::size(actualColIndices));
+}
+
+// The following overload returns a Scalar
+
+template<typename RowIndices, typename ColIndices>
+typename internal::enable_if<internal::valid_indexed_view_overload<RowIndices,ColIndices>::value
+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsScalar,
+  CoeffReturnType >::type
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return Base::operator()(internal::eval_expr_given_size(rowIndices,rows()),internal::eval_expr_given_size(colIndices,cols()));
+}
+
+#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+// The following three overloads are needed to handle raw Index[N] arrays.
+
+template<typename RowIndicesT, std::size_t RowIndicesN, typename ColIndices>
+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],typename IvcColType<ColIndices>::type>
+operator()(const RowIndicesT (&rowIndices)[RowIndicesN], const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],typename IvcColType<ColIndices>::type>
+                    (derived(), rowIndices, ivcCol(colIndices));
+}
+
+template<typename RowIndices, typename ColIndicesT, std::size_t ColIndicesN>
+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcRowType<RowIndices>::type, const ColIndicesT (&)[ColIndicesN]>
+operator()(const RowIndices& rowIndices, const ColIndicesT (&colIndices)[ColIndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcRowType<RowIndices>::type,const ColIndicesT (&)[ColIndicesN]>
+                    (derived(), ivcRow(rowIndices), colIndices);
+}
+
+template<typename RowIndicesT, std::size_t RowIndicesN, typename ColIndicesT, std::size_t ColIndicesN>
+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN], const ColIndicesT (&)[ColIndicesN]>
+operator()(const RowIndicesT (&rowIndices)[RowIndicesN], const ColIndicesT (&colIndices)[ColIndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],const ColIndicesT (&)[ColIndicesN]>
+                    (derived(), rowIndices, colIndices);
+}
+
+#endif // EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+// Overloads for 1D vectors/arrays
+
+template<typename Indices>
+typename internal::enable_if<
+  IsRowMajor && (!(internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1 || internal::is_valid_index_type<Indices>::value)),
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,typename IvcType<Indices>::type> >::type
+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,typename IvcType<Indices>::type>
+            (derived(), IvcIndex(0), ivcCol(indices));
+}
+
+template<typename Indices>
+typename internal::enable_if<
+  (!IsRowMajor) && (!(internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1 || internal::is_valid_index_type<Indices>::value)),
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcType<Indices>::type,IvcIndex> >::type
+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcType<Indices>::type,IvcIndex>
+            (derived(), ivcRow(indices), IvcIndex(0));
+}
+
+template<typename Indices>
+typename internal::enable_if<
+  (internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1) && (!internal::is_valid_index_type<Indices>::value) && (!symbolic::is_symbolic<Indices>::value),
+  VectorBlock<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,internal::array_size<Indices>::value> >::type
+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  typename IvcType<Indices>::type actualIndices = ivcSize(indices);
+  return VectorBlock<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,internal::array_size<Indices>::value>
+            (derived(), internal::first(actualIndices), internal::size(actualIndices));
+}
+
+template<typename IndexType>
+typename internal::enable_if<symbolic::is_symbolic<IndexType>::value, CoeffReturnType >::type
+operator()(const IndexType& id) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return Base::operator()(internal::eval_expr_given_size(id,size()));
+}
+
+#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+template<typename IndicesT, std::size_t IndicesN>
+typename internal::enable_if<IsRowMajor,
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,const IndicesT (&)[IndicesN]> >::type
+operator()(const IndicesT (&indices)[IndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,const IndicesT (&)[IndicesN]>
+            (derived(), IvcIndex(0), indices);
+}
+
+template<typename IndicesT, std::size_t IndicesN>
+typename internal::enable_if<!IsRowMajor,
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const IndicesT (&)[IndicesN],IvcIndex> >::type
+operator()(const IndicesT (&indices)[IndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const IndicesT (&)[IndicesN],IvcIndex>
+            (derived(), indices, IvcIndex(0));
+}
+
+#endif // EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+#undef EIGEN_INDEXED_VIEW_METHOD_CONST
+#undef EIGEN_INDEXED_VIEW_METHOD_TYPE
+
+#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#define EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#include "IndexedViewMethods.h"
+#undef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#endif
+
+#else // EIGEN_PARSED_BY_DOXYGEN
+
+/**
+  * \returns a generic submatrix view defined by the rows and columns indexed \a rowIndices and \a colIndices respectively.
+  *
+  * Each parameter must either be:
+  *  - An integer indexing a single row or column
+  *  - Eigen::all indexing the full set of respective rows or columns in increasing order
+  *  - An ArithmeticSequence as returned by the Eigen::seq and Eigen::seqN functions
+  *  - Any %Eigen's vector/array of integers or expressions
+  *  - Plain C arrays: \c int[N]
+  *  - And more generally any type exposing the following two member functions:
+  * \code
+  * <integral type> operator[](<integral type>) const;
+  * <integral type> size() const;
+  * \endcode
+  * where \c <integral \c type>  stands for any integer type compatible with Eigen::Index (i.e. \c std::ptrdiff_t).
+  *
+  * The last statement implies compatibility with \c std::vector, \c std::valarray, \c std::array, many of the Range-v3's ranges, etc.
+  *
+  * If the submatrix can be represented using a starting position \c (i,j) and positive sizes \c (rows,columns), then this
+  * method will returns a Block object after extraction of the relevant information from the passed arguments. This is the case
+  * when all arguments are either:
+  *  - An integer
+  *  - Eigen::all
+  *  - An ArithmeticSequence with compile-time increment strictly equal to 1, as returned by Eigen::seq(a,b), and Eigen::seqN(a,N).
+  *
+  * Otherwise a more general IndexedView<Derived,RowIndices',ColIndices'> object will be returned, after conversion of the inputs
+  * to more suitable types \c RowIndices' and \c ColIndices'.
+  *
+  * For 1D vectors and arrays, you better use the operator()(const Indices&) overload, which behave the same way but taking a single parameter.
+  *
+  * See also this <a href="https://stackoverflow.com/questions/46110917/eigen-replicate-items-along-one-dimension-without-useless-allocations">question</a> and its answer for an example of how to duplicate coefficients.
+  *
+  * \sa operator()(const Indices&), class Block, class IndexedView, DenseBase::block(Index,Index,Index,Index)
+  */
+template<typename RowIndices, typename ColIndices>
+IndexedView_or_Block
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices);
+
+/** This is an overload of operator()(const RowIndices&, const ColIndices&) for 1D vectors or arrays
+  *
+  * \only_for_vectors
+  */
+template<typename Indices>
+IndexedView_or_VectorBlock
+operator()(const Indices& indices);
+
+#endif  // EIGEN_PARSED_BY_DOXYGEN
diff --git a/C++/yolo_bytetrack/include/Eigen/src/plugins/MatrixCwiseBinaryOps.h b/C++/yolo_bytetrack/include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
new file mode 100644
index 00000000..a0feef87
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
@@ -0,0 +1,152 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is a base class plugin containing matrix specifics coefficient wise functions.
+
+/** \returns an expression of the Schur product (coefficient wise product) of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseProduct.cpp
+  * Output: \verbinclude MatrixBase_cwiseProduct.out
+  *
+  * \sa class CwiseBinaryOp, cwiseAbs2
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)
+cwiseProduct(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise == operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include MatrixBase_cwiseEqual.cpp
+  * Output: \verbinclude MatrixBase_cwiseEqual.out
+  *
+  * \sa cwiseNotEqual(), isApprox(), isMuchSmallerThan()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<numext::equal_to<Scalar>, const Derived, const OtherDerived>
+cwiseEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<numext::equal_to<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise != operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include MatrixBase_cwiseNotEqual.cpp
+  * Output: \verbinclude MatrixBase_cwiseNotEqual.out
+  *
+  * \sa cwiseEqual(), isApprox(), isMuchSmallerThan()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<numext::not_equal_to<Scalar>, const Derived, const OtherDerived>
+cwiseNotEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<numext::not_equal_to<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise min of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseMin.cpp
+  * Output: \verbinclude MatrixBase_cwiseMin.out
+  *
+  * \sa class CwiseBinaryOp, max()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const OtherDerived>
+cwiseMin(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise min of *this and scalar \a other
+  *
+  * \sa class CwiseBinaryOp, min()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const ConstantReturnType>
+cwiseMin(const Scalar &other) const
+{
+  return cwiseMin(Derived::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise max of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseMax.cpp
+  * Output: \verbinclude MatrixBase_cwiseMax.out
+  *
+  * \sa class CwiseBinaryOp, min()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const OtherDerived>
+cwiseMax(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise max of *this and scalar \a other
+  *
+  * \sa class CwiseBinaryOp, min()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const ConstantReturnType>
+cwiseMax(const Scalar &other) const
+{
+  return cwiseMax(Derived::Constant(rows(), cols(), other));
+}
+
+
+/** \returns an expression of the coefficient-wise quotient of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseQuotient.cpp
+  * Output: \verbinclude MatrixBase_cwiseQuotient.out
+  *
+  * \sa class CwiseBinaryOp, cwiseProduct(), cwiseInverse()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>
+cwiseQuotient(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar,internal::cmp_EQ>, const Derived, const ConstantReturnType> CwiseScalarEqualReturnType;
+
+/** \returns an expression of the coefficient-wise == operator of \c *this and a scalar \a s
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * \sa cwiseEqual(const MatrixBase<OtherDerived> &) const
+  */
+EIGEN_DEVICE_FUNC
+inline const CwiseScalarEqualReturnType
+cwiseEqual(const Scalar& s) const
+{
+  return CwiseScalarEqualReturnType(derived(), Derived::Constant(rows(), cols(), s), internal::scalar_cmp_op<Scalar,Scalar,internal::cmp_EQ>());
+}
diff --git a/C++/yolo_bytetrack/include/Eigen/src/plugins/MatrixCwiseUnaryOps.h b/C++/yolo_bytetrack/include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
new file mode 100644
index 00000000..0514d8f7
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
@@ -0,0 +1,95 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is included into the body of the base classes supporting matrix specific coefficient-wise functions.
+// This include MatrixBase and SparseMatrixBase.
+
+
+typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> CwiseAbsReturnType;
+typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> CwiseAbs2ReturnType;
+typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> CwiseArgReturnType;
+typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> CwiseSqrtReturnType;
+typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> CwiseSignReturnType;
+typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> CwiseInverseReturnType;
+
+/// \returns an expression of the coefficient-wise absolute value of \c *this
+///
+/// Example: \include MatrixBase_cwiseAbs.cpp
+/// Output: \verbinclude MatrixBase_cwiseAbs.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseAbs,absolute value)
+///
+/// \sa cwiseAbs2()
+///
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseAbsReturnType
+cwiseAbs() const { return CwiseAbsReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise squared absolute value of \c *this
+///
+/// Example: \include MatrixBase_cwiseAbs2.cpp
+/// Output: \verbinclude MatrixBase_cwiseAbs2.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseAbs2,squared absolute value)
+///
+/// \sa cwiseAbs()
+///
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseAbs2ReturnType
+cwiseAbs2() const { return CwiseAbs2ReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise square root of *this.
+///
+/// Example: \include MatrixBase_cwiseSqrt.cpp
+/// Output: \verbinclude MatrixBase_cwiseSqrt.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseSqrt,square-root)
+///
+/// \sa cwisePow(), cwiseSquare()
+///
+EIGEN_DEVICE_FUNC
+inline const CwiseSqrtReturnType
+cwiseSqrt() const { return CwiseSqrtReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise signum of *this.
+///
+/// Example: \include MatrixBase_cwiseSign.cpp
+/// Output: \verbinclude MatrixBase_cwiseSign.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseSign,sign function)
+///
+EIGEN_DEVICE_FUNC
+inline const CwiseSignReturnType
+cwiseSign() const { return CwiseSignReturnType(derived()); }
+
+
+/// \returns an expression of the coefficient-wise inverse of *this.
+///
+/// Example: \include MatrixBase_cwiseInverse.cpp
+/// Output: \verbinclude MatrixBase_cwiseInverse.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseInverse,inverse)
+///
+/// \sa cwiseProduct()
+///
+EIGEN_DEVICE_FUNC
+inline const CwiseInverseReturnType
+cwiseInverse() const { return CwiseInverseReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise phase angle of \c *this
+///
+/// Example: \include MatrixBase_cwiseArg.cpp
+/// Output: \verbinclude MatrixBase_cwiseArg.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseArg,arg)
+
+EIGEN_DEVICE_FUNC
+inline const CwiseArgReturnType
+cwiseArg() const { return CwiseArgReturnType(derived()); }
diff --git a/C++/yolo_bytetrack/include/Eigen/src/plugins/ReshapedMethods.h b/C++/yolo_bytetrack/include/Eigen/src/plugins/ReshapedMethods.h
new file mode 100644
index 00000000..482a6b04
--- /dev/null
+++ b/C++/yolo_bytetrack/include/Eigen/src/plugins/ReshapedMethods.h
@@ -0,0 +1,149 @@
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+
+/// \returns an expression of \c *this with reshaped sizes.
+///
+/// \param nRows the number of rows in the reshaped expression, specified at either run-time or compile-time, or AutoSize
+/// \param nCols the number of columns in the reshaped expression, specified at either run-time or compile-time, or AutoSize
+/// \tparam Order specifies whether the coefficients should be processed in column-major-order (ColMajor), in row-major-order (RowMajor),
+///               or follows the \em natural order of the nested expression (AutoOrder). The default is ColMajor.
+/// \tparam NRowsType the type of the value handling the number of rows, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns, typically Index.
+///
+/// Dynamic size example: \include MatrixBase_reshaped_int_int.cpp
+/// Output: \verbinclude MatrixBase_reshaped_int_int.out
+///
+/// The number of rows \a nRows and columns \a nCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. In the later case, \c n plays the role of a runtime fallback value in case \c N equals Eigen::Dynamic.
+/// Here is an example with a fixed number of rows and columns:
+/// \include MatrixBase_reshaped_fixed.cpp
+/// Output: \verbinclude MatrixBase_reshaped_fixed.out
+///
+/// Finally, one of the sizes parameter can be automatically deduced from the other one by passing AutoSize as in the following example:
+/// \include MatrixBase_reshaped_auto.cpp
+/// Output: \verbinclude MatrixBase_reshaped_auto.out
+/// AutoSize does preserve compile-time sizes when possible, i.e., when the sizes of the input are known at compile time \b and
+/// that the other size is passed at compile-time using Eigen::fix<N> as above.
+///
+/// \sa class Reshaped, fix, fix<N>(int)
+///
+template<int Order = ColMajor, typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+inline Reshaped<Derived,...>
+reshaped(NRowsType nRows, NColsType nCols);
+
+/// This is the const version of reshaped(NRowsType,NColsType).
+template<int Order = ColMajor, typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+inline const Reshaped<const Derived,...>
+reshaped(NRowsType nRows, NColsType nCols) const;
+
+/// \returns an expression of \c *this with columns (or rows) stacked to a linear column vector
+///
+/// \tparam Order specifies whether the coefficients should be processed in column-major-order (ColMajor), in row-major-order (RowMajor),
+///               or follows the \em natural order of the nested expression (AutoOrder). The default is ColMajor.
+///
+/// This overloads is essentially a shortcut for `A.reshaped<Order>(AutoSize,fix<1>)`.
+///
+/// - If `Order==ColMajor` (the default), then it returns a column-vector from the stacked columns of \c *this.
+/// - If `Order==RowMajor`, then it returns a column-vector from the stacked rows of \c *this.
+/// - If `Order==AutoOrder`, then it returns a column-vector with elements stacked following the storage order of \c *this.
+///   This mode is the recommended one when the particular ordering of the element is not relevant.
+///
+/// Example:
+/// \include MatrixBase_reshaped_to_vector.cpp
+/// Output: \verbinclude MatrixBase_reshaped_to_vector.out
+///
+/// If you want more control, you can still fall back to reshaped(NRowsType,NColsType).
+///
+/// \sa reshaped(NRowsType,NColsType), class Reshaped
+///
+template<int Order = ColMajor>
+EIGEN_DEVICE_FUNC
+inline Reshaped<Derived,...>
+reshaped();
+
+/// This is the const version of reshaped().
+template<int Order = ColMajor>
+EIGEN_DEVICE_FUNC
+inline const Reshaped<const Derived,...>
+reshaped() const;
+
+#else
+
+// This file is automatically included twice to generate const and non-const versions
+
+#ifndef EIGEN_RESHAPED_METHOD_2ND_PASS
+#define EIGEN_RESHAPED_METHOD_CONST const
+#else
+#define EIGEN_RESHAPED_METHOD_CONST
+#endif
+
+#ifndef EIGEN_RESHAPED_METHOD_2ND_PASS
+
+// This part is included once
+
+#endif
+
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,
+                internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,
+                internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value>
+reshaped(NRowsType nRows, NColsType nCols) EIGEN_RESHAPED_METHOD_CONST
+{
+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,
+                  internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,
+                  internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value>
+                (derived(),
+                 internal::get_runtime_reshape_size(nRows,internal::get_runtime_value(nCols),size()),
+                 internal::get_runtime_reshape_size(nCols,internal::get_runtime_value(nRows),size()));
+}
+
+template<int Order, typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,
+                internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,
+                internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value,
+                internal::get_compiletime_reshape_order<Flags,Order>::value>
+reshaped(NRowsType nRows, NColsType nCols) EIGEN_RESHAPED_METHOD_CONST
+{
+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,
+                  internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,
+                  internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value,
+                  internal::get_compiletime_reshape_order<Flags,Order>::value>
+                (derived(),
+                 internal::get_runtime_reshape_size(nRows,internal::get_runtime_value(nCols),size()),
+                 internal::get_runtime_reshape_size(nCols,internal::get_runtime_value(nRows),size()));
+}
+
+// Views as linear vectors
+
+EIGEN_DEVICE_FUNC
+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,SizeAtCompileTime,1>
+reshaped() EIGEN_RESHAPED_METHOD_CONST
+{
+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,SizeAtCompileTime,1>(derived(),size(),1);
+}
+
+template<int Order>
+EIGEN_DEVICE_FUNC
+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived, SizeAtCompileTime, 1,
+                internal::get_compiletime_reshape_order<Flags,Order>::value>
+reshaped() EIGEN_RESHAPED_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT(Order==RowMajor || Order==ColMajor || Order==AutoOrder, INVALID_TEMPLATE_PARAMETER);
+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived, SizeAtCompileTime, 1,
+                  internal::get_compiletime_reshape_order<Flags,Order>::value>
+                (derived(), size(), 1);
+}
+
+#undef EIGEN_RESHAPED_METHOD_CONST
+
+#ifndef EIGEN_RESHAPED_METHOD_2ND_PASS
+#define EIGEN_RESHAPED_METHOD_2ND_PASS
+#include "ReshapedMethods.h"
+#undef EIGEN_RESHAPED_METHOD_2ND_PASS
+#endif
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
diff --git a/C++/yolo_bytetrack/include/STrack.h b/C++/yolo_bytetrack/include/STrack.h
new file mode 100644
index 00000000..752cbefa
--- /dev/null
+++ b/C++/yolo_bytetrack/include/STrack.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <opencv2/opencv.hpp>
+#include "kalmanFilter.h"
+
+using namespace cv;
+using namespace std;
+
+enum TrackState { New = 0, Tracked, Lost, Removed };
+
+class STrack
+{
+public:
+	STrack(vector<float> tlwh_, float score);
+	~STrack();
+
+	vector<float> static tlbr_to_tlwh(vector<float> &tlbr);
+	void static multi_predict(vector<STrack*> &stracks, byte_kalman::KalmanFilter &kalman_filter);
+	void static_tlwh();
+	void static_tlbr();
+	vector<float> tlwh_to_xyah(vector<float> tlwh_tmp);
+	vector<float> to_xyah();
+	void mark_lost();
+	void mark_removed();
+	int next_id();
+	int end_frame();
+	
+	void activate(byte_kalman::KalmanFilter &kalman_filter, int frame_id);
+	void re_activate(STrack &new_track, int frame_id, bool new_id = false);
+	void update(STrack &new_track, int frame_id);
+
+public:
+	bool is_activated;
+	int track_id;
+	int state;
+
+	vector<float> _tlwh;
+	vector<float> tlwh;
+	vector<float> tlbr;
+	int frame_id;
+	int tracklet_len;
+	int start_frame;
+
+	KAL_MEAN mean;
+	KAL_COVA covariance;
+	float score;
+
+private:
+	byte_kalman::KalmanFilter kalman_filter;
+};
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/include/dataType.h b/C++/yolo_bytetrack/include/dataType.h
new file mode 100644
index 00000000..800fead3
--- /dev/null
+++ b/C++/yolo_bytetrack/include/dataType.h
@@ -0,0 +1,36 @@
+#pragma once
+#define EIGEN_DONT_ALIGN_STATICALLY
+#include <cstddef>
+#include <vector>
+
+#include <Eigen/Core>
+#include <Eigen/Dense>
+typedef Eigen::Matrix<float, 1, 4, Eigen::RowMajor> DETECTBOX;
+typedef Eigen::Matrix<float, -1, 4, Eigen::RowMajor> DETECTBOXSS;
+typedef Eigen::Matrix<float, 1, 128, Eigen::RowMajor> FEATURE;
+typedef Eigen::Matrix<float, Eigen::Dynamic, 128, Eigen::RowMajor> FEATURESS;
+//typedef std::vector<FEATURE> FEATURESS;
+
+//Kalmanfilter
+//typedef Eigen::Matrix<float, 8, 8, Eigen::RowMajor> KAL_FILTER;
+typedef Eigen::Matrix<float, 1, 8, Eigen::RowMajor> KAL_MEAN;
+typedef Eigen::Matrix<float, 8, 8, Eigen::RowMajor> KAL_COVA;
+typedef Eigen::Matrix<float, 1, 4, Eigen::RowMajor> KAL_HMEAN;
+typedef Eigen::Matrix<float, 4, 4, Eigen::RowMajor> KAL_HCOVA;
+using KAL_DATA = std::pair<KAL_MEAN, KAL_COVA>;
+using KAL_HDATA = std::pair<KAL_HMEAN, KAL_HCOVA>;
+
+//main
+using RESULT_DATA = std::pair<int, DETECTBOX>;
+
+//tracker:
+using TRACKER_DATA = std::pair<int, FEATURESS>;
+using MATCH_DATA = std::pair<int, int>;
+typedef struct t {
+	std::vector<MATCH_DATA> matches;
+	std::vector<int> unmatched_tracks;
+	std::vector<int> unmatched_detections;
+}TRACHER_MATCHD;
+
+//linear_assignment:
+typedef Eigen::Matrix<float, -1, -1, Eigen::RowMajor> DYNAMICM;
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/include/kalmanFilter.h b/C++/yolo_bytetrack/include/kalmanFilter.h
new file mode 100644
index 00000000..9aebc5af
--- /dev/null
+++ b/C++/yolo_bytetrack/include/kalmanFilter.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "dataType.h"
+
+namespace byte_kalman
+{
+	class KalmanFilter
+	{
+	public:
+		EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+		static const double chi2inv95[10];
+		KalmanFilter();
+		KAL_DATA initiate(const DETECTBOX& measurement);
+		void predict(KAL_MEAN& mean, KAL_COVA& covariance);
+		KAL_HDATA project(const KAL_MEAN& mean, const KAL_COVA& covariance);
+		KAL_DATA update(const KAL_MEAN& mean,
+			const KAL_COVA& covariance,
+			const DETECTBOX& measurement);
+
+		Eigen::Matrix<float, 1, -1> gating_distance(
+			const KAL_MEAN& mean,
+			const KAL_COVA& covariance,
+			const std::vector<DETECTBOX>& measurements,
+			bool only_position = false);
+
+	private:
+		Eigen::Matrix<float, 8, 8, Eigen::RowMajor> _motion_mat;
+		Eigen::Matrix<float, 4, 8, Eigen::RowMajor> _update_mat;
+		float _std_weight_position;
+		float _std_weight_velocity;
+	};
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/include/lapjv.h b/C++/yolo_bytetrack/include/lapjv.h
new file mode 100644
index 00000000..0e34385a
--- /dev/null
+++ b/C++/yolo_bytetrack/include/lapjv.h
@@ -0,0 +1,63 @@
+#ifndef LAPJV_H
+#define LAPJV_H
+
+#define LARGE 1000000
+
+#if !defined TRUE
+#define TRUE 1
+#endif
+#if !defined FALSE
+#define FALSE 0
+#endif
+
+#define NEW(x, t, n) if ((x = (t *)malloc(sizeof(t) * (n))) == 0) { return -1; }
+#define FREE(x) if (x != 0) { free(x); x = 0; }
+#define SWAP_INDICES(a, b) { int_t _temp_index = a; a = b; b = _temp_index; }
+
+#if 0
+#include <assert.h>
+#define ASSERT(cond) assert(cond)
+#define PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#define PRINT_COST_ARRAY(a, n) \
+    while (1) { \
+        printf(#a" = ["); \
+        if ((n) > 0) { \
+            printf("%f", (a)[0]); \
+            for (uint_t j = 1; j < n; j++) { \
+                printf(", %f", (a)[j]); \
+            } \
+        } \
+        printf("]\n"); \
+        break; \
+    }
+#define PRINT_INDEX_ARRAY(a, n) \
+    while (1) { \
+        printf(#a" = ["); \
+        if ((n) > 0) { \
+            printf("%d", (a)[0]); \
+            for (uint_t j = 1; j < n; j++) { \
+                printf(", %d", (a)[j]); \
+            } \
+        } \
+        printf("]\n"); \
+        break; \
+    }
+#else
+#define ASSERT(cond)
+#define PRINTF(fmt, ...)
+#define PRINT_COST_ARRAY(a, n)
+#define PRINT_INDEX_ARRAY(a, n)
+#endif
+
+
+typedef signed int int_t;
+typedef unsigned int uint_t;
+typedef double cost_t;
+typedef char boolean;
+typedef enum fp_t { FP_1 = 1, FP_2 = 2, FP_DYNAMIC = 3 } fp_t;
+
+extern int_t lapjv_internal(
+	const uint_t n, cost_t *cost[],
+	int_t *x, int_t *y);
+
+#endif // LAPJV_H
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/model/labels.txt b/C++/yolo_bytetrack/model/labels.txt
new file mode 100644
index 00000000..4d90a288
--- /dev/null
+++ b/C++/yolo_bytetrack/model/labels.txt
@@ -0,0 +1,2 @@
+person
+car
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/model/uestc.rknn b/C++/yolo_bytetrack/model/uestc.rknn
new file mode 100644
index 00000000..2275016f
Binary files /dev/null and b/C++/yolo_bytetrack/model/uestc.rknn differ
diff --git a/C++/yolo_bytetrack/src/BYTETracker.cpp b/C++/yolo_bytetrack/src/BYTETracker.cpp
new file mode 100644
index 00000000..4292678d
--- /dev/null
+++ b/C++/yolo_bytetrack/src/BYTETracker.cpp
@@ -0,0 +1,242 @@
+#include "BYTETracker.h"
+#include <fstream>
+#include <iostream>
+
+BYTETracker::BYTETracker(int frame_rate, int track_buffer)
+{
+	track_thresh = 0.5;
+	high_thresh = 0.6;
+	match_thresh = 0.8;
+
+	frame_id = 0;
+	max_time_lost = int(frame_rate / 30.0 * track_buffer);
+	cout << "Init ByteTrack!" << endl;
+}
+
+BYTETracker::~BYTETracker()
+{
+}
+
+vector<STrack> BYTETracker::update(const vector<Object>& objects)
+{
+
+	////////////////// Step 1: Get detections //////////////////
+	this->frame_id++;
+	vector<STrack> activated_stracks;
+	vector<STrack> refind_stracks;
+	vector<STrack> removed_stracks;
+	vector<STrack> lost_stracks;
+	vector<STrack> detections;
+	vector<STrack> detections_low;
+
+	vector<STrack> detections_cp;
+	vector<STrack> tracked_stracks_swap;
+	vector<STrack> resa, resb;
+	vector<STrack> output_stracks;
+
+	vector<STrack*> unconfirmed;
+	vector<STrack*> tracked_stracks;
+	vector<STrack*> strack_pool;
+	vector<STrack*> r_tracked_stracks;
+
+	if (objects.size() > 0)
+	{
+		for (int i = 0; i < objects.size(); i++)
+		{
+			vector<float> tlbr_;
+			tlbr_.resize(4);
+			tlbr_[0] = objects[i].rect.x;
+			tlbr_[1] = objects[i].rect.y;
+			tlbr_[2] = objects[i].rect.x + objects[i].rect.width;
+			tlbr_[3] = objects[i].rect.y + objects[i].rect.height;
+
+			float score = objects[i].prob;
+
+			STrack strack(STrack::tlbr_to_tlwh(tlbr_), score);
+			if (score >= track_thresh)
+			{
+				detections.push_back(strack);
+			}
+			else
+			{
+				detections_low.push_back(strack);
+			}
+			
+		}
+	}
+
+	// Add newly detected tracklets to tracked_stracks
+	for (int i = 0; i < this->tracked_stracks.size(); i++)
+	{
+		if (!this->tracked_stracks[i].is_activated)
+			unconfirmed.push_back(&this->tracked_stracks[i]);
+		else
+			tracked_stracks.push_back(&this->tracked_stracks[i]);
+	}
+
+	////////////////// Step 2: First association, with IoU //////////////////
+	strack_pool = joint_stracks(tracked_stracks, this->lost_stracks);
+	STrack::multi_predict(strack_pool, this->kalman_filter);
+
+	vector<vector<float> > dists;
+	int dist_size = 0, dist_size_size = 0;
+	dists = iou_distance(strack_pool, detections, dist_size, dist_size_size);
+
+	vector<vector<int> > matches;
+	vector<int> u_track, u_detection;
+	linear_assignment(dists, dist_size, dist_size_size, match_thresh, matches, u_track, u_detection);
+
+	for (int i = 0; i < matches.size(); i++)
+	{
+		STrack *track = strack_pool[matches[i][0]];
+		STrack *det = &detections[matches[i][1]];
+		if (track->state == TrackState::Tracked)
+		{	
+			track->update(*det, this->frame_id);
+			activated_stracks.push_back(*track);
+		}
+		else
+		{
+			track->re_activate(*det, this->frame_id, false);
+			refind_stracks.push_back(*track);
+		}
+	}
+
+	////////////////// Step 3: Second association, using low score dets //////////////////
+	for (int i = 0; i < u_detection.size(); i++)
+	{
+		detections_cp.push_back(detections[u_detection[i]]);
+	}
+	detections.clear();
+	detections.assign(detections_low.begin(), detections_low.end());
+	
+	for (int i = 0; i < u_track.size(); i++)
+	{
+		if (strack_pool[u_track[i]]->state == TrackState::Tracked)
+		{
+			r_tracked_stracks.push_back(strack_pool[u_track[i]]);
+		}
+	}
+
+	dists.clear();
+	dists = iou_distance(r_tracked_stracks, detections, dist_size, dist_size_size);
+
+	matches.clear();
+	u_track.clear();
+	u_detection.clear();
+	linear_assignment(dists, dist_size, dist_size_size, 0.5, matches, u_track, u_detection);
+
+	for (int i = 0; i < matches.size(); i++)
+	{
+		STrack *track = r_tracked_stracks[matches[i][0]];
+		STrack *det = &detections[matches[i][1]];
+		if (track->state == TrackState::Tracked)
+		{
+			track->update(*det, this->frame_id);
+			activated_stracks.push_back(*track);
+		}
+		else
+		{
+			track->re_activate(*det, this->frame_id, false);
+			refind_stracks.push_back(*track);
+		}
+	}
+
+	for (int i = 0; i < u_track.size(); i++)
+	{
+		STrack *track = r_tracked_stracks[u_track[i]];
+		if (track->state != TrackState::Lost)
+		{
+			track->mark_lost();
+			lost_stracks.push_back(*track);
+		}
+	}
+
+	// Deal with unconfirmed tracks, usually tracks with only one beginning frame
+	detections.clear();
+	detections.assign(detections_cp.begin(), detections_cp.end());
+
+	dists.clear();
+	dists = iou_distance(unconfirmed, detections, dist_size, dist_size_size);
+
+	matches.clear();
+	vector<int> u_unconfirmed;
+	u_detection.clear();
+	linear_assignment(dists, dist_size, dist_size_size, 0.7, matches, u_unconfirmed, u_detection);
+
+	for (int i = 0; i < matches.size(); i++)
+	{
+		unconfirmed[matches[i][0]]->update(detections[matches[i][1]], this->frame_id);
+		activated_stracks.push_back(*unconfirmed[matches[i][0]]);
+	}
+
+	for (int i = 0; i < u_unconfirmed.size(); i++)
+	{
+		STrack *track = unconfirmed[u_unconfirmed[i]];
+		track->mark_removed();
+		removed_stracks.push_back(*track);
+	}
+
+	////////////////// Step 4: Init new stracks //////////////////
+	for (int i = 0; i < u_detection.size(); i++)
+	{
+		STrack *track = &detections[u_detection[i]];
+		if (track->score < this->high_thresh)
+			continue;
+		track->activate(this->kalman_filter, this->frame_id);
+		activated_stracks.push_back(*track);
+	}
+
+	////////////////// Step 5: Update state //////////////////
+	for (int i = 0; i < this->lost_stracks.size(); i++)
+	{
+		if (this->frame_id - this->lost_stracks[i].end_frame() > this->max_time_lost)
+		{
+			this->lost_stracks[i].mark_removed();
+			removed_stracks.push_back(this->lost_stracks[i]);
+		}
+	}
+	
+	for (int i = 0; i < this->tracked_stracks.size(); i++)
+	{
+		if (this->tracked_stracks[i].state == TrackState::Tracked)
+		{
+			tracked_stracks_swap.push_back(this->tracked_stracks[i]);
+		}
+	}
+	this->tracked_stracks.clear();
+	this->tracked_stracks.assign(tracked_stracks_swap.begin(), tracked_stracks_swap.end());
+
+	this->tracked_stracks = joint_stracks(this->tracked_stracks, activated_stracks);
+	this->tracked_stracks = joint_stracks(this->tracked_stracks, refind_stracks);
+
+	//std::cout << activated_stracks.size() << std::endl;
+
+	this->lost_stracks = sub_stracks(this->lost_stracks, this->tracked_stracks);
+	for (int i = 0; i < lost_stracks.size(); i++)
+	{
+		this->lost_stracks.push_back(lost_stracks[i]);
+	}
+
+	this->lost_stracks = sub_stracks(this->lost_stracks, this->removed_stracks);
+	for (int i = 0; i < removed_stracks.size(); i++)
+	{
+		this->removed_stracks.push_back(removed_stracks[i]);
+	}
+	
+	remove_duplicate_stracks(resa, resb, this->tracked_stracks, this->lost_stracks);
+
+	this->tracked_stracks.clear();
+	this->tracked_stracks.assign(resa.begin(), resa.end());
+	this->lost_stracks.clear();
+	this->lost_stracks.assign(resb.begin(), resb.end());
+	
+	for (int i = 0; i < this->tracked_stracks.size(); i++)
+	{
+		if (this->tracked_stracks[i].is_activated)
+		{
+			output_stracks.push_back(this->tracked_stracks[i]);
+		}
+	}
+	return output_stracks;
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/src/STrack.cpp b/C++/yolo_bytetrack/src/STrack.cpp
new file mode 100644
index 00000000..40a54b13
--- /dev/null
+++ b/C++/yolo_bytetrack/src/STrack.cpp
@@ -0,0 +1,199 @@
+#include "STrack.h"
+#include "dataType.h"
+#include <iostream>
+
+STrack::STrack(vector<float> tlwh_, float score)
+{
+	_tlwh.resize(4);
+	_tlwh.assign(tlwh_.begin(), tlwh_.end());
+
+	is_activated = false;
+	track_id = 0;
+	state = TrackState::New;
+	
+	tlwh.resize(4);
+	tlbr.resize(4);
+
+	static_tlwh();
+	static_tlbr();
+	frame_id = 0;
+	tracklet_len = 0;
+	this->score = score;
+	start_frame = 0;
+}
+
+STrack::~STrack()
+{
+}
+
+void STrack::activate(byte_kalman::KalmanFilter &kalman_filter, int frame_id)
+{
+	this->kalman_filter = kalman_filter;
+	this->track_id = this->next_id();
+
+	vector<float> _tlwh_tmp(4);
+	_tlwh_tmp[0] = this->_tlwh[0];
+	_tlwh_tmp[1] = this->_tlwh[1];
+	_tlwh_tmp[2] = this->_tlwh[2];
+	_tlwh_tmp[3] = this->_tlwh[3];
+	vector<float> xyah = tlwh_to_xyah(_tlwh_tmp);
+	DETECTBOX xyah_box;
+	xyah_box[0] = xyah[0];
+	xyah_box[1] = xyah[1];
+	xyah_box[2] = xyah[2];
+	xyah_box[3] = xyah[3];
+	auto mc = this->kalman_filter.initiate(xyah_box);
+	this->mean = mc.first;
+	this->covariance = mc.second;
+
+	static_tlwh();
+	static_tlbr();
+
+	this->tracklet_len = 0;
+	this->state = TrackState::Tracked;
+	if (frame_id == 1)
+	{
+		this->is_activated = true;
+	}
+	//this->is_activated = true;
+	this->frame_id = frame_id;
+	this->start_frame = frame_id;
+}
+
+void STrack::re_activate(STrack &new_track, int frame_id, bool new_id)
+{
+	vector<float> xyah = tlwh_to_xyah(new_track.tlwh);
+	DETECTBOX xyah_box;
+	xyah_box[0] = xyah[0];
+	xyah_box[1] = xyah[1];
+	xyah_box[2] = xyah[2];
+	xyah_box[3] = xyah[3];
+	auto mc = this->kalman_filter.update(this->mean, this->covariance, xyah_box);
+	this->mean = mc.first;
+	this->covariance = mc.second;
+
+	static_tlwh();
+	static_tlbr();
+
+	this->tracklet_len = 0;
+	this->state = TrackState::Tracked;
+	this->is_activated = true;
+	this->frame_id = frame_id;
+	this->score = new_track.score;
+	if (new_id)
+		this->track_id = next_id();
+}
+
+void STrack::update(STrack &new_track, int frame_id)
+{
+	this->frame_id = frame_id;
+	this->tracklet_len++;
+
+	vector<float> xyah = tlwh_to_xyah(new_track.tlwh);
+	DETECTBOX xyah_box;
+	xyah_box[0] = xyah[0];
+	xyah_box[1] = xyah[1];
+	xyah_box[2] = xyah[2];
+	xyah_box[3] = xyah[3];
+
+	// cout << "start kf update1" << endl;
+	// cout << this->mean[0] << " " <<  this->mean[1] << " " << this->mean[2] << " " << this->mean[3] << endl;
+	auto mc = this->kalman_filter.update(this->mean, this->covariance, xyah_box);
+	this->mean = mc.first;
+	this->covariance = mc.second;
+	// cout << "end kf update1" << endl;
+
+	static_tlwh();
+	static_tlbr();
+
+	this->state = TrackState::Tracked;
+	this->is_activated = true;
+
+	this->score = new_track.score;
+}
+
+void STrack::static_tlwh()
+{
+	if (this->state == TrackState::New)
+	{
+		tlwh[0] = _tlwh[0];
+		tlwh[1] = _tlwh[1];
+		tlwh[2] = _tlwh[2];
+		tlwh[3] = _tlwh[3];
+		return;
+	}
+
+	tlwh[0] = mean[0];
+	tlwh[1] = mean[1];
+	tlwh[2] = mean[2];
+	tlwh[3] = mean[3];
+
+	tlwh[2] *= tlwh[3];
+	tlwh[0] -= tlwh[2] / 2;
+	tlwh[1] -= tlwh[3] / 2;
+}
+
+void STrack::static_tlbr()
+{
+	tlbr.clear();
+	tlbr.assign(tlwh.begin(), tlwh.end());
+	tlbr[2] += tlbr[0];
+	tlbr[3] += tlbr[1];
+}
+
+vector<float> STrack::tlwh_to_xyah(vector<float> tlwh_tmp)
+{
+	vector<float> tlwh_output = tlwh_tmp;
+	tlwh_output[0] += tlwh_output[2] / 2;
+	tlwh_output[1] += tlwh_output[3] / 2;
+	tlwh_output[2] /= tlwh_output[3];
+	return tlwh_output;
+}
+
+vector<float> STrack::to_xyah()
+{
+	return tlwh_to_xyah(tlwh);
+}
+
+vector<float> STrack::tlbr_to_tlwh(vector<float> &tlbr)
+{
+	tlbr[2] -= tlbr[0];
+	tlbr[3] -= tlbr[1];
+	return tlbr;
+}
+
+void STrack::mark_lost()
+{
+	state = TrackState::Lost;
+}
+
+void STrack::mark_removed()
+{
+	state = TrackState::Removed;
+}
+
+int STrack::next_id()
+{
+	static int _count = 0;
+	_count++;
+	return _count;
+}
+
+int STrack::end_frame()
+{
+	return this->frame_id;
+}
+
+void STrack::multi_predict(vector<STrack*> &stracks, byte_kalman::KalmanFilter &kalman_filter)
+{
+	for (int i = 0; i < stracks.size(); i++)
+	{
+		if (stracks[i]->state != TrackState::Tracked)
+		{
+			stracks[i]->mean[7] = 0;
+		}
+		kalman_filter.predict(stracks[i]->mean, stracks[i]->covariance);
+		stracks[i]->static_tlwh();
+		stracks[i]->static_tlbr();
+	}
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/src/bytetrack.cpp b/C++/yolo_bytetrack/src/bytetrack.cpp
new file mode 100644
index 00000000..c0a78565
--- /dev/null
+++ b/C++/yolo_bytetrack/src/bytetrack.cpp
@@ -0,0 +1,764 @@
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <numeric>
+#include <chrono>
+#include <vector>
+#include <openssl/sha.h>
+#include <openssl/evp.h>
+#include <curl/curl.h>
+#include <ctime>
+#include <cstring>
+#include <unistd.h>
+#include <atomic>
+#include <thread>
+#include <chrono>
+#include <string>
+#include <dirent.h>
+#include <sys/time.h>
+#include "BYTETracker.h"
+#include "rknn_api.h"
+#include "opencv2/core/core.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/video.hpp"
+#include <unordered_set>
+
+unordered_set<int> low_id; //下行行人id集合
+unordered_set<int> up_id; //上行行人id集合
+unordered_set<int> total_region1; //在基准线下方的行人id存入该集合
+unordered_set<int> total_region2; //在基准线上方的行人id存入该集合
+
+#define CHECK(status) \
+    do\
+    {\
+        auto ret = (status);\
+        if (ret != 0)\
+        {\
+            cerr << "Cuda failure: " << ret << endl;\
+            abort();\
+        }\
+    } while (0)
+
+#define NMS_THRESH 0.45                      // NMS阈值
+#define NUM_ANCHORS 3                        // anchor的数量
+#define NUM_CLASSES 80                       // 类别数
+#define BBOX_CONF_THRESH 0.25                // 置信度阈值
+#define OBJ_NUMB_MAX_SIZE 64                 // 最多检测的目标数
+
+static const int INPUT_W = 640;              // 模型输入width
+static const int INPUT_H = 640;              // 模型输入height
+const int anchor[3][6] = {10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326};
+const string label_name[1] = {"person"};
+
+
+#define MAC_ADDRESS_LENGTH 18
+#define LICENSE_KEY_LENGTH 10
+static char mac_address[MAC_ADDRESS_LENGTH];
+std::atomic<bool> is_algorithm_running(true);
+
+//设备的 MAC 地址
+void set_mac_address(const char *mac) {
+    strncpy(mac_address, mac, 17);
+    mac_address[17] = '\0';
+}
+
+// Base64 编码
+void base64_encode(const unsigned char *input, int length, char *output) {
+    EVP_ENCODE_CTX *ctx = EVP_ENCODE_CTX_new();
+    int outlen;
+    EVP_EncodeInit(ctx);
+    EVP_EncodeUpdate(ctx, (unsigned char *)output, &outlen, input, length);
+    EVP_EncodeFinal(ctx, (unsigned char *)(output + outlen), &outlen);
+    EVP_ENCODE_CTX_free(ctx);
+}
+
+// 生成授权码（使用 SHA-256 哈希算法，并进行 Base64 编码）
+void generate_license_key(const char *mac_address, char *license_key) {
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+    SHA256_CTX sha256;
+    SHA256_Init(&sha256);
+    SHA256_Update(&sha256, mac_address, strlen(mac_address));
+    SHA256_Final(hash, &sha256);
+    char base64_output[65];
+    base64_encode(hash, SHA256_DIGEST_LENGTH, base64_output);
+    strncpy(license_key, base64_output, LICENSE_KEY_LENGTH - 1);
+    license_key[LICENSE_KEY_LENGTH - 1] = '\0';
+}
+
+// 验证授权码是否有效
+bool validate_license_key(const char *license_key, const char *input_license_key) {
+    return strcmp(input_license_key, license_key) == 0;
+}
+
+// 检查授权是否过期
+void check_license_thread() {
+    // 固定到期时间为 2024 年 7 月 10 日，0 点（UTC 时间）
+    std::tm expiration_time = {};
+    expiration_time.tm_year = 2024 - 1900; // 年份从 1900 年开始计算
+    expiration_time.tm_mon = 7; // 月份从 0 开始计算（7 月为 6）
+    expiration_time.tm_mday = 1; // 日
+    // 转换为时间戳
+    std::time_t expiration_timestamp = std::mktime(&expiration_time);
+    while (true) {
+        std::this_thread::sleep_for(std::chrono::hours(12)); // 每秒检查一次
+        // 获取当前时间
+        std::time_t now = std::time(nullptr);
+        // 检查授权是否过期
+        if (now > expiration_timestamp) {
+            std::cout << "License has expired. Stopping algorithm..." << std::endl;
+            is_algorithm_running.store(false);
+            break;
+        }
+    }
+}
+
+cv::Mat static_resize(cv::Mat& img) {
+    float r = min(INPUT_W / (img.cols*1.0), INPUT_H / (img.rows*1.0));
+    // r = std::min(r, 1.0f);
+    int unpad_w = r * img.cols;
+    int unpad_h = r * img.rows;
+    cv::Mat re(unpad_h, unpad_w, CV_8UC3);
+    cv::resize(img, re, re.size());
+    cv::Mat out(INPUT_H, INPUT_W, CV_8UC3, cv::Scalar(114, 114, 114));
+    re.copyTo(out(Rect(0, 0, re.cols, re.rows)));
+    return out;
+}
+
+struct GridAndStride
+{
+    int grid0; // grid_w：模型输入width/stride   width方向的网格数量
+    int grid1; // grid_h：模型输入height/stride    height方向的网格数量
+    int stride; // 下采样倍数，取值有8、16、32
+};
+
+static void check_ret(int ret, string ret_name)
+{
+    // 检查ret是否正确并输出，ret_name表示哪一步
+    if (ret < 0)
+    {
+        cout << ret_name << " error ret=" << ret << endl;
+    }
+}
+
+static void dump_tensor_attr(rknn_tensor_attr *attr)
+{
+    // 打印模型输入和输出的信息
+    printf("  index=%d, name=%s, n_dims=%d, dims=[%d, %d, %d, %d], n_elems=%d, size=%d, fmt=%s, type=%s, qnt_type=%s, "
+           "zp=%d, scale=%f\n",
+           attr->index, attr->name, attr->n_dims, attr->dims[3], attr->dims[2], attr->dims[1], attr->dims[0],
+           attr->n_elems, attr->size, get_format_string(attr->fmt), get_type_string(attr->type),
+           get_qnt_type_string(attr->qnt_type), attr->zp, attr->scale);
+}
+
+// t为结构体，存储了时间信息：1、tv_sec 代表多少秒；2、tv_usec 代表多少微秒， 1000000 微秒 = 1秒
+double __get_us(struct timeval t) { return (t.tv_sec * 1000000 + t.tv_usec);} 
+
+static float sigmoid(float x)
+{
+    return 1.0 / (1.0 + expf(-x));
+}
+
+static float unsigmoid(float y)
+{
+    return -1.0 * logf((1.0 / y) - 1.0);
+}
+
+inline static int32_t __clip(float val, float min, float max)
+{
+    float f = val <= min ? min : (val >= max ? max : val);
+    return f;
+}
+
+static int8_t qnt_f32_to_affine(float f32, int32_t zp, float scale)  // 量化
+{
+    float dst_val = (f32 / scale) + zp;
+    int8_t res = (int8_t)__clip(dst_val, -128, 127);
+    return res;
+}
+
+static uint8_t qnt_f32_to_affine_u8(float f32, int32_t zp, float scale)
+{
+    float dst_val = (f32 / scale) + zp;
+    uint8_t res = (uint8_t)__clip(dst_val, 0, 255);
+    return res;
+}
+
+static float deqnt_affine_to_f32(int8_t qnt, int32_t zp, float scale)  // 反量化
+{
+    return ((float)qnt - (float)zp) * scale;
+}
+
+static float deqnt_affine_u8_to_f32(uint8_t qnt, int32_t zp, float scale) { return ((float)qnt - (float)zp) * scale; }
+
+static void generate_grids_and_stride(const int target_w, const int target_h, vector<int>& strides, vector<GridAndStride>& grid_strides)
+{
+    for (auto stride : strides)
+    {
+        int num_grid_w = target_w / stride;
+        int num_grid_h = target_h / stride;
+        
+        for (int g1 = 0; g1 < num_grid_h; g1++)
+        {
+            for (int g0 = 0; g0 < num_grid_w; g0++)
+            {
+                grid_strides.push_back((GridAndStride){g0, g1, stride});
+            }
+        }
+    }
+}
+static void generate_grids(const int target_w, const int target_h, vector<int>& strides, vector<GridAndStride>& grid_strides)
+{
+    for (auto stride : strides)
+    {
+        int num_grid_w = target_w / stride;
+        int num_grid_h = target_h / stride;
+        grid_strides.push_back((GridAndStride){num_grid_w, num_grid_h, stride});
+        
+    }
+}
+
+static inline float intersection_area(const Object& a, const Object& b)
+{
+    Rect_<float> inter = a.rect & b.rect;
+    return inter.area();
+}
+
+static void qsort_descent_inplace(vector<Object>& faceobjects, int left, int right)
+{
+    int i = left;
+    int j = right;
+    float p = faceobjects[(left + right) / 2].prob;
+
+    while (i <= j)
+    {
+        while (faceobjects[i].prob > p)
+            i++;
+
+        while (faceobjects[j].prob < p)
+            j--;
+
+        if (i <= j)
+        {
+            std::swap(faceobjects[i], faceobjects[j]);
+            i++;
+            j--;
+        }
+    }
+
+    #pragma omp parallel sections
+    {
+        #pragma omp section
+        {
+            if (left < j) qsort_descent_inplace(faceobjects, left, j);
+        }
+        #pragma omp section
+        {
+            if (i < right) qsort_descent_inplace(faceobjects, i, right);
+        }
+    }
+}
+
+static void qsort_descent_inplace(vector<Object>& objects)
+{
+    if (objects.empty())
+        return;
+
+    qsort_descent_inplace(objects, 0, objects.size() - 1);
+}
+
+static void nms_sorted_bboxes(const vector<Object>& faceobjects, vector<int>& picked, float nms_threshold)
+{
+    picked.clear();
+
+    const int n = faceobjects.size();
+
+    vector<float> areas(n);
+    for (int i = 0; i < n; i++)
+    {
+        areas[i] = faceobjects[i].rect.area();
+    }
+
+    for (int i = 0; i < n; i++)
+    {
+        const Object& a = faceobjects[i];
+
+        int keep = 1;
+        for (int j = 0; j < (int)picked.size(); j++)
+        {
+            const Object& b = faceobjects[picked[j]];
+            float inter_area = intersection_area(a, b);
+            float union_area = areas[i] + areas[picked[j]] - inter_area;
+            if (inter_area / union_area > nms_threshold)
+                keep = 0;
+        }
+
+        if (keep)
+            picked.push_back(i);
+    }
+}
+
+static void generate_yolo_proposals(GridAndStride grid_stride, uint8_t *output, int *anchor, float prob_threshold, vector<Object>& objects, int32_t zp, float scale)
+{
+    const int num_class = NUM_CLASSES;
+    const int num_anchors = NUM_ANCHORS;
+    const int grid0 = grid_stride.grid0;
+    const int grid1 = grid_stride.grid1;
+    const int stride = grid_stride.stride;
+    int grid_len = grid0 * grid1;
+    uint8_t thres_u8 = qnt_f32_to_affine_u8(prob_threshold, zp, scale);
+
+    for (int anchor_idx = 0; anchor_idx < num_anchors; anchor_idx++)
+    {
+        for (int i = 0; i < grid1; i++)
+        {
+            for (int j = 0; j < grid0; j++)
+            {
+                uint8_t box_objectness = output[(anchor_idx * (num_class + 5) + 4) * grid_len + i * grid0 + j];
+                if (box_objectness >= thres_u8)
+                {
+                    int basic_pos = anchor_idx * (num_class + 5) * grid_len + i * grid0 + j;;
+                    uint8_t *in_ptr = output + basic_pos;
+                    float box_x = (deqnt_affine_u8_to_f32(*in_ptr, zp, scale)) * 2.0 - 0.5;
+                    float box_y = (deqnt_affine_u8_to_f32(in_ptr[grid_len], zp, scale)) * 2.0 - 0.5;
+                    float box_w = (deqnt_affine_u8_to_f32(in_ptr[2 * grid_len], zp, scale)) * 2.0;
+                    float box_h = (deqnt_affine_u8_to_f32(in_ptr[3 * grid_len], zp, scale)) * 2.0;
+                    float x_center = (box_x + j) * (float)stride;
+                    float y_center = (box_y + i) * (float)stride;
+                    float w = box_w * box_w * (float)anchor[anchor_idx * 2];
+                    float h = box_h * box_h * (float)anchor[anchor_idx * 2 + 1];
+                    float x0 = x_center - w * 0.5f;
+                    float y0 = y_center - h * 0.5f;
+
+                    uint8_t maxClassProbs = in_ptr[5 * grid_len];
+                    int maxClassId = 0;
+                    for (int class_idx = 0; class_idx < num_class; class_idx++)
+                    {
+                        uint8_t prob = in_ptr[(5 + class_idx) * grid_len];
+                        if (prob > maxClassProbs)
+                        {
+                            maxClassId = class_idx;
+                            maxClassProbs = prob;
+                        }
+                    }
+
+                    if(maxClassId != 0)
+                        continue;
+
+                    if(maxClassProbs > thres_u8)
+                    {
+                        Object obj;
+                        obj.rect.x = x0;
+                        obj.rect.y = y0;
+                        obj.rect.width = w;
+                        obj.rect.height = h;
+                        obj.label = maxClassId;
+                        obj.prob = (deqnt_affine_u8_to_f32(maxClassProbs, zp, scale));
+                        objects.push_back(obj);
+                    }
+                }
+            }
+        }
+    }
+}
+float* blobFromImage(cv::Mat& img){
+    // 归一化操作 将原始图像拉成一维数组了
+    cvtColor(img, img, COLOR_BGR2RGB);
+
+    float* blob = new float[img.total()*3]; 
+    int channels = 3;
+    int img_h = img.rows;
+    int img_w = img.cols;
+    vector<float> mean = {0.485, 0.456, 0.406};
+    vector<float> std = {0.229, 0.224, 0.225};
+    for (size_t c = 0; c < channels; c++) 
+    {
+        for (size_t  h = 0; h < img_h; h++) 
+        {
+            for (size_t w = 0; w < img_w; w++) 
+            {
+                blob[c * img_w * img_h + h * img_w + w] =
+                    (((float)img.at<Vec3b>(h, w)[c]) / 255.0f - mean[c]) / std[c];
+            }
+        }
+    }
+    return blob;
+}
+
+static void decode_outputs(rknn_output *outputs, vector<Object>& objects, float resize_scale, const int img_w, const int img_h, int32_t *qnt_zps, float *qnt_scales) {
+        vector<Object> proposals;
+        vector<int> strides = {8, 16, 32};
+        vector<GridAndStride> grid_strides;
+        generate_grids(INPUT_W, INPUT_H, strides, grid_strides);
+        for(int i = 0; i < 3; i++){
+            generate_yolo_proposals(grid_strides[i], (uint8_t *)outputs[i].buf, (int *)anchor[i], BBOX_CONF_THRESH, proposals, qnt_zps[i], qnt_scales[i]);
+        }
+        // std::cout << "num of boxes before nms: " << proposals.size() << std::endl;
+
+        qsort_descent_inplace(proposals);
+
+        vector<int> picked;
+        nms_sorted_bboxes(proposals, picked, NMS_THRESH);
+        int count = picked.size();
+        // std::cout << "num of boxes: " << count << std::endl;
+        objects.resize(count);
+        for (int i = 0; i < count; i++)
+        {
+            objects[i] = proposals[picked[i]];
+            float x0 = (objects[i].rect.x) / resize_scale;
+            float y0 = (objects[i].rect.y) / resize_scale;
+            float x1 = (objects[i].rect.x + objects[i].rect.width) / resize_scale;
+            float y1 = (objects[i].rect.y + objects[i].rect.height) / resize_scale;
+            objects[i].rect.x = x0;
+            objects[i].rect.y = y0;
+            objects[i].rect.width = x1 - x0;
+            objects[i].rect.height = y1 - y0;
+        }
+}
+
+static unsigned char *load_data(FILE *fp, size_t ofst, size_t sz)
+{
+    unsigned char *data;
+    int ret;
+
+    data = NULL;
+
+    if (NULL == fp)
+    {
+        return NULL;
+    }
+
+    ret = fseek(fp, ofst, SEEK_SET);
+    if (ret != 0)
+    {
+        printf("blob seek failure.\n");
+        return NULL;
+    }
+
+    data = (unsigned char *)malloc(sz);
+    if (data == NULL)
+    {
+        printf("buffer malloc failure.\n");
+        return NULL;
+    }
+    ret = fread(data, 1, sz, fp);
+    return data;
+}
+
+static unsigned char *load_model(const char *filename, int *model_size)
+{
+    /* 
+    加载rknn模型
+    filename : rknn模型文件路径
+    model_size : 模型的大小
+    */
+    FILE *fp;
+    unsigned char *data;
+
+    fp = fopen(filename, "rb");
+    if (NULL == fp)
+    {
+        printf("Open rknn model file %s failed.\n", filename);
+        return NULL;
+    }
+
+    fseek(fp, 0, SEEK_END);
+    int size = ftell(fp);
+
+    data = load_data(fp, 0, size);
+
+    fclose(fp);
+
+    *model_size = size;
+    return data;
+}
+
+
+void run_algorithm(const std::vector<std::string>& params) 
+{
+
+    size_t length = params.size();
+    const char *model_name = params[0].c_str();
+ 
+    /********************rknn init*********************/
+    string ret_name;
+    ret_name = "rknn_init"; // 表示rknn的步骤名称
+    rknn_context ctx; // 创建rknn_context对象
+    int model_data_size = 0; // 模型的大小
+    unsigned char *model_data = load_model(model_name, &model_data_size); // 加载RKNN模型
+    /* 初始化参数flag
+    RKNN_FLAG_COLLECT_PERF_MASK：用于运行时查询网络各层时间。
+    RKNN_FLAG_MEM_ALLOC_OUTSIDE：用于表示模型输入、输出、权重、中间 tensor 内存全部由用户分配。
+    */
+    // int ret = rknn_init(&ctx, model_data, model_data_size, RKNN_FLAG_COLLECT_PERF_MASK, NULL); // 初始化RKNN
+    int ret = rknn_init(&ctx, model_data, model_data_size, 0);
+    check_ret(ret, ret_name);
+    // 设置NPU核心为自动调度
+    // rknn_core_mask core_mask = RKNN_NPU_CORE_AUTO;
+    // ret = rknn_set_core_mask(ctx, core_mask);
+    
+    /********************rknn query*********************/
+    // rknn_query 函数能够查询获取到模型输入输出信息、逐层运行时间、模型推理的总时间、
+    // SDK 版本、内存占用信息、用户自定义字符串等信息。
+    // 版本信息
+    ret_name = "rknn_query";
+    rknn_sdk_version version; // SDK版本信息结构体
+    ret = rknn_query(ctx, RKNN_QUERY_SDK_VERSION, &version, sizeof(rknn_sdk_version));
+    check_ret(ret, ret_name);
+    printf("sdk api version: %s\n", version.api_version);
+    printf("driver version: %s\n", version.drv_version);
+
+    // 输入输出信息
+    rknn_input_output_num io_num;
+    ret = rknn_query(ctx, RKNN_QUERY_IN_OUT_NUM, &io_num, sizeof(io_num));
+    check_ret(ret, ret_name);
+    printf("model input num: %d, output num: %d\n", io_num.n_input, io_num.n_output);
+
+    // 输入输出Tensor属性
+    rknn_tensor_attr input_attrs[io_num.n_input];
+    memset(input_attrs, 0, sizeof(input_attrs)); // 初始化内存
+    for (int i = 0; i < io_num.n_input; i++)
+    {
+        input_attrs[i].index = i; // 输入的索引位置
+        ret = rknn_query(ctx, RKNN_QUERY_INPUT_ATTR, &(input_attrs[i]), sizeof(rknn_tensor_attr));
+        check_ret(ret, ret_name);
+        dump_tensor_attr(&(input_attrs[i]));
+    }
+
+    rknn_tensor_attr output_attrs[io_num.n_output];
+    memset(output_attrs, 0, sizeof(output_attrs));
+    for (int i = 0; i < io_num.n_output; i++)
+    {
+        output_attrs[i].index = i;
+        ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(output_attrs[i]), sizeof(rknn_tensor_attr));
+        check_ret(ret, ret_name);
+        dump_tensor_attr(&(output_attrs[i]));
+    }
+
+    // 模型输入信息
+    int channel = 3;
+    int width = 0;
+    int height = 0;
+    if (input_attrs[0].fmt == RKNN_TENSOR_NCHW)
+    {
+        printf("model is NCHW input fmt\n");
+        channel = input_attrs[0].dims[2];
+        width = input_attrs[0].dims[0];
+        height = input_attrs[0].dims[1];
+    }
+    else
+    {
+        printf("model is NHWC input fmt\n");
+        width = input_attrs[0].dims[1];
+        height = input_attrs[0].dims[2];
+        channel = input_attrs[0].dims[3];
+    }
+
+    
+    const string input_video_path {params[1]};
+    static float* prob = new float[OBJ_NUMB_MAX_SIZE]; 
+
+    cv::VideoCapture cap;
+    cap.open(input_video_path);
+	if (!cap.isOpened()){
+        printf("video can't open\n");
+    }
+
+	int img_w = cap.get(cv::CAP_PROP_FRAME_WIDTH);
+	int img_h = cap.get(cv::CAP_PROP_FRAME_HEIGHT);
+    int fps = cap.get(cv::CAP_PROP_FPS);
+
+    const int baseline = (length > 3) ? std::atoi(params[2].c_str()) : img_h / 2; //如果没有输入，划线纵坐标为视频高度一般
+    const int x_min = (length > 4) ? std::atoi(params[3].c_str()) : 0;
+    const int x_max = (length > 5) ? std::atoi(params[4].c_str()) : img_w;  //如果没有输入，划线横坐标默认为整个视频
+
+
+    cv::Mat img;
+    BYTETracker tracker(fps, 50);
+    int num_frames = 0;
+	while (is_algorithm_running.load())
+    {
+        if(!cap.read(img))
+        {
+            cout <<" Break at cap.read(img) !" << endl;
+            break;
+        }
+        if (img.empty())
+        {
+			break;
+        }
+        num_frames++;
+        if (num_frames %2 ==0)
+        {
+            // TODO:
+            cv::Mat pr_img = static_resize(img); // resize图像
+            float resize_scale = min(INPUT_W / (img.cols*1.0), INPUT_H / (img.rows*1.0)); // 图像缩放尺度
+
+            /********************rknn inputs set*********************/
+            ret_name = "rknn_inputs_set";
+            rknn_input inputs[1];
+            memset(inputs, 0, sizeof(inputs));
+        
+            inputs[0].index = 0;                       // 输入的索引位置
+            inputs[0].type = RKNN_TENSOR_UINT8;        // 输入数据类型 采用INT8
+            inputs[0].size = 640 * 640 * 3;            // 这里用的是模型的
+            inputs[0].fmt = RKNN_TENSOR_NHWC;          // 输入格式，NHWC
+            inputs[0].pass_through = 0;                // 为0代表需要进行预处理
+            inputs[0].buf = pr_img.data;               // 如果进行resize需要改为resize的data
+
+            ret = rknn_inputs_set(ctx, io_num.n_input, inputs);
+            check_ret(ret, ret_name);
+
+            /********************rknn run****************************/
+            ret_name = "rknn_run";
+            ret = rknn_run(ctx, NULL); // 推理
+            check_ret(ret, ret_name);
+
+            /********************rknn outputs get****************************/
+            ret_name = "rknn_outputs_get";
+            float out_scales[3] = {0, 0, 0}; // 存储scales 和 zp
+            int32_t out_zps[3] = {0, 0, 0};
+            // 创建rknn_output对象
+            rknn_output outputs[io_num.n_output];
+            memset(outputs, 0, sizeof(outputs));
+            for (int i = 0; i < io_num.n_output; i++) 
+            { 
+                outputs[i].index = i; // 输出索引
+                // outputs[i].is_prealloc = 0; // 由rknn来分配输出的buf，指向输出数据
+                outputs[i].want_float = 0;
+                out_scales[i] = output_attrs[i].scale;
+                out_zps[i] = output_attrs[i].zp; 
+            }
+            ret = rknn_outputs_get(ctx, io_num.n_output, outputs, NULL);
+
+            /********************是否打印推理时间细节****************************/
+            ret_name = "rknn_perf_detail_display";
+            rknn_perf_detail perf_detail;
+            ret = rknn_query(ctx, RKNN_QUERY_PERF_DETAIL, &perf_detail, sizeof(perf_detail));
+            check_ret(ret, ret_name);
+            // printf("%s\n",perf_detail.perf_data);
+
+            // 解码推理结果并进行跟踪
+            vector<Object> objects;
+            decode_outputs(outputs, objects, resize_scale, img_w, img_h, out_zps, out_scales);
+            vector<STrack> output_stracks = tracker.update(objects);
+    
+
+            for (int i = 0; i < output_stracks.size(); i++)
+            {
+                vector<float> tlwh = output_stracks[i].tlwh;
+                cv::Scalar s = tracker.get_color(output_stracks[i].track_id);
+                int x1 = tlwh[0];
+                int y1 = tlwh[1];
+                int cx = int(x1 + tlwh[2] / 2);
+                int cy = y1 + tlwh[3];
+                int id = output_stracks[i].track_id;
+                if(!(cx > x_min && cx < x_max))
+                    continue;
+                if(cy > baseline)
+                {
+                    if(total_region2.find(id) != total_region2.end() && total_region1.find(id) == total_region1.end())
+                    {
+                        low_id.insert(id);
+                    }
+                    total_region1.insert(id);
+                }
+                else if(cy < baseline)
+                {
+                    if(total_region1.find(id) != total_region1.end() && total_region2.find(id) == total_region2.end())
+                    {
+                        up_id.insert(id);
+                    }
+                    total_region2.insert(id);
+                }
+            }
+
+        }
+
+        if (num_frames % 600 ==0){
+            // TODO: 10min
+            CURL *curl;
+            CURLcode res;
+            // 初始化 libcurl
+            curl_global_init(CURL_GLOBAL_DEFAULT);
+            curl = curl_easy_init();
+            if(curl) {
+                // 设置 URL
+                curl_easy_setopt(curl, CURLOPT_URL, "http://localhost:9999");
+
+                // 设置 POST 数据
+                std::string message = "up_nums: " + std::to_string(up_id.size()) + "\ndown_nums: " + std::to_string(low_id.size());
+                curl_easy_setopt(curl, CURLOPT_POSTFIELDS, message);
+
+                // 执行请求
+                res = curl_easy_perform(curl);
+
+                // 检查错误
+                if(res != CURLE_OK)
+                    std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
+
+                // 清理
+                curl_easy_cleanup(curl);
+            }
+            curl_global_cleanup();
+            printf("up_nums: %d \ndown_nums: %d \n", up_id.size(), low_id.size());
+            up_id.clear();
+            low_id.clear();
+        }
+    }
+    cap.release();
+}
+
+int main(int argc, char** argv){
+    if (argc < 3) 
+    {
+        std::cerr << "Usage: " << argv[0] << " <model path> <video path> [baseline] [x_min] [x_max]" << std::endl;
+        return 1;
+    }
+
+    // 输入设备的MAC地址
+    char mac_address[MAC_ADDRESS_LENGTH];
+    printf("Enter MAX ADDRESS: ");
+    fgets(mac_address, MAC_ADDRESS_LENGTH + 1, stdin);
+    mac_address[strcspn(mac_address, "\n")] = '\0'; // 去除换行符
+    set_mac_address(mac_address);
+
+    // 生成授权码
+    char license_key[LICENSE_KEY_LENGTH];
+    generate_license_key(mac_address, license_key);
+    std::cout << "Generated license key: " << license_key << std::endl;
+
+    // 用户输入授权码
+    char input_license_key[LICENSE_KEY_LENGTH];
+    printf("Enter License Key: ");
+    fgets(input_license_key, LICENSE_KEY_LENGTH + 1, stdin);
+    input_license_key[strcspn(input_license_key, "\n")] = '\0'; // 去除换行符
+
+    // 验证授权码是否有效
+    if (!validate_license_key(license_key, input_license_key)) {
+        std::cerr << "Invalid license key. Exiting..." << std::endl;
+        return 1;
+    }
+
+    // 解析算法参数
+    std::vector<std::string> algorithm_params;
+    for (int i = 1; i < argc; ++i) {
+        algorithm_params.push_back(argv[i]);
+    }
+
+    // 启动授权过期检查线程
+    std::thread check_thread(check_license_thread);
+
+    // 创建算法运行线程
+    std::thread run_thread(run_algorithm, algorithm_params);
+
+    // 等待算法运行线程结束
+    run_thread.join();
+
+    // 等待检查线程结束
+    check_thread.join();
+
+    return 0;
+
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/src/kalmanFilter.cpp b/C++/yolo_bytetrack/src/kalmanFilter.cpp
new file mode 100644
index 00000000..d1226b9c
--- /dev/null
+++ b/C++/yolo_bytetrack/src/kalmanFilter.cpp
@@ -0,0 +1,166 @@
+#include "kalmanFilter.h"
+#define EIGEN_DONT_ALIGN_STATICALLY
+#include <Eigen/Cholesky>
+#include <iostream>
+
+namespace byte_kalman
+{
+	const double KalmanFilter::chi2inv95[10] = {
+	0,
+	3.8415,
+	5.9915,
+	7.8147,
+	9.4877,
+	11.070,
+	12.592,
+	14.067,
+	15.507,
+	16.919
+	};
+	KalmanFilter::KalmanFilter()
+	{
+		int ndim = 4;
+		double dt = 1.;
+
+		_motion_mat = Eigen::MatrixXf::Identity(8, 8);
+		for (int i = 0; i < ndim; i++) {
+			_motion_mat(i, ndim + i) = dt;
+		}
+		_update_mat = Eigen::MatrixXf::Identity(4, 8);
+
+		this->_std_weight_position = 1. / 20;
+		this->_std_weight_velocity = 1. / 160;
+	}
+
+	KAL_DATA KalmanFilter::initiate(const DETECTBOX &measurement)
+	{
+		DETECTBOX mean_pos = measurement;
+		DETECTBOX mean_vel;
+		for (int i = 0; i < 4; i++) mean_vel(i) = 0;
+
+		KAL_MEAN mean;
+		for (int i = 0; i < 8; i++) {
+			if (i < 4) mean(i) = mean_pos(i);
+			else mean(i) = mean_vel(i - 4);
+		}
+
+		KAL_MEAN std;
+		std(0) = 2 * _std_weight_position * measurement[3];
+		std(1) = 2 * _std_weight_position * measurement[3];
+		std(2) = 1e-2;
+		std(3) = 2 * _std_weight_position * measurement[3];
+		std(4) = 10 * _std_weight_velocity * measurement[3];
+		std(5) = 10 * _std_weight_velocity * measurement[3];
+		std(6) = 1e-5;
+		std(7) = 10 * _std_weight_velocity * measurement[3];
+
+		KAL_MEAN tmp = std.array().square();
+		KAL_COVA var = tmp.asDiagonal();
+		return std::make_pair(mean, var);
+	}
+
+	void KalmanFilter::predict(KAL_MEAN &mean, KAL_COVA &covariance)
+	{
+		//revise the data;
+		DETECTBOX std_pos;
+		std_pos << _std_weight_position * mean(3),
+			_std_weight_position * mean(3),
+			1e-2,
+			_std_weight_position * mean(3);
+		DETECTBOX std_vel;
+		std_vel << _std_weight_velocity * mean(3),
+			_std_weight_velocity * mean(3),
+			1e-5,
+			_std_weight_velocity * mean(3);
+		KAL_MEAN tmp;
+		tmp.block<1, 4>(0, 0) = std_pos;
+		tmp.block<1, 4>(0, 4) = std_vel;
+		tmp = tmp.array().square();
+		KAL_COVA motion_cov = tmp.asDiagonal();
+		KAL_MEAN mean1 = this->_motion_mat * mean.transpose();
+		KAL_COVA covariance1 = this->_motion_mat * covariance *(_motion_mat.transpose());
+		covariance1 += motion_cov;
+
+		mean = mean1;
+		covariance = covariance1;
+	}
+
+	KAL_HDATA KalmanFilter::project(const KAL_MEAN &mean, const KAL_COVA &covariance)
+	{
+		// std::cout << "kf project" << std::endl;
+		DETECTBOX std;
+		std << _std_weight_position * mean(3), _std_weight_position * mean(3),
+			1e-1, _std_weight_position * mean(3);
+		// std::cout << "**********" << std::endl;
+		KAL_HMEAN mean1 = _update_mat * mean.transpose().eval();
+		// std::cout << "project 1" << std::endl;
+		KAL_HCOVA covariance1 = _update_mat * covariance * (_update_mat.transpose());
+		// std::cout << "project 2" << std::endl;
+		Eigen::Matrix<float, 4, 4> diag = std.asDiagonal();
+		diag = diag.array().square().matrix();
+		covariance1 += diag;
+		//    covariance1.diagonal() << diag;
+		return std::make_pair(mean1, covariance1);
+	}
+
+	KAL_DATA
+		KalmanFilter::update(
+			const KAL_MEAN &mean,
+			const KAL_COVA &covariance,
+			const DETECTBOX &measurement)
+	{
+		// std::cout << "kf update" << std::endl;
+		KAL_HDATA pa = project(mean, covariance);
+		KAL_HMEAN projected_mean = pa.first;
+		KAL_HCOVA projected_cov = pa.second;
+
+		//chol_factor, lower =
+		//scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
+		//kalmain_gain =
+		//scipy.linalg.cho_solve((cho_factor, lower),
+		//np.dot(covariance, self._upadte_mat.T).T,
+		//check_finite=False).T
+		
+		Eigen::Matrix<float, 4, 8> B = (covariance * (_update_mat.transpose())).transpose();
+		// std::cout << "step 1" << std::endl;
+		Eigen::Matrix<float, 8, 4> kalman_gain = (projected_cov.llt().solve(B)).transpose(); // eg.8x4
+		// std::cout << "step 2" << std::endl;
+		Eigen::Matrix<float, 1, 4> innovation = measurement - projected_mean; //eg.1x4
+		// std::cout << "step 3" << std::endl;
+		auto tmp = innovation * (kalman_gain.transpose());
+		// std::cout << "step 4" << std::endl;
+		KAL_MEAN new_mean = (mean.array() + tmp.array()).matrix();
+		// std::cout << "step 5" << std::endl;
+		KAL_COVA new_covariance = covariance - kalman_gain * projected_cov*(kalman_gain.transpose());
+		// std::cout << "step 6" << std::endl;
+		return std::make_pair(new_mean, new_covariance);
+	}
+
+	Eigen::Matrix<float, 1, -1>
+		KalmanFilter::gating_distance(
+			const KAL_MEAN &mean,
+			const KAL_COVA &covariance,
+			const std::vector<DETECTBOX> &measurements,
+			bool only_position)
+	{
+		KAL_HDATA pa = this->project(mean, covariance);
+		if (only_position) {
+			printf("not implement!");
+			exit(0);
+		}
+		KAL_HMEAN mean1 = pa.first;
+		KAL_HCOVA covariance1 = pa.second;
+
+		//    Eigen::Matrix<float, -1, 4, Eigen::RowMajor> d(size, 4);
+		DETECTBOXSS d(measurements.size(), 4);
+		int pos = 0;
+		for (DETECTBOX box : measurements) {
+			d.row(pos++) = box - mean1;
+		}
+		Eigen::Matrix<float, -1, -1, Eigen::RowMajor> factor = covariance1.llt().matrixL();
+		Eigen::Matrix<float, -1, -1> z = factor.triangularView<Eigen::Lower>().solve<Eigen::OnTheRight>(d).transpose();
+		auto zz = ((z.array())*(z.array())).matrix();
+		auto square_maha = zz.colwise().sum();
+		return square_maha;
+	}
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/src/lapjv.cpp b/C++/yolo_bytetrack/src/lapjv.cpp
new file mode 100644
index 00000000..169efd51
--- /dev/null
+++ b/C++/yolo_bytetrack/src/lapjv.cpp
@@ -0,0 +1,343 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "lapjv.h"
+
+/** Column-reduction and reduction transfer for a dense cost matrix.
+ */
+int_t _ccrrt_dense(const uint_t n, cost_t *cost[],
+	int_t *free_rows, int_t *x, int_t *y, cost_t *v)
+{
+	int_t n_free_rows;
+	boolean *unique;
+
+	for (uint_t i = 0; i < n; i++) {
+		x[i] = -1;
+		v[i] = LARGE;
+		y[i] = 0;
+	}
+	for (uint_t i = 0; i < n; i++) {
+		for (uint_t j = 0; j < n; j++) {
+			const cost_t c = cost[i][j];
+			if (c < v[j]) {
+				v[j] = c;
+				y[j] = i;
+			}
+			PRINTF("i=%d, j=%d, c[i,j]=%f, v[j]=%f y[j]=%d\n", i, j, c, v[j], y[j]);
+		}
+	}
+	PRINT_COST_ARRAY(v, n);
+	PRINT_INDEX_ARRAY(y, n);
+	NEW(unique, boolean, n);
+	memset(unique, TRUE, n);
+	{
+		int_t j = n;
+		do {
+			j--;
+			const int_t i = y[j];
+			if (x[i] < 0) {
+				x[i] = j;
+			}
+			else {
+				unique[i] = FALSE;
+				y[j] = -1;
+			}
+		} while (j > 0);
+	}
+	n_free_rows = 0;
+	for (uint_t i = 0; i < n; i++) {
+		if (x[i] < 0) {
+			free_rows[n_free_rows++] = i;
+		}
+		else if (unique[i]) {
+			const int_t j = x[i];
+			cost_t min = LARGE;
+			for (uint_t j2 = 0; j2 < n; j2++) {
+				if (j2 == (uint_t)j) {
+					continue;
+				}
+				const cost_t c = cost[i][j2] - v[j2];
+				if (c < min) {
+					min = c;
+				}
+			}
+			PRINTF("v[%d] = %f - %f\n", j, v[j], min);
+			v[j] -= min;
+		}
+	}
+	FREE(unique);
+	return n_free_rows;
+}
+
+
+/** Augmenting row reduction for a dense cost matrix.
+ */
+int_t _carr_dense(
+	const uint_t n, cost_t *cost[],
+	const uint_t n_free_rows,
+	int_t *free_rows, int_t *x, int_t *y, cost_t *v)
+{
+	uint_t current = 0;
+	int_t new_free_rows = 0;
+	uint_t rr_cnt = 0;
+	PRINT_INDEX_ARRAY(x, n);
+	PRINT_INDEX_ARRAY(y, n);
+	PRINT_COST_ARRAY(v, n);
+	PRINT_INDEX_ARRAY(free_rows, n_free_rows);
+	while (current < n_free_rows) {
+		int_t i0;
+		int_t j1, j2;
+		cost_t v1, v2, v1_new;
+		boolean v1_lowers;
+
+		rr_cnt++;
+		PRINTF("current = %d rr_cnt = %d\n", current, rr_cnt);
+		const int_t free_i = free_rows[current++];
+		j1 = 0;
+		v1 = cost[free_i][0] - v[0];
+		j2 = -1;
+		v2 = LARGE;
+		for (uint_t j = 1; j < n; j++) {
+			PRINTF("%d = %f %d = %f\n", j1, v1, j2, v2);
+			const cost_t c = cost[free_i][j] - v[j];
+			if (c < v2) {
+				if (c >= v1) {
+					v2 = c;
+					j2 = j;
+				}
+				else {
+					v2 = v1;
+					v1 = c;
+					j2 = j1;
+					j1 = j;
+				}
+			}
+		}
+		i0 = y[j1];
+		v1_new = v[j1] - (v2 - v1);
+		v1_lowers = v1_new < v[j1];
+		PRINTF("%d %d 1=%d,%f 2=%d,%f v1'=%f(%d,%g) \n", free_i, i0, j1, v1, j2, v2, v1_new, v1_lowers, v[j1] - v1_new);
+		if (rr_cnt < current * n) {
+			if (v1_lowers) {
+				v[j1] = v1_new;
+			}
+			else if (i0 >= 0 && j2 >= 0) {
+				j1 = j2;
+				i0 = y[j2];
+			}
+			if (i0 >= 0) {
+				if (v1_lowers) {
+					free_rows[--current] = i0;
+				}
+				else {
+					free_rows[new_free_rows++] = i0;
+				}
+			}
+		}
+		else {
+			PRINTF("rr_cnt=%d >= %d (current=%d * n=%d)\n", rr_cnt, current * n, current, n);
+			if (i0 >= 0) {
+				free_rows[new_free_rows++] = i0;
+			}
+		}
+		x[free_i] = j1;
+		y[j1] = free_i;
+	}
+	return new_free_rows;
+}
+
+
+/** Find columns with minimum d[j] and put them on the SCAN list.
+ */
+uint_t _find_dense(const uint_t n, uint_t lo, cost_t *d, int_t *cols, int_t *y)
+{
+	uint_t hi = lo + 1;
+	cost_t mind = d[cols[lo]];
+	for (uint_t k = hi; k < n; k++) {
+		int_t j = cols[k];
+		if (d[j] <= mind) {
+			if (d[j] < mind) {
+				hi = lo;
+				mind = d[j];
+			}
+			cols[k] = cols[hi];
+			cols[hi++] = j;
+		}
+	}
+	return hi;
+}
+
+
+// Scan all columns in TODO starting from arbitrary column in SCAN
+// and try to decrease d of the TODO columns using the SCAN column.
+int_t _scan_dense(const uint_t n, cost_t *cost[],
+	uint_t *plo, uint_t*phi,
+	cost_t *d, int_t *cols, int_t *pred,
+	int_t *y, cost_t *v)
+{
+	uint_t lo = *plo;
+	uint_t hi = *phi;
+	cost_t h, cred_ij;
+
+	while (lo != hi) {
+		int_t j = cols[lo++];
+		const int_t i = y[j];
+		const cost_t mind = d[j];
+		h = cost[i][j] - v[j] - mind;
+		PRINTF("i=%d j=%d h=%f\n", i, j, h);
+		// For all columns in TODO
+		for (uint_t k = hi; k < n; k++) {
+			j = cols[k];
+			cred_ij = cost[i][j] - v[j] - h;
+			if (cred_ij < d[j]) {
+				d[j] = cred_ij;
+				pred[j] = i;
+				if (cred_ij == mind) {
+					if (y[j] < 0) {
+						return j;
+					}
+					cols[k] = cols[hi];
+					cols[hi++] = j;
+				}
+			}
+		}
+	}
+	*plo = lo;
+	*phi = hi;
+	return -1;
+}
+
+
+/** Single iteration of modified Dijkstra shortest path algorithm as explained in the JV paper.
+ *
+ * This is a dense matrix version.
+ *
+ * \return The closest free column index.
+ */
+int_t find_path_dense(
+	const uint_t n, cost_t *cost[],
+	const int_t start_i,
+	int_t *y, cost_t *v,
+	int_t *pred)
+{
+	uint_t lo = 0, hi = 0;
+	int_t final_j = -1;
+	uint_t n_ready = 0;
+	int_t *cols;
+	cost_t *d;
+
+	NEW(cols, int_t, n);
+	NEW(d, cost_t, n);
+
+	for (uint_t i = 0; i < n; i++) {
+		cols[i] = i;
+		pred[i] = start_i;
+		d[i] = cost[start_i][i] - v[i];
+	}
+	PRINT_COST_ARRAY(d, n);
+	while (final_j == -1) {
+		// No columns left on the SCAN list.
+		if (lo == hi) {
+			PRINTF("%d..%d -> find\n", lo, hi);
+			n_ready = lo;
+			hi = _find_dense(n, lo, d, cols, y);
+			PRINTF("check %d..%d\n", lo, hi);
+			PRINT_INDEX_ARRAY(cols, n);
+			for (uint_t k = lo; k < hi; k++) {
+				const int_t j = cols[k];
+				if (y[j] < 0) {
+					final_j = j;
+				}
+			}
+		}
+		if (final_j == -1) {
+			PRINTF("%d..%d -> scan\n", lo, hi);
+			final_j = _scan_dense(
+				n, cost, &lo, &hi, d, cols, pred, y, v);
+			PRINT_COST_ARRAY(d, n);
+			PRINT_INDEX_ARRAY(cols, n);
+			PRINT_INDEX_ARRAY(pred, n);
+		}
+	}
+
+	PRINTF("found final_j=%d\n", final_j);
+	PRINT_INDEX_ARRAY(cols, n);
+	{
+		const cost_t mind = d[cols[lo]];
+		for (uint_t k = 0; k < n_ready; k++) {
+			const int_t j = cols[k];
+			v[j] += d[j] - mind;
+		}
+	}
+
+	FREE(cols);
+	FREE(d);
+
+	return final_j;
+}
+
+
+/** Augment for a dense cost matrix.
+ */
+int_t _ca_dense(
+	const uint_t n, cost_t *cost[],
+	const uint_t n_free_rows,
+	int_t *free_rows, int_t *x, int_t *y, cost_t *v)
+{
+	int_t *pred;
+
+	NEW(pred, int_t, n);
+
+	for (int_t *pfree_i = free_rows; pfree_i < free_rows + n_free_rows; pfree_i++) {
+		int_t i = -1, j;
+		uint_t k = 0;
+
+		PRINTF("looking at free_i=%d\n", *pfree_i);
+		j = find_path_dense(n, cost, *pfree_i, y, v, pred);
+		ASSERT(j >= 0);
+		ASSERT(j < n);
+		while (i != *pfree_i) {
+			PRINTF("augment %d\n", j);
+			PRINT_INDEX_ARRAY(pred, n);
+			i = pred[j];
+			PRINTF("y[%d]=%d -> %d\n", j, y[j], i);
+			y[j] = i;
+			PRINT_INDEX_ARRAY(x, n);
+			SWAP_INDICES(j, x[i]);
+			k++;
+			if (k >= n) {
+				ASSERT(FALSE);
+			}
+		}
+	}
+	FREE(pred);
+	return 0;
+}
+
+
+/** Solve dense sparse LAP.
+ */
+int lapjv_internal(
+	const uint_t n, cost_t *cost[],
+	int_t *x, int_t *y)
+{
+	int ret;
+	int_t *free_rows;
+	cost_t *v;
+
+	NEW(free_rows, int_t, n);
+	NEW(v, cost_t, n);
+	ret = _ccrrt_dense(n, cost, free_rows, x, y, v);
+	int i = 0;
+	while (ret > 0 && i < 2) {
+		ret = _carr_dense(n, cost, ret, free_rows, x, y, v);
+		i++;
+	}
+	if (ret > 0) {
+		ret = _ca_dense(n, cost, ret, free_rows, x, y, v);
+	}
+	FREE(v);
+	FREE(free_rows);
+	return ret;
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack/src/utils.cpp b/C++/yolo_bytetrack/src/utils.cpp
new file mode 100644
index 00000000..f3fa5acd
--- /dev/null
+++ b/C++/yolo_bytetrack/src/utils.cpp
@@ -0,0 +1,432 @@
+#include "BYTETracker.h"
+#include "lapjv.h"
+#include <map>
+#include <iostream>
+using namespace std;
+
+vector<STrack*> BYTETracker::joint_stracks(vector<STrack*> &tlista, vector<STrack> &tlistb)
+{
+	map<int, int> exists;
+	vector<STrack*> res;
+	for (int i = 0; i < tlista.size(); i++)
+	{
+		exists.insert(pair<int, int>(tlista[i]->track_id, 1));
+		res.push_back(tlista[i]);
+	}
+	for (int i = 0; i < tlistb.size(); i++)
+	{
+		int tid = tlistb[i].track_id;
+		if (!exists[tid] || exists.count(tid) == 0)
+		{
+			exists[tid] = 1;
+			res.push_back(&tlistb[i]);
+		}
+	}
+	return res;
+}
+
+vector<STrack> BYTETracker::joint_stracks(vector<STrack> &tlista, vector<STrack> &tlistb)
+{
+	map<int, int> exists;
+	vector<STrack> res;
+	for (int i = 0; i < tlista.size(); i++)
+	{
+		exists.insert(pair<int, int>(tlista[i].track_id, 1));
+		res.push_back(tlista[i]);
+	}
+	for (int i = 0; i < tlistb.size(); i++)
+	{
+		int tid = tlistb[i].track_id;
+		if (!exists[tid] || exists.count(tid) == 0)
+		{
+			exists[tid] = 1;
+			res.push_back(tlistb[i]);
+		}
+	}
+	return res;
+}
+
+vector<STrack> BYTETracker::sub_stracks(vector<STrack> &tlista, vector<STrack> &tlistb)
+{
+	map<int, STrack> stracks;
+	for (int i = 0; i < tlista.size(); i++)
+	{
+		stracks.insert(pair<int, STrack>(tlista[i].track_id, tlista[i]));
+	}
+	for (int i = 0; i < tlistb.size(); i++)
+	{
+		int tid = tlistb[i].track_id;
+		if (stracks.count(tid) != 0)
+		{
+			stracks.erase(tid);
+		}
+	}
+
+	vector<STrack> res;
+	map<int, STrack>::iterator  it;
+	for (it = stracks.begin(); it != stracks.end(); ++it)
+	{
+		res.push_back(it->second);
+	}
+
+	return res;
+}
+
+void BYTETracker::remove_duplicate_stracks(vector<STrack> &resa, vector<STrack> &resb, vector<STrack> &stracksa, vector<STrack> &stracksb)
+{
+	vector<vector<float> > pdist = iou_distance(stracksa, stracksb);
+	vector<pair<int, int> > pairs;
+	for (int i = 0; i < pdist.size(); i++)
+	{
+		for (int j = 0; j < pdist[i].size(); j++)
+		{
+			if (pdist[i][j] < 0.15)
+			{
+				pairs.push_back(pair<int, int>(i, j));
+			}
+		}
+	}
+
+	vector<int> dupa, dupb;
+	for (int i = 0; i < pairs.size(); i++)
+	{
+		int timep = stracksa[pairs[i].first].frame_id - stracksa[pairs[i].first].start_frame;
+		int timeq = stracksb[pairs[i].second].frame_id - stracksb[pairs[i].second].start_frame;
+		if (timep > timeq)
+			dupb.push_back(pairs[i].second);
+		else
+			dupa.push_back(pairs[i].first);
+	}
+
+	for (int i = 0; i < stracksa.size(); i++)
+	{
+		vector<int>::iterator iter = find(dupa.begin(), dupa.end(), i);
+		if (iter == dupa.end())
+		{
+			resa.push_back(stracksa[i]);
+		}
+	}
+
+	for (int i = 0; i < stracksb.size(); i++)
+	{
+		vector<int>::iterator iter = find(dupb.begin(), dupb.end(), i);
+		if (iter == dupb.end())
+		{
+			resb.push_back(stracksb[i]);
+		}
+	}
+}
+
+void BYTETracker::linear_assignment(vector<vector<float> > &cost_matrix, int cost_matrix_size, int cost_matrix_size_size, float thresh,
+	vector<vector<int> > &matches, vector<int> &unmatched_a, vector<int> &unmatched_b)
+{
+	if (cost_matrix.size() == 0)
+	{
+		for (int i = 0; i < cost_matrix_size; i++)
+		{
+			unmatched_a.push_back(i);
+		}
+		for (int i = 0; i < cost_matrix_size_size; i++)
+		{
+			unmatched_b.push_back(i);
+		}
+		return;
+	}
+
+	vector<int> rowsol; vector<int> colsol;
+	float c = lapjv(cost_matrix, rowsol, colsol, true, thresh);
+	for (int i = 0; i < rowsol.size(); i++)
+	{
+		if (rowsol[i] >= 0)
+		{
+			vector<int> match;
+			match.push_back(i);
+			match.push_back(rowsol[i]);
+			matches.push_back(match);
+		}
+		else
+		{
+			unmatched_a.push_back(i);
+		}
+	}
+
+	for (int i = 0; i < colsol.size(); i++)
+	{
+		if (colsol[i] < 0)
+		{
+			unmatched_b.push_back(i);
+		}
+	}
+}
+
+vector<vector<float> > BYTETracker::ious(vector<vector<float> > &atlbrs, vector<vector<float> > &btlbrs)
+{
+	vector<vector<float> > ious;
+	if (atlbrs.size()*btlbrs.size() == 0)
+		return ious;
+
+	ious.resize(atlbrs.size());
+	for (int i = 0; i < ious.size(); i++)
+	{
+		ious[i].resize(btlbrs.size());
+	}
+
+	//bbox_ious
+	for (int k = 0; k < btlbrs.size(); k++)
+	{
+		vector<float> ious_tmp;
+		float box_area = (btlbrs[k][2] - btlbrs[k][0] + 1)*(btlbrs[k][3] - btlbrs[k][1] + 1);
+		for (int n = 0; n < atlbrs.size(); n++)
+		{
+			float iw = min(atlbrs[n][2], btlbrs[k][2]) - max(atlbrs[n][0], btlbrs[k][0]) + 1;
+			if (iw > 0)
+			{
+				float ih = min(atlbrs[n][3], btlbrs[k][3]) - max(atlbrs[n][1], btlbrs[k][1]) + 1;
+				if(ih > 0)
+				{
+					float ua = (atlbrs[n][2] - atlbrs[n][0] + 1)*(atlbrs[n][3] - atlbrs[n][1] + 1) + box_area - iw * ih;
+					ious[n][k] = iw * ih / ua;
+				}
+				else
+				{
+					ious[n][k] = 0.0;
+				}
+			}
+			else
+			{
+				ious[n][k] = 0.0;
+			}
+		}
+	}
+
+	return ious;
+}
+
+vector<vector<float> > BYTETracker::iou_distance(vector<STrack*> &atracks, vector<STrack> &btracks, int &dist_size, int &dist_size_size)
+{
+	vector<vector<float> > cost_matrix;
+	if (atracks.size() * btracks.size() == 0)
+	{
+		dist_size = atracks.size();
+		dist_size_size = btracks.size();
+		return cost_matrix;
+	}
+	vector<vector<float> > atlbrs, btlbrs;
+	for (int i = 0; i < atracks.size(); i++)
+	{
+		atlbrs.push_back(atracks[i]->tlbr);
+	}
+	for (int i = 0; i < btracks.size(); i++)
+	{
+		btlbrs.push_back(btracks[i].tlbr);
+	}
+
+	dist_size = atracks.size();
+	dist_size_size = btracks.size();
+
+	vector<vector<float> > _ious = ious(atlbrs, btlbrs);
+	
+	for (int i = 0; i < _ious.size();i++)
+	{
+		vector<float> _iou;
+		for (int j = 0; j < _ious[i].size(); j++)
+		{
+			_iou.push_back(1 - _ious[i][j]);
+		}
+		cost_matrix.push_back(_iou);
+	}
+
+	return cost_matrix;
+}
+
+vector<vector<float> > BYTETracker::iou_distance(vector<STrack> &atracks, vector<STrack> &btracks)
+{
+	vector<vector<float> > atlbrs, btlbrs;
+	for (int i = 0; i < atracks.size(); i++)
+	{
+		atlbrs.push_back(atracks[i].tlbr);
+	}
+	for (int i = 0; i < btracks.size(); i++)
+	{
+		btlbrs.push_back(btracks[i].tlbr);
+	}
+
+	vector<vector<float> > _ious = ious(atlbrs, btlbrs);
+	vector<vector<float> > cost_matrix;
+	for (int i = 0; i < _ious.size(); i++)
+	{
+		vector<float> _iou;
+		for (int j = 0; j < _ious[i].size(); j++)
+		{
+			_iou.push_back(1 - _ious[i][j]);
+		}
+		cost_matrix.push_back(_iou);
+	}
+
+	return cost_matrix;
+}
+
+double BYTETracker::lapjv(const vector<vector<float> > &cost, vector<int> &rowsol, vector<int> &colsol,
+	bool extend_cost, float cost_limit, bool return_cost)
+{
+	vector<vector<float> > cost_c;
+	cost_c.assign(cost.begin(), cost.end());
+
+	vector<vector<float> > cost_c_extended;
+
+	int n_rows = cost.size();
+	int n_cols = cost[0].size();
+	rowsol.resize(n_rows);
+	colsol.resize(n_cols);
+
+	int n = 0;
+	if (n_rows == n_cols)
+	{
+		n = n_rows;
+	}
+	else
+	{
+		if (!extend_cost)
+		{
+			cout << "set extend_cost=True" << endl;
+			system("pause");
+			exit(0);
+		}
+	}
+		
+	if (extend_cost || cost_limit < LONG_MAX)
+	{
+		n = n_rows + n_cols;
+		cost_c_extended.resize(n);
+		for (int i = 0; i < cost_c_extended.size(); i++)
+			cost_c_extended[i].resize(n);
+
+		if (cost_limit < LONG_MAX)
+		{
+			for (int i = 0; i < cost_c_extended.size(); i++)
+			{
+				for (int j = 0; j < cost_c_extended[i].size(); j++)
+				{
+					cost_c_extended[i][j] = cost_limit / 2.0;
+				}
+			}
+		}
+		else
+		{
+			float cost_max = -1;
+			for (int i = 0; i < cost_c.size(); i++)
+			{
+				for (int j = 0; j < cost_c[i].size(); j++)
+				{
+					if (cost_c[i][j] > cost_max)
+						cost_max = cost_c[i][j];
+				}
+			}
+			for (int i = 0; i < cost_c_extended.size(); i++)
+			{
+				for (int j = 0; j < cost_c_extended[i].size(); j++)
+				{
+					cost_c_extended[i][j] = cost_max + 1;
+				}
+			}
+		}
+
+		for (int i = n_rows; i < cost_c_extended.size(); i++)
+		{
+			for (int j = n_cols; j < cost_c_extended[i].size(); j++)
+			{
+				cost_c_extended[i][j] = 0;
+			}
+		}
+		for (int i = 0; i < n_rows; i++)
+		{
+			for (int j = 0; j < n_cols; j++)
+			{
+				cost_c_extended[i][j] = cost_c[i][j];
+			}
+		}
+
+		cost_c.clear();
+		cost_c.assign(cost_c_extended.begin(), cost_c_extended.end());
+	}
+
+	double **cost_ptr;
+	cost_ptr = new double *[sizeof(double *) * n];
+	for (int i = 0; i < n; i++)
+		cost_ptr[i] = new double[sizeof(double) * n];
+
+	for (int i = 0; i < n; i++)
+	{
+		for (int j = 0; j < n; j++)
+		{
+			cost_ptr[i][j] = cost_c[i][j];
+		}
+	}
+
+	int* x_c = new int[sizeof(int) * n];
+	int *y_c = new int[sizeof(int) * n];
+
+	int ret = lapjv_internal(n, cost_ptr, x_c, y_c);
+	if (ret != 0)
+	{
+		cout << "Calculate Wrong!" << endl;
+		system("pause");
+		exit(0);
+	}
+
+	double opt = 0.0;
+
+	if (n != n_rows)
+	{
+		for (int i = 0; i < n; i++)
+		{
+			if (x_c[i] >= n_cols)
+				x_c[i] = -1;
+			if (y_c[i] >= n_rows)
+				y_c[i] = -1;
+		}
+		for (int i = 0; i < n_rows; i++)
+		{
+			rowsol[i] = x_c[i];
+		}
+		for (int i = 0; i < n_cols; i++)
+		{
+			colsol[i] = y_c[i];
+		}
+
+		if (return_cost)
+		{
+			for (int i = 0; i < rowsol.size(); i++)
+			{
+				if (rowsol[i] != -1)
+				{
+					//cout << i << "\t" << rowsol[i] << "\t" << cost_ptr[i][rowsol[i]] << endl;
+					opt += cost_ptr[i][rowsol[i]];
+				}
+			}
+		}
+	}
+	else if (return_cost)
+	{
+		for (int i = 0; i < rowsol.size(); i++)
+		{
+			opt += cost_ptr[i][rowsol[i]];
+		}
+	}
+
+	for (int i = 0; i < n; i++)
+	{
+		delete[]cost_ptr[i];
+	}
+	delete[]cost_ptr;
+	delete[]x_c;
+	delete[]y_c;
+
+	return opt;
+}
+
+cv::Scalar BYTETracker::get_color(int idx)
+{
+	idx += 3;
+	return cv::Scalar(37 * idx % 255, 17 * idx % 255, 29 * idx % 255);
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/3rdparty/librknn_api/armhf/librknn_api.so b/C++/yolo_bytetrack_old/3rdparty/librknn_api/armhf/librknn_api.so
new file mode 100644
index 00000000..b6726b4a
Binary files /dev/null and b/C++/yolo_bytetrack_old/3rdparty/librknn_api/armhf/librknn_api.so differ
diff --git a/C++/yolo_bytetrack_old/3rdparty/librknn_api/include/rknn_api.h b/C++/yolo_bytetrack_old/3rdparty/librknn_api/include/rknn_api.h
new file mode 100644
index 00000000..3bb6e1eb
--- /dev/null
+++ b/C++/yolo_bytetrack_old/3rdparty/librknn_api/include/rknn_api.h
@@ -0,0 +1,550 @@
+/****************************************************************************
+*
+*    Copyright (c) 2017 - 2018 by Rockchip Corp.  All rights reserved.
+*
+*    The material in this file is confidential and contains trade secrets
+*    of Rockchip Corporation. This is proprietary information owned by
+*    Rockchip Corporation. No part of this work may be disclosed,
+*    reproduced, copied, transmitted, or used in any way for any purpose,
+*    without the express written permission of Rockchip Corporation.
+*
+*****************************************************************************/
+
+
+#ifndef _RKNN_RUNTIME_H
+#define _RKNN_RUNTIME_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+/*
+    Definition of extended flag for rknn_init.
+*/
+/* set high priority context. */
+#define RKNN_FLAG_PRIOR_HIGH                    0x00000000
+
+/* set medium priority context */
+#define RKNN_FLAG_PRIOR_MEDIUM                  0x00000001
+
+/* set low priority context. */
+#define RKNN_FLAG_PRIOR_LOW                     0x00000002
+
+/* asynchronous mode.
+   when enable, rknn_outputs_get will not block for too long because it directly retrieves the result of
+   the previous frame which can increase the frame rate on single-threaded mode, but at the cost of
+   rknn_outputs_get not retrieves the result of the current frame.
+   in multi-threaded mode you do not need to turn this mode on. */
+#define RKNN_FLAG_ASYNC_MASK                    0x00000004
+
+/* collect performance mode.
+   when enable, you can get detailed performance reports via rknn_query(ctx, RKNN_QUERY_PERF_DETAIL, ...),
+   but it will reduce the frame rate. */
+#define RKNN_FLAG_COLLECT_PERF_MASK             0x00000008
+
+/*
+   save pre-compile model.
+*/
+#define RKNN_FLAG_PRECOMPILE_MASK               0x00000020
+
+/*
+    Error code returned by the RKNN API.
+*/
+#define RKNN_SUCC                               0       /* execute succeed. */
+#define RKNN_ERR_FAIL                           -1      /* execute failed. */
+#define RKNN_ERR_TIMEOUT                        -2      /* execute timeout. */
+#define RKNN_ERR_DEVICE_UNAVAILABLE             -3      /* device is unavailable. */
+#define RKNN_ERR_MALLOC_FAIL                    -4      /* memory malloc fail. */
+#define RKNN_ERR_PARAM_INVALID                  -5      /* parameter is invalid. */
+#define RKNN_ERR_MODEL_INVALID                  -6      /* model is invalid. */
+#define RKNN_ERR_CTX_INVALID                    -7      /* context is invalid. */
+#define RKNN_ERR_INPUT_INVALID                  -8      /* input is invalid. */
+#define RKNN_ERR_OUTPUT_INVALID                 -9      /* output is invalid. */
+#define RKNN_ERR_DEVICE_UNMATCH                 -10     /* the device is unmatch, please update rknn sdk
+                                                           and npu driver/firmware. */
+#define RKNN_ERR_INCOMPATILE_PRE_COMPILE_MODEL  -11     /* This RKNN model use pre_compile mode, but not compatible with current driver. */
+//add by chifred: for reporting optimization version bug info
+#define RKNN_ERR_INCOMPATILE_OPTIMIZATION_LEVEL_VERSION  -12     /* This RKNN model set optimization level, but not compatible with current driver. */
+#define RKNN_ERR_TARGET_PLATFORM_UNMATCH        -13     /* This RKNN model set target platform, but not compatible with current platform. */
+//chifred add end
+#define RKNN_ERR_NON_PRE_COMPILED_MODEL_ON_MINI_DRIVER -14  /* This RKNN model is not a pre-compiled model, but the npu driver is mini driver. */
+
+/*
+    Definition for tensor
+*/
+#define RKNN_MAX_DIMS                           16      /* maximum dimension of tensor. */
+#define RKNN_MAX_NAME_LEN                       256     /* maximum name lenth of tensor. */
+
+
+
+#ifdef __arm__
+typedef uint32_t rknn_context;
+#else
+typedef uint64_t rknn_context;
+#endif
+
+/*
+    The query command for rknn_query
+*/
+typedef enum _rknn_query_cmd {
+    RKNN_QUERY_IN_OUT_NUM = 0,                          /* query the number of input & output tensor. */
+    RKNN_QUERY_INPUT_ATTR,                              /* query the attribute of input tensor. */
+    RKNN_QUERY_OUTPUT_ATTR,                             /* query the attribute of output tensor. */
+    RKNN_QUERY_PERF_DETAIL,                             /* query the detail performance, need set
+                                                           RKNN_FLAG_COLLECT_PERF_MASK when call rknn_init. */
+    RKNN_QUERY_PERF_RUN,                                /* query the time of run. */
+    RKNN_QUERY_SDK_VERSION,                             /* query the sdk & driver version */
+    RKNN_QUERY_PRE_COMPILE,                             /* query the pre compile model */
+
+    RKNN_QUERY_CMD_MAX
+} rknn_query_cmd;
+
+/*
+    the tensor data type.
+*/
+typedef enum _rknn_tensor_type {
+    RKNN_TENSOR_FLOAT32 = 0,                            /* data type is float32. */
+    RKNN_TENSOR_FLOAT16,                                /* data type is float16. */
+    RKNN_TENSOR_INT8,                                   /* data type is int8. */
+    RKNN_TENSOR_UINT8,                                  /* data type is uint8. */
+    RKNN_TENSOR_INT16,                                  /* data type is int16. */
+
+    RKNN_TENSOR_TYPE_MAX
+} rknn_tensor_type;
+
+inline static const char *get_type_string(rknn_tensor_type type)
+{
+    switch (type)
+    {
+    case RKNN_TENSOR_FLOAT32:
+        return "FP32";
+    case RKNN_TENSOR_FLOAT16:
+        return "FP16";
+    case RKNN_TENSOR_INT8:
+        return "INT8";
+    case RKNN_TENSOR_UINT8:
+        return "UINT8";
+    case RKNN_TENSOR_INT16:
+        return "INT16";
+    default:
+        return "UNKNOW";
+    }
+}
+
+/*
+    the quantitative type.
+*/
+typedef enum _rknn_tensor_qnt_type {
+    RKNN_TENSOR_QNT_NONE = 0,                           /* none. */
+    RKNN_TENSOR_QNT_DFP,                                /* dynamic fixed point. */
+    RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC,                  /* asymmetric affine. */
+
+    RKNN_TENSOR_QNT_MAX
+} rknn_tensor_qnt_type;
+
+inline static const char *get_qnt_type_string(rknn_tensor_qnt_type type)
+{
+    switch (type)
+    {
+    case RKNN_TENSOR_QNT_NONE:
+        return "NONE";
+    case RKNN_TENSOR_QNT_DFP:
+        return "DFP";
+    case RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC:
+        return "AFFINE";
+    default:
+        return "UNKNOW";
+    }
+}
+
+/*
+    the tensor data format.
+*/
+typedef enum _rknn_tensor_format {
+    RKNN_TENSOR_NCHW = 0,                               /* data format is NCHW. */
+    RKNN_TENSOR_NHWC,                                   /* data format is NHWC. */
+
+    RKNN_TENSOR_FORMAT_MAX
+} rknn_tensor_format;
+
+inline static const char *get_format_string(rknn_tensor_format fmt)
+{
+    switch (fmt)
+    {
+    case RKNN_TENSOR_NCHW:
+        return "NCHW";
+    case RKNN_TENSOR_NHWC:
+        return "NHWC";
+    default:
+        return "UNKNOW";
+    }
+}
+
+/*
+    the information for RKNN_QUERY_IN_OUT_NUM.
+*/
+typedef struct _rknn_input_output_num {
+    uint32_t n_input;                                   /* the number of input. */
+    uint32_t n_output;                                  /* the number of output. */
+} rknn_input_output_num;
+
+/*
+    the information for RKNN_QUERY_INPUT_ATTR / RKNN_QUERY_OUTPUT_ATTR.
+*/
+typedef struct _rknn_tensor_attr {
+    uint32_t index;                                     /* input parameter, the index of input/output tensor,
+                                                           need set before call rknn_query. */
+
+    uint32_t n_dims;                                    /* the number of dimensions. */
+    uint32_t dims[RKNN_MAX_DIMS];                       /* the dimensions array. */
+    char name[RKNN_MAX_NAME_LEN];                       /* the name of tensor. */
+
+    uint32_t n_elems;                                   /* the number of elements. */
+    uint32_t size;                                      /* the bytes size of tensor. */
+
+    rknn_tensor_format fmt;                             /* the data format of tensor. */
+    rknn_tensor_type type;                              /* the data type of tensor. */
+    rknn_tensor_qnt_type qnt_type;                      /* the quantitative type of tensor. */
+    int8_t fl;                                          /* fractional length for RKNN_TENSOR_QNT_DFP. */
+    uint32_t zp;                                        /* zero point for RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC. */
+    float scale;                                        /* scale for RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC. */
+} rknn_tensor_attr;
+
+/*
+    the information for RKNN_QUERY_PERF_DETAIL.
+*/
+typedef struct _rknn_perf_detail {
+    char* perf_data;                                    /* the string pointer of perf detail. don't need free it by user. */
+    uint64_t data_len;                                  /* the string length. */
+} rknn_perf_detail;
+
+/*
+    the information for RKNN_QUERY_PERF_RUN.
+*/
+typedef struct _rknn_perf_run {
+    int64_t run_duration;                               /* real inference time (us) */
+} rknn_perf_run;
+
+/*
+    the information for RKNN_QUERY_SDK_VERSION.
+*/
+typedef struct _rknn_sdk_version {
+    char api_version[256];                              /* the version of rknn api. */
+    char drv_version[256];                              /* the version of rknn driver. */
+} rknn_sdk_version;
+
+/*
+   The flags of rknn_tensor_mem.
+*/
+typedef enum _rknn_tensor_mem_flags {
+    RKNN_TENSOR_MEMORY_FLAGS_UNKNOWN = 0,
+    RKNN_TENSOR_MEMORY_FLAGS_ALLOC_INSIDE = 1,           /*Used to mark in rknn_destroy_mem() whether it is necessary to release the "mem" pointer itself.
+                                                         If the flag RKNN_TENSOR_MEMORY_FLAGS_ALLOC_INSIDE is set, rknn_destroy_mem() will call free(mem).*/
+   
+} rknn_tensor_mem_flags;
+
+
+/*
+    the memory information of tensor.
+*/
+typedef struct _rknn_tensor_memory {
+    void*       logical_addr;                           /* the virtual address of tensor buffer. */
+    uint64_t    physical_addr;                          /* the physical address of tensor buffer. */
+    int32_t     fd;                                     /* the fd of tensor buffer. */
+    uint32_t    size;                                   /* the size of tensor buffer. */
+    uint32_t    handle;                                 /* the handle tensor buffer. */
+    void *      priv_data;                              /* the data which is reserved. */
+    uint64_t reserved_flag;                             /* the flag which is reserved. */
+} rknn_tensor_mem;
+
+/*
+    the input information for rknn_input_set.
+*/
+typedef struct _rknn_input {
+    uint32_t index;                                     /* the input index. */
+    void* buf;                                          /* the input buf for index. */
+    uint32_t size;                                      /* the size of input buf. */
+    uint8_t pass_through;                               /* pass through mode.
+                                                           if TRUE, the buf data is passed directly to the input node of the rknn model
+                                                                    without any conversion. the following variables do not need to be set.
+                                                           if FALSE, the buf data is converted into an input consistent with the model
+                                                                     according to the following type and fmt. so the following variables
+                                                                     need to be set.*/
+    rknn_tensor_type type;                              /* the data type of input buf. */
+    rknn_tensor_format fmt;                             /* the data format of input buf.
+                                                           currently the internal input format of NPU is NCHW by default.
+                                                           so entering NCHW data can avoid the format conversion in the driver. */
+} rknn_input;
+
+/*
+    the output information for rknn_outputs_get.
+*/
+typedef struct _rknn_output {
+    uint8_t want_float;                                 /* want transfer output data to float */
+    uint8_t is_prealloc;                                /* whether buf is pre-allocated.
+                                                           if true, the following variables need to be set.
+                                                           if false, The following variables do not need to be set. */
+    uint32_t index;                                     /* the output index. */
+    void* buf;                                          /* the output buf for index.
+                                                           when is_prealloc = FALSE and rknn_outputs_release called,
+                                                           this buf pointer will be free and don't use it anymore. */
+    uint32_t size;                                      /* the size of output buf. */
+} rknn_output;
+
+/*
+    the extend information for rknn_run.
+*/
+typedef struct _rknn_run_extend {
+    uint64_t frame_id;                                  /* output parameter, indicate current frame id of run. */
+} rknn_run_extend;
+
+/*
+    the extend information for rknn_outputs_get.
+*/
+typedef struct _rknn_output_extend {
+    uint64_t frame_id;                                  /* output parameter, indicate the frame id of outputs, corresponds to
+                                                           struct rknn_run_extend.frame_id.*/
+} rknn_output_extend;
+
+/*
+    the information for RKNN_QUERY_RKNN_PRECOMPILE.
+*/
+typedef struct _rknn_precompile {
+    void* model_data;                                   /* the pointer of precompile model. don't need free it by user. */
+    uint32_t data_len;                                  /* the model length. */
+} rknn_precompile;
+
+/*  rknn_init
+
+    initial the context and load the rknn model.
+
+    input:
+        rknn_context* context       the pointer of context handle.
+        void* model                 pointer to the rknn model.
+        uint32_t size               the size of rknn model.
+        uint32_t flag               extend flag, see the define of RKNN_FLAG_XXX_XXX.
+    return:
+        int                         error code.
+*/
+int rknn_init(rknn_context* context, void* model, uint32_t size, uint32_t flag);
+
+
+/*  rknn_destroy
+
+    unload the rknn model and destroy the context.
+
+    input:
+        rknn_context context        the handle of context.
+    return:
+        int                         error code.
+*/
+int rknn_destroy(rknn_context context);
+
+
+/*  rknn_query
+
+    query the information about model or others. see rknn_query_cmd.
+
+    input:
+        rknn_context context        the handle of context.
+        rknn_query_cmd cmd          the command of query.
+        void* info                  the buffer point of information.
+        uint32_t size               the size of information.
+    return:
+        int                         error code.
+*/
+int rknn_query(rknn_context context, rknn_query_cmd cmd, void* info, uint32_t size);
+
+
+/*  rknn_inputs_set
+
+    set inputs information by input index of rknn model.
+    inputs information see rknn_input.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_inputs           the number of inputs.
+        rknn_input inputs[]         the arrays of inputs information, see rknn_input.
+    return:
+        int                         error code
+*/
+int rknn_inputs_set(rknn_context context, uint32_t n_inputs, rknn_input inputs[]);
+
+
+/*  rknn_inputs_map
+
+    map inputs tensor memory information by input index of rknn model.
+    inputs information see rknn_input.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_inputs           the number of inputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code
+*/
+int rknn_inputs_map(rknn_context context, uint32_t n_inputs, rknn_tensor_mem mem[]);
+
+
+/*  rknn_inputs_sync
+
+    synchronize inputs tensor buffer by input index of rknn model.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_inputs           the number of inputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code
+*/
+int rknn_inputs_sync(rknn_context context, uint32_t n_inputs, rknn_tensor_mem mem[]);
+
+
+/*  rknn_inputs_unmap
+
+    unmap inputs tensor memory information by input index of rknn model.
+    inputs information see rknn_input.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_inputs           the number of inputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code
+*/
+int rknn_inputs_unmap(rknn_context context, uint32_t n_inputs, rknn_tensor_mem mem[]);
+
+
+/*  rknn_run
+
+    run the model to execute inference.
+
+    input:
+        rknn_context context        the handle of context.
+        rknn_run_extend* extend     the extend information of run.
+    return:
+        int                         error code.
+*/
+int rknn_run(rknn_context context, rknn_run_extend* extend);
+
+
+/*  rknn_outputs_get
+
+    wait the inference to finish and get the outputs.
+    this function will block until inference finish.
+    the results will set to outputs[].
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_outputs          the number of outputs.
+        rknn_output outputs[]       the arrays of output, see rknn_output.
+        rknn_output_extend*         the extend information of output.
+    return:
+        int                         error code.
+*/
+int rknn_outputs_get(rknn_context context, uint32_t n_outputs, rknn_output outputs[], rknn_output_extend* extend);
+
+
+/*  rknn_outputs_release
+
+    release the outputs that get by rknn_outputs_get.
+    after called, the rknn_output[x].buf get from rknn_outputs_get will
+    also be free when rknn_output[x].is_prealloc = FALSE.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_ouputs           the number of outputs.
+        rknn_output outputs[]       the arrays of output.
+    return:
+        int                         error code
+*/
+int rknn_outputs_release(rknn_context context, uint32_t n_ouputs, rknn_output outputs[]);
+
+
+/*  rknn_outputs_map
+
+    map the model output tensors memory information.
+    The difference between this function and "rknn_outputs_get" is
+    that it directly maps the model output tensor memory location to the user.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_outputs          the number of outputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code.
+*/
+int rknn_outputs_map(rknn_context context, uint32_t n_outputs, rknn_tensor_mem mem[]);
+
+/*  rknn_outputs_sync
+
+    synchronize the output tensors buffer to ensure cache cohenrency, wait the inference to finish.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_outputs          the number of outputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code.
+*/
+int rknn_outputs_sync(rknn_context context, uint32_t n_outputs, rknn_tensor_mem mem[]);
+
+/*  rknn_outputs_unmap
+
+    unmap the outputs memory information that get by rknn_outputs_map.
+
+    input:
+        rknn_context context        the handle of context.
+        uint32_t n_ouputs           the number of outputs.
+        rknn_tensor_mem mem[]       the array of tensor memory information
+    return:
+        int                         error code
+*/
+int rknn_outputs_unmap(rknn_context context, uint32_t n_ouputs, rknn_tensor_mem mem[]);
+
+/*  rknn_create_mem (memory allocated inside)
+
+    Create tensor memory. This API require libdrm support!
+
+    input:
+        rknn_context ctx            the handle of context.
+        uint64_t size               the size of tensor buffer.
+    return:
+        rknn_tensor_mem             the pointer of tensor memory information.
+*/
+rknn_tensor_mem* rknn_create_mem(rknn_context ctx, uint64_t size);
+
+/*  rknn_destroy_mem (support allocate inside and outside)
+
+    destroy tensor memory.
+
+    input:
+        rknn_context ctx            the handle of context.
+        rknn_tensor_mem *mem        the pointer of tensor memory information.
+    return:
+        int                         error code
+*/
+int rknn_destroy_mem(rknn_context ctx, rknn_tensor_mem *mem);
+
+
+
+/*  rknn_set_io_mem
+
+    set the input and output tensors buffer.
+
+    input:
+        rknn_context ctx            the handle of context.
+        rknn_tensor_mem *mem        the array of tensor memory information.
+        rknn_tensor_attr *attr      the attribute of input or output tensor buffer.
+    return:
+        int                         error code.
+*/
+int rknn_set_io_mem(rknn_context ctx, rknn_tensor_mem *mem, rknn_tensor_attr *attr);
+
+#ifdef __cplusplus
+} //extern "C"
+#endif
+
+#endif  //_RKNN_RUNTIME_H
diff --git a/C++/yolo_bytetrack_old/3rdparty/rga/include/RgaUtils.h b/C++/yolo_bytetrack_old/3rdparty/rga/include/RgaUtils.h
new file mode 100644
index 00000000..1c5a6575
--- /dev/null
+++ b/C++/yolo_bytetrack_old/3rdparty/rga/include/RgaUtils.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2016 Rockchip Electronics Co., Ltd.
+ * Authors:
+ *  Zhiqin Wei <wzq@rock-chips.com>
+ *
+ * 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.
+ */
+
+#ifndef _rga_utils_h_
+#define _rga_utils_h_
+
+// -------------------------------------------------------------------------------
+float get_bpp_from_format(int format);
+int get_buf_from_file(void *buf, int f, int sw, int sh, int index);
+int output_buf_data_to_file(void *buf, int f, int sw, int sh, int index);
+const char *translate_format_str(int format);
+int get_buf_from_file_AFBC(void *buf, int f, int sw, int sh, int index);
+int output_buf_data_to_file_AFBC(void *buf, int f, int sw, int sh, int index);
+#endif
+
diff --git a/C++/yolo_bytetrack_old/3rdparty/rga/include/im2d.h b/C++/yolo_bytetrack_old/3rdparty/rga/include/im2d.h
new file mode 100644
index 00000000..74581712
--- /dev/null
+++ b/C++/yolo_bytetrack_old/3rdparty/rga/include/im2d.h
@@ -0,0 +1,963 @@
+/*
+ * Copyright (C) 2020 Rockchip Electronics Co., Ltd.
+ * Authors:
+ *  PutinLee <putin.lee@rock-chips.com>
+ *  Cerf Yu <cerf.yu@rock-chips.com>
+ *
+ * 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.
+ */
+
+#ifndef _im2d_h_
+#define _im2d_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#ifndef IM_API
+#define IM_API /* define API export as needed */
+#endif
+
+typedef enum {
+    /* Rotation */
+    IM_HAL_TRANSFORM_ROT_90     = 1 << 0,
+    IM_HAL_TRANSFORM_ROT_180    = 1 << 1,
+    IM_HAL_TRANSFORM_ROT_270    = 1 << 2,
+    IM_HAL_TRANSFORM_FLIP_H     = 1 << 3,
+    IM_HAL_TRANSFORM_FLIP_V     = 1 << 4,
+    IM_HAL_TRANSFORM_FLIP_H_V   = 1 << 5,
+    IM_HAL_TRANSFORM_MASK       = 0x3f,
+
+    /*
+     * Blend
+     * Additional blend usage, can be used with both source and target configs.
+     * If none of the below is set, the default "SRC over DST" is applied.
+     */
+    IM_ALPHA_BLEND_SRC_OVER     = 1 << 6,     /* Default, Porter-Duff "SRC over DST" */
+    IM_ALPHA_BLEND_SRC          = 1 << 7,     /* Porter-Duff "SRC" */
+    IM_ALPHA_BLEND_DST          = 1 << 8,     /* Porter-Duff "DST" */
+    IM_ALPHA_BLEND_SRC_IN       = 1 << 9,     /* Porter-Duff "SRC in DST" */
+    IM_ALPHA_BLEND_DST_IN       = 1 << 10,    /* Porter-Duff "DST in SRC" */
+    IM_ALPHA_BLEND_SRC_OUT      = 1 << 11,    /* Porter-Duff "SRC out DST" */
+    IM_ALPHA_BLEND_DST_OUT      = 1 << 12,    /* Porter-Duff "DST out SRC" */
+    IM_ALPHA_BLEND_DST_OVER     = 1 << 13,    /* Porter-Duff "DST over SRC" */
+    IM_ALPHA_BLEND_SRC_ATOP     = 1 << 14,    /* Porter-Duff "SRC ATOP" */
+    IM_ALPHA_BLEND_DST_ATOP     = 1 << 15,    /* Porter-Duff "DST ATOP" */
+    IM_ALPHA_BLEND_XOR          = 1 << 16,    /* Xor */
+    IM_ALPHA_BLEND_MASK         = 0x1ffc0,
+
+    IM_ALPHA_COLORKEY_NORMAL    = 1 << 17,
+    IM_ALPHA_COLORKEY_INVERTED  = 1 << 18,
+    IM_ALPHA_COLORKEY_MASK      = 0x60000,
+
+    IM_SYNC                     = 1 << 19,
+    IM_ASYNC                    = 1 << 26,
+    IM_CROP                     = 1 << 20,    /* Unused */
+    IM_COLOR_FILL               = 1 << 21,
+    IM_COLOR_PALETTE            = 1 << 22,
+    IM_NN_QUANTIZE              = 1 << 23,
+    IM_ROP                      = 1 << 24,
+    IM_ALPHA_BLEND_PRE_MUL      = 1 << 25,
+
+} IM_USAGE;
+
+typedef enum {
+    IM_RASTER_MODE  = 1 << 0,
+    IM_AFBC_MODE    = 1 << 1,
+    IM_TILE_MODE    = 1 << 2,
+} IM_RD_MODE;
+
+typedef enum {
+    IM_SCHEDULER_RGA3_CORE0 = 1 << 0,
+    IM_SCHEDULER_RGA3_CORE1 = 1 << 1,
+    IM_SCHEDULER_RGA2_CORE0 = 1 << 2,
+    IM_SCHEDULER_RGA3_DEFAULT = IM_SCHEDULER_RGA3_CORE0,
+    IM_SCHEDULER_RGA2_DEFAULT = IM_SCHEDULER_RGA2_CORE0,
+    IM_SCHEDULER_MASK       = 0x7,
+    IM_SCHEDULER_DEFAULT = 0,
+} IM_SCHEDULER_CORE;
+
+typedef enum {
+    IM_ROP_AND                  = 0x88,
+    IM_ROP_OR                   = 0xee,
+    IM_ROP_NOT_DST              = 0x55,
+    IM_ROP_NOT_SRC              = 0x33,
+    IM_ROP_XOR                  = 0xf6,
+    IM_ROP_NOT_XOR              = 0xf9,
+} IM_ROP_CODE;
+
+typedef enum {
+    IM_RGA_SUPPORT_FORMAT_ERROR_INDEX = 0,
+    IM_RGA_SUPPORT_FORMAT_RGB_INDEX,
+    IM_RGA_SUPPORT_FORMAT_RGB_OTHER_INDEX,
+    IM_RGA_SUPPORT_FORMAT_BPP_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_8_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_10_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUYV_420_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUYV_422_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_400_INDEX,
+    IM_RGA_SUPPORT_FORMAT_Y4_INDEX,
+    IM_RGA_SUPPORT_FORMAT_MASK_INDEX,
+} IM_RGA_SUPPORT_FORMAT_INDEX;
+
+typedef enum {
+    IM_RGA_SUPPORT_FORMAT_ERROR     = 1 << IM_RGA_SUPPORT_FORMAT_ERROR_INDEX,
+    IM_RGA_SUPPORT_FORMAT_RGB       = 1 << IM_RGA_SUPPORT_FORMAT_RGB_INDEX,
+    IM_RGA_SUPPORT_FORMAT_RGB_OTHER = 1 << IM_RGA_SUPPORT_FORMAT_RGB_OTHER_INDEX,
+    IM_RGA_SUPPORT_FORMAT_BPP       = 1 << IM_RGA_SUPPORT_FORMAT_BPP_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_8     = 1 << IM_RGA_SUPPORT_FORMAT_YUV_8_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_10    = 1 << IM_RGA_SUPPORT_FORMAT_YUV_10_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUYV_420  = 1 << IM_RGA_SUPPORT_FORMAT_YUYV_420_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUYV_422  = 1 << IM_RGA_SUPPORT_FORMAT_YUYV_422_INDEX,
+    IM_RGA_SUPPORT_FORMAT_YUV_400   = 1 << IM_RGA_SUPPORT_FORMAT_YUV_400_INDEX,
+    IM_RGA_SUPPORT_FORMAT_Y4        = 1 << IM_RGA_SUPPORT_FORMAT_Y4_INDEX,
+    IM_RGA_SUPPORT_FORMAT_MASK      = ~((~(unsigned int)0x0 << IM_RGA_SUPPORT_FORMAT_MASK_INDEX) | 1),
+} IM_RGA_SUPPORT_FORMAT;
+
+typedef enum {
+    IM_RGA_SUPPORT_FEATURE_ERROR_INDEX = 0,
+    IM_RGA_SUPPORT_FEATURE_COLOR_FILL_INDEX,
+    IM_RGA_SUPPORT_FEATURE_COLOR_PALETTE_INDEX,
+    IM_RGA_SUPPORT_FEATURE_ROP_INDEX,
+    IM_RGA_SUPPORT_FEATURE_QUANTIZE_INDEX,
+    IM_RGA_SUPPORT_FEATURE_SRC1_R2Y_CSC_INDEX,
+    IM_RGA_SUPPORT_FEATURE_DST_FULL_CSC_INDEX,
+    IM_RGA_SUPPORT_FEATURE_MASK_INDEX,
+} IM_RGA_SUPPORT_FEATURE_INDEX;
+
+typedef enum {
+    IM_RGA_SUPPORT_FEATURE_ERROR          = 1 << IM_RGA_SUPPORT_FEATURE_ERROR_INDEX,
+    IM_RGA_SUPPORT_FEATURE_COLOR_FILL     = 1 << IM_RGA_SUPPORT_FEATURE_COLOR_FILL_INDEX,
+    IM_RGA_SUPPORT_FEATURE_COLOR_PALETTE  = 1 << IM_RGA_SUPPORT_FEATURE_COLOR_PALETTE_INDEX,
+    IM_RGA_SUPPORT_FEATURE_ROP            = 1 << IM_RGA_SUPPORT_FEATURE_ROP_INDEX,
+    IM_RGA_SUPPORT_FEATURE_QUANTIZE       = 1 << IM_RGA_SUPPORT_FEATURE_QUANTIZE_INDEX,
+    IM_RGA_SUPPORT_FEATURE_SRC1_R2Y_CSC   = 1 << IM_RGA_SUPPORT_FEATURE_SRC1_R2Y_CSC_INDEX,
+    IM_RGA_SUPPORT_FEATURE_DST_FULL_CSC   = 1 << IM_RGA_SUPPORT_FEATURE_DST_FULL_CSC_INDEX,
+    IM_RGA_SUPPORT_FEATURE_MASK           = ~((~(unsigned int)0x0 << IM_RGA_SUPPORT_FEATURE_MASK_INDEX) | 1),
+} IM_RGA_SUPPORT_FEATURE;
+
+/* Status codes, returned by any blit function */
+typedef enum {
+    IM_STATUS_NOERROR         =  2,
+    IM_STATUS_SUCCESS         =  1,
+    IM_STATUS_NOT_SUPPORTED   = -1,
+    IM_STATUS_OUT_OF_MEMORY   = -2,
+    IM_STATUS_INVALID_PARAM   = -3,
+    IM_STATUS_ILLEGAL_PARAM   = -4,
+    IM_STATUS_FAILED          =  0,
+} IM_STATUS;
+
+/* Status codes, returned by any blit function */
+typedef enum {
+    IM_YUV_TO_RGB_BT601_LIMIT     = 1 << 0,
+    IM_YUV_TO_RGB_BT601_FULL      = 2 << 0,
+    IM_YUV_TO_RGB_BT709_LIMIT     = 3 << 0,
+    IM_YUV_TO_RGB_MASK            = 3 << 0,
+    IM_RGB_TO_YUV_BT601_FULL      = 1 << 2,
+    IM_RGB_TO_YUV_BT601_LIMIT     = 2 << 2,
+    IM_RGB_TO_YUV_BT709_LIMIT     = 3 << 2,
+    IM_RGB_TO_YUV_MASK            = 3 << 2,
+    IM_RGB_TO_Y4                  = 1 << 4,
+    IM_RGB_TO_Y4_DITHER           = 2 << 4,
+    IM_RGB_TO_Y1_DITHER           = 3 << 4,
+    IM_Y4_MASK                    = 3 << 4,
+    IM_RGB_FULL                   = 1 << 8,
+    IM_RGB_CLIP                   = 2 << 8,
+    IM_YUV_BT601_LIMIT_RANGE      = 3 << 8,
+    IM_YUV_BT601_FULL_RANGE       = 4 << 8,
+    IM_YUV_BT709_LIMIT_RANGE      = 5 << 8,
+    IM_YUV_BT709_FULL_RANGE       = 6 << 8,
+    IM_FULL_CSC_MASK              = 0xf << 8,
+    IM_COLOR_SPACE_DEFAULT        = 0,
+} IM_COLOR_SPACE_MODE;
+
+typedef enum {
+    IM_UP_SCALE,
+    IM_DOWN_SCALE,
+} IM_SCALE;
+
+typedef enum {
+    INTER_NEAREST,
+    INTER_LINEAR,
+    INTER_CUBIC,
+} IM_SCALE_MODE;
+
+/* Get RGA basic information index */
+typedef enum {
+    RGA_VENDOR = 0,
+    RGA_VERSION,
+    RGA_MAX_INPUT,
+    RGA_MAX_OUTPUT,
+    RGA_SCALE_LIMIT,
+    RGA_INPUT_FORMAT,
+    RGA_OUTPUT_FORMAT,
+    RGA_FEATURE,
+    RGA_EXPECTED,
+    RGA_ALL,
+} IM_INFORMATION;
+
+/*rga version index*/
+typedef enum {
+    RGA_V_ERR                  = 0x0,
+    RGA_1                      = 0x1,
+    RGA_1_PLUS                 = 0x2,
+    RGA_2                      = 0x3,
+    RGA_2_LITE0                = 0x4,
+    RGA_2_LITE1                = 0x5,
+    RGA_2_ENHANCE              = 0x6,
+} RGA_VERSION_NUM;
+
+typedef enum {
+    IM_CONFIG_SCHEDULER_CORE,
+    IM_CONFIG_PRIORITY,
+    IM_CHECK_CONFIG,
+} IM_CONFIG_NAME;
+
+//struct AHardwareBuffer AHardwareBuffer;
+
+typedef struct {
+    RGA_VERSION_NUM version;
+    unsigned int input_resolution;
+    unsigned int output_resolution;
+    unsigned int scale_limit;
+    unsigned int performance;
+    unsigned int input_format;
+    unsigned int output_format;
+    unsigned int feature;
+    char reserved[28];
+} rga_info_table_entry;
+
+/* Rectangle definition */
+typedef struct {
+    int x;        /* upper-left x */
+    int y;        /* upper-left y */
+    int width;    /* width */
+    int height;   /* height */
+} im_rect;
+
+typedef struct {
+    int max;                    /* The Maximum value of the color key */
+    int min;                    /* The minimum value of the color key */
+} im_colorkey_range;
+
+
+typedef struct im_nn {
+    int scale_r;                /* scaling factor on R channal */
+    int scale_g;                /* scaling factor on G channal */
+    int scale_b;                /* scaling factor on B channal */
+    int offset_r;               /* offset on R channal */
+    int offset_g;               /* offset on G channal */
+    int offset_b;               /* offset on B channal */
+} im_nn_t;
+
+/* im_info definition */
+typedef struct {
+    void* vir_addr;                     /* virtual address */
+    void* phy_addr;                     /* physical address */
+    int fd;                             /* shared fd */
+
+    int width;                          /* width */
+    int height;                         /* height */
+    int wstride;                        /* wstride */
+    int hstride;                        /* hstride */
+    int format;                         /* format */
+
+    int color_space_mode;               /* color_space_mode */
+    int global_alpha;                   /* global_alpha */
+    int rd_mode;
+
+    /* legarcy */
+    int color;                          /* color, used by color fill */
+    im_colorkey_range colorkey_range;   /* range value of color key */
+    im_nn_t nn;
+    int rop_code;
+} rga_buffer_t;
+
+typedef struct im_opt {
+    int color;                          /* color, used by color fill */
+    im_colorkey_range colorkey_range;   /* range value of color key */
+    im_nn_t nn;
+    int rop_code;
+
+    int priority;
+    int core;
+} im_opt_t;
+
+typedef struct im_context {
+    int priority;
+    IM_SCHEDULER_CORE core;
+    bool check_mode;
+} im_context_t;
+
+/*
+ * @return error message string
+ */
+#define imStrError(...) \
+    ({ \
+        const char* im2d_api_err; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_err = imStrError_t(IM_STATUS_INVALID_PARAM); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_err = imStrError_t((IM_STATUS)im2d_api_args[0]); \
+        } else { \
+            im2d_api_err = ("Fatal error, imStrError() too many parameters\n"); \
+            printf("Fatal error, imStrError() too many parameters\n"); \
+        } \
+        im2d_api_err; \
+    })
+IM_API const char* imStrError_t(IM_STATUS status);
+
+/*
+ * @return rga_buffer_t
+ */
+#define wrapbuffer_virtualaddr(vir_addr, width, height, format, ...) \
+    ({ \
+        rga_buffer_t im2d_api_buffer; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_buffer = wrapbuffer_virtualaddr_t(vir_addr, width, height, width, height, format); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_buffer = wrapbuffer_virtualaddr_t(vir_addr, width, height, im2d_api_args[0], im2d_api_args[1], format); \
+        } else { \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_buffer; \
+    })
+
+#define wrapbuffer_physicaladdr(phy_addr, width, height, format, ...) \
+    ({ \
+        rga_buffer_t im2d_api_buffer; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_buffer = wrapbuffer_physicaladdr_t(phy_addr, width, height, width, height, format); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_buffer = wrapbuffer_physicaladdr_t(phy_addr, width, height, im2d_api_args[0], im2d_api_args[1], format); \
+        } else { \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_buffer; \
+    })
+
+#define wrapbuffer_fd(fd, width, height, format, ...) \
+    ({ \
+        rga_buffer_t im2d_api_buffer; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_buffer = wrapbuffer_fd_t(fd, width, height, width, height, format); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_buffer = wrapbuffer_fd_t(fd, width, height, im2d_api_args[0], im2d_api_args[1], format); \
+        } else { \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_buffer; \
+    })
+
+IM_API rga_buffer_t wrapbuffer_virtualaddr_t(void* vir_addr, int width, int height, int wstride, int hstride, int format);
+IM_API rga_buffer_t wrapbuffer_physicaladdr_t(void* phy_addr, int width, int height, int wstride, int hstride, int format);
+IM_API rga_buffer_t wrapbuffer_fd_t(int fd, int width, int height, int wstride, int hstride, int format);
+
+/*
+ * Get RGA basic information, supported resolution, supported format, etc.
+ *
+ * @param name
+ *      RGA_VENDOR
+ *      RGA_VERSION
+ *      RGA_MAX_INPUT
+ *      RGA_MAX_OUTPUT
+ *      RGA_INPUT_FORMAT
+ *      RGA_OUTPUT_FORMAT
+ *      RGA_EXPECTED
+ *      RGA_ALL
+ *
+ * @returns a usage describing properties of RGA.
+ */
+//IM_API int rga_get_info(rga_info_table_entry *);
+IM_API IM_STATUS rga_get_info(rga_info_table_entry *return_table);
+
+/*
+ * Query RGA basic information, supported resolution, supported format, etc.
+ *
+ * @param name
+ *      RGA_VENDOR
+ *      RGA_VERSION
+ *      RGA_MAX_INPUT
+ *      RGA_MAX_OUTPUT
+ *      RGA_INPUT_FORMAT
+ *      RGA_OUTPUT_FORMAT
+ *      RGA_EXPECTED
+ *      RGA_ALL
+ *
+ * @returns a string describing properties of RGA.
+ */
+IM_API const char* querystring(int name);
+
+/*
+ * check RGA basic information, supported resolution, supported format, etc.
+ *
+ * @param src
+ * @param dst
+ * @param src_rect
+ * @param dst_rect
+ * @param mode_usage
+ *
+ * @returns no error or else negative error code.
+ */
+#define imcheck(src, dst, src_rect, dst_rect, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_NOERROR; \
+        rga_buffer_t im2d_api_pat; \
+        im_rect im2d_api_pat_rect; \
+        memset(&im2d_api_pat, 0, sizeof(rga_buffer_t)); \
+        memset(&im2d_api_pat_rect, 0, sizeof(im_rect)); \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            rga_check_perpare((rga_buffer_t *)(&src), (rga_buffer_t *)(&dst), (rga_buffer_t *)(&im2d_api_pat), \
+                              (im_rect *)(&src_rect), (im_rect *)(&dst_rect), (im_rect *)(&im2d_api_pat_rect), 0); \
+            im2d_api_ret = imcheck_t(src, dst, im2d_api_pat, src_rect, dst_rect, im2d_api_pat_rect, 0); \
+        } else if (im2d_api_argc == 1){ \
+            rga_check_perpare((rga_buffer_t *)(&src), (rga_buffer_t *)(&dst), (rga_buffer_t *)(&im2d_api_pat), \
+                              (im_rect *)(&src_rect), (im_rect *)(&dst_rect), (im_rect *)(&im2d_api_pat_rect), im2d_api_args[0]); \
+            im2d_api_ret = imcheck_t(src, dst, im2d_api_pat, src_rect, dst_rect, im2d_api_pat_rect, im2d_api_args[0]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_FAILED; \
+            printf("check failed\n"); \
+        } \
+        im2d_api_ret; \
+    })
+#define imcheck_composite(src, dst, pat, src_rect, dst_rect, pat_rect, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_NOERROR; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            rga_check_perpare((rga_buffer_t *)(&src), (rga_buffer_t *)(&dst), (rga_buffer_t *)(&pat), \
+                              (im_rect *)(&src_rect), (im_rect *)(&dst_rect), (im_rect *)(&pat_rect), 0); \
+            im2d_api_ret = imcheck_t(src, dst, pat, src_rect, dst_rect, pat_rect, 0); \
+        } else if (im2d_api_argc == 1){ \
+            rga_check_perpare((rga_buffer_t *)(&src), (rga_buffer_t *)(&dst), (rga_buffer_t *)(&pat), \
+                              (im_rect *)(&src_rect), (im_rect *)(&dst_rect), (im_rect *)(&pat_rect), im2d_api_args[0]); \
+            im2d_api_ret = imcheck_t(src, dst, pat, src_rect, dst_rect, pat_rect, im2d_api_args[0]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_FAILED; \
+            printf("check failed\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API void rga_check_perpare(rga_buffer_t *src, rga_buffer_t *dst, rga_buffer_t *pat,
+                              im_rect *src_rect, im_rect *dst_rect, im_rect *pat_rect, int mode_usage);
+IM_API IM_STATUS imcheck_t(const rga_buffer_t src, const rga_buffer_t dst, const rga_buffer_t pat,
+                           const im_rect src_rect, const im_rect dst_rect, const im_rect pat_rect, const int mode_usage);
+
+/*
+ * Resize
+ *
+ * @param src
+ * @param dst
+ * @param fx
+ * @param fy
+ * @param interpolation
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imresize(src, dst, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        double im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(double); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imresize_t(src, dst, 0, 0, IM_SCALE_MODE::INTER_LINEAR, 1); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_ret = imresize_t(src, dst, im2d_api_args[0], im2d_api_args[1], IM_SCALE_MODE::INTER_LINEAR, 1); \
+        } else if (im2d_api_argc == 3){ \
+            im2d_api_ret = imresize_t(src, dst, im2d_api_args[0], im2d_api_args[1], (int)im2d_api_args[2], 1); \
+        } else if (im2d_api_argc == 4){ \
+            im2d_api_ret = imresize_t(src, dst, im2d_api_args[0], im2d_api_args[1], (int)im2d_api_args[2], (int)im2d_api_args[3]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+#define impyramid(src, dst, direction) \
+        imresize_t(src, \
+                   dst, \
+                   direction == IM_UP_SCALE ? 0.5 : 2, \
+                   direction == IM_UP_SCALE ? 0.5 : 2, \
+                   INTER_LINEAR, 1)
+
+IM_API IM_STATUS imresize_t(const rga_buffer_t src, rga_buffer_t dst, double fx, double fy, int interpolation, int sync);
+
+/*
+ * Crop
+ *
+ * @param src
+ * @param dst
+ * @param rect
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imcrop(src, dst, rect, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imcrop_t(src, dst, rect, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imcrop_t(src, dst, rect, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imcrop_t(const rga_buffer_t src, rga_buffer_t dst, im_rect rect, int sync);
+
+/*
+ * rotation
+ *
+ * @param src
+ * @param dst
+ * @param rotation
+ *      IM_HAL_TRANSFORM_ROT_90
+ *      IM_HAL_TRANSFORM_ROT_180
+ *      IM_HAL_TRANSFORM_ROT_270
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imrotate(src, dst, rotation, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imrotate_t(src, dst, rotation, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imrotate_t(src, dst, rotation, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imrotate_t(const rga_buffer_t src, rga_buffer_t dst, int rotation, int sync);
+
+/*
+ * flip
+ *
+ * @param src
+ * @param dst
+ * @param mode
+ *      IM_HAL_TRANSFORM_FLIP_H
+ *      IM_HAL_TRANSFORM_FLIP_V
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imflip(src, dst, mode, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imflip_t(src, dst, mode, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imflip_t(src, dst, mode, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imflip_t (const rga_buffer_t src, rga_buffer_t dst, int mode, int sync);
+
+/*
+ * fill/reset/draw
+ *
+ * @param src
+ * @param dst
+ * @param rect
+ * @param color
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imfill(buf, rect, color, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imfill_t(buf, rect, color, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imfill_t(buf, rect, color, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+#define imreset(buf, rect, color, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imfill_t(buf, rect, color, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imfill_t(buf, rect, color, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+#define imdraw(buf, rect, color, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imfill_t(buf, rect, color, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imfill_t(buf, rect, color, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS imfill_t(rga_buffer_t dst, im_rect rect, int color, int sync);
+
+/*
+ * palette
+ *
+ * @param src
+ * @param dst
+ * @param lut
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define impalette(src, dst, lut,  ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = impalette_t(src, dst, lut, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = impalette_t(src, dst, lut, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS impalette_t(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t lut, int sync);
+
+/*
+ * translate
+ *
+ * @param src
+ * @param dst
+ * @param x
+ * @param y
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imtranslate(src, dst, x, y, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imtranslate_t(src, dst, x, y, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imtranslate_t(src, dst, x, y, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS imtranslate_t(const rga_buffer_t src, rga_buffer_t dst, int x, int y, int sync);
+
+/*
+ * copy
+ *
+ * @param src
+ * @param dst
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imcopy(src, dst, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imcopy_t(src, dst, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imcopy_t(src, dst, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imcopy_t(const rga_buffer_t src, rga_buffer_t dst, int sync);
+
+/*
+ * blend (SRC + DST -> DST or SRCA + SRCB -> DST)
+ *
+ * @param srcA
+ * @param srcB can be NULL.
+ * @param dst
+ * @param mode
+ *      IM_ALPHA_BLEND_MODE
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imblend(srcA, dst, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        rga_buffer_t srcB; \
+        memset(&srcB, 0x00, sizeof(rga_buffer_t)); \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, IM_ALPHA_BLEND_SRC_OVER, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, im2d_api_args[0], 1); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, im2d_api_args[0], im2d_api_args[1]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+#define imcomposite(srcA, srcB, dst, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, IM_ALPHA_BLEND_SRC_OVER, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, im2d_api_args[0], 1); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_ret = imblend_t(srcA, srcB, dst, im2d_api_args[0], im2d_api_args[1]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS imblend_t(const rga_buffer_t srcA, const rga_buffer_t srcB, rga_buffer_t dst, int mode, int sync);
+
+/*
+ * color key
+ *
+ * @param src
+ * @param dst
+ * @param colorkey_range
+ *      max color
+ *      min color
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imcolorkey(src, dst, range, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imcolorkey_t(src, dst, range, IM_ALPHA_COLORKEY_NORMAL, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imcolorkey_t(src, dst, range, im2d_api_args[0], 1); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_ret = imcolorkey_t(src, dst, range, im2d_api_args[0], im2d_api_args[1]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS imcolorkey_t(const rga_buffer_t src, rga_buffer_t dst, im_colorkey_range range, int mode, int sync);
+
+/*
+ * format convert
+ *
+ * @param src
+ * @param dst
+ * @param sfmt
+ * @param dfmt
+ * @param mode
+ *      color space mode: IM_COLOR_SPACE_MODE
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imcvtcolor(src, dst, sfmt, dfmt, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imcvtcolor_t(src, dst, sfmt, dfmt, IM_COLOR_SPACE_DEFAULT, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imcvtcolor_t(src, dst, sfmt, dfmt, im2d_api_args[0], 1); \
+        } else if (im2d_api_argc == 2){ \
+            im2d_api_ret = imcvtcolor_t(src, dst, sfmt, dfmt, im2d_api_args[0], im2d_api_args[1]); \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imcvtcolor_t(rga_buffer_t src, rga_buffer_t dst, int sfmt, int dfmt, int mode, int sync);
+
+/*
+ * nn quantize
+ *
+ * @param src
+ * @param dst
+ * @param nninfo
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imquantize(src, dst, nn_info, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imquantize_t(src, dst, nn_info, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imquantize_t(src, dst, nn_info, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+
+IM_API IM_STATUS imquantize_t(const rga_buffer_t src, rga_buffer_t dst, im_nn_t nn_info, int sync);
+
+/*
+ * ROP
+ *
+ * @param src
+ * @param dst
+ * @param rop_code
+ * @param sync
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+#define imrop(src, dst, rop_code, ...) \
+    ({ \
+        IM_STATUS im2d_api_ret = IM_STATUS_SUCCESS; \
+        int im2d_api_args[] = {__VA_ARGS__}; \
+        int im2d_api_argc = sizeof(im2d_api_args)/sizeof(int); \
+        if (im2d_api_argc == 0) { \
+            im2d_api_ret = imrop_t(src, dst, rop_code, 1); \
+        } else if (im2d_api_argc == 1){ \
+            im2d_api_ret = imrop_t(src, dst, rop_code, im2d_api_args[0]);; \
+        } else { \
+            im2d_api_ret = IM_STATUS_INVALID_PARAM; \
+            printf("invalid parameter\n"); \
+        } \
+        im2d_api_ret; \
+    })
+IM_API IM_STATUS imrop_t(const rga_buffer_t src, rga_buffer_t dst, int rop_code, int sync);
+
+/*
+ * process
+ *
+ * @param src
+ * @param dst
+ * @param usage
+ * @param ...
+ *      wait until operation complete
+ *
+ * @returns success or else negative error code.
+ */
+IM_API IM_STATUS improcess(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat,
+                        im_rect srect, im_rect drect, im_rect prect, int usage);
+
+IM_API IM_STATUS improcess_t(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat,
+                        im_rect srect, im_rect drect, im_rect prect,
+                        int in_fence_fd, int *out_fence_fd, im_opt_t *opt, int usage);
+
+/*
+ * block until all execution is complete
+ *
+ * @returns success or else negative error code.
+ */
+IM_API IM_STATUS imsync(int out_fence_fd);
+
+/*
+ * config
+ *
+ * @param name
+ *      enum IM_CONFIG_NAME
+ * @param value
+ *
+ * @returns success or else negative error code.
+ */
+IM_API IM_STATUS imconfig(IM_CONFIG_NAME name, uint64_t value);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* _im2d_h_ */
+
diff --git a/C++/yolo_bytetrack_old/3rdparty/rga/include/im2d.hpp b/C++/yolo_bytetrack_old/3rdparty/rga/include/im2d.hpp
new file mode 100644
index 00000000..c3bba243
--- /dev/null
+++ b/C++/yolo_bytetrack_old/3rdparty/rga/include/im2d.hpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 Rockchip Electronics Co., Ltd.
+ * Authors:
+ *  PutinLee <putin.lee@rock-chips.com>
+ *  Cerf Yu <cerf.yu@rock-chips.com>
+ *
+ * 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.
+ */
+#ifndef _im2d_hpp_
+#define _im2d_hpp_
+
+#include "im2d.h"
+#include "RgaUtils.h"
+
+#ifdef ANDROID
+
+#include <ui/GraphicBuffer.h>
+
+using namespace android;
+
+IM_API rga_buffer_t wrapbuffer_handle(buffer_handle_t hnd);
+IM_API rga_buffer_t wrapbuffer_GraphicBuffer(sp<GraphicBuffer> buf);
+
+#if USE_AHARDWAREBUFFER
+#include <android/hardware_buffer.h>
+IM_API rga_buffer_t wrapbuffer_AHardwareBuffer(AHardwareBuffer *buf);
+
+#endif /* USE_AHARDWAREBUFFER */
+#endif /* ANDROID */
+#endif /* _im2d_hpp_ */
+
diff --git a/C++/yolo_bytetrack_old/3rdparty/rga/include/rga.h b/C++/yolo_bytetrack_old/3rdparty/rga/include/rga.h
new file mode 100644
index 00000000..8af08be7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/3rdparty/rga/include/rga.h
@@ -0,0 +1,392 @@
+/*
+ * Copyright (C) 2016 Rockchip Electronics Co., Ltd.
+ * Authors:
+ *    Zhiqin Wei <wzq@rock-chips.com>
+ *
+ * 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.
+ */
+
+#ifndef _RGA_DRIVER_H_
+#define _RGA_DRIVER_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+
+#define RGA_BLIT_SYNC   0x5017
+#define RGA_BLIT_ASYNC  0x5018
+#define RGA_FLUSH       0x5019
+#define RGA_GET_RESULT  0x501a
+#define RGA_GET_VERSION 0x501b
+
+#define RGA2_BLIT_SYNC   0x6017
+#define RGA2_BLIT_ASYNC  0x6018
+#define RGA2_FLUSH       0x6019
+#define RGA2_GET_RESULT  0x601a
+#define RGA2_GET_VERSION 0x601b
+#define RGA2_GET_VERSION 0x601b
+
+#define RGA_REG_CTRL_LEN    0x8    /* 8  */
+#define RGA_REG_CMD_LEN     0x1c   /* 28 */
+#define RGA_CMD_BUF_SIZE    0x700  /* 16*28*4 */
+
+#ifndef ENABLE
+#define ENABLE 1
+#endif
+
+#ifndef DISABLE
+#define DISABLE 0
+#endif
+
+/* RGA process mode enum */
+enum {
+    bitblt_mode               = 0x0,
+    color_palette_mode        = 0x1,
+    color_fill_mode           = 0x2,
+    line_point_drawing_mode   = 0x3,
+    blur_sharp_filter_mode    = 0x4,
+    pre_scaling_mode          = 0x5,
+    update_palette_table_mode = 0x6,
+    update_patten_buff_mode   = 0x7,
+};
+
+
+enum {
+    rop_enable_mask          = 0x2,
+    dither_enable_mask       = 0x8,
+    fading_enable_mask       = 0x10,
+    PD_enbale_mask           = 0x20,
+};
+
+enum {
+    yuv2rgb_mode0            = 0x0,     /* BT.601 MPEG */
+    yuv2rgb_mode1            = 0x1,     /* BT.601 JPEG */
+    yuv2rgb_mode2            = 0x2,     /* BT.709      */
+
+    rgb2yuv_601_full                = 0x1 << 8,
+    rgb2yuv_709_full                = 0x2 << 8,
+    yuv2yuv_601_limit_2_709_limit   = 0x3 << 8,
+    yuv2yuv_601_limit_2_709_full    = 0x4 << 8,
+    yuv2yuv_709_limit_2_601_limit   = 0x5 << 8,
+    yuv2yuv_709_limit_2_601_full    = 0x6 << 8,     //not support
+    yuv2yuv_601_full_2_709_limit    = 0x7 << 8,
+    yuv2yuv_601_full_2_709_full     = 0x8 << 8,     //not support
+    yuv2yuv_709_full_2_601_limit    = 0x9 << 8,     //not support
+    yuv2yuv_709_full_2_601_full     = 0xa << 8,     //not support
+    full_csc_mask = 0xf00,
+};
+
+/* RGA rotate mode */
+enum {
+    rotate_mode0             = 0x0,     /* no rotate */
+    rotate_mode1             = 0x1,     /* rotate    */
+    rotate_mode2             = 0x2,     /* x_mirror  */
+    rotate_mode3             = 0x3,     /* y_mirror  */
+};
+
+enum {
+    color_palette_mode0      = 0x0,     /* 1K */
+    color_palette_mode1      = 0x1,     /* 2K */
+    color_palette_mode2      = 0x2,     /* 4K */
+    color_palette_mode3      = 0x3,     /* 8K */
+};
+
+enum {
+    BB_BYPASS   = 0x0,     /* no rotate */
+    BB_ROTATE   = 0x1,     /* rotate    */
+    BB_X_MIRROR = 0x2,     /* x_mirror  */
+    BB_Y_MIRROR = 0x3      /* y_mirror  */
+};
+
+enum {
+    nearby   = 0x0,     /* no rotate */
+    bilinear = 0x1,     /* rotate    */
+    bicubic  = 0x2,     /* x_mirror  */
+};
+
+#define RGA_SCHED_PRIORITY_DEFAULT 0
+#define RGA_SCHED_PRIORITY_MAX 6
+
+enum {
+	RGA3_SCHEDULER_CORE0		= 1 << 0,
+	RGA3_SCHEDULER_CORE1		= 1 << 1,
+	RGA2_SCHEDULER_CORE0		= 1 << 2,
+};
+
+/*
+//          Alpha    Red     Green   Blue
+{  4, 32, {{32,24,   8, 0,  16, 8,  24,16 }}, GGL_RGBA },   // RK_FORMAT_RGBA_8888
+{  4, 24, {{ 0, 0,   8, 0,  16, 8,  24,16 }}, GGL_RGB  },   // RK_FORMAT_RGBX_8888
+{  3, 24, {{ 0, 0,   8, 0,  16, 8,  24,16 }}, GGL_RGB  },   // RK_FORMAT_RGB_888
+{  4, 32, {{32,24,  24,16,  16, 8,   8, 0 }}, GGL_BGRA },   // RK_FORMAT_BGRA_8888
+{  2, 16, {{ 0, 0,  16,11,  11, 5,   5, 0 }}, GGL_RGB  },   // RK_FORMAT_RGB_565
+{  2, 16, {{ 1, 0,  16,11,  11, 6,   6, 1 }}, GGL_RGBA },   // RK_FORMAT_RGBA_5551
+{  2, 16, {{ 4, 0,  16,12,  12, 8,   8, 4 }}, GGL_RGBA },   // RK_FORMAT_RGBA_4444
+{  3, 24, {{ 0, 0,  24,16,  16, 8,   8, 0 }}, GGL_BGR  },   // RK_FORMAT_BGB_888
+
+*/
+/* In order to be compatible with RK_FORMAT_XX and HAL_PIXEL_FORMAT_XX,
+ * RK_FORMAT_XX is shifted to the left by 8 bits to distinguish.  */
+typedef enum _Rga_SURF_FORMAT {
+    RK_FORMAT_RGBA_8888    = 0x0 << 8,
+    RK_FORMAT_RGBX_8888    = 0x1 << 8,
+    RK_FORMAT_RGB_888      = 0x2 << 8,
+    RK_FORMAT_BGRA_8888    = 0x3 << 8,
+    RK_FORMAT_RGB_565      = 0x4 << 8,
+    RK_FORMAT_RGBA_5551    = 0x5 << 8,
+    RK_FORMAT_RGBA_4444    = 0x6 << 8,
+    RK_FORMAT_BGR_888      = 0x7 << 8,
+
+    RK_FORMAT_YCbCr_422_SP = 0x8 << 8,
+    RK_FORMAT_YCbCr_422_P  = 0x9 << 8,
+    RK_FORMAT_YCbCr_420_SP = 0xa << 8,
+    RK_FORMAT_YCbCr_420_P  = 0xb << 8,
+
+    RK_FORMAT_YCrCb_422_SP = 0xc << 8,
+    RK_FORMAT_YCrCb_422_P  = 0xd << 8,
+    RK_FORMAT_YCrCb_420_SP = 0xe << 8,
+    RK_FORMAT_YCrCb_420_P  = 0xf << 8,
+
+    RK_FORMAT_BPP1         = 0x10 << 8,
+    RK_FORMAT_BPP2         = 0x11 << 8,
+    RK_FORMAT_BPP4         = 0x12 << 8,
+    RK_FORMAT_BPP8         = 0x13 << 8,
+
+    RK_FORMAT_Y4           = 0x14 << 8,
+    RK_FORMAT_YCbCr_400    = 0x15 << 8,
+
+    RK_FORMAT_BGRX_8888    = 0x16 << 8,
+
+    RK_FORMAT_YVYU_422     = 0x18 << 8,
+    RK_FORMAT_YVYU_420     = 0x19 << 8,
+    RK_FORMAT_VYUY_422     = 0x1a << 8,
+    RK_FORMAT_VYUY_420     = 0x1b << 8,
+    RK_FORMAT_YUYV_422     = 0x1c << 8,
+    RK_FORMAT_YUYV_420     = 0x1d << 8,
+    RK_FORMAT_UYVY_422     = 0x1e << 8,
+    RK_FORMAT_UYVY_420     = 0x1f << 8,
+
+    RK_FORMAT_YCbCr_420_SP_10B = 0x20 << 8,
+    RK_FORMAT_YCrCb_420_SP_10B = 0x21 << 8,
+    RK_FORMAT_YCbCr_422_10b_SP = 0x22 << 8,
+    RK_FORMAT_YCrCb_422_10b_SP = 0x23 << 8,
+
+    RK_FORMAT_BGR_565      = 0x24 << 8,
+    RK_FORMAT_BGRA_5551    = 0x25 << 8,
+    RK_FORMAT_BGRA_4444    = 0x26 << 8,
+
+    RK_FORMAT_ARGB_8888    = 0x28 << 8,
+    RK_FORMAT_XRGB_8888    = 0x29 << 8,
+    RK_FORMAT_ARGB_5551    = 0x2a << 8,
+    RK_FORMAT_ARGB_4444    = 0x2b << 8,
+    RK_FORMAT_ABGR_8888    = 0x2c << 8,
+    RK_FORMAT_XBGR_8888    = 0x2d << 8,
+    RK_FORMAT_ABGR_5551    = 0x2e << 8,
+    RK_FORMAT_ABGR_4444    = 0x2f << 8,
+
+    RK_FORMAT_UNKNOWN      = 0x100 << 8,
+} RgaSURF_FORMAT;
+
+/* RGA3 rd_mode */
+enum
+{
+    raster_mode             = 0x1 << 0,
+    afbc_mode               = 0x1 << 1,
+    tile_mode               = 0x1 << 2,
+};
+
+typedef struct rga_img_info_t {
+    uint64_t yrgb_addr;          /* yrgb    mem addr         */
+    uint64_t uv_addr;            /* cb/cr   mem addr         */
+    uint64_t v_addr;             /* cr      mem addr         */
+
+    uint32_t format;             //definition by RK_FORMAT
+    uint16_t act_w;
+    uint16_t act_h;
+    uint16_t x_offset;
+    uint16_t y_offset;
+
+    uint16_t vir_w;
+    uint16_t vir_h;
+
+    uint16_t endian_mode; //for BPP
+    uint16_t alpha_swap;
+
+	//used by RGA3
+	uint16_t rotate_mode;
+    uint16_t rd_mode;
+
+	uint16_t is_10b_compact;
+	uint16_t is_10b_endian;
+
+	uint16_t enable;
+}
+rga_img_info_t;
+
+typedef struct POINT {
+    uint16_t x;
+    uint16_t y;
+}
+POINT;
+
+typedef struct RECT {
+    uint16_t xmin;
+    uint16_t xmax; // width - 1
+    uint16_t ymin;
+    uint16_t ymax; // height - 1
+} RECT;
+
+typedef struct MMU {
+    uint8_t mmu_en;
+    uint64_t base_addr;
+    uint32_t mmu_flag;     /* [0] mmu enable [1] src_flush [2] dst_flush [3] CMD_flush [4~5] page size*/
+} MMU;
+
+typedef struct COLOR_FILL {
+    int16_t gr_x_a;
+    int16_t gr_y_a;
+    int16_t gr_x_b;
+    int16_t gr_y_b;
+    int16_t gr_x_g;
+    int16_t gr_y_g;
+    int16_t gr_x_r;
+    int16_t gr_y_r;
+    //u8  cp_gr_saturation;
+}
+COLOR_FILL;
+
+typedef struct FADING {
+    uint8_t b;
+    uint8_t g;
+    uint8_t r;
+    uint8_t res;
+}
+FADING;
+
+typedef struct line_draw_t {
+    POINT start_point;                  /* LineDraw_start_point                */
+    POINT end_point;                    /* LineDraw_end_point                  */
+    uint32_t   color;                   /* LineDraw_color                      */
+    uint32_t   flag;                    /* (enum) LineDrawing mode sel         */
+    uint32_t   line_width;              /* range 1~16 */
+}
+line_draw_t;
+
+/* color space convert coefficient. */
+typedef struct csc_coe_t {
+    int16_t r_v;
+    int16_t g_y;
+    int16_t b_u;
+    int32_t off;
+} csc_coe_t;
+
+typedef struct full_csc_t {
+    uint8_t flag;
+    csc_coe_t coe_y;
+    csc_coe_t coe_u;
+    csc_coe_t coe_v;
+} full_csc_t;
+
+struct rga_req {
+    uint8_t render_mode;                  /* (enum) process mode sel */
+
+    rga_img_info_t src;                   /* src image info */
+    rga_img_info_t dst;                   /* dst image info */
+    rga_img_info_t pat;                   /* patten image info */
+
+    uint64_t rop_mask_addr;               /* rop4 mask addr */
+    uint64_t LUT_addr;                    /* LUT addr */
+
+    RECT clip;                            /* dst clip window default value is dst_vir */
+                                          /* value from [0, w-1] / [0, h-1]*/
+
+    int32_t sina;                         /* dst angle  default value 0  16.16 scan from table */
+    int32_t cosa;                         /* dst angle  default value 0  16.16 scan from table */
+
+    uint16_t alpha_rop_flag;              /* alpha rop process flag           */
+                                          /* ([0] = 1 alpha_rop_enable)       */
+                                          /* ([1] = 1 rop enable)             */
+                                          /* ([2] = 1 fading_enable)          */
+                                          /* ([3] = 1 PD_enable)              */
+                                          /* ([4] = 1 alpha cal_mode_sel)     */
+                                          /* ([5] = 1 dither_enable)          */
+                                          /* ([6] = 1 gradient fill mode sel) */
+                                          /* ([7] = 1 AA_enable)              */
+                                          /* ([8] = 1 nn_quantize)            */
+                                          /* ([9] = 1 Real color mode)        */
+
+    uint8_t  scale_mode;                  /* 0 nearst / 1 bilnear / 2 bicubic */
+
+    uint32_t color_key_max;               /* color key max */
+    uint32_t color_key_min;               /* color key min */
+
+    uint32_t fg_color;                    /* foreground color */
+    uint32_t bg_color;                    /* background color */
+
+    COLOR_FILL gr_color;                  /* color fill use gradient */
+
+    line_draw_t line_draw_info;
+
+    FADING fading;
+
+    uint8_t PD_mode;                      /* porter duff alpha mode sel */
+
+    uint8_t alpha_global_value;           /* global alpha value */
+
+    uint16_t rop_code;                    /* rop2/3/4 code  scan from rop code table*/
+
+    uint8_t bsfilter_flag;                /* [2] 0 blur 1 sharp / [1:0] filter_type*/
+
+    uint8_t palette_mode;                 /* (enum) color palatte  0/1bpp, 1/2bpp 2/4bpp 3/8bpp*/
+
+    uint8_t yuv2rgb_mode;                 /* (enum) BT.601 MPEG / BT.601 JPEG / BT.709  */
+
+    uint8_t endian_mode;                  /* 0/big endian 1/little endian*/
+
+    uint8_t rotate_mode;                  /* (enum) rotate mode  */
+                                          /* 0x0,     no rotate  */
+                                          /* 0x1,     rotate     */
+                                          /* 0x2,     x_mirror   */
+                                          /* 0x3,     y_mirror   */
+
+    uint8_t color_fill_mode;              /* 0 solid color / 1 patten color */
+
+    MMU mmu_info;                         /* mmu information */
+
+    uint8_t  alpha_rop_mode;              /* ([0~1] alpha mode)       */
+                                          /* ([2~3] rop   mode)       */
+                                          /* ([4]   zero  mode en)    */
+                                          /* ([5]   dst   alpha mode) (RGA1) */
+
+    uint8_t  src_trans_mode;
+
+    uint8_t  dither_mode;
+
+    full_csc_t full_csc;                  /* full color space convert */
+
+	int32_t in_fence_fd;
+    uint8_t core;
+    uint8_t priority;
+    int32_t out_fence_fd;
+
+	uint8_t reservr[128];
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_RK29_IPP_DRIVER_H_*/
diff --git a/C++/yolo_bytetrack_old/3rdparty/rga/lib/librga.so b/C++/yolo_bytetrack_old/3rdparty/rga/lib/librga.so
new file mode 100644
index 00000000..152ebf37
Binary files /dev/null and b/C++/yolo_bytetrack_old/3rdparty/rga/lib/librga.so differ
diff --git a/C++/yolo_bytetrack_old/CMakeLists.txt b/C++/yolo_bytetrack_old/CMakeLists.txt
new file mode 100644
index 00000000..41b6fcc0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/CMakeLists.txt
@@ -0,0 +1,59 @@
+cmake_minimum_required(VERSION 3.16.3)
+
+project(yolo_bytetrack)
+
+# 
+set(TOOLCHAIN_DIR /home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf) 
+set(CMAKE_CXX_COMPILER ${TOOLCHAIN_DIR}/bin/arm-linux-gnueabihf-g++)
+set(CMAKE_C_COMPILER ${TOOLCHAIN_DIR}/bin/arm-linux-gnueabihf-gcc)
+
+set(OpenCV_DIR /home/huey/opencv-4.7.0/install/lib/cmake/opencv4)  # 填入OpenCVConfig.cmake
+find_package(OpenCV 4 REQUIRED)
+include_directories(${OpenCV_INCLUDE_DIRS})
+
+set(OPENSSL_ROOT_DIR /home/huey/openssl/install/include/)
+set(OPENSSL_SSL_LIBRARY /home/huey/openssl/install/lib/libssl.so)
+set(OPENSSL_CRYPTO_LIBRARY /home/huey/openssl/install/lib/libcrypto.so)
+set(pkgcfg_lib__OPENSSL_crypto /home/huey/openssl/install/lib/libcrypto.so)
+set(pkgcfg_lib__OPENSSL_ssl /home/huey/openssl/install/lib/libssl.so)
+
+find_package(OpenSSL REQUIRED)
+include_directories(${OPENSSL_INCLUDE_DIR})
+
+
+# install target and libraries
+set(CMAKE_INSTALL_PREFIX ${CMAKE_SOURCE_DIR}/install/rknn_yolov5_1109_new_${CMAKE_SYSTEM_NAME})
+
+set(CMAKE_SKIP_INSTALL_RPATH FALSE)
+set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+
+set(
+  include_libs
+  "${PROJECT_SOURCE_DIR}/include"
+  ${PROJECT_SOURCE_DIR}/3rdparty/librknn_api/include
+  ${PROJECT_SOURCE_DIR}/3rdparty/rga/include
+)
+
+include_directories(${include_libs})
+
+add_executable(yolo_bytetrack
+	src/bytetrack.cpp
+	src/BYTETracker.cpp
+	src/kalmanFilter.cpp
+  src/lapjv.cpp
+  src/STrack.cpp
+  src/utils.cpp
+)
+set(
+  link_libs pthread
+  ${PROJECT_SOURCE_DIR}/3rdparty/librknn_api/armhf/librknn_api.so
+  ${PROJECT_SOURCE_DIR}/3rdparty/rga/lib/librga.so
+)
+
+target_link_libraries(yolo_bytetrack
+  ${OpenCV_LIBS}
+  ${OPENSSL_LIBRARIES}
+  ${link_libs}
+)
+
diff --git a/C++/yolo_bytetrack_old/build/CMakeCache.txt b/C++/yolo_bytetrack_old/build/CMakeCache.txt
new file mode 100644
index 00000000..ecedcb2d
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeCache.txt
@@ -0,0 +1,420 @@
+# This is the CMakeCache file.
+# For build in directory: /home/huey/Desktop/C/yolo_bytetrack/build
+# It was generated by CMake: /usr/bin/cmake
+# You can edit this file to change values found and used by cmake.
+# If you do not want to change any of the values, simply exit the editor.
+# If you do want to change a value, simply edit, save, and exit the editor.
+# The syntax for the file is as follows:
+# KEY:TYPE=VALUE
+# KEY is the name of a variable in the cache.
+# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
+# VALUE is the current value for the KEY.
+
+########################
+# EXTERNAL cache entries
+########################
+
+//Path to a program.
+CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line
+
+//Path to a program.
+CMAKE_AR:FILEPATH=/usr/bin/ar
+
+//Choose the type of build, options are: None Debug Release RelWithDebInfo
+// MinSizeRel ...
+CMAKE_BUILD_TYPE:STRING=
+
+//Enable/Disable color output during build.
+CMAKE_COLOR_MAKEFILE:BOOL=ON
+
+//CXX compiler
+CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++
+
+//A wrapper around 'ar' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_CXX_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar-9
+
+//A wrapper around 'ranlib' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-9
+
+//Flags used by the CXX compiler during all build types.
+CMAKE_CXX_FLAGS:STRING=
+
+//Flags used by the CXX compiler during DEBUG builds.
+CMAKE_CXX_FLAGS_DEBUG:STRING=-g
+
+//Flags used by the CXX compiler during MINSIZEREL builds.
+CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
+
+//Flags used by the CXX compiler during RELEASE builds.
+CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
+
+//Flags used by the CXX compiler during RELWITHDEBINFO builds.
+CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
+
+//C compiler
+CMAKE_C_COMPILER:FILEPATH=/usr/bin/cc
+
+//A wrapper around 'ar' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_C_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar-9
+
+//A wrapper around 'ranlib' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_C_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-9
+
+//Flags used by the C compiler during all build types.
+CMAKE_C_FLAGS:STRING=
+
+//Flags used by the C compiler during DEBUG builds.
+CMAKE_C_FLAGS_DEBUG:STRING=-g
+
+//Flags used by the C compiler during MINSIZEREL builds.
+CMAKE_C_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
+
+//Flags used by the C compiler during RELEASE builds.
+CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
+
+//Flags used by the C compiler during RELWITHDEBINFO builds.
+CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
+
+//Path to a program.
+CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND
+
+//Flags used by the linker during all build types.
+CMAKE_EXE_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during DEBUG builds.
+CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during MINSIZEREL builds.
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during RELEASE builds.
+CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during RELWITHDEBINFO builds.
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Enable/Disable output of compile commands during generation.
+CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=OFF
+
+//Install path prefix, prepended onto install directories.
+CMAKE_INSTALL_PREFIX:PATH=/usr/local
+
+//Path to a program.
+CMAKE_LINKER:FILEPATH=/usr/bin/ld
+
+//Path to a program.
+CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/make
+
+//Flags used by the linker during the creation of modules during
+// all build types.
+CMAKE_MODULE_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of modules during
+// DEBUG builds.
+CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of modules during
+// MINSIZEREL builds.
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of modules during
+// RELEASE builds.
+CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of modules during
+// RELWITHDEBINFO builds.
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Path to a program.
+CMAKE_NM:FILEPATH=/usr/bin/nm
+
+//Path to a program.
+CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy
+
+//Path to a program.
+CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump
+
+//Value Computed by CMake
+CMAKE_PROJECT_DESCRIPTION:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_HOMEPAGE_URL:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_NAME:STATIC=yolo_bytetrack
+
+//Path to a program.
+CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib
+
+//Path to a program.
+CMAKE_READELF:FILEPATH=/usr/bin/readelf
+
+//Flags used by the linker during the creation of shared libraries
+// during all build types.
+CMAKE_SHARED_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during DEBUG builds.
+CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during MINSIZEREL builds.
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during RELEASE builds.
+CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during RELWITHDEBINFO builds.
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//If set, runtime paths are not added when installing shared libraries,
+// but are added when building.
+CMAKE_SKIP_INSTALL_RPATH:BOOL=NO
+
+//If set, runtime paths are not added when using shared libraries.
+CMAKE_SKIP_RPATH:BOOL=NO
+
+//Flags used by the linker during the creation of static libraries
+// during all build types.
+CMAKE_STATIC_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during DEBUG builds.
+CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during MINSIZEREL builds.
+CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during RELEASE builds.
+CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during RELWITHDEBINFO builds.
+CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Path to a program.
+CMAKE_STRIP:FILEPATH=/usr/bin/strip
+
+//If this value is on, makefiles will be generated without the
+// .SILENT directive, and all commands will be echoed to the console
+// during the make.  This is useful for debugging only. With Visual
+// Studio IDE projects all commands are done without /nologo.
+CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE
+
+//Path to a file.
+OPENSSL_INCLUDE_DIR:PATH=/home/huey/openssl/install/include
+
+//pkg-config executable
+PKG_CONFIG_EXECUTABLE:FILEPATH=/usr/bin/pkg-config
+
+//Value Computed by CMake
+yolo_bytetrack_BINARY_DIR:STATIC=/home/huey/Desktop/C/yolo_bytetrack/build
+
+//Value Computed by CMake
+yolo_bytetrack_SOURCE_DIR:STATIC=/home/huey/Desktop/C/yolo_bytetrack
+
+
+########################
+# INTERNAL cache entries
+########################
+
+//ADVANCED property for variable: CMAKE_ADDR2LINE
+CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_AR
+CMAKE_AR-ADVANCED:INTERNAL=1
+//This is the directory where this CMakeCache.txt was created
+CMAKE_CACHEFILE_DIR:INTERNAL=/home/huey/Desktop/C/yolo_bytetrack/build
+//Major version of cmake used to create the current loaded cache
+CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3
+//Minor version of cmake used to create the current loaded cache
+CMAKE_CACHE_MINOR_VERSION:INTERNAL=16
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=3
+//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
+CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/usr/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest
+//ADVANCED property for variable: CMAKE_CXX_COMPILER
+CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR
+CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB
+CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS
+CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG
+CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL
+CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE
+CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO
+CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER
+CMAKE_C_COMPILER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER_AR
+CMAKE_C_COMPILER_AR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER_RANLIB
+CMAKE_C_COMPILER_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS
+CMAKE_C_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG
+CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL
+CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE
+CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO
+CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_DLLTOOL
+CMAKE_DLLTOOL-ADVANCED:INTERNAL=1
+//Path to cache edit program executable.
+CMAKE_EDIT_COMMAND:INTERNAL=/usr/bin/cmake-gui
+//Executable file format
+CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS
+CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG
+CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE
+CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS
+CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1
+//Name of external makefile project generator.
+CMAKE_EXTRA_GENERATOR:INTERNAL=
+//Name of generator.
+CMAKE_GENERATOR:INTERNAL=Unix Makefiles
+//Generator instance identifier.
+CMAKE_GENERATOR_INSTANCE:INTERNAL=
+//Name of generator platform.
+CMAKE_GENERATOR_PLATFORM:INTERNAL=
+//Name of generator toolset.
+CMAKE_GENERATOR_TOOLSET:INTERNAL=
+//Source directory with the top level CMakeLists.txt file for this
+// project
+CMAKE_HOME_DIRECTORY:INTERNAL=/home/huey/Desktop/C/yolo_bytetrack
+//Install .so files without execute permission.
+CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1
+//ADVANCED property for variable: CMAKE_LINKER
+CMAKE_LINKER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MAKE_PROGRAM
+CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS
+CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG
+CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE
+CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_NM
+CMAKE_NM-ADVANCED:INTERNAL=1
+//number of local generators
+CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1
+//ADVANCED property for variable: CMAKE_OBJCOPY
+CMAKE_OBJCOPY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_OBJDUMP
+CMAKE_OBJDUMP-ADVANCED:INTERNAL=1
+//Platform information initialized
+CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_RANLIB
+CMAKE_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_READELF
+CMAKE_READELF-ADVANCED:INTERNAL=1
+//Path to CMake installation.
+CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.16
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS
+CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG
+CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE
+CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH
+CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_RPATH
+CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS
+CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG
+CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL
+CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE
+CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STRIP
+CMAKE_STRIP-ADVANCED:INTERNAL=1
+//uname command
+CMAKE_UNAME:INTERNAL=/usr/bin/uname
+//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
+CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
+//Details about finding OpenCV
+FIND_PACKAGE_MESSAGE_DETAILS_OpenCV:INTERNAL=[/home/huey/opencv-4.7.0/install][v4.7.0(4)]
+//Details about finding OpenSSL
+FIND_PACKAGE_MESSAGE_DETAILS_OpenSSL:INTERNAL=[/home/huey/openssl/install/lib/libcrypto.so][/home/huey/openssl/install/include][c ][v()]
+//ADVANCED property for variable: OPENSSL_INCLUDE_DIR
+OPENSSL_INCLUDE_DIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: PKG_CONFIG_EXECUTABLE
+PKG_CONFIG_EXECUTABLE-ADVANCED:INTERNAL=1
+_OPENSSL_CFLAGS:INTERNAL=
+_OPENSSL_CFLAGS_I:INTERNAL=
+_OPENSSL_CFLAGS_OTHER:INTERNAL=
+_OPENSSL_FOUND:INTERNAL=1
+_OPENSSL_INCLUDEDIR:INTERNAL=/usr/include
+_OPENSSL_INCLUDE_DIRS:INTERNAL=
+_OPENSSL_LDFLAGS:INTERNAL=-lssl;-lcrypto
+_OPENSSL_LDFLAGS_OTHER:INTERNAL=
+_OPENSSL_LIBDIR:INTERNAL=/usr/lib/x86_64-linux-gnu
+_OPENSSL_LIBRARIES:INTERNAL=ssl;crypto
+_OPENSSL_LIBRARY_DIRS:INTERNAL=
+_OPENSSL_LIBS:INTERNAL=
+_OPENSSL_LIBS_L:INTERNAL=
+_OPENSSL_LIBS_OTHER:INTERNAL=
+_OPENSSL_LIBS_PATHS:INTERNAL=
+_OPENSSL_MODULE_NAME:INTERNAL=openssl
+_OPENSSL_PREFIX:INTERNAL=/usr
+_OPENSSL_STATIC_CFLAGS:INTERNAL=
+_OPENSSL_STATIC_CFLAGS_I:INTERNAL=
+_OPENSSL_STATIC_CFLAGS_OTHER:INTERNAL=
+_OPENSSL_STATIC_INCLUDE_DIRS:INTERNAL=
+_OPENSSL_STATIC_LDFLAGS:INTERNAL=-lssl;-lcrypto;-ldl;-pthread
+_OPENSSL_STATIC_LDFLAGS_OTHER:INTERNAL=-pthread
+_OPENSSL_STATIC_LIBDIR:INTERNAL=
+_OPENSSL_STATIC_LIBRARIES:INTERNAL=ssl;crypto;dl
+_OPENSSL_STATIC_LIBRARY_DIRS:INTERNAL=
+_OPENSSL_STATIC_LIBS:INTERNAL=
+_OPENSSL_STATIC_LIBS_L:INTERNAL=
+_OPENSSL_STATIC_LIBS_OTHER:INTERNAL=
+_OPENSSL_STATIC_LIBS_PATHS:INTERNAL=
+_OPENSSL_VERSION:INTERNAL=1.1.1f
+_OPENSSL_openssl_INCLUDEDIR:INTERNAL=
+_OPENSSL_openssl_LIBDIR:INTERNAL=
+_OPENSSL_openssl_PREFIX:INTERNAL=
+_OPENSSL_openssl_VERSION:INTERNAL=
+__pkg_config_arguments__OPENSSL:INTERNAL=QUIET;openssl
+__pkg_config_checked__OPENSSL:INTERNAL=1
+prefix_result:INTERNAL=/usr/lib/x86_64-linux-gnu
+
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeCCompiler.cmake b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeCCompiler.cmake
new file mode 100644
index 00000000..c5ece7b8
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeCCompiler.cmake
@@ -0,0 +1,76 @@
+set(CMAKE_C_COMPILER "/usr/bin/cc")
+set(CMAKE_C_COMPILER_ARG1 "")
+set(CMAKE_C_COMPILER_ID "GNU")
+set(CMAKE_C_COMPILER_VERSION "9.4.0")
+set(CMAKE_C_COMPILER_VERSION_INTERNAL "")
+set(CMAKE_C_COMPILER_WRAPPER "")
+set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "11")
+set(CMAKE_C_COMPILE_FEATURES "c_std_90;c_function_prototypes;c_std_99;c_restrict;c_variadic_macros;c_std_11;c_static_assert")
+set(CMAKE_C90_COMPILE_FEATURES "c_std_90;c_function_prototypes")
+set(CMAKE_C99_COMPILE_FEATURES "c_std_99;c_restrict;c_variadic_macros")
+set(CMAKE_C11_COMPILE_FEATURES "c_std_11;c_static_assert")
+
+set(CMAKE_C_PLATFORM_ID "Linux")
+set(CMAKE_C_SIMULATE_ID "")
+set(CMAKE_C_COMPILER_FRONTEND_VARIANT "")
+set(CMAKE_C_SIMULATE_VERSION "")
+
+
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_C_COMPILER_AR "/usr/bin/gcc-ar-9")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_C_COMPILER_RANLIB "/usr/bin/gcc-ranlib-9")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_MT "")
+set(CMAKE_COMPILER_IS_GNUCC 1)
+set(CMAKE_C_COMPILER_LOADED 1)
+set(CMAKE_C_COMPILER_WORKS TRUE)
+set(CMAKE_C_ABI_COMPILED TRUE)
+set(CMAKE_COMPILER_IS_MINGW )
+set(CMAKE_COMPILER_IS_CYGWIN )
+if(CMAKE_COMPILER_IS_CYGWIN)
+  set(CYGWIN 1)
+  set(UNIX 1)
+endif()
+
+set(CMAKE_C_COMPILER_ENV_VAR "CC")
+
+if(CMAKE_COMPILER_IS_MINGW)
+  set(MINGW 1)
+endif()
+set(CMAKE_C_COMPILER_ID_RUN 1)
+set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m)
+set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_C_LINKER_PREFERENCE 10)
+
+# Save compiler ABI information.
+set(CMAKE_C_SIZEOF_DATA_PTR "8")
+set(CMAKE_C_COMPILER_ABI "ELF")
+set(CMAKE_C_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+
+if(CMAKE_C_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_C_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
+endif()
+
+if(CMAKE_C_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+endif()
+
+set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "")
+if(CMAKE_C_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+
+
+
+
+set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/9/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include")
+set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "gcc;gcc_s;c;gcc;gcc_s")
+set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/9;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib")
+set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake
new file mode 100644
index 00000000..278ef39e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeCXXCompiler.cmake
@@ -0,0 +1,88 @@
+set(CMAKE_CXX_COMPILER "/usr/bin/c++")
+set(CMAKE_CXX_COMPILER_ARG1 "")
+set(CMAKE_CXX_COMPILER_ID "GNU")
+set(CMAKE_CXX_COMPILER_VERSION "9.4.0")
+set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "")
+set(CMAKE_CXX_COMPILER_WRAPPER "")
+set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14")
+set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20")
+set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters")
+set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates")
+set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates")
+set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17")
+set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20")
+
+set(CMAKE_CXX_PLATFORM_ID "Linux")
+set(CMAKE_CXX_SIMULATE_ID "")
+set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "")
+set(CMAKE_CXX_SIMULATE_VERSION "")
+
+
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar-9")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib-9")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_MT "")
+set(CMAKE_COMPILER_IS_GNUCXX 1)
+set(CMAKE_CXX_COMPILER_LOADED 1)
+set(CMAKE_CXX_COMPILER_WORKS TRUE)
+set(CMAKE_CXX_ABI_COMPILED TRUE)
+set(CMAKE_COMPILER_IS_MINGW )
+set(CMAKE_COMPILER_IS_CYGWIN )
+if(CMAKE_COMPILER_IS_CYGWIN)
+  set(CYGWIN 1)
+  set(UNIX 1)
+endif()
+
+set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
+
+if(CMAKE_COMPILER_IS_MINGW)
+  set(MINGW 1)
+endif()
+set(CMAKE_CXX_COMPILER_ID_RUN 1)
+set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;CPP)
+set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
+
+foreach (lang C OBJC OBJCXX)
+  if (CMAKE_${lang}_COMPILER_ID_RUN)
+    foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS)
+      list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension})
+    endforeach()
+  endif()
+endforeach()
+
+set(CMAKE_CXX_LINKER_PREFERENCE 30)
+set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1)
+
+# Save compiler ABI information.
+set(CMAKE_CXX_SIZEOF_DATA_PTR "8")
+set(CMAKE_CXX_COMPILER_ABI "ELF")
+set(CMAKE_CXX_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+
+if(CMAKE_CXX_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_CXX_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
+endif()
+
+if(CMAKE_CXX_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+endif()
+
+set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "")
+if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+
+
+
+
+set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/usr/include/c++/9;/usr/include/x86_64-linux-gnu/c++/9;/usr/include/c++/9/backward;/usr/lib/gcc/x86_64-linux-gnu/9/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include")
+set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc")
+set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/9;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib")
+set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_C.bin b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_C.bin
new file mode 100644
index 00000000..b7a0b099
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_C.bin differ
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin
new file mode 100644
index 00000000..a9f2f4fc
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeDetermineCompilerABI_CXX.bin differ
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeSystem.cmake b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeSystem.cmake
new file mode 100644
index 00000000..b6b39409
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CMakeSystem.cmake
@@ -0,0 +1,15 @@
+set(CMAKE_HOST_SYSTEM "Linux-5.15.0-113-generic")
+set(CMAKE_HOST_SYSTEM_NAME "Linux")
+set(CMAKE_HOST_SYSTEM_VERSION "5.15.0-113-generic")
+set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+
+
+
+set(CMAKE_SYSTEM "Linux-5.15.0-113-generic")
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_VERSION "5.15.0-113-generic")
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+
+set(CMAKE_CROSSCOMPILING "FALSE")
+
+set(CMAKE_SYSTEM_LOADED 1)
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdC/CMakeCCompilerId.c b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdC/CMakeCCompilerId.c
new file mode 100644
index 00000000..d884b509
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdC/CMakeCCompilerId.c
@@ -0,0 +1,671 @@
+#ifdef __cplusplus
+# error "A C++ compiler has been selected for C."
+#endif
+
+#if defined(__18CXX)
+# define ID_VOID_MAIN
+#endif
+#if defined(__CLASSIC_C__)
+/* cv-qualifiers did not exist in K&R C */
+# define const
+# define volatile
+#endif
+
+
+/* Version number components: V=Version, R=Revision, P=Patch
+   Version date components:   YYYY=Year, MM=Month,   DD=Day  */
+
+#if defined(__INTEL_COMPILER) || defined(__ICC)
+# define COMPILER_ID "Intel"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_ID "GNU"
+# endif
+  /* __INTEL_COMPILER = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
+# if defined(__INTEL_COMPILER_UPDATE)
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
+# else
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)
+# endif
+# if defined(__INTEL_COMPILER_BUILD_DATE)
+  /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
+#  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
+# endif
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+# elif defined(__GNUG__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(__PATHCC__)
+# define COMPILER_ID "PathScale"
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+
+#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
+# define COMPILER_ID "Embarcadero"
+# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
+# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
+# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__     & 0xFFFF)
+
+#elif defined(__BORLANDC__)
+# define COMPILER_ID "Borland"
+  /* __BORLANDC__ = 0xVRR */
+# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
+# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
+
+#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
+# define COMPILER_ID "Watcom"
+   /* __WATCOMC__ = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__WATCOMC__)
+# define COMPILER_ID "OpenWatcom"
+   /* __WATCOMC__ = VVRP + 1100 */
+# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__SUNPRO_C)
+# define COMPILER_ID "SunPro"
+# if __SUNPRO_C >= 0x5100
+   /* __SUNPRO_C = 0xVRRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_C    & 0xF)
+# else
+   /* __SUNPRO_CC = 0xVRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_C    & 0xF)
+# endif
+
+#elif defined(__HP_cc)
+# define COMPILER_ID "HP"
+  /* __HP_cc = VVRRPP */
+# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000)
+# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__HP_cc     % 100)
+
+#elif defined(__DECC)
+# define COMPILER_ID "Compaq"
+  /* __DECC_VER = VVRRTPPPP */
+# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000)
+# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000  % 100)
+# define COMPILER_VERSION_PATCH DEC(__DECC_VER         % 10000)
+
+#elif defined(__IBMC__) && defined(__COMPILER_VER__)
+# define COMPILER_ID "zOS"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__ibmxl__) && defined(__clang__)
+# define COMPILER_ID "XLClang"
+# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
+# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
+# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
+
+
+#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800
+# define COMPILER_ID "XL"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800
+# define COMPILER_ID "VisualAge"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__PGI)
+# define COMPILER_ID "PGI"
+# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
+# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
+# if defined(__PGIC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
+# endif
+
+#elif defined(_CRAYC)
+# define COMPILER_ID "Cray"
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
+
+#elif defined(__TI_COMPILER_VERSION__)
+# define COMPILER_ID "TI"
+  /* __TI_COMPILER_VERSION__ = VVVRRRPPP */
+# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
+# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000   % 1000)
+# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__        % 1000)
+
+#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)
+# define COMPILER_ID "Fujitsu"
+
+#elif defined(__ghs__)
+# define COMPILER_ID "GHS"
+/* __GHS_VERSION_NUMBER = VVVVRP */
+# ifdef __GHS_VERSION_NUMBER
+# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
+# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER      % 10)
+# endif
+
+#elif defined(__TINYC__)
+# define COMPILER_ID "TinyCC"
+
+#elif defined(__BCC__)
+# define COMPILER_ID "Bruce"
+
+#elif defined(__SCO_VERSION__)
+# define COMPILER_ID "SCO"
+
+#elif defined(__ARMCC_VERSION) && !defined(__clang__)
+# define COMPILER_ID "ARMCC"
+#if __ARMCC_VERSION >= 1000000
+  /* __ARMCC_VERSION = VRRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION     % 10000)
+#else
+  /* __ARMCC_VERSION = VRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION    % 10000)
+#endif
+
+
+#elif defined(__clang__) && defined(__apple_build_version__)
+# define COMPILER_ID "AppleClang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
+
+#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
+# define COMPILER_ID "ARMClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION     % 10000)
+# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
+
+#elif defined(__clang__)
+# define COMPILER_ID "Clang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+
+#elif defined(__GNUC__)
+# define COMPILER_ID "GNU"
+# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
+# if defined(__GNUC_MINOR__)
+#  define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(_MSC_VER)
+# define COMPILER_ID "MSVC"
+  /* _MSC_VER = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
+# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
+# if defined(_MSC_FULL_VER)
+#  if _MSC_VER >= 1400
+    /* _MSC_FULL_VER = VVRRPPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
+#  else
+    /* _MSC_FULL_VER = VVRRPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
+#  endif
+# endif
+# if defined(_MSC_BUILD)
+#  define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
+# endif
+
+#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
+# define COMPILER_ID "ADSP"
+#if defined(__VISUALDSPVERSION__)
+  /* __VISUALDSPVERSION__ = 0xVVRRPP00 */
+# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
+# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
+# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8  & 0xFF)
+#endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# define COMPILER_ID "IAR"
+# if defined(__VER__) && defined(__ICCARM__)
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
+#  define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
+#  define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__))
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
+#  define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
+#  define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# endif
+
+#elif defined(__SDCC_VERSION_MAJOR) || defined(SDCC)
+# define COMPILER_ID "SDCC"
+# if defined(__SDCC_VERSION_MAJOR)
+#  define COMPILER_VERSION_MAJOR DEC(__SDCC_VERSION_MAJOR)
+#  define COMPILER_VERSION_MINOR DEC(__SDCC_VERSION_MINOR)
+#  define COMPILER_VERSION_PATCH DEC(__SDCC_VERSION_PATCH)
+# else
+  /* SDCC = VRP */
+#  define COMPILER_VERSION_MAJOR DEC(SDCC/100)
+#  define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10)
+#  define COMPILER_VERSION_PATCH DEC(SDCC    % 10)
+# endif
+
+
+/* These compilers are either not known or too old to define an
+  identification macro.  Try to identify the platform and guess that
+  it is the native compiler.  */
+#elif defined(__hpux) || defined(__hpua)
+# define COMPILER_ID "HP"
+
+#else /* unknown compiler */
+# define COMPILER_ID ""
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
+#ifdef SIMULATE_ID
+char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
+#endif
+
+#ifdef __QNXNTO__
+char const* qnxnto = "INFO" ":" "qnxnto[]";
+#endif
+
+#if defined(__CRAYXE) || defined(__CRAYXC)
+char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
+#endif
+
+#define STRINGIFY_HELPER(X) #X
+#define STRINGIFY(X) STRINGIFY_HELPER(X)
+
+/* Identify known platforms by name.  */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+# define PLATFORM_ID "Linux"
+
+#elif defined(__CYGWIN__)
+# define PLATFORM_ID "Cygwin"
+
+#elif defined(__MINGW32__)
+# define PLATFORM_ID "MinGW"
+
+#elif defined(__APPLE__)
+# define PLATFORM_ID "Darwin"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+# define PLATFORM_ID "Windows"
+
+#elif defined(__FreeBSD__) || defined(__FreeBSD)
+# define PLATFORM_ID "FreeBSD"
+
+#elif defined(__NetBSD__) || defined(__NetBSD)
+# define PLATFORM_ID "NetBSD"
+
+#elif defined(__OpenBSD__) || defined(__OPENBSD)
+# define PLATFORM_ID "OpenBSD"
+
+#elif defined(__sun) || defined(sun)
+# define PLATFORM_ID "SunOS"
+
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+# define PLATFORM_ID "AIX"
+
+#elif defined(__hpux) || defined(__hpux__)
+# define PLATFORM_ID "HP-UX"
+
+#elif defined(__HAIKU__)
+# define PLATFORM_ID "Haiku"
+
+#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
+# define PLATFORM_ID "BeOS"
+
+#elif defined(__QNX__) || defined(__QNXNTO__)
+# define PLATFORM_ID "QNX"
+
+#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
+# define PLATFORM_ID "Tru64"
+
+#elif defined(__riscos) || defined(__riscos__)
+# define PLATFORM_ID "RISCos"
+
+#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
+# define PLATFORM_ID "SINIX"
+
+#elif defined(__UNIX_SV__)
+# define PLATFORM_ID "UNIX_SV"
+
+#elif defined(__bsdos__)
+# define PLATFORM_ID "BSDOS"
+
+#elif defined(_MPRAS) || defined(MPRAS)
+# define PLATFORM_ID "MP-RAS"
+
+#elif defined(__osf) || defined(__osf__)
+# define PLATFORM_ID "OSF1"
+
+#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
+# define PLATFORM_ID "SCO_SV"
+
+#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
+# define PLATFORM_ID "ULTRIX"
+
+#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
+# define PLATFORM_ID "Xenix"
+
+#elif defined(__WATCOMC__)
+# if defined(__LINUX__)
+#  define PLATFORM_ID "Linux"
+
+# elif defined(__DOS__)
+#  define PLATFORM_ID "DOS"
+
+# elif defined(__OS2__)
+#  define PLATFORM_ID "OS2"
+
+# elif defined(__WINDOWS__)
+#  define PLATFORM_ID "Windows3x"
+
+# else /* unknown platform */
+#  define PLATFORM_ID
+# endif
+
+#elif defined(__INTEGRITY)
+# if defined(INT_178B)
+#  define PLATFORM_ID "Integrity178"
+
+# else /* regular Integrity */
+#  define PLATFORM_ID "Integrity"
+# endif
+
+#else /* unknown platform */
+# define PLATFORM_ID
+
+#endif
+
+/* For windows compilers MSVC and Intel we can determine
+   the architecture of the compiler being used.  This is because
+   the compilers do not have flags that can change the architecture,
+   but rather depend on which compiler is being used
+*/
+#if defined(_WIN32) && defined(_MSC_VER)
+# if defined(_M_IA64)
+#  define ARCHITECTURE_ID "IA64"
+
+# elif defined(_M_X64) || defined(_M_AMD64)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# elif defined(_M_ARM64)
+#  define ARCHITECTURE_ID "ARM64"
+
+# elif defined(_M_ARM)
+#  if _M_ARM == 4
+#   define ARCHITECTURE_ID "ARMV4I"
+#  elif _M_ARM == 5
+#   define ARCHITECTURE_ID "ARMV5I"
+#  else
+#   define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
+#  endif
+
+# elif defined(_M_MIPS)
+#  define ARCHITECTURE_ID "MIPS"
+
+# elif defined(_M_SH)
+#  define ARCHITECTURE_ID "SHx"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__WATCOMC__)
+# if defined(_M_I86)
+#  define ARCHITECTURE_ID "I86"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# if defined(__ICCARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__ICCRX__)
+#  define ARCHITECTURE_ID "RX"
+
+# elif defined(__ICCRH850__)
+#  define ARCHITECTURE_ID "RH850"
+
+# elif defined(__ICCRL78__)
+#  define ARCHITECTURE_ID "RL78"
+
+# elif defined(__ICCRISCV__)
+#  define ARCHITECTURE_ID "RISCV"
+
+# elif defined(__ICCAVR__)
+#  define ARCHITECTURE_ID "AVR"
+
+# elif defined(__ICC430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# elif defined(__ICCV850__)
+#  define ARCHITECTURE_ID "V850"
+
+# elif defined(__ICC8051__)
+#  define ARCHITECTURE_ID "8051"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__ghs__)
+# if defined(__PPC64__)
+#  define ARCHITECTURE_ID "PPC64"
+
+# elif defined(__ppc__)
+#  define ARCHITECTURE_ID "PPC"
+
+# elif defined(__ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__x86_64__)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(__i386__)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+#else
+#  define ARCHITECTURE_ID
+#endif
+
+/* Convert integer to decimal digit literals.  */
+#define DEC(n)                   \
+  ('0' + (((n) / 10000000)%10)), \
+  ('0' + (((n) / 1000000)%10)),  \
+  ('0' + (((n) / 100000)%10)),   \
+  ('0' + (((n) / 10000)%10)),    \
+  ('0' + (((n) / 1000)%10)),     \
+  ('0' + (((n) / 100)%10)),      \
+  ('0' + (((n) / 10)%10)),       \
+  ('0' +  ((n) % 10))
+
+/* Convert integer to hex digit literals.  */
+#define HEX(n)             \
+  ('0' + ((n)>>28 & 0xF)), \
+  ('0' + ((n)>>24 & 0xF)), \
+  ('0' + ((n)>>20 & 0xF)), \
+  ('0' + ((n)>>16 & 0xF)), \
+  ('0' + ((n)>>12 & 0xF)), \
+  ('0' + ((n)>>8  & 0xF)), \
+  ('0' + ((n)>>4  & 0xF)), \
+  ('0' + ((n)     & 0xF))
+
+/* Construct a string literal encoding the version number components. */
+#ifdef COMPILER_VERSION_MAJOR
+char const info_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
+  COMPILER_VERSION_MAJOR,
+# ifdef COMPILER_VERSION_MINOR
+  '.', COMPILER_VERSION_MINOR,
+#  ifdef COMPILER_VERSION_PATCH
+   '.', COMPILER_VERSION_PATCH,
+#   ifdef COMPILER_VERSION_TWEAK
+    '.', COMPILER_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct a string literal encoding the internal version number. */
+#ifdef COMPILER_VERSION_INTERNAL
+char const info_version_internal[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
+  'i','n','t','e','r','n','a','l','[',
+  COMPILER_VERSION_INTERNAL,']','\0'};
+#endif
+
+/* Construct a string literal encoding the version number components. */
+#ifdef SIMULATE_VERSION_MAJOR
+char const info_simulate_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
+  SIMULATE_VERSION_MAJOR,
+# ifdef SIMULATE_VERSION_MINOR
+  '.', SIMULATE_VERSION_MINOR,
+#  ifdef SIMULATE_VERSION_PATCH
+   '.', SIMULATE_VERSION_PATCH,
+#   ifdef SIMULATE_VERSION_TWEAK
+    '.', SIMULATE_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
+char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
+
+
+
+
+#if !defined(__STDC__)
+# if (defined(_MSC_VER) && !defined(__clang__)) \
+  || (defined(__ibmxl__) || defined(__IBMC__))
+#  define C_DIALECT "90"
+# else
+#  define C_DIALECT
+# endif
+#elif __STDC_VERSION__ >= 201000L
+# define C_DIALECT "11"
+#elif __STDC_VERSION__ >= 199901L
+# define C_DIALECT "99"
+#else
+# define C_DIALECT "90"
+#endif
+const char* info_language_dialect_default =
+  "INFO" ":" "dialect_default[" C_DIALECT "]";
+
+/*--------------------------------------------------------------------------*/
+
+#ifdef ID_VOID_MAIN
+void main() {}
+#else
+# if defined(__CLASSIC_C__)
+int main(argc, argv) int argc; char *argv[];
+# else
+int main(int argc, char* argv[])
+# endif
+{
+  int require = 0;
+  require += info_compiler[argc];
+  require += info_platform[argc];
+  require += info_arch[argc];
+#ifdef COMPILER_VERSION_MAJOR
+  require += info_version[argc];
+#endif
+#ifdef COMPILER_VERSION_INTERNAL
+  require += info_version_internal[argc];
+#endif
+#ifdef SIMULATE_ID
+  require += info_simulate[argc];
+#endif
+#ifdef SIMULATE_VERSION_MAJOR
+  require += info_simulate_version[argc];
+#endif
+#if defined(__CRAYXE) || defined(__CRAYXC)
+  require += info_cray[argc];
+#endif
+  require += info_language_dialect_default[argc];
+  (void)argv;
+  return require;
+}
+#endif
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdC/a.out b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdC/a.out
new file mode 100644
index 00000000..b5c91a37
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdC/a.out differ
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp
new file mode 100644
index 00000000..69cfdba6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdCXX/CMakeCXXCompilerId.cpp
@@ -0,0 +1,660 @@
+/* This source file must have a .cpp extension so that all C++ compilers
+   recognize the extension without flags.  Borland does not know .cxx for
+   example.  */
+#ifndef __cplusplus
+# error "A C compiler has been selected for C++."
+#endif
+
+
+/* Version number components: V=Version, R=Revision, P=Patch
+   Version date components:   YYYY=Year, MM=Month,   DD=Day  */
+
+#if defined(__COMO__)
+# define COMPILER_ID "Comeau"
+  /* __COMO_VERSION__ = VRR */
+# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100)
+# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100)
+
+#elif defined(__INTEL_COMPILER) || defined(__ICC)
+# define COMPILER_ID "Intel"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_ID "GNU"
+# endif
+  /* __INTEL_COMPILER = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
+# if defined(__INTEL_COMPILER_UPDATE)
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
+# else
+#  define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)
+# endif
+# if defined(__INTEL_COMPILER_BUILD_DATE)
+  /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
+#  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
+# endif
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+# elif defined(__GNUG__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(__PATHCC__)
+# define COMPILER_ID "PathScale"
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+
+#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
+# define COMPILER_ID "Embarcadero"
+# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
+# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
+# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__     & 0xFFFF)
+
+#elif defined(__BORLANDC__)
+# define COMPILER_ID "Borland"
+  /* __BORLANDC__ = 0xVRR */
+# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
+# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
+
+#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
+# define COMPILER_ID "Watcom"
+   /* __WATCOMC__ = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__WATCOMC__)
+# define COMPILER_ID "OpenWatcom"
+   /* __WATCOMC__ = VVRP + 1100 */
+# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__SUNPRO_CC)
+# define COMPILER_ID "SunPro"
+# if __SUNPRO_CC >= 0x5100
+   /* __SUNPRO_CC = 0xVRRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC    & 0xF)
+# else
+   /* __SUNPRO_CC = 0xVRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC    & 0xF)
+# endif
+
+#elif defined(__HP_aCC)
+# define COMPILER_ID "HP"
+  /* __HP_aCC = VVRRPP */
+# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000)
+# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__HP_aCC     % 100)
+
+#elif defined(__DECCXX)
+# define COMPILER_ID "Compaq"
+  /* __DECCXX_VER = VVRRTPPPP */
+# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000)
+# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000  % 100)
+# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER         % 10000)
+
+#elif defined(__IBMCPP__) && defined(__COMPILER_VER__)
+# define COMPILER_ID "zOS"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__ibmxl__) && defined(__clang__)
+# define COMPILER_ID "XLClang"
+# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
+# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
+# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
+
+
+#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800
+# define COMPILER_ID "XL"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800
+# define COMPILER_ID "VisualAge"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__PGI)
+# define COMPILER_ID "PGI"
+# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
+# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
+# if defined(__PGIC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
+# endif
+
+#elif defined(_CRAYC)
+# define COMPILER_ID "Cray"
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
+
+#elif defined(__TI_COMPILER_VERSION__)
+# define COMPILER_ID "TI"
+  /* __TI_COMPILER_VERSION__ = VVVRRRPPP */
+# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
+# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000   % 1000)
+# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__        % 1000)
+
+#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)
+# define COMPILER_ID "Fujitsu"
+
+#elif defined(__ghs__)
+# define COMPILER_ID "GHS"
+/* __GHS_VERSION_NUMBER = VVVVRP */
+# ifdef __GHS_VERSION_NUMBER
+# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
+# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER      % 10)
+# endif
+
+#elif defined(__SCO_VERSION__)
+# define COMPILER_ID "SCO"
+
+#elif defined(__ARMCC_VERSION) && !defined(__clang__)
+# define COMPILER_ID "ARMCC"
+#if __ARMCC_VERSION >= 1000000
+  /* __ARMCC_VERSION = VRRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION     % 10000)
+#else
+  /* __ARMCC_VERSION = VRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION    % 10000)
+#endif
+
+
+#elif defined(__clang__) && defined(__apple_build_version__)
+# define COMPILER_ID "AppleClang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
+
+#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
+# define COMPILER_ID "ARMClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION     % 10000)
+# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
+
+#elif defined(__clang__)
+# define COMPILER_ID "Clang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+
+#elif defined(__GNUC__) || defined(__GNUG__)
+# define COMPILER_ID "GNU"
+# if defined(__GNUC__)
+#  define COMPILER_VERSION_MAJOR DEC(__GNUC__)
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(_MSC_VER)
+# define COMPILER_ID "MSVC"
+  /* _MSC_VER = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
+# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
+# if defined(_MSC_FULL_VER)
+#  if _MSC_VER >= 1400
+    /* _MSC_FULL_VER = VVRRPPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
+#  else
+    /* _MSC_FULL_VER = VVRRPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
+#  endif
+# endif
+# if defined(_MSC_BUILD)
+#  define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
+# endif
+
+#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
+# define COMPILER_ID "ADSP"
+#if defined(__VISUALDSPVERSION__)
+  /* __VISUALDSPVERSION__ = 0xVVRRPP00 */
+# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
+# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
+# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8  & 0xFF)
+#endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# define COMPILER_ID "IAR"
+# if defined(__VER__) && defined(__ICCARM__)
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
+#  define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
+#  define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__))
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
+#  define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
+#  define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# endif
+
+
+/* These compilers are either not known or too old to define an
+  identification macro.  Try to identify the platform and guess that
+  it is the native compiler.  */
+#elif defined(__hpux) || defined(__hpua)
+# define COMPILER_ID "HP"
+
+#else /* unknown compiler */
+# define COMPILER_ID ""
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
+#ifdef SIMULATE_ID
+char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
+#endif
+
+#ifdef __QNXNTO__
+char const* qnxnto = "INFO" ":" "qnxnto[]";
+#endif
+
+#if defined(__CRAYXE) || defined(__CRAYXC)
+char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
+#endif
+
+#define STRINGIFY_HELPER(X) #X
+#define STRINGIFY(X) STRINGIFY_HELPER(X)
+
+/* Identify known platforms by name.  */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+# define PLATFORM_ID "Linux"
+
+#elif defined(__CYGWIN__)
+# define PLATFORM_ID "Cygwin"
+
+#elif defined(__MINGW32__)
+# define PLATFORM_ID "MinGW"
+
+#elif defined(__APPLE__)
+# define PLATFORM_ID "Darwin"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+# define PLATFORM_ID "Windows"
+
+#elif defined(__FreeBSD__) || defined(__FreeBSD)
+# define PLATFORM_ID "FreeBSD"
+
+#elif defined(__NetBSD__) || defined(__NetBSD)
+# define PLATFORM_ID "NetBSD"
+
+#elif defined(__OpenBSD__) || defined(__OPENBSD)
+# define PLATFORM_ID "OpenBSD"
+
+#elif defined(__sun) || defined(sun)
+# define PLATFORM_ID "SunOS"
+
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+# define PLATFORM_ID "AIX"
+
+#elif defined(__hpux) || defined(__hpux__)
+# define PLATFORM_ID "HP-UX"
+
+#elif defined(__HAIKU__)
+# define PLATFORM_ID "Haiku"
+
+#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
+# define PLATFORM_ID "BeOS"
+
+#elif defined(__QNX__) || defined(__QNXNTO__)
+# define PLATFORM_ID "QNX"
+
+#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
+# define PLATFORM_ID "Tru64"
+
+#elif defined(__riscos) || defined(__riscos__)
+# define PLATFORM_ID "RISCos"
+
+#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
+# define PLATFORM_ID "SINIX"
+
+#elif defined(__UNIX_SV__)
+# define PLATFORM_ID "UNIX_SV"
+
+#elif defined(__bsdos__)
+# define PLATFORM_ID "BSDOS"
+
+#elif defined(_MPRAS) || defined(MPRAS)
+# define PLATFORM_ID "MP-RAS"
+
+#elif defined(__osf) || defined(__osf__)
+# define PLATFORM_ID "OSF1"
+
+#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
+# define PLATFORM_ID "SCO_SV"
+
+#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
+# define PLATFORM_ID "ULTRIX"
+
+#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
+# define PLATFORM_ID "Xenix"
+
+#elif defined(__WATCOMC__)
+# if defined(__LINUX__)
+#  define PLATFORM_ID "Linux"
+
+# elif defined(__DOS__)
+#  define PLATFORM_ID "DOS"
+
+# elif defined(__OS2__)
+#  define PLATFORM_ID "OS2"
+
+# elif defined(__WINDOWS__)
+#  define PLATFORM_ID "Windows3x"
+
+# else /* unknown platform */
+#  define PLATFORM_ID
+# endif
+
+#elif defined(__INTEGRITY)
+# if defined(INT_178B)
+#  define PLATFORM_ID "Integrity178"
+
+# else /* regular Integrity */
+#  define PLATFORM_ID "Integrity"
+# endif
+
+#else /* unknown platform */
+# define PLATFORM_ID
+
+#endif
+
+/* For windows compilers MSVC and Intel we can determine
+   the architecture of the compiler being used.  This is because
+   the compilers do not have flags that can change the architecture,
+   but rather depend on which compiler is being used
+*/
+#if defined(_WIN32) && defined(_MSC_VER)
+# if defined(_M_IA64)
+#  define ARCHITECTURE_ID "IA64"
+
+# elif defined(_M_X64) || defined(_M_AMD64)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# elif defined(_M_ARM64)
+#  define ARCHITECTURE_ID "ARM64"
+
+# elif defined(_M_ARM)
+#  if _M_ARM == 4
+#   define ARCHITECTURE_ID "ARMV4I"
+#  elif _M_ARM == 5
+#   define ARCHITECTURE_ID "ARMV5I"
+#  else
+#   define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
+#  endif
+
+# elif defined(_M_MIPS)
+#  define ARCHITECTURE_ID "MIPS"
+
+# elif defined(_M_SH)
+#  define ARCHITECTURE_ID "SHx"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__WATCOMC__)
+# if defined(_M_I86)
+#  define ARCHITECTURE_ID "I86"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# if defined(__ICCARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__ICCRX__)
+#  define ARCHITECTURE_ID "RX"
+
+# elif defined(__ICCRH850__)
+#  define ARCHITECTURE_ID "RH850"
+
+# elif defined(__ICCRL78__)
+#  define ARCHITECTURE_ID "RL78"
+
+# elif defined(__ICCRISCV__)
+#  define ARCHITECTURE_ID "RISCV"
+
+# elif defined(__ICCAVR__)
+#  define ARCHITECTURE_ID "AVR"
+
+# elif defined(__ICC430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# elif defined(__ICCV850__)
+#  define ARCHITECTURE_ID "V850"
+
+# elif defined(__ICC8051__)
+#  define ARCHITECTURE_ID "8051"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__ghs__)
+# if defined(__PPC64__)
+#  define ARCHITECTURE_ID "PPC64"
+
+# elif defined(__ppc__)
+#  define ARCHITECTURE_ID "PPC"
+
+# elif defined(__ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__x86_64__)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(__i386__)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+#else
+#  define ARCHITECTURE_ID
+#endif
+
+/* Convert integer to decimal digit literals.  */
+#define DEC(n)                   \
+  ('0' + (((n) / 10000000)%10)), \
+  ('0' + (((n) / 1000000)%10)),  \
+  ('0' + (((n) / 100000)%10)),   \
+  ('0' + (((n) / 10000)%10)),    \
+  ('0' + (((n) / 1000)%10)),     \
+  ('0' + (((n) / 100)%10)),      \
+  ('0' + (((n) / 10)%10)),       \
+  ('0' +  ((n) % 10))
+
+/* Convert integer to hex digit literals.  */
+#define HEX(n)             \
+  ('0' + ((n)>>28 & 0xF)), \
+  ('0' + ((n)>>24 & 0xF)), \
+  ('0' + ((n)>>20 & 0xF)), \
+  ('0' + ((n)>>16 & 0xF)), \
+  ('0' + ((n)>>12 & 0xF)), \
+  ('0' + ((n)>>8  & 0xF)), \
+  ('0' + ((n)>>4  & 0xF)), \
+  ('0' + ((n)     & 0xF))
+
+/* Construct a string literal encoding the version number components. */
+#ifdef COMPILER_VERSION_MAJOR
+char const info_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
+  COMPILER_VERSION_MAJOR,
+# ifdef COMPILER_VERSION_MINOR
+  '.', COMPILER_VERSION_MINOR,
+#  ifdef COMPILER_VERSION_PATCH
+   '.', COMPILER_VERSION_PATCH,
+#   ifdef COMPILER_VERSION_TWEAK
+    '.', COMPILER_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct a string literal encoding the internal version number. */
+#ifdef COMPILER_VERSION_INTERNAL
+char const info_version_internal[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
+  'i','n','t','e','r','n','a','l','[',
+  COMPILER_VERSION_INTERNAL,']','\0'};
+#endif
+
+/* Construct a string literal encoding the version number components. */
+#ifdef SIMULATE_VERSION_MAJOR
+char const info_simulate_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
+  SIMULATE_VERSION_MAJOR,
+# ifdef SIMULATE_VERSION_MINOR
+  '.', SIMULATE_VERSION_MINOR,
+#  ifdef SIMULATE_VERSION_PATCH
+   '.', SIMULATE_VERSION_PATCH,
+#   ifdef SIMULATE_VERSION_TWEAK
+    '.', SIMULATE_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
+char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
+
+
+
+
+#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) && _MSVC_LANG < 201403L
+#  if defined(__INTEL_CXX11_MODE__)
+#    if defined(__cpp_aggregate_nsdmi)
+#      define CXX_STD 201402L
+#    else
+#      define CXX_STD 201103L
+#    endif
+#  else
+#    define CXX_STD 199711L
+#  endif
+#elif defined(_MSC_VER) && defined(_MSVC_LANG)
+#  define CXX_STD _MSVC_LANG
+#else
+#  define CXX_STD __cplusplus
+#endif
+
+const char* info_language_dialect_default = "INFO" ":" "dialect_default["
+#if CXX_STD > 201703L
+  "20"
+#elif CXX_STD >= 201703L
+  "17"
+#elif CXX_STD >= 201402L
+  "14"
+#elif CXX_STD >= 201103L
+  "11"
+#else
+  "98"
+#endif
+"]";
+
+/*--------------------------------------------------------------------------*/
+
+int main(int argc, char* argv[])
+{
+  int require = 0;
+  require += info_compiler[argc];
+  require += info_platform[argc];
+#ifdef COMPILER_VERSION_MAJOR
+  require += info_version[argc];
+#endif
+#ifdef COMPILER_VERSION_INTERNAL
+  require += info_version_internal[argc];
+#endif
+#ifdef SIMULATE_ID
+  require += info_simulate[argc];
+#endif
+#ifdef SIMULATE_VERSION_MAJOR
+  require += info_simulate_version[argc];
+#endif
+#if defined(__CRAYXE) || defined(__CRAYXC)
+  require += info_cray[argc];
+#endif
+  require += info_language_dialect_default[argc];
+  (void)argv;
+  return require;
+}
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out
new file mode 100644
index 00000000..2881803f
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out differ
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/CMakeDirectoryInformation.cmake b/C++/yolo_bytetrack_old/build/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 00000000..4f5aa321
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/huey/Desktop/C/yolo_bytetrack")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/huey/Desktop/C/yolo_bytetrack/build")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/CMakeOutput.log b/C++/yolo_bytetrack_old/build/CMakeFiles/CMakeOutput.log
new file mode 100644
index 00000000..766e8df7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/CMakeOutput.log
@@ -0,0 +1,461 @@
+The system is: Linux - 5.15.0-113-generic - x86_64
+Compiling the C compiler identification source file "CMakeCCompilerId.c" succeeded.
+Compiler: /usr/bin/cc 
+Build flags: 
+Id flags:  
+
+The output was:
+0
+
+
+Compilation of the C compiler identification source "CMakeCCompilerId.c" produced "a.out"
+
+The C compiler identification is GNU, found in "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdC/a.out"
+
+Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded.
+Compiler: /usr/bin/c++ 
+Build flags: 
+Id flags:  
+
+The output was:
+0
+
+
+Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out"
+
+The CXX compiler identification is GNU, found in "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/3.16.3/CompilerIdCXX/a.out"
+
+Determining if the C compiler works passed with the following output:
+Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp
+
+Run Build Command(s):/usr/bin/make cmTC_3ac10/fast && /usr/bin/make -f CMakeFiles/cmTC_3ac10.dir/build.make CMakeFiles/cmTC_3ac10.dir/build
+make[1]: 进入目录“/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp”
+Building C object CMakeFiles/cmTC_3ac10.dir/testCCompiler.c.o
+/usr/bin/cc    -o CMakeFiles/cmTC_3ac10.dir/testCCompiler.c.o   -c /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp/testCCompiler.c
+Linking C executable cmTC_3ac10
+/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_3ac10.dir/link.txt --verbose=1
+/usr/bin/cc      CMakeFiles/cmTC_3ac10.dir/testCCompiler.c.o  -o cmTC_3ac10 
+make[1]: 离开目录“/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp”
+
+
+
+Detecting C compiler ABI info compiled with the following output:
+Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp
+
+Run Build Command(s):/usr/bin/make cmTC_202d0/fast && /usr/bin/make -f CMakeFiles/cmTC_202d0.dir/build.make CMakeFiles/cmTC_202d0.dir/build
+make[1]: Entering directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp'
+Building C object CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o
+/usr/bin/cc   -v -o CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o   -c /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c
+Using built-in specs.
+COLLECT_GCC=/usr/bin/cc
+OFFLOAD_TARGET_NAMES=nvptx-none:hsa
+OFFLOAD_TARGET_DEFAULT=1
+Target: x86_64-linux-gnu
+Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
+Thread model: posix
+gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) 
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64'
+ /usr/lib/gcc/x86_64-linux-gnu/9/cc1 -quiet -v -imultiarch x86_64-linux-gnu /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c -quiet -dumpbase CMakeCCompilerABI.c -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccKCe11d.s
+GNU C17 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)
+	compiled by GNU C version 9.4.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.22.1-GMP
+
+GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
+ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"
+ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"
+#include "..." search starts here:
+#include <...> search starts here:
+ /usr/lib/gcc/x86_64-linux-gnu/9/include
+ /usr/local/include
+ /usr/include/x86_64-linux-gnu
+ /usr/include
+End of search list.
+GNU C17 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)
+	compiled by GNU C version 9.4.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.22.1-GMP
+
+GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+Compiler executable checksum: 01da938ff5dc2163489aa33cb3b747a7
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64'
+ as -v --64 -o CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o /tmp/ccKCe11d.s
+GNU assembler version 2.34 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.34
+COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/
+LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64'
+Linking C executable cmTC_202d0
+/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_202d0.dir/link.txt --verbose=1
+/usr/bin/cc     -v CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o  -o cmTC_202d0 
+Using built-in specs.
+COLLECT_GCC=/usr/bin/cc
+COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper
+OFFLOAD_TARGET_NAMES=nvptx-none:hsa
+OFFLOAD_TARGET_DEFAULT=1
+Target: x86_64-linux-gnu
+Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
+Thread model: posix
+gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) 
+COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/
+LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/
+COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_202d0' '-mtune=generic' '-march=x86-64'
+ /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=/tmp/ccJJ2fOY.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_202d0 /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o
+COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_202d0' '-mtune=generic' '-march=x86-64'
+make[1]: Leaving directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp'
+
+
+
+Parsed C implicit include dir info from above output: rv=done
+  found start of include info
+  found start of implicit include info
+    add: [/usr/lib/gcc/x86_64-linux-gnu/9/include]
+    add: [/usr/local/include]
+    add: [/usr/include/x86_64-linux-gnu]
+    add: [/usr/include]
+  end of search list found
+  collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/9/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/9/include]
+  collapse include dir [/usr/local/include] ==> [/usr/local/include]
+  collapse include dir [/usr/include/x86_64-linux-gnu] ==> [/usr/include/x86_64-linux-gnu]
+  collapse include dir [/usr/include] ==> [/usr/include]
+  implicit include dirs: [/usr/lib/gcc/x86_64-linux-gnu/9/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include]
+
+
+Parsed C implicit link information from above output:
+  link line regex: [^( *|.*[/\])(ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\]+-)?ld|collect2)[^/\]*( |$)]
+  ignore line: [Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp]
+  ignore line: []
+  ignore line: [Run Build Command(s):/usr/bin/make cmTC_202d0/fast && /usr/bin/make -f CMakeFiles/cmTC_202d0.dir/build.make CMakeFiles/cmTC_202d0.dir/build]
+  ignore line: [make[1]: Entering directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp']
+  ignore line: [Building C object CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o]
+  ignore line: [/usr/bin/cc   -v -o CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o   -c /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c]
+  ignore line: [Using built-in specs.]
+  ignore line: [COLLECT_GCC=/usr/bin/cc]
+  ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:hsa]
+  ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+  ignore line: [Target: x86_64-linux-gnu]
+  ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu]
+  ignore line: [Thread model: posix]
+  ignore line: [gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) ]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64']
+  ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/9/cc1 -quiet -v -imultiarch x86_64-linux-gnu /usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c -quiet -dumpbase CMakeCCompilerABI.c -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccKCe11d.s]
+  ignore line: [GNU C17 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)]
+  ignore line: [	compiled by GNU C version 9.4.0  GMP version 6.2.0  MPFR version 4.0.2  MPC version 1.1.0  isl version isl-0.22.1-GMP]
+  ignore line: []
+  ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+  ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"]
+  ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"]
+  ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"]
+  ignore line: [#include "..." search starts here:]
+  ignore line: [#include <...> search starts here:]
+  ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/9/include]
+  ignore line: [ /usr/local/include]
+  ignore line: [ /usr/include/x86_64-linux-gnu]
+  ignore line: [ /usr/include]
+  ignore line: [End of search list.]
+  ignore line: [GNU C17 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)]
+  ignore line: [	compiled by GNU C version 9.4.0  GMP version 6.2.0  MPFR version 4.0.2  MPC version 1.1.0  isl version isl-0.22.1-GMP]
+  ignore line: []
+  ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+  ignore line: [Compiler executable checksum: 01da938ff5dc2163489aa33cb3b747a7]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64']
+  ignore line: [ as -v --64 -o CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o /tmp/ccKCe11d.s]
+  ignore line: [GNU assembler version 2.34 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.34]
+  ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/]
+  ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64']
+  ignore line: [Linking C executable cmTC_202d0]
+  ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_202d0.dir/link.txt --verbose=1]
+  ignore line: [/usr/bin/cc     -v CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o  -o cmTC_202d0 ]
+  ignore line: [Using built-in specs.]
+  ignore line: [COLLECT_GCC=/usr/bin/cc]
+  ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper]
+  ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:hsa]
+  ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+  ignore line: [Target: x86_64-linux-gnu]
+  ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu]
+  ignore line: [Thread model: posix]
+  ignore line: [gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) ]
+  ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/]
+  ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_202d0' '-mtune=generic' '-march=x86-64']
+  link line: [ /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=/tmp/ccJJ2fOY.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_202d0 /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o]
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/collect2] ==> ignore
+    arg [-plugin] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so] ==> ignore
+    arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper] ==> ignore
+    arg [-plugin-opt=-fresolution=/tmp/ccJJ2fOY.res] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+    arg [-plugin-opt=-pass-through=-lc] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+    arg [--build-id] ==> ignore
+    arg [--eh-frame-hdr] ==> ignore
+    arg [-m] ==> ignore
+    arg [elf_x86_64] ==> ignore
+    arg [--hash-style=gnu] ==> ignore
+    arg [--as-needed] ==> ignore
+    arg [-dynamic-linker] ==> ignore
+    arg [/lib64/ld-linux-x86-64.so.2] ==> ignore
+    arg [-pie] ==> ignore
+    arg [-znow] ==> ignore
+    arg [-zrelro] ==> ignore
+    arg [-o] ==> ignore
+    arg [cmTC_202d0] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o] ==> ignore
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib]
+    arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu]
+    arg [-L/lib/../lib] ==> dir [/lib/../lib]
+    arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu]
+    arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../..]
+    arg [CMakeFiles/cmTC_202d0.dir/CMakeCCompilerABI.c.o] ==> ignore
+    arg [-lgcc] ==> lib [gcc]
+    arg [--push-state] ==> ignore
+    arg [--as-needed] ==> ignore
+    arg [-lgcc_s] ==> lib [gcc_s]
+    arg [--pop-state] ==> ignore
+    arg [-lc] ==> lib [c]
+    arg [-lgcc] ==> lib [gcc]
+    arg [--push-state] ==> ignore
+    arg [--as-needed] ==> ignore
+    arg [-lgcc_s] ==> lib [gcc_s]
+    arg [--pop-state] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o] ==> ignore
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9] ==> [/usr/lib/gcc/x86_64-linux-gnu/9]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib] ==> [/usr/lib]
+  collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu]
+  collapse library dir [/lib/../lib] ==> [/lib]
+  collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu]
+  collapse library dir [/usr/lib/../lib] ==> [/usr/lib]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../..] ==> [/usr/lib]
+  implicit libs: [gcc;gcc_s;c;gcc;gcc_s]
+  implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/9;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib]
+  implicit fwks: []
+
+
+Determining if the CXX compiler works passed with the following output:
+Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp
+
+Run Build Command(s):/usr/bin/make cmTC_64d08/fast && /usr/bin/make -f CMakeFiles/cmTC_64d08.dir/build.make CMakeFiles/cmTC_64d08.dir/build
+make[1]: 进入目录“/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp”
+Building CXX object CMakeFiles/cmTC_64d08.dir/testCXXCompiler.cxx.o
+/usr/bin/c++     -o CMakeFiles/cmTC_64d08.dir/testCXXCompiler.cxx.o -c /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp/testCXXCompiler.cxx
+Linking CXX executable cmTC_64d08
+/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_64d08.dir/link.txt --verbose=1
+/usr/bin/c++       CMakeFiles/cmTC_64d08.dir/testCXXCompiler.cxx.o  -o cmTC_64d08 
+make[1]: 离开目录“/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp”
+
+
+
+Detecting CXX compiler ABI info compiled with the following output:
+Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp
+
+Run Build Command(s):/usr/bin/make cmTC_bd58d/fast && /usr/bin/make -f CMakeFiles/cmTC_bd58d.dir/build.make CMakeFiles/cmTC_bd58d.dir/build
+make[1]: Entering directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp'
+Building CXX object CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o
+/usr/bin/c++    -v -o CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp
+Using built-in specs.
+COLLECT_GCC=/usr/bin/c++
+OFFLOAD_TARGET_NAMES=nvptx-none:hsa
+OFFLOAD_TARGET_DEFAULT=1
+Target: x86_64-linux-gnu
+Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
+Thread model: posix
+gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) 
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+ /usr/lib/gcc/x86_64-linux-gnu/9/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccxp1oaQ.s
+GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)
+	compiled by GNU C version 9.4.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.22.1-GMP
+
+GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/9"
+ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
+ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"
+ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"
+#include "..." search starts here:
+#include <...> search starts here:
+ /usr/include/c++/9
+ /usr/include/x86_64-linux-gnu/c++/9
+ /usr/include/c++/9/backward
+ /usr/lib/gcc/x86_64-linux-gnu/9/include
+ /usr/local/include
+ /usr/include/x86_64-linux-gnu
+ /usr/include
+End of search list.
+GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)
+	compiled by GNU C version 9.4.0, GMP version 6.2.0, MPFR version 4.0.2, MPC version 1.1.0, isl version isl-0.22.1-GMP
+
+GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+Compiler executable checksum: 3d1eba838554fa2348dba760e4770469
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+ as -v --64 -o CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccxp1oaQ.s
+GNU assembler version 2.34 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.34
+COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/
+LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/
+COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+Linking CXX executable cmTC_bd58d
+/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_bd58d.dir/link.txt --verbose=1
+/usr/bin/c++      -v CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o  -o cmTC_bd58d 
+Using built-in specs.
+COLLECT_GCC=/usr/bin/c++
+COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper
+OFFLOAD_TARGET_NAMES=nvptx-none:hsa
+OFFLOAD_TARGET_DEFAULT=1
+Target: x86_64-linux-gnu
+Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
+Thread model: posix
+gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) 
+COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/
+LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/
+COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_bd58d' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+ /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=/tmp/ccBblsAo.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_bd58d /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o
+COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_bd58d' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+make[1]: Leaving directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp'
+
+
+
+Parsed CXX implicit include dir info from above output: rv=done
+  found start of include info
+  found start of implicit include info
+    add: [/usr/include/c++/9]
+    add: [/usr/include/x86_64-linux-gnu/c++/9]
+    add: [/usr/include/c++/9/backward]
+    add: [/usr/lib/gcc/x86_64-linux-gnu/9/include]
+    add: [/usr/local/include]
+    add: [/usr/include/x86_64-linux-gnu]
+    add: [/usr/include]
+  end of search list found
+  collapse include dir [/usr/include/c++/9] ==> [/usr/include/c++/9]
+  collapse include dir [/usr/include/x86_64-linux-gnu/c++/9] ==> [/usr/include/x86_64-linux-gnu/c++/9]
+  collapse include dir [/usr/include/c++/9/backward] ==> [/usr/include/c++/9/backward]
+  collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/9/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/9/include]
+  collapse include dir [/usr/local/include] ==> [/usr/local/include]
+  collapse include dir [/usr/include/x86_64-linux-gnu] ==> [/usr/include/x86_64-linux-gnu]
+  collapse include dir [/usr/include] ==> [/usr/include]
+  implicit include dirs: [/usr/include/c++/9;/usr/include/x86_64-linux-gnu/c++/9;/usr/include/c++/9/backward;/usr/lib/gcc/x86_64-linux-gnu/9/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include]
+
+
+Parsed CXX implicit link information from above output:
+  link line regex: [^( *|.*[/\])(ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\]+-)?ld|collect2)[^/\]*( |$)]
+  ignore line: [Change Dir: /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp]
+  ignore line: []
+  ignore line: [Run Build Command(s):/usr/bin/make cmTC_bd58d/fast && /usr/bin/make -f CMakeFiles/cmTC_bd58d.dir/build.make CMakeFiles/cmTC_bd58d.dir/build]
+  ignore line: [make[1]: Entering directory '/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/CMakeTmp']
+  ignore line: [Building CXX object CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o]
+  ignore line: [/usr/bin/c++    -v -o CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp]
+  ignore line: [Using built-in specs.]
+  ignore line: [COLLECT_GCC=/usr/bin/c++]
+  ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:hsa]
+  ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+  ignore line: [Target: x86_64-linux-gnu]
+  ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu]
+  ignore line: [Thread model: posix]
+  ignore line: [gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) ]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+  ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/9/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccxp1oaQ.s]
+  ignore line: [GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)]
+  ignore line: [	compiled by GNU C version 9.4.0  GMP version 6.2.0  MPFR version 4.0.2  MPC version 1.1.0  isl version isl-0.22.1-GMP]
+  ignore line: []
+  ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+  ignore line: [ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/9"]
+  ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"]
+  ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"]
+  ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"]
+  ignore line: [#include "..." search starts here:]
+  ignore line: [#include <...> search starts here:]
+  ignore line: [ /usr/include/c++/9]
+  ignore line: [ /usr/include/x86_64-linux-gnu/c++/9]
+  ignore line: [ /usr/include/c++/9/backward]
+  ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/9/include]
+  ignore line: [ /usr/local/include]
+  ignore line: [ /usr/include/x86_64-linux-gnu]
+  ignore line: [ /usr/include]
+  ignore line: [End of search list.]
+  ignore line: [GNU C++14 (Ubuntu 9.4.0-1ubuntu1~20.04.2) version 9.4.0 (x86_64-linux-gnu)]
+  ignore line: [	compiled by GNU C version 9.4.0  GMP version 6.2.0  MPFR version 4.0.2  MPC version 1.1.0  isl version isl-0.22.1-GMP]
+  ignore line: []
+  ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+  ignore line: [Compiler executable checksum: 3d1eba838554fa2348dba760e4770469]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+  ignore line: [ as -v --64 -o CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccxp1oaQ.s]
+  ignore line: [GNU assembler version 2.34 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.34]
+  ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/]
+  ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+  ignore line: [Linking CXX executable cmTC_bd58d]
+  ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_bd58d.dir/link.txt --verbose=1]
+  ignore line: [/usr/bin/c++      -v CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o  -o cmTC_bd58d ]
+  ignore line: [Using built-in specs.]
+  ignore line: [COLLECT_GCC=/usr/bin/c++]
+  ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper]
+  ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:hsa]
+  ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+  ignore line: [Target: x86_64-linux-gnu]
+  ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.2' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-9QDOt0/gcc-9-9.4.0/debian/tmp-nvptx/usr hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu]
+  ignore line: [Thread model: posix]
+  ignore line: [gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.2) ]
+  ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/]
+  ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/9/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/9/../../../:/lib/:/usr/lib/]
+  ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_bd58d' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+  link line: [ /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=/tmp/ccBblsAo.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_bd58d /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o]
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/collect2] ==> ignore
+    arg [-plugin] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so] ==> ignore
+    arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper] ==> ignore
+    arg [-plugin-opt=-fresolution=/tmp/ccBblsAo.res] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+    arg [-plugin-opt=-pass-through=-lc] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+    arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+    arg [--build-id] ==> ignore
+    arg [--eh-frame-hdr] ==> ignore
+    arg [-m] ==> ignore
+    arg [elf_x86_64] ==> ignore
+    arg [--hash-style=gnu] ==> ignore
+    arg [--as-needed] ==> ignore
+    arg [-dynamic-linker] ==> ignore
+    arg [/lib64/ld-linux-x86-64.so.2] ==> ignore
+    arg [-pie] ==> ignore
+    arg [-znow] ==> ignore
+    arg [-zrelro] ==> ignore
+    arg [-o] ==> ignore
+    arg [cmTC_bd58d] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o] ==> ignore
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib]
+    arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu]
+    arg [-L/lib/../lib] ==> dir [/lib/../lib]
+    arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu]
+    arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib]
+    arg [-L/usr/lib/gcc/x86_64-linux-gnu/9/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../..]
+    arg [CMakeFiles/cmTC_bd58d.dir/CMakeCXXCompilerABI.cpp.o] ==> ignore
+    arg [-lstdc++] ==> lib [stdc++]
+    arg [-lm] ==> lib [m]
+    arg [-lgcc_s] ==> lib [gcc_s]
+    arg [-lgcc] ==> lib [gcc]
+    arg [-lc] ==> lib [c]
+    arg [-lgcc_s] ==> lib [gcc_s]
+    arg [-lgcc] ==> lib [gcc]
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o] ==> ignore
+    arg [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o] ==> ignore
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9] ==> [/usr/lib/gcc/x86_64-linux-gnu/9]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib] ==> [/usr/lib]
+  collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu]
+  collapse library dir [/lib/../lib] ==> [/lib]
+  collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu]
+  collapse library dir [/usr/lib/../lib] ==> [/usr/lib]
+  collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/9/../../..] ==> [/usr/lib]
+  implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc]
+  implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/9;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib]
+  implicit fwks: []
+
+
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/Makefile.cmake b/C++/yolo_bytetrack_old/build/CMakeFiles/Makefile.cmake
new file mode 100644
index 00000000..6f41072f
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/Makefile.cmake
@@ -0,0 +1,128 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# The generator used is:
+set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles")
+
+# The top level Makefile was generated from the following files:
+set(CMAKE_MAKEFILE_DEPENDS
+  "CMakeCache.txt"
+  "../CMakeLists.txt"
+  "CMakeFiles/3.16.3/CMakeCCompiler.cmake"
+  "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake"
+  "CMakeFiles/3.16.3/CMakeSystem.cmake"
+  "/home/huey/opencv-4.7.0/install/lib/cmake/opencv4/OpenCVConfig-version.cmake"
+  "/home/huey/opencv-4.7.0/install/lib/cmake/opencv4/OpenCVConfig.cmake"
+  "/home/huey/opencv-4.7.0/install/lib/cmake/opencv4/OpenCVModules-release.cmake"
+  "/home/huey/opencv-4.7.0/install/lib/cmake/opencv4/OpenCVModules.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeCCompiler.cmake.in"
+  "/usr/share/cmake-3.16/Modules/CMakeCCompilerABI.c"
+  "/usr/share/cmake-3.16/Modules/CMakeCInformation.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeCXXCompiler.cmake.in"
+  "/usr/share/cmake-3.16/Modules/CMakeCXXCompilerABI.cpp"
+  "/usr/share/cmake-3.16/Modules/CMakeCXXInformation.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeCommonLanguageInclude.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeCompilerIdDetection.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCXXCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompileFeatures.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompilerABI.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineCompilerId.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeDetermineSystem.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeFindBinUtils.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeGenericSystem.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeInitializeConfigs.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeLanguageInformation.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeParseImplicitIncludeInfo.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeParseImplicitLinkInfo.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeSystem.cmake.in"
+  "/usr/share/cmake-3.16/Modules/CMakeSystemSpecificInformation.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeSystemSpecificInitialize.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeTestCCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeTestCXXCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeTestCompilerCommon.cmake"
+  "/usr/share/cmake-3.16/Modules/CMakeUnixFindMake.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/ADSP-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/ARMCC-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/ARMClang-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/AppleClang-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Borland-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Bruce-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Clang-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Compaq-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Cray-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Embarcadero-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Fujitsu-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GHS-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU-C.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU-CXX.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU-FindBinUtils.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/GNU.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/HP-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/HP-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/IAR-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Intel-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/MSVC-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/NVIDIA-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/PGI-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/PathScale-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/SCO-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/SDCC-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/SunPro-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/TI-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/Watcom-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/XL-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/XL-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/XLClang-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/zOS-C-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake"
+  "/usr/share/cmake-3.16/Modules/FindOpenSSL.cmake"
+  "/usr/share/cmake-3.16/Modules/FindPackageHandleStandardArgs.cmake"
+  "/usr/share/cmake-3.16/Modules/FindPackageMessage.cmake"
+  "/usr/share/cmake-3.16/Modules/FindPkgConfig.cmake"
+  "/usr/share/cmake-3.16/Modules/Internal/CMakeCheckCompilerFlag.cmake"
+  "/usr/share/cmake-3.16/Modules/Internal/FeatureTesting.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/Linux-Determine-CXX.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/Linux-GNU-C.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/Linux-GNU-CXX.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/Linux-GNU.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/Linux.cmake"
+  "/usr/share/cmake-3.16/Modules/Platform/UnixPaths.cmake"
+  )
+
+# The corresponding makefile is:
+set(CMAKE_MAKEFILE_OUTPUTS
+  "Makefile"
+  "CMakeFiles/cmake.check_cache"
+  )
+
+# Byproducts of CMake generate step:
+set(CMAKE_MAKEFILE_PRODUCTS
+  "CMakeFiles/3.16.3/CMakeSystem.cmake"
+  "CMakeFiles/3.16.3/CMakeCCompiler.cmake"
+  "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake"
+  "CMakeFiles/3.16.3/CMakeCCompiler.cmake"
+  "CMakeFiles/3.16.3/CMakeCXXCompiler.cmake"
+  "CMakeFiles/CMakeDirectoryInformation.cmake"
+  )
+
+# Dependency information for all targets:
+set(CMAKE_DEPEND_INFO_FILES
+  "CMakeFiles/yolo_bytetrack.dir/DependInfo.cmake"
+  )
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/Makefile2 b/C++/yolo_bytetrack_old/build/CMakeFiles/Makefile2
new file mode 100644
index 00000000..71f447f7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/Makefile2
@@ -0,0 +1,106 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# Default target executed when no arguments are given to make.
+default_target: all
+
+.PHONY : default_target
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+
+# Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+
+# A target that is always out of date.
+cmake_force:
+
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E remove -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/huey/Desktop/C/yolo_bytetrack
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/huey/Desktop/C/yolo_bytetrack/build
+
+#=============================================================================
+# Directory level rules for the build root directory
+
+# The main recursive "all" target.
+all: CMakeFiles/yolo_bytetrack.dir/all
+
+.PHONY : all
+
+# The main recursive "preinstall" target.
+preinstall:
+
+.PHONY : preinstall
+
+# The main recursive "clean" target.
+clean: CMakeFiles/yolo_bytetrack.dir/clean
+
+.PHONY : clean
+
+#=============================================================================
+# Target rules for target CMakeFiles/yolo_bytetrack.dir
+
+# All Build rule for target.
+CMakeFiles/yolo_bytetrack.dir/all:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/depend
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=1,2,3,4,5,6,7 "Built target yolo_bytetrack"
+.PHONY : CMakeFiles/yolo_bytetrack.dir/all
+
+# Build rule for subdir invocation for target.
+CMakeFiles/yolo_bytetrack.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles 7
+	$(MAKE) -f CMakeFiles/Makefile2 CMakeFiles/yolo_bytetrack.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles 0
+.PHONY : CMakeFiles/yolo_bytetrack.dir/rule
+
+# Convenience name for target.
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/rule
+
+.PHONY : yolo_bytetrack
+
+# clean rule for target.
+CMakeFiles/yolo_bytetrack.dir/clean:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/clean
+.PHONY : CMakeFiles/yolo_bytetrack.dir/clean
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/TargetDirectories.txt b/C++/yolo_bytetrack_old/build/CMakeFiles/TargetDirectories.txt
new file mode 100644
index 00000000..c5dc9c3a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/TargetDirectories.txt
@@ -0,0 +1,3 @@
+/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/rebuild_cache.dir
+/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/edit_cache.dir
+/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/cmake.check_cache b/C++/yolo_bytetrack_old/build/CMakeFiles/cmake.check_cache
new file mode 100644
index 00000000..3dccd731
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/cmake.check_cache
@@ -0,0 +1 @@
+# This file is generated by cmake for dependency checking of the CMakeCache.txt file
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/progress.marks b/C++/yolo_bytetrack_old/build/CMakeFiles/progress.marks
new file mode 100644
index 00000000..7f8f011e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+7
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/CXX.includecache b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/CXX.includecache
new file mode 100644
index 00000000..66666d8a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/CXX.includecache
@@ -0,0 +1,2734 @@
+#IncludeRegexLine: ^[ 	]*[#%][ 	]*(include|import)[ 	]*[<"]([^">]+)([">])
+
+#IncludeRegexScan: ^.*$
+
+#IncludeRegexComplain: ^$
+
+#IncludeRegexTransform: 
+
+../3rdparty/librknn_api/include/rknn_api.h
+stdint.h
+-
+
+../include/BYTETracker.h
+STrack.h
+../include/STrack.h
+
+../include/Eigen/Cholesky
+Core
+../include/Eigen/Core
+Jacobi
+../include/Eigen/Jacobi
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/Cholesky/LLT.h
+../include/Eigen/src/Cholesky/LLT.h
+src/Cholesky/LDLT.h
+../include/Eigen/src/Cholesky/LDLT.h
+mkl_lapacke.h
+../include/Eigen/mkl_lapacke.h
+src/misc/lapacke.h
+../include/Eigen/src/misc/lapacke.h
+src/Cholesky/LLT_LAPACKE.h
+../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/Core
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/Core/util/Macros.h
+../include/Eigen/src/Core/util/Macros.h
+src/Core/util/ConfigureVectorization.h
+../include/Eigen/src/Core/util/ConfigureVectorization.h
+cuda_runtime.h
+-
+hip/hip_runtime.h
+-
+new
+-
+complex
+-
+src/Core/util/MKL_support.h
+../include/Eigen/src/Core/util/MKL_support.h
+omp.h
+-
+cerrno
+-
+cstddef
+-
+cstdlib
+-
+cmath
+-
+cassert
+-
+functional
+-
+sstream
+-
+iosfwd
+-
+cstring
+-
+string
+-
+limits
+-
+climits
+-
+algorithm
+-
+array
+-
+type_traits
+-
+iostream
+-
+intrin.h
+-
+CL/sycl.hpp
+-
+map
+-
+memory
+-
+utility
+-
+thread
+-
+src/Core/util/Constants.h
+../include/Eigen/src/Core/util/Constants.h
+src/Core/util/Meta.h
+../include/Eigen/src/Core/util/Meta.h
+src/Core/util/ForwardDeclarations.h
+../include/Eigen/src/Core/util/ForwardDeclarations.h
+src/Core/util/StaticAssert.h
+../include/Eigen/src/Core/util/StaticAssert.h
+src/Core/util/XprHelper.h
+../include/Eigen/src/Core/util/XprHelper.h
+src/Core/util/Memory.h
+../include/Eigen/src/Core/util/Memory.h
+src/Core/util/IntegralConstant.h
+../include/Eigen/src/Core/util/IntegralConstant.h
+src/Core/util/SymbolicIndex.h
+../include/Eigen/src/Core/util/SymbolicIndex.h
+src/Core/NumTraits.h
+../include/Eigen/src/Core/NumTraits.h
+src/Core/MathFunctions.h
+../include/Eigen/src/Core/MathFunctions.h
+src/Core/GenericPacketMath.h
+../include/Eigen/src/Core/GenericPacketMath.h
+src/Core/MathFunctionsImpl.h
+../include/Eigen/src/Core/MathFunctionsImpl.h
+src/Core/arch/Default/ConjHelper.h
+../include/Eigen/src/Core/arch/Default/ConjHelper.h
+src/Core/arch/Default/Half.h
+../include/Eigen/src/Core/arch/Default/Half.h
+src/Core/arch/Default/BFloat16.h
+../include/Eigen/src/Core/arch/Default/BFloat16.h
+src/Core/arch/Default/TypeCasting.h
+../include/Eigen/src/Core/arch/Default/TypeCasting.h
+src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+src/Core/arch/SSE/PacketMath.h
+../include/Eigen/src/Core/arch/SSE/PacketMath.h
+src/Core/arch/SSE/TypeCasting.h
+../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+src/Core/arch/SSE/Complex.h
+../include/Eigen/src/Core/arch/SSE/Complex.h
+src/Core/arch/AVX/PacketMath.h
+../include/Eigen/src/Core/arch/AVX/PacketMath.h
+src/Core/arch/AVX/TypeCasting.h
+../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+src/Core/arch/AVX/Complex.h
+../include/Eigen/src/Core/arch/AVX/Complex.h
+src/Core/arch/AVX512/PacketMath.h
+../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+src/Core/arch/AVX512/TypeCasting.h
+../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+src/Core/arch/AVX512/Complex.h
+../include/Eigen/src/Core/arch/AVX512/Complex.h
+src/Core/arch/SSE/MathFunctions.h
+../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+src/Core/arch/AVX/MathFunctions.h
+../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+src/Core/arch/AVX512/MathFunctions.h
+../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+src/Core/arch/SSE/PacketMath.h
+../include/Eigen/src/Core/arch/SSE/PacketMath.h
+src/Core/arch/SSE/TypeCasting.h
+../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+src/Core/arch/SSE/Complex.h
+../include/Eigen/src/Core/arch/SSE/Complex.h
+src/Core/arch/AVX/PacketMath.h
+../include/Eigen/src/Core/arch/AVX/PacketMath.h
+src/Core/arch/AVX/TypeCasting.h
+../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+src/Core/arch/AVX/Complex.h
+../include/Eigen/src/Core/arch/AVX/Complex.h
+src/Core/arch/SSE/MathFunctions.h
+../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+src/Core/arch/AVX/MathFunctions.h
+../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+src/Core/arch/SSE/PacketMath.h
+../include/Eigen/src/Core/arch/SSE/PacketMath.h
+src/Core/arch/SSE/TypeCasting.h
+../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+src/Core/arch/SSE/MathFunctions.h
+../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+src/Core/arch/SSE/Complex.h
+../include/Eigen/src/Core/arch/SSE/Complex.h
+src/Core/arch/AltiVec/PacketMath.h
+../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+src/Core/arch/AltiVec/MathFunctions.h
+../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+src/Core/arch/AltiVec/Complex.h
+../include/Eigen/src/Core/arch/AltiVec/Complex.h
+src/Core/arch/NEON/PacketMath.h
+../include/Eigen/src/Core/arch/NEON/PacketMath.h
+src/Core/arch/NEON/TypeCasting.h
+../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+src/Core/arch/NEON/MathFunctions.h
+../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+src/Core/arch/NEON/Complex.h
+../include/Eigen/src/Core/arch/NEON/Complex.h
+src/Core/arch/SVE/PacketMath.h
+../include/Eigen/src/Core/arch/SVE/PacketMath.h
+src/Core/arch/SVE/TypeCasting.h
+../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+src/Core/arch/SVE/MathFunctions.h
+../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+src/Core/arch/ZVector/PacketMath.h
+../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+src/Core/arch/ZVector/MathFunctions.h
+../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+src/Core/arch/ZVector/Complex.h
+../include/Eigen/src/Core/arch/ZVector/Complex.h
+src/Core/arch/MSA/PacketMath.h
+../include/Eigen/src/Core/arch/MSA/PacketMath.h
+src/Core/arch/MSA/MathFunctions.h
+../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+src/Core/arch/MSA/Complex.h
+../include/Eigen/src/Core/arch/MSA/Complex.h
+src/Core/arch/GPU/PacketMath.h
+../include/Eigen/src/Core/arch/GPU/PacketMath.h
+src/Core/arch/GPU/MathFunctions.h
+../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+src/Core/arch/GPU/TypeCasting.h
+../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+src/Core/arch/SYCL/SyclMemoryModel.h
+../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+src/Core/arch/SYCL/InteropHeaders.h
+../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+src/Core/arch/SYCL/PacketMath.h
+../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+src/Core/arch/SYCL/MathFunctions.h
+../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+src/Core/arch/SYCL/TypeCasting.h
+../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+src/Core/arch/Default/Settings.h
+../include/Eigen/src/Core/arch/Default/Settings.h
+src/Core/arch/Default/GenericPacketMathFunctions.h
+../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+src/Core/functors/TernaryFunctors.h
+../include/Eigen/src/Core/functors/TernaryFunctors.h
+src/Core/functors/BinaryFunctors.h
+../include/Eigen/src/Core/functors/BinaryFunctors.h
+src/Core/functors/UnaryFunctors.h
+../include/Eigen/src/Core/functors/UnaryFunctors.h
+src/Core/functors/NullaryFunctors.h
+../include/Eigen/src/Core/functors/NullaryFunctors.h
+src/Core/functors/StlFunctors.h
+../include/Eigen/src/Core/functors/StlFunctors.h
+src/Core/functors/AssignmentFunctors.h
+../include/Eigen/src/Core/functors/AssignmentFunctors.h
+src/Core/arch/CUDA/Complex.h
+../include/Eigen/src/Core/arch/CUDA/Complex.h
+src/Core/util/IndexedViewHelper.h
+../include/Eigen/src/Core/util/IndexedViewHelper.h
+src/Core/util/ReshapedHelper.h
+../include/Eigen/src/Core/util/ReshapedHelper.h
+src/Core/ArithmeticSequence.h
+../include/Eigen/src/Core/ArithmeticSequence.h
+src/Core/IO.h
+../include/Eigen/src/Core/IO.h
+src/Core/DenseCoeffsBase.h
+../include/Eigen/src/Core/DenseCoeffsBase.h
+src/Core/DenseBase.h
+../include/Eigen/src/Core/DenseBase.h
+src/Core/MatrixBase.h
+../include/Eigen/src/Core/MatrixBase.h
+src/Core/EigenBase.h
+../include/Eigen/src/Core/EigenBase.h
+src/Core/Product.h
+../include/Eigen/src/Core/Product.h
+src/Core/CoreEvaluators.h
+../include/Eigen/src/Core/CoreEvaluators.h
+src/Core/AssignEvaluator.h
+../include/Eigen/src/Core/AssignEvaluator.h
+src/Core/Assign.h
+../include/Eigen/src/Core/Assign.h
+src/Core/ArrayBase.h
+../include/Eigen/src/Core/ArrayBase.h
+src/Core/util/BlasUtil.h
+../include/Eigen/src/Core/util/BlasUtil.h
+src/Core/DenseStorage.h
+../include/Eigen/src/Core/DenseStorage.h
+src/Core/NestByValue.h
+../include/Eigen/src/Core/NestByValue.h
+src/Core/ReturnByValue.h
+../include/Eigen/src/Core/ReturnByValue.h
+src/Core/NoAlias.h
+../include/Eigen/src/Core/NoAlias.h
+src/Core/PlainObjectBase.h
+../include/Eigen/src/Core/PlainObjectBase.h
+src/Core/Matrix.h
+../include/Eigen/src/Core/Matrix.h
+src/Core/Array.h
+../include/Eigen/src/Core/Array.h
+src/Core/CwiseTernaryOp.h
+../include/Eigen/src/Core/CwiseTernaryOp.h
+src/Core/CwiseBinaryOp.h
+../include/Eigen/src/Core/CwiseBinaryOp.h
+src/Core/CwiseUnaryOp.h
+../include/Eigen/src/Core/CwiseUnaryOp.h
+src/Core/CwiseNullaryOp.h
+../include/Eigen/src/Core/CwiseNullaryOp.h
+src/Core/CwiseUnaryView.h
+../include/Eigen/src/Core/CwiseUnaryView.h
+src/Core/SelfCwiseBinaryOp.h
+../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+src/Core/Dot.h
+../include/Eigen/src/Core/Dot.h
+src/Core/StableNorm.h
+../include/Eigen/src/Core/StableNorm.h
+src/Core/Stride.h
+../include/Eigen/src/Core/Stride.h
+src/Core/MapBase.h
+../include/Eigen/src/Core/MapBase.h
+src/Core/Map.h
+../include/Eigen/src/Core/Map.h
+src/Core/Ref.h
+../include/Eigen/src/Core/Ref.h
+src/Core/Block.h
+../include/Eigen/src/Core/Block.h
+src/Core/VectorBlock.h
+../include/Eigen/src/Core/VectorBlock.h
+src/Core/IndexedView.h
+../include/Eigen/src/Core/IndexedView.h
+src/Core/Reshaped.h
+../include/Eigen/src/Core/Reshaped.h
+src/Core/Transpose.h
+../include/Eigen/src/Core/Transpose.h
+src/Core/DiagonalMatrix.h
+../include/Eigen/src/Core/DiagonalMatrix.h
+src/Core/Diagonal.h
+../include/Eigen/src/Core/Diagonal.h
+src/Core/DiagonalProduct.h
+../include/Eigen/src/Core/DiagonalProduct.h
+src/Core/Redux.h
+../include/Eigen/src/Core/Redux.h
+src/Core/Visitor.h
+../include/Eigen/src/Core/Visitor.h
+src/Core/Fuzzy.h
+../include/Eigen/src/Core/Fuzzy.h
+src/Core/Swap.h
+../include/Eigen/src/Core/Swap.h
+src/Core/CommaInitializer.h
+../include/Eigen/src/Core/CommaInitializer.h
+src/Core/GeneralProduct.h
+../include/Eigen/src/Core/GeneralProduct.h
+src/Core/Solve.h
+../include/Eigen/src/Core/Solve.h
+src/Core/Inverse.h
+../include/Eigen/src/Core/Inverse.h
+src/Core/SolverBase.h
+../include/Eigen/src/Core/SolverBase.h
+src/Core/PermutationMatrix.h
+../include/Eigen/src/Core/PermutationMatrix.h
+src/Core/Transpositions.h
+../include/Eigen/src/Core/Transpositions.h
+src/Core/TriangularMatrix.h
+../include/Eigen/src/Core/TriangularMatrix.h
+src/Core/SelfAdjointView.h
+../include/Eigen/src/Core/SelfAdjointView.h
+src/Core/products/GeneralBlockPanelKernel.h
+../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+src/Core/products/Parallelizer.h
+../include/Eigen/src/Core/products/Parallelizer.h
+src/Core/ProductEvaluators.h
+../include/Eigen/src/Core/ProductEvaluators.h
+src/Core/products/GeneralMatrixVector.h
+../include/Eigen/src/Core/products/GeneralMatrixVector.h
+src/Core/products/GeneralMatrixMatrix.h
+../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+src/Core/SolveTriangular.h
+../include/Eigen/src/Core/SolveTriangular.h
+src/Core/products/GeneralMatrixMatrixTriangular.h
+../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+src/Core/products/SelfadjointMatrixVector.h
+../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+src/Core/products/SelfadjointMatrixMatrix.h
+../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+src/Core/products/SelfadjointProduct.h
+../include/Eigen/src/Core/products/SelfadjointProduct.h
+src/Core/products/SelfadjointRank2Update.h
+../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+src/Core/products/TriangularMatrixVector.h
+../include/Eigen/src/Core/products/TriangularMatrixVector.h
+src/Core/products/TriangularMatrixMatrix.h
+../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+src/Core/products/TriangularSolverMatrix.h
+../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+src/Core/products/TriangularSolverVector.h
+../include/Eigen/src/Core/products/TriangularSolverVector.h
+src/Core/BandMatrix.h
+../include/Eigen/src/Core/BandMatrix.h
+src/Core/CoreIterators.h
+../include/Eigen/src/Core/CoreIterators.h
+src/Core/ConditionEstimator.h
+../include/Eigen/src/Core/ConditionEstimator.h
+src/Core/arch/AltiVec/MatrixProduct.h
+../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+src/Core/arch/NEON/GeneralBlockPanelKernel.h
+../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+src/Core/BooleanRedux.h
+../include/Eigen/src/Core/BooleanRedux.h
+src/Core/Select.h
+../include/Eigen/src/Core/Select.h
+src/Core/VectorwiseOp.h
+../include/Eigen/src/Core/VectorwiseOp.h
+src/Core/PartialReduxEvaluator.h
+../include/Eigen/src/Core/PartialReduxEvaluator.h
+src/Core/Random.h
+../include/Eigen/src/Core/Random.h
+src/Core/Replicate.h
+../include/Eigen/src/Core/Replicate.h
+src/Core/Reverse.h
+../include/Eigen/src/Core/Reverse.h
+src/Core/ArrayWrapper.h
+../include/Eigen/src/Core/ArrayWrapper.h
+src/Core/StlIterators.h
+../include/Eigen/src/Core/StlIterators.h
+src/Core/products/GeneralMatrixMatrix_BLAS.h
+../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+src/Core/products/GeneralMatrixVector_BLAS.h
+../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+src/Core/products/SelfadjointMatrixVector_BLAS.h
+../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+src/Core/products/TriangularMatrixMatrix_BLAS.h
+../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+src/Core/products/TriangularMatrixVector_BLAS.h
+../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+src/Core/products/TriangularSolverMatrix_BLAS.h
+../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+src/Core/Assign_MKL.h
+../include/Eigen/src/Core/Assign_MKL.h
+src/Core/GlobalFunctions.h
+../include/Eigen/src/Core/GlobalFunctions.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/Dense
+Core
+../include/Eigen/Core
+LU
+../include/Eigen/LU
+Cholesky
+../include/Eigen/Cholesky
+QR
+../include/Eigen/QR
+SVD
+../include/Eigen/SVD
+Geometry
+../include/Eigen/Geometry
+Eigenvalues
+../include/Eigen/Eigenvalues
+
+../include/Eigen/Eigenvalues
+Core
+../include/Eigen/Core
+Cholesky
+../include/Eigen/Cholesky
+Jacobi
+../include/Eigen/Jacobi
+Householder
+../include/Eigen/Householder
+LU
+../include/Eigen/LU
+Geometry
+../include/Eigen/Geometry
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/misc/RealSvd2x2.h
+../include/Eigen/src/misc/RealSvd2x2.h
+src/Eigenvalues/Tridiagonalization.h
+../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+src/Eigenvalues/RealSchur.h
+../include/Eigen/src/Eigenvalues/RealSchur.h
+src/Eigenvalues/EigenSolver.h
+../include/Eigen/src/Eigenvalues/EigenSolver.h
+src/Eigenvalues/SelfAdjointEigenSolver.h
+../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+src/Eigenvalues/HessenbergDecomposition.h
+../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+src/Eigenvalues/ComplexSchur.h
+../include/Eigen/src/Eigenvalues/ComplexSchur.h
+src/Eigenvalues/ComplexEigenSolver.h
+../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+src/Eigenvalues/RealQZ.h
+../include/Eigen/src/Eigenvalues/RealQZ.h
+src/Eigenvalues/GeneralizedEigenSolver.h
+../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+src/Eigenvalues/MatrixBaseEigenvalues.h
+../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+mkl_lapacke.h
+../include/Eigen/mkl_lapacke.h
+src/misc/lapacke.h
+../include/Eigen/src/misc/lapacke.h
+src/Eigenvalues/RealSchur_LAPACKE.h
+../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+src/Eigenvalues/ComplexSchur_LAPACKE.h
+../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/Geometry
+Core
+../include/Eigen/Core
+SVD
+../include/Eigen/SVD
+LU
+../include/Eigen/LU
+limits
+-
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/Geometry/OrthoMethods.h
+../include/Eigen/src/Geometry/OrthoMethods.h
+src/Geometry/EulerAngles.h
+../include/Eigen/src/Geometry/EulerAngles.h
+src/Geometry/Homogeneous.h
+../include/Eigen/src/Geometry/Homogeneous.h
+src/Geometry/RotationBase.h
+../include/Eigen/src/Geometry/RotationBase.h
+src/Geometry/Rotation2D.h
+../include/Eigen/src/Geometry/Rotation2D.h
+src/Geometry/Quaternion.h
+../include/Eigen/src/Geometry/Quaternion.h
+src/Geometry/AngleAxis.h
+../include/Eigen/src/Geometry/AngleAxis.h
+src/Geometry/Transform.h
+../include/Eigen/src/Geometry/Transform.h
+src/Geometry/Translation.h
+../include/Eigen/src/Geometry/Translation.h
+src/Geometry/Scaling.h
+../include/Eigen/src/Geometry/Scaling.h
+src/Geometry/Hyperplane.h
+../include/Eigen/src/Geometry/Hyperplane.h
+src/Geometry/ParametrizedLine.h
+../include/Eigen/src/Geometry/ParametrizedLine.h
+src/Geometry/AlignedBox.h
+../include/Eigen/src/Geometry/AlignedBox.h
+src/Geometry/Umeyama.h
+../include/Eigen/src/Geometry/Umeyama.h
+src/Geometry/arch/Geometry_SIMD.h
+../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/Householder
+Core
+../include/Eigen/Core
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/Householder/Householder.h
+../include/Eigen/src/Householder/Householder.h
+src/Householder/HouseholderSequence.h
+../include/Eigen/src/Householder/HouseholderSequence.h
+src/Householder/BlockHouseholder.h
+../include/Eigen/src/Householder/BlockHouseholder.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/Jacobi
+Core
+../include/Eigen/Core
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/Jacobi/Jacobi.h
+../include/Eigen/src/Jacobi/Jacobi.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/LU
+Core
+../include/Eigen/Core
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/misc/Kernel.h
+../include/Eigen/src/misc/Kernel.h
+src/misc/Image.h
+../include/Eigen/src/misc/Image.h
+src/LU/FullPivLU.h
+../include/Eigen/src/LU/FullPivLU.h
+src/LU/PartialPivLU.h
+../include/Eigen/src/LU/PartialPivLU.h
+mkl_lapacke.h
+../include/Eigen/mkl_lapacke.h
+src/misc/lapacke.h
+../include/Eigen/src/misc/lapacke.h
+src/LU/PartialPivLU_LAPACKE.h
+../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+src/LU/Determinant.h
+../include/Eigen/src/LU/Determinant.h
+src/LU/InverseImpl.h
+../include/Eigen/src/LU/InverseImpl.h
+src/LU/arch/InverseSize4.h
+../include/Eigen/src/LU/arch/InverseSize4.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/QR
+Core
+../include/Eigen/Core
+Cholesky
+../include/Eigen/Cholesky
+Jacobi
+../include/Eigen/Jacobi
+Householder
+../include/Eigen/Householder
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/QR/HouseholderQR.h
+../include/Eigen/src/QR/HouseholderQR.h
+src/QR/FullPivHouseholderQR.h
+../include/Eigen/src/QR/FullPivHouseholderQR.h
+src/QR/ColPivHouseholderQR.h
+../include/Eigen/src/QR/ColPivHouseholderQR.h
+src/QR/CompleteOrthogonalDecomposition.h
+../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+mkl_lapacke.h
+../include/Eigen/mkl_lapacke.h
+src/misc/lapacke.h
+../include/Eigen/src/misc/lapacke.h
+src/QR/HouseholderQR_LAPACKE.h
+../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+src/QR/ColPivHouseholderQR_LAPACKE.h
+../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/SVD
+QR
+../include/Eigen/QR
+Householder
+../include/Eigen/Householder
+Jacobi
+../include/Eigen/Jacobi
+src/Core/util/DisableStupidWarnings.h
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+src/misc/RealSvd2x2.h
+../include/Eigen/src/misc/RealSvd2x2.h
+src/SVD/UpperBidiagonalization.h
+../include/Eigen/src/SVD/UpperBidiagonalization.h
+src/SVD/SVDBase.h
+../include/Eigen/src/SVD/SVDBase.h
+src/SVD/JacobiSVD.h
+../include/Eigen/src/SVD/JacobiSVD.h
+src/SVD/BDCSVD.h
+../include/Eigen/src/SVD/BDCSVD.h
+mkl_lapacke.h
+../include/Eigen/mkl_lapacke.h
+src/misc/lapacke.h
+../include/Eigen/src/misc/lapacke.h
+src/SVD/JacobiSVD_LAPACKE.h
+../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+src/Core/util/ReenableStupidWarnings.h
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/src/Cholesky/LDLT.h
+
+../include/Eigen/src/Cholesky/LLT.h
+
+../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+
+../include/Eigen/src/Core/ArithmeticSequence.h
+
+../include/Eigen/src/Core/Array.h
+
+../include/Eigen/src/Core/ArrayBase.h
+../plugins/MatrixCwiseUnaryOps.h
+../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+../plugins/ArrayCwiseUnaryOps.h
+../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+../plugins/CommonCwiseBinaryOps.h
+../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+../plugins/MatrixCwiseBinaryOps.h
+../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+../plugins/ArrayCwiseBinaryOps.h
+../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+
+../include/Eigen/src/Core/ArrayWrapper.h
+
+../include/Eigen/src/Core/Assign.h
+
+../include/Eigen/src/Core/AssignEvaluator.h
+
+../include/Eigen/src/Core/Assign_MKL.h
+
+../include/Eigen/src/Core/BandMatrix.h
+
+../include/Eigen/src/Core/Block.h
+
+../include/Eigen/src/Core/BooleanRedux.h
+
+../include/Eigen/src/Core/CommaInitializer.h
+
+../include/Eigen/src/Core/ConditionEstimator.h
+
+../include/Eigen/src/Core/CoreEvaluators.h
+
+../include/Eigen/src/Core/CoreIterators.h
+
+../include/Eigen/src/Core/CwiseBinaryOp.h
+
+../include/Eigen/src/Core/CwiseNullaryOp.h
+
+../include/Eigen/src/Core/CwiseTernaryOp.h
+
+../include/Eigen/src/Core/CwiseUnaryOp.h
+
+../include/Eigen/src/Core/CwiseUnaryView.h
+
+../include/Eigen/src/Core/DenseBase.h
+../plugins/CommonCwiseUnaryOps.h
+../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+../plugins/BlockMethods.h
+../include/Eigen/src/plugins/BlockMethods.h
+../plugins/IndexedViewMethods.h
+../include/Eigen/src/plugins/IndexedViewMethods.h
+../plugins/ReshapedMethods.h
+../include/Eigen/src/plugins/ReshapedMethods.h
+
+../include/Eigen/src/Core/DenseCoeffsBase.h
+
+../include/Eigen/src/Core/DenseStorage.h
+
+../include/Eigen/src/Core/Diagonal.h
+
+../include/Eigen/src/Core/DiagonalMatrix.h
+
+../include/Eigen/src/Core/DiagonalProduct.h
+
+../include/Eigen/src/Core/Dot.h
+
+../include/Eigen/src/Core/EigenBase.h
+
+../include/Eigen/src/Core/Fuzzy.h
+
+../include/Eigen/src/Core/GeneralProduct.h
+
+../include/Eigen/src/Core/GenericPacketMath.h
+
+../include/Eigen/src/Core/GlobalFunctions.h
+
+../include/Eigen/src/Core/IO.h
+
+../include/Eigen/src/Core/IndexedView.h
+
+../include/Eigen/src/Core/Inverse.h
+
+../include/Eigen/src/Core/Map.h
+
+../include/Eigen/src/Core/MapBase.h
+
+../include/Eigen/src/Core/MathFunctions.h
+
+../include/Eigen/src/Core/MathFunctionsImpl.h
+
+../include/Eigen/src/Core/Matrix.h
+
+../include/Eigen/src/Core/MatrixBase.h
+../plugins/CommonCwiseBinaryOps.h
+../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+../plugins/MatrixCwiseUnaryOps.h
+../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+../plugins/MatrixCwiseBinaryOps.h
+../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+
+../include/Eigen/src/Core/NestByValue.h
+
+../include/Eigen/src/Core/NoAlias.h
+
+../include/Eigen/src/Core/NumTraits.h
+
+../include/Eigen/src/Core/PartialReduxEvaluator.h
+
+../include/Eigen/src/Core/PermutationMatrix.h
+
+../include/Eigen/src/Core/PlainObjectBase.h
+
+../include/Eigen/src/Core/Product.h
+
+../include/Eigen/src/Core/ProductEvaluators.h
+
+../include/Eigen/src/Core/Random.h
+
+../include/Eigen/src/Core/Redux.h
+
+../include/Eigen/src/Core/Ref.h
+
+../include/Eigen/src/Core/Replicate.h
+
+../include/Eigen/src/Core/Reshaped.h
+
+../include/Eigen/src/Core/ReturnByValue.h
+
+../include/Eigen/src/Core/Reverse.h
+
+../include/Eigen/src/Core/Select.h
+
+../include/Eigen/src/Core/SelfAdjointView.h
+
+../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+
+../include/Eigen/src/Core/Solve.h
+
+../include/Eigen/src/Core/SolveTriangular.h
+
+../include/Eigen/src/Core/SolverBase.h
+
+../include/Eigen/src/Core/StableNorm.h
+
+../include/Eigen/src/Core/StlIterators.h
+
+../include/Eigen/src/Core/Stride.h
+
+../include/Eigen/src/Core/Swap.h
+
+../include/Eigen/src/Core/Transpose.h
+
+../include/Eigen/src/Core/Transpositions.h
+
+../include/Eigen/src/Core/TriangularMatrix.h
+
+../include/Eigen/src/Core/VectorBlock.h
+
+../include/Eigen/src/Core/VectorwiseOp.h
+
+../include/Eigen/src/Core/Visitor.h
+
+../include/Eigen/src/Core/arch/AVX/Complex.h
+
+../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+
+../include/Eigen/src/Core/arch/AVX/PacketMath.h
+
+../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+
+../include/Eigen/src/Core/arch/AVX512/Complex.h
+
+../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+
+../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+
+../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+
+../include/Eigen/src/Core/arch/AltiVec/Complex.h
+
+../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+
+../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+MatrixProductCommon.h
+../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+MatrixProductMMA.h
+../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+
+../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+
+../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+
+../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+
+../include/Eigen/src/Core/arch/CUDA/Complex.h
+
+../include/Eigen/src/Core/arch/Default/BFloat16.h
+
+../include/Eigen/src/Core/arch/Default/ConjHelper.h
+
+../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+
+../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+
+../include/Eigen/src/Core/arch/Default/Half.h
+sstream
+-
+
+../include/Eigen/src/Core/arch/Default/Settings.h
+
+../include/Eigen/src/Core/arch/Default/TypeCasting.h
+
+../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+
+../include/Eigen/src/Core/arch/GPU/PacketMath.h
+
+../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+
+../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+
+../include/Eigen/src/Core/arch/MSA/Complex.h
+iostream
+-
+
+../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+
+../include/Eigen/src/Core/arch/MSA/PacketMath.h
+iostream
+-
+string
+-
+
+../include/Eigen/src/Core/arch/NEON/Complex.h
+
+../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+
+../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+
+../include/Eigen/src/Core/arch/NEON/PacketMath.h
+
+../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+
+../include/Eigen/src/Core/arch/SSE/Complex.h
+
+../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+
+../include/Eigen/src/Core/arch/SSE/PacketMath.h
+
+../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+
+../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+
+../include/Eigen/src/Core/arch/SVE/PacketMath.h
+
+../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+
+../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+
+../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+
+../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+type_traits
+-
+
+../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CL/sycl.hpp
+-
+stdexcept
+-
+cstddef
+-
+queue
+-
+set
+-
+unordered_map
+-
+
+../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+
+../include/Eigen/src/Core/arch/ZVector/Complex.h
+
+../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+
+../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+
+../include/Eigen/src/Core/functors/AssignmentFunctors.h
+
+../include/Eigen/src/Core/functors/BinaryFunctors.h
+
+../include/Eigen/src/Core/functors/NullaryFunctors.h
+
+../include/Eigen/src/Core/functors/StlFunctors.h
+
+../include/Eigen/src/Core/functors/TernaryFunctors.h
+
+../include/Eigen/src/Core/functors/UnaryFunctors.h
+
+../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+
+../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+
+../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+
+../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+
+../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+
+../include/Eigen/src/Core/products/GeneralMatrixVector.h
+
+../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+
+../include/Eigen/src/Core/products/Parallelizer.h
+atomic
+-
+
+../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+
+../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+
+../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+
+../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+
+../include/Eigen/src/Core/products/SelfadjointProduct.h
+
+../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+
+../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+
+../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+
+../include/Eigen/src/Core/products/TriangularMatrixVector.h
+
+../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+
+../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+
+../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+
+../include/Eigen/src/Core/products/TriangularSolverVector.h
+
+../include/Eigen/src/Core/util/BlasUtil.h
+
+../include/Eigen/src/Core/util/ConfigureVectorization.h
+malloc.h
+-
+immintrin.h
+-
+mmintrin.h
+-
+emmintrin.h
+-
+xmmintrin.h
+-
+pmmintrin.h
+-
+tmmintrin.h
+-
+smmintrin.h
+-
+nmmintrin.h
+-
+immintrin.h
+-
+altivec.h
+-
+altivec.h
+-
+arm_neon.h
+-
+arm_sve.h
+-
+vecintrin.h
+-
+msa.h
+-
+arm_fp16.h
+-
+immintrin.h
+-
+vector_types.h
+-
+cuda_runtime_api.h
+-
+cuda_fp16.h
+-
+hip/hip_vector_types.h
+-
+hip/hip_fp16.h
+-
+
+../include/Eigen/src/Core/util/Constants.h
+
+../include/Eigen/src/Core/util/DisableStupidWarnings.h
+
+../include/Eigen/src/Core/util/ForwardDeclarations.h
+
+../include/Eigen/src/Core/util/IndexedViewHelper.h
+
+../include/Eigen/src/Core/util/IntegralConstant.h
+
+../include/Eigen/src/Core/util/MKL_support.h
+mkl.h
+-
+../../misc/blas.h
+../include/Eigen/src/misc/blas.h
+
+../include/Eigen/src/Core/util/Macros.h
+cuda.h
+-
+hip/hip_runtime.h
+-
+cmath
+-
+cstdlib
+-
+iostream
+-
+
+../include/Eigen/src/Core/util/Memory.h
+
+../include/Eigen/src/Core/util/Meta.h
+cfloat
+-
+math_constants.h
+-
+Eigen/src/Core/arch/HIP/hcc/math_constants.h
+../include/Eigen/src/Core/util/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+cstdint
+-
+stdint.h
+-
+
+../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+
+../include/Eigen/src/Core/util/ReshapedHelper.h
+
+../include/Eigen/src/Core/util/StaticAssert.h
+
+../include/Eigen/src/Core/util/SymbolicIndex.h
+
+../include/Eigen/src/Core/util/XprHelper.h
+
+../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+./ComplexSchur.h
+../include/Eigen/src/Eigenvalues/ComplexSchur.h
+
+../include/Eigen/src/Eigenvalues/ComplexSchur.h
+./HessenbergDecomposition.h
+../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+
+../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+
+../include/Eigen/src/Eigenvalues/EigenSolver.h
+./RealSchur.h
+../include/Eigen/src/Eigenvalues/RealSchur.h
+
+../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+./RealQZ.h
+../include/Eigen/src/Eigenvalues/RealQZ.h
+
+../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+./Tridiagonalization.h
+../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+
+../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+
+../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+
+../include/Eigen/src/Eigenvalues/RealQZ.h
+
+../include/Eigen/src/Eigenvalues/RealSchur.h
+./HessenbergDecomposition.h
+../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+
+../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+
+../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+./Tridiagonalization.h
+../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+
+../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+
+../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+
+../include/Eigen/src/Geometry/AlignedBox.h
+
+../include/Eigen/src/Geometry/AngleAxis.h
+
+../include/Eigen/src/Geometry/EulerAngles.h
+
+../include/Eigen/src/Geometry/Homogeneous.h
+
+../include/Eigen/src/Geometry/Hyperplane.h
+
+../include/Eigen/src/Geometry/OrthoMethods.h
+
+../include/Eigen/src/Geometry/ParametrizedLine.h
+
+../include/Eigen/src/Geometry/Quaternion.h
+
+../include/Eigen/src/Geometry/Rotation2D.h
+
+../include/Eigen/src/Geometry/RotationBase.h
+
+../include/Eigen/src/Geometry/Scaling.h
+
+../include/Eigen/src/Geometry/Transform.h
+
+../include/Eigen/src/Geometry/Translation.h
+
+../include/Eigen/src/Geometry/Umeyama.h
+
+../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+
+../include/Eigen/src/Householder/BlockHouseholder.h
+
+../include/Eigen/src/Householder/Householder.h
+
+../include/Eigen/src/Householder/HouseholderSequence.h
+
+../include/Eigen/src/Jacobi/Jacobi.h
+
+../include/Eigen/src/LU/Determinant.h
+
+../include/Eigen/src/LU/FullPivLU.h
+
+../include/Eigen/src/LU/InverseImpl.h
+
+../include/Eigen/src/LU/PartialPivLU.h
+
+../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+
+../include/Eigen/src/LU/arch/InverseSize4.h
+
+../include/Eigen/src/QR/ColPivHouseholderQR.h
+
+../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+
+../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+
+../include/Eigen/src/QR/FullPivHouseholderQR.h
+
+../include/Eigen/src/QR/HouseholderQR.h
+
+../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+
+../include/Eigen/src/SVD/BDCSVD.h
+
+../include/Eigen/src/SVD/JacobiSVD.h
+
+../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+
+../include/Eigen/src/SVD/SVDBase.h
+
+../include/Eigen/src/SVD/UpperBidiagonalization.h
+
+../include/Eigen/src/misc/Image.h
+
+../include/Eigen/src/misc/Kernel.h
+
+../include/Eigen/src/misc/RealSvd2x2.h
+
+../include/Eigen/src/misc/blas.h
+
+../include/Eigen/src/misc/lapacke.h
+lapacke_config.h
+../include/Eigen/src/misc/lapacke_config.h
+stdlib.h
+-
+complex.h
+-
+complex.h
+-
+lapacke_mangling.h
+../include/Eigen/src/misc/lapacke_mangling.h
+
+../include/Eigen/src/misc/lapacke_mangling.h
+
+../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+
+../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+
+../include/Eigen/src/plugins/BlockMethods.h
+
+../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+
+../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+
+../include/Eigen/src/plugins/IndexedViewMethods.h
+IndexedViewMethods.h
+../include/Eigen/src/plugins/IndexedViewMethods.h
+
+../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+
+../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+
+../include/Eigen/src/plugins/ReshapedMethods.h
+ReshapedMethods.h
+../include/Eigen/src/plugins/ReshapedMethods.h
+
+../include/STrack.h
+opencv2/opencv.hpp
+-
+kalmanFilter.h
+../include/kalmanFilter.h
+
+../include/dataType.h
+cstddef
+-
+vector
+-
+Eigen/Core
+-
+Eigen/Dense
+-
+
+../include/kalmanFilter.h
+dataType.h
+../include/dataType.h
+
+../include/lapjv.h
+assert.h
+-
+
+/home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp
+BYTETracker.h
+/home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.h
+fstream
+-
+iostream
+-
+
+/home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp
+STrack.h
+/home/huey/Desktop/C/yolo_bytetrack/src/STrack.h
+dataType.h
+/home/huey/Desktop/C/yolo_bytetrack/src/dataType.h
+iostream
+-
+
+/home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp
+fstream
+-
+iostream
+-
+sstream
+-
+numeric
+-
+chrono
+-
+vector
+-
+openssl/sha.h
+-
+openssl/evp.h
+-
+ctime
+-
+cstring
+-
+unistd.h
+-
+atomic
+-
+thread
+-
+chrono
+-
+string
+-
+dirent.h
+-
+sys/time.h
+-
+BYTETracker.h
+/home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.h
+rknn_api.h
+/home/huey/Desktop/C/yolo_bytetrack/src/rknn_api.h
+opencv2/core/core.hpp
+/home/huey/Desktop/C/yolo_bytetrack/src/opencv2/core/core.hpp
+opencv2/imgproc/imgproc.hpp
+/home/huey/Desktop/C/yolo_bytetrack/src/opencv2/imgproc/imgproc.hpp
+opencv2/highgui/highgui.hpp
+/home/huey/Desktop/C/yolo_bytetrack/src/opencv2/highgui/highgui.hpp
+opencv2/videoio.hpp
+/home/huey/Desktop/C/yolo_bytetrack/src/opencv2/videoio.hpp
+opencv2/video.hpp
+/home/huey/Desktop/C/yolo_bytetrack/src/opencv2/video.hpp
+unordered_set
+-
+
+/home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp
+kalmanFilter.h
+/home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.h
+Eigen/Cholesky
+-
+iostream
+-
+
+/home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp
+stdio.h
+-
+stdlib.h
+-
+string.h
+-
+lapjv.h
+/home/huey/Desktop/C/yolo_bytetrack/src/lapjv.h
+
+/home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp
+BYTETracker.h
+/home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.h
+lapjv.h
+/home/huey/Desktop/C/yolo_bytetrack/src/lapjv.h
+map
+-
+iostream
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/core/types.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/types.hpp
+opencv2/features2d.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/features2d.hpp
+opencv2/core/affine.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/affine.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/cvdef.h
+opencv2/core/base.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/base.hpp
+opencv2/core/cvstd.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/cvstd.hpp
+opencv2/core/traits.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/traits.hpp
+opencv2/core/matx.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/matx.hpp
+opencv2/core/types.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/types.hpp
+opencv2/core/mat.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/mat.hpp
+opencv2/core/persistence.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/persistence.hpp
+opencv2/core/operations.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/operations.hpp
+opencv2/core/cvstd.inl.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/cvstd.inl.hpp
+opencv2/core/utility.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/utility.hpp
+opencv2/core/optim.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/optim.hpp
+opencv2/core/ovx.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core/ovx.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+opencv2/core.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+opencv2/core/mat.hpp
+-
+chrono
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/opencv_modules.hpp
+climits
+-
+algorithm
+-
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+opencv2/core/cvstd.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvstd.hpp
+opencv2/core/neon_utils.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/neon_utils.hpp
+opencv2/core/vsx_utils.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/vsx_utils.hpp
+opencv2/core/check.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/check.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+opencv2/core/base.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/core.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core.hpp
+opencv2/core/cuda_types.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cuda_types.hpp
+opencv2/opencv.hpp
+-
+opencv2/core/cuda.inl.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cuda.inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+opencv2/core/cuda.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cuda.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+cv_cpu_config.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_config.h
+cv_cpu_helper.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+emmintrin.h
+-
+pmmintrin.h
+-
+tmmintrin.h
+-
+smmintrin.h
+-
+nmmintrin.h
+-
+nmmintrin.h
+-
+popcntintrin.h
+-
+immintrin.h
+-
+arm_neon.h
+-
+immintrin.h
+-
+arm_neon.h
+-
+immintrin.h
+-
+immintrin.h
+-
+Intrin.h
+-
+arm_neon.h
+-
+arm_neon.h
+-
+riscv-vector.h
+-
+arm_neon.h
+-
+altivec.h
+-
+hal/msa_macros.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+lasxintrin.h
+-
+wasm_simd128.h
+-
+riscv_vector.h
+-
+emmintrin.h
+-
+Intrin.h
+-
+arm_neon.h
+-
+arm_neon.h
+-
+altivec.h
+-
+immintrin.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+opencv2/core/version.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/version.hpp
+cvconfig.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvconfig.h
+limits
+-
+limits.h
+-
+opencv2/core/hal/interface.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/hal/interface.h
+cv_cpu_dispatch.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+intrin.h
+-
+array
+-
+cstdint
+-
+stdint.h
+-
+stdint.h
+-
+opencv2/core/fast_math.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/fast_math.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+cstddef
+-
+cstring
+-
+cctype
+-
+string
+-
+algorithm
+-
+utility
+-
+cstdlib
+-
+cmath
+-
+cvstd_wrapper.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+complex
+-
+ostream
+-
+sstream
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+string
+-
+memory
+-
+type_traits
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+cmath
+-
+fastmath.h
+-
+math.h
+-
+emmintrin.h
+-
+altivec.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+cstddef
+-
+stddef.h
+-
+stdbool.h
+-
+cstdint
+-
+stdint.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+msa.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa.h
+stdint.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+opencv2/core/matx.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/matx.hpp
+opencv2/core/types.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/types.hpp
+opencv2/core/bufferpool.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/bufferpool.hpp
+type_traits
+-
+opencv2/core/mat.inl.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/mat.inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+opencv2/core/base.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/base.hpp
+opencv2/core/traits.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/traits.hpp
+opencv2/core/saturate.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/saturate.hpp
+initializer_list
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+cstdio
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+opencv2/core/types.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/types.hpp
+opencv2/core/mat.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/mat.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core.hpp
+time.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+climits
+-
+opencv2/core/fast_math.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/fast_math.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+climits
+-
+cfloat
+-
+vector
+-
+limits
+-
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+opencv2/core/cvstd.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvstd.hpp
+opencv2/core/matx.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/matx.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core.hpp
+ostream
+-
+functional
+-
+mutex
+-
+opencv2/core/utils/instrumentation.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/utils/instrumentation.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+opencv2/core/utility.hpp
+-
+opencv2/core/utils/tls.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+opencv2/core/cvdef.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/opencv2/core/cvdef.h
+assert.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+opencv2/dnn/dnn.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+opencv2/core.hpp
+-
+map
+-
+ostream
+-
+opencv2/dnn/dnn.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+vector
+-
+opencv2/core.hpp
+-
+opencv2/core/async.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/opencv2/core/async.hpp
+../dnn/version.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+opencv2/dnn/dict.hpp
+-
+opencv2/dnn/layer.hpp
+-
+opencv2/dnn/dnn.inl.hpp
+-
+opencv2/dnn/utils/inference_engine.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+opencv2/dnn.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+opencv2/dnn.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+../dnn.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/opencv_modules.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/flann/miniflann.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/flann/miniflann.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/flann/miniflann.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/flann/miniflann.hpp
+opencv2/flann/flann_base.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/flann/flann_base.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+kdtree_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+kdtree_single_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+kmeans_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+composite_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+linear_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+hierarchical_clustering_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+lsh_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+autotuned_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+stdlib.h
+-
+stdio.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+defines.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+stdexcept
+-
+ostream
+-
+typeinfo
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+sstream
+-
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+ground_truth.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+index_testing.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+sampling.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+kdtree_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+kdtree_single_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+kmeans_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+composite_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+linear_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+logger.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+kdtree_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+kmeans_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+config.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+cmath
+-
+cstdlib
+-
+string.h
+-
+stdint.h
+-
+defines.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+Intrin.h
+-
+arm_neon.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/arm_neon.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+boost/dynamic_bitset.hpp
+-
+limits.h
+-
+dist.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+vector
+-
+cstdio
+-
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+params.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+all_indices.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+dist.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+algorithm
+-
+vector
+-
+unordered_map
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+algorithm
+-
+map
+-
+limits
+-
+cmath
+-
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+dist.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+heap.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+allocator.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+cstring
+-
+cmath
+-
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+logger.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+timer.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+algorithm
+-
+map
+-
+cstring
+-
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+dynamic_bitset.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+heap.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+allocator.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+algorithm
+-
+map
+-
+cstring
+-
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+heap.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+allocator.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+algorithm
+-
+map
+-
+limits
+-
+cmath
+-
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+dist.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+heap.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+allocator.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+logger.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+stdio.h
+-
+stdarg.h
+-
+defines.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+algorithm
+-
+cstring
+-
+map
+-
+vector
+-
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+heap.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+lsh_table.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+allocator.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+saving.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+algorithm
+-
+iostream
+-
+iomanip
+-
+limits.h
+-
+unordered_map
+-
+map
+-
+math.h
+-
+stddef.h
+-
+dynamic_bitset.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+stdio.h
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/opencv2/core.hpp
+opencv2/flann/defines.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/opencv2/flann/defines.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+result_set.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+params.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+any.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+iostream
+-
+map
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+algorithm
+-
+cstdlib
+-
+vector
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+algorithm
+-
+cstring
+-
+iostream
+-
+limits
+-
+set
+-
+vector
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+matrix.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+random.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+cstring
+-
+vector
+-
+general.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+nn_index.h
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+time.h
+-
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/opencv2/core.hpp
+opencv2/core/utility.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/opencv2/core/utility.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/imgcodecs.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/imgcodecs.hpp
+opencv2/videoio.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/videoio.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui/highgui.hpp
+opencv2/highgui.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui/opencv2/highgui.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+./imgproc/segmentation.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/imgproc.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/opencv2/imgproc.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/opencv2/imgproc.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+float.h
+-
+map
+-
+iostream
+-
+opencv2/ml/ml.inl.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/objdetect/detection_based_tracker.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/objdetect/detection_based_tracker.hpp
+opencv2/objdetect/face.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/objdetect/face.hpp
+opencv2/objdetect/aruco_detector.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/objdetect/aruco_detector.hpp
+opencv2/objdetect/charuco_detector.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/objdetect/charuco_detector.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+opencv2/core.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+opencv2/objdetect/aruco_dictionary.hpp
+-
+opencv2/objdetect/aruco_board.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+opencv2/core.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+opencv2/objdetect/aruco_detector.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/opencv2/objdetect/aruco_detector.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+opencv2/core.hpp
+-
+vector
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+opencv2/core.hpp
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/opencv_modules.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/calib3d.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/calib3d.hpp
+opencv2/features2d.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/features2d.hpp
+opencv2/dnn.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/dnn.hpp
+opencv2/flann.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/flann.hpp
+opencv2/highgui.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/highgui.hpp
+opencv2/imgcodecs.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/imgcodecs.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/imgproc.hpp
+opencv2/ml.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/ml.hpp
+opencv2/objdetect.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/objdetect.hpp
+opencv2/photo.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/photo.hpp
+opencv2/stitching.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching.hpp
+opencv2/video.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/video.hpp
+opencv2/videoio.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/videoio.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/imgproc.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+opencv2/features2d.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/features2d.hpp
+opencv2/stitching/warpers.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/warpers.hpp
+opencv2/stitching/detail/matchers.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/matchers.hpp
+opencv2/stitching/detail/motion_estimators.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/motion_estimators.hpp
+opencv2/stitching/detail/exposure_compensate.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/exposure_compensate.hpp
+opencv2/stitching/detail/seam_finders.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/seam_finders.hpp
+opencv2/stitching/detail/blenders.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/blenders.hpp
+opencv2/stitching/detail/camera.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/stitching/detail/camera.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+opencv2/core/cuda.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core/cuda.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+opencv2/features2d.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/features2d.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/opencv_modules.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+matchers.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+util.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+camera.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+set
+-
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/opencv_modules.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+list
+-
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+util_inl.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+queue
+-
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+util.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+opencv2/core/cuda.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core/cuda.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/imgproc.hpp
+opencv2/opencv_modules.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/opencv_modules.hpp
+warpers_inl.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/opencv2/core.hpp
+warpers.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+limits
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+opencv2/stitching/detail/warpers.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/opencv2/stitching/detail/warpers.hpp
+string
+-
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+opencv2/video/tracking.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/video/tracking.hpp
+opencv2/video/background_segm.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/video/background_segm.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/opencv2/core.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/opencv2/core.hpp
+opencv2/imgproc.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/opencv2/imgproc.hpp
+
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+opencv2/core.hpp
+/home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv2/core.hpp
+
+/home/huey/openssl/install/include/openssl/asn1.h
+openssl/macros.h
+-
+stdio.h
+-
+time.h
+-
+openssl/e_os2.h
+-
+openssl/opensslconf.h
+-
+openssl/bio.h
+-
+openssl/safestack.h
+-
+openssl/asn1err.h
+-
+openssl/symhacks.h
+-
+openssl/types.h
+-
+openssl/bn.h
+-
+
+/home/huey/openssl/install/include/openssl/asn1err.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/bio.h
+openssl/macros.h
+-
+openssl/e_os2.h
+-
+stdio.h
+-
+stdarg.h
+-
+openssl/crypto.h
+-
+openssl/bioerr.h
+-
+openssl/core.h
+-
+
+/home/huey/openssl/install/include/openssl/bioerr.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/bn.h
+openssl/macros.h
+-
+openssl/e_os2.h
+-
+stdio.h
+-
+openssl/opensslconf.h
+-
+openssl/types.h
+-
+openssl/crypto.h
+-
+openssl/bnerr.h
+-
+
+/home/huey/openssl/install/include/openssl/bnerr.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/configuration.h
+
+/home/huey/openssl/install/include/openssl/core.h
+stddef.h
+-
+openssl/types.h
+-
+
+/home/huey/openssl/install/include/openssl/core_dispatch.h
+stdarg.h
+-
+openssl/core.h
+-
+
+/home/huey/openssl/install/include/openssl/crypto.h
+openssl/macros.h
+-
+stdlib.h
+-
+time.h
+-
+openssl/e_os2.h
+-
+stdio.h
+-
+openssl/safestack.h
+-
+openssl/opensslv.h
+-
+openssl/types.h
+-
+openssl/opensslconf.h
+-
+openssl/cryptoerr.h
+-
+openssl/core.h
+-
+openssl/ebcdic.h
+-
+openssl/symhacks.h
+-
+openssl/opensslv.h
+-
+spthread.h
+-
+pthread.h
+-
+
+/home/huey/openssl/install/include/openssl/cryptoerr.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/cryptoerr_legacy.h
+openssl/macros.h
+-
+openssl/symhacks.h
+-
+
+/home/huey/openssl/install/include/openssl/e_os2.h
+openssl/macros.h
+-
+openssl/opensslconf.h
+-
+strings.h
+-
+spthread.h
+-
+pthread.h
+-
+sys/types.h
+-
+inttypes.h
+-
+stdint.h
+-
+sys/types.h
+-
+stdint.h
+-
+
+/home/huey/openssl/install/include/openssl/ebcdic.h
+openssl/macros.h
+-
+stdlib.h
+-
+
+/home/huey/openssl/install/include/openssl/evp.h
+openssl/macros.h
+-
+stdarg.h
+-
+stdio.h
+-
+openssl/opensslconf.h
+-
+openssl/types.h
+-
+openssl/core.h
+-
+openssl/core_dispatch.h
+-
+openssl/symhacks.h
+-
+openssl/bio.h
+-
+openssl/evperr.h
+-
+openssl/params.h
+-
+openssl/objects.h
+-
+
+/home/huey/openssl/install/include/openssl/evperr.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/macros.h
+openssl/opensslconf.h
+-
+openssl/opensslv.h
+-
+
+/home/huey/openssl/install/include/openssl/obj_mac.h
+
+/home/huey/openssl/install/include/openssl/objects.h
+openssl/macros.h
+-
+openssl/obj_mac.h
+-
+openssl/bio.h
+-
+openssl/asn1.h
+-
+openssl/objectserr.h
+-
+
+/home/huey/openssl/install/include/openssl/objectserr.h
+openssl/opensslconf.h
+-
+openssl/symhacks.h
+-
+openssl/cryptoerr_legacy.h
+-
+
+/home/huey/openssl/install/include/openssl/opensslconf.h
+openssl/configuration.h
+-
+openssl/macros.h
+-
+
+/home/huey/openssl/install/include/openssl/opensslv.h
+openssl/macros.h
+-
+
+/home/huey/openssl/install/include/openssl/params.h
+openssl/core.h
+-
+openssl/bn.h
+-
+
+/home/huey/openssl/install/include/openssl/safestack.h
+openssl/macros.h
+-
+openssl/stack.h
+-
+openssl/e_os2.h
+-
+
+/home/huey/openssl/install/include/openssl/sha.h
+openssl/macros.h
+-
+openssl/e_os2.h
+-
+stddef.h
+-
+
+/home/huey/openssl/install/include/openssl/stack.h
+openssl/macros.h
+-
+
+/home/huey/openssl/install/include/openssl/symhacks.h
+openssl/macros.h
+-
+openssl/e_os2.h
+-
+
+/home/huey/openssl/install/include/openssl/types.h
+limits.h
+-
+openssl/e_os2.h
+-
+openssl/safestack.h
+-
+openssl/macros.h
+-
+
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/DependInfo.cmake b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/DependInfo.cmake
new file mode 100644
index 00000000..31a208a0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/DependInfo.cmake
@@ -0,0 +1,30 @@
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  "CXX"
+  )
+# The set of files for implicit dependencies of each language:
+set(CMAKE_DEPENDS_CHECK_CXX
+  "/home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o"
+  "/home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o"
+  "/home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o"
+  "/home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o"
+  "/home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o"
+  "/home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp" "/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o"
+  )
+set(CMAKE_CXX_COMPILER_ID "GNU")
+
+# The include file search paths:
+set(CMAKE_CXX_TARGET_INCLUDE_PATH
+  "/home/huey/openssl/install/include"
+  "../include"
+  "../3rdparty/librknn_api/include"
+  "../3rdparty/rga/include"
+  "/home/huey/opencv-4.7.0/install/include/opencv4"
+  )
+
+# Targets to which this target links.
+set(CMAKE_TARGET_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/build.make b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/build.make
new file mode 100644
index 00000000..18175065
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/build.make
@@ -0,0 +1,229 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+
+# Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+
+# A target that is always out of date.
+cmake_force:
+
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E remove -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/huey/Desktop/C/yolo_bytetrack
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/huey/Desktop/C/yolo_bytetrack/build
+
+# Include any dependencies generated for this target.
+include CMakeFiles/yolo_bytetrack.dir/depend.make
+
+# Include the progress variables for this target.
+include CMakeFiles/yolo_bytetrack.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include CMakeFiles/yolo_bytetrack.dir/flags.make
+
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../src/bytetrack.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp > CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp -o CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.s
+
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../src/BYTETracker.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp > CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp -o CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.s
+
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../src/kalmanFilter.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp > CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp -o CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.s
+
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o: ../src/lapjv.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp > CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp -o CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.s
+
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../src/STrack.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp > CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp -o CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.s
+
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: CMakeFiles/yolo_bytetrack.dir/flags.make
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../src/utils.cpp
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Building CXX object CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o -c /home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.i"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp > CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.i
+
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.s"
+	/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp -o CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.s
+
+# Object files for target yolo_bytetrack
+yolo_bytetrack_OBJECTS = \
+"CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o" \
+"CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o" \
+"CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o" \
+"CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o" \
+"CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o" \
+"CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o"
+
+# External object files for target yolo_bytetrack
+yolo_bytetrack_EXTERNAL_OBJECTS =
+
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/build.make
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_gapi.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_stitching.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_aruco.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_barcode.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_bgsegm.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_bioinspired.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_ccalib.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_dnn_objdetect.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_dnn_superres.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_dpm.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_face.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_fuzzy.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_hfs.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_img_hash.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_intensity_transform.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_line_descriptor.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_mcc.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_quality.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_rapid.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_reg.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_rgbd.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_saliency.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_stereo.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_structured_light.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_superres.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_surface_matching.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_tracking.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_videostab.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_wechat_qrcode.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_xfeatures2d.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_xobjdetect.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_xphoto.so.4.7.0
+yolo_bytetrack: /home/huey/openssl/install/lib/libssl.so
+yolo_bytetrack: /home/huey/openssl/install/lib/libcrypto.so
+yolo_bytetrack: ../3rdparty/librknn_api/armhf/librknn_api.so
+yolo_bytetrack: ../3rdparty/rga/lib/librga.so
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_shape.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_highgui.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_datasets.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_plot.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_text.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_ml.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_phase_unwrapping.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_optflow.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_ximgproc.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_video.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_videoio.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_imgcodecs.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_objdetect.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_calib3d.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_dnn.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_features2d.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_flann.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_photo.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_imgproc.so.4.7.0
+yolo_bytetrack: /home/huey/opencv-4.7.0/install/lib/libopencv_core.so.4.7.0
+yolo_bytetrack: CMakeFiles/yolo_bytetrack.dir/link.txt
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "Linking CXX executable yolo_bytetrack"
+	$(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/yolo_bytetrack.dir/link.txt --verbose=$(VERBOSE)
+
+# Rule to build all files generated by this target.
+CMakeFiles/yolo_bytetrack.dir/build: yolo_bytetrack
+
+.PHONY : CMakeFiles/yolo_bytetrack.dir/build
+
+CMakeFiles/yolo_bytetrack.dir/clean:
+	$(CMAKE_COMMAND) -P CMakeFiles/yolo_bytetrack.dir/cmake_clean.cmake
+.PHONY : CMakeFiles/yolo_bytetrack.dir/clean
+
+CMakeFiles/yolo_bytetrack.dir/depend:
+	cd /home/huey/Desktop/C/yolo_bytetrack/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/huey/Desktop/C/yolo_bytetrack /home/huey/Desktop/C/yolo_bytetrack /home/huey/Desktop/C/yolo_bytetrack/build /home/huey/Desktop/C/yolo_bytetrack/build /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/yolo_bytetrack.dir/DependInfo.cmake --color=$(COLOR)
+.PHONY : CMakeFiles/yolo_bytetrack.dir/depend
+
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/cmake_clean.cmake b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/cmake_clean.cmake
new file mode 100644
index 00000000..25b21c2e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/cmake_clean.cmake
@@ -0,0 +1,15 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o"
+  "CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o"
+  "CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o"
+  "CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o"
+  "CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o"
+  "CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o"
+  "yolo_bytetrack"
+  "yolo_bytetrack.pdb"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang CXX)
+  include(CMakeFiles/yolo_bytetrack.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/depend.internal b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/depend.internal
new file mode 100644
index 00000000..b85b107d
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/depend.internal
@@ -0,0 +1,1699 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o
+ ../include/BYTETracker.h
+ ../include/Eigen/Cholesky
+ ../include/Eigen/Core
+ ../include/Eigen/Dense
+ ../include/Eigen/Eigenvalues
+ ../include/Eigen/Geometry
+ ../include/Eigen/Householder
+ ../include/Eigen/Jacobi
+ ../include/Eigen/LU
+ ../include/Eigen/QR
+ ../include/Eigen/SVD
+ ../include/Eigen/src/Cholesky/LDLT.h
+ ../include/Eigen/src/Cholesky/LLT.h
+ ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+ ../include/Eigen/src/Core/ArithmeticSequence.h
+ ../include/Eigen/src/Core/Array.h
+ ../include/Eigen/src/Core/ArrayBase.h
+ ../include/Eigen/src/Core/ArrayWrapper.h
+ ../include/Eigen/src/Core/Assign.h
+ ../include/Eigen/src/Core/AssignEvaluator.h
+ ../include/Eigen/src/Core/Assign_MKL.h
+ ../include/Eigen/src/Core/BandMatrix.h
+ ../include/Eigen/src/Core/Block.h
+ ../include/Eigen/src/Core/BooleanRedux.h
+ ../include/Eigen/src/Core/CommaInitializer.h
+ ../include/Eigen/src/Core/ConditionEstimator.h
+ ../include/Eigen/src/Core/CoreEvaluators.h
+ ../include/Eigen/src/Core/CoreIterators.h
+ ../include/Eigen/src/Core/CwiseBinaryOp.h
+ ../include/Eigen/src/Core/CwiseNullaryOp.h
+ ../include/Eigen/src/Core/CwiseTernaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryView.h
+ ../include/Eigen/src/Core/DenseBase.h
+ ../include/Eigen/src/Core/DenseCoeffsBase.h
+ ../include/Eigen/src/Core/DenseStorage.h
+ ../include/Eigen/src/Core/Diagonal.h
+ ../include/Eigen/src/Core/DiagonalMatrix.h
+ ../include/Eigen/src/Core/DiagonalProduct.h
+ ../include/Eigen/src/Core/Dot.h
+ ../include/Eigen/src/Core/EigenBase.h
+ ../include/Eigen/src/Core/Fuzzy.h
+ ../include/Eigen/src/Core/GeneralProduct.h
+ ../include/Eigen/src/Core/GenericPacketMath.h
+ ../include/Eigen/src/Core/GlobalFunctions.h
+ ../include/Eigen/src/Core/IO.h
+ ../include/Eigen/src/Core/IndexedView.h
+ ../include/Eigen/src/Core/Inverse.h
+ ../include/Eigen/src/Core/Map.h
+ ../include/Eigen/src/Core/MapBase.h
+ ../include/Eigen/src/Core/MathFunctions.h
+ ../include/Eigen/src/Core/MathFunctionsImpl.h
+ ../include/Eigen/src/Core/Matrix.h
+ ../include/Eigen/src/Core/MatrixBase.h
+ ../include/Eigen/src/Core/NestByValue.h
+ ../include/Eigen/src/Core/NoAlias.h
+ ../include/Eigen/src/Core/NumTraits.h
+ ../include/Eigen/src/Core/PartialReduxEvaluator.h
+ ../include/Eigen/src/Core/PermutationMatrix.h
+ ../include/Eigen/src/Core/PlainObjectBase.h
+ ../include/Eigen/src/Core/Product.h
+ ../include/Eigen/src/Core/ProductEvaluators.h
+ ../include/Eigen/src/Core/Random.h
+ ../include/Eigen/src/Core/Redux.h
+ ../include/Eigen/src/Core/Ref.h
+ ../include/Eigen/src/Core/Replicate.h
+ ../include/Eigen/src/Core/Reshaped.h
+ ../include/Eigen/src/Core/ReturnByValue.h
+ ../include/Eigen/src/Core/Reverse.h
+ ../include/Eigen/src/Core/Select.h
+ ../include/Eigen/src/Core/SelfAdjointView.h
+ ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+ ../include/Eigen/src/Core/Solve.h
+ ../include/Eigen/src/Core/SolveTriangular.h
+ ../include/Eigen/src/Core/SolverBase.h
+ ../include/Eigen/src/Core/StableNorm.h
+ ../include/Eigen/src/Core/StlIterators.h
+ ../include/Eigen/src/Core/Stride.h
+ ../include/Eigen/src/Core/Swap.h
+ ../include/Eigen/src/Core/Transpose.h
+ ../include/Eigen/src/Core/Transpositions.h
+ ../include/Eigen/src/Core/TriangularMatrix.h
+ ../include/Eigen/src/Core/VectorBlock.h
+ ../include/Eigen/src/Core/VectorwiseOp.h
+ ../include/Eigen/src/Core/Visitor.h
+ ../include/Eigen/src/Core/arch/AVX/Complex.h
+ ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AVX512/Complex.h
+ ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+ ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+ ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+ ../include/Eigen/src/Core/arch/CUDA/Complex.h
+ ../include/Eigen/src/Core/arch/Default/BFloat16.h
+ ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+ ../include/Eigen/src/Core/arch/Default/Half.h
+ ../include/Eigen/src/Core/arch/Default/Settings.h
+ ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+ ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+ ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+ ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+ ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+ ../include/Eigen/src/Core/arch/MSA/Complex.h
+ ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+ ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/Complex.h
+ ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+ ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SSE/Complex.h
+ ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+ ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+ ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+ ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+ ../include/Eigen/src/Core/arch/ZVector/Complex.h
+ ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+ ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+ ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+ ../include/Eigen/src/Core/functors/BinaryFunctors.h
+ ../include/Eigen/src/Core/functors/NullaryFunctors.h
+ ../include/Eigen/src/Core/functors/StlFunctors.h
+ ../include/Eigen/src/Core/functors/TernaryFunctors.h
+ ../include/Eigen/src/Core/functors/UnaryFunctors.h
+ ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/Parallelizer.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointProduct.h
+ ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverVector.h
+ ../include/Eigen/src/Core/util/BlasUtil.h
+ ../include/Eigen/src/Core/util/ConfigureVectorization.h
+ ../include/Eigen/src/Core/util/Constants.h
+ ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ForwardDeclarations.h
+ ../include/Eigen/src/Core/util/IndexedViewHelper.h
+ ../include/Eigen/src/Core/util/IntegralConstant.h
+ ../include/Eigen/src/Core/util/MKL_support.h
+ ../include/Eigen/src/Core/util/Macros.h
+ ../include/Eigen/src/Core/util/Memory.h
+ ../include/Eigen/src/Core/util/Meta.h
+ ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ReshapedHelper.h
+ ../include/Eigen/src/Core/util/StaticAssert.h
+ ../include/Eigen/src/Core/util/SymbolicIndex.h
+ ../include/Eigen/src/Core/util/XprHelper.h
+ ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/EigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+ ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+ ../include/Eigen/src/Eigenvalues/RealQZ.h
+ ../include/Eigen/src/Eigenvalues/RealSchur.h
+ ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+ ../include/Eigen/src/Geometry/AlignedBox.h
+ ../include/Eigen/src/Geometry/AngleAxis.h
+ ../include/Eigen/src/Geometry/EulerAngles.h
+ ../include/Eigen/src/Geometry/Homogeneous.h
+ ../include/Eigen/src/Geometry/Hyperplane.h
+ ../include/Eigen/src/Geometry/OrthoMethods.h
+ ../include/Eigen/src/Geometry/ParametrizedLine.h
+ ../include/Eigen/src/Geometry/Quaternion.h
+ ../include/Eigen/src/Geometry/Rotation2D.h
+ ../include/Eigen/src/Geometry/RotationBase.h
+ ../include/Eigen/src/Geometry/Scaling.h
+ ../include/Eigen/src/Geometry/Transform.h
+ ../include/Eigen/src/Geometry/Translation.h
+ ../include/Eigen/src/Geometry/Umeyama.h
+ ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+ ../include/Eigen/src/Householder/BlockHouseholder.h
+ ../include/Eigen/src/Householder/Householder.h
+ ../include/Eigen/src/Householder/HouseholderSequence.h
+ ../include/Eigen/src/Jacobi/Jacobi.h
+ ../include/Eigen/src/LU/Determinant.h
+ ../include/Eigen/src/LU/FullPivLU.h
+ ../include/Eigen/src/LU/InverseImpl.h
+ ../include/Eigen/src/LU/PartialPivLU.h
+ ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+ ../include/Eigen/src/LU/arch/InverseSize4.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+ ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+ ../include/Eigen/src/QR/FullPivHouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+ ../include/Eigen/src/SVD/BDCSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+ ../include/Eigen/src/SVD/SVDBase.h
+ ../include/Eigen/src/SVD/UpperBidiagonalization.h
+ ../include/Eigen/src/misc/Image.h
+ ../include/Eigen/src/misc/Kernel.h
+ ../include/Eigen/src/misc/RealSvd2x2.h
+ ../include/Eigen/src/misc/blas.h
+ ../include/Eigen/src/misc/lapacke.h
+ ../include/Eigen/src/misc/lapacke_mangling.h
+ ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/BlockMethods.h
+ ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/IndexedViewMethods.h
+ ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/ReshapedMethods.h
+ ../include/STrack.h
+ ../include/dataType.h
+ ../include/kalmanFilter.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/BYTETracker.cpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o
+ ../include/Eigen/Cholesky
+ ../include/Eigen/Core
+ ../include/Eigen/Dense
+ ../include/Eigen/Eigenvalues
+ ../include/Eigen/Geometry
+ ../include/Eigen/Householder
+ ../include/Eigen/Jacobi
+ ../include/Eigen/LU
+ ../include/Eigen/QR
+ ../include/Eigen/SVD
+ ../include/Eigen/src/Cholesky/LDLT.h
+ ../include/Eigen/src/Cholesky/LLT.h
+ ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+ ../include/Eigen/src/Core/ArithmeticSequence.h
+ ../include/Eigen/src/Core/Array.h
+ ../include/Eigen/src/Core/ArrayBase.h
+ ../include/Eigen/src/Core/ArrayWrapper.h
+ ../include/Eigen/src/Core/Assign.h
+ ../include/Eigen/src/Core/AssignEvaluator.h
+ ../include/Eigen/src/Core/Assign_MKL.h
+ ../include/Eigen/src/Core/BandMatrix.h
+ ../include/Eigen/src/Core/Block.h
+ ../include/Eigen/src/Core/BooleanRedux.h
+ ../include/Eigen/src/Core/CommaInitializer.h
+ ../include/Eigen/src/Core/ConditionEstimator.h
+ ../include/Eigen/src/Core/CoreEvaluators.h
+ ../include/Eigen/src/Core/CoreIterators.h
+ ../include/Eigen/src/Core/CwiseBinaryOp.h
+ ../include/Eigen/src/Core/CwiseNullaryOp.h
+ ../include/Eigen/src/Core/CwiseTernaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryView.h
+ ../include/Eigen/src/Core/DenseBase.h
+ ../include/Eigen/src/Core/DenseCoeffsBase.h
+ ../include/Eigen/src/Core/DenseStorage.h
+ ../include/Eigen/src/Core/Diagonal.h
+ ../include/Eigen/src/Core/DiagonalMatrix.h
+ ../include/Eigen/src/Core/DiagonalProduct.h
+ ../include/Eigen/src/Core/Dot.h
+ ../include/Eigen/src/Core/EigenBase.h
+ ../include/Eigen/src/Core/Fuzzy.h
+ ../include/Eigen/src/Core/GeneralProduct.h
+ ../include/Eigen/src/Core/GenericPacketMath.h
+ ../include/Eigen/src/Core/GlobalFunctions.h
+ ../include/Eigen/src/Core/IO.h
+ ../include/Eigen/src/Core/IndexedView.h
+ ../include/Eigen/src/Core/Inverse.h
+ ../include/Eigen/src/Core/Map.h
+ ../include/Eigen/src/Core/MapBase.h
+ ../include/Eigen/src/Core/MathFunctions.h
+ ../include/Eigen/src/Core/MathFunctionsImpl.h
+ ../include/Eigen/src/Core/Matrix.h
+ ../include/Eigen/src/Core/MatrixBase.h
+ ../include/Eigen/src/Core/NestByValue.h
+ ../include/Eigen/src/Core/NoAlias.h
+ ../include/Eigen/src/Core/NumTraits.h
+ ../include/Eigen/src/Core/PartialReduxEvaluator.h
+ ../include/Eigen/src/Core/PermutationMatrix.h
+ ../include/Eigen/src/Core/PlainObjectBase.h
+ ../include/Eigen/src/Core/Product.h
+ ../include/Eigen/src/Core/ProductEvaluators.h
+ ../include/Eigen/src/Core/Random.h
+ ../include/Eigen/src/Core/Redux.h
+ ../include/Eigen/src/Core/Ref.h
+ ../include/Eigen/src/Core/Replicate.h
+ ../include/Eigen/src/Core/Reshaped.h
+ ../include/Eigen/src/Core/ReturnByValue.h
+ ../include/Eigen/src/Core/Reverse.h
+ ../include/Eigen/src/Core/Select.h
+ ../include/Eigen/src/Core/SelfAdjointView.h
+ ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+ ../include/Eigen/src/Core/Solve.h
+ ../include/Eigen/src/Core/SolveTriangular.h
+ ../include/Eigen/src/Core/SolverBase.h
+ ../include/Eigen/src/Core/StableNorm.h
+ ../include/Eigen/src/Core/StlIterators.h
+ ../include/Eigen/src/Core/Stride.h
+ ../include/Eigen/src/Core/Swap.h
+ ../include/Eigen/src/Core/Transpose.h
+ ../include/Eigen/src/Core/Transpositions.h
+ ../include/Eigen/src/Core/TriangularMatrix.h
+ ../include/Eigen/src/Core/VectorBlock.h
+ ../include/Eigen/src/Core/VectorwiseOp.h
+ ../include/Eigen/src/Core/Visitor.h
+ ../include/Eigen/src/Core/arch/AVX/Complex.h
+ ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AVX512/Complex.h
+ ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+ ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+ ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+ ../include/Eigen/src/Core/arch/CUDA/Complex.h
+ ../include/Eigen/src/Core/arch/Default/BFloat16.h
+ ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+ ../include/Eigen/src/Core/arch/Default/Half.h
+ ../include/Eigen/src/Core/arch/Default/Settings.h
+ ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+ ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+ ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+ ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+ ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+ ../include/Eigen/src/Core/arch/MSA/Complex.h
+ ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+ ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/Complex.h
+ ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+ ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SSE/Complex.h
+ ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+ ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+ ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+ ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+ ../include/Eigen/src/Core/arch/ZVector/Complex.h
+ ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+ ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+ ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+ ../include/Eigen/src/Core/functors/BinaryFunctors.h
+ ../include/Eigen/src/Core/functors/NullaryFunctors.h
+ ../include/Eigen/src/Core/functors/StlFunctors.h
+ ../include/Eigen/src/Core/functors/TernaryFunctors.h
+ ../include/Eigen/src/Core/functors/UnaryFunctors.h
+ ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/Parallelizer.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointProduct.h
+ ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverVector.h
+ ../include/Eigen/src/Core/util/BlasUtil.h
+ ../include/Eigen/src/Core/util/ConfigureVectorization.h
+ ../include/Eigen/src/Core/util/Constants.h
+ ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ForwardDeclarations.h
+ ../include/Eigen/src/Core/util/IndexedViewHelper.h
+ ../include/Eigen/src/Core/util/IntegralConstant.h
+ ../include/Eigen/src/Core/util/MKL_support.h
+ ../include/Eigen/src/Core/util/Macros.h
+ ../include/Eigen/src/Core/util/Memory.h
+ ../include/Eigen/src/Core/util/Meta.h
+ ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ReshapedHelper.h
+ ../include/Eigen/src/Core/util/StaticAssert.h
+ ../include/Eigen/src/Core/util/SymbolicIndex.h
+ ../include/Eigen/src/Core/util/XprHelper.h
+ ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/EigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+ ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+ ../include/Eigen/src/Eigenvalues/RealQZ.h
+ ../include/Eigen/src/Eigenvalues/RealSchur.h
+ ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+ ../include/Eigen/src/Geometry/AlignedBox.h
+ ../include/Eigen/src/Geometry/AngleAxis.h
+ ../include/Eigen/src/Geometry/EulerAngles.h
+ ../include/Eigen/src/Geometry/Homogeneous.h
+ ../include/Eigen/src/Geometry/Hyperplane.h
+ ../include/Eigen/src/Geometry/OrthoMethods.h
+ ../include/Eigen/src/Geometry/ParametrizedLine.h
+ ../include/Eigen/src/Geometry/Quaternion.h
+ ../include/Eigen/src/Geometry/Rotation2D.h
+ ../include/Eigen/src/Geometry/RotationBase.h
+ ../include/Eigen/src/Geometry/Scaling.h
+ ../include/Eigen/src/Geometry/Transform.h
+ ../include/Eigen/src/Geometry/Translation.h
+ ../include/Eigen/src/Geometry/Umeyama.h
+ ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+ ../include/Eigen/src/Householder/BlockHouseholder.h
+ ../include/Eigen/src/Householder/Householder.h
+ ../include/Eigen/src/Householder/HouseholderSequence.h
+ ../include/Eigen/src/Jacobi/Jacobi.h
+ ../include/Eigen/src/LU/Determinant.h
+ ../include/Eigen/src/LU/FullPivLU.h
+ ../include/Eigen/src/LU/InverseImpl.h
+ ../include/Eigen/src/LU/PartialPivLU.h
+ ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+ ../include/Eigen/src/LU/arch/InverseSize4.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+ ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+ ../include/Eigen/src/QR/FullPivHouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+ ../include/Eigen/src/SVD/BDCSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+ ../include/Eigen/src/SVD/SVDBase.h
+ ../include/Eigen/src/SVD/UpperBidiagonalization.h
+ ../include/Eigen/src/misc/Image.h
+ ../include/Eigen/src/misc/Kernel.h
+ ../include/Eigen/src/misc/RealSvd2x2.h
+ ../include/Eigen/src/misc/blas.h
+ ../include/Eigen/src/misc/lapacke.h
+ ../include/Eigen/src/misc/lapacke_mangling.h
+ ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/BlockMethods.h
+ ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/IndexedViewMethods.h
+ ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/ReshapedMethods.h
+ ../include/STrack.h
+ ../include/dataType.h
+ ../include/kalmanFilter.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/STrack.cpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o
+ ../3rdparty/librknn_api/include/rknn_api.h
+ ../include/BYTETracker.h
+ ../include/Eigen/Cholesky
+ ../include/Eigen/Core
+ ../include/Eigen/Dense
+ ../include/Eigen/Eigenvalues
+ ../include/Eigen/Geometry
+ ../include/Eigen/Householder
+ ../include/Eigen/Jacobi
+ ../include/Eigen/LU
+ ../include/Eigen/QR
+ ../include/Eigen/SVD
+ ../include/Eigen/src/Cholesky/LDLT.h
+ ../include/Eigen/src/Cholesky/LLT.h
+ ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+ ../include/Eigen/src/Core/ArithmeticSequence.h
+ ../include/Eigen/src/Core/Array.h
+ ../include/Eigen/src/Core/ArrayBase.h
+ ../include/Eigen/src/Core/ArrayWrapper.h
+ ../include/Eigen/src/Core/Assign.h
+ ../include/Eigen/src/Core/AssignEvaluator.h
+ ../include/Eigen/src/Core/Assign_MKL.h
+ ../include/Eigen/src/Core/BandMatrix.h
+ ../include/Eigen/src/Core/Block.h
+ ../include/Eigen/src/Core/BooleanRedux.h
+ ../include/Eigen/src/Core/CommaInitializer.h
+ ../include/Eigen/src/Core/ConditionEstimator.h
+ ../include/Eigen/src/Core/CoreEvaluators.h
+ ../include/Eigen/src/Core/CoreIterators.h
+ ../include/Eigen/src/Core/CwiseBinaryOp.h
+ ../include/Eigen/src/Core/CwiseNullaryOp.h
+ ../include/Eigen/src/Core/CwiseTernaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryView.h
+ ../include/Eigen/src/Core/DenseBase.h
+ ../include/Eigen/src/Core/DenseCoeffsBase.h
+ ../include/Eigen/src/Core/DenseStorage.h
+ ../include/Eigen/src/Core/Diagonal.h
+ ../include/Eigen/src/Core/DiagonalMatrix.h
+ ../include/Eigen/src/Core/DiagonalProduct.h
+ ../include/Eigen/src/Core/Dot.h
+ ../include/Eigen/src/Core/EigenBase.h
+ ../include/Eigen/src/Core/Fuzzy.h
+ ../include/Eigen/src/Core/GeneralProduct.h
+ ../include/Eigen/src/Core/GenericPacketMath.h
+ ../include/Eigen/src/Core/GlobalFunctions.h
+ ../include/Eigen/src/Core/IO.h
+ ../include/Eigen/src/Core/IndexedView.h
+ ../include/Eigen/src/Core/Inverse.h
+ ../include/Eigen/src/Core/Map.h
+ ../include/Eigen/src/Core/MapBase.h
+ ../include/Eigen/src/Core/MathFunctions.h
+ ../include/Eigen/src/Core/MathFunctionsImpl.h
+ ../include/Eigen/src/Core/Matrix.h
+ ../include/Eigen/src/Core/MatrixBase.h
+ ../include/Eigen/src/Core/NestByValue.h
+ ../include/Eigen/src/Core/NoAlias.h
+ ../include/Eigen/src/Core/NumTraits.h
+ ../include/Eigen/src/Core/PartialReduxEvaluator.h
+ ../include/Eigen/src/Core/PermutationMatrix.h
+ ../include/Eigen/src/Core/PlainObjectBase.h
+ ../include/Eigen/src/Core/Product.h
+ ../include/Eigen/src/Core/ProductEvaluators.h
+ ../include/Eigen/src/Core/Random.h
+ ../include/Eigen/src/Core/Redux.h
+ ../include/Eigen/src/Core/Ref.h
+ ../include/Eigen/src/Core/Replicate.h
+ ../include/Eigen/src/Core/Reshaped.h
+ ../include/Eigen/src/Core/ReturnByValue.h
+ ../include/Eigen/src/Core/Reverse.h
+ ../include/Eigen/src/Core/Select.h
+ ../include/Eigen/src/Core/SelfAdjointView.h
+ ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+ ../include/Eigen/src/Core/Solve.h
+ ../include/Eigen/src/Core/SolveTriangular.h
+ ../include/Eigen/src/Core/SolverBase.h
+ ../include/Eigen/src/Core/StableNorm.h
+ ../include/Eigen/src/Core/StlIterators.h
+ ../include/Eigen/src/Core/Stride.h
+ ../include/Eigen/src/Core/Swap.h
+ ../include/Eigen/src/Core/Transpose.h
+ ../include/Eigen/src/Core/Transpositions.h
+ ../include/Eigen/src/Core/TriangularMatrix.h
+ ../include/Eigen/src/Core/VectorBlock.h
+ ../include/Eigen/src/Core/VectorwiseOp.h
+ ../include/Eigen/src/Core/Visitor.h
+ ../include/Eigen/src/Core/arch/AVX/Complex.h
+ ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AVX512/Complex.h
+ ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+ ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+ ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+ ../include/Eigen/src/Core/arch/CUDA/Complex.h
+ ../include/Eigen/src/Core/arch/Default/BFloat16.h
+ ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+ ../include/Eigen/src/Core/arch/Default/Half.h
+ ../include/Eigen/src/Core/arch/Default/Settings.h
+ ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+ ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+ ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+ ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+ ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+ ../include/Eigen/src/Core/arch/MSA/Complex.h
+ ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+ ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/Complex.h
+ ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+ ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SSE/Complex.h
+ ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+ ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+ ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+ ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+ ../include/Eigen/src/Core/arch/ZVector/Complex.h
+ ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+ ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+ ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+ ../include/Eigen/src/Core/functors/BinaryFunctors.h
+ ../include/Eigen/src/Core/functors/NullaryFunctors.h
+ ../include/Eigen/src/Core/functors/StlFunctors.h
+ ../include/Eigen/src/Core/functors/TernaryFunctors.h
+ ../include/Eigen/src/Core/functors/UnaryFunctors.h
+ ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/Parallelizer.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointProduct.h
+ ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverVector.h
+ ../include/Eigen/src/Core/util/BlasUtil.h
+ ../include/Eigen/src/Core/util/ConfigureVectorization.h
+ ../include/Eigen/src/Core/util/Constants.h
+ ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ForwardDeclarations.h
+ ../include/Eigen/src/Core/util/IndexedViewHelper.h
+ ../include/Eigen/src/Core/util/IntegralConstant.h
+ ../include/Eigen/src/Core/util/MKL_support.h
+ ../include/Eigen/src/Core/util/Macros.h
+ ../include/Eigen/src/Core/util/Memory.h
+ ../include/Eigen/src/Core/util/Meta.h
+ ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ReshapedHelper.h
+ ../include/Eigen/src/Core/util/StaticAssert.h
+ ../include/Eigen/src/Core/util/SymbolicIndex.h
+ ../include/Eigen/src/Core/util/XprHelper.h
+ ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/EigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+ ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+ ../include/Eigen/src/Eigenvalues/RealQZ.h
+ ../include/Eigen/src/Eigenvalues/RealSchur.h
+ ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+ ../include/Eigen/src/Geometry/AlignedBox.h
+ ../include/Eigen/src/Geometry/AngleAxis.h
+ ../include/Eigen/src/Geometry/EulerAngles.h
+ ../include/Eigen/src/Geometry/Homogeneous.h
+ ../include/Eigen/src/Geometry/Hyperplane.h
+ ../include/Eigen/src/Geometry/OrthoMethods.h
+ ../include/Eigen/src/Geometry/ParametrizedLine.h
+ ../include/Eigen/src/Geometry/Quaternion.h
+ ../include/Eigen/src/Geometry/Rotation2D.h
+ ../include/Eigen/src/Geometry/RotationBase.h
+ ../include/Eigen/src/Geometry/Scaling.h
+ ../include/Eigen/src/Geometry/Transform.h
+ ../include/Eigen/src/Geometry/Translation.h
+ ../include/Eigen/src/Geometry/Umeyama.h
+ ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+ ../include/Eigen/src/Householder/BlockHouseholder.h
+ ../include/Eigen/src/Householder/Householder.h
+ ../include/Eigen/src/Householder/HouseholderSequence.h
+ ../include/Eigen/src/Jacobi/Jacobi.h
+ ../include/Eigen/src/LU/Determinant.h
+ ../include/Eigen/src/LU/FullPivLU.h
+ ../include/Eigen/src/LU/InverseImpl.h
+ ../include/Eigen/src/LU/PartialPivLU.h
+ ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+ ../include/Eigen/src/LU/arch/InverseSize4.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+ ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+ ../include/Eigen/src/QR/FullPivHouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+ ../include/Eigen/src/SVD/BDCSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+ ../include/Eigen/src/SVD/SVDBase.h
+ ../include/Eigen/src/SVD/UpperBidiagonalization.h
+ ../include/Eigen/src/misc/Image.h
+ ../include/Eigen/src/misc/Kernel.h
+ ../include/Eigen/src/misc/RealSvd2x2.h
+ ../include/Eigen/src/misc/blas.h
+ ../include/Eigen/src/misc/lapacke.h
+ ../include/Eigen/src/misc/lapacke_mangling.h
+ ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/BlockMethods.h
+ ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/IndexedViewMethods.h
+ ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/ReshapedMethods.h
+ ../include/STrack.h
+ ../include/dataType.h
+ ../include/kalmanFilter.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/bytetrack.cpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/core.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui/highgui.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/imgproc.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+ /home/huey/openssl/install/include/openssl/asn1.h
+ /home/huey/openssl/install/include/openssl/asn1err.h
+ /home/huey/openssl/install/include/openssl/bio.h
+ /home/huey/openssl/install/include/openssl/bioerr.h
+ /home/huey/openssl/install/include/openssl/bn.h
+ /home/huey/openssl/install/include/openssl/bnerr.h
+ /home/huey/openssl/install/include/openssl/configuration.h
+ /home/huey/openssl/install/include/openssl/core.h
+ /home/huey/openssl/install/include/openssl/core_dispatch.h
+ /home/huey/openssl/install/include/openssl/crypto.h
+ /home/huey/openssl/install/include/openssl/cryptoerr.h
+ /home/huey/openssl/install/include/openssl/cryptoerr_legacy.h
+ /home/huey/openssl/install/include/openssl/e_os2.h
+ /home/huey/openssl/install/include/openssl/ebcdic.h
+ /home/huey/openssl/install/include/openssl/evp.h
+ /home/huey/openssl/install/include/openssl/evperr.h
+ /home/huey/openssl/install/include/openssl/macros.h
+ /home/huey/openssl/install/include/openssl/obj_mac.h
+ /home/huey/openssl/install/include/openssl/objects.h
+ /home/huey/openssl/install/include/openssl/objectserr.h
+ /home/huey/openssl/install/include/openssl/opensslconf.h
+ /home/huey/openssl/install/include/openssl/opensslv.h
+ /home/huey/openssl/install/include/openssl/params.h
+ /home/huey/openssl/install/include/openssl/safestack.h
+ /home/huey/openssl/install/include/openssl/sha.h
+ /home/huey/openssl/install/include/openssl/stack.h
+ /home/huey/openssl/install/include/openssl/symhacks.h
+ /home/huey/openssl/install/include/openssl/types.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o
+ ../include/Eigen/Cholesky
+ ../include/Eigen/Core
+ ../include/Eigen/Dense
+ ../include/Eigen/Eigenvalues
+ ../include/Eigen/Geometry
+ ../include/Eigen/Householder
+ ../include/Eigen/Jacobi
+ ../include/Eigen/LU
+ ../include/Eigen/QR
+ ../include/Eigen/SVD
+ ../include/Eigen/src/Cholesky/LDLT.h
+ ../include/Eigen/src/Cholesky/LLT.h
+ ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+ ../include/Eigen/src/Core/ArithmeticSequence.h
+ ../include/Eigen/src/Core/Array.h
+ ../include/Eigen/src/Core/ArrayBase.h
+ ../include/Eigen/src/Core/ArrayWrapper.h
+ ../include/Eigen/src/Core/Assign.h
+ ../include/Eigen/src/Core/AssignEvaluator.h
+ ../include/Eigen/src/Core/Assign_MKL.h
+ ../include/Eigen/src/Core/BandMatrix.h
+ ../include/Eigen/src/Core/Block.h
+ ../include/Eigen/src/Core/BooleanRedux.h
+ ../include/Eigen/src/Core/CommaInitializer.h
+ ../include/Eigen/src/Core/ConditionEstimator.h
+ ../include/Eigen/src/Core/CoreEvaluators.h
+ ../include/Eigen/src/Core/CoreIterators.h
+ ../include/Eigen/src/Core/CwiseBinaryOp.h
+ ../include/Eigen/src/Core/CwiseNullaryOp.h
+ ../include/Eigen/src/Core/CwiseTernaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryView.h
+ ../include/Eigen/src/Core/DenseBase.h
+ ../include/Eigen/src/Core/DenseCoeffsBase.h
+ ../include/Eigen/src/Core/DenseStorage.h
+ ../include/Eigen/src/Core/Diagonal.h
+ ../include/Eigen/src/Core/DiagonalMatrix.h
+ ../include/Eigen/src/Core/DiagonalProduct.h
+ ../include/Eigen/src/Core/Dot.h
+ ../include/Eigen/src/Core/EigenBase.h
+ ../include/Eigen/src/Core/Fuzzy.h
+ ../include/Eigen/src/Core/GeneralProduct.h
+ ../include/Eigen/src/Core/GenericPacketMath.h
+ ../include/Eigen/src/Core/GlobalFunctions.h
+ ../include/Eigen/src/Core/IO.h
+ ../include/Eigen/src/Core/IndexedView.h
+ ../include/Eigen/src/Core/Inverse.h
+ ../include/Eigen/src/Core/Map.h
+ ../include/Eigen/src/Core/MapBase.h
+ ../include/Eigen/src/Core/MathFunctions.h
+ ../include/Eigen/src/Core/MathFunctionsImpl.h
+ ../include/Eigen/src/Core/Matrix.h
+ ../include/Eigen/src/Core/MatrixBase.h
+ ../include/Eigen/src/Core/NestByValue.h
+ ../include/Eigen/src/Core/NoAlias.h
+ ../include/Eigen/src/Core/NumTraits.h
+ ../include/Eigen/src/Core/PartialReduxEvaluator.h
+ ../include/Eigen/src/Core/PermutationMatrix.h
+ ../include/Eigen/src/Core/PlainObjectBase.h
+ ../include/Eigen/src/Core/Product.h
+ ../include/Eigen/src/Core/ProductEvaluators.h
+ ../include/Eigen/src/Core/Random.h
+ ../include/Eigen/src/Core/Redux.h
+ ../include/Eigen/src/Core/Ref.h
+ ../include/Eigen/src/Core/Replicate.h
+ ../include/Eigen/src/Core/Reshaped.h
+ ../include/Eigen/src/Core/ReturnByValue.h
+ ../include/Eigen/src/Core/Reverse.h
+ ../include/Eigen/src/Core/Select.h
+ ../include/Eigen/src/Core/SelfAdjointView.h
+ ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+ ../include/Eigen/src/Core/Solve.h
+ ../include/Eigen/src/Core/SolveTriangular.h
+ ../include/Eigen/src/Core/SolverBase.h
+ ../include/Eigen/src/Core/StableNorm.h
+ ../include/Eigen/src/Core/StlIterators.h
+ ../include/Eigen/src/Core/Stride.h
+ ../include/Eigen/src/Core/Swap.h
+ ../include/Eigen/src/Core/Transpose.h
+ ../include/Eigen/src/Core/Transpositions.h
+ ../include/Eigen/src/Core/TriangularMatrix.h
+ ../include/Eigen/src/Core/VectorBlock.h
+ ../include/Eigen/src/Core/VectorwiseOp.h
+ ../include/Eigen/src/Core/Visitor.h
+ ../include/Eigen/src/Core/arch/AVX/Complex.h
+ ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AVX512/Complex.h
+ ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+ ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+ ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+ ../include/Eigen/src/Core/arch/CUDA/Complex.h
+ ../include/Eigen/src/Core/arch/Default/BFloat16.h
+ ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+ ../include/Eigen/src/Core/arch/Default/Half.h
+ ../include/Eigen/src/Core/arch/Default/Settings.h
+ ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+ ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+ ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+ ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+ ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+ ../include/Eigen/src/Core/arch/MSA/Complex.h
+ ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+ ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/Complex.h
+ ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+ ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SSE/Complex.h
+ ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+ ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+ ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+ ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+ ../include/Eigen/src/Core/arch/ZVector/Complex.h
+ ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+ ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+ ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+ ../include/Eigen/src/Core/functors/BinaryFunctors.h
+ ../include/Eigen/src/Core/functors/NullaryFunctors.h
+ ../include/Eigen/src/Core/functors/StlFunctors.h
+ ../include/Eigen/src/Core/functors/TernaryFunctors.h
+ ../include/Eigen/src/Core/functors/UnaryFunctors.h
+ ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/Parallelizer.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointProduct.h
+ ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverVector.h
+ ../include/Eigen/src/Core/util/BlasUtil.h
+ ../include/Eigen/src/Core/util/ConfigureVectorization.h
+ ../include/Eigen/src/Core/util/Constants.h
+ ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ForwardDeclarations.h
+ ../include/Eigen/src/Core/util/IndexedViewHelper.h
+ ../include/Eigen/src/Core/util/IntegralConstant.h
+ ../include/Eigen/src/Core/util/MKL_support.h
+ ../include/Eigen/src/Core/util/Macros.h
+ ../include/Eigen/src/Core/util/Memory.h
+ ../include/Eigen/src/Core/util/Meta.h
+ ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ReshapedHelper.h
+ ../include/Eigen/src/Core/util/StaticAssert.h
+ ../include/Eigen/src/Core/util/SymbolicIndex.h
+ ../include/Eigen/src/Core/util/XprHelper.h
+ ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/EigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+ ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+ ../include/Eigen/src/Eigenvalues/RealQZ.h
+ ../include/Eigen/src/Eigenvalues/RealSchur.h
+ ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+ ../include/Eigen/src/Geometry/AlignedBox.h
+ ../include/Eigen/src/Geometry/AngleAxis.h
+ ../include/Eigen/src/Geometry/EulerAngles.h
+ ../include/Eigen/src/Geometry/Homogeneous.h
+ ../include/Eigen/src/Geometry/Hyperplane.h
+ ../include/Eigen/src/Geometry/OrthoMethods.h
+ ../include/Eigen/src/Geometry/ParametrizedLine.h
+ ../include/Eigen/src/Geometry/Quaternion.h
+ ../include/Eigen/src/Geometry/Rotation2D.h
+ ../include/Eigen/src/Geometry/RotationBase.h
+ ../include/Eigen/src/Geometry/Scaling.h
+ ../include/Eigen/src/Geometry/Transform.h
+ ../include/Eigen/src/Geometry/Translation.h
+ ../include/Eigen/src/Geometry/Umeyama.h
+ ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+ ../include/Eigen/src/Householder/BlockHouseholder.h
+ ../include/Eigen/src/Householder/Householder.h
+ ../include/Eigen/src/Householder/HouseholderSequence.h
+ ../include/Eigen/src/Jacobi/Jacobi.h
+ ../include/Eigen/src/LU/Determinant.h
+ ../include/Eigen/src/LU/FullPivLU.h
+ ../include/Eigen/src/LU/InverseImpl.h
+ ../include/Eigen/src/LU/PartialPivLU.h
+ ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+ ../include/Eigen/src/LU/arch/InverseSize4.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+ ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+ ../include/Eigen/src/QR/FullPivHouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+ ../include/Eigen/src/SVD/BDCSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+ ../include/Eigen/src/SVD/SVDBase.h
+ ../include/Eigen/src/SVD/UpperBidiagonalization.h
+ ../include/Eigen/src/misc/Image.h
+ ../include/Eigen/src/misc/Kernel.h
+ ../include/Eigen/src/misc/RealSvd2x2.h
+ ../include/Eigen/src/misc/blas.h
+ ../include/Eigen/src/misc/lapacke.h
+ ../include/Eigen/src/misc/lapacke_mangling.h
+ ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/BlockMethods.h
+ ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/IndexedViewMethods.h
+ ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/ReshapedMethods.h
+ ../include/dataType.h
+ ../include/kalmanFilter.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/kalmanFilter.cpp
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o
+ ../include/lapjv.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/lapjv.cpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o
+ ../include/BYTETracker.h
+ ../include/Eigen/Cholesky
+ ../include/Eigen/Core
+ ../include/Eigen/Dense
+ ../include/Eigen/Eigenvalues
+ ../include/Eigen/Geometry
+ ../include/Eigen/Householder
+ ../include/Eigen/Jacobi
+ ../include/Eigen/LU
+ ../include/Eigen/QR
+ ../include/Eigen/SVD
+ ../include/Eigen/src/Cholesky/LDLT.h
+ ../include/Eigen/src/Cholesky/LLT.h
+ ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+ ../include/Eigen/src/Core/ArithmeticSequence.h
+ ../include/Eigen/src/Core/Array.h
+ ../include/Eigen/src/Core/ArrayBase.h
+ ../include/Eigen/src/Core/ArrayWrapper.h
+ ../include/Eigen/src/Core/Assign.h
+ ../include/Eigen/src/Core/AssignEvaluator.h
+ ../include/Eigen/src/Core/Assign_MKL.h
+ ../include/Eigen/src/Core/BandMatrix.h
+ ../include/Eigen/src/Core/Block.h
+ ../include/Eigen/src/Core/BooleanRedux.h
+ ../include/Eigen/src/Core/CommaInitializer.h
+ ../include/Eigen/src/Core/ConditionEstimator.h
+ ../include/Eigen/src/Core/CoreEvaluators.h
+ ../include/Eigen/src/Core/CoreIterators.h
+ ../include/Eigen/src/Core/CwiseBinaryOp.h
+ ../include/Eigen/src/Core/CwiseNullaryOp.h
+ ../include/Eigen/src/Core/CwiseTernaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryOp.h
+ ../include/Eigen/src/Core/CwiseUnaryView.h
+ ../include/Eigen/src/Core/DenseBase.h
+ ../include/Eigen/src/Core/DenseCoeffsBase.h
+ ../include/Eigen/src/Core/DenseStorage.h
+ ../include/Eigen/src/Core/Diagonal.h
+ ../include/Eigen/src/Core/DiagonalMatrix.h
+ ../include/Eigen/src/Core/DiagonalProduct.h
+ ../include/Eigen/src/Core/Dot.h
+ ../include/Eigen/src/Core/EigenBase.h
+ ../include/Eigen/src/Core/Fuzzy.h
+ ../include/Eigen/src/Core/GeneralProduct.h
+ ../include/Eigen/src/Core/GenericPacketMath.h
+ ../include/Eigen/src/Core/GlobalFunctions.h
+ ../include/Eigen/src/Core/IO.h
+ ../include/Eigen/src/Core/IndexedView.h
+ ../include/Eigen/src/Core/Inverse.h
+ ../include/Eigen/src/Core/Map.h
+ ../include/Eigen/src/Core/MapBase.h
+ ../include/Eigen/src/Core/MathFunctions.h
+ ../include/Eigen/src/Core/MathFunctionsImpl.h
+ ../include/Eigen/src/Core/Matrix.h
+ ../include/Eigen/src/Core/MatrixBase.h
+ ../include/Eigen/src/Core/NestByValue.h
+ ../include/Eigen/src/Core/NoAlias.h
+ ../include/Eigen/src/Core/NumTraits.h
+ ../include/Eigen/src/Core/PartialReduxEvaluator.h
+ ../include/Eigen/src/Core/PermutationMatrix.h
+ ../include/Eigen/src/Core/PlainObjectBase.h
+ ../include/Eigen/src/Core/Product.h
+ ../include/Eigen/src/Core/ProductEvaluators.h
+ ../include/Eigen/src/Core/Random.h
+ ../include/Eigen/src/Core/Redux.h
+ ../include/Eigen/src/Core/Ref.h
+ ../include/Eigen/src/Core/Replicate.h
+ ../include/Eigen/src/Core/Reshaped.h
+ ../include/Eigen/src/Core/ReturnByValue.h
+ ../include/Eigen/src/Core/Reverse.h
+ ../include/Eigen/src/Core/Select.h
+ ../include/Eigen/src/Core/SelfAdjointView.h
+ ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+ ../include/Eigen/src/Core/Solve.h
+ ../include/Eigen/src/Core/SolveTriangular.h
+ ../include/Eigen/src/Core/SolverBase.h
+ ../include/Eigen/src/Core/StableNorm.h
+ ../include/Eigen/src/Core/StlIterators.h
+ ../include/Eigen/src/Core/Stride.h
+ ../include/Eigen/src/Core/Swap.h
+ ../include/Eigen/src/Core/Transpose.h
+ ../include/Eigen/src/Core/Transpositions.h
+ ../include/Eigen/src/Core/TriangularMatrix.h
+ ../include/Eigen/src/Core/VectorBlock.h
+ ../include/Eigen/src/Core/VectorwiseOp.h
+ ../include/Eigen/src/Core/Visitor.h
+ ../include/Eigen/src/Core/arch/AVX/Complex.h
+ ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AVX512/Complex.h
+ ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+ ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+ ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+ ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+ ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+ ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+ ../include/Eigen/src/Core/arch/CUDA/Complex.h
+ ../include/Eigen/src/Core/arch/Default/BFloat16.h
+ ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+ ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+ ../include/Eigen/src/Core/arch/Default/Half.h
+ ../include/Eigen/src/Core/arch/Default/Settings.h
+ ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+ ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+ ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+ ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+ ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+ ../include/Eigen/src/Core/arch/MSA/Complex.h
+ ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+ ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/Complex.h
+ ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+ ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+ ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SSE/Complex.h
+ ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+ ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+ ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+ ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+ ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+ ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+ ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+ ../include/Eigen/src/Core/arch/ZVector/Complex.h
+ ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+ ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+ ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+ ../include/Eigen/src/Core/functors/BinaryFunctors.h
+ ../include/Eigen/src/Core/functors/NullaryFunctors.h
+ ../include/Eigen/src/Core/functors/StlFunctors.h
+ ../include/Eigen/src/Core/functors/TernaryFunctors.h
+ ../include/Eigen/src/Core/functors/UnaryFunctors.h
+ ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+ ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/Parallelizer.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+ ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/SelfadjointProduct.h
+ ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+ ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+ ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+ ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+ ../include/Eigen/src/Core/products/TriangularSolverVector.h
+ ../include/Eigen/src/Core/util/BlasUtil.h
+ ../include/Eigen/src/Core/util/ConfigureVectorization.h
+ ../include/Eigen/src/Core/util/Constants.h
+ ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ForwardDeclarations.h
+ ../include/Eigen/src/Core/util/IndexedViewHelper.h
+ ../include/Eigen/src/Core/util/IntegralConstant.h
+ ../include/Eigen/src/Core/util/MKL_support.h
+ ../include/Eigen/src/Core/util/Macros.h
+ ../include/Eigen/src/Core/util/Memory.h
+ ../include/Eigen/src/Core/util/Meta.h
+ ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+ ../include/Eigen/src/Core/util/ReshapedHelper.h
+ ../include/Eigen/src/Core/util/StaticAssert.h
+ ../include/Eigen/src/Core/util/SymbolicIndex.h
+ ../include/Eigen/src/Core/util/XprHelper.h
+ ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+ ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/EigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+ ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+ ../include/Eigen/src/Eigenvalues/RealQZ.h
+ ../include/Eigen/src/Eigenvalues/RealSchur.h
+ ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+ ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+ ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+ ../include/Eigen/src/Geometry/AlignedBox.h
+ ../include/Eigen/src/Geometry/AngleAxis.h
+ ../include/Eigen/src/Geometry/EulerAngles.h
+ ../include/Eigen/src/Geometry/Homogeneous.h
+ ../include/Eigen/src/Geometry/Hyperplane.h
+ ../include/Eigen/src/Geometry/OrthoMethods.h
+ ../include/Eigen/src/Geometry/ParametrizedLine.h
+ ../include/Eigen/src/Geometry/Quaternion.h
+ ../include/Eigen/src/Geometry/Rotation2D.h
+ ../include/Eigen/src/Geometry/RotationBase.h
+ ../include/Eigen/src/Geometry/Scaling.h
+ ../include/Eigen/src/Geometry/Transform.h
+ ../include/Eigen/src/Geometry/Translation.h
+ ../include/Eigen/src/Geometry/Umeyama.h
+ ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+ ../include/Eigen/src/Householder/BlockHouseholder.h
+ ../include/Eigen/src/Householder/Householder.h
+ ../include/Eigen/src/Householder/HouseholderSequence.h
+ ../include/Eigen/src/Jacobi/Jacobi.h
+ ../include/Eigen/src/LU/Determinant.h
+ ../include/Eigen/src/LU/FullPivLU.h
+ ../include/Eigen/src/LU/InverseImpl.h
+ ../include/Eigen/src/LU/PartialPivLU.h
+ ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+ ../include/Eigen/src/LU/arch/InverseSize4.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR.h
+ ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+ ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+ ../include/Eigen/src/QR/FullPivHouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR.h
+ ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+ ../include/Eigen/src/SVD/BDCSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD.h
+ ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+ ../include/Eigen/src/SVD/SVDBase.h
+ ../include/Eigen/src/SVD/UpperBidiagonalization.h
+ ../include/Eigen/src/misc/Image.h
+ ../include/Eigen/src/misc/Kernel.h
+ ../include/Eigen/src/misc/RealSvd2x2.h
+ ../include/Eigen/src/misc/blas.h
+ ../include/Eigen/src/misc/lapacke.h
+ ../include/Eigen/src/misc/lapacke_mangling.h
+ ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/BlockMethods.h
+ ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/IndexedViewMethods.h
+ ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+ ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+ ../include/Eigen/src/plugins/ReshapedMethods.h
+ ../include/STrack.h
+ ../include/dataType.h
+ ../include/kalmanFilter.h
+ ../include/lapjv.h
+ /home/huey/Desktop/C/yolo_bytetrack/src/utils.cpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+ /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/depend.make b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/depend.make
new file mode 100644
index 00000000..bea6ea05
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/depend.make
@@ -0,0 +1,1699 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/BYTETracker.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Cholesky
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Core
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Dense
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Eigenvalues
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Geometry
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Householder
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/Jacobi
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/LU
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/QR
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/SVD
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Cholesky/LDLT.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Cholesky/LLT.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ArithmeticSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Array.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ArrayBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ArrayWrapper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Assign.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/AssignEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Assign_MKL.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/BandMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Block.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/BooleanRedux.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CommaInitializer.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ConditionEstimator.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CoreEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CoreIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CwiseNullaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CwiseTernaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CwiseUnaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/CwiseUnaryView.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/DenseBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/DenseCoeffsBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/DenseStorage.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Diagonal.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/DiagonalMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/DiagonalProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Dot.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/EigenBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Fuzzy.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/GeneralProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/GenericPacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/GlobalFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/IO.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/IndexedView.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Inverse.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Map.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/MapBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/MathFunctionsImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/MatrixBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/NestByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/NoAlias.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/NumTraits.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/PartialReduxEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/PermutationMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/PlainObjectBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Product.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ProductEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Random.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Redux.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Ref.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Replicate.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Reshaped.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/ReturnByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Reverse.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Select.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/SelfAdjointView.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Solve.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/SolveTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/SolverBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/StableNorm.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/StlIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Stride.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Swap.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Transpose.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Transpositions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/TriangularMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/VectorBlock.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/VectorwiseOp.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/Visitor.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX512/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/CUDA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/BFloat16.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/Half.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/Settings.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/MSA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/NEON/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SSE/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/ZVector/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/BinaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/NullaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/StlFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/TernaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/functors/UnaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/Parallelizer.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverVector.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/BlasUtil.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/ConfigureVectorization.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/Constants.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/ForwardDeclarations.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/IndexedViewHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/IntegralConstant.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/MKL_support.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/Macros.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/Memory.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/Meta.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/ReshapedHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/StaticAssert.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/SymbolicIndex.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Core/util/XprHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/EigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/RealQZ.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/AlignedBox.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/AngleAxis.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/EulerAngles.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Homogeneous.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Hyperplane.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/OrthoMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/ParametrizedLine.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Quaternion.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Rotation2D.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/RotationBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Scaling.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Transform.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Translation.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/Umeyama.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Householder/BlockHouseholder.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Householder/Householder.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Householder/HouseholderSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/Jacobi/Jacobi.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/Determinant.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/FullPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/InverseImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/PartialPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/LU/arch/InverseSize4.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/FullPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/HouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/SVD/BDCSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/SVD/JacobiSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/SVD/SVDBase.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/SVD/UpperBidiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/Image.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/Kernel.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/RealSvd2x2.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/blas.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/lapacke.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/misc/lapacke_mangling.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/BlockMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/IndexedViewMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/Eigen/src/plugins/ReshapedMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/STrack.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/dataType.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../include/kalmanFilter.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: ../src/BYTETracker.cpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Cholesky
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Core
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Dense
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Eigenvalues
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Geometry
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Householder
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/Jacobi
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/LU
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/QR
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/SVD
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Cholesky/LDLT.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Cholesky/LLT.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ArithmeticSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Array.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ArrayBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ArrayWrapper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Assign.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/AssignEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Assign_MKL.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/BandMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Block.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/BooleanRedux.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CommaInitializer.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ConditionEstimator.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CoreEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CoreIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CwiseNullaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CwiseTernaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CwiseUnaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/CwiseUnaryView.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/DenseBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/DenseCoeffsBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/DenseStorage.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Diagonal.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/DiagonalMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/DiagonalProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Dot.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/EigenBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Fuzzy.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/GeneralProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/GenericPacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/GlobalFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/IO.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/IndexedView.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Inverse.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Map.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/MapBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/MathFunctionsImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/MatrixBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/NestByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/NoAlias.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/NumTraits.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/PartialReduxEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/PermutationMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/PlainObjectBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Product.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ProductEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Random.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Redux.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Ref.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Replicate.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Reshaped.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/ReturnByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Reverse.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Select.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/SelfAdjointView.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Solve.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/SolveTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/SolverBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/StableNorm.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/StlIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Stride.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Swap.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Transpose.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Transpositions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/TriangularMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/VectorBlock.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/VectorwiseOp.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/Visitor.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/CUDA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/BFloat16.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/Half.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/Settings.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/BinaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/NullaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/StlFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/TernaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/functors/UnaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/Parallelizer.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverVector.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/BlasUtil.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/ConfigureVectorization.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/Constants.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/ForwardDeclarations.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/IndexedViewHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/IntegralConstant.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/MKL_support.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/Macros.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/Memory.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/Meta.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/ReshapedHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/StaticAssert.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/SymbolicIndex.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Core/util/XprHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/EigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealQZ.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/AlignedBox.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/AngleAxis.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/EulerAngles.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Homogeneous.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Hyperplane.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/OrthoMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/ParametrizedLine.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Quaternion.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Rotation2D.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/RotationBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Scaling.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Transform.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Translation.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/Umeyama.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Householder/BlockHouseholder.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Householder/Householder.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Householder/HouseholderSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/Jacobi/Jacobi.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/Determinant.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/FullPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/InverseImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/PartialPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/LU/arch/InverseSize4.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/FullPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/HouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/SVD/BDCSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/SVD/JacobiSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/SVD/SVDBase.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/SVD/UpperBidiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/Image.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/Kernel.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/RealSvd2x2.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/blas.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/lapacke.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/misc/lapacke_mangling.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/BlockMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/IndexedViewMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/Eigen/src/plugins/ReshapedMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/STrack.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/dataType.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../include/kalmanFilter.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: ../src/STrack.cpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../3rdparty/librknn_api/include/rknn_api.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/BYTETracker.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Cholesky
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Core
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Dense
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Eigenvalues
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Geometry
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Householder
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/Jacobi
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/LU
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/QR
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/SVD
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Cholesky/LDLT.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Cholesky/LLT.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ArithmeticSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Array.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ArrayBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ArrayWrapper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Assign.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/AssignEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Assign_MKL.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/BandMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Block.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/BooleanRedux.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CommaInitializer.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ConditionEstimator.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CoreEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CoreIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CwiseNullaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CwiseTernaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CwiseUnaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/CwiseUnaryView.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/DenseBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/DenseCoeffsBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/DenseStorage.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Diagonal.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/DiagonalMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/DiagonalProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Dot.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/EigenBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Fuzzy.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/GeneralProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/GenericPacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/GlobalFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/IO.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/IndexedView.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Inverse.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Map.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/MapBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/MathFunctionsImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/MatrixBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/NestByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/NoAlias.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/NumTraits.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/PartialReduxEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/PermutationMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/PlainObjectBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Product.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ProductEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Random.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Redux.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Ref.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Replicate.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Reshaped.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/ReturnByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Reverse.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Select.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/SelfAdjointView.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Solve.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/SolveTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/SolverBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/StableNorm.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/StlIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Stride.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Swap.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Transpose.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Transpositions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/TriangularMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/VectorBlock.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/VectorwiseOp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/Visitor.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/CUDA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/BFloat16.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/Half.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/Settings.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/BinaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/NullaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/StlFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/TernaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/functors/UnaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/Parallelizer.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverVector.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/BlasUtil.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/ConfigureVectorization.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/Constants.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/ForwardDeclarations.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/IndexedViewHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/IntegralConstant.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/MKL_support.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/Macros.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/Memory.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/Meta.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/ReshapedHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/StaticAssert.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/SymbolicIndex.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Core/util/XprHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/EigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealQZ.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/AlignedBox.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/AngleAxis.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/EulerAngles.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Homogeneous.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Hyperplane.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/OrthoMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/ParametrizedLine.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Quaternion.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Rotation2D.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/RotationBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Scaling.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Transform.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Translation.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/Umeyama.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Householder/BlockHouseholder.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Householder/Householder.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Householder/HouseholderSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/Jacobi/Jacobi.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/Determinant.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/FullPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/InverseImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/PartialPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/LU/arch/InverseSize4.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/FullPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/HouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/SVD/BDCSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/SVD/JacobiSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/SVD/SVDBase.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/SVD/UpperBidiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/Image.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/Kernel.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/RealSvd2x2.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/blas.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/lapacke.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/misc/lapacke_mangling.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/BlockMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/IndexedViewMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/Eigen/src/plugins/ReshapedMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/STrack.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/dataType.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../include/kalmanFilter.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: ../src/bytetrack.cpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/core.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui/highgui.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/imgproc.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/asn1.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/asn1err.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/bio.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/bioerr.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/bn.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/bnerr.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/configuration.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/core.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/core_dispatch.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/crypto.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/cryptoerr.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/cryptoerr_legacy.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/e_os2.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/ebcdic.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/evp.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/evperr.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/macros.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/obj_mac.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/objects.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/objectserr.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/opensslconf.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/opensslv.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/params.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/safestack.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/sha.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/stack.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/symhacks.h
+CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o: /home/huey/openssl/install/include/openssl/types.h
+
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Cholesky
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Core
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Dense
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Eigenvalues
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Geometry
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Householder
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/Jacobi
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/LU
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/QR
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/SVD
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Cholesky/LDLT.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Cholesky/LLT.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ArithmeticSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Array.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ArrayBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ArrayWrapper.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Assign.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/AssignEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Assign_MKL.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/BandMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Block.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/BooleanRedux.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CommaInitializer.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ConditionEstimator.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CoreEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CoreIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CwiseNullaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CwiseTernaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CwiseUnaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/CwiseUnaryView.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/DenseBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/DenseCoeffsBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/DenseStorage.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Diagonal.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/DiagonalMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/DiagonalProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Dot.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/EigenBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Fuzzy.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/GeneralProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/GenericPacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/GlobalFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/IO.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/IndexedView.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Inverse.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Map.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/MapBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/MathFunctionsImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/MatrixBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/NestByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/NoAlias.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/NumTraits.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/PartialReduxEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/PermutationMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/PlainObjectBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Product.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ProductEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Random.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Redux.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Ref.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Replicate.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Reshaped.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/ReturnByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Reverse.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Select.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/SelfAdjointView.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Solve.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/SolveTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/SolverBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/StableNorm.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/StlIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Stride.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Swap.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Transpose.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Transpositions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/TriangularMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/VectorBlock.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/VectorwiseOp.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/Visitor.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX512/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/CUDA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/BFloat16.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/Half.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/Settings.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/MSA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/NEON/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SSE/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/ZVector/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/BinaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/NullaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/StlFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/TernaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/functors/UnaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/Parallelizer.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverVector.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/BlasUtil.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/ConfigureVectorization.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/Constants.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/ForwardDeclarations.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/IndexedViewHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/IntegralConstant.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/MKL_support.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/Macros.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/Memory.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/Meta.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/ReshapedHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/StaticAssert.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/SymbolicIndex.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Core/util/XprHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/EigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/RealQZ.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/AlignedBox.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/AngleAxis.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/EulerAngles.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Homogeneous.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Hyperplane.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/OrthoMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/ParametrizedLine.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Quaternion.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Rotation2D.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/RotationBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Scaling.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Transform.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Translation.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/Umeyama.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Householder/BlockHouseholder.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Householder/Householder.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Householder/HouseholderSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/Jacobi/Jacobi.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/Determinant.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/FullPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/InverseImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/PartialPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/LU/arch/InverseSize4.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/FullPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/HouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/SVD/BDCSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/SVD/JacobiSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/SVD/SVDBase.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/SVD/UpperBidiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/Image.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/Kernel.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/RealSvd2x2.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/blas.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/lapacke.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/misc/lapacke_mangling.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/BlockMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/IndexedViewMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/Eigen/src/plugins/ReshapedMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/dataType.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../include/kalmanFilter.h
+CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o: ../src/kalmanFilter.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o: ../include/lapjv.h
+CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o: ../src/lapjv.cpp
+
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/BYTETracker.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Cholesky
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Core
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Dense
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Eigenvalues
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Geometry
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Householder
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/Jacobi
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/LU
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/QR
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/SVD
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Cholesky/LDLT.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Cholesky/LLT.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Cholesky/LLT_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ArithmeticSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Array.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ArrayBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ArrayWrapper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Assign.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/AssignEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Assign_MKL.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/BandMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Block.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/BooleanRedux.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CommaInitializer.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ConditionEstimator.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CoreEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CoreIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CwiseNullaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CwiseTernaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CwiseUnaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/CwiseUnaryView.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/DenseBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/DenseCoeffsBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/DenseStorage.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Diagonal.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/DiagonalMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/DiagonalProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Dot.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/EigenBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Fuzzy.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/GeneralProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/GenericPacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/GlobalFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/IO.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/IndexedView.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Inverse.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Map.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/MapBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/MathFunctionsImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/MatrixBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/NestByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/NoAlias.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/NumTraits.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/PartialReduxEvaluator.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/PermutationMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/PlainObjectBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Product.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ProductEvaluators.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Random.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Redux.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Ref.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Replicate.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Reshaped.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/ReturnByValue.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Reverse.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Select.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/SelfAdjointView.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/SelfCwiseBinaryOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Solve.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/SolveTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/SolverBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/StableNorm.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/StlIterators.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Stride.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Swap.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Transpose.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Transpositions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/TriangularMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/VectorBlock.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/VectorwiseOp.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/Visitor.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX512/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX512/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX512/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AVX512/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/AltiVec/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/CUDA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/BFloat16.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/ConjHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/Half.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/Settings.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/Default/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/GPU/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/GPU/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/GPU/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/MSA/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/MSA/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/MSA/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/NEON/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/NEON/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/NEON/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/NEON/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SSE/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SSE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SSE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SSE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SVE/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SVE/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SVE/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SYCL/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SYCL/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/SYCL/TypeCasting.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/ZVector/Complex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/ZVector/MathFunctions.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/arch/ZVector/PacketMath.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/AssignmentFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/BinaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/NullaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/StlFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/TernaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/functors/UnaryFunctors.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/Parallelizer.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointProduct.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/SelfadjointRank2Update.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/products/TriangularSolverVector.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/BlasUtil.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/ConfigureVectorization.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/Constants.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/DisableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/ForwardDeclarations.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/IndexedViewHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/IntegralConstant.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/MKL_support.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/Macros.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/Memory.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/Meta.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/ReenableStupidWarnings.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/ReshapedHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/StaticAssert.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/SymbolicIndex.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Core/util/XprHelper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/EigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/RealQZ.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Eigenvalues/Tridiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/AlignedBox.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/AngleAxis.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/EulerAngles.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Homogeneous.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Hyperplane.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/OrthoMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/ParametrizedLine.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Quaternion.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Rotation2D.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/RotationBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Scaling.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Transform.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Translation.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/Umeyama.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Geometry/arch/Geometry_SIMD.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Householder/BlockHouseholder.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Householder/Householder.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Householder/HouseholderSequence.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/Jacobi/Jacobi.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/Determinant.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/FullPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/InverseImpl.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/PartialPivLU.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/PartialPivLU_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/LU/arch/InverseSize4.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/FullPivHouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/HouseholderQR.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/QR/HouseholderQR_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/SVD/BDCSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/SVD/JacobiSVD.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/SVD/SVDBase.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/SVD/UpperBidiagonalization.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/Image.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/Kernel.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/RealSvd2x2.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/blas.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/lapacke.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/misc/lapacke_mangling.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/BlockMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/CommonCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/CommonCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/IndexedViewMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/Eigen/src/plugins/ReshapedMethods.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/STrack.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/dataType.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/kalmanFilter.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../include/lapjv.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: ../src/utils.cpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/calib3d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/affine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/async.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/bufferpool.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/check.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cuda_types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_dispatch.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cv_cpu_helper.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvdef.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/cvstd_wrapper.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/fast_math.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/interface.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/hal/msa_macros.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/mat.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/matx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/neon_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/operations.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/optim.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/ovx.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/persistence.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/saturate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/traits.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/types.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utility.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/instrumentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/utils/tls.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/core/vsx_utils.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dict.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/dnn.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/layer.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/utils/inference_engine.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/dnn/version.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/features2d.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/all_indices.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/allocator.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/any.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/autotuned_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/composite_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/config.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/defines.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dist.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/dynamic_bitset.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/flann_base.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/general.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/ground_truth.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/heap.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/hierarchical_clustering_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/index_testing.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kdtree_single_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/kmeans_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/linear_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/logger.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/lsh_table.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/matrix.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/miniflann.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/nn_index.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/params.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/random.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/result_set.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/sampling.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/saving.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/flann/timer.h
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/highgui.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgcodecs.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/imgproc/segmentation.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/ml/ml.inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_board.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/aruco_dictionary.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/charuco_detector.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/detection_based_tracker.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/objdetect/face.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/opencv_modules.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/photo.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/blenders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/camera.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/exposure_compensate.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/matchers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/motion_estimators.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/seam_finders.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/util_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/detail/warpers_inl.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/stitching/warpers.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/background_segm.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/video/tracking.hpp
+CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o: /home/huey/opencv-4.7.0/install/include/opencv4/opencv2/videoio.hpp
+
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/flags.make b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/flags.make
new file mode 100644
index 00000000..89e9a043
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/flags.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# compile CXX with /home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++
+CXX_FLAGS =  
+
+CXX_DEFINES = 
+
+CXX_INCLUDES = -I/home/huey/openssl/install/include -I/home/huey/Desktop/C/yolo_bytetrack/include -I/home/huey/Desktop/C/yolo_bytetrack/3rdparty/librknn_api/include -I/home/huey/Desktop/C/yolo_bytetrack/3rdparty/rga/include -isystem /home/huey/opencv-4.7.0/install/include/opencv4 
+
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/link.txt b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/link.txt
new file mode 100644
index 00000000..26b4953e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/link.txt
@@ -0,0 +1 @@
+/home/huey/linux-x86/arm/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++     CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o  -o yolo_bytetrack  -Wl,-rpath,/home/huey/Desktop/C/yolo_bytetrack/install/rknn_yolov5_1109_new_Linux/lib /home/huey/opencv-4.7.0/install/lib/libopencv_gapi.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_stitching.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_aruco.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_barcode.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_bgsegm.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_bioinspired.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_ccalib.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_dnn_objdetect.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_dnn_superres.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_dpm.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_face.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_fuzzy.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_hfs.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_img_hash.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_intensity_transform.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_line_descriptor.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_mcc.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_quality.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_rapid.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_reg.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_rgbd.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_saliency.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_stereo.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_structured_light.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_superres.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_surface_matching.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_tracking.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_videostab.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_wechat_qrcode.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_xfeatures2d.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_xobjdetect.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_xphoto.so.4.7.0 /home/huey/openssl/install/lib/libssl.so /home/huey/openssl/install/lib/libcrypto.so -lpthread ../3rdparty/librknn_api/armhf/librknn_api.so ../3rdparty/rga/lib/librga.so /home/huey/opencv-4.7.0/install/lib/libopencv_shape.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_highgui.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_datasets.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_plot.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_text.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_ml.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_phase_unwrapping.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_optflow.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_ximgproc.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_video.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_videoio.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_imgcodecs.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_objdetect.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_calib3d.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_dnn.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_features2d.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_flann.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_photo.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_imgproc.so.4.7.0 /home/huey/opencv-4.7.0/install/lib/libopencv_core.so.4.7.0 
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/progress.make b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/progress.make
new file mode 100644
index 00000000..2f823159
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/progress.make
@@ -0,0 +1,8 @@
+CMAKE_PROGRESS_1 = 1
+CMAKE_PROGRESS_2 = 2
+CMAKE_PROGRESS_3 = 3
+CMAKE_PROGRESS_4 = 4
+CMAKE_PROGRESS_5 = 5
+CMAKE_PROGRESS_6 = 6
+CMAKE_PROGRESS_7 = 7
+
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o
new file mode 100644
index 00000000..4d793baa
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o differ
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o
new file mode 100644
index 00000000..e0815c79
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o differ
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o
new file mode 100644
index 00000000..ea07efaf
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o differ
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o
new file mode 100644
index 00000000..b32eed07
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o differ
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o
new file mode 100644
index 00000000..b203f038
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o differ
diff --git a/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o
new file mode 100644
index 00000000..28fd4744
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o differ
diff --git a/C++/yolo_bytetrack_old/build/Makefile b/C++/yolo_bytetrack_old/build/Makefile
new file mode 100644
index 00000000..03dab491
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/Makefile
@@ -0,0 +1,328 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.16
+
+# Default target executed when no arguments are given to make.
+default_target: all
+
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+
+# Remove some rules from gmake that .SUFFIXES does not remove.
+SUFFIXES =
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+
+# Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+
+# A target that is always out of date.
+cmake_force:
+
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /usr/bin/cmake
+
+# The command to remove a file.
+RM = /usr/bin/cmake -E remove -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/huey/Desktop/C/yolo_bytetrack
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/huey/Desktop/C/yolo_bytetrack/build
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
+	/usr/bin/cmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..."
+	/usr/bin/cmake-gui -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+
+.PHONY : edit_cache/fast
+
+# The main all target
+all: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles/progress.marks
+	$(MAKE) -f CMakeFiles/Makefile2 all
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/huey/Desktop/C/yolo_bytetrack/build/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	$(MAKE) -f CMakeFiles/Makefile2 clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	$(MAKE) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	$(MAKE) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+#=============================================================================
+# Target rules for targets named yolo_bytetrack
+
+# Build rule for target.
+yolo_bytetrack: cmake_check_build_system
+	$(MAKE) -f CMakeFiles/Makefile2 yolo_bytetrack
+.PHONY : yolo_bytetrack
+
+# fast build rule for target.
+yolo_bytetrack/fast:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/build
+.PHONY : yolo_bytetrack/fast
+
+src/BYTETracker.o: src/BYTETracker.cpp.o
+
+.PHONY : src/BYTETracker.o
+
+# target to build an object file
+src/BYTETracker.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.o
+.PHONY : src/BYTETracker.cpp.o
+
+src/BYTETracker.i: src/BYTETracker.cpp.i
+
+.PHONY : src/BYTETracker.i
+
+# target to preprocess a source file
+src/BYTETracker.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.i
+.PHONY : src/BYTETracker.cpp.i
+
+src/BYTETracker.s: src/BYTETracker.cpp.s
+
+.PHONY : src/BYTETracker.s
+
+# target to generate assembly for a file
+src/BYTETracker.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/BYTETracker.cpp.s
+.PHONY : src/BYTETracker.cpp.s
+
+src/STrack.o: src/STrack.cpp.o
+
+.PHONY : src/STrack.o
+
+# target to build an object file
+src/STrack.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.o
+.PHONY : src/STrack.cpp.o
+
+src/STrack.i: src/STrack.cpp.i
+
+.PHONY : src/STrack.i
+
+# target to preprocess a source file
+src/STrack.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.i
+.PHONY : src/STrack.cpp.i
+
+src/STrack.s: src/STrack.cpp.s
+
+.PHONY : src/STrack.s
+
+# target to generate assembly for a file
+src/STrack.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/STrack.cpp.s
+.PHONY : src/STrack.cpp.s
+
+src/bytetrack.o: src/bytetrack.cpp.o
+
+.PHONY : src/bytetrack.o
+
+# target to build an object file
+src/bytetrack.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.o
+.PHONY : src/bytetrack.cpp.o
+
+src/bytetrack.i: src/bytetrack.cpp.i
+
+.PHONY : src/bytetrack.i
+
+# target to preprocess a source file
+src/bytetrack.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.i
+.PHONY : src/bytetrack.cpp.i
+
+src/bytetrack.s: src/bytetrack.cpp.s
+
+.PHONY : src/bytetrack.s
+
+# target to generate assembly for a file
+src/bytetrack.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/bytetrack.cpp.s
+.PHONY : src/bytetrack.cpp.s
+
+src/kalmanFilter.o: src/kalmanFilter.cpp.o
+
+.PHONY : src/kalmanFilter.o
+
+# target to build an object file
+src/kalmanFilter.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.o
+.PHONY : src/kalmanFilter.cpp.o
+
+src/kalmanFilter.i: src/kalmanFilter.cpp.i
+
+.PHONY : src/kalmanFilter.i
+
+# target to preprocess a source file
+src/kalmanFilter.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.i
+.PHONY : src/kalmanFilter.cpp.i
+
+src/kalmanFilter.s: src/kalmanFilter.cpp.s
+
+.PHONY : src/kalmanFilter.s
+
+# target to generate assembly for a file
+src/kalmanFilter.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/kalmanFilter.cpp.s
+.PHONY : src/kalmanFilter.cpp.s
+
+src/lapjv.o: src/lapjv.cpp.o
+
+.PHONY : src/lapjv.o
+
+# target to build an object file
+src/lapjv.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.o
+.PHONY : src/lapjv.cpp.o
+
+src/lapjv.i: src/lapjv.cpp.i
+
+.PHONY : src/lapjv.i
+
+# target to preprocess a source file
+src/lapjv.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.i
+.PHONY : src/lapjv.cpp.i
+
+src/lapjv.s: src/lapjv.cpp.s
+
+.PHONY : src/lapjv.s
+
+# target to generate assembly for a file
+src/lapjv.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/lapjv.cpp.s
+.PHONY : src/lapjv.cpp.s
+
+src/utils.o: src/utils.cpp.o
+
+.PHONY : src/utils.o
+
+# target to build an object file
+src/utils.cpp.o:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.o
+.PHONY : src/utils.cpp.o
+
+src/utils.i: src/utils.cpp.i
+
+.PHONY : src/utils.i
+
+# target to preprocess a source file
+src/utils.cpp.i:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.i
+.PHONY : src/utils.cpp.i
+
+src/utils.s: src/utils.cpp.s
+
+.PHONY : src/utils.s
+
+# target to generate assembly for a file
+src/utils.cpp.s:
+	$(MAKE) -f CMakeFiles/yolo_bytetrack.dir/build.make CMakeFiles/yolo_bytetrack.dir/src/utils.cpp.s
+.PHONY : src/utils.cpp.s
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... rebuild_cache"
+	@echo "... edit_cache"
+	@echo "... yolo_bytetrack"
+	@echo "... src/BYTETracker.o"
+	@echo "... src/BYTETracker.i"
+	@echo "... src/BYTETracker.s"
+	@echo "... src/STrack.o"
+	@echo "... src/STrack.i"
+	@echo "... src/STrack.s"
+	@echo "... src/bytetrack.o"
+	@echo "... src/bytetrack.i"
+	@echo "... src/bytetrack.s"
+	@echo "... src/kalmanFilter.o"
+	@echo "... src/kalmanFilter.i"
+	@echo "... src/kalmanFilter.s"
+	@echo "... src/lapjv.o"
+	@echo "... src/lapjv.i"
+	@echo "... src/lapjv.s"
+	@echo "... src/utils.o"
+	@echo "... src/utils.i"
+	@echo "... src/utils.s"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/C++/yolo_bytetrack_old/build/cmake_install.cmake b/C++/yolo_bytetrack_old/build/cmake_install.cmake
new file mode 100644
index 00000000..b11ea028
--- /dev/null
+++ b/C++/yolo_bytetrack_old/build/cmake_install.cmake
@@ -0,0 +1,49 @@
+# Install script for directory: /home/huey/Desktop/C/yolo_bytetrack
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/home/huey/Desktop/C/yolo_bytetrack/install/rknn_yolov5_1109_new_Linux")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "1")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+if(CMAKE_INSTALL_COMPONENT)
+  set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
+else()
+  set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+file(WRITE "/home/huey/Desktop/C/yolo_bytetrack/build/${CMAKE_INSTALL_MANIFEST}"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
diff --git a/C++/yolo_bytetrack_old/build/yolo_bytetrack b/C++/yolo_bytetrack_old/build/yolo_bytetrack
new file mode 100644
index 00000000..61ff5252
Binary files /dev/null and b/C++/yolo_bytetrack_old/build/yolo_bytetrack differ
diff --git a/C++/yolo_bytetrack_old/include/BYTETracker.h b/C++/yolo_bytetrack_old/include/BYTETracker.h
new file mode 100644
index 00000000..477c3344
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/BYTETracker.h
@@ -0,0 +1,49 @@
+#pragma once  //避免头文件重复包含
+
+#include "STrack.h"
+
+struct Object
+{
+    cv::Rect_<float> rect;
+    int label;
+    float prob;
+};
+
+class BYTETracker
+{
+public:
+	BYTETracker(int frame_rate = 30, int track_buffer = 30);
+	~BYTETracker();
+
+	vector<STrack> update(const vector<Object>& objects);
+	cv::Scalar get_color(int idx);
+
+private:
+	vector<STrack*> joint_stracks(vector<STrack*> &tlista, vector<STrack> &tlistb);
+	vector<STrack> joint_stracks(vector<STrack> &tlista, vector<STrack> &tlistb);
+
+	vector<STrack> sub_stracks(vector<STrack> &tlista, vector<STrack> &tlistb);
+	void remove_duplicate_stracks(vector<STrack> &resa, vector<STrack> &resb, vector<STrack> &stracksa, vector<STrack> &stracksb);
+
+	void linear_assignment(vector<vector<float> > &cost_matrix, int cost_matrix_size, int cost_matrix_size_size, float thresh,
+		vector<vector<int> > &matches, vector<int> &unmatched_a, vector<int> &unmatched_b);
+	vector<vector<float> > iou_distance(vector<STrack*> &atracks, vector<STrack> &btracks, int &dist_size, int &dist_size_size);
+	vector<vector<float> > iou_distance(vector<STrack> &atracks, vector<STrack> &btracks);
+	vector<vector<float> > ious(vector<vector<float> > &atlbrs, vector<vector<float> > &btlbrs);
+
+	double lapjv(const vector<vector<float> > &cost, vector<int> &rowsol, vector<int> &colsol, 
+		bool extend_cost = false, float cost_limit = LONG_MAX, bool return_cost = true);
+
+private:
+
+	float track_thresh;
+	float high_thresh;
+	float match_thresh;
+	int frame_id;
+	int max_time_lost;
+
+	vector<STrack> tracked_stracks;
+	vector<STrack> lost_stracks;
+	vector<STrack> removed_stracks;
+	byte_kalman::KalmanFilter kalman_filter;
+};
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/include/Eigen/Cholesky b/C++/yolo_bytetrack_old/include/Eigen/Cholesky
new file mode 100644
index 00000000..a318ceb7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/Cholesky
@@ -0,0 +1,45 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLESKY_MODULE_H
+#define EIGEN_CHOLESKY_MODULE_H
+
+#include "Core"
+#include "Jacobi"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Cholesky_Module Cholesky module
+  *
+  *
+  *
+  * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
+  * Those decompositions are also accessible via the following methods:
+  *  - MatrixBase::llt()
+  *  - MatrixBase::ldlt()
+  *  - SelfAdjointView::llt()
+  *  - SelfAdjointView::ldlt()
+  *
+  * \code
+  * #include <Eigen/Cholesky>
+  * \endcode
+  */
+
+#include "src/Cholesky/LLT.h"
+#include "src/Cholesky/LDLT.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/Cholesky/LLT_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CHOLESKY_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/CholmodSupport b/C++/yolo_bytetrack_old/include/Eigen/CholmodSupport
new file mode 100644
index 00000000..bed8924d
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/CholmodSupport
@@ -0,0 +1,48 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLMODSUPPORT_MODULE_H
+#define EIGEN_CHOLMODSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+extern "C" {
+  #include <cholmod.h>
+}
+
+/** \ingroup Support_modules
+  * \defgroup CholmodSupport_Module CholmodSupport module
+  *
+  * This module provides an interface to the Cholmod library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
+  * It provides the two following main factorization classes:
+  * - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization.
+  * - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial).
+  *
+  * For the sake of completeness, this module also propose the two following classes:
+  * - class CholmodSimplicialLLT
+  * - class CholmodSimplicialLDLT
+  * Note that these classes does not bring any particular advantage compared to the built-in
+  * SimplicialLLT and SimplicialLDLT factorization classes.
+  *
+  * \code
+  * #include <Eigen/CholmodSupport>
+  * \endcode
+  *
+  * In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies.
+  * The dependencies depend on how cholmod has been compiled.
+  * For a cmake based project, you can use our FindCholmod.cmake module to help you in this task.
+  *
+  */
+
+#include "src/CholmodSupport/CholmodSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CHOLMODSUPPORT_MODULE_H
+
diff --git a/C++/yolo_bytetrack_old/include/Eigen/Core b/C++/yolo_bytetrack_old/include/Eigen/Core
new file mode 100644
index 00000000..5921e15f
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/Core
@@ -0,0 +1,384 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2011 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CORE_H
+#define EIGEN_CORE_H
+
+// first thing Eigen does: stop the compiler from reporting useless warnings.
+#include "src/Core/util/DisableStupidWarnings.h"
+
+// then include this file where all our macros are defined. It's really important to do it first because
+// it's where we do all the compiler/OS/arch detections and define most defaults.
+#include "src/Core/util/Macros.h"
+
+// This detects SSE/AVX/NEON/etc. and configure alignment settings
+#include "src/Core/util/ConfigureVectorization.h"
+
+// We need cuda_runtime.h/hip_runtime.h to ensure that
+// the EIGEN_USING_STD macro works properly on the device side
+#if defined(EIGEN_CUDACC)
+  #include <cuda_runtime.h>
+#elif defined(EIGEN_HIPCC)
+  #include <hip/hip_runtime.h>
+#endif
+
+
+#ifdef EIGEN_EXCEPTIONS
+  #include <new>
+#endif
+
+// Disable the ipa-cp-clone optimization flag with MinGW 6.x or newer (enabled by default with -O3)
+// See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details.
+#if EIGEN_COMP_MINGW && EIGEN_GNUC_AT_LEAST(4,6) && EIGEN_GNUC_AT_MOST(5,5)
+  #pragma GCC optimize ("-fno-ipa-cp-clone")
+#endif
+
+// Prevent ICC from specializing std::complex operators that silently fail
+// on device. This allows us to use our own device-compatible specializations
+// instead.
+#if defined(EIGEN_COMP_ICC) && defined(EIGEN_GPU_COMPILE_PHASE) \
+    && !defined(_OVERRIDE_COMPLEX_SPECIALIZATION_)
+#define _OVERRIDE_COMPLEX_SPECIALIZATION_ 1
+#endif
+#include <complex>
+
+// this include file manages BLAS and MKL related macros
+// and inclusion of their respective header files
+#include "src/Core/util/MKL_support.h"
+
+
+#if defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)
+  #define EIGEN_HAS_GPU_FP16
+#endif
+
+#if defined(EIGEN_HAS_CUDA_BF16) || defined(EIGEN_HAS_HIP_BF16)
+  #define EIGEN_HAS_GPU_BF16
+#endif
+
+#if (defined _OPENMP) && (!defined EIGEN_DONT_PARALLELIZE)
+  #define EIGEN_HAS_OPENMP
+#endif
+
+#ifdef EIGEN_HAS_OPENMP
+#include <omp.h>
+#endif
+
+// MSVC for windows mobile does not have the errno.h file
+#if !(EIGEN_COMP_MSVC && EIGEN_OS_WINCE) && !EIGEN_COMP_ARM
+#define EIGEN_HAS_ERRNO
+#endif
+
+#ifdef EIGEN_HAS_ERRNO
+#include <cerrno>
+#endif
+#include <cstddef>
+#include <cstdlib>
+#include <cmath>
+#include <cassert>
+#include <functional>
+#include <sstream>
+#ifndef EIGEN_NO_IO
+  #include <iosfwd>
+#endif
+#include <cstring>
+#include <string>
+#include <limits>
+#include <climits> // for CHAR_BIT
+// for min/max:
+#include <algorithm>
+
+#if EIGEN_HAS_CXX11
+#include <array>
+#endif
+
+// for std::is_nothrow_move_assignable
+#ifdef EIGEN_INCLUDE_TYPE_TRAITS
+#include <type_traits>
+#endif
+
+// for outputting debug info
+#ifdef EIGEN_DEBUG_ASSIGN
+#include <iostream>
+#endif
+
+// required for __cpuid, needs to be included after cmath
+#if EIGEN_COMP_MSVC && EIGEN_ARCH_i386_OR_x86_64 && !EIGEN_OS_WINCE
+  #include <intrin.h>
+#endif
+
+#if defined(EIGEN_USE_SYCL)
+  #undef min
+  #undef max
+  #undef isnan
+  #undef isinf
+  #undef isfinite
+  #include <CL/sycl.hpp>
+  #include <map>
+  #include <memory>
+  #include <utility>
+  #include <thread>
+  #ifndef EIGEN_SYCL_LOCAL_THREAD_DIM0
+  #define EIGEN_SYCL_LOCAL_THREAD_DIM0 16
+  #endif
+  #ifndef EIGEN_SYCL_LOCAL_THREAD_DIM1
+  #define EIGEN_SYCL_LOCAL_THREAD_DIM1 16
+  #endif
+#endif
+
+
+#if defined EIGEN2_SUPPORT_STAGE40_FULL_EIGEN3_STRICTNESS || defined EIGEN2_SUPPORT_STAGE30_FULL_EIGEN3_API || defined EIGEN2_SUPPORT_STAGE20_RESOLVE_API_CONFLICTS || defined EIGEN2_SUPPORT_STAGE10_FULL_EIGEN2_API || defined EIGEN2_SUPPORT
+// This will generate an error message:
+#error Eigen2-support is only available up to version 3.2. Please go to "http://eigen.tuxfamily.org/index.php?title=Eigen2" for further information
+#endif
+
+namespace Eigen {
+
+// we use size_t frequently and we'll never remember to prepend it with std:: every time just to
+// ensure QNX/QCC support
+using std::size_t;
+// gcc 4.6.0 wants std:: for ptrdiff_t
+using std::ptrdiff_t;
+
+}
+
+/** \defgroup Core_Module Core module
+  * This is the main module of Eigen providing dense matrix and vector support
+  * (both fixed and dynamic size) with all the features corresponding to a BLAS library
+  * and much more...
+  *
+  * \code
+  * #include <Eigen/Core>
+  * \endcode
+  */
+
+#include "src/Core/util/Constants.h"
+#include "src/Core/util/Meta.h"
+#include "src/Core/util/ForwardDeclarations.h"
+#include "src/Core/util/StaticAssert.h"
+#include "src/Core/util/XprHelper.h"
+#include "src/Core/util/Memory.h"
+#include "src/Core/util/IntegralConstant.h"
+#include "src/Core/util/SymbolicIndex.h"
+
+#include "src/Core/NumTraits.h"
+#include "src/Core/MathFunctions.h"
+#include "src/Core/GenericPacketMath.h"
+#include "src/Core/MathFunctionsImpl.h"
+#include "src/Core/arch/Default/ConjHelper.h"
+// Generic half float support
+#include "src/Core/arch/Default/Half.h"
+#include "src/Core/arch/Default/BFloat16.h"
+#include "src/Core/arch/Default/TypeCasting.h"
+#include "src/Core/arch/Default/GenericPacketMathFunctionsFwd.h"
+
+#if defined EIGEN_VECTORIZE_AVX512
+  #include "src/Core/arch/SSE/PacketMath.h"
+  #include "src/Core/arch/SSE/TypeCasting.h"
+  #include "src/Core/arch/SSE/Complex.h"
+  #include "src/Core/arch/AVX/PacketMath.h"
+  #include "src/Core/arch/AVX/TypeCasting.h"
+  #include "src/Core/arch/AVX/Complex.h"
+  #include "src/Core/arch/AVX512/PacketMath.h"
+  #include "src/Core/arch/AVX512/TypeCasting.h"
+  #include "src/Core/arch/AVX512/Complex.h"
+  #include "src/Core/arch/SSE/MathFunctions.h"
+  #include "src/Core/arch/AVX/MathFunctions.h"
+  #include "src/Core/arch/AVX512/MathFunctions.h"
+#elif defined EIGEN_VECTORIZE_AVX
+  // Use AVX for floats and doubles, SSE for integers
+  #include "src/Core/arch/SSE/PacketMath.h"
+  #include "src/Core/arch/SSE/TypeCasting.h"
+  #include "src/Core/arch/SSE/Complex.h"
+  #include "src/Core/arch/AVX/PacketMath.h"
+  #include "src/Core/arch/AVX/TypeCasting.h"
+  #include "src/Core/arch/AVX/Complex.h"
+  #include "src/Core/arch/SSE/MathFunctions.h"
+  #include "src/Core/arch/AVX/MathFunctions.h"
+#elif defined EIGEN_VECTORIZE_SSE
+  #include "src/Core/arch/SSE/PacketMath.h"
+  #include "src/Core/arch/SSE/TypeCasting.h"
+  #include "src/Core/arch/SSE/MathFunctions.h"
+  #include "src/Core/arch/SSE/Complex.h"
+#elif defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)
+  #include "src/Core/arch/AltiVec/PacketMath.h"
+  #include "src/Core/arch/AltiVec/MathFunctions.h"
+  #include "src/Core/arch/AltiVec/Complex.h"
+#elif defined EIGEN_VECTORIZE_NEON
+  #include "src/Core/arch/NEON/PacketMath.h"
+  #include "src/Core/arch/NEON/TypeCasting.h"
+  #include "src/Core/arch/NEON/MathFunctions.h"
+  #include "src/Core/arch/NEON/Complex.h"
+#elif defined EIGEN_VECTORIZE_SVE
+  #include "src/Core/arch/SVE/PacketMath.h"
+  #include "src/Core/arch/SVE/TypeCasting.h"
+  #include "src/Core/arch/SVE/MathFunctions.h"
+#elif defined EIGEN_VECTORIZE_ZVECTOR
+  #include "src/Core/arch/ZVector/PacketMath.h"
+  #include "src/Core/arch/ZVector/MathFunctions.h"
+  #include "src/Core/arch/ZVector/Complex.h"
+#elif defined EIGEN_VECTORIZE_MSA
+  #include "src/Core/arch/MSA/PacketMath.h"
+  #include "src/Core/arch/MSA/MathFunctions.h"
+  #include "src/Core/arch/MSA/Complex.h"
+#endif
+
+#if defined EIGEN_VECTORIZE_GPU
+  #include "src/Core/arch/GPU/PacketMath.h"
+  #include "src/Core/arch/GPU/MathFunctions.h"
+  #include "src/Core/arch/GPU/TypeCasting.h"
+#endif
+
+#if defined(EIGEN_USE_SYCL)
+  #include "src/Core/arch/SYCL/SyclMemoryModel.h"
+  #include "src/Core/arch/SYCL/InteropHeaders.h"
+#if !defined(EIGEN_DONT_VECTORIZE_SYCL)
+  #include "src/Core/arch/SYCL/PacketMath.h"
+  #include "src/Core/arch/SYCL/MathFunctions.h"
+  #include "src/Core/arch/SYCL/TypeCasting.h"
+#endif
+#endif
+
+#include "src/Core/arch/Default/Settings.h"
+// This file provides generic implementations valid for scalar as well
+#include "src/Core/arch/Default/GenericPacketMathFunctions.h"
+
+#include "src/Core/functors/TernaryFunctors.h"
+#include "src/Core/functors/BinaryFunctors.h"
+#include "src/Core/functors/UnaryFunctors.h"
+#include "src/Core/functors/NullaryFunctors.h"
+#include "src/Core/functors/StlFunctors.h"
+#include "src/Core/functors/AssignmentFunctors.h"
+
+// Specialized functors to enable the processing of complex numbers
+// on CUDA devices
+#ifdef EIGEN_CUDACC
+#include "src/Core/arch/CUDA/Complex.h"
+#endif
+
+#include "src/Core/util/IndexedViewHelper.h"
+#include "src/Core/util/ReshapedHelper.h"
+#include "src/Core/ArithmeticSequence.h"
+#ifndef EIGEN_NO_IO
+  #include "src/Core/IO.h"
+#endif
+#include "src/Core/DenseCoeffsBase.h"
+#include "src/Core/DenseBase.h"
+#include "src/Core/MatrixBase.h"
+#include "src/Core/EigenBase.h"
+
+#include "src/Core/Product.h"
+#include "src/Core/CoreEvaluators.h"
+#include "src/Core/AssignEvaluator.h"
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN // work around Doxygen bug triggered by Assign.h r814874
+                                // at least confirmed with Doxygen 1.5.5 and 1.5.6
+  #include "src/Core/Assign.h"
+#endif
+
+#include "src/Core/ArrayBase.h"
+#include "src/Core/util/BlasUtil.h"
+#include "src/Core/DenseStorage.h"
+#include "src/Core/NestByValue.h"
+
+// #include "src/Core/ForceAlignedAccess.h"
+
+#include "src/Core/ReturnByValue.h"
+#include "src/Core/NoAlias.h"
+#include "src/Core/PlainObjectBase.h"
+#include "src/Core/Matrix.h"
+#include "src/Core/Array.h"
+#include "src/Core/CwiseTernaryOp.h"
+#include "src/Core/CwiseBinaryOp.h"
+#include "src/Core/CwiseUnaryOp.h"
+#include "src/Core/CwiseNullaryOp.h"
+#include "src/Core/CwiseUnaryView.h"
+#include "src/Core/SelfCwiseBinaryOp.h"
+#include "src/Core/Dot.h"
+#include "src/Core/StableNorm.h"
+#include "src/Core/Stride.h"
+#include "src/Core/MapBase.h"
+#include "src/Core/Map.h"
+#include "src/Core/Ref.h"
+#include "src/Core/Block.h"
+#include "src/Core/VectorBlock.h"
+#include "src/Core/IndexedView.h"
+#include "src/Core/Reshaped.h"
+#include "src/Core/Transpose.h"
+#include "src/Core/DiagonalMatrix.h"
+#include "src/Core/Diagonal.h"
+#include "src/Core/DiagonalProduct.h"
+#include "src/Core/Redux.h"
+#include "src/Core/Visitor.h"
+#include "src/Core/Fuzzy.h"
+#include "src/Core/Swap.h"
+#include "src/Core/CommaInitializer.h"
+#include "src/Core/GeneralProduct.h"
+#include "src/Core/Solve.h"
+#include "src/Core/Inverse.h"
+#include "src/Core/SolverBase.h"
+#include "src/Core/PermutationMatrix.h"
+#include "src/Core/Transpositions.h"
+#include "src/Core/TriangularMatrix.h"
+#include "src/Core/SelfAdjointView.h"
+#include "src/Core/products/GeneralBlockPanelKernel.h"
+#include "src/Core/products/Parallelizer.h"
+#include "src/Core/ProductEvaluators.h"
+#include "src/Core/products/GeneralMatrixVector.h"
+#include "src/Core/products/GeneralMatrixMatrix.h"
+#include "src/Core/SolveTriangular.h"
+#include "src/Core/products/GeneralMatrixMatrixTriangular.h"
+#include "src/Core/products/SelfadjointMatrixVector.h"
+#include "src/Core/products/SelfadjointMatrixMatrix.h"
+#include "src/Core/products/SelfadjointProduct.h"
+#include "src/Core/products/SelfadjointRank2Update.h"
+#include "src/Core/products/TriangularMatrixVector.h"
+#include "src/Core/products/TriangularMatrixMatrix.h"
+#include "src/Core/products/TriangularSolverMatrix.h"
+#include "src/Core/products/TriangularSolverVector.h"
+#include "src/Core/BandMatrix.h"
+#include "src/Core/CoreIterators.h"
+#include "src/Core/ConditionEstimator.h"
+
+#if defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)
+  #include "src/Core/arch/AltiVec/MatrixProduct.h"
+#elif defined EIGEN_VECTORIZE_NEON
+  #include "src/Core/arch/NEON/GeneralBlockPanelKernel.h"
+#endif
+
+#include "src/Core/BooleanRedux.h"
+#include "src/Core/Select.h"
+#include "src/Core/VectorwiseOp.h"
+#include "src/Core/PartialReduxEvaluator.h"
+#include "src/Core/Random.h"
+#include "src/Core/Replicate.h"
+#include "src/Core/Reverse.h"
+#include "src/Core/ArrayWrapper.h"
+#include "src/Core/StlIterators.h"
+
+#ifdef EIGEN_USE_BLAS
+#include "src/Core/products/GeneralMatrixMatrix_BLAS.h"
+#include "src/Core/products/GeneralMatrixVector_BLAS.h"
+#include "src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h"
+#include "src/Core/products/SelfadjointMatrixMatrix_BLAS.h"
+#include "src/Core/products/SelfadjointMatrixVector_BLAS.h"
+#include "src/Core/products/TriangularMatrixMatrix_BLAS.h"
+#include "src/Core/products/TriangularMatrixVector_BLAS.h"
+#include "src/Core/products/TriangularSolverMatrix_BLAS.h"
+#endif // EIGEN_USE_BLAS
+
+#ifdef EIGEN_USE_MKL_VML
+#include "src/Core/Assign_MKL.h"
+#endif
+
+#include "src/Core/GlobalFunctions.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CORE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/Dense b/C++/yolo_bytetrack_old/include/Eigen/Dense
new file mode 100644
index 00000000..5768910b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/Dense
@@ -0,0 +1,7 @@
+#include "Core"
+#include "LU"
+#include "Cholesky"
+#include "QR"
+#include "SVD"
+#include "Geometry"
+#include "Eigenvalues"
diff --git a/C++/yolo_bytetrack_old/include/Eigen/Eigen b/C++/yolo_bytetrack_old/include/Eigen/Eigen
new file mode 100644
index 00000000..654c8dc6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/Eigen
@@ -0,0 +1,2 @@
+#include "Dense"
+#include "Sparse"
diff --git a/C++/yolo_bytetrack_old/include/Eigen/Eigenvalues b/C++/yolo_bytetrack_old/include/Eigen/Eigenvalues
new file mode 100644
index 00000000..5467a2e7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/Eigenvalues
@@ -0,0 +1,60 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EIGENVALUES_MODULE_H
+#define EIGEN_EIGENVALUES_MODULE_H
+
+#include "Core"
+
+#include "Cholesky"
+#include "Jacobi"
+#include "Householder"
+#include "LU"
+#include "Geometry"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Eigenvalues_Module Eigenvalues module
+  *
+  *
+  *
+  * This module mainly provides various eigenvalue solvers.
+  * This module also provides some MatrixBase methods, including:
+  *  - MatrixBase::eigenvalues(),
+  *  - MatrixBase::operatorNorm()
+  *
+  * \code
+  * #include <Eigen/Eigenvalues>
+  * \endcode
+  */
+
+#include "src/misc/RealSvd2x2.h"
+#include "src/Eigenvalues/Tridiagonalization.h"
+#include "src/Eigenvalues/RealSchur.h"
+#include "src/Eigenvalues/EigenSolver.h"
+#include "src/Eigenvalues/SelfAdjointEigenSolver.h"
+#include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h"
+#include "src/Eigenvalues/HessenbergDecomposition.h"
+#include "src/Eigenvalues/ComplexSchur.h"
+#include "src/Eigenvalues/ComplexEigenSolver.h"
+#include "src/Eigenvalues/RealQZ.h"
+#include "src/Eigenvalues/GeneralizedEigenSolver.h"
+#include "src/Eigenvalues/MatrixBaseEigenvalues.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/Eigenvalues/RealSchur_LAPACKE.h"
+#include "src/Eigenvalues/ComplexSchur_LAPACKE.h"
+#include "src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_EIGENVALUES_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/Geometry b/C++/yolo_bytetrack_old/include/Eigen/Geometry
new file mode 100644
index 00000000..bc78110a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/Geometry
@@ -0,0 +1,59 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GEOMETRY_MODULE_H
+#define EIGEN_GEOMETRY_MODULE_H
+
+#include "Core"
+
+#include "SVD"
+#include "LU"
+#include <limits>
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Geometry_Module Geometry module
+  *
+  * This module provides support for:
+  *  - fixed-size homogeneous transformations
+  *  - translation, scaling, 2D and 3D rotations
+  *  - \link Quaternion quaternions \endlink
+  *  - cross products (\ref MatrixBase::cross, \ref MatrixBase::cross3)
+  *  - orthognal vector generation (\ref MatrixBase::unitOrthogonal)
+  *  - some linear components: \link ParametrizedLine parametrized-lines \endlink and \link Hyperplane hyperplanes \endlink
+  *  - \link AlignedBox axis aligned bounding boxes \endlink
+  *  - \link umeyama least-square transformation fitting \endlink
+  *
+  * \code
+  * #include <Eigen/Geometry>
+  * \endcode
+  */
+
+#include "src/Geometry/OrthoMethods.h"
+#include "src/Geometry/EulerAngles.h"
+
+#include "src/Geometry/Homogeneous.h"
+#include "src/Geometry/RotationBase.h"
+#include "src/Geometry/Rotation2D.h"
+#include "src/Geometry/Quaternion.h"
+#include "src/Geometry/AngleAxis.h"
+#include "src/Geometry/Transform.h"
+#include "src/Geometry/Translation.h"
+#include "src/Geometry/Scaling.h"
+#include "src/Geometry/Hyperplane.h"
+#include "src/Geometry/ParametrizedLine.h"
+#include "src/Geometry/AlignedBox.h"
+#include "src/Geometry/Umeyama.h"
+
+// Use the SSE optimized version whenever possible.
+#if (defined EIGEN_VECTORIZE_SSE) || (defined EIGEN_VECTORIZE_NEON)
+#include "src/Geometry/arch/Geometry_SIMD.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_GEOMETRY_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/Householder b/C++/yolo_bytetrack_old/include/Eigen/Householder
new file mode 100644
index 00000000..f2fa7996
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/Householder
@@ -0,0 +1,29 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOUSEHOLDER_MODULE_H
+#define EIGEN_HOUSEHOLDER_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Householder_Module Householder module
+  * This module provides Householder transformations.
+  *
+  * \code
+  * #include <Eigen/Householder>
+  * \endcode
+  */
+
+#include "src/Householder/Householder.h"
+#include "src/Householder/HouseholderSequence.h"
+#include "src/Householder/BlockHouseholder.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_HOUSEHOLDER_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/IterativeLinearSolvers b/C++/yolo_bytetrack_old/include/Eigen/IterativeLinearSolvers
new file mode 100644
index 00000000..957d5750
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/IterativeLinearSolvers
@@ -0,0 +1,48 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
+#define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
+
+#include "SparseCore"
+#include "OrderingMethods"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** 
+  * \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module
+  *
+  * This module currently provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a squared matrix, usually very large and sparse.
+  * Those solvers are accessible via the following classes:
+  *  - ConjugateGradient for selfadjoint (hermitian) matrices,
+  *  - LeastSquaresConjugateGradient for rectangular least-square problems,
+  *  - BiCGSTAB for general square matrices.
+  *
+  * These iterative solvers are associated with some preconditioners:
+  *  - IdentityPreconditioner - not really useful
+  *  - DiagonalPreconditioner - also called Jacobi preconditioner, work very well on diagonal dominant matrices.
+  *  - IncompleteLUT - incomplete LU factorization with dual thresholding
+  *
+  * Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport.
+  *
+    \code
+    #include <Eigen/IterativeLinearSolvers>
+    \endcode
+  */
+
+#include "src/IterativeLinearSolvers/SolveWithGuess.h"
+#include "src/IterativeLinearSolvers/IterativeSolverBase.h"
+#include "src/IterativeLinearSolvers/BasicPreconditioners.h"
+#include "src/IterativeLinearSolvers/ConjugateGradient.h"
+#include "src/IterativeLinearSolvers/LeastSquareConjugateGradient.h"
+#include "src/IterativeLinearSolvers/BiCGSTAB.h"
+#include "src/IterativeLinearSolvers/IncompleteLUT.h"
+#include "src/IterativeLinearSolvers/IncompleteCholesky.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/Jacobi b/C++/yolo_bytetrack_old/include/Eigen/Jacobi
new file mode 100644
index 00000000..43edc7a1
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/Jacobi
@@ -0,0 +1,32 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_JACOBI_MODULE_H
+#define EIGEN_JACOBI_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Jacobi_Module Jacobi module
+  * This module provides Jacobi and Givens rotations.
+  *
+  * \code
+  * #include <Eigen/Jacobi>
+  * \endcode
+  *
+  * In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation:
+  *  - MatrixBase::applyOnTheLeft()
+  *  - MatrixBase::applyOnTheRight().
+  */
+
+#include "src/Jacobi/Jacobi.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_JACOBI_MODULE_H
+
diff --git a/C++/yolo_bytetrack_old/include/Eigen/KLUSupport b/C++/yolo_bytetrack_old/include/Eigen/KLUSupport
new file mode 100644
index 00000000..b23d9053
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/KLUSupport
@@ -0,0 +1,41 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_KLUSUPPORT_MODULE_H
+#define EIGEN_KLUSUPPORT_MODULE_H
+
+#include <Eigen/SparseCore>
+
+#include <Eigen/src/Core/util/DisableStupidWarnings.h>
+
+extern "C" {
+#include <btf.h>
+#include <klu.h>
+   }
+
+/** \ingroup Support_modules
+  * \defgroup KLUSupport_Module KLUSupport module
+  *
+  * This module provides an interface to the KLU library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
+  * It provides the following factorization class:
+  * - class KLU: a sparse LU factorization, well-suited for circuit simulation.
+  *
+  * \code
+  * #include <Eigen/KLUSupport>
+  * \endcode
+  *
+  * In order to use this module, the klu and btf headers must be accessible from the include paths, and your binary must be linked to the klu library and its dependencies.
+  * The dependencies depend on how umfpack has been compiled.
+  * For a cmake based project, you can use our FindKLU.cmake module to help you in this task.
+  *
+  */
+
+#include "src/KLUSupport/KLUSupport.h"
+
+#include <Eigen/src/Core/util/ReenableStupidWarnings.h>
+
+#endif // EIGEN_KLUSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/LU b/C++/yolo_bytetrack_old/include/Eigen/LU
new file mode 100644
index 00000000..1236ceb0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/LU
@@ -0,0 +1,47 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LU_MODULE_H
+#define EIGEN_LU_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup LU_Module LU module
+  * This module includes %LU decomposition and related notions such as matrix inversion and determinant.
+  * This module defines the following MatrixBase methods:
+  *  - MatrixBase::inverse()
+  *  - MatrixBase::determinant()
+  *
+  * \code
+  * #include <Eigen/LU>
+  * \endcode
+  */
+
+#include "src/misc/Kernel.h"
+#include "src/misc/Image.h"
+#include "src/LU/FullPivLU.h"
+#include "src/LU/PartialPivLU.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/LU/PartialPivLU_LAPACKE.h"
+#endif
+#include "src/LU/Determinant.h"
+#include "src/LU/InverseImpl.h"
+
+#if defined EIGEN_VECTORIZE_SSE || defined EIGEN_VECTORIZE_NEON
+  #include "src/LU/arch/InverseSize4.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_LU_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/MetisSupport b/C++/yolo_bytetrack_old/include/Eigen/MetisSupport
new file mode 100644
index 00000000..85c41bf3
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/MetisSupport
@@ -0,0 +1,35 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_METISSUPPORT_MODULE_H
+#define EIGEN_METISSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+extern "C" {
+#include <metis.h>
+}
+
+
+/** \ingroup Support_modules
+  * \defgroup MetisSupport_Module MetisSupport module
+  *
+  * \code
+  * #include <Eigen/MetisSupport>
+  * \endcode
+  * This module defines an interface to the METIS reordering package (http://glaros.dtc.umn.edu/gkhome/views/metis). 
+  * It can be used just as any other built-in method as explained in \link OrderingMethods_Module here. \endlink
+  */
+
+
+#include "src/MetisSupport/MetisSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_METISSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/OrderingMethods b/C++/yolo_bytetrack_old/include/Eigen/OrderingMethods
new file mode 100644
index 00000000..29691a62
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/OrderingMethods
@@ -0,0 +1,70 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ORDERINGMETHODS_MODULE_H
+#define EIGEN_ORDERINGMETHODS_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** 
+  * \defgroup OrderingMethods_Module OrderingMethods module
+  *
+  * This module is currently for internal use only
+  * 
+  * It defines various built-in and external ordering methods for sparse matrices. 
+  * They are typically used to reduce the number of elements during 
+  * the sparse matrix decomposition (LLT, LU, QR).
+  * Precisely, in a preprocessing step, a permutation matrix P is computed using 
+  * those ordering methods and applied to the columns of the matrix. 
+  * Using for instance the sparse Cholesky decomposition, it is expected that 
+  * the nonzeros elements in LLT(A*P) will be much smaller than that in LLT(A).
+  * 
+  * 
+  * Usage : 
+  * \code
+  * #include <Eigen/OrderingMethods>
+  * \endcode
+  * 
+  * A simple usage is as a template parameter in the sparse decomposition classes : 
+  * 
+  * \code 
+  * SparseLU<MatrixType, COLAMDOrdering<int> > solver;
+  * \endcode 
+  * 
+  * \code 
+  * SparseQR<MatrixType, COLAMDOrdering<int> > solver;
+  * \endcode
+  * 
+  * It is possible as well to call directly a particular ordering method for your own purpose, 
+  * \code 
+  * AMDOrdering<int> ordering;
+  * PermutationMatrix<Dynamic, Dynamic, int> perm;
+  * SparseMatrix<double> A; 
+  * //Fill the matrix ...
+  * 
+  * ordering(A, perm); // Call AMD
+  * \endcode
+  * 
+  * \note Some of these methods (like AMD or METIS), need the sparsity pattern 
+  * of the input matrix to be symmetric. When the matrix is structurally unsymmetric, 
+  * Eigen computes internally the pattern of \f$A^T*A\f$ before calling the method.
+  * If your matrix is already symmetric (at leat in structure), you can avoid that
+  * by calling the method with a SelfAdjointView type.
+  * 
+  * \code
+  *  // Call the ordering on the pattern of the lower triangular matrix A
+  * ordering(A.selfadjointView<Lower>(), perm);
+  * \endcode
+  */
+
+#include "src/OrderingMethods/Amd.h"
+#include "src/OrderingMethods/Ordering.h"
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_ORDERINGMETHODS_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/PaStiXSupport b/C++/yolo_bytetrack_old/include/Eigen/PaStiXSupport
new file mode 100644
index 00000000..234619ac
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/PaStiXSupport
@@ -0,0 +1,49 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PASTIXSUPPORT_MODULE_H
+#define EIGEN_PASTIXSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+extern "C" {
+#include <pastix_nompi.h>
+#include <pastix.h>
+}
+
+#ifdef complex
+#undef complex
+#endif
+
+/** \ingroup Support_modules
+  * \defgroup PaStiXSupport_Module PaStiXSupport module
+  * 
+  * This module provides an interface to the <a href="http://pastix.gforge.inria.fr/">PaSTiX</a> library.
+  * PaSTiX is a general \b supernodal, \b parallel and \b opensource sparse solver.
+  * It provides the two following main factorization classes:
+  * - class PastixLLT : a supernodal, parallel LLt Cholesky factorization.
+  * - class PastixLDLT: a supernodal, parallel LDLt Cholesky factorization.
+  * - class PastixLU : a supernodal, parallel LU factorization (optimized for a symmetric pattern).
+  * 
+  * \code
+  * #include <Eigen/PaStiXSupport>
+  * \endcode
+  *
+  * In order to use this module, the PaSTiX headers must be accessible from the include paths, and your binary must be linked to the PaSTiX library and its dependencies.
+  * This wrapper resuires PaStiX version 5.x compiled without MPI support.
+  * The dependencies depend on how PaSTiX has been compiled.
+  * For a cmake based project, you can use our FindPaSTiX.cmake module to help you in this task.
+  *
+  */
+
+#include "src/PaStiXSupport/PaStiXSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_PASTIXSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/PardisoSupport b/C++/yolo_bytetrack_old/include/Eigen/PardisoSupport
new file mode 100644
index 00000000..340edf51
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/PardisoSupport
@@ -0,0 +1,35 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARDISOSUPPORT_MODULE_H
+#define EIGEN_PARDISOSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#include <mkl_pardiso.h>
+
+/** \ingroup Support_modules
+  * \defgroup PardisoSupport_Module PardisoSupport module
+  *
+  * This module brings support for the Intel(R) MKL PARDISO direct sparse solvers.
+  *
+  * \code
+  * #include <Eigen/PardisoSupport>
+  * \endcode
+  *
+  * In order to use this module, the MKL headers must be accessible from the include paths, and your binary must be linked to the MKL library and its dependencies.
+  * See this \ref TopicUsingIntelMKL "page" for more information on MKL-Eigen integration.
+  * 
+  */
+
+#include "src/PardisoSupport/PardisoSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_PARDISOSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/QR b/C++/yolo_bytetrack_old/include/Eigen/QR
new file mode 100644
index 00000000..8465b62c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/QR
@@ -0,0 +1,50 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_QR_MODULE_H
+#define EIGEN_QR_MODULE_H
+
+#include "Core"
+
+#include "Cholesky"
+#include "Jacobi"
+#include "Householder"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup QR_Module QR module
+  *
+  *
+  *
+  * This module provides various QR decompositions
+  * This module also provides some MatrixBase methods, including:
+  *  - MatrixBase::householderQr()
+  *  - MatrixBase::colPivHouseholderQr()
+  *  - MatrixBase::fullPivHouseholderQr()
+  *
+  * \code
+  * #include <Eigen/QR>
+  * \endcode
+  */
+
+#include "src/QR/HouseholderQR.h"
+#include "src/QR/FullPivHouseholderQR.h"
+#include "src/QR/ColPivHouseholderQR.h"
+#include "src/QR/CompleteOrthogonalDecomposition.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/QR/HouseholderQR_LAPACKE.h"
+#include "src/QR/ColPivHouseholderQR_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_QR_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/QtAlignedMalloc b/C++/yolo_bytetrack_old/include/Eigen/QtAlignedMalloc
new file mode 100644
index 00000000..6fe82374
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/QtAlignedMalloc
@@ -0,0 +1,39 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_QTMALLOC_MODULE_H
+#define EIGEN_QTMALLOC_MODULE_H
+
+#include "Core"
+
+#if (!EIGEN_MALLOC_ALREADY_ALIGNED)
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+void *qMalloc(std::size_t size)
+{
+  return Eigen::internal::aligned_malloc(size);
+}
+
+void qFree(void *ptr)
+{
+  Eigen::internal::aligned_free(ptr);
+}
+
+void *qRealloc(void *ptr, std::size_t size)
+{
+  void* newPtr = Eigen::internal::aligned_malloc(size);
+  std::memcpy(newPtr, ptr, size);
+  Eigen::internal::aligned_free(ptr);
+  return newPtr;
+}
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif
+
+#endif // EIGEN_QTMALLOC_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/SPQRSupport b/C++/yolo_bytetrack_old/include/Eigen/SPQRSupport
new file mode 100644
index 00000000..f70390c1
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/SPQRSupport
@@ -0,0 +1,34 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPQRSUPPORT_MODULE_H
+#define EIGEN_SPQRSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#include "SuiteSparseQR.hpp"
+
+/** \ingroup Support_modules
+  * \defgroup SPQRSupport_Module SuiteSparseQR module
+  * 
+  * This module provides an interface to the SPQR library, which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
+  *
+  * \code
+  * #include <Eigen/SPQRSupport>
+  * \endcode
+  *
+  * In order to use this module, the SPQR headers must be accessible from the include paths, and your binary must be linked to the SPQR library and its dependencies (Cholmod, AMD, COLAMD,...).
+  * For a cmake based project, you can use our FindSPQR.cmake and FindCholmod.Cmake modules
+  *
+  */
+
+#include "src/CholmodSupport/CholmodSupport.h"
+#include "src/SPQRSupport/SuiteSparseQRSupport.h"
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/SVD b/C++/yolo_bytetrack_old/include/Eigen/SVD
new file mode 100644
index 00000000..34517949
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/SVD
@@ -0,0 +1,50 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SVD_MODULE_H
+#define EIGEN_SVD_MODULE_H
+
+#include "QR"
+#include "Householder"
+#include "Jacobi"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup SVD_Module SVD module
+  *
+  *
+  *
+  * This module provides SVD decomposition for matrices (both real and complex).
+  * Two decomposition algorithms are provided:
+  *  - JacobiSVD implementing two-sided Jacobi iterations is numerically very accurate, fast for small matrices, but very slow for larger ones.
+  *  - BDCSVD implementing a recursive divide & conquer strategy on top of an upper-bidiagonalization which remains fast for large problems.
+  * These decompositions are accessible via the respective classes and following MatrixBase methods:
+  *  - MatrixBase::jacobiSvd()
+  *  - MatrixBase::bdcSvd()
+  *
+  * \code
+  * #include <Eigen/SVD>
+  * \endcode
+  */
+
+#include "src/misc/RealSvd2x2.h"
+#include "src/SVD/UpperBidiagonalization.h"
+#include "src/SVD/SVDBase.h"
+#include "src/SVD/JacobiSVD.h"
+#include "src/SVD/BDCSVD.h"
+#if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT)
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/SVD/JacobiSVD_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_SVD_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/Sparse b/C++/yolo_bytetrack_old/include/Eigen/Sparse
new file mode 100644
index 00000000..a2ef7a66
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/Sparse
@@ -0,0 +1,34 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_MODULE_H
+#define EIGEN_SPARSE_MODULE_H
+
+/** \defgroup Sparse_Module Sparse meta-module
+  *
+  * Meta-module including all related modules:
+  * - \ref SparseCore_Module
+  * - \ref OrderingMethods_Module
+  * - \ref SparseCholesky_Module
+  * - \ref SparseLU_Module
+  * - \ref SparseQR_Module
+  * - \ref IterativeLinearSolvers_Module
+  *
+    \code
+    #include <Eigen/Sparse>
+    \endcode
+  */
+
+#include "SparseCore"
+#include "OrderingMethods"
+#include "SparseCholesky"
+#include "SparseLU"
+#include "SparseQR"
+#include "IterativeLinearSolvers"
+
+#endif // EIGEN_SPARSE_MODULE_H
+
diff --git a/C++/yolo_bytetrack_old/include/Eigen/SparseCholesky b/C++/yolo_bytetrack_old/include/Eigen/SparseCholesky
new file mode 100644
index 00000000..d2b1f127
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/SparseCholesky
@@ -0,0 +1,37 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2013 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSECHOLESKY_MODULE_H
+#define EIGEN_SPARSECHOLESKY_MODULE_H
+
+#include "SparseCore"
+#include "OrderingMethods"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** 
+  * \defgroup SparseCholesky_Module SparseCholesky module
+  *
+  * This module currently provides two variants of the direct sparse Cholesky decomposition for selfadjoint (hermitian) matrices.
+  * Those decompositions are accessible via the following classes:
+  *  - SimplicialLLt,
+  *  - SimplicialLDLt
+  *
+  * Such problems can also be solved using the ConjugateGradient solver from the IterativeLinearSolvers module.
+  *
+  * \code
+  * #include <Eigen/SparseCholesky>
+  * \endcode
+  */
+
+#include "src/SparseCholesky/SimplicialCholesky.h"
+#include "src/SparseCholesky/SimplicialCholesky_impl.h"
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_SPARSECHOLESKY_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/SparseCore b/C++/yolo_bytetrack_old/include/Eigen/SparseCore
new file mode 100644
index 00000000..76966c4c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/SparseCore
@@ -0,0 +1,69 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSECORE_MODULE_H
+#define EIGEN_SPARSECORE_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#include <vector>
+#include <map>
+#include <cstdlib>
+#include <cstring>
+#include <algorithm>
+
+/** 
+  * \defgroup SparseCore_Module SparseCore module
+  *
+  * This module provides a sparse matrix representation, and basic associated matrix manipulations
+  * and operations.
+  *
+  * See the \ref TutorialSparse "Sparse tutorial"
+  *
+  * \code
+  * #include <Eigen/SparseCore>
+  * \endcode
+  *
+  * This module depends on: Core.
+  */
+
+#include "src/SparseCore/SparseUtil.h"
+#include "src/SparseCore/SparseMatrixBase.h"
+#include "src/SparseCore/SparseAssign.h"
+#include "src/SparseCore/CompressedStorage.h"
+#include "src/SparseCore/AmbiVector.h"
+#include "src/SparseCore/SparseCompressedBase.h"
+#include "src/SparseCore/SparseMatrix.h"
+#include "src/SparseCore/SparseMap.h"
+#include "src/SparseCore/MappedSparseMatrix.h"
+#include "src/SparseCore/SparseVector.h"
+#include "src/SparseCore/SparseRef.h"
+#include "src/SparseCore/SparseCwiseUnaryOp.h"
+#include "src/SparseCore/SparseCwiseBinaryOp.h"
+#include "src/SparseCore/SparseTranspose.h"
+#include "src/SparseCore/SparseBlock.h"
+#include "src/SparseCore/SparseDot.h"
+#include "src/SparseCore/SparseRedux.h"
+#include "src/SparseCore/SparseView.h"
+#include "src/SparseCore/SparseDiagonalProduct.h"
+#include "src/SparseCore/ConservativeSparseSparseProduct.h"
+#include "src/SparseCore/SparseSparseProductWithPruning.h"
+#include "src/SparseCore/SparseProduct.h"
+#include "src/SparseCore/SparseDenseProduct.h"
+#include "src/SparseCore/SparseSelfAdjointView.h"
+#include "src/SparseCore/SparseTriangularView.h"
+#include "src/SparseCore/TriangularSolver.h"
+#include "src/SparseCore/SparsePermutation.h"
+#include "src/SparseCore/SparseFuzzy.h"
+#include "src/SparseCore/SparseSolverBase.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_SPARSECORE_MODULE_H
+
diff --git a/C++/yolo_bytetrack_old/include/Eigen/SparseLU b/C++/yolo_bytetrack_old/include/Eigen/SparseLU
new file mode 100644
index 00000000..37c4a5c5
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/SparseLU
@@ -0,0 +1,50 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSELU_MODULE_H
+#define EIGEN_SPARSELU_MODULE_H
+
+#include "SparseCore"
+
+/** 
+  * \defgroup SparseLU_Module SparseLU module
+  * This module defines a supernodal factorization of general sparse matrices.
+  * The code is fully optimized for supernode-panel updates with specialized kernels.
+  * Please, see the documentation of the SparseLU class for more details.
+  */
+
+// Ordering interface
+#include "OrderingMethods"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#include "src/SparseLU/SparseLU_gemm_kernel.h"
+
+#include "src/SparseLU/SparseLU_Structs.h"
+#include "src/SparseLU/SparseLU_SupernodalMatrix.h"
+#include "src/SparseLU/SparseLUImpl.h"
+#include "src/SparseCore/SparseColEtree.h"
+#include "src/SparseLU/SparseLU_Memory.h"
+#include "src/SparseLU/SparseLU_heap_relax_snode.h"
+#include "src/SparseLU/SparseLU_relax_snode.h"
+#include "src/SparseLU/SparseLU_pivotL.h"
+#include "src/SparseLU/SparseLU_panel_dfs.h"
+#include "src/SparseLU/SparseLU_kernel_bmod.h"
+#include "src/SparseLU/SparseLU_panel_bmod.h"
+#include "src/SparseLU/SparseLU_column_dfs.h"
+#include "src/SparseLU/SparseLU_column_bmod.h"
+#include "src/SparseLU/SparseLU_copy_to_ucol.h"
+#include "src/SparseLU/SparseLU_pruneL.h"
+#include "src/SparseLU/SparseLU_Utils.h"
+#include "src/SparseLU/SparseLU.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_SPARSELU_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/SparseQR b/C++/yolo_bytetrack_old/include/Eigen/SparseQR
new file mode 100644
index 00000000..f5fc5fa7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/SparseQR
@@ -0,0 +1,36 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEQR_MODULE_H
+#define EIGEN_SPARSEQR_MODULE_H
+
+#include "SparseCore"
+#include "OrderingMethods"
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup SparseQR_Module SparseQR module
+  * \brief Provides QR decomposition for sparse matrices
+  * 
+  * This module provides a simplicial version of the left-looking Sparse QR decomposition. 
+  * The columns of the input matrix should be reordered to limit the fill-in during the 
+  * decomposition. Built-in methods (COLAMD, AMD) or external  methods (METIS) can be used to this end.
+  * See the \link OrderingMethods_Module OrderingMethods\endlink module for the list 
+  * of built-in and external ordering methods.
+  * 
+  * \code
+  * #include <Eigen/SparseQR>
+  * \endcode
+  * 
+  * 
+  */
+
+#include "src/SparseCore/SparseColEtree.h"
+#include "src/SparseQR/SparseQR.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/StdDeque b/C++/yolo_bytetrack_old/include/Eigen/StdDeque
new file mode 100644
index 00000000..bc68397b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/StdDeque
@@ -0,0 +1,27 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDDEQUE_MODULE_H
+#define EIGEN_STDDEQUE_MODULE_H
+
+#include "Core"
+#include <deque>
+
+#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
+
+#define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...)
+
+#else
+
+#include "src/StlSupport/StdDeque.h"
+
+#endif
+
+#endif // EIGEN_STDDEQUE_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/StdList b/C++/yolo_bytetrack_old/include/Eigen/StdList
new file mode 100644
index 00000000..4c6262c0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/StdList
@@ -0,0 +1,26 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDLIST_MODULE_H
+#define EIGEN_STDLIST_MODULE_H
+
+#include "Core"
+#include <list>
+
+#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
+
+#define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...)
+
+#else
+
+#include "src/StlSupport/StdList.h"
+
+#endif
+
+#endif // EIGEN_STDLIST_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/StdVector b/C++/yolo_bytetrack_old/include/Eigen/StdVector
new file mode 100644
index 00000000..0c4697ad
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/StdVector
@@ -0,0 +1,27 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDVECTOR_MODULE_H
+#define EIGEN_STDVECTOR_MODULE_H
+
+#include "Core"
+#include <vector>
+
+#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
+
+#define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...)
+
+#else
+
+#include "src/StlSupport/StdVector.h"
+
+#endif
+
+#endif // EIGEN_STDVECTOR_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/SuperLUSupport b/C++/yolo_bytetrack_old/include/Eigen/SuperLUSupport
new file mode 100644
index 00000000..59312a82
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/SuperLUSupport
@@ -0,0 +1,64 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SUPERLUSUPPORT_MODULE_H
+#define EIGEN_SUPERLUSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#ifdef EMPTY
+#define EIGEN_EMPTY_WAS_ALREADY_DEFINED
+#endif
+
+typedef int int_t;
+#include <slu_Cnames.h>
+#include <supermatrix.h>
+#include <slu_util.h>
+
+// slu_util.h defines a preprocessor token named EMPTY which is really polluting,
+// so we remove it in favor of a SUPERLU_EMPTY token.
+// If EMPTY was already defined then we don't undef it.
+
+#if defined(EIGEN_EMPTY_WAS_ALREADY_DEFINED)
+# undef EIGEN_EMPTY_WAS_ALREADY_DEFINED
+#elif defined(EMPTY)
+# undef EMPTY
+#endif
+
+#define SUPERLU_EMPTY (-1)
+
+namespace Eigen { struct SluMatrix; }
+
+/** \ingroup Support_modules
+  * \defgroup SuperLUSupport_Module SuperLUSupport module
+  *
+  * This module provides an interface to the <a href="http://crd-legacy.lbl.gov/~xiaoye/SuperLU/">SuperLU</a> library.
+  * It provides the following factorization class:
+  * - class SuperLU: a supernodal sequential LU factorization.
+  * - class SuperILU: a supernodal sequential incomplete LU factorization (to be used as a preconditioner for iterative methods).
+  *
+  * \warning This wrapper requires at least versions 4.0 of SuperLU. The 3.x versions are not supported.
+  *
+  * \warning When including this module, you have to use SUPERLU_EMPTY instead of EMPTY which is no longer defined because it is too polluting.
+  *
+  * \code
+  * #include <Eigen/SuperLUSupport>
+  * \endcode
+  *
+  * In order to use this module, the superlu headers must be accessible from the include paths, and your binary must be linked to the superlu library and its dependencies.
+  * The dependencies depend on how superlu has been compiled.
+  * For a cmake based project, you can use our FindSuperLU.cmake module to help you in this task.
+  *
+  */
+
+#include "src/SuperLUSupport/SuperLUSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_SUPERLUSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/UmfPackSupport b/C++/yolo_bytetrack_old/include/Eigen/UmfPackSupport
new file mode 100644
index 00000000..00eec808
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/UmfPackSupport
@@ -0,0 +1,40 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UMFPACKSUPPORT_MODULE_H
+#define EIGEN_UMFPACKSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+extern "C" {
+#include <umfpack.h>
+}
+
+/** \ingroup Support_modules
+  * \defgroup UmfPackSupport_Module UmfPackSupport module
+  *
+  * This module provides an interface to the UmfPack library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
+  * It provides the following factorization class:
+  * - class UmfPackLU: a multifrontal sequential LU factorization.
+  *
+  * \code
+  * #include <Eigen/UmfPackSupport>
+  * \endcode
+  *
+  * In order to use this module, the umfpack headers must be accessible from the include paths, and your binary must be linked to the umfpack library and its dependencies.
+  * The dependencies depend on how umfpack has been compiled.
+  * For a cmake based project, you can use our FindUmfPack.cmake module to help you in this task.
+  *
+  */
+
+#include "src/UmfPackSupport/UmfPackSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_UMFPACKSUPPORT_MODULE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Cholesky/LDLT.h b/C++/yolo_bytetrack_old/include/Eigen/src/Cholesky/LDLT.h
new file mode 100644
index 00000000..1013ca04
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Cholesky/LDLT.h
@@ -0,0 +1,688 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Keir Mierle <mierle@gmail.com>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2011 Timothy E. Holy <tim.holy@gmail.com >
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LDLT_H
+#define EIGEN_LDLT_H
+
+namespace Eigen {
+
+namespace internal {
+  template<typename _MatrixType, int _UpLo> struct traits<LDLT<_MatrixType, _UpLo> >
+   : traits<_MatrixType>
+  {
+    typedef MatrixXpr XprKind;
+    typedef SolverStorage StorageKind;
+    typedef int StorageIndex;
+    enum { Flags = 0 };
+  };
+
+  template<typename MatrixType, int UpLo> struct LDLT_Traits;
+
+  // PositiveSemiDef means positive semi-definite and non-zero; same for NegativeSemiDef
+  enum SignMatrix { PositiveSemiDef, NegativeSemiDef, ZeroSign, Indefinite };
+}
+
+/** \ingroup Cholesky_Module
+  *
+  * \class LDLT
+  *
+  * \brief Robust Cholesky decomposition of a matrix with pivoting
+  *
+  * \tparam _MatrixType the type of the matrix of which to compute the LDL^T Cholesky decomposition
+  * \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
+  *             The other triangular part won't be read.
+  *
+  * Perform a robust Cholesky decomposition of a positive semidefinite or negative semidefinite
+  * matrix \f$ A \f$ such that \f$ A =  P^TLDL^*P \f$, where P is a permutation matrix, L
+  * is lower triangular with a unit diagonal and D is a diagonal matrix.
+  *
+  * The decomposition uses pivoting to ensure stability, so that D will have
+  * zeros in the bottom right rank(A) - n submatrix. Avoiding the square root
+  * on D also stabilizes the computation.
+  *
+  * Remember that Cholesky decompositions are not rank-revealing. Also, do not use a Cholesky
+  * decomposition to determine whether a system of equations has a solution.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * \sa MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT
+  */
+template<typename _MatrixType, int _UpLo> class LDLT
+        : public SolverBase<LDLT<_MatrixType, _UpLo> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<LDLT> Base;
+    friend class SolverBase<LDLT>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(LDLT)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+      UpLo = _UpLo
+    };
+    typedef Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1> TmpMatrixType;
+
+    typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType;
+    typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType;
+
+    typedef internal::LDLT_Traits<MatrixType,UpLo> Traits;
+
+    /** \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via LDLT::compute(const MatrixType&).
+      */
+    LDLT()
+      : m_matrix(),
+        m_transpositions(),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa LDLT()
+      */
+    explicit LDLT(Index size)
+      : m_matrix(size, size),
+        m_transpositions(size),
+        m_temporary(size),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {}
+
+    /** \brief Constructor with decomposition
+      *
+      * This calculates the decomposition for the input \a matrix.
+      *
+      * \sa LDLT(Index size)
+      */
+    template<typename InputType>
+    explicit LDLT(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.rows(), matrix.cols()),
+        m_transpositions(matrix.rows()),
+        m_temporary(matrix.rows()),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a LDLT factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa LDLT(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit LDLT(EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_transpositions(matrix.rows()),
+        m_temporary(matrix.rows()),
+        m_sign(internal::ZeroSign),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** Clear any existing decomposition
+     * \sa rankUpdate(w,sigma)
+     */
+    void setZero()
+    {
+      m_isInitialized = false;
+    }
+
+    /** \returns a view of the upper triangular matrix U */
+    inline typename Traits::MatrixU matrixU() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return Traits::getU(m_matrix);
+    }
+
+    /** \returns a view of the lower triangular matrix L */
+    inline typename Traits::MatrixL matrixL() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return Traits::getL(m_matrix);
+    }
+
+    /** \returns the permutation matrix P as a transposition sequence.
+      */
+    inline const TranspositionType& transpositionsP() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_transpositions;
+    }
+
+    /** \returns the coefficients of the diagonal matrix D */
+    inline Diagonal<const MatrixType> vectorD() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_matrix.diagonal();
+    }
+
+    /** \returns true if the matrix is positive (semidefinite) */
+    inline bool isPositive() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_sign == internal::PositiveSemiDef || m_sign == internal::ZeroSign;
+    }
+
+    /** \returns true if the matrix is negative (semidefinite) */
+    inline bool isNegative(void) const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_sign == internal::NegativeSemiDef || m_sign == internal::ZeroSign;
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \returns a solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * This function also supports in-place solves using the syntax <tt>x = decompositionObject.solve(x)</tt> .
+      *
+      * \note_about_checking_solutions
+      *
+      * More precisely, this method solves \f$ A x = b \f$ using the decomposition \f$ A = P^T L D L^* P \f$
+      * by solving the systems \f$ P^T y_1 = b \f$, \f$ L y_2 = y_1 \f$, \f$ D y_3 = y_2 \f$,
+      * \f$ L^* y_4 = y_3 \f$ and \f$ P x = y_4 \f$ in succession. If the matrix \f$ A \f$ is singular, then
+      * \f$ D \f$ will also be singular (all the other matrices are invertible). In that case, the
+      * least-square solution of \f$ D y_3 = y_2 \f$ is computed. This does not mean that this function
+      * computes the least-square solution of \f$ A x = b \f$ if \f$ A \f$ is singular.
+      *
+      * \sa MatrixBase::ldlt(), SelfAdjointView::ldlt()
+      */
+    template<typename Rhs>
+    inline const Solve<LDLT, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    template<typename Derived>
+    bool solveInPlace(MatrixBase<Derived> &bAndX) const;
+
+    template<typename InputType>
+    LDLT& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of
+     *  which \c *this is the LDLT decomposition.
+     */
+    RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    template <typename Derived>
+    LDLT& rankUpdate(const MatrixBase<Derived>& w, const RealScalar& alpha=1);
+
+    /** \returns the internal LDLT decomposition matrix
+      *
+      * TODO: document the storage layout
+      */
+    inline const MatrixType& matrixLDLT() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_matrix;
+    }
+
+    MatrixType reconstructedMatrix() const;
+
+    /** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
+      *
+      * This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
+      * \code x = decomposition.adjoint().solve(b) \endcode
+      */
+    const LDLT& adjoint() const { return *this; };
+
+    EIGEN_DEVICE_FUNC inline EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    EIGEN_DEVICE_FUNC inline EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the factorization failed because of a zero pivot.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "LDLT is not initialized.");
+      return m_info;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    /** \internal
+      * Used to compute and store the Cholesky decomposition A = L D L^* = U^* D U.
+      * The strict upper part is used during the decomposition, the strict lower
+      * part correspond to the coefficients of L (its diagonal is equal to 1 and
+      * is not stored), and the diagonal entries correspond to D.
+      */
+    MatrixType m_matrix;
+    RealScalar m_l1_norm;
+    TranspositionType m_transpositions;
+    TmpMatrixType m_temporary;
+    internal::SignMatrix m_sign;
+    bool m_isInitialized;
+    ComputationInfo m_info;
+};
+
+namespace internal {
+
+template<int UpLo> struct ldlt_inplace;
+
+template<> struct ldlt_inplace<Lower>
+{
+  template<typename MatrixType, typename TranspositionType, typename Workspace>
+  static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign)
+  {
+    using std::abs;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename TranspositionType::StorageIndex IndexType;
+    eigen_assert(mat.rows()==mat.cols());
+    const Index size = mat.rows();
+    bool found_zero_pivot = false;
+    bool ret = true;
+
+    if (size <= 1)
+    {
+      transpositions.setIdentity();
+      if(size==0) sign = ZeroSign;
+      else if (numext::real(mat.coeff(0,0)) > static_cast<RealScalar>(0) ) sign = PositiveSemiDef;
+      else if (numext::real(mat.coeff(0,0)) < static_cast<RealScalar>(0)) sign = NegativeSemiDef;
+      else sign = ZeroSign;
+      return true;
+    }
+
+    for (Index k = 0; k < size; ++k)
+    {
+      // Find largest diagonal element
+      Index index_of_biggest_in_corner;
+      mat.diagonal().tail(size-k).cwiseAbs().maxCoeff(&index_of_biggest_in_corner);
+      index_of_biggest_in_corner += k;
+
+      transpositions.coeffRef(k) = IndexType(index_of_biggest_in_corner);
+      if(k != index_of_biggest_in_corner)
+      {
+        // apply the transposition while taking care to consider only
+        // the lower triangular part
+        Index s = size-index_of_biggest_in_corner-1; // trailing size after the biggest element
+        mat.row(k).head(k).swap(mat.row(index_of_biggest_in_corner).head(k));
+        mat.col(k).tail(s).swap(mat.col(index_of_biggest_in_corner).tail(s));
+        std::swap(mat.coeffRef(k,k),mat.coeffRef(index_of_biggest_in_corner,index_of_biggest_in_corner));
+        for(Index i=k+1;i<index_of_biggest_in_corner;++i)
+        {
+          Scalar tmp = mat.coeffRef(i,k);
+          mat.coeffRef(i,k) = numext::conj(mat.coeffRef(index_of_biggest_in_corner,i));
+          mat.coeffRef(index_of_biggest_in_corner,i) = numext::conj(tmp);
+        }
+        if(NumTraits<Scalar>::IsComplex)
+          mat.coeffRef(index_of_biggest_in_corner,k) = numext::conj(mat.coeff(index_of_biggest_in_corner,k));
+      }
+
+      // partition the matrix:
+      //       A00 |  -  |  -
+      // lu  = A10 | A11 |  -
+      //       A20 | A21 | A22
+      Index rs = size - k - 1;
+      Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
+      Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
+      Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
+
+      if(k>0)
+      {
+        temp.head(k) = mat.diagonal().real().head(k).asDiagonal() * A10.adjoint();
+        mat.coeffRef(k,k) -= (A10 * temp.head(k)).value();
+        if(rs>0)
+          A21.noalias() -= A20 * temp.head(k);
+      }
+
+      // In some previous versions of Eigen (e.g., 3.2.1), the scaling was omitted if the pivot
+      // was smaller than the cutoff value. However, since LDLT is not rank-revealing
+      // we should only make sure that we do not introduce INF or NaN values.
+      // Remark that LAPACK also uses 0 as the cutoff value.
+      RealScalar realAkk = numext::real(mat.coeffRef(k,k));
+      bool pivot_is_valid = (abs(realAkk) > RealScalar(0));
+
+      if(k==0 && !pivot_is_valid)
+      {
+        // The entire diagonal is zero, there is nothing more to do
+        // except filling the transpositions, and checking whether the matrix is zero.
+        sign = ZeroSign;
+        for(Index j = 0; j<size; ++j)
+        {
+          transpositions.coeffRef(j) = IndexType(j);
+          ret = ret && (mat.col(j).tail(size-j-1).array()==Scalar(0)).all();
+        }
+        return ret;
+      }
+
+      if((rs>0) && pivot_is_valid)
+        A21 /= realAkk;
+      else if(rs>0)
+        ret = ret && (A21.array()==Scalar(0)).all();
+
+      if(found_zero_pivot && pivot_is_valid) ret = false; // factorization failed
+      else if(!pivot_is_valid) found_zero_pivot = true;
+
+      if (sign == PositiveSemiDef) {
+        if (realAkk < static_cast<RealScalar>(0)) sign = Indefinite;
+      } else if (sign == NegativeSemiDef) {
+        if (realAkk > static_cast<RealScalar>(0)) sign = Indefinite;
+      } else if (sign == ZeroSign) {
+        if (realAkk > static_cast<RealScalar>(0)) sign = PositiveSemiDef;
+        else if (realAkk < static_cast<RealScalar>(0)) sign = NegativeSemiDef;
+      }
+    }
+
+    return ret;
+  }
+
+  // Reference for the algorithm: Davis and Hager, "Multiple Rank
+  // Modifications of a Sparse Cholesky Factorization" (Algorithm 1)
+  // Trivial rearrangements of their computations (Timothy E. Holy)
+  // allow their algorithm to work for rank-1 updates even if the
+  // original matrix is not of full rank.
+  // Here only rank-1 updates are implemented, to reduce the
+  // requirement for intermediate storage and improve accuracy
+  template<typename MatrixType, typename WDerived>
+  static bool updateInPlace(MatrixType& mat, MatrixBase<WDerived>& w, const typename MatrixType::RealScalar& sigma=1)
+  {
+    using numext::isfinite;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+
+    const Index size = mat.rows();
+    eigen_assert(mat.cols() == size && w.size()==size);
+
+    RealScalar alpha = 1;
+
+    // Apply the update
+    for (Index j = 0; j < size; j++)
+    {
+      // Check for termination due to an original decomposition of low-rank
+      if (!(isfinite)(alpha))
+        break;
+
+      // Update the diagonal terms
+      RealScalar dj = numext::real(mat.coeff(j,j));
+      Scalar wj = w.coeff(j);
+      RealScalar swj2 = sigma*numext::abs2(wj);
+      RealScalar gamma = dj*alpha + swj2;
+
+      mat.coeffRef(j,j) += swj2/alpha;
+      alpha += swj2/dj;
+
+
+      // Update the terms of L
+      Index rs = size-j-1;
+      w.tail(rs) -= wj * mat.col(j).tail(rs);
+      if(gamma != 0)
+        mat.col(j).tail(rs) += (sigma*numext::conj(wj)/gamma)*w.tail(rs);
+    }
+    return true;
+  }
+
+  template<typename MatrixType, typename TranspositionType, typename Workspace, typename WType>
+  static bool update(MatrixType& mat, const TranspositionType& transpositions, Workspace& tmp, const WType& w, const typename MatrixType::RealScalar& sigma=1)
+  {
+    // Apply the permutation to the input w
+    tmp = transpositions * w;
+
+    return ldlt_inplace<Lower>::updateInPlace(mat,tmp,sigma);
+  }
+};
+
+template<> struct ldlt_inplace<Upper>
+{
+  template<typename MatrixType, typename TranspositionType, typename Workspace>
+  static EIGEN_STRONG_INLINE bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign)
+  {
+    Transpose<MatrixType> matt(mat);
+    return ldlt_inplace<Lower>::unblocked(matt, transpositions, temp, sign);
+  }
+
+  template<typename MatrixType, typename TranspositionType, typename Workspace, typename WType>
+  static EIGEN_STRONG_INLINE bool update(MatrixType& mat, TranspositionType& transpositions, Workspace& tmp, WType& w, const typename MatrixType::RealScalar& sigma=1)
+  {
+    Transpose<MatrixType> matt(mat);
+    return ldlt_inplace<Lower>::update(matt, transpositions, tmp, w.conjugate(), sigma);
+  }
+};
+
+template<typename MatrixType> struct LDLT_Traits<MatrixType,Lower>
+{
+  typedef const TriangularView<const MatrixType, UnitLower> MatrixL;
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitUpper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
+};
+
+template<typename MatrixType> struct LDLT_Traits<MatrixType,Upper>
+{
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitLower> MatrixL;
+  typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
+};
+
+} // end namespace internal
+
+/** Compute / recompute the LDLT decomposition A = L D L^* = U^* D U of \a matrix
+  */
+template<typename MatrixType, int _UpLo>
+template<typename InputType>
+LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
+{
+  check_template_parameters();
+
+  eigen_assert(a.rows()==a.cols());
+  const Index size = a.rows();
+
+  m_matrix = a.derived();
+
+  // Compute matrix L1 norm = max abs column sum.
+  m_l1_norm = RealScalar(0);
+  // TODO move this code to SelfAdjointView
+  for (Index col = 0; col < size; ++col) {
+    RealScalar abs_col_sum;
+    if (_UpLo == Lower)
+      abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
+    else
+      abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
+    if (abs_col_sum > m_l1_norm)
+      m_l1_norm = abs_col_sum;
+  }
+
+  m_transpositions.resize(size);
+  m_isInitialized = false;
+  m_temporary.resize(size);
+  m_sign = internal::ZeroSign;
+
+  m_info = internal::ldlt_inplace<UpLo>::unblocked(m_matrix, m_transpositions, m_temporary, m_sign) ? Success : NumericalIssue;
+
+  m_isInitialized = true;
+  return *this;
+}
+
+/** Update the LDLT decomposition:  given A = L D L^T, efficiently compute the decomposition of A + sigma w w^T.
+ * \param w a vector to be incorporated into the decomposition.
+ * \param sigma a scalar, +1 for updates and -1 for "downdates," which correspond to removing previously-added column vectors. Optional; default value is +1.
+ * \sa setZero()
+  */
+template<typename MatrixType, int _UpLo>
+template<typename Derived>
+LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::rankUpdate(const MatrixBase<Derived>& w, const typename LDLT<MatrixType,_UpLo>::RealScalar& sigma)
+{
+  typedef typename TranspositionType::StorageIndex IndexType;
+  const Index size = w.rows();
+  if (m_isInitialized)
+  {
+    eigen_assert(m_matrix.rows()==size);
+  }
+  else
+  {
+    m_matrix.resize(size,size);
+    m_matrix.setZero();
+    m_transpositions.resize(size);
+    for (Index i = 0; i < size; i++)
+      m_transpositions.coeffRef(i) = IndexType(i);
+    m_temporary.resize(size);
+    m_sign = sigma>=0 ? internal::PositiveSemiDef : internal::NegativeSemiDef;
+    m_isInitialized = true;
+  }
+
+  internal::ldlt_inplace<UpLo>::update(m_matrix, m_transpositions, m_temporary, w, sigma);
+
+  return *this;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType, int _UpLo>
+template<typename RhsType, typename DstType>
+void LDLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  _solve_impl_transposed<true>(rhs, dst);
+}
+
+template<typename _MatrixType,int _UpLo>
+template<bool Conjugate, typename RhsType, typename DstType>
+void LDLT<_MatrixType,_UpLo>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  // dst = P b
+  dst = m_transpositions * rhs;
+
+  // dst = L^-1 (P b)
+  // dst = L^-*T (P b)
+  matrixL().template conjugateIf<!Conjugate>().solveInPlace(dst);
+
+  // dst = D^-* (L^-1 P b)
+  // dst = D^-1 (L^-*T P b)
+  // more precisely, use pseudo-inverse of D (see bug 241)
+  using std::abs;
+  const typename Diagonal<const MatrixType>::RealReturnType vecD(vectorD());
+  // In some previous versions, tolerance was set to the max of 1/highest (or rather numeric_limits::min())
+  // and the maximal diagonal entry * epsilon as motivated by LAPACK's xGELSS:
+  // RealScalar tolerance = numext::maxi(vecD.array().abs().maxCoeff() * NumTraits<RealScalar>::epsilon(),RealScalar(1) / NumTraits<RealScalar>::highest());
+  // However, LDLT is not rank revealing, and so adjusting the tolerance wrt to the highest
+  // diagonal element is not well justified and leads to numerical issues in some cases.
+  // Moreover, Lapack's xSYTRS routines use 0 for the tolerance.
+  // Using numeric_limits::min() gives us more robustness to denormals.
+  RealScalar tolerance = (std::numeric_limits<RealScalar>::min)();
+  for (Index i = 0; i < vecD.size(); ++i)
+  {
+    if(abs(vecD(i)) > tolerance)
+      dst.row(i) /= vecD(i);
+    else
+      dst.row(i).setZero();
+  }
+
+  // dst = L^-* (D^-* L^-1 P b)
+  // dst = L^-T (D^-1 L^-*T P b)
+  matrixL().transpose().template conjugateIf<Conjugate>().solveInPlace(dst);
+
+  // dst = P^T (L^-* D^-* L^-1 P b) = A^-1 b
+  // dst = P^-T (L^-T D^-1 L^-*T P b) = A^-1 b
+  dst = m_transpositions.transpose() * dst;
+}
+#endif
+
+/** \internal use x = ldlt_object.solve(x);
+  *
+  * This is the \em in-place version of solve().
+  *
+  * \param bAndX represents both the right-hand side matrix b and result x.
+  *
+  * \returns true always! If you need to check for existence of solutions, use another decomposition like LU, QR, or SVD.
+  *
+  * This version avoids a copy when the right hand side matrix b is not
+  * needed anymore.
+  *
+  * \sa LDLT::solve(), MatrixBase::ldlt()
+  */
+template<typename MatrixType,int _UpLo>
+template<typename Derived>
+bool LDLT<MatrixType,_UpLo>::solveInPlace(MatrixBase<Derived> &bAndX) const
+{
+  eigen_assert(m_isInitialized && "LDLT is not initialized.");
+  eigen_assert(m_matrix.rows() == bAndX.rows());
+
+  bAndX = this->solve(bAndX);
+
+  return true;
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: P^T L D L^* P.
+ * This function is provided for debug purpose. */
+template<typename MatrixType, int _UpLo>
+MatrixType LDLT<MatrixType,_UpLo>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LDLT is not initialized.");
+  const Index size = m_matrix.rows();
+  MatrixType res(size,size);
+
+  // P
+  res.setIdentity();
+  res = transpositionsP() * res;
+  // L^* P
+  res = matrixU() * res;
+  // D(L^*P)
+  res = vectorD().real().asDiagonal() * res;
+  // L(DL^*P)
+  res = matrixL() * res;
+  // P^T (LDL^*P)
+  res = transpositionsP().transpose() * res;
+
+  return res;
+}
+
+/** \cholesky_module
+  * \returns the Cholesky decomposition with full pivoting without square root of \c *this
+  * \sa MatrixBase::ldlt()
+  */
+template<typename MatrixType, unsigned int UpLo>
+inline const LDLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
+SelfAdjointView<MatrixType, UpLo>::ldlt() const
+{
+  return LDLT<PlainObject,UpLo>(m_matrix);
+}
+
+/** \cholesky_module
+  * \returns the Cholesky decomposition with full pivoting without square root of \c *this
+  * \sa SelfAdjointView::ldlt()
+  */
+template<typename Derived>
+inline const LDLT<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::ldlt() const
+{
+  return LDLT<PlainObject>(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_LDLT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Cholesky/LLT.h b/C++/yolo_bytetrack_old/include/Eigen/src/Cholesky/LLT.h
new file mode 100644
index 00000000..8c9b2b39
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Cholesky/LLT.h
@@ -0,0 +1,558 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LLT_H
+#define EIGEN_LLT_H
+
+namespace Eigen {
+
+namespace internal{
+
+template<typename _MatrixType, int _UpLo> struct traits<LLT<_MatrixType, _UpLo> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+template<typename MatrixType, int UpLo> struct LLT_Traits;
+}
+
+/** \ingroup Cholesky_Module
+  *
+  * \class LLT
+  *
+  * \brief Standard Cholesky decomposition (LL^T) of a matrix and associated features
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the LL^T Cholesky decomposition
+  * \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
+  *               The other triangular part won't be read.
+  *
+  * This class performs a LL^T Cholesky decomposition of a symmetric, positive definite
+  * matrix A such that A = LL^* = U^*U, where L is lower triangular.
+  *
+  * While the Cholesky decomposition is particularly useful to solve selfadjoint problems like  D^*D x = b,
+  * for that purpose, we recommend the Cholesky decomposition without square root which is more stable
+  * and even faster. Nevertheless, this standard Cholesky decomposition remains useful in many other
+  * situations like generalised eigen problems with hermitian matrices.
+  *
+  * Remember that Cholesky decompositions are not rank-revealing. This LLT decomposition is only stable on positive definite matrices,
+  * use LDLT instead for the semidefinite case. Also, do not use a Cholesky decomposition to determine whether a system of equations
+  * has a solution.
+  *
+  * Example: \include LLT_example.cpp
+  * Output: \verbinclude LLT_example.out
+  *
+  * \b Performance: for best performance, it is recommended to use a column-major storage format
+  * with the Lower triangular part (the default), or, equivalently, a row-major storage format
+  * with the Upper triangular part. Otherwise, you might get a 20% slowdown for the full factorization
+  * step, and rank-updates can be up to 3 times slower.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * Note that during the decomposition, only the lower (or upper, as defined by _UpLo) triangular part of A is considered.
+  * Therefore, the strict lower part does not have to store correct values.
+  *
+  * \sa MatrixBase::llt(), SelfAdjointView::llt(), class LDLT
+  */
+template<typename _MatrixType, int _UpLo> class LLT
+        : public SolverBase<LLT<_MatrixType, _UpLo> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<LLT> Base;
+    friend class SolverBase<LLT>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(LLT)
+    enum {
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    enum {
+      PacketSize = internal::packet_traits<Scalar>::size,
+      AlignmentMask = int(PacketSize)-1,
+      UpLo = _UpLo
+    };
+
+    typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via LLT::compute(const MatrixType&).
+      */
+    LLT() : m_matrix(), m_isInitialized(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa LLT()
+      */
+    explicit LLT(Index size) : m_matrix(size, size),
+                    m_isInitialized(false) {}
+
+    template<typename InputType>
+    explicit LLT(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.rows(), matrix.cols()),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a LLT factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when
+      * \c MatrixType is a Eigen::Ref.
+      *
+      * \sa LLT(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit LLT(EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \returns a view of the upper triangular matrix U */
+    inline typename Traits::MatrixU matrixU() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return Traits::getU(m_matrix);
+    }
+
+    /** \returns a view of the lower triangular matrix L */
+    inline typename Traits::MatrixL matrixL() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return Traits::getL(m_matrix);
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * Since this LLT class assumes anyway that the matrix A is invertible, the solution
+      * theoretically exists and is unique regardless of b.
+      *
+      * Example: \include LLT_solve.cpp
+      * Output: \verbinclude LLT_solve.out
+      *
+      * \sa solveInPlace(), MatrixBase::llt(), SelfAdjointView::llt()
+      */
+    template<typename Rhs>
+    inline const Solve<LLT, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    template<typename Derived>
+    void solveInPlace(const MatrixBase<Derived> &bAndX) const;
+
+    template<typename InputType>
+    LLT& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of
+      *  which \c *this is the Cholesky decomposition.
+      */
+    RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    /** \returns the LLT decomposition matrix
+      *
+      * TODO: document the storage layout
+      */
+    inline const MatrixType& matrixLLT() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return m_matrix;
+    }
+
+    MatrixType reconstructedMatrix() const;
+
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears not to be positive definite.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "LLT is not initialized.");
+      return m_info;
+    }
+
+    /** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
+      *
+      * This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
+      * \code x = decomposition.adjoint().solve(b) \endcode
+      */
+    const LLT& adjoint() const EIGEN_NOEXCEPT { return *this; };
+
+    inline EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    inline EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+    template<typename VectorType>
+    LLT & rankUpdate(const VectorType& vec, const RealScalar& sigma = 1);
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    /** \internal
+      * Used to compute and store L
+      * The strict upper part is not used and even not initialized.
+      */
+    MatrixType m_matrix;
+    RealScalar m_l1_norm;
+    bool m_isInitialized;
+    ComputationInfo m_info;
+};
+
+namespace internal {
+
+template<typename Scalar, int UpLo> struct llt_inplace;
+
+template<typename MatrixType, typename VectorType>
+static Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)
+{
+  using std::sqrt;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename MatrixType::ColXpr ColXpr;
+  typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
+  typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
+  typedef Matrix<Scalar,Dynamic,1> TempVectorType;
+  typedef typename TempVectorType::SegmentReturnType TempVecSegment;
+
+  Index n = mat.cols();
+  eigen_assert(mat.rows()==n && vec.size()==n);
+
+  TempVectorType temp;
+
+  if(sigma>0)
+  {
+    // This version is based on Givens rotations.
+    // It is faster than the other one below, but only works for updates,
+    // i.e., for sigma > 0
+    temp = sqrt(sigma) * vec;
+
+    for(Index i=0; i<n; ++i)
+    {
+      JacobiRotation<Scalar> g;
+      g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
+
+      Index rs = n-i-1;
+      if(rs>0)
+      {
+        ColXprSegment x(mat.col(i).tail(rs));
+        TempVecSegment y(temp.tail(rs));
+        apply_rotation_in_the_plane(x, y, g);
+      }
+    }
+  }
+  else
+  {
+    temp = vec;
+    RealScalar beta = 1;
+    for(Index j=0; j<n; ++j)
+    {
+      RealScalar Ljj = numext::real(mat.coeff(j,j));
+      RealScalar dj = numext::abs2(Ljj);
+      Scalar wj = temp.coeff(j);
+      RealScalar swj2 = sigma*numext::abs2(wj);
+      RealScalar gamma = dj*beta + swj2;
+
+      RealScalar x = dj + swj2/beta;
+      if (x<=RealScalar(0))
+        return j;
+      RealScalar nLjj = sqrt(x);
+      mat.coeffRef(j,j) = nLjj;
+      beta += swj2/dj;
+
+      // Update the terms of L
+      Index rs = n-j-1;
+      if(rs)
+      {
+        temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
+        if(gamma != 0)
+          mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
+      }
+    }
+  }
+  return -1;
+}
+
+template<typename Scalar> struct llt_inplace<Scalar, Lower>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename MatrixType>
+  static Index unblocked(MatrixType& mat)
+  {
+    using std::sqrt;
+
+    eigen_assert(mat.rows()==mat.cols());
+    const Index size = mat.rows();
+    for(Index k = 0; k < size; ++k)
+    {
+      Index rs = size-k-1; // remaining size
+
+      Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
+      Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
+      Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
+
+      RealScalar x = numext::real(mat.coeff(k,k));
+      if (k>0) x -= A10.squaredNorm();
+      if (x<=RealScalar(0))
+        return k;
+      mat.coeffRef(k,k) = x = sqrt(x);
+      if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint();
+      if (rs>0) A21 /= x;
+    }
+    return -1;
+  }
+
+  template<typename MatrixType>
+  static Index blocked(MatrixType& m)
+  {
+    eigen_assert(m.rows()==m.cols());
+    Index size = m.rows();
+    if(size<32)
+      return unblocked(m);
+
+    Index blockSize = size/8;
+    blockSize = (blockSize/16)*16;
+    blockSize = (std::min)((std::max)(blockSize,Index(8)), Index(128));
+
+    for (Index k=0; k<size; k+=blockSize)
+    {
+      // partition the matrix:
+      //       A00 |  -  |  -
+      // lu  = A10 | A11 |  -
+      //       A20 | A21 | A22
+      Index bs = (std::min)(blockSize, size-k);
+      Index rs = size - k - bs;
+      Block<MatrixType,Dynamic,Dynamic> A11(m,k,   k,   bs,bs);
+      Block<MatrixType,Dynamic,Dynamic> A21(m,k+bs,k,   rs,bs);
+      Block<MatrixType,Dynamic,Dynamic> A22(m,k+bs,k+bs,rs,rs);
+
+      Index ret;
+      if((ret=unblocked(A11))>=0) return k+ret;
+      if(rs>0) A11.adjoint().template triangularView<Upper>().template solveInPlace<OnTheRight>(A21);
+      if(rs>0) A22.template selfadjointView<Lower>().rankUpdate(A21,typename NumTraits<RealScalar>::Literal(-1)); // bottleneck
+    }
+    return -1;
+  }
+
+  template<typename MatrixType, typename VectorType>
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
+  {
+    return Eigen::internal::llt_rank_update_lower(mat, vec, sigma);
+  }
+};
+
+template<typename Scalar> struct llt_inplace<Scalar, Upper>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  template<typename MatrixType>
+  static EIGEN_STRONG_INLINE Index unblocked(MatrixType& mat)
+  {
+    Transpose<MatrixType> matt(mat);
+    return llt_inplace<Scalar, Lower>::unblocked(matt);
+  }
+  template<typename MatrixType>
+  static EIGEN_STRONG_INLINE Index blocked(MatrixType& mat)
+  {
+    Transpose<MatrixType> matt(mat);
+    return llt_inplace<Scalar, Lower>::blocked(matt);
+  }
+  template<typename MatrixType, typename VectorType>
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
+  {
+    Transpose<MatrixType> matt(mat);
+    return llt_inplace<Scalar, Lower>::rankUpdate(matt, vec.conjugate(), sigma);
+  }
+};
+
+template<typename MatrixType> struct LLT_Traits<MatrixType,Lower>
+{
+  typedef const TriangularView<const MatrixType, Lower> MatrixL;
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
+  static bool inplace_decomposition(MatrixType& m)
+  { return llt_inplace<typename MatrixType::Scalar, Lower>::blocked(m)==-1; }
+};
+
+template<typename MatrixType> struct LLT_Traits<MatrixType,Upper>
+{
+  typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
+  typedef const TriangularView<const MatrixType, Upper> MatrixU;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
+  static bool inplace_decomposition(MatrixType& m)
+  { return llt_inplace<typename MatrixType::Scalar, Upper>::blocked(m)==-1; }
+};
+
+} // end namespace internal
+
+/** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix
+  *
+  * \returns a reference to *this
+  *
+  * Example: \include TutorialLinAlgComputeTwice.cpp
+  * Output: \verbinclude TutorialLinAlgComputeTwice.out
+  */
+template<typename MatrixType, int _UpLo>
+template<typename InputType>
+LLT<MatrixType,_UpLo>& LLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
+{
+  check_template_parameters();
+
+  eigen_assert(a.rows()==a.cols());
+  const Index size = a.rows();
+  m_matrix.resize(size, size);
+  if (!internal::is_same_dense(m_matrix, a.derived()))
+    m_matrix = a.derived();
+
+  // Compute matrix L1 norm = max abs column sum.
+  m_l1_norm = RealScalar(0);
+  // TODO move this code to SelfAdjointView
+  for (Index col = 0; col < size; ++col) {
+    RealScalar abs_col_sum;
+    if (_UpLo == Lower)
+      abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
+    else
+      abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
+    if (abs_col_sum > m_l1_norm)
+      m_l1_norm = abs_col_sum;
+  }
+
+  m_isInitialized = true;
+  bool ok = Traits::inplace_decomposition(m_matrix);
+  m_info = ok ? Success : NumericalIssue;
+
+  return *this;
+}
+
+/** Performs a rank one update (or dowdate) of the current decomposition.
+  * If A = LL^* before the rank one update,
+  * then after it we have LL^* = A + sigma * v v^* where \a v must be a vector
+  * of same dimension.
+  */
+template<typename _MatrixType, int _UpLo>
+template<typename VectorType>
+LLT<_MatrixType,_UpLo> & LLT<_MatrixType,_UpLo>::rankUpdate(const VectorType& v, const RealScalar& sigma)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType);
+  eigen_assert(v.size()==m_matrix.cols());
+  eigen_assert(m_isInitialized);
+  if(internal::llt_inplace<typename MatrixType::Scalar, UpLo>::rankUpdate(m_matrix,v,sigma)>=0)
+    m_info = NumericalIssue;
+  else
+    m_info = Success;
+
+  return *this;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType,int _UpLo>
+template<typename RhsType, typename DstType>
+void LLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  _solve_impl_transposed<true>(rhs, dst);
+}
+
+template<typename _MatrixType,int _UpLo>
+template<bool Conjugate, typename RhsType, typename DstType>
+void LLT<_MatrixType,_UpLo>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+    dst = rhs;
+
+    matrixL().template conjugateIf<!Conjugate>().solveInPlace(dst);
+    matrixU().template conjugateIf<!Conjugate>().solveInPlace(dst);
+}
+#endif
+
+/** \internal use x = llt_object.solve(x);
+  *
+  * This is the \em in-place version of solve().
+  *
+  * \param bAndX represents both the right-hand side matrix b and result x.
+  *
+  * This version avoids a copy when the right hand side matrix b is not needed anymore.
+  *
+  * \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here.
+  * This function will const_cast it, so constness isn't honored here.
+  *
+  * \sa LLT::solve(), MatrixBase::llt()
+  */
+template<typename MatrixType, int _UpLo>
+template<typename Derived>
+void LLT<MatrixType,_UpLo>::solveInPlace(const MatrixBase<Derived> &bAndX) const
+{
+  eigen_assert(m_isInitialized && "LLT is not initialized.");
+  eigen_assert(m_matrix.rows()==bAndX.rows());
+  matrixL().solveInPlace(bAndX);
+  matrixU().solveInPlace(bAndX);
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: L L^*.
+ * This function is provided for debug purpose. */
+template<typename MatrixType, int _UpLo>
+MatrixType LLT<MatrixType,_UpLo>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LLT is not initialized.");
+  return matrixL() * matrixL().adjoint().toDenseMatrix();
+}
+
+/** \cholesky_module
+  * \returns the LLT decomposition of \c *this
+  * \sa SelfAdjointView::llt()
+  */
+template<typename Derived>
+inline const LLT<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::llt() const
+{
+  return LLT<PlainObject>(derived());
+}
+
+/** \cholesky_module
+  * \returns the LLT decomposition of \c *this
+  * \sa SelfAdjointView::llt()
+  */
+template<typename MatrixType, unsigned int UpLo>
+inline const LLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
+SelfAdjointView<MatrixType, UpLo>::llt() const
+{
+  return LLT<PlainObject,UpLo>(m_matrix);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_LLT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Cholesky/LLT_LAPACKE.h b/C++/yolo_bytetrack_old/include/Eigen/src/Cholesky/LLT_LAPACKE.h
new file mode 100644
index 00000000..bc6489e6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Cholesky/LLT_LAPACKE.h
@@ -0,0 +1,99 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *     LLt decomposition based on LAPACKE_?potrf function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_LLT_LAPACKE_H
+#define EIGEN_LLT_LAPACKE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Scalar> struct lapacke_llt;
+
+#define EIGEN_LAPACKE_LLT(EIGTYPE, BLASTYPE, LAPACKE_PREFIX) \
+template<> struct lapacke_llt<EIGTYPE> \
+{ \
+  template<typename MatrixType> \
+  static inline Index potrf(MatrixType& m, char uplo) \
+  { \
+    lapack_int matrix_order; \
+    lapack_int size, lda, info, StorageOrder; \
+    EIGTYPE* a; \
+    eigen_assert(m.rows()==m.cols()); \
+    /* Set up parameters for ?potrf */ \
+    size = convert_index<lapack_int>(m.rows()); \
+    StorageOrder = MatrixType::Flags&RowMajorBit?RowMajor:ColMajor; \
+    matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
+    a = &(m.coeffRef(0,0)); \
+    lda = convert_index<lapack_int>(m.outerStride()); \
+\
+    info = LAPACKE_##LAPACKE_PREFIX##potrf( matrix_order, uplo, size, (BLASTYPE*)a, lda ); \
+    info = (info==0) ? -1 : info>0 ? info-1 : size; \
+    return info; \
+  } \
+}; \
+template<> struct llt_inplace<EIGTYPE, Lower> \
+{ \
+  template<typename MatrixType> \
+  static Index blocked(MatrixType& m) \
+  { \
+    return lapacke_llt<EIGTYPE>::potrf(m, 'L'); \
+  } \
+  template<typename MatrixType, typename VectorType> \
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \
+  { return Eigen::internal::llt_rank_update_lower(mat, vec, sigma); } \
+}; \
+template<> struct llt_inplace<EIGTYPE, Upper> \
+{ \
+  template<typename MatrixType> \
+  static Index blocked(MatrixType& m) \
+  { \
+    return lapacke_llt<EIGTYPE>::potrf(m, 'U'); \
+  } \
+  template<typename MatrixType, typename VectorType> \
+  static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \
+  { \
+    Transpose<MatrixType> matt(mat); \
+    return llt_inplace<EIGTYPE, Lower>::rankUpdate(matt, vec.conjugate(), sigma); \
+  } \
+};
+
+EIGEN_LAPACKE_LLT(double, double, d)
+EIGEN_LAPACKE_LLT(float, float, s)
+EIGEN_LAPACKE_LLT(dcomplex, lapack_complex_double, z)
+EIGEN_LAPACKE_LLT(scomplex, lapack_complex_float, c)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_LLT_LAPACKE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/CholmodSupport/CholmodSupport.h b/C++/yolo_bytetrack_old/include/Eigen/src/CholmodSupport/CholmodSupport.h
new file mode 100644
index 00000000..adaf5285
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/CholmodSupport/CholmodSupport.h
@@ -0,0 +1,682 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLMODSUPPORT_H
+#define EIGEN_CHOLMODSUPPORT_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Scalar> struct cholmod_configure_matrix;
+
+template<> struct cholmod_configure_matrix<double> {
+  template<typename CholmodType>
+  static void run(CholmodType& mat) {
+    mat.xtype = CHOLMOD_REAL;
+    mat.dtype = CHOLMOD_DOUBLE;
+  }
+};
+
+template<> struct cholmod_configure_matrix<std::complex<double> > {
+  template<typename CholmodType>
+  static void run(CholmodType& mat) {
+    mat.xtype = CHOLMOD_COMPLEX;
+    mat.dtype = CHOLMOD_DOUBLE;
+  }
+};
+
+// Other scalar types are not yet supported by Cholmod
+// template<> struct cholmod_configure_matrix<float> {
+//   template<typename CholmodType>
+//   static void run(CholmodType& mat) {
+//     mat.xtype = CHOLMOD_REAL;
+//     mat.dtype = CHOLMOD_SINGLE;
+//   }
+// };
+//
+// template<> struct cholmod_configure_matrix<std::complex<float> > {
+//   template<typename CholmodType>
+//   static void run(CholmodType& mat) {
+//     mat.xtype = CHOLMOD_COMPLEX;
+//     mat.dtype = CHOLMOD_SINGLE;
+//   }
+// };
+
+} // namespace internal
+
+/** Wraps the Eigen sparse matrix \a mat into a Cholmod sparse matrix object.
+  * Note that the data are shared.
+  */
+template<typename _Scalar, int _Options, typename _StorageIndex>
+cholmod_sparse viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_StorageIndex> > mat)
+{
+  cholmod_sparse res;
+  res.nzmax   = mat.nonZeros();
+  res.nrow    = mat.rows();
+  res.ncol    = mat.cols();
+  res.p       = mat.outerIndexPtr();
+  res.i       = mat.innerIndexPtr();
+  res.x       = mat.valuePtr();
+  res.z       = 0;
+  res.sorted  = 1;
+  if(mat.isCompressed())
+  {
+    res.packed  = 1;
+    res.nz = 0;
+  }
+  else
+  {
+    res.packed  = 0;
+    res.nz = mat.innerNonZeroPtr();
+  }
+
+  res.dtype   = 0;
+  res.stype   = -1;
+
+  if (internal::is_same<_StorageIndex,int>::value)
+  {
+    res.itype = CHOLMOD_INT;
+  }
+  else if (internal::is_same<_StorageIndex,SuiteSparse_long>::value)
+  {
+    res.itype = CHOLMOD_LONG;
+  }
+  else
+  {
+    eigen_assert(false && "Index type not supported yet");
+  }
+
+  // setup res.xtype
+  internal::cholmod_configure_matrix<_Scalar>::run(res);
+
+  res.stype = 0;
+
+  return res;
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+const cholmod_sparse viewAsCholmod(const SparseMatrix<_Scalar,_Options,_Index>& mat)
+{
+  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.const_cast_derived()));
+  return res;
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+const cholmod_sparse viewAsCholmod(const SparseVector<_Scalar,_Options,_Index>& mat)
+{
+  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.const_cast_derived()));
+  return res;
+}
+
+/** Returns a view of the Eigen sparse matrix \a mat as Cholmod sparse matrix.
+  * The data are not copied but shared. */
+template<typename _Scalar, int _Options, typename _Index, unsigned int UpLo>
+cholmod_sparse viewAsCholmod(const SparseSelfAdjointView<const SparseMatrix<_Scalar,_Options,_Index>, UpLo>& mat)
+{
+  cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<_Scalar,_Options,_Index> >(mat.matrix().const_cast_derived()));
+
+  if(UpLo==Upper) res.stype =  1;
+  if(UpLo==Lower) res.stype = -1;
+  // swap stype for rowmajor matrices (only works for real matrices)
+  EIGEN_STATIC_ASSERT((_Options & RowMajorBit) == 0 || NumTraits<_Scalar>::IsComplex == 0, THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  if(_Options & RowMajorBit) res.stype *=-1;
+
+  return res;
+}
+
+/** Returns a view of the Eigen \b dense matrix \a mat as Cholmod dense matrix.
+  * The data are not copied but shared. */
+template<typename Derived>
+cholmod_dense viewAsCholmod(MatrixBase<Derived>& mat)
+{
+  EIGEN_STATIC_ASSERT((internal::traits<Derived>::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  typedef typename Derived::Scalar Scalar;
+
+  cholmod_dense res;
+  res.nrow   = mat.rows();
+  res.ncol   = mat.cols();
+  res.nzmax  = res.nrow * res.ncol;
+  res.d      = Derived::IsVectorAtCompileTime ? mat.derived().size() : mat.derived().outerStride();
+  res.x      = (void*)(mat.derived().data());
+  res.z      = 0;
+
+  internal::cholmod_configure_matrix<Scalar>::run(res);
+
+  return res;
+}
+
+/** Returns a view of the Cholmod sparse matrix \a cm as an Eigen sparse matrix.
+  * The data are not copied but shared. */
+template<typename Scalar, int Flags, typename StorageIndex>
+MappedSparseMatrix<Scalar,Flags,StorageIndex> viewAsEigen(cholmod_sparse& cm)
+{
+  return MappedSparseMatrix<Scalar,Flags,StorageIndex>
+         (cm.nrow, cm.ncol, static_cast<StorageIndex*>(cm.p)[cm.ncol],
+          static_cast<StorageIndex*>(cm.p), static_cast<StorageIndex*>(cm.i),static_cast<Scalar*>(cm.x) );
+}
+
+namespace internal {
+
+// template specializations for int and long that call the correct cholmod method
+
+#define EIGEN_CHOLMOD_SPECIALIZE0(ret, name) \
+    template<typename _StorageIndex> inline ret cm_ ## name       (cholmod_common &Common) { return cholmod_ ## name   (&Common); } \
+    template<>                       inline ret cm_ ## name<SuiteSparse_long> (cholmod_common &Common) { return cholmod_l_ ## name (&Common); }
+
+#define EIGEN_CHOLMOD_SPECIALIZE1(ret, name, t1, a1) \
+    template<typename _StorageIndex> inline ret cm_ ## name       (t1& a1, cholmod_common &Common) { return cholmod_ ## name   (&a1, &Common); } \
+    template<>                       inline ret cm_ ## name<SuiteSparse_long> (t1& a1, cholmod_common &Common) { return cholmod_l_ ## name (&a1, &Common); }
+
+EIGEN_CHOLMOD_SPECIALIZE0(int, start)
+EIGEN_CHOLMOD_SPECIALIZE0(int, finish)
+
+EIGEN_CHOLMOD_SPECIALIZE1(int, free_factor, cholmod_factor*, L)
+EIGEN_CHOLMOD_SPECIALIZE1(int, free_dense,  cholmod_dense*,  X)
+EIGEN_CHOLMOD_SPECIALIZE1(int, free_sparse, cholmod_sparse*, A)
+
+EIGEN_CHOLMOD_SPECIALIZE1(cholmod_factor*, analyze, cholmod_sparse, A)
+
+template<typename _StorageIndex> inline cholmod_dense*  cm_solve         (int sys, cholmod_factor& L, cholmod_dense&  B, cholmod_common &Common) { return cholmod_solve     (sys, &L, &B, &Common); }
+template<>                       inline cholmod_dense*  cm_solve<SuiteSparse_long>   (int sys, cholmod_factor& L, cholmod_dense&  B, cholmod_common &Common) { return cholmod_l_solve   (sys, &L, &B, &Common); }
+
+template<typename _StorageIndex> inline cholmod_sparse* cm_spsolve       (int sys, cholmod_factor& L, cholmod_sparse& B, cholmod_common &Common) { return cholmod_spsolve   (sys, &L, &B, &Common); }
+template<>                       inline cholmod_sparse* cm_spsolve<SuiteSparse_long> (int sys, cholmod_factor& L, cholmod_sparse& B, cholmod_common &Common) { return cholmod_l_spsolve (sys, &L, &B, &Common); }
+
+template<typename _StorageIndex>
+inline int  cm_factorize_p       (cholmod_sparse*  A, double beta[2], _StorageIndex* fset, std::size_t fsize, cholmod_factor* L, cholmod_common &Common) { return cholmod_factorize_p   (A, beta, fset, fsize, L, &Common); }
+template<>
+inline int  cm_factorize_p<SuiteSparse_long> (cholmod_sparse*  A, double beta[2], SuiteSparse_long* fset,          std::size_t fsize, cholmod_factor* L, cholmod_common &Common) { return cholmod_l_factorize_p (A, beta, fset, fsize, L, &Common); }
+
+#undef EIGEN_CHOLMOD_SPECIALIZE0
+#undef EIGEN_CHOLMOD_SPECIALIZE1
+
+}  // namespace internal
+
+
+enum CholmodMode {
+  CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt
+};
+
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodBase
+  * \brief The base class for the direct Cholesky factorization of Cholmod
+  * \sa class CholmodSupernodalLLT, class CholmodSimplicialLDLT, class CholmodSimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo, typename Derived>
+class CholmodBase : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+  public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef MatrixType CholMatrixType;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    CholmodBase()
+      : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<double,RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
+      m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
+      internal::cm_start<StorageIndex>(m_cholmod);
+    }
+
+    explicit CholmodBase(const MatrixType& matrix)
+      : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<double,RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
+      m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
+      internal::cm_start<StorageIndex>(m_cholmod);
+      compute(matrix);
+    }
+
+    ~CholmodBase()
+    {
+      if(m_cholmodFactor)
+        internal::cm_free_factor<StorageIndex>(m_cholmodFactor, m_cholmod);
+      internal::cm_finish<StorageIndex>(m_cholmod);
+    }
+
+    inline StorageIndex cols() const { return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }
+    inline StorageIndex rows() const { return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    Derived& compute(const MatrixType& matrix)
+    {
+      analyzePattern(matrix);
+      factorize(matrix);
+      return derived();
+    }
+
+    /** Performs a symbolic decomposition on the sparsity pattern of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      if(m_cholmodFactor)
+      {
+        internal::cm_free_factor<StorageIndex>(m_cholmodFactor, m_cholmod);
+        m_cholmodFactor = 0;
+      }
+      cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
+      m_cholmodFactor = internal::cm_analyze<StorageIndex>(A, m_cholmod);
+
+      this->m_isInitialized = true;
+      this->m_info = Success;
+      m_analysisIsOk = true;
+      m_factorizationIsOk = false;
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must have the same sparsity pattern as the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& matrix)
+    {
+      eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+      cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
+      internal::cm_factorize_p<StorageIndex>(&A, m_shiftOffset, 0, 0, m_cholmodFactor, m_cholmod);
+
+      // If the factorization failed, minor is the column at which it did. On success minor == n.
+      this->m_info = (m_cholmodFactor->minor == m_cholmodFactor->n ? Success : NumericalIssue);
+      m_factorizationIsOk = true;
+    }
+
+    /** Returns a reference to the Cholmod's configuration structure to get a full control over the performed operations.
+     *  See the Cholmod user guide for details. */
+    cholmod_common& cholmod() { return m_cholmod; }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      const Index size = m_cholmodFactor->n;
+      EIGEN_UNUSED_VARIABLE(size);
+      eigen_assert(size==b.rows());
+
+      // Cholmod needs column-major storage without inner-stride, which corresponds to the default behavior of Ref.
+      Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b.derived());
+
+      cholmod_dense b_cd = viewAsCholmod(b_ref);
+      cholmod_dense* x_cd = internal::cm_solve<StorageIndex>(CHOLMOD_A, *m_cholmodFactor, b_cd, m_cholmod);
+      if(!x_cd)
+      {
+        this->m_info = NumericalIssue;
+        return;
+      }
+      // TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
+      // NOTE Actually, the copy can be avoided by calling cholmod_solve2 instead of cholmod_solve
+      dest = Matrix<Scalar,Dest::RowsAtCompileTime,Dest::ColsAtCompileTime>::Map(reinterpret_cast<Scalar*>(x_cd->x),b.rows(),b.cols());
+      internal::cm_free_dense<StorageIndex>(x_cd, m_cholmod);
+    }
+
+    /** \internal */
+    template<typename RhsDerived, typename DestDerived>
+    void _solve_impl(const SparseMatrixBase<RhsDerived> &b, SparseMatrixBase<DestDerived> &dest) const
+    {
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      const Index size = m_cholmodFactor->n;
+      EIGEN_UNUSED_VARIABLE(size);
+      eigen_assert(size==b.rows());
+
+      // note: cs stands for Cholmod Sparse
+      Ref<SparseMatrix<typename RhsDerived::Scalar,ColMajor,typename RhsDerived::StorageIndex> > b_ref(b.const_cast_derived());
+      cholmod_sparse b_cs = viewAsCholmod(b_ref);
+      cholmod_sparse* x_cs = internal::cm_spsolve<StorageIndex>(CHOLMOD_A, *m_cholmodFactor, b_cs, m_cholmod);
+      if(!x_cs)
+      {
+        this->m_info = NumericalIssue;
+        return;
+      }
+      // TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
+      // NOTE cholmod_spsolve in fact just calls the dense solver for blocks of 4 columns at a time (similar to Eigen's sparse solver)
+      dest.derived() = viewAsEigen<typename DestDerived::Scalar,ColMajor,typename DestDerived::StorageIndex>(*x_cs);
+      internal::cm_free_sparse<StorageIndex>(x_cs, m_cholmod);
+    }
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+
+
+    /** Sets the shift parameter that will be used to adjust the diagonal coefficients during the numerical factorization.
+      *
+      * During the numerical factorization, an offset term is added to the diagonal coefficients:\n
+      * \c d_ii = \a offset + \c d_ii
+      *
+      * The default is \a offset=0.
+      *
+      * \returns a reference to \c *this.
+      */
+    Derived& setShift(const RealScalar& offset)
+    {
+      m_shiftOffset[0] = double(offset);
+      return derived();
+    }
+
+    /** \returns the determinant of the underlying matrix from the current factorization */
+    Scalar determinant() const
+    {
+      using std::exp;
+      return exp(logDeterminant());
+    }
+
+    /** \returns the log determinant of the underlying matrix from the current factorization */
+    Scalar logDeterminant() const
+    {
+      using std::log;
+      using numext::real;
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+
+      RealScalar logDet = 0;
+      Scalar *x = static_cast<Scalar*>(m_cholmodFactor->x);
+      if (m_cholmodFactor->is_super)
+      {
+        // Supernodal factorization stored as a packed list of dense column-major blocs,
+        // as described by the following structure:
+
+        // super[k] == index of the first column of the j-th super node
+        StorageIndex *super = static_cast<StorageIndex*>(m_cholmodFactor->super);
+        // pi[k] == offset to the description of row indices
+        StorageIndex *pi = static_cast<StorageIndex*>(m_cholmodFactor->pi);
+        // px[k] == offset to the respective dense block
+        StorageIndex *px = static_cast<StorageIndex*>(m_cholmodFactor->px);
+
+        Index nb_super_nodes = m_cholmodFactor->nsuper;
+        for (Index k=0; k < nb_super_nodes; ++k)
+        {
+          StorageIndex ncols = super[k + 1] - super[k];
+          StorageIndex nrows = pi[k + 1] - pi[k];
+
+          Map<const Array<Scalar,1,Dynamic>, 0, InnerStride<> > sk(x + px[k], ncols, InnerStride<>(nrows+1));
+          logDet += sk.real().log().sum();
+        }
+      }
+      else
+      {
+        // Simplicial factorization stored as standard CSC matrix.
+        StorageIndex *p = static_cast<StorageIndex*>(m_cholmodFactor->p);
+        Index size = m_cholmodFactor->n;
+        for (Index k=0; k<size; ++k)
+          logDet += log(real( x[p[k]] ));
+      }
+      if (m_cholmodFactor->is_ll)
+        logDet *= 2.0;
+      return logDet;
+    };
+
+    template<typename Stream>
+    void dumpMemory(Stream& /*s*/)
+    {}
+
+  protected:
+    mutable cholmod_common m_cholmod;
+    cholmod_factor* m_cholmodFactor;
+    double m_shiftOffset[2];
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+};
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodSimplicialLLT
+  * \brief A simplicial direct Cholesky (LLT) factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a simplicial LL^T Cholesky factorization
+  * using the Cholmod library.
+  * This simplicial variant is equivalent to Eigen's built-in SimplicialLLT class. Therefore, it has little practical interest.
+  * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept, class CholmodSupernodalLLT, class SimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodSimplicialLLT : public CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLLT<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLLT> Base;
+    using Base::m_cholmod;
+
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    CholmodSimplicialLLT() : Base() { init(); }
+
+    CholmodSimplicialLLT(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodSimplicialLLT() {}
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 0;
+      m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+      m_cholmod.final_ll = 1;
+    }
+};
+
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodSimplicialLDLT
+  * \brief A simplicial direct Cholesky (LDLT) factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a simplicial LDL^T Cholesky factorization
+  * using the Cholmod library.
+  * This simplicial variant is equivalent to Eigen's built-in SimplicialLDLT class. Therefore, it has little practical interest.
+  * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept, class CholmodSupernodalLLT, class SimplicialLDLT
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodSimplicialLDLT : public CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLDLT<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodSimplicialLDLT> Base;
+    using Base::m_cholmod;
+
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    CholmodSimplicialLDLT() : Base() { init(); }
+
+    CholmodSimplicialLDLT(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodSimplicialLDLT() {}
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 1;
+      m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+    }
+};
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodSupernodalLLT
+  * \brief A supernodal Cholesky (LLT) factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a supernodal LL^T Cholesky factorization
+  * using the Cholmod library.
+  * This supernodal variant performs best on dense enough problems, e.g., 3D FEM, or very high order 2D FEM.
+  * The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodSupernodalLLT : public CholmodBase<_MatrixType, _UpLo, CholmodSupernodalLLT<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodSupernodalLLT> Base;
+    using Base::m_cholmod;
+
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    CholmodSupernodalLLT() : Base() { init(); }
+
+    CholmodSupernodalLLT(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodSupernodalLLT() {}
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 1;
+      m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
+    }
+};
+
+/** \ingroup CholmodSupport_Module
+  * \class CholmodDecomposition
+  * \brief A general Cholesky factorization and solver based on Cholmod
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LL^T or LDL^T Cholesky factorization
+  * using the Cholmod library. The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * This variant permits to change the underlying Cholesky method at runtime.
+  * On the other hand, it does not provide access to the result of the factorization.
+  * The default is to let Cholmod automatically choose between a simplicial and supernodal factorization.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  *
+  * \implsparsesolverconcept
+  *
+  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.
+  *
+  * \warning Only double precision real and complex scalar types are supported by Cholmod.
+  *
+  * \sa \ref TutorialSparseSolverConcept
+  */
+template<typename _MatrixType, int _UpLo = Lower>
+class CholmodDecomposition : public CholmodBase<_MatrixType, _UpLo, CholmodDecomposition<_MatrixType, _UpLo> >
+{
+    typedef CholmodBase<_MatrixType, _UpLo, CholmodDecomposition> Base;
+    using Base::m_cholmod;
+
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    CholmodDecomposition() : Base() { init(); }
+
+    CholmodDecomposition(const MatrixType& matrix) : Base()
+    {
+      init();
+      this->compute(matrix);
+    }
+
+    ~CholmodDecomposition() {}
+
+    void setMode(CholmodMode mode)
+    {
+      switch(mode)
+      {
+        case CholmodAuto:
+          m_cholmod.final_asis = 1;
+          m_cholmod.supernodal = CHOLMOD_AUTO;
+          break;
+        case CholmodSimplicialLLt:
+          m_cholmod.final_asis = 0;
+          m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+          m_cholmod.final_ll = 1;
+          break;
+        case CholmodSupernodalLLt:
+          m_cholmod.final_asis = 1;
+          m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
+          break;
+        case CholmodLDLt:
+          m_cholmod.final_asis = 1;
+          m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
+          break;
+        default:
+          break;
+      }
+    }
+  protected:
+    void init()
+    {
+      m_cholmod.final_asis = 1;
+      m_cholmod.supernodal = CHOLMOD_AUTO;
+    }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CHOLMODSUPPORT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/ArithmeticSequence.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ArithmeticSequence.h
new file mode 100644
index 00000000..b6200fac
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ArithmeticSequence.h
@@ -0,0 +1,413 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARITHMETIC_SEQUENCE_H
+#define EIGEN_ARITHMETIC_SEQUENCE_H
+
+namespace Eigen {
+
+namespace internal {
+
+#if (!EIGEN_HAS_CXX11) || !((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48)
+template<typename T> struct aseq_negate {};
+
+template<> struct aseq_negate<Index> {
+  typedef Index type;
+};
+
+template<int N> struct aseq_negate<FixedInt<N> > {
+  typedef FixedInt<-N> type;
+};
+
+// Compilation error in the following case:
+template<> struct aseq_negate<FixedInt<DynamicIndex> > {};
+
+template<typename FirstType,typename SizeType,typename IncrType,
+         bool FirstIsSymbolic=symbolic::is_symbolic<FirstType>::value,
+         bool SizeIsSymbolic =symbolic::is_symbolic<SizeType>::value>
+struct aseq_reverse_first_type {
+  typedef Index type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,true> {
+  typedef symbolic::AddExpr<FirstType,
+                            symbolic::ProductExpr<symbolic::AddExpr<SizeType,symbolic::ValueExpr<FixedInt<-1> > >,
+                                                  symbolic::ValueExpr<IncrType> >
+                           > type;
+};
+
+template<typename SizeType,typename IncrType,typename EnableIf = void>
+struct aseq_reverse_first_type_aux {
+  typedef Index type;
+};
+
+template<typename SizeType,typename IncrType>
+struct aseq_reverse_first_type_aux<SizeType,IncrType,typename internal::enable_if<bool((SizeType::value+IncrType::value)|0x1)>::type> {
+  typedef FixedInt<(SizeType::value-1)*IncrType::value> type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,false> {
+  typedef typename aseq_reverse_first_type_aux<SizeType,IncrType>::type Aux;
+  typedef symbolic::AddExpr<FirstType,symbolic::ValueExpr<Aux> > type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct aseq_reverse_first_type<FirstType,SizeType,IncrType,false,true> {
+  typedef symbolic::AddExpr<symbolic::ProductExpr<symbolic::AddExpr<SizeType,symbolic::ValueExpr<FixedInt<-1> > >,
+                                                  symbolic::ValueExpr<IncrType> >,
+                            symbolic::ValueExpr<> > type;
+};
+#endif
+
+// Helper to cleanup the type of the increment:
+template<typename T> struct cleanup_seq_incr {
+  typedef typename cleanup_index_type<T,DynamicIndex>::type type;
+};
+
+}
+
+//--------------------------------------------------------------------------------
+// seq(first,last,incr) and seqN(first,size,incr)
+//--------------------------------------------------------------------------------
+
+template<typename FirstType=Index,typename SizeType=Index,typename IncrType=internal::FixedInt<1> >
+class ArithmeticSequence;
+
+template<typename FirstType,typename SizeType,typename IncrType>
+ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
+                   typename internal::cleanup_index_type<SizeType>::type,
+                   typename internal::cleanup_seq_incr<IncrType>::type >
+seqN(FirstType first, SizeType size, IncrType incr);
+
+/** \class ArithmeticSequence
+  * \ingroup Core_Module
+  *
+  * This class represents an arithmetic progression \f$ a_0, a_1, a_2, ..., a_{n-1}\f$ defined by
+  * its \em first value \f$ a_0 \f$, its \em size (aka length) \em n, and the \em increment (aka stride)
+  * that is equal to \f$ a_{i+1}-a_{i}\f$ for any \em i.
+  *
+  * It is internally used as the return type of the Eigen::seq and Eigen::seqN functions, and as the input arguments
+  * of DenseBase::operator()(const RowIndices&, const ColIndices&), and most of the time this is the
+  * only way it is used.
+  *
+  * \tparam FirstType type of the first element, usually an Index,
+  *                   but internally it can be a symbolic expression
+  * \tparam SizeType type representing the size of the sequence, usually an Index
+  *                  or a compile time integral constant. Internally, it can also be a symbolic expression
+  * \tparam IncrType type of the increment, can be a runtime Index, or a compile time integral constant (default is compile-time 1)
+  *
+  * \sa Eigen::seq, Eigen::seqN, DenseBase::operator()(const RowIndices&, const ColIndices&), class IndexedView
+  */
+template<typename FirstType,typename SizeType,typename IncrType>
+class ArithmeticSequence
+{
+public:
+  ArithmeticSequence(FirstType first, SizeType size) : m_first(first), m_size(size) {}
+  ArithmeticSequence(FirstType first, SizeType size, IncrType incr) : m_first(first), m_size(size), m_incr(incr) {}
+
+  enum {
+    SizeAtCompileTime = internal::get_fixed_value<SizeType>::value,
+    IncrAtCompileTime = internal::get_fixed_value<IncrType,DynamicIndex>::value
+  };
+
+  /** \returns the size, i.e., number of elements, of the sequence */
+  Index size()  const { return m_size; }
+
+  /** \returns the first element \f$ a_0 \f$ in the sequence */
+  Index first()  const { return m_first; }
+
+  /** \returns the value \f$ a_i \f$ at index \a i in the sequence. */
+  Index operator[](Index i) const { return m_first + i * m_incr; }
+
+  const FirstType& firstObject() const { return m_first; }
+  const SizeType&  sizeObject()  const { return m_size; }
+  const IncrType&  incrObject()  const { return m_incr; }
+
+protected:
+  FirstType m_first;
+  SizeType  m_size;
+  IncrType  m_incr;
+
+public:
+
+#if EIGEN_HAS_CXX11 && ((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48)
+  auto reverse() const -> decltype(Eigen::seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr)) {
+    return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr);
+  }
+#else
+protected:
+  typedef typename internal::aseq_negate<IncrType>::type ReverseIncrType;
+  typedef typename internal::aseq_reverse_first_type<FirstType,SizeType,IncrType>::type ReverseFirstType;
+public:
+  ArithmeticSequence<ReverseFirstType,SizeType,ReverseIncrType>
+  reverse() const {
+    return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr);
+  }
+#endif
+};
+
+/** \returns an ArithmeticSequence starting at \a first, of length \a size, and increment \a incr
+  *
+  * \sa seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) */
+template<typename FirstType,typename SizeType,typename IncrType>
+ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type,typename internal::cleanup_seq_incr<IncrType>::type >
+seqN(FirstType first, SizeType size, IncrType incr)  {
+  return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type,typename internal::cleanup_seq_incr<IncrType>::type>(first,size,incr);
+}
+
+/** \returns an ArithmeticSequence starting at \a first, of length \a size, and unit increment
+  *
+  * \sa seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType) */
+template<typename FirstType,typename SizeType>
+ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type >
+seqN(FirstType first, SizeType size)  {
+  return ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,typename internal::cleanup_index_type<SizeType>::type>(first,size);
+}
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+
+/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and with positive (or negative) increment \a incr
+  *
+  * It is essentially an alias to:
+  * \code
+  * seqN(f, (l-f+incr)/incr, incr);
+  * \endcode
+  *
+  * \sa seqN(FirstType,SizeType,IncrType), seq(FirstType,LastType)
+  */
+template<typename FirstType,typename LastType, typename IncrType>
+auto seq(FirstType f, LastType l, IncrType incr);
+
+/** \returns an ArithmeticSequence starting at \a f, up (or down) to \a l, and unit increment
+  *
+  * It is essentially an alias to:
+  * \code
+  * seqN(f,l-f+1);
+  * \endcode
+  *
+  * \sa seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType)
+  */
+template<typename FirstType,typename LastType>
+auto seq(FirstType f, LastType l);
+
+#else // EIGEN_PARSED_BY_DOXYGEN
+
+#if EIGEN_HAS_CXX11
+template<typename FirstType,typename LastType>
+auto seq(FirstType f, LastType l) -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+                                                   (  typename internal::cleanup_index_type<LastType>::type(l)
+                                                    - typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>())))
+{
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              (typename internal::cleanup_index_type<LastType>::type(l)
+               -typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()));
+}
+
+template<typename FirstType,typename LastType, typename IncrType>
+auto seq(FirstType f, LastType l, IncrType incr)
+  -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+                   (   typename internal::cleanup_index_type<LastType>::type(l)
+                     - typename internal::cleanup_index_type<FirstType>::type(f)+typename internal::cleanup_seq_incr<IncrType>::type(incr)
+                   ) / typename internal::cleanup_seq_incr<IncrType>::type(incr),
+                   typename internal::cleanup_seq_incr<IncrType>::type(incr)))
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              ( typename internal::cleanup_index_type<LastType>::type(l)
+               -typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr)) / CleanedIncrType(incr),
+              CleanedIncrType(incr));
+}
+
+#else // EIGEN_HAS_CXX11
+
+template<typename FirstType,typename LastType>
+typename internal::enable_if<!(symbolic::is_symbolic<FirstType>::value || symbolic::is_symbolic<LastType>::value),
+                             ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index> >::type
+seq(FirstType f, LastType l)
+{
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              Index((typename internal::cleanup_index_type<LastType>::type(l)-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>())));
+}
+
+template<typename FirstTypeDerived,typename LastType>
+typename internal::enable_if<!symbolic::is_symbolic<LastType>::value,
+    ArithmeticSequence<FirstTypeDerived, symbolic::AddExpr<symbolic::AddExpr<symbolic::NegateExpr<FirstTypeDerived>,symbolic::ValueExpr<> >,
+                                                            symbolic::ValueExpr<internal::FixedInt<1> > > > >::type
+seq(const symbolic::BaseExpr<FirstTypeDerived> &f, LastType l)
+{
+  return seqN(f.derived(),(typename internal::cleanup_index_type<LastType>::type(l)-f.derived()+fix<1>()));
+}
+
+template<typename FirstType,typename LastTypeDerived>
+typename internal::enable_if<!symbolic::is_symbolic<FirstType>::value,
+    ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
+                        symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::ValueExpr<> >,
+                                          symbolic::ValueExpr<internal::FixedInt<1> > > > >::type
+seq(FirstType f, const symbolic::BaseExpr<LastTypeDerived> &l)
+{
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),(l.derived()-typename internal::cleanup_index_type<FirstType>::type(f)+fix<1>()));
+}
+
+template<typename FirstTypeDerived,typename LastTypeDerived>
+ArithmeticSequence<FirstTypeDerived,
+                    symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::NegateExpr<FirstTypeDerived> >,symbolic::ValueExpr<internal::FixedInt<1> > > >
+seq(const symbolic::BaseExpr<FirstTypeDerived> &f, const symbolic::BaseExpr<LastTypeDerived> &l)
+{
+  return seqN(f.derived(),(l.derived()-f.derived()+fix<1>()));
+}
+
+
+template<typename FirstType,typename LastType, typename IncrType>
+typename internal::enable_if<!(symbolic::is_symbolic<FirstType>::value || symbolic::is_symbolic<LastType>::value),
+    ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,Index,typename internal::cleanup_seq_incr<IncrType>::type> >::type
+seq(FirstType f, LastType l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              Index((typename internal::cleanup_index_type<LastType>::type(l)-typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr))/CleanedIncrType(incr)), incr);
+}
+
+template<typename FirstTypeDerived,typename LastType, typename IncrType>
+typename internal::enable_if<!symbolic::is_symbolic<LastType>::value,
+    ArithmeticSequence<FirstTypeDerived,
+                        symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<symbolic::NegateExpr<FirstTypeDerived>,
+                                                                                   symbolic::ValueExpr<> >,
+                                                                 symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                                              symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                        typename internal::cleanup_seq_incr<IncrType>::type> >::type
+seq(const symbolic::BaseExpr<FirstTypeDerived> &f, LastType l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(f.derived(),(typename internal::cleanup_index_type<LastType>::type(l)-f.derived()+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
+}
+
+template<typename FirstType,typename LastTypeDerived, typename IncrType>
+typename internal::enable_if<!symbolic::is_symbolic<FirstType>::value,
+    ArithmeticSequence<typename internal::cleanup_index_type<FirstType>::type,
+                        symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,symbolic::ValueExpr<> >,
+                                                                 symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                                               symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                        typename internal::cleanup_seq_incr<IncrType>::type> >::type
+seq(FirstType f, const symbolic::BaseExpr<LastTypeDerived> &l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
+              (l.derived()-typename internal::cleanup_index_type<FirstType>::type(f)+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
+}
+
+template<typename FirstTypeDerived,typename LastTypeDerived, typename IncrType>
+ArithmeticSequence<FirstTypeDerived,
+                    symbolic::QuotientExpr<symbolic::AddExpr<symbolic::AddExpr<LastTypeDerived,
+                                                                               symbolic::NegateExpr<FirstTypeDerived> >,
+                                                             symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                                          symbolic::ValueExpr<typename internal::cleanup_seq_incr<IncrType>::type> >,
+                    typename internal::cleanup_seq_incr<IncrType>::type>
+seq(const symbolic::BaseExpr<FirstTypeDerived> &f, const symbolic::BaseExpr<LastTypeDerived> &l, IncrType incr)
+{
+  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+  return seqN(f.derived(),(l.derived()-f.derived()+CleanedIncrType(incr))/CleanedIncrType(incr), incr);
+}
+#endif // EIGEN_HAS_CXX11
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+
+#if EIGEN_HAS_CXX11 || defined(EIGEN_PARSED_BY_DOXYGEN)
+/** \cpp11
+  * \returns a symbolic ArithmeticSequence representing the last \a size elements with increment \a incr.
+  *
+  * It is a shortcut for: \code seqN(last-(size-fix<1>)*incr, size, incr) \endcode
+  * 
+  * \sa lastN(SizeType), seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) */
+template<typename SizeType,typename IncrType>
+auto lastN(SizeType size, IncrType incr)
+-> decltype(seqN(Eigen::last-(size-fix<1>())*incr, size, incr))
+{
+  return seqN(Eigen::last-(size-fix<1>())*incr, size, incr);
+}
+
+/** \cpp11
+  * \returns a symbolic ArithmeticSequence representing the last \a size elements with a unit increment.
+  *
+  *  It is a shortcut for: \code seq(last+fix<1>-size, last) \endcode
+  * 
+  * \sa lastN(SizeType,IncrType, seqN(FirstType,SizeType), seq(FirstType,LastType) */
+template<typename SizeType>
+auto lastN(SizeType size)
+-> decltype(seqN(Eigen::last+fix<1>()-size, size))
+{
+  return seqN(Eigen::last+fix<1>()-size, size);
+}
+#endif
+
+namespace internal {
+
+// Convert a symbolic span into a usable one (i.e., remove last/end "keywords")
+template<typename T>
+struct make_size_type {
+  typedef typename internal::conditional<symbolic::is_symbolic<T>::value, Index, T>::type type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType,int XprSize>
+struct IndexedViewCompatibleType<ArithmeticSequence<FirstType,SizeType,IncrType>, XprSize> {
+  typedef ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType> type;
+};
+
+template<typename FirstType,typename SizeType,typename IncrType>
+ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType>
+makeIndexedViewCompatible(const ArithmeticSequence<FirstType,SizeType,IncrType>& ids, Index size,SpecializedType) {
+  return ArithmeticSequence<Index,typename make_size_type<SizeType>::type,IncrType>(
+            eval_expr_given_size(ids.firstObject(),size),eval_expr_given_size(ids.sizeObject(),size),ids.incrObject());
+}
+
+template<typename FirstType,typename SizeType,typename IncrType>
+struct get_compile_time_incr<ArithmeticSequence<FirstType,SizeType,IncrType> > {
+  enum { value = get_fixed_value<IncrType,DynamicIndex>::value };
+};
+
+} // end namespace internal
+
+/** \namespace Eigen::indexing
+  * \ingroup Core_Module
+  * 
+  * The sole purpose of this namespace is to be able to import all functions
+  * and symbols that are expected to be used within operator() for indexing
+  * and slicing. If you already imported the whole Eigen namespace:
+  * \code using namespace Eigen; \endcode
+  * then you are already all set. Otherwise, if you don't want/cannot import
+  * the whole Eigen namespace, the following line:
+  * \code using namespace Eigen::indexing; \endcode
+  * is equivalent to:
+  * \code
+  using Eigen::all;
+  using Eigen::seq;
+  using Eigen::seqN;
+  using Eigen::lastN; // c++11 only
+  using Eigen::last;
+  using Eigen::lastp1;
+  using Eigen::fix;
+  \endcode
+  */
+namespace indexing {
+  using Eigen::all;
+  using Eigen::seq;
+  using Eigen::seqN;
+  #if EIGEN_HAS_CXX11
+  using Eigen::lastN;
+  #endif
+  using Eigen::last;
+  using Eigen::lastp1;
+  using Eigen::fix;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARITHMETIC_SEQUENCE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Array.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Array.h
new file mode 100644
index 00000000..20c789b1
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Array.h
@@ -0,0 +1,417 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARRAY_H
+#define EIGEN_ARRAY_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct traits<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > : traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+  typedef ArrayXpr XprKind;
+  typedef ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > XprBase;
+};
+}
+
+/** \class Array
+  * \ingroup Core_Module
+  *
+  * \brief General-purpose arrays with easy API for coefficient-wise operations
+  *
+  * The %Array class is very similar to the Matrix class. It provides
+  * general-purpose one- and two-dimensional arrays. The difference between the
+  * %Array and the %Matrix class is primarily in the API: the API for the
+  * %Array class provides easy access to coefficient-wise operations, while the
+  * API for the %Matrix class provides easy access to linear-algebra
+  * operations.
+  *
+  * See documentation of class Matrix for detailed information on the template parameters
+  * storage layout.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_ARRAY_PLUGIN.
+  *
+  * \sa \blank \ref TutorialArrayClass, \ref TopicClassHierarchy
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+class Array
+  : public PlainObjectBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+  public:
+
+    typedef PlainObjectBase<Array> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Array)
+
+    enum { Options = _Options };
+    typedef typename Base::PlainObject PlainObject;
+
+  protected:
+    template <typename Derived, typename OtherDerived, bool IsVector>
+    friend struct internal::conservative_resize_like_impl;
+
+    using Base::m_storage;
+
+  public:
+
+    using Base::base;
+    using Base::coeff;
+    using Base::coeffRef;
+
+    /**
+      * The usage of
+      *   using Base::operator=;
+      * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped
+      * the usage of 'using'. This should be done only for operator=.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const EigenBase<OtherDerived> &other)
+    {
+      return Base::operator=(other);
+    }
+
+    /** Set all the entries to \a value.
+      * \sa DenseBase::setConstant(), DenseBase::fill()
+      */
+    /* This overload is needed because the usage of
+      *   using Base::operator=;
+      * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped
+      * the usage of 'using'. This should be done only for operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const Scalar &value)
+    {
+      Base::setConstant(value);
+      return *this;
+    }
+
+    /** Copies the value of the expression \a other into \c *this with automatic resizing.
+      *
+      * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
+      * it will be initialized.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const DenseBase<OtherDerived>& other)
+    {
+      return Base::_set(other);
+    }
+
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array& operator=(const Array& other)
+    {
+      return Base::_set(other);
+    }
+
+    /** Default constructor.
+      *
+      * For fixed-size matrices, does nothing.
+      *
+      * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix
+      * is called a null matrix. This constructor is the unique way to create null matrices: resizing
+      * a matrix to 0 is not supported.
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array() : Base()
+    {
+      Base::_check_template_params();
+      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    // FIXME is it still needed ??
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    Array(internal::constructor_without_unaligned_array_assert)
+      : Base(internal::constructor_without_unaligned_array_assert())
+    {
+      Base::_check_template_params();
+      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+#endif
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    Array(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible<Scalar>::value)
+      : Base(std::move(other))
+    {
+      Base::_check_template_params();
+    }
+    EIGEN_DEVICE_FUNC
+    Array& operator=(Array&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
+    {
+      Base::operator=(std::move(other));
+      return *this;
+    }
+#endif
+
+    #if EIGEN_HAS_CXX11
+    /** \copydoc PlainObjectBase(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
+     *
+     * Example: \include Array_variadic_ctor_cxx11.cpp
+     * Output: \verbinclude Array_variadic_ctor_cxx11.out
+     *
+     * \sa Array(const std::initializer_list<std::initializer_list<Scalar>>&)
+     * \sa Array(const Scalar&), Array(const Scalar&,const Scalar&)
+     */
+    template <typename... ArgTypes>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
+      : Base(a0, a1, a2, a3, args...) {}
+
+    /** \brief Constructs an array and initializes it from the coefficients given as initializer-lists grouped by row. \cpp11
+      *
+      * In the general case, the constructor takes a list of rows, each row being represented as a list of coefficients:
+      *
+      * Example: \include Array_initializer_list_23_cxx11.cpp
+      * Output: \verbinclude Array_initializer_list_23_cxx11.out
+      *
+      * Each of the inner initializer lists must contain the exact same number of elements, otherwise an assertion is triggered.
+      *
+      * In the case of a compile-time column 1D array, implicit transposition from a single row is allowed.
+      * Therefore <code> Array<int,Dynamic,1>{{1,2,3,4,5}}</code> is legal and the more verbose syntax
+      * <code>Array<int,Dynamic,1>{{1},{2},{3},{4},{5}}</code> can be avoided:
+      *
+      * Example: \include Array_initializer_list_vector_cxx11.cpp
+      * Output: \verbinclude Array_initializer_list_vector_cxx11.out
+      *
+      * In the case of fixed-sized arrays, the initializer list sizes must exactly match the array sizes,
+      * and implicit transposition is allowed for compile-time 1D arrays only.
+      *
+      * \sa  Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const std::initializer_list<std::initializer_list<Scalar>>& list) : Base(list) {}
+    #endif // end EIGEN_HAS_CXX11
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE explicit Array(const T& x)
+    {
+      Base::_check_template_params();
+      Base::template _init1<T>(x);
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1)
+    {
+      Base::_check_template_params();
+      this->template _init2<T0,T1>(val0, val1);
+    }
+
+    #else
+    /** \brief Constructs a fixed-sized array initialized with coefficients starting at \a data */
+    EIGEN_DEVICE_FUNC explicit Array(const Scalar *data);
+    /** Constructs a vector or row-vector with given dimension. \only_for_vectors
+      *
+      * Note that this is only useful for dynamic-size vectors. For fixed-size vectors,
+      * it is redundant to pass the dimension here, so it makes more sense to use the default
+      * constructor Array() instead.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE explicit Array(Index dim);
+    /** constructs an initialized 1x1 Array with the given coefficient
+      * \sa const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args */
+    Array(const Scalar& value);
+    /** constructs an uninitialized array with \a rows rows and \a cols columns.
+      *
+      * This is useful for dynamic-size arrays. For fixed-size arrays,
+      * it is redundant to pass these parameters, so one should use the default constructor
+      * Array() instead. */
+    Array(Index rows, Index cols);
+    /** constructs an initialized 2D vector with given coefficients
+      * \sa Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args) */
+    Array(const Scalar& val0, const Scalar& val1);
+    #endif  // end EIGEN_PARSED_BY_DOXYGEN
+
+    /** constructs an initialized 3D vector with given coefficients
+      * \sa Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 3)
+      m_storage.data()[0] = val0;
+      m_storage.data()[1] = val1;
+      m_storage.data()[2] = val2;
+    }
+    /** constructs an initialized 4D vector with given coefficients
+      * \sa Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2, const Scalar& val3)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Array, 4)
+      m_storage.data()[0] = val0;
+      m_storage.data()[1] = val1;
+      m_storage.data()[2] = val2;
+      m_storage.data()[3] = val3;
+    }
+
+    /** Copy constructor */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const Array& other)
+            : Base(other)
+    { }
+
+  private:
+    struct PrivateType {};
+  public:
+
+    /** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other,
+                              typename internal::enable_if<internal::is_convertible<typename OtherDerived::Scalar,Scalar>::value,
+                                                           PrivateType>::type = PrivateType())
+      : Base(other.derived())
+    { }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT{ return 1; }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return this->innerSize(); }
+
+    #ifdef EIGEN_ARRAY_PLUGIN
+    #include EIGEN_ARRAY_PLUGIN
+    #endif
+
+  private:
+
+    template<typename MatrixType, typename OtherDerived, bool SwapPointers>
+    friend struct internal::matrix_swap_impl;
+};
+
+/** \defgroup arraytypedefs Global array typedefs
+  * \ingroup Core_Module
+  *
+  * %Eigen defines several typedef shortcuts for most common 1D and 2D array types.
+  *
+  * The general patterns are the following:
+  *
+  * \c ArrayRowsColsType where \c Rows and \c Cols can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd
+  * for complex double.
+  *
+  * For example, \c Array33d is a fixed-size 3x3 array type of doubles, and \c ArrayXXf is a dynamic-size matrix of floats.
+  *
+  * There are also \c ArraySizeType which are self-explanatory. For example, \c Array4cf is
+  * a fixed-size 1D array of 4 complex floats.
+  *
+  * With \cpp11, template alias are also defined for common sizes.
+  * They follow the same pattern as above except that the scalar type suffix is replaced by a
+  * template parameter, i.e.:
+  *   - `ArrayRowsCols<Type>` where `Rows` and `Cols` can be \c 2,\c 3,\c 4, or \c X for fixed or dynamic size.
+  *   - `ArraySize<Type>` where `Size` can be \c 2,\c 3,\c 4 or \c X for fixed or dynamic size 1D arrays.
+  *
+  * \sa class Array
+  */
+
+#define EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix)   \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Size, Size> Array##SizeSuffix##SizeSuffix##TypeSuffix;  \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Size, 1>    Array##SizeSuffix##TypeSuffix;
+
+#define EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, Size)         \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Size, Dynamic> Array##Size##X##TypeSuffix;  \
+/** \ingroup arraytypedefs */                                    \
+typedef Array<Type, Dynamic, Size> Array##X##Size##TypeSuffix;
+
+#define EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 2, 2) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 3, 3) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 4, 4) \
+EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 4)
+
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(int,                  i)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(float,                f)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(double,               d)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<float>,  cf)
+EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
+
+#undef EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES
+#undef EIGEN_MAKE_ARRAY_TYPEDEFS
+#undef EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS
+
+#if EIGEN_HAS_CXX11
+
+#define EIGEN_MAKE_ARRAY_TYPEDEFS(Size, SizeSuffix)               \
+/** \ingroup arraytypedefs */                                     \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Array##SizeSuffix##SizeSuffix = Array<Type, Size, Size>;    \
+/** \ingroup arraytypedefs */                                     \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Array##SizeSuffix = Array<Type, Size, 1>;
+
+#define EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Size)                     \
+/** \ingroup arraytypedefs */                                     \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Array##Size##X = Array<Type, Size, Dynamic>;                \
+/** \ingroup arraytypedefs */                                     \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Array##X##Size = Array<Type, Dynamic, Size>;
+
+EIGEN_MAKE_ARRAY_TYPEDEFS(2, 2)
+EIGEN_MAKE_ARRAY_TYPEDEFS(3, 3)
+EIGEN_MAKE_ARRAY_TYPEDEFS(4, 4)
+EIGEN_MAKE_ARRAY_TYPEDEFS(Dynamic, X)
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(2)
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(3)
+EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(4)
+
+#undef EIGEN_MAKE_ARRAY_TYPEDEFS
+#undef EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS
+
+#endif // EIGEN_HAS_CXX11
+
+#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, SizeSuffix) \
+using Eigen::Matrix##SizeSuffix##TypeSuffix; \
+using Eigen::Vector##SizeSuffix##TypeSuffix; \
+using Eigen::RowVector##SizeSuffix##TypeSuffix;
+
+#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(TypeSuffix) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 2) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 3) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 4) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, X) \
+
+#define EIGEN_USING_ARRAY_TYPEDEFS \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(i) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(f) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(d) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cf) \
+EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cd)
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARRAY_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/ArrayBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ArrayBase.h
new file mode 100644
index 00000000..ea3dd1c3
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ArrayBase.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARRAYBASE_H
+#define EIGEN_ARRAYBASE_H
+
+namespace Eigen { 
+
+template<typename ExpressionType> class MatrixWrapper;
+
+/** \class ArrayBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for all 1D and 2D array, and related expressions
+  *
+  * An array is similar to a dense vector or matrix. While matrices are mathematical
+  * objects with well defined linear algebra operators, an array is just a collection
+  * of scalar values arranged in a one or two dimensionnal fashion. As the main consequence,
+  * all operations applied to an array are performed coefficient wise. Furthermore,
+  * arrays support scalar math functions of the c++ standard library (e.g., std::sin(x)), and convenient
+  * constructors allowing to easily write generic code working for both scalar values
+  * and arrays.
+  *
+  * This class is the base that is inherited by all array expression types.
+  *
+  * \tparam Derived is the derived type, e.g., an array or an expression type.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_ARRAYBASE_PLUGIN.
+  *
+  * \sa class MatrixBase, \ref TopicClassHierarchy
+  */
+template<typename Derived> class ArrayBase
+  : public DenseBase<Derived>
+{
+  public:
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** The base class for a given storage type. */
+    typedef ArrayBase StorageBaseType;
+
+    typedef ArrayBase Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    typedef DenseBase<Derived> Base;
+    using Base::RowsAtCompileTime;
+    using Base::ColsAtCompileTime;
+    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+    
+    using Base::derived;
+    using Base::const_cast_derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+    using Base::lazyAssign;
+    using Base::operator-;
+    using Base::operator=;
+    using Base::operator+=;
+    using Base::operator-=;
+    using Base::operator*=;
+    using Base::operator/=;
+
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Base::PlainObject PlainObject;
+
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#   include "../plugins/MatrixCwiseUnaryOps.h"
+#   include "../plugins/ArrayCwiseUnaryOps.h"
+#   include "../plugins/CommonCwiseBinaryOps.h"
+#   include "../plugins/MatrixCwiseBinaryOps.h"
+#   include "../plugins/ArrayCwiseBinaryOps.h"
+#   ifdef EIGEN_ARRAYBASE_PLUGIN
+#     include EIGEN_ARRAYBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_UNARY_ADDONS
+
+    /** Special case of the template operator=, in order to prevent the compiler
+      * from generating a default operator= (issue hit with g++ 4.1)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const ArrayBase& other)
+    {
+      internal::call_assignment(derived(), other.derived());
+      return derived();
+    }
+    
+    /** Set all the entries to \a value.
+      * \sa DenseBase::setConstant(), DenseBase::fill() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const Scalar &value)
+    { Base::setConstant(value); return derived(); }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator+=(const Scalar& scalar);
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator-=(const Scalar& scalar);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator+=(const ArrayBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator-=(const ArrayBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator*=(const ArrayBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator/=(const ArrayBase<OtherDerived>& other);
+
+  public:
+    EIGEN_DEVICE_FUNC
+    ArrayBase<Derived>& array() { return *this; }
+    EIGEN_DEVICE_FUNC
+    const ArrayBase<Derived>& array() const { return *this; }
+
+    /** \returns an \link Eigen::MatrixBase Matrix \endlink expression of this array
+      * \sa MatrixBase::array() */
+    EIGEN_DEVICE_FUNC
+    MatrixWrapper<Derived> matrix() { return MatrixWrapper<Derived>(derived()); }
+    EIGEN_DEVICE_FUNC
+    const MatrixWrapper<const Derived> matrix() const { return MatrixWrapper<const Derived>(derived()); }
+
+//     template<typename Dest>
+//     inline void evalTo(Dest& dst) const { dst = matrix(); }
+
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(ArrayBase)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(ArrayBase)
+
+  private:
+    explicit ArrayBase(Index);
+    ArrayBase(Index,Index);
+    template<typename OtherDerived> explicit ArrayBase(const ArrayBase<OtherDerived>&);
+  protected:
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator+=(const MatrixBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator-=(const MatrixBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+};
+
+/** replaces \c *this by \c *this - \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator-=(const ArrayBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this + \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator+=(const ArrayBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this * \a other coefficient wise.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator*=(const ArrayBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::mul_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this / \a other coefficient wise.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+ArrayBase<Derived>::operator/=(const ArrayBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::div_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARRAYBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/ArrayWrapper.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ArrayWrapper.h
new file mode 100644
index 00000000..2e9555b5
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ArrayWrapper.h
@@ -0,0 +1,209 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARRAYWRAPPER_H
+#define EIGEN_ARRAYWRAPPER_H
+
+namespace Eigen {
+
+/** \class ArrayWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a mathematical vector or matrix as an array object
+  *
+  * This class is the return type of MatrixBase::array(), and most of the time
+  * this is the only way it is use.
+  *
+  * \sa MatrixBase::array(), class MatrixWrapper
+  */
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<ArrayWrapper<ExpressionType> >
+  : public traits<typename remove_all<typename ExpressionType::Nested>::type >
+{
+  typedef ArrayXpr XprKind;
+  // Let's remove NestByRefBit
+  enum {
+    Flags0 = traits<typename remove_all<typename ExpressionType::Nested>::type >::Flags,
+    LvalueBitFlag = is_lvalue<ExpressionType>::value ? LvalueBit : 0,
+    Flags = (Flags0 & ~(NestByRefBit | LvalueBit)) | LvalueBitFlag
+  };
+};
+}
+
+template<typename ExpressionType>
+class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> >
+{
+  public:
+    typedef ArrayBase<ArrayWrapper> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ArrayWrapper)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ArrayWrapper)
+    typedef typename internal::remove_all<ExpressionType>::type NestedExpression;
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<ExpressionType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    typedef typename internal::ref_selector<ExpressionType>::non_const_type NestedExpressionType;
+
+    using Base::coeffRef;
+
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE ArrayWrapper(ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_expression.cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return m_expression.outerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return m_expression.innerStride(); }
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return m_expression.data(); }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return m_expression.coeffRef(rowId, colId);
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      return m_expression.coeffRef(index);
+    }
+
+    template<typename Dest>
+    EIGEN_DEVICE_FUNC
+    inline void evalTo(Dest& dst) const { dst = m_expression; }
+
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<NestedExpressionType>::type&
+    nestedExpression() const
+    {
+      return m_expression;
+    }
+
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index)  */
+    EIGEN_DEVICE_FUNC
+    void resize(Index newSize) { m_expression.resize(newSize); }
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index,Index)*/
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols) { m_expression.resize(rows,cols); }
+
+  protected:
+    NestedExpressionType m_expression;
+};
+
+/** \class MatrixWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Expression of an array as a mathematical vector or matrix
+  *
+  * This class is the return type of ArrayBase::matrix(), and most of the time
+  * this is the only way it is use.
+  *
+  * \sa MatrixBase::matrix(), class ArrayWrapper
+  */
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<MatrixWrapper<ExpressionType> >
+ : public traits<typename remove_all<typename ExpressionType::Nested>::type >
+{
+  typedef MatrixXpr XprKind;
+  // Let's remove NestByRefBit
+  enum {
+    Flags0 = traits<typename remove_all<typename ExpressionType::Nested>::type >::Flags,
+    LvalueBitFlag = is_lvalue<ExpressionType>::value ? LvalueBit : 0,
+    Flags = (Flags0 & ~(NestByRefBit | LvalueBit)) | LvalueBitFlag
+  };
+};
+}
+
+template<typename ExpressionType>
+class MatrixWrapper : public MatrixBase<MatrixWrapper<ExpressionType> >
+{
+  public:
+    typedef MatrixBase<MatrixWrapper<ExpressionType> > Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(MatrixWrapper)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(MatrixWrapper)
+    typedef typename internal::remove_all<ExpressionType>::type NestedExpression;
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<ExpressionType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    typedef typename internal::ref_selector<ExpressionType>::non_const_type NestedExpressionType;
+
+    using Base::coeffRef;
+
+    EIGEN_DEVICE_FUNC
+    explicit inline MatrixWrapper(ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_expression.cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return m_expression.outerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return m_expression.innerStride(); }
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); }
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return m_expression.data(); }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return m_expression.derived().coeffRef(rowId, colId);
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      return m_expression.coeffRef(index);
+    }
+
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<NestedExpressionType>::type&
+    nestedExpression() const
+    {
+      return m_expression;
+    }
+
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index)  */
+    EIGEN_DEVICE_FUNC
+    void resize(Index newSize) { m_expression.resize(newSize); }
+    /** Forwards the resizing request to the nested expression
+      * \sa DenseBase::resize(Index,Index)*/
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols) { m_expression.resize(rows,cols); }
+
+  protected:
+    NestedExpressionType m_expression;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_ARRAYWRAPPER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Assign.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Assign.h
new file mode 100644
index 00000000..655412ef
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Assign.h
@@ -0,0 +1,90 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Michael Olbrich <michael.olbrich@gmx.net>
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ASSIGN_H
+#define EIGEN_ASSIGN_H
+
+namespace Eigen {
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>
+  ::lazyAssign(const DenseBase<OtherDerived>& other)
+{
+  enum{
+    SameType = internal::is_same<typename Derived::Scalar,typename OtherDerived::Scalar>::value
+  };
+
+  EIGEN_STATIC_ASSERT_LVALUE(Derived)
+  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived)
+  EIGEN_STATIC_ASSERT(SameType,YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  eigen_assert(rows() == other.rows() && cols() == other.cols());
+  internal::call_assignment_no_alias(derived(),other.derived());
+  
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase<OtherDerived>& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const MatrixBase& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const DenseBase<OtherDerived>& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const EigenBase<OtherDerived>& other)
+{
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  other.derived().evalTo(derived());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ASSIGN_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/AssignEvaluator.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/AssignEvaluator.h
new file mode 100644
index 00000000..7d76f0c2
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/AssignEvaluator.h
@@ -0,0 +1,1010 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2011-2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ASSIGN_EVALUATOR_H
+#define EIGEN_ASSIGN_EVALUATOR_H
+
+namespace Eigen {
+
+// This implementation is based on Assign.h
+
+namespace internal {
+
+/***************************************************************************
+* Part 1 : the logic deciding a strategy for traversal and unrolling       *
+***************************************************************************/
+
+// copy_using_evaluator_traits is based on assign_traits
+
+template <typename DstEvaluator, typename SrcEvaluator, typename AssignFunc, int MaxPacketSize = -1>
+struct copy_using_evaluator_traits
+{
+  typedef typename DstEvaluator::XprType Dst;
+  typedef typename Dst::Scalar DstScalar;
+
+  enum {
+    DstFlags = DstEvaluator::Flags,
+    SrcFlags = SrcEvaluator::Flags
+  };
+
+public:
+  enum {
+    DstAlignment = DstEvaluator::Alignment,
+    SrcAlignment = SrcEvaluator::Alignment,
+    DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit,
+    JointAlignment = EIGEN_PLAIN_ENUM_MIN(DstAlignment,SrcAlignment)
+  };
+
+private:
+  enum {
+    InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
+              : int(DstFlags)&RowMajorBit ? int(Dst::ColsAtCompileTime)
+              : int(Dst::RowsAtCompileTime),
+    InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
+              : int(DstFlags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime)
+              : int(Dst::MaxRowsAtCompileTime),
+    RestrictedInnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(InnerSize,MaxPacketSize),
+    RestrictedLinearSize = EIGEN_SIZE_MIN_PREFER_FIXED(Dst::SizeAtCompileTime,MaxPacketSize),
+    OuterStride = int(outer_stride_at_compile_time<Dst>::ret),
+    MaxSizeAtCompileTime = Dst::SizeAtCompileTime
+  };
+
+  // TODO distinguish between linear traversal and inner-traversals
+  typedef typename find_best_packet<DstScalar,RestrictedLinearSize>::type LinearPacketType;
+  typedef typename find_best_packet<DstScalar,RestrictedInnerSize>::type InnerPacketType;
+
+  enum {
+    LinearPacketSize = unpacket_traits<LinearPacketType>::size,
+    InnerPacketSize = unpacket_traits<InnerPacketType>::size
+  };
+
+public:
+  enum {
+    LinearRequiredAlignment = unpacket_traits<LinearPacketType>::alignment,
+    InnerRequiredAlignment = unpacket_traits<InnerPacketType>::alignment
+  };
+
+private:
+  enum {
+    DstIsRowMajor = DstFlags&RowMajorBit,
+    SrcIsRowMajor = SrcFlags&RowMajorBit,
+    StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)),
+    MightVectorize = bool(StorageOrdersAgree)
+                  && (int(DstFlags) & int(SrcFlags) & ActualPacketAccessBit)
+                  && bool(functor_traits<AssignFunc>::PacketAccess),
+    MayInnerVectorize  = MightVectorize
+                       && int(InnerSize)!=Dynamic && int(InnerSize)%int(InnerPacketSize)==0
+                       && int(OuterStride)!=Dynamic && int(OuterStride)%int(InnerPacketSize)==0
+                       && (EIGEN_UNALIGNED_VECTORIZE  || int(JointAlignment)>=int(InnerRequiredAlignment)),
+    MayLinearize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & LinearAccessBit),
+    MayLinearVectorize = bool(MightVectorize) && bool(MayLinearize) && bool(DstHasDirectAccess)
+                       && (EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)) || MaxSizeAtCompileTime == Dynamic),
+      /* If the destination isn't aligned, we have to do runtime checks and we don't unroll,
+         so it's only good for large enough sizes. */
+    MaySliceVectorize  = bool(MightVectorize) && bool(DstHasDirectAccess)
+                       && (int(InnerMaxSize)==Dynamic || int(InnerMaxSize)>=(EIGEN_UNALIGNED_VECTORIZE?InnerPacketSize:(3*InnerPacketSize)))
+      /* slice vectorization can be slow, so we only want it if the slices are big, which is
+         indicated by InnerMaxSize rather than InnerSize, think of the case of a dynamic block
+         in a fixed-size matrix
+         However, with EIGEN_UNALIGNED_VECTORIZE and unrolling, slice vectorization is still worth it */
+  };
+
+public:
+  enum {
+    Traversal =  int(Dst::SizeAtCompileTime) == 0 ? int(AllAtOnceTraversal) // If compile-size is zero, traversing will fail at compile-time.
+              : (int(MayLinearVectorize) && (LinearPacketSize>InnerPacketSize)) ? int(LinearVectorizedTraversal)
+              : int(MayInnerVectorize)   ? int(InnerVectorizedTraversal)
+              : int(MayLinearVectorize)  ? int(LinearVectorizedTraversal)
+              : int(MaySliceVectorize)   ? int(SliceVectorizedTraversal)
+              : int(MayLinearize)        ? int(LinearTraversal)
+                                         : int(DefaultTraversal),
+    Vectorized = int(Traversal) == InnerVectorizedTraversal
+              || int(Traversal) == LinearVectorizedTraversal
+              || int(Traversal) == SliceVectorizedTraversal
+  };
+
+  typedef typename conditional<int(Traversal)==LinearVectorizedTraversal, LinearPacketType, InnerPacketType>::type PacketType;
+
+private:
+  enum {
+    ActualPacketSize    = int(Traversal)==LinearVectorizedTraversal ? LinearPacketSize
+                        : Vectorized ? InnerPacketSize
+                        : 1,
+    UnrollingLimit      = EIGEN_UNROLLING_LIMIT * ActualPacketSize,
+    MayUnrollCompletely = int(Dst::SizeAtCompileTime) != Dynamic
+                       && int(Dst::SizeAtCompileTime) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit),
+    MayUnrollInner      = int(InnerSize) != Dynamic
+                       && int(InnerSize) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit)
+  };
+
+public:
+  enum {
+    Unrolling = (int(Traversal) == int(InnerVectorizedTraversal) || int(Traversal) == int(DefaultTraversal))
+                ? (
+                    int(MayUnrollCompletely) ? int(CompleteUnrolling)
+                  : int(MayUnrollInner)      ? int(InnerUnrolling)
+                                             : int(NoUnrolling)
+                  )
+              : int(Traversal) == int(LinearVectorizedTraversal)
+                ? ( bool(MayUnrollCompletely) && ( EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)))
+                          ? int(CompleteUnrolling)
+                          : int(NoUnrolling) )
+              : int(Traversal) == int(LinearTraversal)
+                ? ( bool(MayUnrollCompletely) ? int(CompleteUnrolling)
+                                              : int(NoUnrolling) )
+#if EIGEN_UNALIGNED_VECTORIZE
+              : int(Traversal) == int(SliceVectorizedTraversal)
+                ? ( bool(MayUnrollInner) ? int(InnerUnrolling)
+                                         : int(NoUnrolling) )
+#endif
+              : int(NoUnrolling)
+  };
+
+#ifdef EIGEN_DEBUG_ASSIGN
+  static void debug()
+  {
+    std::cerr << "DstXpr: " << typeid(typename DstEvaluator::XprType).name() << std::endl;
+    std::cerr << "SrcXpr: " << typeid(typename SrcEvaluator::XprType).name() << std::endl;
+    std::cerr.setf(std::ios::hex, std::ios::basefield);
+    std::cerr << "DstFlags" << " = " << DstFlags << " (" << demangle_flags(DstFlags) << " )" << std::endl;
+    std::cerr << "SrcFlags" << " = " << SrcFlags << " (" << demangle_flags(SrcFlags) << " )" << std::endl;
+    std::cerr.unsetf(std::ios::hex);
+    EIGEN_DEBUG_VAR(DstAlignment)
+    EIGEN_DEBUG_VAR(SrcAlignment)
+    EIGEN_DEBUG_VAR(LinearRequiredAlignment)
+    EIGEN_DEBUG_VAR(InnerRequiredAlignment)
+    EIGEN_DEBUG_VAR(JointAlignment)
+    EIGEN_DEBUG_VAR(InnerSize)
+    EIGEN_DEBUG_VAR(InnerMaxSize)
+    EIGEN_DEBUG_VAR(LinearPacketSize)
+    EIGEN_DEBUG_VAR(InnerPacketSize)
+    EIGEN_DEBUG_VAR(ActualPacketSize)
+    EIGEN_DEBUG_VAR(StorageOrdersAgree)
+    EIGEN_DEBUG_VAR(MightVectorize)
+    EIGEN_DEBUG_VAR(MayLinearize)
+    EIGEN_DEBUG_VAR(MayInnerVectorize)
+    EIGEN_DEBUG_VAR(MayLinearVectorize)
+    EIGEN_DEBUG_VAR(MaySliceVectorize)
+    std::cerr << "Traversal" << " = " << Traversal << " (" << demangle_traversal(Traversal) << ")" << std::endl;
+    EIGEN_DEBUG_VAR(SrcEvaluator::CoeffReadCost)
+    EIGEN_DEBUG_VAR(DstEvaluator::CoeffReadCost)
+    EIGEN_DEBUG_VAR(Dst::SizeAtCompileTime)
+    EIGEN_DEBUG_VAR(UnrollingLimit)
+    EIGEN_DEBUG_VAR(MayUnrollCompletely)
+    EIGEN_DEBUG_VAR(MayUnrollInner)
+    std::cerr << "Unrolling" << " = " << Unrolling << " (" << demangle_unrolling(Unrolling) << ")" << std::endl;
+    std::cerr << std::endl;
+  }
+#endif
+};
+
+/***************************************************************************
+* Part 2 : meta-unrollers
+***************************************************************************/
+
+/************************
+*** Default traversal ***
+************************/
+
+template<typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling
+{
+  // FIXME: this is not very clean, perhaps this information should be provided by the kernel?
+  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
+  typedef typename DstEvaluatorType::XprType DstXprType;
+
+  enum {
+    outer = Index / DstXprType::InnerSizeAtCompileTime,
+    inner = Index % DstXprType::InnerSizeAtCompileTime
+  };
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    kernel.assignCoeffByOuterInner(outer, inner);
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Index+1, Stop>::run(kernel);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
+};
+
+template<typename Kernel, int Index_, int Stop>
+struct copy_using_evaluator_DefaultTraversal_InnerUnrolling
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer)
+  {
+    kernel.assignCoeffByOuterInner(outer, Index_);
+    copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Index_+1, Stop>::run(kernel, outer);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index) { }
+};
+
+/***********************
+*** Linear traversal ***
+***********************/
+
+template<typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_LinearTraversal_CompleteUnrolling
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel& kernel)
+  {
+    kernel.assignCoeff(Index);
+    copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Index+1, Stop>::run(kernel);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
+};
+
+/**************************
+*** Inner vectorization ***
+**************************/
+
+template<typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_innervec_CompleteUnrolling
+{
+  // FIXME: this is not very clean, perhaps this information should be provided by the kernel?
+  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
+  typedef typename DstEvaluatorType::XprType DstXprType;
+  typedef typename Kernel::PacketType PacketType;
+
+  enum {
+    outer = Index / DstXprType::InnerSizeAtCompileTime,
+    inner = Index % DstXprType::InnerSizeAtCompileTime,
+    SrcAlignment = Kernel::AssignmentTraits::SrcAlignment,
+    DstAlignment = Kernel::AssignmentTraits::DstAlignment
+  };
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, inner);
+    enum { NextIndex = Index + unpacket_traits<PacketType>::size };
+    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, NextIndex, Stop>::run(kernel);
+  }
+};
+
+template<typename Kernel, int Stop>
+struct copy_using_evaluator_innervec_CompleteUnrolling<Kernel, Stop, Stop>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&) { }
+};
+
+template<typename Kernel, int Index_, int Stop, int SrcAlignment, int DstAlignment>
+struct copy_using_evaluator_innervec_InnerUnrolling
+{
+  typedef typename Kernel::PacketType PacketType;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel, Index outer)
+  {
+    kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, Index_);
+    enum { NextIndex = Index_ + unpacket_traits<PacketType>::size };
+    copy_using_evaluator_innervec_InnerUnrolling<Kernel, NextIndex, Stop, SrcAlignment, DstAlignment>::run(kernel, outer);
+  }
+};
+
+template<typename Kernel, int Stop, int SrcAlignment, int DstAlignment>
+struct copy_using_evaluator_innervec_InnerUnrolling<Kernel, Stop, Stop, SrcAlignment, DstAlignment>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &, Index) { }
+};
+
+/***************************************************************************
+* Part 3 : implementation of all cases
+***************************************************************************/
+
+// dense_assignment_loop is based on assign_impl
+
+template<typename Kernel,
+         int Traversal = Kernel::AssignmentTraits::Traversal,
+         int Unrolling = Kernel::AssignmentTraits::Unrolling>
+struct dense_assignment_loop;
+
+/************************
+***** Special Cases *****
+************************/
+
+// Zero-sized assignment is a no-op.
+template<typename Kernel, int Unrolling>
+struct dense_assignment_loop<Kernel, AllAtOnceTraversal, Unrolling>
+{
+  EIGEN_DEVICE_FUNC static void EIGEN_STRONG_INLINE run(Kernel& /*kernel*/)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    EIGEN_STATIC_ASSERT(int(DstXprType::SizeAtCompileTime) == 0,
+      EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT)
+  }
+};
+
+/************************
+*** Default traversal ***
+************************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, DefaultTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static void EIGEN_STRONG_INLINE run(Kernel &kernel)
+  {
+    for(Index outer = 0; outer < kernel.outerSize(); ++outer) {
+      for(Index inner = 0; inner < kernel.innerSize(); ++inner) {
+        kernel.assignCoeffByOuterInner(outer, inner);
+      }
+    }
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, DefaultTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, DefaultTraversal, InnerUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+
+    const Index outerSize = kernel.outerSize();
+    for(Index outer = 0; outer < outerSize; ++outer)
+      copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime>::run(kernel, outer);
+  }
+};
+
+/***************************
+*** Linear vectorization ***
+***************************/
+
+
+// The goal of unaligned_dense_assignment_loop is simply to factorize the handling
+// of the non vectorizable beginning and ending parts
+
+template <bool IsAligned = false>
+struct unaligned_dense_assignment_loop
+{
+  // if IsAligned = true, then do nothing
+  template <typename Kernel>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel&, Index, Index) {}
+};
+
+template <>
+struct unaligned_dense_assignment_loop<false>
+{
+  // MSVC must not inline this functions. If it does, it fails to optimize the
+  // packet access path.
+  // FIXME check which version exhibits this issue
+#if EIGEN_COMP_MSVC
+  template <typename Kernel>
+  static EIGEN_DONT_INLINE void run(Kernel &kernel,
+                                    Index start,
+                                    Index end)
+#else
+  template <typename Kernel>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel,
+                                      Index start,
+                                      Index end)
+#endif
+  {
+    for (Index index = start; index < end; ++index)
+      kernel.assignCoeff(index);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearVectorizedTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    const Index size = kernel.size();
+    typedef typename Kernel::Scalar Scalar;
+    typedef typename Kernel::PacketType PacketType;
+    enum {
+      requestedAlignment = Kernel::AssignmentTraits::LinearRequiredAlignment,
+      packetSize = unpacket_traits<PacketType>::size,
+      dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
+      dstAlignment = packet_traits<Scalar>::AlignedOnScalar ? int(requestedAlignment)
+                                                            : int(Kernel::AssignmentTraits::DstAlignment),
+      srcAlignment = Kernel::AssignmentTraits::JointAlignment
+    };
+    const Index alignedStart = dstIsAligned ? 0 : internal::first_aligned<requestedAlignment>(kernel.dstDataPtr(), size);
+    const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;
+
+    unaligned_dense_assignment_loop<dstIsAligned!=0>::run(kernel, 0, alignedStart);
+
+    for(Index index = alignedStart; index < alignedEnd; index += packetSize)
+      kernel.template assignPacket<dstAlignment, srcAlignment, PacketType>(index);
+
+    unaligned_dense_assignment_loop<>::run(kernel, alignedEnd, size);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearVectorizedTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    typedef typename Kernel::PacketType PacketType;
+
+    enum { size = DstXprType::SizeAtCompileTime,
+           packetSize =unpacket_traits<PacketType>::size,
+           alignedSize = (int(size)/packetSize)*packetSize };
+
+    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, alignedSize>::run(kernel);
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, alignedSize, size>::run(kernel);
+  }
+};
+
+/**************************
+*** Inner vectorization ***
+**************************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, NoUnrolling>
+{
+  typedef typename Kernel::PacketType PacketType;
+  enum {
+    SrcAlignment = Kernel::AssignmentTraits::SrcAlignment,
+    DstAlignment = Kernel::AssignmentTraits::DstAlignment
+  };
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    const Index innerSize = kernel.innerSize();
+    const Index outerSize = kernel.outerSize();
+    const Index packetSize = unpacket_traits<PacketType>::size;
+    for(Index outer = 0; outer < outerSize; ++outer)
+      for(Index inner = 0; inner < innerSize; inner+=packetSize)
+        kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, inner);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, InnerVectorizedTraversal, InnerUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    typedef typename Kernel::AssignmentTraits Traits;
+    const Index outerSize = kernel.outerSize();
+    for(Index outer = 0; outer < outerSize; ++outer)
+      copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, DstXprType::InnerSizeAtCompileTime,
+                                                   Traits::SrcAlignment, Traits::DstAlignment>::run(kernel, outer);
+  }
+};
+
+/***********************
+*** Linear traversal ***
+***********************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    const Index size = kernel.size();
+    for(Index i = 0; i < size; ++i)
+      kernel.assignCoeff(i);
+  }
+};
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, LinearTraversal, CompleteUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, 0, DstXprType::SizeAtCompileTime>::run(kernel);
+  }
+};
+
+/**************************
+*** Slice vectorization ***
+***************************/
+
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, NoUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::Scalar Scalar;
+    typedef typename Kernel::PacketType PacketType;
+    enum {
+      packetSize = unpacket_traits<PacketType>::size,
+      requestedAlignment = int(Kernel::AssignmentTraits::InnerRequiredAlignment),
+      alignable = packet_traits<Scalar>::AlignedOnScalar || int(Kernel::AssignmentTraits::DstAlignment)>=sizeof(Scalar),
+      dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
+      dstAlignment = alignable ? int(requestedAlignment)
+                               : int(Kernel::AssignmentTraits::DstAlignment)
+    };
+    const Scalar *dst_ptr = kernel.dstDataPtr();
+    if((!bool(dstIsAligned)) && (UIntPtr(dst_ptr) % sizeof(Scalar))>0)
+    {
+      // the pointer is not aligned-on scalar, so alignment is not possible
+      return dense_assignment_loop<Kernel,DefaultTraversal,NoUnrolling>::run(kernel);
+    }
+    const Index packetAlignedMask = packetSize - 1;
+    const Index innerSize = kernel.innerSize();
+    const Index outerSize = kernel.outerSize();
+    const Index alignedStep = alignable ? (packetSize - kernel.outerStride() % packetSize) & packetAlignedMask : 0;
+    Index alignedStart = ((!alignable) || bool(dstIsAligned)) ? 0 : internal::first_aligned<requestedAlignment>(dst_ptr, innerSize);
+
+    for(Index outer = 0; outer < outerSize; ++outer)
+    {
+      const Index alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask);
+      // do the non-vectorizable part of the assignment
+      for(Index inner = 0; inner<alignedStart ; ++inner)
+        kernel.assignCoeffByOuterInner(outer, inner);
+
+      // do the vectorizable part of the assignment
+      for(Index inner = alignedStart; inner<alignedEnd; inner+=packetSize)
+        kernel.template assignPacketByOuterInner<dstAlignment, Unaligned, PacketType>(outer, inner);
+
+      // do the non-vectorizable part of the assignment
+      for(Index inner = alignedEnd; inner<innerSize ; ++inner)
+        kernel.assignCoeffByOuterInner(outer, inner);
+
+      alignedStart = numext::mini((alignedStart+alignedStep)%packetSize, innerSize);
+    }
+  }
+};
+
+#if EIGEN_UNALIGNED_VECTORIZE
+template<typename Kernel>
+struct dense_assignment_loop<Kernel, SliceVectorizedTraversal, InnerUnrolling>
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel)
+  {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    typedef typename Kernel::PacketType PacketType;
+
+    enum { innerSize = DstXprType::InnerSizeAtCompileTime,
+           packetSize =unpacket_traits<PacketType>::size,
+           vectorizableSize = (int(innerSize) / int(packetSize)) * int(packetSize),
+           size = DstXprType::SizeAtCompileTime };
+
+    for(Index outer = 0; outer < kernel.outerSize(); ++outer)
+    {
+      copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, vectorizableSize, 0, 0>::run(kernel, outer);
+      copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, vectorizableSize, innerSize>::run(kernel, outer);
+    }
+  }
+};
+#endif
+
+
+/***************************************************************************
+* Part 4 : Generic dense assignment kernel
+***************************************************************************/
+
+// This class generalize the assignment of a coefficient (or packet) from one dense evaluator
+// to another dense writable evaluator.
+// It is parametrized by the two evaluators, and the actual assignment functor.
+// This abstraction level permits to keep the evaluation loops as simple and as generic as possible.
+// One can customize the assignment using this generic dense_assignment_kernel with different
+// functors, or by completely overloading it, by-passing a functor.
+template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version = Specialized>
+class generic_dense_assignment_kernel
+{
+protected:
+  typedef typename DstEvaluatorTypeT::XprType DstXprType;
+  typedef typename SrcEvaluatorTypeT::XprType SrcXprType;
+public:
+
+  typedef DstEvaluatorTypeT DstEvaluatorType;
+  typedef SrcEvaluatorTypeT SrcEvaluatorType;
+  typedef typename DstEvaluatorType::Scalar Scalar;
+  typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor> AssignmentTraits;
+  typedef typename AssignmentTraits::PacketType PacketType;
+
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  generic_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
+    : m_dst(dst), m_src(src), m_functor(func), m_dstExpr(dstExpr)
+  {
+    #ifdef EIGEN_DEBUG_ASSIGN
+    AssignmentTraits::debug();
+    #endif
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT { return m_dstExpr.size(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index innerSize() const EIGEN_NOEXCEPT { return m_dstExpr.innerSize(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index outerSize() const EIGEN_NOEXCEPT { return m_dstExpr.outerSize(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_dstExpr.rows(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_dstExpr.cols(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index outerStride() const EIGEN_NOEXCEPT { return m_dstExpr.outerStride(); }
+
+  EIGEN_DEVICE_FUNC DstEvaluatorType& dstEvaluator() EIGEN_NOEXCEPT { return m_dst; }
+  EIGEN_DEVICE_FUNC const SrcEvaluatorType& srcEvaluator() const EIGEN_NOEXCEPT { return m_src; }
+
+  /// Assign src(row,col) to dst(row,col) through the assignment functor.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index row, Index col)
+  {
+    m_functor.assignCoeff(m_dst.coeffRef(row,col), m_src.coeff(row,col));
+  }
+
+  /// \sa assignCoeff(Index,Index)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Index index)
+  {
+    m_functor.assignCoeff(m_dst.coeffRef(index), m_src.coeff(index));
+  }
+
+  /// \sa assignCoeff(Index,Index)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeffByOuterInner(Index outer, Index inner)
+  {
+    Index row = rowIndexByOuterInner(outer, inner);
+    Index col = colIndexByOuterInner(outer, inner);
+    assignCoeff(row, col);
+  }
+
+
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index row, Index col)
+  {
+    m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(row,col), m_src.template packet<LoadMode,PacketType>(row,col));
+  }
+
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index index)
+  {
+    m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(index), m_src.template packet<LoadMode,PacketType>(index));
+  }
+
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacketByOuterInner(Index outer, Index inner)
+  {
+    Index row = rowIndexByOuterInner(outer, inner);
+    Index col = colIndexByOuterInner(outer, inner);
+    assignPacket<StoreMode,LoadMode,PacketType>(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner)
+  {
+    typedef typename DstEvaluatorType::ExpressionTraits Traits;
+    return int(Traits::RowsAtCompileTime) == 1 ? 0
+      : int(Traits::ColsAtCompileTime) == 1 ? inner
+      : int(DstEvaluatorType::Flags)&RowMajorBit ? outer
+      : inner;
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner)
+  {
+    typedef typename DstEvaluatorType::ExpressionTraits Traits;
+    return int(Traits::ColsAtCompileTime) == 1 ? 0
+      : int(Traits::RowsAtCompileTime) == 1 ? inner
+      : int(DstEvaluatorType::Flags)&RowMajorBit ? inner
+      : outer;
+  }
+
+  EIGEN_DEVICE_FUNC const Scalar* dstDataPtr() const
+  {
+    return m_dstExpr.data();
+  }
+
+protected:
+  DstEvaluatorType& m_dst;
+  const SrcEvaluatorType& m_src;
+  const Functor &m_functor;
+  // TODO find a way to avoid the needs of the original expression
+  DstXprType& m_dstExpr;
+};
+
+// Special kernel used when computing small products whose operands have dynamic dimensions.  It ensures that the
+// PacketSize used is no larger than 4, thereby increasing the chance that vectorized instructions will be used
+// when computing the product.
+
+template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor>
+class restricted_packet_dense_assignment_kernel : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, BuiltIn>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, BuiltIn> Base;
+ public:
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::DstXprType DstXprType;
+    typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, 4> AssignmentTraits;
+    typedef typename AssignmentTraits::PacketType PacketType;
+
+    EIGEN_DEVICE_FUNC restricted_packet_dense_assignment_kernel(DstEvaluatorTypeT &dst, const SrcEvaluatorTypeT &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {
+  }
+ };
+
+/***************************************************************************
+* Part 5 : Entry point for dense rectangular assignment
+***************************************************************************/
+
+template<typename DstXprType,typename SrcXprType, typename Functor>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const Functor &/*func*/)
+{
+  EIGEN_ONLY_USED_FOR_DEBUG(dst);
+  EIGEN_ONLY_USED_FOR_DEBUG(src);
+  eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+}
+
+template<typename DstXprType,typename SrcXprType, typename T1, typename T2>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
+{
+  Index dstRows = src.rows();
+  Index dstCols = src.cols();
+  if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
+    dst.resize(dstRows, dstCols);
+  eigen_assert(dst.rows() == dstRows && dst.cols() == dstCols);
+}
+
+template<typename DstXprType, typename SrcXprType, typename Functor>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
+{
+  typedef evaluator<DstXprType> DstEvaluatorType;
+  typedef evaluator<SrcXprType> SrcEvaluatorType;
+
+  SrcEvaluatorType srcEvaluator(src);
+
+  // NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
+  // we need to resize the destination after the source evaluator has been created.
+  resize_if_allowed(dst, src, func);
+
+  DstEvaluatorType dstEvaluator(dst);
+
+  typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
+  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+
+  dense_assignment_loop<Kernel>::run(kernel);
+}
+
+// Specialization for filling the destination with a constant value.
+#ifndef EIGEN_GPU_COMPILE_PHASE
+template<typename DstXprType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<typename DstXprType::Scalar>, DstXprType>& src, const internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>& func)
+{
+  resize_if_allowed(dst, src, func);
+  std::fill_n(dst.data(), dst.size(), src.functor()());
+}
+#endif
+
+template<typename DstXprType, typename SrcXprType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src)
+{
+  call_dense_assignment_loop(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
+}
+
+/***************************************************************************
+* Part 6 : Generic assignment
+***************************************************************************/
+
+// Based on the respective shapes of the destination and source,
+// the class AssignmentKind determine the kind of assignment mechanism.
+// AssignmentKind must define a Kind typedef.
+template<typename DstShape, typename SrcShape> struct AssignmentKind;
+
+// Assignment kind defined in this file:
+struct Dense2Dense {};
+struct EigenBase2EigenBase {};
+
+template<typename,typename> struct AssignmentKind { typedef EigenBase2EigenBase Kind; };
+template<> struct AssignmentKind<DenseShape,DenseShape> { typedef Dense2Dense Kind; };
+
+// This is the main assignment class
+template< typename DstXprType, typename SrcXprType, typename Functor,
+          typename Kind = typename AssignmentKind< typename evaluator_traits<DstXprType>::Shape , typename evaluator_traits<SrcXprType>::Shape >::Kind,
+          typename EnableIf = void>
+struct Assignment;
+
+
+// The only purpose of this call_assignment() function is to deal with noalias() / "assume-aliasing" and automatic transposition.
+// Indeed, I (Gael) think that this concept of "assume-aliasing" was a mistake, and it makes thing quite complicated.
+// So this intermediate function removes everything related to "assume-aliasing" such that Assignment
+// does not has to bother about these annoying details.
+
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(Dst& dst, const Src& src)
+{
+  call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(const Dst& dst, const Src& src)
+{
+  call_assignment(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+
+// Deal with "assume-aliasing"
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
+{
+  typename plain_matrix_type<Src>::type tmp(src);
+  call_assignment_no_alias(dst, tmp, func);
+}
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if<!evaluator_assume_aliasing<Src>::value, void*>::type = 0)
+{
+  call_assignment_no_alias(dst, src, func);
+}
+
+// by-pass "assume-aliasing"
+// When there is no aliasing, we require that 'dst' has been properly resized
+template<typename Dst, template <typename> class StorageBase, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment(NoAlias<Dst,StorageBase>& dst, const Src& src, const Func& func)
+{
+  call_assignment_no_alias(dst.expression(), src, func);
+}
+
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
+{
+  enum {
+    NeedToTranspose = (    (int(Dst::RowsAtCompileTime) == 1 && int(Src::ColsAtCompileTime) == 1)
+                        || (int(Dst::ColsAtCompileTime) == 1 && int(Src::RowsAtCompileTime) == 1)
+                      ) && int(Dst::SizeAtCompileTime) != 1
+  };
+
+  typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst>::type ActualDstTypeCleaned;
+  typedef typename internal::conditional<NeedToTranspose, Transpose<Dst>, Dst&>::type ActualDstType;
+  ActualDstType actualDst(dst);
+
+  // TODO check whether this is the right place to perform these checks:
+  EIGEN_STATIC_ASSERT_LVALUE(Dst)
+  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(ActualDstTypeCleaned,Src)
+  EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename ActualDstTypeCleaned::Scalar,typename Src::Scalar);
+
+  Assignment<ActualDstTypeCleaned,Src,Func>::run(actualDst, src, func);
+}
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_restricted_packet_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
+{
+    typedef evaluator<Dst> DstEvaluatorType;
+    typedef evaluator<Src> SrcEvaluatorType;
+    typedef restricted_packet_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Func> Kernel;
+
+    EIGEN_STATIC_ASSERT_LVALUE(Dst)
+    EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename Dst::Scalar,typename Src::Scalar);
+
+    SrcEvaluatorType srcEvaluator(src);
+    resize_if_allowed(dst, src, func);
+
+    DstEvaluatorType dstEvaluator(dst);
+    Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+
+    dense_assignment_loop<Kernel>::run(kernel);
+}
+
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias(Dst& dst, const Src& src)
+{
+  call_assignment_no_alias(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+
+template<typename Dst, typename Src, typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, const Func& func)
+{
+  // TODO check whether this is the right place to perform these checks:
+  EIGEN_STATIC_ASSERT_LVALUE(Dst)
+  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst,Src)
+  EIGEN_CHECK_BINARY_COMPATIBILIY(Func,typename Dst::Scalar,typename Src::Scalar);
+
+  Assignment<Dst,Src,Func>::run(dst, src, func);
+}
+template<typename Dst, typename Src>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
+{
+  call_assignment_no_alias_no_transpose(dst, src, internal::assign_op<typename Dst::Scalar,typename Src::Scalar>());
+}
+
+// forward declaration
+template<typename Dst, typename Src> void check_for_aliasing(const Dst &dst, const Src &src);
+
+// Generic Dense to Dense assignment
+// Note that the last template argument "Weak" is needed to make it possible to perform
+// both partial specialization+SFINAE without ambiguous specialization
+template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
+struct Assignment<DstXprType, SrcXprType, Functor, Dense2Dense, Weak>
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+#ifndef EIGEN_NO_DEBUG
+    internal::check_for_aliasing(dst, src);
+#endif
+
+    call_dense_assignment_loop(dst, src, func);
+  }
+};
+
+// Generic assignment through evalTo.
+// TODO: not sure we have to keep that one, but it helps porting current code to new evaluator mechanism.
+// Note that the last template argument "Weak" is needed to make it possible to perform
+// both partial specialization+SFINAE without ambiguous specialization
+template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
+struct Assignment<DstXprType, SrcXprType, Functor, EigenBase2EigenBase, Weak>
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    src.evalTo(dst);
+  }
+
+  // NOTE The following two functions are templated to avoid their instantiation if not needed
+  //      This is needed because some expressions supports evalTo only and/or have 'void' as scalar type.
+  template<typename SrcScalarType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,SrcScalarType> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    src.addTo(dst);
+  }
+
+  template<typename SrcScalarType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,SrcScalarType> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    src.subTo(dst);
+  }
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_ASSIGN_EVALUATOR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Assign_MKL.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Assign_MKL.h
new file mode 100644
index 00000000..c6140d18
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Assign_MKL.h
@@ -0,0 +1,178 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+ Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+ 
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to Intel(R) MKL
+ *   MKL VML support for coefficient-wise unary Eigen expressions like a=b.sin()
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_ASSIGN_VML_H
+#define EIGEN_ASSIGN_VML_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Dst, typename Src>
+class vml_assign_traits
+{
+  private:
+    enum {
+      DstHasDirectAccess = Dst::Flags & DirectAccessBit,
+      SrcHasDirectAccess = Src::Flags & DirectAccessBit,
+      StorageOrdersAgree = (int(Dst::IsRowMajor) == int(Src::IsRowMajor)),
+      InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
+                : int(Dst::Flags)&RowMajorBit ? int(Dst::ColsAtCompileTime)
+                : int(Dst::RowsAtCompileTime),
+      InnerMaxSize  = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
+                    : int(Dst::Flags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime)
+                    : int(Dst::MaxRowsAtCompileTime),
+      MaxSizeAtCompileTime = Dst::SizeAtCompileTime,
+
+      MightEnableVml = StorageOrdersAgree && DstHasDirectAccess && SrcHasDirectAccess && Src::InnerStrideAtCompileTime==1 && Dst::InnerStrideAtCompileTime==1,
+      MightLinearize = MightEnableVml && (int(Dst::Flags) & int(Src::Flags) & LinearAccessBit),
+      VmlSize = MightLinearize ? MaxSizeAtCompileTime : InnerMaxSize,
+      LargeEnough = VmlSize==Dynamic || VmlSize>=EIGEN_MKL_VML_THRESHOLD
+    };
+  public:
+    enum {
+      EnableVml = MightEnableVml && LargeEnough,
+      Traversal = MightLinearize ? LinearTraversal : DefaultTraversal
+    };
+};
+
+#define EIGEN_PP_EXPAND(ARG) ARG
+#if !defined (EIGEN_FAST_MATH) || (EIGEN_FAST_MATH != 1)
+#define EIGEN_VMLMODE_EXPAND_xLA , VML_HA
+#else
+#define EIGEN_VMLMODE_EXPAND_xLA , VML_LA
+#endif
+
+#define EIGEN_VMLMODE_EXPAND_x_
+
+#define EIGEN_VMLMODE_PREFIX_xLA vm
+#define EIGEN_VMLMODE_PREFIX_x_  v
+#define EIGEN_VMLMODE_PREFIX(VMLMODE) EIGEN_CAT(EIGEN_VMLMODE_PREFIX_x,VMLMODE)
+
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE)                                           \
+  template< typename DstXprType, typename SrcXprNested>                                                                         \
+  struct Assignment<DstXprType, CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested>, assign_op<EIGENTYPE,EIGENTYPE>,   \
+                   Dense2Dense, typename enable_if<vml_assign_traits<DstXprType,SrcXprNested>::EnableVml>::type> {              \
+    typedef CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested> SrcXprType;                                            \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<EIGENTYPE,EIGENTYPE> &func) {                       \
+      resize_if_allowed(dst, src, func);                                                                                        \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                                       \
+      if(vml_assign_traits<DstXprType,SrcXprNested>::Traversal==LinearTraversal) {                                              \
+        VMLOP(dst.size(), (const VMLTYPE*)src.nestedExpression().data(),                                                        \
+              (VMLTYPE*)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE) );                                           \
+      } else {                                                                                                                  \
+        const Index outerSize = dst.outerSize();                                                                                \
+        for(Index outer = 0; outer < outerSize; ++outer) {                                                                      \
+          const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.nestedExpression().coeffRef(outer,0)) :                             \
+                                                      &(src.nestedExpression().coeffRef(0, outer));                             \
+          EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer,0)) : &(dst.coeffRef(0, outer));                           \
+          VMLOP( dst.innerSize(), (const VMLTYPE*)src_ptr,                                                                      \
+                (VMLTYPE*)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE));                                             \
+        }                                                                                                                       \
+      }                                                                                                                         \
+    }                                                                                                                           \
+  };                                                                                                                            \
+
+
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE)                                                         \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),s##VMLOP), float, float, VMLMODE)           \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),d##VMLOP), double, double, VMLMODE)
+
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(EIGENOP, VMLOP, VMLMODE)                                                         \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),c##VMLOP), scomplex, MKL_Complex8, VMLMODE) \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, EIGEN_CAT(EIGEN_VMLMODE_PREFIX(VMLMODE),z##VMLOP), dcomplex, MKL_Complex16, VMLMODE)
+  
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALLS(EIGENOP, VMLOP, VMLMODE)                                                              \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE)                                                               \
+  EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(EIGENOP, VMLOP, VMLMODE)
+
+  
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sin,   Sin,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(asin,  Asin,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sinh,  Sinh,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(cos,   Cos,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(acos,  Acos,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(cosh,  Cosh,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(tan,   Tan,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(atan,  Atan,  LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(tanh,  Tanh,  LA)
+// EIGEN_MKL_VML_DECLARE_UNARY_CALLS(abs,   Abs,    _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(exp,   Exp,   LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(log,   Ln,    LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(log10, Log10, LA)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS(sqrt,  Sqrt,  _)
+
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(square, Sqr,   _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_CPLX(arg, Arg,      _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(round, Round,  _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(floor, Floor,  _)
+EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(ceil,  Ceil,   _)
+
+#define EIGEN_MKL_VML_DECLARE_POW_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE)                                           \
+  template< typename DstXprType, typename SrcXprNested, typename Plain>                                                       \
+  struct Assignment<DstXprType, CwiseBinaryOp<scalar_##EIGENOP##_op<EIGENTYPE,EIGENTYPE>, SrcXprNested,                       \
+                    const CwiseNullaryOp<internal::scalar_constant_op<EIGENTYPE>,Plain> >, assign_op<EIGENTYPE,EIGENTYPE>,    \
+                   Dense2Dense, typename enable_if<vml_assign_traits<DstXprType,SrcXprNested>::EnableVml>::type> {            \
+    typedef CwiseBinaryOp<scalar_##EIGENOP##_op<EIGENTYPE,EIGENTYPE>, SrcXprNested,                                           \
+                    const CwiseNullaryOp<internal::scalar_constant_op<EIGENTYPE>,Plain> > SrcXprType;                         \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<EIGENTYPE,EIGENTYPE> &func) {                     \
+      resize_if_allowed(dst, src, func);                                                                                      \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                                     \
+      VMLTYPE exponent = reinterpret_cast<const VMLTYPE&>(src.rhs().functor().m_other);                                       \
+      if(vml_assign_traits<DstXprType,SrcXprNested>::Traversal==LinearTraversal)                                              \
+      {                                                                                                                       \
+        VMLOP( dst.size(), (const VMLTYPE*)src.lhs().data(), exponent,                                                        \
+              (VMLTYPE*)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE) );                                         \
+      } else {                                                                                                                \
+        const Index outerSize = dst.outerSize();                                                                              \
+        for(Index outer = 0; outer < outerSize; ++outer) {                                                                    \
+          const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.lhs().coeffRef(outer,0)) :                                        \
+                                                      &(src.lhs().coeffRef(0, outer));                                        \
+          EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer,0)) : &(dst.coeffRef(0, outer));                         \
+          VMLOP( dst.innerSize(), (const VMLTYPE*)src_ptr, exponent,                                                          \
+                 (VMLTYPE*)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE));                                          \
+        }                                                                                                                     \
+      }                                                                                                                       \
+    }                                                                                                                         \
+  };
+  
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmsPowx, float,    float,         LA)
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmdPowx, double,   double,        LA)
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmcPowx, scomplex, MKL_Complex8,  LA)
+EIGEN_MKL_VML_DECLARE_POW_CALL(pow, vmzPowx, dcomplex, MKL_Complex16, LA)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_ASSIGN_VML_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/BandMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/BandMatrix.h
new file mode 100644
index 00000000..878c0240
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/BandMatrix.h
@@ -0,0 +1,353 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BANDMATRIX_H
+#define EIGEN_BANDMATRIX_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Derived>
+class BandMatrixBase : public EigenBase<Derived>
+{
+  public:
+
+    enum {
+      Flags = internal::traits<Derived>::Flags,
+      CoeffReadCost = internal::traits<Derived>::CoeffReadCost,
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+      Supers = internal::traits<Derived>::Supers,
+      Subs   = internal::traits<Derived>::Subs,
+      Options = internal::traits<Derived>::Options
+    };
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> DenseMatrixType;
+    typedef typename DenseMatrixType::StorageIndex StorageIndex;
+    typedef typename internal::traits<Derived>::CoefficientsType CoefficientsType;
+    typedef EigenBase<Derived> Base;
+
+  protected:
+    enum {
+      DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic))
+                            ? 1 + Supers + Subs
+                            : Dynamic,
+      SizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime)
+    };
+
+  public:
+
+    using Base::derived;
+    using Base::rows;
+    using Base::cols;
+
+    /** \returns the number of super diagonals */
+    inline Index supers() const { return derived().supers(); }
+
+    /** \returns the number of sub diagonals */
+    inline Index subs() const { return derived().subs(); }
+
+    /** \returns an expression of the underlying coefficient matrix */
+    inline const CoefficientsType& coeffs() const { return derived().coeffs(); }
+
+    /** \returns an expression of the underlying coefficient matrix */
+    inline CoefficientsType& coeffs() { return derived().coeffs(); }
+
+    /** \returns a vector expression of the \a i -th column,
+      * only the meaningful part is returned.
+      * \warning the internal storage must be column major. */
+    inline Block<CoefficientsType,Dynamic,1> col(Index i)
+    {
+      EIGEN_STATIC_ASSERT((int(Options) & int(RowMajor)) == 0, THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+      Index start = 0;
+      Index len = coeffs().rows();
+      if (i<=supers())
+      {
+        start = supers()-i;
+        len = (std::min)(rows(),std::max<Index>(0,coeffs().rows() - (supers()-i)));
+      }
+      else if (i>=rows()-subs())
+        len = std::max<Index>(0,coeffs().rows() - (i + 1 - rows() + subs()));
+      return Block<CoefficientsType,Dynamic,1>(coeffs(), start, i, len, 1);
+    }
+
+    /** \returns a vector expression of the main diagonal */
+    inline Block<CoefficientsType,1,SizeAtCompileTime> diagonal()
+    { return Block<CoefficientsType,1,SizeAtCompileTime>(coeffs(),supers(),0,1,(std::min)(rows(),cols())); }
+
+    /** \returns a vector expression of the main diagonal (const version) */
+    inline const Block<const CoefficientsType,1,SizeAtCompileTime> diagonal() const
+    { return Block<const CoefficientsType,1,SizeAtCompileTime>(coeffs(),supers(),0,1,(std::min)(rows(),cols())); }
+
+    template<int Index> struct DiagonalIntReturnType {
+      enum {
+        ReturnOpposite = (int(Options) & int(SelfAdjoint)) && (((Index) > 0 && Supers == 0) || ((Index) < 0 && Subs == 0)),
+        Conjugate = ReturnOpposite && NumTraits<Scalar>::IsComplex,
+        ActualIndex = ReturnOpposite ? -Index : Index,
+        DiagonalSize = (RowsAtCompileTime==Dynamic || ColsAtCompileTime==Dynamic)
+                     ? Dynamic
+                     : (ActualIndex<0
+                     ? EIGEN_SIZE_MIN_PREFER_DYNAMIC(ColsAtCompileTime, RowsAtCompileTime + ActualIndex)
+                     : EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime - ActualIndex))
+      };
+      typedef Block<CoefficientsType,1, DiagonalSize> BuildType;
+      typedef typename internal::conditional<Conjugate,
+                 CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>,BuildType >,
+                 BuildType>::type Type;
+    };
+
+    /** \returns a vector expression of the \a N -th sub or super diagonal */
+    template<int N> inline typename DiagonalIntReturnType<N>::Type diagonal()
+    {
+      return typename DiagonalIntReturnType<N>::BuildType(coeffs(), supers()-N, (std::max)(0,N), 1, diagonalLength(N));
+    }
+
+    /** \returns a vector expression of the \a N -th sub or super diagonal */
+    template<int N> inline const typename DiagonalIntReturnType<N>::Type diagonal() const
+    {
+      return typename DiagonalIntReturnType<N>::BuildType(coeffs(), supers()-N, (std::max)(0,N), 1, diagonalLength(N));
+    }
+
+    /** \returns a vector expression of the \a i -th sub or super diagonal */
+    inline Block<CoefficientsType,1,Dynamic> diagonal(Index i)
+    {
+      eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers()));
+      return Block<CoefficientsType,1,Dynamic>(coeffs(), supers()-i, std::max<Index>(0,i), 1, diagonalLength(i));
+    }
+
+    /** \returns a vector expression of the \a i -th sub or super diagonal */
+    inline const Block<const CoefficientsType,1,Dynamic> diagonal(Index i) const
+    {
+      eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers()));
+      return Block<const CoefficientsType,1,Dynamic>(coeffs(), supers()-i, std::max<Index>(0,i), 1, diagonalLength(i));
+    }
+
+    template<typename Dest> inline void evalTo(Dest& dst) const
+    {
+      dst.resize(rows(),cols());
+      dst.setZero();
+      dst.diagonal() = diagonal();
+      for (Index i=1; i<=supers();++i)
+        dst.diagonal(i) = diagonal(i);
+      for (Index i=1; i<=subs();++i)
+        dst.diagonal(-i) = diagonal(-i);
+    }
+
+    DenseMatrixType toDenseMatrix() const
+    {
+      DenseMatrixType res(rows(),cols());
+      evalTo(res);
+      return res;
+    }
+
+  protected:
+
+    inline Index diagonalLength(Index i) const
+    { return i<0 ? (std::min)(cols(),rows()+i) : (std::min)(rows(),cols()-i); }
+};
+
+/**
+  * \class BandMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Represents a rectangular matrix with a banded storage
+  *
+  * \tparam _Scalar Numeric type, i.e. float, double, int
+  * \tparam _Rows Number of rows, or \b Dynamic
+  * \tparam _Cols Number of columns, or \b Dynamic
+  * \tparam _Supers Number of super diagonal
+  * \tparam _Subs Number of sub diagonal
+  * \tparam _Options A combination of either \b #RowMajor or \b #ColMajor, and of \b #SelfAdjoint
+  *                  The former controls \ref TopicStorageOrders "storage order", and defaults to
+  *                  column-major. The latter controls whether the matrix represents a selfadjoint
+  *                  matrix in which case either Supers of Subs have to be null.
+  *
+  * \sa class TridiagonalMatrix
+  */
+
+template<typename _Scalar, int _Rows, int _Cols, int _Supers, int _Subs, int _Options>
+struct traits<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef _Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef Eigen::Index StorageIndex;
+  enum {
+    CoeffReadCost = NumTraits<Scalar>::ReadCost,
+    RowsAtCompileTime = _Rows,
+    ColsAtCompileTime = _Cols,
+    MaxRowsAtCompileTime = _Rows,
+    MaxColsAtCompileTime = _Cols,
+    Flags = LvalueBit,
+    Supers = _Supers,
+    Subs = _Subs,
+    Options = _Options,
+    DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic
+  };
+  typedef Matrix<Scalar, DataRowsAtCompileTime, ColsAtCompileTime, int(Options) & int(RowMajor) ? RowMajor : ColMajor> CoefficientsType;
+};
+
+template<typename _Scalar, int Rows, int Cols, int Supers, int Subs, int Options>
+class BandMatrix : public BandMatrixBase<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Options> >
+{
+  public:
+
+    typedef typename internal::traits<BandMatrix>::Scalar Scalar;
+    typedef typename internal::traits<BandMatrix>::StorageIndex StorageIndex;
+    typedef typename internal::traits<BandMatrix>::CoefficientsType CoefficientsType;
+
+    explicit inline BandMatrix(Index rows=Rows, Index cols=Cols, Index supers=Supers, Index subs=Subs)
+      : m_coeffs(1+supers+subs,cols),
+        m_rows(rows), m_supers(supers), m_subs(subs)
+    {
+    }
+
+    /** \returns the number of columns */
+    inline EIGEN_CONSTEXPR Index rows() const { return m_rows.value(); }
+
+    /** \returns the number of rows */
+    inline EIGEN_CONSTEXPR Index cols() const { return m_coeffs.cols(); }
+
+    /** \returns the number of super diagonals */
+    inline EIGEN_CONSTEXPR Index supers() const { return m_supers.value(); }
+
+    /** \returns the number of sub diagonals */
+    inline EIGEN_CONSTEXPR Index subs() const { return m_subs.value(); }
+
+    inline const CoefficientsType& coeffs() const { return m_coeffs; }
+    inline CoefficientsType& coeffs() { return m_coeffs; }
+
+  protected:
+
+    CoefficientsType m_coeffs;
+    internal::variable_if_dynamic<Index, Rows>   m_rows;
+    internal::variable_if_dynamic<Index, Supers> m_supers;
+    internal::variable_if_dynamic<Index, Subs>   m_subs;
+};
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+class BandMatrixWrapper;
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+struct traits<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef typename _CoefficientsType::Scalar Scalar;
+  typedef typename _CoefficientsType::StorageKind StorageKind;
+  typedef typename _CoefficientsType::StorageIndex StorageIndex;
+  enum {
+    CoeffReadCost = internal::traits<_CoefficientsType>::CoeffReadCost,
+    RowsAtCompileTime = _Rows,
+    ColsAtCompileTime = _Cols,
+    MaxRowsAtCompileTime = _Rows,
+    MaxColsAtCompileTime = _Cols,
+    Flags = LvalueBit,
+    Supers = _Supers,
+    Subs = _Subs,
+    Options = _Options,
+    DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic
+  };
+  typedef _CoefficientsType CoefficientsType;
+};
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+class BandMatrixWrapper : public BandMatrixBase<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  public:
+
+    typedef typename internal::traits<BandMatrixWrapper>::Scalar Scalar;
+    typedef typename internal::traits<BandMatrixWrapper>::CoefficientsType CoefficientsType;
+    typedef typename internal::traits<BandMatrixWrapper>::StorageIndex StorageIndex;
+
+    explicit inline BandMatrixWrapper(const CoefficientsType& coeffs, Index rows=_Rows, Index cols=_Cols, Index supers=_Supers, Index subs=_Subs)
+      : m_coeffs(coeffs),
+        m_rows(rows), m_supers(supers), m_subs(subs)
+    {
+      EIGEN_UNUSED_VARIABLE(cols);
+      //internal::assert(coeffs.cols()==cols() && (supers()+subs()+1)==coeffs.rows());
+    }
+
+    /** \returns the number of columns */
+    inline EIGEN_CONSTEXPR Index rows() const { return m_rows.value(); }
+
+    /** \returns the number of rows */
+    inline EIGEN_CONSTEXPR Index cols() const { return m_coeffs.cols(); }
+
+    /** \returns the number of super diagonals */
+    inline EIGEN_CONSTEXPR Index supers() const { return m_supers.value(); }
+
+    /** \returns the number of sub diagonals */
+    inline EIGEN_CONSTEXPR Index subs() const { return m_subs.value(); }
+
+    inline const CoefficientsType& coeffs() const { return m_coeffs; }
+
+  protected:
+
+    const CoefficientsType& m_coeffs;
+    internal::variable_if_dynamic<Index, _Rows>   m_rows;
+    internal::variable_if_dynamic<Index, _Supers> m_supers;
+    internal::variable_if_dynamic<Index, _Subs>   m_subs;
+};
+
+/**
+  * \class TridiagonalMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Represents a tridiagonal matrix with a compact banded storage
+  *
+  * \tparam Scalar Numeric type, i.e. float, double, int
+  * \tparam Size Number of rows and cols, or \b Dynamic
+  * \tparam Options Can be 0 or \b SelfAdjoint
+  *
+  * \sa class BandMatrix
+  */
+template<typename Scalar, int Size, int Options>
+class TridiagonalMatrix : public BandMatrix<Scalar,Size,Size,Options&SelfAdjoint?0:1,1,Options|RowMajor>
+{
+    typedef BandMatrix<Scalar,Size,Size,Options&SelfAdjoint?0:1,1,Options|RowMajor> Base;
+    typedef typename Base::StorageIndex StorageIndex;
+  public:
+    explicit TridiagonalMatrix(Index size = Size) : Base(size,size,Options&SelfAdjoint?0:1,1) {}
+
+    inline typename Base::template DiagonalIntReturnType<1>::Type super()
+    { return Base::template diagonal<1>(); }
+    inline const typename Base::template DiagonalIntReturnType<1>::Type super() const
+    { return Base::template diagonal<1>(); }
+    inline typename Base::template DiagonalIntReturnType<-1>::Type sub()
+    { return Base::template diagonal<-1>(); }
+    inline const typename Base::template DiagonalIntReturnType<-1>::Type sub() const
+    { return Base::template diagonal<-1>(); }
+  protected:
+};
+
+
+struct BandShape {};
+
+template<typename _Scalar, int _Rows, int _Cols, int _Supers, int _Subs, int _Options>
+struct evaluator_traits<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
+  : public evaluator_traits_base<BandMatrix<_Scalar,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef BandShape Shape;
+};
+
+template<typename _CoefficientsType,int _Rows, int _Cols, int _Supers, int _Subs,int _Options>
+struct evaluator_traits<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+  : public evaluator_traits_base<BandMatrixWrapper<_CoefficientsType,_Rows,_Cols,_Supers,_Subs,_Options> >
+{
+  typedef BandShape Shape;
+};
+
+template<> struct AssignmentKind<DenseShape,BandShape> { typedef EigenBase2EigenBase Kind; };
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BANDMATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Block.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Block.h
new file mode 100644
index 00000000..3206d663
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Block.h
@@ -0,0 +1,448 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BLOCK_H
+#define EIGEN_BLOCK_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+struct traits<Block<XprType, BlockRows, BlockCols, InnerPanel> > : traits<XprType>
+{
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename traits<XprType>::StorageKind StorageKind;
+  typedef typename traits<XprType>::XprKind XprKind;
+  typedef typename ref_selector<XprType>::type XprTypeNested;
+  typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
+  enum{
+    MatrixRows = traits<XprType>::RowsAtCompileTime,
+    MatrixCols = traits<XprType>::ColsAtCompileTime,
+    RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows,
+    ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols,
+    MaxRowsAtCompileTime = BlockRows==0 ? 0
+                         : RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime)
+                         : int(traits<XprType>::MaxRowsAtCompileTime),
+    MaxColsAtCompileTime = BlockCols==0 ? 0
+                         : ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime)
+                         : int(traits<XprType>::MaxColsAtCompileTime),
+
+    XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0,
+    IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
+               : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
+               : XprTypeIsRowMajor,
+    HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
+    InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+    InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
+                             ? int(inner_stride_at_compile_time<XprType>::ret)
+                             : int(outer_stride_at_compile_time<XprType>::ret),
+    OuterStrideAtCompileTime = HasSameStorageOrderAsXprType
+                             ? int(outer_stride_at_compile_time<XprType>::ret)
+                             : int(inner_stride_at_compile_time<XprType>::ret),
+
+    // FIXME, this traits is rather specialized for dense object and it needs to be cleaned further
+    FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
+    FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
+    Flags = (traits<XprType>::Flags & (DirectAccessBit | (InnerPanel?CompressedAccessBit:0))) | FlagsLvalueBit | FlagsRowMajorBit,
+    // FIXME DirectAccessBit should not be handled by expressions
+    //
+    // Alignment is needed by MapBase's assertions
+    // We can sefely set it to false here. Internal alignment errors will be detected by an eigen_internal_assert in the respective evaluator
+    Alignment = 0
+  };
+};
+
+template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false,
+         bool HasDirectAccess = internal::has_direct_access<XprType>::ret> class BlockImpl_dense;
+
+} // end namespace internal
+
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, typename StorageKind> class BlockImpl;
+
+/** \class Block
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a fixed-size or dynamic-size block
+  *
+  * \tparam XprType the type of the expression in which we are taking a block
+  * \tparam BlockRows the number of rows of the block we are taking at compile time (optional)
+  * \tparam BlockCols the number of columns of the block we are taking at compile time (optional)
+  * \tparam InnerPanel is true, if the block maps to a set of rows of a row major matrix or
+  *         to set of columns of a column major matrix (optional). The parameter allows to determine
+  *         at compile time whether aligned access is possible on the block expression.
+  *
+  * This class represents an expression of either a fixed-size or dynamic-size block. It is the return
+  * type of DenseBase::block(Index,Index,Index,Index) and DenseBase::block<int,int>(Index,Index) and
+  * most of the time this is the only way it is used.
+  *
+  * However, if you want to directly maniputate block expressions,
+  * for instance if you want to write a function returning such an expression, you
+  * will need to use this class.
+  *
+  * Here is an example illustrating the dynamic case:
+  * \include class_Block.cpp
+  * Output: \verbinclude class_Block.out
+  *
+  * \note Even though this expression has dynamic size, in the case where \a XprType
+  * has fixed size, this expression inherits a fixed maximal size which means that evaluating
+  * it does not cause a dynamic memory allocation.
+  *
+  * Here is an example illustrating the fixed-size case:
+  * \include class_FixedBlock.cpp
+  * Output: \verbinclude class_FixedBlock.out
+  *
+  * \sa DenseBase::block(Index,Index,Index,Index), DenseBase::block(Index,Index), class VectorBlock
+  */
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> class Block
+  : public BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind>
+{
+    typedef BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind> Impl;
+  public:
+    //typedef typename Impl::Base Base;
+    typedef Impl Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
+
+    typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+    /** Column or Row constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Block(XprType& xpr, Index i) : Impl(xpr,i)
+    {
+      eigen_assert( (i>=0) && (
+          ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i<xpr.rows())
+        ||((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && i<xpr.cols())));
+    }
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Block(XprType& xpr, Index startRow, Index startCol)
+      : Impl(xpr, startRow, startCol)
+    {
+      EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
+      eigen_assert(startRow >= 0 && BlockRows >= 0 && startRow + BlockRows <= xpr.rows()
+             && startCol >= 0 && BlockCols >= 0 && startCol + BlockCols <= xpr.cols());
+    }
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Block(XprType& xpr,
+          Index startRow, Index startCol,
+          Index blockRows, Index blockCols)
+      : Impl(xpr, startRow, startCol, blockRows, blockCols)
+    {
+      eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
+          && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
+      eigen_assert(startRow >= 0 && blockRows >= 0 && startRow  <= xpr.rows() - blockRows
+          && startCol >= 0 && blockCols >= 0 && startCol <= xpr.cols() - blockCols);
+    }
+};
+
+// The generic default implementation for dense block simplu forward to the internal::BlockImpl_dense
+// that must be specialized for direct and non-direct access...
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Dense>
+  : public internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel>
+{
+    typedef internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel> Impl;
+    typedef typename XprType::StorageIndex StorageIndex;
+  public:
+    typedef Impl Base;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl)
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol) : Impl(xpr, startRow, startCol) {}
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : Impl(xpr, startRow, startCol, blockRows, blockCols) {}
+};
+
+namespace internal {
+
+/** \internal Internal implementation of dense Blocks in the general case. */
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess> class BlockImpl_dense
+  : public internal::dense_xpr_base<Block<XprType, BlockRows, BlockCols, InnerPanel> >::type
+{
+    typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
+    typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+  public:
+
+    typedef typename internal::dense_xpr_base<BlockType>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
+
+    // class InnerIterator; // FIXME apparently never used
+
+    /** Column or Row constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr, Index i)
+      : m_xpr(xpr),
+        // It is a row if and only if BlockRows==1 and BlockCols==XprType::ColsAtCompileTime,
+        // and it is a column if and only if BlockRows==XprType::RowsAtCompileTime and BlockCols==1,
+        // all other cases are invalid.
+        // The case a 1x1 matrix seems ambiguous, but the result is the same anyway.
+        m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
+        m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
+        m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
+        m_blockCols(BlockCols==1 ? 1 : xpr.cols())
+    {}
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
+      : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
+                    m_blockRows(BlockRows), m_blockCols(BlockCols)
+    {}
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline BlockImpl_dense(XprType& xpr,
+          Index startRow, Index startCol,
+          Index blockRows, Index blockCols)
+      : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol),
+                    m_blockRows(blockRows), m_blockCols(blockCols)
+    {}
+
+    EIGEN_DEVICE_FUNC inline Index rows() const { return m_blockRows.value(); }
+    EIGEN_DEVICE_FUNC inline Index cols() const { return m_blockCols.value(); }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index rowId, Index colId)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(XprType)
+      return m_xpr.coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return m_xpr.derived().coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
+    {
+      return m_xpr.coeff(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index index)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(XprType)
+      return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                            m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      return m_xpr.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                            m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const CoeffReturnType coeff(Index index) const
+    {
+      return m_xpr.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                         m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    template<int LoadMode>
+    inline PacketScalar packet(Index rowId, Index colId) const
+    {
+      return m_xpr.template packet<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value());
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
+    {
+      m_xpr.template writePacket<Unaligned>(rowId + m_startRow.value(), colId + m_startCol.value(), val);
+    }
+
+    template<int LoadMode>
+    inline PacketScalar packet(Index index) const
+    {
+      return m_xpr.template packet<Unaligned>
+              (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+               m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index index, const PacketScalar& val)
+    {
+      m_xpr.template writePacket<Unaligned>
+         (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+          m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0), val);
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \sa MapBase::data() */
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const;
+    EIGEN_DEVICE_FUNC inline Index innerStride() const;
+    EIGEN_DEVICE_FUNC inline Index outerStride() const;
+    #endif
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
+    {
+      return m_xpr;
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    XprType& nestedExpression() { return m_xpr; }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    StorageIndex startRow() const EIGEN_NOEXCEPT
+    {
+      return m_startRow.value();
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    StorageIndex startCol() const EIGEN_NOEXCEPT
+    {
+      return m_startCol.value();
+    }
+
+  protected:
+
+    XprTypeNested m_xpr;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
+    const internal::variable_if_dynamic<StorageIndex, RowsAtCompileTime> m_blockRows;
+    const internal::variable_if_dynamic<StorageIndex, ColsAtCompileTime> m_blockCols;
+};
+
+/** \internal Internal implementation of dense Blocks in the direct access case.*/
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
+  : public MapBase<Block<XprType, BlockRows, BlockCols, InnerPanel> >
+{
+    typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
+    typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+    enum {
+      XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0
+    };
+  public:
+
+    typedef MapBase<BlockType> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
+
+    /** Column or Row constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    BlockImpl_dense(XprType& xpr, Index i)
+      : Base(xpr.data() + i * (    ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && (!XprTypeIsRowMajor))
+                                || ((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && ( XprTypeIsRowMajor)) ? xpr.innerStride() : xpr.outerStride()),
+             BlockRows==1 ? 1 : xpr.rows(),
+             BlockCols==1 ? 1 : xpr.cols()),
+        m_xpr(xpr),
+        m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0),
+        m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? i : 0)
+    {
+      init();
+    }
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
+      : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol)),
+        m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
+    {
+      init();
+    }
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    BlockImpl_dense(XprType& xpr,
+          Index startRow, Index startCol,
+          Index blockRows, Index blockCols)
+      : Base(xpr.data()+xpr.innerStride()*(XprTypeIsRowMajor?startCol:startRow) + xpr.outerStride()*(XprTypeIsRowMajor?startRow:startCol), blockRows, blockCols),
+        m_xpr(xpr), m_startRow(startRow), m_startCol(startCol)
+    {
+      init();
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const EIGEN_NOEXCEPT
+    {
+      return m_xpr;
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    XprType& nestedExpression() { return m_xpr; }
+
+    /** \sa MapBase::innerStride() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index innerStride() const EIGEN_NOEXCEPT
+    {
+      return internal::traits<BlockType>::HasSameStorageOrderAsXprType
+             ? m_xpr.innerStride()
+             : m_xpr.outerStride();
+    }
+
+    /** \sa MapBase::outerStride() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index outerStride() const EIGEN_NOEXCEPT
+    {
+      return internal::traits<BlockType>::HasSameStorageOrderAsXprType
+                    ? m_xpr.outerStride()
+                    : m_xpr.innerStride();
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    StorageIndex startRow() const EIGEN_NOEXCEPT { return m_startRow.value(); }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    StorageIndex startCol() const EIGEN_NOEXCEPT { return m_startCol.value(); }
+
+  #ifndef __SUNPRO_CC
+  // FIXME sunstudio is not friendly with the above friend...
+  // META-FIXME there is no 'friend' keyword around here. Is this obsolete?
+  protected:
+  #endif
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal used by allowAligned() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols)
+      : Base(data, blockRows, blockCols), m_xpr(xpr)
+    {
+      init();
+    }
+    #endif
+
+  protected:
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void init()
+    {
+      m_outerStride = internal::traits<BlockType>::HasSameStorageOrderAsXprType
+                    ? m_xpr.outerStride()
+                    : m_xpr.innerStride();
+    }
+
+    XprTypeNested m_xpr;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
+    const internal::variable_if_dynamic<StorageIndex, (XprType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
+    Index m_outerStride;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BLOCK_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/BooleanRedux.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/BooleanRedux.h
new file mode 100644
index 00000000..852de8b9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/BooleanRedux.h
@@ -0,0 +1,162 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ALLANDANY_H
+#define EIGEN_ALLANDANY_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Derived, int UnrollCount, int Rows>
+struct all_unroller
+{
+  enum {
+    col = (UnrollCount-1) / Rows,
+    row = (UnrollCount-1) % Rows
+  };
+
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived &mat)
+  {
+    return all_unroller<Derived, UnrollCount-1, Rows>::run(mat) && mat.coeff(row, col);
+  }
+};
+
+template<typename Derived, int Rows>
+struct all_unroller<Derived, 0, Rows>
+{
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived &/*mat*/) { return true; }
+};
+
+template<typename Derived, int Rows>
+struct all_unroller<Derived, Dynamic, Rows>
+{
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived &) { return false; }
+};
+
+template<typename Derived, int UnrollCount, int Rows>
+struct any_unroller
+{
+  enum {
+    col = (UnrollCount-1) / Rows,
+    row = (UnrollCount-1) % Rows
+  };
+  
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived &mat)
+  {
+    return any_unroller<Derived, UnrollCount-1, Rows>::run(mat) || mat.coeff(row, col);
+  }
+};
+
+template<typename Derived, int Rows>
+struct any_unroller<Derived, 0, Rows>
+{
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived & /*mat*/) { return false; }
+};
+
+template<typename Derived, int Rows>
+struct any_unroller<Derived, Dynamic, Rows>
+{
+  EIGEN_DEVICE_FUNC static inline bool run(const Derived &) { return false; }
+};
+
+} // end namespace internal
+
+/** \returns true if all coefficients are true
+  *
+  * Example: \include MatrixBase_all.cpp
+  * Output: \verbinclude MatrixBase_all.out
+  *
+  * \sa any(), Cwise::operator<()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::all() const
+{
+  typedef internal::evaluator<Derived> Evaluator;
+  enum {
+    unroll = SizeAtCompileTime != Dynamic
+          && SizeAtCompileTime * (int(Evaluator::CoeffReadCost) + int(NumTraits<Scalar>::AddCost)) <= EIGEN_UNROLLING_LIMIT
+  };
+  Evaluator evaluator(derived());
+  if(unroll)
+    return internal::all_unroller<Evaluator, unroll ? int(SizeAtCompileTime) : Dynamic, internal::traits<Derived>::RowsAtCompileTime>::run(evaluator);
+  else
+  {
+    for(Index j = 0; j < cols(); ++j)
+      for(Index i = 0; i < rows(); ++i)
+        if (!evaluator.coeff(i, j)) return false;
+    return true;
+  }
+}
+
+/** \returns true if at least one coefficient is true
+  *
+  * \sa all()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::any() const
+{
+  typedef internal::evaluator<Derived> Evaluator;
+  enum {
+    unroll = SizeAtCompileTime != Dynamic
+          && SizeAtCompileTime * (int(Evaluator::CoeffReadCost) + int(NumTraits<Scalar>::AddCost)) <= EIGEN_UNROLLING_LIMIT
+  };
+  Evaluator evaluator(derived());
+  if(unroll)
+    return internal::any_unroller<Evaluator, unroll ? int(SizeAtCompileTime) : Dynamic, internal::traits<Derived>::RowsAtCompileTime>::run(evaluator);
+  else
+  {
+    for(Index j = 0; j < cols(); ++j)
+      for(Index i = 0; i < rows(); ++i)
+        if (evaluator.coeff(i, j)) return true;
+    return false;
+  }
+}
+
+/** \returns the number of coefficients which evaluate to true
+  *
+  * \sa all(), any()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Eigen::Index DenseBase<Derived>::count() const
+{
+  return derived().template cast<bool>().template cast<Index>().sum();
+}
+
+/** \returns true is \c *this contains at least one Not A Number (NaN).
+  *
+  * \sa allFinite()
+  */
+template<typename Derived>
+inline bool DenseBase<Derived>::hasNaN() const
+{
+#if EIGEN_COMP_MSVC || (defined __FAST_MATH__)
+  return derived().array().isNaN().any();
+#else
+  return !((derived().array()==derived().array()).all());
+#endif
+}
+
+/** \returns true if \c *this contains only finite numbers, i.e., no NaN and no +/-INF values.
+  *
+  * \sa hasNaN()
+  */
+template<typename Derived>
+inline bool DenseBase<Derived>::allFinite() const
+{
+#if EIGEN_COMP_MSVC || (defined __FAST_MATH__)
+  return derived().array().isFinite().all();
+#else
+  return !((derived()-derived()).hasNaN());
+#endif
+}
+    
+} // end namespace Eigen
+
+#endif // EIGEN_ALLANDANY_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/CommaInitializer.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CommaInitializer.h
new file mode 100644
index 00000000..c0e29c75
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CommaInitializer.h
@@ -0,0 +1,164 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMMAINITIALIZER_H
+#define EIGEN_COMMAINITIALIZER_H
+
+namespace Eigen { 
+
+/** \class CommaInitializer
+  * \ingroup Core_Module
+  *
+  * \brief Helper class used by the comma initializer operator
+  *
+  * This class is internally used to implement the comma initializer feature. It is
+  * the return type of MatrixBase::operator<<, and most of the time this is the only
+  * way it is used.
+  *
+  * \sa \blank \ref MatrixBaseCommaInitRef "MatrixBase::operator<<", CommaInitializer::finished()
+  */
+template<typename XprType>
+struct CommaInitializer
+{
+  typedef typename XprType::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  inline CommaInitializer(XprType& xpr, const Scalar& s)
+    : m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1)
+  {
+    eigen_assert(m_xpr.rows() > 0 && m_xpr.cols() > 0
+      && "Cannot comma-initialize a 0x0 matrix (operator<<)");
+    m_xpr.coeffRef(0,0) = s;
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline CommaInitializer(XprType& xpr, const DenseBase<OtherDerived>& other)
+    : m_xpr(xpr), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows())
+  {
+    eigen_assert(m_xpr.rows() >= other.rows() && m_xpr.cols() >= other.cols()
+      && "Cannot comma-initialize a 0x0 matrix (operator<<)");
+    m_xpr.block(0, 0, other.rows(), other.cols()) = other;
+  }
+
+  /* Copy/Move constructor which transfers ownership. This is crucial in 
+   * absence of return value optimization to avoid assertions during destruction. */
+  // FIXME in C++11 mode this could be replaced by a proper RValue constructor
+  EIGEN_DEVICE_FUNC
+  inline CommaInitializer(const CommaInitializer& o)
+  : m_xpr(o.m_xpr), m_row(o.m_row), m_col(o.m_col), m_currentBlockRows(o.m_currentBlockRows) {
+    // Mark original object as finished. In absence of R-value references we need to const_cast:
+    const_cast<CommaInitializer&>(o).m_row = m_xpr.rows();
+    const_cast<CommaInitializer&>(o).m_col = m_xpr.cols();
+    const_cast<CommaInitializer&>(o).m_currentBlockRows = 0;
+  }
+
+  /* inserts a scalar value in the target matrix */
+  EIGEN_DEVICE_FUNC
+  CommaInitializer& operator,(const Scalar& s)
+  {
+    if (m_col==m_xpr.cols())
+    {
+      m_row+=m_currentBlockRows;
+      m_col = 0;
+      m_currentBlockRows = 1;
+      eigen_assert(m_row<m_xpr.rows()
+        && "Too many rows passed to comma initializer (operator<<)");
+    }
+    eigen_assert(m_col<m_xpr.cols()
+      && "Too many coefficients passed to comma initializer (operator<<)");
+    eigen_assert(m_currentBlockRows==1);
+    m_xpr.coeffRef(m_row, m_col++) = s;
+    return *this;
+  }
+
+  /* inserts a matrix expression in the target matrix */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  CommaInitializer& operator,(const DenseBase<OtherDerived>& other)
+  {
+    if (m_col==m_xpr.cols() && (other.cols()!=0 || other.rows()!=m_currentBlockRows))
+    {
+      m_row+=m_currentBlockRows;
+      m_col = 0;
+      m_currentBlockRows = other.rows();
+      eigen_assert(m_row+m_currentBlockRows<=m_xpr.rows()
+        && "Too many rows passed to comma initializer (operator<<)");
+    }
+    eigen_assert((m_col + other.cols() <= m_xpr.cols())
+      && "Too many coefficients passed to comma initializer (operator<<)");
+    eigen_assert(m_currentBlockRows==other.rows());
+    m_xpr.template block<OtherDerived::RowsAtCompileTime, OtherDerived::ColsAtCompileTime>
+                    (m_row, m_col, other.rows(), other.cols()) = other;
+    m_col += other.cols();
+    return *this;
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline ~CommaInitializer()
+#if defined VERIFY_RAISES_ASSERT && (!defined EIGEN_NO_ASSERTION_CHECKING) && defined EIGEN_EXCEPTIONS
+  EIGEN_EXCEPTION_SPEC(Eigen::eigen_assert_exception)
+#endif
+  {
+    finished();
+  }
+
+  /** \returns the built matrix once all its coefficients have been set.
+    * Calling finished is 100% optional. Its purpose is to write expressions
+    * like this:
+    * \code
+    * quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished());
+    * \endcode
+    */
+  EIGEN_DEVICE_FUNC
+  inline XprType& finished() {
+      eigen_assert(((m_row+m_currentBlockRows) == m_xpr.rows() || m_xpr.cols() == 0)
+           && m_col == m_xpr.cols()
+           && "Too few coefficients passed to comma initializer (operator<<)");
+      return m_xpr;
+  }
+
+  XprType& m_xpr;           // target expression
+  Index m_row;              // current row id
+  Index m_col;              // current col id
+  Index m_currentBlockRows; // current block height
+};
+
+/** \anchor MatrixBaseCommaInitRef
+  * Convenient operator to set the coefficients of a matrix.
+  *
+  * The coefficients must be provided in a row major order and exactly match
+  * the size of the matrix. Otherwise an assertion is raised.
+  *
+  * Example: \include MatrixBase_set.cpp
+  * Output: \verbinclude MatrixBase_set.out
+  * 
+  * \note According the c++ standard, the argument expressions of this comma initializer are evaluated in arbitrary order.
+  *
+  * \sa CommaInitializer::finished(), class CommaInitializer
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline CommaInitializer<Derived> DenseBase<Derived>::operator<< (const Scalar& s)
+{
+  return CommaInitializer<Derived>(*static_cast<Derived*>(this), s);
+}
+
+/** \sa operator<<(const Scalar&) */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline CommaInitializer<Derived>
+DenseBase<Derived>::operator<<(const DenseBase<OtherDerived>& other)
+{
+  return CommaInitializer<Derived>(*static_cast<Derived *>(this), other);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMMAINITIALIZER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/ConditionEstimator.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ConditionEstimator.h
new file mode 100644
index 00000000..51a2e5f1
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ConditionEstimator.h
@@ -0,0 +1,175 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Rasmus Munk Larsen (rmlarsen@google.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONDITIONESTIMATOR_H
+#define EIGEN_CONDITIONESTIMATOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Vector, typename RealVector, bool IsComplex>
+struct rcond_compute_sign {
+  static inline Vector run(const Vector& v) {
+    const RealVector v_abs = v.cwiseAbs();
+    return (v_abs.array() == static_cast<typename Vector::RealScalar>(0))
+            .select(Vector::Ones(v.size()), v.cwiseQuotient(v_abs));
+  }
+};
+
+// Partial specialization to avoid elementwise division for real vectors.
+template <typename Vector>
+struct rcond_compute_sign<Vector, Vector, false> {
+  static inline Vector run(const Vector& v) {
+    return (v.array() < static_cast<typename Vector::RealScalar>(0))
+           .select(-Vector::Ones(v.size()), Vector::Ones(v.size()));
+  }
+};
+
+/**
+  * \returns an estimate of ||inv(matrix)||_1 given a decomposition of
+  * \a matrix that implements .solve() and .adjoint().solve() methods.
+  *
+  * This function implements Algorithms 4.1 and 5.1 from
+  *   http://www.maths.manchester.ac.uk/~higham/narep/narep135.pdf
+  * which also forms the basis for the condition number estimators in
+  * LAPACK. Since at most 10 calls to the solve method of dec are
+  * performed, the total cost is O(dims^2), as opposed to O(dims^3)
+  * needed to compute the inverse matrix explicitly.
+  *
+  * The most common usage is in estimating the condition number
+  * ||matrix||_1 * ||inv(matrix)||_1. The first term ||matrix||_1 can be
+  * computed directly in O(n^2) operations.
+  *
+  * Supports the following decompositions: FullPivLU, PartialPivLU, LDLT, and
+  * LLT.
+  *
+  * \sa FullPivLU, PartialPivLU, LDLT, LLT.
+  */
+template <typename Decomposition>
+typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomposition& dec)
+{
+  typedef typename Decomposition::MatrixType MatrixType;
+  typedef typename Decomposition::Scalar Scalar;
+  typedef typename Decomposition::RealScalar RealScalar;
+  typedef typename internal::plain_col_type<MatrixType>::type Vector;
+  typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVector;
+  const bool is_complex = (NumTraits<Scalar>::IsComplex != 0);
+
+  eigen_assert(dec.rows() == dec.cols());
+  const Index n = dec.rows();
+  if (n == 0)
+    return 0;
+
+  // Disable Index to float conversion warning
+#ifdef __INTEL_COMPILER
+  #pragma warning push
+  #pragma warning ( disable : 2259 )
+#endif
+  Vector v = dec.solve(Vector::Ones(n) / Scalar(n));
+#ifdef __INTEL_COMPILER
+  #pragma warning pop
+#endif
+
+  // lower_bound is a lower bound on
+  //   ||inv(matrix)||_1  = sup_v ||inv(matrix) v||_1 / ||v||_1
+  // and is the objective maximized by the ("super-") gradient ascent
+  // algorithm below.
+  RealScalar lower_bound = v.template lpNorm<1>();
+  if (n == 1)
+    return lower_bound;
+
+  // Gradient ascent algorithm follows: We know that the optimum is achieved at
+  // one of the simplices v = e_i, so in each iteration we follow a
+  // super-gradient to move towards the optimal one.
+  RealScalar old_lower_bound = lower_bound;
+  Vector sign_vector(n);
+  Vector old_sign_vector;
+  Index v_max_abs_index = -1;
+  Index old_v_max_abs_index = v_max_abs_index;
+  for (int k = 0; k < 4; ++k)
+  {
+    sign_vector = internal::rcond_compute_sign<Vector, RealVector, is_complex>::run(v);
+    if (k > 0 && !is_complex && sign_vector == old_sign_vector) {
+      // Break if the solution stagnated.
+      break;
+    }
+    // v_max_abs_index = argmax |real( inv(matrix)^T * sign_vector )|
+    v = dec.adjoint().solve(sign_vector);
+    v.real().cwiseAbs().maxCoeff(&v_max_abs_index);
+    if (v_max_abs_index == old_v_max_abs_index) {
+      // Break if the solution stagnated.
+      break;
+    }
+    // Move to the new simplex e_j, where j = v_max_abs_index.
+    v = dec.solve(Vector::Unit(n, v_max_abs_index));  // v = inv(matrix) * e_j.
+    lower_bound = v.template lpNorm<1>();
+    if (lower_bound <= old_lower_bound) {
+      // Break if the gradient step did not increase the lower_bound.
+      break;
+    }
+    if (!is_complex) {
+      old_sign_vector = sign_vector;
+    }
+    old_v_max_abs_index = v_max_abs_index;
+    old_lower_bound = lower_bound;
+  }
+  // The following calculates an independent estimate of ||matrix||_1 by
+  // multiplying matrix by a vector with entries of slowly increasing
+  // magnitude and alternating sign:
+  //   v_i = (-1)^{i} (1 + (i / (dim-1))), i = 0,...,dim-1.
+  // This improvement to Hager's algorithm above is due to Higham. It was
+  // added to make the algorithm more robust in certain corner cases where
+  // large elements in the matrix might otherwise escape detection due to
+  // exact cancellation (especially when op and op_adjoint correspond to a
+  // sequence of backsubstitutions and permutations), which could cause
+  // Hager's algorithm to vastly underestimate ||matrix||_1.
+  Scalar alternating_sign(RealScalar(1));
+  for (Index i = 0; i < n; ++i) {
+    // The static_cast is needed when Scalar is a complex and RealScalar implements expression templates
+    v[i] = alternating_sign * static_cast<RealScalar>(RealScalar(1) + (RealScalar(i) / (RealScalar(n - 1))));
+    alternating_sign = -alternating_sign;
+  }
+  v = dec.solve(v);
+  const RealScalar alternate_lower_bound = (2 * v.template lpNorm<1>()) / (3 * RealScalar(n));
+  return numext::maxi(lower_bound, alternate_lower_bound);
+}
+
+/** \brief Reciprocal condition number estimator.
+  *
+  * Computing a decomposition of a dense matrix takes O(n^3) operations, while
+  * this method estimates the condition number quickly and reliably in O(n^2)
+  * operations.
+  *
+  * \returns an estimate of the reciprocal condition number
+  * (1 / (||matrix||_1 * ||inv(matrix)||_1)) of matrix, given ||matrix||_1 and
+  * its decomposition. Supports the following decompositions: FullPivLU,
+  * PartialPivLU, LDLT, and LLT.
+  *
+  * \sa FullPivLU, PartialPivLU, LDLT, LLT.
+  */
+template <typename Decomposition>
+typename Decomposition::RealScalar
+rcond_estimate_helper(typename Decomposition::RealScalar matrix_norm, const Decomposition& dec)
+{
+  typedef typename Decomposition::RealScalar RealScalar;
+  eigen_assert(dec.rows() == dec.cols());
+  if (dec.rows() == 0)              return NumTraits<RealScalar>::infinity();
+  if (matrix_norm == RealScalar(0)) return RealScalar(0);
+  if (dec.rows() == 1)              return RealScalar(1);
+  const RealScalar inverse_matrix_norm = rcond_invmatrix_L1_norm_estimate(dec);
+  return (inverse_matrix_norm == RealScalar(0) ? RealScalar(0)
+                                               : (RealScalar(1) / inverse_matrix_norm) / matrix_norm);
+}
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/CoreEvaluators.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CoreEvaluators.h
new file mode 100644
index 00000000..0ff8c8de
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CoreEvaluators.h
@@ -0,0 +1,1741 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2011-2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_COREEVALUATORS_H
+#define EIGEN_COREEVALUATORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+// This class returns the evaluator kind from the expression storage kind.
+// Default assumes index based accessors
+template<typename StorageKind>
+struct storage_kind_to_evaluator_kind {
+  typedef IndexBased Kind;
+};
+
+// This class returns the evaluator shape from the expression storage kind.
+// It can be Dense, Sparse, Triangular, Diagonal, SelfAdjoint, Band, etc.
+template<typename StorageKind> struct storage_kind_to_shape;
+
+template<> struct storage_kind_to_shape<Dense>                  { typedef DenseShape Shape;           };
+template<> struct storage_kind_to_shape<SolverStorage>          { typedef SolverShape Shape;           };
+template<> struct storage_kind_to_shape<PermutationStorage>     { typedef PermutationShape Shape;     };
+template<> struct storage_kind_to_shape<TranspositionsStorage>  { typedef TranspositionsShape Shape;  };
+
+// Evaluators have to be specialized with respect to various criteria such as:
+//  - storage/structure/shape
+//  - scalar type
+//  - etc.
+// Therefore, we need specialization of evaluator providing additional template arguments for each kind of evaluators.
+// We currently distinguish the following kind of evaluators:
+// - unary_evaluator    for expressions taking only one arguments (CwiseUnaryOp, CwiseUnaryView, Transpose, MatrixWrapper, ArrayWrapper, Reverse, Replicate)
+// - binary_evaluator   for expression taking two arguments (CwiseBinaryOp)
+// - ternary_evaluator   for expression taking three arguments (CwiseTernaryOp)
+// - product_evaluator  for linear algebra products (Product); special case of binary_evaluator because it requires additional tags for dispatching.
+// - mapbase_evaluator  for Map, Block, Ref
+// - block_evaluator    for Block (special dispatching to a mapbase_evaluator or unary_evaluator)
+
+template< typename T,
+          typename Arg1Kind   = typename evaluator_traits<typename T::Arg1>::Kind,
+          typename Arg2Kind   = typename evaluator_traits<typename T::Arg2>::Kind,
+          typename Arg3Kind   = typename evaluator_traits<typename T::Arg3>::Kind,
+          typename Arg1Scalar = typename traits<typename T::Arg1>::Scalar,
+          typename Arg2Scalar = typename traits<typename T::Arg2>::Scalar,
+          typename Arg3Scalar = typename traits<typename T::Arg3>::Scalar> struct ternary_evaluator;
+
+template< typename T,
+          typename LhsKind   = typename evaluator_traits<typename T::Lhs>::Kind,
+          typename RhsKind   = typename evaluator_traits<typename T::Rhs>::Kind,
+          typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
+          typename RhsScalar = typename traits<typename T::Rhs>::Scalar> struct binary_evaluator;
+
+template< typename T,
+          typename Kind   = typename evaluator_traits<typename T::NestedExpression>::Kind,
+          typename Scalar = typename T::Scalar> struct unary_evaluator;
+
+// evaluator_traits<T> contains traits for evaluator<T>
+
+template<typename T>
+struct evaluator_traits_base
+{
+  // by default, get evaluator kind and shape from storage
+  typedef typename storage_kind_to_evaluator_kind<typename traits<T>::StorageKind>::Kind Kind;
+  typedef typename storage_kind_to_shape<typename traits<T>::StorageKind>::Shape Shape;
+};
+
+// Default evaluator traits
+template<typename T>
+struct evaluator_traits : public evaluator_traits_base<T>
+{
+};
+
+template<typename T, typename Shape = typename evaluator_traits<T>::Shape >
+struct evaluator_assume_aliasing {
+  static const bool value = false;
+};
+
+// By default, we assume a unary expression:
+template<typename T>
+struct evaluator : public unary_evaluator<T>
+{
+  typedef unary_evaluator<T> Base;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const T& xpr) : Base(xpr) {}
+};
+
+
+// TODO: Think about const-correctness
+template<typename T>
+struct evaluator<const T>
+  : evaluator<T>
+{
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const T& xpr) : evaluator<T>(xpr) {}
+};
+
+// ---------- base class for all evaluators ----------
+
+template<typename ExpressionType>
+struct evaluator_base
+{
+  // TODO that's not very nice to have to propagate all these traits. They are currently only needed to handle outer,inner indices.
+  typedef traits<ExpressionType> ExpressionTraits;
+
+  enum {
+    Alignment = 0
+  };
+  // noncopyable:
+  // Don't make this class inherit noncopyable as this kills EBO (Empty Base Optimization)
+  // and make complex evaluator much larger than then should do.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator_base() {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ~evaluator_base() {}
+private:
+  EIGEN_DEVICE_FUNC evaluator_base(const evaluator_base&);
+  EIGEN_DEVICE_FUNC const evaluator_base& operator=(const evaluator_base&);
+};
+
+// -------------------- Matrix and Array --------------------
+//
+// evaluator<PlainObjectBase> is a common base class for the
+// Matrix and Array evaluators.
+// Here we directly specialize evaluator. This is not really a unary expression, and it is, by definition, dense,
+// so no need for more sophisticated dispatching.
+
+// this helper permits to completely eliminate m_outerStride if it is known at compiletime.
+template<typename Scalar,int OuterStride> class plainobjectbase_evaluator_data {
+public:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride) : data(ptr)
+  {
+#ifndef EIGEN_INTERNAL_DEBUGGING
+    EIGEN_UNUSED_VARIABLE(outerStride);
+#endif
+    eigen_internal_assert(outerStride==OuterStride);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+  Index outerStride() const EIGEN_NOEXCEPT { return OuterStride; }
+  const Scalar *data;
+};
+
+template<typename Scalar> class plainobjectbase_evaluator_data<Scalar,Dynamic> {
+public:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride) : data(ptr), m_outerStride(outerStride) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Index outerStride() const { return m_outerStride; }
+  const Scalar *data;
+protected:
+  Index m_outerStride;
+};
+
+template<typename Derived>
+struct evaluator<PlainObjectBase<Derived> >
+  : evaluator_base<Derived>
+{
+  typedef PlainObjectBase<Derived> PlainObjectType;
+  typedef typename PlainObjectType::Scalar Scalar;
+  typedef typename PlainObjectType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    IsRowMajor = PlainObjectType::IsRowMajor,
+    IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime,
+    RowsAtCompileTime = PlainObjectType::RowsAtCompileTime,
+    ColsAtCompileTime = PlainObjectType::ColsAtCompileTime,
+
+    CoeffReadCost = NumTraits<Scalar>::ReadCost,
+    Flags = traits<Derived>::EvaluatorFlags,
+    Alignment = traits<Derived>::Alignment
+  };
+  enum {
+    // We do not need to know the outer stride for vectors
+    OuterStrideAtCompileTime = IsVectorAtCompileTime  ? 0
+                                                      : int(IsRowMajor) ? ColsAtCompileTime
+                                                                        : RowsAtCompileTime
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  evaluator()
+    : m_d(0,OuterStrideAtCompileTime)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const PlainObjectType& m)
+    : m_d(m.data(),IsVectorAtCompileTime ? 0 : m.outerStride())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    if (IsRowMajor)
+      return m_d.data[row * m_d.outerStride() + col];
+    else
+      return m_d.data[row + col * m_d.outerStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.data[index];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    if (IsRowMajor)
+      return const_cast<Scalar*>(m_d.data)[row * m_d.outerStride() + col];
+    else
+      return const_cast<Scalar*>(m_d.data)[row + col * m_d.outerStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return const_cast<Scalar*>(m_d.data)[index];
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    if (IsRowMajor)
+      return ploadt<PacketType, LoadMode>(m_d.data + row * m_d.outerStride() + col);
+    else
+      return ploadt<PacketType, LoadMode>(m_d.data + row + col * m_d.outerStride());
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return ploadt<PacketType, LoadMode>(m_d.data + index);
+  }
+
+  template<int StoreMode,typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    if (IsRowMajor)
+      return pstoret<Scalar, PacketType, StoreMode>
+	            (const_cast<Scalar*>(m_d.data) + row * m_d.outerStride() + col, x);
+    else
+      return pstoret<Scalar, PacketType, StoreMode>
+                    (const_cast<Scalar*>(m_d.data) + row + col * m_d.outerStride(), x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    return pstoret<Scalar, PacketType, StoreMode>(const_cast<Scalar*>(m_d.data) + index, x);
+  }
+
+protected:
+
+  plainobjectbase_evaluator_data<Scalar,OuterStrideAtCompileTime> m_d;
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+struct evaluator<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
+  : evaluator<PlainObjectBase<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > >
+{
+  typedef Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  evaluator() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& m)
+    : evaluator<PlainObjectBase<XprType> >(m)
+  { }
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+struct evaluator<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
+  : evaluator<PlainObjectBase<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > >
+{
+  typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  evaluator() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& m)
+    : evaluator<PlainObjectBase<XprType> >(m)
+  { }
+};
+
+// -------------------- Transpose --------------------
+
+template<typename ArgType>
+struct unary_evaluator<Transpose<ArgType>, IndexBased>
+  : evaluator_base<Transpose<ArgType> >
+{
+  typedef Transpose<ArgType> XprType;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    Flags = evaluator<ArgType>::Flags ^ RowMajorBit,
+    Alignment = evaluator<ArgType>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& t) : m_argImpl(t.nestedExpression()) {}
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(col, row);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(col, row);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  typename XprType::Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(index);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(col, row);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(index);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode,PacketType>(col, row, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode,PacketType>(index, x);
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+};
+
+// -------------------- CwiseNullaryOp --------------------
+// Like Matrix and Array, this is not really a unary expression, so we directly specialize evaluator.
+// Likewise, there is not need to more sophisticated dispatching here.
+
+template<typename Scalar,typename NullaryOp,
+         bool has_nullary = has_nullary_operator<NullaryOp>::value,
+         bool has_unary   = has_unary_operator<NullaryOp>::value,
+         bool has_binary  = has_binary_operator<NullaryOp>::value>
+struct nullary_wrapper
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const { return op(i,j); }
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { return op(i); }
+
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const { return op.template packetOp<T>(i,j); }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { return op.template packetOp<T>(i); }
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,true,false,false>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType=0, IndexType=0) const { return op(); }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType=0, IndexType=0) const { return op.template packetOp<T>(); }
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,false,false,true>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j=0) const { return op(i,j); }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j=0) const { return op.template packetOp<T>(i,j); }
+};
+
+// We need the following specialization for vector-only functors assigned to a runtime vector,
+// for instance, using linspace and assigning a RowVectorXd to a MatrixXd or even a row of a MatrixXd.
+// In this case, i==0 and j is used for the actual iteration.
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,false,true,false>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const {
+    eigen_assert(i==0 || j==0);
+    return op(i+j);
+  }
+  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const {
+    eigen_assert(i==0 || j==0);
+    return op.template packetOp<T>(i+j);
+  }
+
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const { return op(i); }
+  template <typename T, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const { return op.template packetOp<T>(i); }
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,false,false,false> {};
+
+#if 0 && EIGEN_COMP_MSVC>0
+// Disable this ugly workaround. This is now handled in traits<Ref>::match,
+// but this piece of code might still become handly if some other weird compilation
+// erros pop up again.
+
+// MSVC exhibits a weird compilation error when
+// compiling:
+//    Eigen::MatrixXf A = MatrixXf::Random(3,3);
+//    Ref<const MatrixXf> R = 2.f*A;
+// and that has_*ary_operator<scalar_constant_op<float>> have not been instantiated yet.
+// The "problem" is that evaluator<2.f*A> is instantiated by traits<Ref>::match<2.f*A>
+// and at that time has_*ary_operator<T> returns true regardless of T.
+// Then nullary_wrapper is badly instantiated as nullary_wrapper<.,.,true,true,true>.
+// The trick is thus to defer the proper instantiation of nullary_wrapper when coeff(),
+// and packet() are really instantiated as implemented below:
+
+// This is a simple wrapper around Index to enforce the re-instantiation of
+// has_*ary_operator when needed.
+template<typename T> struct nullary_wrapper_workaround_msvc {
+  nullary_wrapper_workaround_msvc(const T&);
+  operator T()const;
+};
+
+template<typename Scalar,typename NullaryOp>
+struct nullary_wrapper<Scalar,NullaryOp,true,true,true>
+{
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().operator()(op,i,j);
+  }
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().operator()(op,i);
+  }
+
+  template <typename T, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().template packetOp<T>(op,i,j);
+  }
+  template <typename T, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {
+    return nullary_wrapper<Scalar,NullaryOp,
+    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
+    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().template packetOp<T>(op,i);
+  }
+};
+#endif // MSVC workaround
+
+template<typename NullaryOp, typename PlainObjectType>
+struct evaluator<CwiseNullaryOp<NullaryOp,PlainObjectType> >
+  : evaluator_base<CwiseNullaryOp<NullaryOp,PlainObjectType> >
+{
+  typedef CwiseNullaryOp<NullaryOp,PlainObjectType> XprType;
+  typedef typename internal::remove_all<PlainObjectType>::type PlainObjectTypeCleaned;
+
+  enum {
+    CoeffReadCost = internal::functor_traits<NullaryOp>::Cost,
+
+    Flags = (evaluator<PlainObjectTypeCleaned>::Flags
+          &  (  HereditaryBits
+              | (functor_has_linear_access<NullaryOp>::ret  ? LinearAccessBit : 0)
+              | (functor_traits<NullaryOp>::PacketAccess    ? PacketAccessBit : 0)))
+          | (functor_traits<NullaryOp>::IsRepeatable ? 0 : EvalBeforeNestingBit),
+    Alignment = AlignedMax
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& n)
+    : m_functor(n.functor()), m_wrapper()
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(IndexType row, IndexType col) const
+  {
+    return m_wrapper(m_functor, row, col);
+  }
+
+  template <typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(IndexType index) const
+  {
+    return m_wrapper(m_functor,index);
+  }
+
+  template<int LoadMode, typename PacketType, typename IndexType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(IndexType row, IndexType col) const
+  {
+    return m_wrapper.template packetOp<PacketType>(m_functor, row, col);
+  }
+
+  template<int LoadMode, typename PacketType, typename IndexType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(IndexType index) const
+  {
+    return m_wrapper.template packetOp<PacketType>(m_functor, index);
+  }
+
+protected:
+  const NullaryOp m_functor;
+  const internal::nullary_wrapper<CoeffReturnType,NullaryOp> m_wrapper;
+};
+
+// -------------------- CwiseUnaryOp --------------------
+
+template<typename UnaryOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IndexBased >
+  : evaluator_base<CwiseUnaryOp<UnaryOp, ArgType> >
+{
+  typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;
+
+  enum {
+    CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<UnaryOp>::Cost),
+
+    Flags = evaluator<ArgType>::Flags
+          & (HereditaryBits | LinearAccessBit | (functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)),
+    Alignment = evaluator<ArgType>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& op) : m_d(op)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(index));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_d.func().packetOp(m_d.argImpl.template packet<LoadMode, PacketType>(row, col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_d.func().packetOp(m_d.argImpl.template packet<LoadMode, PacketType>(index));
+  }
+
+protected:
+
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : op(xpr.functor()), argImpl(xpr.nestedExpression()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const UnaryOp& func() const { return op; }
+    UnaryOp op;
+    evaluator<ArgType> argImpl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- CwiseTernaryOp --------------------
+
+// this is a ternary expression
+template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+struct evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
+  : public ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
+{
+  typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
+  typedef ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > Base;
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+struct ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>, IndexBased, IndexBased>
+  : evaluator_base<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >
+{
+  typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
+
+  enum {
+    CoeffReadCost = int(evaluator<Arg1>::CoeffReadCost) + int(evaluator<Arg2>::CoeffReadCost) + int(evaluator<Arg3>::CoeffReadCost) + int(functor_traits<TernaryOp>::Cost),
+
+    Arg1Flags = evaluator<Arg1>::Flags,
+    Arg2Flags = evaluator<Arg2>::Flags,
+    Arg3Flags = evaluator<Arg3>::Flags,
+    SameType = is_same<typename Arg1::Scalar,typename Arg2::Scalar>::value && is_same<typename Arg1::Scalar,typename Arg3::Scalar>::value,
+    StorageOrdersAgree = (int(Arg1Flags)&RowMajorBit)==(int(Arg2Flags)&RowMajorBit) && (int(Arg1Flags)&RowMajorBit)==(int(Arg3Flags)&RowMajorBit),
+    Flags0 = (int(Arg1Flags) | int(Arg2Flags) | int(Arg3Flags)) & (
+        HereditaryBits
+        | (int(Arg1Flags) & int(Arg2Flags) & int(Arg3Flags) &
+           ( (StorageOrdersAgree ? LinearAccessBit : 0)
+           | (functor_traits<TernaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)
+           )
+        )
+     ),
+    Flags = (Flags0 & ~RowMajorBit) | (Arg1Flags & RowMajorBit),
+    Alignment = EIGEN_PLAIN_ENUM_MIN(
+        EIGEN_PLAIN_ENUM_MIN(evaluator<Arg1>::Alignment, evaluator<Arg2>::Alignment),
+        evaluator<Arg3>::Alignment)
+  };
+
+  EIGEN_DEVICE_FUNC explicit ternary_evaluator(const XprType& xpr) : m_d(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<TernaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.arg1Impl.coeff(row, col), m_d.arg2Impl.coeff(row, col), m_d.arg3Impl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.arg1Impl.coeff(index), m_d.arg2Impl.coeff(index), m_d.arg3Impl.coeff(index));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_d.func().packetOp(m_d.arg1Impl.template packet<LoadMode,PacketType>(row, col),
+                               m_d.arg2Impl.template packet<LoadMode,PacketType>(row, col),
+                               m_d.arg3Impl.template packet<LoadMode,PacketType>(row, col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_d.func().packetOp(m_d.arg1Impl.template packet<LoadMode,PacketType>(index),
+                               m_d.arg2Impl.template packet<LoadMode,PacketType>(index),
+                               m_d.arg3Impl.template packet<LoadMode,PacketType>(index));
+  }
+
+protected:
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : op(xpr.functor()), arg1Impl(xpr.arg1()), arg2Impl(xpr.arg2()), arg3Impl(xpr.arg3()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TernaryOp& func() const { return op; }
+    TernaryOp op;
+    evaluator<Arg1> arg1Impl;
+    evaluator<Arg2> arg2Impl;
+    evaluator<Arg3> arg3Impl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- CwiseBinaryOp --------------------
+
+// this is a binary expression
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+  : public binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > Base;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IndexBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+
+  enum {
+    CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluator<Rhs>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+
+    LhsFlags = evaluator<Lhs>::Flags,
+    RhsFlags = evaluator<Rhs>::Flags,
+    SameType = is_same<typename Lhs::Scalar,typename Rhs::Scalar>::value,
+    StorageOrdersAgree = (int(LhsFlags)&RowMajorBit)==(int(RhsFlags)&RowMajorBit),
+    Flags0 = (int(LhsFlags) | int(RhsFlags)) & (
+        HereditaryBits
+      | (int(LhsFlags) & int(RhsFlags) &
+           ( (StorageOrdersAgree ? LinearAccessBit : 0)
+           | (functor_traits<BinaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)
+           )
+        )
+     ),
+    Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit),
+    Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<Lhs>::Alignment,evaluator<Rhs>::Alignment)
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit binary_evaluator(const XprType& xpr) : m_d(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.lhsImpl.coeff(row, col), m_d.rhsImpl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.lhsImpl.coeff(index), m_d.rhsImpl.coeff(index));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode,PacketType>(row, col),
+                               m_d.rhsImpl.template packet<LoadMode,PacketType>(row, col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode,PacketType>(index),
+                               m_d.rhsImpl.template packet<LoadMode,PacketType>(index));
+  }
+
+protected:
+
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : op(xpr.functor()), lhsImpl(xpr.lhs()), rhsImpl(xpr.rhs()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const BinaryOp& func() const { return op; }
+    BinaryOp op;
+    evaluator<Lhs> lhsImpl;
+    evaluator<Rhs> rhsImpl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- CwiseUnaryView --------------------
+
+template<typename UnaryOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryView<UnaryOp, ArgType>, IndexBased>
+  : evaluator_base<CwiseUnaryView<UnaryOp, ArgType> >
+{
+  typedef CwiseUnaryView<UnaryOp, ArgType> XprType;
+
+  enum {
+    CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<UnaryOp>::Cost),
+
+    Flags = (evaluator<ArgType>::Flags & (HereditaryBits | LinearAccessBit | DirectAccessBit)),
+
+    Alignment = 0 // FIXME it is not very clear why alignment is necessarily lost...
+  };
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op) : m_d(op)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_d.func()(m_d.argImpl.coeff(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_d.func()(m_d.argImpl.coeffRef(row, col));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_d.func()(m_d.argImpl.coeffRef(index));
+  }
+
+protected:
+
+  // this helper permits to completely eliminate the functor if it is empty
+  struct Data
+  {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Data(const XprType& xpr) : op(xpr.functor()), argImpl(xpr.nestedExpression()) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const UnaryOp& func() const { return op; }
+    UnaryOp op;
+    evaluator<ArgType> argImpl;
+  };
+
+  Data m_d;
+};
+
+// -------------------- Map --------------------
+
+// FIXME perhaps the PlainObjectType could be provided by Derived::PlainObject ?
+// but that might complicate template specialization
+template<typename Derived, typename PlainObjectType>
+struct mapbase_evaluator;
+
+template<typename Derived, typename PlainObjectType>
+struct mapbase_evaluator : evaluator_base<Derived>
+{
+  typedef Derived  XprType;
+  typedef typename XprType::PointerType PointerType;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    IsRowMajor = XprType::RowsAtCompileTime,
+    ColsAtCompileTime = XprType::ColsAtCompileTime,
+    CoeffReadCost = NumTraits<Scalar>::ReadCost
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit mapbase_evaluator(const XprType& map)
+    : m_data(const_cast<PointerType>(map.data())),
+      m_innerStride(map.innerStride()),
+      m_outerStride(map.outerStride())
+  {
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(evaluator<Derived>::Flags&PacketAccessBit, internal::inner_stride_at_compile_time<Derived>::ret==1),
+                        PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_data[col * colStride() + row * rowStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_data[index * m_innerStride.value()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_data[col * colStride() + row * rowStride()];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_data[index * m_innerStride.value()];
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    PointerType ptr = m_data + row * rowStride() + col * colStride();
+    return internal::ploadt<PacketType, LoadMode>(ptr);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return internal::ploadt<PacketType, LoadMode>(m_data + index * m_innerStride.value());
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    PointerType ptr = m_data + row * rowStride() + col * colStride();
+    return internal::pstoret<Scalar, PacketType, StoreMode>(ptr, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    internal::pstoret<Scalar, PacketType, StoreMode>(m_data + index * m_innerStride.value(), x);
+  }
+protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+  Index rowStride() const EIGEN_NOEXCEPT {
+    return XprType::IsRowMajor ? m_outerStride.value() : m_innerStride.value();
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+  Index colStride() const EIGEN_NOEXCEPT {
+     return XprType::IsRowMajor ? m_innerStride.value() : m_outerStride.value();
+  }
+
+  PointerType m_data;
+  const internal::variable_if_dynamic<Index, XprType::InnerStrideAtCompileTime> m_innerStride;
+  const internal::variable_if_dynamic<Index, XprType::OuterStrideAtCompileTime> m_outerStride;
+};
+
+template<typename PlainObjectType, int MapOptions, typename StrideType>
+struct evaluator<Map<PlainObjectType, MapOptions, StrideType> >
+  : public mapbase_evaluator<Map<PlainObjectType, MapOptions, StrideType>, PlainObjectType>
+{
+  typedef Map<PlainObjectType, MapOptions, StrideType> XprType;
+  typedef typename XprType::Scalar Scalar;
+  // TODO: should check for smaller packet types once we can handle multi-sized packet types
+  typedef typename packet_traits<Scalar>::type PacketScalar;
+
+  enum {
+    InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
+                             ? int(PlainObjectType::InnerStrideAtCompileTime)
+                             : int(StrideType::InnerStrideAtCompileTime),
+    OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
+                             ? int(PlainObjectType::OuterStrideAtCompileTime)
+                             : int(StrideType::OuterStrideAtCompileTime),
+    HasNoInnerStride = InnerStrideAtCompileTime == 1,
+    HasNoOuterStride = StrideType::OuterStrideAtCompileTime == 0,
+    HasNoStride = HasNoInnerStride && HasNoOuterStride,
+    IsDynamicSize = PlainObjectType::SizeAtCompileTime==Dynamic,
+
+    PacketAccessMask = bool(HasNoInnerStride) ? ~int(0) : ~int(PacketAccessBit),
+    LinearAccessMask = bool(HasNoStride) || bool(PlainObjectType::IsVectorAtCompileTime) ? ~int(0) : ~int(LinearAccessBit),
+    Flags = int( evaluator<PlainObjectType>::Flags) & (LinearAccessMask&PacketAccessMask),
+
+    Alignment = int(MapOptions)&int(AlignedMask)
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& map)
+    : mapbase_evaluator<XprType, PlainObjectType>(map)
+  { }
+};
+
+// -------------------- Ref --------------------
+
+template<typename PlainObjectType, int RefOptions, typename StrideType>
+struct evaluator<Ref<PlainObjectType, RefOptions, StrideType> >
+  : public mapbase_evaluator<Ref<PlainObjectType, RefOptions, StrideType>, PlainObjectType>
+{
+  typedef Ref<PlainObjectType, RefOptions, StrideType> XprType;
+
+  enum {
+    Flags = evaluator<Map<PlainObjectType, RefOptions, StrideType> >::Flags,
+    Alignment = evaluator<Map<PlainObjectType, RefOptions, StrideType> >::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& ref)
+    : mapbase_evaluator<XprType, PlainObjectType>(ref)
+  { }
+};
+
+// -------------------- Block --------------------
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel,
+         bool HasDirectAccess = internal::has_direct_access<ArgType>::ret> struct block_evaluator;
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
+  : block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel>
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+  typedef typename XprType::Scalar Scalar;
+  // TODO: should check for smaller packet types once we can handle multi-sized packet types
+  typedef typename packet_traits<Scalar>::type PacketScalar;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+
+    RowsAtCompileTime = traits<XprType>::RowsAtCompileTime,
+    ColsAtCompileTime = traits<XprType>::ColsAtCompileTime,
+    MaxRowsAtCompileTime = traits<XprType>::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime,
+
+    ArgTypeIsRowMajor = (int(evaluator<ArgType>::Flags)&RowMajorBit) != 0,
+    IsRowMajor = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? 1
+               : (MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1) ? 0
+               : ArgTypeIsRowMajor,
+    HasSameStorageOrderAsArgType = (IsRowMajor == ArgTypeIsRowMajor),
+    InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+    InnerStrideAtCompileTime = HasSameStorageOrderAsArgType
+                             ? int(inner_stride_at_compile_time<ArgType>::ret)
+                             : int(outer_stride_at_compile_time<ArgType>::ret),
+    OuterStrideAtCompileTime = HasSameStorageOrderAsArgType
+                             ? int(outer_stride_at_compile_time<ArgType>::ret)
+                             : int(inner_stride_at_compile_time<ArgType>::ret),
+    MaskPacketAccessBit = (InnerStrideAtCompileTime == 1 || HasSameStorageOrderAsArgType) ? PacketAccessBit : 0,
+
+    FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1 || (InnerPanel && (evaluator<ArgType>::Flags&LinearAccessBit))) ? LinearAccessBit : 0,
+    FlagsRowMajorBit = XprType::Flags&RowMajorBit,
+    Flags0 = evaluator<ArgType>::Flags & ( (HereditaryBits & ~RowMajorBit) |
+                                           DirectAccessBit |
+                                           MaskPacketAccessBit),
+    Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit,
+
+    PacketAlignment = unpacket_traits<PacketScalar>::alignment,
+    Alignment0 = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic)
+                             && (OuterStrideAtCompileTime!=0)
+                             && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % int(PacketAlignment)) == 0)) ? int(PacketAlignment) : 0,
+    Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ArgType>::Alignment, Alignment0)
+  };
+  typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> block_evaluator_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& block) : block_evaluator_type(block)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+};
+
+// no direct-access => dispatch to a unary evaluator
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /*HasDirectAccess*/ false>
+  : unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit block_evaluator(const XprType& block)
+    : unary_evaluator<XprType>(block)
+  {}
+};
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IndexBased>
+  : evaluator_base<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& block)
+    : m_argImpl(block.nestedExpression()),
+      m_startRow(block.startRow()),
+      m_startCol(block.startCol()),
+      m_linear_offset(ForwardLinearAccess?(ArgType::IsRowMajor ? block.startRow()*block.nestedExpression().cols() + block.startCol() : block.startCol()*block.nestedExpression().rows() + block.startRow()):0)
+  { }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    RowsAtCompileTime = XprType::RowsAtCompileTime,
+    ForwardLinearAccess = (InnerPanel || int(XprType::IsRowMajor)==int(ArgType::IsRowMajor)) && bool(evaluator<ArgType>::Flags&LinearAccessBit)
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(m_startRow.value() + row, m_startCol.value() + col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return linear_coeff_impl(index, bool_constant<ForwardLinearAccess>());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(m_startRow.value() + row, m_startCol.value() + col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return linear_coeffRef_impl(index, bool_constant<ForwardLinearAccess>());
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(m_startRow.value() + row, m_startCol.value() + col);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    if (ForwardLinearAccess)
+      return m_argImpl.template packet<LoadMode,PacketType>(m_linear_offset.value() + index);
+    else
+      return packet<LoadMode,PacketType>(RowsAtCompileTime == 1 ? 0 : index,
+                                         RowsAtCompileTime == 1 ? index : 0);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    return m_argImpl.template writePacket<StoreMode,PacketType>(m_startRow.value() + row, m_startCol.value() + col, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    if (ForwardLinearAccess)
+      return m_argImpl.template writePacket<StoreMode,PacketType>(m_linear_offset.value() + index, x);
+    else
+      return writePacket<StoreMode,PacketType>(RowsAtCompileTime == 1 ? 0 : index,
+                                              RowsAtCompileTime == 1 ? index : 0,
+                                              x);
+  }
+
+protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType linear_coeff_impl(Index index, internal::true_type /* ForwardLinearAccess */) const
+  {
+    return m_argImpl.coeff(m_linear_offset.value() + index);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType linear_coeff_impl(Index index, internal::false_type /* not ForwardLinearAccess */) const
+  {
+    return coeff(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& linear_coeffRef_impl(Index index, internal::true_type /* ForwardLinearAccess */)
+  {
+    return m_argImpl.coeffRef(m_linear_offset.value() + index);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& linear_coeffRef_impl(Index index, internal::false_type /* not ForwardLinearAccess */)
+  {
+    return coeffRef(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
+  }
+
+  evaluator<ArgType> m_argImpl;
+  const variable_if_dynamic<Index, (ArgType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
+  const variable_if_dynamic<Index, (ArgType::ColsAtCompileTime == 1 && BlockCols==1) ? 0 : Dynamic> m_startCol;
+  const variable_if_dynamic<Index, ForwardLinearAccess ? Dynamic : 0> m_linear_offset;
+};
+
+// TODO: This evaluator does not actually use the child evaluator;
+// all action is via the data() as returned by the Block expression.
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /* HasDirectAccess */ true>
+  : mapbase_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>,
+                      typename Block<ArgType, BlockRows, BlockCols, InnerPanel>::PlainObject>
+{
+  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+  typedef typename XprType::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit block_evaluator(const XprType& block)
+    : mapbase_evaluator<XprType, typename XprType::PlainObject>(block)
+  {
+    // TODO: for the 3.3 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime
+    eigen_assert(((internal::UIntPtr(block.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned");
+  }
+};
+
+
+// -------------------- Select --------------------
+// NOTE shall we introduce a ternary_evaluator?
+
+// TODO enable vectorization for Select
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
+struct evaluator<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
+  : evaluator_base<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
+{
+  typedef Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> XprType;
+  enum {
+    CoeffReadCost = evaluator<ConditionMatrixType>::CoeffReadCost
+                  + EIGEN_PLAIN_ENUM_MAX(evaluator<ThenMatrixType>::CoeffReadCost,
+                                         evaluator<ElseMatrixType>::CoeffReadCost),
+
+    Flags = (unsigned int)evaluator<ThenMatrixType>::Flags & evaluator<ElseMatrixType>::Flags & HereditaryBits,
+
+    Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ThenMatrixType>::Alignment, evaluator<ElseMatrixType>::Alignment)
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& select)
+    : m_conditionImpl(select.conditionMatrix()),
+      m_thenImpl(select.thenMatrix()),
+      m_elseImpl(select.elseMatrix())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    if (m_conditionImpl.coeff(row, col))
+      return m_thenImpl.coeff(row, col);
+    else
+      return m_elseImpl.coeff(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    if (m_conditionImpl.coeff(index))
+      return m_thenImpl.coeff(index);
+    else
+      return m_elseImpl.coeff(index);
+  }
+
+protected:
+  evaluator<ConditionMatrixType> m_conditionImpl;
+  evaluator<ThenMatrixType> m_thenImpl;
+  evaluator<ElseMatrixType> m_elseImpl;
+};
+
+
+// -------------------- Replicate --------------------
+
+template<typename ArgType, int RowFactor, int ColFactor>
+struct unary_evaluator<Replicate<ArgType, RowFactor, ColFactor> >
+  : evaluator_base<Replicate<ArgType, RowFactor, ColFactor> >
+{
+  typedef Replicate<ArgType, RowFactor, ColFactor> XprType;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  enum {
+    Factor = (RowFactor==Dynamic || ColFactor==Dynamic) ? Dynamic : RowFactor*ColFactor
+  };
+  typedef typename internal::nested_eval<ArgType,Factor>::type ArgTypeNested;
+  typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNestedCleaned;
+
+  enum {
+    CoeffReadCost = evaluator<ArgTypeNestedCleaned>::CoeffReadCost,
+    LinearAccessMask = XprType::IsVectorAtCompileTime ? LinearAccessBit : 0,
+    Flags = (evaluator<ArgTypeNestedCleaned>::Flags & (HereditaryBits|LinearAccessMask) & ~RowMajorBit) | (traits<XprType>::Flags & RowMajorBit),
+
+    Alignment = evaluator<ArgTypeNestedCleaned>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& replicate)
+    : m_arg(replicate.nestedExpression()),
+      m_argImpl(m_arg),
+      m_rows(replicate.nestedExpression().rows()),
+      m_cols(replicate.nestedExpression().cols())
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    // try to avoid using modulo; this is a pure optimization strategy
+    const Index actual_row = internal::traits<XprType>::RowsAtCompileTime==1 ? 0
+                           : RowFactor==1 ? row
+                           : row % m_rows.value();
+    const Index actual_col = internal::traits<XprType>::ColsAtCompileTime==1 ? 0
+                           : ColFactor==1 ? col
+                           : col % m_cols.value();
+
+    return m_argImpl.coeff(actual_row, actual_col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    // try to avoid using modulo; this is a pure optimization strategy
+    const Index actual_index = internal::traits<XprType>::RowsAtCompileTime==1
+                                  ? (ColFactor==1 ?  index : index%m_cols.value())
+                                  : (RowFactor==1 ?  index : index%m_rows.value());
+
+    return m_argImpl.coeff(actual_index);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    const Index actual_row = internal::traits<XprType>::RowsAtCompileTime==1 ? 0
+                           : RowFactor==1 ? row
+                           : row % m_rows.value();
+    const Index actual_col = internal::traits<XprType>::ColsAtCompileTime==1 ? 0
+                           : ColFactor==1 ? col
+                           : col % m_cols.value();
+
+    return m_argImpl.template packet<LoadMode,PacketType>(actual_row, actual_col);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    const Index actual_index = internal::traits<XprType>::RowsAtCompileTime==1
+                                  ? (ColFactor==1 ?  index : index%m_cols.value())
+                                  : (RowFactor==1 ?  index : index%m_rows.value());
+
+    return m_argImpl.template packet<LoadMode,PacketType>(actual_index);
+  }
+
+protected:
+  const ArgTypeNested m_arg;
+  evaluator<ArgTypeNestedCleaned> m_argImpl;
+  const variable_if_dynamic<Index, ArgType::RowsAtCompileTime> m_rows;
+  const variable_if_dynamic<Index, ArgType::ColsAtCompileTime> m_cols;
+};
+
+// -------------------- MatrixWrapper and ArrayWrapper --------------------
+//
+// evaluator_wrapper_base<T> is a common base class for the
+// MatrixWrapper and ArrayWrapper evaluators.
+
+template<typename XprType>
+struct evaluator_wrapper_base
+  : evaluator_base<XprType>
+{
+  typedef typename remove_all<typename XprType::NestedExpressionType>::type ArgType;
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    Flags = evaluator<ArgType>::Flags,
+    Alignment = evaluator<ArgType>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator_wrapper_base(const ArgType& arg) : m_argImpl(arg) {}
+
+  typedef typename ArgType::Scalar Scalar;
+  typedef typename ArgType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(row, col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(index);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(row, col);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    return m_argImpl.template packet<LoadMode,PacketType>(index);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode>(row, col, x);
+  }
+
+  template<int StoreMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    m_argImpl.template writePacket<StoreMode>(index, x);
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+};
+
+template<typename TArgType>
+struct unary_evaluator<MatrixWrapper<TArgType> >
+  : evaluator_wrapper_base<MatrixWrapper<TArgType> >
+{
+  typedef MatrixWrapper<TArgType> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& wrapper)
+    : evaluator_wrapper_base<MatrixWrapper<TArgType> >(wrapper.nestedExpression())
+  { }
+};
+
+template<typename TArgType>
+struct unary_evaluator<ArrayWrapper<TArgType> >
+  : evaluator_wrapper_base<ArrayWrapper<TArgType> >
+{
+  typedef ArrayWrapper<TArgType> XprType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& wrapper)
+    : evaluator_wrapper_base<ArrayWrapper<TArgType> >(wrapper.nestedExpression())
+  { }
+};
+
+
+// -------------------- Reverse --------------------
+
+// defined in Reverse.h:
+template<typename PacketType, bool ReversePacket> struct reverse_packet_cond;
+
+template<typename ArgType, int Direction>
+struct unary_evaluator<Reverse<ArgType, Direction> >
+  : evaluator_base<Reverse<ArgType, Direction> >
+{
+  typedef Reverse<ArgType, Direction> XprType;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    IsRowMajor = XprType::IsRowMajor,
+    IsColMajor = !IsRowMajor,
+    ReverseRow = (Direction == Vertical)   || (Direction == BothDirections),
+    ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
+    ReversePacket = (Direction == BothDirections)
+                    || ((Direction == Vertical)   && IsColMajor)
+                    || ((Direction == Horizontal) && IsRowMajor),
+
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+
+    // let's enable LinearAccess only with vectorization because of the product overhead
+    // FIXME enable DirectAccess with negative strides?
+    Flags0 = evaluator<ArgType>::Flags,
+    LinearAccess = ( (Direction==BothDirections) && (int(Flags0)&PacketAccessBit) )
+                  || ((ReverseRow && XprType::ColsAtCompileTime==1) || (ReverseCol && XprType::RowsAtCompileTime==1))
+                 ? LinearAccessBit : 0,
+
+    Flags = int(Flags0) & (HereditaryBits | PacketAccessBit | LinearAccess),
+
+    Alignment = 0 // FIXME in some rare cases, Alignment could be preserved, like a Vector4f.
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit unary_evaluator(const XprType& reverse)
+    : m_argImpl(reverse.nestedExpression()),
+      m_rows(ReverseRow ? reverse.nestedExpression().rows() : 1),
+      m_cols(ReverseCol ? reverse.nestedExpression().cols() : 1)
+  { }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(ReverseRow ? m_rows.value() - row - 1 : row,
+                           ReverseCol ? m_cols.value() - col - 1 : col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(m_rows.value() * m_cols.value() - index - 1);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(ReverseRow ? m_rows.value() - row - 1 : row,
+                              ReverseCol ? m_cols.value() - col - 1 : col);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(m_rows.value() * m_cols.value() - index - 1);
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index row, Index col) const
+  {
+    enum {
+      PacketSize = unpacket_traits<PacketType>::size,
+      OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
+      OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1
+    };
+    typedef internal::reverse_packet_cond<PacketType,ReversePacket> reverse_packet;
+    return reverse_packet::run(m_argImpl.template packet<LoadMode,PacketType>(
+                                  ReverseRow ? m_rows.value() - row - OffsetRow : row,
+                                  ReverseCol ? m_cols.value() - col - OffsetCol : col));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  PacketType packet(Index index) const
+  {
+    enum { PacketSize = unpacket_traits<PacketType>::size };
+    return preverse(m_argImpl.template packet<LoadMode,PacketType>(m_rows.value() * m_cols.value() - index - PacketSize));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index row, Index col, const PacketType& x)
+  {
+    // FIXME we could factorize some code with packet(i,j)
+    enum {
+      PacketSize = unpacket_traits<PacketType>::size,
+      OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
+      OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1
+    };
+    typedef internal::reverse_packet_cond<PacketType,ReversePacket> reverse_packet;
+    m_argImpl.template writePacket<LoadMode>(
+                                  ReverseRow ? m_rows.value() - row - OffsetRow : row,
+                                  ReverseCol ? m_cols.value() - col - OffsetCol : col,
+                                  reverse_packet::run(x));
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE
+  void writePacket(Index index, const PacketType& x)
+  {
+    enum { PacketSize = unpacket_traits<PacketType>::size };
+    m_argImpl.template writePacket<LoadMode>
+      (m_rows.value() * m_cols.value() - index - PacketSize, preverse(x));
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+
+  // If we do not reverse rows, then we do not need to know the number of rows; same for columns
+  // Nonetheless, in this case it is important to set to 1 such that the coeff(index) method works fine for vectors.
+  const variable_if_dynamic<Index, ReverseRow ? ArgType::RowsAtCompileTime : 1> m_rows;
+  const variable_if_dynamic<Index, ReverseCol ? ArgType::ColsAtCompileTime : 1> m_cols;
+};
+
+
+// -------------------- Diagonal --------------------
+
+template<typename ArgType, int DiagIndex>
+struct evaluator<Diagonal<ArgType, DiagIndex> >
+  : evaluator_base<Diagonal<ArgType, DiagIndex> >
+{
+  typedef Diagonal<ArgType, DiagIndex> XprType;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+
+    Flags = (unsigned int)(evaluator<ArgType>::Flags & (HereditaryBits | DirectAccessBit) & ~RowMajorBit) | LinearAccessBit,
+
+    Alignment = 0
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit evaluator(const XprType& diagonal)
+    : m_argImpl(diagonal.nestedExpression()),
+      m_index(diagonal.index())
+  { }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index) const
+  {
+    return m_argImpl.coeff(row + rowOffset(), row + colOffset());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index index) const
+  {
+    return m_argImpl.coeff(index + rowOffset(), index + colOffset());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index)
+  {
+    return m_argImpl.coeffRef(row + rowOffset(), row + colOffset());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    return m_argImpl.coeffRef(index + rowOffset(), index + colOffset());
+  }
+
+protected:
+  evaluator<ArgType> m_argImpl;
+  const internal::variable_if_dynamicindex<Index, XprType::DiagIndex> m_index;
+
+private:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+  Index rowOffset() const { return m_index.value() > 0 ? 0 : -m_index.value(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+  Index colOffset() const { return m_index.value() > 0 ? m_index.value() : 0; }
+};
+
+
+//----------------------------------------------------------------------
+// deprecated code
+//----------------------------------------------------------------------
+
+// -------------------- EvalToTemp --------------------
+
+// expression class for evaluating nested expression to a temporary
+
+template<typename ArgType> class EvalToTemp;
+
+template<typename ArgType>
+struct traits<EvalToTemp<ArgType> >
+  : public traits<ArgType>
+{ };
+
+template<typename ArgType>
+class EvalToTemp
+  : public dense_xpr_base<EvalToTemp<ArgType> >::type
+{
+ public:
+
+  typedef typename dense_xpr_base<EvalToTemp>::type Base;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)
+
+  explicit EvalToTemp(const ArgType& arg)
+    : m_arg(arg)
+  { }
+
+  const ArgType& arg() const
+  {
+    return m_arg;
+  }
+
+  EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
+  {
+    return m_arg.rows();
+  }
+
+  EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
+  {
+    return m_arg.cols();
+  }
+
+ private:
+  const ArgType& m_arg;
+};
+
+template<typename ArgType>
+struct evaluator<EvalToTemp<ArgType> >
+  : public evaluator<typename ArgType::PlainObject>
+{
+  typedef EvalToTemp<ArgType>                   XprType;
+  typedef typename ArgType::PlainObject         PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
+    : m_result(xpr.arg())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+  }
+
+  // This constructor is used when nesting an EvalTo evaluator in another evaluator
+  EIGEN_DEVICE_FUNC evaluator(const ArgType& arg)
+    : m_result(arg)
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COREEVALUATORS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/CoreIterators.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CoreIterators.h
new file mode 100644
index 00000000..b9671968
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CoreIterators.h
@@ -0,0 +1,132 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COREITERATORS_H
+#define EIGEN_COREITERATORS_H
+
+namespace Eigen { 
+
+/* This file contains the respective InnerIterator definition of the expressions defined in Eigen/Core
+ */
+
+namespace internal {
+
+template<typename XprType, typename EvaluatorKind>
+class inner_iterator_selector;
+
+}
+
+/** \class InnerIterator
+  * \brief An InnerIterator allows to loop over the element of any matrix expression.
+  * 
+  * \warning To be used with care because an evaluator is constructed every time an InnerIterator iterator is constructed.
+  * 
+  * TODO: add a usage example
+  */
+template<typename XprType>
+class InnerIterator
+{
+protected:
+  typedef internal::inner_iterator_selector<XprType, typename internal::evaluator_traits<XprType>::Kind> IteratorType;
+  typedef internal::evaluator<XprType> EvaluatorType;
+  typedef typename internal::traits<XprType>::Scalar Scalar;
+public:
+  /** Construct an iterator over the \a outerId -th row or column of \a xpr */
+  InnerIterator(const XprType &xpr, const Index &outerId)
+    : m_eval(xpr), m_iter(m_eval, outerId, xpr.innerSize())
+  {}
+  
+  /// \returns the value of the current coefficient.
+  EIGEN_STRONG_INLINE Scalar value() const          { return m_iter.value(); }
+  /** Increment the iterator \c *this to the next non-zero coefficient.
+    * Explicit zeros are not skipped over. To skip explicit zeros, see class SparseView
+    */
+  EIGEN_STRONG_INLINE InnerIterator& operator++()   { m_iter.operator++(); return *this; }
+  EIGEN_STRONG_INLINE InnerIterator& operator+=(Index i) { m_iter.operator+=(i); return *this; }
+  EIGEN_STRONG_INLINE InnerIterator operator+(Index i) 
+  { InnerIterator result(*this); result+=i; return result; }
+    
+
+  /// \returns the column or row index of the current coefficient.
+  EIGEN_STRONG_INLINE Index index() const           { return m_iter.index(); }
+  /// \returns the row index of the current coefficient.
+  EIGEN_STRONG_INLINE Index row() const             { return m_iter.row(); }
+  /// \returns the column index of the current coefficient.
+  EIGEN_STRONG_INLINE Index col() const             { return m_iter.col(); }
+  /// \returns \c true if the iterator \c *this still references a valid coefficient.
+  EIGEN_STRONG_INLINE operator bool() const         { return m_iter; }
+  
+protected:
+  EvaluatorType m_eval;
+  IteratorType m_iter;
+private:
+  // If you get here, then you're not using the right InnerIterator type, e.g.:
+  //   SparseMatrix<double,RowMajor> A;
+  //   SparseMatrix<double>::InnerIterator it(A,0);
+  template<typename T> InnerIterator(const EigenBase<T>&,Index outer);
+};
+
+namespace internal {
+
+// Generic inner iterator implementation for dense objects
+template<typename XprType>
+class inner_iterator_selector<XprType, IndexBased>
+{
+protected:
+  typedef evaluator<XprType> EvaluatorType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  enum { IsRowMajor = (XprType::Flags&RowMajorBit)==RowMajorBit };
+  
+public:
+  EIGEN_STRONG_INLINE inner_iterator_selector(const EvaluatorType &eval, const Index &outerId, const Index &innerSize)
+    : m_eval(eval), m_inner(0), m_outer(outerId), m_end(innerSize)
+  {}
+
+  EIGEN_STRONG_INLINE Scalar value() const
+  {
+    return (IsRowMajor) ? m_eval.coeff(m_outer, m_inner)
+                        : m_eval.coeff(m_inner, m_outer);
+  }
+
+  EIGEN_STRONG_INLINE inner_iterator_selector& operator++() { m_inner++; return *this; }
+
+  EIGEN_STRONG_INLINE Index index() const { return m_inner; }
+  inline Index row() const { return IsRowMajor ? m_outer : index(); }
+  inline Index col() const { return IsRowMajor ? index() : m_outer; }
+
+  EIGEN_STRONG_INLINE operator bool() const { return m_inner < m_end && m_inner>=0; }
+
+protected:
+  const EvaluatorType& m_eval;
+  Index m_inner;
+  const Index m_outer;
+  const Index m_end;
+};
+
+// For iterator-based evaluator, inner-iterator is already implemented as
+// evaluator<>::InnerIterator
+template<typename XprType>
+class inner_iterator_selector<XprType, IteratorBased>
+ : public evaluator<XprType>::InnerIterator
+{
+protected:
+  typedef typename evaluator<XprType>::InnerIterator Base;
+  typedef evaluator<XprType> EvaluatorType;
+  
+public:
+  EIGEN_STRONG_INLINE inner_iterator_selector(const EvaluatorType &eval, const Index &outerId, const Index &/*innerSize*/)
+    : Base(eval, outerId)
+  {}  
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COREITERATORS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseBinaryOp.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseBinaryOp.h
new file mode 100644
index 00000000..2202b1cc
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseBinaryOp.h
@@ -0,0 +1,183 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_BINARY_OP_H
+#define EIGEN_CWISE_BINARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  // we must not inherit from traits<Lhs> since it has
+  // the potential to cause problems with MSVC
+  typedef typename remove_all<Lhs>::type Ancestor;
+  typedef typename traits<Ancestor>::XprKind XprKind;
+  enum {
+    RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime,
+    ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime,
+    MaxRowsAtCompileTime = traits<Ancestor>::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = traits<Ancestor>::MaxColsAtCompileTime
+  };
+
+  // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor),
+  // we still want to handle the case when the result type is different.
+  typedef typename result_of<
+                     BinaryOp(
+                       const typename Lhs::Scalar&,
+                       const typename Rhs::Scalar&
+                     )
+                   >::type Scalar;
+  typedef typename cwise_promote_storage_type<typename traits<Lhs>::StorageKind,
+                                              typename traits<Rhs>::StorageKind,
+                                              BinaryOp>::ret StorageKind;
+  typedef typename promote_index_type<typename traits<Lhs>::StorageIndex,
+                                      typename traits<Rhs>::StorageIndex>::type StorageIndex;
+  typedef typename Lhs::Nested LhsNested;
+  typedef typename Rhs::Nested RhsNested;
+  typedef typename remove_reference<LhsNested>::type _LhsNested;
+  typedef typename remove_reference<RhsNested>::type _RhsNested;
+  enum {
+    Flags = cwise_promote_storage_order<typename traits<Lhs>::StorageKind,typename traits<Rhs>::StorageKind,_LhsNested::Flags & RowMajorBit,_RhsNested::Flags & RowMajorBit>::value
+  };
+};
+} // end namespace internal
+
+template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
+class CwiseBinaryOpImpl;
+
+/** \class CwiseBinaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression where a coefficient-wise binary operator is applied to two expressions
+  *
+  * \tparam BinaryOp template functor implementing the operator
+  * \tparam LhsType the type of the left-hand side
+  * \tparam RhsType the type of the right-hand side
+  *
+  * This class represents an expression  where a coefficient-wise binary operator is applied to two expressions.
+  * It is the return type of binary operators, by which we mean only those binary operators where
+  * both the left-hand side and the right-hand side are Eigen expressions.
+  * For example, the return type of matrix1+matrix2 is a CwiseBinaryOp.
+  *
+  * Most of the time, this is the only way that it is used, so you typically don't have to name
+  * CwiseBinaryOp types explicitly.
+  *
+  * \sa MatrixBase::binaryExpr(const MatrixBase<OtherDerived> &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp
+  */
+template<typename BinaryOp, typename LhsType, typename RhsType>
+class CwiseBinaryOp :
+  public CwiseBinaryOpImpl<
+          BinaryOp, LhsType, RhsType,
+          typename internal::cwise_promote_storage_type<typename internal::traits<LhsType>::StorageKind,
+                                                        typename internal::traits<RhsType>::StorageKind,
+                                                        BinaryOp>::ret>,
+  internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::remove_all<BinaryOp>::type Functor;
+    typedef typename internal::remove_all<LhsType>::type Lhs;
+    typedef typename internal::remove_all<RhsType>::type Rhs;
+
+    typedef typename CwiseBinaryOpImpl<
+        BinaryOp, LhsType, RhsType,
+        typename internal::cwise_promote_storage_type<typename internal::traits<LhsType>::StorageKind,
+                                                      typename internal::traits<Rhs>::StorageKind,
+                                                      BinaryOp>::ret>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp)
+
+    typedef typename internal::ref_selector<LhsType>::type LhsNested;
+    typedef typename internal::ref_selector<RhsType>::type RhsNested;
+    typedef typename internal::remove_reference<LhsNested>::type _LhsNested;
+    typedef typename internal::remove_reference<RhsNested>::type _RhsNested;
+
+#if EIGEN_COMP_MSVC && EIGEN_HAS_CXX11
+    //Required for Visual Studio or the Copy constructor will probably not get inlined!
+    EIGEN_STRONG_INLINE
+    CwiseBinaryOp(const CwiseBinaryOp<BinaryOp,LhsType,RhsType>&) = default;
+#endif
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp())
+      : m_lhs(aLhs), m_rhs(aRhs), m_functor(func)
+    {
+      EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename Rhs::Scalar);
+      // require the sizes to match
+      EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
+      eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols());
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT {
+      // return the fixed size type if available to enable compile time optimizations
+      return internal::traits<typename internal::remove_all<LhsNested>::type>::RowsAtCompileTime==Dynamic ? m_rhs.rows() : m_lhs.rows();
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT {
+      // return the fixed size type if available to enable compile time optimizations
+      return internal::traits<typename internal::remove_all<LhsNested>::type>::ColsAtCompileTime==Dynamic ? m_rhs.cols() : m_lhs.cols();
+    }
+
+    /** \returns the left hand side nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const _LhsNested& lhs() const { return m_lhs; }
+    /** \returns the right hand side nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const _RhsNested& rhs() const { return m_rhs; }
+    /** \returns the functor representing the binary operation */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const BinaryOp& functor() const { return m_functor; }
+
+  protected:
+    LhsNested m_lhs;
+    RhsNested m_rhs;
+    const BinaryOp m_functor;
+};
+
+// Generic API dispatcher
+template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
+class CwiseBinaryOpImpl
+  : public internal::generic_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type Base;
+};
+
+/** replaces \c *this by \c *this - \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+/** replaces \c *this by \c *this + \a other.
+  *
+  * \returns a reference to \c *this
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived &
+MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_BINARY_OP_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseNullaryOp.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseNullaryOp.h
new file mode 100644
index 00000000..289ec510
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseNullaryOp.h
@@ -0,0 +1,1001 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_NULLARY_OP_H
+#define EIGEN_CWISE_NULLARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename NullaryOp, typename PlainObjectType>
+struct traits<CwiseNullaryOp<NullaryOp, PlainObjectType> > : traits<PlainObjectType>
+{
+  enum {
+    Flags = traits<PlainObjectType>::Flags & RowMajorBit
+  };
+};
+
+} // namespace internal
+
+/** \class CwiseNullaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression of a matrix where all coefficients are defined by a functor
+  *
+  * \tparam NullaryOp template functor implementing the operator
+  * \tparam PlainObjectType the underlying plain matrix/array type
+  *
+  * This class represents an expression of a generic nullary operator.
+  * It is the return type of the Ones(), Zero(), Constant(), Identity() and Random() methods,
+  * and most of the time this is the only way it is used.
+  *
+  * However, if you want to write a function returning such an expression, you
+  * will need to use this class.
+  *
+  * The functor NullaryOp must expose one of the following method:
+    <table class="manual">
+    <tr            ><td>\c operator()() </td><td>if the procedural generation does not depend on the coefficient entries (e.g., random numbers)</td></tr>
+    <tr class="alt"><td>\c operator()(Index i)</td><td>if the procedural generation makes sense for vectors only and that it depends on the coefficient index \c i (e.g., linspace) </td></tr>
+    <tr            ><td>\c operator()(Index i,Index j)</td><td>if the procedural generation depends on the matrix coordinates \c i, \c j (e.g., to generate a checkerboard with 0 and 1)</td></tr>
+    </table>
+  * It is also possible to expose the last two operators if the generation makes sense for matrices but can be optimized for vectors.
+  *
+  * See DenseBase::NullaryExpr(Index,const CustomNullaryOp&) for an example binding
+  * C++11 random number generators.
+  *
+  * A nullary expression can also be used to implement custom sophisticated matrix manipulations
+  * that cannot be covered by the existing set of natively supported matrix manipulations.
+  * See this \ref TopicCustomizing_NullaryExpr "page" for some examples and additional explanations
+  * on the behavior of CwiseNullaryOp.
+  *
+  * \sa class CwiseUnaryOp, class CwiseBinaryOp, DenseBase::NullaryExpr
+  */
+template<typename NullaryOp, typename PlainObjectType>
+class CwiseNullaryOp : public internal::dense_xpr_base< CwiseNullaryOp<NullaryOp, PlainObjectType> >::type, internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<CwiseNullaryOp>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(CwiseNullaryOp)
+
+    EIGEN_DEVICE_FUNC
+    CwiseNullaryOp(Index rows, Index cols, const NullaryOp& func = NullaryOp())
+      : m_rows(rows), m_cols(cols), m_functor(func)
+    {
+      eigen_assert(rows >= 0
+            && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
+            &&  cols >= 0
+            && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols));
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const { return m_rows.value(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const { return m_cols.value(); }
+
+    /** \returns the functor representing the nullary operation */
+    EIGEN_DEVICE_FUNC
+    const NullaryOp& functor() const { return m_functor; }
+
+  protected:
+    const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
+    const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
+    const NullaryOp m_functor;
+};
+
+
+/** \returns an expression of a matrix defined by a custom functor \a func
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+template<typename CustomNullaryOp>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const CwiseNullaryOp<CustomNullaryOp,typename DenseBase<Derived>::PlainObject>
+#else
+const CwiseNullaryOp<CustomNullaryOp,PlainObject>
+#endif
+DenseBase<Derived>::NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func)
+{
+  return CwiseNullaryOp<CustomNullaryOp, PlainObject>(rows, cols, func);
+}
+
+/** \returns an expression of a matrix defined by a custom functor \a func
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * Here is an example with C++11 random generators: \include random_cpp11.cpp
+  * Output: \verbinclude random_cpp11.out
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+template<typename CustomNullaryOp>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const CwiseNullaryOp<CustomNullaryOp, typename DenseBase<Derived>::PlainObject>
+#else
+const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+#endif
+DenseBase<Derived>::NullaryExpr(Index size, const CustomNullaryOp& func)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  if(RowsAtCompileTime == 1) return CwiseNullaryOp<CustomNullaryOp, PlainObject>(1, size, func);
+  else return CwiseNullaryOp<CustomNullaryOp, PlainObject>(size, 1, func);
+}
+
+/** \returns an expression of a matrix defined by a custom functor \a func
+  *
+  * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+template<typename CustomNullaryOp>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const CwiseNullaryOp<CustomNullaryOp, typename DenseBase<Derived>::PlainObject>
+#else
+const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+#endif
+DenseBase<Derived>::NullaryExpr(const CustomNullaryOp& func)
+{
+  return CwiseNullaryOp<CustomNullaryOp, PlainObject>(RowsAtCompileTime, ColsAtCompileTime, func);
+}
+
+/** \returns an expression of a constant matrix of value \a value
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this DenseBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Constant(Index rows, Index cols, const Scalar& value)
+{
+  return DenseBase<Derived>::NullaryExpr(rows, cols, internal::scalar_constant_op<Scalar>(value));
+}
+
+/** \returns an expression of a constant matrix of value \a value
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this DenseBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Zero() should be used
+  * instead.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Constant(Index size, const Scalar& value)
+{
+  return DenseBase<Derived>::NullaryExpr(size, internal::scalar_constant_op<Scalar>(value));
+}
+
+/** \returns an expression of a constant matrix of value \a value
+  *
+  * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * The template parameter \a CustomNullaryOp is the type of the functor.
+  *
+  * \sa class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Constant(const Scalar& value)
+{
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return DenseBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_constant_op<Scalar>(value));
+}
+
+/** \deprecated because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(Index,const Scalar&,const Scalar&)
+  *
+  * \only_for_vectors
+  *
+  * Example: \include DenseBase_LinSpaced_seq_deprecated.cpp
+  * Output: \verbinclude DenseBase_LinSpaced_seq_deprecated.out
+  *
+  * \sa LinSpaced(Index,const Scalar&, const Scalar&), setLinSpaced(Index,const Scalar&,const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEPRECATED EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar>(low,high,size));
+}
+
+/** \deprecated because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(const Scalar&,const Scalar&)
+  *
+  * \sa LinSpaced(const Scalar&, const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEPRECATED EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(Sequential_t, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar>(low,high,Derived::SizeAtCompileTime));
+}
+
+/**
+  * \brief Sets a linearly spaced vector.
+  *
+  * The function generates 'size' equally spaced values in the closed interval [low,high].
+  * When size is set to 1, a vector of length 1 containing 'high' is returned.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include DenseBase_LinSpaced.cpp
+  * Output: \verbinclude DenseBase_LinSpaced.out
+  *
+  * For integer scalar types, an even spacing is possible if and only if the length of the range,
+  * i.e., \c high-low is a scalar multiple of \c size-1, or if \c size is a scalar multiple of the
+  * number of values \c high-low+1 (meaning each value can be repeated the same number of time).
+  * If one of these two considions is not satisfied, then \c high is lowered to the largest value
+  * satisfying one of this constraint.
+  * Here are some examples:
+  *
+  * Example: \include DenseBase_LinSpacedInt.cpp
+  * Output: \verbinclude DenseBase_LinSpacedInt.out
+  *
+  * \sa setLinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(Index size, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar>(low,high,size));
+}
+
+/**
+  * \copydoc DenseBase::LinSpaced(Index, const Scalar&, const Scalar&)
+  * Special version for fixed size types which does not require the size parameter.
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedReturnType
+DenseBase<Derived>::LinSpaced(const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar>(low,high,Derived::SizeAtCompileTime));
+}
+
+/** \returns true if all coefficients in this matrix are approximately equal to \a val, to within precision \a prec */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isApproxToConstant
+(const Scalar& val, const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = 0; i < rows(); ++i)
+      if(!internal::isApprox(self.coeff(i, j), val, prec))
+        return false;
+  return true;
+}
+
+/** This is just an alias for isApproxToConstant().
+  *
+  * \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isConstant
+(const Scalar& val, const RealScalar& prec) const
+{
+  return isApproxToConstant(val, prec);
+}
+
+/** Alias for setConstant(): sets all coefficients in this expression to \a val.
+  *
+  * \sa setConstant(), Constant(), class CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void DenseBase<Derived>::fill(const Scalar& val)
+{
+  setConstant(val);
+}
+
+/** Sets all coefficients in this expression to value \a val.
+  *
+  * \sa fill(), setConstant(Index,const Scalar&), setConstant(Index,Index,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setConstant(const Scalar& val)
+{
+  return derived() = Constant(rows(), cols(), val);
+}
+
+/** Resizes to the given \a size, and sets all coefficients in this expression to the given value \a val.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setConstant_int.cpp
+  * Output: \verbinclude Matrix_setConstant_int.out
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setConstant(Index size, const Scalar& val)
+{
+  resize(size);
+  return setConstant(val);
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to the given value \a val.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  * \param val the value to which all coefficients are set
+  *
+  * Example: \include Matrix_setConstant_int_int.cpp
+  * Output: \verbinclude Matrix_setConstant_int_int.out
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setConstant(Index rows, Index cols, const Scalar& val)
+{
+  resize(rows, cols);
+  return setConstant(val);
+}
+
+/** Resizes to the given size, changing only the number of columns, and sets all
+  * coefficients in this expression to the given value \a val. For the parameter
+  * of type NoChange_t, just pass the special value \c NoChange.
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setConstant(NoChange_t, Index cols, const Scalar& val)
+{
+  return setConstant(rows(), cols, val);
+}
+
+/** Resizes to the given size, changing only the number of rows, and sets all
+  * coefficients in this expression to the given value \a val. For the parameter
+  * of type NoChange_t, just pass the special value \c NoChange.
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(Index,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setConstant(Index rows, NoChange_t, const Scalar& val)
+{
+  return setConstant(rows, cols(), val);
+}
+
+
+/**
+  * \brief Sets a linearly spaced vector.
+  *
+  * The function generates 'size' equally spaced values in the closed interval [low,high].
+  * When size is set to 1, a vector of length 1 containing 'high' is returned.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include DenseBase_setLinSpaced.cpp
+  * Output: \verbinclude DenseBase_setLinSpaced.out
+  *
+  * For integer scalar types, do not miss the explanations on the definition
+  * of \link LinSpaced(Index,const Scalar&,const Scalar&) even spacing \endlink.
+  *
+  * \sa LinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(Index newSize, const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return derived() = Derived::NullaryExpr(newSize, internal::linspaced_op<Scalar>(low,high,newSize));
+}
+
+/**
+  * \brief Sets a linearly spaced vector.
+  *
+  * The function fills \c *this with equally spaced values in the closed interval [low,high].
+  * When size is set to 1, a vector of length 1 containing 'high' is returned.
+  *
+  * \only_for_vectors
+  *
+  * For integer scalar types, do not miss the explanations on the definition
+  * of \link LinSpaced(Index,const Scalar&,const Scalar&) even spacing \endlink.
+  *
+  * \sa LinSpaced(Index,const Scalar&,const Scalar&), setLinSpaced(Index, const Scalar&, const Scalar&), CwiseNullaryOp
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(const Scalar& low, const Scalar& high)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return setLinSpaced(size(), low, high);
+}
+
+// zero:
+
+/** \returns an expression of a zero matrix.
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_zero_int_int.cpp
+  * Output: \verbinclude MatrixBase_zero_int_int.out
+  *
+  * \sa Zero(), Zero(Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Zero(Index rows, Index cols)
+{
+  return Constant(rows, cols, Scalar(0));
+}
+
+/** \returns an expression of a zero vector.
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Zero() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_zero_int.cpp
+  * Output: \verbinclude MatrixBase_zero_int.out
+  *
+  * \sa Zero(), Zero(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Zero(Index size)
+{
+  return Constant(size, Scalar(0));
+}
+
+/** \returns an expression of a fixed-size zero matrix or vector.
+  *
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * Example: \include MatrixBase_zero.cpp
+  * Output: \verbinclude MatrixBase_zero.out
+  *
+  * \sa Zero(Index), Zero(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Zero()
+{
+  return Constant(Scalar(0));
+}
+
+/** \returns true if *this is approximately equal to the zero matrix,
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isZero.cpp
+  * Output: \verbinclude MatrixBase_isZero.out
+  *
+  * \sa class CwiseNullaryOp, Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isZero(const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = 0; i < rows(); ++i)
+      if(!internal::isMuchSmallerThan(self.coeff(i, j), static_cast<Scalar>(1), prec))
+        return false;
+  return true;
+}
+
+/** Sets all coefficients in this expression to zero.
+  *
+  * Example: \include MatrixBase_setZero.cpp
+  * Output: \verbinclude MatrixBase_setZero.out
+  *
+  * \sa class CwiseNullaryOp, Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setZero()
+{
+  return setConstant(Scalar(0));
+}
+
+/** Resizes to the given \a size, and sets all coefficients in this expression to zero.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setZero_int.cpp
+  * Output: \verbinclude Matrix_setZero_int.out
+  *
+  * \sa DenseBase::setZero(), setZero(Index,Index), class CwiseNullaryOp, DenseBase::Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setZero(Index newSize)
+{
+  resize(newSize);
+  return setConstant(Scalar(0));
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to zero.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setZero_int_int.cpp
+  * Output: \verbinclude Matrix_setZero_int_int.out
+  *
+  * \sa DenseBase::setZero(), setZero(Index), class CwiseNullaryOp, DenseBase::Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setZero(Index rows, Index cols)
+{
+  resize(rows, cols);
+  return setConstant(Scalar(0));
+}
+
+/** Resizes to the given size, changing only the number of columns, and sets all
+  * coefficients in this expression to zero. For the parameter of type NoChange_t,
+  * just pass the special value \c NoChange.
+  *
+  * \sa DenseBase::setZero(), setZero(Index), setZero(Index, Index), setZero(Index, NoChange_t), class CwiseNullaryOp, DenseBase::Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setZero(NoChange_t, Index cols)
+{
+  return setZero(rows(), cols);
+}
+
+/** Resizes to the given size, changing only the number of rows, and sets all
+  * coefficients in this expression to zero. For the parameter of type NoChange_t,
+  * just pass the special value \c NoChange.
+  *
+  * \sa DenseBase::setZero(), setZero(Index), setZero(Index, Index), setZero(NoChange_t, Index), class CwiseNullaryOp, DenseBase::Zero()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setZero(Index rows, NoChange_t)
+{
+  return setZero(rows, cols());
+}
+
+// ones:
+
+/** \returns an expression of a matrix where all coefficients equal one.
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Ones() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_ones_int_int.cpp
+  * Output: \verbinclude MatrixBase_ones_int_int.out
+  *
+  * \sa Ones(), Ones(Index), isOnes(), class Ones
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Ones(Index rows, Index cols)
+{
+  return Constant(rows, cols, Scalar(1));
+}
+
+/** \returns an expression of a vector where all coefficients equal one.
+  *
+  * The parameter \a newSize is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Ones() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_ones_int.cpp
+  * Output: \verbinclude MatrixBase_ones_int.out
+  *
+  * \sa Ones(), Ones(Index,Index), isOnes(), class Ones
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Ones(Index newSize)
+{
+  return Constant(newSize, Scalar(1));
+}
+
+/** \returns an expression of a fixed-size matrix or vector where all coefficients equal one.
+  *
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * Example: \include MatrixBase_ones.cpp
+  * Output: \verbinclude MatrixBase_ones.out
+  *
+  * \sa Ones(Index), Ones(Index,Index), isOnes(), class Ones
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
+DenseBase<Derived>::Ones()
+{
+  return Constant(Scalar(1));
+}
+
+/** \returns true if *this is approximately equal to the matrix where all coefficients
+  *          are equal to 1, within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isOnes.cpp
+  * Output: \verbinclude MatrixBase_isOnes.out
+  *
+  * \sa class CwiseNullaryOp, Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isOnes
+(const RealScalar& prec) const
+{
+  return isApproxToConstant(Scalar(1), prec);
+}
+
+/** Sets all coefficients in this expression to one.
+  *
+  * Example: \include MatrixBase_setOnes.cpp
+  * Output: \verbinclude MatrixBase_setOnes.out
+  *
+  * \sa class CwiseNullaryOp, Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setOnes()
+{
+  return setConstant(Scalar(1));
+}
+
+/** Resizes to the given \a newSize, and sets all coefficients in this expression to one.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setOnes_int.cpp
+  * Output: \verbinclude Matrix_setOnes_int.out
+  *
+  * \sa MatrixBase::setOnes(), setOnes(Index,Index), class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setOnes(Index newSize)
+{
+  resize(newSize);
+  return setConstant(Scalar(1));
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to one.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setOnes_int_int.cpp
+  * Output: \verbinclude Matrix_setOnes_int_int.out
+  *
+  * \sa MatrixBase::setOnes(), setOnes(Index), class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setOnes(Index rows, Index cols)
+{
+  resize(rows, cols);
+  return setConstant(Scalar(1));
+}
+
+/** Resizes to the given size, changing only the number of rows, and sets all
+  * coefficients in this expression to one. For the parameter of type NoChange_t,
+  * just pass the special value \c NoChange.
+  *
+ * \sa MatrixBase::setOnes(), setOnes(Index), setOnes(Index, Index), setOnes(NoChange_t, Index), class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setOnes(Index rows, NoChange_t)
+{
+  return setOnes(rows, cols());
+}
+
+/** Resizes to the given size, changing only the number of columns, and sets all
+  * coefficients in this expression to one. For the parameter of type NoChange_t,
+  * just pass the special value \c NoChange.
+  *
+ * \sa MatrixBase::setOnes(), setOnes(Index), setOnes(Index, Index), setOnes(Index, NoChange_t) class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setOnes(NoChange_t, Index cols)
+{
+  return setOnes(rows(), cols);
+}
+
+// Identity:
+
+/** \returns an expression of the identity matrix (not necessarily square).
+  *
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Identity() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_identity_int_int.cpp
+  * Output: \verbinclude MatrixBase_identity_int_int.out
+  *
+  * \sa Identity(), setIdentity(), isIdentity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType
+MatrixBase<Derived>::Identity(Index rows, Index cols)
+{
+  return DenseBase<Derived>::NullaryExpr(rows, cols, internal::scalar_identity_op<Scalar>());
+}
+
+/** \returns an expression of the identity matrix (not necessarily square).
+  *
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variant taking size arguments.
+  *
+  * Example: \include MatrixBase_identity.cpp
+  * Output: \verbinclude MatrixBase_identity.out
+  *
+  * \sa Identity(Index,Index), setIdentity(), isIdentity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType
+MatrixBase<Derived>::Identity()
+{
+  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+  return MatrixBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_identity_op<Scalar>());
+}
+
+/** \returns true if *this is approximately equal to the identity matrix
+  *          (not necessarily square),
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isIdentity.cpp
+  * Output: \verbinclude MatrixBase_isIdentity.out
+  *
+  * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), setIdentity()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isIdentity
+(const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index j = 0; j < cols(); ++j)
+  {
+    for(Index i = 0; i < rows(); ++i)
+    {
+      if(i == j)
+      {
+        if(!internal::isApprox(self.coeff(i, j), static_cast<Scalar>(1), prec))
+          return false;
+      }
+      else
+      {
+        if(!internal::isMuchSmallerThan(self.coeff(i, j), static_cast<RealScalar>(1), prec))
+          return false;
+      }
+    }
+  }
+  return true;
+}
+
+namespace internal {
+
+template<typename Derived, bool Big = (Derived::SizeAtCompileTime>=16)>
+struct setIdentity_impl
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Derived& run(Derived& m)
+  {
+    return m = Derived::Identity(m.rows(), m.cols());
+  }
+};
+
+template<typename Derived>
+struct setIdentity_impl<Derived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Derived& run(Derived& m)
+  {
+    m.setZero();
+    const Index size = numext::mini(m.rows(), m.cols());
+    for(Index i = 0; i < size; ++i) m.coeffRef(i,i) = typename Derived::Scalar(1);
+    return m;
+  }
+};
+
+} // end namespace internal
+
+/** Writes the identity expression (not necessarily square) into *this.
+  *
+  * Example: \include MatrixBase_setIdentity.cpp
+  * Output: \verbinclude MatrixBase_setIdentity.out
+  *
+  * \sa class CwiseNullaryOp, Identity(), Identity(Index,Index), isIdentity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity()
+{
+  return internal::setIdentity_impl<Derived>::run(derived());
+}
+
+/** \brief Resizes to the given size, and writes the identity expression (not necessarily square) into *this.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setIdentity_int_int.cpp
+  * Output: \verbinclude Matrix_setIdentity_int_int.out
+  *
+  * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Identity()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity(Index rows, Index cols)
+{
+  derived().resize(rows, cols);
+  return setIdentity();
+}
+
+/** \returns an expression of the i-th unit (basis) vector.
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::Unit(Index newSize, Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return BasisReturnType(SquareMatrixType::Identity(newSize,newSize), i);
+}
+
+/** \returns an expression of the i-th unit (basis) vector.
+  *
+  * \only_for_vectors
+  *
+  * This variant is for fixed-size vector only.
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::UnitX(), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::Unit(Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return BasisReturnType(SquareMatrixType::Identity(),i);
+}
+
+/** \returns an expression of the X axis unit vector (1{,0}^*)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitX()
+{ return Derived::Unit(0); }
+
+/** \returns an expression of the Y axis unit vector (0,1{,0}^*)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitY()
+{ return Derived::Unit(1); }
+
+/** \returns an expression of the Z axis unit vector (0,0,1{,0}^*)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitZ()
+{ return Derived::Unit(2); }
+
+/** \returns an expression of the W axis unit vector (0,0,0,1)
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::Unit(Index,Index), MatrixBase::Unit(Index), MatrixBase::UnitY(), MatrixBase::UnitZ(), MatrixBase::UnitW()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::BasisReturnType MatrixBase<Derived>::UnitW()
+{ return Derived::Unit(3); }
+
+/** \brief Set the coefficients of \c *this to the i-th unit (basis) vector
+  *
+  * \param i index of the unique coefficient to be set to 1
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Unit(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setUnit(Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  eigen_assert(i<size());
+  derived().setZero();
+  derived().coeffRef(i) = Scalar(1);
+  return derived();
+}
+
+/** \brief Resizes to the given \a newSize, and writes the i-th unit (basis) vector into *this.
+  *
+  * \param newSize the new size of the vector
+  * \param i index of the unique coefficient to be set to 1
+  *
+  * \only_for_vectors
+  *
+  * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Unit(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setUnit(Index newSize, Index i)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  eigen_assert(i<newSize);
+  derived().resize(newSize);
+  return setUnit(i);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_NULLARY_OP_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseTernaryOp.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseTernaryOp.h
new file mode 100644
index 00000000..9f3576fe
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseTernaryOp.h
@@ -0,0 +1,197 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_TERNARY_OP_H
+#define EIGEN_CWISE_TERNARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+struct traits<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > {
+  // we must not inherit from traits<Arg1> since it has
+  // the potential to cause problems with MSVC
+  typedef typename remove_all<Arg1>::type Ancestor;
+  typedef typename traits<Ancestor>::XprKind XprKind;
+  enum {
+    RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime,
+    ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime,
+    MaxRowsAtCompileTime = traits<Ancestor>::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = traits<Ancestor>::MaxColsAtCompileTime
+  };
+
+  // even though we require Arg1, Arg2, and Arg3 to have the same scalar type
+  // (see CwiseTernaryOp constructor),
+  // we still want to handle the case when the result type is different.
+  typedef typename result_of<TernaryOp(
+      const typename Arg1::Scalar&, const typename Arg2::Scalar&,
+      const typename Arg3::Scalar&)>::type Scalar;
+
+  typedef typename internal::traits<Arg1>::StorageKind StorageKind;
+  typedef typename internal::traits<Arg1>::StorageIndex StorageIndex;
+
+  typedef typename Arg1::Nested Arg1Nested;
+  typedef typename Arg2::Nested Arg2Nested;
+  typedef typename Arg3::Nested Arg3Nested;
+  typedef typename remove_reference<Arg1Nested>::type _Arg1Nested;
+  typedef typename remove_reference<Arg2Nested>::type _Arg2Nested;
+  typedef typename remove_reference<Arg3Nested>::type _Arg3Nested;
+  enum { Flags = _Arg1Nested::Flags & RowMajorBit };
+};
+}  // end namespace internal
+
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3,
+          typename StorageKind>
+class CwiseTernaryOpImpl;
+
+/** \class CwiseTernaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression where a coefficient-wise ternary operator is
+ * applied to two expressions
+  *
+  * \tparam TernaryOp template functor implementing the operator
+  * \tparam Arg1Type the type of the first argument
+  * \tparam Arg2Type the type of the second argument
+  * \tparam Arg3Type the type of the third argument
+  *
+  * This class represents an expression where a coefficient-wise ternary
+ * operator is applied to three expressions.
+  * It is the return type of ternary operators, by which we mean only those
+ * ternary operators where
+  * all three arguments are Eigen expressions.
+  * For example, the return type of betainc(matrix1, matrix2, matrix3) is a
+ * CwiseTernaryOp.
+  *
+  * Most of the time, this is the only way that it is used, so you typically
+ * don't have to name
+  * CwiseTernaryOp types explicitly.
+  *
+  * \sa MatrixBase::ternaryExpr(const MatrixBase<Argument2> &, const
+ * MatrixBase<Argument3> &, const CustomTernaryOp &) const, class CwiseBinaryOp,
+ * class CwiseUnaryOp, class CwiseNullaryOp
+  */
+template <typename TernaryOp, typename Arg1Type, typename Arg2Type,
+          typename Arg3Type>
+class CwiseTernaryOp : public CwiseTernaryOpImpl<
+                           TernaryOp, Arg1Type, Arg2Type, Arg3Type,
+                           typename internal::traits<Arg1Type>::StorageKind>,
+                       internal::no_assignment_operator
+{
+ public:
+  typedef typename internal::remove_all<Arg1Type>::type Arg1;
+  typedef typename internal::remove_all<Arg2Type>::type Arg2;
+  typedef typename internal::remove_all<Arg3Type>::type Arg3;
+
+  typedef typename CwiseTernaryOpImpl<
+      TernaryOp, Arg1Type, Arg2Type, Arg3Type,
+      typename internal::traits<Arg1Type>::StorageKind>::Base Base;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseTernaryOp)
+
+  typedef typename internal::ref_selector<Arg1Type>::type Arg1Nested;
+  typedef typename internal::ref_selector<Arg2Type>::type Arg2Nested;
+  typedef typename internal::ref_selector<Arg3Type>::type Arg3Nested;
+  typedef typename internal::remove_reference<Arg1Nested>::type _Arg1Nested;
+  typedef typename internal::remove_reference<Arg2Nested>::type _Arg2Nested;
+  typedef typename internal::remove_reference<Arg3Nested>::type _Arg3Nested;
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE CwiseTernaryOp(const Arg1& a1, const Arg2& a2,
+                                     const Arg3& a3,
+                                     const TernaryOp& func = TernaryOp())
+      : m_arg1(a1), m_arg2(a2), m_arg3(a3), m_functor(func) {
+    // require the sizes to match
+    EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Arg1, Arg2)
+    EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Arg1, Arg3)
+
+    // The index types should match
+    EIGEN_STATIC_ASSERT((internal::is_same<
+                         typename internal::traits<Arg1Type>::StorageKind,
+                         typename internal::traits<Arg2Type>::StorageKind>::value),
+                        STORAGE_KIND_MUST_MATCH)
+    EIGEN_STATIC_ASSERT((internal::is_same<
+                         typename internal::traits<Arg1Type>::StorageKind,
+                         typename internal::traits<Arg3Type>::StorageKind>::value),
+                        STORAGE_KIND_MUST_MATCH)
+
+    eigen_assert(a1.rows() == a2.rows() && a1.cols() == a2.cols() &&
+                 a1.rows() == a3.rows() && a1.cols() == a3.cols());
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE Index rows() const {
+    // return the fixed size type if available to enable compile time
+    // optimizations
+    if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                RowsAtCompileTime == Dynamic &&
+        internal::traits<typename internal::remove_all<Arg2Nested>::type>::
+                RowsAtCompileTime == Dynamic)
+      return m_arg3.rows();
+    else if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                     RowsAtCompileTime == Dynamic &&
+             internal::traits<typename internal::remove_all<Arg3Nested>::type>::
+                     RowsAtCompileTime == Dynamic)
+      return m_arg2.rows();
+    else
+      return m_arg1.rows();
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE Index cols() const {
+    // return the fixed size type if available to enable compile time
+    // optimizations
+    if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                ColsAtCompileTime == Dynamic &&
+        internal::traits<typename internal::remove_all<Arg2Nested>::type>::
+                ColsAtCompileTime == Dynamic)
+      return m_arg3.cols();
+    else if (internal::traits<typename internal::remove_all<Arg1Nested>::type>::
+                     ColsAtCompileTime == Dynamic &&
+             internal::traits<typename internal::remove_all<Arg3Nested>::type>::
+                     ColsAtCompileTime == Dynamic)
+      return m_arg2.cols();
+    else
+      return m_arg1.cols();
+  }
+
+  /** \returns the first argument nested expression */
+  EIGEN_DEVICE_FUNC
+  const _Arg1Nested& arg1() const { return m_arg1; }
+  /** \returns the first argument nested expression */
+  EIGEN_DEVICE_FUNC
+  const _Arg2Nested& arg2() const { return m_arg2; }
+  /** \returns the third argument nested expression */
+  EIGEN_DEVICE_FUNC
+  const _Arg3Nested& arg3() const { return m_arg3; }
+  /** \returns the functor representing the ternary operation */
+  EIGEN_DEVICE_FUNC
+  const TernaryOp& functor() const { return m_functor; }
+
+ protected:
+  Arg1Nested m_arg1;
+  Arg2Nested m_arg2;
+  Arg3Nested m_arg3;
+  const TernaryOp m_functor;
+};
+
+// Generic API dispatcher
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3,
+          typename StorageKind>
+class CwiseTernaryOpImpl
+    : public internal::generic_xpr_base<
+          CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >::type {
+ public:
+  typedef typename internal::generic_xpr_base<
+      CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> >::type Base;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_CWISE_TERNARY_OP_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseUnaryOp.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseUnaryOp.h
new file mode 100644
index 00000000..e68c4f74
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseUnaryOp.h
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_UNARY_OP_H
+#define EIGEN_CWISE_UNARY_OP_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename UnaryOp, typename XprType>
+struct traits<CwiseUnaryOp<UnaryOp, XprType> >
+ : traits<XprType>
+{
+  typedef typename result_of<
+                     UnaryOp(const typename XprType::Scalar&)
+                   >::type Scalar;
+  typedef typename XprType::Nested XprTypeNested;
+  typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
+  enum {
+    Flags = _XprTypeNested::Flags & RowMajorBit
+  };
+};
+}
+
+template<typename UnaryOp, typename XprType, typename StorageKind>
+class CwiseUnaryOpImpl;
+
+/** \class CwiseUnaryOp
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression where a coefficient-wise unary operator is applied to an expression
+  *
+  * \tparam UnaryOp template functor implementing the operator
+  * \tparam XprType the type of the expression to which we are applying the unary operator
+  *
+  * This class represents an expression where a unary operator is applied to an expression.
+  * It is the return type of all operations taking exactly 1 input expression, regardless of the
+  * presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix
+  * is considered unary, because only the right-hand side is an expression, and its
+  * return type is a specialization of CwiseUnaryOp.
+  *
+  * Most of the time, this is the only way that it is used, so you typically don't have to name
+  * CwiseUnaryOp types explicitly.
+  *
+  * \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp
+  */
+template<typename UnaryOp, typename XprType>
+class CwiseUnaryOp : public CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind>, internal::no_assignment_operator
+{
+  public:
+
+    typedef typename CwiseUnaryOpImpl<UnaryOp, XprType,typename internal::traits<XprType>::StorageKind>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
+    typedef typename internal::ref_selector<XprType>::type XprTypeNested;
+    typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    explicit CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp())
+      : m_xpr(xpr), m_functor(func) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_xpr.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_xpr.cols(); }
+
+    /** \returns the functor representing the unary operation */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const UnaryOp& functor() const { return m_functor; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const typename internal::remove_all<XprTypeNested>::type&
+    nestedExpression() const { return m_xpr; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    typename internal::remove_all<XprTypeNested>::type&
+    nestedExpression() { return m_xpr; }
+
+  protected:
+    XprTypeNested m_xpr;
+    const UnaryOp m_functor;
+};
+
+// Generic API dispatcher
+template<typename UnaryOp, typename XprType, typename StorageKind>
+class CwiseUnaryOpImpl
+  : public internal::generic_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_UNARY_OP_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseUnaryView.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseUnaryView.h
new file mode 100644
index 00000000..a06d7621
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/CwiseUnaryView.h
@@ -0,0 +1,132 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CWISE_UNARY_VIEW_H
+#define EIGEN_CWISE_UNARY_VIEW_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename ViewOp, typename MatrixType>
+struct traits<CwiseUnaryView<ViewOp, MatrixType> >
+ : traits<MatrixType>
+{
+  typedef typename result_of<
+                     ViewOp(const typename traits<MatrixType>::Scalar&)
+                   >::type Scalar;
+  typedef typename MatrixType::Nested MatrixTypeNested;
+  typedef typename remove_all<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags = traits<_MatrixTypeNested>::Flags & (RowMajorBit | FlagsLvalueBit | DirectAccessBit), // FIXME DirectAccessBit should not be handled by expressions
+    MatrixTypeInnerStride =  inner_stride_at_compile_time<MatrixType>::ret,
+    // need to cast the sizeof's from size_t to int explicitly, otherwise:
+    // "error: no integral type can represent all of the enumerator values
+    InnerStrideAtCompileTime = MatrixTypeInnerStride == Dynamic
+                             ? int(Dynamic)
+                             : int(MatrixTypeInnerStride) * int(sizeof(typename traits<MatrixType>::Scalar) / sizeof(Scalar)),
+    OuterStrideAtCompileTime = outer_stride_at_compile_time<MatrixType>::ret == Dynamic
+                             ? int(Dynamic)
+                             : outer_stride_at_compile_time<MatrixType>::ret * int(sizeof(typename traits<MatrixType>::Scalar) / sizeof(Scalar))
+  };
+};
+}
+
+template<typename ViewOp, typename MatrixType, typename StorageKind>
+class CwiseUnaryViewImpl;
+
+/** \class CwiseUnaryView
+  * \ingroup Core_Module
+  *
+  * \brief Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector
+  *
+  * \tparam ViewOp template functor implementing the view
+  * \tparam MatrixType the type of the matrix we are applying the unary operator
+  *
+  * This class represents a lvalue expression of a generic unary view operator of a matrix or a vector.
+  * It is the return type of real() and imag(), and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::unaryViewExpr(const CustomUnaryOp &) const, class CwiseUnaryOp
+  */
+template<typename ViewOp, typename MatrixType>
+class CwiseUnaryView : public CwiseUnaryViewImpl<ViewOp, MatrixType, typename internal::traits<MatrixType>::StorageKind>
+{
+  public:
+
+    typedef typename CwiseUnaryViewImpl<ViewOp, MatrixType,typename internal::traits<MatrixType>::StorageKind>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryView)
+    typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+    explicit EIGEN_DEVICE_FUNC inline CwiseUnaryView(MatrixType& mat, const ViewOp& func = ViewOp())
+      : m_matrix(mat), m_functor(func) {}
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryView)
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+    /** \returns the functor representing unary operation */
+    EIGEN_DEVICE_FUNC const ViewOp& functor() const { return m_functor; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC const typename internal::remove_all<MatrixTypeNested>::type&
+    nestedExpression() const { return m_matrix; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC typename internal::remove_reference<MatrixTypeNested>::type&
+    nestedExpression() { return m_matrix; }
+
+  protected:
+    MatrixTypeNested m_matrix;
+    ViewOp m_functor;
+};
+
+// Generic API dispatcher
+template<typename ViewOp, typename XprType, typename StorageKind>
+class CwiseUnaryViewImpl
+  : public internal::generic_xpr_base<CwiseUnaryView<ViewOp, XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<CwiseUnaryView<ViewOp, XprType> >::type Base;
+};
+
+template<typename ViewOp, typename MatrixType>
+class CwiseUnaryViewImpl<ViewOp,MatrixType,Dense>
+  : public internal::dense_xpr_base< CwiseUnaryView<ViewOp, MatrixType> >::type
+{
+  public:
+
+    typedef CwiseUnaryView<ViewOp, MatrixType> Derived;
+    typedef typename internal::dense_xpr_base< CwiseUnaryView<ViewOp, MatrixType> >::type Base;
+
+    EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryViewImpl)
+
+    EIGEN_DEVICE_FUNC inline Scalar* data() { return &(this->coeffRef(0)); }
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const { return &(this->coeff(0)); }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index innerStride() const
+    {
+      return derived().nestedExpression().innerStride() * sizeof(typename internal::traits<MatrixType>::Scalar) / sizeof(Scalar);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index outerStride() const
+    {
+      return derived().nestedExpression().outerStride() * sizeof(typename internal::traits<MatrixType>::Scalar) / sizeof(Scalar);
+    }
+  protected:
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(CwiseUnaryViewImpl)
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CWISE_UNARY_VIEW_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/DenseBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/DenseBase.h
new file mode 100644
index 00000000..9b16db68
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/DenseBase.h
@@ -0,0 +1,701 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DENSEBASE_H
+#define EIGEN_DENSEBASE_H
+
+namespace Eigen {
+
+namespace internal {
+
+// The index type defined by EIGEN_DEFAULT_DENSE_INDEX_TYPE must be a signed type.
+// This dummy function simply aims at checking that at compile time.
+static inline void check_DenseIndex_is_signed() {
+  EIGEN_STATIC_ASSERT(NumTraits<DenseIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE)
+}
+
+} // end namespace internal
+
+/** \class DenseBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for all dense matrices, vectors, and arrays
+  *
+  * This class is the base that is inherited by all dense objects (matrix, vector, arrays,
+  * and related expression types). The common Eigen API for dense objects is contained in this class.
+  *
+  * \tparam Derived is the derived type, e.g., a matrix type or an expression.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_DENSEBASE_PLUGIN.
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived> class DenseBase
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  : public DenseCoeffsBase<Derived, internal::accessors_level<Derived>::value>
+#else
+  : public DenseCoeffsBase<Derived,DirectWriteAccessors>
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+{
+  public:
+
+    /** Inner iterator type to iterate over the coefficients of a row or column.
+      * \sa class InnerIterator
+      */
+    typedef Eigen::InnerIterator<Derived> InnerIterator;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+
+    /**
+      * \brief The type used to store indices
+      * \details This typedef is relevant for types that store multiple indices such as
+      *          PermutationMatrix or Transpositions, otherwise it defaults to Eigen::Index
+      * \sa \blank \ref TopicPreprocessorDirectives, Eigen::Index, SparseMatrixBase.
+     */
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+
+    /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc. */
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+
+    /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.
+      *
+      * It is an alias for the Scalar type */
+    typedef Scalar value_type;
+
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef DenseCoeffsBase<Derived, internal::accessors_level<Derived>::value> Base;
+
+    using Base::derived;
+    using Base::const_cast_derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::rowIndexByOuterInner;
+    using Base::colIndexByOuterInner;
+    using Base::coeff;
+    using Base::coeffByOuterInner;
+    using Base::operator();
+    using Base::operator[];
+    using Base::x;
+    using Base::y;
+    using Base::z;
+    using Base::w;
+    using Base::stride;
+    using Base::innerStride;
+    using Base::outerStride;
+    using Base::rowStride;
+    using Base::colStride;
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+
+    enum {
+
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+        /**< The number of rows at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
+
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+        /**< The number of columns at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
+
+
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                   internal::traits<Derived>::ColsAtCompileTime>::ret),
+        /**< This is equal to the number of coefficients, i.e. the number of
+          * rows times the number of columns, or to \a Dynamic if this is not
+          * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
+
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+        /**< This value is equal to the maximum possible number of rows that this expression
+          * might have. If this expression might have an arbitrarily high number of rows,
+          * this value is set to \a Dynamic.
+          *
+          * This value is useful to know when evaluating an expression, in order to determine
+          * whether it is possible to avoid doing a dynamic memory allocation.
+          *
+          * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime
+          */
+
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+        /**< This value is equal to the maximum possible number of columns that this expression
+          * might have. If this expression might have an arbitrarily high number of columns,
+          * this value is set to \a Dynamic.
+          *
+          * This value is useful to know when evaluating an expression, in order to determine
+          * whether it is possible to avoid doing a dynamic memory allocation.
+          *
+          * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime
+          */
+
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
+                                                      internal::traits<Derived>::MaxColsAtCompileTime>::ret),
+        /**< This value is equal to the maximum possible number of coefficients that this expression
+          * might have. If this expression might have an arbitrarily high number of coefficients,
+          * this value is set to \a Dynamic.
+          *
+          * This value is useful to know when evaluating an expression, in order to determine
+          * whether it is possible to avoid doing a dynamic memory allocation.
+          *
+          * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime
+          */
+
+      IsVectorAtCompileTime = internal::traits<Derived>::RowsAtCompileTime == 1
+                           || internal::traits<Derived>::ColsAtCompileTime == 1,
+        /**< This is set to true if either the number of rows or the number of
+          * columns is known at compile-time to be equal to 1. Indeed, in that case,
+          * we are dealing with a column-vector (if there is only one column) or with
+          * a row-vector (if there is only one row). */
+
+      NumDimensions = int(MaxSizeAtCompileTime) == 1 ? 0 : bool(IsVectorAtCompileTime) ? 1 : 2,
+        /**< This value is equal to Tensor::NumDimensions, i.e. 0 for scalars, 1 for vectors,
+         * and 2 for matrices.
+         */
+
+      Flags = internal::traits<Derived>::Flags,
+        /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
+          * constructed from this one. See the \ref flags "list of flags".
+          */
+
+      IsRowMajor = int(Flags) & RowMajorBit, /**< True if this expression has row-major storage order. */
+
+      InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime)
+                             : int(IsRowMajor) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+
+      InnerStrideAtCompileTime = internal::inner_stride_at_compile_time<Derived>::ret,
+      OuterStrideAtCompileTime = internal::outer_stride_at_compile_time<Derived>::ret
+    };
+
+    typedef typename internal::find_best_packet<Scalar,SizeAtCompileTime>::type PacketScalar;
+
+    enum { IsPlainObjectBase = 0 };
+
+    /** The plain matrix type corresponding to this expression.
+      * \sa PlainObject */
+    typedef Matrix<typename internal::traits<Derived>::Scalar,
+                internal::traits<Derived>::RowsAtCompileTime,
+                internal::traits<Derived>::ColsAtCompileTime,
+                AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
+                internal::traits<Derived>::MaxRowsAtCompileTime,
+                internal::traits<Derived>::MaxColsAtCompileTime
+          > PlainMatrix;
+
+    /** The plain array type corresponding to this expression.
+      * \sa PlainObject */
+    typedef Array<typename internal::traits<Derived>::Scalar,
+                internal::traits<Derived>::RowsAtCompileTime,
+                internal::traits<Derived>::ColsAtCompileTime,
+                AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
+                internal::traits<Derived>::MaxRowsAtCompileTime,
+                internal::traits<Derived>::MaxColsAtCompileTime
+          > PlainArray;
+
+    /** \brief The plain matrix or array type corresponding to this expression.
+      *
+      * This is not necessarily exactly the return type of eval(). In the case of plain matrices,
+      * the return type of eval() is a const reference to a matrix, not a matrix! It is however guaranteed
+      * that the return type of eval() is either PlainObject or const PlainObject&.
+      */
+    typedef typename internal::conditional<internal::is_same<typename internal::traits<Derived>::XprKind,MatrixXpr >::value,
+                                 PlainMatrix, PlainArray>::type PlainObject;
+
+    /** \returns the number of nonzero coefficients which is in practice the number
+      * of stored coefficients. */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index nonZeros() const { return size(); }
+
+    /** \returns the outer size.
+      *
+      * \note For a vector, this returns just 1. For a matrix (non-vector), this is the major dimension
+      * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of columns for a
+      * column-major matrix, and the number of rows for a row-major matrix. */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index outerSize() const
+    {
+      return IsVectorAtCompileTime ? 1
+           : int(IsRowMajor) ? this->rows() : this->cols();
+    }
+
+    /** \returns the inner size.
+      *
+      * \note For a vector, this is just the size. For a matrix (non-vector), this is the minor dimension
+      * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of rows for a
+      * column-major matrix, and the number of columns for a row-major matrix. */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index innerSize() const
+    {
+      return IsVectorAtCompileTime ? this->size()
+           : int(IsRowMajor) ? this->cols() : this->rows();
+    }
+
+    /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
+      * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
+      * nothing else.
+      */
+    EIGEN_DEVICE_FUNC
+    void resize(Index newSize)
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(newSize);
+      eigen_assert(newSize == this->size()
+                && "DenseBase::resize() does not actually allow to resize.");
+    }
+    /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
+      * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
+      * nothing else.
+      */
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols)
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(rows);
+      EIGEN_ONLY_USED_FOR_DEBUG(cols);
+      eigen_assert(rows == this->rows() && cols == this->cols()
+                && "DenseBase::resize() does not actually allow to resize.");
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
+    /** \internal \deprecated Represents a vector with linearly spaced coefficients that allows sequential access only. */
+    EIGEN_DEPRECATED typedef CwiseNullaryOp<internal::linspaced_op<Scalar>,PlainObject> SequentialLinSpacedReturnType;
+    /** \internal Represents a vector with linearly spaced coefficients that allows random access. */
+    typedef CwiseNullaryOp<internal::linspaced_op<Scalar>,PlainObject> RandomAccessLinSpacedReturnType;
+    /** \internal the return type of MatrixBase::eigenvalues() */
+    typedef Matrix<typename NumTraits<typename internal::traits<Derived>::Scalar>::Real, internal::traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+    /** Copies \a other into *this. \returns a reference to *this. */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const DenseBase<OtherDerived>& other);
+
+    /** Special case of the template operator=, in order to prevent the compiler
+      * from generating a default operator= (issue hit with g++ 4.1)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const DenseBase& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const EigenBase<OtherDerived> &other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator+=(const EigenBase<OtherDerived> &other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator-=(const EigenBase<OtherDerived> &other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const ReturnByValue<OtherDerived>& func);
+
+    /** \internal
+      * Copies \a other into *this without evaluating other. \returns a reference to *this. */
+    template<typename OtherDerived>
+    /** \deprecated */
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
+    Derived& lazyAssign(const DenseBase<OtherDerived>& other);
+
+    EIGEN_DEVICE_FUNC
+    CommaInitializer<Derived> operator<< (const Scalar& s);
+
+    template<unsigned int Added,unsigned int Removed>
+    /** \deprecated it now returns \c *this */
+    EIGEN_DEPRECATED
+    const Derived& flagged() const
+    { return derived(); }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    CommaInitializer<Derived> operator<< (const DenseBase<OtherDerived>& other);
+
+    typedef Transpose<Derived> TransposeReturnType;
+    EIGEN_DEVICE_FUNC
+    TransposeReturnType transpose();
+    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
+    EIGEN_DEVICE_FUNC
+    ConstTransposeReturnType transpose() const;
+    EIGEN_DEVICE_FUNC
+    void transposeInPlace();
+
+    EIGEN_DEVICE_FUNC static const ConstantReturnType
+    Constant(Index rows, Index cols, const Scalar& value);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType
+    Constant(Index size, const Scalar& value);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType
+    Constant(const Scalar& value);
+
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
+    LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high);
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
+    LinSpaced(Sequential_t, const Scalar& low, const Scalar& high);
+
+    EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
+    LinSpaced(Index size, const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC static const RandomAccessLinSpacedReturnType
+    LinSpaced(const Scalar& low, const Scalar& high);
+
+    template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
+    static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+    NullaryExpr(Index rows, Index cols, const CustomNullaryOp& func);
+    template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
+    static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+    NullaryExpr(Index size, const CustomNullaryOp& func);
+    template<typename CustomNullaryOp> EIGEN_DEVICE_FUNC
+    static const CwiseNullaryOp<CustomNullaryOp, PlainObject>
+    NullaryExpr(const CustomNullaryOp& func);
+
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Zero(Index size);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Zero();
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Ones(Index size);
+    EIGEN_DEVICE_FUNC static const ConstantReturnType Ones();
+
+    EIGEN_DEVICE_FUNC void fill(const Scalar& value);
+    EIGEN_DEVICE_FUNC Derived& setConstant(const Scalar& value);
+    EIGEN_DEVICE_FUNC Derived& setLinSpaced(Index size, const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC Derived& setLinSpaced(const Scalar& low, const Scalar& high);
+    EIGEN_DEVICE_FUNC Derived& setZero();
+    EIGEN_DEVICE_FUNC Derived& setOnes();
+    EIGEN_DEVICE_FUNC Derived& setRandom();
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC
+    bool isApprox(const DenseBase<OtherDerived>& other,
+                  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC
+    bool isMuchSmallerThan(const RealScalar& other,
+                           const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC
+    bool isMuchSmallerThan(const DenseBase<OtherDerived>& other,
+                           const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    EIGEN_DEVICE_FUNC bool isApproxToConstant(const Scalar& value, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC bool isConstant(const Scalar& value, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC bool isZero(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC bool isOnes(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    inline bool hasNaN() const;
+    inline bool allFinite() const;
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator*=(const Scalar& other);
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator/=(const Scalar& other);
+
+    typedef typename internal::add_const_on_value_type<typename internal::eval<Derived>::type>::type EvalReturnType;
+    /** \returns the matrix or vector obtained by evaluating this expression.
+      *
+      * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
+      * a const reference, in order to avoid a useless copy.
+      *
+      * \warning Be careful with eval() and the auto C++ keyword, as detailed in this \link TopicPitfalls_auto_keyword page \endlink.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE EvalReturnType eval() const
+    {
+      // Even though MSVC does not honor strong inlining when the return type
+      // is a dynamic matrix, we desperately need strong inlining for fixed
+      // size types on MSVC.
+      return typename internal::eval<Derived>::type(derived());
+    }
+
+    /** swaps *this with the expression \a other.
+      *
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void swap(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT(!OtherDerived::IsPlainObjectBase,THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      eigen_assert(rows()==other.rows() && cols()==other.cols());
+      call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    /** swaps *this with the matrix or array \a other.
+      *
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void swap(PlainObjectBase<OtherDerived>& other)
+    {
+      eigen_assert(rows()==other.rows() && cols()==other.cols());
+      call_assignment(derived(), other.derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC inline const NestByValue<Derived> nestByValue() const;
+    EIGEN_DEVICE_FUNC inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
+    EIGEN_DEVICE_FUNC inline ForceAlignedAccess<Derived> forceAlignedAccess();
+    template<bool Enable> EIGEN_DEVICE_FUNC
+    inline const typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf() const;
+    template<bool Enable> EIGEN_DEVICE_FUNC
+    inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf();
+
+    EIGEN_DEVICE_FUNC Scalar sum() const;
+    EIGEN_DEVICE_FUNC Scalar mean() const;
+    EIGEN_DEVICE_FUNC Scalar trace() const;
+
+    EIGEN_DEVICE_FUNC Scalar prod() const;
+
+    template<int NaNPropagation>
+    EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff() const;
+    template<int NaNPropagation>
+    EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff() const;
+
+
+    // By default, the fastest version with undefined NaN propagation semantics is
+    // used.
+    // TODO(rmlarsen): Replace with default template argument when we move to
+    // c++11 or beyond.
+    EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar minCoeff() const {
+      return minCoeff<PropagateFast>();
+    }
+    EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar maxCoeff() const {
+      return maxCoeff<PropagateFast>();
+    }
+
+    template<int NaNPropagation, typename IndexType>
+    EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const;
+    template<int NaNPropagation, typename IndexType>
+    EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const;
+    template<int NaNPropagation, typename IndexType>
+    EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const;
+    template<int NaNPropagation, typename IndexType>
+    EIGEN_DEVICE_FUNC
+    typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const;
+
+    // TODO(rmlarsen): Replace these methods with a default template argument.
+    template<typename IndexType>
+    EIGEN_DEVICE_FUNC inline
+    typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const {
+      return minCoeff<PropagateFast>(row, col);
+    }
+    template<typename IndexType>
+    EIGEN_DEVICE_FUNC inline
+    typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const {
+      return maxCoeff<PropagateFast>(row, col);
+    }
+    template<typename IndexType>
+     EIGEN_DEVICE_FUNC inline
+    typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const {
+      return minCoeff<PropagateFast>(index);
+    }
+    template<typename IndexType>
+    EIGEN_DEVICE_FUNC inline
+    typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const {
+      return maxCoeff<PropagateFast>(index);
+    }
+  
+    template<typename BinaryOp>
+    EIGEN_DEVICE_FUNC
+    Scalar redux(const BinaryOp& func) const;
+
+    template<typename Visitor>
+    EIGEN_DEVICE_FUNC
+    void visit(Visitor& func) const;
+
+    /** \returns a WithFormat proxy object allowing to print a matrix the with given
+      * format \a fmt.
+      *
+      * See class IOFormat for some examples.
+      *
+      * \sa class IOFormat, class WithFormat
+      */
+    inline const WithFormat<Derived> format(const IOFormat& fmt) const
+    {
+      return WithFormat<Derived>(derived(), fmt);
+    }
+
+    /** \returns the unique coefficient of a 1x1 expression */
+    EIGEN_DEVICE_FUNC
+    CoeffReturnType value() const
+    {
+      EIGEN_STATIC_ASSERT_SIZE_1x1(Derived)
+      eigen_assert(this->rows() == 1 && this->cols() == 1);
+      return derived().coeff(0,0);
+    }
+
+    EIGEN_DEVICE_FUNC bool all() const;
+    EIGEN_DEVICE_FUNC bool any() const;
+    EIGEN_DEVICE_FUNC Index count() const;
+
+    typedef VectorwiseOp<Derived, Horizontal> RowwiseReturnType;
+    typedef const VectorwiseOp<const Derived, Horizontal> ConstRowwiseReturnType;
+    typedef VectorwiseOp<Derived, Vertical> ColwiseReturnType;
+    typedef const VectorwiseOp<const Derived, Vertical> ConstColwiseReturnType;
+
+    /** \returns a VectorwiseOp wrapper of *this for broadcasting and partial reductions
+    *
+    * Example: \include MatrixBase_rowwise.cpp
+    * Output: \verbinclude MatrixBase_rowwise.out
+    *
+    * \sa colwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+    */
+    //Code moved here due to a CUDA compiler bug
+    EIGEN_DEVICE_FUNC inline ConstRowwiseReturnType rowwise() const {
+      return ConstRowwiseReturnType(derived());
+    }
+    EIGEN_DEVICE_FUNC RowwiseReturnType rowwise();
+
+    /** \returns a VectorwiseOp wrapper of *this broadcasting and partial reductions
+    *
+    * Example: \include MatrixBase_colwise.cpp
+    * Output: \verbinclude MatrixBase_colwise.out
+    *
+    * \sa rowwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+    */
+    EIGEN_DEVICE_FUNC inline ConstColwiseReturnType colwise() const {
+      return ConstColwiseReturnType(derived());
+    }
+    EIGEN_DEVICE_FUNC ColwiseReturnType colwise();
+
+    typedef CwiseNullaryOp<internal::scalar_random_op<Scalar>,PlainObject> RandomReturnType;
+    static const RandomReturnType Random(Index rows, Index cols);
+    static const RandomReturnType Random(Index size);
+    static const RandomReturnType Random();
+
+    template<typename ThenDerived,typename ElseDerived>
+    inline EIGEN_DEVICE_FUNC const Select<Derived,ThenDerived,ElseDerived>
+    select(const DenseBase<ThenDerived>& thenMatrix,
+           const DenseBase<ElseDerived>& elseMatrix) const;
+
+    template<typename ThenDerived>
+    inline EIGEN_DEVICE_FUNC const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
+    select(const DenseBase<ThenDerived>& thenMatrix, const typename ThenDerived::Scalar& elseScalar) const;
+
+    template<typename ElseDerived>
+    inline EIGEN_DEVICE_FUNC const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
+    select(const typename ElseDerived::Scalar& thenScalar, const DenseBase<ElseDerived>& elseMatrix) const;
+
+    template<int p> RealScalar lpNorm() const;
+
+    template<int RowFactor, int ColFactor>
+    EIGEN_DEVICE_FUNC
+    const Replicate<Derived,RowFactor,ColFactor> replicate() const;
+    /**
+    * \return an expression of the replication of \c *this
+    *
+    * Example: \include MatrixBase_replicate_int_int.cpp
+    * Output: \verbinclude MatrixBase_replicate_int_int.out
+    *
+    * \sa VectorwiseOp::replicate(), DenseBase::replicate<int,int>(), class Replicate
+    */
+    //Code moved here due to a CUDA compiler bug
+    EIGEN_DEVICE_FUNC
+    const Replicate<Derived, Dynamic, Dynamic> replicate(Index rowFactor, Index colFactor) const
+    {
+      return Replicate<Derived, Dynamic, Dynamic>(derived(), rowFactor, colFactor);
+    }
+
+    typedef Reverse<Derived, BothDirections> ReverseReturnType;
+    typedef const Reverse<const Derived, BothDirections> ConstReverseReturnType;
+    EIGEN_DEVICE_FUNC ReverseReturnType reverse();
+    /** This is the const version of reverse(). */
+    //Code moved here due to a CUDA compiler bug
+    EIGEN_DEVICE_FUNC ConstReverseReturnType reverse() const
+    {
+      return ConstReverseReturnType(derived());
+    }
+    EIGEN_DEVICE_FUNC void reverseInPlace();
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** STL-like <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">RandomAccessIterator</a>
+      * iterator type as returned by the begin() and end() methods.
+      */
+    typedef random_access_iterator_type iterator;
+    /** This is the const version of iterator (aka read-only) */
+    typedef random_access_iterator_type const_iterator;
+    #else
+    typedef typename internal::conditional< (Flags&DirectAccessBit)==DirectAccessBit,
+                                            internal::pointer_based_stl_iterator<Derived>,
+                                            internal::generic_randaccess_stl_iterator<Derived>
+                                          >::type iterator_type;
+
+    typedef typename internal::conditional< (Flags&DirectAccessBit)==DirectAccessBit,
+                                            internal::pointer_based_stl_iterator<const Derived>,
+                                            internal::generic_randaccess_stl_iterator<const Derived>
+                                          >::type const_iterator_type;
+
+    // Stl-style iterators are supported only for vectors.
+
+    typedef typename internal::conditional< IsVectorAtCompileTime,
+                                            iterator_type,
+                                            void
+                                          >::type iterator;
+
+    typedef typename internal::conditional< IsVectorAtCompileTime,
+                                            const_iterator_type,
+                                            void
+                                          >::type const_iterator;
+    #endif
+
+    inline iterator begin();
+    inline const_iterator begin() const;
+    inline const_iterator cbegin() const;
+    inline iterator end();
+    inline const_iterator end() const;
+    inline const_iterator cend() const;
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::DenseBase
+#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND)
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#   include "../plugins/CommonCwiseUnaryOps.h"
+#   include "../plugins/BlockMethods.h"
+#   include "../plugins/IndexedViewMethods.h"
+#   include "../plugins/ReshapedMethods.h"
+#   ifdef EIGEN_DENSEBASE_PLUGIN
+#     include EIGEN_DENSEBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#undef EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF
+#undef EIGEN_DOC_UNARY_ADDONS
+
+    // disable the use of evalTo for dense objects with a nice compilation error
+    template<typename Dest>
+    EIGEN_DEVICE_FUNC
+    inline void evalTo(Dest& ) const
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<Dest,void>::value),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS);
+    }
+
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(DenseBase)
+    /** Default constructor. Do nothing. */
+    EIGEN_DEVICE_FUNC DenseBase()
+    {
+      /* Just checks for self-consistency of the flags.
+       * Only do it when debugging Eigen, as this borders on paranoia and could slow compilation down
+       */
+#ifdef EIGEN_INTERNAL_DEBUGGING
+      EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor))
+                        && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))),
+                          INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION)
+#endif
+    }
+
+  private:
+    EIGEN_DEVICE_FUNC explicit DenseBase(int);
+    EIGEN_DEVICE_FUNC DenseBase(int,int);
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit DenseBase(const DenseBase<OtherDerived>&);
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_DENSEBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/DenseCoeffsBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/DenseCoeffsBase.h
new file mode 100644
index 00000000..37fcdb59
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/DenseCoeffsBase.h
@@ -0,0 +1,685 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DENSECOEFFSBASE_H
+#define EIGEN_DENSECOEFFSBASE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename T> struct add_const_on_value_type_if_arithmetic
+{
+  typedef typename conditional<is_arithmetic<T>::value, T, typename add_const_on_value_type<T>::type>::type type;
+};
+}
+
+/** \brief Base class providing read-only coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  *
+  * \note #ReadOnlyAccessors Constant indicating read-only access
+  *
+  * This class defines the \c operator() \c const function and friends, which can be used to read specific
+  * entries of a matrix or array.
+  *
+  * \sa DenseCoeffsBase<Derived, WriteAccessors>, DenseCoeffsBase<Derived, DirectAccessors>,
+  *     \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
+{
+  public:
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+
+    // Explanation for this CoeffReturnType typedef.
+    // - This is the return type of the coeff() method.
+    // - The LvalueBit means exactly that we can offer a coeffRef() method, which means exactly that we can get references
+    // to coeffs, which means exactly that we can have coeff() return a const reference (as opposed to returning a value).
+    // - The is_artihmetic check is required since "const int", "const double", etc. will cause warnings on some systems
+    // while the declaration of "const T", where T is a non arithmetic type does not. Always returning "const Scalar&" is
+    // not possible, since the underlying expressions might not offer a valid address the reference could be referring to.
+    typedef typename internal::conditional<bool(internal::traits<Derived>::Flags&LvalueBit),
+                         const Scalar&,
+                         typename internal::conditional<internal::is_arithmetic<Scalar>::value, Scalar, const Scalar>::type
+                     >::type CoeffReturnType;
+
+    typedef typename internal::add_const_on_value_type_if_arithmetic<
+                         typename internal::packet_traits<Scalar>::type
+                     >::type PacketReturnType;
+
+    typedef EigenBase<Derived> Base;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner) const
+    {
+      return int(Derived::RowsAtCompileTime) == 1 ? 0
+          : int(Derived::ColsAtCompileTime) == 1 ? inner
+          : int(Derived::Flags)&RowMajorBit ? outer
+          : inner;
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner) const
+    {
+      return int(Derived::ColsAtCompileTime) == 1 ? 0
+          : int(Derived::RowsAtCompileTime) == 1 ? inner
+          : int(Derived::Flags)&RowMajorBit ? inner
+          : outer;
+    }
+
+    /** Short version: don't use this function, use
+      * \link operator()(Index,Index) const \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator()(Index,Index) const \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameters \a row and \a col are in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator()(Index,Index) const \endlink.
+      *
+      * \sa operator()(Index,Index) const, coeffRef(Index,Index), coeff(Index) const
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
+    {
+      eigen_internal_assert(row >= 0 && row < rows()
+                         && col >= 0 && col < cols());
+      return internal::evaluator<Derived>(derived()).coeff(row,col);
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType coeffByOuterInner(Index outer, Index inner) const
+    {
+      return coeff(rowIndexByOuterInner(outer, inner),
+                   colIndexByOuterInner(outer, inner));
+    }
+
+    /** \returns the coefficient at given the given row and column.
+      *
+      * \sa operator()(Index,Index), operator[](Index)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType operator()(Index row, Index col) const
+    {
+      eigen_assert(row >= 0 && row < rows()
+          && col >= 0 && col < cols());
+      return coeff(row, col);
+    }
+
+    /** Short version: don't use this function, use
+      * \link operator[](Index) const \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator[](Index) const \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameter \a index is in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator[](Index) const \endlink.
+      *
+      * \sa operator[](Index) const, coeffRef(Index), coeff(Index,Index) const
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    coeff(Index index) const
+    {
+      EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
+                          THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
+      eigen_internal_assert(index >= 0 && index < size());
+      return internal::evaluator<Derived>(derived()).coeff(index);
+    }
+
+
+    /** \returns the coefficient at given index.
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const,
+      * z() const, w() const
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    operator[](Index index) const
+    {
+      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
+                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
+      eigen_assert(index >= 0 && index < size());
+      return coeff(index);
+    }
+
+    /** \returns the coefficient at given index.
+      *
+      * This is synonymous to operator[](Index) const.
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const,
+      * z() const, w() const
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    operator()(Index index) const
+    {
+      eigen_assert(index >= 0 && index < size());
+      return coeff(index);
+    }
+
+    /** equivalent to operator[](0).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    x() const { return (*this)[0]; }
+
+    /** equivalent to operator[](1).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    y() const
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=2, OUT_OF_RANGE_ACCESS);
+      return (*this)[1];
+    }
+
+    /** equivalent to operator[](2).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    z() const
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=3, OUT_OF_RANGE_ACCESS);
+      return (*this)[2];
+    }
+
+    /** equivalent to operator[](3).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE CoeffReturnType
+    w() const
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS);
+      return (*this)[3];
+    }
+
+    /** \internal
+      * \returns the packet of coefficients starting at the given row and column. It is your responsibility
+      * to ensure that a packet really starts there. This method is only available on expressions having the
+      * PacketAccessBit.
+      *
+      * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select
+      * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
+      * starting at an address which is a multiple of the packet size.
+      */
+
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketReturnType packet(Index row, Index col) const
+    {
+      typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
+      eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols());
+      return internal::evaluator<Derived>(derived()).template packet<LoadMode,DefaultPacketType>(row,col);
+    }
+
+
+    /** \internal */
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketReturnType packetByOuterInner(Index outer, Index inner) const
+    {
+      return packet<LoadMode>(rowIndexByOuterInner(outer, inner),
+                              colIndexByOuterInner(outer, inner));
+    }
+
+    /** \internal
+      * \returns the packet of coefficients starting at the given index. It is your responsibility
+      * to ensure that a packet really starts there. This method is only available on expressions having the
+      * PacketAccessBit and the LinearAccessBit.
+      *
+      * The \a LoadMode parameter may have the value \a #Aligned or \a #Unaligned. Its effect is to select
+      * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
+      * starting at an address which is a multiple of the packet size.
+      */
+
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
+    {
+      EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
+                          THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
+      typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
+      eigen_internal_assert(index >= 0 && index < size());
+      return internal::evaluator<Derived>(derived()).template packet<LoadMode,DefaultPacketType>(index);
+    }
+
+  protected:
+    // explanation: DenseBase is doing "using ..." on the methods from DenseCoeffsBase.
+    // But some methods are only available in the DirectAccess case.
+    // So we add dummy methods here with these names, so that "using... " doesn't fail.
+    // It's not private so that the child class DenseBase can access them, and it's not public
+    // either since it's an implementation detail, so has to be protected.
+    void coeffRef();
+    void coeffRefByOuterInner();
+    void writePacket();
+    void writePacketByOuterInner();
+    void copyCoeff();
+    void copyCoeffByOuterInner();
+    void copyPacket();
+    void copyPacketByOuterInner();
+    void stride();
+    void innerStride();
+    void outerStride();
+    void rowStride();
+    void colStride();
+};
+
+/** \brief Base class providing read/write coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  *
+  * \note #WriteAccessors Constant indicating read/write access
+  *
+  * This class defines the non-const \c operator() function and friends, which can be used to write specific
+  * entries of a matrix or array. This class inherits DenseCoeffsBase<Derived, ReadOnlyAccessors> which
+  * defines the const variant for reading specific entries.
+  *
+  * \sa DenseCoeffsBase<Derived, DirectAccessors>, \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
+{
+  public:
+
+    typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    using Base::coeff;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+    using Base::rowIndexByOuterInner;
+    using Base::colIndexByOuterInner;
+    using Base::operator[];
+    using Base::operator();
+    using Base::x;
+    using Base::y;
+    using Base::z;
+    using Base::w;
+
+    /** Short version: don't use this function, use
+      * \link operator()(Index,Index) \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator()(Index,Index) \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameters \a row and \a col are in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator()(Index,Index) \endlink.
+      *
+      * \sa operator()(Index,Index), coeff(Index, Index) const, coeffRef(Index)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
+    {
+      eigen_internal_assert(row >= 0 && row < rows()
+                         && col >= 0 && col < cols());
+      return internal::evaluator<Derived>(derived()).coeffRef(row,col);
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    coeffRefByOuterInner(Index outer, Index inner)
+    {
+      return coeffRef(rowIndexByOuterInner(outer, inner),
+                      colIndexByOuterInner(outer, inner));
+    }
+
+    /** \returns a reference to the coefficient at given the given row and column.
+      *
+      * \sa operator[](Index)
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    operator()(Index row, Index col)
+    {
+      eigen_assert(row >= 0 && row < rows()
+          && col >= 0 && col < cols());
+      return coeffRef(row, col);
+    }
+
+
+    /** Short version: don't use this function, use
+      * \link operator[](Index) \endlink instead.
+      *
+      * Long version: this function is similar to
+      * \link operator[](Index) \endlink, but without the assertion.
+      * Use this for limiting the performance cost of debugging code when doing
+      * repeated coefficient access. Only use this when it is guaranteed that the
+      * parameters \a row and \a col are in range.
+      *
+      * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
+      * function equivalent to \link operator[](Index) \endlink.
+      *
+      * \sa operator[](Index), coeff(Index) const, coeffRef(Index,Index)
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    coeffRef(Index index)
+    {
+      EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
+                          THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
+      eigen_internal_assert(index >= 0 && index < size());
+      return internal::evaluator<Derived>(derived()).coeffRef(index);
+    }
+
+    /** \returns a reference to the coefficient at given index.
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    operator[](Index index)
+    {
+      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
+                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
+      eigen_assert(index >= 0 && index < size());
+      return coeffRef(index);
+    }
+
+    /** \returns a reference to the coefficient at given index.
+      *
+      * This is synonymous to operator[](Index).
+      *
+      * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+      *
+      * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
+      */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    operator()(Index index)
+    {
+      eigen_assert(index >= 0 && index < size());
+      return coeffRef(index);
+    }
+
+    /** equivalent to operator[](0).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    x() { return (*this)[0]; }
+
+    /** equivalent to operator[](1).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    y()
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=2, OUT_OF_RANGE_ACCESS);
+      return (*this)[1];
+    }
+
+    /** equivalent to operator[](2).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    z()
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=3, OUT_OF_RANGE_ACCESS);
+      return (*this)[2];
+    }
+
+    /** equivalent to operator[](3).  */
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar&
+    w()
+    {
+      EIGEN_STATIC_ASSERT(Derived::SizeAtCompileTime==-1 || Derived::SizeAtCompileTime>=4, OUT_OF_RANGE_ACCESS);
+      return (*this)[3];
+    }
+};
+
+/** \brief Base class providing direct read-only coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  *
+  * \note #DirectAccessors Constant indicating direct access
+  *
+  * This class defines functions to work with strides which can be used to access entries directly. This class
+  * inherits DenseCoeffsBase<Derived, ReadOnlyAccessors> which defines functions to access entries read-only using
+  * \c operator() .
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors>
+{
+  public:
+
+    typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+
+    /** \returns the pointer increment between two consecutive elements within a slice in the inner direction.
+      *
+      * \sa outerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const
+    {
+      return derived().innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns
+      *          in a column-major matrix).
+      *
+      * \sa innerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const
+    {
+      return derived().outerStride();
+    }
+
+    // FIXME shall we remove it ?
+    EIGEN_CONSTEXPR inline Index stride() const
+    {
+      return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive rows.
+      *
+      * \sa innerStride(), outerStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rowStride() const
+    {
+      return Derived::IsRowMajor ? outerStride() : innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive columns.
+      *
+      * \sa innerStride(), outerStride(), rowStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index colStride() const
+    {
+      return Derived::IsRowMajor ? innerStride() : outerStride();
+    }
+};
+
+/** \brief Base class providing direct read/write coefficient access to matrices and arrays.
+  * \ingroup Core_Module
+  * \tparam Derived Type of the derived class
+  *
+  * \note #DirectWriteAccessors Constant indicating direct access
+  *
+  * This class defines functions to work with strides which can be used to access entries directly. This class
+  * inherits DenseCoeffsBase<Derived, WriteAccessors> which defines functions to access entries read/write using
+  * \c operator().
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class DenseCoeffsBase<Derived, DirectWriteAccessors>
+  : public DenseCoeffsBase<Derived, WriteAccessors>
+{
+  public:
+
+    typedef DenseCoeffsBase<Derived, WriteAccessors> Base;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::derived;
+
+    /** \returns the pointer increment between two consecutive elements within a slice in the inner direction.
+      *
+      * \sa outerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT
+    {
+      return derived().innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns
+      *          in a column-major matrix).
+      *
+      * \sa innerStride(), rowStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT
+    {
+      return derived().outerStride();
+    }
+
+    // FIXME shall we remove it ?
+    EIGEN_CONSTEXPR inline Index stride() const EIGEN_NOEXCEPT
+    {
+      return Derived::IsVectorAtCompileTime ? innerStride() : outerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive rows.
+      *
+      * \sa innerStride(), outerStride(), colStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rowStride() const EIGEN_NOEXCEPT
+    {
+      return Derived::IsRowMajor ? outerStride() : innerStride();
+    }
+
+    /** \returns the pointer increment between two consecutive columns.
+      *
+      * \sa innerStride(), outerStride(), rowStride()
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index colStride() const EIGEN_NOEXCEPT
+    {
+      return Derived::IsRowMajor ? innerStride() : outerStride();
+    }
+};
+
+namespace internal {
+
+template<int Alignment, typename Derived, bool JustReturnZero>
+struct first_aligned_impl
+{
+  static EIGEN_CONSTEXPR inline Index run(const Derived&) EIGEN_NOEXCEPT
+  { return 0; }
+};
+
+template<int Alignment, typename Derived>
+struct first_aligned_impl<Alignment, Derived, false>
+{
+  static inline Index run(const Derived& m)
+  {
+    return internal::first_aligned<Alignment>(m.data(), m.size());
+  }
+};
+
+/** \internal \returns the index of the first element of the array stored by \a m that is properly aligned with respect to \a Alignment for vectorization.
+  *
+  * \tparam Alignment requested alignment in Bytes.
+  *
+  * There is also the variant first_aligned(const Scalar*, Integer) defined in Memory.h. See it for more
+  * documentation.
+  */
+template<int Alignment, typename Derived>
+static inline Index first_aligned(const DenseBase<Derived>& m)
+{
+  enum { ReturnZero = (int(evaluator<Derived>::Alignment) >= Alignment) || !(Derived::Flags & DirectAccessBit) };
+  return first_aligned_impl<Alignment, Derived, ReturnZero>::run(m.derived());
+}
+
+template<typename Derived>
+static inline Index first_default_aligned(const DenseBase<Derived>& m)
+{
+  typedef typename Derived::Scalar Scalar;
+  typedef typename packet_traits<Scalar>::type DefaultPacketType;
+  return internal::first_aligned<int(unpacket_traits<DefaultPacketType>::alignment),Derived>(m);
+}
+
+template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
+struct inner_stride_at_compile_time
+{
+  enum { ret = traits<Derived>::InnerStrideAtCompileTime };
+};
+
+template<typename Derived>
+struct inner_stride_at_compile_time<Derived, false>
+{
+  enum { ret = 0 };
+};
+
+template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
+struct outer_stride_at_compile_time
+{
+  enum { ret = traits<Derived>::OuterStrideAtCompileTime };
+};
+
+template<typename Derived>
+struct outer_stride_at_compile_time<Derived, false>
+{
+  enum { ret = 0 };
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_DENSECOEFFSBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/DenseStorage.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/DenseStorage.h
new file mode 100644
index 00000000..08ef6c53
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/DenseStorage.h
@@ -0,0 +1,652 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2010-2013 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIXSTORAGE_H
+#define EIGEN_MATRIXSTORAGE_H
+
+#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+  #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X) X; EIGEN_DENSE_STORAGE_CTOR_PLUGIN;
+#else
+  #define EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(X)
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+struct constructor_without_unaligned_array_assert {};
+
+template<typename T, int Size>
+EIGEN_DEVICE_FUNC
+void check_static_allocation_size()
+{
+  // if EIGEN_STACK_ALLOCATION_LIMIT is defined to 0, then no limit
+  #if EIGEN_STACK_ALLOCATION_LIMIT
+  EIGEN_STATIC_ASSERT(Size * sizeof(T) <= EIGEN_STACK_ALLOCATION_LIMIT, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG);
+  #endif
+}
+
+/** \internal
+  * Static array. If the MatrixOrArrayOptions require auto-alignment, the array will be automatically aligned:
+  * to 16 bytes boundary if the total size is a multiple of 16 bytes.
+  */
+template <typename T, int Size, int MatrixOrArrayOptions,
+          int Alignment = (MatrixOrArrayOptions&DontAlign) ? 0
+                        : compute_default_alignment<T,Size>::value >
+struct plain_array
+{
+  T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  {
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  {
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+#if defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT)
+  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask)
+#elif EIGEN_GNUC_AT_LEAST(4,7)
+  // GCC 4.7 is too aggressive in its optimizations and remove the alignment test based on the fact the array is declared to be aligned.
+  // See this bug report: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53900
+  // Hiding the origin of the array pointer behind a function argument seems to do the trick even if the function is inlined:
+  template<typename PtrType>
+  EIGEN_ALWAYS_INLINE PtrType eigen_unaligned_array_assert_workaround_gcc47(PtrType array) { return array; }
+  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \
+    eigen_assert((internal::UIntPtr(eigen_unaligned_array_assert_workaround_gcc47(array)) & (sizemask)) == 0 \
+              && "this assertion is explained here: " \
+              "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \
+              " **** READ THIS WEB PAGE !!! ****");
+#else
+  #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \
+    eigen_assert((internal::UIntPtr(array) & (sizemask)) == 0 \
+              && "this assertion is explained here: " \
+              "http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html" \
+              " **** READ THIS WEB PAGE !!! ****");
+#endif
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 8>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(8) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  {
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(7);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  {
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 16>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(16) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  {
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(15);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  {
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 32>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(32) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  {
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(31);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  {
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int Size, int MatrixOrArrayOptions>
+struct plain_array<T, Size, MatrixOrArrayOptions, 64>
+{
+  EIGEN_ALIGN_TO_BOUNDARY(64) T array[Size];
+
+  EIGEN_DEVICE_FUNC
+  plain_array()
+  {
+    EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(63);
+    check_static_allocation_size<T,Size>();
+  }
+
+  EIGEN_DEVICE_FUNC
+  plain_array(constructor_without_unaligned_array_assert)
+  {
+    check_static_allocation_size<T,Size>();
+  }
+};
+
+template <typename T, int MatrixOrArrayOptions, int Alignment>
+struct plain_array<T, 0, MatrixOrArrayOptions, Alignment>
+{
+  T array[1];
+  EIGEN_DEVICE_FUNC plain_array() {}
+  EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert) {}
+};
+
+struct plain_array_helper {
+  template<typename T, int Size, int MatrixOrArrayOptions, int Alignment>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  static void copy(const plain_array<T, Size, MatrixOrArrayOptions, Alignment>& src, const Eigen::Index size,
+                         plain_array<T, Size, MatrixOrArrayOptions, Alignment>& dst) {
+    smart_copy(src.array, src.array + size, dst.array);
+  }
+  
+  template<typename T, int Size, int MatrixOrArrayOptions, int Alignment>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  static void swap(plain_array<T, Size, MatrixOrArrayOptions, Alignment>& a, const Eigen::Index a_size,
+                   plain_array<T, Size, MatrixOrArrayOptions, Alignment>& b, const Eigen::Index b_size) {
+    if (a_size < b_size) {
+      std::swap_ranges(b.array, b.array + a_size, a.array);
+      smart_move(b.array + a_size, b.array + b_size, a.array + a_size);
+    } else if (a_size > b_size) {
+      std::swap_ranges(a.array, a.array + b_size, b.array);
+      smart_move(a.array + b_size, a.array + a_size, b.array + b_size);
+    } else {
+      std::swap_ranges(a.array, a.array + a_size, b.array);
+    }
+  }
+};
+
+} // end namespace internal
+
+/** \internal
+  *
+  * \class DenseStorage
+  * \ingroup Core_Module
+  *
+  * \brief Stores the data of a matrix
+  *
+  * This class stores the data of fixed-size, dynamic-size or mixed matrices
+  * in a way as compact as possible.
+  *
+  * \sa Matrix
+  */
+template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage;
+
+// purely fixed-size matrix
+template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage
+{
+    internal::plain_array<T,Size,_Options> m_data;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size)
+    }
+    EIGEN_DEVICE_FUNC
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()) {}
+#if !EIGEN_HAS_CXX11 || defined(EIGEN_DENSE_STORAGE_CTOR_PLUGIN)
+    EIGEN_DEVICE_FUNC
+    DenseStorage(const DenseStorage& other) : m_data(other.m_data) {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = Size)
+    }
+#else
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) = default;
+#endif
+#if !EIGEN_HAS_CXX11
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other) m_data = other.m_data;
+      return *this;
+    }
+#else
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage&) = default;
+#endif
+#if EIGEN_HAS_RVALUE_REFERENCES
+#if !EIGEN_HAS_CXX11
+    EIGEN_DEVICE_FUNC DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+    {
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      if (this != &other)
+        m_data = std::move(other.m_data);
+      return *this;
+    }
+#else
+    EIGEN_DEVICE_FUNC DenseStorage(DenseStorage&&) = default;
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(DenseStorage&&) = default;
+#endif
+#endif
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows==_Rows && cols==_Cols);
+      EIGEN_UNUSED_VARIABLE(size);
+      EIGEN_UNUSED_VARIABLE(rows);
+      EIGEN_UNUSED_VARIABLE(cols);
+    }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) {
+      numext::swap(m_data, other.m_data);
+    }
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index rows(void) EIGEN_NOEXCEPT {return _Rows;}
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index cols(void) EIGEN_NOEXCEPT {return _Cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// null matrix
+template<typename T, int _Rows, int _Cols, int _Options> class DenseStorage<T, 0, _Rows, _Cols, _Options>
+{
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) {}
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage&) { return *this; }
+    EIGEN_DEVICE_FUNC DenseStorage(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& ) {}
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index rows(void) EIGEN_NOEXCEPT {return _Rows;}
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index cols(void) EIGEN_NOEXCEPT {return _Cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
+    EIGEN_DEVICE_FUNC const T *data() const { return 0; }
+    EIGEN_DEVICE_FUNC T *data() { return 0; }
+};
+
+// more specializations for null matrices; these are necessary to resolve ambiguities
+template<typename T, int _Options> class DenseStorage<T, 0, Dynamic, Dynamic, _Options>
+: public DenseStorage<T, 0, 0, 0, _Options> { };
+
+template<typename T, int _Rows, int _Options> class DenseStorage<T, 0, _Rows, Dynamic, _Options>
+: public DenseStorage<T, 0, 0, 0, _Options> { };
+
+template<typename T, int _Cols, int _Options> class DenseStorage<T, 0, Dynamic, _Cols, _Options>
+: public DenseStorage<T, 0, 0, 0, _Options> { };
+
+// dynamic-size matrix with fixed-size storage
+template<typename T, int Size, int _Options> class DenseStorage<T, Size, Dynamic, Dynamic, _Options>
+{
+    internal::plain_array<T,Size,_Options> m_data;
+    Index m_rows;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(other.m_rows), m_cols(other.m_cols)
+    {
+      internal::plain_array_helper::copy(other.m_data, m_rows * m_cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        m_rows = other.m_rows;
+        m_cols = other.m_cols;
+        internal::plain_array_helper::copy(other.m_data, m_rows * m_cols, m_data);
+      }
+      return *this;
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(rows), m_cols(cols) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other)
+    {
+      internal::plain_array_helper::swap(m_data, m_rows * m_cols, other.m_data, other.m_rows * other.m_cols);
+      numext::swap(m_rows,other.m_rows);
+      numext::swap(m_cols,other.m_cols);
+    }
+    EIGEN_DEVICE_FUNC Index rows() const {return m_rows;}
+    EIGEN_DEVICE_FUNC Index cols() const {return m_cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; }
+    EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols) { m_rows = rows; m_cols = cols; }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// dynamic-size matrix with fixed-size storage and fixed width
+template<typename T, int Size, int _Cols, int _Options> class DenseStorage<T, Size, Dynamic, _Cols, _Options>
+{
+    internal::plain_array<T,Size,_Options> m_data;
+    Index m_rows;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(other.m_rows)
+    {
+      internal::plain_array_helper::copy(other.m_data, m_rows * _Cols, m_data);
+    }
+    
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        m_rows = other.m_rows;
+        internal::plain_array_helper::copy(other.m_data, m_rows * _Cols, m_data);
+      }
+      return *this;
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other)
+    { 
+      internal::plain_array_helper::swap(m_data, m_rows * _Cols, other.m_data, other.m_rows * _Cols);
+      numext::swap(m_rows, other.m_rows);
+    }
+    EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT {return m_rows;}
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols(void) const EIGEN_NOEXCEPT {return _Cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index) { m_rows = rows; }
+    EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index) { m_rows = rows; }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// dynamic-size matrix with fixed-size storage and fixed height
+template<typename T, int Size, int _Rows, int _Options> class DenseStorage<T, Size, _Rows, Dynamic, _Options>
+{
+    internal::plain_array<T,Size,_Options> m_data;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_cols(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) 
+      : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(other.m_cols)
+    {
+      internal::plain_array_helper::copy(other.m_data, _Rows * m_cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        m_cols = other.m_cols;
+        internal::plain_array_helper::copy(other.m_data, _Rows * m_cols, m_data);
+      }
+      return *this;
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {}
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) {
+      internal::plain_array_helper::swap(m_data, _Rows * m_cols, other.m_data, _Rows * other.m_cols);
+      numext::swap(m_cols, other.m_cols);
+    }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows(void) const EIGEN_NOEXCEPT {return _Rows;}
+    EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT {return m_cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index, Index, Index cols) { m_cols = cols; }
+    EIGEN_DEVICE_FUNC void resize(Index, Index, Index cols) { m_cols = cols; }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
+};
+
+// purely dynamic matrix.
+template<typename T, int _Options> class DenseStorage<T, Dynamic, Dynamic, Dynamic, _Options>
+{
+    T *m_data;
+    Index m_rows;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
+       : m_data(0), m_rows(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_rows(rows), m_cols(cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows>=0 && cols >=0);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(other.m_rows*other.m_cols))
+      , m_rows(other.m_rows)
+      , m_cols(other.m_cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_rows*m_cols)
+      internal::smart_copy(other.m_data, other.m_data+other.m_rows*other.m_cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        DenseStorage tmp(other);
+        this->swap(tmp);
+      }
+      return *this;
+    }
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+      , m_rows(std::move(other.m_rows))
+      , m_cols(std::move(other.m_cols))
+    {
+      other.m_data = nullptr;
+      other.m_rows = 0;
+      other.m_cols = 0;
+    }
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      numext::swap(m_data, other.m_data);
+      numext::swap(m_rows, other.m_rows);
+      numext::swap(m_cols, other.m_cols);
+      return *this;
+    }
+#endif
+    EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols); }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other)
+    {
+      numext::swap(m_data,other.m_data);
+      numext::swap(m_rows,other.m_rows);
+      numext::swap(m_cols,other.m_cols);
+    }
+    EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT {return m_rows;}
+    EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT {return m_cols;}
+    void conservativeResize(Index size, Index rows, Index cols)
+    {
+      m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, m_rows*m_cols);
+      m_rows = rows;
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
+    {
+      if(size != m_rows*m_cols)
+      {
+        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
+        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
+          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
+        else
+          m_data = 0;
+        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      }
+      m_rows = rows;
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data; }
+};
+
+// matrix with dynamic width and fixed height (so that matrix has dynamic size).
+template<typename T, int _Rows, int _Options> class DenseStorage<T, Dynamic, _Rows, Dynamic, _Options>
+{
+    T *m_data;
+    Index m_cols;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_cols(0) {}
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_cols(cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows==_Rows && cols >=0);
+      EIGEN_UNUSED_VARIABLE(rows);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(_Rows*other.m_cols))
+      , m_cols(other.m_cols)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_cols*_Rows)
+      internal::smart_copy(other.m_data, other.m_data+_Rows*m_cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        DenseStorage tmp(other);
+        this->swap(tmp);
+      }
+      return *this;
+    }
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+      , m_cols(std::move(other.m_cols))
+    {
+      other.m_data = nullptr;
+      other.m_cols = 0;
+    }
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      numext::swap(m_data, other.m_data);
+      numext::swap(m_cols, other.m_cols);
+      return *this;
+    }
+#endif
+    EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols); }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) {
+      numext::swap(m_data,other.m_data);
+      numext::swap(m_cols,other.m_cols);
+    }
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index rows(void) EIGEN_NOEXCEPT {return _Rows;}
+    EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT {return m_cols;}
+    EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols)
+    {
+      m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, _Rows*m_cols);
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols)
+    {
+      if(size != _Rows*m_cols)
+      {
+        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols);
+        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
+          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
+        else
+          m_data = 0;
+        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      }
+      m_cols = cols;
+    }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data; }
+};
+
+// matrix with dynamic height and fixed width (so that matrix has dynamic size).
+template<typename T, int _Cols, int _Options> class DenseStorage<T, Dynamic, Dynamic, _Cols, _Options>
+{
+    T *m_data;
+    Index m_rows;
+  public:
+    EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0) {}
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {}
+    EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_rows(rows)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      eigen_internal_assert(size==rows*cols && rows>=0 && cols == _Cols);
+      EIGEN_UNUSED_VARIABLE(cols);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
+      : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(other.m_rows*_Cols))
+      , m_rows(other.m_rows)
+    {
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN(Index size = m_rows*_Cols)
+      internal::smart_copy(other.m_data, other.m_data+other.m_rows*_Cols, m_data);
+    }
+    EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage& other)
+    {
+      if (this != &other)
+      {
+        DenseStorage tmp(other);
+        this->swap(tmp);
+      }
+      return *this;
+    }
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
+      : m_data(std::move(other.m_data))
+      , m_rows(std::move(other.m_rows))
+    {
+      other.m_data = nullptr;
+      other.m_rows = 0;
+    }
+    EIGEN_DEVICE_FUNC
+    DenseStorage& operator=(DenseStorage&& other) EIGEN_NOEXCEPT
+    {
+      numext::swap(m_data, other.m_data);
+      numext::swap(m_rows, other.m_rows);
+      return *this;
+    }
+#endif
+    EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows); }
+    EIGEN_DEVICE_FUNC void swap(DenseStorage& other) {
+      numext::swap(m_data,other.m_data);
+      numext::swap(m_rows,other.m_rows);
+    }
+    EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT {return m_rows;}
+    EIGEN_DEVICE_FUNC static EIGEN_CONSTEXPR Index cols(void) {return _Cols;}
+    void conservativeResize(Index size, Index rows, Index)
+    {
+      m_data = internal::conditional_aligned_realloc_new_auto<T,(_Options&DontAlign)==0>(m_data, size, m_rows*_Cols);
+      m_rows = rows;
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index)
+    {
+      if(size != m_rows*_Cols)
+      {
+        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows);
+        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
+          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
+        else
+          m_data = 0;
+        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+      }
+      m_rows = rows;
+    }
+    EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
+    EIGEN_DEVICE_FUNC T *data() { return m_data; }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Diagonal.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Diagonal.h
new file mode 100644
index 00000000..3112d2c1
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Diagonal.h
@@ -0,0 +1,258 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DIAGONAL_H
+#define EIGEN_DIAGONAL_H
+
+namespace Eigen {
+
+/** \class Diagonal
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a diagonal/subdiagonal/superdiagonal in a matrix
+  *
+  * \param MatrixType the type of the object in which we are taking a sub/main/super diagonal
+  * \param DiagIndex the index of the sub/super diagonal. The default is 0 and it means the main diagonal.
+  *              A positive value means a superdiagonal, a negative value means a subdiagonal.
+  *              You can also use DynamicIndex so the index can be set at runtime.
+  *
+  * The matrix is not required to be square.
+  *
+  * This class represents an expression of the main diagonal, or any sub/super diagonal
+  * of a square matrix. It is the return type of MatrixBase::diagonal() and MatrixBase::diagonal(Index) and most of the
+  * time this is the only way it is used.
+  *
+  * \sa MatrixBase::diagonal(), MatrixBase::diagonal(Index)
+  */
+
+namespace internal {
+template<typename MatrixType, int DiagIndex>
+struct traits<Diagonal<MatrixType,DiagIndex> >
+ : traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  typedef typename MatrixType::StorageKind StorageKind;
+  enum {
+    RowsAtCompileTime = (int(DiagIndex) == DynamicIndex || int(MatrixType::SizeAtCompileTime) == Dynamic) ? Dynamic
+                      : (EIGEN_PLAIN_ENUM_MIN(MatrixType::RowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0),
+                                              MatrixType::ColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))),
+    ColsAtCompileTime = 1,
+    MaxRowsAtCompileTime = int(MatrixType::MaxSizeAtCompileTime) == Dynamic ? Dynamic
+                         : DiagIndex == DynamicIndex ? EIGEN_SIZE_MIN_PREFER_FIXED(MatrixType::MaxRowsAtCompileTime,
+                                                                              MatrixType::MaxColsAtCompileTime)
+                         : (EIGEN_PLAIN_ENUM_MIN(MatrixType::MaxRowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0),
+                                                 MatrixType::MaxColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))),
+    MaxColsAtCompileTime = 1,
+    MaskLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags = (unsigned int)_MatrixTypeNested::Flags & (RowMajorBit | MaskLvalueBit | DirectAccessBit) & ~RowMajorBit, // FIXME DirectAccessBit should not be handled by expressions
+    MatrixTypeOuterStride = outer_stride_at_compile_time<MatrixType>::ret,
+    InnerStrideAtCompileTime = MatrixTypeOuterStride == Dynamic ? Dynamic : MatrixTypeOuterStride+1,
+    OuterStrideAtCompileTime = 0
+  };
+};
+}
+
+template<typename MatrixType, int _DiagIndex> class Diagonal
+   : public internal::dense_xpr_base< Diagonal<MatrixType,_DiagIndex> >::type
+{
+  public:
+
+    enum { DiagIndex = _DiagIndex };
+    typedef typename internal::dense_xpr_base<Diagonal>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Diagonal)
+
+    EIGEN_DEVICE_FUNC
+    explicit inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) : m_matrix(matrix), m_index(a_index)
+    {
+      eigen_assert( a_index <= m_matrix.cols() && -a_index <= m_matrix.rows() );
+    }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Diagonal)
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const
+    {
+      return m_index.value()<0 ? numext::mini<Index>(m_matrix.cols(),m_matrix.rows()+m_index.value())
+                               : numext::mini<Index>(m_matrix.rows(),m_matrix.cols()-m_index.value());
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return 1; }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT {
+      return m_matrix.outerStride() + 1;
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return 0; }
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<MatrixType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return &(m_matrix.coeffRef(rowOffset(), colOffset())); }
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return &(m_matrix.coeffRef(rowOffset(), colOffset())); }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      return m_matrix.coeffRef(row+rowOffset(), row+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index row, Index) const
+    {
+      return m_matrix.coeffRef(row+rowOffset(), row+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline CoeffReturnType coeff(Index row, Index) const
+    {
+      return m_matrix.coeff(row+rowOffset(), row+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index idx)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      return m_matrix.coeffRef(idx+rowOffset(), idx+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index idx) const
+    {
+      return m_matrix.coeffRef(idx+rowOffset(), idx+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline CoeffReturnType coeff(Index idx) const
+    {
+      return m_matrix.coeff(idx+rowOffset(), idx+colOffset());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline const typename internal::remove_all<typename MatrixType::Nested>::type&
+    nestedExpression() const
+    {
+      return m_matrix;
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Index index() const
+    {
+      return m_index.value();
+    }
+
+  protected:
+    typename internal::ref_selector<MatrixType>::non_const_type m_matrix;
+    const internal::variable_if_dynamicindex<Index, DiagIndex> m_index;
+
+  private:
+    // some compilers may fail to optimize std::max etc in case of compile-time constants...
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index absDiagIndex() const EIGEN_NOEXCEPT { return m_index.value()>0 ? m_index.value() : -m_index.value(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rowOffset() const EIGEN_NOEXCEPT { return m_index.value()>0 ? 0 : -m_index.value(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index colOffset() const EIGEN_NOEXCEPT { return m_index.value()>0 ? m_index.value() : 0; }
+    // trigger a compile-time error if someone try to call packet
+    template<int LoadMode> typename MatrixType::PacketReturnType packet(Index) const;
+    template<int LoadMode> typename MatrixType::PacketReturnType packet(Index,Index) const;
+};
+
+/** \returns an expression of the main diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * Example: \include MatrixBase_diagonal.cpp
+  * Output: \verbinclude MatrixBase_diagonal.out
+  *
+  * \sa class Diagonal */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::DiagonalReturnType
+MatrixBase<Derived>::diagonal()
+{
+  return DiagonalReturnType(derived());
+}
+
+/** This is the const version of diagonal(). */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::ConstDiagonalReturnType
+MatrixBase<Derived>::diagonal() const
+{
+  return ConstDiagonalReturnType(derived());
+}
+
+/** \returns an expression of the \a DiagIndex-th sub or super diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * The template parameter \a DiagIndex represent a super diagonal if \a DiagIndex > 0
+  * and a sub diagonal otherwise. \a DiagIndex == 0 is equivalent to the main diagonal.
+  *
+  * Example: \include MatrixBase_diagonal_int.cpp
+  * Output: \verbinclude MatrixBase_diagonal_int.out
+  *
+  * \sa MatrixBase::diagonal(), class Diagonal */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::DiagonalDynamicIndexReturnType
+MatrixBase<Derived>::diagonal(Index index)
+{
+  return DiagonalDynamicIndexReturnType(derived(), index);
+}
+
+/** This is the const version of diagonal(Index). */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::ConstDiagonalDynamicIndexReturnType
+MatrixBase<Derived>::diagonal(Index index) const
+{
+  return ConstDiagonalDynamicIndexReturnType(derived(), index);
+}
+
+/** \returns an expression of the \a DiagIndex-th sub or super diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * The template parameter \a DiagIndex represent a super diagonal if \a DiagIndex > 0
+  * and a sub diagonal otherwise. \a DiagIndex == 0 is equivalent to the main diagonal.
+  *
+  * Example: \include MatrixBase_diagonal_template_int.cpp
+  * Output: \verbinclude MatrixBase_diagonal_template_int.out
+  *
+  * \sa MatrixBase::diagonal(), class Diagonal */
+template<typename Derived>
+template<int Index_>
+EIGEN_DEVICE_FUNC
+inline typename MatrixBase<Derived>::template DiagonalIndexReturnType<Index_>::Type
+MatrixBase<Derived>::diagonal()
+{
+  return typename DiagonalIndexReturnType<Index_>::Type(derived());
+}
+
+/** This is the const version of diagonal<int>(). */
+template<typename Derived>
+template<int Index_>
+EIGEN_DEVICE_FUNC
+inline typename MatrixBase<Derived>::template ConstDiagonalIndexReturnType<Index_>::Type
+MatrixBase<Derived>::diagonal() const
+{
+  return typename ConstDiagonalIndexReturnType<Index_>::Type(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DIAGONAL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/DiagonalMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/DiagonalMatrix.h
new file mode 100644
index 00000000..542685c6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/DiagonalMatrix.h
@@ -0,0 +1,391 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DIAGONALMATRIX_H
+#define EIGEN_DIAGONALMATRIX_H
+
+namespace Eigen { 
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename Derived>
+class DiagonalBase : public EigenBase<Derived>
+{
+  public:
+    typedef typename internal::traits<Derived>::DiagonalVectorType DiagonalVectorType;
+    typedef typename DiagonalVectorType::Scalar Scalar;
+    typedef typename DiagonalVectorType::RealScalar RealScalar;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+
+    enum {
+      RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+      ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+      MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+      MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+      IsVectorAtCompileTime = 0,
+      Flags = NoPreferredStorageOrderBit
+    };
+
+    typedef Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime> DenseMatrixType;
+    typedef DenseMatrixType DenseType;
+    typedef DiagonalMatrix<Scalar,DiagonalVectorType::SizeAtCompileTime,DiagonalVectorType::MaxSizeAtCompileTime> PlainObject;
+
+    EIGEN_DEVICE_FUNC
+    inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    EIGEN_DEVICE_FUNC
+    inline Derived& derived() { return *static_cast<Derived*>(this); }
+
+    EIGEN_DEVICE_FUNC
+    DenseMatrixType toDenseMatrix() const { return derived(); }
+
+    EIGEN_DEVICE_FUNC
+    inline const DiagonalVectorType& diagonal() const { return derived().diagonal(); }
+    EIGEN_DEVICE_FUNC
+    inline DiagonalVectorType& diagonal() { return derived().diagonal(); }
+
+    EIGEN_DEVICE_FUNC
+    inline Index rows() const { return diagonal().size(); }
+    EIGEN_DEVICE_FUNC
+    inline Index cols() const { return diagonal().size(); }
+
+    template<typename MatrixDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived,MatrixDerived,LazyProduct>
+    operator*(const MatrixBase<MatrixDerived> &matrix) const
+    {
+      return Product<Derived, MatrixDerived, LazyProduct>(derived(),matrix.derived());
+    }
+
+    typedef DiagonalWrapper<const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const DiagonalVectorType> > InverseReturnType;
+    EIGEN_DEVICE_FUNC
+    inline const InverseReturnType
+    inverse() const
+    {
+      return InverseReturnType(diagonal().cwiseInverse());
+    }
+    
+    EIGEN_DEVICE_FUNC
+    inline const DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType,Scalar,product) >
+    operator*(const Scalar& scalar) const
+    {
+      return DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType,Scalar,product) >(diagonal() * scalar);
+    }
+    EIGEN_DEVICE_FUNC
+    friend inline const DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,DiagonalVectorType,product) >
+    operator*(const Scalar& scalar, const DiagonalBase& other)
+    {
+      return DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,DiagonalVectorType,product) >(scalar * other.diagonal());
+    }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    inline unspecified_expression_type
+    #else
+    inline const DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(DiagonalVectorType,typename OtherDerived::DiagonalVectorType,sum) >
+    #endif
+    operator+(const DiagonalBase<OtherDerived>& other) const
+    {
+      return (diagonal() + other.diagonal()).asDiagonal();
+    }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    inline unspecified_expression_type
+    #else
+    inline const DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(DiagonalVectorType,typename OtherDerived::DiagonalVectorType,difference) >
+    #endif
+    operator-(const DiagonalBase<OtherDerived>& other) const
+    {
+      return (diagonal() - other.diagonal()).asDiagonal();
+    }
+};
+
+#endif
+
+/** \class DiagonalMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Represents a diagonal matrix with its storage
+  *
+  * \param _Scalar the type of coefficients
+  * \param SizeAtCompileTime the dimension of the matrix, or Dynamic
+  * \param MaxSizeAtCompileTime the dimension of the matrix, or Dynamic. This parameter is optional and defaults
+  *        to SizeAtCompileTime. Most of the time, you do not need to specify it.
+  *
+  * \sa class DiagonalWrapper
+  */
+
+namespace internal {
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
+struct traits<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
+ : traits<Matrix<_Scalar,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  typedef Matrix<_Scalar,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1> DiagonalVectorType;
+  typedef DiagonalShape StorageKind;
+  enum {
+    Flags = LvalueBit | NoPreferredStorageOrderBit
+  };
+};
+}
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
+class DiagonalMatrix
+  : public DiagonalBase<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  public:
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename internal::traits<DiagonalMatrix>::DiagonalVectorType DiagonalVectorType;
+    typedef const DiagonalMatrix& Nested;
+    typedef _Scalar Scalar;
+    typedef typename internal::traits<DiagonalMatrix>::StorageKind StorageKind;
+    typedef typename internal::traits<DiagonalMatrix>::StorageIndex StorageIndex;
+    #endif
+
+  protected:
+
+    DiagonalVectorType m_diagonal;
+
+  public:
+
+    /** const version of diagonal(). */
+    EIGEN_DEVICE_FUNC
+    inline const DiagonalVectorType& diagonal() const { return m_diagonal; }
+    /** \returns a reference to the stored vector of diagonal coefficients. */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalVectorType& diagonal() { return m_diagonal; }
+
+    /** Default constructor without initialization */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix() {}
+
+    /** Constructs a diagonal matrix with given dimension  */
+    EIGEN_DEVICE_FUNC
+    explicit inline DiagonalMatrix(Index dim) : m_diagonal(dim) {}
+
+    /** 2D constructor. */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix(const Scalar& x, const Scalar& y) : m_diagonal(x,y) {}
+
+    /** 3D constructor. */
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix(const Scalar& x, const Scalar& y, const Scalar& z) : m_diagonal(x,y,z) {}
+
+    #if EIGEN_HAS_CXX11
+    /** \brief Construct a diagonal matrix with fixed size from an arbitrary number of coefficients. \cpp11
+      * 
+      * There exists C++98 anologue constructors for fixed-size diagonal matrices having 2 or 3 coefficients.
+      * 
+      * \warning To construct a diagonal matrix of fixed size, the number of values passed to this 
+      * constructor must match the fixed dimension of \c *this.
+      * 
+      * \sa DiagonalMatrix(const Scalar&, const Scalar&)
+      * \sa DiagonalMatrix(const Scalar&, const Scalar&, const Scalar&)
+      */
+    template <typename... ArgTypes>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    DiagonalMatrix(const Scalar& a0, const Scalar& a1, const Scalar& a2, const ArgTypes&... args)
+      : m_diagonal(a0, a1, a2, args...) {}
+
+    /** \brief Constructs a DiagonalMatrix and initializes it by elements given by an initializer list of initializer
+      * lists \cpp11
+      */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE DiagonalMatrix(const std::initializer_list<std::initializer_list<Scalar>>& list)
+      : m_diagonal(list) {}
+    #endif  // EIGEN_HAS_CXX11
+
+    /** Copy constructor. */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    inline DiagonalMatrix(const DiagonalBase<OtherDerived>& other) : m_diagonal(other.diagonal()) {}
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** copy constructor. prevent a default copy constructor from hiding the other templated constructor */
+    inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.diagonal()) {}
+    #endif
+
+    /** generic constructor from expression of the diagonal coefficients */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    explicit inline DiagonalMatrix(const MatrixBase<OtherDerived>& other) : m_diagonal(other)
+    {}
+
+    /** Copy operator. */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    DiagonalMatrix& operator=(const DiagonalBase<OtherDerived>& other)
+    {
+      m_diagonal = other.diagonal();
+      return *this;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    DiagonalMatrix& operator=(const DiagonalMatrix& other)
+    {
+      m_diagonal = other.diagonal();
+      return *this;
+    }
+    #endif
+
+    /** Resizes to given size. */
+    EIGEN_DEVICE_FUNC
+    inline void resize(Index size) { m_diagonal.resize(size); }
+    /** Sets all coefficients to zero. */
+    EIGEN_DEVICE_FUNC
+    inline void setZero() { m_diagonal.setZero(); }
+    /** Resizes and sets all coefficients to zero. */
+    EIGEN_DEVICE_FUNC
+    inline void setZero(Index size) { m_diagonal.setZero(size); }
+    /** Sets this matrix to be the identity matrix of the current size. */
+    EIGEN_DEVICE_FUNC
+    inline void setIdentity() { m_diagonal.setOnes(); }
+    /** Sets this matrix to be the identity matrix of the given size. */
+    EIGEN_DEVICE_FUNC
+    inline void setIdentity(Index size) { m_diagonal.setOnes(size); }
+};
+
+/** \class DiagonalWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a diagonal matrix
+  *
+  * \param _DiagonalVectorType the type of the vector of diagonal coefficients
+  *
+  * This class is an expression of a diagonal matrix, but not storing its own vector of diagonal coefficients,
+  * instead wrapping an existing vector expression. It is the return type of MatrixBase::asDiagonal()
+  * and most of the time this is the only way that it is used.
+  *
+  * \sa class DiagonalMatrix, class DiagonalBase, MatrixBase::asDiagonal()
+  */
+
+namespace internal {
+template<typename _DiagonalVectorType>
+struct traits<DiagonalWrapper<_DiagonalVectorType> >
+{
+  typedef _DiagonalVectorType DiagonalVectorType;
+  typedef typename DiagonalVectorType::Scalar Scalar;
+  typedef typename DiagonalVectorType::StorageIndex StorageIndex;
+  typedef DiagonalShape StorageKind;
+  typedef typename traits<DiagonalVectorType>::XprKind XprKind;
+  enum {
+    RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+    ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
+    MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+    MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
+    Flags =  (traits<DiagonalVectorType>::Flags & LvalueBit) | NoPreferredStorageOrderBit
+  };
+};
+}
+
+template<typename _DiagonalVectorType>
+class DiagonalWrapper
+  : public DiagonalBase<DiagonalWrapper<_DiagonalVectorType> >, internal::no_assignment_operator
+{
+  public:
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef _DiagonalVectorType DiagonalVectorType;
+    typedef DiagonalWrapper Nested;
+    #endif
+
+    /** Constructor from expression of diagonal coefficients to wrap. */
+    EIGEN_DEVICE_FUNC
+    explicit inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_diagonal) {}
+
+    /** \returns a const reference to the wrapped expression of diagonal coefficients. */
+    EIGEN_DEVICE_FUNC
+    const DiagonalVectorType& diagonal() const { return m_diagonal; }
+
+  protected:
+    typename DiagonalVectorType::Nested m_diagonal;
+};
+
+/** \returns a pseudo-expression of a diagonal matrix with *this as vector of diagonal coefficients
+  *
+  * \only_for_vectors
+  *
+  * Example: \include MatrixBase_asDiagonal.cpp
+  * Output: \verbinclude MatrixBase_asDiagonal.out
+  *
+  * \sa class DiagonalWrapper, class DiagonalMatrix, diagonal(), isDiagonal()
+  **/
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const DiagonalWrapper<const Derived>
+MatrixBase<Derived>::asDiagonal() const
+{
+  return DiagonalWrapper<const Derived>(derived());
+}
+
+/** \returns true if *this is approximately equal to a diagonal matrix,
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isDiagonal.cpp
+  * Output: \verbinclude MatrixBase_isDiagonal.out
+  *
+  * \sa asDiagonal()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isDiagonal(const RealScalar& prec) const
+{
+  if(cols() != rows()) return false;
+  RealScalar maxAbsOnDiagonal = static_cast<RealScalar>(-1);
+  for(Index j = 0; j < cols(); ++j)
+  {
+    RealScalar absOnDiagonal = numext::abs(coeff(j,j));
+    if(absOnDiagonal > maxAbsOnDiagonal) maxAbsOnDiagonal = absOnDiagonal;
+  }
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = 0; i < j; ++i)
+    {
+      if(!internal::isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false;
+      if(!internal::isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false;
+    }
+  return true;
+}
+
+namespace internal {
+
+template<> struct storage_kind_to_shape<DiagonalShape> { typedef DiagonalShape Shape; };
+
+struct Diagonal2Dense {};
+
+template<> struct AssignmentKind<DenseShape,DiagonalShape> { typedef Diagonal2Dense Kind; };
+
+// Diagonal matrix to Dense assignment
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Dense>
+{
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    
+    dst.setZero();
+    dst.diagonal() = src.diagonal();
+  }
+  
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.diagonal() += src.diagonal(); }
+  
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.diagonal() -= src.diagonal(); }
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_DIAGONALMATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/DiagonalProduct.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/DiagonalProduct.h
new file mode 100644
index 00000000..7911d1cd
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/DiagonalProduct.h
@@ -0,0 +1,28 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DIAGONALPRODUCT_H
+#define EIGEN_DIAGONALPRODUCT_H
+
+namespace Eigen { 
+
+/** \returns the diagonal matrix product of \c *this by the diagonal matrix \a diagonal.
+  */
+template<typename Derived>
+template<typename DiagonalDerived>
+EIGEN_DEVICE_FUNC inline const Product<Derived, DiagonalDerived, LazyProduct>
+MatrixBase<Derived>::operator*(const DiagonalBase<DiagonalDerived> &a_diagonal) const
+{
+  return Product<Derived, DiagonalDerived, LazyProduct>(derived(),a_diagonal.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DIAGONALPRODUCT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Dot.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Dot.h
new file mode 100644
index 00000000..5c3441b9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Dot.h
@@ -0,0 +1,318 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008, 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DOT_H
+#define EIGEN_DOT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// helper function for dot(). The problem is that if we put that in the body of dot(), then upon calling dot
+// with mismatched types, the compiler emits errors about failing to instantiate cwiseProduct BEFORE
+// looking at the static assertions. Thus this is a trick to get better compile errors.
+template<typename T, typename U,
+// the NeedToTranspose condition here is taken straight from Assign.h
+         bool NeedToTranspose = T::IsVectorAtCompileTime
+                && U::IsVectorAtCompileTime
+                && ((int(T::RowsAtCompileTime) == 1 && int(U::ColsAtCompileTime) == 1)
+                      |  // FIXME | instead of || to please GCC 4.4.0 stupid warning "suggest parentheses around &&".
+                         // revert to || as soon as not needed anymore.
+                    (int(T::ColsAtCompileTime) == 1 && int(U::RowsAtCompileTime) == 1))
+>
+struct dot_nocheck
+{
+  typedef scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> conj_prod;
+  typedef typename conj_prod::result_type ResScalar;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE
+  static ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)
+  {
+    return a.template binaryExpr<conj_prod>(b).sum();
+  }
+};
+
+template<typename T, typename U>
+struct dot_nocheck<T, U, true>
+{
+  typedef scalar_conj_product_op<typename traits<T>::Scalar,typename traits<U>::Scalar> conj_prod;
+  typedef typename conj_prod::result_type ResScalar;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE
+  static ResScalar run(const MatrixBase<T>& a, const MatrixBase<U>& b)
+  {
+    return a.transpose().template binaryExpr<conj_prod>(b).sum();
+  }
+};
+
+} // end namespace internal
+
+/** \fn MatrixBase::dot
+  * \returns the dot product of *this with other.
+  *
+  * \only_for_vectors
+  *
+  * \note If the scalar type is complex numbers, then this function returns the hermitian
+  * (sesquilinear) dot product, conjugate-linear in the first variable and linear in the
+  * second variable.
+  *
+  * \sa squaredNorm(), norm()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE
+typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
+MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
+#if !(defined(EIGEN_NO_STATIC_ASSERT) && defined(EIGEN_NO_DEBUG))
+  typedef internal::scalar_conj_product_op<Scalar,typename OtherDerived::Scalar> func;
+  EIGEN_CHECK_BINARY_COMPATIBILIY(func,Scalar,typename OtherDerived::Scalar);
+#endif
+  
+  eigen_assert(size() == other.size());
+
+  return internal::dot_nocheck<Derived,OtherDerived>::run(*this, other);
+}
+
+//---------- implementation of L2 norm and related functions ----------
+
+/** \returns, for vectors, the squared \em l2 norm of \c *this, and for matrices the squared Frobenius norm.
+  * In both cases, it consists in the sum of the square of all the matrix entries.
+  * For vectors, this is also equals to the dot product of \c *this with itself.
+  *
+  * \sa dot(), norm(), lpNorm()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::squaredNorm() const
+{
+  return numext::real((*this).cwiseAbs2().sum());
+}
+
+/** \returns, for vectors, the \em l2 norm of \c *this, and for matrices the Frobenius norm.
+  * In both cases, it consists in the square root of the sum of the square of all the matrix entries.
+  * For vectors, this is also equals to the square root of the dot product of \c *this with itself.
+  *
+  * \sa lpNorm(), dot(), squaredNorm()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::norm() const
+{
+  return numext::sqrt(squaredNorm());
+}
+
+/** \returns an expression of the quotient of \c *this by its own norm.
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0),
+  *          then this function returns a copy of the input.
+  *
+  * \only_for_vectors
+  *
+  * \sa norm(), normalize()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::normalized() const
+{
+  typedef typename internal::nested_eval<Derived,2>::type _Nested;
+  _Nested n(derived());
+  RealScalar z = n.squaredNorm();
+  // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
+  if(z>RealScalar(0))
+    return n / numext::sqrt(z);
+  else
+    return n;
+}
+
+/** Normalizes the vector, i.e. divides it by its own norm.
+  *
+  * \only_for_vectors
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0), then \c *this is left unchanged.
+  *
+  * \sa norm(), normalized()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void MatrixBase<Derived>::normalize()
+{
+  RealScalar z = squaredNorm();
+  // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
+  if(z>RealScalar(0))
+    derived() /= numext::sqrt(z);
+}
+
+/** \returns an expression of the quotient of \c *this by its own norm while avoiding underflow and overflow.
+  *
+  * \only_for_vectors
+  *
+  * This method is analogue to the normalized() method, but it reduces the risk of
+  * underflow and overflow when computing the norm.
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0),
+  *          then this function returns a copy of the input.
+  *
+  * \sa stableNorm(), stableNormalize(), normalized()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::stableNormalized() const
+{
+  typedef typename internal::nested_eval<Derived,3>::type _Nested;
+  _Nested n(derived());
+  RealScalar w = n.cwiseAbs().maxCoeff();
+  RealScalar z = (n/w).squaredNorm();
+  if(z>RealScalar(0))
+    return n / (numext::sqrt(z)*w);
+  else
+    return n;
+}
+
+/** Normalizes the vector while avoid underflow and overflow
+  *
+  * \only_for_vectors
+  *
+  * This method is analogue to the normalize() method, but it reduces the risk of
+  * underflow and overflow when computing the norm.
+  *
+  * \warning If the input vector is too small (i.e., this->norm()==0), then \c *this is left unchanged.
+  *
+  * \sa stableNorm(), stableNormalized(), normalize()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void MatrixBase<Derived>::stableNormalize()
+{
+  RealScalar w = cwiseAbs().maxCoeff();
+  RealScalar z = (derived()/w).squaredNorm();
+  if(z>RealScalar(0))
+    derived() /= numext::sqrt(z)*w;
+}
+
+//---------- implementation of other norms ----------
+
+namespace internal {
+
+template<typename Derived, int p>
+struct lpNorm_selector
+{
+  typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const MatrixBase<Derived>& m)
+  {
+    EIGEN_USING_STD(pow)
+    return pow(m.cwiseAbs().array().pow(p).sum(), RealScalar(1)/p);
+  }
+};
+
+template<typename Derived>
+struct lpNorm_selector<Derived, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline typename NumTraits<typename traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m)
+  {
+    return m.cwiseAbs().sum();
+  }
+};
+
+template<typename Derived>
+struct lpNorm_selector<Derived, 2>
+{
+  EIGEN_DEVICE_FUNC
+  static inline typename NumTraits<typename traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m)
+  {
+    return m.norm();
+  }
+};
+
+template<typename Derived>
+struct lpNorm_selector<Derived, Infinity>
+{
+  typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const MatrixBase<Derived>& m)
+  {
+    if(Derived::SizeAtCompileTime==0 || (Derived::SizeAtCompileTime==Dynamic && m.size()==0))
+      return RealScalar(0);
+    return m.cwiseAbs().maxCoeff();
+  }
+};
+
+} // end namespace internal
+
+/** \returns the \b coefficient-wise \f$ \ell^p \f$ norm of \c *this, that is, returns the p-th root of the sum of the p-th powers of the absolute values
+  *          of the coefficients of \c *this. If \a p is the special value \a Eigen::Infinity, this function returns the \f$ \ell^\infty \f$
+  *          norm, that is the maximum of the absolute values of the coefficients of \c *this.
+  *
+  * In all cases, if \c *this is empty, then the value 0 is returned.
+  *
+  * \note For matrices, this function does not compute the <a href="https://en.wikipedia.org/wiki/Operator_norm">operator-norm</a>. That is, if \c *this is a matrix, then its coefficients are interpreted as a 1D vector. Nonetheless, you can easily compute the 1-norm and \f$\infty\f$-norm matrix operator norms using \link TutorialReductionsVisitorsBroadcastingReductionsNorm partial reductions \endlink.
+  *
+  * \sa norm()
+  */
+template<typename Derived>
+template<int p>
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_DEVICE_FUNC inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+#else
+EIGEN_DEVICE_FUNC MatrixBase<Derived>::RealScalar
+#endif
+MatrixBase<Derived>::lpNorm() const
+{
+  return internal::lpNorm_selector<Derived, p>::run(*this);
+}
+
+//---------- implementation of isOrthogonal / isUnitary ----------
+
+/** \returns true if *this is approximately orthogonal to \a other,
+  *          within the precision given by \a prec.
+  *
+  * Example: \include MatrixBase_isOrthogonal.cpp
+  * Output: \verbinclude MatrixBase_isOrthogonal.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+bool MatrixBase<Derived>::isOrthogonal
+(const MatrixBase<OtherDerived>& other, const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,2>::type nested(derived());
+  typename internal::nested_eval<OtherDerived,2>::type otherNested(other.derived());
+  return numext::abs2(nested.dot(otherNested)) <= prec * prec * nested.squaredNorm() * otherNested.squaredNorm();
+}
+
+/** \returns true if *this is approximately an unitary matrix,
+  *          within the precision given by \a prec. In the case where the \a Scalar
+  *          type is real numbers, a unitary matrix is an orthogonal matrix, whence the name.
+  *
+  * \note This can be used to check whether a family of vectors forms an orthonormal basis.
+  *       Indeed, \c m.isUnitary() returns true if and only if the columns (equivalently, the rows) of m form an
+  *       orthonormal basis.
+  *
+  * Example: \include MatrixBase_isUnitary.cpp
+  * Output: \verbinclude MatrixBase_isUnitary.out
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isUnitary(const RealScalar& prec) const
+{
+  typename internal::nested_eval<Derived,1>::type self(derived());
+  for(Index i = 0; i < cols(); ++i)
+  {
+    if(!internal::isApprox(self.col(i).squaredNorm(), static_cast<RealScalar>(1), prec))
+      return false;
+    for(Index j = 0; j < i; ++j)
+      if(!internal::isMuchSmallerThan(self.col(i).dot(self.col(j)), static_cast<Scalar>(1), prec))
+        return false;
+  }
+  return true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DOT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/EigenBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/EigenBase.h
new file mode 100644
index 00000000..6b3c7d37
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/EigenBase.h
@@ -0,0 +1,160 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EIGENBASE_H
+#define EIGEN_EIGENBASE_H
+
+namespace Eigen {
+
+/** \class EigenBase
+  * \ingroup Core_Module
+  *
+  * Common base class for all classes T such that MatrixBase has an operator=(T) and a constructor MatrixBase(T).
+  *
+  * In other words, an EigenBase object is an object that can be copied into a MatrixBase.
+  *
+  * Besides MatrixBase-derived classes, this also includes special matrix classes such as diagonal matrices, etc.
+  *
+  * Notice that this class is trivial, it is only used to disambiguate overloaded functions.
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived> struct EigenBase
+{
+//   typedef typename internal::plain_matrix_type<Derived>::type PlainObject;
+
+  /** \brief The interface type of indices
+    * \details To change this, \c \#define the preprocessor symbol \c EIGEN_DEFAULT_DENSE_INDEX_TYPE.
+    * \sa StorageIndex, \ref TopicPreprocessorDirectives.
+    * DEPRECATED: Since Eigen 3.3, its usage is deprecated. Use Eigen::Index instead.
+    * Deprecation is not marked with a doxygen comment because there are too many existing usages to add the deprecation attribute.
+    */
+  typedef Eigen::Index Index;
+
+  // FIXME is it needed?
+  typedef typename internal::traits<Derived>::StorageKind StorageKind;
+
+  /** \returns a reference to the derived object */
+  EIGEN_DEVICE_FUNC
+  Derived& derived() { return *static_cast<Derived*>(this); }
+  /** \returns a const reference to the derived object */
+  EIGEN_DEVICE_FUNC
+  const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+  EIGEN_DEVICE_FUNC
+  inline Derived& const_cast_derived() const
+  { return *static_cast<Derived*>(const_cast<EigenBase*>(this)); }
+  EIGEN_DEVICE_FUNC
+  inline const Derived& const_derived() const
+  { return *static_cast<const Derived*>(this); }
+
+  /** \returns the number of rows. \sa cols(), RowsAtCompileTime */
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  inline Index rows() const EIGEN_NOEXCEPT { return derived().rows(); }
+  /** \returns the number of columns. \sa rows(), ColsAtCompileTime*/
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  inline Index cols() const EIGEN_NOEXCEPT { return derived().cols(); }
+  /** \returns the number of coefficients, which is rows()*cols().
+    * \sa rows(), cols(), SizeAtCompileTime. */
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  inline Index size() const EIGEN_NOEXCEPT { return rows() * cols(); }
+
+  /** \internal Don't use it, but do the equivalent: \code dst = *this; \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC
+  inline void evalTo(Dest& dst) const
+  { derived().evalTo(dst); }
+
+  /** \internal Don't use it, but do the equivalent: \code dst += *this; \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC
+  inline void addTo(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    typename Dest::PlainObject res(rows(),cols());
+    evalTo(res);
+    dst += res;
+  }
+
+  /** \internal Don't use it, but do the equivalent: \code dst -= *this; \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC
+  inline void subTo(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    typename Dest::PlainObject res(rows(),cols());
+    evalTo(res);
+    dst -= res;
+  }
+
+  /** \internal Don't use it, but do the equivalent: \code dst.applyOnTheRight(*this); \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC inline void applyThisOnTheRight(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    dst = dst * this->derived();
+  }
+
+  /** \internal Don't use it, but do the equivalent: \code dst.applyOnTheLeft(*this); \endcode */
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC inline void applyThisOnTheLeft(Dest& dst) const
+  {
+    // This is the default implementation,
+    // derived class can reimplement it in a more optimized way.
+    dst = this->derived() * dst;
+  }
+
+};
+
+/***************************************************************************
+* Implementation of matrix base methods
+***************************************************************************/
+
+/** \brief Copies the generic expression \a other into *this.
+  *
+  * \details The expression must provide a (templated) evalTo(Derived& dst) const
+  * function which does the actual job. In practice, this allows any user to write
+  * its own special matrix without having to modify MatrixBase
+  *
+  * \returns a reference to *this.
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+Derived& DenseBase<Derived>::operator=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+Derived& DenseBase<Derived>::operator+=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+Derived& DenseBase<Derived>::operator-=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_EIGENBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/ForceAlignedAccess.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ForceAlignedAccess.h
new file mode 100644
index 00000000..817a43af
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ForceAlignedAccess.h
@@ -0,0 +1,150 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FORCEALIGNEDACCESS_H
+#define EIGEN_FORCEALIGNEDACCESS_H
+
+namespace Eigen {
+
+/** \class ForceAlignedAccess
+  * \ingroup Core_Module
+  *
+  * \brief Enforce aligned packet loads and stores regardless of what is requested
+  *
+  * \param ExpressionType the type of the object of which we are forcing aligned packet access
+  *
+  * This class is the return type of MatrixBase::forceAlignedAccess()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::forceAlignedAccess()
+  */
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<ForceAlignedAccess<ExpressionType> > : public traits<ExpressionType>
+{};
+}
+
+template<typename ExpressionType> class ForceAlignedAccess
+  : public internal::dense_xpr_base< ForceAlignedAccess<ExpressionType> >::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<ForceAlignedAccess>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ForceAlignedAccess)
+
+    EIGEN_DEVICE_FUNC explicit inline ForceAlignedAccess(const ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_expression.cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return m_expression.outerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return m_expression.innerStride(); }
+
+    EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index row, Index col) const
+    {
+      return m_expression.coeff(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col)
+    {
+      return m_expression.const_cast_derived().coeffRef(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index index) const
+    {
+      return m_expression.coeff(index);
+    }
+
+    EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index index)
+    {
+      return m_expression.const_cast_derived().coeffRef(index);
+    }
+
+    template<int LoadMode>
+    inline const PacketScalar packet(Index row, Index col) const
+    {
+      return m_expression.template packet<Aligned>(row, col);
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index row, Index col, const PacketScalar& x)
+    {
+      m_expression.const_cast_derived().template writePacket<Aligned>(row, col, x);
+    }
+
+    template<int LoadMode>
+    inline const PacketScalar packet(Index index) const
+    {
+      return m_expression.template packet<Aligned>(index);
+    }
+
+    template<int LoadMode>
+    inline void writePacket(Index index, const PacketScalar& x)
+    {
+      m_expression.const_cast_derived().template writePacket<Aligned>(index, x);
+    }
+
+    EIGEN_DEVICE_FUNC operator const ExpressionType&() const { return m_expression; }
+
+  protected:
+    const ExpressionType& m_expression;
+
+  private:
+    ForceAlignedAccess& operator=(const ForceAlignedAccess&);
+};
+
+/** \returns an expression of *this with forced aligned access
+  * \sa forceAlignedAccessIf(),class ForceAlignedAccess
+  */
+template<typename Derived>
+inline const ForceAlignedAccess<Derived>
+MatrixBase<Derived>::forceAlignedAccess() const
+{
+  return ForceAlignedAccess<Derived>(derived());
+}
+
+/** \returns an expression of *this with forced aligned access
+  * \sa forceAlignedAccessIf(), class ForceAlignedAccess
+  */
+template<typename Derived>
+inline ForceAlignedAccess<Derived>
+MatrixBase<Derived>::forceAlignedAccess()
+{
+  return ForceAlignedAccess<Derived>(derived());
+}
+
+/** \returns an expression of *this with forced aligned access if \a Enable is true.
+  * \sa forceAlignedAccess(), class ForceAlignedAccess
+  */
+template<typename Derived>
+template<bool Enable>
+inline typename internal::add_const_on_value_type<typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type>::type
+MatrixBase<Derived>::forceAlignedAccessIf() const
+{
+  return derived();  // FIXME This should not work but apparently is never used
+}
+
+/** \returns an expression of *this with forced aligned access if \a Enable is true.
+  * \sa forceAlignedAccess(), class ForceAlignedAccess
+  */
+template<typename Derived>
+template<bool Enable>
+inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type
+MatrixBase<Derived>::forceAlignedAccessIf()
+{
+  return derived();  // FIXME This should not work but apparently is never used
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FORCEALIGNEDACCESS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Fuzzy.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Fuzzy.h
new file mode 100644
index 00000000..43aa49b2
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Fuzzy.h
@@ -0,0 +1,155 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FUZZY_H
+#define EIGEN_FUZZY_H
+
+namespace Eigen { 
+
+namespace internal
+{
+
+template<typename Derived, typename OtherDerived, bool is_integer = NumTraits<typename Derived::Scalar>::IsInteger>
+struct isApprox_selector
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar& prec)
+  {
+    typename internal::nested_eval<Derived,2>::type nested(x);
+    typename internal::nested_eval<OtherDerived,2>::type otherNested(y);
+    return (nested - otherNested).cwiseAbs2().sum() <= prec * prec * numext::mini(nested.cwiseAbs2().sum(), otherNested.cwiseAbs2().sum());
+  }
+};
+
+template<typename Derived, typename OtherDerived>
+struct isApprox_selector<Derived, OtherDerived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar&)
+  {
+    return x.matrix() == y.matrix();
+  }
+};
+
+template<typename Derived, typename OtherDerived, bool is_integer = NumTraits<typename Derived::Scalar>::IsInteger>
+struct isMuchSmallerThan_object_selector
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived& y, const typename Derived::RealScalar& prec)
+  {
+    return x.cwiseAbs2().sum() <= numext::abs2(prec) * y.cwiseAbs2().sum();
+  }
+};
+
+template<typename Derived, typename OtherDerived>
+struct isMuchSmallerThan_object_selector<Derived, OtherDerived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const OtherDerived&, const typename Derived::RealScalar&)
+  {
+    return x.matrix() == Derived::Zero(x.rows(), x.cols()).matrix();
+  }
+};
+
+template<typename Derived, bool is_integer = NumTraits<typename Derived::Scalar>::IsInteger>
+struct isMuchSmallerThan_scalar_selector
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const typename Derived::RealScalar& y, const typename Derived::RealScalar& prec)
+  {
+    return x.cwiseAbs2().sum() <= numext::abs2(prec * y);
+  }
+};
+
+template<typename Derived>
+struct isMuchSmallerThan_scalar_selector<Derived, true>
+{
+  EIGEN_DEVICE_FUNC
+  static bool run(const Derived& x, const typename Derived::RealScalar&, const typename Derived::RealScalar&)
+  {
+    return x.matrix() == Derived::Zero(x.rows(), x.cols()).matrix();
+  }
+};
+
+} // end namespace internal
+
+
+/** \returns \c true if \c *this is approximately equal to \a other, within the precision
+  * determined by \a prec.
+  *
+  * \note The fuzzy compares are done multiplicatively. Two vectors \f$ v \f$ and \f$ w \f$
+  * are considered to be approximately equal within precision \f$ p \f$ if
+  * \f[ \Vert v - w \Vert \leqslant p\,\min(\Vert v\Vert, \Vert w\Vert). \f]
+  * For matrices, the comparison is done using the Hilbert-Schmidt norm (aka Frobenius norm
+  * L2 norm).
+  *
+  * \note Because of the multiplicativeness of this comparison, one can't use this function
+  * to check whether \c *this is approximately equal to the zero matrix or vector.
+  * Indeed, \c isApprox(zero) returns false unless \c *this itself is exactly the zero matrix
+  * or vector. If you want to test whether \c *this is zero, use internal::isMuchSmallerThan(const
+  * RealScalar&, RealScalar) instead.
+  *
+  * \sa internal::isMuchSmallerThan(const RealScalar&, RealScalar) const
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isApprox(
+  const DenseBase<OtherDerived>& other,
+  const RealScalar& prec
+) const
+{
+  return internal::isApprox_selector<Derived, OtherDerived>::run(derived(), other.derived(), prec);
+}
+
+/** \returns \c true if the norm of \c *this is much smaller than \a other,
+  * within the precision determined by \a prec.
+  *
+  * \note The fuzzy compares are done multiplicatively. A vector \f$ v \f$ is
+  * considered to be much smaller than \f$ x \f$ within precision \f$ p \f$ if
+  * \f[ \Vert v \Vert \leqslant p\,\vert x\vert. \f]
+  *
+  * For matrices, the comparison is done using the Hilbert-Schmidt norm. For this reason,
+  * the value of the reference scalar \a other should come from the Hilbert-Schmidt norm
+  * of a reference matrix of same dimensions.
+  *
+  * \sa isApprox(), isMuchSmallerThan(const DenseBase<OtherDerived>&, RealScalar) const
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isMuchSmallerThan(
+  const typename NumTraits<Scalar>::Real& other,
+  const RealScalar& prec
+) const
+{
+  return internal::isMuchSmallerThan_scalar_selector<Derived>::run(derived(), other, prec);
+}
+
+/** \returns \c true if the norm of \c *this is much smaller than the norm of \a other,
+  * within the precision determined by \a prec.
+  *
+  * \note The fuzzy compares are done multiplicatively. A vector \f$ v \f$ is
+  * considered to be much smaller than a vector \f$ w \f$ within precision \f$ p \f$ if
+  * \f[ \Vert v \Vert \leqslant p\,\Vert w\Vert. \f]
+  * For matrices, the comparison is done using the Hilbert-Schmidt norm.
+  *
+  * \sa isApprox(), isMuchSmallerThan(const RealScalar&, RealScalar) const
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC bool DenseBase<Derived>::isMuchSmallerThan(
+  const DenseBase<OtherDerived>& other,
+  const RealScalar& prec
+) const
+{
+  return internal::isMuchSmallerThan_object_selector<Derived, OtherDerived>::run(derived(), other.derived(), prec);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FUZZY_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/GeneralProduct.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/GeneralProduct.h
new file mode 100644
index 00000000..6906aa75
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/GeneralProduct.h
@@ -0,0 +1,465 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_PRODUCT_H
+#define EIGEN_GENERAL_PRODUCT_H
+
+namespace Eigen {
+
+enum {
+  Large = 2,
+  Small = 3
+};
+
+// Define the threshold value to fallback from the generic matrix-matrix product
+// implementation (heavy) to the lightweight coeff-based product one.
+// See generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct>
+// in products/GeneralMatrixMatrix.h for more details.
+// TODO This threshold should also be used in the compile-time selector below.
+#ifndef EIGEN_GEMM_TO_COEFFBASED_THRESHOLD
+// This default value has been obtained on a Haswell architecture.
+#define EIGEN_GEMM_TO_COEFFBASED_THRESHOLD 20
+#endif
+
+namespace internal {
+
+template<int Rows, int Cols, int Depth> struct product_type_selector;
+
+template<int Size, int MaxSize> struct product_size_category
+{
+  enum {
+    #ifndef EIGEN_GPU_COMPILE_PHASE
+    is_large = MaxSize == Dynamic ||
+               Size >= EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD ||
+               (Size==Dynamic && MaxSize>=EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD),
+    #else
+    is_large = 0,
+    #endif
+    value = is_large  ? Large
+          : Size == 1 ? 1
+                      : Small
+  };
+};
+
+template<typename Lhs, typename Rhs> struct product_type
+{
+  typedef typename remove_all<Lhs>::type _Lhs;
+  typedef typename remove_all<Rhs>::type _Rhs;
+  enum {
+    MaxRows = traits<_Lhs>::MaxRowsAtCompileTime,
+    Rows    = traits<_Lhs>::RowsAtCompileTime,
+    MaxCols = traits<_Rhs>::MaxColsAtCompileTime,
+    Cols    = traits<_Rhs>::ColsAtCompileTime,
+    MaxDepth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::MaxColsAtCompileTime,
+                                           traits<_Rhs>::MaxRowsAtCompileTime),
+    Depth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::ColsAtCompileTime,
+                                        traits<_Rhs>::RowsAtCompileTime)
+  };
+
+  // the splitting into different lines of code here, introducing the _select enums and the typedef below,
+  // is to work around an internal compiler error with gcc 4.1 and 4.2.
+private:
+  enum {
+    rows_select = product_size_category<Rows,MaxRows>::value,
+    cols_select = product_size_category<Cols,MaxCols>::value,
+    depth_select = product_size_category<Depth,MaxDepth>::value
+  };
+  typedef product_type_selector<rows_select, cols_select, depth_select> selector;
+
+public:
+  enum {
+    value = selector::ret,
+    ret = selector::ret
+  };
+#ifdef EIGEN_DEBUG_PRODUCT
+  static void debug()
+  {
+      EIGEN_DEBUG_VAR(Rows);
+      EIGEN_DEBUG_VAR(Cols);
+      EIGEN_DEBUG_VAR(Depth);
+      EIGEN_DEBUG_VAR(rows_select);
+      EIGEN_DEBUG_VAR(cols_select);
+      EIGEN_DEBUG_VAR(depth_select);
+      EIGEN_DEBUG_VAR(value);
+  }
+#endif
+};
+
+/* The following allows to select the kind of product at compile time
+ * based on the three dimensions of the product.
+ * This is a compile time mapping from {1,Small,Large}^3 -> {product types} */
+// FIXME I'm not sure the current mapping is the ideal one.
+template<int M, int N>  struct product_type_selector<M,N,1>              { enum { ret = OuterProduct }; };
+template<int M>         struct product_type_selector<M, 1, 1>            { enum { ret = LazyCoeffBasedProductMode }; };
+template<int N>         struct product_type_selector<1, N, 1>            { enum { ret = LazyCoeffBasedProductMode }; };
+template<int Depth>     struct product_type_selector<1,    1,    Depth>  { enum { ret = InnerProduct }; };
+template<>              struct product_type_selector<1,    1,    1>      { enum { ret = InnerProduct }; };
+template<>              struct product_type_selector<Small,1,    Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<1,    Small,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small,Small,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small, Small, 1>    { enum { ret = LazyCoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small, Large, 1>    { enum { ret = LazyCoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large, Small, 1>    { enum { ret = LazyCoeffBasedProductMode }; };
+template<>              struct product_type_selector<1,    Large,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<1,    Large,Large>  { enum { ret = GemvProduct }; };
+template<>              struct product_type_selector<1,    Small,Large>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large,1,    Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large,1,    Large>  { enum { ret = GemvProduct }; };
+template<>              struct product_type_selector<Small,1,    Large>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small,Small,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Large,Small,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Small,Large,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Large,Large,Large>  { enum { ret = GemmProduct }; };
+template<>              struct product_type_selector<Large,Small,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Small,Large,Small>  { enum { ret = CoeffBasedProductMode }; };
+template<>              struct product_type_selector<Large,Large,Small>  { enum { ret = GemmProduct }; };
+
+} // end namespace internal
+
+/***********************************************************************
+*  Implementation of Inner Vector Vector Product
+***********************************************************************/
+
+// FIXME : maybe the "inner product" could return a Scalar
+// instead of a 1x1 matrix ??
+// Pro: more natural for the user
+// Cons: this could be a problem if in a meta unrolled algorithm a matrix-matrix
+// product ends up to a row-vector times col-vector product... To tackle this use
+// case, we could have a specialization for Block<MatrixType,1,1> with: operator=(Scalar x);
+
+/***********************************************************************
+*  Implementation of Outer Vector Vector Product
+***********************************************************************/
+
+/***********************************************************************
+*  Implementation of General Matrix Vector Product
+***********************************************************************/
+
+/*  According to the shape/flags of the matrix we have to distinghish 3 different cases:
+ *   1 - the matrix is col-major, BLAS compatible and M is large => call fast BLAS-like colmajor routine
+ *   2 - the matrix is row-major, BLAS compatible and N is large => call fast BLAS-like rowmajor routine
+ *   3 - all other cases are handled using a simple loop along the outer-storage direction.
+ *  Therefore we need a lower level meta selector.
+ *  Furthermore, if the matrix is the rhs, then the product has to be transposed.
+ */
+namespace internal {
+
+template<int Side, int StorageOrder, bool BlasCompatible>
+struct gemv_dense_selector;
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Scalar,int Size,int MaxSize,bool Cond> struct gemv_static_vector_if;
+
+template<typename Scalar,int Size,int MaxSize>
+struct gemv_static_vector_if<Scalar,Size,MaxSize,false>
+{
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Scalar* data() { eigen_internal_assert(false && "should never be called"); return 0; }
+};
+
+template<typename Scalar,int Size>
+struct gemv_static_vector_if<Scalar,Size,Dynamic,true>
+{
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Scalar* data() { return 0; }
+};
+
+template<typename Scalar,int Size,int MaxSize>
+struct gemv_static_vector_if<Scalar,Size,MaxSize,true>
+{
+  enum {
+    ForceAlignment  = internal::packet_traits<Scalar>::Vectorizable,
+    PacketSize      = internal::packet_traits<Scalar>::size
+  };
+  #if EIGEN_MAX_STATIC_ALIGN_BYTES!=0
+  internal::plain_array<Scalar,EIGEN_SIZE_MIN_PREFER_FIXED(Size,MaxSize),0,EIGEN_PLAIN_ENUM_MIN(AlignedMax,PacketSize)> m_data;
+  EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; }
+  #else
+  // Some architectures cannot align on the stack,
+  // => let's manually enforce alignment by allocating more data and return the address of the first aligned element.
+  internal::plain_array<Scalar,EIGEN_SIZE_MIN_PREFER_FIXED(Size,MaxSize)+(ForceAlignment?EIGEN_MAX_ALIGN_BYTES:0),0> m_data;
+  EIGEN_STRONG_INLINE Scalar* data() {
+    return ForceAlignment
+            ? reinterpret_cast<Scalar*>((internal::UIntPtr(m_data.array) & ~(std::size_t(EIGEN_MAX_ALIGN_BYTES-1))) + EIGEN_MAX_ALIGN_BYTES)
+            : m_data.array;
+  }
+  #endif
+};
+
+// The vector is on the left => transposition
+template<int StorageOrder, bool BlasCompatible>
+struct gemv_dense_selector<OnTheLeft,StorageOrder,BlasCompatible>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    Transpose<Dest> destT(dest);
+    enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor };
+    gemv_dense_selector<OnTheRight,OtherStorageOrder,BlasCompatible>
+      ::run(rhs.transpose(), lhs.transpose(), destT, alpha);
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,ColMajor,true>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static inline void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar   LhsScalar;
+    typedef typename Rhs::Scalar   RhsScalar;
+    typedef typename Dest::Scalar  ResScalar;
+    typedef typename Dest::RealScalar  RealScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  
+    typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest;
+
+    ActualLhsType actualLhs = LhsBlasTraits::extract(lhs);
+    ActualRhsType actualRhs = RhsBlasTraits::extract(rhs);
+
+    ResScalar actualAlpha = combine_scalar_factors(alpha, lhs, rhs);
+
+    // make sure Dest is a compile-time vector type (bug 1166)
+    typedef typename conditional<Dest::IsVectorAtCompileTime, Dest, typename Dest::ColXpr>::type ActualDest;
+
+    enum {
+      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
+      // on, the other hand it is good for the cache to pack the vector anyways...
+      EvalToDestAtCompileTime = (ActualDest::InnerStrideAtCompileTime==1),
+      ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex),
+      MightCannotUseDest = ((!EvalToDestAtCompileTime) || ComplexByReal) && (ActualDest::MaxSizeAtCompileTime!=0)
+    };
+
+    typedef const_blas_data_mapper<LhsScalar,Index,ColMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,RowMajor> RhsMapper;
+    RhsScalar compatibleAlpha = get_factor<ResScalar,RhsScalar>::run(actualAlpha);
+
+    if(!MightCannotUseDest)
+    {
+      // shortcut if we are sure to be able to use dest directly,
+      // this ease the compiler to generate cleaner and more optimzized code for most common cases
+      general_matrix_vector_product
+          <Index,LhsScalar,LhsMapper,ColMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
+          actualLhs.rows(), actualLhs.cols(),
+          LhsMapper(actualLhs.data(), actualLhs.outerStride()),
+          RhsMapper(actualRhs.data(), actualRhs.innerStride()),
+          dest.data(), 1,
+          compatibleAlpha);
+    }
+    else
+    {
+      gemv_static_vector_if<ResScalar,ActualDest::SizeAtCompileTime,ActualDest::MaxSizeAtCompileTime,MightCannotUseDest> static_dest;
+
+      const bool alphaIsCompatible = (!ComplexByReal) || (numext::imag(actualAlpha)==RealScalar(0));
+      const bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
+
+      ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(),
+                                                    evalToDest ? dest.data() : static_dest.data());
+
+      if(!evalToDest)
+      {
+        #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+        Index size = dest.size();
+        EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+        #endif
+        if(!alphaIsCompatible)
+        {
+          MappedDest(actualDestPtr, dest.size()).setZero();
+          compatibleAlpha = RhsScalar(1);
+        }
+        else
+          MappedDest(actualDestPtr, dest.size()) = dest;
+      }
+
+      general_matrix_vector_product
+          <Index,LhsScalar,LhsMapper,ColMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
+          actualLhs.rows(), actualLhs.cols(),
+          LhsMapper(actualLhs.data(), actualLhs.outerStride()),
+          RhsMapper(actualRhs.data(), actualRhs.innerStride()),
+          actualDestPtr, 1,
+          compatibleAlpha);
+
+      if (!evalToDest)
+      {
+        if(!alphaIsCompatible)
+          dest.matrix() += actualAlpha * MappedDest(actualDestPtr, dest.size());
+        else
+          dest = MappedDest(actualDestPtr, dest.size());
+      }
+    }
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,RowMajor,true>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar   LhsScalar;
+    typedef typename Rhs::Scalar   RhsScalar;
+    typedef typename Dest::Scalar  ResScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+    typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
+    typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
+
+    ResScalar actualAlpha = combine_scalar_factors(alpha, lhs, rhs);
+
+    enum {
+      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
+      // on, the other hand it is good for the cache to pack the vector anyways...
+      DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1 || ActualRhsTypeCleaned::MaxSizeAtCompileTime==0
+    };
+
+    gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;
+
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
+        DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
+
+    if(!DirectlyUseRhs)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = actualRhs.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    }
+
+    typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
+    general_matrix_vector_product
+        <Index,LhsScalar,LhsMapper,RowMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
+        actualLhs.rows(), actualLhs.cols(),
+        LhsMapper(actualLhs.data(), actualLhs.outerStride()),
+        RhsMapper(actualRhsPtr, 1),
+        dest.data(), dest.col(0).innerStride(), //NOTE  if dest is not a vector at compile-time, then dest.innerStride() might be wrong. (bug 1166)
+        actualAlpha);
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,ColMajor,false>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    EIGEN_STATIC_ASSERT((!nested_eval<Lhs,1>::Evaluate),EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE);
+    // TODO if rhs is large enough it might be beneficial to make sure that dest is sequentially stored in memory, otherwise use a temp
+    typename nested_eval<Rhs,1>::type actual_rhs(rhs);
+    const Index size = rhs.rows();
+    for(Index k=0; k<size; ++k)
+      dest += (alpha*actual_rhs.coeff(k)) * lhs.col(k);
+  }
+};
+
+template<> struct gemv_dense_selector<OnTheRight,RowMajor,false>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    EIGEN_STATIC_ASSERT((!nested_eval<Lhs,1>::Evaluate),EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE);
+    typename nested_eval<Rhs,Lhs::RowsAtCompileTime>::type actual_rhs(rhs);
+    const Index rows = dest.rows();
+    for(Index i=0; i<rows; ++i)
+      dest.coeffRef(i) += alpha * (lhs.row(i).cwiseProduct(actual_rhs.transpose())).sum();
+  }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Implementation of matrix base methods
+***************************************************************************/
+
+/** \returns the matrix product of \c *this and \a other.
+  *
+  * \note If instead of the matrix product you want the coefficient-wise product, see Cwise::operator*().
+  *
+  * \sa lazyProduct(), operator*=(const MatrixBase&), Cwise::operator*()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const Product<Derived, OtherDerived>
+MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived> &other) const
+{
+  // A note regarding the function declaration: In MSVC, this function will sometimes
+  // not be inlined since DenseStorage is an unwindable object for dynamic
+  // matrices and product types are holding a member to store the result.
+  // Thus it does not help tagging this function with EIGEN_STRONG_INLINE.
+  enum {
+    ProductIsValid =  Derived::ColsAtCompileTime==Dynamic
+                   || OtherDerived::RowsAtCompileTime==Dynamic
+                   || int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime),
+    AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime,
+    SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived)
+  };
+  // note to the lost user:
+  //    * for a dot product use: v1.dot(v2)
+  //    * for a coeff-wise product use: v1.cwiseProduct(v2)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes),
+    INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors),
+    INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
+  EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)
+#ifdef EIGEN_DEBUG_PRODUCT
+  internal::product_type<Derived,OtherDerived>::debug();
+#endif
+
+  return Product<Derived, OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the matrix product of \c *this and \a other without implicit evaluation.
+  *
+  * The returned product will behave like any other expressions: the coefficients of the product will be
+  * computed once at a time as requested. This might be useful in some extremely rare cases when only
+  * a small and no coherent fraction of the result's coefficients have to be computed.
+  *
+  * \warning This version of the matrix product can be much much slower. So use it only if you know
+  * what you are doing and that you measured a true speed improvement.
+  *
+  * \sa operator*(const MatrixBase&)
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const Product<Derived,OtherDerived,LazyProduct>
+MatrixBase<Derived>::lazyProduct(const MatrixBase<OtherDerived> &other) const
+{
+  enum {
+    ProductIsValid =  Derived::ColsAtCompileTime==Dynamic
+                   || OtherDerived::RowsAtCompileTime==Dynamic
+                   || int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime),
+    AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime,
+    SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived)
+  };
+  // note to the lost user:
+  //    * for a dot product use: v1.dot(v2)
+  //    * for a coeff-wise product use: v1.cwiseProduct(v2)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes),
+    INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS)
+  EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors),
+    INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
+  EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)
+
+  return Product<Derived,OtherDerived,LazyProduct>(derived(), other.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PRODUCT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/GenericPacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/GenericPacketMath.h
new file mode 100644
index 00000000..cf677a19
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/GenericPacketMath.h
@@ -0,0 +1,1040 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERIC_PACKET_MATH_H
+#define EIGEN_GENERIC_PACKET_MATH_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+  * \file GenericPacketMath.h
+  *
+  * Default implementation for types not supported by the vectorization.
+  * In practice these functions are provided to make easier the writing
+  * of generic vectorized code.
+  */
+
+#ifndef EIGEN_DEBUG_ALIGNED_LOAD
+#define EIGEN_DEBUG_ALIGNED_LOAD
+#endif
+
+#ifndef EIGEN_DEBUG_UNALIGNED_LOAD
+#define EIGEN_DEBUG_UNALIGNED_LOAD
+#endif
+
+#ifndef EIGEN_DEBUG_ALIGNED_STORE
+#define EIGEN_DEBUG_ALIGNED_STORE
+#endif
+
+#ifndef EIGEN_DEBUG_UNALIGNED_STORE
+#define EIGEN_DEBUG_UNALIGNED_STORE
+#endif
+
+struct default_packet_traits
+{
+  enum {
+    HasHalfPacket = 0,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 0,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 1,
+    HasBlend     = 0,
+    // This flag is used to indicate whether packet comparison is supported.
+    // pcmp_eq, pcmp_lt and pcmp_le should be defined for it to be true.
+    HasCmp       = 0,
+
+    HasDiv    = 0,
+    HasSqrt   = 0,
+    HasRsqrt  = 0,
+    HasExp    = 0,
+    HasExpm1  = 0,
+    HasLog    = 0,
+    HasLog1p  = 0,
+    HasLog10  = 0,
+    HasPow    = 0,
+
+    HasSin    = 0,
+    HasCos    = 0,
+    HasTan    = 0,
+    HasASin   = 0,
+    HasACos   = 0,
+    HasATan   = 0,
+    HasSinh   = 0,
+    HasCosh   = 0,
+    HasTanh   = 0,
+    HasLGamma = 0,
+    HasDiGamma = 0,
+    HasZeta = 0,
+    HasPolygamma = 0,
+    HasErf = 0,
+    HasErfc = 0,
+    HasNdtri = 0,
+    HasBessel = 0,
+    HasIGamma = 0,
+    HasIGammaDerA = 0,
+    HasGammaSampleDerAlpha = 0,
+    HasIGammac = 0,
+    HasBetaInc = 0,
+
+    HasRound  = 0,
+    HasRint   = 0,
+    HasFloor  = 0,
+    HasCeil   = 0,
+    HasSign   = 0
+  };
+};
+
+template<typename T> struct packet_traits : default_packet_traits
+{
+  typedef T type;
+  typedef T half;
+  enum {
+    Vectorizable = 0,
+    size = 1,
+    AlignedOnScalar = 0,
+    HasHalfPacket = 0
+  };
+  enum {
+    HasAdd    = 0,
+    HasSub    = 0,
+    HasMul    = 0,
+    HasNegate = 0,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasConj   = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<typename T> struct packet_traits<const T> : packet_traits<T> { };
+
+template<typename T> struct unpacket_traits
+{
+  typedef T type;
+  typedef T half;
+  enum
+  {
+    size = 1,
+    alignment = 1,
+    vectorizable = false,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<typename T> struct unpacket_traits<const T> : unpacket_traits<T> { };
+
+template <typename Src, typename Tgt> struct type_casting_traits {
+  enum {
+    VectorizedCast = 0,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+/** \internal Wrapper to ensure that multiple packet types can map to the same
+    same underlying vector type. */
+template<typename T, int unique_id = 0>
+struct eigen_packet_wrapper
+{
+  EIGEN_ALWAYS_INLINE operator T&() { return m_val; }
+  EIGEN_ALWAYS_INLINE operator const T&() const { return m_val; }
+  EIGEN_ALWAYS_INLINE eigen_packet_wrapper() {}
+  EIGEN_ALWAYS_INLINE eigen_packet_wrapper(const T &v) : m_val(v) {}
+  EIGEN_ALWAYS_INLINE eigen_packet_wrapper& operator=(const T &v) {
+    m_val = v;
+    return *this;
+  }
+
+  T m_val;
+};
+
+
+/** \internal A convenience utility for determining if the type is a scalar.
+ * This is used to enable some generic packet implementations.
+ */
+template<typename Packet>
+struct is_scalar {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  enum {
+    value = internal::is_same<Packet, Scalar>::value
+  };
+};
+
+/** \internal \returns static_cast<TgtType>(a) (coeff-wise) */
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a) {
+  return static_cast<TgtPacket>(a);
+}
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a, const SrcPacket& /*b*/) {
+  return static_cast<TgtPacket>(a);
+}
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a, const SrcPacket& /*b*/, const SrcPacket& /*c*/, const SrcPacket& /*d*/) {
+  return static_cast<TgtPacket>(a);
+}
+template <typename SrcPacket, typename TgtPacket>
+EIGEN_DEVICE_FUNC inline TgtPacket
+pcast(const SrcPacket& a, const SrcPacket& /*b*/, const SrcPacket& /*c*/, const SrcPacket& /*d*/,
+      const SrcPacket& /*e*/, const SrcPacket& /*f*/, const SrcPacket& /*g*/, const SrcPacket& /*h*/) {
+  return static_cast<TgtPacket>(a);
+}
+
+/** \internal \returns reinterpret_cast<Target>(a) */
+template <typename Target, typename Packet>
+EIGEN_DEVICE_FUNC inline Target
+preinterpret(const Packet& a); /* { return reinterpret_cast<const Target&>(a); } */
+
+/** \internal \returns a + b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+padd(const Packet& a, const Packet& b) { return a+b; }
+// Avoid compiler warning for boolean algebra.
+template<> EIGEN_DEVICE_FUNC inline bool
+padd(const bool& a, const bool& b) { return a || b; }
+
+/** \internal \returns a - b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+psub(const Packet& a, const Packet& b) { return a-b; }
+
+/** \internal \returns -a (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pnegate(const Packet& a) { return -a; }
+
+template<> EIGEN_DEVICE_FUNC inline bool
+pnegate(const bool& a) { return !a; }
+
+/** \internal \returns conj(a) (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pconj(const Packet& a) { return numext::conj(a); }
+
+/** \internal \returns a * b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmul(const Packet& a, const Packet& b) { return a*b; }
+// Avoid compiler warning for boolean algebra.
+template<> EIGEN_DEVICE_FUNC inline bool
+pmul(const bool& a, const bool& b) { return a && b; }
+
+/** \internal \returns a / b (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pdiv(const Packet& a, const Packet& b) { return a/b; }
+
+// In the generic case, memset to all one bits.
+template<typename Packet, typename EnableIf = void>
+struct ptrue_impl {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& /*a*/){
+    Packet b;
+    memset(static_cast<void*>(&b), 0xff, sizeof(Packet));
+    return b;
+  }
+};
+
+// For non-trivial scalars, set to Scalar(1) (i.e. a non-zero value).
+// Although this is technically not a valid bitmask, the scalar path for pselect
+// uses a comparison to zero, so this should still work in most cases. We don't
+// have another option, since the scalar type requires initialization.
+template<typename T>
+struct ptrue_impl<T, 
+    typename internal::enable_if<is_scalar<T>::value && NumTraits<T>::RequireInitialization>::type > {
+  static EIGEN_DEVICE_FUNC inline T run(const T& /*a*/){
+    return T(1);
+  }
+};
+
+/** \internal \returns one bits. */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+ptrue(const Packet& a) {
+  return ptrue_impl<Packet>::run(a);
+}
+
+// In the general case, memset to zero.
+template<typename Packet, typename EnableIf = void>
+struct pzero_impl {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& /*a*/) {
+    Packet b;
+    memset(static_cast<void*>(&b), 0x00, sizeof(Packet));
+    return b;
+  }
+};
+
+// For scalars, explicitly set to Scalar(0), since the underlying representation
+// for zero may not consist of all-zero bits.
+template<typename T>
+struct pzero_impl<T,
+    typename internal::enable_if<is_scalar<T>::value>::type> {
+  static EIGEN_DEVICE_FUNC inline T run(const T& /*a*/) {
+    return T(0);
+  }
+};
+
+/** \internal \returns packet of zeros */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pzero(const Packet& a) {
+  return pzero_impl<Packet>::run(a);
+}
+
+/** \internal \returns a <= b as a bit mask */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pcmp_le(const Packet& a, const Packet& b)  { return a<=b ? ptrue(a) : pzero(a); }
+
+/** \internal \returns a < b as a bit mask */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pcmp_lt(const Packet& a, const Packet& b)  { return a<b ? ptrue(a) : pzero(a); }
+
+/** \internal \returns a == b as a bit mask */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pcmp_eq(const Packet& a, const Packet& b) { return a==b ? ptrue(a) : pzero(a); }
+
+/** \internal \returns a < b or a==NaN or b==NaN as a bit mask */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pcmp_lt_or_nan(const Packet& a, const Packet& b) { return a>=b ? pzero(a) : ptrue(a); }
+
+template<typename T>
+struct bit_and {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(const T& a, const T& b) const {
+    return a & b;
+  }
+};
+
+template<typename T>
+struct bit_or {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(const T& a, const T& b) const {
+    return a | b;
+  }
+};
+
+template<typename T>
+struct bit_xor {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(const T& a, const T& b) const {
+    return a ^ b;
+  }
+};
+
+template<typename T>
+struct bit_not {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR EIGEN_ALWAYS_INLINE T operator()(const T& a) const {
+    return ~a;
+  }
+};
+
+// Use operators &, |, ^, ~.
+template<typename T>
+struct operator_bitwise_helper {
+  EIGEN_DEVICE_FUNC static inline T bitwise_and(const T& a, const T& b) { return bit_and<T>()(a, b); }
+  EIGEN_DEVICE_FUNC static inline T bitwise_or(const T& a, const T& b) { return bit_or<T>()(a, b); }
+  EIGEN_DEVICE_FUNC static inline T bitwise_xor(const T& a, const T& b) { return bit_xor<T>()(a, b); }
+  EIGEN_DEVICE_FUNC static inline T bitwise_not(const T& a) { return bit_not<T>()(a); }
+};
+
+// Apply binary operations byte-by-byte
+template<typename T>
+struct bytewise_bitwise_helper {
+  EIGEN_DEVICE_FUNC static inline T bitwise_and(const T& a, const T& b) {
+    return binary(a, b, bit_and<unsigned char>());
+  }
+  EIGEN_DEVICE_FUNC static inline T bitwise_or(const T& a, const T& b) { 
+    return binary(a, b, bit_or<unsigned char>());
+   }
+  EIGEN_DEVICE_FUNC static inline T bitwise_xor(const T& a, const T& b) {
+    return binary(a, b, bit_xor<unsigned char>());
+  }
+  EIGEN_DEVICE_FUNC static inline T bitwise_not(const T& a) { 
+    return unary(a,bit_not<unsigned char>());
+   }
+  
+ private:
+  template<typename Op>
+  EIGEN_DEVICE_FUNC static inline T unary(const T& a, Op op) {
+    const unsigned char* a_ptr = reinterpret_cast<const unsigned char*>(&a);
+    T c;
+    unsigned char* c_ptr = reinterpret_cast<unsigned char*>(&c);
+    for (size_t i = 0; i < sizeof(T); ++i) {
+      *c_ptr++ = op(*a_ptr++);
+    }
+    return c;
+  }
+
+  template<typename Op>
+  EIGEN_DEVICE_FUNC static inline T binary(const T& a, const T& b, Op op) {
+    const unsigned char* a_ptr = reinterpret_cast<const unsigned char*>(&a);
+    const unsigned char* b_ptr = reinterpret_cast<const unsigned char*>(&b);
+    T c;
+    unsigned char* c_ptr = reinterpret_cast<unsigned char*>(&c);
+    for (size_t i = 0; i < sizeof(T); ++i) {
+      *c_ptr++ = op(*a_ptr++, *b_ptr++);
+    }
+    return c;
+  }
+};
+
+// In the general case, use byte-by-byte manipulation.
+template<typename T, typename EnableIf = void>
+struct bitwise_helper : public bytewise_bitwise_helper<T> {};
+
+// For integers or non-trivial scalars, use binary operators.
+template<typename T>
+struct bitwise_helper<T,
+  typename internal::enable_if<
+    is_scalar<T>::value && (NumTraits<T>::IsInteger || NumTraits<T>::RequireInitialization)>::type
+  > : public operator_bitwise_helper<T> {};
+
+/** \internal \returns the bitwise and of \a a and \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pand(const Packet& a, const Packet& b) {
+  return bitwise_helper<Packet>::bitwise_and(a, b);
+}
+
+/** \internal \returns the bitwise or of \a a and \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+por(const Packet& a, const Packet& b) {
+  return bitwise_helper<Packet>::bitwise_or(a, b);
+}
+
+/** \internal \returns the bitwise xor of \a a and \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pxor(const Packet& a, const Packet& b) {
+  return bitwise_helper<Packet>::bitwise_xor(a, b);
+}
+
+/** \internal \returns the bitwise not of \a a */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pnot(const Packet& a) {
+  return bitwise_helper<Packet>::bitwise_not(a);
+}
+
+/** \internal \returns the bitwise and of \a a and not \a b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pandnot(const Packet& a, const Packet& b) { return pand(a, pnot(b)); }
+
+// In the general case, use bitwise select.
+template<typename Packet, typename EnableIf = void>
+struct pselect_impl {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& mask, const Packet& a, const Packet& b) {
+    return por(pand(a,mask),pandnot(b,mask));
+  }
+};
+
+// For scalars, use ternary select.
+template<typename Packet>
+struct pselect_impl<Packet, 
+    typename internal::enable_if<is_scalar<Packet>::value>::type > {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& mask, const Packet& a, const Packet& b) {
+    return numext::equal_strict(mask, Packet(0)) ? b : a;
+  }
+};
+
+/** \internal \returns \a or \b for each field in packet according to \mask */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pselect(const Packet& mask, const Packet& a, const Packet& b) {
+  return pselect_impl<Packet>::run(mask, a, b);
+}
+
+template<> EIGEN_DEVICE_FUNC inline bool pselect<bool>(
+    const bool& cond, const bool& a, const bool& b) {
+  return cond ? a : b;
+}
+
+/** \internal \returns the min or of \a a and \a b (coeff-wise)
+    If either \a a or \a b are NaN, the result is implementation defined. */
+template<int NaNPropagation>
+struct pminmax_impl {
+  template <typename Packet, typename Op>
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
+    return op(a,b);
+  }
+};
+
+/** \internal \returns the min or max of \a a and \a b (coeff-wise)
+    If either \a a or \a b are NaN, NaN is returned. */
+template<>
+struct pminmax_impl<PropagateNaN> {
+  template <typename Packet, typename Op>
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
+  Packet not_nan_mask_a = pcmp_eq(a, a);
+  Packet not_nan_mask_b = pcmp_eq(b, b);
+  return pselect(not_nan_mask_a,
+                 pselect(not_nan_mask_b, op(a, b), b),
+                 a);
+  }
+};
+
+/** \internal \returns the min or max of \a a and \a b (coeff-wise)
+    If both \a a and \a b are NaN, NaN is returned.
+    Equivalent to std::fmin(a, b).  */
+template<>
+struct pminmax_impl<PropagateNumbers> {
+  template <typename Packet, typename Op>
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
+  Packet not_nan_mask_a = pcmp_eq(a, a);
+  Packet not_nan_mask_b = pcmp_eq(b, b);
+  return pselect(not_nan_mask_a,
+                 pselect(not_nan_mask_b, op(a, b), a),
+                 b);
+  }
+};
+
+
+#ifndef SYCL_DEVICE_ONLY
+#define EIGEN_BINARY_OP_NAN_PROPAGATION(Type, Func) Func
+#else
+#define EIGEN_BINARY_OP_NAN_PROPAGATION(Type, Func) \
+[](const Type& a, const Type& b) { \
+        return Func(a, b);}
+#endif
+
+/** \internal \returns the min of \a a and \a b  (coeff-wise).
+    If \a a or \b b is NaN, the return value is implementation defined. */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmin(const Packet& a, const Packet& b) { return numext::mini(a,b); }
+
+/** \internal \returns the min of \a a and \a b  (coeff-wise).
+    NaNPropagation determines the NaN propagation semantics. */
+template <int NaNPropagation, typename Packet>
+EIGEN_DEVICE_FUNC inline Packet pmin(const Packet& a, const Packet& b) {
+  return pminmax_impl<NaNPropagation>::run(a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet, (pmin<Packet>)));
+}
+
+/** \internal \returns the max of \a a and \a b  (coeff-wise)
+    If \a a or \b b is NaN, the return value is implementation defined. */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmax(const Packet& a, const Packet& b) { return numext::maxi(a, b); }
+
+/** \internal \returns the max of \a a and \a b  (coeff-wise).
+    NaNPropagation determines the NaN propagation semantics. */
+template <int NaNPropagation, typename Packet>
+EIGEN_DEVICE_FUNC inline Packet pmax(const Packet& a, const Packet& b) {
+  return pminmax_impl<NaNPropagation>::run(a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet,(pmax<Packet>)));
+}
+
+/** \internal \returns the absolute value of \a a */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pabs(const Packet& a) { return numext::abs(a); }
+template<> EIGEN_DEVICE_FUNC inline unsigned int
+pabs(const unsigned int& a) { return a; }
+template<> EIGEN_DEVICE_FUNC inline unsigned long
+pabs(const unsigned long& a) { return a; }
+template<> EIGEN_DEVICE_FUNC inline unsigned long long
+pabs(const unsigned long long& a) { return a; }
+
+/** \internal \returns the addsub value of \a a,b */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+paddsub(const Packet& a, const Packet& b) {
+  return pselect(peven_mask(a), padd(a, b), psub(a, b));
+ }
+
+/** \internal \returns the phase angle of \a a */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+parg(const Packet& a) { using numext::arg; return arg(a); }
+
+
+/** \internal \returns \a a logically shifted by N bits to the right */
+template<int N> EIGEN_DEVICE_FUNC inline int
+parithmetic_shift_right(const int& a) { return a >> N; }
+template<int N> EIGEN_DEVICE_FUNC inline long int
+parithmetic_shift_right(const long int& a) { return a >> N; }
+
+/** \internal \returns \a a arithmetically shifted by N bits to the right */
+template<int N> EIGEN_DEVICE_FUNC inline int
+plogical_shift_right(const int& a) { return static_cast<int>(static_cast<unsigned int>(a) >> N); }
+template<int N> EIGEN_DEVICE_FUNC inline long int
+plogical_shift_right(const long int& a) { return static_cast<long>(static_cast<unsigned long>(a) >> N); }
+
+/** \internal \returns \a a shifted by N bits to the left */
+template<int N> EIGEN_DEVICE_FUNC inline int
+plogical_shift_left(const int& a) { return a << N; }
+template<int N> EIGEN_DEVICE_FUNC inline long int
+plogical_shift_left(const long int& a) { return a << N; }
+
+/** \internal \returns the significant and exponent of the underlying floating point numbers
+  * See https://en.cppreference.com/w/cpp/numeric/math/frexp
+  */
+template <typename Packet>
+EIGEN_DEVICE_FUNC inline Packet pfrexp(const Packet& a, Packet& exponent) {
+  int exp;
+  EIGEN_USING_STD(frexp);
+  Packet result = static_cast<Packet>(frexp(a, &exp));
+  exponent = static_cast<Packet>(exp);
+  return result;
+}
+
+/** \internal \returns a * 2^((int)exponent)
+  * See https://en.cppreference.com/w/cpp/numeric/math/ldexp
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pldexp(const Packet &a, const Packet &exponent) {
+  EIGEN_USING_STD(ldexp)
+  return static_cast<Packet>(ldexp(a, static_cast<int>(exponent)));
+}
+
+/** \internal \returns the min of \a a and \a b  (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pabsdiff(const Packet& a, const Packet& b) { return pselect(pcmp_lt(a, b), psub(b, a), psub(a, b)); }
+
+/** \internal \returns a packet version of \a *from, from must be 16 bytes aligned */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pload(const typename unpacket_traits<Packet>::type* from) { return *from; }
+
+/** \internal \returns a packet version of \a *from, (un-aligned load) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+ploadu(const typename unpacket_traits<Packet>::type* from) { return *from; }
+
+/** \internal \returns a packet version of \a *from, (un-aligned masked load)
+ * There is no generic implementation. We only have implementations for specialized
+ * cases. Generic case should not be called.
+ */
+template<typename Packet> EIGEN_DEVICE_FUNC inline
+typename enable_if<unpacket_traits<Packet>::masked_load_available, Packet>::type
+ploadu(const typename unpacket_traits<Packet>::type* from, typename unpacket_traits<Packet>::mask_t umask);
+
+/** \internal \returns a packet with constant coefficients \a a, e.g.: (a,a,a,a) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pset1(const typename unpacket_traits<Packet>::type& a) { return a; }
+
+/** \internal \returns a packet with constant coefficients set from bits */
+template<typename Packet,typename BitsType> EIGEN_DEVICE_FUNC inline Packet
+pset1frombits(BitsType a);
+
+/** \internal \returns a packet with constant coefficients \a a[0], e.g.: (a[0],a[0],a[0],a[0]) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pload1(const typename unpacket_traits<Packet>::type  *a) { return pset1<Packet>(*a); }
+
+/** \internal \returns a packet with elements of \a *from duplicated.
+  * For instance, for a packet of 8 elements, 4 scalars will be read from \a *from and
+  * duplicated to form: {from[0],from[0],from[1],from[1],from[2],from[2],from[3],from[3]}
+  * Currently, this function is only used for scalar * complex products.
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
+ploaddup(const typename unpacket_traits<Packet>::type* from) { return *from; }
+
+/** \internal \returns a packet with elements of \a *from quadrupled.
+  * For instance, for a packet of 8 elements, 2 scalars will be read from \a *from and
+  * replicated to form: {from[0],from[0],from[0],from[0],from[1],from[1],from[1],from[1]}
+  * Currently, this function is only used in matrix products.
+  * For packet-size smaller or equal to 4, this function is equivalent to pload1
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+ploadquad(const typename unpacket_traits<Packet>::type* from)
+{ return pload1<Packet>(from); }
+
+/** \internal equivalent to
+  * \code
+  * a0 = pload1(a+0);
+  * a1 = pload1(a+1);
+  * a2 = pload1(a+2);
+  * a3 = pload1(a+3);
+  * \endcode
+  * \sa pset1, pload1, ploaddup, pbroadcast2
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC
+inline void pbroadcast4(const typename unpacket_traits<Packet>::type *a,
+                        Packet& a0, Packet& a1, Packet& a2, Packet& a3)
+{
+  a0 = pload1<Packet>(a+0);
+  a1 = pload1<Packet>(a+1);
+  a2 = pload1<Packet>(a+2);
+  a3 = pload1<Packet>(a+3);
+}
+
+/** \internal equivalent to
+  * \code
+  * a0 = pload1(a+0);
+  * a1 = pload1(a+1);
+  * \endcode
+  * \sa pset1, pload1, ploaddup, pbroadcast4
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC
+inline void pbroadcast2(const typename unpacket_traits<Packet>::type *a,
+                        Packet& a0, Packet& a1)
+{
+  a0 = pload1<Packet>(a+0);
+  a1 = pload1<Packet>(a+1);
+}
+
+/** \internal \brief Returns a packet with coefficients (a,a+1,...,a+packet_size-1). */
+template<typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
+plset(const typename unpacket_traits<Packet>::type& a) { return a; }
+
+/** \internal \returns a packet with constant coefficients \a a, e.g.: (x, 0, x, 0),
+     where x is the value of all 1-bits. */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+peven_mask(const Packet& /*a*/) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  const size_t n = unpacket_traits<Packet>::size;
+  EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar elements[n];
+  for(size_t i = 0; i < n; ++i) {
+    memset(elements+i, ((i & 1) == 0 ? 0xff : 0), sizeof(Scalar));
+  }
+  return ploadu<Packet>(elements);
+}
+
+
+/** \internal copy the packet \a from to \a *to, \a to must be 16 bytes aligned */
+template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstore(Scalar* to, const Packet& from)
+{ (*to) = from; }
+
+/** \internal copy the packet \a from to \a *to, (un-aligned store) */
+template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstoreu(Scalar* to, const Packet& from)
+{  (*to) = from; }
+
+/** \internal copy the packet \a from to \a *to, (un-aligned store with a mask)
+ * There is no generic implementation. We only have implementations for specialized
+ * cases. Generic case should not be called.
+ */
+template<typename Scalar, typename Packet>
+EIGEN_DEVICE_FUNC inline
+typename enable_if<unpacket_traits<Packet>::masked_store_available, void>::type
+pstoreu(Scalar* to, const Packet& from, typename unpacket_traits<Packet>::mask_t umask);
+
+ template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather(const Scalar* from, Index /*stride*/)
+ { return ploadu<Packet>(from); }
+
+ template<typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pscatter(Scalar* to, const Packet& from, Index /*stride*/)
+ { pstore(to, from); }
+
+/** \internal tries to do cache prefetching of \a addr */
+template<typename Scalar> EIGEN_DEVICE_FUNC inline void prefetch(const Scalar* addr)
+{
+#if defined(EIGEN_HIP_DEVICE_COMPILE)
+  // do nothing
+#elif defined(EIGEN_CUDA_ARCH)
+#if defined(__LP64__) || EIGEN_OS_WIN64
+  // 64-bit pointer operand constraint for inlined asm
+  asm(" prefetch.L1 [ %1 ];" : "=l"(addr) : "l"(addr));
+#else
+  // 32-bit pointer operand constraint for inlined asm
+  asm(" prefetch.L1 [ %1 ];" : "=r"(addr) : "r"(addr));
+#endif
+#elif (!EIGEN_COMP_MSVC) && (EIGEN_COMP_GNUC || EIGEN_COMP_CLANG || EIGEN_COMP_ICC)
+  __builtin_prefetch(addr);
+#endif
+}
+
+/** \internal \returns the reversed elements of \a a*/
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet preverse(const Packet& a)
+{ return a; }
+
+/** \internal \returns \a a with real and imaginary part flipped (for complex type only) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet pcplxflip(const Packet& a)
+{
+  return Packet(numext::imag(a),numext::real(a));
+}
+
+/**************************
+* Special math functions
+***************************/
+
+/** \internal \returns the sine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet psin(const Packet& a) { EIGEN_USING_STD(sin); return sin(a); }
+
+/** \internal \returns the cosine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pcos(const Packet& a) { EIGEN_USING_STD(cos); return cos(a); }
+
+/** \internal \returns the tan of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet ptan(const Packet& a) { EIGEN_USING_STD(tan); return tan(a); }
+
+/** \internal \returns the arc sine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pasin(const Packet& a) { EIGEN_USING_STD(asin); return asin(a); }
+
+/** \internal \returns the arc cosine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pacos(const Packet& a) { EIGEN_USING_STD(acos); return acos(a); }
+
+/** \internal \returns the arc tangent of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet patan(const Packet& a) { EIGEN_USING_STD(atan); return atan(a); }
+
+/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet psinh(const Packet& a) { EIGEN_USING_STD(sinh); return sinh(a); }
+
+/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pcosh(const Packet& a) { EIGEN_USING_STD(cosh); return cosh(a); }
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet ptanh(const Packet& a) { EIGEN_USING_STD(tanh); return tanh(a); }
+
+/** \internal \returns the exp of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pexp(const Packet& a) { EIGEN_USING_STD(exp); return exp(a); }
+
+/** \internal \returns the expm1 of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pexpm1(const Packet& a) { return numext::expm1(a); }
+
+/** \internal \returns the log of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog(const Packet& a) { EIGEN_USING_STD(log); return log(a); }
+
+/** \internal \returns the log1p of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog1p(const Packet& a) { return numext::log1p(a); }
+
+/** \internal \returns the log10 of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog10(const Packet& a) { EIGEN_USING_STD(log10); return log10(a); }
+
+/** \internal \returns the log10 of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet plog2(const Packet& a) {
+  typedef typename internal::unpacket_traits<Packet>::type Scalar;
+  return pmul(pset1<Packet>(Scalar(EIGEN_LOG2E)), plog(a)); 
+}
+
+/** \internal \returns the square-root of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet psqrt(const Packet& a) { return numext::sqrt(a); }
+
+/** \internal \returns the reciprocal square-root of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet prsqrt(const Packet& a) {
+  typedef typename internal::unpacket_traits<Packet>::type Scalar;
+  return pdiv(pset1<Packet>(Scalar(1)), psqrt(a));
+}
+
+/** \internal \returns the rounded value of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pround(const Packet& a) { using numext::round; return round(a); }
+
+/** \internal \returns the floor of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pfloor(const Packet& a) { using numext::floor; return floor(a); }
+
+/** \internal \returns the rounded value of \a a (coeff-wise) with current
+ * rounding mode */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet print(const Packet& a) { using numext::rint; return rint(a); }
+
+/** \internal \returns the ceil of \a a (coeff-wise) */
+template<typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+Packet pceil(const Packet& a) { using numext::ceil; return ceil(a); }
+
+/** \internal \returns the first element of a packet */
+template<typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type
+pfirst(const Packet& a)
+{ return a; }
+
+/** \internal \returns the sum of the elements of upper and lower half of \a a if \a a is larger than 4.
+  * For a packet {a0, a1, a2, a3, a4, a5, a6, a7}, it returns a half packet {a0+a4, a1+a5, a2+a6, a3+a7}
+  * For packet-size smaller or equal to 4, this boils down to a noop.
+  */
+template<typename Packet>
+EIGEN_DEVICE_FUNC inline typename conditional<(unpacket_traits<Packet>::size%8)==0,typename unpacket_traits<Packet>::half,Packet>::type
+predux_half_dowto4(const Packet& a)
+{ return a; }
+
+// Slow generic implementation of Packet reduction.
+template <typename Packet, typename Op>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type
+predux_helper(const Packet& a, Op op) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  const size_t n = unpacket_traits<Packet>::size;
+  EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar elements[n];
+  pstoreu<Scalar>(elements, a);
+  for(size_t k = n / 2; k > 0; k /= 2)  {
+    for(size_t i = 0; i < k; ++i) {
+      elements[i] = op(elements[i], elements[i + k]);
+    }
+  }
+  return elements[0];
+}
+
+/** \internal \returns the sum of the elements of \a a*/
+template<typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type
+predux(const Packet& a)
+{
+  return a;
+}
+
+/** \internal \returns the product of the elements of \a a */
+template <typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_mul(
+    const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type Scalar; 
+  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmul<Scalar>)));
+}
+
+/** \internal \returns the min of the elements of \a a */
+template <typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_min(
+    const Packet &a) {
+  typedef typename unpacket_traits<Packet>::type Scalar; 
+  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmin<PropagateFast, Scalar>)));
+}
+
+template <int NaNPropagation, typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_min(
+    const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type Scalar; 
+  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmin<NaNPropagation, Scalar>)));
+}
+
+/** \internal \returns the min of the elements of \a a */
+template <typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_max(
+    const Packet &a) {
+  typedef typename unpacket_traits<Packet>::type Scalar; 
+  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmax<PropagateFast, Scalar>)));
+}
+
+template <int NaNPropagation, typename Packet>
+EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_max(
+    const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type Scalar; 
+  return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmax<NaNPropagation, Scalar>)));
+}
+
+#undef EIGEN_BINARY_OP_NAN_PROPAGATION
+
+/** \internal \returns true if all coeffs of \a a means "true"
+  * It is supposed to be called on values returned by pcmp_*.
+  */
+// not needed yet
+// template<typename Packet> EIGEN_DEVICE_FUNC inline bool predux_all(const Packet& a)
+// { return bool(a); }
+
+/** \internal \returns true if any coeffs of \a a means "true"
+  * It is supposed to be called on values returned by pcmp_*.
+  */
+template<typename Packet> EIGEN_DEVICE_FUNC inline bool predux_any(const Packet& a)
+{
+  // Dirty but generic implementation where "true" is assumed to be non 0 and all the sames.
+  // It is expected that "true" is either:
+  //  - Scalar(1)
+  //  - bits full of ones (NaN for floats),
+  //  - or first bit equals to 1 (1 for ints, smallest denormal for floats).
+  // For all these cases, taking the sum is just fine, and this boils down to a no-op for scalars.
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  return numext::not_equal_strict(predux(a), Scalar(0));
+}
+
+/***************************************************************************
+* The following functions might not have to be overwritten for vectorized types
+***************************************************************************/
+
+/** \internal copy a packet with constant coefficient \a a (e.g., [a,a,a,a]) to \a *to. \a to must be 16 bytes aligned */
+// NOTE: this function must really be templated on the packet type (think about different packet types for the same scalar type)
+template<typename Packet>
+inline void pstore1(typename unpacket_traits<Packet>::type* to, const typename unpacket_traits<Packet>::type& a)
+{
+  pstore(to, pset1<Packet>(a));
+}
+
+/** \internal \returns a * b + c (coeff-wise) */
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pmadd(const Packet&  a,
+         const Packet&  b,
+         const Packet&  c)
+{ return padd(pmul(a, b),c); }
+
+/** \internal \returns a packet version of \a *from.
+  * The pointer \a from must be aligned on a \a Alignment bytes boundary. */
+template<typename Packet, int Alignment>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt(const typename unpacket_traits<Packet>::type* from)
+{
+  if(Alignment >= unpacket_traits<Packet>::alignment)
+    return pload<Packet>(from);
+  else
+    return ploadu<Packet>(from);
+}
+
+/** \internal copy the packet \a from to \a *to.
+  * The pointer \a from must be aligned on a \a Alignment bytes boundary. */
+template<typename Scalar, typename Packet, int Alignment>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(Scalar* to, const Packet& from)
+{
+  if(Alignment >= unpacket_traits<Packet>::alignment)
+    pstore(to, from);
+  else
+    pstoreu(to, from);
+}
+
+/** \internal \returns a packet version of \a *from.
+  * Unlike ploadt, ploadt_ro takes advantage of the read-only memory path on the
+  * hardware if available to speedup the loading of data that won't be modified
+  * by the current computation.
+  */
+template<typename Packet, int LoadMode>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt_ro(const typename unpacket_traits<Packet>::type* from)
+{
+  return ploadt<Packet, LoadMode>(from);
+}
+
+/***************************************************************************
+* Fast complex products (GCC generates a function call which is very slow)
+***************************************************************************/
+
+// Eigen+CUDA does not support complexes.
+#if !defined(EIGEN_GPUCC)
+
+template<> inline std::complex<float> pmul(const std::complex<float>& a, const std::complex<float>& b)
+{ return std::complex<float>(a.real()*b.real() - a.imag()*b.imag(), a.imag()*b.real() + a.real()*b.imag()); }
+
+template<> inline std::complex<double> pmul(const std::complex<double>& a, const std::complex<double>& b)
+{ return std::complex<double>(a.real()*b.real() - a.imag()*b.imag(), a.imag()*b.real() + a.real()*b.imag()); }
+
+#endif
+
+
+/***************************************************************************
+ * PacketBlock, that is a collection of N packets where the number of words
+ * in the packet is a multiple of N.
+***************************************************************************/
+template <typename Packet,int N=unpacket_traits<Packet>::size> struct PacketBlock {
+  Packet packet[N];
+};
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet,1>& /*kernel*/) {
+  // Nothing to do in the scalar case, i.e. a 1x1 matrix.
+}
+
+/***************************************************************************
+ * Selector, i.e. vector of N boolean values used to select (i.e. blend)
+ * words from 2 packets.
+***************************************************************************/
+template <size_t N> struct Selector {
+  bool select[N];
+};
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
+pblend(const Selector<unpacket_traits<Packet>::size>& ifPacket, const Packet& thenPacket, const Packet& elsePacket) {
+  return ifPacket.select[0] ? thenPacket : elsePacket;
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERIC_PACKET_MATH_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/GlobalFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/GlobalFunctions.h
new file mode 100644
index 00000000..629af94b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/GlobalFunctions.h
@@ -0,0 +1,194 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GLOBAL_FUNCTIONS_H
+#define EIGEN_GLOBAL_FUNCTIONS_H
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(NAME,FUNCTOR,DOC_OP,DOC_DETAILS) \
+  /** \returns an expression of the coefficient-wise DOC_OP of \a x
+
+    DOC_DETAILS
+
+    \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_##NAME">Math functions</a>, class CwiseUnaryOp
+    */ \
+  template<typename Derived> \
+  inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> \
+  NAME(const Eigen::ArrayBase<Derived>& x);
+
+#else
+
+#define EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(NAME,FUNCTOR,DOC_OP,DOC_DETAILS) \
+  template<typename Derived> \
+  inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> \
+  (NAME)(const Eigen::ArrayBase<Derived>& x) { \
+    return Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived>(x.derived()); \
+  }
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME,FUNCTOR) \
+  \
+  template<typename Derived> \
+  struct NAME##_retval<ArrayBase<Derived> > \
+  { \
+    typedef const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> type; \
+  }; \
+  template<typename Derived> \
+  struct NAME##_impl<ArrayBase<Derived> > \
+  { \
+    static inline typename NAME##_retval<ArrayBase<Derived> >::type run(const Eigen::ArrayBase<Derived>& x) \
+    { \
+      return typename NAME##_retval<ArrayBase<Derived> >::type(x.derived()); \
+    } \
+  };
+
+namespace Eigen
+{
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(real,scalar_real_op,real part,\sa ArrayBase::real)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(imag,scalar_imag_op,imaginary part,\sa ArrayBase::imag)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(conj,scalar_conjugate_op,complex conjugate,\sa ArrayBase::conjugate)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(inverse,scalar_inverse_op,inverse,\sa ArrayBase::inverse)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sin,scalar_sin_op,sine,\sa ArrayBase::sin)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cos,scalar_cos_op,cosine,\sa ArrayBase::cos)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tan,scalar_tan_op,tangent,\sa ArrayBase::tan)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(atan,scalar_atan_op,arc-tangent,\sa ArrayBase::atan)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(asin,scalar_asin_op,arc-sine,\sa ArrayBase::asin)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(acos,scalar_acos_op,arc-consine,\sa ArrayBase::acos)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sinh,scalar_sinh_op,hyperbolic sine,\sa ArrayBase::sinh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cosh,scalar_cosh_op,hyperbolic cosine,\sa ArrayBase::cosh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tanh,scalar_tanh_op,hyperbolic tangent,\sa ArrayBase::tanh)
+#if EIGEN_HAS_CXX11_MATH
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(asinh,scalar_asinh_op,inverse hyperbolic sine,\sa ArrayBase::asinh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(acosh,scalar_acosh_op,inverse hyperbolic cosine,\sa ArrayBase::acosh)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(atanh,scalar_atanh_op,inverse hyperbolic tangent,\sa ArrayBase::atanh)
+#endif
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(logistic,scalar_logistic_op,logistic function,\sa ArrayBase::logistic)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(lgamma,scalar_lgamma_op,natural logarithm of the gamma function,\sa ArrayBase::lgamma)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(digamma,scalar_digamma_op,derivative of lgamma,\sa ArrayBase::digamma)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(erf,scalar_erf_op,error function,\sa ArrayBase::erf)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(erfc,scalar_erfc_op,complement error function,\sa ArrayBase::erfc)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(ndtri,scalar_ndtri_op,inverse normal distribution function,\sa ArrayBase::ndtri)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(exp,scalar_exp_op,exponential,\sa ArrayBase::exp)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(expm1,scalar_expm1_op,exponential of a value minus 1,\sa ArrayBase::expm1)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log,scalar_log_op,natural logarithm,\sa Eigen::log10 DOXCOMMA ArrayBase::log)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log1p,scalar_log1p_op,natural logarithm of 1 plus the value,\sa ArrayBase::log1p)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log10,scalar_log10_op,base 10 logarithm,\sa Eigen::log DOXCOMMA ArrayBase::log10)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(log2,scalar_log2_op,base 2 logarithm,\sa Eigen::log DOXCOMMA ArrayBase::log2)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs,scalar_abs_op,absolute value,\sa ArrayBase::abs DOXCOMMA MatrixBase::cwiseAbs)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(abs2,scalar_abs2_op,squared absolute value,\sa ArrayBase::abs2 DOXCOMMA MatrixBase::cwiseAbs2)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(arg,scalar_arg_op,complex argument,\sa ArrayBase::arg DOXCOMMA MatrixBase::cwiseArg)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sqrt,scalar_sqrt_op,square root,\sa ArrayBase::sqrt DOXCOMMA MatrixBase::cwiseSqrt)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(rsqrt,scalar_rsqrt_op,reciprocal square root,\sa ArrayBase::rsqrt)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(square,scalar_square_op,square (power 2),\sa Eigen::abs2 DOXCOMMA Eigen::pow DOXCOMMA ArrayBase::square)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cube,scalar_cube_op,cube (power 3),\sa Eigen::pow DOXCOMMA ArrayBase::cube)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(rint,scalar_rint_op,nearest integer,\sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(round,scalar_round_op,nearest integer,\sa Eigen::floor DOXCOMMA Eigen::ceil DOXCOMMA ArrayBase::round)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(floor,scalar_floor_op,nearest integer not greater than the giben value,\sa Eigen::ceil DOXCOMMA ArrayBase::floor)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(ceil,scalar_ceil_op,nearest integer not less than the giben value,\sa Eigen::floor DOXCOMMA ArrayBase::ceil)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isnan,scalar_isnan_op,not-a-number test,\sa Eigen::isinf DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isnan)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isinf,scalar_isinf_op,infinite value test,\sa Eigen::isnan DOXCOMMA Eigen::isfinite DOXCOMMA ArrayBase::isinf)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(isfinite,scalar_isfinite_op,finite value test,\sa Eigen::isinf DOXCOMMA Eigen::isnan DOXCOMMA ArrayBase::isfinite)
+  EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sign,scalar_sign_op,sign (or 0),\sa ArrayBase::sign)
+
+  /** \returns an expression of the coefficient-wise power of \a x to the given constant \a exponent.
+    *
+    * \tparam ScalarExponent is the scalar type of \a exponent. It must be compatible with the scalar type of the given expression (\c Derived::Scalar).
+    *
+    * \sa ArrayBase::pow()
+    *
+    * \relates ArrayBase
+    */
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  template<typename Derived,typename ScalarExponent>
+  inline const CwiseBinaryOp<internal::scalar_pow_op<Derived::Scalar,ScalarExponent>,Derived,Constant<ScalarExponent> >
+  pow(const Eigen::ArrayBase<Derived>& x, const ScalarExponent& exponent);
+#else
+  template <typename Derived,typename ScalarExponent>
+  EIGEN_DEVICE_FUNC inline
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(
+    const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,typename internal::promote_scalar_arg<typename Derived::Scalar
+                                                 EIGEN_COMMA ScalarExponent EIGEN_COMMA
+                                                 EIGEN_SCALAR_BINARY_SUPPORTED(pow,typename Derived::Scalar,ScalarExponent)>::type,pow))
+  pow(const Eigen::ArrayBase<Derived>& x, const ScalarExponent& exponent)
+  {
+    typedef typename internal::promote_scalar_arg<typename Derived::Scalar,ScalarExponent,
+                                                  EIGEN_SCALAR_BINARY_SUPPORTED(pow,typename Derived::Scalar,ScalarExponent)>::type PromotedExponent;
+    return EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,PromotedExponent,pow)(x.derived(),
+           typename internal::plain_constant_type<Derived,PromotedExponent>::type(x.derived().rows(), x.derived().cols(), internal::scalar_constant_op<PromotedExponent>(exponent)));
+  }
+#endif
+
+  /** \returns an expression of the coefficient-wise power of \a x to the given array of \a exponents.
+    *
+    * This function computes the coefficient-wise power.
+    *
+    * Example: \include Cwise_array_power_array.cpp
+    * Output: \verbinclude Cwise_array_power_array.out
+    *
+    * \sa ArrayBase::pow()
+    *
+    * \relates ArrayBase
+    */
+  template<typename Derived,typename ExponentDerived>
+  inline const Eigen::CwiseBinaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar, typename ExponentDerived::Scalar>, const Derived, const ExponentDerived>
+  pow(const Eigen::ArrayBase<Derived>& x, const Eigen::ArrayBase<ExponentDerived>& exponents)
+  {
+    return Eigen::CwiseBinaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar, typename ExponentDerived::Scalar>, const Derived, const ExponentDerived>(
+      x.derived(),
+      exponents.derived()
+    );
+  }
+
+  /** \returns an expression of the coefficient-wise power of the scalar \a x to the given array of \a exponents.
+    *
+    * This function computes the coefficient-wise power between a scalar and an array of exponents.
+    *
+    * \tparam Scalar is the scalar type of \a x. It must be compatible with the scalar type of the given array expression (\c Derived::Scalar).
+    *
+    * Example: \include Cwise_scalar_power_array.cpp
+    * Output: \verbinclude Cwise_scalar_power_array.out
+    *
+    * \sa ArrayBase::pow()
+    *
+    * \relates ArrayBase
+    */
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  template<typename Scalar,typename Derived>
+  inline const CwiseBinaryOp<internal::scalar_pow_op<Scalar,Derived::Scalar>,Constant<Scalar>,Derived>
+  pow(const Scalar& x,const Eigen::ArrayBase<Derived>& x);
+#else
+  template <typename Scalar, typename Derived>
+  EIGEN_DEVICE_FUNC inline
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(
+    const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename internal::promote_scalar_arg<typename Derived::Scalar
+                                                 EIGEN_COMMA Scalar EIGEN_COMMA
+                                                 EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type,Derived,pow))
+  pow(const Scalar& x, const Eigen::ArrayBase<Derived>& exponents) {
+    typedef typename internal::promote_scalar_arg<typename Derived::Scalar,Scalar,
+                                                  EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type PromotedScalar;
+    return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedScalar,Derived,pow)(
+           typename internal::plain_constant_type<Derived,PromotedScalar>::type(exponents.derived().rows(), exponents.derived().cols(), internal::scalar_constant_op<PromotedScalar>(x)), exponents.derived());
+  }
+#endif
+
+
+  namespace internal
+  {
+    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(real,scalar_real_op)
+    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(imag,scalar_imag_op)
+    EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs2,scalar_abs2_op)
+  }
+}
+
+// TODO: cleanly disable those functions that are not supported on Array (numext::real_ref, internal::random, internal::isApprox...)
+
+#endif // EIGEN_GLOBAL_FUNCTIONS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/IO.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/IO.h
new file mode 100644
index 00000000..e81c3152
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/IO.h
@@ -0,0 +1,258 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_IO_H
+#define EIGEN_IO_H
+
+namespace Eigen { 
+
+enum { DontAlignCols = 1 };
+enum { StreamPrecision = -1,
+       FullPrecision = -2 };
+
+namespace internal {
+template<typename Derived>
+std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt);
+}
+
+/** \class IOFormat
+  * \ingroup Core_Module
+  *
+  * \brief Stores a set of parameters controlling the way matrices are printed
+  *
+  * List of available parameters:
+  *  - \b precision number of digits for floating point values, or one of the special constants \c StreamPrecision and \c FullPrecision.
+  *                 The default is the special value \c StreamPrecision which means to use the
+  *                 stream's own precision setting, as set for instance using \c cout.precision(3). The other special value
+  *                 \c FullPrecision means that the number of digits will be computed to match the full precision of each floating-point
+  *                 type.
+  *  - \b flags an OR-ed combination of flags, the default value is 0, the only currently available flag is \c DontAlignCols which
+  *             allows to disable the alignment of columns, resulting in faster code.
+  *  - \b coeffSeparator string printed between two coefficients of the same row
+  *  - \b rowSeparator string printed between two rows
+  *  - \b rowPrefix string printed at the beginning of each row
+  *  - \b rowSuffix string printed at the end of each row
+  *  - \b matPrefix string printed at the beginning of the matrix
+  *  - \b matSuffix string printed at the end of the matrix
+  *  - \b fill character printed to fill the empty space in aligned columns
+  *
+  * Example: \include IOFormat.cpp
+  * Output: \verbinclude IOFormat.out
+  *
+  * \sa DenseBase::format(), class WithFormat
+  */
+struct IOFormat
+{
+  /** Default constructor, see class IOFormat for the meaning of the parameters */
+  IOFormat(int _precision = StreamPrecision, int _flags = 0,
+    const std::string& _coeffSeparator = " ",
+    const std::string& _rowSeparator = "\n", const std::string& _rowPrefix="", const std::string& _rowSuffix="",
+    const std::string& _matPrefix="", const std::string& _matSuffix="", const char _fill=' ')
+  : matPrefix(_matPrefix), matSuffix(_matSuffix), rowPrefix(_rowPrefix), rowSuffix(_rowSuffix), rowSeparator(_rowSeparator),
+    rowSpacer(""), coeffSeparator(_coeffSeparator), fill(_fill), precision(_precision), flags(_flags)
+  {
+    // TODO check if rowPrefix, rowSuffix or rowSeparator contains a newline
+    // don't add rowSpacer if columns are not to be aligned
+    if((flags & DontAlignCols))
+      return;
+    int i = int(matSuffix.length())-1;
+    while (i>=0 && matSuffix[i]!='\n')
+    {
+      rowSpacer += ' ';
+      i--;
+    }
+  }
+  std::string matPrefix, matSuffix;
+  std::string rowPrefix, rowSuffix, rowSeparator, rowSpacer;
+  std::string coeffSeparator;
+  char fill;
+  int precision;
+  int flags;
+};
+
+/** \class WithFormat
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression providing matrix output with given format
+  *
+  * \tparam ExpressionType the type of the object on which IO stream operations are performed
+  *
+  * This class represents an expression with stream operators controlled by a given IOFormat.
+  * It is the return type of DenseBase::format()
+  * and most of the time this is the only way it is used.
+  *
+  * See class IOFormat for some examples.
+  *
+  * \sa DenseBase::format(), class IOFormat
+  */
+template<typename ExpressionType>
+class WithFormat
+{
+  public:
+
+    WithFormat(const ExpressionType& matrix, const IOFormat& format)
+      : m_matrix(matrix), m_format(format)
+    {}
+
+    friend std::ostream & operator << (std::ostream & s, const WithFormat& wf)
+    {
+      return internal::print_matrix(s, wf.m_matrix.eval(), wf.m_format);
+    }
+
+  protected:
+    typename ExpressionType::Nested m_matrix;
+    IOFormat m_format;
+};
+
+namespace internal {
+
+// NOTE: This helper is kept for backward compatibility with previous code specializing
+//       this internal::significant_decimals_impl structure. In the future we should directly
+//       call digits10() which has been introduced in July 2016 in 3.3.
+template<typename Scalar>
+struct significant_decimals_impl
+{
+  static inline int run()
+  {
+    return NumTraits<Scalar>::digits10();
+  }
+};
+
+/** \internal
+  * print the matrix \a _m to the output stream \a s using the output format \a fmt */
+template<typename Derived>
+std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt)
+{
+  using internal::is_same;
+  using internal::conditional;
+
+  if(_m.size() == 0)
+  {
+    s << fmt.matPrefix << fmt.matSuffix;
+    return s;
+  }
+  
+  typename Derived::Nested m = _m;
+  typedef typename Derived::Scalar Scalar;
+  typedef typename
+      conditional<
+          is_same<Scalar, char>::value ||
+            is_same<Scalar, unsigned char>::value ||
+            is_same<Scalar, numext::int8_t>::value ||
+            is_same<Scalar, numext::uint8_t>::value,
+          int,
+          typename conditional<
+              is_same<Scalar, std::complex<char> >::value ||
+                is_same<Scalar, std::complex<unsigned char> >::value ||
+                is_same<Scalar, std::complex<numext::int8_t> >::value ||
+                is_same<Scalar, std::complex<numext::uint8_t> >::value,
+              std::complex<int>,
+              const Scalar&
+            >::type
+        >::type PrintType;
+
+  Index width = 0;
+
+  std::streamsize explicit_precision;
+  if(fmt.precision == StreamPrecision)
+  {
+    explicit_precision = 0;
+  }
+  else if(fmt.precision == FullPrecision)
+  {
+    if (NumTraits<Scalar>::IsInteger)
+    {
+      explicit_precision = 0;
+    }
+    else
+    {
+      explicit_precision = significant_decimals_impl<Scalar>::run();
+    }
+  }
+  else
+  {
+    explicit_precision = fmt.precision;
+  }
+
+  std::streamsize old_precision = 0;
+  if(explicit_precision) old_precision = s.precision(explicit_precision);
+
+  bool align_cols = !(fmt.flags & DontAlignCols);
+  if(align_cols)
+  {
+    // compute the largest width
+    for(Index j = 0; j < m.cols(); ++j)
+      for(Index i = 0; i < m.rows(); ++i)
+      {
+        std::stringstream sstr;
+        sstr.copyfmt(s);
+        sstr << static_cast<PrintType>(m.coeff(i,j));
+        width = std::max<Index>(width, Index(sstr.str().length()));
+      }
+  }
+  std::streamsize old_width = s.width();
+  char old_fill_character = s.fill();
+  s << fmt.matPrefix;
+  for(Index i = 0; i < m.rows(); ++i)
+  {
+    if (i)
+      s << fmt.rowSpacer;
+    s << fmt.rowPrefix;
+    if(width) {
+      s.fill(fmt.fill);
+      s.width(width);
+    }
+    s << static_cast<PrintType>(m.coeff(i, 0));
+    for(Index j = 1; j < m.cols(); ++j)
+    {
+      s << fmt.coeffSeparator;
+      if(width) {
+        s.fill(fmt.fill);
+        s.width(width);
+      }
+      s << static_cast<PrintType>(m.coeff(i, j));
+    }
+    s << fmt.rowSuffix;
+    if( i < m.rows() - 1)
+      s << fmt.rowSeparator;
+  }
+  s << fmt.matSuffix;
+  if(explicit_precision) s.precision(old_precision);
+  if(width) {
+    s.fill(old_fill_character);
+    s.width(old_width);
+  }
+  return s;
+}
+
+} // end namespace internal
+
+/** \relates DenseBase
+  *
+  * Outputs the matrix, to the given stream.
+  *
+  * If you wish to print the matrix with a format different than the default, use DenseBase::format().
+  *
+  * It is also possible to change the default format by defining EIGEN_DEFAULT_IO_FORMAT before including Eigen headers.
+  * If not defined, this will automatically be defined to Eigen::IOFormat(), that is the Eigen::IOFormat with default parameters.
+  *
+  * \sa DenseBase::format()
+  */
+template<typename Derived>
+std::ostream & operator <<
+(std::ostream & s,
+ const DenseBase<Derived> & m)
+{
+  return internal::print_matrix(s, m.eval(), EIGEN_DEFAULT_IO_FORMAT);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_IO_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/IndexedView.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/IndexedView.h
new file mode 100644
index 00000000..08476251
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/IndexedView.h
@@ -0,0 +1,237 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INDEXED_VIEW_H
+#define EIGEN_INDEXED_VIEW_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename XprType, typename RowIndices, typename ColIndices>
+struct traits<IndexedView<XprType, RowIndices, ColIndices> >
+ : traits<XprType>
+{
+  enum {
+    RowsAtCompileTime = int(array_size<RowIndices>::value),
+    ColsAtCompileTime = int(array_size<ColIndices>::value),
+    MaxRowsAtCompileTime = RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime) : Dynamic,
+    MaxColsAtCompileTime = ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime) : Dynamic,
+
+    XprTypeIsRowMajor = (int(traits<XprType>::Flags)&RowMajorBit) != 0,
+    IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
+               : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
+               : XprTypeIsRowMajor,
+
+    RowIncr = int(get_compile_time_incr<RowIndices>::value),
+    ColIncr = int(get_compile_time_incr<ColIndices>::value),
+    InnerIncr = IsRowMajor ? ColIncr : RowIncr,
+    OuterIncr = IsRowMajor ? RowIncr : ColIncr,
+
+    HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
+    XprInnerStride = HasSameStorageOrderAsXprType ? int(inner_stride_at_compile_time<XprType>::ret) : int(outer_stride_at_compile_time<XprType>::ret),
+    XprOuterstride = HasSameStorageOrderAsXprType ? int(outer_stride_at_compile_time<XprType>::ret) : int(inner_stride_at_compile_time<XprType>::ret),
+
+    InnerSize = XprTypeIsRowMajor ? ColsAtCompileTime : RowsAtCompileTime,
+    IsBlockAlike = InnerIncr==1 && OuterIncr==1,
+    IsInnerPannel = HasSameStorageOrderAsXprType && is_same<AllRange<InnerSize>,typename conditional<XprTypeIsRowMajor,ColIndices,RowIndices>::type>::value,
+
+    InnerStrideAtCompileTime = InnerIncr<0 || InnerIncr==DynamicIndex || XprInnerStride==Dynamic ? Dynamic : XprInnerStride * InnerIncr,
+    OuterStrideAtCompileTime = OuterIncr<0 || OuterIncr==DynamicIndex || XprOuterstride==Dynamic ? Dynamic : XprOuterstride * OuterIncr,
+
+    ReturnAsScalar = is_same<RowIndices,SingleRange>::value && is_same<ColIndices,SingleRange>::value,
+    ReturnAsBlock = (!ReturnAsScalar) && IsBlockAlike,
+    ReturnAsIndexedView = (!ReturnAsScalar) && (!ReturnAsBlock),
+
+    // FIXME we deal with compile-time strides if and only if we have DirectAccessBit flag,
+    // but this is too strict regarding negative strides...
+    DirectAccessMask = (int(InnerIncr)!=UndefinedIncr && int(OuterIncr)!=UndefinedIncr && InnerIncr>=0 && OuterIncr>=0) ? DirectAccessBit : 0,
+    FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
+    FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
+    FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
+    Flags = (traits<XprType>::Flags & (HereditaryBits | DirectAccessMask )) | FlagsLvalueBit | FlagsRowMajorBit | FlagsLinearAccessBit
+  };
+
+  typedef Block<XprType,RowsAtCompileTime,ColsAtCompileTime,IsInnerPannel> BlockType;
+};
+
+}
+
+template<typename XprType, typename RowIndices, typename ColIndices, typename StorageKind>
+class IndexedViewImpl;
+
+
+/** \class IndexedView
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a non-sequential sub-matrix defined by arbitrary sequences of row and column indices
+  *
+  * \tparam XprType the type of the expression in which we are taking the intersections of sub-rows and sub-columns
+  * \tparam RowIndices the type of the object defining the sequence of row indices
+  * \tparam ColIndices the type of the object defining the sequence of column indices
+  *
+  * This class represents an expression of a sub-matrix (or sub-vector) defined as the intersection
+  * of sub-sets of rows and columns, that are themself defined by generic sequences of row indices \f$ \{r_0,r_1,..r_{m-1}\} \f$
+  * and column indices \f$ \{c_0,c_1,..c_{n-1} \}\f$. Let \f$ A \f$  be the nested matrix, then the resulting matrix \f$ B \f$ has \c m
+  * rows and \c n columns, and its entries are given by: \f$ B(i,j) = A(r_i,c_j) \f$.
+  *
+  * The \c RowIndices and \c ColIndices types must be compatible with the following API:
+  * \code
+  * <integral type> operator[](Index) const;
+  * Index size() const;
+  * \endcode
+  *
+  * Typical supported types thus include:
+  *  - std::vector<int>
+  *  - std::valarray<int>
+  *  - std::array<int>
+  *  - Plain C arrays: int[N]
+  *  - Eigen::ArrayXi
+  *  - decltype(ArrayXi::LinSpaced(...))
+  *  - Any view/expressions of the previous types
+  *  - Eigen::ArithmeticSequence
+  *  - Eigen::internal::AllRange      (helper for Eigen::all)
+  *  - Eigen::internal::SingleRange  (helper for single index)
+  *  - etc.
+  *
+  * In typical usages of %Eigen, this class should never be used directly. It is the return type of
+  * DenseBase::operator()(const RowIndices&, const ColIndices&).
+  *
+  * \sa class Block
+  */
+template<typename XprType, typename RowIndices, typename ColIndices>
+class IndexedView : public IndexedViewImpl<XprType, RowIndices, ColIndices, typename internal::traits<XprType>::StorageKind>
+{
+public:
+  typedef typename IndexedViewImpl<XprType, RowIndices, ColIndices, typename internal::traits<XprType>::StorageKind>::Base Base;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(IndexedView)
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(IndexedView)
+
+  typedef typename internal::ref_selector<XprType>::non_const_type MatrixTypeNested;
+  typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+  template<typename T0, typename T1>
+  IndexedView(XprType& xpr, const T0& rowIndices, const T1& colIndices)
+    : m_xpr(xpr), m_rowIndices(rowIndices), m_colIndices(colIndices)
+  {}
+
+  /** \returns number of rows */
+  Index rows() const { return internal::size(m_rowIndices); }
+
+  /** \returns number of columns */
+  Index cols() const { return internal::size(m_colIndices); }
+
+  /** \returns the nested expression */
+  const typename internal::remove_all<XprType>::type&
+  nestedExpression() const { return m_xpr; }
+
+  /** \returns the nested expression */
+  typename internal::remove_reference<XprType>::type&
+  nestedExpression() { return m_xpr; }
+
+  /** \returns a const reference to the object storing/generating the row indices */
+  const RowIndices& rowIndices() const { return m_rowIndices; }
+
+  /** \returns a const reference to the object storing/generating the column indices */
+  const ColIndices& colIndices() const { return m_colIndices; }
+
+protected:
+  MatrixTypeNested m_xpr;
+  RowIndices m_rowIndices;
+  ColIndices m_colIndices;
+};
+
+
+// Generic API dispatcher
+template<typename XprType, typename RowIndices, typename ColIndices, typename StorageKind>
+class IndexedViewImpl
+  : public internal::generic_xpr_base<IndexedView<XprType, RowIndices, ColIndices> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<IndexedView<XprType, RowIndices, ColIndices> >::type Base;
+};
+
+namespace internal {
+
+
+template<typename ArgType, typename RowIndices, typename ColIndices>
+struct unary_evaluator<IndexedView<ArgType, RowIndices, ColIndices>, IndexBased>
+  : evaluator_base<IndexedView<ArgType, RowIndices, ColIndices> >
+{
+  typedef IndexedView<ArgType, RowIndices, ColIndices> XprType;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost /* TODO + cost of row/col index */,
+
+    FlagsLinearAccessBit = (traits<XprType>::RowsAtCompileTime == 1 || traits<XprType>::ColsAtCompileTime == 1) ? LinearAccessBit : 0,
+
+    FlagsRowMajorBit = traits<XprType>::FlagsRowMajorBit, 
+
+    Flags = (evaluator<ArgType>::Flags & (HereditaryBits & ~RowMajorBit /*| LinearAccessBit | DirectAccessBit*/)) | FlagsLinearAccessBit | FlagsRowMajorBit,
+
+    Alignment = 0
+  };
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_xpr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeff(Index row, Index col) const
+  {
+    return m_argImpl.coeff(m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index row, Index col)
+  {
+    return m_argImpl.coeffRef(m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Scalar& coeffRef(Index index)
+  {
+    EIGEN_STATIC_ASSERT_LVALUE(XprType)
+    Index row = XprType::RowsAtCompileTime == 1 ? 0 : index;
+    Index col = XprType::RowsAtCompileTime == 1 ? index : 0;
+    return m_argImpl.coeffRef( m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar& coeffRef(Index index) const
+  {
+    Index row = XprType::RowsAtCompileTime == 1 ? 0 : index;
+    Index col = XprType::RowsAtCompileTime == 1 ? index : 0;
+    return m_argImpl.coeffRef( m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const CoeffReturnType coeff(Index index) const
+  {
+    Index row = XprType::RowsAtCompileTime == 1 ? 0 : index;
+    Index col = XprType::RowsAtCompileTime == 1 ? index : 0;
+    return m_argImpl.coeff( m_xpr.rowIndices()[row], m_xpr.colIndices()[col]);
+  }
+
+protected:
+
+  evaluator<ArgType> m_argImpl;
+  const XprType& m_xpr;
+
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_INDEXED_VIEW_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Inverse.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Inverse.h
new file mode 100644
index 00000000..c514438c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Inverse.h
@@ -0,0 +1,117 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014-2019 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INVERSE_H
+#define EIGEN_INVERSE_H
+
+namespace Eigen {
+
+template<typename XprType,typename StorageKind> class InverseImpl;
+
+namespace internal {
+
+template<typename XprType>
+struct traits<Inverse<XprType> >
+  : traits<typename XprType::PlainObject>
+{
+  typedef typename XprType::PlainObject PlainObject;
+  typedef traits<PlainObject> BaseTraits;
+  enum {
+    Flags = BaseTraits::Flags & RowMajorBit
+  };
+};
+
+} // end namespace internal
+
+/** \class Inverse
+  *
+  * \brief Expression of the inverse of another expression
+  *
+  * \tparam XprType the type of the expression we are taking the inverse
+  *
+  * This class represents an abstract expression of A.inverse()
+  * and most of the time this is the only way it is used.
+  *
+  */
+template<typename XprType>
+class Inverse : public InverseImpl<XprType,typename internal::traits<XprType>::StorageKind>
+{
+public:
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename XprType::Scalar                            Scalar;
+  typedef typename internal::ref_selector<XprType>::type      XprTypeNested;
+  typedef typename internal::remove_all<XprTypeNested>::type  XprTypeNestedCleaned;
+  typedef typename internal::ref_selector<Inverse>::type Nested;
+  typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+  explicit EIGEN_DEVICE_FUNC Inverse(const XprType &xpr)
+    : m_xpr(xpr)
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR  Index rows() const EIGEN_NOEXCEPT { return m_xpr.cols(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR  Index cols() const EIGEN_NOEXCEPT { return m_xpr.rows(); }
+
+  EIGEN_DEVICE_FUNC const XprTypeNestedCleaned& nestedExpression() const { return m_xpr; }
+
+protected:
+  XprTypeNested m_xpr;
+};
+
+// Generic API dispatcher
+template<typename XprType, typename StorageKind>
+class InverseImpl
+  : public internal::generic_xpr_base<Inverse<XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<Inverse<XprType> >::type Base;
+  typedef typename XprType::Scalar Scalar;
+private:
+
+  Scalar coeff(Index row, Index col) const;
+  Scalar coeff(Index i) const;
+};
+
+namespace internal {
+
+/** \internal
+  * \brief Default evaluator for Inverse expression.
+  *
+  * This default evaluator for Inverse expression simply evaluate the inverse into a temporary
+  * by a call to internal::call_assignment_no_alias.
+  * Therefore, inverse implementers only have to specialize Assignment<Dst,Inverse<...>, ...> for
+  * there own nested expression.
+  *
+  * \sa class Inverse
+  */
+template<typename ArgType>
+struct unary_evaluator<Inverse<ArgType> >
+  : public evaluator<typename Inverse<ArgType>::PlainObject>
+{
+  typedef Inverse<ArgType> InverseType;
+  typedef typename InverseType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum { Flags = Base::Flags | EvalBeforeNestingBit };
+
+  unary_evaluator(const InverseType& inv_xpr)
+    : m_result(inv_xpr.rows(), inv_xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    internal::call_assignment_no_alias(m_result, inv_xpr);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_INVERSE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Map.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Map.h
new file mode 100644
index 00000000..218cc157
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Map.h
@@ -0,0 +1,171 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MAP_H
+#define EIGEN_MAP_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename PlainObjectType, int MapOptions, typename StrideType>
+struct traits<Map<PlainObjectType, MapOptions, StrideType> >
+  : public traits<PlainObjectType>
+{
+  typedef traits<PlainObjectType> TraitsBase;
+  enum {
+    PlainObjectTypeInnerSize = ((traits<PlainObjectType>::Flags&RowMajorBit)==RowMajorBit)
+                             ? PlainObjectType::ColsAtCompileTime
+                             : PlainObjectType::RowsAtCompileTime,
+
+    InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
+                             ? int(PlainObjectType::InnerStrideAtCompileTime)
+                             : int(StrideType::InnerStrideAtCompileTime),
+    OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
+                             ? (InnerStrideAtCompileTime==Dynamic || PlainObjectTypeInnerSize==Dynamic
+                                ? Dynamic
+                                : int(InnerStrideAtCompileTime) * int(PlainObjectTypeInnerSize))
+                             : int(StrideType::OuterStrideAtCompileTime),
+    Alignment = int(MapOptions)&int(AlignedMask),
+    Flags0 = TraitsBase::Flags & (~NestByRefBit),
+    Flags = is_lvalue<PlainObjectType>::value ? int(Flags0) : (int(Flags0) & ~LvalueBit)
+  };
+private:
+  enum { Options }; // Expressions don't have Options
+};
+}
+
+/** \class Map
+  * \ingroup Core_Module
+  *
+  * \brief A matrix or vector expression mapping an existing array of data.
+  *
+  * \tparam PlainObjectType the equivalent matrix type of the mapped data
+  * \tparam MapOptions specifies the pointer alignment in bytes. It can be: \c #Aligned128, \c #Aligned64, \c #Aligned32, \c #Aligned16, \c #Aligned8 or \c #Unaligned.
+  *                The default is \c #Unaligned.
+  * \tparam StrideType optionally specifies strides. By default, Map assumes the memory layout
+  *                   of an ordinary, contiguous array. This can be overridden by specifying strides.
+  *                   The type passed here must be a specialization of the Stride template, see examples below.
+  *
+  * This class represents a matrix or vector expression mapping an existing array of data.
+  * It can be used to let Eigen interface without any overhead with non-Eigen data structures,
+  * such as plain C arrays or structures from other libraries. By default, it assumes that the
+  * data is laid out contiguously in memory. You can however override this by explicitly specifying
+  * inner and outer strides.
+  *
+  * Here's an example of simply mapping a contiguous array as a \ref TopicStorageOrders "column-major" matrix:
+  * \include Map_simple.cpp
+  * Output: \verbinclude Map_simple.out
+  *
+  * If you need to map non-contiguous arrays, you can do so by specifying strides:
+  *
+  * Here's an example of mapping an array as a vector, specifying an inner stride, that is, the pointer
+  * increment between two consecutive coefficients. Here, we're specifying the inner stride as a compile-time
+  * fixed value.
+  * \include Map_inner_stride.cpp
+  * Output: \verbinclude Map_inner_stride.out
+  *
+  * Here's an example of mapping an array while specifying an outer stride. Here, since we're mapping
+  * as a column-major matrix, 'outer stride' means the pointer increment between two consecutive columns.
+  * Here, we're specifying the outer stride as a runtime parameter. Note that here \c OuterStride<> is
+  * a short version of \c OuterStride<Dynamic> because the default template parameter of OuterStride
+  * is  \c Dynamic
+  * \include Map_outer_stride.cpp
+  * Output: \verbinclude Map_outer_stride.out
+  *
+  * For more details and for an example of specifying both an inner and an outer stride, see class Stride.
+  *
+  * \b Tip: to change the array of data mapped by a Map object, you can use the C++
+  * placement new syntax:
+  *
+  * Example: \include Map_placement_new.cpp
+  * Output: \verbinclude Map_placement_new.out
+  *
+  * This class is the return type of PlainObjectBase::Map() but can also be used directly.
+  *
+  * \sa PlainObjectBase::Map(), \ref TopicStorageOrders
+  */
+template<typename PlainObjectType, int MapOptions, typename StrideType> class Map
+  : public MapBase<Map<PlainObjectType, MapOptions, StrideType> >
+{
+  public:
+
+    typedef MapBase<Map> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Map)
+
+    typedef typename Base::PointerType PointerType;
+    typedef PointerType PointerArgType;
+    EIGEN_DEVICE_FUNC
+    inline PointerType cast_to_pointer_type(PointerArgType ptr) { return ptr; }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const
+    {
+      return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const
+    {
+      return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
+           : internal::traits<Map>::OuterStrideAtCompileTime != Dynamic ? Index(internal::traits<Map>::OuterStrideAtCompileTime)
+           : IsVectorAtCompileTime ? (this->size() * innerStride())
+           : int(Flags)&RowMajorBit ? (this->cols() * innerStride())
+           : (this->rows() * innerStride());
+    }
+
+    /** Constructor in the fixed-size case.
+      *
+      * \param dataPtr pointer to the array to map
+      * \param stride optional Stride object, passing the strides.
+      */
+    EIGEN_DEVICE_FUNC
+    explicit inline Map(PointerArgType dataPtr, const StrideType& stride = StrideType())
+      : Base(cast_to_pointer_type(dataPtr)), m_stride(stride)
+    {
+      PlainObjectType::Base::_check_template_params();
+    }
+
+    /** Constructor in the dynamic-size vector case.
+      *
+      * \param dataPtr pointer to the array to map
+      * \param size the size of the vector expression
+      * \param stride optional Stride object, passing the strides.
+      */
+    EIGEN_DEVICE_FUNC
+    inline Map(PointerArgType dataPtr, Index size, const StrideType& stride = StrideType())
+      : Base(cast_to_pointer_type(dataPtr), size), m_stride(stride)
+    {
+      PlainObjectType::Base::_check_template_params();
+    }
+
+    /** Constructor in the dynamic-size matrix case.
+      *
+      * \param dataPtr pointer to the array to map
+      * \param rows the number of rows of the matrix expression
+      * \param cols the number of columns of the matrix expression
+      * \param stride optional Stride object, passing the strides.
+      */
+    EIGEN_DEVICE_FUNC
+    inline Map(PointerArgType dataPtr, Index rows, Index cols, const StrideType& stride = StrideType())
+      : Base(cast_to_pointer_type(dataPtr), rows, cols), m_stride(stride)
+    {
+      PlainObjectType::Base::_check_template_params();
+    }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
+
+  protected:
+    StrideType m_stride;
+};
+
+
+} // end namespace Eigen
+
+#endif // EIGEN_MAP_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/MapBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/MapBase.h
new file mode 100644
index 00000000..d856447f
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/MapBase.h
@@ -0,0 +1,310 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MAPBASE_H
+#define EIGEN_MAPBASE_H
+
+#define EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) \
+      EIGEN_STATIC_ASSERT((int(internal::evaluator<Derived>::Flags) & LinearAccessBit) || Derived::IsVectorAtCompileTime, \
+                          YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT)
+
+namespace Eigen {
+
+/** \ingroup Core_Module
+  *
+  * \brief Base class for dense Map and Block expression with direct access
+  *
+  * This base class provides the const low-level accessors (e.g. coeff, coeffRef) of dense
+  * Map and Block objects with direct access.
+  * Typical users do not have to directly deal with this class.
+  *
+  * This class can be extended by through the macro plugin \c EIGEN_MAPBASE_PLUGIN.
+  * See \link TopicCustomizing_Plugins customizing Eigen \endlink for details.
+  *
+  * The \c Derived class has to provide the following two methods describing the memory layout:
+  *  \code Index innerStride() const; \endcode
+  *  \code Index outerStride() const; \endcode
+  *
+  * \sa class Map, class Block
+  */
+template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
+  : public internal::dense_xpr_base<Derived>::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<Derived>::type Base;
+    enum {
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      InnerStrideAtCompileTime = internal::traits<Derived>::InnerStrideAtCompileTime,
+      SizeAtCompileTime = Base::SizeAtCompileTime
+    };
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef typename internal::conditional<
+                         bool(internal::is_lvalue<Derived>::value),
+                         Scalar *,
+                         const Scalar *>::type
+                     PointerType;
+
+    using Base::derived;
+//    using Base::RowsAtCompileTime;
+//    using Base::ColsAtCompileTime;
+//    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+    using Base::IsRowMajor;
+
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+    using Base::lazyAssign;
+    using Base::eval;
+
+    using Base::innerStride;
+    using Base::outerStride;
+    using Base::rowStride;
+    using Base::colStride;
+
+    // bug 217 - compile error on ICC 11.1
+    using Base::operator=;
+
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+
+    /** \copydoc DenseBase::rows() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_rows.value(); }
+    /** \copydoc DenseBase::cols() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_cols.value(); }
+
+    /** Returns a pointer to the first coefficient of the matrix or vector.
+      *
+      * \note When addressing this data, make sure to honor the strides returned by innerStride() and outerStride().
+      *
+      * \sa innerStride(), outerStride()
+      */
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const { return m_data; }
+
+    /** \copydoc PlainObjectBase::coeff(Index,Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeff(Index rowId, Index colId) const
+    {
+      return m_data[colId * colStride() + rowId * rowStride()];
+    }
+
+    /** \copydoc PlainObjectBase::coeff(Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeff(Index index) const
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return m_data[index * innerStride()];
+    }
+
+    /** \copydoc PlainObjectBase::coeffRef(Index,Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return this->m_data[colId * colStride() + rowId * rowStride()];
+    }
+
+    /** \copydoc PlainObjectBase::coeffRef(Index) const */
+    EIGEN_DEVICE_FUNC
+    inline const Scalar& coeffRef(Index index) const
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return this->m_data[index * innerStride()];
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    inline PacketScalar packet(Index rowId, Index colId) const
+    {
+      return internal::ploadt<PacketScalar, LoadMode>
+               (m_data + (colId * colStride() + rowId * rowStride()));
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    inline PacketScalar packet(Index index) const
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride());
+    }
+
+    /** \internal Constructor for fixed size matrices or vectors */
+    EIGEN_DEVICE_FUNC
+    explicit inline MapBase(PointerType dataPtr) : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime)
+    {
+      EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
+      checkSanity<Derived>();
+    }
+
+    /** \internal Constructor for dynamically sized vectors */
+    EIGEN_DEVICE_FUNC
+    inline MapBase(PointerType dataPtr, Index vecSize)
+            : m_data(dataPtr),
+              m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)),
+              m_cols(ColsAtCompileTime == Dynamic ? vecSize : Index(ColsAtCompileTime))
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+      eigen_assert(vecSize >= 0);
+      eigen_assert(dataPtr == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == vecSize);
+      checkSanity<Derived>();
+    }
+
+    /** \internal Constructor for dynamically sized matrices */
+    EIGEN_DEVICE_FUNC
+    inline MapBase(PointerType dataPtr, Index rows, Index cols)
+            : m_data(dataPtr), m_rows(rows), m_cols(cols)
+    {
+      eigen_assert( (dataPtr == 0)
+              || (   rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
+                  && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)));
+      checkSanity<Derived>();
+    }
+
+    #ifdef EIGEN_MAPBASE_PLUGIN
+    #include EIGEN_MAPBASE_PLUGIN
+    #endif
+
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(MapBase)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(MapBase)
+
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    void checkSanity(typename internal::enable_if<(internal::traits<T>::Alignment>0),void*>::type = 0) const
+    {
+#if EIGEN_MAX_ALIGN_BYTES>0
+      // innerStride() is not set yet when this function is called, so we optimistically assume the lowest plausible value:
+      const Index minInnerStride = InnerStrideAtCompileTime == Dynamic ? 1 : Index(InnerStrideAtCompileTime);
+      EIGEN_ONLY_USED_FOR_DEBUG(minInnerStride);
+      eigen_assert((   ((internal::UIntPtr(m_data) % internal::traits<Derived>::Alignment) == 0)
+                    || (cols() * rows() * minInnerStride * sizeof(Scalar)) < internal::traits<Derived>::Alignment ) && "data is not aligned");
+#endif
+    }
+
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    void checkSanity(typename internal::enable_if<internal::traits<T>::Alignment==0,void*>::type = 0) const
+    {}
+
+    PointerType m_data;
+    const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
+    const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
+};
+
+/** \ingroup Core_Module
+  *
+  * \brief Base class for non-const dense Map and Block expression with direct access
+  *
+  * This base class provides the non-const low-level accessors (e.g. coeff and coeffRef) of
+  * dense Map and Block objects with direct access.
+  * It inherits MapBase<Derived, ReadOnlyAccessors> which defines the const variant for reading specific entries.
+  *
+  * \sa class Map, class Block
+  */
+template<typename Derived> class MapBase<Derived, WriteAccessors>
+  : public MapBase<Derived, ReadOnlyAccessors>
+{
+    typedef MapBase<Derived, ReadOnlyAccessors> ReadOnlyMapBase;
+  public:
+
+    typedef MapBase<Derived, ReadOnlyAccessors> Base;
+
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::PacketScalar PacketScalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    typedef typename Base::PointerType PointerType;
+
+    using Base::derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+
+    using Base::innerStride;
+    using Base::outerStride;
+    using Base::rowStride;
+    using Base::colStride;
+
+    typedef typename internal::conditional<
+                    internal::is_lvalue<Derived>::value,
+                    Scalar,
+                    const Scalar
+                  >::type ScalarWithConstIfNotLvalue;
+
+    EIGEN_DEVICE_FUNC
+    inline const Scalar* data() const { return this->m_data; }
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue& coeffRef(Index row, Index col)
+    {
+      return this->m_data[col * colStride() + row * rowStride()];
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline ScalarWithConstIfNotLvalue& coeffRef(Index index)
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      return this->m_data[index * innerStride()];
+    }
+
+    template<int StoreMode>
+    inline void writePacket(Index row, Index col, const PacketScalar& val)
+    {
+      internal::pstoret<Scalar, PacketScalar, StoreMode>
+               (this->m_data + (col * colStride() + row * rowStride()), val);
+    }
+
+    template<int StoreMode>
+    inline void writePacket(Index index, const PacketScalar& val)
+    {
+      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
+      internal::pstoret<Scalar, PacketScalar, StoreMode>
+                (this->m_data + index * innerStride(), val);
+    }
+
+    EIGEN_DEVICE_FUNC explicit inline MapBase(PointerType dataPtr) : Base(dataPtr) {}
+    EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index vecSize) : Base(dataPtr, vecSize) {}
+    EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index rows, Index cols) : Base(dataPtr, rows, cols) {}
+
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const MapBase& other)
+    {
+      ReadOnlyMapBase::Base::operator=(other);
+      return derived();
+    }
+
+    // In theory we could simply refer to Base:Base::operator=, but MSVC does not like Base::Base,
+    // see bugs 821 and 920.
+    using ReadOnlyMapBase::Base::operator=;
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(MapBase)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(MapBase)
+};
+
+#undef EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS
+
+} // end namespace Eigen
+
+#endif // EIGEN_MAPBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/MathFunctions.h
new file mode 100644
index 00000000..61b78f4f
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/MathFunctions.h
@@ -0,0 +1,2057 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATHFUNCTIONS_H
+#define EIGEN_MATHFUNCTIONS_H
+
+// TODO this should better be moved to NumTraits
+// Source: WolframAlpha
+#define EIGEN_PI    3.141592653589793238462643383279502884197169399375105820974944592307816406L
+#define EIGEN_LOG2E 1.442695040888963407359924681001892137426645954152985934135449406931109219L
+#define EIGEN_LN2   0.693147180559945309417232121458176568075500134360255254120680009493393621L
+
+namespace Eigen {
+
+// On WINCE, std::abs is defined for int only, so let's defined our own overloads:
+// This issue has been confirmed with MSVC 2008 only, but the issue might exist for more recent versions too.
+#if EIGEN_OS_WINCE && EIGEN_COMP_MSVC && EIGEN_COMP_MSVC<=1500
+long        abs(long        x) { return (labs(x));  }
+double      abs(double      x) { return (fabs(x));  }
+float       abs(float       x) { return (fabsf(x)); }
+long double abs(long double x) { return (fabsl(x)); }
+#endif
+
+namespace internal {
+
+/** \internal \class global_math_functions_filtering_base
+  *
+  * What it does:
+  * Defines a typedef 'type' as follows:
+  * - if type T has a member typedef Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl, then
+  *   global_math_functions_filtering_base<T>::type is a typedef for it.
+  * - otherwise, global_math_functions_filtering_base<T>::type is a typedef for T.
+  *
+  * How it's used:
+  * To allow to defined the global math functions (like sin...) in certain cases, like the Array expressions.
+  * When you do sin(array1+array2), the object array1+array2 has a complicated expression type, all what you want to know
+  * is that it inherits ArrayBase. So we implement a partial specialization of sin_impl for ArrayBase<Derived>.
+  * So we must make sure to use sin_impl<ArrayBase<Derived> > and not sin_impl<Derived>, otherwise our partial specialization
+  * won't be used. How does sin know that? That's exactly what global_math_functions_filtering_base tells it.
+  *
+  * How it's implemented:
+  * SFINAE in the style of enable_if. Highly susceptible of breaking compilers. With GCC, it sure does work, but if you replace
+  * the typename dummy by an integer template parameter, it doesn't work anymore!
+  */
+
+template<typename T, typename dummy = void>
+struct global_math_functions_filtering_base
+{
+  typedef T type;
+};
+
+template<typename T> struct always_void { typedef void type; };
+
+template<typename T>
+struct global_math_functions_filtering_base
+  <T,
+   typename always_void<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>::type
+  >
+{
+  typedef typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl type;
+};
+
+#define EIGEN_MATHFUNC_IMPL(func, scalar) Eigen::internal::func##_impl<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>
+#define EIGEN_MATHFUNC_RETVAL(func, scalar) typename Eigen::internal::func##_retval<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>::type
+
+/****************************************************************************
+* Implementation of real                                                 *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct real_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return x;
+  }
+};
+
+template<typename Scalar>
+struct real_default_impl<Scalar,true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    using std::real;
+    return real(x);
+  }
+};
+
+template<typename Scalar> struct real_impl : real_default_impl<Scalar> {};
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+template<typename T>
+struct real_impl<std::complex<T> >
+{
+  typedef T RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline T run(const std::complex<T>& x)
+  {
+    return x.real();
+  }
+};
+#endif
+
+template<typename Scalar>
+struct real_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of imag                                                 *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct imag_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar&)
+  {
+    return RealScalar(0);
+  }
+};
+
+template<typename Scalar>
+struct imag_default_impl<Scalar,true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    using std::imag;
+    return imag(x);
+  }
+};
+
+template<typename Scalar> struct imag_impl : imag_default_impl<Scalar> {};
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+template<typename T>
+struct imag_impl<std::complex<T> >
+{
+  typedef T RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline T run(const std::complex<T>& x)
+  {
+    return x.imag();
+  }
+};
+#endif
+
+template<typename Scalar>
+struct imag_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of real_ref                                             *
+****************************************************************************/
+
+template<typename Scalar>
+struct real_ref_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar& run(Scalar& x)
+  {
+    return reinterpret_cast<RealScalar*>(&x)[0];
+  }
+  EIGEN_DEVICE_FUNC
+  static inline const RealScalar& run(const Scalar& x)
+  {
+    return reinterpret_cast<const RealScalar*>(&x)[0];
+  }
+};
+
+template<typename Scalar>
+struct real_ref_retval
+{
+  typedef typename NumTraits<Scalar>::Real & type;
+};
+
+/****************************************************************************
+* Implementation of imag_ref                                             *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex>
+struct imag_ref_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar& run(Scalar& x)
+  {
+    return reinterpret_cast<RealScalar*>(&x)[1];
+  }
+  EIGEN_DEVICE_FUNC
+  static inline const RealScalar& run(const Scalar& x)
+  {
+    return reinterpret_cast<RealScalar*>(&x)[1];
+  }
+};
+
+template<typename Scalar>
+struct imag_ref_default_impl<Scalar, false>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline Scalar run(Scalar&)
+  {
+    return Scalar(0);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline const Scalar run(const Scalar&)
+  {
+    return Scalar(0);
+  }
+};
+
+template<typename Scalar>
+struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
+
+template<typename Scalar>
+struct imag_ref_retval
+{
+  typedef typename NumTraits<Scalar>::Real & type;
+};
+
+/****************************************************************************
+* Implementation of conj                                                 *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct conj_default_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    return x;
+  }
+};
+
+template<typename Scalar>
+struct conj_default_impl<Scalar,true>
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    using std::conj;
+    return conj(x);
+  }
+};
+
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct conj_impl : conj_default_impl<Scalar, IsComplex> {};
+
+template<typename Scalar>
+struct conj_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of abs2                                                 *
+****************************************************************************/
+
+template<typename Scalar,bool IsComplex>
+struct abs2_impl_default
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return x*x;
+  }
+};
+
+template<typename Scalar>
+struct abs2_impl_default<Scalar, true> // IsComplex
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return x.real()*x.real() + x.imag()*x.imag();
+  }
+};
+
+template<typename Scalar>
+struct abs2_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return abs2_impl_default<Scalar,NumTraits<Scalar>::IsComplex>::run(x);
+  }
+};
+
+template<typename Scalar>
+struct abs2_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of sqrt/rsqrt                                             *
+****************************************************************************/
+
+template<typename Scalar>
+struct sqrt_impl
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE Scalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD(sqrt);
+    return sqrt(x);
+  }
+};
+
+// Complex sqrt defined in MathFunctionsImpl.h.
+template<typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_sqrt(const std::complex<T>& a_x);
+
+// Custom implementation is faster than `std::sqrt`, works on
+// GPU, and correctly handles special cases (unlike MSVC).
+template<typename T>
+struct sqrt_impl<std::complex<T> >
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE std::complex<T> run(const std::complex<T>& x)
+  {
+    return complex_sqrt<T>(x);
+  }
+};
+
+template<typename Scalar>
+struct sqrt_retval
+{
+  typedef Scalar type;
+};
+
+// Default implementation relies on numext::sqrt, at bottom of file.
+template<typename T>
+struct rsqrt_impl;
+
+// Complex rsqrt defined in MathFunctionsImpl.h.
+template<typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_rsqrt(const std::complex<T>& a_x);
+
+template<typename T>
+struct rsqrt_impl<std::complex<T> >
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE std::complex<T> run(const std::complex<T>& x)
+  {
+    return complex_rsqrt<T>(x);
+  }
+};
+
+template<typename Scalar>
+struct rsqrt_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of norm1                                                *
+****************************************************************************/
+
+template<typename Scalar, bool IsComplex>
+struct norm1_default_impl;
+
+template<typename Scalar>
+struct norm1_default_impl<Scalar,true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD(abs);
+    return abs(x.real()) + abs(x.imag());
+  }
+};
+
+template<typename Scalar>
+struct norm1_default_impl<Scalar, false>
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD(abs);
+    return abs(x);
+  }
+};
+
+template<typename Scalar>
+struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
+
+template<typename Scalar>
+struct norm1_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of hypot                                                *
+****************************************************************************/
+
+template<typename Scalar> struct hypot_impl;
+
+template<typename Scalar>
+struct hypot_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of cast                                                 *
+****************************************************************************/
+
+template<typename OldType, typename NewType, typename EnableIf = void>
+struct cast_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline NewType run(const OldType& x)
+  {
+    return static_cast<NewType>(x);
+  }
+};
+
+// Casting from S -> Complex<T> leads to an implicit conversion from S to T,
+// generating warnings on clang.  Here we explicitly cast the real component.
+template<typename OldType, typename NewType>
+struct cast_impl<OldType, NewType,
+  typename internal::enable_if<
+    !NumTraits<OldType>::IsComplex && NumTraits<NewType>::IsComplex
+  >::type>
+{
+  EIGEN_DEVICE_FUNC
+  static inline NewType run(const OldType& x)
+  {
+    typedef typename NumTraits<NewType>::Real NewReal;
+    return static_cast<NewType>(static_cast<NewReal>(x));
+  }
+};
+
+// here, for once, we're plainly returning NewType: we don't want cast to do weird things.
+
+template<typename OldType, typename NewType>
+EIGEN_DEVICE_FUNC
+inline NewType cast(const OldType& x)
+{
+  return cast_impl<OldType, NewType>::run(x);
+}
+
+/****************************************************************************
+* Implementation of round                                                   *
+****************************************************************************/
+
+template<typename Scalar>
+struct round_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
+#if EIGEN_HAS_CXX11_MATH
+    EIGEN_USING_STD(round);
+#endif
+    return Scalar(round(x));
+  }
+};
+
+#if !EIGEN_HAS_CXX11_MATH
+#if EIGEN_HAS_C99_MATH
+// Use ::roundf for float.
+template<>
+struct round_impl<float> {
+  EIGEN_DEVICE_FUNC
+  static inline float run(const float& x)
+  {
+    return ::roundf(x);
+  }
+};
+#else
+template<typename Scalar>
+struct round_using_floor_ceil_impl
+{
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
+    // Without C99 round/roundf, resort to floor/ceil.
+    EIGEN_USING_STD(floor);
+    EIGEN_USING_STD(ceil);
+    // If not enough precision to resolve a decimal at all, return the input.
+    // Otherwise, adding 0.5 can trigger an increment by 1.
+    const Scalar limit = Scalar(1ull << (NumTraits<Scalar>::digits() - 1));
+    if (x >= limit || x <= -limit) {
+      return x;
+    }
+    return (x > Scalar(0)) ? Scalar(floor(x + Scalar(0.5))) : Scalar(ceil(x - Scalar(0.5)));
+  }
+};
+
+template<>
+struct round_impl<float> : round_using_floor_ceil_impl<float> {};
+
+template<>
+struct round_impl<double> : round_using_floor_ceil_impl<double> {};
+#endif // EIGEN_HAS_C99_MATH
+#endif // !EIGEN_HAS_CXX11_MATH
+
+template<typename Scalar>
+struct round_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of rint                                                    *
+****************************************************************************/
+
+template<typename Scalar>
+struct rint_impl {
+  EIGEN_DEVICE_FUNC
+  static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
+#if EIGEN_HAS_CXX11_MATH
+      EIGEN_USING_STD(rint);
+#endif
+    return rint(x);
+  }
+};
+
+#if !EIGEN_HAS_CXX11_MATH
+template<>
+struct rint_impl<double> {
+  EIGEN_DEVICE_FUNC
+  static inline double run(const double& x)
+  {
+    return ::rint(x);
+  }
+};
+template<>
+struct rint_impl<float> {
+  EIGEN_DEVICE_FUNC
+  static inline float run(const float& x)
+  {
+    return ::rintf(x);
+  }
+};
+#endif
+
+template<typename Scalar>
+struct rint_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of arg                                                     *
+****************************************************************************/
+
+// Visual Studio 2017 has a bug where arg(float) returns 0 for negative inputs.
+// This seems to be fixed in VS 2019.
+#if EIGEN_HAS_CXX11_MATH && (!EIGEN_COMP_MSVC || EIGEN_COMP_MSVC >= 1920)
+// std::arg is only defined for types of std::complex, or integer types or float/double/long double
+template<typename Scalar,
+          bool HasStdImpl = NumTraits<Scalar>::IsComplex || is_integral<Scalar>::value
+                            || is_same<Scalar, float>::value || is_same<Scalar, double>::value
+                            || is_same<Scalar, long double>::value >
+struct arg_default_impl;
+
+template<typename Scalar>
+struct arg_default_impl<Scalar, true> {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    #if defined(EIGEN_HIP_DEVICE_COMPILE)
+    // HIP does not seem to have a native device side implementation for the math routine "arg"
+    using std::arg;
+    #else
+    EIGEN_USING_STD(arg);
+    #endif
+    return static_cast<RealScalar>(arg(x));
+  }
+};
+
+// Must be non-complex floating-point type (e.g. half/bfloat16).
+template<typename Scalar>
+struct arg_default_impl<Scalar, false> {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return (x < Scalar(0)) ? RealScalar(EIGEN_PI) : RealScalar(0);
+  }
+};
+#else
+template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct arg_default_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    return (x < RealScalar(0)) ? RealScalar(EIGEN_PI) : RealScalar(0);
+  }
+};
+
+template<typename Scalar>
+struct arg_default_impl<Scalar,true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline RealScalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD(arg);
+    return arg(x);
+  }
+};
+#endif
+template<typename Scalar> struct arg_impl : arg_default_impl<Scalar> {};
+
+template<typename Scalar>
+struct arg_retval
+{
+  typedef typename NumTraits<Scalar>::Real type;
+};
+
+/****************************************************************************
+* Implementation of expm1                                                   *
+****************************************************************************/
+
+// This implementation is based on GSL Math's expm1.
+namespace std_fallback {
+  // fallback expm1 implementation in case there is no expm1(Scalar) function in namespace of Scalar,
+  // or that there is no suitable std::expm1 function available. Implementation
+  // attributed to Kahan. See: http://www.plunk.org/~hatch/rightway.php.
+  template<typename Scalar>
+  EIGEN_DEVICE_FUNC inline Scalar expm1(const Scalar& x) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    EIGEN_USING_STD(exp);
+    Scalar u = exp(x);
+    if (numext::equal_strict(u, Scalar(1))) {
+      return x;
+    }
+    Scalar um1 = u - RealScalar(1);
+    if (numext::equal_strict(um1, Scalar(-1))) {
+      return RealScalar(-1);
+    }
+
+    EIGEN_USING_STD(log);
+    Scalar logu = log(u);
+    return numext::equal_strict(u, logu) ? u : (u - RealScalar(1)) * x / logu;
+  }
+}
+
+template<typename Scalar>
+struct expm1_impl {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    #if EIGEN_HAS_CXX11_MATH
+    using std::expm1;
+    #else
+    using std_fallback::expm1;
+    #endif
+    return expm1(x);
+  }
+};
+
+template<typename Scalar>
+struct expm1_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of log                                                     *
+****************************************************************************/
+
+// Complex log defined in MathFunctionsImpl.h.
+template<typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_log(const std::complex<T>& z);
+
+template<typename Scalar>
+struct log_impl {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_USING_STD(log);
+    return static_cast<Scalar>(log(x));
+  }
+};
+
+template<typename Scalar>
+struct log_impl<std::complex<Scalar> > {
+  EIGEN_DEVICE_FUNC static inline std::complex<Scalar> run(const std::complex<Scalar>& z)
+  {
+    return complex_log(z);
+  }
+};
+
+/****************************************************************************
+* Implementation of log1p                                                   *
+****************************************************************************/
+
+namespace std_fallback {
+  // fallback log1p implementation in case there is no log1p(Scalar) function in namespace of Scalar,
+  // or that there is no suitable std::log1p function available
+  template<typename Scalar>
+  EIGEN_DEVICE_FUNC inline Scalar log1p(const Scalar& x) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    EIGEN_USING_STD(log);
+    Scalar x1p = RealScalar(1) + x;
+    Scalar log_1p = log_impl<Scalar>::run(x1p);
+    const bool is_small = numext::equal_strict(x1p, Scalar(1));
+    const bool is_inf = numext::equal_strict(x1p, log_1p);
+    return (is_small || is_inf) ? x : x * (log_1p / (x1p - RealScalar(1)));
+  }
+}
+
+template<typename Scalar>
+struct log1p_impl {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& x)
+  {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+    #if EIGEN_HAS_CXX11_MATH
+    using std::log1p;
+    #else
+    using std_fallback::log1p;
+    #endif
+    return log1p(x);
+  }
+};
+
+// Specialization for complex types that are not supported by std::log1p.
+template <typename RealScalar>
+struct log1p_impl<std::complex<RealScalar> > {
+  EIGEN_DEVICE_FUNC static inline std::complex<RealScalar> run(
+      const std::complex<RealScalar>& x) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
+    return std_fallback::log1p(x);
+  }
+};
+
+template<typename Scalar>
+struct log1p_retval
+{
+  typedef Scalar type;
+};
+
+/****************************************************************************
+* Implementation of pow                                                  *
+****************************************************************************/
+
+template<typename ScalarX,typename ScalarY, bool IsInteger = NumTraits<ScalarX>::IsInteger&&NumTraits<ScalarY>::IsInteger>
+struct pow_impl
+{
+  //typedef Scalar retval;
+  typedef typename ScalarBinaryOpTraits<ScalarX,ScalarY,internal::scalar_pow_op<ScalarX,ScalarY> >::ReturnType result_type;
+  static EIGEN_DEVICE_FUNC inline result_type run(const ScalarX& x, const ScalarY& y)
+  {
+    EIGEN_USING_STD(pow);
+    return pow(x, y);
+  }
+};
+
+template<typename ScalarX,typename ScalarY>
+struct pow_impl<ScalarX,ScalarY, true>
+{
+  typedef ScalarX result_type;
+  static EIGEN_DEVICE_FUNC inline ScalarX run(ScalarX x, ScalarY y)
+  {
+    ScalarX res(1);
+    eigen_assert(!NumTraits<ScalarY>::IsSigned || y >= 0);
+    if(y & 1) res *= x;
+    y >>= 1;
+    while(y)
+    {
+      x *= x;
+      if(y&1) res *= x;
+      y >>= 1;
+    }
+    return res;
+  }
+};
+
+/****************************************************************************
+* Implementation of random                                               *
+****************************************************************************/
+
+template<typename Scalar,
+         bool IsComplex,
+         bool IsInteger>
+struct random_default_impl {};
+
+template<typename Scalar>
+struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
+
+template<typename Scalar>
+struct random_retval
+{
+  typedef Scalar type;
+};
+
+template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y);
+template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random();
+
+template<typename Scalar>
+struct random_default_impl<Scalar, false, false>
+{
+  static inline Scalar run(const Scalar& x, const Scalar& y)
+  {
+    return x + (y-x) * Scalar(std::rand()) / Scalar(RAND_MAX);
+  }
+  static inline Scalar run()
+  {
+    return run(Scalar(NumTraits<Scalar>::IsSigned ? -1 : 0), Scalar(1));
+  }
+};
+
+enum {
+  meta_floor_log2_terminate,
+  meta_floor_log2_move_up,
+  meta_floor_log2_move_down,
+  meta_floor_log2_bogus
+};
+
+template<unsigned int n, int lower, int upper> struct meta_floor_log2_selector
+{
+  enum { middle = (lower + upper) / 2,
+         value = (upper <= lower + 1) ? int(meta_floor_log2_terminate)
+               : (n < (1 << middle)) ? int(meta_floor_log2_move_down)
+               : (n==0) ? int(meta_floor_log2_bogus)
+               : int(meta_floor_log2_move_up)
+  };
+};
+
+template<unsigned int n,
+         int lower = 0,
+         int upper = sizeof(unsigned int) * CHAR_BIT - 1,
+         int selector = meta_floor_log2_selector<n, lower, upper>::value>
+struct meta_floor_log2 {};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_down>
+{
+  enum { value = meta_floor_log2<n, lower, meta_floor_log2_selector<n, lower, upper>::middle>::value };
+};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_up>
+{
+  enum { value = meta_floor_log2<n, meta_floor_log2_selector<n, lower, upper>::middle, upper>::value };
+};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_terminate>
+{
+  enum { value = (n >= ((unsigned int)(1) << (lower+1))) ? lower+1 : lower };
+};
+
+template<unsigned int n, int lower, int upper>
+struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>
+{
+  // no value, error at compile time
+};
+
+template<typename Scalar>
+struct random_default_impl<Scalar, false, true>
+{
+  static inline Scalar run(const Scalar& x, const Scalar& y)
+  {
+    if (y <= x)
+      return x;
+    // ScalarU is the unsigned counterpart of Scalar, possibly Scalar itself.
+    typedef typename make_unsigned<Scalar>::type ScalarU;
+    // ScalarX is the widest of ScalarU and unsigned int.
+    // We'll deal only with ScalarX and unsigned int below thus avoiding signed
+    // types and arithmetic and signed overflows (which are undefined behavior).
+    typedef typename conditional<(ScalarU(-1) > unsigned(-1)), ScalarU, unsigned>::type ScalarX;
+    // The following difference doesn't overflow, provided our integer types are two's
+    // complement and have the same number of padding bits in signed and unsigned variants.
+    // This is the case in most modern implementations of C++.
+    ScalarX range = ScalarX(y) - ScalarX(x);
+    ScalarX offset = 0;
+    ScalarX divisor = 1;
+    ScalarX multiplier = 1;
+    const unsigned rand_max = RAND_MAX;
+    if (range <= rand_max) divisor = (rand_max + 1) / (range + 1);
+    else                   multiplier = 1 + range / (rand_max + 1);
+    // Rejection sampling.
+    do {
+      offset = (unsigned(std::rand()) * multiplier) / divisor;
+    } while (offset > range);
+    return Scalar(ScalarX(x) + offset);
+  }
+
+  static inline Scalar run()
+  {
+#ifdef EIGEN_MAKING_DOCS
+    return run(Scalar(NumTraits<Scalar>::IsSigned ? -10 : 0), Scalar(10));
+#else
+    enum { rand_bits = meta_floor_log2<(unsigned int)(RAND_MAX)+1>::value,
+           scalar_bits = sizeof(Scalar) * CHAR_BIT,
+           shift = EIGEN_PLAIN_ENUM_MAX(0, int(rand_bits) - int(scalar_bits)),
+           offset = NumTraits<Scalar>::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0
+    };
+    return Scalar((std::rand() >> shift) - offset);
+#endif
+  }
+};
+
+template<typename Scalar>
+struct random_default_impl<Scalar, true, false>
+{
+  static inline Scalar run(const Scalar& x, const Scalar& y)
+  {
+    return Scalar(random(x.real(), y.real()),
+                  random(x.imag(), y.imag()));
+  }
+  static inline Scalar run()
+  {
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    return Scalar(random<RealScalar>(), random<RealScalar>());
+  }
+};
+
+template<typename Scalar>
+inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y)
+{
+  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
+}
+
+template<typename Scalar>
+inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random()
+{
+  return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
+}
+
+// Implementation of is* functions
+
+// std::is* do not work with fast-math and gcc, std::is* are available on MSVC 2013 and newer, as well as in clang.
+#if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG)
+#define EIGEN_USE_STD_FPCLASSIFY 1
+#else
+#define EIGEN_USE_STD_FPCLASSIFY 0
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<internal::is_integral<T>::value,bool>::type
+isnan_impl(const T&) { return false; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<internal::is_integral<T>::value,bool>::type
+isinf_impl(const T&) { return false; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<internal::is_integral<T>::value,bool>::type
+isfinite_impl(const T&) { return true; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
+isfinite_impl(const T& x)
+{
+  #if defined(EIGEN_GPU_COMPILE_PHASE)
+    return (::isfinite)(x);
+  #elif EIGEN_USE_STD_FPCLASSIFY
+    using std::isfinite;
+    return isfinite EIGEN_NOT_A_MACRO (x);
+  #else
+    return x<=NumTraits<T>::highest() && x>=NumTraits<T>::lowest();
+  #endif
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
+isinf_impl(const T& x)
+{
+  #if defined(EIGEN_GPU_COMPILE_PHASE)
+    return (::isinf)(x);
+  #elif EIGEN_USE_STD_FPCLASSIFY
+    using std::isinf;
+    return isinf EIGEN_NOT_A_MACRO (x);
+  #else
+    return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
+  #endif
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),bool>::type
+isnan_impl(const T& x)
+{
+  #if defined(EIGEN_GPU_COMPILE_PHASE)
+    return (::isnan)(x);
+  #elif EIGEN_USE_STD_FPCLASSIFY
+    using std::isnan;
+    return isnan EIGEN_NOT_A_MACRO (x);
+  #else
+    return x != x;
+  #endif
+}
+
+#if (!EIGEN_USE_STD_FPCLASSIFY)
+
+#if EIGEN_COMP_MSVC
+
+template<typename T> EIGEN_DEVICE_FUNC bool isinf_msvc_helper(T x)
+{
+  return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF;
+}
+
+//MSVC defines a _isnan builtin function, but for double only
+EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return _isnan(x)!=0; }
+EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x)      { return _isnan(x)!=0; }
+EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x)       { return _isnan(x)!=0; }
+
+EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return isinf_msvc_helper(x); }
+EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x)      { return isinf_msvc_helper(x); }
+EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x)       { return isinf_msvc_helper(x); }
+
+#elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC)
+
+#if EIGEN_GNUC_AT_LEAST(5,0)
+  #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only")))
+#else
+  // NOTE the inline qualifier and noinline attribute are both needed: the former is to avoid linking issue (duplicate symbol),
+  //      while the second prevent too aggressive optimizations in fast-math mode:
+  #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((noinline,optimize("no-finite-math-only")))
+#endif
+
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const long double& x) { return __builtin_isnan(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const double& x)      { return __builtin_isnan(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isnan_impl(const float& x)       { return __builtin_isnan(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const double& x)      { return __builtin_isinf(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const float& x)       { return __builtin_isinf(x); }
+template<> EIGEN_TMP_NOOPT_ATTRIB bool isinf_impl(const long double& x) { return __builtin_isinf(x); }
+
+#undef EIGEN_TMP_NOOPT_ATTRIB
+
+#endif
+
+#endif
+
+// The following overload are defined at the end of this file
+template<typename T> EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x);
+template<typename T> EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x);
+template<typename T> EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x);
+
+template<typename T> T generic_fast_tanh_float(const T& a_x);
+} // end namespace internal
+
+/****************************************************************************
+* Generic math functions                                                    *
+****************************************************************************/
+
+namespace numext {
+
+#if (!defined(EIGEN_GPUCC) || defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC))
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
+{
+  EIGEN_USING_STD(min)
+  return min EIGEN_NOT_A_MACRO (x,y);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
+{
+  EIGEN_USING_STD(max)
+  return max EIGEN_NOT_A_MACRO (x,y);
+}
+#else
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y)
+{
+  return y < x ? y : x;
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE float mini(const float& x, const float& y)
+{
+  return fminf(x, y);
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE double mini(const double& x, const double& y)
+{
+  return fmin(x, y);
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE long double mini(const long double& x, const long double& y)
+{
+#if defined(EIGEN_HIPCC)
+  // no "fminl" on HIP yet
+  return (x < y) ? x : y;
+#else
+  return fminl(x, y);
+#endif
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y)
+{
+  return x < y ? y : x;
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE float maxi(const float& x, const float& y)
+{
+  return fmaxf(x, y);
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE double maxi(const double& x, const double& y)
+{
+  return fmax(x, y);
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE long double maxi(const long double& x, const long double& y)
+{
+#if defined(EIGEN_HIPCC)
+  // no "fmaxl" on HIP yet
+  return (x > y) ? x : y;
+#else
+  return fmaxl(x, y);
+#endif
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+
+
+#define SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_char)   \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_short)  \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_int)    \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_long)
+#define SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_char)   \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_short)  \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_int)    \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_long)
+#define SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_uchar)  \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_ushort) \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_uint)   \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_ulong)
+#define SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_uchar)  \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_ushort) \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_uint)   \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_ulong)
+#define SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY(NAME, FUNC)
+#define SYCL_SPECIALIZE_INTEGER_TYPES_UNARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY(NAME, FUNC)
+#define SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_float) \
+  SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC,cl::sycl::cl_double)
+#define SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(NAME, FUNC) \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_float) \
+  SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC,cl::sycl::cl_double)
+#define SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(NAME, FUNC, RET_TYPE) \
+  SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, RET_TYPE, cl::sycl::cl_float) \
+  SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, RET_TYPE, cl::sycl::cl_double)
+
+#define SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE) \
+template<>                                               \
+  EIGEN_DEVICE_FUNC                                      \
+  EIGEN_ALWAYS_INLINE RET_TYPE NAME(const ARG_TYPE& x) { \
+    return cl::sycl::FUNC(x);                            \
+  }
+
+#define SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, TYPE) \
+  SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, TYPE, TYPE)
+
+#define SYCL_SPECIALIZE_GEN1_BINARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE1, ARG_TYPE2) \
+  template<>                                                                  \
+  EIGEN_DEVICE_FUNC                                                           \
+  EIGEN_ALWAYS_INLINE RET_TYPE NAME(const ARG_TYPE1& x, const ARG_TYPE2& y) { \
+    return cl::sycl::FUNC(x, y);                                              \
+  }
+
+#define SYCL_SPECIALIZE_GEN2_BINARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE) \
+  SYCL_SPECIALIZE_GEN1_BINARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE, ARG_TYPE)
+
+#define SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, TYPE) \
+  SYCL_SPECIALIZE_GEN2_BINARY_FUNC(NAME, FUNC, TYPE, TYPE)
+
+SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(mini, min)
+SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(mini, fmin)
+SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(maxi, max)
+SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(maxi, fmax)
+
+#endif
+
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(real, Scalar) real(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(const Scalar& x)
+{
+  return internal::real_ref_impl<Scalar>::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(imag, Scalar) imag(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(arg, Scalar) arg(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(arg, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(const Scalar& x)
+{
+  return internal::imag_ref_impl<Scalar>::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) abs2(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x);
+}
+
+EIGEN_DEVICE_FUNC
+inline bool abs2(bool x) { return x; }
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE T absdiff(const T& x, const T& y)
+{
+  return x > y ? x - y : y - x;
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE float absdiff(const float& x, const float& y)
+{
+  return fabsf(x - y);
+}
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE double absdiff(const double& x, const double& y)
+{
+  return fabs(x - y);
+}
+
+#if !defined(EIGEN_GPUCC)
+// HIP and CUDA do not support long double.
+template<>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE long double absdiff(const long double& x, const long double& y) {
+  return fabsl(x - y);
+}
+#endif
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(const Scalar& x, const Scalar& y)
+{
+  return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+  SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(hypot, hypot)
+#endif
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(log1p, Scalar) log1p(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(log1p, Scalar)::run(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(log1p, log1p)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float log1p(const float &x) { return ::log1pf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double log1p(const double &x) { return ::log1p(x); }
+#endif
+
+template<typename ScalarX,typename ScalarY>
+EIGEN_DEVICE_FUNC
+inline typename internal::pow_impl<ScalarX,ScalarY>::result_type pow(const ScalarX& x, const ScalarY& y)
+{
+  return internal::pow_impl<ScalarX,ScalarY>::run(x, y);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(pow, pow)
+#endif
+
+template<typename T> EIGEN_DEVICE_FUNC bool (isnan)   (const T &x) { return internal::isnan_impl(x); }
+template<typename T> EIGEN_DEVICE_FUNC bool (isinf)   (const T &x) { return internal::isinf_impl(x); }
+template<typename T> EIGEN_DEVICE_FUNC bool (isfinite)(const T &x) { return internal::isfinite_impl(x); }
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isnan, isnan, bool)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isinf, isinf, bool)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isfinite, isfinite, bool)
+#endif
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(rint, Scalar) rint(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(rint, Scalar)::run(x);
+}
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(round, Scalar) round(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(round, Scalar)::run(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(round, round)
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+T (floor)(const T& x)
+{
+  EIGEN_USING_STD(floor)
+  return floor(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(floor, floor)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float floor(const float &x) { return ::floorf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double floor(const double &x) { return ::floor(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+T (ceil)(const T& x)
+{
+  EIGEN_USING_STD(ceil);
+  return ceil(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(ceil, ceil)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float ceil(const float &x) { return ::ceilf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double ceil(const double &x) { return ::ceil(x); }
+#endif
+
+
+/** Log base 2 for 32 bits positive integers.
+  * Conveniently returns 0 for x==0. */
+inline int log2(int x)
+{
+  eigen_assert(x>=0);
+  unsigned int v(x);
+  static const int table[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+  v |= v >> 1;
+  v |= v >> 2;
+  v |= v >> 4;
+  v |= v >> 8;
+  v |= v >> 16;
+  return table[(v * 0x07C4ACDDU) >> 27];
+}
+
+/** \returns the square root of \a x.
+  *
+  * It is essentially equivalent to
+  * \code using std::sqrt; return sqrt(x); \endcode
+  * but slightly faster for float/double and some compilers (e.g., gcc), thanks to
+  * specializations when SSE is enabled.
+  *
+  * It's usage is justified in performance critical functions, like norm/normalize.
+  */
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+EIGEN_ALWAYS_INLINE EIGEN_MATHFUNC_RETVAL(sqrt, Scalar) sqrt(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(sqrt, Scalar)::run(x);
+}
+
+// Boolean specialization, avoids implicit float to bool conversion (-Wimplicit-conversion-floating-point-to-bool).
+template<>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC
+bool sqrt<bool>(const bool &x) { return x; }
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sqrt, sqrt)
+#endif
+
+/** \returns the reciprocal square root of \a x. **/
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T rsqrt(const T& x)
+{
+  return internal::rsqrt_impl<T>::run(x);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T log(const T &x) {
+  return internal::log_impl<T>::run(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(log, log)
+#endif
+
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float log(const float &x) { return ::logf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double log(const double &x) { return ::log(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+typename internal::enable_if<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex,typename NumTraits<T>::Real>::type
+abs(const T &x) {
+  EIGEN_USING_STD(abs);
+  return abs(x);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+typename internal::enable_if<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex),typename NumTraits<T>::Real>::type
+abs(const T &x) {
+  return x;
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_INTEGER_TYPES_UNARY(abs, abs)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(abs, fabs)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float abs(const float &x) { return ::fabsf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double abs(const double &x) { return ::fabs(x); }
+
+template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float abs(const std::complex<float>& x) {
+  return ::hypotf(x.real(), x.imag());
+}
+
+template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double abs(const std::complex<double>& x) {
+  return ::hypot(x.real(), x.imag());
+}
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T exp(const T &x) {
+  EIGEN_USING_STD(exp);
+  return exp(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(exp, exp)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float exp(const float &x) { return ::expf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double exp(const double &x) { return ::exp(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+std::complex<float> exp(const std::complex<float>& x) {
+  float com = ::expf(x.real());
+  float res_real = com * ::cosf(x.imag());
+  float res_imag = com * ::sinf(x.imag());
+  return std::complex<float>(res_real, res_imag);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+std::complex<double> exp(const std::complex<double>& x) {
+  double com = ::exp(x.real());
+  double res_real = com * ::cos(x.imag());
+  double res_imag = com * ::sin(x.imag());
+  return std::complex<double>(res_real, res_imag);
+}
+#endif
+
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+inline EIGEN_MATHFUNC_RETVAL(expm1, Scalar) expm1(const Scalar& x)
+{
+  return EIGEN_MATHFUNC_IMPL(expm1, Scalar)::run(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(expm1, expm1)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float expm1(const float &x) { return ::expm1f(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double expm1(const double &x) { return ::expm1(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T cos(const T &x) {
+  EIGEN_USING_STD(cos);
+  return cos(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(cos,cos)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float cos(const float &x) { return ::cosf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double cos(const double &x) { return ::cos(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T sin(const T &x) {
+  EIGEN_USING_STD(sin);
+  return sin(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sin, sin)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float sin(const float &x) { return ::sinf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double sin(const double &x) { return ::sin(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T tan(const T &x) {
+  EIGEN_USING_STD(tan);
+  return tan(x);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(tan, tan)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float tan(const float &x) { return ::tanf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double tan(const double &x) { return ::tan(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T acos(const T &x) {
+  EIGEN_USING_STD(acos);
+  return acos(x);
+}
+
+#if EIGEN_HAS_CXX11_MATH
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T acosh(const T &x) {
+  EIGEN_USING_STD(acosh);
+  return static_cast<T>(acosh(x));
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(acos, acos)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(acosh, acosh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float acos(const float &x) { return ::acosf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double acos(const double &x) { return ::acos(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T asin(const T &x) {
+  EIGEN_USING_STD(asin);
+  return asin(x);
+}
+
+#if EIGEN_HAS_CXX11_MATH
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T asinh(const T &x) {
+  EIGEN_USING_STD(asinh);
+  return static_cast<T>(asinh(x));
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(asin, asin)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(asinh, asinh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float asin(const float &x) { return ::asinf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double asin(const double &x) { return ::asin(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T atan(const T &x) {
+  EIGEN_USING_STD(atan);
+  return static_cast<T>(atan(x));
+}
+
+#if EIGEN_HAS_CXX11_MATH
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T atanh(const T &x) {
+  EIGEN_USING_STD(atanh);
+  return static_cast<T>(atanh(x));
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(atan, atan)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(atanh, atanh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float atan(const float &x) { return ::atanf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double atan(const double &x) { return ::atan(x); }
+#endif
+
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T cosh(const T &x) {
+  EIGEN_USING_STD(cosh);
+  return static_cast<T>(cosh(x));
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(cosh, cosh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float cosh(const float &x) { return ::coshf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double cosh(const double &x) { return ::cosh(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T sinh(const T &x) {
+  EIGEN_USING_STD(sinh);
+  return static_cast<T>(sinh(x));
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sinh, sinh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float sinh(const float &x) { return ::sinhf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double sinh(const double &x) { return ::sinh(x); }
+#endif
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T tanh(const T &x) {
+  EIGEN_USING_STD(tanh);
+  return tanh(x);
+}
+
+#if (!defined(EIGEN_GPUCC)) && EIGEN_FAST_MATH && !defined(SYCL_DEVICE_ONLY)
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float tanh(float x) { return internal::generic_fast_tanh_float(x); }
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(tanh, tanh)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float tanh(const float &x) { return ::tanhf(x); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double tanh(const double &x) { return ::tanh(x); }
+#endif
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+T fmod(const T& a, const T& b) {
+  EIGEN_USING_STD(fmod);
+  return fmod(a, b);
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(fmod, fmod)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float fmod(const float& a, const float& b) {
+  return ::fmodf(a, b);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double fmod(const double& a, const double& b) {
+  return ::fmod(a, b);
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+#undef SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY
+#undef SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY
+#undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY
+#undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY
+#undef SYCL_SPECIALIZE_INTEGER_TYPES_BINARY
+#undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY
+#undef SYCL_SPECIALIZE_FLOATING_TYPES_BINARY
+#undef SYCL_SPECIALIZE_FLOATING_TYPES_UNARY
+#undef SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE
+#undef SYCL_SPECIALIZE_GEN_UNARY_FUNC
+#undef SYCL_SPECIALIZE_UNARY_FUNC
+#undef SYCL_SPECIALIZE_GEN1_BINARY_FUNC
+#undef SYCL_SPECIALIZE_GEN2_BINARY_FUNC
+#undef SYCL_SPECIALIZE_BINARY_FUNC
+#endif
+
+} // end namespace numext
+
+namespace internal {
+
+template<typename T>
+EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x)
+{
+  return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x)
+{
+  return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x)
+{
+  return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
+}
+
+/****************************************************************************
+* Implementation of fuzzy comparisons                                       *
+****************************************************************************/
+
+template<typename Scalar,
+         bool IsComplex,
+         bool IsInteger>
+struct scalar_fuzzy_default_impl {};
+
+template<typename Scalar>
+struct scalar_fuzzy_default_impl<Scalar, false, false>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
+  {
+    return numext::abs(x) <= numext::abs(y) * prec;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
+  {
+    return numext::abs(x - y) <= numext::mini(numext::abs(x), numext::abs(y)) * prec;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar& prec)
+  {
+    return x <= y || isApprox(x, y, prec);
+  }
+};
+
+template<typename Scalar>
+struct scalar_fuzzy_default_impl<Scalar, false, true>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, const RealScalar&)
+  {
+    return x == Scalar(0);
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar&)
+  {
+    return x == y;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar&)
+  {
+    return x <= y;
+  }
+};
+
+template<typename Scalar>
+struct scalar_fuzzy_default_impl<Scalar, true, false>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec)
+  {
+    return numext::abs2(x) <= numext::abs2(y) * prec * prec;
+  }
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec)
+  {
+    return numext::abs2(x - y) <= numext::mini(numext::abs2(x), numext::abs2(y)) * prec * prec;
+  }
+};
+
+template<typename Scalar>
+struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
+
+template<typename Scalar, typename OtherScalar> EIGEN_DEVICE_FUNC
+inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
+                              const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
+{
+  return scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision);
+}
+
+template<typename Scalar> EIGEN_DEVICE_FUNC
+inline bool isApprox(const Scalar& x, const Scalar& y,
+                     const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
+{
+  return scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision);
+}
+
+template<typename Scalar> EIGEN_DEVICE_FUNC
+inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y,
+                               const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
+{
+  return scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision);
+}
+
+/******************************************
+***  The special case of the  bool type ***
+******************************************/
+
+template<> struct random_impl<bool>
+{
+  static inline bool run()
+  {
+    return random<int>(0,1)==0 ? false : true;
+  }
+
+  static inline bool run(const bool& a, const bool& b)
+  {
+    return random<int>(a, b)==0 ? false : true;
+  }
+};
+
+template<> struct scalar_fuzzy_impl<bool>
+{
+  typedef bool RealScalar;
+
+  template<typename OtherScalar> EIGEN_DEVICE_FUNC
+  static inline bool isMuchSmallerThan(const bool& x, const bool&, const bool&)
+  {
+    return !x;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline bool isApprox(bool x, bool y, bool)
+  {
+    return x == y;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline bool isApproxOrLessThan(const bool& x, const bool& y, const bool&)
+  {
+    return (!x) || y;
+  }
+
+};
+
+} // end namespace internal
+
+// Default implementations that rely on other numext implementations
+namespace internal {
+
+// Specialization for complex types that are not supported by std::expm1.
+template <typename RealScalar>
+struct expm1_impl<std::complex<RealScalar> > {
+  EIGEN_DEVICE_FUNC static inline std::complex<RealScalar> run(
+      const std::complex<RealScalar>& x) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
+    RealScalar xr = x.real();
+    RealScalar xi = x.imag();
+    // expm1(z) = exp(z) - 1
+    //          = exp(x +  i * y) - 1
+    //          = exp(x) * (cos(y) + i * sin(y)) - 1
+    //          = exp(x) * cos(y) - 1 + i * exp(x) * sin(y)
+    // Imag(expm1(z)) = exp(x) * sin(y)
+    // Real(expm1(z)) = exp(x) * cos(y) - 1
+    //          = exp(x) * cos(y) - 1.
+    //          = expm1(x) + exp(x) * (cos(y) - 1)
+    //          = expm1(x) + exp(x) * (2 * sin(y / 2) ** 2)
+    RealScalar erm1 = numext::expm1<RealScalar>(xr);
+    RealScalar er = erm1 + RealScalar(1.);
+    RealScalar sin2 = numext::sin(xi / RealScalar(2.));
+    sin2 = sin2 * sin2;
+    RealScalar s = numext::sin(xi);
+    RealScalar real_part = erm1 - RealScalar(2.) * er * sin2;
+    return std::complex<RealScalar>(real_part, er * s);
+  }
+};
+
+template<typename T>
+struct rsqrt_impl {
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE T run(const T& x) {
+    return T(1)/numext::sqrt(x);
+  }
+};
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+template<typename T>
+struct conj_impl<std::complex<T>, true>
+{
+  EIGEN_DEVICE_FUNC
+  static inline std::complex<T> run(const std::complex<T>& x)
+  {
+    return std::complex<T>(numext::real(x), -numext::imag(x));
+  }
+};
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATHFUNCTIONS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/MathFunctionsImpl.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/MathFunctionsImpl.h
new file mode 100644
index 00000000..4eaaaa78
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/MathFunctionsImpl.h
@@ -0,0 +1,200 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATHFUNCTIONSIMPL_H
+#define EIGEN_MATHFUNCTIONSIMPL_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise)
+    Doesn't do anything fancy, just a 13/6-degree rational interpolant which
+    is accurate up to a couple of ulps in the (approximate) range [-8, 8],
+    outside of which tanh(x) = +/-1 in single precision. The input is clamped
+    to the range [-c, c]. The value c is chosen as the smallest value where
+    the approximation evaluates to exactly 1. In the reange [-0.0004, 0.0004]
+    the approxmation tanh(x) ~= x is used for better accuracy as x tends to zero.
+
+    This implementation works on both scalars and packets.
+*/
+template<typename T>
+T generic_fast_tanh_float(const T& a_x)
+{
+  // Clamp the inputs to the range [-c, c]
+#ifdef EIGEN_VECTORIZE_FMA
+  const T plus_clamp = pset1<T>(7.99881172180175781f);
+  const T minus_clamp = pset1<T>(-7.99881172180175781f);
+#else
+  const T plus_clamp = pset1<T>(7.90531110763549805f);
+  const T minus_clamp = pset1<T>(-7.90531110763549805f);
+#endif
+  const T tiny = pset1<T>(0.0004f);
+  const T x = pmax(pmin(a_x, plus_clamp), minus_clamp);
+  const T tiny_mask = pcmp_lt(pabs(a_x), tiny);
+  // The monomial coefficients of the numerator polynomial (odd).
+  const T alpha_1 = pset1<T>(4.89352455891786e-03f);
+  const T alpha_3 = pset1<T>(6.37261928875436e-04f);
+  const T alpha_5 = pset1<T>(1.48572235717979e-05f);
+  const T alpha_7 = pset1<T>(5.12229709037114e-08f);
+  const T alpha_9 = pset1<T>(-8.60467152213735e-11f);
+  const T alpha_11 = pset1<T>(2.00018790482477e-13f);
+  const T alpha_13 = pset1<T>(-2.76076847742355e-16f);
+
+  // The monomial coefficients of the denominator polynomial (even).
+  const T beta_0 = pset1<T>(4.89352518554385e-03f);
+  const T beta_2 = pset1<T>(2.26843463243900e-03f);
+  const T beta_4 = pset1<T>(1.18534705686654e-04f);
+  const T beta_6 = pset1<T>(1.19825839466702e-06f);
+
+  // Since the polynomials are odd/even, we need x^2.
+  const T x2 = pmul(x, x);
+
+  // Evaluate the numerator polynomial p.
+  T p = pmadd(x2, alpha_13, alpha_11);
+  p = pmadd(x2, p, alpha_9);
+  p = pmadd(x2, p, alpha_7);
+  p = pmadd(x2, p, alpha_5);
+  p = pmadd(x2, p, alpha_3);
+  p = pmadd(x2, p, alpha_1);
+  p = pmul(x, p);
+
+  // Evaluate the denominator polynomial q.
+  T q = pmadd(x2, beta_6, beta_4);
+  q = pmadd(x2, q, beta_2);
+  q = pmadd(x2, q, beta_0);
+
+  // Divide the numerator by the denominator.
+  return pselect(tiny_mask, x, pdiv(p, q));
+}
+
+template<typename RealScalar>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+RealScalar positive_real_hypot(const RealScalar& x, const RealScalar& y)
+{
+  // IEEE IEC 6059 special cases.
+  if ((numext::isinf)(x) || (numext::isinf)(y))
+    return NumTraits<RealScalar>::infinity();
+  if ((numext::isnan)(x) || (numext::isnan)(y))
+    return NumTraits<RealScalar>::quiet_NaN();
+    
+  EIGEN_USING_STD(sqrt);
+  RealScalar p, qp;
+  p = numext::maxi(x,y);
+  if(p==RealScalar(0)) return RealScalar(0);
+  qp = numext::mini(y,x) / p;
+  return p * sqrt(RealScalar(1) + qp*qp);
+}
+
+template<typename Scalar>
+struct hypot_impl
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  static EIGEN_DEVICE_FUNC
+  inline RealScalar run(const Scalar& x, const Scalar& y)
+  {
+    EIGEN_USING_STD(abs);
+    return positive_real_hypot<RealScalar>(abs(x), abs(y));
+  }
+};
+
+// Generic complex sqrt implementation that correctly handles corner cases
+// according to https://en.cppreference.com/w/cpp/numeric/complex/sqrt
+template<typename T>
+EIGEN_DEVICE_FUNC std::complex<T> complex_sqrt(const std::complex<T>& z) {
+  // Computes the principal sqrt of the input.
+  //
+  // For a complex square root of the number x + i*y. We want to find real
+  // numbers u and v such that
+  //    (u + i*v)^2 = x + i*y  <=>
+  //    u^2 - v^2 + i*2*u*v = x + i*v.
+  // By equating the real and imaginary parts we get:
+  //    u^2 - v^2 = x
+  //    2*u*v = y.
+  //
+  // For x >= 0, this has the numerically stable solution
+  //    u = sqrt(0.5 * (x + sqrt(x^2 + y^2)))
+  //    v = y / (2 * u)
+  // and for x < 0,
+  //    v = sign(y) * sqrt(0.5 * (-x + sqrt(x^2 + y^2)))
+  //    u = y / (2 * v)
+  //
+  // Letting w = sqrt(0.5 * (|x| + |z|)),
+  //   if x == 0: u = w, v = sign(y) * w
+  //   if x > 0:  u = w, v = y / (2 * w)
+  //   if x < 0:  u = |y| / (2 * w), v = sign(y) * w
+
+  const T x = numext::real(z);
+  const T y = numext::imag(z);
+  const T zero = T(0);
+  const T w = numext::sqrt(T(0.5) * (numext::abs(x) + numext::hypot(x, y)));
+
+  return
+    (numext::isinf)(y) ? std::complex<T>(NumTraits<T>::infinity(), y)
+      : x == zero ? std::complex<T>(w, y < zero ? -w : w)
+      : x > zero ? std::complex<T>(w, y / (2 * w))
+      : std::complex<T>(numext::abs(y) / (2 * w), y < zero ? -w : w );
+}
+
+// Generic complex rsqrt implementation.
+template<typename T>
+EIGEN_DEVICE_FUNC std::complex<T> complex_rsqrt(const std::complex<T>& z) {
+  // Computes the principal reciprocal sqrt of the input.
+  //
+  // For a complex reciprocal square root of the number z = x + i*y. We want to
+  // find real numbers u and v such that
+  //    (u + i*v)^2 = 1 / (x + i*y)  <=>
+  //    u^2 - v^2 + i*2*u*v = x/|z|^2 - i*v/|z|^2.
+  // By equating the real and imaginary parts we get:
+  //    u^2 - v^2 = x/|z|^2
+  //    2*u*v = y/|z|^2.
+  //
+  // For x >= 0, this has the numerically stable solution
+  //    u = sqrt(0.5 * (x + |z|)) / |z|
+  //    v = -y / (2 * u * |z|)
+  // and for x < 0,
+  //    v = -sign(y) * sqrt(0.5 * (-x + |z|)) / |z|
+  //    u = -y / (2 * v * |z|)
+  //
+  // Letting w = sqrt(0.5 * (|x| + |z|)),
+  //   if x == 0: u = w / |z|, v = -sign(y) * w / |z|
+  //   if x > 0:  u = w / |z|, v = -y / (2 * w * |z|)
+  //   if x < 0:  u = |y| / (2 * w * |z|), v = -sign(y) * w / |z|
+
+  const T x = numext::real(z);
+  const T y = numext::imag(z);
+  const T zero = T(0);
+
+  const T abs_z = numext::hypot(x, y);
+  const T w = numext::sqrt(T(0.5) * (numext::abs(x) + abs_z));
+  const T woz = w / abs_z;
+  // Corner cases consistent with 1/sqrt(z) on gcc/clang.
+  return
+    abs_z == zero ? std::complex<T>(NumTraits<T>::infinity(), NumTraits<T>::quiet_NaN())
+      : ((numext::isinf)(x) || (numext::isinf)(y)) ? std::complex<T>(zero, zero)
+      : x == zero ? std::complex<T>(woz, y < zero ? woz : -woz)
+      : x > zero ? std::complex<T>(woz, -y / (2 * w * abs_z))
+      : std::complex<T>(numext::abs(y) / (2 * w * abs_z), y < zero ? woz : -woz );
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC std::complex<T> complex_log(const std::complex<T>& z) {
+  // Computes complex log.
+  T a = numext::abs(z);
+  EIGEN_USING_STD(atan2);
+  T b = atan2(z.imag(), z.real());
+  return std::complex<T>(numext::log(a), b);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATHFUNCTIONSIMPL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Matrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Matrix.h
new file mode 100644
index 00000000..f0e59a91
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Matrix.h
@@ -0,0 +1,565 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIX_H
+#define EIGEN_MATRIX_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+private:
+  enum { size = internal::size_at_compile_time<_Rows,_Cols>::ret };
+  typedef typename find_best_packet<_Scalar,size>::type PacketScalar;
+  enum {
+      row_major_bit = _Options&RowMajor ? RowMajorBit : 0,
+      is_dynamic_size_storage = _MaxRows==Dynamic || _MaxCols==Dynamic,
+      max_size = is_dynamic_size_storage ? Dynamic : _MaxRows*_MaxCols,
+      default_alignment = compute_default_alignment<_Scalar,max_size>::value,
+      actual_alignment = ((_Options&DontAlign)==0) ? default_alignment : 0,
+      required_alignment = unpacket_traits<PacketScalar>::alignment,
+      packet_access_bit = (packet_traits<_Scalar>::Vectorizable && (EIGEN_UNALIGNED_VECTORIZE || (actual_alignment>=required_alignment))) ? PacketAccessBit : 0
+    };
+
+public:
+  typedef _Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef Eigen::Index StorageIndex;
+  typedef MatrixXpr XprKind;
+  enum {
+    RowsAtCompileTime = _Rows,
+    ColsAtCompileTime = _Cols,
+    MaxRowsAtCompileTime = _MaxRows,
+    MaxColsAtCompileTime = _MaxCols,
+    Flags = compute_matrix_flags<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::ret,
+    Options = _Options,
+    InnerStrideAtCompileTime = 1,
+    OuterStrideAtCompileTime = (Options&RowMajor) ? ColsAtCompileTime : RowsAtCompileTime,
+
+    // FIXME, the following flag in only used to define NeedsToAlign in PlainObjectBase
+    EvaluatorFlags = LinearAccessBit | DirectAccessBit | packet_access_bit | row_major_bit,
+    Alignment = actual_alignment
+  };
+};
+}
+
+/** \class Matrix
+  * \ingroup Core_Module
+  *
+  * \brief The matrix class, also used for vectors and row-vectors
+  *
+  * The %Matrix class is the work-horse for all \em dense (\ref dense "note") matrices and vectors within Eigen.
+  * Vectors are matrices with one column, and row-vectors are matrices with one row.
+  *
+  * The %Matrix class encompasses \em both fixed-size and dynamic-size objects (\ref fixedsize "note").
+  *
+  * The first three template parameters are required:
+  * \tparam _Scalar Numeric type, e.g. float, double, int or std::complex<float>.
+  *                 User defined scalar types are supported as well (see \ref user_defined_scalars "here").
+  * \tparam _Rows Number of rows, or \b Dynamic
+  * \tparam _Cols Number of columns, or \b Dynamic
+  *
+  * The remaining template parameters are optional -- in most cases you don't have to worry about them.
+  * \tparam _Options A combination of either \b #RowMajor or \b #ColMajor, and of either
+  *                 \b #AutoAlign or \b #DontAlign.
+  *                 The former controls \ref TopicStorageOrders "storage order", and defaults to column-major. The latter controls alignment, which is required
+  *                 for vectorization. It defaults to aligning matrices except for fixed sizes that aren't a multiple of the packet size.
+  * \tparam _MaxRows Maximum number of rows. Defaults to \a _Rows (\ref maxrows "note").
+  * \tparam _MaxCols Maximum number of columns. Defaults to \a _Cols (\ref maxrows "note").
+  *
+  * Eigen provides a number of typedefs covering the usual cases. Here are some examples:
+  *
+  * \li \c Matrix2d is a 2x2 square matrix of doubles (\c Matrix<double, 2, 2>)
+  * \li \c Vector4f is a vector of 4 floats (\c Matrix<float, 4, 1>)
+  * \li \c RowVector3i is a row-vector of 3 ints (\c Matrix<int, 1, 3>)
+  *
+  * \li \c MatrixXf is a dynamic-size matrix of floats (\c Matrix<float, Dynamic, Dynamic>)
+  * \li \c VectorXf is a dynamic-size vector of floats (\c Matrix<float, Dynamic, 1>)
+  *
+  * \li \c Matrix2Xf is a partially fixed-size (dynamic-size) matrix of floats (\c Matrix<float, 2, Dynamic>)
+  * \li \c MatrixX3d is a partially dynamic-size (fixed-size) matrix of double (\c Matrix<double, Dynamic, 3>)
+  *
+  * See \link matrixtypedefs this page \endlink for a complete list of predefined \em %Matrix and \em Vector typedefs.
+  *
+  * You can access elements of vectors and matrices using normal subscripting:
+  *
+  * \code
+  * Eigen::VectorXd v(10);
+  * v[0] = 0.1;
+  * v[1] = 0.2;
+  * v(0) = 0.3;
+  * v(1) = 0.4;
+  *
+  * Eigen::MatrixXi m(10, 10);
+  * m(0, 1) = 1;
+  * m(0, 2) = 2;
+  * m(0, 3) = 3;
+  * \endcode
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_MATRIX_PLUGIN.
+  *
+  * <i><b>Some notes:</b></i>
+  *
+  * <dl>
+  * <dt><b>\anchor dense Dense versus sparse:</b></dt>
+  * <dd>This %Matrix class handles dense, not sparse matrices and vectors. For sparse matrices and vectors, see the Sparse module.
+  *
+  * Dense matrices and vectors are plain usual arrays of coefficients. All the coefficients are stored, in an ordinary contiguous array.
+  * This is unlike Sparse matrices and vectors where the coefficients are stored as a list of nonzero coefficients.</dd>
+  *
+  * <dt><b>\anchor fixedsize Fixed-size versus dynamic-size:</b></dt>
+  * <dd>Fixed-size means that the numbers of rows and columns are known are compile-time. In this case, Eigen allocates the array
+  * of coefficients as a fixed-size array, as a class member. This makes sense for very small matrices, typically up to 4x4, sometimes up
+  * to 16x16. Larger matrices should be declared as dynamic-size even if one happens to know their size at compile-time.
+  *
+  * Dynamic-size means that the numbers of rows or columns are not necessarily known at compile-time. In this case they are runtime
+  * variables, and the array of coefficients is allocated dynamically on the heap.
+  *
+  * Note that \em dense matrices, be they Fixed-size or Dynamic-size, <em>do not</em> expand dynamically in the sense of a std::map.
+  * If you want this behavior, see the Sparse module.</dd>
+  *
+  * <dt><b>\anchor maxrows _MaxRows and _MaxCols:</b></dt>
+  * <dd>In most cases, one just leaves these parameters to the default values.
+  * These parameters mean the maximum size of rows and columns that the matrix may have. They are useful in cases
+  * when the exact numbers of rows and columns are not known are compile-time, but it is known at compile-time that they cannot
+  * exceed a certain value. This happens when taking dynamic-size blocks inside fixed-size matrices: in this case _MaxRows and _MaxCols
+  * are the dimensions of the original matrix, while _Rows and _Cols are Dynamic.</dd>
+  * </dl>
+  *
+  * <i><b>ABI and storage layout</b></i>
+  *
+  * The table below summarizes the ABI of some possible Matrix instances which is fixed thorough the lifetime of Eigen 3.
+  * <table  class="manual">
+  * <tr><th>Matrix type</th><th>Equivalent C structure</th></tr>
+  * <tr><td>\code Matrix<T,Dynamic,Dynamic> \endcode</td><td>\code
+  * struct {
+  *   T *data;                  // with (size_t(data)%EIGEN_MAX_ALIGN_BYTES)==0
+  *   Eigen::Index rows, cols;
+  *  };
+  * \endcode</td></tr>
+  * <tr class="alt"><td>\code
+  * Matrix<T,Dynamic,1>
+  * Matrix<T,1,Dynamic> \endcode</td><td>\code
+  * struct {
+  *   T *data;                  // with (size_t(data)%EIGEN_MAX_ALIGN_BYTES)==0
+  *   Eigen::Index size;
+  *  };
+  * \endcode</td></tr>
+  * <tr><td>\code Matrix<T,Rows,Cols> \endcode</td><td>\code
+  * struct {
+  *   T data[Rows*Cols];        // with (size_t(data)%A(Rows*Cols*sizeof(T)))==0
+  *  };
+  * \endcode</td></tr>
+  * <tr class="alt"><td>\code Matrix<T,Dynamic,Dynamic,0,MaxRows,MaxCols> \endcode</td><td>\code
+  * struct {
+  *   T data[MaxRows*MaxCols];  // with (size_t(data)%A(MaxRows*MaxCols*sizeof(T)))==0
+  *   Eigen::Index rows, cols;
+  *  };
+  * \endcode</td></tr>
+  * </table>
+  * Note that in this table Rows, Cols, MaxRows and MaxCols are all positive integers. A(S) is defined to the largest possible power-of-two
+  * smaller to EIGEN_MAX_STATIC_ALIGN_BYTES.
+  *
+  * \see MatrixBase for the majority of the API methods for matrices, \ref TopicClassHierarchy,
+  * \ref TopicStorageOrders
+  */
+
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+class Matrix
+  : public PlainObjectBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+  public:
+
+    /** \brief Base class typedef.
+      * \sa PlainObjectBase
+      */
+    typedef PlainObjectBase<Matrix> Base;
+
+    enum { Options = _Options };
+
+    EIGEN_DENSE_PUBLIC_INTERFACE(Matrix)
+
+    typedef typename Base::PlainObject PlainObject;
+
+    using Base::base;
+    using Base::coeffRef;
+
+    /**
+      * \brief Assigns matrices to each other.
+      *
+      * \note This is a special case of the templated operator=. Its purpose is
+      * to prevent a default operator= from hiding the templated operator=.
+      *
+      * \callgraph
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const Matrix& other)
+    {
+      return Base::_set(other);
+    }
+
+    /** \internal
+      * \brief Copies the value of the expression \a other into \c *this with automatic resizing.
+      *
+      * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
+      * it will be initialized.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const DenseBase<OtherDerived>& other)
+    {
+      return Base::_set(other);
+    }
+
+    /* Here, doxygen failed to copy the brief information when using \copydoc */
+
+    /**
+      * \brief Copies the generic expression \a other into *this.
+      * \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other)
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const EigenBase<OtherDerived> &other)
+    {
+      return Base::operator=(other);
+    }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix& operator=(const ReturnByValue<OtherDerived>& func)
+    {
+      return Base::operator=(func);
+    }
+
+    /** \brief Default constructor.
+      *
+      * For fixed-size matrices, does nothing.
+      *
+      * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix
+      * is called a null matrix. This constructor is the unique way to create null matrices: resizing
+      * a matrix to 0 is not supported.
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Matrix() : Base()
+    {
+      Base::_check_template_params();
+      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+    // FIXME is it still needed
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    explicit Matrix(internal::constructor_without_unaligned_array_assert)
+      : Base(internal::constructor_without_unaligned_array_assert())
+    { Base::_check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED }
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Matrix(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible<Scalar>::value)
+      : Base(std::move(other))
+    {
+      Base::_check_template_params();
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Matrix& operator=(Matrix&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
+    {
+      Base::operator=(std::move(other));
+      return *this;
+    }
+#endif
+
+#if EIGEN_HAS_CXX11
+    /** \copydoc PlainObjectBase(const Scalar&, const Scalar&, const Scalar&,  const Scalar&, const ArgTypes&... args)
+     *
+     * Example: \include Matrix_variadic_ctor_cxx11.cpp
+     * Output: \verbinclude Matrix_variadic_ctor_cxx11.out
+     *
+     * \sa Matrix(const std::initializer_list<std::initializer_list<Scalar>>&)
+     */
+    template <typename... ArgTypes>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Matrix(const Scalar& a0, const Scalar& a1, const Scalar& a2,  const Scalar& a3, const ArgTypes&... args)
+      : Base(a0, a1, a2, a3, args...) {}
+
+    /** \brief Constructs a Matrix and initializes it from the coefficients given as initializer-lists grouped by row. \cpp11
+      *
+      * In the general case, the constructor takes a list of rows, each row being represented as a list of coefficients:
+      *
+      * Example: \include Matrix_initializer_list_23_cxx11.cpp
+      * Output: \verbinclude Matrix_initializer_list_23_cxx11.out
+      *
+      * Each of the inner initializer lists must contain the exact same number of elements, otherwise an assertion is triggered.
+      *
+      * In the case of a compile-time column vector, implicit transposition from a single row is allowed.
+      * Therefore <code>VectorXd{{1,2,3,4,5}}</code> is legal and the more verbose syntax
+      * <code>RowVectorXd{{1},{2},{3},{4},{5}}</code> can be avoided:
+      *
+      * Example: \include Matrix_initializer_list_vector_cxx11.cpp
+      * Output: \verbinclude Matrix_initializer_list_vector_cxx11.out
+      *
+      * In the case of fixed-sized matrices, the initializer list sizes must exactly match the matrix sizes,
+      * and implicit transposition is allowed for compile-time vectors only.
+      *
+      * \sa Matrix(const Scalar& a0, const Scalar& a1, const Scalar& a2,  const Scalar& a3, const ArgTypes&... args)
+      */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE Matrix(const std::initializer_list<std::initializer_list<Scalar>>& list) : Base(list) {}
+#endif // end EIGEN_HAS_CXX11
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+    // This constructor is for both 1x1 matrices and dynamic vectors
+    template<typename T>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    explicit Matrix(const T& x)
+    {
+      Base::_check_template_params();
+      Base::template _init1<T>(x);
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Matrix(const T0& x, const T1& y)
+    {
+      Base::_check_template_params();
+      Base::template _init2<T0,T1>(x, y);
+    }
+
+
+#else
+    /** \brief Constructs a fixed-sized matrix initialized with coefficients starting at \a data */
+    EIGEN_DEVICE_FUNC
+    explicit Matrix(const Scalar *data);
+
+    /** \brief Constructs a vector or row-vector with given dimension. \only_for_vectors
+      *
+      * This is useful for dynamic-size vectors. For fixed-size vectors,
+      * it is redundant to pass these parameters, so one should use the default constructor
+      * Matrix() instead.
+      *
+      * \warning This constructor is disabled for fixed-size \c 1x1 matrices. For instance,
+      * calling Matrix<double,1,1>(1) will call the initialization constructor: Matrix(const Scalar&).
+      * For fixed-size \c 1x1 matrices it is therefore recommended to use the default
+      * constructor Matrix() instead, especially when using one of the non standard
+      * \c EIGEN_INITIALIZE_MATRICES_BY_{ZERO,\c NAN} macros (see \ref TopicPreprocessorDirectives).
+      */
+    EIGEN_STRONG_INLINE explicit Matrix(Index dim);
+    /** \brief Constructs an initialized 1x1 matrix with the given coefficient
+      * \sa Matrix(const Scalar&, const Scalar&, const Scalar&,  const Scalar&, const ArgTypes&...) */
+    Matrix(const Scalar& x);
+    /** \brief Constructs an uninitialized matrix with \a rows rows and \a cols columns.
+      *
+      * This is useful for dynamic-size matrices. For fixed-size matrices,
+      * it is redundant to pass these parameters, so one should use the default constructor
+      * Matrix() instead.
+      *
+      * \warning This constructor is disabled for fixed-size \c 1x2 and \c 2x1 vectors. For instance,
+      * calling Matrix2f(2,1) will call the initialization constructor: Matrix(const Scalar& x, const Scalar& y).
+      * For fixed-size \c 1x2 or \c 2x1 vectors it is therefore recommended to use the default
+      * constructor Matrix() instead, especially when using one of the non standard
+      * \c EIGEN_INITIALIZE_MATRICES_BY_{ZERO,\c NAN} macros (see \ref TopicPreprocessorDirectives).
+      */
+    EIGEN_DEVICE_FUNC
+    Matrix(Index rows, Index cols);
+
+    /** \brief Constructs an initialized 2D vector with given coefficients
+      * \sa Matrix(const Scalar&, const Scalar&, const Scalar&,  const Scalar&, const ArgTypes&...) */
+    Matrix(const Scalar& x, const Scalar& y);
+    #endif  // end EIGEN_PARSED_BY_DOXYGEN
+
+    /** \brief Constructs an initialized 3D vector with given coefficients
+      * \sa Matrix(const Scalar&, const Scalar&, const Scalar&,  const Scalar&, const ArgTypes&...)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 3)
+      m_storage.data()[0] = x;
+      m_storage.data()[1] = y;
+      m_storage.data()[2] = z;
+    }
+    /** \brief Constructs an initialized 4D vector with given coefficients
+      * \sa Matrix(const Scalar&, const Scalar&, const Scalar&,  const Scalar&, const ArgTypes&...)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w)
+    {
+      Base::_check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 4)
+      m_storage.data()[0] = x;
+      m_storage.data()[1] = y;
+      m_storage.data()[2] = z;
+      m_storage.data()[3] = w;
+    }
+
+
+    /** \brief Copy constructor */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const Matrix& other) : Base(other)
+    { }
+
+    /** \brief Copy constructor for generic expressions.
+      * \sa MatrixBase::operator=(const EigenBase<OtherDerived>&)
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other)
+      : Base(other.derived())
+    { }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return 1; }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return this->innerSize(); }
+
+    /////////// Geometry module ///////////
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    explicit Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Matrix& operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
+
+    // allow to extend Matrix outside Eigen
+    #ifdef EIGEN_MATRIX_PLUGIN
+    #include EIGEN_MATRIX_PLUGIN
+    #endif
+
+  protected:
+    template <typename Derived, typename OtherDerived, bool IsVector>
+    friend struct internal::conservative_resize_like_impl;
+
+    using Base::m_storage;
+};
+
+/** \defgroup matrixtypedefs Global matrix typedefs
+  *
+  * \ingroup Core_Module
+  *
+  * %Eigen defines several typedef shortcuts for most common matrix and vector types.
+  *
+  * The general patterns are the following:
+  *
+  * \c MatrixSizeType where \c Size can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd
+  * for complex double.
+  *
+  * For example, \c Matrix3d is a fixed-size 3x3 matrix type of doubles, and \c MatrixXf is a dynamic-size matrix of floats.
+  *
+  * There are also \c VectorSizeType and \c RowVectorSizeType which are self-explanatory. For example, \c Vector4cf is
+  * a fixed-size vector of 4 complex floats.
+  *
+  * With \cpp11, template alias are also defined for common sizes.
+  * They follow the same pattern as above except that the scalar type suffix is replaced by a
+  * template parameter, i.e.:
+  *   - `MatrixSize<Type>` where `Size` can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size.
+  *   - `MatrixXSize<Type>` and `MatrixSizeX<Type>` where `Size` can be \c 2,\c 3,\c 4 for hybrid dynamic/fixed matrices.
+  *   - `VectorSize<Type>` and `RowVectorSize<Type>` for column and row vectors.
+  *
+  * With \cpp11, you can also use fully generic column and row vector types: `Vector<Type,Size>` and `RowVector<Type,Size>`.
+  *
+  * \sa class Matrix
+  */
+
+#define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix)   \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Size, Size> Matrix##SizeSuffix##TypeSuffix;  \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Size, 1>    Vector##SizeSuffix##TypeSuffix;  \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, 1, Size>    RowVector##SizeSuffix##TypeSuffix;
+
+#define EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, Size)         \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Size, Dynamic> Matrix##Size##X##TypeSuffix;  \
+/** \ingroup matrixtypedefs */                                    \
+typedef Matrix<Type, Dynamic, Size> Matrix##X##Size##TypeSuffix;
+
+#define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \
+EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \
+EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \
+EIGEN_MAKE_FIXED_TYPEDEFS(Type, TypeSuffix, 4)
+
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(int,                  i)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(float,                f)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(double,               d)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<float>,  cf)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
+
+#undef EIGEN_MAKE_TYPEDEFS_ALL_SIZES
+#undef EIGEN_MAKE_TYPEDEFS
+#undef EIGEN_MAKE_FIXED_TYPEDEFS
+
+#if EIGEN_HAS_CXX11
+
+#define EIGEN_MAKE_TYPEDEFS(Size, SizeSuffix)                     \
+/** \ingroup matrixtypedefs */                                    \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Matrix##SizeSuffix = Matrix<Type, Size, Size>;              \
+/** \ingroup matrixtypedefs */                                    \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Vector##SizeSuffix = Matrix<Type, Size, 1>;                 \
+/** \ingroup matrixtypedefs */                                    \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using RowVector##SizeSuffix = Matrix<Type, 1, Size>;
+
+#define EIGEN_MAKE_FIXED_TYPEDEFS(Size)                           \
+/** \ingroup matrixtypedefs */                                    \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Matrix##Size##X = Matrix<Type, Size, Dynamic>;              \
+/** \ingroup matrixtypedefs */                                    \
+/** \brief \cpp11 */                                              \
+template <typename Type>                                          \
+using Matrix##X##Size = Matrix<Type, Dynamic, Size>;
+
+EIGEN_MAKE_TYPEDEFS(2, 2)
+EIGEN_MAKE_TYPEDEFS(3, 3)
+EIGEN_MAKE_TYPEDEFS(4, 4)
+EIGEN_MAKE_TYPEDEFS(Dynamic, X)
+EIGEN_MAKE_FIXED_TYPEDEFS(2)
+EIGEN_MAKE_FIXED_TYPEDEFS(3)
+EIGEN_MAKE_FIXED_TYPEDEFS(4)
+
+/** \ingroup matrixtypedefs
+  * \brief \cpp11 */
+template <typename Type, int Size>
+using Vector = Matrix<Type, Size, 1>;
+
+/** \ingroup matrixtypedefs
+  * \brief \cpp11 */
+template <typename Type, int Size>
+using RowVector = Matrix<Type, 1, Size>;
+
+#undef EIGEN_MAKE_TYPEDEFS
+#undef EIGEN_MAKE_FIXED_TYPEDEFS
+
+#endif // EIGEN_HAS_CXX11
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/MatrixBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/MatrixBase.h
new file mode 100644
index 00000000..45c3a596
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/MatrixBase.h
@@ -0,0 +1,547 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIXBASE_H
+#define EIGEN_MATRIXBASE_H
+
+namespace Eigen {
+
+/** \class MatrixBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for all dense matrices, vectors, and expressions
+  *
+  * This class is the base that is inherited by all matrix, vector, and related expression
+  * types. Most of the Eigen API is contained in this class, and its base classes. Other important
+  * classes for the Eigen API are Matrix, and VectorwiseOp.
+  *
+  * Note that some methods are defined in other modules such as the \ref LU_Module LU module
+  * for all functions related to matrix inversions.
+  *
+  * \tparam Derived is the derived type, e.g. a matrix type, or an expression, etc.
+  *
+  * When writing a function taking Eigen objects as argument, if you want your function
+  * to take as argument any matrix, vector, or expression, just let it take a
+  * MatrixBase argument. As an example, here is a function printFirstRow which, given
+  * a matrix, vector, or expression \a x, prints the first row of \a x.
+  *
+  * \code
+    template<typename Derived>
+    void printFirstRow(const Eigen::MatrixBase<Derived>& x)
+    {
+      cout << x.row(0) << endl;
+    }
+  * \endcode
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_MATRIXBASE_PLUGIN.
+  *
+  * \sa \blank \ref TopicClassHierarchy
+  */
+template<typename Derived> class MatrixBase
+  : public DenseBase<Derived>
+{
+  public:
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef MatrixBase StorageBaseType;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    typedef DenseBase<Derived> Base;
+    using Base::RowsAtCompileTime;
+    using Base::ColsAtCompileTime;
+    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+
+    using Base::derived;
+    using Base::const_cast_derived;
+    using Base::rows;
+    using Base::cols;
+    using Base::size;
+    using Base::coeff;
+    using Base::coeffRef;
+    using Base::lazyAssign;
+    using Base::eval;
+    using Base::operator-;
+    using Base::operator+=;
+    using Base::operator-=;
+    using Base::operator*=;
+    using Base::operator/=;
+
+    typedef typename Base::CoeffReturnType CoeffReturnType;
+    typedef typename Base::ConstTransposeReturnType ConstTransposeReturnType;
+    typedef typename Base::RowXpr RowXpr;
+    typedef typename Base::ColXpr ColXpr;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** type of the equivalent square matrix */
+    typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime),
+                          EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+    /** \returns the size of the main diagonal, which is min(rows(),cols()).
+      * \sa rows(), cols(), SizeAtCompileTime. */
+    EIGEN_DEVICE_FUNC
+    inline Index diagonalSize() const { return (numext::mini)(rows(),cols()); }
+
+    typedef typename Base::PlainObject PlainObject;
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject> ConstantReturnType;
+    /** \internal the return type of MatrixBase::adjoint() */
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
+                        ConstTransposeReturnType
+                     >::type AdjointReturnType;
+    /** \internal Return type of eigenvalues() */
+    typedef Matrix<std::complex<RealScalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType;
+    /** \internal the return type of identity */
+    typedef CwiseNullaryOp<internal::scalar_identity_op<Scalar>,PlainObject> IdentityReturnType;
+    /** \internal the return type of unit vectors */
+    typedef Block<const CwiseNullaryOp<internal::scalar_identity_op<Scalar>, SquareMatrixType>,
+                  internal::traits<Derived>::RowsAtCompileTime,
+                  internal::traits<Derived>::ColsAtCompileTime> BasisReturnType;
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#   include "../plugins/CommonCwiseBinaryOps.h"
+#   include "../plugins/MatrixCwiseUnaryOps.h"
+#   include "../plugins/MatrixCwiseBinaryOps.h"
+#   ifdef EIGEN_MATRIXBASE_PLUGIN
+#     include EIGEN_MATRIXBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_UNARY_ADDONS
+
+    /** Special case of the template operator=, in order to prevent the compiler
+      * from generating a default operator= (issue hit with g++ 4.1)
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const MatrixBase& other);
+
+    // We cannot inherit here via Base::operator= since it is causing
+    // trouble with MSVC.
+
+    template <typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator=(const DenseBase<OtherDerived>& other);
+
+    template <typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const EigenBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    Derived& operator=(const ReturnByValue<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator+=(const MatrixBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator-=(const MatrixBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived,OtherDerived>
+    operator*(const MatrixBase<OtherDerived> &other) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived,OtherDerived,LazyProduct>
+    lazyProduct(const MatrixBase<OtherDerived> &other) const;
+
+    template<typename OtherDerived>
+    Derived& operator*=(const EigenBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    void applyOnTheLeft(const EigenBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    void applyOnTheRight(const EigenBase<OtherDerived>& other);
+
+    template<typename DiagonalDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<Derived, DiagonalDerived, LazyProduct>
+    operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
+    dot(const MatrixBase<OtherDerived>& other) const;
+
+    EIGEN_DEVICE_FUNC RealScalar squaredNorm() const;
+    EIGEN_DEVICE_FUNC RealScalar norm() const;
+    RealScalar stableNorm() const;
+    RealScalar blueNorm() const;
+    RealScalar hypotNorm() const;
+    EIGEN_DEVICE_FUNC const PlainObject normalized() const;
+    EIGEN_DEVICE_FUNC const PlainObject stableNormalized() const;
+    EIGEN_DEVICE_FUNC void normalize();
+    EIGEN_DEVICE_FUNC void stableNormalize();
+
+    EIGEN_DEVICE_FUNC const AdjointReturnType adjoint() const;
+    EIGEN_DEVICE_FUNC void adjointInPlace();
+
+    typedef Diagonal<Derived> DiagonalReturnType;
+    EIGEN_DEVICE_FUNC
+    DiagonalReturnType diagonal();
+
+    typedef typename internal::add_const<Diagonal<const Derived> >::type ConstDiagonalReturnType;
+    EIGEN_DEVICE_FUNC
+    ConstDiagonalReturnType diagonal() const;
+
+    template<int Index> struct DiagonalIndexReturnType { typedef Diagonal<Derived,Index> Type; };
+    template<int Index> struct ConstDiagonalIndexReturnType { typedef const Diagonal<const Derived,Index> Type; };
+
+    template<int Index>
+    EIGEN_DEVICE_FUNC
+    typename DiagonalIndexReturnType<Index>::Type diagonal();
+
+    template<int Index>
+    EIGEN_DEVICE_FUNC
+    typename ConstDiagonalIndexReturnType<Index>::Type diagonal() const;
+
+    typedef Diagonal<Derived,DynamicIndex> DiagonalDynamicIndexReturnType;
+    typedef typename internal::add_const<Diagonal<const Derived,DynamicIndex> >::type ConstDiagonalDynamicIndexReturnType;
+
+    EIGEN_DEVICE_FUNC
+    DiagonalDynamicIndexReturnType diagonal(Index index);
+    EIGEN_DEVICE_FUNC
+    ConstDiagonalDynamicIndexReturnType diagonal(Index index) const;
+
+    template<unsigned int Mode> struct TriangularViewReturnType { typedef TriangularView<Derived, Mode> Type; };
+    template<unsigned int Mode> struct ConstTriangularViewReturnType { typedef const TriangularView<const Derived, Mode> Type; };
+
+    template<unsigned int Mode>
+    EIGEN_DEVICE_FUNC
+    typename TriangularViewReturnType<Mode>::Type triangularView();
+    template<unsigned int Mode>
+    EIGEN_DEVICE_FUNC
+    typename ConstTriangularViewReturnType<Mode>::Type triangularView() const;
+
+    template<unsigned int UpLo> struct SelfAdjointViewReturnType { typedef SelfAdjointView<Derived, UpLo> Type; };
+    template<unsigned int UpLo> struct ConstSelfAdjointViewReturnType { typedef const SelfAdjointView<const Derived, UpLo> Type; };
+
+    template<unsigned int UpLo>
+    EIGEN_DEVICE_FUNC
+    typename SelfAdjointViewReturnType<UpLo>::Type selfadjointView();
+    template<unsigned int UpLo>
+    EIGEN_DEVICE_FUNC
+    typename ConstSelfAdjointViewReturnType<UpLo>::Type selfadjointView() const;
+
+    const SparseView<Derived> sparseView(const Scalar& m_reference = Scalar(0),
+                                         const typename NumTraits<Scalar>::Real& m_epsilon = NumTraits<Scalar>::dummy_precision()) const;
+    EIGEN_DEVICE_FUNC static const IdentityReturnType Identity();
+    EIGEN_DEVICE_FUNC static const IdentityReturnType Identity(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC static const BasisReturnType Unit(Index size, Index i);
+    EIGEN_DEVICE_FUNC static const BasisReturnType Unit(Index i);
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitX();
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitY();
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitZ();
+    EIGEN_DEVICE_FUNC static const BasisReturnType UnitW();
+
+    EIGEN_DEVICE_FUNC
+    const DiagonalWrapper<const Derived> asDiagonal() const;
+    const PermutationWrapper<const Derived> asPermutation() const;
+
+    EIGEN_DEVICE_FUNC
+    Derived& setIdentity();
+    EIGEN_DEVICE_FUNC
+    Derived& setIdentity(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setUnit(Index i);
+    EIGEN_DEVICE_FUNC Derived& setUnit(Index newSize, Index i);
+
+    bool isIdentity(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    bool isDiagonal(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    bool isUpperTriangular(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    bool isLowerTriangular(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    template<typename OtherDerived>
+    bool isOrthogonal(const MatrixBase<OtherDerived>& other,
+                      const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+    bool isUnitary(const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    /** \returns true if each coefficients of \c *this and \a other are all exactly equal.
+      * \warning When using floating point scalar values you probably should rather use a
+      *          fuzzy comparison such as isApprox()
+      * \sa isApprox(), operator!= */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC inline bool operator==(const MatrixBase<OtherDerived>& other) const
+    { return cwiseEqual(other).all(); }
+
+    /** \returns true if at least one pair of coefficients of \c *this and \a other are not exactly equal to each other.
+      * \warning When using floating point scalar values you probably should rather use a
+      *          fuzzy comparison such as isApprox()
+      * \sa isApprox(), operator== */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC inline bool operator!=(const MatrixBase<OtherDerived>& other) const
+    { return cwiseNotEqual(other).any(); }
+
+    NoAlias<Derived,Eigen::MatrixBase > EIGEN_DEVICE_FUNC noalias();
+
+    // TODO forceAlignedAccess is temporarily disabled
+    // Need to find a nicer workaround.
+    inline const Derived& forceAlignedAccess() const { return derived(); }
+    inline Derived& forceAlignedAccess() { return derived(); }
+    template<bool Enable> inline const Derived& forceAlignedAccessIf() const { return derived(); }
+    template<bool Enable> inline Derived& forceAlignedAccessIf() { return derived(); }
+
+    EIGEN_DEVICE_FUNC Scalar trace() const;
+
+    template<int p> EIGEN_DEVICE_FUNC RealScalar lpNorm() const;
+
+    EIGEN_DEVICE_FUNC MatrixBase<Derived>& matrix() { return *this; }
+    EIGEN_DEVICE_FUNC const MatrixBase<Derived>& matrix() const { return *this; }
+
+    /** \returns an \link Eigen::ArrayBase Array \endlink expression of this matrix
+      * \sa ArrayBase::matrix() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ArrayWrapper<Derived> array() { return ArrayWrapper<Derived>(derived()); }
+    /** \returns a const \link Eigen::ArrayBase Array \endlink expression of this matrix
+      * \sa ArrayBase::matrix() */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArrayWrapper<const Derived> array() const { return ArrayWrapper<const Derived>(derived()); }
+
+/////////// LU module ///////////
+
+    inline const FullPivLU<PlainObject> fullPivLu() const;
+    inline const PartialPivLU<PlainObject> partialPivLu() const;
+
+    inline const PartialPivLU<PlainObject> lu() const;
+
+    EIGEN_DEVICE_FUNC
+    inline const Inverse<Derived> inverse() const;
+
+    template<typename ResultType>
+    inline void computeInverseAndDetWithCheck(
+      ResultType& inverse,
+      typename ResultType::Scalar& determinant,
+      bool& invertible,
+      const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
+    ) const;
+
+    template<typename ResultType>
+    inline void computeInverseWithCheck(
+      ResultType& inverse,
+      bool& invertible,
+      const RealScalar& absDeterminantThreshold = NumTraits<Scalar>::dummy_precision()
+    ) const;
+
+    EIGEN_DEVICE_FUNC
+    Scalar determinant() const;
+
+/////////// Cholesky module ///////////
+
+    inline const LLT<PlainObject>  llt() const;
+    inline const LDLT<PlainObject> ldlt() const;
+
+/////////// QR module ///////////
+
+    inline const HouseholderQR<PlainObject> householderQr() const;
+    inline const ColPivHouseholderQR<PlainObject> colPivHouseholderQr() const;
+    inline const FullPivHouseholderQR<PlainObject> fullPivHouseholderQr() const;
+    inline const CompleteOrthogonalDecomposition<PlainObject> completeOrthogonalDecomposition() const;
+
+/////////// Eigenvalues module ///////////
+
+    inline EigenvaluesReturnType eigenvalues() const;
+    inline RealScalar operatorNorm() const;
+
+/////////// SVD module ///////////
+
+    inline JacobiSVD<PlainObject> jacobiSvd(unsigned int computationOptions = 0) const;
+    inline BDCSVD<PlainObject>    bdcSvd(unsigned int computationOptions = 0) const;
+
+/////////// Geometry module ///////////
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /// \internal helper struct to form the return type of the cross product
+    template<typename OtherDerived> struct cross_product_return_type {
+      typedef typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType Scalar;
+      typedef Matrix<Scalar,MatrixBase::RowsAtCompileTime,MatrixBase::ColsAtCompileTime> type;
+    };
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    inline typename cross_product_return_type<OtherDerived>::type
+#else
+    inline PlainObject
+#endif
+    cross(const MatrixBase<OtherDerived>& other) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    inline PlainObject cross3(const MatrixBase<OtherDerived>& other) const;
+
+    EIGEN_DEVICE_FUNC
+    inline PlainObject unitOrthogonal(void) const;
+
+    EIGEN_DEVICE_FUNC
+    inline Matrix<Scalar,3,1> eulerAngles(Index a0, Index a1, Index a2) const;
+
+    // put this as separate enum value to work around possible GCC 4.3 bug (?)
+    enum { HomogeneousReturnTypeDirection = ColsAtCompileTime==1&&RowsAtCompileTime==1 ? ((internal::traits<Derived>::Flags&RowMajorBit)==RowMajorBit ? Horizontal : Vertical)
+                                          : ColsAtCompileTime==1 ? Vertical : Horizontal };
+    typedef Homogeneous<Derived, HomogeneousReturnTypeDirection> HomogeneousReturnType;
+    EIGEN_DEVICE_FUNC
+    inline HomogeneousReturnType homogeneous() const;
+
+    enum {
+      SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1
+    };
+    typedef Block<const Derived,
+                  internal::traits<Derived>::ColsAtCompileTime==1 ? SizeMinusOne : 1,
+                  internal::traits<Derived>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> ConstStartMinusOne;
+    typedef EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(ConstStartMinusOne,Scalar,quotient) HNormalizedReturnType;
+    EIGEN_DEVICE_FUNC
+    inline const HNormalizedReturnType hnormalized() const;
+
+////////// Householder module ///////////
+
+    EIGEN_DEVICE_FUNC
+    void makeHouseholderInPlace(Scalar& tau, RealScalar& beta);
+    template<typename EssentialPart>
+    EIGEN_DEVICE_FUNC
+    void makeHouseholder(EssentialPart& essential,
+                         Scalar& tau, RealScalar& beta) const;
+    template<typename EssentialPart>
+    EIGEN_DEVICE_FUNC
+    void applyHouseholderOnTheLeft(const EssentialPart& essential,
+                                   const Scalar& tau,
+                                   Scalar* workspace);
+    template<typename EssentialPart>
+    EIGEN_DEVICE_FUNC
+    void applyHouseholderOnTheRight(const EssentialPart& essential,
+                                    const Scalar& tau,
+                                    Scalar* workspace);
+
+///////// Jacobi module /////////
+
+    template<typename OtherScalar>
+    EIGEN_DEVICE_FUNC
+    void applyOnTheLeft(Index p, Index q, const JacobiRotation<OtherScalar>& j);
+    template<typename OtherScalar>
+    EIGEN_DEVICE_FUNC
+    void applyOnTheRight(Index p, Index q, const JacobiRotation<OtherScalar>& j);
+
+///////// SparseCore module /////////
+
+    template<typename OtherDerived>
+    EIGEN_STRONG_INLINE const typename SparseMatrixBase<OtherDerived>::template CwiseProductDenseReturnType<Derived>::Type
+    cwiseProduct(const SparseMatrixBase<OtherDerived> &other) const
+    {
+      return other.cwiseProduct(derived());
+    }
+
+///////// MatrixFunctions module /////////
+
+    typedef typename internal::stem_function<Scalar>::type StemFunction;
+#define EIGEN_MATRIX_FUNCTION(ReturnType, Name, Description) \
+    /** \returns an expression of the matrix Description of \c *this. \brief This function requires the <a href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>. To compute the coefficient-wise Description use ArrayBase::##Name . */ \
+    const ReturnType<Derived> Name() const;
+#define EIGEN_MATRIX_FUNCTION_1(ReturnType, Name, Description, Argument) \
+    /** \returns an expression of the matrix Description of \c *this. \brief This function requires the <a href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>. To compute the coefficient-wise Description use ArrayBase::##Name . */ \
+    const ReturnType<Derived> Name(Argument) const;
+
+    EIGEN_MATRIX_FUNCTION(MatrixExponentialReturnValue, exp, exponential)
+    /** \brief Helper function for the <a href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>.*/
+    const MatrixFunctionReturnValue<Derived> matrixFunction(StemFunction f) const;
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, cosh, hyperbolic cosine)
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, sinh, hyperbolic sine)
+#if EIGEN_HAS_CXX11_MATH
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, atanh, inverse hyperbolic cosine)
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, acosh, inverse hyperbolic cosine)
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, asinh, inverse hyperbolic sine)
+#endif
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, cos, cosine)
+    EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, sin, sine)
+    EIGEN_MATRIX_FUNCTION(MatrixSquareRootReturnValue, sqrt, square root)
+    EIGEN_MATRIX_FUNCTION(MatrixLogarithmReturnValue, log, logarithm)
+    EIGEN_MATRIX_FUNCTION_1(MatrixPowerReturnValue,        pow, power to \c p, const RealScalar& p)
+    EIGEN_MATRIX_FUNCTION_1(MatrixComplexPowerReturnValue, pow, power to \c p, const std::complex<RealScalar>& p)
+
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(MatrixBase)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(MatrixBase)
+
+  private:
+    EIGEN_DEVICE_FUNC explicit MatrixBase(int);
+    EIGEN_DEVICE_FUNC MatrixBase(int,int);
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit MatrixBase(const MatrixBase<OtherDerived>&);
+  protected:
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator+=(const ArrayBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+    // mixing arrays and matrices is not legal
+    template<typename OtherDerived> Derived& operator-=(const ArrayBase<OtherDerived>& )
+    {EIGEN_STATIC_ASSERT(std::ptrdiff_t(sizeof(typename OtherDerived::Scalar))==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES); return *this;}
+};
+
+
+/***************************************************************************
+* Implementation of matrix base methods
+***************************************************************************/
+
+/** replaces \c *this by \c *this * \a other.
+  *
+  * \returns a reference to \c *this
+  *
+  * Example: \include MatrixBase_applyOnTheRight.cpp
+  * Output: \verbinclude MatrixBase_applyOnTheRight.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+inline Derived&
+MatrixBase<Derived>::operator*=(const EigenBase<OtherDerived> &other)
+{
+  other.derived().applyThisOnTheRight(derived());
+  return derived();
+}
+
+/** replaces \c *this by \c *this * \a other. It is equivalent to MatrixBase::operator*=().
+  *
+  * Example: \include MatrixBase_applyOnTheRight.cpp
+  * Output: \verbinclude MatrixBase_applyOnTheRight.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+inline void MatrixBase<Derived>::applyOnTheRight(const EigenBase<OtherDerived> &other)
+{
+  other.derived().applyThisOnTheRight(derived());
+}
+
+/** replaces \c *this by \a other * \c *this.
+  *
+  * Example: \include MatrixBase_applyOnTheLeft.cpp
+  * Output: \verbinclude MatrixBase_applyOnTheLeft.out
+  */
+template<typename Derived>
+template<typename OtherDerived>
+inline void MatrixBase<Derived>::applyOnTheLeft(const EigenBase<OtherDerived> &other)
+{
+  other.derived().applyThisOnTheLeft(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIXBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/NestByValue.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/NestByValue.h
new file mode 100644
index 00000000..b4275768
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/NestByValue.h
@@ -0,0 +1,85 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NESTBYVALUE_H
+#define EIGEN_NESTBYVALUE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename ExpressionType>
+struct traits<NestByValue<ExpressionType> > : public traits<ExpressionType>
+{
+  enum {
+    Flags = traits<ExpressionType>::Flags & ~NestByRefBit
+  };
+};
+}
+
+/** \class NestByValue
+  * \ingroup Core_Module
+  *
+  * \brief Expression which must be nested by value
+  *
+  * \tparam ExpressionType the type of the object of which we are requiring nesting-by-value
+  *
+  * This class is the return type of MatrixBase::nestByValue()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::nestByValue()
+  */
+template<typename ExpressionType> class NestByValue
+  : public internal::dense_xpr_base< NestByValue<ExpressionType> >::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<NestByValue>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(NestByValue)
+
+    EIGEN_DEVICE_FUNC explicit inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index rows() const EIGEN_NOEXCEPT { return m_expression.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index cols() const EIGEN_NOEXCEPT { return m_expression.cols(); }
+
+    EIGEN_DEVICE_FUNC operator const ExpressionType&() const { return m_expression; }
+
+    EIGEN_DEVICE_FUNC const ExpressionType& nestedExpression() const { return m_expression; }
+
+  protected:
+    const ExpressionType m_expression;
+};
+
+/** \returns an expression of the temporary version of *this.
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const NestByValue<Derived>
+DenseBase<Derived>::nestByValue() const
+{
+  return NestByValue<Derived>(derived());
+}
+
+namespace internal {
+
+// Evaluator of Solve -> eval into a temporary
+template<typename ArgType>
+struct evaluator<NestByValue<ArgType> >
+  : public evaluator<ArgType>
+{
+  typedef evaluator<ArgType> Base;
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const NestByValue<ArgType>& xpr)
+    : Base(xpr.nestedExpression())
+  {}
+};
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_NESTBYVALUE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/NoAlias.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/NoAlias.h
new file mode 100644
index 00000000..570283d9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/NoAlias.h
@@ -0,0 +1,109 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NOALIAS_H
+#define EIGEN_NOALIAS_H
+
+namespace Eigen {
+
+/** \class NoAlias
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression providing an operator = assuming no aliasing
+  *
+  * \tparam ExpressionType the type of the object on which to do the lazy assignment
+  *
+  * This class represents an expression with special assignment operators
+  * assuming no aliasing between the target expression and the source expression.
+  * More precisely it alloas to bypass the EvalBeforeAssignBit flag of the source expression.
+  * It is the return type of MatrixBase::noalias()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::noalias()
+  */
+template<typename ExpressionType, template <typename> class StorageBase>
+class NoAlias
+{
+  public:
+    typedef typename ExpressionType::Scalar Scalar;
+    
+    EIGEN_DEVICE_FUNC
+    explicit NoAlias(ExpressionType& expression) : m_expression(expression) {}
+    
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase<OtherDerived>& other)
+    {
+      call_assignment_no_alias(m_expression, other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+      return m_expression;
+    }
+    
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase<OtherDerived>& other)
+    {
+      call_assignment_no_alias(m_expression, other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+      return m_expression;
+    }
+    
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase<OtherDerived>& other)
+    {
+      call_assignment_no_alias(m_expression, other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+      return m_expression;
+    }
+
+    EIGEN_DEVICE_FUNC
+    ExpressionType& expression() const
+    {
+      return m_expression;
+    }
+
+  protected:
+    ExpressionType& m_expression;
+};
+
+/** \returns a pseudo expression of \c *this with an operator= assuming
+  * no aliasing between \c *this and the source expression.
+  *
+  * More precisely, noalias() allows to bypass the EvalBeforeAssignBit flag.
+  * Currently, even though several expressions may alias, only product
+  * expressions have this flag. Therefore, noalias() is only useful when
+  * the source expression contains a matrix product.
+  *
+  * Here are some examples where noalias is useful:
+  * \code
+  * D.noalias()  = A * B;
+  * D.noalias() += A.transpose() * B;
+  * D.noalias() -= 2 * A * B.adjoint();
+  * \endcode
+  *
+  * On the other hand the following example will lead to a \b wrong result:
+  * \code
+  * A.noalias() = A * B;
+  * \endcode
+  * because the result matrix A is also an operand of the matrix product. Therefore,
+  * there is no alternative than evaluating A * B in a temporary, that is the default
+  * behavior when you write:
+  * \code
+  * A = A * B;
+  * \endcode
+  *
+  * \sa class NoAlias
+  */
+template<typename Derived>
+NoAlias<Derived,MatrixBase> EIGEN_DEVICE_FUNC MatrixBase<Derived>::noalias()
+{
+  return NoAlias<Derived, Eigen::MatrixBase >(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_NOALIAS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/NumTraits.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/NumTraits.h
new file mode 100644
index 00000000..72eac5a9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/NumTraits.h
@@ -0,0 +1,335 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NUMTRAITS_H
+#define EIGEN_NUMTRAITS_H
+
+namespace Eigen {
+
+namespace internal {
+
+// default implementation of digits10(), based on numeric_limits if specialized,
+// 0 for integer types, and log10(epsilon()) otherwise.
+template< typename T,
+          bool use_numeric_limits = std::numeric_limits<T>::is_specialized,
+          bool is_integer = NumTraits<T>::IsInteger>
+struct default_digits10_impl
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() { return std::numeric_limits<T>::digits10; }
+};
+
+template<typename T>
+struct default_digits10_impl<T,false,false> // Floating point
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() {
+    using std::log10;
+    using std::ceil;
+    typedef typename NumTraits<T>::Real Real;
+    return int(ceil(-log10(NumTraits<Real>::epsilon())));
+  }
+};
+
+template<typename T>
+struct default_digits10_impl<T,false,true> // Integer
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() { return 0; }
+};
+
+
+// default implementation of digits(), based on numeric_limits if specialized,
+// 0 for integer types, and log2(epsilon()) otherwise.
+template< typename T,
+          bool use_numeric_limits = std::numeric_limits<T>::is_specialized,
+          bool is_integer = NumTraits<T>::IsInteger>
+struct default_digits_impl
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() { return std::numeric_limits<T>::digits; }
+};
+
+template<typename T>
+struct default_digits_impl<T,false,false> // Floating point
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() {
+    using std::log;
+    using std::ceil;
+    typedef typename NumTraits<T>::Real Real;
+    return int(ceil(-log(NumTraits<Real>::epsilon())/log(static_cast<Real>(2))));
+  }
+};
+
+template<typename T>
+struct default_digits_impl<T,false,true> // Integer
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int run() { return 0; }
+};
+
+} // end namespace internal
+
+namespace numext {
+/** \internal bit-wise cast without changing the underlying bit representation. */
+
+// TODO: Replace by std::bit_cast (available in C++20)
+template <typename Tgt, typename Src>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Tgt bit_cast(const Src& src) {
+#if EIGEN_HAS_TYPE_TRAITS
+  // The behaviour of memcpy is not specified for non-trivially copyable types
+  EIGEN_STATIC_ASSERT(std::is_trivially_copyable<Src>::value, THIS_TYPE_IS_NOT_SUPPORTED);
+  EIGEN_STATIC_ASSERT(std::is_trivially_copyable<Tgt>::value && std::is_default_constructible<Tgt>::value,
+                      THIS_TYPE_IS_NOT_SUPPORTED);
+#endif
+
+  EIGEN_STATIC_ASSERT(sizeof(Src) == sizeof(Tgt), THIS_TYPE_IS_NOT_SUPPORTED);
+  Tgt tgt;
+  EIGEN_USING_STD(memcpy)
+  memcpy(&tgt, &src, sizeof(Tgt));
+  return tgt;
+}
+}  // namespace numext
+
+/** \class NumTraits
+  * \ingroup Core_Module
+  *
+  * \brief Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
+  *
+  * \tparam T the numeric type at hand
+  *
+  * This class stores enums, typedefs and static methods giving information about a numeric type.
+  *
+  * The provided data consists of:
+  * \li A typedef \c Real, giving the "real part" type of \a T. If \a T is already real,
+  *     then \c Real is just a typedef to \a T. If \a T is \c std::complex<U> then \c Real
+  *     is a typedef to \a U.
+  * \li A typedef \c NonInteger, giving the type that should be used for operations producing non-integral values,
+  *     such as quotients, square roots, etc. If \a T is a floating-point type, then this typedef just gives
+  *     \a T again. Note however that many Eigen functions such as internal::sqrt simply refuse to
+  *     take integers. Outside of a few cases, Eigen doesn't do automatic type promotion. Thus, this typedef is
+  *     only intended as a helper for code that needs to explicitly promote types.
+  * \li A typedef \c Literal giving the type to use for numeric literals such as "2" or "0.5". For instance, for \c std::complex<U>, Literal is defined as \c U.
+  *     Of course, this type must be fully compatible with \a T. In doubt, just use \a T here.
+  * \li A typedef \a Nested giving the type to use to nest a value inside of the expression tree. If you don't know what
+  *     this means, just use \a T here.
+  * \li An enum value \a IsComplex. It is equal to 1 if \a T is a \c std::complex
+  *     type, and to 0 otherwise.
+  * \li An enum value \a IsInteger. It is equal to \c 1 if \a T is an integer type such as \c int,
+  *     and to \c 0 otherwise.
+  * \li Enum values ReadCost, AddCost and MulCost representing a rough estimate of the number of CPU cycles needed
+  *     to by move / add / mul instructions respectively, assuming the data is already stored in CPU registers.
+  *     Stay vague here. No need to do architecture-specific stuff. If you don't know what this means, just use \c Eigen::HugeCost.
+  * \li An enum value \a IsSigned. It is equal to \c 1 if \a T is a signed type and to 0 if \a T is unsigned.
+  * \li An enum value \a RequireInitialization. It is equal to \c 1 if the constructor of the numeric type \a T must
+  *     be called, and to 0 if it is safe not to call it. Default is 0 if \a T is an arithmetic type, and 1 otherwise.
+  * \li An epsilon() function which, unlike <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/epsilon">std::numeric_limits::epsilon()</a>,
+  *     it returns a \a Real instead of a \a T.
+  * \li A dummy_precision() function returning a weak epsilon value. It is mainly used as a default
+  *     value by the fuzzy comparison operators.
+  * \li highest() and lowest() functions returning the highest and lowest possible values respectively.
+  * \li digits() function returning the number of radix digits (non-sign digits for integers, mantissa for floating-point). This is
+  *     the analogue of <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/digits">std::numeric_limits<T>::digits</a>
+  *     which is used as the default implementation if specialized.
+  * \li digits10() function returning the number of decimal digits that can be represented without change. This is
+  *     the analogue of <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/digits10">std::numeric_limits<T>::digits10</a>
+  *     which is used as the default implementation if specialized.
+  * \li min_exponent() and max_exponent() functions returning the highest and lowest possible values, respectively,
+  *     such that the radix raised to the power exponent-1 is a normalized floating-point number.  These are equivalent to
+  *     <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/min_exponent">std::numeric_limits<T>::min_exponent</a>/
+  *     <a href="http://en.cppreference.com/w/cpp/types/numeric_limits/max_exponent">std::numeric_limits<T>::max_exponent</a>.
+  * \li infinity() function returning a representation of positive infinity, if available.
+  * \li quiet_NaN function returning a non-signaling "not-a-number", if available.
+  */
+
+template<typename T> struct GenericNumTraits
+{
+  enum {
+    IsInteger = std::numeric_limits<T>::is_integer,
+    IsSigned = std::numeric_limits<T>::is_signed,
+    IsComplex = 0,
+    RequireInitialization = internal::is_arithmetic<T>::value ? 0 : 1,
+    ReadCost = 1,
+    AddCost = 1,
+    MulCost = 1
+  };
+
+  typedef T Real;
+  typedef typename internal::conditional<
+                     IsInteger,
+                     typename internal::conditional<sizeof(T)<=2, float, double>::type,
+                     T
+                   >::type NonInteger;
+  typedef T Nested;
+  typedef T Literal;
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline Real epsilon()
+  {
+    return numext::numeric_limits<T>::epsilon();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline int digits10()
+  {
+    return internal::default_digits10_impl<T>::run();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline int digits()
+  {
+    return internal::default_digits_impl<T>::run();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline int min_exponent()
+  {
+    return numext::numeric_limits<T>::min_exponent;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline int max_exponent()
+  {
+    return numext::numeric_limits<T>::max_exponent;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline Real dummy_precision()
+  {
+    // make sure to override this for floating-point types
+    return Real(0);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline T highest() {
+    return (numext::numeric_limits<T>::max)();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline T lowest()  {
+    return IsInteger ? (numext::numeric_limits<T>::min)()
+                     : static_cast<T>(-(numext::numeric_limits<T>::max)());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline T infinity() {
+    return numext::numeric_limits<T>::infinity();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline T quiet_NaN() {
+    return numext::numeric_limits<T>::quiet_NaN();
+  }
+};
+
+template<typename T> struct NumTraits : GenericNumTraits<T>
+{};
+
+template<> struct NumTraits<float>
+  : GenericNumTraits<float>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline float dummy_precision() { return 1e-5f; }
+};
+
+template<> struct NumTraits<double> : GenericNumTraits<double>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline double dummy_precision() { return 1e-12; }
+};
+
+template<> struct NumTraits<long double>
+  : GenericNumTraits<long double>
+{
+  EIGEN_CONSTEXPR
+  static inline long double dummy_precision() { return 1e-15l; }
+};
+
+template<typename _Real> struct NumTraits<std::complex<_Real> >
+  : GenericNumTraits<std::complex<_Real> >
+{
+  typedef _Real Real;
+  typedef typename NumTraits<_Real>::Literal Literal;
+  enum {
+    IsComplex = 1,
+    RequireInitialization = NumTraits<_Real>::RequireInitialization,
+    ReadCost = 2 * NumTraits<_Real>::ReadCost,
+    AddCost = 2 * NumTraits<Real>::AddCost,
+    MulCost = 4 * NumTraits<Real>::MulCost + 2 * NumTraits<Real>::AddCost
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline Real epsilon() { return NumTraits<Real>::epsilon(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline Real dummy_precision() { return NumTraits<Real>::dummy_precision(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline int digits10() { return NumTraits<Real>::digits10(); }
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+struct NumTraits<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
+{
+  typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> ArrayType;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Array<RealScalar, Rows, Cols, Options, MaxRows, MaxCols> Real;
+  typedef typename NumTraits<Scalar>::NonInteger NonIntegerScalar;
+  typedef Array<NonIntegerScalar, Rows, Cols, Options, MaxRows, MaxCols> NonInteger;
+  typedef ArrayType & Nested;
+  typedef typename NumTraits<Scalar>::Literal Literal;
+
+  enum {
+    IsComplex = NumTraits<Scalar>::IsComplex,
+    IsInteger = NumTraits<Scalar>::IsInteger,
+    IsSigned  = NumTraits<Scalar>::IsSigned,
+    RequireInitialization = 1,
+    ReadCost = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * int(NumTraits<Scalar>::ReadCost),
+    AddCost  = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * int(NumTraits<Scalar>::AddCost),
+    MulCost  = ArrayType::SizeAtCompileTime==Dynamic ? HugeCost : ArrayType::SizeAtCompileTime * int(NumTraits<Scalar>::MulCost)
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline RealScalar epsilon() { return NumTraits<RealScalar>::epsilon(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static inline RealScalar dummy_precision() { return NumTraits<RealScalar>::dummy_precision(); }
+
+  EIGEN_CONSTEXPR
+  static inline int digits10() { return NumTraits<Scalar>::digits10(); }
+};
+
+template<> struct NumTraits<std::string>
+  : GenericNumTraits<std::string>
+{
+  enum {
+    RequireInitialization = 1,
+    ReadCost = HugeCost,
+    AddCost  = HugeCost,
+    MulCost  = HugeCost
+  };
+
+  EIGEN_CONSTEXPR
+  static inline int digits10() { return 0; }
+
+private:
+  static inline std::string epsilon();
+  static inline std::string dummy_precision();
+  static inline std::string lowest();
+  static inline std::string highest();
+  static inline std::string infinity();
+  static inline std::string quiet_NaN();
+};
+
+// Empty specialization for void to allow template specialization based on NumTraits<T>::Real with T==void and SFINAE.
+template<> struct NumTraits<void> {};
+
+template<> struct NumTraits<bool> : GenericNumTraits<bool> {};
+
+} // end namespace Eigen
+
+#endif // EIGEN_NUMTRAITS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/PartialReduxEvaluator.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/PartialReduxEvaluator.h
new file mode 100644
index 00000000..29abf35b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/PartialReduxEvaluator.h
@@ -0,0 +1,232 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2018 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARTIALREDUX_H
+#define EIGEN_PARTIALREDUX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+/***************************************************************************
+*
+* This file provides evaluators for partial reductions.
+* There are two modes:
+*
+*  - scalar path: simply calls the respective function on the column or row.
+*    -> nothing special here, all the tricky part is handled by the return
+*       types of VectorwiseOp's members. They embed the functor calling the
+*       respective DenseBase's member function.
+*
+*  - vectorized path: implements a packet-wise reductions followed by
+*    some (optional) processing of the outcome, e.g., division by n for mean.
+*
+* For the vectorized path let's observe that the packet-size and outer-unrolling
+* are both decided by the assignement logic. So all we have to do is to decide
+* on the inner unrolling.
+*
+* For the unrolling, we can reuse "internal::redux_vec_unroller" from Redux.h,
+* but be need to be careful to specify correct increment.
+*
+***************************************************************************/
+
+
+/* logic deciding a strategy for unrolling of vectorized paths */
+template<typename Func, typename Evaluator>
+struct packetwise_redux_traits
+{
+  enum {
+    OuterSize = int(Evaluator::IsRowMajor) ? Evaluator::RowsAtCompileTime : Evaluator::ColsAtCompileTime,
+    Cost = OuterSize == Dynamic ? HugeCost
+         : OuterSize * Evaluator::CoeffReadCost + (OuterSize-1) * functor_traits<Func>::Cost,
+    Unrolling = Cost <= EIGEN_UNROLLING_LIMIT ? CompleteUnrolling : NoUnrolling
+  };
+
+};
+
+/* Value to be returned when size==0 , by default let's return 0 */
+template<typename PacketType,typename Func>
+EIGEN_DEVICE_FUNC
+PacketType packetwise_redux_empty_value(const Func& ) { return pset1<PacketType>(0); }
+
+/* For products the default is 1 */
+template<typename PacketType,typename Scalar>
+EIGEN_DEVICE_FUNC
+PacketType packetwise_redux_empty_value(const scalar_product_op<Scalar,Scalar>& ) { return pset1<PacketType>(1); }
+
+/* Perform the actual reduction */
+template<typename Func, typename Evaluator,
+         int Unrolling = packetwise_redux_traits<Func, Evaluator>::Unrolling
+>
+struct packetwise_redux_impl;
+
+/* Perform the actual reduction with unrolling */
+template<typename Func, typename Evaluator>
+struct packetwise_redux_impl<Func, Evaluator, CompleteUnrolling>
+{
+  typedef redux_novec_unroller<Func,Evaluator, 0, Evaluator::SizeAtCompileTime> Base;
+  typedef typename Evaluator::Scalar Scalar;
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE
+  PacketType run(const Evaluator &eval, const Func& func, Index /*size*/)
+  {
+    return redux_vec_unroller<Func, Evaluator, 0, packetwise_redux_traits<Func, Evaluator>::OuterSize>::template run<PacketType>(eval,func);
+  }
+};
+
+/* Add a specialization of redux_vec_unroller for size==0 at compiletime.
+ * This specialization is not required for general reductions, which is
+ * why it is defined here.
+ */
+template<typename Func, typename Evaluator, int Start>
+struct redux_vec_unroller<Func, Evaluator, Start, 0>
+{
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE PacketType run(const Evaluator &, const Func& f)
+  {
+    return packetwise_redux_empty_value<PacketType>(f);
+  }
+};
+
+/* Perform the actual reduction for dynamic sizes */
+template<typename Func, typename Evaluator>
+struct packetwise_redux_impl<Func, Evaluator, NoUnrolling>
+{
+  typedef typename Evaluator::Scalar Scalar;
+  typedef typename redux_traits<Func, Evaluator>::PacketType PacketScalar;
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC
+  static PacketType run(const Evaluator &eval, const Func& func, Index size)
+  {
+    if(size==0)
+      return packetwise_redux_empty_value<PacketType>(func);
+    
+    const Index size4 = (size-1)&(~3);
+    PacketType p = eval.template packetByOuterInner<Unaligned,PacketType>(0,0);
+    Index i = 1;
+    // This loop is optimized for instruction pipelining:
+    // - each iteration generates two independent instructions
+    // - thanks to branch prediction and out-of-order execution we have independent instructions across loops
+    for(; i<size4; i+=4)
+      p = func.packetOp(p,
+            func.packetOp(
+              func.packetOp(eval.template packetByOuterInner<Unaligned,PacketType>(i+0,0),eval.template packetByOuterInner<Unaligned,PacketType>(i+1,0)),
+              func.packetOp(eval.template packetByOuterInner<Unaligned,PacketType>(i+2,0),eval.template packetByOuterInner<Unaligned,PacketType>(i+3,0))));
+    for(; i<size; ++i)
+      p = func.packetOp(p, eval.template packetByOuterInner<Unaligned,PacketType>(i,0));
+    return p;
+  }
+};
+
+template< typename ArgType, typename MemberOp, int Direction>
+struct evaluator<PartialReduxExpr<ArgType, MemberOp, Direction> >
+  : evaluator_base<PartialReduxExpr<ArgType, MemberOp, Direction> >
+{
+  typedef PartialReduxExpr<ArgType, MemberOp, Direction> XprType;
+  typedef typename internal::nested_eval<ArgType,1>::type ArgTypeNested;
+  typedef typename internal::add_const_on_value_type<ArgTypeNested>::type ConstArgTypeNested;
+  typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNestedCleaned;
+  typedef typename ArgType::Scalar InputScalar;
+  typedef typename XprType::Scalar Scalar;
+  enum {
+    TraversalSize = Direction==int(Vertical) ? int(ArgType::RowsAtCompileTime) :  int(ArgType::ColsAtCompileTime)
+  };
+  typedef typename MemberOp::template Cost<int(TraversalSize)> CostOpType;
+  enum {
+    CoeffReadCost = TraversalSize==Dynamic ? HugeCost
+                  : TraversalSize==0 ? 1
+                  : int(TraversalSize) * int(evaluator<ArgType>::CoeffReadCost) + int(CostOpType::value),
+    
+    _ArgFlags = evaluator<ArgType>::Flags,
+
+    _Vectorizable =  bool(int(_ArgFlags)&PacketAccessBit)
+                  && bool(MemberOp::Vectorizable)
+                  && (Direction==int(Vertical) ? bool(_ArgFlags&RowMajorBit) : (_ArgFlags&RowMajorBit)==0)
+                  && (TraversalSize!=0),
+                  
+    Flags = (traits<XprType>::Flags&RowMajorBit)
+          | (evaluator<ArgType>::Flags&(HereditaryBits&(~RowMajorBit)))
+          | (_Vectorizable ? PacketAccessBit : 0)
+          | LinearAccessBit,
+    
+    Alignment = 0 // FIXME this will need to be improved once PartialReduxExpr is vectorized
+  };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType xpr)
+    : m_arg(xpr.nestedExpression()), m_functor(xpr.functor())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(TraversalSize==Dynamic ? HugeCost : (TraversalSize==0 ? 1 : int(CostOpType::value)));
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar coeff(Index i, Index j) const
+  {
+    return coeff(Direction==Vertical ? j : i);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar coeff(Index index) const
+  {
+    return m_functor(m_arg.template subVector<DirectionType(Direction)>(index));
+  }
+
+  template<int LoadMode,typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  PacketType packet(Index i, Index j) const
+  {
+    return packet<LoadMode,PacketType>(Direction==Vertical ? j : i);
+  }
+  
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+  PacketType packet(Index idx) const
+  {
+    enum { PacketSize = internal::unpacket_traits<PacketType>::size };
+    typedef Block<const ArgTypeNestedCleaned,
+                  Direction==Vertical ? int(ArgType::RowsAtCompileTime) : int(PacketSize),
+                  Direction==Vertical ? int(PacketSize) : int(ArgType::ColsAtCompileTime),
+                  true /* InnerPanel */> PanelType;
+    
+    PanelType panel(m_arg,
+                    Direction==Vertical ? 0 : idx,
+                    Direction==Vertical ? idx : 0,
+                    Direction==Vertical ? m_arg.rows() : Index(PacketSize),
+                    Direction==Vertical ? Index(PacketSize) : m_arg.cols());
+
+    // FIXME
+    // See bug 1612, currently if PacketSize==1 (i.e. complex<double> with 128bits registers) then the storage-order of panel get reversed
+    // and methods like packetByOuterInner do not make sense anymore in this context.
+    // So let's just by pass "vectorization" in this case:
+    if(PacketSize==1)
+      return internal::pset1<PacketType>(coeff(idx));
+    
+    typedef typename internal::redux_evaluator<PanelType> PanelEvaluator;
+    PanelEvaluator panel_eval(panel);
+    typedef typename MemberOp::BinaryOp BinaryOp;
+    PacketType p = internal::packetwise_redux_impl<BinaryOp,PanelEvaluator>::template run<PacketType>(panel_eval,m_functor.binaryFunc(),m_arg.outerSize());
+    return p;
+  }
+
+protected:
+  ConstArgTypeNested m_arg;
+  const MemberOp m_functor;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIALREDUX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/PermutationMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/PermutationMatrix.h
new file mode 100644
index 00000000..69401bf4
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/PermutationMatrix.h
@@ -0,0 +1,605 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PERMUTATIONMATRIX_H
+#define EIGEN_PERMUTATIONMATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+enum PermPermProduct_t {PermPermProduct};
+
+} // end namespace internal
+
+/** \class PermutationBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for permutations
+  *
+  * \tparam Derived the derived class
+  *
+  * This class is the base class for all expressions representing a permutation matrix,
+  * internally stored as a vector of integers.
+  * The convention followed here is that if \f$ \sigma \f$ is a permutation, the corresponding permutation matrix
+  * \f$ P_\sigma \f$ is such that if \f$ (e_1,\ldots,e_p) \f$ is the canonical basis, we have:
+  *  \f[ P_\sigma(e_i) = e_{\sigma(i)}. \f]
+  * This convention ensures that for any two permutations \f$ \sigma, \tau \f$, we have:
+  *  \f[ P_{\sigma\circ\tau} = P_\sigma P_\tau. \f]
+  *
+  * Permutation matrices are square and invertible.
+  *
+  * Notice that in addition to the member functions and operators listed here, there also are non-member
+  * operator* to multiply any kind of permutation object with any kind of matrix expression (MatrixBase)
+  * on either side.
+  *
+  * \sa class PermutationMatrix, class PermutationWrapper
+  */
+template<typename Derived>
+class PermutationBase : public EigenBase<Derived>
+{
+    typedef internal::traits<Derived> Traits;
+    typedef EigenBase<Derived> Base;
+  public:
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    enum {
+      Flags = Traits::Flags,
+      RowsAtCompileTime = Traits::RowsAtCompileTime,
+      ColsAtCompileTime = Traits::ColsAtCompileTime,
+      MaxRowsAtCompileTime = Traits::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = Traits::MaxColsAtCompileTime
+    };
+    typedef typename Traits::StorageIndex StorageIndex;
+    typedef Matrix<StorageIndex,RowsAtCompileTime,ColsAtCompileTime,0,MaxRowsAtCompileTime,MaxColsAtCompileTime>
+            DenseMatrixType;
+    typedef PermutationMatrix<IndicesType::SizeAtCompileTime,IndicesType::MaxSizeAtCompileTime,StorageIndex>
+            PlainPermutationType;
+    typedef PlainPermutationType PlainObject;
+    using Base::derived;
+    typedef Inverse<Derived> InverseReturnType;
+    typedef void Scalar;
+    #endif
+
+    /** Copies the other permutation into *this */
+    template<typename OtherDerived>
+    Derived& operator=(const PermutationBase<OtherDerived>& other)
+    {
+      indices() = other.indices();
+      return derived();
+    }
+
+    /** Assignment from the Transpositions \a tr */
+    template<typename OtherDerived>
+    Derived& operator=(const TranspositionsBase<OtherDerived>& tr)
+    {
+      setIdentity(tr.size());
+      for(Index k=size()-1; k>=0; --k)
+        applyTranspositionOnTheRight(k,tr.coeff(k));
+      return derived();
+    }
+
+    /** \returns the number of rows */
+    inline EIGEN_DEVICE_FUNC Index rows() const { return Index(indices().size()); }
+
+    /** \returns the number of columns */
+    inline EIGEN_DEVICE_FUNC Index cols() const { return Index(indices().size()); }
+
+    /** \returns the size of a side of the respective square matrix, i.e., the number of indices */
+    inline EIGEN_DEVICE_FUNC Index size() const { return Index(indices().size()); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename DenseDerived>
+    void evalTo(MatrixBase<DenseDerived>& other) const
+    {
+      other.setZero();
+      for (Index i=0; i<rows(); ++i)
+        other.coeffRef(indices().coeff(i),i) = typename DenseDerived::Scalar(1);
+    }
+    #endif
+
+    /** \returns a Matrix object initialized from this permutation matrix. Notice that it
+      * is inefficient to return this Matrix object by value. For efficiency, favor using
+      * the Matrix constructor taking EigenBase objects.
+      */
+    DenseMatrixType toDenseMatrix() const
+    {
+      return derived();
+    }
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return derived().indices(); }
+    /** \returns a reference to the stored array representing the permutation. */
+    IndicesType& indices() { return derived().indices(); }
+
+    /** Resizes to given size.
+      */
+    inline void resize(Index newSize)
+    {
+      indices().resize(newSize);
+    }
+
+    /** Sets *this to be the identity permutation matrix */
+    void setIdentity()
+    {
+      StorageIndex n = StorageIndex(size());
+      for(StorageIndex i = 0; i < n; ++i)
+        indices().coeffRef(i) = i;
+    }
+
+    /** Sets *this to be the identity permutation matrix of given size.
+      */
+    void setIdentity(Index newSize)
+    {
+      resize(newSize);
+      setIdentity();
+    }
+
+    /** Multiplies *this by the transposition \f$(ij)\f$ on the left.
+      *
+      * \returns a reference to *this.
+      *
+      * \warning This is much slower than applyTranspositionOnTheRight(Index,Index):
+      * this has linear complexity and requires a lot of branching.
+      *
+      * \sa applyTranspositionOnTheRight(Index,Index)
+      */
+    Derived& applyTranspositionOnTheLeft(Index i, Index j)
+    {
+      eigen_assert(i>=0 && j>=0 && i<size() && j<size());
+      for(Index k = 0; k < size(); ++k)
+      {
+        if(indices().coeff(k) == i) indices().coeffRef(k) = StorageIndex(j);
+        else if(indices().coeff(k) == j) indices().coeffRef(k) = StorageIndex(i);
+      }
+      return derived();
+    }
+
+    /** Multiplies *this by the transposition \f$(ij)\f$ on the right.
+      *
+      * \returns a reference to *this.
+      *
+      * This is a fast operation, it only consists in swapping two indices.
+      *
+      * \sa applyTranspositionOnTheLeft(Index,Index)
+      */
+    Derived& applyTranspositionOnTheRight(Index i, Index j)
+    {
+      eigen_assert(i>=0 && j>=0 && i<size() && j<size());
+      std::swap(indices().coeffRef(i), indices().coeffRef(j));
+      return derived();
+    }
+
+    /** \returns the inverse permutation matrix.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    inline InverseReturnType inverse() const
+    { return InverseReturnType(derived()); }
+    /** \returns the tranpose permutation matrix.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    inline InverseReturnType transpose() const
+    { return InverseReturnType(derived()); }
+
+    /**** multiplication helpers to hopefully get RVO ****/
+
+  
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  protected:
+    template<typename OtherDerived>
+    void assignTranspose(const PermutationBase<OtherDerived>& other)
+    {
+      for (Index i=0; i<rows();++i) indices().coeffRef(other.indices().coeff(i)) = i;
+    }
+    template<typename Lhs,typename Rhs>
+    void assignProduct(const Lhs& lhs, const Rhs& rhs)
+    {
+      eigen_assert(lhs.cols() == rhs.rows());
+      for (Index i=0; i<rows();++i) indices().coeffRef(i) = lhs.indices().coeff(rhs.indices().coeff(i));
+    }
+#endif
+
+  public:
+
+    /** \returns the product permutation matrix.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    template<typename Other>
+    inline PlainPermutationType operator*(const PermutationBase<Other>& other) const
+    { return PlainPermutationType(internal::PermPermProduct, derived(), other.derived()); }
+
+    /** \returns the product of a permutation with another inverse permutation.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    template<typename Other>
+    inline PlainPermutationType operator*(const InverseImpl<Other,PermutationStorage>& other) const
+    { return PlainPermutationType(internal::PermPermProduct, *this, other.eval()); }
+
+    /** \returns the product of an inverse permutation with another permutation.
+      *
+      * \note \blank \note_try_to_help_rvo
+      */
+    template<typename Other> friend
+    inline PlainPermutationType operator*(const InverseImpl<Other, PermutationStorage>& other, const PermutationBase& perm)
+    { return PlainPermutationType(internal::PermPermProduct, other.eval(), perm); }
+    
+    /** \returns the determinant of the permutation matrix, which is either 1 or -1 depending on the parity of the permutation.
+      *
+      * This function is O(\c n) procedure allocating a buffer of \c n booleans.
+      */
+    Index determinant() const
+    {
+      Index res = 1;
+      Index n = size();
+      Matrix<bool,RowsAtCompileTime,1,0,MaxRowsAtCompileTime> mask(n);
+      mask.fill(false);
+      Index r = 0;
+      while(r < n)
+      {
+        // search for the next seed
+        while(r<n && mask[r]) r++;
+        if(r>=n)
+          break;
+        // we got one, let's follow it until we are back to the seed
+        Index k0 = r++;
+        mask.coeffRef(k0) = true;
+        for(Index k=indices().coeff(k0); k!=k0; k=indices().coeff(k))
+        {
+          mask.coeffRef(k) = true;
+          res = -res;
+        }
+      }
+      return res;
+    }
+
+  protected:
+
+};
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+struct traits<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex> >
+ : traits<Matrix<_StorageIndex,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  typedef PermutationStorage StorageKind;
+  typedef Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> IndicesType;
+  typedef _StorageIndex StorageIndex;
+  typedef void Scalar;
+};
+}
+
+/** \class PermutationMatrix
+  * \ingroup Core_Module
+  *
+  * \brief Permutation matrix
+  *
+  * \tparam SizeAtCompileTime the number of rows/cols, or Dynamic
+  * \tparam MaxSizeAtCompileTime the maximum number of rows/cols, or Dynamic. This optional parameter defaults to SizeAtCompileTime. Most of the time, you should not have to specify it.
+  * \tparam _StorageIndex the integer type of the indices
+  *
+  * This class represents a permutation matrix, internally stored as a vector of integers.
+  *
+  * \sa class PermutationBase, class PermutationWrapper, class DiagonalMatrix
+  */
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+class PermutationMatrix : public PermutationBase<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex> >
+{
+    typedef PermutationBase<PermutationMatrix> Base;
+    typedef internal::traits<PermutationMatrix> Traits;
+  public:
+
+    typedef const PermutationMatrix& Nested;
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename Traits::StorageIndex StorageIndex;
+    #endif
+
+    inline PermutationMatrix()
+    {}
+
+    /** Constructs an uninitialized permutation matrix of given size.
+      */
+    explicit inline PermutationMatrix(Index size) : m_indices(size)
+    {
+      eigen_internal_assert(size <= NumTraits<StorageIndex>::highest());
+    }
+
+    /** Copy constructor. */
+    template<typename OtherDerived>
+    inline PermutationMatrix(const PermutationBase<OtherDerived>& other)
+      : m_indices(other.indices()) {}
+
+    /** Generic constructor from expression of the indices. The indices
+      * array has the meaning that the permutations sends each integer i to indices[i].
+      *
+      * \warning It is your responsibility to check that the indices array that you passes actually
+      * describes a permutation, i.e., each value between 0 and n-1 occurs exactly once, where n is the
+      * array's size.
+      */
+    template<typename Other>
+    explicit inline PermutationMatrix(const MatrixBase<Other>& indices) : m_indices(indices)
+    {}
+
+    /** Convert the Transpositions \a tr to a permutation matrix */
+    template<typename Other>
+    explicit PermutationMatrix(const TranspositionsBase<Other>& tr)
+      : m_indices(tr.size())
+    {
+      *this = tr;
+    }
+
+    /** Copies the other permutation into *this */
+    template<typename Other>
+    PermutationMatrix& operator=(const PermutationBase<Other>& other)
+    {
+      m_indices = other.indices();
+      return *this;
+    }
+
+    /** Assignment from the Transpositions \a tr */
+    template<typename Other>
+    PermutationMatrix& operator=(const TranspositionsBase<Other>& tr)
+    {
+      return Base::operator=(tr.derived());
+    }
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return m_indices; }
+    /** \returns a reference to the stored array representing the permutation. */
+    IndicesType& indices() { return m_indices; }
+
+
+    /**** multiplication helpers to hopefully get RVO ****/
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename Other>
+    PermutationMatrix(const InverseImpl<Other,PermutationStorage>& other)
+      : m_indices(other.derived().nestedExpression().size())
+    {
+      eigen_internal_assert(m_indices.size() <= NumTraits<StorageIndex>::highest());
+      StorageIndex end = StorageIndex(m_indices.size());
+      for (StorageIndex i=0; i<end;++i)
+        m_indices.coeffRef(other.derived().nestedExpression().indices().coeff(i)) = i;
+    }
+    template<typename Lhs,typename Rhs>
+    PermutationMatrix(internal::PermPermProduct_t, const Lhs& lhs, const Rhs& rhs)
+      : m_indices(lhs.indices().size())
+    {
+      Base::assignProduct(lhs,rhs);
+    }
+#endif
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess>
+struct traits<Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess> >
+ : traits<Matrix<_StorageIndex,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
+{
+  typedef PermutationStorage StorageKind;
+  typedef Map<const Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>, _PacketAccess> IndicesType;
+  typedef _StorageIndex StorageIndex;
+  typedef void Scalar;
+};
+}
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess>
+class Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess>
+  : public PermutationBase<Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess> >
+{
+    typedef PermutationBase<Map> Base;
+    typedef internal::traits<Map> Traits;
+  public:
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+    #endif
+
+    inline Map(const StorageIndex* indicesPtr)
+      : m_indices(indicesPtr)
+    {}
+
+    inline Map(const StorageIndex* indicesPtr, Index size)
+      : m_indices(indicesPtr,size)
+    {}
+
+    /** Copies the other permutation into *this */
+    template<typename Other>
+    Map& operator=(const PermutationBase<Other>& other)
+    { return Base::operator=(other.derived()); }
+
+    /** Assignment from the Transpositions \a tr */
+    template<typename Other>
+    Map& operator=(const TranspositionsBase<Other>& tr)
+    { return Base::operator=(tr.derived()); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    Map& operator=(const Map& other)
+    {
+      m_indices = other.m_indices;
+      return *this;
+    }
+    #endif
+
+    /** const version of indices(). */
+    const IndicesType& indices() const { return m_indices; }
+    /** \returns a reference to the stored array representing the permutation. */
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+template<typename _IndicesType> class TranspositionsWrapper;
+namespace internal {
+template<typename _IndicesType>
+struct traits<PermutationWrapper<_IndicesType> >
+{
+  typedef PermutationStorage StorageKind;
+  typedef void Scalar;
+  typedef typename _IndicesType::Scalar StorageIndex;
+  typedef _IndicesType IndicesType;
+  enum {
+    RowsAtCompileTime = _IndicesType::SizeAtCompileTime,
+    ColsAtCompileTime = _IndicesType::SizeAtCompileTime,
+    MaxRowsAtCompileTime = IndicesType::MaxSizeAtCompileTime,
+    MaxColsAtCompileTime = IndicesType::MaxSizeAtCompileTime,
+    Flags = 0
+  };
+};
+}
+
+/** \class PermutationWrapper
+  * \ingroup Core_Module
+  *
+  * \brief Class to view a vector of integers as a permutation matrix
+  *
+  * \tparam _IndicesType the type of the vector of integer (can be any compatible expression)
+  *
+  * This class allows to view any vector expression of integers as a permutation matrix.
+  *
+  * \sa class PermutationBase, class PermutationMatrix
+  */
+template<typename _IndicesType>
+class PermutationWrapper : public PermutationBase<PermutationWrapper<_IndicesType> >
+{
+    typedef PermutationBase<PermutationWrapper> Base;
+    typedef internal::traits<PermutationWrapper> Traits;
+  public:
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename Traits::IndicesType IndicesType;
+    #endif
+
+    inline PermutationWrapper(const IndicesType& indices)
+      : m_indices(indices)
+    {}
+
+    /** const version of indices(). */
+    const typename internal::remove_all<typename IndicesType::Nested>::type&
+    indices() const { return m_indices; }
+
+  protected:
+
+    typename IndicesType::Nested m_indices;
+};
+
+
+/** \returns the matrix with the permutation applied to the columns.
+  */
+template<typename MatrixDerived, typename PermutationDerived>
+EIGEN_DEVICE_FUNC
+const Product<MatrixDerived, PermutationDerived, AliasFreeProduct>
+operator*(const MatrixBase<MatrixDerived> &matrix,
+          const PermutationBase<PermutationDerived>& permutation)
+{
+  return Product<MatrixDerived, PermutationDerived, AliasFreeProduct>
+            (matrix.derived(), permutation.derived());
+}
+
+/** \returns the matrix with the permutation applied to the rows.
+  */
+template<typename PermutationDerived, typename MatrixDerived>
+EIGEN_DEVICE_FUNC
+const Product<PermutationDerived, MatrixDerived, AliasFreeProduct>
+operator*(const PermutationBase<PermutationDerived> &permutation,
+          const MatrixBase<MatrixDerived>& matrix)
+{
+  return Product<PermutationDerived, MatrixDerived, AliasFreeProduct>
+            (permutation.derived(), matrix.derived());
+}
+
+
+template<typename PermutationType>
+class InverseImpl<PermutationType, PermutationStorage>
+  : public EigenBase<Inverse<PermutationType> >
+{
+    typedef typename PermutationType::PlainPermutationType PlainPermutationType;
+    typedef internal::traits<PermutationType> PermTraits;
+  protected:
+    InverseImpl() {}
+  public:
+    typedef Inverse<PermutationType> InverseType;
+    using EigenBase<Inverse<PermutationType> >::derived;
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    typedef typename PermutationType::DenseMatrixType DenseMatrixType;
+    enum {
+      RowsAtCompileTime = PermTraits::RowsAtCompileTime,
+      ColsAtCompileTime = PermTraits::ColsAtCompileTime,
+      MaxRowsAtCompileTime = PermTraits::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = PermTraits::MaxColsAtCompileTime
+    };
+    #endif
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename DenseDerived>
+    void evalTo(MatrixBase<DenseDerived>& other) const
+    {
+      other.setZero();
+      for (Index i=0; i<derived().rows();++i)
+        other.coeffRef(i, derived().nestedExpression().indices().coeff(i)) = typename DenseDerived::Scalar(1);
+    }
+    #endif
+
+    /** \return the equivalent permutation matrix */
+    PlainPermutationType eval() const { return derived(); }
+
+    DenseMatrixType toDenseMatrix() const { return derived(); }
+
+    /** \returns the matrix with the inverse permutation applied to the columns.
+      */
+    template<typename OtherDerived> friend
+    const Product<OtherDerived, InverseType, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix, const InverseType& trPerm)
+    {
+      return Product<OtherDerived, InverseType, AliasFreeProduct>(matrix.derived(), trPerm.derived());
+    }
+
+    /** \returns the matrix with the inverse permutation applied to the rows.
+      */
+    template<typename OtherDerived>
+    const Product<InverseType, OtherDerived, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix) const
+    {
+      return Product<InverseType, OtherDerived, AliasFreeProduct>(derived(), matrix.derived());
+    }
+};
+
+template<typename Derived>
+const PermutationWrapper<const Derived> MatrixBase<Derived>::asPermutation() const
+{
+  return derived();
+}
+
+namespace internal {
+
+template<> struct AssignmentKind<DenseShape,PermutationShape> { typedef EigenBase2EigenBase Kind; };
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PERMUTATIONMATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/PlainObjectBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/PlainObjectBase.h
new file mode 100644
index 00000000..e2ddbd1d
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/PlainObjectBase.h
@@ -0,0 +1,1128 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DENSESTORAGEBASE_H
+#define EIGEN_DENSESTORAGEBASE_H
+
+#if defined(EIGEN_INITIALIZE_MATRICES_BY_ZERO)
+# define EIGEN_INITIALIZE_COEFFS
+# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(Index i=0;i<base().size();++i) coeffRef(i)=Scalar(0);
+#elif defined(EIGEN_INITIALIZE_MATRICES_BY_NAN)
+# define EIGEN_INITIALIZE_COEFFS
+# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED for(Index i=0;i<base().size();++i) coeffRef(i)=std::numeric_limits<Scalar>::quiet_NaN();
+#else
+# undef EIGEN_INITIALIZE_COEFFS
+# define EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+template<int MaxSizeAtCompileTime> struct check_rows_cols_for_overflow {
+  template<typename Index>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE void run(Index, Index)
+  {
+  }
+};
+
+template<> struct check_rows_cols_for_overflow<Dynamic> {
+  template<typename Index>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols)
+  {
+    // http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242
+    // we assume Index is signed
+    Index max_index = (std::size_t(1) << (8 * sizeof(Index) - 1)) - 1; // assume Index is signed
+    bool error = (rows == 0 || cols == 0) ? false
+               : (rows > max_index / cols);
+    if (error)
+      throw_std_bad_alloc();
+  }
+};
+
+template <typename Derived,
+          typename OtherDerived = Derived,
+          bool IsVector = bool(Derived::IsVectorAtCompileTime) && bool(OtherDerived::IsVectorAtCompileTime)>
+struct conservative_resize_like_impl;
+
+template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct matrix_swap_impl;
+
+} // end namespace internal
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+namespace doxygen {
+
+// This is a workaround to doxygen not being able to understand the inheritance logic
+// when it is hidden by the dense_xpr_base helper struct.
+// Moreover, doxygen fails to include members that are not documented in the declaration body of
+// MatrixBase if we inherits MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >,
+// this is why we simply inherits MatrixBase, though this does not make sense.
+
+/** This class is just a workaround for Doxygen and it does not not actually exist. */
+template<typename Derived> struct dense_xpr_base_dispatcher;
+/** This class is just a workaround for Doxygen and it does not not actually exist. */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct dense_xpr_base_dispatcher<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+    : public MatrixBase {};
+/** This class is just a workaround for Doxygen and it does not not actually exist. */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct dense_xpr_base_dispatcher<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+    : public ArrayBase {};
+
+} // namespace doxygen
+
+/** \class PlainObjectBase
+  * \ingroup Core_Module
+  * \brief %Dense storage base class for matrices and arrays.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_PLAINOBJECTBASE_PLUGIN.
+  *
+  * \tparam Derived is the derived type, e.g., a Matrix or Array
+  *
+  * \sa \ref TopicClassHierarchy
+  */
+template<typename Derived>
+class PlainObjectBase : public doxygen::dense_xpr_base_dispatcher<Derived>
+#else
+template<typename Derived>
+class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
+#endif
+{
+  public:
+    enum { Options = internal::traits<Derived>::Options };
+    typedef typename internal::dense_xpr_base<Derived>::type Base;
+
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Derived DenseType;
+
+    using Base::RowsAtCompileTime;
+    using Base::ColsAtCompileTime;
+    using Base::SizeAtCompileTime;
+    using Base::MaxRowsAtCompileTime;
+    using Base::MaxColsAtCompileTime;
+    using Base::MaxSizeAtCompileTime;
+    using Base::IsVectorAtCompileTime;
+    using Base::Flags;
+
+    typedef Eigen::Map<Derived, Unaligned>  MapType;
+    typedef const Eigen::Map<const Derived, Unaligned> ConstMapType;
+    typedef Eigen::Map<Derived, AlignedMax> AlignedMapType;
+    typedef const Eigen::Map<const Derived, AlignedMax> ConstAlignedMapType;
+    template<typename StrideType> struct StridedMapType { typedef Eigen::Map<Derived, Unaligned, StrideType> type; };
+    template<typename StrideType> struct StridedConstMapType { typedef Eigen::Map<const Derived, Unaligned, StrideType> type; };
+    template<typename StrideType> struct StridedAlignedMapType { typedef Eigen::Map<Derived, AlignedMax, StrideType> type; };
+    template<typename StrideType> struct StridedConstAlignedMapType { typedef Eigen::Map<const Derived, AlignedMax, StrideType> type; };
+
+  protected:
+    DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
+
+  public:
+    enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment>0) };
+    EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
+
+    EIGEN_DEVICE_FUNC
+    Base& base() { return *static_cast<Base*>(this); }
+    EIGEN_DEVICE_FUNC
+    const Base& base() const { return *static_cast<const Base*>(this); }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_storage.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_storage.cols(); }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index,Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
+    {
+      if(Flags & RowMajorBit)
+        return m_storage.data()[colId + rowId * m_storage.cols()];
+      else // column-major
+        return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
+    {
+      return m_storage.data()[index];
+    }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
+    {
+      if(Flags & RowMajorBit)
+        return m_storage.data()[colId + rowId * m_storage.cols()];
+      else // column-major
+        return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
+
+    /** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const
+      * provided to by-pass the creation of an evaluator of the expression, thus saving compilation efforts.
+      *
+      * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const for details. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
+    {
+      return m_storage.data()[index];
+    }
+
+    /** This is the const version of coeffRef(Index,Index) which is thus synonym of coeff(Index,Index).
+      * It is provided for convenience. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      if(Flags & RowMajorBit)
+        return m_storage.data()[colId + rowId * m_storage.cols()];
+      else // column-major
+        return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
+
+    /** This is the const version of coeffRef(Index) which is thus synonym of coeff(Index).
+      * It is provided for convenience. */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
+    {
+      return m_storage.data()[index];
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
+    {
+      return internal::ploadt<PacketScalar, LoadMode>
+               (m_storage.data() + (Flags & RowMajorBit
+                                   ? colId + rowId * m_storage.cols()
+                                   : rowId + colId * m_storage.rows()));
+    }
+
+    /** \internal */
+    template<int LoadMode>
+    EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
+    {
+      return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index);
+    }
+
+    /** \internal */
+    template<int StoreMode>
+    EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
+    {
+      internal::pstoret<Scalar, PacketScalar, StoreMode>
+              (m_storage.data() + (Flags & RowMajorBit
+                                   ? colId + rowId * m_storage.cols()
+                                   : rowId + colId * m_storage.rows()), val);
+    }
+
+    /** \internal */
+    template<int StoreMode>
+    EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& val)
+    {
+      internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, val);
+    }
+
+    /** \returns a const pointer to the data array of this matrix */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar *data() const
+    { return m_storage.data(); }
+
+    /** \returns a pointer to the data array of this matrix */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar *data()
+    { return m_storage.data(); }
+
+    /** Resizes \c *this to a \a rows x \a cols matrix.
+      *
+      * This method is intended for dynamic-size matrices, although it is legal to call it on any
+      * matrix as long as fixed dimensions are left unchanged. If you only want to change the number
+      * of rows and/or of columns, you can use resize(NoChange_t, Index), resize(Index, NoChange_t).
+      *
+      * If the current number of coefficients of \c *this exactly matches the
+      * product \a rows * \a cols, then no memory allocation is performed and
+      * the current values are left unchanged. In all other cases, including
+      * shrinking, the data is reallocated and all previous values are lost.
+      *
+      * Example: \include Matrix_resize_int_int.cpp
+      * Output: \verbinclude Matrix_resize_int_int.out
+      *
+      * \sa resize(Index) for vectors, resize(NoChange_t, Index), resize(Index, NoChange_t)
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
+    {
+      eigen_assert(   EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,rows==RowsAtCompileTime)
+                   && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,cols==ColsAtCompileTime)
+                   && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,rows<=MaxRowsAtCompileTime)
+                   && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,cols<=MaxColsAtCompileTime)
+                   && rows>=0 && cols>=0 && "Invalid sizes when resizing a matrix or array.");
+      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
+      #ifdef EIGEN_INITIALIZE_COEFFS
+        Index size = rows*cols;
+        bool size_changed = size != this->size();
+        m_storage.resize(size, rows, cols);
+        if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+      #else
+        m_storage.resize(rows*cols, rows, cols);
+      #endif
+    }
+
+    /** Resizes \c *this to a vector of length \a size
+      *
+      * \only_for_vectors. This method does not work for
+      * partially dynamic matrices when the static dimension is anything other
+      * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
+      *
+      * Example: \include Matrix_resize_int.cpp
+      * Output: \verbinclude Matrix_resize_int.out
+      *
+      * \sa resize(Index,Index), resize(NoChange_t, Index), resize(Index, NoChange_t)
+      */
+    EIGEN_DEVICE_FUNC
+    inline void resize(Index size)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
+      eigen_assert(((SizeAtCompileTime == Dynamic && (MaxSizeAtCompileTime==Dynamic || size<=MaxSizeAtCompileTime)) || SizeAtCompileTime == size) && size>=0);
+      #ifdef EIGEN_INITIALIZE_COEFFS
+        bool size_changed = size != this->size();
+      #endif
+      if(RowsAtCompileTime == 1)
+        m_storage.resize(size, 1, size);
+      else
+        m_storage.resize(size, size, 1);
+      #ifdef EIGEN_INITIALIZE_COEFFS
+        if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+      #endif
+    }
+
+    /** Resizes the matrix, changing only the number of columns. For the parameter of type NoChange_t, just pass the special value \c NoChange
+      * as in the example below.
+      *
+      * Example: \include Matrix_resize_NoChange_int.cpp
+      * Output: \verbinclude Matrix_resize_NoChange_int.out
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC
+    inline void resize(NoChange_t, Index cols)
+    {
+      resize(rows(), cols);
+    }
+
+    /** Resizes the matrix, changing only the number of rows. For the parameter of type NoChange_t, just pass the special value \c NoChange
+      * as in the example below.
+      *
+      * Example: \include Matrix_resize_int_NoChange.cpp
+      * Output: \verbinclude Matrix_resize_int_NoChange.out
+      *
+      * \sa resize(Index,Index)
+      */
+    EIGEN_DEVICE_FUNC
+    inline void resize(Index rows, NoChange_t)
+    {
+      resize(rows, cols());
+    }
+
+    /** Resizes \c *this to have the same dimensions as \a other.
+      * Takes care of doing all the checking that's needed.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
+    {
+      const OtherDerived& other = _other.derived();
+      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
+      const Index othersize = other.rows()*other.cols();
+      if(RowsAtCompileTime == 1)
+      {
+        eigen_assert(other.rows() == 1 || other.cols() == 1);
+        resize(1, othersize);
+      }
+      else if(ColsAtCompileTime == 1)
+      {
+        eigen_assert(other.rows() == 1 || other.cols() == 1);
+        resize(othersize, 1);
+      }
+      else resize(other.rows(), other.cols());
+    }
+
+    /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
+      *
+      * The method is intended for matrices of dynamic size. If you only want to change the number
+      * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
+      * conservativeResize(Index, NoChange_t).
+      *
+      * Matrices are resized relative to the top-left element. In case values need to be
+      * appended to the matrix they will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols)
+    {
+      internal::conservative_resize_like_impl<Derived>::run(*this, rows, cols);
+    }
+
+    /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
+      *
+      * As opposed to conservativeResize(Index rows, Index cols), this version leaves
+      * the number of columns unchanged.
+      *
+      * In case the matrix is growing, new rows will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t)
+    {
+      // Note: see the comment in conservativeResize(Index,Index)
+      conservativeResize(rows, cols());
+    }
+
+    /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
+      *
+      * As opposed to conservativeResize(Index rows, Index cols), this version leaves
+      * the number of rows unchanged.
+      *
+      * In case the matrix is growing, new columns will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(NoChange_t, Index cols)
+    {
+      // Note: see the comment in conservativeResize(Index,Index)
+      conservativeResize(rows(), cols);
+    }
+
+    /** Resizes the vector to \a size while retaining old values.
+      *
+      * \only_for_vectors. This method does not work for
+      * partially dynamic matrices when the static dimension is anything other
+      * than 1. For example it will not work with Matrix<double, 2, Dynamic>.
+      *
+      * When values are appended, they will be uninitialized.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResize(Index size)
+    {
+      internal::conservative_resize_like_impl<Derived>::run(*this, size);
+    }
+
+    /** Resizes the matrix to \a rows x \a cols of \c other, while leaving old values untouched.
+      *
+      * The method is intended for matrices of dynamic size. If you only want to change the number
+      * of rows and/or of columns, you can use conservativeResize(NoChange_t, Index) or
+      * conservativeResize(Index, NoChange_t).
+      *
+      * Matrices are resized relative to the top-left element. In case values need to be
+      * appended to the matrix they will copied from \c other.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other)
+    {
+      internal::conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other);
+    }
+
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
+    {
+      return _set(other);
+    }
+
+    /** \sa MatrixBase::lazyAssign() */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
+    {
+      _resize_to_match(other);
+      return Base::lazyAssign(other.derived());
+    }
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
+    {
+      resize(func.rows(), func.cols());
+      return Base::operator=(func);
+    }
+
+    // Prevent user from trying to instantiate PlainObjectBase objects
+    // by making all its constructor protected. See bug 1074.
+  protected:
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase() : m_storage()
+    {
+//       _check_template_params();
+//       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    // FIXME is it still needed ?
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert)
+      : m_storage(internal::constructor_without_unaligned_array_assert())
+    {
+//       _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+#endif
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+    EIGEN_DEVICE_FUNC
+    PlainObjectBase(PlainObjectBase&& other) EIGEN_NOEXCEPT
+      : m_storage( std::move(other.m_storage) )
+    {
+    }
+
+    EIGEN_DEVICE_FUNC
+    PlainObjectBase& operator=(PlainObjectBase&& other) EIGEN_NOEXCEPT
+    {
+      _check_template_params();
+      m_storage = std::move(other.m_storage);
+      return *this;
+    }
+#endif
+
+    /** Copy constructor */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const PlainObjectBase& other)
+      : Base(), m_storage(other.m_storage) { }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
+      : m_storage(size, rows, cols)
+    {
+//       _check_template_params();
+//       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+    }
+
+    #if EIGEN_HAS_CXX11
+    /** \brief Construct a row of column vector with fixed size from an arbitrary number of coefficients. \cpp11
+      *
+      * \only_for_vectors
+      *
+      * This constructor is for 1D array or vectors with more than 4 coefficients.
+      * There exists C++98 analogue constructors for fixed-size array/vector having 1, 2, 3, or 4 coefficients.
+      *
+      * \warning To construct a column (resp. row) vector of fixed length, the number of values passed to this
+      * constructor must match the the fixed number of rows (resp. columns) of \c *this.
+      */
+    template <typename... ArgTypes>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    PlainObjectBase(const Scalar& a0, const Scalar& a1, const Scalar& a2,  const Scalar& a3, const ArgTypes&... args)
+      : m_storage()
+    {
+      _check_template_params();
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, sizeof...(args) + 4);
+      m_storage.data()[0] = a0;
+      m_storage.data()[1] = a1;
+      m_storage.data()[2] = a2;
+      m_storage.data()[3] = a3;
+      Index i = 4;
+      auto x = {(m_storage.data()[i++] = args, 0)...};
+      static_cast<void>(x);
+    }
+
+    /** \brief Constructs a Matrix or Array and initializes it by elements given by an initializer list of initializer
+      * lists \cpp11
+      */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<std::initializer_list<Scalar>>& list)
+      : m_storage()
+    {
+      _check_template_params();
+
+      size_t list_size = 0;
+      if (list.begin() != list.end()) {
+        list_size = list.begin()->size();
+      }
+
+      // This is to allow syntax like VectorXi {{1, 2, 3, 4}}
+      if (ColsAtCompileTime == 1 && list.size() == 1) {
+        eigen_assert(list_size == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
+        resize(list_size, ColsAtCompileTime);
+        std::copy(list.begin()->begin(), list.begin()->end(), m_storage.data());
+      } else {
+        eigen_assert(list.size() == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
+        eigen_assert(list_size == static_cast<size_t>(ColsAtCompileTime) || ColsAtCompileTime == Dynamic);
+        resize(list.size(), list_size);
+
+        Index row_index = 0;
+        for (const std::initializer_list<Scalar>& row : list) {
+          eigen_assert(list_size == row.size());
+          Index col_index = 0;
+          for (const Scalar& e : row) {
+            coeffRef(row_index, col_index) = e;
+            ++col_index;
+          }
+          ++row_index;
+        }
+      }
+    }
+    #endif  // end EIGEN_HAS_CXX11
+
+    /** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
+      : m_storage()
+    {
+      _check_template_params();
+      resizeLike(other);
+      _set_noalias(other);
+    }
+
+    /** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
+      : m_storage()
+    {
+      _check_template_params();
+      resizeLike(other);
+      *this = other.derived();
+    }
+    /** \brief Copy constructor with in-place evaluation */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& other)
+    {
+      _check_template_params();
+      // FIXME this does not automatically transpose vectors if necessary
+      resize(other.rows(), other.cols());
+      other.evalTo(this->derived());
+    }
+
+  public:
+
+    /** \brief Copies the generic expression \a other into *this.
+      * \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other)
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
+    {
+      _resize_to_match(other);
+      Base::operator=(other.derived());
+      return this->derived();
+    }
+
+    /** \name Map
+      * These are convenience functions returning Map objects. The Map() static functions return unaligned Map objects,
+      * while the AlignedMap() functions return aligned Map objects and thus should be called only with 16-byte-aligned
+      * \a data pointers.
+      *
+      * Here is an example using strides:
+      * \include Matrix_Map_stride.cpp
+      * Output: \verbinclude Matrix_Map_stride.out
+      *
+      * \see class Map
+      */
+    //@{
+    static inline ConstMapType Map(const Scalar* data)
+    { return ConstMapType(data); }
+    static inline MapType Map(Scalar* data)
+    { return MapType(data); }
+    static inline ConstMapType Map(const Scalar* data, Index size)
+    { return ConstMapType(data, size); }
+    static inline MapType Map(Scalar* data, Index size)
+    { return MapType(data, size); }
+    static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
+    { return ConstMapType(data, rows, cols); }
+    static inline MapType Map(Scalar* data, Index rows, Index cols)
+    { return MapType(data, rows, cols); }
+
+    static inline ConstAlignedMapType MapAligned(const Scalar* data)
+    { return ConstAlignedMapType(data); }
+    static inline AlignedMapType MapAligned(Scalar* data)
+    { return AlignedMapType(data); }
+    static inline ConstAlignedMapType MapAligned(const Scalar* data, Index size)
+    { return ConstAlignedMapType(data, size); }
+    static inline AlignedMapType MapAligned(Scalar* data, Index size)
+    { return AlignedMapType(data, size); }
+    static inline ConstAlignedMapType MapAligned(const Scalar* data, Index rows, Index cols)
+    { return ConstAlignedMapType(data, rows, cols); }
+    static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index cols)
+    { return AlignedMapType(data, rows, cols); }
+
+    template<int Outer, int Inner>
+    static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstMapType<Stride<Outer, Inner> >::type Map(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedMapType<Stride<Outer, Inner> >::type Map(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+
+    template<int Outer, int Inner>
+    static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, const Stride<Outer, Inner>& stride)
+    { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index size, const Stride<Outer, Inner>& stride)
+    { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, size, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type MapAligned(const Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedConstAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+    template<int Outer, int Inner>
+    static inline typename StridedAlignedMapType<Stride<Outer, Inner> >::type MapAligned(Scalar* data, Index rows, Index cols, const Stride<Outer, Inner>& stride)
+    { return typename StridedAlignedMapType<Stride<Outer, Inner> >::type(data, rows, cols, stride); }
+    //@}
+
+    using Base::setConstant;
+    EIGEN_DEVICE_FUNC Derived& setConstant(Index size, const Scalar& val);
+    EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, Index cols, const Scalar& val);
+    EIGEN_DEVICE_FUNC Derived& setConstant(NoChange_t, Index cols, const Scalar& val);
+    EIGEN_DEVICE_FUNC Derived& setConstant(Index rows, NoChange_t, const Scalar& val);
+
+    using Base::setZero;
+    EIGEN_DEVICE_FUNC Derived& setZero(Index size);
+    EIGEN_DEVICE_FUNC Derived& setZero(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setZero(NoChange_t, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setZero(Index rows, NoChange_t);
+
+    using Base::setOnes;
+    EIGEN_DEVICE_FUNC Derived& setOnes(Index size);
+    EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setOnes(NoChange_t, Index cols);
+    EIGEN_DEVICE_FUNC Derived& setOnes(Index rows, NoChange_t);
+
+    using Base::setRandom;
+    Derived& setRandom(Index size);
+    Derived& setRandom(Index rows, Index cols);
+    Derived& setRandom(NoChange_t, Index cols);
+    Derived& setRandom(Index rows, NoChange_t);
+
+    #ifdef EIGEN_PLAINOBJECTBASE_PLUGIN
+    #include EIGEN_PLAINOBJECTBASE_PLUGIN
+    #endif
+
+  protected:
+    /** \internal Resizes *this in preparation for assigning \a other to it.
+      * Takes care of doing all the checking that's needed.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
+    {
+      #ifdef EIGEN_NO_AUTOMATIC_RESIZING
+      eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size())
+                 : (rows() == other.rows() && cols() == other.cols())))
+        && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
+      EIGEN_ONLY_USED_FOR_DEBUG(other);
+      #else
+      resizeLike(other);
+      #endif
+    }
+
+    /**
+      * \brief Copies the value of the expression \a other into \c *this with automatic resizing.
+      *
+      * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
+      * it will be initialized.
+      *
+      * Note that copying a row-vector into a vector (and conversely) is allowed.
+      * The resizing, if any, is then done in the appropriate way so that row-vectors
+      * remain row-vectors and vectors remain vectors.
+      *
+      * \sa operator=(const MatrixBase<OtherDerived>&), _set_noalias()
+      *
+      * \internal
+      */
+    // aliasing is dealt once in internal::call_assignment
+    // so at this stage we have to assume aliasing... and resising has to be done later.
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
+    {
+      internal::call_assignment(this->derived(), other.derived());
+      return this->derived();
+    }
+
+    /** \internal Like _set() but additionally makes the assumption that no aliasing effect can happen (which
+      * is the case when creating a new matrix) so one can enforce lazy evaluation.
+      *
+      * \sa operator=(const MatrixBase<OtherDerived>&), _set()
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
+    {
+      // I don't think we need this resize call since the lazyAssign will anyways resize
+      // and lazyAssign will be called by the assign selector.
+      //_resize_to_match(other);
+      // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because
+      // it wouldn't allow to copy a row-vector into a column-vector.
+      internal::call_assignment_no_alias(this->derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+      return this->derived();
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0)
+    {
+      const bool t0_is_integer_alike = internal::is_valid_index_type<T0>::value;
+      const bool t1_is_integer_alike = internal::is_valid_index_type<T1>::value;
+      EIGEN_STATIC_ASSERT(t0_is_integer_alike &&
+                          t1_is_integer_alike,
+                          FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
+      resize(rows,cols);
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
+      m_storage.data()[0] = Scalar(val0);
+      m_storage.data()[1] = Scalar(val1);
+    }
+
+    template<typename T0, typename T1>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1,
+                                    typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
+                                                                  && (internal::is_same<T0,Index>::value)
+                                                                  && (internal::is_same<T1,Index>::value)
+                                                                  && Base::SizeAtCompileTime==2,T1>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
+      m_storage.data()[0] = Scalar(val0);
+      m_storage.data()[1] = Scalar(val1);
+    }
+
+    // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
+    // then the argument is meant to be the size of the object.
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(Index size, typename internal::enable_if<    (Base::SizeAtCompileTime!=1 || !internal::is_convertible<T, Scalar>::value)
+                                                                              && ((!internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value || Base::SizeAtCompileTime==Dynamic)),T>::type* = 0)
+    {
+      // NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT argument.
+      const bool is_integer_alike = internal::is_valid_index_type<T>::value;
+      EIGEN_UNUSED_VARIABLE(is_integer_alike);
+      EIGEN_STATIC_ASSERT(is_integer_alike,
+                          FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
+      resize(size);
+    }
+
+    // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type can be implicitly converted)
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Scalar& val0, typename internal::enable_if<Base::SizeAtCompileTime==1 && internal::is_convertible<T, Scalar>::value,T>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
+      m_storage.data()[0] = val0;
+    }
+
+    // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar type match the index type)
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Index& val0,
+                                    typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
+                                                                  && (internal::is_same<Index,T>::value)
+                                                                  && Base::SizeAtCompileTime==1
+                                                                  && internal::is_convertible<T, Scalar>::value,T*>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
+      m_storage.data()[0] = Scalar(val0);
+    }
+
+    // Initialize a fixed size matrix from a pointer to raw data
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Scalar* data){
+      this->_set_noalias(ConstMapType(data));
+    }
+
+    // Initialize an arbitrary matrix from a dense expression
+    template<typename T, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const DenseBase<OtherDerived>& other){
+      this->_set_noalias(other);
+    }
+
+    // Initialize an arbitrary matrix from an object convertible to the Derived type.
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Derived& other){
+      this->_set_noalias(other);
+    }
+
+    // Initialize an arbitrary matrix from a generic Eigen expression
+    template<typename T, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const EigenBase<OtherDerived>& other){
+      this->derived() = other;
+    }
+
+    template<typename T, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const ReturnByValue<OtherDerived>& other)
+    {
+      resize(other.rows(), other.cols());
+      other.evalTo(this->derived());
+    }
+
+    template<typename T, typename OtherDerived, int ColsAtCompileTime>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
+    {
+      this->derived() = r;
+    }
+
+    // For fixed-size Array<Scalar,...>
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Scalar& val0,
+                                    typename internal::enable_if<    Base::SizeAtCompileTime!=Dynamic
+                                                                  && Base::SizeAtCompileTime!=1
+                                                                  && internal::is_convertible<T, Scalar>::value
+                                                                  && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T>::type* = 0)
+    {
+      Base::setConstant(val0);
+    }
+
+    // For fixed-size Array<Index,...>
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _init1(const Index& val0,
+                                    typename internal::enable_if<    (!internal::is_same<Index,Scalar>::value)
+                                                                  && (internal::is_same<Index,T>::value)
+                                                                  && Base::SizeAtCompileTime!=Dynamic
+                                                                  && Base::SizeAtCompileTime!=1
+                                                                  && internal::is_convertible<T, Scalar>::value
+                                                                  && internal::is_same<typename internal::traits<Derived>::XprKind,ArrayXpr>::value,T*>::type* = 0)
+    {
+      Base::setConstant(val0);
+    }
+
+    template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
+    friend struct internal::matrix_swap_impl;
+
+  public:
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal
+      * \brief Override DenseBase::swap() since for dynamic-sized matrices
+      * of same type it is enough to swap the data pointers.
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void swap(DenseBase<OtherDerived> & other)
+    {
+      enum { SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime==Dynamic };
+      internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.derived());
+    }
+
+    /** \internal
+      * \brief const version forwarded to DenseBase::swap
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void swap(DenseBase<OtherDerived> const & other)
+    { Base::swap(other.derived()); }
+
+    EIGEN_DEVICE_FUNC
+    static EIGEN_STRONG_INLINE void _check_template_params()
+    {
+      EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (int(Options)&RowMajor)==RowMajor)
+                        && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (int(Options)&RowMajor)==0)
+                        && ((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0))
+                        && ((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0))
+                        && ((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0))
+                        && ((MaxColsAtCompileTime == Dynamic) || (MaxColsAtCompileTime >= 0))
+                        && (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
+                        && (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
+                        && (Options & (DontAlign|RowMajor)) == Options),
+        INVALID_MATRIX_TEMPLATE_PARAMETERS)
+    }
+
+    enum { IsPlainObjectBase = 1 };
+#endif
+  public:
+    // These apparently need to be down here for nvcc+icc to prevent duplicate
+    // Map symbol.
+    template<typename PlainObjectType, int MapOptions, typename StrideType> friend class Eigen::Map;
+    friend class Eigen::Map<Derived, Unaligned>;
+    friend class Eigen::Map<const Derived, Unaligned>;
+#if EIGEN_MAX_ALIGN_BYTES>0
+    // for EIGEN_MAX_ALIGN_BYTES==0, AlignedMax==Unaligned, and many compilers generate warnings for friend-ing a class twice.
+    friend class Eigen::Map<Derived, AlignedMax>;
+    friend class Eigen::Map<const Derived, AlignedMax>;
+#endif
+};
+
+namespace internal {
+
+template <typename Derived, typename OtherDerived, bool IsVector>
+struct conservative_resize_like_impl
+{
+  #if EIGEN_HAS_TYPE_TRAITS
+  static const bool IsRelocatable = std::is_trivially_copyable<typename Derived::Scalar>::value;
+  #else
+  static const bool IsRelocatable = !NumTraits<typename Derived::Scalar>::RequireInitialization;
+  #endif
+  static void run(DenseBase<Derived>& _this, Index rows, Index cols)
+  {
+    if (_this.rows() == rows && _this.cols() == cols) return;
+    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
+
+    if ( IsRelocatable
+          && (( Derived::IsRowMajor && _this.cols() == cols) ||  // row-major and we change only the number of rows
+              (!Derived::IsRowMajor && _this.rows() == rows) ))  // column-major and we change only the number of columns
+    {
+      internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
+      _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
+    }
+    else
+    {
+      // The storage order does not allow us to use reallocation.
+      Derived tmp(rows,cols);
+      const Index common_rows = numext::mini(rows, _this.rows());
+      const Index common_cols = numext::mini(cols, _this.cols());
+      tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
+      _this.derived().swap(tmp);
+    }
+  }
+
+  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
+  {
+    if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
+
+    // Note: Here is space for improvement. Basically, for conservativeResize(Index,Index),
+    // neither RowsAtCompileTime or ColsAtCompileTime must be Dynamic. If only one of the
+    // dimensions is dynamic, one could use either conservativeResize(Index rows, NoChange_t) or
+    // conservativeResize(NoChange_t, Index cols). For these methods new static asserts like
+    // EIGEN_STATIC_ASSERT_DYNAMIC_ROWS and EIGEN_STATIC_ASSERT_DYNAMIC_COLS would be good.
+    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
+    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
+
+    if ( IsRelocatable &&
+          (( Derived::IsRowMajor && _this.cols() == other.cols()) ||  // row-major and we change only the number of rows
+           (!Derived::IsRowMajor && _this.rows() == other.rows()) ))  // column-major and we change only the number of columns
+    {
+      const Index new_rows = other.rows() - _this.rows();
+      const Index new_cols = other.cols() - _this.cols();
+      _this.derived().m_storage.conservativeResize(other.size(),other.rows(),other.cols());
+      if (new_rows>0)
+        _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
+      else if (new_cols>0)
+        _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
+    }
+    else
+    {
+      // The storage order does not allow us to use reallocation.
+      Derived tmp(other);
+      const Index common_rows = numext::mini(tmp.rows(), _this.rows());
+      const Index common_cols = numext::mini(tmp.cols(), _this.cols());
+      tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
+      _this.derived().swap(tmp);
+    }
+  }
+};
+
+// Here, the specialization for vectors inherits from the general matrix case
+// to allow calling .conservativeResize(rows,cols) on vectors.
+template <typename Derived, typename OtherDerived>
+struct conservative_resize_like_impl<Derived,OtherDerived,true>
+  : conservative_resize_like_impl<Derived,OtherDerived,false>
+{
+  typedef conservative_resize_like_impl<Derived,OtherDerived,false> Base;
+  using Base::run;
+  using Base::IsRelocatable;
+
+  static void run(DenseBase<Derived>& _this, Index size)
+  {
+    const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : size;
+    const Index new_cols = Derived::RowsAtCompileTime==1 ? size : 1;
+    if(IsRelocatable)
+      _this.derived().m_storage.conservativeResize(size,new_rows,new_cols);
+    else
+      Base::run(_this.derived(), new_rows, new_cols);
+  }
+
+  static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
+  {
+    if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;
+
+    const Index num_new_elements = other.size() - _this.size();
+
+    const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
+    const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
+    if(IsRelocatable)
+      _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);
+    else
+      Base::run(_this.derived(), new_rows, new_cols);
+
+    if (num_new_elements > 0)
+      _this.tail(num_new_elements) = other.tail(num_new_elements);
+  }
+};
+
+template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers>
+struct matrix_swap_impl
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE void run(MatrixTypeA& a, MatrixTypeB& b)
+  {
+    a.base().swap(b);
+  }
+};
+
+template<typename MatrixTypeA, typename MatrixTypeB>
+struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(MatrixTypeA& a, MatrixTypeB& b)
+  {
+    static_cast<typename MatrixTypeA::Base&>(a).m_storage.swap(static_cast<typename MatrixTypeB::Base&>(b).m_storage);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_DENSESTORAGEBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Product.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Product.h
new file mode 100644
index 00000000..70a6c106
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Product.h
@@ -0,0 +1,191 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PRODUCT_H
+#define EIGEN_PRODUCT_H
+
+namespace Eigen {
+
+template<typename Lhs, typename Rhs, int Option, typename StorageKind> class ProductImpl;
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Option>
+struct traits<Product<Lhs, Rhs, Option> >
+{
+  typedef typename remove_all<Lhs>::type LhsCleaned;
+  typedef typename remove_all<Rhs>::type RhsCleaned;
+  typedef traits<LhsCleaned> LhsTraits;
+  typedef traits<RhsCleaned> RhsTraits;
+
+  typedef MatrixXpr XprKind;
+
+  typedef typename ScalarBinaryOpTraits<typename traits<LhsCleaned>::Scalar, typename traits<RhsCleaned>::Scalar>::ReturnType Scalar;
+  typedef typename product_promote_storage_type<typename LhsTraits::StorageKind,
+                                                typename RhsTraits::StorageKind,
+                                                internal::product_type<Lhs,Rhs>::ret>::ret StorageKind;
+  typedef typename promote_index_type<typename LhsTraits::StorageIndex,
+                                      typename RhsTraits::StorageIndex>::type StorageIndex;
+
+  enum {
+    RowsAtCompileTime    = LhsTraits::RowsAtCompileTime,
+    ColsAtCompileTime    = RhsTraits::ColsAtCompileTime,
+    MaxRowsAtCompileTime = LhsTraits::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = RhsTraits::MaxColsAtCompileTime,
+
+    // FIXME: only needed by GeneralMatrixMatrixTriangular
+    InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(LhsTraits::ColsAtCompileTime, RhsTraits::RowsAtCompileTime),
+
+    // The storage order is somewhat arbitrary here. The correct one will be determined through the evaluator.
+    Flags = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? RowMajorBit
+          : (MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1) ? 0
+          : (   ((LhsTraits::Flags&NoPreferredStorageOrderBit) && (RhsTraits::Flags&RowMajorBit))
+             || ((RhsTraits::Flags&NoPreferredStorageOrderBit) && (LhsTraits::Flags&RowMajorBit)) ) ? RowMajorBit
+          : NoPreferredStorageOrderBit
+  };
+};
+
+} // end namespace internal
+
+/** \class Product
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the product of two arbitrary matrices or vectors
+  *
+  * \tparam _Lhs the type of the left-hand side expression
+  * \tparam _Rhs the type of the right-hand side expression
+  *
+  * This class represents an expression of the product of two arbitrary matrices.
+  *
+  * The other template parameters are:
+  * \tparam Option     can be DefaultProduct, AliasFreeProduct, or LazyProduct
+  *
+  */
+template<typename _Lhs, typename _Rhs, int Option>
+class Product : public ProductImpl<_Lhs,_Rhs,Option,
+                                   typename internal::product_promote_storage_type<typename internal::traits<_Lhs>::StorageKind,
+                                                                                   typename internal::traits<_Rhs>::StorageKind,
+                                                                                   internal::product_type<_Lhs,_Rhs>::ret>::ret>
+{
+  public:
+
+    typedef _Lhs Lhs;
+    typedef _Rhs Rhs;
+
+    typedef typename ProductImpl<
+        Lhs, Rhs, Option,
+        typename internal::product_promote_storage_type<typename internal::traits<Lhs>::StorageKind,
+                                                        typename internal::traits<Rhs>::StorageKind,
+                                                        internal::product_type<Lhs,Rhs>::ret>::ret>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Product)
+
+    typedef typename internal::ref_selector<Lhs>::type LhsNested;
+    typedef typename internal::ref_selector<Rhs>::type RhsNested;
+    typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
+    typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Product(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), m_rhs(rhs)
+    {
+      eigen_assert(lhs.cols() == rhs.rows()
+        && "invalid matrix product"
+        && "if you wanted a coeff-wise or a dot product use the respective explicit functions");
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_lhs.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const LhsNestedCleaned& lhs() const { return m_lhs; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const RhsNestedCleaned& rhs() const { return m_rhs; }
+
+  protected:
+
+    LhsNested m_lhs;
+    RhsNested m_rhs;
+};
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Option, int ProductTag = internal::product_type<Lhs,Rhs>::ret>
+class dense_product_base
+ : public internal::dense_xpr_base<Product<Lhs,Rhs,Option> >::type
+{};
+
+/** Conversion to scalar for inner-products */
+template<typename Lhs, typename Rhs, int Option>
+class dense_product_base<Lhs, Rhs, Option, InnerProduct>
+ : public internal::dense_xpr_base<Product<Lhs,Rhs,Option> >::type
+{
+  typedef Product<Lhs,Rhs,Option> ProductXpr;
+  typedef typename internal::dense_xpr_base<ProductXpr>::type Base;
+public:
+  using Base::derived;
+  typedef typename Base::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE operator const Scalar() const
+  {
+    return internal::evaluator<ProductXpr>(derived()).coeff(0,0);
+  }
+};
+
+} // namespace internal
+
+// Generic API dispatcher
+template<typename Lhs, typename Rhs, int Option, typename StorageKind>
+class ProductImpl : public internal::generic_xpr_base<Product<Lhs,Rhs,Option>, MatrixXpr, StorageKind>::type
+{
+  public:
+    typedef typename internal::generic_xpr_base<Product<Lhs,Rhs,Option>, MatrixXpr, StorageKind>::type Base;
+};
+
+template<typename Lhs, typename Rhs, int Option>
+class ProductImpl<Lhs,Rhs,Option,Dense>
+  : public internal::dense_product_base<Lhs,Rhs,Option>
+{
+    typedef Product<Lhs, Rhs, Option> Derived;
+
+  public:
+
+    typedef typename internal::dense_product_base<Lhs, Rhs, Option> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
+  protected:
+    enum {
+      IsOneByOne = (RowsAtCompileTime == 1 || RowsAtCompileTime == Dynamic) &&
+                   (ColsAtCompileTime == 1 || ColsAtCompileTime == Dynamic),
+      EnableCoeff = IsOneByOne || Option==LazyProduct
+    };
+
+  public:
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(Index row, Index col) const
+    {
+      EIGEN_STATIC_ASSERT(EnableCoeff, THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS);
+      eigen_assert( (Option==LazyProduct) || (this->rows() == 1 && this->cols() == 1) );
+
+      return internal::evaluator<Derived>(derived()).coeff(row,col);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(Index i) const
+    {
+      EIGEN_STATIC_ASSERT(EnableCoeff, THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS);
+      eigen_assert( (Option==LazyProduct) || (this->rows() == 1 && this->cols() == 1) );
+
+      return internal::evaluator<Derived>(derived()).coeff(i);
+    }
+
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_PRODUCT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/ProductEvaluators.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ProductEvaluators.h
new file mode 100644
index 00000000..8cf294b2
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ProductEvaluators.h
@@ -0,0 +1,1179 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2011 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_PRODUCTEVALUATORS_H
+#define EIGEN_PRODUCTEVALUATORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+  * Evaluator of a product expression.
+  * Since products require special treatments to handle all possible cases,
+  * we simply defer the evaluation logic to a product_evaluator class
+  * which offers more partial specialization possibilities.
+  *
+  * \sa class product_evaluator
+  */
+template<typename Lhs, typename Rhs, int Options>
+struct evaluator<Product<Lhs, Rhs, Options> >
+ : public product_evaluator<Product<Lhs, Rhs, Options> >
+{
+  typedef Product<Lhs, Rhs, Options> XprType;
+  typedef product_evaluator<XprType> Base;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// Catch "scalar * ( A * B )" and transform it to "(A*scalar) * B"
+// TODO we should apply that rule only if that's really helpful
+template<typename Lhs, typename Rhs, typename Scalar1, typename Scalar2, typename Plain1>
+struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_product_op<Scalar1,Scalar2>,
+                                               const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                                               const Product<Lhs, Rhs, DefaultProduct> > >
+{
+  static const bool value = true;
+};
+template<typename Lhs, typename Rhs, typename Scalar1, typename Scalar2, typename Plain1>
+struct evaluator<CwiseBinaryOp<internal::scalar_product_op<Scalar1,Scalar2>,
+                               const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                               const Product<Lhs, Rhs, DefaultProduct> > >
+ : public evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1,Lhs,product), Rhs, DefaultProduct> >
+{
+  typedef CwiseBinaryOp<internal::scalar_product_op<Scalar1,Scalar2>,
+                               const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                               const Product<Lhs, Rhs, DefaultProduct> > XprType;
+  typedef evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1,Lhs,product), Rhs, DefaultProduct> > Base;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr)
+    : Base(xpr.lhs().functor().m_other * xpr.rhs().lhs() * xpr.rhs().rhs())
+  {}
+};
+
+
+template<typename Lhs, typename Rhs, int DiagIndex>
+struct evaluator<Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex> >
+ : public evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex> >
+{
+  typedef Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex> XprType;
+  typedef evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex> > Base;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr)
+    : Base(Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex>(
+        Product<Lhs, Rhs, LazyProduct>(xpr.nestedExpression().lhs(), xpr.nestedExpression().rhs()),
+        xpr.index() ))
+  {}
+};
+
+
+// Helper class to perform a matrix product with the destination at hand.
+// Depending on the sizes of the factors, there are different evaluation strategies
+// as controlled by internal::product_type.
+template< typename Lhs, typename Rhs,
+          typename LhsShape = typename evaluator_traits<Lhs>::Shape,
+          typename RhsShape = typename evaluator_traits<Rhs>::Shape,
+          int ProductType = internal::product_type<Lhs,Rhs>::value>
+struct generic_product_impl;
+
+template<typename Lhs, typename Rhs>
+struct evaluator_assume_aliasing<Product<Lhs, Rhs, DefaultProduct> > {
+  static const bool value = true;
+};
+
+// This is the default evaluator implementation for products:
+// It creates a temporary and call generic_product_impl
+template<typename Lhs, typename Rhs, int Options, int ProductTag, typename LhsShape, typename RhsShape>
+struct product_evaluator<Product<Lhs, Rhs, Options>, ProductTag, LhsShape, RhsShape>
+  : public evaluator<typename Product<Lhs, Rhs, Options>::PlainObject>
+{
+  typedef Product<Lhs, Rhs, Options> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit product_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+
+// FIXME shall we handle nested_eval here?,
+// if so, then we must take care at removing the call to nested_eval in the specializations (e.g., in permutation_matrix_product, transposition_matrix_product, etc.)
+//     typedef typename internal::nested_eval<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
+//     typedef typename internal::nested_eval<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
+//     typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
+//     typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
+//
+//     const LhsNested lhs(xpr.lhs());
+//     const RhsNested rhs(xpr.rhs());
+//
+//     generic_product_impl<LhsNestedCleaned, RhsNestedCleaned>::evalTo(m_result, lhs, rhs);
+
+    generic_product_impl<Lhs, Rhs, LhsShape, RhsShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+// The following three shortcuts are enabled only if the scalar types match exactly.
+// TODO: we could enable them for different scalar types when the product is not vectorized.
+
+// Dense = Product
+template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::assign_op<Scalar,Scalar>, Dense2Dense,
+  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type>
+{
+  typedef Product<Lhs,Rhs,Options> SrcXprType;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    // FIXME shall we handle nested_eval here?
+    generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());
+  }
+};
+
+// Dense += Product
+template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::add_assign_op<Scalar,Scalar>, Dense2Dense,
+  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type>
+{
+  typedef Product<Lhs,Rhs,Options> SrcXprType;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar,Scalar> &)
+  {
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    // FIXME shall we handle nested_eval here?
+    generic_product_impl<Lhs, Rhs>::addTo(dst, src.lhs(), src.rhs());
+  }
+};
+
+// Dense -= Product
+template< typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,Options>, internal::sub_assign_op<Scalar,Scalar>, Dense2Dense,
+  typename enable_if<(Options==DefaultProduct || Options==AliasFreeProduct)>::type>
+{
+  typedef Product<Lhs,Rhs,Options> SrcXprType;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar,Scalar> &)
+  {
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    // FIXME shall we handle nested_eval here?
+    generic_product_impl<Lhs, Rhs>::subTo(dst, src.lhs(), src.rhs());
+  }
+};
+
+
+// Dense ?= scalar * Product
+// TODO we should apply that rule if that's really helpful
+// for instance, this is not good for inner products
+template< typename DstXprType, typename Lhs, typename Rhs, typename AssignFunc, typename Scalar, typename ScalarBis, typename Plain>
+struct Assignment<DstXprType, CwiseBinaryOp<internal::scalar_product_op<ScalarBis,Scalar>, const CwiseNullaryOp<internal::scalar_constant_op<ScalarBis>,Plain>,
+                                           const Product<Lhs,Rhs,DefaultProduct> >, AssignFunc, Dense2Dense>
+{
+  typedef CwiseBinaryOp<internal::scalar_product_op<ScalarBis,Scalar>,
+                        const CwiseNullaryOp<internal::scalar_constant_op<ScalarBis>,Plain>,
+                        const Product<Lhs,Rhs,DefaultProduct> > SrcXprType;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const AssignFunc& func)
+  {
+    call_assignment_no_alias(dst, (src.lhs().functor().m_other * src.rhs().lhs())*src.rhs().rhs(), func);
+  }
+};
+
+//----------------------------------------
+// Catch "Dense ?= xpr + Product<>" expression to save one temporary
+// FIXME we could probably enable these rules for any product, i.e., not only Dense and DefaultProduct
+
+template<typename OtherXpr, typename Lhs, typename Rhs>
+struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_sum_op<typename OtherXpr::Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, const OtherXpr,
+                                               const Product<Lhs,Rhs,DefaultProduct> >, DenseShape > {
+  static const bool value = true;
+};
+
+template<typename OtherXpr, typename Lhs, typename Rhs>
+struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_difference_op<typename OtherXpr::Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, const OtherXpr,
+                                               const Product<Lhs,Rhs,DefaultProduct> >, DenseShape > {
+  static const bool value = true;
+};
+
+template<typename DstXprType, typename OtherXpr, typename ProductType, typename Func1, typename Func2>
+struct assignment_from_xpr_op_product
+{
+  template<typename SrcXprType, typename InitialFunc>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const InitialFunc& /*func*/)
+  {
+    call_assignment_no_alias(dst, src.lhs(), Func1());
+    call_assignment_no_alias(dst, src.rhs(), Func2());
+  }
+};
+
+#define EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(ASSIGN_OP,BINOP,ASSIGN_OP2) \
+  template< typename DstXprType, typename OtherXpr, typename Lhs, typename Rhs, typename DstScalar, typename SrcScalar, typename OtherScalar,typename ProdScalar> \
+  struct Assignment<DstXprType, CwiseBinaryOp<internal::BINOP<OtherScalar,ProdScalar>, const OtherXpr, \
+                                            const Product<Lhs,Rhs,DefaultProduct> >, internal::ASSIGN_OP<DstScalar,SrcScalar>, Dense2Dense> \
+    : assignment_from_xpr_op_product<DstXprType, OtherXpr, Product<Lhs,Rhs,DefaultProduct>, internal::ASSIGN_OP<DstScalar,OtherScalar>, internal::ASSIGN_OP2<DstScalar,ProdScalar> > \
+  {}
+
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(assign_op,    scalar_sum_op,add_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(add_assign_op,scalar_sum_op,add_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(sub_assign_op,scalar_sum_op,sub_assign_op);
+
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(assign_op,    scalar_difference_op,sub_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(add_assign_op,scalar_difference_op,sub_assign_op);
+EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT(sub_assign_op,scalar_difference_op,add_assign_op);
+
+//----------------------------------------
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,InnerProduct>
+{
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    dst.coeffRef(0,0) = (lhs.transpose().cwiseProduct(rhs)).sum();
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    dst.coeffRef(0,0) += (lhs.transpose().cwiseProduct(rhs)).sum();
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { dst.coeffRef(0,0) -= (lhs.transpose().cwiseProduct(rhs)).sum(); }
+};
+
+
+/***********************************************************************
+*  Implementation of outer dense * dense vector product
+***********************************************************************/
+
+// Column major result
+template<typename Dst, typename Lhs, typename Rhs, typename Func>
+void EIGEN_DEVICE_FUNC outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const false_type&)
+{
+  evaluator<Rhs> rhsEval(rhs);
+  ei_declare_local_nested_eval(Lhs,lhs,Rhs::SizeAtCompileTime,actual_lhs);
+  // FIXME if cols is large enough, then it might be useful to make sure that lhs is sequentially stored
+  // FIXME not very good if rhs is real and lhs complex while alpha is real too
+  const Index cols = dst.cols();
+  for (Index j=0; j<cols; ++j)
+    func(dst.col(j), rhsEval.coeff(Index(0),j) * actual_lhs);
+}
+
+// Row major result
+template<typename Dst, typename Lhs, typename Rhs, typename Func>
+void EIGEN_DEVICE_FUNC outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const true_type&)
+{
+  evaluator<Lhs> lhsEval(lhs);
+  ei_declare_local_nested_eval(Rhs,rhs,Lhs::SizeAtCompileTime,actual_rhs);
+  // FIXME if rows is large enough, then it might be useful to make sure that rhs is sequentially stored
+  // FIXME not very good if lhs is real and rhs complex while alpha is real too
+  const Index rows = dst.rows();
+  for (Index i=0; i<rows; ++i)
+    func(dst.row(i), lhsEval.coeff(i,Index(0)) * actual_rhs);
+}
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,OuterProduct>
+{
+  template<typename T> struct is_row_major : internal::conditional<(int(T::Flags)&RowMajorBit), internal::true_type, internal::false_type>::type {};
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  // TODO it would be nice to be able to exploit our *_assign_op functors for that purpose
+  struct set  { template<typename Dst, typename Src> EIGEN_DEVICE_FUNC void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived()  = src; } };
+  struct add  { template<typename Dst, typename Src> EIGEN_DEVICE_FUNC void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() += src; } };
+  struct sub  { template<typename Dst, typename Src> EIGEN_DEVICE_FUNC void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() -= src; } };
+  struct adds {
+    Scalar m_scale;
+    explicit adds(const Scalar& s) : m_scale(s) {}
+    template<typename Dst, typename Src> void EIGEN_DEVICE_FUNC operator()(const Dst& dst, const Src& src) const {
+      dst.const_cast_derived() += m_scale * src;
+    }
+  };
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, set(), is_row_major<Dst>());
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, add(), is_row_major<Dst>());
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, sub(), is_row_major<Dst>());
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    internal::outer_product_selector_run(dst, lhs, rhs, adds(alpha), is_row_major<Dst>());
+  }
+
+};
+
+
+// This base class provides default implementations for evalTo, addTo, subTo, in terms of scaleAndAddTo
+template<typename Lhs, typename Rhs, typename Derived>
+struct generic_product_impl_base
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { dst.setZero(); scaleAndAddTo(dst, lhs, rhs, Scalar(1)); }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { scaleAndAddTo(dst,lhs, rhs, Scalar(1)); }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  { scaleAndAddTo(dst, lhs, rhs, Scalar(-1)); }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  { Derived::scaleAndAddTo(dst,lhs,rhs,alpha); }
+
+};
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemvProduct>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemvProduct> >
+{
+  typedef typename nested_eval<Lhs,1>::type LhsNested;
+  typedef typename nested_eval<Rhs,1>::type RhsNested;
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  enum { Side = Lhs::IsVectorAtCompileTime ? OnTheLeft : OnTheRight };
+  typedef typename internal::remove_all<typename internal::conditional<int(Side)==OnTheRight,LhsNested,RhsNested>::type>::type MatrixType;
+
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    // Fallback to inner product if both the lhs and rhs is a runtime vector.
+    if (lhs.rows() == 1 && rhs.cols() == 1) {
+      dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rhs.col(0));
+      return;
+    }
+    LhsNested actual_lhs(lhs);
+    RhsNested actual_rhs(rhs);
+    internal::gemv_dense_selector<Side,
+                            (int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor,
+                            bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)
+                           >::run(actual_lhs, actual_rhs, dst, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,CoeffBasedProductMode>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // Same as: dst.noalias() = lhs.lazyProduct(rhs);
+    // but easier on the compiler side
+    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::assign_op<typename Dst::Scalar,Scalar>());
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // dst.noalias() += lhs.lazyProduct(rhs);
+    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::add_assign_op<typename Dst::Scalar,Scalar>());
+  }
+
+  template<typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // dst.noalias() -= lhs.lazyProduct(rhs);
+    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::sub_assign_op<typename Dst::Scalar,Scalar>());
+  }
+
+  // This is a special evaluation path called from generic_product_impl<...,GemmProduct> in file GeneralMatrixMatrix.h
+  // This variant tries to extract scalar multiples from both the LHS and RHS and factor them out. For instance:
+  //   dst {,+,-}= (s1*A)*(B*s2)
+  // will be rewritten as:
+  //   dst {,+,-}= (s1*s2) * (A.lazyProduct(B))
+  // There are at least four benefits of doing so:
+  //  1 - huge performance gain for heap-allocated matrix types as it save costly allocations.
+  //  2 - it is faster than simply by-passing the heap allocation through stack allocation.
+  //  3 - it makes this fallback consistent with the heavy GEMM routine.
+  //  4 - it fully by-passes huge stack allocation attempts when multiplying huge fixed-size matrices.
+  //      (see https://stackoverflow.com/questions/54738495)
+  // For small fixed sizes matrices, howver, the gains are less obvious, it is sometimes x2 faster, but sometimes x3 slower,
+  // and the behavior depends also a lot on the compiler... This is why this re-writting strategy is currently
+  // enabled only when falling back from the main GEMM.
+  template<typename Dst, typename Func>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void eval_dynamic(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Func &func)
+  {
+    enum {
+      HasScalarFactor = blas_traits<Lhs>::HasScalarFactor || blas_traits<Rhs>::HasScalarFactor,
+      ConjLhs = blas_traits<Lhs>::NeedToConjugate,
+      ConjRhs = blas_traits<Rhs>::NeedToConjugate
+    };
+    // FIXME: in c++11 this should be auto, and extractScalarFactor should also return auto
+    //        this is important for real*complex_mat
+    Scalar actualAlpha = combine_scalar_factors<Scalar>(lhs, rhs);
+
+    eval_dynamic_impl(dst,
+                      blas_traits<Lhs>::extract(lhs).template conjugateIf<ConjLhs>(),
+                      blas_traits<Rhs>::extract(rhs).template conjugateIf<ConjRhs>(),
+                      func,
+                      actualAlpha,
+                      typename conditional<HasScalarFactor,true_type,false_type>::type());
+  }
+
+protected:
+
+  template<typename Dst, typename LhsT, typename RhsT, typename Func, typename Scalar>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void eval_dynamic_impl(Dst& dst, const LhsT& lhs, const RhsT& rhs, const Func &func, const Scalar&  s /* == 1 */, false_type)
+  {
+    EIGEN_UNUSED_VARIABLE(s);
+    eigen_internal_assert(s==Scalar(1));
+    call_restricted_packet_assignment_no_alias(dst, lhs.lazyProduct(rhs), func);
+  }
+
+  template<typename Dst, typename LhsT, typename RhsT, typename Func, typename Scalar>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void eval_dynamic_impl(Dst& dst, const LhsT& lhs, const RhsT& rhs, const Func &func, const Scalar& s, true_type)
+  {
+    call_restricted_packet_assignment_no_alias(dst, s * lhs.lazyProduct(rhs), func);
+  }
+};
+
+// This specialization enforces the use of a coefficient-based evaluation strategy
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,LazyCoeffBasedProductMode>
+  : generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,CoeffBasedProductMode> {};
+
+// Case 2: Evaluate coeff by coeff
+//
+// This is mostly taken from CoeffBasedProduct.h
+// The main difference is that we add an extra argument to the etor_product_*_impl::run() function
+// for the inner dimension of the product, because evaluator object do not know their size.
+
+template<int Traversal, int UnrollingIndex, typename Lhs, typename Rhs, typename RetScalar>
+struct etor_product_coeff_impl;
+
+template<int StorageOrder, int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, DenseShape>
+    : evaluator_base<Product<Lhs, Rhs, LazyProduct> >
+{
+  typedef Product<Lhs, Rhs, LazyProduct> XprType;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit product_evaluator(const XprType& xpr)
+    : m_lhs(xpr.lhs()),
+      m_rhs(xpr.rhs()),
+      m_lhsImpl(m_lhs),     // FIXME the creation of the evaluator objects should result in a no-op, but check that!
+      m_rhsImpl(m_rhs),     //       Moreover, they are only useful for the packet path, so we could completely disable them when not needed,
+                            //       or perhaps declare them on the fly on the packet method... We have experiment to check what's best.
+      m_innerDim(xpr.lhs().cols())
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::MulCost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::AddCost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+#if 0
+    std::cerr << "LhsOuterStrideBytes=  " << LhsOuterStrideBytes << "\n";
+    std::cerr << "RhsOuterStrideBytes=  " << RhsOuterStrideBytes << "\n";
+    std::cerr << "LhsAlignment=         " << LhsAlignment << "\n";
+    std::cerr << "RhsAlignment=         " << RhsAlignment << "\n";
+    std::cerr << "CanVectorizeLhs=      " << CanVectorizeLhs << "\n";
+    std::cerr << "CanVectorizeRhs=      " << CanVectorizeRhs << "\n";
+    std::cerr << "CanVectorizeInner=    " << CanVectorizeInner << "\n";
+    std::cerr << "EvalToRowMajor=       " << EvalToRowMajor << "\n";
+    std::cerr << "Alignment=            " << Alignment << "\n";
+    std::cerr << "Flags=                " << Flags << "\n";
+#endif
+  }
+
+  // Everything below here is taken from CoeffBasedProduct.h
+
+  typedef typename internal::nested_eval<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
+  typedef typename internal::nested_eval<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
+
+  typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
+  typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
+
+  typedef evaluator<LhsNestedCleaned> LhsEtorType;
+  typedef evaluator<RhsNestedCleaned> RhsEtorType;
+
+  enum {
+    RowsAtCompileTime = LhsNestedCleaned::RowsAtCompileTime,
+    ColsAtCompileTime = RhsNestedCleaned::ColsAtCompileTime,
+    InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(LhsNestedCleaned::ColsAtCompileTime, RhsNestedCleaned::RowsAtCompileTime),
+    MaxRowsAtCompileTime = LhsNestedCleaned::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = RhsNestedCleaned::MaxColsAtCompileTime
+  };
+
+  typedef typename find_best_packet<Scalar,RowsAtCompileTime>::type LhsVecPacketType;
+  typedef typename find_best_packet<Scalar,ColsAtCompileTime>::type RhsVecPacketType;
+
+  enum {
+
+    LhsCoeffReadCost = LhsEtorType::CoeffReadCost,
+    RhsCoeffReadCost = RhsEtorType::CoeffReadCost,
+    CoeffReadCost = InnerSize==0 ? NumTraits<Scalar>::ReadCost
+                  : InnerSize == Dynamic ? HugeCost
+                    : InnerSize * (NumTraits<Scalar>::MulCost + int(LhsCoeffReadCost) + int(RhsCoeffReadCost))
+                    + (InnerSize - 1) * NumTraits<Scalar>::AddCost,
+
+    Unroll = CoeffReadCost <= EIGEN_UNROLLING_LIMIT,
+
+    LhsFlags = LhsEtorType::Flags,
+    RhsFlags = RhsEtorType::Flags,
+
+    LhsRowMajor = LhsFlags & RowMajorBit,
+    RhsRowMajor = RhsFlags & RowMajorBit,
+
+    LhsVecPacketSize = unpacket_traits<LhsVecPacketType>::size,
+    RhsVecPacketSize = unpacket_traits<RhsVecPacketType>::size,
+
+    // Here, we don't care about alignment larger than the usable packet size.
+    LhsAlignment = EIGEN_PLAIN_ENUM_MIN(LhsEtorType::Alignment,LhsVecPacketSize*int(sizeof(typename LhsNestedCleaned::Scalar))),
+    RhsAlignment = EIGEN_PLAIN_ENUM_MIN(RhsEtorType::Alignment,RhsVecPacketSize*int(sizeof(typename RhsNestedCleaned::Scalar))),
+
+    SameType = is_same<typename LhsNestedCleaned::Scalar,typename RhsNestedCleaned::Scalar>::value,
+
+    CanVectorizeRhs = bool(RhsRowMajor) && (RhsFlags & PacketAccessBit) && (ColsAtCompileTime!=1),
+    CanVectorizeLhs = (!LhsRowMajor) && (LhsFlags & PacketAccessBit) && (RowsAtCompileTime!=1),
+
+    EvalToRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
+                    : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
+                    : (bool(RhsRowMajor) && !CanVectorizeLhs),
+
+    Flags = ((int(LhsFlags) | int(RhsFlags)) & HereditaryBits & ~RowMajorBit)
+          | (EvalToRowMajor ? RowMajorBit : 0)
+          // TODO enable vectorization for mixed types
+          | (SameType && (CanVectorizeLhs || CanVectorizeRhs) ? PacketAccessBit : 0)
+          | (XprType::IsVectorAtCompileTime ? LinearAccessBit : 0),
+
+    LhsOuterStrideBytes = int(LhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename LhsNestedCleaned::Scalar)),
+    RhsOuterStrideBytes = int(RhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename RhsNestedCleaned::Scalar)),
+
+    Alignment = bool(CanVectorizeLhs) ? (LhsOuterStrideBytes<=0 || (int(LhsOuterStrideBytes) % EIGEN_PLAIN_ENUM_MAX(1,LhsAlignment))!=0 ? 0 : LhsAlignment)
+              : bool(CanVectorizeRhs) ? (RhsOuterStrideBytes<=0 || (int(RhsOuterStrideBytes) % EIGEN_PLAIN_ENUM_MAX(1,RhsAlignment))!=0 ? 0 : RhsAlignment)
+              : 0,
+
+    /* CanVectorizeInner deserves special explanation. It does not affect the product flags. It is not used outside
+     * of Product. If the Product itself is not a packet-access expression, there is still a chance that the inner
+     * loop of the product might be vectorized. This is the meaning of CanVectorizeInner. Since it doesn't affect
+     * the Flags, it is safe to make this value depend on ActualPacketAccessBit, that doesn't affect the ABI.
+     */
+    CanVectorizeInner =    SameType
+                        && LhsRowMajor
+                        && (!RhsRowMajor)
+                        && (int(LhsFlags) & int(RhsFlags) & ActualPacketAccessBit)
+                        && (int(InnerSize) % packet_traits<Scalar>::size == 0)
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index row, Index col) const
+  {
+    return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum();
+  }
+
+  /* Allow index-based non-packet access. It is impossible though to allow index-based packed access,
+   * which is why we don't set the LinearAccessBit.
+   * TODO: this seems possible when the result is a vector
+   */
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const CoeffReturnType coeff(Index index) const
+  {
+    const Index row = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? 0 : index;
+    const Index col = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? index : 0;
+    return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum();
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const PacketType packet(Index row, Index col) const
+  {
+    PacketType res;
+    typedef etor_product_packet_impl<bool(int(Flags)&RowMajorBit) ? RowMajor : ColMajor,
+                                     Unroll ? int(InnerSize) : Dynamic,
+                                     LhsEtorType, RhsEtorType, PacketType, LoadMode> PacketImpl;
+    PacketImpl::run(row, col, m_lhsImpl, m_rhsImpl, m_innerDim, res);
+    return res;
+  }
+
+  template<int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const PacketType packet(Index index) const
+  {
+    const Index row = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? 0 : index;
+    const Index col = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime==1) ? index : 0;
+    return packet<LoadMode,PacketType>(row,col);
+  }
+
+protected:
+  typename internal::add_const_on_value_type<LhsNested>::type m_lhs;
+  typename internal::add_const_on_value_type<RhsNested>::type m_rhs;
+
+  LhsEtorType m_lhsImpl;
+  RhsEtorType m_rhsImpl;
+
+  // TODO: Get rid of m_innerDim if known at compile time
+  Index m_innerDim;
+};
+
+template<typename Lhs, typename Rhs>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, LazyCoeffBasedProductMode, DenseShape, DenseShape>
+  : product_evaluator<Product<Lhs, Rhs, LazyProduct>, CoeffBasedProductMode, DenseShape, DenseShape>
+{
+  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  typedef Product<Lhs, Rhs, LazyProduct> BaseProduct;
+  typedef product_evaluator<BaseProduct, CoeffBasedProductMode, DenseShape, DenseShape> Base;
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit product_evaluator(const XprType& xpr)
+    : Base(BaseProduct(xpr.lhs(),xpr.rhs()))
+  {}
+};
+
+/****************************************
+*** Coeff based product, Packet path  ***
+****************************************/
+
+template<int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet &res)
+  {
+    etor_product_packet_impl<RowMajor, UnrollingIndex-1, Lhs, Rhs, Packet, LoadMode>::run(row, col, lhs, rhs, innerDim, res);
+    res =  pmadd(pset1<Packet>(lhs.coeff(row, Index(UnrollingIndex-1))), rhs.template packet<LoadMode,Packet>(Index(UnrollingIndex-1), col), res);
+  }
+};
+
+template<int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet &res)
+  {
+    etor_product_packet_impl<ColMajor, UnrollingIndex-1, Lhs, Rhs, Packet, LoadMode>::run(row, col, lhs, rhs, innerDim, res);
+    res =  pmadd(lhs.template packet<LoadMode,Packet>(row, Index(UnrollingIndex-1)), pset1<Packet>(rhs.coeff(Index(UnrollingIndex-1), col)), res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, 1, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index /*innerDim*/, Packet &res)
+  {
+    res = pmul(pset1<Packet>(lhs.coeff(row, Index(0))),rhs.template packet<LoadMode,Packet>(Index(0), col));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, 1, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index /*innerDim*/, Packet &res)
+  {
+    res = pmul(lhs.template packet<LoadMode,Packet>(row, Index(0)), pset1<Packet>(rhs.coeff(Index(0), col)));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, 0, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const Lhs& /*lhs*/, const Rhs& /*rhs*/, Index /*innerDim*/, Packet &res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, 0, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const Lhs& /*lhs*/, const Rhs& /*rhs*/, Index /*innerDim*/, Packet &res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet& res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+    for(Index i = 0; i < innerDim; ++i)
+      res =  pmadd(pset1<Packet>(lhs.coeff(row, i)), rhs.template packet<LoadMode,Packet>(i, col), res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename Packet, int LoadMode>
+struct etor_product_packet_impl<ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode>
+{
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index innerDim, Packet& res)
+  {
+    res = pset1<Packet>(typename unpacket_traits<Packet>::type(0));
+    for(Index i = 0; i < innerDim; ++i)
+      res =  pmadd(lhs.template packet<LoadMode,Packet>(row, i), pset1<Packet>(rhs.coeff(i, col)), res);
+  }
+};
+
+
+/***************************************************************************
+* Triangular products
+***************************************************************************/
+template<int Mode, bool LhsIsTriangular,
+         typename Lhs, bool LhsIsVector,
+         typename Rhs, bool RhsIsVector>
+struct triangular_product_impl;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,TriangularShape,DenseShape,ProductTag>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,TriangularShape,DenseShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    triangular_product_impl<Lhs::Mode,true,typename Lhs::MatrixType,false,Rhs, Rhs::ColsAtCompileTime==1>
+        ::run(dst, lhs.nestedExpression(), rhs, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,DenseShape,TriangularShape,ProductTag>
+: generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,TriangularShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    triangular_product_impl<Rhs::Mode,false,Lhs,Lhs::RowsAtCompileTime==1, typename Rhs::MatrixType, false>::run(dst, lhs, rhs.nestedExpression(), alpha);
+  }
+};
+
+
+/***************************************************************************
+* SelfAdjoint products
+***************************************************************************/
+template <typename Lhs, int LhsMode, bool LhsIsVector,
+          typename Rhs, int RhsMode, bool RhsIsVector>
+struct selfadjoint_product_impl;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,SelfAdjointShape,DenseShape,ProductTag>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,SelfAdjointShape,DenseShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC
+  void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    selfadjoint_product_impl<typename Lhs::MatrixType,Lhs::Mode,false,Rhs,0,Rhs::IsVectorAtCompileTime>::run(dst, lhs.nestedExpression(), rhs, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs,Rhs,DenseShape,SelfAdjointShape,ProductTag>
+: generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,SelfAdjointShape,ProductTag> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    selfadjoint_product_impl<Lhs,0,Lhs::IsVectorAtCompileTime,typename Rhs::MatrixType,Rhs::Mode,false>::run(dst, lhs, rhs.nestedExpression(), alpha);
+  }
+};
+
+
+/***************************************************************************
+* Diagonal products
+***************************************************************************/
+
+template<typename MatrixType, typename DiagonalType, typename Derived, int ProductOrder>
+struct diagonal_product_evaluator_base
+  : evaluator_base<Derived>
+{
+   typedef typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType Scalar;
+public:
+  enum {
+    CoeffReadCost = int(NumTraits<Scalar>::MulCost) + int(evaluator<MatrixType>::CoeffReadCost) + int(evaluator<DiagonalType>::CoeffReadCost),
+
+    MatrixFlags = evaluator<MatrixType>::Flags,
+    DiagFlags = evaluator<DiagonalType>::Flags,
+
+    _StorageOrder = (Derived::MaxRowsAtCompileTime==1 && Derived::MaxColsAtCompileTime!=1) ? RowMajor
+                  : (Derived::MaxColsAtCompileTime==1 && Derived::MaxRowsAtCompileTime!=1) ? ColMajor
+                  : MatrixFlags & RowMajorBit ? RowMajor : ColMajor,
+    _SameStorageOrder = _StorageOrder == (MatrixFlags & RowMajorBit ? RowMajor : ColMajor),
+
+    _ScalarAccessOnDiag =  !((int(_StorageOrder) == ColMajor && int(ProductOrder) == OnTheLeft)
+                           ||(int(_StorageOrder) == RowMajor && int(ProductOrder) == OnTheRight)),
+    _SameTypes = is_same<typename MatrixType::Scalar, typename DiagonalType::Scalar>::value,
+    // FIXME currently we need same types, but in the future the next rule should be the one
+    //_Vectorizable = bool(int(MatrixFlags)&PacketAccessBit) && ((!_PacketOnDiag) || (_SameTypes && bool(int(DiagFlags)&PacketAccessBit))),
+    _Vectorizable =   bool(int(MatrixFlags)&PacketAccessBit)
+                  &&  _SameTypes
+                  && (_SameStorageOrder || (MatrixFlags&LinearAccessBit)==LinearAccessBit)
+                  && (_ScalarAccessOnDiag || (bool(int(DiagFlags)&PacketAccessBit))),
+    _LinearAccessMask = (MatrixType::RowsAtCompileTime==1 || MatrixType::ColsAtCompileTime==1) ? LinearAccessBit : 0,
+    Flags = ((HereditaryBits|_LinearAccessMask) & (unsigned int)(MatrixFlags)) | (_Vectorizable ? PacketAccessBit : 0),
+    Alignment = evaluator<MatrixType>::Alignment,
+
+    AsScalarProduct =     (DiagonalType::SizeAtCompileTime==1)
+                      ||  (DiagonalType::SizeAtCompileTime==Dynamic && MatrixType::RowsAtCompileTime==1 && ProductOrder==OnTheLeft)
+                      ||  (DiagonalType::SizeAtCompileTime==Dynamic && MatrixType::ColsAtCompileTime==1 && ProductOrder==OnTheRight)
+  };
+
+  EIGEN_DEVICE_FUNC diagonal_product_evaluator_base(const MatrixType &mat, const DiagonalType &diag)
+    : m_diagImpl(diag), m_matImpl(mat)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::MulCost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index idx) const
+  {
+    if(AsScalarProduct)
+      return m_diagImpl.coeff(0) * m_matImpl.coeff(idx);
+    else
+      return m_diagImpl.coeff(idx) * m_matImpl.coeff(idx);
+  }
+
+protected:
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::true_type) const
+  {
+    return internal::pmul(m_matImpl.template packet<LoadMode,PacketType>(row, col),
+                          internal::pset1<PacketType>(m_diagImpl.coeff(id)));
+  }
+
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::false_type) const
+  {
+    enum {
+      InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime,
+      DiagonalPacketLoadMode = EIGEN_PLAIN_ENUM_MIN(LoadMode,((InnerSize%16) == 0) ? int(Aligned16) : int(evaluator<DiagonalType>::Alignment)) // FIXME hardcoded 16!!
+    };
+    return internal::pmul(m_matImpl.template packet<LoadMode,PacketType>(row, col),
+                          m_diagImpl.template packet<DiagonalPacketLoadMode,PacketType>(id));
+  }
+
+  evaluator<DiagonalType> m_diagImpl;
+  evaluator<MatrixType>   m_matImpl;
+};
+
+// diagonal * dense
+template<typename Lhs, typename Rhs, int ProductKind, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DiagonalShape, DenseShape>
+  : diagonal_product_evaluator_base<Rhs, typename Lhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheLeft>
+{
+  typedef diagonal_product_evaluator_base<Rhs, typename Lhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheLeft> Base;
+  using Base::m_diagImpl;
+  using Base::m_matImpl;
+  using Base::coeff;
+  typedef typename Base::Scalar Scalar;
+
+  typedef Product<Lhs, Rhs, ProductKind> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef typename Lhs::DiagonalVectorType DiagonalType;
+
+
+  enum { StorageOrder = Base::_StorageOrder };
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.rhs(), xpr.lhs().diagonal())
+  {
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const
+  {
+    return m_diagImpl.coeff(row) * m_matImpl.coeff(row, col);
+  }
+
+#ifndef EIGEN_GPUCC
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
+  {
+    // FIXME: NVCC used to complain about the template keyword, but we have to check whether this is still the case.
+    // See also similar calls below.
+    return this->template packet_impl<LoadMode,PacketType>(row,col, row,
+                                 typename internal::conditional<int(StorageOrder)==RowMajor, internal::true_type, internal::false_type>::type());
+  }
+
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index idx) const
+  {
+    return packet<LoadMode,PacketType>(int(StorageOrder)==ColMajor?idx:0,int(StorageOrder)==ColMajor?0:idx);
+  }
+#endif
+};
+
+// dense * diagonal
+template<typename Lhs, typename Rhs, int ProductKind, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DenseShape, DiagonalShape>
+  : diagonal_product_evaluator_base<Lhs, typename Rhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheRight>
+{
+  typedef diagonal_product_evaluator_base<Lhs, typename Rhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheRight> Base;
+  using Base::m_diagImpl;
+  using Base::m_matImpl;
+  using Base::coeff;
+  typedef typename Base::Scalar Scalar;
+
+  typedef Product<Lhs, Rhs, ProductKind> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+
+  enum { StorageOrder = Base::_StorageOrder };
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.lhs(), xpr.rhs().diagonal())
+  {
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const
+  {
+    return m_matImpl.coeff(row, col) * m_diagImpl.coeff(col);
+  }
+
+#ifndef EIGEN_GPUCC
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
+  {
+    return this->template packet_impl<LoadMode,PacketType>(row,col, col,
+                                 typename internal::conditional<int(StorageOrder)==ColMajor, internal::true_type, internal::false_type>::type());
+  }
+
+  template<int LoadMode,typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index idx) const
+  {
+    return packet<LoadMode,PacketType>(int(StorageOrder)==ColMajor?idx:0,int(StorageOrder)==ColMajor?0:idx);
+  }
+#endif
+};
+
+/***************************************************************************
+* Products with permutation matrices
+***************************************************************************/
+
+/** \internal
+  * \class permutation_matrix_product
+  * Internal helper class implementing the product between a permutation matrix and a matrix.
+  * This class is specialized for DenseShape below and for SparseShape in SparseCore/SparsePermutation.h
+  */
+template<typename ExpressionType, int Side, bool Transposed, typename ExpressionShape>
+struct permutation_matrix_product;
+
+template<typename ExpressionType, int Side, bool Transposed>
+struct permutation_matrix_product<ExpressionType, Side, Transposed, DenseShape>
+{
+    typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
+    typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+
+    template<typename Dest, typename PermutationType>
+    static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Dest& dst, const PermutationType& perm, const ExpressionType& xpr)
+    {
+      MatrixType mat(xpr);
+      const Index n = Side==OnTheLeft ? mat.rows() : mat.cols();
+      // FIXME we need an is_same for expression that is not sensitive to constness. For instance
+      // is_same_xpr<Block<const Matrix>, Block<Matrix> >::value should be true.
+      //if(is_same<MatrixTypeCleaned,Dest>::value && extract_data(dst) == extract_data(mat))
+      if(is_same_dense(dst, mat))
+      {
+        // apply the permutation inplace
+        Matrix<bool,PermutationType::RowsAtCompileTime,1,0,PermutationType::MaxRowsAtCompileTime> mask(perm.size());
+        mask.fill(false);
+        Index r = 0;
+        while(r < perm.size())
+        {
+          // search for the next seed
+          while(r<perm.size() && mask[r]) r++;
+          if(r>=perm.size())
+            break;
+          // we got one, let's follow it until we are back to the seed
+          Index k0 = r++;
+          Index kPrev = k0;
+          mask.coeffRef(k0) = true;
+          for(Index k=perm.indices().coeff(k0); k!=k0; k=perm.indices().coeff(k))
+          {
+                  Block<Dest, Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime, Side==OnTheRight ? 1 : Dest::ColsAtCompileTime>(dst, k)
+            .swap(Block<Dest, Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime, Side==OnTheRight ? 1 : Dest::ColsAtCompileTime>
+                       (dst,((Side==OnTheLeft) ^ Transposed) ? k0 : kPrev));
+
+            mask.coeffRef(k) = true;
+            kPrev = k;
+          }
+        }
+      }
+      else
+      {
+        for(Index i = 0; i < n; ++i)
+        {
+          Block<Dest, Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime, Side==OnTheRight ? 1 : Dest::ColsAtCompileTime>
+               (dst, ((Side==OnTheLeft) ^ Transposed) ? perm.indices().coeff(i) : i)
+
+          =
+
+          Block<const MatrixTypeCleaned,Side==OnTheLeft ? 1 : MatrixTypeCleaned::RowsAtCompileTime,Side==OnTheRight ? 1 : MatrixTypeCleaned::ColsAtCompileTime>
+               (mat, ((Side==OnTheRight) ^ Transposed) ? perm.indices().coeff(i) : i);
+        }
+      }
+    }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, PermutationShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    permutation_matrix_product<Rhs, OnTheLeft, false, MatrixShape>::run(dst, lhs, rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, MatrixShape, PermutationShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    permutation_matrix_product<Lhs, OnTheRight, false, MatrixShape>::run(dst, rhs, lhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Inverse<Lhs>, Rhs, PermutationShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Inverse<Lhs>& lhs, const Rhs& rhs)
+  {
+    permutation_matrix_product<Rhs, OnTheLeft, true, MatrixShape>::run(dst, lhs.nestedExpression(), rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Inverse<Rhs>, MatrixShape, PermutationShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Inverse<Rhs>& rhs)
+  {
+    permutation_matrix_product<Lhs, OnTheRight, true, MatrixShape>::run(dst, rhs.nestedExpression(), lhs);
+  }
+};
+
+
+/***************************************************************************
+* Products with transpositions matrices
+***************************************************************************/
+
+// FIXME could we unify Transpositions and Permutation into a single "shape"??
+
+/** \internal
+  * \class transposition_matrix_product
+  * Internal helper class implementing the product between a permutation matrix and a matrix.
+  */
+template<typename ExpressionType, int Side, bool Transposed, typename ExpressionShape>
+struct transposition_matrix_product
+{
+  typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
+  typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+
+  template<typename Dest, typename TranspositionType>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Dest& dst, const TranspositionType& tr, const ExpressionType& xpr)
+  {
+    MatrixType mat(xpr);
+    typedef typename TranspositionType::StorageIndex StorageIndex;
+    const Index size = tr.size();
+    StorageIndex j = 0;
+
+    if(!is_same_dense(dst,mat))
+      dst = mat;
+
+    for(Index k=(Transposed?size-1:0) ; Transposed?k>=0:k<size ; Transposed?--k:++k)
+      if(Index(j=tr.coeff(k))!=k)
+      {
+        if(Side==OnTheLeft)        dst.row(k).swap(dst.row(j));
+        else if(Side==OnTheRight)  dst.col(k).swap(dst.col(j));
+      }
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, TranspositionsShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    transposition_matrix_product<Rhs, OnTheLeft, false, MatrixShape>::run(dst, lhs, rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Rhs, MatrixShape, TranspositionsShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    transposition_matrix_product<Lhs, OnTheRight, false, MatrixShape>::run(dst, rhs, lhs);
+  }
+};
+
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Transpose<Lhs>, Rhs, TranspositionsShape, MatrixShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Transpose<Lhs>& lhs, const Rhs& rhs)
+  {
+    transposition_matrix_product<Rhs, OnTheLeft, true, MatrixShape>::run(dst, lhs.nestedExpression(), rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
+struct generic_product_impl<Lhs, Transpose<Rhs>, MatrixShape, TranspositionsShape, ProductTag>
+{
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Transpose<Rhs>& rhs)
+  {
+    transposition_matrix_product<Lhs, OnTheRight, true, MatrixShape>::run(dst, rhs.nestedExpression(), lhs);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PRODUCT_EVALUATORS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Random.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Random.h
new file mode 100644
index 00000000..dab2ac8e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Random.h
@@ -0,0 +1,218 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_RANDOM_H
+#define EIGEN_RANDOM_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Scalar> struct scalar_random_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_random_op)
+  inline const Scalar operator() () const { return random<Scalar>(); }
+};
+
+template<typename Scalar>
+struct functor_traits<scalar_random_op<Scalar> >
+{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false, IsRepeatable = false }; };
+
+} // end namespace internal
+
+/** \returns a random matrix expression
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * The parameters \a rows and \a cols are the number of rows and of columns of
+  * the returned matrix. Must be compatible with this MatrixBase type.
+  *
+  * \not_reentrant
+  * 
+  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
+  * it is redundant to pass \a rows and \a cols as arguments, so Random() should be used
+  * instead.
+  * 
+  *
+  * Example: \include MatrixBase_random_int_int.cpp
+  * Output: \verbinclude MatrixBase_random_int_int.out
+  *
+  * This expression has the "evaluate before nesting" flag so that it will be evaluated into
+  * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected
+  * behavior with expressions involving random matrices.
+  * 
+  * See DenseBase::NullaryExpr(Index, const CustomNullaryOp&) for an example using C++11 random generators.
+  *
+  * \sa DenseBase::setRandom(), DenseBase::Random(Index), DenseBase::Random()
+  */
+template<typename Derived>
+inline const typename DenseBase<Derived>::RandomReturnType
+DenseBase<Derived>::Random(Index rows, Index cols)
+{
+  return NullaryExpr(rows, cols, internal::scalar_random_op<Scalar>());
+}
+
+/** \returns a random vector expression
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  *
+  * The parameter \a size is the size of the returned vector.
+  * Must be compatible with this MatrixBase type.
+  *
+  * \only_for_vectors
+  * \not_reentrant
+  *
+  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
+  * it is redundant to pass \a size as argument, so Random() should be used
+  * instead.
+  *
+  * Example: \include MatrixBase_random_int.cpp
+  * Output: \verbinclude MatrixBase_random_int.out
+  *
+  * This expression has the "evaluate before nesting" flag so that it will be evaluated into
+  * a temporary vector whenever it is nested in a larger expression. This prevents unexpected
+  * behavior with expressions involving random matrices.
+  *
+  * \sa DenseBase::setRandom(), DenseBase::Random(Index,Index), DenseBase::Random()
+  */
+template<typename Derived>
+inline const typename DenseBase<Derived>::RandomReturnType
+DenseBase<Derived>::Random(Index size)
+{
+  return NullaryExpr(size, internal::scalar_random_op<Scalar>());
+}
+
+/** \returns a fixed-size random matrix or vector expression
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
+  * need to use the variants taking size arguments.
+  *
+  * Example: \include MatrixBase_random.cpp
+  * Output: \verbinclude MatrixBase_random.out
+  *
+  * This expression has the "evaluate before nesting" flag so that it will be evaluated into
+  * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected
+  * behavior with expressions involving random matrices.
+  * 
+  * \not_reentrant
+  *
+  * \sa DenseBase::setRandom(), DenseBase::Random(Index,Index), DenseBase::Random(Index)
+  */
+template<typename Derived>
+inline const typename DenseBase<Derived>::RandomReturnType
+DenseBase<Derived>::Random()
+{
+  return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_random_op<Scalar>());
+}
+
+/** Sets all coefficients in this expression to random values.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * \not_reentrant
+  * 
+  * Example: \include MatrixBase_setRandom.cpp
+  * Output: \verbinclude MatrixBase_setRandom.out
+  *
+  * \sa class CwiseNullaryOp, setRandom(Index), setRandom(Index,Index)
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Derived& DenseBase<Derived>::setRandom()
+{
+  return *this = Random(rows(), cols());
+}
+
+/** Resizes to the given \a newSize, and sets all coefficients in this expression to random values.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  * 
+  * \only_for_vectors
+  * \not_reentrant
+  *
+  * Example: \include Matrix_setRandom_int.cpp
+  * Output: \verbinclude Matrix_setRandom_int.out
+  *
+  * \sa DenseBase::setRandom(), setRandom(Index,Index), class CwiseNullaryOp, DenseBase::Random()
+  */
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setRandom(Index newSize)
+{
+  resize(newSize);
+  return setRandom();
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to random values.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  *
+  * \not_reentrant
+  * 
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setRandom_int_int.cpp
+  * Output: \verbinclude Matrix_setRandom_int_int.out
+  *
+  * \sa DenseBase::setRandom(), setRandom(Index), class CwiseNullaryOp, DenseBase::Random()
+  */
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setRandom(Index rows, Index cols)
+{
+  resize(rows, cols);
+  return setRandom();
+}
+
+/** Resizes to the given size, changing only the number of columns, and sets all
+  * coefficients in this expression to random values. For the parameter of type
+  * NoChange_t, just pass the special value \c NoChange.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  *
+  * \not_reentrant
+  *
+  * \sa DenseBase::setRandom(), setRandom(Index), setRandom(Index, NoChange_t), class CwiseNullaryOp, DenseBase::Random()
+  */
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setRandom(NoChange_t, Index cols)
+{
+  return setRandom(rows(), cols);
+}
+
+/** Resizes to the given size, changing only the number of rows, and sets all
+  * coefficients in this expression to random values. For the parameter of type
+  * NoChange_t, just pass the special value \c NoChange.
+  *
+  * Numbers are uniformly spread through their whole definition range for integer types,
+  * and in the [-1:1] range for floating point scalar types.
+  *
+  * \not_reentrant
+  *
+  * \sa DenseBase::setRandom(), setRandom(Index), setRandom(NoChange_t, Index), class CwiseNullaryOp, DenseBase::Random()
+  */
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+PlainObjectBase<Derived>::setRandom(Index rows, NoChange_t)
+{
+  return setRandom(rows, cols());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_RANDOM_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Redux.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Redux.h
new file mode 100644
index 00000000..b6790d11
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Redux.h
@@ -0,0 +1,515 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REDUX_H
+#define EIGEN_REDUX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// TODO
+//  * implement other kind of vectorization
+//  * factorize code
+
+/***************************************************************************
+* Part 1 : the logic deciding a strategy for vectorization and unrolling
+***************************************************************************/
+
+template<typename Func, typename Evaluator>
+struct redux_traits
+{
+public:
+    typedef typename find_best_packet<typename Evaluator::Scalar,Evaluator::SizeAtCompileTime>::type PacketType;
+  enum {
+    PacketSize = unpacket_traits<PacketType>::size,
+    InnerMaxSize = int(Evaluator::IsRowMajor)
+                 ? Evaluator::MaxColsAtCompileTime
+                 : Evaluator::MaxRowsAtCompileTime,
+    OuterMaxSize = int(Evaluator::IsRowMajor)
+                 ? Evaluator::MaxRowsAtCompileTime
+                 : Evaluator::MaxColsAtCompileTime,
+    SliceVectorizedWork = int(InnerMaxSize)==Dynamic ? Dynamic
+                        : int(OuterMaxSize)==Dynamic ? (int(InnerMaxSize)>=int(PacketSize) ? Dynamic : 0)
+                        : (int(InnerMaxSize)/int(PacketSize)) * int(OuterMaxSize)
+  };
+
+  enum {
+    MightVectorize = (int(Evaluator::Flags)&ActualPacketAccessBit)
+                  && (functor_traits<Func>::PacketAccess),
+    MayLinearVectorize = bool(MightVectorize) && (int(Evaluator::Flags)&LinearAccessBit),
+    MaySliceVectorize  = bool(MightVectorize) && (int(SliceVectorizedWork)==Dynamic || int(SliceVectorizedWork)>=3)
+  };
+
+public:
+  enum {
+    Traversal = int(MayLinearVectorize) ? int(LinearVectorizedTraversal)
+              : int(MaySliceVectorize)  ? int(SliceVectorizedTraversal)
+                                        : int(DefaultTraversal)
+  };
+
+public:
+  enum {
+    Cost = Evaluator::SizeAtCompileTime == Dynamic ? HugeCost
+         : int(Evaluator::SizeAtCompileTime) * int(Evaluator::CoeffReadCost) + (Evaluator::SizeAtCompileTime-1) * functor_traits<Func>::Cost,
+    UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Traversal) == int(DefaultTraversal) ? 1 : int(PacketSize))
+  };
+
+public:
+  enum {
+    Unrolling = Cost <= UnrollingLimit ? CompleteUnrolling : NoUnrolling
+  };
+  
+#ifdef EIGEN_DEBUG_ASSIGN
+  static void debug()
+  {
+    std::cerr << "Xpr: " << typeid(typename Evaluator::XprType).name() << std::endl;
+    std::cerr.setf(std::ios::hex, std::ios::basefield);
+    EIGEN_DEBUG_VAR(Evaluator::Flags)
+    std::cerr.unsetf(std::ios::hex);
+    EIGEN_DEBUG_VAR(InnerMaxSize)
+    EIGEN_DEBUG_VAR(OuterMaxSize)
+    EIGEN_DEBUG_VAR(SliceVectorizedWork)
+    EIGEN_DEBUG_VAR(PacketSize)
+    EIGEN_DEBUG_VAR(MightVectorize)
+    EIGEN_DEBUG_VAR(MayLinearVectorize)
+    EIGEN_DEBUG_VAR(MaySliceVectorize)
+    std::cerr << "Traversal" << " = " << Traversal << " (" << demangle_traversal(Traversal) << ")" << std::endl;
+    EIGEN_DEBUG_VAR(UnrollingLimit)
+    std::cerr << "Unrolling" << " = " << Unrolling << " (" << demangle_unrolling(Unrolling) << ")" << std::endl;
+    std::cerr << std::endl;
+  }
+#endif
+};
+
+/***************************************************************************
+* Part 2 : unrollers
+***************************************************************************/
+
+/*** no vectorization ***/
+
+template<typename Func, typename Evaluator, int Start, int Length>
+struct redux_novec_unroller
+{
+  enum {
+    HalfLength = Length/2
+  };
+
+  typedef typename Evaluator::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Scalar run(const Evaluator &eval, const Func& func)
+  {
+    return func(redux_novec_unroller<Func, Evaluator, Start, HalfLength>::run(eval,func),
+                redux_novec_unroller<Func, Evaluator, Start+HalfLength, Length-HalfLength>::run(eval,func));
+  }
+};
+
+template<typename Func, typename Evaluator, int Start>
+struct redux_novec_unroller<Func, Evaluator, Start, 1>
+{
+  enum {
+    outer = Start / Evaluator::InnerSizeAtCompileTime,
+    inner = Start % Evaluator::InnerSizeAtCompileTime
+  };
+
+  typedef typename Evaluator::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Scalar run(const Evaluator &eval, const Func&)
+  {
+    return eval.coeffByOuterInner(outer, inner);
+  }
+};
+
+// This is actually dead code and will never be called. It is required
+// to prevent false warnings regarding failed inlining though
+// for 0 length run() will never be called at all.
+template<typename Func, typename Evaluator, int Start>
+struct redux_novec_unroller<Func, Evaluator, Start, 0>
+{
+  typedef typename Evaluator::Scalar Scalar;
+  EIGEN_DEVICE_FUNC 
+  static EIGEN_STRONG_INLINE Scalar run(const Evaluator&, const Func&) { return Scalar(); }
+};
+
+/*** vectorization ***/
+
+template<typename Func, typename Evaluator, int Start, int Length>
+struct redux_vec_unroller
+{
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE PacketType run(const Evaluator &eval, const Func& func)
+  {
+    enum {
+      PacketSize = unpacket_traits<PacketType>::size,
+      HalfLength = Length/2
+    };
+
+    return func.packetOp(
+            redux_vec_unroller<Func, Evaluator, Start, HalfLength>::template run<PacketType>(eval,func),
+            redux_vec_unroller<Func, Evaluator, Start+HalfLength, Length-HalfLength>::template run<PacketType>(eval,func) );
+  }
+};
+
+template<typename Func, typename Evaluator, int Start>
+struct redux_vec_unroller<Func, Evaluator, Start, 1>
+{
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE PacketType run(const Evaluator &eval, const Func&)
+  {
+    enum {
+      PacketSize = unpacket_traits<PacketType>::size,
+      index = Start * PacketSize,
+      outer = index / int(Evaluator::InnerSizeAtCompileTime),
+      inner = index % int(Evaluator::InnerSizeAtCompileTime),
+      alignment = Evaluator::Alignment
+    };
+    return eval.template packetByOuterInner<alignment,PacketType>(outer, inner);
+  }
+};
+
+/***************************************************************************
+* Part 3 : implementation of all cases
+***************************************************************************/
+
+template<typename Func, typename Evaluator,
+         int Traversal = redux_traits<Func, Evaluator>::Traversal,
+         int Unrolling = redux_traits<Func, Evaluator>::Unrolling
+>
+struct redux_impl;
+
+template<typename Func, typename Evaluator>
+struct redux_impl<Func, Evaluator, DefaultTraversal, NoUnrolling>
+{
+  typedef typename Evaluator::Scalar Scalar;
+
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE
+  Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
+  {
+    eigen_assert(xpr.rows()>0 && xpr.cols()>0 && "you are using an empty matrix");
+    Scalar res;
+    res = eval.coeffByOuterInner(0, 0);
+    for(Index i = 1; i < xpr.innerSize(); ++i)
+      res = func(res, eval.coeffByOuterInner(0, i));
+    for(Index i = 1; i < xpr.outerSize(); ++i)
+      for(Index j = 0; j < xpr.innerSize(); ++j)
+        res = func(res, eval.coeffByOuterInner(i, j));
+    return res;
+  }
+};
+
+template<typename Func, typename Evaluator>
+struct redux_impl<Func,Evaluator, DefaultTraversal, CompleteUnrolling>
+  : redux_novec_unroller<Func,Evaluator, 0, Evaluator::SizeAtCompileTime>
+{
+  typedef redux_novec_unroller<Func,Evaluator, 0, Evaluator::SizeAtCompileTime> Base;
+  typedef typename Evaluator::Scalar Scalar;
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE
+  Scalar run(const Evaluator &eval, const Func& func, const XprType& /*xpr*/)
+  {
+    return Base::run(eval,func);
+  }
+};
+
+template<typename Func, typename Evaluator>
+struct redux_impl<Func, Evaluator, LinearVectorizedTraversal, NoUnrolling>
+{
+  typedef typename Evaluator::Scalar Scalar;
+  typedef typename redux_traits<Func, Evaluator>::PacketType PacketScalar;
+
+  template<typename XprType>
+  static Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
+  {
+    const Index size = xpr.size();
+    
+    const Index packetSize = redux_traits<Func, Evaluator>::PacketSize;
+    const int packetAlignment = unpacket_traits<PacketScalar>::alignment;
+    enum {
+      alignment0 = (bool(Evaluator::Flags & DirectAccessBit) && bool(packet_traits<Scalar>::AlignedOnScalar)) ? int(packetAlignment) : int(Unaligned),
+      alignment = EIGEN_PLAIN_ENUM_MAX(alignment0, Evaluator::Alignment)
+    };
+    const Index alignedStart = internal::first_default_aligned(xpr);
+    const Index alignedSize2 = ((size-alignedStart)/(2*packetSize))*(2*packetSize);
+    const Index alignedSize = ((size-alignedStart)/(packetSize))*(packetSize);
+    const Index alignedEnd2 = alignedStart + alignedSize2;
+    const Index alignedEnd  = alignedStart + alignedSize;
+    Scalar res;
+    if(alignedSize)
+    {
+      PacketScalar packet_res0 = eval.template packet<alignment,PacketScalar>(alignedStart);
+      if(alignedSize>packetSize) // we have at least two packets to partly unroll the loop
+      {
+        PacketScalar packet_res1 = eval.template packet<alignment,PacketScalar>(alignedStart+packetSize);
+        for(Index index = alignedStart + 2*packetSize; index < alignedEnd2; index += 2*packetSize)
+        {
+          packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment,PacketScalar>(index));
+          packet_res1 = func.packetOp(packet_res1, eval.template packet<alignment,PacketScalar>(index+packetSize));
+        }
+
+        packet_res0 = func.packetOp(packet_res0,packet_res1);
+        if(alignedEnd>alignedEnd2)
+          packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment,PacketScalar>(alignedEnd2));
+      }
+      res = func.predux(packet_res0);
+
+      for(Index index = 0; index < alignedStart; ++index)
+        res = func(res,eval.coeff(index));
+
+      for(Index index = alignedEnd; index < size; ++index)
+        res = func(res,eval.coeff(index));
+    }
+    else // too small to vectorize anything.
+         // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
+    {
+      res = eval.coeff(0);
+      for(Index index = 1; index < size; ++index)
+        res = func(res,eval.coeff(index));
+    }
+
+    return res;
+  }
+};
+
+// NOTE: for SliceVectorizedTraversal we simply bypass unrolling
+template<typename Func, typename Evaluator, int Unrolling>
+struct redux_impl<Func, Evaluator, SliceVectorizedTraversal, Unrolling>
+{
+  typedef typename Evaluator::Scalar Scalar;
+  typedef typename redux_traits<Func, Evaluator>::PacketType PacketType;
+
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC static Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
+  {
+    eigen_assert(xpr.rows()>0 && xpr.cols()>0 && "you are using an empty matrix");
+    const Index innerSize = xpr.innerSize();
+    const Index outerSize = xpr.outerSize();
+    enum {
+      packetSize = redux_traits<Func, Evaluator>::PacketSize
+    };
+    const Index packetedInnerSize = ((innerSize)/packetSize)*packetSize;
+    Scalar res;
+    if(packetedInnerSize)
+    {
+      PacketType packet_res = eval.template packet<Unaligned,PacketType>(0,0);
+      for(Index j=0; j<outerSize; ++j)
+        for(Index i=(j==0?packetSize:0); i<packetedInnerSize; i+=Index(packetSize))
+          packet_res = func.packetOp(packet_res, eval.template packetByOuterInner<Unaligned,PacketType>(j,i));
+
+      res = func.predux(packet_res);
+      for(Index j=0; j<outerSize; ++j)
+        for(Index i=packetedInnerSize; i<innerSize; ++i)
+          res = func(res, eval.coeffByOuterInner(j,i));
+    }
+    else // too small to vectorize anything.
+         // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
+    {
+      res = redux_impl<Func, Evaluator, DefaultTraversal, NoUnrolling>::run(eval, func, xpr);
+    }
+
+    return res;
+  }
+};
+
+template<typename Func, typename Evaluator>
+struct redux_impl<Func, Evaluator, LinearVectorizedTraversal, CompleteUnrolling>
+{
+  typedef typename Evaluator::Scalar Scalar;
+
+  typedef typename redux_traits<Func, Evaluator>::PacketType PacketType;
+  enum {
+    PacketSize = redux_traits<Func, Evaluator>::PacketSize,
+    Size = Evaluator::SizeAtCompileTime,
+    VectorizedSize = (int(Size) / int(PacketSize)) * int(PacketSize)
+  };
+
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE
+  Scalar run(const Evaluator &eval, const Func& func, const XprType &xpr)
+  {
+    EIGEN_ONLY_USED_FOR_DEBUG(xpr)
+    eigen_assert(xpr.rows()>0 && xpr.cols()>0 && "you are using an empty matrix");
+    if (VectorizedSize > 0) {
+      Scalar res = func.predux(redux_vec_unroller<Func, Evaluator, 0, Size / PacketSize>::template run<PacketType>(eval,func));
+      if (VectorizedSize != Size)
+        res = func(res,redux_novec_unroller<Func, Evaluator, VectorizedSize, Size-VectorizedSize>::run(eval,func));
+      return res;
+    }
+    else {
+      return redux_novec_unroller<Func, Evaluator, 0, Size>::run(eval,func);
+    }
+  }
+};
+
+// evaluator adaptor
+template<typename _XprType>
+class redux_evaluator : public internal::evaluator<_XprType>
+{
+  typedef internal::evaluator<_XprType> Base;
+public:
+  typedef _XprType XprType;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  explicit redux_evaluator(const XprType &xpr) : Base(xpr) {}
+  
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename XprType::PacketScalar PacketScalar;
+  
+  enum {
+    MaxRowsAtCompileTime = XprType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = XprType::MaxColsAtCompileTime,
+    // TODO we should not remove DirectAccessBit and rather find an elegant way to query the alignment offset at runtime from the evaluator
+    Flags = Base::Flags & ~DirectAccessBit,
+    IsRowMajor = XprType::IsRowMajor,
+    SizeAtCompileTime = XprType::SizeAtCompileTime,
+    InnerSizeAtCompileTime = XprType::InnerSizeAtCompileTime
+  };
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  CoeffReturnType coeffByOuterInner(Index outer, Index inner) const
+  { return Base::coeff(IsRowMajor ? outer : inner, IsRowMajor ? inner : outer); }
+  
+  template<int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  PacketType packetByOuterInner(Index outer, Index inner) const
+  { return Base::template packet<LoadMode,PacketType>(IsRowMajor ? outer : inner, IsRowMajor ? inner : outer); }
+  
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Part 4 : public API
+***************************************************************************/
+
+
+/** \returns the result of a full redux operation on the whole matrix or vector using \a func
+  *
+  * The template parameter \a BinaryOp is the type of the functor \a func which must be
+  * an associative operator. Both current C++98 and C++11 functor styles are handled.
+  *
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  *
+  * \sa DenseBase::sum(), DenseBase::minCoeff(), DenseBase::maxCoeff(), MatrixBase::colwise(), MatrixBase::rowwise()
+  */
+template<typename Derived>
+template<typename Func>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::redux(const Func& func) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  typedef typename internal::redux_evaluator<Derived> ThisEvaluator;
+  ThisEvaluator thisEval(derived());
+
+  // The initial expression is passed to the reducer as an additional argument instead of
+  // passing it as a member of redux_evaluator to help  
+  return internal::redux_impl<Func, ThisEvaluator>::run(thisEval, func, derived());
+}
+
+/** \returns the minimum of all coefficients of \c *this.
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is minimum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  */
+template<typename Derived>
+template<int NaNPropagation>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::minCoeff() const
+{
+  return derived().redux(Eigen::internal::scalar_min_op<Scalar,Scalar, NaNPropagation>());
+}
+
+/** \returns the maximum of all coefficients of \c *this. 
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  */
+template<typename Derived>
+template<int NaNPropagation>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::maxCoeff() const
+{
+  return derived().redux(Eigen::internal::scalar_max_op<Scalar,Scalar, NaNPropagation>());
+}
+
+/** \returns the sum of all coefficients of \c *this
+  *
+  * If \c *this is empty, then the value 0 is returned.
+  *
+  * \sa trace(), prod(), mean()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::sum() const
+{
+  if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0))
+    return Scalar(0);
+  return derived().redux(Eigen::internal::scalar_sum_op<Scalar,Scalar>());
+}
+
+/** \returns the mean of all coefficients of *this
+*
+* \sa trace(), prod(), sum()
+*/
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::mean() const
+{
+#ifdef __INTEL_COMPILER
+  #pragma warning push
+  #pragma warning ( disable : 2259 )
+#endif
+  return Scalar(derived().redux(Eigen::internal::scalar_sum_op<Scalar,Scalar>())) / Scalar(this->size());
+#ifdef __INTEL_COMPILER
+  #pragma warning pop
+#endif
+}
+
+/** \returns the product of all coefficients of *this
+  *
+  * Example: \include MatrixBase_prod.cpp
+  * Output: \verbinclude MatrixBase_prod.out
+  *
+  * \sa sum(), mean(), trace()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::prod() const
+{
+  if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0))
+    return Scalar(1);
+  return derived().redux(Eigen::internal::scalar_product_op<Scalar>());
+}
+
+/** \returns the trace of \c *this, i.e. the sum of the coefficients on the main diagonal.
+  *
+  * \c *this can be any matrix, not necessarily square.
+  *
+  * \sa diagonal(), sum()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
+MatrixBase<Derived>::trace() const
+{
+  return derived().diagonal().sum();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REDUX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Ref.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Ref.h
new file mode 100644
index 00000000..c2a37ead
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Ref.h
@@ -0,0 +1,381 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REF_H
+#define EIGEN_REF_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename _PlainObjectType, int _Options, typename _StrideType>
+struct traits<Ref<_PlainObjectType, _Options, _StrideType> >
+  : public traits<Map<_PlainObjectType, _Options, _StrideType> >
+{
+  typedef _PlainObjectType PlainObjectType;
+  typedef _StrideType StrideType;
+  enum {
+    Options = _Options,
+    Flags = traits<Map<_PlainObjectType, _Options, _StrideType> >::Flags | NestByRefBit,
+    Alignment = traits<Map<_PlainObjectType, _Options, _StrideType> >::Alignment
+  };
+
+  template<typename Derived> struct match {
+    enum {
+      IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime,
+      HasDirectAccess = internal::has_direct_access<Derived>::ret,
+      StorageOrderMatch = IsVectorAtCompileTime || ((PlainObjectType::Flags&RowMajorBit)==(Derived::Flags&RowMajorBit)),
+      InnerStrideMatch = int(StrideType::InnerStrideAtCompileTime)==int(Dynamic)
+                      || int(StrideType::InnerStrideAtCompileTime)==int(Derived::InnerStrideAtCompileTime)
+                      || (int(StrideType::InnerStrideAtCompileTime)==0 && int(Derived::InnerStrideAtCompileTime)==1),
+      OuterStrideMatch = IsVectorAtCompileTime
+                      || int(StrideType::OuterStrideAtCompileTime)==int(Dynamic) || int(StrideType::OuterStrideAtCompileTime)==int(Derived::OuterStrideAtCompileTime),
+      // NOTE, this indirection of evaluator<Derived>::Alignment is needed
+      // to workaround a very strange bug in MSVC related to the instantiation
+      // of has_*ary_operator in evaluator<CwiseNullaryOp>.
+      // This line is surprisingly very sensitive. For instance, simply adding parenthesis
+      // as "DerivedAlignment = (int(evaluator<Derived>::Alignment))," will make MSVC fail...
+      DerivedAlignment = int(evaluator<Derived>::Alignment),
+      AlignmentMatch = (int(traits<PlainObjectType>::Alignment)==int(Unaligned)) || (DerivedAlignment >= int(Alignment)), // FIXME the first condition is not very clear, it should be replaced by the required alignment
+      ScalarTypeMatch = internal::is_same<typename PlainObjectType::Scalar, typename Derived::Scalar>::value,
+      MatchAtCompileTime = HasDirectAccess && StorageOrderMatch && InnerStrideMatch && OuterStrideMatch && AlignmentMatch && ScalarTypeMatch
+    };
+    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
+  };
+
+};
+
+template<typename Derived>
+struct traits<RefBase<Derived> > : public traits<Derived> {};
+
+}
+
+template<typename Derived> class RefBase
+ : public MapBase<Derived>
+{
+  typedef typename internal::traits<Derived>::PlainObjectType PlainObjectType;
+  typedef typename internal::traits<Derived>::StrideType StrideType;
+
+public:
+
+  typedef MapBase<Derived> Base;
+  EIGEN_DENSE_PUBLIC_INTERFACE(RefBase)
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index innerStride() const
+  {
+    return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index outerStride() const
+  {
+    return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
+         : IsVectorAtCompileTime ? this->size()
+         : int(Flags)&RowMajorBit ? this->cols()
+         : this->rows();
+  }
+
+  EIGEN_DEVICE_FUNC RefBase()
+    : Base(0,RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime),
+      // Stride<> does not allow default ctor for Dynamic strides, so let' initialize it with dummy values:
+      m_stride(StrideType::OuterStrideAtCompileTime==Dynamic?0:StrideType::OuterStrideAtCompileTime,
+               StrideType::InnerStrideAtCompileTime==Dynamic?0:StrideType::InnerStrideAtCompileTime)
+  {}
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(RefBase)
+
+protected:
+
+  typedef Stride<StrideType::OuterStrideAtCompileTime,StrideType::InnerStrideAtCompileTime> StrideBase;
+
+  // Resolves inner stride if default 0.
+  static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index resolveInnerStride(Index inner) {
+    return inner == 0 ? 1 : inner;
+  }
+
+  // Resolves outer stride if default 0.
+  static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index resolveOuterStride(Index inner, Index outer, Index rows, Index cols, bool isVectorAtCompileTime, bool isRowMajor) {
+    return outer == 0 ? isVectorAtCompileTime ? inner * rows * cols : isRowMajor ? inner * cols : inner * rows : outer;
+  }
+
+  // Returns true if construction is valid, false if there is a stride mismatch,
+  // and fails if there is a size mismatch.
+  template<typename Expression>
+  EIGEN_DEVICE_FUNC bool construct(Expression& expr)
+  {
+    // Check matrix sizes.  If this is a compile-time vector, we do allow
+    // implicitly transposing.
+    EIGEN_STATIC_ASSERT(
+      EIGEN_PREDICATE_SAME_MATRIX_SIZE(PlainObjectType, Expression)
+      // If it is a vector, the transpose sizes might match.
+      || ( PlainObjectType::IsVectorAtCompileTime
+            && ((int(PlainObjectType::RowsAtCompileTime)==Eigen::Dynamic
+              || int(Expression::ColsAtCompileTime)==Eigen::Dynamic
+              || int(PlainObjectType::RowsAtCompileTime)==int(Expression::ColsAtCompileTime))
+            &&  (int(PlainObjectType::ColsAtCompileTime)==Eigen::Dynamic
+              || int(Expression::RowsAtCompileTime)==Eigen::Dynamic
+              || int(PlainObjectType::ColsAtCompileTime)==int(Expression::RowsAtCompileTime)))),
+      YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES
+    )
+
+    // Determine runtime rows and columns.
+    Index rows = expr.rows();
+    Index cols = expr.cols();
+    if(PlainObjectType::RowsAtCompileTime==1)
+    {
+      eigen_assert(expr.rows()==1 || expr.cols()==1);
+      rows = 1;
+      cols = expr.size();
+    }
+    else if(PlainObjectType::ColsAtCompileTime==1)
+    {
+      eigen_assert(expr.rows()==1 || expr.cols()==1);
+      rows = expr.size();
+      cols = 1;
+    }
+    // Verify that the sizes are valid.
+    eigen_assert(
+      (PlainObjectType::RowsAtCompileTime == Dynamic) || (PlainObjectType::RowsAtCompileTime == rows));
+    eigen_assert(
+      (PlainObjectType::ColsAtCompileTime == Dynamic) || (PlainObjectType::ColsAtCompileTime == cols));
+
+
+    // If this is a vector, we might be transposing, which means that stride should swap.
+    const bool transpose = PlainObjectType::IsVectorAtCompileTime && (rows != expr.rows());
+    // If the storage format differs, we also need to swap the stride.
+    const bool row_major = ((PlainObjectType::Flags)&RowMajorBit) != 0;
+    const bool expr_row_major = (Expression::Flags&RowMajorBit) != 0;
+    const bool storage_differs =  (row_major != expr_row_major);
+
+    const bool swap_stride = (transpose != storage_differs);
+
+    // Determine expr's actual strides, resolving any defaults if zero.
+    const Index expr_inner_actual = resolveInnerStride(expr.innerStride());
+    const Index expr_outer_actual = resolveOuterStride(expr_inner_actual,
+                                                       expr.outerStride(),
+                                                       expr.rows(),
+                                                       expr.cols(),
+                                                       Expression::IsVectorAtCompileTime != 0,
+                                                       expr_row_major);
+
+    // If this is a column-major row vector or row-major column vector, the inner-stride
+    // is arbitrary, so set it to either the compile-time inner stride or 1.
+    const bool row_vector = (rows == 1);
+    const bool col_vector = (cols == 1);
+    const Index inner_stride =
+        ( (!row_major && row_vector) || (row_major && col_vector) ) ?
+            ( StrideType::InnerStrideAtCompileTime > 0 ? Index(StrideType::InnerStrideAtCompileTime) : 1)
+            : swap_stride ? expr_outer_actual : expr_inner_actual;
+
+    // If this is a column-major column vector or row-major row vector, the outer-stride
+    // is arbitrary, so set it to either the compile-time outer stride or vector size.
+    const Index outer_stride =
+      ( (!row_major && col_vector) || (row_major && row_vector) ) ?
+          ( StrideType::OuterStrideAtCompileTime > 0 ? Index(StrideType::OuterStrideAtCompileTime) : rows * cols * inner_stride)
+          : swap_stride ? expr_inner_actual : expr_outer_actual;
+
+    // Check if given inner/outer strides are compatible with compile-time strides.
+    const bool inner_valid = (StrideType::InnerStrideAtCompileTime == Dynamic)
+        || (resolveInnerStride(Index(StrideType::InnerStrideAtCompileTime)) == inner_stride);
+    if (!inner_valid) {
+      return false;
+    }
+
+    const bool outer_valid = (StrideType::OuterStrideAtCompileTime == Dynamic)
+        || (resolveOuterStride(
+              inner_stride,
+              Index(StrideType::OuterStrideAtCompileTime),
+              rows, cols, PlainObjectType::IsVectorAtCompileTime != 0,
+              row_major)
+            == outer_stride);
+    if (!outer_valid) {
+      return false;
+    }
+
+    ::new (static_cast<Base*>(this)) Base(expr.data(), rows, cols);
+    ::new (&m_stride) StrideBase(
+      (StrideType::OuterStrideAtCompileTime == 0) ? 0 : outer_stride,
+      (StrideType::InnerStrideAtCompileTime == 0) ? 0 : inner_stride );
+    return true;
+  }
+
+  StrideBase m_stride;
+};
+
+/** \class Ref
+  * \ingroup Core_Module
+  *
+  * \brief A matrix or vector expression mapping an existing expression
+  *
+  * \tparam PlainObjectType the equivalent matrix type of the mapped data
+  * \tparam Options specifies the pointer alignment in bytes. It can be: \c #Aligned128, , \c #Aligned64, \c #Aligned32, \c #Aligned16, \c #Aligned8 or \c #Unaligned.
+  *                 The default is \c #Unaligned.
+  * \tparam StrideType optionally specifies strides. By default, Ref implies a contiguous storage along the inner dimension (inner stride==1),
+  *                   but accepts a variable outer stride (leading dimension).
+  *                   This can be overridden by specifying strides.
+  *                   The type passed here must be a specialization of the Stride template, see examples below.
+  *
+  * This class provides a way to write non-template functions taking Eigen objects as parameters while limiting the number of copies.
+  * A Ref<> object can represent either a const expression or a l-value:
+  * \code
+  * // in-out argument:
+  * void foo1(Ref<VectorXf> x);
+  *
+  * // read-only const argument:
+  * void foo2(const Ref<const VectorXf>& x);
+  * \endcode
+  *
+  * In the in-out case, the input argument must satisfy the constraints of the actual Ref<> type, otherwise a compilation issue will be triggered.
+  * By default, a Ref<VectorXf> can reference any dense vector expression of float having a contiguous memory layout.
+  * Likewise, a Ref<MatrixXf> can reference any column-major dense matrix expression of float whose column's elements are contiguously stored with
+  * the possibility to have a constant space in-between each column, i.e. the inner stride must be equal to 1, but the outer stride (or leading dimension)
+  * can be greater than the number of rows.
+  *
+  * In the const case, if the input expression does not match the above requirement, then it is evaluated into a temporary before being passed to the function.
+  * Here are some examples:
+  * \code
+  * MatrixXf A;
+  * VectorXf a;
+  * foo1(a.head());             // OK
+  * foo1(A.col());              // OK
+  * foo1(A.row());              // Compilation error because here innerstride!=1
+  * foo2(A.row());              // Compilation error because A.row() is a 1xN object while foo2 is expecting a Nx1 object
+  * foo2(A.row().transpose());  // The row is copied into a contiguous temporary
+  * foo2(2*a);                  // The expression is evaluated into a temporary
+  * foo2(A.col().segment(2,4)); // No temporary
+  * \endcode
+  *
+  * The range of inputs that can be referenced without temporary can be enlarged using the last two template parameters.
+  * Here is an example accepting an innerstride!=1:
+  * \code
+  * // in-out argument:
+  * void foo3(Ref<VectorXf,0,InnerStride<> > x);
+  * foo3(A.row());              // OK
+  * \endcode
+  * The downside here is that the function foo3 might be significantly slower than foo1 because it won't be able to exploit vectorization, and will involve more
+  * expensive address computations even if the input is contiguously stored in memory. To overcome this issue, one might propose to overload internally calling a
+  * template function, e.g.:
+  * \code
+  * // in the .h:
+  * void foo(const Ref<MatrixXf>& A);
+  * void foo(const Ref<MatrixXf,0,Stride<> >& A);
+  *
+  * // in the .cpp:
+  * template<typename TypeOfA> void foo_impl(const TypeOfA& A) {
+  *     ... // crazy code goes here
+  * }
+  * void foo(const Ref<MatrixXf>& A) { foo_impl(A); }
+  * void foo(const Ref<MatrixXf,0,Stride<> >& A) { foo_impl(A); }
+  * \endcode
+  *
+  * See also the following stackoverflow questions for further references:
+  *  - <a href="http://stackoverflow.com/questions/21132538/correct-usage-of-the-eigenref-class">Correct usage of the Eigen::Ref<> class</a>
+  *
+  * \sa PlainObjectBase::Map(), \ref TopicStorageOrders
+  */
+template<typename PlainObjectType, int Options, typename StrideType> class Ref
+  : public RefBase<Ref<PlainObjectType, Options, StrideType> >
+{
+  private:
+    typedef internal::traits<Ref> Traits;
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(const PlainObjectBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0);
+  public:
+
+    typedef RefBase<Ref> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Ref)
+
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(PlainObjectBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      // Construction must pass since we will not create temprary storage in the non-const case.
+      const bool success = Base::construct(expr.derived());
+      EIGEN_UNUSED_VARIABLE(success)
+      eigen_assert(success);
+    }
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(const DenseBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::MatchAtCompileTime),Derived>::type* = 0)
+    #else
+    /** Implicit constructor from any dense expression */
+    template<typename Derived>
+    inline Ref(DenseBase<Derived>& expr)
+    #endif
+    {
+      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      EIGEN_STATIC_ASSERT(!Derived::IsPlainObjectBase,THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      // Construction must pass since we will not create temporary storage in the non-const case.
+      const bool success = Base::construct(expr.const_cast_derived());
+      EIGEN_UNUSED_VARIABLE(success)
+      eigen_assert(success);
+    }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Ref)
+
+};
+
+// this is the const ref version
+template<typename TPlainObjectType, int Options, typename StrideType> class Ref<const TPlainObjectType, Options, StrideType>
+  : public RefBase<Ref<const TPlainObjectType, Options, StrideType> >
+{
+    typedef internal::traits<Ref> Traits;
+  public:
+
+    typedef RefBase<Ref> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Ref)
+
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC inline Ref(const DenseBase<Derived>& expr,
+                                 typename internal::enable_if<bool(Traits::template match<Derived>::ScalarTypeMatch),Derived>::type* = 0)
+    {
+//      std::cout << match_helper<Derived>::HasDirectAccess << "," << match_helper<Derived>::OuterStrideMatch << "," << match_helper<Derived>::InnerStrideMatch << "\n";
+//      std::cout << int(StrideType::OuterStrideAtCompileTime) << " - " << int(Derived::OuterStrideAtCompileTime) << "\n";
+//      std::cout << int(StrideType::InnerStrideAtCompileTime) << " - " << int(Derived::InnerStrideAtCompileTime) << "\n";
+      construct(expr.derived(), typename Traits::template match<Derived>::type());
+    }
+
+    EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) {
+      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
+    }
+
+    template<typename OtherRef>
+    EIGEN_DEVICE_FUNC inline Ref(const RefBase<OtherRef>& other) {
+      construct(other.derived(), typename Traits::template match<OtherRef>::type());
+    }
+
+  protected:
+
+    template<typename Expression>
+    EIGEN_DEVICE_FUNC void construct(const Expression& expr,internal::true_type)
+    {
+      // Check if we can use the underlying expr's storage directly, otherwise call the copy version.
+      if (!Base::construct(expr)) {
+        construct(expr, internal::false_type());
+      }
+    }
+
+    template<typename Expression>
+    EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type)
+    {
+      internal::call_assignment_no_alias(m_object,expr,internal::assign_op<Scalar,Scalar>());
+      Base::construct(m_object);
+    }
+
+  protected:
+    TPlainObjectType m_object;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_REF_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Replicate.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Replicate.h
new file mode 100644
index 00000000..ab5be7e6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Replicate.h
@@ -0,0 +1,142 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REPLICATE_H
+#define EIGEN_REPLICATE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename MatrixType,int RowFactor,int ColFactor>
+struct traits<Replicate<MatrixType,RowFactor,ColFactor> >
+ : traits<MatrixType>
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename traits<MatrixType>::XprKind XprKind;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    RowsAtCompileTime = RowFactor==Dynamic || int(MatrixType::RowsAtCompileTime)==Dynamic
+                      ? Dynamic
+                      : RowFactor * MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = ColFactor==Dynamic || int(MatrixType::ColsAtCompileTime)==Dynamic
+                      ? Dynamic
+                      : ColFactor * MatrixType::ColsAtCompileTime,
+   //FIXME we don't propagate the max sizes !!!
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    IsRowMajor = MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1 ? 1
+               : MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1 ? 0
+               : (MatrixType::Flags & RowMajorBit) ? 1 : 0,
+
+    // FIXME enable DirectAccess with negative strides?
+    Flags = IsRowMajor ? RowMajorBit : 0
+  };
+};
+}
+
+/**
+  * \class Replicate
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the multiple replication of a matrix or vector
+  *
+  * \tparam MatrixType the type of the object we are replicating
+  * \tparam RowFactor number of repetitions at compile time along the vertical direction, can be Dynamic.
+  * \tparam ColFactor number of repetitions at compile time along the horizontal direction, can be Dynamic.
+  *
+  * This class represents an expression of the multiple replication of a matrix or vector.
+  * It is the return type of DenseBase::replicate() and most of the time
+  * this is the only way it is used.
+  *
+  * \sa DenseBase::replicate()
+  */
+template<typename MatrixType,int RowFactor,int ColFactor> class Replicate
+  : public internal::dense_xpr_base< Replicate<MatrixType,RowFactor,ColFactor> >::type
+{
+    typedef typename internal::traits<Replicate>::MatrixTypeNested MatrixTypeNested;
+    typedef typename internal::traits<Replicate>::_MatrixTypeNested _MatrixTypeNested;
+  public:
+
+    typedef typename internal::dense_xpr_base<Replicate>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Replicate)
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+    template<typename OriginalMatrixType>
+    EIGEN_DEVICE_FUNC
+    inline explicit Replicate(const OriginalMatrixType& matrix)
+      : m_matrix(matrix), m_rowFactor(RowFactor), m_colFactor(ColFactor)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<typename internal::remove_const<MatrixType>::type,OriginalMatrixType>::value),
+                          THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE)
+      eigen_assert(RowFactor!=Dynamic && ColFactor!=Dynamic);
+    }
+
+    template<typename OriginalMatrixType>
+    EIGEN_DEVICE_FUNC
+    inline Replicate(const OriginalMatrixType& matrix, Index rowFactor, Index colFactor)
+      : m_matrix(matrix), m_rowFactor(rowFactor), m_colFactor(colFactor)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<typename internal::remove_const<MatrixType>::type,OriginalMatrixType>::value),
+                          THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE)
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const { return m_matrix.rows() * m_rowFactor.value(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const { return m_matrix.cols() * m_colFactor.value(); }
+
+    EIGEN_DEVICE_FUNC
+    const _MatrixTypeNested& nestedExpression() const
+    {
+      return m_matrix;
+    }
+
+  protected:
+    MatrixTypeNested m_matrix;
+    const internal::variable_if_dynamic<Index, RowFactor> m_rowFactor;
+    const internal::variable_if_dynamic<Index, ColFactor> m_colFactor;
+};
+
+/**
+  * \return an expression of the replication of \c *this
+  *
+  * Example: \include MatrixBase_replicate.cpp
+  * Output: \verbinclude MatrixBase_replicate.out
+  *
+  * \sa VectorwiseOp::replicate(), DenseBase::replicate(Index,Index), class Replicate
+  */
+template<typename Derived>
+template<int RowFactor, int ColFactor>
+EIGEN_DEVICE_FUNC const Replicate<Derived,RowFactor,ColFactor>
+DenseBase<Derived>::replicate() const
+{
+  return Replicate<Derived,RowFactor,ColFactor>(derived());
+}
+
+/**
+  * \return an expression of the replication of each column (or row) of \c *this
+  *
+  * Example: \include DirectionWise_replicate_int.cpp
+  * Output: \verbinclude DirectionWise_replicate_int.out
+  *
+  * \sa VectorwiseOp::replicate(), DenseBase::replicate(), class Replicate
+  */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC const typename VectorwiseOp<ExpressionType,Direction>::ReplicateReturnType
+VectorwiseOp<ExpressionType,Direction>::replicate(Index factor) const
+{
+  return typename VectorwiseOp<ExpressionType,Direction>::ReplicateReturnType
+          (_expression(),Direction==Vertical?factor:1,Direction==Horizontal?factor:1);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REPLICATE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Reshaped.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Reshaped.h
new file mode 100644
index 00000000..52de73b6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Reshaped.h
@@ -0,0 +1,454 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2014 yoco <peter.xiau@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_RESHAPED_H
+#define EIGEN_RESHAPED_H
+
+namespace Eigen {
+
+/** \class Reshaped
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a fixed-size or dynamic-size reshape
+  *
+  * \tparam XprType the type of the expression in which we are taking a reshape
+  * \tparam Rows the number of rows of the reshape we are taking at compile time (optional)
+  * \tparam Cols the number of columns of the reshape we are taking at compile time (optional)
+  * \tparam Order can be ColMajor or RowMajor, default is ColMajor.
+  *
+  * This class represents an expression of either a fixed-size or dynamic-size reshape.
+  * It is the return type of DenseBase::reshaped(NRowsType,NColsType) and
+  * most of the time this is the only way it is used.
+  *
+  * However, in C++98, if you want to directly maniputate reshaped expressions,
+  * for instance if you want to write a function returning such an expression, you
+  * will need to use this class. In C++11, it is advised to use the \em auto
+  * keyword for such use cases.
+  *
+  * Here is an example illustrating the dynamic case:
+  * \include class_Reshaped.cpp
+  * Output: \verbinclude class_Reshaped.out
+  *
+  * Here is an example illustrating the fixed-size case:
+  * \include class_FixedReshaped.cpp
+  * Output: \verbinclude class_FixedReshaped.out
+  *
+  * \sa DenseBase::reshaped(NRowsType,NColsType)
+  */
+
+namespace internal {
+
+template<typename XprType, int Rows, int Cols, int Order>
+struct traits<Reshaped<XprType, Rows, Cols, Order> > : traits<XprType>
+{
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename traits<XprType>::StorageKind StorageKind;
+  typedef typename traits<XprType>::XprKind XprKind;
+  enum{
+    MatrixRows = traits<XprType>::RowsAtCompileTime,
+    MatrixCols = traits<XprType>::ColsAtCompileTime,
+    RowsAtCompileTime = Rows,
+    ColsAtCompileTime = Cols,
+    MaxRowsAtCompileTime = Rows,
+    MaxColsAtCompileTime = Cols,
+    XpxStorageOrder = ((int(traits<XprType>::Flags) & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor,
+    ReshapedStorageOrder = (RowsAtCompileTime == 1 && ColsAtCompileTime != 1) ? RowMajor
+                         : (ColsAtCompileTime == 1 && RowsAtCompileTime != 1) ? ColMajor
+                         : XpxStorageOrder,
+    HasSameStorageOrderAsXprType = (ReshapedStorageOrder == XpxStorageOrder),
+    InnerSize = (ReshapedStorageOrder==int(RowMajor)) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+    InnerStrideAtCompileTime = HasSameStorageOrderAsXprType
+                             ? int(inner_stride_at_compile_time<XprType>::ret)
+                             : Dynamic,
+    OuterStrideAtCompileTime = Dynamic,
+
+    HasDirectAccess = internal::has_direct_access<XprType>::ret
+                    && (Order==int(XpxStorageOrder))
+                    && ((evaluator<XprType>::Flags&LinearAccessBit)==LinearAccessBit),
+
+    MaskPacketAccessBit = (InnerSize == Dynamic || (InnerSize % packet_traits<Scalar>::size) == 0)
+                       && (InnerStrideAtCompileTime == 1)
+                        ? PacketAccessBit : 0,
+    //MaskAlignedBit = ((OuterStrideAtCompileTime!=Dynamic) && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % 16) == 0)) ? AlignedBit : 0,
+    FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
+    FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
+    FlagsRowMajorBit = (ReshapedStorageOrder==int(RowMajor)) ? RowMajorBit : 0,
+    FlagsDirectAccessBit = HasDirectAccess ? DirectAccessBit : 0,
+    Flags0 = traits<XprType>::Flags & ( (HereditaryBits & ~RowMajorBit) | MaskPacketAccessBit),
+
+    Flags = (Flags0 | FlagsLinearAccessBit | FlagsLvalueBit | FlagsRowMajorBit | FlagsDirectAccessBit)
+  };
+};
+
+template<typename XprType, int Rows, int Cols, int Order, bool HasDirectAccess> class ReshapedImpl_dense;
+
+} // end namespace internal
+
+template<typename XprType, int Rows, int Cols, int Order, typename StorageKind> class ReshapedImpl;
+
+template<typename XprType, int Rows, int Cols, int Order> class Reshaped
+  : public ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind>
+{
+    typedef ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind> Impl;
+  public:
+    //typedef typename Impl::Base Base;
+    typedef Impl Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Reshaped)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reshaped)
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline Reshaped(XprType& xpr)
+      : Impl(xpr)
+    {
+      EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
+      eigen_assert(Rows * Cols == xpr.rows() * xpr.cols());
+    }
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline Reshaped(XprType& xpr,
+          Index reshapeRows, Index reshapeCols)
+      : Impl(xpr, reshapeRows, reshapeCols)
+    {
+      eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==reshapeRows)
+          && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==reshapeCols));
+      eigen_assert(reshapeRows * reshapeCols == xpr.rows() * xpr.cols());
+    }
+};
+
+// The generic default implementation for dense reshape simply forward to the internal::ReshapedImpl_dense
+// that must be specialized for direct and non-direct access...
+template<typename XprType, int Rows, int Cols, int Order>
+class ReshapedImpl<XprType, Rows, Cols, Order, Dense>
+  : public internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,internal::traits<Reshaped<XprType,Rows,Cols,Order> >::HasDirectAccess>
+{
+    typedef internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,internal::traits<Reshaped<XprType,Rows,Cols,Order> >::HasDirectAccess> Impl;
+  public:
+    typedef Impl Base;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl)
+    EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr) : Impl(xpr) {}
+    EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr, Index reshapeRows, Index reshapeCols)
+      : Impl(xpr, reshapeRows, reshapeCols) {}
+};
+
+namespace internal {
+
+/** \internal Internal implementation of dense Reshaped in the general case. */
+template<typename XprType, int Rows, int Cols, int Order>
+class ReshapedImpl_dense<XprType,Rows,Cols,Order,false>
+  : public internal::dense_xpr_base<Reshaped<XprType, Rows, Cols, Order> >::type
+{
+    typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType;
+  public:
+
+    typedef typename internal::dense_xpr_base<ReshapedType>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense)
+
+    typedef typename internal::ref_selector<XprType>::non_const_type MatrixTypeNested;
+    typedef typename internal::remove_all<XprType>::type NestedExpression;
+
+    class InnerIterator;
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline ReshapedImpl_dense(XprType& xpr)
+      : m_xpr(xpr), m_rows(Rows), m_cols(Cols)
+    {}
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline ReshapedImpl_dense(XprType& xpr, Index nRows, Index nCols)
+      : m_xpr(xpr), m_rows(nRows), m_cols(nCols)
+    {}
+
+    EIGEN_DEVICE_FUNC Index rows() const { return m_rows; }
+    EIGEN_DEVICE_FUNC Index cols() const { return m_cols; }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \sa MapBase::data() */
+    EIGEN_DEVICE_FUNC inline const Scalar* data() const;
+    EIGEN_DEVICE_FUNC inline Index innerStride() const;
+    EIGEN_DEVICE_FUNC inline Index outerStride() const;
+    #endif
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<XprType>::type&
+    nestedExpression() const { return m_xpr; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC
+    typename internal::remove_reference<XprType>::type&
+    nestedExpression() { return m_xpr; }
+
+  protected:
+
+    MatrixTypeNested m_xpr;
+    const internal::variable_if_dynamic<Index, Rows> m_rows;
+    const internal::variable_if_dynamic<Index, Cols> m_cols;
+};
+
+
+/** \internal Internal implementation of dense Reshaped in the direct access case. */
+template<typename XprType, int Rows, int Cols, int Order>
+class ReshapedImpl_dense<XprType, Rows, Cols, Order, true>
+  : public MapBase<Reshaped<XprType, Rows, Cols, Order> >
+{
+    typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType;
+    typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+  public:
+
+    typedef MapBase<ReshapedType> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense)
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline ReshapedImpl_dense(XprType& xpr)
+      : Base(xpr.data()), m_xpr(xpr)
+    {}
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC
+    inline ReshapedImpl_dense(XprType& xpr, Index nRows, Index nCols)
+      : Base(xpr.data(), nRows, nCols),
+        m_xpr(xpr)
+    {}
+
+    EIGEN_DEVICE_FUNC
+    const typename internal::remove_all<XprTypeNested>::type& nestedExpression() const
+    {
+      return m_xpr;
+    }
+
+    EIGEN_DEVICE_FUNC
+    XprType& nestedExpression() { return m_xpr; }
+
+    /** \sa MapBase::innerStride() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const
+    {
+      return m_xpr.innerStride();
+    }
+
+    /** \sa MapBase::outerStride() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const
+    {
+      return ((Flags&RowMajorBit)==RowMajorBit) ? this->cols() : this->rows();
+    }
+
+  protected:
+
+    XprTypeNested m_xpr;
+};
+
+// Evaluators
+template<typename ArgType, int Rows, int Cols, int Order, bool HasDirectAccess> struct reshaped_evaluator;
+
+template<typename ArgType, int Rows, int Cols, int Order>
+struct evaluator<Reshaped<ArgType, Rows, Cols, Order> >
+  : reshaped_evaluator<ArgType, Rows, Cols, Order, traits<Reshaped<ArgType,Rows,Cols,Order> >::HasDirectAccess>
+{
+  typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
+  typedef typename XprType::Scalar Scalar;
+  // TODO: should check for smaller packet types
+  typedef typename packet_traits<Scalar>::type PacketScalar;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    HasDirectAccess = traits<XprType>::HasDirectAccess,
+
+//     RowsAtCompileTime = traits<XprType>::RowsAtCompileTime,
+//     ColsAtCompileTime = traits<XprType>::ColsAtCompileTime,
+//     MaxRowsAtCompileTime = traits<XprType>::MaxRowsAtCompileTime,
+//     MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime,
+//
+//     InnerStrideAtCompileTime = traits<XprType>::HasSameStorageOrderAsXprType
+//                              ? int(inner_stride_at_compile_time<ArgType>::ret)
+//                              : Dynamic,
+//     OuterStrideAtCompileTime = Dynamic,
+
+    FlagsLinearAccessBit = (traits<XprType>::RowsAtCompileTime == 1 || traits<XprType>::ColsAtCompileTime == 1 || HasDirectAccess) ? LinearAccessBit : 0,
+    FlagsRowMajorBit = (traits<XprType>::ReshapedStorageOrder==int(RowMajor)) ? RowMajorBit : 0,
+    FlagsDirectAccessBit =  HasDirectAccess ? DirectAccessBit : 0,
+    Flags0 = evaluator<ArgType>::Flags & (HereditaryBits & ~RowMajorBit),
+    Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit | FlagsDirectAccessBit,
+
+    PacketAlignment = unpacket_traits<PacketScalar>::alignment,
+    Alignment = evaluator<ArgType>::Alignment
+  };
+  typedef reshaped_evaluator<ArgType, Rows, Cols, Order, HasDirectAccess> reshaped_evaluator_type;
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : reshaped_evaluator_type(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+};
+
+template<typename ArgType, int Rows, int Cols, int Order>
+struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ false>
+  : evaluator_base<Reshaped<ArgType, Rows, Cols, Order> >
+{
+  typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
+
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost /* TODO + cost of index computations */,
+
+    Flags = (evaluator<ArgType>::Flags & (HereditaryBits /*| LinearAccessBit | DirectAccessBit*/)),
+
+    Alignment = 0
+  };
+
+  EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_xpr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  typedef std::pair<Index, Index> RowCol;
+
+  inline RowCol index_remap(Index rowId, Index colId) const
+  {
+    if(Order==ColMajor)
+    {
+      const Index nth_elem_idx = colId * m_xpr.rows() + rowId;
+      return RowCol(nth_elem_idx % m_xpr.nestedExpression().rows(),
+                    nth_elem_idx / m_xpr.nestedExpression().rows());
+    }
+    else
+    {
+      const Index nth_elem_idx = colId + rowId * m_xpr.cols();
+      return RowCol(nth_elem_idx / m_xpr.nestedExpression().cols(),
+                    nth_elem_idx % m_xpr.nestedExpression().cols());
+    }
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline Scalar& coeffRef(Index rowId, Index colId)
+  {
+    EIGEN_STATIC_ASSERT_LVALUE(XprType)
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.coeffRef(row_col.first, row_col.second);
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline const Scalar& coeffRef(Index rowId, Index colId) const
+  {
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.coeffRef(row_col.first, row_col.second);
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
+  {
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.coeff(row_col.first, row_col.second);
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline Scalar& coeffRef(Index index)
+  {
+    EIGEN_STATIC_ASSERT_LVALUE(XprType)
+    const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
+                                       Rows == 1 ? index : 0);
+    return m_argImpl.coeffRef(row_col.first, row_col.second);
+
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline const Scalar& coeffRef(Index index) const
+  {
+    const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
+                                       Rows == 1 ? index : 0);
+    return m_argImpl.coeffRef(row_col.first, row_col.second);
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline const CoeffReturnType coeff(Index index) const
+  {
+    const RowCol row_col = index_remap(Rows == 1 ? 0 : index,
+                                       Rows == 1 ? index : 0);
+    return m_argImpl.coeff(row_col.first, row_col.second);
+  }
+#if 0
+  EIGEN_DEVICE_FUNC
+  template<int LoadMode>
+  inline PacketScalar packet(Index rowId, Index colId) const
+  {
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second);
+
+  }
+
+  template<int LoadMode>
+  EIGEN_DEVICE_FUNC
+  inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
+  {
+    const RowCol row_col = index_remap(rowId, colId);
+    m_argImpl.const_cast_derived().template writePacket<Unaligned>
+            (row_col.first, row_col.second, val);
+  }
+
+  template<int LoadMode>
+  EIGEN_DEVICE_FUNC
+  inline PacketScalar packet(Index index) const
+  {
+    const RowCol row_col = index_remap(RowsAtCompileTime == 1 ? 0 : index,
+                                        RowsAtCompileTime == 1 ? index : 0);
+    return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second);
+  }
+
+  template<int LoadMode>
+  EIGEN_DEVICE_FUNC
+  inline void writePacket(Index index, const PacketScalar& val)
+  {
+    const RowCol row_col = index_remap(RowsAtCompileTime == 1 ? 0 : index,
+                                        RowsAtCompileTime == 1 ? index : 0);
+    return m_argImpl.template packet<Unaligned>(row_col.first, row_col.second, val);
+  }
+#endif
+protected:
+
+  evaluator<ArgType> m_argImpl;
+  const XprType& m_xpr;
+
+};
+
+template<typename ArgType, int Rows, int Cols, int Order>
+struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ true>
+: mapbase_evaluator<Reshaped<ArgType, Rows, Cols, Order>,
+                      typename Reshaped<ArgType, Rows, Cols, Order>::PlainObject>
+{
+  typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
+  typedef typename XprType::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr)
+    : mapbase_evaluator<XprType, typename XprType::PlainObject>(xpr)
+  {
+    // TODO: for the 3.4 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime
+    eigen_assert(((internal::UIntPtr(xpr.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned");
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_RESHAPED_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/ReturnByValue.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ReturnByValue.h
new file mode 100644
index 00000000..4dad13ea
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/ReturnByValue.h
@@ -0,0 +1,119 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_RETURNBYVALUE_H
+#define EIGEN_RETURNBYVALUE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Derived>
+struct traits<ReturnByValue<Derived> >
+  : public traits<typename traits<Derived>::ReturnType>
+{
+  enum {
+    // We're disabling the DirectAccess because e.g. the constructor of
+    // the Block-with-DirectAccess expression requires to have a coeffRef method.
+    // Also, we don't want to have to implement the stride stuff.
+    Flags = (traits<typename traits<Derived>::ReturnType>::Flags
+             | EvalBeforeNestingBit) & ~DirectAccessBit
+  };
+};
+
+/* The ReturnByValue object doesn't even have a coeff() method.
+ * So the only way that nesting it in an expression can work, is by evaluating it into a plain matrix.
+ * So internal::nested always gives the plain return matrix type.
+ *
+ * FIXME: I don't understand why we need this specialization: isn't this taken care of by the EvalBeforeNestingBit ??
+ * Answer: EvalBeforeNestingBit should be deprecated since we have the evaluators
+ */
+template<typename Derived,int n,typename PlainObject>
+struct nested_eval<ReturnByValue<Derived>, n, PlainObject>
+{
+  typedef typename traits<Derived>::ReturnType type;
+};
+
+} // end namespace internal
+
+/** \class ReturnByValue
+  * \ingroup Core_Module
+  *
+  */
+template<typename Derived> class ReturnByValue
+  : public internal::dense_xpr_base< ReturnByValue<Derived> >::type, internal::no_assignment_operator
+{
+  public:
+    typedef typename internal::traits<Derived>::ReturnType ReturnType;
+
+    typedef typename internal::dense_xpr_base<ReturnByValue>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue)
+
+    template<typename Dest>
+    EIGEN_DEVICE_FUNC
+    inline void evalTo(Dest& dst) const
+    { static_cast<const Derived*>(this)->evalTo(dst); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return static_cast<const Derived*>(this)->rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return static_cast<const Derived*>(this)->cols(); }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+#define Unusable YOU_ARE_TRYING_TO_ACCESS_A_SINGLE_COEFFICIENT_IN_A_SPECIAL_EXPRESSION_WHERE_THAT_IS_NOT_ALLOWED_BECAUSE_THAT_WOULD_BE_INEFFICIENT
+    class Unusable{
+      Unusable(const Unusable&) {}
+      Unusable& operator=(const Unusable&) {return *this;}
+    };
+    const Unusable& coeff(Index) const { return *reinterpret_cast<const Unusable*>(this); }
+    const Unusable& coeff(Index,Index) const { return *reinterpret_cast<const Unusable*>(this); }
+    Unusable& coeffRef(Index) { return *reinterpret_cast<Unusable*>(this); }
+    Unusable& coeffRef(Index,Index) { return *reinterpret_cast<Unusable*>(this); }
+#undef Unusable
+#endif
+};
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Derived& DenseBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  other.evalTo(derived());
+  return derived();
+}
+
+namespace internal {
+
+// Expression is evaluated in a temporary; default implementation of Assignment is bypassed so that
+// when a ReturnByValue expression is assigned, the evaluator is not constructed.
+// TODO: Finalize port to new regime; ReturnByValue should not exist in the expression world
+
+template<typename Derived>
+struct evaluator<ReturnByValue<Derived> >
+  : public evaluator<typename internal::traits<Derived>::ReturnType>
+{
+  typedef ReturnByValue<Derived> XprType;
+  typedef typename internal::traits<Derived>::ReturnType PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    xpr.evalTo(m_result);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_RETURNBYVALUE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Reverse.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Reverse.h
new file mode 100644
index 00000000..28cdd76a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Reverse.h
@@ -0,0 +1,217 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Ricard Marxer <email@ricardmarxer.com>
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REVERSE_H
+#define EIGEN_REVERSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatrixType, int Direction>
+struct traits<Reverse<MatrixType, Direction> >
+ : traits<MatrixType>
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename traits<MatrixType>::XprKind XprKind;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    Flags = _MatrixTypeNested::Flags & (RowMajorBit | LvalueBit)
+  };
+};
+
+template<typename PacketType, bool ReversePacket> struct reverse_packet_cond
+{
+  static inline PacketType run(const PacketType& x) { return preverse(x); }
+};
+
+template<typename PacketType> struct reverse_packet_cond<PacketType,false>
+{
+  static inline PacketType run(const PacketType& x) { return x; }
+};
+
+} // end namespace internal
+
+/** \class Reverse
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the reverse of a vector or matrix
+  *
+  * \tparam MatrixType the type of the object of which we are taking the reverse
+  * \tparam Direction defines the direction of the reverse operation, can be Vertical, Horizontal, or BothDirections
+  *
+  * This class represents an expression of the reverse of a vector.
+  * It is the return type of MatrixBase::reverse() and VectorwiseOp::reverse()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::reverse(), VectorwiseOp::reverse()
+  */
+template<typename MatrixType, int Direction> class Reverse
+  : public internal::dense_xpr_base< Reverse<MatrixType, Direction> >::type
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<Reverse>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Reverse)
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+    using Base::IsRowMajor;
+
+  protected:
+    enum {
+      PacketSize = internal::packet_traits<Scalar>::size,
+      IsColMajor = !IsRowMajor,
+      ReverseRow = (Direction == Vertical)   || (Direction == BothDirections),
+      ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
+      OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
+      OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1,
+      ReversePacket = (Direction == BothDirections)
+                    || ((Direction == Vertical)   && IsColMajor)
+                    || ((Direction == Horizontal) && IsRowMajor)
+    };
+    typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> reverse_packet;
+  public:
+
+    EIGEN_DEVICE_FUNC explicit inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { }
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reverse)
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+    EIGEN_DEVICE_FUNC inline Index innerStride() const
+    {
+      return -m_matrix.innerStride();
+    }
+
+    EIGEN_DEVICE_FUNC const typename internal::remove_all<typename MatrixType::Nested>::type&
+    nestedExpression() const
+    {
+      return m_matrix;
+    }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+};
+
+/** \returns an expression of the reverse of *this.
+  *
+  * Example: \include MatrixBase_reverse.cpp
+  * Output: \verbinclude MatrixBase_reverse.out
+  *
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::ReverseReturnType
+DenseBase<Derived>::reverse()
+{
+  return ReverseReturnType(derived());
+}
+
+
+//reverse const overload moved DenseBase.h due to a CUDA compiler bug
+
+/** This is the "in place" version of reverse: it reverses \c *this.
+  *
+  * In most cases it is probably better to simply use the reversed expression
+  * of a matrix. However, when reversing the matrix data itself is really needed,
+  * then this "in-place" version is probably the right choice because it provides
+  * the following additional benefits:
+  *  - less error prone: doing the same operation with .reverse() requires special care:
+  *    \code m = m.reverse().eval(); \endcode
+  *  - this API enables reverse operations without the need for a temporary
+  *  - it allows future optimizations (cache friendliness, etc.)
+  *
+  * \sa VectorwiseOp::reverseInPlace(), reverse() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void DenseBase<Derived>::reverseInPlace()
+{
+  if(cols()>rows())
+  {
+    Index half = cols()/2;
+    leftCols(half).swap(rightCols(half).reverse());
+    if((cols()%2)==1)
+    {
+      Index half2 = rows()/2;
+      col(half).head(half2).swap(col(half).tail(half2).reverse());
+    }
+  }
+  else
+  {
+    Index half = rows()/2;
+    topRows(half).swap(bottomRows(half).reverse());
+    if((rows()%2)==1)
+    {
+      Index half2 = cols()/2;
+      row(half).head(half2).swap(row(half).tail(half2).reverse());
+    }
+  }
+}
+
+namespace internal {
+
+template<int Direction>
+struct vectorwise_reverse_inplace_impl;
+
+template<>
+struct vectorwise_reverse_inplace_impl<Vertical>
+{
+  template<typename ExpressionType>
+  static void run(ExpressionType &xpr)
+  {
+    const int HalfAtCompileTime = ExpressionType::RowsAtCompileTime==Dynamic?Dynamic:ExpressionType::RowsAtCompileTime/2;
+    Index half = xpr.rows()/2;
+    xpr.topRows(fix<HalfAtCompileTime>(half))
+       .swap(xpr.bottomRows(fix<HalfAtCompileTime>(half)).colwise().reverse());
+  }
+};
+
+template<>
+struct vectorwise_reverse_inplace_impl<Horizontal>
+{
+  template<typename ExpressionType>
+  static void run(ExpressionType &xpr)
+  {
+    const int HalfAtCompileTime = ExpressionType::ColsAtCompileTime==Dynamic?Dynamic:ExpressionType::ColsAtCompileTime/2;
+    Index half = xpr.cols()/2;
+    xpr.leftCols(fix<HalfAtCompileTime>(half))
+       .swap(xpr.rightCols(fix<HalfAtCompileTime>(half)).rowwise().reverse());
+  }
+};
+
+} // end namespace internal
+
+/** This is the "in place" version of VectorwiseOp::reverse: it reverses each column or row of \c *this.
+  *
+  * In most cases it is probably better to simply use the reversed expression
+  * of a matrix. However, when reversing the matrix data itself is really needed,
+  * then this "in-place" version is probably the right choice because it provides
+  * the following additional benefits:
+  *  - less error prone: doing the same operation with .reverse() requires special care:
+  *    \code m = m.reverse().eval(); \endcode
+  *  - this API enables reverse operations without the need for a temporary
+  *
+  * \sa DenseBase::reverseInPlace(), reverse() */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC void VectorwiseOp<ExpressionType,Direction>::reverseInPlace()
+{
+  internal::vectorwise_reverse_inplace_impl<Direction>::run(m_matrix);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REVERSE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Select.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Select.h
new file mode 100644
index 00000000..7c86bf87
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Select.h
@@ -0,0 +1,164 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELECT_H
+#define EIGEN_SELECT_H
+
+namespace Eigen {
+
+/** \class Select
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a coefficient wise version of the C++ ternary operator ?:
+  *
+  * \param ConditionMatrixType the type of the \em condition expression which must be a boolean matrix
+  * \param ThenMatrixType the type of the \em then expression
+  * \param ElseMatrixType the type of the \em else expression
+  *
+  * This class represents an expression of a coefficient wise version of the C++ ternary operator ?:.
+  * It is the return type of DenseBase::select() and most of the time this is the only way it is used.
+  *
+  * \sa DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const
+  */
+
+namespace internal {
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
+struct traits<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
+ : traits<ThenMatrixType>
+{
+  typedef typename traits<ThenMatrixType>::Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef typename traits<ThenMatrixType>::XprKind XprKind;
+  typedef typename ConditionMatrixType::Nested ConditionMatrixNested;
+  typedef typename ThenMatrixType::Nested ThenMatrixNested;
+  typedef typename ElseMatrixType::Nested ElseMatrixNested;
+  enum {
+    RowsAtCompileTime = ConditionMatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = ConditionMatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = ConditionMatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = ConditionMatrixType::MaxColsAtCompileTime,
+    Flags = (unsigned int)ThenMatrixType::Flags & ElseMatrixType::Flags & RowMajorBit
+  };
+};
+}
+
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
+class Select : public internal::dense_xpr_base< Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >::type,
+               internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<Select>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Select)
+
+    inline EIGEN_DEVICE_FUNC
+    Select(const ConditionMatrixType& a_conditionMatrix,
+           const ThenMatrixType& a_thenMatrix,
+           const ElseMatrixType& a_elseMatrix)
+      : m_condition(a_conditionMatrix), m_then(a_thenMatrix), m_else(a_elseMatrix)
+    {
+      eigen_assert(m_condition.rows() == m_then.rows() && m_condition.rows() == m_else.rows());
+      eigen_assert(m_condition.cols() == m_then.cols() && m_condition.cols() == m_else.cols());
+    }
+
+    inline EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_condition.rows(); }
+    inline EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_condition.cols(); }
+
+    inline EIGEN_DEVICE_FUNC
+    const Scalar coeff(Index i, Index j) const
+    {
+      if (m_condition.coeff(i,j))
+        return m_then.coeff(i,j);
+      else
+        return m_else.coeff(i,j);
+    }
+
+    inline EIGEN_DEVICE_FUNC
+    const Scalar coeff(Index i) const
+    {
+      if (m_condition.coeff(i))
+        return m_then.coeff(i);
+      else
+        return m_else.coeff(i);
+    }
+
+    inline EIGEN_DEVICE_FUNC const ConditionMatrixType& conditionMatrix() const
+    {
+      return m_condition;
+    }
+
+    inline EIGEN_DEVICE_FUNC const ThenMatrixType& thenMatrix() const
+    {
+      return m_then;
+    }
+
+    inline EIGEN_DEVICE_FUNC const ElseMatrixType& elseMatrix() const
+    {
+      return m_else;
+    }
+
+  protected:
+    typename ConditionMatrixType::Nested m_condition;
+    typename ThenMatrixType::Nested m_then;
+    typename ElseMatrixType::Nested m_else;
+};
+
+
+/** \returns a matrix where each coefficient (i,j) is equal to \a thenMatrix(i,j)
+  * if \c *this(i,j), and \a elseMatrix(i,j) otherwise.
+  *
+  * Example: \include MatrixBase_select.cpp
+  * Output: \verbinclude MatrixBase_select.out
+  *
+  * \sa class Select
+  */
+template<typename Derived>
+template<typename ThenDerived,typename ElseDerived>
+inline EIGEN_DEVICE_FUNC const Select<Derived,ThenDerived,ElseDerived>
+DenseBase<Derived>::select(const DenseBase<ThenDerived>& thenMatrix,
+                            const DenseBase<ElseDerived>& elseMatrix) const
+{
+  return Select<Derived,ThenDerived,ElseDerived>(derived(), thenMatrix.derived(), elseMatrix.derived());
+}
+
+/** Version of DenseBase::select(const DenseBase&, const DenseBase&) with
+  * the \em else expression being a scalar value.
+  *
+  * \sa DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const, class Select
+  */
+template<typename Derived>
+template<typename ThenDerived>
+inline EIGEN_DEVICE_FUNC const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
+DenseBase<Derived>::select(const DenseBase<ThenDerived>& thenMatrix,
+                           const typename ThenDerived::Scalar& elseScalar) const
+{
+  return Select<Derived,ThenDerived,typename ThenDerived::ConstantReturnType>(
+    derived(), thenMatrix.derived(), ThenDerived::Constant(rows(),cols(),elseScalar));
+}
+
+/** Version of DenseBase::select(const DenseBase&, const DenseBase&) with
+  * the \em then expression being a scalar value.
+  *
+  * \sa DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const, class Select
+  */
+template<typename Derived>
+template<typename ElseDerived>
+inline EIGEN_DEVICE_FUNC const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
+DenseBase<Derived>::select(const typename ElseDerived::Scalar& thenScalar,
+                           const DenseBase<ElseDerived>& elseMatrix) const
+{
+  return Select<Derived,typename ElseDerived::ConstantReturnType,ElseDerived>(
+    derived(), ElseDerived::Constant(rows(),cols(),thenScalar), elseMatrix.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELECT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/SelfAdjointView.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/SelfAdjointView.h
new file mode 100644
index 00000000..8ce3b372
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/SelfAdjointView.h
@@ -0,0 +1,365 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINTMATRIX_H
+#define EIGEN_SELFADJOINTMATRIX_H
+
+namespace Eigen {
+
+/** \class SelfAdjointView
+  * \ingroup Core_Module
+  *
+  *
+  * \brief Expression of a selfadjoint matrix from a triangular part of a dense matrix
+  *
+  * \param MatrixType the type of the dense matrix storing the coefficients
+  * \param TriangularPart can be either \c #Lower or \c #Upper
+  *
+  * This class is an expression of a sefladjoint matrix from a triangular part of a matrix
+  * with given dense storage of the coefficients. It is the return type of MatrixBase::selfadjointView()
+  * and most of the time this is the only way that it is used.
+  *
+  * \sa class TriangularBase, MatrixBase::selfadjointView()
+  */
+
+namespace internal {
+template<typename MatrixType, unsigned int UpLo>
+struct traits<SelfAdjointView<MatrixType, UpLo> > : traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+  typedef typename remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
+  typedef MatrixType ExpressionType;
+  typedef typename MatrixType::PlainObject FullMatrixType;
+  enum {
+    Mode = UpLo | SelfAdjoint,
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags =  MatrixTypeNestedCleaned::Flags & (HereditaryBits|FlagsLvalueBit)
+           & (~(PacketAccessBit | DirectAccessBit | LinearAccessBit)) // FIXME these flags should be preserved
+  };
+};
+}
+
+
+template<typename _MatrixType, unsigned int UpLo> class SelfAdjointView
+  : public TriangularBase<SelfAdjointView<_MatrixType, UpLo> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef TriangularBase<SelfAdjointView> Base;
+    typedef typename internal::traits<SelfAdjointView>::MatrixTypeNested MatrixTypeNested;
+    typedef typename internal::traits<SelfAdjointView>::MatrixTypeNestedCleaned MatrixTypeNestedCleaned;
+    typedef MatrixTypeNestedCleaned NestedExpression;
+
+    /** \brief The type of coefficients in this matrix */
+    typedef typename internal::traits<SelfAdjointView>::Scalar Scalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType;
+    typedef SelfAdjointView<typename internal::add_const<MatrixType>::type, UpLo> ConstSelfAdjointView;
+
+    enum {
+      Mode = internal::traits<SelfAdjointView>::Mode,
+      Flags = internal::traits<SelfAdjointView>::Flags,
+      TransposeMode = ((int(Mode) & int(Upper)) ? Lower : 0) | ((int(Mode) & int(Lower)) ? Upper : 0)
+    };
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    EIGEN_DEVICE_FUNC
+    explicit inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
+    {
+      EIGEN_STATIC_ASSERT(UpLo==Lower || UpLo==Upper,SELFADJOINTVIEW_ACCEPTS_UPPER_AND_LOWER_MODE_ONLY);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return m_matrix.outerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return m_matrix.innerStride(); }
+
+    /** \sa MatrixBase::coeff()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar coeff(Index row, Index col) const
+    {
+      Base::check_coordinates_internal(row, col);
+      return m_matrix.coeff(row, col);
+    }
+
+    /** \sa MatrixBase::coeffRef()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(SelfAdjointView);
+      Base::check_coordinates_internal(row, col);
+      return m_matrix.coeffRef(row, col);
+    }
+
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    const MatrixTypeNestedCleaned& _expression() const { return m_matrix; }
+
+    EIGEN_DEVICE_FUNC
+    const MatrixTypeNestedCleaned& nestedExpression() const { return m_matrix; }
+    EIGEN_DEVICE_FUNC
+    MatrixTypeNestedCleaned& nestedExpression() { return m_matrix; }
+
+    /** Efficient triangular matrix times vector/matrix product */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<SelfAdjointView,OtherDerived>
+    operator*(const MatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<SelfAdjointView,OtherDerived>(*this, rhs.derived());
+    }
+
+    /** Efficient vector/matrix times triangular matrix product */
+    template<typename OtherDerived> friend
+    EIGEN_DEVICE_FUNC
+    const Product<OtherDerived,SelfAdjointView>
+    operator*(const MatrixBase<OtherDerived>& lhs, const SelfAdjointView& rhs)
+    {
+      return Product<OtherDerived,SelfAdjointView>(lhs.derived(),rhs);
+    }
+
+    friend EIGEN_DEVICE_FUNC
+    const SelfAdjointView<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,MatrixType,product),UpLo>
+    operator*(const Scalar& s, const SelfAdjointView& mat)
+    {
+      return (s*mat.nestedExpression()).template selfadjointView<UpLo>();
+    }
+
+    /** Perform a symmetric rank 2 update of the selfadjoint matrix \c *this:
+      * \f$ this = this + \alpha u v^* + conj(\alpha) v u^* \f$
+      * \returns a reference to \c *this
+      *
+      * The vectors \a u and \c v \b must be column vectors, however they can be
+      * a adjoint expression without any overhead. Only the meaningful triangular
+      * part of the matrix is updated, the rest is left unchanged.
+      *
+      * \sa rankUpdate(const MatrixBase<DerivedU>&, Scalar)
+      */
+    template<typename DerivedU, typename DerivedV>
+    EIGEN_DEVICE_FUNC
+    SelfAdjointView& rankUpdate(const MatrixBase<DerivedU>& u, const MatrixBase<DerivedV>& v, const Scalar& alpha = Scalar(1));
+
+    /** Perform a symmetric rank K update of the selfadjoint matrix \c *this:
+      * \f$ this = this + \alpha ( u u^* ) \f$ where \a u is a vector or matrix.
+      *
+      * \returns a reference to \c *this
+      *
+      * Note that to perform \f$ this = this + \alpha ( u^* u ) \f$ you can simply
+      * call this function with u.adjoint().
+      *
+      * \sa rankUpdate(const MatrixBase<DerivedU>&, const MatrixBase<DerivedV>&, Scalar)
+      */
+    template<typename DerivedU>
+    EIGEN_DEVICE_FUNC
+    SelfAdjointView& rankUpdate(const MatrixBase<DerivedU>& u, const Scalar& alpha = Scalar(1));
+
+    /** \returns an expression of a triangular view extracted from the current selfadjoint view of a given triangular part
+      *
+      * The parameter \a TriMode can have the following values: \c #Upper, \c #StrictlyUpper, \c #UnitUpper,
+      * \c #Lower, \c #StrictlyLower, \c #UnitLower.
+      *
+      * If \c TriMode references the same triangular part than \c *this, then this method simply return a \c TriangularView of the nested expression,
+      * otherwise, the nested expression is first transposed, thus returning a \c TriangularView<Transpose<MatrixType>> object.
+      *
+      * \sa MatrixBase::triangularView(), class TriangularView
+      */
+    template<unsigned int TriMode>
+    EIGEN_DEVICE_FUNC
+    typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)),
+                                   TriangularView<MatrixType,TriMode>,
+                                   TriangularView<typename MatrixType::AdjointReturnType,TriMode> >::type
+    triangularView() const
+    {
+      typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)), MatrixType&, typename MatrixType::ConstTransposeReturnType>::type tmp1(m_matrix);
+      typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)), MatrixType&, typename MatrixType::AdjointReturnType>::type tmp2(tmp1);
+      return typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)),
+                                   TriangularView<MatrixType,TriMode>,
+                                   TriangularView<typename MatrixType::AdjointReturnType,TriMode> >::type(tmp2);
+    }
+
+    typedef SelfAdjointView<const MatrixConjugateReturnType,UpLo> ConjugateReturnType;
+    /** \sa MatrixBase::conjugate() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConjugateReturnType conjugate() const
+    { return ConjugateReturnType(m_matrix.conjugate()); }
+
+    /** \returns an expression of the complex conjugate of \c *this if Cond==true,
+     *           returns \c *this otherwise.
+     */
+    template<bool Cond>
+    EIGEN_DEVICE_FUNC
+    inline typename internal::conditional<Cond,ConjugateReturnType,ConstSelfAdjointView>::type
+    conjugateIf() const
+    {
+      typedef typename internal::conditional<Cond,ConjugateReturnType,ConstSelfAdjointView>::type ReturnType;
+      return ReturnType(m_matrix.template conjugateIf<Cond>());
+    }
+
+    typedef SelfAdjointView<const typename MatrixType::AdjointReturnType,TransposeMode> AdjointReturnType;
+    /** \sa MatrixBase::adjoint() const */
+    EIGEN_DEVICE_FUNC
+    inline const AdjointReturnType adjoint() const
+    { return AdjointReturnType(m_matrix.adjoint()); }
+
+    typedef SelfAdjointView<typename MatrixType::TransposeReturnType,TransposeMode> TransposeReturnType;
+     /** \sa MatrixBase::transpose() */
+    EIGEN_DEVICE_FUNC
+    inline TransposeReturnType transpose()
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      typename MatrixType::TransposeReturnType tmp(m_matrix);
+      return TransposeReturnType(tmp);
+    }
+
+    typedef SelfAdjointView<const typename MatrixType::ConstTransposeReturnType,TransposeMode> ConstTransposeReturnType;
+    /** \sa MatrixBase::transpose() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConstTransposeReturnType transpose() const
+    {
+      return ConstTransposeReturnType(m_matrix.transpose());
+    }
+
+    /** \returns a const expression of the main diagonal of the matrix \c *this
+      *
+      * This method simply returns the diagonal of the nested expression, thus by-passing the SelfAdjointView decorator.
+      *
+      * \sa MatrixBase::diagonal(), class Diagonal */
+    EIGEN_DEVICE_FUNC
+    typename MatrixType::ConstDiagonalReturnType diagonal() const
+    {
+      return typename MatrixType::ConstDiagonalReturnType(m_matrix);
+    }
+
+/////////// Cholesky module ///////////
+
+    const LLT<PlainObject, UpLo> llt() const;
+    const LDLT<PlainObject, UpLo> ldlt() const;
+
+/////////// Eigenvalue module ///////////
+
+    /** Real part of #Scalar */
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    /** Return type of eigenvalues() */
+    typedef Matrix<RealScalar, internal::traits<MatrixType>::ColsAtCompileTime, 1> EigenvaluesReturnType;
+
+    EIGEN_DEVICE_FUNC
+    EigenvaluesReturnType eigenvalues() const;
+    EIGEN_DEVICE_FUNC
+    RealScalar operatorNorm() const;
+
+  protected:
+    MatrixTypeNested m_matrix;
+};
+
+
+// template<typename OtherDerived, typename MatrixType, unsigned int UpLo>
+// internal::selfadjoint_matrix_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> >
+// operator*(const MatrixBase<OtherDerived>& lhs, const SelfAdjointView<MatrixType,UpLo>& rhs)
+// {
+//   return internal::matrix_selfadjoint_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> >(lhs.derived(),rhs);
+// }
+
+// selfadjoint to dense matrix
+
+namespace internal {
+
+// TODO currently a selfadjoint expression has the form SelfAdjointView<.,.>
+//      in the future selfadjoint-ness should be defined by the expression traits
+//      such that Transpose<SelfAdjointView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
+template<typename MatrixType, unsigned int Mode>
+struct evaluator_traits<SelfAdjointView<MatrixType,Mode> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef SelfAdjointShape Shape;
+};
+
+template<int UpLo, int SetOpposite, typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version>
+class triangular_dense_assignment_kernel<UpLo,SelfAdjoint,SetOpposite,DstEvaluatorTypeT,SrcEvaluatorTypeT,Functor,Version>
+  : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> Base;
+  typedef typename Base::DstXprType DstXprType;
+  typedef typename Base::SrcXprType SrcXprType;
+  using Base::m_dst;
+  using Base::m_src;
+  using Base::m_functor;
+public:
+
+  typedef typename Base::DstEvaluatorType DstEvaluatorType;
+  typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
+  typedef typename Base::Scalar Scalar;
+  typedef typename Base::AssignmentTraits AssignmentTraits;
+
+
+  EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {}
+
+  EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
+  {
+    eigen_internal_assert(row!=col);
+    Scalar tmp = m_src.coeff(row,col);
+    m_functor.assignCoeff(m_dst.coeffRef(row,col), tmp);
+    m_functor.assignCoeff(m_dst.coeffRef(col,row), numext::conj(tmp));
+  }
+
+  EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
+  {
+    Base::assignCoeff(id,id);
+  }
+
+  EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index, Index)
+  { eigen_internal_assert(false && "should never be called"); }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Implementation of MatrixBase methods
+***************************************************************************/
+
+/** This is the const version of MatrixBase::selfadjointView() */
+template<typename Derived>
+template<unsigned int UpLo>
+EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type
+MatrixBase<Derived>::selfadjointView() const
+{
+  return typename ConstSelfAdjointViewReturnType<UpLo>::Type(derived());
+}
+
+/** \returns an expression of a symmetric/self-adjoint view extracted from the upper or lower triangular part of the current matrix
+  *
+  * The parameter \a UpLo can be either \c #Upper or \c #Lower
+  *
+  * Example: \include MatrixBase_selfadjointView.cpp
+  * Output: \verbinclude MatrixBase_selfadjointView.out
+  *
+  * \sa class SelfAdjointView
+  */
+template<typename Derived>
+template<unsigned int UpLo>
+EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type
+MatrixBase<Derived>::selfadjointView()
+{
+  return typename SelfAdjointViewReturnType<UpLo>::Type(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINTMATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/SelfCwiseBinaryOp.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/SelfCwiseBinaryOp.h
new file mode 100644
index 00000000..7c89c2e2
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/SelfCwiseBinaryOp.h
@@ -0,0 +1,47 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFCWISEBINARYOP_H
+#define EIGEN_SELFCWISEBINARYOP_H
+
+namespace Eigen { 
+
+// TODO generalize the scalar type of 'other'
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator*=(const Scalar& other)
+{
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::mul_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator+=(const Scalar& other)
+{
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::add_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& ArrayBase<Derived>::operator-=(const Scalar& other)
+{
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::sub_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator/=(const Scalar& other)
+{
+  internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::div_assign_op<Scalar,Scalar>());
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFCWISEBINARYOP_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Solve.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Solve.h
new file mode 100644
index 00000000..23d5cb70
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Solve.h
@@ -0,0 +1,188 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVE_H
+#define EIGEN_SOLVE_H
+
+namespace Eigen {
+
+template<typename Decomposition, typename RhsType, typename StorageKind> class SolveImpl;
+
+/** \class Solve
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression representing a solving operation
+  *
+  * \tparam Decomposition the type of the matrix or decomposition object
+  * \tparam Rhstype the type of the right-hand side
+  *
+  * This class represents an expression of A.solve(B)
+  * and most of the time this is the only way it is used.
+  *
+  */
+namespace internal {
+
+// this solve_traits class permits to determine the evaluation type with respect to storage kind (Dense vs Sparse)
+template<typename Decomposition, typename RhsType,typename StorageKind> struct solve_traits;
+
+template<typename Decomposition, typename RhsType>
+struct solve_traits<Decomposition,RhsType,Dense>
+{
+  typedef typename make_proper_matrix_type<typename RhsType::Scalar,
+                 Decomposition::ColsAtCompileTime,
+                 RhsType::ColsAtCompileTime,
+                 RhsType::PlainObject::Options,
+                 Decomposition::MaxColsAtCompileTime,
+                 RhsType::MaxColsAtCompileTime>::type PlainObject;
+};
+
+template<typename Decomposition, typename RhsType>
+struct traits<Solve<Decomposition, RhsType> >
+  : traits<typename solve_traits<Decomposition,RhsType,typename internal::traits<RhsType>::StorageKind>::PlainObject>
+{
+  typedef typename solve_traits<Decomposition,RhsType,typename internal::traits<RhsType>::StorageKind>::PlainObject PlainObject;
+  typedef typename promote_index_type<typename Decomposition::StorageIndex, typename RhsType::StorageIndex>::type StorageIndex;
+  typedef traits<PlainObject> BaseTraits;
+  enum {
+    Flags = BaseTraits::Flags & RowMajorBit,
+    CoeffReadCost = HugeCost
+  };
+};
+
+}
+
+
+template<typename Decomposition, typename RhsType>
+class Solve : public SolveImpl<Decomposition,RhsType,typename internal::traits<RhsType>::StorageKind>
+{
+public:
+  typedef typename internal::traits<Solve>::PlainObject PlainObject;
+  typedef typename internal::traits<Solve>::StorageIndex StorageIndex;
+
+  Solve(const Decomposition &dec, const RhsType &rhs)
+    : m_dec(dec), m_rhs(rhs)
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_dec.cols(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+  EIGEN_DEVICE_FUNC const Decomposition& dec() const { return m_dec; }
+  EIGEN_DEVICE_FUNC const RhsType&       rhs() const { return m_rhs; }
+
+protected:
+  const Decomposition &m_dec;
+  const RhsType       &m_rhs;
+};
+
+
+// Specialization of the Solve expression for dense results
+template<typename Decomposition, typename RhsType>
+class SolveImpl<Decomposition,RhsType,Dense>
+  : public MatrixBase<Solve<Decomposition,RhsType> >
+{
+  typedef Solve<Decomposition,RhsType> Derived;
+
+public:
+
+  typedef MatrixBase<Solve<Decomposition,RhsType> > Base;
+  EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
+
+private:
+
+  Scalar coeff(Index row, Index col) const;
+  Scalar coeff(Index i) const;
+};
+
+// Generic API dispatcher
+template<typename Decomposition, typename RhsType, typename StorageKind>
+class SolveImpl : public internal::generic_xpr_base<Solve<Decomposition,RhsType>, MatrixXpr, StorageKind>::type
+{
+  public:
+    typedef typename internal::generic_xpr_base<Solve<Decomposition,RhsType>, MatrixXpr, StorageKind>::type Base;
+};
+
+namespace internal {
+
+// Evaluator of Solve -> eval into a temporary
+template<typename Decomposition, typename RhsType>
+struct evaluator<Solve<Decomposition,RhsType> >
+  : public evaluator<typename Solve<Decomposition,RhsType>::PlainObject>
+{
+  typedef Solve<Decomposition,RhsType> SolveType;
+  typedef typename SolveType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum { Flags = Base::Flags | EvalBeforeNestingBit };
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const SolveType& solve)
+    : m_result(solve.rows(), solve.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    solve.dec()._solve_impl(solve.rhs(), m_result);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+// Specialization for "dst = dec.solve(rhs)"
+// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef Solve<DecType,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec()._solve_impl(src.rhs(), dst);
+  }
+};
+
+// Specialization for "dst = dec.transpose().solve(rhs)"
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<Transpose<const DecType>,RhsType>, internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef Solve<Transpose<const DecType>,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec().nestedExpression().template _solve_impl_transposed<false>(src.rhs(), dst);
+  }
+};
+
+// Specialization for "dst = dec.adjoint().solve(rhs)"
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType>,
+                  internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec().nestedExpression().nestedExpression().template _solve_impl_transposed<true>(src.rhs(), dst);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/SolveTriangular.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/SolveTriangular.h
new file mode 100644
index 00000000..dfbf9952
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/SolveTriangular.h
@@ -0,0 +1,235 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVETRIANGULAR_H
+#define EIGEN_SOLVETRIANGULAR_H
+
+namespace Eigen {
+
+namespace internal {
+
+// Forward declarations:
+// The following two routines are implemented in the products/TriangularSolver*.h files
+template<typename LhsScalar, typename RhsScalar, typename Index, int Side, int Mode, bool Conjugate, int StorageOrder>
+struct triangular_solve_vector;
+
+template <typename Scalar, typename Index, int Side, int Mode, bool Conjugate, int TriStorageOrder, int OtherStorageOrder, int OtherInnerStride>
+struct triangular_solve_matrix;
+
+// small helper struct extracting some traits on the underlying solver operation
+template<typename Lhs, typename Rhs, int Side>
+class trsolve_traits
+{
+  private:
+    enum {
+      RhsIsVectorAtCompileTime = (Side==OnTheLeft ? Rhs::ColsAtCompileTime : Rhs::RowsAtCompileTime)==1
+    };
+  public:
+    enum {
+      Unrolling   = (RhsIsVectorAtCompileTime && Rhs::SizeAtCompileTime != Dynamic && Rhs::SizeAtCompileTime <= 8)
+                  ? CompleteUnrolling : NoUnrolling,
+      RhsVectors  = RhsIsVectorAtCompileTime ? 1 : Dynamic
+    };
+};
+
+template<typename Lhs, typename Rhs,
+  int Side, // can be OnTheLeft/OnTheRight
+  int Mode, // can be Upper/Lower | UnitDiag
+  int Unrolling = trsolve_traits<Lhs,Rhs,Side>::Unrolling,
+  int RhsVectors = trsolve_traits<Lhs,Rhs,Side>::RhsVectors
+  >
+struct triangular_solver_selector;
+
+template<typename Lhs, typename Rhs, int Side, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,1>
+{
+  typedef typename Lhs::Scalar LhsScalar;
+  typedef typename Rhs::Scalar RhsScalar;
+  typedef blas_traits<Lhs> LhsProductTraits;
+  typedef typename LhsProductTraits::ExtractType ActualLhsType;
+  typedef Map<Matrix<RhsScalar,Dynamic,1>, Aligned> MappedRhs;
+  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
+  {
+    ActualLhsType actualLhs = LhsProductTraits::extract(lhs);
+
+    // FIXME find a way to allow an inner stride if packet_traits<Scalar>::size==1
+
+    bool useRhsDirectly = Rhs::InnerStrideAtCompileTime==1 || rhs.innerStride()==1;
+
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhs,rhs.size(),
+                                                  (useRhsDirectly ? rhs.data() : 0));
+
+    if(!useRhsDirectly)
+      MappedRhs(actualRhs,rhs.size()) = rhs;
+
+    triangular_solve_vector<LhsScalar, RhsScalar, Index, Side, Mode, LhsProductTraits::NeedToConjugate,
+                            (int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor>
+      ::run(actualLhs.cols(), actualLhs.data(), actualLhs.outerStride(), actualRhs);
+
+    if(!useRhsDirectly)
+      rhs = MappedRhs(actualRhs, rhs.size());
+  }
+};
+
+// the rhs is a matrix
+template<typename Lhs, typename Rhs, int Side, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,Dynamic>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef blas_traits<Lhs> LhsProductTraits;
+  typedef typename LhsProductTraits::DirectLinearAccessType ActualLhsType;
+
+  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
+  {
+    typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);
+
+    const Index size = lhs.rows();
+    const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();
+
+    typedef internal::gemm_blocking_space<(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
+              Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxRowsAtCompileTime,4> BlockingType;
+
+    BlockingType blocking(rhs.rows(), rhs.cols(), size, 1, false);
+
+    triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,(int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor,
+                               (Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor, Rhs::InnerStrideAtCompileTime>
+      ::run(size, othersize, &actualLhs.coeffRef(0,0), actualLhs.outerStride(), &rhs.coeffRef(0,0), rhs.innerStride(), rhs.outerStride(), blocking);
+  }
+};
+
+/***************************************************************************
+* meta-unrolling implementation
+***************************************************************************/
+
+template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size,
+         bool Stop = LoopIndex==Size>
+struct triangular_solver_unroller;
+
+template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size>
+struct triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex,Size,false> {
+  enum {
+    IsLower = ((Mode&Lower)==Lower),
+    DiagIndex  = IsLower ? LoopIndex : Size - LoopIndex - 1,
+    StartIndex = IsLower ? 0         : DiagIndex+1
+  };
+  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
+  {
+    if (LoopIndex>0)
+      rhs.coeffRef(DiagIndex) -= lhs.row(DiagIndex).template segment<LoopIndex>(StartIndex).transpose()
+                                .cwiseProduct(rhs.template segment<LoopIndex>(StartIndex)).sum();
+
+    if(!(Mode & UnitDiag))
+      rhs.coeffRef(DiagIndex) /= lhs.coeff(DiagIndex,DiagIndex);
+
+    triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex+1,Size>::run(lhs,rhs);
+  }
+};
+
+template<typename Lhs, typename Rhs, int Mode, int LoopIndex, int Size>
+struct triangular_solver_unroller<Lhs,Rhs,Mode,LoopIndex,Size,true> {
+  static EIGEN_DEVICE_FUNC void run(const Lhs&, Rhs&) {}
+};
+
+template<typename Lhs, typename Rhs, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,CompleteUnrolling,1> {
+  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
+  { triangular_solver_unroller<Lhs,Rhs,Mode,0,Rhs::SizeAtCompileTime>::run(lhs,rhs); }
+};
+
+template<typename Lhs, typename Rhs, int Mode>
+struct triangular_solver_selector<Lhs,Rhs,OnTheRight,Mode,CompleteUnrolling,1> {
+  static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
+  {
+    Transpose<const Lhs> trLhs(lhs);
+    Transpose<Rhs> trRhs(rhs);
+
+    triangular_solver_unroller<Transpose<const Lhs>,Transpose<Rhs>,
+                              ((Mode&Upper)==Upper ? Lower : Upper) | (Mode&UnitDiag),
+                              0,Rhs::SizeAtCompileTime>::run(trLhs,trRhs);
+  }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* TriangularView methods
+***************************************************************************/
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatrixType, unsigned int Mode>
+template<int Side, typename OtherDerived>
+EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType,Mode,Dense>::solveInPlace(const MatrixBase<OtherDerived>& _other) const
+{
+  OtherDerived& other = _other.const_cast_derived();
+  eigen_assert( derived().cols() == derived().rows() && ((Side==OnTheLeft && derived().cols() == other.rows()) || (Side==OnTheRight && derived().cols() == other.cols())) );
+  eigen_assert((!(int(Mode) & int(ZeroDiag))) && bool(int(Mode) & (int(Upper) | int(Lower))));
+  // If solving for a 0x0 matrix, nothing to do, simply return.
+  if (derived().cols() == 0)
+    return;
+
+  enum { copy = (internal::traits<OtherDerived>::Flags & RowMajorBit)  && OtherDerived::IsVectorAtCompileTime && OtherDerived::SizeAtCompileTime!=1};
+  typedef typename internal::conditional<copy,
+    typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
+  OtherCopy otherCopy(other);
+
+  internal::triangular_solver_selector<MatrixType, typename internal::remove_reference<OtherCopy>::type,
+    Side, Mode>::run(derived().nestedExpression(), otherCopy);
+
+  if (copy)
+    other = otherCopy;
+}
+
+template<typename Derived, unsigned int Mode>
+template<int Side, typename Other>
+const internal::triangular_solve_retval<Side,TriangularView<Derived,Mode>,Other>
+TriangularViewImpl<Derived,Mode,Dense>::solve(const MatrixBase<Other>& other) const
+{
+  return internal::triangular_solve_retval<Side,TriangularViewType,Other>(derived(), other.derived());
+}
+#endif
+
+namespace internal {
+
+
+template<int Side, typename TriangularType, typename Rhs>
+struct traits<triangular_solve_retval<Side, TriangularType, Rhs> >
+{
+  typedef typename internal::plain_matrix_type_column_major<Rhs>::type ReturnType;
+};
+
+template<int Side, typename TriangularType, typename Rhs> struct triangular_solve_retval
+ : public ReturnByValue<triangular_solve_retval<Side, TriangularType, Rhs> >
+{
+  typedef typename remove_all<typename Rhs::Nested>::type RhsNestedCleaned;
+  typedef ReturnByValue<triangular_solve_retval> Base;
+
+  triangular_solve_retval(const TriangularType& tri, const Rhs& rhs)
+    : m_triangularMatrix(tri), m_rhs(rhs)
+  {}
+
+  inline EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_rhs.rows(); }
+  inline EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+  template<typename Dest> inline void evalTo(Dest& dst) const
+  {
+    if(!is_same_dense(dst,m_rhs))
+      dst = m_rhs;
+    m_triangularMatrix.template solveInPlace<Side>(dst);
+  }
+
+  protected:
+    const TriangularType& m_triangularMatrix;
+    typename Rhs::Nested m_rhs;
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVETRIANGULAR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/SolverBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/SolverBase.h
new file mode 100644
index 00000000..50146104
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/SolverBase.h
@@ -0,0 +1,168 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVERBASE_H
+#define EIGEN_SOLVERBASE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Derived>
+struct solve_assertion {
+    template<bool Transpose_, typename Rhs>
+    static void run(const Derived& solver, const Rhs& b) { solver.template _check_solve_assertion<Transpose_>(b); }
+};
+
+template<typename Derived>
+struct solve_assertion<Transpose<Derived> >
+{
+    typedef Transpose<Derived> type;
+
+    template<bool Transpose_, typename Rhs>
+    static void run(const type& transpose, const Rhs& b)
+    {
+        internal::solve_assertion<typename internal::remove_all<Derived>::type>::template run<true>(transpose.nestedExpression(), b);
+    }
+};
+
+template<typename Scalar, typename Derived>
+struct solve_assertion<CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<Scalar>, const Transpose<Derived> > >
+{
+    typedef CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<Scalar>, const Transpose<Derived> > type;
+
+    template<bool Transpose_, typename Rhs>
+    static void run(const type& adjoint, const Rhs& b)
+    {
+        internal::solve_assertion<typename internal::remove_all<Transpose<Derived> >::type>::template run<true>(adjoint.nestedExpression(), b);
+    }
+};
+} // end namespace internal
+
+/** \class SolverBase
+  * \brief A base class for matrix decomposition and solvers
+  *
+  * \tparam Derived the actual type of the decomposition/solver.
+  *
+  * Any matrix decomposition inheriting this base class provide the following API:
+  *
+  * \code
+  * MatrixType A, b, x;
+  * DecompositionType dec(A);
+  * x = dec.solve(b);             // solve A   * x = b
+  * x = dec.transpose().solve(b); // solve A^T * x = b
+  * x = dec.adjoint().solve(b);   // solve A'  * x = b
+  * \endcode
+  *
+  * \warning Currently, any other usage of transpose() and adjoint() are not supported and will produce compilation errors.
+  *
+  * \sa class PartialPivLU, class FullPivLU, class HouseholderQR, class ColPivHouseholderQR, class FullPivHouseholderQR, class CompleteOrthogonalDecomposition, class LLT, class LDLT, class SVDBase
+  */
+template<typename Derived>
+class SolverBase : public EigenBase<Derived>
+{
+  public:
+
+    typedef EigenBase<Derived> Base;
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef Scalar CoeffReturnType;
+
+    template<typename Derived_>
+    friend struct internal::solve_assertion;
+
+    enum {
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                          internal::traits<Derived>::ColsAtCompileTime>::ret),
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
+                                                             internal::traits<Derived>::MaxColsAtCompileTime>::ret),
+      IsVectorAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime == 1
+                           || internal::traits<Derived>::MaxColsAtCompileTime == 1,
+      NumDimensions = int(MaxSizeAtCompileTime) == 1 ? 0 : bool(IsVectorAtCompileTime) ? 1 : 2
+    };
+
+    /** Default constructor */
+    SolverBase()
+    {}
+
+    ~SolverBase()
+    {}
+
+    using Base::derived;
+
+    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      */
+    template<typename Rhs>
+    inline const Solve<Derived, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      internal::solve_assertion<typename internal::remove_all<Derived>::type>::template run<false>(derived(), b);
+      return Solve<Derived, Rhs>(derived(), b.derived());
+    }
+
+    /** \internal the return type of transpose() */
+    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
+    /** \returns an expression of the transposed of the factored matrix.
+      *
+      * A typical usage is to solve for the transposed problem A^T x = b:
+      * \code x = dec.transpose().solve(b); \endcode
+      *
+      * \sa adjoint(), solve()
+      */
+    inline ConstTransposeReturnType transpose() const
+    {
+      return ConstTransposeReturnType(derived());
+    }
+
+    /** \internal the return type of adjoint() */
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
+                        ConstTransposeReturnType
+                     >::type AdjointReturnType;
+    /** \returns an expression of the adjoint of the factored matrix
+      *
+      * A typical usage is to solve for the adjoint problem A' x = b:
+      * \code x = dec.adjoint().solve(b); \endcode
+      *
+      * For real scalar types, this function is equivalent to transpose().
+      *
+      * \sa transpose(), solve()
+      */
+    inline AdjointReturnType adjoint() const
+    {
+      return AdjointReturnType(derived().transpose());
+    }
+
+  protected:
+
+    template<bool Transpose_, typename Rhs>
+    void _check_solve_assertion(const Rhs& b) const {
+        EIGEN_ONLY_USED_FOR_DEBUG(b);
+        eigen_assert(derived().m_isInitialized && "Solver is not initialized.");
+        eigen_assert((Transpose_?derived().cols():derived().rows())==b.rows() && "SolverBase::solve(): invalid number of rows of the right hand side matrix b");
+    }
+};
+
+namespace internal {
+
+template<typename Derived>
+struct generic_xpr_base<Derived, MatrixXpr, SolverStorage>
+{
+  typedef SolverBase<Derived> type;
+
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVERBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/StableNorm.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/StableNorm.h
new file mode 100644
index 00000000..4a3f0cca
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/StableNorm.h
@@ -0,0 +1,251 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STABLENORM_H
+#define EIGEN_STABLENORM_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename ExpressionType, typename Scalar>
+inline void stable_norm_kernel(const ExpressionType& bl, Scalar& ssq, Scalar& scale, Scalar& invScale)
+{
+  Scalar maxCoeff = bl.cwiseAbs().maxCoeff();
+  
+  if(maxCoeff>scale)
+  {
+    ssq = ssq * numext::abs2(scale/maxCoeff);
+    Scalar tmp = Scalar(1)/maxCoeff;
+    if(tmp > NumTraits<Scalar>::highest())
+    {
+      invScale = NumTraits<Scalar>::highest();
+      scale = Scalar(1)/invScale;
+    }
+    else if(maxCoeff>NumTraits<Scalar>::highest()) // we got a INF
+    {
+      invScale = Scalar(1);
+      scale = maxCoeff;
+    }
+    else
+    {
+      scale = maxCoeff;
+      invScale = tmp;
+    }
+  }
+  else if(maxCoeff!=maxCoeff) // we got a NaN
+  {
+    scale = maxCoeff;
+  }
+  
+  // TODO if the maxCoeff is much much smaller than the current scale,
+  // then we can neglect this sub vector
+  if(scale>Scalar(0)) // if scale==0, then bl is 0 
+    ssq += (bl*invScale).squaredNorm();
+}
+
+template<typename VectorType, typename RealScalar>
+void stable_norm_impl_inner_step(const VectorType &vec, RealScalar& ssq, RealScalar& scale, RealScalar& invScale)
+{
+  typedef typename VectorType::Scalar Scalar;
+  const Index blockSize = 4096;
+  
+  typedef typename internal::nested_eval<VectorType,2>::type VectorTypeCopy;
+  typedef typename internal::remove_all<VectorTypeCopy>::type VectorTypeCopyClean;
+  const VectorTypeCopy copy(vec);
+  
+  enum {
+    CanAlign = (   (int(VectorTypeCopyClean::Flags)&DirectAccessBit)
+                || (int(internal::evaluator<VectorTypeCopyClean>::Alignment)>0) // FIXME Alignment)>0 might not be enough
+               ) && (blockSize*sizeof(Scalar)*2<EIGEN_STACK_ALLOCATION_LIMIT)
+                 && (EIGEN_MAX_STATIC_ALIGN_BYTES>0) // if we cannot allocate on the stack, then let's not bother about this optimization
+  };
+  typedef typename internal::conditional<CanAlign, Ref<const Matrix<Scalar,Dynamic,1,0,blockSize,1>, internal::evaluator<VectorTypeCopyClean>::Alignment>,
+                                                   typename VectorTypeCopyClean::ConstSegmentReturnType>::type SegmentWrapper;
+  Index n = vec.size();
+  
+  Index bi = internal::first_default_aligned(copy);
+  if (bi>0)
+    internal::stable_norm_kernel(copy.head(bi), ssq, scale, invScale);
+  for (; bi<n; bi+=blockSize)
+    internal::stable_norm_kernel(SegmentWrapper(copy.segment(bi,numext::mini(blockSize, n - bi))), ssq, scale, invScale);
+}
+
+template<typename VectorType>
+typename VectorType::RealScalar
+stable_norm_impl(const VectorType &vec, typename enable_if<VectorType::IsVectorAtCompileTime>::type* = 0 )
+{
+  using std::sqrt;
+  using std::abs;
+
+  Index n = vec.size();
+
+  if(n==1)
+    return abs(vec.coeff(0));
+
+  typedef typename VectorType::RealScalar RealScalar;
+  RealScalar scale(0);
+  RealScalar invScale(1);
+  RealScalar ssq(0); // sum of squares
+
+  stable_norm_impl_inner_step(vec, ssq, scale, invScale);
+  
+  return scale * sqrt(ssq);
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar
+stable_norm_impl(const MatrixType &mat, typename enable_if<!MatrixType::IsVectorAtCompileTime>::type* = 0 )
+{
+  using std::sqrt;
+
+  typedef typename MatrixType::RealScalar RealScalar;
+  RealScalar scale(0);
+  RealScalar invScale(1);
+  RealScalar ssq(0); // sum of squares
+
+  for(Index j=0; j<mat.outerSize(); ++j)
+    stable_norm_impl_inner_step(mat.innerVector(j), ssq, scale, invScale);
+  return scale * sqrt(ssq);
+}
+
+template<typename Derived>
+inline typename NumTraits<typename traits<Derived>::Scalar>::Real
+blueNorm_impl(const EigenBase<Derived>& _vec)
+{
+  typedef typename Derived::RealScalar RealScalar;  
+  using std::pow;
+  using std::sqrt;
+  using std::abs;
+
+  // This program calculates the machine-dependent constants
+  // bl, b2, slm, s2m, relerr overfl
+  // from the "basic" machine-dependent numbers
+  // nbig, ibeta, it, iemin, iemax, rbig.
+  // The following define the basic machine-dependent constants.
+  // For portability, the PORT subprograms "ilmaeh" and "rlmach"
+  // are used. For any specific computer, each of the assignment
+  // statements can be replaced
+  static const int ibeta = std::numeric_limits<RealScalar>::radix;  // base for floating-point numbers
+  static const int it    = NumTraits<RealScalar>::digits();  // number of base-beta digits in mantissa
+  static const int iemin = NumTraits<RealScalar>::min_exponent();  // minimum exponent
+  static const int iemax = NumTraits<RealScalar>::max_exponent();  // maximum exponent
+  static const RealScalar rbig   = NumTraits<RealScalar>::highest();  // largest floating-point number
+  static const RealScalar b1     = RealScalar(pow(RealScalar(ibeta),RealScalar(-((1-iemin)/2))));  // lower boundary of midrange
+  static const RealScalar b2     = RealScalar(pow(RealScalar(ibeta),RealScalar((iemax + 1 - it)/2)));  // upper boundary of midrange
+  static const RealScalar s1m    = RealScalar(pow(RealScalar(ibeta),RealScalar((2-iemin)/2)));  // scaling factor for lower range
+  static const RealScalar s2m    = RealScalar(pow(RealScalar(ibeta),RealScalar(- ((iemax+it)/2))));  // scaling factor for upper range
+  static const RealScalar eps    = RealScalar(pow(double(ibeta), 1-it));
+  static const RealScalar relerr = sqrt(eps);  // tolerance for neglecting asml
+
+  const Derived& vec(_vec.derived());
+  Index n = vec.size();
+  RealScalar ab2 = b2 / RealScalar(n);
+  RealScalar asml = RealScalar(0);
+  RealScalar amed = RealScalar(0);
+  RealScalar abig = RealScalar(0);
+
+  for(Index j=0; j<vec.outerSize(); ++j)
+  {
+    for(typename Derived::InnerIterator iter(vec, j); iter; ++iter)
+    {
+      RealScalar ax = abs(iter.value());
+      if(ax > ab2)     abig += numext::abs2(ax*s2m);
+      else if(ax < b1) asml += numext::abs2(ax*s1m);
+      else             amed += numext::abs2(ax);
+    }
+  }
+  if(amed!=amed)
+    return amed;  // we got a NaN
+  if(abig > RealScalar(0))
+  {
+    abig = sqrt(abig);
+    if(abig > rbig) // overflow, or *this contains INF values
+      return abig;  // return INF
+    if(amed > RealScalar(0))
+    {
+      abig = abig/s2m;
+      amed = sqrt(amed);
+    }
+    else
+      return abig/s2m;
+  }
+  else if(asml > RealScalar(0))
+  {
+    if (amed > RealScalar(0))
+    {
+      abig = sqrt(amed);
+      amed = sqrt(asml) / s1m;
+    }
+    else
+      return sqrt(asml)/s1m;
+  }
+  else
+    return sqrt(amed);
+  asml = numext::mini(abig, amed);
+  abig = numext::maxi(abig, amed);
+  if(asml <= abig*relerr)
+    return abig;
+  else
+    return abig * sqrt(RealScalar(1) + numext::abs2(asml/abig));
+}
+
+} // end namespace internal
+
+/** \returns the \em l2 norm of \c *this avoiding underflow and overflow.
+  * This version use a blockwise two passes algorithm:
+  *  1 - find the absolute largest coefficient \c s
+  *  2 - compute \f$ s \Vert \frac{*this}{s} \Vert \f$ in a standard way
+  *
+  * For architecture/scalar types supporting vectorization, this version
+  * is faster than blueNorm(). Otherwise the blueNorm() is much faster.
+  *
+  * \sa norm(), blueNorm(), hypotNorm()
+  */
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+MatrixBase<Derived>::stableNorm() const
+{
+  return internal::stable_norm_impl(derived());
+}
+
+/** \returns the \em l2 norm of \c *this using the Blue's algorithm.
+  * A Portable Fortran Program to Find the Euclidean Norm of a Vector,
+  * ACM TOMS, Vol 4, Issue 1, 1978.
+  *
+  * For architecture/scalar types without vectorization, this version
+  * is much faster than stableNorm(). Otherwise the stableNorm() is faster.
+  *
+  * \sa norm(), stableNorm(), hypotNorm()
+  */
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+MatrixBase<Derived>::blueNorm() const
+{
+  return internal::blueNorm_impl(*this);
+}
+
+/** \returns the \em l2 norm of \c *this avoiding undeflow and overflow.
+  * This version use a concatenation of hypot() calls, and it is very slow.
+  *
+  * \sa norm(), stableNorm()
+  */
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+MatrixBase<Derived>::hypotNorm() const
+{
+  if(size()==1)
+    return numext::abs(coeff(0,0));
+  else
+    return this->cwiseAbs().redux(internal::scalar_hypot_op<RealScalar>());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_STABLENORM_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/StlIterators.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/StlIterators.h
new file mode 100644
index 00000000..09041db1
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/StlIterators.h
@@ -0,0 +1,463 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STLITERATORS_H
+#define EIGEN_STLITERATORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename IteratorType>
+struct indexed_based_stl_iterator_traits;
+
+template<typename  Derived>
+class indexed_based_stl_iterator_base
+{
+protected:
+  typedef indexed_based_stl_iterator_traits<Derived> traits;
+  typedef typename traits::XprType XprType;
+  typedef indexed_based_stl_iterator_base<typename traits::non_const_iterator> non_const_iterator;
+  typedef indexed_based_stl_iterator_base<typename traits::const_iterator> const_iterator;
+  typedef typename internal::conditional<internal::is_const<XprType>::value,non_const_iterator,const_iterator>::type other_iterator;
+  // NOTE: in C++03 we cannot declare friend classes through typedefs because we need to write friend class:
+  friend class indexed_based_stl_iterator_base<typename traits::const_iterator>;
+  friend class indexed_based_stl_iterator_base<typename traits::non_const_iterator>;
+public:
+  typedef Index difference_type;
+  typedef std::random_access_iterator_tag iterator_category;
+
+  indexed_based_stl_iterator_base() EIGEN_NO_THROW : mp_xpr(0), m_index(0) {}
+  indexed_based_stl_iterator_base(XprType& xpr, Index index) EIGEN_NO_THROW : mp_xpr(&xpr), m_index(index) {}
+
+  indexed_based_stl_iterator_base(const non_const_iterator& other) EIGEN_NO_THROW
+    : mp_xpr(other.mp_xpr), m_index(other.m_index)
+  {}
+
+  indexed_based_stl_iterator_base& operator=(const non_const_iterator& other)
+  {
+    mp_xpr = other.mp_xpr;
+    m_index = other.m_index;
+    return *this;
+  }
+
+  Derived& operator++() { ++m_index; return derived(); }
+  Derived& operator--() { --m_index; return derived(); }
+
+  Derived operator++(int) { Derived prev(derived()); operator++(); return prev;}
+  Derived operator--(int) { Derived prev(derived()); operator--(); return prev;}
+
+  friend Derived operator+(const indexed_based_stl_iterator_base& a, Index b) { Derived ret(a.derived()); ret += b; return ret; }
+  friend Derived operator-(const indexed_based_stl_iterator_base& a, Index b) { Derived ret(a.derived()); ret -= b; return ret; }
+  friend Derived operator+(Index a, const indexed_based_stl_iterator_base& b) { Derived ret(b.derived()); ret += a; return ret; }
+  friend Derived operator-(Index a, const indexed_based_stl_iterator_base& b) { Derived ret(b.derived()); ret -= a; return ret; }
+  
+  Derived& operator+=(Index b) { m_index += b; return derived(); }
+  Derived& operator-=(Index b) { m_index -= b; return derived(); }
+
+  difference_type operator-(const indexed_based_stl_iterator_base& other) const
+  {
+    eigen_assert(mp_xpr == other.mp_xpr);
+    return m_index - other.m_index;
+  }
+
+  difference_type operator-(const other_iterator& other) const
+  {
+    eigen_assert(mp_xpr == other.mp_xpr);
+    return m_index - other.m_index;
+  }
+
+  bool operator==(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
+  bool operator!=(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
+  bool operator< (const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <  other.m_index; }
+  bool operator<=(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
+  bool operator> (const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >  other.m_index; }
+  bool operator>=(const indexed_based_stl_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
+
+  bool operator==(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
+  bool operator!=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
+  bool operator< (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <  other.m_index; }
+  bool operator<=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
+  bool operator> (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >  other.m_index; }
+  bool operator>=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
+
+protected:
+
+  Derived& derived() { return static_cast<Derived&>(*this); }
+  const Derived& derived() const { return static_cast<const Derived&>(*this); }
+
+  XprType *mp_xpr;
+  Index m_index;
+};
+
+template<typename  Derived>
+class indexed_based_stl_reverse_iterator_base
+{
+protected:
+  typedef indexed_based_stl_iterator_traits<Derived> traits;
+  typedef typename traits::XprType XprType;
+  typedef indexed_based_stl_reverse_iterator_base<typename traits::non_const_iterator> non_const_iterator;
+  typedef indexed_based_stl_reverse_iterator_base<typename traits::const_iterator> const_iterator;
+  typedef typename internal::conditional<internal::is_const<XprType>::value,non_const_iterator,const_iterator>::type other_iterator;
+  // NOTE: in C++03 we cannot declare friend classes through typedefs because we need to write friend class:
+  friend class indexed_based_stl_reverse_iterator_base<typename traits::const_iterator>;
+  friend class indexed_based_stl_reverse_iterator_base<typename traits::non_const_iterator>;
+public:
+  typedef Index difference_type;
+  typedef std::random_access_iterator_tag iterator_category;
+
+  indexed_based_stl_reverse_iterator_base() : mp_xpr(0), m_index(0) {}
+  indexed_based_stl_reverse_iterator_base(XprType& xpr, Index index) : mp_xpr(&xpr), m_index(index) {}
+
+  indexed_based_stl_reverse_iterator_base(const non_const_iterator& other)
+    : mp_xpr(other.mp_xpr), m_index(other.m_index)
+  {}
+
+  indexed_based_stl_reverse_iterator_base& operator=(const non_const_iterator& other)
+  {
+    mp_xpr = other.mp_xpr;
+    m_index = other.m_index;
+    return *this;
+  }
+
+  Derived& operator++() { --m_index; return derived(); }
+  Derived& operator--() { ++m_index; return derived(); }
+
+  Derived operator++(int) { Derived prev(derived()); operator++(); return prev;}
+  Derived operator--(int) { Derived prev(derived()); operator--(); return prev;}
+
+  friend Derived operator+(const indexed_based_stl_reverse_iterator_base& a, Index b) { Derived ret(a.derived()); ret += b; return ret; }
+  friend Derived operator-(const indexed_based_stl_reverse_iterator_base& a, Index b) { Derived ret(a.derived()); ret -= b; return ret; }
+  friend Derived operator+(Index a, const indexed_based_stl_reverse_iterator_base& b) { Derived ret(b.derived()); ret += a; return ret; }
+  friend Derived operator-(Index a, const indexed_based_stl_reverse_iterator_base& b) { Derived ret(b.derived()); ret -= a; return ret; }
+  
+  Derived& operator+=(Index b) { m_index -= b; return derived(); }
+  Derived& operator-=(Index b) { m_index += b; return derived(); }
+
+  difference_type operator-(const indexed_based_stl_reverse_iterator_base& other) const
+  {
+    eigen_assert(mp_xpr == other.mp_xpr);
+    return other.m_index - m_index;
+  }
+
+  difference_type operator-(const other_iterator& other) const
+  {
+    eigen_assert(mp_xpr == other.mp_xpr);
+    return other.m_index - m_index;
+  }
+
+  bool operator==(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
+  bool operator!=(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
+  bool operator< (const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >  other.m_index; }
+  bool operator<=(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
+  bool operator> (const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <  other.m_index; }
+  bool operator>=(const indexed_based_stl_reverse_iterator_base& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
+
+  bool operator==(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index == other.m_index; }
+  bool operator!=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index != other.m_index; }
+  bool operator< (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >  other.m_index; }
+  bool operator<=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index >= other.m_index; }
+  bool operator> (const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <  other.m_index; }
+  bool operator>=(const other_iterator& other) const { eigen_assert(mp_xpr == other.mp_xpr); return m_index <= other.m_index; }
+
+protected:
+
+  Derived& derived() { return static_cast<Derived&>(*this); }
+  const Derived& derived() const { return static_cast<const Derived&>(*this); }
+
+  XprType *mp_xpr;
+  Index m_index;
+};
+
+template<typename XprType>
+class pointer_based_stl_iterator
+{
+  enum { is_lvalue  = internal::is_lvalue<XprType>::value };
+  typedef pointer_based_stl_iterator<typename internal::remove_const<XprType>::type> non_const_iterator;
+  typedef pointer_based_stl_iterator<typename internal::add_const<XprType>::type> const_iterator;
+  typedef typename internal::conditional<internal::is_const<XprType>::value,non_const_iterator,const_iterator>::type other_iterator;
+  // NOTE: in C++03 we cannot declare friend classes through typedefs because we need to write friend class:
+  friend class pointer_based_stl_iterator<typename internal::add_const<XprType>::type>;
+  friend class pointer_based_stl_iterator<typename internal::remove_const<XprType>::type>;
+public:
+  typedef Index difference_type;
+  typedef typename XprType::Scalar value_type;
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef typename internal::conditional<bool(is_lvalue), value_type*, const value_type*>::type pointer;
+  typedef typename internal::conditional<bool(is_lvalue), value_type&, const value_type&>::type reference;
+
+
+  pointer_based_stl_iterator() EIGEN_NO_THROW : m_ptr(0) {}
+  pointer_based_stl_iterator(XprType& xpr, Index index) EIGEN_NO_THROW : m_incr(xpr.innerStride())
+  {
+    m_ptr = xpr.data() + index * m_incr.value();
+  }
+
+  pointer_based_stl_iterator(const non_const_iterator& other) EIGEN_NO_THROW
+    : m_ptr(other.m_ptr), m_incr(other.m_incr)
+  {}
+
+  pointer_based_stl_iterator& operator=(const non_const_iterator& other) EIGEN_NO_THROW
+  {
+    m_ptr = other.m_ptr;
+    m_incr.setValue(other.m_incr);
+    return *this;
+  }
+
+  reference operator*()         const { return *m_ptr;   }
+  reference operator[](Index i) const { return *(m_ptr+i*m_incr.value()); }
+  pointer   operator->()        const { return m_ptr;    }
+
+  pointer_based_stl_iterator& operator++() { m_ptr += m_incr.value(); return *this; }
+  pointer_based_stl_iterator& operator--() { m_ptr -= m_incr.value(); return *this; }
+
+  pointer_based_stl_iterator operator++(int) { pointer_based_stl_iterator prev(*this); operator++(); return prev;}
+  pointer_based_stl_iterator operator--(int) { pointer_based_stl_iterator prev(*this); operator--(); return prev;}
+
+  friend pointer_based_stl_iterator operator+(const pointer_based_stl_iterator& a, Index b) { pointer_based_stl_iterator ret(a); ret += b; return ret; }
+  friend pointer_based_stl_iterator operator-(const pointer_based_stl_iterator& a, Index b) { pointer_based_stl_iterator ret(a); ret -= b; return ret; }
+  friend pointer_based_stl_iterator operator+(Index a, const pointer_based_stl_iterator& b) { pointer_based_stl_iterator ret(b); ret += a; return ret; }
+  friend pointer_based_stl_iterator operator-(Index a, const pointer_based_stl_iterator& b) { pointer_based_stl_iterator ret(b); ret -= a; return ret; }
+  
+  pointer_based_stl_iterator& operator+=(Index b) { m_ptr += b*m_incr.value(); return *this; }
+  pointer_based_stl_iterator& operator-=(Index b) { m_ptr -= b*m_incr.value(); return *this; }
+
+  difference_type operator-(const pointer_based_stl_iterator& other) const {
+    return (m_ptr - other.m_ptr)/m_incr.value();
+  }
+
+  difference_type operator-(const other_iterator& other) const {
+    return (m_ptr - other.m_ptr)/m_incr.value();
+  }
+
+  bool operator==(const pointer_based_stl_iterator& other) const { return m_ptr == other.m_ptr; }
+  bool operator!=(const pointer_based_stl_iterator& other) const { return m_ptr != other.m_ptr; }
+  bool operator< (const pointer_based_stl_iterator& other) const { return m_ptr <  other.m_ptr; }
+  bool operator<=(const pointer_based_stl_iterator& other) const { return m_ptr <= other.m_ptr; }
+  bool operator> (const pointer_based_stl_iterator& other) const { return m_ptr >  other.m_ptr; }
+  bool operator>=(const pointer_based_stl_iterator& other) const { return m_ptr >= other.m_ptr; }
+
+  bool operator==(const other_iterator& other) const { return m_ptr == other.m_ptr; }
+  bool operator!=(const other_iterator& other) const { return m_ptr != other.m_ptr; }
+  bool operator< (const other_iterator& other) const { return m_ptr <  other.m_ptr; }
+  bool operator<=(const other_iterator& other) const { return m_ptr <= other.m_ptr; }
+  bool operator> (const other_iterator& other) const { return m_ptr >  other.m_ptr; }
+  bool operator>=(const other_iterator& other) const { return m_ptr >= other.m_ptr; }
+
+protected:
+
+  pointer m_ptr;
+  internal::variable_if_dynamic<Index, XprType::InnerStrideAtCompileTime> m_incr;
+};
+
+template<typename _XprType>
+struct indexed_based_stl_iterator_traits<generic_randaccess_stl_iterator<_XprType> >
+{
+  typedef _XprType XprType;
+  typedef generic_randaccess_stl_iterator<typename internal::remove_const<XprType>::type> non_const_iterator;
+  typedef generic_randaccess_stl_iterator<typename internal::add_const<XprType>::type> const_iterator;
+};
+
+template<typename XprType>
+class generic_randaccess_stl_iterator : public indexed_based_stl_iterator_base<generic_randaccess_stl_iterator<XprType> >
+{
+public:
+  typedef typename XprType::Scalar value_type;
+
+protected:
+
+  enum {
+    has_direct_access = (internal::traits<XprType>::Flags & DirectAccessBit) ? 1 : 0,
+    is_lvalue  = internal::is_lvalue<XprType>::value
+  };
+
+  typedef indexed_based_stl_iterator_base<generic_randaccess_stl_iterator> Base;
+  using Base::m_index;
+  using Base::mp_xpr;
+
+  // TODO currently const Transpose/Reshape expressions never returns const references,
+  // so lets return by value too.
+  //typedef typename internal::conditional<bool(has_direct_access), const value_type&, const value_type>::type read_only_ref_t;
+  typedef const value_type read_only_ref_t;
+
+public:
+  
+  typedef typename internal::conditional<bool(is_lvalue), value_type *, const value_type *>::type pointer;
+  typedef typename internal::conditional<bool(is_lvalue), value_type&, read_only_ref_t>::type reference;
+  
+  generic_randaccess_stl_iterator() : Base() {}
+  generic_randaccess_stl_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
+  generic_randaccess_stl_iterator(const typename Base::non_const_iterator& other) : Base(other) {}
+  using Base::operator=;
+
+  reference operator*()         const { return   (*mp_xpr)(m_index);   }
+  reference operator[](Index i) const { return   (*mp_xpr)(m_index+i); }
+  pointer   operator->()        const { return &((*mp_xpr)(m_index)); }
+};
+
+template<typename _XprType, DirectionType Direction>
+struct indexed_based_stl_iterator_traits<subvector_stl_iterator<_XprType,Direction> >
+{
+  typedef _XprType XprType;
+  typedef subvector_stl_iterator<typename internal::remove_const<XprType>::type, Direction> non_const_iterator;
+  typedef subvector_stl_iterator<typename internal::add_const<XprType>::type, Direction> const_iterator;
+};
+
+template<typename XprType, DirectionType Direction>
+class subvector_stl_iterator : public indexed_based_stl_iterator_base<subvector_stl_iterator<XprType,Direction> >
+{
+protected:
+
+  enum { is_lvalue  = internal::is_lvalue<XprType>::value };
+
+  typedef indexed_based_stl_iterator_base<subvector_stl_iterator> Base;
+  using Base::m_index;
+  using Base::mp_xpr;
+
+  typedef typename internal::conditional<Direction==Vertical,typename XprType::ColXpr,typename XprType::RowXpr>::type SubVectorType;
+  typedef typename internal::conditional<Direction==Vertical,typename XprType::ConstColXpr,typename XprType::ConstRowXpr>::type ConstSubVectorType;
+
+
+public:
+  typedef typename internal::conditional<bool(is_lvalue), SubVectorType, ConstSubVectorType>::type reference;
+  typedef typename reference::PlainObject value_type;
+
+private:
+  class subvector_stl_iterator_ptr
+  {
+  public:
+      subvector_stl_iterator_ptr(const reference &subvector) : m_subvector(subvector) {}
+      reference* operator->() { return &m_subvector; }
+  private:
+      reference m_subvector;
+  };
+public:
+
+  typedef subvector_stl_iterator_ptr pointer;
+  
+  subvector_stl_iterator() : Base() {}
+  subvector_stl_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
+
+  reference operator*()         const { return (*mp_xpr).template subVector<Direction>(m_index); }
+  reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index+i); }
+  pointer   operator->()        const { return (*mp_xpr).template subVector<Direction>(m_index); }
+};
+
+template<typename _XprType, DirectionType Direction>
+struct indexed_based_stl_iterator_traits<subvector_stl_reverse_iterator<_XprType,Direction> >
+{
+  typedef _XprType XprType;
+  typedef subvector_stl_reverse_iterator<typename internal::remove_const<XprType>::type, Direction> non_const_iterator;
+  typedef subvector_stl_reverse_iterator<typename internal::add_const<XprType>::type, Direction> const_iterator;
+};
+
+template<typename XprType, DirectionType Direction>
+class subvector_stl_reverse_iterator : public indexed_based_stl_reverse_iterator_base<subvector_stl_reverse_iterator<XprType,Direction> >
+{
+protected:
+
+  enum { is_lvalue  = internal::is_lvalue<XprType>::value };
+
+  typedef indexed_based_stl_reverse_iterator_base<subvector_stl_reverse_iterator> Base;
+  using Base::m_index;
+  using Base::mp_xpr;
+
+  typedef typename internal::conditional<Direction==Vertical,typename XprType::ColXpr,typename XprType::RowXpr>::type SubVectorType;
+  typedef typename internal::conditional<Direction==Vertical,typename XprType::ConstColXpr,typename XprType::ConstRowXpr>::type ConstSubVectorType;
+
+
+public:
+  typedef typename internal::conditional<bool(is_lvalue), SubVectorType, ConstSubVectorType>::type reference;
+  typedef typename reference::PlainObject value_type;
+
+private:
+  class subvector_stl_reverse_iterator_ptr
+  {
+  public:
+      subvector_stl_reverse_iterator_ptr(const reference &subvector) : m_subvector(subvector) {}
+      reference* operator->() { return &m_subvector; }
+  private:
+      reference m_subvector;
+  };
+public:
+
+  typedef subvector_stl_reverse_iterator_ptr pointer;
+  
+  subvector_stl_reverse_iterator() : Base() {}
+  subvector_stl_reverse_iterator(XprType& xpr, Index index) : Base(xpr,index) {}
+
+  reference operator*()         const { return (*mp_xpr).template subVector<Direction>(m_index); }
+  reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index+i); }
+  pointer   operator->()        const { return (*mp_xpr).template subVector<Direction>(m_index); }
+};
+
+} // namespace internal
+
+
+/** returns an iterator to the first element of the 1D vector or array
+  * \only_for_vectors
+  * \sa end(), cbegin()
+  */
+template<typename Derived>
+inline typename DenseBase<Derived>::iterator DenseBase<Derived>::begin()
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return iterator(derived(), 0);
+}
+
+/** const version of begin() */
+template<typename Derived>
+inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::begin() const
+{
+  return cbegin();
+}
+
+/** returns a read-only const_iterator to the first element of the 1D vector or array
+  * \only_for_vectors
+  * \sa cend(), begin()
+  */
+template<typename Derived>
+inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cbegin() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return const_iterator(derived(), 0);
+}
+
+/** returns an iterator to the element following the last element of the 1D vector or array
+  * \only_for_vectors
+  * \sa begin(), cend()
+  */
+template<typename Derived>
+inline typename DenseBase<Derived>::iterator DenseBase<Derived>::end()
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return iterator(derived(), size());
+}
+
+/** const version of end() */
+template<typename Derived>
+inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::end() const
+{
+  return cend();
+}
+
+/** returns a read-only const_iterator to the element following the last element of the 1D vector or array
+  * \only_for_vectors
+  * \sa begin(), cend()
+  */
+template<typename Derived>
+inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cend() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return const_iterator(derived(), size());
+}
+
+} // namespace Eigen
+
+#endif // EIGEN_STLITERATORS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Stride.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Stride.h
new file mode 100644
index 00000000..6494d514
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Stride.h
@@ -0,0 +1,116 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STRIDE_H
+#define EIGEN_STRIDE_H
+
+namespace Eigen {
+
+/** \class Stride
+  * \ingroup Core_Module
+  *
+  * \brief Holds strides information for Map
+  *
+  * This class holds the strides information for mapping arrays with strides with class Map.
+  *
+  * It holds two values: the inner stride and the outer stride.
+  *
+  * The inner stride is the pointer increment between two consecutive entries within a given row of a
+  * row-major matrix or within a given column of a column-major matrix.
+  *
+  * The outer stride is the pointer increment between two consecutive rows of a row-major matrix or
+  * between two consecutive columns of a column-major matrix.
+  *
+  * These two values can be passed either at compile-time as template parameters, or at runtime as
+  * arguments to the constructor.
+  *
+  * Indeed, this class takes two template parameters:
+  *  \tparam _OuterStrideAtCompileTime the outer stride, or Dynamic if you want to specify it at runtime.
+  *  \tparam _InnerStrideAtCompileTime the inner stride, or Dynamic if you want to specify it at runtime.
+  *
+  * Here is an example:
+  * \include Map_general_stride.cpp
+  * Output: \verbinclude Map_general_stride.out
+  *
+  * Both strides can be negative, however, a negative stride of -1 cannot be specified at compiletime
+  * because of the ambiguity with Dynamic which is defined to -1 (historically, negative strides were
+  * not allowed).
+  *
+  * \sa class InnerStride, class OuterStride, \ref TopicStorageOrders
+  */
+template<int _OuterStrideAtCompileTime, int _InnerStrideAtCompileTime>
+class Stride
+{
+  public:
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    enum {
+      InnerStrideAtCompileTime = _InnerStrideAtCompileTime,
+      OuterStrideAtCompileTime = _OuterStrideAtCompileTime
+    };
+
+    /** Default constructor, for use when strides are fixed at compile time */
+    EIGEN_DEVICE_FUNC
+    Stride()
+      : m_outer(OuterStrideAtCompileTime), m_inner(InnerStrideAtCompileTime)
+    {
+      // FIXME: for Eigen 4 we should use DynamicIndex instead of Dynamic.
+      // FIXME: for Eigen 4 we should also unify this API with fix<>
+      eigen_assert(InnerStrideAtCompileTime != Dynamic && OuterStrideAtCompileTime != Dynamic);
+    }
+
+    /** Constructor allowing to pass the strides at runtime */
+    EIGEN_DEVICE_FUNC
+    Stride(Index outerStride, Index innerStride)
+      : m_outer(outerStride), m_inner(innerStride)
+    {
+    }
+
+    /** Copy constructor */
+    EIGEN_DEVICE_FUNC
+    Stride(const Stride& other)
+      : m_outer(other.outer()), m_inner(other.inner())
+    {}
+
+    /** \returns the outer stride */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outer() const { return m_outer.value(); }
+    /** \returns the inner stride */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index inner() const { return m_inner.value(); }
+
+  protected:
+    internal::variable_if_dynamic<Index, OuterStrideAtCompileTime> m_outer;
+    internal::variable_if_dynamic<Index, InnerStrideAtCompileTime> m_inner;
+};
+
+/** \brief Convenience specialization of Stride to specify only an inner stride
+  * See class Map for some examples */
+template<int Value>
+class InnerStride : public Stride<0, Value>
+{
+    typedef Stride<0, Value> Base;
+  public:
+    EIGEN_DEVICE_FUNC InnerStride() : Base() {}
+    EIGEN_DEVICE_FUNC InnerStride(Index v) : Base(0, v) {} // FIXME making this explicit could break valid code
+};
+
+/** \brief Convenience specialization of Stride to specify only an outer stride
+  * See class Map for some examples */
+template<int Value>
+class OuterStride : public Stride<Value, 0>
+{
+    typedef Stride<Value, 0> Base;
+  public:
+    EIGEN_DEVICE_FUNC OuterStride() : Base() {}
+    EIGEN_DEVICE_FUNC OuterStride(Index v) : Base(v,0) {} // FIXME making this explicit could break valid code
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_STRIDE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Swap.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Swap.h
new file mode 100644
index 00000000..180a4e5a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Swap.h
@@ -0,0 +1,68 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SWAP_H
+#define EIGEN_SWAP_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// Overload default assignPacket behavior for swapping them
+template<typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT>
+class generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, Specialized>
+ : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn> Base;
+  using Base::m_dst;
+  using Base::m_src;
+  using Base::m_functor;
+  
+public:
+  typedef typename Base::Scalar Scalar;
+  typedef typename Base::DstXprType DstXprType;
+  typedef swap_assign_op<Scalar> Functor;
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  generic_dense_assignment_kernel(DstEvaluatorTypeT &dst, const SrcEvaluatorTypeT &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {}
+  
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE void assignPacket(Index row, Index col)
+  {
+    PacketType tmp = m_src.template packet<LoadMode,PacketType>(row,col);
+    const_cast<SrcEvaluatorTypeT&>(m_src).template writePacket<LoadMode>(row,col, m_dst.template packet<StoreMode,PacketType>(row,col));
+    m_dst.template writePacket<StoreMode>(row,col,tmp);
+  }
+  
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE void assignPacket(Index index)
+  {
+    PacketType tmp = m_src.template packet<LoadMode,PacketType>(index);
+    const_cast<SrcEvaluatorTypeT&>(m_src).template writePacket<LoadMode>(index, m_dst.template packet<StoreMode,PacketType>(index));
+    m_dst.template writePacket<StoreMode>(index,tmp);
+  }
+  
+  // TODO find a simple way not to have to copy/paste this function from generic_dense_assignment_kernel, by simple I mean no CRTP (Gael)
+  template<int StoreMode, int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE void assignPacketByOuterInner(Index outer, Index inner)
+  {
+    Index row = Base::rowIndexByOuterInner(outer, inner); 
+    Index col = Base::colIndexByOuterInner(outer, inner);
+    assignPacket<StoreMode,LoadMode,PacketType>(row, col);
+  }
+};
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SWAP_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Transpose.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Transpose.h
new file mode 100644
index 00000000..2bc658f4
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Transpose.h
@@ -0,0 +1,464 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSPOSE_H
+#define EIGEN_TRANSPOSE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename MatrixType>
+struct traits<Transpose<MatrixType> > : public traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type MatrixTypeNestedPlain;
+  enum {
+    RowsAtCompileTime = MatrixType::ColsAtCompileTime,
+    ColsAtCompileTime = MatrixType::RowsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags0 = traits<MatrixTypeNestedPlain>::Flags & ~(LvalueBit | NestByRefBit),
+    Flags1 = Flags0 | FlagsLvalueBit,
+    Flags = Flags1 ^ RowMajorBit,
+    InnerStrideAtCompileTime = inner_stride_at_compile_time<MatrixType>::ret,
+    OuterStrideAtCompileTime = outer_stride_at_compile_time<MatrixType>::ret
+  };
+};
+}
+
+template<typename MatrixType, typename StorageKind> class TransposeImpl;
+
+/** \class Transpose
+  * \ingroup Core_Module
+  *
+  * \brief Expression of the transpose of a matrix
+  *
+  * \tparam MatrixType the type of the object of which we are taking the transpose
+  *
+  * This class represents an expression of the transpose of a matrix.
+  * It is the return type of MatrixBase::transpose() and MatrixBase::adjoint()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::transpose(), MatrixBase::adjoint()
+  */
+template<typename MatrixType> class Transpose
+  : public TransposeImpl<MatrixType,typename internal::traits<MatrixType>::StorageKind>
+{
+  public:
+
+    typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+
+    typedef typename TransposeImpl<MatrixType,typename internal::traits<MatrixType>::StorageKind>::Base Base;
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Transpose)
+    typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE Transpose(MatrixType& matrix) : m_matrix(matrix) {}
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Transpose)
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const typename internal::remove_all<MatrixTypeNested>::type&
+    nestedExpression() const { return m_matrix; }
+
+    /** \returns the nested expression */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    typename internal::remove_reference<MatrixTypeNested>::type&
+    nestedExpression() { return m_matrix; }
+
+    /** \internal */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void resize(Index nrows, Index ncols) {
+      m_matrix.resize(ncols,nrows);
+    }
+
+  protected:
+    typename internal::ref_selector<MatrixType>::non_const_type m_matrix;
+};
+
+namespace internal {
+
+template<typename MatrixType, bool HasDirectAccess = has_direct_access<MatrixType>::ret>
+struct TransposeImpl_base
+{
+  typedef typename dense_xpr_base<Transpose<MatrixType> >::type type;
+};
+
+template<typename MatrixType>
+struct TransposeImpl_base<MatrixType, false>
+{
+  typedef typename dense_xpr_base<Transpose<MatrixType> >::type type;
+};
+
+} // end namespace internal
+
+// Generic API dispatcher
+template<typename XprType, typename StorageKind>
+class TransposeImpl
+  : public internal::generic_xpr_base<Transpose<XprType> >::type
+{
+public:
+  typedef typename internal::generic_xpr_base<Transpose<XprType> >::type Base;
+};
+
+template<typename MatrixType> class TransposeImpl<MatrixType,Dense>
+  : public internal::TransposeImpl_base<MatrixType>::type
+{
+  public:
+
+    typedef typename internal::TransposeImpl_base<MatrixType>::type Base;
+    using Base::coeffRef;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Transpose<MatrixType>)
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TransposeImpl)
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Index innerStride() const { return derived().nestedExpression().innerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Index outerStride() const { return derived().nestedExpression().outerStride(); }
+
+    typedef typename internal::conditional<
+                       internal::is_lvalue<MatrixType>::value,
+                       Scalar,
+                       const Scalar
+                     >::type ScalarWithConstIfNotLvalue;
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    ScalarWithConstIfNotLvalue* data() { return derived().nestedExpression().data(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const Scalar* data() const { return derived().nestedExpression().data(); }
+
+    // FIXME: shall we keep the const version of coeffRef?
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const Scalar& coeffRef(Index rowId, Index colId) const
+    {
+      return derived().nestedExpression().coeffRef(colId, rowId);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const Scalar& coeffRef(Index index) const
+    {
+      return derived().nestedExpression().coeffRef(index);
+    }
+  protected:
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(TransposeImpl)
+};
+
+/** \returns an expression of the transpose of *this.
+  *
+  * Example: \include MatrixBase_transpose.cpp
+  * Output: \verbinclude MatrixBase_transpose.out
+  *
+  * \warning If you want to replace a matrix by its own transpose, do \b NOT do this:
+  * \code
+  * m = m.transpose(); // bug!!! caused by aliasing effect
+  * \endcode
+  * Instead, use the transposeInPlace() method:
+  * \code
+  * m.transposeInPlace();
+  * \endcode
+  * which gives Eigen good opportunities for optimization, or alternatively you can also do:
+  * \code
+  * m = m.transpose().eval();
+  * \endcode
+  *
+  * \sa transposeInPlace(), adjoint() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+Transpose<Derived>
+DenseBase<Derived>::transpose()
+{
+  return TransposeReturnType(derived());
+}
+
+/** This is the const version of transpose().
+  *
+  * Make sure you read the warning for transpose() !
+  *
+  * \sa transposeInPlace(), adjoint() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename DenseBase<Derived>::ConstTransposeReturnType
+DenseBase<Derived>::transpose() const
+{
+  return ConstTransposeReturnType(derived());
+}
+
+/** \returns an expression of the adjoint (i.e. conjugate transpose) of *this.
+  *
+  * Example: \include MatrixBase_adjoint.cpp
+  * Output: \verbinclude MatrixBase_adjoint.out
+  *
+  * \warning If you want to replace a matrix by its own adjoint, do \b NOT do this:
+  * \code
+  * m = m.adjoint(); // bug!!! caused by aliasing effect
+  * \endcode
+  * Instead, use the adjointInPlace() method:
+  * \code
+  * m.adjointInPlace();
+  * \endcode
+  * which gives Eigen good opportunities for optimization, or alternatively you can also do:
+  * \code
+  * m = m.adjoint().eval();
+  * \endcode
+  *
+  * \sa adjointInPlace(), transpose(), conjugate(), class Transpose, class internal::scalar_conjugate_op */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const typename MatrixBase<Derived>::AdjointReturnType
+MatrixBase<Derived>::adjoint() const
+{
+  return AdjointReturnType(this->transpose());
+}
+
+/***************************************************************************
+* "in place" transpose implementation
+***************************************************************************/
+
+namespace internal {
+
+template<typename MatrixType,
+  bool IsSquare = (MatrixType::RowsAtCompileTime == MatrixType::ColsAtCompileTime) && MatrixType::RowsAtCompileTime!=Dynamic,
+  bool MatchPacketSize =
+        (int(MatrixType::RowsAtCompileTime) == int(internal::packet_traits<typename MatrixType::Scalar>::size))
+    &&  (internal::evaluator<MatrixType>::Flags&PacketAccessBit) >
+struct inplace_transpose_selector;
+
+template<typename MatrixType>
+struct inplace_transpose_selector<MatrixType,true,false> { // square matrix
+  static void run(MatrixType& m) {
+    m.matrix().template triangularView<StrictlyUpper>().swap(m.matrix().transpose().template triangularView<StrictlyUpper>());
+  }
+};
+
+template<typename MatrixType>
+struct inplace_transpose_selector<MatrixType,true,true> { // PacketSize x PacketSize
+  static void run(MatrixType& m) {
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename internal::packet_traits<typename MatrixType::Scalar>::type Packet;
+    const Index PacketSize = internal::packet_traits<Scalar>::size;
+    const Index Alignment = internal::evaluator<MatrixType>::Alignment;
+    PacketBlock<Packet> A;
+    for (Index i=0; i<PacketSize; ++i)
+      A.packet[i] = m.template packetByOuterInner<Alignment>(i,0);
+    internal::ptranspose(A);
+    for (Index i=0; i<PacketSize; ++i)
+      m.template writePacket<Alignment>(m.rowIndexByOuterInner(i,0), m.colIndexByOuterInner(i,0), A.packet[i]);
+  }
+};
+
+
+template <typename MatrixType, Index Alignment>
+void BlockedInPlaceTranspose(MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename internal::packet_traits<typename MatrixType::Scalar>::type Packet;
+  const Index PacketSize = internal::packet_traits<Scalar>::size;
+  eigen_assert(m.rows() == m.cols());
+  int row_start = 0;
+  for (; row_start + PacketSize <= m.rows(); row_start += PacketSize) {
+    for (int col_start = row_start; col_start + PacketSize <= m.cols(); col_start += PacketSize) {
+      PacketBlock<Packet> A;
+      if (row_start == col_start) {
+        for (Index i=0; i<PacketSize; ++i)
+          A.packet[i] = m.template packetByOuterInner<Alignment>(row_start + i,col_start);
+        internal::ptranspose(A);
+        for (Index i=0; i<PacketSize; ++i)
+          m.template writePacket<Alignment>(m.rowIndexByOuterInner(row_start + i, col_start), m.colIndexByOuterInner(row_start + i,col_start), A.packet[i]);
+      } else {
+        PacketBlock<Packet> B;
+        for (Index i=0; i<PacketSize; ++i) {
+          A.packet[i] = m.template packetByOuterInner<Alignment>(row_start + i,col_start);
+          B.packet[i] = m.template packetByOuterInner<Alignment>(col_start + i, row_start);
+        }
+        internal::ptranspose(A);
+        internal::ptranspose(B);
+        for (Index i=0; i<PacketSize; ++i) {
+          m.template writePacket<Alignment>(m.rowIndexByOuterInner(row_start + i, col_start), m.colIndexByOuterInner(row_start + i,col_start), B.packet[i]);
+          m.template writePacket<Alignment>(m.rowIndexByOuterInner(col_start + i, row_start), m.colIndexByOuterInner(col_start + i,row_start), A.packet[i]);
+        }
+      }
+    }
+  }
+  for (Index row = row_start; row < m.rows(); ++row) {
+    m.matrix().row(row).head(row).swap(
+        m.matrix().col(row).head(row).transpose());
+  }
+}
+
+template<typename MatrixType,bool MatchPacketSize>
+struct inplace_transpose_selector<MatrixType,false,MatchPacketSize> { // non square or dynamic matrix
+  static void run(MatrixType& m) {
+    typedef typename MatrixType::Scalar Scalar;
+    if (m.rows() == m.cols()) {
+      const Index PacketSize = internal::packet_traits<Scalar>::size;
+      if (!NumTraits<Scalar>::IsComplex && m.rows() >= PacketSize) {
+        if ((m.rows() % PacketSize) == 0)
+          BlockedInPlaceTranspose<MatrixType,internal::evaluator<MatrixType>::Alignment>(m);
+        else
+          BlockedInPlaceTranspose<MatrixType,Unaligned>(m);
+      }
+      else {
+        m.matrix().template triangularView<StrictlyUpper>().swap(m.matrix().transpose().template triangularView<StrictlyUpper>());
+      }
+    } else {
+      m = m.transpose().eval();
+    }
+  }
+};
+
+
+} // end namespace internal
+
+/** This is the "in place" version of transpose(): it replaces \c *this by its own transpose.
+  * Thus, doing
+  * \code
+  * m.transposeInPlace();
+  * \endcode
+  * has the same effect on m as doing
+  * \code
+  * m = m.transpose().eval();
+  * \endcode
+  * and is faster and also safer because in the latter line of code, forgetting the eval() results
+  * in a bug caused by \ref TopicAliasing "aliasing".
+  *
+  * Notice however that this method is only useful if you want to replace a matrix by its own transpose.
+  * If you just need the transpose of a matrix, use transpose().
+  *
+  * \note if the matrix is not square, then \c *this must be a resizable matrix.
+  * This excludes (non-square) fixed-size matrices, block-expressions and maps.
+  *
+  * \sa transpose(), adjoint(), adjointInPlace() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void DenseBase<Derived>::transposeInPlace()
+{
+  eigen_assert((rows() == cols() || (RowsAtCompileTime == Dynamic && ColsAtCompileTime == Dynamic))
+               && "transposeInPlace() called on a non-square non-resizable matrix");
+  internal::inplace_transpose_selector<Derived>::run(derived());
+}
+
+/***************************************************************************
+* "in place" adjoint implementation
+***************************************************************************/
+
+/** This is the "in place" version of adjoint(): it replaces \c *this by its own transpose.
+  * Thus, doing
+  * \code
+  * m.adjointInPlace();
+  * \endcode
+  * has the same effect on m as doing
+  * \code
+  * m = m.adjoint().eval();
+  * \endcode
+  * and is faster and also safer because in the latter line of code, forgetting the eval() results
+  * in a bug caused by aliasing.
+  *
+  * Notice however that this method is only useful if you want to replace a matrix by its own adjoint.
+  * If you just need the adjoint of a matrix, use adjoint().
+  *
+  * \note if the matrix is not square, then \c *this must be a resizable matrix.
+  * This excludes (non-square) fixed-size matrices, block-expressions and maps.
+  *
+  * \sa transpose(), adjoint(), transposeInPlace() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline void MatrixBase<Derived>::adjointInPlace()
+{
+  derived() = adjoint().eval();
+}
+
+#ifndef EIGEN_NO_DEBUG
+
+// The following is to detect aliasing problems in most common cases.
+
+namespace internal {
+
+template<bool DestIsTransposed, typename OtherDerived>
+struct check_transpose_aliasing_compile_time_selector
+{
+  enum { ret = bool(blas_traits<OtherDerived>::IsTransposed) != DestIsTransposed };
+};
+
+template<bool DestIsTransposed, typename BinOp, typename DerivedA, typename DerivedB>
+struct check_transpose_aliasing_compile_time_selector<DestIsTransposed,CwiseBinaryOp<BinOp,DerivedA,DerivedB> >
+{
+  enum { ret =    bool(blas_traits<DerivedA>::IsTransposed) != DestIsTransposed
+               || bool(blas_traits<DerivedB>::IsTransposed) != DestIsTransposed
+  };
+};
+
+template<typename Scalar, bool DestIsTransposed, typename OtherDerived>
+struct check_transpose_aliasing_run_time_selector
+{
+  static bool run(const Scalar* dest, const OtherDerived& src)
+  {
+    return (bool(blas_traits<OtherDerived>::IsTransposed) != DestIsTransposed) && (dest!=0 && dest==(const Scalar*)extract_data(src));
+  }
+};
+
+template<typename Scalar, bool DestIsTransposed, typename BinOp, typename DerivedA, typename DerivedB>
+struct check_transpose_aliasing_run_time_selector<Scalar,DestIsTransposed,CwiseBinaryOp<BinOp,DerivedA,DerivedB> >
+{
+  static bool run(const Scalar* dest, const CwiseBinaryOp<BinOp,DerivedA,DerivedB>& src)
+  {
+    return ((blas_traits<DerivedA>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(const Scalar*)extract_data(src.lhs())))
+        || ((blas_traits<DerivedB>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(const Scalar*)extract_data(src.rhs())));
+  }
+};
+
+// the following selector, checkTransposeAliasing_impl, based on MightHaveTransposeAliasing,
+// is because when the condition controlling the assert is known at compile time, ICC emits a warning.
+// This is actually a good warning: in expressions that don't have any transposing, the condition is
+// known at compile time to be false, and using that, we can avoid generating the code of the assert again
+// and again for all these expressions that don't need it.
+
+template<typename Derived, typename OtherDerived,
+         bool MightHaveTransposeAliasing
+                 = check_transpose_aliasing_compile_time_selector
+                     <blas_traits<Derived>::IsTransposed,OtherDerived>::ret
+        >
+struct checkTransposeAliasing_impl
+{
+    static void run(const Derived& dst, const OtherDerived& other)
+    {
+        eigen_assert((!check_transpose_aliasing_run_time_selector
+                      <typename Derived::Scalar,blas_traits<Derived>::IsTransposed,OtherDerived>
+                      ::run(extract_data(dst), other))
+          && "aliasing detected during transposition, use transposeInPlace() "
+             "or evaluate the rhs into a temporary using .eval()");
+
+    }
+};
+
+template<typename Derived, typename OtherDerived>
+struct checkTransposeAliasing_impl<Derived, OtherDerived, false>
+{
+    static void run(const Derived&, const OtherDerived&)
+    {
+    }
+};
+
+template<typename Dst, typename Src>
+void check_for_aliasing(const Dst &dst, const Src &src)
+{
+  if((!Dst::IsVectorAtCompileTime) && dst.rows()>1 && dst.cols()>1)
+    internal::checkTransposeAliasing_impl<Dst, Src>::run(dst, src);
+}
+
+} // end namespace internal
+
+#endif // EIGEN_NO_DEBUG
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSPOSE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Transpositions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Transpositions.h
new file mode 100644
index 00000000..38a7b01c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Transpositions.h
@@ -0,0 +1,386 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSPOSITIONS_H
+#define EIGEN_TRANSPOSITIONS_H
+
+namespace Eigen {
+
+template<typename Derived>
+class TranspositionsBase
+{
+    typedef internal::traits<Derived> Traits;
+
+  public:
+
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    EIGEN_DEVICE_FUNC
+    Derived& derived() { return *static_cast<Derived*>(this); }
+    EIGEN_DEVICE_FUNC
+    const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    Derived& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      indices() = other.indices();
+      return derived();
+    }
+
+    /** \returns the number of transpositions */
+    EIGEN_DEVICE_FUNC
+    Index size() const { return indices().size(); }
+    /** \returns the number of rows of the equivalent permutation matrix */
+    EIGEN_DEVICE_FUNC
+    Index rows() const { return indices().size(); }
+    /** \returns the number of columns of the equivalent permutation matrix */
+    EIGEN_DEVICE_FUNC
+    Index cols() const { return indices().size(); }
+
+    /** Direct access to the underlying index vector */
+    EIGEN_DEVICE_FUNC
+    inline const StorageIndex& coeff(Index i) const { return indices().coeff(i); }
+    /** Direct access to the underlying index vector */
+    inline StorageIndex& coeffRef(Index i) { return indices().coeffRef(i); }
+    /** Direct access to the underlying index vector */
+    inline const StorageIndex& operator()(Index i) const { return indices()(i); }
+    /** Direct access to the underlying index vector */
+    inline StorageIndex& operator()(Index i) { return indices()(i); }
+    /** Direct access to the underlying index vector */
+    inline const StorageIndex& operator[](Index i) const { return indices()(i); }
+    /** Direct access to the underlying index vector */
+    inline StorageIndex& operator[](Index i) { return indices()(i); }
+
+    /** const version of indices(). */
+    EIGEN_DEVICE_FUNC
+    const IndicesType& indices() const { return derived().indices(); }
+    /** \returns a reference to the stored array representing the transpositions. */
+    EIGEN_DEVICE_FUNC
+    IndicesType& indices() { return derived().indices(); }
+
+    /** Resizes to given size. */
+    inline void resize(Index newSize)
+    {
+      indices().resize(newSize);
+    }
+
+    /** Sets \c *this to represents an identity transformation */
+    void setIdentity()
+    {
+      for(StorageIndex i = 0; i < indices().size(); ++i)
+        coeffRef(i) = i;
+    }
+
+    // FIXME: do we want such methods ?
+    // might be useful when the target matrix expression is complex, e.g.:
+    // object.matrix().block(..,..,..,..) = trans * object.matrix().block(..,..,..,..);
+    /*
+    template<typename MatrixType>
+    void applyForwardToRows(MatrixType& mat) const
+    {
+      for(Index k=0 ; k<size() ; ++k)
+        if(m_indices(k)!=k)
+          mat.row(k).swap(mat.row(m_indices(k)));
+    }
+
+    template<typename MatrixType>
+    void applyBackwardToRows(MatrixType& mat) const
+    {
+      for(Index k=size()-1 ; k>=0 ; --k)
+        if(m_indices(k)!=k)
+          mat.row(k).swap(mat.row(m_indices(k)));
+    }
+    */
+
+    /** \returns the inverse transformation */
+    inline Transpose<TranspositionsBase> inverse() const
+    { return Transpose<TranspositionsBase>(derived()); }
+
+    /** \returns the tranpose transformation */
+    inline Transpose<TranspositionsBase> transpose() const
+    { return Transpose<TranspositionsBase>(derived()); }
+
+  protected:
+};
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+struct traits<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+ : traits<PermutationMatrix<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+{
+  typedef Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> IndicesType;
+  typedef TranspositionsStorage StorageKind;
+};
+}
+
+/** \class Transpositions
+  * \ingroup Core_Module
+  *
+  * \brief Represents a sequence of transpositions (row/column interchange)
+  *
+  * \tparam SizeAtCompileTime the number of transpositions, or Dynamic
+  * \tparam MaxSizeAtCompileTime the maximum number of transpositions, or Dynamic. This optional parameter defaults to SizeAtCompileTime. Most of the time, you should not have to specify it.
+  *
+  * This class represents a permutation transformation as a sequence of \em n transpositions
+  * \f$[T_{n-1} \ldots T_{i} \ldots T_{0}]\f$. It is internally stored as a vector of integers \c indices.
+  * Each transposition \f$ T_{i} \f$ applied on the left of a matrix (\f$ T_{i} M\f$) interchanges
+  * the rows \c i and \c indices[i] of the matrix \c M.
+  * A transposition applied on the right (e.g., \f$ M T_{i}\f$) yields a column interchange.
+  *
+  * Compared to the class PermutationMatrix, such a sequence of transpositions is what is
+  * computed during a decomposition with pivoting, and it is faster when applying the permutation in-place.
+  *
+  * To apply a sequence of transpositions to a matrix, simply use the operator * as in the following example:
+  * \code
+  * Transpositions tr;
+  * MatrixXf mat;
+  * mat = tr * mat;
+  * \endcode
+  * In this example, we detect that the matrix appears on both side, and so the transpositions
+  * are applied in-place without any temporary or extra copy.
+  *
+  * \sa class PermutationMatrix
+  */
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex>
+class Transpositions : public TranspositionsBase<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+{
+    typedef internal::traits<Transpositions> Traits;
+  public:
+
+    typedef TranspositionsBase<Transpositions> Base;
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+
+    inline Transpositions() {}
+
+    /** Copy constructor. */
+    template<typename OtherDerived>
+    inline Transpositions(const TranspositionsBase<OtherDerived>& other)
+      : m_indices(other.indices()) {}
+
+    /** Generic constructor from expression of the transposition indices. */
+    template<typename Other>
+    explicit inline Transpositions(const MatrixBase<Other>& indices) : m_indices(indices)
+    {}
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    Transpositions& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      return Base::operator=(other);
+    }
+
+    /** Constructs an uninitialized permutation matrix of given size.
+      */
+    inline Transpositions(Index size) : m_indices(size)
+    {}
+
+    /** const version of indices(). */
+    EIGEN_DEVICE_FUNC
+    const IndicesType& indices() const { return m_indices; }
+    /** \returns a reference to the stored array representing the transpositions. */
+    EIGEN_DEVICE_FUNC
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+
+namespace internal {
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess>
+struct traits<Map<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex>,_PacketAccess> >
+ : traits<PermutationMatrix<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex> >
+{
+  typedef Map<const Matrix<_StorageIndex,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1>, _PacketAccess> IndicesType;
+  typedef _StorageIndex StorageIndex;
+  typedef TranspositionsStorage StorageKind;
+};
+}
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int PacketAccess>
+class Map<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex>,PacketAccess>
+ : public TranspositionsBase<Map<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndex>,PacketAccess> >
+{
+    typedef internal::traits<Map> Traits;
+  public:
+
+    typedef TranspositionsBase<Map> Base;
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+
+    explicit inline Map(const StorageIndex* indicesPtr)
+      : m_indices(indicesPtr)
+    {}
+
+    inline Map(const StorageIndex* indicesPtr, Index size)
+      : m_indices(indicesPtr,size)
+    {}
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    Map& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      return Base::operator=(other);
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    Map& operator=(const Map& other)
+    {
+      m_indices = other.m_indices;
+      return *this;
+    }
+    #endif
+
+    /** const version of indices(). */
+    EIGEN_DEVICE_FUNC
+    const IndicesType& indices() const { return m_indices; }
+
+    /** \returns a reference to the stored array representing the transpositions. */
+    EIGEN_DEVICE_FUNC
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    IndicesType m_indices;
+};
+
+namespace internal {
+template<typename _IndicesType>
+struct traits<TranspositionsWrapper<_IndicesType> >
+ : traits<PermutationWrapper<_IndicesType> >
+{
+  typedef TranspositionsStorage StorageKind;
+};
+}
+
+template<typename _IndicesType>
+class TranspositionsWrapper
+ : public TranspositionsBase<TranspositionsWrapper<_IndicesType> >
+{
+    typedef internal::traits<TranspositionsWrapper> Traits;
+  public:
+
+    typedef TranspositionsBase<TranspositionsWrapper> Base;
+    typedef typename Traits::IndicesType IndicesType;
+    typedef typename IndicesType::Scalar StorageIndex;
+
+    explicit inline TranspositionsWrapper(IndicesType& indices)
+      : m_indices(indices)
+    {}
+
+    /** Copies the \a other transpositions into \c *this */
+    template<typename OtherDerived>
+    TranspositionsWrapper& operator=(const TranspositionsBase<OtherDerived>& other)
+    {
+      return Base::operator=(other);
+    }
+
+    /** const version of indices(). */
+    EIGEN_DEVICE_FUNC
+    const IndicesType& indices() const { return m_indices; }
+
+    /** \returns a reference to the stored array representing the transpositions. */
+    EIGEN_DEVICE_FUNC
+    IndicesType& indices() { return m_indices; }
+
+  protected:
+
+    typename IndicesType::Nested m_indices;
+};
+
+
+
+/** \returns the \a matrix with the \a transpositions applied to the columns.
+  */
+template<typename MatrixDerived, typename TranspositionsDerived>
+EIGEN_DEVICE_FUNC
+const Product<MatrixDerived, TranspositionsDerived, AliasFreeProduct>
+operator*(const MatrixBase<MatrixDerived> &matrix,
+          const TranspositionsBase<TranspositionsDerived>& transpositions)
+{
+  return Product<MatrixDerived, TranspositionsDerived, AliasFreeProduct>
+            (matrix.derived(), transpositions.derived());
+}
+
+/** \returns the \a matrix with the \a transpositions applied to the rows.
+  */
+template<typename TranspositionsDerived, typename MatrixDerived>
+EIGEN_DEVICE_FUNC
+const Product<TranspositionsDerived, MatrixDerived, AliasFreeProduct>
+operator*(const TranspositionsBase<TranspositionsDerived> &transpositions,
+          const MatrixBase<MatrixDerived>& matrix)
+{
+  return Product<TranspositionsDerived, MatrixDerived, AliasFreeProduct>
+            (transpositions.derived(), matrix.derived());
+}
+
+// Template partial specialization for transposed/inverse transpositions
+
+namespace internal {
+
+template<typename Derived>
+struct traits<Transpose<TranspositionsBase<Derived> > >
+ : traits<Derived>
+{};
+
+} // end namespace internal
+
+template<typename TranspositionsDerived>
+class Transpose<TranspositionsBase<TranspositionsDerived> >
+{
+    typedef TranspositionsDerived TranspositionType;
+    typedef typename TranspositionType::IndicesType IndicesType;
+  public:
+
+    explicit Transpose(const TranspositionType& t) : m_transpositions(t) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index size() const EIGEN_NOEXCEPT { return m_transpositions.size(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return m_transpositions.size(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return m_transpositions.size(); }
+
+    /** \returns the \a matrix with the inverse transpositions applied to the columns.
+      */
+    template<typename OtherDerived> friend
+    const Product<OtherDerived, Transpose, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix, const Transpose& trt)
+    {
+      return Product<OtherDerived, Transpose, AliasFreeProduct>(matrix.derived(), trt);
+    }
+
+    /** \returns the \a matrix with the inverse transpositions applied to the rows.
+      */
+    template<typename OtherDerived>
+    const Product<Transpose, OtherDerived, AliasFreeProduct>
+    operator*(const MatrixBase<OtherDerived>& matrix) const
+    {
+      return Product<Transpose, OtherDerived, AliasFreeProduct>(*this, matrix.derived());
+    }
+
+    EIGEN_DEVICE_FUNC
+    const TranspositionType& nestedExpression() const { return m_transpositions; }
+
+  protected:
+    const TranspositionType& m_transpositions;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSPOSITIONS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/TriangularMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/TriangularMatrix.h
new file mode 100644
index 00000000..fdb8bc15
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/TriangularMatrix.h
@@ -0,0 +1,1001 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULARMATRIX_H
+#define EIGEN_TRIANGULARMATRIX_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<int Side, typename TriangularType, typename Rhs> struct triangular_solve_retval;
+
+}
+
+/** \class TriangularBase
+  * \ingroup Core_Module
+  *
+  * \brief Base class for triangular part in a matrix
+  */
+template<typename Derived> class TriangularBase : public EigenBase<Derived>
+{
+  public:
+
+    enum {
+      Mode = internal::traits<Derived>::Mode,
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+      MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
+
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                   internal::traits<Derived>::ColsAtCompileTime>::ret),
+      /**< This is equal to the number of coefficients, i.e. the number of
+          * rows times the number of columns, or to \a Dynamic if this is not
+          * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
+
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime,
+                                                   internal::traits<Derived>::MaxColsAtCompileTime>::ret)
+
+    };
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+    typedef typename internal::traits<Derived>::FullMatrixType DenseMatrixType;
+    typedef DenseMatrixType DenseType;
+    typedef Derived const& Nested;
+
+    EIGEN_DEVICE_FUNC
+    inline TriangularBase() { eigen_assert(!((int(Mode) & int(UnitDiag)) && (int(Mode) & int(ZeroDiag)))); }
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return derived().rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return derived().cols(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index outerStride() const EIGEN_NOEXCEPT { return derived().outerStride(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index innerStride() const EIGEN_NOEXCEPT { return derived().innerStride(); }
+
+    // dummy resize function
+    EIGEN_DEVICE_FUNC
+    void resize(Index rows, Index cols)
+    {
+      EIGEN_UNUSED_VARIABLE(rows);
+      EIGEN_UNUSED_VARIABLE(cols);
+      eigen_assert(rows==this->rows() && cols==this->cols());
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar coeff(Index row, Index col) const  { return derived().coeff(row,col); }
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index col) { return derived().coeffRef(row,col); }
+
+    /** \see MatrixBase::copyCoeff(row,col)
+      */
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void copyCoeff(Index row, Index col, Other& other)
+    {
+      derived().coeffRef(row, col) = other.coeff(row, col);
+    }
+
+    EIGEN_DEVICE_FUNC
+    inline Scalar operator()(Index row, Index col) const
+    {
+      check_coordinates(row, col);
+      return coeff(row,col);
+    }
+    EIGEN_DEVICE_FUNC
+    inline Scalar& operator()(Index row, Index col)
+    {
+      check_coordinates(row, col);
+      return coeffRef(row,col);
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    EIGEN_DEVICE_FUNC
+    inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    EIGEN_DEVICE_FUNC
+    inline Derived& derived() { return *static_cast<Derived*>(this); }
+    #endif // not EIGEN_PARSED_BY_DOXYGEN
+
+    template<typename DenseDerived>
+    EIGEN_DEVICE_FUNC
+    void evalTo(MatrixBase<DenseDerived> &other) const;
+    template<typename DenseDerived>
+    EIGEN_DEVICE_FUNC
+    void evalToLazy(MatrixBase<DenseDerived> &other) const;
+
+    EIGEN_DEVICE_FUNC
+    DenseMatrixType toDenseMatrix() const
+    {
+      DenseMatrixType res(rows(), cols());
+      evalToLazy(res);
+      return res;
+    }
+
+  protected:
+
+    void check_coordinates(Index row, Index col) const
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(row);
+      EIGEN_ONLY_USED_FOR_DEBUG(col);
+      eigen_assert(col>=0 && col<cols() && row>=0 && row<rows());
+      const int mode = int(Mode) & ~SelfAdjoint;
+      EIGEN_ONLY_USED_FOR_DEBUG(mode);
+      eigen_assert((mode==Upper && col>=row)
+                || (mode==Lower && col<=row)
+                || ((mode==StrictlyUpper || mode==UnitUpper) && col>row)
+                || ((mode==StrictlyLower || mode==UnitLower) && col<row));
+    }
+
+    #ifdef EIGEN_INTERNAL_DEBUGGING
+    void check_coordinates_internal(Index row, Index col) const
+    {
+      check_coordinates(row, col);
+    }
+    #else
+    void check_coordinates_internal(Index , Index ) const {}
+    #endif
+
+};
+
+/** \class TriangularView
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a triangular part in a matrix
+  *
+  * \param MatrixType the type of the object in which we are taking the triangular part
+  * \param Mode the kind of triangular matrix expression to construct. Can be #Upper,
+  *             #Lower, #UnitUpper, #UnitLower, #StrictlyUpper, or #StrictlyLower.
+  *             This is in fact a bit field; it must have either #Upper or #Lower,
+  *             and additionally it may have #UnitDiag or #ZeroDiag or neither.
+  *
+  * This class represents a triangular part of a matrix, not necessarily square. Strictly speaking, for rectangular
+  * matrices one should speak of "trapezoid" parts. This class is the return type
+  * of MatrixBase::triangularView() and SparseMatrixBase::triangularView(), and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::triangularView()
+  */
+namespace internal {
+template<typename MatrixType, unsigned int _Mode>
+struct traits<TriangularView<MatrixType, _Mode> > : traits<MatrixType>
+{
+  typedef typename ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
+  typedef typename remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
+  typedef typename MatrixType::PlainObject FullMatrixType;
+  typedef MatrixType ExpressionType;
+  enum {
+    Mode = _Mode,
+    FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
+    Flags = (MatrixTypeNestedCleaned::Flags & (HereditaryBits | FlagsLvalueBit) & (~(PacketAccessBit | DirectAccessBit | LinearAccessBit)))
+  };
+};
+}
+
+template<typename _MatrixType, unsigned int _Mode, typename StorageKind> class TriangularViewImpl;
+
+template<typename _MatrixType, unsigned int _Mode> class TriangularView
+  : public TriangularViewImpl<_MatrixType, _Mode, typename internal::traits<_MatrixType>::StorageKind >
+{
+  public:
+
+    typedef TriangularViewImpl<_MatrixType, _Mode, typename internal::traits<_MatrixType>::StorageKind > Base;
+    typedef typename internal::traits<TriangularView>::Scalar Scalar;
+    typedef _MatrixType MatrixType;
+
+  protected:
+    typedef typename internal::traits<TriangularView>::MatrixTypeNested MatrixTypeNested;
+    typedef typename internal::traits<TriangularView>::MatrixTypeNestedNonRef MatrixTypeNestedNonRef;
+
+    typedef typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType;
+    typedef TriangularView<typename internal::add_const<MatrixType>::type, _Mode> ConstTriangularView;
+
+  public:
+
+    typedef typename internal::traits<TriangularView>::StorageKind StorageKind;
+    typedef typename internal::traits<TriangularView>::MatrixTypeNestedCleaned NestedExpression;
+
+    enum {
+      Mode = _Mode,
+      Flags = internal::traits<TriangularView>::Flags,
+      TransposeMode = (Mode & Upper ? Lower : 0)
+                    | (Mode & Lower ? Upper : 0)
+                    | (Mode & (UnitDiag))
+                    | (Mode & (ZeroDiag)),
+      IsVectorAtCompileTime = false
+    };
+
+    EIGEN_DEVICE_FUNC
+    explicit inline TriangularView(MatrixType& matrix) : m_matrix(matrix)
+    {}
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TriangularView)
+
+    /** \copydoc EigenBase::rows() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    /** \copydoc EigenBase::cols() */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+    /** \returns a const reference to the nested expression */
+    EIGEN_DEVICE_FUNC
+    const NestedExpression& nestedExpression() const { return m_matrix; }
+
+    /** \returns a reference to the nested expression */
+    EIGEN_DEVICE_FUNC
+    NestedExpression& nestedExpression() { return m_matrix; }
+
+    typedef TriangularView<const MatrixConjugateReturnType,Mode> ConjugateReturnType;
+    /** \sa MatrixBase::conjugate() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConjugateReturnType conjugate() const
+    { return ConjugateReturnType(m_matrix.conjugate()); }
+
+    /** \returns an expression of the complex conjugate of \c *this if Cond==true,
+     *           returns \c *this otherwise.
+     */
+    template<bool Cond>
+    EIGEN_DEVICE_FUNC
+    inline typename internal::conditional<Cond,ConjugateReturnType,ConstTriangularView>::type
+    conjugateIf() const
+    {
+      typedef typename internal::conditional<Cond,ConjugateReturnType,ConstTriangularView>::type ReturnType;
+      return ReturnType(m_matrix.template conjugateIf<Cond>());
+    }
+
+    typedef TriangularView<const typename MatrixType::AdjointReturnType,TransposeMode> AdjointReturnType;
+    /** \sa MatrixBase::adjoint() const */
+    EIGEN_DEVICE_FUNC
+    inline const AdjointReturnType adjoint() const
+    { return AdjointReturnType(m_matrix.adjoint()); }
+
+    typedef TriangularView<typename MatrixType::TransposeReturnType,TransposeMode> TransposeReturnType;
+     /** \sa MatrixBase::transpose() */
+    EIGEN_DEVICE_FUNC
+    inline TransposeReturnType transpose()
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+      typename MatrixType::TransposeReturnType tmp(m_matrix);
+      return TransposeReturnType(tmp);
+    }
+
+    typedef TriangularView<const typename MatrixType::ConstTransposeReturnType,TransposeMode> ConstTransposeReturnType;
+    /** \sa MatrixBase::transpose() const */
+    EIGEN_DEVICE_FUNC
+    inline const ConstTransposeReturnType transpose() const
+    {
+      return ConstTransposeReturnType(m_matrix.transpose());
+    }
+
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    inline const Solve<TriangularView, Other>
+    solve(const MatrixBase<Other>& other) const
+    { return Solve<TriangularView, Other>(*this, other.derived()); }
+
+  // workaround MSVC ICE
+  #if EIGEN_COMP_MSVC
+    template<int Side, typename Other>
+    EIGEN_DEVICE_FUNC
+    inline const internal::triangular_solve_retval<Side,TriangularView, Other>
+    solve(const MatrixBase<Other>& other) const
+    { return Base::template solve<Side>(other); }
+  #else
+    using Base::solve;
+  #endif
+
+    /** \returns a selfadjoint view of the referenced triangular part which must be either \c #Upper or \c #Lower.
+      *
+      * This is a shortcut for \code this->nestedExpression().selfadjointView<(*this)::Mode>() \endcode
+      * \sa MatrixBase::selfadjointView() */
+    EIGEN_DEVICE_FUNC
+    SelfAdjointView<MatrixTypeNestedNonRef,Mode> selfadjointView()
+    {
+      EIGEN_STATIC_ASSERT((Mode&(UnitDiag|ZeroDiag))==0,PROGRAMMING_ERROR);
+      return SelfAdjointView<MatrixTypeNestedNonRef,Mode>(m_matrix);
+    }
+
+    /** This is the const version of selfadjointView() */
+    EIGEN_DEVICE_FUNC
+    const SelfAdjointView<MatrixTypeNestedNonRef,Mode> selfadjointView() const
+    {
+      EIGEN_STATIC_ASSERT((Mode&(UnitDiag|ZeroDiag))==0,PROGRAMMING_ERROR);
+      return SelfAdjointView<MatrixTypeNestedNonRef,Mode>(m_matrix);
+    }
+
+
+    /** \returns the determinant of the triangular matrix
+      * \sa MatrixBase::determinant() */
+    EIGEN_DEVICE_FUNC
+    Scalar determinant() const
+    {
+      if (Mode & UnitDiag)
+        return 1;
+      else if (Mode & ZeroDiag)
+        return 0;
+      else
+        return m_matrix.diagonal().prod();
+    }
+
+  protected:
+
+    MatrixTypeNested m_matrix;
+};
+
+/** \ingroup Core_Module
+  *
+  * \brief Base class for a triangular part in a \b dense matrix
+  *
+  * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be instantiated.
+  * It extends class TriangularView with additional methods which available for dense expressions only.
+  *
+  * \sa class TriangularView, MatrixBase::triangularView()
+  */
+template<typename _MatrixType, unsigned int _Mode> class TriangularViewImpl<_MatrixType,_Mode,Dense>
+  : public TriangularBase<TriangularView<_MatrixType, _Mode> >
+{
+  public:
+
+    typedef TriangularView<_MatrixType, _Mode> TriangularViewType;
+    typedef TriangularBase<TriangularViewType> Base;
+    typedef typename internal::traits<TriangularViewType>::Scalar Scalar;
+
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::PlainObject DenseMatrixType;
+    typedef DenseMatrixType PlainObject;
+
+  public:
+    using Base::evalToLazy;
+    using Base::derived;
+
+    typedef typename internal::traits<TriangularViewType>::StorageKind StorageKind;
+
+    enum {
+      Mode = _Mode,
+      Flags = internal::traits<TriangularViewType>::Flags
+    };
+
+    /** \returns the outer-stride of the underlying dense matrix
+      * \sa DenseCoeffsBase::outerStride() */
+    EIGEN_DEVICE_FUNC
+    inline Index outerStride() const { return derived().nestedExpression().outerStride(); }
+    /** \returns the inner-stride of the underlying dense matrix
+      * \sa DenseCoeffsBase::innerStride() */
+    EIGEN_DEVICE_FUNC
+    inline Index innerStride() const { return derived().nestedExpression().innerStride(); }
+
+    /** \sa MatrixBase::operator+=() */
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator+=(const DenseBase<Other>& other) {
+      internal::call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename Other::Scalar>());
+      return derived();
+    }
+    /** \sa MatrixBase::operator-=() */
+    template<typename Other>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator-=(const DenseBase<Other>& other) {
+      internal::call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename Other::Scalar>());
+      return derived();
+    }
+
+    /** \sa MatrixBase::operator*=() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator*=(const typename internal::traits<MatrixType>::Scalar& other) { return *this = derived().nestedExpression() * other; }
+    /** \sa DenseBase::operator/=() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType&  operator/=(const typename internal::traits<MatrixType>::Scalar& other) { return *this = derived().nestedExpression() / other; }
+
+    /** \sa MatrixBase::fill() */
+    EIGEN_DEVICE_FUNC
+    void fill(const Scalar& value) { setConstant(value); }
+    /** \sa MatrixBase::setConstant() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& setConstant(const Scalar& value)
+    { return *this = MatrixType::Constant(derived().rows(), derived().cols(), value); }
+    /** \sa MatrixBase::setZero() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& setZero() { return setConstant(Scalar(0)); }
+    /** \sa MatrixBase::setOnes() */
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& setOnes() { return setConstant(Scalar(1)); }
+
+    /** \sa MatrixBase::coeff()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar coeff(Index row, Index col) const
+    {
+      Base::check_coordinates_internal(row, col);
+      return derived().nestedExpression().coeff(row, col);
+    }
+
+    /** \sa MatrixBase::coeffRef()
+      * \warning the coordinates must fit into the referenced triangular part
+      */
+    EIGEN_DEVICE_FUNC
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(TriangularViewType);
+      Base::check_coordinates_internal(row, col);
+      return derived().nestedExpression().coeffRef(row, col);
+    }
+
+    /** Assigns a triangular matrix to a triangular part of a dense matrix */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& operator=(const TriangularBase<OtherDerived>& other);
+
+    /** Shortcut for\code *this = other.other.triangularView<(*this)::Mode>() \endcode */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& operator=(const MatrixBase<OtherDerived>& other);
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    EIGEN_DEVICE_FUNC
+    TriangularViewType& operator=(const TriangularViewImpl& other)
+    { return *this = other.derived().nestedExpression(); }
+
+    template<typename OtherDerived>
+    /** \deprecated */
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
+    void lazyAssign(const TriangularBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    /** \deprecated */
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
+    void lazyAssign(const MatrixBase<OtherDerived>& other);
+#endif
+
+    /** Efficient triangular matrix times vector/matrix product */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const Product<TriangularViewType,OtherDerived>
+    operator*(const MatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<TriangularViewType,OtherDerived>(derived(), rhs.derived());
+    }
+
+    /** Efficient vector/matrix times triangular matrix product */
+    template<typename OtherDerived> friend
+    EIGEN_DEVICE_FUNC
+    const Product<OtherDerived,TriangularViewType>
+    operator*(const MatrixBase<OtherDerived>& lhs, const TriangularViewImpl& rhs)
+    {
+      return Product<OtherDerived,TriangularViewType>(lhs.derived(),rhs.derived());
+    }
+
+    /** \returns the product of the inverse of \c *this with \a other, \a *this being triangular.
+      *
+      * This function computes the inverse-matrix matrix product inverse(\c *this) * \a other if
+      * \a Side==OnTheLeft (the default), or the right-inverse-multiply  \a other * inverse(\c *this) if
+      * \a Side==OnTheRight.
+      *
+      * Note that the template parameter \c Side can be omitted, in which case \c Side==OnTheLeft
+      *
+      * The matrix \c *this must be triangular and invertible (i.e., all the coefficients of the
+      * diagonal must be non zero). It works as a forward (resp. backward) substitution if \c *this
+      * is an upper (resp. lower) triangular matrix.
+      *
+      * Example: \include Triangular_solve.cpp
+      * Output: \verbinclude Triangular_solve.out
+      *
+      * This function returns an expression of the inverse-multiply and can works in-place if it is assigned
+      * to the same matrix or vector \a other.
+      *
+      * For users coming from BLAS, this function (and more specifically solveInPlace()) offer
+      * all the operations supported by the \c *TRSV and \c *TRSM BLAS routines.
+      *
+      * \sa TriangularView::solveInPlace()
+      */
+    template<int Side, typename Other>
+    inline const internal::triangular_solve_retval<Side,TriangularViewType, Other>
+    solve(const MatrixBase<Other>& other) const;
+
+    /** "in-place" version of TriangularView::solve() where the result is written in \a other
+      *
+      * \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here.
+      * This function will const_cast it, so constness isn't honored here.
+      *
+      * Note that the template parameter \c Side can be omitted, in which case \c Side==OnTheLeft
+      *
+      * See TriangularView:solve() for the details.
+      */
+    template<int Side, typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void solveInPlace(const MatrixBase<OtherDerived>& other) const;
+
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    void solveInPlace(const MatrixBase<OtherDerived>& other) const
+    { return solveInPlace<OnTheLeft>(other); }
+
+    /** Swaps the coefficients of the common triangular parts of two matrices */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+    void swap(TriangularBase<OtherDerived> &other)
+#else
+    void swap(TriangularBase<OtherDerived> const & other)
+#endif
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(OtherDerived);
+      call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    /** Shortcut for \code (*this).swap(other.triangularView<(*this)::Mode>()) \endcode */
+    template<typename OtherDerived>
+    /** \deprecated */
+    EIGEN_DEPRECATED EIGEN_DEVICE_FUNC
+    void swap(MatrixBase<OtherDerived> const & other)
+    {
+      EIGEN_STATIC_ASSERT_LVALUE(OtherDerived);
+      call_assignment(derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
+    }
+
+    template<typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _solve_impl(const RhsType &rhs, DstType &dst) const {
+      if(!internal::is_same_dense(dst,rhs))
+        dst = rhs;
+      this->solveInPlace(dst);
+    }
+
+    template<typename ProductType>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE TriangularViewType& _assignProduct(const ProductType& prod, const Scalar& alpha, bool beta);
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(TriangularViewImpl)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(TriangularViewImpl)
+
+};
+
+/***************************************************************************
+* Implementation of triangular evaluation/assignment
+***************************************************************************/
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+// FIXME should we keep that possibility
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline TriangularView<MatrixType, Mode>&
+TriangularViewImpl<MatrixType, Mode, Dense>::operator=(const MatrixBase<OtherDerived>& other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+// FIXME should we keep that possibility
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const MatrixBase<OtherDerived>& other)
+{
+  internal::call_assignment_no_alias(derived(), other.template triangularView<Mode>());
+}
+
+
+
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline TriangularView<MatrixType, Mode>&
+TriangularViewImpl<MatrixType, Mode, Dense>::operator=(const TriangularBase<OtherDerived>& other)
+{
+  eigen_assert(Mode == int(OtherDerived::Mode));
+  internal::call_assignment(derived(), other.derived());
+  return derived();
+}
+
+template<typename MatrixType, unsigned int Mode>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(const TriangularBase<OtherDerived>& other)
+{
+  eigen_assert(Mode == int(OtherDerived::Mode));
+  internal::call_assignment_no_alias(derived(), other.derived());
+}
+#endif
+
+/***************************************************************************
+* Implementation of TriangularBase methods
+***************************************************************************/
+
+/** Assigns a triangular or selfadjoint matrix to a dense matrix.
+  * If the matrix is triangular, the opposite part is set to zero. */
+template<typename Derived>
+template<typename DenseDerived>
+EIGEN_DEVICE_FUNC void TriangularBase<Derived>::evalTo(MatrixBase<DenseDerived> &other) const
+{
+  evalToLazy(other.derived());
+}
+
+/***************************************************************************
+* Implementation of TriangularView methods
+***************************************************************************/
+
+/***************************************************************************
+* Implementation of MatrixBase methods
+***************************************************************************/
+
+/**
+  * \returns an expression of a triangular view extracted from the current matrix
+  *
+  * The parameter \a Mode can have the following values: \c #Upper, \c #StrictlyUpper, \c #UnitUpper,
+  * \c #Lower, \c #StrictlyLower, \c #UnitLower.
+  *
+  * Example: \include MatrixBase_triangularView.cpp
+  * Output: \verbinclude MatrixBase_triangularView.out
+  *
+  * \sa class TriangularView
+  */
+template<typename Derived>
+template<unsigned int Mode>
+EIGEN_DEVICE_FUNC
+typename MatrixBase<Derived>::template TriangularViewReturnType<Mode>::Type
+MatrixBase<Derived>::triangularView()
+{
+  return typename TriangularViewReturnType<Mode>::Type(derived());
+}
+
+/** This is the const version of MatrixBase::triangularView() */
+template<typename Derived>
+template<unsigned int Mode>
+EIGEN_DEVICE_FUNC
+typename MatrixBase<Derived>::template ConstTriangularViewReturnType<Mode>::Type
+MatrixBase<Derived>::triangularView() const
+{
+  return typename ConstTriangularViewReturnType<Mode>::Type(derived());
+}
+
+/** \returns true if *this is approximately equal to an upper triangular matrix,
+  *          within the precision given by \a prec.
+  *
+  * \sa isLowerTriangular()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isUpperTriangular(const RealScalar& prec) const
+{
+  RealScalar maxAbsOnUpperPart = static_cast<RealScalar>(-1);
+  for(Index j = 0; j < cols(); ++j)
+  {
+    Index maxi = numext::mini(j, rows()-1);
+    for(Index i = 0; i <= maxi; ++i)
+    {
+      RealScalar absValue = numext::abs(coeff(i,j));
+      if(absValue > maxAbsOnUpperPart) maxAbsOnUpperPart = absValue;
+    }
+  }
+  RealScalar threshold = maxAbsOnUpperPart * prec;
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = j+1; i < rows(); ++i)
+      if(numext::abs(coeff(i, j)) > threshold) return false;
+  return true;
+}
+
+/** \returns true if *this is approximately equal to a lower triangular matrix,
+  *          within the precision given by \a prec.
+  *
+  * \sa isUpperTriangular()
+  */
+template<typename Derived>
+bool MatrixBase<Derived>::isLowerTriangular(const RealScalar& prec) const
+{
+  RealScalar maxAbsOnLowerPart = static_cast<RealScalar>(-1);
+  for(Index j = 0; j < cols(); ++j)
+    for(Index i = j; i < rows(); ++i)
+    {
+      RealScalar absValue = numext::abs(coeff(i,j));
+      if(absValue > maxAbsOnLowerPart) maxAbsOnLowerPart = absValue;
+    }
+  RealScalar threshold = maxAbsOnLowerPart * prec;
+  for(Index j = 1; j < cols(); ++j)
+  {
+    Index maxi = numext::mini(j, rows()-1);
+    for(Index i = 0; i < maxi; ++i)
+      if(numext::abs(coeff(i, j)) > threshold) return false;
+  }
+  return true;
+}
+
+
+/***************************************************************************
+****************************************************************************
+* Evaluators and Assignment of triangular expressions
+***************************************************************************
+***************************************************************************/
+
+namespace internal {
+
+
+// TODO currently a triangular expression has the form TriangularView<.,.>
+//      in the future triangular-ness should be defined by the expression traits
+//      such that Transpose<TriangularView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
+template<typename MatrixType, unsigned int Mode>
+struct evaluator_traits<TriangularView<MatrixType,Mode> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef typename glue_shapes<typename evaluator_traits<MatrixType>::Shape, TriangularShape>::type Shape;
+};
+
+template<typename MatrixType, unsigned int Mode>
+struct unary_evaluator<TriangularView<MatrixType,Mode>, IndexBased>
+ : evaluator<typename internal::remove_all<MatrixType>::type>
+{
+  typedef TriangularView<MatrixType,Mode> XprType;
+  typedef evaluator<typename internal::remove_all<MatrixType>::type> Base;
+  EIGEN_DEVICE_FUNC
+  unary_evaluator(const XprType &xpr) : Base(xpr.nestedExpression()) {}
+};
+
+// Additional assignment kinds:
+struct Triangular2Triangular    {};
+struct Triangular2Dense         {};
+struct Dense2Triangular         {};
+
+
+template<typename Kernel, unsigned int Mode, int UnrollCount, bool ClearOpposite> struct triangular_assignment_loop;
+
+
+/** \internal Specialization of the dense assignment kernel for triangular matrices.
+  * The main difference is that the triangular, diagonal, and opposite parts are processed through three different functions.
+  * \tparam UpLo must be either Lower or Upper
+  * \tparam Mode must be either 0, UnitDiag, ZeroDiag, or SelfAdjoint
+  */
+template<int UpLo, int Mode, int SetOpposite, typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version = Specialized>
+class triangular_dense_assignment_kernel : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>
+{
+protected:
+  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> Base;
+  typedef typename Base::DstXprType DstXprType;
+  typedef typename Base::SrcXprType SrcXprType;
+  using Base::m_dst;
+  using Base::m_src;
+  using Base::m_functor;
+public:
+
+  typedef typename Base::DstEvaluatorType DstEvaluatorType;
+  typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
+  typedef typename Base::Scalar Scalar;
+  typedef typename Base::AssignmentTraits AssignmentTraits;
+
+
+  EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
+    : Base(dst, src, func, dstExpr)
+  {}
+
+#ifdef EIGEN_INTERNAL_DEBUGGING
+  EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
+  {
+    eigen_internal_assert(row!=col);
+    Base::assignCoeff(row,col);
+  }
+#else
+  using Base::assignCoeff;
+#endif
+
+  EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
+  {
+         if(Mode==UnitDiag && SetOpposite) m_functor.assignCoeff(m_dst.coeffRef(id,id), Scalar(1));
+    else if(Mode==ZeroDiag && SetOpposite) m_functor.assignCoeff(m_dst.coeffRef(id,id), Scalar(0));
+    else if(Mode==0)                       Base::assignCoeff(id,id);
+  }
+
+  EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index row, Index col)
+  {
+    eigen_internal_assert(row!=col);
+    if(SetOpposite)
+      m_functor.assignCoeff(m_dst.coeffRef(row,col), Scalar(0));
+  }
+};
+
+template<int Mode, bool SetOpposite, typename DstXprType, typename SrcXprType, typename Functor>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_triangular_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
+{
+  typedef evaluator<DstXprType> DstEvaluatorType;
+  typedef evaluator<SrcXprType> SrcEvaluatorType;
+
+  SrcEvaluatorType srcEvaluator(src);
+
+  Index dstRows = src.rows();
+  Index dstCols = src.cols();
+  if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+    dst.resize(dstRows, dstCols);
+  DstEvaluatorType dstEvaluator(dst);
+
+  typedef triangular_dense_assignment_kernel< Mode&(Lower|Upper),Mode&(UnitDiag|ZeroDiag|SelfAdjoint),SetOpposite,
+                                              DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
+  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+
+  enum {
+      unroll = DstXprType::SizeAtCompileTime != Dynamic
+            && SrcEvaluatorType::CoeffReadCost < HugeCost
+            && DstXprType::SizeAtCompileTime * (int(DstEvaluatorType::CoeffReadCost) + int(SrcEvaluatorType::CoeffReadCost)) / 2 <= EIGEN_UNROLLING_LIMIT
+    };
+
+  triangular_assignment_loop<Kernel, Mode, unroll ? int(DstXprType::SizeAtCompileTime) : Dynamic, SetOpposite>::run(kernel);
+}
+
+template<int Mode, bool SetOpposite, typename DstXprType, typename SrcXprType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+void call_triangular_assignment_loop(DstXprType& dst, const SrcXprType& src)
+{
+  call_triangular_assignment_loop<Mode,SetOpposite>(dst, src, internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
+}
+
+template<> struct AssignmentKind<TriangularShape,TriangularShape> { typedef Triangular2Triangular Kind; };
+template<> struct AssignmentKind<DenseShape,TriangularShape>      { typedef Triangular2Dense      Kind; };
+template<> struct AssignmentKind<TriangularShape,DenseShape>      { typedef Dense2Triangular      Kind; };
+
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Triangular2Triangular>
+{
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    eigen_assert(int(DstXprType::Mode) == int(SrcXprType::Mode));
+
+    call_triangular_assignment_loop<DstXprType::Mode, false>(dst, src, func);
+  }
+};
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Triangular2Dense>
+{
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    call_triangular_assignment_loop<SrcXprType::Mode, (int(SrcXprType::Mode) & int(SelfAdjoint)) == 0>(dst, src, func);
+  }
+};
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Dense2Triangular>
+{
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    call_triangular_assignment_loop<DstXprType::Mode, false>(dst, src, func);
+  }
+};
+
+
+template<typename Kernel, unsigned int Mode, int UnrollCount, bool SetOpposite>
+struct triangular_assignment_loop
+{
+  // FIXME: this is not very clean, perhaps this information should be provided by the kernel?
+  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
+  typedef typename DstEvaluatorType::XprType DstXprType;
+
+  enum {
+    col = (UnrollCount-1) / DstXprType::RowsAtCompileTime,
+    row = (UnrollCount-1) % DstXprType::RowsAtCompileTime
+  };
+
+  typedef typename Kernel::Scalar Scalar;
+
+  EIGEN_DEVICE_FUNC
+  static inline void run(Kernel &kernel)
+  {
+    triangular_assignment_loop<Kernel, Mode, UnrollCount-1, SetOpposite>::run(kernel);
+
+    if(row==col)
+      kernel.assignDiagonalCoeff(row);
+    else if( ((Mode&Lower) && row>col) || ((Mode&Upper) && row<col) )
+      kernel.assignCoeff(row,col);
+    else if(SetOpposite)
+      kernel.assignOppositeCoeff(row,col);
+  }
+};
+
+// prevent buggy user code from causing an infinite recursion
+template<typename Kernel, unsigned int Mode, bool SetOpposite>
+struct triangular_assignment_loop<Kernel, Mode, 0, SetOpposite>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(Kernel &) {}
+};
+
+
+
+// TODO: experiment with a recursive assignment procedure splitting the current
+//       triangular part into one rectangular and two triangular parts.
+
+
+template<typename Kernel, unsigned int Mode, bool SetOpposite>
+struct triangular_assignment_loop<Kernel, Mode, Dynamic, SetOpposite>
+{
+  typedef typename Kernel::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  static inline void run(Kernel &kernel)
+  {
+    for(Index j = 0; j < kernel.cols(); ++j)
+    {
+      Index maxi = numext::mini(j, kernel.rows());
+      Index i = 0;
+      if (((Mode&Lower) && SetOpposite) || (Mode&Upper))
+      {
+        for(; i < maxi; ++i)
+          if(Mode&Upper) kernel.assignCoeff(i, j);
+          else           kernel.assignOppositeCoeff(i, j);
+      }
+      else
+        i = maxi;
+
+      if(i<kernel.rows()) // then i==j
+        kernel.assignDiagonalCoeff(i++);
+
+      if (((Mode&Upper) && SetOpposite) || (Mode&Lower))
+      {
+        for(; i < kernel.rows(); ++i)
+          if(Mode&Lower) kernel.assignCoeff(i, j);
+          else           kernel.assignOppositeCoeff(i, j);
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+/** Assigns a triangular or selfadjoint matrix to a dense matrix.
+  * If the matrix is triangular, the opposite part is set to zero. */
+template<typename Derived>
+template<typename DenseDerived>
+EIGEN_DEVICE_FUNC void TriangularBase<Derived>::evalToLazy(MatrixBase<DenseDerived> &other) const
+{
+  other.derived().resize(this->rows(), this->cols());
+  internal::call_triangular_assignment_loop<Derived::Mode, (int(Derived::Mode) & int(SelfAdjoint)) == 0 /* SetOpposite */>(other.derived(), derived().nestedExpression());
+}
+
+namespace internal {
+
+// Triangular = Product
+template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular>
+{
+  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename SrcXprType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst._assignProduct(src, Scalar(1), false);
+  }
+};
+
+// Triangular += Product
+template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::add_assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular>
+{
+  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<Scalar,typename SrcXprType::Scalar> &)
+  {
+    dst._assignProduct(src, Scalar(1), true);
+  }
+};
+
+// Triangular -= Product
+template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
+struct Assignment<DstXprType, Product<Lhs,Rhs,DefaultProduct>, internal::sub_assign_op<Scalar,typename Product<Lhs,Rhs,DefaultProduct>::Scalar>, Dense2Triangular>
+{
+  typedef Product<Lhs,Rhs,DefaultProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<Scalar,typename SrcXprType::Scalar> &)
+  {
+    dst._assignProduct(src, Scalar(-1), true);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULARMATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/VectorBlock.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/VectorBlock.h
new file mode 100644
index 00000000..71c5b95e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/VectorBlock.h
@@ -0,0 +1,96 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_VECTORBLOCK_H
+#define EIGEN_VECTORBLOCK_H
+
+namespace Eigen { 
+
+namespace internal {
+template<typename VectorType, int Size>
+struct traits<VectorBlock<VectorType, Size> >
+  : public traits<Block<VectorType,
+                     traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
+                     traits<VectorType>::Flags & RowMajorBit ? Size : 1> >
+{
+};
+}
+
+/** \class VectorBlock
+  * \ingroup Core_Module
+  *
+  * \brief Expression of a fixed-size or dynamic-size sub-vector
+  *
+  * \tparam VectorType the type of the object in which we are taking a sub-vector
+  * \tparam Size size of the sub-vector we are taking at compile time (optional)
+  *
+  * This class represents an expression of either a fixed-size or dynamic-size sub-vector.
+  * It is the return type of DenseBase::segment(Index,Index) and DenseBase::segment<int>(Index) and
+  * most of the time this is the only way it is used.
+  *
+  * However, if you want to directly manipulate sub-vector expressions,
+  * for instance if you want to write a function returning such an expression, you
+  * will need to use this class.
+  *
+  * Here is an example illustrating the dynamic case:
+  * \include class_VectorBlock.cpp
+  * Output: \verbinclude class_VectorBlock.out
+  *
+  * \note Even though this expression has dynamic size, in the case where \a VectorType
+  * has fixed size, this expression inherits a fixed maximal size which means that evaluating
+  * it does not cause a dynamic memory allocation.
+  *
+  * Here is an example illustrating the fixed-size case:
+  * \include class_FixedVectorBlock.cpp
+  * Output: \verbinclude class_FixedVectorBlock.out
+  *
+  * \sa class Block, DenseBase::segment(Index,Index,Index,Index), DenseBase::segment(Index,Index)
+  */
+template<typename VectorType, int Size> class VectorBlock
+  : public Block<VectorType,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1>
+{
+    typedef Block<VectorType,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1> Base;
+    enum {
+      IsColVector = !(internal::traits<VectorType>::Flags & RowMajorBit)
+    };
+  public:
+    EIGEN_DENSE_PUBLIC_INTERFACE(VectorBlock)
+
+    using Base::operator=;
+
+    /** Dynamic-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    VectorBlock(VectorType& vector, Index start, Index size)
+      : Base(vector,
+             IsColVector ? start : 0, IsColVector ? 0 : start,
+             IsColVector ? size  : 1, IsColVector ? 1 : size)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorBlock);
+    }
+
+    /** Fixed-size constructor
+      */
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    VectorBlock(VectorType& vector, Index start)
+      : Base(vector, IsColVector ? start : 0, IsColVector ? 0 : start)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorBlock);
+    }
+};
+
+
+} // end namespace Eigen
+
+#endif // EIGEN_VECTORBLOCK_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/VectorwiseOp.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/VectorwiseOp.h
new file mode 100644
index 00000000..870f4f1e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/VectorwiseOp.h
@@ -0,0 +1,784 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2019 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARTIAL_REDUX_H
+#define EIGEN_PARTIAL_REDUX_H
+
+namespace Eigen {
+
+/** \class PartialReduxExpr
+  * \ingroup Core_Module
+  *
+  * \brief Generic expression of a partially reduxed matrix
+  *
+  * \tparam MatrixType the type of the matrix we are applying the redux operation
+  * \tparam MemberOp type of the member functor
+  * \tparam Direction indicates the direction of the redux (#Vertical or #Horizontal)
+  *
+  * This class represents an expression of a partial redux operator of a matrix.
+  * It is the return type of some VectorwiseOp functions,
+  * and most of the time this is the only way it is used.
+  *
+  * \sa class VectorwiseOp
+  */
+
+template< typename MatrixType, typename MemberOp, int Direction>
+class PartialReduxExpr;
+
+namespace internal {
+template<typename MatrixType, typename MemberOp, int Direction>
+struct traits<PartialReduxExpr<MatrixType, MemberOp, Direction> >
+ : traits<MatrixType>
+{
+  typedef typename MemberOp::result_type Scalar;
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename traits<MatrixType>::XprKind XprKind;
+  typedef typename MatrixType::Scalar InputScalar;
+  enum {
+    RowsAtCompileTime = Direction==Vertical   ? 1 : MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = Direction==Vertical   ? 1 : MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::MaxColsAtCompileTime,
+    Flags = RowsAtCompileTime == 1 ? RowMajorBit : 0,
+    TraversalSize = Direction==Vertical ? MatrixType::RowsAtCompileTime :  MatrixType::ColsAtCompileTime
+  };
+};
+}
+
+template< typename MatrixType, typename MemberOp, int Direction>
+class PartialReduxExpr : public internal::dense_xpr_base< PartialReduxExpr<MatrixType, MemberOp, Direction> >::type,
+                         internal::no_assignment_operator
+{
+  public:
+
+    typedef typename internal::dense_xpr_base<PartialReduxExpr>::type Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(PartialReduxExpr)
+
+    EIGEN_DEVICE_FUNC
+    explicit PartialReduxExpr(const MatrixType& mat, const MemberOp& func = MemberOp())
+      : m_matrix(mat), m_functor(func) {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return (Direction==Vertical   ? 1 : m_matrix.rows()); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return (Direction==Horizontal ? 1 : m_matrix.cols()); }
+
+    EIGEN_DEVICE_FUNC
+    typename MatrixType::Nested nestedExpression() const { return m_matrix; }
+
+    EIGEN_DEVICE_FUNC
+    const MemberOp& functor() const { return m_functor; }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+    const MemberOp m_functor;
+};
+
+template<typename A,typename B> struct partial_redux_dummy_func;
+
+#define EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(MEMBER,COST,VECTORIZABLE,BINARYOP)                \
+  template <typename ResultType,typename Scalar>                                                            \
+  struct member_##MEMBER {                                                                  \
+    EIGEN_EMPTY_STRUCT_CTOR(member_##MEMBER)                                                \
+    typedef ResultType result_type;                                                         \
+    typedef BINARYOP<Scalar,Scalar> BinaryOp;   \
+    template<int Size> struct Cost { enum { value = COST }; };             \
+    enum { Vectorizable = VECTORIZABLE };                                                   \
+    template<typename XprType>                                                              \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                   \
+    ResultType operator()(const XprType& mat) const                                         \
+    { return mat.MEMBER(); }                                                                \
+    BinaryOp binaryFunc() const { return BinaryOp(); }                                      \
+  }
+
+#define EIGEN_MEMBER_FUNCTOR(MEMBER,COST) \
+  EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(MEMBER,COST,0,partial_redux_dummy_func)
+
+namespace internal {
+
+EIGEN_MEMBER_FUNCTOR(norm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(stableNorm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(blueNorm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size-1) * functor_traits<scalar_hypot_op<Scalar> >::Cost );
+EIGEN_MEMBER_FUNCTOR(all, (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(any, (Size-1)*NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(count, (Size-1)*NumTraits<Scalar>::AddCost);
+
+EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(sum, (Size-1)*NumTraits<Scalar>::AddCost, 1, internal::scalar_sum_op);
+EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(minCoeff, (Size-1)*NumTraits<Scalar>::AddCost, 1, internal::scalar_min_op);
+EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(maxCoeff, (Size-1)*NumTraits<Scalar>::AddCost, 1, internal::scalar_max_op);
+EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(prod, (Size-1)*NumTraits<Scalar>::MulCost, 1, internal::scalar_product_op);
+
+template <int p, typename ResultType,typename Scalar>
+struct member_lpnorm {
+  typedef ResultType result_type;
+  enum { Vectorizable = 0 };
+  template<int Size> struct Cost
+  { enum { value = (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost }; };
+  EIGEN_DEVICE_FUNC member_lpnorm() {}
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC inline ResultType operator()(const XprType& mat) const
+  { return mat.template lpNorm<p>(); }
+};
+
+template <typename BinaryOpT, typename Scalar>
+struct member_redux {
+  typedef BinaryOpT BinaryOp;
+  typedef typename result_of<
+                     BinaryOp(const Scalar&,const Scalar&)
+                   >::type  result_type;
+
+  enum { Vectorizable = functor_traits<BinaryOp>::PacketAccess };
+  template<int Size> struct Cost { enum { value = (Size-1) * functor_traits<BinaryOp>::Cost }; };
+  EIGEN_DEVICE_FUNC explicit member_redux(const BinaryOp func) : m_functor(func) {}
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline result_type operator()(const DenseBase<Derived>& mat) const
+  { return mat.redux(m_functor); }
+  const BinaryOp& binaryFunc() const { return m_functor; }
+  const BinaryOp m_functor;
+};
+}
+
+/** \class VectorwiseOp
+  * \ingroup Core_Module
+  *
+  * \brief Pseudo expression providing broadcasting and partial reduction operations
+  *
+  * \tparam ExpressionType the type of the object on which to do partial reductions
+  * \tparam Direction indicates whether to operate on columns (#Vertical) or rows (#Horizontal)
+  *
+  * This class represents a pseudo expression with broadcasting and partial reduction features.
+  * It is the return type of DenseBase::colwise() and DenseBase::rowwise()
+  * and most of the time this is the only way it is explicitly used.
+  *
+  * To understand the logic of rowwise/colwise expression, let's consider a generic case `A.colwise().foo()`
+  * where `foo` is any method of `VectorwiseOp`. This expression is equivalent to applying `foo()` to each
+  * column of `A` and then re-assemble the outputs in a matrix expression:
+  * \code [A.col(0).foo(), A.col(1).foo(), ..., A.col(A.cols()-1).foo()] \endcode
+  *
+  * Example: \include MatrixBase_colwise.cpp
+  * Output: \verbinclude MatrixBase_colwise.out
+  *
+  * The begin() and end() methods are obviously exceptions to the previous rule as they
+  * return STL-compatible begin/end iterators to the rows or columns of the nested expression.
+  * Typical use cases include for-range-loop and calls to STL algorithms:
+  *
+  * Example: \include MatrixBase_colwise_iterator_cxx11.cpp
+  * Output: \verbinclude MatrixBase_colwise_iterator_cxx11.out
+  *
+  * For a partial reduction on an empty input, some rules apply.
+  * For the sake of clarity, let's consider a vertical reduction:
+  *   - If the number of columns is zero, then a 1x0 row-major vector expression is returned.
+  *   - Otherwise, if the number of rows is zero, then
+  *       - a row vector of zeros is returned for sum-like reductions (sum, squaredNorm, norm, etc.)
+  *       - a row vector of ones is returned for a product reduction (e.g., <code>MatrixXd(n,0).colwise().prod()</code>)
+  *       - an assert is triggered for all other reductions (minCoeff,maxCoeff,redux(bin_op))
+  *
+  * \sa DenseBase::colwise(), DenseBase::rowwise(), class PartialReduxExpr
+  */
+template<typename ExpressionType, int Direction> class VectorwiseOp
+{
+  public:
+
+    typedef typename ExpressionType::Scalar Scalar;
+    typedef typename ExpressionType::RealScalar RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    typedef typename internal::ref_selector<ExpressionType>::non_const_type ExpressionTypeNested;
+    typedef typename internal::remove_all<ExpressionTypeNested>::type ExpressionTypeNestedCleaned;
+
+    template<template<typename OutScalar,typename InputScalar> class Functor,
+                      typename ReturnScalar=Scalar> struct ReturnType
+    {
+      typedef PartialReduxExpr<ExpressionType,
+                               Functor<ReturnScalar,Scalar>,
+                               Direction
+                              > Type;
+    };
+
+    template<typename BinaryOp> struct ReduxReturnType
+    {
+      typedef PartialReduxExpr<ExpressionType,
+                               internal::member_redux<BinaryOp,Scalar>,
+                               Direction
+                              > Type;
+    };
+
+    enum {
+      isVertical   = (Direction==Vertical) ? 1 : 0,
+      isHorizontal = (Direction==Horizontal) ? 1 : 0
+    };
+
+  protected:
+
+    template<typename OtherDerived> struct ExtendedType {
+      typedef Replicate<OtherDerived,
+                        isVertical   ? 1 : ExpressionType::RowsAtCompileTime,
+                        isHorizontal ? 1 : ExpressionType::ColsAtCompileTime> Type;
+    };
+
+    /** \internal
+      * Replicates a vector to match the size of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    typename ExtendedType<OtherDerived>::Type
+    extendedTo(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isVertical, OtherDerived::MaxColsAtCompileTime==1),
+                          YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED)
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isHorizontal, OtherDerived::MaxRowsAtCompileTime==1),
+                          YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED)
+      return typename ExtendedType<OtherDerived>::Type
+                      (other.derived(),
+                       isVertical   ? 1 : m_matrix.rows(),
+                       isHorizontal ? 1 : m_matrix.cols());
+    }
+
+    template<typename OtherDerived> struct OppositeExtendedType {
+      typedef Replicate<OtherDerived,
+                        isHorizontal ? 1 : ExpressionType::RowsAtCompileTime,
+                        isVertical   ? 1 : ExpressionType::ColsAtCompileTime> Type;
+    };
+
+    /** \internal
+      * Replicates a vector in the opposite direction to match the size of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    typename OppositeExtendedType<OtherDerived>::Type
+    extendedToOpposite(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isHorizontal, OtherDerived::MaxColsAtCompileTime==1),
+                          YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED)
+      EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isVertical, OtherDerived::MaxRowsAtCompileTime==1),
+                          YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED)
+      return typename OppositeExtendedType<OtherDerived>::Type
+                      (other.derived(),
+                       isHorizontal  ? 1 : m_matrix.rows(),
+                       isVertical    ? 1 : m_matrix.cols());
+    }
+
+  public:
+    EIGEN_DEVICE_FUNC
+    explicit inline VectorwiseOp(ExpressionType& matrix) : m_matrix(matrix) {}
+
+    /** \internal */
+    EIGEN_DEVICE_FUNC
+    inline const ExpressionType& _expression() const { return m_matrix; }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** STL-like <a href="https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator">RandomAccessIterator</a>
+      * iterator type over the columns or rows as returned by the begin() and end() methods.
+      */
+    random_access_iterator_type iterator;
+    /** This is the const version of iterator (aka read-only) */
+    random_access_iterator_type const_iterator;
+    #else
+    typedef internal::subvector_stl_iterator<ExpressionType,               DirectionType(Direction)> iterator;
+    typedef internal::subvector_stl_iterator<const ExpressionType,         DirectionType(Direction)> const_iterator;
+    typedef internal::subvector_stl_reverse_iterator<ExpressionType,       DirectionType(Direction)> reverse_iterator;
+    typedef internal::subvector_stl_reverse_iterator<const ExpressionType, DirectionType(Direction)> const_reverse_iterator;
+    #endif
+
+    /** returns an iterator to the first row (rowwise) or column (colwise) of the nested expression.
+      * \sa end(), cbegin()
+      */
+    iterator                 begin()       { return iterator      (m_matrix, 0); }
+    /** const version of begin() */
+    const_iterator           begin() const { return const_iterator(m_matrix, 0); }
+    /** const version of begin() */
+    const_iterator          cbegin() const { return const_iterator(m_matrix, 0); }
+
+    /** returns a reverse iterator to the last row (rowwise) or column (colwise) of the nested expression.
+      * \sa rend(), crbegin()
+      */
+    reverse_iterator        rbegin()       { return reverse_iterator       (m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()-1); }
+	/** const version of rbegin() */
+    const_reverse_iterator  rbegin() const { return const_reverse_iterator (m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()-1); }
+	/** const version of rbegin() */
+	const_reverse_iterator crbegin() const { return const_reverse_iterator (m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()-1); }
+
+    /** returns an iterator to the row (resp. column) following the last row (resp. column) of the nested expression
+      * \sa begin(), cend()
+      */
+    iterator                 end()         { return iterator      (m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()); }
+    /** const version of end() */
+    const_iterator           end()  const  { return const_iterator(m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()); }
+    /** const version of end() */
+    const_iterator          cend()  const  { return const_iterator(m_matrix, m_matrix.template subVectors<DirectionType(Direction)>()); }
+
+    /** returns a reverse iterator to the row (resp. column) before the first row (resp. column) of the nested expression
+      * \sa begin(), cend()
+      */
+    reverse_iterator        rend()         { return reverse_iterator       (m_matrix, -1); }
+    /** const version of rend() */
+    const_reverse_iterator  rend()  const  { return const_reverse_iterator (m_matrix, -1); }
+    /** const version of rend() */
+    const_reverse_iterator crend()  const  { return const_reverse_iterator (m_matrix, -1); }
+
+    /** \returns a row or column vector expression of \c *this reduxed by \a func
+      *
+      * The template parameter \a BinaryOp is the type of the functor
+      * of the custom redux operator. Note that func must be an associative operator.
+      *
+      * \warning the size along the reduction direction must be strictly positive,
+      *          otherwise an assertion is triggered.
+      *
+      * \sa class VectorwiseOp, DenseBase::colwise(), DenseBase::rowwise()
+      */
+    template<typename BinaryOp>
+    EIGEN_DEVICE_FUNC
+    const typename ReduxReturnType<BinaryOp>::Type
+    redux(const BinaryOp& func = BinaryOp()) const
+    {
+      eigen_assert(redux_length()>0 && "you are using an empty matrix");
+      return typename ReduxReturnType<BinaryOp>::Type(_expression(), internal::member_redux<BinaryOp,Scalar>(func));
+    }
+
+    typedef typename ReturnType<internal::member_minCoeff>::Type MinCoeffReturnType;
+    typedef typename ReturnType<internal::member_maxCoeff>::Type MaxCoeffReturnType;
+    typedef PartialReduxExpr<const CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const ExpressionTypeNestedCleaned>,internal::member_sum<RealScalar,RealScalar>,Direction> SquaredNormReturnType;
+    typedef CwiseUnaryOp<internal::scalar_sqrt_op<RealScalar>, const SquaredNormReturnType> NormReturnType;
+    typedef typename ReturnType<internal::member_blueNorm,RealScalar>::Type BlueNormReturnType;
+    typedef typename ReturnType<internal::member_stableNorm,RealScalar>::Type StableNormReturnType;
+    typedef typename ReturnType<internal::member_hypotNorm,RealScalar>::Type HypotNormReturnType;
+    typedef typename ReturnType<internal::member_sum>::Type SumReturnType;
+    typedef EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(SumReturnType,Scalar,quotient) MeanReturnType;
+    typedef typename ReturnType<internal::member_all>::Type AllReturnType;
+    typedef typename ReturnType<internal::member_any>::Type AnyReturnType;
+    typedef PartialReduxExpr<ExpressionType, internal::member_count<Index,Scalar>, Direction> CountReturnType;
+    typedef typename ReturnType<internal::member_prod>::Type ProdReturnType;
+    typedef Reverse<const ExpressionType, Direction> ConstReverseReturnType;
+    typedef Reverse<ExpressionType, Direction> ReverseReturnType;
+
+    template<int p> struct LpNormReturnType {
+      typedef PartialReduxExpr<ExpressionType, internal::member_lpnorm<p,RealScalar,Scalar>,Direction> Type;
+    };
+
+    /** \returns a row (or column) vector expression of the smallest coefficient
+      * of each column (or row) of the referenced expression.
+      *
+      * \warning the size along the reduction direction must be strictly positive,
+      *          otherwise an assertion is triggered.
+      *
+      * \warning the result is undefined if \c *this contains NaN.
+      *
+      * Example: \include PartialRedux_minCoeff.cpp
+      * Output: \verbinclude PartialRedux_minCoeff.out
+      *
+      * \sa DenseBase::minCoeff() */
+    EIGEN_DEVICE_FUNC
+    const MinCoeffReturnType minCoeff() const
+    {
+      eigen_assert(redux_length()>0 && "you are using an empty matrix");
+      return MinCoeffReturnType(_expression());
+    }
+
+    /** \returns a row (or column) vector expression of the largest coefficient
+      * of each column (or row) of the referenced expression.
+      *
+      * \warning the size along the reduction direction must be strictly positive,
+      *          otherwise an assertion is triggered.
+      *
+      * \warning the result is undefined if \c *this contains NaN.
+      *
+      * Example: \include PartialRedux_maxCoeff.cpp
+      * Output: \verbinclude PartialRedux_maxCoeff.out
+      *
+      * \sa DenseBase::maxCoeff() */
+    EIGEN_DEVICE_FUNC
+    const MaxCoeffReturnType maxCoeff() const
+    {
+      eigen_assert(redux_length()>0 && "you are using an empty matrix");
+      return MaxCoeffReturnType(_expression());
+    }
+
+    /** \returns a row (or column) vector expression of the squared norm
+      * of each column (or row) of the referenced expression.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * Example: \include PartialRedux_squaredNorm.cpp
+      * Output: \verbinclude PartialRedux_squaredNorm.out
+      *
+      * \sa DenseBase::squaredNorm() */
+    EIGEN_DEVICE_FUNC
+    const SquaredNormReturnType squaredNorm() const
+    { return SquaredNormReturnType(m_matrix.cwiseAbs2()); }
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * Example: \include PartialRedux_norm.cpp
+      * Output: \verbinclude PartialRedux_norm.out
+      *
+      * \sa DenseBase::norm() */
+    EIGEN_DEVICE_FUNC
+    const NormReturnType norm() const
+    { return NormReturnType(squaredNorm()); }
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * Example: \include PartialRedux_norm.cpp
+      * Output: \verbinclude PartialRedux_norm.out
+      *
+      * \sa DenseBase::norm() */
+    template<int p>
+    EIGEN_DEVICE_FUNC
+    const typename LpNormReturnType<p>::Type lpNorm() const
+    { return typename LpNormReturnType<p>::Type(_expression()); }
+
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression, using
+      * Blue's algorithm.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * \sa DenseBase::blueNorm() */
+    EIGEN_DEVICE_FUNC
+    const BlueNormReturnType blueNorm() const
+    { return BlueNormReturnType(_expression()); }
+
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression, avoiding
+      * underflow and overflow.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * \sa DenseBase::stableNorm() */
+    EIGEN_DEVICE_FUNC
+    const StableNormReturnType stableNorm() const
+    { return StableNormReturnType(_expression()); }
+
+
+    /** \returns a row (or column) vector expression of the norm
+      * of each column (or row) of the referenced expression, avoiding
+      * underflow and overflow using a concatenation of hypot() calls.
+      * This is a vector with real entries, even if the original matrix has complex entries.
+      *
+      * \sa DenseBase::hypotNorm() */
+    EIGEN_DEVICE_FUNC
+    const HypotNormReturnType hypotNorm() const
+    { return HypotNormReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the sum
+      * of each column (or row) of the referenced expression.
+      *
+      * Example: \include PartialRedux_sum.cpp
+      * Output: \verbinclude PartialRedux_sum.out
+      *
+      * \sa DenseBase::sum() */
+    EIGEN_DEVICE_FUNC
+    const SumReturnType sum() const
+    { return SumReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the mean
+    * of each column (or row) of the referenced expression.
+    *
+    * \sa DenseBase::mean() */
+    EIGEN_DEVICE_FUNC
+    const MeanReturnType mean() const
+    { return sum() / Scalar(Direction==Vertical?m_matrix.rows():m_matrix.cols()); }
+
+    /** \returns a row (or column) vector expression representing
+      * whether \b all coefficients of each respective column (or row) are \c true.
+      * This expression can be assigned to a vector with entries of type \c bool.
+      *
+      * \sa DenseBase::all() */
+    EIGEN_DEVICE_FUNC
+    const AllReturnType all() const
+    { return AllReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression representing
+      * whether \b at \b least one coefficient of each respective column (or row) is \c true.
+      * This expression can be assigned to a vector with entries of type \c bool.
+      *
+      * \sa DenseBase::any() */
+    EIGEN_DEVICE_FUNC
+    const AnyReturnType any() const
+    { return AnyReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression representing
+      * the number of \c true coefficients of each respective column (or row).
+      * This expression can be assigned to a vector whose entries have the same type as is used to
+      * index entries of the original matrix; for dense matrices, this is \c std::ptrdiff_t .
+      *
+      * Example: \include PartialRedux_count.cpp
+      * Output: \verbinclude PartialRedux_count.out
+      *
+      * \sa DenseBase::count() */
+    EIGEN_DEVICE_FUNC
+    const CountReturnType count() const
+    { return CountReturnType(_expression()); }
+
+    /** \returns a row (or column) vector expression of the product
+      * of each column (or row) of the referenced expression.
+      *
+      * Example: \include PartialRedux_prod.cpp
+      * Output: \verbinclude PartialRedux_prod.out
+      *
+      * \sa DenseBase::prod() */
+    EIGEN_DEVICE_FUNC
+    const ProdReturnType prod() const
+    { return ProdReturnType(_expression()); }
+
+
+    /** \returns a matrix expression
+      * where each column (or row) are reversed.
+      *
+      * Example: \include Vectorwise_reverse.cpp
+      * Output: \verbinclude Vectorwise_reverse.out
+      *
+      * \sa DenseBase::reverse() */
+    EIGEN_DEVICE_FUNC
+    const ConstReverseReturnType reverse() const
+    { return ConstReverseReturnType( _expression() ); }
+
+    /** \returns a writable matrix expression
+      * where each column (or row) are reversed.
+      *
+      * \sa reverse() const */
+    EIGEN_DEVICE_FUNC
+    ReverseReturnType reverse()
+    { return ReverseReturnType( _expression() ); }
+
+    typedef Replicate<ExpressionType,(isVertical?Dynamic:1),(isHorizontal?Dynamic:1)> ReplicateReturnType;
+    EIGEN_DEVICE_FUNC
+    const ReplicateReturnType replicate(Index factor) const;
+
+    /**
+      * \return an expression of the replication of each column (or row) of \c *this
+      *
+      * Example: \include DirectionWise_replicate.cpp
+      * Output: \verbinclude DirectionWise_replicate.out
+      *
+      * \sa VectorwiseOp::replicate(Index), DenseBase::replicate(), class Replicate
+      */
+    // NOTE implemented here because of sunstudio's compilation errors
+    // isVertical*Factor+isHorizontal instead of (isVertical?Factor:1) to handle CUDA bug with ternary operator
+    template<int Factor> const Replicate<ExpressionType,isVertical*Factor+isHorizontal,isHorizontal*Factor+isVertical>
+    EIGEN_DEVICE_FUNC
+    replicate(Index factor = Factor) const
+    {
+      return Replicate<ExpressionType,(isVertical?Factor:1),(isHorizontal?Factor:1)>
+          (_expression(),isVertical?factor:1,isHorizontal?factor:1);
+    }
+
+/////////// Artithmetic operators ///////////
+
+    /** Copies the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      //eigen_assert((m_matrix.isNull()) == (other.isNull())); FIXME
+      return m_matrix = extendedTo(other.derived());
+    }
+
+    /** Adds the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator+=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix += extendedTo(other.derived());
+    }
+
+    /** Substracts the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator-=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix -= extendedTo(other.derived());
+    }
+
+    /** Multiples each subvector of \c *this by the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator*=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      m_matrix *= extendedTo(other.derived());
+      return m_matrix;
+    }
+
+    /** Divides each subvector of \c *this by the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    ExpressionType& operator/=(const DenseBase<OtherDerived>& other)
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      m_matrix /= extendedTo(other.derived());
+      return m_matrix;
+    }
+
+    /** Returns the expression of the sum of the vector \a other to each subvector of \c *this */
+    template<typename OtherDerived> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_sum_op<Scalar,typename OtherDerived::Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    operator+(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix + extendedTo(other.derived());
+    }
+
+    /** Returns the expression of the difference between each subvector of \c *this and the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_difference_op<Scalar,typename OtherDerived::Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    operator-(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix - extendedTo(other.derived());
+    }
+
+    /** Returns the expression where each subvector is the product of the vector \a other
+      * by the corresponding subvector of \c *this */
+    template<typename OtherDerived> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_product_op<Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    EIGEN_DEVICE_FUNC
+    operator*(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix * extendedTo(other.derived());
+    }
+
+    /** Returns the expression where each subvector is the quotient of the corresponding
+      * subvector of \c *this by the vector \a other */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_quotient_op<Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename ExtendedType<OtherDerived>::Type>
+    operator/(const DenseBase<OtherDerived>& other) const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+      EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+      EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+      return m_matrix / extendedTo(other.derived());
+    }
+
+    /** \returns an expression where each column (or row) of the referenced matrix are normalized.
+      * The referenced matrix is \b not modified.
+      * \sa MatrixBase::normalized(), normalize()
+      */
+    EIGEN_DEVICE_FUNC
+    CwiseBinaryOp<internal::scalar_quotient_op<Scalar>,
+                  const ExpressionTypeNestedCleaned,
+                  const typename OppositeExtendedType<NormReturnType>::Type>
+    normalized() const { return m_matrix.cwiseQuotient(extendedToOpposite(this->norm())); }
+
+
+    /** Normalize in-place each row or columns of the referenced matrix.
+      * \sa MatrixBase::normalize(), normalized()
+      */
+    EIGEN_DEVICE_FUNC void normalize() {
+      m_matrix = this->normalized();
+    }
+
+    EIGEN_DEVICE_FUNC inline void reverseInPlace();
+
+/////////// Geometry module ///////////
+
+    typedef Homogeneous<ExpressionType,Direction> HomogeneousReturnType;
+    EIGEN_DEVICE_FUNC
+    HomogeneousReturnType homogeneous() const;
+
+    typedef typename ExpressionType::PlainObject CrossReturnType;
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC
+    const CrossReturnType cross(const MatrixBase<OtherDerived>& other) const;
+
+    enum {
+      HNormalized_Size = Direction==Vertical ? internal::traits<ExpressionType>::RowsAtCompileTime
+                                             : internal::traits<ExpressionType>::ColsAtCompileTime,
+      HNormalized_SizeMinusOne = HNormalized_Size==Dynamic ? Dynamic : HNormalized_Size-1
+    };
+    typedef Block<const ExpressionType,
+                  Direction==Vertical   ? int(HNormalized_SizeMinusOne)
+                                        : int(internal::traits<ExpressionType>::RowsAtCompileTime),
+                  Direction==Horizontal ? int(HNormalized_SizeMinusOne)
+                                        : int(internal::traits<ExpressionType>::ColsAtCompileTime)>
+            HNormalized_Block;
+    typedef Block<const ExpressionType,
+                  Direction==Vertical   ? 1 : int(internal::traits<ExpressionType>::RowsAtCompileTime),
+                  Direction==Horizontal ? 1 : int(internal::traits<ExpressionType>::ColsAtCompileTime)>
+            HNormalized_Factors;
+    typedef CwiseBinaryOp<internal::scalar_quotient_op<typename internal::traits<ExpressionType>::Scalar>,
+                const HNormalized_Block,
+                const Replicate<HNormalized_Factors,
+                  Direction==Vertical   ? HNormalized_SizeMinusOne : 1,
+                  Direction==Horizontal ? HNormalized_SizeMinusOne : 1> >
+            HNormalizedReturnType;
+
+    EIGEN_DEVICE_FUNC
+    const HNormalizedReturnType hnormalized() const;
+
+#   ifdef EIGEN_VECTORWISEOP_PLUGIN
+#     include EIGEN_VECTORWISEOP_PLUGIN
+#   endif
+
+  protected:
+    Index redux_length() const
+    {
+      return Direction==Vertical ? m_matrix.rows() : m_matrix.cols();
+    }
+    ExpressionTypeNested m_matrix;
+};
+
+//const colwise moved to DenseBase.h due to CUDA compiler bug
+
+
+/** \returns a writable VectorwiseOp wrapper of *this providing additional partial reduction operations
+  *
+  * \sa rowwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::ColwiseReturnType
+DenseBase<Derived>::colwise()
+{
+  return ColwiseReturnType(derived());
+}
+
+//const rowwise moved to DenseBase.h due to CUDA compiler bug
+
+
+/** \returns a writable VectorwiseOp wrapper of *this providing additional partial reduction operations
+  *
+  * \sa colwise(), class VectorwiseOp, \ref TutorialReductionsVisitorsBroadcasting
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename DenseBase<Derived>::RowwiseReturnType
+DenseBase<Derived>::rowwise()
+{
+  return RowwiseReturnType(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIAL_REDUX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/Visitor.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Visitor.h
new file mode 100644
index 00000000..00bcca87
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/Visitor.h
@@ -0,0 +1,381 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_VISITOR_H
+#define EIGEN_VISITOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Visitor, typename Derived, int UnrollCount>
+struct visitor_impl
+{
+  enum {
+    col = (UnrollCount-1) / Derived::RowsAtCompileTime,
+    row = (UnrollCount-1) % Derived::RowsAtCompileTime
+  };
+
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived &mat, Visitor& visitor)
+  {
+    visitor_impl<Visitor, Derived, UnrollCount-1>::run(mat, visitor);
+    visitor(mat.coeff(row, col), row, col);
+  }
+};
+
+template<typename Visitor, typename Derived>
+struct visitor_impl<Visitor, Derived, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived &mat, Visitor& visitor)
+  {
+    return visitor.init(mat.coeff(0, 0), 0, 0);
+  }
+};
+
+// This specialization enables visitors on empty matrices at compile-time
+template<typename Visitor, typename Derived>
+struct visitor_impl<Visitor, Derived, 0> {
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived &/*mat*/, Visitor& /*visitor*/)
+  {}
+};
+
+template<typename Visitor, typename Derived>
+struct visitor_impl<Visitor, Derived, Dynamic>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const Derived& mat, Visitor& visitor)
+  {
+    visitor.init(mat.coeff(0,0), 0, 0);
+    for(Index i = 1; i < mat.rows(); ++i)
+      visitor(mat.coeff(i, 0), i, 0);
+    for(Index j = 1; j < mat.cols(); ++j)
+      for(Index i = 0; i < mat.rows(); ++i)
+        visitor(mat.coeff(i, j), i, j);
+  }
+};
+
+// evaluator adaptor
+template<typename XprType>
+class visitor_evaluator
+{
+public:
+  EIGEN_DEVICE_FUNC
+  explicit visitor_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) {}
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  enum {
+    RowsAtCompileTime = XprType::RowsAtCompileTime,
+    CoeffReadCost = internal::evaluator<XprType>::CoeffReadCost
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_xpr.rows(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_xpr.cols(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT { return m_xpr.size(); }
+
+  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index row, Index col) const
+  { return m_evaluator.coeff(row, col); }
+
+protected:
+  internal::evaluator<XprType> m_evaluator;
+  const XprType &m_xpr;
+};
+} // end namespace internal
+
+/** Applies the visitor \a visitor to the whole coefficients of the matrix or vector.
+  *
+  * The template parameter \a Visitor is the type of the visitor and provides the following interface:
+  * \code
+  * struct MyVisitor {
+  *   // called for the first coefficient
+  *   void init(const Scalar& value, Index i, Index j);
+  *   // called for all other coefficients
+  *   void operator() (const Scalar& value, Index i, Index j);
+  * };
+  * \endcode
+  *
+  * \note compared to one or two \em for \em loops, visitors offer automatic
+  * unrolling for small fixed size matrix.
+  *
+  * \note if the matrix is empty, then the visitor is left unchanged.
+  *
+  * \sa minCoeff(Index*,Index*), maxCoeff(Index*,Index*), DenseBase::redux()
+  */
+template<typename Derived>
+template<typename Visitor>
+EIGEN_DEVICE_FUNC
+void DenseBase<Derived>::visit(Visitor& visitor) const
+{
+  if(size()==0)
+    return;
+
+  typedef typename internal::visitor_evaluator<Derived> ThisEvaluator;
+  ThisEvaluator thisEval(derived());
+
+  enum {
+    unroll =  SizeAtCompileTime != Dynamic
+           && SizeAtCompileTime * int(ThisEvaluator::CoeffReadCost) + (SizeAtCompileTime-1) * int(internal::functor_traits<Visitor>::Cost) <= EIGEN_UNROLLING_LIMIT
+  };
+  return internal::visitor_impl<Visitor, ThisEvaluator, unroll ? int(SizeAtCompileTime) : Dynamic>::run(thisEval, visitor);
+}
+
+namespace internal {
+
+/** \internal
+  * \brief Base class to implement min and max visitors
+  */
+template <typename Derived>
+struct coeff_visitor
+{
+  // default initialization to avoid countless invalid maybe-uninitialized warnings by gcc
+  EIGEN_DEVICE_FUNC
+  coeff_visitor() : row(-1), col(-1), res(0) {}
+  typedef typename Derived::Scalar Scalar;
+  Index row, col;
+  Scalar res;
+  EIGEN_DEVICE_FUNC
+  inline void init(const Scalar& value, Index i, Index j)
+  {
+    res = value;
+    row = i;
+    col = j;
+  }
+};
+
+/** \internal
+  * \brief Visitor computing the min coefficient with its value and coordinates
+  *
+  * \sa DenseBase::minCoeff(Index*, Index*)
+  */
+template <typename Derived, int NaNPropagation>
+struct min_coeff_visitor : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if(value < this->res)
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template <typename Derived>
+struct min_coeff_visitor<Derived, PropagateNumbers> : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if((numext::isnan)(this->res) || (!(numext::isnan)(value) && value < this->res))
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template <typename Derived>
+struct min_coeff_visitor<Derived, PropagateNaN> : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if((numext::isnan)(value) || value < this->res)
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template<typename Scalar, int NaNPropagation>
+    struct functor_traits<min_coeff_visitor<Scalar, NaNPropagation> > {
+  enum {
+    Cost = NumTraits<Scalar>::AddCost
+  };
+};
+
+/** \internal
+  * \brief Visitor computing the max coefficient with its value and coordinates
+  *
+  * \sa DenseBase::maxCoeff(Index*, Index*)
+  */
+template <typename Derived, int NaNPropagation>
+struct max_coeff_visitor : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if(value > this->res)
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template <typename Derived>
+struct max_coeff_visitor<Derived, PropagateNumbers> : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if((numext::isnan)(this->res) || (!(numext::isnan)(value) && value > this->res))
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template <typename Derived>
+struct max_coeff_visitor<Derived, PropagateNaN> : coeff_visitor<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_DEVICE_FUNC
+  void operator() (const Scalar& value, Index i, Index j)
+  {
+    if((numext::isnan)(value) || value > this->res)
+    {
+      this->res = value;
+      this->row = i;
+      this->col = j;
+    }
+  }
+};
+
+template<typename Scalar, int NaNPropagation>
+struct functor_traits<max_coeff_visitor<Scalar, NaNPropagation> > {
+  enum {
+    Cost = NumTraits<Scalar>::AddCost
+  };
+};
+
+} // end namespace internal
+
+/** \fn DenseBase<Derived>::minCoeff(IndexType* rowId, IndexType* colId) const
+  * \returns the minimum of all coefficients of *this and puts in *row and *col its location.
+  *
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  *
+  * \sa DenseBase::minCoeff(Index*), DenseBase::maxCoeff(Index*,Index*), DenseBase::visit(), DenseBase::minCoeff()
+  */
+template<typename Derived>
+template<int NaNPropagation, typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::minCoeff(IndexType* rowId, IndexType* colId) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  internal::min_coeff_visitor<Derived, NaNPropagation> minVisitor;
+  this->visit(minVisitor);
+  *rowId = minVisitor.row;
+  if (colId) *colId = minVisitor.col;
+  return minVisitor.res;
+}
+
+/** \returns the minimum of all coefficients of *this and puts in *index its location.
+  *
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  *
+  * \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::minCoeff()
+  */
+template<typename Derived>
+template<int NaNPropagation, typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::minCoeff(IndexType* index) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+      internal::min_coeff_visitor<Derived, NaNPropagation> minVisitor;
+  this->visit(minVisitor);
+  *index = IndexType((RowsAtCompileTime==1) ? minVisitor.col : minVisitor.row);
+  return minVisitor.res;
+}
+
+/** \fn DenseBase<Derived>::maxCoeff(IndexType* rowId, IndexType* colId) const
+  * \returns the maximum of all coefficients of *this and puts in *row and *col its location.
+  *
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  *
+  * \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::maxCoeff()
+  */
+template<typename Derived>
+template<int NaNPropagation, typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::maxCoeff(IndexType* rowPtr, IndexType* colPtr) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  internal::max_coeff_visitor<Derived, NaNPropagation> maxVisitor;
+  this->visit(maxVisitor);
+  *rowPtr = maxVisitor.row;
+  if (colPtr) *colPtr = maxVisitor.col;
+  return maxVisitor.res;
+}
+
+/** \returns the maximum of all coefficients of *this and puts in *index its location.
+  *
+  * In case \c *this contains NaN, NaNPropagation determines the behavior:
+  *   NaNPropagation == PropagateFast : undefined
+  *   NaNPropagation == PropagateNaN : result is NaN
+  *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+  * \warning the matrix must be not empty, otherwise an assertion is triggered.
+  *
+  * \sa DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visitor(), DenseBase::maxCoeff()
+  */
+template<typename Derived>
+template<int NaNPropagation, typename IndexType>
+EIGEN_DEVICE_FUNC
+typename internal::traits<Derived>::Scalar
+DenseBase<Derived>::maxCoeff(IndexType* index) const
+{
+  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");
+
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+      internal::max_coeff_visitor<Derived, NaNPropagation> maxVisitor;
+  this->visit(maxVisitor);
+  *index = (RowsAtCompileTime==1) ? maxVisitor.col : maxVisitor.row;
+  return maxVisitor.res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_VISITOR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/Complex.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/Complex.h
new file mode 100644
index 00000000..ab7bd6c6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/Complex.h
@@ -0,0 +1,372 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner (benoit.steiner.goog@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_AVX_H
+#define EIGEN_COMPLEX_AVX_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- float ----------
+struct Packet4cf
+{
+  EIGEN_STRONG_INLINE Packet4cf() {}
+  EIGEN_STRONG_INLINE explicit Packet4cf(const __m256& a) : v(a) {}
+  __m256  v;
+};
+
+#ifndef EIGEN_VECTORIZE_AVX512
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet4cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+#endif
+
+template<> struct unpacket_traits<Packet4cf> {
+  typedef std::complex<float> type;
+  typedef Packet2cf half;
+  typedef Packet8f as_real;
+  enum {
+    size=4,
+    alignment=Aligned32,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4cf padd<Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_add_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf psub<Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_sub_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf pnegate(const Packet4cf& a)
+{
+  return Packet4cf(pnegate(a.v));
+}
+template<> EIGEN_STRONG_INLINE Packet4cf pconj(const Packet4cf& a)
+{
+  const __m256 mask = _mm256_castsi256_ps(_mm256_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000));
+  return Packet4cf(_mm256_xor_ps(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf pmul<Packet4cf>(const Packet4cf& a, const Packet4cf& b)
+{
+  __m256 tmp1 = _mm256_mul_ps(_mm256_moveldup_ps(a.v), b.v);
+  __m256 tmp2 = _mm256_mul_ps(_mm256_movehdup_ps(a.v), _mm256_permute_ps(b.v, _MM_SHUFFLE(2,3,0,1)));
+  __m256 result = _mm256_addsub_ps(tmp1, tmp2);
+  return Packet4cf(result);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4cf pcmp_eq(const Packet4cf& a, const Packet4cf& b) {
+  __m256 eq = _mm256_cmp_ps(a.v, b.v, _CMP_EQ_OQ);
+  return Packet4cf(_mm256_and_ps(eq, _mm256_permute_ps(eq, 0xb1)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf ptrue<Packet4cf>(const Packet4cf& a) { return Packet4cf(ptrue(Packet8f(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet4cf pand   <Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_and_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf por    <Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_or_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf pxor   <Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_xor_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cf pandnot<Packet4cf>(const Packet4cf& a, const Packet4cf& b) { return Packet4cf(_mm256_andnot_ps(b.v,a.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet4cf pload <Packet4cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet4cf(pload<Packet8f>(&numext::real_ref(*from))); }
+template<> EIGEN_STRONG_INLINE Packet4cf ploadu<Packet4cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet4cf(ploadu<Packet8f>(&numext::real_ref(*from))); }
+
+
+template<> EIGEN_STRONG_INLINE Packet4cf pset1<Packet4cf>(const std::complex<float>& from)
+{
+  return Packet4cf(_mm256_castpd_ps(_mm256_broadcast_sd((const double*)(const void*)&from)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf ploaddup<Packet4cf>(const std::complex<float>* from)
+{
+  // FIXME The following might be optimized using _mm256_movedup_pd
+  Packet2cf a = ploaddup<Packet2cf>(from);
+  Packet2cf b = ploaddup<Packet2cf>(from+1);
+  return  Packet4cf(_mm256_insertf128_ps(_mm256_castps128_ps256(a.v), b.v, 1));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float>* to, const Packet4cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore(&numext::real_ref(*to), from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float>* to, const Packet4cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&numext::real_ref(*to), from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet4cf pgather<std::complex<float>, Packet4cf>(const std::complex<float>* from, Index stride)
+{
+  return Packet4cf(_mm256_set_ps(std::imag(from[3*stride]), std::real(from[3*stride]),
+                                 std::imag(from[2*stride]), std::real(from[2*stride]),
+                                 std::imag(from[1*stride]), std::real(from[1*stride]),
+                                 std::imag(from[0*stride]), std::real(from[0*stride])));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet4cf>(std::complex<float>* to, const Packet4cf& from, Index stride)
+{
+  __m128 low = _mm256_extractf128_ps(from.v, 0);
+  to[stride*0] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(low, low, 0)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(low, low, 1)));
+  to[stride*1] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(low, low, 2)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(low, low, 3)));
+
+  __m128 high = _mm256_extractf128_ps(from.v, 1);
+  to[stride*2] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(high, high, 0)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(high, high, 1)));
+  to[stride*3] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(high, high, 2)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(high, high, 3)));
+
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet4cf>(const Packet4cf& a)
+{
+  return pfirst(Packet2cf(_mm256_castps256_ps128(a.v)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf preverse(const Packet4cf& a) {
+  __m128 low  = _mm256_extractf128_ps(a.v, 0);
+  __m128 high = _mm256_extractf128_ps(a.v, 1);
+  __m128d lowd  = _mm_castps_pd(low);
+  __m128d highd = _mm_castps_pd(high);
+  low  = _mm_castpd_ps(_mm_shuffle_pd(lowd,lowd,0x1));
+  high = _mm_castpd_ps(_mm_shuffle_pd(highd,highd,0x1));
+  __m256 result = _mm256_setzero_ps();
+  result = _mm256_insertf128_ps(result, low, 1);
+  result = _mm256_insertf128_ps(result, high, 0);
+  return Packet4cf(result);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet4cf>(const Packet4cf& a)
+{
+  return predux(padd(Packet2cf(_mm256_extractf128_ps(a.v,0)),
+                     Packet2cf(_mm256_extractf128_ps(a.v,1))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet4cf>(const Packet4cf& a)
+{
+  return predux_mul(pmul(Packet2cf(_mm256_extractf128_ps(a.v, 0)),
+                         Packet2cf(_mm256_extractf128_ps(a.v, 1))));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet4cf,Packet8f)
+
+template<> EIGEN_STRONG_INLINE Packet4cf pdiv<Packet4cf>(const Packet4cf& a, const Packet4cf& b)
+{
+  Packet4cf num = pmul(a, pconj(b));
+  __m256 tmp = _mm256_mul_ps(b.v, b.v);
+  __m256 tmp2    = _mm256_shuffle_ps(tmp,tmp,0xB1);
+  __m256 denom = _mm256_add_ps(tmp, tmp2);
+  return Packet4cf(_mm256_div_ps(num.v, denom));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf pcplxflip<Packet4cf>(const Packet4cf& x)
+{
+  return Packet4cf(_mm256_shuffle_ps(x.v, x.v, _MM_SHUFFLE(2, 3, 0 ,1)));
+}
+
+//---------- double ----------
+struct Packet2cd
+{
+  EIGEN_STRONG_INLINE Packet2cd() {}
+  EIGEN_STRONG_INLINE explicit Packet2cd(const __m256d& a) : v(a) {}
+  __m256d  v;
+};
+
+#ifndef EIGEN_VECTORIZE_AVX512
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet2cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 2,
+    HasHalfPacket = 1,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+#endif
+
+template<> struct unpacket_traits<Packet2cd> {
+  typedef std::complex<double> type;
+  typedef Packet1cd half;
+  typedef Packet4d as_real;
+  enum {
+    size=2,
+    alignment=Aligned32,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet2cd padd<Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_add_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd psub<Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_sub_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pnegate(const Packet2cd& a) { return Packet2cd(pnegate(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pconj(const Packet2cd& a)
+{
+  const __m256d mask = _mm256_castsi256_pd(_mm256_set_epi32(0x80000000,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0));
+  return Packet2cd(_mm256_xor_pd(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd pmul<Packet2cd>(const Packet2cd& a, const Packet2cd& b)
+{
+  __m256d tmp1 = _mm256_shuffle_pd(a.v,a.v,0x0);
+  __m256d even = _mm256_mul_pd(tmp1, b.v);
+  __m256d tmp2 = _mm256_shuffle_pd(a.v,a.v,0xF);
+  __m256d tmp3 = _mm256_shuffle_pd(b.v,b.v,0x5);
+  __m256d odd  = _mm256_mul_pd(tmp2, tmp3);
+  return Packet2cd(_mm256_addsub_pd(even, odd));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cd pcmp_eq(const Packet2cd& a, const Packet2cd& b) {
+  __m256d eq = _mm256_cmp_pd(a.v, b.v, _CMP_EQ_OQ);
+  return Packet2cd(pand(eq, _mm256_permute_pd(eq, 0x5)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd ptrue<Packet2cd>(const Packet2cd& a) { return Packet2cd(ptrue(Packet4d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet2cd pand   <Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_and_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd por    <Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_or_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pxor   <Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_xor_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cd pandnot<Packet2cd>(const Packet2cd& a, const Packet2cd& b) { return Packet2cd(_mm256_andnot_pd(b.v,a.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cd pload <Packet2cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet2cd(pload<Packet4d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cd ploadu<Packet2cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cd(ploadu<Packet4d>((const double*)from)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cd pset1<Packet2cd>(const std::complex<double>& from)
+{
+  // in case casting to a __m128d* is really not safe, then we can still fallback to this version: (much slower though)
+//   return Packet2cd(_mm256_loadu2_m128d((const double*)&from,(const double*)&from));
+    return Packet2cd(_mm256_broadcast_pd((const __m128d*)(const void*)&from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd ploaddup<Packet2cd>(const std::complex<double>* from) { return pset1<Packet2cd>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet2cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet2cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cd pgather<std::complex<double>, Packet2cd>(const std::complex<double>* from, Index stride)
+{
+  return Packet2cd(_mm256_set_pd(std::imag(from[1*stride]), std::real(from[1*stride]),
+				 std::imag(from[0*stride]), std::real(from[0*stride])));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet2cd>(std::complex<double>* to, const Packet2cd& from, Index stride)
+{
+  __m128d low = _mm256_extractf128_pd(from.v, 0);
+  to[stride*0] = std::complex<double>(_mm_cvtsd_f64(low), _mm_cvtsd_f64(_mm_shuffle_pd(low, low, 1)));
+  __m128d high = _mm256_extractf128_pd(from.v, 1);
+  to[stride*1] = std::complex<double>(_mm_cvtsd_f64(high), _mm_cvtsd_f64(_mm_shuffle_pd(high, high, 1)));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet2cd>(const Packet2cd& a)
+{
+  __m128d low = _mm256_extractf128_pd(a.v, 0);
+  EIGEN_ALIGN16 double res[2];
+  _mm_store_pd(res, low);
+  return std::complex<double>(res[0],res[1]);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd preverse(const Packet2cd& a) {
+  __m256d result = _mm256_permute2f128_pd(a.v, a.v, 1);
+  return Packet2cd(result);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet2cd>(const Packet2cd& a)
+{
+  return predux(padd(Packet1cd(_mm256_extractf128_pd(a.v,0)),
+                     Packet1cd(_mm256_extractf128_pd(a.v,1))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet2cd>(const Packet2cd& a)
+{
+  return predux(pmul(Packet1cd(_mm256_extractf128_pd(a.v,0)),
+                     Packet1cd(_mm256_extractf128_pd(a.v,1))));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cd,Packet4d)
+
+template<> EIGEN_STRONG_INLINE Packet2cd pdiv<Packet2cd>(const Packet2cd& a, const Packet2cd& b)
+{
+  Packet2cd num = pmul(a, pconj(b));
+  __m256d tmp = _mm256_mul_pd(b.v, b.v);
+  __m256d denom = _mm256_hadd_pd(tmp, tmp);
+  return Packet2cd(_mm256_div_pd(num.v, denom));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd pcplxflip<Packet2cd>(const Packet2cd& x)
+{
+  return Packet2cd(_mm256_shuffle_pd(x.v, x.v, 0x5));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4cf,4>& kernel) {
+  __m256d P0 = _mm256_castps_pd(kernel.packet[0].v);
+  __m256d P1 = _mm256_castps_pd(kernel.packet[1].v);
+  __m256d P2 = _mm256_castps_pd(kernel.packet[2].v);
+  __m256d P3 = _mm256_castps_pd(kernel.packet[3].v);
+
+  __m256d T0 = _mm256_shuffle_pd(P0, P1, 15);
+  __m256d T1 = _mm256_shuffle_pd(P0, P1, 0);
+  __m256d T2 = _mm256_shuffle_pd(P2, P3, 15);
+  __m256d T3 = _mm256_shuffle_pd(P2, P3, 0);
+
+  kernel.packet[1].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T0, T2, 32));
+  kernel.packet[3].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T0, T2, 49));
+  kernel.packet[0].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T1, T3, 32));
+  kernel.packet[2].v = _mm256_castpd_ps(_mm256_permute2f128_pd(T1, T3, 49));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2cd,2>& kernel) {
+  __m256d tmp = _mm256_permute2f128_pd(kernel.packet[0].v, kernel.packet[1].v, 0+(2<<4));
+  kernel.packet[1].v = _mm256_permute2f128_pd(kernel.packet[0].v, kernel.packet[1].v, 1+(3<<4));
+ kernel.packet[0].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cd psqrt<Packet2cd>(const Packet2cd& a) {
+  return psqrt_complex<Packet2cd>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cf psqrt<Packet4cf>(const Packet4cf& a) {
+  return psqrt_complex<Packet4cf>(a);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_AVX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/MathFunctions.h
new file mode 100644
index 00000000..67041c81
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/MathFunctions.h
@@ -0,0 +1,228 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_AVX_H
+#define EIGEN_MATH_FUNCTIONS_AVX_H
+
+/* The sin and cos functions of this file are loosely derived from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+namespace Eigen {
+
+namespace internal {
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+psin<Packet8f>(const Packet8f& _x) {
+  return psin_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+pcos<Packet8f>(const Packet8f& _x) {
+  return pcos_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+plog<Packet8f>(const Packet8f& _x) {
+  return plog_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d
+plog<Packet4d>(const Packet4d& _x) {
+  return plog_double(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+plog2<Packet8f>(const Packet8f& _x) {
+  return plog2_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d
+plog2<Packet4d>(const Packet4d& _x) {
+  return plog2_double(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f plog1p<Packet8f>(const Packet8f& _x) {
+  return generic_plog1p(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f pexpm1<Packet8f>(const Packet8f& _x) {
+  return generic_expm1(_x);
+}
+
+// Exponential function. Works by writing "x = m*log(2) + r" where
+// "m = floor(x/log(2)+1/2)" and "r" is the remainder. The result is then
+// "exp(x) = 2^m*exp(r)" where exp(r) is in the range [-1,1).
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+pexp<Packet8f>(const Packet8f& _x) {
+  return pexp_float(_x);
+}
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8f
+ptanh<Packet8f>(const Packet8f& _x) {
+  return internal::generic_fast_tanh_float(_x);
+}
+
+// Exponential function for doubles.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4d
+pexp<Packet4d>(const Packet4d& _x) {
+  return pexp_double(_x);
+}
+
+// Functions for sqrt.
+// The EIGEN_FAST_MATH version uses the _mm_rsqrt_ps approximation and one step
+// of Newton's method, at a cost of 1-2 bits of precision as opposed to the
+// exact solution. It does not handle +inf, or denormalized numbers correctly.
+// The main advantage of this approach is not just speed, but also the fact that
+// it can be inlined and pipelined with other computations, further reducing its
+// effective latency. This is similar to Quake3's fast inverse square root.
+// For detail see here: http://www.beyond3d.com/content/articles/8/
+#if EIGEN_FAST_MATH
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f psqrt<Packet8f>(const Packet8f& _x) {
+  Packet8f minus_half_x = pmul(_x, pset1<Packet8f>(-0.5f));
+  Packet8f denormal_mask = pandnot(
+      pcmp_lt(_x, pset1<Packet8f>((std::numeric_limits<float>::min)())),
+      pcmp_lt(_x, pzero(_x)));
+
+  // Compute approximate reciprocal sqrt.
+  Packet8f x = _mm256_rsqrt_ps(_x);
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(minus_half_x, pmul(x,x), pset1<Packet8f>(1.5f)));
+  // Flush results for denormals to zero.
+  return pandnot(pmul(_x,x), denormal_mask);
+}
+
+#else
+
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f psqrt<Packet8f>(const Packet8f& _x) {
+  return _mm256_sqrt_ps(_x);
+}
+
+#endif
+
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4d psqrt<Packet4d>(const Packet4d& _x) {
+  return _mm256_sqrt_pd(_x);
+}
+
+#if EIGEN_FAST_MATH
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f prsqrt<Packet8f>(const Packet8f& _x) {
+  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(inf, 0x7f800000);
+  _EIGEN_DECLARE_CONST_Packet8f(one_point_five, 1.5f);
+  _EIGEN_DECLARE_CONST_Packet8f(minus_half, -0.5f);
+  _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(flt_min, 0x00800000);
+
+  Packet8f neg_half = pmul(_x, p8f_minus_half);
+
+  // select only the inverse sqrt of positive normal inputs (denormals are
+  // flushed to zero and cause infs as well).
+  Packet8f lt_min_mask = _mm256_cmp_ps(_x, p8f_flt_min, _CMP_LT_OQ);
+  Packet8f inf_mask =  _mm256_cmp_ps(_x, p8f_inf, _CMP_EQ_OQ);
+  Packet8f not_normal_finite_mask = _mm256_or_ps(lt_min_mask, inf_mask);
+
+  // Compute an approximate result using the rsqrt intrinsic.
+  Packet8f y_approx = _mm256_rsqrt_ps(_x);
+
+  // Do a single step of Newton-Raphson iteration to improve the approximation.
+  // This uses the formula y_{n+1} = y_n * (1.5 - y_n * (0.5 * x) * y_n).
+  // It is essential to evaluate the inner term like this because forming
+  // y_n^2 may over- or underflow.
+  Packet8f y_newton = pmul(y_approx, pmadd(y_approx, pmul(neg_half, y_approx), p8f_one_point_five));
+
+  // Select the result of the Newton-Raphson step for positive normal arguments.
+  // For other arguments, choose the output of the intrinsic. This will
+  // return rsqrt(+inf) = 0, rsqrt(x) = NaN if x < 0, and rsqrt(x) = +inf if
+  // x is zero or a positive denormalized float (equivalent to flushing positive
+  // denormalized inputs to zero).
+  return pselect<Packet8f>(not_normal_finite_mask, y_approx, y_newton);
+}
+
+#else
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet8f prsqrt<Packet8f>(const Packet8f& _x) {
+  _EIGEN_DECLARE_CONST_Packet8f(one, 1.0f);
+  return _mm256_div_ps(p8f_one, _mm256_sqrt_ps(_x));
+}
+#endif
+
+template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4d prsqrt<Packet4d>(const Packet4d& _x) {
+  _EIGEN_DECLARE_CONST_Packet4d(one, 1.0);
+  return _mm256_div_pd(p4d_one, _mm256_sqrt_pd(_x));
+}
+
+F16_PACKET_FUNCTION(Packet8f, Packet8h, psin)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, pcos)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, plog)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, plog2)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, plog1p)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, pexpm1)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, pexp)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, ptanh)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, psqrt)
+F16_PACKET_FUNCTION(Packet8f, Packet8h, prsqrt)
+
+template <>
+EIGEN_STRONG_INLINE Packet8h pfrexp(const Packet8h& a, Packet8h& exponent) {
+  Packet8f fexponent;
+  const Packet8h out = float2half(pfrexp<Packet8f>(half2float(a), fexponent));
+  exponent = float2half(fexponent);
+  return out;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h pldexp(const Packet8h& a, const Packet8h& exponent) {
+  return float2half(pldexp<Packet8f>(half2float(a), half2float(exponent)));
+}
+
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, psin)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, pcos)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, plog)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, plog2)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, plog1p)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, pexpm1)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, pexp)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, ptanh)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, psqrt)
+BF16_PACKET_FUNCTION(Packet8f, Packet8bf, prsqrt)
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pfrexp(const Packet8bf& a, Packet8bf& exponent) {
+  Packet8f fexponent;
+  const Packet8bf out = F32ToBf16(pfrexp<Packet8f>(Bf16ToF32(a), fexponent));
+  exponent = F32ToBf16(fexponent);
+  return out;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pldexp(const Packet8bf& a, const Packet8bf& exponent) {
+  return F32ToBf16(pldexp<Packet8f>(Bf16ToF32(a), Bf16ToF32(exponent)));
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_AVX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/PacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/PacketMath.h
new file mode 100644
index 00000000..7fc32fd7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/PacketMath.h
@@ -0,0 +1,1574 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner (benoit.steiner.goog@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_AVX_H
+#define EIGEN_PACKET_MATH_AVX_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#if !defined(EIGEN_VECTORIZE_AVX512) && !defined(EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS)
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 16
+#endif
+
+#ifdef EIGEN_VECTORIZE_FMA
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+#endif
+
+typedef __m256  Packet8f;
+typedef __m256i Packet8i;
+typedef __m256d Packet4d;
+typedef eigen_packet_wrapper<__m128i, 2> Packet8h;
+typedef eigen_packet_wrapper<__m128i, 3> Packet8bf;
+
+template<> struct is_arithmetic<__m256>  { enum { value = true }; };
+template<> struct is_arithmetic<__m256i> { enum { value = true }; };
+template<> struct is_arithmetic<__m256d> { enum { value = true }; };
+template<> struct is_arithmetic<Packet8h> { enum { value = true }; };
+template<> struct is_arithmetic<Packet8bf> { enum { value = true }; };
+
+#define _EIGEN_DECLARE_CONST_Packet8f(NAME,X) \
+  const Packet8f p8f_##NAME = pset1<Packet8f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4d(NAME,X) \
+  const Packet4d p4d_##NAME = pset1<Packet4d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet8f_FROM_INT(NAME,X) \
+  const Packet8f p8f_##NAME = _mm256_castsi256_ps(pset1<Packet8i>(X))
+
+#define _EIGEN_DECLARE_CONST_Packet8i(NAME,X) \
+  const Packet8i p8i_##NAME = pset1<Packet8i>(X)
+
+// Use the packet_traits defined in AVX512/PacketMath.h instead if we're going
+// to leverage AVX512 instructions.
+#ifndef EIGEN_VECTORIZE_AVX512
+template<> struct packet_traits<float>  : default_packet_traits
+{
+  typedef Packet8f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+
+    HasCmp  = 1,
+    HasDiv = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasLog1p = 1,
+    HasExpm1 = 1,
+    HasExp = 1,
+    HasNdtri = 1,
+    HasBessel = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+    HasBlend = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1
+  };
+};
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet4d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+    HasHalfPacket = 1,
+
+    HasCmp  = 1,
+    HasDiv  = 1,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasBlend = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1
+  };
+};
+
+template <>
+struct packet_traits<Eigen::half> : default_packet_traits {
+  typedef Packet8h type;
+  // There is no half-size packet for Packet8h.
+  typedef Packet8h half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+
+    HasCmp    = 1,
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasSin    = EIGEN_FAST_MATH,
+    HasCos    = EIGEN_FAST_MATH,
+    HasNegate = 1,
+    HasAbs    = 1,
+    HasAbs2   = 0,
+    HasMin    = 1,
+    HasMax    = 1,
+    HasConj   = 1,
+    HasSetLinear = 0,
+    HasLog    = 1,
+    HasLog1p  = 1,
+    HasExpm1  = 1,
+    HasExp    = 1,
+    HasSqrt   = 1,
+    HasRsqrt  = 1,
+    HasTanh   = EIGEN_FAST_MATH,
+    HasErf    = EIGEN_FAST_MATH,
+    HasBlend  = 0,
+    HasRound  = 1,
+    HasFloor  = 1,
+    HasCeil   = 1,
+    HasRint   = 1,
+    HasBessel = 1,
+    HasNdtri  = 1
+  };
+};
+
+template <>
+struct packet_traits<bfloat16> : default_packet_traits {
+  typedef Packet8bf type;
+  // There is no half-size packet for current Packet8bf.
+  // TODO: support as SSE path.
+  typedef Packet8bf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+
+    HasCmp = 1,
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasNegate = 1,
+    HasAbs    = 1,
+    HasAbs2   = 0,
+    HasMin    = 1,
+    HasMax    = 1,
+    HasConj   = 1,
+    HasSetLinear = 0,
+    HasLog = 1,
+    HasLog1p  = 1,
+    HasExpm1  = 1,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+    HasBlend = 0,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+    HasBessel = 1,
+    HasNdtri  = 1
+  };
+};
+#endif
+
+template<> struct scalar_div_cost<float,true> { enum { value = 14 }; };
+template<> struct scalar_div_cost<double,true> { enum { value = 16 }; };
+
+/* Proper support for integers is only provided by AVX2. In the meantime, we'll
+   use SSE instructions and packets to deal with integers.
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet8i type;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=8
+  };
+};
+*/
+
+template<> struct unpacket_traits<Packet8f> {
+  typedef float     type;
+  typedef Packet4f  half;
+  typedef Packet8i  integer_packet;
+  typedef uint8_t   mask_t;
+  enum {size=8, alignment=Aligned32, vectorizable=true, masked_load_available=true, masked_store_available=true};
+};
+template<> struct unpacket_traits<Packet4d> {
+  typedef double type;
+  typedef Packet2d half;
+  enum {size=4, alignment=Aligned32, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet8i> { typedef int    type; typedef Packet4i half; enum {size=8, alignment=Aligned32, vectorizable=false, masked_load_available=false, masked_store_available=false}; };
+template<> struct unpacket_traits<Packet8bf> { typedef bfloat16 type; typedef Packet8bf half; enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; };
+
+// Helper function for bit packing snippet of low precision comparison.
+// It packs the flags from 16x16 to 8x16.
+EIGEN_STRONG_INLINE __m128i Pack16To8(Packet8f rf) {
+  return _mm_packs_epi32(_mm256_extractf128_si256(_mm256_castps_si256(rf), 0),
+                         _mm256_extractf128_si256(_mm256_castps_si256(rf), 1));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet8f pset1<Packet8f>(const float&  from) { return _mm256_set1_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet4d pset1<Packet4d>(const double& from) { return _mm256_set1_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet8i pset1<Packet8i>(const int&    from) { return _mm256_set1_epi32(from); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pset1frombits<Packet8f>(unsigned int from) { return _mm256_castsi256_ps(pset1<Packet8i>(from)); }
+template<> EIGEN_STRONG_INLINE Packet4d pset1frombits<Packet4d>(uint64_t from) { return _mm256_castsi256_pd(_mm256_set1_epi64x(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pzero(const Packet8f& /*a*/) { return _mm256_setzero_ps(); }
+template<> EIGEN_STRONG_INLINE Packet4d pzero(const Packet4d& /*a*/) { return _mm256_setzero_pd(); }
+template<> EIGEN_STRONG_INLINE Packet8i pzero(const Packet8i& /*a*/) { return _mm256_setzero_si256(); }
+
+
+template<> EIGEN_STRONG_INLINE Packet8f peven_mask(const Packet8f& /*a*/) { return _mm256_castsi256_ps(_mm256_set_epi32(0, -1, 0, -1, 0, -1, 0, -1)); }
+template<> EIGEN_STRONG_INLINE Packet8i peven_mask(const Packet8i& /*a*/) { return _mm256_set_epi32(0, -1, 0, -1, 0, -1, 0, -1); }
+template<> EIGEN_STRONG_INLINE Packet4d peven_mask(const Packet4d& /*a*/) { return _mm256_castsi256_pd(_mm256_set_epi32(0, 0, -1, -1, 0, 0, -1, -1)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pload1<Packet8f>(const float*  from) { return _mm256_broadcast_ss(from); }
+template<> EIGEN_STRONG_INLINE Packet4d pload1<Packet4d>(const double* from) { return _mm256_broadcast_sd(from); }
+
+template<> EIGEN_STRONG_INLINE Packet8f plset<Packet8f>(const float& a) { return _mm256_add_ps(_mm256_set1_ps(a), _mm256_set_ps(7.0,6.0,5.0,4.0,3.0,2.0,1.0,0.0)); }
+template<> EIGEN_STRONG_INLINE Packet4d plset<Packet4d>(const double& a) { return _mm256_add_pd(_mm256_set1_pd(a), _mm256_set_pd(3.0,2.0,1.0,0.0)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f padd<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_add_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d padd<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_add_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i padd<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_add_epi32(a,b);
+#else
+  __m128i lo = _mm_add_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
+  __m128i hi = _mm_add_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f psub<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_sub_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d psub<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_sub_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i psub<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_sub_epi32(a,b);
+#else
+  __m128i lo = _mm_sub_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
+  __m128i hi = _mm_sub_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pnegate(const Packet8f& a)
+{
+  return _mm256_sub_ps(_mm256_set1_ps(0.0),a);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pnegate(const Packet4d& a)
+{
+  return _mm256_sub_pd(_mm256_set1_pd(0.0),a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pconj(const Packet8f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4d pconj(const Packet4d& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8i pconj(const Packet8i& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet8f pmul<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_mul_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pmul<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_mul_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i pmul<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_mullo_epi32(a,b);
+#else
+  const __m128i lo = _mm_mullo_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
+  const __m128i hi = _mm_mullo_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pdiv<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_div_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pdiv<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_div_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i pdiv<Packet8i>(const Packet8i& /*a*/, const Packet8i& /*b*/)
+{ eigen_assert(false && "packet integer division are not supported by AVX");
+  return pset1<Packet8i>(0);
+}
+
+#ifdef EIGEN_VECTORIZE_FMA
+template<> EIGEN_STRONG_INLINE Packet8f pmadd(const Packet8f& a, const Packet8f& b, const Packet8f& c) {
+#if ( (EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC<80) || (EIGEN_COMP_CLANG) )
+  // Clang stupidly generates a vfmadd213ps instruction plus some vmovaps on registers,
+  //  and even register spilling with clang>=6.0 (bug 1637).
+  // Gcc stupidly generates a vfmadd132ps instruction.
+  // So let's enforce it to generate a vfmadd231ps instruction since the most common use
+  //  case is to accumulate the result of the product.
+  Packet8f res = c;
+  __asm__("vfmadd231ps %[a], %[b], %[c]" : [c] "+x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  return _mm256_fmadd_ps(a,b,c);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4d pmadd(const Packet4d& a, const Packet4d& b, const Packet4d& c) {
+#if ( (EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC<80) || (EIGEN_COMP_CLANG) )
+  // see above
+  Packet4d res = c;
+  __asm__("vfmadd231pd %[a], %[b], %[c]" : [c] "+x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  return _mm256_fmadd_pd(a,b,c);
+#endif
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet8f pcmp_le(const Packet8f& a, const Packet8f& b) { return _mm256_cmp_ps(a,b,_CMP_LE_OQ); }
+template<> EIGEN_STRONG_INLINE Packet8f pcmp_lt(const Packet8f& a, const Packet8f& b) { return _mm256_cmp_ps(a,b,_CMP_LT_OQ); }
+template<> EIGEN_STRONG_INLINE Packet8f pcmp_lt_or_nan(const Packet8f& a, const Packet8f& b) { return _mm256_cmp_ps(a, b, _CMP_NGE_UQ); }
+template<> EIGEN_STRONG_INLINE Packet8f pcmp_eq(const Packet8f& a, const Packet8f& b) { return _mm256_cmp_ps(a,b,_CMP_EQ_OQ); }
+
+template<> EIGEN_STRONG_INLINE Packet4d pcmp_le(const Packet4d& a, const Packet4d& b) { return _mm256_cmp_pd(a,b,_CMP_LE_OQ); }
+template<> EIGEN_STRONG_INLINE Packet4d pcmp_lt(const Packet4d& a, const Packet4d& b) { return _mm256_cmp_pd(a,b,_CMP_LT_OQ); }
+template<> EIGEN_STRONG_INLINE Packet4d pcmp_lt_or_nan(const Packet4d& a, const Packet4d& b) { return _mm256_cmp_pd(a, b, _CMP_NGE_UQ); }
+template<> EIGEN_STRONG_INLINE Packet4d pcmp_eq(const Packet4d& a, const Packet4d& b) { return _mm256_cmp_pd(a,b,_CMP_EQ_OQ); }
+
+
+template<> EIGEN_STRONG_INLINE Packet8i pcmp_eq(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_cmpeq_epi32(a,b);
+#else
+  __m128i lo = _mm_cmpeq_epi32(_mm256_extractf128_si256(a, 0), _mm256_extractf128_si256(b, 0));
+  __m128i hi = _mm_cmpeq_epi32(_mm256_extractf128_si256(a, 1), _mm256_extractf128_si256(b, 1));
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pmin<Packet8f>(const Packet8f& a, const Packet8f& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // There appears to be a bug in GCC, by which the optimizer may flip
+  // the argument order in calls to _mm_min_ps/_mm_max_ps, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  Packet8f res;
+  asm("vminps %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  // Arguments are swapped to match NaN propagation behavior of std::min.
+  return _mm256_min_ps(b,a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4d pmin<Packet4d>(const Packet4d& a, const Packet4d& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // See pmin above
+  Packet4d res;
+  asm("vminpd %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  // Arguments are swapped to match NaN propagation behavior of std::min.
+  return _mm256_min_pd(b,a);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pmax<Packet8f>(const Packet8f& a, const Packet8f& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // See pmin above
+  Packet8f res;
+  asm("vmaxps %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  // Arguments are swapped to match NaN propagation behavior of std::max.
+  return _mm256_max_ps(b,a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4d pmax<Packet4d>(const Packet4d& a, const Packet4d& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // See pmin above
+  Packet4d res;
+  asm("vmaxpd %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  return res;
+#else
+  // Arguments are swapped to match NaN propagation behavior of std::max.
+  return _mm256_max_pd(b,a);
+#endif
+}
+
+// Add specializations for min/max with prescribed NaN progation.
+template<>
+EIGEN_STRONG_INLINE Packet8f pmin<PropagateNumbers, Packet8f>(const Packet8f& a, const Packet8f& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet8f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4d pmin<PropagateNumbers, Packet4d>(const Packet4d& a, const Packet4d& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet4d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8f pmax<PropagateNumbers, Packet8f>(const Packet8f& a, const Packet8f& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet8f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4d pmax<PropagateNumbers, Packet4d>(const Packet4d& a, const Packet4d& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet4d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8f pmin<PropagateNaN, Packet8f>(const Packet8f& a, const Packet8f& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet8f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4d pmin<PropagateNaN, Packet4d>(const Packet4d& a, const Packet4d& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet4d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8f pmax<PropagateNaN, Packet8f>(const Packet8f& a, const Packet8f& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet8f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4d pmax<PropagateNaN, Packet4d>(const Packet4d& a, const Packet4d& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet4d>);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f print<Packet8f>(const Packet8f& a) { return _mm256_round_ps(a, _MM_FROUND_CUR_DIRECTION); }
+template<> EIGEN_STRONG_INLINE Packet4d print<Packet4d>(const Packet4d& a) { return _mm256_round_pd(a, _MM_FROUND_CUR_DIRECTION); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pceil<Packet8f>(const Packet8f& a) { return _mm256_ceil_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet4d pceil<Packet4d>(const Packet4d& a) { return _mm256_ceil_pd(a); }
+
+template<> EIGEN_STRONG_INLINE Packet8f pfloor<Packet8f>(const Packet8f& a) { return _mm256_floor_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet4d pfloor<Packet4d>(const Packet4d& a) { return _mm256_floor_pd(a); }
+
+
+template<> EIGEN_STRONG_INLINE Packet8i ptrue<Packet8i>(const Packet8i& a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  // vpcmpeqd has lower latency than the more general vcmpps
+  return _mm256_cmpeq_epi32(a,a);
+#else
+  const __m256 b = _mm256_castsi256_ps(a);
+  return _mm256_castps_si256(_mm256_cmp_ps(b,b,_CMP_TRUE_UQ));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f ptrue<Packet8f>(const Packet8f& a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  // vpcmpeqd has lower latency than the more general vcmpps
+  const __m256i b = _mm256_castps_si256(a);
+  return _mm256_castsi256_ps(_mm256_cmpeq_epi32(b,b));
+#else
+  return _mm256_cmp_ps(a,a,_CMP_TRUE_UQ);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4d ptrue<Packet4d>(const Packet4d& a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  // vpcmpeqq has lower latency than the more general vcmppd
+  const __m256i b = _mm256_castpd_si256(a);
+  return _mm256_castsi256_pd(_mm256_cmpeq_epi64(b,b));
+#else
+  return _mm256_cmp_pd(a,a,_CMP_TRUE_UQ);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pand<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_and_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pand<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_and_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i pand<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_and_si256(a,b);
+#else
+  return _mm256_castps_si256(_mm256_and_ps(_mm256_castsi256_ps(a),_mm256_castsi256_ps(b)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f por<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_or_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d por<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_or_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i por<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_or_si256(a,b);
+#else
+  return _mm256_castps_si256(_mm256_or_ps(_mm256_castsi256_ps(a),_mm256_castsi256_ps(b)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pxor<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_xor_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4d pxor<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_xor_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8i pxor<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_xor_si256(a,b);
+#else
+  return _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(a),_mm256_castsi256_ps(b)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pandnot<Packet8f>(const Packet8f& a, const Packet8f& b) { return _mm256_andnot_ps(b,a); }
+template<> EIGEN_STRONG_INLINE Packet4d pandnot<Packet4d>(const Packet4d& a, const Packet4d& b) { return _mm256_andnot_pd(b,a); }
+template<> EIGEN_STRONG_INLINE Packet8i pandnot<Packet8i>(const Packet8i& a, const Packet8i& b) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_andnot_si256(b,a);
+#else
+  return _mm256_castps_si256(_mm256_andnot_ps(_mm256_castsi256_ps(b),_mm256_castsi256_ps(a)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pround<Packet8f>(const Packet8f& a)
+{
+  const Packet8f mask = pset1frombits<Packet8f>(static_cast<numext::uint32_t>(0x80000000u));
+  const Packet8f prev0dot5 = pset1frombits<Packet8f>(static_cast<numext::uint32_t>(0x3EFFFFFFu));
+  return _mm256_round_ps(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pround<Packet4d>(const Packet4d& a)
+{
+  const Packet4d mask = pset1frombits<Packet4d>(static_cast<numext::uint64_t>(0x8000000000000000ull));
+  const Packet4d prev0dot5 = pset1frombits<Packet4d>(static_cast<numext::uint64_t>(0x3FDFFFFFFFFFFFFFull));
+  return _mm256_round_pd(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pselect<Packet8f>(const Packet8f& mask, const Packet8f& a, const Packet8f& b)
+{ return _mm256_blendv_ps(b,a,mask); }
+template<> EIGEN_STRONG_INLINE Packet4d pselect<Packet4d>(const Packet4d& mask, const Packet4d& a, const Packet4d& b)
+{ return _mm256_blendv_pd(b,a,mask); }
+
+template<int N> EIGEN_STRONG_INLINE Packet8i parithmetic_shift_right(Packet8i a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_srai_epi32(a, N);
+#else
+  __m128i lo = _mm_srai_epi32(_mm256_extractf128_si256(a, 0), N);
+  __m128i hi = _mm_srai_epi32(_mm256_extractf128_si256(a, 1), N);
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet8i plogical_shift_right(Packet8i a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_srli_epi32(a, N);
+#else
+  __m128i lo = _mm_srli_epi32(_mm256_extractf128_si256(a, 0), N);
+  __m128i hi = _mm_srli_epi32(_mm256_extractf128_si256(a, 1), N);
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet8i plogical_shift_left(Packet8i a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_slli_epi32(a, N);
+#else
+  __m128i lo = _mm_slli_epi32(_mm256_extractf128_si256(a, 0), N);
+  __m128i hi = _mm_slli_epi32(_mm256_extractf128_si256(a, 1), N);
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pload<Packet8f>(const float*   from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet4d pload<Packet4d>(const double*  from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet8i pload<Packet8i>(const int*     from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_si256(reinterpret_cast<const __m256i*>(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f ploadu<Packet8f>(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet4d ploadu<Packet4d>(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet8i ploadu<Packet8i>(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet8f ploadu<Packet8f>(const float* from, uint8_t umask) {
+  Packet8i mask = _mm256_set1_epi8(static_cast<char>(umask));
+  const Packet8i bit_mask = _mm256_set_epi32(0xffffff7f, 0xffffffbf, 0xffffffdf, 0xffffffef, 0xfffffff7, 0xfffffffb, 0xfffffffd, 0xfffffffe);
+  mask = por<Packet8i>(mask, bit_mask);
+  mask = pcmp_eq<Packet8i>(mask, _mm256_set1_epi32(0xffffffff));
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm256_maskload_ps(from, mask);
+}
+
+// Loads 4 floats from memory a returns the packet {a0, a0  a1, a1, a2, a2, a3, a3}
+template<> EIGEN_STRONG_INLINE Packet8f ploaddup<Packet8f>(const float* from)
+{
+  // TODO try to find a way to avoid the need of a temporary register
+//   Packet8f tmp  = _mm256_castps128_ps256(_mm_loadu_ps(from));
+//   tmp = _mm256_insertf128_ps(tmp, _mm_movehl_ps(_mm256_castps256_ps128(tmp),_mm256_castps256_ps128(tmp)), 1);
+//   return _mm256_unpacklo_ps(tmp,tmp);
+
+  // _mm256_insertf128_ps is very slow on Haswell, thus:
+  Packet8f tmp = _mm256_broadcast_ps((const __m128*)(const void*)from);
+  // mimic an "inplace" permutation of the lower 128bits using a blend
+  tmp = _mm256_blend_ps(tmp,_mm256_castps128_ps256(_mm_permute_ps( _mm256_castps256_ps128(tmp), _MM_SHUFFLE(1,0,1,0))), 15);
+  // then we can perform a consistent permutation on the global register to get everything in shape:
+  return  _mm256_permute_ps(tmp, _MM_SHUFFLE(3,3,2,2));
+}
+// Loads 2 doubles from memory a returns the packet {a0, a0  a1, a1}
+template<> EIGEN_STRONG_INLINE Packet4d ploaddup<Packet4d>(const double* from)
+{
+  Packet4d tmp = _mm256_broadcast_pd((const __m128d*)(const void*)from);
+  return  _mm256_permute_pd(tmp, 3<<2);
+}
+
+// Loads 2 floats from memory a returns the packet {a0, a0  a0, a0, a1, a1, a1, a1}
+template<> EIGEN_STRONG_INLINE Packet8f ploadquad<Packet8f>(const float* from)
+{
+  Packet8f tmp = _mm256_castps128_ps256(_mm_broadcast_ss(from));
+  return _mm256_insertf128_ps(tmp, _mm_broadcast_ss(from+1), 1);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet8f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_store_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet4d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_store_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet8i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*   to, const Packet8f& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet4d& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*       to, const Packet8i& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*   to, const Packet8f& from, uint8_t umask) {
+  Packet8i mask = _mm256_set1_epi8(static_cast<char>(umask));
+  const Packet8i bit_mask = _mm256_set_epi32(0xffffff7f, 0xffffffbf, 0xffffffdf, 0xffffffef, 0xfffffff7, 0xfffffffb, 0xfffffffd, 0xfffffffe);
+  mask = por<Packet8i>(mask, bit_mask);
+  mask = pcmp_eq<Packet8i>(mask, _mm256_set1_epi32(0xffffffff));
+  EIGEN_DEBUG_UNALIGNED_STORE return _mm256_maskstore_ps(to, mask, from);
+}
+
+// NOTE: leverage _mm256_i32gather_ps and _mm256_i32gather_pd if AVX2 instructions are available
+// NOTE: for the record the following seems to be slower: return _mm256_i32gather_ps(from, _mm256_set1_epi32(stride), 4);
+template<> EIGEN_DEVICE_FUNC inline Packet8f pgather<float, Packet8f>(const float* from, Index stride)
+{
+  return _mm256_set_ps(from[7*stride], from[6*stride], from[5*stride], from[4*stride],
+                       from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet4d pgather<double, Packet4d>(const double* from, Index stride)
+{
+  return _mm256_set_pd(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet8f>(float* to, const Packet8f& from, Index stride)
+{
+  __m128 low = _mm256_extractf128_ps(from, 0);
+  to[stride*0] = _mm_cvtss_f32(low);
+  to[stride*1] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 1));
+  to[stride*2] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 2));
+  to[stride*3] = _mm_cvtss_f32(_mm_shuffle_ps(low, low, 3));
+
+  __m128 high = _mm256_extractf128_ps(from, 1);
+  to[stride*4] = _mm_cvtss_f32(high);
+  to[stride*5] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 1));
+  to[stride*6] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 2));
+  to[stride*7] = _mm_cvtss_f32(_mm_shuffle_ps(high, high, 3));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet4d>(double* to, const Packet4d& from, Index stride)
+{
+  __m128d low = _mm256_extractf128_pd(from, 0);
+  to[stride*0] = _mm_cvtsd_f64(low);
+  to[stride*1] = _mm_cvtsd_f64(_mm_shuffle_pd(low, low, 1));
+  __m128d high = _mm256_extractf128_pd(from, 1);
+  to[stride*2] = _mm_cvtsd_f64(high);
+  to[stride*3] = _mm_cvtsd_f64(_mm_shuffle_pd(high, high, 1));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore1<Packet8f>(float* to, const float& a)
+{
+  Packet8f pa = pset1<Packet8f>(a);
+  pstore(to, pa);
+}
+template<> EIGEN_STRONG_INLINE void pstore1<Packet4d>(double* to, const double& a)
+{
+  Packet4d pa = pset1<Packet4d>(a);
+  pstore(to, pa);
+}
+template<> EIGEN_STRONG_INLINE void pstore1<Packet8i>(int* to, const int& a)
+{
+  Packet8i pa = pset1<Packet8i>(a);
+  pstore(to, pa);
+}
+
+#ifndef EIGEN_VECTORIZE_AVX512
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+#endif
+
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet8f>(const Packet8f& a) {
+  return _mm_cvtss_f32(_mm256_castps256_ps128(a));
+}
+template<> EIGEN_STRONG_INLINE double pfirst<Packet4d>(const Packet4d& a) {
+  return _mm_cvtsd_f64(_mm256_castpd256_pd128(a));
+}
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet8i>(const Packet8i& a) {
+  return _mm_cvtsi128_si32(_mm256_castsi256_si128(a));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet8f preverse(const Packet8f& a)
+{
+  __m256 tmp = _mm256_shuffle_ps(a,a,0x1b);
+  return _mm256_permute2f128_ps(tmp, tmp, 1);
+}
+template<> EIGEN_STRONG_INLINE Packet4d preverse(const Packet4d& a)
+{
+   __m256d tmp = _mm256_shuffle_pd(a,a,5);
+  return _mm256_permute2f128_pd(tmp, tmp, 1);
+  #if 0
+  // This version is unlikely to be faster as _mm256_shuffle_ps and _mm256_permute_pd
+  // exhibit the same latency/throughput, but it is here for future reference/benchmarking...
+  __m256d swap_halves = _mm256_permute2f128_pd(a,a,1);
+    return _mm256_permute_pd(swap_halves,5);
+  #endif
+}
+
+// pabs should be ok
+template<> EIGEN_STRONG_INLINE Packet8f pabs(const Packet8f& a)
+{
+  const Packet8f mask = _mm256_castsi256_ps(_mm256_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF));
+  return _mm256_and_ps(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pabs(const Packet4d& a)
+{
+  const Packet4d mask = _mm256_castsi256_pd(_mm256_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF));
+  return _mm256_and_pd(a,mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pfrexp<Packet8f>(const Packet8f& a, Packet8f& exponent) {
+  return pfrexp_generic(a,exponent);
+}
+
+// Extract exponent without existence of Packet4l.
+template<>
+EIGEN_STRONG_INLINE  
+Packet4d pfrexp_generic_get_biased_exponent(const Packet4d& a) {
+  const Packet4d cst_exp_mask  = pset1frombits<Packet4d>(static_cast<uint64_t>(0x7ff0000000000000ull));
+  __m256i a_expo = _mm256_castpd_si256(pand(a, cst_exp_mask));
+#ifdef EIGEN_VECTORIZE_AVX2
+  a_expo = _mm256_srli_epi64(a_expo, 52);
+  __m128i lo = _mm256_extractf128_si256(a_expo, 0);
+  __m128i hi = _mm256_extractf128_si256(a_expo, 1);
+#else
+  __m128i lo = _mm256_extractf128_si256(a_expo, 0);
+  __m128i hi = _mm256_extractf128_si256(a_expo, 1);
+  lo = _mm_srli_epi64(lo, 52);
+  hi = _mm_srli_epi64(hi, 52);
+#endif
+  Packet2d exponent_lo = _mm_cvtepi32_pd(vec4i_swizzle1(lo, 0, 2, 1, 3));
+  Packet2d exponent_hi = _mm_cvtepi32_pd(vec4i_swizzle1(hi, 0, 2, 1, 3));
+  Packet4d exponent = _mm256_insertf128_pd(_mm256_setzero_pd(), exponent_lo, 0);
+  exponent = _mm256_insertf128_pd(exponent, exponent_hi, 1);
+  return exponent;
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4d pfrexp<Packet4d>(const Packet4d& a, Packet4d& exponent) {
+  return pfrexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pldexp<Packet8f>(const Packet8f& a, const Packet8f& exponent) {
+  return pldexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4d pldexp<Packet4d>(const Packet4d& a, const Packet4d& exponent) {
+  // Clamp exponent to [-2099, 2099]
+  const Packet4d max_exponent = pset1<Packet4d>(2099.0);
+  const Packet4i e = _mm256_cvtpd_epi32(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
+  
+  // Split 2^e into four factors and multiply.
+  const Packet4i bias = pset1<Packet4i>(1023);
+  Packet4i b = parithmetic_shift_right<2>(e);  // floor(e/4)
+  
+  // 2^b
+  Packet4i hi = vec4i_swizzle1(padd(b, bias), 0, 2, 1, 3);
+  Packet4i lo = _mm_slli_epi64(hi, 52);
+  hi = _mm_slli_epi64(_mm_srli_epi64(hi, 32), 52);
+  Packet4d c = _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
+  Packet4d out = pmul(pmul(pmul(a, c), c), c);  // a * 2^(3b)
+  
+  // 2^(e - 3b)
+  b = psub(psub(psub(e, b), b), b);  // e - 3b
+  hi = vec4i_swizzle1(padd(b, bias), 0, 2, 1, 3);
+  lo = _mm_slli_epi64(hi, 52);
+  hi = _mm_slli_epi64(_mm_srli_epi64(hi, 32), 52);
+  c = _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
+  out = pmul(out, c); // a * 2^e
+  return out;
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet8f>(const Packet8f& a)
+{
+  return predux(Packet4f(_mm_add_ps(_mm256_castps256_ps128(a),_mm256_extractf128_ps(a,1))));
+}
+template<> EIGEN_STRONG_INLINE double predux<Packet4d>(const Packet4d& a)
+{
+  return predux(Packet2d(_mm_add_pd(_mm256_castpd256_pd128(a),_mm256_extractf128_pd(a,1))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f predux_half_dowto4<Packet8f>(const Packet8f& a)
+{
+  return _mm_add_ps(_mm256_castps256_ps128(a),_mm256_extractf128_ps(a,1));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet8f>(const Packet8f& a)
+{
+  Packet8f tmp;
+  tmp = _mm256_mul_ps(a, _mm256_permute2f128_ps(a,a,1));
+  tmp = _mm256_mul_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
+  return pfirst(_mm256_mul_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet4d>(const Packet4d& a)
+{
+  Packet4d tmp;
+  tmp = _mm256_mul_pd(a, _mm256_permute2f128_pd(a,a,1));
+  return pfirst(_mm256_mul_pd(tmp, _mm256_shuffle_pd(tmp,tmp,1)));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_min<Packet8f>(const Packet8f& a)
+{
+  Packet8f tmp = _mm256_min_ps(a, _mm256_permute2f128_ps(a,a,1));
+  tmp = _mm256_min_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
+  return pfirst(_mm256_min_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_min<Packet4d>(const Packet4d& a)
+{
+  Packet4d tmp = _mm256_min_pd(a, _mm256_permute2f128_pd(a,a,1));
+  return pfirst(_mm256_min_pd(tmp, _mm256_shuffle_pd(tmp, tmp, 1)));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_max<Packet8f>(const Packet8f& a)
+{
+  Packet8f tmp = _mm256_max_ps(a, _mm256_permute2f128_ps(a,a,1));
+  tmp = _mm256_max_ps(tmp, _mm256_shuffle_ps(tmp,tmp,_MM_SHUFFLE(1,0,3,2)));
+  return pfirst(_mm256_max_ps(tmp, _mm256_shuffle_ps(tmp,tmp,1)));
+}
+
+template<> EIGEN_STRONG_INLINE double predux_max<Packet4d>(const Packet4d& a)
+{
+  Packet4d tmp = _mm256_max_pd(a, _mm256_permute2f128_pd(a,a,1));
+  return pfirst(_mm256_max_pd(tmp, _mm256_shuffle_pd(tmp, tmp, 1)));
+}
+
+// not needed yet
+// template<> EIGEN_STRONG_INLINE bool predux_all(const Packet8f& x)
+// {
+//   return _mm256_movemask_ps(x)==0xFF;
+// }
+
+template<> EIGEN_STRONG_INLINE bool predux_any(const Packet8f& x)
+{
+  return _mm256_movemask_ps(x)!=0;
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8f,8>& kernel) {
+  __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+  __m256 T4 = _mm256_unpacklo_ps(kernel.packet[4], kernel.packet[5]);
+  __m256 T5 = _mm256_unpackhi_ps(kernel.packet[4], kernel.packet[5]);
+  __m256 T6 = _mm256_unpacklo_ps(kernel.packet[6], kernel.packet[7]);
+  __m256 T7 = _mm256_unpackhi_ps(kernel.packet[6], kernel.packet[7]);
+  __m256 S0 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(1,0,1,0));
+  __m256 S1 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(3,2,3,2));
+  __m256 S2 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(1,0,1,0));
+  __m256 S3 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(3,2,3,2));
+  __m256 S4 = _mm256_shuffle_ps(T4,T6,_MM_SHUFFLE(1,0,1,0));
+  __m256 S5 = _mm256_shuffle_ps(T4,T6,_MM_SHUFFLE(3,2,3,2));
+  __m256 S6 = _mm256_shuffle_ps(T5,T7,_MM_SHUFFLE(1,0,1,0));
+  __m256 S7 = _mm256_shuffle_ps(T5,T7,_MM_SHUFFLE(3,2,3,2));
+  kernel.packet[0] = _mm256_permute2f128_ps(S0, S4, 0x20);
+  kernel.packet[1] = _mm256_permute2f128_ps(S1, S5, 0x20);
+  kernel.packet[2] = _mm256_permute2f128_ps(S2, S6, 0x20);
+  kernel.packet[3] = _mm256_permute2f128_ps(S3, S7, 0x20);
+  kernel.packet[4] = _mm256_permute2f128_ps(S0, S4, 0x31);
+  kernel.packet[5] = _mm256_permute2f128_ps(S1, S5, 0x31);
+  kernel.packet[6] = _mm256_permute2f128_ps(S2, S6, 0x31);
+  kernel.packet[7] = _mm256_permute2f128_ps(S3, S7, 0x31);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8f,4>& kernel) {
+  __m256 T0 = _mm256_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T1 = _mm256_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m256 T2 = _mm256_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m256 T3 = _mm256_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+
+  __m256 S0 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(1,0,1,0));
+  __m256 S1 = _mm256_shuffle_ps(T0,T2,_MM_SHUFFLE(3,2,3,2));
+  __m256 S2 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(1,0,1,0));
+  __m256 S3 = _mm256_shuffle_ps(T1,T3,_MM_SHUFFLE(3,2,3,2));
+
+  kernel.packet[0] = _mm256_permute2f128_ps(S0, S1, 0x20);
+  kernel.packet[1] = _mm256_permute2f128_ps(S2, S3, 0x20);
+  kernel.packet[2] = _mm256_permute2f128_ps(S0, S1, 0x31);
+  kernel.packet[3] = _mm256_permute2f128_ps(S2, S3, 0x31);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4d,4>& kernel) {
+  __m256d T0 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 15);
+  __m256d T1 = _mm256_shuffle_pd(kernel.packet[0], kernel.packet[1], 0);
+  __m256d T2 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 15);
+  __m256d T3 = _mm256_shuffle_pd(kernel.packet[2], kernel.packet[3], 0);
+
+  kernel.packet[1] = _mm256_permute2f128_pd(T0, T2, 32);
+  kernel.packet[3] = _mm256_permute2f128_pd(T0, T2, 49);
+  kernel.packet[0] = _mm256_permute2f128_pd(T1, T3, 32);
+  kernel.packet[2] = _mm256_permute2f128_pd(T1, T3, 49);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pblend(const Selector<8>& ifPacket, const Packet8f& thenPacket, const Packet8f& elsePacket) {
+  const __m256 zero = _mm256_setzero_ps();
+  const __m256 select = _mm256_set_ps(ifPacket.select[7], ifPacket.select[6], ifPacket.select[5], ifPacket.select[4], ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m256 false_mask = _mm256_cmp_ps(select, zero, _CMP_EQ_UQ);
+  return _mm256_blendv_ps(thenPacket, elsePacket, false_mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4d pblend(const Selector<4>& ifPacket, const Packet4d& thenPacket, const Packet4d& elsePacket) {
+  const __m256d zero = _mm256_setzero_pd();
+  const __m256d select = _mm256_set_pd(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m256d false_mask = _mm256_cmp_pd(select, zero, _CMP_EQ_UQ);
+  return _mm256_blendv_pd(thenPacket, elsePacket, false_mask);
+}
+
+// Packet math for Eigen::half
+
+template<> struct unpacket_traits<Packet8h> { typedef Eigen::half type; enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet8h half; };
+
+template<> EIGEN_STRONG_INLINE Packet8h pset1<Packet8h>(const Eigen::half& from) {
+  return _mm_set1_epi16(numext::bit_cast<numext::uint16_t>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half pfirst<Packet8h>(const Packet8h& from) {
+  return numext::bit_cast<Eigen::half>(static_cast<numext::uint16_t>(_mm_extract_epi16(from, 0)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pload<Packet8h>(const Eigen::half* from) {
+  return _mm_load_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h ploadu<Packet8h>(const Eigen::half* from) {
+  return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet8h& from) {
+  _mm_store_si128(reinterpret_cast<__m128i*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet8h& from) {
+  _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h
+ploaddup<Packet8h>(const Eigen::half*  from) {
+  const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
+  const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
+  const numext::uint16_t c = numext::bit_cast<numext::uint16_t>(from[2]);
+  const numext::uint16_t d = numext::bit_cast<numext::uint16_t>(from[3]);
+  return _mm_set_epi16(d, d, c, c, b, b, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h
+ploadquad<Packet8h>(const Eigen::half* from) {
+  const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
+  const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
+  return _mm_set_epi16(b, b, b, b, a, a, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h ptrue(const Packet8h& a) {
+ return _mm_cmpeq_epi32(a, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h pabs(const Packet8h& a) {
+  const __m128i sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm_andnot_si128(sign_mask, a);
+}
+
+EIGEN_STRONG_INLINE Packet8f half2float(const Packet8h& a) {
+#ifdef EIGEN_HAS_FP16_C
+  return _mm256_cvtph_ps(a);
+#else
+  EIGEN_ALIGN32 Eigen::half aux[8];
+  pstore(aux, a);
+  float f0(aux[0]);
+  float f1(aux[1]);
+  float f2(aux[2]);
+  float f3(aux[3]);
+  float f4(aux[4]);
+  float f5(aux[5]);
+  float f6(aux[6]);
+  float f7(aux[7]);
+
+  return _mm256_set_ps(f7, f6, f5, f4, f3, f2, f1, f0);
+#endif
+}
+
+EIGEN_STRONG_INLINE Packet8h float2half(const Packet8f& a) {
+#ifdef EIGEN_HAS_FP16_C
+  return _mm256_cvtps_ph(a, _MM_FROUND_TO_NEAREST_INT|_MM_FROUND_NO_EXC);
+#else
+  EIGEN_ALIGN32 float aux[8];
+  pstore(aux, a);
+  const numext::uint16_t s0 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[0]));
+  const numext::uint16_t s1 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[1]));
+  const numext::uint16_t s2 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[2]));
+  const numext::uint16_t s3 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[3]));
+  const numext::uint16_t s4 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[4]));
+  const numext::uint16_t s5 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[5]));
+  const numext::uint16_t s6 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[6]));
+  const numext::uint16_t s7 = numext::bit_cast<numext::uint16_t>(Eigen::half(aux[7]));
+  return _mm_set_epi16(s7, s6, s5, s4, s3, s2, s1, s0);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h pmin<Packet8h>(const Packet8h& a,
+                                            const Packet8h& b) {
+  return float2half(pmin<Packet8f>(half2float(a), half2float(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h pmax<Packet8h>(const Packet8h& a,
+                                            const Packet8h& b) {
+  return float2half(pmax<Packet8f>(half2float(a), half2float(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h plset<Packet8h>(const half& a) {
+  return float2half(plset<Packet8f>(static_cast<float>(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h por(const Packet8h& a,const Packet8h& b) {
+  // in some cases Packet4i is a wrapper around __m128i, so we either need to
+  // cast to Packet4i to directly call the intrinsics as below:
+  return _mm_or_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8h pxor(const Packet8h& a,const Packet8h& b) {
+  return _mm_xor_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8h pand(const Packet8h& a,const Packet8h& b) {
+  return _mm_and_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8h pandnot(const Packet8h& a,const Packet8h& b) {
+  return _mm_andnot_si128(b,a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pselect(const Packet8h& mask, const Packet8h& a, const Packet8h& b) {
+  return _mm_blendv_epi8(b, a, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pround<Packet8h>(const Packet8h& a) {
+  return float2half(pround<Packet8f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h print<Packet8h>(const Packet8h& a) {
+  return float2half(print<Packet8f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pceil<Packet8h>(const Packet8h& a) {
+  return float2half(pceil<Packet8f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pfloor<Packet8h>(const Packet8h& a) {
+  return float2half(pfloor<Packet8f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pcmp_eq(const Packet8h& a,const Packet8h& b) {
+  return Pack16To8(pcmp_eq(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pcmp_le(const Packet8h& a,const Packet8h& b) {
+  return Pack16To8(pcmp_le(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pcmp_lt(const Packet8h& a,const Packet8h& b) {
+  return Pack16To8(pcmp_lt(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pcmp_lt_or_nan(const Packet8h& a,const Packet8h& b) {
+  return Pack16To8(pcmp_lt_or_nan(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pconj(const Packet8h& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet8h pnegate(const Packet8h& a) {
+  Packet8h sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm_xor_si128(a, sign_mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h padd<Packet8h>(const Packet8h& a, const Packet8h& b) {
+  Packet8f af = half2float(a);
+  Packet8f bf = half2float(b);
+  Packet8f rf = padd(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h psub<Packet8h>(const Packet8h& a, const Packet8h& b) {
+  Packet8f af = half2float(a);
+  Packet8f bf = half2float(b);
+  Packet8f rf = psub(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pmul<Packet8h>(const Packet8h& a, const Packet8h& b) {
+  Packet8f af = half2float(a);
+  Packet8f bf = half2float(b);
+  Packet8f rf = pmul(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pdiv<Packet8h>(const Packet8h& a, const Packet8h& b) {
+  Packet8f af = half2float(a);
+  Packet8f bf = half2float(b);
+  Packet8f rf = pdiv(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pgather<Eigen::half, Packet8h>(const Eigen::half* from, Index stride)
+{
+  const numext::uint16_t s0 = numext::bit_cast<numext::uint16_t>(from[0*stride]);
+  const numext::uint16_t s1 = numext::bit_cast<numext::uint16_t>(from[1*stride]);
+  const numext::uint16_t s2 = numext::bit_cast<numext::uint16_t>(from[2*stride]);
+  const numext::uint16_t s3 = numext::bit_cast<numext::uint16_t>(from[3*stride]);
+  const numext::uint16_t s4 = numext::bit_cast<numext::uint16_t>(from[4*stride]);
+  const numext::uint16_t s5 = numext::bit_cast<numext::uint16_t>(from[5*stride]);
+  const numext::uint16_t s6 = numext::bit_cast<numext::uint16_t>(from[6*stride]);
+  const numext::uint16_t s7 = numext::bit_cast<numext::uint16_t>(from[7*stride]);
+  return _mm_set_epi16(s7, s6, s5, s4, s3, s2, s1, s0);
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet8h>(Eigen::half* to, const Packet8h& from, Index stride)
+{
+  EIGEN_ALIGN32 Eigen::half aux[8];
+  pstore(aux, from);
+  to[stride*0] = aux[0];
+  to[stride*1] = aux[1];
+  to[stride*2] = aux[2];
+  to[stride*3] = aux[3];
+  to[stride*4] = aux[4];
+  to[stride*5] = aux[5];
+  to[stride*6] = aux[6];
+  to[stride*7] = aux[7];
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_max<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux_max<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_min<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux_min<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet8h>(const Packet8h& a) {
+  Packet8f af = half2float(a);
+  float reduced = predux_mul<Packet8f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h preverse(const Packet8h& a)
+{
+  __m128i m = _mm_setr_epi8(14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1);
+  return _mm_shuffle_epi8(a,m);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet8h,8>& kernel) {
+  __m128i a = kernel.packet[0];
+  __m128i b = kernel.packet[1];
+  __m128i c = kernel.packet[2];
+  __m128i d = kernel.packet[3];
+  __m128i e = kernel.packet[4];
+  __m128i f = kernel.packet[5];
+  __m128i g = kernel.packet[6];
+  __m128i h = kernel.packet[7];
+
+  __m128i a03b03 = _mm_unpacklo_epi16(a, b);
+  __m128i c03d03 = _mm_unpacklo_epi16(c, d);
+  __m128i e03f03 = _mm_unpacklo_epi16(e, f);
+  __m128i g03h03 = _mm_unpacklo_epi16(g, h);
+  __m128i a47b47 = _mm_unpackhi_epi16(a, b);
+  __m128i c47d47 = _mm_unpackhi_epi16(c, d);
+  __m128i e47f47 = _mm_unpackhi_epi16(e, f);
+  __m128i g47h47 = _mm_unpackhi_epi16(g, h);
+
+  __m128i a01b01c01d01 = _mm_unpacklo_epi32(a03b03, c03d03);
+  __m128i a23b23c23d23 = _mm_unpackhi_epi32(a03b03, c03d03);
+  __m128i e01f01g01h01 = _mm_unpacklo_epi32(e03f03, g03h03);
+  __m128i e23f23g23h23 = _mm_unpackhi_epi32(e03f03, g03h03);
+  __m128i a45b45c45d45 = _mm_unpacklo_epi32(a47b47, c47d47);
+  __m128i a67b67c67d67 = _mm_unpackhi_epi32(a47b47, c47d47);
+  __m128i e45f45g45h45 = _mm_unpacklo_epi32(e47f47, g47h47);
+  __m128i e67f67g67h67 = _mm_unpackhi_epi32(e47f47, g47h47);
+
+  __m128i a0b0c0d0e0f0g0h0 = _mm_unpacklo_epi64(a01b01c01d01, e01f01g01h01);
+  __m128i a1b1c1d1e1f1g1h1 = _mm_unpackhi_epi64(a01b01c01d01, e01f01g01h01);
+  __m128i a2b2c2d2e2f2g2h2 = _mm_unpacklo_epi64(a23b23c23d23, e23f23g23h23);
+  __m128i a3b3c3d3e3f3g3h3 = _mm_unpackhi_epi64(a23b23c23d23, e23f23g23h23);
+  __m128i a4b4c4d4e4f4g4h4 = _mm_unpacklo_epi64(a45b45c45d45, e45f45g45h45);
+  __m128i a5b5c5d5e5f5g5h5 = _mm_unpackhi_epi64(a45b45c45d45, e45f45g45h45);
+  __m128i a6b6c6d6e6f6g6h6 = _mm_unpacklo_epi64(a67b67c67d67, e67f67g67h67);
+  __m128i a7b7c7d7e7f7g7h7 = _mm_unpackhi_epi64(a67b67c67d67, e67f67g67h67);
+
+  kernel.packet[0] = a0b0c0d0e0f0g0h0;
+  kernel.packet[1] = a1b1c1d1e1f1g1h1;
+  kernel.packet[2] = a2b2c2d2e2f2g2h2;
+  kernel.packet[3] = a3b3c3d3e3f3g3h3;
+  kernel.packet[4] = a4b4c4d4e4f4g4h4;
+  kernel.packet[5] = a5b5c5d5e5f5g5h5;
+  kernel.packet[6] = a6b6c6d6e6f6g6h6;
+  kernel.packet[7] = a7b7c7d7e7f7g7h7;
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet8h,4>& kernel) {
+  EIGEN_ALIGN32 Eigen::half in[4][8];
+  pstore<Eigen::half>(in[0], kernel.packet[0]);
+  pstore<Eigen::half>(in[1], kernel.packet[1]);
+  pstore<Eigen::half>(in[2], kernel.packet[2]);
+  pstore<Eigen::half>(in[3], kernel.packet[3]);
+
+  EIGEN_ALIGN32 Eigen::half out[4][8];
+
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      out[i][j] = in[j][2*i];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+4] = in[j][2*i+1];
+    }
+  }
+
+  kernel.packet[0] = pload<Packet8h>(out[0]);
+  kernel.packet[1] = pload<Packet8h>(out[1]);
+  kernel.packet[2] = pload<Packet8h>(out[2]);
+  kernel.packet[3] = pload<Packet8h>(out[3]);
+}
+
+// BFloat16 implementation.
+
+EIGEN_STRONG_INLINE Packet8f Bf16ToF32(const Packet8bf& a) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  __m256i extend = _mm256_cvtepu16_epi32(a);
+  return _mm256_castsi256_ps(_mm256_slli_epi32(extend, 16));
+#else
+  __m128i lo = _mm_cvtepu16_epi32(a);
+  __m128i hi = _mm_cvtepu16_epi32(_mm_srli_si128(a, 8));
+  __m128i lo_shift = _mm_slli_epi32(lo, 16);
+  __m128i hi_shift = _mm_slli_epi32(hi, 16);
+  return _mm256_castsi256_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(lo_shift), hi_shift, 1));
+#endif
+}
+
+// Convert float to bfloat16 according to round-to-nearest-even/denormals algorithm.
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16(const Packet8f& a) {
+  Packet8bf r;
+
+  __m256i input = _mm256_castps_si256(a);
+
+#ifdef EIGEN_VECTORIZE_AVX2
+  // uint32_t lsb = (input >> 16);
+  __m256i t = _mm256_srli_epi32(input, 16);
+  // uint32_t lsb = lsb & 1;
+  t = _mm256_and_si256(t, _mm256_set1_epi32(1));
+  // uint32_t rounding_bias = 0x7fff + lsb;
+  t = _mm256_add_epi32(t, _mm256_set1_epi32(0x7fff));
+  // input += rounding_bias;
+  t = _mm256_add_epi32(t, input);
+  // input = input >> 16;
+  t = _mm256_srli_epi32(t, 16);
+  // Check NaN before converting back to bf16
+  __m256 mask = _mm256_cmp_ps(a, a, _CMP_ORD_Q);
+  __m256i nan = _mm256_set1_epi32(0x7fc0);
+  t = _mm256_blendv_epi8(nan, t, _mm256_castps_si256(mask));
+  // output = numext::bit_cast<uint16_t>(input);
+  return _mm_packus_epi32(_mm256_extractf128_si256(t, 0),
+                         _mm256_extractf128_si256(t, 1));
+#else
+  // uint32_t lsb = (input >> 16);
+  __m128i lo = _mm_srli_epi32(_mm256_extractf128_si256(input, 0), 16);
+  __m128i hi = _mm_srli_epi32(_mm256_extractf128_si256(input, 1), 16);
+  // uint32_t lsb = lsb & 1;
+  lo = _mm_and_si128(lo, _mm_set1_epi32(1));
+  hi = _mm_and_si128(hi, _mm_set1_epi32(1));
+  // uint32_t rounding_bias = 0x7fff + lsb;
+  lo = _mm_add_epi32(lo, _mm_set1_epi32(0x7fff));
+  hi = _mm_add_epi32(hi, _mm_set1_epi32(0x7fff));
+  // input += rounding_bias;
+  lo = _mm_add_epi32(lo, _mm256_extractf128_si256(input, 0));
+  hi = _mm_add_epi32(hi, _mm256_extractf128_si256(input, 1));
+  // input = input >> 16;
+  lo = _mm_srli_epi32(lo, 16);
+  hi = _mm_srli_epi32(hi, 16);
+  // Check NaN before converting back to bf16
+  __m256 mask = _mm256_cmp_ps(a, a, _CMP_ORD_Q);
+  __m128i nan = _mm_set1_epi32(0x7fc0);
+  lo = _mm_blendv_epi8(nan, lo, _mm_castps_si128(_mm256_castps256_ps128(mask)));
+  hi = _mm_blendv_epi8(nan, hi, _mm_castps_si128(_mm256_extractf128_ps(mask, 1)));
+  // output = numext::bit_cast<uint16_t>(input);
+  return _mm_packus_epi32(lo, hi);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pset1<Packet8bf>(const bfloat16& from) {
+  return _mm_set1_epi16(numext::bit_cast<numext::uint16_t>(from));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 pfirst<Packet8bf>(const Packet8bf& from) {
+  return numext::bit_cast<bfloat16>(static_cast<numext::uint16_t>(_mm_extract_epi16(from, 0)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pload<Packet8bf>(const bfloat16* from) {
+  return _mm_load_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf ploadu<Packet8bf>(const bfloat16* from) {
+  return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<bfloat16>(bfloat16* to, const Packet8bf& from) {
+  _mm_store_si128(reinterpret_cast<__m128i*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<bfloat16>(bfloat16* to, const Packet8bf& from) {
+  _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf
+ploaddup<Packet8bf>(const bfloat16* from) {
+  const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
+  const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
+  const numext::uint16_t c = numext::bit_cast<numext::uint16_t>(from[2]);
+  const numext::uint16_t d = numext::bit_cast<numext::uint16_t>(from[3]);
+  return _mm_set_epi16(d, d, c, c, b, b, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf
+ploadquad<Packet8bf>(const bfloat16* from) {
+  const numext::uint16_t a = numext::bit_cast<numext::uint16_t>(from[0]);
+  const numext::uint16_t b = numext::bit_cast<numext::uint16_t>(from[1]);
+  return _mm_set_epi16(b, b, b, b, a, a, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf ptrue(const Packet8bf& a) {
+ return _mm_cmpeq_epi32(a, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pabs(const Packet8bf& a) {
+  const __m128i sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm_andnot_si128(sign_mask, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pmin<Packet8bf>(const Packet8bf& a,
+                                                const Packet8bf& b) {
+  return F32ToBf16(pmin<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pmax<Packet8bf>(const Packet8bf& a,
+                                                const Packet8bf& b) {
+  return F32ToBf16(pmax<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf plset<Packet8bf>(const bfloat16& a) {
+  return F32ToBf16(plset<Packet8f>(static_cast<float>(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf por(const Packet8bf& a,const Packet8bf& b) {
+  return _mm_or_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pxor(const Packet8bf& a,const Packet8bf& b) {
+  return _mm_xor_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pand(const Packet8bf& a,const Packet8bf& b) {
+  return _mm_and_si128(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pandnot(const Packet8bf& a,const Packet8bf& b) {
+  return _mm_andnot_si128(b,a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pselect(const Packet8bf& mask, const Packet8bf& a, const Packet8bf& b) {
+  return _mm_blendv_epi8(b, a, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pround<Packet8bf>(const Packet8bf& a)
+{
+  return F32ToBf16(pround<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf print<Packet8bf>(const Packet8bf& a) {
+  return F32ToBf16(print<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pceil<Packet8bf>(const Packet8bf& a) {
+  return F32ToBf16(pceil<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pfloor<Packet8bf>(const Packet8bf& a) {
+  return F32ToBf16(pfloor<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_eq(const Packet8bf& a,const Packet8bf& b) {
+  return Pack16To8(pcmp_eq(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_le(const Packet8bf& a,const Packet8bf& b) {
+  return Pack16To8(pcmp_le(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_lt(const Packet8bf& a,const Packet8bf& b) {
+  return Pack16To8(pcmp_lt(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_lt_or_nan(const Packet8bf& a,const Packet8bf& b) {
+  return Pack16To8(pcmp_lt_or_nan(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pconj(const Packet8bf& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet8bf pnegate(const Packet8bf& a) {
+  Packet8bf sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm_xor_si128(a, sign_mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf padd<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return F32ToBf16(padd<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf psub<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return F32ToBf16(psub<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pmul<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return F32ToBf16(pmul<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pdiv<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return F32ToBf16(pdiv<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet8bf pgather<bfloat16, Packet8bf>(const bfloat16* from, Index stride)
+{
+  const numext::uint16_t s0 = numext::bit_cast<numext::uint16_t>(from[0*stride]);
+  const numext::uint16_t s1 = numext::bit_cast<numext::uint16_t>(from[1*stride]);
+  const numext::uint16_t s2 = numext::bit_cast<numext::uint16_t>(from[2*stride]);
+  const numext::uint16_t s3 = numext::bit_cast<numext::uint16_t>(from[3*stride]);
+  const numext::uint16_t s4 = numext::bit_cast<numext::uint16_t>(from[4*stride]);
+  const numext::uint16_t s5 = numext::bit_cast<numext::uint16_t>(from[5*stride]);
+  const numext::uint16_t s6 = numext::bit_cast<numext::uint16_t>(from[6*stride]);
+  const numext::uint16_t s7 = numext::bit_cast<numext::uint16_t>(from[7*stride]);
+  return _mm_set_epi16(s7, s6, s5, s4, s3, s2, s1, s0);
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<bfloat16, Packet8bf>(bfloat16* to, const Packet8bf& from, Index stride)
+{
+  EIGEN_ALIGN32 bfloat16 aux[8];
+  pstore(aux, from);
+  to[stride*0] = aux[0];
+  to[stride*1] = aux[1];
+  to[stride*2] = aux[2];
+  to[stride*3] = aux[3];
+  to[stride*4] = aux[4];
+  to[stride*5] = aux[5];
+  to[stride*6] = aux[6];
+  to[stride*7] = aux[7];
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux<Packet8bf>(const Packet8bf& a) {
+  return static_cast<bfloat16>(predux<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_max<Packet8bf>(const Packet8bf& a) {
+  return static_cast<bfloat16>(predux_max<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_min<Packet8bf>(const Packet8bf& a) {
+  return static_cast<bfloat16>(predux_min<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_mul<Packet8bf>(const Packet8bf& a) {
+  return static_cast<bfloat16>(predux_mul<Packet8f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf preverse(const Packet8bf& a)
+{
+  __m128i m = _mm_setr_epi8(14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1);
+  return _mm_shuffle_epi8(a,m);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet8bf,8>& kernel) {
+  __m128i a = kernel.packet[0];
+  __m128i b = kernel.packet[1];
+  __m128i c = kernel.packet[2];
+  __m128i d = kernel.packet[3];
+  __m128i e = kernel.packet[4];
+  __m128i f = kernel.packet[5];
+  __m128i g = kernel.packet[6];
+  __m128i h = kernel.packet[7];
+
+  __m128i a03b03 = _mm_unpacklo_epi16(a, b);
+  __m128i c03d03 = _mm_unpacklo_epi16(c, d);
+  __m128i e03f03 = _mm_unpacklo_epi16(e, f);
+  __m128i g03h03 = _mm_unpacklo_epi16(g, h);
+  __m128i a47b47 = _mm_unpackhi_epi16(a, b);
+  __m128i c47d47 = _mm_unpackhi_epi16(c, d);
+  __m128i e47f47 = _mm_unpackhi_epi16(e, f);
+  __m128i g47h47 = _mm_unpackhi_epi16(g, h);
+
+  __m128i a01b01c01d01 = _mm_unpacklo_epi32(a03b03, c03d03);
+  __m128i a23b23c23d23 = _mm_unpackhi_epi32(a03b03, c03d03);
+  __m128i e01f01g01h01 = _mm_unpacklo_epi32(e03f03, g03h03);
+  __m128i e23f23g23h23 = _mm_unpackhi_epi32(e03f03, g03h03);
+  __m128i a45b45c45d45 = _mm_unpacklo_epi32(a47b47, c47d47);
+  __m128i a67b67c67d67 = _mm_unpackhi_epi32(a47b47, c47d47);
+  __m128i e45f45g45h45 = _mm_unpacklo_epi32(e47f47, g47h47);
+  __m128i e67f67g67h67 = _mm_unpackhi_epi32(e47f47, g47h47);
+
+  kernel.packet[0] = _mm_unpacklo_epi64(a01b01c01d01, e01f01g01h01);
+  kernel.packet[1] = _mm_unpackhi_epi64(a01b01c01d01, e01f01g01h01);
+  kernel.packet[2] = _mm_unpacklo_epi64(a23b23c23d23, e23f23g23h23);
+  kernel.packet[3] = _mm_unpackhi_epi64(a23b23c23d23, e23f23g23h23);
+  kernel.packet[4] = _mm_unpacklo_epi64(a45b45c45d45, e45f45g45h45);
+  kernel.packet[5] = _mm_unpackhi_epi64(a45b45c45d45, e45f45g45h45);
+  kernel.packet[6] = _mm_unpacklo_epi64(a67b67c67d67, e67f67g67h67);
+  kernel.packet[7] = _mm_unpackhi_epi64(a67b67c67d67, e67f67g67h67);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet8bf,4>& kernel) {
+  __m128i a = kernel.packet[0];
+  __m128i b = kernel.packet[1];
+  __m128i c = kernel.packet[2];
+  __m128i d = kernel.packet[3];
+
+  __m128i ab_03 = _mm_unpacklo_epi16(a, b);
+  __m128i cd_03 = _mm_unpacklo_epi16(c, d);
+  __m128i ab_47 = _mm_unpackhi_epi16(a, b);
+  __m128i cd_47 = _mm_unpackhi_epi16(c, d);
+
+  kernel.packet[0] = _mm_unpacklo_epi32(ab_03, cd_03);
+  kernel.packet[1] = _mm_unpackhi_epi32(ab_03, cd_03);
+  kernel.packet[2] = _mm_unpacklo_epi32(ab_47, cd_47);
+  kernel.packet[3] = _mm_unpackhi_epi32(ab_47, cd_47);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_AVX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/TypeCasting.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/TypeCasting.h
new file mode 100644
index 00000000..d507fb67
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX/TypeCasting.h
@@ -0,0 +1,115 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_AVX_H
+#define EIGEN_TYPE_CASTING_AVX_H
+
+namespace Eigen {
+
+namespace internal {
+
+// For now we use SSE to handle integers, so we can't use AVX instructions to cast
+// from int to float
+template <>
+struct type_casting_traits<float, int> {
+  enum {
+    VectorizedCast = 0,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<int, float> {
+  enum {
+    VectorizedCast = 0,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+
+#ifndef EIGEN_VECTORIZE_AVX512
+
+template <>
+struct type_casting_traits<Eigen::half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+
+template <>
+struct type_casting_traits<float, Eigen::half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<bfloat16, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<float, bfloat16> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+#endif  // EIGEN_VECTORIZE_AVX512
+
+template<> EIGEN_STRONG_INLINE Packet8i pcast<Packet8f, Packet8i>(const Packet8f& a) {
+  return _mm256_cvttps_epi32(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pcast<Packet8i, Packet8f>(const Packet8i& a) {
+  return _mm256_cvtepi32_ps(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8i preinterpret<Packet8i,Packet8f>(const Packet8f& a) {
+  return _mm256_castps_si256(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f preinterpret<Packet8f,Packet8i>(const Packet8i& a) {
+  return _mm256_castsi256_ps(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pcast<Packet8h, Packet8f>(const Packet8h& a) {
+  return half2float(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8f pcast<Packet8bf, Packet8f>(const Packet8bf& a) {
+  return Bf16ToF32(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8h pcast<Packet8f, Packet8h>(const Packet8f& a) {
+  return float2half(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcast<Packet8f, Packet8bf>(const Packet8f& a) {
+  return F32ToBf16(a);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_AVX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/Complex.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/Complex.h
new file mode 100644
index 00000000..49c72b3f
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/Complex.h
@@ -0,0 +1,422 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_AVX512_H
+#define EIGEN_COMPLEX_AVX512_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- float ----------
+struct Packet8cf
+{
+  EIGEN_STRONG_INLINE Packet8cf() {}
+  EIGEN_STRONG_INLINE explicit Packet8cf(const __m512& a) : v(a) {}
+  __m512  v;
+};
+
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet8cf type;
+  typedef Packet4cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet8cf> {
+  typedef std::complex<float> type;
+  typedef Packet4cf half;
+  typedef Packet16f as_real;
+  enum {
+    size = 8,
+    alignment=unpacket_traits<Packet16f>::alignment,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet8cf ptrue<Packet8cf>(const Packet8cf& a) { return Packet8cf(ptrue(Packet16f(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet8cf padd<Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(_mm512_add_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet8cf psub<Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(_mm512_sub_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet8cf pnegate(const Packet8cf& a)
+{
+  return Packet8cf(pnegate(a.v));
+}
+template<> EIGEN_STRONG_INLINE Packet8cf pconj(const Packet8cf& a)
+{
+  const __m512 mask = _mm512_castsi512_ps(_mm512_setr_epi32(
+    0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000,
+    0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000,0x00000000,0x80000000));
+  return Packet8cf(pxor(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf pmul<Packet8cf>(const Packet8cf& a, const Packet8cf& b)
+{
+  __m512 tmp2 = _mm512_mul_ps(_mm512_movehdup_ps(a.v), _mm512_permute_ps(b.v, _MM_SHUFFLE(2,3,0,1)));
+  return Packet8cf(_mm512_fmaddsub_ps(_mm512_moveldup_ps(a.v), b.v, tmp2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf pand   <Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(pand(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet8cf por    <Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(por(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet8cf pxor   <Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(pxor(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet8cf pandnot<Packet8cf>(const Packet8cf& a, const Packet8cf& b) { return Packet8cf(pandnot(a.v,b.v)); }
+
+template <>
+EIGEN_STRONG_INLINE Packet8cf pcmp_eq(const Packet8cf& a, const Packet8cf& b) {
+  __m512 eq = pcmp_eq<Packet16f>(a.v, b.v);
+  return Packet8cf(pand(eq, _mm512_permute_ps(eq, 0xB1)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf pload <Packet8cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet8cf(pload<Packet16f>(&numext::real_ref(*from))); }
+template<> EIGEN_STRONG_INLINE Packet8cf ploadu<Packet8cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet8cf(ploadu<Packet16f>(&numext::real_ref(*from))); }
+
+
+template<> EIGEN_STRONG_INLINE Packet8cf pset1<Packet8cf>(const std::complex<float>& from)
+{
+  return Packet8cf(_mm512_castpd_ps(pload1<Packet8d>((const double*)(const void*)&from)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf ploaddup<Packet8cf>(const std::complex<float>* from)
+{
+  return Packet8cf( _mm512_castpd_ps( ploaddup<Packet8d>((const double*)(const void*)from )) );
+}
+template<> EIGEN_STRONG_INLINE Packet8cf ploadquad<Packet8cf>(const std::complex<float>* from)
+{
+  return Packet8cf( _mm512_castpd_ps( ploadquad<Packet8d>((const double*)(const void*)from )) );
+}
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float>* to, const Packet8cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore(&numext::real_ref(*to), from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float>* to, const Packet8cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&numext::real_ref(*to), from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet8cf pgather<std::complex<float>, Packet8cf>(const std::complex<float>* from, Index stride)
+{
+  return Packet8cf(_mm512_castpd_ps(pgather<double,Packet8d>((const double*)(const void*)from, stride)));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet8cf>(std::complex<float>* to, const Packet8cf& from, Index stride)
+{
+  pscatter((double*)(void*)to, _mm512_castps_pd(from.v), stride);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet8cf>(const Packet8cf& a)
+{
+  return pfirst(Packet2cf(_mm512_castps512_ps128(a.v)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf preverse(const Packet8cf& a) {
+  return Packet8cf(_mm512_castsi512_ps(
+            _mm512_permutexvar_epi64( _mm512_set_epi32(0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7),
+                                      _mm512_castps_si512(a.v))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet8cf>(const Packet8cf& a)
+{
+  return predux(padd(Packet4cf(extract256<0>(a.v)),
+                     Packet4cf(extract256<1>(a.v))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet8cf>(const Packet8cf& a)
+{
+  return predux_mul(pmul(Packet4cf(extract256<0>(a.v)),
+                         Packet4cf(extract256<1>(a.v))));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4cf predux_half_dowto4<Packet8cf>(const Packet8cf& a) {
+  __m256 lane0 = extract256<0>(a.v);
+  __m256 lane1 = extract256<1>(a.v);
+  __m256 res = _mm256_add_ps(lane0, lane1);
+  return Packet4cf(res);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet8cf,Packet16f)
+
+template<> EIGEN_STRONG_INLINE Packet8cf pdiv<Packet8cf>(const Packet8cf& a, const Packet8cf& b)
+{
+  Packet8cf num = pmul(a, pconj(b));
+  __m512 tmp = _mm512_mul_ps(b.v, b.v);
+  __m512 tmp2    = _mm512_shuffle_ps(tmp,tmp,0xB1);
+  __m512 denom = _mm512_add_ps(tmp, tmp2);
+  return Packet8cf(_mm512_div_ps(num.v, denom));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf pcplxflip<Packet8cf>(const Packet8cf& x)
+{
+  return Packet8cf(_mm512_shuffle_ps(x.v, x.v, _MM_SHUFFLE(2, 3, 0 ,1)));
+}
+
+//---------- double ----------
+struct Packet4cd
+{
+  EIGEN_STRONG_INLINE Packet4cd() {}
+  EIGEN_STRONG_INLINE explicit Packet4cd(const __m512d& a) : v(a) {}
+  __m512d  v;
+};
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet4cd type;
+  typedef Packet2cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet4cd> {
+  typedef std::complex<double> type;
+  typedef Packet2cd half;
+  typedef Packet8d as_real;
+  enum {
+    size = 4,
+    alignment = unpacket_traits<Packet8d>::alignment,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4cd padd<Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(_mm512_add_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd psub<Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(_mm512_sub_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd pnegate(const Packet4cd& a) { return Packet4cd(pnegate(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd pconj(const Packet4cd& a)
+{
+  const __m512d mask = _mm512_castsi512_pd(
+          _mm512_set_epi32(0x80000000,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,
+                           0x80000000,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0));
+  return Packet4cd(pxor(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd pmul<Packet4cd>(const Packet4cd& a, const Packet4cd& b)
+{
+  __m512d tmp1 = _mm512_shuffle_pd(a.v,a.v,0x0);
+  __m512d tmp2 = _mm512_shuffle_pd(a.v,a.v,0xFF);
+  __m512d tmp3 = _mm512_shuffle_pd(b.v,b.v,0x55);
+  __m512d odd  = _mm512_mul_pd(tmp2, tmp3);
+  return Packet4cd(_mm512_fmaddsub_pd(tmp1, b.v, odd));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd ptrue<Packet4cd>(const Packet4cd& a) { return Packet4cd(ptrue(Packet8d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet4cd pand   <Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(pand(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd por    <Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(por(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd pxor   <Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(pxor(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet4cd pandnot<Packet4cd>(const Packet4cd& a, const Packet4cd& b) { return Packet4cd(pandnot(a.v,b.v)); }
+
+template <>
+EIGEN_STRONG_INLINE Packet4cd pcmp_eq(const Packet4cd& a, const Packet4cd& b) {
+  __m512d eq = pcmp_eq<Packet8d>(a.v, b.v);
+  return Packet4cd(pand(eq, _mm512_permute_pd(eq, 0x55)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd pload <Packet4cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet4cd(pload<Packet8d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet4cd ploadu<Packet4cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet4cd(ploadu<Packet8d>((const double*)from)); }
+
+template<> EIGEN_STRONG_INLINE Packet4cd pset1<Packet4cd>(const std::complex<double>& from)
+{
+  #ifdef EIGEN_VECTORIZE_AVX512DQ
+  return Packet4cd(_mm512_broadcast_f64x2(pset1<Packet1cd>(from).v));
+  #else
+  return Packet4cd(_mm512_castps_pd(_mm512_broadcast_f32x4( _mm_castpd_ps(pset1<Packet1cd>(from).v))));
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd ploaddup<Packet4cd>(const std::complex<double>* from) {
+  return Packet4cd(_mm512_insertf64x4(
+          _mm512_castpd256_pd512(ploaddup<Packet2cd>(from).v), ploaddup<Packet2cd>(from+1).v, 1));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet4cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet4cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet4cd pgather<std::complex<double>, Packet4cd>(const std::complex<double>* from, Index stride)
+{
+  return Packet4cd(_mm512_insertf64x4(_mm512_castpd256_pd512(
+            _mm256_insertf128_pd(_mm256_castpd128_pd256(ploadu<Packet1cd>(from+0*stride).v), ploadu<Packet1cd>(from+1*stride).v,1)),
+            _mm256_insertf128_pd(_mm256_castpd128_pd256(ploadu<Packet1cd>(from+2*stride).v), ploadu<Packet1cd>(from+3*stride).v,1), 1));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet4cd>(std::complex<double>* to, const Packet4cd& from, Index stride)
+{
+  __m512i fromi = _mm512_castpd_si512(from.v);
+  double* tod = (double*)(void*)to;
+  _mm_storeu_pd(tod+0*stride, _mm_castsi128_pd(_mm512_extracti32x4_epi32(fromi,0)) );
+  _mm_storeu_pd(tod+2*stride, _mm_castsi128_pd(_mm512_extracti32x4_epi32(fromi,1)) );
+  _mm_storeu_pd(tod+4*stride, _mm_castsi128_pd(_mm512_extracti32x4_epi32(fromi,2)) );
+  _mm_storeu_pd(tod+6*stride, _mm_castsi128_pd(_mm512_extracti32x4_epi32(fromi,3)) );
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet4cd>(const Packet4cd& a)
+{
+  __m128d low = extract128<0>(a.v);
+  EIGEN_ALIGN16 double res[2];
+  _mm_store_pd(res, low);
+  return std::complex<double>(res[0],res[1]);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd preverse(const Packet4cd& a) {
+  return Packet4cd(_mm512_shuffle_f64x2(a.v, a.v, (shuffle_mask<3,2,1,0>::mask)));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet4cd>(const Packet4cd& a)
+{
+  return predux(padd(Packet2cd(_mm512_extractf64x4_pd(a.v,0)),
+                     Packet2cd(_mm512_extractf64x4_pd(a.v,1))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet4cd>(const Packet4cd& a)
+{
+  return predux_mul(pmul(Packet2cd(_mm512_extractf64x4_pd(a.v,0)),
+                         Packet2cd(_mm512_extractf64x4_pd(a.v,1))));
+}
+
+template<> struct conj_helper<Packet4cd, Packet4cd, false,true>
+{
+  EIGEN_STRONG_INLINE Packet4cd pmadd(const Packet4cd& x, const Packet4cd& y, const Packet4cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet4cd pmul(const Packet4cd& a, const Packet4cd& b) const
+  {
+    return internal::pmul(a, pconj(b));
+  }
+};
+
+template<> struct conj_helper<Packet4cd, Packet4cd, true,false>
+{
+  EIGEN_STRONG_INLINE Packet4cd pmadd(const Packet4cd& x, const Packet4cd& y, const Packet4cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet4cd pmul(const Packet4cd& a, const Packet4cd& b) const
+  {
+    return internal::pmul(pconj(a), b);
+  }
+};
+
+template<> struct conj_helper<Packet4cd, Packet4cd, true,true>
+{
+  EIGEN_STRONG_INLINE Packet4cd pmadd(const Packet4cd& x, const Packet4cd& y, const Packet4cd& c) const
+  { return padd(pmul(x,y),c); }
+
+  EIGEN_STRONG_INLINE Packet4cd pmul(const Packet4cd& a, const Packet4cd& b) const
+  {
+    return pconj(internal::pmul(a, b));
+  }
+};
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet4cd,Packet8d)
+
+template<> EIGEN_STRONG_INLINE Packet4cd pdiv<Packet4cd>(const Packet4cd& a, const Packet4cd& b)
+{
+  Packet4cd num = pmul(a, pconj(b));
+  __m512d tmp = _mm512_mul_pd(b.v, b.v);
+  __m512d denom =  padd(_mm512_permute_pd(tmp,0x55), tmp);
+  return Packet4cd(_mm512_div_pd(num.v, denom));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd pcplxflip<Packet4cd>(const Packet4cd& x)
+{
+  return Packet4cd(_mm512_permute_pd(x.v,0x55));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8cf,4>& kernel) {
+  PacketBlock<Packet8d,4> pb;
+  
+  pb.packet[0] = _mm512_castps_pd(kernel.packet[0].v);
+  pb.packet[1] = _mm512_castps_pd(kernel.packet[1].v);
+  pb.packet[2] = _mm512_castps_pd(kernel.packet[2].v);
+  pb.packet[3] = _mm512_castps_pd(kernel.packet[3].v);
+  ptranspose(pb);
+  kernel.packet[0].v = _mm512_castpd_ps(pb.packet[0]);
+  kernel.packet[1].v = _mm512_castpd_ps(pb.packet[1]);
+  kernel.packet[2].v = _mm512_castpd_ps(pb.packet[2]);
+  kernel.packet[3].v = _mm512_castpd_ps(pb.packet[3]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8cf,8>& kernel) {
+  PacketBlock<Packet8d,8> pb;
+  
+  pb.packet[0] = _mm512_castps_pd(kernel.packet[0].v);
+  pb.packet[1] = _mm512_castps_pd(kernel.packet[1].v);
+  pb.packet[2] = _mm512_castps_pd(kernel.packet[2].v);
+  pb.packet[3] = _mm512_castps_pd(kernel.packet[3].v);
+  pb.packet[4] = _mm512_castps_pd(kernel.packet[4].v);
+  pb.packet[5] = _mm512_castps_pd(kernel.packet[5].v);
+  pb.packet[6] = _mm512_castps_pd(kernel.packet[6].v);
+  pb.packet[7] = _mm512_castps_pd(kernel.packet[7].v);
+  ptranspose(pb);
+  kernel.packet[0].v = _mm512_castpd_ps(pb.packet[0]);
+  kernel.packet[1].v = _mm512_castpd_ps(pb.packet[1]);
+  kernel.packet[2].v = _mm512_castpd_ps(pb.packet[2]);
+  kernel.packet[3].v = _mm512_castpd_ps(pb.packet[3]);
+  kernel.packet[4].v = _mm512_castpd_ps(pb.packet[4]);
+  kernel.packet[5].v = _mm512_castpd_ps(pb.packet[5]);
+  kernel.packet[6].v = _mm512_castpd_ps(pb.packet[6]);
+  kernel.packet[7].v = _mm512_castpd_ps(pb.packet[7]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4cd,4>& kernel) {
+  __m512d T0 = _mm512_shuffle_f64x2(kernel.packet[0].v, kernel.packet[1].v, (shuffle_mask<0,1,0,1>::mask)); // [a0 a1 b0 b1]
+  __m512d T1 = _mm512_shuffle_f64x2(kernel.packet[0].v, kernel.packet[1].v, (shuffle_mask<2,3,2,3>::mask)); // [a2 a3 b2 b3]
+  __m512d T2 = _mm512_shuffle_f64x2(kernel.packet[2].v, kernel.packet[3].v, (shuffle_mask<0,1,0,1>::mask)); // [c0 c1 d0 d1]
+  __m512d T3 = _mm512_shuffle_f64x2(kernel.packet[2].v, kernel.packet[3].v, (shuffle_mask<2,3,2,3>::mask)); // [c2 c3 d2 d3]
+
+  kernel.packet[3] = Packet4cd(_mm512_shuffle_f64x2(T1, T3, (shuffle_mask<1,3,1,3>::mask))); // [a3 b3 c3 d3]
+  kernel.packet[2] = Packet4cd(_mm512_shuffle_f64x2(T1, T3, (shuffle_mask<0,2,0,2>::mask))); // [a2 b2 c2 d2]
+  kernel.packet[1] = Packet4cd(_mm512_shuffle_f64x2(T0, T2, (shuffle_mask<1,3,1,3>::mask))); // [a1 b1 c1 d1]
+  kernel.packet[0] = Packet4cd(_mm512_shuffle_f64x2(T0, T2, (shuffle_mask<0,2,0,2>::mask))); // [a0 b0 c0 d0]
+}
+
+template<> EIGEN_STRONG_INLINE Packet4cd psqrt<Packet4cd>(const Packet4cd& a) {
+  return psqrt_complex<Packet4cd>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8cf psqrt<Packet8cf>(const Packet8cf& a) {
+  return psqrt_complex<Packet8cf>(a);
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_AVX512_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/MathFunctions.h
new file mode 100644
index 00000000..6fd726d2
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/MathFunctions.h
@@ -0,0 +1,362 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Pedro Gonnet (pedro.gonnet@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
+#define THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
+
+namespace Eigen {
+
+namespace internal {
+
+// Disable the code for older versions of gcc that don't support many of the required avx512 instrinsics.
+#if EIGEN_GNUC_AT_LEAST(5, 3) || EIGEN_COMP_CLANG  || EIGEN_COMP_MSVC >= 1923
+
+#define _EIGEN_DECLARE_CONST_Packet16f(NAME, X) \
+  const Packet16f p16f_##NAME = pset1<Packet16f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(NAME, X) \
+  const Packet16f p16f_##NAME =  preinterpret<Packet16f,Packet16i>(pset1<Packet16i>(X))
+
+#define _EIGEN_DECLARE_CONST_Packet8d(NAME, X) \
+  const Packet8d p8d_##NAME = pset1<Packet8d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet8d_FROM_INT64(NAME, X) \
+  const Packet8d p8d_##NAME = _mm512_castsi512_pd(_mm512_set1_epi64(X))
+
+#define _EIGEN_DECLARE_CONST_Packet16bf(NAME, X) \
+  const Packet16bf p16bf_##NAME = pset1<Packet16bf>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet16bf_FROM_INT(NAME, X) \
+  const Packet16bf p16bf_##NAME =  preinterpret<Packet16bf,Packet16i>(pset1<Packet16i>(X))
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+plog<Packet16f>(const Packet16f& _x) {
+  return plog_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+plog<Packet8d>(const Packet8d& _x) {
+  return plog_double(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, plog)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, plog)
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+plog2<Packet16f>(const Packet16f& _x) {
+  return plog2_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+plog2<Packet8d>(const Packet8d& _x) {
+  return plog2_double(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, plog2)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, plog2)
+
+// Exponential function. Works by writing "x = m*log(2) + r" where
+// "m = floor(x/log(2)+1/2)" and "r" is the remainder. The result is then
+// "exp(x) = 2^m*exp(r)" where exp(r) is in the range [-1,1).
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+pexp<Packet16f>(const Packet16f& _x) {
+  _EIGEN_DECLARE_CONST_Packet16f(1, 1.0f);
+  _EIGEN_DECLARE_CONST_Packet16f(half, 0.5f);
+  _EIGEN_DECLARE_CONST_Packet16f(127, 127.0f);
+
+  _EIGEN_DECLARE_CONST_Packet16f(exp_hi, 88.3762626647950f);
+  _EIGEN_DECLARE_CONST_Packet16f(exp_lo, -88.3762626647949f);
+
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_LOG2EF, 1.44269504088896341f);
+
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p0, 1.9875691500E-4f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p1, 1.3981999507E-3f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p2, 8.3334519073E-3f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p3, 4.1665795894E-2f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p4, 1.6666665459E-1f);
+  _EIGEN_DECLARE_CONST_Packet16f(cephes_exp_p5, 5.0000001201E-1f);
+
+  // Clamp x.
+  Packet16f x = pmax(pmin(_x, p16f_exp_hi), p16f_exp_lo);
+
+  // Express exp(x) as exp(m*ln(2) + r), start by extracting
+  // m = floor(x/ln(2) + 0.5).
+  Packet16f m = _mm512_floor_ps(pmadd(x, p16f_cephes_LOG2EF, p16f_half));
+
+  // Get r = x - m*ln(2). Note that we can do this without losing more than one
+  // ulp precision due to the FMA instruction.
+  _EIGEN_DECLARE_CONST_Packet16f(nln2, -0.6931471805599453f);
+  Packet16f r = _mm512_fmadd_ps(m, p16f_nln2, x);
+  Packet16f r2 = pmul(r, r);
+  Packet16f r3 = pmul(r2, r);
+
+  // Evaluate the polynomial approximant,improved by instruction-level parallelism.
+  Packet16f y, y1, y2;
+  y  = pmadd(p16f_cephes_exp_p0, r, p16f_cephes_exp_p1);
+  y1 = pmadd(p16f_cephes_exp_p3, r, p16f_cephes_exp_p4);
+  y2 = padd(r, p16f_1);
+  y  = pmadd(y, r, p16f_cephes_exp_p2);
+  y1 = pmadd(y1, r, p16f_cephes_exp_p5);
+  y  = pmadd(y, r3, y1);
+  y  = pmadd(y, r2, y2);
+
+  // Build emm0 = 2^m.
+  Packet16i emm0 = _mm512_cvttps_epi32(padd(m, p16f_127));
+  emm0 = _mm512_slli_epi32(emm0, 23);
+
+  // Return 2^m * exp(r).
+  return pmax(pmul(y, _mm512_castsi512_ps(emm0)), _x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+pexp<Packet8d>(const Packet8d& _x) {
+  return pexp_double(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, pexp)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, pexp)
+
+template <>
+EIGEN_STRONG_INLINE Packet16h pfrexp(const Packet16h& a, Packet16h& exponent) {
+  Packet16f fexponent;
+  const Packet16h out = float2half(pfrexp<Packet16f>(half2float(a), fexponent));
+  exponent = float2half(fexponent);
+  return out;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16h pldexp(const Packet16h& a, const Packet16h& exponent) {
+  return float2half(pldexp<Packet16f>(half2float(a), half2float(exponent)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pfrexp(const Packet16bf& a, Packet16bf& exponent) {
+  Packet16f fexponent;
+  const Packet16bf out = F32ToBf16(pfrexp<Packet16f>(Bf16ToF32(a), fexponent));
+  exponent = F32ToBf16(fexponent);
+  return out;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pldexp(const Packet16bf& a, const Packet16bf& exponent) {
+  return F32ToBf16(pldexp<Packet16f>(Bf16ToF32(a), Bf16ToF32(exponent)));
+}
+
+// Functions for sqrt.
+// The EIGEN_FAST_MATH version uses the _mm_rsqrt_ps approximation and one step
+// of Newton's method, at a cost of 1-2 bits of precision as opposed to the
+// exact solution. The main advantage of this approach is not just speed, but
+// also the fact that it can be inlined and pipelined with other computations,
+// further reducing its effective latency.
+#if EIGEN_FAST_MATH
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+psqrt<Packet16f>(const Packet16f& _x) {
+  Packet16f neg_half = pmul(_x, pset1<Packet16f>(-.5f));
+  __mmask16 denormal_mask = _mm512_kand(
+      _mm512_cmp_ps_mask(_x, pset1<Packet16f>((std::numeric_limits<float>::min)()),
+                        _CMP_LT_OQ),
+      _mm512_cmp_ps_mask(_x, _mm512_setzero_ps(), _CMP_GE_OQ));
+
+  Packet16f x = _mm512_rsqrt14_ps(_x);
+
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), pset1<Packet16f>(1.5f)));
+
+  // Flush results for denormals to zero.
+  return _mm512_mask_blend_ps(denormal_mask, pmul(_x,x), _mm512_setzero_ps());
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+psqrt<Packet8d>(const Packet8d& _x) {
+  Packet8d neg_half = pmul(_x, pset1<Packet8d>(-.5));
+  __mmask16 denormal_mask = _mm512_kand(
+      _mm512_cmp_pd_mask(_x, pset1<Packet8d>((std::numeric_limits<double>::min)()),
+                        _CMP_LT_OQ),
+      _mm512_cmp_pd_mask(_x, _mm512_setzero_pd(), _CMP_GE_OQ));
+
+  Packet8d x = _mm512_rsqrt14_pd(_x);
+
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), pset1<Packet8d>(1.5)));
+
+  // Do a second step of Newton's iteration.
+  x = pmul(x, pmadd(neg_half, pmul(x, x), pset1<Packet8d>(1.5)));
+
+  return _mm512_mask_blend_pd(denormal_mask, pmul(_x,x), _mm512_setzero_pd());
+}
+#else
+template <>
+EIGEN_STRONG_INLINE Packet16f psqrt<Packet16f>(const Packet16f& x) {
+  return _mm512_sqrt_ps(x);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d psqrt<Packet8d>(const Packet8d& x) {
+  return _mm512_sqrt_pd(x);
+}
+#endif
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, psqrt)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, psqrt)
+
+// prsqrt for float.
+#if defined(EIGEN_VECTORIZE_AVX512ER)
+
+template <>
+EIGEN_STRONG_INLINE Packet16f prsqrt<Packet16f>(const Packet16f& x) {
+  return _mm512_rsqrt28_ps(x);
+}
+#elif EIGEN_FAST_MATH
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+prsqrt<Packet16f>(const Packet16f& _x) {
+  _EIGEN_DECLARE_CONST_Packet16f_FROM_INT(inf, 0x7f800000);
+  _EIGEN_DECLARE_CONST_Packet16f(one_point_five, 1.5f);
+  _EIGEN_DECLARE_CONST_Packet16f(minus_half, -0.5f);
+
+  Packet16f neg_half = pmul(_x, p16f_minus_half);
+
+  // Identity infinite, negative and denormal arguments.
+  __mmask16 inf_mask = _mm512_cmp_ps_mask(_x, p16f_inf, _CMP_EQ_OQ);
+  __mmask16 not_pos_mask = _mm512_cmp_ps_mask(_x, _mm512_setzero_ps(), _CMP_LE_OQ);
+  __mmask16 not_finite_pos_mask = not_pos_mask | inf_mask;
+
+  // Compute an approximate result using the rsqrt intrinsic, forcing +inf
+  // for denormals for consistency with AVX and SSE implementations.
+  Packet16f y_approx = _mm512_rsqrt14_ps(_x);
+
+  // Do a single step of Newton-Raphson iteration to improve the approximation.
+  // This uses the formula y_{n+1} = y_n * (1.5 - y_n * (0.5 * x) * y_n).
+  // It is essential to evaluate the inner term like this because forming
+  // y_n^2 may over- or underflow.
+  Packet16f y_newton = pmul(y_approx, pmadd(y_approx, pmul(neg_half, y_approx), p16f_one_point_five));
+
+  // Select the result of the Newton-Raphson step for positive finite arguments.
+  // For other arguments, choose the output of the intrinsic. This will
+  // return rsqrt(+inf) = 0, rsqrt(x) = NaN if x < 0, and rsqrt(0) = +inf.
+  return _mm512_mask_blend_ps(not_finite_pos_mask, y_newton, y_approx);
+}
+#else
+
+template <>
+EIGEN_STRONG_INLINE Packet16f prsqrt<Packet16f>(const Packet16f& x) {
+  _EIGEN_DECLARE_CONST_Packet16f(one, 1.0f);
+  return _mm512_div_ps(p16f_one, _mm512_sqrt_ps(x));
+}
+#endif
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, prsqrt)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, prsqrt)
+
+// prsqrt for double.
+#if EIGEN_FAST_MATH
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet8d
+prsqrt<Packet8d>(const Packet8d& _x) {
+  _EIGEN_DECLARE_CONST_Packet8d(one_point_five, 1.5);
+  _EIGEN_DECLARE_CONST_Packet8d(minus_half, -0.5);
+  _EIGEN_DECLARE_CONST_Packet8d_FROM_INT64(inf, 0x7ff0000000000000LL);
+
+  Packet8d neg_half = pmul(_x, p8d_minus_half);
+
+  // Identity infinite, negative and denormal arguments.
+  __mmask8 inf_mask = _mm512_cmp_pd_mask(_x, p8d_inf, _CMP_EQ_OQ);
+  __mmask8 not_pos_mask = _mm512_cmp_pd_mask(_x, _mm512_setzero_pd(), _CMP_LE_OQ);
+  __mmask8 not_finite_pos_mask = not_pos_mask | inf_mask;
+
+  // Compute an approximate result using the rsqrt intrinsic, forcing +inf
+  // for denormals for consistency with AVX and SSE implementations.
+#if defined(EIGEN_VECTORIZE_AVX512ER)
+  Packet8d y_approx = _mm512_rsqrt28_pd(_x);
+#else
+  Packet8d y_approx = _mm512_rsqrt14_pd(_x);
+#endif
+  // Do one or two steps of Newton-Raphson's to improve the approximation, depending on the
+  // starting accuracy (either 2^-14 or 2^-28, depending on whether AVX512ER is available).
+  // The Newton-Raphson algorithm has quadratic convergence and roughly doubles the number
+  // of correct digits for each step.
+  // This uses the formula y_{n+1} = y_n * (1.5 - y_n * (0.5 * x) * y_n).
+  // It is essential to evaluate the inner term like this because forming
+  // y_n^2 may over- or underflow.
+  Packet8d y_newton = pmul(y_approx, pmadd(neg_half, pmul(y_approx, y_approx), p8d_one_point_five));
+#if !defined(EIGEN_VECTORIZE_AVX512ER)
+  y_newton = pmul(y_newton, pmadd(y_newton, pmul(neg_half, y_newton), p8d_one_point_five));
+#endif
+  // Select the result of the Newton-Raphson step for positive finite arguments.
+  // For other arguments, choose the output of the intrinsic. This will
+  // return rsqrt(+inf) = 0, rsqrt(x) = NaN if x < 0, and rsqrt(0) = +inf.
+  return _mm512_mask_blend_pd(not_finite_pos_mask, y_newton, y_approx);
+}
+#else
+template <>
+EIGEN_STRONG_INLINE Packet8d prsqrt<Packet8d>(const Packet8d& x) {
+  _EIGEN_DECLARE_CONST_Packet8d(one, 1.0f);
+  return _mm512_div_pd(p8d_one, _mm512_sqrt_pd(x));
+}
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet16f plog1p<Packet16f>(const Packet16f& _x) {
+  return generic_plog1p(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, plog1p)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, plog1p)
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet16f pexpm1<Packet16f>(const Packet16f& _x) {
+  return generic_expm1(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, pexpm1)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, pexpm1)
+
+#endif
+
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+psin<Packet16f>(const Packet16f& _x) {
+  return psin_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+pcos<Packet16f>(const Packet16f& _x) {
+  return pcos_float(_x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet16f
+ptanh<Packet16f>(const Packet16f& _x) {
+  return internal::generic_fast_tanh_float(_x);
+}
+
+F16_PACKET_FUNCTION(Packet16f, Packet16h, psin)
+F16_PACKET_FUNCTION(Packet16f, Packet16h, pcos)
+F16_PACKET_FUNCTION(Packet16f, Packet16h, ptanh)
+
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, psin)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, pcos)
+BF16_PACKET_FUNCTION(Packet16f, Packet16bf, ptanh)
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/PacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/PacketMath.h
new file mode 100644
index 00000000..34d49ab6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -0,0 +1,2303 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner (benoit.steiner.goog@gmail.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_AVX512_H
+#define EIGEN_PACKET_MATH_AVX512_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
+#endif
+
+#ifdef EIGEN_VECTORIZE_FMA
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+#endif
+
+typedef __m512 Packet16f;
+typedef __m512i Packet16i;
+typedef __m512d Packet8d;
+typedef eigen_packet_wrapper<__m256i, 1> Packet16h;
+typedef eigen_packet_wrapper<__m256i, 2> Packet16bf;
+
+template <>
+struct is_arithmetic<__m512> {
+  enum { value = true };
+};
+template <>
+struct is_arithmetic<__m512i> {
+  enum { value = true };
+};
+template <>
+struct is_arithmetic<__m512d> {
+  enum { value = true };
+};
+
+template<> struct is_arithmetic<Packet16h> { enum { value = true }; };
+
+template <>
+struct packet_traits<half> : default_packet_traits {
+  typedef Packet16h type;
+  // There is no half-size packet for Packet16h.
+  typedef Packet16h half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+
+    HasCmp    = 1,
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 1,
+    HasAbs2   = 0,
+    HasMin    = 1,
+    HasMax    = 1,
+    HasConj   = 1,
+    HasSetLinear = 0,
+    HasLog    = 1,
+    HasLog1p  = 1,
+    HasExpm1  = 1,
+    HasExp    = 1,
+    HasSqrt   = 1,
+    HasRsqrt  = 1,
+    HasSin    = EIGEN_FAST_MATH,
+    HasCos    = EIGEN_FAST_MATH,
+    HasTanh   = EIGEN_FAST_MATH,
+    HasErf    = EIGEN_FAST_MATH,
+    HasBlend = 0,
+    HasRound  = 1,
+    HasFloor  = 1,
+    HasCeil   = 1,
+    HasRint   = 1,
+    HasBessel = 1,
+    HasNdtri  = 1
+  };
+};
+
+template<> struct packet_traits<float>  : default_packet_traits
+{
+  typedef Packet16f type;
+  typedef Packet8f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+
+    HasAbs = 1,
+    HasMin    = 1,
+    HasMax    = 1,
+    HasConj   = 1,
+    HasBlend = 0,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+#if EIGEN_GNUC_AT_LEAST(5, 3) || (!EIGEN_COMP_GNUC_STRICT)
+    HasLog = 1,
+    HasLog1p  = 1,
+    HasExpm1  = 1,
+    HasNdtri = 1,
+    HasBessel  = 1,
+    HasExp = 1,
+    HasSqrt = EIGEN_FAST_MATH,
+    HasRsqrt = EIGEN_FAST_MATH,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+#endif
+    HasCmp  = 1,
+    HasDiv = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1
+  };
+ };
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet8d type;
+  typedef Packet4d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+#if EIGEN_GNUC_AT_LEAST(5, 3) || (!EIGEN_COMP_GNUC_STRICT)
+    HasLog  = 1,
+    HasExp = 1,
+    HasSqrt = EIGEN_FAST_MATH,
+    HasRsqrt = EIGEN_FAST_MATH,
+#endif
+    HasCmp  = 1,
+    HasDiv = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1
+  };
+};
+
+/* TODO Implement AVX512 for integers
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet16i type;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=8
+  };
+};
+*/
+
+template <>
+struct unpacket_traits<Packet16f> {
+  typedef float type;
+  typedef Packet8f half;
+  typedef Packet16i integer_packet;
+  typedef uint16_t mask_t;
+  enum { size = 16, alignment=Aligned64, vectorizable=true, masked_load_available=true, masked_store_available=true };
+};
+template <>
+struct unpacket_traits<Packet8d> {
+  typedef double type;
+  typedef Packet4d half;
+  enum { size = 8, alignment=Aligned64, vectorizable=true, masked_load_available=false, masked_store_available=false };
+};
+template <>
+struct unpacket_traits<Packet16i> {
+  typedef int type;
+  typedef Packet8i half;
+  enum { size = 16, alignment=Aligned64, vectorizable=false, masked_load_available=false, masked_store_available=false };
+};
+
+template<>
+struct unpacket_traits<Packet16h> {
+  typedef Eigen::half type;
+  typedef Packet8h half;
+  enum {size=16, alignment=Aligned32, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pset1<Packet16f>(const float& from) {
+  return _mm512_set1_ps(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pset1<Packet8d>(const double& from) {
+  return _mm512_set1_pd(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pset1<Packet16i>(const int& from) {
+  return _mm512_set1_epi32(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pset1frombits<Packet16f>(unsigned int from) {
+  return _mm512_castsi512_ps(_mm512_set1_epi32(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d pset1frombits<Packet8d>(const numext::uint64_t from) {
+  return _mm512_castsi512_pd(_mm512_set1_epi64(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pzero(const Packet16f& /*a*/) { return _mm512_setzero_ps(); }
+template<> EIGEN_STRONG_INLINE Packet8d pzero(const Packet8d& /*a*/) { return _mm512_setzero_pd(); }
+template<> EIGEN_STRONG_INLINE Packet16i pzero(const Packet16i& /*a*/) { return _mm512_setzero_si512(); }
+
+template<> EIGEN_STRONG_INLINE Packet16f peven_mask(const Packet16f& /*a*/) {
+  return _mm512_castsi512_ps(_mm512_set_epi32(0, -1, 0, -1, 0, -1, 0, -1,
+                                              0, -1, 0, -1, 0, -1, 0, -1));
+}
+template<> EIGEN_STRONG_INLINE Packet16i peven_mask(const Packet16i& /*a*/) {
+  return _mm512_set_epi32(0, -1, 0, -1, 0, -1, 0, -1,
+                          0, -1, 0, -1, 0, -1, 0, -1);
+}
+template<> EIGEN_STRONG_INLINE Packet8d peven_mask(const Packet8d& /*a*/) {
+  return _mm512_castsi512_pd(_mm512_set_epi32(0, 0, -1, -1, 0, 0, -1, -1,
+                                              0, 0, -1, -1, 0, 0, -1, -1));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pload1<Packet16f>(const float* from) {
+  return _mm512_broadcastss_ps(_mm_load_ps1(from));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pload1<Packet8d>(const double* from) {
+  return _mm512_set1_pd(*from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f plset<Packet16f>(const float& a) {
+  return _mm512_add_ps(
+      _mm512_set1_ps(a),
+      _mm512_set_ps(15.0f, 14.0f, 13.0f, 12.0f, 11.0f, 10.0f, 9.0f, 8.0f, 7.0f, 6.0f, 5.0f,
+                    4.0f, 3.0f, 2.0f, 1.0f, 0.0f));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d plset<Packet8d>(const double& a) {
+  return _mm512_add_pd(_mm512_set1_pd(a),
+                       _mm512_set_pd(7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f padd<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_add_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d padd<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_add_pd(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i padd<Packet16i>(const Packet16i& a,
+                                              const Packet16i& b) {
+  return _mm512_add_epi32(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f psub<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_sub_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d psub<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_sub_pd(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i psub<Packet16i>(const Packet16i& a,
+                                              const Packet16i& b) {
+  return _mm512_sub_epi32(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pnegate(const Packet16f& a) {
+  return _mm512_sub_ps(_mm512_set1_ps(0.0), a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pnegate(const Packet8d& a) {
+  return _mm512_sub_pd(_mm512_set1_pd(0.0), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pconj(const Packet16f& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pconj(const Packet8d& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pconj(const Packet16i& a) {
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pmul<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_mul_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmul<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_mul_pd(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pmul<Packet16i>(const Packet16i& a,
+                                              const Packet16i& b) {
+  return _mm512_mullo_epi32(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pdiv<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  return _mm512_div_ps(a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pdiv<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  return _mm512_div_pd(a, b);
+}
+
+#ifdef EIGEN_VECTORIZE_FMA
+template <>
+EIGEN_STRONG_INLINE Packet16f pmadd(const Packet16f& a, const Packet16f& b,
+                                    const Packet16f& c) {
+  return _mm512_fmadd_ps(a, b, c);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmadd(const Packet8d& a, const Packet8d& b,
+                                   const Packet8d& c) {
+  return _mm512_fmadd_pd(a, b, c);
+}
+#endif
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet16f pselect(const Packet16f& mask,
+                                           const Packet16f& a,
+                                           const Packet16f& b) {
+  __mmask16 mask16 = _mm512_cmp_epi32_mask(
+      _mm512_castps_si512(mask), _mm512_setzero_epi32(), _MM_CMPINT_EQ);
+  return _mm512_mask_blend_ps(mask16, a, b);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet8d pselect(const Packet8d& mask,
+                                          const Packet8d& a,
+                                          const Packet8d& b) {
+  __mmask8 mask8 = _mm512_cmp_epi64_mask(_mm512_castpd_si512(mask),
+                                         _mm512_setzero_epi32(), _MM_CMPINT_EQ);
+  return _mm512_mask_blend_pd(mask8, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pmin<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm512_min_ps(b, a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmin<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm512_min_pd(b, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pmax<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm512_max_ps(b, a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pmax<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm512_max_pd(b, a);
+}
+
+// Add specializations for min/max with prescribed NaN progation.
+template<>
+EIGEN_STRONG_INLINE Packet16f pmin<PropagateNumbers, Packet16f>(const Packet16f& a, const Packet16f& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet16f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8d pmin<PropagateNumbers, Packet8d>(const Packet8d& a, const Packet8d& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet8d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet16f pmax<PropagateNumbers, Packet16f>(const Packet16f& a, const Packet16f& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet16f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8d pmax<PropagateNumbers, Packet8d>(const Packet8d& a, const Packet8d& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet8d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet16f pmin<PropagateNaN, Packet16f>(const Packet16f& a, const Packet16f& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet16f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8d pmin<PropagateNaN, Packet8d>(const Packet8d& a, const Packet8d& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet8d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet16f pmax<PropagateNaN, Packet16f>(const Packet16f& a, const Packet16f& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet16f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet8d pmax<PropagateNaN, Packet8d>(const Packet8d& a, const Packet8d& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet8d>);
+}
+
+
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+template<int I_> EIGEN_STRONG_INLINE Packet8f extract256(Packet16f x) { return _mm512_extractf32x8_ps(x,I_); }
+template<int I_> EIGEN_STRONG_INLINE Packet2d extract128(Packet8d x) { return _mm512_extractf64x2_pd(x,I_); }
+EIGEN_STRONG_INLINE Packet16f cat256(Packet8f a, Packet8f b) { return _mm512_insertf32x8(_mm512_castps256_ps512(a),b,1); }
+#else
+// AVX512F does not define _mm512_extractf32x8_ps to extract _m256 from _m512
+template<int I_> EIGEN_STRONG_INLINE Packet8f extract256(Packet16f x) {
+  return  _mm256_castsi256_ps(_mm512_extracti64x4_epi64( _mm512_castps_si512(x),I_));
+}
+
+// AVX512F does not define _mm512_extractf64x2_pd to extract _m128 from _m512
+template<int I_> EIGEN_STRONG_INLINE Packet2d extract128(Packet8d x) {
+  return _mm_castsi128_pd(_mm512_extracti32x4_epi32( _mm512_castpd_si512(x),I_));
+}
+
+EIGEN_STRONG_INLINE Packet16f cat256(Packet8f a, Packet8f b) {
+  return _mm512_castsi512_ps(_mm512_inserti64x4(_mm512_castsi256_si512(_mm256_castps_si256(a)),
+                                                _mm256_castps_si256(b),1));
+}
+#endif
+
+// Helper function for bit packing snippet of low precision comparison.
+// It packs the flags from 32x16 to 16x16.
+EIGEN_STRONG_INLINE __m256i Pack32To16(Packet16f rf) {
+  // Split data into small pieces and handle with AVX instructions
+  // to guarantee internal order of vector.
+  // Operation:
+  //   dst[15:0]    := Saturate16(rf[31:0])
+  //   dst[31:16]   := Saturate16(rf[63:32])
+  //   ...
+  //   dst[255:240] := Saturate16(rf[255:224])
+  __m256i lo = _mm256_castps_si256(extract256<0>(rf));
+  __m256i hi = _mm256_castps_si256(extract256<1>(rf));
+  __m128i result_lo = _mm_packs_epi32(_mm256_extractf128_si256(lo, 0),
+                                      _mm256_extractf128_si256(lo, 1));
+  __m128i result_hi = _mm_packs_epi32(_mm256_extractf128_si256(hi, 0),
+                                      _mm256_extractf128_si256(hi, 1));
+  return _mm256_insertf128_si256(_mm256_castsi128_si256(result_lo), result_hi, 1);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pcmp_eq(const Packet16f& a, const Packet16f& b) {
+  __mmask16 mask = _mm512_cmp_ps_mask(a, b, _CMP_EQ_OQ);
+  return _mm512_castsi512_ps(
+      _mm512_mask_set1_epi32(_mm512_set1_epi32(0), mask, 0xffffffffu));
+}
+template<> EIGEN_STRONG_INLINE Packet16f pcmp_le(const Packet16f& a, const Packet16f& b) {
+  __mmask16 mask = _mm512_cmp_ps_mask(a, b, _CMP_LE_OQ);
+  return _mm512_castsi512_ps(
+      _mm512_mask_set1_epi32(_mm512_set1_epi32(0), mask, 0xffffffffu));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pcmp_lt(const Packet16f& a, const Packet16f& b) {
+  __mmask16 mask = _mm512_cmp_ps_mask(a, b, _CMP_LT_OQ);
+  return _mm512_castsi512_ps(
+      _mm512_mask_set1_epi32(_mm512_set1_epi32(0), mask, 0xffffffffu));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pcmp_lt_or_nan(const Packet16f& a, const Packet16f& b) {
+  __mmask16 mask = _mm512_cmp_ps_mask(a, b, _CMP_NGE_UQ);
+  return _mm512_castsi512_ps(
+      _mm512_mask_set1_epi32(_mm512_set1_epi32(0), mask, 0xffffffffu));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16i pcmp_eq(const Packet16i& a, const Packet16i& b) {
+  __mmask16 mask = _mm512_cmp_epi32_mask(a, b, _CMP_EQ_OQ);
+  return _mm512_mask_set1_epi32(_mm512_set1_epi32(0), mask, 0xffffffffu);
+}
+
+
+template <>
+EIGEN_STRONG_INLINE Packet8d pcmp_eq(const Packet8d& a, const Packet8d& b) {
+  __mmask8 mask = _mm512_cmp_pd_mask(a, b, _CMP_EQ_OQ);
+  return _mm512_castsi512_pd(
+      _mm512_mask_set1_epi64(_mm512_set1_epi64(0), mask, 0xffffffffffffffffu));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pcmp_le(const Packet8d& a, const Packet8d& b) {
+  __mmask8 mask = _mm512_cmp_pd_mask(a, b, _CMP_LE_OQ);
+  return _mm512_castsi512_pd(
+      _mm512_mask_set1_epi64(_mm512_set1_epi64(0), mask, 0xffffffffffffffffu));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pcmp_lt(const Packet8d& a, const Packet8d& b) {
+  __mmask8 mask = _mm512_cmp_pd_mask(a, b, _CMP_LT_OQ);
+  return _mm512_castsi512_pd(
+      _mm512_mask_set1_epi64(_mm512_set1_epi64(0), mask, 0xffffffffffffffffu));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pcmp_lt_or_nan(const Packet8d& a, const Packet8d& b) {
+  __mmask8 mask = _mm512_cmp_pd_mask(a, b, _CMP_NGE_UQ);
+  return _mm512_castsi512_pd(
+      _mm512_mask_set1_epi64(_mm512_set1_epi64(0), mask, 0xffffffffffffffffu));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f print<Packet16f>(const Packet16f& a) { return _mm512_roundscale_ps(a, _MM_FROUND_CUR_DIRECTION); }
+template<> EIGEN_STRONG_INLINE Packet8d print<Packet8d>(const Packet8d& a) { return _mm512_roundscale_pd(a, _MM_FROUND_CUR_DIRECTION); }
+
+template<> EIGEN_STRONG_INLINE Packet16f pceil<Packet16f>(const Packet16f& a) { return _mm512_roundscale_ps(a, _MM_FROUND_TO_POS_INF); }
+template<> EIGEN_STRONG_INLINE Packet8d pceil<Packet8d>(const Packet8d& a) { return _mm512_roundscale_pd(a, _MM_FROUND_TO_POS_INF); }
+
+template<> EIGEN_STRONG_INLINE Packet16f pfloor<Packet16f>(const Packet16f& a) { return _mm512_roundscale_ps(a, _MM_FROUND_TO_NEG_INF); }
+template<> EIGEN_STRONG_INLINE Packet8d pfloor<Packet8d>(const Packet8d& a) { return _mm512_roundscale_pd(a, _MM_FROUND_TO_NEG_INF); }
+
+template <>
+EIGEN_STRONG_INLINE Packet16i ptrue<Packet16i>(const Packet16i& /*a*/) {
+  return _mm512_set1_epi32(0xffffffffu);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f ptrue<Packet16f>(const Packet16f& a) {
+  return _mm512_castsi512_ps(ptrue<Packet16i>(_mm512_castps_si512(a)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d ptrue<Packet8d>(const Packet8d& a) {
+  return _mm512_castsi512_pd(ptrue<Packet16i>(_mm512_castpd_si512(a)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16i pand<Packet16i>(const Packet16i& a,
+                                              const Packet16i& b) {
+  return _mm512_and_si512(a,b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pand<Packet16f>(const Packet16f& a,
+                                              const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_and_ps(a, b);
+#else
+  return _mm512_castsi512_ps(pand(_mm512_castps_si512(a),_mm512_castps_si512(b)));
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pand<Packet8d>(const Packet8d& a,
+                                            const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_and_pd(a, b);
+#else
+  Packet8d res = _mm512_undefined_pd();
+  Packet4d lane0_a = _mm512_extractf64x4_pd(a, 0);
+  Packet4d lane0_b = _mm512_extractf64x4_pd(b, 0);
+  res = _mm512_insertf64x4(res, _mm256_and_pd(lane0_a, lane0_b), 0);
+
+  Packet4d lane1_a = _mm512_extractf64x4_pd(a, 1);
+  Packet4d lane1_b = _mm512_extractf64x4_pd(b, 1);
+  return _mm512_insertf64x4(res, _mm256_and_pd(lane1_a, lane1_b), 1);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16i por<Packet16i>(const Packet16i& a, const Packet16i& b) {
+  return _mm512_or_si512(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f por<Packet16f>(const Packet16f& a, const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_or_ps(a, b);
+#else
+  return _mm512_castsi512_ps(por(_mm512_castps_si512(a),_mm512_castps_si512(b)));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d por<Packet8d>(const Packet8d& a,
+                                           const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_or_pd(a, b);
+#else
+  return _mm512_castsi512_pd(por(_mm512_castpd_si512(a),_mm512_castpd_si512(b)));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16i pxor<Packet16i>(const Packet16i& a, const Packet16i& b) {
+  return _mm512_xor_si512(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pxor<Packet16f>(const Packet16f& a, const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_xor_ps(a, b);
+#else
+  return _mm512_castsi512_ps(pxor(_mm512_castps_si512(a),_mm512_castps_si512(b)));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8d pxor<Packet8d>(const Packet8d& a, const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_xor_pd(a, b);
+#else
+  return _mm512_castsi512_pd(pxor(_mm512_castpd_si512(a),_mm512_castpd_si512(b)));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16i pandnot<Packet16i>(const Packet16i& a, const Packet16i& b) {
+  return _mm512_andnot_si512(b, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pandnot<Packet16f>(const Packet16f& a, const Packet16f& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_andnot_ps(b, a);
+#else
+  return _mm512_castsi512_ps(pandnot(_mm512_castps_si512(a),_mm512_castps_si512(b)));
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pandnot<Packet8d>(const Packet8d& a,const Packet8d& b) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_andnot_pd(b, a);
+#else
+  return _mm512_castsi512_pd(pandnot(_mm512_castpd_si512(a),_mm512_castpd_si512(b)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pround<Packet16f>(const Packet16f& a)
+{
+  // Work-around for default std::round rounding mode.
+  const Packet16f mask = pset1frombits<Packet16f>(static_cast<numext::uint32_t>(0x80000000u));
+  const Packet16f prev0dot5 = pset1frombits<Packet16f>(static_cast<numext::uint32_t>(0x3EFFFFFFu));
+  return _mm512_roundscale_ps(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+template<> EIGEN_STRONG_INLINE Packet8d pround<Packet8d>(const Packet8d& a)
+{
+  // Work-around for default std::round rounding mode.
+  const Packet8d mask = pset1frombits<Packet8d>(static_cast<numext::uint64_t>(0x8000000000000000ull));
+  const Packet8d prev0dot5 = pset1frombits<Packet8d>(static_cast<numext::uint64_t>(0x3FDFFFFFFFFFFFFFull));
+  return _mm512_roundscale_pd(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet16i parithmetic_shift_right(Packet16i a) {
+  return _mm512_srai_epi32(a, N);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet16i plogical_shift_right(Packet16i a) {
+  return _mm512_srli_epi32(a, N);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet16i plogical_shift_left(Packet16i a) {
+  return _mm512_slli_epi32(a, N);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f pload<Packet16f>(const float* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_ps(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pload<Packet8d>(const double* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_pd(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i pload<Packet16i>(const int* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return _mm512_load_si512(
+      reinterpret_cast<const __m512i*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f ploadu<Packet16f>(const float* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_ps(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d ploadu<Packet8d>(const double* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_pd(from);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16i ploadu<Packet16i>(const int* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_loadu_si512(
+      reinterpret_cast<const __m512i*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16f ploadu<Packet16f>(const float* from, uint16_t umask) {
+  __mmask16 mask = static_cast<__mmask16>(umask);
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_maskz_loadu_ps(mask, from);
+}
+
+// Loads 8 floats from memory a returns the packet
+// {a0, a0  a1, a1, a2, a2, a3, a3, a4, a4, a5, a5, a6, a6, a7, a7}
+template <>
+EIGEN_STRONG_INLINE Packet16f ploaddup<Packet16f>(const float* from) {
+  // an unaligned load is required here as there is no requirement
+  // on the alignment of input pointer 'from'
+  __m256i low_half = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
+  __m512 even_elements = _mm512_castsi512_ps(_mm512_cvtepu32_epi64(low_half));
+  __m512 pairs = _mm512_permute_ps(even_elements, _MM_SHUFFLE(2, 2, 0, 0));
+  return pairs;
+}
+
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+// FIXME: this does not look optimal, better load a Packet4d and shuffle...
+// Loads 4 doubles from memory a returns the packet {a0, a0  a1, a1, a2, a2, a3,
+// a3}
+template <>
+EIGEN_STRONG_INLINE Packet8d ploaddup<Packet8d>(const double* from) {
+ __m512d x = _mm512_setzero_pd();
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[0]), 0);
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[1]), 1);
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[2]), 2);
+  x = _mm512_insertf64x2(x, _mm_loaddup_pd(&from[3]), 3);
+  return x;
+}
+#else
+template <>
+EIGEN_STRONG_INLINE Packet8d ploaddup<Packet8d>(const double* from) {
+  __m512d x = _mm512_setzero_pd();
+  x = _mm512_mask_broadcastsd_pd(x, 0x3<<0, _mm_load_sd(from+0));
+  x = _mm512_mask_broadcastsd_pd(x, 0x3<<2, _mm_load_sd(from+1));
+  x = _mm512_mask_broadcastsd_pd(x, 0x3<<4, _mm_load_sd(from+2));
+  x = _mm512_mask_broadcastsd_pd(x, 0x3<<6, _mm_load_sd(from+3));
+  return x;
+}
+#endif
+
+// Loads 4 floats from memory a returns the packet
+// {a0, a0  a0, a0, a1, a1, a1, a1, a2, a2, a2, a2, a3, a3, a3, a3}
+template <>
+EIGEN_STRONG_INLINE Packet16f ploadquad<Packet16f>(const float* from) {
+  Packet16f tmp = _mm512_castps128_ps512(ploadu<Packet4f>(from));
+  const Packet16i scatter_mask = _mm512_set_epi32(3,3,3,3, 2,2,2,2, 1,1,1,1, 0,0,0,0);
+  return _mm512_permutexvar_ps(scatter_mask, tmp);
+}
+
+// Loads 2 doubles from memory a returns the packet
+// {a0, a0  a0, a0, a1, a1, a1, a1}
+template <>
+EIGEN_STRONG_INLINE Packet8d ploadquad<Packet8d>(const double* from) {
+  __m256d lane0 = _mm256_set1_pd(*from);
+  __m256d lane1 = _mm256_set1_pd(*(from+1));
+  __m512d tmp = _mm512_undefined_pd();
+  tmp = _mm512_insertf64x4(tmp, lane0, 0);
+  return _mm512_insertf64x4(tmp, lane1, 1);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet16f& from) {
+  EIGEN_DEBUG_ALIGNED_STORE _mm512_store_ps(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet8d& from) {
+  EIGEN_DEBUG_ALIGNED_STORE _mm512_store_pd(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore<int>(int* to, const Packet16i& from) {
+  EIGEN_DEBUG_ALIGNED_STORE _mm512_storeu_si512(reinterpret_cast<__m512i*>(to),
+                                                from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet16f& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_ps(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet8d& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_pd(to, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstoreu<int>(int* to, const Packet16i& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE _mm512_storeu_si512(
+      reinterpret_cast<__m512i*>(to), from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet16f& from, uint16_t umask) {
+  __mmask16 mask = static_cast<__mmask16>(umask);
+  EIGEN_DEBUG_UNALIGNED_STORE return _mm512_mask_storeu_ps(to, mask, from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet16f pgather<float, Packet16f>(const float* from,
+                                                             Index stride) {
+  Packet16i stride_vector = _mm512_set1_epi32(convert_index<int>(stride));
+  Packet16i stride_multiplier =
+      _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  Packet16i indices = _mm512_mullo_epi32(stride_vector, stride_multiplier);
+
+  return _mm512_i32gather_ps(indices, from, 4);
+}
+template <>
+EIGEN_DEVICE_FUNC inline Packet8d pgather<double, Packet8d>(const double* from,
+                                                            Index stride) {
+  Packet8i stride_vector = _mm256_set1_epi32(convert_index<int>(stride));
+  Packet8i stride_multiplier = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
+  Packet8i indices = _mm256_mullo_epi32(stride_vector, stride_multiplier);
+
+  return _mm512_i32gather_pd(indices, from, 8);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<float, Packet16f>(float* to,
+                                                         const Packet16f& from,
+                                                         Index stride) {
+  Packet16i stride_vector = _mm512_set1_epi32(convert_index<int>(stride));
+  Packet16i stride_multiplier =
+      _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  Packet16i indices = _mm512_mullo_epi32(stride_vector, stride_multiplier);
+  _mm512_i32scatter_ps(to, indices, from, 4);
+}
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<double, Packet8d>(double* to,
+                                                         const Packet8d& from,
+                                                         Index stride) {
+  Packet8i stride_vector = _mm256_set1_epi32(convert_index<int>(stride));
+  Packet8i stride_multiplier = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
+  Packet8i indices = _mm256_mullo_epi32(stride_vector, stride_multiplier);
+  _mm512_i32scatter_pd(to, indices, from, 8);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore1<Packet16f>(float* to, const float& a) {
+  Packet16f pa = pset1<Packet16f>(a);
+  pstore(to, pa);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore1<Packet8d>(double* to, const double& a) {
+  Packet8d pa = pset1<Packet8d>(a);
+  pstore(to, pa);
+}
+template <>
+EIGEN_STRONG_INLINE void pstore1<Packet16i>(int* to, const int& a) {
+  Packet16i pa = pset1<Packet16i>(a);
+  pstore(to, pa);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+
+template <>
+EIGEN_STRONG_INLINE float pfirst<Packet16f>(const Packet16f& a) {
+  return _mm_cvtss_f32(_mm512_extractf32x4_ps(a, 0));
+}
+template <>
+EIGEN_STRONG_INLINE double pfirst<Packet8d>(const Packet8d& a) {
+  return _mm_cvtsd_f64(_mm256_extractf128_pd(_mm512_extractf64x4_pd(a, 0), 0));
+}
+template <>
+EIGEN_STRONG_INLINE int pfirst<Packet16i>(const Packet16i& a) {
+  return _mm_extract_epi32(_mm512_extracti32x4_epi32(a, 0), 0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f preverse(const Packet16f& a)
+{
+  return _mm512_permutexvar_ps(_mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8d preverse(const Packet8d& a)
+{
+  return _mm512_permutexvar_pd(_mm512_set_epi32(0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pabs(const Packet16f& a)
+{
+  // _mm512_abs_ps intrinsic not found, so hack around it
+  return _mm512_castsi512_ps(_mm512_and_si512(_mm512_castps_si512(a), _mm512_set1_epi32(0x7fffffff)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pabs(const Packet8d& a) {
+  // _mm512_abs_ps intrinsic not found, so hack around it
+  return _mm512_castsi512_pd(_mm512_and_si512(_mm512_castpd_si512(a),
+                                   _mm512_set1_epi64(0x7fffffffffffffff)));
+}
+
+template<>
+EIGEN_STRONG_INLINE Packet16f pfrexp<Packet16f>(const Packet16f& a, Packet16f& exponent){
+  return pfrexp_generic(a, exponent);
+}
+
+// Extract exponent without existence of Packet8l.
+template<>
+EIGEN_STRONG_INLINE  
+Packet8d pfrexp_generic_get_biased_exponent(const Packet8d& a) {
+  const Packet8d cst_exp_mask  = pset1frombits<Packet8d>(static_cast<uint64_t>(0x7ff0000000000000ull));
+  #ifdef EIGEN_VECTORIZE_AVX512DQ
+  return _mm512_cvtepi64_pd(_mm512_srli_epi64(_mm512_castpd_si512(pand(a, cst_exp_mask)), 52));
+  #else
+  return _mm512_cvtepi32_pd(_mm512_cvtepi64_epi32(_mm512_srli_epi64(_mm512_castpd_si512(pand(a, cst_exp_mask)), 52)));
+  #endif
+}
+
+template<>
+EIGEN_STRONG_INLINE Packet8d pfrexp<Packet8d>(const Packet8d& a, Packet8d& exponent) {
+  return pfrexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pldexp<Packet16f>(const Packet16f& a, const Packet16f& exponent) {
+  return pldexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8d pldexp<Packet8d>(const Packet8d& a, const Packet8d& exponent) {
+  // Clamp exponent to [-2099, 2099]
+  const Packet8d max_exponent = pset1<Packet8d>(2099.0);
+  const Packet8i e = _mm512_cvtpd_epi32(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
+  
+  // Split 2^e into four factors and multiply.
+  const Packet8i bias = pset1<Packet8i>(1023);
+  Packet8i b = parithmetic_shift_right<2>(e);  // floor(e/4)
+  
+  // 2^b
+  const Packet8i permute_idx = _mm256_setr_epi32(0, 4, 1, 5, 2, 6, 3, 7);
+  Packet8i hi = _mm256_permutevar8x32_epi32(padd(b, bias), permute_idx);
+  Packet8i lo = _mm256_slli_epi64(hi, 52);
+  hi = _mm256_slli_epi64(_mm256_srli_epi64(hi, 32), 52);
+  Packet8d c = _mm512_castsi512_pd(_mm512_inserti64x4(_mm512_castsi256_si512(lo), hi, 1));
+  Packet8d out = pmul(pmul(pmul(a, c), c), c);  // a * 2^(3b)
+  
+  // 2^(e - 3b)
+  b = psub(psub(psub(e, b), b), b);  // e - 3b
+  hi = _mm256_permutevar8x32_epi32(padd(b, bias), permute_idx);
+  lo = _mm256_slli_epi64(hi, 52);
+  hi = _mm256_slli_epi64(_mm256_srli_epi64(hi, 32), 52);
+  c = _mm512_castsi512_pd(_mm512_inserti64x4(_mm512_castsi256_si512(lo), hi, 1));
+  out = pmul(out, c);  // a * 2^e
+  return out;
+}
+
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+// AVX512F does not define _mm512_extractf32x8_ps to extract _m256 from _m512
+#define EIGEN_EXTRACT_8f_FROM_16f(INPUT, OUTPUT)                           \
+  __m256 OUTPUT##_0 = _mm512_extractf32x8_ps(INPUT, 0);                    \
+  __m256 OUTPUT##_1 = _mm512_extractf32x8_ps(INPUT, 1)
+#else
+#define EIGEN_EXTRACT_8f_FROM_16f(INPUT, OUTPUT)                \
+  __m256 OUTPUT##_0 = _mm256_insertf128_ps(                     \
+      _mm256_castps128_ps256(_mm512_extractf32x4_ps(INPUT, 0)), \
+      _mm512_extractf32x4_ps(INPUT, 1), 1);                     \
+  __m256 OUTPUT##_1 = _mm256_insertf128_ps(                     \
+      _mm256_castps128_ps256(_mm512_extractf32x4_ps(INPUT, 2)), \
+      _mm512_extractf32x4_ps(INPUT, 3), 1);
+#endif
+
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+#define EIGEN_INSERT_8f_INTO_16f(OUTPUT, INPUTA, INPUTB) \
+  OUTPUT = _mm512_insertf32x8(_mm512_castps256_ps512(INPUTA), INPUTB, 1);
+#else
+#define EIGEN_INSERT_8f_INTO_16f(OUTPUT, INPUTA, INPUTB)                    \
+  OUTPUT = _mm512_undefined_ps();                                           \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTA, 0), 0); \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTA, 1), 1); \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTB, 0), 2); \
+  OUTPUT = _mm512_insertf32x4(OUTPUT, _mm256_extractf128_ps(INPUTB, 1), 3);
+#endif
+
+template <>
+EIGEN_STRONG_INLINE float predux<Packet16f>(const Packet16f& a) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  __m256 lane0 = _mm512_extractf32x8_ps(a, 0);
+  __m256 lane1 = _mm512_extractf32x8_ps(a, 1);
+  Packet8f x = _mm256_add_ps(lane0, lane1);
+  return predux<Packet8f>(x);
+#else
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 sum = _mm_add_ps(_mm_add_ps(lane0, lane1), _mm_add_ps(lane2, lane3));
+  sum = _mm_hadd_ps(sum, sum);
+  sum = _mm_hadd_ps(sum, _mm_permute_ps(sum, 1));
+  return _mm_cvtss_f32(sum);
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE double predux<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d sum = _mm256_add_pd(lane0, lane1);
+  __m256d tmp0 = _mm256_hadd_pd(sum, _mm256_permute2f128_pd(sum, sum, 1));
+  return _mm_cvtsd_f64(_mm256_castpd256_pd128(_mm256_hadd_pd(tmp0, tmp0)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8f predux_half_dowto4<Packet16f>(const Packet16f& a) {
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+  __m256 lane0 = _mm512_extractf32x8_ps(a, 0);
+  __m256 lane1 = _mm512_extractf32x8_ps(a, 1);
+  return _mm256_add_ps(lane0, lane1);
+#else
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 sum0 = _mm_add_ps(lane0, lane2);
+  __m128 sum1 = _mm_add_ps(lane1, lane3);
+  return _mm256_insertf128_ps(_mm256_castps128_ps256(sum0), sum1, 1);
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet4d predux_half_dowto4<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  return _mm256_add_pd(lane0, lane1);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_mul<Packet16f>(const Packet16f& a) {
+//#ifdef EIGEN_VECTORIZE_AVX512DQ
+#if 0
+  Packet8f lane0 = _mm512_extractf32x8_ps(a, 0);
+  Packet8f lane1 = _mm512_extractf32x8_ps(a, 1);
+  Packet8f res = pmul(lane0, lane1);
+  res = pmul(res, _mm256_permute2f128_ps(res, res, 1));
+  res = pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+#else
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 res = pmul(pmul(lane0, lane1), pmul(lane2, lane3));
+  res = pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(pmul(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE double predux_mul<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d res = pmul(lane0, lane1);
+  res = pmul(res, _mm256_permute2f128_pd(res, res, 1));
+  return pfirst(pmul(res, _mm256_shuffle_pd(res, res, 1)));
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_min<Packet16f>(const Packet16f& a) {
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 res = _mm_min_ps(_mm_min_ps(lane0, lane1), _mm_min_ps(lane2, lane3));
+  res = _mm_min_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(_mm_min_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+}
+template <>
+EIGEN_STRONG_INLINE double predux_min<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d res = _mm256_min_pd(lane0, lane1);
+  res = _mm256_min_pd(res, _mm256_permute2f128_pd(res, res, 1));
+  return pfirst(_mm256_min_pd(res, _mm256_shuffle_pd(res, res, 1)));
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_max<Packet16f>(const Packet16f& a) {
+  __m128 lane0 = _mm512_extractf32x4_ps(a, 0);
+  __m128 lane1 = _mm512_extractf32x4_ps(a, 1);
+  __m128 lane2 = _mm512_extractf32x4_ps(a, 2);
+  __m128 lane3 = _mm512_extractf32x4_ps(a, 3);
+  __m128 res = _mm_max_ps(_mm_max_ps(lane0, lane1), _mm_max_ps(lane2, lane3));
+  res = _mm_max_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 3, 2)));
+  return pfirst(_mm_max_ps(res, _mm_permute_ps(res, _MM_SHUFFLE(0, 0, 0, 1))));
+}
+
+template <>
+EIGEN_STRONG_INLINE double predux_max<Packet8d>(const Packet8d& a) {
+  __m256d lane0 = _mm512_extractf64x4_pd(a, 0);
+  __m256d lane1 = _mm512_extractf64x4_pd(a, 1);
+  __m256d res = _mm256_max_pd(lane0, lane1);
+  res = _mm256_max_pd(res, _mm256_permute2f128_pd(res, res, 1));
+  return pfirst(_mm256_max_pd(res, _mm256_shuffle_pd(res, res, 1)));
+}
+
+template<> EIGEN_STRONG_INLINE bool predux_any(const Packet16f& x)
+{
+  Packet16i xi = _mm512_castps_si512(x);
+  __mmask16 tmp = _mm512_test_epi32_mask(xi,xi);
+  return !_mm512_kortestz(tmp,tmp);
+}
+
+
+
+#define PACK_OUTPUT(OUTPUT, INPUT, INDEX, STRIDE) \
+  EIGEN_INSERT_8f_INTO_16f(OUTPUT[INDEX], INPUT[INDEX], INPUT[INDEX + STRIDE]);
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet16f, 16>& kernel) {
+  __m512 T0 = _mm512_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T1 = _mm512_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T2 = _mm512_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m512 T3 = _mm512_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+  __m512 T4 = _mm512_unpacklo_ps(kernel.packet[4], kernel.packet[5]);
+  __m512 T5 = _mm512_unpackhi_ps(kernel.packet[4], kernel.packet[5]);
+  __m512 T6 = _mm512_unpacklo_ps(kernel.packet[6], kernel.packet[7]);
+  __m512 T7 = _mm512_unpackhi_ps(kernel.packet[6], kernel.packet[7]);
+  __m512 T8 = _mm512_unpacklo_ps(kernel.packet[8], kernel.packet[9]);
+  __m512 T9 = _mm512_unpackhi_ps(kernel.packet[8], kernel.packet[9]);
+  __m512 T10 = _mm512_unpacklo_ps(kernel.packet[10], kernel.packet[11]);
+  __m512 T11 = _mm512_unpackhi_ps(kernel.packet[10], kernel.packet[11]);
+  __m512 T12 = _mm512_unpacklo_ps(kernel.packet[12], kernel.packet[13]);
+  __m512 T13 = _mm512_unpackhi_ps(kernel.packet[12], kernel.packet[13]);
+  __m512 T14 = _mm512_unpacklo_ps(kernel.packet[14], kernel.packet[15]);
+  __m512 T15 = _mm512_unpackhi_ps(kernel.packet[14], kernel.packet[15]);
+  __m512 S0 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S1 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S2 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S3 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S4 = _mm512_shuffle_ps(T4, T6, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S5 = _mm512_shuffle_ps(T4, T6, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S6 = _mm512_shuffle_ps(T5, T7, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S7 = _mm512_shuffle_ps(T5, T7, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S8 = _mm512_shuffle_ps(T8, T10, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S9 = _mm512_shuffle_ps(T8, T10, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S10 = _mm512_shuffle_ps(T9, T11, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S11 = _mm512_shuffle_ps(T9, T11, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S12 = _mm512_shuffle_ps(T12, T14, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S13 = _mm512_shuffle_ps(T12, T14, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S14 = _mm512_shuffle_ps(T13, T15, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S15 = _mm512_shuffle_ps(T13, T15, _MM_SHUFFLE(3, 2, 3, 2));
+
+  EIGEN_EXTRACT_8f_FROM_16f(S0, S0);
+  EIGEN_EXTRACT_8f_FROM_16f(S1, S1);
+  EIGEN_EXTRACT_8f_FROM_16f(S2, S2);
+  EIGEN_EXTRACT_8f_FROM_16f(S3, S3);
+  EIGEN_EXTRACT_8f_FROM_16f(S4, S4);
+  EIGEN_EXTRACT_8f_FROM_16f(S5, S5);
+  EIGEN_EXTRACT_8f_FROM_16f(S6, S6);
+  EIGEN_EXTRACT_8f_FROM_16f(S7, S7);
+  EIGEN_EXTRACT_8f_FROM_16f(S8, S8);
+  EIGEN_EXTRACT_8f_FROM_16f(S9, S9);
+  EIGEN_EXTRACT_8f_FROM_16f(S10, S10);
+  EIGEN_EXTRACT_8f_FROM_16f(S11, S11);
+  EIGEN_EXTRACT_8f_FROM_16f(S12, S12);
+  EIGEN_EXTRACT_8f_FROM_16f(S13, S13);
+  EIGEN_EXTRACT_8f_FROM_16f(S14, S14);
+  EIGEN_EXTRACT_8f_FROM_16f(S15, S15);
+
+  PacketBlock<Packet8f, 32> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_ps(S0_0, S4_0, 0x20);
+  tmp.packet[1] = _mm256_permute2f128_ps(S1_0, S5_0, 0x20);
+  tmp.packet[2] = _mm256_permute2f128_ps(S2_0, S6_0, 0x20);
+  tmp.packet[3] = _mm256_permute2f128_ps(S3_0, S7_0, 0x20);
+  tmp.packet[4] = _mm256_permute2f128_ps(S0_0, S4_0, 0x31);
+  tmp.packet[5] = _mm256_permute2f128_ps(S1_0, S5_0, 0x31);
+  tmp.packet[6] = _mm256_permute2f128_ps(S2_0, S6_0, 0x31);
+  tmp.packet[7] = _mm256_permute2f128_ps(S3_0, S7_0, 0x31);
+
+  tmp.packet[8] = _mm256_permute2f128_ps(S0_1, S4_1, 0x20);
+  tmp.packet[9] = _mm256_permute2f128_ps(S1_1, S5_1, 0x20);
+  tmp.packet[10] = _mm256_permute2f128_ps(S2_1, S6_1, 0x20);
+  tmp.packet[11] = _mm256_permute2f128_ps(S3_1, S7_1, 0x20);
+  tmp.packet[12] = _mm256_permute2f128_ps(S0_1, S4_1, 0x31);
+  tmp.packet[13] = _mm256_permute2f128_ps(S1_1, S5_1, 0x31);
+  tmp.packet[14] = _mm256_permute2f128_ps(S2_1, S6_1, 0x31);
+  tmp.packet[15] = _mm256_permute2f128_ps(S3_1, S7_1, 0x31);
+
+  // Second set of _m256 outputs
+  tmp.packet[16] = _mm256_permute2f128_ps(S8_0, S12_0, 0x20);
+  tmp.packet[17] = _mm256_permute2f128_ps(S9_0, S13_0, 0x20);
+  tmp.packet[18] = _mm256_permute2f128_ps(S10_0, S14_0, 0x20);
+  tmp.packet[19] = _mm256_permute2f128_ps(S11_0, S15_0, 0x20);
+  tmp.packet[20] = _mm256_permute2f128_ps(S8_0, S12_0, 0x31);
+  tmp.packet[21] = _mm256_permute2f128_ps(S9_0, S13_0, 0x31);
+  tmp.packet[22] = _mm256_permute2f128_ps(S10_0, S14_0, 0x31);
+  tmp.packet[23] = _mm256_permute2f128_ps(S11_0, S15_0, 0x31);
+
+  tmp.packet[24] = _mm256_permute2f128_ps(S8_1, S12_1, 0x20);
+  tmp.packet[25] = _mm256_permute2f128_ps(S9_1, S13_1, 0x20);
+  tmp.packet[26] = _mm256_permute2f128_ps(S10_1, S14_1, 0x20);
+  tmp.packet[27] = _mm256_permute2f128_ps(S11_1, S15_1, 0x20);
+  tmp.packet[28] = _mm256_permute2f128_ps(S8_1, S12_1, 0x31);
+  tmp.packet[29] = _mm256_permute2f128_ps(S9_1, S13_1, 0x31);
+  tmp.packet[30] = _mm256_permute2f128_ps(S10_1, S14_1, 0x31);
+  tmp.packet[31] = _mm256_permute2f128_ps(S11_1, S15_1, 0x31);
+
+  // Pack them into the output
+  PACK_OUTPUT(kernel.packet, tmp.packet, 0, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 1, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 2, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 3, 16);
+
+  PACK_OUTPUT(kernel.packet, tmp.packet, 4, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 5, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 6, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 7, 16);
+
+  PACK_OUTPUT(kernel.packet, tmp.packet, 8, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 9, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 10, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 11, 16);
+
+  PACK_OUTPUT(kernel.packet, tmp.packet, 12, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 13, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 14, 16);
+  PACK_OUTPUT(kernel.packet, tmp.packet, 15, 16);
+}
+#define PACK_OUTPUT_2(OUTPUT, INPUT, INDEX, STRIDE)         \
+  EIGEN_INSERT_8f_INTO_16f(OUTPUT[INDEX], INPUT[2 * INDEX], \
+                           INPUT[2 * INDEX + STRIDE]);
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet16f, 4>& kernel) {
+  __m512 T0 = _mm512_unpacklo_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T1 = _mm512_unpackhi_ps(kernel.packet[0], kernel.packet[1]);
+  __m512 T2 = _mm512_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
+  __m512 T3 = _mm512_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
+
+  __m512 S0 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S1 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S2 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S3 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
+
+  EIGEN_EXTRACT_8f_FROM_16f(S0, S0);
+  EIGEN_EXTRACT_8f_FROM_16f(S1, S1);
+  EIGEN_EXTRACT_8f_FROM_16f(S2, S2);
+  EIGEN_EXTRACT_8f_FROM_16f(S3, S3);
+
+  PacketBlock<Packet8f, 8> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_ps(S0_0, S1_0, 0x20);
+  tmp.packet[1] = _mm256_permute2f128_ps(S2_0, S3_0, 0x20);
+  tmp.packet[2] = _mm256_permute2f128_ps(S0_0, S1_0, 0x31);
+  tmp.packet[3] = _mm256_permute2f128_ps(S2_0, S3_0, 0x31);
+
+  tmp.packet[4] = _mm256_permute2f128_ps(S0_1, S1_1, 0x20);
+  tmp.packet[5] = _mm256_permute2f128_ps(S2_1, S3_1, 0x20);
+  tmp.packet[6] = _mm256_permute2f128_ps(S0_1, S1_1, 0x31);
+  tmp.packet[7] = _mm256_permute2f128_ps(S2_1, S3_1, 0x31);
+
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 0, 1);
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 1, 1);
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 2, 1);
+  PACK_OUTPUT_2(kernel.packet, tmp.packet, 3, 1);
+}
+
+#define PACK_OUTPUT_SQ_D(OUTPUT, INPUT, INDEX, STRIDE)                \
+  OUTPUT[INDEX] = _mm512_insertf64x4(OUTPUT[INDEX], INPUT[INDEX], 0); \
+  OUTPUT[INDEX] = _mm512_insertf64x4(OUTPUT[INDEX], INPUT[INDEX + STRIDE], 1);
+
+#define PACK_OUTPUT_D(OUTPUT, INPUT, INDEX, STRIDE)                         \
+  OUTPUT[INDEX] = _mm512_insertf64x4(OUTPUT[INDEX], INPUT[(2 * INDEX)], 0); \
+  OUTPUT[INDEX] =                                                           \
+      _mm512_insertf64x4(OUTPUT[INDEX], INPUT[(2 * INDEX) + STRIDE], 1);
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8d, 4>& kernel) {
+  __m512d T0 = _mm512_shuffle_pd(kernel.packet[0], kernel.packet[1], 0);
+  __m512d T1 = _mm512_shuffle_pd(kernel.packet[0], kernel.packet[1], 0xff);
+  __m512d T2 = _mm512_shuffle_pd(kernel.packet[2], kernel.packet[3], 0);
+  __m512d T3 = _mm512_shuffle_pd(kernel.packet[2], kernel.packet[3], 0xff);
+
+  PacketBlock<Packet4d, 8> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x20);
+  tmp.packet[1] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x20);
+  tmp.packet[2] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x31);
+  tmp.packet[3] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x31);
+
+  tmp.packet[4] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x20);
+  tmp.packet[5] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x20);
+  tmp.packet[6] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x31);
+  tmp.packet[7] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x31);
+
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 0, 1);
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 1, 1);
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 2, 1);
+  PACK_OUTPUT_D(kernel.packet, tmp.packet, 3, 1);
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet8d, 8>& kernel) {
+  __m512d T0 = _mm512_unpacklo_pd(kernel.packet[0], kernel.packet[1]);
+  __m512d T1 = _mm512_unpackhi_pd(kernel.packet[0], kernel.packet[1]);
+  __m512d T2 = _mm512_unpacklo_pd(kernel.packet[2], kernel.packet[3]);
+  __m512d T3 = _mm512_unpackhi_pd(kernel.packet[2], kernel.packet[3]);
+  __m512d T4 = _mm512_unpacklo_pd(kernel.packet[4], kernel.packet[5]);
+  __m512d T5 = _mm512_unpackhi_pd(kernel.packet[4], kernel.packet[5]);
+  __m512d T6 = _mm512_unpacklo_pd(kernel.packet[6], kernel.packet[7]);
+  __m512d T7 = _mm512_unpackhi_pd(kernel.packet[6], kernel.packet[7]);
+
+  PacketBlock<Packet4d, 16> tmp;
+
+  tmp.packet[0] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x20);
+  tmp.packet[1] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x20);
+  tmp.packet[2] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 0),
+                                         _mm512_extractf64x4_pd(T2, 0), 0x31);
+  tmp.packet[3] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 0),
+                                         _mm512_extractf64x4_pd(T3, 0), 0x31);
+
+  tmp.packet[4] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x20);
+  tmp.packet[5] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x20);
+  tmp.packet[6] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T0, 1),
+                                         _mm512_extractf64x4_pd(T2, 1), 0x31);
+  tmp.packet[7] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T1, 1),
+                                         _mm512_extractf64x4_pd(T3, 1), 0x31);
+
+  tmp.packet[8] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 0),
+                                         _mm512_extractf64x4_pd(T6, 0), 0x20);
+  tmp.packet[9] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 0),
+                                         _mm512_extractf64x4_pd(T7, 0), 0x20);
+  tmp.packet[10] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 0),
+                                          _mm512_extractf64x4_pd(T6, 0), 0x31);
+  tmp.packet[11] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 0),
+                                          _mm512_extractf64x4_pd(T7, 0), 0x31);
+
+  tmp.packet[12] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 1),
+                                          _mm512_extractf64x4_pd(T6, 1), 0x20);
+  tmp.packet[13] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 1),
+                                          _mm512_extractf64x4_pd(T7, 1), 0x20);
+  tmp.packet[14] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T4, 1),
+                                          _mm512_extractf64x4_pd(T6, 1), 0x31);
+  tmp.packet[15] = _mm256_permute2f128_pd(_mm512_extractf64x4_pd(T5, 1),
+                                          _mm512_extractf64x4_pd(T7, 1), 0x31);
+
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 0, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 1, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 2, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 3, 8);
+
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 4, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 5, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 6, 8);
+  PACK_OUTPUT_SQ_D(kernel.packet, tmp.packet, 7, 8);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16f pblend(const Selector<16>& /*ifPacket*/,
+                                     const Packet16f& /*thenPacket*/,
+                                     const Packet16f& /*elsePacket*/) {
+  assert(false && "To be implemented");
+  return Packet16f();
+}
+template <>
+EIGEN_STRONG_INLINE Packet8d pblend(const Selector<8>& ifPacket,
+                                    const Packet8d& thenPacket,
+                                    const Packet8d& elsePacket) {
+  __mmask8 m = (ifPacket.select[0]   )
+             | (ifPacket.select[1]<<1)
+             | (ifPacket.select[2]<<2)
+             | (ifPacket.select[3]<<3)
+             | (ifPacket.select[4]<<4)
+             | (ifPacket.select[5]<<5)
+             | (ifPacket.select[6]<<6)
+             | (ifPacket.select[7]<<7);
+  return _mm512_mask_blend_pd(m, elsePacket, thenPacket);
+}
+
+// Packet math for Eigen::half
+template<> EIGEN_STRONG_INLINE Packet16h pset1<Packet16h>(const Eigen::half& from) {
+  return _mm256_set1_epi16(from.x);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half pfirst<Packet16h>(const Packet16h& from) {
+  return half_impl::raw_uint16_to_half(static_cast<unsigned short>(_mm256_extract_epi16(from, 0)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pload<Packet16h>(const Eigen::half* from) {
+  return _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h ploadu<Packet16h>(const Eigen::half* from) {
+  return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<half>(Eigen::half* to, const Packet16h& from) {
+  // (void*) -> workaround clang warning:
+  // cast from 'Eigen::half *' to '__m256i *' increases required alignment from 2 to 32
+  _mm256_store_si256((__m256i*)(void*)to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<half>(Eigen::half* to, const Packet16h& from) {
+  // (void*) -> workaround clang warning:
+  // cast from 'Eigen::half *' to '__m256i *' increases required alignment from 2 to 32
+  _mm256_storeu_si256((__m256i*)(void*)to, from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h
+ploaddup<Packet16h>(const Eigen::half*  from) {
+  unsigned short a = from[0].x;
+  unsigned short b = from[1].x;
+  unsigned short c = from[2].x;
+  unsigned short d = from[3].x;
+  unsigned short e = from[4].x;
+  unsigned short f = from[5].x;
+  unsigned short g = from[6].x;
+  unsigned short h = from[7].x;
+  return _mm256_set_epi16(h, h, g, g, f, f, e, e, d, d, c, c, b, b, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h
+ploadquad(const Eigen::half* from) {
+  unsigned short a = from[0].x;
+  unsigned short b = from[1].x;
+  unsigned short c = from[2].x;
+  unsigned short d = from[3].x;
+  return _mm256_set_epi16(d, d, d, d, c, c, c, c, b, b, b, b, a, a, a, a);
+}
+
+EIGEN_STRONG_INLINE Packet16f half2float(const Packet16h& a) {
+#ifdef EIGEN_HAS_FP16_C
+  return _mm512_cvtph_ps(a);
+#else
+  EIGEN_ALIGN64 half aux[16];
+  pstore(aux, a);
+  float f0(aux[0]);
+  float f1(aux[1]);
+  float f2(aux[2]);
+  float f3(aux[3]);
+  float f4(aux[4]);
+  float f5(aux[5]);
+  float f6(aux[6]);
+  float f7(aux[7]);
+  float f8(aux[8]);
+  float f9(aux[9]);
+  float fa(aux[10]);
+  float fb(aux[11]);
+  float fc(aux[12]);
+  float fd(aux[13]);
+  float fe(aux[14]);
+  float ff(aux[15]);
+
+  return _mm512_set_ps(
+      ff, fe, fd, fc, fb, fa, f9, f8, f7, f6, f5, f4, f3, f2, f1, f0);
+#endif
+}
+
+EIGEN_STRONG_INLINE Packet16h float2half(const Packet16f& a) {
+#ifdef EIGEN_HAS_FP16_C
+  return _mm512_cvtps_ph(a, _MM_FROUND_TO_NEAREST_INT|_MM_FROUND_NO_EXC);
+#else
+  EIGEN_ALIGN64 float aux[16];
+  pstore(aux, a);
+  half h0(aux[0]);
+  half h1(aux[1]);
+  half h2(aux[2]);
+  half h3(aux[3]);
+  half h4(aux[4]);
+  half h5(aux[5]);
+  half h6(aux[6]);
+  half h7(aux[7]);
+  half h8(aux[8]);
+  half h9(aux[9]);
+  half ha(aux[10]);
+  half hb(aux[11]);
+  half hc(aux[12]);
+  half hd(aux[13]);
+  half he(aux[14]);
+  half hf(aux[15]);
+
+  return _mm256_set_epi16(
+      hf.x, he.x, hd.x, hc.x, hb.x, ha.x, h9.x, h8.x,
+      h7.x, h6.x, h5.x, h4.x, h3.x, h2.x, h1.x, h0.x);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h ptrue(const Packet16h& a) {
+  return ptrue(Packet8i(a));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16h pabs(const Packet16h& a) {
+  const __m256i sign_mask = _mm256_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm256_andnot_si256(sign_mask, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16h pmin<Packet16h>(const Packet16h& a,
+                                              const Packet16h& b) {
+  return float2half(pmin<Packet16f>(half2float(a), half2float(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16h pmax<Packet16h>(const Packet16h& a,
+                                              const Packet16h& b) {
+  return float2half(pmax<Packet16f>(half2float(a), half2float(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16h plset<Packet16h>(const half& a) {
+  return float2half(plset<Packet16f>(static_cast<float>(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h por(const Packet16h& a,const Packet16h& b) {
+  // in some cases Packet8i is a wrapper around __m256i, so we need to
+  // cast to Packet8i to call the correct overload.
+  return por(Packet8i(a),Packet8i(b));
+}
+template<> EIGEN_STRONG_INLINE Packet16h pxor(const Packet16h& a,const Packet16h& b) {
+  return pxor(Packet8i(a),Packet8i(b));
+}
+template<> EIGEN_STRONG_INLINE Packet16h pand(const Packet16h& a,const Packet16h& b) {
+  return pand(Packet8i(a),Packet8i(b));
+}
+template<> EIGEN_STRONG_INLINE Packet16h pandnot(const Packet16h& a,const Packet16h& b) {
+  return pandnot(Packet8i(a),Packet8i(b));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pselect(const Packet16h& mask, const Packet16h& a, const Packet16h& b) {
+  return _mm256_blendv_epi8(b, a, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pround<Packet16h>(const Packet16h& a) {
+  return float2half(pround<Packet16f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h print<Packet16h>(const Packet16h& a) {
+  return float2half(print<Packet16f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pceil<Packet16h>(const Packet16h& a) {
+  return float2half(pceil<Packet16f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pfloor<Packet16h>(const Packet16h& a) {
+  return float2half(pfloor<Packet16f>(half2float(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pcmp_eq(const Packet16h& a,const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  return Pack32To16(pcmp_eq(af, bf));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pcmp_le(const Packet16h& a,const Packet16h& b) {
+  return Pack32To16(pcmp_le(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pcmp_lt(const Packet16h& a,const Packet16h& b) {
+  return Pack32To16(pcmp_lt(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pcmp_lt_or_nan(const Packet16h& a,const Packet16h& b) {
+  return Pack32To16(pcmp_lt_or_nan(half2float(a), half2float(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pconj(const Packet16h& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet16h pnegate(const Packet16h& a) {
+  Packet16h sign_mask = _mm256_set1_epi16(static_cast<unsigned short>(0x8000));
+  return _mm256_xor_si256(a, sign_mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h padd<Packet16h>(const Packet16h& a, const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  Packet16f rf = padd(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h psub<Packet16h>(const Packet16h& a, const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  Packet16f rf = psub(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pmul<Packet16h>(const Packet16h& a, const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  Packet16f rf = pmul(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pdiv<Packet16h>(const Packet16h& a, const Packet16h& b) {
+  Packet16f af = half2float(a);
+  Packet16f bf = half2float(b);
+  Packet16f rf = pdiv(af, bf);
+  return float2half(rf);
+}
+
+template<> EIGEN_STRONG_INLINE half predux<Packet16h>(const Packet16h& from) {
+  Packet16f from_float = half2float(from);
+  return half(predux(from_float));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8h predux_half_dowto4<Packet16h>(const Packet16h& a) {
+  Packet8h lane0 = _mm256_extractf128_si256(a, 0);
+  Packet8h lane1 = _mm256_extractf128_si256(a, 1);
+  return padd<Packet8h>(lane0, lane1);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_max<Packet16h>(const Packet16h& a) {
+  Packet16f af = half2float(a);
+  float reduced = predux_max<Packet16f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half predux_min<Packet16h>(const Packet16h& a) {
+  Packet16f af = half2float(a);
+  float reduced = predux_min<Packet16f>(af);
+  return Eigen::half(reduced);
+}
+
+template<> EIGEN_STRONG_INLINE half predux_mul<Packet16h>(const Packet16h& from) {
+  Packet16f from_float = half2float(from);
+  return half(predux_mul(from_float));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h preverse(const Packet16h& a)
+{
+  __m128i m = _mm_setr_epi8(14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1);
+  return _mm256_insertf128_si256(
+                    _mm256_castsi128_si256(_mm_shuffle_epi8(_mm256_extractf128_si256(a,1),m)),
+                                           _mm_shuffle_epi8(_mm256_extractf128_si256(a,0),m), 1);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16h pgather<Eigen::half, Packet16h>(const Eigen::half* from, Index stride)
+{
+  return _mm256_set_epi16(
+      from[15*stride].x, from[14*stride].x, from[13*stride].x, from[12*stride].x,
+      from[11*stride].x, from[10*stride].x, from[9*stride].x, from[8*stride].x,
+      from[7*stride].x, from[6*stride].x, from[5*stride].x, from[4*stride].x,
+      from[3*stride].x, from[2*stride].x, from[1*stride].x, from[0*stride].x);
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<half, Packet16h>(half* to, const Packet16h& from, Index stride)
+{
+  EIGEN_ALIGN64 half aux[16];
+  pstore(aux, from);
+  to[stride*0] = aux[0];
+  to[stride*1] = aux[1];
+  to[stride*2] = aux[2];
+  to[stride*3] = aux[3];
+  to[stride*4] = aux[4];
+  to[stride*5] = aux[5];
+  to[stride*6] = aux[6];
+  to[stride*7] = aux[7];
+  to[stride*8] = aux[8];
+  to[stride*9] = aux[9];
+  to[stride*10] = aux[10];
+  to[stride*11] = aux[11];
+  to[stride*12] = aux[12];
+  to[stride*13] = aux[13];
+  to[stride*14] = aux[14];
+  to[stride*15] = aux[15];
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet16h,16>& kernel) {
+  __m256i a = kernel.packet[0];
+  __m256i b = kernel.packet[1];
+  __m256i c = kernel.packet[2];
+  __m256i d = kernel.packet[3];
+  __m256i e = kernel.packet[4];
+  __m256i f = kernel.packet[5];
+  __m256i g = kernel.packet[6];
+  __m256i h = kernel.packet[7];
+  __m256i i = kernel.packet[8];
+  __m256i j = kernel.packet[9];
+  __m256i k = kernel.packet[10];
+  __m256i l = kernel.packet[11];
+  __m256i m = kernel.packet[12];
+  __m256i n = kernel.packet[13];
+  __m256i o = kernel.packet[14];
+  __m256i p = kernel.packet[15];
+
+  __m256i ab_07 = _mm256_unpacklo_epi16(a, b);
+  __m256i cd_07 = _mm256_unpacklo_epi16(c, d);
+  __m256i ef_07 = _mm256_unpacklo_epi16(e, f);
+  __m256i gh_07 = _mm256_unpacklo_epi16(g, h);
+  __m256i ij_07 = _mm256_unpacklo_epi16(i, j);
+  __m256i kl_07 = _mm256_unpacklo_epi16(k, l);
+  __m256i mn_07 = _mm256_unpacklo_epi16(m, n);
+  __m256i op_07 = _mm256_unpacklo_epi16(o, p);
+
+  __m256i ab_8f = _mm256_unpackhi_epi16(a, b);
+  __m256i cd_8f = _mm256_unpackhi_epi16(c, d);
+  __m256i ef_8f = _mm256_unpackhi_epi16(e, f);
+  __m256i gh_8f = _mm256_unpackhi_epi16(g, h);
+  __m256i ij_8f = _mm256_unpackhi_epi16(i, j);
+  __m256i kl_8f = _mm256_unpackhi_epi16(k, l);
+  __m256i mn_8f = _mm256_unpackhi_epi16(m, n);
+  __m256i op_8f = _mm256_unpackhi_epi16(o, p);
+
+  __m256i abcd_03 = _mm256_unpacklo_epi32(ab_07, cd_07);
+  __m256i abcd_47 = _mm256_unpackhi_epi32(ab_07, cd_07);
+  __m256i efgh_03 = _mm256_unpacklo_epi32(ef_07, gh_07);
+  __m256i efgh_47 = _mm256_unpackhi_epi32(ef_07, gh_07);
+  __m256i ijkl_03 = _mm256_unpacklo_epi32(ij_07, kl_07);
+  __m256i ijkl_47 = _mm256_unpackhi_epi32(ij_07, kl_07);
+  __m256i mnop_03 = _mm256_unpacklo_epi32(mn_07, op_07);
+  __m256i mnop_47 = _mm256_unpackhi_epi32(mn_07, op_07);
+
+  __m256i abcd_8b = _mm256_unpacklo_epi32(ab_8f, cd_8f);
+  __m256i abcd_cf = _mm256_unpackhi_epi32(ab_8f, cd_8f);
+  __m256i efgh_8b = _mm256_unpacklo_epi32(ef_8f, gh_8f);
+  __m256i efgh_cf = _mm256_unpackhi_epi32(ef_8f, gh_8f);
+  __m256i ijkl_8b = _mm256_unpacklo_epi32(ij_8f, kl_8f);
+  __m256i ijkl_cf = _mm256_unpackhi_epi32(ij_8f, kl_8f);
+  __m256i mnop_8b = _mm256_unpacklo_epi32(mn_8f, op_8f);
+  __m256i mnop_cf = _mm256_unpackhi_epi32(mn_8f, op_8f);
+
+  __m256i abcdefgh_01 = _mm256_unpacklo_epi64(abcd_03, efgh_03);
+  __m256i abcdefgh_23 = _mm256_unpackhi_epi64(abcd_03, efgh_03);
+  __m256i ijklmnop_01 = _mm256_unpacklo_epi64(ijkl_03, mnop_03);
+  __m256i ijklmnop_23 = _mm256_unpackhi_epi64(ijkl_03, mnop_03);
+  __m256i abcdefgh_45 = _mm256_unpacklo_epi64(abcd_47, efgh_47);
+  __m256i abcdefgh_67 = _mm256_unpackhi_epi64(abcd_47, efgh_47);
+  __m256i ijklmnop_45 = _mm256_unpacklo_epi64(ijkl_47, mnop_47);
+  __m256i ijklmnop_67 = _mm256_unpackhi_epi64(ijkl_47, mnop_47);
+  __m256i abcdefgh_89 = _mm256_unpacklo_epi64(abcd_8b, efgh_8b);
+  __m256i abcdefgh_ab = _mm256_unpackhi_epi64(abcd_8b, efgh_8b);
+  __m256i ijklmnop_89 = _mm256_unpacklo_epi64(ijkl_8b, mnop_8b);
+  __m256i ijklmnop_ab = _mm256_unpackhi_epi64(ijkl_8b, mnop_8b);
+  __m256i abcdefgh_cd = _mm256_unpacklo_epi64(abcd_cf, efgh_cf);
+  __m256i abcdefgh_ef = _mm256_unpackhi_epi64(abcd_cf, efgh_cf);
+  __m256i ijklmnop_cd = _mm256_unpacklo_epi64(ijkl_cf, mnop_cf);
+  __m256i ijklmnop_ef = _mm256_unpackhi_epi64(ijkl_cf, mnop_cf);
+
+  // NOTE: no unpacklo/hi instr in this case, so using permute instr.
+  __m256i a_p_0 = _mm256_permute2x128_si256(abcdefgh_01, ijklmnop_01, 0x20);
+  __m256i a_p_1 = _mm256_permute2x128_si256(abcdefgh_23, ijklmnop_23, 0x20);
+  __m256i a_p_2 = _mm256_permute2x128_si256(abcdefgh_45, ijklmnop_45, 0x20);
+  __m256i a_p_3 = _mm256_permute2x128_si256(abcdefgh_67, ijklmnop_67, 0x20);
+  __m256i a_p_4 = _mm256_permute2x128_si256(abcdefgh_89, ijklmnop_89, 0x20);
+  __m256i a_p_5 = _mm256_permute2x128_si256(abcdefgh_ab, ijklmnop_ab, 0x20);
+  __m256i a_p_6 = _mm256_permute2x128_si256(abcdefgh_cd, ijklmnop_cd, 0x20);
+  __m256i a_p_7 = _mm256_permute2x128_si256(abcdefgh_ef, ijklmnop_ef, 0x20);
+  __m256i a_p_8 = _mm256_permute2x128_si256(abcdefgh_01, ijklmnop_01, 0x31);
+  __m256i a_p_9 = _mm256_permute2x128_si256(abcdefgh_23, ijklmnop_23, 0x31);
+  __m256i a_p_a = _mm256_permute2x128_si256(abcdefgh_45, ijklmnop_45, 0x31);
+  __m256i a_p_b = _mm256_permute2x128_si256(abcdefgh_67, ijklmnop_67, 0x31);
+  __m256i a_p_c = _mm256_permute2x128_si256(abcdefgh_89, ijklmnop_89, 0x31);
+  __m256i a_p_d = _mm256_permute2x128_si256(abcdefgh_ab, ijklmnop_ab, 0x31);
+  __m256i a_p_e = _mm256_permute2x128_si256(abcdefgh_cd, ijklmnop_cd, 0x31);
+  __m256i a_p_f = _mm256_permute2x128_si256(abcdefgh_ef, ijklmnop_ef, 0x31);
+
+  kernel.packet[0] = a_p_0;
+  kernel.packet[1] = a_p_1;
+  kernel.packet[2] = a_p_2;
+  kernel.packet[3] = a_p_3;
+  kernel.packet[4] = a_p_4;
+  kernel.packet[5] = a_p_5;
+  kernel.packet[6] = a_p_6;
+  kernel.packet[7] = a_p_7;
+  kernel.packet[8] = a_p_8;
+  kernel.packet[9] = a_p_9;
+  kernel.packet[10] = a_p_a;
+  kernel.packet[11] = a_p_b;
+  kernel.packet[12] = a_p_c;
+  kernel.packet[13] = a_p_d;
+  kernel.packet[14] = a_p_e;
+  kernel.packet[15] = a_p_f;
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet16h,8>& kernel) {
+  EIGEN_ALIGN64 half in[8][16];
+  pstore<half>(in[0], kernel.packet[0]);
+  pstore<half>(in[1], kernel.packet[1]);
+  pstore<half>(in[2], kernel.packet[2]);
+  pstore<half>(in[3], kernel.packet[3]);
+  pstore<half>(in[4], kernel.packet[4]);
+  pstore<half>(in[5], kernel.packet[5]);
+  pstore<half>(in[6], kernel.packet[6]);
+  pstore<half>(in[7], kernel.packet[7]);
+
+  EIGEN_ALIGN64 half out[8][16];
+
+  for (int i = 0; i < 8; ++i) {
+    for (int j = 0; j < 8; ++j) {
+      out[i][j] = in[j][2*i];
+    }
+    for (int j = 0; j < 8; ++j) {
+      out[i][j+8] = in[j][2*i+1];
+    }
+  }
+
+  kernel.packet[0] = pload<Packet16h>(out[0]);
+  kernel.packet[1] = pload<Packet16h>(out[1]);
+  kernel.packet[2] = pload<Packet16h>(out[2]);
+  kernel.packet[3] = pload<Packet16h>(out[3]);
+  kernel.packet[4] = pload<Packet16h>(out[4]);
+  kernel.packet[5] = pload<Packet16h>(out[5]);
+  kernel.packet[6] = pload<Packet16h>(out[6]);
+  kernel.packet[7] = pload<Packet16h>(out[7]);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet16h,4>& kernel) {
+  EIGEN_ALIGN64 half in[4][16];
+  pstore<half>(in[0], kernel.packet[0]);
+  pstore<half>(in[1], kernel.packet[1]);
+  pstore<half>(in[2], kernel.packet[2]);
+  pstore<half>(in[3], kernel.packet[3]);
+
+  EIGEN_ALIGN64 half out[4][16];
+
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      out[i][j] = in[j][4*i];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+4] = in[j][4*i+1];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+8] = in[j][4*i+2];
+    }
+    for (int j = 0; j < 4; ++j) {
+      out[i][j+12] = in[j][4*i+3];
+    }
+  }
+
+  kernel.packet[0] = pload<Packet16h>(out[0]);
+  kernel.packet[1] = pload<Packet16h>(out[1]);
+  kernel.packet[2] = pload<Packet16h>(out[2]);
+  kernel.packet[3] = pload<Packet16h>(out[3]);
+}
+
+template <> struct is_arithmetic<Packet16bf> { enum { value = true }; };
+
+template <>
+struct packet_traits<bfloat16> : default_packet_traits {
+  typedef Packet16bf type;
+  typedef Packet8bf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+    HasBlend = 0,
+    HasInsert = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+#if EIGEN_GNUC_AT_LEAST(5, 3) || (!EIGEN_COMP_GNUC_STRICT)
+#ifdef EIGEN_VECTORIZE_AVX512DQ
+    HasLog = 1,  // Currently fails test with bad accuracy.
+    HasLog1p  = 1,
+    HasExpm1  = 1,
+    HasNdtri = 1,
+    HasBessel  = 1,
+#endif
+    HasExp = 1,
+    HasSqrt = EIGEN_FAST_MATH,
+    HasRsqrt = EIGEN_FAST_MATH,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+#endif
+    HasCmp  = 1,
+    HasDiv = 1
+  };
+};
+
+template <>
+struct unpacket_traits<Packet16bf>
+{
+  typedef bfloat16 type;
+  enum {size=16, alignment=Aligned32, vectorizable=true, masked_load_available=false, masked_store_available=false};
+  typedef Packet8bf half;
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pset1<Packet16bf>(const bfloat16& from) {
+  return _mm256_set1_epi16(from.value);
+}
+
+template <>
+EIGEN_STRONG_INLINE bfloat16 pfirst<Packet16bf>(const Packet16bf& from) {
+  bfloat16 t;
+  t.value = static_cast<unsigned short>(_mm256_extract_epi16(from, 0));
+  return t;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pload<Packet16bf>(const bfloat16* from) {
+  return _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf ploadu<Packet16bf>(const bfloat16* from) {
+  return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<bfloat16>(bfloat16* to,
+                                          const Packet16bf& from) {
+  _mm256_store_si256(reinterpret_cast<__m256i*>(to), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<bfloat16>(bfloat16* to,
+                                           const Packet16bf& from) {
+  _mm256_storeu_si256(reinterpret_cast<__m256i*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf
+ploaddup<Packet16bf>(const bfloat16* from) {
+  Packet16bf r;
+  unsigned short a = from[0].value;
+  unsigned short b = from[1].value;
+  unsigned short c = from[2].value;
+  unsigned short d = from[3].value;
+  unsigned short e = from[4].value;
+  unsigned short f = from[5].value;
+  unsigned short g = from[6].value;
+  unsigned short h = from[7].value;
+  return _mm256_set_epi16(h, h, g, g, f, f, e, e, d, d, c, c, b, b, a, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf
+ploadquad(const bfloat16* from) {
+  Packet16bf r;
+  unsigned short a = from[0].value;
+  unsigned short b = from[1].value;
+  unsigned short c = from[2].value;
+  unsigned short d = from[3].value;
+  return _mm256_set_epi16(d, d, d, d, c, c, c, c, b, b, b, b, a, a, a, a);
+}
+
+EIGEN_STRONG_INLINE Packet16f Bf16ToF32(const Packet16bf& a) {
+  return _mm512_castsi512_ps(_mm512_slli_epi32(_mm512_cvtepu16_epi32(a), 16));
+}
+
+// Convert float to bfloat16 according to round-to-nearest-even/denormals algorithm.
+EIGEN_STRONG_INLINE Packet16bf F32ToBf16(const Packet16f& a) {
+  Packet16bf r;
+
+#if defined(EIGEN_VECTORIZE_AVX512BF16) && EIGEN_GNUC_AT_LEAST(10, 1)
+  // Since GCC 10.1 supports avx512bf16 and C style explicit cast
+  // (C++ static_cast is not supported yet), do converion via intrinsic
+  // and register path for performance.
+  r = (__m256i)(_mm512_cvtneps_pbh(a));
+
+#else
+  __m512i t;
+  __m512i input = _mm512_castps_si512(a);
+  __m512i nan = _mm512_set1_epi32(0x7fc0);
+
+  // uint32_t lsb = (input >> 16) & 1;
+  t = _mm512_and_si512(_mm512_srli_epi32(input, 16), _mm512_set1_epi32(1));
+  // uint32_t rounding_bias = 0x7fff + lsb;
+  t = _mm512_add_epi32(t, _mm512_set1_epi32(0x7fff));
+  // input += rounding_bias;
+  t = _mm512_add_epi32(t, input);
+  // input = input >> 16;
+  t = _mm512_srli_epi32(t, 16);
+
+  // Check NaN before converting back to bf16
+  __mmask16 mask = _mm512_cmp_ps_mask(a, a, _CMP_ORD_Q);
+
+  t = _mm512_mask_blend_epi32(mask, nan, t);
+  // output.value = static_cast<uint16_t>(input);
+  r = _mm512_cvtepi32_epi16(t);
+#endif // EIGEN_VECTORIZE_AVX512BF16
+
+  return r;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf ptrue(const Packet16bf& a) {
+  return ptrue<Packet8i>(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf por(const Packet16bf& a, const Packet16bf& b) {
+  return por<Packet8i>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pxor(const Packet16bf& a, const Packet16bf& b) {
+  return pxor<Packet8i>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pand(const Packet16bf& a, const Packet16bf& b) {
+  return pand<Packet8i>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pandnot(const Packet16bf& a,
+                                       const Packet16bf& b) {
+  return pandnot<Packet8i>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pselect(const Packet16bf& mask,
+                                       const Packet16bf& a,
+                                       const Packet16bf& b) {
+  // Input mask is expected to be all 0/1, handle it with 8-bit
+  // intrinsic for performance.
+  return _mm256_blendv_epi8(b, a, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf pround<Packet16bf>(const Packet16bf& a)
+{
+  return F32ToBf16(pround<Packet16f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf print<Packet16bf>(const Packet16bf& a) {
+  return F32ToBf16(print<Packet16f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf pceil<Packet16bf>(const Packet16bf& a) {
+  return F32ToBf16(pceil<Packet16f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16bf pfloor<Packet16bf>(const Packet16bf& a) {
+  return F32ToBf16(pfloor<Packet16f>(Bf16ToF32(a)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pcmp_eq(const Packet16bf& a,
+                                       const Packet16bf& b) {
+  return Pack32To16(pcmp_eq(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pcmp_le(const Packet16bf& a,
+                                       const Packet16bf& b) {
+  return Pack32To16(pcmp_le(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pcmp_lt(const Packet16bf& a,
+                                       const Packet16bf& b) {
+  return Pack32To16(pcmp_lt(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pcmp_lt_or_nan(const Packet16bf& a,
+                                              const Packet16bf& b) {
+  return Pack32To16(pcmp_lt_or_nan(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pnegate(const Packet16bf& a) {
+  Packet16bf sign_mask = _mm256_set1_epi16(static_cast<unsigned short>(0x8000));
+  return _mm256_xor_si256(a, sign_mask);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pconj(const Packet16bf& a) {
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pabs(const Packet16bf& a) {
+  const __m256i sign_mask = _mm256_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  return _mm256_andnot_si256(sign_mask, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf padd<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(padd<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf psub<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(psub<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pmul<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(pmul<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pdiv<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(pdiv<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pmin<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(pmin<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pmax<Packet16bf>(const Packet16bf& a,
+                                                const Packet16bf& b) {
+  return F32ToBf16(pmax<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf plset<Packet16bf>(const bfloat16& a) {
+  return F32ToBf16(plset<Packet16f>(static_cast<float>(a)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf predux_half_dowto4<Packet16bf>(const Packet16bf& a) {
+  Packet8bf lane0 = _mm256_extractf128_si256(a, 0);
+  Packet8bf lane1 = _mm256_extractf128_si256(a, 1);
+  return padd<Packet8bf>(lane0, lane1);
+}
+
+template <>
+EIGEN_STRONG_INLINE bfloat16 predux<Packet16bf>(const Packet16bf& p) {
+  return static_cast<bfloat16>(predux<Packet16f>(Bf16ToF32(p)));
+}
+
+template <>
+EIGEN_STRONG_INLINE bfloat16 predux_mul<Packet16bf>(const Packet16bf& from) {
+  return static_cast<bfloat16>(predux_mul<Packet16f>(Bf16ToF32(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE bfloat16 predux_min<Packet16bf>(const Packet16bf& from) {
+  return static_cast<bfloat16>(predux_min<Packet16f>(Bf16ToF32(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE bfloat16 predux_max<Packet16bf>(const Packet16bf& from) {
+  return static_cast<bfloat16>(predux_max<Packet16f>(Bf16ToF32(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf preverse(const Packet16bf& a) {
+  __m256i m = _mm256_setr_epi8(14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1,
+                               14,15,12,13,10,11,8,9,6,7,4,5,2,3,0,1);
+
+  Packet16bf res;
+  // Swap hi and lo first because shuffle is in 128-bit lanes.
+  res = _mm256_permute2x128_si256(a, a, 1);
+  // Shuffle 8-bit values in src within 2*128-bit lanes.
+  return _mm256_shuffle_epi8(res, m);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pgather<bfloat16, Packet16bf>(const bfloat16* from,
+                                                             Index stride) {
+  return _mm256_set_epi16(
+      from[15*stride].value, from[14*stride].value, from[13*stride].value, from[12*stride].value,
+      from[11*stride].value, from[10*stride].value, from[9*stride].value, from[8*stride].value,
+      from[7*stride].value, from[6*stride].value, from[5*stride].value, from[4*stride].value,
+      from[3*stride].value, from[2*stride].value, from[1*stride].value, from[0*stride].value);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pscatter<bfloat16, Packet16bf>(bfloat16* to,
+                                                        const Packet16bf& from,
+                                                        Index stride) {
+  EIGEN_ALIGN64 bfloat16 aux[16];
+  pstore(aux, from);
+  to[stride*0] = aux[0];
+  to[stride*1] = aux[1];
+  to[stride*2] = aux[2];
+  to[stride*3] = aux[3];
+  to[stride*4] = aux[4];
+  to[stride*5] = aux[5];
+  to[stride*6] = aux[6];
+  to[stride*7] = aux[7];
+  to[stride*8] = aux[8];
+  to[stride*9] = aux[9];
+  to[stride*10] = aux[10];
+  to[stride*11] = aux[11];
+  to[stride*12] = aux[12];
+  to[stride*13] = aux[13];
+  to[stride*14] = aux[14];
+  to[stride*15] = aux[15];
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16bf,16>& kernel) {
+  __m256i a = kernel.packet[0];
+  __m256i b = kernel.packet[1];
+  __m256i c = kernel.packet[2];
+  __m256i d = kernel.packet[3];
+  __m256i e = kernel.packet[4];
+  __m256i f = kernel.packet[5];
+  __m256i g = kernel.packet[6];
+  __m256i h = kernel.packet[7];
+  __m256i i = kernel.packet[8];
+  __m256i j = kernel.packet[9];
+  __m256i k = kernel.packet[10];
+  __m256i l = kernel.packet[11];
+  __m256i m = kernel.packet[12];
+  __m256i n = kernel.packet[13];
+  __m256i o = kernel.packet[14];
+  __m256i p = kernel.packet[15];
+
+  __m256i ab_07 = _mm256_unpacklo_epi16(a, b);
+  __m256i cd_07 = _mm256_unpacklo_epi16(c, d);
+  __m256i ef_07 = _mm256_unpacklo_epi16(e, f);
+  __m256i gh_07 = _mm256_unpacklo_epi16(g, h);
+  __m256i ij_07 = _mm256_unpacklo_epi16(i, j);
+  __m256i kl_07 = _mm256_unpacklo_epi16(k, l);
+  __m256i mn_07 = _mm256_unpacklo_epi16(m, n);
+  __m256i op_07 = _mm256_unpacklo_epi16(o, p);
+
+  __m256i ab_8f = _mm256_unpackhi_epi16(a, b);
+  __m256i cd_8f = _mm256_unpackhi_epi16(c, d);
+  __m256i ef_8f = _mm256_unpackhi_epi16(e, f);
+  __m256i gh_8f = _mm256_unpackhi_epi16(g, h);
+  __m256i ij_8f = _mm256_unpackhi_epi16(i, j);
+  __m256i kl_8f = _mm256_unpackhi_epi16(k, l);
+  __m256i mn_8f = _mm256_unpackhi_epi16(m, n);
+  __m256i op_8f = _mm256_unpackhi_epi16(o, p);
+
+  __m256i abcd_03 = _mm256_unpacklo_epi32(ab_07, cd_07);
+  __m256i abcd_47 = _mm256_unpackhi_epi32(ab_07, cd_07);
+  __m256i efgh_03 = _mm256_unpacklo_epi32(ef_07, gh_07);
+  __m256i efgh_47 = _mm256_unpackhi_epi32(ef_07, gh_07);
+  __m256i ijkl_03 = _mm256_unpacklo_epi32(ij_07, kl_07);
+  __m256i ijkl_47 = _mm256_unpackhi_epi32(ij_07, kl_07);
+  __m256i mnop_03 = _mm256_unpacklo_epi32(mn_07, op_07);
+  __m256i mnop_47 = _mm256_unpackhi_epi32(mn_07, op_07);
+
+  __m256i abcd_8b = _mm256_unpacklo_epi32(ab_8f, cd_8f);
+  __m256i abcd_cf = _mm256_unpackhi_epi32(ab_8f, cd_8f);
+  __m256i efgh_8b = _mm256_unpacklo_epi32(ef_8f, gh_8f);
+  __m256i efgh_cf = _mm256_unpackhi_epi32(ef_8f, gh_8f);
+  __m256i ijkl_8b = _mm256_unpacklo_epi32(ij_8f, kl_8f);
+  __m256i ijkl_cf = _mm256_unpackhi_epi32(ij_8f, kl_8f);
+  __m256i mnop_8b = _mm256_unpacklo_epi32(mn_8f, op_8f);
+  __m256i mnop_cf = _mm256_unpackhi_epi32(mn_8f, op_8f);
+
+  __m256i abcdefgh_01 = _mm256_unpacklo_epi64(abcd_03, efgh_03);
+  __m256i abcdefgh_23 = _mm256_unpackhi_epi64(abcd_03, efgh_03);
+  __m256i ijklmnop_01 = _mm256_unpacklo_epi64(ijkl_03, mnop_03);
+  __m256i ijklmnop_23 = _mm256_unpackhi_epi64(ijkl_03, mnop_03);
+  __m256i abcdefgh_45 = _mm256_unpacklo_epi64(abcd_47, efgh_47);
+  __m256i abcdefgh_67 = _mm256_unpackhi_epi64(abcd_47, efgh_47);
+  __m256i ijklmnop_45 = _mm256_unpacklo_epi64(ijkl_47, mnop_47);
+  __m256i ijklmnop_67 = _mm256_unpackhi_epi64(ijkl_47, mnop_47);
+  __m256i abcdefgh_89 = _mm256_unpacklo_epi64(abcd_8b, efgh_8b);
+  __m256i abcdefgh_ab = _mm256_unpackhi_epi64(abcd_8b, efgh_8b);
+  __m256i ijklmnop_89 = _mm256_unpacklo_epi64(ijkl_8b, mnop_8b);
+  __m256i ijklmnop_ab = _mm256_unpackhi_epi64(ijkl_8b, mnop_8b);
+  __m256i abcdefgh_cd = _mm256_unpacklo_epi64(abcd_cf, efgh_cf);
+  __m256i abcdefgh_ef = _mm256_unpackhi_epi64(abcd_cf, efgh_cf);
+  __m256i ijklmnop_cd = _mm256_unpacklo_epi64(ijkl_cf, mnop_cf);
+  __m256i ijklmnop_ef = _mm256_unpackhi_epi64(ijkl_cf, mnop_cf);
+
+  // NOTE: no unpacklo/hi instr in this case, so using permute instr.
+  kernel.packet[0] = _mm256_permute2x128_si256(abcdefgh_01, ijklmnop_01, 0x20);
+  kernel.packet[1] = _mm256_permute2x128_si256(abcdefgh_23, ijklmnop_23, 0x20);
+  kernel.packet[2] = _mm256_permute2x128_si256(abcdefgh_45, ijklmnop_45, 0x20);
+  kernel.packet[3] = _mm256_permute2x128_si256(abcdefgh_67, ijklmnop_67, 0x20);
+  kernel.packet[4] = _mm256_permute2x128_si256(abcdefgh_89, ijklmnop_89, 0x20);
+  kernel.packet[5] = _mm256_permute2x128_si256(abcdefgh_ab, ijklmnop_ab, 0x20);
+  kernel.packet[6] = _mm256_permute2x128_si256(abcdefgh_cd, ijklmnop_cd, 0x20);
+  kernel.packet[7] = _mm256_permute2x128_si256(abcdefgh_ef, ijklmnop_ef, 0x20);
+  kernel.packet[8] = _mm256_permute2x128_si256(abcdefgh_01, ijklmnop_01, 0x31);
+  kernel.packet[9] = _mm256_permute2x128_si256(abcdefgh_23, ijklmnop_23, 0x31);
+  kernel.packet[10] = _mm256_permute2x128_si256(abcdefgh_45, ijklmnop_45, 0x31);
+  kernel.packet[11] = _mm256_permute2x128_si256(abcdefgh_67, ijklmnop_67, 0x31);
+  kernel.packet[12] = _mm256_permute2x128_si256(abcdefgh_89, ijklmnop_89, 0x31);
+  kernel.packet[13] = _mm256_permute2x128_si256(abcdefgh_ab, ijklmnop_ab, 0x31);
+  kernel.packet[14] = _mm256_permute2x128_si256(abcdefgh_cd, ijklmnop_cd, 0x31);
+  kernel.packet[15] = _mm256_permute2x128_si256(abcdefgh_ef, ijklmnop_ef, 0x31);
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16bf,4>& kernel) {
+  __m256i a = kernel.packet[0];
+  __m256i b = kernel.packet[1];
+  __m256i c = kernel.packet[2];
+  __m256i d = kernel.packet[3];
+
+  __m256i ab_07 = _mm256_unpacklo_epi16(a, b);
+  __m256i cd_07 = _mm256_unpacklo_epi16(c, d);
+  __m256i ab_8f = _mm256_unpackhi_epi16(a, b);
+  __m256i cd_8f = _mm256_unpackhi_epi16(c, d);
+
+  __m256i abcd_03 = _mm256_unpacklo_epi32(ab_07, cd_07);
+  __m256i abcd_47 = _mm256_unpackhi_epi32(ab_07, cd_07);
+  __m256i abcd_8b = _mm256_unpacklo_epi32(ab_8f, cd_8f);
+  __m256i abcd_cf = _mm256_unpackhi_epi32(ab_8f, cd_8f);
+
+  // NOTE: no unpacklo/hi instr in this case, so using permute instr.
+  kernel.packet[0] = _mm256_permute2x128_si256(abcd_03, abcd_47, 0x20);
+  kernel.packet[1] = _mm256_permute2x128_si256(abcd_8b, abcd_cf, 0x20);
+  kernel.packet[2] = _mm256_permute2x128_si256(abcd_03, abcd_47, 0x31);
+  kernel.packet[3] = _mm256_permute2x128_si256(abcd_8b, abcd_cf, 0x31);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_AVX512_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/TypeCasting.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/TypeCasting.h
new file mode 100644
index 00000000..33041272
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AVX512/TypeCasting.h
@@ -0,0 +1,89 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2019 Rasmus Munk Larsen <rmlarsen@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_AVX512_H
+#define EIGEN_TYPE_CASTING_AVX512_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<> EIGEN_STRONG_INLINE Packet16i pcast<Packet16f, Packet16i>(const Packet16f& a) {
+  return _mm512_cvttps_epi32(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f pcast<Packet16i, Packet16f>(const Packet16i& a) {
+  return _mm512_cvtepi32_ps(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16i preinterpret<Packet16i, Packet16f>(const Packet16f& a) {
+  return _mm512_castps_si512(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16f preinterpret<Packet16f, Packet16i>(const Packet16i& a) {
+  return _mm512_castsi512_ps(a);
+}
+
+template <>
+struct type_casting_traits<half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet16f pcast<Packet16h, Packet16f>(const Packet16h& a) {
+  return half2float(a);
+}
+
+template <>
+struct type_casting_traits<float, half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet16h pcast<Packet16f, Packet16h>(const Packet16f& a) {
+  return float2half(a);
+}
+
+template <>
+struct type_casting_traits<bfloat16, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet16f pcast<Packet16bf, Packet16f>(const Packet16bf& a) {
+  return Bf16ToF32(a);
+}
+
+template <>
+struct type_casting_traits<float, bfloat16> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet16bf pcast<Packet16f, Packet16bf>(const Packet16f& a) {
+  return F32ToBf16(a);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_AVX512_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/Complex.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/Complex.h
new file mode 100644
index 00000000..f424f11c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/Complex.h
@@ -0,0 +1,417 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010-2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX32_ALTIVEC_H
+#define EIGEN_COMPLEX32_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+static Packet4ui  p4ui_CONJ_XOR = vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO);//{ 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
+#ifdef __VSX__
+#if defined(_BIG_ENDIAN)
+static Packet2ul  p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_MZERO, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+static Packet2ul  p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO,  (Packet4ui) p2d_MZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+#else
+static Packet2ul  p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO,  (Packet4ui) p2d_MZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+static Packet2ul  p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2d_MZERO, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+#endif
+#endif
+
+//---------- float ----------
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE explicit Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {}
+
+  EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b)
+  {
+    Packet4f v1, v2;
+
+    // Permute and multiply the real parts of a and b
+    v1 = vec_perm(a.v, a.v, p16uc_PSET32_WODD);
+    // Get the imaginary parts of a
+    v2 = vec_perm(a.v, a.v, p16uc_PSET32_WEVEN);
+    // multiply a_re * b
+    v1 = vec_madd(v1, b.v, p4f_ZERO);
+    // multiply a_im * b and get the conjugate result
+    v2 = vec_madd(v2, b.v, p4f_ZERO);
+    v2 = reinterpret_cast<Packet4f>(pxor(v2, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR)));
+    // permute back to a proper order
+    v2 = vec_perm(v2, v2, p16uc_COMPLEX32_REV);
+
+    return Packet2cf(padd<Packet4f>(v1, v2));
+  }
+
+  EIGEN_STRONG_INLINE Packet2cf& operator*=(const Packet2cf& b) {
+    v = pmul(Packet2cf(*this), b).v;
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator*(const Packet2cf& b) const {
+    return Packet2cf(*this) *= b;
+  }
+
+  EIGEN_STRONG_INLINE Packet2cf& operator+=(const Packet2cf& b) {
+    v = padd(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator+(const Packet2cf& b) const {
+    return Packet2cf(*this) += b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator-=(const Packet2cf& b) {
+    v = psub(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator-(const Packet2cf& b) const {
+    return Packet2cf(*this) -= b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator-(void) const {
+    return Packet2cf(-v);
+  }
+
+  Packet4f  v;
+};
+
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  typedef Packet4f as_real;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+#ifdef __VSX__
+    HasBlend  = 1,
+#endif
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet2cf half; typedef Packet4f as_real; };
+
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+  if((std::ptrdiff_t(&from) % 16) == 0)
+    res.v = pload<Packet4f>((const float *)&from);
+  else
+    res.v = ploadu<Packet4f>((const float *)&from);
+  res.v = vec_perm(res.v, res.v, p16uc_PSET64_HI);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pload<Packet2cf>(const std::complex<float>*        from) { return Packet2cf(pload<Packet4f>((const float *) from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>*       from) { return Packet2cf(ploadu<Packet4f>((const float*) from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>*     from) { return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { pstore((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { pstoreu((float*)to, from.v); }
+
+EIGEN_STRONG_INLINE Packet2cf pload2(const std::complex<float>* from0, const std::complex<float>* from1)
+{
+  Packet4f res0, res1;
+#ifdef __VSX__
+  __asm__ ("lxsdx %x0,%y1" : "=wa" (res0) : "Z" (*from0));
+  __asm__ ("lxsdx %x0,%y1" : "=wa" (res1) : "Z" (*from1));
+#ifdef _BIG_ENDIAN
+  __asm__ ("xxpermdi %x0, %x1, %x2, 0" : "=wa" (res0) : "wa" (res0), "wa" (res1));
+#else
+  __asm__ ("xxpermdi %x0, %x2, %x1, 0" : "=wa" (res0) : "wa" (res0), "wa" (res1));
+#endif
+#else
+  *reinterpret_cast<std::complex<float> *>(&res0) = *from0;
+  *reinterpret_cast<std::complex<float> *>(&res1) = *from1;
+  res0 = vec_perm(res0, res1, p16uc_TRANSPOSE64_HI);
+#endif
+  return Packet2cf(res0);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
+{
+  EIGEN_ALIGN16 std::complex<float> af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+  return pload<Packet2cf>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  EIGEN_ALIGN16 std::complex<float> af[2];
+  pstore<std::complex<float> >((std::complex<float> *) af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(a.v + b.v); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(a.v - b.v); }
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a.v, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR))); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pand   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pand<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf por    <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(por<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pxor<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pandnot<Packet4f>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> * addr)    { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet2cf>(const Packet2cf& a)
+{
+  EIGEN_ALIGN16 std::complex<float> res[2];
+  pstore((float *)&res, a.v);
+
+  return res[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{
+  Packet4f rev_a;
+  rev_a = vec_perm(a.v, a.v, p16uc_COMPLEX32_REV2);
+  return Packet2cf(rev_a);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  Packet4f b;
+  b = vec_sld(a.v, a.v, 8);
+  b = padd<Packet4f>(a.v, b);
+  return pfirst<Packet2cf>(Packet2cf(b));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  Packet4f b;
+  Packet2cf prod;
+  b = vec_sld(a.v, a.v, 8);
+  prod = pmul<Packet2cf>(a, Packet2cf(b));
+
+  return pfirst<Packet2cf>(prod);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for AltiVec
+  Packet2cf res = pmul(a, pconj(b));
+  Packet4f s = pmul<Packet4f>(b.v, b.v);
+  return Packet2cf(pdiv(res.v, padd<Packet4f>(s, vec_perm(s, s, p16uc_COMPLEX32_REV))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& x)
+{
+  return Packet2cf(vec_perm(x.v, x.v, p16uc_COMPLEX32_REV));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel)
+{
+  Packet4f tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b) {
+  Packet4f eq = reinterpret_cast<Packet4f>(vec_cmpeq(a.v,b.v));
+  return Packet2cf(vec_and(eq, vec_perm(eq, eq, p16uc_COMPLEX32_REV)));
+}
+
+#ifdef __VSX__
+template<> EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  Packet2cf result;
+  result.v = reinterpret_cast<Packet4f>(pblend<Packet2d>(ifPacket, reinterpret_cast<Packet2d>(thenPacket.v), reinterpret_cast<Packet2d>(elsePacket.v)));
+  return result;
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2cf psqrt<Packet2cf>(const Packet2cf& a)
+{
+  return psqrt_complex<Packet2cf>(a);
+}
+
+//---------- double ----------
+#ifdef __VSX__
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {}
+
+  EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b)
+  {
+    Packet2d a_re, a_im, v1, v2;
+
+    // Permute and multiply the real parts of a and b
+    a_re = vec_perm(a.v, a.v, p16uc_PSET64_HI);
+    // Get the imaginary parts of a
+    a_im = vec_perm(a.v, a.v, p16uc_PSET64_LO);
+    // multiply a_re * b
+    v1 = vec_madd(a_re, b.v, p2d_ZERO);
+    // multiply a_im * b and get the conjugate result
+    v2 = vec_madd(a_im, b.v, p2d_ZERO);
+    v2 = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(v2), reinterpret_cast<Packet4ui>(v2), 8));
+    v2 = pxor(v2, reinterpret_cast<Packet2d>(p2ul_CONJ_XOR1));
+
+    return Packet1cd(padd<Packet2d>(v1, v2));
+  }
+
+  EIGEN_STRONG_INLINE Packet1cd& operator*=(const Packet1cd& b) {
+    v = pmul(Packet1cd(*this), b).v;
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator*(const Packet1cd& b) const {
+    return Packet1cd(*this) *= b;
+  }
+
+  EIGEN_STRONG_INLINE Packet1cd& operator+=(const Packet1cd& b) {
+    v = padd(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator+(const Packet1cd& b) const {
+    return Packet1cd(*this) += b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator-=(const Packet1cd& b) {
+    v = psub(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator-(const Packet1cd& b) const {
+    return Packet1cd(*this) -= b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator-(void) const {
+    return Packet1cd(-v);
+  }
+
+  Packet2d v;
+};
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  typedef Packet2d as_real;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet1cd half; typedef Packet2d as_real; };
+
+template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from) { return Packet1cd(pload<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) { return Packet1cd(ploadu<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { pstoreu((double*)to, from.v); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>&  from)
+{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(const std::complex<double>* from, Index)
+{
+  return pload<Packet1cd>(from);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to, const Packet1cd& from, Index)
+{
+  pstore<std::complex<double> >(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v + b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v - b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) { return Packet1cd(pxor(a.v, reinterpret_cast<Packet2d>(p2ul_CONJ_XOR2))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pand   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(pand(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd por    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(por(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pxor   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(pxor(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(pandnot(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>*     from)  { return pset1<Packet1cd>(*from); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> * addr)    { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double>  pfirst<Packet1cd>(const Packet1cd& a)
+{
+  EIGEN_ALIGN16 std::complex<double> res[2];
+  pstore<std::complex<double> >(res, a);
+
+  return res[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for AltiVec
+  Packet1cd res = pmul(a,pconj(b));
+  Packet2d s = pmul<Packet2d>(b.v, b.v);
+  return Packet1cd(pdiv(res.v, padd<Packet2d>(s, vec_perm(s, s, p16uc_REVERSE64))));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
+{
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd,2>& kernel)
+{
+  Packet2d tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b) {
+  // Compare real and imaginary parts of a and b to get the mask vector:
+  // [re(a)==re(b), im(a)==im(b)]
+  Packet2d eq = reinterpret_cast<Packet2d>(vec_cmpeq(a.v,b.v));
+  // Swap real/imag elements in the mask in to get:
+  // [im(a)==im(b), re(a)==re(b)]
+  Packet2d eq_swapped = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(eq), reinterpret_cast<Packet4ui>(eq), 8));
+  // Return re(a)==re(b) & im(a)==im(b) by computing bitwise AND of eq and eq_swapped
+  return Packet1cd(vec_and(eq, eq_swapped));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd psqrt<Packet1cd>(const Packet1cd& a)
+{
+  return psqrt_complex<Packet1cd>(a);
+}
+
+#endif // __VSX__
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX32_ALTIVEC_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
new file mode 100644
index 00000000..3a7a3293
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
@@ -0,0 +1,90 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+#define EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f plog<Packet4f>(const Packet4f& _x)
+{
+  return plog_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexp<Packet4f>(const Packet4f& _x)
+{
+  return pexp_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psin<Packet4f>(const Packet4f& _x)
+{
+  return psin_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pcos<Packet4f>(const Packet4f& _x)
+{
+  return pcos_float(_x);
+}
+
+#ifndef EIGEN_COMP_CLANG
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& x)
+{
+  return  vec_rsqrt(x);
+}
+#endif
+
+#ifdef __VSX__
+#ifndef EIGEN_COMP_CLANG
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d prsqrt<Packet2d>(const Packet2d& x)
+{
+  return  vec_rsqrt(x);
+}
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& x)
+{
+  return  vec_sqrt(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d psqrt<Packet2d>(const Packet2d& x)
+{
+  return  vec_sqrt(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d pexp<Packet2d>(const Packet2d& _x)
+{
+  return pexp_double(_x);
+}
+#endif
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+ptanh<Packet4f>(const Packet4f& x) {
+  return internal::generic_fast_tanh_float(x);
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_ALTIVEC_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
new file mode 100644
index 00000000..3f79b97d
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
@@ -0,0 +1,2937 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020 Everton Constantino (everton.constantino@ibm.com)
+// Copyright (C) 2021 Chip Kerchner (chip.kerchner@ibm.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIX_PRODUCT_ALTIVEC_H
+#define EIGEN_MATRIX_PRODUCT_ALTIVEC_H
+
+#ifndef EIGEN_ALTIVEC_USE_CUSTOM_PACK
+#define EIGEN_ALTIVEC_USE_CUSTOM_PACK    1
+#endif
+
+#include "MatrixProductCommon.h"
+
+// Since LLVM doesn't support dynamic dispatching, force either always MMA or VSX
+#if EIGEN_COMP_LLVM
+#if !defined(EIGEN_ALTIVEC_DISABLE_MMA) && !defined(EIGEN_ALTIVEC_MMA_ONLY)
+#ifdef __MMA__
+#define EIGEN_ALTIVEC_MMA_ONLY
+#else
+#define EIGEN_ALTIVEC_DISABLE_MMA
+#endif
+#endif
+#endif
+
+#ifdef __has_builtin
+#if __has_builtin(__builtin_mma_assemble_acc)
+  #define ALTIVEC_MMA_SUPPORT
+#endif
+#endif
+
+#if defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+  #include "MatrixProductMMA.h"
+#endif
+
+/**************************************************************************************************
+ * TODO                                                                                           *
+ * - Check StorageOrder on dhs_pack (the innermost second loop seems unvectorized when it could). *
+ * - Check the possibility of transposing as GETREAL and GETIMAG when needed.                     *
+ **************************************************************************************************/
+namespace Eigen {
+
+namespace internal {
+
+/**************************
+ * Constants and typedefs *
+ **************************/
+template<typename Scalar>
+struct quad_traits
+{
+  typedef typename packet_traits<Scalar>::type    vectortype;
+  typedef PacketBlock<vectortype,4>                     type;
+  typedef vectortype                                 rhstype;
+  enum
+  {
+    vectorsize = packet_traits<Scalar>::size,
+    size = 4,
+    rows = 4
+  };
+};
+
+template<>
+struct quad_traits<double>
+{
+  typedef Packet2d                        vectortype;
+  typedef PacketBlock<vectortype,4>             type;
+  typedef PacketBlock<Packet2d,2>            rhstype;
+  enum
+  {
+    vectorsize = packet_traits<double>::size,
+    size = 2,
+    rows = 4
+  };
+};
+
+// MatrixProduct decomposes real/imaginary vectors into a real vector and an imaginary vector, this turned out
+// to be faster than Eigen's usual approach of having real/imaginary pairs on a single vector. This constants then
+// are responsible to extract from convert between Eigen's and MatrixProduct approach.
+
+const static Packet16uc p16uc_GETREAL32 = {  0,  1,  2,  3,
+                                             8,  9, 10, 11,
+                                            16, 17, 18, 19,
+                                            24, 25, 26, 27};
+
+const static Packet16uc p16uc_GETIMAG32 = {  4,  5,  6,  7,
+                                            12, 13, 14, 15,
+                                            20, 21, 22, 23,
+                                            28, 29, 30, 31};
+const static Packet16uc p16uc_GETREAL64 = {  0,  1,  2,  3,  4,  5,  6,  7,
+                                            16, 17, 18, 19, 20, 21, 22, 23};
+
+//[a,ai],[b,bi] = [ai,bi]
+const static Packet16uc p16uc_GETIMAG64 = {  8,  9, 10, 11, 12, 13, 14, 15,
+                                            24, 25, 26, 27, 28, 29, 30, 31};
+
+/*********************************************
+ * Single precision real and complex packing *
+ * *******************************************/
+
+/**
+ * Symm packing is related to packing of symmetric adjoint blocks, as expected the packing leaves
+ * the diagonal real, whatever is below it is copied from the respective upper diagonal element and 
+ * conjugated. There's no PanelMode available for symm packing.
+ *
+ * Packing in general is supposed to leave the lhs block and the rhs block easy to be read by gemm using 
+ * its respective rank-update instructions. The float32/64 versions are different because at this moment
+ * the size of the accumulator is fixed at 512-bits so you can't have a 4x4 accumulator of 64-bit elements.
+ * 
+ * As mentioned earlier MatrixProduct breaks complex numbers into a real vector and a complex vector so packing has
+ * to take that into account, at the moment, we run pack the real part and then the imaginary part, this is the main
+ * reason why packing for complex is broken down into several different parts, also the reason why we endup having a
+ * float32/64 and complex float32/64 version.
+ **/
+template<typename Scalar, typename Index, int StorageOrder>
+EIGEN_ALWAYS_INLINE std::complex<Scalar> getAdjointVal(Index i, Index j, const_blas_data_mapper<std::complex<Scalar>, Index, StorageOrder>& dt)
+{
+  std::complex<Scalar> v;
+  if(i < j)
+  {
+    v.real( dt(j,i).real());
+    v.imag(-dt(j,i).imag());
+  } else if(i > j)
+  {
+    v.real( dt(i,j).real());
+    v.imag( dt(i,j).imag());
+  } else {
+    v.real( dt(i,j).real());
+    v.imag((Scalar)0.0);
+  }
+  return v;
+}
+
+template<typename Scalar, typename Index, int StorageOrder, int N>
+EIGEN_STRONG_INLINE void symm_pack_complex_rhs_helper(std::complex<Scalar>* blockB, const std::complex<Scalar>* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+{
+  const Index depth = k2 + rows;
+  const_blas_data_mapper<std::complex<Scalar>, Index, StorageOrder> rhs(_rhs, rhsStride);
+  const Index vectorSize = N*quad_traits<Scalar>::vectorsize;
+  const Index vectorDelta = vectorSize * rows;
+  Scalar* blockBf = reinterpret_cast<Scalar *>(blockB);
+
+  Index rir = 0, rii, j = 0;
+  for(; j + vectorSize <= cols; j+=vectorSize)
+  {
+    rii = rir + vectorDelta;
+
+    for(Index i = k2; i < depth; i++)
+    {
+      for(Index k = 0; k < vectorSize; k++)
+      {
+        std::complex<Scalar> v = getAdjointVal<Scalar, Index, StorageOrder>(i, j + k, rhs);
+
+        blockBf[rir + k] = v.real();
+        blockBf[rii + k] = v.imag();
+      }
+      rir += vectorSize;
+      rii += vectorSize;
+    }
+
+    rir += vectorDelta;
+  }
+  if (j < cols)
+  {
+    rii = rir + ((cols - j) * rows);
+
+    for(Index i = k2; i < depth; i++)
+    {
+      Index k = j;
+      for(; k < cols; k++)
+      {
+        std::complex<Scalar> v = getAdjointVal<Scalar, Index, StorageOrder>(i, k, rhs);
+
+        blockBf[rir] = v.real();
+        blockBf[rii] = v.imag();
+
+        rir += 1;
+        rii += 1;
+      }
+    }
+  }
+}
+
+template<typename Scalar, typename Index, int StorageOrder>
+EIGEN_STRONG_INLINE void symm_pack_complex_lhs_helper(std::complex<Scalar>* blockA, const std::complex<Scalar>* _lhs, Index lhsStride, Index cols, Index rows)
+{
+  const Index depth = cols;
+  const_blas_data_mapper<std::complex<Scalar>, Index, StorageOrder> lhs(_lhs, lhsStride);
+  const Index vectorSize = quad_traits<Scalar>::vectorsize;
+  const Index vectorDelta = vectorSize * depth;
+  Scalar* blockAf = (Scalar *)(blockA);
+
+  Index rir = 0, rii, j = 0;
+  for(; j + vectorSize <= rows; j+=vectorSize)
+  {
+    rii = rir + vectorDelta;
+
+    for(Index i = 0; i < depth; i++)
+    {
+      for(Index k = 0; k < vectorSize; k++)
+      {
+        std::complex<Scalar> v = getAdjointVal<Scalar, Index, StorageOrder>(j+k, i, lhs);
+
+        blockAf[rir + k] = v.real();
+        blockAf[rii + k] = v.imag();
+      }
+      rir += vectorSize;
+      rii += vectorSize;
+    }
+
+    rir += vectorDelta;
+  }
+
+  if (j < rows)
+  {
+    rii = rir + ((rows - j) * depth);
+
+    for(Index i = 0; i < depth; i++)
+    {
+      Index k = j;
+      for(; k < rows; k++)
+      {
+        std::complex<Scalar> v = getAdjointVal<Scalar, Index, StorageOrder>(k, i, lhs);
+
+        blockAf[rir] = v.real();
+        blockAf[rii] = v.imag();
+
+        rir += 1;
+        rii += 1;
+      }
+    }
+  }
+}
+
+template<typename Scalar, typename Index, int StorageOrder, int N>
+EIGEN_STRONG_INLINE void symm_pack_rhs_helper(Scalar* blockB, const Scalar* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+{
+  const Index depth = k2 + rows;
+  const_blas_data_mapper<Scalar, Index, StorageOrder> rhs(_rhs, rhsStride);
+  const Index vectorSize = quad_traits<Scalar>::vectorsize;
+
+  Index ri = 0, j = 0;
+  for(; j + N*vectorSize <= cols; j+=N*vectorSize)
+  {
+    Index i = k2;
+    for(; i < depth; i++)
+    {
+      for(Index k = 0; k < N*vectorSize; k++)
+      {
+        if(i <= j+k)
+          blockB[ri + k] = rhs(j+k, i);
+        else
+          blockB[ri + k] = rhs(i, j+k);
+      }
+      ri += N*vectorSize;
+    }
+  }
+
+  if (j < cols)
+  {
+    for(Index i = k2; i < depth; i++)
+    {
+      Index k = j;
+      for(; k < cols; k++)
+      {
+        if(k <= i)
+          blockB[ri] = rhs(i, k);
+        else
+          blockB[ri] = rhs(k, i);
+        ri += 1;
+      }
+    }
+  }
+}
+
+template<typename Scalar, typename Index, int StorageOrder>
+EIGEN_STRONG_INLINE void symm_pack_lhs_helper(Scalar* blockA, const Scalar* _lhs, Index lhsStride, Index cols, Index rows)
+{
+  const Index depth = cols;
+  const_blas_data_mapper<Scalar, Index, StorageOrder> lhs(_lhs, lhsStride);
+  const Index vectorSize = quad_traits<Scalar>::vectorsize;
+
+  Index ri = 0, j = 0;
+  for(; j + vectorSize <= rows; j+=vectorSize)
+  {
+    Index i = 0;
+
+    for(; i < depth; i++)
+    {
+      for(Index k = 0; k < vectorSize; k++)
+      {
+        if(i <= j+k)
+          blockA[ri + k] = lhs(j+k, i);
+        else
+          blockA[ri + k] = lhs(i, j+k);
+      }
+      ri += vectorSize;
+    }
+  }
+
+  if (j < rows)
+  {
+    for(Index i = 0; i < depth; i++)
+    {
+      Index k = j;
+      for(; k < rows; k++)
+      {
+        if(i <= k)
+          blockA[ri] = lhs(k, i);
+        else
+          blockA[ri] = lhs(i, k);
+        ri += 1;
+      }
+    }
+  }
+}
+
+template<typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs<std::complex<float>, Index, nr, StorageOrder>
+{
+  void operator()(std::complex<float>* blockB, const std::complex<float>* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    symm_pack_complex_rhs_helper<float, Index, StorageOrder, 1>(blockB, _rhs, rhsStride, rows, cols, k2);
+  }
+};
+
+template<typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs<std::complex<float>, Index, Pack1, Pack2_dummy, StorageOrder>
+{
+  void operator()(std::complex<float>* blockA, const std::complex<float>* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    symm_pack_complex_lhs_helper<float, Index, StorageOrder>(blockA, _lhs, lhsStride, cols, rows);
+  }
+};
+
+// *********** symm_pack std::complex<float64> ***********
+
+template<typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs<std::complex<double>, Index, nr, StorageOrder>
+{
+  void operator()(std::complex<double>* blockB, const std::complex<double>* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    symm_pack_complex_rhs_helper<double, Index, StorageOrder, 2>(blockB, _rhs, rhsStride, rows, cols, k2);
+  }
+};
+
+template<typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs<std::complex<double>, Index, Pack1, Pack2_dummy, StorageOrder>
+{
+  void operator()(std::complex<double>* blockA, const std::complex<double>* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    symm_pack_complex_lhs_helper<double, Index, StorageOrder>(blockA, _lhs, lhsStride, cols, rows);
+  }
+};
+
+// *********** symm_pack float32 ***********
+template<typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs<float, Index, nr, StorageOrder>
+{
+  void operator()(float* blockB, const float* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    symm_pack_rhs_helper<float, Index, StorageOrder, 1>(blockB, _rhs, rhsStride, rows, cols, k2);
+  }
+};
+
+template<typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs<float, Index, Pack1, Pack2_dummy, StorageOrder>
+{
+  void operator()(float* blockA, const float* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    symm_pack_lhs_helper<float, Index, StorageOrder>(blockA, _lhs, lhsStride, cols, rows);
+  }
+};
+
+// *********** symm_pack float64 ***********
+template<typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs<double, Index, nr, StorageOrder>
+{
+  void operator()(double* blockB, const double* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    symm_pack_rhs_helper<double, Index, StorageOrder, 2>(blockB, _rhs, rhsStride, rows, cols, k2);
+  }
+};
+
+template<typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs<double, Index, Pack1, Pack2_dummy, StorageOrder>
+{
+  void operator()(double* blockA, const double* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    symm_pack_lhs_helper<double, Index, StorageOrder>(blockA, _lhs, lhsStride, cols, rows);
+  }
+};
+
+/**
+ * PanelMode
+ * Packing might be called several times before being multiplied by gebp_kernel, this happens because 
+ * on special occasions it fills part of block with other parts of the matrix. Two variables control
+ * how PanelMode should behave: offset and stride. The idea is that those variables represent whatever
+ * is going to be the real offset and stride in the future and this is what you should obey. The process
+ * is to behave as you would with normal packing but leave the start of each part with the correct offset
+ * and the end as well respecting the real stride the block will have. Gebp is aware of both blocks stride
+ * and offset and behaves accordingly.
+ **/
+
+template<typename Scalar, typename Packet, typename Index>
+EIGEN_ALWAYS_INLINE void storeBlock(Scalar* to, PacketBlock<Packet,4>& block)
+{
+  const Index size = 16 / sizeof(Scalar);
+  pstore<Scalar>(to + (0 * size), block.packet[0]);
+  pstore<Scalar>(to + (1 * size), block.packet[1]);
+  pstore<Scalar>(to + (2 * size), block.packet[2]);
+  pstore<Scalar>(to + (3 * size), block.packet[3]);
+}
+
+template<typename Scalar, typename Packet, typename Index>
+EIGEN_ALWAYS_INLINE void storeBlock(Scalar* to, PacketBlock<Packet,2>& block)
+{
+  const Index size = 16 / sizeof(Scalar);
+  pstore<Scalar>(to + (0 * size), block.packet[0]);
+  pstore<Scalar>(to + (1 * size), block.packet[1]);
+}
+
+// General template for lhs & rhs complex packing.
+template<typename Scalar, typename Index, typename DataMapper, typename Packet, typename PacketC, int StorageOrder, bool Conjugate, bool PanelMode, bool UseLhs>
+struct dhs_cpack {
+  EIGEN_STRONG_INLINE void operator()(std::complex<Scalar>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<Scalar>::vectorsize;
+    const Index vectorDelta = vectorSize * ((PanelMode) ? stride : depth);
+    Index rir = ((PanelMode) ? (vectorSize*offset) : 0), rii;
+    Scalar* blockAt = reinterpret_cast<Scalar *>(blockA);
+    Index j = 0;
+
+    for(; j + vectorSize <= rows; j+=vectorSize)
+    {
+      Index i = 0;
+
+      rii = rir + vectorDelta;
+
+      for(; i + vectorSize <= depth; i+=vectorSize)
+      {
+        PacketBlock<Packet,4> blockr, blocki;
+        PacketBlock<PacketC,8> cblock;
+
+        if (UseLhs) {
+          bload<DataMapper, PacketC, Index, 2, 0, StorageOrder>(cblock, lhs, j, i);
+        } else {
+          bload<DataMapper, PacketC, Index, 2, 0, StorageOrder>(cblock, lhs, i, j);
+        }
+
+        blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[4].v, p16uc_GETREAL32);
+        blockr.packet[1] = vec_perm(cblock.packet[1].v, cblock.packet[5].v, p16uc_GETREAL32);
+        blockr.packet[2] = vec_perm(cblock.packet[2].v, cblock.packet[6].v, p16uc_GETREAL32);
+        blockr.packet[3] = vec_perm(cblock.packet[3].v, cblock.packet[7].v, p16uc_GETREAL32);
+
+        blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[4].v, p16uc_GETIMAG32);
+        blocki.packet[1] = vec_perm(cblock.packet[1].v, cblock.packet[5].v, p16uc_GETIMAG32);
+        blocki.packet[2] = vec_perm(cblock.packet[2].v, cblock.packet[6].v, p16uc_GETIMAG32);
+        blocki.packet[3] = vec_perm(cblock.packet[3].v, cblock.packet[7].v, p16uc_GETIMAG32);
+
+        if(Conjugate)
+        {
+          blocki.packet[0] = -blocki.packet[0];
+          blocki.packet[1] = -blocki.packet[1];
+          blocki.packet[2] = -blocki.packet[2];
+          blocki.packet[3] = -blocki.packet[3];
+        }
+
+        if(((StorageOrder == RowMajor) && UseLhs) || (((StorageOrder == ColMajor) && !UseLhs)))
+        {
+          ptranspose(blockr);
+          ptranspose(blocki);
+        }
+
+        storeBlock<Scalar, Packet, Index>(blockAt + rir, blockr);
+        storeBlock<Scalar, Packet, Index>(blockAt + rii, blocki);
+
+        rir += 4*vectorSize;
+        rii += 4*vectorSize;
+      }
+      for(; i < depth; i++)
+      {
+        PacketBlock<Packet,1> blockr, blocki;
+        PacketBlock<PacketC,2> cblock;
+
+        if(((StorageOrder == ColMajor) && UseLhs) || (((StorageOrder == RowMajor) && !UseLhs)))
+        {
+          if (UseLhs) {
+            cblock.packet[0] = lhs.template loadPacket<PacketC>(j + 0, i);
+            cblock.packet[1] = lhs.template loadPacket<PacketC>(j + 2, i);
+          } else {
+            cblock.packet[0] = lhs.template loadPacket<PacketC>(i, j + 0);
+            cblock.packet[1] = lhs.template loadPacket<PacketC>(i, j + 2);
+          }
+        } else {
+          std::complex<Scalar> lhs0, lhs1;
+          if (UseLhs) {
+            lhs0 = lhs(j + 0, i);
+            lhs1 = lhs(j + 1, i);
+            cblock.packet[0] = pload2(&lhs0, &lhs1);
+            lhs0 = lhs(j + 2, i);
+            lhs1 = lhs(j + 3, i);
+            cblock.packet[1] = pload2(&lhs0, &lhs1);
+          } else {
+            lhs0 = lhs(i, j + 0);
+            lhs1 = lhs(i, j + 1);
+            cblock.packet[0] = pload2(&lhs0, &lhs1);
+            lhs0 = lhs(i, j + 2);
+            lhs1 = lhs(i, j + 3);
+            cblock.packet[1] = pload2(&lhs0, &lhs1);
+          }
+        }
+
+        blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETREAL32);
+        blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETIMAG32);
+
+        if(Conjugate)
+        {
+          blocki.packet[0] = -blocki.packet[0];
+        }
+
+        pstore<Scalar>(blockAt + rir, blockr.packet[0]);
+        pstore<Scalar>(blockAt + rii, blocki.packet[0]);
+
+        rir += vectorSize;
+        rii += vectorSize;
+      }
+
+      rir += ((PanelMode) ? (vectorSize*(2*stride - depth)) : vectorDelta);
+    }
+
+    if (j < rows)
+    {
+      if(PanelMode) rir += (offset*(rows - j - vectorSize));
+      rii = rir + (((PanelMode) ? stride : depth) * (rows - j));
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < rows; k++)
+        {
+          if (UseLhs) {
+            blockAt[rir] = lhs(k, i).real();
+
+            if(Conjugate)
+              blockAt[rii] = -lhs(k, i).imag();
+            else
+              blockAt[rii] =  lhs(k, i).imag();
+          } else {
+            blockAt[rir] = lhs(i, k).real();
+
+            if(Conjugate)
+              blockAt[rii] = -lhs(i, k).imag();
+            else
+              blockAt[rii] =  lhs(i, k).imag();
+          }
+
+          rir += 1;
+          rii += 1;
+        }
+      }
+    }
+  }
+};
+
+// General template for lhs & rhs packing.
+template<typename Scalar, typename Index, typename DataMapper, typename Packet, int StorageOrder, bool PanelMode, bool UseLhs>
+struct dhs_pack{
+  EIGEN_STRONG_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<Scalar>::vectorsize;
+    Index ri = 0, j = 0;
+
+    for(; j + vectorSize <= rows; j+=vectorSize)
+    {
+      Index i = 0;
+
+      if(PanelMode) ri += vectorSize*offset;
+
+      for(; i + vectorSize <= depth; i+=vectorSize)
+      {
+        PacketBlock<Packet,4> block;
+
+        if (UseLhs) {
+          bload<DataMapper, Packet, Index, 4, 0, StorageOrder>(block, lhs, j, i);
+        } else {
+          bload<DataMapper, Packet, Index, 4, 0, StorageOrder>(block, lhs, i, j);
+        }
+        if(((StorageOrder == RowMajor) && UseLhs) || ((StorageOrder == ColMajor) && !UseLhs))
+        {
+          ptranspose(block);
+        }
+
+        storeBlock<Scalar, Packet, Index>(blockA + ri, block);
+
+        ri += 4*vectorSize;
+      }
+      for(; i < depth; i++)
+      {
+        if(((StorageOrder == RowMajor) && UseLhs) || ((StorageOrder == ColMajor) && !UseLhs))
+        {
+          if (UseLhs) {
+            blockA[ri+0] = lhs(j+0, i);
+            blockA[ri+1] = lhs(j+1, i);
+            blockA[ri+2] = lhs(j+2, i);
+            blockA[ri+3] = lhs(j+3, i);
+          } else {
+            blockA[ri+0] = lhs(i, j+0);
+            blockA[ri+1] = lhs(i, j+1);
+            blockA[ri+2] = lhs(i, j+2);
+            blockA[ri+3] = lhs(i, j+3);
+          }
+        } else {
+          Packet lhsV;
+          if (UseLhs) {
+            lhsV = lhs.template loadPacket<Packet>(j, i);
+          } else {
+            lhsV = lhs.template loadPacket<Packet>(i, j);
+          }
+          pstore<Scalar>(blockA + ri, lhsV);
+        }
+
+        ri += vectorSize;
+      }
+
+      if(PanelMode) ri += vectorSize*(stride - offset - depth);
+    }
+
+    if (j < rows)
+    {
+      if(PanelMode) ri += offset*(rows - j);
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < rows; k++)
+        {
+          if (UseLhs) {
+            blockA[ri] = lhs(k, i);
+          } else {
+            blockA[ri] = lhs(i, k);
+          }
+          ri += 1;
+        }
+      }
+    }
+  }
+};
+
+// General template for lhs packing, float64 specialization.
+template<typename Index, typename DataMapper, int StorageOrder, bool PanelMode>
+struct dhs_pack<double, Index, DataMapper, Packet2d, StorageOrder, PanelMode, true>
+{
+  EIGEN_STRONG_INLINE void operator()(double* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<double>::vectorsize;
+    Index ri = 0, j = 0;
+
+    for(; j + vectorSize <= rows; j+=vectorSize)
+    {
+      Index i = 0;
+
+      if(PanelMode) ri += vectorSize*offset;
+
+      for(; i + vectorSize <= depth; i+=vectorSize)
+      {
+        PacketBlock<Packet2d,2> block;
+        if(StorageOrder == RowMajor)
+        {
+          block.packet[0] = lhs.template loadPacket<Packet2d>(j + 0, i);
+          block.packet[1] = lhs.template loadPacket<Packet2d>(j + 1, i);
+
+          ptranspose(block);
+        } else {
+          block.packet[0] = lhs.template loadPacket<Packet2d>(j, i + 0);
+          block.packet[1] = lhs.template loadPacket<Packet2d>(j, i + 1);
+        }
+
+        storeBlock<double, Packet2d, Index>(blockA + ri, block);
+
+        ri += 2*vectorSize;
+      }
+      for(; i < depth; i++)
+      {
+        if(StorageOrder == RowMajor)
+        {
+          blockA[ri+0] = lhs(j+0, i);
+          blockA[ri+1] = lhs(j+1, i);
+        } else {
+          Packet2d lhsV = lhs.template loadPacket<Packet2d>(j, i);
+          pstore<double>(blockA + ri, lhsV);
+        }
+
+        ri += vectorSize;
+      }
+
+      if(PanelMode) ri += vectorSize*(stride - offset - depth);
+    }
+
+    if (j < rows)
+    {
+      if(PanelMode) ri += offset*(rows - j);
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < rows; k++)
+        {
+          blockA[ri] = lhs(k, i);
+          ri += 1;
+        }
+      }
+    }
+  }
+};
+
+// General template for rhs packing, float64 specialization.
+template<typename Index, typename DataMapper, int StorageOrder, bool PanelMode>
+struct dhs_pack<double, Index, DataMapper, Packet2d, StorageOrder, PanelMode, false>
+{
+  EIGEN_STRONG_INLINE void operator()(double* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<double>::vectorsize;
+    Index ri = 0, j = 0;
+
+    for(; j + 2*vectorSize <= cols; j+=2*vectorSize)
+    {
+      Index i = 0;
+
+      if(PanelMode) ri += offset*(2*vectorSize);
+
+      for(; i + vectorSize <= depth; i+=vectorSize)
+      {
+        PacketBlock<Packet2d,4> block;
+        if(StorageOrder == ColMajor)
+        {
+          PacketBlock<Packet2d,2> block1, block2;
+          block1.packet[0] = rhs.template loadPacket<Packet2d>(i, j + 0);
+          block1.packet[1] = rhs.template loadPacket<Packet2d>(i, j + 1);
+          block2.packet[0] = rhs.template loadPacket<Packet2d>(i, j + 2);
+          block2.packet[1] = rhs.template loadPacket<Packet2d>(i, j + 3);
+
+          ptranspose(block1);
+          ptranspose(block2);
+
+          pstore<double>(blockB + ri    , block1.packet[0]);
+          pstore<double>(blockB + ri + 2, block2.packet[0]);
+          pstore<double>(blockB + ri + 4, block1.packet[1]);
+          pstore<double>(blockB + ri + 6, block2.packet[1]);
+        } else {
+          block.packet[0] = rhs.template loadPacket<Packet2d>(i + 0, j + 0); //[a1 a2]
+          block.packet[1] = rhs.template loadPacket<Packet2d>(i + 0, j + 2); //[a3 a4]
+          block.packet[2] = rhs.template loadPacket<Packet2d>(i + 1, j + 0); //[b1 b2]
+          block.packet[3] = rhs.template loadPacket<Packet2d>(i + 1, j + 2); //[b3 b4]
+
+          storeBlock<double, Packet2d, Index>(blockB + ri, block);
+        }
+
+        ri += 4*vectorSize;
+      }
+      for(; i < depth; i++)
+      {
+        if(StorageOrder == ColMajor)
+        {
+          blockB[ri+0] = rhs(i, j+0);
+          blockB[ri+1] = rhs(i, j+1);
+
+          ri += vectorSize;
+
+          blockB[ri+0] = rhs(i, j+2);
+          blockB[ri+1] = rhs(i, j+3);
+        } else {
+          Packet2d rhsV = rhs.template loadPacket<Packet2d>(i, j);
+          pstore<double>(blockB + ri, rhsV);
+
+          ri += vectorSize;
+
+          rhsV = rhs.template loadPacket<Packet2d>(i, j + 2);
+          pstore<double>(blockB + ri, rhsV);
+        }
+        ri += vectorSize;
+      }
+
+      if(PanelMode) ri += (2*vectorSize)*(stride - offset - depth);
+    }
+
+    if (j < cols)
+    {
+      if(PanelMode) ri += offset*(cols - j);
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < cols; k++)
+        {
+          blockB[ri] = rhs(i, k);
+          ri += 1;
+        }
+      }
+    }
+  }
+};
+
+// General template for lhs complex packing, float64 specialization.
+template<typename Index, typename DataMapper, typename Packet, typename PacketC, int StorageOrder, bool Conjugate, bool PanelMode>
+struct dhs_cpack<double, Index, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, true>
+{
+  EIGEN_STRONG_INLINE void operator()(std::complex<double>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<double>::vectorsize;
+    const Index vectorDelta = vectorSize * ((PanelMode) ? stride : depth);
+    Index rir = ((PanelMode) ? (vectorSize*offset) : 0), rii;
+    double* blockAt = reinterpret_cast<double *>(blockA);
+    Index j = 0;
+
+    for(; j + vectorSize <= rows; j+=vectorSize)
+    {
+      Index i = 0;
+
+      rii = rir + vectorDelta;
+
+      for(; i + vectorSize <= depth; i+=vectorSize)
+      {
+        PacketBlock<Packet,2> blockr, blocki;
+        PacketBlock<PacketC,4> cblock;
+
+        if(StorageOrder == ColMajor)
+        {
+          cblock.packet[0] = lhs.template loadPacket<PacketC>(j, i + 0); //[a1 a1i]
+          cblock.packet[1] = lhs.template loadPacket<PacketC>(j, i + 1); //[b1 b1i]
+
+          cblock.packet[2] = lhs.template loadPacket<PacketC>(j + 1, i + 0); //[a2 a2i]
+          cblock.packet[3] = lhs.template loadPacket<PacketC>(j + 1, i + 1); //[b2 b2i]
+
+          blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[2].v, p16uc_GETREAL64); //[a1 a2]
+          blockr.packet[1] = vec_perm(cblock.packet[1].v, cblock.packet[3].v, p16uc_GETREAL64); //[b1 b2]
+
+          blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[2].v, p16uc_GETIMAG64);
+          blocki.packet[1] = vec_perm(cblock.packet[1].v, cblock.packet[3].v, p16uc_GETIMAG64);
+        } else {
+          cblock.packet[0] = lhs.template loadPacket<PacketC>(j + 0, i); //[a1 a1i]
+          cblock.packet[1] = lhs.template loadPacket<PacketC>(j + 1, i); //[a2 a2i]
+
+          cblock.packet[2] = lhs.template loadPacket<PacketC>(j + 0, i + 1); //[b1 b1i]
+          cblock.packet[3] = lhs.template loadPacket<PacketC>(j + 1, i + 1); //[b2 b2i
+
+          blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETREAL64); //[a1 a2]
+          blockr.packet[1] = vec_perm(cblock.packet[2].v, cblock.packet[3].v, p16uc_GETREAL64); //[b1 b2]
+
+          blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETIMAG64);
+          blocki.packet[1] = vec_perm(cblock.packet[2].v, cblock.packet[3].v, p16uc_GETIMAG64);
+        }
+
+        if(Conjugate)
+        {
+          blocki.packet[0] = -blocki.packet[0];
+          blocki.packet[1] = -blocki.packet[1];
+        }
+
+        storeBlock<double, Packet, Index>(blockAt + rir, blockr);
+        storeBlock<double, Packet, Index>(blockAt + rii, blocki);
+
+        rir += 2*vectorSize;
+        rii += 2*vectorSize;
+      }
+      for(; i < depth; i++)
+      {
+        PacketBlock<Packet,1> blockr, blocki;
+        PacketBlock<PacketC,2> cblock;
+
+        cblock.packet[0] = lhs.template loadPacket<PacketC>(j + 0, i);
+        cblock.packet[1] = lhs.template loadPacket<PacketC>(j + 1, i);
+
+        blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETREAL64);
+        blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETIMAG64);
+
+        if(Conjugate)
+        {
+          blocki.packet[0] = -blocki.packet[0];
+        }
+
+        pstore<double>(blockAt + rir, blockr.packet[0]);
+        pstore<double>(blockAt + rii, blocki.packet[0]);
+
+        rir += vectorSize;
+        rii += vectorSize;
+      }
+
+      rir += ((PanelMode) ? (vectorSize*(2*stride - depth)) : vectorDelta);
+    }
+
+    if (j < rows)
+    {
+      if(PanelMode) rir += (offset*(rows - j - vectorSize));
+      rii = rir + (((PanelMode) ? stride : depth) * (rows - j));
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < rows; k++)
+        {
+          blockAt[rir] = lhs(k, i).real();
+
+          if(Conjugate)
+            blockAt[rii] = -lhs(k, i).imag();
+          else
+            blockAt[rii] =  lhs(k, i).imag();
+
+          rir += 1;
+          rii += 1;
+        }
+      }
+    }
+  }
+};
+
+// General template for rhs complex packing, float64 specialization.
+template<typename Index, typename DataMapper, typename Packet, typename PacketC, int StorageOrder, bool Conjugate, bool PanelMode>
+struct dhs_cpack<double, Index, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, false>
+{
+  EIGEN_STRONG_INLINE void operator()(std::complex<double>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+  {
+    const Index vectorSize = quad_traits<double>::vectorsize;
+    const Index vectorDelta = 2*vectorSize * ((PanelMode) ? stride : depth);
+    Index rir = ((PanelMode) ? (2*vectorSize*offset) : 0), rii;
+    double* blockBt = reinterpret_cast<double *>(blockB);
+    Index j = 0;
+
+    for(; j + 2*vectorSize <= cols; j+=2*vectorSize)
+    {
+      Index i = 0;
+
+      rii = rir + vectorDelta;
+
+      for(; i < depth; i++)
+      {
+        PacketBlock<PacketC,4> cblock;
+        PacketBlock<Packet,2> blockr, blocki;
+
+        bload<DataMapper, PacketC, Index, 2, 0, ColMajor>(cblock, rhs, i, j);
+
+        blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETREAL64);
+        blockr.packet[1] = vec_perm(cblock.packet[2].v, cblock.packet[3].v, p16uc_GETREAL64);
+
+        blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETIMAG64);
+        blocki.packet[1] = vec_perm(cblock.packet[2].v, cblock.packet[3].v, p16uc_GETIMAG64);
+
+        if(Conjugate)
+        {
+          blocki.packet[0] = -blocki.packet[0];
+          blocki.packet[1] = -blocki.packet[1];
+        }
+
+        storeBlock<double, Packet, Index>(blockBt + rir, blockr);
+        storeBlock<double, Packet, Index>(blockBt + rii, blocki);
+
+        rir += 2*vectorSize;
+        rii += 2*vectorSize;
+      }
+
+      rir += ((PanelMode) ? (2*vectorSize*(2*stride - depth)) : vectorDelta);
+    }
+
+    if (j < cols)
+    {
+      if(PanelMode) rir += (offset*(cols - j - 2*vectorSize));
+      rii = rir + (((PanelMode) ? stride : depth) * (cols - j));
+
+      for(Index i = 0; i < depth; i++)
+      {
+        Index k = j;
+        for(; k < cols; k++)
+        {
+          blockBt[rir] = rhs(i, k).real();
+
+          if(Conjugate)
+            blockBt[rii] = -rhs(i, k).imag();
+          else
+            blockBt[rii] =  rhs(i, k).imag();
+
+          rir += 1;
+          rii += 1;
+        }
+      }
+    }
+  }
+};
+
+/**************
+ * GEMM utils *
+ **************/
+
+// 512-bits rank1-update of acc. It can either positive or negative accumulate (useful for complex gemm).
+template<typename Packet, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pger_common(PacketBlock<Packet,4>* acc, const Packet& lhsV, const Packet* rhsV)
+{
+  if(NegativeAccumulate)
+  {
+    acc->packet[0] = vec_nmsub(lhsV, rhsV[0], acc->packet[0]);
+    acc->packet[1] = vec_nmsub(lhsV, rhsV[1], acc->packet[1]);
+    acc->packet[2] = vec_nmsub(lhsV, rhsV[2], acc->packet[2]);
+    acc->packet[3] = vec_nmsub(lhsV, rhsV[3], acc->packet[3]);
+  } else {
+    acc->packet[0] = vec_madd(lhsV, rhsV[0], acc->packet[0]);
+    acc->packet[1] = vec_madd(lhsV, rhsV[1], acc->packet[1]);
+    acc->packet[2] = vec_madd(lhsV, rhsV[2], acc->packet[2]);
+    acc->packet[3] = vec_madd(lhsV, rhsV[3], acc->packet[3]);
+  }
+}
+
+template<typename Packet, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pger_common(PacketBlock<Packet,1>* acc, const Packet& lhsV, const Packet* rhsV)
+{
+  if(NegativeAccumulate)
+  {
+    acc->packet[0] = vec_nmsub(lhsV, rhsV[0], acc->packet[0]);
+  } else {
+    acc->packet[0] = vec_madd(lhsV, rhsV[0], acc->packet[0]);
+  }
+}
+
+template<int N, typename Scalar, typename Packet, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pger(PacketBlock<Packet,N>* acc, const Scalar* lhs, const Packet* rhsV)
+{
+  Packet lhsV = pload<Packet>(lhs);
+
+  pger_common<Packet, NegativeAccumulate>(acc, lhsV, rhsV);
+}
+
+template<typename Scalar, typename Packet, typename Index>
+EIGEN_ALWAYS_INLINE void loadPacketRemaining(const Scalar* lhs, Packet &lhsV, Index remaining_rows)
+{
+#ifdef _ARCH_PWR9
+  lhsV = vec_xl_len((Scalar *)lhs, remaining_rows * sizeof(Scalar));
+#else
+  Index i = 0;
+  do {
+    lhsV[i] = lhs[i];
+  } while (++i < remaining_rows);
+#endif
+}
+
+template<int N, typename Scalar, typename Packet, typename Index, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pger(PacketBlock<Packet,N>* acc, const Scalar* lhs, const Packet* rhsV, Index remaining_rows)
+{
+  Packet lhsV;
+  loadPacketRemaining<Scalar, Packet, Index>(lhs, lhsV, remaining_rows);
+
+  pger_common<Packet, NegativeAccumulate>(acc, lhsV, rhsV);
+}
+
+// 512-bits rank1-update of complex acc. It takes decoupled accumulators as entries. It also takes cares of mixed types real * complex and complex * real.
+template<int N, typename Packet, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void pgerc_common(PacketBlock<Packet,N>* accReal, PacketBlock<Packet,N>* accImag, const Packet &lhsV, const Packet &lhsVi, const Packet* rhsV, const Packet* rhsVi)
+{
+  pger_common<Packet, false>(accReal, lhsV, rhsV);
+  if(LhsIsReal)
+  {
+    pger_common<Packet, ConjugateRhs>(accImag, lhsV, rhsVi);
+    EIGEN_UNUSED_VARIABLE(lhsVi);
+  } else {
+    if (!RhsIsReal) {
+      pger_common<Packet, ConjugateLhs == ConjugateRhs>(accReal, lhsVi, rhsVi);
+      pger_common<Packet, ConjugateRhs>(accImag, lhsV, rhsVi);
+    } else {
+      EIGEN_UNUSED_VARIABLE(rhsVi);
+    }
+    pger_common<Packet, ConjugateLhs>(accImag, lhsVi, rhsV);
+  }
+}
+
+template<int N, typename Scalar, typename Packet, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void pgerc(PacketBlock<Packet,N>* accReal, PacketBlock<Packet,N>* accImag, const Scalar* lhs_ptr, const Scalar* lhs_ptr_imag, const Packet* rhsV, const Packet* rhsVi)
+{
+  Packet lhsV = ploadLhs<Scalar, Packet>(lhs_ptr);
+  Packet lhsVi;
+  if(!LhsIsReal) lhsVi = ploadLhs<Scalar, Packet>(lhs_ptr_imag);
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+
+  pgerc_common<N, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(accReal, accImag, lhsV, lhsVi, rhsV, rhsVi);
+}
+
+template<typename Scalar, typename Packet, typename Index, bool LhsIsReal>
+EIGEN_ALWAYS_INLINE void loadPacketRemaining(const Scalar* lhs_ptr, const Scalar* lhs_ptr_imag, Packet &lhsV, Packet &lhsVi, Index remaining_rows)
+{
+#ifdef _ARCH_PWR9
+  lhsV = vec_xl_len((Scalar *)lhs_ptr, remaining_rows * sizeof(Scalar));
+  if(!LhsIsReal) lhsVi = vec_xl_len((Scalar *)lhs_ptr_imag, remaining_rows * sizeof(Scalar));
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+#else
+  Index i = 0;
+  do {
+    lhsV[i] = lhs_ptr[i];
+    if(!LhsIsReal) lhsVi[i] = lhs_ptr_imag[i];
+  } while (++i < remaining_rows);
+  if(LhsIsReal) EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+#endif
+}
+
+template<int N, typename Scalar, typename Packet, typename Index, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void pgerc(PacketBlock<Packet,N>* accReal, PacketBlock<Packet,N>* accImag, const Scalar* lhs_ptr, const Scalar* lhs_ptr_imag, const Packet* rhsV, const Packet* rhsVi, Index remaining_rows)
+{
+  Packet lhsV, lhsVi;
+  loadPacketRemaining<Scalar, Packet, Index, LhsIsReal>(lhs_ptr, lhs_ptr_imag, lhsV, lhsVi, remaining_rows);
+
+  pgerc_common<N, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(accReal, accImag, lhsV, lhsVi, rhsV, rhsVi);
+}
+
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE Packet ploadLhs(const Scalar* lhs)
+{
+  return ploadu<Packet>(lhs);
+}
+
+// Zero the accumulator on PacketBlock.
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE void bsetzero(PacketBlock<Packet,4>& acc)
+{
+  acc.packet[0] = pset1<Packet>((Scalar)0);
+  acc.packet[1] = pset1<Packet>((Scalar)0);
+  acc.packet[2] = pset1<Packet>((Scalar)0);
+  acc.packet[3] = pset1<Packet>((Scalar)0);
+}
+
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE void bsetzero(PacketBlock<Packet,1>& acc)
+{
+  acc.packet[0] = pset1<Packet>((Scalar)0);
+}
+
+// Scale the PacketBlock vectors by alpha.
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscale(PacketBlock<Packet,4>& acc, PacketBlock<Packet,4>& accZ, const Packet& pAlpha)
+{
+  acc.packet[0] = pmadd(pAlpha, accZ.packet[0], acc.packet[0]);
+  acc.packet[1] = pmadd(pAlpha, accZ.packet[1], acc.packet[1]);
+  acc.packet[2] = pmadd(pAlpha, accZ.packet[2], acc.packet[2]);
+  acc.packet[3] = pmadd(pAlpha, accZ.packet[3], acc.packet[3]);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscale(PacketBlock<Packet,1>& acc, PacketBlock<Packet,1>& accZ, const Packet& pAlpha)
+{
+  acc.packet[0] = pmadd(pAlpha, accZ.packet[0], acc.packet[0]);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscalec_common(PacketBlock<Packet,4>& acc, PacketBlock<Packet,4>& accZ, const Packet& pAlpha)
+{
+  acc.packet[0] = pmul<Packet>(accZ.packet[0], pAlpha);
+  acc.packet[1] = pmul<Packet>(accZ.packet[1], pAlpha);
+  acc.packet[2] = pmul<Packet>(accZ.packet[2], pAlpha);
+  acc.packet[3] = pmul<Packet>(accZ.packet[3], pAlpha);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscalec_common(PacketBlock<Packet,1>& acc, PacketBlock<Packet,1>& accZ, const Packet& pAlpha)
+{
+  acc.packet[0] = pmul<Packet>(accZ.packet[0], pAlpha);
+}
+
+// Complex version of PacketBlock scaling.
+template<typename Packet, int N>
+EIGEN_ALWAYS_INLINE void bscalec(PacketBlock<Packet,N>& aReal, PacketBlock<Packet,N>& aImag, const Packet& bReal, const Packet& bImag, PacketBlock<Packet,N>& cReal, PacketBlock<Packet,N>& cImag)
+{
+  bscalec_common<Packet>(cReal, aReal, bReal);
+
+  bscalec_common<Packet>(cImag, aImag, bReal);
+
+  pger_common<Packet, true>(&cReal, bImag, aImag.packet);
+
+  pger_common<Packet, false>(&cImag, bImag, aReal.packet);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void band(PacketBlock<Packet,4>& acc, const Packet& pMask)
+{
+  acc.packet[0] = pand(acc.packet[0], pMask);
+  acc.packet[1] = pand(acc.packet[1], pMask);
+  acc.packet[2] = pand(acc.packet[2], pMask);
+  acc.packet[3] = pand(acc.packet[3], pMask);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscalec(PacketBlock<Packet,4>& aReal, PacketBlock<Packet,4>& aImag, const Packet& bReal, const Packet& bImag, PacketBlock<Packet,4>& cReal, PacketBlock<Packet,4>& cImag, const Packet& pMask)
+{
+  band<Packet>(aReal, pMask);
+  band<Packet>(aImag, pMask);
+
+  bscalec<Packet,4>(aReal, aImag, bReal, bImag, cReal, cImag);
+}
+
+// Load a PacketBlock, the N parameters make tunning gemm easier so we can add more accumulators as needed.
+template<typename DataMapper, typename Packet, typename Index, const Index accCols, int N, int StorageOrder>
+EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet,4>& acc, const DataMapper& res, Index row, Index col)
+{
+  if (StorageOrder == RowMajor) {
+    acc.packet[0] = res.template loadPacket<Packet>(row + 0, col + N*accCols);
+    acc.packet[1] = res.template loadPacket<Packet>(row + 1, col + N*accCols);
+    acc.packet[2] = res.template loadPacket<Packet>(row + 2, col + N*accCols);
+    acc.packet[3] = res.template loadPacket<Packet>(row + 3, col + N*accCols);
+  } else {
+    acc.packet[0] = res.template loadPacket<Packet>(row + N*accCols, col + 0);
+    acc.packet[1] = res.template loadPacket<Packet>(row + N*accCols, col + 1);
+    acc.packet[2] = res.template loadPacket<Packet>(row + N*accCols, col + 2);
+    acc.packet[3] = res.template loadPacket<Packet>(row + N*accCols, col + 3);
+  }
+}
+
+// An overload of bload when you have a PacketBLock with 8 vectors.
+template<typename DataMapper, typename Packet, typename Index, const Index accCols, int N, int StorageOrder>
+EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet,8>& acc, const DataMapper& res, Index row, Index col)
+{
+  if (StorageOrder == RowMajor) {
+    acc.packet[0] = res.template loadPacket<Packet>(row + 0, col + N*accCols);
+    acc.packet[1] = res.template loadPacket<Packet>(row + 1, col + N*accCols);
+    acc.packet[2] = res.template loadPacket<Packet>(row + 2, col + N*accCols);
+    acc.packet[3] = res.template loadPacket<Packet>(row + 3, col + N*accCols);
+    acc.packet[4] = res.template loadPacket<Packet>(row + 0, col + (N+1)*accCols);
+    acc.packet[5] = res.template loadPacket<Packet>(row + 1, col + (N+1)*accCols);
+    acc.packet[6] = res.template loadPacket<Packet>(row + 2, col + (N+1)*accCols);
+    acc.packet[7] = res.template loadPacket<Packet>(row + 3, col + (N+1)*accCols);
+  } else {
+    acc.packet[0] = res.template loadPacket<Packet>(row + N*accCols, col + 0);
+    acc.packet[1] = res.template loadPacket<Packet>(row + N*accCols, col + 1);
+    acc.packet[2] = res.template loadPacket<Packet>(row + N*accCols, col + 2);
+    acc.packet[3] = res.template loadPacket<Packet>(row + N*accCols, col + 3);
+    acc.packet[4] = res.template loadPacket<Packet>(row + (N+1)*accCols, col + 0);
+    acc.packet[5] = res.template loadPacket<Packet>(row + (N+1)*accCols, col + 1);
+    acc.packet[6] = res.template loadPacket<Packet>(row + (N+1)*accCols, col + 2);
+    acc.packet[7] = res.template loadPacket<Packet>(row + (N+1)*accCols, col + 3);
+  }
+}
+
+template<typename DataMapper, typename Packet, typename Index, const Index accCols, int N, int StorageOrder>
+EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet,2>& acc, const DataMapper& res, Index row, Index col)
+{
+  acc.packet[0] = res.template loadPacket<Packet>(row + N*accCols, col + 0);
+  acc.packet[1] = res.template loadPacket<Packet>(row + (N+1)*accCols, col + 0);
+}
+
+const static Packet4i mask41 = { -1,  0,  0,  0 };
+const static Packet4i mask42 = { -1, -1,  0,  0 };
+const static Packet4i mask43 = { -1, -1, -1,  0 };
+
+const static Packet2l mask21 = { -1, 0 };
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE Packet bmask(const int remaining_rows)
+{
+  if (remaining_rows == 0) {
+    return pset1<Packet>(float(0.0));  // Not used
+  } else {
+    switch (remaining_rows) {
+      case 1:  return Packet(mask41);
+      case 2:  return Packet(mask42);
+      default: return Packet(mask43);
+    }
+  }
+}
+
+template<>
+EIGEN_ALWAYS_INLINE Packet2d bmask<Packet2d>(const int remaining_rows)
+{
+  if (remaining_rows == 0) {
+    return pset1<Packet2d>(double(0.0));  // Not used
+  } else {
+    return Packet2d(mask21);
+  }
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscale(PacketBlock<Packet,4>& acc, PacketBlock<Packet,4>& accZ, const Packet& pAlpha, const Packet& pMask)
+{
+  band<Packet>(accZ, pMask);
+
+  bscale<Packet>(acc, accZ, pAlpha);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void pbroadcast4_old(const __UNPACK_TYPE__(Packet)* a, Packet& a0, Packet& a1, Packet& a2, Packet& a3)
+{
+  pbroadcast4<Packet>(a, a0, a1, a2, a3);
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void pbroadcast4_old<Packet2d>(const double* a, Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+  a1 = pload<Packet2d>(a);
+  a3 = pload<Packet2d>(a + 2);
+  a0 = vec_splat(a1, 0);
+  a1 = vec_splat(a1, 1);
+  a2 = vec_splat(a3, 0);
+  a3 = vec_splat(a3, 1);
+}
+
+// PEEL loop factor.
+#define PEEL 7
+
+template<typename Scalar, typename Packet, typename Index>
+EIGEN_ALWAYS_INLINE void MICRO_EXTRA_COL(
+  const Scalar* &lhs_ptr,
+  const Scalar* &rhs_ptr,
+  PacketBlock<Packet,1> &accZero,
+  Index remaining_rows,
+  Index remaining_cols)
+{
+  Packet rhsV[1];
+  rhsV[0] = pset1<Packet>(rhs_ptr[0]);
+  pger<1,Scalar, Packet, false>(&accZero, lhs_ptr, rhsV);
+  lhs_ptr += remaining_rows;
+  rhs_ptr += remaining_cols;
+}
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accRows>
+EIGEN_STRONG_INLINE void gemm_extra_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index row,
+  Index col,
+  Index remaining_rows,
+  Index remaining_cols,
+  const Packet& pAlpha)
+{
+  const Scalar* rhs_ptr = rhs_base;
+  const Scalar* lhs_ptr = lhs_base + row*strideA + remaining_rows*offsetA;
+  PacketBlock<Packet,1> accZero;
+
+  bsetzero<Scalar, Packet>(accZero);
+
+  Index remaining_depth = (depth & -accRows);
+  Index k = 0;
+  for(; k + PEEL <= remaining_depth; k+= PEEL)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr);
+    EIGEN_POWER_PREFETCH(lhs_ptr);
+    for (int l = 0; l < PEEL; l++) {
+      MICRO_EXTRA_COL<Scalar, Packet, Index>(lhs_ptr, rhs_ptr, accZero, remaining_rows, remaining_cols);
+    }
+  }
+  for(; k < remaining_depth; k++)
+  {
+    MICRO_EXTRA_COL<Scalar, Packet, Index>(lhs_ptr, rhs_ptr, accZero, remaining_rows, remaining_cols);
+  }
+  for(; k < depth; k++)
+  {
+    Packet rhsV[1];
+    rhsV[0] = pset1<Packet>(rhs_ptr[0]);
+    pger<1, Scalar, Packet, Index, false>(&accZero, lhs_ptr, rhsV, remaining_rows);
+    lhs_ptr += remaining_rows;
+    rhs_ptr += remaining_cols;
+  }
+
+  accZero.packet[0] = vec_mul(pAlpha, accZero.packet[0]);
+  for(Index i = 0; i < remaining_rows; i++) {
+    res(row + i, col) += accZero.packet[0][i];
+  }
+}
+
+template<typename Scalar, typename Packet, typename Index, const Index accRows>
+EIGEN_ALWAYS_INLINE void MICRO_EXTRA_ROW(
+  const Scalar* &lhs_ptr,
+  const Scalar* &rhs_ptr,
+  PacketBlock<Packet,4> &accZero,
+  Index remaining_rows)
+{
+  Packet rhsV[4];
+  pbroadcast4<Packet>(rhs_ptr, rhsV[0], rhsV[1], rhsV[2], rhsV[3]);
+  pger<4, Scalar, Packet, false>(&accZero, lhs_ptr, rhsV);
+  lhs_ptr += remaining_rows;
+  rhs_ptr += accRows;
+}
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accRows, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_extra_row(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index row,
+  Index col,
+  Index rows,
+  Index cols,
+  Index remaining_rows,
+  const Packet& pAlpha,
+  const Packet& pMask)
+{
+  const Scalar* rhs_ptr = rhs_base;
+  const Scalar* lhs_ptr = lhs_base + row*strideA + remaining_rows*offsetA;
+  PacketBlock<Packet,4> accZero, acc;
+
+  bsetzero<Scalar, Packet>(accZero);
+
+  Index remaining_depth = (col + accRows < cols) ? depth : (depth & -accRows);
+  Index k = 0;
+  for(; k + PEEL <= remaining_depth; k+= PEEL)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr);
+    EIGEN_POWER_PREFETCH(lhs_ptr);
+    for (int l = 0; l < PEEL; l++) {
+      MICRO_EXTRA_ROW<Scalar, Packet, Index, accRows>(lhs_ptr, rhs_ptr, accZero, remaining_rows);
+    }
+  }
+  for(; k < remaining_depth; k++)
+  {
+    MICRO_EXTRA_ROW<Scalar, Packet, Index, accRows>(lhs_ptr, rhs_ptr, accZero, remaining_rows);
+  }
+
+  if ((remaining_depth == depth) && (rows >= accCols))
+  {
+    for(Index j = 0; j < 4; j++) {
+      acc.packet[j] = res.template loadPacket<Packet>(row, col + j);
+    }
+    bscale<Packet>(acc, accZero, pAlpha, pMask);
+    res.template storePacketBlock<Packet,4>(row, col, acc);
+  } else {
+    for(; k < depth; k++)
+    {
+      Packet rhsV[4];
+      pbroadcast4<Packet>(rhs_ptr, rhsV[0], rhsV[1], rhsV[2], rhsV[3]);
+      pger<4, Scalar, Packet, Index, false>(&accZero, lhs_ptr, rhsV, remaining_rows);
+      lhs_ptr += remaining_rows;
+      rhs_ptr += accRows;
+    }
+
+    for(Index j = 0; j < 4; j++) {
+      accZero.packet[j] = vec_mul(pAlpha, accZero.packet[j]);
+    }
+    for(Index j = 0; j < 4; j++) {
+      for(Index i = 0; i < remaining_rows; i++) {
+        res(row + i, col + j) += accZero.packet[j][i];
+      }
+    }
+  }
+}
+
+#define MICRO_UNROLL(func) \
+  func(0) func(1) func(2) func(3) func(4) func(5) func(6) func(7)
+
+#define MICRO_UNROLL_WORK(func, func2, peel) \
+    MICRO_UNROLL(func2); \
+    func(0,peel) func(1,peel) func(2,peel) func(3,peel) \
+    func(4,peel) func(5,peel) func(6,peel) func(7,peel)
+
+#define MICRO_LOAD_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhsV##iter = ploadLhs<Scalar, Packet>(lhs_ptr##iter); \
+    lhs_ptr##iter += accCols; \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhsV##iter); \
+  }
+
+#define MICRO_WORK_ONE(iter, peel) \
+  if (unroll_factor > iter) { \
+    pger_common<Packet, false>(&accZero##iter, lhsV##iter, rhsV##peel); \
+  }
+
+#define MICRO_TYPE_PEEL4(func, func2, peel) \
+  if (PEEL > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4, lhsV5, lhsV6, lhsV7; \
+    pbroadcast4<Packet>(rhs_ptr + (accRows * peel), rhsV##peel[0], rhsV##peel[1], rhsV##peel[2], rhsV##peel[3]); \
+    MICRO_UNROLL_WORK(func, func2, peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+  }
+
+#define MICRO_TYPE_PEEL1(func, func2, peel) \
+  if (PEEL > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4, lhsV5, lhsV6, lhsV7; \
+    rhsV##peel[0] = pset1<Packet>(rhs_ptr[remaining_cols * peel]); \
+    MICRO_UNROLL_WORK(func, func2, peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+  }
+
+#define MICRO_UNROLL_TYPE_PEEL(M, func, func1, func2) \
+  Packet rhsV0[M], rhsV1[M], rhsV2[M], rhsV3[M], rhsV4[M], rhsV5[M], rhsV6[M], rhsV7[M], rhsV8[M], rhsV9[M]; \
+  func(func1,func2,0); func(func1,func2,1); \
+  func(func1,func2,2); func(func1,func2,3); \
+  func(func1,func2,4); func(func1,func2,5); \
+  func(func1,func2,6); func(func1,func2,7); \
+  func(func1,func2,8); func(func1,func2,9);
+
+#define MICRO_UNROLL_TYPE_ONE(M, func, func1, func2) \
+  Packet rhsV0[M]; \
+  func(func1,func2,0);
+
+#define MICRO_ONE_PEEL4 \
+  MICRO_UNROLL_TYPE_PEEL(4, MICRO_TYPE_PEEL4, MICRO_WORK_ONE, MICRO_LOAD_ONE); \
+  rhs_ptr += (accRows * PEEL);
+
+#define MICRO_ONE4 \
+  MICRO_UNROLL_TYPE_ONE(4, MICRO_TYPE_PEEL4, MICRO_WORK_ONE, MICRO_LOAD_ONE); \
+  rhs_ptr += accRows;
+
+#define MICRO_ONE_PEEL1 \
+  MICRO_UNROLL_TYPE_PEEL(1, MICRO_TYPE_PEEL1, MICRO_WORK_ONE, MICRO_LOAD_ONE); \
+  rhs_ptr += (remaining_cols * PEEL);
+
+#define MICRO_ONE1 \
+  MICRO_UNROLL_TYPE_ONE(1, MICRO_TYPE_PEEL1, MICRO_WORK_ONE, MICRO_LOAD_ONE); \
+  rhs_ptr += remaining_cols;
+
+#define MICRO_DST_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bsetzero<Scalar, Packet>(accZero##iter); \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(accZero##iter); \
+  }
+
+#define MICRO_DST_PTR MICRO_UNROLL(MICRO_DST_PTR_ONE)
+
+#define MICRO_SRC_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhs_ptr##iter = lhs_base + ( (row/accCols) + iter )*strideA*accCols + accCols*offsetA; \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr##iter); \
+  }
+
+#define MICRO_SRC_PTR MICRO_UNROLL(MICRO_SRC_PTR_ONE)
+
+#define MICRO_PREFETCH_ONE(iter) \
+  if (unroll_factor > iter) { \
+    EIGEN_POWER_PREFETCH(lhs_ptr##iter); \
+  }
+
+#define MICRO_PREFETCH MICRO_UNROLL(MICRO_PREFETCH_ONE)
+
+#define MICRO_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    acc.packet[0] = res.template loadPacket<Packet>(row + iter*accCols, col + 0); \
+    acc.packet[1] = res.template loadPacket<Packet>(row + iter*accCols, col + 1); \
+    acc.packet[2] = res.template loadPacket<Packet>(row + iter*accCols, col + 2); \
+    acc.packet[3] = res.template loadPacket<Packet>(row + iter*accCols, col + 3); \
+    bscale<Packet>(acc, accZero##iter, pAlpha); \
+    res.template storePacketBlock<Packet,4>(row + iter*accCols, col, acc); \
+  }
+
+#define MICRO_STORE MICRO_UNROLL(MICRO_STORE_ONE)
+
+#define MICRO_COL_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    acc.packet[0] = res.template loadPacket<Packet>(row + iter*accCols, col + 0); \
+    bscale<Packet>(acc, accZero##iter, pAlpha); \
+    res.template storePacketBlock<Packet,1>(row + iter*accCols, col, acc); \
+  }
+
+#define MICRO_COL_STORE MICRO_UNROLL(MICRO_COL_STORE_ONE)
+
+template<int unroll_factor, typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accRows, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_unrolled_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index& row,
+  Index col,
+  const Packet& pAlpha)
+{
+  const Scalar* rhs_ptr = rhs_base;
+  const Scalar* lhs_ptr0 = NULL, *  lhs_ptr1 = NULL, * lhs_ptr2 = NULL, * lhs_ptr3 = NULL, * lhs_ptr4 = NULL, * lhs_ptr5 = NULL, * lhs_ptr6 = NULL, * lhs_ptr7 = NULL;
+  PacketBlock<Packet,4> accZero0, accZero1, accZero2, accZero3, accZero4, accZero5, accZero6, accZero7;
+  PacketBlock<Packet,4> acc;
+
+  MICRO_SRC_PTR
+  MICRO_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL <= depth; k+= PEEL)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr);
+    MICRO_PREFETCH
+    MICRO_ONE_PEEL4
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_ONE4
+  }
+  MICRO_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<int unroll_factor, typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_unrolled_col_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index& row,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlpha)
+{
+  const Scalar* rhs_ptr = rhs_base;
+  const Scalar* lhs_ptr0 = NULL, * lhs_ptr1 = NULL, * lhs_ptr2 = NULL, * lhs_ptr3 = NULL, * lhs_ptr4 = NULL, * lhs_ptr5 = NULL, * lhs_ptr6 = NULL, *lhs_ptr7 = NULL;
+  PacketBlock<Packet,1> accZero0, accZero1, accZero2, accZero3, accZero4, accZero5, accZero6, accZero7;
+  PacketBlock<Packet,1> acc;
+
+  MICRO_SRC_PTR
+  MICRO_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL <= depth; k+= PEEL)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr);
+    MICRO_PREFETCH
+    MICRO_ONE_PEEL1
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_ONE1
+  }
+  MICRO_COL_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_unrolled_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index& row,
+  Index rows,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlpha)
+{
+#define MAX_UNROLL 6
+  while(row + MAX_UNROLL*accCols <= rows) {
+    gemm_unrolled_col_iteration<MAX_UNROLL, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+  }
+  switch( (rows-row)/accCols ) {
+#if MAX_UNROLL > 7
+    case 7:
+      gemm_unrolled_col_iteration<7, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+      break;
+#endif
+#if MAX_UNROLL > 6
+    case 6:
+      gemm_unrolled_col_iteration<6, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+      break;
+#endif
+#if MAX_UNROLL > 5
+   case 5:
+      gemm_unrolled_col_iteration<5, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+      break;
+#endif
+#if MAX_UNROLL > 4
+   case 4:
+      gemm_unrolled_col_iteration<4, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+      break;
+#endif
+#if MAX_UNROLL > 3
+   case 3:
+     gemm_unrolled_col_iteration<3, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+     break;
+#endif
+#if MAX_UNROLL > 2
+   case 2:
+     gemm_unrolled_col_iteration<2, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+     break;
+#endif
+#if MAX_UNROLL > 1
+   case 1:
+     gemm_unrolled_col_iteration<1, Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_cols, pAlpha);
+     break;
+#endif
+   default:
+     break;
+  }
+#undef MAX_UNROLL
+}
+
+/****************
+ * GEMM kernels *
+ * **************/
+template<typename Scalar, typename Index, typename Packet, typename RhsPacket, typename DataMapper, const Index accRows, const Index accCols>
+EIGEN_STRONG_INLINE void gemm(const DataMapper& res, const Scalar* blockA, const Scalar* blockB, Index rows, Index depth, Index cols, Scalar alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
+{
+      const Index remaining_rows = rows % accCols;
+      const Index remaining_cols = cols % accRows;
+
+      if( strideA == -1 ) strideA = depth;
+      if( strideB == -1 ) strideB = depth;
+
+      const Packet pAlpha = pset1<Packet>(alpha);
+      const Packet pMask  = bmask<Packet>((const int)(remaining_rows));
+
+      Index col = 0;
+      for(; col + accRows <= cols; col += accRows)
+      {
+        const Scalar* rhs_base = blockB + col*strideB + accRows*offsetB;
+        const Scalar* lhs_base = blockA;
+        Index row = 0;
+
+#define MAX_UNROLL 6
+        while(row + MAX_UNROLL*accCols <= rows) {
+          gemm_unrolled_iteration<MAX_UNROLL, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+        }
+        switch( (rows-row)/accCols ) {
+#if MAX_UNROLL > 7
+          case 7:
+            gemm_unrolled_iteration<7, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 6
+          case 6:
+            gemm_unrolled_iteration<6, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 5
+          case 5:
+            gemm_unrolled_iteration<5, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 4
+          case 4:
+            gemm_unrolled_iteration<4, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 3
+          case 3:
+            gemm_unrolled_iteration<3, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 2
+          case 2:
+            gemm_unrolled_iteration<2, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_UNROLL > 1
+          case 1:
+            gemm_unrolled_iteration<1, Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+          default:
+            break;
+        }
+#undef MAX_UNROLL
+
+        if(remaining_rows > 0)
+        {
+          gemm_extra_row<Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, rows, cols, remaining_rows, pAlpha, pMask);
+        }
+    }
+
+    if(remaining_cols > 0)
+    {
+      const Scalar* rhs_base = blockB + col*strideB + remaining_cols*offsetB;
+      const Scalar* lhs_base = blockA;
+
+      for(; col < cols; col++)
+      {
+        Index row = 0;
+
+        gemm_unrolled_col<Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, rows, col, remaining_cols, pAlpha);
+
+        if (remaining_rows > 0)
+        {
+          gemm_extra_col<Scalar, Packet, DataMapper, Index, accRows>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_rows, remaining_cols, pAlpha);
+        }
+        rhs_base++;
+      }
+    }
+}
+
+#define accColsC (accCols / 2)
+#define advanceRows ((LhsIsReal) ? 1 : 2)
+#define advanceCols ((RhsIsReal) ? 1 : 2)
+
+// PEEL_COMPLEX loop factor.
+#define PEEL_COMPLEX 3
+
+template<typename Scalar, typename Packet, typename Index, const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void MICRO_COMPLEX_EXTRA_COL(
+  const Scalar* &lhs_ptr_real, const Scalar* &lhs_ptr_imag,
+  const Scalar* &rhs_ptr_real, const Scalar* &rhs_ptr_imag,
+  PacketBlock<Packet,1> &accReal, PacketBlock<Packet,1> &accImag,
+  Index remaining_rows,
+  Index remaining_cols)
+{
+  Packet rhsV[1], rhsVi[1];
+  rhsV[0] = pset1<Packet>(rhs_ptr_real[0]);
+  if(!RhsIsReal) rhsVi[0] = pset1<Packet>(rhs_ptr_imag[0]);
+  pgerc<1, Scalar, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal, &accImag, lhs_ptr_real, lhs_ptr_imag, rhsV, rhsVi);
+  lhs_ptr_real += remaining_rows;
+  if(!LhsIsReal) lhs_ptr_imag += remaining_rows;
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+  rhs_ptr_real += remaining_cols;
+  if(!RhsIsReal) rhs_ptr_imag += remaining_cols;
+  else EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+}
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_extra_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index row,
+  Index col,
+  Index remaining_rows,
+  Index remaining_cols,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag)
+{
+  const Scalar* rhs_ptr_real = rhs_base;
+  const Scalar* rhs_ptr_imag;
+  if(!RhsIsReal) rhs_ptr_imag = rhs_base + remaining_cols*strideB;
+  else EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+  const Scalar* lhs_ptr_real = lhs_base + advanceRows*row*strideA + remaining_rows*offsetA;
+  const Scalar* lhs_ptr_imag;
+  if(!LhsIsReal) lhs_ptr_imag = lhs_ptr_real + remaining_rows*strideA;
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+  PacketBlock<Packet,1> accReal, accImag;
+  PacketBlock<Packet,1> taccReal, taccImag;
+  PacketBlock<Packetc,1> acc0, acc1;
+
+  bsetzero<Scalar, Packet>(accReal);
+  bsetzero<Scalar, Packet>(accImag);
+
+  Index remaining_depth = (depth & -accRows);
+  Index k = 0;
+  for(; k + PEEL_COMPLEX <= remaining_depth; k+= PEEL_COMPLEX)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr_real);
+    if(!RhsIsReal) {
+      EIGEN_POWER_PREFETCH(rhs_ptr_imag);
+    }
+    EIGEN_POWER_PREFETCH(lhs_ptr_real);
+    if(!LhsIsReal) {
+      EIGEN_POWER_PREFETCH(lhs_ptr_imag);
+    }
+    for (int l = 0; l < PEEL_COMPLEX; l++) {
+      MICRO_COMPLEX_EXTRA_COL<Scalar, Packet, Index, accRows, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(lhs_ptr_real, lhs_ptr_imag, rhs_ptr_real, rhs_ptr_imag, accReal, accImag, remaining_rows, remaining_cols);
+    }
+  }
+  for(; k < remaining_depth; k++)
+  {
+    MICRO_COMPLEX_EXTRA_COL<Scalar, Packet, Index, accRows, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(lhs_ptr_real, lhs_ptr_imag, rhs_ptr_real, rhs_ptr_imag, accReal, accImag, remaining_rows, remaining_cols);
+  }
+
+  for(; k < depth; k++)
+  {
+    Packet rhsV[1], rhsVi[1];
+    rhsV[0] = pset1<Packet>(rhs_ptr_real[0]);
+    if(!RhsIsReal) rhsVi[0] = pset1<Packet>(rhs_ptr_imag[0]);
+    pgerc<1, Scalar, Packet, Index, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal, &accImag, lhs_ptr_real, lhs_ptr_imag, rhsV, rhsVi, remaining_rows);
+    lhs_ptr_real += remaining_rows;
+    if(!LhsIsReal) lhs_ptr_imag += remaining_rows;
+    rhs_ptr_real += remaining_cols;
+    if(!RhsIsReal) rhs_ptr_imag += remaining_cols;
+  }
+
+  bscalec<Packet,1>(accReal, accImag, pAlphaReal, pAlphaImag, taccReal, taccImag);
+  bcouple_common<Packet, Packetc>(taccReal, taccImag, acc0, acc1);
+
+  if ((sizeof(Scalar) == sizeof(float)) && (remaining_rows == 1))
+  {
+    res(row + 0, col + 0) += pfirst<Packetc>(acc0.packet[0]);
+  } else {
+    acc0.packet[0] += res.template loadPacket<Packetc>(row + 0, col + 0);
+    res.template storePacketBlock<Packetc,1>(row + 0, col + 0, acc0);
+    if(remaining_rows > accColsC) {
+      res(row + accColsC, col + 0) += pfirst<Packetc>(acc1.packet[0]);
+    }
+  }
+}
+
+template<typename Scalar, typename Packet, typename Index, const Index accRows, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void MICRO_COMPLEX_EXTRA_ROW(
+  const Scalar* &lhs_ptr_real, const Scalar* &lhs_ptr_imag,
+  const Scalar* &rhs_ptr_real, const Scalar* &rhs_ptr_imag,
+  PacketBlock<Packet,4> &accReal, PacketBlock<Packet,4> &accImag,
+  Index remaining_rows)
+{
+  Packet rhsV[4], rhsVi[4];
+  pbroadcast4_old<Packet>(rhs_ptr_real, rhsV[0], rhsV[1], rhsV[2], rhsV[3]);
+  if(!RhsIsReal) pbroadcast4_old<Packet>(rhs_ptr_imag, rhsVi[0], rhsVi[1], rhsVi[2], rhsVi[3]);
+  pgerc<4, Scalar, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal, &accImag, lhs_ptr_real, lhs_ptr_imag, rhsV, rhsVi);
+  lhs_ptr_real += remaining_rows;
+  if(!LhsIsReal) lhs_ptr_imag += remaining_rows;
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+  rhs_ptr_real += accRows;
+  if(!RhsIsReal) rhs_ptr_imag += accRows;
+  else EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+}
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_extra_row(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index row,
+  Index col,
+  Index rows,
+  Index cols,
+  Index remaining_rows,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag,
+  const Packet& pMask)
+{
+  const Scalar* rhs_ptr_real = rhs_base;
+  const Scalar* rhs_ptr_imag;
+  if(!RhsIsReal) rhs_ptr_imag = rhs_base + accRows*strideB;
+  else EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+  const Scalar* lhs_ptr_real = lhs_base + advanceRows*row*strideA + remaining_rows*offsetA;
+  const Scalar* lhs_ptr_imag;
+  if(!LhsIsReal) lhs_ptr_imag = lhs_ptr_real + remaining_rows*strideA;
+  else EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
+  PacketBlock<Packet,4> accReal, accImag;
+  PacketBlock<Packet,4> taccReal, taccImag;
+  PacketBlock<Packetc,4> acc0, acc1;
+  PacketBlock<Packetc,8> tRes;
+
+  bsetzero<Scalar, Packet>(accReal);
+  bsetzero<Scalar, Packet>(accImag);
+
+  Index remaining_depth = (col + accRows < cols) ? depth : (depth & -accRows);
+  Index k = 0;
+  for(; k + PEEL_COMPLEX <= remaining_depth; k+= PEEL_COMPLEX)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr_real);
+    if(!RhsIsReal) {
+      EIGEN_POWER_PREFETCH(rhs_ptr_imag);
+    }
+    EIGEN_POWER_PREFETCH(lhs_ptr_real);
+    if(!LhsIsReal) {
+      EIGEN_POWER_PREFETCH(lhs_ptr_imag);
+    }
+    for (int l = 0; l < PEEL_COMPLEX; l++) {
+      MICRO_COMPLEX_EXTRA_ROW<Scalar, Packet, Index, accRows, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(lhs_ptr_real, lhs_ptr_imag, rhs_ptr_real, rhs_ptr_imag, accReal, accImag, remaining_rows);
+    }
+  }
+  for(; k < remaining_depth; k++)
+  {
+    MICRO_COMPLEX_EXTRA_ROW<Scalar, Packet, Index, accRows, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(lhs_ptr_real, lhs_ptr_imag, rhs_ptr_real, rhs_ptr_imag, accReal, accImag, remaining_rows);
+  }
+
+  if ((remaining_depth == depth) && (rows >= accCols))
+  {
+    bload<DataMapper, Packetc, Index, accColsC, 0, ColMajor>(tRes, res, row, col);
+    bscalec<Packet>(accReal, accImag, pAlphaReal, pAlphaImag, taccReal, taccImag, pMask);
+    bcouple<Packet, Packetc>(taccReal, taccImag, tRes, acc0, acc1);
+    res.template storePacketBlock<Packetc,4>(row + 0, col, acc0);
+    res.template storePacketBlock<Packetc,4>(row + accColsC, col, acc1);
+  } else {
+    for(; k < depth; k++)
+    {
+      Packet rhsV[4], rhsVi[4];
+      pbroadcast4_old<Packet>(rhs_ptr_real, rhsV[0], rhsV[1], rhsV[2], rhsV[3]);
+      if(!RhsIsReal) pbroadcast4_old<Packet>(rhs_ptr_imag, rhsVi[0], rhsVi[1], rhsVi[2], rhsVi[3]);
+      pgerc<4, Scalar, Packet, Index, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal, &accImag, lhs_ptr_real, lhs_ptr_imag, rhsV, rhsVi, remaining_rows);
+      lhs_ptr_real += remaining_rows;
+      if(!LhsIsReal) lhs_ptr_imag += remaining_rows;
+      rhs_ptr_real += accRows;
+      if(!RhsIsReal) rhs_ptr_imag += accRows;
+    }
+
+    bscalec<Packet,4>(accReal, accImag, pAlphaReal, pAlphaImag, taccReal, taccImag);
+    bcouple_common<Packet, Packetc>(taccReal, taccImag, acc0, acc1);
+
+    if ((sizeof(Scalar) == sizeof(float)) && (remaining_rows == 1))
+    {
+      for(Index j = 0; j < 4; j++) {
+        res(row + 0, col + j) += pfirst<Packetc>(acc0.packet[j]);
+      }
+    } else {
+      for(Index j = 0; j < 4; j++) {
+        PacketBlock<Packetc,1> acc2;
+        acc2.packet[0] = res.template loadPacket<Packetc>(row + 0, col + j) + acc0.packet[j];
+        res.template storePacketBlock<Packetc,1>(row + 0, col + j, acc2);
+        if(remaining_rows > accColsC) {
+          res(row + accColsC, col + j) += pfirst<Packetc>(acc1.packet[j]);
+        }
+      }
+    }
+  }
+}
+
+#define MICRO_COMPLEX_UNROLL(func) \
+  func(0) func(1) func(2) func(3) func(4)
+
+#define MICRO_COMPLEX_UNROLL_WORK(func, func2, peel) \
+    MICRO_COMPLEX_UNROLL(func2); \
+    func(0,peel) func(1,peel) func(2,peel) func(3,peel) func(4,peel)
+
+#define MICRO_COMPLEX_LOAD_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhsV##iter = ploadLhs<Scalar, Packet>(lhs_ptr_real##iter); \
+    lhs_ptr_real##iter += accCols; \
+    if(!LhsIsReal) { \
+      lhsVi##iter = ploadLhs<Scalar, Packet>(lhs_ptr_imag##iter); \
+      lhs_ptr_imag##iter += accCols; \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(lhsVi##iter); \
+    } \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhsV##iter); \
+    EIGEN_UNUSED_VARIABLE(lhsVi##iter); \
+  }
+
+#define MICRO_COMPLEX_WORK_ONE4(iter, peel) \
+  if (unroll_factor > iter) { \
+    pgerc_common<4, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal##iter, &accImag##iter, lhsV##iter, lhsVi##iter, rhsV##peel, rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_WORK_ONE1(iter, peel) \
+  if (unroll_factor > iter) { \
+    pgerc_common<1, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal##iter, &accImag##iter, lhsV##iter, lhsVi##iter, rhsV##peel, rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_TYPE_PEEL4(func, func2, peel) \
+  if (PEEL_COMPLEX > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4; \
+    Packet lhsVi0, lhsVi1, lhsVi2, lhsVi3, lhsVi4; \
+    pbroadcast4_old<Packet>(rhs_ptr_real + (accRows * peel), rhsV##peel[0], rhsV##peel[1], rhsV##peel[2], rhsV##peel[3]); \
+    if(!RhsIsReal) { \
+      pbroadcast4_old<Packet>(rhs_ptr_imag + (accRows * peel), rhsVi##peel[0], rhsVi##peel[1], rhsVi##peel[2], rhsVi##peel[3]); \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+    } \
+    MICRO_COMPLEX_UNROLL_WORK(func, func2, peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+    EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_TYPE_PEEL1(func, func2, peel) \
+  if (PEEL_COMPLEX > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4; \
+    Packet lhsVi0, lhsVi1, lhsVi2, lhsVi3, lhsVi4; \
+    rhsV##peel[0] = pset1<Packet>(rhs_ptr_real[remaining_cols * peel]); \
+    if(!RhsIsReal) { \
+      rhsVi##peel[0] = pset1<Packet>(rhs_ptr_imag[remaining_cols * peel]); \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+    } \
+    MICRO_COMPLEX_UNROLL_WORK(func, func2, peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+    EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_UNROLL_TYPE_PEEL(M, func, func1, func2) \
+  Packet rhsV0[M], rhsV1[M], rhsV2[M], rhsV3[M], rhsV4[M], rhsV5[M], rhsV6[M], rhsV7[M], rhsV8[M], rhsV9[M]; \
+  Packet rhsVi0[M], rhsVi1[M], rhsVi2[M], rhsVi3[M], rhsVi4[M], rhsVi5[M], rhsVi6[M], rhsVi7[M], rhsVi8[M], rhsVi9[M]; \
+  func(func1,func2,0); func(func1,func2,1); \
+  func(func1,func2,2); func(func1,func2,3); \
+  func(func1,func2,4); func(func1,func2,5); \
+  func(func1,func2,6); func(func1,func2,7); \
+  func(func1,func2,8); func(func1,func2,9);
+
+#define MICRO_COMPLEX_UNROLL_TYPE_ONE(M, func, func1, func2) \
+  Packet rhsV0[M], rhsVi0[M];\
+  func(func1,func2,0);
+
+#define MICRO_COMPLEX_ONE_PEEL4 \
+  MICRO_COMPLEX_UNROLL_TYPE_PEEL(4, MICRO_COMPLEX_TYPE_PEEL4, MICRO_COMPLEX_WORK_ONE4, MICRO_COMPLEX_LOAD_ONE); \
+  rhs_ptr_real += (accRows * PEEL_COMPLEX); \
+  if(!RhsIsReal) rhs_ptr_imag += (accRows * PEEL_COMPLEX);
+
+#define MICRO_COMPLEX_ONE4 \
+  MICRO_COMPLEX_UNROLL_TYPE_ONE(4, MICRO_COMPLEX_TYPE_PEEL4, MICRO_COMPLEX_WORK_ONE4, MICRO_COMPLEX_LOAD_ONE); \
+  rhs_ptr_real += accRows; \
+  if(!RhsIsReal) rhs_ptr_imag += accRows;
+
+#define MICRO_COMPLEX_ONE_PEEL1 \
+  MICRO_COMPLEX_UNROLL_TYPE_PEEL(1, MICRO_COMPLEX_TYPE_PEEL1, MICRO_COMPLEX_WORK_ONE1, MICRO_COMPLEX_LOAD_ONE); \
+  rhs_ptr_real += (remaining_cols * PEEL_COMPLEX); \
+  if(!RhsIsReal) rhs_ptr_imag += (remaining_cols * PEEL_COMPLEX);
+
+#define MICRO_COMPLEX_ONE1 \
+  MICRO_COMPLEX_UNROLL_TYPE_ONE(1, MICRO_COMPLEX_TYPE_PEEL1, MICRO_COMPLEX_WORK_ONE1, MICRO_COMPLEX_LOAD_ONE); \
+  rhs_ptr_real += remaining_cols; \
+  if(!RhsIsReal) rhs_ptr_imag += remaining_cols;
+
+#define MICRO_COMPLEX_DST_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bsetzero<Scalar, Packet>(accReal##iter); \
+    bsetzero<Scalar, Packet>(accImag##iter); \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(accReal##iter); \
+    EIGEN_UNUSED_VARIABLE(accImag##iter); \
+  }
+
+#define MICRO_COMPLEX_DST_PTR MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_DST_PTR_ONE)
+
+#define MICRO_COMPLEX_SRC_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhs_ptr_real##iter = lhs_base + ( ((advanceRows*row)/accCols) + iter*advanceRows )*strideA*accCols + accCols*offsetA; \
+    if(!LhsIsReal) { \
+      lhs_ptr_imag##iter = lhs_ptr_real##iter + accCols*strideA; \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(lhs_ptr_imag##iter); \
+    } \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr_real##iter); \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr_imag##iter); \
+  }
+
+#define MICRO_COMPLEX_SRC_PTR MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_SRC_PTR_ONE)
+
+#define MICRO_COMPLEX_PREFETCH_ONE(iter) \
+  if (unroll_factor > iter) { \
+    EIGEN_POWER_PREFETCH(lhs_ptr_real##iter); \
+    if(!LhsIsReal) { \
+      EIGEN_POWER_PREFETCH(lhs_ptr_imag##iter); \
+    } \
+  }
+
+#define MICRO_COMPLEX_PREFETCH MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_PREFETCH_ONE)
+
+#define MICRO_COMPLEX_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bload<DataMapper, Packetc, Index, accColsC, 0, ColMajor>(tRes, res, row + iter*accCols, col); \
+    bscalec<Packet,4>(accReal##iter, accImag##iter, pAlphaReal, pAlphaImag, taccReal, taccImag); \
+    bcouple<Packet, Packetc>(taccReal, taccImag, tRes, acc0, acc1); \
+    res.template storePacketBlock<Packetc,4>(row + iter*accCols + 0, col, acc0); \
+    res.template storePacketBlock<Packetc,4>(row + iter*accCols + accColsC, col, acc1); \
+  }
+
+#define MICRO_COMPLEX_STORE MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_STORE_ONE)
+
+#define MICRO_COMPLEX_COL_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bload<DataMapper, Packetc, Index, accColsC, 0, ColMajor>(tRes, res, row + iter*accCols, col); \
+    bscalec<Packet,1>(accReal##iter, accImag##iter, pAlphaReal, pAlphaImag, taccReal, taccImag); \
+    bcouple<Packet, Packetc>(taccReal, taccImag, tRes, acc0, acc1); \
+    res.template storePacketBlock<Packetc,1>(row + iter*accCols + 0, col, acc0); \
+    res.template storePacketBlock<Packetc,1>(row + iter*accCols + accColsC, col, acc1); \
+  }
+
+#define MICRO_COMPLEX_COL_STORE MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_COL_STORE_ONE)
+
+template<int unroll_factor, typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_unrolled_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index& row,
+  Index col,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag)
+{
+  const Scalar* rhs_ptr_real = rhs_base;
+  const Scalar* rhs_ptr_imag;
+  if(!RhsIsReal) {
+    rhs_ptr_imag = rhs_base + accRows*strideB;
+  } else {
+    EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+  }
+  const Scalar* lhs_ptr_real0 = NULL, * lhs_ptr_imag0 = NULL, * lhs_ptr_real1 = NULL, * lhs_ptr_imag1 = NULL;
+  const Scalar* lhs_ptr_real2 = NULL, * lhs_ptr_imag2 = NULL, * lhs_ptr_real3 = NULL, * lhs_ptr_imag3 = NULL;
+  const Scalar* lhs_ptr_real4 = NULL, * lhs_ptr_imag4 = NULL;
+  PacketBlock<Packet,4> accReal0, accImag0, accReal1, accImag1;
+  PacketBlock<Packet,4> accReal2, accImag2, accReal3, accImag3;
+  PacketBlock<Packet,4> accReal4, accImag4;
+  PacketBlock<Packet,4> taccReal, taccImag;
+  PacketBlock<Packetc,4> acc0, acc1;
+  PacketBlock<Packetc,8> tRes;
+
+  MICRO_COMPLEX_SRC_PTR
+  MICRO_COMPLEX_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL_COMPLEX <= depth; k+= PEEL_COMPLEX)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr_real);
+    if(!RhsIsReal) {
+      EIGEN_POWER_PREFETCH(rhs_ptr_imag);
+    }
+    MICRO_COMPLEX_PREFETCH
+    MICRO_COMPLEX_ONE_PEEL4
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_COMPLEX_ONE4
+  }
+  MICRO_COMPLEX_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<int unroll_factor, typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_unrolled_col_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index& row,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag)
+{
+  const Scalar* rhs_ptr_real = rhs_base;
+  const Scalar* rhs_ptr_imag;
+  if(!RhsIsReal) {
+    rhs_ptr_imag = rhs_base + remaining_cols*strideB;
+  } else {
+    EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+  }
+  const Scalar* lhs_ptr_real0 = NULL, * lhs_ptr_imag0 = NULL, * lhs_ptr_real1 = NULL, * lhs_ptr_imag1 = NULL;
+  const Scalar* lhs_ptr_real2 = NULL, * lhs_ptr_imag2 = NULL, * lhs_ptr_real3 = NULL, * lhs_ptr_imag3 = NULL;
+  const Scalar* lhs_ptr_real4 = NULL, * lhs_ptr_imag4 = NULL;
+  PacketBlock<Packet,1> accReal0, accImag0, accReal1, accImag1;
+  PacketBlock<Packet,1> accReal2, accImag2, accReal3, accImag3;
+  PacketBlock<Packet,1> accReal4, accImag4;
+  PacketBlock<Packet,1> taccReal, taccImag;
+  PacketBlock<Packetc,1> acc0, acc1;
+  PacketBlock<Packetc,2> tRes;
+
+  MICRO_COMPLEX_SRC_PTR
+  MICRO_COMPLEX_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL_COMPLEX <= depth; k+= PEEL_COMPLEX)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr_real);
+    if(!RhsIsReal) {
+      EIGEN_POWER_PREFETCH(rhs_ptr_imag);
+    }
+    MICRO_COMPLEX_PREFETCH
+    MICRO_COMPLEX_ONE_PEEL1
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_COMPLEX_ONE1
+  }
+  MICRO_COMPLEX_COL_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_unrolled_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index& row,
+  Index rows,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag)
+{
+#define MAX_COMPLEX_UNROLL 3
+  while(row + MAX_COMPLEX_UNROLL*accCols <= rows) {
+    gemm_complex_unrolled_col_iteration<MAX_COMPLEX_UNROLL, Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_cols, pAlphaReal, pAlphaImag);
+  }
+  switch( (rows-row)/accCols ) {
+#if MAX_COMPLEX_UNROLL > 4
+   case 4:
+     gemm_complex_unrolled_col_iteration<4, Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_cols, pAlphaReal, pAlphaImag);
+     break;
+#endif
+#if MAX_COMPLEX_UNROLL > 3
+   case 3:
+     gemm_complex_unrolled_col_iteration<3, Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_cols, pAlphaReal, pAlphaImag);
+     break;
+#endif
+#if MAX_COMPLEX_UNROLL > 2
+   case 2:
+     gemm_complex_unrolled_col_iteration<2, Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_cols, pAlphaReal, pAlphaImag);
+     break;
+#endif
+#if MAX_COMPLEX_UNROLL > 1
+   case 1:
+     gemm_complex_unrolled_col_iteration<1, Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_cols, pAlphaReal, pAlphaImag);
+     break;
+#endif
+   default:
+     break;
+  }
+#undef MAX_COMPLEX_UNROLL
+}
+
+template<typename LhsScalar, typename RhsScalar, typename Scalarc, typename Scalar, typename Index, typename Packet, typename Packetc, typename RhsPacket, typename DataMapper, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex(const DataMapper& res, const LhsScalar* blockAc, const RhsScalar* blockBc, Index rows, Index depth, Index cols, Scalarc alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
+{
+      const Index remaining_rows = rows % accCols;
+      const Index remaining_cols = cols % accRows;
+
+      if( strideA == -1 ) strideA = depth;
+      if( strideB == -1 ) strideB = depth;
+
+      const Packet pAlphaReal = pset1<Packet>(alpha.real());
+      const Packet pAlphaImag = pset1<Packet>(alpha.imag());
+      const Packet pMask = bmask<Packet>((const int)(remaining_rows));
+
+      const Scalar* blockA = (Scalar *) blockAc;
+      const Scalar* blockB = (Scalar *) blockBc;
+
+      Index col = 0;
+      for(; col + accRows <= cols; col += accRows)
+      {
+        const Scalar* rhs_base = blockB + advanceCols*col*strideB + accRows*offsetB;
+        const Scalar* lhs_base = blockA;
+        Index row = 0;
+
+#define MAX_COMPLEX_UNROLL 3
+        while(row + MAX_COMPLEX_UNROLL*accCols <= rows) {
+          gemm_complex_unrolled_iteration<MAX_COMPLEX_UNROLL, Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+        }
+        switch( (rows-row)/accCols ) {
+#if MAX_COMPLEX_UNROLL > 4
+          case 4:
+            gemm_complex_unrolled_iteration<4, Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_UNROLL > 3
+          case 3:
+            gemm_complex_unrolled_iteration<3, Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_UNROLL > 2
+          case 2:
+            gemm_complex_unrolled_iteration<2, Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_UNROLL > 1
+          case 1:
+            gemm_complex_unrolled_iteration<1, Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+          default:
+            break;
+        }
+#undef MAX_COMPLEX_UNROLL
+
+        if(remaining_rows > 0)
+        {
+          gemm_complex_extra_row<Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, rows, cols, remaining_rows, pAlphaReal, pAlphaImag, pMask);
+        }
+      }
+
+      if(remaining_cols > 0)
+      {
+        const Scalar* rhs_base = blockB + advanceCols*col*strideB + remaining_cols*offsetB;
+        const Scalar* lhs_base = blockA;
+
+        for(; col < cols; col++)
+        {
+          Index row = 0;
+
+          gemm_complex_unrolled_col<Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, rows, col, remaining_cols, pAlphaReal, pAlphaImag);
+
+          if (remaining_rows > 0)
+          {
+            gemm_complex_extra_col<Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_rows, remaining_cols, pAlphaReal, pAlphaImag);
+          }
+          rhs_base++;
+        }
+      }
+}
+
+#undef accColsC
+#undef advanceCols
+#undef advanceRows
+
+/************************************
+ * ppc64le template specializations *
+ * **********************************/
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<double, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(double* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<double, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+  ::operator()(double* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+    dhs_pack<double, Index, DataMapper, Packet2d, ColMajor, PanelMode, true> pack;
+    pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<double, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(double* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<double, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+  ::operator()(double* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+    dhs_pack<double, Index, DataMapper, Packet2d, RowMajor, PanelMode, true> pack;
+    pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+#if EIGEN_ALTIVEC_USE_CUSTOM_PACK
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<double, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(double* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<double, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(double* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_pack<double, Index, DataMapper, Packet2d, ColMajor, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<double, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(double* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<double, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+  ::operator()(double* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_pack<double, Index, DataMapper, Packet2d, RowMajor, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+#endif
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<float, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(float* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<float, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+  ::operator()(float* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_pack<float, Index, DataMapper, Packet4f, RowMajor, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<float, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(float* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<float, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+  ::operator()(float* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_pack<float, Index, DataMapper, Packet4f, ColMajor, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<std::complex<float>, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<float>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<std::complex<float>, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<float>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_cpack<float, Index, DataMapper, Packet4f, Packet2cf, RowMajor, Conjugate, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<std::complex<float>, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<float>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<std::complex<float>, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<float>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_cpack<float, Index, DataMapper, Packet4f, Packet2cf, ColMajor, Conjugate, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+#if EIGEN_ALTIVEC_USE_CUSTOM_PACK
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<float, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(float* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<float, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(float* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_pack<float, Index, DataMapper, Packet4f, ColMajor, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<float, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(float* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<float, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+  ::operator()(float* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_pack<float, Index, DataMapper, Packet4f, RowMajor, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+#endif
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<std::complex<float>, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<float>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<std::complex<float>, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<float>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_cpack<float, Index, DataMapper, Packet4f, Packet2cf, ColMajor, Conjugate, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<std::complex<float>, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<float>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<std::complex<float>, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<float>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_cpack<float, Index, DataMapper, Packet4f, Packet2cf, RowMajor, Conjugate, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<std::complex<double>, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<double>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<std::complex<double>, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<double>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_cpack<double, Index, DataMapper, Packet2d, Packet1cd, RowMajor, Conjugate, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<std::complex<double>, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<double>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+void gemm_pack_lhs<std::complex<double>, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<double>* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  dhs_cpack<double, Index, DataMapper, Packet2d, Packet1cd, ColMajor, Conjugate, PanelMode, true> pack;
+  pack(blockA, lhs, depth, rows, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<std::complex<double>, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<double>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<std::complex<double>, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<double>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_cpack<double, Index, DataMapper, Packet2d, Packet1cd, ColMajor, Conjugate, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<std::complex<double>, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  void operator()(std::complex<double>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+void gemm_pack_rhs<std::complex<double>, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+  ::operator()(std::complex<double>* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  dhs_cpack<double, Index, DataMapper, Packet2d, Packet1cd, RowMajor, Conjugate, PanelMode, false> pack;
+  pack(blockB, rhs, depth, cols, stride, offset);
+}
+
+// ********* gebp specializations *********
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<float, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef typename quad_traits<float>::vectortype   Packet;
+  typedef typename quad_traits<float>::rhstype      RhsPacket;
+
+  void operator()(const DataMapper& res, const float* blockA, const float* blockB,
+                  Index rows, Index depth, Index cols, float alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<float, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const float* blockA, const float* blockB,
+               Index rows, Index depth, Index cols, float alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<float>::rows;
+    const Index accCols = quad_traits<float>::size;
+    void (*gemm_function)(const DataMapper&, const float*, const float*, Index, Index, Index, float, Index, Index, Index, Index);
+
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+      //generate with MMA only
+      gemm_function = &Eigen::internal::gemmMMA<float, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+    #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+      if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+        gemm_function = &Eigen::internal::gemmMMA<float, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+      }
+      else{
+        gemm_function = &Eigen::internal::gemm<float, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+      }
+    #else
+      gemm_function = &Eigen::internal::gemm<float, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+    #endif
+      gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<std::complex<float>, std::complex<float>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef Packet4f   Packet;
+  typedef Packet2cf  Packetc;
+  typedef Packet4f   RhsPacket;
+
+  void operator()(const DataMapper& res, const std::complex<float>* blockA, const std::complex<float>* blockB,
+                  Index rows, Index depth, Index cols, std::complex<float> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<std::complex<float>, std::complex<float>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const std::complex<float>* blockA, const std::complex<float>* blockB,
+               Index rows, Index depth, Index cols, std::complex<float> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<float>::rows;
+    const Index accCols = quad_traits<float>::size;
+    void (*gemm_function)(const DataMapper&, const std::complex<float>*, const std::complex<float>*,
+          Index, Index, Index, std::complex<float>, Index, Index, Index, Index);
+
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<float>, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<float>, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<std::complex<float>, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<std::complex<float>, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+     #endif
+      gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<float, std::complex<float>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef Packet4f   Packet;
+  typedef Packet2cf  Packetc;
+  typedef Packet4f   RhsPacket;
+
+  void operator()(const DataMapper& res, const float* blockA, const std::complex<float>* blockB,
+                  Index rows, Index depth, Index cols, std::complex<float> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<float, std::complex<float>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const float* blockA, const std::complex<float>* blockB,
+               Index rows, Index depth, Index cols, std::complex<float> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<float>::rows;
+    const Index accCols = quad_traits<float>::size;
+    void (*gemm_function)(const DataMapper&, const float*, const std::complex<float>*,
+          Index, Index, Index, std::complex<float>, Index, Index, Index, Index);
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<float, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<float, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<float, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<float, std::complex<float>, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+     #endif
+       gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<std::complex<float>, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef Packet4f   Packet;
+  typedef Packet2cf  Packetc;
+  typedef Packet4f   RhsPacket;
+
+  void operator()(const DataMapper& res, const std::complex<float>* blockA, const float* blockB,
+                  Index rows, Index depth, Index cols, std::complex<float> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<std::complex<float>, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const std::complex<float>* blockA, const float* blockB,
+               Index rows, Index depth, Index cols, std::complex<float> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<float>::rows;
+    const Index accCols = quad_traits<float>::size;
+    void (*gemm_function)(const DataMapper&, const std::complex<float>*, const float*,
+          Index, Index, Index, std::complex<float>, Index, Index, Index, Index);
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<float>, float, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<float>, float, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<std::complex<float>, float, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<std::complex<float>, float, std::complex<float>, float, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+     #endif
+       gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<double, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef typename quad_traits<double>::vectortype  Packet;
+  typedef typename quad_traits<double>::rhstype     RhsPacket;
+
+  void operator()(const DataMapper& res, const double* blockA, const double* blockB,
+                  Index rows, Index depth, Index cols, double alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<double, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const double* blockA, const double* blockB,
+               Index rows, Index depth, Index cols, double alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<double>::rows;
+    const Index accCols = quad_traits<double>::size;
+    void (*gemm_function)(const DataMapper&, const double*, const double*, Index, Index, Index, double, Index, Index, Index, Index);
+
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+      //generate with MMA only
+      gemm_function = &Eigen::internal::gemmMMA<double, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+    #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+      if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+        gemm_function = &Eigen::internal::gemmMMA<double, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+      }
+      else{
+        gemm_function = &Eigen::internal::gemm<double, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+      }
+    #else
+      gemm_function = &Eigen::internal::gemm<double, Index, Packet, RhsPacket, DataMapper, accRows, accCols>;
+    #endif
+      gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<std::complex<double>, std::complex<double>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef quad_traits<double>::vectortype   Packet;
+  typedef Packet1cd  Packetc;
+  typedef quad_traits<double>::rhstype   RhsPacket;
+
+  void operator()(const DataMapper& res, const std::complex<double>* blockA, const std::complex<double>* blockB,
+                  Index rows, Index depth, Index cols, std::complex<double> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<std::complex<double>, std::complex<double>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const std::complex<double>* blockA, const std::complex<double>* blockB,
+               Index rows, Index depth, Index cols, std::complex<double> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<double>::rows;
+    const Index accCols = quad_traits<double>::size;
+    void (*gemm_function)(const DataMapper&, const std::complex<double>*, const std::complex<double>*,
+          Index, Index, Index, std::complex<double>, Index, Index, Index, Index);
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<double>, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<double>, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<std::complex<double>, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<std::complex<double>, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, false>;
+     #endif
+       gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<std::complex<double>, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef quad_traits<double>::vectortype   Packet;
+  typedef Packet1cd  Packetc;
+  typedef quad_traits<double>::rhstype   RhsPacket;
+
+  void operator()(const DataMapper& res, const std::complex<double>* blockA, const double* blockB,
+                  Index rows, Index depth, Index cols, std::complex<double> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<std::complex<double>, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const std::complex<double>* blockA, const double* blockB,
+               Index rows, Index depth, Index cols, std::complex<double> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<double>::rows;
+    const Index accCols = quad_traits<double>::size;
+    void (*gemm_function)(const DataMapper&, const std::complex<double>*, const double*,
+          Index, Index, Index, std::complex<double>, Index, Index, Index, Index);
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<double>, double, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<std::complex<double>, double, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<std::complex<double>, double, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<std::complex<double>, double, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, false, true>;
+     #endif
+       gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<double, std::complex<double>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+{
+  typedef quad_traits<double>::vectortype   Packet;
+  typedef Packet1cd  Packetc;
+  typedef quad_traits<double>::rhstype   RhsPacket;
+
+  void operator()(const DataMapper& res, const double* blockA, const std::complex<double>* blockB,
+                  Index rows, Index depth, Index cols, std::complex<double> alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+void gebp_kernel<double, std::complex<double>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>
+  ::operator()(const DataMapper& res, const double* blockA, const std::complex<double>* blockB,
+               Index rows, Index depth, Index cols, std::complex<double> alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    const Index accRows = quad_traits<double>::rows;
+    const Index accCols = quad_traits<double>::size;
+    void (*gemm_function)(const DataMapper&, const double*, const std::complex<double>*,
+          Index, Index, Index, std::complex<double>, Index, Index, Index, Index);
+    #ifdef EIGEN_ALTIVEC_MMA_ONLY
+       //generate with MMA only
+       gemm_function = &Eigen::internal::gemm_complexMMA<double, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+     #elif defined(ALTIVEC_MMA_SUPPORT) && !defined(EIGEN_ALTIVEC_DISABLE_MMA)
+       if (__builtin_cpu_supports ("arch_3_1") && __builtin_cpu_supports ("mma")){
+         gemm_function = &Eigen::internal::gemm_complexMMA<double, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+       }
+       else{
+         gemm_function = &Eigen::internal::gemm_complex<double, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+       }
+     #else
+       gemm_function = &Eigen::internal::gemm_complex<double, std::complex<double>, std::complex<double>, double, Index, Packet, Packetc, RhsPacket, DataMapper, accRows, accCols, ConjugateLhs, ConjugateRhs, true, false>;
+     #endif
+       gemm_function(res, blockA, blockB, rows, depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIX_PRODUCT_ALTIVEC_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
new file mode 100644
index 00000000..33d54349
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
@@ -0,0 +1,221 @@
+//#define EIGEN_POWER_USE_PREFETCH  // Use prefetching in gemm routines
+#ifdef EIGEN_POWER_USE_PREFETCH
+#define EIGEN_POWER_PREFETCH(p)  prefetch(p)
+#else
+#define EIGEN_POWER_PREFETCH(p)
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accRows>
+EIGEN_STRONG_INLINE void gemm_extra_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index row,
+  Index col,
+  Index remaining_rows,
+  Index remaining_cols,
+  const Packet& pAlpha);
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accRows, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_extra_row(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index row,
+  Index col,
+  Index rows,
+  Index cols,
+  Index remaining_rows,
+  const Packet& pAlpha,
+  const Packet& pMask);
+
+template<typename Scalar, typename Packet, typename DataMapper, typename Index, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_unrolled_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index& row,
+  Index rows,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlpha);
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE Packet bmask(const int remaining_rows);
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_extra_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index row,
+  Index col,
+  Index remaining_rows,
+  Index remaining_cols,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag);
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_extra_row(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index row,
+  Index col,
+  Index rows,
+  Index cols,
+  Index remaining_rows,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag,
+  const Packet& pMask);
+
+template<typename Scalar, typename Packet, typename Packetc, typename DataMapper, typename Index, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_unrolled_col(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index& row,
+  Index rows,
+  Index col,
+  Index remaining_cols,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag);
+
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE Packet ploadLhs(const Scalar* lhs);
+
+template<typename DataMapper, typename Packet, typename Index, const Index accCols, int N, int StorageOrder>
+EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet,4>& acc, const DataMapper& res, Index row, Index col);
+
+template<typename DataMapper, typename Packet, typename Index, const Index accCols, int N, int StorageOrder>
+EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet,8>& acc, const DataMapper& res, Index row, Index col);
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void bscale(PacketBlock<Packet,4>& acc, PacketBlock<Packet,4>& accZ, const Packet& pAlpha);
+
+template<typename Packet, int N>
+EIGEN_ALWAYS_INLINE void bscalec(PacketBlock<Packet,N>& aReal, PacketBlock<Packet,N>& aImag, const Packet& bReal, const Packet& bImag, PacketBlock<Packet,N>& cReal, PacketBlock<Packet,N>& cImag);
+
+const static Packet16uc p16uc_SETCOMPLEX32_FIRST = {  0,  1,  2,  3,
+                                                     16, 17, 18, 19,
+                                                      4,  5,  6,  7,
+                                                     20, 21, 22, 23};
+
+const static Packet16uc p16uc_SETCOMPLEX32_SECOND = {  8,  9, 10, 11,
+                                                      24, 25, 26, 27,
+                                                      12, 13, 14, 15,
+                                                      28, 29, 30, 31};
+//[a,b],[ai,bi] = [a,ai] - This is equivalent to p16uc_GETREAL64
+const static Packet16uc p16uc_SETCOMPLEX64_FIRST = {  0,  1,  2,  3,  4,  5,  6,  7,
+                                                     16, 17, 18, 19, 20, 21, 22, 23};
+
+//[a,b],[ai,bi] = [b,bi] - This is equivalent to p16uc_GETIMAG64
+const static Packet16uc p16uc_SETCOMPLEX64_SECOND = {  8,  9, 10, 11, 12, 13, 14, 15,
+                                                      24, 25, 26, 27, 28, 29, 30, 31};
+
+
+// Grab two decouples real/imaginary PacketBlocks and return two coupled (real/imaginary pairs) PacketBlocks.
+template<typename Packet, typename Packetc>
+EIGEN_ALWAYS_INLINE void bcouple_common(PacketBlock<Packet,4>& taccReal, PacketBlock<Packet,4>& taccImag, PacketBlock<Packetc, 4>& acc1, PacketBlock<Packetc, 4>& acc2)
+{
+  acc1.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX32_FIRST);
+  acc1.packet[1].v = vec_perm(taccReal.packet[1], taccImag.packet[1], p16uc_SETCOMPLEX32_FIRST);
+  acc1.packet[2].v = vec_perm(taccReal.packet[2], taccImag.packet[2], p16uc_SETCOMPLEX32_FIRST);
+  acc1.packet[3].v = vec_perm(taccReal.packet[3], taccImag.packet[3], p16uc_SETCOMPLEX32_FIRST);
+
+  acc2.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX32_SECOND);
+  acc2.packet[1].v = vec_perm(taccReal.packet[1], taccImag.packet[1], p16uc_SETCOMPLEX32_SECOND);
+  acc2.packet[2].v = vec_perm(taccReal.packet[2], taccImag.packet[2], p16uc_SETCOMPLEX32_SECOND);
+  acc2.packet[3].v = vec_perm(taccReal.packet[3], taccImag.packet[3], p16uc_SETCOMPLEX32_SECOND);
+}
+
+template<typename Packet, typename Packetc>
+EIGEN_ALWAYS_INLINE void bcouple(PacketBlock<Packet,4>& taccReal, PacketBlock<Packet,4>& taccImag, PacketBlock<Packetc,8>& tRes, PacketBlock<Packetc, 4>& acc1, PacketBlock<Packetc, 4>& acc2)
+{
+  bcouple_common<Packet, Packetc>(taccReal, taccImag, acc1, acc2);
+
+  acc1.packet[0] = padd<Packetc>(tRes.packet[0], acc1.packet[0]);
+  acc1.packet[1] = padd<Packetc>(tRes.packet[1], acc1.packet[1]);
+  acc1.packet[2] = padd<Packetc>(tRes.packet[2], acc1.packet[2]);
+  acc1.packet[3] = padd<Packetc>(tRes.packet[3], acc1.packet[3]);
+
+  acc2.packet[0] = padd<Packetc>(tRes.packet[4], acc2.packet[0]);
+  acc2.packet[1] = padd<Packetc>(tRes.packet[5], acc2.packet[1]);
+  acc2.packet[2] = padd<Packetc>(tRes.packet[6], acc2.packet[2]);
+  acc2.packet[3] = padd<Packetc>(tRes.packet[7], acc2.packet[3]);
+}
+
+template<typename Packet, typename Packetc>
+EIGEN_ALWAYS_INLINE void bcouple_common(PacketBlock<Packet,1>& taccReal, PacketBlock<Packet,1>& taccImag, PacketBlock<Packetc, 1>& acc1, PacketBlock<Packetc, 1>& acc2)
+{
+  acc1.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX32_FIRST);
+
+  acc2.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX32_SECOND);
+}
+
+template<typename Packet, typename Packetc>
+EIGEN_ALWAYS_INLINE void bcouple(PacketBlock<Packet,1>& taccReal, PacketBlock<Packet,1>& taccImag, PacketBlock<Packetc,2>& tRes, PacketBlock<Packetc, 1>& acc1, PacketBlock<Packetc, 1>& acc2)
+{
+  bcouple_common<Packet, Packetc>(taccReal, taccImag, acc1, acc2);
+
+  acc1.packet[0] = padd<Packetc>(tRes.packet[0], acc1.packet[0]);
+
+  acc2.packet[0] = padd<Packetc>(tRes.packet[1], acc2.packet[0]);
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void bcouple_common<Packet2d, Packet1cd>(PacketBlock<Packet2d,4>& taccReal, PacketBlock<Packet2d,4>& taccImag, PacketBlock<Packet1cd, 4>& acc1, PacketBlock<Packet1cd, 4>& acc2)
+{
+  acc1.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX64_FIRST);
+  acc1.packet[1].v = vec_perm(taccReal.packet[1], taccImag.packet[1], p16uc_SETCOMPLEX64_FIRST);
+  acc1.packet[2].v = vec_perm(taccReal.packet[2], taccImag.packet[2], p16uc_SETCOMPLEX64_FIRST);
+  acc1.packet[3].v = vec_perm(taccReal.packet[3], taccImag.packet[3], p16uc_SETCOMPLEX64_FIRST);
+
+  acc2.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX64_SECOND);
+  acc2.packet[1].v = vec_perm(taccReal.packet[1], taccImag.packet[1], p16uc_SETCOMPLEX64_SECOND);
+  acc2.packet[2].v = vec_perm(taccReal.packet[2], taccImag.packet[2], p16uc_SETCOMPLEX64_SECOND);
+  acc2.packet[3].v = vec_perm(taccReal.packet[3], taccImag.packet[3], p16uc_SETCOMPLEX64_SECOND);
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void bcouple_common<Packet2d, Packet1cd>(PacketBlock<Packet2d,1>& taccReal, PacketBlock<Packet2d,1>& taccImag, PacketBlock<Packet1cd, 1>& acc1, PacketBlock<Packet1cd, 1>& acc2)
+{
+  acc1.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX64_FIRST);
+
+  acc2.packet[0].v = vec_perm(taccReal.packet[0], taccImag.packet[0], p16uc_SETCOMPLEX64_SECOND);
+}
+
+// This is necessary because ploadRhs for double returns a pair of vectors when MMA is enabled.
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE Packet ploadRhs(const Scalar* rhs)
+{
+  return ploadu<Packet>(rhs);
+}
+
+} // end namespace internal
+} // end namespace Eigen
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
new file mode 100644
index 00000000..6540c6fa
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
@@ -0,0 +1,629 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020 Everton Constantino (everton.constantino@ibm.com)
+// Copyright (C) 2021 Chip Kerchner (chip.kerchner@ibm.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
+#define EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
+
+#pragma GCC target("cpu=power10")
+
+#ifdef __has_builtin
+#if !__has_builtin(__builtin_vsx_assemble_pair)
+#define __builtin_vsx_assemble_pair __builtin_mma_assemble_pair
+#endif
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE void bsetzeroMMA(__vector_quad* acc)
+{
+  __builtin_mma_xxsetaccz(acc);
+}
+
+template<typename DataMapper, typename Index, typename Packet, const Index accCols>
+EIGEN_ALWAYS_INLINE void storeAccumulator(Index i, Index j, const DataMapper& data, const Packet& alpha, __vector_quad* acc)
+{
+  PacketBlock<Packet, 4> result;
+  __builtin_mma_disassemble_acc(&result.packet, acc);
+
+  PacketBlock<Packet, 4> tRes;
+  bload<DataMapper, Packet, Index, accCols, 0, ColMajor>(tRes, data, i, j);
+
+  bscale<Packet>(tRes, result, alpha);
+
+  data.template storePacketBlock<Packet, 4>(i, j, tRes);
+}
+
+template<typename DataMapper, typename Index, typename Packet, typename Packetc, const Index accColsC, int N>
+EIGEN_ALWAYS_INLINE void storeComplexAccumulator(Index i, Index j, const DataMapper& data, const Packet& alphaReal, const Packet& alphaImag, __vector_quad* accReal, __vector_quad* accImag)
+{
+  PacketBlock<Packet, 4> resultReal, resultImag;
+  __builtin_mma_disassemble_acc(&resultReal.packet, accReal);
+  __builtin_mma_disassemble_acc(&resultImag.packet, accImag);
+
+  PacketBlock<Packetc, 8> tRes;
+  bload<DataMapper, Packetc, Index, accColsC, N, ColMajor>(tRes, data, i, j);
+
+  PacketBlock<Packet,4> taccReal, taccImag;
+  bscalec<Packet,4>(resultReal, resultImag, alphaReal, alphaImag, taccReal, taccImag);
+
+  PacketBlock<Packetc, 4> acc1, acc2;
+  bcouple<Packet, Packetc>(taccReal, taccImag, tRes, acc1, acc2);
+
+  data.template storePacketBlock<Packetc, 4>(i + N*accColsC, j, acc1);
+  data.template storePacketBlock<Packetc, 4>(i + (N+1)*accColsC, j, acc2);
+}
+
+// Defaults to float32, since Eigen still supports C++03 we can't use default template arguments
+template<typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pgerMMA(__vector_quad* acc, const RhsPacket& a, const LhsPacket& b)
+{
+  if(NegativeAccumulate)
+  {
+    __builtin_mma_xvf32gernp(acc, (__vector unsigned char)a, (__vector unsigned char)b);
+  } else {
+    __builtin_mma_xvf32gerpp(acc, (__vector unsigned char)a, (__vector unsigned char)b);
+  }
+}
+
+template<typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pgerMMA(__vector_quad* acc, const PacketBlock<Packet2d,2>& a, const Packet2d& b)
+{
+  __vector_pair* a0 = (__vector_pair *)(&a.packet[0]);
+  if(NegativeAccumulate)
+  {
+    __builtin_mma_xvf64gernp(acc, *a0, (__vector unsigned char)b);
+  } else {
+    __builtin_mma_xvf64gerpp(acc, *a0, (__vector unsigned char)b);
+  }
+}
+
+template<typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pgerMMA(__vector_quad* acc, const __vector_pair& a, const Packet2d& b)
+{
+  if(NegativeAccumulate)
+  {
+    __builtin_mma_xvf64gernp(acc, (__vector_pair)a, (__vector unsigned char)b);
+  } else {
+    __builtin_mma_xvf64gerpp(acc, (__vector_pair)a, (__vector unsigned char)b);
+  }
+}
+
+template<typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
+EIGEN_ALWAYS_INLINE void pgerMMA(__vector_quad*, const __vector_pair&, const Packet4f&)
+{
+  // Just for compilation
+}
+
+template<typename Scalar, typename Packet, typename RhsPacket, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_ALWAYS_INLINE void pgercMMA(__vector_quad* accReal, __vector_quad* accImag, const Packet& lhsV, const Packet& lhsVi, const RhsPacket& rhsV, const RhsPacket& rhsVi)
+{
+  pgerMMA<Packet, RhsPacket, false>(accReal,  rhsV,  lhsV);
+  if(LhsIsReal) {
+    pgerMMA<Packet, RhsPacket, ConjugateRhs>(accImag, rhsVi,  lhsV);
+  } else {
+    if(!RhsIsReal) {
+      pgerMMA<Packet, RhsPacket, ConjugateLhs == ConjugateRhs>(accReal, rhsVi, lhsVi);
+      pgerMMA<Packet, RhsPacket, ConjugateRhs>(accImag, rhsVi,  lhsV);
+    } else {
+      EIGEN_UNUSED_VARIABLE(rhsVi);
+    }
+    pgerMMA<Packet, RhsPacket, ConjugateLhs>(accImag,  rhsV, lhsVi);
+  }
+}
+
+// This is necessary because ploadRhs for double returns a pair of vectors when MMA is enabled.
+template<typename Scalar, typename Packet>
+EIGEN_ALWAYS_INLINE void ploadRhsMMA(const Scalar* rhs, Packet& rhsV)
+{
+  rhsV = ploadRhs<Scalar, Packet>((const Scalar*)(rhs));
+} 
+
+template<>
+EIGEN_ALWAYS_INLINE void ploadRhsMMA<double, PacketBlock<Packet2d, 2> >(const double* rhs, PacketBlock<Packet2d, 2>& rhsV)
+{
+  rhsV.packet[0] = ploadRhs<double, Packet2d>((const double *)((Packet2d *)rhs      ));
+  rhsV.packet[1] = ploadRhs<double, Packet2d>((const double *)(((Packet2d *)rhs) + 1));
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void ploadRhsMMA<double, __vector_pair>(const double* rhs, __vector_pair& rhsV)
+{
+#if EIGEN_COMP_LLVM
+  __builtin_vsx_assemble_pair(&rhsV,
+    (__vector unsigned char)(ploadRhs<double, Packet2d>((const double *)(((Packet2d *)rhs) + 1))),
+    (__vector unsigned char)(ploadRhs<double, Packet2d>((const double *)((Packet2d *)rhs      ))));
+#else
+  __asm__ ("lxvp %x0,%1" : "=wa" (rhsV) : "Y" (*rhs));
+#endif
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void ploadRhsMMA(const float*, __vector_pair&)
+{
+  // Just for compilation
+}
+
+// PEEL_MMA loop factor.
+#define PEEL_MMA 7
+
+#define MICRO_MMA_UNROLL(func) \
+  func(0) func(1) func(2) func(3) func(4) func(5) func(6) func(7)
+
+#define MICRO_MMA_LOAD_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhsV##iter = ploadLhs<Scalar, Packet>(lhs_ptr##iter); \
+    lhs_ptr##iter += accCols; \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhsV##iter); \
+  }
+
+#define MICRO_MMA_WORK_ONE(iter, type, peel) \
+  if (unroll_factor > iter) { \
+    pgerMMA<Packet, type, false>(&accZero##iter, rhsV##peel, lhsV##iter); \
+  }
+
+#define MICRO_MMA_TYPE_PEEL(func, func2, type, peel) \
+  if (PEEL_MMA > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4, lhsV5, lhsV6, lhsV7; \
+    ploadRhsMMA<Scalar, type>(rhs_ptr + (accRows * peel), rhsV##peel); \
+    MICRO_MMA_UNROLL(func2); \
+    func(0,type,peel) func(1,type,peel) func(2,type,peel) func(3,type,peel) \
+    func(4,type,peel) func(5,type,peel) func(6,type,peel) func(7,type,peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+  }
+
+#define MICRO_MMA_UNROLL_TYPE_PEEL(func, func2, type) \
+  type rhsV0, rhsV1, rhsV2, rhsV3, rhsV4, rhsV5, rhsV6, rhsV7, rhsV8, rhsV9; \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,0); MICRO_MMA_TYPE_PEEL(func,func2,type,1); \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,2); MICRO_MMA_TYPE_PEEL(func,func2,type,3); \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,4); MICRO_MMA_TYPE_PEEL(func,func2,type,5); \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,6); MICRO_MMA_TYPE_PEEL(func,func2,type,7); \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,8); MICRO_MMA_TYPE_PEEL(func,func2,type,9);
+
+#define MICRO_MMA_UNROLL_TYPE_ONE(func, func2, type) \
+  type rhsV0; \
+  MICRO_MMA_TYPE_PEEL(func,func2,type,0);
+
+#define MICRO_MMA_ONE_PEEL \
+  if (sizeof(Scalar) == sizeof(float)) { \
+    MICRO_MMA_UNROLL_TYPE_PEEL(MICRO_MMA_WORK_ONE, MICRO_MMA_LOAD_ONE, RhsPacket); \
+  } else { \
+    MICRO_MMA_UNROLL_TYPE_PEEL(MICRO_MMA_WORK_ONE, MICRO_MMA_LOAD_ONE, __vector_pair); \
+  } \
+  rhs_ptr += (accRows * PEEL_MMA);
+
+#define MICRO_MMA_ONE \
+  if (sizeof(Scalar) == sizeof(float)) { \
+    MICRO_MMA_UNROLL_TYPE_ONE(MICRO_MMA_WORK_ONE, MICRO_MMA_LOAD_ONE, RhsPacket); \
+  } else { \
+    MICRO_MMA_UNROLL_TYPE_ONE(MICRO_MMA_WORK_ONE, MICRO_MMA_LOAD_ONE, __vector_pair); \
+  } \
+  rhs_ptr += accRows;
+
+#define MICRO_MMA_DST_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bsetzeroMMA<Scalar, Packet>(&accZero##iter); \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(accZero##iter); \
+  }
+
+#define MICRO_MMA_DST_PTR MICRO_MMA_UNROLL(MICRO_MMA_DST_PTR_ONE)
+
+#define MICRO_MMA_SRC_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhs_ptr##iter = lhs_base + ( (row/accCols) + iter )*strideA*accCols + accCols*offsetA; \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr##iter); \
+  }
+
+#define MICRO_MMA_SRC_PTR MICRO_MMA_UNROLL(MICRO_MMA_SRC_PTR_ONE)
+
+#define MICRO_MMA_PREFETCH_ONE(iter) \
+  if (unroll_factor > iter) { \
+    EIGEN_POWER_PREFETCH(lhs_ptr##iter); \
+  }
+
+#define MICRO_MMA_PREFETCH MICRO_MMA_UNROLL(MICRO_MMA_PREFETCH_ONE)
+
+#define MICRO_MMA_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    storeAccumulator<DataMapper, Index, Packet, accCols>(row + iter*accCols, col, res, pAlpha, &accZero##iter); \
+  }
+
+#define MICRO_MMA_STORE MICRO_MMA_UNROLL(MICRO_MMA_STORE_ONE)
+
+template<int unroll_factor, typename Scalar, typename Packet, typename RhsPacket, typename DataMapper, typename Index, const Index accRows, const Index accCols>
+EIGEN_STRONG_INLINE void gemm_unrolled_MMA_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index& row,
+  Index col,
+  const Packet& pAlpha)
+{
+  const Scalar* rhs_ptr = rhs_base;
+  const Scalar* lhs_ptr0 = NULL, * lhs_ptr1 = NULL, * lhs_ptr2 = NULL, * lhs_ptr3 = NULL, * lhs_ptr4 = NULL, * lhs_ptr5 = NULL, * lhs_ptr6 = NULL, * lhs_ptr7 = NULL;
+  __vector_quad accZero0, accZero1, accZero2, accZero3, accZero4, accZero5, accZero6, accZero7;
+
+  MICRO_MMA_SRC_PTR
+  MICRO_MMA_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL_MMA <= depth; k+= PEEL_MMA)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr);
+    MICRO_MMA_PREFETCH
+    MICRO_MMA_ONE_PEEL
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_MMA_ONE
+  }
+  MICRO_MMA_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<typename Scalar, typename Index, typename Packet, typename RhsPacket, typename DataMapper, const Index accRows, const Index accCols>
+void gemmMMA(const DataMapper& res, const Scalar* blockA, const Scalar* blockB, Index rows, Index depth, Index cols, Scalar alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
+{
+      const Index remaining_rows = rows % accCols;
+      const Index remaining_cols = cols % accRows;
+
+      if( strideA == -1 ) strideA = depth;
+      if( strideB == -1 ) strideB = depth;
+
+      const Packet pAlpha = pset1<Packet>(alpha);
+      const Packet pMask  = bmask<Packet>((const int)(remaining_rows));
+
+      Index col = 0;
+      for(; col + accRows <= cols; col += accRows)
+      {
+        const Scalar* rhs_base = blockB + col*strideB + accRows*offsetB;
+        const Scalar* lhs_base = blockA;
+
+        Index row = 0;
+#define MAX_MMA_UNROLL 7
+        while(row + MAX_MMA_UNROLL*accCols <= rows) {
+          gemm_unrolled_MMA_iteration<MAX_MMA_UNROLL, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+        }
+        switch( (rows-row)/accCols ) {
+#if MAX_MMA_UNROLL > 7
+          case 7:
+            gemm_unrolled_MMA_iteration<7, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 6
+          case 6:
+            gemm_unrolled_MMA_iteration<6, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 5
+          case 5:
+            gemm_unrolled_MMA_iteration<5, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 4
+          case 4:
+            gemm_unrolled_MMA_iteration<4, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 3
+          case 3:
+            gemm_unrolled_MMA_iteration<3, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 2
+          case 2:
+            gemm_unrolled_MMA_iteration<2, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+#if MAX_MMA_UNROLL > 1
+          case 1:
+            gemm_unrolled_MMA_iteration<1, Scalar, Packet, RhsPacket, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, pAlpha);
+            break;
+#endif
+          default:
+            break;
+        }
+#undef MAX_MMA_UNROLL
+
+        if(remaining_rows > 0)
+        {
+          gemm_extra_row<Scalar, Packet, DataMapper, Index, accRows, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, rows, cols, remaining_rows, pAlpha, pMask);
+        }
+      }
+
+      if(remaining_cols > 0)
+      {
+        const Scalar* rhs_base = blockB + col*strideB + remaining_cols*offsetB;
+        const Scalar* lhs_base = blockA;
+
+        for(; col < cols; col++)
+        {
+          Index row = 0;
+
+          gemm_unrolled_col<Scalar, Packet, DataMapper, Index, accCols>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, rows, col, remaining_cols, pAlpha);
+
+          if (remaining_rows > 0)
+          {
+            gemm_extra_col<Scalar, Packet, DataMapper, Index, accRows>(res, lhs_base, rhs_base, depth, strideA, offsetA, row, col, remaining_rows, remaining_cols, pAlpha);
+          }
+          rhs_base++;
+        }
+      }
+}
+
+#define accColsC (accCols / 2)
+#define advanceRows ((LhsIsReal) ? 1 : 2)
+#define advanceCols ((RhsIsReal) ? 1 : 2)
+
+// PEEL_COMPLEX_MMA loop factor.
+#define PEEL_COMPLEX_MMA 7
+
+#define MICRO_COMPLEX_MMA_UNROLL(func) \
+  func(0) func(1) func(2) func(3) func(4)
+
+#define MICRO_COMPLEX_MMA_LOAD_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhsV##iter = ploadLhs<Scalar, Packet>(lhs_ptr_real##iter); \
+    lhs_ptr_real##iter += accCols; \
+    if(!LhsIsReal) { \
+      lhsVi##iter = ploadLhs<Scalar, Packet>(lhs_ptr_imag##iter); \
+      lhs_ptr_imag##iter += accCols; \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(lhsVi##iter); \
+    } \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhsV##iter); \
+    EIGEN_UNUSED_VARIABLE(lhsVi##iter); \
+  }
+
+#define MICRO_COMPLEX_MMA_WORK_ONE(iter, type, peel) \
+  if (unroll_factor > iter) { \
+    pgercMMA<Scalar, Packet, type, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(&accReal##iter, &accImag##iter, lhsV##iter, lhsVi##iter, rhsV##peel, rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_MMA_TYPE_PEEL(func, func2, type, peel) \
+  if (PEEL_COMPLEX_MMA > peel) { \
+    Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4; \
+    Packet lhsVi0, lhsVi1, lhsVi2, lhsVi3, lhsVi4; \
+    ploadRhsMMA<Scalar, type>(rhs_ptr_real + (accRows * peel), rhsV##peel); \
+    if(!RhsIsReal) { \
+      ploadRhsMMA<Scalar, type>(rhs_ptr_imag + (accRows * peel), rhsVi##peel); \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+    } \
+    MICRO_COMPLEX_MMA_UNROLL(func2); \
+    func(0,type,peel) func(1,type,peel) func(2,type,peel) func(3,type,peel) func(4,type,peel) \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(rhsV##peel); \
+    EIGEN_UNUSED_VARIABLE(rhsVi##peel); \
+  }
+
+#define MICRO_COMPLEX_MMA_UNROLL_TYPE_PEEL(func, func2, type) \
+  type rhsV0, rhsV1, rhsV2, rhsV3, rhsV4, rhsV5, rhsV6, rhsV7, rhsV8, rhsV9; \
+  type rhsVi0, rhsVi1, rhsVi2, rhsVi3, rhsVi4, rhsVi5, rhsVi6, rhsVi7, rhsVi8, rhsVi9; \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,0); MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,1); \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,2); MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,3); \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,4); MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,5); \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,6); MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,7); \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,8); MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,9);
+
+#define MICRO_COMPLEX_MMA_UNROLL_TYPE_ONE(func, func2, type) \
+  type rhsV0, rhsVi0; \
+  MICRO_COMPLEX_MMA_TYPE_PEEL(func,func2,type,0);
+
+#define MICRO_COMPLEX_MMA_ONE_PEEL \
+  if (sizeof(Scalar) == sizeof(float)) { \
+    MICRO_COMPLEX_MMA_UNROLL_TYPE_PEEL(MICRO_COMPLEX_MMA_WORK_ONE, MICRO_COMPLEX_MMA_LOAD_ONE, RhsPacket); \
+  } else { \
+    MICRO_COMPLEX_MMA_UNROLL_TYPE_PEEL(MICRO_COMPLEX_MMA_WORK_ONE, MICRO_COMPLEX_MMA_LOAD_ONE, __vector_pair); \
+  } \
+  rhs_ptr_real += (accRows * PEEL_COMPLEX_MMA); \
+  if(!RhsIsReal) rhs_ptr_imag += (accRows * PEEL_COMPLEX_MMA);
+
+#define MICRO_COMPLEX_MMA_ONE \
+  if (sizeof(Scalar) == sizeof(float)) { \
+    MICRO_COMPLEX_MMA_UNROLL_TYPE_ONE(MICRO_COMPLEX_MMA_WORK_ONE, MICRO_COMPLEX_MMA_LOAD_ONE, RhsPacket); \
+  } else { \
+    MICRO_COMPLEX_MMA_UNROLL_TYPE_ONE(MICRO_COMPLEX_MMA_WORK_ONE, MICRO_COMPLEX_MMA_LOAD_ONE, __vector_pair); \
+  } \
+  rhs_ptr_real += accRows; \
+  if(!RhsIsReal) rhs_ptr_imag += accRows;
+
+#define MICRO_COMPLEX_MMA_DST_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    bsetzeroMMA<Scalar, Packet>(&accReal##iter); \
+    bsetzeroMMA<Scalar, Packet>(&accImag##iter); \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(accReal##iter); \
+    EIGEN_UNUSED_VARIABLE(accImag##iter); \
+  }
+
+#define MICRO_COMPLEX_MMA_DST_PTR MICRO_COMPLEX_MMA_UNROLL(MICRO_COMPLEX_MMA_DST_PTR_ONE)
+
+#define MICRO_COMPLEX_MMA_SRC_PTR_ONE(iter) \
+  if (unroll_factor > iter) { \
+    lhs_ptr_real##iter = lhs_base + ( ((advanceRows*row)/accCols) + iter*advanceRows )*strideA*accCols + accCols*offsetA; \
+    if(!LhsIsReal) { \
+      lhs_ptr_imag##iter = lhs_ptr_real##iter + accCols*strideA; \
+    } else { \
+      EIGEN_UNUSED_VARIABLE(lhs_ptr_imag##iter); \
+    } \
+  } else { \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr_real##iter); \
+    EIGEN_UNUSED_VARIABLE(lhs_ptr_imag##iter); \
+  }
+
+#define MICRO_COMPLEX_MMA_SRC_PTR MICRO_COMPLEX_MMA_UNROLL(MICRO_COMPLEX_MMA_SRC_PTR_ONE)
+
+#define MICRO_COMPLEX_MMA_PREFETCH_ONE(iter) \
+  if (unroll_factor > iter) { \
+    EIGEN_POWER_PREFETCH(lhs_ptr_real##iter); \
+    if(!LhsIsReal) { \
+      EIGEN_POWER_PREFETCH(lhs_ptr_imag##iter); \
+    } \
+  }
+
+#define MICRO_COMPLEX_MMA_PREFETCH MICRO_COMPLEX_MMA_UNROLL(MICRO_COMPLEX_MMA_PREFETCH_ONE)
+
+#define MICRO_COMPLEX_MMA_STORE_ONE(iter) \
+  if (unroll_factor > iter) { \
+    storeComplexAccumulator<DataMapper, Index, Packet, Packetc, accColsC, 0>(row + iter*accCols, col, res, pAlphaReal, pAlphaImag, &accReal##iter, &accImag##iter); \
+  }
+
+#define MICRO_COMPLEX_MMA_STORE MICRO_COMPLEX_MMA_UNROLL(MICRO_COMPLEX_MMA_STORE_ONE)
+
+template<int unroll_factor, typename Scalar, typename Packet, typename Packetc, typename RhsPacket, typename DataMapper, typename Index, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+EIGEN_STRONG_INLINE void gemm_complex_unrolled_MMA_iteration(
+  const DataMapper& res,
+  const Scalar* lhs_base,
+  const Scalar* rhs_base,
+  Index depth,
+  Index strideA,
+  Index offsetA,
+  Index strideB,
+  Index& row,
+  Index col,
+  const Packet& pAlphaReal,
+  const Packet& pAlphaImag)
+{
+  const Scalar* rhs_ptr_real = rhs_base;
+  const Scalar* rhs_ptr_imag;
+  if(!RhsIsReal) {
+    rhs_ptr_imag = rhs_base + accRows*strideB;
+  } else {
+    EIGEN_UNUSED_VARIABLE(rhs_ptr_imag);
+  }
+  const Scalar* lhs_ptr_real0 = NULL, * lhs_ptr_imag0 = NULL, * lhs_ptr_real1 = NULL, * lhs_ptr_imag1 = NULL;
+  const Scalar* lhs_ptr_real2 = NULL, * lhs_ptr_imag2 = NULL, * lhs_ptr_real3 = NULL, * lhs_ptr_imag3 = NULL;
+  const Scalar* lhs_ptr_real4 = NULL, * lhs_ptr_imag4 = NULL;
+  __vector_quad accReal0, accImag0, accReal1, accImag1, accReal2, accImag2, accReal3, accImag3, accReal4, accImag4;
+
+  MICRO_COMPLEX_MMA_SRC_PTR
+  MICRO_COMPLEX_MMA_DST_PTR
+
+  Index k = 0;
+  for(; k + PEEL_COMPLEX_MMA <= depth; k+= PEEL_COMPLEX_MMA)
+  {
+    EIGEN_POWER_PREFETCH(rhs_ptr_real);
+    if(!RhsIsReal) {
+      EIGEN_POWER_PREFETCH(rhs_ptr_imag);
+    }
+    MICRO_COMPLEX_MMA_PREFETCH
+    MICRO_COMPLEX_MMA_ONE_PEEL
+  }
+  for(; k < depth; k++)
+  {
+    MICRO_COMPLEX_MMA_ONE
+  }
+  MICRO_COMPLEX_MMA_STORE
+
+  row += unroll_factor*accCols;
+}
+
+template<typename LhsScalar, typename RhsScalar, typename Scalarc, typename Scalar, typename Index, typename Packet, typename Packetc, typename RhsPacket, typename DataMapper, const Index accRows, const Index accCols, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
+void gemm_complexMMA(const DataMapper& res, const LhsScalar* blockAc, const RhsScalar* blockBc, Index rows, Index depth, Index cols, Scalarc alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
+{
+      const Index remaining_rows = rows % accCols;
+      const Index remaining_cols = cols % accRows;
+
+      if( strideA == -1 ) strideA = depth;
+      if( strideB == -1 ) strideB = depth;
+
+      const Packet pAlphaReal = pset1<Packet>(alpha.real());
+      const Packet pAlphaImag = pset1<Packet>(alpha.imag());
+      const Packet pMask = bmask<Packet>((const int)(remaining_rows));
+
+      const Scalar* blockA = (Scalar *) blockAc;
+      const Scalar* blockB = (Scalar *) blockBc;
+
+      Index col = 0;
+      for(; col + accRows <= cols; col += accRows)
+      {
+        const Scalar* rhs_base = blockB + advanceCols*col*strideB + accRows*offsetB;
+        const Scalar* lhs_base = blockA;
+        Index row = 0;
+
+#define MAX_COMPLEX_MMA_UNROLL 4
+        while(row + MAX_COMPLEX_MMA_UNROLL*accCols <= rows) {
+          gemm_complex_unrolled_MMA_iteration<MAX_COMPLEX_MMA_UNROLL, Scalar, Packet, Packetc, RhsPacket, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+        }
+        switch( (rows-row)/accCols ) {
+#if MAX_COMPLEX_MMA_UNROLL > 4
+          case 4:
+            gemm_complex_unrolled_MMA_iteration<4, Scalar, Packet, Packetc, RhsPacket, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_MMA_UNROLL > 3
+          case 3:
+            gemm_complex_unrolled_MMA_iteration<3, Scalar, Packet, Packetc, RhsPacket, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_MMA_UNROLL > 2
+          case 2:
+            gemm_complex_unrolled_MMA_iteration<2, Scalar, Packet, Packetc, RhsPacket, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+#if MAX_COMPLEX_MMA_UNROLL > 1
+          case 1:
+            gemm_complex_unrolled_MMA_iteration<1, Scalar, Packet, Packetc, RhsPacket, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, pAlphaReal, pAlphaImag);
+            break;
+#endif
+          default:
+            break;
+        }
+#undef MAX_COMPLEX_MMA_UNROLL
+
+        if(remaining_rows > 0)
+        {
+          gemm_complex_extra_row<Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, rows, cols, remaining_rows, pAlphaReal, pAlphaImag, pMask);
+        }
+      }
+
+      if(remaining_cols > 0)
+      {
+        const Scalar* rhs_base = blockB + advanceCols*col*strideB + remaining_cols*offsetB;
+        const Scalar* lhs_base = blockA;
+
+        for(; col < cols; col++)
+        {
+          Index row = 0;
+
+          gemm_complex_unrolled_col<Scalar, Packet, Packetc, DataMapper, Index, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, rows, col, remaining_cols, pAlphaReal, pAlphaImag);
+
+          if (remaining_rows > 0)
+          {
+            gemm_complex_extra_col<Scalar, Packet, Packetc, DataMapper, Index, accRows, accCols, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(res, lhs_base, rhs_base, depth, strideA, offsetA, strideB, row, col, remaining_rows, remaining_cols, pAlphaReal, pAlphaImag);
+          }
+          rhs_base++;
+        }
+      }
+}
+
+#undef accColsC
+#undef advanceRows
+#undef advanceCols
+
+#pragma GCC reset_options
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
+
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/PacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/PacketMath.h
new file mode 100644
index 00000000..2a440545
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/AltiVec/PacketMath.h
@@ -0,0 +1,2711 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_ALTIVEC_H
+#define EIGEN_PACKET_MATH_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 4
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+// NOTE Altivec has 32 registers, but Eigen only accepts a value of 8 or 16
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS  32
+#endif
+
+typedef __vector float                   Packet4f;
+typedef __vector int                     Packet4i;
+typedef __vector unsigned int            Packet4ui;
+typedef __vector __bool int              Packet4bi;
+typedef __vector short int               Packet8s;
+typedef __vector unsigned short int      Packet8us;
+typedef __vector signed char             Packet16c;
+typedef __vector unsigned char           Packet16uc;
+typedef eigen_packet_wrapper<__vector unsigned short int,0> Packet8bf;
+
+// We don't want to write the same code all the time, but we need to reuse the constants
+// and it doesn't really work to declare them global, so we define macros instead
+#define _EIGEN_DECLARE_CONST_FAST_Packet4f(NAME,X) \
+  Packet4f p4f_##NAME = {X, X, X, X}
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = vec_splat_s32(X)
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet4ui(NAME,X) \
+  Packet4ui p4ui_##NAME = {X, X, X, X}
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet8us(NAME,X) \
+  Packet8us p8us_##NAME = {X, X, X, X, X, X, X, X}
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet16uc(NAME,X) \
+  Packet16uc p16uc_##NAME = {X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X}
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME,X) \
+  Packet2d p2d_##NAME = pset1<Packet2d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2l(NAME,X) \
+  Packet2l p2l_##NAME = pset1<Packet2l>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = reinterpret_cast<Packet4f>(pset1<Packet4i>(X))
+
+#define DST_CHAN 1
+#define DST_CTRL(size, count, stride) (((size) << 24) | ((count) << 16) | (stride))
+#define __UNPACK_TYPE__(PACKETNAME) typename unpacket_traits<PACKETNAME>::type 
+
+// These constants are endian-agnostic
+static _EIGEN_DECLARE_CONST_FAST_Packet4f(ZERO, 0); //{ 0.0, 0.0, 0.0, 0.0}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ZERO, 0); //{ 0, 0, 0, 0,}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ONE,1); //{ 1, 1, 1, 1}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS16,-16); //{ -16, -16, -16, -16}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS1,-1); //{ -1, -1, -1, -1}
+static _EIGEN_DECLARE_CONST_FAST_Packet4ui(SIGN, 0x80000000u);
+static _EIGEN_DECLARE_CONST_FAST_Packet4ui(PREV0DOT5, 0x3EFFFFFFu);
+static _EIGEN_DECLARE_CONST_FAST_Packet8us(ONE,1); //{ 1, 1, 1, 1, 1, 1, 1, 1}
+static _EIGEN_DECLARE_CONST_FAST_Packet16uc(ONE,1);
+static Packet4f p4f_MZERO = (Packet4f) vec_sl((Packet4ui)p4i_MINUS1, (Packet4ui)p4i_MINUS1); //{ 0x80000000, 0x80000000, 0x80000000, 0x80000000}
+#ifndef __VSX__
+static Packet4f p4f_ONE = vec_ctf(p4i_ONE, 0); //{ 1.0, 1.0, 1.0, 1.0}
+#endif
+
+static Packet4f  p4f_COUNTDOWN  = { 0.0, 1.0, 2.0, 3.0 };
+static Packet4i  p4i_COUNTDOWN  = { 0, 1, 2, 3 };
+static Packet8s  p8s_COUNTDOWN  = { 0, 1, 2, 3, 4, 5, 6, 7 };
+static Packet8us p8us_COUNTDOWN = { 0, 1, 2, 3, 4, 5, 6, 7 };
+
+static Packet16c  p16c_COUNTDOWN = { 0, 1, 2, 3, 4, 5, 6, 7,
+                                    8, 9, 10, 11, 12, 13, 14, 15};
+static Packet16uc p16uc_COUNTDOWN = { 0, 1, 2, 3, 4, 5, 6, 7, 
+                                    8, 9, 10, 11, 12, 13, 14, 15};
+
+static Packet16uc p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 };
+static Packet16uc p16uc_REVERSE16 = { 14,15, 12,13, 10,11, 8,9, 6,7, 4,5, 2,3, 0,1 };
+static Packet16uc p16uc_REVERSE8 = { 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 };
+
+static Packet16uc p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 };
+static Packet16uc p16uc_DUPLICATE16_HI = { 0,1,0,1, 2,3,2,3, 4,5,4,5, 6,7,6,7 };
+static Packet16uc p16uc_DUPLICATE8_HI = { 0,0, 1,1, 2,2, 3,3, 4,4, 5,5, 6,6, 7,7 };
+static const Packet16uc p16uc_DUPLICATE16_EVEN= { 0,1 ,0,1, 4,5, 4,5, 8,9, 8,9, 12,13, 12,13 };
+static const Packet16uc p16uc_DUPLICATE16_ODD = { 2,3 ,2,3, 6,7, 6,7, 10,11, 10,11, 14,15, 14,15 };
+
+static Packet16uc p16uc_QUADRUPLICATE16_HI = { 0,1,0,1,0,1,0,1, 2,3,2,3,2,3,2,3 };
+
+// Handle endianness properly while loading constants
+// Define global static constants:
+#ifdef _BIG_ENDIAN
+static Packet16uc p16uc_FORWARD = vec_lvsl(0, (float*)0);
+#ifdef __VSX__
+static Packet16uc p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+#endif
+static Packet16uc p16uc_PSET32_WODD   = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
+static Packet16uc p16uc_PSET32_WEVEN  = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 };
+static Packet16uc p16uc_HALF64_0_16 = vec_sld((Packet16uc)p4i_ZERO, vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 3), 8);      //{ 0,0,0,0, 0,0,0,0, 16,16,16,16, 16,16,16,16};
+#else
+static Packet16uc p16uc_FORWARD = p16uc_REVERSE32;
+static Packet16uc p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+static Packet16uc p16uc_PSET32_WODD = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 1), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
+static Packet16uc p16uc_PSET32_WEVEN = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 };
+static Packet16uc p16uc_HALF64_0_16 = vec_sld(vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 0), (Packet16uc)p4i_ZERO, 8);      //{ 0,0,0,0, 0,0,0,0, 16,16,16,16, 16,16,16,16};
+#endif // _BIG_ENDIAN
+
+static Packet16uc p16uc_PSET64_HI = (Packet16uc) vec_mergeh((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 };
+static Packet16uc p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 8,9,10,11, 12,13,14,15, 8,9,10,11, 12,13,14,15 };
+static Packet16uc p16uc_TRANSPOSE64_HI = p16uc_PSET64_HI + p16uc_HALF64_0_16;                                         //{ 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23};
+static Packet16uc p16uc_TRANSPOSE64_LO = p16uc_PSET64_LO + p16uc_HALF64_0_16;                                         //{ 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31};
+
+static Packet16uc p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8);                                         //{ 4,5,6,7, 0,1,2,3, 12,13,14,15, 8,9,10,11 };
+
+#ifdef _BIG_ENDIAN
+static Packet16uc p16uc_COMPLEX32_REV2 = vec_sld(p16uc_FORWARD, p16uc_FORWARD, 8);                                            //{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+#else
+static Packet16uc p16uc_COMPLEX32_REV2 = vec_sld(p16uc_PSET64_HI, p16uc_PSET64_LO, 8);                                            //{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+#endif // _BIG_ENDIAN
+
+#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  #define EIGEN_PPC_PREFETCH(ADDR) __builtin_prefetch(ADDR);
+#else
+  #define EIGEN_PPC_PREFETCH(ADDR) asm( "   dcbt [%[addr]]\n" :: [addr] "r" (ADDR) : "cc" );
+#endif
+
+template <>
+struct packet_traits<float> : default_packet_traits {
+  typedef Packet4f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasAbs = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasExp = 1,
+#ifdef __VSX__
+    HasSqrt = 1,
+#if !EIGEN_COMP_CLANG
+    HasRsqrt = 1,
+#else
+    HasRsqrt = 0,
+#endif
+#else
+    HasSqrt = 0,
+    HasRsqrt = 0,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+#endif
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+template <>
+struct packet_traits<bfloat16> : default_packet_traits {
+  typedef Packet8bf type;
+  typedef Packet8bf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasAbs = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasExp = 1,
+#ifdef __VSX__
+    HasSqrt = 1,
+#if !EIGEN_COMP_CLANG
+    HasRsqrt = 1,
+#else
+    HasRsqrt = 0,
+#endif
+#else
+    HasSqrt = 0,
+    HasRsqrt = 0,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+#endif
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<int> : default_packet_traits {
+  typedef Packet4i type;
+  typedef Packet4i half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasAdd   = 1,
+    HasSub   = 1,
+    HasShift = 1,
+    HasMul   = 1,
+    HasDiv   = 0,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<short int> : default_packet_traits {
+  typedef Packet8s type;
+  typedef Packet8s half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 0,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<unsigned short int> : default_packet_traits {
+  typedef Packet8us type;
+  typedef Packet8us half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 0,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<signed char> : default_packet_traits {
+  typedef Packet16c type;
+  typedef Packet16c half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 0,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<unsigned char> : default_packet_traits {
+  typedef Packet16uc type;
+  typedef Packet16uc half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 0,
+    HasBlend = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet4f>
+{
+  typedef float     type;
+  typedef Packet4f  half;
+  typedef Packet4i  integer_packet;
+  enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet4i>
+{
+  typedef int       type;
+  typedef Packet4i  half;
+  enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet8s>
+{
+  typedef short int type;
+  typedef Packet8s  half;
+  enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet8us>
+{
+  typedef unsigned short int type;
+  typedef Packet8us          half;
+  enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+
+template<> struct unpacket_traits<Packet16c>
+{
+  typedef signed char type;
+  typedef Packet16c  half;
+  enum {size=16, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet16uc>
+{
+  typedef unsigned char type;
+  typedef Packet16uc  half;
+  enum {size=16, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+
+template<> struct unpacket_traits<Packet8bf>
+{
+  typedef bfloat16 type;
+  typedef Packet8bf          half;
+  enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+inline std::ostream & operator <<(std::ostream & s, const Packet16c & v)
+{
+  union {
+    Packet16c   v;
+    signed char n[16];
+  } vt;
+  vt.v = v;
+  for (int i=0; i< 16; i++)
+    s << vt.n[i] << ", ";
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet16uc & v)
+{
+  union {
+    Packet16uc   v;
+    unsigned char n[16];
+  } vt;
+  vt.v = v;
+  for (int i=0; i< 16; i++)
+    s << vt.n[i] << ", ";
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4f & v)
+{
+  union {
+    Packet4f   v;
+    float n[4];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4i & v)
+{
+  union {
+    Packet4i   v;
+    int n[4];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4ui & v)
+{
+  union {
+    Packet4ui   v;
+    unsigned int n[4];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1] << ", " << vt.n[2] << ", " << vt.n[3];
+  return s;
+}
+
+template <typename Packet>
+EIGEN_STRONG_INLINE Packet pload_common(const __UNPACK_TYPE__(Packet)* from)
+{
+  // some versions of GCC throw "unused-but-set-parameter".
+  // ignoring these warnings for now.
+  EIGEN_UNUSED_VARIABLE(from);
+  EIGEN_DEBUG_ALIGNED_LOAD
+#ifdef __VSX__
+  return vec_xl(0, const_cast<__UNPACK_TYPE__(Packet)*>(from));
+#else
+  return vec_ld(0, from);
+#endif
+}
+
+// Need to define them first or we get specialization after instantiation errors
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from)
+{
+  return pload_common<Packet4f>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int*     from)
+{
+  return pload_common<Packet4i>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8s pload<Packet8s>(const short int* from)
+{
+  return pload_common<Packet8s>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us pload<Packet8us>(const unsigned short int* from)
+{
+  return pload_common<Packet8us>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16c pload<Packet16c>(const signed char*     from)
+{
+  return pload_common<Packet16c>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16uc pload<Packet16uc>(const unsigned char*     from)
+{
+  return pload_common<Packet16uc>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pload<Packet8bf>(const bfloat16*     from)
+{
+  return pload_common<Packet8us>(reinterpret_cast<const unsigned short int*>(from));
+}
+
+template <typename Packet>
+EIGEN_STRONG_INLINE void pstore_common(__UNPACK_TYPE__(Packet)* to, const Packet& from){
+  // some versions of GCC throw "unused-but-set-parameter" (float *to).
+  // ignoring these warnings for now.
+  EIGEN_UNUSED_VARIABLE(to);
+  EIGEN_DEBUG_ALIGNED_STORE
+#ifdef __VSX__
+  vec_xst(from, 0, to);
+#else
+  vec_st(from, 0, to);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet4f& from)
+{
+  pstore_common<Packet4f>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet4i& from)
+{
+  pstore_common<Packet4i>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<short int>(short int*       to, const Packet8s& from)
+{
+  pstore_common<Packet8s>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<unsigned short int>(unsigned short int*       to, const Packet8us& from)
+{
+  pstore_common<Packet8us>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<bfloat16>(bfloat16*       to, const Packet8bf& from)
+{
+  pstore_common<Packet8us>(reinterpret_cast<unsigned short int*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<signed char>(signed char*       to, const Packet16c& from)
+{
+  pstore_common<Packet16c>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<unsigned char>(unsigned char*       to, const Packet16uc& from)
+{
+  pstore_common<Packet16uc>(to, from);
+}
+
+template<typename Packet>
+EIGEN_STRONG_INLINE Packet pset1_size4(const __UNPACK_TYPE__(Packet)& from)
+{
+  Packet v = {from, from, from, from};
+  return v;
+}
+
+template<typename Packet>
+EIGEN_STRONG_INLINE Packet pset1_size8(const __UNPACK_TYPE__(Packet)& from)
+{
+  Packet v = {from, from, from, from, from, from, from, from};
+  return v;
+}
+
+template<typename Packet>
+EIGEN_STRONG_INLINE Packet pset1_size16(const __UNPACK_TYPE__(Packet)& from)
+{
+  Packet v = {from, from, from, from, from, from, from, from, from, from, from, from, from, from, from, from};
+  return v;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) {
+  return pset1_size4<Packet4f>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from)   {
+  return pset1_size4<Packet4i>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8s pset1<Packet8s>(const short int&    from)   {
+  return pset1_size8<Packet8s>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us pset1<Packet8us>(const unsigned short int&    from)   {
+  return pset1_size8<Packet8us>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16c pset1<Packet16c>(const signed char&    from)   {
+  return pset1_size16<Packet16c>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16uc pset1<Packet16uc>(const unsigned char&    from)   {
+  return pset1_size16<Packet16uc>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1frombits<Packet4f>(unsigned int from) {
+  return reinterpret_cast<Packet4f>(pset1<Packet4i>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pset1<Packet8bf>(const bfloat16&    from)   {
+  return pset1_size8<Packet8us>(reinterpret_cast<const unsigned short int&>(from));
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE void
+pbroadcast4_common(const __UNPACK_TYPE__(Packet) *a,
+                      Packet& a0, Packet& a1, Packet& a2, Packet& a3)
+{
+  a3 = pload<Packet>(a);
+  a0 = vec_splat(a3, 0);
+  a1 = vec_splat(a3, 1);
+  a2 = vec_splat(a3, 2);
+  a3 = vec_splat(a3, 3);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  pbroadcast4_common<Packet4f>(a, a0, a1, a2, a3);
+}
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4i>(const int *a,
+                      Packet4i& a0, Packet4i& a1, Packet4i& a2, Packet4i& a3)
+{
+  pbroadcast4_common<Packet4i>(a, a0, a1, a2, a3);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather_common(const __UNPACK_TYPE__(Packet)* from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[4];
+  a[0] = from[0*stride];
+  a[1] = from[1*stride];
+  a[2] = from[2*stride];
+  a[3] = from[3*stride];
+  return pload<Packet>(a);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  return pgather_common<Packet4f>(from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int, Packet4i>(const int* from, Index stride)
+{
+  return pgather_common<Packet4i>(from, stride);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather_size8(const __UNPACK_TYPE__(Packet)* from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[8];
+  a[0] = from[0*stride];
+  a[1] = from[1*stride];
+  a[2] = from[2*stride];
+  a[3] = from[3*stride];
+  a[4] = from[4*stride];
+  a[5] = from[5*stride];
+  a[6] = from[6*stride];
+  a[7] = from[7*stride];
+  return pload<Packet>(a);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet8s pgather<short int, Packet8s>(const short int* from, Index stride)
+{
+  return pgather_size8<Packet8s>(from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet8us pgather<unsigned short int, Packet8us>(const unsigned short int* from, Index stride)
+{
+  return pgather_size8<Packet8us>(from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet8bf pgather<bfloat16, Packet8bf>(const bfloat16* from, Index stride)
+{
+  return pgather_size8<Packet8bf>(from, stride);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather_size16(const __UNPACK_TYPE__(Packet)* from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[16];
+  a[0] = from[0*stride];
+  a[1] = from[1*stride];
+  a[2] = from[2*stride];
+  a[3] = from[3*stride];
+  a[4] = from[4*stride];
+  a[5] = from[5*stride];
+  a[6] = from[6*stride];
+  a[7] = from[7*stride];
+  a[8] = from[8*stride];
+  a[9] = from[9*stride];
+  a[10] = from[10*stride];
+  a[11] = from[11*stride];
+  a[12] = from[12*stride];
+  a[13] = from[13*stride];
+  a[14] = from[14*stride];
+  a[15] = from[15*stride];
+  return pload<Packet>(a);
+}
+
+
+template<> EIGEN_DEVICE_FUNC inline Packet16c pgather<signed char, Packet16c>(const signed char* from, Index stride)
+{
+  return pgather_size16<Packet16c>(from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet16uc pgather<unsigned char, Packet16uc>(const unsigned char* from, Index stride)
+{
+  return pgather_size16<Packet16uc>(from, stride);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline void pscatter_size4(__UNPACK_TYPE__(Packet)* to, const Packet& from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[4];
+  pstore<__UNPACK_TYPE__(Packet)>(a, from);
+  to[0*stride] = a[0];
+  to[1*stride] = a[1];
+  to[2*stride] = a[2];
+  to[3*stride] = a[3];
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  pscatter_size4<Packet4f>(to, from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<int, Packet4i>(int* to, const Packet4i& from, Index stride)
+{
+  pscatter_size4<Packet4i>(to, from, stride);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline void pscatter_size8(__UNPACK_TYPE__(Packet)* to, const Packet& from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[8];
+  pstore<__UNPACK_TYPE__(Packet)>(a, from);
+  to[0*stride] = a[0];
+  to[1*stride] = a[1];
+  to[2*stride] = a[2];
+  to[3*stride] = a[3];
+  to[4*stride] = a[4];
+  to[5*stride] = a[5];
+  to[6*stride] = a[6];
+  to[7*stride] = a[7];
+}
+
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<short int, Packet8s>(short int* to, const Packet8s& from, Index stride)
+{
+  pscatter_size8<Packet8s>(to, from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<unsigned short int, Packet8us>(unsigned short int* to, const Packet8us& from, Index stride)
+{
+  pscatter_size8<Packet8us>(to, from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<bfloat16, Packet8bf>(bfloat16* to, const Packet8bf& from, Index stride)
+{
+  pscatter_size8<Packet8bf>(to, from, stride);
+}
+
+template<typename Packet> EIGEN_DEVICE_FUNC inline void pscatter_size16(__UNPACK_TYPE__(Packet)* to, const Packet& from, Index stride)
+{
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) a[16];
+  pstore<__UNPACK_TYPE__(Packet)>(a, from);
+  to[0*stride] = a[0];
+  to[1*stride] = a[1];
+  to[2*stride] = a[2];
+  to[3*stride] = a[3];
+  to[4*stride] = a[4];
+  to[5*stride] = a[5];
+  to[6*stride] = a[6];
+  to[7*stride] = a[7];
+  to[8*stride] = a[8];
+  to[9*stride] = a[9];
+  to[10*stride] = a[10];
+  to[11*stride] = a[11];
+  to[12*stride] = a[12];
+  to[13*stride] = a[13];
+  to[14*stride] = a[14];
+  to[15*stride] = a[15];
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<signed char, Packet16c>(signed char* to, const Packet16c& from, Index stride)
+{
+  pscatter_size16<Packet16c>(to, from, stride);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<unsigned char, Packet16uc>(unsigned char* to, const Packet16uc& from, Index stride)
+{
+  pscatter_size16<Packet16uc>(to, from, stride);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f   plset<Packet4f>(const float&     a) { return pset1<Packet4f>(a) + p4f_COUNTDOWN;  }
+template<> EIGEN_STRONG_INLINE Packet4i   plset<Packet4i>(const int&       a) { return pset1<Packet4i>(a) + p4i_COUNTDOWN;  }
+template<> EIGEN_STRONG_INLINE Packet8s   plset<Packet8s>(const short int& a) { return pset1<Packet8s>(a) + p8s_COUNTDOWN; }
+template<> EIGEN_STRONG_INLINE Packet8us  plset<Packet8us>(const unsigned short int& a) { return pset1<Packet8us>(a) + p8us_COUNTDOWN; }
+template<> EIGEN_STRONG_INLINE Packet16c  plset<Packet16c>(const signed char& a)   { return pset1<Packet16c>(a) + p16c_COUNTDOWN; }
+template<> EIGEN_STRONG_INLINE Packet16uc plset<Packet16uc>(const unsigned char& a)   { return pset1<Packet16uc>(a) + p16uc_COUNTDOWN; }
+
+template<> EIGEN_STRONG_INLINE Packet4f   padd<Packet4f>  (const Packet4f&   a, const Packet4f&   b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet4i   padd<Packet4i>  (const Packet4i&   a, const Packet4i&   b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet4ui   padd<Packet4ui>  (const Packet4ui&   a, const Packet4ui&   b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet8s   padd<Packet8s>  (const Packet8s&   a, const Packet8s&   b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet8us  padd<Packet8us> (const Packet8us&  a, const Packet8us&  b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet16c  padd<Packet16c> (const Packet16c&  a, const Packet16c&  b) { return a + b; }
+template<> EIGEN_STRONG_INLINE Packet16uc padd<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return a + b; }
+
+template<> EIGEN_STRONG_INLINE Packet4f   psub<Packet4f>  (const Packet4f&   a, const Packet4f&   b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet4i   psub<Packet4i>  (const Packet4i&   a, const Packet4i&   b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet8s   psub<Packet8s>  (const Packet8s&   a, const Packet8s&   b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet8us  psub<Packet8us> (const Packet8us&  a, const Packet8us&  b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet16c  psub<Packet16c> (const Packet16c&  a, const Packet16c&  b) { return a - b; }
+template<> EIGEN_STRONG_INLINE Packet16uc psub<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return a - b; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return p4f_ZERO - a; }
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return p4i_ZERO - a; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4f   pmul<Packet4f>  (const Packet4f&   a, const Packet4f&   b) { return vec_madd(a,b, p4f_MZERO); }
+template<> EIGEN_STRONG_INLINE Packet4i   pmul<Packet4i>  (const Packet4i&   a, const Packet4i&   b) { return a * b; }
+template<> EIGEN_STRONG_INLINE Packet8s   pmul<Packet8s>  (const Packet8s&   a, const Packet8s&   b) { return vec_mul(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us  pmul<Packet8us> (const Packet8us&  a, const Packet8us&  b) { return vec_mul(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c  pmul<Packet16c> (const Packet16c&  a, const Packet16c&  b) { return vec_mul(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmul<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vec_mul(a,b); }
+
+
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+#ifndef __VSX__  // VSX actually provides a div instruction
+  Packet4f t, y_0, y_1;
+
+  // Altivec does not offer a divide instruction, we have to do a reciprocal approximation
+  y_0 = vec_re(b);
+
+  // Do one Newton-Raphson iteration to get the needed accuracy
+  t   = vec_nmsub(y_0, b, p4f_ONE);
+  y_1 = vec_madd(y_0, t, y_0);
+
+  return vec_madd(a, y_1, p4f_MZERO);
+#else
+  return vec_div(a, b);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/)
+{ eigen_assert(false && "packet integer division are not supported by AltiVec");
+  return pset1<Packet4i>(0);
+}
+
+// for some weird raisons, it has to be overloaded for packet of integers
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) { return vec_madd(a,b,c); }
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return a*b + c; }
+template<> EIGEN_STRONG_INLINE Packet8s pmadd(const Packet8s& a, const Packet8s& b, const Packet8s& c) { return vec_madd(a,b,c); }
+template<> EIGEN_STRONG_INLINE Packet8us pmadd(const Packet8us& a, const Packet8us& b, const Packet8us& c) { return vec_madd(a,b,c); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  #ifdef __VSX__
+  // NOTE: about 10% slower than vec_min, but consistent with std::min and SSE regarding NaN
+  Packet4f ret;
+  __asm__ ("xvcmpgesp %x0,%x1,%x2\n\txxsel %x0,%x1,%x2,%x0" : "=&wa" (ret) : "wa" (a), "wa" (b));
+  return ret;
+  #else
+  return vec_min(a, b);
+  #endif
+}
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmin<Packet8s>(const Packet8s& a, const Packet8s& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmin<Packet8us>(const Packet8us& a, const Packet8us& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmin<Packet16c>(const Packet16c& a, const Packet16c& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmin<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vec_min(a, b); }
+
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  #ifdef __VSX__
+  // NOTE: about 10% slower than vec_max, but consistent with std::max and SSE regarding NaN
+  Packet4f ret;
+  __asm__ ("xvcmpgtsp %x0,%x2,%x1\n\txxsel %x0,%x1,%x2,%x0" : "=&wa" (ret) : "wa" (a), "wa" (b));
+  return ret;
+  #else
+  return vec_max(a, b);
+  #endif
+}
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmax<Packet8s>(const Packet8s& a, const Packet8s& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmax<Packet8us>(const Packet8us& a, const Packet8us& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmax<Packet16c>(const Packet16c& a, const Packet16c& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmax<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vec_max(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_le(const Packet4f& a, const Packet4f& b) { return reinterpret_cast<Packet4f>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt(const Packet4f& a, const Packet4f& b) { return reinterpret_cast<Packet4f>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_eq(const Packet4f& a, const Packet4f& b) { return reinterpret_cast<Packet4f>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan(const Packet4f& a, const Packet4f& b) {
+  Packet4f c = reinterpret_cast<Packet4f>(vec_cmpge(a,b));
+  return vec_nor(c,c);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_le(const Packet4i& a, const Packet4i& b) { return reinterpret_cast<Packet4i>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_lt(const Packet4i& a, const Packet4i& b) { return reinterpret_cast<Packet4i>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_eq(const Packet4i& a, const Packet4i& b) { return reinterpret_cast<Packet4i>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_le(const Packet8s& a, const Packet8s& b) { return reinterpret_cast<Packet8s>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_lt(const Packet8s& a, const Packet8s& b) { return reinterpret_cast<Packet8s>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_eq(const Packet8s& a, const Packet8s& b) { return reinterpret_cast<Packet8s>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_le(const Packet8us& a, const Packet8us& b) { return reinterpret_cast<Packet8us>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_lt(const Packet8us& a, const Packet8us& b) { return reinterpret_cast<Packet8us>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_eq(const Packet8us& a, const Packet8us& b) { return reinterpret_cast<Packet8us>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_le(const Packet16c& a, const Packet16c& b) { return reinterpret_cast<Packet16c>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_lt(const Packet16c& a, const Packet16c& b) { return reinterpret_cast<Packet16c>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_eq(const Packet16c& a, const Packet16c& b) { return reinterpret_cast<Packet16c>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_le(const Packet16uc& a, const Packet16uc& b) { return reinterpret_cast<Packet16uc>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_lt(const Packet16uc& a, const Packet16uc& b) { return reinterpret_cast<Packet16uc>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_eq(const Packet16uc& a, const Packet16uc& b) { return reinterpret_cast<Packet16uc>(vec_cmpeq(a,b)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pand<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8us pand<Packet8us>(const Packet8us& a, const Packet8us& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8bf pand<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return pand<Packet8us>(a, b);
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8s por<Packet8s>(const Packet8s& a, const Packet8s& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8us por<Packet8us>(const Packet8us& a, const Packet8us& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8bf por<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  return por<Packet8us>(a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8bf pxor<Packet8bf>(const Packet8bf& a, const Packet8bf& b) { 
+  return pxor<Packet8us>(a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_andc(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_andc(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pselect(const Packet4f& mask, const Packet4f& a, const Packet4f& b) {
+  return vec_sel(b, a, reinterpret_cast<Packet4ui>(mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a)
+{
+    Packet4f t = vec_add(reinterpret_cast<Packet4f>(vec_or(vec_and(reinterpret_cast<Packet4ui>(a), p4ui_SIGN), p4ui_PREV0DOT5)), a);
+    Packet4f res;
+
+#ifdef __VSX__
+    __asm__("xvrspiz %x0, %x1\n\t"
+        : "=&wa" (res)
+        : "wa" (t));
+#else
+    __asm__("vrfiz %0, %1\n\t"
+        : "=v" (res)
+        : "v" (t));
+#endif
+
+    return res;
+}
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const  Packet4f& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a) { return vec_floor(a); }
+template<> EIGEN_STRONG_INLINE Packet4f print<Packet4f>(const Packet4f& a)
+{
+    Packet4f res;
+
+    __asm__("xvrspic %x0, %x1\n\t"
+        : "=&wa" (res)
+        : "wa" (a));
+
+    return res;
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE Packet ploadu_common(const __UNPACK_TYPE__(Packet)* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD
+#ifdef _BIG_ENDIAN
+  Packet16uc MSQ, LSQ;
+  Packet16uc mask;
+  MSQ = vec_ld(0, (unsigned char *)from);          // most significant quadword
+  LSQ = vec_ld(15, (unsigned char *)from);         // least significant quadword
+  mask = vec_lvsl(0, from);                        // create the permute mask
+  //TODO: Add static_cast here
+  return (Packet) vec_perm(MSQ, LSQ, mask);           // align the data
+#else
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return vec_xl(0, const_cast<__UNPACK_TYPE__(Packet)*>(from));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from)
+{
+  return ploadu_common<Packet4f>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from)
+{
+  return ploadu_common<Packet4i>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet8s ploadu<Packet8s>(const short int* from)
+{
+  return ploadu_common<Packet8s>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet8us ploadu<Packet8us>(const unsigned short int* from)
+{
+  return ploadu_common<Packet8us>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf ploadu<Packet8bf>(const bfloat16* from)
+{
+  return ploadu_common<Packet8us>(reinterpret_cast<const unsigned short int*>(from));
+}
+template<> EIGEN_STRONG_INLINE Packet16c ploadu<Packet16c>(const signed char* from)
+{
+  return ploadu_common<Packet16c>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet16uc ploadu<Packet16uc>(const unsigned char* from)
+{
+  return ploadu_common<Packet16uc>(from);
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE Packet ploaddup_common(const __UNPACK_TYPE__(Packet)*   from)
+{
+  Packet p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet>(from);
+  else                                  p = ploadu<Packet>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
+}
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float*   from)
+{
+  return ploaddup_common<Packet4f>(from);
+}
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int*     from)
+{
+  return ploaddup_common<Packet4i>(from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8s ploaddup<Packet8s>(const short int*     from)
+{
+  Packet8s p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet8s>(from);
+  else                                  p = ploadu<Packet8s>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE16_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us ploaddup<Packet8us>(const unsigned short int*     from)
+{
+  Packet8us p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet8us>(from);
+  else                                  p = ploadu<Packet8us>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE16_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8s ploadquad<Packet8s>(const short int*     from)
+{
+  Packet8s p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet8s>(from);
+  else                                  p = ploadu<Packet8s>(from);
+  return vec_perm(p, p, p16uc_QUADRUPLICATE16_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us ploadquad<Packet8us>(const unsigned short int*     from)
+{
+  Packet8us p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet8us>(from);
+  else                                  p = ploadu<Packet8us>(from);
+  return vec_perm(p, p, p16uc_QUADRUPLICATE16_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf ploadquad<Packet8bf>(const bfloat16*     from)
+{
+  return ploadquad<Packet8us>(reinterpret_cast<const unsigned short int*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet16c ploaddup<Packet16c>(const signed char*     from)
+{
+  Packet16c p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet16c>(from);
+  else                                  p = ploadu<Packet16c>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE8_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16uc ploaddup<Packet16uc>(const unsigned char*     from)
+{
+  Packet16uc p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet16uc>(from);
+  else                                  p = ploadu<Packet16uc>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE8_HI);
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE void pstoreu_common(__UNPACK_TYPE__(Packet)*  to, const Packet& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE
+#ifdef _BIG_ENDIAN
+  // Taken from http://developer.apple.com/hardwaredrivers/ve/alignment.html
+  // Warning: not thread safe!
+  Packet16uc MSQ, LSQ, edges;
+  Packet16uc edgeAlign, align;
+
+  MSQ = vec_ld(0, (unsigned char *)to);                     // most significant quadword
+  LSQ = vec_ld(15, (unsigned char *)to);                    // least significant quadword
+  edgeAlign = vec_lvsl(0, to);                              // permute map to extract edges
+  edges=vec_perm(LSQ,MSQ,edgeAlign);                        // extract the edges
+  align = vec_lvsr( 0, to );                                // permute map to misalign data
+  MSQ = vec_perm(edges,(Packet16uc)from,align);             // misalign the data (MSQ)
+  LSQ = vec_perm((Packet16uc)from,edges,align);             // misalign the data (LSQ)
+  vec_st( LSQ, 15, (unsigned char *)to );                   // Store the LSQ part first
+  vec_st( MSQ, 0, (unsigned char *)to );                   // Store the MSQ part second
+#else
+  vec_xst(from, 0, to);
+#endif
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*  to, const Packet4f& from)
+{
+  pstoreu_common<Packet4f>(to, from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*      to, const Packet4i& from)
+{
+  pstoreu_common<Packet4i>(to, from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<short int>(short int*      to, const Packet8s& from)
+{
+  pstoreu_common<Packet8s>(to, from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<unsigned short int>(unsigned short int*      to, const Packet8us& from)
+{
+  pstoreu_common<Packet8us>(to, from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<bfloat16>(bfloat16*      to, const Packet8bf& from)
+{
+  pstoreu_common<Packet8us>(reinterpret_cast<unsigned short int*>(to), from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<signed char>(signed char*      to, const Packet16c& from)
+{
+  pstoreu_common<Packet16c>(to, from);
+}
+template<> EIGEN_STRONG_INLINE void pstoreu<unsigned char>(unsigned char*      to, const Packet16uc& from)
+{
+  pstoreu_common<Packet16uc>(to, from);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr)    { EIGEN_PPC_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*     addr)    { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { EIGEN_ALIGN16 float x; vec_ste(a, 0, &x); return x; }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { EIGEN_ALIGN16 int   x; vec_ste(a, 0, &x); return x; }
+
+template<typename Packet> EIGEN_STRONG_INLINE __UNPACK_TYPE__(Packet) pfirst_common(const Packet& a) {
+  EIGEN_ALIGN16 __UNPACK_TYPE__(Packet) x;
+  vec_ste(a, 0, &x);
+  return x;
+}
+
+template<> EIGEN_STRONG_INLINE short int pfirst<Packet8s>(const Packet8s& a) {
+  return pfirst_common<Packet8s>(a);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned short int pfirst<Packet8us>(const Packet8us& a) {
+  return pfirst_common<Packet8us>(a);
+}
+
+template<> EIGEN_STRONG_INLINE signed char pfirst<Packet16c>(const Packet16c& a)
+{
+  return pfirst_common<Packet16c>(a);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned char pfirst<Packet16uc>(const Packet16uc& a)
+{
+  return pfirst_common<Packet16uc>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{
+  return reinterpret_cast<Packet4f>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
+}
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a)
+{
+  return reinterpret_cast<Packet4i>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
+}
+template<> EIGEN_STRONG_INLINE Packet8s preverse(const Packet8s& a)
+{
+  return reinterpret_cast<Packet8s>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE16));
+}
+template<> EIGEN_STRONG_INLINE Packet8us preverse(const Packet8us& a)
+{
+  return reinterpret_cast<Packet8us>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE16));
+}
+template<> EIGEN_STRONG_INLINE Packet16c preverse(const Packet16c& a)
+{
+  return vec_perm(a, a, p16uc_REVERSE8);
+}
+template<> EIGEN_STRONG_INLINE Packet16uc preverse(const Packet16uc& a)
+{
+  return vec_perm(a, a, p16uc_REVERSE8);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf preverse(const Packet8bf& a)
+{
+  return preverse<Packet8us>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet8s pabs(const Packet8s& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet8us pabs(const Packet8us& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet16c pabs(const Packet16c& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet16uc pabs(const Packet16uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8bf  pabs(const Packet8bf& a) {
+  _EIGEN_DECLARE_CONST_FAST_Packet8us(abs_mask,0x7FFF);
+  return pand<Packet8us>(p8us_abs_mask, a);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(const Packet4i& a)
+{ return vec_sra(a,reinterpret_cast<Packet4ui>(pset1<Packet4i>(N))); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_right(const Packet4i& a)
+{ return vec_sr(a,reinterpret_cast<Packet4ui>(pset1<Packet4i>(N))); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_left(const Packet4i& a)
+{ return vec_sl(a,reinterpret_cast<Packet4ui>(pset1<Packet4i>(N))); }
+template<int N> EIGEN_STRONG_INLINE Packet4f plogical_shift_left(const Packet4f& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
+  Packet4ui r = vec_sl(reinterpret_cast<Packet4ui>(a), p4ui_mask);
+  return reinterpret_cast<Packet4f>(r);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet4f plogical_shift_right(const Packet4f& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
+  Packet4ui r = vec_sr(reinterpret_cast<Packet4ui>(a), p4ui_mask);
+  return reinterpret_cast<Packet4f>(r);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet4ui plogical_shift_right(const Packet4ui& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
+  return vec_sr(a, p4ui_mask);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet4ui plogical_shift_left(const Packet4ui& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
+  return vec_sl(a, p4ui_mask);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet8us plogical_shift_left(const Packet8us& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
+  return vec_sl(a, p8us_mask);
+}
+template<int N> EIGEN_STRONG_INLINE Packet8us plogical_shift_right(const Packet8us& a)
+{
+  const _EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
+  return vec_sr(a, p8us_mask);
+}
+
+EIGEN_STRONG_INLINE Packet4f Bf16ToF32Even(const Packet8bf& bf){
+  return plogical_shift_left<16>(reinterpret_cast<Packet4f>(bf.m_val));
+}
+
+EIGEN_STRONG_INLINE Packet4f Bf16ToF32Odd(const Packet8bf& bf){
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(high_mask, 0xFFFF0000);
+  return pand<Packet4f>(
+    reinterpret_cast<Packet4f>(bf.m_val),
+    reinterpret_cast<Packet4f>(p4ui_high_mask)
+  );
+}
+
+// Simple interleaving of bool masks, prevents true values from being
+// converted to NaNs.
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16Bool(Packet4f even, Packet4f odd) {
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(high_mask, 0xFFFF0000);
+  Packet4f bf_odd, bf_even;
+  bf_odd = pand(reinterpret_cast<Packet4f>(p4ui_high_mask), odd);
+  bf_even = plogical_shift_right<16>(even);
+  return reinterpret_cast<Packet8us>(por<Packet4f>(bf_even, bf_odd));
+}
+
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16(Packet4f p4f){
+  Packet4ui input = reinterpret_cast<Packet4ui>(p4f);
+  Packet4ui lsb = plogical_shift_right<16>(input);
+  lsb = pand<Packet4ui>(lsb, reinterpret_cast<Packet4ui>(p4i_ONE));
+
+  _EIGEN_DECLARE_CONST_FAST_Packet4ui(BIAS,0x7FFFu);
+  Packet4ui rounding_bias = padd<Packet4ui>(lsb, p4ui_BIAS);
+  input = padd<Packet4ui>(input, rounding_bias);
+
+  //Test NaN and Subnormal - Begin
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(exp_mask, 0x7F800000);
+  Packet4ui exp = pand<Packet4ui>(p4ui_exp_mask, reinterpret_cast<Packet4ui>(p4f));
+
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(mantissa_mask, 0x7FFFFF);
+  Packet4ui mantissa = pand<Packet4ui>(p4ui_mantissa_mask, reinterpret_cast<Packet4ui>(p4f));
+
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(max_exp, 0x7F800000);
+  Packet4bi is_max_exp = vec_cmpeq(exp, p4ui_max_exp);
+  Packet4bi is_zero_exp = vec_cmpeq(exp, reinterpret_cast<Packet4ui>(p4i_ZERO));
+
+  Packet4bi is_mant_zero = vec_cmpeq(mantissa, reinterpret_cast<Packet4ui>(p4i_ZERO));
+  Packet4ui nan_selector = pandnot<Packet4ui>(
+      reinterpret_cast<Packet4ui>(is_max_exp),
+      reinterpret_cast<Packet4ui>(is_mant_zero)
+  );
+
+  Packet4ui subnormal_selector = pandnot<Packet4ui>(
+      reinterpret_cast<Packet4ui>(is_zero_exp),
+      reinterpret_cast<Packet4ui>(is_mant_zero)
+  );
+
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(nan, 0x7FC00000);
+  input = vec_sel(input, p4ui_nan, nan_selector);
+  input = vec_sel(input, reinterpret_cast<Packet4ui>(p4f), subnormal_selector);
+  //Test NaN and Subnormal - End
+
+  input = plogical_shift_right<16>(input);
+  return reinterpret_cast<Packet8us>(input);
+}
+
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16(Packet4f even, Packet4f odd){
+  Packet4f bf_odd, bf_even;
+  bf_odd = reinterpret_cast<Packet4f>(F32ToBf16(odd).m_val);
+  bf_odd = plogical_shift_left<16>(bf_odd);
+  bf_even = reinterpret_cast<Packet4f>(F32ToBf16(even).m_val);
+  return reinterpret_cast<Packet8us>(por<Packet4f>(bf_even, bf_odd));
+}
+#define BF16_TO_F32_UNARY_OP_WRAPPER(OP, A) \
+  Packet4f a_even = Bf16ToF32Even(A);\
+  Packet4f a_odd = Bf16ToF32Odd(A);\
+  Packet4f op_even = OP(a_even);\
+  Packet4f op_odd = OP(a_odd);\
+  return F32ToBf16(op_even, op_odd);\
+
+#define BF16_TO_F32_BINARY_OP_WRAPPER(OP, A, B) \
+  Packet4f a_even = Bf16ToF32Even(A);\
+  Packet4f a_odd = Bf16ToF32Odd(A);\
+  Packet4f b_even = Bf16ToF32Even(B);\
+  Packet4f b_odd = Bf16ToF32Odd(B);\
+  Packet4f op_even = OP(a_even, b_even);\
+  Packet4f op_odd = OP(a_odd, b_odd);\
+  return F32ToBf16(op_even, op_odd);\
+
+#define BF16_TO_F32_BINARY_OP_WRAPPER_BOOL(OP, A, B) \
+  Packet4f a_even = Bf16ToF32Even(A);\
+  Packet4f a_odd = Bf16ToF32Odd(A);\
+  Packet4f b_even = Bf16ToF32Even(B);\
+  Packet4f b_odd = Bf16ToF32Odd(B);\
+  Packet4f op_even = OP(a_even, b_even);\
+  Packet4f op_odd = OP(a_odd, b_odd);\
+  return F32ToBf16Bool(op_even, op_odd);\
+
+template<> EIGEN_STRONG_INLINE Packet8bf padd<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(padd<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pmul<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(pmul<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pdiv<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(pdiv<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pnegate<Packet8bf>(const Packet8bf& a) {
+  BF16_TO_F32_UNARY_OP_WRAPPER(pnegate<Packet4f>, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf psub<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(psub<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf psqrt<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(vec_sqrt, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf prsqrt<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(prsqrt<Packet4f>, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pexp<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(pexp_float, a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pldexp<Packet4f>(const Packet4f& a, const Packet4f& exponent) {
+  return pldexp_generic(a,exponent);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pldexp<Packet8bf> (const Packet8bf& a, const Packet8bf& exponent){
+  BF16_TO_F32_BINARY_OP_WRAPPER(pldexp<Packet4f>, a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pfrexp<Packet4f>(const Packet4f& a, Packet4f& exponent) {
+  return pfrexp_generic(a,exponent);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pfrexp<Packet8bf> (const Packet8bf& a, Packet8bf& e){
+  Packet4f a_even = Bf16ToF32Even(a);
+  Packet4f a_odd = Bf16ToF32Odd(a);
+  Packet4f e_even;
+  Packet4f e_odd;
+  Packet4f op_even = pfrexp<Packet4f>(a_even, e_even);
+  Packet4f op_odd = pfrexp<Packet4f>(a_odd, e_odd);
+  e = F32ToBf16(e_even, e_odd);
+  return F32ToBf16(op_even, op_odd);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf psin<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(psin_float, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pcos<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(pcos_float, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf plog<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(plog_float, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pfloor<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(pfloor<Packet4f>, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pceil<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(pceil<Packet4f>, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pround<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(pround<Packet4f>, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf print<Packet8bf> (const Packet8bf& a){
+  BF16_TO_F32_UNARY_OP_WRAPPER(print<Packet4f>, a);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pmadd(const Packet8bf& a, const Packet8bf& b, const Packet8bf& c) {
+  Packet4f a_even = Bf16ToF32Even(a);
+  Packet4f a_odd = Bf16ToF32Odd(a);
+  Packet4f b_even = Bf16ToF32Even(b);
+  Packet4f b_odd = Bf16ToF32Odd(b);
+  Packet4f c_even = Bf16ToF32Even(c);
+  Packet4f c_odd = Bf16ToF32Odd(c);
+  Packet4f pmadd_even = pmadd<Packet4f>(a_even, b_even, c_even);
+  Packet4f pmadd_odd = pmadd<Packet4f>(a_odd, b_odd, c_odd);
+  return F32ToBf16(pmadd_even, pmadd_odd);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pmin<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(pmin<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pmax<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER(pmax<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_lt(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER_BOOL(pcmp_lt<Packet4f>, a, b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_lt_or_nan(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER_BOOL(pcmp_lt_or_nan<Packet4f>, a, b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_le(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER_BOOL(pcmp_le<Packet4f>, a, b);
+}
+template<> EIGEN_STRONG_INLINE Packet8bf pcmp_eq(const Packet8bf& a, const Packet8bf& b) {
+  BF16_TO_F32_BINARY_OP_WRAPPER_BOOL(pcmp_eq<Packet4f>, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 pfirst(const Packet8bf& a) {
+  return Eigen::bfloat16_impl::raw_uint16_to_bfloat16((pfirst<Packet8us>(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf ploaddup<Packet8bf>(const  bfloat16*     from)
+{
+  return ploaddup<Packet8us>(reinterpret_cast<const unsigned short int*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf plset<Packet8bf>(const bfloat16& a) {
+  bfloat16 countdown[8] = { bfloat16(0), bfloat16(1), bfloat16(2), bfloat16(3),
+                            bfloat16(4), bfloat16(5), bfloat16(6), bfloat16(7) };
+  return padd<Packet8bf>(pset1<Packet8bf>(a), pload<Packet8bf>(countdown));
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, sum;
+  b   = vec_sld(a, a, 8);
+  sum = a + b;
+  b   = vec_sld(sum, sum, 4);
+  sum += b;
+  return pfirst(sum);
+}
+
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i sum;
+  sum = vec_sums(a, p4i_ZERO);
+#ifdef _BIG_ENDIAN
+  sum = vec_sld(sum, p4i_ZERO, 12);
+#else
+  sum = vec_sld(p4i_ZERO, sum, 4);
+#endif
+  return pfirst(sum);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux<Packet8bf>(const Packet8bf& a)
+{
+  float redux_even = predux<Packet4f>(Bf16ToF32Even(a));
+  float redux_odd  = predux<Packet4f>(Bf16ToF32Odd(a));
+  float f32_result = redux_even + redux_odd;
+  return bfloat16(f32_result);
+}
+template<typename Packet> EIGEN_STRONG_INLINE __UNPACK_TYPE__(Packet) predux_size8(const Packet& a)
+{
+  union{
+    Packet v;
+    __UNPACK_TYPE__(Packet) n[8];
+  } vt;
+  vt.v = a;
+
+  EIGEN_ALIGN16 int first_loader[4] = { vt.n[0], vt.n[1], vt.n[2], vt.n[3] };
+  EIGEN_ALIGN16 int second_loader[4] = { vt.n[4], vt.n[5], vt.n[6], vt.n[7] };
+  Packet4i first_half  = pload<Packet4i>(first_loader);
+  Packet4i second_half = pload<Packet4i>(second_loader);
+
+  return static_cast<__UNPACK_TYPE__(Packet)>(predux(first_half) + predux(second_half));
+}
+
+template<> EIGEN_STRONG_INLINE short int predux<Packet8s>(const Packet8s& a)
+{
+  return predux_size8<Packet8s>(a);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned short int predux<Packet8us>(const Packet8us& a)
+{
+  return predux_size8<Packet8us>(a);
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE __UNPACK_TYPE__(Packet) predux_size16(const Packet& a)
+{
+  union{
+    Packet v;
+    __UNPACK_TYPE__(Packet) n[16];
+  } vt;
+  vt.v = a;
+
+  EIGEN_ALIGN16 int first_loader[4] = { vt.n[0], vt.n[1], vt.n[2], vt.n[3] };
+  EIGEN_ALIGN16 int second_loader[4] = { vt.n[4], vt.n[5], vt.n[6], vt.n[7] };
+  EIGEN_ALIGN16 int third_loader[4] = { vt.n[8], vt.n[9], vt.n[10], vt.n[11] };
+  EIGEN_ALIGN16 int fourth_loader[4] = { vt.n[12], vt.n[13], vt.n[14], vt.n[15] };
+
+  Packet4i first_quarter = pload<Packet4i>(first_loader);
+  Packet4i second_quarter = pload<Packet4i>(second_loader);
+  Packet4i third_quarter = pload<Packet4i>(third_loader);
+  Packet4i fourth_quarter = pload<Packet4i>(fourth_loader);
+
+  return static_cast<__UNPACK_TYPE__(Packet)>(predux(first_quarter) + predux(second_quarter)
+		                  + predux(third_quarter) + predux(fourth_quarter));
+}
+
+template<> EIGEN_STRONG_INLINE signed char predux<Packet16c>(const Packet16c& a)
+{
+  return predux_size16<Packet16c>(a);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned char predux<Packet16uc>(const Packet16uc& a)
+{
+  return predux_size16<Packet16uc>(a);
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  Packet4f prod;
+  prod = pmul(a, vec_sld(a, a, 8));
+  return pfirst(pmul(prod, vec_sld(prod, prod, 4)));
+}
+
+template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
+{
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  return aux[0] * aux[1] * aux[2] * aux[3];
+}
+
+template<> EIGEN_STRONG_INLINE short int predux_mul<Packet8s>(const Packet8s& a)
+{
+  Packet8s pair, quad, octo;
+
+  pair = vec_mul(a, vec_sld(a, a, 8));
+  quad = vec_mul(pair, vec_sld(pair, pair, 4));
+  octo = vec_mul(quad, vec_sld(quad, quad, 2));
+
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned short int predux_mul<Packet8us>(const Packet8us& a)
+{
+  Packet8us pair, quad, octo;
+
+  pair = vec_mul(a, vec_sld(a, a, 8));
+  quad = vec_mul(pair, vec_sld(pair, pair, 4));
+  octo = vec_mul(quad, vec_sld(quad, quad, 2));
+
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_mul<Packet8bf>(const Packet8bf& a)
+{
+  float redux_even = predux_mul<Packet4f>(Bf16ToF32Even(a));
+  float redux_odd  = predux_mul<Packet4f>(Bf16ToF32Odd(a));
+  float f32_result = redux_even * redux_odd;
+  return bfloat16(f32_result);
+}
+
+
+template<> EIGEN_STRONG_INLINE signed char predux_mul<Packet16c>(const Packet16c& a)
+{
+  Packet16c pair, quad, octo, result;
+
+  pair = vec_mul(a, vec_sld(a, a, 8));
+  quad = vec_mul(pair, vec_sld(pair, pair, 4));
+  octo = vec_mul(quad, vec_sld(quad, quad, 2));
+  result = vec_mul(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned char predux_mul<Packet16uc>(const Packet16uc& a)
+{
+  Packet16uc pair, quad, octo, result;
+
+  pair = vec_mul(a, vec_sld(a, a, 8));
+  quad = vec_mul(pair, vec_sld(pair, pair, 4));
+  octo = vec_mul(quad, vec_sld(quad, quad, 2));
+  result = vec_mul(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+
+// min
+template<typename Packet> EIGEN_STRONG_INLINE
+__UNPACK_TYPE__(Packet) predux_min4(const Packet& a)
+{
+  Packet b, res;
+  b = vec_min(a, vec_sld(a, a, 8));
+  res = vec_min(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  return predux_min4<Packet4f>(a);
+}
+
+template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
+{
+  return predux_min4<Packet4i>(a);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_min<Packet8bf>(const Packet8bf& a)
+{
+  float redux_even = predux_min<Packet4f>(Bf16ToF32Even(a));
+  float redux_odd  = predux_min<Packet4f>(Bf16ToF32Odd(a));
+  float f32_result = (std::min)(redux_even, redux_odd);
+  return bfloat16(f32_result);
+}
+
+template<> EIGEN_STRONG_INLINE short int predux_min<Packet8s>(const Packet8s& a)
+{
+  Packet8s pair, quad, octo;
+  
+  //pair = { Min(a0,a4), Min(a1,a5), Min(a2,a6), Min(a3,a7) }
+  pair = vec_min(a, vec_sld(a, a, 8)); 
+
+  //quad = { Min(a0, a4, a2, a6), Min(a1, a5, a3, a7) }
+  quad = vec_min(pair, vec_sld(pair, pair, 4));
+
+  //octo = { Min(a0, a4, a2, a6, a1, a5, a3, a7) }
+  octo = vec_min(quad, vec_sld(quad, quad, 2));
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned short int predux_min<Packet8us>(const Packet8us& a)
+{
+  Packet8us pair, quad, octo;
+  
+  //pair = { Min(a0,a4), Min(a1,a5), Min(a2,a6), Min(a3,a7) }
+  pair = vec_min(a, vec_sld(a, a, 8)); 
+
+  //quad = { Min(a0, a4, a2, a6), Min(a1, a5, a3, a7) }
+  quad = vec_min(pair, vec_sld(pair, pair, 4));
+
+  //octo = { Min(a0, a4, a2, a6, a1, a5, a3, a7) }
+  octo = vec_min(quad, vec_sld(quad, quad, 2));
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE signed char predux_min<Packet16c>(const Packet16c& a)
+{
+  Packet16c pair, quad, octo, result;
+
+  pair = vec_min(a, vec_sld(a, a, 8));
+  quad = vec_min(pair, vec_sld(pair, pair, 4));
+  octo = vec_min(quad, vec_sld(quad, quad, 2));
+  result = vec_min(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned char predux_min<Packet16uc>(const Packet16uc& a)
+{
+  Packet16uc pair, quad, octo, result;
+
+  pair = vec_min(a, vec_sld(a, a, 8));
+  quad = vec_min(pair, vec_sld(pair, pair, 4));
+  octo = vec_min(quad, vec_sld(quad, quad, 2));
+  result = vec_min(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+// max
+template<typename Packet> EIGEN_STRONG_INLINE __UNPACK_TYPE__(Packet) predux_max4(const Packet& a)
+{
+  Packet b, res;
+  b = vec_max(a, vec_sld(a, a, 8));
+  res = vec_max(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  return predux_max4<Packet4f>(a);
+}
+
+template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
+{
+  return predux_max4<Packet4i>(a);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_max<Packet8bf>(const Packet8bf& a)
+{
+  float redux_even = predux_max<Packet4f>(Bf16ToF32Even(a));
+  float redux_odd  = predux_max<Packet4f>(Bf16ToF32Odd(a));
+  float f32_result = (std::max)(redux_even, redux_odd);
+  return bfloat16(f32_result);
+}
+
+template<> EIGEN_STRONG_INLINE short int predux_max<Packet8s>(const Packet8s& a)
+{
+  Packet8s pair, quad, octo;
+  
+  //pair = { Max(a0,a4), Max(a1,a5), Max(a2,a6), Max(a3,a7) }
+  pair = vec_max(a, vec_sld(a, a, 8)); 
+
+  //quad = { Max(a0, a4, a2, a6), Max(a1, a5, a3, a7) }
+  quad = vec_max(pair, vec_sld(pair, pair, 4));
+
+  //octo = { Max(a0, a4, a2, a6, a1, a5, a3, a7) }
+  octo = vec_max(quad, vec_sld(quad, quad, 2));
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned short int predux_max<Packet8us>(const Packet8us& a)
+{
+  Packet8us pair, quad, octo;
+  
+  //pair = { Max(a0,a4), Max(a1,a5), Max(a2,a6), Max(a3,a7) }
+  pair = vec_max(a, vec_sld(a, a, 8)); 
+
+  //quad = { Max(a0, a4, a2, a6), Max(a1, a5, a3, a7) }
+  quad = vec_max(pair, vec_sld(pair, pair, 4));
+
+  //octo = { Max(a0, a4, a2, a6, a1, a5, a3, a7) }
+  octo = vec_max(quad, vec_sld(quad, quad, 2));
+  return pfirst(octo);
+}
+
+template<> EIGEN_STRONG_INLINE signed char predux_max<Packet16c>(const Packet16c& a)
+{
+  Packet16c pair, quad, octo, result;
+
+  pair = vec_max(a, vec_sld(a, a, 8));
+  quad = vec_max(pair, vec_sld(pair, pair, 4));
+  octo = vec_max(quad, vec_sld(quad, quad, 2));
+  result = vec_max(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+
+template<> EIGEN_STRONG_INLINE unsigned char predux_max<Packet16uc>(const Packet16uc& a)
+{
+  Packet16uc pair, quad, octo, result;
+
+  pair = vec_max(a, vec_sld(a, a, 8));
+  quad = vec_max(pair, vec_sld(pair, pair, 4));
+  octo = vec_max(quad, vec_sld(quad, quad, 2));
+  result = vec_max(octo, vec_sld(octo, octo, 1));
+
+  return pfirst(result);
+}
+
+template<> EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x)
+{
+  return vec_any_ne(x, pzero(x));
+}
+
+template <typename T> EIGEN_DEVICE_FUNC inline void
+ptranpose_common(PacketBlock<T,4>& kernel){
+  T t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  ptranpose_common<Packet4f>(kernel);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4i,4>& kernel) {
+  ptranpose_common<Packet4i>(kernel);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8s,4>& kernel) {
+  Packet8s t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8us,4>& kernel) {
+  Packet8us t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8bf,4>& kernel) {
+  Packet8us t0, t1, t2, t3;
+
+  t0 = vec_mergeh(kernel.packet[0].m_val, kernel.packet[2].m_val);
+  t1 = vec_mergel(kernel.packet[0].m_val, kernel.packet[2].m_val);
+  t2 = vec_mergeh(kernel.packet[1].m_val, kernel.packet[3].m_val);
+  t3 = vec_mergel(kernel.packet[1].m_val, kernel.packet[3].m_val);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16c,4>& kernel) {
+  Packet16c t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16uc,4>& kernel) {
+  Packet16uc t0, t1, t2, t3;
+  t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8s,8>& kernel) {
+  Packet8s v[8], sum[8];
+
+  v[0] = vec_mergeh(kernel.packet[0], kernel.packet[4]);
+  v[1] = vec_mergel(kernel.packet[0], kernel.packet[4]);
+  v[2] = vec_mergeh(kernel.packet[1], kernel.packet[5]);
+  v[3] = vec_mergel(kernel.packet[1], kernel.packet[5]);
+  v[4] = vec_mergeh(kernel.packet[2], kernel.packet[6]);
+  v[5] = vec_mergel(kernel.packet[2], kernel.packet[6]);
+  v[6] = vec_mergeh(kernel.packet[3], kernel.packet[7]);
+  v[7] = vec_mergel(kernel.packet[3], kernel.packet[7]);
+  sum[0] = vec_mergeh(v[0], v[4]);
+  sum[1] = vec_mergel(v[0], v[4]);
+  sum[2] = vec_mergeh(v[1], v[5]);
+  sum[3] = vec_mergel(v[1], v[5]);
+  sum[4] = vec_mergeh(v[2], v[6]);
+  sum[5] = vec_mergel(v[2], v[6]);
+  sum[6] = vec_mergeh(v[3], v[7]);
+  sum[7] = vec_mergel(v[3], v[7]);
+
+  kernel.packet[0] = vec_mergeh(sum[0], sum[4]);
+  kernel.packet[1] = vec_mergel(sum[0], sum[4]);
+  kernel.packet[2] = vec_mergeh(sum[1], sum[5]);
+  kernel.packet[3] = vec_mergel(sum[1], sum[5]);
+  kernel.packet[4] = vec_mergeh(sum[2], sum[6]);
+  kernel.packet[5] = vec_mergel(sum[2], sum[6]);
+  kernel.packet[6] = vec_mergeh(sum[3], sum[7]);
+  kernel.packet[7] = vec_mergel(sum[3], sum[7]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8us,8>& kernel) {
+  Packet8us v[8], sum[8];
+
+  v[0] = vec_mergeh(kernel.packet[0], kernel.packet[4]);
+  v[1] = vec_mergel(kernel.packet[0], kernel.packet[4]);
+  v[2] = vec_mergeh(kernel.packet[1], kernel.packet[5]);
+  v[3] = vec_mergel(kernel.packet[1], kernel.packet[5]);
+  v[4] = vec_mergeh(kernel.packet[2], kernel.packet[6]);
+  v[5] = vec_mergel(kernel.packet[2], kernel.packet[6]);
+  v[6] = vec_mergeh(kernel.packet[3], kernel.packet[7]);
+  v[7] = vec_mergel(kernel.packet[3], kernel.packet[7]);
+  sum[0] = vec_mergeh(v[0], v[4]);
+  sum[1] = vec_mergel(v[0], v[4]);
+  sum[2] = vec_mergeh(v[1], v[5]);
+  sum[3] = vec_mergel(v[1], v[5]);
+  sum[4] = vec_mergeh(v[2], v[6]);
+  sum[5] = vec_mergel(v[2], v[6]);
+  sum[6] = vec_mergeh(v[3], v[7]);
+  sum[7] = vec_mergel(v[3], v[7]);
+
+  kernel.packet[0] = vec_mergeh(sum[0], sum[4]);
+  kernel.packet[1] = vec_mergel(sum[0], sum[4]);
+  kernel.packet[2] = vec_mergeh(sum[1], sum[5]);
+  kernel.packet[3] = vec_mergel(sum[1], sum[5]);
+  kernel.packet[4] = vec_mergeh(sum[2], sum[6]);
+  kernel.packet[5] = vec_mergel(sum[2], sum[6]);
+  kernel.packet[6] = vec_mergeh(sum[3], sum[7]);
+  kernel.packet[7] = vec_mergel(sum[3], sum[7]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet8bf,8>& kernel) {
+  Packet8bf v[8], sum[8];
+
+  v[0] = vec_mergeh(kernel.packet[0].m_val, kernel.packet[4].m_val);
+  v[1] = vec_mergel(kernel.packet[0].m_val, kernel.packet[4].m_val);
+  v[2] = vec_mergeh(kernel.packet[1].m_val, kernel.packet[5].m_val);
+  v[3] = vec_mergel(kernel.packet[1].m_val, kernel.packet[5].m_val);
+  v[4] = vec_mergeh(kernel.packet[2].m_val, kernel.packet[6].m_val);
+  v[5] = vec_mergel(kernel.packet[2].m_val, kernel.packet[6].m_val);
+  v[6] = vec_mergeh(kernel.packet[3].m_val, kernel.packet[7].m_val);
+  v[7] = vec_mergel(kernel.packet[3].m_val, kernel.packet[7].m_val);
+  sum[0] = vec_mergeh(v[0].m_val, v[4].m_val);
+  sum[1] = vec_mergel(v[0].m_val, v[4].m_val);
+  sum[2] = vec_mergeh(v[1].m_val, v[5].m_val);
+  sum[3] = vec_mergel(v[1].m_val, v[5].m_val);
+  sum[4] = vec_mergeh(v[2].m_val, v[6].m_val);
+  sum[5] = vec_mergel(v[2].m_val, v[6].m_val);
+  sum[6] = vec_mergeh(v[3].m_val, v[7].m_val);
+  sum[7] = vec_mergel(v[3].m_val, v[7].m_val);
+
+  kernel.packet[0] = vec_mergeh(sum[0].m_val, sum[4].m_val);
+  kernel.packet[1] = vec_mergel(sum[0].m_val, sum[4].m_val);
+  kernel.packet[2] = vec_mergeh(sum[1].m_val, sum[5].m_val);
+  kernel.packet[3] = vec_mergel(sum[1].m_val, sum[5].m_val);
+  kernel.packet[4] = vec_mergeh(sum[2].m_val, sum[6].m_val);
+  kernel.packet[5] = vec_mergel(sum[2].m_val, sum[6].m_val);
+  kernel.packet[6] = vec_mergeh(sum[3].m_val, sum[7].m_val);
+  kernel.packet[7] = vec_mergel(sum[3].m_val, sum[7].m_val);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16c,16>& kernel) {
+  Packet16c step1[16], step2[16], step3[16];
+
+  step1[0] = vec_mergeh(kernel.packet[0], kernel.packet[8]);
+  step1[1] = vec_mergel(kernel.packet[0], kernel.packet[8]);
+  step1[2] = vec_mergeh(kernel.packet[1], kernel.packet[9]);
+  step1[3] = vec_mergel(kernel.packet[1], kernel.packet[9]);
+  step1[4] = vec_mergeh(kernel.packet[2], kernel.packet[10]);
+  step1[5] = vec_mergel(kernel.packet[2], kernel.packet[10]);
+  step1[6] = vec_mergeh(kernel.packet[3], kernel.packet[11]);
+  step1[7] = vec_mergel(kernel.packet[3], kernel.packet[11]);
+  step1[8] = vec_mergeh(kernel.packet[4], kernel.packet[12]);
+  step1[9] = vec_mergel(kernel.packet[4], kernel.packet[12]);
+  step1[10] = vec_mergeh(kernel.packet[5], kernel.packet[13]);
+  step1[11] = vec_mergel(kernel.packet[5], kernel.packet[13]);
+  step1[12] = vec_mergeh(kernel.packet[6], kernel.packet[14]);
+  step1[13] = vec_mergel(kernel.packet[6], kernel.packet[14]);
+  step1[14] = vec_mergeh(kernel.packet[7], kernel.packet[15]);
+  step1[15] = vec_mergel(kernel.packet[7], kernel.packet[15]);
+
+  step2[0]  = vec_mergeh(step1[0], step1[8]);
+  step2[1]  = vec_mergel(step1[0], step1[8]);
+  step2[2]  = vec_mergeh(step1[1], step1[9]);
+  step2[3]  = vec_mergel(step1[1], step1[9]);
+  step2[4]  = vec_mergeh(step1[2], step1[10]);
+  step2[5]  = vec_mergel(step1[2], step1[10]);
+  step2[6]  = vec_mergeh(step1[3], step1[11]);
+  step2[7]  = vec_mergel(step1[3], step1[11]);
+  step2[8]  = vec_mergeh(step1[4], step1[12]);
+  step2[9]  = vec_mergel(step1[4], step1[12]);
+  step2[10] = vec_mergeh(step1[5], step1[13]);
+  step2[11] = vec_mergel(step1[5], step1[13]);
+  step2[12] = vec_mergeh(step1[6], step1[14]);
+  step2[13] = vec_mergel(step1[6], step1[14]);
+  step2[14] = vec_mergeh(step1[7], step1[15]);
+  step2[15] = vec_mergel(step1[7], step1[15]);
+
+  step3[0]  = vec_mergeh(step2[0], step2[8]);
+  step3[1]  = vec_mergel(step2[0], step2[8]);
+  step3[2]  = vec_mergeh(step2[1], step2[9]);
+  step3[3]  = vec_mergel(step2[1], step2[9]);
+  step3[4]  = vec_mergeh(step2[2], step2[10]);
+  step3[5]  = vec_mergel(step2[2], step2[10]);
+  step3[6]  = vec_mergeh(step2[3], step2[11]);
+  step3[7]  = vec_mergel(step2[3], step2[11]);
+  step3[8]  = vec_mergeh(step2[4], step2[12]);
+  step3[9]  = vec_mergel(step2[4], step2[12]);
+  step3[10] = vec_mergeh(step2[5], step2[13]);
+  step3[11] = vec_mergel(step2[5], step2[13]);
+  step3[12] = vec_mergeh(step2[6], step2[14]);
+  step3[13] = vec_mergel(step2[6], step2[14]);
+  step3[14] = vec_mergeh(step2[7], step2[15]);
+  step3[15] = vec_mergel(step2[7], step2[15]);
+
+  kernel.packet[0]  = vec_mergeh(step3[0], step3[8]);
+  kernel.packet[1]  = vec_mergel(step3[0], step3[8]);
+  kernel.packet[2]  = vec_mergeh(step3[1], step3[9]);
+  kernel.packet[3]  = vec_mergel(step3[1], step3[9]);
+  kernel.packet[4]  = vec_mergeh(step3[2], step3[10]);
+  kernel.packet[5]  = vec_mergel(step3[2], step3[10]);
+  kernel.packet[6]  = vec_mergeh(step3[3], step3[11]);
+  kernel.packet[7]  = vec_mergel(step3[3], step3[11]);
+  kernel.packet[8]  = vec_mergeh(step3[4], step3[12]);
+  kernel.packet[9]  = vec_mergel(step3[4], step3[12]);
+  kernel.packet[10] = vec_mergeh(step3[5], step3[13]);
+  kernel.packet[11] = vec_mergel(step3[5], step3[13]);
+  kernel.packet[12] = vec_mergeh(step3[6], step3[14]);
+  kernel.packet[13] = vec_mergel(step3[6], step3[14]);
+  kernel.packet[14] = vec_mergeh(step3[7], step3[15]);
+  kernel.packet[15] = vec_mergel(step3[7], step3[15]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16uc,16>& kernel) {
+  Packet16uc step1[16], step2[16], step3[16];
+
+  step1[0] = vec_mergeh(kernel.packet[0], kernel.packet[8]);
+  step1[1] = vec_mergel(kernel.packet[0], kernel.packet[8]);
+  step1[2] = vec_mergeh(kernel.packet[1], kernel.packet[9]);
+  step1[3] = vec_mergel(kernel.packet[1], kernel.packet[9]);
+  step1[4] = vec_mergeh(kernel.packet[2], kernel.packet[10]);
+  step1[5] = vec_mergel(kernel.packet[2], kernel.packet[10]);
+  step1[6] = vec_mergeh(kernel.packet[3], kernel.packet[11]);
+  step1[7] = vec_mergel(kernel.packet[3], kernel.packet[11]);
+  step1[8] = vec_mergeh(kernel.packet[4], kernel.packet[12]);
+  step1[9] = vec_mergel(kernel.packet[4], kernel.packet[12]);
+  step1[10] = vec_mergeh(kernel.packet[5], kernel.packet[13]);
+  step1[11] = vec_mergel(kernel.packet[5], kernel.packet[13]);
+  step1[12] = vec_mergeh(kernel.packet[6], kernel.packet[14]);
+  step1[13] = vec_mergel(kernel.packet[6], kernel.packet[14]);
+  step1[14] = vec_mergeh(kernel.packet[7], kernel.packet[15]);
+  step1[15] = vec_mergel(kernel.packet[7], kernel.packet[15]);
+
+  step2[0]  = vec_mergeh(step1[0], step1[8]);
+  step2[1]  = vec_mergel(step1[0], step1[8]);
+  step2[2]  = vec_mergeh(step1[1], step1[9]);
+  step2[3]  = vec_mergel(step1[1], step1[9]);
+  step2[4]  = vec_mergeh(step1[2], step1[10]);
+  step2[5]  = vec_mergel(step1[2], step1[10]);
+  step2[6]  = vec_mergeh(step1[3], step1[11]);
+  step2[7]  = vec_mergel(step1[3], step1[11]);
+  step2[8]  = vec_mergeh(step1[4], step1[12]);
+  step2[9]  = vec_mergel(step1[4], step1[12]);
+  step2[10] = vec_mergeh(step1[5], step1[13]);
+  step2[11] = vec_mergel(step1[5], step1[13]);
+  step2[12] = vec_mergeh(step1[6], step1[14]);
+  step2[13] = vec_mergel(step1[6], step1[14]);
+  step2[14] = vec_mergeh(step1[7], step1[15]);
+  step2[15] = vec_mergel(step1[7], step1[15]);
+
+  step3[0]  = vec_mergeh(step2[0], step2[8]);
+  step3[1]  = vec_mergel(step2[0], step2[8]);
+  step3[2]  = vec_mergeh(step2[1], step2[9]);
+  step3[3]  = vec_mergel(step2[1], step2[9]);
+  step3[4]  = vec_mergeh(step2[2], step2[10]);
+  step3[5]  = vec_mergel(step2[2], step2[10]);
+  step3[6]  = vec_mergeh(step2[3], step2[11]);
+  step3[7]  = vec_mergel(step2[3], step2[11]);
+  step3[8]  = vec_mergeh(step2[4], step2[12]);
+  step3[9]  = vec_mergel(step2[4], step2[12]);
+  step3[10] = vec_mergeh(step2[5], step2[13]);
+  step3[11] = vec_mergel(step2[5], step2[13]);
+  step3[12] = vec_mergeh(step2[6], step2[14]);
+  step3[13] = vec_mergel(step2[6], step2[14]);
+  step3[14] = vec_mergeh(step2[7], step2[15]);
+  step3[15] = vec_mergel(step2[7], step2[15]);
+
+  kernel.packet[0]  = vec_mergeh(step3[0], step3[8]);
+  kernel.packet[1]  = vec_mergel(step3[0], step3[8]);
+  kernel.packet[2]  = vec_mergeh(step3[1], step3[9]);
+  kernel.packet[3]  = vec_mergel(step3[1], step3[9]);
+  kernel.packet[4]  = vec_mergeh(step3[2], step3[10]);
+  kernel.packet[5]  = vec_mergel(step3[2], step3[10]);
+  kernel.packet[6]  = vec_mergeh(step3[3], step3[11]);
+  kernel.packet[7]  = vec_mergel(step3[3], step3[11]);
+  kernel.packet[8]  = vec_mergeh(step3[4], step3[12]);
+  kernel.packet[9]  = vec_mergel(step3[4], step3[12]);
+  kernel.packet[10] = vec_mergeh(step3[5], step3[13]);
+  kernel.packet[11] = vec_mergel(step3[5], step3[13]);
+  kernel.packet[12] = vec_mergeh(step3[6], step3[14]);
+  kernel.packet[13] = vec_mergel(step3[6], step3[14]);
+  kernel.packet[14] = vec_mergeh(step3[7], step3[15]);
+  kernel.packet[15] = vec_mergel(step3[7], step3[15]);
+}
+
+template<typename Packet> EIGEN_STRONG_INLINE
+Packet pblend4(const Selector<4>& ifPacket, const Packet& thenPacket, const Packet& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
+  Packet4ui mask = reinterpret_cast<Packet4ui>(vec_cmpeq(reinterpret_cast<Packet4ui>(select), reinterpret_cast<Packet4ui>(p4i_ONE)));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket) {
+  return pblend4<Packet4i>(ifPacket, thenPacket, elsePacket);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  return pblend4<Packet4f>(ifPacket, thenPacket, elsePacket);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8s pblend(const Selector<8>& ifPacket, const Packet8s& thenPacket, const Packet8s& elsePacket) {
+  Packet8us select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3],
+                       ifPacket.select[4], ifPacket.select[5], ifPacket.select[6], ifPacket.select[7] };
+  Packet8us mask = reinterpret_cast<Packet8us>(vec_cmpeq(select, p8us_ONE));
+  Packet8s result = vec_sel(elsePacket, thenPacket, mask);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us pblend(const Selector<8>& ifPacket, const Packet8us& thenPacket, const Packet8us& elsePacket) {
+  Packet8us select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3],
+                       ifPacket.select[4], ifPacket.select[5], ifPacket.select[6], ifPacket.select[7] };
+  Packet8us mask = reinterpret_cast<Packet8us>(vec_cmpeq(reinterpret_cast<Packet8us>(select), p8us_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pblend(const Selector<8>& ifPacket, const Packet8bf& thenPacket, const Packet8bf& elsePacket) {
+  return pblend<Packet8us>(ifPacket, thenPacket, elsePacket);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16c pblend(const Selector<16>& ifPacket, const Packet16c& thenPacket, const Packet16c& elsePacket) {
+  Packet16uc select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3],
+                       ifPacket.select[4], ifPacket.select[5], ifPacket.select[6], ifPacket.select[7],
+                       ifPacket.select[8], ifPacket.select[9], ifPacket.select[10], ifPacket.select[11],
+                       ifPacket.select[12], ifPacket.select[13], ifPacket.select[14], ifPacket.select[15] };
+
+  Packet16uc mask = reinterpret_cast<Packet16uc>(vec_cmpeq(reinterpret_cast<Packet16uc>(select), p16uc_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16uc pblend(const Selector<16>& ifPacket, const Packet16uc& thenPacket, const Packet16uc& elsePacket) {
+  Packet16uc select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3],
+                       ifPacket.select[4], ifPacket.select[5], ifPacket.select[6], ifPacket.select[7],
+                       ifPacket.select[8], ifPacket.select[9], ifPacket.select[10], ifPacket.select[11],
+                       ifPacket.select[12], ifPacket.select[13], ifPacket.select[14], ifPacket.select[15] };
+
+  Packet16uc mask = reinterpret_cast<Packet16uc>(vec_cmpeq(reinterpret_cast<Packet16uc>(select), p16uc_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+template <>
+struct type_casting_traits<float, int> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<int, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<bfloat16, unsigned short int> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<unsigned short int, bfloat16> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4i pcast<Packet4f, Packet4i>(const Packet4f& a) {
+  return vec_cts(a,0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4ui pcast<Packet4f, Packet4ui>(const Packet4f& a) {
+  return vec_ctu(a,0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4i, Packet4f>(const Packet4i& a) {
+  return vec_ctf(a,0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4ui, Packet4f>(const Packet4ui& a) {
+  return vec_ctf(a,0);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8us pcast<Packet8bf, Packet8us>(const Packet8bf& a) {
+  Packet4f float_even = Bf16ToF32Even(a);
+  Packet4f float_odd = Bf16ToF32Odd(a);
+  Packet4ui int_even = pcast<Packet4f, Packet4ui>(float_even);
+  Packet4ui int_odd = pcast<Packet4f, Packet4ui>(float_odd);
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(low_mask, 0x0000FFFF);
+  Packet4ui low_even = pand<Packet4ui>(int_even, p4ui_low_mask);
+  Packet4ui low_odd = pand<Packet4ui>(int_odd, p4ui_low_mask);
+
+  //Check values that are bigger than USHRT_MAX (0xFFFF)
+  Packet4bi overflow_selector;
+  if(vec_any_gt(int_even, p4ui_low_mask)){
+    overflow_selector = vec_cmpgt(int_even, p4ui_low_mask);
+    low_even = vec_sel(low_even, p4ui_low_mask, overflow_selector);
+  }
+  if(vec_any_gt(int_odd, p4ui_low_mask)){
+    overflow_selector = vec_cmpgt(int_odd, p4ui_low_mask);
+    low_odd = vec_sel(low_even, p4ui_low_mask, overflow_selector);
+  }
+
+  low_odd = plogical_shift_left<16>(low_odd);
+
+  Packet4ui int_final = por<Packet4ui>(low_even, low_odd);
+  return reinterpret_cast<Packet8us>(int_final);
+}
+
+template<> EIGEN_STRONG_INLINE Packet8bf pcast<Packet8us, Packet8bf>(const Packet8us& a) {
+  //short -> int -> float -> bfloat16
+  const _EIGEN_DECLARE_CONST_FAST_Packet4ui(low_mask, 0x0000FFFF);
+  Packet4ui int_cast = reinterpret_cast<Packet4ui>(a);
+  Packet4ui int_even = pand<Packet4ui>(int_cast, p4ui_low_mask);
+  Packet4ui int_odd = plogical_shift_right<16>(int_cast);
+  Packet4f float_even = pcast<Packet4ui, Packet4f>(int_even);
+  Packet4f float_odd = pcast<Packet4ui, Packet4f>(int_odd);
+  return F32ToBf16(float_even, float_odd);
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i,Packet4f>(const Packet4f& a) {
+  return reinterpret_cast<Packet4i>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f,Packet4i>(const Packet4i& a) {
+  return reinterpret_cast<Packet4f>(a);
+}
+
+
+
+//---------- double ----------
+#ifdef __VSX__
+typedef __vector double              Packet2d;
+typedef __vector unsigned long long  Packet2ul;
+typedef __vector long long           Packet2l;
+#if EIGEN_COMP_CLANG
+typedef Packet2ul                    Packet2bl;
+#else
+typedef __vector __bool long         Packet2bl;
+#endif
+
+static Packet2l  p2l_ONE  = { 1, 1 };
+static Packet2l  p2l_ZERO = reinterpret_cast<Packet2l>(p4i_ZERO);
+static Packet2ul p2ul_SIGN = { 0x8000000000000000ull, 0x8000000000000000ull };
+static Packet2ul p2ul_PREV0DOT5 = { 0x3FDFFFFFFFFFFFFFull, 0x3FDFFFFFFFFFFFFFull };
+static Packet2d  p2d_ONE  = { 1.0, 1.0 };
+static Packet2d  p2d_ZERO = reinterpret_cast<Packet2d>(p4f_ZERO);
+static Packet2d  p2d_MZERO = { numext::bit_cast<double>(0x8000000000000000ull),
+                               numext::bit_cast<double>(0x8000000000000000ull) };
+
+#ifdef _BIG_ENDIAN
+static Packet2d p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(p2d_ZERO), reinterpret_cast<Packet4f>(p2d_ONE), 8));
+#else
+static Packet2d p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(p2d_ONE), reinterpret_cast<Packet4f>(p2d_ZERO), 8));
+#endif
+
+template<int index> Packet2d vec_splat_dbl(Packet2d& a)
+{
+  return vec_splat(a, index);
+}
+
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 1,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasMin  = 1,
+    HasMax  = 1,
+    HasAbs  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 0,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet2d half; };
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2l & v)
+{
+  union {
+    Packet2l   v;
+    int64_t n[2];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2d & v)
+{
+  union {
+    Packet2d   v;
+    double n[2];
+  } vt;
+  vt.v = v;
+  s << vt.n[0] << ", " << vt.n[1];
+  return s;
+}
+
+// Need to define them first or we get specialization after instantiation errors
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD
+  return vec_xl(0, const_cast<double *>(from)); // cast needed by Clang
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<double>(double*   to, const Packet2d& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE
+  vec_xst(from, 0, to);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double&  from) {
+  Packet2d v = {from, from};
+  return v;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pset1frombits<Packet2d>(unsigned long from) {
+  Packet2l v = {static_cast<long long>(from), static_cast<long long>(from)};
+  return reinterpret_cast<Packet2d>(v);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet2d>(const double *a,
+                      Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+  //This way is faster than vec_splat (at least for doubles in Power 9)
+  a0 = pset1<Packet2d>(a[0]);
+  a1 = pset1<Packet2d>(a[1]);
+  a2 = pset1<Packet2d>(a[2]);
+  a3 = pset1<Packet2d>(a[3]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+  EIGEN_ALIGN16 double af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+ return pload<Packet2d>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  EIGEN_ALIGN16 double af[2];
+  pstore<double>(af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) { return pset1<Packet2d>(a) + p2d_COUNTDOWN; }
+
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return a + b; }
+
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return a - b; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) { return p2d_ZERO - a; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_madd(a,b,p2d_MZERO); }
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_div(a,b); }
+
+// for some weird raisons, it has to be overloaded for packet of integers
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return vec_madd(a, b, c); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b)
+{
+  // NOTE: about 10% slower than vec_min, but consistent with std::min and SSE regarding NaN
+  Packet2d ret;
+  __asm__ ("xvcmpgedp %x0,%x1,%x2\n\txxsel %x0,%x1,%x2,%x0" : "=&wa" (ret) : "wa" (a), "wa" (b));
+  return ret;
+ }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b)
+{
+  // NOTE: about 10% slower than vec_max, but consistent with std::max and SSE regarding NaN
+  Packet2d ret;
+  __asm__ ("xvcmpgtdp %x0,%x2,%x1\n\txxsel %x0,%x1,%x2,%x0" : "=&wa" (ret) : "wa" (a), "wa" (b));
+  return ret;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_le(const Packet2d& a, const Packet2d& b) { return reinterpret_cast<Packet2d>(vec_cmple(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt(const Packet2d& a, const Packet2d& b) { return reinterpret_cast<Packet2d>(vec_cmplt(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_eq(const Packet2d& a, const Packet2d& b) { return reinterpret_cast<Packet2d>(vec_cmpeq(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan(const Packet2d& a, const Packet2d& b) {
+  Packet2d c = reinterpret_cast<Packet2d>(vec_cmpge(a,b));
+  return vec_nor(c,c);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_or(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_xor(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, vec_nor(b, b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a)
+{
+    Packet2d t = vec_add(reinterpret_cast<Packet2d>(vec_or(vec_and(reinterpret_cast<Packet2ul>(a), p2ul_SIGN), p2ul_PREV0DOT5)), a);
+    Packet2d res;
+
+    __asm__("xvrdpiz %x0, %x1\n\t"
+        : "=&wa" (res)
+        : "wa" (t));
+
+    return res;
+}
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const  Packet2d& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) { return vec_floor(a); }
+template<> EIGEN_STRONG_INLINE Packet2d print<Packet2d>(const Packet2d& a)
+{
+    Packet2d res;
+
+    __asm__("xvrdpic %x0, %x1\n\t"
+        : "=&wa" (res)
+        : "wa" (a));
+
+    return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return vec_xl(0, const_cast<double*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double*   from)
+{
+  Packet2d p;
+  if((std::ptrdiff_t(from) % 16) == 0)  p = pload<Packet2d>(from);
+  else                                  p = ploadu<Packet2d>(from);
+  return vec_splat_dbl<0>(p);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double*  to, const Packet2d& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE
+  vec_xst(from, 0, to);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { EIGEN_PPC_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE double  pfirst<Packet2d>(const Packet2d& a) { EIGEN_ALIGN16 double x[2]; pstore<double>(x, a); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a)
+{
+  return reinterpret_cast<Packet2d>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE64));
+}
+template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a) { return vec_abs(a); }
+
+// VSX support varies between different compilers and even different
+// versions of the same compiler.  For gcc version >= 4.9.3, we can use
+// vec_cts to efficiently convert Packet2d to Packet2l.  Otherwise, use
+// a slow version that works with older compilers. 
+// Update: apparently vec_cts/vec_ctf intrinsics for 64-bit doubles
+// are buggy, https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70963
+template<>
+inline Packet2l pcast<Packet2d, Packet2l>(const Packet2d& x) {
+#if EIGEN_GNUC_AT_LEAST(5, 4) || \
+    (EIGEN_GNUC_AT(6, 1) && __GNUC_PATCHLEVEL__ >= 1)
+  return vec_cts(x, 0);    // TODO: check clang version.
+#else
+  double tmp[2];
+  memcpy(tmp, &x, sizeof(tmp));
+  Packet2l l = { static_cast<long long>(tmp[0]),
+                 static_cast<long long>(tmp[1]) };
+  return l;
+#endif
+}
+
+template<>
+inline Packet2d pcast<Packet2l, Packet2d>(const Packet2l& x) {
+  unsigned long long tmp[2];
+  memcpy(tmp, &x, sizeof(tmp));
+  Packet2d d = { static_cast<double>(tmp[0]),
+                 static_cast<double>(tmp[1]) };
+  return d;
+}
+
+
+// Packet2l shifts.
+// For POWER8 we simply use vec_sr/l. 
+//
+// Things are more complicated for POWER7. There is actually a
+// vec_xxsxdi intrinsic but it is not supported by some gcc versions.
+// So we need to shift by N % 32 and rearrage bytes.
+#ifdef __POWER8_VECTOR__
+
+template<int N>
+EIGEN_STRONG_INLINE Packet2l plogical_shift_left(const Packet2l& a) {
+  const Packet2ul shift = { N, N };
+  return vec_sl(a, shift); 
+}
+
+template<int N>
+EIGEN_STRONG_INLINE Packet2l plogical_shift_right(const Packet2l& a) {
+  const Packet2ul shift = { N, N };
+  return vec_sr(a, shift); 
+}
+
+#else
+
+// Shifts [A, B, C, D] to [B, 0, D, 0].
+// Used to implement left shifts for Packet2l.
+EIGEN_ALWAYS_INLINE Packet4i shift_even_left(const Packet4i& a) {
+  static const Packet16uc perm = {
+      0x14, 0x15, 0x16, 0x17, 0x00, 0x01, 0x02, 0x03, 
+      0x1c, 0x1d, 0x1e, 0x1f, 0x08, 0x09, 0x0a, 0x0b };
+  #ifdef  _BIG_ENDIAN
+    return vec_perm(p4i_ZERO, a, perm);
+  #else
+    return vec_perm(a, p4i_ZERO, perm);
+  #endif
+}
+
+// Shifts [A, B, C, D] to [0, A, 0, C].
+// Used to implement right shifts for Packet2l.
+EIGEN_ALWAYS_INLINE Packet4i shift_odd_right(const Packet4i& a) {
+  static const Packet16uc perm = {
+      0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13, 
+      0x0c, 0x0d, 0x0e, 0x0f, 0x18, 0x19, 0x1a, 0x1b };
+  #ifdef  _BIG_ENDIAN
+    return vec_perm(p4i_ZERO, a, perm);
+  #else
+    return vec_perm(a, p4i_ZERO, perm);
+  #endif
+}
+
+template<int N, typename EnableIf = void>
+struct plogical_shift_left_impl;
+
+template<int N>
+struct plogical_shift_left_impl<N, typename enable_if<(N < 32) && (N >= 0)>::type> {
+  static EIGEN_STRONG_INLINE Packet2l run(const Packet2l& a) {
+    static const unsigned n = static_cast<unsigned>(N);
+    const Packet4ui shift = {n, n, n, n};
+    const Packet4i ai = reinterpret_cast<Packet4i>(a);
+    static const unsigned m = static_cast<unsigned>(32 - N);
+    const Packet4ui shift_right = {m, m, m, m};
+    const Packet4i out_hi = vec_sl(ai, shift);
+    const Packet4i out_lo = shift_even_left(vec_sr(ai, shift_right));
+    return reinterpret_cast<Packet2l>(por<Packet4i>(out_hi, out_lo));
+  }
+};
+
+template<int N>
+struct plogical_shift_left_impl<N, typename enable_if<(N >= 32)>::type> {
+  static EIGEN_STRONG_INLINE Packet2l run(const Packet2l& a) {
+    static const unsigned m = static_cast<unsigned>(N - 32);
+    const Packet4ui shift = {m, m, m, m};
+    const Packet4i ai = reinterpret_cast<Packet4i>(a);
+    return reinterpret_cast<Packet2l>(shift_even_left(vec_sl(ai, shift)));
+  }
+};
+
+template<int N>
+EIGEN_STRONG_INLINE Packet2l plogical_shift_left(const Packet2l& a) {
+  return plogical_shift_left_impl<N>::run(a); 
+}
+
+template<int N, typename EnableIf = void>
+struct plogical_shift_right_impl;
+
+template<int N>
+struct plogical_shift_right_impl<N, typename enable_if<(N < 32) && (N >= 0)>::type> {
+  static EIGEN_STRONG_INLINE Packet2l run(const Packet2l& a) {
+    static const unsigned n = static_cast<unsigned>(N);
+    const Packet4ui shift = {n, n, n, n};
+    const Packet4i ai = reinterpret_cast<Packet4i>(a);
+    static const unsigned m = static_cast<unsigned>(32 - N);
+    const Packet4ui shift_left = {m, m, m, m};
+    const Packet4i out_lo = vec_sr(ai, shift);
+    const Packet4i out_hi = shift_odd_right(vec_sl(ai, shift_left));
+    return reinterpret_cast<Packet2l>(por<Packet4i>(out_hi, out_lo));
+  }
+};
+
+template<int N>
+struct plogical_shift_right_impl<N, typename enable_if<(N >= 32)>::type> {
+  static EIGEN_STRONG_INLINE Packet2l run(const Packet2l& a) {
+    static const unsigned m = static_cast<unsigned>(N - 32);
+    const Packet4ui shift = {m, m, m, m};
+    const Packet4i ai = reinterpret_cast<Packet4i>(a);
+    return reinterpret_cast<Packet2l>(shift_odd_right(vec_sr(ai, shift)));
+  }
+};
+
+template<int N>
+EIGEN_STRONG_INLINE Packet2l plogical_shift_right(const Packet2l& a) {
+  return plogical_shift_right_impl<N>::run(a); 
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d pldexp<Packet2d>(const Packet2d& a, const Packet2d& exponent) {
+  // Clamp exponent to [-2099, 2099]
+  const Packet2d max_exponent = pset1<Packet2d>(2099.0);
+  const Packet2l e = pcast<Packet2d, Packet2l>(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
+
+  // Split 2^e into four factors and multiply:
+  const Packet2l  bias = { 1023, 1023 };
+  Packet2l b = plogical_shift_right<2>(e);  // floor(e/4)
+  Packet2d c = reinterpret_cast<Packet2d>(plogical_shift_left<52>(b + bias));
+  Packet2d out = pmul(pmul(pmul(a, c), c), c); // a * 2^(3b)
+  b = psub(psub(psub(e, b), b), b);  // e - 3b
+  c = reinterpret_cast<Packet2d>(plogical_shift_left<52>(b + bias)); // 2^(e - 3b)
+  out = pmul(out, c); // a * 2^e
+  return out;
+}
+
+
+// Extract exponent without existence of Packet2l.
+template<>
+EIGEN_STRONG_INLINE  
+Packet2d pfrexp_generic_get_biased_exponent(const Packet2d& a) {
+  return pcast<Packet2l, Packet2d>(plogical_shift_right<52>(reinterpret_cast<Packet2l>(pabs(a))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pfrexp<Packet2d> (const Packet2d& a, Packet2d& exponent) {
+  return pfrexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{
+  Packet2d b, sum;
+  b   = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4f>(a), reinterpret_cast<Packet4f>(a), 8));
+  sum = a + b;
+  return pfirst<Packet2d>(sum);
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmul(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(a), reinterpret_cast<Packet4ui>(a), 8))));
+}
+
+// min
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmin(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(a), reinterpret_cast<Packet4ui>(a), 8))));
+}
+
+// max
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmax(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4ui>(a), reinterpret_cast<Packet4ui>(a), 8))));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2d,2>& kernel) {
+  Packet2d t0, t1;
+  t0 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_HI);
+  t1 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_LO);
+  kernel.packet[0] = t0;
+  kernel.packet[1] = t1;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket) {
+  Packet2l select = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2bl mask = reinterpret_cast<Packet2bl>( vec_cmpeq(reinterpret_cast<Packet2d>(select), reinterpret_cast<Packet2d>(p2l_ONE)) );
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+
+#endif // __VSX__
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_ALTIVEC_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/CUDA/Complex.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/CUDA/Complex.h
new file mode 100644
index 00000000..deb4c869
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/CUDA/Complex.h
@@ -0,0 +1,258 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// Copyright (C) 2021 C. Antonio Sanchez <cantonios@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_CUDA_H
+#define EIGEN_COMPLEX_CUDA_H
+
+// clang-format off
+// Many std::complex methods such as operator+, operator-, operator* and
+// operator/ are not constexpr. Due to this, GCC and older versions of clang do
+// not treat them as device functions and thus Eigen functors making use of
+// these operators fail to compile. Here, we manually specialize these
+// operators and functors for complex types when building for CUDA to enable
+// their use on-device.
+
+#if defined(EIGEN_CUDACC) && defined(EIGEN_GPU_COMPILE_PHASE)
+    
+// ICC already specializes std::complex<float> and std::complex<double>
+// operators, preventing us from making them device functions here.
+// This will lead to silent runtime errors if the operators are used on device.
+//
+// To allow std::complex operator use on device, define _OVERRIDE_COMPLEX_SPECIALIZATION_
+// prior to first inclusion of <complex>.  This prevents ICC from adding
+// its own specializations, so our custom ones below can be used instead.
+#if !(defined(EIGEN_COMP_ICC) && defined(_USE_COMPLEX_SPECIALIZATION_))
+
+// Import Eigen's internal operator specializations.
+#define EIGEN_USING_STD_COMPLEX_OPERATORS           \
+  using Eigen::complex_operator_detail::operator+;  \
+  using Eigen::complex_operator_detail::operator-;  \
+  using Eigen::complex_operator_detail::operator*;  \
+  using Eigen::complex_operator_detail::operator/;  \
+  using Eigen::complex_operator_detail::operator+=; \
+  using Eigen::complex_operator_detail::operator-=; \
+  using Eigen::complex_operator_detail::operator*=; \
+  using Eigen::complex_operator_detail::operator/=; \
+  using Eigen::complex_operator_detail::operator==; \
+  using Eigen::complex_operator_detail::operator!=;
+
+namespace Eigen {
+
+// Specialized std::complex overloads.
+namespace complex_operator_detail {
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+std::complex<T> complex_multiply(const std::complex<T>& a, const std::complex<T>& b) {
+  const T a_real = numext::real(a);
+  const T a_imag = numext::imag(a);
+  const T b_real = numext::real(b);
+  const T b_imag = numext::imag(b);
+  return std::complex<T>(
+      a_real * b_real - a_imag * b_imag,
+      a_imag * b_real + a_real * b_imag);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+std::complex<T> complex_divide_fast(const std::complex<T>& a, const std::complex<T>& b) {
+  const T a_real = numext::real(a);
+  const T a_imag = numext::imag(a);
+  const T b_real = numext::real(b);
+  const T b_imag = numext::imag(b);
+  const T norm = (b_real * b_real + b_imag * b_imag);
+  return std::complex<T>((a_real * b_real + a_imag * b_imag) / norm,
+                          (a_imag * b_real - a_real * b_imag) / norm);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+std::complex<T> complex_divide_stable(const std::complex<T>& a, const std::complex<T>& b) {
+  const T a_real = numext::real(a);
+  const T a_imag = numext::imag(a);
+  const T b_real = numext::real(b);
+  const T b_imag = numext::imag(b);
+  // Smith's complex division (https://arxiv.org/pdf/1210.4539.pdf),
+  // guards against over/under-flow.
+  const bool scale_imag = numext::abs(b_imag) <= numext::abs(b_real);
+  const T rscale = scale_imag ? T(1) : b_real / b_imag;
+  const T iscale = scale_imag ? b_imag / b_real : T(1);
+  const T denominator = b_real * rscale + b_imag * iscale;
+  return std::complex<T>((a_real * rscale + a_imag * iscale) / denominator, 
+                         (a_imag * rscale - a_real * iscale) / denominator);
+}
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+std::complex<T> complex_divide(const std::complex<T>& a, const std::complex<T>& b) {
+#if EIGEN_FAST_MATH
+  return complex_divide_fast(a, b);
+#else
+  return complex_divide_stable(a, b);
+#endif
+}
+
+// NOTE: We cannot specialize compound assignment operators with Scalar T,
+//         (i.e.  operator@=(const T&), for @=+,-,*,/)
+//       since they are already specialized for float/double/long double within
+//       the standard <complex> header. We also do not specialize the stream
+//       operators.
+#define EIGEN_CREATE_STD_COMPLEX_OPERATOR_SPECIALIZATIONS(T)                                    \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator+(const std::complex<T>& a) { return a; }                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator-(const std::complex<T>& a) {                                           \
+  return std::complex<T>(-numext::real(a), -numext::imag(a));                                   \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator+(const std::complex<T>& a, const std::complex<T>& b) {                 \
+  return std::complex<T>(numext::real(a) + numext::real(b), numext::imag(a) + numext::imag(b)); \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator+(const std::complex<T>& a, const T& b) {                               \
+  return std::complex<T>(numext::real(a) + b, numext::imag(a));                                 \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator+(const T& a, const std::complex<T>& b) {                               \
+  return std::complex<T>(a + numext::real(b), numext::imag(b));                                 \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator-(const std::complex<T>& a, const std::complex<T>& b) {                 \
+  return std::complex<T>(numext::real(a) - numext::real(b), numext::imag(a) - numext::imag(b)); \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator-(const std::complex<T>& a, const T& b) {                               \
+  return std::complex<T>(numext::real(a) - b, numext::imag(a));                                 \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator-(const T& a, const std::complex<T>& b) {                               \
+  return std::complex<T>(a - numext::real(b), -numext::imag(b));                                \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator*(const std::complex<T>& a, const std::complex<T>& b) {                 \
+  return complex_multiply(a, b);                                                                \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator*(const std::complex<T>& a, const T& b) {                               \
+  return std::complex<T>(numext::real(a) * b, numext::imag(a) * b);                             \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator*(const T& a, const std::complex<T>& b) {                               \
+  return std::complex<T>(a * numext::real(b), a * numext::imag(b));                             \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator/(const std::complex<T>& a, const std::complex<T>& b) {                 \
+  return complex_divide(a, b);                                                                  \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator/(const std::complex<T>& a, const T& b) {                               \
+  return std::complex<T>(numext::real(a) / b, numext::imag(a) / b);                             \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T> operator/(const T& a, const std::complex<T>& b) {                               \
+  return complex_divide(std::complex<T>(a, 0), b);                                              \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T>& operator+=(std::complex<T>& a, const std::complex<T>& b) {                     \
+  numext::real_ref(a) += numext::real(b);                                                       \
+  numext::imag_ref(a) += numext::imag(b);                                                       \
+  return a;                                                                                     \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T>& operator-=(std::complex<T>& a, const std::complex<T>& b) {                     \
+  numext::real_ref(a) -= numext::real(b);                                                       \
+  numext::imag_ref(a) -= numext::imag(b);                                                       \
+  return a;                                                                                     \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T>& operator*=(std::complex<T>& a, const std::complex<T>& b) {                     \
+  a = complex_multiply(a, b);                                                                   \
+  return a;                                                                                     \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+std::complex<T>& operator/=(std::complex<T>& a, const std::complex<T>& b) {                     \
+  a = complex_divide(a, b);                                                                     \
+  return  a;                                                                                    \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator==(const std::complex<T>& a, const std::complex<T>& b) {                           \
+  return numext::real(a) == numext::real(b) && numext::imag(a) == numext::imag(b);              \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator==(const std::complex<T>& a, const T& b) {                                         \
+  return numext::real(a) == b && numext::imag(a) == 0;                                          \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator==(const T& a, const std::complex<T>& b) {                                         \
+  return a  == numext::real(b) && 0 == numext::imag(b);                                         \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator!=(const std::complex<T>& a, const std::complex<T>& b) {                           \
+  return !(a == b);                                                                             \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator!=(const std::complex<T>& a, const T& b) {                                         \
+  return !(a == b);                                                                             \
+}                                                                                               \
+                                                                                                \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE                                                           \
+bool operator!=(const T& a, const std::complex<T>& b) {                                         \
+  return !(a == b);                                                                             \
+}
+
+// Do not specialize for long double, since that reduces to double on device.
+EIGEN_CREATE_STD_COMPLEX_OPERATOR_SPECIALIZATIONS(float)
+EIGEN_CREATE_STD_COMPLEX_OPERATOR_SPECIALIZATIONS(double)
+
+#undef EIGEN_CREATE_STD_COMPLEX_OPERATOR_SPECIALIZATIONS
+
+  
+}  // namespace complex_operator_detail
+
+EIGEN_USING_STD_COMPLEX_OPERATORS
+
+namespace numext {
+EIGEN_USING_STD_COMPLEX_OPERATORS
+}  // namespace numext
+
+namespace internal {
+EIGEN_USING_STD_COMPLEX_OPERATORS
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // !(EIGEN_COMP_ICC && _USE_COMPLEX_SPECIALIZATION_)
+
+#endif  // EIGEN_CUDACC && EIGEN_GPU_COMPILE_PHASE
+
+#endif  // EIGEN_COMPLEX_CUDA_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/BFloat16.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/BFloat16.h
new file mode 100644
index 00000000..1c28f4f9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/BFloat16.h
@@ -0,0 +1,700 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#ifndef EIGEN_BFLOAT16_H
+#define EIGEN_BFLOAT16_H
+
+#define BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, METHOD)         \
+  template <>                                                       \
+  EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED  \
+  PACKET_BF16 METHOD<PACKET_BF16>(const PACKET_BF16& _x) {          \
+    return F32ToBf16(METHOD<PACKET_F>(Bf16ToF32(_x)));              \
+  }
+
+namespace Eigen {
+
+struct bfloat16;
+
+namespace bfloat16_impl {
+
+// Make our own __bfloat16_raw definition.
+struct __bfloat16_raw {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __bfloat16_raw() : value(0) {}
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __bfloat16_raw(unsigned short raw) : value(raw) {}
+  unsigned short value;
+};
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __bfloat16_raw raw_uint16_to_bfloat16(unsigned short value);
+template <bool AssumeArgumentIsNormalOrInfinityOrZero>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw float_to_bfloat16_rtne(float ff);
+// Forward declarations of template specializations, to avoid Visual C++ 2019 errors, saying:
+// > error C2908: explicit specialization; 'float_to_bfloat16_rtne' has already been instantiated
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw float_to_bfloat16_rtne<false>(float ff);
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw float_to_bfloat16_rtne<true>(float ff);
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float bfloat16_to_float(__bfloat16_raw h);
+
+struct bfloat16_base : public __bfloat16_raw {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16_base() {}
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16_base(const __bfloat16_raw& h) : __bfloat16_raw(h) {}
+};
+
+} // namespace bfloat16_impl
+
+// Class definition.
+struct bfloat16 : public bfloat16_impl::bfloat16_base {
+
+  typedef bfloat16_impl::__bfloat16_raw __bfloat16_raw;
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16(const __bfloat16_raw& h) : bfloat16_impl::bfloat16_base(h) {}
+
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16(bool b)
+      : bfloat16_impl::bfloat16_base(bfloat16_impl::raw_uint16_to_bfloat16(b ? 0x3f80 : 0)) {}
+
+  template<class T>
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16(T val)
+      : bfloat16_impl::bfloat16_base(bfloat16_impl::float_to_bfloat16_rtne<internal::is_integral<T>::value>(static_cast<float>(val))) {}
+
+  explicit EIGEN_DEVICE_FUNC bfloat16(float f)
+      : bfloat16_impl::bfloat16_base(bfloat16_impl::float_to_bfloat16_rtne<false>(f)) {}
+
+  // Following the convention of numpy, converting between complex and
+  // float will lead to loss of imag value.
+  template<typename RealScalar>
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16(const std::complex<RealScalar>& val)
+      : bfloat16_impl::bfloat16_base(bfloat16_impl::float_to_bfloat16_rtne<false>(static_cast<float>(val.real()))) {}
+
+  EIGEN_DEVICE_FUNC operator float() const {  // NOLINT: Allow implicit conversion to float, because it is lossless.
+    return bfloat16_impl::bfloat16_to_float(*this);
+  }
+};
+} // namespace Eigen
+
+namespace std {
+template<>
+struct numeric_limits<Eigen::bfloat16> {
+  static const bool is_specialized = true;
+  static const bool is_signed = true;
+  static const bool is_integer = false;
+  static const bool is_exact = false;
+  static const bool has_infinity = true;
+  static const bool has_quiet_NaN = true;
+  static const bool has_signaling_NaN = true;
+  static const float_denorm_style has_denorm = std::denorm_absent;
+  static const bool has_denorm_loss = false;
+  static const std::float_round_style round_style = numeric_limits<float>::round_style;
+  static const bool is_iec559 = false;
+  static const bool is_bounded = true;
+  static const bool is_modulo = false;
+  static const int digits = 8;
+  static const int digits10 = 2;
+  static const int max_digits10 = 4;
+  static const int radix = 2;
+  static const int min_exponent = numeric_limits<float>::min_exponent;
+  static const int min_exponent10 = numeric_limits<float>::min_exponent10;
+  static const int max_exponent = numeric_limits<float>::max_exponent;
+  static const int max_exponent10 = numeric_limits<float>::max_exponent10;
+  static const bool traps = numeric_limits<float>::traps;
+  static const bool tinyness_before = numeric_limits<float>::tinyness_before;
+
+  static Eigen::bfloat16 (min)() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x0080); }
+  static Eigen::bfloat16 lowest() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0xff7f); }
+  static Eigen::bfloat16 (max)() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x7f7f); }
+  static Eigen::bfloat16 epsilon() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x3c00); }
+  static Eigen::bfloat16 round_error() { return Eigen::bfloat16(0x3f00); }
+  static Eigen::bfloat16 infinity() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x7f80); }
+  static Eigen::bfloat16 quiet_NaN() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x7fc0); }
+  static Eigen::bfloat16 signaling_NaN() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x7f81); }
+  static Eigen::bfloat16 denorm_min() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x0001); }
+};
+
+// If std::numeric_limits<T> is specialized, should also specialize
+// std::numeric_limits<const T>, std::numeric_limits<volatile T>, and
+// std::numeric_limits<const volatile T>
+// https://stackoverflow.com/a/16519653/
+template<>
+struct numeric_limits<const Eigen::bfloat16> : numeric_limits<Eigen::bfloat16> {};
+template<>
+struct numeric_limits<volatile Eigen::bfloat16> : numeric_limits<Eigen::bfloat16> {};
+template<>
+struct numeric_limits<const volatile Eigen::bfloat16> : numeric_limits<Eigen::bfloat16> {};
+} // namespace std
+
+namespace Eigen {
+
+namespace bfloat16_impl {
+
+// We need to distinguish ‘clang as the CUDA compiler’ from ‘clang as the host compiler,
+// invoked by NVCC’ (e.g. on MacOS). The former needs to see both host and device implementation
+// of the functions, while the latter can only deal with one of them.
+#if !defined(EIGEN_HAS_NATIVE_BF16) || (EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC) // Emulate support for bfloat16 floats
+
+#if EIGEN_COMP_CLANG && defined(EIGEN_CUDACC)
+// We need to provide emulated *host-side* BF16 operators for clang.
+#pragma push_macro("EIGEN_DEVICE_FUNC")
+#undef EIGEN_DEVICE_FUNC
+#if defined(EIGEN_HAS_CUDA_BF16) && defined(EIGEN_HAS_NATIVE_BF16)
+#define EIGEN_DEVICE_FUNC __host__
+#else // both host and device need emulated ops.
+#define EIGEN_DEVICE_FUNC __host__ __device__
+#endif
+#endif
+
+// Definitions for CPUs, mostly working through conversion
+// to/from fp32.
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator + (const bfloat16& a, const bfloat16& b) {
+  return bfloat16(float(a) + float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator + (const bfloat16& a, const int& b) {
+  return bfloat16(float(a) + static_cast<float>(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator + (const int& a, const bfloat16& b) {
+  return bfloat16(static_cast<float>(a) + float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator * (const bfloat16& a, const bfloat16& b) {
+  return bfloat16(float(a) * float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator - (const bfloat16& a, const bfloat16& b) {
+  return bfloat16(float(a) - float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator / (const bfloat16& a, const bfloat16& b) {
+  return bfloat16(float(a) / float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator - (const bfloat16& a) {
+  bfloat16 result;
+  result.value = a.value ^ 0x8000;
+  return result;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16& operator += (bfloat16& a, const bfloat16& b) {
+  a = bfloat16(float(a) + float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16& operator *= (bfloat16& a, const bfloat16& b) {
+  a = bfloat16(float(a) * float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16& operator -= (bfloat16& a, const bfloat16& b) {
+  a = bfloat16(float(a) - float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16& operator /= (bfloat16& a, const bfloat16& b) {
+  a = bfloat16(float(a) / float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator++(bfloat16& a) {
+  a += bfloat16(1);
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator--(bfloat16& a) {
+  a -= bfloat16(1);
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator++(bfloat16& a, int) {
+  bfloat16 original_value = a;
+  ++a;
+  return original_value;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator--(bfloat16& a, int) {
+  bfloat16 original_value = a;
+  --a;
+  return original_value;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator == (const bfloat16& a, const bfloat16& b) {
+  return numext::equal_strict(float(a),float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator != (const bfloat16& a, const bfloat16& b) {
+  return numext::not_equal_strict(float(a), float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator < (const bfloat16& a, const bfloat16& b) {
+  return float(a) < float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator <= (const bfloat16& a, const bfloat16& b) {
+  return float(a) <= float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator > (const bfloat16& a, const bfloat16& b) {
+  return float(a) > float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator >= (const bfloat16& a, const bfloat16& b) {
+  return float(a) >= float(b);
+}
+
+#if EIGEN_COMP_CLANG && defined(EIGEN_CUDACC)
+#pragma pop_macro("EIGEN_DEVICE_FUNC")
+#endif
+#endif  // Emulate support for bfloat16 floats
+
+// Division by an index. Do it in full float precision to avoid accuracy
+// issues in converting the denominator to bfloat16.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator / (const bfloat16& a, Index b) {
+  return bfloat16(static_cast<float>(a) / static_cast<float>(b));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw truncate_to_bfloat16(const float v) {
+  __bfloat16_raw output;
+  if (Eigen::numext::isnan EIGEN_NOT_A_MACRO(v)) {
+    output.value = std::signbit(v) ? 0xFFC0: 0x7FC0;
+    return output;
+  }
+  const uint16_t* p = reinterpret_cast<const uint16_t*>(&v);
+#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+  output.value = p[0];
+#else
+  output.value = p[1];
+#endif
+  return output;
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __bfloat16_raw raw_uint16_to_bfloat16(numext::uint16_t value) {
+  return __bfloat16_raw(value);
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR numext::uint16_t raw_bfloat16_as_uint16(const __bfloat16_raw& bf) {
+  return bf.value;
+}
+
+// float_to_bfloat16_rtne template specialization that does not make any
+// assumption about the value of its function argument (ff).
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw float_to_bfloat16_rtne<false>(float ff) {
+#if (defined(EIGEN_HAS_CUDA_BF16) && defined(EIGEN_HAS_HIP_BF16))
+  // Nothing to do here
+#else
+  __bfloat16_raw output;
+
+  if (Eigen::numext::isnan EIGEN_NOT_A_MACRO(ff)) {
+    // If the value is a NaN, squash it to a qNaN with msb of fraction set,
+    // this makes sure after truncation we don't end up with an inf.
+    //
+    // qNaN magic: All exponent bits set + most significant bit of fraction
+    // set.
+    output.value = std::signbit(ff) ? 0xFFC0: 0x7FC0;
+  } else {
+    // Fast rounding algorithm that rounds a half value to nearest even. This
+    // reduces expected error when we convert a large number of floats. Here
+    // is how it works:
+    //
+    // Definitions:
+    // To convert a float 32 to bfloat16, a float 32 can be viewed as 32 bits
+    // with the following tags:
+    //
+    // Sign |  Exp (8 bits) | Frac (23 bits)
+    //  S     EEEEEEEE         FFFFFFLRTTTTTTTTTTTTTTT
+    //
+    //  S: Sign bit.
+    //  E: Exponent bits.
+    //  F: First 6 bits of fraction.
+    //  L: Least significant bit of resulting bfloat16 if we truncate away the
+    //  rest of the float32. This is also the 7th bit of fraction
+    //  R: Rounding bit, 8th bit of fraction.
+    //  T: Sticky bits, rest of fraction, 15 bits.
+    //
+    // To round half to nearest even, there are 3 cases where we want to round
+    // down (simply truncate the result of the bits away, which consists of
+    // rounding bit and sticky bits) and two cases where we want to round up
+    // (truncate then add one to the result).
+    //
+    // The fast converting algorithm simply adds lsb (L) to 0x7fff (15 bits of
+    // 1s) as the rounding bias, adds the rounding bias to the input, then
+    // truncates the last 16 bits away.
+    //
+    // To understand how it works, we can analyze this algorithm case by case:
+    //
+    // 1. L = 0, R = 0:
+    //   Expect: round down, this is less than half value.
+    //
+    //   Algorithm:
+    //   - Rounding bias: 0x7fff + 0 = 0x7fff
+    //   - Adding rounding bias to input may create any carry, depending on
+    //   whether there is any value set to 1 in T bits.
+    //   - R may be set to 1 if there is a carry.
+    //   - L remains 0.
+    //   - Note that this case also handles Inf and -Inf, where all fraction
+    //   bits, including L, R and Ts are all 0. The output remains Inf after
+    //   this algorithm.
+    //
+    // 2. L = 1, R = 0:
+    //   Expect: round down, this is less than half value.
+    //
+    //   Algorithm:
+    //   - Rounding bias: 0x7fff + 1 = 0x8000
+    //   - Adding rounding bias to input doesn't change sticky bits but
+    //   adds 1 to rounding bit.
+    //   - L remains 1.
+    //
+    // 3. L = 0, R = 1, all of T are 0:
+    //   Expect: round down, this is exactly at half, the result is already
+    //   even (L=0).
+    //
+    //   Algorithm:
+    //   - Rounding bias: 0x7fff + 0 = 0x7fff
+    //   - Adding rounding bias to input sets all sticky bits to 1, but
+    //   doesn't create a carry.
+    //   - R remains 1.
+    //   - L remains 0.
+    //
+    // 4. L = 1, R = 1:
+    //   Expect: round up, this is exactly at half, the result needs to be
+    //   round to the next even number.
+    //
+    //   Algorithm:
+    //   - Rounding bias: 0x7fff + 1 = 0x8000
+    //   - Adding rounding bias to input doesn't change sticky bits, but
+    //   creates a carry from rounding bit.
+    //   - The carry sets L to 0, creates another carry bit and propagate
+    //   forward to F bits.
+    //   - If all the F bits are 1, a carry then propagates to the exponent
+    //   bits, which then creates the minimum value with the next exponent
+    //   value. Note that we won't have the case where exponents are all 1,
+    //   since that's either a NaN (handled in the other if condition) or inf
+    //   (handled in case 1).
+    //
+    // 5. L = 0, R = 1, any of T is 1:
+    //   Expect: round up, this is greater than half.
+    //
+    //   Algorithm:
+    //   - Rounding bias: 0x7fff + 0 = 0x7fff
+    //   - Adding rounding bias to input creates a carry from sticky bits,
+    //   sets rounding bit to 0, then create another carry.
+    //   - The second carry sets L to 1.
+    //
+    // Examples:
+    //
+    //  Exact half value that is already even:
+    //    Input:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit) | Frac (last 16 bit)
+    //     S     E E E E E E E E      F F F F F F L     RTTTTTTTTTTTTTTT
+    //     0     0 0 0 0 0 0 0 0      0 0 0 0 0 1 0     1000000000000000
+    //
+    //     This falls into case 3. We truncate the rest of 16 bits and no
+    //     carry is created into F and L:
+    //
+    //    Output:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit)
+    //     S     E E E E E E E E      F F F F F F L
+    //     0     0 0 0 0 0 0 0 0      0 0 0 0 0 1 0
+    //
+    //  Exact half value, round to next even number:
+    //    Input:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit) | Frac (last 16 bit)
+    //     S     E E E E E E E E      F F F F F F L     RTTTTTTTTTTTTTTT
+    //     0     0 0 0 0 0 0 0 0      0 0 0 0 0 0 1     1000000000000000
+    //
+    //     This falls into case 4. We create a carry from R and T,
+    //     which then propagates into L and F:
+    //
+    //    Output:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit)
+    //     S     E E E E E E E E      F F F F F F L
+    //     0     0 0 0 0 0 0 0 0      0 0 0 0 0 1 0
+    //
+    //
+    //  Max denormal value round to min normal value:
+    //    Input:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit) | Frac (last 16 bit)
+    //     S     E E E E E E E E      F F F F F F L     RTTTTTTTTTTTTTTT
+    //     0     0 0 0 0 0 0 0 0      1 1 1 1 1 1 1     1111111111111111
+    //
+    //     This falls into case 4. We create a carry from R and T,
+    //     propagate into L and F, which then propagates into exponent
+    //     bits:
+    //
+    //    Output:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit)
+    //     S     E E E E E E E E      F F F F F F L
+    //     0     0 0 0 0 0 0 0 1      0 0 0 0 0 0 0
+    //
+    //  Max normal value round to Inf:
+    //    Input:
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit) | Frac (last 16 bit)
+    //     S     E E E E E E E E      F F F F F F L     RTTTTTTTTTTTTTTT
+    //     0     1 1 1 1 1 1 1 0      1 1 1 1 1 1 1     1111111111111111
+    //
+    //     This falls into case 4. We create a carry from R and T,
+    //     propagate into L and F, which then propagates into exponent
+    //     bits:
+    //
+    //    Sign |  Exp (8 bit)     | Frac (first 7 bit)
+    //     S     E E E E E E E E      F F F F F F L
+    //     0     1 1 1 1 1 1 1 1      0 0 0 0 0 0 0
+
+    // At this point, ff must be either a normal float, or +/-infinity.
+    output = float_to_bfloat16_rtne<true>(ff);
+  }
+  return output;
+#endif
+}
+
+// float_to_bfloat16_rtne template specialization that assumes that its function
+// argument (ff) is either a normal floating point number, or +/-infinity, or
+// zero. Used to improve the runtime performance of conversion from an integer
+// type to bfloat16.
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __bfloat16_raw float_to_bfloat16_rtne<true>(float ff) {
+#if (defined(EIGEN_HAS_CUDA_BF16) && defined(EIGEN_HAS_HIP_BF16))
+    // Nothing to do here
+#else
+    numext::uint32_t input = numext::bit_cast<numext::uint32_t>(ff);
+    __bfloat16_raw output;
+
+    // Least significant bit of resulting bfloat.
+    numext::uint32_t lsb = (input >> 16) & 1;
+    numext::uint32_t rounding_bias = 0x7fff + lsb;
+    input += rounding_bias;
+    output.value = static_cast<numext::uint16_t>(input >> 16);
+    return output;
+#endif
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float bfloat16_to_float(__bfloat16_raw h) {
+    float result = 0;
+    unsigned short* q = reinterpret_cast<unsigned short*>(&result);
+#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    q[0] = h.value;
+#else
+    q[1] = h.value;
+#endif
+    return result;
+}
+// --- standard functions ---
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isinf)(const bfloat16& a) {
+  EIGEN_USING_STD(isinf);
+  return (isinf)(float(a));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isnan)(const bfloat16& a) {
+  EIGEN_USING_STD(isnan);
+  return (isnan)(float(a));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isfinite)(const bfloat16& a) {
+  return !(isinf EIGEN_NOT_A_MACRO (a)) && !(isnan EIGEN_NOT_A_MACRO (a));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 abs(const bfloat16& a) {
+  bfloat16 result;
+  result.value = a.value & 0x7FFF;
+  return result;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 exp(const bfloat16& a) {
+   return bfloat16(::expf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 expm1(const bfloat16& a) {
+  return bfloat16(numext::expm1(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log(const bfloat16& a) {
+  return bfloat16(::logf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log1p(const bfloat16& a) {
+  return bfloat16(numext::log1p(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log10(const bfloat16& a) {
+  return bfloat16(::log10f(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log2(const bfloat16& a) {
+  return bfloat16(static_cast<float>(EIGEN_LOG2E) * ::logf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 sqrt(const bfloat16& a) {
+    return bfloat16(::sqrtf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 pow(const bfloat16& a, const bfloat16& b) {
+  return bfloat16(::powf(float(a), float(b)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 sin(const bfloat16& a) {
+  return bfloat16(::sinf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 cos(const bfloat16& a) {
+  return bfloat16(::cosf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 tan(const bfloat16& a) {
+  return bfloat16(::tanf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 asin(const bfloat16& a) {
+  return bfloat16(::asinf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 acos(const bfloat16& a) {
+  return bfloat16(::acosf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 atan(const bfloat16& a) {
+  return bfloat16(::atanf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 sinh(const bfloat16& a) {
+  return bfloat16(::sinhf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 cosh(const bfloat16& a) {
+  return bfloat16(::coshf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 tanh(const bfloat16& a) {
+  return bfloat16(::tanhf(float(a)));
+}
+#if EIGEN_HAS_CXX11_MATH
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 asinh(const bfloat16& a) {
+  return bfloat16(::asinhf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 acosh(const bfloat16& a) {
+  return bfloat16(::acoshf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 atanh(const bfloat16& a) {
+  return bfloat16(::atanhf(float(a)));
+}
+#endif
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 floor(const bfloat16& a) {
+  return bfloat16(::floorf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 ceil(const bfloat16& a) {
+  return bfloat16(::ceilf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 rint(const bfloat16& a) {
+  return bfloat16(::rintf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 round(const bfloat16& a) {
+  return bfloat16(::roundf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 fmod(const bfloat16& a, const bfloat16& b) {
+  return bfloat16(::fmodf(float(a), float(b)));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 (min)(const bfloat16& a, const bfloat16& b) {
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return f2 < f1 ? b : a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 (max)(const bfloat16& a, const bfloat16& b) {
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return f1 < f2 ? b : a;
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 fmin(const bfloat16& a, const bfloat16& b) {
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return bfloat16(::fminf(f1, f2));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 fmax(const bfloat16& a, const bfloat16& b) {
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return bfloat16(::fmaxf(f1, f2));
+}
+
+#ifndef EIGEN_NO_IO
+EIGEN_ALWAYS_INLINE std::ostream& operator << (std::ostream& os, const bfloat16& v) {
+  os << static_cast<float>(v);
+  return os;
+}
+#endif
+
+} // namespace bfloat16_impl
+
+namespace internal {
+
+template<>
+struct random_default_impl<bfloat16, false, false>
+{
+  static inline bfloat16 run(const bfloat16& x, const bfloat16& y)
+  {
+    return x + (y-x) * bfloat16(float(std::rand()) / float(RAND_MAX));
+  }
+  static inline bfloat16 run()
+  {
+    return run(bfloat16(-1.f), bfloat16(1.f));
+  }
+};
+
+template<> struct is_arithmetic<bfloat16> { enum { value = true }; };
+
+} // namespace internal
+
+template<> struct NumTraits<Eigen::bfloat16>
+    : GenericNumTraits<Eigen::bfloat16>
+{
+  enum {
+    IsSigned = true,
+    IsInteger = false,
+    IsComplex = false,
+    RequireInitialization = false
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 epsilon() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0x3c00);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 dummy_precision() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0x3D4D);  // bfloat16(5e-2f);
+
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 highest() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0x7F7F);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 lowest() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0xFF7F);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 infinity() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0x7f80);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::bfloat16 quiet_NaN() {
+    return bfloat16_impl::raw_uint16_to_bfloat16(0x7fc0);
+  }
+};
+
+} // namespace Eigen
+
+namespace Eigen {
+namespace numext {
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+bool (isnan)(const Eigen::bfloat16& h) {
+  return (bfloat16_impl::isnan)(h);
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+bool (isinf)(const Eigen::bfloat16& h) {
+  return (bfloat16_impl::isinf)(h);
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+bool (isfinite)(const Eigen::bfloat16& h) {
+  return (bfloat16_impl::isfinite)(h);
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bit_cast<Eigen::bfloat16, uint16_t>(const uint16_t& src) {
+  return Eigen::bfloat16(Eigen::bfloat16_impl::raw_uint16_to_bfloat16(src));
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC uint16_t bit_cast<uint16_t, Eigen::bfloat16>(const Eigen::bfloat16& src) {
+  return Eigen::bfloat16_impl::raw_bfloat16_as_uint16(src);
+}
+
+}  // namespace numext
+}  // namespace Eigen
+
+#if EIGEN_HAS_STD_HASH
+namespace std {
+template <>
+struct hash<Eigen::bfloat16> {
+  EIGEN_STRONG_INLINE std::size_t operator()(const Eigen::bfloat16& a) const {
+    return static_cast<std::size_t>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(a));
+  }
+};
+} // namespace std
+#endif
+
+
+#endif // EIGEN_BFLOAT16_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/ConjHelper.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/ConjHelper.h
new file mode 100644
index 00000000..53830b5a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/ConjHelper.h
@@ -0,0 +1,117 @@
+
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARCH_CONJ_HELPER_H
+#define EIGEN_ARCH_CONJ_HELPER_H
+
+#define EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(PACKET_CPLX, PACKET_REAL)      \
+  template <>                                                           \
+  struct conj_helper<PACKET_REAL, PACKET_CPLX, false, false> {          \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmadd(const PACKET_REAL& x,         \
+                                          const PACKET_CPLX& y,         \
+                                          const PACKET_CPLX& c) const { \
+      return padd(c, this->pmul(x, y));                                 \
+    }                                                                   \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmul(const PACKET_REAL& x,          \
+                                         const PACKET_CPLX& y) const {  \
+      return PACKET_CPLX(Eigen::internal::pmul<PACKET_REAL>(x, y.v));   \
+    }                                                                   \
+  };                                                                    \
+                                                                        \
+  template <>                                                           \
+  struct conj_helper<PACKET_CPLX, PACKET_REAL, false, false> {          \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmadd(const PACKET_CPLX& x,         \
+                                          const PACKET_REAL& y,         \
+                                          const PACKET_CPLX& c) const { \
+      return padd(c, this->pmul(x, y));                                 \
+    }                                                                   \
+    EIGEN_STRONG_INLINE PACKET_CPLX pmul(const PACKET_CPLX& x,          \
+                                         const PACKET_REAL& y) const {  \
+      return PACKET_CPLX(Eigen::internal::pmul<PACKET_REAL>(x.v, y));   \
+    }                                                                   \
+  };
+
+namespace Eigen {
+namespace internal {
+
+template<bool Conjugate> struct conj_if;
+
+template<> struct conj_if<true> {
+  template<typename T>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x) const { return numext::conj(x); }
+  template<typename T>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T pconj(const T& x) const { return internal::pconj(x); }
+};
+
+template<> struct conj_if<false> {
+  template<typename T>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T& operator()(const T& x) const { return x; }
+  template<typename T>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T& pconj(const T& x) const { return x; }
+};
+
+// Generic Implementation, assume scalars since the packet-version is
+// specialized below.
+template<typename LhsType, typename RhsType, bool ConjLhs, bool ConjRhs>
+struct conj_helper {
+  typedef typename ScalarBinaryOpTraits<LhsType, RhsType>::ReturnType ResultType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType
+  pmadd(const LhsType& x, const RhsType& y, const ResultType& c) const
+  { return this->pmul(x, y) + c; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType
+  pmul(const LhsType& x, const RhsType& y) const
+  { return conj_if<ConjLhs>()(x) * conj_if<ConjRhs>()(y); }
+};
+
+template<typename LhsScalar, typename RhsScalar>
+struct conj_helper<LhsScalar, RhsScalar, true, true> {
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar>::ReturnType ResultType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType
+  pmadd(const LhsScalar& x, const RhsScalar& y, const ResultType& c) const
+  { return this->pmul(x, y) + c; }
+
+  // We save a conjuation by using the identity conj(a)*conj(b) = conj(a*b).
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType
+  pmul(const LhsScalar& x, const RhsScalar& y) const
+  { return numext::conj(x * y); }
+};
+
+// Implementation with equal type, use packet operations.
+template<typename Packet, bool ConjLhs, bool ConjRhs>
+struct conj_helper<Packet, Packet, ConjLhs, ConjRhs>
+{
+  typedef Packet ResultType;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmadd(const Packet& x, const Packet& y, const Packet& c) const
+  { return Eigen::internal::pmadd(conj_if<ConjLhs>().pconj(x), conj_if<ConjRhs>().pconj(y), c); }
+
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmul(const Packet& x, const Packet& y) const
+  { return Eigen::internal::pmul(conj_if<ConjLhs>().pconj(x), conj_if<ConjRhs>().pconj(y)); }
+};
+
+template<typename Packet>
+struct conj_helper<Packet, Packet, true, true>
+{
+  typedef Packet ResultType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmadd(const Packet& x, const Packet& y, const Packet& c) const
+  { return Eigen::internal::pmadd(pconj(x), pconj(y), c); }
+  // We save a conjuation by using the identity conj(a)*conj(b) = conj(a*b).
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmul(const Packet& x, const Packet& y) const
+  { return pconj(Eigen::internal::pmul(x, y)); }
+};
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_ARCH_CONJ_HELPER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
new file mode 100644
index 00000000..c9fbaf68
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
@@ -0,0 +1,1649 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+// Copyright (C) 2009-2019 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The exp and log functions of this file initially come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+#ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_H
+#define EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_H
+
+namespace Eigen {
+namespace internal {
+
+// Creates a Scalar integer type with same bit-width.
+template<typename T> struct make_integer;
+template<> struct make_integer<float>    { typedef numext::int32_t type; };
+template<> struct make_integer<double>   { typedef numext::int64_t type; };
+template<> struct make_integer<half>     { typedef numext::int16_t type; };
+template<> struct make_integer<bfloat16> { typedef numext::int16_t type; };
+
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC  
+Packet pfrexp_generic_get_biased_exponent(const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
+  enum { mantissa_bits = numext::numeric_limits<Scalar>::digits - 1};
+  return pcast<PacketI, Packet>(plogical_shift_right<mantissa_bits>(preinterpret<PacketI>(pabs(a))));
+}
+
+// Safely applies frexp, correctly handles denormals.
+// Assumes IEEE floating point format.
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+Packet pfrexp_generic(const Packet& a, Packet& exponent) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  typedef typename make_unsigned<typename make_integer<Scalar>::type>::type ScalarUI;
+  enum {
+    TotalBits = sizeof(Scalar) * CHAR_BIT,
+    MantissaBits = numext::numeric_limits<Scalar>::digits - 1,
+    ExponentBits = int(TotalBits) - int(MantissaBits) - 1
+  };
+
+  EIGEN_CONSTEXPR ScalarUI scalar_sign_mantissa_mask = 
+      ~(((ScalarUI(1) << int(ExponentBits)) - ScalarUI(1)) << int(MantissaBits)); // ~0x7f800000
+  const Packet sign_mantissa_mask = pset1frombits<Packet>(static_cast<ScalarUI>(scalar_sign_mantissa_mask)); 
+  const Packet half = pset1<Packet>(Scalar(0.5));
+  const Packet zero = pzero(a);
+  const Packet normal_min = pset1<Packet>((numext::numeric_limits<Scalar>::min)()); // Minimum normal value, 2^-126
+  
+  // To handle denormals, normalize by multiplying by 2^(int(MantissaBits)+1).
+  const Packet is_denormal = pcmp_lt(pabs(a), normal_min);
+  EIGEN_CONSTEXPR ScalarUI scalar_normalization_offset = ScalarUI(int(MantissaBits) + 1); // 24
+  // The following cannot be constexpr because bfloat16(uint16_t) is not constexpr.
+  const Scalar scalar_normalization_factor = Scalar(ScalarUI(1) << int(scalar_normalization_offset)); // 2^24
+  const Packet normalization_factor = pset1<Packet>(scalar_normalization_factor);  
+  const Packet normalized_a = pselect(is_denormal, pmul(a, normalization_factor), a);
+  
+  // Determine exponent offset: -126 if normal, -126-24 if denormal
+  const Scalar scalar_exponent_offset = -Scalar((ScalarUI(1)<<(int(ExponentBits)-1)) - ScalarUI(2)); // -126
+  Packet exponent_offset = pset1<Packet>(scalar_exponent_offset);
+  const Packet normalization_offset = pset1<Packet>(-Scalar(scalar_normalization_offset)); // -24
+  exponent_offset = pselect(is_denormal, padd(exponent_offset, normalization_offset), exponent_offset);
+  
+  // Determine exponent and mantissa from normalized_a.
+  exponent = pfrexp_generic_get_biased_exponent(normalized_a);
+  // Zero, Inf and NaN return 'a' unmodified, exponent is zero
+  // (technically the exponent is unspecified for inf/NaN, but GCC/Clang set it to zero)
+  const Scalar scalar_non_finite_exponent = Scalar((ScalarUI(1) << int(ExponentBits)) - ScalarUI(1));  // 255
+  const Packet non_finite_exponent = pset1<Packet>(scalar_non_finite_exponent);
+  const Packet is_zero_or_not_finite = por(pcmp_eq(a, zero), pcmp_eq(exponent, non_finite_exponent));
+  const Packet m = pselect(is_zero_or_not_finite, a, por(pand(normalized_a, sign_mantissa_mask), half));
+  exponent = pselect(is_zero_or_not_finite, zero, padd(exponent, exponent_offset));  
+  return m;
+}
+
+// Safely applies ldexp, correctly handles overflows, underflows and denormals.
+// Assumes IEEE floating point format.
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+Packet pldexp_generic(const Packet& a, const Packet& exponent) {
+  // We want to return a * 2^exponent, allowing for all possible integer
+  // exponents without overflowing or underflowing in intermediate
+  // computations.
+  //
+  // Since 'a' and the output can be denormal, the maximum range of 'exponent'
+  // to consider for a float is:
+  //   -255-23 -> 255+23
+  // Below -278 any finite float 'a' will become zero, and above +278 any
+  // finite float will become inf, including when 'a' is the smallest possible 
+  // denormal.
+  //
+  // Unfortunately, 2^(278) cannot be represented using either one or two
+  // finite normal floats, so we must split the scale factor into at least
+  // three parts. It turns out to be faster to split 'exponent' into four
+  // factors, since [exponent>>2] is much faster to compute that [exponent/3].
+  //
+  // Set e = min(max(exponent, -278), 278);
+  //     b = floor(e/4);
+  //   out = ((((a * 2^(b)) * 2^(b)) * 2^(b)) * 2^(e-3*b))
+  //
+  // This will avoid any intermediate overflows and correctly handle 0, inf,
+  // NaN cases.
+  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  typedef typename unpacket_traits<PacketI>::type ScalarI;
+  enum {
+    TotalBits = sizeof(Scalar) * CHAR_BIT,
+    MantissaBits = numext::numeric_limits<Scalar>::digits - 1,
+    ExponentBits = int(TotalBits) - int(MantissaBits) - 1
+  };
+
+  const Packet max_exponent = pset1<Packet>(Scalar((ScalarI(1)<<int(ExponentBits)) + ScalarI(int(MantissaBits) - 1)));  // 278
+  const PacketI bias = pset1<PacketI>((ScalarI(1)<<(int(ExponentBits)-1)) - ScalarI(1));  // 127
+  const PacketI e = pcast<Packet, PacketI>(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
+  PacketI b = parithmetic_shift_right<2>(e); // floor(e/4);
+  Packet c = preinterpret<Packet>(plogical_shift_left<int(MantissaBits)>(padd(b, bias)));  // 2^b
+  Packet out = pmul(pmul(pmul(a, c), c), c);  // a * 2^(3b)
+  b = psub(psub(psub(e, b), b), b); // e - 3b
+  c = preinterpret<Packet>(plogical_shift_left<int(MantissaBits)>(padd(b, bias)));  // 2^(e-3*b)
+  out = pmul(out, c);
+  return out;
+}
+
+// Explicitly multiplies 
+//    a * (2^e)
+// clamping e to the range
+// [NumTraits<Scalar>::min_exponent()-2, NumTraits<Scalar>::max_exponent()]
+//
+// This is approx 7x faster than pldexp_impl, but will prematurely over/underflow
+// if 2^e doesn't fit into a normal floating-point Scalar.
+//
+// Assumes IEEE floating point format
+template<typename Packet>
+struct pldexp_fast_impl {
+  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  typedef typename unpacket_traits<PacketI>::type ScalarI;
+  enum {
+    TotalBits = sizeof(Scalar) * CHAR_BIT,
+    MantissaBits = numext::numeric_limits<Scalar>::digits - 1,
+    ExponentBits = int(TotalBits) - int(MantissaBits) - 1
+  };
+  
+  static EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+  Packet run(const Packet& a, const Packet& exponent) {
+    const Packet bias = pset1<Packet>(Scalar((ScalarI(1)<<(int(ExponentBits)-1)) - ScalarI(1)));  // 127
+    const Packet limit = pset1<Packet>(Scalar((ScalarI(1)<<int(ExponentBits)) - ScalarI(1)));     // 255
+    // restrict biased exponent between 0 and 255 for float.
+    const PacketI e = pcast<Packet, PacketI>(pmin(pmax(padd(exponent, bias), pzero(limit)), limit)); // exponent + 127
+    // return a * (2^e)
+    return pmul(a, preinterpret<Packet>(plogical_shift_left<int(MantissaBits)>(e)));
+  }
+};
+
+// Natural or base 2 logarithm.
+// Computes log(x) as log(2^e * m) = C*e + log(m), where the constant C =log(2)
+// and m is in the range [sqrt(1/2),sqrt(2)). In this range, the logarithm can
+// be easily approximated by a polynomial centered on m=1 for stability.
+// TODO(gonnet): Further reduce the interval allowing for lower-degree
+//               polynomial interpolants -> ... -> profit!
+template <typename Packet, bool base2>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_impl_float(const Packet _x)
+{
+  Packet x = _x;
+
+  const Packet cst_1              = pset1<Packet>(1.0f);
+  const Packet cst_neg_half       = pset1<Packet>(-0.5f);
+  // The smallest non denormalized float number.
+  const Packet cst_min_norm_pos   = pset1frombits<Packet>( 0x00800000u);
+  const Packet cst_minus_inf      = pset1frombits<Packet>( 0xff800000u);
+  const Packet cst_pos_inf        = pset1frombits<Packet>( 0x7f800000u);
+
+  // Polynomial coefficients.
+  const Packet cst_cephes_SQRTHF = pset1<Packet>(0.707106781186547524f);
+  const Packet cst_cephes_log_p0 = pset1<Packet>(7.0376836292E-2f);
+  const Packet cst_cephes_log_p1 = pset1<Packet>(-1.1514610310E-1f);
+  const Packet cst_cephes_log_p2 = pset1<Packet>(1.1676998740E-1f);
+  const Packet cst_cephes_log_p3 = pset1<Packet>(-1.2420140846E-1f);
+  const Packet cst_cephes_log_p4 = pset1<Packet>(+1.4249322787E-1f);
+  const Packet cst_cephes_log_p5 = pset1<Packet>(-1.6668057665E-1f);
+  const Packet cst_cephes_log_p6 = pset1<Packet>(+2.0000714765E-1f);
+  const Packet cst_cephes_log_p7 = pset1<Packet>(-2.4999993993E-1f);
+  const Packet cst_cephes_log_p8 = pset1<Packet>(+3.3333331174E-1f);
+
+  // Truncate input values to the minimum positive normal.
+  x = pmax(x, cst_min_norm_pos);
+
+  Packet e;
+  // extract significant in the range [0.5,1) and exponent
+  x = pfrexp(x,e);
+
+  // part2: Shift the inputs from the range [0.5,1) to [sqrt(1/2),sqrt(2))
+  // and shift by -1. The values are then centered around 0, which improves
+  // the stability of the polynomial evaluation.
+  //   if( x < SQRTHF ) {
+  //     e -= 1;
+  //     x = x + x - 1.0;
+  //   } else { x = x - 1.0; }
+  Packet mask = pcmp_lt(x, cst_cephes_SQRTHF);
+  Packet tmp = pand(x, mask);
+  x = psub(x, cst_1);
+  e = psub(e, pand(cst_1, mask));
+  x = padd(x, tmp);
+
+  Packet x2 = pmul(x, x);
+  Packet x3 = pmul(x2, x);
+
+  // Evaluate the polynomial approximant of degree 8 in three parts, probably
+  // to improve instruction-level parallelism.
+  Packet y, y1, y2;
+  y  = pmadd(cst_cephes_log_p0, x, cst_cephes_log_p1);
+  y1 = pmadd(cst_cephes_log_p3, x, cst_cephes_log_p4);
+  y2 = pmadd(cst_cephes_log_p6, x, cst_cephes_log_p7);
+  y  = pmadd(y, x, cst_cephes_log_p2);
+  y1 = pmadd(y1, x, cst_cephes_log_p5);
+  y2 = pmadd(y2, x, cst_cephes_log_p8);
+  y  = pmadd(y, x3, y1);
+  y  = pmadd(y, x3, y2);
+  y  = pmul(y, x3);
+
+  y = pmadd(cst_neg_half, x2, y);
+  x = padd(x, y);
+
+  // Add the logarithm of the exponent back to the result of the interpolation.
+  if (base2) {
+    const Packet cst_log2e = pset1<Packet>(static_cast<float>(EIGEN_LOG2E));
+    x = pmadd(x, cst_log2e, e);
+  } else {
+    const Packet cst_ln2 = pset1<Packet>(static_cast<float>(EIGEN_LN2));
+    x = pmadd(e, cst_ln2, x);
+  }
+
+  Packet invalid_mask = pcmp_lt_or_nan(_x, pzero(_x));
+  Packet iszero_mask  = pcmp_eq(_x,pzero(_x));
+  Packet pos_inf_mask = pcmp_eq(_x,cst_pos_inf);
+  // Filter out invalid inputs, i.e.:
+  //  - negative arg will be NAN
+  //  - 0 will be -INF
+  //  - +INF will be +INF
+  return pselect(iszero_mask, cst_minus_inf,
+                              por(pselect(pos_inf_mask,cst_pos_inf,x), invalid_mask));
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_float(const Packet _x)
+{
+  return plog_impl_float<Packet, /* base2 */ false>(_x);
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog2_float(const Packet _x)
+{
+  return plog_impl_float<Packet, /* base2 */ true>(_x);
+}
+
+/* Returns the base e (2.718...) or base 2 logarithm of x.
+ * The argument is separated into its exponent and fractional parts.
+ * The logarithm of the fraction in the interval [sqrt(1/2), sqrt(2)],
+ * is approximated by
+ *
+ *     log(1+x) = x - 0.5 x**2 + x**3 P(x)/Q(x).
+ *
+ * for more detail see: http://www.netlib.org/cephes/
+ */
+template <typename Packet, bool base2>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_impl_double(const Packet _x)
+{
+  Packet x = _x;
+
+  const Packet cst_1              = pset1<Packet>(1.0);
+  const Packet cst_neg_half       = pset1<Packet>(-0.5);
+  // The smallest non denormalized double.
+  const Packet cst_min_norm_pos   = pset1frombits<Packet>( static_cast<uint64_t>(0x0010000000000000ull));
+  const Packet cst_minus_inf      = pset1frombits<Packet>( static_cast<uint64_t>(0xfff0000000000000ull));
+  const Packet cst_pos_inf        = pset1frombits<Packet>( static_cast<uint64_t>(0x7ff0000000000000ull));
+
+
+ // Polynomial Coefficients for log(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
+ //                             1/sqrt(2) <= x < sqrt(2)
+  const Packet cst_cephes_SQRTHF = pset1<Packet>(0.70710678118654752440E0);
+  const Packet cst_cephes_log_p0 = pset1<Packet>(1.01875663804580931796E-4);
+  const Packet cst_cephes_log_p1 = pset1<Packet>(4.97494994976747001425E-1);
+  const Packet cst_cephes_log_p2 = pset1<Packet>(4.70579119878881725854E0);
+  const Packet cst_cephes_log_p3 = pset1<Packet>(1.44989225341610930846E1);
+  const Packet cst_cephes_log_p4 = pset1<Packet>(1.79368678507819816313E1);
+  const Packet cst_cephes_log_p5 = pset1<Packet>(7.70838733755885391666E0);
+
+  const Packet cst_cephes_log_q0 = pset1<Packet>(1.0);
+  const Packet cst_cephes_log_q1 = pset1<Packet>(1.12873587189167450590E1);
+  const Packet cst_cephes_log_q2 = pset1<Packet>(4.52279145837532221105E1);
+  const Packet cst_cephes_log_q3 = pset1<Packet>(8.29875266912776603211E1);
+  const Packet cst_cephes_log_q4 = pset1<Packet>(7.11544750618563894466E1);
+  const Packet cst_cephes_log_q5 = pset1<Packet>(2.31251620126765340583E1);
+
+  // Truncate input values to the minimum positive normal.
+  x = pmax(x, cst_min_norm_pos);
+
+  Packet e;
+  // extract significant in the range [0.5,1) and exponent
+  x = pfrexp(x,e);
+  
+  // Shift the inputs from the range [0.5,1) to [sqrt(1/2),sqrt(2))
+  // and shift by -1. The values are then centered around 0, which improves
+  // the stability of the polynomial evaluation.
+  //   if( x < SQRTHF ) {
+  //     e -= 1;
+  //     x = x + x - 1.0;
+  //   } else { x = x - 1.0; }
+  Packet mask = pcmp_lt(x, cst_cephes_SQRTHF);
+  Packet tmp = pand(x, mask);
+  x = psub(x, cst_1);
+  e = psub(e, pand(cst_1, mask));
+  x = padd(x, tmp);
+
+  Packet x2 = pmul(x, x);
+  Packet x3 = pmul(x2, x);
+
+  // Evaluate the polynomial approximant , probably to improve instruction-level parallelism.
+  // y = x - 0.5*x^2 + x^3 * polevl( x, P, 5 ) / p1evl( x, Q, 5 ) );
+  Packet y, y1, y_;
+  y  = pmadd(cst_cephes_log_p0, x, cst_cephes_log_p1);
+  y1 = pmadd(cst_cephes_log_p3, x, cst_cephes_log_p4);
+  y  = pmadd(y, x, cst_cephes_log_p2);
+  y1 = pmadd(y1, x, cst_cephes_log_p5);
+  y_ = pmadd(y, x3, y1);
+
+  y  = pmadd(cst_cephes_log_q0, x, cst_cephes_log_q1);
+  y1 = pmadd(cst_cephes_log_q3, x, cst_cephes_log_q4);
+  y  = pmadd(y, x, cst_cephes_log_q2);
+  y1 = pmadd(y1, x, cst_cephes_log_q5);
+  y  = pmadd(y, x3, y1);
+
+  y_ = pmul(y_, x3);
+  y  = pdiv(y_, y);
+
+  y = pmadd(cst_neg_half, x2, y);
+  x = padd(x, y);
+
+  // Add the logarithm of the exponent back to the result of the interpolation.
+  if (base2) {
+    const Packet cst_log2e = pset1<Packet>(static_cast<double>(EIGEN_LOG2E));
+    x = pmadd(x, cst_log2e, e);
+  } else {
+    const Packet cst_ln2 = pset1<Packet>(static_cast<double>(EIGEN_LN2));
+    x = pmadd(e, cst_ln2, x);
+  }
+
+  Packet invalid_mask = pcmp_lt_or_nan(_x, pzero(_x));
+  Packet iszero_mask  = pcmp_eq(_x,pzero(_x));
+  Packet pos_inf_mask = pcmp_eq(_x,cst_pos_inf);
+  // Filter out invalid inputs, i.e.:
+  //  - negative arg will be NAN
+  //  - 0 will be -INF
+  //  - +INF will be +INF
+  return pselect(iszero_mask, cst_minus_inf,
+                              por(pselect(pos_inf_mask,cst_pos_inf,x), invalid_mask));
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_double(const Packet _x)
+{
+  return plog_impl_double<Packet, /* base2 */ false>(_x);
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog2_double(const Packet _x)
+{
+  return plog_impl_double<Packet, /* base2 */ true>(_x);
+}
+
+/** \internal \returns log(1 + x) computed using W. Kahan's formula.
+    See: http://www.plunk.org/~hatch/rightway.php
+ */
+template<typename Packet>
+Packet generic_plog1p(const Packet& x)
+{
+  typedef typename unpacket_traits<Packet>::type ScalarType;
+  const Packet one = pset1<Packet>(ScalarType(1));
+  Packet xp1 = padd(x, one);
+  Packet small_mask = pcmp_eq(xp1, one);
+  Packet log1 = plog(xp1);
+  Packet inf_mask = pcmp_eq(xp1, log1);
+  Packet log_large = pmul(x, pdiv(log1, psub(xp1, one)));
+  return pselect(por(small_mask, inf_mask), x, log_large);
+}
+
+/** \internal \returns exp(x)-1 computed using W. Kahan's formula.
+    See: http://www.plunk.org/~hatch/rightway.php
+ */
+template<typename Packet>
+Packet generic_expm1(const Packet& x)
+{
+  typedef typename unpacket_traits<Packet>::type ScalarType;
+  const Packet one = pset1<Packet>(ScalarType(1));
+  const Packet neg_one = pset1<Packet>(ScalarType(-1));
+  Packet u = pexp(x);
+  Packet one_mask = pcmp_eq(u, one);
+  Packet u_minus_one = psub(u, one);
+  Packet neg_one_mask = pcmp_eq(u_minus_one, neg_one);
+  Packet logu = plog(u);
+  // The following comparison is to catch the case where
+  // exp(x) = +inf. It is written in this way to avoid having
+  // to form the constant +inf, which depends on the packet
+  // type.
+  Packet pos_inf_mask = pcmp_eq(logu, u);
+  Packet expm1 = pmul(u_minus_one, pdiv(x, logu));
+  expm1 = pselect(pos_inf_mask, u, expm1);
+  return pselect(one_mask,
+                 x,
+                 pselect(neg_one_mask,
+                         neg_one,
+                         expm1));
+}
+
+
+// Exponential function. Works by writing "x = m*log(2) + r" where
+// "m = floor(x/log(2)+1/2)" and "r" is the remainder. The result is then
+// "exp(x) = 2^m*exp(r)" where exp(r) is in the range [-1,1).
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pexp_float(const Packet _x)
+{
+  const Packet cst_1      = pset1<Packet>(1.0f);
+  const Packet cst_half   = pset1<Packet>(0.5f);
+  const Packet cst_exp_hi = pset1<Packet>( 88.723f);
+  const Packet cst_exp_lo = pset1<Packet>(-88.723f);
+
+  const Packet cst_cephes_LOG2EF = pset1<Packet>(1.44269504088896341f);
+  const Packet cst_cephes_exp_p0 = pset1<Packet>(1.9875691500E-4f);
+  const Packet cst_cephes_exp_p1 = pset1<Packet>(1.3981999507E-3f);
+  const Packet cst_cephes_exp_p2 = pset1<Packet>(8.3334519073E-3f);
+  const Packet cst_cephes_exp_p3 = pset1<Packet>(4.1665795894E-2f);
+  const Packet cst_cephes_exp_p4 = pset1<Packet>(1.6666665459E-1f);
+  const Packet cst_cephes_exp_p5 = pset1<Packet>(5.0000001201E-1f);
+
+  // Clamp x.
+  Packet x = pmax(pmin(_x, cst_exp_hi), cst_exp_lo);
+
+  // Express exp(x) as exp(m*ln(2) + r), start by extracting
+  // m = floor(x/ln(2) + 0.5).
+  Packet m = pfloor(pmadd(x, cst_cephes_LOG2EF, cst_half));
+
+  // Get r = x - m*ln(2). If no FMA instructions are available, m*ln(2) is
+  // subtracted out in two parts, m*C1+m*C2 = m*ln(2), to avoid accumulating
+  // truncation errors.
+  const Packet cst_cephes_exp_C1 = pset1<Packet>(-0.693359375f);
+  const Packet cst_cephes_exp_C2 = pset1<Packet>(2.12194440e-4f);
+  Packet r = pmadd(m, cst_cephes_exp_C1, x);
+  r = pmadd(m, cst_cephes_exp_C2, r);
+
+  Packet r2 = pmul(r, r);
+  Packet r3 = pmul(r2, r);
+
+  // Evaluate the polynomial approximant,improved by instruction-level parallelism.
+  Packet y, y1, y2;
+  y  = pmadd(cst_cephes_exp_p0, r, cst_cephes_exp_p1);
+  y1 = pmadd(cst_cephes_exp_p3, r, cst_cephes_exp_p4);
+  y2 = padd(r, cst_1);
+  y  = pmadd(y, r, cst_cephes_exp_p2);
+  y1 = pmadd(y1, r, cst_cephes_exp_p5);
+  y  = pmadd(y, r3, y1);
+  y  = pmadd(y, r2, y2);
+
+  // Return 2^m * exp(r).
+  // TODO: replace pldexp with faster implementation since y in [-1, 1).
+  return pmax(pldexp(y,m), _x);
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pexp_double(const Packet _x)
+{
+  Packet x = _x;
+
+  const Packet cst_1 = pset1<Packet>(1.0);
+  const Packet cst_2 = pset1<Packet>(2.0);
+  const Packet cst_half = pset1<Packet>(0.5);
+
+  const Packet cst_exp_hi = pset1<Packet>(709.784);
+  const Packet cst_exp_lo = pset1<Packet>(-709.784);
+
+  const Packet cst_cephes_LOG2EF = pset1<Packet>(1.4426950408889634073599);
+  const Packet cst_cephes_exp_p0 = pset1<Packet>(1.26177193074810590878e-4);
+  const Packet cst_cephes_exp_p1 = pset1<Packet>(3.02994407707441961300e-2);
+  const Packet cst_cephes_exp_p2 = pset1<Packet>(9.99999999999999999910e-1);
+  const Packet cst_cephes_exp_q0 = pset1<Packet>(3.00198505138664455042e-6);
+  const Packet cst_cephes_exp_q1 = pset1<Packet>(2.52448340349684104192e-3);
+  const Packet cst_cephes_exp_q2 = pset1<Packet>(2.27265548208155028766e-1);
+  const Packet cst_cephes_exp_q3 = pset1<Packet>(2.00000000000000000009e0);
+  const Packet cst_cephes_exp_C1 = pset1<Packet>(0.693145751953125);
+  const Packet cst_cephes_exp_C2 = pset1<Packet>(1.42860682030941723212e-6);
+
+  Packet tmp, fx;
+
+  // clamp x
+  x = pmax(pmin(x, cst_exp_hi), cst_exp_lo);
+  // Express exp(x) as exp(g + n*log(2)).
+  fx = pmadd(cst_cephes_LOG2EF, x, cst_half);
+
+  // Get the integer modulus of log(2), i.e. the "n" described above.
+  fx = pfloor(fx);
+
+  // Get the remainder modulo log(2), i.e. the "g" described above. Subtract
+  // n*log(2) out in two steps, i.e. n*C1 + n*C2, C1+C2=log2 to get the last
+  // digits right.
+  tmp = pmul(fx, cst_cephes_exp_C1);
+  Packet z = pmul(fx, cst_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  Packet x2 = pmul(x, x);
+
+  // Evaluate the numerator polynomial of the rational interpolant.
+  Packet px = cst_cephes_exp_p0;
+  px = pmadd(px, x2, cst_cephes_exp_p1);
+  px = pmadd(px, x2, cst_cephes_exp_p2);
+  px = pmul(px, x);
+
+  // Evaluate the denominator polynomial of the rational interpolant.
+  Packet qx = cst_cephes_exp_q0;
+  qx = pmadd(qx, x2, cst_cephes_exp_q1);
+  qx = pmadd(qx, x2, cst_cephes_exp_q2);
+  qx = pmadd(qx, x2, cst_cephes_exp_q3);
+
+  // I don't really get this bit, copied from the SSE2 routines, so...
+  // TODO(gonnet): Figure out what is going on here, perhaps find a better
+  // rational interpolant?
+  x = pdiv(px, psub(qx, px));
+  x = pmadd(cst_2, x, cst_1);
+
+  // Construct the result 2^n * exp(g) = e * x. The max is used to catch
+  // non-finite values in the input.
+  // TODO: replace pldexp with faster implementation since x in [-1, 1).
+  return pmax(pldexp(x,fx), _x);
+}
+
+// The following code is inspired by the following stack-overflow answer:
+//   https://stackoverflow.com/questions/30463616/payne-hanek-algorithm-implementation-in-c/30465751#30465751
+// It has been largely optimized:
+//  - By-pass calls to frexp.
+//  - Aligned loads of required 96 bits of 2/pi. This is accomplished by
+//    (1) balancing the mantissa and exponent to the required bits of 2/pi are
+//    aligned on 8-bits, and (2) replicating the storage of the bits of 2/pi.
+//  - Avoid a branch in rounding and extraction of the remaining fractional part.
+// Overall, I measured a speed up higher than x2 on x86-64.
+inline float trig_reduce_huge (float xf, int *quadrant)
+{
+  using Eigen::numext::int32_t;
+  using Eigen::numext::uint32_t;
+  using Eigen::numext::int64_t;
+  using Eigen::numext::uint64_t;
+
+  const double pio2_62 = 3.4061215800865545e-19;    // pi/2 * 2^-62
+  const uint64_t zero_dot_five = uint64_t(1) << 61; // 0.5 in 2.62-bit fixed-point foramt
+
+  // 192 bits of 2/pi for Payne-Hanek reduction
+  // Bits are introduced by packet of 8 to enable aligned reads.
+  static const uint32_t two_over_pi [] = 
+  {
+    0x00000028, 0x000028be, 0x0028be60, 0x28be60db,
+    0xbe60db93, 0x60db9391, 0xdb939105, 0x9391054a,
+    0x91054a7f, 0x054a7f09, 0x4a7f09d5, 0x7f09d5f4,
+    0x09d5f47d, 0xd5f47d4d, 0xf47d4d37, 0x7d4d3770,
+    0x4d377036, 0x377036d8, 0x7036d8a5, 0x36d8a566,
+    0xd8a5664f, 0xa5664f10, 0x664f10e4, 0x4f10e410,
+    0x10e41000, 0xe4100000
+  };
+  
+  uint32_t xi = numext::bit_cast<uint32_t>(xf);
+  // Below, -118 = -126 + 8.
+  //   -126 is to get the exponent,
+  //   +8 is to enable alignment of 2/pi's bits on 8 bits.
+  // This is possible because the fractional part of x as only 24 meaningful bits.
+  uint32_t e = (xi >> 23) - 118;
+  // Extract the mantissa and shift it to align it wrt the exponent
+  xi = ((xi & 0x007fffffu)| 0x00800000u) << (e & 0x7);
+
+  uint32_t i = e >> 3;
+  uint32_t twoopi_1  = two_over_pi[i-1];
+  uint32_t twoopi_2  = two_over_pi[i+3];
+  uint32_t twoopi_3  = two_over_pi[i+7];
+
+  // Compute x * 2/pi in 2.62-bit fixed-point format.
+  uint64_t p;
+  p = uint64_t(xi) * twoopi_3;
+  p = uint64_t(xi) * twoopi_2 + (p >> 32);
+  p = (uint64_t(xi * twoopi_1) << 32) + p;
+
+  // Round to nearest: add 0.5 and extract integral part.
+  uint64_t q = (p + zero_dot_five) >> 62;
+  *quadrant = int(q);
+  // Now it remains to compute "r = x - q*pi/2" with high accuracy,
+  // since we have p=x/(pi/2) with high accuracy, we can more efficiently compute r as:
+  //   r = (p-q)*pi/2,
+  // where the product can be be carried out with sufficient accuracy using double precision.
+  p -= q<<62;
+  return float(double(int64_t(p)) * pio2_62);
+}
+
+template<bool ComputeSine,typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+#if EIGEN_GNUC_AT_LEAST(4,4) && EIGEN_COMP_GNUC_STRICT
+__attribute__((optimize("-fno-unsafe-math-optimizations")))
+#endif
+Packet psincos_float(const Packet& _x)
+{
+  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
+
+  const Packet  cst_2oPI            = pset1<Packet>(0.636619746685028076171875f); // 2/PI
+  const Packet  cst_rounding_magic  = pset1<Packet>(12582912); // 2^23 for rounding
+  const PacketI csti_1              = pset1<PacketI>(1);
+  const Packet  cst_sign_mask       = pset1frombits<Packet>(0x80000000u);
+
+  Packet x = pabs(_x);
+
+  // Scale x by 2/Pi to find x's octant.
+  Packet y = pmul(x, cst_2oPI);
+
+  // Rounding trick:
+  Packet y_round = padd(y, cst_rounding_magic);
+  EIGEN_OPTIMIZATION_BARRIER(y_round)
+  PacketI y_int = preinterpret<PacketI>(y_round); // last 23 digits represent integer (if abs(x)<2^24)
+  y = psub(y_round, cst_rounding_magic); // nearest integer to x*4/pi
+
+  // Reduce x by y octants to get: -Pi/4 <= x <= +Pi/4
+  // using "Extended precision modular arithmetic"
+  #if defined(EIGEN_HAS_SINGLE_INSTRUCTION_MADD)
+  // This version requires true FMA for high accuracy
+  // It provides a max error of 1ULP up to (with absolute_error < 5.9605e-08):
+  const float huge_th = ComputeSine ? 117435.992f : 71476.0625f;
+  x = pmadd(y, pset1<Packet>(-1.57079601287841796875f), x);
+  x = pmadd(y, pset1<Packet>(-3.1391647326017846353352069854736328125e-07f), x);
+  x = pmadd(y, pset1<Packet>(-5.390302529957764765544681040410068817436695098876953125e-15f), x);
+  #else
+  // Without true FMA, the previous set of coefficients maintain 1ULP accuracy
+  // up to x<15.7 (for sin), but accuracy is immediately lost for x>15.7.
+  // We thus use one more iteration to maintain 2ULPs up to reasonably large inputs.
+
+  // The following set of coefficients maintain 1ULP up to 9.43 and 14.16 for sin and cos respectively.
+  // and 2 ULP up to:
+  const float huge_th = ComputeSine ? 25966.f : 18838.f;
+  x = pmadd(y, pset1<Packet>(-1.5703125), x); // = 0xbfc90000
+  EIGEN_OPTIMIZATION_BARRIER(x)
+  x = pmadd(y, pset1<Packet>(-0.000483989715576171875), x); // = 0xb9fdc000
+  EIGEN_OPTIMIZATION_BARRIER(x)
+  x = pmadd(y, pset1<Packet>(1.62865035235881805419921875e-07), x); // = 0x342ee000
+  x = pmadd(y, pset1<Packet>(5.5644315544167710640977020375430583953857421875e-11), x); // = 0x2e74b9ee
+
+  // For the record, the following set of coefficients maintain 2ULP up
+  // to a slightly larger range:
+  // const float huge_th = ComputeSine ? 51981.f : 39086.125f;
+  // but it slightly fails to maintain 1ULP for two values of sin below pi.
+  // x = pmadd(y, pset1<Packet>(-3.140625/2.), x);
+  // x = pmadd(y, pset1<Packet>(-0.00048351287841796875), x);
+  // x = pmadd(y, pset1<Packet>(-3.13855707645416259765625e-07), x);
+  // x = pmadd(y, pset1<Packet>(-6.0771006282767103812147979624569416046142578125e-11), x);
+
+  // For the record, with only 3 iterations it is possible to maintain
+  // 1 ULP up to 3PI (maybe more) and 2ULP up to 255.
+  // The coefficients are: 0xbfc90f80, 0xb7354480, 0x2e74b9ee
+  #endif
+
+  if(predux_any(pcmp_le(pset1<Packet>(huge_th),pabs(_x))))
+  {
+    const int PacketSize = unpacket_traits<Packet>::size;
+    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) float vals[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) float x_cpy[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) int y_int2[PacketSize];
+    pstoreu(vals, pabs(_x));
+    pstoreu(x_cpy, x);
+    pstoreu(y_int2, y_int);
+    for(int k=0; k<PacketSize;++k)
+    {
+      float val = vals[k];
+      if(val>=huge_th && (numext::isfinite)(val))
+        x_cpy[k] = trig_reduce_huge(val,&y_int2[k]);
+    }
+    x = ploadu<Packet>(x_cpy);
+    y_int = ploadu<PacketI>(y_int2);
+  }
+
+  // Compute the sign to apply to the polynomial.
+  // sin: sign = second_bit(y_int) xor signbit(_x)
+  // cos: sign = second_bit(y_int+1)
+  Packet sign_bit = ComputeSine ? pxor(_x, preinterpret<Packet>(plogical_shift_left<30>(y_int)))
+                                : preinterpret<Packet>(plogical_shift_left<30>(padd(y_int,csti_1)));
+  sign_bit = pand(sign_bit, cst_sign_mask); // clear all but left most bit
+
+  // Get the polynomial selection mask from the second bit of y_int
+  // We'll calculate both (sin and cos) polynomials and then select from the two.
+  Packet poly_mask = preinterpret<Packet>(pcmp_eq(pand(y_int, csti_1), pzero(y_int)));
+
+  Packet x2 = pmul(x,x);
+
+  // Evaluate the cos(x) polynomial. (-Pi/4 <= x <= Pi/4)
+  Packet y1 =        pset1<Packet>(2.4372266125283204019069671630859375e-05f);
+  y1 = pmadd(y1, x2, pset1<Packet>(-0.00138865201734006404876708984375f     ));
+  y1 = pmadd(y1, x2, pset1<Packet>(0.041666619479656219482421875f           ));
+  y1 = pmadd(y1, x2, pset1<Packet>(-0.5f));
+  y1 = pmadd(y1, x2, pset1<Packet>(1.f));
+
+  // Evaluate the sin(x) polynomial. (Pi/4 <= x <= Pi/4)
+  // octave/matlab code to compute those coefficients:
+  //    x = (0:0.0001:pi/4)';
+  //    A = [x.^3 x.^5 x.^7];
+  //    w = ((1.-(x/(pi/4)).^2).^5)*2000+1;         # weights trading relative accuracy
+  //    c = (A'*diag(w)*A)\(A'*diag(w)*(sin(x)-x)); # weighted LS, linear coeff forced to 1
+  //    printf('%.64f\n %.64f\n%.64f\n', c(3), c(2), c(1))
+  //
+  Packet y2 =        pset1<Packet>(-0.0001959234114083702898469196984621021329076029360294342041015625f);
+  y2 = pmadd(y2, x2, pset1<Packet>( 0.0083326873655616851693794799871284340042620897293090820312500000f));
+  y2 = pmadd(y2, x2, pset1<Packet>(-0.1666666203982298255503735617821803316473960876464843750000000000f));
+  y2 = pmul(y2, x2);
+  y2 = pmadd(y2, x, x);
+
+  // Select the correct result from the two polynomials.
+  y = ComputeSine ? pselect(poly_mask,y2,y1)
+                  : pselect(poly_mask,y1,y2);
+
+  // Update the sign and filter huge inputs
+  return pxor(y, sign_bit);
+}
+
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet psin_float(const Packet& x)
+{
+  return psincos_float<true>(x);
+}
+
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pcos_float(const Packet& x)
+{
+  return psincos_float<false>(x);
+}
+
+
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet psqrt_complex(const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  typedef typename Scalar::value_type RealScalar;
+  typedef typename unpacket_traits<Packet>::as_real RealPacket;
+
+  // Computes the principal sqrt of the complex numbers in the input.
+  //
+  // For example, for packets containing 2 complex numbers stored in interleaved format
+  //    a = [a0, a1] = [x0, y0, x1, y1],
+  // where x0 = real(a0), y0 = imag(a0) etc., this function returns
+  //    b = [b0, b1] = [u0, v0, u1, v1],
+  // such that b0^2 = a0, b1^2 = a1.
+  //
+  // To derive the formula for the complex square roots, let's consider the equation for
+  // a single complex square root of the number x + i*y. We want to find real numbers
+  // u and v such that
+  //    (u + i*v)^2 = x + i*y  <=>
+  //    u^2 - v^2 + i*2*u*v = x + i*v.
+  // By equating the real and imaginary parts we get:
+  //    u^2 - v^2 = x
+  //    2*u*v = y.
+  //
+  // For x >= 0, this has the numerically stable solution
+  //    u = sqrt(0.5 * (x + sqrt(x^2 + y^2)))
+  //    v = 0.5 * (y / u)
+  // and for x < 0,
+  //    v = sign(y) * sqrt(0.5 * (-x + sqrt(x^2 + y^2)))
+  //    u = 0.5 * (y / v)
+  //
+  //  To avoid unnecessary over- and underflow, we compute sqrt(x^2 + y^2) as
+  //     l = max(|x|, |y|) * sqrt(1 + (min(|x|, |y|) / max(|x|, |y|))^2) ,
+
+  // In the following, without lack of generality, we have annotated the code, assuming
+  // that the input is a packet of 2 complex numbers.
+  //
+  // Step 1. Compute l = [l0, l0, l1, l1], where
+  //    l0 = sqrt(x0^2 + y0^2),  l1 = sqrt(x1^2 + y1^2)
+  // To avoid over- and underflow, we use the stable formula for each hypotenuse
+  //    l0 = (min0 == 0 ? max0 : max0 * sqrt(1 + (min0/max0)**2)),
+  // where max0 = max(|x0|, |y0|), min0 = min(|x0|, |y0|), and similarly for l1.
+
+  RealPacket a_abs = pabs(a.v);           // [|x0|, |y0|, |x1|, |y1|]
+  RealPacket a_abs_flip = pcplxflip(Packet(a_abs)).v; // [|y0|, |x0|, |y1|, |x1|]
+  RealPacket a_max = pmax(a_abs, a_abs_flip);
+  RealPacket a_min = pmin(a_abs, a_abs_flip);
+  RealPacket a_min_zero_mask = pcmp_eq(a_min, pzero(a_min));
+  RealPacket a_max_zero_mask = pcmp_eq(a_max, pzero(a_max));
+  RealPacket r = pdiv(a_min, a_max);
+  const RealPacket cst_one  = pset1<RealPacket>(RealScalar(1));
+  RealPacket l = pmul(a_max, psqrt(padd(cst_one, pmul(r, r))));  // [l0, l0, l1, l1]
+  // Set l to a_max if a_min is zero.
+  l = pselect(a_min_zero_mask, a_max, l);
+
+  // Step 2. Compute [rho0, *, rho1, *], where
+  // rho0 = sqrt(0.5 * (l0 + |x0|)), rho1 =  sqrt(0.5 * (l1 + |x1|))
+  // We don't care about the imaginary parts computed here. They will be overwritten later.
+  const RealPacket cst_half = pset1<RealPacket>(RealScalar(0.5));
+  Packet rho;
+  rho.v = psqrt(pmul(cst_half, padd(a_abs, l)));
+
+  // Step 3. Compute [rho0, eta0, rho1, eta1], where
+  // eta0 = (y0 / l0) / 2, and eta1 = (y1 / l1) / 2.
+  // set eta = 0 of input is 0 + i0.
+  RealPacket eta = pandnot(pmul(cst_half, pdiv(a.v, pcplxflip(rho).v)), a_max_zero_mask);
+  RealPacket real_mask = peven_mask(a.v);
+  Packet positive_real_result;
+  // Compute result for inputs with positive real part.
+  positive_real_result.v = pselect(real_mask, rho.v, eta);
+
+  // Step 4. Compute solution for inputs with negative real part:
+  //         [|eta0|, sign(y0)*rho0, |eta1|, sign(y1)*rho1]
+  const RealScalar neg_zero = RealScalar(numext::bit_cast<float>(0x80000000u));
+  const RealPacket cst_imag_sign_mask = pset1<Packet>(Scalar(RealScalar(0.0), neg_zero)).v;
+  RealPacket imag_signs = pand(a.v, cst_imag_sign_mask);
+  Packet negative_real_result;
+  // Notice that rho is positive, so taking it's absolute value is a noop.
+  negative_real_result.v = por(pabs(pcplxflip(positive_real_result).v), imag_signs);
+
+  // Step 5. Select solution branch based on the sign of the real parts.
+  Packet negative_real_mask;
+  negative_real_mask.v = pcmp_lt(pand(real_mask, a.v), pzero(a.v));
+  negative_real_mask.v = por(negative_real_mask.v, pcplxflip(negative_real_mask).v);
+  Packet result = pselect(negative_real_mask, negative_real_result, positive_real_result);
+
+  // Step 6. Handle special cases for infinities:
+  // * If z is (x,+∞), the result is (+∞,+∞) even if x is NaN
+  // * If z is (x,-∞), the result is (+∞,-∞) even if x is NaN
+  // * If z is (-∞,y), the result is (0*|y|,+∞) for finite or NaN y
+  // * If z is (+∞,y), the result is (+∞,0*|y|) for finite or NaN y
+  const RealPacket cst_pos_inf = pset1<RealPacket>(NumTraits<RealScalar>::infinity());
+  Packet is_inf;
+  is_inf.v = pcmp_eq(a_abs, cst_pos_inf);
+  Packet is_real_inf;
+  is_real_inf.v = pand(is_inf.v, real_mask);
+  is_real_inf = por(is_real_inf, pcplxflip(is_real_inf));
+  // prepare packet of (+∞,0*|y|) or (0*|y|,+∞), depending on the sign of the infinite real part.
+  Packet real_inf_result;
+  real_inf_result.v = pmul(a_abs, pset1<Packet>(Scalar(RealScalar(1.0), RealScalar(0.0))).v);
+  real_inf_result.v = pselect(negative_real_mask.v, pcplxflip(real_inf_result).v, real_inf_result.v);
+  // prepare packet of (+∞,+∞) or (+∞,-∞), depending on the sign of the infinite imaginary part.
+  Packet is_imag_inf;
+  is_imag_inf.v = pandnot(is_inf.v, real_mask);
+  is_imag_inf = por(is_imag_inf, pcplxflip(is_imag_inf));
+  Packet imag_inf_result;
+  imag_inf_result.v = por(pand(cst_pos_inf, real_mask), pandnot(a.v, real_mask));
+
+  return  pselect(is_imag_inf, imag_inf_result,
+                  pselect(is_real_inf, real_inf_result,result));
+}
+
+// TODO(rmlarsen): The following set of utilities for double word arithmetic
+// should perhaps be refactored as a separate file, since it would be generally
+// useful for special function implementation etc. Writing the algorithms in
+// terms if a double word type would also make the code more readable.
+
+// This function splits x into the nearest integer n and fractional part r,
+// such that x = n + r holds exactly.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void absolute_split(const Packet& x, Packet& n, Packet& r) {
+  n = pround(x);
+  r = psub(x, n);
+}
+
+// This function computes the sum {s, r}, such that x + y = s_hi + s_lo
+// holds exactly, and s_hi = fl(x+y), if |x| >= |y|.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void fast_twosum(const Packet& x, const Packet& y, Packet& s_hi, Packet& s_lo) {
+  s_hi = padd(x, y);
+  const Packet t = psub(s_hi, x);
+  s_lo = psub(y, t);
+}
+
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+// This function implements the extended precision product of
+// a pair of floating point numbers. Given {x, y}, it computes the pair
+// {p_hi, p_lo} such that x * y = p_hi + p_lo holds exactly and
+// p_hi = fl(x * y).
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void twoprod(const Packet& x, const Packet& y,
+             Packet& p_hi, Packet& p_lo) {
+  p_hi = pmul(x, y);
+  p_lo = pmadd(x, y, pnegate(p_hi));
+}
+
+#else
+
+// This function implements the Veltkamp splitting. Given a floating point
+// number x it returns the pair {x_hi, x_lo} such that x_hi + x_lo = x holds
+// exactly and that half of the significant of x fits in x_hi.
+// This is Algorithm 3 from Jean-Michel Muller, "Elementary Functions",
+// 3rd edition, Birkh\"auser, 2016.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void veltkamp_splitting(const Packet& x, Packet& x_hi, Packet& x_lo) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  EIGEN_CONSTEXPR int shift = (NumTraits<Scalar>::digits() + 1) / 2;
+  const Scalar shift_scale = Scalar(uint64_t(1) << shift);  // Scalar constructor not necessarily constexpr.
+  const Packet gamma = pmul(pset1<Packet>(shift_scale + Scalar(1)), x);
+  Packet rho = psub(x, gamma);
+  x_hi = padd(rho, gamma);
+  x_lo = psub(x, x_hi);
+}
+
+// This function implements Dekker's algorithm for products x * y.
+// Given floating point numbers {x, y} computes the pair
+// {p_hi, p_lo} such that x * y = p_hi + p_lo holds exactly and
+// p_hi = fl(x * y).
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void twoprod(const Packet& x, const Packet& y,
+             Packet& p_hi, Packet& p_lo) {
+  Packet x_hi, x_lo, y_hi, y_lo;
+  veltkamp_splitting(x, x_hi, x_lo);
+  veltkamp_splitting(y, y_hi, y_lo);
+
+  p_hi = pmul(x, y);
+  p_lo = pmadd(x_hi, y_hi, pnegate(p_hi));
+  p_lo = pmadd(x_hi, y_lo, p_lo);
+  p_lo = pmadd(x_lo, y_hi, p_lo);
+  p_lo = pmadd(x_lo, y_lo, p_lo);
+}
+
+#endif  // EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+
+
+// This function implements Dekker's algorithm for the addition
+// of two double word numbers represented by {x_hi, x_lo} and {y_hi, y_lo}.
+// It returns the result as a pair {s_hi, s_lo} such that
+// x_hi + x_lo + y_hi + y_lo = s_hi + s_lo holds exactly.
+// This is Algorithm 5 from Jean-Michel Muller, "Elementary Functions",
+// 3rd edition, Birkh\"auser, 2016.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+  void twosum(const Packet& x_hi, const Packet& x_lo,
+              const Packet& y_hi, const Packet& y_lo,
+              Packet& s_hi, Packet& s_lo) {
+  const Packet x_greater_mask = pcmp_lt(pabs(y_hi), pabs(x_hi));
+  Packet r_hi_1, r_lo_1;
+  fast_twosum(x_hi, y_hi,r_hi_1, r_lo_1);
+  Packet r_hi_2, r_lo_2;
+  fast_twosum(y_hi, x_hi,r_hi_2, r_lo_2);
+  const Packet r_hi = pselect(x_greater_mask, r_hi_1, r_hi_2);
+
+  const Packet s1 = padd(padd(y_lo, r_lo_1), x_lo);
+  const Packet s2 = padd(padd(x_lo, r_lo_2), y_lo);
+  const Packet s = pselect(x_greater_mask, s1, s2);
+
+  fast_twosum(r_hi, s, s_hi, s_lo);
+}
+
+// This is a version of twosum for double word numbers,
+// which assumes that |x_hi| >= |y_hi|.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+  void fast_twosum(const Packet& x_hi, const Packet& x_lo,
+              const Packet& y_hi, const Packet& y_lo,
+              Packet& s_hi, Packet& s_lo) {
+  Packet r_hi, r_lo;
+  fast_twosum(x_hi, y_hi, r_hi, r_lo);
+  const Packet s = padd(padd(y_lo, r_lo), x_lo);
+  fast_twosum(r_hi, s, s_hi, s_lo);
+}
+
+// This is a version of twosum for adding a floating point number x to
+// double word number {y_hi, y_lo} number, with the assumption
+// that |x| >= |y_hi|.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void fast_twosum(const Packet& x,
+                 const Packet& y_hi, const Packet& y_lo,
+                 Packet& s_hi, Packet& s_lo) {
+  Packet r_hi, r_lo;
+  fast_twosum(x, y_hi, r_hi, r_lo);
+  const Packet s = padd(y_lo, r_lo);
+  fast_twosum(r_hi, s, s_hi, s_lo);
+}
+
+// This function implements the multiplication of a double word
+// number represented by {x_hi, x_lo} by a floating point number y.
+// It returns the result as a pair {p_hi, p_lo} such that
+// (x_hi + x_lo) * y = p_hi + p_lo hold with a relative error
+// of less than 2*2^{-2p}, where p is the number of significand bit
+// in the floating point type.
+// This is Algorithm 7 from Jean-Michel Muller, "Elementary Functions",
+// 3rd edition, Birkh\"auser, 2016.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void twoprod(const Packet& x_hi, const Packet& x_lo, const Packet& y,
+             Packet& p_hi, Packet& p_lo) {
+  Packet c_hi, c_lo1;
+  twoprod(x_hi, y, c_hi, c_lo1);
+  const Packet c_lo2 = pmul(x_lo, y);
+  Packet t_hi, t_lo1;
+  fast_twosum(c_hi, c_lo2, t_hi, t_lo1);
+  const Packet t_lo2 = padd(t_lo1, c_lo1);
+  fast_twosum(t_hi, t_lo2, p_hi, p_lo);
+}
+
+// This function implements the multiplication of two double word
+// numbers represented by {x_hi, x_lo} and {y_hi, y_lo}.
+// It returns the result as a pair {p_hi, p_lo} such that
+// (x_hi + x_lo) * (y_hi + y_lo) = p_hi + p_lo holds with a relative error
+// of less than 2*2^{-2p}, where p is the number of significand bit
+// in the floating point type.
+template<typename Packet>
+EIGEN_STRONG_INLINE
+void twoprod(const Packet& x_hi, const Packet& x_lo,
+             const Packet& y_hi, const Packet& y_lo,
+             Packet& p_hi, Packet& p_lo) {
+  Packet p_hi_hi, p_hi_lo;
+  twoprod(x_hi, x_lo, y_hi, p_hi_hi, p_hi_lo);
+  Packet p_lo_hi, p_lo_lo;
+  twoprod(x_hi, x_lo, y_lo, p_lo_hi, p_lo_lo);
+  fast_twosum(p_hi_hi, p_hi_lo, p_lo_hi, p_lo_lo, p_hi, p_lo);
+}
+
+// This function computes the reciprocal of a floating point number
+// with extra precision and returns the result as a double word.
+template <typename Packet>
+void doubleword_reciprocal(const Packet& x, Packet& recip_hi, Packet& recip_lo) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  // 1. Approximate the reciprocal as the reciprocal of the high order element.
+  Packet approx_recip = prsqrt(x);
+  approx_recip = pmul(approx_recip, approx_recip);
+
+  // 2. Run one step of Newton-Raphson iteration in double word arithmetic
+  // to get the bottom half. The NR iteration for reciprocal of 'a' is
+  //    x_{i+1} = x_i * (2 - a * x_i)
+
+  // -a*x_i
+  Packet t1_hi, t1_lo;
+  twoprod(pnegate(x), approx_recip, t1_hi, t1_lo);
+  // 2 - a*x_i
+  Packet t2_hi, t2_lo;
+  fast_twosum(pset1<Packet>(Scalar(2)), t1_hi, t2_hi, t2_lo);
+  Packet t3_hi, t3_lo;
+  fast_twosum(t2_hi, padd(t2_lo, t1_lo), t3_hi, t3_lo);
+  // x_i * (2 - a * x_i)
+  twoprod(t3_hi, t3_lo, approx_recip, recip_hi, recip_lo);
+}
+
+
+// This function computes log2(x) and returns the result as a double word.
+template <typename Scalar>
+struct accurate_log2 {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  void operator()(const Packet& x, Packet& log2_x_hi, Packet& log2_x_lo) {
+    log2_x_hi = plog2(x);
+    log2_x_lo = pzero(x);
+  }
+};
+
+// This specialization uses a more accurate algorithm to compute log2(x) for
+// floats in [1/sqrt(2);sqrt(2)] with a relative accuracy of ~6.42e-10.
+// This additional accuracy is needed to counter the error-magnification
+// inherent in multiplying by a potentially large exponent in pow(x,y).
+// The minimax polynomial used was calculated using the Sollya tool.
+// See sollya.org.
+template <>
+struct accurate_log2<float> {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  void operator()(const Packet& z, Packet& log2_x_hi, Packet& log2_x_lo) {
+    // The function log(1+x)/x is approximated in the interval
+    // [1/sqrt(2)-1;sqrt(2)-1] by a degree 10 polynomial of the form
+    //  Q(x) = (C0 + x * (C1 + x * (C2 + x * (C3 + x * P(x))))),
+    // where the degree 6 polynomial P(x) is evaluated in single precision,
+    // while the remaining 4 terms of Q(x), as well as the final multiplication by x
+    // to reconstruct log(1+x) are evaluated in extra precision using
+    // double word arithmetic. C0 through C3 are extra precise constants
+    // stored as double words.
+    //
+    // The polynomial coefficients were calculated using Sollya commands:
+    // > n = 10;
+    // > f = log2(1+x)/x;
+    // > interval = [sqrt(0.5)-1;sqrt(2)-1];
+    // > p = fpminimax(f,n,[|double,double,double,double,single...|],interval,relative,floating);
+    
+    const Packet p6 = pset1<Packet>( 9.703654795885e-2f);
+    const Packet p5 = pset1<Packet>(-0.1690667718648f);
+    const Packet p4 = pset1<Packet>( 0.1720575392246f);
+    const Packet p3 = pset1<Packet>(-0.1789081543684f);
+    const Packet p2 = pset1<Packet>( 0.2050433009862f);
+    const Packet p1 = pset1<Packet>(-0.2404672354459f);
+    const Packet p0 = pset1<Packet>( 0.2885761857032f);
+
+    const Packet C3_hi = pset1<Packet>(-0.360674142838f);
+    const Packet C3_lo = pset1<Packet>(-6.13283912543e-09f);
+    const Packet C2_hi = pset1<Packet>(0.480897903442f);
+    const Packet C2_lo = pset1<Packet>(-1.44861207474e-08f);
+    const Packet C1_hi = pset1<Packet>(-0.721347510815f);
+    const Packet C1_lo = pset1<Packet>(-4.84483164698e-09f);
+    const Packet C0_hi = pset1<Packet>(1.44269502163f);
+    const Packet C0_lo = pset1<Packet>(2.01711713999e-08f);
+    const Packet one = pset1<Packet>(1.0f);
+
+    const Packet x = psub(z, one);
+    // Evaluate P(x) in working precision.
+    // We evaluate it in multiple parts to improve instruction level
+    // parallelism.
+    Packet x2 = pmul(x,x);
+    Packet p_even = pmadd(p6, x2, p4);
+    p_even = pmadd(p_even, x2, p2);
+    p_even = pmadd(p_even, x2, p0);
+    Packet p_odd = pmadd(p5, x2, p3);
+    p_odd = pmadd(p_odd, x2, p1);
+    Packet p = pmadd(p_odd, x, p_even);
+
+    // Now evaluate the low-order tems of Q(x) in double word precision.
+    // In the following, due to the alternating signs and the fact that
+    // |x| < sqrt(2)-1, we can assume that |C*_hi| >= q_i, and use
+    // fast_twosum instead of the slower twosum.
+    Packet q_hi, q_lo;
+    Packet t_hi, t_lo;
+    // C3 + x * p(x)
+    twoprod(p, x, t_hi, t_lo);
+    fast_twosum(C3_hi, C3_lo, t_hi, t_lo, q_hi, q_lo);
+    // C2 + x * p(x)
+    twoprod(q_hi, q_lo, x, t_hi, t_lo);
+    fast_twosum(C2_hi, C2_lo, t_hi, t_lo, q_hi, q_lo);
+    // C1 + x * p(x)
+    twoprod(q_hi, q_lo, x, t_hi, t_lo);
+    fast_twosum(C1_hi, C1_lo, t_hi, t_lo, q_hi, q_lo);
+    // C0 + x * p(x)
+    twoprod(q_hi, q_lo, x, t_hi, t_lo);
+    fast_twosum(C0_hi, C0_lo, t_hi, t_lo, q_hi, q_lo);
+
+    // log(z) ~= x * Q(x)
+    twoprod(q_hi, q_lo, x, log2_x_hi, log2_x_lo);
+  }
+};
+
+// This specialization uses a more accurate algorithm to compute log2(x) for
+// floats in [1/sqrt(2);sqrt(2)] with a relative accuracy of ~1.27e-18.
+// This additional accuracy is needed to counter the error-magnification
+// inherent in multiplying by a potentially large exponent in pow(x,y).
+// The minimax polynomial used was calculated using the Sollya tool.
+// See sollya.org.
+
+template <>
+struct accurate_log2<double> {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  void operator()(const Packet& x, Packet& log2_x_hi, Packet& log2_x_lo) {
+    // We use a transformation of variables:
+    //    r = c * (x-1) / (x+1),
+    // such that
+    //    log2(x) = log2((1 + r/c) / (1 - r/c)) = f(r).
+    // The function f(r) can be approximated well using an odd polynomial
+    // of the form
+    //   P(r) = ((Q(r^2) * r^2 + C) * r^2 + 1) * r,
+    // For the implementation of log2<double> here, Q is of degree 6 with
+    // coefficient represented in working precision (double), while C is a
+    // constant represented in extra precision as a double word to achieve
+    // full accuracy.
+    //
+    // The polynomial coefficients were computed by the Sollya script:
+    //
+    // c = 2 / log(2);
+    // trans = c * (x-1)/(x+1);
+    // itrans = (1+x/c)/(1-x/c);
+    // interval=[trans(sqrt(0.5)); trans(sqrt(2))];
+    // print(interval);
+    // f = log2(itrans(x));
+    // p=fpminimax(f,[|1,3,5,7,9,11,13,15,17|],[|1,DD,double...|],interval,relative,floating);
+    const Packet q12 = pset1<Packet>(2.87074255468000586e-9);
+    const Packet q10 = pset1<Packet>(2.38957980901884082e-8);
+    const Packet q8 = pset1<Packet>(2.31032094540014656e-7);
+    const Packet q6 = pset1<Packet>(2.27279857398537278e-6);
+    const Packet q4 = pset1<Packet>(2.31271023278625638e-5);
+    const Packet q2 = pset1<Packet>(2.47556738444535513e-4);
+    const Packet q0 = pset1<Packet>(2.88543873228900172e-3);
+    const Packet C_hi = pset1<Packet>(0.0400377511598501157);
+    const Packet C_lo = pset1<Packet>(-4.77726582251425391e-19);
+    const Packet one = pset1<Packet>(1.0);
+
+    const Packet cst_2_log2e_hi = pset1<Packet>(2.88539008177792677);
+    const Packet cst_2_log2e_lo = pset1<Packet>(4.07660016854549667e-17);
+    // c * (x - 1)
+    Packet num_hi, num_lo;
+    twoprod(cst_2_log2e_hi, cst_2_log2e_lo, psub(x, one), num_hi, num_lo);
+    // TODO(rmlarsen): Investigate if using the division algorithm by
+    // Muller et al. is faster/more accurate.
+    // 1 / (x + 1)
+    Packet denom_hi, denom_lo;
+    doubleword_reciprocal(padd(x, one), denom_hi, denom_lo);
+    // r =  c * (x-1) / (x+1),
+    Packet r_hi, r_lo;
+    twoprod(num_hi, num_lo, denom_hi, denom_lo, r_hi, r_lo);
+    // r2 = r * r
+    Packet r2_hi, r2_lo;
+    twoprod(r_hi, r_lo, r_hi, r_lo, r2_hi, r2_lo);
+    // r4 = r2 * r2
+    Packet r4_hi, r4_lo;
+    twoprod(r2_hi, r2_lo, r2_hi, r2_lo, r4_hi, r4_lo);
+
+    // Evaluate Q(r^2) in working precision. We evaluate it in two parts
+    // (even and odd in r^2) to improve instruction level parallelism.
+    Packet q_even = pmadd(q12, r4_hi, q8);
+    Packet q_odd = pmadd(q10, r4_hi, q6);
+    q_even = pmadd(q_even, r4_hi, q4);
+    q_odd = pmadd(q_odd, r4_hi, q2);
+    q_even = pmadd(q_even, r4_hi, q0);
+    Packet q = pmadd(q_odd, r2_hi, q_even);
+
+    // Now evaluate the low order terms of P(x) in double word precision.
+    // In the following, due to the increasing magnitude of the coefficients
+    // and r being constrained to [-0.5, 0.5] we can use fast_twosum instead
+    // of the slower twosum.
+    // Q(r^2) * r^2
+    Packet p_hi, p_lo;
+    twoprod(r2_hi, r2_lo, q, p_hi, p_lo);
+    // Q(r^2) * r^2 + C
+    Packet p1_hi, p1_lo;
+    fast_twosum(C_hi, C_lo, p_hi, p_lo, p1_hi, p1_lo);
+    // (Q(r^2) * r^2 + C) * r^2
+    Packet p2_hi, p2_lo;
+    twoprod(r2_hi, r2_lo, p1_hi, p1_lo, p2_hi, p2_lo);
+    // ((Q(r^2) * r^2 + C) * r^2 + 1)
+    Packet p3_hi, p3_lo;
+    fast_twosum(one, p2_hi, p2_lo, p3_hi, p3_lo);
+
+    // log(z) ~= ((Q(r^2) * r^2 + C) * r^2 + 1) * r
+    twoprod(p3_hi, p3_lo, r_hi, r_lo, log2_x_hi, log2_x_lo);
+  }
+};
+
+// This function computes exp2(x) (i.e. 2**x).
+template <typename Scalar>
+struct fast_accurate_exp2 {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  Packet operator()(const Packet& x) {
+    // TODO(rmlarsen): Add a pexp2 packetop.
+    return pexp(pmul(pset1<Packet>(Scalar(EIGEN_LN2)), x));
+  }
+};
+
+// This specialization uses a faster algorithm to compute exp2(x) for floats
+// in [-0.5;0.5] with a relative accuracy of 1 ulp.
+// The minimax polynomial used was calculated using the Sollya tool.
+// See sollya.org.
+template <>
+struct fast_accurate_exp2<float> {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  Packet operator()(const Packet& x) {
+    // This function approximates exp2(x) by a degree 6 polynomial of the form
+    // Q(x) = 1 + x * (C + x * P(x)), where the degree 4 polynomial P(x) is evaluated in
+    // single precision, and the remaining steps are evaluated with extra precision using
+    // double word arithmetic. C is an extra precise constant stored as a double word.
+    //
+    // The polynomial coefficients were calculated using Sollya commands:
+    // > n = 6;
+    // > f = 2^x;
+    // > interval = [-0.5;0.5];
+    // > p = fpminimax(f,n,[|1,double,single...|],interval,relative,floating);
+
+    const Packet p4 = pset1<Packet>(1.539513905e-4f);
+    const Packet p3 = pset1<Packet>(1.340007293e-3f);
+    const Packet p2 = pset1<Packet>(9.618283249e-3f);
+    const Packet p1 = pset1<Packet>(5.550328270e-2f);
+    const Packet p0 = pset1<Packet>(0.2402264923f);
+
+    const Packet C_hi = pset1<Packet>(0.6931471825f);
+    const Packet C_lo = pset1<Packet>(2.36836577e-08f);
+    const Packet one = pset1<Packet>(1.0f);
+
+    // Evaluate P(x) in working precision.
+    // We evaluate even and odd parts of the polynomial separately
+    // to gain some instruction level parallelism.
+    Packet x2 = pmul(x,x);
+    Packet p_even = pmadd(p4, x2, p2);
+    Packet p_odd = pmadd(p3, x2, p1);
+    p_even = pmadd(p_even, x2, p0);
+    Packet p = pmadd(p_odd, x, p_even);
+
+    // Evaluate the remaining terms of Q(x) with extra precision using
+    // double word arithmetic.
+    Packet p_hi, p_lo;
+    // x * p(x)
+    twoprod(p, x, p_hi, p_lo);
+    // C + x * p(x)
+    Packet q1_hi, q1_lo;
+    twosum(p_hi, p_lo, C_hi, C_lo, q1_hi, q1_lo);
+    // x * (C + x * p(x))
+    Packet q2_hi, q2_lo;
+    twoprod(q1_hi, q1_lo, x, q2_hi, q2_lo);
+    // 1 + x * (C + x * p(x))
+    Packet q3_hi, q3_lo;
+    // Since |q2_hi| <= sqrt(2)-1 < 1, we can use fast_twosum
+    // for adding it to unity here.
+    fast_twosum(one, q2_hi, q3_hi, q3_lo);
+    return padd(q3_hi, padd(q2_lo, q3_lo));
+  }
+};
+
+// in [-0.5;0.5] with a relative accuracy of 1 ulp.
+// The minimax polynomial used was calculated using the Sollya tool.
+// See sollya.org.
+template <>
+struct fast_accurate_exp2<double> {
+  template <typename Packet>
+  EIGEN_STRONG_INLINE
+  Packet operator()(const Packet& x) {
+    // This function approximates exp2(x) by a degree 10 polynomial of the form
+    // Q(x) = 1 + x * (C + x * P(x)), where the degree 8 polynomial P(x) is evaluated in
+    // single precision, and the remaining steps are evaluated with extra precision using
+    // double word arithmetic. C is an extra precise constant stored as a double word.
+    //
+    // The polynomial coefficients were calculated using Sollya commands:
+    // > n = 11;
+    // > f = 2^x;
+    // > interval = [-0.5;0.5];
+    // > p = fpminimax(f,n,[|1,DD,double...|],interval,relative,floating);
+
+    const Packet p9 = pset1<Packet>(4.431642109085495276e-10);
+    const Packet p8 = pset1<Packet>(7.073829923303358410e-9);
+    const Packet p7 = pset1<Packet>(1.017822306737031311e-7);
+    const Packet p6 = pset1<Packet>(1.321543498017646657e-6);
+    const Packet p5 = pset1<Packet>(1.525273342728892877e-5);
+    const Packet p4 = pset1<Packet>(1.540353045780084423e-4);
+    const Packet p3 = pset1<Packet>(1.333355814685869807e-3);
+    const Packet p2 = pset1<Packet>(9.618129107593478832e-3);
+    const Packet p1 = pset1<Packet>(5.550410866481961247e-2);
+    const Packet p0 = pset1<Packet>(0.240226506959101332);
+    const Packet C_hi = pset1<Packet>(0.693147180559945286); 
+    const Packet C_lo = pset1<Packet>(4.81927865669806721e-17);
+    const Packet one = pset1<Packet>(1.0);
+
+    // Evaluate P(x) in working precision.
+    // We evaluate even and odd parts of the polynomial separately
+    // to gain some instruction level parallelism.
+    Packet x2 = pmul(x,x);
+    Packet p_even = pmadd(p8, x2, p6);
+    Packet p_odd = pmadd(p9, x2, p7);
+    p_even = pmadd(p_even, x2, p4);
+    p_odd = pmadd(p_odd, x2, p5);
+    p_even = pmadd(p_even, x2, p2);
+    p_odd = pmadd(p_odd, x2, p3);
+    p_even = pmadd(p_even, x2, p0);
+    p_odd = pmadd(p_odd, x2, p1);
+    Packet p = pmadd(p_odd, x, p_even);
+
+    // Evaluate the remaining terms of Q(x) with extra precision using
+    // double word arithmetic.
+    Packet p_hi, p_lo;
+    // x * p(x)
+    twoprod(p, x, p_hi, p_lo);
+    // C + x * p(x)
+    Packet q1_hi, q1_lo;
+    twosum(p_hi, p_lo, C_hi, C_lo, q1_hi, q1_lo);
+    // x * (C + x * p(x))
+    Packet q2_hi, q2_lo;
+    twoprod(q1_hi, q1_lo, x, q2_hi, q2_lo);
+    // 1 + x * (C + x * p(x))
+    Packet q3_hi, q3_lo;
+    // Since |q2_hi| <= sqrt(2)-1 < 1, we can use fast_twosum
+    // for adding it to unity here.
+    fast_twosum(one, q2_hi, q3_hi, q3_lo);
+    return padd(q3_hi, padd(q2_lo, q3_lo));
+  }
+};
+
+// This function implements the non-trivial case of pow(x,y) where x is
+// positive and y is (possibly) non-integer.
+// Formally, pow(x,y) = exp2(y * log2(x)), where exp2(x) is shorthand for 2^x.
+// TODO(rmlarsen): We should probably add this as a packet up 'ppow', to make it
+// easier to specialize or turn off for specific types and/or backends.x
+template <typename Packet>
+EIGEN_STRONG_INLINE Packet generic_pow_impl(const Packet& x, const Packet& y) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+  // Split x into exponent e_x and mantissa m_x.
+  Packet e_x;
+  Packet m_x = pfrexp(x, e_x);
+
+  // Adjust m_x to lie in [1/sqrt(2):sqrt(2)] to minimize absolute error in log2(m_x).
+  EIGEN_CONSTEXPR Scalar sqrt_half = Scalar(0.70710678118654752440);
+  const Packet m_x_scale_mask = pcmp_lt(m_x, pset1<Packet>(sqrt_half));
+  m_x = pselect(m_x_scale_mask, pmul(pset1<Packet>(Scalar(2)), m_x), m_x);
+  e_x = pselect(m_x_scale_mask, psub(e_x, pset1<Packet>(Scalar(1))), e_x);
+
+  // Compute log2(m_x) with 6 extra bits of accuracy.
+  Packet rx_hi, rx_lo;
+  accurate_log2<Scalar>()(m_x, rx_hi, rx_lo);
+
+  // Compute the two terms {y * e_x, y * r_x} in f = y * log2(x) with doubled
+  // precision using double word arithmetic.
+  Packet f1_hi, f1_lo, f2_hi, f2_lo;
+  twoprod(e_x, y, f1_hi, f1_lo);
+  twoprod(rx_hi, rx_lo, y, f2_hi, f2_lo);
+  // Sum the two terms in f using double word arithmetic. We know
+  // that |e_x| > |log2(m_x)|, except for the case where e_x==0.
+  // This means that we can use fast_twosum(f1,f2).
+  // In the case e_x == 0, e_x * y = f1 = 0, so we don't lose any
+  // accuracy by violating the assumption of fast_twosum, because
+  // it's a no-op.
+  Packet f_hi, f_lo;
+  fast_twosum(f1_hi, f1_lo, f2_hi, f2_lo, f_hi, f_lo);
+
+  // Split f into integer and fractional parts.
+  Packet n_z, r_z;
+  absolute_split(f_hi, n_z, r_z);
+  r_z = padd(r_z, f_lo);
+  Packet n_r;
+  absolute_split(r_z, n_r, r_z);
+  n_z = padd(n_z, n_r);
+
+  // We now have an accurate split of f = n_z + r_z and can compute
+  //   x^y = 2**{n_z + r_z) = exp2(r_z) * 2**{n_z}.
+  // Since r_z is in [-0.5;0.5], we compute the first factor to high accuracy
+  // using a specialized algorithm. Multiplication by the second factor can
+  // be done exactly using pldexp(), since it is an integer power of 2.
+  const Packet e_r = fast_accurate_exp2<Scalar>()(r_z);
+  return pldexp(e_r, n_z);
+}
+
+// Generic implementation of pow(x,y).
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet generic_pow(const Packet& x, const Packet& y) {
+  typedef typename unpacket_traits<Packet>::type Scalar;
+
+  const Packet cst_pos_inf = pset1<Packet>(NumTraits<Scalar>::infinity());
+  const Packet cst_zero = pset1<Packet>(Scalar(0));
+  const Packet cst_one = pset1<Packet>(Scalar(1));
+  const Packet cst_nan = pset1<Packet>(NumTraits<Scalar>::quiet_NaN());
+
+  const Packet abs_x = pabs(x);
+  // Predicates for sign and magnitude of x.
+  const Packet x_is_zero = pcmp_eq(x, cst_zero);
+  const Packet x_is_neg = pcmp_lt(x, cst_zero);
+  const Packet abs_x_is_inf = pcmp_eq(abs_x, cst_pos_inf);
+  const Packet abs_x_is_one =  pcmp_eq(abs_x, cst_one);
+  const Packet abs_x_is_gt_one = pcmp_lt(cst_one, abs_x);
+  const Packet abs_x_is_lt_one = pcmp_lt(abs_x, cst_one);
+  const Packet x_is_one =  pandnot(abs_x_is_one, x_is_neg);
+  const Packet x_is_neg_one =  pand(abs_x_is_one, x_is_neg);
+  const Packet x_is_nan = pandnot(ptrue(x), pcmp_eq(x, x));
+
+  // Predicates for sign and magnitude of y.
+  const Packet y_is_one = pcmp_eq(y, cst_one);
+  const Packet y_is_zero = pcmp_eq(y, cst_zero);
+  const Packet y_is_neg = pcmp_lt(y, cst_zero);
+  const Packet y_is_pos = pandnot(ptrue(y), por(y_is_zero, y_is_neg));
+  const Packet y_is_nan = pandnot(ptrue(y), pcmp_eq(y, y));
+  const Packet abs_y_is_inf = pcmp_eq(pabs(y), cst_pos_inf);
+  EIGEN_CONSTEXPR Scalar huge_exponent =
+      (NumTraits<Scalar>::max_exponent() * Scalar(EIGEN_LN2)) /
+       NumTraits<Scalar>::epsilon();
+  const Packet abs_y_is_huge = pcmp_le(pset1<Packet>(huge_exponent), pabs(y));
+
+  // Predicates for whether y is integer and/or even.
+  const Packet y_is_int = pcmp_eq(pfloor(y), y);
+  const Packet y_div_2 = pmul(y, pset1<Packet>(Scalar(0.5)));
+  const Packet y_is_even = pcmp_eq(pround(y_div_2), y_div_2);
+
+  // Predicates encoding special cases for the value of pow(x,y)
+  const Packet invalid_negative_x = pandnot(pandnot(pandnot(x_is_neg, abs_x_is_inf),
+                                                    y_is_int),
+                                            abs_y_is_inf);
+  const Packet pow_is_one = por(por(x_is_one, y_is_zero),
+                                pand(x_is_neg_one,
+                                     por(abs_y_is_inf, pandnot(y_is_even, invalid_negative_x))));
+  const Packet pow_is_nan = por(invalid_negative_x, por(x_is_nan, y_is_nan));
+  const Packet pow_is_zero = por(por(por(pand(x_is_zero, y_is_pos),
+                                         pand(abs_x_is_inf, y_is_neg)),
+                                     pand(pand(abs_x_is_lt_one, abs_y_is_huge),
+                                          y_is_pos)),
+                                 pand(pand(abs_x_is_gt_one, abs_y_is_huge),
+                                      y_is_neg));
+  const Packet pow_is_inf = por(por(por(pand(x_is_zero, y_is_neg),
+                                        pand(abs_x_is_inf, y_is_pos)),
+                                    pand(pand(abs_x_is_lt_one, abs_y_is_huge),
+                                         y_is_neg)),
+                                pand(pand(abs_x_is_gt_one, abs_y_is_huge),
+                                     y_is_pos));
+
+  // General computation of pow(x,y) for positive x or negative x and integer y.
+  const Packet negate_pow_abs = pandnot(x_is_neg, y_is_even);
+  const Packet pow_abs = generic_pow_impl(abs_x, y);
+  return pselect(y_is_one, x,
+                 pselect(pow_is_one, cst_one,
+                         pselect(pow_is_nan, cst_nan,
+                                 pselect(pow_is_inf, cst_pos_inf,
+                                         pselect(pow_is_zero, cst_zero,
+                                                 pselect(negate_pow_abs, pnegate(pow_abs), pow_abs))))));
+}
+
+
+
+/* polevl (modified for Eigen)
+ *
+ *      Evaluate polynomial
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * int N;
+ * Scalar x, y, coef[N+1];
+ *
+ * y = polevl<decltype(x), N>( x, coef);
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Evaluates polynomial of degree N:
+ *
+ *                     2          N
+ * y  =  C  + C x + C x  +...+ C x
+ *        0    1     2          N
+ *
+ * Coefficients are stored in reverse order:
+ *
+ * coef[0] = C  , ..., coef[N] = C  .
+ *            N                   0
+ *
+ *  The function p1evl() assumes that coef[N] = 1.0 and is
+ * omitted from the array.  Its calling arguments are
+ * otherwise the same as polevl().
+ *
+ *
+ * The Eigen implementation is templatized.  For best speed, store
+ * coef as a const array (constexpr), e.g.
+ *
+ * const double coef[] = {1.0, 2.0, 3.0, ...};
+ *
+ */
+template <typename Packet, int N>
+struct ppolevl {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& x, const typename unpacket_traits<Packet>::type coeff[]) {
+    EIGEN_STATIC_ASSERT((N > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return pmadd(ppolevl<Packet, N-1>::run(x, coeff), x, pset1<Packet>(coeff[N]));
+  }
+};
+
+template <typename Packet>
+struct ppolevl<Packet, 0> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& x, const typename unpacket_traits<Packet>::type coeff[]) {
+    EIGEN_UNUSED_VARIABLE(x);
+    return pset1<Packet>(coeff[0]);
+  }
+};
+
+/* chbevl (modified for Eigen)
+ *
+ *     Evaluate Chebyshev series
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * int N;
+ * Scalar x, y, coef[N], chebevl();
+ *
+ * y = chbevl( x, coef, N );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Evaluates the series
+ *
+ *        N-1
+ *         - '
+ *  y  =   >   coef[i] T (x/2)
+ *         -            i
+ *        i=0
+ *
+ * of Chebyshev polynomials Ti at argument x/2.
+ *
+ * Coefficients are stored in reverse order, i.e. the zero
+ * order term is last in the array.  Note N is the number of
+ * coefficients, not the order.
+ *
+ * If coefficients are for the interval a to b, x must
+ * have been transformed to x -> 2(2x - b - a)/(b-a) before
+ * entering the routine.  This maps x from (a, b) to (-1, 1),
+ * over which the Chebyshev polynomials are defined.
+ *
+ * If the coefficients are for the inverted interval, in
+ * which (a, b) is mapped to (1/b, 1/a), the transformation
+ * required is x -> 2(2ab/x - b - a)/(b-a).  If b is infinity,
+ * this becomes x -> 4a/x - 1.
+ *
+ *
+ *
+ * SPEED:
+ *
+ * Taking advantage of the recurrence properties of the
+ * Chebyshev polynomials, the routine requires one more
+ * addition per loop than evaluating a nested polynomial of
+ * the same degree.
+ *
+ */
+
+template <typename Packet, int N>
+struct pchebevl {
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE Packet run(Packet x, const typename unpacket_traits<Packet>::type coef[]) {
+    typedef typename unpacket_traits<Packet>::type Scalar;
+    Packet b0 = pset1<Packet>(coef[0]);
+    Packet b1 = pset1<Packet>(static_cast<Scalar>(0.f));
+    Packet b2;
+
+    for (int i = 1; i < N; i++) {
+      b2 = b1;
+      b1 = b0;
+      b0 = psub(pmadd(x, b1, pset1<Packet>(coef[i])), b2);
+    }
+
+    return pmul(pset1<Packet>(static_cast<Scalar>(0.5f)), psub(b0, b2));
+  }
+};
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
new file mode 100644
index 00000000..177a04e9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
@@ -0,0 +1,110 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2019 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_FWD_H
+#define EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_FWD_H
+
+namespace Eigen {
+namespace internal {
+
+// Forward declarations of the generic math functions
+// implemented in GenericPacketMathFunctions.h
+// This is needed to workaround a circular dependency.
+
+/***************************************************************************
+ * Some generic implementations to be used by implementors
+***************************************************************************/
+
+/** Default implementation of pfrexp.
+  * It is expected to be called by implementers of template<> pfrexp.
+  */
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+Packet pfrexp_generic(const Packet& a, Packet& exponent);
+
+// Extracts the biased exponent value from Packet p, and casts the results to
+// a floating-point Packet type. Used by pfrexp_generic. Override this if
+// there is no unpacket_traits<Packet>::integer_packet.
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+Packet pfrexp_generic_get_biased_exponent(const Packet& p);
+
+/** Default implementation of pldexp.
+  * It is expected to be called by implementers of template<> pldexp.
+  */
+template<typename Packet> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+Packet pldexp_generic(const Packet& a, const Packet& exponent);
+
+/** \internal \returns log(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_float(const Packet _x);
+
+/** \internal \returns log2(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog2_float(const Packet _x);
+
+/** \internal \returns log(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog_double(const Packet _x);
+
+/** \internal \returns log2(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet plog2_double(const Packet _x);
+
+/** \internal \returns log(1 + x) */
+template<typename Packet>
+Packet generic_plog1p(const Packet& x);
+
+/** \internal \returns exp(x)-1 */
+template<typename Packet>
+Packet generic_expm1(const Packet& x);
+
+/** \internal \returns exp(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pexp_float(const Packet _x);
+
+/** \internal \returns exp(x) for double precision real numbers */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pexp_double(const Packet _x);
+
+/** \internal \returns sin(x) for single precision float */
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet psin_float(const Packet& x);
+
+/** \internal \returns cos(x) for single precision float */
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet pcos_float(const Packet& x);
+
+/** \internal \returns sqrt(x) for complex types */
+template<typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
+EIGEN_UNUSED
+Packet psqrt_complex(const Packet& a);
+
+template <typename Packet, int N> struct ppolevl;
+
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_FWD_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/Half.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/Half.h
new file mode 100644
index 00000000..9f8e8cc1
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/Half.h
@@ -0,0 +1,942 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// The conversion routines are Copyright (c) Fabian Giesen, 2016.
+// The original license follows:
+//
+// Copyright (c) Fabian Giesen, 2016
+// All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted.
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Standard 16-bit float type, mostly useful for GPUs. Defines a new
+// type Eigen::half (inheriting either from CUDA's or HIP's __half struct) with
+// operator overloads such that it behaves basically as an arithmetic
+// type. It will be quite slow on CPUs (so it is recommended to stay
+// in fp32 for CPUs, except for simple parameter conversions, I/O
+// to disk and the likes), but fast on GPUs.
+
+
+#ifndef EIGEN_HALF_H
+#define EIGEN_HALF_H
+
+#include <sstream>
+
+#if defined(EIGEN_HAS_GPU_FP16) || defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+// When compiling with GPU support, the "__half_raw" base class as well as
+// some other routines are defined in the GPU compiler header files
+// (cuda_fp16.h, hip_fp16.h), and they are not tagged constexpr
+// As a consequence, we get compile failures when compiling Eigen with
+// GPU support. Hence the need to disable EIGEN_CONSTEXPR when building
+// Eigen with GPU support
+  #pragma push_macro("EIGEN_CONSTEXPR")
+  #undef EIGEN_CONSTEXPR
+  #define EIGEN_CONSTEXPR
+#endif
+
+#define F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, METHOD)           \
+  template <>                                                       \
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_UNUSED                \
+  PACKET_F16 METHOD<PACKET_F16>(const PACKET_F16& _x) {             \
+    return float2half(METHOD<PACKET_F>(half2float(_x)));            \
+  }
+
+namespace Eigen {
+
+struct half;
+
+namespace half_impl {
+
+// We want to use the __half_raw struct from the HIP header file only during the device compile phase.
+// This is required because of a quirk in the way TensorFlow GPU builds are done.
+// When compiling TensorFlow source code with GPU support, files that
+//  * contain GPU kernels (i.e. *.cu.cc files) are compiled via hipcc
+//  * do not contain GPU kernels ( i.e. *.cc files) are compiled via gcc (typically)
+//
+// Tensorflow uses the Eigen::half type as its FP16 type, and there are functions that
+//  * are defined in a file that gets compiled via hipcc AND
+//  * have Eigen::half as a pass-by-value argument AND
+//  * are called in a file that gets compiled via gcc
+//
+// In the scenario described above the caller and callee will see different versions
+// of the Eigen::half base class __half_raw, and they will be compiled by different compilers
+//
+// There appears to be an ABI mismatch between gcc and clang (which is called by hipcc) that results in
+// the callee getting corrupted values for the Eigen::half argument.
+//
+// Making the host side compile phase of hipcc use the same Eigen::half impl, as the gcc compile, resolves
+// this error, and hence the following convoluted #if condition
+#if !defined(EIGEN_HAS_GPU_FP16) || !defined(EIGEN_GPU_COMPILE_PHASE)
+// Make our own __half_raw definition that is similar to CUDA's.
+struct __half_raw {
+#if (defined(EIGEN_HAS_GPU_FP16) && !defined(EIGEN_GPU_COMPILE_PHASE))
+  // Eigen::half can be used as the datatype for shared memory declarations (in Eigen and TF)
+  // The element type for shared memory cannot have non-trivial constructors
+  // and hence the following special casing (which skips the zero-initilization).
+  // Note that this check gets done even in the host compilation phase, and
+  // hence the need for this
+  EIGEN_DEVICE_FUNC __half_raw() {}
+#else
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw() : x(0) {}
+#endif
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw(numext::uint16_t raw) : x(numext::bit_cast<__fp16>(raw)) {
+  }
+  __fp16 x;
+#else
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw(numext::uint16_t raw) : x(raw) {}
+  numext::uint16_t x;
+#endif
+};
+
+#elif defined(EIGEN_HAS_HIP_FP16)
+  // Nothing to do here
+  // HIP fp16 header file has a definition for __half_raw
+#elif defined(EIGEN_HAS_CUDA_FP16)
+  #if EIGEN_CUDA_SDK_VER < 90000
+    // In CUDA < 9.0, __half is the equivalent of CUDA 9's __half_raw
+    typedef __half __half_raw;
+  #endif // defined(EIGEN_HAS_CUDA_FP16)
+#elif defined(SYCL_DEVICE_ONLY)
+  typedef cl::sycl::half __half_raw;
+#endif
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw raw_uint16_to_half(numext::uint16_t x);
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(float ff);
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float half_to_float(__half_raw h);
+
+struct half_base : public __half_raw {
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half_base() {}
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half_base(const __half_raw& h) : __half_raw(h) {}
+
+#if defined(EIGEN_HAS_GPU_FP16)
+ #if defined(EIGEN_HAS_HIP_FP16)
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half_base(const __half& h) { x = __half_as_ushort(h); }
+ #elif defined(EIGEN_HAS_CUDA_FP16)
+  #if EIGEN_CUDA_SDK_VER >= 90000
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half_base(const __half& h) : __half_raw(*(__half_raw*)&h) {}
+  #endif
+ #endif
+#endif
+};
+
+} // namespace half_impl
+
+// Class definition.
+struct half : public half_impl::half_base {
+
+  // Writing this out as separate #if-else blocks to make the code easier to follow
+  // The same applies to most #if-else blocks in this file
+#if !defined(EIGEN_HAS_GPU_FP16) || !defined(EIGEN_GPU_COMPILE_PHASE)
+  // Use the same base class for the following two scenarios
+  // * when compiling without GPU support enabled
+  // * during host compile phase when compiling with GPU support enabled
+  typedef half_impl::__half_raw __half_raw;
+#elif defined(EIGEN_HAS_HIP_FP16)
+  // Nothing to do here
+  // HIP fp16 header file has a definition for __half_raw
+#elif defined(EIGEN_HAS_CUDA_FP16)
+  // Note that EIGEN_CUDA_SDK_VER is set to 0 even when compiling with HIP, so
+  // (EIGEN_CUDA_SDK_VER < 90000) is true even for HIP!  So keeping this within
+  // #if defined(EIGEN_HAS_CUDA_FP16) is needed
+  #if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000
+    typedef half_impl::__half_raw __half_raw;
+  #endif
+#endif
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half(const __half_raw& h) : half_impl::half_base(h) {}
+
+#if defined(EIGEN_HAS_GPU_FP16)
+ #if defined(EIGEN_HAS_HIP_FP16)
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half(const __half& h) : half_impl::half_base(h) {}
+ #elif defined(EIGEN_HAS_CUDA_FP16)
+  #if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER >= 90000
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half(const __half& h) : half_impl::half_base(h) {}
+  #endif
+ #endif
+#endif
+
+
+  explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half(bool b)
+      : half_impl::half_base(half_impl::raw_uint16_to_half(b ? 0x3c00 : 0)) {}
+  template<class T>
+  explicit EIGEN_DEVICE_FUNC half(T val)
+      : half_impl::half_base(half_impl::float_to_half_rtne(static_cast<float>(val))) {}
+  explicit EIGEN_DEVICE_FUNC half(float f)
+      : half_impl::half_base(half_impl::float_to_half_rtne(f)) {}
+
+  // Following the convention of numpy, converting between complex and
+  // float will lead to loss of imag value.
+  template<typename RealScalar>
+  explicit EIGEN_DEVICE_FUNC half(std::complex<RealScalar> c)
+      : half_impl::half_base(half_impl::float_to_half_rtne(static_cast<float>(c.real()))) {}
+
+   EIGEN_DEVICE_FUNC operator float() const {  // NOLINT: Allow implicit conversion to float, because it is lossless.
+    return half_impl::half_to_float(*this);
+  }
+
+#if defined(EIGEN_HAS_GPU_FP16) && !defined(EIGEN_GPU_COMPILE_PHASE)
+  EIGEN_DEVICE_FUNC operator __half() const {
+    ::__half_raw hr;
+    hr.x = x;
+    return __half(hr);
+  }
+#endif
+};
+
+} // end namespace Eigen
+
+namespace std {
+template<>
+struct numeric_limits<Eigen::half> {
+  static const bool is_specialized = true;
+  static const bool is_signed = true;
+  static const bool is_integer = false;
+  static const bool is_exact = false;
+  static const bool has_infinity = true;
+  static const bool has_quiet_NaN = true;
+  static const bool has_signaling_NaN = true;
+  static const float_denorm_style has_denorm = denorm_present;
+  static const bool has_denorm_loss = false;
+  static const std::float_round_style round_style = std::round_to_nearest;
+  static const bool is_iec559 = false;
+  static const bool is_bounded = false;
+  static const bool is_modulo = false;
+  static const int digits = 11;
+  static const int digits10 = 3;      // according to http://half.sourceforge.net/structstd_1_1numeric__limits_3_01half__float_1_1half_01_4.html
+  static const int max_digits10 = 5;  // according to http://half.sourceforge.net/structstd_1_1numeric__limits_3_01half__float_1_1half_01_4.html
+  static const int radix = 2;
+  static const int min_exponent = -13;
+  static const int min_exponent10 = -4;
+  static const int max_exponent = 16;
+  static const int max_exponent10 = 4;
+  static const bool traps = true;
+  static const bool tinyness_before = false;
+
+  static Eigen::half (min)() { return Eigen::half_impl::raw_uint16_to_half(0x400); }
+  static Eigen::half lowest() { return Eigen::half_impl::raw_uint16_to_half(0xfbff); }
+  static Eigen::half (max)() { return Eigen::half_impl::raw_uint16_to_half(0x7bff); }
+  static Eigen::half epsilon() { return Eigen::half_impl::raw_uint16_to_half(0x0800); }
+  static Eigen::half round_error() { return Eigen::half(0.5); }
+  static Eigen::half infinity() { return Eigen::half_impl::raw_uint16_to_half(0x7c00); }
+  static Eigen::half quiet_NaN() { return Eigen::half_impl::raw_uint16_to_half(0x7e00); }
+  static Eigen::half signaling_NaN() { return Eigen::half_impl::raw_uint16_to_half(0x7d00); }
+  static Eigen::half denorm_min() { return Eigen::half_impl::raw_uint16_to_half(0x1); }
+};
+
+// If std::numeric_limits<T> is specialized, should also specialize
+// std::numeric_limits<const T>, std::numeric_limits<volatile T>, and
+// std::numeric_limits<const volatile T>
+// https://stackoverflow.com/a/16519653/
+template<>
+struct numeric_limits<const Eigen::half> : numeric_limits<Eigen::half> {};
+template<>
+struct numeric_limits<volatile Eigen::half> : numeric_limits<Eigen::half> {};
+template<>
+struct numeric_limits<const volatile Eigen::half> : numeric_limits<Eigen::half> {};
+} // end namespace std
+
+namespace Eigen {
+
+namespace half_impl {
+
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && \
+     EIGEN_CUDA_ARCH >= 530) ||                                  \
+    (defined(EIGEN_HAS_HIP_FP16) && defined(HIP_DEVICE_COMPILE))
+// Note: We deliberatly do *not* define this to 1 even if we have Arm's native
+// fp16 type since GPU halfs are rather different from native CPU halfs.
+// TODO: Rename to something like EIGEN_HAS_NATIVE_GPU_FP16
+#define EIGEN_HAS_NATIVE_FP16
+#endif
+
+// Intrinsics for native fp16 support. Note that on current hardware,
+// these are no faster than fp32 arithmetic (you need to use the half2
+// versions to get the ALU speed increased), but you do save the
+// conversion steps back and forth.
+
+#if defined(EIGEN_HAS_NATIVE_FP16)
+EIGEN_STRONG_INLINE __device__ half operator + (const half& a, const half& b) {
+#if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER >= 90000
+  return __hadd(::__half(a), ::__half(b));
+#else
+  return __hadd(a, b);
+#endif
+}
+EIGEN_STRONG_INLINE __device__ half operator * (const half& a, const half& b) {
+  return __hmul(a, b);
+}
+EIGEN_STRONG_INLINE __device__ half operator - (const half& a, const half& b) {
+  return __hsub(a, b);
+}
+EIGEN_STRONG_INLINE __device__ half operator / (const half& a, const half& b) {
+#if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER >= 90000
+  return __hdiv(a, b);
+#else
+  float num = __half2float(a);
+  float denom = __half2float(b);
+  return __float2half(num / denom);
+#endif
+}
+EIGEN_STRONG_INLINE __device__ half operator - (const half& a) {
+  return __hneg(a);
+}
+EIGEN_STRONG_INLINE __device__ half& operator += (half& a, const half& b) {
+  a = a + b;
+  return a;
+}
+EIGEN_STRONG_INLINE __device__ half& operator *= (half& a, const half& b) {
+  a = a * b;
+  return a;
+}
+EIGEN_STRONG_INLINE __device__ half& operator -= (half& a, const half& b) {
+  a = a - b;
+  return a;
+}
+EIGEN_STRONG_INLINE __device__ half& operator /= (half& a, const half& b) {
+  a = a / b;
+  return a;
+}
+EIGEN_STRONG_INLINE __device__ bool operator == (const half& a, const half& b) {
+  return __heq(a, b);
+}
+EIGEN_STRONG_INLINE __device__ bool operator != (const half& a, const half& b) {
+  return __hne(a, b);
+}
+EIGEN_STRONG_INLINE __device__ bool operator < (const half& a, const half& b) {
+  return __hlt(a, b);
+}
+EIGEN_STRONG_INLINE __device__ bool operator <= (const half& a, const half& b) {
+  return __hle(a, b);
+}
+EIGEN_STRONG_INLINE __device__ bool operator > (const half& a, const half& b) {
+  return __hgt(a, b);
+}
+EIGEN_STRONG_INLINE __device__ bool operator >= (const half& a, const half& b) {
+  return __hge(a, b);
+}
+#endif
+
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator + (const half& a, const half& b) {
+  return half(vaddh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator * (const half& a, const half& b) {
+  return half(vmulh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (const half& a, const half& b) {
+  return half(vsubh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator / (const half& a, const half& b) {
+  return half(vdivh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (const half& a) {
+  return half(vnegh_f16(a.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator += (half& a, const half& b) {
+  a = half(vaddh_f16(a.x, b.x));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator *= (half& a, const half& b) {
+  a = half(vmulh_f16(a.x, b.x));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator -= (half& a, const half& b) {
+  a = half(vsubh_f16(a.x, b.x));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator /= (half& a, const half& b) {
+  a = half(vdivh_f16(a.x, b.x));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator == (const half& a, const half& b) {
+  return vceqh_f16(a.x, b.x);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator != (const half& a, const half& b) {
+  return !vceqh_f16(a.x, b.x);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator < (const half& a, const half& b) {
+  return vclth_f16(a.x, b.x);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator <= (const half& a, const half& b) {
+  return vcleh_f16(a.x, b.x);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator > (const half& a, const half& b) {
+  return vcgth_f16(a.x, b.x);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator >= (const half& a, const half& b) {
+  return vcgeh_f16(a.x, b.x);
+}
+// We need to distinguish ‘clang as the CUDA compiler’ from ‘clang as the host compiler,
+// invoked by NVCC’ (e.g. on MacOS). The former needs to see both host and device implementation
+// of the functions, while the latter can only deal with one of them.
+#elif !defined(EIGEN_HAS_NATIVE_FP16) || (EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC) // Emulate support for half floats
+
+#if EIGEN_COMP_CLANG && defined(EIGEN_CUDACC)
+// We need to provide emulated *host-side* FP16 operators for clang.
+#pragma push_macro("EIGEN_DEVICE_FUNC")
+#undef EIGEN_DEVICE_FUNC
+#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_HAS_NATIVE_FP16)
+#define EIGEN_DEVICE_FUNC __host__
+#else // both host and device need emulated ops.
+#define EIGEN_DEVICE_FUNC __host__ __device__
+#endif
+#endif
+
+// Definitions for CPUs and older HIP+CUDA, mostly working through conversion
+// to/from fp32.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator + (const half& a, const half& b) {
+  return half(float(a) + float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator * (const half& a, const half& b) {
+  return half(float(a) * float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (const half& a, const half& b) {
+  return half(float(a) - float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator / (const half& a, const half& b) {
+  return half(float(a) / float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (const half& a) {
+  half result;
+  result.x = a.x ^ 0x8000;
+  return result;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator += (half& a, const half& b) {
+  a = half(float(a) + float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator *= (half& a, const half& b) {
+  a = half(float(a) * float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator -= (half& a, const half& b) {
+  a = half(float(a) - float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator /= (half& a, const half& b) {
+  a = half(float(a) / float(b));
+  return a;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator == (const half& a, const half& b) {
+  return numext::equal_strict(float(a),float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator != (const half& a, const half& b) {
+  return numext::not_equal_strict(float(a), float(b));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator < (const half& a, const half& b) {
+  return float(a) < float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator <= (const half& a, const half& b) {
+  return float(a) <= float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator > (const half& a, const half& b) {
+  return float(a) > float(b);
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator >= (const half& a, const half& b) {
+  return float(a) >= float(b);
+}
+
+#if defined(__clang__) && defined(__CUDA__)
+#pragma pop_macro("EIGEN_DEVICE_FUNC")
+#endif
+#endif  // Emulate support for half floats
+
+// Division by an index. Do it in full float precision to avoid accuracy
+// issues in converting the denominator to half.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator / (const half& a, Index b) {
+  return half(static_cast<float>(a) / static_cast<float>(b));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator++(half& a) {
+  a += half(1);
+  return a;
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator--(half& a) {
+  a -= half(1);
+  return a;
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator++(half& a, int) {
+  half original_value = a;
+  ++a;
+  return original_value;
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator--(half& a, int) {
+  half original_value = a;
+  --a;
+  return original_value;
+}
+
+// Conversion routines, including fallbacks for the host or older CUDA.
+// Note that newer Intel CPUs (Haswell or newer) have vectorized versions of
+// these in hardware. If we need more performance on older/other CPUs, they are
+// also possible to vectorize directly.
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw raw_uint16_to_half(numext::uint16_t x) {
+  // We cannot simply do a "return __half_raw(x)" here, because __half_raw is union type
+  // in the hip_fp16 header file, and that will trigger a compile error
+  // On the other hand, having anything but a return statement also triggers a compile error
+  // because this is constexpr function.
+  // Fortunately, since we need to disable EIGEN_CONSTEXPR for GPU anyway, we can get out
+  // of this catch22 by having separate bodies for GPU / non GPU
+#if defined(EIGEN_HAS_GPU_FP16)
+   __half_raw h;
+   h.x = x;
+  return h;
+#else
+  return __half_raw(x);
+#endif
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC numext::uint16_t raw_half_as_uint16(const __half_raw& h) {
+  // HIP/CUDA/Default have a member 'x' of type uint16_t.
+  // For ARM64 native half, the member 'x' is of type __fp16, so we need to bit-cast.
+  // For SYCL, cl::sycl::half is _Float16, so cast directly.
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  return numext::bit_cast<numext::uint16_t>(h.x);
+#elif defined(SYCL_DEVICE_ONLY)
+  return numext::bit_cast<numext::uint16_t>(h);
+#else
+  return h.x;
+#endif
+}
+
+union float32_bits {
+  unsigned int u;
+  float f;
+};
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(float ff) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  __half tmp_ff = __float2half(ff);
+  return *(__half_raw*)&tmp_ff;
+
+#elif defined(EIGEN_HAS_FP16_C)
+  __half_raw h;
+  h.x = _cvtss_sh(ff, 0);
+  return h;
+
+#elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  __half_raw h;
+  h.x = static_cast<__fp16>(ff);
+  return h;
+
+#else
+  float32_bits f; f.f = ff;
+
+  const float32_bits f32infty = { 255 << 23 };
+  const float32_bits f16max = { (127 + 16) << 23 };
+  const float32_bits denorm_magic = { ((127 - 15) + (23 - 10) + 1) << 23 };
+  unsigned int sign_mask = 0x80000000u;
+  __half_raw o;
+  o.x = static_cast<numext::uint16_t>(0x0u);
+
+  unsigned int sign = f.u & sign_mask;
+  f.u ^= sign;
+
+  // NOTE all the integer compares in this function can be safely
+  // compiled into signed compares since all operands are below
+  // 0x80000000. Important if you want fast straight SSE2 code
+  // (since there's no unsigned PCMPGTD).
+
+  if (f.u >= f16max.u) {  // result is Inf or NaN (all exponent bits set)
+    o.x = (f.u > f32infty.u) ? 0x7e00 : 0x7c00; // NaN->qNaN and Inf->Inf
+  } else {  // (De)normalized number or zero
+    if (f.u < (113 << 23)) {  // resulting FP16 is subnormal or zero
+      // use a magic value to align our 10 mantissa bits at the bottom of
+      // the float. as long as FP addition is round-to-nearest-even this
+      // just works.
+      f.f += denorm_magic.f;
+
+      // and one integer subtract of the bias later, we have our final float!
+      o.x = static_cast<numext::uint16_t>(f.u - denorm_magic.u);
+    } else {
+      unsigned int mant_odd = (f.u >> 13) & 1; // resulting mantissa is odd
+
+      // update exponent, rounding bias part 1
+      // Equivalent to `f.u += ((unsigned int)(15 - 127) << 23) + 0xfff`, but
+      // without arithmetic overflow.
+      f.u += 0xc8000fffU;
+      // rounding bias part 2
+      f.u += mant_odd;
+      // take the bits!
+      o.x = static_cast<numext::uint16_t>(f.u >> 13);
+    }
+  }
+
+  o.x |= static_cast<numext::uint16_t>(sign >> 16);
+  return o;
+#endif
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float half_to_float(__half_raw h) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  return __half2float(h);
+#elif defined(EIGEN_HAS_FP16_C)
+  return _cvtsh_ss(h.x);
+#elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  return static_cast<float>(h.x);
+#else
+  const float32_bits magic = { 113 << 23 };
+  const unsigned int shifted_exp = 0x7c00 << 13; // exponent mask after shift
+  float32_bits o;
+
+  o.u = (h.x & 0x7fff) << 13;             // exponent/mantissa bits
+  unsigned int exp = shifted_exp & o.u;   // just the exponent
+  o.u += (127 - 15) << 23;                // exponent adjust
+
+  // handle exponent special cases
+  if (exp == shifted_exp) {     // Inf/NaN?
+    o.u += (128 - 16) << 23;    // extra exp adjust
+  } else if (exp == 0) {        // Zero/Denormal?
+    o.u += 1 << 23;             // extra exp adjust
+    o.f -= magic.f;             // renormalize
+  }
+
+  o.u |= (h.x & 0x8000) << 16;    // sign bit
+  return o.f;
+#endif
+}
+
+// --- standard functions ---
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isinf)(const half& a) {
+#ifdef EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC
+  return (numext::bit_cast<numext::uint16_t>(a.x) & 0x7fff) == 0x7c00;
+#else
+  return (a.x & 0x7fff) == 0x7c00;
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isnan)(const half& a) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  return __hisnan(a);
+#elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  return (numext::bit_cast<numext::uint16_t>(a.x) & 0x7fff) > 0x7c00;
+#else
+  return (a.x & 0x7fff) > 0x7c00;
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (isfinite)(const half& a) {
+  return !(isinf EIGEN_NOT_A_MACRO (a)) && !(isnan EIGEN_NOT_A_MACRO (a));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half abs(const half& a) {
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  return half(vabsh_f16(a.x));
+#else
+  half result;
+  result.x = a.x & 0x7FFF;
+  return result;
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half exp(const half& a) {
+#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530) || \
+  defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hexp(a));
+#else
+   return half(::expf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half expm1(const half& a) {
+  return half(numext::expm1(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log(const half& a) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && EIGEN_CUDA_SDK_VER >= 80000 && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  return half(::hlog(a));
+#else
+  return half(::logf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log1p(const half& a) {
+  return half(numext::log1p(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log10(const half& a) {
+  return half(::log10f(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log2(const half& a) {
+  return half(static_cast<float>(EIGEN_LOG2E) * ::logf(float(a)));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half sqrt(const half& a) {
+#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530) || \
+  defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hsqrt(a));
+#else
+    return half(::sqrtf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half pow(const half& a, const half& b) {
+  return half(::powf(float(a), float(b)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half sin(const half& a) {
+  return half(::sinf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half cos(const half& a) {
+  return half(::cosf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half tan(const half& a) {
+  return half(::tanf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half tanh(const half& a) {
+  return half(::tanhf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half asin(const half& a) {
+  return half(::asinf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half acos(const half& a) {
+  return half(::acosf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half floor(const half& a) {
+#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300) || \
+  defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hfloor(a));
+#else
+  return half(::floorf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half ceil(const half& a) {
+#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300) || \
+  defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hceil(a));
+#else
+  return half(::ceilf(float(a)));
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half rint(const half& a) {
+  return half(::rintf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half round(const half& a) {
+  return half(::roundf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half fmod(const half& a, const half& b) {
+  return half(::fmodf(float(a), float(b)));
+}
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half (min)(const half& a, const half& b) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  return __hlt(b, a) ? b : a;
+#else
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return f2 < f1 ? b : a;
+#endif
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half (max)(const half& a, const half& b) {
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+  return __hlt(a, b) ? b : a;
+#else
+  const float f1 = static_cast<float>(a);
+  const float f2 = static_cast<float>(b);
+  return f1 < f2 ? b : a;
+#endif
+}
+
+#ifndef EIGEN_NO_IO
+EIGEN_ALWAYS_INLINE std::ostream& operator << (std::ostream& os, const half& v) {
+  os << static_cast<float>(v);
+  return os;
+}
+#endif
+
+} // end namespace half_impl
+
+// import Eigen::half_impl::half into Eigen namespace
+// using half_impl::half;
+
+namespace internal {
+
+template<>
+struct random_default_impl<half, false, false>
+{
+  static inline half run(const half& x, const half& y)
+  {
+    return x + (y-x) * half(float(std::rand()) / float(RAND_MAX));
+  }
+  static inline half run()
+  {
+    return run(half(-1.f), half(1.f));
+  }
+};
+
+template<> struct is_arithmetic<half> { enum { value = true }; };
+
+} // end namespace internal
+
+template<> struct NumTraits<Eigen::half>
+    : GenericNumTraits<Eigen::half>
+{
+  enum {
+    IsSigned = true,
+    IsInteger = false,
+    IsComplex = false,
+    RequireInitialization = false
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half epsilon() {
+    return half_impl::raw_uint16_to_half(0x0800);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half dummy_precision() {
+    return half_impl::raw_uint16_to_half(0x211f); //  Eigen::half(1e-2f);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half highest() {
+    return half_impl::raw_uint16_to_half(0x7bff);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half lowest() {
+    return half_impl::raw_uint16_to_half(0xfbff);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half infinity() {
+    return half_impl::raw_uint16_to_half(0x7c00);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half quiet_NaN() {
+    return half_impl::raw_uint16_to_half(0x7e00);
+  }
+};
+
+} // end namespace Eigen
+
+#if defined(EIGEN_HAS_GPU_FP16) || defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  #pragma pop_macro("EIGEN_CONSTEXPR")
+#endif
+
+namespace Eigen {
+namespace numext {
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool(isnan)(const Eigen::half& h) {
+  return (half_impl::isnan)(h);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool(isinf)(const Eigen::half& h) {
+  return (half_impl::isinf)(h);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool(isfinite)(const Eigen::half& h) {
+  return (half_impl::isfinite)(h);
+}
+
+#endif
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bit_cast<Eigen::half, uint16_t>(const uint16_t& src) {
+  return Eigen::half(Eigen::half_impl::raw_uint16_to_half(src));
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC uint16_t bit_cast<uint16_t, Eigen::half>(const Eigen::half& src) {
+  return Eigen::half_impl::raw_half_as_uint16(src);
+}
+
+}  // namespace numext
+}  // namespace Eigen
+
+// Add the missing shfl* intrinsics.
+// The __shfl* functions are only valid on HIP or _CUDA_ARCH_ >= 300.
+//   CUDA defines them for (__CUDA_ARCH__ >= 300 || !defined(__CUDA_ARCH__))
+//
+// HIP and CUDA prior to SDK 9.0 define
+//    __shfl, __shfl_up, __shfl_down, __shfl_xor for int and float
+// CUDA since 9.0 deprecates those and instead defines
+//    __shfl_sync, __shfl_up_sync, __shfl_down_sync, __shfl_xor_sync,
+//    with native support for __half and __nv_bfloat16
+//
+// Note that the following are __device__ - only functions.
+#if (defined(EIGEN_CUDACC) && (!defined(EIGEN_CUDA_ARCH) || EIGEN_CUDA_ARCH >= 300)) \
+    || defined(EIGEN_HIPCC)
+
+#if defined(EIGEN_HAS_CUDA_FP16) && EIGEN_CUDA_SDK_VER >= 90000
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_sync(unsigned mask, Eigen::half var, int srcLane, int width=warpSize) {
+  const __half h = var;
+  return static_cast<Eigen::half>(__shfl_sync(mask, h, srcLane, width));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_up_sync(unsigned mask, Eigen::half var, unsigned int delta, int width=warpSize) {
+  const __half h = var;
+  return static_cast<Eigen::half>(__shfl_up_sync(mask, h, delta, width));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_down_sync(unsigned mask, Eigen::half var, unsigned int delta, int width=warpSize) {
+  const __half h = var;
+  return static_cast<Eigen::half>(__shfl_down_sync(mask, h, delta, width));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_xor_sync(unsigned mask, Eigen::half var, int laneMask, int width=warpSize) {
+  const __half h = var;
+  return static_cast<Eigen::half>(__shfl_xor_sync(mask, h, laneMask, width));
+}
+
+#else // HIP or CUDA SDK < 9.0
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl(Eigen::half var, int srcLane, int width=warpSize) {
+  const int ivar = static_cast<int>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(var));
+  return Eigen::numext::bit_cast<Eigen::half>(static_cast<Eigen::numext::uint16_t>(__shfl(ivar, srcLane, width)));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_up(Eigen::half var, unsigned int delta, int width=warpSize) {
+  const int ivar = static_cast<int>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(var));
+  return Eigen::numext::bit_cast<Eigen::half>(static_cast<Eigen::numext::uint16_t>(__shfl_up(ivar, delta, width)));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_down(Eigen::half var, unsigned int delta, int width=warpSize) {
+  const int ivar = static_cast<int>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(var));
+  return Eigen::numext::bit_cast<Eigen::half>(static_cast<Eigen::numext::uint16_t>(__shfl_down(ivar, delta, width)));
+}
+
+__device__ EIGEN_STRONG_INLINE Eigen::half __shfl_xor(Eigen::half var, int laneMask, int width=warpSize) {
+  const int ivar = static_cast<int>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(var));
+  return Eigen::numext::bit_cast<Eigen::half>(static_cast<Eigen::numext::uint16_t>(__shfl_xor(ivar, laneMask, width)));
+}
+
+#endif // HIP vs CUDA
+#endif // __shfl*
+
+// ldg() has an overload for __half_raw, but we also need one for Eigen::half.
+#if (defined(EIGEN_CUDACC) && (!defined(EIGEN_CUDA_ARCH) || EIGEN_CUDA_ARCH >= 350)) \
+    || defined(EIGEN_HIPCC)
+EIGEN_STRONG_INLINE __device__ Eigen::half __ldg(const Eigen::half* ptr) {
+  return Eigen::half_impl::raw_uint16_to_half(__ldg(reinterpret_cast<const Eigen::numext::uint16_t*>(ptr)));
+}
+#endif // __ldg
+
+#if EIGEN_HAS_STD_HASH
+namespace std {
+template <>
+struct hash<Eigen::half> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::size_t operator()(const Eigen::half& a) const {
+    return static_cast<std::size_t>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(a));
+  }
+};
+} // end namespace std
+#endif
+
+#endif // EIGEN_HALF_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/Settings.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/Settings.h
new file mode 100644
index 00000000..a5c3ada4
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/Settings.h
@@ -0,0 +1,49 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+/* All the parameters defined in this file can be specialized in the
+ * architecture specific files, and/or by the user.
+ * More to come... */
+
+#ifndef EIGEN_DEFAULT_SETTINGS_H
+#define EIGEN_DEFAULT_SETTINGS_H
+
+/** Defines the maximal loop size to enable meta unrolling of loops.
+  * Note that the value here is expressed in Eigen's own notion of "number of FLOPS",
+  * it does not correspond to the number of iterations or the number of instructions
+  */
+#ifndef EIGEN_UNROLLING_LIMIT
+#define EIGEN_UNROLLING_LIMIT 110
+#endif
+
+/** Defines the threshold between a "small" and a "large" matrix.
+  * This threshold is mainly used to select the proper product implementation.
+  */
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+/** Defines the maximal width of the blocks used in the triangular product and solver
+  * for vectors (level 2 blas xTRMV and xTRSV). The default is 8.
+  */
+#ifndef EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH
+#define EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH 8
+#endif
+
+
+/** Defines the default number of registers available for that architecture.
+  * Currently it must be 8 or 16. Other values will fail.
+  */
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 8
+#endif
+
+#endif // EIGEN_DEFAULT_SETTINGS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/TypeCasting.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/TypeCasting.h
new file mode 100644
index 00000000..fb8183b7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/Default/TypeCasting.h
@@ -0,0 +1,120 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// Copyright (C) 2019 Rasmus Munk Larsen <rmlarsen@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERIC_TYPE_CASTING_H
+#define EIGEN_GENERIC_TYPE_CASTING_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<>
+struct scalar_cast_op<float, Eigen::half> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef Eigen::half result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half operator() (const float& a) const {
+    #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+      (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+      return __float2half(a);
+    #else
+      return Eigen::half(a);
+    #endif
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<float, Eigen::half> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<int, Eigen::half> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef Eigen::half result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half operator() (const int& a) const {
+    #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+      (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+      return __float2half(static_cast<float>(a));
+    #else
+      return Eigen::half(static_cast<float>(a));
+    #endif
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<int, Eigen::half> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<Eigen::half, float> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef float result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator() (const Eigen::half& a) const {
+    #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+      (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+      return __half2float(a);
+    #else
+      return static_cast<float>(a);
+    #endif
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<Eigen::half, float> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<float, Eigen::bfloat16> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef Eigen::bfloat16 result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16 operator() (const float& a) const {
+    return Eigen::bfloat16(a);
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<float, Eigen::bfloat16> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<int, Eigen::bfloat16> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef Eigen::bfloat16 result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16 operator() (const int& a) const {
+    return Eigen::bfloat16(static_cast<float>(a));
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<int, Eigen::bfloat16> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+template<>
+struct scalar_cast_op<Eigen::bfloat16, float> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef float result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator() (const Eigen::bfloat16& a) const {
+    return static_cast<float>(a);
+  }
+};
+
+template<>
+struct functor_traits<scalar_cast_op<Eigen::bfloat16, float> >
+{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; };
+
+
+}
+}
+
+#endif  // EIGEN_GENERIC_TYPE_CASTING_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/GPU/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/GPU/MathFunctions.h
new file mode 100644
index 00000000..d2b3a256
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/GPU/MathFunctions.h
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_GPU_H
+#define EIGEN_MATH_FUNCTIONS_GPU_H
+
+namespace Eigen {
+
+namespace internal {
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#if defined(EIGEN_GPUCC) && defined(EIGEN_USE_GPU)
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 plog<float4>(const float4& a)
+{
+  return make_float4(logf(a.x), logf(a.y), logf(a.z), logf(a.w));
+}
+
+template<>  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 plog<double2>(const double2& a)
+{
+  using ::log;
+  return make_double2(log(a.x), log(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 plog1p<float4>(const float4& a)
+{
+  return make_float4(log1pf(a.x), log1pf(a.y), log1pf(a.z), log1pf(a.w));
+}
+
+template<>  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 plog1p<double2>(const double2& a)
+{
+  return make_double2(log1p(a.x), log1p(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 pexp<float4>(const float4& a)
+{
+  return make_float4(expf(a.x), expf(a.y), expf(a.z), expf(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 pexp<double2>(const double2& a)
+{
+  using ::exp;
+  return make_double2(exp(a.x), exp(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 pexpm1<float4>(const float4& a)
+{
+  return make_float4(expm1f(a.x), expm1f(a.y), expm1f(a.z), expm1f(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 pexpm1<double2>(const double2& a)
+{
+  return make_double2(expm1(a.x), expm1(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 psqrt<float4>(const float4& a)
+{
+  return make_float4(sqrtf(a.x), sqrtf(a.y), sqrtf(a.z), sqrtf(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 psqrt<double2>(const double2& a)
+{
+  using ::sqrt;
+  return make_double2(sqrt(a.x), sqrt(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+float4 prsqrt<float4>(const float4& a)
+{
+  return make_float4(rsqrtf(a.x), rsqrtf(a.y), rsqrtf(a.z), rsqrtf(a.w));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+double2 prsqrt<double2>(const double2& a)
+{
+  return make_double2(rsqrt(a.x), rsqrt(a.y));
+}
+
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATH_FUNCTIONS_GPU_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/GPU/PacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/GPU/PacketMath.h
new file mode 100644
index 00000000..689110de
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/GPU/PacketMath.h
@@ -0,0 +1,1685 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_GPU_H
+#define EIGEN_PACKET_MATH_GPU_H
+
+namespace Eigen {
+
+namespace internal {
+
+// Read-only data cached load available.
+#if defined(EIGEN_HIP_DEVICE_COMPILE) || (defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 350)
+#define EIGEN_GPU_HAS_LDG 1
+#endif
+
+// FP16 math available.
+#if (defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530)
+#define EIGEN_CUDA_HAS_FP16_ARITHMETIC 1
+#endif
+
+#if defined(EIGEN_HIP_DEVICE_COMPILE) || defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
+#define EIGEN_GPU_HAS_FP16_ARITHMETIC 1
+#endif
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#if defined(EIGEN_GPUCC) && defined(EIGEN_USE_GPU)
+
+template<> struct is_arithmetic<float4>  { enum { value = true }; };
+template<> struct is_arithmetic<double2> { enum { value = true }; };
+
+template<> struct packet_traits<float> : default_packet_traits
+{
+  typedef float4 type;
+  typedef float4 half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+    HasHalfPacket = 0,
+
+    HasDiv  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasLGamma = 1,
+    HasDiGamma = 1,
+    HasZeta = 1,
+    HasPolygamma = 1,
+    HasErf = 1,
+    HasErfc = 1,
+    HasNdtri = 1,
+    HasBessel = 1,
+    HasIGamma = 1,
+    HasIGammaDerA = 1,
+    HasGammaSampleDerAlpha = 1,
+    HasIGammac = 1,
+    HasBetaInc = 1,
+
+    HasBlend = 0,
+    HasFloor = 1,
+  };
+};
+
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef double2 type;
+  typedef double2 half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 0,
+
+    HasDiv  = 1,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasLGamma = 1,
+    HasDiGamma = 1,
+    HasZeta = 1,
+    HasPolygamma = 1,
+    HasErf = 1,
+    HasErfc = 1,
+    HasNdtri = 1,
+    HasBessel = 1,
+    HasIGamma = 1,
+    HasIGammaDerA = 1,
+    HasGammaSampleDerAlpha = 1,
+    HasIGammac = 1,
+    HasBetaInc = 1,
+
+    HasBlend = 0,
+    HasFloor = 1,
+  };
+};
+
+
+template<> struct unpacket_traits<float4>  { typedef float  type; enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef float4 half; };
+template<> struct unpacket_traits<double2> { typedef double type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef double2 half; };
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pset1<float4>(const float&  from) {
+  return make_float4(from, from, from, from);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pset1<double2>(const double& from) {
+  return make_double2(from, from);
+}
+
+// We need to distinguish ‘clang as the CUDA compiler’ from ‘clang as the host compiler,
+// invoked by NVCC’ (e.g. on MacOS). The former needs to see both host and device implementation
+// of the functions, while the latter can only deal with one of them.
+#if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIPCC) || (defined(EIGEN_CUDACC) && EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC)
+namespace {
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_and(const float& a,
+                                                        const float& b) {
+  return __int_as_float(__float_as_int(a) & __float_as_int(b));
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_and(const double& a,
+                                                         const double& b) {
+  return __longlong_as_double(__double_as_longlong(a) &
+                              __double_as_longlong(b));
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_or(const float& a,
+                                                       const float& b) {
+  return __int_as_float(__float_as_int(a) | __float_as_int(b));
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_or(const double& a,
+                                                        const double& b) {
+  return __longlong_as_double(__double_as_longlong(a) |
+                              __double_as_longlong(b));
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_xor(const float& a,
+                                                        const float& b) {
+  return __int_as_float(__float_as_int(a) ^ __float_as_int(b));
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_xor(const double& a,
+                                                         const double& b) {
+  return __longlong_as_double(__double_as_longlong(a) ^
+                              __double_as_longlong(b));
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_andnot(const float& a,
+                                                           const float& b) {
+  return __int_as_float(__float_as_int(a) & ~__float_as_int(b));
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_andnot(const double& a,
+                                                            const double& b) {
+  return __longlong_as_double(__double_as_longlong(a) &
+                              ~__double_as_longlong(b));
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float eq_mask(const float& a,
+                                                    const float& b) {
+  return __int_as_float(a == b ? 0xffffffffu : 0u);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double eq_mask(const double& a,
+                                                     const double& b) {
+  return __longlong_as_double(a == b ? 0xffffffffffffffffull : 0ull);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float lt_mask(const float& a,
+                                                    const float& b) {
+  return __int_as_float(a < b ? 0xffffffffu : 0u);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double lt_mask(const double& a,
+                                                     const double& b) {
+  return __longlong_as_double(a < b ? 0xffffffffffffffffull : 0ull);
+}
+
+}  // namespace
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pand<float4>(const float4& a,
+                                                          const float4& b) {
+  return make_float4(bitwise_and(a.x, b.x), bitwise_and(a.y, b.y),
+                     bitwise_and(a.z, b.z), bitwise_and(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pand<double2>(const double2& a,
+                                                            const double2& b) {
+  return make_double2(bitwise_and(a.x, b.x), bitwise_and(a.y, b.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 por<float4>(const float4& a,
+                                                         const float4& b) {
+  return make_float4(bitwise_or(a.x, b.x), bitwise_or(a.y, b.y),
+                     bitwise_or(a.z, b.z), bitwise_or(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 por<double2>(const double2& a,
+                                                           const double2& b) {
+  return make_double2(bitwise_or(a.x, b.x), bitwise_or(a.y, b.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pxor<float4>(const float4& a,
+                                                          const float4& b) {
+  return make_float4(bitwise_xor(a.x, b.x), bitwise_xor(a.y, b.y),
+                     bitwise_xor(a.z, b.z), bitwise_xor(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pxor<double2>(const double2& a,
+                                                            const double2& b) {
+  return make_double2(bitwise_xor(a.x, b.x), bitwise_xor(a.y, b.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pandnot<float4>(const float4& a,
+                                                             const float4& b) {
+  return make_float4(bitwise_andnot(a.x, b.x), bitwise_andnot(a.y, b.y),
+                     bitwise_andnot(a.z, b.z), bitwise_andnot(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
+pandnot<double2>(const double2& a, const double2& b) {
+  return make_double2(bitwise_andnot(a.x, b.x), bitwise_andnot(a.y, b.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcmp_eq<float4>(const float4& a,
+                                                             const float4& b) {
+  return make_float4(eq_mask(a.x, b.x), eq_mask(a.y, b.y), eq_mask(a.z, b.z),
+                     eq_mask(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcmp_lt<float4>(const float4& a,
+                                                             const float4& b) {
+  return make_float4(lt_mask(a.x, b.x), lt_mask(a.y, b.y), lt_mask(a.z, b.z),
+                     lt_mask(a.w, b.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
+pcmp_eq<double2>(const double2& a, const double2& b) {
+  return make_double2(eq_mask(a.x, b.x), eq_mask(a.y, b.y));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2
+pcmp_lt<double2>(const double2& a, const double2& b) {
+  return make_double2(lt_mask(a.x, b.x), lt_mask(a.y, b.y));
+}
+#endif // defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIPCC) || (defined(EIGEN_CUDACC) && EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC)
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 plset<float4>(const float& a) {
+  return make_float4(a, a+1, a+2, a+3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 plset<double2>(const double& a) {
+  return make_double2(a, a+1);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 padd<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x+b.x, a.y+b.y, a.z+b.z, a.w+b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 padd<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x+b.x, a.y+b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 psub<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x-b.x, a.y-b.y, a.z-b.z, a.w-b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 psub<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x-b.x, a.y-b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pnegate(const float4& a) {
+  return make_float4(-a.x, -a.y, -a.z, -a.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pnegate(const double2& a) {
+  return make_double2(-a.x, -a.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pconj(const float4& a) { return a; }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pconj(const double2& a) { return a; }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pmul<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x*b.x, a.y*b.y, a.z*b.z, a.w*b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pmul<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x*b.x, a.y*b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pdiv<float4>(const float4& a, const float4& b) {
+  return make_float4(a.x/b.x, a.y/b.y, a.z/b.z, a.w/b.w);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pdiv<double2>(const double2& a, const double2& b) {
+  return make_double2(a.x/b.x, a.y/b.y);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pmin<float4>(const float4& a, const float4& b) {
+  return make_float4(fminf(a.x, b.x), fminf(a.y, b.y), fminf(a.z, b.z), fminf(a.w, b.w));
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pmin<double2>(const double2& a, const double2& b) {
+  return make_double2(fmin(a.x, b.x), fmin(a.y, b.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pmax<float4>(const float4& a, const float4& b) {
+  return make_float4(fmaxf(a.x, b.x), fmaxf(a.y, b.y), fmaxf(a.z, b.z), fmaxf(a.w, b.w));
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pmax<double2>(const double2& a, const double2& b) {
+  return make_double2(fmax(a.x, b.x), fmax(a.y, b.y));
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pload<float4>(const float* from) {
+  return *reinterpret_cast<const float4*>(from);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pload<double2>(const double* from) {
+  return *reinterpret_cast<const double2*>(from);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 ploadu<float4>(const float* from) {
+  return make_float4(from[0], from[1], from[2], from[3]);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 ploadu<double2>(const double* from) {
+  return make_double2(from[0], from[1]);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 ploaddup<float4>(const float*   from) {
+  return make_float4(from[0], from[0], from[1], from[1]);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 ploaddup<double2>(const double*  from) {
+  return make_double2(from[0], from[0]);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore<float>(float*   to, const float4& from) {
+  *reinterpret_cast<float4*>(to) = from;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore<double>(double* to, const double2& from) {
+  *reinterpret_cast<double2*>(to) = from;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu<float>(float*  to, const float4& from) {
+  to[0] = from.x;
+  to[1] = from.y;
+  to[2] = from.z;
+  to[3] = from.w;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const double2& from) {
+  to[0] = from.x;
+  to[1] = from.y;
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float4 ploadt_ro<float4, Aligned>(const float* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  return __ldg((const float4*)from);
+#else
+  return make_float4(from[0], from[1], from[2], from[3]);
+#endif
+}
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double2 ploadt_ro<double2, Aligned>(const double* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  return __ldg((const double2*)from);
+#else
+  return make_double2(from[0], from[1]);
+#endif
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float4 ploadt_ro<float4, Unaligned>(const float* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  return make_float4(__ldg(from+0), __ldg(from+1), __ldg(from+2), __ldg(from+3));
+#else
+  return make_float4(from[0], from[1], from[2], from[3]);
+#endif
+}
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double2 ploadt_ro<double2, Unaligned>(const double* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  return make_double2(__ldg(from+0), __ldg(from+1));
+#else
+  return make_double2(from[0], from[1]);
+#endif
+}
+
+template<> EIGEN_DEVICE_FUNC inline float4 pgather<float, float4>(const float* from, Index stride) {
+  return make_float4(from[0*stride], from[1*stride], from[2*stride], from[3*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline double2 pgather<double, double2>(const double* from, Index stride) {
+  return make_double2(from[0*stride], from[1*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, float4>(float* to, const float4& from, Index stride) {
+  to[stride*0] = from.x;
+  to[stride*1] = from.y;
+  to[stride*2] = from.z;
+  to[stride*3] = from.w;
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, double2>(double* to, const double2& from, Index stride) {
+  to[stride*0] = from.x;
+  to[stride*1] = from.y;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  pfirst<float4>(const float4& a) {
+  return a.x;
+}
+template<> EIGEN_DEVICE_FUNC inline double pfirst<double2>(const double2& a) {
+  return a.x;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux<float4>(const float4& a) {
+  return a.x + a.y + a.z + a.w;
+}
+template<> EIGEN_DEVICE_FUNC inline double predux<double2>(const double2& a) {
+  return a.x + a.y;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux_max<float4>(const float4& a) {
+  return fmaxf(fmaxf(a.x, a.y), fmaxf(a.z, a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double predux_max<double2>(const double2& a) {
+  return fmax(a.x, a.y);
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux_min<float4>(const float4& a) {
+  return fminf(fminf(a.x, a.y), fminf(a.z, a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double predux_min<double2>(const double2& a) {
+  return fmin(a.x, a.y);
+}
+
+template<> EIGEN_DEVICE_FUNC inline float  predux_mul<float4>(const float4& a) {
+  return a.x * a.y * a.z * a.w;
+}
+template<> EIGEN_DEVICE_FUNC inline double predux_mul<double2>(const double2& a) {
+  return a.x * a.y;
+}
+
+template<> EIGEN_DEVICE_FUNC inline float4  pabs<float4>(const float4& a) {
+  return make_float4(fabsf(a.x), fabsf(a.y), fabsf(a.z), fabsf(a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double2 pabs<double2>(const double2& a) {
+  return make_double2(fabs(a.x), fabs(a.y));
+}
+
+template<> EIGEN_DEVICE_FUNC inline float4  pfloor<float4>(const float4& a) {
+  return make_float4(floorf(a.x), floorf(a.y), floorf(a.z), floorf(a.w));
+}
+template<> EIGEN_DEVICE_FUNC inline double2 pfloor<double2>(const double2& a) {
+  return make_double2(floor(a.x), floor(a.y));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<float4,4>& kernel) {
+  float tmp = kernel.packet[0].y;
+  kernel.packet[0].y = kernel.packet[1].x;
+  kernel.packet[1].x = tmp;
+
+  tmp = kernel.packet[0].z;
+  kernel.packet[0].z = kernel.packet[2].x;
+  kernel.packet[2].x = tmp;
+
+  tmp = kernel.packet[0].w;
+  kernel.packet[0].w = kernel.packet[3].x;
+  kernel.packet[3].x = tmp;
+
+  tmp = kernel.packet[1].z;
+  kernel.packet[1].z = kernel.packet[2].y;
+  kernel.packet[2].y = tmp;
+
+  tmp = kernel.packet[1].w;
+  kernel.packet[1].w = kernel.packet[3].y;
+  kernel.packet[3].y = tmp;
+
+  tmp = kernel.packet[2].w;
+  kernel.packet[2].w = kernel.packet[3].z;
+  kernel.packet[3].z = tmp;
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<double2,2>& kernel) {
+  double tmp = kernel.packet[0].y;
+  kernel.packet[0].y = kernel.packet[1].x;
+  kernel.packet[1].x = tmp;
+}
+
+#endif // defined(EIGEN_GPUCC) && defined(EIGEN_USE_GPU)
+
+// Packet4h2 must be defined in the macro without EIGEN_CUDA_ARCH, meaning
+// its corresponding packet_traits<Eigen::half> must be visible on host.
+#if defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)
+
+typedef ulonglong2 Packet4h2;
+template<> struct unpacket_traits<Packet4h2> { typedef Eigen::half type; enum {size=8, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet4h2 half; };
+template<> struct is_arithmetic<Packet4h2> { enum { value = true }; };
+
+template<> struct unpacket_traits<half2> { typedef Eigen::half type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef half2 half; };
+template<> struct is_arithmetic<half2> { enum { value = true }; };
+
+template<> struct packet_traits<Eigen::half> : default_packet_traits
+{
+  typedef Packet4h2 type;
+  typedef Packet4h2 half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=8,
+    HasHalfPacket = 0,
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasSqrt   = 1,
+    HasRsqrt  = 1,
+    HasExp    = 1,
+    HasExpm1  = 1,
+    HasLog    = 1,
+    HasLog1p  = 1
+  };
+};
+
+namespace {
+// This is equivalent to make_half2, which is undocumented and doesn't seem to always exist.
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 combine_half(const __half& a, const __half& b) {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return __halves2half2(a, b);
+#else
+  // Round-about way since __halves2half2 is a __device__ function.
+  return __floats2half2_rn(__half2float(a), __half2float(b));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE __half get_half2_low(const half2& a) {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return __low2half(a);
+#else
+  return __float2half(__low2float(a));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE __half get_half2_high(const half2& a) {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return __high2half(a);
+#else
+  return __float2half(__high2float(a));
+#endif
+}
+} // namespace
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pset1<half2>(const Eigen::half& from) {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return __half2half2(from);
+#else
+  const float f = __half2float(from);
+  return __floats2half2_rn(f, f);
+#endif
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pset1<Packet4h2>(const Eigen::half& from) {
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = pset1<half2>(from);
+  p_alias[1] = pset1<half2>(from);
+  p_alias[2] = pset1<half2>(from);
+  p_alias[3] = pset1<half2>(from);
+  return r;
+}
+
+// We now need this visible on both host and device.
+// #if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIPCC) || (defined(EIGEN_CUDACC) && EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC)
+namespace {
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pload(const Eigen::half* from) {
+  return *reinterpret_cast<const half2*>(from);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ploadu(const Eigen::half* from) {
+  return combine_half(from[0], from[1]);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ploaddup(const Eigen::half*  from) {
+  return combine_half(from[0], from[0]);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore(Eigen::half* to,
+                                                  const half2& from) {
+  *reinterpret_cast<half2*>(to) = from;
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu(Eigen::half* to,
+                                                   const half2& from) {
+  to[0] = get_half2_low(from);
+  to[1] = get_half2_high(from);
+}
+
+
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE half2 ploadt_ro_aligned(
+    const Eigen::half* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  // Input is guaranteed to be properly aligned.
+  return __ldg(reinterpret_cast<const half2*>(from));
+#else
+  return combine_half(*(from+0), *(from+1));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE half2 ploadt_ro_unaligned(
+    const Eigen::half* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  return __halves2half2(__ldg(from+0), __ldg(from+1));
+#else
+  return combine_half(*(from+0), *(from+1));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pgather(const Eigen::half* from,
+                                                    Index stride) {
+  return combine_half(from[0*stride], from[1*stride]);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter(
+    Eigen::half* to, const half2& from, Index stride) {
+  to[stride*0] = get_half2_low(from);
+  to[stride*1] = get_half2_high(from);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half pfirst(const half2& a) {
+  return get_half2_low(a);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pabs(const half2& a) {
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half result1 = half_impl::raw_uint16_to_half(a1.x & 0x7FFF);
+  half result2 = half_impl::raw_uint16_to_half(a2.x & 0x7FFF);
+  return combine_half(result1, result2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ptrue(const half2& /*a*/) {
+  half true_half = half_impl::raw_uint16_to_half(0xffffu);
+  return pset1<half2>(true_half);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pzero(const half2& /*a*/) {
+  half false_half = half_impl::raw_uint16_to_half(0x0000u);
+  return pset1<half2>(false_half);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<half2,2>& kernel) {
+  __half a1 = get_half2_low(kernel.packet[0]);
+  __half a2 = get_half2_high(kernel.packet[0]);
+  __half b1 = get_half2_low(kernel.packet[1]);
+  __half b2 = get_half2_high(kernel.packet[1]);
+  kernel.packet[0] = combine_half(a1, b1);
+  kernel.packet[1] = combine_half(a2, b2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plset(const Eigen::half& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __halves2half2(a, __hadd(a, __float2half(1.0f)));
+#else
+  float f = __half2float(a) + 1.0f;
+  return combine_half(a, __float2half(f));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pselect(const half2& mask,
+                                                    const half2& a,
+                                                    const half2& b) {
+  half mask_low = get_half2_low(mask);
+  half mask_high = get_half2_high(mask);
+  half result_low = mask_low == half(0) ? get_half2_low(b) : get_half2_low(a);
+  half result_high = mask_high == half(0) ? get_half2_high(b) : get_half2_high(a);
+  return combine_half(result_low, result_high);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcmp_eq(const half2& a,
+                                                    const half2& b) {
+  half true_half = half_impl::raw_uint16_to_half(0xffffu);
+  half false_half = half_impl::raw_uint16_to_half(0x0000u);
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half eq1 = __half2float(a1) == __half2float(b1) ? true_half : false_half;
+  half eq2 = __half2float(a2) == __half2float(b2) ? true_half : false_half;
+  return combine_half(eq1, eq2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcmp_lt(const half2& a,
+                                                    const half2& b) {
+  half true_half = half_impl::raw_uint16_to_half(0xffffu);
+  half false_half = half_impl::raw_uint16_to_half(0x0000u);
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half eq1 = __half2float(a1) < __half2float(b1) ? true_half : false_half;
+  half eq2 = __half2float(a2) < __half2float(b2) ? true_half : false_half;
+  return combine_half(eq1, eq2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pand(const half2& a,
+                                                 const half2& b) {
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half result1 = half_impl::raw_uint16_to_half(a1.x & b1.x);
+  half result2 = half_impl::raw_uint16_to_half(a2.x & b2.x);
+  return combine_half(result1, result2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 por(const half2& a,
+                                                const half2& b) {
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half result1 = half_impl::raw_uint16_to_half(a1.x | b1.x);
+  half result2 = half_impl::raw_uint16_to_half(a2.x | b2.x);
+  return combine_half(result1, result2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pxor(const half2& a,
+                                                 const half2& b) {
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half result1 = half_impl::raw_uint16_to_half(a1.x ^ b1.x);
+  half result2 = half_impl::raw_uint16_to_half(a2.x ^ b2.x);
+  return combine_half(result1, result2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pandnot(const half2& a,
+                                                    const half2& b) {
+  half a1 = get_half2_low(a);
+  half a2 = get_half2_high(a);
+  half b1 = get_half2_low(b);
+  half b2 = get_half2_high(b);
+  half result1 = half_impl::raw_uint16_to_half(a1.x & ~b1.x);
+  half result2 = half_impl::raw_uint16_to_half(a2.x & ~b2.x);
+  return combine_half(result1, result2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 padd(const half2& a,
+                                                 const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hadd2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 + b1;
+  float r2 = a2 + b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 psub(const half2& a,
+                                                 const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hsub2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 - b1;
+  float r2 = a2 - b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pnegate(const half2& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hneg2(a);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return __floats2half2_rn(-a1, -a2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pconj(const half2& a) { return a; }
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmul(const half2& a,
+                                                 const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hmul2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 * b1;
+  float r2 = a2 * b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmadd(const half2& a,
+                                                  const half2& b,
+                                                  const half2& c) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+   return __hfma2(a, b, c);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float c1 = __low2float(c);
+  float c2 = __high2float(c);
+  float r1 = a1 * b1 + c1;
+  float r2 = a2 * b2 + c2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pdiv(const half2& a,
+                                                 const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __h2div(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 / b1;
+  float r2 = a2 / b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmin(const half2& a,
+                                                 const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  __half r1 = a1 < b1 ? get_half2_low(a) : get_half2_low(b);
+  __half r2 = a2 < b2 ? get_half2_high(a) : get_half2_high(b);
+  return combine_half(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmax(const half2& a,
+                                                 const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  __half r1 = a1 > b1 ? get_half2_low(a) : get_half2_low(b);
+  __half r2 = a2 > b2 ? get_half2_high(a) : get_half2_high(b);
+  return combine_half(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux(const half2& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hadd(__low2half(a), __high2half(a));
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return Eigen::half(__float2half(a1 + a2));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_max(const half2& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  __half first = __low2half(a);
+  __half second = __high2half(a);
+  return __hgt(first, second) ? first : second;
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return a1 > a2 ? get_half2_low(a) : get_half2_high(a);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_min(const half2& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  __half first = __low2half(a);
+  __half second = __high2half(a);
+  return __hlt(first, second) ? first : second;
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return a1 < a2 ? get_half2_low(a) : get_half2_high(a);
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_mul(const half2& a) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hmul(__low2half(a), __high2half(a));
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  return Eigen::half(__float2half(a1 * a2));
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plog1p(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = log1pf(a1);
+  float r2 = log1pf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pexpm1(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = expm1f(a1);
+  float r2 = expm1f(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+#if (EIGEN_CUDA_SDK_VER >= 80000 && defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)) || \
+  defined(EIGEN_HIP_DEVICE_COMPILE)
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+half2 plog(const half2& a) {
+  return h2log(a);
+}
+
+ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+half2 pexp(const half2& a) {
+  return h2exp(a);
+}
+
+ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+half2 psqrt(const half2& a) {
+  return h2sqrt(a);
+}
+
+ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+half2 prsqrt(const half2& a) {
+  return h2rsqrt(a);
+}
+
+#else
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plog(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = logf(a1);
+  float r2 = logf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pexp(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = expf(a1);
+  float r2 = expf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 psqrt(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = sqrtf(a1);
+  float r2 = sqrtf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 prsqrt(const half2& a) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float r1 = rsqrtf(a1);
+  float r2 = rsqrtf(a2);
+  return __floats2half2_rn(r1, r2);
+}
+#endif
+} // namespace
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pload<Packet4h2>(const Eigen::half* from) {
+  return *reinterpret_cast<const Packet4h2*>(from);
+}
+
+// unaligned load;
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+ploadu<Packet4h2>(const Eigen::half* from) {
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = ploadu(from + 0);
+  p_alias[1] = ploadu(from + 2);
+  p_alias[2] = ploadu(from + 4);
+  p_alias[3] = ploadu(from + 6);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+ploaddup<Packet4h2>(const Eigen::half* from) {
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = ploaddup(from + 0);
+  p_alias[1] = ploaddup(from + 1);
+  p_alias[2] = ploaddup(from + 2);
+  p_alias[3] = ploaddup(from + 3);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore<Eigen::half>(
+    Eigen::half* to, const Packet4h2& from) {
+  *reinterpret_cast<Packet4h2*>(to) = from;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(
+    Eigen::half* to, const Packet4h2& from) {
+  const half2* from_alias = reinterpret_cast<const half2*>(&from);
+  pstoreu(to + 0,from_alias[0]);
+  pstoreu(to + 2,from_alias[1]);
+  pstoreu(to + 4,from_alias[2]);
+  pstoreu(to + 6,from_alias[3]);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet4h2
+ploadt_ro<Packet4h2, Aligned>(const Eigen::half* from) {
+#if defined(EIGEN_GPU_HAS_LDG)
+  Packet4h2 r;
+  r = __ldg(reinterpret_cast<const Packet4h2*>(from));
+  return r;
+#else
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  r_alias[0] = ploadt_ro_aligned(from + 0);
+  r_alias[1] = ploadt_ro_aligned(from + 2);
+  r_alias[2] = ploadt_ro_aligned(from + 4);
+  r_alias[3] = ploadt_ro_aligned(from + 6);
+  return r;
+#endif
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet4h2
+ploadt_ro<Packet4h2, Unaligned>(const Eigen::half* from) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  r_alias[0] = ploadt_ro_unaligned(from + 0);
+  r_alias[1] = ploadt_ro_unaligned(from + 2);
+  r_alias[2] = ploadt_ro_unaligned(from + 4);
+  r_alias[3] = ploadt_ro_unaligned(from + 6);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pgather<Eigen::half, Packet4h2>(const Eigen::half* from, Index stride) {
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = combine_half(from[0 * stride], from[1 * stride]);
+  p_alias[1] = combine_half(from[2 * stride], from[3 * stride]);
+  p_alias[2] = combine_half(from[4 * stride], from[5 * stride]);
+  p_alias[3] = combine_half(from[6 * stride], from[7 * stride]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet4h2>(
+    Eigen::half* to, const Packet4h2& from, Index stride) {
+  const half2* from_alias = reinterpret_cast<const half2*>(&from);
+  pscatter(to + stride * 0, from_alias[0], stride);
+  pscatter(to + stride * 2, from_alias[1], stride);
+  pscatter(to + stride * 4, from_alias[2], stride);
+  pscatter(to + stride * 6, from_alias[3], stride);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half pfirst<Packet4h2>(
+    const Packet4h2& a) {
+  return pfirst(*(reinterpret_cast<const half2*>(&a)));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pabs<Packet4h2>(
+    const Packet4h2& a) {
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  p_alias[0] = pabs(a_alias[0]);
+  p_alias[1] = pabs(a_alias[1]);
+  p_alias[2] = pabs(a_alias[2]);
+  p_alias[3] = pabs(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 ptrue<Packet4h2>(
+    const Packet4h2& /*a*/) {
+  half true_half = half_impl::raw_uint16_to_half(0xffffu);
+  return pset1<Packet4h2>(true_half);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pzero<Packet4h2>(const Packet4h2& /*a*/) {
+  half false_half = half_impl::raw_uint16_to_half(0x0000u);
+  return pset1<Packet4h2>(false_half);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose_double(
+    double* d_row0, double* d_row1, double* d_row2, double* d_row3,
+    double* d_row4, double* d_row5, double* d_row6, double* d_row7) {
+  double d_tmp;
+  d_tmp = d_row0[1];
+  d_row0[1] = d_row4[0];
+  d_row4[0] = d_tmp;
+
+  d_tmp = d_row1[1];
+  d_row1[1] = d_row5[0];
+  d_row5[0] = d_tmp;
+
+  d_tmp = d_row2[1];
+  d_row2[1] = d_row6[0];
+  d_row6[0] = d_tmp;
+
+  d_tmp = d_row3[1];
+  d_row3[1] = d_row7[0];
+  d_row7[0] = d_tmp;
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose_half2(
+    half2* f_row0, half2* f_row1, half2* f_row2, half2* f_row3) {
+  half2 f_tmp;
+  f_tmp = f_row0[1];
+  f_row0[1] = f_row2[0];
+  f_row2[0] = f_tmp;
+
+  f_tmp = f_row1[1];
+  f_row1[1] = f_row3[0];
+  f_row3[0] = f_tmp;
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose_half(half2& f0, half2& f1) {
+  __half a1 = get_half2_low(f0);
+  __half a2 = get_half2_high(f0);
+  __half b1 = get_half2_low(f1);
+  __half b2 = get_half2_high(f1);
+  f0 = combine_half(a1, b1);
+  f1 = combine_half(a2, b2);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet4h2,8>& kernel) {
+  double* d_row0 = reinterpret_cast<double*>(&kernel.packet[0]);
+  double* d_row1 = reinterpret_cast<double*>(&kernel.packet[1]);
+  double* d_row2 = reinterpret_cast<double*>(&kernel.packet[2]);
+  double* d_row3 = reinterpret_cast<double*>(&kernel.packet[3]);
+  double* d_row4 = reinterpret_cast<double*>(&kernel.packet[4]);
+  double* d_row5 = reinterpret_cast<double*>(&kernel.packet[5]);
+  double* d_row6 = reinterpret_cast<double*>(&kernel.packet[6]);
+  double* d_row7 = reinterpret_cast<double*>(&kernel.packet[7]);
+  ptranspose_double(d_row0, d_row1, d_row2, d_row3,
+                    d_row4, d_row5, d_row6, d_row7);
+
+
+  half2* f_row0 = reinterpret_cast<half2*>(d_row0);
+  half2* f_row1 = reinterpret_cast<half2*>(d_row1);
+  half2* f_row2 = reinterpret_cast<half2*>(d_row2);
+  half2* f_row3 = reinterpret_cast<half2*>(d_row3);
+  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
+  ptranspose_half(f_row0[0], f_row1[0]);
+  ptranspose_half(f_row0[1], f_row1[1]);
+  ptranspose_half(f_row2[0], f_row3[0]);
+  ptranspose_half(f_row2[1], f_row3[1]);
+
+  f_row0 = reinterpret_cast<half2*>(d_row0 + 1);
+  f_row1 = reinterpret_cast<half2*>(d_row1 + 1);
+  f_row2 = reinterpret_cast<half2*>(d_row2 + 1);
+  f_row3 = reinterpret_cast<half2*>(d_row3 + 1);
+  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
+  ptranspose_half(f_row0[0], f_row1[0]);
+  ptranspose_half(f_row0[1], f_row1[1]);
+  ptranspose_half(f_row2[0], f_row3[0]);
+  ptranspose_half(f_row2[1], f_row3[1]);
+
+  f_row0 = reinterpret_cast<half2*>(d_row4);
+  f_row1 = reinterpret_cast<half2*>(d_row5);
+  f_row2 = reinterpret_cast<half2*>(d_row6);
+  f_row3 = reinterpret_cast<half2*>(d_row7);
+  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
+  ptranspose_half(f_row0[0], f_row1[0]);
+  ptranspose_half(f_row0[1], f_row1[1]);
+  ptranspose_half(f_row2[0], f_row3[0]);
+  ptranspose_half(f_row2[1], f_row3[1]);
+
+  f_row0 = reinterpret_cast<half2*>(d_row4 + 1);
+  f_row1 = reinterpret_cast<half2*>(d_row5 + 1);
+  f_row2 = reinterpret_cast<half2*>(d_row6 + 1);
+  f_row3 = reinterpret_cast<half2*>(d_row7 + 1);
+  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
+  ptranspose_half(f_row0[0], f_row1[0]);
+  ptranspose_half(f_row0[1], f_row1[1]);
+  ptranspose_half(f_row2[0], f_row3[0]);
+  ptranspose_half(f_row2[1], f_row3[1]);
+
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+plset<Packet4h2>(const Eigen::half& a) {
+#if defined(EIGEN_HIP_DEVICE_COMPILE)
+
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = __halves2half2(a, __hadd(a, __float2half(1.0f)));
+  p_alias[1] = __halves2half2(__hadd(a, __float2half(2.0f)),
+                              __hadd(a, __float2half(3.0f)));
+  p_alias[2] = __halves2half2(__hadd(a, __float2half(4.0f)),
+                              __hadd(a, __float2half(5.0f)));
+  p_alias[3] = __halves2half2(__hadd(a, __float2half(6.0f)),
+                              __hadd(a, __float2half(7.0f)));
+  return r;
+#elif defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+
+  half2 b = pset1<half2>(a);
+  half2 c;
+  half2 half_offset0 = __halves2half2(__float2half(0.0f),__float2half(2.0f));
+  half2 half_offset1 = __halves2half2(__float2half(4.0f),__float2half(6.0f));
+
+  c = __hadd2(b, half_offset0);
+  r_alias[0] = plset(__low2half(c));
+  r_alias[1] = plset(__high2half(c));
+
+  c = __hadd2(b, half_offset1);
+  r_alias[2] = plset(__low2half(c));
+  r_alias[3] = plset(__high2half(c));
+
+  return r;
+
+#else
+  float f = __half2float(a);
+  Packet4h2 r;
+  half2* p_alias = reinterpret_cast<half2*>(&r);
+  p_alias[0] = combine_half(a, __float2half(f + 1.0f));
+  p_alias[1] = combine_half(__float2half(f + 2.0f), __float2half(f + 3.0f));
+  p_alias[2] = combine_half(__float2half(f + 4.0f), __float2half(f + 5.0f));
+  p_alias[3] = combine_half(__float2half(f + 6.0f), __float2half(f + 7.0f));
+  return r;
+#endif
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pselect<Packet4h2>(const Packet4h2& mask, const Packet4h2& a,
+                   const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* mask_alias = reinterpret_cast<const half2*>(&mask);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pselect(mask_alias[0], a_alias[0], b_alias[0]);
+  r_alias[1] = pselect(mask_alias[1], a_alias[1], b_alias[1]);
+  r_alias[2] = pselect(mask_alias[2], a_alias[2], b_alias[2]);
+  r_alias[3] = pselect(mask_alias[3], a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pcmp_eq<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pcmp_eq(a_alias[0], b_alias[0]);
+  r_alias[1] = pcmp_eq(a_alias[1], b_alias[1]);
+  r_alias[2] = pcmp_eq(a_alias[2], b_alias[2]);
+  r_alias[3] = pcmp_eq(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pand<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pand(a_alias[0], b_alias[0]);
+  r_alias[1] = pand(a_alias[1], b_alias[1]);
+  r_alias[2] = pand(a_alias[2], b_alias[2]);
+  r_alias[3] = pand(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 por<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = por(a_alias[0], b_alias[0]);
+  r_alias[1] = por(a_alias[1], b_alias[1]);
+  r_alias[2] = por(a_alias[2], b_alias[2]);
+  r_alias[3] = por(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pxor<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pxor(a_alias[0], b_alias[0]);
+  r_alias[1] = pxor(a_alias[1], b_alias[1]);
+  r_alias[2] = pxor(a_alias[2], b_alias[2]);
+  r_alias[3] = pxor(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pandnot<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pandnot(a_alias[0], b_alias[0]);
+  r_alias[1] = pandnot(a_alias[1], b_alias[1]);
+  r_alias[2] = pandnot(a_alias[2], b_alias[2]);
+  r_alias[3] = pandnot(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 padd<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = padd(a_alias[0], b_alias[0]);
+  r_alias[1] = padd(a_alias[1], b_alias[1]);
+  r_alias[2] = padd(a_alias[2], b_alias[2]);
+  r_alias[3] = padd(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 psub<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = psub(a_alias[0], b_alias[0]);
+  r_alias[1] = psub(a_alias[1], b_alias[1]);
+  r_alias[2] = psub(a_alias[2], b_alias[2]);
+  r_alias[3] = psub(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pnegate(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = pnegate(a_alias[0]);
+  r_alias[1] = pnegate(a_alias[1]);
+  r_alias[2] = pnegate(a_alias[2]);
+  r_alias[3] = pnegate(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pconj(const Packet4h2& a) {
+  return a;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmul<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pmul(a_alias[0], b_alias[0]);
+  r_alias[1] = pmul(a_alias[1], b_alias[1]);
+  r_alias[2] = pmul(a_alias[2], b_alias[2]);
+  r_alias[3] = pmul(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmadd<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b, const Packet4h2& c) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  const half2* c_alias = reinterpret_cast<const half2*>(&c);
+  r_alias[0] = pmadd(a_alias[0], b_alias[0], c_alias[0]);
+  r_alias[1] = pmadd(a_alias[1], b_alias[1], c_alias[1]);
+  r_alias[2] = pmadd(a_alias[2], b_alias[2], c_alias[2]);
+  r_alias[3] = pmadd(a_alias[3], b_alias[3], c_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pdiv<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pdiv(a_alias[0], b_alias[0]);
+  r_alias[1] = pdiv(a_alias[1], b_alias[1]);
+  r_alias[2] = pdiv(a_alias[2], b_alias[2]);
+  r_alias[3] = pdiv(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmin<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pmin(a_alias[0], b_alias[0]);
+  r_alias[1] = pmin(a_alias[1], b_alias[1]);
+  r_alias[2] = pmin(a_alias[2], b_alias[2]);
+  r_alias[3] = pmin(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmax<Packet4h2>(
+    const Packet4h2& a, const Packet4h2& b) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  const half2* b_alias = reinterpret_cast<const half2*>(&b);
+  r_alias[0] = pmax(a_alias[0], b_alias[0]);
+  r_alias[1] = pmax(a_alias[1], b_alias[1]);
+  r_alias[2] = pmax(a_alias[2], b_alias[2]);
+  r_alias[3] = pmax(a_alias[3], b_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux<Packet4h2>(
+    const Packet4h2& a) {
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+
+  return predux(a_alias[0]) + predux(a_alias[1]) +
+         predux(a_alias[2]) + predux(a_alias[3]);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_max<Packet4h2>(
+    const Packet4h2& a) {
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  half2 m0 = combine_half(predux_max(a_alias[0]),
+                            predux_max(a_alias[1]));
+  half2 m1 = combine_half(predux_max(a_alias[2]),
+                            predux_max(a_alias[3]));
+  __half first  = predux_max(m0);
+  __half second = predux_max(m1);
+#if defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
+  return (__hgt(first, second) ? first : second);
+#else
+  float ffirst  = __half2float(first);
+  float fsecond = __half2float(second);
+  return (ffirst > fsecond)? first: second;
+#endif
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_min<Packet4h2>(
+    const Packet4h2& a) {
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  half2 m0 = combine_half(predux_min(a_alias[0]),
+                            predux_min(a_alias[1]));
+  half2 m1 = combine_half(predux_min(a_alias[2]),
+                            predux_min(a_alias[3]));
+  __half first  = predux_min(m0);
+  __half second = predux_min(m1);
+#if defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
+  return (__hlt(first, second) ? first : second);
+#else
+  float ffirst  = __half2float(first);
+  float fsecond = __half2float(second);
+  return (ffirst < fsecond)? first: second;
+#endif
+}
+
+// likely overflow/underflow
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet4h2>(
+    const Packet4h2& a) {
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  return predux_mul(pmul(pmul(a_alias[0], a_alias[1]),
+                                       pmul(a_alias[2], a_alias[3])));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+plog1p<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = plog1p(a_alias[0]);
+  r_alias[1] = plog1p(a_alias[1]);
+  r_alias[2] = plog1p(a_alias[2]);
+  r_alias[3] = plog1p(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+pexpm1<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = pexpm1(a_alias[0]);
+  r_alias[1] = pexpm1(a_alias[1]);
+  r_alias[2] = pexpm1(a_alias[2]);
+  r_alias[3] = pexpm1(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 plog<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = plog(a_alias[0]);
+  r_alias[1] = plog(a_alias[1]);
+  r_alias[2] = plog(a_alias[2]);
+  r_alias[3] = plog(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pexp<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = pexp(a_alias[0]);
+  r_alias[1] = pexp(a_alias[1]);
+  r_alias[2] = pexp(a_alias[2]);
+  r_alias[3] = pexp(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 psqrt<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = psqrt(a_alias[0]);
+  r_alias[1] = psqrt(a_alias[1]);
+  r_alias[2] = psqrt(a_alias[2]);
+  r_alias[3] = psqrt(a_alias[3]);
+  return r;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2
+prsqrt<Packet4h2>(const Packet4h2& a) {
+  Packet4h2 r;
+  half2* r_alias = reinterpret_cast<half2*>(&r);
+  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  r_alias[0] = prsqrt(a_alias[0]);
+  r_alias[1] = prsqrt(a_alias[1]);
+  r_alias[2] = prsqrt(a_alias[2]);
+  r_alias[3] = prsqrt(a_alias[3]);
+  return r;
+}
+
+// The following specialized padd, pmul, pdiv, pmin, pmax, pset1 are needed for
+// the implementation of GPU half reduction.
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 padd<half2>(const half2& a,
+                                                        const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hadd2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 + b1;
+  float r2 = a2 + b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmul<half2>(const half2& a,
+                                                        const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __hmul2(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 * b1;
+  float r2 = a2 * b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pdiv<half2>(const half2& a,
+                                                        const half2& b) {
+#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+  return __h2div(a, b);
+#else
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  float r1 = a1 / b1;
+  float r2 = a2 / b2;
+  return __floats2half2_rn(r1, r2);
+#endif
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmin<half2>(const half2& a,
+                                                        const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  __half r1 = a1 < b1 ? get_half2_low(a) : get_half2_low(b);
+  __half r2 = a2 < b2 ? get_half2_high(a) : get_half2_high(b);
+  return combine_half(r1, r2);
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmax<half2>(const half2& a,
+                                                        const half2& b) {
+  float a1 = __low2float(a);
+  float a2 = __high2float(a);
+  float b1 = __low2float(b);
+  float b2 = __high2float(b);
+  __half r1 = a1 > b1 ? get_half2_low(a) : get_half2_low(b);
+  __half r2 = a2 > b2 ? get_half2_high(a) : get_half2_high(b);
+  return combine_half(r1, r2);
+}
+
+// #endif // defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIPCC) || (defined(EIGEN_CUDACC) && EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC)
+
+#endif // defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)
+
+#undef EIGEN_GPU_HAS_LDG
+#undef EIGEN_CUDA_HAS_FP16_ARITHMETIC
+#undef EIGEN_GPU_HAS_FP16_ARITHMETIC
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+
+#endif // EIGEN_PACKET_MATH_GPU_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/GPU/TypeCasting.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/GPU/TypeCasting.h
new file mode 100644
index 00000000..75454622
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/GPU/TypeCasting.h
@@ -0,0 +1,80 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_GPU_H
+#define EIGEN_TYPE_CASTING_GPU_H
+
+namespace Eigen {
+
+namespace internal {
+
+#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
+  (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+
+
+template <>
+struct type_casting_traits<Eigen::half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 2
+  };
+};
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcast<half2, float4>(const half2& a, const half2& b) {
+  float2 r1 = __half22float2(a);
+  float2 r2 = __half22float2(b);
+  return make_float4(r1.x, r1.y, r2.x, r2.y);
+}
+
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pcast<float4, Packet4h2>(const float4& a, const float4& b) {
+  Packet4h2 r;
+  half2* r_alias=reinterpret_cast<half2*>(&r);
+  r_alias[0]=__floats2half2_rn(a.x,a.y);
+  r_alias[1]=__floats2half2_rn(a.z,a.w);
+  r_alias[2]=__floats2half2_rn(b.x,b.y);
+  r_alias[3]=__floats2half2_rn(b.z,b.w);
+  return r;
+}
+
+template <>
+struct type_casting_traits<float, Eigen::half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 2,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcast<Packet4h2, float4>(const Packet4h2& a) {
+  // Simply discard the second half of the input
+  float4 r;
+  const half2* a_alias=reinterpret_cast<const half2*>(&a);
+  float2 r1 = __half22float2(a_alias[0]);
+  float2 r2 = __half22float2(a_alias[1]);
+  r.x=static_cast<float>(r1.x);
+  r.y=static_cast<float>(r1.y);
+  r.z=static_cast<float>(r2.x);
+  r.w=static_cast<float>(r2.y);
+  return r;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcast<float4, half2>(const float4& a) {
+  // Simply discard the second half of the input
+  return __floats2half2_rn(a.x, a.y);
+}
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_GPU_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/HIP/hcc/math_constants.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
new file mode 100644
index 00000000..25375a0a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/HIP/hcc/math_constants.h
@@ -0,0 +1,23 @@
+/*
+ * math_constants.h - 
+ *  HIP equivalent of the CUDA header of the same name
+ */
+
+#ifndef __MATH_CONSTANTS_H__
+#define __MATH_CONSTANTS_H__
+
+/* single precision constants */
+
+#define HIPRT_INF_F        __int_as_float(0x7f800000)
+#define HIPRT_NAN_F        __int_as_float(0x7fffffff)
+#define HIPRT_MIN_DENORM_F __int_as_float(0x00000001)
+#define HIPRT_MAX_NORMAL_F __int_as_float(0x7f7fffff)
+#define HIPRT_NEG_ZERO_F   __int_as_float(0x80000000)
+#define HIPRT_ZERO_F       0.0f
+#define HIPRT_ONE_F        1.0f
+
+/* double precision constants */
+#define HIPRT_INF          __hiloint2double(0x7ff00000, 0x00000000)
+#define HIPRT_NAN          __hiloint2double(0xfff80000, 0x00000000)
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/MSA/Complex.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/MSA/Complex.h
new file mode 100644
index 00000000..53dacfa4
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/MSA/Complex.h
@@ -0,0 +1,648 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Wave Computing, Inc.
+// Written by:
+//   Chris Larsen
+//   Alexey Frunze (afrunze@wavecomp.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_MSA_H
+#define EIGEN_COMPLEX_MSA_H
+
+#include <iostream>
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- float ----------
+struct Packet2cf {
+  EIGEN_STRONG_INLINE Packet2cf() {
+  }
+  EIGEN_STRONG_INLINE explicit Packet2cf(const std::complex<float>& a,
+                                         const std::complex<float>& b) {
+    Packet4f t = { std::real(a), std::imag(a), std::real(b), std::imag(b) };
+    v = t;
+  }
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {
+  }
+  EIGEN_STRONG_INLINE Packet2cf(const Packet2cf& a) : v(a.v) {
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator=(const Packet2cf& b) {
+    v = b.v;
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf conjugate(void) const {
+    return Packet2cf((Packet4f)__builtin_msa_bnegi_d((v2u64)v, 63));
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator*=(const Packet2cf& b) {
+    Packet4f v1, v2;
+
+    // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
+    v1 = (Packet4f)__builtin_msa_ilvev_w((v4i32)v, (v4i32)v);
+    // Get the imag values of a | a1_im | a1_im | a2_im | a2_im |
+    v2 = (Packet4f)__builtin_msa_ilvod_w((v4i32)v, (v4i32)v);
+    // Multiply the real a with b
+    v1 = pmul(v1, b.v);
+    // Multiply the imag a with b
+    v2 = pmul(v2, b.v);
+    // Conjugate v2
+    v2 = Packet2cf(v2).conjugate().v;
+    // Swap real/imag elements in v2.
+    v2 = (Packet4f)__builtin_msa_shf_w((v4i32)v2, EIGEN_MSA_SHF_I8(1, 0, 3, 2));
+    // Add and return the result
+    v = padd(v1, v2);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator*(const Packet2cf& b) const {
+    return Packet2cf(*this) *= b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator+=(const Packet2cf& b) {
+    v = padd(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator+(const Packet2cf& b) const {
+    return Packet2cf(*this) += b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator-=(const Packet2cf& b) {
+    v = psub(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator-(const Packet2cf& b) const {
+    return Packet2cf(*this) -= b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf& operator/=(const Packet2cf& b) {
+    *this *= b.conjugate();
+    Packet4f s = pmul<Packet4f>(b.v, b.v);
+    s = padd(s, (Packet4f)__builtin_msa_shf_w((v4i32)s, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+    v = pdiv(v, s);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator/(const Packet2cf& b) const {
+    return Packet2cf(*this) /= b;
+  }
+  EIGEN_STRONG_INLINE Packet2cf operator-(void) const {
+    return Packet2cf(pnegate(v));
+  }
+
+  Packet4f v;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const Packet2cf& value) {
+  os << "[ (" << value.v[0] << ", " << value.v[1]
+     << "i),"
+        "  ("
+     << value.v[2] << ", " << value.v[3] << "i) ]";
+  return os;
+}
+
+template <>
+struct packet_traits<std::complex<float> > : default_packet_traits {
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasSetLinear = 0,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct unpacket_traits<Packet2cf> {
+  typedef std::complex<float> type;
+  enum { size = 2, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
+  typedef Packet2cf half;
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>& from) {
+  EIGEN_MSA_DEBUG;
+
+  float f0 = from.real(), f1 = from.imag();
+  Packet4f v0 = { f0, f0, f0, f0 };
+  Packet4f v1 = { f1, f1, f1, f1 };
+  return Packet2cf((Packet4f)__builtin_msa_ilvr_w((Packet4i)v1, (Packet4i)v0));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a + b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a - b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return -a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a.conjugate();
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a * b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pand<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf(pand(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf por<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf(por(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pxor<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf(pxor(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf(pandnot(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pload<Packet2cf>(const std::complex<float>* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from) {
+  EIGEN_MSA_DEBUG;
+
+  return pset1<Packet2cf>(*from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<float> >(std::complex<float>* to,
+                                                      const Packet2cf& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_STORE pstore<float>((float*)to, from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float>* to,
+                                                       const Packet2cf& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<float>((float*)to, from.v);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(
+    const std::complex<float>* from, Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf(from[0 * stride], from[1 * stride]);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to,
+                                                                       const Packet2cf& from,
+                                                                       Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  *to = std::complex<float>(from.v[0], from.v[1]);
+  to += stride;
+  *to = std::complex<float>(from.v[2], from.v[3]);
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float>* addr) {
+  EIGEN_MSA_DEBUG;
+
+  prefetch(reinterpret_cast<const float*>(addr));
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return std::complex<float>(a.v[0], a.v[1]);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf((Packet4f)__builtin_msa_shf_w((v4i32)a.v, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet2cf((Packet4f)__builtin_msa_shf_w((v4i32)a.v, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4f value = (Packet4f)preverse((Packet2d)a.v);
+  value += a.v;
+  return std::complex<float>(value[0], value[1]);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a) {
+  EIGEN_MSA_DEBUG;
+
+  return std::complex<float>((a.v[0] * a.v[2]) - (a.v[1] * a.v[3]),
+                             (a.v[0] * a.v[3]) + (a.v[1] * a.v[2]));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf, Packet4f)
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a / b;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet2cf, 2>& value) {
+  os << "[ " << value.packet[0] << ", " << std::endl << "  " << value.packet[1] << " ]";
+  return os;
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2cf, 2>& kernel) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4f tmp =
+      (Packet4f)__builtin_msa_ilvl_d((v2i64)kernel.packet[1].v, (v2i64)kernel.packet[0].v);
+  kernel.packet[0].v =
+      (Packet4f)__builtin_msa_ilvr_d((v2i64)kernel.packet[1].v, (v2i64)kernel.packet[0].v);
+  kernel.packet[1].v = tmp;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket,
+                                     const Packet2cf& elsePacket) {
+  return (Packet2cf)(Packet4f)pblend<Packet2d>(ifPacket, (Packet2d)thenPacket.v,
+                                               (Packet2d)elsePacket.v);
+}
+
+//---------- double ----------
+
+struct Packet1cd {
+  EIGEN_STRONG_INLINE Packet1cd() {
+  }
+  EIGEN_STRONG_INLINE explicit Packet1cd(const std::complex<double>& a) {
+    v[0] = std::real(a);
+    v[1] = std::imag(a);
+  }
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {
+  }
+  EIGEN_STRONG_INLINE Packet1cd(const Packet1cd& a) : v(a.v) {
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator=(const Packet1cd& b) {
+    v = b.v;
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd conjugate(void) const {
+    static const v2u64 p2ul_CONJ_XOR = { 0x0, 0x8000000000000000 };
+    return (Packet1cd)pxor(v, (Packet2d)p2ul_CONJ_XOR);
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator*=(const Packet1cd& b) {
+    Packet2d v1, v2;
+
+    // Get the real values of a | a1_re | a1_re
+    v1 = (Packet2d)__builtin_msa_ilvev_d((v2i64)v, (v2i64)v);
+    // Get the imag values of a | a1_im | a1_im
+    v2 = (Packet2d)__builtin_msa_ilvod_d((v2i64)v, (v2i64)v);
+    // Multiply the real a with b
+    v1 = pmul(v1, b.v);
+    // Multiply the imag a with b
+    v2 = pmul(v2, b.v);
+    // Conjugate v2
+    v2 = Packet1cd(v2).conjugate().v;
+    // Swap real/imag elements in v2.
+    v2 = (Packet2d)__builtin_msa_shf_w((v4i32)v2, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+    // Add and return the result
+    v = padd(v1, v2);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator*(const Packet1cd& b) const {
+    return Packet1cd(*this) *= b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator+=(const Packet1cd& b) {
+    v = padd(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator+(const Packet1cd& b) const {
+    return Packet1cd(*this) += b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator-=(const Packet1cd& b) {
+    v = psub(v, b.v);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator-(const Packet1cd& b) const {
+    return Packet1cd(*this) -= b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd& operator/=(const Packet1cd& b) {
+    *this *= b.conjugate();
+    Packet2d s = pmul<Packet2d>(b.v, b.v);
+    s = padd(s, preverse<Packet2d>(s));
+    v = pdiv(v, s);
+    return *this;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator/(const Packet1cd& b) const {
+    return Packet1cd(*this) /= b;
+  }
+  EIGEN_STRONG_INLINE Packet1cd operator-(void) const {
+    return Packet1cd(pnegate(v));
+  }
+
+  Packet2d v;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const Packet1cd& value) {
+  os << "[ (" << value.v[0] << ", " << value.v[1] << "i) ]";
+  return os;
+}
+
+template <>
+struct packet_traits<std::complex<double> > : default_packet_traits {
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasSetLinear = 0
+  };
+};
+
+template <>
+struct unpacket_traits<Packet1cd> {
+  typedef std::complex<double> type;
+  enum { size = 1, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
+  typedef Packet1cd half;
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pload<Packet1cd>(const std::complex<double>* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>& from) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a + b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a - b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return -a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a.conjugate();
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a * b;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pand<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(pand(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd por<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(por(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pxor<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(pxor(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(pandnot(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) {
+  EIGEN_MSA_DEBUG;
+
+  return pset1<Packet1cd>(*from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<double> >(std::complex<double>* to,
+                                                       const Packet1cd& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_STORE pstore<double>((double*)to, from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double>* to,
+                                                        const Packet1cd& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<double>((double*)to, from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double>* addr) {
+  EIGEN_MSA_DEBUG;
+
+  prefetch(reinterpret_cast<const double*>(addr));
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(
+    const std::complex<double>* from, Index stride __attribute__((unused))) {
+  EIGEN_MSA_DEBUG;
+
+  Packet1cd res;
+  res.v[0] = std::real(from[0]);
+  res.v[1] = std::imag(from[0]);
+  return res;
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to,
+                                                                        const Packet1cd& from,
+                                                                        Index stride
+                                                                        __attribute__((unused))) {
+  EIGEN_MSA_DEBUG;
+
+  pstore(to, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet1cd>(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return std::complex<double>(a.v[0], a.v[1]);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return pfirst(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) {
+  EIGEN_MSA_DEBUG;
+
+  return pfirst(a);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd, Packet2d)
+
+template <>
+EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b) {
+  EIGEN_MSA_DEBUG;
+
+  return a / b;
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip /*<Packet1cd>*/ (const Packet1cd& x) {
+  EIGEN_MSA_DEBUG;
+
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet1cd, 2>& value) {
+  os << "[ " << value.packet[0] << ", " << std::endl << "  " << value.packet[1] << " ]";
+  return os;
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd, 2>& kernel) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d v1, v2;
+
+  v1 = (Packet2d)__builtin_msa_ilvev_d((v2i64)kernel.packet[0].v, (v2i64)kernel.packet[1].v);
+  // Get the imag values of a
+  v2 = (Packet2d)__builtin_msa_ilvod_d((v2i64)kernel.packet[0].v, (v2i64)kernel.packet[1].v);
+
+  kernel.packet[0].v = v1;
+  kernel.packet[1].v = v2;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_COMPLEX_MSA_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/MSA/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/MSA/MathFunctions.h
new file mode 100644
index 00000000..f5181b90
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/MSA/MathFunctions.h
@@ -0,0 +1,387 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// Copyright (C) 2018 Wave Computing, Inc.
+// Written by:
+//   Chris Larsen
+//   Alexey Frunze (afrunze@wavecomp.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The sin, cos, exp, and log functions of this file come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+/* The tanh function of this file is an adaptation of
+ * template<typename T> T generic_fast_tanh_float(const T&)
+ * from MathFunctionsImpl.h.
+ */
+
+#ifndef EIGEN_MATH_FUNCTIONS_MSA_H
+#define EIGEN_MATH_FUNCTIONS_MSA_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+plog<Packet4f>(const Packet4f& _x) {
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_SQRTHF, 0.707106781186547524f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p0, 7.0376836292e-2f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p1, -1.1514610310e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p2, 1.1676998740e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p3, -1.2420140846e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p4, +1.4249322787e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p5, -1.6668057665e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p6, +2.0000714765e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p7, -2.4999993993e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p8, +3.3333331174e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q1, -2.12194440e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q2, 0.693359375f);
+  static _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+  static _EIGEN_DECLARE_CONST_Packet4f(1, 1.0f);
+
+  // Convert negative argument into NAN (quiet negative, to be specific).
+  Packet4f zero = (Packet4f)__builtin_msa_ldi_w(0);
+  Packet4i neg_mask = __builtin_msa_fclt_w(_x, zero);
+  Packet4i zero_mask = __builtin_msa_fceq_w(_x, zero);
+  Packet4f non_neg_x_or_nan = padd(_x, (Packet4f)neg_mask);  // Add 0.0 or NAN.
+  Packet4f x = non_neg_x_or_nan;
+
+  // Extract exponent from x = mantissa * 2**exponent, where 1.0 <= mantissa < 2.0.
+  // N.B. the exponent is one less of what frexpf() would return.
+  Packet4i e_int = __builtin_msa_ftint_s_w(__builtin_msa_flog2_w(x));
+  // Multiply x by 2**(-exponent-1) to get 0.5 <= x < 1.0 as from frexpf().
+  x = __builtin_msa_fexp2_w(x, (Packet4i)__builtin_msa_nori_b((v16u8)e_int, 0));
+
+  /*
+     if (x < SQRTHF) {
+       x = x + x - 1.0;
+     } else {
+       e += 1;
+       x = x - 1.0;
+     }
+  */
+  Packet4f xx = padd(x, x);
+  Packet4i ge_mask = __builtin_msa_fcle_w(p4f_cephes_SQRTHF, x);
+  e_int = psub(e_int, ge_mask);
+  x = (Packet4f)__builtin_msa_bsel_v((v16u8)ge_mask, (v16u8)xx, (v16u8)x);
+  x = psub(x, p4f_1);
+  Packet4f e = __builtin_msa_ffint_s_w(e_int);
+
+  Packet4f x2 = pmul(x, x);
+  Packet4f x3 = pmul(x2, x);
+
+  Packet4f y, y1, y2;
+  y = pmadd(p4f_cephes_log_p0, x, p4f_cephes_log_p1);
+  y1 = pmadd(p4f_cephes_log_p3, x, p4f_cephes_log_p4);
+  y2 = pmadd(p4f_cephes_log_p6, x, p4f_cephes_log_p7);
+  y = pmadd(y, x, p4f_cephes_log_p2);
+  y1 = pmadd(y1, x, p4f_cephes_log_p5);
+  y2 = pmadd(y2, x, p4f_cephes_log_p8);
+  y = pmadd(y, x3, y1);
+  y = pmadd(y, x3, y2);
+  y = pmul(y, x3);
+
+  y = pmadd(e, p4f_cephes_log_q1, y);
+  x = __builtin_msa_fmsub_w(x, x2, p4f_half);
+  x = padd(x, y);
+  x = pmadd(e, p4f_cephes_log_q2, x);
+
+  // x is now the logarithm result candidate. We still need to handle the
+  // extreme arguments of zero and positive infinity, though.
+  // N.B. if the argument is +INFINITY, x is NAN because the polynomial terms
+  // contain infinities of both signs (see the coefficients and code above).
+  // INFINITY - INFINITY is NAN.
+
+  // If the argument is +INFINITY, make it the new result candidate.
+  // To achieve that we choose the smaller of the result candidate and the
+  // argument.
+  // This is correct for all finite pairs of values (the logarithm is smaller
+  // than the argument).
+  // This is also correct in the special case when the argument is +INFINITY
+  // and the result candidate is NAN. This is because the fmin.df instruction
+  // prefers non-NANs to NANs.
+  x = __builtin_msa_fmin_w(x, non_neg_x_or_nan);
+
+  // If the argument is zero (including -0.0), the result becomes -INFINITY.
+  Packet4i neg_infs = __builtin_msa_slli_w(zero_mask, 23);
+  x = (Packet4f)__builtin_msa_bsel_v((v16u8)zero_mask, (v16u8)x, (v16u8)neg_infs);
+
+  return x;
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+pexp<Packet4f>(const Packet4f& _x) {
+  // Limiting single-precision pexp's argument to [-128, +128] lets pexp
+  // reach 0 and INFINITY naturally.
+  static _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -128.0f);
+  static _EIGEN_DECLARE_CONST_Packet4f(exp_hi, +128.0f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894e-2f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+  static _EIGEN_DECLARE_CONST_Packet4f(1, 1.0f);
+
+  Packet4f x = _x;
+
+  // Clamp x.
+  x = (Packet4f)__builtin_msa_bsel_v((v16u8)__builtin_msa_fclt_w(x, p4f_exp_lo), (v16u8)x,
+                                     (v16u8)p4f_exp_lo);
+  x = (Packet4f)__builtin_msa_bsel_v((v16u8)__builtin_msa_fclt_w(p4f_exp_hi, x), (v16u8)x,
+                                     (v16u8)p4f_exp_hi);
+
+  // Round to nearest integer by adding 0.5 (with x's sign) and truncating.
+  Packet4f x2_add = (Packet4f)__builtin_msa_binsli_w((v4u32)p4f_half, (v4u32)x, 0);
+  Packet4f x2 = pmadd(x, p4f_cephes_LOG2EF, x2_add);
+  Packet4i x2_int = __builtin_msa_ftrunc_s_w(x2);
+  Packet4f x2_int_f = __builtin_msa_ffint_s_w(x2_int);
+
+  x = __builtin_msa_fmsub_w(x, x2_int_f, p4f_cephes_exp_C1);
+  x = __builtin_msa_fmsub_w(x, x2_int_f, p4f_cephes_exp_C2);
+
+  Packet4f z = pmul(x, x);
+
+  Packet4f y = p4f_cephes_exp_p0;
+  y = pmadd(y, x, p4f_cephes_exp_p1);
+  y = pmadd(y, x, p4f_cephes_exp_p2);
+  y = pmadd(y, x, p4f_cephes_exp_p3);
+  y = pmadd(y, x, p4f_cephes_exp_p4);
+  y = pmadd(y, x, p4f_cephes_exp_p5);
+  y = pmadd(y, z, x);
+  y = padd(y, p4f_1);
+
+  // y *= 2**exponent.
+  y = __builtin_msa_fexp2_w(y, x2_int);
+
+  return y;
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+ptanh<Packet4f>(const Packet4f& _x) {
+  static _EIGEN_DECLARE_CONST_Packet4f(tanh_tiny, 1e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(tanh_hi, 9.0f);
+  // The monomial coefficients of the numerator polynomial (odd).
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_1, 4.89352455891786e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_3, 6.37261928875436e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_5, 1.48572235717979e-5f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_7, 5.12229709037114e-8f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_9, -8.60467152213735e-11f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_11, 2.00018790482477e-13f);
+  static _EIGEN_DECLARE_CONST_Packet4f(alpha_13, -2.76076847742355e-16f);
+  // The monomial coefficients of the denominator polynomial (even).
+  static _EIGEN_DECLARE_CONST_Packet4f(beta_0, 4.89352518554385e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(beta_2, 2.26843463243900e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(beta_4, 1.18534705686654e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(beta_6, 1.19825839466702e-6f);
+
+  Packet4f x = pabs(_x);
+  Packet4i tiny_mask = __builtin_msa_fclt_w(x, p4f_tanh_tiny);
+
+  // Clamp the inputs to the range [-9, 9] since anything outside
+  // this range is -/+1.0f in single-precision.
+  x = (Packet4f)__builtin_msa_bsel_v((v16u8)__builtin_msa_fclt_w(p4f_tanh_hi, x), (v16u8)x,
+                                     (v16u8)p4f_tanh_hi);
+
+  // Since the polynomials are odd/even, we need x**2.
+  Packet4f x2 = pmul(x, x);
+
+  // Evaluate the numerator polynomial p.
+  Packet4f p = pmadd(x2, p4f_alpha_13, p4f_alpha_11);
+  p = pmadd(x2, p, p4f_alpha_9);
+  p = pmadd(x2, p, p4f_alpha_7);
+  p = pmadd(x2, p, p4f_alpha_5);
+  p = pmadd(x2, p, p4f_alpha_3);
+  p = pmadd(x2, p, p4f_alpha_1);
+  p = pmul(x, p);
+
+  // Evaluate the denominator polynomial q.
+  Packet4f q = pmadd(x2, p4f_beta_6, p4f_beta_4);
+  q = pmadd(x2, q, p4f_beta_2);
+  q = pmadd(x2, q, p4f_beta_0);
+
+  // Divide the numerator by the denominator.
+  p = pdiv(p, q);
+
+  // Reinstate the sign.
+  p = (Packet4f)__builtin_msa_binsli_w((v4u32)p, (v4u32)_x, 0);
+
+  // When the argument is very small in magnitude it's more accurate to just return it.
+  p = (Packet4f)__builtin_msa_bsel_v((v16u8)tiny_mask, (v16u8)p, (v16u8)_x);
+
+  return p;
+}
+
+template <bool sine>
+Packet4f psincos_inner_msa_float(const Packet4f& _x) {
+  static _EIGEN_DECLARE_CONST_Packet4f(sincos_max_arg, 13176795.0f);  // Approx. (2**24) / (4/Pi).
+  static _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP1, -0.78515625f);
+  static _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP2, -2.4187564849853515625e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP3, -3.77489497744594108e-8f);
+  static _EIGEN_DECLARE_CONST_Packet4f(sincof_p0, -1.9515295891e-4f);
+  static _EIGEN_DECLARE_CONST_Packet4f(sincof_p1, 8.3321608736e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(sincof_p2, -1.6666654611e-1f);
+  static _EIGEN_DECLARE_CONST_Packet4f(coscof_p0, 2.443315711809948e-5f);
+  static _EIGEN_DECLARE_CONST_Packet4f(coscof_p1, -1.388731625493765e-3f);
+  static _EIGEN_DECLARE_CONST_Packet4f(coscof_p2, 4.166664568298827e-2f);
+  static _EIGEN_DECLARE_CONST_Packet4f(cephes_FOPI, 1.27323954473516f);  // 4/Pi.
+  static _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+  static _EIGEN_DECLARE_CONST_Packet4f(1, 1.0f);
+
+  Packet4f x = pabs(_x);
+
+  // Translate infinite arguments into NANs.
+  Packet4f zero_or_nan_if_inf = psub(_x, _x);
+  x = padd(x, zero_or_nan_if_inf);
+  // Prevent sin/cos from generating values larger than 1.0 in magnitude
+  // for very large arguments by setting x to 0.0.
+  Packet4i small_or_nan_mask = __builtin_msa_fcult_w(x, p4f_sincos_max_arg);
+  x = pand(x, (Packet4f)small_or_nan_mask);
+
+  // Scale x by 4/Pi to find x's octant.
+  Packet4f y = pmul(x, p4f_cephes_FOPI);
+  // Get the octant. We'll reduce x by this number of octants or by one more than it.
+  Packet4i y_int = __builtin_msa_ftrunc_s_w(y);
+  // x's from even-numbered octants will translate to octant 0: [0, +Pi/4].
+  // x's from odd-numbered octants will translate to octant -1: [-Pi/4, 0].
+  // Adjustment for odd-numbered octants: octant = (octant + 1) & (~1).
+  Packet4i y_int1 = __builtin_msa_addvi_w(y_int, 1);
+  Packet4i y_int2 = (Packet4i)__builtin_msa_bclri_w((Packet4ui)y_int1, 0); // bclri = bit-clear
+  y = __builtin_msa_ffint_s_w(y_int2);
+
+  // Compute the sign to apply to the polynomial.
+  Packet4i sign_mask = sine ? pxor(__builtin_msa_slli_w(y_int1, 29), (Packet4i)_x)
+                            : __builtin_msa_slli_w(__builtin_msa_addvi_w(y_int, 3), 29);
+
+  // Get the polynomial selection mask.
+  // We'll calculate both (sin and cos) polynomials and then select from the two.
+  Packet4i poly_mask = __builtin_msa_ceqi_w(__builtin_msa_slli_w(y_int2, 30), 0);
+
+  // Reduce x by y octants to get: -Pi/4 <= x <= +Pi/4.
+  // The magic pass: "Extended precision modular arithmetic"
+  // x = ((x - y * DP1) - y * DP2) - y * DP3
+  Packet4f tmp1 = pmul(y, p4f_minus_cephes_DP1);
+  Packet4f tmp2 = pmul(y, p4f_minus_cephes_DP2);
+  Packet4f tmp3 = pmul(y, p4f_minus_cephes_DP3);
+  x = padd(x, tmp1);
+  x = padd(x, tmp2);
+  x = padd(x, tmp3);
+
+  // Evaluate the cos(x) polynomial.
+  y = p4f_coscof_p0;
+  Packet4f z = pmul(x, x);
+  y = pmadd(y, z, p4f_coscof_p1);
+  y = pmadd(y, z, p4f_coscof_p2);
+  y = pmul(y, z);
+  y = pmul(y, z);
+  y = __builtin_msa_fmsub_w(y, z, p4f_half);
+  y = padd(y, p4f_1);
+
+  // Evaluate the sin(x) polynomial.
+  Packet4f y2 = p4f_sincof_p0;
+  y2 = pmadd(y2, z, p4f_sincof_p1);
+  y2 = pmadd(y2, z, p4f_sincof_p2);
+  y2 = pmul(y2, z);
+  y2 = pmadd(y2, x, x);
+
+  // Select the correct result from the two polynomials.
+  y = sine ? (Packet4f)__builtin_msa_bsel_v((v16u8)poly_mask, (v16u8)y, (v16u8)y2)
+           : (Packet4f)__builtin_msa_bsel_v((v16u8)poly_mask, (v16u8)y2, (v16u8)y);
+
+  // Update the sign.
+  sign_mask = pxor(sign_mask, (Packet4i)y);
+  y = (Packet4f)__builtin_msa_binsli_w((v4u32)y, (v4u32)sign_mask, 0); // binsli = bit-insert-left
+  return y;
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+psin<Packet4f>(const Packet4f& x) {
+  return psincos_inner_msa_float</* sine */ true>(x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+pcos<Packet4f>(const Packet4f& x) {
+  return psincos_inner_msa_float</* sine */ false>(x);
+}
+
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d
+pexp<Packet2d>(const Packet2d& _x) {
+  // Limiting double-precision pexp's argument to [-1024, +1024] lets pexp
+  // reach 0 and INFINITY naturally.
+  static _EIGEN_DECLARE_CONST_Packet2d(exp_lo, -1024.0);
+  static _EIGEN_DECLARE_CONST_Packet2d(exp_hi, +1024.0);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_LOG2EF, 1.4426950408889634073599);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C1, 0.693145751953125);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C2, 1.42860682030941723212e-6);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p0, 1.26177193074810590878e-4);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p1, 3.02994407707441961300e-2);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p2, 9.99999999999999999910e-1);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q0, 3.00198505138664455042e-6);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q1, 2.52448340349684104192e-3);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q2, 2.27265548208155028766e-1);
+  static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q3, 2.00000000000000000009e0);
+  static _EIGEN_DECLARE_CONST_Packet2d(half, 0.5);
+  static _EIGEN_DECLARE_CONST_Packet2d(1, 1.0);
+  static _EIGEN_DECLARE_CONST_Packet2d(2, 2.0);
+
+  Packet2d x = _x;
+
+  // Clamp x.
+  x = (Packet2d)__builtin_msa_bsel_v((v16u8)__builtin_msa_fclt_d(x, p2d_exp_lo), (v16u8)x,
+                                     (v16u8)p2d_exp_lo);
+  x = (Packet2d)__builtin_msa_bsel_v((v16u8)__builtin_msa_fclt_d(p2d_exp_hi, x), (v16u8)x,
+                                     (v16u8)p2d_exp_hi);
+
+  // Round to nearest integer by adding 0.5 (with x's sign) and truncating.
+  Packet2d x2_add = (Packet2d)__builtin_msa_binsli_d((v2u64)p2d_half, (v2u64)x, 0);
+  Packet2d x2 = pmadd(x, p2d_cephes_LOG2EF, x2_add);
+  Packet2l x2_long = __builtin_msa_ftrunc_s_d(x2);
+  Packet2d x2_long_d = __builtin_msa_ffint_s_d(x2_long);
+
+  x = __builtin_msa_fmsub_d(x, x2_long_d, p2d_cephes_exp_C1);
+  x = __builtin_msa_fmsub_d(x, x2_long_d, p2d_cephes_exp_C2);
+
+  x2 = pmul(x, x);
+
+  Packet2d px = p2d_cephes_exp_p0;
+  px = pmadd(px, x2, p2d_cephes_exp_p1);
+  px = pmadd(px, x2, p2d_cephes_exp_p2);
+  px = pmul(px, x);
+
+  Packet2d qx = p2d_cephes_exp_q0;
+  qx = pmadd(qx, x2, p2d_cephes_exp_q1);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q2);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q3);
+
+  x = pdiv(px, psub(qx, px));
+  x = pmadd(p2d_2, x, p2d_1);
+
+  // x *= 2**exponent.
+  x = __builtin_msa_fexp2_d(x, x2_long);
+
+  return x;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_MSA_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/MSA/PacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/MSA/PacketMath.h
new file mode 100644
index 00000000..afe8f337
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/MSA/PacketMath.h
@@ -0,0 +1,1233 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Wave Computing, Inc.
+// Written by:
+//   Chris Larsen
+//   Alexey Frunze (afrunze@wavecomp.com)
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_MSA_H
+#define EIGEN_PACKET_MATH_MSA_H
+
+#include <iostream>
+#include <string>
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
+#endif
+
+#if 0
+#define EIGEN_MSA_DEBUG                                                             \
+  static bool firstTime = true;                                                     \
+  do {                                                                              \
+    if (firstTime) {                                                                \
+      std::cout << __FILE__ << ':' << __LINE__ << ':' << __FUNCTION__ << std::endl; \
+      firstTime = false;                                                            \
+    }                                                                               \
+  } while (0)
+#else
+#define EIGEN_MSA_DEBUG
+#endif
+
+#define EIGEN_MSA_SHF_I8(a, b, c, d) (((d) << 6) | ((c) << 4) | ((b) << 2) | (a))
+
+typedef v4f32 Packet4f;
+typedef v4i32 Packet4i;
+typedef v4u32 Packet4ui;
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME, X) const Packet4f p4f_##NAME = { X, X, X, X }
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME, X) const Packet4i p4i_##NAME = { X, X, X, X }
+#define _EIGEN_DECLARE_CONST_Packet4ui(NAME, X) const Packet4ui p4ui_##NAME = { X, X, X, X }
+
+inline std::ostream& operator<<(std::ostream& os, const Packet4f& value) {
+  os << "[ " << value[0] << ", " << value[1] << ", " << value[2] << ", " << value[3] << " ]";
+  return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Packet4i& value) {
+  os << "[ " << value[0] << ", " << value[1] << ", " << value[2] << ", " << value[3] << " ]";
+  return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Packet4ui& value) {
+  os << "[ " << value[0] << ", " << value[1] << ", " << value[2] << ", " << value[3] << " ]";
+  return os;
+}
+
+template <>
+struct packet_traits<float> : default_packet_traits {
+  typedef Packet4f type;
+  typedef Packet4f half;  // Packet2f intrinsics not implemented yet
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,  // Packet2f intrinsics not implemented yet
+    // FIXME check the Has*
+    HasDiv = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<int32_t> : default_packet_traits {
+  typedef Packet4i type;
+  typedef Packet4i half;  // Packet2i intrinsics not implemented yet
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,  // Packet2i intrinsics not implemented yet
+    // FIXME check the Has*
+    HasDiv = 1,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct unpacket_traits<Packet4f> {
+  typedef float type;
+  enum { size = 4, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
+  typedef Packet4f half;
+};
+
+template <>
+struct unpacket_traits<Packet4i> {
+  typedef int32_t type;
+  enum { size = 4, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
+  typedef Packet4i half;
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4f v = { from, from, from, from };
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int32_t& from) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fill_w(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pload1<Packet4f>(const float* from) {
+  EIGEN_MSA_DEBUG;
+
+  float f = *from;
+  Packet4f v = { f, f, f, f };
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pload1<Packet4i>(const int32_t* from) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fill_w(*from);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fadd_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_addv_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a) {
+  EIGEN_MSA_DEBUG;
+
+  static const Packet4f countdown = { 0.0f, 1.0f, 2.0f, 3.0f };
+  return padd(pset1<Packet4f>(a), countdown);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int32_t& a) {
+  EIGEN_MSA_DEBUG;
+
+  static const Packet4i countdown = { 0, 1, 2, 3 };
+  return padd(pset1<Packet4i>(a), countdown);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fsub_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_subv_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_bnegi_w((v4u32)a, 31);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_addvi_w((v4i32)__builtin_msa_nori_b((v16u8)a, 0), 1);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fmul_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_mulv_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fdiv_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_div_s_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fmadd_w(c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) {
+  EIGEN_MSA_DEBUG;
+
+  // Use "asm" construct to avoid __builtin_msa_maddv_w GNU C bug.
+  Packet4i value = c;
+  __asm__("maddv.w %w[value], %w[a], %w[b]\n"
+          // Outputs
+          : [value] "+f"(value)
+          // Inputs
+          : [a] "f"(a), [b] "f"(b));
+  return value;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_and_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4i)__builtin_msa_and_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_or_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4i)__builtin_msa_or_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_xor_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4i)__builtin_msa_xor_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+  return pand(a, (Packet4f)__builtin_msa_xori_b((v16u8)b, 255));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return pand(a, (Packet4i)__builtin_msa_xori_b((v16u8)b, 255));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  // This prefers numbers to NaNs.
+  return __builtin_msa_fmin_w(a, b);
+#else
+  // This prefers NaNs to numbers.
+  Packet4i aNaN = __builtin_msa_fcun_w(a, a);
+  Packet4i aMinOrNaN = por(__builtin_msa_fclt_w(a, b), aNaN);
+  return (Packet4f)__builtin_msa_bsel_v((v16u8)aMinOrNaN, (v16u8)b, (v16u8)a);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_min_s_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  // This prefers numbers to NaNs.
+  return __builtin_msa_fmax_w(a, b);
+#else
+  // This prefers NaNs to numbers.
+  Packet4i aNaN = __builtin_msa_fcun_w(a, a);
+  Packet4i aMaxOrNaN = por(__builtin_msa_fclt_w(b, a), aNaN);
+  return (Packet4f)__builtin_msa_bsel_v((v16u8)aMaxOrNaN, (v16u8)b, (v16u8)a);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_max_s_w(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_LOAD return (Packet4f)__builtin_msa_ld_w(const_cast<float*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int32_t* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_LOAD return __builtin_msa_ld_w(const_cast<int32_t*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return (Packet4f)__builtin_msa_ld_w(const_cast<float*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int32_t* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return (Packet4i)__builtin_msa_ld_w(const_cast<int32_t*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float* from) {
+  EIGEN_MSA_DEBUG;
+
+  float f0 = from[0], f1 = from[1];
+  Packet4f v0 = { f0, f0, f0, f0 };
+  Packet4f v1 = { f1, f1, f1, f1 };
+  return (Packet4f)__builtin_msa_ilvr_d((v2i64)v1, (v2i64)v0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int32_t* from) {
+  EIGEN_MSA_DEBUG;
+
+  int32_t i0 = from[0], i1 = from[1];
+  Packet4i v0 = { i0, i0, i0, i0 };
+  Packet4i v1 = { i1, i1, i1, i1 };
+  return (Packet4i)__builtin_msa_ilvr_d((v2i64)v1, (v2i64)v0);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_STORE __builtin_msa_st_w((Packet4i)from, to, 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<int32_t>(int32_t* to, const Packet4i& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_STORE __builtin_msa_st_w(from, to, 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet4f& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_STORE __builtin_msa_st_w((Packet4i)from, to, 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<int32_t>(int32_t* to, const Packet4i& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_STORE __builtin_msa_st_w(from, to, 0);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  float f = *from;
+  Packet4f v = { f, f, f, f };
+  v[1] = from[stride];
+  v[2] = from[2 * stride];
+  v[3] = from[3 * stride];
+  return v;
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet4i pgather<int32_t, Packet4i>(const int32_t* from, Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  int32_t i = *from;
+  Packet4i v = { i, i, i, i };
+  v[1] = from[stride];
+  v[2] = from[2 * stride];
+  v[3] = from[3 * stride];
+  return v;
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from,
+                                                        Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  *to = from[0];
+  to += stride;
+  *to = from[1];
+  to += stride;
+  *to = from[2];
+  to += stride;
+  *to = from[3];
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<int32_t, Packet4i>(int32_t* to, const Packet4i& from,
+                                                          Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  *to = from[0];
+  to += stride;
+  *to = from[1];
+  to += stride;
+  *to = from[2];
+  to += stride;
+  *to = from[3];
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) {
+  EIGEN_MSA_DEBUG;
+
+  __builtin_prefetch(addr);
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<int32_t>(const int32_t* addr) {
+  EIGEN_MSA_DEBUG;
+
+  __builtin_prefetch(addr);
+}
+
+template <>
+EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE int32_t pfirst<Packet4i>(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_shf_w((v4i32)a, EIGEN_MSA_SHF_I8(3, 2, 1, 0));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_shf_w(a, EIGEN_MSA_SHF_I8(3, 2, 1, 0));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet4f)__builtin_msa_bclri_w((v4u32)a, 31);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4i zero = __builtin_msa_ldi_w(0);
+  return __builtin_msa_add_a_w(zero, a);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4f s = padd(a, (Packet4f)__builtin_msa_shf_w((v4i32)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  s = padd(s, (Packet4f)__builtin_msa_shf_w((v4i32)s, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return s[0];
+}
+
+
+template <>
+EIGEN_STRONG_INLINE int32_t predux<Packet4i>(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4i s = padd(a, __builtin_msa_shf_w(a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  s = padd(s, __builtin_msa_shf_w(s, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return s[0];
+}
+
+// Other reduction functions:
+// mul
+template <>
+EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4f p = pmul(a, (Packet4f)__builtin_msa_shf_w((v4i32)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  p = pmul(p, (Packet4f)__builtin_msa_shf_w((v4i32)p, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return p[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE int32_t predux_mul<Packet4i>(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4i p = pmul(a, __builtin_msa_shf_w(a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  p = pmul(p, __builtin_msa_shf_w(p, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return p[0];
+}
+
+// min
+template <>
+EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  // Swap 64-bit halves of a.
+  Packet4f swapped = (Packet4f)__builtin_msa_shf_w((Packet4i)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+#if !EIGEN_FAST_MATH
+  // Detect presence of NaNs from pairs a[0]-a[2] and a[1]-a[3] as two 32-bit
+  // masks of all zeroes/ones in low 64 bits.
+  v16u8 unord = (v16u8)__builtin_msa_fcun_w(a, swapped);
+  // Combine the two masks into one: 64 ones if no NaNs, otherwise 64 zeroes.
+  unord = (v16u8)__builtin_msa_ceqi_d((v2i64)unord, 0);
+#endif
+  // Continue with min computation.
+  Packet4f v = __builtin_msa_fmin_w(a, swapped);
+  v = __builtin_msa_fmin_w(
+      v, (Packet4f)__builtin_msa_shf_w((Packet4i)v, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+#if !EIGEN_FAST_MATH
+  // Based on the mask select between v and 4 qNaNs.
+  v16u8 qnans = (v16u8)__builtin_msa_fill_w(0x7FC00000);
+  v = (Packet4f)__builtin_msa_bsel_v(unord, qnans, (v16u8)v);
+#endif
+  return v[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE int32_t predux_min<Packet4i>(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4i m = pmin(a, __builtin_msa_shf_w(a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  m = pmin(m, __builtin_msa_shf_w(m, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return m[0];
+}
+
+// max
+template <>
+EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  // Swap 64-bit halves of a.
+  Packet4f swapped = (Packet4f)__builtin_msa_shf_w((Packet4i)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+#if !EIGEN_FAST_MATH
+  // Detect presence of NaNs from pairs a[0]-a[2] and a[1]-a[3] as two 32-bit
+  // masks of all zeroes/ones in low 64 bits.
+  v16u8 unord = (v16u8)__builtin_msa_fcun_w(a, swapped);
+  // Combine the two masks into one: 64 ones if no NaNs, otherwise 64 zeroes.
+  unord = (v16u8)__builtin_msa_ceqi_d((v2i64)unord, 0);
+#endif
+  // Continue with max computation.
+  Packet4f v = __builtin_msa_fmax_w(a, swapped);
+  v = __builtin_msa_fmax_w(
+      v, (Packet4f)__builtin_msa_shf_w((Packet4i)v, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+#if !EIGEN_FAST_MATH
+  // Based on the mask select between v and 4 qNaNs.
+  v16u8 qnans = (v16u8)__builtin_msa_fill_w(0x7FC00000);
+  v = (Packet4f)__builtin_msa_bsel_v(unord, qnans, (v16u8)v);
+#endif
+  return v[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE int32_t predux_max<Packet4i>(const Packet4i& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet4i m = pmax(a, __builtin_msa_shf_w(a, EIGEN_MSA_SHF_I8(2, 3, 0, 1)));
+  m = pmax(m, __builtin_msa_shf_w(m, EIGEN_MSA_SHF_I8(1, 0, 3, 2)));
+  return m[0];
+}
+
+inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet4f, 4>& value) {
+  os << "[ " << value.packet[0] << "," << std::endl
+     << "  " << value.packet[1] << "," << std::endl
+     << "  " << value.packet[2] << "," << std::endl
+     << "  " << value.packet[3] << " ]";
+  return os;
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4f, 4>& kernel) {
+  EIGEN_MSA_DEBUG;
+
+  v4i32 tmp1, tmp2, tmp3, tmp4;
+
+  tmp1 = __builtin_msa_ilvr_w((v4i32)kernel.packet[1], (v4i32)kernel.packet[0]);
+  tmp2 = __builtin_msa_ilvr_w((v4i32)kernel.packet[3], (v4i32)kernel.packet[2]);
+  tmp3 = __builtin_msa_ilvl_w((v4i32)kernel.packet[1], (v4i32)kernel.packet[0]);
+  tmp4 = __builtin_msa_ilvl_w((v4i32)kernel.packet[3], (v4i32)kernel.packet[2]);
+
+  kernel.packet[0] = (Packet4f)__builtin_msa_ilvr_d((v2i64)tmp2, (v2i64)tmp1);
+  kernel.packet[1] = (Packet4f)__builtin_msa_ilvod_d((v2i64)tmp2, (v2i64)tmp1);
+  kernel.packet[2] = (Packet4f)__builtin_msa_ilvr_d((v2i64)tmp4, (v2i64)tmp3);
+  kernel.packet[3] = (Packet4f)__builtin_msa_ilvod_d((v2i64)tmp4, (v2i64)tmp3);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet4i, 4>& value) {
+  os << "[ " << value.packet[0] << "," << std::endl
+     << "  " << value.packet[1] << "," << std::endl
+     << "  " << value.packet[2] << "," << std::endl
+     << "  " << value.packet[3] << " ]";
+  return os;
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4i, 4>& kernel) {
+  EIGEN_MSA_DEBUG;
+
+  v4i32 tmp1, tmp2, tmp3, tmp4;
+
+  tmp1 = __builtin_msa_ilvr_w(kernel.packet[1], kernel.packet[0]);
+  tmp2 = __builtin_msa_ilvr_w(kernel.packet[3], kernel.packet[2]);
+  tmp3 = __builtin_msa_ilvl_w(kernel.packet[1], kernel.packet[0]);
+  tmp4 = __builtin_msa_ilvl_w(kernel.packet[3], kernel.packet[2]);
+
+  kernel.packet[0] = (Packet4i)__builtin_msa_ilvr_d((v2i64)tmp2, (v2i64)tmp1);
+  kernel.packet[1] = (Packet4i)__builtin_msa_ilvod_d((v2i64)tmp2, (v2i64)tmp1);
+  kernel.packet[2] = (Packet4i)__builtin_msa_ilvr_d((v2i64)tmp4, (v2i64)tmp3);
+  kernel.packet[3] = (Packet4i)__builtin_msa_ilvod_d((v2i64)tmp4, (v2i64)tmp3);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f psqrt(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fsqrt_w(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f prsqrt(const Packet4f& a) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  return __builtin_msa_frsqrt_w(a);
+#else
+  Packet4f ones = __builtin_msa_ffint_s_w(__builtin_msa_ldi_w(1));
+  return pdiv(ones, psqrt(a));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a) {
+  Packet4f v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"  // 3 = round towards -INFINITY.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.w %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a) {
+  Packet4f v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"
+      "xori    %[new_mode], %[new_mode], 1\n"  // 2 = round towards +INFINITY.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.w %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a) {
+  Packet4f v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"
+      "xori    %[new_mode], %[new_mode], 3\n"  // 0 = round to nearest, ties to even.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.w %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,
+                                    const Packet4f& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2],
+                       ifPacket.select[3] };
+  Packet4i mask = __builtin_msa_ceqi_w((Packet4i)select, 0);
+  return (Packet4f)__builtin_msa_bsel_v((v16u8)mask, (v16u8)thenPacket, (v16u8)elsePacket);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,
+                                    const Packet4i& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2],
+                       ifPacket.select[3] };
+  Packet4i mask = __builtin_msa_ceqi_w((Packet4i)select, 0);
+  return (Packet4i)__builtin_msa_bsel_v((v16u8)mask, (v16u8)thenPacket, (v16u8)elsePacket);
+}
+
+//---------- double ----------
+
+typedef v2f64 Packet2d;
+typedef v2i64 Packet2l;
+typedef v2u64 Packet2ul;
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME, X) const Packet2d p2d_##NAME = { X, X }
+#define _EIGEN_DECLARE_CONST_Packet2l(NAME, X) const Packet2l p2l_##NAME = { X, X }
+#define _EIGEN_DECLARE_CONST_Packet2ul(NAME, X) const Packet2ul p2ul_##NAME = { X, X }
+
+inline std::ostream& operator<<(std::ostream& os, const Packet2d& value) {
+  os << "[ " << value[0] << ", " << value[1] << " ]";
+  return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Packet2l& value) {
+  os << "[ " << value[0] << ", " << value[1] << " ]";
+  return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Packet2ul& value) {
+  os << "[ " << value[0] << ", " << value[1] << " ]";
+  return os;
+}
+
+template <>
+struct packet_traits<double> : default_packet_traits {
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+    // FIXME check the Has*
+    HasDiv = 1,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct unpacket_traits<Packet2d> {
+  typedef double type;
+  enum { size = 2, alignment = Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false };
+  typedef Packet2d half;
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d value = { from, from };
+  return value;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fadd_d(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) {
+  EIGEN_MSA_DEBUG;
+
+  static const Packet2d countdown = { 0.0, 1.0 };
+  return padd(pset1<Packet2d>(a), countdown);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fsub_d(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_bnegi_d((v2u64)a, 63);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fmul_d(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fdiv_d(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fmadd_d(c, a, b);
+}
+
+// Logical Operations are not supported for float, so we have to reinterpret casts using MSA
+// intrinsics
+template <>
+EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_and_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_or_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_xor_v((v16u8)a, (v16u8)b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+  return pand(a, (Packet2d)__builtin_msa_xori_b((v16u8)b, 255));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return (Packet2d)__builtin_msa_ld_d(const_cast<double*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  // This prefers numbers to NaNs.
+  return __builtin_msa_fmin_d(a, b);
+#else
+  // This prefers NaNs to numbers.
+  v2i64 aNaN = __builtin_msa_fcun_d(a, a);
+  v2i64 aMinOrNaN = por(__builtin_msa_fclt_d(a, b), aNaN);
+  return (Packet2d)__builtin_msa_bsel_v((v16u8)aMinOrNaN, (v16u8)b, (v16u8)a);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  // This prefers numbers to NaNs.
+  return __builtin_msa_fmax_d(a, b);
+#else
+  // This prefers NaNs to numbers.
+  v2i64 aNaN = __builtin_msa_fcun_d(a, a);
+  v2i64 aMaxOrNaN = por(__builtin_msa_fclt_d(b, a), aNaN);
+  return (Packet2d)__builtin_msa_bsel_v((v16u8)aMaxOrNaN, (v16u8)b, (v16u8)a);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_LOAD return (Packet2d)__builtin_msa_ld_d(const_cast<double*>(from), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double* from) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d value = { *from, *from };
+  return value;
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet2d& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_ALIGNED_STORE __builtin_msa_st_d((v2i64)from, to, 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet2d& from) {
+  EIGEN_MSA_DEBUG;
+
+  EIGEN_DEBUG_UNALIGNED_STORE __builtin_msa_st_d((v2i64)from, to, 0);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d value;
+  value[0] = *from;
+  from += stride;
+  value[1] = *from;
+  return value;
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from,
+                                                         Index stride) {
+  EIGEN_MSA_DEBUG;
+
+  *to = from[0];
+  to += stride;
+  *to = from[1];
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) {
+  EIGEN_MSA_DEBUG;
+
+  __builtin_prefetch(addr);
+}
+
+template <>
+EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return a[0];
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_shf_w((v4i32)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return (Packet2d)__builtin_msa_bclri_d((v2u64)a, 63);
+}
+
+template <>
+EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d s = padd(a, preverse(a));
+  return s[0];
+}
+
+// Other reduction functions:
+// mul
+template <>
+EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d p = pmul(a, preverse(a));
+  return p[0];
+}
+
+// min
+template <>
+EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  Packet2d swapped = (Packet2d)__builtin_msa_shf_w((Packet4i)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+  Packet2d v = __builtin_msa_fmin_d(a, swapped);
+  return v[0];
+#else
+  double a0 = a[0], a1 = a[1];
+  return ((numext::isnan)(a0) || a0 < a1) ? a0 : a1;
+#endif
+}
+
+// max
+template <>
+EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  Packet2d swapped = (Packet2d)__builtin_msa_shf_w((Packet4i)a, EIGEN_MSA_SHF_I8(2, 3, 0, 1));
+  Packet2d v = __builtin_msa_fmax_d(a, swapped);
+  return v[0];
+#else
+  double a0 = a[0], a1 = a[1];
+  return ((numext::isnan)(a0) || a0 > a1) ? a0 : a1;
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d psqrt(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+  return __builtin_msa_fsqrt_d(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d prsqrt(const Packet2d& a) {
+  EIGEN_MSA_DEBUG;
+
+#if EIGEN_FAST_MATH
+  return __builtin_msa_frsqrt_d(a);
+#else
+  Packet2d ones = __builtin_msa_ffint_s_d(__builtin_msa_ldi_d(1));
+  return pdiv(ones, psqrt(a));
+#endif
+}
+
+inline std::ostream& operator<<(std::ostream& os, const PacketBlock<Packet2d, 2>& value) {
+  os << "[ " << value.packet[0] << "," << std::endl << "  " << value.packet[1] << " ]";
+  return os;
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2d, 2>& kernel) {
+  EIGEN_MSA_DEBUG;
+
+  Packet2d trn1 = (Packet2d)__builtin_msa_ilvev_d((v2i64)kernel.packet[1], (v2i64)kernel.packet[0]);
+  Packet2d trn2 = (Packet2d)__builtin_msa_ilvod_d((v2i64)kernel.packet[1], (v2i64)kernel.packet[0]);
+  kernel.packet[0] = trn1;
+  kernel.packet[1] = trn2;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) {
+  Packet2d v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"  // 3 = round towards -INFINITY.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.d %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a) {
+  Packet2d v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"
+      "xori    %[new_mode], %[new_mode], 1\n"  // 2 = round towards +INFINITY.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.d %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a) {
+  Packet2d v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"
+      "xori    %[new_mode], %[new_mode], 3\n"  // 0 = round to nearest, ties to even.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.d %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,
+                                    const Packet2d& elsePacket) {
+  Packet2ul select = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2l mask = __builtin_msa_ceqi_d((Packet2l)select, 0);
+  return (Packet2d)__builtin_msa_bsel_v((v16u8)mask, (v16u8)thenPacket, (v16u8)elsePacket);
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_PACKET_MATH_MSA_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/Complex.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/Complex.h
new file mode 100644
index 00000000..f40af7f8
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/Complex.h
@@ -0,0 +1,584 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_NEON_H
+#define EIGEN_COMPLEX_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+inline uint32x4_t p4ui_CONJ_XOR()
+{
+// See bug 1325, clang fails to call vld1q_u64.
+#if EIGEN_COMP_CLANG || EIGEN_COMP_CASTXML
+  uint32x4_t ret = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
+  return ret;
+#else
+  static const uint32_t conj_XOR_DATA[] = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
+  return vld1q_u32( conj_XOR_DATA );
+#endif
+}
+
+inline uint32x2_t p2ui_CONJ_XOR()
+{
+  static const uint32_t conj_XOR_DATA[] = { 0x00000000, 0x80000000 };
+  return vld1_u32( conj_XOR_DATA );
+}
+
+//---------- float ----------
+
+struct Packet1cf
+{
+  EIGEN_STRONG_INLINE Packet1cf() {}
+  EIGEN_STRONG_INLINE explicit Packet1cf(const Packet2f& a) : v(a) {}
+  Packet2f v;
+};
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {}
+  Packet4f v;
+};
+
+template<> struct packet_traits<std::complex<float> > : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet1cf half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasMul       = 1,
+    HasDiv       = 1,
+    HasNegate    = 1,
+    HasAbs       = 0,
+    HasAbs2      = 0,
+    HasMin       = 0,
+    HasMax       = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet1cf>
+{
+  typedef std::complex<float> type;
+  typedef Packet1cf half;
+  typedef Packet2f as_real;
+  enum
+  {
+    size = 1,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet2cf>
+{
+  typedef std::complex<float> type;
+  typedef Packet1cf half;
+  typedef Packet4f as_real;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet1cf pcast<float,Packet1cf>(const float& a)
+{ return Packet1cf(vset_lane_f32(a, vdup_n_f32(0.f), 0)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pcast<Packet2f,Packet2cf>(const Packet2f& a)
+{ return Packet2cf(vreinterpretq_f32_u64(vmovl_u32(vreinterpret_u32_f32(a)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pset1<Packet1cf>(const std::complex<float>& from)
+{ return Packet1cf(vld1_f32(reinterpret_cast<const float*>(&from))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>& from)
+{
+  const float32x2_t r64 = vld1_f32(reinterpret_cast<const float*>(&from));
+  return Packet2cf(vcombine_f32(r64, r64));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf padd<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(padd<Packet2f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(padd<Packet4f>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf psub<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(psub<Packet2f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(psub<Packet4f>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pnegate(const Packet1cf& a) { return Packet1cf(pnegate<Packet2f>(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate<Packet4f>(a.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pconj(const Packet1cf& a)
+{
+  const Packet2ui b = vreinterpret_u32_f32(a.v);
+  return Packet1cf(vreinterpret_f32_u32(veor_u32(b, p2ui_CONJ_XOR())));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a)
+{
+  const Packet4ui b = vreinterpretq_u32_f32(a.v);
+  return Packet2cf(vreinterpretq_f32_u32(veorq_u32(b, p4ui_CONJ_XOR())));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf pmul<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{
+  Packet2f v1, v2;
+
+  // Get the real values of a | a1_re | a1_re |
+  v1 = vdup_lane_f32(a.v, 0);
+  // Get the imag values of a | a1_im | a1_im |
+  v2 = vdup_lane_f32(a.v, 1);
+  // Multiply the real a with b
+  v1 = vmul_f32(v1, b.v);
+  // Multiply the imag a with b
+  v2 = vmul_f32(v2, b.v);
+  // Conjugate v2
+  v2 = vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(v2), p2ui_CONJ_XOR()));
+  // Swap real/imag elements in v2.
+  v2 = vrev64_f32(v2);
+  // Add and return the result
+  return Packet1cf(vadd_f32(v1, v2));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  Packet4f v1, v2;
+
+  // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
+  v1 = vcombine_f32(vdup_lane_f32(vget_low_f32(a.v), 0), vdup_lane_f32(vget_high_f32(a.v), 0));
+  // Get the imag values of a | a1_im | a1_im | a2_im | a2_im |
+  v2 = vcombine_f32(vdup_lane_f32(vget_low_f32(a.v), 1), vdup_lane_f32(vget_high_f32(a.v), 1));
+  // Multiply the real a with b
+  v1 = vmulq_f32(v1, b.v);
+  // Multiply the imag a with b
+  v2 = vmulq_f32(v2, b.v);
+  // Conjugate v2
+  v2 = vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(v2), p4ui_CONJ_XOR()));
+  // Swap real/imag elements in v2.
+  v2 = vrev64q_f32(v2);
+  // Add and return the result
+  return Packet2cf(vaddq_f32(v1, v2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf pcmp_eq(const Packet1cf& a, const Packet1cf& b)
+{
+  // Compare real and imaginary parts of a and b to get the mask vector:
+  // [re(a[0])==re(b[0]), im(a[0])==im(b[0])]
+  Packet2f eq = pcmp_eq<Packet2f>(a.v, b.v);
+  // Swap real/imag elements in the mask in to get:
+  // [im(a[0])==im(b[0]), re(a[0])==re(b[0])]
+  Packet2f eq_swapped = vrev64_f32(eq);
+  // Return re(a)==re(b) && im(a)==im(b) by computing bitwise AND of eq and eq_swapped
+  return Packet1cf(pand<Packet2f>(eq, eq_swapped));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b)
+{
+  // Compare real and imaginary parts of a and b to get the mask vector:
+  // [re(a[0])==re(b[0]), im(a[0])==im(b[0]), re(a[1])==re(b[1]), im(a[1])==im(b[1])]
+  Packet4f eq = pcmp_eq<Packet4f>(a.v, b.v);
+  // Swap real/imag elements in the mask in to get:
+  // [im(a[0])==im(b[0]), re(a[0])==re(b[0]), im(a[1])==im(b[1]), re(a[1])==re(b[1])]
+  Packet4f eq_swapped = vrev64q_f32(eq);
+  // Return re(a)==re(b) && im(a)==im(b) by computing bitwise AND of eq and eq_swapped
+  return Packet2cf(pand<Packet4f>(eq, eq_swapped));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf pand<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(vreinterpret_f32_u32(vand_u32(vreinterpret_u32_f32(a.v), vreinterpret_u32_f32(b.v)))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pand<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a.v), vreinterpretq_u32_f32(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf por<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(vreinterpret_f32_u32(vorr_u32(vreinterpret_u32_f32(a.v), vreinterpret_u32_f32(b.v)))); }
+template<> EIGEN_STRONG_INLINE Packet2cf por<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a.v), vreinterpretq_u32_f32(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pxor<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(a.v), vreinterpret_u32_f32(b.v)))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a.v), vreinterpretq_u32_f32(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pandnot<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{ return Packet1cf(vreinterpret_f32_u32(vbic_u32(vreinterpret_u32_f32(a.v), vreinterpret_u32_f32(b.v)))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{ return Packet2cf(vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a.v), vreinterpretq_u32_f32(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pload<Packet1cf>(const std::complex<float>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cf(pload<Packet2f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pload<Packet2cf>(const std::complex<float>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>(reinterpret_cast<const float*>(from))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf ploadu<Packet1cf>(const std::complex<float>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cf(ploadu<Packet2f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>(reinterpret_cast<const float*>(from))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf ploaddup<Packet1cf>(const std::complex<float>* from)
+{ return pset1<Packet1cf>(*from); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from)
+{ return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *to, const Packet1cf& from)
+{ EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *to, const Packet2cf& from)
+{ EIGEN_DEBUG_ALIGNED_STORE pstore(reinterpret_cast<float*>(to), from.v); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *to, const Packet1cf& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *to, const Packet2cf& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu(reinterpret_cast<float*>(to), from.v); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet1cf pgather<std::complex<float>, Packet1cf>(
+    const std::complex<float>* from, Index stride)
+{
+  const Packet2f tmp = vdup_n_f32(std::real(from[0*stride]));
+  return Packet1cf(vset_lane_f32(std::imag(from[0*stride]), tmp, 1));
+}
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(
+    const std::complex<float>* from, Index stride)
+{
+  Packet4f res = vdupq_n_f32(std::real(from[0*stride]));
+  res = vsetq_lane_f32(std::imag(from[0*stride]), res, 1);
+  res = vsetq_lane_f32(std::real(from[1*stride]), res, 2);
+  res = vsetq_lane_f32(std::imag(from[1*stride]), res, 3);
+  return Packet2cf(res);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet1cf>(
+    std::complex<float>* to, const Packet1cf& from, Index stride)
+{ to[stride*0] = std::complex<float>(vget_lane_f32(from.v, 0), vget_lane_f32(from.v, 1)); }
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(
+    std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  to[stride*0] = std::complex<float>(vgetq_lane_f32(from.v, 0), vgetq_lane_f32(from.v, 1));
+  to[stride*1] = std::complex<float>(vgetq_lane_f32(from.v, 2), vgetq_lane_f32(from.v, 3));
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> *addr)
+{ EIGEN_ARM_PREFETCH(reinterpret_cast<const float*>(addr)); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet1cf>(const Packet1cf& a)
+{
+  EIGEN_ALIGN16 std::complex<float> x;
+  vst1_f32(reinterpret_cast<float*>(&x), a.v);
+  return x;
+}
+template<> EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a)
+{
+  EIGEN_ALIGN16 std::complex<float> x[2];
+  vst1q_f32(reinterpret_cast<float*>(x), a.v);
+  return x[0];
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf preverse(const Packet1cf& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{ return Packet2cf(vcombine_f32(vget_high_f32(a.v), vget_low_f32(a.v))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cf pcplxflip<Packet1cf>(const Packet1cf& a)
+{ return Packet1cf(vrev64_f32(a.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& a)
+{ return Packet2cf(vrev64q_f32(a.v)); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet1cf>(const Packet1cf& a)
+{
+  std::complex<float> s;
+  vst1_f32((float *)&s, a.v);
+  return s;
+}
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> s;
+  vst1_f32(reinterpret_cast<float*>(&s), vadd_f32(vget_low_f32(a.v), vget_high_f32(a.v)));
+  return s;
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet1cf>(const Packet1cf& a)
+{
+  std::complex<float> s;
+  vst1_f32((float *)&s, a.v);
+  return s;
+}
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  float32x2_t a1, a2, v1, v2, prod;
+  std::complex<float> s;
+
+  a1 = vget_low_f32(a.v);
+  a2 = vget_high_f32(a.v);
+   // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
+  v1 = vdup_lane_f32(a1, 0);
+  // Get the real values of a | a1_im | a1_im | a2_im | a2_im |
+  v2 = vdup_lane_f32(a1, 1);
+  // Multiply the real a with b
+  v1 = vmul_f32(v1, a2);
+  // Multiply the imag a with b
+  v2 = vmul_f32(v2, a2);
+  // Conjugate v2
+  v2 = vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(v2), p2ui_CONJ_XOR()));
+  // Swap real/imag elements in v2.
+  v2 = vrev64_f32(v2);
+  // Add v1, v2
+  prod = vadd_f32(v1, v2);
+
+  vst1_f32(reinterpret_cast<float*>(&s), prod);
+
+  return s;
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cf,Packet2f)
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet1cf pdiv<Packet1cf>(const Packet1cf& a, const Packet1cf& b)
+{
+  // TODO optimize it for NEON
+  Packet1cf res = pmul(a, pconj(b));
+  Packet2f s, rev_s;
+
+  // this computes the norm
+  s = vmul_f32(b.v, b.v);
+  rev_s = vrev64_f32(s);
+
+  return Packet1cf(pdiv<Packet2f>(res.v, vadd_f32(s, rev_s)));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for NEON
+  Packet2cf res = pmul(a,pconj(b));
+  Packet4f s, rev_s;
+
+  // this computes the norm
+  s = vmulq_f32(b.v, b.v);
+  rev_s = vrev64q_f32(s);
+
+  return Packet2cf(pdiv<Packet4f>(res.v, vaddq_f32(s, rev_s)));
+}
+
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1cf, 1>& /*kernel*/) {}
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2cf, 2>& kernel)
+{
+  Packet4f tmp = vcombine_f32(vget_high_f32(kernel.packet[0].v), vget_high_f32(kernel.packet[1].v));
+  kernel.packet[0].v = vcombine_f32(vget_low_f32(kernel.packet[0].v), vget_low_f32(kernel.packet[1].v));
+  kernel.packet[1].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cf psqrt<Packet1cf>(const Packet1cf& a) {
+  return psqrt_complex<Packet1cf>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf psqrt<Packet2cf>(const Packet2cf& a) {
+  return psqrt_complex<Packet2cf>(a);
+}
+
+//---------- double ----------
+#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+
+// See bug 1325, clang fails to call vld1q_u64.
+#if EIGEN_COMP_CLANG || EIGEN_COMP_CASTXML
+  static uint64x2_t p2ul_CONJ_XOR = {0x0, 0x8000000000000000};
+#else
+  const uint64_t  p2ul_conj_XOR_DATA[] = { 0x0, 0x8000000000000000 };
+  static uint64x2_t p2ul_CONJ_XOR = vld1q_u64( p2ul_conj_XOR_DATA );
+#endif
+
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {}
+  Packet2d v;
+};
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet1cd>
+{
+  typedef std::complex<double> type;
+  typedef Packet1cd half;
+  typedef Packet2d as_real;
+  enum
+  {
+    size=1,
+    alignment=Aligned16,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet1cd pload<Packet1cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>(reinterpret_cast<const double*>(from))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>(reinterpret_cast<const double*>(from))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>& from)
+{
+  /* here we really have to use unaligned loads :( */
+  return ploadu<Packet1cd>(&from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(padd<Packet2d>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(psub<Packet2d>(a.v, b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a)
+{ return Packet1cd(pnegate<Packet2d>(a.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a)
+{ return Packet1cd(vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(a.v), p2ul_CONJ_XOR))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  Packet2d v1, v2;
+
+  // Get the real values of a
+  v1 = vdupq_lane_f64(vget_low_f64(a.v), 0);
+  // Get the imag values of a
+  v2 = vdupq_lane_f64(vget_high_f64(a.v), 0);
+  // Multiply the real a with b
+  v1 = vmulq_f64(v1, b.v);
+  // Multiply the imag a with b
+  v2 = vmulq_f64(v2, b.v);
+  // Conjugate v2
+  v2 = vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(v2), p2ul_CONJ_XOR));
+  // Swap real/imag elements in v2.
+  v2 = preverse<Packet2d>(v2);
+  // Add and return the result
+  return Packet1cd(vaddq_f64(v1, v2));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b)
+{
+  // Compare real and imaginary parts of a and b to get the mask vector:
+  // [re(a)==re(b), im(a)==im(b)]
+  Packet2d eq = pcmp_eq<Packet2d>(a.v, b.v);
+  // Swap real/imag elements in the mask in to get:
+  // [im(a)==im(b), re(a)==re(b)]
+  Packet2d eq_swapped = vreinterpretq_f64_u32(vrev64q_u32(vreinterpretq_u32_f64(eq)));
+  // Return re(a)==re(b) & im(a)==im(b) by computing bitwise AND of eq and eq_swapped
+  return Packet1cd(pand<Packet2d>(eq, eq_swapped));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pand<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd por<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pxor<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{ return Packet1cd(vreinterpretq_f64_u64(vbicq_u64(vreinterpretq_u64_f64(a.v),vreinterpretq_u64_f64(b.v)))); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from)
+{ return pset1<Packet1cd>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *to, const Packet1cd& from)
+{ EIGEN_DEBUG_ALIGNED_STORE pstore(reinterpret_cast<double*>(to), from.v); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *to, const Packet1cd& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE pstoreu(reinterpret_cast<double*>(to), from.v); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> *addr)
+{ EIGEN_ARM_PREFETCH(reinterpret_cast<const double*>(addr)); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(
+    const std::complex<double>* from, Index stride)
+{
+  Packet2d res = pset1<Packet2d>(0.0);
+  res = vsetq_lane_f64(std::real(from[0*stride]), res, 0);
+  res = vsetq_lane_f64(std::imag(from[0*stride]), res, 1);
+  return Packet1cd(res);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(
+    std::complex<double>* to, const Packet1cd& from, Index stride)
+{ to[stride*0] = std::complex<double>(vgetq_lane_f64(from.v, 0), vgetq_lane_f64(from.v, 1)); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet1cd>(const Packet1cd& a)
+{
+  EIGEN_ALIGN16 std::complex<double> res;
+  pstore<std::complex<double> >(&res, a);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) { return pfirst(a); }
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for NEON
+  Packet1cd res = pmul(a,pconj(b));
+  Packet2d s = pmul<Packet2d>(b.v, b.v);
+  Packet2d rev_s = preverse<Packet2d>(s);
+
+  return Packet1cd(pdiv(res.v, padd<Packet2d>(s,rev_s)));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
+{ return Packet1cd(preverse(Packet2d(x.v))); }
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd,2>& kernel)
+{
+  Packet2d tmp = vcombine_f64(vget_high_f64(kernel.packet[0].v), vget_high_f64(kernel.packet[1].v));
+  kernel.packet[0].v = vcombine_f64(vget_low_f64(kernel.packet[0].v), vget_low_f64(kernel.packet[1].v));
+  kernel.packet[1].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd psqrt<Packet1cd>(const Packet1cd& a) {
+  return psqrt_complex<Packet1cd>(a);
+}
+
+#endif // EIGEN_ARCH_ARM64
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_NEON_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
new file mode 100644
index 00000000..3481f337
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
@@ -0,0 +1,183 @@
+namespace Eigen {
+namespace internal {
+  
+#if EIGEN_ARCH_ARM && EIGEN_COMP_CLANG
+
+// Clang seems to excessively spill registers in the GEBP kernel on 32-bit arm.
+// Here we specialize gebp_traits to eliminate these register spills.
+// See #2138.
+template<>
+struct gebp_traits <float,float,false,false,Architecture::NEON,GEBPPacketFull>
+ : gebp_traits<float,float,false,false,Architecture::Generic,GEBPPacketFull>
+{
+  EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha, ResPacket& r) const
+  { 
+    // This volatile inline ASM both acts as a barrier to prevent reordering,
+    // as well as enforces strict register use.
+    asm volatile(
+      "vmla.f32 %q[r], %q[c], %q[alpha]"
+      : [r] "+w" (r)
+      : [c] "w" (c),
+        [alpha] "w" (alpha)
+      : );
+  }
+
+  template <typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const Packet4f& a, const Packet4f& b,
+                                Packet4f& c, Packet4f& tmp,
+                                const LaneIdType&) const {
+    acc(a, b, c);
+  }
+  
+  template <typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const Packet4f& a, const QuadPacket<Packet4f>& b,
+                                Packet4f& c, Packet4f& tmp,
+                                const LaneIdType& lane) const {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+};
+
+#endif // EIGEN_ARCH_ARM && EIGEN_COMP_CLANG
+
+#if EIGEN_ARCH_ARM64
+
+template<>
+struct gebp_traits <float,float,false,false,Architecture::NEON,GEBPPacketFull>
+ : gebp_traits<float,float,false,false,Architecture::Generic,GEBPPacketFull>
+{
+  typedef float RhsPacket;
+  typedef float32x4_t RhsPacketx4;
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = *b;
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    dest = vld1q_f32(b);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = *b;
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
+  {}
+
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    loadRhs(b,dest);
+  }
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<0>&) const
+  {
+    c = vfmaq_n_f32(c, a, b);
+  }
+
+  // NOTE: Template parameter inference failed when compiled with Android NDK:
+  // "candidate template ignored: could not match 'FixedInt<N>' against 'Eigen::internal::FixedInt<0>".
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<0>&) const
+  { madd_helper<0>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<1>&) const
+  { madd_helper<1>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<2>&) const
+  { madd_helper<2>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<3>&) const
+  { madd_helper<3>(a, b, c); }
+
+ private:
+  template<int LaneID>
+  EIGEN_STRONG_INLINE void madd_helper(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c) const
+  {
+    #if EIGEN_COMP_GNUC_STRICT && !(EIGEN_GNUC_AT_LEAST(9,0))
+    // workaround gcc issue https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89101
+    // vfmaq_laneq_f32 is implemented through a costly dup
+         if(LaneID==0)  asm("fmla %0.4s, %1.4s, %2.s[0]\n" : "+w" (c) : "w" (a), "w" (b) :  );
+    else if(LaneID==1)  asm("fmla %0.4s, %1.4s, %2.s[1]\n" : "+w" (c) : "w" (a), "w" (b) :  );
+    else if(LaneID==2)  asm("fmla %0.4s, %1.4s, %2.s[2]\n" : "+w" (c) : "w" (a), "w" (b) :  );
+    else if(LaneID==3)  asm("fmla %0.4s, %1.4s, %2.s[3]\n" : "+w" (c) : "w" (a), "w" (b) :  );
+    #else
+    c = vfmaq_laneq_f32(c, a, b, LaneID);
+    #endif
+  }
+};
+
+
+template<>
+struct gebp_traits <double,double,false,false,Architecture::NEON>
+ : gebp_traits<double,double,false,false,Architecture::Generic>
+{
+  typedef double RhsPacket;
+
+  struct RhsPacketx4 {
+    float64x2_t B_0, B_1;
+  };
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = *b;
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    dest.B_0 = vld1q_f64(b);
+    dest.B_1 = vld1q_f64(b+2);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacket& dest) const
+  {
+    loadRhs(b,dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
+  {}
+
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    loadRhs(b,dest);
+  }
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<0>&) const
+  {
+    c = vfmaq_n_f64(c, a, b);
+  }
+
+  // NOTE: Template parameter inference failed when compiled with Android NDK:
+  // "candidate template ignored: could not match 'FixedInt<N>' against 'Eigen::internal::FixedInt<0>".
+
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<0>&) const
+  { madd_helper<0>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<1>&) const
+  { madd_helper<1>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<2>&) const
+  { madd_helper<2>(a, b, c); }
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c, RhsPacket& /*tmp*/, const FixedInt<3>&) const
+  { madd_helper<3>(a, b, c); }
+
+ private:
+  template <int LaneID>
+  EIGEN_STRONG_INLINE void madd_helper(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c) const
+  {
+    #if EIGEN_COMP_GNUC_STRICT && !(EIGEN_GNUC_AT_LEAST(9,0))
+    // workaround gcc issue https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89101
+    // vfmaq_laneq_f64 is implemented through a costly dup
+         if(LaneID==0)  asm("fmla %0.2d, %1.2d, %2.d[0]\n" : "+w" (c) : "w" (a), "w" (b.B_0) :  );
+    else if(LaneID==1)  asm("fmla %0.2d, %1.2d, %2.d[1]\n" : "+w" (c) : "w" (a), "w" (b.B_0) :  );
+    else if(LaneID==2)  asm("fmla %0.2d, %1.2d, %2.d[0]\n" : "+w" (c) : "w" (a), "w" (b.B_1) :  );
+    else if(LaneID==3)  asm("fmla %0.2d, %1.2d, %2.d[1]\n" : "+w" (c) : "w" (a), "w" (b.B_1) :  );
+    #else
+         if(LaneID==0) c = vfmaq_laneq_f64(c, a, b.B_0, 0);
+    else if(LaneID==1) c = vfmaq_laneq_f64(c, a, b.B_0, 1);
+    else if(LaneID==2) c = vfmaq_laneq_f64(c, a, b.B_1, 0);
+    else if(LaneID==3) c = vfmaq_laneq_f64(c, a, b.B_1, 1);
+    #endif
+  }
+};
+
+#endif // EIGEN_ARCH_ARM64
+
+}  // namespace internal
+}  // namespace Eigen
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/MathFunctions.h
new file mode 100644
index 00000000..fa6615a8
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/MathFunctions.h
@@ -0,0 +1,75 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_NEON_H
+#define EIGEN_MATH_FUNCTIONS_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f pexp<Packet2f>(const Packet2f& x)
+{ return pexp_float(x); }
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f pexp<Packet4f>(const Packet4f& x)
+{ return pexp_float(x); }
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f plog<Packet2f>(const Packet2f& x)
+{ return plog_float(x); }
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f plog<Packet4f>(const Packet4f& x)
+{ return plog_float(x); }
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f psin<Packet2f>(const Packet2f& x)
+{ return psin_float(x); }
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f psin<Packet4f>(const Packet4f& x)
+{ return psin_float(x); }
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f pcos<Packet2f>(const Packet2f& x)
+{ return pcos_float(x); }
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f pcos<Packet4f>(const Packet4f& x)
+{ return pcos_float(x); }
+
+// Hyperbolic Tangent function.
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2f ptanh<Packet2f>(const Packet2f& x)
+{ return internal::generic_fast_tanh_float(x); }
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f ptanh<Packet4f>(const Packet4f& x)
+{ return internal::generic_fast_tanh_float(x); }
+
+BF16_PACKET_FUNCTION(Packet4f, Packet4bf, psin)
+BF16_PACKET_FUNCTION(Packet4f, Packet4bf, pcos)
+BF16_PACKET_FUNCTION(Packet4f, Packet4bf, plog)
+BF16_PACKET_FUNCTION(Packet4f, Packet4bf, pexp)
+BF16_PACKET_FUNCTION(Packet4f, Packet4bf, ptanh)
+
+template <>
+EIGEN_STRONG_INLINE Packet4bf pfrexp(const Packet4bf& a, Packet4bf& exponent) {
+  Packet4f fexponent;
+  const Packet4bf out = F32ToBf16(pfrexp<Packet4f>(Bf16ToF32(a), fexponent));
+  exponent = F32ToBf16(fexponent);
+  return out;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4bf pldexp(const Packet4bf& a, const Packet4bf& exponent) {
+  return F32ToBf16(pldexp<Packet4f>(Bf16ToF32(a), Bf16ToF32(exponent)));
+}
+
+//---------- double ----------
+
+#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d pexp<Packet2d>(const Packet2d& x)
+{ return pexp_double(x); }
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet2d plog<Packet2d>(const Packet2d& x)
+{ return plog_double(x); }
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATH_FUNCTIONS_NEON_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/PacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/PacketMath.h
new file mode 100644
index 00000000..d2aeef43
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/PacketMath.h
@@ -0,0 +1,4587 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Konstantinos Margaritis <markos@freevec.org>
+// Heavily based on Gael's SSE version.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_NEON_H
+#define EIGEN_PACKET_MATH_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#if EIGEN_ARCH_ARM64
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
+#else
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 16
+#endif
+#endif
+
+#if EIGEN_COMP_MSVC_STRICT
+
+// In MSVC's arm_neon.h header file, all NEON vector types
+// are aliases to the same underlying type __n128.
+// We thus have to wrap them to make them different C++ types.
+// (See also bug 1428)
+typedef eigen_packet_wrapper<float32x2_t,0>  Packet2f;
+typedef eigen_packet_wrapper<float32x4_t,1>  Packet4f;
+typedef eigen_packet_wrapper<int32_t    ,2>  Packet4c;
+typedef eigen_packet_wrapper<int8x8_t   ,3>  Packet8c;
+typedef eigen_packet_wrapper<int8x16_t  ,4>  Packet16c;
+typedef eigen_packet_wrapper<uint32_t   ,5>  Packet4uc;
+typedef eigen_packet_wrapper<uint8x8_t  ,6>  Packet8uc;
+typedef eigen_packet_wrapper<uint8x16_t ,7>  Packet16uc;
+typedef eigen_packet_wrapper<int16x4_t  ,8>  Packet4s;
+typedef eigen_packet_wrapper<int16x8_t  ,9>  Packet8s;
+typedef eigen_packet_wrapper<uint16x4_t ,10> Packet4us;
+typedef eigen_packet_wrapper<uint16x8_t ,11> Packet8us;
+typedef eigen_packet_wrapper<int32x2_t  ,12> Packet2i;
+typedef eigen_packet_wrapper<int32x4_t  ,13> Packet4i;
+typedef eigen_packet_wrapper<uint32x2_t ,14> Packet2ui;
+typedef eigen_packet_wrapper<uint32x4_t ,15> Packet4ui;
+typedef eigen_packet_wrapper<int64x2_t  ,16> Packet2l;
+typedef eigen_packet_wrapper<uint64x2_t ,17> Packet2ul;
+
+#else
+
+typedef float32x2_t                          Packet2f;
+typedef float32x4_t                          Packet4f;
+typedef eigen_packet_wrapper<int32_t    ,2>  Packet4c;
+typedef int8x8_t                             Packet8c;
+typedef int8x16_t                            Packet16c;
+typedef eigen_packet_wrapper<uint32_t   ,5>  Packet4uc;
+typedef uint8x8_t                            Packet8uc;
+typedef uint8x16_t                           Packet16uc;
+typedef int16x4_t                            Packet4s;
+typedef int16x8_t                            Packet8s;
+typedef uint16x4_t                           Packet4us;
+typedef uint16x8_t                           Packet8us;
+typedef int32x2_t                            Packet2i;
+typedef int32x4_t                            Packet4i;
+typedef uint32x2_t                           Packet2ui;
+typedef uint32x4_t                           Packet4ui;
+typedef int64x2_t                            Packet2l;
+typedef uint64x2_t                           Packet2ul;
+
+#endif // EIGEN_COMP_MSVC_STRICT
+
+EIGEN_STRONG_INLINE Packet4f shuffle1(const Packet4f& m, int mask){
+  const float* a = reinterpret_cast<const float*>(&m);
+  Packet4f res = {*(a + (mask & 3)), *(a + ((mask >> 2) & 3)), *(a + ((mask >> 4) & 3 )), *(a + ((mask >> 6) & 3))};
+  return res;
+}
+
+// fuctionally equivalent to _mm_shuffle_ps in SSE when interleave
+// == false (i.e. shuffle<false>(m, n, mask) equals _mm_shuffle_ps(m, n, mask)),
+// interleave m and n when interleave == true. Currently used in LU/arch/InverseSize4.h
+// to enable a shared implementation for fast inversion of matrices of size 4. 
+template<bool interleave> 
+EIGEN_STRONG_INLINE Packet4f shuffle2(const Packet4f &m, const Packet4f &n, int mask)
+{
+  const float* a = reinterpret_cast<const float*>(&m);
+  const float* b = reinterpret_cast<const float*>(&n);
+  Packet4f res = {*(a + (mask & 3)), *(a + ((mask >> 2) & 3)), *(b + ((mask >> 4) & 3)), *(b + ((mask >> 6) & 3))};
+  return res;
+}
+
+template<> 
+EIGEN_STRONG_INLINE Packet4f shuffle2<true>(const Packet4f &m, const Packet4f &n, int mask) 
+{
+  const float* a = reinterpret_cast<const float*>(&m);
+  const float* b = reinterpret_cast<const float*>(&n);
+  Packet4f res = {*(a + (mask & 3)), *(b + ((mask >> 2) & 3)), *(a + ((mask >> 4) & 3)), *(b + ((mask >> 6) & 3))};
+  return res;
+}
+
+EIGEN_STRONG_INLINE static int eigen_neon_shuffle_mask(int p, int q, int r, int s) {return ((s)<<6|(r)<<4|(q)<<2|(p));}
+
+EIGEN_STRONG_INLINE Packet4f vec4f_swizzle1(const Packet4f& a, int p, int q, int r, int s)
+{ 
+  return shuffle1(a, eigen_neon_shuffle_mask(p, q, r, s));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_swizzle2(const Packet4f& a, const Packet4f& b, int p, int q, int r, int s)
+{ 
+  return shuffle2<false>(a,b,eigen_neon_shuffle_mask(p, q, r, s));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_movelh(const Packet4f& a, const Packet4f& b)
+{
+  return shuffle2<false>(a,b,eigen_neon_shuffle_mask(0, 1, 0, 1));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_movehl(const Packet4f& a, const Packet4f& b)
+{
+  return shuffle2<false>(b,a,eigen_neon_shuffle_mask(2, 3, 2, 3));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_unpacklo(const Packet4f& a, const Packet4f& b)
+{
+  return shuffle2<true>(a,b,eigen_neon_shuffle_mask(0, 0, 1, 1));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_unpackhi(const Packet4f& a, const Packet4f& b)
+{
+  return shuffle2<true>(a,b,eigen_neon_shuffle_mask(2, 2, 3, 3));
+}
+#define vec4f_duplane(a, p) \
+  vdupq_lane_f32(vget_low_f32(a), p)
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  const Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1<int32_t>(X))
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  const Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+#if EIGEN_ARCH_ARM64
+  // __builtin_prefetch tends to do nothing on ARM64 compilers because the
+  // prefetch instructions there are too detailed for __builtin_prefetch to map
+  // meaningfully to them.
+  #define EIGEN_ARM_PREFETCH(ADDR)  __asm__ __volatile__("prfm pldl1keep, [%[addr]]\n" ::[addr] "r"(ADDR) : );
+#elif EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  #define EIGEN_ARM_PREFETCH(ADDR) __builtin_prefetch(ADDR);
+#elif defined __pld
+  #define EIGEN_ARM_PREFETCH(ADDR) __pld(ADDR)
+#elif EIGEN_ARCH_ARM32
+  #define EIGEN_ARM_PREFETCH(ADDR) __asm__ __volatile__ ("pld [%[addr]]\n" :: [addr] "r" (ADDR) : );
+#else
+  // by default no explicit prefetching
+  #define EIGEN_ARM_PREFETCH(ADDR)
+#endif
+
+template <>
+struct packet_traits<float> : default_packet_traits
+{
+  typedef Packet4f type;
+  typedef Packet2f half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+
+    HasDiv   = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+
+    HasSin  = EIGEN_FAST_MATH,
+    HasCos  = EIGEN_FAST_MATH,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf  = EIGEN_FAST_MATH,
+    HasBessel = 0,  // Issues with accuracy.
+    HasNdtri = 0
+  };
+};
+
+template <>
+struct packet_traits<int8_t> : default_packet_traits
+{
+  typedef Packet16c type;
+  typedef Packet8c half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasAbsDiff   = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0
+  };
+};
+
+template <>
+struct packet_traits<uint8_t> : default_packet_traits
+{
+  typedef Packet16uc type;
+  typedef Packet8uc half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 16,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 0,
+    HasAbs       = 1,
+    HasAbsDiff   = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+
+    HasSqrt = 1
+  };
+};
+
+template <>
+struct packet_traits<int16_t> : default_packet_traits
+{
+  typedef Packet8s type;
+  typedef Packet4s half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasAbsDiff   = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0
+  };
+};
+
+template <>
+struct packet_traits<uint16_t> : default_packet_traits
+{
+  typedef Packet8us type;
+  typedef Packet4us half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 0,
+    HasAbs       = 0,
+    HasAbsDiff   = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+    HasSqrt = 1
+  };
+};
+
+template <>
+struct packet_traits<int32_t> : default_packet_traits
+{
+  typedef Packet4i type;
+  typedef Packet2i half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0
+  };
+};
+
+template <>
+struct packet_traits<uint32_t> : default_packet_traits
+{
+  typedef Packet4ui type;
+  typedef Packet2ui half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 1,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 0,
+    HasAbs       = 0,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+
+    HasSqrt = 1
+  };
+};
+
+template <>
+struct packet_traits<int64_t> : default_packet_traits
+{
+  typedef Packet2l type;
+  typedef Packet2l half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasCmp       = 1,
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0
+  };
+};
+
+template <>
+struct packet_traits<uint64_t> : default_packet_traits
+{
+  typedef Packet2ul type;
+  typedef Packet2ul half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasCmp       = 1,
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 0,
+    HasAbs       = 0,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0
+  };
+};
+
+#if EIGEN_GNUC_AT_MOST(4, 4) && !EIGEN_COMP_LLVM
+// workaround gcc 4.2, 4.3 and 4.4 compilation issue
+EIGEN_STRONG_INLINE float32x4_t vld1q_f32(const float* x) { return ::vld1q_f32((const float32_t*)x); }
+EIGEN_STRONG_INLINE float32x2_t vld1_f32(const float* x) { return ::vld1_f32 ((const float32_t*)x); }
+EIGEN_STRONG_INLINE float32x2_t vld1_dup_f32(const float* x) { return ::vld1_dup_f32 ((const float32_t*)x); }
+EIGEN_STRONG_INLINE void vst1q_f32(float* to, float32x4_t from) { ::vst1q_f32((float32_t*)to,from); }
+EIGEN_STRONG_INLINE void vst1_f32 (float* to, float32x2_t from) { ::vst1_f32 ((float32_t*)to,from); }
+#endif
+
+template<> struct unpacket_traits<Packet2f>
+{
+  typedef float type;
+  typedef Packet2f half;
+  typedef Packet2i integer_packet;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4f>
+{
+  typedef float type;
+  typedef Packet2f half;
+  typedef Packet4i integer_packet;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4c>
+{
+  typedef int8_t type;
+  typedef Packet4c half;
+  enum
+  {
+    size = 4,
+    alignment = Unaligned,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet8c>
+{
+  typedef int8_t type;
+  typedef Packet4c half;
+  enum
+  {
+    size = 8,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet16c>
+{
+  typedef int8_t type;
+  typedef Packet8c half;
+  enum
+  {
+    size = 16,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4uc>
+{
+  typedef uint8_t type;
+  typedef Packet4uc half;
+  enum
+  {
+    size = 4,
+    alignment = Unaligned,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet8uc>
+{
+  typedef uint8_t type;
+  typedef Packet4uc half;
+  enum
+  {
+    size = 8,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet16uc>
+{
+  typedef uint8_t type;
+  typedef Packet8uc half;
+  enum
+  {
+    size = 16,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false};
+};
+template<> struct unpacket_traits<Packet4s>
+{
+  typedef int16_t type;
+  typedef Packet4s half;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet8s>
+{
+  typedef int16_t type;
+  typedef Packet4s half;
+  enum
+  {
+    size = 8,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4us>
+{
+  typedef uint16_t type;
+  typedef Packet4us half;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet8us>
+{
+  typedef uint16_t type;
+  typedef Packet4us half;
+  enum
+  {
+    size = 8,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet2i>
+{
+  typedef int32_t type;
+  typedef Packet2i half;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4i>
+{
+  typedef int32_t type;
+  typedef Packet2i half;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet2ui>
+{
+  typedef uint32_t type;
+  typedef Packet2ui half;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet4ui>
+{
+  typedef uint32_t type;
+  typedef Packet2ui half;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet2l>
+{
+  typedef int64_t type;
+  typedef Packet2l half;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+template<> struct unpacket_traits<Packet2ul>
+{
+  typedef uint64_t type;
+  typedef Packet2ul half;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet2f pset1<Packet2f>(const float& from) { return vdup_n_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) { return vdupq_n_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4c pset1<Packet4c>(const int8_t& from)
+{ return vget_lane_s32(vreinterpret_s32_s8(vdup_n_s8(from)), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c pset1<Packet8c>(const int8_t& from) { return vdup_n_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet16c pset1<Packet16c>(const int8_t& from) { return vdupq_n_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet4uc pset1<Packet4uc>(const uint8_t& from)
+{ return vget_lane_u32(vreinterpret_u32_u8(vdup_n_u8(from)), 0); }
+template<> EIGEN_STRONG_INLINE Packet8uc pset1<Packet8uc>(const uint8_t& from) { return vdup_n_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet16uc pset1<Packet16uc>(const uint8_t& from) { return vdupq_n_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet4s pset1<Packet4s>(const int16_t& from) { return vdup_n_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet8s pset1<Packet8s>(const int16_t& from) { return vdupq_n_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet4us pset1<Packet4us>(const uint16_t& from) { return vdup_n_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet8us pset1<Packet8us>(const uint16_t& from) { return vdupq_n_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet2i pset1<Packet2i>(const int32_t& from) { return vdup_n_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int32_t& from) { return vdupq_n_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet2ui pset1<Packet2ui>(const uint32_t& from) { return vdup_n_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet4ui pset1<Packet4ui>(const uint32_t& from) { return vdupq_n_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet2l pset1<Packet2l>(const int64_t& from) { return vdupq_n_s64(from); }
+template<> EIGEN_STRONG_INLINE Packet2ul pset1<Packet2ul>(const uint64_t& from) { return vdupq_n_u64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pset1frombits<Packet2f>(unsigned int from)
+{ return vreinterpret_f32_u32(vdup_n_u32(from)); }
+template<> EIGEN_STRONG_INLINE Packet4f pset1frombits<Packet4f>(unsigned int from)
+{ return vreinterpretq_f32_u32(vdupq_n_u32(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet2f plset<Packet2f>(const float& a)
+{
+  const float c[] = {0.0f,1.0f};
+  return vadd_f32(pset1<Packet2f>(a), vld1_f32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a)
+{
+  const float c[] = {0.0f,1.0f,2.0f,3.0f};
+  return vaddq_f32(pset1<Packet4f>(a), vld1q_f32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4c plset<Packet4c>(const int8_t& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vadd_s8(vreinterpret_s8_u32(vdup_n_u32(0x03020100)), vdup_n_s8(a))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c plset<Packet8c>(const int8_t& a)
+{
+  const int8_t c[] = {0,1,2,3,4,5,6,7};
+  return vadd_s8(pset1<Packet8c>(a), vld1_s8(c));
+}
+template<> EIGEN_STRONG_INLINE Packet16c plset<Packet16c>(const int8_t& a)
+{
+  const int8_t c[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+  return vaddq_s8(pset1<Packet16c>(a), vld1q_s8(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4uc plset<Packet4uc>(const uint8_t& a)
+{ return vget_lane_u32(vreinterpret_u32_u8(vadd_u8(vreinterpret_u8_u32(vdup_n_u32(0x03020100)), vdup_n_u8(a))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8uc plset<Packet8uc>(const uint8_t& a)
+{
+  const uint8_t c[] = {0,1,2,3,4,5,6,7};
+  return vadd_u8(pset1<Packet8uc>(a), vld1_u8(c));
+}
+template<> EIGEN_STRONG_INLINE Packet16uc plset<Packet16uc>(const uint8_t& a)
+{
+  const uint8_t c[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+  return vaddq_u8(pset1<Packet16uc>(a), vld1q_u8(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4s plset<Packet4s>(const int16_t& a)
+{
+  const int16_t c[] = {0,1,2,3};
+  return vadd_s16(pset1<Packet4s>(a), vld1_s16(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4us plset<Packet4us>(const uint16_t& a)
+{
+  const uint16_t c[] = {0,1,2,3};
+  return vadd_u16(pset1<Packet4us>(a), vld1_u16(c));
+}
+template<> EIGEN_STRONG_INLINE Packet8s plset<Packet8s>(const int16_t& a)
+{
+  const int16_t c[] = {0,1,2,3,4,5,6,7};
+  return vaddq_s16(pset1<Packet8s>(a), vld1q_s16(c));
+}
+template<> EIGEN_STRONG_INLINE Packet8us plset<Packet8us>(const uint16_t& a)
+{
+  const uint16_t c[] = {0,1,2,3,4,5,6,7};
+  return vaddq_u16(pset1<Packet8us>(a), vld1q_u16(c));
+}
+template<> EIGEN_STRONG_INLINE Packet2i plset<Packet2i>(const int32_t& a)
+{
+  const int32_t c[] = {0,1};
+  return vadd_s32(pset1<Packet2i>(a), vld1_s32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int32_t& a)
+{
+  const int32_t c[] = {0,1,2,3};
+  return vaddq_s32(pset1<Packet4i>(a), vld1q_s32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet2ui plset<Packet2ui>(const uint32_t& a)
+{
+  const uint32_t c[] = {0,1};
+  return vadd_u32(pset1<Packet2ui>(a), vld1_u32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet4ui plset<Packet4ui>(const uint32_t& a)
+{
+  const uint32_t c[] = {0,1,2,3};
+  return vaddq_u32(pset1<Packet4ui>(a), vld1q_u32(c));
+}
+template<> EIGEN_STRONG_INLINE Packet2l plset<Packet2l>(const int64_t& a)
+{
+  const int64_t c[] = {0,1};
+  return vaddq_s64(pset1<Packet2l>(a), vld1q_s64(c));
+}
+template<> EIGEN_STRONG_INLINE Packet2ul plset<Packet2ul>(const uint64_t& a)
+{
+  const uint64_t c[] = {0,1};
+  return vaddq_u64(pset1<Packet2ul>(a), vld1q_u64(c));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f padd<Packet2f>(const Packet2f& a, const Packet2f& b) { return vadd_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return vaddq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4c padd<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vadd_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c padd<Packet8c>(const Packet8c& a, const Packet8c& b) { return vadd_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c padd<Packet16c>(const Packet16c& a, const Packet16c& b) { return vaddq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc padd<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vadd_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc padd<Packet8uc>(const Packet8uc& a, const Packet8uc& b) { return vadd_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc padd<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vaddq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s padd<Packet4s>(const Packet4s& a, const Packet4s& b) { return vadd_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s padd<Packet8s>(const Packet8s& a, const Packet8s& b) { return vaddq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us padd<Packet4us>(const Packet4us& a, const Packet4us& b) { return vadd_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us padd<Packet8us>(const Packet8us& a, const Packet8us& b) { return vaddq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i padd<Packet2i>(const Packet2i& a, const Packet2i& b) { return vadd_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return vaddq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui padd<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vadd_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui padd<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vaddq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l padd<Packet2l>(const Packet2l& a, const Packet2l& b) { return vaddq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul padd<Packet2ul>(const Packet2ul& a, const Packet2ul& b) { return vaddq_u64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f psub<Packet2f>(const Packet2f& a, const Packet2f& b) { return vsub_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return vsubq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4c psub<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vsub_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c psub<Packet8c>(const Packet8c& a, const Packet8c& b) { return vsub_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c psub<Packet16c>(const Packet16c& a, const Packet16c& b) { return vsubq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc psub<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vsub_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc psub<Packet8uc>(const Packet8uc& a, const Packet8uc& b) { return vsub_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc psub<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vsubq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s psub<Packet4s>(const Packet4s& a, const Packet4s& b) { return vsub_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s psub<Packet8s>(const Packet8s& a, const Packet8s& b) { return vsubq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us psub<Packet4us>(const Packet4us& a, const Packet4us& b) { return vsub_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us psub<Packet8us>(const Packet8us& a, const Packet8us& b) { return vsubq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i psub<Packet2i>(const Packet2i& a, const Packet2i& b) { return vsub_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return vsubq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui psub<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vsub_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui psub<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vsubq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l psub<Packet2l>(const Packet2l& a, const Packet2l& b) { return vsubq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul psub<Packet2ul>(const Packet2ul& a, const Packet2ul& b) { return vsubq_u64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pxor<Packet2f>(const Packet2f& a, const Packet2f& b);
+template<> EIGEN_STRONG_INLINE Packet2f paddsub<Packet2f>(const Packet2f& a, const Packet2f & b) {
+  Packet2f mask = {numext::bit_cast<float>(0x80000000u), 0.0f};
+  return padd(a, pxor(mask, b));
+}
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b);
+template<> EIGEN_STRONG_INLINE Packet4f paddsub<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  Packet4f mask = {numext::bit_cast<float>(0x80000000u), 0.0f, numext::bit_cast<float>(0x80000000u), 0.0f};
+  return padd(a, pxor(mask, b));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pnegate(const Packet2f& a) { return vneg_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return vnegq_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4c pnegate(const Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vneg_s8(vreinterpret_s8_s32(vdup_n_s32(a)))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c pnegate(const Packet8c& a) { return vneg_s8(a); }
+template<> EIGEN_STRONG_INLINE Packet16c pnegate(const Packet16c& a) { return vnegq_s8(a); }
+template<> EIGEN_STRONG_INLINE Packet4s pnegate(const Packet4s& a) { return vneg_s16(a); }
+template<> EIGEN_STRONG_INLINE Packet8s pnegate(const Packet8s& a) { return vnegq_s16(a); }
+template<> EIGEN_STRONG_INLINE Packet2i pnegate(const Packet2i& a) { return vneg_s32(a); }
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return vnegq_s32(a); }
+template<> EIGEN_STRONG_INLINE Packet2l pnegate(const Packet2l& a) {
+#if EIGEN_ARCH_ARM64
+  return vnegq_s64(a);
+#else
+  return vcombine_s64(
+      vdup_n_s64(-vgetq_lane_s64(a, 0)),
+      vdup_n_s64(-vgetq_lane_s64(a, 1)));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pconj(const Packet2f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4c pconj(const Packet4c& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8c pconj(const Packet8c& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet16c pconj(const Packet16c& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4uc pconj(const Packet4uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8uc pconj(const Packet8uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet16uc pconj(const Packet16uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4s pconj(const Packet4s& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8s pconj(const Packet8s& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4us pconj(const Packet4us& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8us pconj(const Packet8us& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2i pconj(const Packet2i& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2ui pconj(const Packet2ui& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4ui pconj(const Packet4ui& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2l pconj(const Packet2l& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2ul pconj(const Packet2ul& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet2f pmul<Packet2f>(const Packet2f& a, const Packet2f& b) { return vmul_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmulq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4c pmul<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vmul_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pmul<Packet8c>(const Packet8c& a, const Packet8c& b) { return vmul_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmul<Packet16c>(const Packet16c& a, const Packet16c& b) { return vmulq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pmul<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vmul_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pmul<Packet8uc>(const Packet8uc& a, const Packet8uc& b) { return vmul_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmul<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vmulq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pmul<Packet4s>(const Packet4s& a, const Packet4s& b) { return vmul_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmul<Packet8s>(const Packet8s& a, const Packet8s& b) { return vmulq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pmul<Packet4us>(const Packet4us& a, const Packet4us& b) { return vmul_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmul<Packet8us>(const Packet8us& a, const Packet8us& b) { return vmulq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pmul<Packet2i>(const Packet2i& a, const Packet2i& b) { return vmul_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmulq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pmul<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vmul_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pmul<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vmulq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pmul<Packet2l>(const Packet2l& a, const Packet2l& b) {
+  return vcombine_s64(
+    vdup_n_s64(vgetq_lane_s64(a, 0)*vgetq_lane_s64(b, 0)),
+    vdup_n_s64(vgetq_lane_s64(a, 1)*vgetq_lane_s64(b, 1)));
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pmul<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
+  return vcombine_u64(
+    vdup_n_u64(vgetq_lane_u64(a, 0)*vgetq_lane_u64(b, 0)),
+    vdup_n_u64(vgetq_lane_u64(a, 1)*vgetq_lane_u64(b, 1)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pdiv<Packet2f>(const Packet2f& a, const Packet2f& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vdiv_f32(a,b);
+#else
+  Packet2f inv, restep, div;
+
+  // NEON does not offer a divide instruction, we have to do a reciprocal approximation
+  // However NEON in contrast to other SIMD engines (AltiVec/SSE), offers
+  // a reciprocal estimate AND a reciprocal step -which saves a few instructions
+  // vrecpeq_f32() returns an estimate to 1/b, which we will finetune with
+  // Newton-Raphson and vrecpsq_f32()
+  inv = vrecpe_f32(b);
+
+  // This returns a differential, by which we will have to multiply inv to get a better
+  // approximation of 1/b.
+  restep = vrecps_f32(b, inv);
+  inv = vmul_f32(restep, inv);
+
+  // Finally, multiply a by 1/b and get the wanted result of the division.
+  div = vmul_f32(a, inv);
+
+  return div;
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vdivq_f32(a,b);
+#else
+  Packet4f inv, restep, div;
+
+  // NEON does not offer a divide instruction, we have to do a reciprocal approximation
+  // However NEON in contrast to other SIMD engines (AltiVec/SSE), offers
+  // a reciprocal estimate AND a reciprocal step -which saves a few instructions
+  // vrecpeq_f32() returns an estimate to 1/b, which we will finetune with
+  // Newton-Raphson and vrecpsq_f32()
+  inv = vrecpeq_f32(b);
+
+  // This returns a differential, by which we will have to multiply inv to get a better
+  // approximation of 1/b.
+  restep = vrecpsq_f32(b, inv);
+  inv = vmulq_f32(restep, inv);
+
+  // Finally, multiply a by 1/b and get the wanted result of the division.
+  div = vmulq_f32(a, inv);
+
+  return div;
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4c pdiv<Packet4c>(const Packet4c& /*a*/, const Packet4c& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4c>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pdiv<Packet8c>(const Packet8c& /*a*/, const Packet8c& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet8c>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet16c pdiv<Packet16c>(const Packet16c& /*a*/, const Packet16c& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet16c>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet4uc pdiv<Packet4uc>(const Packet4uc& /*a*/, const Packet4uc& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4uc>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pdiv<Packet8uc>(const Packet8uc& /*a*/, const Packet8uc& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet8uc>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet16uc pdiv<Packet16uc>(const Packet16uc& /*a*/, const Packet16uc& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet16uc>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet4s pdiv<Packet4s>(const Packet4s& /*a*/, const Packet4s& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4s>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet8s pdiv<Packet8s>(const Packet8s& /*a*/, const Packet8s& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet8s>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet4us pdiv<Packet4us>(const Packet4us& /*a*/, const Packet4us& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4us>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet8us pdiv<Packet8us>(const Packet8us& /*a*/, const Packet8us& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet8us>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet2i pdiv<Packet2i>(const Packet2i& /*a*/, const Packet2i& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet2i>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4i>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet2ui pdiv<Packet2ui>(const Packet2ui& /*a*/, const Packet2ui& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet2ui>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet4ui pdiv<Packet4ui>(const Packet4ui& /*a*/, const Packet4ui& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet4ui>(0);
+}
+template<> EIGEN_STRONG_INLINE Packet2l pdiv<Packet2l>(const Packet2l& /*a*/, const Packet2l& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet2l>(0LL);
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pdiv<Packet2ul>(const Packet2ul& /*a*/, const Packet2ul& /*b*/)
+{
+  eigen_assert(false && "packet integer division are not supported by NEON");
+  return pset1<Packet2ul>(0ULL);
+}
+
+
+#ifdef __ARM_FEATURE_FMA
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
+{ return vfmaq_f32(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet2f pmadd(const Packet2f& a, const Packet2f& b, const Packet2f& c)
+{ return vfma_f32(c,a,b); }
+#else
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
+{
+  return vmlaq_f32(c,a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet2f pmadd(const Packet2f& a, const Packet2f& b, const Packet2f& c)
+{
+  return vmla_f32(c,a,b);
+}
+#endif
+
+// No FMA instruction for int, so use MLA unconditionally.
+template<> EIGEN_STRONG_INLINE Packet4c pmadd(const Packet4c& a, const Packet4c& b, const Packet4c& c)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vmla_s8(
+      vreinterpret_s8_s32(vdup_n_s32(c)),
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pmadd(const Packet8c& a, const Packet8c& b, const Packet8c& c)
+{ return vmla_s8(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmadd(const Packet16c& a, const Packet16c& b, const Packet16c& c)
+{ return vmlaq_s8(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pmadd(const Packet4uc& a, const Packet4uc& b, const Packet4uc& c)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vmla_u8(
+      vreinterpret_u8_u32(vdup_n_u32(c)),
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pmadd(const Packet8uc& a, const Packet8uc& b, const Packet8uc& c)
+{ return vmla_u8(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmadd(const Packet16uc& a, const Packet16uc& b, const Packet16uc& c)
+{ return vmlaq_u8(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pmadd(const Packet4s& a, const Packet4s& b, const Packet4s& c)
+{ return vmla_s16(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmadd(const Packet8s& a, const Packet8s& b, const Packet8s& c)
+{ return vmlaq_s16(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pmadd(const Packet4us& a, const Packet4us& b, const Packet4us& c)
+{ return vmla_u16(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmadd(const Packet8us& a, const Packet8us& b, const Packet8us& c)
+{ return vmlaq_u16(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pmadd(const Packet2i& a, const Packet2i& b, const Packet2i& c)
+{ return vmla_s32(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c)
+{ return vmlaq_s32(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pmadd(const Packet2ui& a, const Packet2ui& b, const Packet2ui& c)
+{ return vmla_u32(c,a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pmadd(const Packet4ui& a, const Packet4ui& b, const Packet4ui& c)
+{ return vmlaq_u32(c,a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pabsdiff<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vabd_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pabsdiff<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vabdq_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4c pabsdiff<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vabd_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pabsdiff<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return vabd_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pabsdiff<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vabdq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pabsdiff<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vabd_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pabsdiff<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vabd_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pabsdiff<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vabdq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pabsdiff<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vabd_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pabsdiff<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vabdq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pabsdiff<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vabd_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pabsdiff<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vabdq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pabsdiff<Packet2i>(const Packet2i& a, const Packet2i& b)
+{ return vabd_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pabsdiff<Packet4i>(const Packet4i& a, const Packet4i& b)
+{ return vabdq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pabsdiff<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vabd_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pabsdiff<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vabdq_u32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pmin<Packet2f>(const Packet2f& a, const Packet2f& b) { return vmin_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) { return vminq_f32(a,b); }
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+// numeric max and min are only available if ARM_FEATURE_NUMERIC_MAXMIN is defined (which can only be the case for Armv8 systems).
+template<> EIGEN_STRONG_INLINE Packet4f pmin<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) { return vminnmq_f32(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2f pmin<PropagateNumbers, Packet2f>(const Packet2f& a, const Packet2f& b) { return vminnm_f32(a, b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) { return pmin<Packet4f>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pmin<PropagateNaN, Packet2f>(const Packet2f& a, const Packet2f& b) { return pmin<Packet2f>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4c pmin<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vmin_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pmin<Packet8c>(const Packet8c& a, const Packet8c& b) { return vmin_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmin<Packet16c>(const Packet16c& a, const Packet16c& b) { return vminq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pmin<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vmin_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pmin<Packet8uc>(const Packet8uc& a, const Packet8uc& b) { return vmin_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmin<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vminq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pmin<Packet4s>(const Packet4s& a, const Packet4s& b) { return vmin_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmin<Packet8s>(const Packet8s& a, const Packet8s& b) { return vminq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pmin<Packet4us>(const Packet4us& a, const Packet4us& b) { return vmin_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmin<Packet8us>(const Packet8us& a, const Packet8us& b) { return vminq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pmin<Packet2i>(const Packet2i& a, const Packet2i& b) { return vmin_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vminq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pmin<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vmin_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pmin<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vminq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pmin<Packet2l>(const Packet2l& a, const Packet2l& b) {
+  return vcombine_s64(
+      vdup_n_s64((std::min)(vgetq_lane_s64(a, 0), vgetq_lane_s64(b, 0))),
+      vdup_n_s64((std::min)(vgetq_lane_s64(a, 1), vgetq_lane_s64(b, 1))));
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pmin<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
+  return vcombine_u64(
+      vdup_n_u64((std::min)(vgetq_lane_u64(a, 0), vgetq_lane_u64(b, 0))),
+      vdup_n_u64((std::min)(vgetq_lane_u64(a, 1), vgetq_lane_u64(b, 1))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pmax<Packet2f>(const Packet2f& a, const Packet2f& b) { return vmax_f32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmaxq_f32(a,b); }
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+// numeric max and min are only available if ARM_FEATURE_NUMERIC_MAXMIN is defined (which can only be the case for Armv8 systems).
+template<> EIGEN_STRONG_INLINE Packet4f pmax<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) { return vmaxnmq_f32(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2f pmax<PropagateNumbers, Packet2f>(const Packet2f& a, const Packet2f& b) { return vmaxnm_f32(a, b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) { return pmax<Packet4f>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pmax<PropagateNaN, Packet2f>(const Packet2f& a, const Packet2f& b) { return pmax<Packet2f>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4c pmax<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vmax_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pmax<Packet8c>(const Packet8c& a, const Packet8c& b) { return vmax_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pmax<Packet16c>(const Packet16c& a, const Packet16c& b) { return vmaxq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pmax<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vmax_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pmax<Packet8uc>(const Packet8uc& a, const Packet8uc& b) { return vmax_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pmax<Packet16uc>(const Packet16uc& a, const Packet16uc& b) { return vmaxq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pmax<Packet4s>(const Packet4s& a, const Packet4s& b) { return vmax_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pmax<Packet8s>(const Packet8s& a, const Packet8s& b) { return vmaxq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pmax<Packet4us>(const Packet4us& a, const Packet4us& b) { return vmax_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pmax<Packet8us>(const Packet8us& a, const Packet8us& b) { return vmaxq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pmax<Packet2i>(const Packet2i& a, const Packet2i& b) { return vmax_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmaxq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pmax<Packet2ui>(const Packet2ui& a, const Packet2ui& b) { return vmax_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pmax<Packet4ui>(const Packet4ui& a, const Packet4ui& b) { return vmaxq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pmax<Packet2l>(const Packet2l& a, const Packet2l& b) {
+  return vcombine_s64(
+      vdup_n_s64((std::max)(vgetq_lane_s64(a, 0), vgetq_lane_s64(b, 0))),
+      vdup_n_s64((std::max)(vgetq_lane_s64(a, 1), vgetq_lane_s64(b, 1))));
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pmax<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
+  return vcombine_u64(
+      vdup_n_u64((std::max)(vgetq_lane_u64(a, 0), vgetq_lane_u64(b, 0))),
+      vdup_n_u64((std::max)(vgetq_lane_u64(a, 1), vgetq_lane_u64(b, 1))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pcmp_le<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vcle_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_le<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vcleq_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4c pcmp_le<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_u8(vcle_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pcmp_le<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return vreinterpret_s8_u8(vcle_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_le<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vreinterpretq_s8_u8(vcleq_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4uc pcmp_le<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vcle_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pcmp_le<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vcle_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_le<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vcleq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pcmp_le<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vreinterpret_s16_u16(vcle_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_le<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vreinterpretq_s16_u16(vcleq_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4us pcmp_le<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vcle_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_le<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vcleq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pcmp_le<Packet2i>(const Packet2i& a, const Packet2i& b)
+{ return vreinterpret_s32_u32(vcle_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_le<Packet4i>(const Packet4i& a, const Packet4i& b)
+{ return vreinterpretq_s32_u32(vcleq_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2ui pcmp_le<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vcle_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pcmp_le<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vcleq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pcmp_le<Packet2l>(const Packet2l& a, const Packet2l& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vreinterpretq_s64_u64(vcleq_s64(a,b));
+#else
+  return vcombine_s64(
+      vdup_n_s64(vgetq_lane_s64(a, 0) <= vgetq_lane_s64(b, 0) ? numext::int64_t(-1) : 0),
+      vdup_n_s64(vgetq_lane_s64(a, 1) <= vgetq_lane_s64(b, 1) ? numext::int64_t(-1) : 0));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pcmp_le<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vcleq_u64(a,b);
+#else
+  return vcombine_u64(
+      vdup_n_u64(vgetq_lane_u64(a, 0) <= vgetq_lane_u64(b, 0) ? numext::uint64_t(-1) : 0),
+      vdup_n_u64(vgetq_lane_u64(a, 1) <= vgetq_lane_u64(b, 1) ? numext::uint64_t(-1) : 0));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pcmp_lt<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vclt_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vcltq_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4c pcmp_lt<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_u8(vclt_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pcmp_lt<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return vreinterpret_s8_u8(vclt_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_lt<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vreinterpretq_s8_u8(vcltq_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4uc pcmp_lt<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vclt_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pcmp_lt<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vclt_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_lt<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vcltq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pcmp_lt<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vreinterpret_s16_u16(vclt_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_lt<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vreinterpretq_s16_u16(vcltq_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4us pcmp_lt<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vclt_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_lt<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vcltq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pcmp_lt<Packet2i>(const Packet2i& a, const Packet2i& b)
+{ return vreinterpret_s32_u32(vclt_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_lt<Packet4i>(const Packet4i& a, const Packet4i& b)
+{ return vreinterpretq_s32_u32(vcltq_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2ui pcmp_lt<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vclt_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pcmp_lt<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vcltq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pcmp_lt<Packet2l>(const Packet2l& a, const Packet2l& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vreinterpretq_s64_u64(vcltq_s64(a,b));
+#else
+  return vcombine_s64(
+      vdup_n_s64(vgetq_lane_s64(a, 0) < vgetq_lane_s64(b, 0) ? numext::int64_t(-1) : 0),
+      vdup_n_s64(vgetq_lane_s64(a, 1) < vgetq_lane_s64(b, 1) ? numext::int64_t(-1) : 0));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pcmp_lt<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vcltq_u64(a,b);
+#else
+  return vcombine_u64(
+      vdup_n_u64(vgetq_lane_u64(a, 0) < vgetq_lane_u64(b, 0) ? numext::uint64_t(-1) : 0),
+      vdup_n_u64(vgetq_lane_u64(a, 1) < vgetq_lane_u64(b, 1) ? numext::uint64_t(-1) : 0));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pcmp_eq<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vceq_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_eq<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vceqq_f32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4c pcmp_eq<Packet4c>(const Packet4c& a, const Packet4c& b)
+{
+  return vget_lane_s32(vreinterpret_s32_u8(vceq_s8(
+      vreinterpret_s8_s32(vdup_n_s32(a)),
+      vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c pcmp_eq<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return vreinterpret_s8_u8(vceq_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet16c pcmp_eq<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vreinterpretq_s8_u8(vceqq_s8(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4uc pcmp_eq<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vceq_u8(
+      vreinterpret_u8_u32(vdup_n_u32(a)),
+      vreinterpret_u8_u32(vdup_n_u32(b)))), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pcmp_eq<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vceq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pcmp_eq<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vceqq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pcmp_eq<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vreinterpret_s16_u16(vceq_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet8s pcmp_eq<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vreinterpretq_s16_u16(vceqq_s16(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4us pcmp_eq<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vceq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pcmp_eq<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vceqq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pcmp_eq<Packet2i>(const Packet2i& a, const Packet2i& b)
+{ return vreinterpret_s32_u32(vceq_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_eq<Packet4i>(const Packet4i& a, const Packet4i& b)
+{ return vreinterpretq_s32_u32(vceqq_s32(a,b)); }
+template<> EIGEN_STRONG_INLINE Packet2ui pcmp_eq<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vceq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pcmp_eq<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vceqq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pcmp_eq<Packet2l>(const Packet2l& a, const Packet2l& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vreinterpretq_s64_u64(vceqq_s64(a,b));
+#else
+  return vcombine_s64(
+      vdup_n_s64(vgetq_lane_s64(a, 0) == vgetq_lane_s64(b, 0) ? numext::int64_t(-1) : 0),
+      vdup_n_s64(vgetq_lane_s64(a, 1) == vgetq_lane_s64(b, 1) ? numext::int64_t(-1) : 0));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pcmp_eq<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{
+#if EIGEN_ARCH_ARM64
+  return vceqq_u64(a,b);
+#else
+  return vcombine_u64(
+      vdup_n_u64(vgetq_lane_u64(a, 0) == vgetq_lane_u64(b, 0) ? numext::uint64_t(-1) : 0),
+      vdup_n_u64(vgetq_lane_u64(a, 1) == vgetq_lane_u64(b, 1) ? numext::uint64_t(-1) : 0));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pcmp_lt_or_nan<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vmvn_u32(vcge_f32(a,b))); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vmvnq_u32(vcgeq_f32(a,b))); }
+
+// Logical Operations are not supported for float, so we have to reinterpret casts using NEON intrinsics
+template<> EIGEN_STRONG_INLINE Packet2f pand<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vand_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4c pand<Packet4c>(const Packet4c& a, const Packet4c& b)
+{ return a & b; }
+template<> EIGEN_STRONG_INLINE Packet8c pand<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return vand_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pand<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vandq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pand<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{ return a & b; }
+template<> EIGEN_STRONG_INLINE Packet8uc pand<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vand_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pand<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vandq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pand<Packet4s>(const Packet4s& a, const Packet4s& b) { return vand_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pand<Packet8s>(const Packet8s& a, const Packet8s& b) { return vandq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pand<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vand_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pand<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vandq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pand<Packet2i>(const Packet2i& a, const Packet2i& b) { return vand_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vandq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pand<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vand_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pand<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vandq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pand<Packet2l>(const Packet2l& a, const Packet2l& b) { return vandq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul pand<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{ return vandq_u64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f por<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vorr_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4c por<Packet4c>(const Packet4c& a, const Packet4c& b)
+{ return a | b; }
+template<> EIGEN_STRONG_INLINE Packet8c por<Packet8c>(const Packet8c& a, const Packet8c& b) { return vorr_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c por<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return vorrq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc por<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{ return a | b; }
+template<> EIGEN_STRONG_INLINE Packet8uc por<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vorr_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc por<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vorrq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s por<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vorr_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s por<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vorrq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us por<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vorr_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us por<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vorrq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i por<Packet2i>(const Packet2i& a, const Packet2i& b) { return vorr_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vorrq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui por<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vorr_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui por<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vorrq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l por<Packet2l>(const Packet2l& a, const Packet2l& b)
+{ return vorrq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul por<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{ return vorrq_u64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pxor<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4c pxor<Packet4c>(const Packet4c& a, const Packet4c& b)
+{ return a ^ b; }
+template<> EIGEN_STRONG_INLINE Packet8c pxor<Packet8c>(const Packet8c& a, const Packet8c& b)
+{ return veor_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pxor<Packet16c>(const Packet16c& a, const Packet16c& b)
+{ return veorq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pxor<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{ return a ^ b; }
+template<> EIGEN_STRONG_INLINE Packet8uc pxor<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return veor_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pxor<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return veorq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pxor<Packet4s>(const Packet4s& a, const Packet4s& b) { return veor_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pxor<Packet8s>(const Packet8s& a, const Packet8s& b) { return veorq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pxor<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return veor_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pxor<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return veorq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pxor<Packet2i>(const Packet2i& a, const Packet2i& b) { return veor_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return veorq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pxor<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return veor_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pxor<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return veorq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pxor<Packet2l>(const Packet2l& a, const Packet2l& b)
+{ return veorq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul pxor<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{ return veorq_u64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pandnot<Packet2f>(const Packet2f& a, const Packet2f& b)
+{ return vreinterpret_f32_u32(vbic_u32(vreinterpret_u32_f32(a),vreinterpret_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b)
+{ return vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); }
+template<> EIGEN_STRONG_INLINE Packet4c pandnot<Packet4c>(const Packet4c& a, const Packet4c& b)
+{ return a & ~b; }
+template<> EIGEN_STRONG_INLINE Packet8c pandnot<Packet8c>(const Packet8c& a, const Packet8c& b) { return vbic_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16c pandnot<Packet16c>(const Packet16c& a, const Packet16c& b) { return vbicq_s8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4uc pandnot<Packet4uc>(const Packet4uc& a, const Packet4uc& b)
+{ return a & ~b; }
+template<> EIGEN_STRONG_INLINE Packet8uc pandnot<Packet8uc>(const Packet8uc& a, const Packet8uc& b)
+{ return vbic_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16uc pandnot<Packet16uc>(const Packet16uc& a, const Packet16uc& b)
+{ return vbicq_u8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4s pandnot<Packet4s>(const Packet4s& a, const Packet4s& b)
+{ return vbic_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8s pandnot<Packet8s>(const Packet8s& a, const Packet8s& b)
+{ return vbicq_s16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4us pandnot<Packet4us>(const Packet4us& a, const Packet4us& b)
+{ return vbic_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet8us pandnot<Packet8us>(const Packet8us& a, const Packet8us& b)
+{ return vbicq_u16(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2i pandnot<Packet2i>(const Packet2i& a, const Packet2i& b)
+{ return vbic_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b)
+{ return vbicq_s32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ui pandnot<Packet2ui>(const Packet2ui& a, const Packet2ui& b)
+{ return vbic_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4ui pandnot<Packet4ui>(const Packet4ui& a, const Packet4ui& b)
+{ return vbicq_u32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2l pandnot<Packet2l>(const Packet2l& a, const Packet2l& b)
+{ return vbicq_s64(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2ul pandnot<Packet2ul>(const Packet2ul& a, const Packet2ul& b)
+{ return vbicq_u64(a,b); }
+
+
+template<int N> EIGEN_STRONG_INLINE Packet4c parithmetic_shift_right(Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vshr_n_s8(vreinterpret_s8_s32(vdup_n_s32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8c parithmetic_shift_right(Packet8c a) { return vshr_n_s8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet16c parithmetic_shift_right(Packet16c a) { return vshrq_n_s8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4uc parithmetic_shift_right(Packet4uc& a)
+{ return vget_lane_u32(vreinterpret_u32_u8(vshr_n_u8(vreinterpret_u8_u32(vdup_n_u32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8uc parithmetic_shift_right(Packet8uc a) { return vshr_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet16uc parithmetic_shift_right(Packet16uc a) { return vshrq_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4s parithmetic_shift_right(Packet4s a) { return vshr_n_s16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet8s parithmetic_shift_right(Packet8s a) { return vshrq_n_s16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4us parithmetic_shift_right(Packet4us a) { return vshr_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet8us parithmetic_shift_right(Packet8us a) { return vshrq_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2i parithmetic_shift_right(Packet2i a) { return vshr_n_s32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(Packet4i a) { return vshrq_n_s32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2ui parithmetic_shift_right(Packet2ui a) { return vshr_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4ui parithmetic_shift_right(Packet4ui a) { return vshrq_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2l parithmetic_shift_right(Packet2l a) { return vshrq_n_s64(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2ul parithmetic_shift_right(Packet2ul a) { return vshrq_n_u64(a,N); }
+
+template<int N> EIGEN_STRONG_INLINE Packet4c plogical_shift_right(Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_u8(vshr_n_u8(vreinterpret_u8_s32(vdup_n_s32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8c plogical_shift_right(Packet8c a)
+{ return vreinterpret_s8_u8(vshr_n_u8(vreinterpret_u8_s8(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet16c plogical_shift_right(Packet16c a)
+{ return vreinterpretq_s8_u8(vshrq_n_u8(vreinterpretq_u8_s8(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet4uc plogical_shift_right(Packet4uc& a)
+{ return vget_lane_u32(vreinterpret_u32_s8(vshr_n_s8(vreinterpret_s8_u32(vdup_n_u32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8uc plogical_shift_right(Packet8uc a) { return vshr_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet16uc plogical_shift_right(Packet16uc a) { return vshrq_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4s plogical_shift_right(Packet4s a)
+{ return vreinterpret_s16_u16(vshr_n_u16(vreinterpret_u16_s16(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet8s plogical_shift_right(Packet8s a)
+{ return vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet4us plogical_shift_right(Packet4us a) { return vshr_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet8us plogical_shift_right(Packet8us a) { return vshrq_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2i plogical_shift_right(Packet2i a)
+{ return vreinterpret_s32_u32(vshr_n_u32(vreinterpret_u32_s32(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_right(Packet4i a)
+{ return vreinterpretq_s32_u32(vshrq_n_u32(vreinterpretq_u32_s32(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet2ui plogical_shift_right(Packet2ui a) { return vshr_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4ui plogical_shift_right(Packet4ui a) { return vshrq_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2l plogical_shift_right(Packet2l a)
+{ return vreinterpretq_s64_u64(vshrq_n_u64(vreinterpretq_u64_s64(a),N)); }
+template<int N> EIGEN_STRONG_INLINE Packet2ul plogical_shift_right(Packet2ul a) { return vshrq_n_u64(a,N); }
+
+template<int N> EIGEN_STRONG_INLINE Packet4c plogical_shift_left(Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vshl_n_s8(vreinterpret_s8_s32(vdup_n_s32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8c plogical_shift_left(Packet8c a) { return vshl_n_s8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet16c plogical_shift_left(Packet16c a) { return vshlq_n_s8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4uc plogical_shift_left(Packet4uc& a)
+{ return vget_lane_u32(vreinterpret_u32_u8(vshl_n_u8(vreinterpret_u8_u32(vdup_n_u32(a)), N)), 0); }
+template<int N> EIGEN_STRONG_INLINE Packet8uc plogical_shift_left(Packet8uc a) { return vshl_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet16uc plogical_shift_left(Packet16uc a) { return vshlq_n_u8(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4s plogical_shift_left(Packet4s a) { return vshl_n_s16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet8s plogical_shift_left(Packet8s a) { return vshlq_n_s16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4us plogical_shift_left(Packet4us a) { return vshl_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet8us plogical_shift_left(Packet8us a) { return vshlq_n_u16(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2i plogical_shift_left(Packet2i a) { return vshl_n_s32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_left(Packet4i a) { return vshlq_n_s32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2ui plogical_shift_left(Packet2ui a) { return vshl_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4ui plogical_shift_left(Packet4ui a) { return vshlq_n_u32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2l plogical_shift_left(Packet2l a) { return vshlq_n_s64(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet2ul plogical_shift_left(Packet2ul a) { return vshlq_n_u64(a,N); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pload<Packet2f>(const float* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4c pload<Packet4c>(const int8_t* from)
+{
+  Packet4c res;
+  memcpy(&res, from, sizeof(Packet4c));
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet8c pload<Packet8c>(const int8_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet16c pload<Packet16c>(const int8_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet4uc pload<Packet4uc>(const uint8_t* from)
+{
+  Packet4uc res;
+  memcpy(&res, from, sizeof(Packet4uc));
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet8uc pload<Packet8uc>(const uint8_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet16uc pload<Packet16uc>(const uint8_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet4s pload<Packet4s>(const int16_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet8s pload<Packet8s>(const int16_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet4us pload<Packet4us>(const uint16_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet8us pload<Packet8us>(const uint16_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet2i pload<Packet2i>(const int32_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int32_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet2ui pload<Packet2ui>(const uint32_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet4ui pload<Packet4ui>(const uint32_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet2l pload<Packet2l>(const int64_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s64(from); }
+template<> EIGEN_STRONG_INLINE Packet2ul pload<Packet2ul>(const uint64_t* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_u64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2f ploadu<Packet2f>(const float* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4c ploadu<Packet4c>(const int8_t* from)
+{
+  Packet4c res;
+  memcpy(&res, from, sizeof(Packet4c));
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet8c ploadu<Packet8c>(const int8_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet16c ploadu<Packet16c>(const int8_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s8(from); }
+template<> EIGEN_STRONG_INLINE Packet4uc ploadu<Packet4uc>(const uint8_t* from)
+{
+  Packet4uc res;
+  memcpy(&res, from, sizeof(Packet4uc));
+  return res;
+}
+template<> EIGEN_STRONG_INLINE Packet8uc ploadu<Packet8uc>(const uint8_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet16uc ploadu<Packet16uc>(const uint8_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_u8(from); }
+template<> EIGEN_STRONG_INLINE Packet4s ploadu<Packet4s>(const int16_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet8s ploadu<Packet8s>(const int16_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s16(from); }
+template<> EIGEN_STRONG_INLINE Packet4us ploadu<Packet4us>(const uint16_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet8us ploadu<Packet8us>(const uint16_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_u16(from); }
+template<> EIGEN_STRONG_INLINE Packet2i ploadu<Packet2i>(const int32_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int32_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet2ui ploadu<Packet2ui>(const uint32_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet4ui ploadu<Packet4ui>(const uint32_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet2l ploadu<Packet2l>(const int64_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s64(from); }
+template<> EIGEN_STRONG_INLINE Packet2ul ploadu<Packet2ul>(const uint64_t* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_u64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2f ploaddup<Packet2f>(const float* from)
+{ return vld1_dup_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float* from)
+{ return vcombine_f32(vld1_dup_f32(from), vld1_dup_f32(from+1)); }
+template<> EIGEN_STRONG_INLINE Packet4c ploaddup<Packet4c>(const int8_t* from)
+{
+  const int8x8_t a = vreinterpret_s8_s32(vdup_n_s32(pload<Packet4c>(from)));
+  return vget_lane_s32(vreinterpret_s32_s8(vzip_s8(a,a).val[0]), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8c ploaddup<Packet8c>(const int8_t* from)
+{
+  const int8x8_t a = vld1_s8(from);
+  return vzip_s8(a,a).val[0];
+}
+template<> EIGEN_STRONG_INLINE Packet16c ploaddup<Packet16c>(const int8_t* from)
+{
+  const int8x8_t a = vld1_s8(from);
+  const int8x8x2_t b = vzip_s8(a,a);
+  return vcombine_s8(b.val[0], b.val[1]);
+}
+template<> EIGEN_STRONG_INLINE Packet4uc ploaddup<Packet4uc>(const uint8_t* from)
+{
+  const uint8x8_t a = vreinterpret_u8_u32(vdup_n_u32(pload<Packet4uc>(from)));
+  return vget_lane_u32(vreinterpret_u32_u8(vzip_u8(a,a).val[0]), 0);
+}
+template<> EIGEN_STRONG_INLINE Packet8uc ploaddup<Packet8uc>(const uint8_t* from)
+{
+  const uint8x8_t a = vld1_u8(from);
+  return vzip_u8(a,a).val[0];
+}
+template<> EIGEN_STRONG_INLINE Packet16uc ploaddup<Packet16uc>(const uint8_t* from)
+{
+  const uint8x8_t a = vld1_u8(from);
+  const uint8x8x2_t b = vzip_u8(a,a);
+  return vcombine_u8(b.val[0], b.val[1]);
+}
+template<> EIGEN_STRONG_INLINE Packet4s ploaddup<Packet4s>(const int16_t* from)
+{
+  return vreinterpret_s16_u32(vzip_u32(vreinterpret_u32_s16(vld1_dup_s16(from)),
+      vreinterpret_u32_s16(vld1_dup_s16(from+1))).val[0]);
+}
+template<> EIGEN_STRONG_INLINE Packet8s ploaddup<Packet8s>(const int16_t* from)
+{
+  const int16x4_t a = vld1_s16(from);
+  const int16x4x2_t b = vzip_s16(a,a);
+  return vcombine_s16(b.val[0], b.val[1]);
+}
+template<> EIGEN_STRONG_INLINE Packet4us ploaddup<Packet4us>(const uint16_t* from)
+{
+  return vreinterpret_u16_u32(vzip_u32(vreinterpret_u32_u16(vld1_dup_u16(from)),
+      vreinterpret_u32_u16(vld1_dup_u16(from+1))).val[0]);
+}
+template<> EIGEN_STRONG_INLINE Packet8us ploaddup<Packet8us>(const uint16_t* from)
+{
+  const uint16x4_t a = vld1_u16(from);
+  const uint16x4x2_t b = vzip_u16(a,a);
+  return vcombine_u16(b.val[0], b.val[1]);
+}
+template<> EIGEN_STRONG_INLINE Packet2i ploaddup<Packet2i>(const int32_t* from)
+{ return vld1_dup_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int32_t* from)
+{ return vcombine_s32(vld1_dup_s32(from), vld1_dup_s32(from+1)); }
+template<> EIGEN_STRONG_INLINE Packet2ui ploaddup<Packet2ui>(const uint32_t* from)
+{ return vld1_dup_u32(from); }
+template<> EIGEN_STRONG_INLINE Packet4ui ploaddup<Packet4ui>(const uint32_t* from)
+{ return vcombine_u32(vld1_dup_u32(from), vld1_dup_u32(from+1)); }
+template<> EIGEN_STRONG_INLINE Packet2l ploaddup<Packet2l>(const int64_t* from)
+{ return vld1q_dup_s64(from); }
+template<> EIGEN_STRONG_INLINE Packet2ul ploaddup<Packet2ul>(const uint64_t* from)
+{ return vld1q_dup_u64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet4f ploadquad<Packet4f>(const float* from) { return vld1q_dup_f32(from); }
+template<> EIGEN_STRONG_INLINE Packet4c ploadquad<Packet4c>(const int8_t* from)
+{ return vget_lane_s32(vreinterpret_s32_s8(vld1_dup_s8(from)), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c ploadquad<Packet8c>(const int8_t* from)
+{
+  return vreinterpret_s8_u32(vzip_u32(
+      vreinterpret_u32_s8(vld1_dup_s8(from)),
+      vreinterpret_u32_s8(vld1_dup_s8(from+1))).val[0]);
+}
+template<> EIGEN_STRONG_INLINE Packet16c ploadquad<Packet16c>(const int8_t* from)
+{
+  const int8x8_t a = vreinterpret_s8_u32(vzip_u32(
+      vreinterpret_u32_s8(vld1_dup_s8(from)),
+      vreinterpret_u32_s8(vld1_dup_s8(from+1))).val[0]);
+  const int8x8_t b = vreinterpret_s8_u32(vzip_u32(
+      vreinterpret_u32_s8(vld1_dup_s8(from+2)),
+      vreinterpret_u32_s8(vld1_dup_s8(from+3))).val[0]);
+  return vcombine_s8(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet4uc ploadquad<Packet4uc>(const uint8_t* from)
+{ return vget_lane_u32(vreinterpret_u32_u8(vld1_dup_u8(from)), 0); }
+template<> EIGEN_STRONG_INLINE Packet8uc ploadquad<Packet8uc>(const uint8_t* from)
+{
+  return vreinterpret_u8_u32(vzip_u32(
+      vreinterpret_u32_u8(vld1_dup_u8(from)),
+      vreinterpret_u32_u8(vld1_dup_u8(from+1))).val[0]);
+}
+template<> EIGEN_STRONG_INLINE Packet16uc ploadquad<Packet16uc>(const uint8_t* from)
+{
+  const uint8x8_t a = vreinterpret_u8_u32(vzip_u32(
+      vreinterpret_u32_u8(vld1_dup_u8(from)),
+      vreinterpret_u32_u8(vld1_dup_u8(from+1))).val[0]);
+  const uint8x8_t b = vreinterpret_u8_u32(vzip_u32(
+      vreinterpret_u32_u8(vld1_dup_u8(from+2)),
+      vreinterpret_u32_u8(vld1_dup_u8(from+3))).val[0]);
+  return vcombine_u8(a,b);
+}
+template<> EIGEN_STRONG_INLINE Packet8s ploadquad<Packet8s>(const int16_t* from)
+{ return vcombine_s16(vld1_dup_s16(from), vld1_dup_s16(from+1)); }
+template<> EIGEN_STRONG_INLINE Packet8us ploadquad<Packet8us>(const uint16_t* from)
+{ return vcombine_u16(vld1_dup_u16(from), vld1_dup_u16(from+1)); }
+template<> EIGEN_STRONG_INLINE Packet4i ploadquad<Packet4i>(const int32_t* from) { return vld1q_dup_s32(from); }
+template<> EIGEN_STRONG_INLINE Packet4ui ploadquad<Packet4ui>(const uint32_t* from) { return vld1q_dup_u32(from); }
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet2f& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_f32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_f32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int8_t>(int8_t* to, const Packet4c& from)
+{ memcpy(to, &from, sizeof(from)); }
+template<> EIGEN_STRONG_INLINE void pstore<int8_t>(int8_t* to, const Packet8c& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_s8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int8_t>(int8_t* to, const Packet16c& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_s8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint8_t>(uint8_t* to, const Packet4uc& from)
+{ memcpy(to, &from, sizeof(from)); }
+template<> EIGEN_STRONG_INLINE void pstore<uint8_t>(uint8_t* to, const Packet8uc& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_u8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint8_t>(uint8_t* to, const Packet16uc& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_u8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int16_t>(int16_t* to, const Packet4s& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_s16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int16_t>(int16_t* to, const Packet8s& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_s16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint16_t>(uint16_t* to, const Packet4us& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_u16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint16_t>(uint16_t* to, const Packet8us& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_u16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int32_t>(int32_t* to, const Packet2i& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_s32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int32_t>(int32_t* to, const Packet4i& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint32_t>(uint32_t* to, const Packet2ui& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1_u32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint32_t>(uint32_t* to, const Packet4ui& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_u32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<int64_t>(int64_t* to, const Packet2l& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_s64(to,from); }
+template<> EIGEN_STRONG_INLINE void pstore<uint64_t>(uint64_t* to, const Packet2ul& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_u64(to,from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet2f& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_f32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet4f& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_f32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int8_t>(int8_t* to, const Packet4c& from)
+{ memcpy(to, &from, sizeof(from)); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int8_t>(int8_t* to, const Packet8c& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_s8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int8_t>(int8_t* to, const Packet16c& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_s8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint8_t>(uint8_t* to, const Packet4uc& from)
+{ memcpy(to, &from, sizeof(from)); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint8_t>(uint8_t* to, const Packet8uc& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_u8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint8_t>(uint8_t* to, const Packet16uc& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_u8(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int16_t>(int16_t* to, const Packet4s& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_s16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int16_t>(int16_t* to, const Packet8s& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_s16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint16_t>(uint16_t* to, const Packet4us& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_u16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint16_t>(uint16_t* to, const Packet8us& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_u16(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int32_t>(int32_t* to, const Packet2i& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_s32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int32_t>(int32_t* to, const Packet4i& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint32_t>(uint32_t* to, const Packet2ui& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1_u32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint32_t>(uint32_t* to, const Packet4ui& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_u32(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int64_t>(int64_t* to, const Packet2l& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_s64(to,from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<uint64_t>(uint64_t* to, const Packet2ul& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_u64(to,from); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f pgather<float, Packet2f>(const float* from, Index stride)
+{
+  Packet2f res = vld1_dup_f32(from);
+  res = vld1_lane_f32(from + 1*stride, res, 1);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  Packet4f res = vld1q_dup_f32(from);
+  res = vld1q_lane_f32(from + 1*stride, res, 1);
+  res = vld1q_lane_f32(from + 2*stride, res, 2);
+  res = vld1q_lane_f32(from + 3*stride, res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c pgather<int8_t, Packet4c>(const int8_t* from, Index stride)
+{
+  Packet4c res;
+  for (int i = 0; i != 4; i++)
+    reinterpret_cast<int8_t*>(&res)[i] = *(from + i * stride);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c pgather<int8_t, Packet8c>(const int8_t* from, Index stride)
+{
+  Packet8c res = vld1_dup_s8(from);
+  res = vld1_lane_s8(from + 1*stride, res, 1);
+  res = vld1_lane_s8(from + 2*stride, res, 2);
+  res = vld1_lane_s8(from + 3*stride, res, 3);
+  res = vld1_lane_s8(from + 4*stride, res, 4);
+  res = vld1_lane_s8(from + 5*stride, res, 5);
+  res = vld1_lane_s8(from + 6*stride, res, 6);
+  res = vld1_lane_s8(from + 7*stride, res, 7);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c pgather<int8_t, Packet16c>(const int8_t* from, Index stride)
+{
+  Packet16c res = vld1q_dup_s8(from);
+  res = vld1q_lane_s8(from + 1*stride, res, 1);
+  res = vld1q_lane_s8(from + 2*stride, res, 2);
+  res = vld1q_lane_s8(from + 3*stride, res, 3);
+  res = vld1q_lane_s8(from + 4*stride, res, 4);
+  res = vld1q_lane_s8(from + 5*stride, res, 5);
+  res = vld1q_lane_s8(from + 6*stride, res, 6);
+  res = vld1q_lane_s8(from + 7*stride, res, 7);
+  res = vld1q_lane_s8(from + 8*stride, res, 8);
+  res = vld1q_lane_s8(from + 9*stride, res, 9);
+  res = vld1q_lane_s8(from + 10*stride, res, 10);
+  res = vld1q_lane_s8(from + 11*stride, res, 11);
+  res = vld1q_lane_s8(from + 12*stride, res, 12);
+  res = vld1q_lane_s8(from + 13*stride, res, 13);
+  res = vld1q_lane_s8(from + 14*stride, res, 14);
+  res = vld1q_lane_s8(from + 15*stride, res, 15);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc pgather<uint8_t, Packet4uc>(const uint8_t* from, Index stride)
+{
+  Packet4uc res;
+  for (int i = 0; i != 4; i++)
+    reinterpret_cast<uint8_t*>(&res)[i] = *(from + i * stride);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc pgather<uint8_t, Packet8uc>(const uint8_t* from, Index stride)
+{
+  Packet8uc res = vld1_dup_u8(from);
+  res = vld1_lane_u8(from + 1*stride, res, 1);
+  res = vld1_lane_u8(from + 2*stride, res, 2);
+  res = vld1_lane_u8(from + 3*stride, res, 3);
+  res = vld1_lane_u8(from + 4*stride, res, 4);
+  res = vld1_lane_u8(from + 5*stride, res, 5);
+  res = vld1_lane_u8(from + 6*stride, res, 6);
+  res = vld1_lane_u8(from + 7*stride, res, 7);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc pgather<uint8_t, Packet16uc>(const uint8_t* from, Index stride)
+{
+  Packet16uc res = vld1q_dup_u8(from);
+  res = vld1q_lane_u8(from + 1*stride, res, 1);
+  res = vld1q_lane_u8(from + 2*stride, res, 2);
+  res = vld1q_lane_u8(from + 3*stride, res, 3);
+  res = vld1q_lane_u8(from + 4*stride, res, 4);
+  res = vld1q_lane_u8(from + 5*stride, res, 5);
+  res = vld1q_lane_u8(from + 6*stride, res, 6);
+  res = vld1q_lane_u8(from + 7*stride, res, 7);
+  res = vld1q_lane_u8(from + 8*stride, res, 8);
+  res = vld1q_lane_u8(from + 9*stride, res, 9);
+  res = vld1q_lane_u8(from + 10*stride, res, 10);
+  res = vld1q_lane_u8(from + 11*stride, res, 11);
+  res = vld1q_lane_u8(from + 12*stride, res, 12);
+  res = vld1q_lane_u8(from + 13*stride, res, 13);
+  res = vld1q_lane_u8(from + 14*stride, res, 14);
+  res = vld1q_lane_u8(from + 15*stride, res, 15);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s pgather<int16_t, Packet4s>(const int16_t* from, Index stride)
+{
+  Packet4s res = vld1_dup_s16(from);
+  res = vld1_lane_s16(from + 1*stride, res, 1);
+  res = vld1_lane_s16(from + 2*stride, res, 2);
+  res = vld1_lane_s16(from + 3*stride, res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s pgather<int16_t, Packet8s>(const int16_t* from, Index stride)
+{
+  Packet8s res = vld1q_dup_s16(from);
+  res = vld1q_lane_s16(from + 1*stride, res, 1);
+  res = vld1q_lane_s16(from + 2*stride, res, 2);
+  res = vld1q_lane_s16(from + 3*stride, res, 3);
+  res = vld1q_lane_s16(from + 4*stride, res, 4);
+  res = vld1q_lane_s16(from + 5*stride, res, 5);
+  res = vld1q_lane_s16(from + 6*stride, res, 6);
+  res = vld1q_lane_s16(from + 7*stride, res, 7);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us pgather<uint16_t, Packet4us>(const uint16_t* from, Index stride)
+{
+  Packet4us res = vld1_dup_u16(from);
+  res = vld1_lane_u16(from + 1*stride, res, 1);
+  res = vld1_lane_u16(from + 2*stride, res, 2);
+  res = vld1_lane_u16(from + 3*stride, res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us pgather<uint16_t, Packet8us>(const uint16_t* from, Index stride)
+{
+  Packet8us res = vld1q_dup_u16(from);
+  res = vld1q_lane_u16(from + 1*stride, res, 1);
+  res = vld1q_lane_u16(from + 2*stride, res, 2);
+  res = vld1q_lane_u16(from + 3*stride, res, 3);
+  res = vld1q_lane_u16(from + 4*stride, res, 4);
+  res = vld1q_lane_u16(from + 5*stride, res, 5);
+  res = vld1q_lane_u16(from + 6*stride, res, 6);
+  res = vld1q_lane_u16(from + 7*stride, res, 7);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i pgather<int32_t, Packet2i>(const int32_t* from, Index stride)
+{
+  Packet2i res = vld1_dup_s32(from);
+  res = vld1_lane_s32(from + 1*stride, res, 1);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i pgather<int32_t, Packet4i>(const int32_t* from, Index stride)
+{
+  Packet4i res = vld1q_dup_s32(from);
+  res = vld1q_lane_s32(from + 1*stride, res, 1);
+  res = vld1q_lane_s32(from + 2*stride, res, 2);
+  res = vld1q_lane_s32(from + 3*stride, res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui pgather<uint32_t, Packet2ui>(const uint32_t* from, Index stride)
+{
+  Packet2ui res = vld1_dup_u32(from);
+  res = vld1_lane_u32(from + 1*stride, res, 1);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui pgather<uint32_t, Packet4ui>(const uint32_t* from, Index stride)
+{
+  Packet4ui res = vld1q_dup_u32(from);
+  res = vld1q_lane_u32(from + 1*stride, res, 1);
+  res = vld1q_lane_u32(from + 2*stride, res, 2);
+  res = vld1q_lane_u32(from + 3*stride, res, 3);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l pgather<int64_t, Packet2l>(const int64_t* from, Index stride)
+{
+  Packet2l res = vld1q_dup_s64(from);
+  res = vld1q_lane_s64(from + 1*stride, res, 1);
+  return res;
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul pgather<uint64_t, Packet2ul>(const uint64_t* from, Index stride)
+{
+  Packet2ul res = vld1q_dup_u64(from);
+  res = vld1q_lane_u64(from + 1*stride, res, 1);
+  return res;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<float, Packet2f>(float* to, const Packet2f& from, Index stride)
+{
+  vst1_lane_f32(to + stride*0, from, 0);
+  vst1_lane_f32(to + stride*1, from, 1);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  vst1q_lane_f32(to + stride*0, from, 0);
+  vst1q_lane_f32(to + stride*1, from, 1);
+  vst1q_lane_f32(to + stride*2, from, 2);
+  vst1q_lane_f32(to + stride*3, from, 3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int8_t, Packet4c>(int8_t* to, const Packet4c& from, Index stride)
+{
+  for (int i = 0; i != 4; i++)
+    *(to + i * stride) = reinterpret_cast<const int8_t*>(&from)[i];
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int8_t, Packet8c>(int8_t* to, const Packet8c& from, Index stride)
+{
+  vst1_lane_s8(to + stride*0, from, 0);
+  vst1_lane_s8(to + stride*1, from, 1);
+  vst1_lane_s8(to + stride*2, from, 2);
+  vst1_lane_s8(to + stride*3, from, 3);
+  vst1_lane_s8(to + stride*4, from, 4);
+  vst1_lane_s8(to + stride*5, from, 5);
+  vst1_lane_s8(to + stride*6, from, 6);
+  vst1_lane_s8(to + stride*7, from, 7);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int8_t, Packet16c>(int8_t* to, const Packet16c& from, Index stride)
+{
+  vst1q_lane_s8(to + stride*0, from, 0);
+  vst1q_lane_s8(to + stride*1, from, 1);
+  vst1q_lane_s8(to + stride*2, from, 2);
+  vst1q_lane_s8(to + stride*3, from, 3);
+  vst1q_lane_s8(to + stride*4, from, 4);
+  vst1q_lane_s8(to + stride*5, from, 5);
+  vst1q_lane_s8(to + stride*6, from, 6);
+  vst1q_lane_s8(to + stride*7, from, 7);
+  vst1q_lane_s8(to + stride*8, from, 8);
+  vst1q_lane_s8(to + stride*9, from, 9);
+  vst1q_lane_s8(to + stride*10, from, 10);
+  vst1q_lane_s8(to + stride*11, from, 11);
+  vst1q_lane_s8(to + stride*12, from, 12);
+  vst1q_lane_s8(to + stride*13, from, 13);
+  vst1q_lane_s8(to + stride*14, from, 14);
+  vst1q_lane_s8(to + stride*15, from, 15);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint8_t, Packet4uc>(uint8_t* to, const Packet4uc& from, Index stride)
+{
+  for (int i = 0; i != 4; i++)
+    *(to + i * stride) = reinterpret_cast<const uint8_t*>(&from)[i];
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint8_t, Packet8uc>(uint8_t* to, const Packet8uc& from, Index stride)
+{
+  vst1_lane_u8(to + stride*0, from, 0);
+  vst1_lane_u8(to + stride*1, from, 1);
+  vst1_lane_u8(to + stride*2, from, 2);
+  vst1_lane_u8(to + stride*3, from, 3);
+  vst1_lane_u8(to + stride*4, from, 4);
+  vst1_lane_u8(to + stride*5, from, 5);
+  vst1_lane_u8(to + stride*6, from, 6);
+  vst1_lane_u8(to + stride*7, from, 7);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint8_t, Packet16uc>(uint8_t* to, const Packet16uc& from, Index stride)
+{
+  vst1q_lane_u8(to + stride*0, from, 0);
+  vst1q_lane_u8(to + stride*1, from, 1);
+  vst1q_lane_u8(to + stride*2, from, 2);
+  vst1q_lane_u8(to + stride*3, from, 3);
+  vst1q_lane_u8(to + stride*4, from, 4);
+  vst1q_lane_u8(to + stride*5, from, 5);
+  vst1q_lane_u8(to + stride*6, from, 6);
+  vst1q_lane_u8(to + stride*7, from, 7);
+  vst1q_lane_u8(to + stride*8, from, 8);
+  vst1q_lane_u8(to + stride*9, from, 9);
+  vst1q_lane_u8(to + stride*10, from, 10);
+  vst1q_lane_u8(to + stride*11, from, 11);
+  vst1q_lane_u8(to + stride*12, from, 12);
+  vst1q_lane_u8(to + stride*13, from, 13);
+  vst1q_lane_u8(to + stride*14, from, 14);
+  vst1q_lane_u8(to + stride*15, from, 15);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int16_t, Packet4s>(int16_t* to, const Packet4s& from, Index stride)
+{
+  vst1_lane_s16(to + stride*0, from, 0);
+  vst1_lane_s16(to + stride*1, from, 1);
+  vst1_lane_s16(to + stride*2, from, 2);
+  vst1_lane_s16(to + stride*3, from, 3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int16_t, Packet8s>(int16_t* to, const Packet8s& from, Index stride)
+{
+  vst1q_lane_s16(to + stride*0, from, 0);
+  vst1q_lane_s16(to + stride*1, from, 1);
+  vst1q_lane_s16(to + stride*2, from, 2);
+  vst1q_lane_s16(to + stride*3, from, 3);
+  vst1q_lane_s16(to + stride*4, from, 4);
+  vst1q_lane_s16(to + stride*5, from, 5);
+  vst1q_lane_s16(to + stride*6, from, 6);
+  vst1q_lane_s16(to + stride*7, from, 7);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint16_t, Packet4us>(uint16_t* to, const Packet4us& from, Index stride)
+{
+  vst1_lane_u16(to + stride*0, from, 0);
+  vst1_lane_u16(to + stride*1, from, 1);
+  vst1_lane_u16(to + stride*2, from, 2);
+  vst1_lane_u16(to + stride*3, from, 3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint16_t, Packet8us>(uint16_t* to, const Packet8us& from, Index stride)
+{
+  vst1q_lane_u16(to + stride*0, from, 0);
+  vst1q_lane_u16(to + stride*1, from, 1);
+  vst1q_lane_u16(to + stride*2, from, 2);
+  vst1q_lane_u16(to + stride*3, from, 3);
+  vst1q_lane_u16(to + stride*4, from, 4);
+  vst1q_lane_u16(to + stride*5, from, 5);
+  vst1q_lane_u16(to + stride*6, from, 6);
+  vst1q_lane_u16(to + stride*7, from, 7);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int32_t, Packet2i>(int32_t* to, const Packet2i& from, Index stride)
+{
+  vst1_lane_s32(to + stride*0, from, 0);
+  vst1_lane_s32(to + stride*1, from, 1);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int32_t, Packet4i>(int32_t* to, const Packet4i& from, Index stride)
+{
+  vst1q_lane_s32(to + stride*0, from, 0);
+  vst1q_lane_s32(to + stride*1, from, 1);
+  vst1q_lane_s32(to + stride*2, from, 2);
+  vst1q_lane_s32(to + stride*3, from, 3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint32_t, Packet2ui>(uint32_t* to, const Packet2ui& from, Index stride)
+{
+  vst1_lane_u32(to + stride*0, from, 0);
+  vst1_lane_u32(to + stride*1, from, 1);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint32_t, Packet4ui>(uint32_t* to, const Packet4ui& from, Index stride)
+{
+  vst1q_lane_u32(to + stride*0, from, 0);
+  vst1q_lane_u32(to + stride*1, from, 1);
+  vst1q_lane_u32(to + stride*2, from, 2);
+  vst1q_lane_u32(to + stride*3, from, 3);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<int64_t, Packet2l>(int64_t* to, const Packet2l& from, Index stride)
+{
+  vst1q_lane_s64(to + stride*0, from, 0);
+  vst1q_lane_s64(to + stride*1, from, 1);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<uint64_t, Packet2ul>(uint64_t* to, const Packet2ul& from, Index stride)
+{
+  vst1q_lane_u64(to + stride*0, from, 0);
+  vst1q_lane_u64(to + stride*1, from, 1);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int8_t>(const int8_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<uint8_t>(const uint8_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int16_t>(const int16_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<uint16_t>(const uint16_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int32_t>(const int32_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<uint32_t>(const uint32_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<int64_t>(const int64_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<uint64_t>(const uint64_t* addr) { EIGEN_ARM_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE float pfirst<Packet2f>(const Packet2f& a) { return vget_lane_f32(a,0); }
+template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { return vgetq_lane_f32(a,0); }
+template<> EIGEN_STRONG_INLINE int8_t pfirst<Packet4c>(const Packet4c& a) { return static_cast<int8_t>(a & 0xff); }
+template<> EIGEN_STRONG_INLINE int8_t pfirst<Packet8c>(const Packet8c& a) { return vget_lane_s8(a,0); }
+template<> EIGEN_STRONG_INLINE int8_t pfirst<Packet16c>(const Packet16c& a) { return vgetq_lane_s8(a,0); }
+template<> EIGEN_STRONG_INLINE uint8_t pfirst<Packet4uc>(const Packet4uc& a) { return static_cast<uint8_t>(a & 0xff); }
+template<> EIGEN_STRONG_INLINE uint8_t pfirst<Packet8uc>(const Packet8uc& a) { return vget_lane_u8(a,0); }
+template<> EIGEN_STRONG_INLINE uint8_t pfirst<Packet16uc>(const Packet16uc& a) { return vgetq_lane_u8(a,0); }
+template<> EIGEN_STRONG_INLINE int16_t pfirst<Packet4s>(const Packet4s& a) { return vget_lane_s16(a,0); }
+template<> EIGEN_STRONG_INLINE int16_t pfirst<Packet8s>(const Packet8s& a) { return vgetq_lane_s16(a,0); }
+template<> EIGEN_STRONG_INLINE uint16_t pfirst<Packet4us>(const Packet4us& a) { return vget_lane_u16(a,0); }
+template<> EIGEN_STRONG_INLINE uint16_t pfirst<Packet8us>(const Packet8us& a) { return vgetq_lane_u16(a,0); }
+template<> EIGEN_STRONG_INLINE int32_t pfirst<Packet2i>(const Packet2i& a) { return vget_lane_s32(a,0); }
+template<> EIGEN_STRONG_INLINE int32_t pfirst<Packet4i>(const Packet4i& a) { return vgetq_lane_s32(a,0); }
+template<> EIGEN_STRONG_INLINE uint32_t pfirst<Packet2ui>(const Packet2ui& a) { return vget_lane_u32(a,0); }
+template<> EIGEN_STRONG_INLINE uint32_t pfirst<Packet4ui>(const Packet4ui& a) { return vgetq_lane_u32(a,0); }
+template<> EIGEN_STRONG_INLINE int64_t pfirst<Packet2l>(const Packet2l& a) { return vgetq_lane_s64(a,0); }
+template<> EIGEN_STRONG_INLINE uint64_t pfirst<Packet2ul>(const Packet2ul& a) { return vgetq_lane_u64(a,0); }
+
+template<> EIGEN_STRONG_INLINE Packet2f preverse(const Packet2f& a) { return vrev64_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{
+  const float32x4_t a_r64 = vrev64q_f32(a);
+  return vcombine_f32(vget_high_f32(a_r64), vget_low_f32(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet4c preverse(const Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vrev64_s8(vreinterpret_s8_s32(vdup_n_s32(a)))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c preverse(const Packet8c& a) { return vrev64_s8(a); }
+template<> EIGEN_STRONG_INLINE Packet16c preverse(const Packet16c& a)
+{
+  const int8x16_t a_r64 = vrev64q_s8(a);
+  return vcombine_s8(vget_high_s8(a_r64), vget_low_s8(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet4uc preverse(const Packet4uc& a)
+{ return vget_lane_u32(vreinterpret_u32_u8(vrev64_u8(vreinterpret_u8_u32(vdup_n_u32(a)))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8uc preverse(const Packet8uc& a) { return vrev64_u8(a); }
+template<> EIGEN_STRONG_INLINE Packet16uc preverse(const Packet16uc& a)
+{
+  const uint8x16_t a_r64 = vrev64q_u8(a);
+  return vcombine_u8(vget_high_u8(a_r64), vget_low_u8(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet4s preverse(const Packet4s& a) { return vrev64_s16(a); }
+template<> EIGEN_STRONG_INLINE Packet8s preverse(const Packet8s& a)
+{
+  const int16x8_t a_r64 = vrev64q_s16(a);
+  return vcombine_s16(vget_high_s16(a_r64), vget_low_s16(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet4us preverse(const Packet4us& a) { return vrev64_u16(a); }
+template<> EIGEN_STRONG_INLINE Packet8us preverse(const Packet8us& a)
+{
+  const uint16x8_t a_r64 = vrev64q_u16(a);
+  return vcombine_u16(vget_high_u16(a_r64), vget_low_u16(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet2i preverse(const Packet2i& a) { return vrev64_s32(a); }
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a)
+{
+  const int32x4_t a_r64 = vrev64q_s32(a);
+  return vcombine_s32(vget_high_s32(a_r64), vget_low_s32(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet2ui preverse(const Packet2ui& a) { return vrev64_u32(a); }
+template<> EIGEN_STRONG_INLINE Packet4ui preverse(const Packet4ui& a)
+{
+  const uint32x4_t a_r64 = vrev64q_u32(a);
+  return vcombine_u32(vget_high_u32(a_r64), vget_low_u32(a_r64));
+}
+template<> EIGEN_STRONG_INLINE Packet2l preverse(const Packet2l& a)
+{ return vcombine_s64(vget_high_s64(a), vget_low_s64(a)); }
+template<> EIGEN_STRONG_INLINE Packet2ul preverse(const Packet2ul& a)
+{ return vcombine_u64(vget_high_u64(a), vget_low_u64(a)); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pabs(const Packet2f& a) { return vabs_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { return vabsq_f32(a); }
+template<> EIGEN_STRONG_INLINE Packet4c pabs<Packet4c>(const Packet4c& a)
+{ return vget_lane_s32(vreinterpret_s32_s8(vabs_s8(vreinterpret_s8_s32(vdup_n_s32(a)))), 0); }
+template<> EIGEN_STRONG_INLINE Packet8c pabs(const Packet8c& a) { return vabs_s8(a); }
+template<> EIGEN_STRONG_INLINE Packet16c pabs(const Packet16c& a) { return vabsq_s8(a); }
+template<> EIGEN_STRONG_INLINE Packet4uc pabs(const Packet4uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8uc pabs(const Packet8uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet16uc pabs(const Packet16uc& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4s pabs(const Packet4s& a) { return vabs_s16(a); }
+template<> EIGEN_STRONG_INLINE Packet8s pabs(const Packet8s& a) { return vabsq_s16(a); }
+template<> EIGEN_STRONG_INLINE Packet4us pabs(const Packet4us& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet8us pabs(const Packet8us& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2i pabs(const Packet2i& a) { return vabs_s32(a); }
+template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { return vabsq_s32(a); }
+template<> EIGEN_STRONG_INLINE Packet2ui pabs(const Packet2ui& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4ui pabs(const Packet4ui& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2l pabs(const Packet2l& a) {
+#if EIGEN_ARCH_ARM64
+  return vabsq_s64(a);
+#else
+  return vcombine_s64(
+      vdup_n_s64((std::abs)(vgetq_lane_s64(a, 0))),
+      vdup_n_s64((std::abs)(vgetq_lane_s64(a, 1))));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2ul pabs(const Packet2ul& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet2f pfrexp<Packet2f>(const Packet2f& a, Packet2f& exponent)
+{ return pfrexp_generic(a,exponent); }
+template<> EIGEN_STRONG_INLINE Packet4f pfrexp<Packet4f>(const Packet4f& a, Packet4f& exponent)
+{ return pfrexp_generic(a,exponent); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pldexp<Packet2f>(const Packet2f& a, const Packet2f& exponent)
+{ return pldexp_generic(a,exponent); }
+template<> EIGEN_STRONG_INLINE Packet4f pldexp<Packet4f>(const Packet4f& a, const Packet4f& exponent)
+{ return pldexp_generic(a,exponent); }
+
+template<> EIGEN_STRONG_INLINE float predux<Packet2f>(const Packet2f& a) { return vget_lane_f32(vpadd_f32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  const float32x2_t sum = vadd_f32(vget_low_f32(a), vget_high_f32(a));
+  return vget_lane_f32(vpadd_f32(sum, sum), 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux<Packet4c>(const Packet4c& a)
+{
+  const int8x8_t a_dup = vreinterpret_s8_s32(vdup_n_s32(a));
+  int8x8_t sum = vpadd_s8(a_dup, a_dup);
+  sum = vpadd_s8(sum, sum);
+  return vget_lane_s8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux<Packet8c>(const Packet8c& a)
+{
+  int8x8_t sum = vpadd_s8(a,a);
+  sum = vpadd_s8(sum, sum);
+  sum = vpadd_s8(sum, sum);
+  return vget_lane_s8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux<Packet16c>(const Packet16c& a)
+{
+  int8x8_t sum = vadd_s8(vget_low_s8(a), vget_high_s8(a));
+  sum = vpadd_s8(sum, sum);
+  sum = vpadd_s8(sum, sum);
+  sum = vpadd_s8(sum, sum);
+  return vget_lane_s8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux<Packet4uc>(const Packet4uc& a)
+{
+  const uint8x8_t a_dup = vreinterpret_u8_u32(vdup_n_u32(a));
+  uint8x8_t sum = vpadd_u8(a_dup, a_dup);
+  sum = vpadd_u8(sum, sum);
+  return vget_lane_u8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux<Packet8uc>(const Packet8uc& a)
+{
+  uint8x8_t sum = vpadd_u8(a,a);
+  sum = vpadd_u8(sum, sum);
+  sum = vpadd_u8(sum, sum);
+  return vget_lane_u8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux<Packet16uc>(const Packet16uc& a)
+{
+  uint8x8_t sum = vadd_u8(vget_low_u8(a), vget_high_u8(a));
+  sum = vpadd_u8(sum, sum);
+  sum = vpadd_u8(sum, sum);
+  sum = vpadd_u8(sum, sum);
+  return vget_lane_u8(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux<Packet4s>(const Packet4s& a)
+{
+  const int16x4_t sum = vpadd_s16(a,a);
+  return vget_lane_s16(vpadd_s16(sum, sum), 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux<Packet8s>(const Packet8s& a)
+{
+  int16x4_t sum = vadd_s16(vget_low_s16(a), vget_high_s16(a));
+  sum = vpadd_s16(sum, sum);
+  sum = vpadd_s16(sum, sum);
+  return vget_lane_s16(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux<Packet4us>(const Packet4us& a)
+{
+  const uint16x4_t sum = vpadd_u16(a,a);
+  return vget_lane_u16(vpadd_u16(sum, sum), 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux<Packet8us>(const Packet8us& a)
+{
+  uint16x4_t sum = vadd_u16(vget_low_u16(a), vget_high_u16(a));
+  sum = vpadd_u16(sum, sum);
+  sum = vpadd_u16(sum, sum);
+  return vget_lane_u16(sum, 0);
+}
+template<> EIGEN_STRONG_INLINE int32_t predux<Packet2i>(const Packet2i& a) { return vget_lane_s32(vpadd_s32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE int32_t predux<Packet4i>(const Packet4i& a)
+{
+  const int32x2_t sum = vadd_s32(vget_low_s32(a), vget_high_s32(a));
+  return vget_lane_s32(vpadd_s32(sum, sum), 0);
+}
+template<> EIGEN_STRONG_INLINE uint32_t predux<Packet2ui>(const Packet2ui& a) { return vget_lane_u32(vpadd_u32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE uint32_t predux<Packet4ui>(const Packet4ui& a)
+{
+  const uint32x2_t sum = vadd_u32(vget_low_u32(a), vget_high_u32(a));
+  return vget_lane_u32(vpadd_u32(sum, sum), 0);
+}
+template<> EIGEN_STRONG_INLINE int64_t predux<Packet2l>(const Packet2l& a)
+{ return vgetq_lane_s64(a, 0) + vgetq_lane_s64(a, 1); }
+template<> EIGEN_STRONG_INLINE uint64_t predux<Packet2ul>(const Packet2ul& a)
+{ return vgetq_lane_u64(a, 0) + vgetq_lane_u64(a, 1); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4c predux_half_dowto4(const Packet8c& a)
+{
+  return vget_lane_s32(vreinterpret_s32_s8(vadd_s8(a,
+      vreinterpret_s8_s32(vrev64_s32(vreinterpret_s32_s8(a))))), 0);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c predux_half_dowto4(const Packet16c& a)
+{ return vadd_s8(vget_high_s8(a), vget_low_s8(a)); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4uc predux_half_dowto4(const Packet8uc& a)
+{
+  return vget_lane_u32(vreinterpret_u32_u8(vadd_u8(a,
+      vreinterpret_u8_u32(vrev64_u32(vreinterpret_u32_u8(a))))), 0);
+}
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc predux_half_dowto4(const Packet16uc& a)
+{ return vadd_u8(vget_high_u8(a), vget_low_u8(a)); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s predux_half_dowto4(const Packet8s& a)
+{ return vadd_s16(vget_high_s16(a), vget_low_s16(a)); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us predux_half_dowto4(const Packet8us& a)
+{ return vadd_u16(vget_high_u16(a), vget_low_u16(a)); }
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet2f>(const Packet2f& a)
+{ return vget_lane_f32(a, 0) * vget_lane_f32(a, 1); }
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{ return predux_mul(vmul_f32(vget_low_f32(a), vget_high_f32(a))); }
+template<> EIGEN_STRONG_INLINE int8_t predux_mul<Packet4c>(const Packet4c& a)
+{
+  int8x8_t prod = vreinterpret_s8_s32(vdup_n_s32(a));
+  prod = vmul_s8(prod, vrev16_s8(prod));
+  return vget_lane_s8(prod, 0) * vget_lane_s8(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_mul<Packet8c>(const Packet8c& a)
+{
+  int8x8_t prod = vmul_s8(a, vrev16_s8(a));
+  prod = vmul_s8(prod, vrev32_s8(prod));
+  return vget_lane_s8(prod, 0) * vget_lane_s8(prod, 4);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_mul<Packet16c>(const Packet16c& a)
+{ return predux_mul(vmul_s8(vget_low_s8(a), vget_high_s8(a))); }
+template<> EIGEN_STRONG_INLINE uint8_t predux_mul<Packet4uc>(const Packet4uc& a)
+{
+  uint8x8_t prod = vreinterpret_u8_u32(vdup_n_u32(a));
+  prod = vmul_u8(prod, vrev16_u8(prod));
+  return vget_lane_u8(prod, 0) * vget_lane_u8(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_mul<Packet8uc>(const Packet8uc& a)
+{
+  uint8x8_t prod = vmul_u8(a, vrev16_u8(a));
+  prod = vmul_u8(prod, vrev32_u8(prod));
+  return vget_lane_u8(prod, 0) * vget_lane_u8(prod, 4);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_mul<Packet16uc>(const Packet16uc& a)
+{ return predux_mul(vmul_u8(vget_low_u8(a), vget_high_u8(a))); }
+template<> EIGEN_STRONG_INLINE int16_t predux_mul<Packet4s>(const Packet4s& a)
+{
+  const int16x4_t prod = vmul_s16(a, vrev32_s16(a));
+  return vget_lane_s16(prod, 0) * vget_lane_s16(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux_mul<Packet8s>(const Packet8s& a)
+{
+  int16x4_t prod;
+
+  // Get the product of a_lo * a_hi -> |a1*a5|a2*a6|a3*a7|a4*a8|
+  prod = vmul_s16(vget_low_s16(a), vget_high_s16(a));
+  // Swap and multiply |a1*a5*a2*a6|a3*a7*a4*a8|
+  prod = vmul_s16(prod, vrev32_s16(prod));
+  // Multiply |a1*a5*a2*a6*a3*a7*a4*a8|
+  return vget_lane_s16(prod, 0) * vget_lane_s16(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_mul<Packet4us>(const Packet4us& a)
+{
+  const uint16x4_t prod = vmul_u16(a, vrev32_u16(a));
+  return vget_lane_u16(prod, 0) * vget_lane_u16(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_mul<Packet8us>(const Packet8us& a)
+{
+  uint16x4_t prod;
+
+  // Get the product of a_lo * a_hi -> |a1*a5|a2*a6|a3*a7|a4*a8|
+  prod = vmul_u16(vget_low_u16(a), vget_high_u16(a));
+  // Swap and multiply |a1*a5*a2*a6|a3*a7*a4*a8|
+  prod = vmul_u16(prod, vrev32_u16(prod));
+  // Multiply |a1*a5*a2*a6*a3*a7*a4*a8|
+  return vget_lane_u16(prod, 0) * vget_lane_u16(prod, 2);
+}
+template<> EIGEN_STRONG_INLINE int32_t predux_mul<Packet2i>(const Packet2i& a)
+{ return vget_lane_s32(a, 0) * vget_lane_s32(a, 1); }
+template<> EIGEN_STRONG_INLINE int32_t predux_mul<Packet4i>(const Packet4i& a)
+{ return predux_mul(vmul_s32(vget_low_s32(a), vget_high_s32(a))); }
+template<> EIGEN_STRONG_INLINE uint32_t predux_mul<Packet2ui>(const Packet2ui& a)
+{ return vget_lane_u32(a, 0) * vget_lane_u32(a, 1); }
+template<> EIGEN_STRONG_INLINE uint32_t predux_mul<Packet4ui>(const Packet4ui& a)
+{ return predux_mul(vmul_u32(vget_low_u32(a), vget_high_u32(a))); }
+template<> EIGEN_STRONG_INLINE int64_t predux_mul<Packet2l>(const Packet2l& a)
+{ return vgetq_lane_s64(a, 0) * vgetq_lane_s64(a, 1); }
+template<> EIGEN_STRONG_INLINE uint64_t predux_mul<Packet2ul>(const Packet2ul& a)
+{ return vgetq_lane_u64(a, 0) * vgetq_lane_u64(a, 1); }
+
+// min
+template<> EIGEN_STRONG_INLINE float predux_min<Packet2f>(const Packet2f& a)
+{ return vget_lane_f32(vpmin_f32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  const float32x2_t min = vmin_f32(vget_low_f32(a), vget_high_f32(a));
+  return vget_lane_f32(vpmin_f32(min, min), 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_min<Packet4c>(const Packet4c& a)
+{
+  const int8x8_t a_dup = vreinterpret_s8_s32(vdup_n_s32(a));
+  int8x8_t min = vpmin_s8(a_dup, a_dup);
+  min = vpmin_s8(min, min);
+  return vget_lane_s8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_min<Packet8c>(const Packet8c& a)
+{
+  int8x8_t min = vpmin_s8(a,a);
+  min = vpmin_s8(min, min);
+  min = vpmin_s8(min, min);
+  return vget_lane_s8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_min<Packet16c>(const Packet16c& a)
+{
+  int8x8_t min = vmin_s8(vget_low_s8(a), vget_high_s8(a));
+  min = vpmin_s8(min, min);
+  min = vpmin_s8(min, min);
+  min = vpmin_s8(min, min);
+  return vget_lane_s8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_min<Packet4uc>(const Packet4uc& a)
+{
+  const uint8x8_t a_dup = vreinterpret_u8_u32(vdup_n_u32(a));
+  uint8x8_t min = vpmin_u8(a_dup, a_dup);
+  min = vpmin_u8(min, min);
+  return vget_lane_u8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_min<Packet8uc>(const Packet8uc& a)
+{
+  uint8x8_t min = vpmin_u8(a,a);
+  min = vpmin_u8(min, min);
+  min = vpmin_u8(min, min);
+  return vget_lane_u8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_min<Packet16uc>(const Packet16uc& a)
+{
+  uint8x8_t min = vmin_u8(vget_low_u8(a), vget_high_u8(a));
+  min = vpmin_u8(min, min);
+  min = vpmin_u8(min, min);
+  min = vpmin_u8(min, min);
+  return vget_lane_u8(min, 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux_min<Packet4s>(const Packet4s& a)
+{
+  const int16x4_t min = vpmin_s16(a,a);
+  return vget_lane_s16(vpmin_s16(min, min), 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux_min<Packet8s>(const Packet8s& a)
+{
+  int16x4_t min = vmin_s16(vget_low_s16(a), vget_high_s16(a));
+  min = vpmin_s16(min, min);
+  min = vpmin_s16(min, min);
+  return vget_lane_s16(min, 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_min<Packet4us>(const Packet4us& a)
+{
+  const uint16x4_t min = vpmin_u16(a,a);
+  return vget_lane_u16(vpmin_u16(min, min), 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_min<Packet8us>(const Packet8us& a)
+{
+  uint16x4_t min = vmin_u16(vget_low_u16(a), vget_high_u16(a));
+  min = vpmin_u16(min, min);
+  min = vpmin_u16(min, min);
+  return vget_lane_u16(min, 0);
+}
+template<> EIGEN_STRONG_INLINE int32_t predux_min<Packet2i>(const Packet2i& a)
+{ return vget_lane_s32(vpmin_s32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE int32_t predux_min<Packet4i>(const Packet4i& a)
+{
+  const int32x2_t min = vmin_s32(vget_low_s32(a), vget_high_s32(a));
+  return vget_lane_s32(vpmin_s32(min, min), 0);
+}
+template<> EIGEN_STRONG_INLINE uint32_t predux_min<Packet2ui>(const Packet2ui& a)
+{ return vget_lane_u32(vpmin_u32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE uint32_t predux_min<Packet4ui>(const Packet4ui& a)
+{
+  const uint32x2_t min = vmin_u32(vget_low_u32(a), vget_high_u32(a));
+  return vget_lane_u32(vpmin_u32(min, min), 0);
+}
+template<> EIGEN_STRONG_INLINE int64_t predux_min<Packet2l>(const Packet2l& a)
+{ return (std::min)(vgetq_lane_s64(a, 0), vgetq_lane_s64(a, 1)); }
+template<> EIGEN_STRONG_INLINE uint64_t predux_min<Packet2ul>(const Packet2ul& a)
+{ return (std::min)(vgetq_lane_u64(a, 0), vgetq_lane_u64(a, 1)); }
+
+// max
+template<> EIGEN_STRONG_INLINE float predux_max<Packet2f>(const Packet2f& a)
+{ return vget_lane_f32(vpmax_f32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  const float32x2_t max = vmax_f32(vget_low_f32(a), vget_high_f32(a));
+  return vget_lane_f32(vpmax_f32(max, max), 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_max<Packet4c>(const Packet4c& a)
+{
+  const int8x8_t a_dup = vreinterpret_s8_s32(vdup_n_s32(a));
+  int8x8_t max = vpmax_s8(a_dup, a_dup);
+  max = vpmax_s8(max, max);
+  return vget_lane_s8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_max<Packet8c>(const Packet8c& a)
+{
+  int8x8_t max = vpmax_s8(a,a);
+  max = vpmax_s8(max, max);
+  max = vpmax_s8(max, max);
+  return vget_lane_s8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE int8_t predux_max<Packet16c>(const Packet16c& a)
+{
+  int8x8_t max = vmax_s8(vget_low_s8(a), vget_high_s8(a));
+  max = vpmax_s8(max, max);
+  max = vpmax_s8(max, max);
+  max = vpmax_s8(max, max);
+  return vget_lane_s8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_max<Packet4uc>(const Packet4uc& a)
+{
+  const uint8x8_t a_dup = vreinterpret_u8_u32(vdup_n_u32(a));
+  uint8x8_t max = vpmax_u8(a_dup, a_dup);
+  max = vpmax_u8(max, max);
+  return vget_lane_u8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_max<Packet8uc>(const Packet8uc& a)
+{
+  uint8x8_t max = vpmax_u8(a,a);
+  max = vpmax_u8(max, max);
+  max = vpmax_u8(max, max);
+  return vget_lane_u8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE uint8_t predux_max<Packet16uc>(const Packet16uc& a)
+{
+  uint8x8_t max = vmax_u8(vget_low_u8(a), vget_high_u8(a));
+  max = vpmax_u8(max, max);
+  max = vpmax_u8(max, max);
+  max = vpmax_u8(max, max);
+  return vget_lane_u8(max, 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux_max<Packet4s>(const Packet4s& a)
+{
+  const int16x4_t max = vpmax_s16(a,a);
+  return vget_lane_s16(vpmax_s16(max, max), 0);
+}
+template<> EIGEN_STRONG_INLINE int16_t predux_max<Packet8s>(const Packet8s& a)
+{
+  int16x4_t max = vmax_s16(vget_low_s16(a), vget_high_s16(a));
+  max = vpmax_s16(max, max);
+  max = vpmax_s16(max, max);
+  return vget_lane_s16(max, 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_max<Packet4us>(const Packet4us& a)
+{
+  const uint16x4_t max = vpmax_u16(a,a);
+  return vget_lane_u16(vpmax_u16(max, max), 0);
+}
+template<> EIGEN_STRONG_INLINE uint16_t predux_max<Packet8us>(const Packet8us& a)
+{
+  uint16x4_t max = vmax_u16(vget_low_u16(a), vget_high_u16(a));
+  max = vpmax_u16(max, max);
+  max = vpmax_u16(max, max);
+  return vget_lane_u16(max, 0);
+}
+template<> EIGEN_STRONG_INLINE int32_t predux_max<Packet2i>(const Packet2i& a)
+{ return vget_lane_s32(vpmax_s32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE int32_t predux_max<Packet4i>(const Packet4i& a)
+{
+  const int32x2_t max = vmax_s32(vget_low_s32(a), vget_high_s32(a));
+  return vget_lane_s32(vpmax_s32(max, max), 0);
+}
+template<> EIGEN_STRONG_INLINE uint32_t predux_max<Packet2ui>(const Packet2ui& a)
+{ return vget_lane_u32(vpmax_u32(a,a), 0); }
+template<> EIGEN_STRONG_INLINE uint32_t predux_max<Packet4ui>(const Packet4ui& a)
+{
+  const uint32x2_t max = vmax_u32(vget_low_u32(a), vget_high_u32(a));
+  return vget_lane_u32(vpmax_u32(max, max), 0);
+}
+template<> EIGEN_STRONG_INLINE int64_t predux_max<Packet2l>(const Packet2l& a)
+{ return (std::max)(vgetq_lane_s64(a, 0), vgetq_lane_s64(a, 1)); }
+template<> EIGEN_STRONG_INLINE uint64_t predux_max<Packet2ul>(const Packet2ul& a)
+{ return (std::max)(vgetq_lane_u64(a, 0), vgetq_lane_u64(a, 1)); }
+
+template<> EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x)
+{
+  uint32x2_t tmp = vorr_u32(vget_low_u32( vreinterpretq_u32_f32(x)),
+                            vget_high_u32(vreinterpretq_u32_f32(x)));
+  return vget_lane_u32(vpmax_u32(tmp, tmp), 0);
+}
+
+// Helpers for ptranspose.
+namespace detail {
+  
+template<typename Packet>
+void zip_in_place(Packet& p1, Packet& p2);
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet2f>(Packet2f& p1, Packet2f& p2) {
+  const float32x2x2_t tmp = vzip_f32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4f>(Packet4f& p1, Packet4f& p2) {
+  const float32x4x2_t tmp = vzipq_f32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet8c>(Packet8c& p1, Packet8c& p2) {
+  const int8x8x2_t tmp = vzip_s8(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet16c>(Packet16c& p1, Packet16c& p2) {
+  const int8x16x2_t tmp = vzipq_s8(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet8uc>(Packet8uc& p1, Packet8uc& p2) {
+  const uint8x8x2_t tmp = vzip_u8(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet16uc>(Packet16uc& p1, Packet16uc& p2) {
+  const uint8x16x2_t tmp = vzipq_u8(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet2i>(Packet2i& p1, Packet2i& p2) {
+  const int32x2x2_t tmp = vzip_s32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4i>(Packet4i& p1, Packet4i& p2) {
+  const int32x4x2_t tmp = vzipq_s32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet2ui>(Packet2ui& p1, Packet2ui& p2) {
+  const uint32x2x2_t tmp = vzip_u32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4ui>(Packet4ui& p1, Packet4ui& p2) {
+  const uint32x4x2_t tmp = vzipq_u32(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4s>(Packet4s& p1, Packet4s& p2) {
+  const int16x4x2_t tmp = vzip_s16(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet8s>(Packet8s& p1, Packet8s& p2) {
+  const int16x8x2_t tmp = vzipq_s16(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4us>(Packet4us& p1, Packet4us& p2) {
+  const uint16x4x2_t tmp = vzip_u16(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet8us>(Packet8us& p1, Packet8us& p2) {
+  const uint16x8x2_t tmp = vzipq_u16(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void ptranspose_impl(PacketBlock<Packet, 2>& kernel) {
+  zip_in_place(kernel.packet[0], kernel.packet[1]);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void ptranspose_impl(PacketBlock<Packet, 4>& kernel) {
+  zip_in_place(kernel.packet[0], kernel.packet[2]);
+  zip_in_place(kernel.packet[1], kernel.packet[3]);
+  zip_in_place(kernel.packet[0], kernel.packet[1]);
+  zip_in_place(kernel.packet[2], kernel.packet[3]);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void ptranspose_impl(PacketBlock<Packet, 8>& kernel) {
+  zip_in_place(kernel.packet[0], kernel.packet[4]);
+  zip_in_place(kernel.packet[1], kernel.packet[5]);
+  zip_in_place(kernel.packet[2], kernel.packet[6]);
+  zip_in_place(kernel.packet[3], kernel.packet[7]);
+
+  zip_in_place(kernel.packet[0], kernel.packet[2]);
+  zip_in_place(kernel.packet[1], kernel.packet[3]);
+  zip_in_place(kernel.packet[4], kernel.packet[6]);
+  zip_in_place(kernel.packet[5], kernel.packet[7]);
+  
+  zip_in_place(kernel.packet[0], kernel.packet[1]);
+  zip_in_place(kernel.packet[2], kernel.packet[3]);
+  zip_in_place(kernel.packet[4], kernel.packet[5]);
+  zip_in_place(kernel.packet[6], kernel.packet[7]);
+}
+
+template<typename Packet>
+EIGEN_ALWAYS_INLINE void ptranspose_impl(PacketBlock<Packet, 16>& kernel) {
+  EIGEN_UNROLL_LOOP
+  for (int i=0; i<4; ++i) {
+    const int m = (1 << i);
+    EIGEN_UNROLL_LOOP
+    for (int j=0; j<m; ++j) {
+      const int n = (1 << (3-i));
+      EIGEN_UNROLL_LOOP
+      for (int k=0; k<n; ++k) {
+        const int idx = 2*j*n+k;
+        zip_in_place(kernel.packet[idx], kernel.packet[idx + n]);
+      }
+    }
+  }
+}
+
+} // namespace detail
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2f, 2>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4f, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4c, 4>& kernel)
+{
+  const int8x8_t a = vreinterpret_s8_s32(vset_lane_s32(kernel.packet[2], vdup_n_s32(kernel.packet[0]), 1));
+  const int8x8_t b = vreinterpret_s8_s32(vset_lane_s32(kernel.packet[3], vdup_n_s32(kernel.packet[1]), 1));
+
+  const int8x8x2_t zip8 = vzip_s8(a,b);
+  const int16x4x2_t zip16 = vzip_s16(vreinterpret_s16_s8(zip8.val[0]), vreinterpret_s16_s8(zip8.val[1]));
+
+  kernel.packet[0] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[0]), 0);
+  kernel.packet[1] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[0]), 1);
+  kernel.packet[2] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[1]), 0);
+  kernel.packet[3] = vget_lane_s32(vreinterpret_s32_s16(zip16.val[1]), 1);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8c, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8c, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16c, 16>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16c, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16c, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4uc, 4>& kernel)
+{
+  const uint8x8_t a = vreinterpret_u8_u32(vset_lane_u32(kernel.packet[2], vdup_n_u32(kernel.packet[0]), 1));
+  const uint8x8_t b = vreinterpret_u8_u32(vset_lane_u32(kernel.packet[3], vdup_n_u32(kernel.packet[1]), 1));
+
+  const uint8x8x2_t zip8 = vzip_u8(a,b);
+  const uint16x4x2_t zip16 = vzip_u16(vreinterpret_u16_u8(zip8.val[0]), vreinterpret_u16_u8(zip8.val[1]));
+
+  kernel.packet[0] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[0]), 0);
+  kernel.packet[1] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[0]), 1);
+  kernel.packet[2] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[1]), 0);
+  kernel.packet[3] = vget_lane_u32(vreinterpret_u32_u16(zip16.val[1]), 1);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8uc, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8uc, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16uc, 16>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16uc, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16uc, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4s, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8s, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8s, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4us, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8us, 8>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8us, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2i, 2>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4i, 4>& kernel) {
+    detail::ptranspose_impl(kernel);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2ui, 2>& kernel) {
+  detail::zip_in_place(kernel.packet[0], kernel.packet[1]);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4ui, 4>& kernel) {
+  detail::ptranspose_impl(kernel);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet2l, 2>& kernel)
+{
+#if EIGEN_ARCH_ARM64
+  const int64x2_t tmp1 = vzip1q_s64(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[1] = vzip2q_s64(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[0] = tmp1;
+#else
+  const int64x1_t tmp[2][2] = {
+    { vget_low_s64(kernel.packet[0]), vget_high_s64(kernel.packet[0]) },
+    { vget_low_s64(kernel.packet[1]), vget_high_s64(kernel.packet[1]) }
+  };
+
+  kernel.packet[0] = vcombine_s64(tmp[0][0], tmp[1][0]);
+  kernel.packet[1] = vcombine_s64(tmp[0][1], tmp[1][1]);
+#endif
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet2ul, 2>& kernel)
+{
+#if EIGEN_ARCH_ARM64
+  const uint64x2_t tmp1 = vzip1q_u64(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[1] = vzip2q_u64(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[0] = tmp1;
+#else
+  const uint64x1_t tmp[2][2] = {
+    { vget_low_u64(kernel.packet[0]), vget_high_u64(kernel.packet[0]) },
+    { vget_low_u64(kernel.packet[1]), vget_high_u64(kernel.packet[1]) }
+  };
+
+  kernel.packet[0] = vcombine_u64(tmp[0][0], tmp[1][0]);
+  kernel.packet[1] = vcombine_u64(tmp[0][1], tmp[1][1]);
+#endif
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f pselect( const Packet2f& mask, const Packet2f& a, const Packet2f& b)
+{ return vbsl_f32(vreinterpret_u32_f32(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f pselect(const Packet4f& mask, const Packet4f& a, const Packet4f& b)
+{ return vbslq_f32(vreinterpretq_u32_f32(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8c pselect(const Packet8c& mask, const Packet8c& a, const Packet8c& b)
+{ return vbsl_s8(vreinterpret_u8_s8(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16c pselect(const Packet16c& mask, const Packet16c& a, const Packet16c& b)
+{ return vbslq_s8(vreinterpretq_u8_s8(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8uc pselect(const Packet8uc& mask, const Packet8uc& a, const Packet8uc& b)
+{ return vbsl_u8(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet16uc pselect(const Packet16uc& mask, const Packet16uc& a, const Packet16uc& b)
+{ return vbslq_u8(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4s pselect(const Packet4s& mask, const Packet4s& a, const Packet4s& b)
+{ return vbsl_s16(vreinterpret_u16_s16(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8s pselect(const Packet8s& mask, const Packet8s& a, const Packet8s& b)
+{ return vbslq_s16(vreinterpretq_u16_s16(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4us pselect(const Packet4us& mask, const Packet4us& a, const Packet4us& b)
+{ return vbsl_u16(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8us pselect(const Packet8us& mask, const Packet8us& a, const Packet8us& b)
+{ return vbslq_u16(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i pselect(const Packet2i& mask, const Packet2i& a, const Packet2i& b)
+{ return vbsl_s32(vreinterpret_u32_s32(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i pselect(const Packet4i& mask, const Packet4i& a, const Packet4i& b)
+{ return vbslq_s32(vreinterpretq_u32_s32(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ui pselect(const Packet2ui& mask, const Packet2ui& a, const Packet2ui& b)
+{ return vbsl_u32(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4ui pselect(const Packet4ui& mask, const Packet4ui& a, const Packet4ui& b)
+{ return vbslq_u32(mask, a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2l pselect(const Packet2l& mask, const Packet2l& a, const Packet2l& b)
+{ return vbslq_s64(vreinterpretq_u64_s64(mask), a, b); }
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2ul pselect(const Packet2ul& mask, const Packet2ul& a, const Packet2ul& b)
+{ return vbslq_u64(mask, a, b); }
+
+// Use armv8 rounding intinsics if available.
+#if EIGEN_ARCH_ARMV8
+template<> EIGEN_STRONG_INLINE Packet2f print<Packet2f>(const Packet2f& a)
+{ return vrndn_f32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f print<Packet4f>(const Packet4f& a)
+{ return vrndnq_f32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pfloor<Packet2f>(const Packet2f& a)
+{ return vrndm_f32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a)
+{ return vrndmq_f32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2f pceil<Packet2f>(const Packet2f& a)
+{ return vrndp_f32(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a)
+{ return vrndpq_f32(a); }
+
+#else
+
+template<> EIGEN_STRONG_INLINE Packet4f print(const Packet4f& a) {
+  // Adds and subtracts signum(a) * 2^23 to force rounding.
+  const Packet4f limit = pset1<Packet4f>(static_cast<float>(1<<23));
+  const Packet4f abs_a = pabs(a);
+  Packet4f r = padd(abs_a, limit);
+  // Don't compile-away addition and subtraction.
+  EIGEN_OPTIMIZATION_BARRIER(r);
+  r = psub(r, limit);
+  // If greater than limit, simply return a.  Otherwise, account for sign.
+  r = pselect(pcmp_lt(abs_a, limit),
+              pselect(pcmp_lt(a, pzero(a)), pnegate(r), r), a);
+  return r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f print(const Packet2f& a) {
+  // Adds and subtracts signum(a) * 2^23 to force rounding.
+  const Packet2f limit = pset1<Packet2f>(static_cast<float>(1<<23));
+  const Packet2f abs_a = pabs(a);
+  Packet2f r = padd(abs_a, limit);
+  // Don't compile-away addition and subtraction.
+  EIGEN_OPTIMIZATION_BARRIER(r);
+  r = psub(r, limit);
+  // If greater than limit, simply return a.  Otherwise, account for sign.
+  r = pselect(pcmp_lt(abs_a, limit),
+              pselect(pcmp_lt(a, pzero(a)), pnegate(r), r), a);
+  return r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a)
+{
+  const Packet4f cst_1 = pset1<Packet4f>(1.0f);
+  Packet4f tmp  = print<Packet4f>(a);
+  // If greater, subtract one.
+  Packet4f mask = pcmp_lt(a, tmp);
+  mask = pand(mask, cst_1);
+  return psub(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pfloor<Packet2f>(const Packet2f& a)
+{
+  const Packet2f cst_1 = pset1<Packet2f>(1.0f);
+  Packet2f tmp  = print<Packet2f>(a);
+  // If greater, subtract one.
+  Packet2f mask = pcmp_lt(a, tmp);
+  mask = pand(mask, cst_1);
+  return psub(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a)
+{
+  const Packet4f cst_1 = pset1<Packet4f>(1.0f);
+  Packet4f tmp  = print<Packet4f>(a);
+  // If smaller, add one.
+  Packet4f mask = pcmp_lt(tmp, a);
+  mask = pand(mask, cst_1);
+  return padd(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f pceil<Packet2f>(const Packet2f& a)
+{
+  const Packet2f cst_1 = pset1<Packet2f>(1.0);
+  Packet2f tmp  = print<Packet2f>(a);
+  // If smaller, add one.
+  Packet2f mask = pcmp_lt(tmp, a);
+  mask = pand(mask, cst_1);
+  return padd(tmp, mask);
+}
+
+#endif
+
+/**
+ * Computes the integer square root
+ * @remarks The calculation is performed using an algorithm which iterates through each binary digit of the result
+ *   and tests whether setting that digit to 1 would cause the square of the value to be greater than the argument
+ *   value. The algorithm is described in detail here: http://ww1.microchip.com/downloads/en/AppNotes/91040a.pdf .
+ */
+template<> EIGEN_STRONG_INLINE Packet4uc psqrt(const Packet4uc& a) {
+  uint8x8_t x = vreinterpret_u8_u32(vdup_n_u32(a));
+  uint8x8_t res = vdup_n_u8(0);
+  uint8x8_t add = vdup_n_u8(0x8);
+  for (int i = 0; i < 4; i++)
+  {
+    const uint8x8_t temp = vorr_u8(res, add);
+    res = vbsl_u8(vcge_u8(x, vmul_u8(temp, temp)), temp, res);
+    add = vshr_n_u8(add, 1);
+  }
+  return vget_lane_u32(vreinterpret_u32_u8(res), 0);
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet8uc psqrt(const Packet8uc& a) {
+  uint8x8_t res = vdup_n_u8(0);
+  uint8x8_t add = vdup_n_u8(0x8);
+  for (int i = 0; i < 4; i++)
+  {
+    const uint8x8_t temp = vorr_u8(res, add);
+    res = vbsl_u8(vcge_u8(a, vmul_u8(temp, temp)), temp, res);
+    add = vshr_n_u8(add, 1);
+  }
+  return res;
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet16uc psqrt(const Packet16uc& a) {
+  uint8x16_t res = vdupq_n_u8(0);
+  uint8x16_t add = vdupq_n_u8(0x8);
+  for (int i = 0; i < 4; i++)
+  {
+    const uint8x16_t temp = vorrq_u8(res, add);
+    res = vbslq_u8(vcgeq_u8(a, vmulq_u8(temp, temp)), temp, res);
+    add = vshrq_n_u8(add, 1);
+  }
+  return res;
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet4us psqrt(const Packet4us& a) {
+  uint16x4_t res = vdup_n_u16(0);
+  uint16x4_t add = vdup_n_u16(0x80);
+  for (int i = 0; i < 8; i++)
+  {
+    const uint16x4_t temp = vorr_u16(res, add);
+    res = vbsl_u16(vcge_u16(a, vmul_u16(temp, temp)), temp, res);
+    add = vshr_n_u16(add, 1);
+  }
+  return res;
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet8us psqrt(const Packet8us& a) {
+  uint16x8_t res = vdupq_n_u16(0);
+  uint16x8_t add = vdupq_n_u16(0x80);
+  for (int i = 0; i < 8; i++)
+  {
+    const uint16x8_t temp = vorrq_u16(res, add);
+    res = vbslq_u16(vcgeq_u16(a, vmulq_u16(temp, temp)), temp, res);
+    add = vshrq_n_u16(add, 1);
+  }
+  return res;
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet2ui psqrt(const Packet2ui& a) {
+  uint32x2_t res = vdup_n_u32(0);
+  uint32x2_t add = vdup_n_u32(0x8000);
+  for (int i = 0; i < 16; i++)
+  {
+    const uint32x2_t temp = vorr_u32(res, add);
+    res = vbsl_u32(vcge_u32(a, vmul_u32(temp, temp)), temp, res);
+    add = vshr_n_u32(add, 1);
+  }
+  return res;
+}
+/// @copydoc Eigen::internal::psqrt(const Packet4uc& a)
+template<> EIGEN_STRONG_INLINE Packet4ui psqrt(const Packet4ui& a) {
+  uint32x4_t res = vdupq_n_u32(0);
+  uint32x4_t add = vdupq_n_u32(0x8000);
+  for (int i = 0; i < 16; i++)
+  {
+    const uint32x4_t temp = vorrq_u32(res, add);
+    res = vbslq_u32(vcgeq_u32(a, vmulq_u32(temp, temp)), temp, res);
+    add = vshrq_n_u32(add, 1);
+  }
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f prsqrt(const Packet4f& a) {
+  // Compute approximate reciprocal sqrt.
+  Packet4f x = vrsqrteq_f32(a);
+  // Do Newton iterations for 1/sqrt(x).
+  x = vmulq_f32(vrsqrtsq_f32(vmulq_f32(a, x), x), x);
+  x = vmulq_f32(vrsqrtsq_f32(vmulq_f32(a, x), x), x);
+  const Packet4f infinity = pset1<Packet4f>(NumTraits<float>::infinity());
+  return pselect(pcmp_eq(a, pzero(a)), infinity, x);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2f prsqrt(const Packet2f& a) {
+  // Compute approximate reciprocal sqrt.
+  Packet2f x = vrsqrte_f32(a);
+  // Do Newton iterations for 1/sqrt(x).
+  x = vmul_f32(vrsqrts_f32(vmul_f32(a, x), x), x);
+  x = vmul_f32(vrsqrts_f32(vmul_f32(a, x), x), x);
+  const Packet2f infinity = pset1<Packet2f>(NumTraits<float>::infinity());
+  return pselect(pcmp_eq(a, pzero(a)), infinity, x);
+}
+
+// Unfortunately vsqrt_f32 is only available for A64.
+#if EIGEN_ARCH_ARM64
+template<> EIGEN_STRONG_INLINE Packet4f psqrt(const Packet4f& _x){return vsqrtq_f32(_x);}
+template<> EIGEN_STRONG_INLINE Packet2f psqrt(const Packet2f& _x){return vsqrt_f32(_x); }
+#else
+template<> EIGEN_STRONG_INLINE Packet4f psqrt(const Packet4f& a) {
+  const Packet4f infinity = pset1<Packet4f>(NumTraits<float>::infinity());
+  const Packet4f is_zero_or_inf = por(pcmp_eq(a, pzero(a)), pcmp_eq(a, infinity));
+  return pselect(is_zero_or_inf, a, pmul(a, prsqrt(a)));
+}
+template<> EIGEN_STRONG_INLINE Packet2f psqrt(const Packet2f& a) {
+  const Packet2f infinity = pset1<Packet2f>(NumTraits<float>::infinity());
+  const Packet2f is_zero_or_inf = por(pcmp_eq(a, pzero(a)), pcmp_eq(a, infinity));
+  return pselect(is_zero_or_inf, a, pmul(a, prsqrt(a)));
+}
+#endif
+
+//---------- bfloat16 ----------
+// TODO: Add support for native armv8.6-a bfloat16_t
+
+// TODO: Guard if we have native bfloat16 support
+typedef eigen_packet_wrapper<uint16x4_t, 19> Packet4bf;
+
+template<> struct is_arithmetic<Packet4bf> { enum { value = true }; };
+
+template<> struct packet_traits<bfloat16> : default_packet_traits
+{
+  typedef Packet4bf type;
+  typedef Packet4bf half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasCmp       = 1,
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+    HasDiv       = 1,
+    HasFloor     = 1,
+    HasCeil      = 1,
+    HasRint      = 1,
+
+    HasSin  = EIGEN_FAST_MATH,
+    HasCos  = EIGEN_FAST_MATH,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 0,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf  = EIGEN_FAST_MATH,
+    HasBessel = 0,  // Issues with accuracy.
+    HasNdtri = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet4bf>
+{
+  typedef bfloat16 type;
+  typedef Packet4bf half;
+  enum
+  {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+namespace detail {  
+template<>
+EIGEN_ALWAYS_INLINE void zip_in_place<Packet4bf>(Packet4bf& p1, Packet4bf& p2) {
+  const uint16x4x2_t tmp = vzip_u16(p1, p2);
+  p1 = tmp.val[0];
+  p2 = tmp.val[1];
+}
+} // namespace detail
+
+EIGEN_STRONG_INLINE Packet4bf F32ToBf16(const Packet4f& p)
+{
+  // See the scalar implemention in BFloat16.h for a comprehensible explanation
+  // of this fast rounding algorithm
+  Packet4ui input = reinterpret_cast<Packet4ui>(p);
+
+  // lsb = (input >> 16) & 1
+  Packet4ui lsb =  vandq_u32(vshrq_n_u32(input, 16), vdupq_n_u32(1));
+
+  // rounding_bias = 0x7fff + lsb
+  Packet4ui rounding_bias = vaddq_u32(lsb, vdupq_n_u32(0x7fff));
+
+  // input += rounding_bias
+  input = vaddq_u32(input, rounding_bias);
+
+  // input = input >> 16
+  input = vshrq_n_u32(input, 16);
+
+  // Replace float-nans by bfloat16-nans, that is 0x7fc0
+  const Packet4ui bf16_nan = vdupq_n_u32(0x7fc0);
+  const Packet4ui mask = vceqq_f32(p, p);
+  input = vbslq_u32(mask, input, bf16_nan);
+
+  // output = static_cast<uint16_t>(input)
+  return vmovn_u32(input);
+}
+
+EIGEN_STRONG_INLINE Packet4f Bf16ToF32(const Packet4bf& p)
+{
+  return reinterpret_cast<Packet4f>(vshlq_n_u32(vmovl_u16(p), 16));
+}
+
+EIGEN_STRONG_INLINE Packet4bf F32MaskToBf16Mask(const Packet4f& p) {
+  return vmovn_u32(vreinterpretq_u32_f32(p));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pset1<Packet4bf>(const bfloat16& from) {
+  return pset1<Packet4us>(from.value);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 pfirst<Packet4bf>(const Packet4bf& from) {
+  return bfloat16_impl::raw_uint16_to_bfloat16(static_cast<uint16_t>(pfirst<Packet4us>(from)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pload<Packet4bf>(const bfloat16* from)
+{
+  return pload<Packet4us>(reinterpret_cast<const uint16_t*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf ploadu<Packet4bf>(const bfloat16* from)
+{
+  return ploadu<Packet4us>(reinterpret_cast<const uint16_t*>(from));
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<bfloat16>(bfloat16* to, const Packet4bf& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE vst1_u16(reinterpret_cast<uint16_t*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<bfloat16>(bfloat16* to, const Packet4bf& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE vst1_u16(reinterpret_cast<uint16_t*>(to), from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf ploaddup<Packet4bf>(const bfloat16* from)
+{
+  return ploaddup<Packet4us>(reinterpret_cast<const uint16_t*>(from));
+}
+
+template <> EIGEN_STRONG_INLINE Packet4bf pabs(const Packet4bf& a) {
+  return F32ToBf16(pabs<Packet4f>(Bf16ToF32(a)));
+}
+
+template <> EIGEN_STRONG_INLINE Packet4bf pmin<PropagateNumbers, Packet4bf>(const Packet4bf &a,
+                                                                            const Packet4bf &b)
+{
+  return F32ToBf16(pmin<PropagateNumbers, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+template <> EIGEN_STRONG_INLINE Packet4bf pmin<PropagateNaN, Packet4bf>(const Packet4bf &a,
+                                                                        const Packet4bf &b)
+{
+  return F32ToBf16(pmin<PropagateNaN, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <> EIGEN_STRONG_INLINE Packet4bf pmin<Packet4bf>(const Packet4bf &a,
+                                                          const Packet4bf &b)
+{
+  return F32ToBf16(pmin<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <> EIGEN_STRONG_INLINE Packet4bf pmax<PropagateNumbers, Packet4bf>(const Packet4bf &a,
+                                                                            const Packet4bf &b)
+{
+  return F32ToBf16(pmax<PropagateNumbers, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+template <> EIGEN_STRONG_INLINE Packet4bf pmax<PropagateNaN, Packet4bf>(const Packet4bf &a,
+                                                                        const Packet4bf &b)
+{
+  return F32ToBf16(pmax<PropagateNaN, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template <> EIGEN_STRONG_INLINE Packet4bf pmax<Packet4bf>(const Packet4bf &a,
+                                                          const Packet4bf &b)
+{
+  return F32ToBf16(pmax<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf plset<Packet4bf>(const bfloat16& a)
+{
+  return F32ToBf16(plset<Packet4f>(static_cast<float>(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf por(const Packet4bf& a,const Packet4bf& b) {
+  return por<Packet4us>(a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pxor(const Packet4bf& a,const Packet4bf& b) {
+  return pxor<Packet4us>(a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pand(const Packet4bf& a,const Packet4bf& b) {
+  return pand<Packet4us>(a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pandnot(const Packet4bf& a,const Packet4bf& b) {
+  return pandnot<Packet4us>(a, b);
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4bf pselect(const Packet4bf& mask, const Packet4bf& a,
+                                                      const Packet4bf& b)
+{
+  return pselect<Packet4us>(mask, a, b);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf print<Packet4bf>(const Packet4bf& a)
+{
+  return F32ToBf16(print<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pfloor<Packet4bf>(const Packet4bf& a)
+{
+  return F32ToBf16(pfloor<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pceil<Packet4bf>(const Packet4bf& a)
+{
+  return F32ToBf16(pceil<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pconj(const Packet4bf& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4bf padd<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
+  return F32ToBf16(padd<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf psub<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
+  return F32ToBf16(psub<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pmul<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
+  return F32ToBf16(pmul<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pdiv<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
+  return F32ToBf16(pdiv<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<>
+EIGEN_STRONG_INLINE Packet4bf pgather<bfloat16, Packet4bf>(const bfloat16* from, Index stride)
+{
+  return pgather<uint16_t, Packet4us>(reinterpret_cast<const uint16_t*>(from), stride);
+}
+
+template<>
+EIGEN_STRONG_INLINE void pscatter<bfloat16, Packet4bf>(bfloat16* to, const Packet4bf& from, Index stride)
+{
+  pscatter<uint16_t, Packet4us>(reinterpret_cast<uint16_t*>(to), from, stride);
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux<Packet4bf>(const Packet4bf& a)
+{
+  return static_cast<bfloat16>(predux<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_max<Packet4bf>(const Packet4bf& a)
+{
+  return static_cast<bfloat16>(predux_max<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_min<Packet4bf>(const Packet4bf& a)
+{
+  return static_cast<bfloat16>(predux_min<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE bfloat16 predux_mul<Packet4bf>(const Packet4bf& a)
+{
+  return static_cast<bfloat16>(predux_mul<Packet4f>(Bf16ToF32(a)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf preverse<Packet4bf>(const Packet4bf& a)
+{
+  return preverse<Packet4us>(a);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4bf, 4>& kernel)
+{
+  detail::ptranspose_impl(kernel);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pabsdiff<Packet4bf>(const Packet4bf& a, const Packet4bf& b)
+{
+  return F32ToBf16(pabsdiff<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pcmp_eq<Packet4bf>(const Packet4bf& a, const Packet4bf& b)
+{
+  return F32MaskToBf16Mask(pcmp_eq<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pcmp_lt<Packet4bf>(const Packet4bf& a, const Packet4bf& b)
+{
+  return F32MaskToBf16Mask(pcmp_lt<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pcmp_lt_or_nan<Packet4bf>(const Packet4bf& a, const Packet4bf& b)
+{
+  return F32MaskToBf16Mask(pcmp_lt_or_nan<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pcmp_le<Packet4bf>(const Packet4bf& a, const Packet4bf& b)
+{
+  return F32MaskToBf16Mask(pcmp_le<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4bf pnegate<Packet4bf>(const Packet4bf& a)
+{
+  return pxor<Packet4us>(a, pset1<Packet4us>(static_cast<uint16_t>(0x8000)));
+}
+
+//---------- double ----------
+
+// Clang 3.5 in the iOS toolchain has an ICE triggered by NEON intrisics for double.
+// Confirmed at least with __apple_build_version__ = 6000054.
+#ifdef __apple_build_version__
+// Let's hope that by the time __apple_build_version__ hits the 601* range, the bug will be fixed.
+// https://gist.github.com/yamaya/2924292 suggests that the 3 first digits are only updated with
+// major toolchain updates.
+#define EIGEN_APPLE_DOUBLE_NEON_BUG (__apple_build_version__ < 6010000)
+#else
+#define EIGEN_APPLE_DOUBLE_NEON_BUG 0
+#endif
+
+#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+
+// Bug 907: workaround missing declarations of the following two functions in the ADK
+// Defining these functions as templates ensures that if these intrinsics are
+// already defined in arm_neon.h, then our workaround doesn't cause a conflict
+// and has lower priority in overload resolution.
+template <typename T> uint64x2_t vreinterpretq_u64_f64(T a) { return (uint64x2_t) a; }
+
+template <typename T> float64x2_t vreinterpretq_f64_u64(T a) { return (float64x2_t) a; }
+
+typedef float64x2_t Packet2d;
+typedef float64x1_t Packet1d;
+
+// fuctionally equivalent to _mm_shuffle_pd in SSE (i.e. shuffle(m, n, mask) equals _mm_shuffle_pd(m,n,mask))
+// Currently used in LU/arch/InverseSize4.h to enable a shared implementation
+// for fast inversion of matrices of size 4.
+EIGEN_STRONG_INLINE Packet2d shuffle(const Packet2d& m, const Packet2d& n, int mask)
+{
+  const double* a = reinterpret_cast<const double*>(&m);
+  const double* b = reinterpret_cast<const double*>(&n);
+  Packet2d res = {*(a + (mask & 1)), *(b + ((mask >> 1) & 1))};
+  return res;
+}
+
+EIGEN_STRONG_INLINE Packet2d vec2d_swizzle2(const Packet2d& a, const Packet2d& b, int mask)
+{
+  return shuffle(a, b, mask);
+}
+EIGEN_STRONG_INLINE Packet2d vec2d_unpacklo(const Packet2d& a,const Packet2d& b)
+{
+  return shuffle(a, b, 0);
+}
+EIGEN_STRONG_INLINE Packet2d vec2d_unpackhi(const Packet2d& a,const Packet2d& b)
+{
+  return shuffle(a, b, 3);
+}
+#define vec2d_duplane(a, p) \
+  vdupq_laneq_f64(a, p)
+
+template<> struct packet_traits<double>  : default_packet_traits
+{
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum
+  {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasCmp       = 1,
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 1,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 1,
+    HasArg       = 0,
+    HasAbs2      = 1,
+    HasAbsDiff   = 1,
+    HasMin       = 1,
+    HasMax       = 1,
+    HasConj      = 1,
+    HasSetLinear = 0,
+    HasBlend     = 0,
+
+    HasDiv   = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = 0,
+    HasErf  = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2d>
+{
+  typedef double type;
+  typedef Packet2d half;
+  typedef Packet2l integer_packet;
+  enum
+  {
+    size = 2,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double&  from) { return vdupq_n_f64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a)
+{
+  const double c[] = {0.0,1.0};
+  return vaddq_f64(pset1<Packet2d>(a), vld1q_f64(c));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return vaddq_f64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return vsubq_f64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& , const Packet2d& );
+template<> EIGEN_STRONG_INLINE Packet2d paddsub<Packet2d>(const Packet2d& a, const Packet2d& b){
+  const Packet2d mask = {numext::bit_cast<double>(0x8000000000000000ull),0.0};
+  return padd(a, pxor(mask, b));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) { return vnegq_f64(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return vmulq_f64(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return vdivq_f64(a,b); }
+
+#ifdef __ARM_FEATURE_FMA
+// See bug 936. See above comment about FMA for float.
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c)
+{ return vfmaq_f64(c,a,b); }
+#else
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c)
+{ return vmlaq_f64(c,a,b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) { return vminq_f64(a,b); }
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+// numeric max and min are only available if ARM_FEATURE_NUMERIC_MAXMIN is defined (which can only be the case for Armv8 systems).
+template<> EIGEN_STRONG_INLINE Packet2d pmin<PropagateNumbers, Packet2d>(const Packet2d& a, const Packet2d& b) { return vminnmq_f64(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmax<PropagateNumbers, Packet2d>(const Packet2d& a, const Packet2d& b) { return vmaxnmq_f64(a, b); }
+
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d pmin<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) { return pmin<Packet2d>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) { return vmaxq_f64(a,b); }
+
+
+template<> EIGEN_STRONG_INLINE Packet2d pmax<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) { return pmax<Packet2d>(a, b); }
+
+// Logical Operations are not supported for float, so we have to reinterpret casts using NEON intrinsics
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vandq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b))); }
+
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vorrq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b))); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(veorq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b))); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vbicq_u64(vreinterpretq_u64_f64(a),vreinterpretq_u64_f64(b))); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_le(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vcleq_f64(a,b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vcltq_f64(a,b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u32(vmvnq_u32(vreinterpretq_u32_u64(vcgeq_f64(a,b)))); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_eq(const Packet2d& a, const Packet2d& b)
+{ return vreinterpretq_f64_u64(vceqq_f64(a,b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f64(from); }
+
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double* from) { return vld1q_dup_f64(from); }
+template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet2d& from)
+{ EIGEN_DEBUG_ALIGNED_STORE vst1q_f64(to,from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet2d& from)
+{ EIGEN_DEBUG_UNALIGNED_STORE vst1q_f64(to,from); }
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+  Packet2d res = pset1<Packet2d>(0.0);
+  res = vld1q_lane_f64(from + 0*stride, res, 0);
+  res = vld1q_lane_f64(from + 1*stride, res, 1);
+  return res;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  vst1q_lane_f64(to + stride*0, from, 0);
+  vst1q_lane_f64(to + stride*1, from, 1);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { EIGEN_ARM_PREFETCH(addr); }
+
+// FIXME only store the 2 first elements ?
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return vgetq_lane_f64(a,0); }
+
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a)
+{ return vcombine_f64(vget_high_f64(a), vget_low_f64(a)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a) { return vabsq_f64(a); }
+
+#if EIGEN_COMP_CLANG && defined(__apple_build_version__)
+// workaround ICE, see bug 907
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{ return (vget_low_f64(a) + vget_high_f64(a))[0]; }
+#else
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{ return vget_lane_f64(vget_low_f64(a) + vget_high_f64(a), 0); }
+#endif
+
+// Other reduction functions:
+// mul
+#if EIGEN_COMP_CLANG && defined(__apple_build_version__)
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{ return (vget_low_f64(a) * vget_high_f64(a))[0]; }
+#else
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{ return vget_lane_f64(vget_low_f64(a) * vget_high_f64(a), 0); }
+#endif
+
+// min
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{ return vgetq_lane_f64(vpminq_f64(a,a), 0); }
+
+// max
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{ return vgetq_lane_f64(vpmaxq_f64(a,a), 0); }
+
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet2d, 2>& kernel)
+{
+  const float64x2_t tmp1 = vzip1q_f64(kernel.packet[0], kernel.packet[1]);
+  const float64x2_t tmp2 = vzip2q_f64(kernel.packet[0], kernel.packet[1]);
+
+  kernel.packet[0] = tmp1;
+  kernel.packet[1] = tmp2;
+}
+
+template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2d pselect( const Packet2d& mask, const Packet2d& a, const Packet2d& b)
+{ return vbslq_f64(vreinterpretq_u64_f64(mask), a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d print<Packet2d>(const Packet2d& a)
+{ return vrndnq_f64(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a)
+{ return vrndmq_f64(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a)
+{ return vrndpq_f64(a); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pldexp<Packet2d>(const Packet2d& a, const Packet2d& exponent)
+{ return pldexp_generic(a, exponent); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pfrexp<Packet2d>(const Packet2d& a, Packet2d& exponent)
+{ return pfrexp_generic(a,exponent); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pset1frombits<Packet2d>(uint64_t from)
+{ return vreinterpretq_f64_u64(vdupq_n_u64(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d prsqrt(const Packet2d& a) {
+  // Compute approximate reciprocal sqrt.
+  Packet2d x = vrsqrteq_f64(a);
+  // Do Newton iterations for 1/sqrt(x).
+  x = vmulq_f64(vrsqrtsq_f64(vmulq_f64(a, x), x), x);
+  x = vmulq_f64(vrsqrtsq_f64(vmulq_f64(a, x), x), x);
+  x = vmulq_f64(vrsqrtsq_f64(vmulq_f64(a, x), x), x);
+  const Packet2d infinity = pset1<Packet2d>(NumTraits<double>::infinity());
+  return pselect(pcmp_eq(a, pzero(a)), infinity, x);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d psqrt(const Packet2d& _x){ return vsqrtq_f64(_x); }
+
+#endif // EIGEN_ARCH_ARM64
+
+// Do we have an fp16 types and supporting Neon intrinsics?
+#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+typedef float16x4_t Packet4hf;
+typedef float16x8_t Packet8hf;
+
+template <>
+struct packet_traits<Eigen::half> : default_packet_traits {
+  typedef Packet8hf type;
+  typedef Packet4hf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 8,
+    HasHalfPacket = 1,
+
+    HasCmp = 1,
+    HasCast = 1,
+    HasAdd = 1,
+    HasSub = 1,
+    HasShift = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasAbs2 = 1,
+    HasAbsDiff = 0,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 1,
+    HasSetLinear = 0,
+    HasBlend = 0,
+    HasInsert = 1,
+    HasReduxp = 1,
+    HasDiv = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasRint = 1,
+    HasSin = 0,
+    HasCos = 0,
+    HasLog = 0,
+    HasExp = 0,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasErf = EIGEN_FAST_MATH,
+    HasBessel = 0,  // Issues with accuracy.
+    HasNdtri = 0
+  };
+};
+
+template <>
+struct unpacket_traits<Packet4hf> {
+  typedef Eigen::half type;
+  typedef Packet4hf half;
+  enum {
+    size = 4,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+struct unpacket_traits<Packet8hf> {
+  typedef Eigen::half type;
+  typedef Packet4hf half;
+  enum {
+    size = 8,
+    alignment = Aligned16,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf predux_half_dowto4<Packet8hf>(const Packet8hf& a) {
+  return vadd_f16(vget_low_f16(a), vget_high_f16(a));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pset1<Packet8hf>(const Eigen::half& from) {
+  return vdupq_n_f16(from.x);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pset1<Packet4hf>(const Eigen::half& from) {
+  return vdup_n_f16(from.x);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf plset<Packet8hf>(const Eigen::half& a) {
+  const float16_t f[] = {0, 1, 2, 3, 4, 5, 6, 7};
+  Packet8hf countdown = vld1q_f16(f);
+  return vaddq_f16(pset1<Packet8hf>(a), countdown);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf plset<Packet4hf>(const Eigen::half& a) {
+  const float16_t f[] = {0, 1, 2, 3};
+  Packet4hf countdown = vld1_f16(f);
+  return vadd_f16(pset1<Packet4hf>(a), countdown);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf padd<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vaddq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf padd<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vadd_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf psub<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vsubq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf psub<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vsub_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pnegate(const Packet8hf& a) {
+  return vnegq_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pnegate(const Packet4hf& a) {
+  return vneg_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pconj(const Packet8hf& a) {
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pconj(const Packet4hf& a) {
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pmul<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vmulq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pmul<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vmul_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pdiv<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vdivq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pdiv<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vdiv_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pmadd(const Packet8hf& a, const Packet8hf& b, const Packet8hf& c) {
+  return vfmaq_f16(c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pmadd(const Packet4hf& a, const Packet4hf& b, const Packet4hf& c) {
+  return vfma_f16(c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pmin<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vminq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pmin<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vmin_f16(a, b);
+}
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+// numeric max and min are only available if ARM_FEATURE_NUMERIC_MAXMIN is defined (which can only be the case for Armv8 systems).
+template<> EIGEN_STRONG_INLINE Packet4hf pmin<PropagateNumbers, Packet4hf>(const Packet4hf& a, const Packet4hf& b) { return vminnm_f16(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8hf pmin<PropagateNumbers, Packet8hf>(const Packet8hf& a, const Packet8hf& b) { return vminnmq_f16(a, b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4hf pmin<PropagateNaN, Packet4hf>(const Packet4hf& a, const Packet4hf& b) { return pmin<Packet4hf>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet8hf pmin<PropagateNaN, Packet8hf>(const Packet8hf& a, const Packet8hf& b) { return pmin<Packet8hf>(a, b); }
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pmax<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vmaxq_f16(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pmax<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vmax_f16(a, b);
+}
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+// numeric max and min are only available if ARM_FEATURE_NUMERIC_MAXMIN is defined (which can only be the case for Armv8 systems).
+template<> EIGEN_STRONG_INLINE Packet4hf pmax<PropagateNumbers, Packet4hf>(const Packet4hf& a, const Packet4hf& b) { return vmaxnm_f16(a, b); }
+template<> EIGEN_STRONG_INLINE Packet8hf pmax<PropagateNumbers, Packet8hf>(const Packet8hf& a, const Packet8hf& b) { return vmaxnmq_f16(a, b); }
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4hf pmax<PropagateNaN, Packet4hf>(const Packet4hf& a, const Packet4hf& b) { return pmax<Packet4hf>(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet8hf pmax<PropagateNaN, Packet8hf>(const Packet8hf& a, const Packet8hf& b) { return pmax<Packet8hf>(a, b); }
+
+#define EIGEN_MAKE_ARM_FP16_CMP_8(name)                                               \
+  template <>                                                                         \
+  EIGEN_STRONG_INLINE Packet8hf pcmp_##name(const Packet8hf& a, const Packet8hf& b) { \
+    return vreinterpretq_f16_u16(vc##name##q_f16(a, b));                              \
+  }
+
+#define EIGEN_MAKE_ARM_FP16_CMP_4(name)                                               \
+  template <>                                                                         \
+  EIGEN_STRONG_INLINE Packet4hf pcmp_##name(const Packet4hf& a, const Packet4hf& b) { \
+    return vreinterpret_f16_u16(vc##name##_f16(a, b));                                \
+  }
+
+EIGEN_MAKE_ARM_FP16_CMP_8(eq)
+EIGEN_MAKE_ARM_FP16_CMP_8(lt)
+EIGEN_MAKE_ARM_FP16_CMP_8(le)
+
+EIGEN_MAKE_ARM_FP16_CMP_4(eq)
+EIGEN_MAKE_ARM_FP16_CMP_4(lt)
+EIGEN_MAKE_ARM_FP16_CMP_4(le)
+
+#undef EIGEN_MAKE_ARM_FP16_CMP_8
+#undef EIGEN_MAKE_ARM_FP16_CMP_4
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pcmp_lt_or_nan<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vreinterpretq_f16_u16(vmvnq_u16(vcgeq_f16(a, b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pcmp_lt_or_nan<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(vmvn_u16(vcge_f16(a, b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf print<Packet8hf>(const Packet8hf& a)
+{ return vrndnq_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf print<Packet4hf>(const Packet4hf& a)
+{ return vrndn_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pfloor<Packet8hf>(const Packet8hf& a)
+{ return vrndmq_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pfloor<Packet4hf>(const Packet4hf& a)
+{ return vrndm_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pceil<Packet8hf>(const Packet8hf& a)
+{ return vrndpq_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pceil<Packet4hf>(const Packet4hf& a)
+{ return vrndp_f16(a); }
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf psqrt<Packet8hf>(const Packet8hf& a) {
+  return vsqrtq_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf psqrt<Packet4hf>(const Packet4hf& a) {
+  return vsqrt_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pand<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vreinterpretq_f16_u16(vandq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pand<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(vand_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf por<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vreinterpretq_f16_u16(vorrq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf por<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(vorr_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pxor<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vreinterpretq_f16_u16(veorq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pxor<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(veor_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pandnot<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
+  return vreinterpretq_f16_u16(vbicq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pandnot<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(vbic_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pload<Packet8hf>(const Eigen::half* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f16(reinterpret_cast<const float16_t*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pload<Packet4hf>(const Eigen::half* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return vld1_f16(reinterpret_cast<const float16_t*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf ploadu<Packet8hf>(const Eigen::half* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f16(reinterpret_cast<const float16_t*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf ploadu<Packet4hf>(const Eigen::half* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return vld1_f16(reinterpret_cast<const float16_t*>(from));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf ploaddup<Packet8hf>(const Eigen::half* from) {
+  Packet8hf packet;
+  packet[0] = from[0].x;
+  packet[1] = from[0].x;
+  packet[2] = from[1].x;
+  packet[3] = from[1].x;
+  packet[4] = from[2].x;
+  packet[5] = from[2].x;
+  packet[6] = from[3].x;
+  packet[7] = from[3].x;
+  return packet;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf ploaddup<Packet4hf>(const Eigen::half* from) {
+  float16x4_t packet;
+  float16_t* tmp;
+  tmp = (float16_t*)&packet;
+  tmp[0] = from[0].x;
+  tmp[1] = from[0].x;
+  tmp[2] = from[1].x;
+  tmp[3] = from[1].x;
+  return packet;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf ploadquad<Packet8hf>(const Eigen::half* from) {
+  Packet4hf lo, hi;
+  lo = vld1_dup_f16(reinterpret_cast<const float16_t*>(from));
+  hi = vld1_dup_f16(reinterpret_cast<const float16_t*>(from+1));
+  return vcombine_f16(lo, hi);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pinsertfirst(const Packet8hf& a, Eigen::half b) { return vsetq_lane_f16(b.x, a, 0); }
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pinsertfirst(const Packet4hf& a, Eigen::half b) { return vset_lane_f16(b.x, a, 0); }
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pselect(const Packet8hf& mask, const Packet8hf& a, const Packet8hf& b) {
+  return vbslq_f16(vreinterpretq_u16_f16(mask), a, b);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pselect(const Packet4hf& mask, const Packet4hf& a, const Packet4hf& b) {
+  return vbsl_f16(vreinterpret_u16_f16(mask), a, b);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pinsertlast(const Packet8hf& a, Eigen::half b) { return vsetq_lane_f16(b.x, a, 7); }
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pinsertlast(const Packet4hf& a, Eigen::half b) { return vset_lane_f16(b.x, a, 3); }
+
+template <>
+EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet8hf& from) {
+  EIGEN_DEBUG_ALIGNED_STORE vst1q_f16(reinterpret_cast<float16_t*>(to), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet4hf& from) {
+  EIGEN_DEBUG_ALIGNED_STORE vst1_f16(reinterpret_cast<float16_t*>(to), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet8hf& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE vst1q_f16(reinterpret_cast<float16_t*>(to), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet4hf& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE vst1_f16(reinterpret_cast<float16_t*>(to), from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pgather<Eigen::half, Packet8hf>(const Eigen::half* from, Index stride) {
+  Packet8hf res = pset1<Packet8hf>(Eigen::half(0.f));
+  res = vsetq_lane_f16(from[0 * stride].x, res, 0);
+  res = vsetq_lane_f16(from[1 * stride].x, res, 1);
+  res = vsetq_lane_f16(from[2 * stride].x, res, 2);
+  res = vsetq_lane_f16(from[3 * stride].x, res, 3);
+  res = vsetq_lane_f16(from[4 * stride].x, res, 4);
+  res = vsetq_lane_f16(from[5 * stride].x, res, 5);
+  res = vsetq_lane_f16(from[6 * stride].x, res, 6);
+  res = vsetq_lane_f16(from[7 * stride].x, res, 7);
+  return res;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pgather<Eigen::half, Packet4hf>(const Eigen::half* from, Index stride) {
+  Packet4hf res = pset1<Packet4hf>(Eigen::half(0.f));
+  res = vset_lane_f16(from[0 * stride].x, res, 0);
+  res = vset_lane_f16(from[1 * stride].x, res, 1);
+  res = vset_lane_f16(from[2 * stride].x, res, 2);
+  res = vset_lane_f16(from[3 * stride].x, res, 3);
+  return res;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet8hf>(Eigen::half* to, const Packet8hf& from, Index stride) {
+  to[stride * 0].x = vgetq_lane_f16(from, 0);
+  to[stride * 1].x = vgetq_lane_f16(from, 1);
+  to[stride * 2].x = vgetq_lane_f16(from, 2);
+  to[stride * 3].x = vgetq_lane_f16(from, 3);
+  to[stride * 4].x = vgetq_lane_f16(from, 4);
+  to[stride * 5].x = vgetq_lane_f16(from, 5);
+  to[stride * 6].x = vgetq_lane_f16(from, 6);
+  to[stride * 7].x = vgetq_lane_f16(from, 7);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet4hf>(Eigen::half* to, const Packet4hf& from, Index stride) {
+  to[stride * 0].x = vget_lane_f16(from, 0);
+  to[stride * 1].x = vget_lane_f16(from, 1);
+  to[stride * 2].x = vget_lane_f16(from, 2);
+  to[stride * 3].x = vget_lane_f16(from, 3);
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<Eigen::half>(const Eigen::half* addr) {
+  EIGEN_ARM_PREFETCH(addr);
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half pfirst<Packet8hf>(const Packet8hf& a) {
+  float16_t x[8];
+  vst1q_f16(x, a);
+  Eigen::half h;
+  h.x = x[0];
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half pfirst<Packet4hf>(const Packet4hf& a) {
+  float16_t x[4];
+  vst1_f16(x, a);
+  Eigen::half h;
+  h.x = x[0];
+  return h;
+}
+
+template<> EIGEN_STRONG_INLINE Packet8hf preverse(const Packet8hf& a) {
+  float16x4_t a_lo, a_hi;
+  Packet8hf a_r64;
+
+  a_r64 = vrev64q_f16(a);
+  a_lo = vget_low_f16(a_r64);
+  a_hi = vget_high_f16(a_r64);
+  return vcombine_f16(a_hi, a_lo);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf preverse<Packet4hf>(const Packet4hf& a) {
+  return vrev64_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pabs<Packet8hf>(const Packet8hf& a) {
+  return vabsq_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pabs<Packet4hf>(const Packet4hf& a) {
+  return vabs_f16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux<Packet8hf>(const Packet8hf& a) {
+  float16x4_t a_lo, a_hi, sum;
+
+  a_lo = vget_low_f16(a);
+  a_hi = vget_high_f16(a);
+  sum = vpadd_f16(a_lo, a_hi);
+  sum = vpadd_f16(sum, sum);
+  sum = vpadd_f16(sum, sum);
+
+  Eigen::half h;
+  h.x = vget_lane_f16(sum, 0);
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux<Packet4hf>(const Packet4hf& a) {
+  float16x4_t sum;
+
+  sum = vpadd_f16(a, a);
+  sum = vpadd_f16(sum, sum);
+  Eigen::half h;
+  h.x = vget_lane_f16(sum, 0);
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet8hf>(const Packet8hf& a) {
+  float16x4_t a_lo, a_hi, prod;
+
+  a_lo = vget_low_f16(a);
+  a_hi = vget_high_f16(a);
+  prod = vmul_f16(a_lo, a_hi);
+  prod = vmul_f16(prod, vrev64_f16(prod));
+
+  Eigen::half h;
+  h.x = vmulh_f16(vget_lane_f16(prod, 0), vget_lane_f16(prod, 1));
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet4hf>(const Packet4hf& a) {
+  float16x4_t prod;
+  prod = vmul_f16(a, vrev64_f16(a));
+  Eigen::half h;
+  h.x = vmulh_f16(vget_lane_f16(prod, 0), vget_lane_f16(prod, 1));
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_min<Packet8hf>(const Packet8hf& a) {
+  float16x4_t a_lo, a_hi, min;
+
+  a_lo = vget_low_f16(a);
+  a_hi = vget_high_f16(a);
+  min = vpmin_f16(a_lo, a_hi);
+  min = vpmin_f16(min, min);
+  min = vpmin_f16(min, min);
+
+  Eigen::half h;
+  h.x = vget_lane_f16(min, 0);
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_min<Packet4hf>(const Packet4hf& a) {
+  Packet4hf tmp;
+  tmp = vpmin_f16(a, a);
+  tmp = vpmin_f16(tmp, tmp);
+  Eigen::half h;
+  h.x = vget_lane_f16(tmp, 0);
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_max<Packet8hf>(const Packet8hf& a) {
+  float16x4_t a_lo, a_hi, max;
+
+  a_lo = vget_low_f16(a);
+  a_hi = vget_high_f16(a);
+  max = vpmax_f16(a_lo, a_hi);
+  max = vpmax_f16(max, max);
+  max = vpmax_f16(max, max);
+
+  Eigen::half h;
+  h.x = vget_lane_f16(max, 0);
+  return h;
+}
+
+template <>
+EIGEN_STRONG_INLINE Eigen::half predux_max<Packet4hf>(const Packet4hf& a) {
+  Packet4hf tmp;
+  tmp = vpmax_f16(a, a);
+  tmp = vpmax_f16(tmp, tmp);
+  Eigen::half h;
+  h.x = vget_lane_f16(tmp, 0);
+  return h;
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8hf, 4>& kernel)
+{
+  const float16x8x2_t zip16_1 = vzipq_f16(kernel.packet[0], kernel.packet[1]);
+  const float16x8x2_t zip16_2 = vzipq_f16(kernel.packet[2], kernel.packet[3]);
+
+  const float32x4x2_t zip32_1 = vzipq_f32(vreinterpretq_f32_f16(zip16_1.val[0]), vreinterpretq_f32_f16(zip16_2.val[0]));
+  const float32x4x2_t zip32_2 = vzipq_f32(vreinterpretq_f32_f16(zip16_1.val[1]), vreinterpretq_f32_f16(zip16_2.val[1]));
+
+  kernel.packet[0] = vreinterpretq_f16_f32(zip32_1.val[0]);
+  kernel.packet[1] = vreinterpretq_f16_f32(zip32_1.val[1]);
+  kernel.packet[2] = vreinterpretq_f16_f32(zip32_2.val[0]);
+  kernel.packet[3] = vreinterpretq_f16_f32(zip32_2.val[1]);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4hf, 4>& kernel) {
+  EIGEN_ALIGN16 float16x4x4_t tmp_x4;
+  float16_t* tmp = (float16_t*)&kernel;
+  tmp_x4 = vld4_f16(tmp);
+
+  kernel.packet[0] = tmp_x4.val[0];
+  kernel.packet[1] = tmp_x4.val[1];
+  kernel.packet[2] = tmp_x4.val[2];
+  kernel.packet[3] = tmp_x4.val[3];
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8hf, 8>& kernel) {
+  float16x8x2_t T_1[4];
+
+  T_1[0] = vuzpq_f16(kernel.packet[0], kernel.packet[1]);
+  T_1[1] = vuzpq_f16(kernel.packet[2], kernel.packet[3]);
+  T_1[2] = vuzpq_f16(kernel.packet[4], kernel.packet[5]);
+  T_1[3] = vuzpq_f16(kernel.packet[6], kernel.packet[7]);
+
+  float16x8x2_t T_2[4];
+  T_2[0] = vuzpq_f16(T_1[0].val[0], T_1[1].val[0]);
+  T_2[1] = vuzpq_f16(T_1[0].val[1], T_1[1].val[1]);
+  T_2[2] = vuzpq_f16(T_1[2].val[0], T_1[3].val[0]);
+  T_2[3] = vuzpq_f16(T_1[2].val[1], T_1[3].val[1]);
+
+  float16x8x2_t T_3[4];
+  T_3[0] = vuzpq_f16(T_2[0].val[0], T_2[2].val[0]);
+  T_3[1] = vuzpq_f16(T_2[0].val[1], T_2[2].val[1]);
+  T_3[2] = vuzpq_f16(T_2[1].val[0], T_2[3].val[0]);
+  T_3[3] = vuzpq_f16(T_2[1].val[1], T_2[3].val[1]);
+
+  kernel.packet[0] = T_3[0].val[0];
+  kernel.packet[1] = T_3[2].val[0];
+  kernel.packet[2] = T_3[1].val[0];
+  kernel.packet[3] = T_3[3].val[0];
+  kernel.packet[4] = T_3[0].val[1];
+  kernel.packet[5] = T_3[2].val[1];
+  kernel.packet[6] = T_3[1].val[1];
+  kernel.packet[7] = T_3[3].val[1];
+}
+#endif // end EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_NEON_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/TypeCasting.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/TypeCasting.h
new file mode 100644
index 00000000..54f97336
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/NEON/TypeCasting.h
@@ -0,0 +1,1419 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Rasmus Munk Larsen <rmlarsen@google.com>
+// Copyright (C) 2020 Antonio Sanchez <cantonios@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_NEON_H
+#define EIGEN_TYPE_CASTING_NEON_H
+
+namespace Eigen {
+
+namespace internal {
+
+//==============================================================================
+// pcast, SrcType = float
+//==============================================================================
+template <>
+struct type_casting_traits<float, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet4f, Packet4f>(const Packet4f& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet2f, Packet2f>(const Packet2f& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<float, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+struct type_casting_traits<float, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+// If float64 exists, first convert to that to keep as much precision as possible.
+#if EIGEN_ARCH_ARM64
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet4f, Packet2l>(const Packet4f& a) {
+  // Discard second half of input.
+  return vcvtq_s64_f64(vcvt_f64_f32(vget_low_f32(a)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet4f, Packet2ul>(const Packet4f& a) {
+  // Discard second half of input.
+  return vcvtq_u64_f64(vcvt_f64_f32(vget_low_f32(a)));
+}
+#else
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet4f, Packet2l>(const Packet4f& a) {
+  // Discard second half of input.
+  return vmovl_s32(vget_low_s32(vcvtq_s32_f32(a)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet4f, Packet2ul>(const Packet4f& a) {
+  // Discard second half of input.
+  return vmovl_u32(vget_low_u32(vcvtq_u32_f32(a)));
+}
+#endif  // EIGEN_ARCH_ARM64
+
+template <>
+struct type_casting_traits<float, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet4f, Packet4i>(const Packet4f& a) {
+  return vcvtq_s32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet2f, Packet2i>(const Packet2f& a) {
+  return vcvt_s32_f32(a);
+}
+
+template <>
+struct type_casting_traits<float, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet4f, Packet4ui>(const Packet4f& a) {
+  return vcvtq_u32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet2f, Packet2ui>(const Packet2f& a) {
+  return vcvt_u32_f32(a);
+}
+
+template <>
+struct type_casting_traits<float, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet4f, Packet8s>(const Packet4f& a, const Packet4f& b) {
+  return vcombine_s16(vmovn_s32(vcvtq_s32_f32(a)), vmovn_s32(vcvtq_s32_f32(b)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet2f, Packet4s>(const Packet2f& a, const Packet2f& b) {
+  return vmovn_s32(vcombine_s32(vcvt_s32_f32(a), vcvt_s32_f32(b)));
+}
+
+template <>
+struct type_casting_traits<float, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet4f, Packet8us>(const Packet4f& a, const Packet4f& b) {
+  return vcombine_u16(vmovn_u32(vcvtq_u32_f32(a)), vmovn_u32(vcvtq_u32_f32(b)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet2f, Packet4us>(const Packet2f& a, const Packet2f& b) {
+  return vmovn_u32(vcombine_u32(vcvt_u32_f32(a), vcvt_u32_f32(b)));
+}
+
+template <>
+struct type_casting_traits<float, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet4f, Packet16c>(const Packet4f& a, const Packet4f& b, const Packet4f& c,
+                                                         const Packet4f& d) {
+  const int16x8_t ab_s16 = pcast<Packet4f, Packet8s>(a, b);
+  const int16x8_t cd_s16 = pcast<Packet4f, Packet8s>(c, d);
+  return vcombine_s8(vmovn_s16(ab_s16), vmovn_s16(cd_s16));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet2f, Packet8c>(const Packet2f& a, const Packet2f& b, const Packet2f& c,
+                                                       const Packet2f& d) {
+  const int16x4_t ab_s16 = pcast<Packet2f, Packet4s>(a, b);
+  const int16x4_t cd_s16 = pcast<Packet2f, Packet4s>(c, d);
+  return vmovn_s16(vcombine_s16(ab_s16, cd_s16));
+}
+
+template <>
+struct type_casting_traits<float, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet4f, Packet16uc>(const Packet4f& a, const Packet4f& b, const Packet4f& c,
+                                                           const Packet4f& d) {
+  const uint16x8_t ab_u16 = pcast<Packet4f, Packet8us>(a, b);
+  const uint16x8_t cd_u16 = pcast<Packet4f, Packet8us>(c, d);
+  return vcombine_u8(vmovn_u16(ab_u16), vmovn_u16(cd_u16));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet2f, Packet8uc>(const Packet2f& a, const Packet2f& b, const Packet2f& c,
+                                                         const Packet2f& d) {
+  const uint16x4_t ab_u16 = pcast<Packet2f, Packet4us>(a, b);
+  const uint16x4_t cd_u16 = pcast<Packet2f, Packet4us>(c, d);
+  return vmovn_u16(vcombine_u16(ab_u16, cd_u16));
+}
+
+//==============================================================================
+// pcast, SrcType = int8_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::int8_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet16c, Packet4f>(const Packet16c& a) {
+  // Discard all but first 4 bytes.
+  return vcvtq_f32_s32(vmovl_s16(vget_low_s16(vmovl_s8(vget_low_s8(a)))));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet8c, Packet2f>(const Packet8c& a) {
+  // Discard all but first 2 bytes.
+  return vcvt_f32_s32(vget_low_s32(vmovl_s16(vget_low_s16(vmovl_s8(a)))));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet16c, Packet2l>(const Packet16c& a) {
+  // Discard all but first two bytes.
+  return vmovl_s32(vget_low_s32(vmovl_s16(vget_low_s16(vmovl_s8(vget_low_s8(a))))));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet16c, Packet2ul>(const Packet16c& a) {
+  return vreinterpretq_u64_s64(pcast<Packet16c, Packet2l>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet16c, Packet4i>(const Packet16c& a) {
+  // Discard all but first 4 bytes.
+  return vmovl_s16(vget_low_s16(vmovl_s8(vget_low_s8(a))));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet8c, Packet2i>(const Packet8c& a) {
+  // Discard all but first 2 bytes.
+  return vget_low_s32(vmovl_s16(vget_low_s16(vmovl_s8(a))));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet16c, Packet4ui>(const Packet16c& a) {
+  return vreinterpretq_u32_s32(pcast<Packet16c, Packet4i>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet8c, Packet2ui>(const Packet8c& a) {
+  return vreinterpret_u32_s32(pcast<Packet8c, Packet2i>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet16c, Packet8s>(const Packet16c& a) {
+  // Discard second half of input.
+  return vmovl_s8(vget_low_s8(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet8c, Packet4s>(const Packet8c& a) {
+  // Discard second half of input.
+  return vget_low_s16(vmovl_s8(a));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet16c, Packet8us>(const Packet16c& a) {
+  return vreinterpretq_u16_s16(pcast<Packet16c, Packet8s>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet8c, Packet4us>(const Packet8c& a) {
+  return vreinterpret_u16_s16(pcast<Packet8c, Packet4s>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet16c, Packet16c>(const Packet16c& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet8c, Packet8c>(const Packet8c& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet4c pcast<Packet4c, Packet4c>(const Packet4c& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet16c, Packet16uc>(const Packet16c& a) {
+  return vreinterpretq_u8_s8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet8c, Packet8uc>(const Packet8c& a) {
+  return vreinterpret_u8_s8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4uc pcast<Packet4c, Packet4uc>(const Packet4c& a) {
+  return static_cast<Packet4uc>(a);
+}
+
+//==============================================================================
+// pcast, SrcType = uint8_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::uint8_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet16uc, Packet4f>(const Packet16uc& a) {
+  // Discard all but first 4 bytes.
+  return vcvtq_f32_u32(vmovl_u16(vget_low_u16(vmovl_u8(vget_low_u8(a)))));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet8uc, Packet2f>(const Packet8uc& a) {
+  // Discard all but first 2 bytes.
+  return vcvt_f32_u32(vget_low_u32(vmovl_u16(vget_low_u16(vmovl_u8(a)))));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet16uc, Packet2ul>(const Packet16uc& a) {
+  // Discard all but first two bytes.
+  return vmovl_u32(vget_low_u32(vmovl_u16(vget_low_u16(vmovl_u8(vget_low_u8(a))))));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet16uc, Packet2l>(const Packet16uc& a) {
+  return vreinterpretq_s64_u64(pcast<Packet16uc, Packet2ul>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet16uc, Packet4ui>(const Packet16uc& a) {
+  // Discard all but first 4 bytes.
+  return vmovl_u16(vget_low_u16(vmovl_u8(vget_low_u8(a))));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet8uc, Packet2ui>(const Packet8uc& a) {
+  // Discard all but first 2 bytes.
+  return vget_low_u32(vmovl_u16(vget_low_u16(vmovl_u8(a))));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet16uc, Packet4i>(const Packet16uc& a) {
+  return vreinterpretq_s32_u32(pcast<Packet16uc, Packet4ui>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet8uc, Packet2i>(const Packet8uc& a) {
+  return vreinterpret_s32_u32(pcast<Packet8uc, Packet2ui>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet16uc, Packet8us>(const Packet16uc& a) {
+  // Discard second half of input.
+  return vmovl_u8(vget_low_u8(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet8uc, Packet4us>(const Packet8uc& a) {
+  // Discard second half of input.
+  return vget_low_u16(vmovl_u8(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet16uc, Packet8s>(const Packet16uc& a) {
+  return vreinterpretq_s16_u16(pcast<Packet16uc, Packet8us>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet8uc, Packet4s>(const Packet8uc& a) {
+  return vreinterpret_s16_u16(pcast<Packet8uc, Packet4us>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet16uc, Packet16uc>(const Packet16uc& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet8uc, Packet8uc>(const Packet8uc& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet4uc pcast<Packet4uc, Packet4uc>(const Packet4uc& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet16uc, Packet16c>(const Packet16uc& a) {
+  return vreinterpretq_s8_u8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet8uc, Packet8c>(const Packet8uc& a) {
+  return vreinterpret_s8_u8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4c pcast<Packet4uc, Packet4c>(const Packet4uc& a) {
+  return static_cast<Packet4c>(a);
+}
+
+//==============================================================================
+// pcast, SrcType = int16_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::int16_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet8s, Packet4f>(const Packet8s& a) {
+  // Discard second half of input.
+  return vcvtq_f32_s32(vmovl_s16(vget_low_s16(a)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet4s, Packet2f>(const Packet4s& a) {
+  // Discard second half of input.
+  return vcvt_f32_s32(vget_low_s32(vmovl_s16(a)));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet8s, Packet2l>(const Packet8s& a) {
+  // Discard all but first two values.
+  return vmovl_s32(vget_low_s32(vmovl_s16(vget_low_s16(a))));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet8s, Packet2ul>(const Packet8s& a) {
+  return vreinterpretq_u64_s64(pcast<Packet8s, Packet2l>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet8s, Packet4i>(const Packet8s& a) {
+  // Discard second half of input.
+  return vmovl_s16(vget_low_s16(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet4s, Packet2i>(const Packet4s& a) {
+  // Discard second half of input.
+  return vget_low_s32(vmovl_s16(a));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet8s, Packet4ui>(const Packet8s& a) {
+  return vreinterpretq_u32_s32(pcast<Packet8s, Packet4i>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet4s, Packet2ui>(const Packet4s& a) {
+  return vreinterpret_u32_s32(pcast<Packet4s, Packet2i>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet8s, Packet8s>(const Packet8s& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet4s, Packet4s>(const Packet4s& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet8s, Packet8us>(const Packet8s& a) {
+  return vreinterpretq_u16_s16(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet4s, Packet4us>(const Packet4s& a) {
+  return vreinterpret_u16_s16(a);
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet8s, Packet16c>(const Packet8s& a, const Packet8s& b) {
+  return vcombine_s8(vmovn_s16(a), vmovn_s16(b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet4s, Packet8c>(const Packet4s& a, const Packet4s& b) {
+  return vmovn_s16(vcombine_s16(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet8s, Packet16uc>(const Packet8s& a, const Packet8s& b) {
+  return vcombine_u8(vmovn_u16(vreinterpretq_u16_s16(a)), vmovn_u16(vreinterpretq_u16_s16(b)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet4s, Packet8uc>(const Packet4s& a, const Packet4s& b) {
+  return vmovn_u16(vcombine_u16(vreinterpret_u16_s16(a), vreinterpret_u16_s16(b)));
+}
+
+//==============================================================================
+// pcast, SrcType = uint16_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::uint16_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet8us, Packet4f>(const Packet8us& a) {
+  // Discard second half of input.
+  return vcvtq_f32_u32(vmovl_u16(vget_low_u16(a)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet4us, Packet2f>(const Packet4us& a) {
+  // Discard second half of input.
+  return vcvt_f32_u32(vget_low_u32(vmovl_u16(a)));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet8us, Packet2ul>(const Packet8us& a) {
+  // Discard all but first two values.
+  return vmovl_u32(vget_low_u32(vmovl_u16(vget_low_u16(a))));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet8us, Packet2l>(const Packet8us& a) {
+  return vreinterpretq_s64_u64(pcast<Packet8us, Packet2ul>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet8us, Packet4ui>(const Packet8us& a) {
+  // Discard second half of input.
+  return vmovl_u16(vget_low_u16(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet4us, Packet2ui>(const Packet4us& a) {
+  // Discard second half of input.
+  return vget_low_u32(vmovl_u16(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet8us, Packet4i>(const Packet8us& a) {
+  return vreinterpretq_s32_u32(pcast<Packet8us, Packet4ui>(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet4us, Packet2i>(const Packet4us& a) {
+  return vreinterpret_s32_u32(pcast<Packet4us, Packet2ui>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet8us, Packet8us>(const Packet8us& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet4us, Packet4us>(const Packet4us& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet8us, Packet8s>(const Packet8us& a) {
+  return vreinterpretq_s16_u16(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet4us, Packet4s>(const Packet4us& a) {
+  return vreinterpret_s16_u16(a);
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet8us, Packet16uc>(const Packet8us& a, const Packet8us& b) {
+  return vcombine_u8(vmovn_u16(a), vmovn_u16(b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet4us, Packet8uc>(const Packet4us& a, const Packet4us& b) {
+  return vmovn_u16(vcombine_u16(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet8us, Packet16c>(const Packet8us& a, const Packet8us& b) {
+  return vreinterpretq_s8_u8(pcast<Packet8us, Packet16uc>(a, b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet4us, Packet8c>(const Packet4us& a, const Packet4us& b) {
+  return vreinterpret_s8_u8(pcast<Packet4us, Packet8uc>(a, b));
+}
+
+//==============================================================================
+// pcast, SrcType = int32_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::int32_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet4i, Packet4f>(const Packet4i& a) {
+  return vcvtq_f32_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet2i, Packet2f>(const Packet2i& a) {
+  return vcvt_f32_s32(a);
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet4i, Packet2l>(const Packet4i& a) {
+  // Discard second half of input.
+  return vmovl_s32(vget_low_s32(a));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet4i, Packet2ul>(const Packet4i& a) {
+  return vreinterpretq_u64_s64(pcast<Packet4i, Packet2l>(a));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet4i, Packet4i>(const Packet4i& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet2i, Packet2i>(const Packet2i& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet4i, Packet4ui>(const Packet4i& a) {
+  return vreinterpretq_u32_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet2i, Packet2ui>(const Packet2i& a) {
+  return vreinterpret_u32_s32(a);
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet4i, Packet8s>(const Packet4i& a, const Packet4i& b) {
+  return vcombine_s16(vmovn_s32(a), vmovn_s32(b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet2i, Packet4s>(const Packet2i& a, const Packet2i& b) {
+  return vmovn_s32(vcombine_s32(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet4i, Packet8us>(const Packet4i& a, const Packet4i& b) {
+  return vcombine_u16(vmovn_u32(vreinterpretq_u32_s32(a)), vmovn_u32(vreinterpretq_u32_s32(b)));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet2i, Packet4us>(const Packet2i& a, const Packet2i& b) {
+  return vmovn_u32(vreinterpretq_u32_s32(vcombine_s32(a, b)));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet4i, Packet16c>(const Packet4i& a, const Packet4i& b, const Packet4i& c,
+                                                         const Packet4i& d) {
+  const int16x8_t ab_s16 = pcast<Packet4i, Packet8s>(a, b);
+  const int16x8_t cd_s16 = pcast<Packet4i, Packet8s>(c, d);
+  return vcombine_s8(vmovn_s16(ab_s16), vmovn_s16(cd_s16));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet2i, Packet8c>(const Packet2i& a, const Packet2i& b, const Packet2i& c,
+                                                       const Packet2i& d) {
+  const int16x4_t ab_s16 = vmovn_s32(vcombine_s32(a, b));
+  const int16x4_t cd_s16 = vmovn_s32(vcombine_s32(c, d));
+  return vmovn_s16(vcombine_s16(ab_s16, cd_s16));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet4i, Packet16uc>(const Packet4i& a, const Packet4i& b, const Packet4i& c,
+                                                           const Packet4i& d) {
+  const uint16x8_t ab_u16 = pcast<Packet4i, Packet8us>(a, b);
+  const uint16x8_t cd_u16 = pcast<Packet4i, Packet8us>(c, d);
+  return vcombine_u8(vmovn_u16(ab_u16), vmovn_u16(cd_u16));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet2i, Packet8uc>(const Packet2i& a, const Packet2i& b, const Packet2i& c,
+                                                         const Packet2i& d) {
+  const uint16x4_t ab_u16 = pcast<Packet2i, Packet4us>(a, b);
+  const uint16x4_t cd_u16 = pcast<Packet2i, Packet4us>(c, d);
+  return vmovn_u16(vcombine_u16(ab_u16, cd_u16));
+}
+
+//==============================================================================
+// pcast, SrcType = uint32_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::uint32_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet4ui, Packet4f>(const Packet4ui& a) {
+  return vcvtq_f32_u32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f pcast<Packet2ui, Packet2f>(const Packet2ui& a) {
+  return vcvt_f32_u32(a);
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet4ui, Packet2ul>(const Packet4ui& a) {
+  // Discard second half of input.
+  return vmovl_u32(vget_low_u32(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet4ui, Packet2l>(const Packet4ui& a) {
+  return vreinterpretq_s64_u64(pcast<Packet4ui, Packet2ul>(a));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet4ui, Packet4ui>(const Packet4ui& a) {
+  return a;
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui pcast<Packet2ui, Packet2ui>(const Packet2ui& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet4ui, Packet4i>(const Packet4ui& a) {
+  return vreinterpretq_s32_u32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i pcast<Packet2ui, Packet2i>(const Packet2ui& a) {
+  return vreinterpret_s32_u32(a);
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet4ui, Packet8us>(const Packet4ui& a, const Packet4ui& b) {
+  return vcombine_u16(vmovn_u32(a), vmovn_u32(b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us pcast<Packet2ui, Packet4us>(const Packet2ui& a, const Packet2ui& b) {
+  return vmovn_u32(vcombine_u32(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet4ui, Packet8s>(const Packet4ui& a, const Packet4ui& b) {
+  return vreinterpretq_s16_u16(pcast<Packet4ui, Packet8us>(a, b));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4s pcast<Packet2ui, Packet4s>(const Packet2ui& a, const Packet2ui& b) {
+  return vreinterpret_s16_u16(pcast<Packet2ui, Packet4us>(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet4ui, Packet16uc>(const Packet4ui& a, const Packet4ui& b, const Packet4ui& c,
+                                                            const Packet4ui& d) {
+  const uint16x8_t ab_u16 = vcombine_u16(vmovn_u32(a), vmovn_u32(b));
+  const uint16x8_t cd_u16 = vcombine_u16(vmovn_u32(c), vmovn_u32(d));
+  return vcombine_u8(vmovn_u16(ab_u16), vmovn_u16(cd_u16));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc pcast<Packet2ui, Packet8uc>(const Packet2ui& a, const Packet2ui& b, const Packet2ui& c,
+                                                          const Packet2ui& d) {
+  const uint16x4_t ab_u16 = vmovn_u32(vcombine_u32(a, b));
+  const uint16x4_t cd_u16 = vmovn_u32(vcombine_u32(c, d));
+  return vmovn_u16(vcombine_u16(ab_u16, cd_u16));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet4ui, Packet16c>(const Packet4ui& a, const Packet4ui& b, const Packet4ui& c,
+                                                          const Packet4ui& d) {
+  return vreinterpretq_s8_u8(pcast<Packet4ui, Packet16uc>(a, b, c, d));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c pcast<Packet2ui, Packet8c>(const Packet2ui& a, const Packet2ui& b, const Packet2ui& c,
+                                                        const Packet2ui& d) {
+  return vreinterpret_s8_u8(pcast<Packet2ui, Packet8uc>(a, b, c, d));
+}
+
+//==============================================================================
+// pcast, SrcType = int64_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::int64_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet2l, Packet4f>(const Packet2l& a, const Packet2l& b) {
+  return vcvtq_f32_s32(vcombine_s32(vmovn_s64(a), vmovn_s64(b)));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet2l, Packet2l>(const Packet2l& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet2l, Packet2ul>(const Packet2l& a) {
+  return vreinterpretq_u64_s64(a);
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet2l, Packet4i>(const Packet2l& a, const Packet2l& b) {
+  return vcombine_s32(vmovn_s64(a), vmovn_s64(b));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet2l, Packet4ui>(const Packet2l& a, const Packet2l& b) {
+  return vcombine_u32(vmovn_u64(vreinterpretq_u64_s64(a)), vmovn_u64(vreinterpretq_u64_s64(b)));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet2l, Packet8s>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
+                                                       const Packet2l& d) {
+  const int32x4_t ab_s32 = pcast<Packet2l, Packet4i>(a, b);
+  const int32x4_t cd_s32 = pcast<Packet2l, Packet4i>(c, d);
+  return vcombine_s16(vmovn_s32(ab_s32), vmovn_s32(cd_s32));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet2l, Packet8us>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
+                                                         const Packet2l& d) {
+  const uint32x4_t ab_u32 = pcast<Packet2l, Packet4ui>(a, b);
+  const uint32x4_t cd_u32 = pcast<Packet2l, Packet4ui>(c, d);
+  return vcombine_u16(vmovn_u32(ab_u32), vmovn_u32(cd_u32));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet2l, Packet16c>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
+                                                         const Packet2l& d, const Packet2l& e, const Packet2l& f,
+                                                         const Packet2l& g, const Packet2l& h) {
+  const int16x8_t abcd_s16 = pcast<Packet2l, Packet8s>(a, b, c, d);
+  const int16x8_t efgh_s16 = pcast<Packet2l, Packet8s>(e, f, g, h);
+  return vcombine_s8(vmovn_s16(abcd_s16), vmovn_s16(efgh_s16));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet2l, Packet16uc>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
+                                                           const Packet2l& d, const Packet2l& e, const Packet2l& f,
+                                                           const Packet2l& g, const Packet2l& h) {
+  const uint16x8_t abcd_u16 = pcast<Packet2l, Packet8us>(a, b, c, d);
+  const uint16x8_t efgh_u16 = pcast<Packet2l, Packet8us>(e, f, g, h);
+  return vcombine_u8(vmovn_u16(abcd_u16), vmovn_u16(efgh_u16));
+}
+
+//==============================================================================
+// pcast, SrcType = uint64_t
+//==============================================================================
+template <>
+struct type_casting_traits<numext::uint64_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet2ul, Packet4f>(const Packet2ul& a, const Packet2ul& b) {
+  return vcvtq_f32_u32(vcombine_u32(vmovn_u64(a), vmovn_u64(b)));
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet2ul, Packet2ul>(const Packet2ul& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet2ul, Packet2l>(const Packet2ul& a) {
+  return vreinterpretq_s64_u64(a);
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet2ul, Packet4ui>(const Packet2ul& a, const Packet2ul& b) {
+  return vcombine_u32(vmovn_u64(a), vmovn_u64(b));
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet2ul, Packet4i>(const Packet2ul& a, const Packet2ul& b) {
+  return vreinterpretq_s32_u32(pcast<Packet2ul, Packet4ui>(a, b));
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet2ul, Packet8us>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
+                                                          const Packet2ul& d) {
+  const uint16x4_t ab_u16 = vmovn_u32(vcombine_u32(vmovn_u64(a), vmovn_u64(b)));
+  const uint16x4_t cd_u16 = vmovn_u32(vcombine_u32(vmovn_u64(c), vmovn_u64(d)));
+  return vcombine_u16(ab_u16, cd_u16);
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet2ul, Packet8s>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
+                                                        const Packet2ul& d) {
+  return vreinterpretq_s16_u16(pcast<Packet2ul, Packet8us>(a, b, c, d));
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet2ul, Packet16uc>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
+                                                            const Packet2ul& d, const Packet2ul& e, const Packet2ul& f,
+                                                            const Packet2ul& g, const Packet2ul& h) {
+  const uint16x8_t abcd_u16 = pcast<Packet2ul, Packet8us>(a, b, c, d);
+  const uint16x8_t efgh_u16 = pcast<Packet2ul, Packet8us>(e, f, g, h);
+  return vcombine_u8(vmovn_u16(abcd_u16), vmovn_u16(efgh_u16));
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet2ul, Packet16c>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
+                                                          const Packet2ul& d, const Packet2ul& e, const Packet2ul& f,
+                                                          const Packet2ul& g, const Packet2ul& h) {
+  return vreinterpretq_s8_u8(pcast<Packet2ul, Packet16uc>(a, b, c, d, e, f, g, h));
+}
+
+//==============================================================================
+// preinterpret
+//==============================================================================
+template <>
+EIGEN_STRONG_INLINE Packet2f preinterpret<Packet2f, Packet2i>(const Packet2i& a) {
+  return vreinterpret_f32_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2f preinterpret<Packet2f, Packet2ui>(const Packet2ui& a) {
+  return vreinterpret_f32_u32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f, Packet4i>(const Packet4i& a) {
+  return vreinterpretq_f32_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f, Packet4ui>(const Packet4ui& a) {
+  return vreinterpretq_f32_u32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4c preinterpret<Packet4c, Packet4uc>(const Packet4uc& a) {
+  return static_cast<Packet4c>(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8c preinterpret<Packet8c, Packet8uc>(const Packet8uc& a) {
+  return vreinterpret_s8_u8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16c preinterpret<Packet16c, Packet16uc>(const Packet16uc& a) {
+  return vreinterpretq_s8_u8(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4uc preinterpret<Packet4uc, Packet4c>(const Packet4c& a) {
+  return static_cast<Packet4uc>(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8uc preinterpret<Packet8uc, Packet8c>(const Packet8c& a) {
+  return vreinterpret_u8_s8(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet16uc preinterpret<Packet16uc, Packet16c>(const Packet16c& a) {
+  return vreinterpretq_u8_s8(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4s preinterpret<Packet4s, Packet4us>(const Packet4us& a) {
+  return vreinterpret_s16_u16(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8s preinterpret<Packet8s, Packet8us>(const Packet8us& a) {
+  return vreinterpretq_s16_u16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4us preinterpret<Packet4us, Packet4s>(const Packet4s& a) {
+  return vreinterpret_u16_s16(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet8us preinterpret<Packet8us, Packet8s>(const Packet8s& a) {
+  return vreinterpretq_u16_s16(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2i preinterpret<Packet2i, Packet2f>(const Packet2f& a) {
+  return vreinterpret_s32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2i preinterpret<Packet2i, Packet2ui>(const Packet2ui& a) {
+  return vreinterpret_s32_u32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i, Packet4f>(const Packet4f& a) {
+  return vreinterpretq_s32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i, Packet4ui>(const Packet4ui& a) {
+  return vreinterpretq_s32_u32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2ui preinterpret<Packet2ui, Packet2f>(const Packet2f& a) {
+  return vreinterpret_u32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ui preinterpret<Packet2ui, Packet2i>(const Packet2i& a) {
+  return vreinterpret_u32_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4ui preinterpret<Packet4ui, Packet4f>(const Packet4f& a) {
+  return vreinterpretq_u32_f32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4ui preinterpret<Packet4ui, Packet4i>(const Packet4i& a) {
+  return vreinterpretq_u32_s32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2l preinterpret<Packet2l, Packet2ul>(const Packet2ul& a) {
+  return vreinterpretq_s64_u64(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ul preinterpret<Packet2ul, Packet2l>(const Packet2l& a) {
+  return vreinterpretq_u64_s64(a);
+}
+
+#if EIGEN_ARCH_ARM64
+
+//==============================================================================
+// pcast/preinterpret, Double
+//==============================================================================
+
+template <>
+struct type_casting_traits<double, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet2d, Packet2d>(const Packet2d& a) {
+  return a;
+}
+
+template <>
+struct type_casting_traits<double, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet2d, Packet4f>(const Packet2d& a, const Packet2d& b) {
+  return vcombine_f32(vcvt_f32_f64(a), vcvt_f32_f64(b));
+}
+
+template <>
+struct type_casting_traits<double, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2l pcast<Packet2d, Packet2l>(const Packet2d& a) {
+  return vcvtq_s64_f64(a);
+}
+
+template <>
+struct type_casting_traits<double, numext::uint64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcast<Packet2d, Packet2ul>(const Packet2d& a) {
+  return vcvtq_u64_f64(a);
+}
+
+template <>
+struct type_casting_traits<double, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4i pcast<Packet2d, Packet4i>(const Packet2d& a, const Packet2d& b) {
+  return vcombine_s32(vmovn_s64(vcvtq_s64_f64(a)), vmovn_s64(vcvtq_s64_f64(b)));
+}
+
+template <>
+struct type_casting_traits<double, numext::uint32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet4ui pcast<Packet2d, Packet4ui>(const Packet2d& a, const Packet2d& b) {
+  return vcombine_u32(vmovn_u64(vcvtq_u64_f64(a)), vmovn_u64(vcvtq_u64_f64(b)));
+}
+
+template <>
+struct type_casting_traits<double, numext::int16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8s pcast<Packet2d, Packet8s>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
+                                                       const Packet2d& d) {
+  const int32x4_t ab_s32 = pcast<Packet2d, Packet4i>(a, b);
+  const int32x4_t cd_s32 = pcast<Packet2d, Packet4i>(c, d);
+  return vcombine_s16(vmovn_s32(ab_s32), vmovn_s32(cd_s32));
+}
+
+template <>
+struct type_casting_traits<double, numext::uint16_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 4, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet8us pcast<Packet2d, Packet8us>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
+                                                         const Packet2d& d) {
+  const uint32x4_t ab_u32 = pcast<Packet2d, Packet4ui>(a, b);
+  const uint32x4_t cd_u32 = pcast<Packet2d, Packet4ui>(c, d);
+  return vcombine_u16(vmovn_u32(ab_u32), vmovn_u32(cd_u32));
+}
+
+template <>
+struct type_casting_traits<double, numext::int8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16c pcast<Packet2d, Packet16c>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
+                                                         const Packet2d& d, const Packet2d& e, const Packet2d& f,
+                                                         const Packet2d& g, const Packet2d& h) {
+  const int16x8_t abcd_s16 = pcast<Packet2d, Packet8s>(a, b, c, d);
+  const int16x8_t efgh_s16 = pcast<Packet2d, Packet8s>(e, f, g, h);
+  return vcombine_s8(vmovn_s16(abcd_s16), vmovn_s16(efgh_s16));
+}
+
+template <>
+struct type_casting_traits<double, numext::uint8_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 8, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet16uc pcast<Packet2d, Packet16uc>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
+                                                           const Packet2d& d, const Packet2d& e, const Packet2d& f,
+                                                           const Packet2d& g, const Packet2d& h) {
+  const uint16x8_t abcd_u16 = pcast<Packet2d, Packet8us>(a, b, c, d);
+  const uint16x8_t efgh_u16 = pcast<Packet2d, Packet8us>(e, f, g, h);
+  return vcombine_u8(vmovn_u16(abcd_u16), vmovn_u16(efgh_u16));
+}
+
+template <>
+struct type_casting_traits<float, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet4f, Packet2d>(const Packet4f& a) {
+  // Discard second-half of input.
+  return vcvt_f64_f32(vget_low_f32(a));
+}
+
+template <>
+struct type_casting_traits<numext::int8_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet16c, Packet2d>(const Packet16c& a) {
+  // Discard all but first two values.
+  return vcvt_f64_f32(pcast<Packet8c, Packet2f>(vget_low_s8(a)));
+}
+
+template <>
+struct type_casting_traits<numext::uint8_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 8 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet16uc, Packet2d>(const Packet16uc& a) {
+  // Discard all but first two values.
+  return vcvt_f64_f32(pcast<Packet8uc, Packet2f>(vget_low_u8(a)));
+}
+
+template <>
+struct type_casting_traits<numext::int16_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet8s, Packet2d>(const Packet8s& a) {
+  // Discard all but first two values.
+  return vcvt_f64_f32(pcast<Packet4s, Packet2f>(vget_low_s16(a)));
+}
+
+template <>
+struct type_casting_traits<numext::uint16_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet8us, Packet2d>(const Packet8us& a) {
+  // Discard all but first two values.
+  return vcvt_f64_f32(pcast<Packet4us, Packet2f>(vget_low_u16(a)));
+}
+
+template <>
+struct type_casting_traits<numext::int32_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet4i, Packet2d>(const Packet4i& a) {
+  // Discard second half of input.
+  return vcvtq_f64_s64(vmovl_s32(vget_low_s32(a)));
+}
+
+template <>
+struct type_casting_traits<numext::uint32_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet4ui, Packet2d>(const Packet4ui& a) {
+  // Discard second half of input.
+  return vcvtq_f64_u64(vmovl_u32(vget_low_u32(a)));
+}
+
+template <>
+struct type_casting_traits<numext::int64_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet2l, Packet2d>(const Packet2l& a) {
+  return vcvtq_f64_s64(a);
+}
+
+template <>
+struct type_casting_traits<numext::uint64_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+template <>
+EIGEN_STRONG_INLINE Packet2d pcast<Packet2ul, Packet2d>(const Packet2ul& a) {
+  return vcvtq_f64_u64(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d preinterpret<Packet2d, Packet2l>(const Packet2l& a) {
+  return vreinterpretq_f64_s64(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2d preinterpret<Packet2d, Packet2ul>(const Packet2ul& a) {
+  return vreinterpretq_f64_u64(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2l preinterpret<Packet2l, Packet2d>(const Packet2d& a) {
+  return vreinterpretq_s64_f64(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ul preinterpret<Packet2ul, Packet2d>(const Packet2d& a) {
+  return vreinterpretq_u64_f64(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2d preinterpret<Packet2d, Packet4i>(const Packet4i& a) {
+  return vreinterpretq_f64_s32(a);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i, Packet2d>(const Packet2d& a) {
+  return vreinterpretq_s32_f64(a);
+}
+
+#endif  // EIGEN_ARCH_ARM64
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TYPE_CASTING_NEON_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/Complex.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/Complex.h
new file mode 100644
index 00000000..8fe22da4
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/Complex.h
@@ -0,0 +1,351 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_SSE_H
+#define EIGEN_COMPLEX_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- float ----------
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const __m128& a) : v(a) {}
+  Packet4f v;
+};
+
+// Use the packet_traits defined in AVX/PacketMath.h instead if we're going
+// to leverage AVX instructions.
+#ifndef EIGEN_VECTORIZE_AVX
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0,
+    HasBlend  = 1
+  };
+};
+#endif
+
+template<> struct unpacket_traits<Packet2cf> {
+  typedef std::complex<float> type;
+  typedef Packet2cf half;
+  typedef Packet4f as_real;
+  enum {
+    size=2,
+    alignment=Aligned16,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_add_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_sub_ps(a.v,b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a)
+{
+  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000));
+  return Packet2cf(_mm_xor_ps(a.v,mask));
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a)
+{
+  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000));
+  return Packet2cf(_mm_xor_ps(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  #ifdef EIGEN_VECTORIZE_SSE3
+  return Packet2cf(_mm_addsub_ps(_mm_mul_ps(_mm_moveldup_ps(a.v), b.v),
+                                 _mm_mul_ps(_mm_movehdup_ps(a.v),
+                                            vec4f_swizzle1(b.v, 1, 0, 3, 2))));
+//   return Packet2cf(_mm_addsub_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v),
+//                                  _mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
+//                                             vec4f_swizzle1(b.v, 1, 0, 3, 2))));
+  #else
+  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x00000000,0x80000000,0x00000000));
+  return Packet2cf(_mm_add_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v),
+                              _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3),
+                                                    vec4f_swizzle1(b.v, 1, 0, 3, 2)), mask)));
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf ptrue  <Packet2cf>(const Packet2cf& a) { return Packet2cf(ptrue(Packet4f(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pand   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_and_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf por    <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_or_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_xor_ps(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_andnot_ps(b.v,a.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pload <Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>(&numext::real_ref(*from))); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>(&numext::real_ref(*from))); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+#ifdef EIGEN_VECTORIZE_SSE3
+  res.v = _mm_castpd_ps(_mm_loaddup_pd(reinterpret_cast<double const*>(&from)));
+#else
+  res.v = _mm_castpd_ps(_mm_load_sd(reinterpret_cast<double const*>(&from)));
+  res.v = _mm_movelh_ps(res.v, res.v);
+#endif
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>* from) { return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore(&numext::real_ref(*to), Packet4f(from.v)); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *   to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&numext::real_ref(*to), Packet4f(from.v)); }
+
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
+{
+  return Packet2cf(_mm_set_ps(std::imag(from[1*stride]), std::real(from[1*stride]),
+                              std::imag(from[0*stride]), std::real(from[0*stride])));
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  to[stride*0] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 0)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 1)));
+  to[stride*1] = std::complex<float>(_mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 2)),
+                                     _mm_cvtss_f32(_mm_shuffle_ps(from.v, from.v, 3)));
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> *   addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet2cf>(const Packet2cf& a)
+{
+  #if EIGEN_GNUC_AT_MOST(4,3)
+  // Workaround gcc 4.2 ICE - this is not performance wise ideal, but who cares...
+  // This workaround also fix invalid code generation with gcc 4.3
+  EIGEN_ALIGN16 std::complex<float> res[2];
+  _mm_store_ps((float*)res, a.v);
+  return res[0];
+  #else
+  std::complex<float> res;
+  _mm_storel_pi((__m64*)&res, a.v);
+  return res;
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) { return Packet2cf(_mm_castpd_ps(preverse(Packet2d(_mm_castps_pd(a.v))))); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  return pfirst(Packet2cf(_mm_add_ps(a.v, _mm_movehl_ps(a.v,a.v))));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  return pfirst(pmul(a, Packet2cf(_mm_movehl_ps(a.v,a.v))));
+}
+
+EIGEN_STRONG_INLINE Packet2cf pcplxflip/* <Packet2cf> */(const Packet2cf& x)
+{
+  return Packet2cf(vec4f_swizzle1(x.v, 1, 0, 3, 2));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for SSE3 and 4
+  Packet2cf res = pmul(a, pconj(b));
+  __m128 s = _mm_mul_ps(b.v,b.v);
+  return Packet2cf(_mm_div_ps(res.v,_mm_add_ps(s,vec4f_swizzle1(s, 1, 0, 3, 2))));
+}
+
+
+
+//---------- double ----------
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const __m128d& a) : v(a) {}
+  Packet2d v;
+};
+
+// Use the packet_traits defined in AVX/PacketMath.h instead if we're going
+// to leverage AVX instructions.
+#ifndef EIGEN_VECTORIZE_AVX
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasSqrt   = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+#endif
+
+template<> struct unpacket_traits<Packet1cd> {
+  typedef std::complex<double> type;
+  typedef Packet1cd half;
+  typedef Packet2d as_real;
+  enum {
+    size=1,
+    alignment=Aligned16,
+    vectorizable=true,
+    masked_load_available=false,
+    masked_store_available=false
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_add_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_sub_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a)
+{
+  const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0));
+  return Packet1cd(_mm_xor_pd(a.v,mask));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  #ifdef EIGEN_VECTORIZE_SSE3
+  return Packet1cd(_mm_addsub_pd(_mm_mul_pd(_mm_movedup_pd(a.v), b.v),
+                                 _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
+                                            vec2d_swizzle1(b.v, 1, 0))));
+  #else
+  const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x0,0x0,0x80000000,0x0));
+  return Packet1cd(_mm_add_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v),
+                              _mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
+                                                    vec2d_swizzle1(b.v, 1, 0)), mask)));
+  #endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd ptrue  <Packet1cd>(const Packet1cd& a) { return Packet1cd(ptrue(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pand   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_and_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd por    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_or_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pxor   <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_xor_pd(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_andnot_pd(b.v,a.v)); }
+
+// FIXME force unaligned load, this is a temporary fix
+template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from)
+{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>&  from)
+{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) { return pset1<Packet1cd>(*from); }
+
+// FIXME force unaligned store, this is a temporary fix
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, Packet2d(from.v)); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, Packet2d(from.v)); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> *   addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double>  pfirst<Packet1cd>(const Packet1cd& a)
+{
+  EIGEN_ALIGN16 double res[2];
+  _mm_store_pd(res, a.v);
+  return std::complex<double>(res[0],res[1]);
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for SSE3 and 4
+  Packet1cd res = pmul(a,pconj(b));
+  __m128d s = _mm_mul_pd(b.v,b.v);
+  return Packet1cd(_mm_div_pd(res.v, _mm_add_pd(s,_mm_shuffle_pd(s, s, 0x1))));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/* <Packet1cd> */(const Packet1cd& x)
+{
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2cf,2>& kernel) {
+  __m128d w1 = _mm_castps_pd(kernel.packet[0].v);
+  __m128d w2 = _mm_castps_pd(kernel.packet[1].v);
+
+  __m128 tmp = _mm_castpd_ps(_mm_unpackhi_pd(w1, w2));
+  kernel.packet[0].v = _mm_castpd_ps(_mm_unpacklo_pd(w1, w2));
+  kernel.packet[1].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b)
+{
+  __m128 eq = _mm_cmpeq_ps(a.v, b.v);
+  return Packet2cf(pand<Packet4f>(eq, vec4f_swizzle1(eq, 1, 0, 3, 2)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b)
+{
+  __m128d eq = _mm_cmpeq_pd(a.v, b.v);
+  return Packet1cd(pand<Packet2d>(eq, vec2d_swizzle1(eq, 1, 0)));
+}
+
+template<>  EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  __m128d result = pblend<Packet2d>(ifPacket, _mm_castps_pd(thenPacket.v), _mm_castps_pd(elsePacket.v));
+  return Packet2cf(_mm_castpd_ps(result));
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd psqrt<Packet1cd>(const Packet1cd& a) {
+  return psqrt_complex<Packet1cd>(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf psqrt<Packet2cf>(const Packet2cf& a) {
+  return psqrt_complex<Packet2cf>(a);
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_SSE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/MathFunctions.h
new file mode 100644
index 00000000..8736d0d6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/MathFunctions.h
@@ -0,0 +1,199 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The sin and cos and functions of this file come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+#ifndef EIGEN_MATH_FUNCTIONS_SSE_H
+#define EIGEN_MATH_FUNCTIONS_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f plog<Packet4f>(const Packet4f& _x) {
+  return plog_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d plog<Packet2d>(const Packet2d& _x) {
+  return plog_double(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f plog2<Packet4f>(const Packet4f& _x) {
+  return plog2_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d plog2<Packet2d>(const Packet2d& _x) {
+  return plog2_double(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f plog1p<Packet4f>(const Packet4f& _x) {
+  return generic_plog1p(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexpm1<Packet4f>(const Packet4f& _x) {
+  return generic_expm1(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexp<Packet4f>(const Packet4f& _x)
+{
+  return pexp_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d pexp<Packet2d>(const Packet2d& x)
+{
+  return pexp_double(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psin<Packet4f>(const Packet4f& _x)
+{
+  return psin_float(_x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pcos<Packet4f>(const Packet4f& _x)
+{
+  return pcos_float(_x);
+}
+
+#if EIGEN_FAST_MATH
+
+// Functions for sqrt.
+// The EIGEN_FAST_MATH version uses the _mm_rsqrt_ps approximation and one step
+// of Newton's method, at a cost of 1-2 bits of precision as opposed to the
+// exact solution. It does not handle +inf, or denormalized numbers correctly.
+// The main advantage of this approach is not just speed, but also the fact that
+// it can be inlined and pipelined with other computations, further reducing its
+// effective latency. This is similar to Quake3's fast inverse square root.
+// For detail see here: http://www.beyond3d.com/content/articles/8/
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& _x)
+{
+  Packet4f minus_half_x = pmul(_x, pset1<Packet4f>(-0.5f));
+  Packet4f denormal_mask = pandnot(
+      pcmp_lt(_x, pset1<Packet4f>((std::numeric_limits<float>::min)())),
+      pcmp_lt(_x, pzero(_x)));
+
+  // Compute approximate reciprocal sqrt.
+  Packet4f x = _mm_rsqrt_ps(_x);
+  // Do a single step of Newton's iteration.
+  x = pmul(x, pmadd(minus_half_x, pmul(x,x), pset1<Packet4f>(1.5f)));
+  // Flush results for denormals to zero.
+  return pandnot(pmul(_x,x), denormal_mask);
+}
+
+#else
+
+template<>EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& x) { return _mm_sqrt_ps(x); }
+
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d psqrt<Packet2d>(const Packet2d& x) { return _mm_sqrt_pd(x); }
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet16b psqrt<Packet16b>(const Packet16b& x) { return x; }
+
+#if EIGEN_FAST_MATH
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& _x) {
+  _EIGEN_DECLARE_CONST_Packet4f(one_point_five, 1.5f);
+  _EIGEN_DECLARE_CONST_Packet4f(minus_half, -0.5f);
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(inf, 0x7f800000u);
+  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(flt_min, 0x00800000u);
+
+  Packet4f neg_half = pmul(_x, p4f_minus_half);
+
+  // Identity infinite, zero, negative and denormal arguments.
+  Packet4f lt_min_mask = _mm_cmplt_ps(_x, p4f_flt_min);
+  Packet4f inf_mask = _mm_cmpeq_ps(_x, p4f_inf);
+  Packet4f not_normal_finite_mask = _mm_or_ps(lt_min_mask, inf_mask);
+
+  // Compute an approximate result using the rsqrt intrinsic.
+  Packet4f y_approx = _mm_rsqrt_ps(_x);
+
+  // Do a single step of Newton-Raphson iteration to improve the approximation.
+  // This uses the formula y_{n+1} = y_n * (1.5 - y_n * (0.5 * x) * y_n).
+  // It is essential to evaluate the inner term like this because forming
+  // y_n^2 may over- or underflow.
+  Packet4f y_newton = pmul(
+      y_approx, pmadd(y_approx, pmul(neg_half, y_approx), p4f_one_point_five));
+
+  // Select the result of the Newton-Raphson step for positive normal arguments.
+  // For other arguments, choose the output of the intrinsic. This will
+  // return rsqrt(+inf) = 0, rsqrt(x) = NaN if x < 0, and rsqrt(x) = +inf if
+  // x is zero or a positive denormalized float (equivalent to flushing positive
+  // denormalized inputs to zero).
+  return pselect<Packet4f>(not_normal_finite_mask, y_approx, y_newton);
+}
+
+#else
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& x) {
+  // Unfortunately we can't use the much faster mm_rsqrt_ps since it only provides an approximation.
+  return _mm_div_ps(pset1<Packet4f>(1.0f), _mm_sqrt_ps(x));
+}
+
+#endif
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d prsqrt<Packet2d>(const Packet2d& x) {
+  return _mm_div_pd(pset1<Packet2d>(1.0), _mm_sqrt_pd(x));
+}
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+ptanh<Packet4f>(const Packet4f& x) {
+  return internal::generic_fast_tanh_float(x);
+}
+
+} // end namespace internal
+
+namespace numext {
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+float sqrt(const float &x)
+{
+  return internal::pfirst(internal::Packet4f(_mm_sqrt_ss(_mm_set_ss(x))));
+}
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+double sqrt(const double &x)
+{
+#if EIGEN_COMP_GNUC_STRICT
+  // This works around a GCC bug generating poor code for _mm_sqrt_pd
+  // See https://gitlab.com/libeigen/eigen/commit/8dca9f97e38970
+  return internal::pfirst(internal::Packet2d(__builtin_ia32_sqrtsd(_mm_set_sd(x))));
+#else
+  return internal::pfirst(internal::Packet2d(_mm_sqrt_pd(_mm_set_sd(x))));
+#endif
+}
+
+} // end namespace numex
+
+} // end namespace Eigen
+
+#endif // EIGEN_MATH_FUNCTIONS_SSE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/PacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/PacketMath.h
new file mode 100644
index 00000000..db102c73
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/PacketMath.h
@@ -0,0 +1,1505 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_SSE_H
+#define EIGEN_PACKET_MATH_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#if !defined(EIGEN_VECTORIZE_AVX) && !defined(EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS)
+// 32 bits =>  8 registers
+// 64 bits => 16 registers
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS (2*sizeof(void*))
+#endif
+
+#ifdef EIGEN_VECTORIZE_FMA
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+#endif
+
+#if ((defined EIGEN_VECTORIZE_AVX) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_MINGW) && (__GXX_ABI_VERSION < 1004)) || EIGEN_OS_QNX
+// With GCC's default ABI version, a __m128 or __m256 are the same types and therefore we cannot
+// have overloads for both types without linking error.
+// One solution is to increase ABI version using -fabi-version=4 (or greater).
+// Otherwise, we workaround this inconvenience by wrapping 128bit types into the following helper
+// structure:
+typedef eigen_packet_wrapper<__m128>  Packet4f;
+typedef eigen_packet_wrapper<__m128d> Packet2d;
+#else
+typedef __m128  Packet4f;
+typedef __m128d Packet2d;
+#endif
+
+typedef eigen_packet_wrapper<__m128i, 0> Packet4i;
+typedef eigen_packet_wrapper<__m128i, 1> Packet16b;
+
+template<> struct is_arithmetic<__m128>  { enum { value = true }; };
+template<> struct is_arithmetic<__m128i> { enum { value = true }; };
+template<> struct is_arithmetic<__m128d> { enum { value = true }; };
+template<> struct is_arithmetic<Packet4i>  { enum { value = true }; };
+template<> struct is_arithmetic<Packet16b>  { enum { value = true }; };
+
+template<int p, int q, int r, int s>
+struct shuffle_mask{
+ enum { mask = (s)<<6|(r)<<4|(q)<<2|(p) };
+};
+
+// TODO: change the implementation of all swizzle* ops from macro to template,
+#define vec4f_swizzle1(v,p,q,r,s) \
+  Packet4f(_mm_castsi128_ps(_mm_shuffle_epi32( _mm_castps_si128(v), (shuffle_mask<p,q,r,s>::mask))))
+
+#define vec4i_swizzle1(v,p,q,r,s) \
+  Packet4i(_mm_shuffle_epi32( v, (shuffle_mask<p,q,r,s>::mask)))
+
+#define vec2d_swizzle1(v,p,q) \
+  Packet2d(_mm_castsi128_pd(_mm_shuffle_epi32( _mm_castpd_si128(v), (shuffle_mask<2*p,2*p+1,2*q,2*q+1>::mask))))
+
+#define vec4f_swizzle2(a,b,p,q,r,s) \
+  Packet4f(_mm_shuffle_ps( (a), (b), (shuffle_mask<p,q,r,s>::mask)))
+
+#define vec4i_swizzle2(a,b,p,q,r,s) \
+  Packet4i(_mm_castps_si128( (_mm_shuffle_ps( _mm_castsi128_ps(a), _mm_castsi128_ps(b), (shuffle_mask<p,q,r,s>::mask)))))
+
+EIGEN_STRONG_INLINE Packet4f vec4f_movelh(const Packet4f& a, const Packet4f& b)
+{
+  return Packet4f(_mm_movelh_ps(a,b));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_movehl(const Packet4f& a, const Packet4f& b)
+{
+  return Packet4f(_mm_movehl_ps(a,b));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_unpacklo(const Packet4f& a, const Packet4f& b)
+{
+  return Packet4f(_mm_unpacklo_ps(a,b));
+}
+EIGEN_STRONG_INLINE Packet4f vec4f_unpackhi(const Packet4f& a, const Packet4f& b)
+{
+  return Packet4f(_mm_unpackhi_ps(a,b));
+}
+#define vec4f_duplane(a,p) \
+  vec4f_swizzle2(a,a,p,p,p,p)
+
+#define vec2d_swizzle2(a,b,mask) \
+  Packet2d(_mm_shuffle_pd(a,b,mask))
+
+EIGEN_STRONG_INLINE Packet2d vec2d_unpacklo(const Packet2d& a, const Packet2d& b)
+{
+  return Packet2d(_mm_unpacklo_pd(a,b));
+}
+EIGEN_STRONG_INLINE Packet2d vec2d_unpackhi(const Packet2d& a, const Packet2d& b)
+{
+  return Packet2d(_mm_unpackhi_pd(a,b));
+}
+#define vec2d_duplane(a,p) \
+  vec2d_swizzle2(a,a,(p<<1)|p)
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  const Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME,X) \
+  const Packet2d p2d_##NAME = pset1<Packet2d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = pset1frombits<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  const Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+
+// Use the packet_traits defined in AVX/PacketMath.h instead if we're going
+// to leverage AVX instructions.
+#ifndef EIGEN_VECTORIZE_AVX
+template <>
+struct packet_traits<float> : default_packet_traits {
+  typedef Packet4f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasCmp  = 1,
+    HasDiv = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasLog1p = 1,
+    HasExpm1 = 1,
+    HasNdtri = 1,
+    HasExp = 1,
+    HasBessel = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH,
+    HasBlend = 1,
+    HasCeil = 1,
+    HasFloor = 1,
+#ifdef EIGEN_VECTORIZE_SSE4_1
+    HasRound = 1,
+#endif
+    HasRint = 1
+  };
+};
+template <>
+struct packet_traits<double> : default_packet_traits {
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 0,
+
+    HasCmp  = 1,
+    HasDiv  = 1,
+    HasLog  = 1,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasBlend = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+#ifdef EIGEN_VECTORIZE_SSE4_1
+    HasRound = 1,
+#endif
+    HasRint = 1
+  };
+};
+#endif
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet4i type;
+  typedef Packet4i half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=4,
+
+    HasShift = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct packet_traits<bool> : default_packet_traits
+{
+  typedef Packet16b type;
+  typedef Packet16b half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    HasHalfPacket = 0,
+    size=16,
+
+    HasAdd       = 1,
+    HasSub       = 1,
+    HasShift     = 0,
+    HasMul       = 1,
+    HasNegate    = 1,
+    HasAbs       = 0,
+    HasAbs2      = 0,
+    HasMin       = 0,
+    HasMax       = 0,
+    HasConj      = 0,
+    HasSqrt      = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet4f> {
+  typedef float     type;
+  typedef Packet4f  half;
+  typedef Packet4i  integer_packet;
+  enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet2d> {
+  typedef double    type;
+  typedef Packet2d  half;
+  enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet4i> {
+  typedef int       type;
+  typedef Packet4i  half;
+  enum {size=4, alignment=Aligned16, vectorizable=false, masked_load_available=false, masked_store_available=false};
+};
+template<> struct unpacket_traits<Packet16b> {
+  typedef bool       type;
+  typedef Packet16b  half;
+  enum {size=16, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false};
+};
+
+#ifndef EIGEN_VECTORIZE_AVX
+template<> struct scalar_div_cost<float,true> { enum { value = 7 }; };
+template<> struct scalar_div_cost<double,true> { enum { value = 8 }; };
+#endif
+
+#if EIGEN_COMP_MSVC==1500
+// Workaround MSVC 9 internal compiler error.
+// TODO: It has been detected with win64 builds (amd64), so let's check whether it also happens in 32bits+SSE mode
+// TODO: let's check whether there does not exist a better fix, like adding a pset0() function. (it crashed on pset1(0)).
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) { return _mm_set_ps(from,from,from,from); }
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set_pd(from,from); }
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from) { return _mm_set_epi32(from,from,from,from); }
+#else
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&  from) { return _mm_set_ps1(from); }
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set1_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from) { return _mm_set1_epi32(from); }
+#endif
+template<> EIGEN_STRONG_INLINE Packet16b pset1<Packet16b>(const bool&    from) { return _mm_set1_epi8(static_cast<char>(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1frombits<Packet4f>(unsigned int from) { return _mm_castsi128_ps(pset1<Packet4i>(from)); }
+template<> EIGEN_STRONG_INLINE Packet2d pset1frombits<Packet2d>(uint64_t from) { return _mm_castsi128_pd(_mm_set1_epi64x(from)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f peven_mask(const Packet4f& /*a*/) { return _mm_castsi128_ps(_mm_set_epi32(0, -1, 0, -1)); }
+template<> EIGEN_STRONG_INLINE Packet4i peven_mask(const Packet4i& /*a*/) { return _mm_set_epi32(0, -1, 0, -1); }
+template<> EIGEN_STRONG_INLINE Packet2d peven_mask(const Packet2d& /*a*/) { return _mm_castsi128_pd(_mm_set_epi32(0, 0, -1, -1)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pzero(const Packet4f& /*a*/) { return _mm_setzero_ps(); }
+template<> EIGEN_STRONG_INLINE Packet2d pzero(const Packet2d& /*a*/) { return _mm_setzero_pd(); }
+template<> EIGEN_STRONG_INLINE Packet4i pzero(const Packet4i& /*a*/) { return _mm_setzero_si128(); }
+
+// GCC generates a shufps instruction for _mm_set1_ps/_mm_load1_ps instead of the more efficient pshufd instruction.
+// However, using inrinsics for pset1 makes gcc to generate crappy code in some cases (see bug 203)
+// Using inline assembly is also not an option because then gcc fails to reorder properly the instructions.
+// Therefore, we introduced the pload1 functions to be used in product kernels for which bug 203 does not apply.
+// Also note that with AVX, we want it to generate a vbroadcastss.
+#if EIGEN_COMP_GNUC_STRICT && (!defined __AVX__)
+template<> EIGEN_STRONG_INLINE Packet4f pload1<Packet4f>(const float *from) {
+  return vec4f_swizzle1(_mm_load_ss(from),0,0,0,0);
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(const float& a) { return _mm_add_ps(pset1<Packet4f>(a), _mm_set_ps(3,2,1,0)); }
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) { return _mm_add_pd(pset1<Packet2d>(a),_mm_set_pd(1,0)); }
+template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int& a) { return _mm_add_epi32(pset1<Packet4i>(a),_mm_set_epi32(3,2,1,0)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_add_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_add_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_add_epi32(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet16b padd<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_or_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_sub_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_sub_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_sub_epi32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16b psub<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_xor_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b);
+template<> EIGEN_STRONG_INLINE Packet4f paddsub<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE3
+  return _mm_addsub_ps(a,b);
+#else
+  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x0,0x80000000,0x0));
+  return padd(a, pxor(mask, b));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& , const Packet2d& );
+template<> EIGEN_STRONG_INLINE Packet2d paddsub<Packet2d>(const Packet2d& a, const Packet2d& b) 
+{
+#ifdef EIGEN_VECTORIZE_SSE3  
+  return _mm_addsub_pd(a,b); 
+#else
+  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x80000000,0x0,0x0)); 
+  return padd(a, pxor(mask, b));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a)
+{
+  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000));
+  return _mm_xor_ps(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a)
+{
+  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x80000000,0x0,0x80000000));
+  return _mm_xor_pd(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a)
+{
+  return psub(Packet4i(_mm_setr_epi32(0,0,0,0)), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet16b pnegate(const Packet16b& a)
+{
+  return psub(pset1<Packet16b>(false), a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_mul_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_mul_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_mullo_epi32(a,b);
+#else
+  // this version is slightly faster than 4 scalar products
+  return vec4i_swizzle1(
+            vec4i_swizzle2(
+              _mm_mul_epu32(a,b),
+              _mm_mul_epu32(vec4i_swizzle1(a,1,0,3,2),
+                            vec4i_swizzle1(b,1,0,3,2)),
+              0,2,0,2),
+            0,2,1,3);
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet16b pmul<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_and_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_div_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_div_pd(a,b); }
+
+// for some weird raisons, it has to be overloaded for packet of integers
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd(pmul(a,b), c); }
+#ifdef EIGEN_VECTORIZE_FMA
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) { return _mm_fmadd_ps(a,b,c); }
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return _mm_fmadd_pd(a,b,c); }
+#endif
+
+#ifdef EIGEN_VECTORIZE_SSE4_1
+template<> EIGEN_DEVICE_FUNC inline Packet4f pselect(const Packet4f& mask, const Packet4f& a, const Packet4f& b) {
+  return _mm_blendv_ps(b,a,mask);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4i pselect(const Packet4i& mask, const Packet4i& a, const Packet4i& b) {
+  return _mm_castps_si128(_mm_blendv_ps(_mm_castsi128_ps(b),_mm_castsi128_ps(a),_mm_castsi128_ps(mask)));
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet2d pselect(const Packet2d& mask, const Packet2d& a, const Packet2d& b) {  return _mm_blendv_pd(b,a,mask); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet16b pselect(const Packet16b& mask, const Packet16b& a, const Packet16b& b) {
+  return _mm_blendv_epi8(b,a,mask);
+}
+#else
+template<> EIGEN_DEVICE_FUNC inline Packet16b pselect(const Packet16b& mask, const Packet16b& a, const Packet16b& b) {
+  Packet16b a_part = _mm_and_si128(mask, a);
+  Packet16b b_part = _mm_andnot_si128(mask, b);
+  return _mm_or_si128(a_part, b_part);
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4i ptrue<Packet4i>(const Packet4i& a) { return _mm_cmpeq_epi32(a, a); }
+template<> EIGEN_STRONG_INLINE Packet16b ptrue<Packet16b>(const Packet16b& a) { return _mm_cmpeq_epi8(a, a); }
+template<> EIGEN_STRONG_INLINE Packet4f
+ptrue<Packet4f>(const Packet4f& a) {
+  Packet4i b = _mm_castps_si128(a);
+  return _mm_castsi128_ps(_mm_cmpeq_epi32(b, b));
+}
+template<> EIGEN_STRONG_INLINE Packet2d
+ptrue<Packet2d>(const Packet2d& a) {
+  Packet4i b = _mm_castpd_si128(a);
+  return _mm_castsi128_pd(_mm_cmpeq_epi32(b, b));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_and_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_and_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_and_si128(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16b pand<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_and_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_or_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_or_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_or_si128(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16b por<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_or_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_xor_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_xor_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_xor_si128(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16b pxor<Packet16b>(const Packet16b& a, const Packet16b& b) { return _mm_xor_si128(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_andnot_ps(b,a); }
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_andnot_pd(b,a); }
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_andnot_si128(b,a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_le(const Packet4f& a, const Packet4f& b) { return _mm_cmple_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt(const Packet4f& a, const Packet4f& b) { return _mm_cmplt_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan(const Packet4f& a, const Packet4f& b) { return _mm_cmpnge_ps(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4f pcmp_eq(const Packet4f& a, const Packet4f& b) { return _mm_cmpeq_ps(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_le(const Packet2d& a, const Packet2d& b) { return _mm_cmple_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt(const Packet2d& a, const Packet2d& b) { return _mm_cmplt_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan(const Packet2d& a, const Packet2d& b) { return _mm_cmpnge_pd(a,b); }
+template<> EIGEN_STRONG_INLINE Packet2d pcmp_eq(const Packet2d& a, const Packet2d& b) { return _mm_cmpeq_pd(a,b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_lt(const Packet4i& a, const Packet4i& b) { return _mm_cmplt_epi32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_eq(const Packet4i& a, const Packet4i& b) { return _mm_cmpeq_epi32(a,b); }
+template<> EIGEN_STRONG_INLINE Packet16b pcmp_eq(const Packet16b& a, const Packet16b& b) { return _mm_cmpeq_epi8(a,b); }
+template<> EIGEN_STRONG_INLINE Packet4i pcmp_le(const Packet4i& a, const Packet4i& b) { return por(pcmp_lt(a,b), pcmp_eq(a,b)); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_min_ps, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  #ifdef EIGEN_VECTORIZE_AVX
+  Packet4f res;
+  asm("vminps %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  #else
+  Packet4f res = b;
+  asm("minps %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  #endif
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm_min_ps(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_min_pd, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  #ifdef EIGEN_VECTORIZE_AVX
+  Packet2d res;
+  asm("vminpd %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  #else
+  Packet2d res = b;
+  asm("minpd %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  #endif
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::min.
+  return _mm_min_pd(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_min_epi32(a,b);
+#else
+  // after some bench, this version *is* faster than a scalar implementation
+  Packet4i mask = _mm_cmplt_epi32(a,b);
+  return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b));
+#endif
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_max_ps, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  #ifdef EIGEN_VECTORIZE_AVX
+  Packet4f res;
+  asm("vmaxps %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  #else
+  Packet4f res = b;
+  asm("maxps %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  #endif
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm_max_ps(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) {
+#if EIGEN_COMP_GNUC && EIGEN_COMP_GNUC < 63
+  // There appears to be a bug in GCC, by which the optimizer may
+  // flip the argument order in calls to _mm_max_pd, so we have to
+  // resort to inline ASM here. This is supposed to be fixed in gcc6.3,
+  // see also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=72867
+  #ifdef EIGEN_VECTORIZE_AVX
+  Packet2d res;
+  asm("vmaxpd %[a], %[b], %[res]" : [res] "=x" (res) : [a] "x" (a), [b] "x" (b));
+  #else
+  Packet2d res = b;
+  asm("maxpd %[a], %[res]" : [res] "+x" (res) : [a] "x" (a));
+  #endif
+  return res;
+#else
+  // Arguments are reversed to match NaN propagation behavior of std::max.
+  return _mm_max_pd(b, a);
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_max_epi32(a,b);
+#else
+  // after some bench, this version *is* faster than a scalar implementation
+  Packet4i mask = _mm_cmpgt_epi32(a,b);
+  return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b));
+#endif
+}
+
+template <typename Packet, typename Op>
+EIGEN_STRONG_INLINE Packet pminmax_propagate_numbers(const Packet& a, const Packet& b, Op op) {
+  // In this implementation, we take advantage of the fact that pmin/pmax for SSE
+  // always return a if either a or b is NaN.
+  Packet not_nan_mask_a = pcmp_eq(a, a);
+  Packet m = op(a, b);
+  return pselect<Packet>(not_nan_mask_a, m, b);
+}
+
+template <typename Packet, typename Op>
+EIGEN_STRONG_INLINE Packet pminmax_propagate_nan(const Packet& a, const Packet& b, Op op) {
+  // In this implementation, we take advantage of the fact that pmin/pmax for SSE
+  // always return a if either a or b is NaN.
+  Packet not_nan_mask_a = pcmp_eq(a, a);
+  Packet m = op(b, a);
+  return pselect<Packet>(not_nan_mask_a, m, a);
+}
+
+// Add specializations for min/max with prescribed NaN progation.
+template<>
+EIGEN_STRONG_INLINE Packet4f pmin<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet4f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet2d pmin<PropagateNumbers, Packet2d>(const Packet2d& a, const Packet2d& b) {
+  return pminmax_propagate_numbers(a, b, pmin<Packet2d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4f pmax<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet4f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet2d pmax<PropagateNumbers, Packet2d>(const Packet2d& a, const Packet2d& b) {
+  return pminmax_propagate_numbers(a, b, pmax<Packet2d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4f pmin<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet4f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet2d pmin<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) {
+  return pminmax_propagate_nan(a, b, pmin<Packet2d>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet4f pmax<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet4f>);
+}
+template<>
+EIGEN_STRONG_INLINE Packet2d pmax<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) {
+  return pminmax_propagate_nan(a, b, pmax<Packet2d>);
+}
+
+template<int N> EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(const Packet4i& a) { return _mm_srai_epi32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_right   (const Packet4i& a) { return _mm_srli_epi32(a,N); }
+template<int N> EIGEN_STRONG_INLINE Packet4i plogical_shift_left    (const Packet4i& a) { return _mm_slli_epi32(a,N); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a)
+{
+  const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF));
+  return _mm_and_ps(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a)
+{
+  const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF));
+  return _mm_and_pd(a,mask);
+}
+template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a)
+{
+  #ifdef EIGEN_VECTORIZE_SSSE3
+  return _mm_abs_epi32(a);
+  #else
+  Packet4i aux = _mm_srai_epi32(a,31);
+  return _mm_sub_epi32(_mm_xor_si128(a,aux),aux);
+  #endif
+}
+
+#ifdef EIGEN_VECTORIZE_SSE4_1
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a)
+{
+  // Unfortunatly _mm_round_ps doesn't have a rounding mode to implement numext::round.
+  const Packet4f mask = pset1frombits<Packet4f>(0x80000000u);
+  const Packet4f prev0dot5 = pset1frombits<Packet4f>(0x3EFFFFFFu);
+  return _mm_round_ps(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a)
+{
+  const Packet2d mask = _mm_castsi128_pd(_mm_set_epi64x(0x8000000000000000ull, 0x8000000000000000ull));
+  const Packet2d prev0dot5 = _mm_castsi128_pd(_mm_set_epi64x(0x3FDFFFFFFFFFFFFFull, 0x3FDFFFFFFFFFFFFFull));
+  return _mm_round_pd(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f print<Packet4f>(const Packet4f& a) { return _mm_round_ps(a, _MM_FROUND_CUR_DIRECTION); }
+template<> EIGEN_STRONG_INLINE Packet2d print<Packet2d>(const Packet2d& a) { return _mm_round_pd(a, _MM_FROUND_CUR_DIRECTION); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a) { return _mm_ceil_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a) { return _mm_ceil_pd(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a) { return _mm_floor_ps(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) { return _mm_floor_pd(a); }
+#else
+template<> EIGEN_STRONG_INLINE Packet4f print(const Packet4f& a) {
+  // Adds and subtracts signum(a) * 2^23 to force rounding.
+  const Packet4f limit = pset1<Packet4f>(static_cast<float>(1<<23));
+  const Packet4f abs_a = pabs(a);
+  Packet4f r = padd(abs_a, limit);
+  // Don't compile-away addition and subtraction.
+  EIGEN_OPTIMIZATION_BARRIER(r);
+  r = psub(r, limit);
+  // If greater than limit, simply return a.  Otherwise, account for sign.
+  r = pselect(pcmp_lt(abs_a, limit),
+              pselect(pcmp_lt(a, pzero(a)), pnegate(r), r), a);
+  return r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d print(const Packet2d& a) {
+  // Adds and subtracts signum(a) * 2^52 to force rounding.
+  const Packet2d limit = pset1<Packet2d>(static_cast<double>(1ull<<52));
+  const Packet2d abs_a = pabs(a);
+  Packet2d r = padd(abs_a, limit);
+  // Don't compile-away addition and subtraction.
+  EIGEN_OPTIMIZATION_BARRIER(r);
+  r = psub(r, limit);
+  // If greater than limit, simply return a.  Otherwise, account for sign.
+  r = pselect(pcmp_lt(abs_a, limit),
+              pselect(pcmp_lt(a, pzero(a)), pnegate(r), r), a);
+  return r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a)
+{
+  const Packet4f cst_1 = pset1<Packet4f>(1.0f);
+  Packet4f tmp  = print<Packet4f>(a);
+  // If greater, subtract one.
+  Packet4f mask = _mm_cmpgt_ps(tmp, a);
+  mask = pand(mask, cst_1);
+  return psub(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a)
+{
+  const Packet2d cst_1 = pset1<Packet2d>(1.0);
+  Packet2d tmp  = print<Packet2d>(a);
+  // If greater, subtract one.
+  Packet2d mask = _mm_cmpgt_pd(tmp, a);
+  mask = pand(mask, cst_1);
+  return psub(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const Packet4f& a)
+{
+  const Packet4f cst_1 = pset1<Packet4f>(1.0f);
+  Packet4f tmp  = print<Packet4f>(a);
+  // If smaller, add one.
+  Packet4f mask = _mm_cmplt_ps(tmp, a);
+  mask = pand(mask, cst_1);
+  return padd(tmp, mask);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const Packet2d& a)
+{
+  const Packet2d cst_1 = pset1<Packet2d>(1.0);
+  Packet2d tmp  = print<Packet2d>(a);
+  // If smaller, add one.
+  Packet2d mask = _mm_cmplt_pd(tmp, a);
+  mask = pand(mask, cst_1);
+  return padd(tmp, mask);
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float*   from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_ps(from); }
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double*  from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_pd(from); }
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int*     from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast<const __m128i*>(from)); }
+template<> EIGEN_STRONG_INLINE Packet16b pload<Packet16b>(const bool*     from) { EIGEN_DEBUG_ALIGNED_LOAD return  _mm_load_si128(reinterpret_cast<const __m128i*>(from)); }
+
+#if EIGEN_COMP_MSVC
+  template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float*  from) {
+    EIGEN_DEBUG_UNALIGNED_LOAD
+    #if (EIGEN_COMP_MSVC==1600)
+    // NOTE Some version of MSVC10 generates bad code when using _mm_loadu_ps
+    // (i.e., it does not generate an unaligned load!!
+    __m128 res = _mm_loadl_pi(_mm_set1_ps(0.0f), (const __m64*)(from));
+    res = _mm_loadh_pi(res, (const __m64*)(from+2));
+    return res;
+    #else
+    return _mm_loadu_ps(from);
+    #endif
+  }
+#else
+// NOTE: with the code below, MSVC's compiler crashes!
+
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_ps(from);
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_pd(from);
+}
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+}
+template<> EIGEN_STRONG_INLINE Packet16b ploadu<Packet16b>(const bool*     from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD
+  return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float*   from)
+{
+  return vec4f_swizzle1(_mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(from))), 0, 0, 1, 1);
+}
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double*  from)
+{ return pset1<Packet2d>(from[0]); }
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int*     from)
+{
+  Packet4i tmp;
+  tmp = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(from));
+  return vec4i_swizzle1(tmp, 0, 0, 1, 1);
+}
+
+// Loads 8 bools from memory and returns the packet
+// {b0, b0, b1, b1, b2, b2, b3, b3, b4, b4, b5, b5, b6, b6, b7, b7}
+template<> EIGEN_STRONG_INLINE Packet16b ploaddup<Packet16b>(const bool*     from)
+{
+  __m128i tmp = _mm_castpd_si128(pload1<Packet2d>(reinterpret_cast<const double*>(from)));
+  return  _mm_unpacklo_epi8(tmp, tmp);
+}
+
+// Loads 4 bools from memory and returns the packet
+// {b0, b0  b0, b0, b1, b1, b1, b1, b2, b2, b2, b2, b3, b3, b3, b3}
+template<> EIGEN_STRONG_INLINE Packet16b
+ploadquad<Packet16b>(const bool* from) {
+  __m128i tmp = _mm_castps_si128(pload1<Packet4f>(reinterpret_cast<const float*>(from)));
+  tmp = _mm_unpacklo_epi8(tmp, tmp);
+  return  _mm_unpacklo_epi16(tmp, tmp);
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet2d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast<__m128i*>(to), from); }
+template<> EIGEN_STRONG_INLINE void pstore<bool>(bool*     to, const Packet16b& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast<__m128i*>(to), from); }
+
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const Packet2d& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_pd(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float*   to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_ps(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*       to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<bool>(bool*     to, const Packet16b& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_storeu_si128(reinterpret_cast<__m128i*>(to), from); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+ return _mm_set_ps(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+ return _mm_set_pd(from[1*stride], from[0*stride]);
+}
+template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int, Packet4i>(const int* from, Index stride)
+{
+ return _mm_set_epi32(from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet16b pgather<bool, Packet16b>(const bool* from, Index stride)
+{
+  return _mm_set_epi8(from[15*stride], from[14*stride], from[13*stride], from[12*stride],
+                      from[11*stride], from[10*stride], from[9*stride], from[8*stride],
+                      from[7*stride], from[6*stride], from[5*stride], from[4*stride],
+                      from[3*stride], from[2*stride], from[1*stride], from[0*stride]);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  to[stride*0] = _mm_cvtss_f32(from);
+  to[stride*1] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 1));
+  to[stride*2] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 2));
+  to[stride*3] = _mm_cvtss_f32(_mm_shuffle_ps(from, from, 3));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  to[stride*0] = _mm_cvtsd_f64(from);
+  to[stride*1] = _mm_cvtsd_f64(_mm_shuffle_pd(from, from, 1));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<int, Packet4i>(int* to, const Packet4i& from, Index stride)
+{
+  to[stride*0] = _mm_cvtsi128_si32(from);
+  to[stride*1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 1));
+  to[stride*2] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 2));
+  to[stride*3] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 3));
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<bool, Packet16b>(bool* to, const Packet16b& from, Index stride)
+{
+  to[4*stride*0] = _mm_cvtsi128_si32(from);
+  to[4*stride*1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 1));
+  to[4*stride*2] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 2));
+  to[4*stride*3] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 3));
+}
+
+
+// some compilers might be tempted to perform multiple moves instead of using a vector path.
+template<> EIGEN_STRONG_INLINE void pstore1<Packet4f>(float* to, const float& a)
+{
+  Packet4f pa = _mm_set_ss(a);
+  pstore(to, Packet4f(vec4f_swizzle1(pa,0,0,0,0)));
+}
+// some compilers might be tempted to perform multiple moves instead of using a vector path.
+template<> EIGEN_STRONG_INLINE void pstore1<Packet2d>(double* to, const double& a)
+{
+  Packet2d pa = _mm_set_sd(a);
+  pstore(to, Packet2d(vec2d_swizzle1(pa,0,0)));
+}
+
+#if EIGEN_COMP_PGI && EIGEN_COMP_PGI < 1900
+typedef const void * SsePrefetchPtrType;
+#else
+typedef const char * SsePrefetchPtrType;
+#endif
+
+#ifndef EIGEN_VECTORIZE_AVX
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0); }
+#endif
+
+#if EIGEN_COMP_MSVC_STRICT && EIGEN_OS_WIN64
+// The temporary variable fixes an internal compilation error in vs <= 2008 and a wrong-result bug in vs 2010
+// Direct of the struct members fixed bug #62.
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { return a.m128_f32[0]; }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return a.m128d_f64[0]; }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; }
+#elif EIGEN_COMP_MSVC_STRICT
+// The temporary variable fixes an internal compilation error in vs <= 2008 and a wrong-result bug in vs 2010
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { float x = _mm_cvtss_f32(a); return x; }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { double x = _mm_cvtsd_f64(a); return x; }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; }
+#else
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { return _mm_cvtss_f32(a); }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return _mm_cvtsd_f64(a); }
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { return _mm_cvtsi128_si32(a); }
+#endif
+template<> EIGEN_STRONG_INLINE bool   pfirst<Packet16b>(const Packet16b& a) { int x = _mm_cvtsi128_si32(a); return static_cast<bool>(x & 1); }
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a) { return _mm_shuffle_ps(a,a,0x1B); }
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a) { return _mm_shuffle_pd(a,a,0x1); }
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a) { return _mm_shuffle_epi32(a,0x1B); }
+template<> EIGEN_STRONG_INLINE Packet16b preverse(const Packet16b& a) {
+#ifdef EIGEN_VECTORIZE_SSSE3
+  __m128i mask = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  return _mm_shuffle_epi8(a, mask);
+#else
+  Packet16b tmp = _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3));
+  tmp = _mm_shufflehi_epi16(_mm_shufflelo_epi16(tmp, _MM_SHUFFLE(2, 3, 0, 1)), _MM_SHUFFLE(2, 3, 0, 1));
+  return _mm_or_si128(_mm_slli_epi16(tmp, 8), _mm_srli_epi16(tmp, 8));
+#endif
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pfrexp<Packet4f>(const Packet4f& a, Packet4f& exponent) {
+  return pfrexp_generic(a,exponent);
+}
+
+// Extract exponent without existence of Packet2l.
+template<>
+EIGEN_STRONG_INLINE  
+Packet2d pfrexp_generic_get_biased_exponent(const Packet2d& a) {
+  const Packet2d cst_exp_mask  = pset1frombits<Packet2d>(static_cast<uint64_t>(0x7ff0000000000000ull));
+  __m128i a_expo = _mm_srli_epi64(_mm_castpd_si128(pand(a, cst_exp_mask)), 52);
+  return _mm_cvtepi32_pd(vec4i_swizzle1(a_expo, 0, 2, 1, 3));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pfrexp<Packet2d>(const Packet2d& a, Packet2d& exponent) {
+  return pfrexp_generic(a, exponent);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pldexp<Packet4f>(const Packet4f& a, const Packet4f& exponent) {
+  return pldexp_generic(a,exponent);
+}
+
+// We specialize pldexp here, since the generic implementation uses Packet2l, which is not well
+// supported by SSE, and has more range than is needed for exponents.
+template<> EIGEN_STRONG_INLINE Packet2d pldexp<Packet2d>(const Packet2d& a, const Packet2d& exponent) {
+  // Clamp exponent to [-2099, 2099]
+  const Packet2d max_exponent = pset1<Packet2d>(2099.0);
+  const Packet2d e = pmin(pmax(exponent, pnegate(max_exponent)), max_exponent);
+  
+  // Convert e to integer and swizzle to low-order bits.
+  const Packet4i ei = vec4i_swizzle1(_mm_cvtpd_epi32(e), 0, 3, 1, 3);
+  
+  // Split 2^e into four factors and multiply:
+  const Packet4i bias = _mm_set_epi32(0, 1023, 0, 1023);
+  Packet4i b = parithmetic_shift_right<2>(ei);  // floor(e/4)
+  Packet2d c = _mm_castsi128_pd(_mm_slli_epi64(padd(b, bias), 52));  // 2^b
+  Packet2d out = pmul(pmul(pmul(a, c), c), c); // a * 2^(3b)
+  b = psub(psub(psub(ei, b), b), b);  // e - 3b
+  c = _mm_castsi128_pd(_mm_slli_epi64(padd(b, bias), 52));  // 2^(e - 3b)
+  out = pmul(out, c);  // a * 2^e
+  return out;
+}
+
+// with AVX, the default implementations based on pload1 are faster
+#ifndef __AVX__
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  a3 = pload<Packet4f>(a);
+  a0 = vec4f_swizzle1(a3, 0,0,0,0);
+  a1 = vec4f_swizzle1(a3, 1,1,1,1);
+  a2 = vec4f_swizzle1(a3, 2,2,2,2);
+  a3 = vec4f_swizzle1(a3, 3,3,3,3);
+}
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet2d>(const double *a,
+                      Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+#ifdef EIGEN_VECTORIZE_SSE3
+  a0 = _mm_loaddup_pd(a+0);
+  a1 = _mm_loaddup_pd(a+1);
+  a2 = _mm_loaddup_pd(a+2);
+  a3 = _mm_loaddup_pd(a+3);
+#else
+  a1 = pload<Packet2d>(a);
+  a0 = vec2d_swizzle1(a1, 0,0);
+  a1 = vec2d_swizzle1(a1, 1,1);
+  a3 = pload<Packet2d>(a+2);
+  a2 = vec2d_swizzle1(a3, 0,0);
+  a3 = vec2d_swizzle1(a3, 1,1);
+#endif
+}
+#endif
+
+EIGEN_STRONG_INLINE void punpackp(Packet4f* vecs)
+{
+  vecs[1] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x55));
+  vecs[2] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xAA));
+  vecs[3] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xFF));
+  vecs[0] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x00));
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  // Disable SSE3 _mm_hadd_pd that is extremely slow on all existing Intel's architectures
+  // (from Nehalem to Haswell)
+// #ifdef EIGEN_VECTORIZE_SSE3
+//   Packet4f tmp = _mm_add_ps(a, vec4f_swizzle1(a,2,3,2,3));
+//   return pfirst<Packet4f>(_mm_hadd_ps(tmp, tmp));
+// #else
+  Packet4f tmp = _mm_add_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_add_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+// #endif
+}
+
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{
+  // Disable SSE3 _mm_hadd_pd that is extremely slow on all existing Intel's architectures
+  // (from Nehalem to Haswell)
+// #ifdef EIGEN_VECTORIZE_SSE3
+//   return pfirst<Packet2d>(_mm_hadd_pd(a, a));
+// #else
+  return pfirst<Packet2d>(_mm_add_sd(a, _mm_unpackhi_pd(a,a)));
+// #endif
+}
+
+#ifdef EIGEN_VECTORIZE_SSSE3
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i tmp0 = _mm_hadd_epi32(a,a);
+  return pfirst<Packet4i>(_mm_hadd_epi32(tmp0,tmp0));
+}
+
+#else
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i tmp = _mm_add_epi32(a, _mm_unpackhi_epi64(a,a));
+  return pfirst(tmp) + pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1));
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE bool predux<Packet16b>(const Packet16b& a) {
+  Packet4i tmp = _mm_or_si128(a, _mm_unpackhi_epi64(a,a));
+  return (pfirst(tmp) != 0) || (pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1)) != 0);
+}
+
+// Other reduction functions:
+
+
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  Packet4f tmp = _mm_mul_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_mul_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{
+  return pfirst<Packet2d>(_mm_mul_sd(a, _mm_unpackhi_pd(a,a)));
+}
+template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
+{
+  // after some experiments, it is seems this is the fastest way to implement it
+  // for GCC (eg., reusing pmul is very slow !)
+  // TODO try to call _mm_mul_epu32 directly
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  return  (aux[0] * aux[1]) * (aux[2] * aux[3]);
+}
+
+template<> EIGEN_STRONG_INLINE bool predux_mul<Packet16b>(const Packet16b& a) {
+  Packet4i tmp = _mm_and_si128(a, _mm_unpackhi_epi64(a,a));
+  return ((pfirst<Packet4i>(tmp) == 0x01010101) &&
+          (pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1)) == 0x01010101));
+}
+
+// min
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  Packet4f tmp = _mm_min_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_min_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{
+  return pfirst<Packet2d>(_mm_min_sd(a, _mm_unpackhi_pd(a,a)));
+}
+template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  Packet4i tmp = _mm_min_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0,0,3,2)));
+  return pfirst<Packet4i>(_mm_min_epi32(tmp,_mm_shuffle_epi32(tmp, 1)));
+#else
+  // after some experiments, it is seems this is the fastest way to implement it
+  // for GCC (eg., it does not like using std::min after the pstore !!)
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  int aux0 = aux[0]<aux[1] ? aux[0] : aux[1];
+  int aux2 = aux[2]<aux[3] ? aux[2] : aux[3];
+  return aux0<aux2 ? aux0 : aux2;
+#endif // EIGEN_VECTORIZE_SSE4_1
+}
+
+// max
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  Packet4f tmp = _mm_max_ps(a, _mm_movehl_ps(a,a));
+  return pfirst<Packet4f>(_mm_max_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1)));
+}
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{
+  return pfirst<Packet2d>(_mm_max_sd(a, _mm_unpackhi_pd(a,a)));
+}
+template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
+{
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  Packet4i tmp = _mm_max_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0,0,3,2)));
+  return pfirst<Packet4i>(_mm_max_epi32(tmp,_mm_shuffle_epi32(tmp, 1)));
+#else
+  // after some experiments, it is seems this is the fastest way to implement it
+  // for GCC (eg., it does not like using std::min after the pstore !!)
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  int aux0 = aux[0]>aux[1] ? aux[0] : aux[1];
+  int aux2 = aux[2]>aux[3] ? aux[2] : aux[3];
+  return aux0>aux2 ? aux0 : aux2;
+#endif // EIGEN_VECTORIZE_SSE4_1
+}
+
+// not needed yet
+// template<> EIGEN_STRONG_INLINE bool predux_all(const Packet4f& x)
+// {
+//   return _mm_movemask_ps(x) == 0xF;
+// }
+
+template<> EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x)
+{
+  return _mm_movemask_ps(x) != 0x0;
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  _MM_TRANSPOSE4_PS(kernel.packet[0], kernel.packet[1], kernel.packet[2], kernel.packet[3]);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2d,2>& kernel) {
+  __m128d tmp = _mm_unpackhi_pd(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[0] = _mm_unpacklo_pd(kernel.packet[0], kernel.packet[1]);
+  kernel.packet[1] = tmp;
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4i,4>& kernel) {
+  __m128i T0 = _mm_unpacklo_epi32(kernel.packet[0], kernel.packet[1]);
+  __m128i T1 = _mm_unpacklo_epi32(kernel.packet[2], kernel.packet[3]);
+  __m128i T2 = _mm_unpackhi_epi32(kernel.packet[0], kernel.packet[1]);
+  __m128i T3 = _mm_unpackhi_epi32(kernel.packet[2], kernel.packet[3]);
+
+  kernel.packet[0] = _mm_unpacklo_epi64(T0, T1);
+  kernel.packet[1] = _mm_unpackhi_epi64(T0, T1);
+  kernel.packet[2] = _mm_unpacklo_epi64(T2, T3);
+  kernel.packet[3] = _mm_unpackhi_epi64(T2, T3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16b,4>& kernel) {
+  __m128i T0 =  _mm_unpacklo_epi8(kernel.packet[0], kernel.packet[1]);
+  __m128i T1 =  _mm_unpackhi_epi8(kernel.packet[0], kernel.packet[1]);
+  __m128i T2 =  _mm_unpacklo_epi8(kernel.packet[2], kernel.packet[3]);
+  __m128i T3 =  _mm_unpackhi_epi8(kernel.packet[2], kernel.packet[3]);
+  kernel.packet[0] = _mm_unpacklo_epi16(T0, T2);
+  kernel.packet[1] = _mm_unpackhi_epi16(T0, T2);
+  kernel.packet[2] = _mm_unpacklo_epi16(T1, T3);
+  kernel.packet[3] = _mm_unpackhi_epi16(T1, T3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet16b,16>& kernel) {
+  // If we number the elements in the input thus:
+  // kernel.packet[ 0] = {00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 0a, 0b, 0c, 0d, 0e, 0f}
+  // kernel.packet[ 1] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1a, 1b, 1c, 1d, 1e, 1f}
+  // ...
+  // kernel.packet[15] = {f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, fa, fb, fc, fd, fe, ff},
+  //
+  // the desired output is:
+  // kernel.packet[ 0] = {00, 10, 20, 30, 40, 50, 60, 70, 80, 90, a0, b0, c0, d0, e0, f0}
+  // kernel.packet[ 1] = {01, 11, 21, 31, 41, 51, 61, 71, 81, 91, a1, b1, c1, d1, e1, f1}
+  // ...
+  // kernel.packet[15] = {0f, 1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f, 9f, af, bf, cf, df, ef, ff},
+  __m128i t0 =  _mm_unpacklo_epi8(kernel.packet[0], kernel.packet[1]); // 00 10 01 11 02 12 03 13 04 14 05 15 06 16 07 17
+  __m128i t1 =  _mm_unpackhi_epi8(kernel.packet[0], kernel.packet[1]); // 08 18 09 19 0a 1a 0b 1b 0c 1c 0d 1d 0e 1e 0f 1f
+  __m128i t2 =  _mm_unpacklo_epi8(kernel.packet[2], kernel.packet[3]); // 20 30 21 31 22 32 ...                     27 37
+  __m128i t3 =  _mm_unpackhi_epi8(kernel.packet[2], kernel.packet[3]); // 28 38 29 39 2a 3a ...                     2f 3f
+  __m128i t4 =  _mm_unpacklo_epi8(kernel.packet[4], kernel.packet[5]); // 40 50 41 51 42 52                         47 57
+  __m128i t5 =  _mm_unpackhi_epi8(kernel.packet[4], kernel.packet[5]); // 48 58 49 59 4a 5a
+  __m128i t6 =  _mm_unpacklo_epi8(kernel.packet[6], kernel.packet[7]);
+  __m128i t7 =  _mm_unpackhi_epi8(kernel.packet[6], kernel.packet[7]);
+  __m128i t8 =  _mm_unpacklo_epi8(kernel.packet[8], kernel.packet[9]);
+  __m128i t9 =  _mm_unpackhi_epi8(kernel.packet[8], kernel.packet[9]);
+  __m128i ta =  _mm_unpacklo_epi8(kernel.packet[10], kernel.packet[11]);
+  __m128i tb =  _mm_unpackhi_epi8(kernel.packet[10], kernel.packet[11]);
+  __m128i tc =  _mm_unpacklo_epi8(kernel.packet[12], kernel.packet[13]);
+  __m128i td =  _mm_unpackhi_epi8(kernel.packet[12], kernel.packet[13]);
+  __m128i te =  _mm_unpacklo_epi8(kernel.packet[14], kernel.packet[15]);
+  __m128i tf =  _mm_unpackhi_epi8(kernel.packet[14], kernel.packet[15]);
+
+  __m128i s0 =  _mm_unpacklo_epi16(t0, t2); // 00 10 20 30 01 11 21 31 02 12 22 32 03 13 23 33
+  __m128i s1 =  _mm_unpackhi_epi16(t0, t2); // 04 14 24 34
+  __m128i s2 =  _mm_unpacklo_epi16(t1, t3); // 08 18 28 38 ...
+  __m128i s3 =  _mm_unpackhi_epi16(t1, t3); // 0c 1c 2c 3c ...
+  __m128i s4 =  _mm_unpacklo_epi16(t4, t6); // 40 50 60 70 41 51 61 71 42 52 62 72 43 53 63 73
+  __m128i s5 =  _mm_unpackhi_epi16(t4, t6); // 44 54 64 74 ...
+  __m128i s6 =  _mm_unpacklo_epi16(t5, t7);
+  __m128i s7 =  _mm_unpackhi_epi16(t5, t7);
+  __m128i s8 =  _mm_unpacklo_epi16(t8, ta);
+  __m128i s9 =  _mm_unpackhi_epi16(t8, ta);
+  __m128i sa =  _mm_unpacklo_epi16(t9, tb);
+  __m128i sb =  _mm_unpackhi_epi16(t9, tb);
+  __m128i sc =  _mm_unpacklo_epi16(tc, te);
+  __m128i sd =  _mm_unpackhi_epi16(tc, te);
+  __m128i se =  _mm_unpacklo_epi16(td, tf);
+  __m128i sf =  _mm_unpackhi_epi16(td, tf);
+
+  __m128i u0 =  _mm_unpacklo_epi32(s0, s4); // 00 10 20 30 40 50 60 70 01 11 21 31 41 51 61 71
+  __m128i u1 =  _mm_unpackhi_epi32(s0, s4); // 02 12 22 32 42 52 62 72 03 13 23 33 43 53 63 73
+  __m128i u2 =  _mm_unpacklo_epi32(s1, s5);
+  __m128i u3 =  _mm_unpackhi_epi32(s1, s5);
+  __m128i u4 =  _mm_unpacklo_epi32(s2, s6);
+  __m128i u5 =  _mm_unpackhi_epi32(s2, s6);
+  __m128i u6 =  _mm_unpacklo_epi32(s3, s7);
+  __m128i u7 =  _mm_unpackhi_epi32(s3, s7);
+  __m128i u8 =  _mm_unpacklo_epi32(s8, sc);
+  __m128i u9 =  _mm_unpackhi_epi32(s8, sc);
+  __m128i ua =  _mm_unpacklo_epi32(s9, sd);
+  __m128i ub =  _mm_unpackhi_epi32(s9, sd);
+  __m128i uc =  _mm_unpacklo_epi32(sa, se);
+  __m128i ud =  _mm_unpackhi_epi32(sa, se);
+  __m128i ue =  _mm_unpacklo_epi32(sb, sf);
+  __m128i uf =  _mm_unpackhi_epi32(sb, sf);
+
+  kernel.packet[0]  = _mm_unpacklo_epi64(u0, u8);
+  kernel.packet[1]  = _mm_unpackhi_epi64(u0, u8);
+  kernel.packet[2]  = _mm_unpacklo_epi64(u1, u9);
+  kernel.packet[3]  = _mm_unpackhi_epi64(u1, u9);
+  kernel.packet[4]  = _mm_unpacklo_epi64(u2, ua);
+  kernel.packet[5]  = _mm_unpackhi_epi64(u2, ua);
+  kernel.packet[6]  = _mm_unpacklo_epi64(u3, ub);
+  kernel.packet[7]  = _mm_unpackhi_epi64(u3, ub);
+  kernel.packet[8]  = _mm_unpacklo_epi64(u4, uc);
+  kernel.packet[9]  = _mm_unpackhi_epi64(u4, uc);
+  kernel.packet[10] = _mm_unpacklo_epi64(u5, ud);
+  kernel.packet[11] = _mm_unpackhi_epi64(u5, ud);
+  kernel.packet[12] = _mm_unpacklo_epi64(u6, ue);
+  kernel.packet[13] = _mm_unpackhi_epi64(u6, ue);
+  kernel.packet[14] = _mm_unpacklo_epi64(u7, uf);
+  kernel.packet[15] = _mm_unpackhi_epi64(u7, uf);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket) {
+  const __m128i zero = _mm_setzero_si128();
+  const __m128i select = _mm_set_epi32(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m128i false_mask = _mm_cmpeq_epi32(select, zero);
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blendv_epi8(thenPacket, elsePacket, false_mask);
+#else
+  return _mm_or_si128(_mm_andnot_si128(false_mask, thenPacket), _mm_and_si128(false_mask, elsePacket));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  const __m128 zero = _mm_setzero_ps();
+  const __m128 select = _mm_set_ps(ifPacket.select[3], ifPacket.select[2], ifPacket.select[1], ifPacket.select[0]);
+  __m128 false_mask = _mm_cmpeq_ps(select, zero);
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blendv_ps(thenPacket, elsePacket, false_mask);
+#else
+  return _mm_or_ps(_mm_andnot_ps(false_mask, thenPacket), _mm_and_ps(false_mask, elsePacket));
+#endif
+}
+template<> EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket) {
+  const __m128d zero = _mm_setzero_pd();
+  const __m128d select = _mm_set_pd(ifPacket.select[1], ifPacket.select[0]);
+  __m128d false_mask = _mm_cmpeq_pd(select, zero);
+#ifdef EIGEN_VECTORIZE_SSE4_1
+  return _mm_blendv_pd(thenPacket, elsePacket, false_mask);
+#else
+  return _mm_or_pd(_mm_andnot_pd(false_mask, thenPacket), _mm_and_pd(false_mask, elsePacket));
+#endif
+}
+
+// Scalar path for pmadd with FMA to ensure consistency with vectorized path.
+#ifdef EIGEN_VECTORIZE_FMA
+template<> EIGEN_STRONG_INLINE float pmadd(const float& a, const float& b, const float& c) {
+  return ::fmaf(a,b,c);
+}
+template<> EIGEN_STRONG_INLINE double pmadd(const double& a, const double& b, const double& c) {
+  return ::fma(a,b,c);
+}
+#endif
+
+
+// Packet math for Eigen::half
+// Disable the following code since it's broken on too many platforms / compilers.
+//#elif defined(EIGEN_VECTORIZE_SSE) && (!EIGEN_ARCH_x86_64) && (!EIGEN_COMP_MSVC)
+#if 0
+
+typedef struct {
+  __m64 x;
+} Packet4h;
+
+
+template<> struct is_arithmetic<Packet4h> { enum { value = true }; };
+
+template <>
+struct packet_traits<Eigen::half> : default_packet_traits {
+  typedef Packet4h type;
+  // There is no half-size packet for Packet4h.
+  typedef Packet4h half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 0,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasConj   = 0,
+    HasSetLinear = 0,
+    HasSqrt = 0,
+    HasRsqrt = 0,
+    HasExp = 0,
+    HasLog = 0,
+    HasBlend = 0
+  };
+};
+
+
+template<> struct unpacket_traits<Packet4h> { typedef Eigen::half type; enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet4h half; };
+
+template<> EIGEN_STRONG_INLINE Packet4h pset1<Packet4h>(const Eigen::half& from) {
+  Packet4h result;
+  result.x = _mm_set1_pi16(from.x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Eigen::half pfirst<Packet4h>(const Packet4h& from) {
+  return half_impl::raw_uint16_to_half(static_cast<unsigned short>(_mm_cvtsi64_si32(from.x)));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pconj(const Packet4h& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4h padd<Packet4h>(const Packet4h& a, const Packet4h& b) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  __int64_t b64 = _mm_cvtm64_si64(b.x);
+
+  Eigen::half h[4];
+
+  Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
+  Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
+  h[0] = ha + hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
+  h[1] = ha + hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
+  h[2] = ha + hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
+  h[3] = ha + hb;
+  Packet4h result;
+  result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h psub<Packet4h>(const Packet4h& a, const Packet4h& b) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  __int64_t b64 = _mm_cvtm64_si64(b.x);
+
+  Eigen::half h[4];
+
+  Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
+  Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
+  h[0] = ha - hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
+  h[1] = ha - hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
+  h[2] = ha - hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
+  h[3] = ha - hb;
+  Packet4h result;
+  result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pmul<Packet4h>(const Packet4h& a, const Packet4h& b) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  __int64_t b64 = _mm_cvtm64_si64(b.x);
+
+  Eigen::half h[4];
+
+  Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
+  Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
+  h[0] = ha * hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
+  h[1] = ha * hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
+  h[2] = ha * hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
+  h[3] = ha * hb;
+  Packet4h result;
+  result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pdiv<Packet4h>(const Packet4h& a, const Packet4h& b) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  __int64_t b64 = _mm_cvtm64_si64(b.x);
+
+  Eigen::half h[4];
+
+  Eigen::half ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64));
+  Eigen::half hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64));
+  h[0] = ha / hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 16));
+  h[1] = ha / hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 32));
+  h[2] = ha / hb;
+  ha = half_impl::raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  hb = half_impl::raw_uint16_to_half(static_cast<unsigned short>(b64 >> 48));
+  h[3] = ha / hb;
+  Packet4h result;
+  result.x = _mm_set_pi16(h[3].x, h[2].x, h[1].x, h[0].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pload<Packet4h>(const Eigen::half* from) {
+  Packet4h result;
+  result.x = _mm_cvtsi64_m64(*reinterpret_cast<const __int64_t*>(from));
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h ploadu<Packet4h>(const Eigen::half* from) {
+  Packet4h result;
+  result.x = _mm_cvtsi64_m64(*reinterpret_cast<const __int64_t*>(from));
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet4h& from) {
+  __int64_t r = _mm_cvtm64_si64(from.x);
+  *(reinterpret_cast<__int64_t*>(to)) = r;
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet4h& from) {
+  __int64_t r = _mm_cvtm64_si64(from.x);
+  *(reinterpret_cast<__int64_t*>(to)) = r;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h
+ploadquad<Packet4h>(const Eigen::half* from) {
+  return pset1<Packet4h>(*from);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4h pgather<Eigen::half, Packet4h>(const Eigen::half* from, Index stride)
+{
+  Packet4h result;
+  result.x = _mm_set_pi16(from[3*stride].x, from[2*stride].x, from[1*stride].x, from[0*stride].x);
+  return result;
+}
+
+template<> EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet4h>(Eigen::half* to, const Packet4h& from, Index stride)
+{
+  __int64_t a = _mm_cvtm64_si64(from.x);
+  to[stride*0].x = static_cast<unsigned short>(a);
+  to[stride*1].x = static_cast<unsigned short>(a >> 16);
+  to[stride*2].x = static_cast<unsigned short>(a >> 32);
+  to[stride*3].x = static_cast<unsigned short>(a >> 48);
+}
+
+EIGEN_STRONG_INLINE void
+ptranspose(PacketBlock<Packet4h,4>& kernel) {
+  __m64 T0 = _mm_unpacklo_pi16(kernel.packet[0].x, kernel.packet[1].x);
+  __m64 T1 = _mm_unpacklo_pi16(kernel.packet[2].x, kernel.packet[3].x);
+  __m64 T2 = _mm_unpackhi_pi16(kernel.packet[0].x, kernel.packet[1].x);
+  __m64 T3 = _mm_unpackhi_pi16(kernel.packet[2].x, kernel.packet[3].x);
+
+  kernel.packet[0].x = _mm_unpacklo_pi32(T0, T1);
+  kernel.packet[1].x = _mm_unpackhi_pi32(T0, T1);
+  kernel.packet[2].x = _mm_unpacklo_pi32(T2, T3);
+  kernel.packet[3].x = _mm_unpackhi_pi32(T2, T3);
+}
+
+#endif
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#if EIGEN_COMP_PGI && EIGEN_COMP_PGI < 1900
+// PGI++ does not define the following intrinsics in C++ mode.
+static inline __m128  _mm_castpd_ps   (__m128d x) { return reinterpret_cast<__m128&>(x);  }
+static inline __m128i _mm_castpd_si128(__m128d x) { return reinterpret_cast<__m128i&>(x); }
+static inline __m128d _mm_castps_pd   (__m128  x) { return reinterpret_cast<__m128d&>(x); }
+static inline __m128i _mm_castps_si128(__m128  x) { return reinterpret_cast<__m128i&>(x); }
+static inline __m128  _mm_castsi128_ps(__m128i x) { return reinterpret_cast<__m128&>(x);  }
+static inline __m128d _mm_castsi128_pd(__m128i x) { return reinterpret_cast<__m128d&>(x); }
+#endif
+
+#endif // EIGEN_PACKET_MATH_SSE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/TypeCasting.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/TypeCasting.h
new file mode 100644
index 00000000..d2a0037e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SSE/TypeCasting.h
@@ -0,0 +1,142 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_SSE_H
+#define EIGEN_TYPE_CASTING_SSE_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_VECTORIZE_AVX
+template <>
+struct type_casting_traits<float, int> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<int, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<double, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 2,
+    TgtCoeffRatio = 1
+  };
+};
+
+template <>
+struct type_casting_traits<float, double> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 2
+  };
+};
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4i pcast<Packet4f, Packet4i>(const Packet4f& a) {
+  return _mm_cvttps_epi32(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4i, Packet4f>(const Packet4i& a) {
+  return _mm_cvtepi32_ps(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet2d, Packet4f>(const Packet2d& a, const Packet2d& b) {
+  return _mm_shuffle_ps(_mm_cvtpd_ps(a), _mm_cvtpd_ps(b), (1 << 2) | (1 << 6));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pcast<Packet4f, Packet2d>(const Packet4f& a) {
+  // Simply discard the second half of the input
+  return _mm_cvtps_pd(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i,Packet4f>(const Packet4f& a) {
+  return _mm_castps_si128(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f,Packet4i>(const Packet4i& a) {
+  return _mm_castsi128_ps(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d preinterpret<Packet2d,Packet4i>(const Packet4i& a) {
+  return _mm_castsi128_pd(a);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i,Packet2d>(const Packet2d& a) {
+  return _mm_castpd_si128(a);
+}
+
+// Disable the following code since it's broken on too many platforms / compilers.
+//#elif defined(EIGEN_VECTORIZE_SSE) && (!EIGEN_ARCH_x86_64) && (!EIGEN_COMP_MSVC)
+#if 0
+
+template <>
+struct type_casting_traits<Eigen::half, float> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4f pcast<Packet4h, Packet4f>(const Packet4h& a) {
+  __int64_t a64 = _mm_cvtm64_si64(a.x);
+  Eigen::half h = raw_uint16_to_half(static_cast<unsigned short>(a64));
+  float f1 = static_cast<float>(h);
+  h = raw_uint16_to_half(static_cast<unsigned short>(a64 >> 16));
+  float f2 = static_cast<float>(h);
+  h = raw_uint16_to_half(static_cast<unsigned short>(a64 >> 32));
+  float f3 = static_cast<float>(h);
+  h = raw_uint16_to_half(static_cast<unsigned short>(a64 >> 48));
+  float f4 = static_cast<float>(h);
+  return _mm_set_ps(f4, f3, f2, f1);
+}
+
+template <>
+struct type_casting_traits<float, Eigen::half> {
+  enum {
+    VectorizedCast = 1,
+    SrcCoeffRatio = 1,
+    TgtCoeffRatio = 1
+  };
+};
+
+template<> EIGEN_STRONG_INLINE Packet4h pcast<Packet4f, Packet4h>(const Packet4f& a) {
+  EIGEN_ALIGN16 float aux[4];
+  pstore(aux, a);
+  Eigen::half h0(aux[0]);
+  Eigen::half h1(aux[1]);
+  Eigen::half h2(aux[2]);
+  Eigen::half h3(aux[3]);
+
+  Packet4h result;
+  result.x = _mm_set_pi16(h3.x, h2.x, h1.x, h0.x);
+  return result;
+}
+
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_SSE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SVE/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SVE/MathFunctions.h
new file mode 100644
index 00000000..b139ea2e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SVE/MathFunctions.h
@@ -0,0 +1,44 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020, Arm Limited and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATH_FUNCTIONS_SVE_H
+#define EIGEN_MATH_FUNCTIONS_SVE_H
+
+namespace Eigen {
+namespace internal {
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf pexp<PacketXf>(const PacketXf& x) {
+  return pexp_float(x);
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf plog<PacketXf>(const PacketXf& x) {
+  return plog_float(x);
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf psin<PacketXf>(const PacketXf& x) {
+  return psin_float(x);
+}
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf pcos<PacketXf>(const PacketXf& x) {
+  return pcos_float(x);
+}
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_STRONG_INLINE EIGEN_UNUSED PacketXf ptanh<PacketXf>(const PacketXf& x) {
+  return internal::generic_fast_tanh_float(x);
+}
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_SVE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SVE/PacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SVE/PacketMath.h
new file mode 100644
index 00000000..9060b372
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SVE/PacketMath.h
@@ -0,0 +1,752 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020, Arm Limited and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_SVE_H
+#define EIGEN_PACKET_MATH_SVE_H
+
+namespace Eigen
+{
+namespace internal
+{
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
+
+template <typename Scalar, int SVEVectorLength>
+struct sve_packet_size_selector {
+  enum { size = SVEVectorLength / (sizeof(Scalar) * CHAR_BIT) };
+};
+
+/********************************* int32 **************************************/
+typedef svint32_t PacketXi __attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)));
+
+template <>
+struct packet_traits<numext::int32_t> : default_packet_traits {
+  typedef PacketXi type;
+  typedef PacketXi half;  // Half not implemented yet
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = sve_packet_size_selector<numext::int32_t, EIGEN_ARM64_SVE_VL>::size,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasShift = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasAbs2 = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 1,
+    HasSetLinear = 0,
+    HasBlend = 0,
+    HasReduxp = 0  // Not implemented in SVE
+  };
+};
+
+template <>
+struct unpacket_traits<PacketXi> {
+  typedef numext::int32_t type;
+  typedef PacketXi half;  // Half not yet implemented
+  enum {
+    size = sve_packet_size_selector<numext::int32_t, EIGEN_ARM64_SVE_VL>::size,
+    alignment = Aligned64,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<numext::int32_t>(const numext::int32_t* addr)
+{
+  svprfw(svptrue_b32(), addr, SV_PLDL1KEEP);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pset1<PacketXi>(const numext::int32_t& from)
+{
+  return svdup_n_s32(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi plset<PacketXi>(const numext::int32_t& a)
+{
+  numext::int32_t c[packet_traits<numext::int32_t>::size];
+  for (int i = 0; i < packet_traits<numext::int32_t>::size; i++) c[i] = i;
+  return svadd_s32_z(svptrue_b32(), pset1<PacketXi>(a), svld1_s32(svptrue_b32(), c));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi padd<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svadd_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi psub<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svsub_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pnegate(const PacketXi& a)
+{
+  return svneg_s32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pconj(const PacketXi& a)
+{
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pmul<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svmul_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pdiv<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svdiv_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pmadd(const PacketXi& a, const PacketXi& b, const PacketXi& c)
+{
+  return svmla_s32_z(svptrue_b32(), c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pmin<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svmin_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pmax<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svmax_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pcmp_le<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svdup_n_s32_z(svcmplt_s32(svptrue_b32(), a, b), 0xffffffffu);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pcmp_lt<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svdup_n_s32_z(svcmplt_s32(svptrue_b32(), a, b), 0xffffffffu);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pcmp_eq<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svdup_n_s32_z(svcmpeq_s32(svptrue_b32(), a, b), 0xffffffffu);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi ptrue<PacketXi>(const PacketXi& /*a*/)
+{
+  return svdup_n_s32_z(svptrue_b32(), 0xffffffffu);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pzero<PacketXi>(const PacketXi& /*a*/)
+{
+  return svdup_n_s32_z(svptrue_b32(), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pand<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svand_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi por<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svorr_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pxor<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return sveor_s32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pandnot<PacketXi>(const PacketXi& a, const PacketXi& b)
+{
+  return svbic_s32_z(svptrue_b32(), a, b);
+}
+
+template <int N>
+EIGEN_STRONG_INLINE PacketXi parithmetic_shift_right(PacketXi a)
+{
+  return svasrd_n_s32_z(svptrue_b32(), a, N);
+}
+
+template <int N>
+EIGEN_STRONG_INLINE PacketXi plogical_shift_right(PacketXi a)
+{
+  return svreinterpret_s32_u32(svlsr_u32_z(svptrue_b32(), svreinterpret_u32_s32(a), svdup_n_u32_z(svptrue_b32(), N)));
+}
+
+template <int N>
+EIGEN_STRONG_INLINE PacketXi plogical_shift_left(PacketXi a)
+{
+  return svlsl_s32_z(svptrue_b32(), a, svdup_n_u32_z(svptrue_b32(), N));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pload<PacketXi>(const numext::int32_t* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD return svld1_s32(svptrue_b32(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi ploadu<PacketXi>(const numext::int32_t* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD return svld1_s32(svptrue_b32(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi ploaddup<PacketXi>(const numext::int32_t* from)
+{
+  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
+  return svld1_gather_u32index_s32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi ploadquad<PacketXi>(const numext::int32_t* from)
+{
+  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a0, a0, a1, a1, a1, a1, ...}
+  return svld1_gather_u32index_s32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<numext::int32_t>(numext::int32_t* to, const PacketXi& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE svst1_s32(svptrue_b32(), to, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<numext::int32_t>(numext::int32_t* to, const PacketXi& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE svst1_s32(svptrue_b32(), to, from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline PacketXi pgather<numext::int32_t, PacketXi>(const numext::int32_t* from, Index stride)
+{
+  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint32_t indices = svindex_s32(0, stride);
+  return svld1_gather_s32index_s32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<numext::int32_t, PacketXi>(numext::int32_t* to, const PacketXi& from, Index stride)
+{
+  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint32_t indices = svindex_s32(0, stride);
+  svst1_scatter_s32index_s32(svptrue_b32(), to, indices, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int32_t pfirst<PacketXi>(const PacketXi& a)
+{
+  // svlasta returns the first element if all predicate bits are 0
+  return svlasta_s32(svpfalse_b(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi preverse(const PacketXi& a)
+{
+  return svrev_s32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pabs(const PacketXi& a)
+{
+  return svabs_s32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int32_t predux<PacketXi>(const PacketXi& a)
+{
+  return static_cast<numext::int32_t>(svaddv_s32(svptrue_b32(), a));
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int32_t predux_mul<PacketXi>(const PacketXi& a)
+{
+  EIGEN_STATIC_ASSERT((EIGEN_ARM64_SVE_VL % 128 == 0),
+                      EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
+
+  // Multiply the vector by its reverse
+  svint32_t prod = svmul_s32_z(svptrue_b32(), a, svrev_s32(a));
+  svint32_t half_prod;
+
+  // Extract the high half of the vector. Depending on the VL more reductions need to be done
+  if (EIGEN_ARM64_SVE_VL >= 2048) {
+    half_prod = svtbl_s32(prod, svindex_u32(32, 1));
+    prod = svmul_s32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 1024) {
+    half_prod = svtbl_s32(prod, svindex_u32(16, 1));
+    prod = svmul_s32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 512) {
+    half_prod = svtbl_s32(prod, svindex_u32(8, 1));
+    prod = svmul_s32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 256) {
+    half_prod = svtbl_s32(prod, svindex_u32(4, 1));
+    prod = svmul_s32_z(svptrue_b32(), prod, half_prod);
+  }
+  // Last reduction
+  half_prod = svtbl_s32(prod, svindex_u32(2, 1));
+  prod = svmul_s32_z(svptrue_b32(), prod, half_prod);
+
+  // The reduction is done to the first element.
+  return pfirst<PacketXi>(prod);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int32_t predux_min<PacketXi>(const PacketXi& a)
+{
+  return svminv_s32(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int32_t predux_max<PacketXi>(const PacketXi& a)
+{
+  return svmaxv_s32(svptrue_b32(), a);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<PacketXi, N>& kernel) {
+  int buffer[packet_traits<numext::int32_t>::size * N] = {0};
+  int i = 0;
+
+  PacketXi stride_index = svindex_s32(0, N);
+
+  for (i = 0; i < N; i++) {
+    svst1_scatter_s32index_s32(svptrue_b32(), buffer + i, stride_index, kernel.packet[i]);
+  }
+  for (i = 0; i < N; i++) {
+    kernel.packet[i] = svld1_s32(svptrue_b32(), buffer + i * packet_traits<numext::int32_t>::size);
+  }
+}
+
+/********************************* float32 ************************************/
+
+typedef svfloat32_t PacketXf __attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)));
+
+template <>
+struct packet_traits<float> : default_packet_traits {
+  typedef PacketXf type;
+  typedef PacketXf half;
+
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = sve_packet_size_selector<float, EIGEN_ARM64_SVE_VL>::size,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasShift = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasAbs2 = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 1,
+    HasSetLinear = 0,
+    HasBlend = 0,
+    HasReduxp = 0,  // Not implemented in SVE
+
+    HasDiv = 1,
+    HasFloor = 1,
+
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasExp = 1,
+    HasSqrt = 0,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH
+  };
+};
+
+template <>
+struct unpacket_traits<PacketXf> {
+  typedef float type;
+  typedef PacketXf half;  // Half not yet implemented
+  typedef PacketXi integer_packet;
+
+  enum {
+    size = sve_packet_size_selector<float, EIGEN_ARM64_SVE_VL>::size,
+    alignment = Aligned64,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pset1<PacketXf>(const float& from)
+{
+  return svdup_n_f32(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pset1frombits<PacketXf>(numext::uint32_t from)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svptrue_b32(), from));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf plset<PacketXf>(const float& a)
+{
+  float c[packet_traits<float>::size];
+  for (int i = 0; i < packet_traits<float>::size; i++) c[i] = i;
+  return svadd_f32_z(svptrue_b32(), pset1<PacketXf>(a), svld1_f32(svptrue_b32(), c));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf padd<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svadd_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf psub<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svsub_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pnegate(const PacketXf& a)
+{
+  return svneg_f32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pconj(const PacketXf& a)
+{
+  return a;
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmul<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svmul_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pdiv<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svdiv_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmadd(const PacketXf& a, const PacketXf& b, const PacketXf& c)
+{
+  return svmla_f32_z(svptrue_b32(), c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmin<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svmin_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmin<PropagateNaN, PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return pmin<PacketXf>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmin<PropagateNumbers, PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svminnm_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmax<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svmax_f32_z(svptrue_b32(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmax<PropagateNaN, PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return pmax<PacketXf>(a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmax<PropagateNumbers, PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svmaxnm_f32_z(svptrue_b32(), a, b);
+}
+
+// Float comparisons in SVE return svbool (predicate). Use svdup to set active
+// lanes to 1 (0xffffffffu) and inactive lanes to 0.
+template <>
+EIGEN_STRONG_INLINE PacketXf pcmp_le<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svcmplt_f32(svptrue_b32(), a, b), 0xffffffffu));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pcmp_lt<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svcmplt_f32(svptrue_b32(), a, b), 0xffffffffu));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pcmp_eq<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svcmpeq_f32(svptrue_b32(), a, b), 0xffffffffu));
+}
+
+// Do a predicate inverse (svnot_b_z) on the predicate resulted from the
+// greater/equal comparison (svcmpge_f32). Then fill a float vector with the
+// active elements.
+template <>
+EIGEN_STRONG_INLINE PacketXf pcmp_lt_or_nan<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svnot_b_z(svptrue_b32(), svcmpge_f32(svptrue_b32(), a, b)), 0xffffffffu));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pfloor<PacketXf>(const PacketXf& a)
+{
+  return svrintm_f32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf ptrue<PacketXf>(const PacketXf& /*a*/)
+{
+  return svreinterpret_f32_u32(svdup_n_u32_z(svptrue_b32(), 0xffffffffu));
+}
+
+// Logical Operations are not supported for float, so reinterpret casts
+template <>
+EIGEN_STRONG_INLINE PacketXf pand<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svand_u32_z(svptrue_b32(), svreinterpret_u32_f32(a), svreinterpret_u32_f32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf por<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svorr_u32_z(svptrue_b32(), svreinterpret_u32_f32(a), svreinterpret_u32_f32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pxor<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(sveor_u32_z(svptrue_b32(), svreinterpret_u32_f32(a), svreinterpret_u32_f32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pandnot<PacketXf>(const PacketXf& a, const PacketXf& b)
+{
+  return svreinterpret_f32_u32(svbic_u32_z(svptrue_b32(), svreinterpret_u32_f32(a), svreinterpret_u32_f32(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pload<PacketXf>(const float* from)
+{
+  EIGEN_DEBUG_ALIGNED_LOAD return svld1_f32(svptrue_b32(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf ploadu<PacketXf>(const float* from)
+{
+  EIGEN_DEBUG_UNALIGNED_LOAD return svld1_f32(svptrue_b32(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf ploaddup<PacketXf>(const float* from)
+{
+  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
+  return svld1_gather_u32index_f32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf ploadquad<PacketXf>(const float* from)
+{
+  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
+  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a0, a0, a1, a1, a1, a1, ...}
+  return svld1_gather_u32index_f32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<float>(float* to, const PacketXf& from)
+{
+  EIGEN_DEBUG_ALIGNED_STORE svst1_f32(svptrue_b32(), to, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const PacketXf& from)
+{
+  EIGEN_DEBUG_UNALIGNED_STORE svst1_f32(svptrue_b32(), to, from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline PacketXf pgather<float, PacketXf>(const float* from, Index stride)
+{
+  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint32_t indices = svindex_s32(0, stride);
+  return svld1_gather_s32index_f32(svptrue_b32(), from, indices);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<float, PacketXf>(float* to, const PacketXf& from, Index stride)
+{
+  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint32_t indices = svindex_s32(0, stride);
+  svst1_scatter_s32index_f32(svptrue_b32(), to, indices, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE float pfirst<PacketXf>(const PacketXf& a)
+{
+  // svlasta returns the first element if all predicate bits are 0
+  return svlasta_f32(svpfalse_b(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf preverse(const PacketXf& a)
+{
+  return svrev_f32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pabs(const PacketXf& a)
+{
+  return svabs_f32_z(svptrue_b32(), a);
+}
+
+// TODO(tellenbach): Should this go into MathFunctions.h? If so, change for 
+// all vector extensions and the generic version.
+template <>
+EIGEN_STRONG_INLINE PacketXf pfrexp<PacketXf>(const PacketXf& a, PacketXf& exponent)
+{
+  return pfrexp_generic(a, exponent);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux<PacketXf>(const PacketXf& a)
+{
+  return svaddv_f32(svptrue_b32(), a);
+}
+
+// Other reduction functions:
+// mul
+// Only works for SVE Vls multiple of 128
+template <>
+EIGEN_STRONG_INLINE float predux_mul<PacketXf>(const PacketXf& a)
+{
+  EIGEN_STATIC_ASSERT((EIGEN_ARM64_SVE_VL % 128 == 0),
+                      EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
+  // Multiply the vector by its reverse
+  svfloat32_t prod = svmul_f32_z(svptrue_b32(), a, svrev_f32(a));
+  svfloat32_t half_prod;
+
+  // Extract the high half of the vector. Depending on the VL more reductions need to be done
+  if (EIGEN_ARM64_SVE_VL >= 2048) {
+    half_prod = svtbl_f32(prod, svindex_u32(32, 1));
+    prod = svmul_f32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 1024) {
+    half_prod = svtbl_f32(prod, svindex_u32(16, 1));
+    prod = svmul_f32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 512) {
+    half_prod = svtbl_f32(prod, svindex_u32(8, 1));
+    prod = svmul_f32_z(svptrue_b32(), prod, half_prod);
+  }
+  if (EIGEN_ARM64_SVE_VL >= 256) {
+    half_prod = svtbl_f32(prod, svindex_u32(4, 1));
+    prod = svmul_f32_z(svptrue_b32(), prod, half_prod);
+  }
+  // Last reduction
+  half_prod = svtbl_f32(prod, svindex_u32(2, 1));
+  prod = svmul_f32_z(svptrue_b32(), prod, half_prod);
+
+  // The reduction is done to the first element.
+  return pfirst<PacketXf>(prod);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_min<PacketXf>(const PacketXf& a)
+{
+  return svminv_f32(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE float predux_max<PacketXf>(const PacketXf& a)
+{
+  return svmaxv_f32(svptrue_b32(), a);
+}
+
+template<int N>
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<PacketXf, N>& kernel)
+{
+  float buffer[packet_traits<float>::size * N] = {0};
+  int i = 0;
+
+  PacketXi stride_index = svindex_s32(0, N);
+
+  for (i = 0; i < N; i++) {
+    svst1_scatter_s32index_f32(svptrue_b32(), buffer + i, stride_index, kernel.packet[i]);
+  }
+
+  for (i = 0; i < N; i++) {
+    kernel.packet[i] = svld1_f32(svptrue_b32(), buffer + i * packet_traits<float>::size);
+  }
+}
+
+template<>
+EIGEN_STRONG_INLINE PacketXf pldexp<PacketXf>(const PacketXf& a, const PacketXf& exponent)
+{
+  return pldexp_generic(a, exponent);
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_PACKET_MATH_SVE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SVE/TypeCasting.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SVE/TypeCasting.h
new file mode 100644
index 00000000..7ba5d9cd
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SVE/TypeCasting.h
@@ -0,0 +1,49 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020, Arm Limited and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TYPE_CASTING_SVE_H
+#define EIGEN_TYPE_CASTING_SVE_H
+
+namespace Eigen {
+namespace internal {
+
+template <>
+struct type_casting_traits<float, numext::int32_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+
+template <>
+struct type_casting_traits<numext::int32_t, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pcast<PacketXi, PacketXf>(const PacketXi& a) {
+  return svcvt_f32_s32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi pcast<PacketXf, PacketXi>(const PacketXf& a) {
+  return svcvt_s32_f32_z(svptrue_b32(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXf preinterpret<PacketXf, PacketXi>(const PacketXi& a) {
+  return svreinterpret_f32_s32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXi preinterpret<PacketXi, PacketXf>(const PacketXf& a) {
+  return svreinterpret_s32_f32(a);
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif // EIGEN_TYPE_CASTING_SVE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/InteropHeaders.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
new file mode 100644
index 00000000..10856ff5
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
@@ -0,0 +1,232 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*****************************************************************
+ * InteropHeaders.h
+ *
+ * \brief:
+ *  InteropHeaders
+ *
+ *****************************************************************/
+
+#ifndef EIGEN_INTEROP_HEADERS_SYCL_H
+#define EIGEN_INTEROP_HEADERS_SYCL_H
+
+namespace Eigen {
+
+#if !defined(EIGEN_DONT_VECTORIZE_SYCL)
+
+namespace internal {
+
+template <int has_blend, int lengths>
+struct sycl_packet_traits : default_packet_traits {
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = lengths,
+    HasHalfPacket = 0,
+    HasDiv = 1,
+    HasLog = 1,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasSin = 1,
+    HasCos = 1,
+    HasTan = 1,
+    HasASin = 1,
+    HasACos = 1,
+    HasATan = 1,
+    HasSinh = 1,
+    HasCosh = 1,
+    HasTanh = 1,
+    HasLGamma = 0,
+    HasDiGamma = 0,
+    HasZeta = 0,
+    HasPolygamma = 0,
+    HasErf = 0,
+    HasErfc = 0,
+    HasNdtri = 0,
+    HasIGamma = 0,
+    HasIGammac = 0,
+    HasBetaInc = 0,
+    HasBlend = has_blend,
+    // This flag is used to indicate whether packet comparison is supported.
+    // pcmp_eq, pcmp_lt and pcmp_le should be defined for it to be true.
+    HasCmp = 1,
+    HasMax = 1,
+    HasMin = 1,
+    HasMul = 1,
+    HasAdd = 1,
+    HasFloor = 1,
+    HasRound = 1,
+    HasRint = 1,
+    HasLog1p = 1,
+    HasExpm1 = 1,
+    HasCeil = 1,
+  };
+};
+
+#ifdef SYCL_DEVICE_ONLY
+#define SYCL_PACKET_TRAITS(packet_type, has_blend, unpacket_type, lengths) \
+  template <>                                                              \
+  struct packet_traits<unpacket_type>                                      \
+      : sycl_packet_traits<has_blend, lengths> {                           \
+    typedef packet_type type;                                              \
+    typedef packet_type half;                                              \
+  };
+
+SYCL_PACKET_TRAITS(cl::sycl::cl_float4, 1, float, 4)
+SYCL_PACKET_TRAITS(cl::sycl::cl_float4, 1, const float, 4)
+SYCL_PACKET_TRAITS(cl::sycl::cl_double2, 0, double, 2)
+SYCL_PACKET_TRAITS(cl::sycl::cl_double2, 0, const double, 2)
+#undef SYCL_PACKET_TRAITS
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#define SYCL_ARITHMETIC(packet_type)  \
+  template <>                         \
+  struct is_arithmetic<packet_type> { \
+    enum { value = true };            \
+  };
+SYCL_ARITHMETIC(cl::sycl::cl_float4)
+SYCL_ARITHMETIC(cl::sycl::cl_double2)
+#undef SYCL_ARITHMETIC
+
+#define SYCL_UNPACKET_TRAITS(packet_type, unpacket_type, lengths)        \
+  template <>                                                            \
+  struct unpacket_traits<packet_type> {                                  \
+    typedef unpacket_type type;                                          \
+    enum { size = lengths, vectorizable = true, alignment = Aligned16 }; \
+    typedef packet_type half;                                            \
+  };
+SYCL_UNPACKET_TRAITS(cl::sycl::cl_float4, float, 4)
+SYCL_UNPACKET_TRAITS(cl::sycl::cl_double2, double, 2)
+
+#undef SYCL_UNPACKET_TRAITS
+#endif
+
+}  // end namespace internal
+
+#endif
+
+namespace TensorSycl {
+namespace internal {
+
+template <typename PacketReturnType, int PacketSize>
+struct PacketWrapper;
+// This function should never get called on the device
+#ifndef SYCL_DEVICE_ONLY
+template <typename PacketReturnType, int PacketSize>
+struct PacketWrapper {
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
+      Scalar;
+  template <typename Index>
+  EIGEN_DEVICE_FUNC static Scalar scalarize(Index, PacketReturnType &) {
+    eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR  THE CHOSEN TYPE");
+    abort();
+  }
+  EIGEN_DEVICE_FUNC static PacketReturnType convert_to_packet_type(Scalar in,
+                                                                   Scalar) {
+    return ::Eigen::internal::template plset<PacketReturnType>(in);
+  }
+  EIGEN_DEVICE_FUNC static void set_packet(PacketReturnType, Scalar *) {
+    eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR  THE CHOSEN TYPE");
+    abort();
+  }
+};
+
+#elif defined(SYCL_DEVICE_ONLY)
+template <typename PacketReturnType>
+struct PacketWrapper<PacketReturnType, 4> {
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
+      Scalar;
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, PacketReturnType &in) {
+    switch (index) {
+      case 0:
+        return in.x();
+      case 1:
+        return in.y();
+      case 2:
+        return in.z();
+      case 3:
+        return in.w();
+      default:
+      //INDEX MUST BE BETWEEN 0 and 3.There is no abort function in SYCL kernel. so we cannot use abort here. 
+      // The code will never reach here
+      __builtin_unreachable();
+    }
+    __builtin_unreachable();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(
+      Scalar in, Scalar other) {
+    return PacketReturnType(in, other, other, other);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
+    lhs = PacketReturnType(rhs[0], rhs[1], rhs[2], rhs[3]);
+  }
+};
+
+template <typename PacketReturnType>
+struct PacketWrapper<PacketReturnType, 1> {
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
+      Scalar;
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index, PacketReturnType &in) {
+    return in;
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(Scalar in,
+                                                                   Scalar) {
+    return PacketReturnType(in);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
+    lhs = rhs[0];
+  }
+};
+
+template <typename PacketReturnType>
+struct PacketWrapper<PacketReturnType, 2> {
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
+      Scalar;
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, PacketReturnType &in) {
+    switch (index) {
+      case 0:
+        return in.x();
+      case 1:
+        return in.y();
+      default:
+        //INDEX MUST BE BETWEEN 0 and 1.There is no abort function in SYCL kernel. so we cannot use abort here. 
+      // The code will never reach here
+        __builtin_unreachable();
+    }
+    __builtin_unreachable();
+  }
+  
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(
+      Scalar in, Scalar other) {
+    return PacketReturnType(in, other);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
+    lhs = PacketReturnType(rhs[0], rhs[1]);
+  }
+};
+
+#endif
+
+}  // end namespace internal
+}  // end namespace TensorSycl
+}  // end namespace Eigen
+
+#endif  // EIGEN_INTEROP_HEADERS_SYCL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/MathFunctions.h
new file mode 100644
index 00000000..2ab0f2a7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/MathFunctions.h
@@ -0,0 +1,301 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*****************************************************************
+ * MathFunctions.h
+ *
+ * \brief:
+ *  MathFunctions
+ *
+ *****************************************************************/
+
+#ifndef EIGEN_MATH_FUNCTIONS_SYCL_H
+#define EIGEN_MATH_FUNCTIONS_SYCL_H
+namespace Eigen {
+
+namespace internal {
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#if defined(SYCL_DEVICE_ONLY)
+#define SYCL_PLOG(packet_type)                                         \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog<packet_type>( \
+      const packet_type& a) {                                          \
+    return cl::sycl::log(a);                                           \
+  }
+
+SYCL_PLOG(cl::sycl::cl_float4)
+SYCL_PLOG(cl::sycl::cl_double2)
+#undef SYCL_PLOG
+
+#define SYCL_PLOG1P(packet_type)                                         \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog1p<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::log1p(a);                                           \
+  }
+
+SYCL_PLOG1P(cl::sycl::cl_float4)
+SYCL_PLOG1P(cl::sycl::cl_double2)
+#undef SYCL_PLOG1P
+
+#define SYCL_PLOG10(packet_type)                                         \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog10<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::log10(a);                                           \
+  }
+
+SYCL_PLOG10(cl::sycl::cl_float4)
+SYCL_PLOG10(cl::sycl::cl_double2)
+#undef SYCL_PLOG10
+
+#define SYCL_PEXP(packet_type)                                         \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexp<packet_type>( \
+      const packet_type& a) {                                          \
+    return cl::sycl::exp(a);                                           \
+  }
+
+SYCL_PEXP(cl::sycl::cl_float4)
+SYCL_PEXP(cl::sycl::cl_float)
+SYCL_PEXP(cl::sycl::cl_double2)
+#undef SYCL_PEXP
+
+#define SYCL_PEXPM1(packet_type)                                         \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexpm1<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::expm1(a);                                           \
+  }
+
+SYCL_PEXPM1(cl::sycl::cl_float4)
+SYCL_PEXPM1(cl::sycl::cl_double2)
+#undef SYCL_PEXPM1
+
+#define SYCL_PSQRT(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psqrt<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::sqrt(a);                                           \
+  }
+
+SYCL_PSQRT(cl::sycl::cl_float4)
+SYCL_PSQRT(cl::sycl::cl_double2)
+#undef SYCL_PSQRT
+
+#define SYCL_PRSQRT(packet_type)                                         \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type prsqrt<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::rsqrt(a);                                           \
+  }
+
+SYCL_PRSQRT(cl::sycl::cl_float4)
+SYCL_PRSQRT(cl::sycl::cl_double2)
+#undef SYCL_PRSQRT
+
+/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
+#define SYCL_PSIN(packet_type)                                         \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psin<packet_type>( \
+      const packet_type& a) {                                          \
+    return cl::sycl::sin(a);                                           \
+  }
+
+SYCL_PSIN(cl::sycl::cl_float4)
+SYCL_PSIN(cl::sycl::cl_double2)
+#undef SYCL_PSIN
+
+/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
+#define SYCL_PCOS(packet_type)                                         \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcos<packet_type>( \
+      const packet_type& a) {                                          \
+    return cl::sycl::cos(a);                                           \
+  }
+
+SYCL_PCOS(cl::sycl::cl_float4)
+SYCL_PCOS(cl::sycl::cl_double2)
+#undef SYCL_PCOS
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
+#define SYCL_PTAN(packet_type)                                         \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptan<packet_type>( \
+      const packet_type& a) {                                          \
+    return cl::sycl::tan(a);                                           \
+  }
+
+SYCL_PTAN(cl::sycl::cl_float4)
+SYCL_PTAN(cl::sycl::cl_double2)
+#undef SYCL_PTAN
+
+/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
+#define SYCL_PASIN(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pasin<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::asin(a);                                           \
+  }
+
+SYCL_PASIN(cl::sycl::cl_float4)
+SYCL_PASIN(cl::sycl::cl_double2)
+#undef SYCL_PASIN
+
+/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
+#define SYCL_PACOS(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pacos<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::acos(a);                                           \
+  }
+
+SYCL_PACOS(cl::sycl::cl_float4)
+SYCL_PACOS(cl::sycl::cl_double2)
+#undef SYCL_PACOS
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
+#define SYCL_PATAN(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type patan<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::atan(a);                                           \
+  }
+
+SYCL_PATAN(cl::sycl::cl_float4)
+SYCL_PATAN(cl::sycl::cl_double2)
+#undef SYCL_PATAN
+
+/** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
+#define SYCL_PSINH(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psinh<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::sinh(a);                                           \
+  }
+
+SYCL_PSINH(cl::sycl::cl_float4)
+SYCL_PSINH(cl::sycl::cl_double2)
+#undef SYCL_PSINH
+
+/** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
+#define SYCL_PCOSH(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcosh<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::cosh(a);                                           \
+  }
+
+SYCL_PCOSH(cl::sycl::cl_float4)
+SYCL_PCOSH(cl::sycl::cl_double2)
+#undef SYCL_PCOSH
+
+/** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
+#define SYCL_PTANH(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptanh<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::tanh(a);                                           \
+  }
+
+SYCL_PTANH(cl::sycl::cl_float4)
+SYCL_PTANH(cl::sycl::cl_double2)
+#undef SYCL_PTANH
+
+#define SYCL_PCEIL(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pceil<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::ceil(a);                                           \
+  }
+
+SYCL_PCEIL(cl::sycl::cl_float4)
+SYCL_PCEIL(cl::sycl::cl_double2)
+#undef SYCL_PCEIL
+
+#define SYCL_PROUND(packet_type)                                         \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pround<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::round(a);                                           \
+  }
+
+SYCL_PROUND(cl::sycl::cl_float4)
+SYCL_PROUND(cl::sycl::cl_double2)
+#undef SYCL_PROUND
+
+#define SYCL_PRINT(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type print<packet_type>( \
+      const packet_type& a) {                                           \
+    return cl::sycl::rint(a);                                           \
+  }
+
+SYCL_PRINT(cl::sycl::cl_float4)
+SYCL_PRINT(cl::sycl::cl_double2)
+#undef SYCL_PRINT
+
+#define SYCL_FLOOR(packet_type)                                          \
+  template <>                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pfloor<packet_type>( \
+      const packet_type& a) {                                            \
+    return cl::sycl::floor(a);                                           \
+  }
+
+SYCL_FLOOR(cl::sycl::cl_float4)
+SYCL_FLOOR(cl::sycl::cl_double2)
+#undef SYCL_FLOOR
+
+#define SYCL_PMIN(packet_type, expr)                                   \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmin<packet_type>( \
+      const packet_type& a, const packet_type& b) {                    \
+    return expr;                                                       \
+  }
+
+SYCL_PMIN(cl::sycl::cl_float4, cl::sycl::fmin(a, b))
+SYCL_PMIN(cl::sycl::cl_double2, cl::sycl::fmin(a, b))
+#undef SYCL_PMIN
+
+#define SYCL_PMAX(packet_type, expr)                                   \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmax<packet_type>( \
+      const packet_type& a, const packet_type& b) {                    \
+    return expr;                                                       \
+  }
+
+SYCL_PMAX(cl::sycl::cl_float4, cl::sycl::fmax(a, b))
+SYCL_PMAX(cl::sycl::cl_double2, cl::sycl::fmax(a, b))
+#undef SYCL_PMAX
+
+#define SYCL_PLDEXP(packet_type)                                             \
+  template <>                                                                \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pldexp(                  \
+      const packet_type& a, const packet_type& exponent) {                   \
+    return cl::sycl::ldexp(                                                  \
+        a, exponent.template convert<cl::sycl::cl_int,                       \
+                                     cl::sycl::rounding_mode::automatic>()); \
+  }
+
+SYCL_PLDEXP(cl::sycl::cl_float4)
+SYCL_PLDEXP(cl::sycl::cl_double2)
+#undef SYCL_PLDEXP
+
+#endif
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_SYCL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/PacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/PacketMath.h
new file mode 100644
index 00000000..87badc07
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/PacketMath.h
@@ -0,0 +1,670 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*****************************************************************
+ * PacketMath.h
+ *
+ * \brief:
+ *  PacketMath
+ *
+ *****************************************************************/
+
+#ifndef EIGEN_PACKET_MATH_SYCL_H
+#define EIGEN_PACKET_MATH_SYCL_H
+#include <type_traits>
+namespace Eigen {
+
+namespace internal {
+#ifdef SYCL_DEVICE_ONLY
+
+#define SYCL_PLOADT_RO(address_space_target)                                 \
+  template <typename packet_type, int Alignment>                             \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type ploadt_ro(               \
+      typename cl::sycl::multi_ptr<                                          \
+          const typename unpacket_traits<packet_type>::type,                 \
+          cl::sycl::access::address_space::address_space_target>::pointer_t  \
+          from) {                                                            \
+    typedef typename unpacket_traits<packet_type>::type scalar;              \
+    typedef cl::sycl::multi_ptr<                                             \
+        scalar, cl::sycl::access::address_space::address_space_target>       \
+        multi_ptr;                                                           \
+    auto res = packet_type(                                                  \
+        static_cast<typename unpacket_traits<packet_type>::type>(0));        \
+    res.load(0, multi_ptr(const_cast<typename multi_ptr::pointer_t>(from))); \
+    return res;                                                              \
+  }
+
+SYCL_PLOADT_RO(global_space)
+SYCL_PLOADT_RO(local_space)
+#undef SYCL_PLOADT_RO
+#endif
+
+template <typename packet_type, int Alignment, typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type
+ploadt_ro(const Eigen::TensorSycl::internal::RangeAccess<
+          cl::sycl::access::mode::read_write, T>& from) {
+  return ploadt_ro<packet_type, Alignment>(from.get_pointer());
+}
+
+#ifdef SYCL_DEVICE_ONLY
+#define SYCL_PLOAD(address_space_target, Alignment, AlignedType)            \
+  template <typename packet_type>                                           \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type pload##AlignedType(     \
+      typename cl::sycl::multi_ptr<                                         \
+          const typename unpacket_traits<packet_type>::type,                \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          from) {                                                           \
+    return ploadt_ro<packet_type, Alignment>(from);                         \
+  }
+
+// global space
+SYCL_PLOAD(global_space, Unaligned, u)
+SYCL_PLOAD(global_space, Aligned, )
+// local space
+SYCL_PLOAD(local_space, Unaligned, u)
+SYCL_PLOAD(local_space, Aligned, )
+
+#undef SYCL_PLOAD
+#endif
+
+#define SYCL_PLOAD(Alignment, AlignedType)                              \
+  template <typename packet_type>                                       \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type pload##AlignedType( \
+      const Eigen::TensorSycl::internal::RangeAccess<                   \
+          cl::sycl::access::mode::read_write,                           \
+          typename unpacket_traits<packet_type>::type>                  \
+          from) {                                                       \
+    return ploadt_ro<packet_type, Alignment>(from);                     \
+  }
+SYCL_PLOAD(Unaligned, u)
+SYCL_PLOAD(Aligned, )
+#undef SYCL_PLOAD
+
+#ifdef SYCL_DEVICE_ONLY
+/** \internal \returns a packet version of \a *from.
+ * The pointer \a from must be aligned on a \a Alignment bytes boundary. */
+#define SYCL_PLOADT(address_space_target)                                   \
+  template <typename packet_type, int Alignment>                            \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type ploadt(                 \
+      typename cl::sycl::multi_ptr<                                         \
+          const typename unpacket_traits<packet_type>::type,                \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          from) {                                                           \
+    if (Alignment >= unpacket_traits<packet_type>::alignment)               \
+      return pload<packet_type>(from);                                      \
+    else                                                                    \
+      return ploadu<packet_type>(from);                                     \
+  }
+
+// global space
+SYCL_PLOADT(global_space)
+// local space
+SYCL_PLOADT(local_space)
+#undef SYCL_PLOADT
+#endif
+
+template <typename packet_type, int Alignment>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type
+ploadt(const Eigen::TensorSycl::internal::RangeAccess<
+       cl::sycl::access::mode::read_write,
+       typename unpacket_traits<packet_type>::type>& from) {
+  return ploadt<packet_type, Alignment>(from.get_pointer());
+}
+#ifdef SYCL_DEVICE_ONLY
+
+// private_space
+#define SYCL_PLOADT_RO_SPECIAL(packet_type, Alignment)                 \
+  template <>                                                          \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type                    \
+  ploadt_ro<packet_type, Alignment>(                                   \
+      const typename unpacket_traits<packet_type>::type* from) {       \
+    typedef typename unpacket_traits<packet_type>::type scalar;        \
+    auto res = packet_type(static_cast<scalar>(0));                    \
+    res.template load<cl::sycl::access::address_space::private_space>( \
+        0, const_cast<scalar*>(from));                                 \
+    return res;                                                        \
+  }
+
+SYCL_PLOADT_RO_SPECIAL(cl::sycl::cl_float4, Aligned)
+SYCL_PLOADT_RO_SPECIAL(cl::sycl::cl_double2, Aligned)
+SYCL_PLOADT_RO_SPECIAL(cl::sycl::cl_float4, Unaligned)
+SYCL_PLOADT_RO_SPECIAL(cl::sycl::cl_double2, Unaligned)
+
+#define SYCL_PLOAD_SPECIAL(packet_type, alignment_type)                    \
+  template <>                                                              \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type pload##alignment_type( \
+      const typename unpacket_traits<packet_type>::type* from) {           \
+    typedef typename unpacket_traits<packet_type>::type scalar;            \
+    auto res = packet_type(static_cast<scalar>(0));                        \
+    res.template load<cl::sycl::access::address_space::private_space>(     \
+        0, const_cast<scalar*>(from));                                     \
+    return res;                                                            \
+  }
+SYCL_PLOAD_SPECIAL(cl::sycl::cl_float4, )
+SYCL_PLOAD_SPECIAL(cl::sycl::cl_double2, )
+SYCL_PLOAD_SPECIAL(cl::sycl::cl_float4, u)
+SYCL_PLOAD_SPECIAL(cl::sycl::cl_double2, u)
+
+#undef SYCL_PLOAD_SPECIAL
+
+#define SYCL_PSTORE(scalar, packet_type, address_space_target, alignment)   \
+  template <>                                                               \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstore##alignment(             \
+      typename cl::sycl::multi_ptr<                                         \
+          scalar,                                                           \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          to,                                                               \
+      const packet_type& from) {                                            \
+    typedef cl::sycl::multi_ptr<                                            \
+        scalar, cl::sycl::access::address_space::address_space_target>      \
+        multi_ptr;                                                          \
+    from.store(0, multi_ptr(to));                                           \
+  }
+
+// global space
+SYCL_PSTORE(float, cl::sycl::cl_float4, global_space, )
+SYCL_PSTORE(float, cl::sycl::cl_float4, global_space, u)
+SYCL_PSTORE(double, cl::sycl::cl_double2, global_space, )
+SYCL_PSTORE(double, cl::sycl::cl_double2, global_space, u)
+SYCL_PSTORE(float, cl::sycl::cl_float4, local_space, )
+SYCL_PSTORE(float, cl::sycl::cl_float4, local_space, u)
+SYCL_PSTORE(double, cl::sycl::cl_double2, local_space, )
+SYCL_PSTORE(double, cl::sycl::cl_double2, local_space, u)
+
+SYCL_PSTORE(float, cl::sycl::cl_float4, private_space, )
+SYCL_PSTORE(float, cl::sycl::cl_float4, private_space, u)
+SYCL_PSTORE(double, cl::sycl::cl_double2, private_space, )
+SYCL_PSTORE(double, cl::sycl::cl_double2, private_space, u)
+#undef SYCL_PSTORE
+
+#define SYCL_PSTORE_T(address_space_target)                                 \
+  template <typename scalar, typename packet_type, int Alignment>           \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(                       \
+      typename cl::sycl::multi_ptr<                                         \
+          scalar,                                                           \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          to,                                                               \
+      const packet_type& from) {                                            \
+    if (Alignment)                                                          \
+      pstore(to, from);                                                     \
+    else                                                                    \
+      pstoreu(to, from);                                                    \
+  }
+
+SYCL_PSTORE_T(global_space)
+
+SYCL_PSTORE_T(local_space)
+
+#undef SYCL_PSTORE_T
+
+#define SYCL_PSET1(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type pset1<packet_type>( \
+      const typename unpacket_traits<packet_type>::type& from) {        \
+    return packet_type(from);                                           \
+  }
+
+// global space
+SYCL_PSET1(cl::sycl::cl_float4)
+SYCL_PSET1(cl::sycl::cl_double2)
+
+#undef SYCL_PSET1
+
+template <typename packet_type>
+struct get_base_packet {
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type
+  get_ploaddup(sycl_multi_pointer) {}
+
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type
+  get_pgather(sycl_multi_pointer, Index) {}
+};
+
+template <>
+struct get_base_packet<cl::sycl::cl_float4> {
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_float4 get_ploaddup(
+      sycl_multi_pointer from) {
+    return cl::sycl::cl_float4(from[0], from[0], from[1], from[1]);
+  }
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_float4 get_pgather(
+      sycl_multi_pointer from, Index stride) {
+    return cl::sycl::cl_float4(from[0 * stride], from[1 * stride],
+                               from[2 * stride], from[3 * stride]);
+  }
+
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void set_pscatter(
+      sycl_multi_pointer to, const cl::sycl::cl_float4& from, Index stride) {
+    auto tmp = stride;
+    to[0] = from.x();
+    to[tmp] = from.y();
+    to[tmp += stride] = from.z();
+    to[tmp += stride] = from.w();
+  }
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_float4 set_plset(
+      const float& a) {
+    return cl::sycl::cl_float4(static_cast<float>(a), static_cast<float>(a + 1),
+                               static_cast<float>(a + 2),
+                               static_cast<float>(a + 3));
+  }
+};
+
+template <>
+struct get_base_packet<cl::sycl::cl_double2> {
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_double2
+  get_ploaddup(const sycl_multi_pointer from) {
+    return cl::sycl::cl_double2(from[0], from[0]);
+  }
+
+  template <typename sycl_multi_pointer, typename Index>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_double2 get_pgather(
+      const sycl_multi_pointer from, Index stride) {
+    return cl::sycl::cl_double2(from[0 * stride], from[1 * stride]);
+  }
+
+  template <typename sycl_multi_pointer>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void set_pscatter(
+      sycl_multi_pointer to, const cl::sycl::cl_double2& from, Index stride) {
+    to[0] = from.x();
+    to[stride] = from.y();
+  }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE cl::sycl::cl_double2 set_plset(
+      const double& a) {
+    return cl::sycl::cl_double2(static_cast<double>(a),
+                                static_cast<double>(a + 1));
+  }
+};
+
+#define SYCL_PLOAD_DUP(address_space_target)                                \
+  template <typename packet_type>                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ploaddup(               \
+      typename cl::sycl::multi_ptr<                                         \
+          const typename unpacket_traits<packet_type>::type,                \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          from) {                                                           \
+    return get_base_packet<packet_type>::get_ploaddup(from);                \
+  }
+
+// global space
+SYCL_PLOAD_DUP(global_space)
+// local_space
+SYCL_PLOAD_DUP(local_space)
+#undef SYCL_PLOAD_DUP
+
+#define SYCL_PLOAD_DUP_SPECILIZE(packet_type)                              \
+  template <>                                                              \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ploaddup<packet_type>( \
+      const typename unpacket_traits<packet_type>::type* from) {           \
+    return get_base_packet<packet_type>::get_ploaddup(from);               \
+  }
+
+SYCL_PLOAD_DUP_SPECILIZE(cl::sycl::cl_float4)
+SYCL_PLOAD_DUP_SPECILIZE(cl::sycl::cl_double2)
+
+#undef SYCL_PLOAD_DUP_SPECILIZE
+
+#define SYCL_PLSET(packet_type)                                         \
+  template <>                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type plset<packet_type>( \
+      const typename unpacket_traits<packet_type>::type& a) {           \
+    return get_base_packet<packet_type>::set_plset(a);                  \
+  }
+
+SYCL_PLSET(cl::sycl::cl_float4)
+SYCL_PLSET(cl::sycl::cl_double2)
+
+#undef SYCL_PLSET
+
+#define SYCL_PGATHER(address_space_target)                                  \
+  template <typename Scalar, typename packet_type>                          \
+  EIGEN_DEVICE_FUNC inline packet_type pgather(                             \
+      typename cl::sycl::multi_ptr<                                         \
+          const typename unpacket_traits<packet_type>::type,                \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          from,                                                             \
+      Index stride) {                                                       \
+    return get_base_packet<packet_type>::get_pgather(from, stride);         \
+  }
+
+// global space
+SYCL_PGATHER(global_space)
+// local space
+SYCL_PGATHER(local_space)
+
+#undef SYCL_PGATHER
+
+#define SYCL_PGATHER_SPECILIZE(scalar, packet_type)                            \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type                            \
+  pgather<scalar, packet_type>(                                                \
+      const typename unpacket_traits<packet_type>::type* from, Index stride) { \
+    return get_base_packet<packet_type>::get_pgather(from, stride);            \
+  }
+
+SYCL_PGATHER_SPECILIZE(float, cl::sycl::cl_float4)
+SYCL_PGATHER_SPECILIZE(double, cl::sycl::cl_double2)
+
+#undef SYCL_PGATHER_SPECILIZE
+
+#define SYCL_PSCATTER(address_space_target)                                 \
+  template <typename Scalar, typename packet_type>                          \
+  EIGEN_DEVICE_FUNC inline void pscatter(                                   \
+      typename cl::sycl::multi_ptr<                                         \
+          typename unpacket_traits<packet_type>::type,                      \
+          cl::sycl::access::address_space::address_space_target>::pointer_t \
+          to,                                                               \
+      const packet_type& from, Index stride) {                              \
+    get_base_packet<packet_type>::set_pscatter(to, from, stride);           \
+  }
+
+// global space
+SYCL_PSCATTER(global_space)
+// local space
+SYCL_PSCATTER(local_space)
+
+#undef SYCL_PSCATTER
+
+#define SYCL_PSCATTER_SPECILIZE(scalar, packet_type)                        \
+  template <>                                                               \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<scalar, packet_type>( \
+      typename unpacket_traits<packet_type>::type * to,                     \
+      const packet_type& from, Index stride) {                              \
+    get_base_packet<packet_type>::set_pscatter(to, from, stride);           \
+  }
+
+SYCL_PSCATTER_SPECILIZE(float, cl::sycl::cl_float4)
+SYCL_PSCATTER_SPECILIZE(double, cl::sycl::cl_double2)
+
+#undef SYCL_PSCATTER_SPECILIZE
+
+#define SYCL_PMAD(packet_type)                                            \
+  template <>                                                             \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE packet_type pmadd(                \
+      const packet_type& a, const packet_type& b, const packet_type& c) { \
+    return cl::sycl::mad(a, b, c);                                        \
+  }
+
+SYCL_PMAD(cl::sycl::cl_float4)
+SYCL_PMAD(cl::sycl::cl_double2)
+#undef SYCL_PMAD
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float pfirst<cl::sycl::cl_float4>(
+    const cl::sycl::cl_float4& a) {
+  return a.x();
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double pfirst<cl::sycl::cl_double2>(
+    const cl::sycl::cl_double2& a) {
+  return a.x();
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float predux<cl::sycl::cl_float4>(
+    const cl::sycl::cl_float4& a) {
+  return a.x() + a.y() + a.z() + a.w();
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double predux<cl::sycl::cl_double2>(
+    const cl::sycl::cl_double2& a) {
+  return a.x() + a.y();
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float predux_max<cl::sycl::cl_float4>(
+    const cl::sycl::cl_float4& a) {
+  return cl::sycl::fmax(cl::sycl::fmax(a.x(), a.y()),
+                        cl::sycl::fmax(a.z(), a.w()));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double predux_max<cl::sycl::cl_double2>(
+    const cl::sycl::cl_double2& a) {
+  return cl::sycl::fmax(a.x(), a.y());
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float predux_min<cl::sycl::cl_float4>(
+    const cl::sycl::cl_float4& a) {
+  return cl::sycl::fmin(cl::sycl::fmin(a.x(), a.y()),
+                        cl::sycl::fmin(a.z(), a.w()));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double predux_min<cl::sycl::cl_double2>(
+    const cl::sycl::cl_double2& a) {
+  return cl::sycl::fmin(a.x(), a.y());
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float predux_mul<cl::sycl::cl_float4>(
+    const cl::sycl::cl_float4& a) {
+  return a.x() * a.y() * a.z() * a.w();
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double predux_mul<cl::sycl::cl_double2>(
+    const cl::sycl::cl_double2& a) {
+  return a.x() * a.y();
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_float4
+pabs<cl::sycl::cl_float4>(const cl::sycl::cl_float4& a) {
+  return cl::sycl::cl_float4(cl::sycl::fabs(a.x()), cl::sycl::fabs(a.y()),
+                             cl::sycl::fabs(a.z()), cl::sycl::fabs(a.w()));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_double2
+pabs<cl::sycl::cl_double2>(const cl::sycl::cl_double2& a) {
+  return cl::sycl::cl_double2(cl::sycl::fabs(a.x()), cl::sycl::fabs(a.y()));
+}
+
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet sycl_pcmp_le(const Packet &a,
+                                                          const Packet &b) {
+  return ((a <= b)
+              .template convert<typename unpacket_traits<Packet>::type,
+                                cl::sycl::rounding_mode::automatic>());
+}
+
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet sycl_pcmp_lt(const Packet &a,
+                                                          const Packet &b) {
+  return ((a < b)
+              .template convert<typename unpacket_traits<Packet>::type,
+                                cl::sycl::rounding_mode::automatic>());
+}
+
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet sycl_pcmp_eq(const Packet &a,
+                                                          const Packet &b) {
+  return ((a == b)
+              .template convert<typename unpacket_traits<Packet>::type,
+                                cl::sycl::rounding_mode::automatic>());
+}
+
+#define SYCL_PCMP(OP, TYPE)                                                    \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TYPE pcmp_##OP<TYPE>(const TYPE &a,    \
+                                                             const TYPE &b) {  \
+    return sycl_pcmp_##OP<TYPE>(a, b);                                         \
+  }
+
+SYCL_PCMP(le, cl::sycl::cl_float4)
+SYCL_PCMP(lt, cl::sycl::cl_float4)
+SYCL_PCMP(eq, cl::sycl::cl_float4)
+SYCL_PCMP(le, cl::sycl::cl_double2)
+SYCL_PCMP(lt, cl::sycl::cl_double2)
+SYCL_PCMP(eq, cl::sycl::cl_double2)
+#undef SYCL_PCMP
+
+template <typename T> struct convert_to_integer;
+
+template <> struct convert_to_integer<float> {
+  using type = std::int32_t;
+  using packet_type = cl::sycl::cl_int4;
+};
+template <> struct convert_to_integer<double> {
+  using type = std::int64_t;
+  using packet_type = cl::sycl::cl_long2;
+};
+
+template <typename PacketIn>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename convert_to_integer<
+    typename unpacket_traits<PacketIn>::type>::packet_type
+vector_as_int(const PacketIn &p) {
+  return (
+      p.template convert<typename convert_to_integer<
+                             typename unpacket_traits<PacketIn>::type>::type,
+                         cl::sycl::rounding_mode::automatic>());
+}
+
+template <typename packetOut, typename PacketIn>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packetOut
+convert_vector(const PacketIn &p) {
+  return (p.template convert<typename unpacket_traits<packetOut>::type,
+                             cl::sycl::rounding_mode::automatic>());
+}
+
+#define SYCL_PAND(TYPE)                                                        \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TYPE pand<TYPE>(const TYPE &a,         \
+                                                        const TYPE &b) {       \
+    return convert_vector<TYPE>(vector_as_int(a) & vector_as_int(b));          \
+  }
+SYCL_PAND(cl::sycl::cl_float4)
+SYCL_PAND(cl::sycl::cl_double2)
+#undef SYCL_PAND
+
+#define SYCL_POR(TYPE)                                                         \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TYPE por<TYPE>(const TYPE &a,          \
+                                                       const TYPE &b) {        \
+    return convert_vector<TYPE>(vector_as_int(a) | vector_as_int(b));          \
+  }
+
+SYCL_POR(cl::sycl::cl_float4)
+SYCL_POR(cl::sycl::cl_double2)
+#undef SYCL_POR
+
+#define SYCL_PXOR(TYPE)                                                        \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TYPE pxor<TYPE>(const TYPE &a,         \
+                                                        const TYPE &b) {       \
+    return convert_vector<TYPE>(vector_as_int(a) ^ vector_as_int(b));          \
+  }
+
+SYCL_PXOR(cl::sycl::cl_float4)
+SYCL_PXOR(cl::sycl::cl_double2)
+#undef SYCL_PXOR
+
+#define SYCL_PANDNOT(TYPE)                                                     \
+  template <>                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TYPE pandnot<TYPE>(const TYPE &a,      \
+                                                           const TYPE &b) {    \
+    return convert_vector<TYPE>(vector_as_int(a) & (~vector_as_int(b)));       \
+  }
+SYCL_PANDNOT(cl::sycl::cl_float4)
+SYCL_PANDNOT(cl::sycl::cl_double2)
+#undef SYCL_PANDNOT
+
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(
+    PacketBlock<cl::sycl::cl_float4, 4>& kernel) {
+  float tmp = kernel.packet[0].y();
+  kernel.packet[0].y() = kernel.packet[1].x();
+  kernel.packet[1].x() = tmp;
+
+  tmp = kernel.packet[0].z();
+  kernel.packet[0].z() = kernel.packet[2].x();
+  kernel.packet[2].x() = tmp;
+
+  tmp = kernel.packet[0].w();
+  kernel.packet[0].w() = kernel.packet[3].x();
+  kernel.packet[3].x() = tmp;
+
+  tmp = kernel.packet[1].z();
+  kernel.packet[1].z() = kernel.packet[2].y();
+  kernel.packet[2].y() = tmp;
+
+  tmp = kernel.packet[1].w();
+  kernel.packet[1].w() = kernel.packet[3].y();
+  kernel.packet[3].y() = tmp;
+
+  tmp = kernel.packet[2].w();
+  kernel.packet[2].w() = kernel.packet[3].z();
+  kernel.packet[3].z() = tmp;
+}
+
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(
+    PacketBlock<cl::sycl::cl_double2, 2>& kernel) {
+  double tmp = kernel.packet[0].y();
+  kernel.packet[0].y() = kernel.packet[1].x();
+  kernel.packet[1].x() = tmp;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_float4 pblend(
+    const Selector<unpacket_traits<cl::sycl::cl_float4>::size>& ifPacket,
+    const cl::sycl::cl_float4& thenPacket,
+    const cl::sycl::cl_float4& elsePacket) {
+  cl::sycl::cl_int4 condition(
+      ifPacket.select[0] ? 0 : -1, ifPacket.select[1] ? 0 : -1,
+      ifPacket.select[2] ? 0 : -1, ifPacket.select[3] ? 0 : -1);
+  return cl::sycl::select(thenPacket, elsePacket, condition);
+}
+
+template <>
+inline cl::sycl::cl_double2 pblend(
+    const Selector<unpacket_traits<cl::sycl::cl_double2>::size>& ifPacket,
+    const cl::sycl::cl_double2& thenPacket,
+    const cl::sycl::cl_double2& elsePacket) {
+  cl::sycl::cl_long2 condition(ifPacket.select[0] ? 0 : -1,
+                               ifPacket.select[1] ? 0 : -1);
+  return cl::sycl::select(thenPacket, elsePacket, condition);
+}
+#endif  // SYCL_DEVICE_ONLY
+
+#define SYCL_PSTORE(alignment)                                  \
+  template <typename packet_type>                               \
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstore##alignment( \
+      const Eigen::TensorSycl::internal::RangeAccess<           \
+          cl::sycl::access::mode::read_write,                   \
+          typename unpacket_traits<packet_type>::type>& to,     \
+      const packet_type& from) {                                \
+    pstore##alignment(to.get_pointer(), from);                  \
+  }
+
+// global space
+SYCL_PSTORE()
+SYCL_PSTORE(u)
+
+#undef SYCL_PSTORE
+
+template <typename scalar, typename packet_type, int Alignment>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(
+    Eigen::TensorSycl::internal::RangeAccess<
+        cl::sycl::access::mode::read_write,
+        typename unpacket_traits<packet_type>::type>
+        to,
+    const packet_type& from) {
+  pstoret<scalar, packet_type, Alignment>(to.get_pointer(), from);
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_PACKET_MATH_SYCL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
new file mode 100644
index 00000000..f81e59db
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
@@ -0,0 +1,694 @@
+/***************************************************************************
+ *  Copyright (C) 2017 Codeplay Software Limited
+ *  This Source Code Form is subject to the terms of the Mozilla
+ *  Public License v. 2.0. If a copy of the MPL was not distributed
+ *  with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ *
+ *  SyclMemoryModel.h
+ *
+ *  Description:
+ *    Interface for SYCL buffers to behave as a non-dereferenceable pointer
+ *    Interface for Placeholder accessor to behave as a pointer on both host
+ *    and device
+ *
+ * Authors:
+ *
+ *    Ruyman Reyes   Codeplay Software Ltd.
+ *    Mehdi Goli     Codeplay Software Ltd.
+ *    Vanya Yaneva   Codeplay Software Ltd.
+ *
+ **************************************************************************/
+
+#if defined(EIGEN_USE_SYCL) && \
+    !defined(EIGEN_CXX11_TENSOR_TENSOR_SYCL_STORAGE_MEMORY_H)
+#define EIGEN_CXX11_TENSOR_TENSOR_SYCL_STORAGE_MEMORY_H
+
+#include <CL/sycl.hpp>
+#ifdef EIGEN_EXCEPTIONS
+#include <stdexcept>
+#endif
+#include <cstddef>
+#include <queue>
+#include <set>
+#include <unordered_map>
+
+namespace Eigen {
+namespace TensorSycl {
+namespace internal {
+
+using sycl_acc_target = cl::sycl::access::target;
+using sycl_acc_mode = cl::sycl::access::mode;
+
+/**
+ * Default values for template arguments
+ */
+using buffer_data_type_t = uint8_t;
+const sycl_acc_target default_acc_target = sycl_acc_target::global_buffer;
+const sycl_acc_mode default_acc_mode = sycl_acc_mode::read_write;
+
+/**
+ * PointerMapper
+ *  Associates fake pointers with buffers.
+ *
+ */
+class PointerMapper {
+ public:
+  using base_ptr_t = std::intptr_t;
+
+  /* Structure of a virtual pointer
+   *
+   * |================================================|
+   * |               POINTER ADDRESS                  |
+   * |================================================|
+   */
+  struct virtual_pointer_t {
+    /* Type for the pointers
+     */
+    base_ptr_t m_contents;
+
+    /** Conversions from virtual_pointer_t to
+     * void * should just reinterpret_cast the integer number
+     */
+    operator void *() const { return reinterpret_cast<void *>(m_contents); }
+
+    /**
+     * Convert back to the integer number.
+     */
+    operator base_ptr_t() const { return m_contents; }
+
+    /**
+     * Add a certain value to the pointer to create a
+     * new pointer to that offset
+     */
+    virtual_pointer_t operator+(size_t off) { return m_contents + off; }
+
+    /* Numerical order for sorting pointers in containers. */
+    bool operator<(virtual_pointer_t rhs) const {
+      return (static_cast<base_ptr_t>(m_contents) <
+              static_cast<base_ptr_t>(rhs.m_contents));
+    }
+
+    bool operator>(virtual_pointer_t rhs) const {
+      return (static_cast<base_ptr_t>(m_contents) >
+              static_cast<base_ptr_t>(rhs.m_contents));
+    }
+
+    /**
+     * Numerical order for sorting pointers in containers
+     */
+    bool operator==(virtual_pointer_t rhs) const {
+      return (static_cast<base_ptr_t>(m_contents) ==
+              static_cast<base_ptr_t>(rhs.m_contents));
+    }
+
+    /**
+     * Simple forward to the equality overload.
+     */
+    bool operator!=(virtual_pointer_t rhs) const {
+      return !(this->operator==(rhs));
+    }
+
+    /**
+     * Converts a void * into a virtual pointer structure.
+     * Note that this will only work if the void * was
+     * already a virtual_pointer_t, but we have no way of
+     * checking
+     */
+    virtual_pointer_t(const void *ptr)
+        : m_contents(reinterpret_cast<base_ptr_t>(ptr)){};
+
+    /**
+     * Creates a virtual_pointer_t from the given integer
+     * number
+     */
+    virtual_pointer_t(base_ptr_t u) : m_contents(u){};
+  };
+
+  /* Definition of a null pointer
+   */
+  const virtual_pointer_t null_virtual_ptr = nullptr;
+
+  /**
+   * Whether if a pointer is null or not.
+   * A pointer is nullptr if the value is of null_virtual_ptr
+   */
+  static inline bool is_nullptr(virtual_pointer_t ptr) {
+    return (static_cast<void *>(ptr) == nullptr);
+  }
+
+  /* basic type for all buffers
+   */
+  using buffer_t = cl::sycl::buffer_mem;
+
+  /**
+   * Node that stores information about a device allocation.
+   * Nodes are sorted by size to organise a free list of nodes
+   * that can be recovered.
+   */
+  struct pMapNode_t {
+    buffer_t m_buffer;
+    size_t m_size;
+    bool m_free;
+
+    pMapNode_t(buffer_t b, size_t size, bool f)
+        : m_buffer{b}, m_size{size}, m_free{f} {
+      m_buffer.set_final_data(nullptr);
+    }
+
+    bool operator<=(const pMapNode_t &rhs) { return (m_size <= rhs.m_size); }
+  };
+
+  /** Storage of the pointer / buffer tree
+   */
+  using pointerMap_t = std::map<virtual_pointer_t, pMapNode_t>;
+
+  /**
+   * Obtain the insertion point in the pointer map for
+   * a pointer of the given size.
+   * \param requiredSize Size attemted to reclaim
+   */
+  typename pointerMap_t::iterator get_insertion_point(size_t requiredSize) {
+    typename pointerMap_t::iterator retVal;
+    bool reuse = false;
+    if (!m_freeList.empty()) {
+      // try to re-use an existing block
+      for (auto freeElem : m_freeList) {
+        if (freeElem->second.m_size >= requiredSize) {
+          retVal = freeElem;
+          reuse = true;
+          // Element is not going to be free anymore
+          m_freeList.erase(freeElem);
+          break;
+        }
+      }
+    }
+    if (!reuse) {
+      retVal = std::prev(m_pointerMap.end());
+    }
+    return retVal;
+  }
+
+  /**
+   * Returns an iterator to the node that stores the information
+   * of the given virtual pointer from the given pointer map structure.
+   * If pointer is not found, throws std::out_of_range.
+   * If the pointer map structure is empty, throws std::out_of_range
+   *
+   * \param pMap the pointerMap_t structure storing all the pointers
+   * \param virtual_pointer_ptr The virtual pointer to obtain the node of
+   * \throws std::out:of_range if the pointer is not found or pMap is empty
+   */
+  typename pointerMap_t::iterator get_node(const virtual_pointer_t ptr) {
+    if (this->count() == 0) {
+      m_pointerMap.clear();
+      EIGEN_THROW_X(std::out_of_range("There are no pointers allocated\n"));
+
+    }
+    if (is_nullptr(ptr)) {
+      m_pointerMap.clear();
+      EIGEN_THROW_X(std::out_of_range("Cannot access null pointer\n"));
+    }
+    // The previous element to the lower bound is the node that
+    // holds this memory address
+    auto node = m_pointerMap.lower_bound(ptr);
+    // If the value of the pointer is not the one of the node
+    // then we return the previous one
+    if (node == std::end(m_pointerMap)) {
+      --node;
+    } else if (node->first != ptr) {
+      if (node == std::begin(m_pointerMap)) {
+        m_pointerMap.clear();
+        EIGEN_THROW_X(
+            std::out_of_range("The pointer is not registered in the map\n"));
+
+      }
+      --node;
+    }
+
+    return node;
+  }
+
+  /* get_buffer.
+   * Returns a buffer from the map using the pointer address
+   */
+  template <typename buffer_data_type = buffer_data_type_t>
+  cl::sycl::buffer<buffer_data_type, 1> get_buffer(
+      const virtual_pointer_t ptr) {
+    using sycl_buffer_t = cl::sycl::buffer<buffer_data_type, 1>;
+
+    // get_node() returns a `buffer_mem`, so we need to cast it to a `buffer<>`.
+    // We can do this without the `buffer_mem` being a pointer, as we
+    // only declare member variables in the base class (`buffer_mem`) and not in
+    // the child class (`buffer<>).
+    auto node = get_node(ptr);
+    eigen_assert(node->first == ptr || node->first < ptr);
+    eigen_assert(ptr < static_cast<virtual_pointer_t>(node->second.m_size +
+                                                      node->first));
+    return *(static_cast<sycl_buffer_t *>(&node->second.m_buffer));
+  }
+
+  /**
+   * @brief Returns an accessor to the buffer of the given virtual pointer
+   * @param accessMode
+   * @param accessTarget
+   * @param ptr The virtual pointer
+   */
+  template <sycl_acc_mode access_mode = default_acc_mode,
+            sycl_acc_target access_target = default_acc_target,
+            typename buffer_data_type = buffer_data_type_t>
+  cl::sycl::accessor<buffer_data_type, 1, access_mode, access_target>
+  get_access(const virtual_pointer_t ptr) {
+    auto buf = get_buffer<buffer_data_type>(ptr);
+    return buf.template get_access<access_mode, access_target>();
+  }
+
+  /**
+   * @brief Returns an accessor to the buffer of the given virtual pointer
+   *        in the given command group scope
+   * @param accessMode
+   * @param accessTarget
+   * @param ptr The virtual pointer
+   * @param cgh Reference to the command group scope
+   */
+  template <sycl_acc_mode access_mode = default_acc_mode,
+            sycl_acc_target access_target = default_acc_target,
+            typename buffer_data_type = buffer_data_type_t>
+  cl::sycl::accessor<buffer_data_type, 1, access_mode, access_target>
+  get_access(const virtual_pointer_t ptr, cl::sycl::handler &cgh) {
+    auto buf = get_buffer<buffer_data_type>(ptr);
+    return buf.template get_access<access_mode, access_target>(cgh);
+  }
+
+  /*
+   * Returns the offset from the base address of this pointer.
+   */
+  inline std::ptrdiff_t get_offset(const virtual_pointer_t ptr) {
+    // The previous element to the lower bound is the node that
+    // holds this memory address
+    auto node = get_node(ptr);
+    auto start = node->first;
+    eigen_assert(start == ptr || start < ptr);
+    eigen_assert(ptr < start + node->second.m_size);
+    return (ptr - start);
+  }
+
+  /*
+   * Returns the number of elements by which the given pointer is offset from
+   * the base address.
+   */
+  template <typename buffer_data_type>
+  inline size_t get_element_offset(const virtual_pointer_t ptr) {
+    return get_offset(ptr) / sizeof(buffer_data_type);
+  }
+
+  /**
+   * Constructs the PointerMapper structure.
+   */
+  PointerMapper(base_ptr_t baseAddress = 4096)
+      : m_pointerMap{}, m_freeList{}, m_baseAddress{baseAddress} {
+    if (m_baseAddress == 0) {
+      EIGEN_THROW_X(std::invalid_argument("Base address cannot be zero\n"));
+    }
+  };
+
+  /**
+   * PointerMapper cannot be copied or moved
+   */
+  PointerMapper(const PointerMapper &) = delete;
+
+  /**
+   * Empty the pointer list
+   */
+  inline void clear() {
+    m_freeList.clear();
+    m_pointerMap.clear();
+  }
+
+  /* add_pointer.
+   * Adds an existing pointer to the map and returns the virtual pointer id.
+   */
+  inline virtual_pointer_t add_pointer(const buffer_t &b) {
+    return add_pointer_impl(b);
+  }
+
+  /* add_pointer.
+   * Adds a pointer to the map and returns the virtual pointer id.
+   */
+  inline virtual_pointer_t add_pointer(buffer_t &&b) {
+    return add_pointer_impl(b);
+  }
+
+  /**
+   * @brief Fuses the given node with the previous nodes in the
+   *        pointer map if they are free
+   *
+   * @param node A reference to the free node to be fused
+   */
+  void fuse_forward(typename pointerMap_t::iterator &node) {
+    while (node != std::prev(m_pointerMap.end())) {
+      // if following node is free
+      // remove it and extend the current node with its size
+      auto fwd_node = std::next(node);
+      if (!fwd_node->second.m_free) {
+        break;
+      }
+      auto fwd_size = fwd_node->second.m_size;
+      m_freeList.erase(fwd_node);
+      m_pointerMap.erase(fwd_node);
+
+      node->second.m_size += fwd_size;
+    }
+  }
+
+  /**
+   * @brief Fuses the given node with the following nodes in the
+   *        pointer map if they are free
+   *
+   * @param node A reference to the free node to be fused
+   */
+  void fuse_backward(typename pointerMap_t::iterator &node) {
+    while (node != m_pointerMap.begin()) {
+      // if previous node is free, extend it
+      // with the size of the current one
+      auto prev_node = std::prev(node);
+      if (!prev_node->second.m_free) {
+        break;
+      }
+      prev_node->second.m_size += node->second.m_size;
+
+      // remove the current node
+      m_freeList.erase(node);
+      m_pointerMap.erase(node);
+
+      // point to the previous node
+      node = prev_node;
+    }
+  }
+
+  /* remove_pointer.
+   * Removes the given pointer from the map.
+   * The pointer is allowed to be reused only if ReUse if true.
+   */
+  template <bool ReUse = true>
+  void remove_pointer(const virtual_pointer_t ptr) {
+    if (is_nullptr(ptr)) {
+      return;
+    }
+    auto node = this->get_node(ptr);
+
+    node->second.m_free = true;
+    m_freeList.emplace(node);
+
+    // Fuse the node
+    // with free nodes before and after it
+    fuse_forward(node);
+    fuse_backward(node);
+
+    // If after fusing the node is the last one
+    // simply remove it (since it is free)
+    if (node == std::prev(m_pointerMap.end())) {
+      m_freeList.erase(node);
+      m_pointerMap.erase(node);
+    }
+  }
+
+  /* count.
+   * Return the number of active pointers (i.e, pointers that
+   * have been malloc but not freed).
+   */
+  size_t count() const { return (m_pointerMap.size() - m_freeList.size()); }
+
+ private:
+  /* add_pointer_impl.
+   * Adds a pointer to the map and returns the virtual pointer id.
+   * BufferT is either a const buffer_t& or a buffer_t&&.
+   */
+  template <class BufferT>
+  virtual_pointer_t add_pointer_impl(BufferT b) {
+    virtual_pointer_t retVal = nullptr;
+    size_t bufSize = b.get_count();
+    pMapNode_t p{b, bufSize, false};
+    // If this is the first pointer:
+    if (m_pointerMap.empty()) {
+      virtual_pointer_t initialVal{m_baseAddress};
+      m_pointerMap.emplace(initialVal, p);
+      return initialVal;
+    }
+
+    auto lastElemIter = get_insertion_point(bufSize);
+    // We are recovering an existing free node
+    if (lastElemIter->second.m_free) {
+      lastElemIter->second.m_buffer = b;
+      lastElemIter->second.m_free = false;
+
+      // If the recovered node is bigger than the inserted one
+      // add a new free node with the remaining space
+      if (lastElemIter->second.m_size > bufSize) {
+        // create a new node with the remaining space
+        auto remainingSize = lastElemIter->second.m_size - bufSize;
+        pMapNode_t p2{b, remainingSize, true};
+
+        // update size of the current node
+        lastElemIter->second.m_size = bufSize;
+
+        // add the new free node
+        auto newFreePtr = lastElemIter->first + bufSize;
+        auto freeNode = m_pointerMap.emplace(newFreePtr, p2).first;
+        m_freeList.emplace(freeNode);
+      }
+
+      retVal = lastElemIter->first;
+    } else {
+      size_t lastSize = lastElemIter->second.m_size;
+      retVal = lastElemIter->first + lastSize;
+      m_pointerMap.emplace(retVal, p);
+    }
+    return retVal;
+  }
+
+  /**
+   * Compare two iterators to pointer map entries according to
+   * the size of the allocation on the device.
+   */
+  struct SortBySize {
+    bool operator()(typename pointerMap_t::iterator a,
+                    typename pointerMap_t::iterator b) const {
+      return ((a->first < b->first) && (a->second <= b->second)) ||
+             ((a->first < b->first) && (b->second <= a->second));
+    }
+  };
+
+  /* Maps the pointer addresses to buffer and size pairs.
+   */
+  pointerMap_t m_pointerMap;
+
+  /* List of free nodes available for re-using
+   */
+  std::set<typename pointerMap_t::iterator, SortBySize> m_freeList;
+
+  /* Base address used when issuing the first virtual pointer, allows users
+   * to specify alignment. Cannot be zero. */
+  std::intptr_t m_baseAddress;
+};
+
+/* remove_pointer.
+ * Removes the given pointer from the map.
+ * The pointer is allowed to be reused only if ReUse if true.
+ */
+template <>
+inline void PointerMapper::remove_pointer<false>(const virtual_pointer_t ptr) {
+  if (is_nullptr(ptr)) {
+    return;
+  }
+  m_pointerMap.erase(this->get_node(ptr));
+}
+
+/**
+ * Malloc-like interface to the pointer-mapper.
+ * Given a size, creates a byte-typed buffer and returns a
+ * fake pointer to keep track of it.
+ * \param size Size in bytes of the desired allocation
+ * \throw cl::sycl::exception if error while creating the buffer
+ */
+inline void *SYCLmalloc(size_t size, PointerMapper &pMap) {
+  if (size == 0) {
+    return nullptr;
+  }
+  // Create a generic buffer of the given size
+  using buffer_t = cl::sycl::buffer<buffer_data_type_t, 1>;
+  auto thePointer = pMap.add_pointer(buffer_t(cl::sycl::range<1>{size}));
+  // Store the buffer on the global list
+  return static_cast<void *>(thePointer);
+}
+
+/**
+ * Free-like interface to the pointer mapper.
+ * Given a fake-pointer created with the virtual-pointer malloc,
+ * destroys the buffer and remove it from the list.
+ * If ReUse is false, the pointer is not added to the freeList,
+ * it should be false only for sub-buffers.
+ */
+template <bool ReUse = true, typename PointerMapper>
+inline void SYCLfree(void *ptr, PointerMapper &pMap) {
+  pMap.template remove_pointer<ReUse>(ptr);
+}
+
+/**
+ * Clear all the memory allocated by SYCL.
+ */
+template <typename PointerMapper>
+inline void SYCLfreeAll(PointerMapper &pMap) {
+  pMap.clear();
+}
+
+template <cl::sycl::access::mode AcMd, typename T>
+struct RangeAccess {
+  static const auto global_access = cl::sycl::access::target::global_buffer;
+  static const auto is_place_holder = cl::sycl::access::placeholder::true_t;
+  typedef T scalar_t;
+  typedef scalar_t &ref_t;
+  typedef typename cl::sycl::global_ptr<scalar_t>::pointer_t ptr_t;
+
+  // the accessor type does not necessarily the same as T
+  typedef cl::sycl::accessor<scalar_t, 1, AcMd, global_access, is_place_holder>
+      accessor;
+
+  typedef RangeAccess<AcMd, T> self_t;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RangeAccess(accessor access,
+                                                    size_t offset,
+                                                    std::intptr_t virtual_ptr)
+      : access_(access), offset_(offset), virtual_ptr_(virtual_ptr) {}
+
+  RangeAccess(cl::sycl::buffer<scalar_t, 1> buff =
+                  cl::sycl::buffer<scalar_t, 1>(cl::sycl::range<1>(1)))
+      : access_{accessor{buff}}, offset_(0), virtual_ptr_(-1) {}
+
+  // This should be only used for null constructor on the host side
+  RangeAccess(std::nullptr_t) : RangeAccess() {}
+  // This template parameter must be removed and scalar_t should be replaced
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ptr_t get_pointer() const {
+    return (access_.get_pointer().get() + offset_);
+  }
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t &operator+=(Index offset) {
+    offset_ += (offset);
+    return *this;
+  }
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t operator+(Index offset) const {
+    return self_t(access_, offset_ + offset, virtual_ptr_);
+  }
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t operator-(Index offset) const {
+    return self_t(access_, offset_ - offset, virtual_ptr_);
+  }
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t &operator-=(Index offset) {
+    offset_ -= offset;
+    return *this;
+  }
+
+  // THIS IS FOR NULL COMPARISON ONLY
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend bool operator==(
+      const RangeAccess &lhs, std::nullptr_t) {
+    return ((lhs.virtual_ptr_ == -1));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend bool operator!=(
+      const RangeAccess &lhs, std::nullptr_t i) {
+    return !(lhs == i);
+  }
+
+  // THIS IS FOR NULL COMPARISON ONLY
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend bool operator==(
+      std::nullptr_t, const RangeAccess &rhs) {
+    return ((rhs.virtual_ptr_ == -1));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend bool operator!=(
+      std::nullptr_t i, const RangeAccess &rhs) {
+    return !(i == rhs);
+  }
+  // Prefix operator (Increment and return value)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t &operator++() {
+    offset_++;
+    return (*this);
+  }
+
+  // Postfix operator (Return value and increment)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE self_t operator++(int i) {
+    EIGEN_UNUSED_VARIABLE(i);
+    self_t temp_iterator(*this);
+    offset_++;
+    return temp_iterator;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t get_size() const {
+    return (access_.get_count() - offset_);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t get_offset() const {
+    return offset_;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void set_offset(std::ptrdiff_t offset) {
+    offset_ = offset;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ref_t operator*() const {
+    return *get_pointer();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ref_t operator*() {
+    return *get_pointer();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ptr_t operator->() = delete;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ref_t operator[](int x) {
+    return *(get_pointer() + x);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ref_t operator[](int x) const {
+    return *(get_pointer() + x);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_t *get_virtual_pointer() const {
+    return reinterpret_cast<scalar_t *>(virtual_ptr_ +
+                                        (offset_ * sizeof(scalar_t)));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit operator bool() const {
+    return (virtual_ptr_ != -1);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE operator RangeAccess<AcMd, const T>() {
+    return RangeAccess<AcMd, const T>(access_, offset_, virtual_ptr_);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  operator RangeAccess<AcMd, const T>() const {
+    return RangeAccess<AcMd, const T>(access_, offset_, virtual_ptr_);
+  }
+  // binding placeholder accessors to a command group handler for SYCL
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void bind(
+      cl::sycl::handler &cgh) const {
+    cgh.require(access_);
+  }
+
+ private:
+  accessor access_;
+  size_t offset_;
+  std::intptr_t virtual_ptr_;  // the location of the buffer in the map
+};
+
+template <cl::sycl::access::mode AcMd, typename T>
+struct RangeAccess<AcMd, const T> : RangeAccess<AcMd, T> {
+  typedef RangeAccess<AcMd, T> Base;
+  using Base::Base;
+};
+
+}  // namespace internal
+}  // namespace TensorSycl
+}  // namespace Eigen
+
+#endif  // EIGEN_CXX11_TENSOR_TENSOR_SYCL_STORAGE_MEMORY_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/TypeCasting.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/TypeCasting.h
new file mode 100644
index 00000000..9208ab21
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/SYCL/TypeCasting.h
@@ -0,0 +1,85 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*****************************************************************
+ * TypeCasting.h
+ *
+ * \brief:
+ *  TypeCasting
+ *
+ *****************************************************************/
+
+#ifndef EIGEN_TYPE_CASTING_SYCL_H
+#define EIGEN_TYPE_CASTING_SYCL_H
+
+namespace Eigen {
+
+namespace internal {
+#ifdef SYCL_DEVICE_ONLY
+template <>
+struct type_casting_traits<float, int> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_int4
+pcast<cl::sycl::cl_float4, cl::sycl::cl_int4>(const cl::sycl::cl_float4& a) {
+  return a
+      .template convert<cl::sycl::cl_int, cl::sycl::rounding_mode::automatic>();
+}
+
+template <>
+struct type_casting_traits<int, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_float4
+pcast<cl::sycl::cl_int4, cl::sycl::cl_float4>(const cl::sycl::cl_int4& a) {
+  return a.template convert<cl::sycl::cl_float,
+                            cl::sycl::rounding_mode::automatic>();
+}
+
+template <>
+struct type_casting_traits<double, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_float4
+pcast<cl::sycl::cl_double2, cl::sycl::cl_float4>(
+    const cl::sycl::cl_double2& a, const cl::sycl::cl_double2& b) {
+  auto a1 = a.template convert<cl::sycl::cl_float,
+                               cl::sycl::rounding_mode::automatic>();
+  auto b1 = b.template convert<cl::sycl::cl_float,
+                               cl::sycl::rounding_mode::automatic>();
+  return cl::sycl::float4(a1.x(), a1.y(), b1.x(), b1.y());
+}
+
+template <>
+struct type_casting_traits<float, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_double2
+pcast<cl::sycl::cl_float4, cl::sycl::cl_double2>(const cl::sycl::cl_float4& a) {
+  // Simply discard the second half of the input
+  return cl::sycl::cl_double2(a.x(), a.y());
+}
+
+#endif
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TYPE_CASTING_SYCL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/ZVector/Complex.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/ZVector/Complex.h
new file mode 100644
index 00000000..0b9b33d9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/ZVector/Complex.h
@@ -0,0 +1,426 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX32_ALTIVEC_H
+#define EIGEN_COMPLEX32_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+static Packet4ui  p4ui_CONJ_XOR = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 }; //vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO);
+#endif
+
+static Packet2ul  p2ul_CONJ_XOR1 = (Packet2ul) vec_sld((Packet4ui) p2d_ZERO_, (Packet4ui) p2l_ZERO, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+static Packet2ul  p2ul_CONJ_XOR2 = (Packet2ul) vec_sld((Packet4ui) p2l_ZERO,  (Packet4ui) p2d_ZERO_, 8);//{ 0x8000000000000000, 0x0000000000000000 };
+
+struct Packet1cd
+{
+  EIGEN_STRONG_INLINE Packet1cd() {}
+  EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {}
+  Packet2d v;
+};
+
+struct Packet2cf
+{
+  EIGEN_STRONG_INLINE Packet2cf() {}
+  EIGEN_STRONG_INLINE explicit Packet2cf(const Packet4f& a) : v(a) {}
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ < 12)
+  union {
+    Packet4f v;
+    Packet1cd cd[2];
+  };
+#else
+  Packet4f v;
+#endif
+};
+
+template<> struct packet_traits<std::complex<float> >  : default_packet_traits
+{
+  typedef Packet2cf type;
+  typedef Packet2cf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 2,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasBlend  = 1,
+    HasSetLinear = 0
+  };
+};
+
+
+template<> struct packet_traits<std::complex<double> >  : default_packet_traits
+{
+  typedef Packet1cd type;
+  typedef Packet1cd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 1,
+    HasHalfPacket = 0,
+
+    HasAdd    = 1,
+    HasSub    = 1,
+    HasMul    = 1,
+    HasDiv    = 1,
+    HasNegate = 1,
+    HasAbs    = 0,
+    HasAbs2   = 0,
+    HasMin    = 0,
+    HasMax    = 0,
+    HasSetLinear = 0
+  };
+};
+
+template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float>  type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet2cf half; };
+template<> struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet1cd half; };
+
+/* Forward declaration */
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel);
+
+/* complex<double> first */
+template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> *   to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); }
+
+template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>&  from)
+{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); }
+
+template<> EIGEN_DEVICE_FUNC inline Packet1cd pgather<std::complex<double>, Packet1cd>(const std::complex<double>* from, Index stride EIGEN_UNUSED)
+{
+  return pload<Packet1cd>(from);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<double>, Packet1cd>(std::complex<double>* to, const Packet1cd& from, Index stride EIGEN_UNUSED)
+{
+  pstore<std::complex<double> >(to, from);
+}
+template<> EIGEN_STRONG_INLINE Packet1cd padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v + b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(a.v - b.v); }
+template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2d(a.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) { return Packet1cd((Packet2d)vec_xor((Packet2d)a.v, (Packet2d)p2ul_CONJ_XOR2)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  Packet2d a_re, a_im, v1, v2;
+
+  // Permute and multiply the real parts of a and b
+  a_re = vec_perm(a.v, a.v, p16uc_PSET64_HI);
+  // Get the imaginary parts of a
+  a_im = vec_perm(a.v, a.v, p16uc_PSET64_LO);
+  // multiply a_re * b
+  v1 = vec_madd(a_re, b.v, p2d_ZERO);
+  // multiply a_im * b and get the conjugate result
+  v2 = vec_madd(a_im, b.v, p2d_ZERO);
+  v2 = (Packet2d) vec_sld((Packet4ui)v2, (Packet4ui)v2, 8);
+  v2 = (Packet2d) vec_xor((Packet2d)v2, (Packet2d) p2ul_CONJ_XOR1);
+
+  return Packet1cd(v1 + v2);
+}
+template<> EIGEN_STRONG_INLINE Packet1cd pand    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_and(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd por     <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_or(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pxor    <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_xor(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet1cd pandnot <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(vec_and(a.v, vec_nor(b.v,b.v))); }
+template<> EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>*     from) {  return pset1<Packet1cd>(*from); }
+template<> EIGEN_STRONG_INLINE Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b) {
+  Packet2d eq = vec_cmpeq (a.v, b.v);
+  Packet2d tmp = { eq[1], eq[0] };
+  return (Packet1cd)pand<Packet2d>(eq, tmp);
+}
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> *   addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE std::complex<double>  pfirst<Packet1cd>(const Packet1cd& a)
+{
+  std::complex<double> EIGEN_ALIGN16 res;
+  pstore<std::complex<double> >(&res, a);
+
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; }
+template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a)
+{
+  return pfirst(a);
+}
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd,Packet2d)
+
+template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
+{
+  // TODO optimize it for AltiVec
+  Packet1cd res = pmul(a,pconj(b));
+  Packet2d s = vec_madd(b.v, b.v, p2d_ZERO_);
+  return Packet1cd(pdiv(res.v, s + vec_perm(s, s, p16uc_REVERSE64)));
+}
+
+EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
+{
+  return Packet1cd(preverse(Packet2d(x.v)));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet1cd,2>& kernel)
+{
+  Packet2d tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+
+/* complex<float> follows */
+template<> EIGEN_STRONG_INLINE Packet2cf pload <Packet2cf>(const std::complex<float>* from)  { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from)  { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>((const float*)from)); }
+template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> *     to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); }
+template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> *     to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); }
+
+template<> EIGEN_STRONG_INLINE std::complex<float>  pfirst<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> EIGEN_ALIGN16 res[2];
+  pstore<std::complex<float> >(res, a);
+
+  return res[0];
+}
+
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ < 12)
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+  res.cd[0] = Packet1cd(vec_ld2f((const float *)&from));
+  res.cd[1] = res.cd[0];
+  return res;
+}
+#else
+template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>&  from)
+{
+  Packet2cf res;
+  if((std::ptrdiff_t(&from) % 16) == 0)
+    res.v = pload<Packet4f>((const float *)&from);
+  else
+    res.v = ploadu<Packet4f>((const float *)&from);
+  res.v = vec_perm(res.v, res.v, p16uc_PSET64_HI);
+  return res;
+}
+#endif
+
+template<> EIGEN_DEVICE_FUNC inline Packet2cf pgather<std::complex<float>, Packet2cf>(const std::complex<float>* from, Index stride)
+{
+  std::complex<float> EIGEN_ALIGN16 af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+  return pload<Packet2cf>(af);
+}
+template<> EIGEN_DEVICE_FUNC inline void pscatter<std::complex<float>, Packet2cf>(std::complex<float>* to, const Packet2cf& from, Index stride)
+{
+  std::complex<float> EIGEN_ALIGN16 af[2];
+  pstore<std::complex<float> >((std::complex<float> *) af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(padd<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(psub<Packet4f>(a.v, b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(Packet4f(a.v))); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf pand   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pand<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf por    <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(por<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pxor   <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pxor<Packet4f>(a.v,b.v)); }
+template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(pandnot<Packet4f>(a.v,b.v)); }
+
+template<> EIGEN_STRONG_INLINE Packet2cf ploaddup<Packet2cf>(const std::complex<float>*      from) {  return pset1<Packet2cf>(*from); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> *     addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ < 12)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b) {
+  Packet4f eq = pcmp_eq<Packet4f> (a.v, b.v);
+  Packet2cf res;
+  Packet2d tmp1 = { eq.v4f[0][1], eq.v4f[0][0] };
+  Packet2d tmp2 = { eq.v4f[1][1], eq.v4f[1][0] };
+  res.v.v4f[0] = pand<Packet2d>(eq.v4f[0], tmp1);
+  res.v.v4f[1] = pand<Packet2d>(eq.v4f[1], tmp2);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a)
+{
+  Packet2cf res;
+  res.v.v4f[0] = pconj(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[0]))).v;
+  res.v.v4f[1] = pconj(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[1]))).v;
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  Packet2cf res;
+  res.v.v4f[0] = pmul(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[0])), Packet1cd(reinterpret_cast<Packet2d>(b.v.v4f[0]))).v;
+  res.v.v4f[1] = pmul(Packet1cd(reinterpret_cast<Packet2d>(a.v.v4f[1])), Packet1cd(reinterpret_cast<Packet2d>(b.v.v4f[1]))).v;
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{
+  Packet2cf res;
+  res.cd[0] = a.cd[1];
+  res.cd[1] = a.cd[0];
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> res;
+  Packet1cd b = padd<Packet1cd>(a.cd[0], a.cd[1]);
+  vec_st2f(b.v, (float*)&res);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  std::complex<float> res;
+  Packet1cd b = pmul<Packet1cd>(a.cd[0], a.cd[1]);
+  vec_st2f(b.v, (float*)&res);
+  return res;
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for AltiVec
+  Packet2cf res;
+  res.cd[0] = pdiv<Packet1cd>(a.cd[0], b.cd[0]);
+  res.cd[1] = pdiv<Packet1cd>(a.cd[1], b.cd[1]);
+  return res;
+}
+
+EIGEN_STRONG_INLINE Packet2cf pcplxflip/*<Packet2cf>*/(const Packet2cf& x)
+{
+  Packet2cf res;
+  res.cd[0] = pcplxflip(x.cd[0]);
+  res.cd[1] = pcplxflip(x.cd[1]);
+  return res;
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel)
+{
+  Packet1cd tmp = kernel.packet[0].cd[1];
+  kernel.packet[0].cd[1] = kernel.packet[1].cd[0];
+  kernel.packet[1].cd[0] = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  Packet2cf result;
+  const Selector<4> ifPacket4 = { ifPacket.select[0], ifPacket.select[0], ifPacket.select[1], ifPacket.select[1] };
+  result.v = pblend<Packet4f>(ifPacket4, thenPacket.v, elsePacket.v);
+  return result;
+}
+#else
+template<> EIGEN_STRONG_INLINE Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b) {
+  Packet4f eq = vec_cmpeq (a.v, b.v);
+  Packet4f tmp = { eq[1], eq[0], eq[3], eq[2] };
+  return (Packet2cf)pand<Packet4f>(eq, tmp);
+}
+template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a.v, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR))); }
+template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  Packet4f a_re, a_im, prod, prod_im;
+
+  // Permute and multiply the real parts of a and b
+  a_re = vec_perm(a.v, a.v, p16uc_PSET32_WODD);
+  
+  // Get the imaginary parts of a
+  a_im = vec_perm(a.v, a.v, p16uc_PSET32_WEVEN);
+
+  // multiply a_im * b and get the conjugate result
+  prod_im = a_im * b.v;
+  prod_im = pxor<Packet4f>(prod_im, reinterpret_cast<Packet4f>(p4ui_CONJ_XOR));
+  // permute back to a proper order
+  prod_im = vec_perm(prod_im, prod_im, p16uc_COMPLEX32_REV);
+
+  // multiply a_re * b, add prod_im
+  prod = pmadd<Packet4f>(a_re, b.v, prod_im);
+ 
+  return Packet2cf(prod);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a)
+{
+  Packet4f rev_a;
+  rev_a = vec_perm(a.v, a.v, p16uc_COMPLEX32_REV2);
+  return Packet2cf(rev_a);
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a)
+{
+  Packet4f b;
+  b = vec_sld(a.v, a.v, 8);
+  b = padd<Packet4f>(a.v, b);
+  return pfirst<Packet2cf>(Packet2cf(b));
+}
+
+template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a)
+{
+  Packet4f b;
+  Packet2cf prod;
+  b = vec_sld(a.v, a.v, 8);
+  prod = pmul<Packet2cf>(a, Packet2cf(b));
+
+  return pfirst<Packet2cf>(prod);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2cf,Packet4f)
+
+template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b)
+{
+  // TODO optimize it for AltiVec
+  Packet2cf res = pmul(a, pconj(b));
+  Packet4f s = pmul<Packet4f>(b.v, b.v);
+  return Packet2cf(pdiv(res.v, padd<Packet4f>(s, vec_perm(s, s, p16uc_COMPLEX32_REV))));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& x)
+{
+  return Packet2cf(vec_perm(x.v, x.v, p16uc_COMPLEX32_REV));
+}
+
+EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet2cf,2>& kernel)
+{
+  Packet4f tmp = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_HI);
+  kernel.packet[1].v = vec_perm(kernel.packet[0].v, kernel.packet[1].v, p16uc_TRANSPOSE64_LO);
+  kernel.packet[0].v = tmp;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket, const Packet2cf& elsePacket) {
+  Packet2cf result;
+  result.v = reinterpret_cast<Packet4f>(pblend<Packet2d>(ifPacket, reinterpret_cast<Packet2d>(thenPacket.v), reinterpret_cast<Packet2d>(elsePacket.v)));
+  return result;
+}
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX32_ALTIVEC_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/ZVector/MathFunctions.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/ZVector/MathFunctions.h
new file mode 100644
index 00000000..1635e128
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/ZVector/MathFunctions.h
@@ -0,0 +1,233 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007 Julien Pommier
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* The sin, cos, exp, and log functions of this file come from
+ * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
+ */
+
+#ifndef EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+#define EIGEN_MATH_FUNCTIONS_ALTIVEC_H
+
+namespace Eigen {
+
+namespace internal {
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+static _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
+static _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
+static _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
+static _EIGEN_DECLARE_CONST_Packet4i(23, 23);
+
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(inv_mant_mask, ~0x7f800000);
+
+/* the smallest non denormalized float number */
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(min_norm_pos,  0x00800000);
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(minus_inf,     0xff800000); // -1.f/0.f
+static _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(minus_nan,     0xffffffff);
+  
+/* natural logarithm computed for 4 simultaneous float
+  return NaN for x <= 0
+*/
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_SQRTHF, 0.707106781186547524f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p0, 7.0376836292E-2f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p1, - 1.1514610310E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p2, 1.1676998740E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p3, - 1.2420140846E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p4, + 1.4249322787E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p5, - 1.6668057665E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p6, + 2.0000714765E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p7, - 2.4999993993E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p8, + 3.3333331174E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q1, -2.12194440e-4f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q2, 0.693359375f);
+
+static _EIGEN_DECLARE_CONST_Packet4f(exp_hi,  88.3762626647950f);
+static _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -88.3762626647949f);
+
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f);
+
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500E-4f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507E-3f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073E-3f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894E-2f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459E-1f);
+static _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201E-1f);
+#endif
+
+static _EIGEN_DECLARE_CONST_Packet2d(1 , 1.0);
+static _EIGEN_DECLARE_CONST_Packet2d(2 , 2.0);
+static _EIGEN_DECLARE_CONST_Packet2d(half, 0.5);
+
+static _EIGEN_DECLARE_CONST_Packet2d(exp_hi,  709.437);
+static _EIGEN_DECLARE_CONST_Packet2d(exp_lo, -709.436139303);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_LOG2EF, 1.4426950408889634073599);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p0, 1.26177193074810590878e-4);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p1, 3.02994407707441961300e-2);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_p2, 9.99999999999999999910e-1);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q0, 3.00198505138664455042e-6);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q1, 2.52448340349684104192e-3);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q2, 2.27265548208155028766e-1);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_q3, 2.00000000000000000009e0);
+
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C1, 0.693145751953125);
+static _EIGEN_DECLARE_CONST_Packet2d(cephes_exp_C2, 1.42860682030941723212e-6);
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d pexp<Packet2d>(const Packet2d& _x)
+{
+  Packet2d x = _x;
+
+  Packet2d tmp, fx;
+  Packet2l emm0;
+
+  // clamp x
+  x = pmax(pmin(x, p2d_exp_hi), p2d_exp_lo);
+  /* express exp(x) as exp(g + n*log(2)) */
+  fx = pmadd(p2d_cephes_LOG2EF, x, p2d_half);
+
+  fx = vec_floor(fx);
+
+  tmp = pmul(fx, p2d_cephes_exp_C1);
+  Packet2d z = pmul(fx, p2d_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  Packet2d x2 = pmul(x,x);
+
+  Packet2d px = p2d_cephes_exp_p0;
+  px = pmadd(px, x2, p2d_cephes_exp_p1);
+  px = pmadd(px, x2, p2d_cephes_exp_p2);
+  px = pmul (px, x);
+
+  Packet2d qx = p2d_cephes_exp_q0;
+  qx = pmadd(qx, x2, p2d_cephes_exp_q1);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q2);
+  qx = pmadd(qx, x2, p2d_cephes_exp_q3);
+
+  x = pdiv(px,psub(qx,px));
+  x = pmadd(p2d_2,x,p2d_1);
+
+  // build 2^n
+  emm0 = vec_ctsl(fx, 0);
+
+  static const Packet2l p2l_1023 = { 1023, 1023 };
+  static const Packet2ul p2ul_52 = { 52, 52 };
+
+  emm0 = emm0 + p2l_1023;
+  emm0 = emm0 << reinterpret_cast<Packet2l>(p2ul_52);
+
+  // Altivec's max & min operators just drop silent NaNs. Check NaNs in 
+  // inputs and return them unmodified.
+  Packet2ul isnumber_mask = reinterpret_cast<Packet2ul>(vec_cmpeq(_x, _x));
+  return vec_sel(_x, pmax(pmul(x, reinterpret_cast<Packet2d>(emm0)), _x),
+                 isnumber_mask);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f pexp<Packet4f>(const Packet4f& _x)
+{
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+  Packet4f x = _x;
+
+  Packet4f tmp, fx;
+  Packet4i emm0;
+
+  // clamp x
+  x = pmax(pmin(x, p4f_exp_hi), p4f_exp_lo);
+
+  // express exp(x) as exp(g + n*log(2))
+  fx = pmadd(x, p4f_cephes_LOG2EF, p4f_half);
+
+  fx = pfloor(fx);
+
+  tmp = pmul(fx, p4f_cephes_exp_C1);
+  Packet4f z = pmul(fx, p4f_cephes_exp_C2);
+  x = psub(x, tmp);
+  x = psub(x, z);
+
+  z = pmul(x,x);
+
+  Packet4f y = p4f_cephes_exp_p0;
+  y = pmadd(y, x, p4f_cephes_exp_p1);
+  y = pmadd(y, x, p4f_cephes_exp_p2);
+  y = pmadd(y, x, p4f_cephes_exp_p3);
+  y = pmadd(y, x, p4f_cephes_exp_p4);
+  y = pmadd(y, x, p4f_cephes_exp_p5);
+  y = pmadd(y, z, x);
+  y = padd(y, p4f_1);
+
+  // build 2^n
+  emm0 = (Packet4i){ (int)fx[0], (int)fx[1], (int)fx[2], (int)fx[3] };
+  emm0 = emm0 + p4i_0x7f;
+  emm0 = emm0 << reinterpret_cast<Packet4i>(p4i_23);
+
+  return pmax(pmul(y, reinterpret_cast<Packet4f>(emm0)), _x);
+#else
+  Packet4f res;
+  res.v4f[0] = pexp<Packet2d>(_x.v4f[0]);
+  res.v4f[1] = pexp<Packet2d>(_x.v4f[1]);
+  return res;
+#endif
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d psqrt<Packet2d>(const Packet2d& x)
+{
+  return vec_sqrt(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f psqrt<Packet4f>(const Packet4f& x)
+{
+  Packet4f res;
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+  res = vec_sqrt(x);
+#else
+  res.v4f[0] = psqrt<Packet2d>(x.v4f[0]);
+  res.v4f[1] = psqrt<Packet2d>(x.v4f[1]);
+#endif
+  return res;
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet2d prsqrt<Packet2d>(const Packet2d& x) {
+  return pset1<Packet2d>(1.0) / psqrt<Packet2d>(x);
+}
+
+template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
+Packet4f prsqrt<Packet4f>(const Packet4f& x) {
+  Packet4f res;
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+  res = pset1<Packet4f>(1.0) / psqrt<Packet4f>(x);
+#else
+  res.v4f[0] = prsqrt<Packet2d>(x.v4f[0]);
+  res.v4f[1] = prsqrt<Packet2d>(x.v4f[1]);
+#endif
+  return res;
+}
+
+// Hyperbolic Tangent function.
+template <>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED Packet4f
+ptanh<Packet4f>(const Packet4f& x) {
+  return internal::generic_fast_tanh_float(x);
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATH_FUNCTIONS_ALTIVEC_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/ZVector/PacketMath.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/ZVector/PacketMath.h
new file mode 100644
index 00000000..1f55a90a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/arch/ZVector/PacketMath.h
@@ -0,0 +1,1060 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Konstantinos Margaritis <markos@freevec.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PACKET_MATH_ZVECTOR_H
+#define EIGEN_PACKET_MATH_ZVECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 16
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS  32
+#endif
+
+typedef __vector int                 Packet4i;
+typedef __vector unsigned int        Packet4ui;
+typedef __vector __bool int          Packet4bi;
+typedef __vector short int           Packet8i;
+typedef __vector unsigned char       Packet16uc;
+typedef __vector double              Packet2d;
+typedef __vector unsigned long long  Packet2ul;
+typedef __vector long long           Packet2l;
+
+// Z14 has builtin support for float vectors
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+typedef __vector float               Packet4f;
+#else
+typedef struct {
+	Packet2d  v4f[2];
+} Packet4f;
+#endif
+
+typedef union {
+  numext::int32_t   i[4];
+  numext::uint32_t ui[4];
+  numext::int64_t   l[2];
+  numext::uint64_t ul[2];
+  double    d[2];
+  float     f[4];
+  Packet4i  v4i;
+  Packet4ui v4ui;
+  Packet2l  v2l;
+  Packet2ul v2ul;
+  Packet2d  v2d;
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+  Packet4f  v4f;
+#endif
+} Packet;
+
+// We don't want to write the same code all the time, but we need to reuse the constants
+// and it doesn't really work to declare them global, so we define macros instead
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = reinterpret_cast<Packet4i>(vec_splat_s32(X))
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet2d(NAME,X) \
+  Packet2d p2d_##NAME = reinterpret_cast<Packet2d>(vec_splat_s64(X))
+
+#define _EIGEN_DECLARE_CONST_FAST_Packet2l(NAME,X) \
+  Packet2l p2l_##NAME = reinterpret_cast<Packet2l>(vec_splat_s64(X))
+
+#define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \
+  Packet4i p4i_##NAME = pset1<Packet4i>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2d(NAME,X) \
+  Packet2d p2d_##NAME = pset1<Packet2d>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet2l(NAME,X) \
+  Packet2l p2l_##NAME = pset1<Packet2l>(X)
+
+// These constants are endian-agnostic
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ZERO, 0); //{ 0, 0, 0, 0,}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(ONE, 1); //{ 1, 1, 1, 1}
+
+static _EIGEN_DECLARE_CONST_FAST_Packet2d(ZERO, 0);
+static _EIGEN_DECLARE_CONST_FAST_Packet2l(ZERO, 0);
+static _EIGEN_DECLARE_CONST_FAST_Packet2l(ONE, 1);
+
+static Packet2d p2d_ONE = { 1.0, 1.0 };
+static Packet2d p2d_ZERO_ = { numext::bit_cast<double>0x8000000000000000ull),
+                              numext::bit_cast<double>0x8000000000000000ull) };
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+#define _EIGEN_DECLARE_CONST_FAST_Packet4f(NAME,X) \
+  Packet4f p4f_##NAME = reinterpret_cast<Packet4f>(vec_splat_s32(X))
+
+#define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \
+  Packet4f p4f_##NAME = pset1<Packet4f>(X)
+
+#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \
+  const Packet4f p4f_##NAME = reinterpret_cast<Packet4f>(pset1<Packet4i>(X))
+
+static _EIGEN_DECLARE_CONST_FAST_Packet4f(ZERO, 0); //{ 0.0, 0.0, 0.0, 0.0}
+static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS1,-1); //{ -1, -1, -1, -1}
+static Packet4f p4f_MZERO = { 0x80000000, 0x80000000, 0x80000000, 0x80000000};
+#endif
+
+static Packet4i p4i_COUNTDOWN = { 0, 1, 2, 3 };
+static Packet4f p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 };
+static Packet2d p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet16uc>(p2d_ZERO), reinterpret_cast<Packet16uc>(p2d_ONE), 8));
+
+static Packet16uc p16uc_PSET64_HI = { 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 };
+static Packet16uc p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 };
+
+// Mask alignment
+#define _EIGEN_MASK_ALIGNMENT	0xfffffffffffffff0
+
+#define _EIGEN_ALIGNED_PTR(x)	((std::ptrdiff_t)(x) & _EIGEN_MASK_ALIGNMENT)
+
+// Handle endianness properly while loading constants
+// Define global static constants:
+
+static Packet16uc p16uc_FORWARD =   { 0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15 };
+static Packet16uc p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 };
+static Packet16uc p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+
+static Packet16uc p16uc_PSET32_WODD   = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
+static Packet16uc p16uc_PSET32_WEVEN  = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 };
+/*static Packet16uc p16uc_HALF64_0_16 = vec_sld((Packet16uc)p4i_ZERO, vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 3), 8);      //{ 0,0,0,0, 0,0,0,0, 16,16,16,16, 16,16,16,16};
+
+static Packet16uc p16uc_PSET64_HI = (Packet16uc) vec_mergeh((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 };*/
+static Packet16uc p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);     //{ 8,9,10,11, 12,13,14,15, 8,9,10,11, 12,13,14,15 };
+/*static Packet16uc p16uc_TRANSPOSE64_HI = vec_add(p16uc_PSET64_HI, p16uc_HALF64_0_16);                                         //{ 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23};
+static Packet16uc p16uc_TRANSPOSE64_LO = vec_add(p16uc_PSET64_LO, p16uc_HALF64_0_16);                                         //{ 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31};*/
+static Packet16uc p16uc_TRANSPOSE64_HI = { 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23};
+static Packet16uc p16uc_TRANSPOSE64_LO = { 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31};
+
+static Packet16uc p16uc_COMPLEX32_REV = vec_sld(p16uc_REVERSE32, p16uc_REVERSE32, 8);                                         //{ 4,5,6,7, 0,1,2,3, 12,13,14,15, 8,9,10,11 };
+
+static Packet16uc p16uc_COMPLEX32_REV2 = vec_sld(p16uc_FORWARD, p16uc_FORWARD, 8);                                            //{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 };
+
+
+#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  #define EIGEN_ZVECTOR_PREFETCH(ADDR) __builtin_prefetch(ADDR);
+#else
+  #define EIGEN_ZVECTOR_PREFETCH(ADDR) asm( "   pfd [%[addr]]\n" :: [addr] "r" (ADDR) : "cc" );
+#endif
+
+template<> struct packet_traits<int>    : default_packet_traits
+{
+  typedef Packet4i type;
+  typedef Packet4i half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasBlend = 1
+  };
+};
+
+template <>
+struct packet_traits<float> : default_packet_traits {
+  typedef Packet4f type;
+  typedef Packet4f half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = 4,
+    HasHalfPacket = 0,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasAbs = 1,
+    HasSin = 0,
+    HasCos = 0,
+    HasLog = 0,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasTanh = 1,
+    HasErf = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct packet_traits<double> : default_packet_traits
+{
+  typedef Packet2d type;
+  typedef Packet2d half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size=2,
+    HasHalfPacket = 1,
+
+    HasAdd  = 1,
+    HasSub  = 1,
+    HasMul  = 1,
+    HasDiv  = 1,
+    HasMin  = 1,
+    HasMax  = 1,
+    HasAbs  = 1,
+    HasSin  = 0,
+    HasCos  = 0,
+    HasLog  = 0,
+    HasExp  = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasRound = 1,
+    HasFloor = 1,
+    HasCeil = 1,
+    HasNegate = 1,
+    HasBlend = 1
+  };
+};
+
+template<> struct unpacket_traits<Packet4i> { typedef int    type; enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet4i half; };
+template<> struct unpacket_traits<Packet4f> { typedef float  type; enum {size=4, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet4f half; };
+template<> struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, alignment=Aligned16, vectorizable=true, masked_load_available=false, masked_store_available=false}; typedef Packet2d half; };
+
+/* Forward declaration */
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet4f,4>& kernel);
+ 
+inline std::ostream & operator <<(std::ostream & s, const Packet4i & v)
+{
+  Packet vt;
+  vt.v4i = v;
+  s << vt.i[0] << ", " << vt.i[1] << ", " << vt.i[2] << ", " << vt.i[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet4ui & v)
+{
+  Packet vt;
+  vt.v4ui = v;
+  s << vt.ui[0] << ", " << vt.ui[1] << ", " << vt.ui[2] << ", " << vt.ui[3];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2l & v)
+{
+  Packet vt;
+  vt.v2l = v;
+  s << vt.l[0] << ", " << vt.l[1];
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2ul & v)
+{
+  Packet vt;
+  vt.v2ul = v;
+  s << vt.ul[0] << ", " << vt.ul[1] ;
+  return s;
+}
+
+inline std::ostream & operator <<(std::ostream & s, const Packet2d & v)
+{
+  Packet vt;
+  vt.v2d = v;
+  s << vt.d[0] << ", " << vt.d[1];
+  return s;
+}
+
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
+inline std::ostream & operator <<(std::ostream & s, const Packet4f & v)
+{
+  Packet vt;
+  vt.v4f = v;
+  s << vt.f[0] << ", " << vt.f[1] << ", " << vt.f[2] << ", " << vt.f[3];
+  return s;
+}
+#endif
+
+template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int*     from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet *vfrom;
+  vfrom = (Packet *) from;
+  return vfrom->v4i;
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet *vfrom;
+  vfrom = (Packet *) from;
+  return vfrom->v2d;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<int>(int*       to, const Packet4i& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  Packet *vto;
+  vto = (Packet *) to;
+  vto->v4i = from;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<double>(double*   to, const Packet2d& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  Packet *vto;
+  vto = (Packet *) to;
+  vto->v2d = from;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int&    from)
+{
+  return vec_splats(from);
+}
+template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) {
+  return vec_splats(from);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4i>(const int *a,
+                      Packet4i& a0, Packet4i& a1, Packet4i& a2, Packet4i& a3)
+{
+  a3 = pload<Packet4i>(a);
+  a0 = vec_splat(a3, 0);
+  a1 = vec_splat(a3, 1);
+  a2 = vec_splat(a3, 2);
+  a3 = vec_splat(a3, 3);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet2d>(const double *a,
+                      Packet2d& a0, Packet2d& a1, Packet2d& a2, Packet2d& a3)
+{
+  a1 = pload<Packet2d>(a);
+  a0 = vec_splat(a1, 0);
+  a1 = vec_splat(a1, 1);
+  a3 = pload<Packet2d>(a+2);
+  a2 = vec_splat(a3, 0);
+  a3 = vec_splat(a3, 1);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4i pgather<int, Packet4i>(const int* from, Index stride)
+{
+  int EIGEN_ALIGN16 ai[4];
+  ai[0] = from[0*stride];
+  ai[1] = from[1*stride];
+  ai[2] = from[2*stride];
+  ai[3] = from[3*stride];
+ return pload<Packet4i>(ai);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet2d pgather<double, Packet2d>(const double* from, Index stride)
+{
+  double EIGEN_ALIGN16 af[2];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+ return pload<Packet2d>(af);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<int, Packet4i>(int* to, const Packet4i& from, Index stride)
+{
+  int EIGEN_ALIGN16 ai[4];
+  pstore<int>((int *)ai, from);
+  to[0*stride] = ai[0];
+  to[1*stride] = ai[1];
+  to[2*stride] = ai[2];
+  to[3*stride] = ai[3];
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<double, Packet2d>(double* to, const Packet2d& from, Index stride)
+{
+  double EIGEN_ALIGN16 af[2];
+  pstore<double>(af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a + b); }
+template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a + b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a - b); }
+template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a - b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a * b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a * b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& a, const Packet4i& b) { return (a / b); }
+template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return (a / b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return (-a); }
+template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) { return (-a); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) { return a; }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd<Packet4i>(pmul<Packet4i>(a, b), c); }
+template<> EIGEN_STRONG_INLINE Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) { return vec_madd(a, b, c); }
+
+template<> EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(const int& a)    { return padd<Packet4i>(pset1<Packet4i>(a), p4i_COUNTDOWN); }
+template<> EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(const double& a) { return padd<Packet2d>(pset1<Packet2d>(a), p2d_COUNTDOWN); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_min(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_max(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_or(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_xor(a, b); }
+
+template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return pand<Packet4i>(a, vec_nor(b, b)); }
+template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return vec_and(a, vec_nor(b, b)); }
+
+template<> EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(const Packet2d& a) { return vec_round(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(const  Packet2d& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) { return vec_floor(a); }
+
+template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int*       from) { return pload<Packet4i>(from); }
+template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double*    from) { return pload<Packet2d>(from); }
+
+
+template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int*     from)
+{
+  Packet4i p = pload<Packet4i>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double*   from)
+{
+  Packet2d p = pload<Packet2d>(from);
+  return vec_perm(p, p, p16uc_PSET64_HI);
+}
+
+template<> EIGEN_STRONG_INLINE void pstoreu<int>(int*        to, const Packet4i& from) { pstore<int>(to, from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<double>(double*  to, const Packet2d& from) { pstore<double>(to, from); }
+
+template<> EIGEN_STRONG_INLINE void prefetch<int>(const int*       addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+
+template<> EIGEN_STRONG_INLINE int    pfirst<Packet4i>(const Packet4i& a) { int    EIGEN_ALIGN16 x[4]; pstore(x, a); return x[0]; }
+template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { double EIGEN_ALIGN16 x[2]; pstore(x, a); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a)
+{
+  return reinterpret_cast<Packet4i>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
+}
+
+template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a)
+{
+  return reinterpret_cast<Packet2d>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE64));
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pabs<Packet4i>(const Packet4i& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE Packet2d pabs<Packet2d>(const Packet2d& a) { return vec_abs(a); }
+
+template<> EIGEN_STRONG_INLINE int predux<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, sum;
+  b   = vec_sld(a, a, 8);
+  sum = padd<Packet4i>(a, b);
+  b   = vec_sld(sum, sum, 4);
+  sum = padd<Packet4i>(sum, b);
+  return pfirst(sum);
+}
+
+template<> EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a)
+{
+  Packet2d b, sum;
+  b   = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8));
+  sum = padd<Packet2d>(a, b);
+  return pfirst(sum);
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(const Packet4i& a)
+{
+  EIGEN_ALIGN16 int aux[4];
+  pstore(aux, a);
+  return aux[0] * aux[1] * aux[2] * aux[3];
+}
+
+template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmul(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
+}
+
+// min
+template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, res;
+  b   = pmin<Packet4i>(a, vec_sld(a, a, 8));
+  res = pmin<Packet4i>(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmin<Packet2d>(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
+}
+
+// max
+template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(const Packet4i& a)
+{
+  Packet4i b, res;
+  b = pmax<Packet4i>(a, vec_sld(a, a, 8));
+  res = pmax<Packet4i>(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+// max
+template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(const Packet2d& a)
+{
+  return pfirst(pmax<Packet2d>(a, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(a), reinterpret_cast<Packet4i>(a), 8))));
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4i,4>& kernel) {
+  Packet4i t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  Packet4i t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  Packet4i t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  Packet4i t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet2d,2>& kernel) {
+  Packet2d t0 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_HI);
+  Packet2d t1 = vec_perm(kernel.packet[0], kernel.packet[1], p16uc_TRANSPOSE64_LO);
+  kernel.packet[0] = t0;
+  kernel.packet[1] = t1;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket, const Packet4i& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
+  Packet4ui mask = vec_cmpeq(select, reinterpret_cast<Packet4ui>(p4i_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+
+template<> EIGEN_STRONG_INLINE Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket, const Packet2d& elsePacket) {
+  Packet2ul select = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2ul mask = vec_cmpeq(select, reinterpret_cast<Packet2ul>(p2l_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+/* z13 has no vector float support so we emulate that with double
+   z14 has proper vector float support.
+*/
+#if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ < 12)
+/* Helper function to simulate a vec_splat_packet4f
+ */
+template<int element> EIGEN_STRONG_INLINE Packet4f vec_splat_packet4f(const Packet4f&   from)
+{
+  Packet4f splat;
+  switch (element) {
+  case 0:
+    splat.v4f[0] = vec_splat(from.v4f[0], 0);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  case 1:
+    splat.v4f[0] = vec_splat(from.v4f[0], 1);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  case 2:
+    splat.v4f[0] = vec_splat(from.v4f[1], 0);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  case 3:
+    splat.v4f[0] = vec_splat(from.v4f[1], 1);
+    splat.v4f[1] = splat.v4f[0];
+    break;
+  }
+  return splat;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float*   from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet4f vfrom;
+  vfrom.v4f[0] = vec_ld2f(&from[0]);
+  vfrom.v4f[1] = vec_ld2f(&from[2]);
+  return vfrom;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float*   to, const Packet4f& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  vec_st2f(from.v4f[0], &to[0]);
+  vec_st2f(from.v4f[1], &to[2]);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float&    from)
+{
+  Packet4f to;
+  to.v4f[0] = pset1<Packet2d>(static_cast<const double&>(from));
+  to.v4f[1] = to.v4f[0];
+  return to;
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  a3 = pload<Packet4f>(a);
+  a0 = vec_splat_packet4f<0>(a3);
+  a1 = vec_splat_packet4f<1>(a3);
+  a2 = vec_splat_packet4f<2>(a3);
+  a3 = vec_splat_packet4f<3>(a3);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  float EIGEN_ALIGN16 ai[4];
+  ai[0] = from[0*stride];
+  ai[1] = from[1*stride];
+  ai[2] = from[2*stride];
+  ai[3] = from[3*stride];
+ return pload<Packet4f>(ai);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  float EIGEN_ALIGN16 ai[4];
+  pstore<float>((float *)ai, from);
+  to[0*stride] = ai[0];
+  to[1*stride] = ai[1];
+  to[2*stride] = ai[2];
+  to[3*stride] = ai[3];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] + b.v4f[0];
+  c.v4f[1] = a.v4f[1] + b.v4f[1];
+  return c;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] - b.v4f[0];
+  c.v4f[1] = a.v4f[1] - b.v4f[1];
+  return c;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] * b.v4f[0];
+  c.v4f[1] = a.v4f[1] * b.v4f[1];
+  return c;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f c;
+  c.v4f[0] = a.v4f[0] / b.v4f[0];
+  c.v4f[1] = a.v4f[1] / b.v4f[1];
+  return c;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a)
+{
+  Packet4f c;
+  c.v4f[0] = -a.v4f[0];
+  c.v4f[1] = -a.v4f[1];
+  return c;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
+{
+  Packet4f res;
+  res.v4f[0] = vec_madd(a.v4f[0], b.v4f[0], c.v4f[0]);
+  res.v4f[1] = vec_madd(a.v4f[1], b.v4f[1], c.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pmin(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pmin(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pmax(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pmax(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pand(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pand(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = por(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = por(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pxor(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pxor(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pandnot(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pandnot(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = vec_round(a.v4f[0]);
+  res.v4f[1] = vec_round(a.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(const  Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = vec_ceil(a.v4f[0]);
+  res.v4f[1] = vec_ceil(a.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(const Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = vec_floor(a.v4f[0]);
+  res.v4f[1] = vec_floor(a.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float*    from)
+{
+  Packet4f p = pload<Packet4f>(from);
+  p.v4f[1] = vec_splat(p.v4f[0], 1);
+  p.v4f[0] = vec_splat(p.v4f[0], 0);
+  return p;
+}
+
+template<> EIGEN_STRONG_INLINE float  pfirst<Packet4f>(const Packet4f& a) { float  EIGEN_ALIGN16 x[2]; vec_st2f(a.v4f[0], &x[0]); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{
+  Packet4f rev;
+  rev.v4f[0] = preverse<Packet2d>(a.v4f[1]);
+  rev.v4f[1] = preverse<Packet2d>(a.v4f[0]);
+  return rev;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pabs<Packet4f>(const Packet4f& a)
+{
+  Packet4f res;
+  res.v4f[0] = pabs(a.v4f[0]);
+  res.v4f[1] = pabs(a.v4f[1]);
+  return res;
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  Packet2d sum;
+  sum = padd<Packet2d>(a.v4f[0], a.v4f[1]);
+  double first = predux<Packet2d>(sum);
+  return static_cast<float>(first);
+}
+
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  // Return predux_mul<Packet2d> of the subvectors product
+  return static_cast<float>(pfirst(predux_mul(pmul(a.v4f[0], a.v4f[1]))));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  Packet2d b, res;
+  b   = pmin<Packet2d>(a.v4f[0], a.v4f[1]);
+  res = pmin<Packet2d>(b, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(b), reinterpret_cast<Packet4i>(b), 8)));
+  return static_cast<float>(pfirst(res));
+}
+
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  Packet2d b, res;
+  b   = pmax<Packet2d>(a.v4f[0], a.v4f[1]);
+  res = pmax<Packet2d>(b, reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet4i>(b), reinterpret_cast<Packet4i>(b), 8)));
+  return static_cast<float>(pfirst(res));
+}
+
+/* Split the Packet4f PacketBlock into 4 Packet2d PacketBlocks and transpose each one
+ */
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  PacketBlock<Packet2d,2> t0,t1,t2,t3;
+  // copy top-left 2x2 Packet2d block
+  t0.packet[0] = kernel.packet[0].v4f[0];
+  t0.packet[1] = kernel.packet[1].v4f[0];
+
+  // copy top-right 2x2 Packet2d block
+  t1.packet[0] = kernel.packet[0].v4f[1];
+  t1.packet[1] = kernel.packet[1].v4f[1];
+
+  // copy bottom-left 2x2 Packet2d block
+  t2.packet[0] = kernel.packet[2].v4f[0];
+  t2.packet[1] = kernel.packet[3].v4f[0];
+
+  // copy bottom-right 2x2 Packet2d block
+  t3.packet[0] = kernel.packet[2].v4f[1];
+  t3.packet[1] = kernel.packet[3].v4f[1];
+
+  // Transpose all 2x2 blocks
+  ptranspose(t0);
+  ptranspose(t1);
+  ptranspose(t2);
+  ptranspose(t3);
+
+  // Copy back transposed blocks, but exchange t1 and t2 due to transposition
+  kernel.packet[0].v4f[0] = t0.packet[0];
+  kernel.packet[0].v4f[1] = t2.packet[0];
+  kernel.packet[1].v4f[0] = t0.packet[1];
+  kernel.packet[1].v4f[1] = t2.packet[1];
+  kernel.packet[2].v4f[0] = t1.packet[0];
+  kernel.packet[2].v4f[1] = t3.packet[0];
+  kernel.packet[3].v4f[0] = t1.packet[1];
+  kernel.packet[3].v4f[1] = t3.packet[1];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  Packet2ul select_hi = { ifPacket.select[0], ifPacket.select[1] };
+  Packet2ul select_lo = { ifPacket.select[2], ifPacket.select[3] };
+  Packet2ul mask_hi = vec_cmpeq(select_hi, reinterpret_cast<Packet2ul>(p2l_ONE));
+  Packet2ul mask_lo = vec_cmpeq(select_lo, reinterpret_cast<Packet2ul>(p2l_ONE));
+  Packet4f result;
+  result.v4f[0] = vec_sel(elsePacket.v4f[0], thenPacket.v4f[0], mask_hi);
+  result.v4f[1] = vec_sel(elsePacket.v4f[1], thenPacket.v4f[1], mask_lo);
+  return result;
+}
+
+template<> Packet4f EIGEN_STRONG_INLINE pcmp_le<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pcmp_le(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pcmp_le(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> Packet4f EIGEN_STRONG_INLINE pcmp_lt<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pcmp_lt(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pcmp_lt(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+template<> Packet4f EIGEN_STRONG_INLINE pcmp_eq<Packet4f>(const Packet4f& a, const Packet4f& b)
+{
+  Packet4f res;
+  res.v4f[0] = pcmp_eq(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pcmp_eq(a.v4f[1], b.v4f[1]);
+  return res;
+}
+
+#else
+template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_LOAD
+  Packet *vfrom;
+  vfrom = (Packet *) from;
+  return vfrom->v4f;
+}
+
+template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from)
+{
+  // FIXME: No intrinsic yet
+  EIGEN_DEBUG_ALIGNED_STORE
+  Packet *vto;
+  vto = (Packet *) to;
+  vto->v4f = from;
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from)
+{
+  return vec_splats(from);
+}
+
+template<> EIGEN_STRONG_INLINE void
+pbroadcast4<Packet4f>(const float *a,
+                      Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3)
+{
+  a3 = pload<Packet4f>(a);
+  a0 = vec_splat(a3, 0);
+  a1 = vec_splat(a3, 1);
+  a2 = vec_splat(a3, 2);
+  a3 = vec_splat(a3, 3);
+}
+
+template<> EIGEN_DEVICE_FUNC inline Packet4f pgather<float, Packet4f>(const float* from, Index stride)
+{
+  float EIGEN_ALIGN16 af[4];
+  af[0] = from[0*stride];
+  af[1] = from[1*stride];
+  af[2] = from[2*stride];
+  af[3] = from[3*stride];
+ return pload<Packet4f>(af);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void pscatter<float, Packet4f>(float* to, const Packet4f& from, Index stride)
+{
+  float EIGEN_ALIGN16 af[4];
+  pstore<float>((float*)af, from);
+  to[0*stride] = af[0];
+  to[1*stride] = af[1];
+  to[2*stride] = af[2];
+  to[3*stride] = af[3];
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return (a + b); }
+template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return (a - b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return (a * b); }
+template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) { return (a / b); }
+template<> EIGEN_STRONG_INLINE Packet4f pnegate<Packet4f>(const Packet4f& a) { return (-a); }
+template<> EIGEN_STRONG_INLINE Packet4f pconj<Packet4f>  (const Packet4f& a) { return a; }
+template<> EIGEN_STRONG_INLINE Packet4f pmadd<Packet4f>  (const Packet4f& a, const Packet4f& b, const Packet4f& c) { return vec_madd(a, b, c); }
+template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>   (const Packet4f& a, const Packet4f& b) { return vec_min(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>   (const Packet4f& a, const Packet4f& b) { return vec_max(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>   (const Packet4f& a, const Packet4f& b) { return vec_and(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>    (const Packet4f& a, const Packet4f& b) { return vec_or(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>   (const Packet4f& a, const Packet4f& b) { return vec_xor(a, b); }
+template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_and(a, vec_nor(b, b)); }
+template<> EIGEN_STRONG_INLINE Packet4f pround<Packet4f> (const Packet4f& a) { return vec_round(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>  (const Packet4f& a) { return vec_ceil(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f> (const Packet4f& a) { return vec_floor(a); }
+template<> EIGEN_STRONG_INLINE Packet4f pabs<Packet4f>   (const Packet4f& a) { return vec_abs(a); }
+template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; pstore(x, a); return x[0]; }
+
+template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float* from)
+{
+  Packet4f p = pload<Packet4f>(from);
+  return vec_perm(p, p, p16uc_DUPLICATE32_HI);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a)
+{
+  return reinterpret_cast<Packet4f>(vec_perm(reinterpret_cast<Packet16uc>(a), reinterpret_cast<Packet16uc>(a), p16uc_REVERSE32));
+}
+
+template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, sum;
+  b   = vec_sld(a, a, 8);
+  sum = padd<Packet4f>(a, b);
+  b   = vec_sld(sum, sum, 4);
+  sum = padd<Packet4f>(sum, b);
+  return pfirst(sum);
+}
+
+// Other reduction functions:
+// mul
+template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a)
+{
+  Packet4f prod;
+  prod = pmul(a, vec_sld(a, a, 8));
+  return pfirst(pmul(prod, vec_sld(prod, prod, 4)));
+}
+
+// min
+template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, res;
+  b   = pmin<Packet4f>(a, vec_sld(a, a, 8));
+  res = pmin<Packet4f>(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+// max
+template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(const Packet4f& a)
+{
+  Packet4f b, res;
+  b = pmax<Packet4f>(a, vec_sld(a, a, 8));
+  res = pmax<Packet4f>(b, vec_sld(b, b, 4));
+  return pfirst(res);
+}
+
+EIGEN_DEVICE_FUNC inline void
+ptranspose(PacketBlock<Packet4f,4>& kernel) {
+  Packet4f t0 = vec_mergeh(kernel.packet[0], kernel.packet[2]);
+  Packet4f t1 = vec_mergel(kernel.packet[0], kernel.packet[2]);
+  Packet4f t2 = vec_mergeh(kernel.packet[1], kernel.packet[3]);
+  Packet4f t3 = vec_mergel(kernel.packet[1], kernel.packet[3]);
+  kernel.packet[0] = vec_mergeh(t0, t2);
+  kernel.packet[1] = vec_mergel(t0, t2);
+  kernel.packet[2] = vec_mergeh(t1, t3);
+  kernel.packet[3] = vec_mergel(t1, t3);
+}
+
+template<> EIGEN_STRONG_INLINE Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket, const Packet4f& elsePacket) {
+  Packet4ui select = { ifPacket.select[0], ifPacket.select[1], ifPacket.select[2], ifPacket.select[3] };
+  Packet4ui mask = vec_cmpeq(select, reinterpret_cast<Packet4ui>(p4i_ONE));
+  return vec_sel(elsePacket, thenPacket, mask);
+}
+
+#endif
+
+template<> EIGEN_STRONG_INLINE void prefetch<float>(const float*   addr) { EIGEN_ZVECTOR_PREFETCH(addr); }
+template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f> (const float* from) { return pload<Packet4f>(from); }
+template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet4f& from) { pstore<float>(to, from); }
+template<> EIGEN_STRONG_INLINE Packet4f plset<Packet4f>  (const float& a)  { return padd<Packet4f>(pset1<Packet4f>(a), p4f_COUNTDOWN); }
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PACKET_MATH_ZVECTOR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/AssignmentFunctors.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/AssignmentFunctors.h
new file mode 100644
index 00000000..bf64ef4e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/AssignmentFunctors.h
@@ -0,0 +1,177 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ASSIGNMENT_FUNCTORS_H
+#define EIGEN_ASSIGNMENT_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+  
+/** \internal
+  * \brief Template functor for scalar/packet assignment
+  *
+  */
+template<typename DstScalar,typename SrcScalar> struct assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a = b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,b); }
+};
+
+// Empty overload for void type (used by PermutationMatrix)
+template<typename DstScalar> struct assign_op<DstScalar,void> {};
+
+template<typename DstScalar,typename SrcScalar>
+struct functor_traits<assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::Vectorizable && packet_traits<SrcScalar>::Vectorizable
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with addition
+  *
+  */
+template<typename DstScalar,typename SrcScalar> struct add_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(add_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a += b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::padd(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar,typename SrcScalar>
+struct functor_traits<add_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::AddCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasAdd
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with subtraction
+  *
+  */
+template<typename DstScalar,typename SrcScalar> struct sub_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(sub_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a -= b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::psub(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar,typename SrcScalar>
+struct functor_traits<sub_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::AddCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasSub
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with multiplication
+  *
+  */
+template<typename DstScalar, typename SrcScalar=DstScalar>
+struct mul_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(mul_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a *= b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::pmul(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar, typename SrcScalar>
+struct functor_traits<mul_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasMul
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with diviving
+  *
+  */
+template<typename DstScalar, typename SrcScalar=DstScalar> struct div_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(div_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(DstScalar& a, const SrcScalar& b) const { a /= b; }
+  
+  template<int Alignment, typename Packet>
+  EIGEN_STRONG_INLINE void assignPacket(DstScalar* a, const Packet& b) const
+  { internal::pstoret<DstScalar,Packet,Alignment>(a,internal::pdiv(internal::ploadt<Packet,Alignment>(a),b)); }
+};
+template<typename DstScalar, typename SrcScalar>
+struct functor_traits<div_assign_op<DstScalar,SrcScalar> > {
+  enum {
+    Cost = NumTraits<DstScalar>::ReadCost + NumTraits<DstScalar>::MulCost,
+    PacketAccess = is_same<DstScalar,SrcScalar>::value && packet_traits<DstScalar>::HasDiv
+  };
+};
+
+/** \internal
+  * \brief Template functor for scalar/packet assignment with swapping
+  *
+  * It works as follow. For a non-vectorized evaluation loop, we have:
+  *   for(i) func(A.coeffRef(i), B.coeff(i));
+  * where B is a SwapWrapper expression. The trick is to make SwapWrapper::coeff behaves like a non-const coeffRef.
+  * Actually, SwapWrapper might not even be needed since even if B is a plain expression, since it has to be writable
+  * B.coeff already returns a const reference to the underlying scalar value.
+  * 
+  * The case of a vectorized loop is more tricky:
+  *   for(i,j) func.assignPacket<A_Align>(&A.coeffRef(i,j), B.packet<B_Align>(i,j));
+  * Here, B must be a SwapWrapper whose packet function actually returns a proxy object holding a Scalar*,
+  * the actual alignment and Packet type.
+  *
+  */
+template<typename Scalar> struct swap_assign_op {
+
+  EIGEN_EMPTY_STRUCT_CTOR(swap_assign_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignCoeff(Scalar& a, const Scalar& b) const
+  {
+#ifdef EIGEN_GPUCC
+    // FIXME is there some kind of cuda::swap?
+    Scalar t=b; const_cast<Scalar&>(b)=a; a=t;
+#else
+    using std::swap;
+    swap(a,const_cast<Scalar&>(b));
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<swap_assign_op<Scalar> > {
+  enum {
+    Cost = 3 * NumTraits<Scalar>::ReadCost,
+    PacketAccess = 
+    #if defined(EIGEN_VECTORIZE_AVX) && EIGEN_COMP_CLANG && (EIGEN_COMP_CLANG<800 || defined(__apple_build_version__))
+    // This is a partial workaround for a bug in clang generating bad code
+    // when mixing 256/512 bits loads and 128 bits moves.
+    // See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1684
+    //     https://bugs.llvm.org/show_bug.cgi?id=40815
+    0
+    #else
+    packet_traits<Scalar>::Vectorizable
+    #endif
+  };
+};
+
+} // namespace internal
+
+} // namespace Eigen
+
+#endif // EIGEN_ASSIGNMENT_FUNCTORS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/BinaryFunctors.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/BinaryFunctors.h
new file mode 100644
index 00000000..63f09ab9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/BinaryFunctors.h
@@ -0,0 +1,541 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BINARY_FUNCTORS_H
+#define EIGEN_BINARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- associative binary functors ----------
+
+template<typename Arg1, typename Arg2>
+struct binary_op_base
+{
+  typedef Arg1 first_argument_type;
+  typedef Arg2 second_argument_type;
+};
+
+/** \internal
+  * \brief Template functor to compute the sum of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::operator+, class VectorwiseOp, DenseBase::sum()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_sum_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_sum_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op)
+#else
+  scalar_sum_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a + b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::padd(a,b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(const Packet& a) const
+  { return internal::predux(a); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_sum_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (int(NumTraits<LhsScalar>::AddCost) + int(NumTraits<RhsScalar>::AddCost)) / 2, // rough estimate!
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasAdd && packet_traits<RhsScalar>::HasAdd
+    // TODO vectorize mixed sum
+  };
+};
+
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool scalar_sum_op<bool,bool>::operator() (const bool& a, const bool& b) const { return a || b; }
+
+
+/** \internal
+  * \brief Template functor to compute the product of two scalars
+  *
+  * \sa class CwiseBinaryOp, Cwise::operator*(), class VectorwiseOp, MatrixBase::redux()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_product_op  : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_product_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op)
+#else
+  scalar_product_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a * b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pmul(a,b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(const Packet& a) const
+  { return internal::predux_mul(a); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_product_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (int(NumTraits<LhsScalar>::MulCost) + int(NumTraits<RhsScalar>::MulCost))/2, // rough estimate!
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul
+    // TODO vectorize mixed product
+  };
+};
+
+template<>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool scalar_product_op<bool,bool>::operator() (const bool& a, const bool& b) const { return a && b; }
+
+
+/** \internal
+  * \brief Template functor to compute the conjugate product of two scalars
+  *
+  * This is a short cut for conj(x) * y which is needed for optimization purpose; in Eigen2 support mode, this becomes x * conj(y)
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_conj_product_op  : binary_op_base<LhsScalar,RhsScalar>
+{
+
+  enum {
+    Conj = NumTraits<LhsScalar>::IsComplex
+  };
+  
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_conj_product_op>::ReturnType result_type;
+  
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_conj_product_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const RhsScalar& b) const
+  { return conj_helper<LhsScalar,RhsScalar,Conj,false>().pmul(a,b); }
+  
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
+  { return conj_helper<Packet,Packet,Conj,false>().pmul(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_conj_product_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = NumTraits<LhsScalar>::MulCost,
+    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the min of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::cwiseMin, class VectorwiseOp, MatrixBase::minCoeff()
+  */
+template<typename LhsScalar,typename RhsScalar, int NaNPropagation>
+struct scalar_min_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_min_op>::ReturnType result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_min_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const RhsScalar& b) const {
+    return internal::pmin<NaNPropagation>(a, b);
+  }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
+  {
+    return internal::pmin<NaNPropagation>(a,b);
+  }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(const Packet& a) const
+  {
+    return internal::predux_min<NaNPropagation>(a);
+  }
+};
+
+template<typename LhsScalar,typename RhsScalar, int NaNPropagation>
+struct functor_traits<scalar_min_op<LhsScalar,RhsScalar, NaNPropagation> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMin
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the max of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::cwiseMax, class VectorwiseOp, MatrixBase::maxCoeff()
+  */
+template<typename LhsScalar,typename RhsScalar, int NaNPropagation>
+struct scalar_max_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_max_op>::ReturnType result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_max_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const RhsScalar& b) const {
+    return internal::pmax<NaNPropagation>(a,b);
+  }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
+  {
+    return internal::pmax<NaNPropagation>(a,b);
+  }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type predux(const Packet& a) const
+  {
+    return internal::predux_max<NaNPropagation>(a);
+  }
+};
+
+template<typename LhsScalar,typename RhsScalar, int NaNPropagation>
+struct functor_traits<scalar_max_op<LhsScalar,RhsScalar, NaNPropagation> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMax
+  };
+};
+
+/** \internal
+  * \brief Template functors for comparison of two scalars
+  * \todo Implement packet-comparisons
+  */
+template<typename LhsScalar, typename RhsScalar, ComparisonName cmp> struct scalar_cmp_op;
+
+template<typename LhsScalar, typename RhsScalar, ComparisonName cmp>
+struct functor_traits<scalar_cmp_op<LhsScalar,RhsScalar, cmp> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = false
+  };
+};
+
+template<ComparisonName Cmp, typename LhsScalar, typename RhsScalar>
+struct result_of<scalar_cmp_op<LhsScalar, RhsScalar, Cmp>(LhsScalar,RhsScalar)> {
+  typedef bool type;
+};
+
+
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_EQ> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a==b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_LT> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_LE> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<=b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_GT> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_GE> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>=b;}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_UNORD> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return !(a<=b || b<=a);}
+};
+template<typename LhsScalar, typename RhsScalar>
+struct scalar_cmp_op<LhsScalar,RhsScalar, cmp_NEQ> : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef bool result_type;
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cmp_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a!=b;}
+};
+
+/** \internal
+  * \brief Template functor to compute the hypot of two \b positive \b and \b real scalars
+  *
+  * \sa MatrixBase::stableNorm(), class Redux
+  */
+template<typename Scalar>
+struct scalar_hypot_op<Scalar,Scalar> : binary_op_base<Scalar,Scalar>
+{
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_hypot_op)
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar &x, const Scalar &y) const
+  {
+    // This functor is used by hypotNorm only for which it is faster to first apply abs
+    // on all coefficients prior to reduction through hypot.
+    // This way we avoid calling abs on positive and real entries, and this also permits
+    // to seamlessly handle complexes. Otherwise we would have to handle both real and complexes
+    // through the same functor...
+    return internal::positive_real_hypot(x,y);
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_hypot_op<Scalar,Scalar> > {
+  enum
+  {
+    Cost = 3 * NumTraits<Scalar>::AddCost +
+           2 * NumTraits<Scalar>::MulCost +
+           2 * scalar_div_cost<Scalar,false>::value,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the pow of two scalars
+  * See the specification of pow in https://en.cppreference.com/w/cpp/numeric/math/pow
+  */
+template<typename Scalar, typename Exponent>
+struct scalar_pow_op  : binary_op_base<Scalar,Exponent>
+{
+  typedef typename ScalarBinaryOpTraits<Scalar,Exponent,scalar_pow_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_pow_op)
+#else
+  scalar_pow_op() {
+    typedef Scalar LhsScalar;
+    typedef Exponent RhsScalar;
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+
+  EIGEN_DEVICE_FUNC
+  inline result_type operator() (const Scalar& a, const Exponent& b) const { return numext::pow(a, b); }
+
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  {
+    return generic_pow(a,b);
+  }
+};
+
+template<typename Scalar, typename Exponent>
+struct functor_traits<scalar_pow_op<Scalar,Exponent> > {
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = (!NumTraits<Scalar>::IsComplex && !NumTraits<Scalar>::IsInteger &&
+                    packet_traits<Scalar>::HasExp && packet_traits<Scalar>::HasLog &&
+                    packet_traits<Scalar>::HasRound && packet_traits<Scalar>::HasCmp &&
+                    // Temporarly disable packet access for half/bfloat16 until
+                    // accuracy is improved.
+                    !is_same<Scalar, half>::value && !is_same<Scalar, bfloat16>::value
+                    )
+  };
+};
+
+//---------- non associative binary functors ----------
+
+/** \internal
+  * \brief Template functor to compute the difference of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::operator-
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_difference_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_difference_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op)
+#else
+  scalar_difference_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a - b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::psub(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_difference_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (int(NumTraits<LhsScalar>::AddCost) + int(NumTraits<RhsScalar>::AddCost)) / 2,
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasSub && packet_traits<RhsScalar>::HasSub
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the quotient of two scalars
+  *
+  * \sa class CwiseBinaryOp, Cwise::operator/()
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_quotient_op  : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_quotient_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op)
+#else
+  scalar_quotient_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a / b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pdiv(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_quotient_op<LhsScalar,RhsScalar> > {
+  typedef typename scalar_quotient_op<LhsScalar,RhsScalar>::result_type result_type;
+  enum {
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasDiv && packet_traits<RhsScalar>::HasDiv,
+    Cost = scalar_div_cost<result_type,PacketAccess>::value
+  };
+};
+
+
+
+/** \internal
+  * \brief Template functor to compute the and of two booleans
+  *
+  * \sa class CwiseBinaryOp, ArrayBase::operator&&
+  */
+struct scalar_boolean_and_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_and_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a && b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pand(a,b); }
+};
+template<> struct functor_traits<scalar_boolean_and_op> {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = true
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the or of two booleans
+  *
+  * \sa class CwiseBinaryOp, ArrayBase::operator||
+  */
+struct scalar_boolean_or_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_or_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a || b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::por(a,b); }
+};
+template<> struct functor_traits<scalar_boolean_or_op> {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = true
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the xor of two booleans
+ *
+ * \sa class CwiseBinaryOp, ArrayBase::operator^
+ */
+struct scalar_boolean_xor_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_xor_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a ^ b; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pxor(a,b); }
+};
+template<> struct functor_traits<scalar_boolean_xor_op> {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = true
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the absolute difference of two scalars
+  *
+  * \sa class CwiseBinaryOp, MatrixBase::absolute_difference
+  */
+template<typename LhsScalar,typename RhsScalar>
+struct scalar_absolute_difference_op : binary_op_base<LhsScalar,RhsScalar>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_absolute_difference_op>::ReturnType result_type;
+#ifndef EIGEN_SCALAR_BINARY_OP_PLUGIN
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_absolute_difference_op)
+#else
+  scalar_absolute_difference_op() {
+    EIGEN_SCALAR_BINARY_OP_PLUGIN
+  }
+#endif
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const
+  { return numext::absdiff(a,b); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
+  { return internal::pabsdiff(a,b); }
+};
+template<typename LhsScalar,typename RhsScalar>
+struct functor_traits<scalar_absolute_difference_op<LhsScalar,RhsScalar> > {
+  enum {
+    Cost = (NumTraits<LhsScalar>::AddCost+NumTraits<RhsScalar>::AddCost)/2,
+    PacketAccess = is_same<LhsScalar,RhsScalar>::value && packet_traits<LhsScalar>::HasAbsDiff
+  };
+};
+
+
+
+//---------- binary functors bound to a constant, thus appearing as a unary functor ----------
+
+// The following two classes permits to turn any binary functor into a unary one with one argument bound to a constant value.
+// They are analogues to std::binder1st/binder2nd but with the following differences:
+//  - they are compatible with packetOp
+//  - they are portable across C++ versions (the std::binder* are deprecated in C++11)
+template<typename BinaryOp> struct bind1st_op : BinaryOp {
+
+  typedef typename BinaryOp::first_argument_type  first_argument_type;
+  typedef typename BinaryOp::second_argument_type second_argument_type;
+  typedef typename BinaryOp::result_type          result_type;
+
+  EIGEN_DEVICE_FUNC explicit bind1st_op(const first_argument_type &val) : m_value(val) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const second_argument_type& b) const { return BinaryOp::operator()(m_value,b); }
+
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& b) const
+  { return BinaryOp::packetOp(internal::pset1<Packet>(m_value), b); }
+
+  first_argument_type m_value;
+};
+template<typename BinaryOp> struct functor_traits<bind1st_op<BinaryOp> > : functor_traits<BinaryOp> {};
+
+
+template<typename BinaryOp> struct bind2nd_op : BinaryOp {
+
+  typedef typename BinaryOp::first_argument_type  first_argument_type;
+  typedef typename BinaryOp::second_argument_type second_argument_type;
+  typedef typename BinaryOp::result_type          result_type;
+
+  EIGEN_DEVICE_FUNC explicit bind2nd_op(const second_argument_type &val) : m_value(val) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const first_argument_type& a) const { return BinaryOp::operator()(a,m_value); }
+
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return BinaryOp::packetOp(a,internal::pset1<Packet>(m_value)); }
+
+  second_argument_type m_value;
+};
+template<typename BinaryOp> struct functor_traits<bind2nd_op<BinaryOp> > : functor_traits<BinaryOp> {};
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BINARY_FUNCTORS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/NullaryFunctors.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/NullaryFunctors.h
new file mode 100644
index 00000000..192f225d
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/NullaryFunctors.h
@@ -0,0 +1,189 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NULLARY_FUNCTORS_H
+#define EIGEN_NULLARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Scalar>
+struct scalar_constant_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_constant_op(const scalar_constant_op& other) : m_other(other.m_other) { }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_constant_op(const Scalar& other) : m_other(other) { }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() () const { return m_other; }
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const PacketType packetOp() const { return internal::pset1<PacketType>(m_other); }
+  const Scalar m_other;
+};
+template<typename Scalar>
+struct functor_traits<scalar_constant_op<Scalar> >
+{ enum { Cost = 0 /* as the constant value should be loaded in register only once for the whole expression */,
+         PacketAccess = packet_traits<Scalar>::Vectorizable, IsRepeatable = true }; };
+
+template<typename Scalar> struct scalar_identity_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op)
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType row, IndexType col) const { return row==col ? Scalar(1) : Scalar(0); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_identity_op<Scalar> >
+{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = false, IsRepeatable = true }; };
+
+template <typename Scalar, bool IsInteger> struct linspaced_op_impl;
+
+template <typename Scalar>
+struct linspaced_op_impl<Scalar,/*IsInteger*/false>
+{
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  EIGEN_DEVICE_FUNC linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps) :
+    m_low(low), m_high(high), m_size1(num_steps==1 ? 1 : num_steps-1), m_step(num_steps==1 ? Scalar() : Scalar((high-low)/RealScalar(num_steps-1))),
+    m_flip(numext::abs(high)<numext::abs(low))
+  {}
+
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType i) const {
+    if(m_flip)
+      return (i==0)? m_low : Scalar(m_high - RealScalar(m_size1-i)*m_step);
+    else
+      return (i==m_size1)? m_high : Scalar(m_low + RealScalar(i)*m_step);
+  }
+
+  template<typename Packet, typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const
+  {
+    // Principle:
+    // [low, ..., low] + ( [step, ..., step] * ( [i, ..., i] + [0, ..., size] ) )
+    if(m_flip)
+    {
+      Packet pi = plset<Packet>(Scalar(i-m_size1));
+      Packet res = padd(pset1<Packet>(m_high), pmul(pset1<Packet>(m_step), pi));
+      if (EIGEN_PREDICT_TRUE(i != 0)) return res;
+      Packet mask = pcmp_lt(pset1<Packet>(0), plset<Packet>(0));
+      return pselect<Packet>(mask, res, pset1<Packet>(m_low));
+    }
+    else
+    {
+      Packet pi = plset<Packet>(Scalar(i));
+      Packet res = padd(pset1<Packet>(m_low), pmul(pset1<Packet>(m_step), pi));
+      if(EIGEN_PREDICT_TRUE(i != m_size1-unpacket_traits<Packet>::size+1)) return res;
+      Packet mask = pcmp_lt(plset<Packet>(0), pset1<Packet>(unpacket_traits<Packet>::size-1));
+      return pselect<Packet>(mask, res, pset1<Packet>(m_high));
+    }
+  }
+
+  const Scalar m_low;
+  const Scalar m_high;
+  const Index m_size1;
+  const Scalar m_step;
+  const bool m_flip;
+};
+
+template <typename Scalar>
+struct linspaced_op_impl<Scalar,/*IsInteger*/true>
+{
+  EIGEN_DEVICE_FUNC linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps) :
+    m_low(low),
+    m_multiplier((high-low)/convert_index<Scalar>(num_steps<=1 ? 1 : num_steps-1)),
+    m_divisor(convert_index<Scalar>((high>=low?num_steps:-num_steps)+(high-low))/((numext::abs(high-low)+1)==0?1:(numext::abs(high-low)+1))),
+    m_use_divisor(num_steps>1 && (numext::abs(high-low)+1)<num_steps)
+  {}
+
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  const Scalar operator() (IndexType i) const
+  {
+    if(m_use_divisor) return m_low + convert_index<Scalar>(i)/m_divisor;
+    else              return m_low + convert_index<Scalar>(i)*m_multiplier;
+  }
+
+  const Scalar m_low;
+  const Scalar m_multiplier;
+  const Scalar m_divisor;
+  const bool m_use_divisor;
+};
+
+// ----- Linspace functor ----------------------------------------------------------------
+
+// Forward declaration (we default to random access which does not really give
+// us a speed gain when using packet access but it allows to use the functor in
+// nested expressions).
+template <typename Scalar> struct linspaced_op;
+template <typename Scalar> struct functor_traits< linspaced_op<Scalar> >
+{
+  enum
+  {
+    Cost = 1,
+    PacketAccess =   (!NumTraits<Scalar>::IsInteger) && packet_traits<Scalar>::HasSetLinear && packet_traits<Scalar>::HasBlend,
+                  /*&& ((!NumTraits<Scalar>::IsInteger) || packet_traits<Scalar>::HasDiv),*/ // <- vectorization for integer is currently disabled
+    IsRepeatable = true
+  };
+};
+template <typename Scalar> struct linspaced_op
+{
+  EIGEN_DEVICE_FUNC linspaced_op(const Scalar& low, const Scalar& high, Index num_steps)
+    : impl((num_steps==1 ? high : low),high,num_steps)
+  {}
+
+  template<typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (IndexType i) const { return impl(i); }
+
+  template<typename Packet,typename IndexType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const { return impl.template packetOp<Packet>(i); }
+
+  // This proxy object handles the actual required temporaries and the different
+  // implementations (integer vs. floating point).
+  const linspaced_op_impl<Scalar,NumTraits<Scalar>::IsInteger> impl;
+};
+
+// Linear access is automatically determined from the operator() prototypes available for the given functor.
+// If it exposes an operator()(i,j), then we assume the i and j coefficients are required independently
+// and linear access is not possible. In all other cases, linear access is enabled.
+// Users should not have to deal with this structure.
+template<typename Functor> struct functor_has_linear_access { enum { ret = !has_binary_operator<Functor>::value }; };
+
+// For unreliable compilers, let's specialize the has_*ary_operator
+// helpers so that at least built-in nullary functors work fine.
+#if !( (EIGEN_COMP_MSVC>1600) || (EIGEN_GNUC_AT_LEAST(4,8)) || (EIGEN_COMP_ICC>=1600))
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 1}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 0}; };
+
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<scalar_identity_op<Scalar>,IndexType> { enum { value = 1}; };
+
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<linspaced_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<linspaced_op<Scalar>,IndexType> { enum { value = 1}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<linspaced_op<Scalar>,IndexType> { enum { value = 0}; };
+
+template<typename Scalar,typename IndexType>
+struct has_nullary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 1}; };
+template<typename Scalar,typename IndexType>
+struct has_unary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 0}; };
+template<typename Scalar,typename IndexType>
+struct has_binary_operator<scalar_random_op<Scalar>,IndexType> { enum { value = 0}; };
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_NULLARY_FUNCTORS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/StlFunctors.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/StlFunctors.h
new file mode 100644
index 00000000..4570c9b6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/StlFunctors.h
@@ -0,0 +1,166 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STL_FUNCTORS_H
+#define EIGEN_STL_FUNCTORS_H
+
+namespace Eigen {
+
+// Portable replacements for certain functors.
+namespace numext {
+
+template<typename T = void>
+struct equal_to {
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC bool operator()(const T& lhs, const T& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+template<typename T = void>
+struct not_equal_to {
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC bool operator()(const T& lhs, const T& rhs) const {
+    return lhs != rhs;
+  }
+};
+
+}
+
+
+namespace internal {
+
+// default functor traits for STL functors:
+
+template<typename T>
+struct functor_traits<std::multiplies<T> >
+{ enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::divides<T> >
+{ enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::plus<T> >
+{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::minus<T> >
+{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::negate<T> >
+{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::logical_or<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::logical_and<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::logical_not<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::greater<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::less<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::greater_equal<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::less_equal<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::equal_to<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<numext::equal_to<T> >
+  : functor_traits<std::equal_to<T> > {};
+
+template<typename T>
+struct functor_traits<std::not_equal_to<T> >
+{ enum { Cost = 1, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<numext::not_equal_to<T> >
+  : functor_traits<std::not_equal_to<T> > {};
+
+#if (EIGEN_COMP_CXXVER < 11)
+// std::binder* are deprecated since c++11 and will be removed in c++17
+template<typename T>
+struct functor_traits<std::binder2nd<T> >
+{ enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; };
+
+template<typename T>
+struct functor_traits<std::binder1st<T> >
+{ enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; };
+#endif
+
+#if (EIGEN_COMP_CXXVER < 17)
+// std::unary_negate is deprecated since c++17 and will be removed in c++20
+template<typename T>
+struct functor_traits<std::unary_negate<T> >
+{ enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; };
+
+// std::binary_negate is deprecated since c++17 and will be removed in c++20
+template<typename T>
+struct functor_traits<std::binary_negate<T> >
+{ enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; };
+#endif
+
+#ifdef EIGEN_STDEXT_SUPPORT
+
+template<typename T0,typename T1>
+struct functor_traits<std::project1st<T0,T1> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::project2nd<T0,T1> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::select2nd<std::pair<T0,T1> > >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::select1st<std::pair<T0,T1> > >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+template<typename T0,typename T1>
+struct functor_traits<std::unary_compose<T0,T1> >
+{ enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost, PacketAccess = false }; };
+
+template<typename T0,typename T1,typename T2>
+struct functor_traits<std::binary_compose<T0,T1,T2> >
+{ enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost + functor_traits<T2>::Cost, PacketAccess = false }; };
+
+#endif // EIGEN_STDEXT_SUPPORT
+
+// allow to add new functors and specializations of functor_traits from outside Eigen.
+// this macro is really needed because functor_traits must be specialized after it is declared but before it is used...
+#ifdef EIGEN_FUNCTORS_PLUGIN
+#include EIGEN_FUNCTORS_PLUGIN
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_STL_FUNCTORS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/TernaryFunctors.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/TernaryFunctors.h
new file mode 100644
index 00000000..b254e96c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/TernaryFunctors.h
@@ -0,0 +1,25 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TERNARY_FUNCTORS_H
+#define EIGEN_TERNARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+//---------- associative ternary functors ----------
+
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TERNARY_FUNCTORS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/UnaryFunctors.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/UnaryFunctors.h
new file mode 100644
index 00000000..16136d18
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/functors/UnaryFunctors.h
@@ -0,0 +1,1131 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UNARY_FUNCTORS_H
+#define EIGEN_UNARY_FUNCTORS_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+  * \brief Template functor to compute the opposite of a scalar
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::operator-
+  */
+template<typename Scalar> struct scalar_opposite_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_opposite_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return -a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::pnegate(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_opposite_op<Scalar> >
+{ enum {
+    Cost = NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasNegate };
+};
+
+/** \internal
+  * \brief Template functor to compute the absolute value of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::abs
+  */
+template<typename Scalar> struct scalar_abs_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return numext::abs(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::pabs(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_abs_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasAbs
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the score of a scalar, to chose a pivot
+  *
+  * \sa class CwiseUnaryOp
+  */
+template<typename Scalar> struct scalar_score_coeff_op : scalar_abs_op<Scalar>
+{
+  typedef void Score_is_abs;
+};
+template<typename Scalar>
+struct functor_traits<scalar_score_coeff_op<Scalar> > : functor_traits<scalar_abs_op<Scalar> > {};
+
+/* Avoid recomputing abs when we know the score and they are the same. Not a true Eigen functor.  */
+template<typename Scalar, typename=void> struct abs_knowing_score
+{
+  EIGEN_EMPTY_STRUCT_CTOR(abs_knowing_score)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  template<typename Score>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a, const Score&) const { return numext::abs(a); }
+};
+template<typename Scalar> struct abs_knowing_score<Scalar, typename scalar_score_coeff_op<Scalar>::Score_is_abs>
+{
+  EIGEN_EMPTY_STRUCT_CTOR(abs_knowing_score)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  template<typename Scal>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scal&, const result_type& a) const { return a; }
+};
+
+/** \internal
+  * \brief Template functor to compute the squared absolute value of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::abs2
+  */
+template<typename Scalar> struct scalar_abs2_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return numext::abs2(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::pmul(a,a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_abs2_op<Scalar> >
+{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasAbs2 }; };
+
+/** \internal
+  * \brief Template functor to compute the conjugate of a complex value
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::conjugate()
+  */
+template<typename Scalar> struct scalar_conjugate_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_conjugate_op)
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::conj(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const { return internal::pconj(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_conjugate_op<Scalar> >
+{
+  enum {
+    Cost = 0,
+    // Yes the cost is zero even for complexes because in most cases for which
+    // the cost is used, conjugation turns to be a no-op. Some examples:
+    //   cost(a*conj(b)) == cost(a*b)
+    //   cost(a+conj(b)) == cost(a+b)
+    //   <etc.
+    // If we don't set it to zero, then:
+    //   A.conjugate().lazyProduct(B.conjugate())
+    // will bake its operands. We definitely don't want that!
+    PacketAccess = packet_traits<Scalar>::HasConj
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the phase angle of a complex
+  *
+  * \sa class CwiseUnaryOp, Cwise::arg
+  */
+template<typename Scalar> struct scalar_arg_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_arg_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return numext::arg(a); }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::parg(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_arg_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::IsComplex ? 5 * NumTraits<Scalar>::MulCost : NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasArg
+  };
+};
+/** \internal
+  * \brief Template functor to cast a scalar to another type
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::cast()
+  */
+template<typename Scalar, typename NewType>
+struct scalar_cast_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+  typedef NewType result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return cast<Scalar, NewType>(a); }
+};
+template<typename Scalar, typename NewType>
+struct functor_traits<scalar_cast_op<Scalar,NewType> >
+{ enum { Cost = is_same<Scalar, NewType>::value ? 0 : NumTraits<NewType>::AddCost, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to arithmetically shift a scalar right by a number of bits
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::shift_right()
+  */
+template<typename Scalar, int N>
+struct scalar_shift_right_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_shift_right_op)
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const
+  { return a >> N; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::parithmetic_shift_right<N>(a); }
+};
+template<typename Scalar, int N>
+struct functor_traits<scalar_shift_right_op<Scalar,N> >
+{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasShift }; };
+
+/** \internal
+  * \brief Template functor to logically shift a scalar left by a number of bits
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::shift_left()
+  */
+template<typename Scalar, int N>
+struct scalar_shift_left_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_shift_left_op)
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const
+  { return a << N; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
+  { return internal::plogical_shift_left<N>(a); }
+};
+template<typename Scalar, int N>
+struct functor_traits<scalar_shift_left_op<Scalar,N> >
+{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasShift }; };
+
+/** \internal
+  * \brief Template functor to extract the real part of a complex
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::real()
+  */
+template<typename Scalar>
+struct scalar_real_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_real_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::real(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_real_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to extract the imaginary part of a complex
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::imag()
+  */
+template<typename Scalar>
+struct scalar_imag_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return numext::imag(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_imag_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to extract the real part of a complex as a reference
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::real()
+  */
+template<typename Scalar>
+struct scalar_real_ref_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_real_ref_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return numext::real_ref(*const_cast<Scalar*>(&a)); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_real_ref_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  * \brief Template functor to extract the imaginary part of a complex as a reference
+  *
+  * \sa class CwiseUnaryOp, MatrixBase::imag()
+  */
+template<typename Scalar>
+struct scalar_imag_ref_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_ref_op)
+  typedef typename NumTraits<Scalar>::Real result_type;
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return numext::imag_ref(*const_cast<Scalar*>(&a)); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_imag_ref_op<Scalar> >
+{ enum { Cost = 0, PacketAccess = false }; };
+
+/** \internal
+  *
+  * \brief Template functor to compute the exponential of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::exp()
+  */
+template<typename Scalar> struct scalar_exp_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::exp(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_exp_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasExp,
+    // The following numbers are based on the AVX implementation.
+#ifdef EIGEN_VECTORIZE_FMA
+    // Haswell can issue 2 add/mul/madd per cycle.
+    Cost =
+    (sizeof(Scalar) == 4
+     // float: 8 pmadd, 4 pmul, 2 padd/psub, 6 other
+     ? (8 * NumTraits<Scalar>::AddCost + 6 * NumTraits<Scalar>::MulCost)
+     // double: 7 pmadd, 5 pmul, 3 padd/psub, 1 div,  13 other
+     : (14 * NumTraits<Scalar>::AddCost +
+        6 * NumTraits<Scalar>::MulCost +
+        scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value))
+#else
+    Cost =
+    (sizeof(Scalar) == 4
+     // float: 7 pmadd, 6 pmul, 4 padd/psub, 10 other
+     ? (21 * NumTraits<Scalar>::AddCost + 13 * NumTraits<Scalar>::MulCost)
+     // double: 7 pmadd, 5 pmul, 3 padd/psub, 1 div,  13 other
+     : (23 * NumTraits<Scalar>::AddCost +
+        12 * NumTraits<Scalar>::MulCost +
+        scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value))
+#endif
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the exponential of a scalar - 1.
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::expm1()
+  */
+template<typename Scalar> struct scalar_expm1_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_expm1_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::expm1(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pexpm1(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_expm1_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasExpm1,
+    Cost = functor_traits<scalar_exp_op<Scalar> >::Cost // TODO measure cost of expm1
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the logarithm of a scalar
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::log()
+  */
+template<typename Scalar> struct scalar_log_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::log(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_log_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasLog,
+    Cost =
+    (PacketAccess
+     // The following numbers are based on the AVX implementation.
+#ifdef EIGEN_VECTORIZE_FMA
+     // 8 pmadd, 6 pmul, 8 padd/psub, 16 other, can issue 2 add/mul/madd per cycle.
+     ? (20 * NumTraits<Scalar>::AddCost + 7 * NumTraits<Scalar>::MulCost)
+#else
+     // 8 pmadd, 6 pmul, 8 padd/psub, 20 other
+     ? (36 * NumTraits<Scalar>::AddCost + 14 * NumTraits<Scalar>::MulCost)
+#endif
+     // Measured cost of std::log.
+     : sizeof(Scalar)==4 ? 40 : 85)
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the logarithm of 1 plus a scalar value
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::log1p()
+  */
+template<typename Scalar> struct scalar_log1p_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log1p_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::log1p(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog1p(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_log1p_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasLog1p,
+    Cost = functor_traits<scalar_log_op<Scalar> >::Cost // TODO measure cost of log1p
+  };
+};
+
+/** \internal
+  *
+  * \brief Template functor to compute the base-10 logarithm of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::log10()
+  */
+template<typename Scalar> struct scalar_log10_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log10_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { EIGEN_USING_STD(log10) return log10(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog10(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_log10_op<Scalar> >
+{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog10 }; };
+
+/** \internal
+  *
+  * \brief Template functor to compute the base-2 logarithm of a scalar
+  *
+  * \sa class CwiseUnaryOp, Cwise::log2()
+  */
+template<typename Scalar> struct scalar_log2_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_log2_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return Scalar(EIGEN_LOG2E) * numext::log(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::plog2(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_log2_op<Scalar> >
+{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasLog }; };
+
+/** \internal
+  * \brief Template functor to compute the square root of a scalar
+  * \sa class CwiseUnaryOp, Cwise::sqrt()
+  */
+template<typename Scalar> struct scalar_sqrt_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::sqrt(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_sqrt_op<Scalar> > {
+  enum {
+#if EIGEN_FAST_MATH
+    // The following numbers are based on the AVX implementation.
+    Cost = (sizeof(Scalar) == 8 ? 28
+                                // 4 pmul, 1 pmadd, 3 other
+                                : (3 * NumTraits<Scalar>::AddCost +
+                                   5 * NumTraits<Scalar>::MulCost)),
+#else
+    // The following numbers are based on min VSQRT throughput on Haswell.
+    Cost = (sizeof(Scalar) == 8 ? 28 : 14),
+#endif
+    PacketAccess = packet_traits<Scalar>::HasSqrt
+  };
+};
+
+// Boolean specialization to eliminate -Wimplicit-conversion-floating-point-to-bool warnings.
+template<> struct scalar_sqrt_op<bool> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline bool operator() (const bool& a) const { return a; }
+  template <typename Packet>
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return a; }
+};
+template <>
+struct functor_traits<scalar_sqrt_op<bool> > {
+  enum { Cost = 1, PacketAccess = packet_traits<bool>::Vectorizable };
+};
+
+/** \internal
+  * \brief Template functor to compute the reciprocal square root of a scalar
+  * \sa class CwiseUnaryOp, Cwise::rsqrt()
+  */
+template<typename Scalar> struct scalar_rsqrt_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_rsqrt_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::rsqrt(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::prsqrt(a); }
+};
+
+template<typename Scalar>
+struct functor_traits<scalar_rsqrt_op<Scalar> >
+{ enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasRsqrt
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the cosine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::cos()
+  */
+template<typename Scalar> struct scalar_cos_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return numext::cos(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_cos_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasCos
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the sine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::sin()
+  */
+template<typename Scalar> struct scalar_sin_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::sin(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_sin_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasSin
+  };
+};
+
+
+/** \internal
+  * \brief Template functor to compute the tan of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::tan()
+  */
+template<typename Scalar> struct scalar_tan_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::tan(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_tan_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasTan
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the arc cosine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::acos()
+  */
+template<typename Scalar> struct scalar_acos_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::acos(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pacos(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_acos_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasACos
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the arc sine of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::asin()
+  */
+template<typename Scalar> struct scalar_asin_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::asin(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pasin(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_asin_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasASin
+  };
+};
+
+
+/** \internal
+  * \brief Template functor to compute the atan of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::atan()
+  */
+template<typename Scalar> struct scalar_atan_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_atan_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::atan(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::patan(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_atan_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasATan
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the tanh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::tanh()
+  */
+template <typename Scalar>
+struct scalar_tanh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_tanh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator()(const Scalar& a) const { return numext::tanh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& x) const { return ptanh(x); }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_tanh_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasTanh,
+    Cost = ( (EIGEN_FAST_MATH && is_same<Scalar,float>::value)
+// The following numbers are based on the AVX implementation,
+#ifdef EIGEN_VECTORIZE_FMA
+                // Haswell can issue 2 add/mul/madd per cycle.
+                // 9 pmadd, 2 pmul, 1 div, 2 other
+                ? (2 * NumTraits<Scalar>::AddCost +
+                   6 * NumTraits<Scalar>::MulCost +
+                   scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value)
+#else
+                ? (11 * NumTraits<Scalar>::AddCost +
+                   11 * NumTraits<Scalar>::MulCost +
+                   scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value)
+#endif
+                // This number assumes a naive implementation of tanh
+                : (6 * NumTraits<Scalar>::AddCost +
+                   3 * NumTraits<Scalar>::MulCost +
+                   2 * scalar_div_cost<Scalar,packet_traits<Scalar>::HasDiv>::value +
+                   functor_traits<scalar_exp_op<Scalar> >::Cost))
+  };
+};
+
+#if EIGEN_HAS_CXX11_MATH
+/** \internal
+  * \brief Template functor to compute the atanh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::atanh()
+  */
+template <typename Scalar>
+struct scalar_atanh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_atanh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator()(const Scalar& a) const { return numext::atanh(a); }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_atanh_op<Scalar> > {
+  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
+};
+#endif
+
+/** \internal
+  * \brief Template functor to compute the sinh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::sinh()
+  */
+template<typename Scalar> struct scalar_sinh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sinh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::sinh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psinh(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_sinh_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasSinh
+  };
+};
+
+#if EIGEN_HAS_CXX11_MATH
+/** \internal
+  * \brief Template functor to compute the asinh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::asinh()
+  */
+template <typename Scalar>
+struct scalar_asinh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_asinh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator()(const Scalar& a) const { return numext::asinh(a); }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_asinh_op<Scalar> > {
+  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
+};
+#endif
+
+/** \internal
+  * \brief Template functor to compute the cosh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::cosh()
+  */
+template<typename Scalar> struct scalar_cosh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cosh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { return numext::cosh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pcosh(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_cosh_op<Scalar> >
+{
+  enum {
+    Cost = 5 * NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasCosh
+  };
+};
+
+#if EIGEN_HAS_CXX11_MATH
+/** \internal
+  * \brief Template functor to compute the acosh of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::acosh()
+  */
+template <typename Scalar>
+struct scalar_acosh_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_acosh_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator()(const Scalar& a) const { return numext::acosh(a); }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_acosh_op<Scalar> > {
+  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
+};
+#endif
+
+/** \internal
+  * \brief Template functor to compute the inverse of a scalar
+  * \sa class CwiseUnaryOp, Cwise::inverse()
+  */
+template<typename Scalar>
+struct scalar_inverse_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_inverse_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return internal::pdiv(pset1<Packet>(Scalar(1)),a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_inverse_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasDiv,
+    Cost = scalar_div_cost<Scalar, PacketAccess>::value
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the square of a scalar
+  * \sa class CwiseUnaryOp, Cwise::square()
+  */
+template<typename Scalar>
+struct scalar_square_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return a*a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return internal::pmul(a,a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_square_op<Scalar> >
+{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
+
+// Boolean specialization to avoid -Wint-in-bool-context warnings on GCC.
+template<>
+struct scalar_square_op<bool> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op)
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline bool operator() (const bool& a) const { return a; }
+  template<typename Packet>
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return a; }
+};
+template<>
+struct functor_traits<scalar_square_op<bool> >
+{ enum { Cost = 0, PacketAccess = packet_traits<bool>::Vectorizable }; };
+
+/** \internal
+  * \brief Template functor to compute the cube of a scalar
+  * \sa class CwiseUnaryOp, Cwise::cube()
+  */
+template<typename Scalar>
+struct scalar_cube_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op)
+  EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return a*a*a; }
+  template<typename Packet>
+  EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return internal::pmul(a,pmul(a,a)); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_cube_op<Scalar> >
+{ enum { Cost = 2*NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; };
+
+// Boolean specialization to avoid -Wint-in-bool-context warnings on GCC.
+template<>
+struct scalar_cube_op<bool> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op)
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline bool operator() (const bool& a) const { return a; }
+  template<typename Packet>
+  EIGEN_DEPRECATED EIGEN_DEVICE_FUNC inline const Packet packetOp(const Packet& a) const
+  { return a; }
+};
+template<>
+struct functor_traits<scalar_cube_op<bool> >
+{ enum { Cost = 0, PacketAccess = packet_traits<bool>::Vectorizable }; };
+
+/** \internal
+  * \brief Template functor to compute the rounded value of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::round()
+  */
+template<typename Scalar> struct scalar_round_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_round_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::round(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pround(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_round_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasRound
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the floor of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::floor()
+  */
+template<typename Scalar> struct scalar_floor_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_floor_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::floor(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pfloor(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_floor_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasFloor
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the rounded (with current rounding mode)  value of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::rint()
+  */
+template<typename Scalar> struct scalar_rint_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_rint_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::rint(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::print(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_rint_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasRint
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the ceil of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::ceil()
+  */
+template<typename Scalar> struct scalar_ceil_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_ceil_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return numext::ceil(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::pceil(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_ceil_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = packet_traits<Scalar>::HasCeil
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute whether a scalar is NaN
+  * \sa class CwiseUnaryOp, ArrayBase::isnan()
+  */
+template<typename Scalar> struct scalar_isnan_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isnan_op)
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const {
+#if defined(SYCL_DEVICE_ONLY)
+    return numext::isnan(a);
+#else
+    return (numext::isnan)(a);
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_isnan_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to check whether a scalar is +/-inf
+  * \sa class CwiseUnaryOp, ArrayBase::isinf()
+  */
+template<typename Scalar> struct scalar_isinf_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isinf_op)
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const {
+#if defined(SYCL_DEVICE_ONLY)
+    return numext::isinf(a);
+#else
+    return (numext::isinf)(a);
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_isinf_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to check whether a scalar has a finite value
+  * \sa class CwiseUnaryOp, ArrayBase::isfinite()
+  */
+template<typename Scalar> struct scalar_isfinite_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_isfinite_op)
+  typedef bool result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const {
+#if defined(SYCL_DEVICE_ONLY)
+    return numext::isfinite(a);
+#else
+    return (numext::isfinite)(a);
+#endif
+  }
+};
+template<typename Scalar>
+struct functor_traits<scalar_isfinite_op<Scalar> >
+{
+  enum {
+    Cost = NumTraits<Scalar>::MulCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the logical not of a boolean
+  *
+  * \sa class CwiseUnaryOp, ArrayBase::operator!
+  */
+template<typename Scalar> struct scalar_boolean_not_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_not_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a) const { return !a; }
+};
+template<typename Scalar>
+struct functor_traits<scalar_boolean_not_op<Scalar> > {
+  enum {
+    Cost = NumTraits<bool>::AddCost,
+    PacketAccess = false
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the signum of a scalar
+  * \sa class CwiseUnaryOp, Cwise::sign()
+  */
+template<typename Scalar,bool is_complex=(NumTraits<Scalar>::IsComplex!=0), bool is_integer=(NumTraits<Scalar>::IsInteger!=0) > struct scalar_sign_op;
+template<typename Scalar>
+struct scalar_sign_op<Scalar, false, true> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sign_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
+  {
+      return Scalar( (a>Scalar(0)) - (a<Scalar(0)) );
+  }
+  //TODO
+  //template <typename Packet>
+  //EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psign(a); }
+};
+
+template<typename Scalar>
+struct scalar_sign_op<Scalar, false, false> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sign_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
+  {
+    return (numext::isnan)(a) ? a : Scalar( (a>Scalar(0)) - (a<Scalar(0)) );
+  }
+  //TODO
+  //template <typename Packet>
+  //EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psign(a); }
+};
+
+template<typename Scalar, bool is_integer>
+struct scalar_sign_op<Scalar,true, is_integer> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_sign_op)
+  EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
+  {
+    typedef typename NumTraits<Scalar>::Real real_type;
+    real_type aa = numext::abs(a);
+    if (aa==real_type(0))
+      return Scalar(0);
+    aa = real_type(1)/aa;
+    return Scalar(a.real()*aa, a.imag()*aa );
+  }
+  //TODO
+  //template <typename Packet>
+  //EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const { return internal::psign(a); }
+};
+template<typename Scalar>
+struct functor_traits<scalar_sign_op<Scalar> >
+{ enum {
+    Cost =
+        NumTraits<Scalar>::IsComplex
+        ? ( 8*NumTraits<Scalar>::MulCost  ) // roughly
+        : ( 3*NumTraits<Scalar>::AddCost),
+    PacketAccess = packet_traits<Scalar>::HasSign
+  };
+};
+
+/** \internal
+  * \brief Template functor to compute the logistic function of a scalar
+  * \sa class CwiseUnaryOp, ArrayBase::logistic()
+  */
+template <typename T>
+struct scalar_logistic_op {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_logistic_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x) const {
+    return packetOp(x);
+  }
+
+  template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Packet packetOp(const Packet& x) const {
+    const Packet one = pset1<Packet>(T(1));
+    return pdiv(one, padd(one, pexp(pnegate(x))));
+  }
+};
+
+#ifndef EIGEN_GPU_COMPILE_PHASE
+/** \internal
+  * \brief Template specialization of the logistic function for float.
+  *
+  *  Uses just a 9/10-degree rational interpolant which
+  *  interpolates 1/(1+exp(-x)) - 0.5 up to a couple of ulps in the range
+  *  [-9, 18]. Below -9 we use the more accurate approximation
+  *  1/(1+exp(-x)) ~= exp(x), and above 18 the logistic function is 1 withing
+  *  one ulp. The shifted logistic is interpolated because it was easier to
+  *  make the fit converge.
+  *
+  */
+template <>
+struct scalar_logistic_op<float> {
+  EIGEN_EMPTY_STRUCT_CTOR(scalar_logistic_op)
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator()(const float& x) const {
+    return packetOp(x);
+  }
+
+  template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  Packet packetOp(const Packet& _x) const {
+    const Packet cutoff_lower = pset1<Packet>(-9.f);
+    const Packet lt_mask = pcmp_lt<Packet>(_x, cutoff_lower);
+    const bool any_small = predux_any(lt_mask);
+
+    // The upper cut-off is the smallest x for which the rational approximation evaluates to 1.
+    // Choosing this value saves us a few instructions clamping the results at the end.
+#ifdef EIGEN_VECTORIZE_FMA
+    const Packet cutoff_upper = pset1<Packet>(15.7243833541870117f);
+#else
+    const Packet cutoff_upper = pset1<Packet>(15.6437711715698242f);
+#endif
+    const Packet x = pmin(_x, cutoff_upper);
+
+    // The monomial coefficients of the numerator polynomial (odd).
+    const Packet alpha_1 = pset1<Packet>(2.48287947061529e-01f);
+    const Packet alpha_3 = pset1<Packet>(8.51377133304701e-03f);
+    const Packet alpha_5 = pset1<Packet>(6.08574864600143e-05f);
+    const Packet alpha_7 = pset1<Packet>(1.15627324459942e-07f);
+    const Packet alpha_9 = pset1<Packet>(4.37031012579801e-11f);
+
+    // The monomial coefficients of the denominator polynomial (even).
+    const Packet beta_0 = pset1<Packet>(9.93151921023180e-01f);
+    const Packet beta_2 = pset1<Packet>(1.16817656904453e-01f);
+    const Packet beta_4 = pset1<Packet>(1.70198817374094e-03f);
+    const Packet beta_6 = pset1<Packet>(6.29106785017040e-06f);
+    const Packet beta_8 = pset1<Packet>(5.76102136993427e-09f);
+    const Packet beta_10 = pset1<Packet>(6.10247389755681e-13f);
+
+    // Since the polynomials are odd/even, we need x^2.
+    const Packet x2 = pmul(x, x);
+
+    // Evaluate the numerator polynomial p.
+    Packet p = pmadd(x2, alpha_9, alpha_7);
+    p = pmadd(x2, p, alpha_5);
+    p = pmadd(x2, p, alpha_3);
+    p = pmadd(x2, p, alpha_1);
+    p = pmul(x, p);
+
+    // Evaluate the denominator polynomial q.
+    Packet q = pmadd(x2, beta_10, beta_8);
+    q = pmadd(x2, q, beta_6);
+    q = pmadd(x2, q, beta_4);
+    q = pmadd(x2, q, beta_2);
+    q = pmadd(x2, q, beta_0);
+    // Divide the numerator by the denominator and shift it up.
+    const Packet logistic = padd(pdiv(p, q), pset1<Packet>(0.5f));
+    if (EIGEN_PREDICT_FALSE(any_small)) {
+      const Packet exponential = pexp(_x);
+      return pselect(lt_mask, exponential, logistic);
+    } else {
+      return logistic;
+    }
+  }
+};
+#endif  // #ifndef EIGEN_GPU_COMPILE_PHASE
+
+template <typename T>
+struct functor_traits<scalar_logistic_op<T> > {
+  enum {
+    // The cost estimate for float here here is for the common(?) case where
+    // all arguments are greater than -9.
+    Cost = scalar_div_cost<T, packet_traits<T>::HasDiv>::value +
+           (internal::is_same<T, float>::value
+                ? NumTraits<T>::AddCost * 15 + NumTraits<T>::MulCost * 11
+                : NumTraits<T>::AddCost * 2 +
+                      functor_traits<scalar_exp_op<T> >::Cost),
+    PacketAccess =
+        packet_traits<T>::HasAdd && packet_traits<T>::HasDiv &&
+        (internal::is_same<T, float>::value
+             ? packet_traits<T>::HasMul && packet_traits<T>::HasMax &&
+                   packet_traits<T>::HasMin
+             : packet_traits<T>::HasNegate && packet_traits<T>::HasExp)
+  };
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_FUNCTORS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
new file mode 100644
index 00000000..f35b760c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
@@ -0,0 +1,2645 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_BLOCK_PANEL_H
+#define EIGEN_GENERAL_BLOCK_PANEL_H
+
+
+namespace Eigen {
+
+namespace internal {
+
+enum GEBPPacketSizeType {
+  GEBPPacketFull = 0,
+  GEBPPacketHalf,
+  GEBPPacketQuarter
+};
+
+template<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs=false, bool _ConjRhs=false, int Arch=Architecture::Target, int _PacketSize=GEBPPacketFull>
+class gebp_traits;
+
+
+/** \internal \returns b if a<=0, and returns a otherwise. */
+inline std::ptrdiff_t manage_caching_sizes_helper(std::ptrdiff_t a, std::ptrdiff_t b)
+{
+  return a<=0 ? b : a;
+}
+
+#if defined(EIGEN_DEFAULT_L1_CACHE_SIZE)
+#define EIGEN_SET_DEFAULT_L1_CACHE_SIZE(val) EIGEN_DEFAULT_L1_CACHE_SIZE
+#else
+#define EIGEN_SET_DEFAULT_L1_CACHE_SIZE(val) val
+#endif // defined(EIGEN_DEFAULT_L1_CACHE_SIZE)
+
+#if defined(EIGEN_DEFAULT_L2_CACHE_SIZE)
+#define EIGEN_SET_DEFAULT_L2_CACHE_SIZE(val) EIGEN_DEFAULT_L2_CACHE_SIZE
+#else
+#define EIGEN_SET_DEFAULT_L2_CACHE_SIZE(val) val
+#endif // defined(EIGEN_DEFAULT_L2_CACHE_SIZE)
+
+#if defined(EIGEN_DEFAULT_L3_CACHE_SIZE)
+#define EIGEN_SET_DEFAULT_L3_CACHE_SIZE(val) EIGEN_DEFAULT_L3_CACHE_SIZE
+#else
+#define EIGEN_SET_DEFAULT_L3_CACHE_SIZE(val) val
+#endif // defined(EIGEN_DEFAULT_L3_CACHE_SIZE)
+  
+#if EIGEN_ARCH_i386_OR_x86_64
+const std::ptrdiff_t defaultL1CacheSize = EIGEN_SET_DEFAULT_L1_CACHE_SIZE(32*1024);
+const std::ptrdiff_t defaultL2CacheSize = EIGEN_SET_DEFAULT_L2_CACHE_SIZE(256*1024);
+const std::ptrdiff_t defaultL3CacheSize = EIGEN_SET_DEFAULT_L3_CACHE_SIZE(2*1024*1024);
+#elif EIGEN_ARCH_PPC
+const std::ptrdiff_t defaultL1CacheSize = EIGEN_SET_DEFAULT_L1_CACHE_SIZE(64*1024);
+const std::ptrdiff_t defaultL2CacheSize = EIGEN_SET_DEFAULT_L2_CACHE_SIZE(512*1024);
+const std::ptrdiff_t defaultL3CacheSize = EIGEN_SET_DEFAULT_L3_CACHE_SIZE(4*1024*1024);
+#else
+const std::ptrdiff_t defaultL1CacheSize = EIGEN_SET_DEFAULT_L1_CACHE_SIZE(16*1024);
+const std::ptrdiff_t defaultL2CacheSize = EIGEN_SET_DEFAULT_L2_CACHE_SIZE(512*1024);
+const std::ptrdiff_t defaultL3CacheSize = EIGEN_SET_DEFAULT_L3_CACHE_SIZE(512*1024);
+#endif
+
+#undef EIGEN_SET_DEFAULT_L1_CACHE_SIZE
+#undef EIGEN_SET_DEFAULT_L2_CACHE_SIZE
+#undef EIGEN_SET_DEFAULT_L3_CACHE_SIZE
+
+/** \internal */
+struct CacheSizes {
+  CacheSizes(): m_l1(-1),m_l2(-1),m_l3(-1) {
+    int l1CacheSize, l2CacheSize, l3CacheSize;
+    queryCacheSizes(l1CacheSize, l2CacheSize, l3CacheSize);
+    m_l1 = manage_caching_sizes_helper(l1CacheSize, defaultL1CacheSize);
+    m_l2 = manage_caching_sizes_helper(l2CacheSize, defaultL2CacheSize);
+    m_l3 = manage_caching_sizes_helper(l3CacheSize, defaultL3CacheSize);
+  }
+
+  std::ptrdiff_t m_l1;
+  std::ptrdiff_t m_l2;
+  std::ptrdiff_t m_l3;
+};
+
+/** \internal */
+inline void manage_caching_sizes(Action action, std::ptrdiff_t* l1, std::ptrdiff_t* l2, std::ptrdiff_t* l3)
+{
+  static CacheSizes m_cacheSizes;
+
+  if(action==SetAction)
+  {
+    // set the cpu cache size and cache all block sizes from a global cache size in byte
+    eigen_internal_assert(l1!=0 && l2!=0);
+    m_cacheSizes.m_l1 = *l1;
+    m_cacheSizes.m_l2 = *l2;
+    m_cacheSizes.m_l3 = *l3;
+  }
+  else if(action==GetAction)
+  {
+    eigen_internal_assert(l1!=0 && l2!=0);
+    *l1 = m_cacheSizes.m_l1;
+    *l2 = m_cacheSizes.m_l2;
+    *l3 = m_cacheSizes.m_l3;
+  }
+  else
+  {
+    eigen_internal_assert(false);
+  }
+}
+
+/* Helper for computeProductBlockingSizes.
+ *
+ * Given a m x k times k x n matrix product of scalar types \c LhsScalar and \c RhsScalar,
+ * this function computes the blocking size parameters along the respective dimensions
+ * for matrix products and related algorithms. The blocking sizes depends on various
+ * parameters:
+ * - the L1 and L2 cache sizes,
+ * - the register level blocking sizes defined by gebp_traits,
+ * - the number of scalars that fit into a packet (when vectorization is enabled).
+ *
+ * \sa setCpuCacheSizes */
+
+template<typename LhsScalar, typename RhsScalar, int KcFactor, typename Index>
+void evaluateProductBlockingSizesHeuristic(Index& k, Index& m, Index& n, Index num_threads = 1)
+{
+  typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+  // Explanations:
+  // Let's recall that the product algorithms form mc x kc vertical panels A' on the lhs and
+  // kc x nc blocks B' on the rhs. B' has to fit into L2/L3 cache. Moreover, A' is processed
+  // per mr x kc horizontal small panels where mr is the blocking size along the m dimension
+  // at the register level. This small horizontal panel has to stay within L1 cache.
+  std::ptrdiff_t l1, l2, l3;
+  manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  #ifdef EIGEN_VECTORIZE_AVX512
+  // We need to find a rationale for that, but without this adjustment,
+  // performance with AVX512 is pretty bad, like -20% slower.
+  // One reason is that with increasing packet-size, the blocking size k
+  // has to become pretty small if we want that 1 lhs panel fit within L1.
+  // For instance, with the 3pX4 kernel and double, the size of the lhs+rhs panels are:
+  //   k*(3*64 + 4*8) Bytes, with l1=32kBytes, and k%8=0, we have k=144.
+  // This is quite small for a good reuse of the accumulation registers.
+  l1 *= 4;
+  #endif
+
+  if (num_threads > 1) {
+    typedef typename Traits::ResScalar ResScalar;
+    enum {
+      kdiv = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
+      ksub = Traits::mr * Traits::nr * sizeof(ResScalar),
+      kr = 8,
+      mr = Traits::mr,
+      nr = Traits::nr
+    };
+    // Increasing k gives us more time to prefetch the content of the "C"
+    // registers. However once the latency is hidden there is no point in
+    // increasing the value of k, so we'll cap it at 320 (value determined
+    // experimentally).
+    // To avoid that k vanishes, we make k_cache at least as big as kr
+    const Index k_cache = numext::maxi<Index>(kr, (numext::mini<Index>)((l1-ksub)/kdiv, 320));
+    if (k_cache < k) {
+      k = k_cache - (k_cache % kr);
+      eigen_internal_assert(k > 0);
+    }
+
+    const Index n_cache = (l2-l1) / (nr * sizeof(RhsScalar) * k);
+    const Index n_per_thread = numext::div_ceil(n, num_threads);
+    if (n_cache <= n_per_thread) {
+      // Don't exceed the capacity of the l2 cache.
+      eigen_internal_assert(n_cache >= static_cast<Index>(nr));
+      n = n_cache - (n_cache % nr);
+      eigen_internal_assert(n > 0);
+    } else {
+      n = (numext::mini<Index>)(n, (n_per_thread + nr - 1) - ((n_per_thread + nr - 1) % nr));
+    }
+
+    if (l3 > l2) {
+      // l3 is shared between all cores, so we'll give each thread its own chunk of l3.
+      const Index m_cache = (l3-l2) / (sizeof(LhsScalar) * k * num_threads);
+      const Index m_per_thread = numext::div_ceil(m, num_threads);
+      if(m_cache < m_per_thread && m_cache >= static_cast<Index>(mr)) {
+        m = m_cache - (m_cache % mr);
+        eigen_internal_assert(m > 0);
+      } else {
+        m = (numext::mini<Index>)(m, (m_per_thread + mr - 1) - ((m_per_thread + mr - 1) % mr));
+      }
+    }
+  }
+  else {
+    // In unit tests we do not want to use extra large matrices,
+    // so we reduce the cache size to check the blocking strategy is not flawed
+#ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
+    l1 = 9*1024;
+    l2 = 32*1024;
+    l3 = 512*1024;
+#endif
+
+    // Early return for small problems because the computation below are time consuming for small problems.
+    // Perhaps it would make more sense to consider k*n*m??
+    // Note that for very tiny problem, this function should be bypassed anyway
+    // because we use the coefficient-based implementation for them.
+    if((numext::maxi)(k,(numext::maxi)(m,n))<48)
+      return;
+
+    typedef typename Traits::ResScalar ResScalar;
+    enum {
+      k_peeling = 8,
+      k_div = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
+      k_sub = Traits::mr * Traits::nr * sizeof(ResScalar)
+    };
+
+    // ---- 1st level of blocking on L1, yields kc ----
+
+    // Blocking on the third dimension (i.e., k) is chosen so that an horizontal panel
+    // of size mr x kc of the lhs plus a vertical panel of kc x nr of the rhs both fits within L1 cache.
+    // We also include a register-level block of the result (mx x nr).
+    // (In an ideal world only the lhs panel would stay in L1)
+    // Moreover, kc has to be a multiple of 8 to be compatible with loop peeling, leading to a maximum blocking size of:
+    const Index max_kc = numext::maxi<Index>(((l1-k_sub)/k_div) & (~(k_peeling-1)),1);
+    const Index old_k = k;
+    if(k>max_kc)
+    {
+      // We are really blocking on the third dimension:
+      // -> reduce blocking size to make sure the last block is as large as possible
+      //    while keeping the same number of sweeps over the result.
+      k = (k%max_kc)==0 ? max_kc
+                        : max_kc - k_peeling * ((max_kc-1-(k%max_kc))/(k_peeling*(k/max_kc+1)));
+
+      eigen_internal_assert(((old_k/k) == (old_k/max_kc)) && "the number of sweeps has to remain the same");
+    }
+
+    // ---- 2nd level of blocking on max(L2,L3), yields nc ----
+
+    // TODO find a reliable way to get the actual amount of cache per core to use for 2nd level blocking, that is:
+    //      actual_l2 = max(l2, l3/nb_core_sharing_l3)
+    // The number below is quite conservative: it is better to underestimate the cache size rather than overestimating it)
+    // For instance, it corresponds to 6MB of L3 shared among 4 cores.
+    #ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
+    const Index actual_l2 = l3;
+    #else
+    const Index actual_l2 = 1572864; // == 1.5 MB
+    #endif
+
+    // Here, nc is chosen such that a block of kc x nc of the rhs fit within half of L2.
+    // The second half is implicitly reserved to access the result and lhs coefficients.
+    // When k<max_kc, then nc can arbitrarily growth. In practice, it seems to be fruitful
+    // to limit this growth: we bound nc to growth by a factor x1.5.
+    // However, if the entire lhs block fit within L1, then we are not going to block on the rows at all,
+    // and it becomes fruitful to keep the packed rhs blocks in L1 if there is enough remaining space.
+    Index max_nc;
+    const Index lhs_bytes = m * k * sizeof(LhsScalar);
+    const Index remaining_l1 = l1- k_sub - lhs_bytes;
+    if(remaining_l1 >= Index(Traits::nr*sizeof(RhsScalar))*k)
+    {
+      // L1 blocking
+      max_nc = remaining_l1 / (k*sizeof(RhsScalar));
+    }
+    else
+    {
+      // L2 blocking
+      max_nc = (3*actual_l2)/(2*2*max_kc*sizeof(RhsScalar));
+    }
+    // WARNING Below, we assume that Traits::nr is a power of two.
+    Index nc = numext::mini<Index>(actual_l2/(2*k*sizeof(RhsScalar)), max_nc) & (~(Traits::nr-1));
+    if(n>nc)
+    {
+      // We are really blocking over the columns:
+      // -> reduce blocking size to make sure the last block is as large as possible
+      //    while keeping the same number of sweeps over the packed lhs.
+      //    Here we allow one more sweep if this gives us a perfect match, thus the commented "-1"
+      n = (n%nc)==0 ? nc
+                    : (nc - Traits::nr * ((nc/*-1*/-(n%nc))/(Traits::nr*(n/nc+1))));
+    }
+    else if(old_k==k)
+    {
+      // So far, no blocking at all, i.e., kc==k, and nc==n.
+      // In this case, let's perform a blocking over the rows such that the packed lhs data is kept in cache L1/L2
+      // TODO: part of this blocking strategy is now implemented within the kernel itself, so the L1-based heuristic here should be obsolete.
+      Index problem_size = k*n*sizeof(LhsScalar);
+      Index actual_lm = actual_l2;
+      Index max_mc = m;
+      if(problem_size<=1024)
+      {
+        // problem is small enough to keep in L1
+        // Let's choose m such that lhs's block fit in 1/3 of L1
+        actual_lm = l1;
+      }
+      else if(l3!=0 && problem_size<=32768)
+      {
+        // we have both L2 and L3, and problem is small enough to be kept in L2
+        // Let's choose m such that lhs's block fit in 1/3 of L2
+        actual_lm = l2;
+        max_mc = (numext::mini<Index>)(576,max_mc);
+      }
+      Index mc = (numext::mini<Index>)(actual_lm/(3*k*sizeof(LhsScalar)), max_mc);
+      if (mc > Traits::mr) mc -= mc % Traits::mr;
+      else if (mc==0) return;
+      m = (m%mc)==0 ? mc
+                    : (mc - Traits::mr * ((mc/*-1*/-(m%mc))/(Traits::mr*(m/mc+1))));
+    }
+  }
+}
+
+template <typename Index>
+inline bool useSpecificBlockingSizes(Index& k, Index& m, Index& n)
+{
+#ifdef EIGEN_TEST_SPECIFIC_BLOCKING_SIZES
+  if (EIGEN_TEST_SPECIFIC_BLOCKING_SIZES) {
+    k = numext::mini<Index>(k, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_K);
+    m = numext::mini<Index>(m, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_M);
+    n = numext::mini<Index>(n, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_N);
+    return true;
+  }
+#else
+  EIGEN_UNUSED_VARIABLE(k)
+  EIGEN_UNUSED_VARIABLE(m)
+  EIGEN_UNUSED_VARIABLE(n)
+#endif
+  return false;
+}
+
+/** \brief Computes the blocking parameters for a m x k times k x n matrix product
+  *
+  * \param[in,out] k Input: the third dimension of the product. Output: the blocking size along the same dimension.
+  * \param[in,out] m Input: the number of rows of the left hand side. Output: the blocking size along the same dimension.
+  * \param[in,out] n Input: the number of columns of the right hand side. Output: the blocking size along the same dimension.
+  *
+  * Given a m x k times k x n matrix product of scalar types \c LhsScalar and \c RhsScalar,
+  * this function computes the blocking size parameters along the respective dimensions
+  * for matrix products and related algorithms.
+  *
+  * The blocking size parameters may be evaluated:
+  *   - either by a heuristic based on cache sizes;
+  *   - or using fixed prescribed values (for testing purposes).
+  *
+  * \sa setCpuCacheSizes */
+
+template<typename LhsScalar, typename RhsScalar, int KcFactor, typename Index>
+void computeProductBlockingSizes(Index& k, Index& m, Index& n, Index num_threads = 1)
+{
+  if (!useSpecificBlockingSizes(k, m, n)) {
+    evaluateProductBlockingSizesHeuristic<LhsScalar, RhsScalar, KcFactor, Index>(k, m, n, num_threads);
+  }
+}
+
+template<typename LhsScalar, typename RhsScalar, typename Index>
+inline void computeProductBlockingSizes(Index& k, Index& m, Index& n, Index num_threads = 1)
+{
+  computeProductBlockingSizes<LhsScalar,RhsScalar,1,Index>(k, m, n, num_threads);
+}
+
+template <typename RhsPacket, typename RhsPacketx4, int registers_taken>
+struct RhsPanelHelper {
+ private:
+  static const int remaining_registers = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS - registers_taken;
+ public:
+  typedef typename conditional<remaining_registers>=4, RhsPacketx4, RhsPacket>::type type;
+};
+
+template <typename Packet>
+struct QuadPacket
+{
+  Packet B_0, B1, B2, B3;
+  const Packet& get(const FixedInt<0>&) const { return B_0; }
+  const Packet& get(const FixedInt<1>&) const { return B1; }
+  const Packet& get(const FixedInt<2>&) const { return B2; }
+  const Packet& get(const FixedInt<3>&) const { return B3; }
+};
+
+template <int N, typename T1, typename T2, typename T3>
+struct packet_conditional { typedef T3 type; };
+
+template <typename T1, typename T2, typename T3>
+struct packet_conditional<GEBPPacketFull, T1, T2, T3> { typedef T1 type; };
+
+template <typename T1, typename T2, typename T3>
+struct packet_conditional<GEBPPacketHalf, T1, T2, T3> { typedef T2 type; };
+
+#define PACKET_DECL_COND_PREFIX(prefix, name, packet_size)         \
+  typedef typename packet_conditional<packet_size,                 \
+                                      typename packet_traits<name ## Scalar>::type, \
+                                      typename packet_traits<name ## Scalar>::half, \
+                                      typename unpacket_traits<typename packet_traits<name ## Scalar>::half>::half>::type \
+  prefix ## name ## Packet
+
+#define PACKET_DECL_COND(name, packet_size)                        \
+  typedef typename packet_conditional<packet_size,                 \
+                                      typename packet_traits<name ## Scalar>::type, \
+                                      typename packet_traits<name ## Scalar>::half, \
+                                      typename unpacket_traits<typename packet_traits<name ## Scalar>::half>::half>::type \
+  name ## Packet
+
+#define PACKET_DECL_COND_SCALAR_PREFIX(prefix, packet_size)        \
+  typedef typename packet_conditional<packet_size,                 \
+                                      typename packet_traits<Scalar>::type, \
+                                      typename packet_traits<Scalar>::half, \
+                                      typename unpacket_traits<typename packet_traits<Scalar>::half>::half>::type \
+  prefix ## ScalarPacket
+
+#define PACKET_DECL_COND_SCALAR(packet_size)                       \
+  typedef typename packet_conditional<packet_size,                 \
+                                      typename packet_traits<Scalar>::type, \
+                                      typename packet_traits<Scalar>::half, \
+                                      typename unpacket_traits<typename packet_traits<Scalar>::half>::half>::type \
+  ScalarPacket
+
+/* Vectorization logic
+ *  real*real: unpack rhs to constant packets, ...
+ * 
+ *  cd*cd : unpack rhs to (b_r,b_r), (b_i,b_i), mul to get (a_r b_r,a_i b_r) (a_r b_i,a_i b_i),
+ *          storing each res packet into two packets (2x2),
+ *          at the end combine them: swap the second and addsub them 
+ *  cf*cf : same but with 2x4 blocks
+ *  cplx*real : unpack rhs to constant packets, ...
+ *  real*cplx : load lhs as (a0,a0,a1,a1), and mul as usual
+ */
+template<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs, bool _ConjRhs, int Arch, int _PacketSize>
+class gebp_traits
+{
+public:
+  typedef _LhsScalar LhsScalar;
+  typedef _RhsScalar RhsScalar;
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  PACKET_DECL_COND_PREFIX(_, Lhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Rhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Res, _PacketSize);
+
+  enum {
+    ConjLhs = _ConjLhs,
+    ConjRhs = _ConjRhs,
+    Vectorizable = unpacket_traits<_LhsPacket>::vectorizable && unpacket_traits<_RhsPacket>::vectorizable,
+    LhsPacketSize = Vectorizable ? unpacket_traits<_LhsPacket>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<_RhsPacket>::size : 1,
+    ResPacketSize = Vectorizable ? unpacket_traits<_ResPacket>::size : 1,
+    
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+
+    // register block size along the N direction must be 1 or 4
+    nr = 4,
+
+    // register block size along the M direction (currently, this one cannot be modified)
+    default_mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*LhsPacketSize,
+#if defined(EIGEN_HAS_SINGLE_INSTRUCTION_MADD) && !defined(EIGEN_VECTORIZE_ALTIVEC) && !defined(EIGEN_VECTORIZE_VSX) \
+    && ((!EIGEN_COMP_MSVC) || (EIGEN_COMP_MSVC>=1914))
+    // we assume 16 registers or more
+    // See bug 992, if the scalar type is not vectorizable but that EIGEN_HAS_SINGLE_INSTRUCTION_MADD is defined,
+    // then using 3*LhsPacketSize triggers non-implemented paths in syrk.
+    // Bug 1515: MSVC prior to v19.14 yields to register spilling.
+    mr = Vectorizable ? 3*LhsPacketSize : default_mr,
+#else
+    mr = default_mr,
+#endif
+    
+    LhsProgress = LhsPacketSize,
+    RhsProgress = 1
+  };
+
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+  typedef LhsPacket LhsPacket4Packing;
+
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+  typedef ResPacket AccPacket;
+  
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p)
+  {
+    p = pset1<ResPacket>(ResScalar(0));
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    dest = pset1<RhsPacketType>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    pbroadcast4(b, dest.B_0, dest.B1, dest.B2, dest.B3);
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
+  {
+  }
+
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = ploadquad<RhsPacket>(b);
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = pload<LhsPacketType>(a);
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = ploadu<LhsPacketType>(a);
+  }
+
+  template<typename LhsPacketType, typename RhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp, const LaneIdType&) const
+  {
+    conj_helper<LhsPacketType,RhsPacketType,ConjLhs,ConjRhs> cj;
+    // It would be a lot cleaner to call pmadd all the time. Unfortunately if we
+    // let gcc allocate the register in which to store the result of the pmul
+    // (in the case where there is no FMA) gcc fails to figure out how to avoid
+    // spilling register.
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c = cj.pmadd(a,b,c);
+#else
+    tmp = b; tmp = cj.pmul(a,tmp); c = padd(c,tmp);
+#endif
+  }
+
+  template<typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp, const LaneIdType& lane) const
+  {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+
+  EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha, ResPacket& r) const
+  {
+    r = pmadd(c,alpha,r);
+  }
+  
+  template<typename ResPacketHalf>
+  EIGEN_STRONG_INLINE void acc(const ResPacketHalf& c, const ResPacketHalf& alpha, ResPacketHalf& r) const
+  {
+    r = pmadd(c,alpha,r);
+  }
+
+};
+
+template<typename RealScalar, bool _ConjLhs, int Arch, int _PacketSize>
+class gebp_traits<std::complex<RealScalar>, RealScalar, _ConjLhs, false, Arch, _PacketSize>
+{
+public:
+  typedef std::complex<RealScalar> LhsScalar;
+  typedef RealScalar RhsScalar;
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  PACKET_DECL_COND_PREFIX(_, Lhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Rhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Res, _PacketSize);
+
+  enum {
+    ConjLhs = _ConjLhs,
+    ConjRhs = false,
+    Vectorizable = unpacket_traits<_LhsPacket>::vectorizable && unpacket_traits<_RhsPacket>::vectorizable,
+    LhsPacketSize = Vectorizable ? unpacket_traits<_LhsPacket>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<_RhsPacket>::size : 1,
+    ResPacketSize = Vectorizable ? unpacket_traits<_ResPacket>::size : 1,
+    
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+    nr = 4,
+#if defined(EIGEN_HAS_SINGLE_INSTRUCTION_MADD) && !defined(EIGEN_VECTORIZE_ALTIVEC) && !defined(EIGEN_VECTORIZE_VSX)
+    // we assume 16 registers
+    mr = 3*LhsPacketSize,
+#else
+    mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*LhsPacketSize,
+#endif
+
+    LhsProgress = LhsPacketSize,
+    RhsProgress = 1
+  };
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+  typedef LhsPacket LhsPacket4Packing;
+
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+
+  typedef ResPacket AccPacket;
+
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p)
+  {
+    p = pset1<ResPacket>(ResScalar(0));
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    dest = pset1<RhsPacketType>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    pbroadcast4(b, dest.B_0, dest.B1, dest.B2, dest.B3);
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
+  {}
+  
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    loadRhsQuad_impl(b,dest, typename conditional<RhsPacketSize==16,true_type,false_type>::type());
+  }
+
+  EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket& dest, const true_type&) const
+  {
+    // FIXME we can do better!
+    // what we want here is a ploadheight
+    RhsScalar tmp[4] = {b[0],b[0],b[1],b[1]};
+    dest = ploadquad<RhsPacket>(tmp);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket& dest, const false_type&) const
+  {
+    eigen_internal_assert(RhsPacketSize<=8);
+    dest = pset1<RhsPacket>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = pload<LhsPacket>(a);
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = ploadu<LhsPacketType>(a);
+  }
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp, const LaneIdType&) const
+  {
+    madd_impl(a, b, c, tmp, typename conditional<Vectorizable,true_type,false_type>::type());
+  }
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void madd_impl(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp, const true_type&) const
+  {
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c.v = pmadd(a.v,b,c.v);
+#else
+    tmp = b; tmp = pmul(a.v,tmp); c.v = padd(c.v,tmp);
+#endif
+  }
+
+  EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/, const false_type&) const
+  {
+    c += a * b;
+  }
+
+  template<typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp, const LaneIdType& lane) const
+  {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+
+  template <typename ResPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void acc(const AccPacketType& c, const ResPacketType& alpha, ResPacketType& r) const
+  {
+    conj_helper<ResPacketType,ResPacketType,ConjLhs,false> cj;
+    r = cj.pmadd(c,alpha,r);
+  }
+
+protected:
+};
+
+template<typename Packet>
+struct DoublePacket
+{
+  Packet first;
+  Packet second;
+};
+
+template<typename Packet>
+DoublePacket<Packet> padd(const DoublePacket<Packet> &a, const DoublePacket<Packet> &b)
+{
+  DoublePacket<Packet> res;
+  res.first  = padd(a.first, b.first);
+  res.second = padd(a.second,b.second);
+  return res;
+}
+
+// note that for DoublePacket<RealPacket> the "4" in "downto4"
+// corresponds to the number of complexes, so it means "8"
+// it terms of real coefficients.
+
+template<typename Packet>
+const DoublePacket<Packet>&
+predux_half_dowto4(const DoublePacket<Packet> &a,
+                   typename enable_if<unpacket_traits<Packet>::size<=8>::type* = 0)
+{
+  return a;
+}
+
+template<typename Packet>
+DoublePacket<typename unpacket_traits<Packet>::half>
+predux_half_dowto4(const DoublePacket<Packet> &a,
+                   typename enable_if<unpacket_traits<Packet>::size==16>::type* = 0)
+{
+  // yes, that's pretty hackish :(
+  DoublePacket<typename unpacket_traits<Packet>::half> res;
+  typedef std::complex<typename unpacket_traits<Packet>::type> Cplx;
+  typedef typename packet_traits<Cplx>::type CplxPacket;
+  res.first  = predux_half_dowto4(CplxPacket(a.first)).v;
+  res.second = predux_half_dowto4(CplxPacket(a.second)).v;
+  return res;
+}
+
+// same here, "quad" actually means "8" in terms of real coefficients
+template<typename Scalar, typename RealPacket>
+void loadQuadToDoublePacket(const Scalar* b, DoublePacket<RealPacket>& dest,
+                            typename enable_if<unpacket_traits<RealPacket>::size<=8>::type* = 0)
+{
+  dest.first  = pset1<RealPacket>(numext::real(*b));
+  dest.second = pset1<RealPacket>(numext::imag(*b));
+}
+
+template<typename Scalar, typename RealPacket>
+void loadQuadToDoublePacket(const Scalar* b, DoublePacket<RealPacket>& dest,
+                            typename enable_if<unpacket_traits<RealPacket>::size==16>::type* = 0)
+{
+  // yes, that's pretty hackish too :(
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  RealScalar r[4] = {numext::real(b[0]), numext::real(b[0]), numext::real(b[1]), numext::real(b[1])};
+  RealScalar i[4] = {numext::imag(b[0]), numext::imag(b[0]), numext::imag(b[1]), numext::imag(b[1])};
+  dest.first  = ploadquad<RealPacket>(r);
+  dest.second = ploadquad<RealPacket>(i);
+}
+
+
+template<typename Packet> struct unpacket_traits<DoublePacket<Packet> > {
+  typedef DoublePacket<typename unpacket_traits<Packet>::half> half;
+};
+// template<typename Packet>
+// DoublePacket<Packet> pmadd(const DoublePacket<Packet> &a, const DoublePacket<Packet> &b)
+// {
+//   DoublePacket<Packet> res;
+//   res.first  = padd(a.first, b.first);
+//   res.second = padd(a.second,b.second);
+//   return res;
+// }
+
+template<typename RealScalar, bool _ConjLhs, bool _ConjRhs, int Arch, int _PacketSize>
+class gebp_traits<std::complex<RealScalar>, std::complex<RealScalar>, _ConjLhs, _ConjRhs, Arch, _PacketSize >
+{
+public:
+  typedef std::complex<RealScalar>  Scalar;
+  typedef std::complex<RealScalar>  LhsScalar;
+  typedef std::complex<RealScalar>  RhsScalar;
+  typedef std::complex<RealScalar>  ResScalar;
+  
+  PACKET_DECL_COND_PREFIX(_, Lhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Rhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Res, _PacketSize);
+  PACKET_DECL_COND(Real, _PacketSize);
+  PACKET_DECL_COND_SCALAR(_PacketSize);
+
+  enum {
+    ConjLhs = _ConjLhs,
+    ConjRhs = _ConjRhs,
+    Vectorizable = unpacket_traits<RealPacket>::vectorizable
+                && unpacket_traits<ScalarPacket>::vectorizable,
+    ResPacketSize   = Vectorizable ? unpacket_traits<_ResPacket>::size : 1,
+    LhsPacketSize = Vectorizable ? unpacket_traits<_LhsPacket>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<RhsScalar>::size : 1,
+    RealPacketSize  = Vectorizable ? unpacket_traits<RealPacket>::size : 1,
+
+    // FIXME: should depend on NumberOfRegisters
+    nr = 4,
+    mr = ResPacketSize,
+
+    LhsProgress = ResPacketSize,
+    RhsProgress = 1
+  };
+  
+  typedef DoublePacket<RealPacket>                 DoublePacketType;
+
+  typedef typename conditional<Vectorizable,ScalarPacket,Scalar>::type LhsPacket4Packing;
+  typedef typename conditional<Vectorizable,RealPacket,  Scalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,ScalarPacket,Scalar>::type ResPacket;
+  typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type AccPacket;
+
+  // this actualy holds 8 packets!
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+  
+  EIGEN_STRONG_INLINE void initAcc(Scalar& p) { p = Scalar(0); }
+
+  EIGEN_STRONG_INLINE void initAcc(DoublePacketType& p)
+  {
+    p.first   = pset1<RealPacket>(RealScalar(0));
+    p.second  = pset1<RealPacket>(RealScalar(0));
+  }
+
+  // Scalar path
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, ScalarPacket& dest) const
+  {
+    dest = pset1<ScalarPacket>(*b);
+  }
+
+  // Vectorized path
+  template<typename RealPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, DoublePacket<RealPacketType>& dest) const
+  {
+    dest.first  = pset1<RealPacketType>(numext::real(*b));
+    dest.second = pset1<RealPacketType>(numext::imag(*b));
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    loadRhs(b, dest.B_0);
+    loadRhs(b + 1, dest.B1);
+    loadRhs(b + 2, dest.B2);
+    loadRhs(b + 3, dest.B3);
+  }
+
+  // Scalar path
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, ScalarPacket& dest) const
+  {
+    loadRhs(b, dest);
+  }
+
+  // Vectorized path
+  template<typename RealPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, DoublePacket<RealPacketType>& dest) const
+  {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const {}
+  
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, ResPacket& dest) const
+  {
+    loadRhs(b,dest);
+  }
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, DoublePacketType& dest) const
+  {
+    loadQuadToDoublePacket(b,dest);
+  }
+
+  // nothing special here
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = pload<LhsPacket>((const typename unpacket_traits<LhsPacket>::type*)(a));
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = ploadu<LhsPacketType>((const typename unpacket_traits<LhsPacketType>::type*)(a));
+  }
+
+  template<typename LhsPacketType, typename RhsPacketType, typename ResPacketType, typename TmpType, typename LaneIdType>
+  EIGEN_STRONG_INLINE
+  typename enable_if<!is_same<RhsPacketType,RhsPacketx4>::value>::type
+  madd(const LhsPacketType& a, const RhsPacketType& b, DoublePacket<ResPacketType>& c, TmpType& /*tmp*/, const LaneIdType&) const
+  {
+    c.first   = padd(pmul(a,b.first), c.first);
+    c.second  = padd(pmul(a,b.second),c.second);
+  }
+
+  template<typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, ResPacket& c, RhsPacket& /*tmp*/, const LaneIdType&) const
+  {
+    c = cj.pmadd(a,b,c);
+  }
+
+  template<typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp, const LaneIdType& lane) const
+  {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+  
+  EIGEN_STRONG_INLINE void acc(const Scalar& c, const Scalar& alpha, Scalar& r) const { r += alpha * c; }
+  
+  template<typename RealPacketType, typename ResPacketType>
+  EIGEN_STRONG_INLINE void acc(const DoublePacket<RealPacketType>& c, const ResPacketType& alpha, ResPacketType& r) const
+  {
+    // assemble c
+    ResPacketType tmp;
+    if((!ConjLhs)&&(!ConjRhs))
+    {
+      tmp = pcplxflip(pconj(ResPacketType(c.second)));
+      tmp = padd(ResPacketType(c.first),tmp);
+    }
+    else if((!ConjLhs)&&(ConjRhs))
+    {
+      tmp = pconj(pcplxflip(ResPacketType(c.second)));
+      tmp = padd(ResPacketType(c.first),tmp);
+    }
+    else if((ConjLhs)&&(!ConjRhs))
+    {
+      tmp = pcplxflip(ResPacketType(c.second));
+      tmp = padd(pconj(ResPacketType(c.first)),tmp);
+    }
+    else if((ConjLhs)&&(ConjRhs))
+    {
+      tmp = pcplxflip(ResPacketType(c.second));
+      tmp = psub(pconj(ResPacketType(c.first)),tmp);
+    }
+    
+    r = pmadd(tmp,alpha,r);
+  }
+
+protected:
+  conj_helper<LhsScalar,RhsScalar,ConjLhs,ConjRhs> cj;
+};
+
+template<typename RealScalar, bool _ConjRhs, int Arch, int _PacketSize>
+class gebp_traits<RealScalar, std::complex<RealScalar>, false, _ConjRhs, Arch, _PacketSize >
+{
+public:
+  typedef std::complex<RealScalar>  Scalar;
+  typedef RealScalar  LhsScalar;
+  typedef Scalar      RhsScalar;
+  typedef Scalar      ResScalar;
+
+  PACKET_DECL_COND_PREFIX(_, Lhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Rhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Res, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Real, _PacketSize);
+  PACKET_DECL_COND_SCALAR_PREFIX(_, _PacketSize);
+
+#undef PACKET_DECL_COND_SCALAR_PREFIX
+#undef PACKET_DECL_COND_PREFIX
+#undef PACKET_DECL_COND_SCALAR
+#undef PACKET_DECL_COND
+
+  enum {
+    ConjLhs = false,
+    ConjRhs = _ConjRhs,
+    Vectorizable = unpacket_traits<_RealPacket>::vectorizable
+                && unpacket_traits<_ScalarPacket>::vectorizable,
+    LhsPacketSize = Vectorizable ? unpacket_traits<_LhsPacket>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<_RhsPacket>::size : 1,
+    ResPacketSize = Vectorizable ? unpacket_traits<_ResPacket>::size : 1,
+    
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+    // FIXME: should depend on NumberOfRegisters
+    nr = 4,
+    mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*ResPacketSize,
+
+    LhsProgress = ResPacketSize,
+    RhsProgress = 1
+  };
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+  typedef LhsPacket LhsPacket4Packing;
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+  typedef ResPacket AccPacket;
+
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p)
+  {
+    p = pset1<ResPacket>(ResScalar(0));
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    dest = pset1<RhsPacketType>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const
+  {
+    pbroadcast4(b, dest.B_0, dest.B1, dest.B2, dest.B3);
+  }
+
+  template<typename RhsPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacketType& dest) const
+  {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
+  {}
+
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
+  {
+    dest = ploaddup<LhsPacket>(a);
+  }
+  
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const
+  {
+    dest = ploadquad<RhsPacket>(b);
+  }
+
+  template<typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
+  {
+    dest = ploaddup<LhsPacketType>(a);
+  }
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp, const LaneIdType&) const
+  {
+    madd_impl(a, b, c, tmp, typename conditional<Vectorizable,true_type,false_type>::type());
+  }
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void madd_impl(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp, const true_type&) const
+  {
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c.v = pmadd(a,b.v,c.v);
+#else
+    tmp = b; tmp.v = pmul(a,tmp.v); c = padd(c,tmp);
+#endif
+    
+  }
+
+  EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/, const false_type&) const
+  {
+    c += a * b;
+  }
+
+  template<typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp, const LaneIdType& lane) const
+  {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+
+  template <typename ResPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void acc(const AccPacketType& c, const ResPacketType& alpha, ResPacketType& r) const
+  {
+    conj_helper<ResPacketType,ResPacketType,false,ConjRhs> cj;
+    r = cj.pmadd(alpha,c,r);
+  }
+
+protected:
+
+};
+
+/* optimized General packed Block * packed Panel product kernel
+ *
+ * Mixing type logic: C += A * B
+ *  |  A  |  B  | comments
+ *  |real |cplx | no vectorization yet, would require to pack A with duplication
+ *  |cplx |real | easy vectorization
+ */
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel
+{
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Architecture::Target> Traits;
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Architecture::Target,GEBPPacketHalf> HalfTraits;
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Architecture::Target,GEBPPacketQuarter> QuarterTraits;
+  
+  typedef typename Traits::ResScalar ResScalar;
+  typedef typename Traits::LhsPacket LhsPacket;
+  typedef typename Traits::RhsPacket RhsPacket;
+  typedef typename Traits::ResPacket ResPacket;
+  typedef typename Traits::AccPacket AccPacket;
+  typedef typename Traits::RhsPacketx4 RhsPacketx4;
+
+  typedef typename RhsPanelHelper<RhsPacket, RhsPacketx4, 15>::type RhsPanel15;
+
+  typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Architecture::Target> SwappedTraits;
+
+  typedef typename SwappedTraits::ResScalar SResScalar;
+  typedef typename SwappedTraits::LhsPacket SLhsPacket;
+  typedef typename SwappedTraits::RhsPacket SRhsPacket;
+  typedef typename SwappedTraits::ResPacket SResPacket;
+  typedef typename SwappedTraits::AccPacket SAccPacket;
+
+  typedef typename HalfTraits::LhsPacket LhsPacketHalf;
+  typedef typename HalfTraits::RhsPacket RhsPacketHalf;
+  typedef typename HalfTraits::ResPacket ResPacketHalf;
+  typedef typename HalfTraits::AccPacket AccPacketHalf;
+
+  typedef typename QuarterTraits::LhsPacket LhsPacketQuarter;
+  typedef typename QuarterTraits::RhsPacket RhsPacketQuarter;
+  typedef typename QuarterTraits::ResPacket ResPacketQuarter;
+  typedef typename QuarterTraits::AccPacket AccPacketQuarter;
+
+  typedef typename DataMapper::LinearMapper LinearMapper;
+
+  enum {
+    Vectorizable  = Traits::Vectorizable,
+    LhsProgress   = Traits::LhsProgress,
+    LhsProgressHalf      = HalfTraits::LhsProgress,
+    LhsProgressQuarter   = QuarterTraits::LhsProgress,
+    RhsProgress   = Traits::RhsProgress,
+    RhsProgressHalf      = HalfTraits::RhsProgress,
+    RhsProgressQuarter   = QuarterTraits::RhsProgress,
+    ResPacketSize = Traits::ResPacketSize
+  };
+
+  EIGEN_DONT_INLINE
+  void operator()(const DataMapper& res, const LhsScalar* blockA, const RhsScalar* blockB,
+                  Index rows, Index depth, Index cols, ResScalar alpha,
+                  Index strideA=-1, Index strideB=-1, Index offsetA=0, Index offsetB=0);
+};
+
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs,
+int SwappedLhsProgress = gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Architecture::Target>::LhsProgress>
+struct last_row_process_16_packets
+{
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Architecture::Target> Traits;
+  typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Architecture::Target> SwappedTraits;
+
+  typedef typename Traits::ResScalar ResScalar;
+  typedef typename SwappedTraits::LhsPacket SLhsPacket;
+  typedef typename SwappedTraits::RhsPacket SRhsPacket;
+  typedef typename SwappedTraits::ResPacket SResPacket;
+  typedef typename SwappedTraits::AccPacket SAccPacket;
+
+  EIGEN_STRONG_INLINE void operator()(const DataMapper& res, SwappedTraits &straits, const LhsScalar* blA,
+                  const RhsScalar* blB, Index depth, const Index endk, Index i, Index j2,
+                  ResScalar alpha, SAccPacket &C0)
+    {
+      EIGEN_UNUSED_VARIABLE(res);
+      EIGEN_UNUSED_VARIABLE(straits);
+      EIGEN_UNUSED_VARIABLE(blA);
+      EIGEN_UNUSED_VARIABLE(blB);
+      EIGEN_UNUSED_VARIABLE(depth);
+      EIGEN_UNUSED_VARIABLE(endk);
+      EIGEN_UNUSED_VARIABLE(i);
+      EIGEN_UNUSED_VARIABLE(j2);
+      EIGEN_UNUSED_VARIABLE(alpha);
+      EIGEN_UNUSED_VARIABLE(C0);
+    }
+};
+
+
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct last_row_process_16_packets<LhsScalar, RhsScalar, Index, DataMapper,  mr,  nr, ConjugateLhs,  ConjugateRhs, 16> {
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Architecture::Target> Traits;
+  typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Architecture::Target> SwappedTraits;
+
+  typedef typename Traits::ResScalar ResScalar;
+  typedef typename SwappedTraits::LhsPacket SLhsPacket;
+  typedef typename SwappedTraits::RhsPacket SRhsPacket;
+  typedef typename SwappedTraits::ResPacket SResPacket;
+  typedef typename SwappedTraits::AccPacket SAccPacket;
+
+  EIGEN_STRONG_INLINE void operator()(const DataMapper& res, SwappedTraits &straits, const LhsScalar* blA,
+                  const RhsScalar* blB, Index depth, const Index endk, Index i, Index j2,
+                  ResScalar alpha, SAccPacket &C0)
+  {
+    typedef typename unpacket_traits<typename unpacket_traits<SResPacket>::half>::half SResPacketQuarter;
+    typedef typename unpacket_traits<typename unpacket_traits<SLhsPacket>::half>::half SLhsPacketQuarter;
+    typedef typename unpacket_traits<typename unpacket_traits<SRhsPacket>::half>::half SRhsPacketQuarter;
+    typedef typename unpacket_traits<typename unpacket_traits<SAccPacket>::half>::half SAccPacketQuarter;
+
+    SResPacketQuarter R = res.template gatherPacket<SResPacketQuarter>(i, j2);
+    SResPacketQuarter alphav = pset1<SResPacketQuarter>(alpha);
+
+    if (depth - endk > 0)
+      {
+	// We have to handle the last row(s) of the rhs, which
+	// correspond to a half-packet
+	SAccPacketQuarter c0 = predux_half_dowto4(predux_half_dowto4(C0));
+
+	for (Index kk = endk; kk < depth; kk++)
+	  {
+	    SLhsPacketQuarter a0;
+	    SRhsPacketQuarter b0;
+	    straits.loadLhsUnaligned(blB, a0);
+	    straits.loadRhs(blA, b0);
+	    straits.madd(a0,b0,c0,b0, fix<0>);
+	    blB += SwappedTraits::LhsProgress/4;
+	    blA += 1;
+	  }
+	straits.acc(c0, alphav, R);
+      }
+    else
+      {
+	straits.acc(predux_half_dowto4(predux_half_dowto4(C0)), alphav, R);
+      }
+    res.scatterPacket(i, j2, R);
+  }
+};
+
+template<int nr, Index LhsProgress, Index RhsProgress, typename LhsScalar, typename RhsScalar, typename ResScalar, typename AccPacket, typename LhsPacket, typename RhsPacket, typename ResPacket, typename GEBPTraits, typename LinearMapper, typename DataMapper>
+struct lhs_process_one_packet
+{
+  typedef typename GEBPTraits::RhsPacketx4 RhsPacketx4;
+
+  EIGEN_STRONG_INLINE void peeled_kc_onestep(Index K, const LhsScalar* blA, const RhsScalar* blB, GEBPTraits traits, LhsPacket *A0, RhsPacketx4 *rhs_panel, RhsPacket *T0, AccPacket *C0, AccPacket *C1, AccPacket *C2, AccPacket *C3)
+  {
+    EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1X4");
+    EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!");
+    traits.loadLhs(&blA[(0+1*K)*LhsProgress], *A0);
+    traits.loadRhs(&blB[(0+4*K)*RhsProgress], *rhs_panel);
+    traits.madd(*A0, *rhs_panel, *C0, *T0, fix<0>);
+    traits.madd(*A0, *rhs_panel, *C1, *T0, fix<1>);
+    traits.madd(*A0, *rhs_panel, *C2, *T0, fix<2>);
+    traits.madd(*A0, *rhs_panel, *C3, *T0, fix<3>);
+    #if EIGEN_GNUC_AT_LEAST(6,0) && defined(EIGEN_VECTORIZE_SSE)
+    __asm__  ("" : "+x,m" (*A0));
+    #endif
+    EIGEN_ASM_COMMENT("end step of gebp micro kernel 1X4");
+  }
+
+  EIGEN_STRONG_INLINE void operator()(
+    const DataMapper& res, const LhsScalar* blockA, const RhsScalar* blockB, ResScalar alpha,
+    Index peelStart, Index peelEnd, Index strideA, Index strideB, Index offsetA, Index offsetB,
+    int prefetch_res_offset, Index peeled_kc, Index pk, Index cols, Index depth, Index packet_cols4)
+  {
+    GEBPTraits traits;
+
+    // loops on each largest micro horizontal panel of lhs
+    // (LhsProgress x depth)
+    for(Index i=peelStart; i<peelEnd; i+=LhsProgress)
+    {
+      // loops on each largest micro vertical panel of rhs (depth * nr)
+      for(Index j2=0; j2<packet_cols4; j2+=nr)
+      {
+        // We select a LhsProgress x nr micro block of res
+        // which is entirely stored into 1 x nr registers.
+
+        const LhsScalar* blA = &blockA[i*strideA+offsetA*(LhsProgress)];
+        prefetch(&blA[0]);
+
+        // gets res block as register
+        AccPacket C0, C1, C2, C3;
+        traits.initAcc(C0);
+        traits.initAcc(C1);
+        traits.initAcc(C2);
+        traits.initAcc(C3);
+        // To improve instruction pipelining, let's double the accumulation registers:
+        //  even k will accumulate in C*, while odd k will accumulate in D*.
+        // This trick is crutial to get good performance with FMA, otherwise it is 
+        // actually faster to perform separated MUL+ADD because of a naturally
+        // better instruction-level parallelism.
+        AccPacket D0, D1, D2, D3;
+        traits.initAcc(D0);
+        traits.initAcc(D1);
+        traits.initAcc(D2);
+        traits.initAcc(D3);
+
+        LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
+        LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
+        LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
+        LinearMapper r3 = res.getLinearMapper(i, j2 + 3);
+
+        r0.prefetch(prefetch_res_offset);
+        r1.prefetch(prefetch_res_offset);
+        r2.prefetch(prefetch_res_offset);
+        r3.prefetch(prefetch_res_offset);
+
+        // performs "inner" products
+        const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+        prefetch(&blB[0]);
+        LhsPacket A0, A1;
+
+        for(Index k=0; k<peeled_kc; k+=pk)
+        {
+          EIGEN_ASM_COMMENT("begin gebp micro kernel 1/half/quarterX4");
+          RhsPacketx4 rhs_panel;
+          RhsPacket T0;
+
+          internal::prefetch(blB+(48+0));
+          peeled_kc_onestep(0, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
+          peeled_kc_onestep(1, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
+          peeled_kc_onestep(2, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
+          peeled_kc_onestep(3, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
+          internal::prefetch(blB+(48+16));
+          peeled_kc_onestep(4, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
+          peeled_kc_onestep(5, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
+          peeled_kc_onestep(6, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
+          peeled_kc_onestep(7, blA, blB, traits, &A1, &rhs_panel, &T0, &D0, &D1, &D2, &D3);
+
+          blB += pk*4*RhsProgress;
+          blA += pk*LhsProgress;
+
+          EIGEN_ASM_COMMENT("end gebp micro kernel 1/half/quarterX4");
+        }
+        C0 = padd(C0,D0);
+        C1 = padd(C1,D1);
+        C2 = padd(C2,D2);
+        C3 = padd(C3,D3);
+
+        // process remaining peeled loop
+        for(Index k=peeled_kc; k<depth; k++)
+        {
+          RhsPacketx4 rhs_panel;
+          RhsPacket T0;
+          peeled_kc_onestep(0, blA, blB, traits, &A0, &rhs_panel, &T0, &C0, &C1, &C2, &C3);
+          blB += 4*RhsProgress;
+          blA += LhsProgress;
+        }
+
+        ResPacket R0, R1;
+        ResPacket alphav = pset1<ResPacket>(alpha);
+
+        R0 = r0.template loadPacket<ResPacket>(0);
+        R1 = r1.template loadPacket<ResPacket>(0);
+        traits.acc(C0, alphav, R0);
+        traits.acc(C1,  alphav, R1);
+        r0.storePacket(0, R0);
+        r1.storePacket(0, R1);
+
+        R0 = r2.template loadPacket<ResPacket>(0);
+        R1 = r3.template loadPacket<ResPacket>(0);
+        traits.acc(C2,  alphav, R0);
+        traits.acc(C3,  alphav, R1);
+        r2.storePacket(0, R0);
+        r3.storePacket(0, R1);
+      }
+
+      // Deal with remaining columns of the rhs
+      for(Index j2=packet_cols4; j2<cols; j2++)
+      {
+        // One column at a time
+        const LhsScalar* blA = &blockA[i*strideA+offsetA*(LhsProgress)];
+        prefetch(&blA[0]);
+
+        // gets res block as register
+        AccPacket C0;
+        traits.initAcc(C0);
+
+        LinearMapper r0 = res.getLinearMapper(i, j2);
+
+        // performs "inner" products
+        const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+        LhsPacket A0;
+
+        for(Index k= 0; k<peeled_kc; k+=pk)
+        {
+          EIGEN_ASM_COMMENT("begin gebp micro kernel 1/half/quarterX1");
+          RhsPacket B_0;
+
+#define EIGEN_GEBGP_ONESTEP(K)                                          \
+	      do {                                                      \
+		EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1/half/quarterX1"); \
+		EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+    /* FIXME: why unaligned???? */ \
+		traits.loadLhsUnaligned(&blA[(0+1*K)*LhsProgress], A0); \
+		traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);		\
+		traits.madd(A0, B_0, C0, B_0, fix<0>);				\
+		EIGEN_ASM_COMMENT("end step of gebp micro kernel 1/half/quarterX1"); \
+	      } while(false);
+
+          EIGEN_GEBGP_ONESTEP(0);
+          EIGEN_GEBGP_ONESTEP(1);
+          EIGEN_GEBGP_ONESTEP(2);
+          EIGEN_GEBGP_ONESTEP(3);
+          EIGEN_GEBGP_ONESTEP(4);
+          EIGEN_GEBGP_ONESTEP(5);
+          EIGEN_GEBGP_ONESTEP(6);
+          EIGEN_GEBGP_ONESTEP(7);
+
+          blB += pk*RhsProgress;
+          blA += pk*LhsProgress;
+
+          EIGEN_ASM_COMMENT("end gebp micro kernel 1/half/quarterX1");
+        }
+
+        // process remaining peeled loop
+        for(Index k=peeled_kc; k<depth; k++)
+        {
+          RhsPacket B_0;
+          EIGEN_GEBGP_ONESTEP(0);
+          blB += RhsProgress;
+          blA += LhsProgress;
+        }
+#undef EIGEN_GEBGP_ONESTEP
+        ResPacket R0;
+        ResPacket alphav = pset1<ResPacket>(alpha);
+        R0 = r0.template loadPacket<ResPacket>(0);
+        traits.acc(C0, alphav, R0);
+        r0.storePacket(0, R0);
+      }
+    }
+  }
+};
+
+template<int nr, Index LhsProgress, Index RhsProgress, typename LhsScalar, typename RhsScalar, typename ResScalar, typename AccPacket, typename LhsPacket, typename RhsPacket, typename ResPacket, typename GEBPTraits, typename LinearMapper, typename DataMapper>
+struct lhs_process_fraction_of_packet : lhs_process_one_packet<nr, LhsProgress, RhsProgress, LhsScalar, RhsScalar, ResScalar, AccPacket, LhsPacket, RhsPacket, ResPacket, GEBPTraits, LinearMapper, DataMapper>
+{
+
+EIGEN_STRONG_INLINE void peeled_kc_onestep(Index K, const LhsScalar* blA, const RhsScalar* blB, GEBPTraits traits, LhsPacket *A0, RhsPacket *B_0, RhsPacket *B1, RhsPacket *B2, RhsPacket *B3, AccPacket *C0, AccPacket *C1, AccPacket *C2, AccPacket *C3)
+  {
+        EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1X4");
+        EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!");
+        traits.loadLhsUnaligned(&blA[(0+1*K)*(LhsProgress)], *A0);
+        traits.broadcastRhs(&blB[(0+4*K)*RhsProgress], *B_0, *B1, *B2, *B3);
+        traits.madd(*A0, *B_0, *C0, *B_0);
+        traits.madd(*A0, *B1,  *C1, *B1);
+        traits.madd(*A0, *B2,  *C2, *B2);
+        traits.madd(*A0, *B3,  *C3, *B3);
+        EIGEN_ASM_COMMENT("end step of gebp micro kernel 1X4");
+  }
+};
+
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+EIGEN_DONT_INLINE
+void gebp_kernel<LhsScalar,RhsScalar,Index,DataMapper,mr,nr,ConjugateLhs,ConjugateRhs>
+  ::operator()(const DataMapper& res, const LhsScalar* blockA, const RhsScalar* blockB,
+               Index rows, Index depth, Index cols, ResScalar alpha,
+               Index strideA, Index strideB, Index offsetA, Index offsetB)
+  {
+    Traits traits;
+    SwappedTraits straits;
+    
+    if(strideA==-1) strideA = depth;
+    if(strideB==-1) strideB = depth;
+    conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
+    Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+    const Index peeled_mc3 = mr>=3*Traits::LhsProgress ? (rows/(3*LhsProgress))*(3*LhsProgress) : 0;
+    const Index peeled_mc2 = mr>=2*Traits::LhsProgress ? peeled_mc3+((rows-peeled_mc3)/(2*LhsProgress))*(2*LhsProgress) : 0;
+    const Index peeled_mc1 = mr>=1*Traits::LhsProgress ? peeled_mc2+((rows-peeled_mc2)/(1*LhsProgress))*(1*LhsProgress) : 0;
+    const Index peeled_mc_half = mr>=LhsProgressHalf ? peeled_mc1+((rows-peeled_mc1)/(LhsProgressHalf))*(LhsProgressHalf) : 0;
+    const Index peeled_mc_quarter = mr>=LhsProgressQuarter ? peeled_mc_half+((rows-peeled_mc_half)/(LhsProgressQuarter))*(LhsProgressQuarter) : 0;
+    enum { pk = 8 }; // NOTE Such a large peeling factor is important for large matrices (~ +5% when >1000 on Haswell)
+    const Index peeled_kc  = depth & ~(pk-1);
+    const int prefetch_res_offset = 32/sizeof(ResScalar);    
+//     const Index depth2     = depth & ~1;
+
+    //---------- Process 3 * LhsProgress rows at once ----------
+    // This corresponds to 3*LhsProgress x nr register blocks.
+    // Usually, make sense only with FMA
+    if(mr>=3*Traits::LhsProgress)
+    {
+      // Here, the general idea is to loop on each largest micro horizontal panel of the lhs (3*Traits::LhsProgress x depth)
+      // and on each largest micro vertical panel of the rhs (depth * nr).
+      // Blocking sizes, i.e., 'depth' has been computed so that the micro horizontal panel of the lhs fit in L1.
+      // However, if depth is too small, we can extend the number of rows of these horizontal panels.
+      // This actual number of rows is computed as follow:
+      const Index l1 = defaultL1CacheSize; // in Bytes, TODO, l1 should be passed to this function.
+      // The max(1, ...) here is needed because we may be using blocking params larger than what our known l1 cache size
+      // suggests we should be using: either because our known l1 cache size is inaccurate (e.g. on Android, we can only guess),
+      // or because we are testing specific blocking sizes.
+      const Index actual_panel_rows = (3*LhsProgress) * std::max<Index>(1,( (l1 - sizeof(ResScalar)*mr*nr - depth*nr*sizeof(RhsScalar)) / (depth * sizeof(LhsScalar) * 3*LhsProgress) ));
+      for(Index i1=0; i1<peeled_mc3; i1+=actual_panel_rows)
+      {
+        const Index actual_panel_end = (std::min)(i1+actual_panel_rows, peeled_mc3);
+        for(Index j2=0; j2<packet_cols4; j2+=nr)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=3*LhsProgress)
+          {
+          
+          // We selected a 3*Traits::LhsProgress x nr micro block of res which is entirely
+          // stored into 3 x nr registers.
+          
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(3*LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C1, C2,  C3,
+                    C4, C5, C6,  C7,
+                    C8, C9, C10, C11;
+          traits.initAcc(C0);  traits.initAcc(C1);  traits.initAcc(C2);  traits.initAcc(C3);
+          traits.initAcc(C4);  traits.initAcc(C5);  traits.initAcc(C6);  traits.initAcc(C7);
+          traits.initAcc(C8);  traits.initAcc(C9);  traits.initAcc(C10); traits.initAcc(C11);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
+          LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
+          LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
+          LinearMapper r3 = res.getLinearMapper(i, j2 + 3);
+
+          r0.prefetch(0);
+          r1.prefetch(0);
+          r2.prefetch(0);
+          r3.prefetch(0);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+          prefetch(&blB[0]);
+          LhsPacket A0, A1;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 3pX4");
+            // 15 registers are taken (12 for acc, 2 for lhs).
+            RhsPanel15 rhs_panel;
+            RhsPacket T0;
+            LhsPacket A2;
+            #if EIGEN_COMP_GNUC_STRICT && EIGEN_ARCH_ARM64 && defined(EIGEN_VECTORIZE_NEON) && !(EIGEN_GNUC_AT_LEAST(9,0))
+            // see http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1633
+            // without this workaround A0, A1, and A2 are loaded in the same register,
+            // which is not good for pipelining
+            #define EIGEN_GEBP_3PX4_REGISTER_ALLOC_WORKAROUND __asm__  ("" : "+w,m" (A0), "+w,m" (A1), "+w,m" (A2));
+            #else
+            #define EIGEN_GEBP_3PX4_REGISTER_ALLOC_WORKAROUND
+            #endif
+#define EIGEN_GEBP_ONESTEP(K)                                                     \
+            do {                                                                  \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 3pX4");          \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              internal::prefetch(blA + (3 * K + 16) * LhsProgress);               \
+              if (EIGEN_ARCH_ARM || EIGEN_ARCH_MIPS) {                            \
+                internal::prefetch(blB + (4 * K + 16) * RhsProgress);             \
+              } /* Bug 953 */                                                     \
+              traits.loadLhs(&blA[(0 + 3 * K) * LhsProgress], A0);                \
+              traits.loadLhs(&blA[(1 + 3 * K) * LhsProgress], A1);                \
+              traits.loadLhs(&blA[(2 + 3 * K) * LhsProgress], A2);                \
+              EIGEN_GEBP_3PX4_REGISTER_ALLOC_WORKAROUND \
+              traits.loadRhs(blB + (0+4*K) * Traits::RhsProgress, rhs_panel);     \
+              traits.madd(A0, rhs_panel, C0, T0, fix<0>);                         \
+              traits.madd(A1, rhs_panel, C4, T0, fix<0>);                         \
+              traits.madd(A2, rhs_panel, C8, T0, fix<0>);                         \
+              traits.updateRhs(blB + (1+4*K) * Traits::RhsProgress, rhs_panel);   \
+              traits.madd(A0, rhs_panel, C1, T0, fix<1>);                         \
+              traits.madd(A1, rhs_panel, C5, T0, fix<1>);                         \
+              traits.madd(A2, rhs_panel, C9, T0, fix<1>);                         \
+              traits.updateRhs(blB + (2+4*K) * Traits::RhsProgress, rhs_panel);   \
+              traits.madd(A0, rhs_panel, C2, T0, fix<2>);                         \
+              traits.madd(A1, rhs_panel, C6, T0, fix<2>);                         \
+              traits.madd(A2, rhs_panel, C10, T0, fix<2>);                        \
+              traits.updateRhs(blB + (3+4*K) * Traits::RhsProgress, rhs_panel);   \
+              traits.madd(A0, rhs_panel, C3, T0, fix<3>);                         \
+              traits.madd(A1, rhs_panel, C7, T0, fix<3>);                         \
+              traits.madd(A2, rhs_panel, C11, T0, fix<3>);                        \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 3pX4");            \
+            } while (false)
+
+            internal::prefetch(blB);
+            EIGEN_GEBP_ONESTEP(0);
+            EIGEN_GEBP_ONESTEP(1);
+            EIGEN_GEBP_ONESTEP(2);
+            EIGEN_GEBP_ONESTEP(3);
+            EIGEN_GEBP_ONESTEP(4);
+            EIGEN_GEBP_ONESTEP(5);
+            EIGEN_GEBP_ONESTEP(6);
+            EIGEN_GEBP_ONESTEP(7);
+
+            blB += pk*4*RhsProgress;
+            blA += pk*3*Traits::LhsProgress;
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 3pX4");
+          }
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPanel15 rhs_panel;
+            RhsPacket T0;
+            LhsPacket A2;
+            EIGEN_GEBP_ONESTEP(0);
+            blB += 4*RhsProgress;
+            blA += 3*Traits::LhsProgress;
+          }
+
+#undef EIGEN_GEBP_ONESTEP
+
+          ResPacket R0, R1, R2;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r0.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r0.template loadPacket<ResPacket>(2 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          traits.acc(C8, alphav, R2);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          r0.storePacket(2 * Traits::ResPacketSize, R2);
+
+          R0 = r1.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r1.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r1.template loadPacket<ResPacket>(2 * Traits::ResPacketSize);
+          traits.acc(C1, alphav, R0);
+          traits.acc(C5, alphav, R1);
+          traits.acc(C9, alphav, R2);
+          r1.storePacket(0 * Traits::ResPacketSize, R0);
+          r1.storePacket(1 * Traits::ResPacketSize, R1);
+          r1.storePacket(2 * Traits::ResPacketSize, R2);
+
+          R0 = r2.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r2.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r2.template loadPacket<ResPacket>(2 * Traits::ResPacketSize);
+          traits.acc(C2, alphav, R0);
+          traits.acc(C6, alphav, R1);
+          traits.acc(C10, alphav, R2);
+          r2.storePacket(0 * Traits::ResPacketSize, R0);
+          r2.storePacket(1 * Traits::ResPacketSize, R1);
+          r2.storePacket(2 * Traits::ResPacketSize, R2);
+
+          R0 = r3.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r3.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r3.template loadPacket<ResPacket>(2 * Traits::ResPacketSize);
+          traits.acc(C3, alphav, R0);
+          traits.acc(C7, alphav, R1);
+          traits.acc(C11, alphav, R2);
+          r3.storePacket(0 * Traits::ResPacketSize, R0);
+          r3.storePacket(1 * Traits::ResPacketSize, R1);
+          r3.storePacket(2 * Traits::ResPacketSize, R2);          
+          }
+        }
+
+        // Deal with remaining columns of the rhs
+        for(Index j2=packet_cols4; j2<cols; j2++)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=3*LhsProgress)
+          {
+          // One column at a time
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(3*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C4, C8;
+          traits.initAcc(C0);
+          traits.initAcc(C4);
+          traits.initAcc(C8);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2);
+          r0.prefetch(0);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+          LhsPacket A0, A1, A2;
+          
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 3pX1");
+            RhsPacket B_0;
+#define EIGEN_GEBGP_ONESTEP(K)                                                    \
+            do {                                                                  \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 3pX1");          \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              traits.loadLhs(&blA[(0 + 3 * K) * LhsProgress], A0);                \
+              traits.loadLhs(&blA[(1 + 3 * K) * LhsProgress], A1);                \
+              traits.loadLhs(&blA[(2 + 3 * K) * LhsProgress], A2);                \
+              traits.loadRhs(&blB[(0 + K) * RhsProgress], B_0);                   \
+              traits.madd(A0, B_0, C0, B_0, fix<0>);                              \
+              traits.madd(A1, B_0, C4, B_0, fix<0>);                              \
+              traits.madd(A2, B_0, C8, B_0, fix<0>);                              \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 3pX1");            \
+            } while (false)
+
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += int(pk) * int(RhsProgress);
+            blA += int(pk) * 3 * int(Traits::LhsProgress);
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 3pX1");
+          }
+
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacket B_0;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += RhsProgress;
+            blA += 3*Traits::LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+          ResPacket R0, R1, R2;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r0.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r0.template loadPacket<ResPacket>(2 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          traits.acc(C8, alphav, R2);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          r0.storePacket(2 * Traits::ResPacketSize, R2);          
+          }
+        }
+      }
+    }
+
+    //---------- Process 2 * LhsProgress rows at once ----------
+    if(mr>=2*Traits::LhsProgress)
+    {
+      const Index l1 = defaultL1CacheSize; // in Bytes, TODO, l1 should be passed to this function.
+      // The max(1, ...) here is needed because we may be using blocking params larger than what our known l1 cache size
+      // suggests we should be using: either because our known l1 cache size is inaccurate (e.g. on Android, we can only guess),
+      // or because we are testing specific blocking sizes.
+      Index actual_panel_rows = (2*LhsProgress) * std::max<Index>(1,( (l1 - sizeof(ResScalar)*mr*nr - depth*nr*sizeof(RhsScalar)) / (depth * sizeof(LhsScalar) * 2*LhsProgress) ));
+
+      for(Index i1=peeled_mc3; i1<peeled_mc2; i1+=actual_panel_rows)
+      {
+        Index actual_panel_end = (std::min)(i1+actual_panel_rows, peeled_mc2);
+        for(Index j2=0; j2<packet_cols4; j2+=nr)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=2*LhsProgress)
+          {
+          
+          // We selected a 2*Traits::LhsProgress x nr micro block of res which is entirely
+          // stored into 2 x nr registers.
+          
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(2*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C1, C2, C3,
+                    C4, C5, C6, C7;
+          traits.initAcc(C0); traits.initAcc(C1); traits.initAcc(C2); traits.initAcc(C3);
+          traits.initAcc(C4); traits.initAcc(C5); traits.initAcc(C6); traits.initAcc(C7);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2 + 0);
+          LinearMapper r1 = res.getLinearMapper(i, j2 + 1);
+          LinearMapper r2 = res.getLinearMapper(i, j2 + 2);
+          LinearMapper r3 = res.getLinearMapper(i, j2 + 3);
+
+          r0.prefetch(prefetch_res_offset);
+          r1.prefetch(prefetch_res_offset);
+          r2.prefetch(prefetch_res_offset);
+          r3.prefetch(prefetch_res_offset);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+          prefetch(&blB[0]);
+          LhsPacket A0, A1;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 2pX4");
+            RhsPacketx4 rhs_panel;
+            RhsPacket T0;
+
+          // NOTE: the begin/end asm comments below work around bug 935!
+          // but they are not enough for gcc>=6 without FMA (bug 1637)
+          #if EIGEN_GNUC_AT_LEAST(6,0) && defined(EIGEN_VECTORIZE_SSE)
+            #define EIGEN_GEBP_2PX4_SPILLING_WORKAROUND __asm__  ("" : [a0] "+x,m" (A0),[a1] "+x,m" (A1));
+          #else
+            #define EIGEN_GEBP_2PX4_SPILLING_WORKAROUND
+          #endif
+#define EIGEN_GEBGP_ONESTEP(K)                                            \
+            do {                                                          \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 2pX4");  \
+              traits.loadLhs(&blA[(0 + 2 * K) * LhsProgress], A0);        \
+              traits.loadLhs(&blA[(1 + 2 * K) * LhsProgress], A1);        \
+              traits.loadRhs(&blB[(0 + 4 * K) * RhsProgress], rhs_panel); \
+              traits.madd(A0, rhs_panel, C0, T0, fix<0>);                 \
+              traits.madd(A1, rhs_panel, C4, T0, fix<0>);                 \
+              traits.madd(A0, rhs_panel, C1, T0, fix<1>);                 \
+              traits.madd(A1, rhs_panel, C5, T0, fix<1>);                 \
+              traits.madd(A0, rhs_panel, C2, T0, fix<2>);                 \
+              traits.madd(A1, rhs_panel, C6, T0, fix<2>);                 \
+              traits.madd(A0, rhs_panel, C3, T0, fix<3>);                 \
+              traits.madd(A1, rhs_panel, C7, T0, fix<3>);                 \
+              EIGEN_GEBP_2PX4_SPILLING_WORKAROUND                         \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 2pX4");    \
+            } while (false)
+
+            internal::prefetch(blB+(48+0));
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            internal::prefetch(blB+(48+16));
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += pk*4*RhsProgress;
+            blA += pk*(2*Traits::LhsProgress);
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 2pX4");
+          }
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacketx4 rhs_panel;
+            RhsPacket T0;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += 4*RhsProgress;
+            blA += 2*Traits::LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+
+          ResPacket R0, R1, R2, R3;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r0.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r1.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R3 = r1.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          traits.acc(C1, alphav, R2);
+          traits.acc(C5, alphav, R3);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          r1.storePacket(0 * Traits::ResPacketSize, R2);
+          r1.storePacket(1 * Traits::ResPacketSize, R3);
+
+          R0 = r2.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r2.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          R2 = r3.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R3 = r3.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          traits.acc(C2,  alphav, R0);
+          traits.acc(C6,  alphav, R1);
+          traits.acc(C3,  alphav, R2);
+          traits.acc(C7,  alphav, R3);
+          r2.storePacket(0 * Traits::ResPacketSize, R0);
+          r2.storePacket(1 * Traits::ResPacketSize, R1);
+          r3.storePacket(0 * Traits::ResPacketSize, R2);
+          r3.storePacket(1 * Traits::ResPacketSize, R3);
+          }
+        }
+      
+        // Deal with remaining columns of the rhs
+        for(Index j2=packet_cols4; j2<cols; j2++)
+        {
+          for(Index i=i1; i<actual_panel_end; i+=2*LhsProgress)
+          {
+          // One column at a time
+          const LhsScalar* blA = &blockA[i*strideA+offsetA*(2*Traits::LhsProgress)];
+          prefetch(&blA[0]);
+
+          // gets res block as register
+          AccPacket C0, C4;
+          traits.initAcc(C0);
+          traits.initAcc(C4);
+
+          LinearMapper r0 = res.getLinearMapper(i, j2);
+          r0.prefetch(prefetch_res_offset);
+
+          // performs "inner" products
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+          LhsPacket A0, A1;
+
+          for(Index k=0; k<peeled_kc; k+=pk)
+          {
+            EIGEN_ASM_COMMENT("begin gebp micro kernel 2pX1");
+            RhsPacket B_0, B1;
+        
+#define EIGEN_GEBGP_ONESTEP(K) \
+            do {                                                                  \
+              EIGEN_ASM_COMMENT("begin step of gebp micro kernel 2pX1");          \
+              EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!"); \
+              traits.loadLhs(&blA[(0+2*K)*LhsProgress], A0);                      \
+              traits.loadLhs(&blA[(1+2*K)*LhsProgress], A1);                      \
+              traits.loadRhs(&blB[(0+K)*RhsProgress], B_0);                       \
+              traits.madd(A0, B_0, C0, B1, fix<0>);                               \
+              traits.madd(A1, B_0, C4, B_0, fix<0>);                              \
+              EIGEN_ASM_COMMENT("end step of gebp micro kernel 2pX1");            \
+            } while(false)
+        
+            EIGEN_GEBGP_ONESTEP(0);
+            EIGEN_GEBGP_ONESTEP(1);
+            EIGEN_GEBGP_ONESTEP(2);
+            EIGEN_GEBGP_ONESTEP(3);
+            EIGEN_GEBGP_ONESTEP(4);
+            EIGEN_GEBGP_ONESTEP(5);
+            EIGEN_GEBGP_ONESTEP(6);
+            EIGEN_GEBGP_ONESTEP(7);
+
+            blB += int(pk) * int(RhsProgress);
+            blA += int(pk) * 2 * int(Traits::LhsProgress);
+
+            EIGEN_ASM_COMMENT("end gebp micro kernel 2pX1");
+          }
+
+          // process remaining peeled loop
+          for(Index k=peeled_kc; k<depth; k++)
+          {
+            RhsPacket B_0, B1;
+            EIGEN_GEBGP_ONESTEP(0);
+            blB += RhsProgress;
+            blA += 2*Traits::LhsProgress;
+          }
+#undef EIGEN_GEBGP_ONESTEP
+          ResPacket R0, R1;
+          ResPacket alphav = pset1<ResPacket>(alpha);
+
+          R0 = r0.template loadPacket<ResPacket>(0 * Traits::ResPacketSize);
+          R1 = r0.template loadPacket<ResPacket>(1 * Traits::ResPacketSize);
+          traits.acc(C0, alphav, R0);
+          traits.acc(C4, alphav, R1);
+          r0.storePacket(0 * Traits::ResPacketSize, R0);
+          r0.storePacket(1 * Traits::ResPacketSize, R1);
+          }
+        }
+      }
+    }
+    //---------- Process 1 * LhsProgress rows at once ----------
+    if(mr>=1*Traits::LhsProgress)
+    {
+      lhs_process_one_packet<nr, LhsProgress, RhsProgress, LhsScalar, RhsScalar, ResScalar, AccPacket, LhsPacket, RhsPacket, ResPacket, Traits, LinearMapper, DataMapper> p;
+      p(res, blockA, blockB, alpha, peeled_mc2, peeled_mc1, strideA, strideB, offsetA, offsetB, prefetch_res_offset, peeled_kc, pk, cols, depth, packet_cols4);
+    }
+    //---------- Process LhsProgressHalf rows at once ----------
+    if((LhsProgressHalf < LhsProgress) && mr>=LhsProgressHalf)
+    {
+      lhs_process_fraction_of_packet<nr, LhsProgressHalf, RhsProgressHalf, LhsScalar, RhsScalar, ResScalar, AccPacketHalf, LhsPacketHalf, RhsPacketHalf, ResPacketHalf, HalfTraits, LinearMapper, DataMapper> p;
+      p(res, blockA, blockB, alpha, peeled_mc1, peeled_mc_half, strideA, strideB, offsetA, offsetB, prefetch_res_offset, peeled_kc, pk, cols, depth, packet_cols4);
+    }
+    //---------- Process LhsProgressQuarter rows at once ----------
+    if((LhsProgressQuarter < LhsProgressHalf) && mr>=LhsProgressQuarter)
+    {
+      lhs_process_fraction_of_packet<nr, LhsProgressQuarter, RhsProgressQuarter, LhsScalar, RhsScalar, ResScalar, AccPacketQuarter, LhsPacketQuarter, RhsPacketQuarter, ResPacketQuarter, QuarterTraits, LinearMapper, DataMapper> p;
+      p(res, blockA, blockB, alpha, peeled_mc_half, peeled_mc_quarter, strideA, strideB, offsetA, offsetB, prefetch_res_offset, peeled_kc, pk, cols, depth, packet_cols4);
+    }
+    //---------- Process remaining rows, 1 at once ----------
+    if(peeled_mc_quarter<rows)
+    {
+      // loop on each panel of the rhs
+      for(Index j2=0; j2<packet_cols4; j2+=nr)
+      {
+        // loop on each row of the lhs (1*LhsProgress x depth)
+        for(Index i=peeled_mc_quarter; i<rows; i+=1)
+        {
+          const LhsScalar* blA = &blockA[i*strideA+offsetA];
+          prefetch(&blA[0]);
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB*nr];
+
+          // If LhsProgress is 8 or 16, it assumes that there is a
+          // half or quarter packet, respectively, of the same size as
+          // nr (which is currently 4) for the return type.
+          const int SResPacketHalfSize = unpacket_traits<typename unpacket_traits<SResPacket>::half>::size;
+          const int SResPacketQuarterSize = unpacket_traits<typename unpacket_traits<typename unpacket_traits<SResPacket>::half>::half>::size;
+          if ((SwappedTraits::LhsProgress % 4) == 0 &&
+              (SwappedTraits::LhsProgress<=16) &&
+              (SwappedTraits::LhsProgress!=8  || SResPacketHalfSize==nr) &&
+              (SwappedTraits::LhsProgress!=16 || SResPacketQuarterSize==nr))
+          {
+            SAccPacket C0, C1, C2, C3;
+            straits.initAcc(C0);
+            straits.initAcc(C1);
+            straits.initAcc(C2);
+            straits.initAcc(C3);
+
+            const Index spk   = (std::max)(1,SwappedTraits::LhsProgress/4);
+            const Index endk  = (depth/spk)*spk;
+            const Index endk4 = (depth/(spk*4))*(spk*4);
+
+            Index k=0;
+            for(; k<endk4; k+=4*spk)
+            {
+              SLhsPacket A0,A1;
+              SRhsPacket B_0,B_1;
+
+              straits.loadLhsUnaligned(blB+0*SwappedTraits::LhsProgress, A0);
+              straits.loadLhsUnaligned(blB+1*SwappedTraits::LhsProgress, A1);
+
+              straits.loadRhsQuad(blA+0*spk, B_0);
+              straits.loadRhsQuad(blA+1*spk, B_1);
+              straits.madd(A0,B_0,C0,B_0, fix<0>);
+              straits.madd(A1,B_1,C1,B_1, fix<0>);
+
+              straits.loadLhsUnaligned(blB+2*SwappedTraits::LhsProgress, A0);
+              straits.loadLhsUnaligned(blB+3*SwappedTraits::LhsProgress, A1);
+              straits.loadRhsQuad(blA+2*spk, B_0);
+              straits.loadRhsQuad(blA+3*spk, B_1);
+              straits.madd(A0,B_0,C2,B_0, fix<0>);
+              straits.madd(A1,B_1,C3,B_1, fix<0>);
+
+              blB += 4*SwappedTraits::LhsProgress;
+              blA += 4*spk;
+            }
+            C0 = padd(padd(C0,C1),padd(C2,C3));
+            for(; k<endk; k+=spk)
+            {
+              SLhsPacket A0;
+              SRhsPacket B_0;
+
+              straits.loadLhsUnaligned(blB, A0);
+              straits.loadRhsQuad(blA, B_0);
+              straits.madd(A0,B_0,C0,B_0, fix<0>);
+
+              blB += SwappedTraits::LhsProgress;
+              blA += spk;
+            }
+            if(SwappedTraits::LhsProgress==8)
+            {
+              // Special case where we have to first reduce the accumulation register C0
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SResPacket>::half,SResPacket>::type SResPacketHalf;
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SLhsPacket>::half,SLhsPacket>::type SLhsPacketHalf;
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SRhsPacket>::half,SRhsPacket>::type SRhsPacketHalf;
+              typedef typename conditional<SwappedTraits::LhsProgress>=8,typename unpacket_traits<SAccPacket>::half,SAccPacket>::type SAccPacketHalf;
+
+              SResPacketHalf R = res.template gatherPacket<SResPacketHalf>(i, j2);
+              SResPacketHalf alphav = pset1<SResPacketHalf>(alpha);
+
+              if(depth-endk>0)
+              {
+                // We have to handle the last row of the rhs which corresponds to a half-packet
+                SLhsPacketHalf a0;
+                SRhsPacketHalf b0;
+                straits.loadLhsUnaligned(blB, a0);
+                straits.loadRhs(blA, b0);
+                SAccPacketHalf c0 = predux_half_dowto4(C0);
+                straits.madd(a0,b0,c0,b0, fix<0>);
+                straits.acc(c0, alphav, R);
+              }
+              else
+              {
+                straits.acc(predux_half_dowto4(C0), alphav, R);
+              }
+              res.scatterPacket(i, j2, R);
+            }
+            else if (SwappedTraits::LhsProgress==16)
+            {
+              // Special case where we have to first reduce the
+              // accumulation register C0. We specialize the block in
+              // template form, so that LhsProgress < 16 paths don't
+              // fail to compile
+              last_row_process_16_packets<LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs> p;
+	            p(res, straits, blA, blB, depth, endk, i, j2,alpha, C0);
+            }
+            else
+            {
+              SResPacket R = res.template gatherPacket<SResPacket>(i, j2);
+              SResPacket alphav = pset1<SResPacket>(alpha);
+              straits.acc(C0, alphav, R);
+              res.scatterPacket(i, j2, R);
+            }
+          }
+          else // scalar path
+          {
+            // get a 1 x 4 res block as registers
+            ResScalar C0(0), C1(0), C2(0), C3(0);
+
+            for(Index k=0; k<depth; k++)
+            {
+              LhsScalar A0;
+              RhsScalar B_0, B_1;
+
+              A0 = blA[k];
+
+              B_0 = blB[0];
+              B_1 = blB[1];
+              C0 = cj.pmadd(A0,B_0,C0);
+              C1 = cj.pmadd(A0,B_1,C1);
+
+              B_0 = blB[2];
+              B_1 = blB[3];
+              C2 = cj.pmadd(A0,B_0,C2);
+              C3 = cj.pmadd(A0,B_1,C3);
+
+              blB += 4;
+            }
+            res(i, j2 + 0) += alpha * C0;
+            res(i, j2 + 1) += alpha * C1;
+            res(i, j2 + 2) += alpha * C2;
+            res(i, j2 + 3) += alpha * C3;
+          }
+        }
+      }
+      // remaining columns
+      for(Index j2=packet_cols4; j2<cols; j2++)
+      {
+        // loop on each row of the lhs (1*LhsProgress x depth)
+        for(Index i=peeled_mc_quarter; i<rows; i+=1)
+        {
+          const LhsScalar* blA = &blockA[i*strideA+offsetA];
+          prefetch(&blA[0]);
+          // gets a 1 x 1 res block as registers
+          ResScalar C0(0);
+          const RhsScalar* blB = &blockB[j2*strideB+offsetB];
+          for(Index k=0; k<depth; k++)
+          {
+            LhsScalar A0 = blA[k];
+            RhsScalar B_0 = blB[k];
+            C0 = cj.pmadd(A0, B_0, C0);
+          }
+          res(i, j2) += alpha * C0;
+        }
+      }
+    }
+  }
+
+
+// pack a block of the lhs
+// The traversal is as follow (mr==4):
+//   0  4  8 12 ...
+//   1  5  9 13 ...
+//   2  6 10 14 ...
+//   3  7 11 15 ...
+//
+//  16 20 24 28 ...
+//  17 21 25 29 ...
+//  18 22 26 30 ...
+//  19 23 27 31 ...
+//
+//  32 33 34 35 ...
+//  36 36 38 39 ...
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+{
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  EIGEN_DONT_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode>
+  ::operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  typedef typename unpacket_traits<Packet>::half HalfPacket;
+  typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>::half QuarterPacket;
+  enum { PacketSize = unpacket_traits<Packet>::size,
+         HalfPacketSize = unpacket_traits<HalfPacket>::size,
+         QuarterPacketSize = unpacket_traits<QuarterPacket>::size,
+         HasHalf = (int)HalfPacketSize < (int)PacketSize,
+         HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize};
+
+  EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK LHS");
+  EIGEN_UNUSED_VARIABLE(stride);
+  EIGEN_UNUSED_VARIABLE(offset);
+  eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+  eigen_assert( ((Pack1%PacketSize)==0 && Pack1<=4*PacketSize) || (Pack1<=4) );
+  conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+  Index count = 0;
+
+  const Index peeled_mc3 = Pack1>=3*PacketSize ? (rows/(3*PacketSize))*(3*PacketSize) : 0;
+  const Index peeled_mc2 = Pack1>=2*PacketSize ? peeled_mc3+((rows-peeled_mc3)/(2*PacketSize))*(2*PacketSize) : 0;
+  const Index peeled_mc1 = Pack1>=1*PacketSize ? peeled_mc2+((rows-peeled_mc2)/(1*PacketSize))*(1*PacketSize) : 0;
+  const Index peeled_mc_half = Pack1>=HalfPacketSize ? peeled_mc1+((rows-peeled_mc1)/(HalfPacketSize))*(HalfPacketSize) : 0;
+  const Index peeled_mc_quarter = Pack1>=QuarterPacketSize ? (rows/(QuarterPacketSize))*(QuarterPacketSize) : 0;
+  const Index last_lhs_progress = rows > peeled_mc_quarter ? (rows - peeled_mc_quarter) & ~1 : 0;
+  const Index peeled_mc0 = Pack2>=PacketSize ? peeled_mc_quarter
+                         : Pack2>1 && last_lhs_progress ? (rows/last_lhs_progress)*last_lhs_progress : 0;
+
+  Index i=0;
+
+  // Pack 3 packets
+  if(Pack1>=3*PacketSize)
+  {
+    for(; i<peeled_mc3; i+=3*PacketSize)
+    {
+      if(PanelMode) count += (3*PacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        Packet A, B, C;
+        A = lhs.template loadPacket<Packet>(i+0*PacketSize, k);
+        B = lhs.template loadPacket<Packet>(i+1*PacketSize, k);
+        C = lhs.template loadPacket<Packet>(i+2*PacketSize, k);
+        pstore(blockA+count, cj.pconj(A)); count+=PacketSize;
+        pstore(blockA+count, cj.pconj(B)); count+=PacketSize;
+        pstore(blockA+count, cj.pconj(C)); count+=PacketSize;
+      }
+      if(PanelMode) count += (3*PacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack 2 packets
+  if(Pack1>=2*PacketSize)
+  {
+    for(; i<peeled_mc2; i+=2*PacketSize)
+    {
+      if(PanelMode) count += (2*PacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        Packet A, B;
+        A = lhs.template loadPacket<Packet>(i+0*PacketSize, k);
+        B = lhs.template loadPacket<Packet>(i+1*PacketSize, k);
+        pstore(blockA+count, cj.pconj(A)); count+=PacketSize;
+        pstore(blockA+count, cj.pconj(B)); count+=PacketSize;
+      }
+      if(PanelMode) count += (2*PacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack 1 packets
+  if(Pack1>=1*PacketSize)
+  {
+    for(; i<peeled_mc1; i+=1*PacketSize)
+    {
+      if(PanelMode) count += (1*PacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        Packet A;
+        A = lhs.template loadPacket<Packet>(i+0*PacketSize, k);
+        pstore(blockA+count, cj.pconj(A));
+        count+=PacketSize;
+      }
+      if(PanelMode) count += (1*PacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack half packets
+  if(HasHalf && Pack1>=HalfPacketSize)
+  {
+    for(; i<peeled_mc_half; i+=HalfPacketSize)
+    {
+      if(PanelMode) count += (HalfPacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        HalfPacket A;
+        A = lhs.template loadPacket<HalfPacket>(i+0*(HalfPacketSize), k);
+        pstoreu(blockA+count, cj.pconj(A));
+        count+=HalfPacketSize;
+      }
+      if(PanelMode) count += (HalfPacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack quarter packets
+  if(HasQuarter && Pack1>=QuarterPacketSize)
+  {
+    for(; i<peeled_mc_quarter; i+=QuarterPacketSize)
+    {
+      if(PanelMode) count += (QuarterPacketSize) * offset;
+
+      for(Index k=0; k<depth; k++)
+      {
+        QuarterPacket A;
+        A = lhs.template loadPacket<QuarterPacket>(i+0*(QuarterPacketSize), k);
+        pstoreu(blockA+count, cj.pconj(A));
+        count+=QuarterPacketSize;
+      }
+      if(PanelMode) count += (QuarterPacketSize) * (stride-offset-depth);
+    }
+  }
+  // Pack2 may be *smaller* than PacketSize—that happens for
+  // products like real * complex, where we have to go half the
+  // progress on the lhs in order to duplicate those operands to
+  // address both real & imaginary parts on the rhs. This portion will
+  // pack those half ones until they match the number expected on the
+  // last peeling loop at this point (for the rhs).
+  if(Pack2<PacketSize && Pack2>1)
+  {
+    for(; i<peeled_mc0; i+=last_lhs_progress)
+    {
+      if(PanelMode) count += last_lhs_progress * offset;
+
+      for(Index k=0; k<depth; k++)
+        for(Index w=0; w<last_lhs_progress; w++)
+          blockA[count++] = cj(lhs(i+w, k));
+
+      if(PanelMode) count += last_lhs_progress * (stride-offset-depth);
+    }
+  }
+  // Pack scalars
+  for(; i<rows; i++)
+  {
+    if(PanelMode) count += offset;
+    for(Index k=0; k<depth; k++)
+      blockA[count++] = cj(lhs(i, k));
+    if(PanelMode) count += (stride-offset-depth);
+  }
+}
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+struct gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+{
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  EIGEN_DONT_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride=0, Index offset=0);
+};
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate, bool PanelMode>
+EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode>
+  ::operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
+{
+  typedef typename unpacket_traits<Packet>::half HalfPacket;
+  typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>::half QuarterPacket;
+  enum { PacketSize = unpacket_traits<Packet>::size,
+         HalfPacketSize = unpacket_traits<HalfPacket>::size,
+         QuarterPacketSize = unpacket_traits<QuarterPacket>::size,
+         HasHalf = (int)HalfPacketSize < (int)PacketSize,
+         HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize};
+
+  EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK LHS");
+  EIGEN_UNUSED_VARIABLE(stride);
+  EIGEN_UNUSED_VARIABLE(offset);
+  eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+  conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+  Index count = 0;
+  bool gone_half = false, gone_quarter = false, gone_last = false;
+
+  Index i = 0;
+  int pack = Pack1;
+  int psize = PacketSize;
+  while(pack>0)
+  {
+    Index remaining_rows = rows-i;
+    Index peeled_mc = gone_last ? Pack2>1 ? (rows/pack)*pack : 0 : i+(remaining_rows/pack)*pack;
+    Index starting_pos = i;
+    for(; i<peeled_mc; i+=pack)
+    {
+      if(PanelMode) count += pack * offset;
+
+      Index k=0;
+      if(pack>=psize && psize >= QuarterPacketSize)
+      {
+        const Index peeled_k = (depth/psize)*psize;
+        for(; k<peeled_k; k+=psize)
+        {
+          for (Index m = 0; m < pack; m += psize)
+          {
+            if (psize == PacketSize) {
+              PacketBlock<Packet> kernel;
+              for (int p = 0; p < psize; ++p) kernel.packet[p] = lhs.template loadPacket<Packet>(i+p+m, k);
+              ptranspose(kernel);
+              for (int p = 0; p < psize; ++p) pstore(blockA+count+m+(pack)*p, cj.pconj(kernel.packet[p]));
+            } else if (HasHalf && psize == HalfPacketSize) {
+              gone_half = true;
+              PacketBlock<HalfPacket> kernel_half;
+              for (int p = 0; p < psize; ++p) kernel_half.packet[p] = lhs.template loadPacket<HalfPacket>(i+p+m, k);
+              ptranspose(kernel_half);
+              for (int p = 0; p < psize; ++p) pstore(blockA+count+m+(pack)*p, cj.pconj(kernel_half.packet[p]));
+            } else if (HasQuarter && psize == QuarterPacketSize) {
+              gone_quarter = true;
+              PacketBlock<QuarterPacket> kernel_quarter;
+              for (int p = 0; p < psize; ++p) kernel_quarter.packet[p] = lhs.template loadPacket<QuarterPacket>(i+p+m, k);
+              ptranspose(kernel_quarter);
+              for (int p = 0; p < psize; ++p) pstore(blockA+count+m+(pack)*p, cj.pconj(kernel_quarter.packet[p]));
+	    }
+          }
+          count += psize*pack;
+        }
+      }
+
+      for(; k<depth; k++)
+      {
+        Index w=0;
+        for(; w<pack-3; w+=4)
+        {
+          Scalar a(cj(lhs(i+w+0, k))),
+                 b(cj(lhs(i+w+1, k))),
+                 c(cj(lhs(i+w+2, k))),
+                 d(cj(lhs(i+w+3, k)));
+          blockA[count++] = a;
+          blockA[count++] = b;
+          blockA[count++] = c;
+          blockA[count++] = d;
+        }
+        if(pack%4)
+          for(;w<pack;++w)
+            blockA[count++] = cj(lhs(i+w, k));
+      }
+
+      if(PanelMode) count += pack * (stride-offset-depth);
+    }
+
+    pack -= psize;
+    Index left = rows - i;
+    if (pack <= 0) {
+      if (!gone_last &&
+          (starting_pos == i || left >= psize/2 || left >= psize/4) &&
+          ((psize/2 == HalfPacketSize && HasHalf && !gone_half) ||
+           (psize/2 == QuarterPacketSize && HasQuarter && !gone_quarter))) {
+        psize /= 2;
+        pack = psize;
+        continue;
+      }
+      // Pack2 may be *smaller* than PacketSize—that happens for
+      // products like real * complex, where we have to go half the
+      // progress on the lhs in order to duplicate those operands to
+      // address both real & imaginary parts on the rhs. This portion will
+      // pack those half ones until they match the number expected on the
+      // last peeling loop at this point (for the rhs).
+      if (Pack2 < PacketSize && !gone_last) {
+        gone_last = true;
+        psize = pack = left & ~1;
+      }
+    }
+  }
+
+  for(; i<rows; i++)
+  {
+    if(PanelMode) count += offset;
+    for(Index k=0; k<depth; k++)
+      blockA[count++] = cj(lhs(i, k));
+    if(PanelMode) count += (stride-offset-depth);
+  }
+}
+
+// copy a complete panel of the rhs
+// this version is optimized for column major matrices
+// The traversal order is as follow: (nr==4):
+//  0  1  2  3   12 13 14 15   24 27
+//  4  5  6  7   16 17 18 19   25 28
+//  8  9 10 11   20 21 22 23   26 29
+//  .  .  .  .    .  .  .  .    .  .
+template<typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  enum { PacketSize = packet_traits<Scalar>::size };
+  EIGEN_DONT_INLINE void operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0);
+};
+
+template<typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
+  ::operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
+{
+  EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS COLMAJOR");
+  EIGEN_UNUSED_VARIABLE(stride);
+  EIGEN_UNUSED_VARIABLE(offset);
+  eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+  conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+  Index packet_cols8 = nr>=8 ? (cols/8) * 8 : 0;
+  Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+  Index count = 0;
+  const Index peeled_k = (depth/PacketSize)*PacketSize;
+//   if(nr>=8)
+//   {
+//     for(Index j2=0; j2<packet_cols8; j2+=8)
+//     {
+//       // skip what we have before
+//       if(PanelMode) count += 8 * offset;
+//       const Scalar* b0 = &rhs[(j2+0)*rhsStride];
+//       const Scalar* b1 = &rhs[(j2+1)*rhsStride];
+//       const Scalar* b2 = &rhs[(j2+2)*rhsStride];
+//       const Scalar* b3 = &rhs[(j2+3)*rhsStride];
+//       const Scalar* b4 = &rhs[(j2+4)*rhsStride];
+//       const Scalar* b5 = &rhs[(j2+5)*rhsStride];
+//       const Scalar* b6 = &rhs[(j2+6)*rhsStride];
+//       const Scalar* b7 = &rhs[(j2+7)*rhsStride];
+//       Index k=0;
+//       if(PacketSize==8) // TODO enable vectorized transposition for PacketSize==4
+//       {
+//         for(; k<peeled_k; k+=PacketSize) {
+//           PacketBlock<Packet> kernel;
+//           for (int p = 0; p < PacketSize; ++p) {
+//             kernel.packet[p] = ploadu<Packet>(&rhs[(j2+p)*rhsStride+k]);
+//           }
+//           ptranspose(kernel);
+//           for (int p = 0; p < PacketSize; ++p) {
+//             pstoreu(blockB+count, cj.pconj(kernel.packet[p]));
+//             count+=PacketSize;
+//           }
+//         }
+//       }
+//       for(; k<depth; k++)
+//       {
+//         blockB[count+0] = cj(b0[k]);
+//         blockB[count+1] = cj(b1[k]);
+//         blockB[count+2] = cj(b2[k]);
+//         blockB[count+3] = cj(b3[k]);
+//         blockB[count+4] = cj(b4[k]);
+//         blockB[count+5] = cj(b5[k]);
+//         blockB[count+6] = cj(b6[k]);
+//         blockB[count+7] = cj(b7[k]);
+//         count += 8;
+//       }
+//       // skip what we have after
+//       if(PanelMode) count += 8 * (stride-offset-depth);
+//     }
+//   }
+
+  if(nr>=4)
+  {
+    for(Index j2=packet_cols8; j2<packet_cols4; j2+=4)
+    {
+      // skip what we have before
+      if(PanelMode) count += 4 * offset;
+      const LinearMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
+      const LinearMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
+      const LinearMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
+      const LinearMapper dm3 = rhs.getLinearMapper(0, j2 + 3);
+
+      Index k=0;
+      if((PacketSize%4)==0) // TODO enable vectorized transposition for PacketSize==2 ??
+      {
+        for(; k<peeled_k; k+=PacketSize) {
+          PacketBlock<Packet,(PacketSize%4)==0?4:PacketSize> kernel;
+          kernel.packet[0           ] = dm0.template loadPacket<Packet>(k);
+          kernel.packet[1%PacketSize] = dm1.template loadPacket<Packet>(k);
+          kernel.packet[2%PacketSize] = dm2.template loadPacket<Packet>(k);
+          kernel.packet[3%PacketSize] = dm3.template loadPacket<Packet>(k);
+          ptranspose(kernel);
+          pstoreu(blockB+count+0*PacketSize, cj.pconj(kernel.packet[0]));
+          pstoreu(blockB+count+1*PacketSize, cj.pconj(kernel.packet[1%PacketSize]));
+          pstoreu(blockB+count+2*PacketSize, cj.pconj(kernel.packet[2%PacketSize]));
+          pstoreu(blockB+count+3*PacketSize, cj.pconj(kernel.packet[3%PacketSize]));
+          count+=4*PacketSize;
+        }
+      }
+      for(; k<depth; k++)
+      {
+        blockB[count+0] = cj(dm0(k));
+        blockB[count+1] = cj(dm1(k));
+        blockB[count+2] = cj(dm2(k));
+        blockB[count+3] = cj(dm3(k));
+        count += 4;
+      }
+      // skip what we have after
+      if(PanelMode) count += 4 * (stride-offset-depth);
+    }
+  }
+
+  // copy the remaining columns one at a time (nr==1)
+  for(Index j2=packet_cols4; j2<cols; ++j2)
+  {
+    if(PanelMode) count += offset;
+    const LinearMapper dm0 = rhs.getLinearMapper(0, j2);
+    for(Index k=0; k<depth; k++)
+    {
+      blockB[count] = cj(dm0(k));
+      count += 1;
+    }
+    if(PanelMode) count += (stride-offset-depth);
+  }
+}
+
+// this version is optimized for row major matrices
+template<typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
+struct gemm_pack_rhs<Scalar, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename unpacket_traits<Packet>::half HalfPacket;
+  typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>::half QuarterPacket;
+  typedef typename DataMapper::LinearMapper LinearMapper;
+  enum { PacketSize = packet_traits<Scalar>::size,
+         HalfPacketSize = unpacket_traits<HalfPacket>::size,
+		 QuarterPacketSize = unpacket_traits<QuarterPacket>::size};
+  EIGEN_DONT_INLINE void operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride=0, Index offset=0)
+  {
+    EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS ROWMAJOR");
+    EIGEN_UNUSED_VARIABLE(stride);
+    EIGEN_UNUSED_VARIABLE(offset);
+    eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
+    const bool HasHalf = (int)HalfPacketSize < (int)PacketSize;
+    const bool HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize;
+    conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+    Index packet_cols8 = nr>=8 ? (cols/8) * 8 : 0;
+    Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+    Index count = 0;
+
+  //   if(nr>=8)
+  //   {
+  //     for(Index j2=0; j2<packet_cols8; j2+=8)
+  //     {
+  //       // skip what we have before
+  //       if(PanelMode) count += 8 * offset;
+  //       for(Index k=0; k<depth; k++)
+  //       {
+  //         if (PacketSize==8) {
+  //           Packet A = ploadu<Packet>(&rhs[k*rhsStride + j2]);
+  //           pstoreu(blockB+count, cj.pconj(A));
+  //         } else if (PacketSize==4) {
+  //           Packet A = ploadu<Packet>(&rhs[k*rhsStride + j2]);
+  //           Packet B = ploadu<Packet>(&rhs[k*rhsStride + j2 + PacketSize]);
+  //           pstoreu(blockB+count, cj.pconj(A));
+  //           pstoreu(blockB+count+PacketSize, cj.pconj(B));
+  //         } else {
+  //           const Scalar* b0 = &rhs[k*rhsStride + j2];
+  //           blockB[count+0] = cj(b0[0]);
+  //           blockB[count+1] = cj(b0[1]);
+  //           blockB[count+2] = cj(b0[2]);
+  //           blockB[count+3] = cj(b0[3]);
+  //           blockB[count+4] = cj(b0[4]);
+  //           blockB[count+5] = cj(b0[5]);
+  //           blockB[count+6] = cj(b0[6]);
+  //           blockB[count+7] = cj(b0[7]);
+  //         }
+  //         count += 8;
+  //       }
+  //       // skip what we have after
+  //       if(PanelMode) count += 8 * (stride-offset-depth);
+  //     }
+  //   }
+    if(nr>=4)
+    {
+      for(Index j2=packet_cols8; j2<packet_cols4; j2+=4)
+      {
+        // skip what we have before
+        if(PanelMode) count += 4 * offset;
+        for(Index k=0; k<depth; k++)
+        {
+          if (PacketSize==4) {
+            Packet A = rhs.template loadPacket<Packet>(k, j2);
+            pstoreu(blockB+count, cj.pconj(A));
+            count += PacketSize;
+          } else if (HasHalf && HalfPacketSize==4) {
+            HalfPacket A = rhs.template loadPacket<HalfPacket>(k, j2);
+            pstoreu(blockB+count, cj.pconj(A));
+            count += HalfPacketSize;
+          } else if (HasQuarter && QuarterPacketSize==4) {
+            QuarterPacket A = rhs.template loadPacket<QuarterPacket>(k, j2);
+            pstoreu(blockB+count, cj.pconj(A));
+            count += QuarterPacketSize;
+          } else {
+            const LinearMapper dm0 = rhs.getLinearMapper(k, j2);
+            blockB[count+0] = cj(dm0(0));
+            blockB[count+1] = cj(dm0(1));
+            blockB[count+2] = cj(dm0(2));
+            blockB[count+3] = cj(dm0(3));
+            count += 4;
+          }
+        }
+        // skip what we have after
+        if(PanelMode) count += 4 * (stride-offset-depth);
+      }
+    }
+    // copy the remaining columns one at a time (nr==1)
+    for(Index j2=packet_cols4; j2<cols; ++j2)
+    {
+      if(PanelMode) count += offset;
+      for(Index k=0; k<depth; k++)
+      {
+        blockB[count] = cj(rhs(k, j2));
+        count += 1;
+      }
+      if(PanelMode) count += stride-offset-depth;
+    }
+  }
+};
+
+} // end namespace internal
+
+/** \returns the currently set level 1 cpu cache size (in bytes) used to estimate the ideal blocking size parameters.
+  * \sa setCpuCacheSize */
+inline std::ptrdiff_t l1CacheSize()
+{
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  return l1;
+}
+
+/** \returns the currently set level 2 cpu cache size (in bytes) used to estimate the ideal blocking size parameters.
+  * \sa setCpuCacheSize */
+inline std::ptrdiff_t l2CacheSize()
+{
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  return l2;
+}
+
+/** \returns the currently set level 3 cpu cache size (in bytes) used to estimate the ideal blocking size paramete\
+rs.                                                                                                                
+* \sa setCpuCacheSize */
+inline std::ptrdiff_t l3CacheSize()
+{
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  return l3;
+}
+
+/** Set the cpu L1 and L2 cache sizes (in bytes).
+  * These values are use to adjust the size of the blocks
+  * for the algorithms working per blocks.
+  *
+  * \sa computeProductBlockingSizes */
+inline void setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3)
+{
+  internal::manage_caching_sizes(SetAction, &l1, &l2, &l3);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_BLOCK_PANEL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrix.h
new file mode 100644
index 00000000..caa65fcc
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrix.h
@@ -0,0 +1,517 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename _LhsScalar, typename _RhsScalar> class level3_blocking;
+
+/* Specialization for a row-major destination matrix => simple transposition of the product */
+template<
+  typename Index,
+  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+  int ResInnerStride>
+struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor,ResInnerStride>
+{
+  typedef gebp_traits<RhsScalar,LhsScalar> Traits;
+
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  static EIGEN_STRONG_INLINE void run(
+    Index rows, Index cols, Index depth,
+    const LhsScalar* lhs, Index lhsStride,
+    const RhsScalar* rhs, Index rhsStride,
+    ResScalar* res, Index resIncr, Index resStride,
+    ResScalar alpha,
+    level3_blocking<RhsScalar,LhsScalar>& blocking,
+    GemmParallelInfo<Index>* info = 0)
+  {
+    // transpose the product such that the result is column major
+    general_matrix_matrix_product<Index,
+      RhsScalar, RhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateRhs,
+      LhsScalar, LhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateLhs,
+      ColMajor,ResInnerStride>
+    ::run(cols,rows,depth,rhs,rhsStride,lhs,lhsStride,res,resIncr,resStride,alpha,blocking,info);
+  }
+};
+
+/*  Specialization for a col-major destination matrix
+ *    => Blocking algorithm following Goto's paper */
+template<
+  typename Index,
+  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+  int ResInnerStride>
+struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride>
+{
+
+typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+static void run(Index rows, Index cols, Index depth,
+  const LhsScalar* _lhs, Index lhsStride,
+  const RhsScalar* _rhs, Index rhsStride,
+  ResScalar* _res, Index resIncr, Index resStride,
+  ResScalar alpha,
+  level3_blocking<LhsScalar,RhsScalar>& blocking,
+  GemmParallelInfo<Index>* info = 0)
+{
+  typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
+  typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;
+  typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor,Unaligned,ResInnerStride> ResMapper;
+  LhsMapper lhs(_lhs, lhsStride);
+  RhsMapper rhs(_rhs, rhsStride);
+  ResMapper res(_res, resStride, resIncr);
+
+  Index kc = blocking.kc();                   // cache block size along the K direction
+  Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+  Index nc = (std::min)(cols,blocking.nc());  // cache block size along the N direction
+
+  gemm_pack_lhs<LhsScalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder> pack_lhs;
+  gemm_pack_rhs<RhsScalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
+  gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp;
+
+#ifdef EIGEN_HAS_OPENMP
+  if(info)
+  {
+    // this is the parallel version!
+    int tid = omp_get_thread_num();
+    int threads = omp_get_num_threads();
+
+    LhsScalar* blockA = blocking.blockA();
+    eigen_internal_assert(blockA!=0);
+
+    std::size_t sizeB = kc*nc;
+    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, 0);
+
+    // For each horizontal panel of the rhs, and corresponding vertical panel of the lhs...
+    for(Index k=0; k<depth; k+=kc)
+    {
+      const Index actual_kc = (std::min)(k+kc,depth)-k; // => rows of B', and cols of the A'
+
+      // In order to reduce the chance that a thread has to wait for the other,
+      // let's start by packing B'.
+      pack_rhs(blockB, rhs.getSubMapper(k,0), actual_kc, nc);
+
+      // Pack A_k to A' in a parallel fashion:
+      // each thread packs the sub block A_k,i to A'_i where i is the thread id.
+
+      // However, before copying to A'_i, we have to make sure that no other thread is still using it,
+      // i.e., we test that info[tid].users equals 0.
+      // Then, we set info[tid].users to the number of threads to mark that all other threads are going to use it.
+      while(info[tid].users!=0) {}
+      info[tid].users = threads;
+
+      pack_lhs(blockA+info[tid].lhs_start*actual_kc, lhs.getSubMapper(info[tid].lhs_start,k), actual_kc, info[tid].lhs_length);
+
+      // Notify the other threads that the part A'_i is ready to go.
+      info[tid].sync = k;
+
+      // Computes C_i += A' * B' per A'_i
+      for(int shift=0; shift<threads; ++shift)
+      {
+        int i = (tid+shift)%threads;
+
+        // At this point we have to make sure that A'_i has been updated by the thread i,
+        // we use testAndSetOrdered to mimic a volatile access.
+        // However, no need to wait for the B' part which has been updated by the current thread!
+        if (shift>0) {
+          while(info[i].sync!=k) {
+          }
+        }
+
+        gebp(res.getSubMapper(info[i].lhs_start, 0), blockA+info[i].lhs_start*actual_kc, blockB, info[i].lhs_length, actual_kc, nc, alpha);
+      }
+
+      // Then keep going as usual with the remaining B'
+      for(Index j=nc; j<cols; j+=nc)
+      {
+        const Index actual_nc = (std::min)(j+nc,cols)-j;
+
+        // pack B_k,j to B'
+        pack_rhs(blockB, rhs.getSubMapper(k,j), actual_kc, actual_nc);
+
+        // C_j += A' * B'
+        gebp(res.getSubMapper(0, j), blockA, blockB, rows, actual_kc, actual_nc, alpha);
+      }
+
+      // Release all the sub blocks A'_i of A' for the current thread,
+      // i.e., we simply decrement the number of users by 1
+      for(Index i=0; i<threads; ++i)
+#if !EIGEN_HAS_CXX11_ATOMIC
+        #pragma omp atomic
+#endif
+        info[i].users -= 1;
+    }
+  }
+  else
+#endif // EIGEN_HAS_OPENMP
+  {
+    EIGEN_UNUSED_VARIABLE(info);
+
+    // this is the sequential version!
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*nc;
+
+    ei_declare_aligned_stack_constructed_variable(LhsScalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, blocking.blockB());
+
+    const bool pack_rhs_once = mc!=rows && kc==depth && nc==cols;
+
+    // For each horizontal panel of the rhs, and corresponding panel of the lhs...
+    for(Index i2=0; i2<rows; i2+=mc)
+    {
+      const Index actual_mc = (std::min)(i2+mc,rows)-i2;
+
+      for(Index k2=0; k2<depth; k2+=kc)
+      {
+        const Index actual_kc = (std::min)(k2+kc,depth)-k2;
+
+        // OK, here we have selected one horizontal panel of rhs and one vertical panel of lhs.
+        // => Pack lhs's panel into a sequential chunk of memory (L2/L3 caching)
+        // Note that this panel will be read as many times as the number of blocks in the rhs's
+        // horizontal panel which is, in practice, a very low number.
+        pack_lhs(blockA, lhs.getSubMapper(i2,k2), actual_kc, actual_mc);
+
+        // For each kc x nc block of the rhs's horizontal panel...
+        for(Index j2=0; j2<cols; j2+=nc)
+        {
+          const Index actual_nc = (std::min)(j2+nc,cols)-j2;
+
+          // We pack the rhs's block into a sequential chunk of memory (L2 caching)
+          // Note that this block will be read a very high number of times, which is equal to the number of
+          // micro horizontal panel of the large rhs's panel (e.g., rows/12 times).
+          if((!pack_rhs_once) || i2==0)
+            pack_rhs(blockB, rhs.getSubMapper(k2,j2), actual_kc, actual_nc);
+
+          // Everything is packed, we can now call the panel * block kernel:
+          gebp(res.getSubMapper(i2, j2), blockA, blockB, actual_mc, actual_kc, actual_nc, alpha);
+        }
+      }
+    }
+  }
+}
+
+};
+
+/*********************************************************************************
+*  Specialization of generic_product_impl for "large" GEMM, i.e.,
+*  implementation of the high level wrapper to general_matrix_matrix_product
+**********************************************************************************/
+
+template<typename Scalar, typename Index, typename Gemm, typename Lhs, typename Rhs, typename Dest, typename BlockingType>
+struct gemm_functor
+{
+  gemm_functor(const Lhs& lhs, const Rhs& rhs, Dest& dest, const Scalar& actualAlpha, BlockingType& blocking)
+    : m_lhs(lhs), m_rhs(rhs), m_dest(dest), m_actualAlpha(actualAlpha), m_blocking(blocking)
+  {}
+
+  void initParallelSession(Index num_threads) const
+  {
+    m_blocking.initParallel(m_lhs.rows(), m_rhs.cols(), m_lhs.cols(), num_threads);
+    m_blocking.allocateA();
+  }
+
+  void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
+  {
+    if(cols==-1)
+      cols = m_rhs.cols();
+
+    Gemm::run(rows, cols, m_lhs.cols(),
+              &m_lhs.coeffRef(row,0), m_lhs.outerStride(),
+              &m_rhs.coeffRef(0,col), m_rhs.outerStride(),
+              (Scalar*)&(m_dest.coeffRef(row,col)), m_dest.innerStride(), m_dest.outerStride(),
+              m_actualAlpha, m_blocking, info);
+  }
+
+  typedef typename Gemm::Traits Traits;
+
+  protected:
+    const Lhs& m_lhs;
+    const Rhs& m_rhs;
+    Dest& m_dest;
+    Scalar m_actualAlpha;
+    BlockingType& m_blocking;
+};
+
+template<int StorageOrder, typename LhsScalar, typename RhsScalar, int MaxRows, int MaxCols, int MaxDepth, int KcFactor=1,
+bool FiniteAtCompileTime = MaxRows!=Dynamic && MaxCols!=Dynamic && MaxDepth != Dynamic> class gemm_blocking_space;
+
+template<typename _LhsScalar, typename _RhsScalar>
+class level3_blocking
+{
+    typedef _LhsScalar LhsScalar;
+    typedef _RhsScalar RhsScalar;
+
+  protected:
+    LhsScalar* m_blockA;
+    RhsScalar* m_blockB;
+
+    Index m_mc;
+    Index m_nc;
+    Index m_kc;
+
+  public:
+
+    level3_blocking()
+      : m_blockA(0), m_blockB(0), m_mc(0), m_nc(0), m_kc(0)
+    {}
+
+    inline Index mc() const { return m_mc; }
+    inline Index nc() const { return m_nc; }
+    inline Index kc() const { return m_kc; }
+
+    inline LhsScalar* blockA() { return m_blockA; }
+    inline RhsScalar* blockB() { return m_blockB; }
+};
+
+template<int StorageOrder, typename _LhsScalar, typename _RhsScalar, int MaxRows, int MaxCols, int MaxDepth, int KcFactor>
+class gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols, MaxDepth, KcFactor, true /* == FiniteAtCompileTime */>
+  : public level3_blocking<
+      typename conditional<StorageOrder==RowMajor,_RhsScalar,_LhsScalar>::type,
+      typename conditional<StorageOrder==RowMajor,_LhsScalar,_RhsScalar>::type>
+{
+    enum {
+      Transpose = StorageOrder==RowMajor,
+      ActualRows = Transpose ? MaxCols : MaxRows,
+      ActualCols = Transpose ? MaxRows : MaxCols
+    };
+    typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsScalar;
+    typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsScalar;
+    typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+    enum {
+      SizeA = ActualRows * MaxDepth,
+      SizeB = ActualCols * MaxDepth
+    };
+
+#if EIGEN_MAX_STATIC_ALIGN_BYTES >= EIGEN_DEFAULT_ALIGN_BYTES
+    EIGEN_ALIGN_MAX LhsScalar m_staticA[SizeA];
+    EIGEN_ALIGN_MAX RhsScalar m_staticB[SizeB];
+#else
+    EIGEN_ALIGN_MAX char m_staticA[SizeA * sizeof(LhsScalar) + EIGEN_DEFAULT_ALIGN_BYTES-1];
+    EIGEN_ALIGN_MAX char m_staticB[SizeB * sizeof(RhsScalar) + EIGEN_DEFAULT_ALIGN_BYTES-1];
+#endif
+
+  public:
+
+    gemm_blocking_space(Index /*rows*/, Index /*cols*/, Index /*depth*/, Index /*num_threads*/, bool /*full_rows = false*/)
+    {
+      this->m_mc = ActualRows;
+      this->m_nc = ActualCols;
+      this->m_kc = MaxDepth;
+#if EIGEN_MAX_STATIC_ALIGN_BYTES >= EIGEN_DEFAULT_ALIGN_BYTES
+      this->m_blockA = m_staticA;
+      this->m_blockB = m_staticB;
+#else
+      this->m_blockA = reinterpret_cast<LhsScalar*>((internal::UIntPtr(m_staticA) + (EIGEN_DEFAULT_ALIGN_BYTES-1)) & ~std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1));
+      this->m_blockB = reinterpret_cast<RhsScalar*>((internal::UIntPtr(m_staticB) + (EIGEN_DEFAULT_ALIGN_BYTES-1)) & ~std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1));
+#endif
+    }
+
+    void initParallel(Index, Index, Index, Index)
+    {}
+
+    inline void allocateA() {}
+    inline void allocateB() {}
+    inline void allocateAll() {}
+};
+
+template<int StorageOrder, typename _LhsScalar, typename _RhsScalar, int MaxRows, int MaxCols, int MaxDepth, int KcFactor>
+class gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols, MaxDepth, KcFactor, false>
+  : public level3_blocking<
+      typename conditional<StorageOrder==RowMajor,_RhsScalar,_LhsScalar>::type,
+      typename conditional<StorageOrder==RowMajor,_LhsScalar,_RhsScalar>::type>
+{
+    enum {
+      Transpose = StorageOrder==RowMajor
+    };
+    typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsScalar;
+    typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsScalar;
+    typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+    Index m_sizeA;
+    Index m_sizeB;
+
+  public:
+
+    gemm_blocking_space(Index rows, Index cols, Index depth, Index num_threads, bool l3_blocking)
+    {
+      this->m_mc = Transpose ? cols : rows;
+      this->m_nc = Transpose ? rows : cols;
+      this->m_kc = depth;
+
+      if(l3_blocking)
+      {
+        computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, this->m_mc, this->m_nc, num_threads);
+      }
+      else  // no l3 blocking
+      {
+        Index n = this->m_nc;
+        computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, this->m_mc, n, num_threads);
+      }
+
+      m_sizeA = this->m_mc * this->m_kc;
+      m_sizeB = this->m_kc * this->m_nc;
+    }
+
+    void initParallel(Index rows, Index cols, Index depth, Index num_threads)
+    {
+      this->m_mc = Transpose ? cols : rows;
+      this->m_nc = Transpose ? rows : cols;
+      this->m_kc = depth;
+
+      eigen_internal_assert(this->m_blockA==0 && this->m_blockB==0);
+      Index m = this->m_mc;
+      computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, m, this->m_nc, num_threads);
+      m_sizeA = this->m_mc * this->m_kc;
+      m_sizeB = this->m_kc * this->m_nc;
+    }
+
+    void allocateA()
+    {
+      if(this->m_blockA==0)
+        this->m_blockA = aligned_new<LhsScalar>(m_sizeA);
+    }
+
+    void allocateB()
+    {
+      if(this->m_blockB==0)
+        this->m_blockB = aligned_new<RhsScalar>(m_sizeB);
+    }
+
+    void allocateAll()
+    {
+      allocateA();
+      allocateB();
+    }
+
+    ~gemm_blocking_space()
+    {
+      aligned_delete(this->m_blockA, m_sizeA);
+      aligned_delete(this->m_blockB, m_sizeB);
+    }
+};
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs>
+struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  typedef typename Lhs::Scalar LhsScalar;
+  typedef typename Rhs::Scalar RhsScalar;
+
+  typedef internal::blas_traits<Lhs> LhsBlasTraits;
+  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+  typedef typename internal::remove_all<ActualLhsType>::type ActualLhsTypeCleaned;
+
+  typedef internal::blas_traits<Rhs> RhsBlasTraits;
+  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+  enum {
+    MaxDepthAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(Lhs::MaxColsAtCompileTime,Rhs::MaxRowsAtCompileTime)
+  };
+
+  typedef generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,CoeffBasedProductMode> lazyproduct;
+
+  template<typename Dst>
+  static void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    // See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=404 for a discussion and helper program
+    // to determine the following heuristic.
+    // EIGEN_GEMM_TO_COEFFBASED_THRESHOLD is typically defined to 20 in GeneralProduct.h,
+    // unless it has been specialized by the user or for a given architecture.
+    // Note that the condition rhs.rows()>0 was required because lazy product is (was?) not happy with empty inputs.
+    // I'm not sure it is still required.
+    if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
+      lazyproduct::eval_dynamic(dst, lhs, rhs, internal::assign_op<typename Dst::Scalar,Scalar>());
+    else
+    {
+      dst.setZero();
+      scaleAndAddTo(dst, lhs, rhs, Scalar(1));
+    }
+  }
+
+  template<typename Dst>
+  static void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
+      lazyproduct::eval_dynamic(dst, lhs, rhs, internal::add_assign_op<typename Dst::Scalar,Scalar>());
+    else
+      scaleAndAddTo(dst,lhs, rhs, Scalar(1));
+  }
+
+  template<typename Dst>
+  static void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
+      lazyproduct::eval_dynamic(dst, lhs, rhs, internal::sub_assign_op<typename Dst::Scalar,Scalar>());
+    else
+      scaleAndAddTo(dst, lhs, rhs, Scalar(-1));
+  }
+
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& a_lhs, const Rhs& a_rhs, const Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==a_lhs.rows() && dst.cols()==a_rhs.cols());
+    if(a_lhs.cols()==0 || a_lhs.rows()==0 || a_rhs.cols()==0)
+      return;
+
+    if (dst.cols() == 1)
+    {
+      // Fallback to GEMV if either the lhs or rhs is a runtime vector
+      typename Dest::ColXpr dst_vec(dst.col(0));
+      return internal::generic_product_impl<Lhs,typename Rhs::ConstColXpr,DenseShape,DenseShape,GemvProduct>
+        ::scaleAndAddTo(dst_vec, a_lhs, a_rhs.col(0), alpha);
+    }
+    else if (dst.rows() == 1)
+    {
+      // Fallback to GEMV if either the lhs or rhs is a runtime vector
+      typename Dest::RowXpr dst_vec(dst.row(0));
+      return internal::generic_product_impl<typename Lhs::ConstRowXpr,Rhs,DenseShape,DenseShape,GemvProduct>
+        ::scaleAndAddTo(dst_vec, a_lhs.row(0), a_rhs, alpha);
+    }
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    Scalar actualAlpha = combine_scalar_factors(alpha, a_lhs, a_rhs);
+
+    typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,LhsScalar,RhsScalar,
+            Dest::MaxRowsAtCompileTime,Dest::MaxColsAtCompileTime,MaxDepthAtCompileTime> BlockingType;
+
+    typedef internal::gemm_functor<
+      Scalar, Index,
+      internal::general_matrix_matrix_product<
+        Index,
+        LhsScalar, (ActualLhsTypeCleaned::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(LhsBlasTraits::NeedToConjugate),
+        RhsScalar, (ActualRhsTypeCleaned::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(RhsBlasTraits::NeedToConjugate),
+        (Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,
+        Dest::InnerStrideAtCompileTime>,
+      ActualLhsTypeCleaned, ActualRhsTypeCleaned, Dest, BlockingType> GemmFunctor;
+
+    BlockingType blocking(dst.rows(), dst.cols(), lhs.cols(), 1, true);
+    internal::parallelize_gemm<(Dest::MaxRowsAtCompileTime>32 || Dest::MaxRowsAtCompileTime==Dynamic)>
+        (GemmFunctor(lhs, rhs, dst, actualAlpha, blocking), a_lhs.rows(), a_rhs.cols(), a_lhs.cols(), Dest::Flags&RowMajorBit);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
new file mode 100644
index 00000000..6ba0d9bd
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
@@ -0,0 +1,317 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
+
+namespace Eigen { 
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjLhs, bool ConjRhs>
+struct selfadjoint_rank1_update;
+
+namespace internal {
+
+/**********************************************************************
+* This file implements a general A * B product while
+* evaluating only one triangular part of the product.
+* This is a more general version of self adjoint product (C += A A^T)
+* as the level 3 SYRK Blas routine.
+**********************************************************************/
+
+// forward declarations (defined at the end of this file)
+template<typename LhsScalar, typename RhsScalar, typename Index, int mr, int nr, bool ConjLhs, bool ConjRhs, int ResInnerStride, int UpLo>
+struct tribb_kernel;
+  
+/* Optimized matrix-matrix product evaluating only one triangular half */
+template <typename Index,
+          typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+                              int ResStorageOrder, int ResInnerStride, int  UpLo, int Version = Specialized>
+struct general_matrix_matrix_triangular_product;
+
+// as usual if the result is row major => we transpose the product
+template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+                          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+                          int ResInnerStride, int  UpLo, int Version>
+struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor,ResInnerStride,UpLo,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* lhs, Index lhsStride,
+                                      const RhsScalar* rhs, Index rhsStride, ResScalar* res, Index resIncr, Index resStride,
+                                      const ResScalar& alpha, level3_blocking<RhsScalar,LhsScalar>& blocking)
+  {
+    general_matrix_matrix_triangular_product<Index,
+        RhsScalar, RhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateRhs,
+        LhsScalar, LhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateLhs,
+        ColMajor, ResInnerStride, UpLo==Lower?Upper:Lower>
+      ::run(size,depth,rhs,rhsStride,lhs,lhsStride,res,resIncr,resStride,alpha,blocking);
+  }
+};
+
+template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+                          typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+                          int ResInnerStride, int  UpLo, int Version>
+struct general_matrix_matrix_triangular_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride,UpLo,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const LhsScalar* _lhs, Index lhsStride,
+                                      const RhsScalar* _rhs, Index rhsStride,
+                                      ResScalar* _res, Index resIncr, Index resStride,
+                                      const ResScalar& alpha, level3_blocking<LhsScalar,RhsScalar>& blocking)
+  {
+    typedef gebp_traits<LhsScalar,RhsScalar> Traits;
+
+    typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride, resIncr);
+
+    Index kc = blocking.kc();
+    Index mc = (std::min)(size,blocking.mc());
+
+    // !!! mc must be a multiple of nr:
+    if(mc > Traits::nr)
+      mc = (mc/Traits::nr)*Traits::nr;
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*size;
+
+    ei_declare_aligned_stack_constructed_variable(LhsScalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, blocking.blockB());
+
+    gemm_pack_lhs<LhsScalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<RhsScalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
+    gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp;
+    tribb_kernel<LhsScalar, RhsScalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs, ResInnerStride, UpLo> sybb;
+
+    for(Index k2=0; k2<depth; k2+=kc)
+    {
+      const Index actual_kc = (std::min)(k2+kc,depth)-k2;
+
+      // note that the actual rhs is the transpose/adjoint of mat
+      pack_rhs(blockB, rhs.getSubMapper(k2,0), actual_kc, size);
+
+      for(Index i2=0; i2<size; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,size)-i2;
+
+        pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        // the selected actual_mc * size panel of res is split into three different part:
+        //  1 - before the diagonal => processed with gebp or skipped
+        //  2 - the actual_mc x actual_mc symmetric block => processed with a special kernel
+        //  3 - after the diagonal => processed with gebp or skipped
+        if (UpLo==Lower)
+          gebp(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc,
+               (std::min)(size,i2), alpha, -1, -1, 0, 0);
+
+        sybb(_res+resStride*i2 + resIncr*i2, resIncr, resStride, blockA, blockB + actual_kc*i2, actual_mc, actual_kc, alpha);
+
+        if (UpLo==Upper)
+        {
+          Index j2 = i2+actual_mc;
+          gebp(res.getSubMapper(i2, j2), blockA, blockB+actual_kc*j2, actual_mc,
+               actual_kc, (std::max)(Index(0), size-j2), alpha, -1, -1, 0, 0);
+        }
+      }
+    }
+  }
+};
+
+// Optimized packed Block * packed Block product kernel evaluating only one given triangular part
+// This kernel is built on top of the gebp kernel:
+// - the current destination block is processed per panel of actual_mc x BlockSize
+//   where BlockSize is set to the minimal value allowing gebp to be as fast as possible
+// - then, as usual, each panel is split into three parts along the diagonal,
+//   the sub blocks above and below the diagonal are processed as usual,
+//   while the triangular block overlapping the diagonal is evaluated into a
+//   small temporary buffer which is then accumulated into the result using a
+//   triangular traversal.
+template<typename LhsScalar, typename RhsScalar, typename Index, int mr, int nr, bool ConjLhs, bool ConjRhs, int ResInnerStride, int UpLo>
+struct tribb_kernel
+{
+  typedef gebp_traits<LhsScalar,RhsScalar,ConjLhs,ConjRhs> Traits;
+  typedef typename Traits::ResScalar ResScalar;
+
+  enum {
+    BlockSize  = meta_least_common_multiple<EIGEN_PLAIN_ENUM_MAX(mr,nr),EIGEN_PLAIN_ENUM_MIN(mr,nr)>::ret
+  };
+  void operator()(ResScalar* _res, Index resIncr, Index resStride, const LhsScalar* blockA, const RhsScalar* blockB, Index size, Index depth, const ResScalar& alpha)
+  {
+    typedef blas_data_mapper<ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    typedef blas_data_mapper<ResScalar, Index, ColMajor, Unaligned> BufferMapper;
+    ResMapper res(_res, resStride, resIncr);
+    gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, mr, nr, ConjLhs, ConjRhs> gebp_kernel1;
+    gebp_kernel<LhsScalar, RhsScalar, Index, BufferMapper, mr, nr, ConjLhs, ConjRhs> gebp_kernel2;
+
+    Matrix<ResScalar,BlockSize,BlockSize,ColMajor> buffer((internal::constructor_without_unaligned_array_assert()));
+
+    // let's process the block per panel of actual_mc x BlockSize,
+    // again, each is split into three parts, etc.
+    for (Index j=0; j<size; j+=BlockSize)
+    {
+      Index actualBlockSize = std::min<Index>(BlockSize,size - j);
+      const RhsScalar* actual_b = blockB+j*depth;
+
+      if(UpLo==Upper)
+        gebp_kernel1(res.getSubMapper(0, j), blockA, actual_b, j, depth, actualBlockSize, alpha,
+                     -1, -1, 0, 0);
+      
+      // selfadjoint micro block
+      {
+        Index i = j;
+        buffer.setZero();
+        // 1 - apply the kernel on the temporary buffer
+        gebp_kernel2(BufferMapper(buffer.data(), BlockSize), blockA+depth*i, actual_b, actualBlockSize, depth, actualBlockSize, alpha,
+                     -1, -1, 0, 0);
+
+        // 2 - triangular accumulation
+        for(Index j1=0; j1<actualBlockSize; ++j1)
+        {
+          typename ResMapper::LinearMapper r = res.getLinearMapper(i,j+j1);
+          for(Index i1=UpLo==Lower ? j1 : 0;
+              UpLo==Lower ? i1<actualBlockSize : i1<=j1; ++i1)
+            r(i1) += buffer(i1,j1);
+        }
+      }
+
+      if(UpLo==Lower)
+      {
+        Index i = j+actualBlockSize;
+        gebp_kernel1(res.getSubMapper(i, j), blockA+depth*i, actual_b, size-i, 
+                     depth, actualBlockSize, alpha, -1, -1, 0, 0);
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+// high level API
+
+template<typename MatrixType, typename ProductType, int UpLo, bool IsOuterProduct>
+struct general_product_to_triangular_selector;
+
+
+template<typename MatrixType, typename ProductType, int UpLo>
+struct general_product_to_triangular_selector<MatrixType,ProductType,UpLo,true>
+{
+  static void run(MatrixType& mat, const ProductType& prod, const typename MatrixType::Scalar& alpha, bool beta)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    
+    typedef typename internal::remove_all<typename ProductType::LhsNested>::type Lhs;
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
+    typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
+    typename internal::add_const_on_value_type<ActualLhs>::type actualLhs = LhsBlasTraits::extract(prod.lhs());
+    
+    typedef typename internal::remove_all<typename ProductType::RhsNested>::type Rhs;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
+    typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
+    typename internal::add_const_on_value_type<ActualRhs>::type actualRhs = RhsBlasTraits::extract(prod.rhs());
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(prod.lhs().derived()) * RhsBlasTraits::extractScalarFactor(prod.rhs().derived());
+
+    if(!beta)
+      mat.template triangularView<UpLo>().setZero();
+
+    enum {
+      StorageOrder = (internal::traits<MatrixType>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+      UseLhsDirectly = _ActualLhs::InnerStrideAtCompileTime==1,
+      UseRhsDirectly = _ActualRhs::InnerStrideAtCompileTime==1
+    };
+    
+    internal::gemv_static_vector_if<Scalar,Lhs::SizeAtCompileTime,Lhs::MaxSizeAtCompileTime,!UseLhsDirectly> static_lhs;
+    ei_declare_aligned_stack_constructed_variable(Scalar, actualLhsPtr, actualLhs.size(),
+      (UseLhsDirectly ? const_cast<Scalar*>(actualLhs.data()) : static_lhs.data()));
+    if(!UseLhsDirectly) Map<typename _ActualLhs::PlainObject>(actualLhsPtr, actualLhs.size()) = actualLhs;
+    
+    internal::gemv_static_vector_if<Scalar,Rhs::SizeAtCompileTime,Rhs::MaxSizeAtCompileTime,!UseRhsDirectly> static_rhs;
+    ei_declare_aligned_stack_constructed_variable(Scalar, actualRhsPtr, actualRhs.size(),
+      (UseRhsDirectly ? const_cast<Scalar*>(actualRhs.data()) : static_rhs.data()));
+    if(!UseRhsDirectly) Map<typename _ActualRhs::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    
+    
+    selfadjoint_rank1_update<Scalar,Index,StorageOrder,UpLo,
+                              LhsBlasTraits::NeedToConjugate && NumTraits<Scalar>::IsComplex,
+                              RhsBlasTraits::NeedToConjugate && NumTraits<Scalar>::IsComplex>
+          ::run(actualLhs.size(), mat.data(), mat.outerStride(), actualLhsPtr, actualRhsPtr, actualAlpha);
+  }
+};
+
+template<typename MatrixType, typename ProductType, int UpLo>
+struct general_product_to_triangular_selector<MatrixType,ProductType,UpLo,false>
+{
+  static void run(MatrixType& mat, const ProductType& prod, const typename MatrixType::Scalar& alpha, bool beta)
+  {
+    typedef typename internal::remove_all<typename ProductType::LhsNested>::type Lhs;
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
+    typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
+    typename internal::add_const_on_value_type<ActualLhs>::type actualLhs = LhsBlasTraits::extract(prod.lhs());
+    
+    typedef typename internal::remove_all<typename ProductType::RhsNested>::type Rhs;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
+    typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
+    typename internal::add_const_on_value_type<ActualRhs>::type actualRhs = RhsBlasTraits::extract(prod.rhs());
+
+    typename ProductType::Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(prod.lhs().derived()) * RhsBlasTraits::extractScalarFactor(prod.rhs().derived());
+
+    if(!beta)
+      mat.template triangularView<UpLo>().setZero();
+
+    enum {
+      IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0,
+      LhsIsRowMajor = _ActualLhs::Flags&RowMajorBit ? 1 : 0,
+      RhsIsRowMajor = _ActualRhs::Flags&RowMajorBit ? 1 : 0,
+      SkipDiag = (UpLo&(UnitDiag|ZeroDiag))!=0
+    };
+
+    Index size = mat.cols();
+    if(SkipDiag)
+      size--;
+    Index depth = actualLhs.cols();
+
+    typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,typename Lhs::Scalar,typename Rhs::Scalar,
+          MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime, _ActualRhs::MaxColsAtCompileTime> BlockingType;
+
+    BlockingType blocking(size, size, depth, 1, false);
+
+    internal::general_matrix_matrix_triangular_product<Index,
+      typename Lhs::Scalar, LhsIsRowMajor ? RowMajor : ColMajor, LhsBlasTraits::NeedToConjugate,
+      typename Rhs::Scalar, RhsIsRowMajor ? RowMajor : ColMajor, RhsBlasTraits::NeedToConjugate,
+      IsRowMajor ? RowMajor : ColMajor, MatrixType::InnerStrideAtCompileTime, UpLo&(Lower|Upper)>
+      ::run(size, depth,
+            &actualLhs.coeffRef(SkipDiag&&(UpLo&Lower)==Lower ? 1 : 0,0), actualLhs.outerStride(),
+            &actualRhs.coeffRef(0,SkipDiag&&(UpLo&Upper)==Upper ? 1 : 0), actualRhs.outerStride(),
+            mat.data() + (SkipDiag ? (bool(IsRowMajor) != ((UpLo&Lower)==Lower) ? mat.innerStride() : mat.outerStride() ) : 0),
+            mat.innerStride(), mat.outerStride(), actualAlpha, blocking);
+  }
+};
+
+template<typename MatrixType, unsigned int UpLo>
+template<typename ProductType>
+EIGEN_DEVICE_FUNC TriangularView<MatrixType,UpLo>& TriangularViewImpl<MatrixType,UpLo,Dense>::_assignProduct(const ProductType& prod, const Scalar& alpha, bool beta)
+{
+  EIGEN_STATIC_ASSERT((UpLo&UnitDiag)==0, WRITING_TO_TRIANGULAR_PART_WITH_UNIT_DIAGONAL_IS_NOT_SUPPORTED);
+  eigen_assert(derived().nestedExpression().rows() == prod.rows() && derived().cols() == prod.cols());
+
+  general_product_to_triangular_selector<MatrixType, ProductType, UpLo, internal::traits<ProductType>::InnerSize==1>::run(derived().nestedExpression().const_cast_derived(), prod, alpha, beta);
+
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
new file mode 100644
index 00000000..9a650ec2
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
@@ -0,0 +1,145 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Level 3 BLAS SYRK/HERK implementation.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Index, typename Scalar, int AStorageOrder, bool ConjugateA, int ResStorageOrder, int UpLo>
+struct general_matrix_matrix_rankupdate :
+       general_matrix_matrix_triangular_product<
+         Index,Scalar,AStorageOrder,ConjugateA,Scalar,AStorageOrder,ConjugateA,ResStorageOrder,1,UpLo,BuiltIn> {};
+
+
+// try to go to BLAS specialization
+#define EIGEN_BLAS_RANKUPDATE_SPECIALIZE(Scalar) \
+template <typename Index, int LhsStorageOrder, bool ConjugateLhs, \
+                          int RhsStorageOrder, bool ConjugateRhs, int  UpLo> \
+struct general_matrix_matrix_triangular_product<Index,Scalar,LhsStorageOrder,ConjugateLhs, \
+               Scalar,RhsStorageOrder,ConjugateRhs,ColMajor,1,UpLo,Specialized> { \
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const Scalar* lhs, Index lhsStride, \
+                          const Scalar* rhs, Index rhsStride, Scalar* res, Index resIncr, Index resStride, Scalar alpha, level3_blocking<Scalar, Scalar>& blocking) \
+  { \
+    if ( lhs==rhs && ((UpLo&(Lower|Upper))==UpLo) ) { \
+      general_matrix_matrix_rankupdate<Index,Scalar,LhsStorageOrder,ConjugateLhs,ColMajor,UpLo> \
+      ::run(size,depth,lhs,lhsStride,rhs,rhsStride,res,resStride,alpha,blocking); \
+    } else { \
+      general_matrix_matrix_triangular_product<Index, \
+        Scalar, LhsStorageOrder, ConjugateLhs, \
+        Scalar, RhsStorageOrder, ConjugateRhs, \
+        ColMajor, 1, UpLo, BuiltIn> \
+      ::run(size,depth,lhs,lhsStride,rhs,rhsStride,res,resIncr,resStride,alpha,blocking); \
+    } \
+  } \
+};
+
+EIGEN_BLAS_RANKUPDATE_SPECIALIZE(double)
+EIGEN_BLAS_RANKUPDATE_SPECIALIZE(float)
+// TODO handle complex cases
+// EIGEN_BLAS_RANKUPDATE_SPECIALIZE(dcomplex)
+// EIGEN_BLAS_RANKUPDATE_SPECIALIZE(scomplex)
+
+// SYRK for float/double
+#define EIGEN_BLAS_RANKUPDATE_R(EIGTYPE, BLASTYPE, BLASFUNC) \
+template <typename Index, int AStorageOrder, bool ConjugateA, int  UpLo> \
+struct general_matrix_matrix_rankupdate<Index,EIGTYPE,AStorageOrder,ConjugateA,ColMajor,UpLo> { \
+  enum { \
+    IsLower = (UpLo&Lower) == Lower, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = ((AStorageOrder==ColMajor) && ConjugateA) ? 1 : 0 \
+  }; \
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const EIGTYPE* lhs, Index lhsStride, \
+                          const EIGTYPE* /*rhs*/, Index /*rhsStride*/, EIGTYPE* res, Index resStride, EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+  /* typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs;*/ \
+\
+   BlasIndex lda=convert_index<BlasIndex>(lhsStride), ldc=convert_index<BlasIndex>(resStride), n=convert_index<BlasIndex>(size), k=convert_index<BlasIndex>(depth); \
+   char uplo=((IsLower) ? 'L' : 'U'), trans=((AStorageOrder==RowMajor) ? 'T':'N'); \
+   EIGTYPE beta(1); \
+   BLASFUNC(&uplo, &trans, &n, &k, (const BLASTYPE*)&numext::real_ref(alpha), lhs, &lda, (const BLASTYPE*)&numext::real_ref(beta), res, &ldc); \
+  } \
+};
+
+// HERK for complex data
+#define EIGEN_BLAS_RANKUPDATE_C(EIGTYPE, BLASTYPE, RTYPE, BLASFUNC) \
+template <typename Index, int AStorageOrder, bool ConjugateA, int  UpLo> \
+struct general_matrix_matrix_rankupdate<Index,EIGTYPE,AStorageOrder,ConjugateA,ColMajor,UpLo> { \
+  enum { \
+    IsLower = (UpLo&Lower) == Lower, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = (((AStorageOrder==ColMajor) && ConjugateA) || ((AStorageOrder==RowMajor) && !ConjugateA)) ? 1 : 0 \
+  }; \
+  static EIGEN_STRONG_INLINE void run(Index size, Index depth,const EIGTYPE* lhs, Index lhsStride, \
+                          const EIGTYPE* /*rhs*/, Index /*rhsStride*/, EIGTYPE* res, Index resStride, EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, AStorageOrder> MatrixType; \
+\
+   BlasIndex lda=convert_index<BlasIndex>(lhsStride), ldc=convert_index<BlasIndex>(resStride), n=convert_index<BlasIndex>(size), k=convert_index<BlasIndex>(depth); \
+   char uplo=((IsLower) ? 'L' : 'U'), trans=((AStorageOrder==RowMajor) ? 'C':'N'); \
+   RTYPE alpha_, beta_; \
+   const EIGTYPE* a_ptr; \
+\
+   alpha_ = alpha.real(); \
+   beta_ = 1.0; \
+/* Copy with conjugation in some cases*/ \
+   MatrixType a; \
+   if (conjA) { \
+     Map<const MatrixType, 0, OuterStride<> > mapA(lhs,n,k,OuterStride<>(lhsStride)); \
+     a = mapA.conjugate(); \
+     lda = a.outerStride(); \
+     a_ptr = a.data(); \
+   } else a_ptr=lhs; \
+   BLASFUNC(&uplo, &trans, &n, &k, &alpha_, (BLASTYPE*)a_ptr, &lda, &beta_, (BLASTYPE*)res, &ldc); \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_RANKUPDATE_R(double, double, dsyrk)
+EIGEN_BLAS_RANKUPDATE_R(float,  float,  ssyrk)
+#else
+EIGEN_BLAS_RANKUPDATE_R(double, double, dsyrk_)
+EIGEN_BLAS_RANKUPDATE_R(float,  float,  ssyrk_)
+#endif
+
+// TODO hanlde complex cases
+// EIGEN_BLAS_RANKUPDATE_C(dcomplex, double, double, zherk_)
+// EIGEN_BLAS_RANKUPDATE_C(scomplex, float,  float, cherk_)
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
new file mode 100644
index 00000000..71abf401
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
@@ -0,0 +1,124 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   General matrix-matrix product functionality based on ?GEMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
+#define EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements general matrix-matrix multiplication using BLAS
+* gemm function via partial specialization of
+* general_matrix_matrix_product::run(..) method for float, double,
+* std::complex<float> and std::complex<double> types
+**********************************************************************/
+
+// gemm specialization
+
+#define GEMM_SPECIALIZATION(EIGTYPE, EIGPREFIX, BLASTYPE, BLASFUNC) \
+template< \
+  typename Index, \
+  int LhsStorageOrder, bool ConjugateLhs, \
+  int RhsStorageOrder, bool ConjugateRhs> \
+struct general_matrix_matrix_product<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,RhsStorageOrder,ConjugateRhs,ColMajor,1> \
+{ \
+typedef gebp_traits<EIGTYPE,EIGTYPE> Traits; \
+\
+static void run(Index rows, Index cols, Index depth, \
+  const EIGTYPE* _lhs, Index lhsStride, \
+  const EIGTYPE* _rhs, Index rhsStride, \
+  EIGTYPE* res, Index resIncr, Index resStride, \
+  EIGTYPE alpha, \
+  level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/, \
+  GemmParallelInfo<Index>* /*info = 0*/) \
+{ \
+  using std::conj; \
+\
+  EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+  eigen_assert(resIncr == 1); \
+  char transa, transb; \
+  BlasIndex m, n, k, lda, ldb, ldc; \
+  const EIGTYPE *a, *b; \
+  EIGTYPE beta(1); \
+  MatrixX##EIGPREFIX a_tmp, b_tmp; \
+\
+/* Set transpose options */ \
+  transa = (LhsStorageOrder==RowMajor) ? ((ConjugateLhs) ? 'C' : 'T') : 'N'; \
+  transb = (RhsStorageOrder==RowMajor) ? ((ConjugateRhs) ? 'C' : 'T') : 'N'; \
+\
+/* Set m, n, k */ \
+  m = convert_index<BlasIndex>(rows);  \
+  n = convert_index<BlasIndex>(cols);  \
+  k = convert_index<BlasIndex>(depth); \
+\
+/* Set lda, ldb, ldc */ \
+  lda = convert_index<BlasIndex>(lhsStride); \
+  ldb = convert_index<BlasIndex>(rhsStride); \
+  ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+  if ((LhsStorageOrder==ColMajor) && (ConjugateLhs)) { \
+    Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,m,k,OuterStride<>(lhsStride)); \
+    a_tmp = lhs.conjugate(); \
+    a = a_tmp.data(); \
+    lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+  } else a = _lhs; \
+\
+  if ((RhsStorageOrder==ColMajor) && (ConjugateRhs)) { \
+    Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,k,n,OuterStride<>(rhsStride)); \
+    b_tmp = rhs.conjugate(); \
+    b = b_tmp.data(); \
+    ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+  } else b = _rhs; \
+\
+  BLASFUNC(&transa, &transb, &m, &n, &k, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+}};
+
+#ifdef EIGEN_USE_MKL
+GEMM_SPECIALIZATION(double,   d,  double, dgemm)
+GEMM_SPECIALIZATION(float,    f,  float,  sgemm)
+GEMM_SPECIALIZATION(dcomplex, cd, MKL_Complex16, zgemm)
+GEMM_SPECIALIZATION(scomplex, cf, MKL_Complex8,  cgemm)
+#else
+GEMM_SPECIALIZATION(double,   d,  double, dgemm_)
+GEMM_SPECIALIZATION(float,    f,  float,  sgemm_)
+GEMM_SPECIALIZATION(dcomplex, cd, double, zgemm_)
+GEMM_SPECIALIZATION(scomplex, cf, float,  cgemm_)
+#endif
+
+} // end namespase internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixVector.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixVector.h
new file mode 100644
index 00000000..dfb6aebc
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixVector.h
@@ -0,0 +1,518 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERAL_MATRIX_VECTOR_H
+#define EIGEN_GENERAL_MATRIX_VECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+enum GEMVPacketSizeType {
+  GEMVPacketFull = 0,
+  GEMVPacketHalf,
+  GEMVPacketQuarter
+};
+
+template <int N, typename T1, typename T2, typename T3>
+struct gemv_packet_cond { typedef T3 type; };
+
+template <typename T1, typename T2, typename T3>
+struct gemv_packet_cond<GEMVPacketFull, T1, T2, T3> { typedef T1 type; };
+
+template <typename T1, typename T2, typename T3>
+struct gemv_packet_cond<GEMVPacketHalf, T1, T2, T3> { typedef T2 type; };
+
+template<typename LhsScalar, typename RhsScalar, int _PacketSize=GEMVPacketFull>
+class gemv_traits
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+#define PACKET_DECL_COND_PREFIX(prefix, name, packet_size)                        \
+  typedef typename gemv_packet_cond<packet_size,                                  \
+                                    typename packet_traits<name ## Scalar>::type, \
+                                    typename packet_traits<name ## Scalar>::half, \
+                                    typename unpacket_traits<typename packet_traits<name ## Scalar>::half>::half>::type \
+  prefix ## name ## Packet
+
+  PACKET_DECL_COND_PREFIX(_, Lhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Rhs, _PacketSize);
+  PACKET_DECL_COND_PREFIX(_, Res, _PacketSize);
+#undef PACKET_DECL_COND_PREFIX
+
+public:
+  enum {
+        Vectorizable = unpacket_traits<_LhsPacket>::vectorizable &&
+        unpacket_traits<_RhsPacket>::vectorizable &&
+        int(unpacket_traits<_LhsPacket>::size)==int(unpacket_traits<_RhsPacket>::size),
+        LhsPacketSize = Vectorizable ? unpacket_traits<_LhsPacket>::size : 1,
+        RhsPacketSize = Vectorizable ? unpacket_traits<_RhsPacket>::size : 1,
+        ResPacketSize = Vectorizable ? unpacket_traits<_ResPacket>::size : 1
+  };
+
+  typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type LhsPacket;
+  typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type RhsPacket;
+  typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type ResPacket;
+};
+
+
+/* Optimized col-major matrix * vector product:
+ * This algorithm processes the matrix per vertical panels,
+ * which are then processed horizontaly per chunck of 8*PacketSize x 1 vertical segments.
+ *
+ * Mixing type logic: C += alpha * A * B
+ *  |  A  |  B  |alpha| comments
+ *  |real |cplx |cplx | no vectorization
+ *  |real |cplx |real | alpha is converted to a cplx when calling the run function, no vectorization
+ *  |cplx |real |cplx | invalid, the caller has to do tmp: = A * B; C += alpha*tmp
+ *  |cplx |real |real | optimal case, vectorization possible via real-cplx mul
+ *
+ * The same reasoning apply for the transposed case.
+ */
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>
+{
+  typedef gemv_traits<LhsScalar,RhsScalar> Traits;
+  typedef gemv_traits<LhsScalar,RhsScalar,GEMVPacketHalf> HalfTraits;
+  typedef gemv_traits<LhsScalar,RhsScalar,GEMVPacketQuarter> QuarterTraits;
+
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  typedef typename Traits::LhsPacket LhsPacket;
+  typedef typename Traits::RhsPacket RhsPacket;
+  typedef typename Traits::ResPacket ResPacket;
+
+  typedef typename HalfTraits::LhsPacket LhsPacketHalf;
+  typedef typename HalfTraits::RhsPacket RhsPacketHalf;
+  typedef typename HalfTraits::ResPacket ResPacketHalf;
+
+  typedef typename QuarterTraits::LhsPacket LhsPacketQuarter;
+  typedef typename QuarterTraits::RhsPacket RhsPacketQuarter;
+  typedef typename QuarterTraits::ResPacket ResPacketQuarter;
+
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run(
+  Index rows, Index cols,
+  const LhsMapper& lhs,
+  const RhsMapper& rhs,
+        ResScalar* res, Index resIncr,
+  RhsScalar alpha);
+};
+
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>::run(
+  Index rows, Index cols,
+  const LhsMapper& alhs,
+  const RhsMapper& rhs,
+        ResScalar* res, Index resIncr,
+  RhsScalar alpha)
+{
+  EIGEN_UNUSED_VARIABLE(resIncr);
+  eigen_internal_assert(resIncr==1);
+
+  // The following copy tells the compiler that lhs's attributes are not modified outside this function
+  // This helps GCC to generate propoer code.
+  LhsMapper lhs(alhs);
+
+  conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
+  conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj;
+  conj_helper<LhsPacketHalf,RhsPacketHalf,ConjugateLhs,ConjugateRhs> pcj_half;
+  conj_helper<LhsPacketQuarter,RhsPacketQuarter,ConjugateLhs,ConjugateRhs> pcj_quarter;
+
+  const Index lhsStride = lhs.stride();
+  // TODO: for padded aligned inputs, we could enable aligned reads
+  enum { LhsAlignment = Unaligned,
+         ResPacketSize = Traits::ResPacketSize,
+         ResPacketSizeHalf = HalfTraits::ResPacketSize,
+         ResPacketSizeQuarter = QuarterTraits::ResPacketSize,
+         LhsPacketSize = Traits::LhsPacketSize,
+         HasHalf = (int)ResPacketSizeHalf < (int)ResPacketSize,
+         HasQuarter = (int)ResPacketSizeQuarter < (int)ResPacketSizeHalf
+  };
+
+  const Index n8 = rows-8*ResPacketSize+1;
+  const Index n4 = rows-4*ResPacketSize+1;
+  const Index n3 = rows-3*ResPacketSize+1;
+  const Index n2 = rows-2*ResPacketSize+1;
+  const Index n1 = rows-1*ResPacketSize+1;
+  const Index n_half = rows-1*ResPacketSizeHalf+1;
+  const Index n_quarter = rows-1*ResPacketSizeQuarter+1;
+
+  // TODO: improve the following heuristic:
+  const Index block_cols = cols<128 ? cols : (lhsStride*sizeof(LhsScalar)<32000?16:4);
+  ResPacket palpha = pset1<ResPacket>(alpha);
+  ResPacketHalf palpha_half = pset1<ResPacketHalf>(alpha);
+  ResPacketQuarter palpha_quarter = pset1<ResPacketQuarter>(alpha);
+
+  for(Index j2=0; j2<cols; j2+=block_cols)
+  {
+    Index jend = numext::mini(j2+block_cols,cols);
+    Index i=0;
+    for(; i<n8; i+=ResPacketSize*8)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0)),
+                c2 = pset1<ResPacket>(ResScalar(0)),
+                c3 = pset1<ResPacket>(ResScalar(0)),
+                c4 = pset1<ResPacket>(ResScalar(0)),
+                c5 = pset1<ResPacket>(ResScalar(0)),
+                c6 = pset1<ResPacket>(ResScalar(0)),
+                c7 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+        c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*2,j),b0,c2);
+        c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*3,j),b0,c3);
+        c4 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*4,j),b0,c4);
+        c5 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*5,j),b0,c5);
+        c6 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*6,j),b0,c6);
+        c7 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*7,j),b0,c7);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      pstoreu(res+i+ResPacketSize*2, pmadd(c2,palpha,ploadu<ResPacket>(res+i+ResPacketSize*2)));
+      pstoreu(res+i+ResPacketSize*3, pmadd(c3,palpha,ploadu<ResPacket>(res+i+ResPacketSize*3)));
+      pstoreu(res+i+ResPacketSize*4, pmadd(c4,palpha,ploadu<ResPacket>(res+i+ResPacketSize*4)));
+      pstoreu(res+i+ResPacketSize*5, pmadd(c5,palpha,ploadu<ResPacket>(res+i+ResPacketSize*5)));
+      pstoreu(res+i+ResPacketSize*6, pmadd(c6,palpha,ploadu<ResPacket>(res+i+ResPacketSize*6)));
+      pstoreu(res+i+ResPacketSize*7, pmadd(c7,palpha,ploadu<ResPacket>(res+i+ResPacketSize*7)));
+    }
+    if(i<n4)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0)),
+                c2 = pset1<ResPacket>(ResScalar(0)),
+                c3 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+        c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*2,j),b0,c2);
+        c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*3,j),b0,c3);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      pstoreu(res+i+ResPacketSize*2, pmadd(c2,palpha,ploadu<ResPacket>(res+i+ResPacketSize*2)));
+      pstoreu(res+i+ResPacketSize*3, pmadd(c3,palpha,ploadu<ResPacket>(res+i+ResPacketSize*3)));
+
+      i+=ResPacketSize*4;
+    }
+    if(i<n3)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0)),
+                c2 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+        c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*2,j),b0,c2);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      pstoreu(res+i+ResPacketSize*2, pmadd(c2,palpha,ploadu<ResPacket>(res+i+ResPacketSize*2)));
+
+      i+=ResPacketSize*3;
+    }
+    if(i<n2)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+                c1 = pset1<ResPacket>(ResScalar(0));
+
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*0,j),b0,c0);
+        c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+LhsPacketSize*1,j),b0,c1);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      pstoreu(res+i+ResPacketSize*1, pmadd(c1,palpha,ploadu<ResPacket>(res+i+ResPacketSize*1)));
+      i+=ResPacketSize*2;
+    }
+    if(i<n1)
+    {
+      ResPacket c0 = pset1<ResPacket>(ResScalar(0));
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacket b0 = pset1<RhsPacket>(rhs(j,0));
+        c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      }
+      pstoreu(res+i+ResPacketSize*0, pmadd(c0,palpha,ploadu<ResPacket>(res+i+ResPacketSize*0)));
+      i+=ResPacketSize;
+    }
+    if(HasHalf && i<n_half)
+    {
+      ResPacketHalf c0 = pset1<ResPacketHalf>(ResScalar(0));
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacketHalf b0 = pset1<RhsPacketHalf>(rhs(j,0));
+        c0 = pcj_half.pmadd(lhs.template load<LhsPacketHalf,LhsAlignment>(i+0,j),b0,c0);
+      }
+      pstoreu(res+i+ResPacketSizeHalf*0, pmadd(c0,palpha_half,ploadu<ResPacketHalf>(res+i+ResPacketSizeHalf*0)));
+      i+=ResPacketSizeHalf;
+    }
+    if(HasQuarter && i<n_quarter)
+    {
+      ResPacketQuarter c0 = pset1<ResPacketQuarter>(ResScalar(0));
+      for(Index j=j2; j<jend; j+=1)
+      {
+        RhsPacketQuarter b0 = pset1<RhsPacketQuarter>(rhs(j,0));
+        c0 = pcj_quarter.pmadd(lhs.template load<LhsPacketQuarter,LhsAlignment>(i+0,j),b0,c0);
+      }
+      pstoreu(res+i+ResPacketSizeQuarter*0, pmadd(c0,palpha_quarter,ploadu<ResPacketQuarter>(res+i+ResPacketSizeQuarter*0)));
+      i+=ResPacketSizeQuarter;
+    }
+    for(;i<rows;++i)
+    {
+      ResScalar c0(0);
+      for(Index j=j2; j<jend; j+=1)
+        c0 += cj.pmul(lhs(i,j), rhs(j,0));
+      res[i] += alpha*c0;
+    }
+  }
+}
+
+/* Optimized row-major matrix * vector product:
+ * This algorithm processes 4 rows at once that allows to both reduce
+ * the number of load/stores of the result by a factor 4 and to reduce
+ * the instruction dependency. Moreover, we know that all bands have the
+ * same alignment pattern.
+ *
+ * Mixing type logic:
+ *  - alpha is always a complex (or converted to a complex)
+ *  - no vectorization
+ */
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+struct general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>
+{
+  typedef gemv_traits<LhsScalar,RhsScalar> Traits;
+  typedef gemv_traits<LhsScalar,RhsScalar,GEMVPacketHalf> HalfTraits;
+  typedef gemv_traits<LhsScalar,RhsScalar,GEMVPacketQuarter> QuarterTraits;
+
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  typedef typename Traits::LhsPacket LhsPacket;
+  typedef typename Traits::RhsPacket RhsPacket;
+  typedef typename Traits::ResPacket ResPacket;
+
+  typedef typename HalfTraits::LhsPacket LhsPacketHalf;
+  typedef typename HalfTraits::RhsPacket RhsPacketHalf;
+  typedef typename HalfTraits::ResPacket ResPacketHalf;
+
+  typedef typename QuarterTraits::LhsPacket LhsPacketQuarter;
+  typedef typename QuarterTraits::RhsPacket RhsPacketQuarter;
+  typedef typename QuarterTraits::ResPacket ResPacketQuarter;
+
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run(
+  Index rows, Index cols,
+  const LhsMapper& lhs,
+  const RhsMapper& rhs,
+        ResScalar* res, Index resIncr,
+  ResScalar alpha);
+};
+
+template<typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version>
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjugateLhs,RhsScalar,RhsMapper,ConjugateRhs,Version>::run(
+  Index rows, Index cols,
+  const LhsMapper& alhs,
+  const RhsMapper& rhs,
+  ResScalar* res, Index resIncr,
+  ResScalar alpha)
+{
+  // The following copy tells the compiler that lhs's attributes are not modified outside this function
+  // This helps GCC to generate propoer code.
+  LhsMapper lhs(alhs);
+
+  eigen_internal_assert(rhs.stride()==1);
+  conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj;
+  conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj;
+  conj_helper<LhsPacketHalf,RhsPacketHalf,ConjugateLhs,ConjugateRhs> pcj_half;
+  conj_helper<LhsPacketQuarter,RhsPacketQuarter,ConjugateLhs,ConjugateRhs> pcj_quarter;
+
+  // TODO: fine tune the following heuristic. The rationale is that if the matrix is very large,
+  //       processing 8 rows at once might be counter productive wrt cache.
+  const Index n8 = lhs.stride()*sizeof(LhsScalar)>32000 ? 0 : rows-7;
+  const Index n4 = rows-3;
+  const Index n2 = rows-1;
+
+  // TODO: for padded aligned inputs, we could enable aligned reads
+  enum { LhsAlignment = Unaligned,
+         ResPacketSize = Traits::ResPacketSize,
+         ResPacketSizeHalf = HalfTraits::ResPacketSize,
+         ResPacketSizeQuarter = QuarterTraits::ResPacketSize,
+         LhsPacketSize = Traits::LhsPacketSize,
+         LhsPacketSizeHalf = HalfTraits::LhsPacketSize,
+         LhsPacketSizeQuarter = QuarterTraits::LhsPacketSize,
+         HasHalf = (int)ResPacketSizeHalf < (int)ResPacketSize,
+         HasQuarter = (int)ResPacketSizeQuarter < (int)ResPacketSizeHalf
+  };
+
+  Index i=0;
+  for(; i<n8; i+=8)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+              c1 = pset1<ResPacket>(ResScalar(0)),
+              c2 = pset1<ResPacket>(ResScalar(0)),
+              c3 = pset1<ResPacket>(ResScalar(0)),
+              c4 = pset1<ResPacket>(ResScalar(0)),
+              c5 = pset1<ResPacket>(ResScalar(0)),
+              c6 = pset1<ResPacket>(ResScalar(0)),
+              c7 = pset1<ResPacket>(ResScalar(0));
+
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j,0);
+
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+1,j),b0,c1);
+      c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+2,j),b0,c2);
+      c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+3,j),b0,c3);
+      c4 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+4,j),b0,c4);
+      c5 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+5,j),b0,c5);
+      c6 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+6,j),b0,c6);
+      c7 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+7,j),b0,c7);
+    }
+    ResScalar cc0 = predux(c0);
+    ResScalar cc1 = predux(c1);
+    ResScalar cc2 = predux(c2);
+    ResScalar cc3 = predux(c3);
+    ResScalar cc4 = predux(c4);
+    ResScalar cc5 = predux(c5);
+    ResScalar cc6 = predux(c6);
+    ResScalar cc7 = predux(c7);
+    for(; j<cols; ++j)
+    {
+      RhsScalar b0 = rhs(j,0);
+
+      cc0 += cj.pmul(lhs(i+0,j), b0);
+      cc1 += cj.pmul(lhs(i+1,j), b0);
+      cc2 += cj.pmul(lhs(i+2,j), b0);
+      cc3 += cj.pmul(lhs(i+3,j), b0);
+      cc4 += cj.pmul(lhs(i+4,j), b0);
+      cc5 += cj.pmul(lhs(i+5,j), b0);
+      cc6 += cj.pmul(lhs(i+6,j), b0);
+      cc7 += cj.pmul(lhs(i+7,j), b0);
+    }
+    res[(i+0)*resIncr] += alpha*cc0;
+    res[(i+1)*resIncr] += alpha*cc1;
+    res[(i+2)*resIncr] += alpha*cc2;
+    res[(i+3)*resIncr] += alpha*cc3;
+    res[(i+4)*resIncr] += alpha*cc4;
+    res[(i+5)*resIncr] += alpha*cc5;
+    res[(i+6)*resIncr] += alpha*cc6;
+    res[(i+7)*resIncr] += alpha*cc7;
+  }
+  for(; i<n4; i+=4)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+              c1 = pset1<ResPacket>(ResScalar(0)),
+              c2 = pset1<ResPacket>(ResScalar(0)),
+              c3 = pset1<ResPacket>(ResScalar(0));
+
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j,0);
+
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+1,j),b0,c1);
+      c2 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+2,j),b0,c2);
+      c3 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+3,j),b0,c3);
+    }
+    ResScalar cc0 = predux(c0);
+    ResScalar cc1 = predux(c1);
+    ResScalar cc2 = predux(c2);
+    ResScalar cc3 = predux(c3);
+    for(; j<cols; ++j)
+    {
+      RhsScalar b0 = rhs(j,0);
+
+      cc0 += cj.pmul(lhs(i+0,j), b0);
+      cc1 += cj.pmul(lhs(i+1,j), b0);
+      cc2 += cj.pmul(lhs(i+2,j), b0);
+      cc3 += cj.pmul(lhs(i+3,j), b0);
+    }
+    res[(i+0)*resIncr] += alpha*cc0;
+    res[(i+1)*resIncr] += alpha*cc1;
+    res[(i+2)*resIncr] += alpha*cc2;
+    res[(i+3)*resIncr] += alpha*cc3;
+  }
+  for(; i<n2; i+=2)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0)),
+              c1 = pset1<ResPacket>(ResScalar(0));
+
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket, Unaligned>(j,0);
+
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+0,j),b0,c0);
+      c1 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i+1,j),b0,c1);
+    }
+    ResScalar cc0 = predux(c0);
+    ResScalar cc1 = predux(c1);
+    for(; j<cols; ++j)
+    {
+      RhsScalar b0 = rhs(j,0);
+
+      cc0 += cj.pmul(lhs(i+0,j), b0);
+      cc1 += cj.pmul(lhs(i+1,j), b0);
+    }
+    res[(i+0)*resIncr] += alpha*cc0;
+    res[(i+1)*resIncr] += alpha*cc1;
+  }
+  for(; i<rows; ++i)
+  {
+    ResPacket c0 = pset1<ResPacket>(ResScalar(0));
+    ResPacketHalf c0_h = pset1<ResPacketHalf>(ResScalar(0));
+    ResPacketQuarter c0_q = pset1<ResPacketQuarter>(ResScalar(0));
+    Index j=0;
+    for(; j+LhsPacketSize<=cols; j+=LhsPacketSize)
+    {
+      RhsPacket b0 = rhs.template load<RhsPacket,Unaligned>(j,0);
+      c0 = pcj.pmadd(lhs.template load<LhsPacket,LhsAlignment>(i,j),b0,c0);
+    }
+    ResScalar cc0 = predux(c0);
+    if (HasHalf) {
+      for(; j+LhsPacketSizeHalf<=cols; j+=LhsPacketSizeHalf)
+        {
+          RhsPacketHalf b0 = rhs.template load<RhsPacketHalf,Unaligned>(j,0);
+          c0_h = pcj_half.pmadd(lhs.template load<LhsPacketHalf,LhsAlignment>(i,j),b0,c0_h);
+        }
+      cc0 += predux(c0_h);
+    }
+    if (HasQuarter) {
+      for(; j+LhsPacketSizeQuarter<=cols; j+=LhsPacketSizeQuarter)
+        {
+          RhsPacketQuarter b0 = rhs.template load<RhsPacketQuarter,Unaligned>(j,0);
+          c0_q = pcj_quarter.pmadd(lhs.template load<LhsPacketQuarter,LhsAlignment>(i,j),b0,c0_q);
+        }
+      cc0 += predux(c0_q);
+    }
+    for(; j<cols; ++j)
+    {
+      cc0 += cj.pmul(lhs(i,j), rhs(j,0));
+    }
+    res[i*resIncr] += alpha*cc0;
+  }
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_VECTOR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
new file mode 100644
index 00000000..6e36c2b3
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
@@ -0,0 +1,136 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   General matrix-vector product functionality based on ?GEMV.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
+#define EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements general matrix-vector multiplication using BLAS
+* gemv function via partial specialization of
+* general_matrix_vector_product::run(..) method for float, double,
+* std::complex<float> and std::complex<double> types
+**********************************************************************/
+
+// gemv specialization
+
+template<typename Index, typename LhsScalar, int StorageOrder, bool ConjugateLhs, typename RhsScalar, bool ConjugateRhs>
+struct general_matrix_vector_product_gemv;
+
+#define EIGEN_BLAS_GEMV_SPECIALIZE(Scalar) \
+template<typename Index, bool ConjugateLhs, bool ConjugateRhs> \
+struct general_matrix_vector_product<Index,Scalar,const_blas_data_mapper<Scalar,Index,ColMajor>,ColMajor,ConjugateLhs,Scalar,const_blas_data_mapper<Scalar,Index,RowMajor>,ConjugateRhs,Specialized> { \
+static void run( \
+  Index rows, Index cols, \
+  const const_blas_data_mapper<Scalar,Index,ColMajor> &lhs, \
+  const const_blas_data_mapper<Scalar,Index,RowMajor> &rhs, \
+  Scalar* res, Index resIncr, Scalar alpha) \
+{ \
+  if (ConjugateLhs) { \
+    general_matrix_vector_product<Index,Scalar,const_blas_data_mapper<Scalar,Index,ColMajor>,ColMajor,ConjugateLhs,Scalar,const_blas_data_mapper<Scalar,Index,RowMajor>,ConjugateRhs,BuiltIn>::run( \
+      rows, cols, lhs, rhs, res, resIncr, alpha); \
+  } else { \
+    general_matrix_vector_product_gemv<Index,Scalar,ColMajor,ConjugateLhs,Scalar,ConjugateRhs>::run( \
+      rows, cols, lhs.data(), lhs.stride(), rhs.data(), rhs.stride(), res, resIncr, alpha); \
+  } \
+} \
+}; \
+template<typename Index, bool ConjugateLhs, bool ConjugateRhs> \
+struct general_matrix_vector_product<Index,Scalar,const_blas_data_mapper<Scalar,Index,RowMajor>,RowMajor,ConjugateLhs,Scalar,const_blas_data_mapper<Scalar,Index,ColMajor>,ConjugateRhs,Specialized> { \
+static void run( \
+  Index rows, Index cols, \
+  const const_blas_data_mapper<Scalar,Index,RowMajor> &lhs, \
+  const const_blas_data_mapper<Scalar,Index,ColMajor> &rhs, \
+  Scalar* res, Index resIncr, Scalar alpha) \
+{ \
+    general_matrix_vector_product_gemv<Index,Scalar,RowMajor,ConjugateLhs,Scalar,ConjugateRhs>::run( \
+      rows, cols, lhs.data(), lhs.stride(), rhs.data(), rhs.stride(), res, resIncr, alpha); \
+} \
+}; \
+
+EIGEN_BLAS_GEMV_SPECIALIZE(double)
+EIGEN_BLAS_GEMV_SPECIALIZE(float)
+EIGEN_BLAS_GEMV_SPECIALIZE(dcomplex)
+EIGEN_BLAS_GEMV_SPECIALIZE(scomplex)
+
+#define EIGEN_BLAS_GEMV_SPECIALIZATION(EIGTYPE,BLASTYPE,BLASFUNC) \
+template<typename Index, int LhsStorageOrder, bool ConjugateLhs, bool ConjugateRhs> \
+struct general_matrix_vector_product_gemv<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,ConjugateRhs> \
+{ \
+typedef Matrix<EIGTYPE,Dynamic,1,ColMajor> GEMVVector;\
+\
+static void run( \
+  Index rows, Index cols, \
+  const EIGTYPE* lhs, Index lhsStride, \
+  const EIGTYPE* rhs, Index rhsIncr, \
+  EIGTYPE* res, Index resIncr, EIGTYPE alpha) \
+{ \
+  BlasIndex m=convert_index<BlasIndex>(rows), n=convert_index<BlasIndex>(cols), \
+            lda=convert_index<BlasIndex>(lhsStride), incx=convert_index<BlasIndex>(rhsIncr), incy=convert_index<BlasIndex>(resIncr); \
+  const EIGTYPE beta(1); \
+  const EIGTYPE *x_ptr; \
+  char trans=(LhsStorageOrder==ColMajor) ? 'N' : (ConjugateLhs) ? 'C' : 'T'; \
+  if (LhsStorageOrder==RowMajor) { \
+    m = convert_index<BlasIndex>(cols); \
+    n = convert_index<BlasIndex>(rows); \
+  }\
+  GEMVVector x_tmp; \
+  if (ConjugateRhs) { \
+    Map<const GEMVVector, 0, InnerStride<> > map_x(rhs,cols,1,InnerStride<>(incx)); \
+    x_tmp=map_x.conjugate(); \
+    x_ptr=x_tmp.data(); \
+    incx=1; \
+  } else x_ptr=rhs; \
+  BLASFUNC(&trans, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)lhs, &lda, (const BLASTYPE*)x_ptr, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &incy); \
+}\
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_GEMV_SPECIALIZATION(double,   double, dgemv)
+EIGEN_BLAS_GEMV_SPECIALIZATION(float,    float,  sgemv)
+EIGEN_BLAS_GEMV_SPECIALIZATION(dcomplex, MKL_Complex16, zgemv)
+EIGEN_BLAS_GEMV_SPECIALIZATION(scomplex, MKL_Complex8 , cgemv)
+#else
+EIGEN_BLAS_GEMV_SPECIALIZATION(double,   double, dgemv_)
+EIGEN_BLAS_GEMV_SPECIALIZATION(float,    float,  sgemv_)
+EIGEN_BLAS_GEMV_SPECIALIZATION(dcomplex, double, zgemv_)
+EIGEN_BLAS_GEMV_SPECIALIZATION(scomplex, float,  cgemv_)
+#endif
+
+} // end namespase internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/Parallelizer.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/Parallelizer.h
new file mode 100644
index 00000000..8f91879e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/Parallelizer.h
@@ -0,0 +1,180 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARALLELIZER_H
+#define EIGEN_PARALLELIZER_H
+
+#if EIGEN_HAS_CXX11_ATOMIC
+#include <atomic>
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal */
+inline void manage_multi_threading(Action action, int* v)
+{
+  static int m_maxThreads = -1;
+  EIGEN_UNUSED_VARIABLE(m_maxThreads)
+
+  if(action==SetAction)
+  {
+    eigen_internal_assert(v!=0);
+    m_maxThreads = *v;
+  }
+  else if(action==GetAction)
+  {
+    eigen_internal_assert(v!=0);
+    #ifdef EIGEN_HAS_OPENMP
+    if(m_maxThreads>0)
+      *v = m_maxThreads;
+    else
+      *v = omp_get_max_threads();
+    #else
+    *v = 1;
+    #endif
+  }
+  else
+  {
+    eigen_internal_assert(false);
+  }
+}
+
+}
+
+/** Must be call first when calling Eigen from multiple threads */
+inline void initParallel()
+{
+  int nbt;
+  internal::manage_multi_threading(GetAction, &nbt);
+  std::ptrdiff_t l1, l2, l3;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+}
+
+/** \returns the max number of threads reserved for Eigen
+  * \sa setNbThreads */
+inline int nbThreads()
+{
+  int ret;
+  internal::manage_multi_threading(GetAction, &ret);
+  return ret;
+}
+
+/** Sets the max number of threads reserved for Eigen
+  * \sa nbThreads */
+inline void setNbThreads(int v)
+{
+  internal::manage_multi_threading(SetAction, &v);
+}
+
+namespace internal {
+
+template<typename Index> struct GemmParallelInfo
+{
+  GemmParallelInfo() : sync(-1), users(0), lhs_start(0), lhs_length(0) {}
+
+  // volatile is not enough on all architectures (see bug 1572)
+  // to guarantee that when thread A says to thread B that it is
+  // done with packing a block, then all writes have been really
+  // carried out... C++11 memory model+atomic guarantees this.
+#if EIGEN_HAS_CXX11_ATOMIC
+  std::atomic<Index> sync;
+  std::atomic<int> users;
+#else
+  Index volatile sync;
+  int volatile users;
+#endif
+
+  Index lhs_start;
+  Index lhs_length;
+};
+
+template<bool Condition, typename Functor, typename Index>
+void parallelize_gemm(const Functor& func, Index rows, Index cols, Index depth, bool transpose)
+{
+  // TODO when EIGEN_USE_BLAS is defined,
+  // we should still enable OMP for other scalar types
+  // Without C++11, we have to disable GEMM's parallelization on
+  // non x86 architectures because there volatile is not enough for our purpose.
+  // See bug 1572.
+#if (! defined(EIGEN_HAS_OPENMP)) || defined(EIGEN_USE_BLAS) || ((!EIGEN_HAS_CXX11_ATOMIC) && !(EIGEN_ARCH_i386_OR_x86_64))
+  // FIXME the transpose variable is only needed to properly split
+  // the matrix product when multithreading is enabled. This is a temporary
+  // fix to support row-major destination matrices. This whole
+  // parallelizer mechanism has to be redesigned anyway.
+  EIGEN_UNUSED_VARIABLE(depth);
+  EIGEN_UNUSED_VARIABLE(transpose);
+  func(0,rows, 0,cols);
+#else
+
+  // Dynamically check whether we should enable or disable OpenMP.
+  // The conditions are:
+  // - the max number of threads we can create is greater than 1
+  // - we are not already in a parallel code
+  // - the sizes are large enough
+
+  // compute the maximal number of threads from the size of the product:
+  // This first heuristic takes into account that the product kernel is fully optimized when working with nr columns at once.
+  Index size = transpose ? rows : cols;
+  Index pb_max_threads = std::max<Index>(1,size / Functor::Traits::nr);
+
+  // compute the maximal number of threads from the total amount of work:
+  double work = static_cast<double>(rows) * static_cast<double>(cols) *
+      static_cast<double>(depth);
+  double kMinTaskSize = 50000;  // FIXME improve this heuristic.
+  pb_max_threads = std::max<Index>(1, std::min<Index>(pb_max_threads, static_cast<Index>( work / kMinTaskSize ) ));
+
+  // compute the number of threads we are going to use
+  Index threads = std::min<Index>(nbThreads(), pb_max_threads);
+
+  // if multi-threading is explicitly disabled, not useful, or if we already are in a parallel session,
+  // then abort multi-threading
+  // FIXME omp_get_num_threads()>1 only works for openmp, what if the user does not use openmp?
+  if((!Condition) || (threads==1) || (omp_get_num_threads()>1))
+    return func(0,rows, 0,cols);
+
+  Eigen::initParallel();
+  func.initParallelSession(threads);
+
+  if(transpose)
+    std::swap(rows,cols);
+
+  ei_declare_aligned_stack_constructed_variable(GemmParallelInfo<Index>,info,threads,0);
+
+  #pragma omp parallel num_threads(threads)
+  {
+    Index i = omp_get_thread_num();
+    // Note that the actual number of threads might be lower than the number of request ones.
+    Index actual_threads = omp_get_num_threads();
+
+    Index blockCols = (cols / actual_threads) & ~Index(0x3);
+    Index blockRows = (rows / actual_threads);
+    blockRows = (blockRows/Functor::Traits::mr)*Functor::Traits::mr;
+
+    Index r0 = i*blockRows;
+    Index actualBlockRows = (i+1==actual_threads) ? rows-r0 : blockRows;
+
+    Index c0 = i*blockCols;
+    Index actualBlockCols = (i+1==actual_threads) ? cols-c0 : blockCols;
+
+    info[i].lhs_start = r0;
+    info[i].lhs_length = actualBlockRows;
+
+    if(transpose) func(c0, actualBlockCols, 0, rows, info);
+    else          func(0, rows, c0, actualBlockCols, info);
+  }
+#endif
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARALLELIZER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
new file mode 100644
index 00000000..33ecf10f
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
@@ -0,0 +1,544 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_MATRIX_H
+#define EIGEN_SELFADJOINT_MATRIX_MATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// pack a selfadjoint block diagonal for use with the gebp_kernel
+template<typename Scalar, typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+struct symm_pack_lhs
+{
+  template<int BlockRows> inline
+  void pack(Scalar* blockA, const const_blas_data_mapper<Scalar,Index,StorageOrder>& lhs, Index cols, Index i, Index& count)
+  {
+    // normal copy
+    for(Index k=0; k<i; k++)
+      for(Index w=0; w<BlockRows; w++)
+        blockA[count++] = lhs(i+w,k);           // normal
+    // symmetric copy
+    Index h = 0;
+    for(Index k=i; k<i+BlockRows; k++)
+    {
+      for(Index w=0; w<h; w++)
+        blockA[count++] = numext::conj(lhs(k, i+w)); // transposed
+
+      blockA[count++] = numext::real(lhs(k,k));   // real (diagonal)
+
+      for(Index w=h+1; w<BlockRows; w++)
+        blockA[count++] = lhs(i+w, k);          // normal
+      ++h;
+    }
+    // transposed copy
+    for(Index k=i+BlockRows; k<cols; k++)
+      for(Index w=0; w<BlockRows; w++)
+        blockA[count++] = numext::conj(lhs(k, i+w)); // transposed
+  }
+  void operator()(Scalar* blockA, const Scalar* _lhs, Index lhsStride, Index cols, Index rows)
+  {
+    typedef typename unpacket_traits<typename packet_traits<Scalar>::type>::half HalfPacket;
+    typedef typename unpacket_traits<typename unpacket_traits<typename packet_traits<Scalar>::type>::half>::half QuarterPacket;
+    enum { PacketSize = packet_traits<Scalar>::size,
+           HalfPacketSize = unpacket_traits<HalfPacket>::size,
+           QuarterPacketSize = unpacket_traits<QuarterPacket>::size,
+           HasHalf = (int)HalfPacketSize < (int)PacketSize,
+           HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize};
+
+    const_blas_data_mapper<Scalar,Index,StorageOrder> lhs(_lhs,lhsStride);
+    Index count = 0;
+    //Index peeled_mc3 = (rows/Pack1)*Pack1;
+    
+    const Index peeled_mc3 = Pack1>=3*PacketSize ? (rows/(3*PacketSize))*(3*PacketSize) : 0;
+    const Index peeled_mc2 = Pack1>=2*PacketSize ? peeled_mc3+((rows-peeled_mc3)/(2*PacketSize))*(2*PacketSize) : 0;
+    const Index peeled_mc1 = Pack1>=1*PacketSize ? peeled_mc2+((rows-peeled_mc2)/(1*PacketSize))*(1*PacketSize) : 0;
+    const Index peeled_mc_half = Pack1>=HalfPacketSize ? peeled_mc1+((rows-peeled_mc1)/(HalfPacketSize))*(HalfPacketSize) : 0;
+    const Index peeled_mc_quarter = Pack1>=QuarterPacketSize ? peeled_mc_half+((rows-peeled_mc_half)/(QuarterPacketSize))*(QuarterPacketSize) : 0;
+    
+    if(Pack1>=3*PacketSize)
+      for(Index i=0; i<peeled_mc3; i+=3*PacketSize)
+        pack<3*PacketSize>(blockA, lhs, cols, i, count);
+    
+    if(Pack1>=2*PacketSize)
+      for(Index i=peeled_mc3; i<peeled_mc2; i+=2*PacketSize)
+        pack<2*PacketSize>(blockA, lhs, cols, i, count);
+    
+    if(Pack1>=1*PacketSize)
+      for(Index i=peeled_mc2; i<peeled_mc1; i+=1*PacketSize)
+        pack<1*PacketSize>(blockA, lhs, cols, i, count);
+
+    if(HasHalf && Pack1>=HalfPacketSize)
+      for(Index i=peeled_mc1; i<peeled_mc_half; i+=HalfPacketSize)
+        pack<HalfPacketSize>(blockA, lhs, cols, i, count);
+
+    if(HasQuarter && Pack1>=QuarterPacketSize)
+      for(Index i=peeled_mc_half; i<peeled_mc_quarter; i+=QuarterPacketSize)
+        pack<QuarterPacketSize>(blockA, lhs, cols, i, count);
+
+    // do the same with mr==1
+    for(Index i=peeled_mc_quarter; i<rows; i++)
+    {
+      for(Index k=0; k<i; k++)
+        blockA[count++] = lhs(i, k);                   // normal
+
+      blockA[count++] = numext::real(lhs(i, i));       // real (diagonal)
+
+      for(Index k=i+1; k<cols; k++)
+        blockA[count++] = numext::conj(lhs(k, i));     // transposed
+    }
+  }
+};
+
+template<typename Scalar, typename Index, int nr, int StorageOrder>
+struct symm_pack_rhs
+{
+  enum { PacketSize = packet_traits<Scalar>::size };
+  void operator()(Scalar* blockB, const Scalar* _rhs, Index rhsStride, Index rows, Index cols, Index k2)
+  {
+    Index end_k = k2 + rows;
+    Index count = 0;
+    const_blas_data_mapper<Scalar,Index,StorageOrder> rhs(_rhs,rhsStride);
+    Index packet_cols8 = nr>=8 ? (cols/8) * 8 : 0;
+    Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
+
+    // first part: normal case
+    for(Index j2=0; j2<k2; j2+=nr)
+    {
+      for(Index k=k2; k<end_k; k++)
+      {
+        blockB[count+0] = rhs(k,j2+0);
+        blockB[count+1] = rhs(k,j2+1);
+        if (nr>=4)
+        {
+          blockB[count+2] = rhs(k,j2+2);
+          blockB[count+3] = rhs(k,j2+3);
+        }
+        if (nr>=8)
+        {
+          blockB[count+4] = rhs(k,j2+4);
+          blockB[count+5] = rhs(k,j2+5);
+          blockB[count+6] = rhs(k,j2+6);
+          blockB[count+7] = rhs(k,j2+7);
+        }
+        count += nr;
+      }
+    }
+
+    // second part: diagonal block
+    Index end8 = nr>=8 ? (std::min)(k2+rows,packet_cols8) : k2;
+    if(nr>=8)
+    {
+      for(Index j2=k2; j2<end8; j2+=8)
+      {
+        // again we can split vertically in three different parts (transpose, symmetric, normal)
+        // transpose
+        for(Index k=k2; k<j2; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          blockB[count+4] = numext::conj(rhs(j2+4,k));
+          blockB[count+5] = numext::conj(rhs(j2+5,k));
+          blockB[count+6] = numext::conj(rhs(j2+6,k));
+          blockB[count+7] = numext::conj(rhs(j2+7,k));
+          count += 8;
+        }
+        // symmetric
+        Index h = 0;
+        for(Index k=j2; k<j2+8; k++)
+        {
+          // normal
+          for (Index w=0 ; w<h; ++w)
+            blockB[count+w] = rhs(k,j2+w);
+
+          blockB[count+h] = numext::real(rhs(k,k));
+
+          // transpose
+          for (Index w=h+1 ; w<8; ++w)
+            blockB[count+w] = numext::conj(rhs(j2+w,k));
+          count += 8;
+          ++h;
+        }
+        // normal
+        for(Index k=j2+8; k<end_k; k++)
+        {
+          blockB[count+0] = rhs(k,j2+0);
+          blockB[count+1] = rhs(k,j2+1);
+          blockB[count+2] = rhs(k,j2+2);
+          blockB[count+3] = rhs(k,j2+3);
+          blockB[count+4] = rhs(k,j2+4);
+          blockB[count+5] = rhs(k,j2+5);
+          blockB[count+6] = rhs(k,j2+6);
+          blockB[count+7] = rhs(k,j2+7);
+          count += 8;
+        }
+      }
+    }
+    if(nr>=4)
+    {
+      for(Index j2=end8; j2<(std::min)(k2+rows,packet_cols4); j2+=4)
+      {
+        // again we can split vertically in three different parts (transpose, symmetric, normal)
+        // transpose
+        for(Index k=k2; k<j2; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          count += 4;
+        }
+        // symmetric
+        Index h = 0;
+        for(Index k=j2; k<j2+4; k++)
+        {
+          // normal
+          for (Index w=0 ; w<h; ++w)
+            blockB[count+w] = rhs(k,j2+w);
+
+          blockB[count+h] = numext::real(rhs(k,k));
+
+          // transpose
+          for (Index w=h+1 ; w<4; ++w)
+            blockB[count+w] = numext::conj(rhs(j2+w,k));
+          count += 4;
+          ++h;
+        }
+        // normal
+        for(Index k=j2+4; k<end_k; k++)
+        {
+          blockB[count+0] = rhs(k,j2+0);
+          blockB[count+1] = rhs(k,j2+1);
+          blockB[count+2] = rhs(k,j2+2);
+          blockB[count+3] = rhs(k,j2+3);
+          count += 4;
+        }
+      }
+    }
+
+    // third part: transposed
+    if(nr>=8)
+    {
+      for(Index j2=k2+rows; j2<packet_cols8; j2+=8)
+      {
+        for(Index k=k2; k<end_k; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          blockB[count+4] = numext::conj(rhs(j2+4,k));
+          blockB[count+5] = numext::conj(rhs(j2+5,k));
+          blockB[count+6] = numext::conj(rhs(j2+6,k));
+          blockB[count+7] = numext::conj(rhs(j2+7,k));
+          count += 8;
+        }
+      }
+    }
+    if(nr>=4)
+    {
+      for(Index j2=(std::max)(packet_cols8,k2+rows); j2<packet_cols4; j2+=4)
+      {
+        for(Index k=k2; k<end_k; k++)
+        {
+          blockB[count+0] = numext::conj(rhs(j2+0,k));
+          blockB[count+1] = numext::conj(rhs(j2+1,k));
+          blockB[count+2] = numext::conj(rhs(j2+2,k));
+          blockB[count+3] = numext::conj(rhs(j2+3,k));
+          count += 4;
+        }
+      }
+    }
+
+    // copy the remaining columns one at a time (=> the same with nr==1)
+    for(Index j2=packet_cols4; j2<cols; ++j2)
+    {
+      // transpose
+      Index half = (std::min)(end_k,j2);
+      for(Index k=k2; k<half; k++)
+      {
+        blockB[count] = numext::conj(rhs(j2,k));
+        count += 1;
+      }
+
+      if(half==j2 && half<k2+rows)
+      {
+        blockB[count] = numext::real(rhs(j2,j2));
+        count += 1;
+      }
+      else
+        half--;
+
+      // normal
+      for(Index k=half+1; k<k2+rows; k++)
+      {
+        blockB[count] = rhs(k,j2);
+        count += 1;
+      }
+    }
+  }
+};
+
+/* Optimized selfadjoint matrix * matrix (_SYMM) product built on top of
+ * the general matrix matrix product.
+ */
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs,
+          int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs,
+          int ResStorageOrder, int ResInnerStride>
+struct product_selfadjoint_matrix;
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs,
+          int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs,
+          int ResInnerStride>
+struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,LhsSelfAdjoint,ConjugateLhs, RhsStorageOrder,RhsSelfAdjoint,ConjugateRhs,RowMajor,ResInnerStride>
+{
+
+  static EIGEN_STRONG_INLINE void run(
+    Index rows, Index cols,
+    const Scalar* lhs, Index lhsStride,
+    const Scalar* rhs, Index rhsStride,
+    Scalar* res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    product_selfadjoint_matrix<Scalar, Index,
+      EIGEN_LOGICAL_XOR(RhsSelfAdjoint,RhsStorageOrder==RowMajor) ? ColMajor : RowMajor,
+      RhsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(RhsSelfAdjoint,ConjugateRhs),
+      EIGEN_LOGICAL_XOR(LhsSelfAdjoint,LhsStorageOrder==RowMajor) ? ColMajor : RowMajor,
+      LhsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(LhsSelfAdjoint,ConjugateLhs),
+      ColMajor,ResInnerStride>
+      ::run(cols, rows,  rhs, rhsStride,  lhs, lhsStride,  res, resIncr, resStride,  alpha, blocking);
+  }
+};
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride>
+struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,true,ConjugateLhs, RhsStorageOrder,false,ConjugateRhs,ColMajor,ResInnerStride>
+{
+
+  static EIGEN_DONT_INLINE void run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride>
+EIGEN_DONT_INLINE void product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,true,ConjugateLhs, RhsStorageOrder,false,ConjugateRhs,ColMajor,ResInnerStride>::run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index size = rows;
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, (LhsStorageOrder == RowMajor) ? ColMajor : RowMajor> LhsTransposeMapper;
+    typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    LhsTransposeMapper lhs_transpose(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride, resIncr);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+    // kc must be smaller than mc
+    kc = (std::min)(kc,mc);
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    symm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder> pack_rhs;
+    gemm_pack_lhs<Scalar, Index, LhsTransposeMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder==RowMajor?ColMajor:RowMajor, true> pack_lhs_transposed;
+
+    for(Index k2=0; k2<size; k2+=kc)
+    {
+      const Index actual_kc = (std::min)(k2+kc,size)-k2;
+
+      // we have selected one row panel of rhs and one column panel of lhs
+      // pack rhs's panel into a sequential chunk of memory
+      // and expand each coeff to a constant packet for further reuse
+      pack_rhs(blockB, rhs.getSubMapper(k2,0), actual_kc, cols);
+
+      // the select lhs's panel has to be split in three different parts:
+      //  1 - the transposed panel above the diagonal block => transposed packed copy
+      //  2 - the diagonal block => special packed copy
+      //  3 - the panel below the diagonal block => generic packed copy
+      for(Index i2=0; i2<k2; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,k2)-i2;
+        // transposed packed copy
+        pack_lhs_transposed(blockA, lhs_transpose.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+      // the block diagonal
+      {
+        const Index actual_mc = (std::min)(k2+kc,size)-k2;
+        // symmetric packed copy
+        pack_lhs(blockA, &lhs(k2,k2), lhsStride, actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(k2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+
+      for(Index i2=k2+kc; i2<size; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,size)-i2;
+        gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder,false>()
+          (blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+    }
+  }
+
+// matrix * selfadjoint product
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride>
+struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,false,ConjugateLhs, RhsStorageOrder,true,ConjugateRhs,ColMajor,ResInnerStride>
+{
+
+  static EIGEN_DONT_INLINE void run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride>
+EIGEN_DONT_INLINE void product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,false,ConjugateLhs, RhsStorageOrder,true,ConjugateRhs,ColMajor,ResInnerStride>::run(
+    Index rows, Index cols,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index size = cols;
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    ResMapper res(_res,resStride, resIncr);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder> pack_lhs;
+    symm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs;
+
+    for(Index k2=0; k2<size; k2+=kc)
+    {
+      const Index actual_kc = (std::min)(k2+kc,size)-k2;
+
+      pack_rhs(blockB, _rhs, rhsStride, actual_kc, cols, k2);
+
+      // => GEPP
+      for(Index i2=0; i2<rows; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(i2+mc,rows)-i2;
+        pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
+      }
+    }
+  }
+
+} // end namespace internal
+
+/***************************************************************************
+* Wrapper to product_selfadjoint_matrix
+***************************************************************************/
+
+namespace internal {
+  
+template<typename Lhs, int LhsMode, typename Rhs, int RhsMode>
+struct selfadjoint_product_impl<Lhs,LhsMode,false,Rhs,RhsMode,false>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  typedef internal::blas_traits<Lhs> LhsBlasTraits;
+  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+  typedef internal::blas_traits<Rhs> RhsBlasTraits;
+  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  
+  enum {
+    LhsIsUpper = (LhsMode&(Upper|Lower))==Upper,
+    LhsIsSelfAdjoint = (LhsMode&SelfAdjoint)==SelfAdjoint,
+    RhsIsUpper = (RhsMode&(Upper|Lower))==Upper,
+    RhsIsSelfAdjoint = (RhsMode&SelfAdjoint)==SelfAdjoint
+  };
+  
+  template<typename Dest>
+  static void run(Dest &dst, const Lhs &a_lhs, const Rhs &a_rhs, const Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==a_lhs.rows() && dst.cols()==a_rhs.cols());
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs)
+                               * RhsBlasTraits::extractScalarFactor(a_rhs);
+
+    typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
+              Lhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxColsAtCompileTime,1> BlockingType;
+
+    BlockingType blocking(lhs.rows(), rhs.cols(), lhs.cols(), 1, false);
+
+    internal::product_selfadjoint_matrix<Scalar, Index,
+      EIGEN_LOGICAL_XOR(LhsIsUpper,internal::traits<Lhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, LhsIsSelfAdjoint,
+      NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(LhsIsUpper,bool(LhsBlasTraits::NeedToConjugate)),
+      EIGEN_LOGICAL_XOR(RhsIsUpper,internal::traits<Rhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, RhsIsSelfAdjoint,
+      NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(RhsIsUpper,bool(RhsBlasTraits::NeedToConjugate)),
+      internal::traits<Dest>::Flags&RowMajorBit  ? RowMajor : ColMajor,
+      Dest::InnerStrideAtCompileTime>
+      ::run(
+        lhs.rows(), rhs.cols(),                 // sizes
+        &lhs.coeffRef(0,0), lhs.outerStride(),  // lhs info
+        &rhs.coeffRef(0,0), rhs.outerStride(),  // rhs info
+        &dst.coeffRef(0,0), dst.innerStride(), dst.outerStride(),  // result info
+        actualAlpha, blocking                   // alpha
+      );
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_MATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
new file mode 100644
index 00000000..61396dbd
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
@@ -0,0 +1,295 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Self adjoint matrix * matrix product functionality based on ?SYMM/?HEMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
+#define EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+/* Optimized selfadjoint matrix * matrix (?SYMM/?HEMM) product */
+
+#define EIGEN_BLAS_SYMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,true,ConjugateLhs,RhsStorageOrder,false,ConjugateRhs,ColMajor,1> \
+{\
+\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resIncr, Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+    eigen_assert(resIncr == 1); \
+    char side='L', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+\
+/* Set transpose options */ \
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows);  \
+    n = convert_index<BlasIndex>(cols);  \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(lhsStride); \
+    ldb = convert_index<BlasIndex>(rhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (LhsStorageOrder==RowMajor) uplo='U'; \
+    a = _lhs; \
+\
+    if (RhsStorageOrder==RowMajor) { \
+      Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,n,m,OuterStride<>(rhsStride)); \
+      b_tmp = rhs.adjoint(); \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } else b = _rhs; \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+\
+  } \
+};
+
+
+#define EIGEN_BLAS_HEMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,true,ConjugateLhs,RhsStorageOrder,false,ConjugateRhs,ColMajor,1> \
+{\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resIncr, Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+    eigen_assert(resIncr == 1); \
+    char side='L', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+    Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> a_tmp; \
+\
+/* Set transpose options */ \
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows); \
+    n = convert_index<BlasIndex>(cols); \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(lhsStride); \
+    ldb = convert_index<BlasIndex>(rhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (((LhsStorageOrder==ColMajor) && ConjugateLhs) || ((LhsStorageOrder==RowMajor) && (!ConjugateLhs))) { \
+      Map<const Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder>, 0, OuterStride<> > lhs(_lhs,m,m,OuterStride<>(lhsStride)); \
+      a_tmp = lhs.conjugate(); \
+      a = a_tmp.data(); \
+      lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+    } else a = _lhs; \
+    if (LhsStorageOrder==RowMajor) uplo='U'; \
+\
+    if (RhsStorageOrder==ColMajor && (!ConjugateRhs)) { \
+       b = _rhs; } \
+    else { \
+      if (RhsStorageOrder==ColMajor && ConjugateRhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,m,n,OuterStride<>(rhsStride)); \
+        b_tmp = rhs.conjugate(); \
+      } else \
+      if (ConjugateRhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,n,m,OuterStride<>(rhsStride)); \
+        b_tmp = rhs.adjoint(); \
+      } else { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs,n,m,OuterStride<>(rhsStride)); \
+        b_tmp = rhs.transpose(); \
+      } \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+\
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_SYMM_L(double, double, d, dsymm)
+EIGEN_BLAS_SYMM_L(float, float, f, ssymm)
+EIGEN_BLAS_HEMM_L(dcomplex, MKL_Complex16, cd, zhemm)
+EIGEN_BLAS_HEMM_L(scomplex, MKL_Complex8, cf, chemm)
+#else
+EIGEN_BLAS_SYMM_L(double, double, d, dsymm_)
+EIGEN_BLAS_SYMM_L(float, float, f, ssymm_)
+EIGEN_BLAS_HEMM_L(dcomplex, double, cd, zhemm_)
+EIGEN_BLAS_HEMM_L(scomplex, float, cf, chemm_)
+#endif
+
+/* Optimized matrix * selfadjoint matrix (?SYMM/?HEMM) product */
+
+#define EIGEN_BLAS_SYMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,false,ConjugateLhs,RhsStorageOrder,true,ConjugateRhs,ColMajor,1> \
+{\
+\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resIncr, Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+    eigen_assert(resIncr == 1); \
+    char side='R', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+\
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows);  \
+    n = convert_index<BlasIndex>(cols);  \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(rhsStride); \
+    ldb = convert_index<BlasIndex>(lhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (RhsStorageOrder==RowMajor) uplo='U'; \
+    a = _rhs; \
+\
+    if (LhsStorageOrder==RowMajor) { \
+      Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,n,m,OuterStride<>(rhsStride)); \
+      b_tmp = lhs.adjoint(); \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } else b = _lhs; \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+\
+  } \
+};
+
+
+#define EIGEN_BLAS_HEMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_selfadjoint_matrix<EIGTYPE,Index,LhsStorageOrder,false,ConjugateLhs,RhsStorageOrder,true,ConjugateRhs,ColMajor,1> \
+{\
+  static void run( \
+    Index rows, Index cols, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resIncr, Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) \
+  { \
+    EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+    eigen_assert(resIncr == 1); \
+    char side='R', uplo='L'; \
+    BlasIndex m, n, lda, ldb, ldc; \
+    const EIGTYPE *a, *b; \
+    EIGTYPE beta(1); \
+    MatrixX##EIGPREFIX b_tmp; \
+    Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> a_tmp; \
+\
+/* Set m, n, k */ \
+    m = convert_index<BlasIndex>(rows); \
+    n = convert_index<BlasIndex>(cols); \
+\
+/* Set lda, ldb, ldc */ \
+    lda = convert_index<BlasIndex>(rhsStride); \
+    ldb = convert_index<BlasIndex>(lhsStride); \
+    ldc = convert_index<BlasIndex>(resStride); \
+\
+/* Set a, b, c */ \
+    if (((RhsStorageOrder==ColMajor) && ConjugateRhs) || ((RhsStorageOrder==RowMajor) && (!ConjugateRhs))) { \
+      Map<const Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder>, 0, OuterStride<> > rhs(_rhs,n,n,OuterStride<>(rhsStride)); \
+      a_tmp = rhs.conjugate(); \
+      a = a_tmp.data(); \
+      lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+    } else a = _rhs; \
+    if (RhsStorageOrder==RowMajor) uplo='U'; \
+\
+    if (LhsStorageOrder==ColMajor && (!ConjugateLhs)) { \
+       b = _lhs; } \
+    else { \
+      if (LhsStorageOrder==ColMajor && ConjugateLhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,m,n,OuterStride<>(lhsStride)); \
+        b_tmp = lhs.conjugate(); \
+      } else \
+      if (ConjugateLhs) { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,n,m,OuterStride<>(lhsStride)); \
+        b_tmp = lhs.adjoint(); \
+      } else { \
+        Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs,n,m,OuterStride<>(lhsStride)); \
+        b_tmp = lhs.transpose(); \
+      } \
+      b = b_tmp.data(); \
+      ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+    } \
+\
+    BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc); \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_SYMM_R(double, double, d, dsymm)
+EIGEN_BLAS_SYMM_R(float, float, f, ssymm)
+EIGEN_BLAS_HEMM_R(dcomplex, MKL_Complex16, cd, zhemm)
+EIGEN_BLAS_HEMM_R(scomplex, MKL_Complex8, cf, chemm)
+#else
+EIGEN_BLAS_SYMM_R(double, double, d, dsymm_)
+EIGEN_BLAS_SYMM_R(float, float, f, ssymm_)
+EIGEN_BLAS_HEMM_R(dcomplex, double, cd, zhemm_)
+EIGEN_BLAS_HEMM_R(scomplex, float, cf, chemm_)
+#endif
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixVector.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixVector.h
new file mode 100644
index 00000000..d38fd72b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixVector.h
@@ -0,0 +1,262 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_VECTOR_H
+#define EIGEN_SELFADJOINT_MATRIX_VECTOR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/* Optimized selfadjoint matrix * vector product:
+ * This algorithm processes 2 columns at once that allows to both reduce
+ * the number of load/stores of the result by a factor 2 and to reduce
+ * the instruction dependency.
+ */
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs, int Version=Specialized>
+struct selfadjoint_matrix_vector_product;
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs, int Version>
+struct selfadjoint_matrix_vector_product
+
+{
+static EIGEN_DONT_INLINE EIGEN_DEVICE_FUNC
+void run(
+  Index size,
+  const Scalar*  lhs, Index lhsStride,
+  const Scalar*  rhs,
+  Scalar* res,
+  Scalar alpha);
+};
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs, int Version>
+EIGEN_DONT_INLINE EIGEN_DEVICE_FUNC
+void selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,Version>::run(
+  Index size,
+  const Scalar*  lhs, Index lhsStride,
+  const Scalar*  rhs,
+  Scalar* res,
+  Scalar alpha)
+{
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  const Index PacketSize = sizeof(Packet)/sizeof(Scalar);
+
+  enum {
+    IsRowMajor = StorageOrder==RowMajor ? 1 : 0,
+    IsLower = UpLo == Lower ? 1 : 0,
+    FirstTriangular = IsRowMajor == IsLower
+  };
+
+  conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs,  IsRowMajor), ConjugateRhs> cj0;
+  conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> cj1;
+  conj_helper<RealScalar,Scalar,false, ConjugateRhs> cjd;
+
+  conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs,  IsRowMajor), ConjugateRhs> pcj0;
+  conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> pcj1;
+
+  Scalar cjAlpha = ConjugateRhs ? numext::conj(alpha) : alpha;
+
+  Index bound = numext::maxi(Index(0), size-8) & 0xfffffffe;
+  if (FirstTriangular)
+    bound = size - bound;
+
+  for (Index j=FirstTriangular ? bound : 0;
+       j<(FirstTriangular ? size : bound);j+=2)
+  {
+    const Scalar* EIGEN_RESTRICT A0 = lhs + j*lhsStride;
+    const Scalar* EIGEN_RESTRICT A1 = lhs + (j+1)*lhsStride;
+
+    Scalar t0 = cjAlpha * rhs[j];
+    Packet ptmp0 = pset1<Packet>(t0);
+    Scalar t1 = cjAlpha * rhs[j+1];
+    Packet ptmp1 = pset1<Packet>(t1);
+
+    Scalar t2(0);
+    Packet ptmp2 = pset1<Packet>(t2);
+    Scalar t3(0);
+    Packet ptmp3 = pset1<Packet>(t3);
+
+    Index starti = FirstTriangular ? 0 : j+2;
+    Index endi   = FirstTriangular ? j : size;
+    Index alignedStart = (starti) + internal::first_default_aligned(&res[starti], endi-starti);
+    Index alignedEnd = alignedStart + ((endi-alignedStart)/(PacketSize))*(PacketSize);
+
+    res[j]   += cjd.pmul(numext::real(A0[j]), t0);
+    res[j+1] += cjd.pmul(numext::real(A1[j+1]), t1);
+    if(FirstTriangular)
+    {
+      res[j]   += cj0.pmul(A1[j],   t1);
+      t3       += cj1.pmul(A1[j],   rhs[j]);
+    }
+    else
+    {
+      res[j+1] += cj0.pmul(A0[j+1],t0);
+      t2 += cj1.pmul(A0[j+1], rhs[j+1]);
+    }
+
+    for (Index i=starti; i<alignedStart; ++i)
+    {
+      res[i] += cj0.pmul(A0[i], t0) + cj0.pmul(A1[i],t1);
+      t2 += cj1.pmul(A0[i], rhs[i]);
+      t3 += cj1.pmul(A1[i], rhs[i]);
+    }
+    // Yes this an optimization for gcc 4.3 and 4.4 (=> huge speed up)
+    // gcc 4.2 does this optimization automatically.
+    const Scalar* EIGEN_RESTRICT a0It  = A0  + alignedStart;
+    const Scalar* EIGEN_RESTRICT a1It  = A1  + alignedStart;
+    const Scalar* EIGEN_RESTRICT rhsIt = rhs + alignedStart;
+          Scalar* EIGEN_RESTRICT resIt = res + alignedStart;
+    for (Index i=alignedStart; i<alignedEnd; i+=PacketSize)
+    {
+      Packet A0i = ploadu<Packet>(a0It);  a0It  += PacketSize;
+      Packet A1i = ploadu<Packet>(a1It);  a1It  += PacketSize;
+      Packet Bi  = ploadu<Packet>(rhsIt); rhsIt += PacketSize; // FIXME should be aligned in most cases
+      Packet Xi  = pload <Packet>(resIt);
+
+      Xi    = pcj0.pmadd(A0i,ptmp0, pcj0.pmadd(A1i,ptmp1,Xi));
+      ptmp2 = pcj1.pmadd(A0i,  Bi, ptmp2);
+      ptmp3 = pcj1.pmadd(A1i,  Bi, ptmp3);
+      pstore(resIt,Xi); resIt += PacketSize;
+    }
+    for (Index i=alignedEnd; i<endi; i++)
+    {
+      res[i] += cj0.pmul(A0[i], t0) + cj0.pmul(A1[i],t1);
+      t2 += cj1.pmul(A0[i], rhs[i]);
+      t3 += cj1.pmul(A1[i], rhs[i]);
+    }
+
+    res[j]   += alpha * (t2 + predux(ptmp2));
+    res[j+1] += alpha * (t3 + predux(ptmp3));
+  }
+  for (Index j=FirstTriangular ? 0 : bound;j<(FirstTriangular ? bound : size);j++)
+  {
+    const Scalar* EIGEN_RESTRICT A0 = lhs + j*lhsStride;
+
+    Scalar t1 = cjAlpha * rhs[j];
+    Scalar t2(0);
+    res[j] += cjd.pmul(numext::real(A0[j]), t1);
+    for (Index i=FirstTriangular ? 0 : j+1; i<(FirstTriangular ? j : size); i++)
+    {
+      res[i] += cj0.pmul(A0[i], t1);
+      t2 += cj1.pmul(A0[i], rhs[i]);
+    }
+    res[j] += alpha * t2;
+  }
+}
+
+} // end namespace internal 
+
+/***************************************************************************
+* Wrapper to product_selfadjoint_vector
+***************************************************************************/
+
+namespace internal {
+
+template<typename Lhs, int LhsMode, typename Rhs>
+struct selfadjoint_product_impl<Lhs,LhsMode,false,Rhs,0,true>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  typedef internal::blas_traits<Lhs> LhsBlasTraits;
+  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+  typedef typename internal::remove_all<ActualLhsType>::type ActualLhsTypeCleaned;
+  
+  typedef internal::blas_traits<Rhs> RhsBlasTraits;
+  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+  enum { LhsUpLo = LhsMode&(Upper|Lower) };
+
+  template<typename Dest>
+  static EIGEN_DEVICE_FUNC
+  void run(Dest& dest, const Lhs &a_lhs, const Rhs &a_rhs, const Scalar& alpha)
+  {
+    typedef typename Dest::Scalar ResScalar;
+    typedef typename Rhs::Scalar RhsScalar;
+    typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest;
+    
+    eigen_assert(dest.rows()==a_lhs.rows() && dest.cols()==a_rhs.cols());
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs)
+                               * RhsBlasTraits::extractScalarFactor(a_rhs);
+
+    enum {
+      EvalToDest = (Dest::InnerStrideAtCompileTime==1),
+      UseRhs = (ActualRhsTypeCleaned::InnerStrideAtCompileTime==1)
+    };
+    
+    internal::gemv_static_vector_if<ResScalar,Dest::SizeAtCompileTime,Dest::MaxSizeAtCompileTime,!EvalToDest> static_dest;
+    internal::gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!UseRhs> static_rhs;
+
+    ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(),
+                                                  EvalToDest ? dest.data() : static_dest.data());
+                                                  
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,rhs.size(),
+        UseRhs ? const_cast<RhsScalar*>(rhs.data()) : static_rhs.data());
+    
+    if(!EvalToDest)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = dest.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      MappedDest(actualDestPtr, dest.size()) = dest;
+    }
+      
+    if(!UseRhs)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = rhs.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, rhs.size()) = rhs;
+    }
+      
+      
+    internal::selfadjoint_matrix_vector_product<Scalar, Index, (internal::traits<ActualLhsTypeCleaned>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+                                                int(LhsUpLo), bool(LhsBlasTraits::NeedToConjugate), bool(RhsBlasTraits::NeedToConjugate)>::run
+      (
+        lhs.rows(),                             // size
+        &lhs.coeffRef(0,0),  lhs.outerStride(), // lhs info
+        actualRhsPtr,                           // rhs info
+        actualDestPtr,                          // result info
+        actualAlpha                             // scale factor
+      );
+    
+    if(!EvalToDest)
+      dest = MappedDest(actualDestPtr, dest.size());
+  }
+};
+
+template<typename Lhs, typename Rhs, int RhsMode>
+struct selfadjoint_product_impl<Lhs,0,true,Rhs,RhsMode,false>
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  enum { RhsUpLo = RhsMode&(Upper|Lower)  };
+
+  template<typename Dest>
+  static void run(Dest& dest, const Lhs &a_lhs, const Rhs &a_rhs, const Scalar& alpha)
+  {
+    // let's simply transpose the product
+    Transpose<Dest> destT(dest);
+    selfadjoint_product_impl<Transpose<const Rhs>, int(RhsUpLo)==Upper ? Lower : Upper, false,
+                             Transpose<const Lhs>, 0, true>::run(destT, a_rhs.transpose(), a_lhs.transpose(), alpha);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_VECTOR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
new file mode 100644
index 00000000..1238345e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
@@ -0,0 +1,118 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Selfadjoint matrix-vector product functionality based on ?SYMV/HEMV.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
+#define EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements selfadjoint matrix-vector multiplication using BLAS
+**********************************************************************/
+
+// symv/hemv specialization
+
+template<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs>
+struct selfadjoint_matrix_vector_product_symv :
+  selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,BuiltIn> {};
+
+#define EIGEN_BLAS_SYMV_SPECIALIZE(Scalar) \
+template<typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs> \
+struct selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,Specialized> { \
+static void run( \
+  Index size, const Scalar*  lhs, Index lhsStride, \
+  const Scalar* _rhs, Scalar* res, Scalar alpha) { \
+    enum {\
+      IsColMajor = StorageOrder==ColMajor \
+    }; \
+    if (IsColMajor == ConjugateLhs) {\
+      selfadjoint_matrix_vector_product<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs,BuiltIn>::run( \
+        size, lhs, lhsStride, _rhs, res, alpha);  \
+    } else {\
+      selfadjoint_matrix_vector_product_symv<Scalar,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs>::run( \
+        size, lhs, lhsStride, _rhs, res, alpha);  \
+    }\
+  } \
+}; \
+
+EIGEN_BLAS_SYMV_SPECIALIZE(double)
+EIGEN_BLAS_SYMV_SPECIALIZE(float)
+EIGEN_BLAS_SYMV_SPECIALIZE(dcomplex)
+EIGEN_BLAS_SYMV_SPECIALIZE(scomplex)
+
+#define EIGEN_BLAS_SYMV_SPECIALIZATION(EIGTYPE,BLASTYPE,BLASFUNC) \
+template<typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs> \
+struct selfadjoint_matrix_vector_product_symv<EIGTYPE,Index,StorageOrder,UpLo,ConjugateLhs,ConjugateRhs> \
+{ \
+typedef Matrix<EIGTYPE,Dynamic,1,ColMajor> SYMVVector;\
+\
+static void run( \
+Index size, const EIGTYPE*  lhs, Index lhsStride, \
+const EIGTYPE* _rhs, EIGTYPE* res, EIGTYPE alpha) \
+{ \
+  enum {\
+    IsRowMajor = StorageOrder==RowMajor ? 1 : 0, \
+    IsLower = UpLo == Lower ? 1 : 0 \
+  }; \
+  BlasIndex n=convert_index<BlasIndex>(size), lda=convert_index<BlasIndex>(lhsStride), incx=1, incy=1; \
+  EIGTYPE beta(1); \
+  const EIGTYPE *x_ptr; \
+  char uplo=(IsRowMajor) ? (IsLower ? 'U' : 'L') : (IsLower ? 'L' : 'U'); \
+  SYMVVector x_tmp; \
+  if (ConjugateRhs) { \
+    Map<const SYMVVector, 0 > map_x(_rhs,size,1); \
+    x_tmp=map_x.conjugate(); \
+    x_ptr=x_tmp.data(); \
+  } else x_ptr=_rhs; \
+  BLASFUNC(&uplo, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)lhs, &lda, (const BLASTYPE*)x_ptr, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &incy); \
+}\
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_SYMV_SPECIALIZATION(double,   double, dsymv)
+EIGEN_BLAS_SYMV_SPECIALIZATION(float,    float,  ssymv)
+EIGEN_BLAS_SYMV_SPECIALIZATION(dcomplex, MKL_Complex16, zhemv)
+EIGEN_BLAS_SYMV_SPECIALIZATION(scomplex, MKL_Complex8,  chemv)
+#else
+EIGEN_BLAS_SYMV_SPECIALIZATION(double,   double, dsymv_)
+EIGEN_BLAS_SYMV_SPECIALIZATION(float,    float,  ssymv_)
+EIGEN_BLAS_SYMV_SPECIALIZATION(dcomplex, double, zhemv_)
+EIGEN_BLAS_SYMV_SPECIALIZATION(scomplex, float,  chemv_)
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointProduct.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointProduct.h
new file mode 100644
index 00000000..a21be805
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointProduct.h
@@ -0,0 +1,133 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINT_PRODUCT_H
+#define EIGEN_SELFADJOINT_PRODUCT_H
+
+/**********************************************************************
+* This file implements a self adjoint product: C += A A^T updating only
+* half of the selfadjoint matrix C.
+* It corresponds to the level 3 SYRK and level 2 SYR Blas routines.
+**********************************************************************/
+
+namespace Eigen { 
+
+
+template<typename Scalar, typename Index, int UpLo, bool ConjLhs, bool ConjRhs>
+struct selfadjoint_rank1_update<Scalar,Index,ColMajor,UpLo,ConjLhs,ConjRhs>
+{
+  static void run(Index size, Scalar* mat, Index stride, const Scalar* vecX, const Scalar* vecY, const Scalar& alpha)
+  {
+    internal::conj_if<ConjRhs> cj;
+    typedef Map<const Matrix<Scalar,Dynamic,1> > OtherMap;
+    typedef typename internal::conditional<ConjLhs,typename OtherMap::ConjugateReturnType,const OtherMap&>::type ConjLhsType;
+    for (Index i=0; i<size; ++i)
+    {
+      Map<Matrix<Scalar,Dynamic,1> >(mat+stride*i+(UpLo==Lower ? i : 0), (UpLo==Lower ? size-i : (i+1)))
+          += (alpha * cj(vecY[i])) * ConjLhsType(OtherMap(vecX+(UpLo==Lower ? i : 0),UpLo==Lower ? size-i : (i+1)));
+    }
+  }
+};
+
+template<typename Scalar, typename Index, int UpLo, bool ConjLhs, bool ConjRhs>
+struct selfadjoint_rank1_update<Scalar,Index,RowMajor,UpLo,ConjLhs,ConjRhs>
+{
+  static void run(Index size, Scalar* mat, Index stride, const Scalar* vecX, const Scalar* vecY, const Scalar& alpha)
+  {
+    selfadjoint_rank1_update<Scalar,Index,ColMajor,UpLo==Lower?Upper:Lower,ConjRhs,ConjLhs>::run(size,mat,stride,vecY,vecX,alpha);
+  }
+};
+
+template<typename MatrixType, typename OtherType, int UpLo, bool OtherIsVector = OtherType::IsVectorAtCompileTime>
+struct selfadjoint_product_selector;
+
+template<typename MatrixType, typename OtherType, int UpLo>
+struct selfadjoint_product_selector<MatrixType,OtherType,UpLo,true>
+{
+  static void run(MatrixType& mat, const OtherType& other, const typename MatrixType::Scalar& alpha)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    typedef internal::blas_traits<OtherType> OtherBlasTraits;
+    typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
+    typedef typename internal::remove_all<ActualOtherType>::type _ActualOtherType;
+    typename internal::add_const_on_value_type<ActualOtherType>::type actualOther = OtherBlasTraits::extract(other.derived());
+
+    Scalar actualAlpha = alpha * OtherBlasTraits::extractScalarFactor(other.derived());
+
+    enum {
+      StorageOrder = (internal::traits<MatrixType>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+      UseOtherDirectly = _ActualOtherType::InnerStrideAtCompileTime==1
+    };
+    internal::gemv_static_vector_if<Scalar,OtherType::SizeAtCompileTime,OtherType::MaxSizeAtCompileTime,!UseOtherDirectly> static_other;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, actualOtherPtr, other.size(),
+      (UseOtherDirectly ? const_cast<Scalar*>(actualOther.data()) : static_other.data()));
+      
+    if(!UseOtherDirectly)
+      Map<typename _ActualOtherType::PlainObject>(actualOtherPtr, actualOther.size()) = actualOther;
+    
+    selfadjoint_rank1_update<Scalar,Index,StorageOrder,UpLo,
+                              OtherBlasTraits::NeedToConjugate  && NumTraits<Scalar>::IsComplex,
+                            (!OtherBlasTraits::NeedToConjugate) && NumTraits<Scalar>::IsComplex>
+          ::run(other.size(), mat.data(), mat.outerStride(), actualOtherPtr, actualOtherPtr, actualAlpha);
+  }
+};
+
+template<typename MatrixType, typename OtherType, int UpLo>
+struct selfadjoint_product_selector<MatrixType,OtherType,UpLo,false>
+{
+  static void run(MatrixType& mat, const OtherType& other, const typename MatrixType::Scalar& alpha)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    typedef internal::blas_traits<OtherType> OtherBlasTraits;
+    typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
+    typedef typename internal::remove_all<ActualOtherType>::type _ActualOtherType;
+    typename internal::add_const_on_value_type<ActualOtherType>::type actualOther = OtherBlasTraits::extract(other.derived());
+
+    Scalar actualAlpha = alpha * OtherBlasTraits::extractScalarFactor(other.derived());
+
+    enum {
+      IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0,
+      OtherIsRowMajor = _ActualOtherType::Flags&RowMajorBit ? 1 : 0
+    };
+
+    Index size = mat.cols();
+    Index depth = actualOther.cols();
+
+    typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,Scalar,Scalar,
+              MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime, _ActualOtherType::MaxColsAtCompileTime> BlockingType;
+
+    BlockingType blocking(size, size, depth, 1, false);
+
+
+    internal::general_matrix_matrix_triangular_product<Index,
+      Scalar, OtherIsRowMajor ? RowMajor : ColMajor,   OtherBlasTraits::NeedToConjugate  && NumTraits<Scalar>::IsComplex,
+      Scalar, OtherIsRowMajor ? ColMajor : RowMajor, (!OtherBlasTraits::NeedToConjugate) && NumTraits<Scalar>::IsComplex,
+      IsRowMajor ? RowMajor : ColMajor, MatrixType::InnerStrideAtCompileTime, UpLo>
+      ::run(size, depth,
+            actualOther.data(), actualOther.outerStride(), actualOther.data(), actualOther.outerStride(),
+            mat.data(), mat.innerStride(), mat.outerStride(), actualAlpha, blocking);
+  }
+};
+
+// high level API
+
+template<typename MatrixType, unsigned int UpLo>
+template<typename DerivedU>
+EIGEN_DEVICE_FUNC SelfAdjointView<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo>
+::rankUpdate(const MatrixBase<DerivedU>& u, const Scalar& alpha)
+{
+  selfadjoint_product_selector<MatrixType,DerivedU,UpLo>::run(_expression().const_cast_derived(), u.derived(), alpha);
+
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINT_PRODUCT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointRank2Update.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointRank2Update.h
new file mode 100644
index 00000000..f752a0bf
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/SelfadjointRank2Update.h
@@ -0,0 +1,94 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINTRANK2UPTADE_H
+#define EIGEN_SELFADJOINTRANK2UPTADE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/* Optimized selfadjoint matrix += alpha * uv' + conj(alpha)*vu'
+ * It corresponds to the Level2 syr2 BLAS routine
+ */
+
+template<typename Scalar, typename Index, typename UType, typename VType, int UpLo>
+struct selfadjoint_rank2_update_selector;
+
+template<typename Scalar, typename Index, typename UType, typename VType>
+struct selfadjoint_rank2_update_selector<Scalar,Index,UType,VType,Lower>
+{
+  static EIGEN_DEVICE_FUNC
+  void run(Scalar* mat, Index stride, const UType& u, const VType& v, const Scalar& alpha)
+  {
+    const Index size = u.size();
+    for (Index i=0; i<size; ++i)
+    {
+      Map<Matrix<Scalar,Dynamic,1> >(mat+stride*i+i, size-i) +=
+                        (numext::conj(alpha) * numext::conj(u.coeff(i))) * v.tail(size-i)
+                      + (alpha * numext::conj(v.coeff(i))) * u.tail(size-i);
+    }
+  }
+};
+
+template<typename Scalar, typename Index, typename UType, typename VType>
+struct selfadjoint_rank2_update_selector<Scalar,Index,UType,VType,Upper>
+{
+  static void run(Scalar* mat, Index stride, const UType& u, const VType& v, const Scalar& alpha)
+  {
+    const Index size = u.size();
+    for (Index i=0; i<size; ++i)
+      Map<Matrix<Scalar,Dynamic,1> >(mat+stride*i, i+1) +=
+                        (numext::conj(alpha)  * numext::conj(u.coeff(i))) * v.head(i+1)
+                      + (alpha * numext::conj(v.coeff(i))) * u.head(i+1);
+  }
+};
+
+template<bool Cond, typename T> struct conj_expr_if
+  : conditional<!Cond, const T&,
+      CwiseUnaryOp<scalar_conjugate_op<typename traits<T>::Scalar>,T> > {};
+
+} // end namespace internal
+
+template<typename MatrixType, unsigned int UpLo>
+template<typename DerivedU, typename DerivedV>
+EIGEN_DEVICE_FUNC SelfAdjointView<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo>
+::rankUpdate(const MatrixBase<DerivedU>& u, const MatrixBase<DerivedV>& v, const Scalar& alpha)
+{
+  typedef internal::blas_traits<DerivedU> UBlasTraits;
+  typedef typename UBlasTraits::DirectLinearAccessType ActualUType;
+  typedef typename internal::remove_all<ActualUType>::type _ActualUType;
+  typename internal::add_const_on_value_type<ActualUType>::type actualU = UBlasTraits::extract(u.derived());
+
+  typedef internal::blas_traits<DerivedV> VBlasTraits;
+  typedef typename VBlasTraits::DirectLinearAccessType ActualVType;
+  typedef typename internal::remove_all<ActualVType>::type _ActualVType;
+  typename internal::add_const_on_value_type<ActualVType>::type actualV = VBlasTraits::extract(v.derived());
+
+  // If MatrixType is row major, then we use the routine for lower triangular in the upper triangular case and
+  // vice versa, and take the complex conjugate of all coefficients and vector entries.
+
+  enum { IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0 };
+  Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived())
+                             * numext::conj(VBlasTraits::extractScalarFactor(v.derived()));
+  if (IsRowMajor)
+    actualAlpha = numext::conj(actualAlpha);
+
+  typedef typename internal::remove_all<typename internal::conj_expr_if<int(IsRowMajor) ^ int(UBlasTraits::NeedToConjugate), _ActualUType>::type>::type UType;
+  typedef typename internal::remove_all<typename internal::conj_expr_if<int(IsRowMajor) ^ int(VBlasTraits::NeedToConjugate), _ActualVType>::type>::type VType;
+  internal::selfadjoint_rank2_update_selector<Scalar, Index, UType, VType,
+    (IsRowMajor ? int(UpLo==Upper ? Lower : Upper) : UpLo)>
+    ::run(_expression().const_cast_derived().data(),_expression().outerStride(),UType(actualU),VType(actualV),actualAlpha);
+
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINTRANK2UPTADE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixMatrix.h
new file mode 100644
index 00000000..f0c60507
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixMatrix.h
@@ -0,0 +1,472 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULAR_MATRIX_MATRIX_H
+#define EIGEN_TRIANGULAR_MATRIX_MATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// template<typename Scalar, int mr, int StorageOrder, bool Conjugate, int Mode>
+// struct gemm_pack_lhs_triangular
+// {
+//   Matrix<Scalar,mr,mr,
+//   void operator()(Scalar* blockA, const EIGEN_RESTRICT Scalar* _lhs, int lhsStride, int depth, int rows)
+//   {
+//     conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
+//     const_blas_data_mapper<Scalar, StorageOrder> lhs(_lhs,lhsStride);
+//     int count = 0;
+//     const int peeled_mc = (rows/mr)*mr;
+//     for(int i=0; i<peeled_mc; i+=mr)
+//     {
+//       for(int k=0; k<depth; k++)
+//         for(int w=0; w<mr; w++)
+//           blockA[count++] = cj(lhs(i+w, k));
+//     }
+//     for(int i=peeled_mc; i<rows; i++)
+//     {
+//       for(int k=0; k<depth; k++)
+//         blockA[count++] = cj(lhs(i, k));
+//     }
+//   }
+// };
+
+/* Optimized triangular matrix * matrix (_TRMM++) product built on top of
+ * the general matrix matrix product.
+ */
+template <typename Scalar, typename Index,
+          int Mode, bool LhsIsTriangular,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResStorageOrder, int ResInnerStride,
+          int Version = Specialized>
+struct product_triangular_matrix_matrix;
+
+template <typename Scalar, typename Index,
+          int Mode, bool LhsIsTriangular,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride, int Version>
+struct product_triangular_matrix_matrix<Scalar,Index,Mode,LhsIsTriangular,
+                                           LhsStorageOrder,ConjugateLhs,
+                                           RhsStorageOrder,ConjugateRhs,RowMajor,ResInnerStride,Version>
+{
+  static EIGEN_STRONG_INLINE void run(
+    Index rows, Index cols, Index depth,
+    const Scalar* lhs, Index lhsStride,
+    const Scalar* rhs, Index rhsStride,
+    Scalar* res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    product_triangular_matrix_matrix<Scalar, Index,
+      (Mode&(UnitDiag|ZeroDiag)) | ((Mode&Upper) ? Lower : Upper),
+      (!LhsIsTriangular),
+      RhsStorageOrder==RowMajor ? ColMajor : RowMajor,
+      ConjugateRhs,
+      LhsStorageOrder==RowMajor ? ColMajor : RowMajor,
+      ConjugateLhs,
+      ColMajor, ResInnerStride>
+      ::run(cols, rows, depth, rhs, rhsStride, lhs, lhsStride, res, resIncr, resStride, alpha, blocking);
+  }
+};
+
+// implements col-major += alpha * op(triangular) * op(general)
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride, int Version>
+struct product_triangular_matrix_matrix<Scalar,Index,Mode,true,
+                                           LhsStorageOrder,ConjugateLhs,
+                                           RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride,Version>
+{
+  
+  typedef gebp_traits<Scalar,Scalar> Traits;
+  enum {
+    SmallPanelWidth   = 2 * EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+    IsLower = (Mode&Lower) == Lower,
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1
+  };
+
+  static EIGEN_DONT_INLINE void run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride, int Version>
+EIGEN_DONT_INLINE void product_triangular_matrix_matrix<Scalar,Index,Mode,true,
+                                                        LhsStorageOrder,ConjugateLhs,
+                                                        RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride,Version>::run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    // strip zeros
+    Index diagSize  = (std::min)(_rows,_depth);
+    Index rows      = IsLower ? _rows : diagSize;
+    Index depth     = IsLower ? diagSize : _depth;
+    Index cols      = _cols;
+    
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride, resIncr);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+    // The small panel size must not be larger than blocking size.
+    // Usually this should never be the case because SmallPanelWidth^2 is very small
+    // compared to L2 cache size, but let's be safe:
+    Index panelWidth = (std::min)(Index(SmallPanelWidth),(std::min)(kc,mc));
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    // To work around an "error: member reference base type 'Matrix<...>
+    // (Eigen::internal::constructor_without_unaligned_array_assert (*)())' is
+    // not a structure or union" compilation error in nvcc (tested V8.0.61),
+    // create a dummy internal::constructor_without_unaligned_array_assert
+    // object to pass to the Matrix constructor.
+    internal::constructor_without_unaligned_array_assert a;
+    Matrix<Scalar,SmallPanelWidth,SmallPanelWidth,LhsStorageOrder> triangularBuffer(a);
+    triangularBuffer.setZero();
+    if((Mode&ZeroDiag)==ZeroDiag)
+      triangularBuffer.diagonal().setZero();
+    else
+      triangularBuffer.diagonal().setOnes();
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder> pack_rhs;
+
+    for(Index k2=IsLower ? depth : 0;
+        IsLower ? k2>0 : k2<depth;
+        IsLower ? k2-=kc : k2+=kc)
+    {
+      Index actual_kc = (std::min)(IsLower ? k2 : depth-k2, kc);
+      Index actual_k2 = IsLower ? k2-actual_kc : k2;
+
+      // align blocks with the end of the triangular part for trapezoidal lhs
+      if((!IsLower)&&(k2<rows)&&(k2+actual_kc>rows))
+      {
+        actual_kc = rows-k2;
+        k2 = k2+actual_kc-kc;
+      }
+
+      pack_rhs(blockB, rhs.getSubMapper(actual_k2,0), actual_kc, cols);
+
+      // the selected lhs's panel has to be split in three different parts:
+      //  1 - the part which is zero => skip it
+      //  2 - the diagonal block => special kernel
+      //  3 - the dense panel below (lower case) or above (upper case) the diagonal block => GEPP
+
+      // the block diagonal, if any:
+      if(IsLower || actual_k2<rows)
+      {
+        // for each small vertical panels of lhs
+        for (Index k1=0; k1<actual_kc; k1+=panelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-k1, panelWidth);
+          Index lengthTarget = IsLower ? actual_kc-k1-actualPanelWidth : k1;
+          Index startBlock   = actual_k2+k1;
+          Index blockBOffset = k1;
+
+          // => GEBP with the micro triangular block
+          // The trick is to pack this micro block while filling the opposite triangular part with zeros.
+          // To this end we do an extra triangular copy to a small temporary buffer
+          for (Index k=0;k<actualPanelWidth;++k)
+          {
+            if (SetDiag)
+              triangularBuffer.coeffRef(k,k) = lhs(startBlock+k,startBlock+k);
+            for (Index i=IsLower ? k+1 : 0; IsLower ? i<actualPanelWidth : i<k; ++i)
+              triangularBuffer.coeffRef(i,k) = lhs(startBlock+i,startBlock+k);
+          }
+          pack_lhs(blockA, LhsMapper(triangularBuffer.data(), triangularBuffer.outerStride()), actualPanelWidth, actualPanelWidth);
+
+          gebp_kernel(res.getSubMapper(startBlock, 0), blockA, blockB,
+                      actualPanelWidth, actualPanelWidth, cols, alpha,
+                      actualPanelWidth, actual_kc, 0, blockBOffset);
+
+          // GEBP with remaining micro panel
+          if (lengthTarget>0)
+          {
+            Index startTarget  = IsLower ? actual_k2+k1+actualPanelWidth : actual_k2;
+
+            pack_lhs(blockA, lhs.getSubMapper(startTarget,startBlock), actualPanelWidth, lengthTarget);
+
+            gebp_kernel(res.getSubMapper(startTarget, 0), blockA, blockB,
+                        lengthTarget, actualPanelWidth, cols, alpha,
+                        actualPanelWidth, actual_kc, 0, blockBOffset);
+          }
+        }
+      }
+      // the part below (lower case) or above (upper case) the diagonal => GEPP
+      {
+        Index start = IsLower ? k2 : 0;
+        Index end   = IsLower ? rows : (std::min)(actual_k2,rows);
+        for(Index i2=start; i2<end; i2+=mc)
+        {
+          const Index actual_mc = (std::min)(i2+mc,end)-i2;
+          gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr,Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder,false>()
+            (blockA, lhs.getSubMapper(i2, actual_k2), actual_kc, actual_mc);
+
+          gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc,
+                      actual_kc, cols, alpha, -1, -1, 0, 0);
+        }
+      }
+    }
+  }
+
+// implements col-major += alpha * op(general) * op(triangular)
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride, int Version>
+struct product_triangular_matrix_matrix<Scalar,Index,Mode,false,
+                                        LhsStorageOrder,ConjugateLhs,
+                                        RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride,Version>
+{
+  typedef gebp_traits<Scalar,Scalar> Traits;
+  enum {
+    SmallPanelWidth   = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+    IsLower = (Mode&Lower) == Lower,
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1
+  };
+
+  static EIGEN_DONT_INLINE void run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* res,        Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking);
+};
+
+template <typename Scalar, typename Index, int Mode,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResInnerStride, int Version>
+EIGEN_DONT_INLINE void product_triangular_matrix_matrix<Scalar,Index,Mode,false,
+                                                        LhsStorageOrder,ConjugateLhs,
+                                                        RhsStorageOrder,ConjugateRhs,ColMajor,ResInnerStride,Version>::run(
+    Index _rows, Index _cols, Index _depth,
+    const Scalar* _lhs, Index lhsStride,
+    const Scalar* _rhs, Index rhsStride,
+    Scalar* _res,       Index resIncr, Index resStride,
+    const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking)
+  {
+    const Index PacketBytes = packet_traits<Scalar>::size*sizeof(Scalar);
+    // strip zeros
+    Index diagSize  = (std::min)(_cols,_depth);
+    Index rows      = _rows;
+    Index depth     = IsLower ? _depth : diagSize;
+    Index cols      = IsLower ? diagSize : _cols;
+    
+    typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
+    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    LhsMapper lhs(_lhs,lhsStride);
+    RhsMapper rhs(_rhs,rhsStride);
+    ResMapper res(_res, resStride, resIncr);
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols+EIGEN_MAX_ALIGN_BYTES/sizeof(Scalar);
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    internal::constructor_without_unaligned_array_assert a;
+    Matrix<Scalar,SmallPanelWidth,SmallPanelWidth,RhsStorageOrder> triangularBuffer(a);
+    triangularBuffer.setZero();
+    if((Mode&ZeroDiag)==ZeroDiag)
+      triangularBuffer.diagonal().setZero();
+    else
+      triangularBuffer.diagonal().setOnes();
+
+    gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, LhsStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder> pack_rhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr,RhsStorageOrder,false,true> pack_rhs_panel;
+
+    for(Index k2=IsLower ? 0 : depth;
+        IsLower ? k2<depth  : k2>0;
+        IsLower ? k2+=kc   : k2-=kc)
+    {
+      Index actual_kc = (std::min)(IsLower ? depth-k2 : k2, kc);
+      Index actual_k2 = IsLower ? k2 : k2-actual_kc;
+
+      // align blocks with the end of the triangular part for trapezoidal rhs
+      if(IsLower && (k2<cols) && (actual_k2+actual_kc>cols))
+      {
+        actual_kc = cols-k2;
+        k2 = actual_k2 + actual_kc - kc;
+      }
+
+      // remaining size
+      Index rs = IsLower ? (std::min)(cols,actual_k2) : cols - k2;
+      // size of the triangular part
+      Index ts = (IsLower && actual_k2>=cols) ? 0 : actual_kc;
+
+      Scalar* geb = blockB+ts*ts;
+      geb = geb + internal::first_aligned<PacketBytes>(geb,PacketBytes/sizeof(Scalar));
+
+      pack_rhs(geb, rhs.getSubMapper(actual_k2,IsLower ? 0 : k2), actual_kc, rs);
+
+      // pack the triangular part of the rhs padding the unrolled blocks with zeros
+      if(ts>0)
+      {
+        for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+          Index actual_j2 = actual_k2 + j2;
+          Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
+          Index panelLength = IsLower ? actual_kc-j2-actualPanelWidth : j2;
+          // general part
+          pack_rhs_panel(blockB+j2*actual_kc,
+                         rhs.getSubMapper(actual_k2+panelOffset, actual_j2),
+                         panelLength, actualPanelWidth,
+                         actual_kc, panelOffset);
+
+          // append the triangular part via a temporary buffer
+          for (Index j=0;j<actualPanelWidth;++j)
+          {
+            if (SetDiag)
+              triangularBuffer.coeffRef(j,j) = rhs(actual_j2+j,actual_j2+j);
+            for (Index k=IsLower ? j+1 : 0; IsLower ? k<actualPanelWidth : k<j; ++k)
+              triangularBuffer.coeffRef(k,j) = rhs(actual_j2+k,actual_j2+j);
+          }
+
+          pack_rhs_panel(blockB+j2*actual_kc,
+                         RhsMapper(triangularBuffer.data(), triangularBuffer.outerStride()),
+                         actualPanelWidth, actualPanelWidth,
+                         actual_kc, j2);
+        }
+      }
+
+      for (Index i2=0; i2<rows; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(mc,rows-i2);
+        pack_lhs(blockA, lhs.getSubMapper(i2, actual_k2), actual_kc, actual_mc);
+
+        // triangular kernel
+        if(ts>0)
+        {
+          for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
+          {
+            Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+            Index panelLength = IsLower ? actual_kc-j2 : j2+actualPanelWidth;
+            Index blockOffset = IsLower ? j2 : 0;
+
+            gebp_kernel(res.getSubMapper(i2, actual_k2 + j2),
+                        blockA, blockB+j2*actual_kc,
+                        actual_mc, panelLength, actualPanelWidth,
+                        alpha,
+                        actual_kc, actual_kc,  // strides
+                        blockOffset, blockOffset);// offsets
+          }
+        }
+        gebp_kernel(res.getSubMapper(i2, IsLower ? 0 : k2),
+                    blockA, geb, actual_mc, actual_kc, rs,
+                    alpha,
+                    -1, -1, 0, 0);
+      }
+    }
+  }
+
+/***************************************************************************
+* Wrapper to product_triangular_matrix_matrix
+***************************************************************************/
+
+} // end namespace internal
+
+namespace internal {
+template<int Mode, bool LhsIsTriangular, typename Lhs, typename Rhs>
+struct triangular_product_impl<Mode,LhsIsTriangular,Lhs,false,Rhs,false>
+{
+  template<typename Dest> static void run(Dest& dst, const Lhs &a_lhs, const Rhs &a_rhs, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar  LhsScalar;
+    typedef typename Rhs::Scalar  RhsScalar;
+    typedef typename Dest::Scalar Scalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef typename internal::remove_all<ActualLhsType>::type ActualLhsTypeCleaned;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+    
+    typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
+
+    LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(a_lhs);
+    RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(a_rhs);
+    Scalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+
+    typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
+              Lhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxColsAtCompileTime,4> BlockingType;
+
+    enum { IsLower = (Mode&Lower) == Lower };
+    Index stripedRows  = ((!LhsIsTriangular) || (IsLower))  ? lhs.rows() : (std::min)(lhs.rows(),lhs.cols());
+    Index stripedCols  = ((LhsIsTriangular)  || (!IsLower)) ? rhs.cols() : (std::min)(rhs.cols(),rhs.rows());
+    Index stripedDepth = LhsIsTriangular ? ((!IsLower) ? lhs.cols() : (std::min)(lhs.cols(),lhs.rows()))
+                                         : ((IsLower)  ? rhs.rows() : (std::min)(rhs.rows(),rhs.cols()));
+
+    BlockingType blocking(stripedRows, stripedCols, stripedDepth, 1, false);
+
+    internal::product_triangular_matrix_matrix<Scalar, Index,
+      Mode, LhsIsTriangular,
+      (internal::traits<ActualLhsTypeCleaned>::Flags&RowMajorBit) ? RowMajor : ColMajor, LhsBlasTraits::NeedToConjugate,
+      (internal::traits<ActualRhsTypeCleaned>::Flags&RowMajorBit) ? RowMajor : ColMajor, RhsBlasTraits::NeedToConjugate,
+      (internal::traits<Dest          >::Flags&RowMajorBit) ? RowMajor : ColMajor, Dest::InnerStrideAtCompileTime>
+      ::run(
+        stripedRows, stripedCols, stripedDepth,   // sizes
+        &lhs.coeffRef(0,0), lhs.outerStride(),    // lhs info
+        &rhs.coeffRef(0,0), rhs.outerStride(),    // rhs info
+        &dst.coeffRef(0,0), dst.innerStride(), dst.outerStride(),    // result info
+        actualAlpha, blocking
+      );
+
+    // Apply correction if the diagonal is unit and a scalar factor was nested:
+    if ((Mode&UnitDiag)==UnitDiag)
+    {
+      if (LhsIsTriangular && lhs_alpha!=LhsScalar(1))
+      {
+        Index diagSize = (std::min)(lhs.rows(),lhs.cols());
+        dst.topRows(diagSize) -= ((lhs_alpha-LhsScalar(1))*a_rhs).topRows(diagSize);
+      }
+      else if ((!LhsIsTriangular) && rhs_alpha!=RhsScalar(1))
+      {
+        Index diagSize = (std::min)(rhs.rows(),rhs.cols());
+        dst.leftCols(diagSize) -= (rhs_alpha-RhsScalar(1))*a_lhs.leftCols(diagSize);
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_MATRIX_MATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
new file mode 100644
index 00000000..a98d12e4
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
@@ -0,0 +1,317 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Triangular matrix * matrix product functionality based on ?TRMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
+#define EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+template <typename Scalar, typename Index,
+          int Mode, bool LhsIsTriangular,
+          int LhsStorageOrder, bool ConjugateLhs,
+          int RhsStorageOrder, bool ConjugateRhs,
+          int ResStorageOrder>
+struct product_triangular_matrix_matrix_trmm :
+       product_triangular_matrix_matrix<Scalar,Index,Mode,
+          LhsIsTriangular,LhsStorageOrder,ConjugateLhs,
+          RhsStorageOrder, ConjugateRhs, ResStorageOrder, 1, BuiltIn> {};
+
+
+// try to go to BLAS specialization
+#define EIGEN_BLAS_TRMM_SPECIALIZE(Scalar, LhsIsTriangular) \
+template <typename Index, int Mode, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_triangular_matrix_matrix<Scalar,Index, Mode, LhsIsTriangular, \
+           LhsStorageOrder,ConjugateLhs, RhsStorageOrder,ConjugateRhs,ColMajor,1,Specialized> { \
+  static inline void run(Index _rows, Index _cols, Index _depth, const Scalar* _lhs, Index lhsStride,\
+    const Scalar* _rhs, Index rhsStride, Scalar* res, Index resIncr, Index resStride, Scalar alpha, level3_blocking<Scalar,Scalar>& blocking) { \
+      EIGEN_ONLY_USED_FOR_DEBUG(resIncr); \
+      eigen_assert(resIncr == 1); \
+      product_triangular_matrix_matrix_trmm<Scalar,Index,Mode, \
+        LhsIsTriangular,LhsStorageOrder,ConjugateLhs, \
+        RhsStorageOrder, ConjugateRhs, ColMajor>::run( \
+          _rows, _cols, _depth, _lhs, lhsStride, _rhs, rhsStride, res, resStride, alpha, blocking); \
+  } \
+};
+
+EIGEN_BLAS_TRMM_SPECIALIZE(double, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(double, false)
+EIGEN_BLAS_TRMM_SPECIALIZE(dcomplex, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(dcomplex, false)
+EIGEN_BLAS_TRMM_SPECIALIZE(float, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(float, false)
+EIGEN_BLAS_TRMM_SPECIALIZE(scomplex, true)
+EIGEN_BLAS_TRMM_SPECIALIZE(scomplex, false)
+
+// implements col-major += alpha * op(triangular) * op(general)
+#define EIGEN_BLAS_TRMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, int Mode, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_triangular_matrix_matrix_trmm<EIGTYPE,Index,Mode,true, \
+         LhsStorageOrder,ConjugateLhs,RhsStorageOrder,ConjugateRhs,ColMajor> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = ((LhsStorageOrder==ColMajor) && ConjugateLhs) ? 1 : 0 \
+  }; \
+\
+  static void run( \
+    Index _rows, Index _cols, Index _depth, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE,EIGTYPE>& blocking) \
+  { \
+   Index diagSize  = (std::min)(_rows,_depth); \
+   Index rows      = IsLower ? _rows : diagSize; \
+   Index depth     = IsLower ? diagSize : _depth; \
+   Index cols      = _cols; \
+\
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> MatrixLhs; \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs; \
+\
+/* Non-square case - doesn't fit to BLAS ?TRMM. Fall to default triangular product or call BLAS ?GEMM*/ \
+   if (rows != depth) { \
+\
+     /* FIXME handle mkl_domain_get_max_threads */ \
+     /*int nthr = mkl_domain_get_max_threads(EIGEN_BLAS_DOMAIN_BLAS);*/ int nthr = 1;\
+\
+     if (((nthr==1) && (((std::max)(rows,depth)-diagSize)/(double)diagSize < 0.5))) { \
+     /* Most likely no benefit to call TRMM or GEMM from BLAS */ \
+       product_triangular_matrix_matrix<EIGTYPE,Index,Mode,true, \
+       LhsStorageOrder,ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, 1, BuiltIn>::run( \
+           _rows, _cols, _depth, _lhs, lhsStride, _rhs, rhsStride, res, 1, resStride, alpha, blocking); \
+     /*std::cout << "TRMM_L: A is not square! Go to Eigen TRMM implementation!\n";*/ \
+     } else { \
+     /* Make sense to call GEMM */ \
+       Map<const MatrixLhs, 0, OuterStride<> > lhsMap(_lhs,rows,depth,OuterStride<>(lhsStride)); \
+       MatrixLhs aa_tmp=lhsMap.template triangularView<Mode>(); \
+       BlasIndex aStride = convert_index<BlasIndex>(aa_tmp.outerStride()); \
+       gemm_blocking_space<ColMajor,EIGTYPE,EIGTYPE,Dynamic,Dynamic,Dynamic> gemm_blocking(_rows,_cols,_depth, 1, true); \
+       general_matrix_matrix_product<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,RhsStorageOrder,ConjugateRhs,ColMajor,1>::run( \
+       rows, cols, depth, aa_tmp.data(), aStride, _rhs, rhsStride, res, 1, resStride, alpha, gemm_blocking, 0); \
+\
+     /*std::cout << "TRMM_L: A is not square! Go to BLAS GEMM implementation! " << nthr<<" \n";*/ \
+     } \
+     return; \
+   } \
+   char side = 'L', transa, uplo, diag = 'N'; \
+   EIGTYPE *b; \
+   const EIGTYPE *a; \
+   BlasIndex m, n, lda, ldb; \
+\
+/* Set m, n */ \
+   m = convert_index<BlasIndex>(diagSize); \
+   n = convert_index<BlasIndex>(cols); \
+\
+/* Set trans */ \
+   transa = (LhsStorageOrder==RowMajor) ? ((ConjugateLhs) ? 'C' : 'T') : 'N'; \
+\
+/* Set b, ldb */ \
+   Map<const MatrixRhs, 0, OuterStride<> > rhs(_rhs,depth,cols,OuterStride<>(rhsStride)); \
+   MatrixX##EIGPREFIX b_tmp; \
+\
+   if (ConjugateRhs) b_tmp = rhs.conjugate(); else b_tmp = rhs; \
+   b = b_tmp.data(); \
+   ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+\
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (LhsStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   Map<const MatrixLhs, 0, OuterStride<> > lhs(_lhs,rows,depth,OuterStride<>(lhsStride)); \
+   MatrixLhs a_tmp; \
+\
+   if ((conjA!=0) || (SetDiag==0)) { \
+     if (conjA) a_tmp = lhs.conjugate(); else a_tmp = lhs; \
+     if (IsZeroDiag) \
+       a_tmp.diagonal().setZero(); \
+     else if (IsUnitDiag) \
+       a_tmp.diagonal().setOnes();\
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _lhs; \
+     lda = convert_index<BlasIndex>(lhsStride); \
+   } \
+   /*std::cout << "TRMM_L: A is square! Go to BLAS TRMM implementation! \n";*/ \
+/* call ?trmm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)b, &ldb); \
+\
+/* Add op(a_triangular)*b into res*/ \
+   Map<MatrixX##EIGPREFIX, 0, OuterStride<> > res_tmp(res,rows,cols,OuterStride<>(resStride)); \
+   res_tmp=res_tmp+b_tmp; \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMM_L(double, double, d, dtrmm)
+EIGEN_BLAS_TRMM_L(dcomplex, MKL_Complex16, cd, ztrmm)
+EIGEN_BLAS_TRMM_L(float, float, f, strmm)
+EIGEN_BLAS_TRMM_L(scomplex, MKL_Complex8, cf, ctrmm)
+#else
+EIGEN_BLAS_TRMM_L(double, double, d, dtrmm_)
+EIGEN_BLAS_TRMM_L(dcomplex, double, cd, ztrmm_)
+EIGEN_BLAS_TRMM_L(float, float, f, strmm_)
+EIGEN_BLAS_TRMM_L(scomplex, float, cf, ctrmm_)
+#endif
+
+// implements col-major += alpha * op(general) * op(triangular)
+#define EIGEN_BLAS_TRMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC) \
+template <typename Index, int Mode, \
+          int LhsStorageOrder, bool ConjugateLhs, \
+          int RhsStorageOrder, bool ConjugateRhs> \
+struct product_triangular_matrix_matrix_trmm<EIGTYPE,Index,Mode,false, \
+         LhsStorageOrder,ConjugateLhs,RhsStorageOrder,ConjugateRhs,ColMajor> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper, \
+    conjA = ((RhsStorageOrder==ColMajor) && ConjugateRhs) ? 1 : 0 \
+  }; \
+\
+  static void run( \
+    Index _rows, Index _cols, Index _depth, \
+    const EIGTYPE* _lhs, Index lhsStride, \
+    const EIGTYPE* _rhs, Index rhsStride, \
+    EIGTYPE* res,        Index resStride, \
+    EIGTYPE alpha, level3_blocking<EIGTYPE,EIGTYPE>& blocking) \
+  { \
+   Index diagSize  = (std::min)(_cols,_depth); \
+   Index rows      = _rows; \
+   Index depth     = IsLower ? _depth : diagSize; \
+   Index cols      = IsLower ? diagSize : _cols; \
+\
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> MatrixLhs; \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs; \
+\
+/* Non-square case - doesn't fit to BLAS ?TRMM. Fall to default triangular product or call BLAS ?GEMM*/ \
+   if (cols != depth) { \
+\
+     int nthr = 1 /*mkl_domain_get_max_threads(EIGEN_BLAS_DOMAIN_BLAS)*/; \
+\
+     if ((nthr==1) && (((std::max)(cols,depth)-diagSize)/(double)diagSize < 0.5)) { \
+     /* Most likely no benefit to call TRMM or GEMM from BLAS*/ \
+       product_triangular_matrix_matrix<EIGTYPE,Index,Mode,false, \
+       LhsStorageOrder,ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, 1, BuiltIn>::run( \
+           _rows, _cols, _depth, _lhs, lhsStride, _rhs, rhsStride, res, 1, resStride, alpha, blocking); \
+       /*std::cout << "TRMM_R: A is not square! Go to Eigen TRMM implementation!\n";*/ \
+     } else { \
+     /* Make sense to call GEMM */ \
+       Map<const MatrixRhs, 0, OuterStride<> > rhsMap(_rhs,depth,cols, OuterStride<>(rhsStride)); \
+       MatrixRhs aa_tmp=rhsMap.template triangularView<Mode>(); \
+       BlasIndex aStride = convert_index<BlasIndex>(aa_tmp.outerStride()); \
+       gemm_blocking_space<ColMajor,EIGTYPE,EIGTYPE,Dynamic,Dynamic,Dynamic> gemm_blocking(_rows,_cols,_depth, 1, true); \
+       general_matrix_matrix_product<Index,EIGTYPE,LhsStorageOrder,ConjugateLhs,EIGTYPE,RhsStorageOrder,ConjugateRhs,ColMajor,1>::run( \
+       rows, cols, depth, _lhs, lhsStride, aa_tmp.data(), aStride, res, 1, resStride, alpha, gemm_blocking, 0); \
+\
+     /*std::cout << "TRMM_R: A is not square! Go to BLAS GEMM implementation! " << nthr<<" \n";*/ \
+     } \
+     return; \
+   } \
+   char side = 'R', transa, uplo, diag = 'N'; \
+   EIGTYPE *b; \
+   const EIGTYPE *a; \
+   BlasIndex m, n, lda, ldb; \
+\
+/* Set m, n */ \
+   m = convert_index<BlasIndex>(rows); \
+   n = convert_index<BlasIndex>(diagSize); \
+\
+/* Set trans */ \
+   transa = (RhsStorageOrder==RowMajor) ? ((ConjugateRhs) ? 'C' : 'T') : 'N'; \
+\
+/* Set b, ldb */ \
+   Map<const MatrixLhs, 0, OuterStride<> > lhs(_lhs,rows,depth,OuterStride<>(lhsStride)); \
+   MatrixX##EIGPREFIX b_tmp; \
+\
+   if (ConjugateLhs) b_tmp = lhs.conjugate(); else b_tmp = lhs; \
+   b = b_tmp.data(); \
+   ldb = convert_index<BlasIndex>(b_tmp.outerStride()); \
+\
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (RhsStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   Map<const MatrixRhs, 0, OuterStride<> > rhs(_rhs,depth,cols, OuterStride<>(rhsStride)); \
+   MatrixRhs a_tmp; \
+\
+   if ((conjA!=0) || (SetDiag==0)) { \
+     if (conjA) a_tmp = rhs.conjugate(); else a_tmp = rhs; \
+     if (IsZeroDiag) \
+       a_tmp.diagonal().setZero(); \
+     else if (IsUnitDiag) \
+       a_tmp.diagonal().setOnes();\
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _rhs; \
+     lda = convert_index<BlasIndex>(rhsStride); \
+   } \
+   /*std::cout << "TRMM_R: A is square! Go to BLAS TRMM implementation! \n";*/ \
+/* call ?trmm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)b, &ldb); \
+\
+/* Add op(a_triangular)*b into res*/ \
+   Map<MatrixX##EIGPREFIX, 0, OuterStride<> > res_tmp(res,rows,cols,OuterStride<>(resStride)); \
+   res_tmp=res_tmp+b_tmp; \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMM_R(double, double, d, dtrmm)
+EIGEN_BLAS_TRMM_R(dcomplex, MKL_Complex16, cd, ztrmm)
+EIGEN_BLAS_TRMM_R(float, float, f, strmm)
+EIGEN_BLAS_TRMM_R(scomplex, MKL_Complex8, cf, ctrmm)
+#else
+EIGEN_BLAS_TRMM_R(double, double, d, dtrmm_)
+EIGEN_BLAS_TRMM_R(dcomplex, double, cd, ztrmm_)
+EIGEN_BLAS_TRMM_R(float, float, f, strmm_)
+EIGEN_BLAS_TRMM_R(scomplex, float, cf, ctrmm_)
+#endif
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixVector.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixVector.h
new file mode 100644
index 00000000..76bfa159
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -0,0 +1,350 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULARMATRIXVECTOR_H
+#define EIGEN_TRIANGULARMATRIXVECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder, int Version=Specialized>
+struct triangular_matrix_vector_product;
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>
+struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,ColMajor,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  enum {
+    IsLower = ((Mode&Lower)==Lower),
+    HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
+    HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
+  };
+  static EIGEN_DONT_INLINE  void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+                                     const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const RhsScalar& alpha);
+};
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>
+EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,ColMajor,Version>
+  ::run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+        const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const RhsScalar& alpha)
+  {
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+    Index size = (std::min)(_rows,_cols);
+    Index rows = IsLower ? _rows : (std::min)(_rows,_cols);
+    Index cols = IsLower ? (std::min)(_rows,_cols) : _cols;
+
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,ColMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,rows,cols,OuterStride<>(lhsStride));
+    typename conj_expr_if<ConjLhs,LhsMap>::type cjLhs(lhs);
+
+    typedef Map<const Matrix<RhsScalar,Dynamic,1>, 0, InnerStride<> > RhsMap;
+    const RhsMap rhs(_rhs,cols,InnerStride<>(rhsIncr));
+    typename conj_expr_if<ConjRhs,RhsMap>::type cjRhs(rhs);
+
+    typedef Map<Matrix<ResScalar,Dynamic,1> > ResMap;
+    ResMap res(_res,rows);
+
+    typedef const_blas_data_mapper<LhsScalar,Index,ColMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,RowMajor> RhsMapper;
+
+    for (Index pi=0; pi<size; pi+=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(PanelWidth, size-pi);
+      for (Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = pi + k;
+        Index s = IsLower ? ((HasUnitDiag||HasZeroDiag) ? i+1 : i ) : pi;
+        Index r = IsLower ? actualPanelWidth-k : k+1;
+        if ((!(HasUnitDiag||HasZeroDiag)) || (--r)>0)
+          res.segment(s,r) += (alpha * cjRhs.coeff(i)) * cjLhs.col(i).segment(s,r);
+        if (HasUnitDiag)
+          res.coeffRef(i) += alpha * cjRhs.coeff(i);
+      }
+      Index r = IsLower ? rows - pi - actualPanelWidth : pi;
+      if (r>0)
+      {
+        Index s = IsLower ? pi+actualPanelWidth : 0;
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs,BuiltIn>::run(
+            r, actualPanelWidth,
+            LhsMapper(&lhs.coeffRef(s,pi), lhsStride),
+            RhsMapper(&rhs.coeffRef(pi), rhsIncr),
+            &res.coeffRef(s), resIncr, alpha);
+      }
+    }
+    if((!IsLower) && cols>size)
+    {
+      general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs>::run(
+          rows, cols-size,
+          LhsMapper(&lhs.coeffRef(0,size), lhsStride),
+          RhsMapper(&rhs.coeffRef(size), rhsIncr),
+          _res, resIncr, alpha);
+    }
+  }
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs,int Version>
+struct triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,RowMajor,Version>
+{
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  enum {
+    IsLower = ((Mode&Lower)==Lower),
+    HasUnitDiag = (Mode & UnitDiag)==UnitDiag,
+    HasZeroDiag = (Mode & ZeroDiag)==ZeroDiag
+  };
+  static EIGEN_DONT_INLINE void run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+                                    const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const ResScalar& alpha);
+};
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs,int Version>
+EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,RowMajor,Version>
+  ::run(Index _rows, Index _cols, const LhsScalar* _lhs, Index lhsStride,
+        const RhsScalar* _rhs, Index rhsIncr, ResScalar* _res, Index resIncr, const ResScalar& alpha)
+  {
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+    Index diagSize = (std::min)(_rows,_cols);
+    Index rows = IsLower ? _rows : diagSize;
+    Index cols = IsLower ? diagSize : _cols;
+
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,rows,cols,OuterStride<>(lhsStride));
+    typename conj_expr_if<ConjLhs,LhsMap>::type cjLhs(lhs);
+
+    typedef Map<const Matrix<RhsScalar,Dynamic,1> > RhsMap;
+    const RhsMap rhs(_rhs,cols);
+    typename conj_expr_if<ConjRhs,RhsMap>::type cjRhs(rhs);
+
+    typedef Map<Matrix<ResScalar,Dynamic,1>, 0, InnerStride<> > ResMap;
+    ResMap res(_res,rows,InnerStride<>(resIncr));
+
+    typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,RowMajor> RhsMapper;
+
+    for (Index pi=0; pi<diagSize; pi+=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(PanelWidth, diagSize-pi);
+      for (Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = pi + k;
+        Index s = IsLower ? pi  : ((HasUnitDiag||HasZeroDiag) ? i+1 : i);
+        Index r = IsLower ? k+1 : actualPanelWidth-k;
+        if ((!(HasUnitDiag||HasZeroDiag)) || (--r)>0)
+          res.coeffRef(i) += alpha * (cjLhs.row(i).segment(s,r).cwiseProduct(cjRhs.segment(s,r).transpose())).sum();
+        if (HasUnitDiag)
+          res.coeffRef(i) += alpha * cjRhs.coeff(i);
+      }
+      Index r = IsLower ? pi : cols - pi - actualPanelWidth;
+      if (r>0)
+      {
+        Index s = IsLower ? 0 : pi + actualPanelWidth;
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs,BuiltIn>::run(
+            actualPanelWidth, r,
+            LhsMapper(&lhs.coeffRef(pi,s), lhsStride),
+            RhsMapper(&rhs.coeffRef(s), rhsIncr),
+            &res.coeffRef(pi), resIncr, alpha);
+      }
+    }
+    if(IsLower && rows>diagSize)
+    {
+      general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,ConjLhs,RhsScalar,RhsMapper,ConjRhs>::run(
+            rows-diagSize, cols,
+            LhsMapper(&lhs.coeffRef(diagSize,0), lhsStride),
+            RhsMapper(&rhs.coeffRef(0), rhsIncr),
+            &res.coeffRef(diagSize), resIncr, alpha);
+    }
+  }
+
+/***************************************************************************
+* Wrapper to product_triangular_vector
+***************************************************************************/
+
+template<int Mode,int StorageOrder>
+struct trmv_selector;
+
+} // end namespace internal
+
+namespace internal {
+
+template<int Mode, typename Lhs, typename Rhs>
+struct triangular_product_impl<Mode,true,Lhs,false,Rhs,true>
+{
+  template<typename Dest> static void run(Dest& dst, const Lhs &lhs, const Rhs &rhs, const typename Dest::Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==lhs.rows() && dst.cols()==rhs.cols());
+  
+    internal::trmv_selector<Mode,(int(internal::traits<Lhs>::Flags)&RowMajorBit) ? RowMajor : ColMajor>::run(lhs, rhs, dst, alpha);
+  }
+};
+
+template<int Mode, typename Lhs, typename Rhs>
+struct triangular_product_impl<Mode,false,Lhs,true,Rhs,false>
+{
+  template<typename Dest> static void run(Dest& dst, const Lhs &lhs, const Rhs &rhs, const typename Dest::Scalar& alpha)
+  {
+    eigen_assert(dst.rows()==lhs.rows() && dst.cols()==rhs.cols());
+
+    Transpose<Dest> dstT(dst);
+    internal::trmv_selector<(Mode & (UnitDiag|ZeroDiag)) | ((Mode & Lower) ? Upper : Lower),
+                            (int(internal::traits<Rhs>::Flags)&RowMajorBit) ? ColMajor : RowMajor>
+            ::run(rhs.transpose(),lhs.transpose(), dstT, alpha);
+  }
+};
+
+} // end namespace internal
+
+namespace internal {
+
+// TODO: find a way to factorize this piece of code with gemv_selector since the logic is exactly the same.
+  
+template<int Mode> struct trmv_selector<Mode,ColMajor>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar      LhsScalar;
+    typedef typename Rhs::Scalar      RhsScalar;
+    typedef typename Dest::Scalar     ResScalar;
+    typedef typename Dest::RealScalar RealScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    
+    typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest;
+
+    typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
+    typename internal::add_const_on_value_type<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
+
+    LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
+    RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
+    ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+
+    enum {
+      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
+      // on, the other hand it is good for the cache to pack the vector anyways...
+      EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime==1,
+      ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex),
+      MightCannotUseDest = (Dest::InnerStrideAtCompileTime!=1) || ComplexByReal
+    };
+
+    gemv_static_vector_if<ResScalar,Dest::SizeAtCompileTime,Dest::MaxSizeAtCompileTime,MightCannotUseDest> static_dest;
+
+    bool alphaIsCompatible = (!ComplexByReal) || (numext::imag(actualAlpha)==RealScalar(0));
+    bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
+
+    RhsScalar compatibleAlpha = get_factor<ResScalar,RhsScalar>::run(actualAlpha);
+
+    ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(),
+                                                  evalToDest ? dest.data() : static_dest.data());
+
+    if(!evalToDest)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = dest.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      if(!alphaIsCompatible)
+      {
+        MappedDest(actualDestPtr, dest.size()).setZero();
+        compatibleAlpha = RhsScalar(1);
+      }
+      else
+        MappedDest(actualDestPtr, dest.size()) = dest;
+    }
+
+    internal::triangular_matrix_vector_product
+      <Index,Mode,
+       LhsScalar, LhsBlasTraits::NeedToConjugate,
+       RhsScalar, RhsBlasTraits::NeedToConjugate,
+       ColMajor>
+      ::run(actualLhs.rows(),actualLhs.cols(),
+            actualLhs.data(),actualLhs.outerStride(),
+            actualRhs.data(),actualRhs.innerStride(),
+            actualDestPtr,1,compatibleAlpha);
+
+    if (!evalToDest)
+    {
+      if(!alphaIsCompatible)
+        dest += actualAlpha * MappedDest(actualDestPtr, dest.size());
+      else
+        dest = MappedDest(actualDestPtr, dest.size());
+    }
+
+    if ( ((Mode&UnitDiag)==UnitDiag) && (lhs_alpha!=LhsScalar(1)) )
+    {
+      Index diagSize = (std::min)(lhs.rows(),lhs.cols());
+      dest.head(diagSize) -= (lhs_alpha-LhsScalar(1))*rhs.head(diagSize);
+    }
+  }
+};
+
+template<int Mode> struct trmv_selector<Mode,RowMajor>
+{
+  template<typename Lhs, typename Rhs, typename Dest>
+  static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
+  {
+    typedef typename Lhs::Scalar      LhsScalar;
+    typedef typename Rhs::Scalar      RhsScalar;
+    typedef typename Dest::Scalar     ResScalar;
+    
+    typedef internal::blas_traits<Lhs> LhsBlasTraits;
+    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
+    typedef internal::blas_traits<Rhs> RhsBlasTraits;
+    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
+
+    typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
+    typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
+
+    LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
+    RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
+    ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+
+    enum {
+      DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1
+    };
+
+    gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;
+
+    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
+        DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
+
+    if(!DirectlyUseRhs)
+    {
+      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      Index size = actualRhs.size();
+      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+      #endif
+      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    }
+
+    internal::triangular_matrix_vector_product
+      <Index,Mode,
+       LhsScalar, LhsBlasTraits::NeedToConjugate,
+       RhsScalar, RhsBlasTraits::NeedToConjugate,
+       RowMajor>
+      ::run(actualLhs.rows(),actualLhs.cols(),
+            actualLhs.data(),actualLhs.outerStride(),
+            actualRhsPtr,1,
+            dest.data(),dest.innerStride(),
+            actualAlpha);
+
+    if ( ((Mode&UnitDiag)==UnitDiag) && (lhs_alpha!=LhsScalar(1)) )
+    {
+      Index diagSize = (std::min)(lhs.rows(),lhs.cols());
+      dest.head(diagSize) -= (lhs_alpha-LhsScalar(1))*rhs.head(diagSize);
+    }
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULARMATRIXVECTOR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
new file mode 100644
index 00000000..3d47a2b9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
@@ -0,0 +1,255 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Triangular matrix-vector product functionality based on ?TRMV.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
+#define EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************************************************
+* This file implements triangular matrix-vector multiplication using BLAS
+**********************************************************************/
+
+// trmv/hemv specialization
+
+template<typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int StorageOrder>
+struct triangular_matrix_vector_product_trmv :
+  triangular_matrix_vector_product<Index,Mode,LhsScalar,ConjLhs,RhsScalar,ConjRhs,StorageOrder,BuiltIn> {};
+
+#define EIGEN_BLAS_TRMV_SPECIALIZE(Scalar) \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,ColMajor,Specialized> { \
+ static void run(Index _rows, Index _cols, const Scalar* _lhs, Index lhsStride, \
+                                     const Scalar* _rhs, Index rhsIncr, Scalar* _res, Index resIncr, Scalar alpha) { \
+      triangular_matrix_vector_product_trmv<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,ColMajor>::run( \
+        _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+  } \
+}; \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,RowMajor,Specialized> { \
+ static void run(Index _rows, Index _cols, const Scalar* _lhs, Index lhsStride, \
+                                     const Scalar* _rhs, Index rhsIncr, Scalar* _res, Index resIncr, Scalar alpha) { \
+      triangular_matrix_vector_product_trmv<Index,Mode,Scalar,ConjLhs,Scalar,ConjRhs,RowMajor>::run( \
+        _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+  } \
+};
+
+EIGEN_BLAS_TRMV_SPECIALIZE(double)
+EIGEN_BLAS_TRMV_SPECIALIZE(float)
+EIGEN_BLAS_TRMV_SPECIALIZE(dcomplex)
+EIGEN_BLAS_TRMV_SPECIALIZE(scomplex)
+
+// implements col-major: res += alpha * op(triangular) * vector
+#define EIGEN_BLAS_TRMV_CM(EIGTYPE, BLASTYPE, EIGPREFIX, BLASPREFIX, BLASPOSTFIX) \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product_trmv<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,ColMajor> { \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper \
+  }; \
+ static void run(Index _rows, Index _cols, const EIGTYPE* _lhs, Index lhsStride, \
+                 const EIGTYPE* _rhs, Index rhsIncr, EIGTYPE* _res, Index resIncr, EIGTYPE alpha) \
+ { \
+   if (ConjLhs || IsZeroDiag) { \
+     triangular_matrix_vector_product<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,ColMajor,BuiltIn>::run( \
+       _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+     return; \
+   }\
+   Index size = (std::min)(_rows,_cols); \
+   Index rows = IsLower ? _rows : size; \
+   Index cols = IsLower ? size : _cols; \
+\
+   typedef VectorX##EIGPREFIX VectorRhs; \
+   EIGTYPE *x, *y;\
+\
+/* Set x*/ \
+   Map<const VectorRhs, 0, InnerStride<> > rhs(_rhs,cols,InnerStride<>(rhsIncr)); \
+   VectorRhs x_tmp; \
+   if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+   x = x_tmp.data(); \
+\
+/* Square part handling */\
+\
+   char trans, uplo, diag; \
+   BlasIndex m, n, lda, incx, incy; \
+   EIGTYPE const *a; \
+   EIGTYPE beta(1); \
+\
+/* Set m, n */ \
+   n = convert_index<BlasIndex>(size); \
+   lda = convert_index<BlasIndex>(lhsStride); \
+   incx = 1; \
+   incy = convert_index<BlasIndex>(resIncr); \
+\
+/* Set uplo, trans and diag*/ \
+   trans = 'N'; \
+   uplo = IsLower ? 'L' : 'U'; \
+   diag = IsUnitDiag ? 'U' : 'N'; \
+\
+/* call ?TRMV*/ \
+   BLASPREFIX##trmv##BLASPOSTFIX(&uplo, &trans, &diag, &n, (const BLASTYPE*)_lhs, &lda, (BLASTYPE*)x, &incx); \
+\
+/* Add op(a_tr)rhs into res*/ \
+   BLASPREFIX##axpy##BLASPOSTFIX(&n, (const BLASTYPE*)&numext::real_ref(alpha),(const BLASTYPE*)x, &incx, (BLASTYPE*)_res, &incy); \
+/* Non-square case - doesn't fit to BLAS ?TRMV. Fall to default triangular product*/ \
+   if (size<(std::max)(rows,cols)) { \
+     if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+     x = x_tmp.data(); \
+     if (size<rows) { \
+       y = _res + size*resIncr; \
+       a = _lhs + size; \
+       m = convert_index<BlasIndex>(rows-size); \
+       n = convert_index<BlasIndex>(size); \
+     } \
+     else { \
+       x += size; \
+       y = _res; \
+       a = _lhs + size*lda; \
+       m = convert_index<BlasIndex>(size); \
+       n = convert_index<BlasIndex>(cols-size); \
+     } \
+     BLASPREFIX##gemv##BLASPOSTFIX(&trans, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)x, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)y, &incy); \
+   } \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMV_CM(double,   double, d,  d,)
+EIGEN_BLAS_TRMV_CM(dcomplex, MKL_Complex16, cd, z,)
+EIGEN_BLAS_TRMV_CM(float,    float,  f,  s,)
+EIGEN_BLAS_TRMV_CM(scomplex, MKL_Complex8,  cf, c,)
+#else
+EIGEN_BLAS_TRMV_CM(double,   double, d,  d, _)
+EIGEN_BLAS_TRMV_CM(dcomplex, double, cd, z, _)
+EIGEN_BLAS_TRMV_CM(float,    float,  f,  s, _)
+EIGEN_BLAS_TRMV_CM(scomplex, float,  cf, c, _)
+#endif
+
+// implements row-major: res += alpha * op(triangular) * vector
+#define EIGEN_BLAS_TRMV_RM(EIGTYPE, BLASTYPE, EIGPREFIX, BLASPREFIX, BLASPOSTFIX) \
+template<typename Index, int Mode, bool ConjLhs, bool ConjRhs> \
+struct triangular_matrix_vector_product_trmv<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,RowMajor> { \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    LowUp = IsLower ? Lower : Upper \
+  }; \
+ static void run(Index _rows, Index _cols, const EIGTYPE* _lhs, Index lhsStride, \
+                 const EIGTYPE* _rhs, Index rhsIncr, EIGTYPE* _res, Index resIncr, EIGTYPE alpha) \
+ { \
+   if (IsZeroDiag) { \
+     triangular_matrix_vector_product<Index,Mode,EIGTYPE,ConjLhs,EIGTYPE,ConjRhs,RowMajor,BuiltIn>::run( \
+       _rows, _cols, _lhs, lhsStride, _rhs, rhsIncr, _res, resIncr, alpha); \
+     return; \
+   }\
+   Index size = (std::min)(_rows,_cols); \
+   Index rows = IsLower ? _rows : size; \
+   Index cols = IsLower ? size : _cols; \
+\
+   typedef VectorX##EIGPREFIX VectorRhs; \
+   EIGTYPE *x, *y;\
+\
+/* Set x*/ \
+   Map<const VectorRhs, 0, InnerStride<> > rhs(_rhs,cols,InnerStride<>(rhsIncr)); \
+   VectorRhs x_tmp; \
+   if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+   x = x_tmp.data(); \
+\
+/* Square part handling */\
+\
+   char trans, uplo, diag; \
+   BlasIndex m, n, lda, incx, incy; \
+   EIGTYPE const *a; \
+   EIGTYPE beta(1); \
+\
+/* Set m, n */ \
+   n = convert_index<BlasIndex>(size); \
+   lda = convert_index<BlasIndex>(lhsStride); \
+   incx = 1; \
+   incy = convert_index<BlasIndex>(resIncr); \
+\
+/* Set uplo, trans and diag*/ \
+   trans = ConjLhs ? 'C' : 'T'; \
+   uplo = IsLower ? 'U' : 'L'; \
+   diag = IsUnitDiag ? 'U' : 'N'; \
+\
+/* call ?TRMV*/ \
+   BLASPREFIX##trmv##BLASPOSTFIX(&uplo, &trans, &diag, &n, (const BLASTYPE*)_lhs, &lda, (BLASTYPE*)x, &incx); \
+\
+/* Add op(a_tr)rhs into res*/ \
+   BLASPREFIX##axpy##BLASPOSTFIX(&n, (const BLASTYPE*)&numext::real_ref(alpha),(const BLASTYPE*)x, &incx, (BLASTYPE*)_res, &incy); \
+/* Non-square case - doesn't fit to BLAS ?TRMV. Fall to default triangular product*/ \
+   if (size<(std::max)(rows,cols)) { \
+     if (ConjRhs) x_tmp = rhs.conjugate(); else x_tmp = rhs; \
+     x = x_tmp.data(); \
+     if (size<rows) { \
+       y = _res + size*resIncr; \
+       a = _lhs + size*lda; \
+       m = convert_index<BlasIndex>(rows-size); \
+       n = convert_index<BlasIndex>(size); \
+     } \
+     else { \
+       x += size; \
+       y = _res; \
+       a = _lhs + size; \
+       m = convert_index<BlasIndex>(size); \
+       n = convert_index<BlasIndex>(cols-size); \
+     } \
+     BLASPREFIX##gemv##BLASPOSTFIX(&trans, &n, &m, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)x, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)y, &incy); \
+   } \
+  } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRMV_RM(double,   double, d,  d,)
+EIGEN_BLAS_TRMV_RM(dcomplex, MKL_Complex16, cd, z,)
+EIGEN_BLAS_TRMV_RM(float,    float,  f,  s,)
+EIGEN_BLAS_TRMV_RM(scomplex, MKL_Complex8,  cf, c,)
+#else
+EIGEN_BLAS_TRMV_RM(double,   double, d,  d,_)
+EIGEN_BLAS_TRMV_RM(dcomplex, double, cd, z,_)
+EIGEN_BLAS_TRMV_RM(float,    float,  f,  s,_)
+EIGEN_BLAS_TRMV_RM(scomplex, float,  cf, c,_)
+#endif
+
+} // end namespase internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularSolverMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularSolverMatrix.h
new file mode 100644
index 00000000..6d879ba0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularSolverMatrix.h
@@ -0,0 +1,337 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULAR_SOLVER_MATRIX_H
+#define EIGEN_TRIANGULAR_SOLVER_MATRIX_H
+
+namespace Eigen { 
+
+namespace internal {
+
+// if the rhs is row major, let's transpose the product
+template <typename Scalar, typename Index, int Side, int Mode, bool Conjugate, int TriStorageOrder, int OtherInnerStride>
+struct triangular_solve_matrix<Scalar,Index,Side,Mode,Conjugate,TriStorageOrder,RowMajor,OtherInnerStride>
+{
+  static void run(
+    Index size, Index cols,
+    const Scalar*  tri, Index triStride,
+    Scalar* _other, Index otherIncr, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking)
+  {
+    triangular_solve_matrix<
+      Scalar, Index, Side==OnTheLeft?OnTheRight:OnTheLeft,
+      (Mode&UnitDiag) | ((Mode&Upper) ? Lower : Upper),
+      NumTraits<Scalar>::IsComplex && Conjugate,
+      TriStorageOrder==RowMajor ? ColMajor : RowMajor, ColMajor, OtherInnerStride>
+      ::run(size, cols, tri, triStride, _other, otherIncr, otherStride, blocking);
+  }
+};
+
+/* Optimized triangular solver with multiple right hand side and the triangular matrix on the left
+ */
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder,int OtherInnerStride>
+struct triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>
+{
+  static EIGEN_DONT_INLINE void run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherIncr, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking);
+};
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder, int OtherInnerStride>
+EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>::run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherIncr, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index cols = otherSize;
+
+    typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
+    typedef blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride> OtherMapper;
+    TriMapper tri(_tri, triStride);
+    OtherMapper other(_other, otherStride, otherIncr);
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+
+    enum {
+      SmallPanelWidth   = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+      IsLower = (Mode&Lower) == Lower
+    };
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(size,blocking.mc());  // cache block size along the M direction
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*cols;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    conj_if<Conjugate> conj;
+    gebp_kernel<Scalar, Scalar, Index, OtherMapper, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel;
+    gemm_pack_lhs<Scalar, Index, TriMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, TriStorageOrder> pack_lhs;
+    gemm_pack_rhs<Scalar, Index, OtherMapper, Traits::nr, ColMajor, false, true> pack_rhs;
+
+    // the goal here is to subdivise the Rhs panels such that we keep some cache
+    // coherence when accessing the rhs elements
+    std::ptrdiff_t l1, l2, l3;
+    manage_caching_sizes(GetAction, &l1, &l2, &l3);
+    Index subcols = cols>0 ? l2/(4 * sizeof(Scalar) * std::max<Index>(otherStride,size)) : 0;
+    subcols = std::max<Index>((subcols/Traits::nr)*Traits::nr, Traits::nr);
+
+    for(Index k2=IsLower ? 0 : size;
+        IsLower ? k2<size : k2>0;
+        IsLower ? k2+=kc : k2-=kc)
+    {
+      const Index actual_kc = (std::min)(IsLower ? size-k2 : k2, kc);
+
+      // We have selected and packed a big horizontal panel R1 of rhs. Let B be the packed copy of this panel,
+      // and R2 the remaining part of rhs. The corresponding vertical panel of lhs is split into
+      // A11 (the triangular part) and A21 the remaining rectangular part.
+      // Then the high level algorithm is:
+      //  - B = R1                    => general block copy (done during the next step)
+      //  - R1 = A11^-1 B             => tricky part
+      //  - update B from the new R1  => actually this has to be performed continuously during the above step
+      //  - R2 -= A21 * B             => GEPP
+
+      // The tricky part: compute R1 = A11^-1 B while updating B from R1
+      // The idea is to split A11 into multiple small vertical panels.
+      // Each panel can be split into a small triangular part T1k which is processed without optimization,
+      // and the remaining small part T2k which is processed using gebp with appropriate block strides
+      for(Index j2=0; j2<cols; j2+=subcols)
+      {
+        Index actual_cols = (std::min)(cols-j2,subcols);
+        // for each small vertical panels [T1k^T, T2k^T]^T of lhs
+        for (Index k1=0; k1<actual_kc; k1+=SmallPanelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-k1, SmallPanelWidth);
+          // tr solve
+          for (Index k=0; k<actualPanelWidth; ++k)
+          {
+            // TODO write a small kernel handling this (can be shared with trsv)
+            Index i  = IsLower ? k2+k1+k : k2-k1-k-1;
+            Index rs = actualPanelWidth - k - 1; // remaining size
+            Index s  = TriStorageOrder==RowMajor ? (IsLower ? k2+k1 : i+1)
+                                                 :  IsLower ? i+1 : i-rs;
+
+            Scalar a = (Mode & UnitDiag) ? Scalar(1) : Scalar(1)/conj(tri(i,i));
+            for (Index j=j2; j<j2+actual_cols; ++j)
+            {
+              if (TriStorageOrder==RowMajor)
+              {
+                Scalar b(0);
+                const Scalar* l = &tri(i,s);
+                typename OtherMapper::LinearMapper r = other.getLinearMapper(s,j);
+                for (Index i3=0; i3<k; ++i3)
+                  b += conj(l[i3]) * r(i3);
+
+                other(i,j) = (other(i,j) - b)*a;
+              }
+              else
+              {
+                Scalar& otherij = other(i,j);
+                otherij *= a;
+                Scalar b = otherij;
+                typename OtherMapper::LinearMapper r = other.getLinearMapper(s,j);
+                typename TriMapper::LinearMapper l = tri.getLinearMapper(s,i);
+                for (Index i3=0;i3<rs;++i3)
+                  r(i3) -= b * conj(l(i3));
+              }
+            }
+          }
+
+          Index lengthTarget = actual_kc-k1-actualPanelWidth;
+          Index startBlock   = IsLower ? k2+k1 : k2-k1-actualPanelWidth;
+          Index blockBOffset = IsLower ? k1 : lengthTarget;
+
+          // update the respective rows of B from other
+          pack_rhs(blockB+actual_kc*j2, other.getSubMapper(startBlock,j2), actualPanelWidth, actual_cols, actual_kc, blockBOffset);
+
+          // GEBP
+          if (lengthTarget>0)
+          {
+            Index startTarget  = IsLower ? k2+k1+actualPanelWidth : k2-actual_kc;
+
+            pack_lhs(blockA, tri.getSubMapper(startTarget,startBlock), actualPanelWidth, lengthTarget);
+
+            gebp_kernel(other.getSubMapper(startTarget,j2), blockA, blockB+actual_kc*j2, lengthTarget, actualPanelWidth, actual_cols, Scalar(-1),
+                        actualPanelWidth, actual_kc, 0, blockBOffset);
+          }
+        }
+      }
+      
+      // R2 -= A21 * B => GEPP
+      {
+        Index start = IsLower ? k2+kc : 0;
+        Index end   = IsLower ? size : k2-kc;
+        for(Index i2=start; i2<end; i2+=mc)
+        {
+          const Index actual_mc = (std::min)(mc,end-i2);
+          if (actual_mc>0)
+          {
+            pack_lhs(blockA, tri.getSubMapper(i2, IsLower ? k2 : k2-kc), actual_kc, actual_mc);
+
+            gebp_kernel(other.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0, 0);
+          }
+        }
+      }
+    }
+  }
+
+/* Optimized triangular solver with multiple left hand sides and the triangular matrix on the right
+ */
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder, int OtherInnerStride>
+struct triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>
+{
+  static EIGEN_DONT_INLINE void run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherIncr, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking);
+};
+template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder, int OtherInnerStride>
+EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>::run(
+    Index size, Index otherSize,
+    const Scalar* _tri, Index triStride,
+    Scalar* _other, Index otherIncr, Index otherStride,
+    level3_blocking<Scalar,Scalar>& blocking)
+  {
+    Index rows = otherSize;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    typedef blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride> LhsMapper;
+    typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> RhsMapper;
+    LhsMapper lhs(_other, otherStride, otherIncr);
+    RhsMapper rhs(_tri, triStride);
+
+    typedef gebp_traits<Scalar,Scalar> Traits;
+    enum {
+      RhsStorageOrder   = TriStorageOrder,
+      SmallPanelWidth   = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
+      IsLower = (Mode&Lower) == Lower
+    };
+
+    Index kc = blocking.kc();                   // cache block size along the K direction
+    Index mc = (std::min)(rows,blocking.mc());  // cache block size along the M direction
+
+    std::size_t sizeA = kc*mc;
+    std::size_t sizeB = kc*size;
+
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
+    ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
+
+    conj_if<Conjugate> conj;
+    gebp_kernel<Scalar, Scalar, Index, LhsMapper, Traits::mr, Traits::nr, false, Conjugate> gebp_kernel;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
+    gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr, RhsStorageOrder,false,true> pack_rhs_panel;
+    gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, ColMajor, false, true> pack_lhs_panel;
+
+    for(Index k2=IsLower ? size : 0;
+        IsLower ? k2>0 : k2<size;
+        IsLower ? k2-=kc : k2+=kc)
+    {
+      const Index actual_kc = (std::min)(IsLower ? k2 : size-k2, kc);
+      Index actual_k2 = IsLower ? k2-actual_kc : k2 ;
+
+      Index startPanel = IsLower ? 0 : k2+actual_kc;
+      Index rs = IsLower ? actual_k2 : size - actual_k2 - actual_kc;
+      Scalar* geb = blockB+actual_kc*actual_kc;
+
+      if (rs>0) pack_rhs(geb, rhs.getSubMapper(actual_k2,startPanel), actual_kc, rs);
+
+      // triangular packing (we only pack the panels off the diagonal,
+      // neglecting the blocks overlapping the diagonal
+      {
+        for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
+        {
+          Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+          Index actual_j2 = actual_k2 + j2;
+          Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
+          Index panelLength = IsLower ? actual_kc-j2-actualPanelWidth : j2;
+
+          if (panelLength>0)
+          pack_rhs_panel(blockB+j2*actual_kc,
+                         rhs.getSubMapper(actual_k2+panelOffset, actual_j2),
+                         panelLength, actualPanelWidth,
+                         actual_kc, panelOffset);
+        }
+      }
+
+      for(Index i2=0; i2<rows; i2+=mc)
+      {
+        const Index actual_mc = (std::min)(mc,rows-i2);
+
+        // triangular solver kernel
+        {
+          // for each small block of the diagonal (=> vertical panels of rhs)
+          for (Index j2 = IsLower
+                      ? (actual_kc - ((actual_kc%SmallPanelWidth) ? Index(actual_kc%SmallPanelWidth)
+                                                                  : Index(SmallPanelWidth)))
+                      : 0;
+               IsLower ? j2>=0 : j2<actual_kc;
+               IsLower ? j2-=SmallPanelWidth : j2+=SmallPanelWidth)
+          {
+            Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
+            Index absolute_j2 = actual_k2 + j2;
+            Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
+            Index panelLength = IsLower ? actual_kc - j2 - actualPanelWidth : j2;
+
+            // GEBP
+            if(panelLength>0)
+            {
+              gebp_kernel(lhs.getSubMapper(i2,absolute_j2),
+                          blockA, blockB+j2*actual_kc,
+                          actual_mc, panelLength, actualPanelWidth,
+                          Scalar(-1),
+                          actual_kc, actual_kc, // strides
+                          panelOffset, panelOffset); // offsets
+            }
+
+            // unblocked triangular solve
+            for (Index k=0; k<actualPanelWidth; ++k)
+            {
+              Index j = IsLower ? absolute_j2+actualPanelWidth-k-1 : absolute_j2+k;
+
+              typename LhsMapper::LinearMapper r = lhs.getLinearMapper(i2,j);
+              for (Index k3=0; k3<k; ++k3)
+              {
+                Scalar b = conj(rhs(IsLower ? j+1+k3 : absolute_j2+k3,j));
+                typename LhsMapper::LinearMapper a = lhs.getLinearMapper(i2,IsLower ? j+1+k3 : absolute_j2+k3);
+                for (Index i=0; i<actual_mc; ++i)
+                  r(i) -= a(i) * b;
+              }
+              if((Mode & UnitDiag)==0)
+              {
+                Scalar inv_rjj = RealScalar(1)/conj(rhs(j,j));
+                for (Index i=0; i<actual_mc; ++i)
+                  r(i) *= inv_rjj;
+              }
+            }
+
+            // pack the just computed part of lhs to A
+            pack_lhs_panel(blockA, lhs.getSubMapper(i2,absolute_j2),
+                           actualPanelWidth, actual_mc,
+                           actual_kc, j2);
+          }
+        }
+
+        if (rs>0)
+          gebp_kernel(lhs.getSubMapper(i2, startPanel), blockA, geb,
+                      actual_mc, actual_kc, rs, Scalar(-1),
+                      -1, -1, 0, 0);
+      }
+    }
+  }
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_SOLVER_MATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
new file mode 100644
index 00000000..621194ce
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
@@ -0,0 +1,167 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to BLAS F77
+ *   Triangular matrix * matrix product functionality based on ?TRMM.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
+#define EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
+
+namespace Eigen {
+
+namespace internal {
+
+// implements LeftSide op(triangular)^-1 * general
+#define EIGEN_BLAS_TRSM_L(EIGTYPE, BLASTYPE, BLASFUNC) \
+template <typename Index, int Mode, bool Conjugate, int TriStorageOrder> \
+struct triangular_solve_matrix<EIGTYPE,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor,1> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    conjA = ((TriStorageOrder==ColMajor) && Conjugate) ? 1 : 0 \
+  }; \
+  static void run( \
+      Index size, Index otherSize, \
+      const EIGTYPE* _tri, Index triStride, \
+      EIGTYPE* _other, Index otherIncr, Index otherStride, level3_blocking<EIGTYPE,EIGTYPE>& /*blocking*/) \
+  { \
+   EIGEN_ONLY_USED_FOR_DEBUG(otherIncr); \
+   eigen_assert(otherIncr == 1); \
+   BlasIndex m = convert_index<BlasIndex>(size), n = convert_index<BlasIndex>(otherSize), lda, ldb; \
+   char side = 'L', uplo, diag='N', transa; \
+   /* Set alpha_ */ \
+   EIGTYPE alpha(1); \
+   ldb = convert_index<BlasIndex>(otherStride);\
+\
+   const EIGTYPE *a; \
+/* Set trans */ \
+   transa = (TriStorageOrder==RowMajor) ? ((Conjugate) ? 'C' : 'T') : 'N'; \
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (TriStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, TriStorageOrder> MatrixTri; \
+   Map<const MatrixTri, 0, OuterStride<> > tri(_tri,size,size,OuterStride<>(triStride)); \
+   MatrixTri a_tmp; \
+\
+   if (conjA) { \
+     a_tmp = tri.conjugate(); \
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _tri; \
+     lda = convert_index<BlasIndex>(triStride); \
+   } \
+   if (IsUnitDiag) diag='U'; \
+/* call ?trsm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)_other, &ldb); \
+ } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRSM_L(double,   double, dtrsm)
+EIGEN_BLAS_TRSM_L(dcomplex, MKL_Complex16, ztrsm)
+EIGEN_BLAS_TRSM_L(float,    float,  strsm)
+EIGEN_BLAS_TRSM_L(scomplex, MKL_Complex8, ctrsm)
+#else
+EIGEN_BLAS_TRSM_L(double,   double, dtrsm_)
+EIGEN_BLAS_TRSM_L(dcomplex, double, ztrsm_)
+EIGEN_BLAS_TRSM_L(float,    float,  strsm_)
+EIGEN_BLAS_TRSM_L(scomplex, float,  ctrsm_)
+#endif
+
+// implements RightSide general * op(triangular)^-1
+#define EIGEN_BLAS_TRSM_R(EIGTYPE, BLASTYPE, BLASFUNC) \
+template <typename Index, int Mode, bool Conjugate, int TriStorageOrder> \
+struct triangular_solve_matrix<EIGTYPE,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor,1> \
+{ \
+  enum { \
+    IsLower = (Mode&Lower) == Lower, \
+    IsUnitDiag  = (Mode&UnitDiag) ? 1 : 0, \
+    IsZeroDiag  = (Mode&ZeroDiag) ? 1 : 0, \
+    conjA = ((TriStorageOrder==ColMajor) && Conjugate) ? 1 : 0 \
+  }; \
+  static void run( \
+      Index size, Index otherSize, \
+      const EIGTYPE* _tri, Index triStride, \
+      EIGTYPE* _other, Index otherIncr, Index otherStride, level3_blocking<EIGTYPE,EIGTYPE>& /*blocking*/) \
+  { \
+   EIGEN_ONLY_USED_FOR_DEBUG(otherIncr); \
+   eigen_assert(otherIncr == 1); \
+   BlasIndex m = convert_index<BlasIndex>(otherSize), n = convert_index<BlasIndex>(size), lda, ldb; \
+   char side = 'R', uplo, diag='N', transa; \
+   /* Set alpha_ */ \
+   EIGTYPE alpha(1); \
+   ldb = convert_index<BlasIndex>(otherStride);\
+\
+   const EIGTYPE *a; \
+/* Set trans */ \
+   transa = (TriStorageOrder==RowMajor) ? ((Conjugate) ? 'C' : 'T') : 'N'; \
+/* Set uplo */ \
+   uplo = IsLower ? 'L' : 'U'; \
+   if (TriStorageOrder==RowMajor) uplo = (uplo == 'L') ? 'U' : 'L'; \
+/* Set a, lda */ \
+   typedef Matrix<EIGTYPE, Dynamic, Dynamic, TriStorageOrder> MatrixTri; \
+   Map<const MatrixTri, 0, OuterStride<> > tri(_tri,size,size,OuterStride<>(triStride)); \
+   MatrixTri a_tmp; \
+\
+   if (conjA) { \
+     a_tmp = tri.conjugate(); \
+     a = a_tmp.data(); \
+     lda = convert_index<BlasIndex>(a_tmp.outerStride()); \
+   } else { \
+     a = _tri; \
+     lda = convert_index<BlasIndex>(triStride); \
+   } \
+   if (IsUnitDiag) diag='U'; \
+/* call ?trsm*/ \
+   BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (BLASTYPE*)_other, &ldb); \
+   /*std::cout << "TRMS_L specialization!\n";*/ \
+ } \
+};
+
+#ifdef EIGEN_USE_MKL
+EIGEN_BLAS_TRSM_R(double,   double, dtrsm)
+EIGEN_BLAS_TRSM_R(dcomplex, MKL_Complex16, ztrsm)
+EIGEN_BLAS_TRSM_R(float,    float,  strsm)
+EIGEN_BLAS_TRSM_R(scomplex, MKL_Complex8,  ctrsm)
+#else
+EIGEN_BLAS_TRSM_R(double,   double, dtrsm_)
+EIGEN_BLAS_TRSM_R(dcomplex, double, ztrsm_)
+EIGEN_BLAS_TRSM_R(float,    float,  strsm_)
+EIGEN_BLAS_TRSM_R(scomplex, float,  ctrsm_)
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularSolverVector.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularSolverVector.h
new file mode 100644
index 00000000..64731701
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/products/TriangularSolverVector.h
@@ -0,0 +1,148 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIANGULAR_SOLVER_VECTOR_H
+#define EIGEN_TRIANGULAR_SOLVER_VECTOR_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename LhsScalar, typename RhsScalar, typename Index, int Mode, bool Conjugate, int StorageOrder>
+struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheRight, Mode, Conjugate, StorageOrder>
+{
+  static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs)
+  {
+    triangular_solve_vector<LhsScalar,RhsScalar,Index,OnTheLeft,
+        ((Mode&Upper)==Upper ? Lower : Upper) | (Mode&UnitDiag),
+        Conjugate,StorageOrder==RowMajor?ColMajor:RowMajor
+      >::run(size, _lhs, lhsStride, rhs);
+  }
+};
+
+// forward and backward substitution, row-major, rhs is a vector
+template<typename LhsScalar, typename RhsScalar, typename Index, int Mode, bool Conjugate>
+struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, RowMajor>
+{
+  enum {
+    IsLower = ((Mode&Lower)==Lower)
+  };
+  static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs)
+  {
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,size,size,OuterStride<>(lhsStride));
+
+    typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
+
+    typename internal::conditional<
+                          Conjugate,
+                          const CwiseUnaryOp<typename internal::scalar_conjugate_op<LhsScalar>,LhsMap>,
+                          const LhsMap&>
+                        ::type cjLhs(lhs);
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+    for(Index pi=IsLower ? 0 : size;
+        IsLower ? pi<size : pi>0;
+        IsLower ? pi+=PanelWidth : pi-=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(IsLower ? size - pi : pi, PanelWidth);
+
+      Index r = IsLower ? pi : size - pi; // remaining size
+      if (r > 0)
+      {
+        // let's directly call the low level product function because:
+        // 1 - it is faster to compile
+        // 2 - it is slightly faster at runtime
+        Index startRow = IsLower ? pi : pi-actualPanelWidth;
+        Index startCol = IsLower ? 0 : pi;
+
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,RowMajor,Conjugate,RhsScalar,RhsMapper,false>::run(
+          actualPanelWidth, r,
+          LhsMapper(&lhs.coeffRef(startRow,startCol), lhsStride),
+          RhsMapper(rhs + startCol, 1),
+          rhs + startRow, 1,
+          RhsScalar(-1));
+      }
+
+      for(Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = IsLower ? pi+k : pi-k-1;
+        Index s = IsLower ? pi   : i+1;
+        if (k>0)
+          rhs[i] -= (cjLhs.row(i).segment(s,k).transpose().cwiseProduct(Map<const Matrix<RhsScalar,Dynamic,1> >(rhs+s,k))).sum();
+
+        if((!(Mode & UnitDiag)) && numext::not_equal_strict(rhs[i],RhsScalar(0)))
+          rhs[i] /= cjLhs(i,i);
+      }
+    }
+  }
+};
+
+// forward and backward substitution, column-major, rhs is a vector
+template<typename LhsScalar, typename RhsScalar, typename Index, int Mode, bool Conjugate>
+struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, ColMajor>
+{
+  enum {
+    IsLower = ((Mode&Lower)==Lower)
+  };
+  static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs)
+  {
+    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,ColMajor>, 0, OuterStride<> > LhsMap;
+    const LhsMap lhs(_lhs,size,size,OuterStride<>(lhsStride));
+    typedef const_blas_data_mapper<LhsScalar,Index,ColMajor> LhsMapper;
+    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
+    typename internal::conditional<Conjugate,
+                                   const CwiseUnaryOp<typename internal::scalar_conjugate_op<LhsScalar>,LhsMap>,
+                                   const LhsMap&
+                                  >::type cjLhs(lhs);
+    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
+
+    for(Index pi=IsLower ? 0 : size;
+        IsLower ? pi<size : pi>0;
+        IsLower ? pi+=PanelWidth : pi-=PanelWidth)
+    {
+      Index actualPanelWidth = (std::min)(IsLower ? size - pi : pi, PanelWidth);
+      Index startBlock = IsLower ? pi : pi-actualPanelWidth;
+      Index endBlock = IsLower ? pi + actualPanelWidth : 0;
+
+      for(Index k=0; k<actualPanelWidth; ++k)
+      {
+        Index i = IsLower ? pi+k : pi-k-1;
+        if(numext::not_equal_strict(rhs[i],RhsScalar(0)))
+        {
+          if(!(Mode & UnitDiag))
+            rhs[i] /= cjLhs.coeff(i,i);
+
+          Index r = actualPanelWidth - k - 1; // remaining size
+          Index s = IsLower ? i+1 : i-r;
+          if (r>0)
+            Map<Matrix<RhsScalar,Dynamic,1> >(rhs+s,r) -= rhs[i] * cjLhs.col(i).segment(s,r);
+        }
+      }
+      Index r = IsLower ? size - endBlock : startBlock; // remaining size
+      if (r > 0)
+      {
+        // let's directly call the low level product function because:
+        // 1 - it is faster to compile
+        // 2 - it is slightly faster at runtime
+        general_matrix_vector_product<Index,LhsScalar,LhsMapper,ColMajor,Conjugate,RhsScalar,RhsMapper,false>::run(
+            r, actualPanelWidth,
+            LhsMapper(&lhs.coeffRef(endBlock,startBlock), lhsStride),
+            RhsMapper(rhs+startBlock, 1),
+            rhs+endBlock, 1, RhsScalar(-1));
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIANGULAR_SOLVER_VECTOR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/BlasUtil.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/BlasUtil.h
new file mode 100644
index 00000000..e16a5649
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/BlasUtil.h
@@ -0,0 +1,583 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BLASUTIL_H
+#define EIGEN_BLASUTIL_H
+
+// This file contains many lightweight helper classes used to
+// implement and control fast level 2 and level 3 BLAS-like routines.
+
+namespace Eigen {
+
+namespace internal {
+
+// forward declarations
+template<typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs=false, bool ConjugateRhs=false>
+struct gebp_kernel;
+
+template<typename Scalar, typename Index, typename DataMapper, int nr, int StorageOrder, bool Conjugate = false, bool PanelMode=false>
+struct gemm_pack_rhs;
+
+template<typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, int StorageOrder, bool Conjugate = false, bool PanelMode = false>
+struct gemm_pack_lhs;
+
+template<
+  typename Index,
+  typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs,
+  typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs,
+  int ResStorageOrder, int ResInnerStride>
+struct general_matrix_matrix_product;
+
+template<typename Index,
+         typename LhsScalar, typename LhsMapper, int LhsStorageOrder, bool ConjugateLhs,
+         typename RhsScalar, typename RhsMapper, bool ConjugateRhs, int Version=Specialized>
+struct general_matrix_vector_product;
+
+template<typename From,typename To> struct get_factor {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE To run(const From& x) { return To(x); }
+};
+
+template<typename Scalar> struct get_factor<Scalar,typename NumTraits<Scalar>::Real> {
+  EIGEN_DEVICE_FUNC
+  static EIGEN_STRONG_INLINE typename NumTraits<Scalar>::Real run(const Scalar& x) { return numext::real(x); }
+};
+
+
+template<typename Scalar, typename Index>
+class BlasVectorMapper {
+  public:
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE BlasVectorMapper(Scalar *data) : m_data(data) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar operator()(Index i) const {
+    return m_data[i];
+  }
+  template <typename Packet, int AlignmentType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet load(Index i) const {
+    return ploadt<Packet, AlignmentType>(m_data + i);
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC bool aligned(Index i) const {
+    return (UIntPtr(m_data+i)%sizeof(Packet))==0;
+  }
+
+  protected:
+  Scalar* m_data;
+};
+
+template<typename Scalar, typename Index, int AlignmentType, int Incr=1>
+class BlasLinearMapper;
+
+template<typename Scalar, typename Index, int AlignmentType>
+class BlasLinearMapper<Scalar,Index,AlignmentType>
+{
+public:
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE BlasLinearMapper(Scalar *data, Index incr=1)
+    : m_data(data)
+  {
+    EIGEN_ONLY_USED_FOR_DEBUG(incr);
+    eigen_assert(incr==1);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void prefetch(int i) const {
+    internal::prefetch(&operator()(i));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar& operator()(Index i) const {
+    return m_data[i];
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketType loadPacket(Index i) const {
+    return ploadt<PacketType, AlignmentType>(m_data + i);
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacket(Index i, const PacketType &p) const {
+    pstoret<Scalar, PacketType, AlignmentType>(m_data + i, p);
+  }
+
+protected:
+  Scalar *m_data;
+};
+
+// Lightweight helper class to access matrix coefficients.
+template<typename Scalar, typename Index, int StorageOrder, int AlignmentType = Unaligned, int Incr = 1>
+class blas_data_mapper;
+
+// TMP to help PacketBlock store implementation.
+// There's currently no known use case for PacketBlock load.
+// The default implementation assumes ColMajor order.
+// It always store each packet sequentially one `stride` apart.
+template<typename Index, typename Scalar, typename Packet, int n, int idx, int StorageOrder>
+struct PacketBlockManagement
+{
+  PacketBlockManagement<Index, Scalar, Packet, n, idx - 1, StorageOrder> pbm;
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(Scalar *to, const Index stride, Index i, Index j, const PacketBlock<Packet, n> &block) const {
+    pbm.store(to, stride, i, j, block);
+    pstoreu<Scalar>(to + i + (j + idx)*stride, block.packet[idx]);
+  }
+};
+
+// PacketBlockManagement specialization to take care of RowMajor order without ifs.
+template<typename Index, typename Scalar, typename Packet, int n, int idx>
+struct PacketBlockManagement<Index, Scalar, Packet, n, idx, RowMajor>
+{
+  PacketBlockManagement<Index, Scalar, Packet, n, idx - 1, RowMajor> pbm;
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(Scalar *to, const Index stride, Index i, Index j, const PacketBlock<Packet, n> &block) const {
+    pbm.store(to, stride, i, j, block);
+    pstoreu<Scalar>(to + j + (i + idx)*stride, block.packet[idx]);
+  }
+};
+
+template<typename Index, typename Scalar, typename Packet, int n, int StorageOrder>
+struct PacketBlockManagement<Index, Scalar, Packet, n, -1, StorageOrder>
+{
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(Scalar *to, const Index stride, Index i, Index j, const PacketBlock<Packet, n> &block) const {
+    EIGEN_UNUSED_VARIABLE(to);
+    EIGEN_UNUSED_VARIABLE(stride);
+    EIGEN_UNUSED_VARIABLE(i);
+    EIGEN_UNUSED_VARIABLE(j);
+    EIGEN_UNUSED_VARIABLE(block);
+  }
+};
+
+template<typename Index, typename Scalar, typename Packet, int n>
+struct PacketBlockManagement<Index, Scalar, Packet, n, -1, RowMajor>
+{
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(Scalar *to, const Index stride, Index i, Index j, const PacketBlock<Packet, n> &block) const {
+    EIGEN_UNUSED_VARIABLE(to);
+    EIGEN_UNUSED_VARIABLE(stride);
+    EIGEN_UNUSED_VARIABLE(i);
+    EIGEN_UNUSED_VARIABLE(j);
+    EIGEN_UNUSED_VARIABLE(block);
+  }
+};
+
+template<typename Scalar, typename Index, int StorageOrder, int AlignmentType>
+class blas_data_mapper<Scalar,Index,StorageOrder,AlignmentType,1>
+{
+public:
+  typedef BlasLinearMapper<Scalar, Index, AlignmentType> LinearMapper;
+  typedef BlasVectorMapper<Scalar, Index> VectorMapper;
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE blas_data_mapper(Scalar* data, Index stride, Index incr=1)
+   : m_data(data), m_stride(stride)
+  {
+    EIGEN_ONLY_USED_FOR_DEBUG(incr);
+    eigen_assert(incr==1);
+  }
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType>
+  getSubMapper(Index i, Index j) const {
+    return blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType>(&operator()(i, j), m_stride);
+  }
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE LinearMapper getLinearMapper(Index i, Index j) const {
+    return LinearMapper(&operator()(i, j));
+  }
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE VectorMapper getVectorMapper(Index i, Index j) const {
+    return VectorMapper(&operator()(i, j));
+  }
+
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Scalar& operator()(Index i, Index j) const {
+    return m_data[StorageOrder==RowMajor ? j + i*m_stride : i + j*m_stride];
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketType loadPacket(Index i, Index j) const {
+    return ploadt<PacketType, AlignmentType>(&operator()(i, j));
+  }
+
+  template <typename PacketT, int AlignmentT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT load(Index i, Index j) const {
+    return ploadt<PacketT, AlignmentT>(&operator()(i, j));
+  }
+
+  template<typename SubPacket>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void scatterPacket(Index i, Index j, const SubPacket &p) const {
+    pscatter<Scalar, SubPacket>(&operator()(i, j), p, m_stride);
+  }
+
+  template<typename SubPacket>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE SubPacket gatherPacket(Index i, Index j) const {
+    return pgather<Scalar, SubPacket>(&operator()(i, j), m_stride);
+  }
+
+  EIGEN_DEVICE_FUNC const Index stride() const { return m_stride; }
+  EIGEN_DEVICE_FUNC const Scalar* data() const { return m_data; }
+
+  EIGEN_DEVICE_FUNC Index firstAligned(Index size) const {
+    if (UIntPtr(m_data)%sizeof(Scalar)) {
+      return -1;
+    }
+    return internal::first_default_aligned(m_data, size);
+  }
+
+  template<typename SubPacket, int n>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacketBlock(Index i, Index j, const PacketBlock<SubPacket, n> &block) const {
+    PacketBlockManagement<Index, Scalar, SubPacket, n, n-1, StorageOrder> pbm;
+    pbm.store(m_data, m_stride, i, j, block);
+  }
+protected:
+  Scalar* EIGEN_RESTRICT m_data;
+  const Index m_stride;
+};
+
+// Implementation of non-natural increment (i.e. inner-stride != 1)
+// The exposed API is not complete yet compared to the Incr==1 case
+// because some features makes less sense in this case.
+template<typename Scalar, typename Index, int AlignmentType, int Incr>
+class BlasLinearMapper
+{
+public:
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE BlasLinearMapper(Scalar *data,Index incr) : m_data(data), m_incr(incr) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void prefetch(int i) const {
+    internal::prefetch(&operator()(i));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar& operator()(Index i) const {
+    return m_data[i*m_incr.value()];
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketType loadPacket(Index i) const {
+    return pgather<Scalar,PacketType>(m_data + i*m_incr.value(), m_incr.value());
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacket(Index i, const PacketType &p) const {
+    pscatter<Scalar, PacketType>(m_data + i*m_incr.value(), p, m_incr.value());
+  }
+
+protected:
+  Scalar *m_data;
+  const internal::variable_if_dynamic<Index,Incr> m_incr;
+};
+
+template<typename Scalar, typename Index, int StorageOrder, int AlignmentType,int Incr>
+class blas_data_mapper
+{
+public:
+  typedef BlasLinearMapper<Scalar, Index, AlignmentType,Incr> LinearMapper;
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE blas_data_mapper(Scalar* data, Index stride, Index incr) : m_data(data), m_stride(stride), m_incr(incr) {}
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE blas_data_mapper
+  getSubMapper(Index i, Index j) const {
+    return blas_data_mapper(&operator()(i, j), m_stride, m_incr.value());
+  }
+
+  EIGEN_DEVICE_FUNC  EIGEN_ALWAYS_INLINE LinearMapper getLinearMapper(Index i, Index j) const {
+    return LinearMapper(&operator()(i, j), m_incr.value());
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Scalar& operator()(Index i, Index j) const {
+    return m_data[StorageOrder==RowMajor ? j*m_incr.value() + i*m_stride : i*m_incr.value() + j*m_stride];
+  }
+
+  template<typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketType loadPacket(Index i, Index j) const {
+    return pgather<Scalar,PacketType>(&operator()(i, j),m_incr.value());
+  }
+
+  template <typename PacketT, int AlignmentT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT load(Index i, Index j) const {
+    return pgather<Scalar,PacketT>(&operator()(i, j),m_incr.value());
+  }
+
+  template<typename SubPacket>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void scatterPacket(Index i, Index j, const SubPacket &p) const {
+    pscatter<Scalar, SubPacket>(&operator()(i, j), p, m_stride);
+  }
+
+  template<typename SubPacket>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE SubPacket gatherPacket(Index i, Index j) const {
+    return pgather<Scalar, SubPacket>(&operator()(i, j), m_stride);
+  }
+
+  // storePacketBlock_helper defines a way to access values inside the PacketBlock, this is essentially required by the Complex types.
+  template<typename SubPacket, typename ScalarT, int n, int idx>
+  struct storePacketBlock_helper
+  {
+    storePacketBlock_helper<SubPacket, ScalarT, n, idx-1> spbh;
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>* sup, Index i, Index j, const PacketBlock<SubPacket, n>& block) const {
+      spbh.store(sup, i,j,block);
+      for(int l = 0; l < unpacket_traits<SubPacket>::size; l++)
+      {
+        ScalarT *v = &sup->operator()(i+l, j+idx);
+        *v = block.packet[idx][l];
+      }
+    }
+  };
+
+  template<typename SubPacket, int n, int idx>
+  struct storePacketBlock_helper<SubPacket, std::complex<float>, n, idx>
+  {
+    storePacketBlock_helper<SubPacket, std::complex<float>, n, idx-1> spbh;
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>* sup, Index i, Index j, const PacketBlock<SubPacket, n>& block) const {
+      spbh.store(sup,i,j,block);
+      for(int l = 0; l < unpacket_traits<SubPacket>::size; l++)
+      {
+        std::complex<float> *v = &sup->operator()(i+l, j+idx);
+        v->real(block.packet[idx].v[2*l+0]);
+        v->imag(block.packet[idx].v[2*l+1]);
+      }
+    }
+  };
+
+  template<typename SubPacket, int n, int idx>
+  struct storePacketBlock_helper<SubPacket, std::complex<double>, n, idx>
+  {
+    storePacketBlock_helper<SubPacket, std::complex<double>, n, idx-1> spbh;
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>* sup, Index i, Index j, const PacketBlock<SubPacket, n>& block) const {
+      spbh.store(sup,i,j,block);
+      for(int l = 0; l < unpacket_traits<SubPacket>::size; l++)
+      {
+        std::complex<double> *v = &sup->operator()(i+l, j+idx);
+        v->real(block.packet[idx].v[2*l+0]);
+        v->imag(block.packet[idx].v[2*l+1]);
+      }
+    }
+  };
+
+  template<typename SubPacket, typename ScalarT, int n>
+  struct storePacketBlock_helper<SubPacket, ScalarT, n, -1>
+  {
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>*, Index, Index, const PacketBlock<SubPacket, n>& ) const {
+    }
+  };
+
+  template<typename SubPacket, int n>
+  struct storePacketBlock_helper<SubPacket, std::complex<float>, n, -1>
+  {
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>*, Index, Index, const PacketBlock<SubPacket, n>& ) const {
+    }
+  };
+
+  template<typename SubPacket, int n>
+  struct storePacketBlock_helper<SubPacket, std::complex<double>, n, -1>
+  {
+    EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void store(const blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, Incr>*, Index, Index, const PacketBlock<SubPacket, n>& ) const {
+    }
+  };
+  // This function stores a PacketBlock on m_data, this approach is really quite slow compare to Incr=1 and should be avoided when possible.
+  template<typename SubPacket, int n>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacketBlock(Index i, Index j, const PacketBlock<SubPacket, n>&block) const {
+    storePacketBlock_helper<SubPacket, Scalar, n, n-1> spb;
+    spb.store(this, i,j,block);
+  }
+protected:
+  Scalar* EIGEN_RESTRICT m_data;
+  const Index m_stride;
+  const internal::variable_if_dynamic<Index,Incr> m_incr;
+};
+
+// lightweight helper class to access matrix coefficients (const version)
+template<typename Scalar, typename Index, int StorageOrder>
+class const_blas_data_mapper : public blas_data_mapper<const Scalar, Index, StorageOrder> {
+  public:
+  EIGEN_ALWAYS_INLINE const_blas_data_mapper(const Scalar *data, Index stride) : blas_data_mapper<const Scalar, Index, StorageOrder>(data, stride) {}
+
+  EIGEN_ALWAYS_INLINE const_blas_data_mapper<Scalar, Index, StorageOrder> getSubMapper(Index i, Index j) const {
+    return const_blas_data_mapper<Scalar, Index, StorageOrder>(&(this->operator()(i, j)), this->m_stride);
+  }
+};
+
+
+/* Helper class to analyze the factors of a Product expression.
+ * In particular it allows to pop out operator-, scalar multiples,
+ * and conjugate */
+template<typename XprType> struct blas_traits
+{
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef const XprType& ExtractType;
+  typedef XprType _ExtractType;
+  enum {
+    IsComplex = NumTraits<Scalar>::IsComplex,
+    IsTransposed = false,
+    NeedToConjugate = false,
+    HasUsableDirectAccess = (    (int(XprType::Flags)&DirectAccessBit)
+                              && (   bool(XprType::IsVectorAtCompileTime)
+                                  || int(inner_stride_at_compile_time<XprType>::ret) == 1)
+                             ) ?  1 : 0,
+    HasScalarFactor = false
+  };
+  typedef typename conditional<bool(HasUsableDirectAccess),
+    ExtractType,
+    typename _ExtractType::PlainObject
+    >::type DirectLinearAccessType;
+  static inline EIGEN_DEVICE_FUNC ExtractType extract(const XprType& x) { return x; }
+  static inline EIGEN_DEVICE_FUNC const Scalar extractScalarFactor(const XprType&) { return Scalar(1); }
+};
+
+// pop conjugate
+template<typename Scalar, typename NestedXpr>
+struct blas_traits<CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> XprType;
+  typedef typename Base::ExtractType ExtractType;
+
+  enum {
+    IsComplex = NumTraits<Scalar>::IsComplex,
+    NeedToConjugate = Base::NeedToConjugate ? 0 : IsComplex
+  };
+  static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); }
+  static inline Scalar extractScalarFactor(const XprType& x) { return conj(Base::extractScalarFactor(x.nestedExpression())); }
+};
+
+// pop scalar multiple
+template<typename Scalar, typename NestedXpr, typename Plain>
+struct blas_traits<CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain>, NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  enum {
+    HasScalarFactor = true
+  };
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain>, NestedXpr> XprType;
+  typedef typename Base::ExtractType ExtractType;
+  static inline EIGEN_DEVICE_FUNC ExtractType extract(const XprType& x) { return Base::extract(x.rhs()); }
+  static inline EIGEN_DEVICE_FUNC Scalar extractScalarFactor(const XprType& x)
+  { return x.lhs().functor().m_other * Base::extractScalarFactor(x.rhs()); }
+};
+template<typename Scalar, typename NestedXpr, typename Plain>
+struct blas_traits<CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain> > >
+ : blas_traits<NestedXpr>
+{
+  enum {
+    HasScalarFactor = true
+  };
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain> > XprType;
+  typedef typename Base::ExtractType ExtractType;
+  static inline ExtractType extract(const XprType& x) { return Base::extract(x.lhs()); }
+  static inline Scalar extractScalarFactor(const XprType& x)
+  { return Base::extractScalarFactor(x.lhs()) * x.rhs().functor().m_other; }
+};
+template<typename Scalar, typename Plain1, typename Plain2>
+struct blas_traits<CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain1>,
+                                                            const CwiseNullaryOp<scalar_constant_op<Scalar>,Plain2> > >
+ : blas_traits<CwiseNullaryOp<scalar_constant_op<Scalar>,Plain1> >
+{};
+
+// pop opposite
+template<typename Scalar, typename NestedXpr>
+struct blas_traits<CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  enum {
+    HasScalarFactor = true
+  };
+  typedef blas_traits<NestedXpr> Base;
+  typedef CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> XprType;
+  typedef typename Base::ExtractType ExtractType;
+  static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); }
+  static inline Scalar extractScalarFactor(const XprType& x)
+  { return - Base::extractScalarFactor(x.nestedExpression()); }
+};
+
+// pop/push transpose
+template<typename NestedXpr>
+struct blas_traits<Transpose<NestedXpr> >
+ : blas_traits<NestedXpr>
+{
+  typedef typename NestedXpr::Scalar Scalar;
+  typedef blas_traits<NestedXpr> Base;
+  typedef Transpose<NestedXpr> XprType;
+  typedef Transpose<const typename Base::_ExtractType>  ExtractType; // const to get rid of a compile error; anyway blas traits are only used on the RHS
+  typedef Transpose<const typename Base::_ExtractType> _ExtractType;
+  typedef typename conditional<bool(Base::HasUsableDirectAccess),
+    ExtractType,
+    typename ExtractType::PlainObject
+    >::type DirectLinearAccessType;
+  enum {
+    IsTransposed = Base::IsTransposed ? 0 : 1
+  };
+  static inline ExtractType extract(const XprType& x) { return ExtractType(Base::extract(x.nestedExpression())); }
+  static inline Scalar extractScalarFactor(const XprType& x) { return Base::extractScalarFactor(x.nestedExpression()); }
+};
+
+template<typename T>
+struct blas_traits<const T>
+     : blas_traits<T>
+{};
+
+template<typename T, bool HasUsableDirectAccess=blas_traits<T>::HasUsableDirectAccess>
+struct extract_data_selector {
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static const typename T::Scalar* run(const T& m)
+  {
+    return blas_traits<T>::extract(m).data();
+  }
+};
+
+template<typename T>
+struct extract_data_selector<T,false> {
+  static typename T::Scalar* run(const T&) { return 0; }
+};
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const typename T::Scalar* extract_data(const T& m)
+{
+  return extract_data_selector<T>::run(m);
+}
+
+/**
+ * \c combine_scalar_factors extracts and multiplies factors from GEMM and GEMV products.
+ * There is a specialization for booleans
+ */
+template<typename ResScalar, typename Lhs, typename Rhs>
+struct combine_scalar_factors_impl
+{
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static ResScalar run(const Lhs& lhs, const Rhs& rhs)
+  {
+    return blas_traits<Lhs>::extractScalarFactor(lhs) * blas_traits<Rhs>::extractScalarFactor(rhs);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static ResScalar run(const ResScalar& alpha, const Lhs& lhs, const Rhs& rhs)
+  {
+    return alpha * blas_traits<Lhs>::extractScalarFactor(lhs) * blas_traits<Rhs>::extractScalarFactor(rhs);
+  }
+};
+template<typename Lhs, typename Rhs>
+struct combine_scalar_factors_impl<bool, Lhs, Rhs>
+{
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static bool run(const Lhs& lhs, const Rhs& rhs)
+  {
+    return blas_traits<Lhs>::extractScalarFactor(lhs) && blas_traits<Rhs>::extractScalarFactor(rhs);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static bool run(const bool& alpha, const Lhs& lhs, const Rhs& rhs)
+  {
+    return alpha && blas_traits<Lhs>::extractScalarFactor(lhs) && blas_traits<Rhs>::extractScalarFactor(rhs);
+  }
+};
+
+template<typename ResScalar, typename Lhs, typename Rhs>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar combine_scalar_factors(const ResScalar& alpha, const Lhs& lhs, const Rhs& rhs)
+{
+  return combine_scalar_factors_impl<ResScalar,Lhs,Rhs>::run(alpha, lhs, rhs);
+}
+template<typename ResScalar, typename Lhs, typename Rhs>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ResScalar combine_scalar_factors(const Lhs& lhs, const Rhs& rhs)
+{
+  return combine_scalar_factors_impl<ResScalar,Lhs,Rhs>::run(lhs, rhs);
+}
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BLASUTIL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ConfigureVectorization.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ConfigureVectorization.h
new file mode 100644
index 00000000..af4e6962
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ConfigureVectorization.h
@@ -0,0 +1,512 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2018 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2020, Arm Limited and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONFIGURE_VECTORIZATION_H
+#define EIGEN_CONFIGURE_VECTORIZATION_H
+
+//------------------------------------------------------------------------------------------
+// Static and dynamic alignment control
+//
+// The main purpose of this section is to define EIGEN_MAX_ALIGN_BYTES and EIGEN_MAX_STATIC_ALIGN_BYTES
+// as the maximal boundary in bytes on which dynamically and statically allocated data may be alignment respectively.
+// The values of EIGEN_MAX_ALIGN_BYTES and EIGEN_MAX_STATIC_ALIGN_BYTES can be specified by the user. If not,
+// a default value is automatically computed based on architecture, compiler, and OS.
+//
+// This section also defines macros EIGEN_ALIGN_TO_BOUNDARY(N) and the shortcuts EIGEN_ALIGN{8,16,32,_MAX}
+// to be used to declare statically aligned buffers.
+//------------------------------------------------------------------------------------------
+
+
+/* EIGEN_ALIGN_TO_BOUNDARY(n) forces data to be n-byte aligned. This is used to satisfy SIMD requirements.
+ * However, we do that EVEN if vectorization (EIGEN_VECTORIZE) is disabled,
+ * so that vectorization doesn't affect binary compatibility.
+ *
+ * If we made alignment depend on whether or not EIGEN_VECTORIZE is defined, it would be impossible to link
+ * vectorized and non-vectorized code.
+ * 
+ * FIXME: this code can be cleaned up once we switch to proper C++11 only.
+ */
+#if (defined EIGEN_CUDACC)
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __align__(n)
+  #define EIGEN_ALIGNOF(x) __alignof(x)
+#elif EIGEN_HAS_ALIGNAS
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) alignas(n)
+  #define EIGEN_ALIGNOF(x) alignof(x)
+#elif EIGEN_COMP_GNUC || EIGEN_COMP_PGI || EIGEN_COMP_IBM || EIGEN_COMP_ARM
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n)))
+  #define EIGEN_ALIGNOF(x) __alignof(x)
+#elif EIGEN_COMP_MSVC
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __declspec(align(n))
+  #define EIGEN_ALIGNOF(x) __alignof(x)
+#elif EIGEN_COMP_SUNCC
+  // FIXME not sure about this one:
+  #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n)))
+  #define EIGEN_ALIGNOF(x) __alignof(x)
+#else
+  #error Please tell me what is the equivalent of alignas(n) and alignof(x) for your compiler
+#endif
+
+// If the user explicitly disable vectorization, then we also disable alignment
+#if defined(EIGEN_DONT_VECTORIZE)
+  #if defined(EIGEN_GPUCC)
+    // GPU code is always vectorized and requires memory alignment for
+    // statically allocated buffers.
+    #define EIGEN_IDEAL_MAX_ALIGN_BYTES 16
+  #else
+    #define EIGEN_IDEAL_MAX_ALIGN_BYTES 0
+  #endif
+#elif defined(__AVX512F__)
+  // 64 bytes static alignment is preferred only if really required
+  #define EIGEN_IDEAL_MAX_ALIGN_BYTES 64
+#elif defined(__AVX__)
+  // 32 bytes static alignment is preferred only if really required
+  #define EIGEN_IDEAL_MAX_ALIGN_BYTES 32
+#else
+  #define EIGEN_IDEAL_MAX_ALIGN_BYTES 16
+#endif
+
+
+// EIGEN_MIN_ALIGN_BYTES defines the minimal value for which the notion of explicit alignment makes sense
+#define EIGEN_MIN_ALIGN_BYTES 16
+
+// Defined the boundary (in bytes) on which the data needs to be aligned. Note
+// that unless EIGEN_ALIGN is defined and not equal to 0, the data may not be
+// aligned at all regardless of the value of this #define.
+
+#if (defined(EIGEN_DONT_ALIGN_STATICALLY) || defined(EIGEN_DONT_ALIGN))  && defined(EIGEN_MAX_STATIC_ALIGN_BYTES) && EIGEN_MAX_STATIC_ALIGN_BYTES>0
+#error EIGEN_MAX_STATIC_ALIGN_BYTES and EIGEN_DONT_ALIGN[_STATICALLY] are both defined with EIGEN_MAX_STATIC_ALIGN_BYTES!=0. Use EIGEN_MAX_STATIC_ALIGN_BYTES=0 as a synonym of EIGEN_DONT_ALIGN_STATICALLY.
+#endif
+
+// EIGEN_DONT_ALIGN_STATICALLY and EIGEN_DONT_ALIGN are deprecated
+// They imply EIGEN_MAX_STATIC_ALIGN_BYTES=0
+#if defined(EIGEN_DONT_ALIGN_STATICALLY) || defined(EIGEN_DONT_ALIGN)
+  #ifdef EIGEN_MAX_STATIC_ALIGN_BYTES
+    #undef EIGEN_MAX_STATIC_ALIGN_BYTES
+  #endif
+  #define EIGEN_MAX_STATIC_ALIGN_BYTES 0
+#endif
+
+#ifndef EIGEN_MAX_STATIC_ALIGN_BYTES
+
+  // Try to automatically guess what is the best default value for EIGEN_MAX_STATIC_ALIGN_BYTES
+
+  // 16 byte alignment is only useful for vectorization. Since it affects the ABI, we need to enable
+  // 16 byte alignment on all platforms where vectorization might be enabled. In theory we could always
+  // enable alignment, but it can be a cause of problems on some platforms, so we just disable it in
+  // certain common platform (compiler+architecture combinations) to avoid these problems.
+  // Only static alignment is really problematic (relies on nonstandard compiler extensions),
+  // try to keep heap alignment even when we have to disable static alignment.
+  #if EIGEN_COMP_GNUC && !(EIGEN_ARCH_i386_OR_x86_64 || EIGEN_ARCH_ARM_OR_ARM64 || EIGEN_ARCH_PPC || EIGEN_ARCH_IA64 || EIGEN_ARCH_MIPS)
+  #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 1
+  #elif EIGEN_ARCH_ARM_OR_ARM64 && EIGEN_COMP_GNUC_STRICT && EIGEN_GNUC_AT_MOST(4, 6)
+  // Old versions of GCC on ARM, at least 4.4, were once seen to have buggy static alignment support.
+  // Not sure which version fixed it, hopefully it doesn't affect 4.7, which is still somewhat in use.
+  // 4.8 and newer seem definitely unaffected.
+  #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 1
+  #else
+  #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 0
+  #endif
+
+  // static alignment is completely disabled with GCC 3, Sun Studio, and QCC/QNX
+  #if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT \
+  && !EIGEN_GCC3_OR_OLDER \
+  && !EIGEN_COMP_SUNCC \
+  && !EIGEN_OS_QNX
+    #define EIGEN_ARCH_WANTS_STACK_ALIGNMENT 1
+  #else
+    #define EIGEN_ARCH_WANTS_STACK_ALIGNMENT 0
+  #endif
+
+  #if EIGEN_ARCH_WANTS_STACK_ALIGNMENT
+    #define EIGEN_MAX_STATIC_ALIGN_BYTES EIGEN_IDEAL_MAX_ALIGN_BYTES
+  #else
+    #define EIGEN_MAX_STATIC_ALIGN_BYTES 0
+  #endif
+
+#endif
+
+// If EIGEN_MAX_ALIGN_BYTES is defined, then it is considered as an upper bound for EIGEN_MAX_STATIC_ALIGN_BYTES
+#if defined(EIGEN_MAX_ALIGN_BYTES) && EIGEN_MAX_ALIGN_BYTES<EIGEN_MAX_STATIC_ALIGN_BYTES
+#undef EIGEN_MAX_STATIC_ALIGN_BYTES
+#define EIGEN_MAX_STATIC_ALIGN_BYTES EIGEN_MAX_ALIGN_BYTES
+#endif
+
+#if EIGEN_MAX_STATIC_ALIGN_BYTES==0 && !defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT)
+  #define EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT
+#endif
+
+// At this stage, EIGEN_MAX_STATIC_ALIGN_BYTES>0 is the true test whether we want to align arrays on the stack or not.
+// It takes into account both the user choice to explicitly enable/disable alignment (by setting EIGEN_MAX_STATIC_ALIGN_BYTES)
+// and the architecture config (EIGEN_ARCH_WANTS_STACK_ALIGNMENT).
+// Henceforth, only EIGEN_MAX_STATIC_ALIGN_BYTES should be used.
+
+
+// Shortcuts to EIGEN_ALIGN_TO_BOUNDARY
+#define EIGEN_ALIGN8  EIGEN_ALIGN_TO_BOUNDARY(8)
+#define EIGEN_ALIGN16 EIGEN_ALIGN_TO_BOUNDARY(16)
+#define EIGEN_ALIGN32 EIGEN_ALIGN_TO_BOUNDARY(32)
+#define EIGEN_ALIGN64 EIGEN_ALIGN_TO_BOUNDARY(64)
+#if EIGEN_MAX_STATIC_ALIGN_BYTES>0
+#define EIGEN_ALIGN_MAX EIGEN_ALIGN_TO_BOUNDARY(EIGEN_MAX_STATIC_ALIGN_BYTES)
+#else
+#define EIGEN_ALIGN_MAX
+#endif
+
+
+// Dynamic alignment control
+
+#if defined(EIGEN_DONT_ALIGN) && defined(EIGEN_MAX_ALIGN_BYTES) && EIGEN_MAX_ALIGN_BYTES>0
+#error EIGEN_MAX_ALIGN_BYTES and EIGEN_DONT_ALIGN are both defined with EIGEN_MAX_ALIGN_BYTES!=0. Use EIGEN_MAX_ALIGN_BYTES=0 as a synonym of EIGEN_DONT_ALIGN.
+#endif
+
+#ifdef EIGEN_DONT_ALIGN
+  #ifdef EIGEN_MAX_ALIGN_BYTES
+    #undef EIGEN_MAX_ALIGN_BYTES
+  #endif
+  #define EIGEN_MAX_ALIGN_BYTES 0
+#elif !defined(EIGEN_MAX_ALIGN_BYTES)
+  #define EIGEN_MAX_ALIGN_BYTES EIGEN_IDEAL_MAX_ALIGN_BYTES
+#endif
+
+#if EIGEN_IDEAL_MAX_ALIGN_BYTES > EIGEN_MAX_ALIGN_BYTES
+#define EIGEN_DEFAULT_ALIGN_BYTES EIGEN_IDEAL_MAX_ALIGN_BYTES
+#else
+#define EIGEN_DEFAULT_ALIGN_BYTES EIGEN_MAX_ALIGN_BYTES
+#endif
+
+
+#ifndef EIGEN_UNALIGNED_VECTORIZE
+#define EIGEN_UNALIGNED_VECTORIZE 1
+#endif
+
+//----------------------------------------------------------------------
+
+// if alignment is disabled, then disable vectorization. Note: EIGEN_MAX_ALIGN_BYTES is the proper check, it takes into
+// account both the user's will (EIGEN_MAX_ALIGN_BYTES,EIGEN_DONT_ALIGN) and our own platform checks
+#if EIGEN_MAX_ALIGN_BYTES==0
+  #ifndef EIGEN_DONT_VECTORIZE
+    #define EIGEN_DONT_VECTORIZE
+  #endif
+#endif
+
+
+// The following (except #include <malloc.h> and _M_IX86_FP ??) can likely be
+// removed as gcc 4.1 and msvc 2008 are not supported anyways.
+#if EIGEN_COMP_MSVC
+  #include <malloc.h> // for _aligned_malloc -- need it regardless of whether vectorization is enabled
+  #if (EIGEN_COMP_MSVC >= 1500) // 2008 or later
+    // a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP.
+    #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || EIGEN_ARCH_x86_64
+      #define EIGEN_SSE2_ON_MSVC_2008_OR_LATER
+    #endif
+  #endif
+#else
+  #if (defined __SSE2__) && ( (!EIGEN_COMP_GNUC) || EIGEN_COMP_ICC || EIGEN_GNUC_AT_LEAST(4,2) )
+    #define EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC
+  #endif
+#endif
+
+#if !(defined(EIGEN_DONT_VECTORIZE) || defined(EIGEN_GPUCC))
+
+  #if defined (EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER)
+
+    // Defines symbols for compile-time detection of which instructions are
+    // used.
+    // EIGEN_VECTORIZE_YY is defined if and only if the instruction set YY is used
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_SSE
+    #define EIGEN_VECTORIZE_SSE2
+
+    // Detect sse3/ssse3/sse4:
+    // gcc and icc defines __SSE3__, ...
+    // there is no way to know about this on msvc. You can define EIGEN_VECTORIZE_SSE* if you
+    // want to force the use of those instructions with msvc.
+    #ifdef __SSE3__
+      #define EIGEN_VECTORIZE_SSE3
+    #endif
+    #ifdef __SSSE3__
+      #define EIGEN_VECTORIZE_SSSE3
+    #endif
+    #ifdef __SSE4_1__
+      #define EIGEN_VECTORIZE_SSE4_1
+    #endif
+    #ifdef __SSE4_2__
+      #define EIGEN_VECTORIZE_SSE4_2
+    #endif
+    #ifdef __AVX__
+      #ifndef EIGEN_USE_SYCL 
+        #define EIGEN_VECTORIZE_AVX
+      #endif
+      #define EIGEN_VECTORIZE_SSE3
+      #define EIGEN_VECTORIZE_SSSE3
+      #define EIGEN_VECTORIZE_SSE4_1
+      #define EIGEN_VECTORIZE_SSE4_2
+    #endif
+    #ifdef __AVX2__
+      #ifndef EIGEN_USE_SYCL 
+        #define EIGEN_VECTORIZE_AVX2
+        #define EIGEN_VECTORIZE_AVX
+      #endif
+      #define EIGEN_VECTORIZE_SSE3
+      #define EIGEN_VECTORIZE_SSSE3
+      #define EIGEN_VECTORIZE_SSE4_1
+      #define EIGEN_VECTORIZE_SSE4_2
+    #endif
+    #if defined(__FMA__) || (EIGEN_COMP_MSVC && defined(__AVX2__))
+      // MSVC does not expose a switch dedicated for FMA
+      // For MSVC, AVX2 => FMA
+      #define EIGEN_VECTORIZE_FMA
+    #endif
+    #if defined(__AVX512F__)
+      #ifndef EIGEN_VECTORIZE_FMA
+      #if EIGEN_COMP_GNUC
+      #error Please add -mfma to your compiler flags: compiling with -mavx512f alone without SSE/AVX FMA is not supported (bug 1638).
+      #else
+      #error Please enable FMA in your compiler flags (e.g. -mfma): compiling with AVX512 alone without SSE/AVX FMA is not supported (bug 1638).
+      #endif
+      #endif
+      #ifndef EIGEN_USE_SYCL
+        #define EIGEN_VECTORIZE_AVX512
+        #define EIGEN_VECTORIZE_AVX2
+        #define EIGEN_VECTORIZE_AVX
+      #endif
+      #define EIGEN_VECTORIZE_FMA
+      #define EIGEN_VECTORIZE_SSE3
+      #define EIGEN_VECTORIZE_SSSE3
+      #define EIGEN_VECTORIZE_SSE4_1
+      #define EIGEN_VECTORIZE_SSE4_2
+      #ifndef EIGEN_USE_SYCL
+        #ifdef __AVX512DQ__
+          #define EIGEN_VECTORIZE_AVX512DQ
+        #endif
+        #ifdef __AVX512ER__
+          #define EIGEN_VECTORIZE_AVX512ER
+        #endif
+        #ifdef __AVX512BF16__
+          #define EIGEN_VECTORIZE_AVX512BF16
+        #endif
+      #endif
+    #endif
+
+    // Disable AVX support on broken xcode versions
+    #if defined(__apple_build_version__) && (__apple_build_version__ == 11000033 ) && ( __MAC_OS_X_VERSION_MIN_REQUIRED == 101500 )
+      // A nasty bug in the clang compiler shipped with xcode in a common compilation situation
+      // when XCode 11.0 and Mac deployment target macOS 10.15 is https://trac.macports.org/ticket/58776#no1
+      #ifdef EIGEN_VECTORIZE_AVX
+        #undef EIGEN_VECTORIZE_AVX
+        #warning "Disabling AVX support: clang compiler shipped with XCode 11.[012] generates broken assembly with -macosx-version-min=10.15 and AVX enabled. "
+        #ifdef EIGEN_VECTORIZE_AVX2
+          #undef EIGEN_VECTORIZE_AVX2
+        #endif
+        #ifdef EIGEN_VECTORIZE_FMA
+          #undef EIGEN_VECTORIZE_FMA
+        #endif
+        #ifdef EIGEN_VECTORIZE_AVX512
+          #undef EIGEN_VECTORIZE_AVX512
+        #endif
+        #ifdef EIGEN_VECTORIZE_AVX512DQ
+          #undef EIGEN_VECTORIZE_AVX512DQ
+        #endif
+        #ifdef EIGEN_VECTORIZE_AVX512ER
+          #undef EIGEN_VECTORIZE_AVX512ER
+        #endif
+      #endif
+      // NOTE: Confirmed test failures in XCode 11.0, and XCode 11.2 with  -macosx-version-min=10.15 and AVX
+      // NOTE using -macosx-version-min=10.15 with Xcode 11.0 results in runtime segmentation faults in many tests, 11.2 produce core dumps in 3 tests
+      // NOTE using -macosx-version-min=10.14 produces functioning and passing tests in all cases
+      // NOTE __clang_version__ "11.0.0 (clang-1100.0.33.8)"  XCode 11.0 <- Produces many segfault and core dumping tests
+      //                                                                    with  -macosx-version-min=10.15 and AVX
+      // NOTE __clang_version__ "11.0.0 (clang-1100.0.33.12)" XCode 11.2 <- Produces 3 core dumping tests with  
+      //                                                                    -macosx-version-min=10.15 and AVX
+    #endif
+
+    // include files
+
+    // This extern "C" works around a MINGW-w64 compilation issue
+    // https://sourceforge.net/tracker/index.php?func=detail&aid=3018394&group_id=202880&atid=983354
+    // In essence, intrin.h is included by windows.h and also declares intrinsics (just as emmintrin.h etc. below do).
+    // However, intrin.h uses an extern "C" declaration, and g++ thus complains of duplicate declarations
+    // with conflicting linkage.  The linkage for intrinsics doesn't matter, but at that stage the compiler doesn't know;
+    // so, to avoid compile errors when windows.h is included after Eigen/Core, ensure intrinsics are extern "C" here too.
+    // notice that since these are C headers, the extern "C" is theoretically needed anyways.
+    extern "C" {
+      // In theory we should only include immintrin.h and not the other *mmintrin.h header files directly.
+      // Doing so triggers some issues with ICC. However old gcc versions seems to not have this file, thus:
+      #if EIGEN_COMP_ICC >= 1110
+        #include <immintrin.h>
+      #else
+        #include <mmintrin.h>
+        #include <emmintrin.h>
+        #include <xmmintrin.h>
+        #ifdef  EIGEN_VECTORIZE_SSE3
+        #include <pmmintrin.h>
+        #endif
+        #ifdef EIGEN_VECTORIZE_SSSE3
+        #include <tmmintrin.h>
+        #endif
+        #ifdef EIGEN_VECTORIZE_SSE4_1
+        #include <smmintrin.h>
+        #endif
+        #ifdef EIGEN_VECTORIZE_SSE4_2
+        #include <nmmintrin.h>
+        #endif
+        #if defined(EIGEN_VECTORIZE_AVX) || defined(EIGEN_VECTORIZE_AVX512)
+        #include <immintrin.h>
+        #endif
+      #endif
+    } // end extern "C"
+
+  #elif defined __VSX__
+
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_VSX
+    #include <altivec.h>
+    // We need to #undef all these ugly tokens defined in <altivec.h>
+    // => use __vector instead of vector
+    #undef bool
+    #undef vector
+    #undef pixel
+
+  #elif defined __ALTIVEC__
+
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_ALTIVEC
+    #include <altivec.h>
+    // We need to #undef all these ugly tokens defined in <altivec.h>
+    // => use __vector instead of vector
+    #undef bool
+    #undef vector
+    #undef pixel
+
+  #elif ((defined  __ARM_NEON) || (defined __ARM_NEON__)) && !(defined EIGEN_ARM64_USE_SVE)
+
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_NEON
+    #include <arm_neon.h>
+
+  // We currently require SVE to be enabled explicitly via EIGEN_ARM64_USE_SVE and
+  // will not select the backend automatically
+  #elif (defined __ARM_FEATURE_SVE) && (defined EIGEN_ARM64_USE_SVE)
+
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_SVE
+    #include <arm_sve.h>
+
+    // Since we depend on knowing SVE vector lengths at compile-time, we need
+    // to ensure a fixed lengths is set
+    #if defined __ARM_FEATURE_SVE_BITS
+      #define EIGEN_ARM64_SVE_VL __ARM_FEATURE_SVE_BITS
+    #else
+#error "Eigen requires a fixed SVE lector length but EIGEN_ARM64_SVE_VL is not set."
+#endif
+
+#elif (defined __s390x__ && defined __VEC__)
+
+#define EIGEN_VECTORIZE
+#define EIGEN_VECTORIZE_ZVECTOR
+#include <vecintrin.h>
+
+#elif defined __mips_msa
+
+// Limit MSA optimizations to little-endian CPUs for now.
+// TODO: Perhaps, eventually support MSA optimizations on big-endian CPUs?
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#if defined(__LP64__)
+#define EIGEN_MIPS_64
+#else
+#define EIGEN_MIPS_32
+#endif
+#define EIGEN_VECTORIZE
+#define EIGEN_VECTORIZE_MSA
+#include <msa.h>
+#endif
+
+#endif
+#endif
+
+// Following the Arm ACLE arm_neon.h should also include arm_fp16.h but not all
+// compilers seem to follow this. We therefore include it explicitly.
+// See also: https://bugs.llvm.org/show_bug.cgi?id=47955
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+  #include <arm_fp16.h>
+#endif
+
+#if defined(__F16C__) && (!defined(EIGEN_GPUCC) && (!defined(EIGEN_COMP_CLANG) || EIGEN_COMP_CLANG>=380))
+  // We can use the optimized fp16 to float and float to fp16 conversion routines
+  #define EIGEN_HAS_FP16_C
+
+  #if defined(EIGEN_COMP_CLANG)
+    // Workaround for clang: The FP16C intrinsics for clang are included by
+    // immintrin.h, as opposed to emmintrin.h as suggested by Intel:
+    // https://software.intel.com/sites/landingpage/IntrinsicsGuide/#othertechs=FP16C&expand=1711
+    #include <immintrin.h>
+  #endif
+#endif
+
+#if defined EIGEN_CUDACC
+  #define EIGEN_VECTORIZE_GPU
+  #include <vector_types.h>
+  #if EIGEN_CUDA_SDK_VER >= 70500
+    #define EIGEN_HAS_CUDA_FP16
+  #endif
+#endif
+
+#if defined(EIGEN_HAS_CUDA_FP16)
+  #include <cuda_runtime_api.h>
+  #include <cuda_fp16.h>
+#endif
+
+#if defined(EIGEN_HIPCC)
+  #define EIGEN_VECTORIZE_GPU
+  #include <hip/hip_vector_types.h>
+  #define EIGEN_HAS_HIP_FP16
+  #include <hip/hip_fp16.h>
+#endif
+
+
+/** \brief Namespace containing all symbols from the %Eigen library. */
+namespace Eigen {
+
+inline static const char *SimdInstructionSetsInUse(void) {
+#if defined(EIGEN_VECTORIZE_AVX512)
+  return "AVX512, FMA, AVX2, AVX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
+#elif defined(EIGEN_VECTORIZE_AVX)
+  return "AVX SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
+#elif defined(EIGEN_VECTORIZE_SSE4_2)
+  return "SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
+#elif defined(EIGEN_VECTORIZE_SSE4_1)
+  return "SSE, SSE2, SSE3, SSSE3, SSE4.1";
+#elif defined(EIGEN_VECTORIZE_SSSE3)
+  return "SSE, SSE2, SSE3, SSSE3";
+#elif defined(EIGEN_VECTORIZE_SSE3)
+  return "SSE, SSE2, SSE3";
+#elif defined(EIGEN_VECTORIZE_SSE2)
+  return "SSE, SSE2";
+#elif defined(EIGEN_VECTORIZE_ALTIVEC)
+  return "AltiVec";
+#elif defined(EIGEN_VECTORIZE_VSX)
+  return "VSX";
+#elif defined(EIGEN_VECTORIZE_NEON)
+  return "ARM NEON";
+#elif defined(EIGEN_VECTORIZE_SVE)
+  return "ARM SVE";
+#elif defined(EIGEN_VECTORIZE_ZVECTOR)
+  return "S390X ZVECTOR";
+#elif defined(EIGEN_VECTORIZE_MSA)
+  return "MIPS MSA";
+#else
+  return "None";
+#endif
+}
+
+} // end namespace Eigen
+
+
+#endif // EIGEN_CONFIGURE_VECTORIZATION_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Constants.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Constants.h
new file mode 100644
index 00000000..35dcaa7b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Constants.h
@@ -0,0 +1,563 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2020, Arm Limited and Contributors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONSTANTS_H
+#define EIGEN_CONSTANTS_H
+
+namespace Eigen {
+
+/** This value means that a positive quantity (e.g., a size) is not known at compile-time, and that instead the value is
+  * stored in some runtime variable.
+  *
+  * Changing the value of Dynamic breaks the ABI, as Dynamic is often used as a template parameter for Matrix.
+  */
+const int Dynamic = -1;
+
+/** This value means that a signed quantity (e.g., a signed index) is not known at compile-time, and that instead its value
+  * has to be specified at runtime.
+  */
+const int DynamicIndex = 0xffffff;
+
+/** This value means that the increment to go from one value to another in a sequence is not constant for each step.
+  */
+const int UndefinedIncr = 0xfffffe;
+
+/** This value means +Infinity; it is currently used only as the p parameter to MatrixBase::lpNorm<int>().
+  * The value Infinity there means the L-infinity norm.
+  */
+const int Infinity = -1;
+
+/** This value means that the cost to evaluate an expression coefficient is either very expensive or
+  * cannot be known at compile time.
+  *
+  * This value has to be positive to (1) simplify cost computation, and (2) allow to distinguish between a very expensive and very very expensive expressions.
+  * It thus must also be large enough to make sure unrolling won't happen and that sub expressions will be evaluated, but not too large to avoid overflow.
+  */
+const int HugeCost = 10000;
+
+/** \defgroup flags Flags
+  * \ingroup Core_Module
+  *
+  * These are the possible bits which can be OR'ed to constitute the flags of a matrix or
+  * expression.
+  *
+  * It is important to note that these flags are a purely compile-time notion. They are a compile-time property of
+  * an expression type, implemented as enum's. They are not stored in memory at runtime, and they do not incur any
+  * runtime overhead.
+  *
+  * \sa MatrixBase::Flags
+  */
+
+/** \ingroup flags
+  *
+  * for a matrix, this means that the storage order is row-major.
+  * If this bit is not set, the storage order is column-major.
+  * For an expression, this determines the storage order of
+  * the matrix created by evaluation of that expression.
+  * \sa \blank  \ref TopicStorageOrders */
+const unsigned int RowMajorBit = 0x1;
+
+/** \ingroup flags
+  * means the expression should be evaluated by the calling expression */
+const unsigned int EvalBeforeNestingBit = 0x2;
+
+/** \ingroup flags
+  * \deprecated
+  * means the expression should be evaluated before any assignment */
+EIGEN_DEPRECATED
+const unsigned int EvalBeforeAssigningBit = 0x4; // FIXME deprecated
+
+/** \ingroup flags
+  *
+  * Short version: means the expression might be vectorized
+  *
+  * Long version: means that the coefficients can be handled by packets
+  * and start at a memory location whose alignment meets the requirements
+  * of the present CPU architecture for optimized packet access. In the fixed-size
+  * case, there is the additional condition that it be possible to access all the
+  * coefficients by packets (this implies the requirement that the size be a multiple of 16 bytes,
+  * and that any nontrivial strides don't break the alignment). In the dynamic-size case,
+  * there is no such condition on the total size and strides, so it might not be possible to access
+  * all coeffs by packets.
+  *
+  * \note This bit can be set regardless of whether vectorization is actually enabled.
+  *       To check for actual vectorizability, see \a ActualPacketAccessBit.
+  */
+const unsigned int PacketAccessBit = 0x8;
+
+#ifdef EIGEN_VECTORIZE
+/** \ingroup flags
+  *
+  * If vectorization is enabled (EIGEN_VECTORIZE is defined) this constant
+  * is set to the value \a PacketAccessBit.
+  *
+  * If vectorization is not enabled (EIGEN_VECTORIZE is not defined) this constant
+  * is set to the value 0.
+  */
+const unsigned int ActualPacketAccessBit = PacketAccessBit;
+#else
+const unsigned int ActualPacketAccessBit = 0x0;
+#endif
+
+/** \ingroup flags
+  *
+  * Short version: means the expression can be seen as 1D vector.
+  *
+  * Long version: means that one can access the coefficients
+  * of this expression by coeff(int), and coeffRef(int) in the case of a lvalue expression. These
+  * index-based access methods are guaranteed
+  * to not have to do any runtime computation of a (row, col)-pair from the index, so that it
+  * is guaranteed that whenever it is available, index-based access is at least as fast as
+  * (row,col)-based access. Expressions for which that isn't possible don't have the LinearAccessBit.
+  *
+  * If both PacketAccessBit and LinearAccessBit are set, then the
+  * packets of this expression can be accessed by packet(int), and writePacket(int) in the case of a
+  * lvalue expression.
+  *
+  * Typically, all vector expressions have the LinearAccessBit, but there is one exception:
+  * Product expressions don't have it, because it would be troublesome for vectorization, even when the
+  * Product is a vector expression. Thus, vector Product expressions allow index-based coefficient access but
+  * not index-based packet access, so they don't have the LinearAccessBit.
+  */
+const unsigned int LinearAccessBit = 0x10;
+
+/** \ingroup flags
+  *
+  * Means the expression has a coeffRef() method, i.e. is writable as its individual coefficients are directly addressable.
+  * This rules out read-only expressions.
+  *
+  * Note that DirectAccessBit and LvalueBit are mutually orthogonal, as there are examples of expression having one but note
+  * the other:
+  *   \li writable expressions that don't have a very simple memory layout as a strided array, have LvalueBit but not DirectAccessBit
+  *   \li Map-to-const expressions, for example Map<const Matrix>, have DirectAccessBit but not LvalueBit
+  *
+  * Expressions having LvalueBit also have their coeff() method returning a const reference instead of returning a new value.
+  */
+const unsigned int LvalueBit = 0x20;
+
+/** \ingroup flags
+  *
+  * Means that the underlying array of coefficients can be directly accessed as a plain strided array. The memory layout
+  * of the array of coefficients must be exactly the natural one suggested by rows(), cols(),
+  * outerStride(), innerStride(), and the RowMajorBit. This rules out expressions such as Diagonal, whose coefficients,
+  * though referencable, do not have such a regular memory layout.
+  *
+  * See the comment on LvalueBit for an explanation of how LvalueBit and DirectAccessBit are mutually orthogonal.
+  */
+const unsigned int DirectAccessBit = 0x40;
+
+/** \deprecated \ingroup flags
+  *
+  * means the first coefficient packet is guaranteed to be aligned.
+  * An expression cannot have the AlignedBit without the PacketAccessBit flag.
+  * In other words, this means we are allow to perform an aligned packet access to the first element regardless
+  * of the expression kind:
+  * \code
+  * expression.packet<Aligned>(0);
+  * \endcode
+  */
+EIGEN_DEPRECATED const unsigned int AlignedBit = 0x80;
+
+const unsigned int NestByRefBit = 0x100;
+
+/** \ingroup flags
+  *
+  * for an expression, this means that the storage order
+  * can be either row-major or column-major.
+  * The precise choice will be decided at evaluation time or when
+  * combined with other expressions.
+  * \sa \blank  \ref RowMajorBit, \ref TopicStorageOrders */
+const unsigned int NoPreferredStorageOrderBit = 0x200;
+
+/** \ingroup flags
+  *
+  * Means that the underlying coefficients can be accessed through pointers to the sparse (un)compressed storage format,
+  * that is, the expression provides:
+  * \code
+    inline const Scalar* valuePtr() const;
+    inline const Index* innerIndexPtr() const;
+    inline const Index* outerIndexPtr() const;
+    inline const Index* innerNonZeroPtr() const;
+    \endcode
+  */
+const unsigned int CompressedAccessBit = 0x400;
+
+
+// list of flags that are inherited by default
+const unsigned int HereditaryBits = RowMajorBit
+                                  | EvalBeforeNestingBit;
+
+/** \defgroup enums Enumerations
+  * \ingroup Core_Module
+  *
+  * Various enumerations used in %Eigen. Many of these are used as template parameters.
+  */
+
+/** \ingroup enums
+  * Enum containing possible values for the \c Mode or \c UpLo parameter of
+  * MatrixBase::selfadjointView() and MatrixBase::triangularView(), and selfadjoint solvers. */
+enum UpLoType {
+  /** View matrix as a lower triangular matrix. */
+  Lower=0x1,                      
+  /** View matrix as an upper triangular matrix. */
+  Upper=0x2,                      
+  /** %Matrix has ones on the diagonal; to be used in combination with #Lower or #Upper. */
+  UnitDiag=0x4, 
+  /** %Matrix has zeros on the diagonal; to be used in combination with #Lower or #Upper. */
+  ZeroDiag=0x8,
+  /** View matrix as a lower triangular matrix with ones on the diagonal. */
+  UnitLower=UnitDiag|Lower, 
+  /** View matrix as an upper triangular matrix with ones on the diagonal. */
+  UnitUpper=UnitDiag|Upper,
+  /** View matrix as a lower triangular matrix with zeros on the diagonal. */
+  StrictlyLower=ZeroDiag|Lower, 
+  /** View matrix as an upper triangular matrix with zeros on the diagonal. */
+  StrictlyUpper=ZeroDiag|Upper,
+  /** Used in BandMatrix and SelfAdjointView to indicate that the matrix is self-adjoint. */
+  SelfAdjoint=0x10,
+  /** Used to support symmetric, non-selfadjoint, complex matrices. */
+  Symmetric=0x20
+};
+
+/** \ingroup enums
+  * Enum for indicating whether a buffer is aligned or not. */
+enum AlignmentType {
+  Unaligned=0,        /**< Data pointer has no specific alignment. */
+  Aligned8=8,         /**< Data pointer is aligned on a 8 bytes boundary. */
+  Aligned16=16,       /**< Data pointer is aligned on a 16 bytes boundary. */
+  Aligned32=32,       /**< Data pointer is aligned on a 32 bytes boundary. */
+  Aligned64=64,       /**< Data pointer is aligned on a 64 bytes boundary. */
+  Aligned128=128,     /**< Data pointer is aligned on a 128 bytes boundary. */
+  AlignedMask=255,
+  Aligned=16,         /**< \deprecated Synonym for Aligned16. */
+#if EIGEN_MAX_ALIGN_BYTES==128
+  AlignedMax = Aligned128
+#elif EIGEN_MAX_ALIGN_BYTES==64
+  AlignedMax = Aligned64
+#elif EIGEN_MAX_ALIGN_BYTES==32
+  AlignedMax = Aligned32
+#elif EIGEN_MAX_ALIGN_BYTES==16
+  AlignedMax = Aligned16
+#elif EIGEN_MAX_ALIGN_BYTES==8
+  AlignedMax = Aligned8
+#elif EIGEN_MAX_ALIGN_BYTES==0
+  AlignedMax = Unaligned
+#else
+#error Invalid value for EIGEN_MAX_ALIGN_BYTES
+#endif
+};
+
+/** \ingroup enums
+  * Enum containing possible values for the \p Direction parameter of
+  * Reverse, PartialReduxExpr and VectorwiseOp. */
+enum DirectionType { 
+  /** For Reverse, all columns are reversed; 
+    * for PartialReduxExpr and VectorwiseOp, act on columns. */
+  Vertical, 
+  /** For Reverse, all rows are reversed; 
+    * for PartialReduxExpr and VectorwiseOp, act on rows. */
+  Horizontal, 
+  /** For Reverse, both rows and columns are reversed; 
+    * not used for PartialReduxExpr and VectorwiseOp. */
+  BothDirections 
+};
+
+/** \internal \ingroup enums
+  * Enum to specify how to traverse the entries of a matrix. */
+enum TraversalType {
+  /** \internal Default traversal, no vectorization, no index-based access */
+  DefaultTraversal,
+  /** \internal No vectorization, use index-based access to have only one for loop instead of 2 nested loops */
+  LinearTraversal,
+  /** \internal Equivalent to a slice vectorization for fixed-size matrices having good alignment
+    * and good size */
+  InnerVectorizedTraversal,
+  /** \internal Vectorization path using a single loop plus scalar loops for the
+    * unaligned boundaries */
+  LinearVectorizedTraversal,
+  /** \internal Generic vectorization path using one vectorized loop per row/column with some
+    * scalar loops to handle the unaligned boundaries */
+  SliceVectorizedTraversal,
+  /** \internal Special case to properly handle incompatible scalar types or other defecting cases*/
+  InvalidTraversal,
+  /** \internal Evaluate all entries at once */
+  AllAtOnceTraversal
+};
+
+/** \internal \ingroup enums
+  * Enum to specify whether to unroll loops when traversing over the entries of a matrix. */
+enum UnrollingType {
+  /** \internal Do not unroll loops. */
+  NoUnrolling,
+  /** \internal Unroll only the inner loop, but not the outer loop. */
+  InnerUnrolling,
+  /** \internal Unroll both the inner and the outer loop. If there is only one loop, 
+    * because linear traversal is used, then unroll that loop. */
+  CompleteUnrolling
+};
+
+/** \internal \ingroup enums
+  * Enum to specify whether to use the default (built-in) implementation or the specialization. */
+enum SpecializedType {
+  Specialized,
+  BuiltIn
+};
+
+/** \ingroup enums
+  * Enum containing possible values for the \p _Options template parameter of
+  * Matrix, Array and BandMatrix. */
+enum StorageOptions {
+  /** Storage order is column major (see \ref TopicStorageOrders). */
+  ColMajor = 0,
+  /** Storage order is row major (see \ref TopicStorageOrders). */
+  RowMajor = 0x1,  // it is only a coincidence that this is equal to RowMajorBit -- don't rely on that
+  /** Align the matrix itself if it is vectorizable fixed-size */
+  AutoAlign = 0,
+  /** Don't require alignment for the matrix itself (the array of coefficients, if dynamically allocated, may still be requested to be aligned) */ // FIXME --- clarify the situation
+  DontAlign = 0x2
+};
+
+/** \ingroup enums
+  * Enum for specifying whether to apply or solve on the left or right. */
+enum SideType {
+  /** Apply transformation on the left. */
+  OnTheLeft = 1,
+  /** Apply transformation on the right. */
+  OnTheRight = 2
+};
+
+/** \ingroup enums
+ * Enum for specifying NaN-propagation behavior, e.g. for coeff-wise min/max. */
+enum NaNPropagationOptions {
+  /**  Implementation defined behavior if NaNs are present. */
+  PropagateFast = 0,
+  /**  Always propagate NaNs. */
+  PropagateNaN,
+  /**  Always propagate not-NaNs. */
+  PropagateNumbers
+};
+
+/* the following used to be written as:
+ *
+ *   struct NoChange_t {};
+ *   namespace {
+ *     EIGEN_UNUSED NoChange_t NoChange;
+ *   }
+ *
+ * on the ground that it feels dangerous to disambiguate overloaded functions on enum/integer types.  
+ * However, this leads to "variable declared but never referenced" warnings on Intel Composer XE,
+ * and we do not know how to get rid of them (bug 450).
+ */
+
+enum NoChange_t   { NoChange };
+enum Sequential_t { Sequential };
+enum Default_t    { Default };
+
+/** \internal \ingroup enums
+  * Used in AmbiVector. */
+enum AmbiVectorMode {
+  IsDense         = 0,
+  IsSparse
+};
+
+/** \ingroup enums
+  * Used as template parameter in DenseCoeffBase and MapBase to indicate 
+  * which accessors should be provided. */
+enum AccessorLevels {
+  /** Read-only access via a member function. */
+  ReadOnlyAccessors, 
+  /** Read/write access via member functions. */
+  WriteAccessors, 
+  /** Direct read-only access to the coefficients. */
+  DirectAccessors, 
+  /** Direct read/write access to the coefficients. */
+  DirectWriteAccessors
+};
+
+/** \ingroup enums
+  * Enum with options to give to various decompositions. */
+enum DecompositionOptions {
+  /** \internal Not used (meant for LDLT?). */
+  Pivoting            = 0x01, 
+  /** \internal Not used (meant for LDLT?). */
+  NoPivoting          = 0x02, 
+  /** Used in JacobiSVD to indicate that the square matrix U is to be computed. */
+  ComputeFullU        = 0x04,
+  /** Used in JacobiSVD to indicate that the thin matrix U is to be computed. */
+  ComputeThinU        = 0x08,
+  /** Used in JacobiSVD to indicate that the square matrix V is to be computed. */
+  ComputeFullV        = 0x10,
+  /** Used in JacobiSVD to indicate that the thin matrix V is to be computed. */
+  ComputeThinV        = 0x20,
+  /** Used in SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver to specify
+    * that only the eigenvalues are to be computed and not the eigenvectors. */
+  EigenvaluesOnly     = 0x40,
+  /** Used in SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver to specify
+    * that both the eigenvalues and the eigenvectors are to be computed. */
+  ComputeEigenvectors = 0x80,
+  /** \internal */
+  EigVecMask = EigenvaluesOnly | ComputeEigenvectors,
+  /** Used in GeneralizedSelfAdjointEigenSolver to indicate that it should
+    * solve the generalized eigenproblem \f$ Ax = \lambda B x \f$. */
+  Ax_lBx              = 0x100,
+  /** Used in GeneralizedSelfAdjointEigenSolver to indicate that it should
+    * solve the generalized eigenproblem \f$ ABx = \lambda x \f$. */
+  ABx_lx              = 0x200,
+  /** Used in GeneralizedSelfAdjointEigenSolver to indicate that it should
+    * solve the generalized eigenproblem \f$ BAx = \lambda x \f$. */
+  BAx_lx              = 0x400,
+  /** \internal */
+  GenEigMask = Ax_lBx | ABx_lx | BAx_lx
+};
+
+/** \ingroup enums
+  * Possible values for the \p QRPreconditioner template parameter of JacobiSVD. */
+enum QRPreconditioners {
+  /** Do not specify what is to be done if the SVD of a non-square matrix is asked for. */
+  NoQRPreconditioner,
+  /** Use a QR decomposition without pivoting as the first step. */
+  HouseholderQRPreconditioner,
+  /** Use a QR decomposition with column pivoting as the first step. */
+  ColPivHouseholderQRPreconditioner,
+  /** Use a QR decomposition with full pivoting as the first step. */
+  FullPivHouseholderQRPreconditioner
+};
+
+#ifdef Success
+#error The preprocessor symbol 'Success' is defined, possibly by the X11 header file X.h
+#endif
+
+/** \ingroup enums
+  * Enum for reporting the status of a computation. */
+enum ComputationInfo {
+  /** Computation was successful. */
+  Success = 0,        
+  /** The provided data did not satisfy the prerequisites. */
+  NumericalIssue = 1, 
+  /** Iterative procedure did not converge. */
+  NoConvergence = 2,
+  /** The inputs are invalid, or the algorithm has been improperly called.
+    * When assertions are enabled, such errors trigger an assert. */
+  InvalidInput = 3
+};
+
+/** \ingroup enums
+  * Enum used to specify how a particular transformation is stored in a matrix.
+  * \sa Transform, Hyperplane::transform(). */
+enum TransformTraits {
+  /** Transformation is an isometry. */
+  Isometry      = 0x1,
+  /** Transformation is an affine transformation stored as a (Dim+1)^2 matrix whose last row is 
+    * assumed to be [0 ... 0 1]. */
+  Affine        = 0x2,
+  /** Transformation is an affine transformation stored as a (Dim) x (Dim+1) matrix. */
+  AffineCompact = 0x10 | Affine,
+  /** Transformation is a general projective transformation stored as a (Dim+1)^2 matrix. */
+  Projective    = 0x20
+};
+
+/** \internal \ingroup enums
+  * Enum used to choose between implementation depending on the computer architecture. */
+namespace Architecture
+{
+  enum Type {
+    Generic = 0x0,
+    SSE = 0x1,
+    AltiVec = 0x2,
+    VSX = 0x3,
+    NEON = 0x4,
+    MSA = 0x5,
+    SVE = 0x6,
+#if defined EIGEN_VECTORIZE_SSE
+    Target = SSE
+#elif defined EIGEN_VECTORIZE_ALTIVEC
+    Target = AltiVec
+#elif defined EIGEN_VECTORIZE_VSX
+    Target = VSX
+#elif defined EIGEN_VECTORIZE_NEON
+    Target = NEON
+#elif defined EIGEN_VECTORIZE_SVE
+    Target = SVE
+#elif defined EIGEN_VECTORIZE_MSA
+    Target = MSA
+#else
+    Target = Generic
+#endif
+  };
+}
+
+/** \internal \ingroup enums
+  * Enum used as template parameter in Product and product evaluators. */
+enum ProductImplType
+{ DefaultProduct=0, LazyProduct, AliasFreeProduct, CoeffBasedProductMode, LazyCoeffBasedProductMode, OuterProduct, InnerProduct, GemvProduct, GemmProduct };
+
+/** \internal \ingroup enums
+  * Enum used in experimental parallel implementation. */
+enum Action {GetAction, SetAction};
+
+/** The type used to identify a dense storage. */
+struct Dense {};
+
+/** The type used to identify a general sparse storage. */
+struct Sparse {};
+
+/** The type used to identify a general solver (factored) storage. */
+struct SolverStorage {};
+
+/** The type used to identify a permutation storage. */
+struct PermutationStorage {};
+
+/** The type used to identify a permutation storage. */
+struct TranspositionsStorage {};
+
+/** The type used to identify a matrix expression */
+struct MatrixXpr {};
+
+/** The type used to identify an array expression */
+struct ArrayXpr {};
+
+// An evaluator must define its shape. By default, it can be one of the following:
+struct DenseShape             { static std::string debugName() { return "DenseShape"; } };
+struct SolverShape            { static std::string debugName() { return "SolverShape"; } };
+struct HomogeneousShape       { static std::string debugName() { return "HomogeneousShape"; } };
+struct DiagonalShape          { static std::string debugName() { return "DiagonalShape"; } };
+struct BandShape              { static std::string debugName() { return "BandShape"; } };
+struct TriangularShape        { static std::string debugName() { return "TriangularShape"; } };
+struct SelfAdjointShape       { static std::string debugName() { return "SelfAdjointShape"; } };
+struct PermutationShape       { static std::string debugName() { return "PermutationShape"; } };
+struct TranspositionsShape    { static std::string debugName() { return "TranspositionsShape"; } };
+struct SparseShape            { static std::string debugName() { return "SparseShape"; } };
+
+namespace internal {
+
+  // random access iterators based on coeff*() accessors.
+struct IndexBased {};
+
+// evaluator based on iterators to access coefficients. 
+struct IteratorBased {};
+
+/** \internal
+ * Constants for comparison functors
+ */
+enum ComparisonName {
+  cmp_EQ = 0,
+  cmp_LT = 1,
+  cmp_LE = 2,
+  cmp_UNORD = 3,
+  cmp_NEQ = 4,
+  cmp_GT = 5,
+  cmp_GE = 6
+};
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_CONSTANTS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/DisableStupidWarnings.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/DisableStupidWarnings.h
new file mode 100644
index 00000000..fe0cfec0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/DisableStupidWarnings.h
@@ -0,0 +1,106 @@
+#ifndef EIGEN_WARNINGS_DISABLED
+#define EIGEN_WARNINGS_DISABLED
+
+#ifdef _MSC_VER
+  // 4100 - unreferenced formal parameter (occurred e.g. in aligned_allocator::destroy(pointer p))
+  // 4101 - unreferenced local variable
+  // 4181 - qualifier applied to reference type ignored
+  // 4211 - nonstandard extension used : redefined extern to static
+  // 4244 - 'argument' : conversion from 'type1' to 'type2', possible loss of data
+  // 4273 - QtAlignedMalloc, inconsistent DLL linkage
+  // 4324 - structure was padded due to declspec(align())
+  // 4503 - decorated name length exceeded, name was truncated
+  // 4512 - assignment operator could not be generated
+  // 4522 - 'class' : multiple assignment operators specified
+  // 4700 - uninitialized local variable 'xyz' used
+  // 4714 - function marked as __forceinline not inlined
+  // 4717 - 'function' : recursive on all control paths, function will cause runtime stack overflow
+  // 4800 - 'type' : forcing value to bool 'true' or 'false' (performance warning)
+  #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+    #pragma warning( push )
+  #endif
+  #pragma warning( disable : 4100 4101 4181 4211 4244 4273 4324 4503 4512 4522 4700 4714 4717 4800)
+
+#elif defined __INTEL_COMPILER
+  // 2196 - routine is both "inline" and "noinline" ("noinline" assumed)
+  //        ICC 12 generates this warning even without any inline keyword, when defining class methods 'inline' i.e. inside of class body
+  //        typedef that may be a reference type.
+  // 279  - controlling expression is constant
+  //        ICC 12 generates this warning on assert(constant_expression_depending_on_template_params) and frankly this is a legitimate use case.
+  // 1684 - conversion from pointer to same-sized integral type (potential portability problem)
+  // 2259 - non-pointer conversion from "Eigen::Index={ptrdiff_t={long}}" to "int" may lose significant bits
+  #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+    #pragma warning push
+  #endif
+  #pragma warning disable 2196 279 1684 2259
+
+#elif defined __clang__
+  // -Wconstant-logical-operand - warning: use of logical && with constant operand; switch to bitwise & or remove constant
+  //     this is really a stupid warning as it warns on compile-time expressions involving enums
+  #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+    #pragma clang diagnostic push
+  #endif
+  #pragma clang diagnostic ignored "-Wconstant-logical-operand"
+  #if __clang_major__ >= 3 && __clang_minor__ >= 5
+    #pragma clang diagnostic ignored "-Wabsolute-value"
+  #endif
+  #if __clang_major__ >= 10
+    #pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
+  #endif
+  #if ( defined(__ALTIVEC__) || defined(__VSX__) ) && __cplusplus < 201103L
+    // warning: generic selections are a C11-specific feature
+    // ignoring warnings thrown at vec_ctf in Altivec/PacketMath.h
+    #pragma clang diagnostic ignored "-Wc11-extensions"
+  #endif
+
+#elif defined __GNUC__
+
+  #if (!defined(EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS)) &&  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+    #pragma GCC diagnostic push
+  #endif
+  // g++ warns about local variables shadowing member functions, which is too strict
+  #pragma GCC diagnostic ignored "-Wshadow"
+  #if __GNUC__ == 4 && __GNUC_MINOR__ < 8
+    // Until g++-4.7 there are warnings when comparing unsigned int vs 0, even in templated functions:
+    #pragma GCC diagnostic ignored "-Wtype-limits"
+  #endif
+  #if __GNUC__>=6
+    #pragma GCC diagnostic ignored "-Wignored-attributes"
+  #endif
+  #if __GNUC__==7
+    // See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89325
+    #pragma GCC diagnostic ignored "-Wattributes"
+  #endif
+#endif
+
+#if defined __NVCC__
+  #pragma diag_suppress boolean_controlling_expr_is_constant
+  // Disable the "statement is unreachable" message
+  #pragma diag_suppress code_is_unreachable
+  // Disable the "dynamic initialization in unreachable code" message
+  #pragma diag_suppress initialization_not_reachable
+  // Disable the "invalid error number" message that we get with older versions of nvcc
+  #pragma diag_suppress 1222
+  // Disable the "calling a __host__ function from a __host__ __device__ function is not allowed" messages (yes, there are many of them and they seem to change with every version of the compiler)
+  #pragma diag_suppress 2527
+  #pragma diag_suppress 2529
+  #pragma diag_suppress 2651
+  #pragma diag_suppress 2653
+  #pragma diag_suppress 2668
+  #pragma diag_suppress 2669
+  #pragma diag_suppress 2670
+  #pragma diag_suppress 2671
+  #pragma diag_suppress 2735
+  #pragma diag_suppress 2737
+  #pragma diag_suppress 2739
+#endif
+
+#else
+// warnings already disabled:
+# ifndef EIGEN_WARNINGS_DISABLED_2
+#  define EIGEN_WARNINGS_DISABLED_2
+# elif defined(EIGEN_INTERNAL_DEBUGGING)
+#  error "Do not include \"DisableStupidWarnings.h\" recursively more than twice!"
+# endif
+
+#endif // not EIGEN_WARNINGS_DISABLED
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ForwardDeclarations.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ForwardDeclarations.h
new file mode 100644
index 00000000..2f9cc449
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ForwardDeclarations.h
@@ -0,0 +1,322 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FORWARDDECLARATIONS_H
+#define EIGEN_FORWARDDECLARATIONS_H
+
+namespace Eigen {
+namespace internal {
+
+template<typename T> struct traits;
+
+// here we say once and for all that traits<const T> == traits<T>
+// When constness must affect traits, it has to be constness on template parameters on which T itself depends.
+// For example, traits<Map<const T> > != traits<Map<T> >, but
+//              traits<const Map<T> > == traits<Map<T> >
+template<typename T> struct traits<const T> : traits<T> {};
+
+template<typename Derived> struct has_direct_access
+{
+  enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 };
+};
+
+template<typename Derived> struct accessors_level
+{
+  enum { has_direct_access = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0,
+         has_write_access = (traits<Derived>::Flags & LvalueBit) ? 1 : 0,
+         value = has_direct_access ? (has_write_access ? DirectWriteAccessors : DirectAccessors)
+                                   : (has_write_access ? WriteAccessors       : ReadOnlyAccessors)
+  };
+};
+
+template<typename T> struct evaluator_traits;
+
+template< typename T> struct evaluator;
+
+} // end namespace internal
+
+template<typename T> struct NumTraits;
+
+template<typename Derived> struct EigenBase;
+template<typename Derived> class DenseBase;
+template<typename Derived> class PlainObjectBase;
+template<typename Derived, int Level> class DenseCoeffsBase;
+
+template<typename _Scalar, int _Rows, int _Cols,
+         int _Options = AutoAlign |
+#if EIGEN_GNUC_AT(3,4)
+    // workaround a bug in at least gcc 3.4.6
+    // the innermost ?: ternary operator is misparsed. We write it slightly
+    // differently and this makes gcc 3.4.6 happy, but it's ugly.
+    // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
+    // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
+                          : Eigen::ColMajor ),
+#else
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor
+                          : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
+#endif
+         int _MaxRows = _Rows,
+         int _MaxCols = _Cols
+> class Matrix;
+
+template<typename Derived> class MatrixBase;
+template<typename Derived> class ArrayBase;
+
+template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged;
+template<typename ExpressionType, template <typename> class StorageBase > class NoAlias;
+template<typename ExpressionType> class NestByValue;
+template<typename ExpressionType> class ForceAlignedAccess;
+template<typename ExpressionType> class SwapWrapper;
+
+template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false> class Block;
+template<typename XprType, typename RowIndices, typename ColIndices> class IndexedView;
+template<typename XprType, int Rows=Dynamic, int Cols=Dynamic, int Order=0> class Reshaped;
+
+template<typename MatrixType, int Size=Dynamic> class VectorBlock;
+template<typename MatrixType> class Transpose;
+template<typename MatrixType> class Conjugate;
+template<typename NullaryOp, typename MatrixType>         class CwiseNullaryOp;
+template<typename UnaryOp,   typename MatrixType>         class CwiseUnaryOp;
+template<typename ViewOp,    typename MatrixType>         class CwiseUnaryView;
+template<typename BinaryOp,  typename Lhs, typename Rhs>  class CwiseBinaryOp;
+template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>  class CwiseTernaryOp;
+template<typename Decomposition, typename Rhstype>        class Solve;
+template<typename XprType>                                class Inverse;
+
+template<typename Lhs, typename Rhs, int Option = DefaultProduct> class Product;
+
+template<typename Derived> class DiagonalBase;
+template<typename _DiagonalVectorType> class DiagonalWrapper;
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
+template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
+template<typename MatrixType, int Index = 0> class Diagonal;
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix;
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions;
+template<typename Derived> class PermutationBase;
+template<typename Derived> class TranspositionsBase;
+template<typename _IndicesType> class PermutationWrapper;
+template<typename _IndicesType> class TranspositionsWrapper;
+
+template<typename Derived,
+         int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
+> class MapBase;
+template<int OuterStrideAtCompileTime, int InnerStrideAtCompileTime> class Stride;
+template<int Value = Dynamic> class InnerStride;
+template<int Value = Dynamic> class OuterStride;
+template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map;
+template<typename Derived> class RefBase;
+template<typename PlainObjectType, int Options = 0,
+         typename StrideType = typename internal::conditional<PlainObjectType::IsVectorAtCompileTime,InnerStride<1>,OuterStride<> >::type > class Ref;
+
+template<typename Derived> class TriangularBase;
+template<typename MatrixType, unsigned int Mode> class TriangularView;
+template<typename MatrixType, unsigned int Mode> class SelfAdjointView;
+template<typename MatrixType> class SparseView;
+template<typename ExpressionType> class WithFormat;
+template<typename MatrixType> struct CommaInitializer;
+template<typename Derived> class ReturnByValue;
+template<typename ExpressionType> class ArrayWrapper;
+template<typename ExpressionType> class MatrixWrapper;
+template<typename Derived> class SolverBase;
+template<typename XprType> class InnerIterator;
+
+namespace internal {
+template<typename XprType> class generic_randaccess_stl_iterator;
+template<typename XprType> class pointer_based_stl_iterator;
+template<typename XprType, DirectionType Direction> class subvector_stl_iterator;
+template<typename XprType, DirectionType Direction> class subvector_stl_reverse_iterator;
+template<typename DecompositionType> struct kernel_retval_base;
+template<typename DecompositionType> struct kernel_retval;
+template<typename DecompositionType> struct image_retval_base;
+template<typename DecompositionType> struct image_retval;
+} // end namespace internal
+
+namespace internal {
+template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix;
+}
+
+namespace internal {
+template<typename Lhs, typename Rhs> struct product_type;
+
+template<bool> struct EnableIf;
+
+/** \internal
+  * \class product_evaluator
+  * Products need their own evaluator with more template arguments allowing for
+  * easier partial template specializations.
+  */
+template< typename T,
+          int ProductTag = internal::product_type<typename T::Lhs,typename T::Rhs>::ret,
+          typename LhsShape = typename evaluator_traits<typename T::Lhs>::Shape,
+          typename RhsShape = typename evaluator_traits<typename T::Rhs>::Shape,
+          typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
+          typename RhsScalar = typename traits<typename T::Rhs>::Scalar
+        > struct product_evaluator;
+}
+
+template<typename Lhs, typename Rhs,
+         int ProductType = internal::product_type<Lhs,Rhs>::value>
+struct ProductReturnType;
+
+// this is a workaround for sun CC
+template<typename Lhs, typename Rhs> struct LazyProductReturnType;
+
+namespace internal {
+
+// Provides scalar/packet-wise product and product with accumulation
+// with optional conjugation of the arguments.
+template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
+
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_sum_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_difference_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_conj_product_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar, int NaNPropagation=PropagateFast> struct scalar_min_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar, int NaNPropagation=PropagateFast> struct scalar_max_op;
+template<typename Scalar> struct scalar_opposite_op;
+template<typename Scalar> struct scalar_conjugate_op;
+template<typename Scalar> struct scalar_real_op;
+template<typename Scalar> struct scalar_imag_op;
+template<typename Scalar> struct scalar_abs_op;
+template<typename Scalar> struct scalar_abs2_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_absolute_difference_op;
+template<typename Scalar> struct scalar_sqrt_op;
+template<typename Scalar> struct scalar_rsqrt_op;
+template<typename Scalar> struct scalar_exp_op;
+template<typename Scalar> struct scalar_log_op;
+template<typename Scalar> struct scalar_cos_op;
+template<typename Scalar> struct scalar_sin_op;
+template<typename Scalar> struct scalar_acos_op;
+template<typename Scalar> struct scalar_asin_op;
+template<typename Scalar> struct scalar_tan_op;
+template<typename Scalar> struct scalar_inverse_op;
+template<typename Scalar> struct scalar_square_op;
+template<typename Scalar> struct scalar_cube_op;
+template<typename Scalar, typename NewType> struct scalar_cast_op;
+template<typename Scalar> struct scalar_random_op;
+template<typename Scalar> struct scalar_constant_op;
+template<typename Scalar> struct scalar_identity_op;
+template<typename Scalar,bool is_complex, bool is_integer> struct scalar_sign_op;
+template<typename Scalar,typename ScalarExponent> struct scalar_pow_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_hypot_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op;
+template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_quotient_op;
+
+// SpecialFunctions module
+template<typename Scalar> struct scalar_lgamma_op;
+template<typename Scalar> struct scalar_digamma_op;
+template<typename Scalar> struct scalar_erf_op;
+template<typename Scalar> struct scalar_erfc_op;
+template<typename Scalar> struct scalar_ndtri_op;
+template<typename Scalar> struct scalar_igamma_op;
+template<typename Scalar> struct scalar_igammac_op;
+template<typename Scalar> struct scalar_zeta_op;
+template<typename Scalar> struct scalar_betainc_op;
+
+// Bessel functions in SpecialFunctions module
+template<typename Scalar> struct scalar_bessel_i0_op;
+template<typename Scalar> struct scalar_bessel_i0e_op;
+template<typename Scalar> struct scalar_bessel_i1_op;
+template<typename Scalar> struct scalar_bessel_i1e_op;
+template<typename Scalar> struct scalar_bessel_j0_op;
+template<typename Scalar> struct scalar_bessel_y0_op;
+template<typename Scalar> struct scalar_bessel_j1_op;
+template<typename Scalar> struct scalar_bessel_y1_op;
+template<typename Scalar> struct scalar_bessel_k0_op;
+template<typename Scalar> struct scalar_bessel_k0e_op;
+template<typename Scalar> struct scalar_bessel_k1_op;
+template<typename Scalar> struct scalar_bessel_k1e_op;
+
+
+} // end namespace internal
+
+struct IOFormat;
+
+// Array module
+template<typename _Scalar, int _Rows, int _Cols,
+         int _Options = AutoAlign |
+#if EIGEN_GNUC_AT(3,4)
+    // workaround a bug in at least gcc 3.4.6
+    // the innermost ?: ternary operator is misparsed. We write it slightly
+    // differently and this makes gcc 3.4.6 happy, but it's ugly.
+    // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
+    // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
+                          : Eigen::ColMajor ),
+#else
+                          ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
+                          : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor
+                          : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
+#endif
+         int _MaxRows = _Rows, int _MaxCols = _Cols> class Array;
+template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select;
+template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
+template<typename ExpressionType, int Direction> class VectorwiseOp;
+template<typename MatrixType,int RowFactor,int ColFactor> class Replicate;
+template<typename MatrixType, int Direction = BothDirections> class Reverse;
+
+template<typename MatrixType> class FullPivLU;
+template<typename MatrixType> class PartialPivLU;
+namespace internal {
+template<typename MatrixType> struct inverse_impl;
+}
+template<typename MatrixType> class HouseholderQR;
+template<typename MatrixType> class ColPivHouseholderQR;
+template<typename MatrixType> class FullPivHouseholderQR;
+template<typename MatrixType> class CompleteOrthogonalDecomposition;
+template<typename MatrixType> class SVDBase;
+template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD;
+template<typename MatrixType> class BDCSVD;
+template<typename MatrixType, int UpLo = Lower> class LLT;
+template<typename MatrixType, int UpLo = Lower> class LDLT;
+template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence;
+template<typename Scalar>     class JacobiRotation;
+
+// Geometry module:
+template<typename Derived, int _Dim> class RotationBase;
+template<typename Lhs, typename Rhs> class Cross;
+template<typename Derived> class QuaternionBase;
+template<typename Scalar> class Rotation2D;
+template<typename Scalar> class AngleAxis;
+template<typename Scalar,int Dim> class Translation;
+template<typename Scalar,int Dim> class AlignedBox;
+template<typename Scalar, int Options = AutoAlign> class Quaternion;
+template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform;
+template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine;
+template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane;
+template<typename Scalar> class UniformScaling;
+template<typename MatrixType,int Direction> class Homogeneous;
+
+// Sparse module:
+template<typename Derived> class SparseMatrixBase;
+
+// MatrixFunctions module
+template<typename Derived> struct MatrixExponentialReturnValue;
+template<typename Derived> class MatrixFunctionReturnValue;
+template<typename Derived> class MatrixSquareRootReturnValue;
+template<typename Derived> class MatrixLogarithmReturnValue;
+template<typename Derived> class MatrixPowerReturnValue;
+template<typename Derived> class MatrixComplexPowerReturnValue;
+
+namespace internal {
+template <typename Scalar>
+struct stem_function
+{
+  typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
+  typedef ComplexScalar type(ComplexScalar, int);
+};
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FORWARDDECLARATIONS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/IndexedViewHelper.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/IndexedViewHelper.h
new file mode 100644
index 00000000..f85de305
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/IndexedViewHelper.h
@@ -0,0 +1,186 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_INDEXED_VIEW_HELPER_H
+#define EIGEN_INDEXED_VIEW_HELPER_H
+
+namespace Eigen {
+
+namespace internal {
+struct symbolic_last_tag {};
+}
+
+/** \var last
+  * \ingroup Core_Module
+  *
+  * Can be used as a parameter to Eigen::seq and Eigen::seqN functions to symbolically reference the last element/row/columns
+  * of the underlying vector or matrix once passed to DenseBase::operator()(const RowIndices&, const ColIndices&).
+  *
+  * This symbolic placeholder supports standard arithmetic operations.
+  *
+  * A typical usage example would be:
+  * \code
+  * using namespace Eigen;
+  * using Eigen::last;
+  * VectorXd v(n);
+  * v(seq(2,last-2)).setOnes();
+  * \endcode
+  *
+  * \sa end
+  */
+static const symbolic::SymbolExpr<internal::symbolic_last_tag> last; // PLEASE use Eigen::last   instead of Eigen::placeholders::last
+
+/** \var lastp1
+  * \ingroup Core_Module
+  *
+  * Can be used as a parameter to Eigen::seq and Eigen::seqN functions to symbolically
+  * reference the last+1 element/row/columns of the underlying vector or matrix once
+  * passed to DenseBase::operator()(const RowIndices&, const ColIndices&).
+  *
+  * This symbolic placeholder supports standard arithmetic operations.
+  * It is essentially an alias to last+fix<1>.
+  *
+  * \sa last
+  */
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+static const auto lastp1 = last+fix<1>;
+#else
+// Using a FixedExpr<1> expression is important here to make sure the compiler
+// can fully optimize the computation starting indices with zero overhead.
+static const symbolic::AddExpr<symbolic::SymbolExpr<internal::symbolic_last_tag>,symbolic::ValueExpr<Eigen::internal::FixedInt<1> > > lastp1(last+fix<1>());
+#endif
+
+namespace internal {
+
+ // Replace symbolic last/end "keywords" by their true runtime value
+inline Index eval_expr_given_size(Index x, Index /* size */)   { return x; }
+
+template<int N>
+FixedInt<N> eval_expr_given_size(FixedInt<N> x, Index /*size*/)   { return x; }
+
+template<typename Derived>
+Index eval_expr_given_size(const symbolic::BaseExpr<Derived> &x, Index size)
+{
+  return x.derived().eval(last=size-1);
+}
+
+// Extract increment/step at compile time
+template<typename T, typename EnableIf = void> struct get_compile_time_incr {
+  enum { value = UndefinedIncr };
+};
+
+// Analogue of std::get<0>(x), but tailored for our needs.
+template<typename T>
+EIGEN_CONSTEXPR Index first(const T& x) EIGEN_NOEXCEPT { return x.first(); }
+
+// IndexedViewCompatibleType/makeIndexedViewCompatible turn an arbitrary object of type T into something usable by MatrixSlice
+// The generic implementation is a no-op
+template<typename T,int XprSize,typename EnableIf=void>
+struct IndexedViewCompatibleType {
+  typedef T type;
+};
+
+template<typename T,typename Q>
+const T& makeIndexedViewCompatible(const T& x, Index /*size*/, Q) { return x; }
+
+//--------------------------------------------------------------------------------
+// Handling of a single Index
+//--------------------------------------------------------------------------------
+
+struct SingleRange {
+  enum {
+    SizeAtCompileTime = 1
+  };
+  SingleRange(Index val) : m_value(val) {}
+  Index operator[](Index) const { return m_value; }
+  static EIGEN_CONSTEXPR Index size() EIGEN_NOEXCEPT { return 1; }
+  Index first() const EIGEN_NOEXCEPT { return m_value; }
+  Index m_value;
+};
+
+template<> struct get_compile_time_incr<SingleRange> {
+  enum { value = 1 }; // 1 or 0 ??
+};
+
+// Turn a single index into something that looks like an array (i.e., that exposes a .size(), and operator[](int) methods)
+template<typename T, int XprSize>
+struct IndexedViewCompatibleType<T,XprSize,typename internal::enable_if<internal::is_integral<T>::value>::type> {
+  // Here we could simply use Array, but maybe it's less work for the compiler to use
+  // a simpler wrapper as SingleRange
+  //typedef Eigen::Array<Index,1,1> type;
+  typedef SingleRange type;
+};
+
+template<typename T, int XprSize>
+struct IndexedViewCompatibleType<T, XprSize, typename enable_if<symbolic::is_symbolic<T>::value>::type> {
+  typedef SingleRange type;
+};
+
+
+template<typename T>
+typename enable_if<symbolic::is_symbolic<T>::value,SingleRange>::type
+makeIndexedViewCompatible(const T& id, Index size, SpecializedType) {
+  return eval_expr_given_size(id,size);
+}
+
+//--------------------------------------------------------------------------------
+// Handling of all
+//--------------------------------------------------------------------------------
+
+struct all_t { all_t() {} };
+
+// Convert a symbolic 'all' into a usable range type
+template<int XprSize>
+struct AllRange {
+  enum { SizeAtCompileTime = XprSize };
+  AllRange(Index size = XprSize) : m_size(size) {}
+  EIGEN_CONSTEXPR Index operator[](Index i) const EIGEN_NOEXCEPT { return i; }
+  EIGEN_CONSTEXPR Index size() const EIGEN_NOEXCEPT { return m_size.value(); }
+  EIGEN_CONSTEXPR Index first() const EIGEN_NOEXCEPT { return 0; }
+  variable_if_dynamic<Index,XprSize> m_size;
+};
+
+template<int XprSize>
+struct IndexedViewCompatibleType<all_t,XprSize> {
+  typedef AllRange<XprSize> type;
+};
+
+template<typename XprSizeType>
+inline AllRange<get_fixed_value<XprSizeType>::value> makeIndexedViewCompatible(all_t , XprSizeType size, SpecializedType) {
+  return AllRange<get_fixed_value<XprSizeType>::value>(size);
+}
+
+template<int Size> struct get_compile_time_incr<AllRange<Size> > {
+  enum { value = 1 };
+};
+
+} // end namespace internal
+
+
+/** \var all
+  * \ingroup Core_Module
+  * Can be used as a parameter to DenseBase::operator()(const RowIndices&, const ColIndices&) to index all rows or columns
+  */
+static const Eigen::internal::all_t all; // PLEASE use Eigen::all instead of Eigen::placeholders::all
+
+
+namespace placeholders {
+  typedef symbolic::SymbolExpr<internal::symbolic_last_tag> last_t;
+  typedef symbolic::AddExpr<symbolic::SymbolExpr<internal::symbolic_last_tag>,symbolic::ValueExpr<Eigen::internal::FixedInt<1> > > end_t;
+  typedef Eigen::internal::all_t all_t;
+
+  EIGEN_DEPRECATED static const all_t  all  = Eigen::all;    // PLEASE use Eigen::all    instead of Eigen::placeholders::all
+  EIGEN_DEPRECATED static const last_t last = Eigen::last;   // PLEASE use Eigen::last   instead of Eigen::placeholders::last
+  EIGEN_DEPRECATED static const end_t  end  = Eigen::lastp1; // PLEASE use Eigen::lastp1 instead of Eigen::placeholders::end
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_INDEXED_VIEW_HELPER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/IntegralConstant.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/IntegralConstant.h
new file mode 100644
index 00000000..945d426e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/IntegralConstant.h
@@ -0,0 +1,272 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_INTEGRAL_CONSTANT_H
+#define EIGEN_INTEGRAL_CONSTANT_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<int N> class FixedInt;
+template<int N> class VariableAndFixedInt;
+
+/** \internal
+  * \class FixedInt
+  *
+  * This class embeds a compile-time integer \c N.
+  *
+  * It is similar to c++11 std::integral_constant<int,N> but with some additional features
+  * such as:
+  *  - implicit conversion to int
+  *  - arithmetic and some bitwise operators: -, +, *, /, %, &, |
+  *  - c++98/14 compatibility with fix<N> and fix<N>() syntax to define integral constants.
+  *
+  * It is strongly discouraged to directly deal with this class FixedInt. Instances are expcected to
+  * be created by the user using Eigen::fix<N> or Eigen::fix<N>(). In C++98-11, the former syntax does
+  * not create a FixedInt<N> instance but rather a point to function that needs to be \em cleaned-up
+  * using the generic helper:
+  * \code
+  * internal::cleanup_index_type<T>::type
+  * internal::cleanup_index_type<T,DynamicKey>::type
+  * \endcode
+  * where T can a FixedInt<N>, a pointer to function FixedInt<N> (*)(), or numerous other integer-like representations.
+  * \c DynamicKey is either Dynamic (default) or DynamicIndex and used to identify true compile-time values.
+  *
+  * For convenience, you can extract the compile-time value \c N in a generic way using the following helper:
+  * \code
+  * internal::get_fixed_value<T,DefaultVal>::value
+  * \endcode
+  * that will give you \c N if T equals FixedInt<N> or FixedInt<N> (*)(), and \c DefaultVal if T does not embed any compile-time value (e.g., T==int).
+  *
+  * \sa fix<N>, class VariableAndFixedInt
+  */
+template<int N> class FixedInt
+{
+public:
+  static const int value = N;
+  EIGEN_CONSTEXPR operator int() const { return value; }
+  FixedInt() {}
+  FixedInt( VariableAndFixedInt<N> other) {
+    #ifndef EIGEN_INTERNAL_DEBUGGING
+    EIGEN_UNUSED_VARIABLE(other);
+    #endif
+    eigen_internal_assert(int(other)==N);
+  }
+
+  FixedInt<-N> operator-() const { return FixedInt<-N>(); }
+  template<int M>
+  FixedInt<N+M> operator+( FixedInt<M>) const { return FixedInt<N+M>(); }
+  template<int M>
+  FixedInt<N-M> operator-( FixedInt<M>) const { return FixedInt<N-M>(); }
+  template<int M>
+  FixedInt<N*M> operator*( FixedInt<M>) const { return FixedInt<N*M>(); }
+  template<int M>
+  FixedInt<N/M> operator/( FixedInt<M>) const { return FixedInt<N/M>(); }
+  template<int M>
+  FixedInt<N%M> operator%( FixedInt<M>) const { return FixedInt<N%M>(); }
+  template<int M>
+  FixedInt<N|M> operator|( FixedInt<M>) const { return FixedInt<N|M>(); }
+  template<int M>
+  FixedInt<N&M> operator&( FixedInt<M>) const { return FixedInt<N&M>(); }
+
+#if EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
+  // Needed in C++14 to allow fix<N>():
+  FixedInt operator() () const { return *this; }
+
+  VariableAndFixedInt<N> operator() (int val) const { return VariableAndFixedInt<N>(val); }
+#else
+  FixedInt ( FixedInt<N> (*)() ) {}
+#endif
+
+#if EIGEN_HAS_CXX11
+  FixedInt(std::integral_constant<int,N>) {}
+#endif
+};
+
+/** \internal
+  * \class VariableAndFixedInt
+  *
+  * This class embeds both a compile-time integer \c N and a runtime integer.
+  * Both values are supposed to be equal unless the compile-time value \c N has a special
+  * value meaning that the runtime-value should be used. Depending on the context, this special
+  * value can be either Eigen::Dynamic (for positive quantities) or Eigen::DynamicIndex (for
+  * quantities that can be negative).
+  *
+  * It is the return-type of the function Eigen::fix<N>(int), and most of the time this is the only
+  * way it is used. It is strongly discouraged to directly deal with instances of VariableAndFixedInt.
+  * Indeed, in order to write generic code, it is the responsibility of the callee to properly convert
+  * it to either a true compile-time quantity (i.e. a FixedInt<N>), or to a runtime quantity (e.g., an Index)
+  * using the following generic helper:
+  * \code
+  * internal::cleanup_index_type<T>::type
+  * internal::cleanup_index_type<T,DynamicKey>::type
+  * \endcode
+  * where T can be a template instantiation of VariableAndFixedInt or numerous other integer-like representations.
+  * \c DynamicKey is either Dynamic (default) or DynamicIndex and used to identify true compile-time values.
+  *
+  * For convenience, you can also extract the compile-time value \c N using the following helper:
+  * \code
+  * internal::get_fixed_value<T,DefaultVal>::value
+  * \endcode
+  * that will give you \c N if T equals VariableAndFixedInt<N>, and \c DefaultVal if T does not embed any compile-time value (e.g., T==int).
+  *
+  * \sa fix<N>(int), class FixedInt
+  */
+template<int N> class VariableAndFixedInt
+{
+public:
+  static const int value = N;
+  operator int() const { return m_value; }
+  VariableAndFixedInt(int val) { m_value = val; }
+protected:
+  int m_value;
+};
+
+template<typename T, int Default=Dynamic> struct get_fixed_value {
+  static const int value = Default;
+};
+
+template<int N,int Default> struct get_fixed_value<FixedInt<N>,Default> {
+  static const int value = N;
+};
+
+#if !EIGEN_HAS_CXX14
+template<int N,int Default> struct get_fixed_value<FixedInt<N> (*)(),Default> {
+  static const int value = N;
+};
+#endif
+
+template<int N,int Default> struct get_fixed_value<VariableAndFixedInt<N>,Default> {
+  static const int value = N ;
+};
+
+template<typename T, int N, int Default>
+struct get_fixed_value<variable_if_dynamic<T,N>,Default> {
+  static const int value = N;
+};
+
+template<typename T> EIGEN_DEVICE_FUNC Index get_runtime_value(const T &x) { return x; }
+#if !EIGEN_HAS_CXX14
+template<int N> EIGEN_DEVICE_FUNC Index get_runtime_value(FixedInt<N> (*)()) { return N; }
+#endif
+
+// Cleanup integer/FixedInt/VariableAndFixedInt/etc types:
+
+// By default, no cleanup:
+template<typename T, int DynamicKey=Dynamic, typename EnableIf=void> struct cleanup_index_type { typedef T type; };
+
+// Convert any integral type (e.g., short, int, unsigned int, etc.) to Eigen::Index
+template<typename T, int DynamicKey> struct cleanup_index_type<T,DynamicKey,typename internal::enable_if<internal::is_integral<T>::value>::type> { typedef Index type; };
+
+#if !EIGEN_HAS_CXX14
+// In c++98/c++11, fix<N> is a pointer to function that we better cleanup to a true FixedInt<N>:
+template<int N, int DynamicKey> struct cleanup_index_type<FixedInt<N> (*)(), DynamicKey> { typedef FixedInt<N> type; };
+#endif
+
+// If VariableAndFixedInt does not match DynamicKey, then we turn it to a pure compile-time value:
+template<int N, int DynamicKey> struct cleanup_index_type<VariableAndFixedInt<N>, DynamicKey> { typedef FixedInt<N> type; };
+// If VariableAndFixedInt matches DynamicKey, then we turn it to a pure runtime-value (aka Index):
+template<int DynamicKey> struct cleanup_index_type<VariableAndFixedInt<DynamicKey>, DynamicKey> { typedef Index type; };
+
+#if EIGEN_HAS_CXX11
+template<int N, int DynamicKey> struct cleanup_index_type<std::integral_constant<int,N>, DynamicKey> { typedef FixedInt<N> type; };
+#endif
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+#if EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
+template<int N>
+static const internal::FixedInt<N> fix{};
+#else
+template<int N>
+inline internal::FixedInt<N> fix() { return internal::FixedInt<N>(); }
+
+// The generic typename T is mandatory. Otherwise, a code like fix<N> could refer to either the function above or this next overload.
+// This way a code like fix<N> can only refer to the previous function.
+template<int N,typename T>
+inline internal::VariableAndFixedInt<N> fix(T val) { return internal::VariableAndFixedInt<N>(internal::convert_index<int>(val)); }
+#endif
+
+#else // EIGEN_PARSED_BY_DOXYGEN
+
+/** \var fix<N>()
+  * \ingroup Core_Module
+  *
+  * This \em identifier permits to construct an object embedding a compile-time integer \c N.
+  *
+  * \tparam N the compile-time integer value
+  *
+  * It is typically used in conjunction with the Eigen::seq and Eigen::seqN functions to pass compile-time values to them:
+  * \code
+  * seqN(10,fix<4>,fix<-3>)   // <=> [10 7 4 1]
+  * \endcode
+  *
+  * See also the function fix(int) to pass both a compile-time and runtime value.
+  *
+  * In c++14, it is implemented as:
+  * \code
+  * template<int N> static const internal::FixedInt<N> fix{};
+  * \endcode
+  * where internal::FixedInt<N> is an internal template class similar to
+  * <a href="http://en.cppreference.com/w/cpp/types/integral_constant">\c std::integral_constant </a><tt> <int,N> </tt>
+  * Here, \c fix<N> is thus an object of type \c internal::FixedInt<N>.
+  *
+  * In c++98/11, it is implemented as a function:
+  * \code
+  * template<int N> inline internal::FixedInt<N> fix();
+  * \endcode
+  * Here internal::FixedInt<N> is thus a pointer to function.
+  *
+  * If for some reason you want a true object in c++98 then you can write: \code fix<N>() \endcode which is also valid in c++14.
+  *
+  * \sa fix<N>(int), seq, seqN
+  */
+template<int N>
+static const auto fix();
+
+/** \fn fix<N>(int)
+  * \ingroup Core_Module
+  *
+  * This function returns an object embedding both a compile-time integer \c N, and a fallback runtime value \a val.
+  *
+  * \tparam N the compile-time integer value
+  * \param  val the fallback runtime integer value
+  *
+  * This function is a more general version of the \ref fix identifier/function that can be used in template code
+  * where the compile-time value could turn out to actually mean "undefined at compile-time". For positive integers
+  * such as a size or a dimension, this case is identified by Eigen::Dynamic, whereas runtime signed integers
+  * (e.g., an increment/stride) are identified as Eigen::DynamicIndex. In such a case, the runtime value \a val
+  * will be used as a fallback.
+  *
+  * A typical use case would be:
+  * \code
+  * template<typename Derived> void foo(const MatrixBase<Derived> &mat) {
+  *   const int N = Derived::RowsAtCompileTime==Dynamic ? Dynamic : Derived::RowsAtCompileTime/2;
+  *   const int n = mat.rows()/2;
+  *   ... mat( seqN(0,fix<N>(n) ) ...;
+  * }
+  * \endcode
+  * In this example, the function Eigen::seqN knows that the second argument is expected to be a size.
+  * If the passed compile-time value N equals Eigen::Dynamic, then the proxy object returned by fix will be dissmissed, and converted to an Eigen::Index of value \c n.
+  * Otherwise, the runtime-value \c n will be dissmissed, and the returned ArithmeticSequence will be of the exact same type as <tt> seqN(0,fix<N>) </tt>.
+  *
+  * \sa fix, seqN, class ArithmeticSequence
+  */
+template<int N>
+static const auto fix(int val);
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+} // end namespace Eigen
+
+#endif // EIGEN_INTEGRAL_CONSTANT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/MKL_support.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/MKL_support.h
new file mode 100644
index 00000000..17963fad
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/MKL_support.h
@@ -0,0 +1,137 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to Intel(R) MKL
+ *   Include file with common MKL declarations
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_MKL_SUPPORT_H
+#define EIGEN_MKL_SUPPORT_H
+
+#ifdef EIGEN_USE_MKL_ALL
+  #ifndef EIGEN_USE_BLAS
+    #define EIGEN_USE_BLAS
+  #endif
+  #ifndef EIGEN_USE_LAPACKE
+    #define EIGEN_USE_LAPACKE
+  #endif
+  #ifndef EIGEN_USE_MKL_VML
+    #define EIGEN_USE_MKL_VML
+  #endif
+#endif
+
+#ifdef EIGEN_USE_LAPACKE_STRICT
+  #define EIGEN_USE_LAPACKE
+#endif
+
+#if defined(EIGEN_USE_MKL_VML) && !defined(EIGEN_USE_MKL)
+  #define EIGEN_USE_MKL
+#endif
+
+
+#if defined EIGEN_USE_MKL
+#   if (!defined MKL_DIRECT_CALL) && (!defined EIGEN_MKL_NO_DIRECT_CALL)
+#       define MKL_DIRECT_CALL
+#       define MKL_DIRECT_CALL_JUST_SET
+#   endif
+#   include <mkl.h>
+/*Check IMKL version for compatibility: < 10.3 is not usable with Eigen*/
+#   ifndef INTEL_MKL_VERSION
+#       undef EIGEN_USE_MKL /* INTEL_MKL_VERSION is not even defined on older versions */
+#   elif INTEL_MKL_VERSION < 100305    /* the intel-mkl-103-release-notes say this was when the lapacke.h interface was added*/
+#       undef EIGEN_USE_MKL
+#   endif
+#   ifndef EIGEN_USE_MKL
+    /*If the MKL version is too old, undef everything*/
+#       undef   EIGEN_USE_MKL_ALL
+#       undef   EIGEN_USE_LAPACKE
+#       undef   EIGEN_USE_MKL_VML
+#       undef   EIGEN_USE_LAPACKE_STRICT
+#       undef   EIGEN_USE_LAPACKE
+#       ifdef   MKL_DIRECT_CALL_JUST_SET
+#           undef MKL_DIRECT_CALL
+#       endif
+#   endif
+#endif
+
+#if defined EIGEN_USE_MKL
+
+#define EIGEN_MKL_VML_THRESHOLD 128
+
+/* MKL_DOMAIN_BLAS, etc are defined only in 10.3 update 7 */
+/* MKL_BLAS, etc are not defined in 11.2 */
+#ifdef MKL_DOMAIN_ALL
+#define EIGEN_MKL_DOMAIN_ALL MKL_DOMAIN_ALL
+#else
+#define EIGEN_MKL_DOMAIN_ALL MKL_ALL
+#endif
+
+#ifdef MKL_DOMAIN_BLAS
+#define EIGEN_MKL_DOMAIN_BLAS MKL_DOMAIN_BLAS
+#else
+#define EIGEN_MKL_DOMAIN_BLAS MKL_BLAS
+#endif
+
+#ifdef MKL_DOMAIN_FFT
+#define EIGEN_MKL_DOMAIN_FFT MKL_DOMAIN_FFT
+#else
+#define EIGEN_MKL_DOMAIN_FFT MKL_FFT
+#endif
+
+#ifdef MKL_DOMAIN_VML
+#define EIGEN_MKL_DOMAIN_VML MKL_DOMAIN_VML
+#else
+#define EIGEN_MKL_DOMAIN_VML MKL_VML
+#endif
+
+#ifdef MKL_DOMAIN_PARDISO
+#define EIGEN_MKL_DOMAIN_PARDISO MKL_DOMAIN_PARDISO
+#else
+#define EIGEN_MKL_DOMAIN_PARDISO MKL_PARDISO
+#endif
+#endif
+
+#if defined(EIGEN_USE_BLAS) && !defined(EIGEN_USE_MKL)
+#include "../../misc/blas.h"
+#endif
+
+namespace Eigen {
+
+typedef std::complex<double> dcomplex;
+typedef std::complex<float>  scomplex;
+
+#if defined(EIGEN_USE_MKL)
+typedef MKL_INT BlasIndex;
+#else
+typedef int BlasIndex;
+#endif
+
+} // end namespace Eigen
+
+
+#endif // EIGEN_MKL_SUPPORT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Macros.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Macros.h
new file mode 100644
index 00000000..986c3d44
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Macros.h
@@ -0,0 +1,1464 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MACROS_H
+#define EIGEN_MACROS_H
+
+//------------------------------------------------------------------------------------------
+// Eigen version and basic defaults
+//------------------------------------------------------------------------------------------
+
+#define EIGEN_WORLD_VERSION 3
+#define EIGEN_MAJOR_VERSION 4
+#define EIGEN_MINOR_VERSION 0
+
+#define EIGEN_VERSION_AT_LEAST(x,y,z) (EIGEN_WORLD_VERSION>x || (EIGEN_WORLD_VERSION>=x && \
+                                      (EIGEN_MAJOR_VERSION>y || (EIGEN_MAJOR_VERSION>=y && \
+                                                                 EIGEN_MINOR_VERSION>=z))))
+
+#ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
+#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION Eigen::RowMajor
+#else
+#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION Eigen::ColMajor
+#endif
+
+#ifndef EIGEN_DEFAULT_DENSE_INDEX_TYPE
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE std::ptrdiff_t
+#endif
+
+// Upperbound on the C++ version to use.
+// Expected values are 03, 11, 14, 17, etc.
+// By default, let's use an arbitrarily large C++ version.
+#ifndef EIGEN_MAX_CPP_VER
+#define EIGEN_MAX_CPP_VER 99
+#endif
+
+/** Allows to disable some optimizations which might affect the accuracy of the result.
+  * Such optimization are enabled by default, and set EIGEN_FAST_MATH to 0 to disable them.
+  * They currently include:
+  *   - single precision ArrayBase::sin() and ArrayBase::cos() for SSE and AVX vectorization.
+  */
+#ifndef EIGEN_FAST_MATH
+#define EIGEN_FAST_MATH 1
+#endif
+
+#ifndef EIGEN_STACK_ALLOCATION_LIMIT
+// 131072 == 128 KB
+#define EIGEN_STACK_ALLOCATION_LIMIT 131072
+#endif
+
+//------------------------------------------------------------------------------------------
+// Compiler identification, EIGEN_COMP_*
+//------------------------------------------------------------------------------------------
+
+/// \internal EIGEN_COMP_GNUC set to 1 for all compilers compatible with GCC
+#ifdef __GNUC__
+  #define EIGEN_COMP_GNUC (__GNUC__*10+__GNUC_MINOR__)
+#else
+  #define EIGEN_COMP_GNUC 0
+#endif
+
+/// \internal EIGEN_COMP_CLANG set to major+minor version (e.g., 307 for clang 3.7) if the compiler is clang
+#if defined(__clang__)
+  #define EIGEN_COMP_CLANG (__clang_major__*100+__clang_minor__)
+#else
+  #define EIGEN_COMP_CLANG 0
+#endif
+
+/// \internal EIGEN_COMP_CASTXML set to 1 if being preprocessed by CastXML
+#if defined(__castxml__)
+  #define EIGEN_COMP_CASTXML 1
+#else
+  #define EIGEN_COMP_CASTXML 0
+#endif
+
+/// \internal EIGEN_COMP_LLVM set to 1 if the compiler backend is llvm
+#if defined(__llvm__)
+  #define EIGEN_COMP_LLVM 1
+#else
+  #define EIGEN_COMP_LLVM 0
+#endif
+
+/// \internal EIGEN_COMP_ICC set to __INTEL_COMPILER if the compiler is Intel compiler, 0 otherwise
+#if defined(__INTEL_COMPILER)
+  #define EIGEN_COMP_ICC __INTEL_COMPILER
+#else
+  #define EIGEN_COMP_ICC 0
+#endif
+
+/// \internal EIGEN_COMP_MINGW set to 1 if the compiler is mingw
+#if defined(__MINGW32__)
+  #define EIGEN_COMP_MINGW 1
+#else
+  #define EIGEN_COMP_MINGW 0
+#endif
+
+/// \internal EIGEN_COMP_SUNCC set to 1 if the compiler is Solaris Studio
+#if defined(__SUNPRO_CC)
+  #define EIGEN_COMP_SUNCC 1
+#else
+  #define EIGEN_COMP_SUNCC 0
+#endif
+
+/// \internal EIGEN_COMP_MSVC set to _MSC_VER if the compiler is Microsoft Visual C++, 0 otherwise.
+#if defined(_MSC_VER)
+  #define EIGEN_COMP_MSVC _MSC_VER
+#else
+  #define EIGEN_COMP_MSVC 0
+#endif
+
+#if defined(__NVCC__)
+#if defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 9)
+  #define EIGEN_COMP_NVCC  ((__CUDACC_VER_MAJOR__ * 10000) + (__CUDACC_VER_MINOR__ * 100))
+#elif defined(__CUDACC_VER__)
+  #define EIGEN_COMP_NVCC __CUDACC_VER__
+#else
+  #error "NVCC did not define compiler version."
+#endif
+#else
+  #define EIGEN_COMP_NVCC 0
+#endif
+
+// For the record, here is a table summarizing the possible values for EIGEN_COMP_MSVC:
+//  name        ver   MSC_VER
+//  2008         9      1500
+//  2010        10      1600
+//  2012        11      1700
+//  2013        12      1800
+//  2015        14      1900
+//  "15"        15      1900
+//  2017-14.1   15.0    1910
+//  2017-14.11  15.3    1911
+//  2017-14.12  15.5    1912
+//  2017-14.13  15.6    1913
+//  2017-14.14  15.7    1914
+
+/// \internal EIGEN_COMP_MSVC_LANG set to _MSVC_LANG if the compiler is Microsoft Visual C++, 0 otherwise.
+#if defined(_MSVC_LANG)
+  #define EIGEN_COMP_MSVC_LANG _MSVC_LANG
+#else
+  #define EIGEN_COMP_MSVC_LANG 0
+#endif
+
+// For the record, here is a table summarizing the possible values for EIGEN_COMP_MSVC_LANG:
+// MSVC option                          Standard  MSVC_LANG
+// /std:c++14 (default as of VS 2019)   C++14     201402L
+// /std:c++17                           C++17     201703L
+// /std:c++latest                       >C++17    >201703L
+
+/// \internal EIGEN_COMP_MSVC_STRICT set to 1 if the compiler is really Microsoft Visual C++ and not ,e.g., ICC or clang-cl
+#if EIGEN_COMP_MSVC && !(EIGEN_COMP_ICC || EIGEN_COMP_LLVM || EIGEN_COMP_CLANG)
+  #define EIGEN_COMP_MSVC_STRICT _MSC_VER
+#else
+  #define EIGEN_COMP_MSVC_STRICT 0
+#endif
+
+/// \internal EIGEN_COMP_IBM set to xlc version if the compiler is IBM XL C++
+// XLC   version
+// 3.1   0x0301
+// 4.5   0x0405
+// 5.0   0x0500
+// 12.1  0x0C01
+#if defined(__IBMCPP__) || defined(__xlc__) || defined(__ibmxl__)
+  #define EIGEN_COMP_IBM __xlC__
+#else
+  #define EIGEN_COMP_IBM 0
+#endif
+
+/// \internal EIGEN_COMP_PGI set to PGI version if the compiler is Portland Group Compiler
+#if defined(__PGI)
+  #define EIGEN_COMP_PGI (__PGIC__*100+__PGIC_MINOR__)
+#else
+  #define EIGEN_COMP_PGI 0
+#endif
+
+/// \internal EIGEN_COMP_ARM set to 1 if the compiler is ARM Compiler
+#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
+  #define EIGEN_COMP_ARM 1
+#else
+  #define EIGEN_COMP_ARM 0
+#endif
+
+/// \internal EIGEN_COMP_EMSCRIPTEN set to 1 if the compiler is Emscripten Compiler
+#if defined(__EMSCRIPTEN__)
+  #define EIGEN_COMP_EMSCRIPTEN 1
+#else
+  #define EIGEN_COMP_EMSCRIPTEN 0
+#endif
+
+
+/// \internal EIGEN_GNUC_STRICT set to 1 if the compiler is really GCC and not a compatible compiler (e.g., ICC, clang, mingw, etc.)
+#if EIGEN_COMP_GNUC && !(EIGEN_COMP_CLANG || EIGEN_COMP_ICC || EIGEN_COMP_MINGW || EIGEN_COMP_PGI || EIGEN_COMP_IBM || EIGEN_COMP_ARM || EIGEN_COMP_EMSCRIPTEN)
+  #define EIGEN_COMP_GNUC_STRICT 1
+#else
+  #define EIGEN_COMP_GNUC_STRICT 0
+#endif
+
+
+#if EIGEN_COMP_GNUC
+  #define EIGEN_GNUC_AT_LEAST(x,y) ((__GNUC__==x && __GNUC_MINOR__>=y) || __GNUC__>x)
+  #define EIGEN_GNUC_AT_MOST(x,y)  ((__GNUC__==x && __GNUC_MINOR__<=y) || __GNUC__<x)
+  #define EIGEN_GNUC_AT(x,y)       ( __GNUC__==x && __GNUC_MINOR__==y )
+#else
+  #define EIGEN_GNUC_AT_LEAST(x,y) 0
+  #define EIGEN_GNUC_AT_MOST(x,y)  0
+  #define EIGEN_GNUC_AT(x,y)       0
+#endif
+
+// FIXME: could probably be removed as we do not support gcc 3.x anymore
+#if EIGEN_COMP_GNUC && (__GNUC__ <= 3)
+#define EIGEN_GCC3_OR_OLDER 1
+#else
+#define EIGEN_GCC3_OR_OLDER 0
+#endif
+
+
+
+//------------------------------------------------------------------------------------------
+// Architecture identification, EIGEN_ARCH_*
+//------------------------------------------------------------------------------------------
+
+
+#if defined(__x86_64__) || (defined(_M_X64) && !defined(_M_ARM64EC)) || defined(__amd64)
+  #define EIGEN_ARCH_x86_64 1
+#else
+  #define EIGEN_ARCH_x86_64 0
+#endif
+
+#if defined(__i386__) || defined(_M_IX86) || defined(_X86_) || defined(__i386)
+  #define EIGEN_ARCH_i386 1
+#else
+  #define EIGEN_ARCH_i386 0
+#endif
+
+#if EIGEN_ARCH_x86_64 || EIGEN_ARCH_i386
+  #define EIGEN_ARCH_i386_OR_x86_64 1
+#else
+  #define EIGEN_ARCH_i386_OR_x86_64 0
+#endif
+
+/// \internal EIGEN_ARCH_ARM set to 1 if the architecture is ARM
+#if defined(__arm__)
+  #define EIGEN_ARCH_ARM 1
+#else
+  #define EIGEN_ARCH_ARM 0
+#endif
+
+/// \internal EIGEN_ARCH_ARM64 set to 1 if the architecture is ARM64
+#if defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC)
+  #define EIGEN_ARCH_ARM64 1
+#else
+  #define EIGEN_ARCH_ARM64 0
+#endif
+
+/// \internal EIGEN_ARCH_ARM_OR_ARM64 set to 1 if the architecture is ARM or ARM64
+#if EIGEN_ARCH_ARM || EIGEN_ARCH_ARM64
+  #define EIGEN_ARCH_ARM_OR_ARM64 1
+#else
+  #define EIGEN_ARCH_ARM_OR_ARM64 0
+#endif
+
+/// \internal EIGEN_ARCH_ARMV8 set to 1 if the architecture is armv8 or greater.
+#if EIGEN_ARCH_ARM_OR_ARM64 && defined(__ARM_ARCH) && __ARM_ARCH >= 8
+#define EIGEN_ARCH_ARMV8 1
+#else
+#define EIGEN_ARCH_ARMV8 0
+#endif
+
+
+/// \internal EIGEN_HAS_ARM64_FP16 set to 1 if the architecture provides an IEEE
+/// compliant Arm fp16 type
+#if EIGEN_ARCH_ARM64
+  #ifndef EIGEN_HAS_ARM64_FP16
+    #if defined(__ARM_FP16_FORMAT_IEEE)
+      #define EIGEN_HAS_ARM64_FP16 1
+    #else
+      #define EIGEN_HAS_ARM64_FP16 0
+    #endif
+  #endif
+#endif
+
+/// \internal EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC set to 1 if the architecture
+/// supports Neon vector intrinsics for fp16.
+#if EIGEN_ARCH_ARM64
+  #ifndef EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+    #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
+      #define EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC 1
+    #else
+      #define EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC 0
+    #endif
+  #endif
+#endif
+
+/// \internal EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC set to 1 if the architecture
+/// supports Neon scalar intrinsics for fp16.
+#if EIGEN_ARCH_ARM64
+  #ifndef EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC
+    #if defined(__ARM_FEATURE_FP16_SCALAR_ARITHMETIC)
+      #define EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC 1
+    #endif
+  #endif
+#endif
+
+/// \internal EIGEN_ARCH_MIPS set to 1 if the architecture is MIPS
+#if defined(__mips__) || defined(__mips)
+  #define EIGEN_ARCH_MIPS 1
+#else
+  #define EIGEN_ARCH_MIPS 0
+#endif
+
+/// \internal EIGEN_ARCH_SPARC set to 1 if the architecture is SPARC
+#if defined(__sparc__) || defined(__sparc)
+  #define EIGEN_ARCH_SPARC 1
+#else
+  #define EIGEN_ARCH_SPARC 0
+#endif
+
+/// \internal EIGEN_ARCH_IA64 set to 1 if the architecture is Intel Itanium
+#if defined(__ia64__)
+  #define EIGEN_ARCH_IA64 1
+#else
+  #define EIGEN_ARCH_IA64 0
+#endif
+
+/// \internal EIGEN_ARCH_PPC set to 1 if the architecture is PowerPC
+#if defined(__powerpc__) || defined(__ppc__) || defined(_M_PPC)
+  #define EIGEN_ARCH_PPC 1
+#else
+  #define EIGEN_ARCH_PPC 0
+#endif
+
+
+
+//------------------------------------------------------------------------------------------
+// Operating system identification, EIGEN_OS_*
+//------------------------------------------------------------------------------------------
+
+/// \internal EIGEN_OS_UNIX set to 1 if the OS is a unix variant
+#if defined(__unix__) || defined(__unix)
+  #define EIGEN_OS_UNIX 1
+#else
+  #define EIGEN_OS_UNIX 0
+#endif
+
+/// \internal EIGEN_OS_LINUX set to 1 if the OS is based on Linux kernel
+#if defined(__linux__)
+  #define EIGEN_OS_LINUX 1
+#else
+  #define EIGEN_OS_LINUX 0
+#endif
+
+/// \internal EIGEN_OS_ANDROID set to 1 if the OS is Android
+// note: ANDROID is defined when using ndk_build, __ANDROID__ is defined when using a standalone toolchain.
+#if defined(__ANDROID__) || defined(ANDROID)
+  #define EIGEN_OS_ANDROID 1
+#else
+  #define EIGEN_OS_ANDROID 0
+#endif
+
+/// \internal EIGEN_OS_GNULINUX set to 1 if the OS is GNU Linux and not Linux-based OS (e.g., not android)
+#if defined(__gnu_linux__) && !(EIGEN_OS_ANDROID)
+  #define EIGEN_OS_GNULINUX 1
+#else
+  #define EIGEN_OS_GNULINUX 0
+#endif
+
+/// \internal EIGEN_OS_BSD set to 1 if the OS is a BSD variant
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__)
+  #define EIGEN_OS_BSD 1
+#else
+  #define EIGEN_OS_BSD 0
+#endif
+
+/// \internal EIGEN_OS_MAC set to 1 if the OS is MacOS
+#if defined(__APPLE__)
+  #define EIGEN_OS_MAC 1
+#else
+  #define EIGEN_OS_MAC 0
+#endif
+
+/// \internal EIGEN_OS_QNX set to 1 if the OS is QNX
+#if defined(__QNX__)
+  #define EIGEN_OS_QNX 1
+#else
+  #define EIGEN_OS_QNX 0
+#endif
+
+/// \internal EIGEN_OS_WIN set to 1 if the OS is Windows based
+#if defined(_WIN32)
+  #define EIGEN_OS_WIN 1
+#else
+  #define EIGEN_OS_WIN 0
+#endif
+
+/// \internal EIGEN_OS_WIN64 set to 1 if the OS is Windows 64bits
+#if defined(_WIN64)
+  #define EIGEN_OS_WIN64 1
+#else
+  #define EIGEN_OS_WIN64 0
+#endif
+
+/// \internal EIGEN_OS_WINCE set to 1 if the OS is Windows CE
+#if defined(_WIN32_WCE)
+  #define EIGEN_OS_WINCE 1
+#else
+  #define EIGEN_OS_WINCE 0
+#endif
+
+/// \internal EIGEN_OS_CYGWIN set to 1 if the OS is Windows/Cygwin
+#if defined(__CYGWIN__)
+  #define EIGEN_OS_CYGWIN 1
+#else
+  #define EIGEN_OS_CYGWIN 0
+#endif
+
+/// \internal EIGEN_OS_WIN_STRICT set to 1 if the OS is really Windows and not some variants
+#if EIGEN_OS_WIN && !( EIGEN_OS_WINCE || EIGEN_OS_CYGWIN )
+  #define EIGEN_OS_WIN_STRICT 1
+#else
+  #define EIGEN_OS_WIN_STRICT 0
+#endif
+
+/// \internal EIGEN_OS_SUN set to __SUNPRO_C if the OS is SUN
+// compiler  solaris   __SUNPRO_C
+// version   studio
+// 5.7       10        0x570
+// 5.8       11        0x580
+// 5.9       12        0x590
+// 5.10	     12.1      0x5100
+// 5.11	     12.2      0x5110
+// 5.12	     12.3      0x5120
+#if (defined(sun) || defined(__sun)) && !(defined(__SVR4) || defined(__svr4__))
+  #define EIGEN_OS_SUN __SUNPRO_C
+#else
+  #define EIGEN_OS_SUN 0
+#endif
+
+/// \internal EIGEN_OS_SOLARIS set to 1 if the OS is Solaris
+#if (defined(sun) || defined(__sun)) && (defined(__SVR4) || defined(__svr4__))
+  #define EIGEN_OS_SOLARIS 1
+#else
+  #define EIGEN_OS_SOLARIS 0
+#endif
+
+
+//------------------------------------------------------------------------------------------
+// Detect GPU compilers and architectures
+//------------------------------------------------------------------------------------------
+
+// NVCC is not supported as the target platform for HIPCC
+// Note that this also makes EIGEN_CUDACC and EIGEN_HIPCC mutually exclusive
+#if defined(__NVCC__) && defined(__HIPCC__)
+  #error "NVCC as the target platform for HIPCC is currently not supported."
+#endif
+
+#if defined(__CUDACC__) && !defined(EIGEN_NO_CUDA)
+  // Means the compiler is either nvcc or clang with CUDA enabled
+  #define EIGEN_CUDACC __CUDACC__
+#endif
+
+#if defined(__CUDA_ARCH__) && !defined(EIGEN_NO_CUDA)
+  // Means we are generating code for the device
+  #define EIGEN_CUDA_ARCH __CUDA_ARCH__
+#endif
+
+#if defined(EIGEN_CUDACC)
+#include <cuda.h>
+  #define EIGEN_CUDA_SDK_VER (CUDA_VERSION * 10)
+#else
+  #define EIGEN_CUDA_SDK_VER 0
+#endif
+
+#if defined(__HIPCC__) && !defined(EIGEN_NO_HIP)
+  // Means the compiler is HIPCC (analogous to EIGEN_CUDACC, but for HIP)
+  #define EIGEN_HIPCC __HIPCC__
+
+  // We need to include hip_runtime.h here because it pulls in
+  // ++ hip_common.h which contains the define for  __HIP_DEVICE_COMPILE__
+  // ++ host_defines.h which contains the defines for the __host__ and __device__ macros
+  #include <hip/hip_runtime.h>
+
+  #if defined(__HIP_DEVICE_COMPILE__)
+    // analogous to EIGEN_CUDA_ARCH, but for HIP
+    #define EIGEN_HIP_DEVICE_COMPILE __HIP_DEVICE_COMPILE__
+  #endif
+
+  // For HIP (ROCm 3.5 and higher), we need to explicitly set the launch_bounds attribute
+  // value to 1024. The compiler assigns a default value of 256 when the attribute is not
+  // specified. This results in failures on the HIP platform, for cases when a GPU kernel
+  // without an explicit launch_bounds attribute is called with a threads_per_block value
+  // greater than 256.
+  //
+  // This is a regression in functioanlity and is expected to be fixed within the next
+  // couple of ROCm releases (compiler will go back to using 1024 value as the default)
+  //
+  // In the meantime, we will use a "only enabled for HIP" macro to set the launch_bounds
+  // attribute.
+
+  #define EIGEN_HIP_LAUNCH_BOUNDS_1024 __launch_bounds__(1024)
+
+#endif
+
+#if !defined(EIGEN_HIP_LAUNCH_BOUNDS_1024)
+#define EIGEN_HIP_LAUNCH_BOUNDS_1024
+#endif // !defined(EIGEN_HIP_LAUNCH_BOUNDS_1024)
+
+// Unify CUDA/HIPCC
+
+#if defined(EIGEN_CUDACC) || defined(EIGEN_HIPCC)
+//
+// If either EIGEN_CUDACC or EIGEN_HIPCC is defined, then define EIGEN_GPUCC
+//
+#define EIGEN_GPUCC
+//
+// EIGEN_HIPCC implies the HIP compiler and is used to tweak Eigen code for use in HIP kernels
+// EIGEN_CUDACC implies the CUDA compiler and is used to tweak Eigen code for use in CUDA kernels
+//
+// In most cases the same tweaks are required to the Eigen code to enable in both the HIP and CUDA kernels.
+// For those cases, the corresponding code should be guarded with
+//      #if defined(EIGEN_GPUCC)
+// instead of
+//      #if defined(EIGEN_CUDACC) || defined(EIGEN_HIPCC)
+//
+// For cases where the tweak is specific to HIP, the code should be guarded with
+//      #if defined(EIGEN_HIPCC)
+//
+// For cases where the tweak is specific to CUDA, the code should be guarded with
+//      #if defined(EIGEN_CUDACC)
+//
+#endif
+
+#if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIP_DEVICE_COMPILE)
+//
+// If either EIGEN_CUDA_ARCH or EIGEN_HIP_DEVICE_COMPILE is defined, then define EIGEN_GPU_COMPILE_PHASE
+//
+#define EIGEN_GPU_COMPILE_PHASE
+//
+// GPU compilers (HIPCC, NVCC) typically do two passes over the source code,
+//   + one to compile the source for the "host" (ie CPU)
+//   + another to compile the source for the "device" (ie. GPU)
+//
+// Code that needs to enabled only during the either the "host" or "device" compilation phase
+// needs to be guarded with a macro that indicates the current compilation phase
+//
+// EIGEN_HIP_DEVICE_COMPILE implies the device compilation phase in HIP
+// EIGEN_CUDA_ARCH implies the device compilation phase in CUDA
+//
+// In most cases, the "host" / "device" specific code is the same for both HIP and CUDA
+// For those cases, the code should be guarded with
+//       #if defined(EIGEN_GPU_COMPILE_PHASE)
+// instead of
+//       #if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIP_DEVICE_COMPILE)
+//
+// For cases where the tweak is specific to HIP, the code should be guarded with
+//      #if defined(EIGEN_HIP_DEVICE_COMPILE)
+//
+// For cases where the tweak is specific to CUDA, the code should be guarded with
+//      #if defined(EIGEN_CUDA_ARCH)
+//
+#endif
+
+#if defined(EIGEN_USE_SYCL) && defined(__SYCL_DEVICE_ONLY__)
+// EIGEN_USE_SYCL is a user-defined macro while __SYCL_DEVICE_ONLY__ is a compiler-defined macro.
+// In most cases we want to check if both macros are defined which can be done using the define below.
+#define SYCL_DEVICE_ONLY
+#endif
+
+//------------------------------------------------------------------------------------------
+// Detect Compiler/Architecture/OS specific features
+//------------------------------------------------------------------------------------------
+
+#if EIGEN_GNUC_AT_MOST(4,3) && !EIGEN_COMP_CLANG
+  // see bug 89
+  #define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO 0
+#else
+  #define EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO 1
+#endif
+
+// Cross compiler wrapper around LLVM's __has_builtin
+#ifdef __has_builtin
+#  define EIGEN_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#  define EIGEN_HAS_BUILTIN(x) 0
+#endif
+
+// A Clang feature extension to determine compiler features.
+// We use it to determine 'cxx_rvalue_references'
+#ifndef __has_feature
+# define __has_feature(x) 0
+#endif
+
+// Some old compilers do not support template specializations like:
+// template<typename T,int N> void foo(const T x[N]);
+#if !(   EIGEN_COMP_CLANG && (   (EIGEN_COMP_CLANG<309)                                                       \
+                              || (defined(__apple_build_version__) && (__apple_build_version__ < 9000000)))  \
+      || EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC<49)
+#define EIGEN_HAS_STATIC_ARRAY_TEMPLATE 1
+#else
+#define EIGEN_HAS_STATIC_ARRAY_TEMPLATE 0
+#endif
+
+// The macro EIGEN_CPLUSPLUS is a replacement for __cplusplus/_MSVC_LANG that
+// works for both platforms, indicating the C++ standard version number.
+//
+// With MSVC, without defining /Zc:__cplusplus, the __cplusplus macro will
+// report 199711L regardless of the language standard specified via /std.
+// We need to rely on _MSVC_LANG instead, which is only available after
+// VS2015.3.
+#if EIGEN_COMP_MSVC_LANG > 0
+#define EIGEN_CPLUSPLUS EIGEN_COMP_MSVC_LANG
+#elif EIGEN_COMP_MSVC >= 1900
+#define EIGEN_CPLUSPLUS 201103L
+#elif defined(__cplusplus)
+#define EIGEN_CPLUSPLUS __cplusplus
+#else
+#define EIGEN_CPLUSPLUS 0
+#endif
+
+// The macro EIGEN_COMP_CXXVER defines the c++ verson expected by the compiler.
+// For instance, if compiling with gcc and -std=c++17, then EIGEN_COMP_CXXVER
+// is defined to 17.
+#if EIGEN_CPLUSPLUS > 201703L
+  #define EIGEN_COMP_CXXVER 20
+#elif EIGEN_CPLUSPLUS > 201402L
+  #define EIGEN_COMP_CXXVER 17
+#elif EIGEN_CPLUSPLUS > 201103L
+  #define EIGEN_COMP_CXXVER 14
+#elif EIGEN_CPLUSPLUS >= 201103L
+  #define EIGEN_COMP_CXXVER 11
+#else
+  #define EIGEN_COMP_CXXVER 03
+#endif
+
+#ifndef EIGEN_HAS_CXX14_VARIABLE_TEMPLATES
+  #if defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304 && EIGEN_MAX_CPP_VER>=14
+    #define EIGEN_HAS_CXX14_VARIABLE_TEMPLATES 1
+  #else
+    #define EIGEN_HAS_CXX14_VARIABLE_TEMPLATES 0
+  #endif
+#endif
+
+
+// The macros EIGEN_HAS_CXX?? defines a rough estimate of available c++ features
+// but in practice we should not rely on them but rather on the availabilty of
+// individual features as defined later.
+// This is why there is no EIGEN_HAS_CXX17.
+// FIXME: get rid of EIGEN_HAS_CXX14 and maybe even EIGEN_HAS_CXX11.
+#if EIGEN_MAX_CPP_VER>=11 && EIGEN_COMP_CXXVER>=11
+#define EIGEN_HAS_CXX11 1
+#else
+#define EIGEN_HAS_CXX11 0
+#endif
+
+#if EIGEN_MAX_CPP_VER>=14 && EIGEN_COMP_CXXVER>=14
+#define EIGEN_HAS_CXX14 1
+#else
+#define EIGEN_HAS_CXX14 0
+#endif
+
+// Do we support r-value references?
+#ifndef EIGEN_HAS_RVALUE_REFERENCES
+#if EIGEN_MAX_CPP_VER>=11 && \
+    (__has_feature(cxx_rvalue_references) || \
+     (EIGEN_COMP_CXXVER >= 11) || (EIGEN_COMP_MSVC >= 1600))
+  #define EIGEN_HAS_RVALUE_REFERENCES 1
+#else
+  #define EIGEN_HAS_RVALUE_REFERENCES 0
+#endif
+#endif
+
+// Does the compiler support C99?
+// Need to include <cmath> to make sure _GLIBCXX_USE_C99 gets defined
+#include <cmath>
+#ifndef EIGEN_HAS_C99_MATH
+#if EIGEN_MAX_CPP_VER>=11 && \
+    ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901))       \
+  || (defined(__GNUC__) && defined(_GLIBCXX_USE_C99)) \
+  || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER)) \
+  || (EIGEN_COMP_MSVC >= 1900) || defined(SYCL_DEVICE_ONLY))
+  #define EIGEN_HAS_C99_MATH 1
+#else
+  #define EIGEN_HAS_C99_MATH 0
+#endif
+#endif
+
+// Does the compiler support result_of?
+// result_of was deprecated in c++17 and removed in c++ 20
+#ifndef EIGEN_HAS_STD_RESULT_OF
+#if EIGEN_HAS_CXX11 && EIGEN_COMP_CXXVER < 17
+#define EIGEN_HAS_STD_RESULT_OF 1
+#else
+#define EIGEN_HAS_STD_RESULT_OF 0
+#endif
+#endif
+
+// Does the compiler support std::hash?
+#ifndef EIGEN_HAS_STD_HASH
+// The std::hash struct is defined in C++11 but is not labelled as a __device__
+// function and is not constexpr, so cannot be used on device.
+#if EIGEN_HAS_CXX11 && !defined(EIGEN_GPU_COMPILE_PHASE)
+#define EIGEN_HAS_STD_HASH 1
+#else
+#define EIGEN_HAS_STD_HASH 0
+#endif
+#endif  // EIGEN_HAS_STD_HASH
+
+#ifndef EIGEN_HAS_STD_INVOKE_RESULT
+#if EIGEN_MAX_CPP_VER >= 17 && EIGEN_COMP_CXXVER >= 17
+#define EIGEN_HAS_STD_INVOKE_RESULT 1
+#else
+#define EIGEN_HAS_STD_INVOKE_RESULT 0
+#endif
+#endif
+
+#ifndef EIGEN_HAS_ALIGNAS
+#if EIGEN_MAX_CPP_VER>=11 && EIGEN_HAS_CXX11 &&   \
+      (     __has_feature(cxx_alignas)            \
+        ||  EIGEN_HAS_CXX14                       \
+        || (EIGEN_COMP_MSVC >= 1800)              \
+        || (EIGEN_GNUC_AT_LEAST(4,8))             \
+        || (EIGEN_COMP_CLANG>=305)                \
+        || (EIGEN_COMP_ICC>=1500)                 \
+        || (EIGEN_COMP_PGI>=1500)                 \
+        || (EIGEN_COMP_SUNCC>=0x5130))
+#define EIGEN_HAS_ALIGNAS 1
+#else
+#define EIGEN_HAS_ALIGNAS 0
+#endif
+#endif
+
+// Does the compiler support type_traits?
+// - full support of type traits was added only to GCC 5.1.0.
+// - 20150626 corresponds to the last release of 4.x libstdc++
+#ifndef EIGEN_HAS_TYPE_TRAITS
+#if EIGEN_MAX_CPP_VER>=11 && (EIGEN_HAS_CXX11 || EIGEN_COMP_MSVC >= 1700) \
+  && ((!EIGEN_COMP_GNUC_STRICT) || EIGEN_GNUC_AT_LEAST(5, 1)) \
+  && ((!defined(__GLIBCXX__))   || __GLIBCXX__ > 20150626)
+#define EIGEN_HAS_TYPE_TRAITS 1
+#define EIGEN_INCLUDE_TYPE_TRAITS
+#else
+#define EIGEN_HAS_TYPE_TRAITS 0
+#endif
+#endif
+
+// Does the compiler support variadic templates?
+#ifndef EIGEN_HAS_VARIADIC_TEMPLATES
+#if EIGEN_MAX_CPP_VER>=11 && (EIGEN_COMP_CXXVER >= 11) \
+  && (!defined(__NVCC__) || !EIGEN_ARCH_ARM_OR_ARM64 || (EIGEN_COMP_NVCC >= 80000) )
+    // ^^ Disable the use of variadic templates when compiling with versions of nvcc older than 8.0 on ARM devices:
+    //    this prevents nvcc from crashing when compiling Eigen on Tegra X1
+#define EIGEN_HAS_VARIADIC_TEMPLATES 1
+#elif  EIGEN_MAX_CPP_VER>=11 && (EIGEN_COMP_CXXVER >= 11) && defined(SYCL_DEVICE_ONLY)
+#define EIGEN_HAS_VARIADIC_TEMPLATES 1
+#else
+#define EIGEN_HAS_VARIADIC_TEMPLATES 0
+#endif
+#endif
+
+// Does the compiler fully support const expressions? (as in c++14)
+#ifndef EIGEN_HAS_CONSTEXPR
+  #if defined(EIGEN_CUDACC)
+  // Const expressions are supported provided that c++11 is enabled and we're using either clang or nvcc 7.5 or above
+    #if EIGEN_MAX_CPP_VER>=14 && (EIGEN_COMP_CXXVER >= 11 && (EIGEN_COMP_CLANG || EIGEN_COMP_NVCC >= 70500))
+      #define EIGEN_HAS_CONSTEXPR 1
+    #endif
+  #elif EIGEN_MAX_CPP_VER>=14 && (__has_feature(cxx_relaxed_constexpr) || (EIGEN_COMP_CXXVER >= 14) || \
+    (EIGEN_GNUC_AT_LEAST(4,8) && (EIGEN_COMP_CXXVER >= 11)) || \
+    (EIGEN_COMP_CLANG >= 306 && (EIGEN_COMP_CXXVER >= 11)))
+    #define EIGEN_HAS_CONSTEXPR 1
+  #endif
+
+  #ifndef EIGEN_HAS_CONSTEXPR
+    #define EIGEN_HAS_CONSTEXPR 0
+  #endif
+
+#endif // EIGEN_HAS_CONSTEXPR
+
+#if EIGEN_HAS_CONSTEXPR
+#define EIGEN_CONSTEXPR constexpr
+#else
+#define EIGEN_CONSTEXPR
+#endif
+
+// Does the compiler support C++11 math?
+// Let's be conservative and enable the default C++11 implementation only if we are sure it exists
+#ifndef EIGEN_HAS_CXX11_MATH
+  #if EIGEN_MAX_CPP_VER>=11 && ((EIGEN_COMP_CXXVER > 11) || (EIGEN_COMP_CXXVER == 11) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_CLANG || EIGEN_COMP_MSVC || EIGEN_COMP_ICC)  \
+      && (EIGEN_ARCH_i386_OR_x86_64) && (EIGEN_OS_GNULINUX || EIGEN_OS_WIN_STRICT || EIGEN_OS_MAC))
+    #define EIGEN_HAS_CXX11_MATH 1
+  #else
+    #define EIGEN_HAS_CXX11_MATH 0
+  #endif
+#endif
+
+// Does the compiler support proper C++11 containers?
+#ifndef EIGEN_HAS_CXX11_CONTAINERS
+  #if    EIGEN_MAX_CPP_VER>=11 && \
+         ((EIGEN_COMP_CXXVER > 11) \
+      || ((EIGEN_COMP_CXXVER == 11) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_CLANG || EIGEN_COMP_MSVC || EIGEN_COMP_ICC>=1400)))
+    #define EIGEN_HAS_CXX11_CONTAINERS 1
+  #else
+    #define EIGEN_HAS_CXX11_CONTAINERS 0
+  #endif
+#endif
+
+// Does the compiler support C++11 noexcept?
+#ifndef EIGEN_HAS_CXX11_NOEXCEPT
+  #if    EIGEN_MAX_CPP_VER>=11 && \
+         (__has_feature(cxx_noexcept) \
+      || (EIGEN_COMP_CXXVER > 11) \
+      || ((EIGEN_COMP_CXXVER == 11) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_CLANG || EIGEN_COMP_MSVC || EIGEN_COMP_ICC>=1400)))
+    #define EIGEN_HAS_CXX11_NOEXCEPT 1
+  #else
+    #define EIGEN_HAS_CXX11_NOEXCEPT 0
+  #endif
+#endif
+
+#ifndef EIGEN_HAS_CXX11_ATOMIC
+  #if    EIGEN_MAX_CPP_VER>=11 && \
+         (__has_feature(cxx_atomic) \
+      || (EIGEN_COMP_CXXVER > 11) \
+      || ((EIGEN_COMP_CXXVER == 11) && (EIGEN_COMP_MSVC==0 || EIGEN_COMP_MSVC >= 1700)))
+    #define EIGEN_HAS_CXX11_ATOMIC 1
+  #else
+    #define EIGEN_HAS_CXX11_ATOMIC 0
+  #endif
+#endif
+
+#ifndef EIGEN_HAS_CXX11_OVERRIDE_FINAL
+  #if    EIGEN_MAX_CPP_VER>=11 && \
+       (EIGEN_COMP_CXXVER >= 11 || EIGEN_COMP_MSVC >= 1700)
+    #define EIGEN_HAS_CXX11_OVERRIDE_FINAL 1
+  #else
+    #define EIGEN_HAS_CXX11_OVERRIDE_FINAL 0
+  #endif
+#endif
+
+// NOTE: the required Apple's clang version is very conservative
+//       and it could be that XCode 9 works just fine.
+// NOTE: the MSVC version is based on https://en.cppreference.com/w/cpp/compiler_support
+//       and not tested.
+#ifndef EIGEN_HAS_CXX17_OVERALIGN
+#if EIGEN_MAX_CPP_VER>=17 && EIGEN_COMP_CXXVER>=17 && (                                 \
+           (EIGEN_COMP_MSVC >= 1912)                                                    \
+        || (EIGEN_GNUC_AT_LEAST(7,0))                                                   \
+        || ((!defined(__apple_build_version__)) && (EIGEN_COMP_CLANG>=500))             \
+        || (( defined(__apple_build_version__)) && (__apple_build_version__>=10000000)) \
+      )
+#define EIGEN_HAS_CXX17_OVERALIGN 1
+#else
+#define EIGEN_HAS_CXX17_OVERALIGN 0
+#endif
+#endif
+
+#if defined(EIGEN_CUDACC) && EIGEN_HAS_CONSTEXPR
+  // While available already with c++11, this is useful mostly starting with c++14 and relaxed constexpr rules
+  #if defined(__NVCC__)
+    // nvcc considers constexpr functions as __host__ __device__ with the option --expt-relaxed-constexpr
+    #ifdef __CUDACC_RELAXED_CONSTEXPR__
+      #define EIGEN_CONSTEXPR_ARE_DEVICE_FUNC
+    #endif
+  #elif defined(__clang__) && defined(__CUDA__) && __has_feature(cxx_relaxed_constexpr)
+    // clang++ always considers constexpr functions as implicitly __host__ __device__
+    #define EIGEN_CONSTEXPR_ARE_DEVICE_FUNC
+  #endif
+#endif
+
+// Does the compiler support the __int128 and __uint128_t extensions for 128-bit
+// integer arithmetic?
+//
+// Clang and GCC define __SIZEOF_INT128__ when these extensions are supported,
+// but we avoid using them in certain cases:
+//
+// * Building using Clang for Windows, where the Clang runtime library has
+//   128-bit support only on LP64 architectures, but Windows is LLP64.
+#ifndef EIGEN_HAS_BUILTIN_INT128
+#if defined(__SIZEOF_INT128__) && !(EIGEN_OS_WIN && EIGEN_COMP_CLANG)
+#define EIGEN_HAS_BUILTIN_INT128 1
+#else
+#define EIGEN_HAS_BUILTIN_INT128 0
+#endif
+#endif
+
+//------------------------------------------------------------------------------------------
+// Preprocessor programming helpers
+//------------------------------------------------------------------------------------------
+
+// This macro can be used to prevent from macro expansion, e.g.:
+//   std::max EIGEN_NOT_A_MACRO(a,b)
+#define EIGEN_NOT_A_MACRO
+
+#define EIGEN_DEBUG_VAR(x) std::cerr << #x << " = " << x << std::endl;
+
+// concatenate two tokens
+#define EIGEN_CAT2(a,b) a ## b
+#define EIGEN_CAT(a,b) EIGEN_CAT2(a,b)
+
+#define EIGEN_COMMA ,
+
+// convert a token to a string
+#define EIGEN_MAKESTRING2(a) #a
+#define EIGEN_MAKESTRING(a) EIGEN_MAKESTRING2(a)
+
+// EIGEN_STRONG_INLINE is a stronger version of the inline, using __forceinline on MSVC,
+// but it still doesn't use GCC's always_inline. This is useful in (common) situations where MSVC needs forceinline
+// but GCC is still doing fine with just inline.
+#ifndef EIGEN_STRONG_INLINE
+#if (EIGEN_COMP_MSVC || EIGEN_COMP_ICC) && !defined(EIGEN_GPUCC)
+#define EIGEN_STRONG_INLINE __forceinline
+#else
+#define EIGEN_STRONG_INLINE inline
+#endif
+#endif
+
+// EIGEN_ALWAYS_INLINE is the stronget, it has the effect of making the function inline and adding every possible
+// attribute to maximize inlining. This should only be used when really necessary: in particular,
+// it uses __attribute__((always_inline)) on GCC, which most of the time is useless and can severely harm compile times.
+// FIXME with the always_inline attribute,
+// gcc 3.4.x and 4.1 reports the following compilation error:
+//   Eval.h:91: sorry, unimplemented: inlining failed in call to 'const Eigen::Eval<Derived> Eigen::MatrixBase<Scalar, Derived>::eval() const'
+//    : function body not available
+//   See also bug 1367
+#if EIGEN_GNUC_AT_LEAST(4,2) && !defined(SYCL_DEVICE_ONLY)
+#define EIGEN_ALWAYS_INLINE __attribute__((always_inline)) inline
+#else
+#define EIGEN_ALWAYS_INLINE EIGEN_STRONG_INLINE
+#endif
+
+#if EIGEN_COMP_GNUC
+#define EIGEN_DONT_INLINE __attribute__((noinline))
+#elif EIGEN_COMP_MSVC
+#define EIGEN_DONT_INLINE __declspec(noinline)
+#else
+#define EIGEN_DONT_INLINE
+#endif
+
+#if EIGEN_COMP_GNUC
+#define EIGEN_PERMISSIVE_EXPR __extension__
+#else
+#define EIGEN_PERMISSIVE_EXPR
+#endif
+
+// GPU stuff
+
+// Disable some features when compiling with GPU compilers (NVCC/clang-cuda/SYCL/HIPCC)
+#if defined(EIGEN_CUDACC) || defined(SYCL_DEVICE_ONLY) || defined(EIGEN_HIPCC)
+  // Do not try asserts on device code
+  #ifndef EIGEN_NO_DEBUG
+  #define EIGEN_NO_DEBUG
+  #endif
+
+  #ifdef EIGEN_INTERNAL_DEBUGGING
+  #undef EIGEN_INTERNAL_DEBUGGING
+  #endif
+
+  #ifdef EIGEN_EXCEPTIONS
+  #undef EIGEN_EXCEPTIONS
+  #endif
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+  #ifndef EIGEN_DONT_VECTORIZE
+    #define EIGEN_DONT_VECTORIZE
+  #endif
+  #define EIGEN_DEVICE_FUNC __attribute__((flatten)) __attribute__((always_inline))
+// All functions callable from CUDA/HIP code must be qualified with __device__
+#elif defined(EIGEN_GPUCC)
+    #define EIGEN_DEVICE_FUNC __host__ __device__
+#else
+  #define EIGEN_DEVICE_FUNC
+#endif
+
+
+// this macro allows to get rid of linking errors about multiply defined functions.
+//  - static is not very good because it prevents definitions from different object files to be merged.
+//           So static causes the resulting linked executable to be bloated with multiple copies of the same function.
+//  - inline is not perfect either as it unwantedly hints the compiler toward inlining the function.
+#define EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC
+#define EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC inline
+
+#ifdef NDEBUG
+# ifndef EIGEN_NO_DEBUG
+#  define EIGEN_NO_DEBUG
+# endif
+#endif
+
+// eigen_plain_assert is where we implement the workaround for the assert() bug in GCC <= 4.3, see bug 89
+#ifdef EIGEN_NO_DEBUG
+  #ifdef SYCL_DEVICE_ONLY // used to silence the warning on SYCL device
+    #define eigen_plain_assert(x) EIGEN_UNUSED_VARIABLE(x)
+  #else
+    #define eigen_plain_assert(x)
+  #endif
+#else
+  #if EIGEN_SAFE_TO_USE_STANDARD_ASSERT_MACRO
+    namespace Eigen {
+    namespace internal {
+    inline bool copy_bool(bool b) { return b; }
+    }
+    }
+    #define eigen_plain_assert(x) assert(x)
+  #else
+    // work around bug 89
+    #include <cstdlib>   // for abort
+    #include <iostream>  // for std::cerr
+
+    namespace Eigen {
+    namespace internal {
+    // trivial function copying a bool. Must be EIGEN_DONT_INLINE, so we implement it after including Eigen headers.
+    // see bug 89.
+    namespace {
+    EIGEN_DONT_INLINE bool copy_bool(bool b) { return b; }
+    }
+    inline void assert_fail(const char *condition, const char *function, const char *file, int line)
+    {
+      std::cerr << "assertion failed: " << condition << " in function " << function << " at " << file << ":" << line << std::endl;
+      abort();
+    }
+    }
+    }
+    #define eigen_plain_assert(x) \
+      do { \
+        if(!Eigen::internal::copy_bool(x)) \
+          Eigen::internal::assert_fail(EIGEN_MAKESTRING(x), __PRETTY_FUNCTION__, __FILE__, __LINE__); \
+      } while(false)
+  #endif
+#endif
+
+// eigen_assert can be overridden
+#ifndef eigen_assert
+#define eigen_assert(x) eigen_plain_assert(x)
+#endif
+
+#ifdef EIGEN_INTERNAL_DEBUGGING
+#define eigen_internal_assert(x) eigen_assert(x)
+#else
+#define eigen_internal_assert(x)
+#endif
+
+#ifdef EIGEN_NO_DEBUG
+#define EIGEN_ONLY_USED_FOR_DEBUG(x) EIGEN_UNUSED_VARIABLE(x)
+#else
+#define EIGEN_ONLY_USED_FOR_DEBUG(x)
+#endif
+
+#ifndef EIGEN_NO_DEPRECATED_WARNING
+  #if EIGEN_COMP_GNUC
+    #define EIGEN_DEPRECATED __attribute__((deprecated))
+  #elif EIGEN_COMP_MSVC
+    #define EIGEN_DEPRECATED __declspec(deprecated)
+  #else
+    #define EIGEN_DEPRECATED
+  #endif
+#else
+  #define EIGEN_DEPRECATED
+#endif
+
+#if EIGEN_COMP_GNUC
+#define EIGEN_UNUSED __attribute__((unused))
+#else
+#define EIGEN_UNUSED
+#endif
+
+// Suppresses 'unused variable' warnings.
+namespace Eigen {
+  namespace internal {
+    template<typename T> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ignore_unused_variable(const T&) {}
+  }
+}
+#define EIGEN_UNUSED_VARIABLE(var) Eigen::internal::ignore_unused_variable(var);
+
+#if !defined(EIGEN_ASM_COMMENT)
+  #if EIGEN_COMP_GNUC && (EIGEN_ARCH_i386_OR_x86_64 || EIGEN_ARCH_ARM_OR_ARM64)
+    #define EIGEN_ASM_COMMENT(X)  __asm__("#" X)
+  #else
+    #define EIGEN_ASM_COMMENT(X)
+  #endif
+#endif
+
+
+// Acts as a barrier preventing operations involving `X` from crossing. This
+// occurs, for example, in the fast rounding trick where a magic constant is
+// added then subtracted, which is otherwise compiled away with -ffast-math.
+//
+// See bug 1674
+#if !defined(EIGEN_OPTIMIZATION_BARRIER)
+  #if EIGEN_COMP_GNUC
+    // According to https://gcc.gnu.org/onlinedocs/gcc/Constraints.html:
+    //   X: Any operand whatsoever.
+    //   r: A register operand is allowed provided that it is in a general
+    //      register.
+    //   g: Any register, memory or immediate integer operand is allowed, except
+    //      for registers that are not general registers.
+    //   w: (AArch32/AArch64) Floating point register, Advanced SIMD vector
+    //      register or SVE vector register.
+    //   x: (SSE) Any SSE register.
+    //      (AArch64) Like w, but restricted to registers 0 to 15 inclusive.
+    //   v: (PowerPC) An Altivec vector register.
+    //   wa:(PowerPC) A VSX register.
+    //
+    // "X" (uppercase) should work for all cases, though this seems to fail for
+    // some versions of GCC for arm/aarch64 with
+    //   "error: inconsistent operand constraints in an 'asm'"
+    // Clang x86_64/arm/aarch64 seems to require "g" to support both scalars and
+    // vectors, otherwise
+    //   "error: non-trivial scalar-to-vector conversion, possible invalid
+    //    constraint for vector type"
+    //
+    // GCC for ppc64le generates an internal compiler error with x/X/g.
+    // GCC for AVX generates an internal compiler error with X.
+    //
+    // Tested on icc/gcc/clang for sse, avx, avx2, avx512dq
+    //           gcc for arm, aarch64,
+    //           gcc for ppc64le,
+    // both vectors and scalars.
+    //
+    // Note that this is restricted to plain types - this will not work
+    // directly for std::complex<T>, Eigen::half, Eigen::bfloat16. For these,
+    // you will need to apply to the underlying POD type.
+    #if EIGEN_ARCH_PPC && EIGEN_COMP_GNUC_STRICT
+      // This seems to be broken on clang.  Packet4f is loaded into a single
+      //   register rather than a vector, zeroing out some entries.  Integer
+      //   types also generate a compile error.
+      // General, Altivec, VSX.
+      #define EIGEN_OPTIMIZATION_BARRIER(X)  __asm__  ("" : "+r,v,wa" (X));
+    #elif EIGEN_ARCH_ARM_OR_ARM64
+      // General, NEON.
+      #define EIGEN_OPTIMIZATION_BARRIER(X)  __asm__  ("" : "+g,w" (X));
+    #elif EIGEN_ARCH_i386_OR_x86_64
+      // General, SSE.
+      #define EIGEN_OPTIMIZATION_BARRIER(X)  __asm__  ("" : "+g,x" (X));
+    #else
+      // Not implemented for other architectures.
+      #define EIGEN_OPTIMIZATION_BARRIER(X)
+    #endif
+  #else
+    // Not implemented for other compilers.
+    #define EIGEN_OPTIMIZATION_BARRIER(X)
+  #endif
+#endif
+
+#if EIGEN_COMP_MSVC
+  // NOTE MSVC often gives C4127 warnings with compiletime if statements. See bug 1362.
+  // This workaround is ugly, but it does the job.
+#  define EIGEN_CONST_CONDITIONAL(cond)  (void)0, cond
+#else
+#  define EIGEN_CONST_CONDITIONAL(cond)  cond
+#endif
+
+#ifdef EIGEN_DONT_USE_RESTRICT_KEYWORD
+  #define EIGEN_RESTRICT
+#endif
+#ifndef EIGEN_RESTRICT
+  #define EIGEN_RESTRICT __restrict
+#endif
+
+
+#ifndef EIGEN_DEFAULT_IO_FORMAT
+#ifdef EIGEN_MAKING_DOCS
+// format used in Eigen's documentation
+// needed to define it here as escaping characters in CMake add_definition's argument seems very problematic.
+#define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat(3, 0, " ", "\n", "", "")
+#else
+#define EIGEN_DEFAULT_IO_FORMAT Eigen::IOFormat()
+#endif
+#endif
+
+// just an empty macro !
+#define EIGEN_EMPTY
+
+
+// When compiling CUDA/HIP device code with NVCC or HIPCC
+// pull in math functions from the global namespace.
+// In host mode, and when device code is compiled with clang,
+// use the std versions.
+#if (defined(EIGEN_CUDA_ARCH) && defined(__NVCC__)) || defined(EIGEN_HIP_DEVICE_COMPILE)
+  #define EIGEN_USING_STD(FUNC) using ::FUNC;
+#else
+  #define EIGEN_USING_STD(FUNC) using std::FUNC;
+#endif
+
+#if EIGEN_COMP_MSVC_STRICT && (EIGEN_COMP_MSVC < 1900 || (EIGEN_COMP_MSVC == 1900 && EIGEN_COMP_NVCC))
+  // For older MSVC versions, as well as 1900 && CUDA 8, using the base operator is necessary,
+  //   otherwise we get duplicate definition errors
+  // For later MSVC versions, we require explicit operator= definition, otherwise we get
+  //   use of implicitly deleted operator errors.
+  // (cf Bugs 920, 1000, 1324, 2291)
+  #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    using Base::operator =;
+#elif EIGEN_COMP_CLANG // workaround clang bug (see http://forum.kde.org/viewtopic.php?f=74&t=102653)
+  #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    using Base::operator =; \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) { Base::operator=(other); return *this; } \
+    template <typename OtherDerived> \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const DenseBase<OtherDerived>& other) { Base::operator=(other.derived()); return *this; }
+#else
+  #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    using Base::operator =; \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) \
+    { \
+      Base::operator=(other); \
+      return *this; \
+    }
+#endif
+
+
+/**
+ * \internal
+ * \brief Macro to explicitly define the default copy constructor.
+ * This is necessary, because the implicit definition is deprecated if the copy-assignment is overridden.
+ */
+#if EIGEN_HAS_CXX11
+#define EIGEN_DEFAULT_COPY_CONSTRUCTOR(CLASS) CLASS(const CLASS&) = default;
+#else
+#define EIGEN_DEFAULT_COPY_CONSTRUCTOR(CLASS)
+#endif
+
+
+
+/** \internal
+ * \brief Macro to manually inherit assignment operators.
+ * This is necessary, because the implicitly defined assignment operator gets deleted when a custom operator= is defined.
+ * With C++11 or later this also default-implements the copy-constructor
+ */
+#define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived)  \
+    EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) \
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(Derived)
+
+/** \internal
+ * \brief Macro to manually define default constructors and destructors.
+ * This is necessary when the copy constructor is re-defined.
+ * For empty helper classes this should usually be protected, to avoid accidentally creating empty objects.
+ *
+ * Hiding the default destructor lead to problems in C++03 mode together with boost::multiprecision
+ */
+#if EIGEN_HAS_CXX11
+#define EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(Derived)  \
+    Derived() = default; \
+    ~Derived() = default;
+#else
+#define EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(Derived)  \
+    Derived() {}; \
+    /* ~Derived() {}; */
+#endif
+
+
+
+
+
+/**
+* Just a side note. Commenting within defines works only by documenting
+* behind the object (via '!<'). Comments cannot be multi-line and thus
+* we have these extra long lines. What is confusing doxygen over here is
+* that we use '\' and basically have a bunch of typedefs with their
+* documentation in a single line.
+**/
+
+#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
+  typedef typename Eigen::internal::traits<Derived>::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex<float>. */ \
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; /*!< \brief The underlying numeric type for composed scalar types. \details In cases where Scalar is e.g. std::complex<T>, T were corresponding to RealScalar. */ \
+  typedef typename Base::CoeffReturnType CoeffReturnType; /*!< \brief The return type for coefficient access. \details Depending on whether the object allows direct coefficient access (e.g. for a MatrixXd), this type is either 'const Scalar&' or simply 'Scalar' for objects that do not allow direct coefficient access. */ \
+  typedef typename Eigen::internal::ref_selector<Derived>::type Nested; \
+  typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \
+  typedef typename Eigen::internal::traits<Derived>::StorageIndex StorageIndex; \
+  enum CompileTimeTraits \
+      { RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime, \
+        ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime, \
+        Flags = Eigen::internal::traits<Derived>::Flags, \
+        SizeAtCompileTime = Base::SizeAtCompileTime, \
+        MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \
+        IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \
+  using Base::derived; \
+  using Base::const_cast_derived;
+
+
+// FIXME Maybe the EIGEN_DENSE_PUBLIC_INTERFACE could be removed as importing PacketScalar is rarely needed
+#define EIGEN_DENSE_PUBLIC_INTERFACE(Derived) \
+  EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
+  typedef typename Base::PacketScalar PacketScalar;
+
+
+#define EIGEN_PLAIN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b)
+#define EIGEN_PLAIN_ENUM_MAX(a,b) (((int)a >= (int)b) ? (int)a : (int)b)
+
+// EIGEN_SIZE_MIN_PREFER_DYNAMIC gives the min between compile-time sizes. 0 has absolute priority, followed by 1,
+// followed by Dynamic, followed by other finite values. The reason for giving Dynamic the priority over
+// finite values is that min(3, Dynamic) should be Dynamic, since that could be anything between 0 and 3.
+#define EIGEN_SIZE_MIN_PREFER_DYNAMIC(a,b) (((int)a == 0 || (int)b == 0) ? 0 \
+                           : ((int)a == 1 || (int)b == 1) ? 1 \
+                           : ((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
+                           : ((int)a <= (int)b) ? (int)a : (int)b)
+
+// EIGEN_SIZE_MIN_PREFER_FIXED is a variant of EIGEN_SIZE_MIN_PREFER_DYNAMIC comparing MaxSizes. The difference is that finite values
+// now have priority over Dynamic, so that min(3, Dynamic) gives 3. Indeed, whatever the actual value is
+// (between 0 and 3), it is not more than 3.
+#define EIGEN_SIZE_MIN_PREFER_FIXED(a,b)  (((int)a == 0 || (int)b == 0) ? 0 \
+                           : ((int)a == 1 || (int)b == 1) ? 1 \
+                           : ((int)a == Dynamic && (int)b == Dynamic) ? Dynamic \
+                           : ((int)a == Dynamic) ? (int)b \
+                           : ((int)b == Dynamic) ? (int)a \
+                           : ((int)a <= (int)b) ? (int)a : (int)b)
+
+// see EIGEN_SIZE_MIN_PREFER_DYNAMIC. No need for a separate variant for MaxSizes here.
+#define EIGEN_SIZE_MAX(a,b) (((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \
+                           : ((int)a >= (int)b) ? (int)a : (int)b)
+
+#define EIGEN_LOGICAL_XOR(a,b) (((a) || (b)) && !((a) && (b)))
+
+#define EIGEN_IMPLIES(a,b) (!(a) || (b))
+
+#if EIGEN_HAS_BUILTIN(__builtin_expect) || EIGEN_COMP_GNUC
+#define EIGEN_PREDICT_FALSE(x) (__builtin_expect(x, false))
+#define EIGEN_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
+#else
+#define EIGEN_PREDICT_FALSE(x) (x)
+#define EIGEN_PREDICT_TRUE(x) (x)
+#endif
+
+// the expression type of a standard coefficient wise binary operation
+#define EIGEN_CWISE_BINARY_RETURN_TYPE(LHS,RHS,OPNAME) \
+    CwiseBinaryOp< \
+      EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)< \
+          typename internal::traits<LHS>::Scalar, \
+          typename internal::traits<RHS>::Scalar \
+      >, \
+      const LHS, \
+      const RHS \
+    >
+
+#define EIGEN_MAKE_CWISE_BINARY_OP(METHOD,OPNAME) \
+  template<typename OtherDerived> \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,OPNAME) \
+  (METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
+  { \
+    return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,OPNAME)(derived(), other.derived()); \
+  }
+
+#define EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,TYPEA,TYPEB) \
+  (Eigen::internal::has_ReturnType<Eigen::ScalarBinaryOpTraits<TYPEA,TYPEB,EIGEN_CAT(EIGEN_CAT(Eigen::internal::scalar_,OPNAME),_op)<TYPEA,TYPEB>  > >::value)
+
+#define EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(EXPR,SCALAR,OPNAME) \
+  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)<typename internal::traits<EXPR>::Scalar,SCALAR>, const EXPR, \
+                const typename internal::plain_constant_type<EXPR,SCALAR>::type>
+
+#define EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(SCALAR,EXPR,OPNAME) \
+  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)<SCALAR,typename internal::traits<EXPR>::Scalar>, \
+                const typename internal::plain_constant_type<EXPR,SCALAR>::type, const EXPR>
+
+// Workaround for MSVC 2010 (see ML thread "patch with compile for for MSVC 2010")
+#if EIGEN_COMP_MSVC_STRICT && (EIGEN_COMP_MSVC_STRICT<=1600)
+#define EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(X) typename internal::enable_if<true,X>::type
+#else
+#define EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(X) X
+#endif
+
+#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD,OPNAME) \
+  template <typename T> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE \
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,Scalar,T)>::type,OPNAME))\
+  (METHOD)(const T& scalar) const { \
+    typedef typename internal::promote_scalar_arg<Scalar,T,EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,Scalar,T)>::type PromotedT; \
+    return EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,PromotedT,OPNAME)(derived(), \
+           typename internal::plain_constant_type<Derived,PromotedT>::type(derived().rows(), derived().cols(), internal::scalar_constant_op<PromotedT>(scalar))); \
+  }
+
+#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD,OPNAME) \
+  template <typename T> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend \
+  EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,T,Scalar)>::type,Derived,OPNAME)) \
+  (METHOD)(const T& scalar, const StorageBaseType& matrix) { \
+    typedef typename internal::promote_scalar_arg<Scalar,T,EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,T,Scalar)>::type PromotedT; \
+    return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedT,Derived,OPNAME)( \
+           typename internal::plain_constant_type<Derived,PromotedT>::type(matrix.derived().rows(), matrix.derived().cols(), internal::scalar_constant_op<PromotedT>(scalar)), matrix.derived()); \
+  }
+
+#define EIGEN_MAKE_SCALAR_BINARY_OP(METHOD,OPNAME) \
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD,OPNAME) \
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD,OPNAME)
+
+
+#if (defined(_CPPUNWIND) || defined(__EXCEPTIONS)) && !defined(EIGEN_CUDA_ARCH) && !defined(EIGEN_EXCEPTIONS) && !defined(EIGEN_USE_SYCL) && !defined(EIGEN_HIP_DEVICE_COMPILE)
+  #define EIGEN_EXCEPTIONS
+#endif
+
+
+#ifdef EIGEN_EXCEPTIONS
+#  define EIGEN_THROW_X(X) throw X
+#  define EIGEN_THROW throw
+#  define EIGEN_TRY try
+#  define EIGEN_CATCH(X) catch (X)
+#else
+#  if defined(EIGEN_CUDA_ARCH)
+#    define EIGEN_THROW_X(X) asm("trap;")
+#    define EIGEN_THROW asm("trap;")
+#  elif defined(EIGEN_HIP_DEVICE_COMPILE)
+#    define EIGEN_THROW_X(X) asm("s_trap 0")
+#    define EIGEN_THROW asm("s_trap 0")
+#  else
+#    define EIGEN_THROW_X(X) std::abort()
+#    define EIGEN_THROW std::abort()
+#  endif
+#  define EIGEN_TRY if (true)
+#  define EIGEN_CATCH(X) else
+#endif
+
+
+#if EIGEN_HAS_CXX11_NOEXCEPT
+#   define EIGEN_INCLUDE_TYPE_TRAITS
+#   define EIGEN_NOEXCEPT noexcept
+#   define EIGEN_NOEXCEPT_IF(x) noexcept(x)
+#   define EIGEN_NO_THROW noexcept(true)
+#   define EIGEN_EXCEPTION_SPEC(X) noexcept(false)
+#else
+#   define EIGEN_NOEXCEPT
+#   define EIGEN_NOEXCEPT_IF(x)
+#   define EIGEN_NO_THROW throw()
+#   if EIGEN_COMP_MSVC || EIGEN_COMP_CXXVER>=17
+      // MSVC does not support exception specifications (warning C4290),
+      // and they are deprecated in c++11 anyway. This is even an error in c++17.
+#     define EIGEN_EXCEPTION_SPEC(X) throw()
+#   else
+#     define EIGEN_EXCEPTION_SPEC(X) throw(X)
+#   endif
+#endif
+
+#if EIGEN_HAS_VARIADIC_TEMPLATES
+// The all function is used to enable a variadic version of eigen_assert which can take a parameter pack as its input.
+namespace Eigen {
+namespace internal {
+
+inline bool all(){ return true; }
+
+template<typename T, typename ...Ts>
+bool all(T t, Ts ... ts){ return t && all(ts...); }
+
+}
+}
+#endif
+
+#if EIGEN_HAS_CXX11_OVERRIDE_FINAL
+// provide override and final specifiers if they are available:
+#   define EIGEN_OVERRIDE override
+#   define EIGEN_FINAL final
+#else
+#   define EIGEN_OVERRIDE
+#   define EIGEN_FINAL
+#endif
+
+// Wrapping #pragma unroll in a macro since it is required for SYCL
+#if defined(SYCL_DEVICE_ONLY)
+  #if defined(_MSC_VER)
+    #define EIGEN_UNROLL_LOOP __pragma(unroll)
+  #else
+    #define EIGEN_UNROLL_LOOP _Pragma("unroll")
+  #endif
+#else
+  #define EIGEN_UNROLL_LOOP
+#endif
+
+#endif // EIGEN_MACROS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Memory.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Memory.h
new file mode 100644
index 00000000..875318cd
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Memory.h
@@ -0,0 +1,1163 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Kenneth Riddile <kfriddile@yahoo.com>
+// Copyright (C) 2010 Hauke Heibel <hauke.heibel@gmail.com>
+// Copyright (C) 2010 Thomas Capricelli <orzel@freehackers.org>
+// Copyright (C) 2013 Pavel Holoborodko <pavel@holoborodko.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+/*****************************************************************************
+*** Platform checks for aligned malloc functions                           ***
+*****************************************************************************/
+
+#ifndef EIGEN_MEMORY_H
+#define EIGEN_MEMORY_H
+
+#ifndef EIGEN_MALLOC_ALREADY_ALIGNED
+
+// Try to determine automatically if malloc is already aligned.
+
+// On 64-bit systems, glibc's malloc returns 16-byte-aligned pointers, see:
+//   http://www.gnu.org/s/libc/manual/html_node/Aligned-Memory-Blocks.html
+// This is true at least since glibc 2.8.
+// This leaves the question how to detect 64-bit. According to this document,
+//   http://gcc.fyxm.net/summit/2003/Porting%20to%2064%20bit.pdf
+// page 114, "[The] LP64 model [...] is used by all 64-bit UNIX ports" so it's indeed
+// quite safe, at least within the context of glibc, to equate 64-bit with LP64.
+#if defined(__GLIBC__) && ((__GLIBC__>=2 && __GLIBC_MINOR__ >= 8) || __GLIBC__>2) \
+ && defined(__LP64__) && ! defined( __SANITIZE_ADDRESS__ ) && (EIGEN_DEFAULT_ALIGN_BYTES == 16)
+  #define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED 1
+#else
+  #define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED 0
+#endif
+
+// FreeBSD 6 seems to have 16-byte aligned malloc
+//   See http://svn.freebsd.org/viewvc/base/stable/6/lib/libc/stdlib/malloc.c?view=markup
+// FreeBSD 7 seems to have 16-byte aligned malloc except on ARM and MIPS architectures
+//   See http://svn.freebsd.org/viewvc/base/stable/7/lib/libc/stdlib/malloc.c?view=markup
+#if defined(__FreeBSD__) && !(EIGEN_ARCH_ARM || EIGEN_ARCH_MIPS) && (EIGEN_DEFAULT_ALIGN_BYTES == 16)
+  #define EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED 1
+#else
+  #define EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED 0
+#endif
+
+#if (EIGEN_OS_MAC && (EIGEN_DEFAULT_ALIGN_BYTES == 16))     \
+ || (EIGEN_OS_WIN64 && (EIGEN_DEFAULT_ALIGN_BYTES == 16))   \
+ || EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED              \
+ || EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED
+  #define EIGEN_MALLOC_ALREADY_ALIGNED 1
+#else
+  #define EIGEN_MALLOC_ALREADY_ALIGNED 0
+#endif
+
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+EIGEN_DEVICE_FUNC
+inline void throw_std_bad_alloc()
+{
+  #ifdef EIGEN_EXCEPTIONS
+    throw std::bad_alloc();
+  #else
+    std::size_t huge = static_cast<std::size_t>(-1);
+    #if defined(EIGEN_HIPCC)
+    //
+    // calls to "::operator new" are to be treated as opaque function calls (i.e no inlining),
+    // and as a consequence the code in the #else block triggers the hipcc warning :
+    // "no overloaded function has restriction specifiers that are compatible with the ambient context"
+    //
+    // "throw_std_bad_alloc" has the EIGEN_DEVICE_FUNC attribute, so it seems that hipcc expects
+    // the same on "operator new"
+    // Reverting code back to the old version in this #if block for the hipcc compiler
+    //
+    new int[huge];
+    #else
+    void* unused = ::operator new(huge);
+    EIGEN_UNUSED_VARIABLE(unused);
+    #endif
+  #endif
+}
+
+/*****************************************************************************
+*** Implementation of handmade aligned functions                           ***
+*****************************************************************************/
+
+/* ----- Hand made implementations of aligned malloc/free and realloc ----- */
+
+/** \internal Like malloc, but the returned pointer is guaranteed to be 16-byte aligned.
+  * Fast, but wastes 16 additional bytes of memory. Does not throw any exception.
+  */
+EIGEN_DEVICE_FUNC inline void* handmade_aligned_malloc(std::size_t size, std::size_t alignment = EIGEN_DEFAULT_ALIGN_BYTES)
+{
+  eigen_assert(alignment >= sizeof(void*) && (alignment & (alignment-1)) == 0 && "Alignment must be at least sizeof(void*) and a power of 2");
+
+  EIGEN_USING_STD(malloc)
+  void *original = malloc(size+alignment);
+  
+  if (original == 0) return 0;
+  void *aligned = reinterpret_cast<void*>((reinterpret_cast<std::size_t>(original) & ~(std::size_t(alignment-1))) + alignment);
+  *(reinterpret_cast<void**>(aligned) - 1) = original;
+  return aligned;
+}
+
+/** \internal Frees memory allocated with handmade_aligned_malloc */
+EIGEN_DEVICE_FUNC inline void handmade_aligned_free(void *ptr)
+{
+  if (ptr) {
+    EIGEN_USING_STD(free)
+    free(*(reinterpret_cast<void**>(ptr) - 1));
+  }
+}
+
+/** \internal
+  * \brief Reallocates aligned memory.
+  * Since we know that our handmade version is based on std::malloc
+  * we can use std::realloc to implement efficient reallocation.
+  */
+inline void* handmade_aligned_realloc(void* ptr, std::size_t size, std::size_t = 0)
+{
+  if (ptr == 0) return handmade_aligned_malloc(size);
+  void *original = *(reinterpret_cast<void**>(ptr) - 1);
+  std::ptrdiff_t previous_offset = static_cast<char *>(ptr)-static_cast<char *>(original);
+  original = std::realloc(original,size+EIGEN_DEFAULT_ALIGN_BYTES);
+  if (original == 0) return 0;
+  void *aligned = reinterpret_cast<void*>((reinterpret_cast<std::size_t>(original) & ~(std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1))) + EIGEN_DEFAULT_ALIGN_BYTES);
+  void *previous_aligned = static_cast<char *>(original)+previous_offset;
+  if(aligned!=previous_aligned)
+    std::memmove(aligned, previous_aligned, size);
+
+  *(reinterpret_cast<void**>(aligned) - 1) = original;
+  return aligned;
+}
+
+/*****************************************************************************
+*** Implementation of portable aligned versions of malloc/free/realloc     ***
+*****************************************************************************/
+
+#ifdef EIGEN_NO_MALLOC
+EIGEN_DEVICE_FUNC inline void check_that_malloc_is_allowed()
+{
+  eigen_assert(false && "heap allocation is forbidden (EIGEN_NO_MALLOC is defined)");
+}
+#elif defined EIGEN_RUNTIME_NO_MALLOC
+EIGEN_DEVICE_FUNC inline bool is_malloc_allowed_impl(bool update, bool new_value = false)
+{
+  static bool value = true;
+  if (update == 1)
+    value = new_value;
+  return value;
+}
+EIGEN_DEVICE_FUNC inline bool is_malloc_allowed() { return is_malloc_allowed_impl(false); }
+EIGEN_DEVICE_FUNC inline bool set_is_malloc_allowed(bool new_value) { return is_malloc_allowed_impl(true, new_value); }
+EIGEN_DEVICE_FUNC inline void check_that_malloc_is_allowed()
+{
+  eigen_assert(is_malloc_allowed() && "heap allocation is forbidden (EIGEN_RUNTIME_NO_MALLOC is defined and g_is_malloc_allowed is false)");
+}
+#else
+EIGEN_DEVICE_FUNC inline void check_that_malloc_is_allowed()
+{}
+#endif
+
+/** \internal Allocates \a size bytes. The returned pointer is guaranteed to have 16 or 32 bytes alignment depending on the requirements.
+  * On allocation error, the returned pointer is null, and std::bad_alloc is thrown.
+  */
+EIGEN_DEVICE_FUNC inline void* aligned_malloc(std::size_t size)
+{
+  check_that_malloc_is_allowed();
+
+  void *result;
+  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
+
+    EIGEN_USING_STD(malloc)
+    result = malloc(size);
+
+    #if EIGEN_DEFAULT_ALIGN_BYTES==16
+    eigen_assert((size<16 || (std::size_t(result)%16)==0) && "System's malloc returned an unaligned pointer. Compile with EIGEN_MALLOC_ALREADY_ALIGNED=0 to fallback to handmade aligned memory allocator.");
+    #endif
+  #else
+    result = handmade_aligned_malloc(size);
+  #endif
+
+  if(!result && size)
+    throw_std_bad_alloc();
+
+  return result;
+}
+
+/** \internal Frees memory allocated with aligned_malloc. */
+EIGEN_DEVICE_FUNC inline void aligned_free(void *ptr)
+{
+  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
+
+    EIGEN_USING_STD(free)
+    free(ptr);
+
+  #else
+    handmade_aligned_free(ptr);
+  #endif
+}
+
+/**
+  * \internal
+  * \brief Reallocates an aligned block of memory.
+  * \throws std::bad_alloc on allocation failure
+  */
+inline void* aligned_realloc(void *ptr, std::size_t new_size, std::size_t old_size)
+{
+  EIGEN_UNUSED_VARIABLE(old_size)
+
+  void *result;
+#if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
+  result = std::realloc(ptr,new_size);
+#else
+  result = handmade_aligned_realloc(ptr,new_size,old_size);
+#endif
+
+  if (!result && new_size)
+    throw_std_bad_alloc();
+
+  return result;
+}
+
+/*****************************************************************************
+*** Implementation of conditionally aligned functions                      ***
+*****************************************************************************/
+
+/** \internal Allocates \a size bytes. If Align is true, then the returned ptr is 16-byte-aligned.
+  * On allocation error, the returned pointer is null, and a std::bad_alloc is thrown.
+  */
+template<bool Align> EIGEN_DEVICE_FUNC inline void* conditional_aligned_malloc(std::size_t size)
+{
+  return aligned_malloc(size);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void* conditional_aligned_malloc<false>(std::size_t size)
+{
+  check_that_malloc_is_allowed();
+
+  EIGEN_USING_STD(malloc)
+  void *result = malloc(size);
+
+  if(!result && size)
+    throw_std_bad_alloc();
+  return result;
+}
+
+/** \internal Frees memory allocated with conditional_aligned_malloc */
+template<bool Align> EIGEN_DEVICE_FUNC inline void conditional_aligned_free(void *ptr)
+{
+  aligned_free(ptr);
+}
+
+template<> EIGEN_DEVICE_FUNC inline void conditional_aligned_free<false>(void *ptr)
+{
+  EIGEN_USING_STD(free)
+  free(ptr);
+}
+
+template<bool Align> inline void* conditional_aligned_realloc(void* ptr, std::size_t new_size, std::size_t old_size)
+{
+  return aligned_realloc(ptr, new_size, old_size);
+}
+
+template<> inline void* conditional_aligned_realloc<false>(void* ptr, std::size_t new_size, std::size_t)
+{
+  return std::realloc(ptr, new_size);
+}
+
+/*****************************************************************************
+*** Construction/destruction of array elements                             ***
+*****************************************************************************/
+
+/** \internal Destructs the elements of an array.
+  * The \a size parameters tells on how many objects to call the destructor of T.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline void destruct_elements_of_array(T *ptr, std::size_t size)
+{
+  // always destruct an array starting from the end.
+  if(ptr)
+    while(size) ptr[--size].~T();
+}
+
+/** \internal Constructs the elements of an array.
+  * The \a size parameter tells on how many objects to call the constructor of T.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline T* construct_elements_of_array(T *ptr, std::size_t size)
+{
+  std::size_t i;
+  EIGEN_TRY
+  {
+      for (i = 0; i < size; ++i) ::new (ptr + i) T;
+      return ptr;
+  }
+  EIGEN_CATCH(...)
+  {
+    destruct_elements_of_array(ptr, i);
+    EIGEN_THROW;
+  }
+  return NULL;
+}
+
+/*****************************************************************************
+*** Implementation of aligned new/delete-like functions                    ***
+*****************************************************************************/
+
+template<typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void check_size_for_overflow(std::size_t size)
+{
+  if(size > std::size_t(-1) / sizeof(T))
+    throw_std_bad_alloc();
+}
+
+/** \internal Allocates \a size objects of type T. The returned pointer is guaranteed to have 16 bytes alignment.
+  * On allocation error, the returned pointer is undefined, but a std::bad_alloc is thrown.
+  * The default constructor of T is called.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline T* aligned_new(std::size_t size)
+{
+  check_size_for_overflow<T>(size);
+  T *result = reinterpret_cast<T*>(aligned_malloc(sizeof(T)*size));
+  EIGEN_TRY
+  {
+    return construct_elements_of_array(result, size);
+  }
+  EIGEN_CATCH(...)
+  {
+    aligned_free(result);
+    EIGEN_THROW;
+  }
+  return result;
+}
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline T* conditional_aligned_new(std::size_t size)
+{
+  check_size_for_overflow<T>(size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
+  EIGEN_TRY
+  {
+    return construct_elements_of_array(result, size);
+  }
+  EIGEN_CATCH(...)
+  {
+    conditional_aligned_free<Align>(result);
+    EIGEN_THROW;
+  }
+  return result;
+}
+
+/** \internal Deletes objects constructed with aligned_new
+  * The \a size parameters tells on how many objects to call the destructor of T.
+  */
+template<typename T> EIGEN_DEVICE_FUNC inline void aligned_delete(T *ptr, std::size_t size)
+{
+  destruct_elements_of_array<T>(ptr, size);
+  Eigen::internal::aligned_free(ptr);
+}
+
+/** \internal Deletes objects constructed with conditional_aligned_new
+  * The \a size parameters tells on how many objects to call the destructor of T.
+  */
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline void conditional_aligned_delete(T *ptr, std::size_t size)
+{
+  destruct_elements_of_array<T>(ptr, size);
+  conditional_aligned_free<Align>(ptr);
+}
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline T* conditional_aligned_realloc_new(T* pts, std::size_t new_size, std::size_t old_size)
+{
+  check_size_for_overflow<T>(new_size);
+  check_size_for_overflow<T>(old_size);
+  if(new_size < old_size)
+    destruct_elements_of_array(pts+new_size, old_size-new_size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
+  if(new_size > old_size)
+  {
+    EIGEN_TRY
+    {
+      construct_elements_of_array(result+old_size, new_size-old_size);
+    }
+    EIGEN_CATCH(...)
+    {
+      conditional_aligned_free<Align>(result);
+      EIGEN_THROW;
+    }
+  }
+  return result;
+}
+
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline T* conditional_aligned_new_auto(std::size_t size)
+{
+  if(size==0)
+    return 0; // short-cut. Also fixes Bug 884
+  check_size_for_overflow<T>(size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
+  if(NumTraits<T>::RequireInitialization)
+  {
+    EIGEN_TRY
+    {
+      construct_elements_of_array(result, size);
+    }
+    EIGEN_CATCH(...)
+    {
+      conditional_aligned_free<Align>(result);
+      EIGEN_THROW;
+    }
+  }
+  return result;
+}
+
+template<typename T, bool Align> inline T* conditional_aligned_realloc_new_auto(T* pts, std::size_t new_size, std::size_t old_size)
+{
+  check_size_for_overflow<T>(new_size);
+  check_size_for_overflow<T>(old_size);
+  if(NumTraits<T>::RequireInitialization && (new_size < old_size))
+    destruct_elements_of_array(pts+new_size, old_size-new_size);
+  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
+  if(NumTraits<T>::RequireInitialization && (new_size > old_size))
+  {
+    EIGEN_TRY
+    {
+      construct_elements_of_array(result+old_size, new_size-old_size);
+    }
+    EIGEN_CATCH(...)
+    {
+      conditional_aligned_free<Align>(result);
+      EIGEN_THROW;
+    }
+  }
+  return result;
+}
+
+template<typename T, bool Align> EIGEN_DEVICE_FUNC inline void conditional_aligned_delete_auto(T *ptr, std::size_t size)
+{
+  if(NumTraits<T>::RequireInitialization)
+    destruct_elements_of_array<T>(ptr, size);
+  conditional_aligned_free<Align>(ptr);
+}
+
+/****************************************************************************/
+
+/** \internal Returns the index of the first element of the array that is well aligned with respect to the requested \a Alignment.
+  *
+  * \tparam Alignment requested alignment in Bytes.
+  * \param array the address of the start of the array
+  * \param size the size of the array
+  *
+  * \note If no element of the array is well aligned or the requested alignment is not a multiple of a scalar,
+  * the size of the array is returned. For example with SSE, the requested alignment is typically 16-bytes. If
+  * packet size for the given scalar type is 1, then everything is considered well-aligned.
+  *
+  * \note Otherwise, if the Alignment is larger that the scalar size, we rely on the assumptions that sizeof(Scalar) is a
+  * power of 2. On the other hand, we do not assume that the array address is a multiple of sizeof(Scalar), as that fails for
+  * example with Scalar=double on certain 32-bit platforms, see bug #79.
+  *
+  * There is also the variant first_aligned(const MatrixBase&) defined in DenseCoeffsBase.h.
+  * \sa first_default_aligned()
+  */
+template<int Alignment, typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC inline Index first_aligned(const Scalar* array, Index size)
+{
+  const Index ScalarSize = sizeof(Scalar);
+  const Index AlignmentSize = Alignment / ScalarSize;
+  const Index AlignmentMask = AlignmentSize-1;
+
+  if(AlignmentSize<=1)
+  {
+    // Either the requested alignment if smaller than a scalar, or it exactly match a 1 scalar
+    // so that all elements of the array have the same alignment.
+    return 0;
+  }
+  else if( (UIntPtr(array) & (sizeof(Scalar)-1)) || (Alignment%ScalarSize)!=0)
+  {
+    // The array is not aligned to the size of a single scalar, or the requested alignment is not a multiple of the scalar size.
+    // Consequently, no element of the array is well aligned.
+    return size;
+  }
+  else
+  {
+    Index first = (AlignmentSize - (Index((UIntPtr(array)/sizeof(Scalar))) & AlignmentMask)) & AlignmentMask;
+    return (first < size) ? first : size;
+  }
+}
+
+/** \internal Returns the index of the first element of the array that is well aligned with respect the largest packet requirement.
+   * \sa first_aligned(Scalar*,Index) and first_default_aligned(DenseBase<Derived>) */
+template<typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC inline Index first_default_aligned(const Scalar* array, Index size)
+{
+  typedef typename packet_traits<Scalar>::type DefaultPacketType;
+  return first_aligned<unpacket_traits<DefaultPacketType>::alignment>(array, size);
+}
+
+/** \internal Returns the smallest integer multiple of \a base and greater or equal to \a size
+  */
+template<typename Index>
+inline Index first_multiple(Index size, Index base)
+{
+  return ((size+base-1)/base)*base;
+}
+
+// std::copy is much slower than memcpy, so let's introduce a smart_copy which
+// use memcpy on trivial types, i.e., on types that does not require an initialization ctor.
+template<typename T, bool UseMemcpy> struct smart_copy_helper;
+
+template<typename T> EIGEN_DEVICE_FUNC void smart_copy(const T* start, const T* end, T* target)
+{
+  smart_copy_helper<T,!NumTraits<T>::RequireInitialization>::run(start, end, target);
+}
+
+template<typename T> struct smart_copy_helper<T,true> {
+  EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T* target)
+  {
+    IntPtr size = IntPtr(end)-IntPtr(start);
+    if(size==0) return;
+    eigen_internal_assert(start!=0 && end!=0 && target!=0);
+    EIGEN_USING_STD(memcpy)
+    memcpy(target, start, size);
+  }
+};
+
+template<typename T> struct smart_copy_helper<T,false> {
+  EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T* target)
+  { std::copy(start, end, target); }
+};
+
+// intelligent memmove. falls back to std::memmove for POD types, uses std::copy otherwise.
+template<typename T, bool UseMemmove> struct smart_memmove_helper;
+
+template<typename T> void smart_memmove(const T* start, const T* end, T* target)
+{
+  smart_memmove_helper<T,!NumTraits<T>::RequireInitialization>::run(start, end, target);
+}
+
+template<typename T> struct smart_memmove_helper<T,true> {
+  static inline void run(const T* start, const T* end, T* target)
+  {
+    IntPtr size = IntPtr(end)-IntPtr(start);
+    if(size==0) return;
+    eigen_internal_assert(start!=0 && end!=0 && target!=0);
+    std::memmove(target, start, size);
+  }
+};
+
+template<typename T> struct smart_memmove_helper<T,false> {
+  static inline void run(const T* start, const T* end, T* target)
+  {
+    if (UIntPtr(target) < UIntPtr(start))
+    {
+      std::copy(start, end, target);
+    }
+    else
+    {
+      std::ptrdiff_t count = (std::ptrdiff_t(end)-std::ptrdiff_t(start)) / sizeof(T);
+      std::copy_backward(start, end, target + count);
+    }
+  }
+};
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+template<typename T> EIGEN_DEVICE_FUNC T* smart_move(T* start, T* end, T* target)
+{
+  return std::move(start, end, target);
+}
+#else
+template<typename T> EIGEN_DEVICE_FUNC T* smart_move(T* start, T* end, T* target)
+{
+  return std::copy(start, end, target);
+}
+#endif
+
+/*****************************************************************************
+*** Implementation of runtime stack allocation (falling back to malloc)    ***
+*****************************************************************************/
+
+// you can overwrite Eigen's default behavior regarding alloca by defining EIGEN_ALLOCA
+// to the appropriate stack allocation function
+#if ! defined EIGEN_ALLOCA && ! defined EIGEN_GPU_COMPILE_PHASE
+  #if EIGEN_OS_LINUX || EIGEN_OS_MAC || (defined alloca)
+    #define EIGEN_ALLOCA alloca
+  #elif EIGEN_COMP_MSVC
+    #define EIGEN_ALLOCA _alloca
+  #endif
+#endif
+
+// With clang -Oz -mthumb, alloca changes the stack pointer in a way that is
+// not allowed in Thumb2. -DEIGEN_STACK_ALLOCATION_LIMIT=0 doesn't work because
+// the compiler still emits bad code because stack allocation checks use "<=".
+// TODO: Eliminate after https://bugs.llvm.org/show_bug.cgi?id=23772
+// is fixed.
+#if defined(__clang__) && defined(__thumb__)
+  #undef EIGEN_ALLOCA
+#endif
+
+// This helper class construct the allocated memory, and takes care of destructing and freeing the handled data
+// at destruction time. In practice this helper class is mainly useful to avoid memory leak in case of exceptions.
+template<typename T> class aligned_stack_memory_handler : noncopyable
+{
+  public:
+    /* Creates a stack_memory_handler responsible for the buffer \a ptr of size \a size.
+     * Note that \a ptr can be 0 regardless of the other parameters.
+     * This constructor takes care of constructing/initializing the elements of the buffer if required by the scalar type T (see NumTraits<T>::RequireInitialization).
+     * In this case, the buffer elements will also be destructed when this handler will be destructed.
+     * Finally, if \a dealloc is true, then the pointer \a ptr is freed.
+     **/
+    EIGEN_DEVICE_FUNC
+    aligned_stack_memory_handler(T* ptr, std::size_t size, bool dealloc)
+      : m_ptr(ptr), m_size(size), m_deallocate(dealloc)
+    {
+      if(NumTraits<T>::RequireInitialization && m_ptr)
+        Eigen::internal::construct_elements_of_array(m_ptr, size);
+    }
+    EIGEN_DEVICE_FUNC
+    ~aligned_stack_memory_handler()
+    {
+      if(NumTraits<T>::RequireInitialization && m_ptr)
+        Eigen::internal::destruct_elements_of_array<T>(m_ptr, m_size);
+      if(m_deallocate)
+        Eigen::internal::aligned_free(m_ptr);
+    }
+  protected:
+    T* m_ptr;
+    std::size_t m_size;
+    bool m_deallocate;
+};
+
+#ifdef EIGEN_ALLOCA
+
+template<typename Xpr, int NbEvaluations,
+         bool MapExternalBuffer = nested_eval<Xpr,NbEvaluations>::Evaluate && Xpr::MaxSizeAtCompileTime==Dynamic
+         >
+struct local_nested_eval_wrapper
+{
+  static const bool NeedExternalBuffer = false;
+  typedef typename Xpr::Scalar Scalar;
+  typedef typename nested_eval<Xpr,NbEvaluations>::type ObjectType;
+  ObjectType object;
+
+  EIGEN_DEVICE_FUNC
+  local_nested_eval_wrapper(const Xpr& xpr, Scalar* ptr) : object(xpr)
+  {
+    EIGEN_UNUSED_VARIABLE(ptr);
+    eigen_internal_assert(ptr==0);
+  }
+};
+
+template<typename Xpr, int NbEvaluations>
+struct local_nested_eval_wrapper<Xpr,NbEvaluations,true>
+{
+  static const bool NeedExternalBuffer = true;
+  typedef typename Xpr::Scalar Scalar;
+  typedef typename plain_object_eval<Xpr>::type PlainObject;
+  typedef Map<PlainObject,EIGEN_DEFAULT_ALIGN_BYTES> ObjectType;
+  ObjectType object;
+
+  EIGEN_DEVICE_FUNC
+  local_nested_eval_wrapper(const Xpr& xpr, Scalar* ptr)
+    : object(ptr==0 ? reinterpret_cast<Scalar*>(Eigen::internal::aligned_malloc(sizeof(Scalar)*xpr.size())) : ptr, xpr.rows(), xpr.cols()),
+      m_deallocate(ptr==0)
+  {
+    if(NumTraits<Scalar>::RequireInitialization && object.data())
+      Eigen::internal::construct_elements_of_array(object.data(), object.size());
+    object = xpr;
+  }
+
+  EIGEN_DEVICE_FUNC
+  ~local_nested_eval_wrapper()
+  {
+    if(NumTraits<Scalar>::RequireInitialization && object.data())
+      Eigen::internal::destruct_elements_of_array(object.data(), object.size());
+    if(m_deallocate)
+      Eigen::internal::aligned_free(object.data());
+  }
+
+private:
+  bool m_deallocate;
+};
+
+#endif // EIGEN_ALLOCA
+
+template<typename T> class scoped_array : noncopyable
+{
+  T* m_ptr;
+public:
+  explicit scoped_array(std::ptrdiff_t size)
+  {
+    m_ptr = new T[size];
+  }
+  ~scoped_array()
+  {
+    delete[] m_ptr;
+  }
+  T& operator[](std::ptrdiff_t i) { return m_ptr[i]; }
+  const T& operator[](std::ptrdiff_t i) const { return m_ptr[i]; }
+  T* &ptr() { return m_ptr; }
+  const T* ptr() const { return m_ptr; }
+  operator const T*() const { return m_ptr; }
+};
+
+template<typename T> void swap(scoped_array<T> &a,scoped_array<T> &b)
+{
+  std::swap(a.ptr(),b.ptr());
+}
+
+} // end namespace internal
+
+/** \internal
+  *
+  * The macro ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) declares, allocates,
+  * and construct an aligned buffer named NAME of SIZE elements of type TYPE on the stack
+  * if the size in bytes is smaller than EIGEN_STACK_ALLOCATION_LIMIT, and if stack allocation is supported by the platform
+  * (currently, this is Linux, OSX and Visual Studio only). Otherwise the memory is allocated on the heap.
+  * The allocated buffer is automatically deleted when exiting the scope of this declaration.
+  * If BUFFER is non null, then the declared variable is simply an alias for BUFFER, and no allocation/deletion occurs.
+  * Here is an example:
+  * \code
+  * {
+  *   ei_declare_aligned_stack_constructed_variable(float,data,size,0);
+  *   // use data[0] to data[size-1]
+  * }
+  * \endcode
+  * The underlying stack allocation function can controlled with the EIGEN_ALLOCA preprocessor token.
+  *
+  * The macro ei_declare_local_nested_eval(XPR_T,XPR,N,NAME) is analogue to
+  * \code
+  *   typename internal::nested_eval<XPRT_T,N>::type NAME(XPR);
+  * \endcode
+  * with the advantage of using aligned stack allocation even if the maximal size of XPR at compile time is unknown.
+  * This is accomplished through alloca if this later is supported and if the required number of bytes
+  * is below EIGEN_STACK_ALLOCATION_LIMIT.
+  */
+#ifdef EIGEN_ALLOCA
+
+  #if EIGEN_DEFAULT_ALIGN_BYTES>0
+    // We always manually re-align the result of EIGEN_ALLOCA.
+    // If alloca is already aligned, the compiler should be smart enough to optimize away the re-alignment.
+    #define EIGEN_ALIGNED_ALLOCA(SIZE) reinterpret_cast<void*>((internal::UIntPtr(EIGEN_ALLOCA(SIZE+EIGEN_DEFAULT_ALIGN_BYTES-1)) + EIGEN_DEFAULT_ALIGN_BYTES-1) & ~(std::size_t(EIGEN_DEFAULT_ALIGN_BYTES-1)))
+  #else
+    #define EIGEN_ALIGNED_ALLOCA(SIZE) EIGEN_ALLOCA(SIZE)
+  #endif
+
+  #define ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) \
+    Eigen::internal::check_size_for_overflow<TYPE>(SIZE); \
+    TYPE* NAME = (BUFFER)!=0 ? (BUFFER) \
+               : reinterpret_cast<TYPE*>( \
+                      (sizeof(TYPE)*SIZE<=EIGEN_STACK_ALLOCATION_LIMIT) ? EIGEN_ALIGNED_ALLOCA(sizeof(TYPE)*SIZE) \
+                    : Eigen::internal::aligned_malloc(sizeof(TYPE)*SIZE) );  \
+    Eigen::internal::aligned_stack_memory_handler<TYPE> EIGEN_CAT(NAME,_stack_memory_destructor)((BUFFER)==0 ? NAME : 0,SIZE,sizeof(TYPE)*SIZE>EIGEN_STACK_ALLOCATION_LIMIT)
+
+
+  #define ei_declare_local_nested_eval(XPR_T,XPR,N,NAME) \
+    Eigen::internal::local_nested_eval_wrapper<XPR_T,N> EIGEN_CAT(NAME,_wrapper)(XPR, reinterpret_cast<typename XPR_T::Scalar*>( \
+      ( (Eigen::internal::local_nested_eval_wrapper<XPR_T,N>::NeedExternalBuffer) && ((sizeof(typename XPR_T::Scalar)*XPR.size())<=EIGEN_STACK_ALLOCATION_LIMIT) ) \
+        ? EIGEN_ALIGNED_ALLOCA( sizeof(typename XPR_T::Scalar)*XPR.size() ) : 0 ) ) ; \
+    typename Eigen::internal::local_nested_eval_wrapper<XPR_T,N>::ObjectType NAME(EIGEN_CAT(NAME,_wrapper).object)
+
+#else
+
+  #define ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) \
+    Eigen::internal::check_size_for_overflow<TYPE>(SIZE); \
+    TYPE* NAME = (BUFFER)!=0 ? BUFFER : reinterpret_cast<TYPE*>(Eigen::internal::aligned_malloc(sizeof(TYPE)*SIZE));    \
+    Eigen::internal::aligned_stack_memory_handler<TYPE> EIGEN_CAT(NAME,_stack_memory_destructor)((BUFFER)==0 ? NAME : 0,SIZE,true)
+
+
+#define ei_declare_local_nested_eval(XPR_T,XPR,N,NAME) typename Eigen::internal::nested_eval<XPR_T,N>::type NAME(XPR)
+
+#endif
+
+
+/*****************************************************************************
+*** Implementation of EIGEN_MAKE_ALIGNED_OPERATOR_NEW [_IF]                ***
+*****************************************************************************/
+
+#if EIGEN_HAS_CXX17_OVERALIGN
+
+// C++17 -> no need to bother about alignment anymore :)
+
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign)
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar,Size)
+
+#else
+
+// HIP does not support new/delete on device.
+#if EIGEN_MAX_ALIGN_BYTES!=0 && !defined(EIGEN_HIP_DEVICE_COMPILE)
+  #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \
+      EIGEN_DEVICE_FUNC \
+      void* operator new(std::size_t size, const std::nothrow_t&) EIGEN_NO_THROW { \
+        EIGEN_TRY { return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); } \
+        EIGEN_CATCH (...) { return 0; } \
+      }
+  #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) \
+      EIGEN_DEVICE_FUNC \
+      void *operator new(std::size_t size) { \
+        return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \
+      } \
+      EIGEN_DEVICE_FUNC \
+      void *operator new[](std::size_t size) { \
+        return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \
+      } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete(void * ptr) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete[](void * ptr) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete(void * ptr, std::size_t /* sz */) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete[](void * ptr, std::size_t /* sz */) EIGEN_NO_THROW { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \
+      /* in-place new and delete. since (at least afaik) there is no actual   */ \
+      /* memory allocated we can safely let the default implementation handle */ \
+      /* this particular case. */ \
+      EIGEN_DEVICE_FUNC \
+      static void *operator new(std::size_t size, void *ptr) { return ::operator new(size,ptr); } \
+      EIGEN_DEVICE_FUNC \
+      static void *operator new[](std::size_t size, void* ptr) { return ::operator new[](size,ptr); } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete(void * memory, void *ptr) EIGEN_NO_THROW { return ::operator delete(memory,ptr); } \
+      EIGEN_DEVICE_FUNC \
+      void operator delete[](void * memory, void *ptr) EIGEN_NO_THROW { return ::operator delete[](memory,ptr); } \
+      /* nothrow-new (returns zero instead of std::bad_alloc) */ \
+      EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \
+      EIGEN_DEVICE_FUNC \
+      void operator delete(void *ptr, const std::nothrow_t&) EIGEN_NO_THROW { \
+        Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); \
+      } \
+      typedef void eigen_aligned_operator_new_marker_type;
+#else
+  #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)
+#endif
+
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar,Size)                        \
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(bool(                                                             \
+        ((Size)!=Eigen::Dynamic) &&                                                                    \
+        (((EIGEN_MAX_ALIGN_BYTES>=16) && ((sizeof(Scalar)*(Size))%(EIGEN_MAX_ALIGN_BYTES  )==0)) ||    \
+         ((EIGEN_MAX_ALIGN_BYTES>=32) && ((sizeof(Scalar)*(Size))%(EIGEN_MAX_ALIGN_BYTES/2)==0)) ||    \
+         ((EIGEN_MAX_ALIGN_BYTES>=64) && ((sizeof(Scalar)*(Size))%(EIGEN_MAX_ALIGN_BYTES/4)==0))   )))
+
+#endif
+
+/****************************************************************************/
+
+/** \class aligned_allocator
+* \ingroup Core_Module
+*
+* \brief STL compatible allocator to use with types requiring a non standrad alignment.
+*
+* The memory is aligned as for dynamically aligned matrix/array types such as MatrixXd.
+* By default, it will thus provide at least 16 bytes alignment and more in following cases:
+*  - 32 bytes alignment if AVX is enabled.
+*  - 64 bytes alignment if AVX512 is enabled.
+*
+* This can be controlled using the \c EIGEN_MAX_ALIGN_BYTES macro as documented
+* \link TopicPreprocessorDirectivesPerformance there \endlink.
+*
+* Example:
+* \code
+* // Matrix4f requires 16 bytes alignment:
+* std::map< int, Matrix4f, std::less<int>,
+*           aligned_allocator<std::pair<const int, Matrix4f> > > my_map_mat4;
+* // Vector3f does not require 16 bytes alignment, no need to use Eigen's allocator:
+* std::map< int, Vector3f > my_map_vec3;
+* \endcode
+*
+* \sa \blank \ref TopicStlContainers.
+*/
+template<class T>
+class aligned_allocator : public std::allocator<T>
+{
+public:
+  typedef std::size_t     size_type;
+  typedef std::ptrdiff_t  difference_type;
+  typedef T*              pointer;
+  typedef const T*        const_pointer;
+  typedef T&              reference;
+  typedef const T&        const_reference;
+  typedef T               value_type;
+
+  template<class U>
+  struct rebind
+  {
+    typedef aligned_allocator<U> other;
+  };
+
+  aligned_allocator() : std::allocator<T>() {}
+
+  aligned_allocator(const aligned_allocator& other) : std::allocator<T>(other) {}
+
+  template<class U>
+  aligned_allocator(const aligned_allocator<U>& other) : std::allocator<T>(other) {}
+
+  ~aligned_allocator() {}
+
+  #if EIGEN_COMP_GNUC_STRICT && EIGEN_GNUC_AT_LEAST(7,0)
+  // In gcc std::allocator::max_size() is bugged making gcc triggers a warning:
+  // eigen/Eigen/src/Core/util/Memory.h:189:12: warning: argument 1 value '18446744073709551612' exceeds maximum object size 9223372036854775807
+  // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87544
+  size_type max_size() const {
+    return (std::numeric_limits<std::ptrdiff_t>::max)()/sizeof(T);
+  }
+  #endif
+
+  pointer allocate(size_type num, const void* /*hint*/ = 0)
+  {
+    internal::check_size_for_overflow<T>(num);
+    return static_cast<pointer>( internal::aligned_malloc(num * sizeof(T)) );
+  }
+
+  void deallocate(pointer p, size_type /*num*/)
+  {
+    internal::aligned_free(p);
+  }
+};
+
+//---------- Cache sizes ----------
+
+#if !defined(EIGEN_NO_CPUID)
+#  if EIGEN_COMP_GNUC && EIGEN_ARCH_i386_OR_x86_64
+#    if defined(__PIC__) && EIGEN_ARCH_i386
+       // Case for x86 with PIC
+#      define EIGEN_CPUID(abcd,func,id) \
+         __asm__ __volatile__ ("xchgl %%ebx, %k1;cpuid; xchgl %%ebx,%k1": "=a" (abcd[0]), "=&r" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "a" (func), "c" (id));
+#    elif defined(__PIC__) && EIGEN_ARCH_x86_64
+       // Case for x64 with PIC. In theory this is only a problem with recent gcc and with medium or large code model, not with the default small code model.
+       // However, we cannot detect which code model is used, and the xchg overhead is negligible anyway.
+#      define EIGEN_CPUID(abcd,func,id) \
+        __asm__ __volatile__ ("xchg{q}\t{%%}rbx, %q1; cpuid; xchg{q}\t{%%}rbx, %q1": "=a" (abcd[0]), "=&r" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "0" (func), "2" (id));
+#    else
+       // Case for x86_64 or x86 w/o PIC
+#      define EIGEN_CPUID(abcd,func,id) \
+         __asm__ __volatile__ ("cpuid": "=a" (abcd[0]), "=b" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "0" (func), "2" (id) );
+#    endif
+#  elif EIGEN_COMP_MSVC
+#    if (EIGEN_COMP_MSVC > 1500) && EIGEN_ARCH_i386_OR_x86_64
+#      define EIGEN_CPUID(abcd,func,id) __cpuidex((int*)abcd,func,id)
+#    endif
+#  endif
+#endif
+
+namespace internal {
+
+#ifdef EIGEN_CPUID
+
+inline bool cpuid_is_vendor(int abcd[4], const int vendor[3])
+{
+  return abcd[1]==vendor[0] && abcd[3]==vendor[1] && abcd[2]==vendor[2];
+}
+
+inline void queryCacheSizes_intel_direct(int& l1, int& l2, int& l3)
+{
+  int abcd[4];
+  l1 = l2 = l3 = 0;
+  int cache_id = 0;
+  int cache_type = 0;
+  do {
+    abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+    EIGEN_CPUID(abcd,0x4,cache_id);
+    cache_type  = (abcd[0] & 0x0F) >> 0;
+    if(cache_type==1||cache_type==3) // data or unified cache
+    {
+      int cache_level = (abcd[0] & 0xE0) >> 5;  // A[7:5]
+      int ways        = (abcd[1] & 0xFFC00000) >> 22; // B[31:22]
+      int partitions  = (abcd[1] & 0x003FF000) >> 12; // B[21:12]
+      int line_size   = (abcd[1] & 0x00000FFF) >>  0; // B[11:0]
+      int sets        = (abcd[2]);                    // C[31:0]
+
+      int cache_size = (ways+1) * (partitions+1) * (line_size+1) * (sets+1);
+
+      switch(cache_level)
+      {
+        case 1: l1 = cache_size; break;
+        case 2: l2 = cache_size; break;
+        case 3: l3 = cache_size; break;
+        default: break;
+      }
+    }
+    cache_id++;
+  } while(cache_type>0 && cache_id<16);
+}
+
+inline void queryCacheSizes_intel_codes(int& l1, int& l2, int& l3)
+{
+  int abcd[4];
+  abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+  l1 = l2 = l3 = 0;
+  EIGEN_CPUID(abcd,0x00000002,0);
+  unsigned char * bytes = reinterpret_cast<unsigned char *>(abcd)+2;
+  bool check_for_p2_core2 = false;
+  for(int i=0; i<14; ++i)
+  {
+    switch(bytes[i])
+    {
+      case 0x0A: l1 = 8; break;   // 0Ah   data L1 cache, 8 KB, 2 ways, 32 byte lines
+      case 0x0C: l1 = 16; break;  // 0Ch   data L1 cache, 16 KB, 4 ways, 32 byte lines
+      case 0x0E: l1 = 24; break;  // 0Eh   data L1 cache, 24 KB, 6 ways, 64 byte lines
+      case 0x10: l1 = 16; break;  // 10h   data L1 cache, 16 KB, 4 ways, 32 byte lines (IA-64)
+      case 0x15: l1 = 16; break;  // 15h   code L1 cache, 16 KB, 4 ways, 32 byte lines (IA-64)
+      case 0x2C: l1 = 32; break;  // 2Ch   data L1 cache, 32 KB, 8 ways, 64 byte lines
+      case 0x30: l1 = 32; break;  // 30h   code L1 cache, 32 KB, 8 ways, 64 byte lines
+      case 0x60: l1 = 16; break;  // 60h   data L1 cache, 16 KB, 8 ways, 64 byte lines, sectored
+      case 0x66: l1 = 8; break;   // 66h   data L1 cache, 8 KB, 4 ways, 64 byte lines, sectored
+      case 0x67: l1 = 16; break;  // 67h   data L1 cache, 16 KB, 4 ways, 64 byte lines, sectored
+      case 0x68: l1 = 32; break;  // 68h   data L1 cache, 32 KB, 4 ways, 64 byte lines, sectored
+      case 0x1A: l2 = 96; break;   // code and data L2 cache, 96 KB, 6 ways, 64 byte lines (IA-64)
+      case 0x22: l3 = 512; break;   // code and data L3 cache, 512 KB, 4 ways (!), 64 byte lines, dual-sectored
+      case 0x23: l3 = 1024; break;   // code and data L3 cache, 1024 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x25: l3 = 2048; break;   // code and data L3 cache, 2048 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x29: l3 = 4096; break;   // code and data L3 cache, 4096 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x39: l2 = 128; break;   // code and data L2 cache, 128 KB, 4 ways, 64 byte lines, sectored
+      case 0x3A: l2 = 192; break;   // code and data L2 cache, 192 KB, 6 ways, 64 byte lines, sectored
+      case 0x3B: l2 = 128; break;   // code and data L2 cache, 128 KB, 2 ways, 64 byte lines, sectored
+      case 0x3C: l2 = 256; break;   // code and data L2 cache, 256 KB, 4 ways, 64 byte lines, sectored
+      case 0x3D: l2 = 384; break;   // code and data L2 cache, 384 KB, 6 ways, 64 byte lines, sectored
+      case 0x3E: l2 = 512; break;   // code and data L2 cache, 512 KB, 4 ways, 64 byte lines, sectored
+      case 0x40: l2 = 0; break;   // no integrated L2 cache (P6 core) or L3 cache (P4 core)
+      case 0x41: l2 = 128; break;   // code and data L2 cache, 128 KB, 4 ways, 32 byte lines
+      case 0x42: l2 = 256; break;   // code and data L2 cache, 256 KB, 4 ways, 32 byte lines
+      case 0x43: l2 = 512; break;   // code and data L2 cache, 512 KB, 4 ways, 32 byte lines
+      case 0x44: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 4 ways, 32 byte lines
+      case 0x45: l2 = 2048; break;   // code and data L2 cache, 2048 KB, 4 ways, 32 byte lines
+      case 0x46: l3 = 4096; break;   // code and data L3 cache, 4096 KB, 4 ways, 64 byte lines
+      case 0x47: l3 = 8192; break;   // code and data L3 cache, 8192 KB, 8 ways, 64 byte lines
+      case 0x48: l2 = 3072; break;   // code and data L2 cache, 3072 KB, 12 ways, 64 byte lines
+      case 0x49: if(l2!=0) l3 = 4096; else {check_for_p2_core2=true; l3 = l2 = 4096;} break;// code and data L3 cache, 4096 KB, 16 ways, 64 byte lines (P4) or L2 for core2
+      case 0x4A: l3 = 6144; break;   // code and data L3 cache, 6144 KB, 12 ways, 64 byte lines
+      case 0x4B: l3 = 8192; break;   // code and data L3 cache, 8192 KB, 16 ways, 64 byte lines
+      case 0x4C: l3 = 12288; break;   // code and data L3 cache, 12288 KB, 12 ways, 64 byte lines
+      case 0x4D: l3 = 16384; break;   // code and data L3 cache, 16384 KB, 16 ways, 64 byte lines
+      case 0x4E: l2 = 6144; break;   // code and data L2 cache, 6144 KB, 24 ways, 64 byte lines
+      case 0x78: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 4 ways, 64 byte lines
+      case 0x79: l2 = 128; break;   // code and data L2 cache, 128 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7A: l2 = 256; break;   // code and data L2 cache, 256 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7B: l2 = 512; break;   // code and data L2 cache, 512 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7C: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 8 ways, 64 byte lines, dual-sectored
+      case 0x7D: l2 = 2048; break;   // code and data L2 cache, 2048 KB, 8 ways, 64 byte lines
+      case 0x7E: l2 = 256; break;   // code and data L2 cache, 256 KB, 8 ways, 128 byte lines, sect. (IA-64)
+      case 0x7F: l2 = 512; break;   // code and data L2 cache, 512 KB, 2 ways, 64 byte lines
+      case 0x80: l2 = 512; break;   // code and data L2 cache, 512 KB, 8 ways, 64 byte lines
+      case 0x81: l2 = 128; break;   // code and data L2 cache, 128 KB, 8 ways, 32 byte lines
+      case 0x82: l2 = 256; break;   // code and data L2 cache, 256 KB, 8 ways, 32 byte lines
+      case 0x83: l2 = 512; break;   // code and data L2 cache, 512 KB, 8 ways, 32 byte lines
+      case 0x84: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 8 ways, 32 byte lines
+      case 0x85: l2 = 2048; break;   // code and data L2 cache, 2048 KB, 8 ways, 32 byte lines
+      case 0x86: l2 = 512; break;   // code and data L2 cache, 512 KB, 4 ways, 64 byte lines
+      case 0x87: l2 = 1024; break;   // code and data L2 cache, 1024 KB, 8 ways, 64 byte lines
+      case 0x88: l3 = 2048; break;   // code and data L3 cache, 2048 KB, 4 ways, 64 byte lines (IA-64)
+      case 0x89: l3 = 4096; break;   // code and data L3 cache, 4096 KB, 4 ways, 64 byte lines (IA-64)
+      case 0x8A: l3 = 8192; break;   // code and data L3 cache, 8192 KB, 4 ways, 64 byte lines (IA-64)
+      case 0x8D: l3 = 3072; break;   // code and data L3 cache, 3072 KB, 12 ways, 128 byte lines (IA-64)
+
+      default: break;
+    }
+  }
+  if(check_for_p2_core2 && l2 == l3)
+    l3 = 0;
+  l1 *= 1024;
+  l2 *= 1024;
+  l3 *= 1024;
+}
+
+inline void queryCacheSizes_intel(int& l1, int& l2, int& l3, int max_std_funcs)
+{
+  if(max_std_funcs>=4)
+    queryCacheSizes_intel_direct(l1,l2,l3);
+  else if(max_std_funcs>=2)
+    queryCacheSizes_intel_codes(l1,l2,l3);
+  else
+    l1 = l2 = l3 = 0;
+}
+
+inline void queryCacheSizes_amd(int& l1, int& l2, int& l3)
+{
+  int abcd[4];
+  abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+  
+  // First query the max supported function.
+  EIGEN_CPUID(abcd,0x80000000,0);
+  if(static_cast<numext::uint32_t>(abcd[0]) >= static_cast<numext::uint32_t>(0x80000006))
+  {
+    EIGEN_CPUID(abcd,0x80000005,0);
+    l1 = (abcd[2] >> 24) * 1024; // C[31:24] = L1 size in KB
+    abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
+    EIGEN_CPUID(abcd,0x80000006,0);
+    l2 = (abcd[2] >> 16) * 1024; // C[31;16] = l2 cache size in KB
+    l3 = ((abcd[3] & 0xFFFC000) >> 18) * 512 * 1024; // D[31;18] = l3 cache size in 512KB
+  }
+  else
+  {
+    l1 = l2 = l3 = 0;
+  }
+}
+#endif
+
+/** \internal
+ * Queries and returns the cache sizes in Bytes of the L1, L2, and L3 data caches respectively */
+inline void queryCacheSizes(int& l1, int& l2, int& l3)
+{
+  #ifdef EIGEN_CPUID
+  int abcd[4];
+  const int GenuineIntel[] = {0x756e6547, 0x49656e69, 0x6c65746e};
+  const int AuthenticAMD[] = {0x68747541, 0x69746e65, 0x444d4163};
+  const int AMDisbetter_[] = {0x69444d41, 0x74656273, 0x21726574}; // "AMDisbetter!"
+
+  // identify the CPU vendor
+  EIGEN_CPUID(abcd,0x0,0);
+  int max_std_funcs = abcd[0];
+  if(cpuid_is_vendor(abcd,GenuineIntel))
+    queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
+  else if(cpuid_is_vendor(abcd,AuthenticAMD) || cpuid_is_vendor(abcd,AMDisbetter_))
+    queryCacheSizes_amd(l1,l2,l3);
+  else
+    // by default let's use Intel's API
+    queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
+
+  // here is the list of other vendors:
+//   ||cpuid_is_vendor(abcd,"VIA VIA VIA ")
+//   ||cpuid_is_vendor(abcd,"CyrixInstead")
+//   ||cpuid_is_vendor(abcd,"CentaurHauls")
+//   ||cpuid_is_vendor(abcd,"GenuineTMx86")
+//   ||cpuid_is_vendor(abcd,"TransmetaCPU")
+//   ||cpuid_is_vendor(abcd,"RiseRiseRise")
+//   ||cpuid_is_vendor(abcd,"Geode by NSC")
+//   ||cpuid_is_vendor(abcd,"SiS SiS SiS ")
+//   ||cpuid_is_vendor(abcd,"UMC UMC UMC ")
+//   ||cpuid_is_vendor(abcd,"NexGenDriven")
+  #else
+  l1 = l2 = l3 = -1;
+  #endif
+}
+
+/** \internal
+ * \returns the size in Bytes of the L1 data cache */
+inline int queryL1CacheSize()
+{
+  int l1(-1), l2, l3;
+  queryCacheSizes(l1,l2,l3);
+  return l1;
+}
+
+/** \internal
+ * \returns the size in Bytes of the L2 or L3 cache if this later is present */
+inline int queryTopLevelCacheSize()
+{
+  int l1, l2(-1), l3(-1);
+  queryCacheSizes(l1,l2,l3);
+  return (std::max)(l2,l3);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_MEMORY_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Meta.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Meta.h
new file mode 100644
index 00000000..81ae2a32
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/Meta.h
@@ -0,0 +1,812 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_META_H
+#define EIGEN_META_H
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+
+ #include <cfloat>
+
+ #if defined(EIGEN_CUDA_ARCH)
+  #include <math_constants.h>
+ #endif
+
+ #if defined(EIGEN_HIP_DEVICE_COMPILE)
+  #include "Eigen/src/Core/arch/HIP/hcc/math_constants.h"
+  #endif
+
+#endif
+
+// Recent versions of ICC require <cstdint> for pointer types below.
+#define EIGEN_ICC_NEEDS_CSTDINT (EIGEN_COMP_ICC>=1600 && EIGEN_COMP_CXXVER >= 11)
+
+// Define portable (u)int{32,64} types
+#if EIGEN_HAS_CXX11 || EIGEN_ICC_NEEDS_CSTDINT
+#include <cstdint>
+namespace Eigen {
+namespace numext {
+typedef std::uint8_t  uint8_t;
+typedef std::int8_t   int8_t;
+typedef std::uint16_t uint16_t;
+typedef std::int16_t  int16_t;
+typedef std::uint32_t uint32_t;
+typedef std::int32_t  int32_t;
+typedef std::uint64_t uint64_t;
+typedef std::int64_t  int64_t;
+}
+}
+#else
+// Without c++11, all compilers able to compile Eigen also
+// provide the C99 stdint.h header file.
+#include <stdint.h>
+namespace Eigen {
+namespace numext {
+typedef ::uint8_t  uint8_t;
+typedef ::int8_t   int8_t;
+typedef ::uint16_t uint16_t;
+typedef ::int16_t  int16_t;
+typedef ::uint32_t uint32_t;
+typedef ::int32_t  int32_t;
+typedef ::uint64_t uint64_t;
+typedef ::int64_t  int64_t;
+}
+}
+#endif
+
+namespace Eigen {
+
+typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE DenseIndex;
+
+/**
+ * \brief The Index type as used for the API.
+ * \details To change this, \c \#define the preprocessor symbol \c EIGEN_DEFAULT_DENSE_INDEX_TYPE.
+ * \sa \blank \ref TopicPreprocessorDirectives, StorageIndex.
+ */
+
+typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Index;
+
+namespace internal {
+
+/** \internal
+  * \file Meta.h
+  * This file contains generic metaprogramming classes which are not specifically related to Eigen.
+  * \note In case you wonder, yes we're aware that Boost already provides all these features,
+  * we however don't want to add a dependency to Boost.
+  */
+
+// Only recent versions of ICC complain about using ptrdiff_t to hold pointers,
+// and older versions do not provide *intptr_t types.
+#if EIGEN_ICC_NEEDS_CSTDINT
+typedef std::intptr_t  IntPtr;
+typedef std::uintptr_t UIntPtr;
+#else
+typedef std::ptrdiff_t IntPtr;
+typedef std::size_t UIntPtr;
+#endif
+#undef EIGEN_ICC_NEEDS_CSTDINT
+
+struct true_type {  enum { value = 1 }; };
+struct false_type { enum { value = 0 }; };
+
+template<bool Condition>
+struct bool_constant;
+
+template<>
+struct bool_constant<true> : true_type {};
+
+template<>
+struct bool_constant<false> : false_type {};
+
+template<bool Condition, typename Then, typename Else>
+struct conditional { typedef Then type; };
+
+template<typename Then, typename Else>
+struct conditional <false, Then, Else> { typedef Else type; };
+
+template<typename T> struct remove_reference { typedef T type; };
+template<typename T> struct remove_reference<T&> { typedef T type; };
+
+template<typename T> struct remove_pointer { typedef T type; };
+template<typename T> struct remove_pointer<T*> { typedef T type; };
+template<typename T> struct remove_pointer<T*const> { typedef T type; };
+
+template <class T> struct remove_const { typedef T type; };
+template <class T> struct remove_const<const T> { typedef T type; };
+template <class T> struct remove_const<const T[]> { typedef T type[]; };
+template <class T, unsigned int Size> struct remove_const<const T[Size]> { typedef T type[Size]; };
+
+template<typename T> struct remove_all { typedef T type; };
+template<typename T> struct remove_all<const T>   { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T const&>  { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T&>        { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T const*>  { typedef typename remove_all<T>::type type; };
+template<typename T> struct remove_all<T*>        { typedef typename remove_all<T>::type type; };
+
+template<typename T> struct is_arithmetic      { enum { value = false }; };
+template<> struct is_arithmetic<float>         { enum { value = true }; };
+template<> struct is_arithmetic<double>        { enum { value = true }; };
+template<> struct is_arithmetic<long double>   { enum { value = true }; };
+template<> struct is_arithmetic<bool>          { enum { value = true }; };
+template<> struct is_arithmetic<char>          { enum { value = true }; };
+template<> struct is_arithmetic<signed char>   { enum { value = true }; };
+template<> struct is_arithmetic<unsigned char> { enum { value = true }; };
+template<> struct is_arithmetic<signed short>  { enum { value = true }; };
+template<> struct is_arithmetic<unsigned short>{ enum { value = true }; };
+template<> struct is_arithmetic<signed int>    { enum { value = true }; };
+template<> struct is_arithmetic<unsigned int>  { enum { value = true }; };
+template<> struct is_arithmetic<signed long>   { enum { value = true }; };
+template<> struct is_arithmetic<unsigned long> { enum { value = true }; };
+
+template<typename T, typename U> struct is_same { enum { value = 0 }; };
+template<typename T> struct is_same<T,T> { enum { value = 1 }; };
+
+template< class T >
+struct is_void : is_same<void, typename remove_const<T>::type> {};
+
+#if EIGEN_HAS_CXX11
+template<> struct is_arithmetic<signed long long>   { enum { value = true }; };
+template<> struct is_arithmetic<unsigned long long> { enum { value = true }; };
+using std::is_integral;
+#else
+template<typename T> struct is_integral               { enum { value = false }; };
+template<> struct is_integral<bool>                   { enum { value = true }; };
+template<> struct is_integral<char>                   { enum { value = true }; };
+template<> struct is_integral<signed char>            { enum { value = true }; };
+template<> struct is_integral<unsigned char>          { enum { value = true }; };
+template<> struct is_integral<signed short>           { enum { value = true }; };
+template<> struct is_integral<unsigned short>         { enum { value = true }; };
+template<> struct is_integral<signed int>             { enum { value = true }; };
+template<> struct is_integral<unsigned int>           { enum { value = true }; };
+template<> struct is_integral<signed long>            { enum { value = true }; };
+template<> struct is_integral<unsigned long>          { enum { value = true }; };
+#if EIGEN_COMP_MSVC
+template<> struct is_integral<signed __int64>         { enum { value = true }; };
+template<> struct is_integral<unsigned __int64>       { enum { value = true }; };
+#endif
+#endif
+
+#if EIGEN_HAS_CXX11
+using std::make_unsigned;
+#else
+// TODO: Possibly improve this implementation of make_unsigned.
+// It is currently used only by
+// template<typename Scalar> struct random_default_impl<Scalar, false, true>.
+template<typename> struct make_unsigned;
+template<> struct make_unsigned<char>             { typedef unsigned char type; };
+template<> struct make_unsigned<signed char>      { typedef unsigned char type; };
+template<> struct make_unsigned<unsigned char>    { typedef unsigned char type; };
+template<> struct make_unsigned<signed short>     { typedef unsigned short type; };
+template<> struct make_unsigned<unsigned short>   { typedef unsigned short type; };
+template<> struct make_unsigned<signed int>       { typedef unsigned int type; };
+template<> struct make_unsigned<unsigned int>     { typedef unsigned int type; };
+template<> struct make_unsigned<signed long>      { typedef unsigned long type; };
+template<> struct make_unsigned<unsigned long>    { typedef unsigned long type; };
+#if EIGEN_COMP_MSVC
+template<> struct make_unsigned<signed __int64>   { typedef unsigned __int64 type; };
+template<> struct make_unsigned<unsigned __int64> { typedef unsigned __int64 type; };
+#endif
+
+// Some platforms define int64_t as `long long` even for C++03, where
+// `long long` is not guaranteed by the standard. In this case we are missing
+// the definition for make_unsigned. If we just define it, we run into issues
+// where `long long` doesn't exist in some compilers for C++03. We therefore add
+// the specialization for these platforms only.
+#if EIGEN_OS_MAC || EIGEN_COMP_MINGW
+template<> struct make_unsigned<unsigned long long> { typedef unsigned long long type; };
+template<> struct make_unsigned<long long>          { typedef unsigned long long type; };
+#endif
+#endif
+
+template <typename T> struct add_const { typedef const T type; };
+template <typename T> struct add_const<T&> { typedef T& type; };
+
+template <typename T> struct is_const { enum { value = 0 }; };
+template <typename T> struct is_const<T const> { enum { value = 1 }; };
+
+template<typename T> struct add_const_on_value_type            { typedef const T type;  };
+template<typename T> struct add_const_on_value_type<T&>        { typedef T const& type; };
+template<typename T> struct add_const_on_value_type<T*>        { typedef T const* type; };
+template<typename T> struct add_const_on_value_type<T* const>  { typedef T const* const type; };
+template<typename T> struct add_const_on_value_type<T const* const>  { typedef T const* const type; };
+
+#if EIGEN_HAS_CXX11
+
+using std::is_convertible;
+
+#else
+
+template<typename From, typename To>
+struct is_convertible_impl
+{
+private:
+  struct any_conversion
+  {
+    template <typename T> any_conversion(const volatile T&);
+    template <typename T> any_conversion(T&);
+  };
+  struct yes {int a[1];};
+  struct no  {int a[2];};
+
+  template<typename T>
+  static yes test(T, int);
+
+  template<typename T>
+  static no  test(any_conversion, ...);
+
+public:
+  static typename internal::remove_reference<From>::type* ms_from;
+#ifdef __INTEL_COMPILER
+  #pragma warning push
+  #pragma warning ( disable : 2259 )
+#endif
+  enum { value = sizeof(test<To>(*ms_from, 0))==sizeof(yes) };
+#ifdef __INTEL_COMPILER
+  #pragma warning pop
+#endif
+};
+
+template<typename From, typename To>
+struct is_convertible
+{
+  enum { value = is_convertible_impl<From,To>::value };
+};
+
+template<typename T>
+struct is_convertible<T,T&> { enum { value = false }; };
+
+template<typename T>
+struct is_convertible<const T,const T&> { enum { value = true }; };
+
+#endif
+
+/** \internal Allows to enable/disable an overload
+  * according to a compile time condition.
+  */
+template<bool Condition, typename T=void> struct enable_if;
+
+template<typename T> struct enable_if<true,T>
+{ typedef T type; };
+
+#if defined(EIGEN_GPU_COMPILE_PHASE) && !EIGEN_HAS_CXX11
+#if !defined(__FLT_EPSILON__)
+#define __FLT_EPSILON__ FLT_EPSILON
+#define __DBL_EPSILON__ DBL_EPSILON
+#endif
+
+namespace device {
+
+template<typename T> struct numeric_limits
+{
+  EIGEN_DEVICE_FUNC
+  static EIGEN_CONSTEXPR T epsilon() { return 0; }
+  static T (max)() { assert(false && "Highest not supported for this type"); }
+  static T (min)() { assert(false && "Lowest not supported for this type"); }
+  static T infinity() { assert(false && "Infinity not supported for this type"); }
+  static T quiet_NaN() { assert(false && "quiet_NaN not supported for this type"); }
+};
+template<> struct numeric_limits<float>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static float epsilon() { return __FLT_EPSILON__; }
+  EIGEN_DEVICE_FUNC
+  static float (max)() {
+  #if defined(EIGEN_CUDA_ARCH)
+    return CUDART_MAX_NORMAL_F;
+  #else
+    return HIPRT_MAX_NORMAL_F;
+  #endif
+  }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static float (min)() { return FLT_MIN; }
+  EIGEN_DEVICE_FUNC
+  static float infinity() {
+  #if defined(EIGEN_CUDA_ARCH)
+    return CUDART_INF_F;
+  #else
+    return HIPRT_INF_F;
+  #endif
+  }
+  EIGEN_DEVICE_FUNC
+  static float quiet_NaN() {
+  #if defined(EIGEN_CUDA_ARCH)
+    return CUDART_NAN_F;
+  #else
+    return HIPRT_NAN_F;
+  #endif
+  }
+};
+template<> struct numeric_limits<double>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static double epsilon() { return __DBL_EPSILON__; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static double (max)() { return DBL_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static double (min)() { return DBL_MIN; }
+  EIGEN_DEVICE_FUNC
+  static double infinity() {
+  #if defined(EIGEN_CUDA_ARCH)
+    return CUDART_INF;
+  #else
+    return HIPRT_INF;
+  #endif
+  }
+  EIGEN_DEVICE_FUNC
+  static double quiet_NaN() {
+  #if defined(EIGEN_CUDA_ARCH)
+    return CUDART_NAN;
+  #else
+    return HIPRT_NAN;
+  #endif
+  }
+};
+template<> struct numeric_limits<int>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int (max)() { return INT_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static int (min)() { return INT_MIN; }
+};
+template<> struct numeric_limits<unsigned int>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned int epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned int (max)() { return UINT_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned int (min)() { return 0; }
+};
+template<> struct numeric_limits<long>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long (max)() { return LONG_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long (min)() { return LONG_MIN; }
+};
+template<> struct numeric_limits<unsigned long>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long (max)() { return ULONG_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long (min)() { return 0; }
+};
+template<> struct numeric_limits<long long>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long long (max)() { return LLONG_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static long long (min)() { return LLONG_MIN; }
+};
+template<> struct numeric_limits<unsigned long long>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long long epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long long (max)() { return ULLONG_MAX; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static unsigned long long (min)() { return 0; }
+};
+template<> struct numeric_limits<bool>
+{
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static bool epsilon() { return false; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  static bool (max)() { return true; }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR 
+  static bool (min)() { return false; }
+};
+
+}
+
+#endif // defined(EIGEN_GPU_COMPILE_PHASE) && !EIGEN_HAS_CXX11
+
+/** \internal
+  * A base class do disable default copy ctor and copy assignment operator.
+  */
+class noncopyable
+{
+  EIGEN_DEVICE_FUNC noncopyable(const noncopyable&);
+  EIGEN_DEVICE_FUNC const noncopyable& operator=(const noncopyable&);
+protected:
+  EIGEN_DEVICE_FUNC noncopyable() {}
+  EIGEN_DEVICE_FUNC ~noncopyable() {}
+};
+
+/** \internal
+  * Provides access to the number of elements in the object of as a compile-time constant expression.
+  * It "returns" Eigen::Dynamic if the size cannot be resolved at compile-time (default).
+  *
+  * Similar to std::tuple_size, but more general.
+  *
+  * It currently supports:
+  *  - any types T defining T::SizeAtCompileTime
+  *  - plain C arrays as T[N]
+  *  - std::array (c++11)
+  *  - some internal types such as SingleRange and AllRange
+  *
+  * The second template parameter eases SFINAE-based specializations.
+  */
+template<typename T, typename EnableIf = void> struct array_size {
+  enum { value = Dynamic };
+};
+
+template<typename T> struct array_size<T,typename internal::enable_if<((T::SizeAtCompileTime&0)==0)>::type> {
+  enum { value = T::SizeAtCompileTime };
+};
+
+template<typename T, int N> struct array_size<const T (&)[N]> {
+  enum { value = N };
+};
+template<typename T, int N> struct array_size<T (&)[N]> {
+  enum { value = N };
+};
+
+#if EIGEN_HAS_CXX11
+template<typename T, std::size_t N> struct array_size<const std::array<T,N> > {
+  enum { value = N };
+};
+template<typename T, std::size_t N> struct array_size<std::array<T,N> > {
+  enum { value = N };
+};
+#endif
+
+/** \internal
+  * Analogue of the std::size free function.
+  * It returns the size of the container or view \a x of type \c T
+  *
+  * It currently supports:
+  *  - any types T defining a member T::size() const
+  *  - plain C arrays as T[N]
+  *
+  */
+template<typename T>
+EIGEN_CONSTEXPR Index size(const T& x) { return x.size(); }
+
+template<typename T,std::size_t N>
+EIGEN_CONSTEXPR Index size(const T (&) [N]) { return N; }
+
+/** \internal
+  * Convenient struct to get the result type of a nullary, unary, binary, or
+  * ternary functor.
+  * 
+  * Pre C++11:
+  * Supports both a Func::result_type member and templated
+  * Func::result<Func(ArgTypes...)>::type member.
+  * 
+  * If none of these members is provided, then the type of the first
+  * argument is returned.
+  * 
+  * Post C++11:
+  * This uses std::result_of. However, note the `type` member removes
+  * const and converts references/pointers to their corresponding value type.
+  */
+#if EIGEN_HAS_STD_INVOKE_RESULT
+template<typename T> struct result_of;
+
+template<typename F, typename... ArgTypes>
+struct result_of<F(ArgTypes...)> {
+  typedef typename std::invoke_result<F, ArgTypes...>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#elif EIGEN_HAS_STD_RESULT_OF
+template<typename T> struct result_of {
+  typedef typename std::result_of<T>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#else
+template<typename T> struct result_of { };
+
+struct has_none {int a[1];};
+struct has_std_result_type {int a[2];};
+struct has_tr1_result {int a[3];};
+
+template<typename Func, int SizeOf>
+struct nullary_result_of_select {};
+
+template<typename Func>
+struct nullary_result_of_select<Func, sizeof(has_std_result_type)> {typedef typename Func::result_type type;};
+
+template<typename Func>
+struct nullary_result_of_select<Func, sizeof(has_tr1_result)> {typedef typename Func::template result<Func()>::type type;};
+
+template<typename Func>
+struct result_of<Func()> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T()>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename nullary_result_of_select<Func, FunctorType>::type type;
+};
+
+template<typename Func, typename ArgType, int SizeOf=sizeof(has_none)>
+struct unary_result_of_select {typedef typename internal::remove_all<ArgType>::type type;};
+
+template<typename Func, typename ArgType>
+struct unary_result_of_select<Func, ArgType, sizeof(has_std_result_type)> {typedef typename Func::result_type type;};
+
+template<typename Func, typename ArgType>
+struct unary_result_of_select<Func, ArgType, sizeof(has_tr1_result)> {typedef typename Func::template result<Func(ArgType)>::type type;};
+
+template<typename Func, typename ArgType>
+struct result_of<Func(ArgType)> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T(ArgType)>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename unary_result_of_select<Func, ArgType, FunctorType>::type type;
+};
+
+template<typename Func, typename ArgType0, typename ArgType1, int SizeOf=sizeof(has_none)>
+struct binary_result_of_select {typedef typename internal::remove_all<ArgType0>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1>
+struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_std_result_type)>
+{typedef typename Func::result_type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1>
+struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_tr1_result)>
+{typedef typename Func::template result<Func(ArgType0,ArgType1)>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1>
+struct result_of<Func(ArgType0,ArgType1)> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1)>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename binary_result_of_select<Func, ArgType0, ArgType1, FunctorType>::type type;
+};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2, int SizeOf=sizeof(has_none)>
+struct ternary_result_of_select {typedef typename internal::remove_all<ArgType0>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
+struct ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, sizeof(has_std_result_type)>
+{typedef typename Func::result_type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
+struct ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, sizeof(has_tr1_result)>
+{typedef typename Func::template result<Func(ArgType0,ArgType1,ArgType2)>::type type;};
+
+template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
+struct result_of<Func(ArgType0,ArgType1,ArgType2)> {
+    template<typename T>
+    static has_std_result_type    testFunctor(T const *, typename T::result_type const * = 0);
+    template<typename T>
+    static has_tr1_result         testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1,ArgType2)>::type const * = 0);
+    static has_none               testFunctor(...);
+
+    // note that the following indirection is needed for gcc-3.3
+    enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
+    typedef typename ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, FunctorType>::type type;
+};
+
+#endif
+
+#if EIGEN_HAS_STD_INVOKE_RESULT
+template<typename F, typename... ArgTypes>
+struct invoke_result {
+  typedef typename std::invoke_result<F, ArgTypes...>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#elif EIGEN_HAS_CXX11
+template<typename F, typename... ArgTypes>
+struct invoke_result {
+  typedef typename result_of<F(ArgTypes...)>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#else
+template<typename F, typename ArgType0 = void, typename ArgType1 = void, typename ArgType2 = void>
+struct invoke_result {
+  typedef typename result_of<F(ArgType0, ArgType1, ArgType2)>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+
+template<typename F>
+struct invoke_result<F, void, void, void> {
+  typedef typename result_of<F()>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+
+template<typename F, typename ArgType0>
+struct invoke_result<F, ArgType0, void, void> {
+  typedef typename result_of<F(ArgType0)>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+
+template<typename F, typename ArgType0, typename ArgType1>
+struct invoke_result<F, ArgType0, ArgType1, void> {
+  typedef typename result_of<F(ArgType0, ArgType1)>::type type1;
+  typedef typename remove_all<type1>::type type;
+};
+#endif
+
+struct meta_yes { char a[1]; };
+struct meta_no  { char a[2]; };
+
+// Check whether T::ReturnType does exist
+template <typename T>
+struct has_ReturnType
+{
+  template <typename C> static meta_yes testFunctor(C const *, typename C::ReturnType const * = 0);
+  template <typename C> static meta_no  testFunctor(...);
+
+  enum { value = sizeof(testFunctor<T>(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+template<typename T> const T* return_ptr();
+
+template <typename T, typename IndexType=Index>
+struct has_nullary_operator
+{
+  template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()())>0)>::type * = 0);
+  static meta_no testFunctor(...);
+
+  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+template <typename T, typename IndexType=Index>
+struct has_unary_operator
+{
+  template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()(IndexType(0)))>0)>::type * = 0);
+  static meta_no testFunctor(...);
+
+  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+template <typename T, typename IndexType=Index>
+struct has_binary_operator
+{
+  template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()(IndexType(0),IndexType(0)))>0)>::type * = 0);
+  static meta_no testFunctor(...);
+
+  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
+};
+
+/** \internal In short, it computes int(sqrt(\a Y)) with \a Y an integer.
+  * Usage example: \code meta_sqrt<1023>::ret \endcode
+  */
+template<int Y,
+         int InfX = 0,
+         int SupX = ((Y==1) ? 1 : Y/2),
+         bool Done = ((SupX-InfX)<=1 ? true : ((SupX*SupX <= Y) && ((SupX+1)*(SupX+1) > Y))) >
+                                // use ?: instead of || just to shut up a stupid gcc 4.3 warning
+class meta_sqrt
+{
+    enum {
+      MidX = (InfX+SupX)/2,
+      TakeInf = MidX*MidX > Y ? 1 : 0,
+      NewInf = int(TakeInf) ? InfX : int(MidX),
+      NewSup = int(TakeInf) ? int(MidX) : SupX
+    };
+  public:
+    enum { ret = meta_sqrt<Y,NewInf,NewSup>::ret };
+};
+
+template<int Y, int InfX, int SupX>
+class meta_sqrt<Y, InfX, SupX, true> { public:  enum { ret = (SupX*SupX <= Y) ? SupX : InfX }; };
+
+
+/** \internal Computes the least common multiple of two positive integer A and B
+  * at compile-time. 
+  */
+template<int A, int B, int K=1, bool Done = ((A*K)%B)==0, bool Big=(A>=B)>
+struct meta_least_common_multiple
+{
+  enum { ret = meta_least_common_multiple<A,B,K+1>::ret };
+};
+template<int A, int B, int K, bool Done>
+struct meta_least_common_multiple<A,B,K,Done,false>
+{
+  enum { ret = meta_least_common_multiple<B,A,K>::ret };
+};
+template<int A, int B, int K>
+struct meta_least_common_multiple<A,B,K,true,true>
+{
+  enum { ret = A*K };
+};
+
+
+/** \internal determines whether the product of two numeric types is allowed and what the return type is */
+template<typename T, typename U> struct scalar_product_traits
+{
+  enum { Defined = 0 };
+};
+
+// FIXME quick workaround around current limitation of result_of
+// template<typename Scalar, typename ArgType0, typename ArgType1>
+// struct result_of<scalar_product_op<Scalar>(ArgType0,ArgType1)> {
+// typedef typename scalar_product_traits<typename remove_all<ArgType0>::type, typename remove_all<ArgType1>::type>::ReturnType type;
+// };
+
+/** \internal Obtains a POD type suitable to use as storage for an object of a size
+  * of at most Len bytes, aligned as specified by \c Align.
+  */
+template<unsigned Len, unsigned Align>
+struct aligned_storage {
+  struct type {
+    EIGEN_ALIGN_TO_BOUNDARY(Align) unsigned char data[Len];
+  };
+};
+
+} // end namespace internal
+
+namespace numext {
+
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+template<typename T> EIGEN_DEVICE_FUNC   void swap(T &a, T &b) { T tmp = b; b = a; a = tmp; }
+#else
+template<typename T> EIGEN_STRONG_INLINE void swap(T &a, T &b) { std::swap(a,b); }
+#endif
+
+#if defined(EIGEN_GPU_COMPILE_PHASE) && !EIGEN_HAS_CXX11
+using internal::device::numeric_limits;
+#else
+using std::numeric_limits;
+#endif
+
+// Integer division with rounding up.
+// T is assumed to be an integer type with a>=0, and b>0
+template<typename T>
+EIGEN_DEVICE_FUNC
+T div_ceil(const T &a, const T &b)
+{
+  return (a+b-1) / b;
+}
+
+// The aim of the following functions is to bypass -Wfloat-equal warnings
+// when we really want a strict equality comparison on floating points.
+template<typename X, typename Y> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool equal_strict(const X& x,const Y& y) { return x == y; }
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE) || (!defined(EIGEN_CUDA_ARCH) && defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC))
+template<> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool equal_strict(const float& x,const float& y) { return std::equal_to<float>()(x,y); }
+
+template<> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool equal_strict(const double& x,const double& y) { return std::equal_to<double>()(x,y); }
+#endif
+
+template<typename X, typename Y> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool not_equal_strict(const X& x,const Y& y) { return x != y; }
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE) || (!defined(EIGEN_CUDA_ARCH) && defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC))
+template<> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool not_equal_strict(const float& x,const float& y) { return std::not_equal_to<float>()(x,y); }
+
+template<> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
+bool not_equal_strict(const double& x,const double& y) { return std::not_equal_to<double>()(x,y); }
+#endif
+
+} // end namespace numext
+
+} // end namespace Eigen
+
+#endif // EIGEN_META_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/NonMPL2.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/NonMPL2.h
new file mode 100644
index 00000000..1af67cf1
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/NonMPL2.h
@@ -0,0 +1,3 @@
+#ifdef EIGEN_MPL2_ONLY
+#error Including non-MPL2 code in EIGEN_MPL2_ONLY mode
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ReenableStupidWarnings.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ReenableStupidWarnings.h
new file mode 100644
index 00000000..1ce6fd1b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ReenableStupidWarnings.h
@@ -0,0 +1,31 @@
+#ifdef EIGEN_WARNINGS_DISABLED_2
+// "DisableStupidWarnings.h" was included twice recursively: Do not reenable warnings yet!
+#  undef EIGEN_WARNINGS_DISABLED_2
+
+#elif defined(EIGEN_WARNINGS_DISABLED)
+#undef EIGEN_WARNINGS_DISABLED
+
+#ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
+  #ifdef _MSC_VER
+    #pragma warning( pop )
+  #elif defined __INTEL_COMPILER
+    #pragma warning pop
+  #elif defined __clang__
+    #pragma clang diagnostic pop
+  #elif defined __GNUC__  &&  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+    #pragma GCC diagnostic pop
+  #endif
+
+  #if defined __NVCC__
+//    Don't reenable the diagnostic messages, as it turns out these messages need
+//    to be disabled at the point of the template instantiation (i.e the user code)
+//    otherwise they'll be triggered by nvcc.
+//    #pragma diag_default code_is_unreachable
+//    #pragma diag_default initialization_not_reachable
+//    #pragma diag_default 2651
+//    #pragma diag_default 2653
+  #endif
+
+#endif
+
+#endif // EIGEN_WARNINGS_DISABLED
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ReshapedHelper.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ReshapedHelper.h
new file mode 100644
index 00000000..41243213
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/ReshapedHelper.h
@@ -0,0 +1,51 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_RESHAPED_HELPER_H
+#define EIGEN_RESHAPED_HELPER_H
+
+namespace Eigen {
+
+enum AutoSize_t   { AutoSize };
+const int AutoOrder = 2;
+
+namespace internal {
+
+template<typename SizeType,typename OtherSize, int TotalSize>
+struct get_compiletime_reshape_size {
+  enum { value = get_fixed_value<SizeType>::value };
+};
+
+template<typename SizeType>
+Index get_runtime_reshape_size(SizeType size, Index /*other*/, Index /*total*/) {
+  return internal::get_runtime_value(size);
+}
+
+template<typename OtherSize, int TotalSize>
+struct get_compiletime_reshape_size<AutoSize_t,OtherSize,TotalSize> {
+  enum {
+    other_size = get_fixed_value<OtherSize>::value,
+    value = (TotalSize==Dynamic || other_size==Dynamic) ? Dynamic : TotalSize / other_size };
+};
+
+inline Index get_runtime_reshape_size(AutoSize_t /*size*/, Index other, Index total) {
+  return total/other;
+}
+
+template<int Flags, int Order>
+struct get_compiletime_reshape_order {
+  enum { value = Order == AutoOrder ? Flags & RowMajorBit : Order };
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_RESHAPED_HELPER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/StaticAssert.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/StaticAssert.h
new file mode 100644
index 00000000..c45de590
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/StaticAssert.h
@@ -0,0 +1,221 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STATIC_ASSERT_H
+#define EIGEN_STATIC_ASSERT_H
+
+/* Some notes on Eigen's static assertion mechanism:
+ *
+ *  - in EIGEN_STATIC_ASSERT(CONDITION,MSG) the parameter CONDITION must be a compile time boolean
+ *    expression, and MSG an enum listed in struct internal::static_assertion<true>
+ *
+ *  - define EIGEN_NO_STATIC_ASSERT to disable them (and save compilation time)
+ *    in that case, the static assertion is converted to the following runtime assert:
+ *      eigen_assert(CONDITION && "MSG")
+ *
+ *  - currently EIGEN_STATIC_ASSERT can only be used in function scope
+ *
+ */
+
+#ifndef EIGEN_STATIC_ASSERT
+#ifndef EIGEN_NO_STATIC_ASSERT
+
+  #if EIGEN_MAX_CPP_VER>=11 && (__has_feature(cxx_static_assert) || (EIGEN_COMP_CXXVER >= 11) || (EIGEN_COMP_MSVC >= 1600))
+
+    // if native static_assert is enabled, let's use it
+    #define EIGEN_STATIC_ASSERT(X,MSG) static_assert(X,#MSG);
+
+  #else // not CXX0X
+
+    namespace Eigen {
+
+    namespace internal {
+
+    template<bool condition>
+    struct static_assertion {};
+
+    template<>
+    struct static_assertion<true>
+    {
+      enum {
+        YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX=1,
+        YOU_MIXED_VECTORS_OF_DIFFERENT_SIZES=1,
+        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES=1,
+        THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE=1,
+        THIS_METHOD_IS_ONLY_FOR_MATRICES_OF_A_SPECIFIC_SIZE=1,
+        THIS_METHOD_IS_ONLY_FOR_OBJECTS_OF_A_SPECIFIC_SIZE=1,
+        OUT_OF_RANGE_ACCESS=1,
+        YOU_MADE_A_PROGRAMMING_MISTAKE=1,
+        EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT=1,
+        EIGEN_INTERNAL_COMPILATION_ERROR_OR_YOU_MADE_A_PROGRAMMING_MISTAKE=1,
+        YOU_CALLED_A_FIXED_SIZE_METHOD_ON_A_DYNAMIC_SIZE_MATRIX_OR_VECTOR=1,
+        YOU_CALLED_A_DYNAMIC_SIZE_METHOD_ON_A_FIXED_SIZE_MATRIX_OR_VECTOR=1,
+        UNALIGNED_LOAD_AND_STORE_OPERATIONS_UNIMPLEMENTED_ON_ALTIVEC=1,
+        THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES=1,
+        FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED=1,
+        NUMERIC_TYPE_MUST_BE_REAL=1,
+        COEFFICIENT_WRITE_ACCESS_TO_SELFADJOINT_NOT_SUPPORTED=1,
+        WRITING_TO_TRIANGULAR_PART_WITH_UNIT_DIAGONAL_IS_NOT_SUPPORTED=1,
+        THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE=1,
+        INVALID_MATRIX_PRODUCT=1,
+        INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS=1,
+        INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION=1,
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY=1,
+        THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES=1,
+        THIS_METHOD_IS_ONLY_FOR_ROW_MAJOR_MATRICES=1,
+        INVALID_MATRIX_TEMPLATE_PARAMETERS=1,
+        INVALID_MATRIXBASE_TEMPLATE_PARAMETERS=1,
+        BOTH_MATRICES_MUST_HAVE_THE_SAME_STORAGE_ORDER=1,
+        THIS_METHOD_IS_ONLY_FOR_DIAGONAL_MATRIX=1,
+        THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE=1,
+        THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES=1,
+        YOU_ALREADY_SPECIFIED_THIS_STRIDE=1,
+        INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION=1,
+        THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD=1,
+        PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1=1,
+        THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS=1,
+        YOU_CANNOT_MIX_ARRAYS_AND_MATRICES=1,
+        YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION=1,
+        THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY=1,
+        YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT=1,
+        THIS_METHOD_IS_ONLY_FOR_1x1_EXPRESSIONS=1,
+        THIS_METHOD_IS_ONLY_FOR_INNER_OR_LAZY_PRODUCTS=1,
+        THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL=1,
+        THIS_METHOD_IS_ONLY_FOR_ARRAYS_NOT_MATRICES=1,
+        YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED=1,
+        YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED=1,
+        THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE=1,
+        THE_STORAGE_ORDER_OF_BOTH_SIDES_MUST_MATCH=1,
+        OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG=1,
+        IMPLICIT_CONVERSION_TO_SCALAR_IS_FOR_INNER_PRODUCT_ONLY=1,
+        STORAGE_LAYOUT_DOES_NOT_MATCH=1,
+        EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT__INVALID_COST_VALUE=1,
+        THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS=1,
+        MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY=1,
+        THIS_TYPE_IS_NOT_SUPPORTED=1,
+        STORAGE_KIND_MUST_MATCH=1,
+        STORAGE_INDEX_MUST_MATCH=1,
+        CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY=1,
+        SELFADJOINTVIEW_ACCEPTS_UPPER_AND_LOWER_MODE_ONLY=1,
+        INVALID_TEMPLATE_PARAMETER=1,
+        GPU_TENSOR_CONTRACTION_DOES_NOT_SUPPORT_OUTPUT_KERNELS=1,
+        THE_ARRAY_SIZE_SHOULD_EQUAL_WITH_PACKET_SIZE=1
+      };
+    };
+
+    } // end namespace internal
+
+    } // end namespace Eigen
+
+    // Specialized implementation for MSVC to avoid "conditional
+    // expression is constant" warnings.  This implementation doesn't
+    // appear to work under GCC, hence the multiple implementations.
+    #if EIGEN_COMP_MSVC
+
+      #define EIGEN_STATIC_ASSERT(CONDITION,MSG) \
+        {Eigen::internal::static_assertion<bool(CONDITION)>::MSG;}
+
+    #else
+      // In some cases clang interprets bool(CONDITION) as function declaration
+      #define EIGEN_STATIC_ASSERT(CONDITION,MSG) \
+        if (Eigen::internal::static_assertion<static_cast<bool>(CONDITION)>::MSG) {}
+
+    #endif
+
+  #endif // not CXX0X
+
+#else // EIGEN_NO_STATIC_ASSERT
+
+  #define EIGEN_STATIC_ASSERT(CONDITION,MSG) eigen_assert((CONDITION) && #MSG);
+
+#endif // EIGEN_NO_STATIC_ASSERT
+#endif // EIGEN_STATIC_ASSERT
+
+// static assertion failing if the type \a TYPE is not a vector type
+#define EIGEN_STATIC_ASSERT_VECTOR_ONLY(TYPE) \
+  EIGEN_STATIC_ASSERT(TYPE::IsVectorAtCompileTime, \
+                      YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX)
+
+// static assertion failing if the type \a TYPE is not fixed-size
+#define EIGEN_STATIC_ASSERT_FIXED_SIZE(TYPE) \
+  EIGEN_STATIC_ASSERT(TYPE::SizeAtCompileTime!=Eigen::Dynamic, \
+                      YOU_CALLED_A_FIXED_SIZE_METHOD_ON_A_DYNAMIC_SIZE_MATRIX_OR_VECTOR)
+
+// static assertion failing if the type \a TYPE is not dynamic-size
+#define EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(TYPE) \
+  EIGEN_STATIC_ASSERT(TYPE::SizeAtCompileTime==Eigen::Dynamic, \
+                      YOU_CALLED_A_DYNAMIC_SIZE_METHOD_ON_A_FIXED_SIZE_MATRIX_OR_VECTOR)
+
+// static assertion failing if the type \a TYPE is not a vector type of the given size
+#define EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(TYPE, SIZE) \
+  EIGEN_STATIC_ASSERT(TYPE::IsVectorAtCompileTime && TYPE::SizeAtCompileTime==SIZE, \
+                      THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE)
+
+// static assertion failing if the type \a TYPE is not a vector type of the given size
+#define EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(TYPE, ROWS, COLS) \
+  EIGEN_STATIC_ASSERT(TYPE::RowsAtCompileTime==ROWS && TYPE::ColsAtCompileTime==COLS, \
+                      THIS_METHOD_IS_ONLY_FOR_MATRICES_OF_A_SPECIFIC_SIZE)
+
+// static assertion failing if the two vector expression types are not compatible (same fixed-size or dynamic size)
+#define EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(TYPE0,TYPE1) \
+  EIGEN_STATIC_ASSERT( \
+      (int(TYPE0::SizeAtCompileTime)==Eigen::Dynamic \
+    || int(TYPE1::SizeAtCompileTime)==Eigen::Dynamic \
+    || int(TYPE0::SizeAtCompileTime)==int(TYPE1::SizeAtCompileTime)),\
+    YOU_MIXED_VECTORS_OF_DIFFERENT_SIZES)
+
+#define EIGEN_PREDICATE_SAME_MATRIX_SIZE(TYPE0,TYPE1) \
+     ( \
+        (int(Eigen::internal::size_of_xpr_at_compile_time<TYPE0>::ret)==0 && int(Eigen::internal::size_of_xpr_at_compile_time<TYPE1>::ret)==0) \
+    || (\
+          (int(TYPE0::RowsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE1::RowsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE0::RowsAtCompileTime)==int(TYPE1::RowsAtCompileTime)) \
+      &&  (int(TYPE0::ColsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE1::ColsAtCompileTime)==Eigen::Dynamic \
+        || int(TYPE0::ColsAtCompileTime)==int(TYPE1::ColsAtCompileTime))\
+       ) \
+     )
+
+#define EIGEN_STATIC_ASSERT_NON_INTEGER(TYPE) \
+    EIGEN_STATIC_ASSERT(!Eigen::NumTraits<TYPE>::IsInteger, THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES)
+
+
+// static assertion failing if it is guaranteed at compile-time that the two matrix expression types have different sizes
+#define EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(TYPE0,TYPE1) \
+  EIGEN_STATIC_ASSERT( \
+     EIGEN_PREDICATE_SAME_MATRIX_SIZE(TYPE0,TYPE1),\
+    YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+
+#define EIGEN_STATIC_ASSERT_SIZE_1x1(TYPE) \
+      EIGEN_STATIC_ASSERT((TYPE::RowsAtCompileTime == 1 || TYPE::RowsAtCompileTime == Eigen::Dynamic) && \
+                          (TYPE::ColsAtCompileTime == 1 || TYPE::ColsAtCompileTime == Eigen::Dynamic), \
+                          THIS_METHOD_IS_ONLY_FOR_1x1_EXPRESSIONS)
+
+#define EIGEN_STATIC_ASSERT_LVALUE(Derived) \
+      EIGEN_STATIC_ASSERT(Eigen::internal::is_lvalue<Derived>::value, \
+                          THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY)
+
+#define EIGEN_STATIC_ASSERT_ARRAYXPR(Derived) \
+      EIGEN_STATIC_ASSERT((Eigen::internal::is_same<typename Eigen::internal::traits<Derived>::XprKind, ArrayXpr>::value), \
+                          THIS_METHOD_IS_ONLY_FOR_ARRAYS_NOT_MATRICES)
+
+#define EIGEN_STATIC_ASSERT_SAME_XPR_KIND(Derived1, Derived2) \
+      EIGEN_STATIC_ASSERT((Eigen::internal::is_same<typename Eigen::internal::traits<Derived1>::XprKind, \
+                                             typename Eigen::internal::traits<Derived2>::XprKind \
+                                            >::value), \
+                          YOU_CANNOT_MIX_ARRAYS_AND_MATRICES)
+
+// Check that a cost value is positive, and that is stay within a reasonable range
+// TODO this check could be enabled for internal debugging only
+#define EIGEN_INTERNAL_CHECK_COST_VALUE(C) \
+      EIGEN_STATIC_ASSERT((C)>=0 && (C)<=HugeCost*HugeCost, EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT__INVALID_COST_VALUE);
+
+#endif // EIGEN_STATIC_ASSERT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/SymbolicIndex.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/SymbolicIndex.h
new file mode 100644
index 00000000..354dd9ad
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/SymbolicIndex.h
@@ -0,0 +1,293 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SYMBOLIC_INDEX_H
+#define EIGEN_SYMBOLIC_INDEX_H
+
+namespace Eigen {
+
+/** \namespace Eigen::symbolic
+  * \ingroup Core_Module
+  *
+  * This namespace defines a set of classes and functions to build and evaluate symbolic expressions of scalar type Index.
+  * Here is a simple example:
+  *
+  * \code
+  * // First step, defines symbols:
+  * struct x_tag {};  static const symbolic::SymbolExpr<x_tag> x;
+  * struct y_tag {};  static const symbolic::SymbolExpr<y_tag> y;
+  * struct z_tag {};  static const symbolic::SymbolExpr<z_tag> z;
+  *
+  * // Defines an expression:
+  * auto expr = (x+3)/y+z;
+  *
+  * // And evaluate it: (c++14)
+  * std::cout << expr.eval(x=6,y=3,z=-13) << "\n";
+  *
+  * // In c++98/11, only one symbol per expression is supported for now:
+  * auto expr98 = (3-x)/2;
+  * std::cout << expr98.eval(x=6) << "\n";
+  * \endcode
+  *
+  * It is currently only used internally to define and manipulate the Eigen::last and Eigen::lastp1 symbols in Eigen::seq and Eigen::seqN.
+  *
+  */
+namespace symbolic {
+
+template<typename Tag> class Symbol;
+template<typename Arg0> class NegateExpr;
+template<typename Arg1,typename Arg2> class AddExpr;
+template<typename Arg1,typename Arg2> class ProductExpr;
+template<typename Arg1,typename Arg2> class QuotientExpr;
+
+// A simple wrapper around an integral value to provide the eval method.
+// We could also use a free-function symbolic_eval...
+template<typename IndexType=Index>
+class ValueExpr {
+public:
+  ValueExpr(IndexType val) : m_value(val) {}
+  template<typename T>
+  IndexType eval_impl(const T&) const { return m_value; }
+protected:
+  IndexType m_value;
+};
+
+// Specialization for compile-time value,
+// It is similar to ValueExpr(N) but this version helps the compiler to generate better code.
+template<int N>
+class ValueExpr<internal::FixedInt<N> > {
+public:
+  ValueExpr() {}
+  template<typename T>
+  EIGEN_CONSTEXPR Index eval_impl(const T&) const { return N; }
+};
+
+
+/** \class BaseExpr
+  * \ingroup Core_Module
+  * Common base class of any symbolic expressions
+  */
+template<typename Derived>
+class BaseExpr
+{
+public:
+  const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+  /** Evaluate the expression given the \a values of the symbols.
+    *
+    * \param values defines the values of the symbols, it can either be a SymbolValue or a std::tuple of SymbolValue
+    *               as constructed by SymbolExpr::operator= operator.
+    *
+    */
+  template<typename T>
+  Index eval(const T& values) const { return derived().eval_impl(values); }
+
+#if EIGEN_HAS_CXX14
+  template<typename... Types>
+  Index eval(Types&&... values) const { return derived().eval_impl(std::make_tuple(values...)); }
+#endif
+
+  NegateExpr<Derived> operator-() const { return NegateExpr<Derived>(derived()); }
+
+  AddExpr<Derived,ValueExpr<> > operator+(Index b) const
+  { return AddExpr<Derived,ValueExpr<> >(derived(),  b); }
+  AddExpr<Derived,ValueExpr<> > operator-(Index a) const
+  { return AddExpr<Derived,ValueExpr<> >(derived(), -a); }
+  ProductExpr<Derived,ValueExpr<> > operator*(Index a) const
+  { return ProductExpr<Derived,ValueExpr<> >(derived(),a); }
+  QuotientExpr<Derived,ValueExpr<> > operator/(Index a) const
+  { return QuotientExpr<Derived,ValueExpr<> >(derived(),a); }
+
+  friend AddExpr<Derived,ValueExpr<> > operator+(Index a, const BaseExpr& b)
+  { return AddExpr<Derived,ValueExpr<> >(b.derived(), a); }
+  friend AddExpr<NegateExpr<Derived>,ValueExpr<> > operator-(Index a, const BaseExpr& b)
+  { return AddExpr<NegateExpr<Derived>,ValueExpr<> >(-b.derived(), a); }
+  friend ProductExpr<ValueExpr<>,Derived> operator*(Index a, const BaseExpr& b)
+  { return ProductExpr<ValueExpr<>,Derived>(a,b.derived()); }
+  friend QuotientExpr<ValueExpr<>,Derived> operator/(Index a, const BaseExpr& b)
+  { return QuotientExpr<ValueExpr<>,Derived>(a,b.derived()); }
+
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N>) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > > operator-(internal::FixedInt<N>) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > >(derived(), ValueExpr<internal::FixedInt<-N> >()); }
+  template<int N>
+  ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator*(internal::FixedInt<N>) const
+  { return ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator/(internal::FixedInt<N>) const
+  { return QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+
+  template<int N>
+  friend AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N>, const BaseExpr& b)
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > > operator-(internal::FixedInt<N>, const BaseExpr& b)
+  { return AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > >(-b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator*(internal::FixedInt<N>, const BaseExpr& b)
+  { return ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+  template<int N>
+  friend QuotientExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator/(internal::FixedInt<N>, const BaseExpr& b)
+  { return QuotientExpr<ValueExpr<internal::FixedInt<N> > ,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+
+#if (!EIGEN_HAS_CXX14)
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N> (*)()) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > > operator-(internal::FixedInt<N> (*)()) const
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > >(derived(), ValueExpr<internal::FixedInt<-N> >()); }
+  template<int N>
+  ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator*(internal::FixedInt<N> (*)()) const
+  { return ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator/(internal::FixedInt<N> (*)()) const
+  { return QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); }
+
+  template<int N>
+  friend AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > > operator-(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > >(-b.derived(), ValueExpr<internal::FixedInt<N> >()); }
+  template<int N>
+  friend ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator*(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+  template<int N>
+  friend QuotientExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator/(internal::FixedInt<N> (*)(), const BaseExpr& b)
+  { return QuotientExpr<ValueExpr<internal::FixedInt<N> > ,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); }
+#endif
+
+
+  template<typename OtherDerived>
+  AddExpr<Derived,OtherDerived> operator+(const BaseExpr<OtherDerived> &b) const
+  { return AddExpr<Derived,OtherDerived>(derived(),  b.derived()); }
+
+  template<typename OtherDerived>
+  AddExpr<Derived,NegateExpr<OtherDerived> > operator-(const BaseExpr<OtherDerived> &b) const
+  { return AddExpr<Derived,NegateExpr<OtherDerived> >(derived(), -b.derived()); }
+
+  template<typename OtherDerived>
+  ProductExpr<Derived,OtherDerived> operator*(const BaseExpr<OtherDerived> &b) const
+  { return ProductExpr<Derived,OtherDerived>(derived(), b.derived()); }
+
+  template<typename OtherDerived>
+  QuotientExpr<Derived,OtherDerived> operator/(const BaseExpr<OtherDerived> &b) const
+  { return QuotientExpr<Derived,OtherDerived>(derived(), b.derived()); }
+};
+
+template<typename T>
+struct is_symbolic {
+  // BaseExpr has no conversion ctor, so we only have to check whether T can be statically cast to its base class BaseExpr<T>.
+  enum { value = internal::is_convertible<T,BaseExpr<T> >::value };
+};
+
+/** Represents the actual value of a symbol identified by its tag
+  *
+  * It is the return type of SymbolValue::operator=, and most of the time this is only way it is used.
+  */
+template<typename Tag>
+class SymbolValue
+{
+public:
+  /** Default constructor from the value \a val */
+  SymbolValue(Index val) : m_value(val) {}
+
+  /** \returns the stored value of the symbol */
+  Index value() const { return m_value; }
+protected:
+  Index m_value;
+};
+
+/** Expression of a symbol uniquely identified by the template parameter type \c tag */
+template<typename tag>
+class SymbolExpr : public BaseExpr<SymbolExpr<tag> >
+{
+public:
+  /** Alias to the template parameter \c tag */
+  typedef tag Tag;
+
+  SymbolExpr() {}
+
+  /** Associate the value \a val to the given symbol \c *this, uniquely identified by its \c Tag.
+    *
+    * The returned object should be passed to ExprBase::eval() to evaluate a given expression with this specified runtime-time value.
+    */
+  SymbolValue<Tag> operator=(Index val) const {
+    return SymbolValue<Tag>(val);
+  }
+
+  Index eval_impl(const SymbolValue<Tag> &values) const { return values.value(); }
+
+#if EIGEN_HAS_CXX14
+  // C++14 versions suitable for multiple symbols
+  template<typename... Types>
+  Index eval_impl(const std::tuple<Types...>& values) const { return std::get<SymbolValue<Tag> >(values).value(); }
+#endif
+};
+
+template<typename Arg0>
+class NegateExpr : public BaseExpr<NegateExpr<Arg0> >
+{
+public:
+  NegateExpr(const Arg0& arg0) : m_arg0(arg0) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return -m_arg0.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+};
+
+template<typename Arg0, typename Arg1>
+class AddExpr : public BaseExpr<AddExpr<Arg0,Arg1> >
+{
+public:
+  AddExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) + m_arg1.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+  Arg1 m_arg1;
+};
+
+template<typename Arg0, typename Arg1>
+class ProductExpr : public BaseExpr<ProductExpr<Arg0,Arg1> >
+{
+public:
+  ProductExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) * m_arg1.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+  Arg1 m_arg1;
+};
+
+template<typename Arg0, typename Arg1>
+class QuotientExpr : public BaseExpr<QuotientExpr<Arg0,Arg1> >
+{
+public:
+  QuotientExpr(const Arg0& arg0, const Arg1& arg1) : m_arg0(arg0), m_arg1(arg1) {}
+
+  template<typename T>
+  Index eval_impl(const T& values) const { return m_arg0.eval_impl(values) / m_arg1.eval_impl(values); }
+protected:
+  Arg0 m_arg0;
+  Arg1 m_arg1;
+};
+
+} // end namespace symbolic
+
+} // end namespace Eigen
+
+#endif // EIGEN_SYMBOLIC_INDEX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/XprHelper.h b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/XprHelper.h
new file mode 100644
index 00000000..71c32b8a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Core/util/XprHelper.h
@@ -0,0 +1,856 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_XPRHELPER_H
+#define EIGEN_XPRHELPER_H
+
+// just a workaround because GCC seems to not really like empty structs
+// FIXME: gcc 4.3 generates bad code when strict-aliasing is enabled
+// so currently we simply disable this optimization for gcc 4.3
+#if EIGEN_COMP_GNUC && !EIGEN_GNUC_AT(4,3)
+  #define EIGEN_EMPTY_STRUCT_CTOR(X) \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE X() {} \
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE X(const X& ) {}
+#else
+  #define EIGEN_EMPTY_STRUCT_CTOR(X)
+#endif
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename IndexDest, typename IndexSrc>
+EIGEN_DEVICE_FUNC
+inline IndexDest convert_index(const IndexSrc& idx) {
+  // for sizeof(IndexDest)>=sizeof(IndexSrc) compilers should be able to optimize this away:
+  eigen_internal_assert(idx <= NumTraits<IndexDest>::highest() && "Index value to big for target type");
+  return IndexDest(idx);
+}
+
+// true if T can be considered as an integral index (i.e., and integral type or enum)
+template<typename T> struct is_valid_index_type
+{
+  enum { value =
+#if EIGEN_HAS_TYPE_TRAITS
+    internal::is_integral<T>::value || std::is_enum<T>::value
+#elif EIGEN_COMP_MSVC
+    internal::is_integral<T>::value || __is_enum(T)
+#else
+    // without C++11, we use is_convertible to Index instead of is_integral in order to treat enums as Index.
+    internal::is_convertible<T,Index>::value && !internal::is_same<T,float>::value && !is_same<T,double>::value
+#endif
+  };
+};
+
+// true if both types are not valid index types
+template<typename RowIndices, typename ColIndices>
+struct valid_indexed_view_overload {
+  enum { value = !(internal::is_valid_index_type<RowIndices>::value && internal::is_valid_index_type<ColIndices>::value) };
+};
+
+// promote_scalar_arg is an helper used in operation between an expression and a scalar, like:
+//    expression * scalar
+// Its role is to determine how the type T of the scalar operand should be promoted given the scalar type ExprScalar of the given expression.
+// The IsSupported template parameter must be provided by the caller as: internal::has_ReturnType<ScalarBinaryOpTraits<ExprScalar,T,op> >::value using the proper order for ExprScalar and T.
+// Then the logic is as follows:
+//  - if the operation is natively supported as defined by IsSupported, then the scalar type is not promoted, and T is returned.
+//  - otherwise, NumTraits<ExprScalar>::Literal is returned if T is implicitly convertible to NumTraits<ExprScalar>::Literal AND that this does not imply a float to integer conversion.
+//  - otherwise, ExprScalar is returned if T is implicitly convertible to ExprScalar AND that this does not imply a float to integer conversion.
+//  - In all other cases, the promoted type is not defined, and the respective operation is thus invalid and not available (SFINAE).
+template<typename ExprScalar,typename T, bool IsSupported>
+struct promote_scalar_arg;
+
+template<typename S,typename T>
+struct promote_scalar_arg<S,T,true>
+{
+  typedef T type;
+};
+
+// Recursively check safe conversion to PromotedType, and then ExprScalar if they are different.
+template<typename ExprScalar,typename T,typename PromotedType,
+  bool ConvertibleToLiteral = internal::is_convertible<T,PromotedType>::value,
+  bool IsSafe = NumTraits<T>::IsInteger || !NumTraits<PromotedType>::IsInteger>
+struct promote_scalar_arg_unsupported;
+
+// Start recursion with NumTraits<ExprScalar>::Literal
+template<typename S,typename T>
+struct promote_scalar_arg<S,T,false> : promote_scalar_arg_unsupported<S,T,typename NumTraits<S>::Literal> {};
+
+// We found a match!
+template<typename S,typename T, typename PromotedType>
+struct promote_scalar_arg_unsupported<S,T,PromotedType,true,true>
+{
+  typedef PromotedType type;
+};
+
+// No match, but no real-to-integer issues, and ExprScalar and current PromotedType are different,
+// so let's try to promote to ExprScalar
+template<typename ExprScalar,typename T, typename PromotedType>
+struct promote_scalar_arg_unsupported<ExprScalar,T,PromotedType,false,true>
+   : promote_scalar_arg_unsupported<ExprScalar,T,ExprScalar>
+{};
+
+// Unsafe real-to-integer, let's stop.
+template<typename S,typename T, typename PromotedType, bool ConvertibleToLiteral>
+struct promote_scalar_arg_unsupported<S,T,PromotedType,ConvertibleToLiteral,false> {};
+
+// T is not even convertible to ExprScalar, let's stop.
+template<typename S,typename T>
+struct promote_scalar_arg_unsupported<S,T,S,false,true> {};
+
+//classes inheriting no_assignment_operator don't generate a default operator=.
+class no_assignment_operator
+{
+  private:
+    no_assignment_operator& operator=(const no_assignment_operator&);
+  protected:
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(no_assignment_operator)
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(no_assignment_operator)
+};
+
+/** \internal return the index type with the largest number of bits */
+template<typename I1, typename I2>
+struct promote_index_type
+{
+  typedef typename conditional<(sizeof(I1)<sizeof(I2)), I2, I1>::type type;
+};
+
+/** \internal If the template parameter Value is Dynamic, this class is just a wrapper around a T variable that
+  * can be accessed using value() and setValue().
+  * Otherwise, this class is an empty structure and value() just returns the template parameter Value.
+  */
+template<typename T, int Value> class variable_if_dynamic
+{
+  public:
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(variable_if_dynamic)
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamic(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); eigen_assert(v == T(Value)); }
+    EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    T value() { return T(Value); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    operator T() const { return T(Value); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void setValue(T v) const { EIGEN_ONLY_USED_FOR_DEBUG(v); eigen_assert(v == T(Value)); }
+};
+
+template<typename T> class variable_if_dynamic<T, Dynamic>
+{
+    T m_value;
+  public:
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamic(T value = 0) EIGEN_NO_THROW : m_value(value) {}
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T value() const { return m_value; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE operator T() const { return m_value; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void setValue(T value) { m_value = value; }
+};
+
+/** \internal like variable_if_dynamic but for DynamicIndex
+  */
+template<typename T, int Value> class variable_if_dynamicindex
+{
+  public:
+    EIGEN_EMPTY_STRUCT_CTOR(variable_if_dynamicindex)
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamicindex(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); eigen_assert(v == T(Value)); }
+    EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+    T value() { return T(Value); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    void setValue(T) {}
+};
+
+template<typename T> class variable_if_dynamicindex<T, DynamicIndex>
+{
+    T m_value;
+    EIGEN_DEVICE_FUNC variable_if_dynamicindex() { eigen_assert(false); }
+  public:
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit variable_if_dynamicindex(T value) : m_value(value) {}
+    EIGEN_DEVICE_FUNC T EIGEN_STRONG_INLINE value() const { return m_value; }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void setValue(T value) { m_value = value; }
+};
+
+template<typename T> struct functor_traits
+{
+  enum
+  {
+    Cost = 10,
+    PacketAccess = false,
+    IsRepeatable = false
+  };
+};
+
+template<typename T> struct packet_traits;
+
+template<typename T> struct unpacket_traits;
+
+template<int Size, typename PacketType,
+         bool Stop = Size==Dynamic || (Size%unpacket_traits<PacketType>::size)==0 || is_same<PacketType,typename unpacket_traits<PacketType>::half>::value>
+struct find_best_packet_helper;
+
+template< int Size, typename PacketType>
+struct find_best_packet_helper<Size,PacketType,true>
+{
+  typedef PacketType type;
+};
+
+template<int Size, typename PacketType>
+struct find_best_packet_helper<Size,PacketType,false>
+{
+  typedef typename find_best_packet_helper<Size,typename unpacket_traits<PacketType>::half>::type type;
+};
+
+template<typename T, int Size>
+struct find_best_packet
+{
+  typedef typename find_best_packet_helper<Size,typename packet_traits<T>::type>::type type;
+};
+
+#if EIGEN_MAX_STATIC_ALIGN_BYTES>0
+template<int ArrayBytes, int AlignmentBytes,
+         bool Match     =  bool((ArrayBytes%AlignmentBytes)==0),
+         bool TryHalf   =  bool(EIGEN_MIN_ALIGN_BYTES<AlignmentBytes) >
+struct compute_default_alignment_helper
+{
+  enum { value = 0 };
+};
+
+template<int ArrayBytes, int AlignmentBytes, bool TryHalf>
+struct compute_default_alignment_helper<ArrayBytes, AlignmentBytes, true, TryHalf> // Match
+{
+  enum { value = AlignmentBytes };
+};
+
+template<int ArrayBytes, int AlignmentBytes>
+struct compute_default_alignment_helper<ArrayBytes, AlignmentBytes, false, true> // Try-half
+{
+  // current packet too large, try with an half-packet
+  enum { value = compute_default_alignment_helper<ArrayBytes, AlignmentBytes/2>::value };
+};
+#else
+// If static alignment is disabled, no need to bother.
+// This also avoids a division by zero in "bool Match =  bool((ArrayBytes%AlignmentBytes)==0)"
+template<int ArrayBytes, int AlignmentBytes>
+struct compute_default_alignment_helper
+{
+  enum { value = 0 };
+};
+#endif
+
+template<typename T, int Size> struct compute_default_alignment {
+  enum { value = compute_default_alignment_helper<Size*sizeof(T),EIGEN_MAX_STATIC_ALIGN_BYTES>::value };
+};
+
+template<typename T> struct compute_default_alignment<T,Dynamic> {
+  enum { value = EIGEN_MAX_ALIGN_BYTES };
+};
+
+template<typename _Scalar, int _Rows, int _Cols,
+         int _Options = AutoAlign |
+                          ( (_Rows==1 && _Cols!=1) ? RowMajor
+                          : (_Cols==1 && _Rows!=1) ? ColMajor
+                          : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
+         int _MaxRows = _Rows,
+         int _MaxCols = _Cols
+> class make_proper_matrix_type
+{
+    enum {
+      IsColVector = _Cols==1 && _Rows!=1,
+      IsRowVector = _Rows==1 && _Cols!=1,
+      Options = IsColVector ? (_Options | ColMajor) & ~RowMajor
+              : IsRowVector ? (_Options | RowMajor) & ~ColMajor
+              : _Options
+    };
+  public:
+    typedef Matrix<_Scalar, _Rows, _Cols, Options, _MaxRows, _MaxCols> type;
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+class compute_matrix_flags
+{
+    enum { row_major_bit = Options&RowMajor ? RowMajorBit : 0 };
+  public:
+    // FIXME currently we still have to handle DirectAccessBit at the expression level to handle DenseCoeffsBase<>
+    // and then propagate this information to the evaluator's flags.
+    // However, I (Gael) think that DirectAccessBit should only matter at the evaluation stage.
+    enum { ret = DirectAccessBit | LvalueBit | NestByRefBit | row_major_bit };
+};
+
+template<int _Rows, int _Cols> struct size_at_compile_time
+{
+  enum { ret = (_Rows==Dynamic || _Cols==Dynamic) ? Dynamic : _Rows * _Cols };
+};
+
+template<typename XprType> struct size_of_xpr_at_compile_time
+{
+  enum { ret = size_at_compile_time<traits<XprType>::RowsAtCompileTime,traits<XprType>::ColsAtCompileTime>::ret };
+};
+
+/* plain_matrix_type : the difference from eval is that plain_matrix_type is always a plain matrix type,
+ * whereas eval is a const reference in the case of a matrix
+ */
+
+template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct plain_matrix_type;
+template<typename T, typename BaseClassType, int Flags> struct plain_matrix_type_dense;
+template<typename T> struct plain_matrix_type<T,Dense>
+{
+  typedef typename plain_matrix_type_dense<T,typename traits<T>::XprKind, traits<T>::Flags>::type type;
+};
+template<typename T> struct plain_matrix_type<T,DiagonalShape>
+{
+  typedef typename T::PlainObject type;
+};
+
+template<typename T, int Flags> struct plain_matrix_type_dense<T,MatrixXpr,Flags>
+{
+  typedef Matrix<typename traits<T>::Scalar,
+                traits<T>::RowsAtCompileTime,
+                traits<T>::ColsAtCompileTime,
+                AutoAlign | (Flags&RowMajorBit ? RowMajor : ColMajor),
+                traits<T>::MaxRowsAtCompileTime,
+                traits<T>::MaxColsAtCompileTime
+          > type;
+};
+
+template<typename T, int Flags> struct plain_matrix_type_dense<T,ArrayXpr,Flags>
+{
+  typedef Array<typename traits<T>::Scalar,
+                traits<T>::RowsAtCompileTime,
+                traits<T>::ColsAtCompileTime,
+                AutoAlign | (Flags&RowMajorBit ? RowMajor : ColMajor),
+                traits<T>::MaxRowsAtCompileTime,
+                traits<T>::MaxColsAtCompileTime
+          > type;
+};
+
+/* eval : the return type of eval(). For matrices, this is just a const reference
+ * in order to avoid a useless copy
+ */
+
+template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct eval;
+
+template<typename T> struct eval<T,Dense>
+{
+  typedef typename plain_matrix_type<T>::type type;
+//   typedef typename T::PlainObject type;
+//   typedef T::Matrix<typename traits<T>::Scalar,
+//                 traits<T>::RowsAtCompileTime,
+//                 traits<T>::ColsAtCompileTime,
+//                 AutoAlign | (traits<T>::Flags&RowMajorBit ? RowMajor : ColMajor),
+//                 traits<T>::MaxRowsAtCompileTime,
+//                 traits<T>::MaxColsAtCompileTime
+//           > type;
+};
+
+template<typename T> struct eval<T,DiagonalShape>
+{
+  typedef typename plain_matrix_type<T>::type type;
+};
+
+// for matrices, no need to evaluate, just use a const reference to avoid a useless copy
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct eval<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Dense>
+{
+  typedef const Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& type;
+};
+
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct eval<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Dense>
+{
+  typedef const Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& type;
+};
+
+
+/* similar to plain_matrix_type, but using the evaluator's Flags */
+template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct plain_object_eval;
+
+template<typename T>
+struct plain_object_eval<T,Dense>
+{
+  typedef typename plain_matrix_type_dense<T,typename traits<T>::XprKind, evaluator<T>::Flags>::type type;
+};
+
+
+/* plain_matrix_type_column_major : same as plain_matrix_type but guaranteed to be column-major
+ */
+template<typename T> struct plain_matrix_type_column_major
+{
+  enum { Rows = traits<T>::RowsAtCompileTime,
+         Cols = traits<T>::ColsAtCompileTime,
+         MaxRows = traits<T>::MaxRowsAtCompileTime,
+         MaxCols = traits<T>::MaxColsAtCompileTime
+  };
+  typedef Matrix<typename traits<T>::Scalar,
+                Rows,
+                Cols,
+                (MaxRows==1&&MaxCols!=1) ? RowMajor : ColMajor,
+                MaxRows,
+                MaxCols
+          > type;
+};
+
+/* plain_matrix_type_row_major : same as plain_matrix_type but guaranteed to be row-major
+ */
+template<typename T> struct plain_matrix_type_row_major
+{
+  enum { Rows = traits<T>::RowsAtCompileTime,
+         Cols = traits<T>::ColsAtCompileTime,
+         MaxRows = traits<T>::MaxRowsAtCompileTime,
+         MaxCols = traits<T>::MaxColsAtCompileTime
+  };
+  typedef Matrix<typename traits<T>::Scalar,
+                Rows,
+                Cols,
+                (MaxCols==1&&MaxRows!=1) ? ColMajor : RowMajor,
+                MaxRows,
+                MaxCols
+          > type;
+};
+
+/** \internal The reference selector for template expressions. The idea is that we don't
+  * need to use references for expressions since they are light weight proxy
+  * objects which should generate no copying overhead. */
+template <typename T>
+struct ref_selector
+{
+  typedef typename conditional<
+    bool(traits<T>::Flags & NestByRefBit),
+    T const&,
+    const T
+  >::type type;
+
+  typedef typename conditional<
+    bool(traits<T>::Flags & NestByRefBit),
+    T &,
+    T
+  >::type non_const_type;
+};
+
+/** \internal Adds the const qualifier on the value-type of T2 if and only if T1 is a const type */
+template<typename T1, typename T2>
+struct transfer_constness
+{
+  typedef typename conditional<
+    bool(internal::is_const<T1>::value),
+    typename internal::add_const_on_value_type<T2>::type,
+    T2
+  >::type type;
+};
+
+
+// However, we still need a mechanism to detect whether an expression which is evaluated multiple time
+// has to be evaluated into a temporary.
+// That's the purpose of this new nested_eval helper:
+/** \internal Determines how a given expression should be nested when evaluated multiple times.
+  * For example, when you do a * (b+c), Eigen will determine how the expression b+c should be
+  * evaluated into the bigger product expression. The choice is between nesting the expression b+c as-is, or
+  * evaluating that expression b+c into a temporary variable d, and nest d so that the resulting expression is
+  * a*d. Evaluating can be beneficial for example if every coefficient access in the resulting expression causes
+  * many coefficient accesses in the nested expressions -- as is the case with matrix product for example.
+  *
+  * \tparam T the type of the expression being nested.
+  * \tparam n the number of coefficient accesses in the nested expression for each coefficient access in the bigger expression.
+  * \tparam PlainObject the type of the temporary if needed.
+  */
+template<typename T, int n, typename PlainObject = typename plain_object_eval<T>::type> struct nested_eval
+{
+  enum {
+    ScalarReadCost = NumTraits<typename traits<T>::Scalar>::ReadCost,
+    CoeffReadCost = evaluator<T>::CoeffReadCost,  // NOTE What if an evaluator evaluate itself into a temporary?
+                                                  //      Then CoeffReadCost will be small (e.g., 1) but we still have to evaluate, especially if n>1.
+                                                  //      This situation is already taken care by the EvalBeforeNestingBit flag, which is turned ON
+                                                  //      for all evaluator creating a temporary. This flag is then propagated by the parent evaluators.
+                                                  //      Another solution could be to count the number of temps?
+    NAsInteger = n == Dynamic ? HugeCost : n,
+    CostEval   = (NAsInteger+1) * ScalarReadCost + CoeffReadCost,
+    CostNoEval = NAsInteger * CoeffReadCost,
+    Evaluate = (int(evaluator<T>::Flags) & EvalBeforeNestingBit) || (int(CostEval) < int(CostNoEval))
+  };
+
+  typedef typename conditional<Evaluate, PlainObject, typename ref_selector<T>::type>::type type;
+};
+
+template<typename T>
+EIGEN_DEVICE_FUNC
+inline T* const_cast_ptr(const T* ptr)
+{
+  return const_cast<T*>(ptr);
+}
+
+template<typename Derived, typename XprKind = typename traits<Derived>::XprKind>
+struct dense_xpr_base
+{
+  /* dense_xpr_base should only ever be used on dense expressions, thus falling either into the MatrixXpr or into the ArrayXpr cases */
+};
+
+template<typename Derived>
+struct dense_xpr_base<Derived, MatrixXpr>
+{
+  typedef MatrixBase<Derived> type;
+};
+
+template<typename Derived>
+struct dense_xpr_base<Derived, ArrayXpr>
+{
+  typedef ArrayBase<Derived> type;
+};
+
+template<typename Derived, typename XprKind = typename traits<Derived>::XprKind, typename StorageKind = typename traits<Derived>::StorageKind>
+struct generic_xpr_base;
+
+template<typename Derived, typename XprKind>
+struct generic_xpr_base<Derived, XprKind, Dense>
+{
+  typedef typename dense_xpr_base<Derived,XprKind>::type type;
+};
+
+template<typename XprType, typename CastType> struct cast_return_type
+{
+  typedef typename XprType::Scalar CurrentScalarType;
+  typedef typename remove_all<CastType>::type _CastType;
+  typedef typename _CastType::Scalar NewScalarType;
+  typedef typename conditional<is_same<CurrentScalarType,NewScalarType>::value,
+                              const XprType&,CastType>::type type;
+};
+
+template <typename A, typename B> struct promote_storage_type;
+
+template <typename A> struct promote_storage_type<A,A>
+{
+  typedef A ret;
+};
+template <typename A> struct promote_storage_type<A, const A>
+{
+  typedef A ret;
+};
+template <typename A> struct promote_storage_type<const A, A>
+{
+  typedef A ret;
+};
+
+/** \internal Specify the "storage kind" of applying a coefficient-wise
+  * binary operations between two expressions of kinds A and B respectively.
+  * The template parameter Functor permits to specialize the resulting storage kind wrt to
+  * the functor.
+  * The default rules are as follows:
+  * \code
+  * A      op A      -> A
+  * A      op dense  -> dense
+  * dense  op B      -> dense
+  * sparse op dense  -> sparse
+  * dense  op sparse -> sparse
+  * \endcode
+  */
+template <typename A, typename B, typename Functor> struct cwise_promote_storage_type;
+
+template <typename A, typename Functor>                   struct cwise_promote_storage_type<A,A,Functor>                                      { typedef A      ret; };
+template <typename Functor>                               struct cwise_promote_storage_type<Dense,Dense,Functor>                              { typedef Dense  ret; };
+template <typename A, typename Functor>                   struct cwise_promote_storage_type<A,Dense,Functor>                                  { typedef Dense  ret; };
+template <typename B, typename Functor>                   struct cwise_promote_storage_type<Dense,B,Functor>                                  { typedef Dense  ret; };
+template <typename Functor>                               struct cwise_promote_storage_type<Sparse,Dense,Functor>                             { typedef Sparse ret; };
+template <typename Functor>                               struct cwise_promote_storage_type<Dense,Sparse,Functor>                             { typedef Sparse ret; };
+
+template <typename LhsKind, typename RhsKind, int LhsOrder, int RhsOrder> struct cwise_promote_storage_order {
+  enum { value = LhsOrder };
+};
+
+template <typename LhsKind, int LhsOrder, int RhsOrder>   struct cwise_promote_storage_order<LhsKind,Sparse,LhsOrder,RhsOrder>                { enum { value = RhsOrder }; };
+template <typename RhsKind, int LhsOrder, int RhsOrder>   struct cwise_promote_storage_order<Sparse,RhsKind,LhsOrder,RhsOrder>                { enum { value = LhsOrder }; };
+template <int Order>                                      struct cwise_promote_storage_order<Sparse,Sparse,Order,Order>                       { enum { value = Order }; };
+
+
+/** \internal Specify the "storage kind" of multiplying an expression of kind A with kind B.
+  * The template parameter ProductTag permits to specialize the resulting storage kind wrt to
+  * some compile-time properties of the product: GemmProduct, GemvProduct, OuterProduct, InnerProduct.
+  * The default rules are as follows:
+  * \code
+  *  K * K            -> K
+  *  dense * K        -> dense
+  *  K * dense        -> dense
+  *  diag * K         -> K
+  *  K * diag         -> K
+  *  Perm * K         -> K
+  * K * Perm          -> K
+  * \endcode
+  */
+template <typename A, typename B, int ProductTag> struct product_promote_storage_type;
+
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  A,                  ProductTag> { typedef A     ret;};
+template <int ProductTag>             struct product_promote_storage_type<Dense,              Dense,              ProductTag> { typedef Dense ret;};
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  Dense,              ProductTag> { typedef Dense ret; };
+template <typename B, int ProductTag> struct product_promote_storage_type<Dense,              B,                  ProductTag> { typedef Dense ret; };
+
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  DiagonalShape,      ProductTag> { typedef A ret; };
+template <typename B, int ProductTag> struct product_promote_storage_type<DiagonalShape,      B,                  ProductTag> { typedef B ret; };
+template <int ProductTag>             struct product_promote_storage_type<Dense,              DiagonalShape,      ProductTag> { typedef Dense ret; };
+template <int ProductTag>             struct product_promote_storage_type<DiagonalShape,      Dense,              ProductTag> { typedef Dense ret; };
+
+template <typename A, int ProductTag> struct product_promote_storage_type<A,                  PermutationStorage, ProductTag> { typedef A ret; };
+template <typename B, int ProductTag> struct product_promote_storage_type<PermutationStorage, B,                  ProductTag> { typedef B ret; };
+template <int ProductTag>             struct product_promote_storage_type<Dense,              PermutationStorage, ProductTag> { typedef Dense ret; };
+template <int ProductTag>             struct product_promote_storage_type<PermutationStorage, Dense,              ProductTag> { typedef Dense ret; };
+
+/** \internal gives the plain matrix or array type to store a row/column/diagonal of a matrix type.
+  * \tparam Scalar optional parameter allowing to pass a different scalar type than the one of the MatrixType.
+  */
+template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
+struct plain_row_type
+{
+  typedef Matrix<Scalar, 1, ExpressionType::ColsAtCompileTime,
+                 int(ExpressionType::PlainObject::Options) | int(RowMajor), 1, ExpressionType::MaxColsAtCompileTime> MatrixRowType;
+  typedef Array<Scalar, 1, ExpressionType::ColsAtCompileTime,
+                 int(ExpressionType::PlainObject::Options) | int(RowMajor), 1, ExpressionType::MaxColsAtCompileTime> ArrayRowType;
+
+  typedef typename conditional<
+    is_same< typename traits<ExpressionType>::XprKind, MatrixXpr >::value,
+    MatrixRowType,
+    ArrayRowType
+  >::type type;
+};
+
+template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
+struct plain_col_type
+{
+  typedef Matrix<Scalar, ExpressionType::RowsAtCompileTime, 1,
+                 ExpressionType::PlainObject::Options & ~RowMajor, ExpressionType::MaxRowsAtCompileTime, 1> MatrixColType;
+  typedef Array<Scalar, ExpressionType::RowsAtCompileTime, 1,
+                 ExpressionType::PlainObject::Options & ~RowMajor, ExpressionType::MaxRowsAtCompileTime, 1> ArrayColType;
+
+  typedef typename conditional<
+    is_same< typename traits<ExpressionType>::XprKind, MatrixXpr >::value,
+    MatrixColType,
+    ArrayColType
+  >::type type;
+};
+
+template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
+struct plain_diag_type
+{
+  enum { diag_size = EIGEN_SIZE_MIN_PREFER_DYNAMIC(ExpressionType::RowsAtCompileTime, ExpressionType::ColsAtCompileTime),
+         max_diag_size = EIGEN_SIZE_MIN_PREFER_FIXED(ExpressionType::MaxRowsAtCompileTime, ExpressionType::MaxColsAtCompileTime)
+  };
+  typedef Matrix<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1> MatrixDiagType;
+  typedef Array<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1> ArrayDiagType;
+
+  typedef typename conditional<
+    is_same< typename traits<ExpressionType>::XprKind, MatrixXpr >::value,
+    MatrixDiagType,
+    ArrayDiagType
+  >::type type;
+};
+
+template<typename Expr,typename Scalar = typename Expr::Scalar>
+struct plain_constant_type
+{
+  enum { Options = (traits<Expr>::Flags&RowMajorBit)?RowMajor:0 };
+
+  typedef Array<Scalar,  traits<Expr>::RowsAtCompileTime,   traits<Expr>::ColsAtCompileTime,
+                Options, traits<Expr>::MaxRowsAtCompileTime,traits<Expr>::MaxColsAtCompileTime> array_type;
+
+  typedef Matrix<Scalar,  traits<Expr>::RowsAtCompileTime,   traits<Expr>::ColsAtCompileTime,
+                 Options, traits<Expr>::MaxRowsAtCompileTime,traits<Expr>::MaxColsAtCompileTime> matrix_type;
+
+  typedef CwiseNullaryOp<scalar_constant_op<Scalar>, const typename conditional<is_same< typename traits<Expr>::XprKind, MatrixXpr >::value, matrix_type, array_type>::type > type;
+};
+
+template<typename ExpressionType>
+struct is_lvalue
+{
+  enum { value = (!bool(is_const<ExpressionType>::value)) &&
+                 bool(traits<ExpressionType>::Flags & LvalueBit) };
+};
+
+template<typename T> struct is_diagonal
+{ enum { ret = false }; };
+
+template<typename T> struct is_diagonal<DiagonalBase<T> >
+{ enum { ret = true }; };
+
+template<typename T> struct is_diagonal<DiagonalWrapper<T> >
+{ enum { ret = true }; };
+
+template<typename T, int S> struct is_diagonal<DiagonalMatrix<T,S> >
+{ enum { ret = true }; };
+
+
+template<typename T> struct is_identity
+{ enum { value = false }; };
+
+template<typename T> struct is_identity<CwiseNullaryOp<internal::scalar_identity_op<typename T::Scalar>, T> >
+{ enum { value = true }; };
+
+
+template<typename S1, typename S2> struct glue_shapes;
+template<> struct glue_shapes<DenseShape,TriangularShape> { typedef TriangularShape type;  };
+
+template<typename T1, typename T2>
+struct possibly_same_dense {
+  enum { value = has_direct_access<T1>::ret && has_direct_access<T2>::ret && is_same<typename T1::Scalar,typename T2::Scalar>::value };
+};
+
+template<typename T1, typename T2>
+EIGEN_DEVICE_FUNC
+bool is_same_dense(const T1 &mat1, const T2 &mat2, typename enable_if<possibly_same_dense<T1,T2>::value>::type * = 0)
+{
+  return (mat1.data()==mat2.data()) && (mat1.innerStride()==mat2.innerStride()) && (mat1.outerStride()==mat2.outerStride());
+}
+
+template<typename T1, typename T2>
+EIGEN_DEVICE_FUNC
+bool is_same_dense(const T1 &, const T2 &, typename enable_if<!possibly_same_dense<T1,T2>::value>::type * = 0)
+{
+  return false;
+}
+
+// Internal helper defining the cost of a scalar division for the type T.
+// The default heuristic can be specialized for each scalar type and architecture.
+template<typename T,bool Vectorized=false,typename EnableIf = void>
+struct scalar_div_cost {
+  enum { value = 8*NumTraits<T>::MulCost };
+};
+
+template<typename T,bool Vectorized>
+struct scalar_div_cost<std::complex<T>, Vectorized> {
+  enum { value = 2*scalar_div_cost<T>::value
+               + 6*NumTraits<T>::MulCost
+               + 3*NumTraits<T>::AddCost
+  };
+};
+
+
+template<bool Vectorized>
+struct scalar_div_cost<signed long,Vectorized,typename conditional<sizeof(long)==8,void,false_type>::type> { enum { value = 24 }; };
+template<bool Vectorized>
+struct scalar_div_cost<unsigned long,Vectorized,typename conditional<sizeof(long)==8,void,false_type>::type> { enum { value = 21 }; };
+
+
+#ifdef EIGEN_DEBUG_ASSIGN
+std::string demangle_traversal(int t)
+{
+  if(t==DefaultTraversal) return "DefaultTraversal";
+  if(t==LinearTraversal) return "LinearTraversal";
+  if(t==InnerVectorizedTraversal) return "InnerVectorizedTraversal";
+  if(t==LinearVectorizedTraversal) return "LinearVectorizedTraversal";
+  if(t==SliceVectorizedTraversal) return "SliceVectorizedTraversal";
+  return "?";
+}
+std::string demangle_unrolling(int t)
+{
+  if(t==NoUnrolling) return "NoUnrolling";
+  if(t==InnerUnrolling) return "InnerUnrolling";
+  if(t==CompleteUnrolling) return "CompleteUnrolling";
+  return "?";
+}
+std::string demangle_flags(int f)
+{
+  std::string res;
+  if(f&RowMajorBit)                 res += " | RowMajor";
+  if(f&PacketAccessBit)             res += " | Packet";
+  if(f&LinearAccessBit)             res += " | Linear";
+  if(f&LvalueBit)                   res += " | Lvalue";
+  if(f&DirectAccessBit)             res += " | Direct";
+  if(f&NestByRefBit)                res += " | NestByRef";
+  if(f&NoPreferredStorageOrderBit)  res += " | NoPreferredStorageOrderBit";
+
+  return res;
+}
+#endif
+
+} // end namespace internal
+
+
+/** \class ScalarBinaryOpTraits
+  * \ingroup Core_Module
+  *
+  * \brief Determines whether the given binary operation of two numeric types is allowed and what the scalar return type is.
+  *
+  * This class permits to control the scalar return type of any binary operation performed on two different scalar types through (partial) template specializations.
+  *
+  * For instance, let \c U1, \c U2 and \c U3 be three user defined scalar types for which most operations between instances of \c U1 and \c U2 returns an \c U3.
+  * You can let %Eigen knows that by defining:
+    \code
+    template<typename BinaryOp>
+    struct ScalarBinaryOpTraits<U1,U2,BinaryOp> { typedef U3 ReturnType;  };
+    template<typename BinaryOp>
+    struct ScalarBinaryOpTraits<U2,U1,BinaryOp> { typedef U3 ReturnType;  };
+    \endcode
+  * You can then explicitly disable some particular operations to get more explicit error messages:
+    \code
+    template<>
+    struct ScalarBinaryOpTraits<U1,U2,internal::scalar_max_op<U1,U2> > {};
+    \endcode
+  * Or customize the return type for individual operation:
+    \code
+    template<>
+    struct ScalarBinaryOpTraits<U1,U2,internal::scalar_sum_op<U1,U2> > { typedef U1 ReturnType; };
+    \endcode
+  *
+  * By default, the following generic combinations are supported:
+  <table class="manual">
+  <tr><th>ScalarA</th><th>ScalarB</th><th>BinaryOp</th><th>ReturnType</th><th>Note</th></tr>
+  <tr            ><td>\c T </td><td>\c T </td><td>\c * </td><td>\c T </td><td></td></tr>
+  <tr class="alt"><td>\c NumTraits<T>::Real </td><td>\c T </td><td>\c * </td><td>\c T </td><td>Only if \c NumTraits<T>::IsComplex </td></tr>
+  <tr            ><td>\c T </td><td>\c NumTraits<T>::Real </td><td>\c * </td><td>\c T </td><td>Only if \c NumTraits<T>::IsComplex </td></tr>
+  </table>
+  *
+  * \sa CwiseBinaryOp
+  */
+template<typename ScalarA, typename ScalarB, typename BinaryOp=internal::scalar_product_op<ScalarA,ScalarB> >
+struct ScalarBinaryOpTraits
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  // for backward compatibility, use the hints given by the (deprecated) internal::scalar_product_traits class.
+  : internal::scalar_product_traits<ScalarA,ScalarB>
+#endif // EIGEN_PARSED_BY_DOXYGEN
+{};
+
+template<typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<T,T,BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+template <typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<T, typename NumTraits<typename internal::enable_if<NumTraits<T>::IsComplex,T>::type>::Real, BinaryOp>
+{
+  typedef T ReturnType;
+};
+template <typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<typename NumTraits<typename internal::enable_if<NumTraits<T>::IsComplex,T>::type>::Real, T, BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+// For Matrix * Permutation
+template<typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<T,void,BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+// For Permutation * Matrix
+template<typename T, typename BinaryOp>
+struct ScalarBinaryOpTraits<void,T,BinaryOp>
+{
+  typedef T ReturnType;
+};
+
+// for Permutation*Permutation
+template<typename BinaryOp>
+struct ScalarBinaryOpTraits<void,void,BinaryOp>
+{
+  typedef void ReturnType;
+};
+
+// We require Lhs and Rhs to have "compatible" scalar types.
+// It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized paths.
+// So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user tries to
+// add together a float matrix and a double matrix.
+#define EIGEN_CHECK_BINARY_COMPATIBILIY(BINOP,LHS,RHS) \
+  EIGEN_STATIC_ASSERT((Eigen::internal::has_ReturnType<ScalarBinaryOpTraits<LHS, RHS,BINOP> >::value), \
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+} // end namespace Eigen
+
+#endif // EIGEN_XPRHELPER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/ComplexEigenSolver.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
new file mode 100644
index 00000000..081e918f
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/ComplexEigenSolver.h
@@ -0,0 +1,346 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Claire Maurice
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_EIGEN_SOLVER_H
+#define EIGEN_COMPLEX_EIGEN_SOLVER_H
+
+#include "./ComplexSchur.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class ComplexEigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of general complex matrices
+  *
+  * \tparam _MatrixType the type of the matrix of which we are
+  * computing the eigendecomposition; this is expected to be an
+  * instantiation of the Matrix class template.
+  *
+  * The eigenvalues and eigenvectors of a matrix \f$ A \f$ are scalars
+  * \f$ \lambda \f$ and vectors \f$ v \f$ such that \f$ Av = \lambda v
+  * \f$.  If \f$ D \f$ is a diagonal matrix with the eigenvalues on
+  * the diagonal, and \f$ V \f$ is a matrix with the eigenvectors as
+  * its columns, then \f$ A V = V D \f$. The matrix \f$ V \f$ is
+  * almost always invertible, in which case we have \f$ A = V D V^{-1}
+  * \f$. This is called the eigendecomposition.
+  *
+  * The main function in this class is compute(), which computes the
+  * eigenvalues and eigenvectors of a given function. The
+  * documentation for that function contains an example showing the
+  * main features of the class.
+  *
+  * \sa class EigenSolver, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class ComplexEigenSolver
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for #MatrixType.
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for vector of eigenvalues as returned by eigenvalues().
+      *
+      * This is a column vector with entries of type #ComplexScalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options&(~RowMajor), MaxColsAtCompileTime, 1> EigenvalueType;
+
+    /** \brief Type for matrix of eigenvectors as returned by eigenvectors().
+      *
+      * This is a square matrix with entries of type #ComplexScalar.
+      * The size is the same as the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> EigenvectorType;
+
+    /** \brief Default constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().
+      */
+    ComplexEigenSolver()
+            : m_eivec(),
+              m_eivalues(),
+              m_schur(),
+              m_isInitialized(false),
+              m_eigenvectorsOk(false),
+              m_matX()
+    {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa ComplexEigenSolver()
+      */
+    explicit ComplexEigenSolver(Index size)
+            : m_eivec(size, size),
+              m_eivalues(size),
+              m_schur(size),
+              m_isInitialized(false),
+              m_eigenvectorsOk(false),
+              m_matX(size, size)
+    {}
+
+    /** \brief Constructor; computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed.
+      *
+      * This constructor calls compute() to compute the eigendecomposition.
+      */
+    template<typename InputType>
+    explicit ComplexEigenSolver(const EigenBase<InputType>& matrix, bool computeEigenvectors = true)
+            : m_eivec(matrix.rows(),matrix.cols()),
+              m_eivalues(matrix.cols()),
+              m_schur(matrix.rows()),
+              m_isInitialized(false),
+              m_eigenvectorsOk(false),
+              m_matX(matrix.rows(),matrix.cols())
+    {
+      compute(matrix.derived(), computeEigenvectors);
+    }
+
+    /** \brief Returns the eigenvectors of given matrix.
+      *
+      * \returns  A const reference to the matrix whose columns are the eigenvectors.
+      *
+      * \pre Either the constructor
+      * ComplexEigenSolver(const MatrixType& matrix, bool) or the member
+      * function compute(const MatrixType& matrix, bool) has been called before
+      * to compute the eigendecomposition of a matrix, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * This function returns a matrix whose columns are the eigenvectors. Column
+      * \f$ k \f$ is an eigenvector corresponding to eigenvalue number \f$ k
+      * \f$ as returned by eigenvalues().  The eigenvectors are normalized to
+      * have (Euclidean) norm equal to one. The matrix returned by this
+      * function is the matrix \f$ V \f$ in the eigendecomposition \f$ A = V D
+      * V^{-1} \f$, if it exists.
+      *
+      * Example: \include ComplexEigenSolver_eigenvectors.cpp
+      * Output: \verbinclude ComplexEigenSolver_eigenvectors.out
+      */
+    const EigenvectorType& eigenvectors() const
+    {
+      eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec;
+    }
+
+    /** \brief Returns the eigenvalues of given matrix.
+      *
+      * \returns A const reference to the column vector containing the eigenvalues.
+      *
+      * \pre Either the constructor
+      * ComplexEigenSolver(const MatrixType& matrix, bool) or the member
+      * function compute(const MatrixType& matrix, bool) has been called before
+      * to compute the eigendecomposition of a matrix.
+      *
+      * This function returns a column vector containing the
+      * eigenvalues. Eigenvalues are repeated according to their
+      * algebraic multiplicity, so there are as many eigenvalues as
+      * rows in the matrix. The eigenvalues are not sorted in any particular
+      * order.
+      *
+      * Example: \include ComplexEigenSolver_eigenvalues.cpp
+      * Output: \verbinclude ComplexEigenSolver_eigenvalues.out
+      */
+    const EigenvalueType& eigenvalues() const
+    {
+      eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
+      return m_eivalues;
+    }
+
+    /** \brief Computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed.
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of the complex matrix \p matrix.
+      * The eigenvalues() function can be used to retrieve them.  If
+      * \p computeEigenvectors is true, then the eigenvectors are also computed
+      * and can be retrieved by calling eigenvectors().
+      *
+      * The matrix is first reduced to Schur form using the
+      * ComplexSchur class. The Schur decomposition is then used to
+      * compute the eigenvalues and eigenvectors.
+      *
+      * The cost of the computation is dominated by the cost of the
+      * Schur decomposition, which is \f$ O(n^3) \f$ where \f$ n \f$
+      * is the size of the matrix.
+      *
+      * Example: \include ComplexEigenSolver_compute.cpp
+      * Output: \verbinclude ComplexEigenSolver_compute.out
+      */
+    template<typename InputType>
+    ComplexEigenSolver& compute(const EigenBase<InputType>& matrix, bool computeEigenvectors = true);
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
+      return m_schur.info();
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. */
+    ComplexEigenSolver& setMaxIterations(Index maxIters)
+    {
+      m_schur.setMaxIterations(maxIters);
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_schur.getMaxIterations();
+    }
+
+  protected:
+    
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+    
+    EigenvectorType m_eivec;
+    EigenvalueType m_eivalues;
+    ComplexSchur<MatrixType> m_schur;
+    bool m_isInitialized;
+    bool m_eigenvectorsOk;
+    EigenvectorType m_matX;
+
+  private:
+    void doComputeEigenvectors(RealScalar matrixnorm);
+    void sortEigenvalues(bool computeEigenvectors);
+};
+
+
+template<typename MatrixType>
+template<typename InputType>
+ComplexEigenSolver<MatrixType>& 
+ComplexEigenSolver<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeEigenvectors)
+{
+  check_template_parameters();
+  
+  // this code is inspired from Jampack
+  eigen_assert(matrix.cols() == matrix.rows());
+
+  // Do a complex Schur decomposition, A = U T U^*
+  // The eigenvalues are on the diagonal of T.
+  m_schur.compute(matrix.derived(), computeEigenvectors);
+
+  if(m_schur.info() == Success)
+  {
+    m_eivalues = m_schur.matrixT().diagonal();
+    if(computeEigenvectors)
+      doComputeEigenvectors(m_schur.matrixT().norm());
+    sortEigenvalues(computeEigenvectors);
+  }
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+  return *this;
+}
+
+
+template<typename MatrixType>
+void ComplexEigenSolver<MatrixType>::doComputeEigenvectors(RealScalar matrixnorm)
+{
+  const Index n = m_eivalues.size();
+
+  matrixnorm = numext::maxi(matrixnorm,(std::numeric_limits<RealScalar>::min)());
+
+  // Compute X such that T = X D X^(-1), where D is the diagonal of T.
+  // The matrix X is unit triangular.
+  m_matX = EigenvectorType::Zero(n, n);
+  for(Index k=n-1 ; k>=0 ; k--)
+  {
+    m_matX.coeffRef(k,k) = ComplexScalar(1.0,0.0);
+    // Compute X(i,k) using the (i,k) entry of the equation X T = D X
+    for(Index i=k-1 ; i>=0 ; i--)
+    {
+      m_matX.coeffRef(i,k) = -m_schur.matrixT().coeff(i,k);
+      if(k-i-1>0)
+        m_matX.coeffRef(i,k) -= (m_schur.matrixT().row(i).segment(i+1,k-i-1) * m_matX.col(k).segment(i+1,k-i-1)).value();
+      ComplexScalar z = m_schur.matrixT().coeff(i,i) - m_schur.matrixT().coeff(k,k);
+      if(z==ComplexScalar(0))
+      {
+        // If the i-th and k-th eigenvalue are equal, then z equals 0.
+        // Use a small value instead, to prevent division by zero.
+        numext::real_ref(z) = NumTraits<RealScalar>::epsilon() * matrixnorm;
+      }
+      m_matX.coeffRef(i,k) = m_matX.coeff(i,k) / z;
+    }
+  }
+
+  // Compute V as V = U X; now A = U T U^* = U X D X^(-1) U^* = V D V^(-1)
+  m_eivec.noalias() = m_schur.matrixU() * m_matX;
+  // .. and normalize the eigenvectors
+  for(Index k=0 ; k<n ; k++)
+  {
+    m_eivec.col(k).normalize();
+  }
+}
+
+
+template<typename MatrixType>
+void ComplexEigenSolver<MatrixType>::sortEigenvalues(bool computeEigenvectors)
+{
+  const Index n =  m_eivalues.size();
+  for (Index i=0; i<n; i++)
+  {
+    Index k;
+    m_eivalues.cwiseAbs().tail(n-i).minCoeff(&k);
+    if (k != 0)
+    {
+      k += i;
+      std::swap(m_eivalues[k],m_eivalues[i]);
+      if(computeEigenvectors)
+	m_eivec.col(i).swap(m_eivec.col(k));
+    }
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_EIGEN_SOLVER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/ComplexSchur.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/ComplexSchur.h
new file mode 100644
index 00000000..fc71468f
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/ComplexSchur.h
@@ -0,0 +1,462 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Claire Maurice
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLEX_SCHUR_H
+#define EIGEN_COMPLEX_SCHUR_H
+
+#include "./HessenbergDecomposition.h"
+
+namespace Eigen { 
+
+namespace internal {
+template<typename MatrixType, bool IsComplex> struct complex_schur_reduce_to_hessenberg;
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class ComplexSchur
+  *
+  * \brief Performs a complex Schur decomposition of a real or complex square matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are
+  * computing the Schur decomposition; this is expected to be an
+  * instantiation of the Matrix class template.
+  *
+  * Given a real or complex square matrix A, this class computes the
+  * Schur decomposition: \f$ A = U T U^*\f$ where U is a unitary
+  * complex matrix, and T is a complex upper triangular matrix.  The
+  * diagonal of the matrix T corresponds to the eigenvalues of the
+  * matrix A.
+  *
+  * Call the function compute() to compute the Schur decomposition of
+  * a given matrix. Alternatively, you can use the 
+  * ComplexSchur(const MatrixType&, bool) constructor which computes
+  * the Schur decomposition at construction time. Once the
+  * decomposition is computed, you can use the matrixU() and matrixT()
+  * functions to retrieve the matrices U and V in the decomposition.
+  *
+  * \note This code is inspired from Jampack
+  *
+  * \sa class RealSchur, class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType> class ComplexSchur
+{
+  public:
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type \p _MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for \p _MatrixType. 
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for the matrices in the Schur decomposition.
+      *
+      * This is a square matrix with entries of type #ComplexScalar. 
+      * The size is the same as the size of \p _MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> ComplexMatrixType;
+
+    /** \brief Default constructor.
+      *
+      * \param [in] size  Positive integer, size of the matrix whose Schur decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user
+      * intends to perform decompositions via compute().  The \p size
+      * parameter is only used as a hint. It is not an error to give a
+      * wrong \p size, but it may impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit ComplexSchur(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime)
+      : m_matT(size,size),
+        m_matU(size,size),
+        m_hess(size),
+        m_isInitialized(false),
+        m_matUisUptodate(false),
+        m_maxIters(-1)
+    {}
+
+    /** \brief Constructor; computes Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix    Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+      *
+      * This constructor calls compute() to compute the Schur decomposition.
+      *
+      * \sa matrixT() and matrixU() for examples.
+      */
+    template<typename InputType>
+    explicit ComplexSchur(const EigenBase<InputType>& matrix, bool computeU = true)
+      : m_matT(matrix.rows(),matrix.cols()),
+        m_matU(matrix.rows(),matrix.cols()),
+        m_hess(matrix.rows()),
+        m_isInitialized(false),
+        m_matUisUptodate(false),
+        m_maxIters(-1)
+    {
+      compute(matrix.derived(), computeU);
+    }
+
+    /** \brief Returns the unitary matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix U.
+      *
+      * It is assumed that either the constructor
+      * ComplexSchur(const MatrixType& matrix, bool computeU) or the
+      * member function compute(const MatrixType& matrix, bool computeU)
+      * has been called before to compute the Schur decomposition of a
+      * matrix, and that \p computeU was set to true (the default
+      * value).
+      *
+      * Example: \include ComplexSchur_matrixU.cpp
+      * Output: \verbinclude ComplexSchur_matrixU.out
+      */
+    const ComplexMatrixType& matrixU() const
+    {
+      eigen_assert(m_isInitialized && "ComplexSchur is not initialized.");
+      eigen_assert(m_matUisUptodate && "The matrix U has not been computed during the ComplexSchur decomposition.");
+      return m_matU;
+    }
+
+    /** \brief Returns the triangular matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix T.
+      *
+      * It is assumed that either the constructor
+      * ComplexSchur(const MatrixType& matrix, bool computeU) or the
+      * member function compute(const MatrixType& matrix, bool computeU)
+      * has been called before to compute the Schur decomposition of a
+      * matrix.
+      *
+      * Note that this function returns a plain square matrix. If you want to reference
+      * only the upper triangular part, use:
+      * \code schur.matrixT().triangularView<Upper>() \endcode 
+      *
+      * Example: \include ComplexSchur_matrixT.cpp
+      * Output: \verbinclude ComplexSchur_matrixT.out
+      */
+    const ComplexMatrixType& matrixT() const
+    {
+      eigen_assert(m_isInitialized && "ComplexSchur is not initialized.");
+      return m_matT;
+    }
+
+    /** \brief Computes Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix  Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+
+      * \returns    Reference to \c *this
+      *
+      * The Schur decomposition is computed by first reducing the
+      * matrix to Hessenberg form using the class
+      * HessenbergDecomposition. The Hessenberg matrix is then reduced
+      * to triangular form by performing QR iterations with a single
+      * shift. The cost of computing the Schur decomposition depends
+      * on the number of iterations; as a rough guide, it may be taken
+      * on the number of iterations; as a rough guide, it may be taken
+      * to be \f$25n^3\f$ complex flops, or \f$10n^3\f$ complex flops
+      * if \a computeU is false.
+      *
+      * Example: \include ComplexSchur_compute.cpp
+      * Output: \verbinclude ComplexSchur_compute.out
+      *
+      * \sa compute(const MatrixType&, bool, Index)
+      */
+    template<typename InputType>
+    ComplexSchur& compute(const EigenBase<InputType>& matrix, bool computeU = true);
+    
+    /** \brief Compute Schur decomposition from a given Hessenberg matrix
+     *  \param[in] matrixH Matrix in Hessenberg form H
+     *  \param[in] matrixQ orthogonal matrix Q that transform a matrix A to H : A = Q H Q^T
+     *  \param computeU Computes the matriX U of the Schur vectors
+     * \return Reference to \c *this
+     * 
+     *  This routine assumes that the matrix is already reduced in Hessenberg form matrixH
+     *  using either the class HessenbergDecomposition or another mean. 
+     *  It computes the upper quasi-triangular matrix T of the Schur decomposition of H
+     *  When computeU is true, this routine computes the matrix U such that 
+     *  A = U T U^T =  (QZ) T (QZ)^T = Q H Q^T where A is the initial matrix
+     * 
+     * NOTE Q is referenced if computeU is true; so, if the initial orthogonal matrix
+     * is not available, the user should give an identity matrix (Q.setIdentity())
+     * 
+     * \sa compute(const MatrixType&, bool)
+     */
+    template<typename HessMatrixType, typename OrthMatrixType>
+    ComplexSchur& computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ,  bool computeU=true);
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "ComplexSchur is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. 
+      *
+      * If not specified by the user, the maximum number of iterations is m_maxIterationsPerRow times the size
+      * of the matrix.
+      */
+    ComplexSchur& setMaxIterations(Index maxIters)
+    {
+      m_maxIters = maxIters;
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_maxIters;
+    }
+
+    /** \brief Maximum number of iterations per row.
+      *
+      * If not otherwise specified, the maximum number of iterations is this number times the size of the
+      * matrix. It is currently set to 30.
+      */
+    static const int m_maxIterationsPerRow = 30;
+
+  protected:
+    ComplexMatrixType m_matT, m_matU;
+    HessenbergDecomposition<MatrixType> m_hess;
+    ComputationInfo m_info;
+    bool m_isInitialized;
+    bool m_matUisUptodate;
+    Index m_maxIters;
+
+  private:  
+    bool subdiagonalEntryIsNeglegible(Index i);
+    ComplexScalar computeShift(Index iu, Index iter);
+    void reduceToTriangularForm(bool computeU);
+    friend struct internal::complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>;
+};
+
+/** If m_matT(i+1,i) is neglegible in floating point arithmetic
+  * compared to m_matT(i,i) and m_matT(j,j), then set it to zero and
+  * return true, else return false. */
+template<typename MatrixType>
+inline bool ComplexSchur<MatrixType>::subdiagonalEntryIsNeglegible(Index i)
+{
+  RealScalar d = numext::norm1(m_matT.coeff(i,i)) + numext::norm1(m_matT.coeff(i+1,i+1));
+  RealScalar sd = numext::norm1(m_matT.coeff(i+1,i));
+  if (internal::isMuchSmallerThan(sd, d, NumTraits<RealScalar>::epsilon()))
+  {
+    m_matT.coeffRef(i+1,i) = ComplexScalar(0);
+    return true;
+  }
+  return false;
+}
+
+
+/** Compute the shift in the current QR iteration. */
+template<typename MatrixType>
+typename ComplexSchur<MatrixType>::ComplexScalar ComplexSchur<MatrixType>::computeShift(Index iu, Index iter)
+{
+  using std::abs;
+  if (iter == 10 || iter == 20) 
+  {
+    // exceptional shift, taken from http://www.netlib.org/eispack/comqr.f
+    return abs(numext::real(m_matT.coeff(iu,iu-1))) + abs(numext::real(m_matT.coeff(iu-1,iu-2)));
+  }
+
+  // compute the shift as one of the eigenvalues of t, the 2x2
+  // diagonal block on the bottom of the active submatrix
+  Matrix<ComplexScalar,2,2> t = m_matT.template block<2,2>(iu-1,iu-1);
+  RealScalar normt = t.cwiseAbs().sum();
+  t /= normt;     // the normalization by sf is to avoid under/overflow
+
+  ComplexScalar b = t.coeff(0,1) * t.coeff(1,0);
+  ComplexScalar c = t.coeff(0,0) - t.coeff(1,1);
+  ComplexScalar disc = sqrt(c*c + RealScalar(4)*b);
+  ComplexScalar det = t.coeff(0,0) * t.coeff(1,1) - b;
+  ComplexScalar trace = t.coeff(0,0) + t.coeff(1,1);
+  ComplexScalar eival1 = (trace + disc) / RealScalar(2);
+  ComplexScalar eival2 = (trace - disc) / RealScalar(2);
+  RealScalar eival1_norm = numext::norm1(eival1);
+  RealScalar eival2_norm = numext::norm1(eival2);
+  // A division by zero can only occur if eival1==eival2==0.
+  // In this case, det==0, and all we have to do is checking that eival2_norm!=0
+  if(eival1_norm > eival2_norm)
+    eival2 = det / eival1;
+  else if(eival2_norm!=RealScalar(0))
+    eival1 = det / eival2;
+
+  // choose the eigenvalue closest to the bottom entry of the diagonal
+  if(numext::norm1(eival1-t.coeff(1,1)) < numext::norm1(eival2-t.coeff(1,1)))
+    return normt * eival1;
+  else
+    return normt * eival2;
+}
+
+
+template<typename MatrixType>
+template<typename InputType>
+ComplexSchur<MatrixType>& ComplexSchur<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeU)
+{
+  m_matUisUptodate = false;
+  eigen_assert(matrix.cols() == matrix.rows());
+
+  if(matrix.cols() == 1)
+  {
+    m_matT = matrix.derived().template cast<ComplexScalar>();
+    if(computeU)  m_matU = ComplexMatrixType::Identity(1,1);
+    m_info = Success;
+    m_isInitialized = true;
+    m_matUisUptodate = computeU;
+    return *this;
+  }
+
+  internal::complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>::run(*this, matrix.derived(), computeU);
+  computeFromHessenberg(m_matT, m_matU, computeU);
+  return *this;
+}
+
+template<typename MatrixType>
+template<typename HessMatrixType, typename OrthMatrixType>
+ComplexSchur<MatrixType>& ComplexSchur<MatrixType>::computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ, bool computeU)
+{
+  m_matT = matrixH;
+  if(computeU)
+    m_matU = matrixQ;
+  reduceToTriangularForm(computeU);
+  return *this;
+}
+namespace internal {
+
+/* Reduce given matrix to Hessenberg form */
+template<typename MatrixType, bool IsComplex>
+struct complex_schur_reduce_to_hessenberg
+{
+  // this is the implementation for the case IsComplex = true
+  static void run(ComplexSchur<MatrixType>& _this, const MatrixType& matrix, bool computeU)
+  {
+    _this.m_hess.compute(matrix);
+    _this.m_matT = _this.m_hess.matrixH();
+    if(computeU)  _this.m_matU = _this.m_hess.matrixQ();
+  }
+};
+
+template<typename MatrixType>
+struct complex_schur_reduce_to_hessenberg<MatrixType, false>
+{
+  static void run(ComplexSchur<MatrixType>& _this, const MatrixType& matrix, bool computeU)
+  {
+    typedef typename ComplexSchur<MatrixType>::ComplexScalar ComplexScalar;
+
+    // Note: m_hess is over RealScalar; m_matT and m_matU is over ComplexScalar
+    _this.m_hess.compute(matrix);
+    _this.m_matT = _this.m_hess.matrixH().template cast<ComplexScalar>();
+    if(computeU)  
+    {
+      // This may cause an allocation which seems to be avoidable
+      MatrixType Q = _this.m_hess.matrixQ(); 
+      _this.m_matU = Q.template cast<ComplexScalar>();
+    }
+  }
+};
+
+} // end namespace internal
+
+// Reduce the Hessenberg matrix m_matT to triangular form by QR iteration.
+template<typename MatrixType>
+void ComplexSchur<MatrixType>::reduceToTriangularForm(bool computeU)
+{  
+  Index maxIters = m_maxIters;
+  if (maxIters == -1)
+    maxIters = m_maxIterationsPerRow * m_matT.rows();
+
+  // The matrix m_matT is divided in three parts. 
+  // Rows 0,...,il-1 are decoupled from the rest because m_matT(il,il-1) is zero. 
+  // Rows il,...,iu is the part we are working on (the active submatrix).
+  // Rows iu+1,...,end are already brought in triangular form.
+  Index iu = m_matT.cols() - 1;
+  Index il;
+  Index iter = 0; // number of iterations we are working on the (iu,iu) element
+  Index totalIter = 0; // number of iterations for whole matrix
+
+  while(true)
+  {
+    // find iu, the bottom row of the active submatrix
+    while(iu > 0)
+    {
+      if(!subdiagonalEntryIsNeglegible(iu-1)) break;
+      iter = 0;
+      --iu;
+    }
+
+    // if iu is zero then we are done; the whole matrix is triangularized
+    if(iu==0) break;
+
+    // if we spent too many iterations, we give up
+    iter++;
+    totalIter++;
+    if(totalIter > maxIters) break;
+
+    // find il, the top row of the active submatrix
+    il = iu-1;
+    while(il > 0 && !subdiagonalEntryIsNeglegible(il-1))
+    {
+      --il;
+    }
+
+    /* perform the QR step using Givens rotations. The first rotation
+       creates a bulge; the (il+2,il) element becomes nonzero. This
+       bulge is chased down to the bottom of the active submatrix. */
+
+    ComplexScalar shift = computeShift(iu, iter);
+    JacobiRotation<ComplexScalar> rot;
+    rot.makeGivens(m_matT.coeff(il,il) - shift, m_matT.coeff(il+1,il));
+    m_matT.rightCols(m_matT.cols()-il).applyOnTheLeft(il, il+1, rot.adjoint());
+    m_matT.topRows((std::min)(il+2,iu)+1).applyOnTheRight(il, il+1, rot);
+    if(computeU) m_matU.applyOnTheRight(il, il+1, rot);
+
+    for(Index i=il+1 ; i<iu ; i++)
+    {
+      rot.makeGivens(m_matT.coeffRef(i,i-1), m_matT.coeffRef(i+1,i-1), &m_matT.coeffRef(i,i-1));
+      m_matT.coeffRef(i+1,i-1) = ComplexScalar(0);
+      m_matT.rightCols(m_matT.cols()-i).applyOnTheLeft(i, i+1, rot.adjoint());
+      m_matT.topRows((std::min)(i+2,iu)+1).applyOnTheRight(i, i+1, rot);
+      if(computeU) m_matU.applyOnTheRight(i, i+1, rot);
+    }
+  }
+
+  if(totalIter <= maxIters)
+    m_info = Success;
+  else
+    m_info = NoConvergence;
+
+  m_isInitialized = true;
+  m_matUisUptodate = computeU;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_SCHUR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
new file mode 100644
index 00000000..4980a3ed
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
@@ -0,0 +1,91 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Complex Schur needed to complex unsymmetrical eigenvalues/eigenvectors.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_COMPLEX_SCHUR_LAPACKE_H
+#define EIGEN_COMPLEX_SCHUR_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_SCHUR_COMPLEX(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX, LAPACKE_PREFIX_U, EIGCOLROW, LAPACKE_COLROW) \
+template<> template<typename InputType> inline \
+ComplexSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >& \
+ComplexSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >::compute(const EigenBase<InputType>& matrix, bool computeU) \
+{ \
+  typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> MatrixType; \
+  typedef MatrixType::RealScalar RealScalar; \
+  typedef std::complex<RealScalar> ComplexScalar; \
+\
+  eigen_assert(matrix.cols() == matrix.rows()); \
+\
+  m_matUisUptodate = false; \
+  if(matrix.cols() == 1) \
+  { \
+    m_matT = matrix.derived().template cast<ComplexScalar>(); \
+    if(computeU)  m_matU = ComplexMatrixType::Identity(1,1); \
+      m_info = Success; \
+      m_isInitialized = true; \
+      m_matUisUptodate = computeU; \
+      return *this; \
+  } \
+  lapack_int n = internal::convert_index<lapack_int>(matrix.cols()), sdim, info; \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  char jobvs, sort='N'; \
+  LAPACK_##LAPACKE_PREFIX_U##_SELECT1 select = 0; \
+  jobvs = (computeU) ? 'V' : 'N'; \
+  m_matU.resize(n, n); \
+  lapack_int ldvs  = internal::convert_index<lapack_int>(m_matU.outerStride()); \
+  m_matT = matrix; \
+  lapack_int lda = internal::convert_index<lapack_int>(m_matT.outerStride()); \
+  Matrix<EIGTYPE, Dynamic, Dynamic> w; \
+  w.resize(n, 1);\
+  info = LAPACKE_##LAPACKE_PREFIX##gees( matrix_order, jobvs, sort, select, n, (LAPACKE_TYPE*)m_matT.data(), lda, &sdim, (LAPACKE_TYPE*)w.data(), (LAPACKE_TYPE*)m_matU.data(), ldvs ); \
+  if(info == 0) \
+    m_info = Success; \
+  else \
+    m_info = NoConvergence; \
+\
+  m_isInitialized = true; \
+  m_matUisUptodate = computeU; \
+  return *this; \
+\
+}
+
+EIGEN_LAPACKE_SCHUR_COMPLEX(dcomplex, lapack_complex_double, z, Z, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_COMPLEX(scomplex, lapack_complex_float,  c, C, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_COMPLEX(dcomplex, lapack_complex_double, z, Z, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SCHUR_COMPLEX(scomplex, lapack_complex_float,  c, C, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPLEX_SCHUR_LAPACKE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/EigenSolver.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/EigenSolver.h
new file mode 100644
index 00000000..572b29e4
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/EigenSolver.h
@@ -0,0 +1,622 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EIGENSOLVER_H
+#define EIGEN_EIGENSOLVER_H
+
+#include "./RealSchur.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class EigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of general matrices
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * eigendecomposition; this is expected to be an instantiation of the Matrix
+  * class template. Currently, only real matrices are supported.
+  *
+  * The eigenvalues and eigenvectors of a matrix \f$ A \f$ are scalars
+  * \f$ \lambda \f$ and vectors \f$ v \f$ such that \f$ Av = \lambda v \f$.  If
+  * \f$ D \f$ is a diagonal matrix with the eigenvalues on the diagonal, and
+  * \f$ V \f$ is a matrix with the eigenvectors as its columns, then \f$ A V =
+  * V D \f$. The matrix \f$ V \f$ is almost always invertible, in which case we
+  * have \f$ A = V D V^{-1} \f$. This is called the eigendecomposition.
+  *
+  * The eigenvalues and eigenvectors of a matrix may be complex, even when the
+  * matrix is real. However, we can choose real matrices \f$ V \f$ and \f$ D
+  * \f$ satisfying \f$ A V = V D \f$, just like the eigendecomposition, if the
+  * matrix \f$ D \f$ is not required to be diagonal, but if it is allowed to
+  * have blocks of the form
+  * \f[ \begin{bmatrix} u & v \\ -v & u \end{bmatrix} \f]
+  * (where \f$ u \f$ and \f$ v \f$ are real numbers) on the diagonal.  These
+  * blocks correspond to complex eigenvalue pairs \f$ u \pm iv \f$. We call
+  * this variant of the eigendecomposition the pseudo-eigendecomposition.
+  *
+  * Call the function compute() to compute the eigenvalues and eigenvectors of
+  * a given matrix. Alternatively, you can use the 
+  * EigenSolver(const MatrixType&, bool) constructor which computes the
+  * eigenvalues and eigenvectors at construction time. Once the eigenvalue and
+  * eigenvectors are computed, they can be retrieved with the eigenvalues() and
+  * eigenvectors() functions. The pseudoEigenvalueMatrix() and
+  * pseudoEigenvectors() methods allow the construction of the
+  * pseudo-eigendecomposition.
+  *
+  * The documentation for EigenSolver(const MatrixType&, bool) contains an
+  * example of the typical use of this class.
+  *
+  * \note The implementation is adapted from
+  * <a href="http://math.nist.gov/javanumerics/jama/">JAMA</a> (public domain).
+  * Their code is based on EISPACK.
+  *
+  * \sa MatrixBase::eigenvalues(), class ComplexEigenSolver, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class EigenSolver
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for #MatrixType. 
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for vector of eigenvalues as returned by eigenvalues(). 
+      *
+      * This is a column vector with entries of type #ComplexScalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
+
+    /** \brief Type for matrix of eigenvectors as returned by eigenvectors(). 
+      *
+      * This is a square matrix with entries of type #ComplexScalar. 
+      * The size is the same as the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> EigenvectorsType;
+
+    /** \brief Default constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via EigenSolver::compute(const MatrixType&, bool).
+      *
+      * \sa compute() for an example.
+      */
+    EigenSolver() : m_eivec(), m_eivalues(), m_isInitialized(false), m_eigenvectorsOk(false), m_realSchur(), m_matT(), m_tmp() {}
+
+    /** \brief Default constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa EigenSolver()
+      */
+    explicit EigenSolver(Index size)
+      : m_eivec(size, size),
+        m_eivalues(size),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false),
+        m_realSchur(size),
+        m_matT(size, size), 
+        m_tmp(size)
+    {}
+
+    /** \brief Constructor; computes eigendecomposition of given matrix. 
+      * 
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed. 
+      *
+      * This constructor calls compute() to compute the eigenvalues
+      * and eigenvectors.
+      *
+      * Example: \include EigenSolver_EigenSolver_MatrixType.cpp
+      * Output: \verbinclude EigenSolver_EigenSolver_MatrixType.out
+      *
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit EigenSolver(const EigenBase<InputType>& matrix, bool computeEigenvectors = true)
+      : m_eivec(matrix.rows(), matrix.cols()),
+        m_eivalues(matrix.cols()),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false),
+        m_realSchur(matrix.cols()),
+        m_matT(matrix.rows(), matrix.cols()), 
+        m_tmp(matrix.cols())
+    {
+      compute(matrix.derived(), computeEigenvectors);
+    }
+
+    /** \brief Returns the eigenvectors of given matrix. 
+      *
+      * \returns  %Matrix whose columns are the (possibly complex) eigenvectors.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * Column \f$ k \f$ of the returned matrix is an eigenvector corresponding
+      * to eigenvalue number \f$ k \f$ as returned by eigenvalues().  The
+      * eigenvectors are normalized to have (Euclidean) norm equal to one. The
+      * matrix returned by this function is the matrix \f$ V \f$ in the
+      * eigendecomposition \f$ A = V D V^{-1} \f$, if it exists.
+      *
+      * Example: \include EigenSolver_eigenvectors.cpp
+      * Output: \verbinclude EigenSolver_eigenvectors.out
+      *
+      * \sa eigenvalues(), pseudoEigenvectors()
+      */
+    EigenvectorsType eigenvectors() const;
+
+    /** \brief Returns the pseudo-eigenvectors of given matrix. 
+      *
+      * \returns  Const reference to matrix whose columns are the pseudo-eigenvectors.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * The real matrix \f$ V \f$ returned by this function and the
+      * block-diagonal matrix \f$ D \f$ returned by pseudoEigenvalueMatrix()
+      * satisfy \f$ AV = VD \f$.
+      *
+      * Example: \include EigenSolver_pseudoEigenvectors.cpp
+      * Output: \verbinclude EigenSolver_pseudoEigenvectors.out
+      *
+      * \sa pseudoEigenvalueMatrix(), eigenvectors()
+      */
+    const MatrixType& pseudoEigenvectors() const
+    {
+      eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec;
+    }
+
+    /** \brief Returns the block-diagonal matrix in the pseudo-eigendecomposition.
+      *
+      * \returns  A block-diagonal matrix.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before.
+      *
+      * The matrix \f$ D \f$ returned by this function is real and
+      * block-diagonal. The blocks on the diagonal are either 1-by-1 or 2-by-2
+      * blocks of the form
+      * \f$ \begin{bmatrix} u & v \\ -v & u \end{bmatrix} \f$.
+      * These blocks are not sorted in any particular order.
+      * The matrix \f$ D \f$ and the matrix \f$ V \f$ returned by
+      * pseudoEigenvectors() satisfy \f$ AV = VD \f$.
+      *
+      * \sa pseudoEigenvectors() for an example, eigenvalues()
+      */
+    MatrixType pseudoEigenvalueMatrix() const;
+
+    /** \brief Returns the eigenvalues of given matrix. 
+      *
+      * \returns A const reference to the column vector containing the eigenvalues.
+      *
+      * \pre Either the constructor 
+      * EigenSolver(const MatrixType&,bool) or the member function
+      * compute(const MatrixType&, bool) has been called before.
+      *
+      * The eigenvalues are repeated according to their algebraic multiplicity,
+      * so there are as many eigenvalues as rows in the matrix. The eigenvalues 
+      * are not sorted in any particular order.
+      *
+      * Example: \include EigenSolver_eigenvalues.cpp
+      * Output: \verbinclude EigenSolver_eigenvalues.out
+      *
+      * \sa eigenvectors(), pseudoEigenvalueMatrix(),
+      *     MatrixBase::eigenvalues()
+      */
+    const EigenvalueType& eigenvalues() const
+    {
+      eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+      return m_eivalues;
+    }
+
+    /** \brief Computes eigendecomposition of given matrix. 
+      * 
+      * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed. 
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of the real matrix \p matrix.
+      * The eigenvalues() function can be used to retrieve them.  If 
+      * \p computeEigenvectors is true, then the eigenvectors are also computed
+      * and can be retrieved by calling eigenvectors().
+      *
+      * The matrix is first reduced to real Schur form using the RealSchur
+      * class. The Schur decomposition is then used to compute the eigenvalues
+      * and eigenvectors.
+      *
+      * The cost of the computation is dominated by the cost of the
+      * Schur decomposition, which is very approximately \f$ 25n^3 \f$
+      * (where \f$ n \f$ is the size of the matrix) if \p computeEigenvectors 
+      * is true, and \f$ 10n^3 \f$ if \p computeEigenvectors is false.
+      *
+      * This method reuses of the allocated data in the EigenSolver object.
+      *
+      * Example: \include EigenSolver_compute.cpp
+      * Output: \verbinclude EigenSolver_compute.out
+      */
+    template<typename InputType>
+    EigenSolver& compute(const EigenBase<InputType>& matrix, bool computeEigenvectors = true);
+
+    /** \returns NumericalIssue if the input contains INF or NaN values or overflow occurred. Returns Success otherwise. */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. */
+    EigenSolver& setMaxIterations(Index maxIters)
+    {
+      m_realSchur.setMaxIterations(maxIters);
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_realSchur.getMaxIterations();
+    }
+
+  private:
+    void doComputeEigenvectors();
+
+  protected:
+    
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+      EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL);
+    }
+    
+    MatrixType m_eivec;
+    EigenvalueType m_eivalues;
+    bool m_isInitialized;
+    bool m_eigenvectorsOk;
+    ComputationInfo m_info;
+    RealSchur<MatrixType> m_realSchur;
+    MatrixType m_matT;
+
+    typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+    ColumnVectorType m_tmp;
+};
+
+template<typename MatrixType>
+MatrixType EigenSolver<MatrixType>::pseudoEigenvalueMatrix() const
+{
+  eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+  const RealScalar precision = RealScalar(2)*NumTraits<RealScalar>::epsilon();
+  Index n = m_eivalues.rows();
+  MatrixType matD = MatrixType::Zero(n,n);
+  for (Index i=0; i<n; ++i)
+  {
+    if (internal::isMuchSmallerThan(numext::imag(m_eivalues.coeff(i)), numext::real(m_eivalues.coeff(i)), precision))
+      matD.coeffRef(i,i) = numext::real(m_eivalues.coeff(i));
+    else
+    {
+      matD.template block<2,2>(i,i) <<  numext::real(m_eivalues.coeff(i)), numext::imag(m_eivalues.coeff(i)),
+                                       -numext::imag(m_eivalues.coeff(i)), numext::real(m_eivalues.coeff(i));
+      ++i;
+    }
+  }
+  return matD;
+}
+
+template<typename MatrixType>
+typename EigenSolver<MatrixType>::EigenvectorsType EigenSolver<MatrixType>::eigenvectors() const
+{
+  eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
+  eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+  const RealScalar precision = RealScalar(2)*NumTraits<RealScalar>::epsilon();
+  Index n = m_eivec.cols();
+  EigenvectorsType matV(n,n);
+  for (Index j=0; j<n; ++j)
+  {
+    if (internal::isMuchSmallerThan(numext::imag(m_eivalues.coeff(j)), numext::real(m_eivalues.coeff(j)), precision) || j+1==n)
+    {
+      // we have a real eigen value
+      matV.col(j) = m_eivec.col(j).template cast<ComplexScalar>();
+      matV.col(j).normalize();
+    }
+    else
+    {
+      // we have a pair of complex eigen values
+      for (Index i=0; i<n; ++i)
+      {
+        matV.coeffRef(i,j)   = ComplexScalar(m_eivec.coeff(i,j),  m_eivec.coeff(i,j+1));
+        matV.coeffRef(i,j+1) = ComplexScalar(m_eivec.coeff(i,j), -m_eivec.coeff(i,j+1));
+      }
+      matV.col(j).normalize();
+      matV.col(j+1).normalize();
+      ++j;
+    }
+  }
+  return matV;
+}
+
+template<typename MatrixType>
+template<typename InputType>
+EigenSolver<MatrixType>& 
+EigenSolver<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeEigenvectors)
+{
+  check_template_parameters();
+  
+  using std::sqrt;
+  using std::abs;
+  using numext::isfinite;
+  eigen_assert(matrix.cols() == matrix.rows());
+
+  // Reduce to real Schur form.
+  m_realSchur.compute(matrix.derived(), computeEigenvectors);
+  
+  m_info = m_realSchur.info();
+
+  if (m_info == Success)
+  {
+    m_matT = m_realSchur.matrixT();
+    if (computeEigenvectors)
+      m_eivec = m_realSchur.matrixU();
+  
+    // Compute eigenvalues from matT
+    m_eivalues.resize(matrix.cols());
+    Index i = 0;
+    while (i < matrix.cols()) 
+    {
+      if (i == matrix.cols() - 1 || m_matT.coeff(i+1, i) == Scalar(0)) 
+      {
+        m_eivalues.coeffRef(i) = m_matT.coeff(i, i);
+        if(!(isfinite)(m_eivalues.coeffRef(i)))
+        {
+          m_isInitialized = true;
+          m_eigenvectorsOk = false;
+          m_info = NumericalIssue;
+          return *this;
+        }
+        ++i;
+      }
+      else
+      {
+        Scalar p = Scalar(0.5) * (m_matT.coeff(i, i) - m_matT.coeff(i+1, i+1));
+        Scalar z;
+        // Compute z = sqrt(abs(p * p + m_matT.coeff(i+1, i) * m_matT.coeff(i, i+1)));
+        // without overflow
+        {
+          Scalar t0 = m_matT.coeff(i+1, i);
+          Scalar t1 = m_matT.coeff(i, i+1);
+          Scalar maxval = numext::maxi<Scalar>(abs(p),numext::maxi<Scalar>(abs(t0),abs(t1)));
+          t0 /= maxval;
+          t1 /= maxval;
+          Scalar p0 = p/maxval;
+          z = maxval * sqrt(abs(p0 * p0 + t0 * t1));
+        }
+        
+        m_eivalues.coeffRef(i)   = ComplexScalar(m_matT.coeff(i+1, i+1) + p, z);
+        m_eivalues.coeffRef(i+1) = ComplexScalar(m_matT.coeff(i+1, i+1) + p, -z);
+        if(!((isfinite)(m_eivalues.coeffRef(i)) && (isfinite)(m_eivalues.coeffRef(i+1))))
+        {
+          m_isInitialized = true;
+          m_eigenvectorsOk = false;
+          m_info = NumericalIssue;
+          return *this;
+        }
+        i += 2;
+      }
+    }
+    
+    // Compute eigenvectors.
+    if (computeEigenvectors)
+      doComputeEigenvectors();
+  }
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+
+  return *this;
+}
+
+
+template<typename MatrixType>
+void EigenSolver<MatrixType>::doComputeEigenvectors()
+{
+  using std::abs;
+  const Index size = m_eivec.cols();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+
+  // inefficient! this is already computed in RealSchur
+  Scalar norm(0);
+  for (Index j = 0; j < size; ++j)
+  {
+    norm += m_matT.row(j).segment((std::max)(j-1,Index(0)), size-(std::max)(j-1,Index(0))).cwiseAbs().sum();
+  }
+  
+  // Backsubstitute to find vectors of upper triangular form
+  if (norm == Scalar(0))
+  {
+    return;
+  }
+
+  for (Index n = size-1; n >= 0; n--)
+  {
+    Scalar p = m_eivalues.coeff(n).real();
+    Scalar q = m_eivalues.coeff(n).imag();
+
+    // Scalar vector
+    if (q == Scalar(0))
+    {
+      Scalar lastr(0), lastw(0);
+      Index l = n;
+
+      m_matT.coeffRef(n,n) = Scalar(1);
+      for (Index i = n-1; i >= 0; i--)
+      {
+        Scalar w = m_matT.coeff(i,i) - p;
+        Scalar r = m_matT.row(i).segment(l,n-l+1).dot(m_matT.col(n).segment(l, n-l+1));
+
+        if (m_eivalues.coeff(i).imag() < Scalar(0))
+        {
+          lastw = w;
+          lastr = r;
+        }
+        else
+        {
+          l = i;
+          if (m_eivalues.coeff(i).imag() == Scalar(0))
+          {
+            if (w != Scalar(0))
+              m_matT.coeffRef(i,n) = -r / w;
+            else
+              m_matT.coeffRef(i,n) = -r / (eps * norm);
+          }
+          else // Solve real equations
+          {
+            Scalar x = m_matT.coeff(i,i+1);
+            Scalar y = m_matT.coeff(i+1,i);
+            Scalar denom = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag();
+            Scalar t = (x * lastr - lastw * r) / denom;
+            m_matT.coeffRef(i,n) = t;
+            if (abs(x) > abs(lastw))
+              m_matT.coeffRef(i+1,n) = (-r - w * t) / x;
+            else
+              m_matT.coeffRef(i+1,n) = (-lastr - y * t) / lastw;
+          }
+
+          // Overflow control
+          Scalar t = abs(m_matT.coeff(i,n));
+          if ((eps * t) * t > Scalar(1))
+            m_matT.col(n).tail(size-i) /= t;
+        }
+      }
+    }
+    else if (q < Scalar(0) && n > 0) // Complex vector
+    {
+      Scalar lastra(0), lastsa(0), lastw(0);
+      Index l = n-1;
+
+      // Last vector component imaginary so matrix is triangular
+      if (abs(m_matT.coeff(n,n-1)) > abs(m_matT.coeff(n-1,n)))
+      {
+        m_matT.coeffRef(n-1,n-1) = q / m_matT.coeff(n,n-1);
+        m_matT.coeffRef(n-1,n) = -(m_matT.coeff(n,n) - p) / m_matT.coeff(n,n-1);
+      }
+      else
+      {
+        ComplexScalar cc = ComplexScalar(Scalar(0),-m_matT.coeff(n-1,n)) / ComplexScalar(m_matT.coeff(n-1,n-1)-p,q);
+        m_matT.coeffRef(n-1,n-1) = numext::real(cc);
+        m_matT.coeffRef(n-1,n) = numext::imag(cc);
+      }
+      m_matT.coeffRef(n,n-1) = Scalar(0);
+      m_matT.coeffRef(n,n) = Scalar(1);
+      for (Index i = n-2; i >= 0; i--)
+      {
+        Scalar ra = m_matT.row(i).segment(l, n-l+1).dot(m_matT.col(n-1).segment(l, n-l+1));
+        Scalar sa = m_matT.row(i).segment(l, n-l+1).dot(m_matT.col(n).segment(l, n-l+1));
+        Scalar w = m_matT.coeff(i,i) - p;
+
+        if (m_eivalues.coeff(i).imag() < Scalar(0))
+        {
+          lastw = w;
+          lastra = ra;
+          lastsa = sa;
+        }
+        else
+        {
+          l = i;
+          if (m_eivalues.coeff(i).imag() == RealScalar(0))
+          {
+            ComplexScalar cc = ComplexScalar(-ra,-sa) / ComplexScalar(w,q);
+            m_matT.coeffRef(i,n-1) = numext::real(cc);
+            m_matT.coeffRef(i,n) = numext::imag(cc);
+          }
+          else
+          {
+            // Solve complex equations
+            Scalar x = m_matT.coeff(i,i+1);
+            Scalar y = m_matT.coeff(i+1,i);
+            Scalar vr = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag() - q * q;
+            Scalar vi = (m_eivalues.coeff(i).real() - p) * Scalar(2) * q;
+            if ((vr == Scalar(0)) && (vi == Scalar(0)))
+              vr = eps * norm * (abs(w) + abs(q) + abs(x) + abs(y) + abs(lastw));
+
+            ComplexScalar cc = ComplexScalar(x*lastra-lastw*ra+q*sa,x*lastsa-lastw*sa-q*ra) / ComplexScalar(vr,vi);
+            m_matT.coeffRef(i,n-1) = numext::real(cc);
+            m_matT.coeffRef(i,n) = numext::imag(cc);
+            if (abs(x) > (abs(lastw) + abs(q)))
+            {
+              m_matT.coeffRef(i+1,n-1) = (-ra - w * m_matT.coeff(i,n-1) + q * m_matT.coeff(i,n)) / x;
+              m_matT.coeffRef(i+1,n) = (-sa - w * m_matT.coeff(i,n) - q * m_matT.coeff(i,n-1)) / x;
+            }
+            else
+            {
+              cc = ComplexScalar(-lastra-y*m_matT.coeff(i,n-1),-lastsa-y*m_matT.coeff(i,n)) / ComplexScalar(lastw,q);
+              m_matT.coeffRef(i+1,n-1) = numext::real(cc);
+              m_matT.coeffRef(i+1,n) = numext::imag(cc);
+            }
+          }
+
+          // Overflow control
+          Scalar t = numext::maxi<Scalar>(abs(m_matT.coeff(i,n-1)),abs(m_matT.coeff(i,n)));
+          if ((eps * t) * t > Scalar(1))
+            m_matT.block(i, n-1, size-i, 2) /= t;
+
+        }
+      }
+      
+      // We handled a pair of complex conjugate eigenvalues, so need to skip them both
+      n--;
+    }
+    else
+    {
+      eigen_assert(0 && "Internal bug in EigenSolver (INF or NaN has not been detected)"); // this should not happen
+    }
+  }
+
+  // Back transformation to get eigenvectors of original matrix
+  for (Index j = size-1; j >= 0; j--)
+  {
+    m_tmp.noalias() = m_eivec.leftCols(j+1) * m_matT.col(j).segment(0, j+1);
+    m_eivec.col(j) = m_tmp;
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_EIGENSOLVER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
new file mode 100644
index 00000000..87d789b3
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
@@ -0,0 +1,418 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+// Copyright (C) 2016 Tobias Wood <tobias@spinicist.org.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERALIZEDEIGENSOLVER_H
+#define EIGEN_GENERALIZEDEIGENSOLVER_H
+
+#include "./RealQZ.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class GeneralizedEigenSolver
+  *
+  * \brief Computes the generalized eigenvalues and eigenvectors of a pair of general matrices
+  *
+  * \tparam _MatrixType the type of the matrices of which we are computing the
+  * eigen-decomposition; this is expected to be an instantiation of the Matrix
+  * class template. Currently, only real matrices are supported.
+  *
+  * The generalized eigenvalues and eigenvectors of a matrix pair \f$ A \f$ and \f$ B \f$ are scalars
+  * \f$ \lambda \f$ and vectors \f$ v \f$ such that \f$ Av = \lambda Bv \f$.  If
+  * \f$ D \f$ is a diagonal matrix with the eigenvalues on the diagonal, and
+  * \f$ V \f$ is a matrix with the eigenvectors as its columns, then \f$ A V =
+  * B V D \f$. The matrix \f$ V \f$ is almost always invertible, in which case we
+  * have \f$ A = B V D V^{-1} \f$. This is called the generalized eigen-decomposition.
+  *
+  * The generalized eigenvalues and eigenvectors of a matrix pair may be complex, even when the
+  * matrices are real. Moreover, the generalized eigenvalue might be infinite if the matrix B is
+  * singular. To workaround this difficulty, the eigenvalues are provided as a pair of complex \f$ \alpha \f$
+  * and real \f$ \beta \f$ such that: \f$ \lambda_i = \alpha_i / \beta_i \f$. If \f$ \beta_i \f$ is (nearly) zero,
+  * then one can consider the well defined left eigenvalue \f$ \mu = \beta_i / \alpha_i\f$ such that:
+  * \f$ \mu_i A v_i = B v_i \f$, or even \f$ \mu_i u_i^T A  = u_i^T B \f$ where \f$ u_i \f$ is
+  * called the left eigenvector.
+  *
+  * Call the function compute() to compute the generalized eigenvalues and eigenvectors of
+  * a given matrix pair. Alternatively, you can use the
+  * GeneralizedEigenSolver(const MatrixType&, const MatrixType&, bool) constructor which computes the
+  * eigenvalues and eigenvectors at construction time. Once the eigenvalue and
+  * eigenvectors are computed, they can be retrieved with the eigenvalues() and
+  * eigenvectors() functions.
+  *
+  * Here is an usage example of this class:
+  * Example: \include GeneralizedEigenSolver.cpp
+  * Output: \verbinclude GeneralizedEigenSolver.out
+  *
+  * \sa MatrixBase::eigenvalues(), class ComplexEigenSolver, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class GeneralizedEigenSolver
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Complex scalar type for #MatrixType. 
+      *
+      * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
+      * \c float or \c double) and just \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef std::complex<RealScalar> ComplexScalar;
+
+    /** \brief Type for vector of real scalar values eigenvalues as returned by betas().
+      *
+      * This is a column vector with entries of type #Scalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> VectorType;
+
+    /** \brief Type for vector of complex scalar values eigenvalues as returned by alphas().
+      *
+      * This is a column vector with entries of type #ComplexScalar.
+      * The length of the vector is the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ComplexVectorType;
+
+    /** \brief Expression type for the eigenvalues as returned by eigenvalues().
+      */
+    typedef CwiseBinaryOp<internal::scalar_quotient_op<ComplexScalar,Scalar>,ComplexVectorType,VectorType> EigenvalueType;
+
+    /** \brief Type for matrix of eigenvectors as returned by eigenvectors(). 
+      *
+      * This is a square matrix with entries of type #ComplexScalar. 
+      * The size is the same as the size of #MatrixType.
+      */
+    typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> EigenvectorsType;
+
+    /** \brief Default constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via EigenSolver::compute(const MatrixType&, bool).
+      *
+      * \sa compute() for an example.
+      */
+    GeneralizedEigenSolver()
+      : m_eivec(),
+        m_alphas(),
+        m_betas(),
+        m_valuesOkay(false),
+        m_vectorsOkay(false),
+        m_realQZ()
+    {}
+
+    /** \brief Default constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa GeneralizedEigenSolver()
+      */
+    explicit GeneralizedEigenSolver(Index size)
+      : m_eivec(size, size),
+        m_alphas(size),
+        m_betas(size),
+        m_valuesOkay(false),
+        m_vectorsOkay(false),
+        m_realQZ(size),
+        m_tmp(size)
+    {}
+
+    /** \brief Constructor; computes the generalized eigendecomposition of given matrix pair.
+      * 
+      * \param[in]  A  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  B  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are computed.
+      *
+      * This constructor calls compute() to compute the generalized eigenvalues
+      * and eigenvectors.
+      *
+      * \sa compute()
+      */
+    GeneralizedEigenSolver(const MatrixType& A, const MatrixType& B, bool computeEigenvectors = true)
+      : m_eivec(A.rows(), A.cols()),
+        m_alphas(A.cols()),
+        m_betas(A.cols()),
+        m_valuesOkay(false),
+        m_vectorsOkay(false),
+        m_realQZ(A.cols()),
+        m_tmp(A.cols())
+    {
+      compute(A, B, computeEigenvectors);
+    }
+
+    /* \brief Returns the computed generalized eigenvectors.
+      *
+      * \returns  %Matrix whose columns are the (possibly complex) right eigenvectors.
+      * i.e. the eigenvectors that solve (A - l*B)x = 0. The ordering matches the eigenvalues.
+      *
+      * \pre Either the constructor 
+      * GeneralizedEigenSolver(const MatrixType&,const MatrixType&, bool) or the member function
+      * compute(const MatrixType&, const MatrixType& bool) has been called before, and
+      * \p computeEigenvectors was set to true (the default).
+      *
+      * \sa eigenvalues()
+      */
+    EigenvectorsType eigenvectors() const {
+      eigen_assert(m_vectorsOkay && "Eigenvectors for GeneralizedEigenSolver were not calculated.");
+      return m_eivec;
+    }
+
+    /** \brief Returns an expression of the computed generalized eigenvalues.
+      *
+      * \returns An expression of the column vector containing the eigenvalues.
+      *
+      * It is a shortcut for \code this->alphas().cwiseQuotient(this->betas()); \endcode
+      * Not that betas might contain zeros. It is therefore not recommended to use this function,
+      * but rather directly deal with the alphas and betas vectors.
+      *
+      * \pre Either the constructor 
+      * GeneralizedEigenSolver(const MatrixType&,const MatrixType&,bool) or the member function
+      * compute(const MatrixType&,const MatrixType&,bool) has been called before.
+      *
+      * The eigenvalues are repeated according to their algebraic multiplicity,
+      * so there are as many eigenvalues as rows in the matrix. The eigenvalues 
+      * are not sorted in any particular order.
+      *
+      * \sa alphas(), betas(), eigenvectors()
+      */
+    EigenvalueType eigenvalues() const
+    {
+      eigen_assert(m_valuesOkay && "GeneralizedEigenSolver is not initialized.");
+      return EigenvalueType(m_alphas,m_betas);
+    }
+
+    /** \returns A const reference to the vectors containing the alpha values
+      *
+      * This vector permits to reconstruct the j-th eigenvalues as alphas(i)/betas(j).
+      *
+      * \sa betas(), eigenvalues() */
+    ComplexVectorType alphas() const
+    {
+      eigen_assert(m_valuesOkay && "GeneralizedEigenSolver is not initialized.");
+      return m_alphas;
+    }
+
+    /** \returns A const reference to the vectors containing the beta values
+      *
+      * This vector permits to reconstruct the j-th eigenvalues as alphas(i)/betas(j).
+      *
+      * \sa alphas(), eigenvalues() */
+    VectorType betas() const
+    {
+      eigen_assert(m_valuesOkay && "GeneralizedEigenSolver is not initialized.");
+      return m_betas;
+    }
+
+    /** \brief Computes generalized eigendecomposition of given matrix.
+      * 
+      * \param[in]  A  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  B  Square matrix whose eigendecomposition is to be computed.
+      * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+      *    eigenvalues are computed; if false, only the eigenvalues are
+      *    computed. 
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of the real matrix \p matrix.
+      * The eigenvalues() function can be used to retrieve them.  If 
+      * \p computeEigenvectors is true, then the eigenvectors are also computed
+      * and can be retrieved by calling eigenvectors().
+      *
+      * The matrix is first reduced to real generalized Schur form using the RealQZ
+      * class. The generalized Schur decomposition is then used to compute the eigenvalues
+      * and eigenvectors.
+      *
+      * The cost of the computation is dominated by the cost of the
+      * generalized Schur decomposition.
+      *
+      * This method reuses of the allocated data in the GeneralizedEigenSolver object.
+      */
+    GeneralizedEigenSolver& compute(const MatrixType& A, const MatrixType& B, bool computeEigenvectors = true);
+
+    ComputationInfo info() const
+    {
+      eigen_assert(m_valuesOkay && "EigenSolver is not initialized.");
+      return m_realQZ.info();
+    }
+
+    /** Sets the maximal number of iterations allowed.
+    */
+    GeneralizedEigenSolver& setMaxIterations(Index maxIters)
+    {
+      m_realQZ.setMaxIterations(maxIters);
+      return *this;
+    }
+
+  protected:
+    
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+      EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL);
+    }
+    
+    EigenvectorsType m_eivec;
+    ComplexVectorType m_alphas;
+    VectorType m_betas;
+    bool m_valuesOkay, m_vectorsOkay;
+    RealQZ<MatrixType> m_realQZ;
+    ComplexVectorType m_tmp;
+};
+
+template<typename MatrixType>
+GeneralizedEigenSolver<MatrixType>&
+GeneralizedEigenSolver<MatrixType>::compute(const MatrixType& A, const MatrixType& B, bool computeEigenvectors)
+{
+  check_template_parameters();
+  
+  using std::sqrt;
+  using std::abs;
+  eigen_assert(A.cols() == A.rows() && B.cols() == A.rows() && B.cols() == B.rows());
+  Index size = A.cols();
+  m_valuesOkay = false;
+  m_vectorsOkay = false;
+  // Reduce to generalized real Schur form:
+  // A = Q S Z and B = Q T Z
+  m_realQZ.compute(A, B, computeEigenvectors);
+  if (m_realQZ.info() == Success)
+  {
+    // Resize storage
+    m_alphas.resize(size);
+    m_betas.resize(size);
+    if (computeEigenvectors)
+    {
+      m_eivec.resize(size,size);
+      m_tmp.resize(size);
+    }
+
+    // Aliases:
+    Map<VectorType> v(reinterpret_cast<Scalar*>(m_tmp.data()), size);
+    ComplexVectorType &cv = m_tmp;
+    const MatrixType &mS = m_realQZ.matrixS();
+    const MatrixType &mT = m_realQZ.matrixT();
+
+    Index i = 0;
+    while (i < size)
+    {
+      if (i == size - 1 || mS.coeff(i+1, i) == Scalar(0))
+      {
+        // Real eigenvalue
+        m_alphas.coeffRef(i) = mS.diagonal().coeff(i);
+        m_betas.coeffRef(i)  = mT.diagonal().coeff(i);
+        if (computeEigenvectors)
+        {
+          v.setConstant(Scalar(0.0));
+          v.coeffRef(i) = Scalar(1.0);
+          // For singular eigenvalues do nothing more
+          if(abs(m_betas.coeffRef(i)) >= (std::numeric_limits<RealScalar>::min)())
+          {
+            // Non-singular eigenvalue
+            const Scalar alpha = real(m_alphas.coeffRef(i));
+            const Scalar beta = m_betas.coeffRef(i);
+            for (Index j = i-1; j >= 0; j--)
+            {
+              const Index st = j+1;
+              const Index sz = i-j;
+              if (j > 0 && mS.coeff(j, j-1) != Scalar(0))
+              {
+                // 2x2 block
+                Matrix<Scalar, 2, 1> rhs = (alpha*mT.template block<2,Dynamic>(j-1,st,2,sz) - beta*mS.template block<2,Dynamic>(j-1,st,2,sz)) .lazyProduct( v.segment(st,sz) );
+                Matrix<Scalar, 2, 2> lhs = beta * mS.template block<2,2>(j-1,j-1) - alpha * mT.template block<2,2>(j-1,j-1);
+                v.template segment<2>(j-1) = lhs.partialPivLu().solve(rhs);
+                j--;
+              }
+              else
+              {
+                v.coeffRef(j) = -v.segment(st,sz).transpose().cwiseProduct(beta*mS.block(j,st,1,sz) - alpha*mT.block(j,st,1,sz)).sum() / (beta*mS.coeffRef(j,j) - alpha*mT.coeffRef(j,j));
+              }
+            }
+          }
+          m_eivec.col(i).real().noalias() = m_realQZ.matrixZ().transpose() * v;
+          m_eivec.col(i).real().normalize();
+          m_eivec.col(i).imag().setConstant(0);
+        }
+        ++i;
+      }
+      else
+      {
+        // We need to extract the generalized eigenvalues of the pair of a general 2x2 block S and a positive diagonal 2x2 block T
+        // Then taking beta=T_00*T_11, we can avoid any division, and alpha is the eigenvalues of A = (U^-1 * S * U) * diag(T_11,T_00):
+
+        // T =  [a 0]
+        //      [0 b]
+        RealScalar a = mT.diagonal().coeff(i),
+                   b = mT.diagonal().coeff(i+1);
+        const RealScalar beta = m_betas.coeffRef(i) = m_betas.coeffRef(i+1) = a*b;
+
+        // ^^ NOTE: using diagonal()(i) instead of coeff(i,i) workarounds a MSVC bug.
+        Matrix<RealScalar,2,2> S2 = mS.template block<2,2>(i,i) * Matrix<Scalar,2,1>(b,a).asDiagonal();
+
+        Scalar p = Scalar(0.5) * (S2.coeff(0,0) - S2.coeff(1,1));
+        Scalar z = sqrt(abs(p * p + S2.coeff(1,0) * S2.coeff(0,1)));
+        const ComplexScalar alpha = ComplexScalar(S2.coeff(1,1) + p, (beta > 0) ? z : -z);
+        m_alphas.coeffRef(i)   = conj(alpha);
+        m_alphas.coeffRef(i+1) = alpha;
+
+        if (computeEigenvectors) {
+          // Compute eigenvector in position (i+1) and then position (i) is just the conjugate
+          cv.setZero();
+          cv.coeffRef(i+1) = Scalar(1.0);
+          // here, the "static_cast" workaound expression template issues.
+          cv.coeffRef(i) = -(static_cast<Scalar>(beta*mS.coeffRef(i,i+1)) - alpha*mT.coeffRef(i,i+1))
+                          / (static_cast<Scalar>(beta*mS.coeffRef(i,i))   - alpha*mT.coeffRef(i,i));
+          for (Index j = i-1; j >= 0; j--)
+          {
+            const Index st = j+1;
+            const Index sz = i+1-j;
+            if (j > 0 && mS.coeff(j, j-1) != Scalar(0))
+            {
+              // 2x2 block
+              Matrix<ComplexScalar, 2, 1> rhs = (alpha*mT.template block<2,Dynamic>(j-1,st,2,sz) - beta*mS.template block<2,Dynamic>(j-1,st,2,sz)) .lazyProduct( cv.segment(st,sz) );
+              Matrix<ComplexScalar, 2, 2> lhs = beta * mS.template block<2,2>(j-1,j-1) - alpha * mT.template block<2,2>(j-1,j-1);
+              cv.template segment<2>(j-1) = lhs.partialPivLu().solve(rhs);
+              j--;
+            } else {
+              cv.coeffRef(j) =  cv.segment(st,sz).transpose().cwiseProduct(beta*mS.block(j,st,1,sz) - alpha*mT.block(j,st,1,sz)).sum()
+                              / (alpha*mT.coeffRef(j,j) - static_cast<Scalar>(beta*mS.coeffRef(j,j)));
+            }
+          }
+          m_eivec.col(i+1).noalias() = (m_realQZ.matrixZ().transpose() * cv);
+          m_eivec.col(i+1).normalize();
+          m_eivec.col(i) = m_eivec.col(i+1).conjugate();
+        }
+        i += 2;
+      }
+    }
+
+    m_valuesOkay = true;
+    m_vectorsOkay = computeEigenvectors;
+  }
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERALIZEDEIGENSOLVER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
new file mode 100644
index 00000000..d0f9091b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
+#define EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
+
+#include "./Tridiagonalization.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class GeneralizedSelfAdjointEigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of the generalized selfadjoint eigen problem
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * eigendecomposition; this is expected to be an instantiation of the Matrix
+  * class template.
+  *
+  * This class solves the generalized eigenvalue problem
+  * \f$ Av = \lambda Bv \f$. In this case, the matrix \f$ A \f$ should be
+  * selfadjoint and the matrix \f$ B \f$ should be positive definite.
+  *
+  * Only the \b lower \b triangular \b part of the input matrix is referenced.
+  *
+  * Call the function compute() to compute the eigenvalues and eigenvectors of
+  * a given matrix. Alternatively, you can use the
+  * GeneralizedSelfAdjointEigenSolver(const MatrixType&, const MatrixType&, int)
+  * constructor which computes the eigenvalues and eigenvectors at construction time.
+  * Once the eigenvalue and eigenvectors are computed, they can be retrieved with the eigenvalues()
+  * and eigenvectors() functions.
+  *
+  * The documentation for GeneralizedSelfAdjointEigenSolver(const MatrixType&, const MatrixType&, int)
+  * contains an example of the typical use of this class.
+  *
+  * \sa class SelfAdjointEigenSolver, class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType>
+class GeneralizedSelfAdjointEigenSolver : public SelfAdjointEigenSolver<_MatrixType>
+{
+    typedef SelfAdjointEigenSolver<_MatrixType> Base;
+  public:
+
+    typedef _MatrixType MatrixType;
+
+    /** \brief Default constructor for fixed-size matrices.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute(). This constructor
+      * can only be used if \p _MatrixType is a fixed-size matrix; use
+      * GeneralizedSelfAdjointEigenSolver(Index) for dynamic-size matrices.
+      */
+    GeneralizedSelfAdjointEigenSolver() : Base() {}
+
+    /** \brief Constructor, pre-allocates memory for dynamic-size matrices.
+      *
+      * \param [in]  size  Positive integer, size of the matrix whose
+      * eigenvalues and eigenvectors will be computed.
+      *
+      * This constructor is useful for dynamic-size matrices, when the user
+      * intends to perform decompositions via compute(). The \p size
+      * parameter is only used as a hint. It is not an error to give a wrong
+      * \p size, but it may impair performance.
+      *
+      * \sa compute() for an example
+      */
+    explicit GeneralizedSelfAdjointEigenSolver(Index size)
+        : Base(size)
+    {}
+
+    /** \brief Constructor; computes generalized eigendecomposition of given matrix pencil.
+      *
+      * \param[in]  matA  Selfadjoint matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  matB  Positive-definite matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options A or-ed set of flags {#ComputeEigenvectors,#EigenvaluesOnly} | {#Ax_lBx,#ABx_lx,#BAx_lx}.
+      *                     Default is #ComputeEigenvectors|#Ax_lBx.
+      *
+      * This constructor calls compute(const MatrixType&, const MatrixType&, int)
+      * to compute the eigenvalues and (if requested) the eigenvectors of the
+      * generalized eigenproblem \f$ Ax = \lambda B x \f$ with \a matA the
+      * selfadjoint matrix \f$ A \f$ and \a matB the positive definite matrix
+      * \f$ B \f$. Each eigenvector \f$ x \f$ satisfies the property
+      * \f$ x^* B x = 1 \f$. The eigenvectors are computed if
+      * \a options contains ComputeEigenvectors.
+      *
+      * In addition, the two following variants can be solved via \p options:
+      * - \c ABx_lx: \f$ ABx = \lambda x \f$
+      * - \c BAx_lx: \f$ BAx = \lambda x \f$
+      *
+      * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.out
+      *
+      * \sa compute(const MatrixType&, const MatrixType&, int)
+      */
+    GeneralizedSelfAdjointEigenSolver(const MatrixType& matA, const MatrixType& matB,
+                                      int options = ComputeEigenvectors|Ax_lBx)
+      : Base(matA.cols())
+    {
+      compute(matA, matB, options);
+    }
+
+    /** \brief Computes generalized eigendecomposition of given matrix pencil.
+      *
+      * \param[in]  matA  Selfadjoint matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  matB  Positive-definite matrix in matrix pencil.
+      *                   Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options A or-ed set of flags {#ComputeEigenvectors,#EigenvaluesOnly} | {#Ax_lBx,#ABx_lx,#BAx_lx}.
+      *                     Default is #ComputeEigenvectors|#Ax_lBx.
+      *
+      * \returns    Reference to \c *this
+      *
+      * According to \p options, this function computes eigenvalues and (if requested)
+      * the eigenvectors of one of the following three generalized eigenproblems:
+      * - \c Ax_lBx: \f$ Ax = \lambda B x \f$
+      * - \c ABx_lx: \f$ ABx = \lambda x \f$
+      * - \c BAx_lx: \f$ BAx = \lambda x \f$
+      * with \a matA the selfadjoint matrix \f$ A \f$ and \a matB the positive definite
+      * matrix \f$ B \f$.
+      * In addition, each eigenvector \f$ x \f$ satisfies the property \f$ x^* B x = 1 \f$.
+      *
+      * The eigenvalues() function can be used to retrieve
+      * the eigenvalues. If \p options contains ComputeEigenvectors, then the
+      * eigenvectors are also computed and can be retrieved by calling
+      * eigenvectors().
+      *
+      * The implementation uses LLT to compute the Cholesky decomposition
+      * \f$ B = LL^* \f$ and computes the classical eigendecomposition
+      * of the selfadjoint matrix \f$ L^{-1} A (L^*)^{-1} \f$ if \p options contains Ax_lBx
+      * and of \f$ L^{*} A L \f$ otherwise. This solves the
+      * generalized eigenproblem, because any solution of the generalized
+      * eigenproblem \f$ Ax = \lambda B x \f$ corresponds to a solution
+      * \f$ L^{-1} A (L^*)^{-1} (L^* x) = \lambda (L^* x) \f$ of the
+      * eigenproblem for \f$ L^{-1} A (L^*)^{-1} \f$. Similar statements
+      * can be made for the two other variants.
+      *
+      * Example: \include SelfAdjointEigenSolver_compute_MatrixType2.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_compute_MatrixType2.out
+      *
+      * \sa GeneralizedSelfAdjointEigenSolver(const MatrixType&, const MatrixType&, int)
+      */
+    GeneralizedSelfAdjointEigenSolver& compute(const MatrixType& matA, const MatrixType& matB,
+                                               int options = ComputeEigenvectors|Ax_lBx);
+
+  protected:
+
+};
+
+
+template<typename MatrixType>
+GeneralizedSelfAdjointEigenSolver<MatrixType>& GeneralizedSelfAdjointEigenSolver<MatrixType>::
+compute(const MatrixType& matA, const MatrixType& matB, int options)
+{
+  eigen_assert(matA.cols()==matA.rows() && matB.rows()==matA.rows() && matB.cols()==matB.rows());
+  eigen_assert((options&~(EigVecMask|GenEigMask))==0
+          && (options&EigVecMask)!=EigVecMask
+          && ((options&GenEigMask)==0 || (options&GenEigMask)==Ax_lBx
+           || (options&GenEigMask)==ABx_lx || (options&GenEigMask)==BAx_lx)
+          && "invalid option parameter");
+
+  bool computeEigVecs = ((options&EigVecMask)==0) || ((options&EigVecMask)==ComputeEigenvectors);
+
+  // Compute the cholesky decomposition of matB = L L' = U'U
+  LLT<MatrixType> cholB(matB);
+
+  int type = (options&GenEigMask);
+  if(type==0)
+    type = Ax_lBx;
+
+  if(type==Ax_lBx)
+  {
+    // compute C = inv(L) A inv(L')
+    MatrixType matC = matA.template selfadjointView<Lower>();
+    cholB.matrixL().template solveInPlace<OnTheLeft>(matC);
+    cholB.matrixU().template solveInPlace<OnTheRight>(matC);
+
+    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly );
+
+    // transform back the eigen vectors: evecs = inv(U) * evecs
+    if(computeEigVecs)
+      cholB.matrixU().solveInPlace(Base::m_eivec);
+  }
+  else if(type==ABx_lx)
+  {
+    // compute C = L' A L
+    MatrixType matC = matA.template selfadjointView<Lower>();
+    matC = matC * cholB.matrixL();
+    matC = cholB.matrixU() * matC;
+
+    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
+
+    // transform back the eigen vectors: evecs = inv(U) * evecs
+    if(computeEigVecs)
+      cholB.matrixU().solveInPlace(Base::m_eivec);
+  }
+  else if(type==BAx_lx)
+  {
+    // compute C = L' A L
+    MatrixType matC = matA.template selfadjointView<Lower>();
+    matC = matC * cholB.matrixL();
+    matC = cholB.matrixU() * matC;
+
+    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
+
+    // transform back the eigen vectors: evecs = L * evecs
+    if(computeEigVecs)
+      Base::m_eivec = cholB.matrixL() * Base::m_eivec;
+  }
+
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/HessenbergDecomposition.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
new file mode 100644
index 00000000..1f211393
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/HessenbergDecomposition.h
@@ -0,0 +1,374 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HESSENBERGDECOMPOSITION_H
+#define EIGEN_HESSENBERGDECOMPOSITION_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<typename MatrixType> struct HessenbergDecompositionMatrixHReturnType;
+template<typename MatrixType>
+struct traits<HessenbergDecompositionMatrixHReturnType<MatrixType> >
+{
+  typedef MatrixType ReturnType;
+};
+
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class HessenbergDecomposition
+  *
+  * \brief Reduces a square matrix to Hessenberg form by an orthogonal similarity transformation
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the Hessenberg decomposition
+  *
+  * This class performs an Hessenberg decomposition of a matrix \f$ A \f$. In
+  * the real case, the Hessenberg decomposition consists of an orthogonal
+  * matrix \f$ Q \f$ and a Hessenberg matrix \f$ H \f$ such that \f$ A = Q H
+  * Q^T \f$. An orthogonal matrix is a matrix whose inverse equals its
+  * transpose (\f$ Q^{-1} = Q^T \f$). A Hessenberg matrix has zeros below the
+  * subdiagonal, so it is almost upper triangular. The Hessenberg decomposition
+  * of a complex matrix is \f$ A = Q H Q^* \f$ with \f$ Q \f$ unitary (that is,
+  * \f$ Q^{-1} = Q^* \f$).
+  *
+  * Call the function compute() to compute the Hessenberg decomposition of a
+  * given matrix. Alternatively, you can use the
+  * HessenbergDecomposition(const MatrixType&) constructor which computes the
+  * Hessenberg decomposition at construction time. Once the decomposition is
+  * computed, you can use the matrixH() and matrixQ() functions to construct
+  * the matrices H and Q in the decomposition.
+  *
+  * The documentation for matrixH() contains an example of the typical use of
+  * this class.
+  *
+  * \sa class ComplexSchur, class Tridiagonalization, \ref QR_Module "QR Module"
+  */
+template<typename _MatrixType> class HessenbergDecomposition
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    enum {
+      Size = MatrixType::RowsAtCompileTime,
+      SizeMinusOne = Size == Dynamic ? Dynamic : Size - 1,
+      Options = MatrixType::Options,
+      MaxSize = MatrixType::MaxRowsAtCompileTime,
+      MaxSizeMinusOne = MaxSize == Dynamic ? Dynamic : MaxSize - 1
+    };
+
+    /** \brief Scalar type for matrices of type #MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    /** \brief Type for vector of Householder coefficients.
+      *
+      * This is column vector with entries of type #Scalar. The length of the
+      * vector is one less than the size of #MatrixType, if it is a fixed-side
+      * type.
+      */
+    typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType;
+
+    /** \brief Return type of matrixQ() */
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename CoeffVectorType::ConjugateReturnType>::type> HouseholderSequenceType;
+    
+    typedef internal::HessenbergDecompositionMatrixHReturnType<MatrixType> MatrixHReturnType;
+
+    /** \brief Default constructor; the decomposition will be computed later.
+      *
+      * \param [in] size  The size of the matrix whose Hessenberg decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().  The \p size parameter is only
+      * used as a hint. It is not an error to give a wrong \p size, but it may
+      * impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit HessenbergDecomposition(Index size = Size==Dynamic ? 2 : Size)
+      : m_matrix(size,size),
+        m_temp(size),
+        m_isInitialized(false)
+    {
+      if(size>1)
+        m_hCoeffs.resize(size-1);
+    }
+
+    /** \brief Constructor; computes Hessenberg decomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose Hessenberg decomposition is to be computed.
+      *
+      * This constructor calls compute() to compute the Hessenberg
+      * decomposition.
+      *
+      * \sa matrixH() for an example.
+      */
+    template<typename InputType>
+    explicit HessenbergDecomposition(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_temp(matrix.rows()),
+        m_isInitialized(false)
+    {
+      if(matrix.rows()<2)
+      {
+        m_isInitialized = true;
+        return;
+      }
+      m_hCoeffs.resize(matrix.rows()-1,1);
+      _compute(m_matrix, m_hCoeffs, m_temp);
+      m_isInitialized = true;
+    }
+
+    /** \brief Computes Hessenberg decomposition of given matrix.
+      *
+      * \param[in]  matrix  Square matrix whose Hessenberg decomposition is to be computed.
+      * \returns    Reference to \c *this
+      *
+      * The Hessenberg decomposition is computed by bringing the columns of the
+      * matrix successively in the required form using Householder reflections
+      * (see, e.g., Algorithm 7.4.2 in Golub \& Van Loan, <i>%Matrix
+      * Computations</i>). The cost is \f$ 10n^3/3 \f$ flops, where \f$ n \f$
+      * denotes the size of the given matrix.
+      *
+      * This method reuses of the allocated data in the HessenbergDecomposition
+      * object.
+      *
+      * Example: \include HessenbergDecomposition_compute.cpp
+      * Output: \verbinclude HessenbergDecomposition_compute.out
+      */
+    template<typename InputType>
+    HessenbergDecomposition& compute(const EigenBase<InputType>& matrix)
+    {
+      m_matrix = matrix.derived();
+      if(matrix.rows()<2)
+      {
+        m_isInitialized = true;
+        return *this;
+      }
+      m_hCoeffs.resize(matrix.rows()-1,1);
+      _compute(m_matrix, m_hCoeffs, m_temp);
+      m_isInitialized = true;
+      return *this;
+    }
+
+    /** \brief Returns the Householder coefficients.
+      *
+      * \returns a const reference to the vector of Householder coefficients
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * The Householder coefficients allow the reconstruction of the matrix
+      * \f$ Q \f$ in the Hessenberg decomposition from the packed data.
+      *
+      * \sa packedMatrix(), \ref Householder_Module "Householder module"
+      */
+    const CoeffVectorType& householderCoefficients() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return m_hCoeffs;
+    }
+
+    /** \brief Returns the internal representation of the decomposition
+      *
+      *	\returns a const reference to a matrix with the internal representation
+      *	         of the decomposition.
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * The returned matrix contains the following information:
+      *  - the upper part and lower sub-diagonal represent the Hessenberg matrix H
+      *  - the rest of the lower part contains the Householder vectors that, combined with
+      *    Householder coefficients returned by householderCoefficients(),
+      *    allows to reconstruct the matrix Q as
+      *       \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
+      *    Here, the matrices \f$ H_i \f$ are the Householder transformations
+      *       \f$ H_i = (I - h_i v_i v_i^T) \f$
+      *    where \f$ h_i \f$ is the \f$ i \f$th Householder coefficient and
+      *    \f$ v_i \f$ is the Householder vector defined by
+      *       \f$ v_i = [ 0, \ldots, 0, 1, M(i+2,i), \ldots, M(N-1,i) ]^T \f$
+      *    with M the matrix returned by this function.
+      *
+      * See LAPACK for further details on this packed storage.
+      *
+      * Example: \include HessenbergDecomposition_packedMatrix.cpp
+      * Output: \verbinclude HessenbergDecomposition_packedMatrix.out
+      *
+      * \sa householderCoefficients()
+      */
+    const MatrixType& packedMatrix() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return m_matrix;
+    }
+
+    /** \brief Reconstructs the orthogonal matrix Q in the decomposition
+      *
+      * \returns object representing the matrix Q
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * This function returns a light-weight object of template class
+      * HouseholderSequence. You can either apply it directly to a matrix or
+      * you can convert it to a matrix of type #MatrixType.
+      *
+      * \sa matrixH() for an example, class HouseholderSequence
+      */
+    HouseholderSequenceType matrixQ() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return HouseholderSequenceType(m_matrix, m_hCoeffs.conjugate())
+             .setLength(m_matrix.rows() - 1)
+             .setShift(1);
+    }
+
+    /** \brief Constructs the Hessenberg matrix H in the decomposition
+      *
+      * \returns expression object representing the matrix H
+      *
+      * \pre Either the constructor HessenbergDecomposition(const MatrixType&)
+      * or the member function compute(const MatrixType&) has been called
+      * before to compute the Hessenberg decomposition of a matrix.
+      *
+      * The object returned by this function constructs the Hessenberg matrix H
+      * when it is assigned to a matrix or otherwise evaluated. The matrix H is
+      * constructed from the packed matrix as returned by packedMatrix(): The
+      * upper part (including the subdiagonal) of the packed matrix contains
+      * the matrix H. It may sometimes be better to directly use the packed
+      * matrix instead of constructing the matrix H.
+      *
+      * Example: \include HessenbergDecomposition_matrixH.cpp
+      * Output: \verbinclude HessenbergDecomposition_matrixH.out
+      *
+      * \sa matrixQ(), packedMatrix()
+      */
+    MatrixHReturnType matrixH() const
+    {
+      eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
+      return MatrixHReturnType(*this);
+    }
+
+  private:
+
+    typedef Matrix<Scalar, 1, Size, int(Options) | int(RowMajor), 1, MaxSize> VectorType;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    static void _compute(MatrixType& matA, CoeffVectorType& hCoeffs, VectorType& temp);
+
+  protected:
+    MatrixType m_matrix;
+    CoeffVectorType m_hCoeffs;
+    VectorType m_temp;
+    bool m_isInitialized;
+};
+
+/** \internal
+  * Performs a tridiagonal decomposition of \a matA in place.
+  *
+  * \param matA the input selfadjoint matrix
+  * \param hCoeffs returned Householder coefficients
+  *
+  * The result is written in the lower triangular part of \a matA.
+  *
+  * Implemented from Golub's "%Matrix Computations", algorithm 8.3.1.
+  *
+  * \sa packedMatrix()
+  */
+template<typename MatrixType>
+void HessenbergDecomposition<MatrixType>::_compute(MatrixType& matA, CoeffVectorType& hCoeffs, VectorType& temp)
+{
+  eigen_assert(matA.rows()==matA.cols());
+  Index n = matA.rows();
+  temp.resize(n);
+  for (Index i = 0; i<n-1; ++i)
+  {
+    // let's consider the vector v = i-th column starting at position i+1
+    Index remainingSize = n-i-1;
+    RealScalar beta;
+    Scalar h;
+    matA.col(i).tail(remainingSize).makeHouseholderInPlace(h, beta);
+    matA.col(i).coeffRef(i+1) = beta;
+    hCoeffs.coeffRef(i) = h;
+
+    // Apply similarity transformation to remaining columns,
+    // i.e., compute A = H A H'
+
+    // A = H A
+    matA.bottomRightCorner(remainingSize, remainingSize)
+        .applyHouseholderOnTheLeft(matA.col(i).tail(remainingSize-1), h, &temp.coeffRef(0));
+
+    // A = A H'
+    matA.rightCols(remainingSize)
+        .applyHouseholderOnTheRight(matA.col(i).tail(remainingSize-1), numext::conj(h), &temp.coeffRef(0));
+  }
+}
+
+namespace internal {
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \brief Expression type for return value of HessenbergDecomposition::matrixH()
+  *
+  * \tparam MatrixType type of matrix in the Hessenberg decomposition
+  *
+  * Objects of this type represent the Hessenberg matrix in the Hessenberg
+  * decomposition of some matrix. The object holds a reference to the
+  * HessenbergDecomposition class until the it is assigned or evaluated for
+  * some other reason (the reference should remain valid during the life time
+  * of this object). This class is the return type of
+  * HessenbergDecomposition::matrixH(); there is probably no other use for this
+  * class.
+  */
+template<typename MatrixType> struct HessenbergDecompositionMatrixHReturnType
+: public ReturnByValue<HessenbergDecompositionMatrixHReturnType<MatrixType> >
+{
+  public:
+    /** \brief Constructor.
+      *
+      * \param[in] hess  Hessenberg decomposition
+      */
+    HessenbergDecompositionMatrixHReturnType(const HessenbergDecomposition<MatrixType>& hess) : m_hess(hess) { }
+
+    /** \brief Hessenberg matrix in decomposition.
+      *
+      * \param[out] result  Hessenberg matrix in decomposition \p hess which
+      *                     was passed to the constructor
+      */
+    template <typename ResultType>
+    inline void evalTo(ResultType& result) const
+    {
+      result = m_hess.packedMatrix();
+      Index n = result.rows();
+      if (n>2)
+        result.bottomLeftCorner(n-2, n-2).template triangularView<Lower>().setZero();
+    }
+
+    Index rows() const { return m_hess.packedMatrix().rows(); }
+    Index cols() const { return m_hess.packedMatrix().cols(); }
+
+  protected:
+    const HessenbergDecomposition<MatrixType>& m_hess;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_HESSENBERGDECOMPOSITION_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
new file mode 100644
index 00000000..66e5a3db
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
@@ -0,0 +1,158 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MATRIXBASEEIGENVALUES_H
+#define EIGEN_MATRIXBASEEIGENVALUES_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Derived, bool IsComplex>
+struct eigenvalues_selector
+{
+  // this is the implementation for the case IsComplex = true
+  static inline typename MatrixBase<Derived>::EigenvaluesReturnType const
+  run(const MatrixBase<Derived>& m)
+  {
+    typedef typename Derived::PlainObject PlainObject;
+    PlainObject m_eval(m);
+    return ComplexEigenSolver<PlainObject>(m_eval, false).eigenvalues();
+  }
+};
+
+template<typename Derived>
+struct eigenvalues_selector<Derived, false>
+{
+  static inline typename MatrixBase<Derived>::EigenvaluesReturnType const
+  run(const MatrixBase<Derived>& m)
+  {
+    typedef typename Derived::PlainObject PlainObject;
+    PlainObject m_eval(m);
+    return EigenSolver<PlainObject>(m_eval, false).eigenvalues();
+  }
+};
+
+} // end namespace internal
+
+/** \brief Computes the eigenvalues of a matrix 
+  * \returns Column vector containing the eigenvalues.
+  *
+  * \eigenvalues_module
+  * This function computes the eigenvalues with the help of the EigenSolver
+  * class (for real matrices) or the ComplexEigenSolver class (for complex
+  * matrices). 
+  *
+  * The eigenvalues are repeated according to their algebraic multiplicity,
+  * so there are as many eigenvalues as rows in the matrix.
+  *
+  * The SelfAdjointView class provides a better algorithm for selfadjoint
+  * matrices.
+  *
+  * Example: \include MatrixBase_eigenvalues.cpp
+  * Output: \verbinclude MatrixBase_eigenvalues.out
+  *
+  * \sa EigenSolver::eigenvalues(), ComplexEigenSolver::eigenvalues(),
+  *     SelfAdjointView::eigenvalues()
+  */
+template<typename Derived>
+inline typename MatrixBase<Derived>::EigenvaluesReturnType
+MatrixBase<Derived>::eigenvalues() const
+{
+  return internal::eigenvalues_selector<Derived, NumTraits<Scalar>::IsComplex>::run(derived());
+}
+
+/** \brief Computes the eigenvalues of a matrix
+  * \returns Column vector containing the eigenvalues.
+  *
+  * \eigenvalues_module
+  * This function computes the eigenvalues with the help of the
+  * SelfAdjointEigenSolver class.  The eigenvalues are repeated according to
+  * their algebraic multiplicity, so there are as many eigenvalues as rows in
+  * the matrix.
+  *
+  * Example: \include SelfAdjointView_eigenvalues.cpp
+  * Output: \verbinclude SelfAdjointView_eigenvalues.out
+  *
+  * \sa SelfAdjointEigenSolver::eigenvalues(), MatrixBase::eigenvalues()
+  */
+template<typename MatrixType, unsigned int UpLo> 
+EIGEN_DEVICE_FUNC inline typename SelfAdjointView<MatrixType, UpLo>::EigenvaluesReturnType
+SelfAdjointView<MatrixType, UpLo>::eigenvalues() const
+{
+  PlainObject thisAsMatrix(*this);
+  return SelfAdjointEigenSolver<PlainObject>(thisAsMatrix, false).eigenvalues();
+}
+
+
+
+/** \brief Computes the L2 operator norm
+  * \returns Operator norm of the matrix.
+  *
+  * \eigenvalues_module
+  * This function computes the L2 operator norm of a matrix, which is also
+  * known as the spectral norm. The norm of a matrix \f$ A \f$ is defined to be
+  * \f[ \|A\|_2 = \max_x \frac{\|Ax\|_2}{\|x\|_2} \f]
+  * where the maximum is over all vectors and the norm on the right is the
+  * Euclidean vector norm. The norm equals the largest singular value, which is
+  * the square root of the largest eigenvalue of the positive semi-definite
+  * matrix \f$ A^*A \f$.
+  *
+  * The current implementation uses the eigenvalues of \f$ A^*A \f$, as computed
+  * by SelfAdjointView::eigenvalues(), to compute the operator norm of a
+  * matrix.  The SelfAdjointView class provides a better algorithm for
+  * selfadjoint matrices.
+  *
+  * Example: \include MatrixBase_operatorNorm.cpp
+  * Output: \verbinclude MatrixBase_operatorNorm.out
+  *
+  * \sa SelfAdjointView::eigenvalues(), SelfAdjointView::operatorNorm()
+  */
+template<typename Derived>
+inline typename MatrixBase<Derived>::RealScalar
+MatrixBase<Derived>::operatorNorm() const
+{
+  using std::sqrt;
+  typename Derived::PlainObject m_eval(derived());
+  // FIXME if it is really guaranteed that the eigenvalues are already sorted,
+  // then we don't need to compute a maxCoeff() here, comparing the 1st and last ones is enough.
+  return sqrt((m_eval*m_eval.adjoint())
+                 .eval()
+		 .template selfadjointView<Lower>()
+		 .eigenvalues()
+		 .maxCoeff()
+		 );
+}
+
+/** \brief Computes the L2 operator norm
+  * \returns Operator norm of the matrix.
+  *
+  * \eigenvalues_module
+  * This function computes the L2 operator norm of a self-adjoint matrix. For a
+  * self-adjoint matrix, the operator norm is the largest eigenvalue.
+  *
+  * The current implementation uses the eigenvalues of the matrix, as computed
+  * by eigenvalues(), to compute the operator norm of the matrix.
+  *
+  * Example: \include SelfAdjointView_operatorNorm.cpp
+  * Output: \verbinclude SelfAdjointView_operatorNorm.out
+  *
+  * \sa eigenvalues(), MatrixBase::operatorNorm()
+  */
+template<typename MatrixType, unsigned int UpLo>
+EIGEN_DEVICE_FUNC inline typename SelfAdjointView<MatrixType, UpLo>::RealScalar
+SelfAdjointView<MatrixType, UpLo>::operatorNorm() const
+{
+  return eigenvalues().cwiseAbs().maxCoeff();
+}
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/RealQZ.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/RealQZ.h
new file mode 100644
index 00000000..50913018
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/RealQZ.h
@@ -0,0 +1,657 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Alexey Korepanov <kaikaikai@yandex.ru>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REAL_QZ_H
+#define EIGEN_REAL_QZ_H
+
+namespace Eigen {
+
+  /** \eigenvalues_module \ingroup Eigenvalues_Module
+   *
+   *
+   * \class RealQZ
+   *
+   * \brief Performs a real QZ decomposition of a pair of square matrices
+   *
+   * \tparam _MatrixType the type of the matrix of which we are computing the
+   * real QZ decomposition; this is expected to be an instantiation of the
+   * Matrix class template.
+   *
+   * Given a real square matrices A and B, this class computes the real QZ
+   * decomposition: \f$ A = Q S Z \f$, \f$ B = Q T Z \f$ where Q and Z are
+   * real orthogonal matrixes, T is upper-triangular matrix, and S is upper
+   * quasi-triangular matrix. An orthogonal matrix is a matrix whose
+   * inverse is equal to its transpose, \f$ U^{-1} = U^T \f$. A quasi-triangular
+   * matrix is a block-triangular matrix whose diagonal consists of 1-by-1
+   * blocks and 2-by-2 blocks where further reduction is impossible due to
+   * complex eigenvalues. 
+   *
+   * The eigenvalues of the pencil \f$ A - z B \f$ can be obtained from
+   * 1x1 and 2x2 blocks on the diagonals of S and T.
+   *
+   * Call the function compute() to compute the real QZ decomposition of a
+   * given pair of matrices. Alternatively, you can use the 
+   * RealQZ(const MatrixType& B, const MatrixType& B, bool computeQZ)
+   * constructor which computes the real QZ decomposition at construction
+   * time. Once the decomposition is computed, you can use the matrixS(),
+   * matrixT(), matrixQ() and matrixZ() functions to retrieve the matrices
+   * S, T, Q and Z in the decomposition. If computeQZ==false, some time
+   * is saved by not computing matrices Q and Z.
+   *
+   * Example: \include RealQZ_compute.cpp
+   * Output: \include RealQZ_compute.out
+   *
+   * \note The implementation is based on the algorithm in "Matrix Computations"
+   * by Gene H. Golub and Charles F. Van Loan, and a paper "An algorithm for
+   * generalized eigenvalue problems" by C.B.Moler and G.W.Stewart.
+   *
+   * \sa class RealSchur, class ComplexSchur, class EigenSolver, class ComplexEigenSolver
+   */
+
+  template<typename _MatrixType> class RealQZ
+  {
+    public:
+      typedef _MatrixType MatrixType;
+      enum {
+        RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+        ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+        Options = MatrixType::Options,
+        MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+        MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+      };
+      typedef typename MatrixType::Scalar Scalar;
+      typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
+      typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+      typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
+      typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+
+      /** \brief Default constructor.
+       *
+       * \param [in] size  Positive integer, size of the matrix whose QZ decomposition will be computed.
+       *
+       * The default constructor is useful in cases in which the user intends to
+       * perform decompositions via compute().  The \p size parameter is only
+       * used as a hint. It is not an error to give a wrong \p size, but it may
+       * impair performance.
+       *
+       * \sa compute() for an example.
+       */
+      explicit RealQZ(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime) :
+        m_S(size, size),
+        m_T(size, size),
+        m_Q(size, size),
+        m_Z(size, size),
+        m_workspace(size*2),
+        m_maxIters(400),
+        m_isInitialized(false),
+        m_computeQZ(true)
+      {}
+
+      /** \brief Constructor; computes real QZ decomposition of given matrices
+       * 
+       * \param[in]  A          Matrix A.
+       * \param[in]  B          Matrix B.
+       * \param[in]  computeQZ  If false, A and Z are not computed.
+       *
+       * This constructor calls compute() to compute the QZ decomposition.
+       */
+      RealQZ(const MatrixType& A, const MatrixType& B, bool computeQZ = true) :
+        m_S(A.rows(),A.cols()),
+        m_T(A.rows(),A.cols()),
+        m_Q(A.rows(),A.cols()),
+        m_Z(A.rows(),A.cols()),
+        m_workspace(A.rows()*2),
+        m_maxIters(400),
+        m_isInitialized(false),
+        m_computeQZ(true)
+      {
+        compute(A, B, computeQZ);
+      }
+
+      /** \brief Returns matrix Q in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix Q.
+       */
+      const MatrixType& matrixQ() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
+        return m_Q;
+      }
+
+      /** \brief Returns matrix Z in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix Z.
+       */
+      const MatrixType& matrixZ() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
+        return m_Z;
+      }
+
+      /** \brief Returns matrix S in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix S.
+       */
+      const MatrixType& matrixS() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_S;
+      }
+
+      /** \brief Returns matrix S in the QZ decomposition. 
+       *
+       * \returns A const reference to the matrix S.
+       */
+      const MatrixType& matrixT() const {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_T;
+      }
+
+      /** \brief Computes QZ decomposition of given matrix. 
+       * 
+       * \param[in]  A          Matrix A.
+       * \param[in]  B          Matrix B.
+       * \param[in]  computeQZ  If false, A and Z are not computed.
+       * \returns    Reference to \c *this
+       */
+      RealQZ& compute(const MatrixType& A, const MatrixType& B, bool computeQZ = true);
+
+      /** \brief Reports whether previous computation was successful.
+       *
+       * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+       */
+      ComputationInfo info() const
+      {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_info;
+      }
+
+      /** \brief Returns number of performed QR-like iterations.
+      */
+      Index iterations() const
+      {
+        eigen_assert(m_isInitialized && "RealQZ is not initialized.");
+        return m_global_iter;
+      }
+
+      /** Sets the maximal number of iterations allowed to converge to one eigenvalue
+       * or decouple the problem.
+      */
+      RealQZ& setMaxIterations(Index maxIters)
+      {
+        m_maxIters = maxIters;
+        return *this;
+      }
+
+    private:
+
+      MatrixType m_S, m_T, m_Q, m_Z;
+      Matrix<Scalar,Dynamic,1> m_workspace;
+      ComputationInfo m_info;
+      Index m_maxIters;
+      bool m_isInitialized;
+      bool m_computeQZ;
+      Scalar m_normOfT, m_normOfS;
+      Index m_global_iter;
+
+      typedef Matrix<Scalar,3,1> Vector3s;
+      typedef Matrix<Scalar,2,1> Vector2s;
+      typedef Matrix<Scalar,2,2> Matrix2s;
+      typedef JacobiRotation<Scalar> JRs;
+
+      void hessenbergTriangular();
+      void computeNorms();
+      Index findSmallSubdiagEntry(Index iu);
+      Index findSmallDiagEntry(Index f, Index l);
+      void splitOffTwoRows(Index i);
+      void pushDownZero(Index z, Index f, Index l);
+      void step(Index f, Index l, Index iter);
+
+  }; // RealQZ
+
+  /** \internal Reduces S and T to upper Hessenberg - triangular form */
+  template<typename MatrixType>
+    void RealQZ<MatrixType>::hessenbergTriangular()
+    {
+
+      const Index dim = m_S.cols();
+
+      // perform QR decomposition of T, overwrite T with R, save Q
+      HouseholderQR<MatrixType> qrT(m_T);
+      m_T = qrT.matrixQR();
+      m_T.template triangularView<StrictlyLower>().setZero();
+      m_Q = qrT.householderQ();
+      // overwrite S with Q* S
+      m_S.applyOnTheLeft(m_Q.adjoint());
+      // init Z as Identity
+      if (m_computeQZ)
+        m_Z = MatrixType::Identity(dim,dim);
+      // reduce S to upper Hessenberg with Givens rotations
+      for (Index j=0; j<=dim-3; j++) {
+        for (Index i=dim-1; i>=j+2; i--) {
+          JRs G;
+          // kill S(i,j)
+          if(m_S.coeff(i,j) != 0)
+          {
+            G.makeGivens(m_S.coeff(i-1,j), m_S.coeff(i,j), &m_S.coeffRef(i-1, j));
+            m_S.coeffRef(i,j) = Scalar(0.0);
+            m_S.rightCols(dim-j-1).applyOnTheLeft(i-1,i,G.adjoint());
+            m_T.rightCols(dim-i+1).applyOnTheLeft(i-1,i,G.adjoint());
+            // update Q
+            if (m_computeQZ)
+              m_Q.applyOnTheRight(i-1,i,G);
+          }
+          // kill T(i,i-1)
+          if(m_T.coeff(i,i-1)!=Scalar(0))
+          {
+            G.makeGivens(m_T.coeff(i,i), m_T.coeff(i,i-1), &m_T.coeffRef(i,i));
+            m_T.coeffRef(i,i-1) = Scalar(0.0);
+            m_S.applyOnTheRight(i,i-1,G);
+            m_T.topRows(i).applyOnTheRight(i,i-1,G);
+            // update Z
+            if (m_computeQZ)
+              m_Z.applyOnTheLeft(i,i-1,G.adjoint());
+          }
+        }
+      }
+    }
+
+  /** \internal Computes vector L1 norms of S and T when in Hessenberg-Triangular form already */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::computeNorms()
+    {
+      const Index size = m_S.cols();
+      m_normOfS = Scalar(0.0);
+      m_normOfT = Scalar(0.0);
+      for (Index j = 0; j < size; ++j)
+      {
+        m_normOfS += m_S.col(j).segment(0, (std::min)(size,j+2)).cwiseAbs().sum();
+        m_normOfT += m_T.row(j).segment(j, size - j).cwiseAbs().sum();
+      }
+    }
+
+
+  /** \internal Look for single small sub-diagonal element S(res, res-1) and return res (or 0) */
+  template<typename MatrixType>
+    inline Index RealQZ<MatrixType>::findSmallSubdiagEntry(Index iu)
+    {
+      using std::abs;
+      Index res = iu;
+      while (res > 0)
+      {
+        Scalar s = abs(m_S.coeff(res-1,res-1)) + abs(m_S.coeff(res,res));
+        if (s == Scalar(0.0))
+          s = m_normOfS;
+        if (abs(m_S.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s)
+          break;
+        res--;
+      }
+      return res;
+    }
+
+  /** \internal Look for single small diagonal element T(res, res) for res between f and l, and return res (or f-1)  */
+  template<typename MatrixType>
+    inline Index RealQZ<MatrixType>::findSmallDiagEntry(Index f, Index l)
+    {
+      using std::abs;
+      Index res = l;
+      while (res >= f) {
+        if (abs(m_T.coeff(res,res)) <= NumTraits<Scalar>::epsilon() * m_normOfT)
+          break;
+        res--;
+      }
+      return res;
+    }
+
+  /** \internal decouple 2x2 diagonal block in rows i, i+1 if eigenvalues are real */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::splitOffTwoRows(Index i)
+    {
+      using std::abs;
+      using std::sqrt;
+      const Index dim=m_S.cols();
+      if (abs(m_S.coeff(i+1,i))==Scalar(0))
+        return;
+      Index j = findSmallDiagEntry(i,i+1);
+      if (j==i-1)
+      {
+        // block of (S T^{-1})
+        Matrix2s STi = m_T.template block<2,2>(i,i).template triangularView<Upper>().
+          template solve<OnTheRight>(m_S.template block<2,2>(i,i));
+        Scalar p = Scalar(0.5)*(STi(0,0)-STi(1,1));
+        Scalar q = p*p + STi(1,0)*STi(0,1);
+        if (q>=0) {
+          Scalar z = sqrt(q);
+          // one QR-like iteration for ABi - lambda I
+          // is enough - when we know exact eigenvalue in advance,
+          // convergence is immediate
+          JRs G;
+          if (p>=0)
+            G.makeGivens(p + z, STi(1,0));
+          else
+            G.makeGivens(p - z, STi(1,0));
+          m_S.rightCols(dim-i).applyOnTheLeft(i,i+1,G.adjoint());
+          m_T.rightCols(dim-i).applyOnTheLeft(i,i+1,G.adjoint());
+          // update Q
+          if (m_computeQZ)
+            m_Q.applyOnTheRight(i,i+1,G);
+
+          G.makeGivens(m_T.coeff(i+1,i+1), m_T.coeff(i+1,i));
+          m_S.topRows(i+2).applyOnTheRight(i+1,i,G);
+          m_T.topRows(i+2).applyOnTheRight(i+1,i,G);
+          // update Z
+          if (m_computeQZ)
+            m_Z.applyOnTheLeft(i+1,i,G.adjoint());
+
+          m_S.coeffRef(i+1,i) = Scalar(0.0);
+          m_T.coeffRef(i+1,i) = Scalar(0.0);
+        }
+      }
+      else
+      {
+        pushDownZero(j,i,i+1);
+      }
+    }
+
+  /** \internal use zero in T(z,z) to zero S(l,l-1), working in block f..l */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::pushDownZero(Index z, Index f, Index l)
+    {
+      JRs G;
+      const Index dim = m_S.cols();
+      for (Index zz=z; zz<l; zz++)
+      {
+        // push 0 down
+        Index firstColS = zz>f ? (zz-1) : zz;
+        G.makeGivens(m_T.coeff(zz, zz+1), m_T.coeff(zz+1, zz+1));
+        m_S.rightCols(dim-firstColS).applyOnTheLeft(zz,zz+1,G.adjoint());
+        m_T.rightCols(dim-zz).applyOnTheLeft(zz,zz+1,G.adjoint());
+        m_T.coeffRef(zz+1,zz+1) = Scalar(0.0);
+        // update Q
+        if (m_computeQZ)
+          m_Q.applyOnTheRight(zz,zz+1,G);
+        // kill S(zz+1, zz-1)
+        if (zz>f)
+        {
+          G.makeGivens(m_S.coeff(zz+1, zz), m_S.coeff(zz+1,zz-1));
+          m_S.topRows(zz+2).applyOnTheRight(zz, zz-1,G);
+          m_T.topRows(zz+1).applyOnTheRight(zz, zz-1,G);
+          m_S.coeffRef(zz+1,zz-1) = Scalar(0.0);
+          // update Z
+          if (m_computeQZ)
+            m_Z.applyOnTheLeft(zz,zz-1,G.adjoint());
+        }
+      }
+      // finally kill S(l,l-1)
+      G.makeGivens(m_S.coeff(l,l), m_S.coeff(l,l-1));
+      m_S.applyOnTheRight(l,l-1,G);
+      m_T.applyOnTheRight(l,l-1,G);
+      m_S.coeffRef(l,l-1)=Scalar(0.0);
+      // update Z
+      if (m_computeQZ)
+        m_Z.applyOnTheLeft(l,l-1,G.adjoint());
+    }
+
+  /** \internal QR-like iterative step for block f..l */
+  template<typename MatrixType>
+    inline void RealQZ<MatrixType>::step(Index f, Index l, Index iter)
+    {
+      using std::abs;
+      const Index dim = m_S.cols();
+
+      // x, y, z
+      Scalar x, y, z;
+      if (iter==10)
+      {
+        // Wilkinson ad hoc shift
+        const Scalar
+          a11=m_S.coeff(f+0,f+0), a12=m_S.coeff(f+0,f+1),
+          a21=m_S.coeff(f+1,f+0), a22=m_S.coeff(f+1,f+1), a32=m_S.coeff(f+2,f+1),
+          b12=m_T.coeff(f+0,f+1),
+          b11i=Scalar(1.0)/m_T.coeff(f+0,f+0),
+          b22i=Scalar(1.0)/m_T.coeff(f+1,f+1),
+          a87=m_S.coeff(l-1,l-2),
+          a98=m_S.coeff(l-0,l-1),
+          b77i=Scalar(1.0)/m_T.coeff(l-2,l-2),
+          b88i=Scalar(1.0)/m_T.coeff(l-1,l-1);
+        Scalar ss = abs(a87*b77i) + abs(a98*b88i),
+               lpl = Scalar(1.5)*ss,
+               ll = ss*ss;
+        x = ll + a11*a11*b11i*b11i - lpl*a11*b11i + a12*a21*b11i*b22i
+          - a11*a21*b12*b11i*b11i*b22i;
+        y = a11*a21*b11i*b11i - lpl*a21*b11i + a21*a22*b11i*b22i 
+          - a21*a21*b12*b11i*b11i*b22i;
+        z = a21*a32*b11i*b22i;
+      }
+      else if (iter==16)
+      {
+        // another exceptional shift
+        x = m_S.coeff(f,f)/m_T.coeff(f,f)-m_S.coeff(l,l)/m_T.coeff(l,l) + m_S.coeff(l,l-1)*m_T.coeff(l-1,l) /
+          (m_T.coeff(l-1,l-1)*m_T.coeff(l,l));
+        y = m_S.coeff(f+1,f)/m_T.coeff(f,f);
+        z = 0;
+      }
+      else if (iter>23 && !(iter%8))
+      {
+        // extremely exceptional shift
+        x = internal::random<Scalar>(-1.0,1.0);
+        y = internal::random<Scalar>(-1.0,1.0);
+        z = internal::random<Scalar>(-1.0,1.0);
+      }
+      else
+      {
+        // Compute the shifts: (x,y,z,0...) = (AB^-1 - l1 I) (AB^-1 - l2 I) e1
+        // where l1 and l2 are the eigenvalues of the 2x2 matrix C = U V^-1 where
+        // U and V are 2x2 bottom right sub matrices of A and B. Thus:
+        //  = AB^-1AB^-1 + l1 l2 I - (l1+l2)(AB^-1)
+        //  = AB^-1AB^-1 + det(M) - tr(M)(AB^-1)
+        // Since we are only interested in having x, y, z with a correct ratio, we have:
+        const Scalar
+          a11 = m_S.coeff(f,f),     a12 = m_S.coeff(f,f+1),
+          a21 = m_S.coeff(f+1,f),   a22 = m_S.coeff(f+1,f+1),
+                                    a32 = m_S.coeff(f+2,f+1),
+
+          a88 = m_S.coeff(l-1,l-1), a89 = m_S.coeff(l-1,l),
+          a98 = m_S.coeff(l,l-1),   a99 = m_S.coeff(l,l),
+
+          b11 = m_T.coeff(f,f),     b12 = m_T.coeff(f,f+1),
+                                    b22 = m_T.coeff(f+1,f+1),
+
+          b88 = m_T.coeff(l-1,l-1), b89 = m_T.coeff(l-1,l),
+                                    b99 = m_T.coeff(l,l);
+
+        x = ( (a88/b88 - a11/b11)*(a99/b99 - a11/b11) - (a89/b99)*(a98/b88) + (a98/b88)*(b89/b99)*(a11/b11) ) * (b11/a21)
+          + a12/b22 - (a11/b11)*(b12/b22);
+        y = (a22/b22-a11/b11) - (a21/b11)*(b12/b22) - (a88/b88-a11/b11) - (a99/b99-a11/b11) + (a98/b88)*(b89/b99);
+        z = a32/b22;
+      }
+
+      JRs G;
+
+      for (Index k=f; k<=l-2; k++)
+      {
+        // variables for Householder reflections
+        Vector2s essential2;
+        Scalar tau, beta;
+
+        Vector3s hr(x,y,z);
+
+        // Q_k to annihilate S(k+1,k-1) and S(k+2,k-1)
+        hr.makeHouseholderInPlace(tau, beta);
+        essential2 = hr.template bottomRows<2>();
+        Index fc=(std::max)(k-1,Index(0));  // first col to update
+        m_S.template middleRows<3>(k).rightCols(dim-fc).applyHouseholderOnTheLeft(essential2, tau, m_workspace.data());
+        m_T.template middleRows<3>(k).rightCols(dim-fc).applyHouseholderOnTheLeft(essential2, tau, m_workspace.data());
+        if (m_computeQZ)
+          m_Q.template middleCols<3>(k).applyHouseholderOnTheRight(essential2, tau, m_workspace.data());
+        if (k>f)
+          m_S.coeffRef(k+2,k-1) = m_S.coeffRef(k+1,k-1) = Scalar(0.0);
+
+        // Z_{k1} to annihilate T(k+2,k+1) and T(k+2,k)
+        hr << m_T.coeff(k+2,k+2),m_T.coeff(k+2,k),m_T.coeff(k+2,k+1);
+        hr.makeHouseholderInPlace(tau, beta);
+        essential2 = hr.template bottomRows<2>();
+        {
+          Index lr = (std::min)(k+4,dim); // last row to update
+          Map<Matrix<Scalar,Dynamic,1> > tmp(m_workspace.data(),lr);
+          // S
+          tmp = m_S.template middleCols<2>(k).topRows(lr) * essential2;
+          tmp += m_S.col(k+2).head(lr);
+          m_S.col(k+2).head(lr) -= tau*tmp;
+          m_S.template middleCols<2>(k).topRows(lr) -= (tau*tmp) * essential2.adjoint();
+          // T
+          tmp = m_T.template middleCols<2>(k).topRows(lr) * essential2;
+          tmp += m_T.col(k+2).head(lr);
+          m_T.col(k+2).head(lr) -= tau*tmp;
+          m_T.template middleCols<2>(k).topRows(lr) -= (tau*tmp) * essential2.adjoint();
+        }
+        if (m_computeQZ)
+        {
+          // Z
+          Map<Matrix<Scalar,1,Dynamic> > tmp(m_workspace.data(),dim);
+          tmp = essential2.adjoint()*(m_Z.template middleRows<2>(k));
+          tmp += m_Z.row(k+2);
+          m_Z.row(k+2) -= tau*tmp;
+          m_Z.template middleRows<2>(k) -= essential2 * (tau*tmp);
+        }
+        m_T.coeffRef(k+2,k) = m_T.coeffRef(k+2,k+1) = Scalar(0.0);
+
+        // Z_{k2} to annihilate T(k+1,k)
+        G.makeGivens(m_T.coeff(k+1,k+1), m_T.coeff(k+1,k));
+        m_S.applyOnTheRight(k+1,k,G);
+        m_T.applyOnTheRight(k+1,k,G);
+        // update Z
+        if (m_computeQZ)
+          m_Z.applyOnTheLeft(k+1,k,G.adjoint());
+        m_T.coeffRef(k+1,k) = Scalar(0.0);
+
+        // update x,y,z
+        x = m_S.coeff(k+1,k);
+        y = m_S.coeff(k+2,k);
+        if (k < l-2)
+          z = m_S.coeff(k+3,k);
+      } // loop over k
+
+      // Q_{n-1} to annihilate y = S(l,l-2)
+      G.makeGivens(x,y);
+      m_S.applyOnTheLeft(l-1,l,G.adjoint());
+      m_T.applyOnTheLeft(l-1,l,G.adjoint());
+      if (m_computeQZ)
+        m_Q.applyOnTheRight(l-1,l,G);
+      m_S.coeffRef(l,l-2) = Scalar(0.0);
+
+      // Z_{n-1} to annihilate T(l,l-1)
+      G.makeGivens(m_T.coeff(l,l),m_T.coeff(l,l-1));
+      m_S.applyOnTheRight(l,l-1,G);
+      m_T.applyOnTheRight(l,l-1,G);
+      if (m_computeQZ)
+        m_Z.applyOnTheLeft(l,l-1,G.adjoint());
+      m_T.coeffRef(l,l-1) = Scalar(0.0);
+    }
+
+  template<typename MatrixType>
+    RealQZ<MatrixType>& RealQZ<MatrixType>::compute(const MatrixType& A_in, const MatrixType& B_in, bool computeQZ)
+    {
+
+      const Index dim = A_in.cols();
+
+      eigen_assert (A_in.rows()==dim && A_in.cols()==dim 
+          && B_in.rows()==dim && B_in.cols()==dim 
+          && "Need square matrices of the same dimension");
+
+      m_isInitialized = true;
+      m_computeQZ = computeQZ;
+      m_S = A_in; m_T = B_in;
+      m_workspace.resize(dim*2);
+      m_global_iter = 0;
+
+      // entrance point: hessenberg triangular decomposition
+      hessenbergTriangular();
+      // compute L1 vector norms of T, S into m_normOfS, m_normOfT
+      computeNorms();
+
+      Index l = dim-1, 
+            f, 
+            local_iter = 0;
+
+      while (l>0 && local_iter<m_maxIters)
+      {
+        f = findSmallSubdiagEntry(l);
+        // now rows and columns f..l (including) decouple from the rest of the problem
+        if (f>0) m_S.coeffRef(f,f-1) = Scalar(0.0);
+        if (f == l) // One root found
+        {
+          l--;
+          local_iter = 0;
+        }
+        else if (f == l-1) // Two roots found
+        {
+          splitOffTwoRows(f);
+          l -= 2;
+          local_iter = 0;
+        }
+        else // No convergence yet
+        {
+          // if there's zero on diagonal of T, we can isolate an eigenvalue with Givens rotations
+          Index z = findSmallDiagEntry(f,l);
+          if (z>=f)
+          {
+            // zero found
+            pushDownZero(z,f,l);
+          }
+          else
+          {
+            // We are sure now that S.block(f,f, l-f+1,l-f+1) is underuced upper-Hessenberg 
+            // and T.block(f,f, l-f+1,l-f+1) is invertible uper-triangular, which allows to
+            // apply a QR-like iteration to rows and columns f..l.
+            step(f,l, local_iter);
+            local_iter++;
+            m_global_iter++;
+          }
+        }
+      }
+      // check if we converged before reaching iterations limit
+      m_info = (local_iter<m_maxIters) ? Success : NoConvergence;
+
+      // For each non triangular 2x2 diagonal block of S,
+      //    reduce the respective 2x2 diagonal block of T to positive diagonal form using 2x2 SVD.
+      // This step is not mandatory for QZ, but it does help further extraction of eigenvalues/eigenvectors,
+      // and is in par with Lapack/Matlab QZ.
+      if(m_info==Success)
+      {
+        for(Index i=0; i<dim-1; ++i)
+        {
+          if(m_S.coeff(i+1, i) != Scalar(0))
+          {
+            JacobiRotation<Scalar> j_left, j_right;
+            internal::real_2x2_jacobi_svd(m_T, i, i+1, &j_left, &j_right);
+
+            // Apply resulting Jacobi rotations
+            m_S.applyOnTheLeft(i,i+1,j_left);
+            m_S.applyOnTheRight(i,i+1,j_right);
+            m_T.applyOnTheLeft(i,i+1,j_left);
+            m_T.applyOnTheRight(i,i+1,j_right);
+            m_T(i+1,i) = m_T(i,i+1) = Scalar(0);
+
+            if(m_computeQZ) {
+              m_Q.applyOnTheRight(i,i+1,j_left.transpose());
+              m_Z.applyOnTheLeft(i,i+1,j_right.transpose());
+            }
+
+            i++;
+          }
+        }
+      }
+
+      return *this;
+    } // end compute
+
+} // end namespace Eigen
+
+#endif //EIGEN_REAL_QZ
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/RealSchur.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/RealSchur.h
new file mode 100644
index 00000000..7304ef34
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/RealSchur.h
@@ -0,0 +1,558 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REAL_SCHUR_H
+#define EIGEN_REAL_SCHUR_H
+
+#include "./HessenbergDecomposition.h"
+
+namespace Eigen { 
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class RealSchur
+  *
+  * \brief Performs a real Schur decomposition of a square matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * real Schur decomposition; this is expected to be an instantiation of the
+  * Matrix class template.
+  *
+  * Given a real square matrix A, this class computes the real Schur
+  * decomposition: \f$ A = U T U^T \f$ where U is a real orthogonal matrix and
+  * T is a real quasi-triangular matrix. An orthogonal matrix is a matrix whose
+  * inverse is equal to its transpose, \f$ U^{-1} = U^T \f$. A quasi-triangular
+  * matrix is a block-triangular matrix whose diagonal consists of 1-by-1
+  * blocks and 2-by-2 blocks with complex eigenvalues. The eigenvalues of the
+  * blocks on the diagonal of T are the same as the eigenvalues of the matrix
+  * A, and thus the real Schur decomposition is used in EigenSolver to compute
+  * the eigendecomposition of a matrix.
+  *
+  * Call the function compute() to compute the real Schur decomposition of a
+  * given matrix. Alternatively, you can use the RealSchur(const MatrixType&, bool)
+  * constructor which computes the real Schur decomposition at construction
+  * time. Once the decomposition is computed, you can use the matrixU() and
+  * matrixT() functions to retrieve the matrices U and T in the decomposition.
+  *
+  * The documentation of RealSchur(const MatrixType&, bool) contains an example
+  * of the typical use of this class.
+  *
+  * \note The implementation is adapted from
+  * <a href="http://math.nist.gov/javanumerics/jama/">JAMA</a> (public domain).
+  * Their code is based on EISPACK.
+  *
+  * \sa class ComplexSchur, class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType> class RealSchur
+{
+  public:
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
+    typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+
+    /** \brief Default constructor.
+      *
+      * \param [in] size  Positive integer, size of the matrix whose Schur decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().  The \p size parameter is only
+      * used as a hint. It is not an error to give a wrong \p size, but it may
+      * impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit RealSchur(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime)
+            : m_matT(size, size),
+              m_matU(size, size),
+              m_workspaceVector(size),
+              m_hess(size),
+              m_isInitialized(false),
+              m_matUisUptodate(false),
+              m_maxIters(-1)
+    { }
+
+    /** \brief Constructor; computes real Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix    Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+      *
+      * This constructor calls compute() to compute the Schur decomposition.
+      *
+      * Example: \include RealSchur_RealSchur_MatrixType.cpp
+      * Output: \verbinclude RealSchur_RealSchur_MatrixType.out
+      */
+    template<typename InputType>
+    explicit RealSchur(const EigenBase<InputType>& matrix, bool computeU = true)
+            : m_matT(matrix.rows(),matrix.cols()),
+              m_matU(matrix.rows(),matrix.cols()),
+              m_workspaceVector(matrix.rows()),
+              m_hess(matrix.rows()),
+              m_isInitialized(false),
+              m_matUisUptodate(false),
+              m_maxIters(-1)
+    {
+      compute(matrix.derived(), computeU);
+    }
+
+    /** \brief Returns the orthogonal matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix U.
+      *
+      * \pre Either the constructor RealSchur(const MatrixType&, bool) or the
+      * member function compute(const MatrixType&, bool) has been called before
+      * to compute the Schur decomposition of a matrix, and \p computeU was set
+      * to true (the default value).
+      *
+      * \sa RealSchur(const MatrixType&, bool) for an example
+      */
+    const MatrixType& matrixU() const
+    {
+      eigen_assert(m_isInitialized && "RealSchur is not initialized.");
+      eigen_assert(m_matUisUptodate && "The matrix U has not been computed during the RealSchur decomposition.");
+      return m_matU;
+    }
+
+    /** \brief Returns the quasi-triangular matrix in the Schur decomposition. 
+      *
+      * \returns A const reference to the matrix T.
+      *
+      * \pre Either the constructor RealSchur(const MatrixType&, bool) or the
+      * member function compute(const MatrixType&, bool) has been called before
+      * to compute the Schur decomposition of a matrix.
+      *
+      * \sa RealSchur(const MatrixType&, bool) for an example
+      */
+    const MatrixType& matrixT() const
+    {
+      eigen_assert(m_isInitialized && "RealSchur is not initialized.");
+      return m_matT;
+    }
+  
+    /** \brief Computes Schur decomposition of given matrix. 
+      * 
+      * \param[in]  matrix    Square matrix whose Schur decomposition is to be computed.
+      * \param[in]  computeU  If true, both T and U are computed; if false, only T is computed.
+      * \returns    Reference to \c *this
+      *
+      * The Schur decomposition is computed by first reducing the matrix to
+      * Hessenberg form using the class HessenbergDecomposition. The Hessenberg
+      * matrix is then reduced to triangular form by performing Francis QR
+      * iterations with implicit double shift. The cost of computing the Schur
+      * decomposition depends on the number of iterations; as a rough guide, it
+      * may be taken to be \f$25n^3\f$ flops if \a computeU is true and
+      * \f$10n^3\f$ flops if \a computeU is false.
+      *
+      * Example: \include RealSchur_compute.cpp
+      * Output: \verbinclude RealSchur_compute.out
+      *
+      * \sa compute(const MatrixType&, bool, Index)
+      */
+    template<typename InputType>
+    RealSchur& compute(const EigenBase<InputType>& matrix, bool computeU = true);
+
+    /** \brief Computes Schur decomposition of a Hessenberg matrix H = Z T Z^T
+     *  \param[in] matrixH Matrix in Hessenberg form H
+     *  \param[in] matrixQ orthogonal matrix Q that transform a matrix A to H : A = Q H Q^T
+     *  \param computeU Computes the matriX U of the Schur vectors
+     * \return Reference to \c *this
+     * 
+     *  This routine assumes that the matrix is already reduced in Hessenberg form matrixH
+     *  using either the class HessenbergDecomposition or another mean. 
+     *  It computes the upper quasi-triangular matrix T of the Schur decomposition of H
+     *  When computeU is true, this routine computes the matrix U such that 
+     *  A = U T U^T =  (QZ) T (QZ)^T = Q H Q^T where A is the initial matrix
+     * 
+     * NOTE Q is referenced if computeU is true; so, if the initial orthogonal matrix
+     * is not available, the user should give an identity matrix (Q.setIdentity())
+     * 
+     * \sa compute(const MatrixType&, bool)
+     */
+    template<typename HessMatrixType, typename OrthMatrixType>
+    RealSchur& computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ,  bool computeU);
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "RealSchur is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Sets the maximum number of iterations allowed. 
+      *
+      * If not specified by the user, the maximum number of iterations is m_maxIterationsPerRow times the size
+      * of the matrix.
+      */
+    RealSchur& setMaxIterations(Index maxIters)
+    {
+      m_maxIters = maxIters;
+      return *this;
+    }
+
+    /** \brief Returns the maximum number of iterations. */
+    Index getMaxIterations()
+    {
+      return m_maxIters;
+    }
+
+    /** \brief Maximum number of iterations per row.
+      *
+      * If not otherwise specified, the maximum number of iterations is this number times the size of the
+      * matrix. It is currently set to 40.
+      */
+    static const int m_maxIterationsPerRow = 40;
+
+  private:
+    
+    MatrixType m_matT;
+    MatrixType m_matU;
+    ColumnVectorType m_workspaceVector;
+    HessenbergDecomposition<MatrixType> m_hess;
+    ComputationInfo m_info;
+    bool m_isInitialized;
+    bool m_matUisUptodate;
+    Index m_maxIters;
+
+    typedef Matrix<Scalar,3,1> Vector3s;
+
+    Scalar computeNormOfT();
+    Index findSmallSubdiagEntry(Index iu, const Scalar& considerAsZero);
+    void splitOffTwoRows(Index iu, bool computeU, const Scalar& exshift);
+    void computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo);
+    void initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im, Vector3s& firstHouseholderVector);
+    void performFrancisQRStep(Index il, Index im, Index iu, bool computeU, const Vector3s& firstHouseholderVector, Scalar* workspace);
+};
+
+
+template<typename MatrixType>
+template<typename InputType>
+RealSchur<MatrixType>& RealSchur<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeU)
+{
+  const Scalar considerAsZero = (std::numeric_limits<Scalar>::min)();
+
+  eigen_assert(matrix.cols() == matrix.rows());
+  Index maxIters = m_maxIters;
+  if (maxIters == -1)
+    maxIters = m_maxIterationsPerRow * matrix.rows();
+
+  Scalar scale = matrix.derived().cwiseAbs().maxCoeff();
+  if(scale<considerAsZero)
+  {
+    m_matT.setZero(matrix.rows(),matrix.cols());
+    if(computeU)
+      m_matU.setIdentity(matrix.rows(),matrix.cols());
+    m_info = Success;
+    m_isInitialized = true;
+    m_matUisUptodate = computeU;
+    return *this;
+  }
+
+  // Step 1. Reduce to Hessenberg form
+  m_hess.compute(matrix.derived()/scale);
+
+  // Step 2. Reduce to real Schur form
+  // Note: we copy m_hess.matrixQ() into m_matU here and not in computeFromHessenberg
+  //       to be able to pass our working-space buffer for the Householder to Dense evaluation.
+  m_workspaceVector.resize(matrix.cols());
+  if(computeU)
+    m_hess.matrixQ().evalTo(m_matU, m_workspaceVector);
+  computeFromHessenberg(m_hess.matrixH(), m_matU, computeU);
+
+  m_matT *= scale;
+  
+  return *this;
+}
+template<typename MatrixType>
+template<typename HessMatrixType, typename OrthMatrixType>
+RealSchur<MatrixType>& RealSchur<MatrixType>::computeFromHessenberg(const HessMatrixType& matrixH, const OrthMatrixType& matrixQ,  bool computeU)
+{
+  using std::abs;
+
+  m_matT = matrixH;
+  m_workspaceVector.resize(m_matT.cols());
+  if(computeU && !internal::is_same_dense(m_matU,matrixQ))
+    m_matU = matrixQ;
+  
+  Index maxIters = m_maxIters;
+  if (maxIters == -1)
+    maxIters = m_maxIterationsPerRow * matrixH.rows();
+  Scalar* workspace = &m_workspaceVector.coeffRef(0);
+
+  // The matrix m_matT is divided in three parts. 
+  // Rows 0,...,il-1 are decoupled from the rest because m_matT(il,il-1) is zero. 
+  // Rows il,...,iu is the part we are working on (the active window).
+  // Rows iu+1,...,end are already brought in triangular form.
+  Index iu = m_matT.cols() - 1;
+  Index iter = 0;      // iteration count for current eigenvalue
+  Index totalIter = 0; // iteration count for whole matrix
+  Scalar exshift(0);   // sum of exceptional shifts
+  Scalar norm = computeNormOfT();
+  // sub-diagonal entries smaller than considerAsZero will be treated as zero.
+  // We use eps^2 to enable more precision in small eigenvalues.
+  Scalar considerAsZero = numext::maxi<Scalar>( norm * numext::abs2(NumTraits<Scalar>::epsilon()),
+                                                (std::numeric_limits<Scalar>::min)() );
+
+  if(norm!=Scalar(0))
+  {
+    while (iu >= 0)
+    {
+      Index il = findSmallSubdiagEntry(iu,considerAsZero);
+
+      // Check for convergence
+      if (il == iu) // One root found
+      {
+        m_matT.coeffRef(iu,iu) = m_matT.coeff(iu,iu) + exshift;
+        if (iu > 0)
+          m_matT.coeffRef(iu, iu-1) = Scalar(0);
+        iu--;
+        iter = 0;
+      }
+      else if (il == iu-1) // Two roots found
+      {
+        splitOffTwoRows(iu, computeU, exshift);
+        iu -= 2;
+        iter = 0;
+      }
+      else // No convergence yet
+      {
+        // The firstHouseholderVector vector has to be initialized to something to get rid of a silly GCC warning (-O1 -Wall -DNDEBUG )
+        Vector3s firstHouseholderVector = Vector3s::Zero(), shiftInfo;
+        computeShift(iu, iter, exshift, shiftInfo);
+        iter = iter + 1;
+        totalIter = totalIter + 1;
+        if (totalIter > maxIters) break;
+        Index im;
+        initFrancisQRStep(il, iu, shiftInfo, im, firstHouseholderVector);
+        performFrancisQRStep(il, im, iu, computeU, firstHouseholderVector, workspace);
+      }
+    }
+  }
+  if(totalIter <= maxIters)
+    m_info = Success;
+  else
+    m_info = NoConvergence;
+
+  m_isInitialized = true;
+  m_matUisUptodate = computeU;
+  return *this;
+}
+
+/** \internal Computes and returns vector L1 norm of T */
+template<typename MatrixType>
+inline typename MatrixType::Scalar RealSchur<MatrixType>::computeNormOfT()
+{
+  const Index size = m_matT.cols();
+  // FIXME to be efficient the following would requires a triangular reduxion code
+  // Scalar norm = m_matT.upper().cwiseAbs().sum() 
+  //               + m_matT.bottomLeftCorner(size-1,size-1).diagonal().cwiseAbs().sum();
+  Scalar norm(0);
+  for (Index j = 0; j < size; ++j)
+    norm += m_matT.col(j).segment(0, (std::min)(size,j+2)).cwiseAbs().sum();
+  return norm;
+}
+
+/** \internal Look for single small sub-diagonal element and returns its index */
+template<typename MatrixType>
+inline Index RealSchur<MatrixType>::findSmallSubdiagEntry(Index iu, const Scalar& considerAsZero)
+{
+  using std::abs;
+  Index res = iu;
+  while (res > 0)
+  {
+    Scalar s = abs(m_matT.coeff(res-1,res-1)) + abs(m_matT.coeff(res,res));
+
+    s = numext::maxi<Scalar>(s * NumTraits<Scalar>::epsilon(), considerAsZero);
+    
+    if (abs(m_matT.coeff(res,res-1)) <= s)
+      break;
+    res--;
+  }
+  return res;
+}
+
+/** \internal Update T given that rows iu-1 and iu decouple from the rest. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::splitOffTwoRows(Index iu, bool computeU, const Scalar& exshift)
+{
+  using std::sqrt;
+  using std::abs;
+  const Index size = m_matT.cols();
+
+  // The eigenvalues of the 2x2 matrix [a b; c d] are 
+  // trace +/- sqrt(discr/4) where discr = tr^2 - 4*det, tr = a + d, det = ad - bc
+  Scalar p = Scalar(0.5) * (m_matT.coeff(iu-1,iu-1) - m_matT.coeff(iu,iu));
+  Scalar q = p * p + m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu);   // q = tr^2 / 4 - det = discr/4
+  m_matT.coeffRef(iu,iu) += exshift;
+  m_matT.coeffRef(iu-1,iu-1) += exshift;
+
+  if (q >= Scalar(0)) // Two real eigenvalues
+  {
+    Scalar z = sqrt(abs(q));
+    JacobiRotation<Scalar> rot;
+    if (p >= Scalar(0))
+      rot.makeGivens(p + z, m_matT.coeff(iu, iu-1));
+    else
+      rot.makeGivens(p - z, m_matT.coeff(iu, iu-1));
+
+    m_matT.rightCols(size-iu+1).applyOnTheLeft(iu-1, iu, rot.adjoint());
+    m_matT.topRows(iu+1).applyOnTheRight(iu-1, iu, rot);
+    m_matT.coeffRef(iu, iu-1) = Scalar(0); 
+    if (computeU)
+      m_matU.applyOnTheRight(iu-1, iu, rot);
+  }
+
+  if (iu > 1) 
+    m_matT.coeffRef(iu-1, iu-2) = Scalar(0);
+}
+
+/** \internal Form shift in shiftInfo, and update exshift if an exceptional shift is performed. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo)
+{
+  using std::sqrt;
+  using std::abs;
+  shiftInfo.coeffRef(0) = m_matT.coeff(iu,iu);
+  shiftInfo.coeffRef(1) = m_matT.coeff(iu-1,iu-1);
+  shiftInfo.coeffRef(2) = m_matT.coeff(iu,iu-1) * m_matT.coeff(iu-1,iu);
+
+  // Wilkinson's original ad hoc shift
+  if (iter == 10)
+  {
+    exshift += shiftInfo.coeff(0);
+    for (Index i = 0; i <= iu; ++i)
+      m_matT.coeffRef(i,i) -= shiftInfo.coeff(0);
+    Scalar s = abs(m_matT.coeff(iu,iu-1)) + abs(m_matT.coeff(iu-1,iu-2));
+    shiftInfo.coeffRef(0) = Scalar(0.75) * s;
+    shiftInfo.coeffRef(1) = Scalar(0.75) * s;
+    shiftInfo.coeffRef(2) = Scalar(-0.4375) * s * s;
+  }
+
+  // MATLAB's new ad hoc shift
+  if (iter == 30)
+  {
+    Scalar s = (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
+    s = s * s + shiftInfo.coeff(2);
+    if (s > Scalar(0))
+    {
+      s = sqrt(s);
+      if (shiftInfo.coeff(1) < shiftInfo.coeff(0))
+        s = -s;
+      s = s + (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
+      s = shiftInfo.coeff(0) - shiftInfo.coeff(2) / s;
+      exshift += s;
+      for (Index i = 0; i <= iu; ++i)
+        m_matT.coeffRef(i,i) -= s;
+      shiftInfo.setConstant(Scalar(0.964));
+    }
+  }
+}
+
+/** \internal Compute index im at which Francis QR step starts and the first Householder vector. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im, Vector3s& firstHouseholderVector)
+{
+  using std::abs;
+  Vector3s& v = firstHouseholderVector; // alias to save typing
+
+  for (im = iu-2; im >= il; --im)
+  {
+    const Scalar Tmm = m_matT.coeff(im,im);
+    const Scalar r = shiftInfo.coeff(0) - Tmm;
+    const Scalar s = shiftInfo.coeff(1) - Tmm;
+    v.coeffRef(0) = (r * s - shiftInfo.coeff(2)) / m_matT.coeff(im+1,im) + m_matT.coeff(im,im+1);
+    v.coeffRef(1) = m_matT.coeff(im+1,im+1) - Tmm - r - s;
+    v.coeffRef(2) = m_matT.coeff(im+2,im+1);
+    if (im == il) {
+      break;
+    }
+    const Scalar lhs = m_matT.coeff(im,im-1) * (abs(v.coeff(1)) + abs(v.coeff(2)));
+    const Scalar rhs = v.coeff(0) * (abs(m_matT.coeff(im-1,im-1)) + abs(Tmm) + abs(m_matT.coeff(im+1,im+1)));
+    if (abs(lhs) < NumTraits<Scalar>::epsilon() * rhs)
+      break;
+  }
+}
+
+/** \internal Perform a Francis QR step involving rows il:iu and columns im:iu. */
+template<typename MatrixType>
+inline void RealSchur<MatrixType>::performFrancisQRStep(Index il, Index im, Index iu, bool computeU, const Vector3s& firstHouseholderVector, Scalar* workspace)
+{
+  eigen_assert(im >= il);
+  eigen_assert(im <= iu-2);
+
+  const Index size = m_matT.cols();
+
+  for (Index k = im; k <= iu-2; ++k)
+  {
+    bool firstIteration = (k == im);
+
+    Vector3s v;
+    if (firstIteration)
+      v = firstHouseholderVector;
+    else
+      v = m_matT.template block<3,1>(k,k-1);
+
+    Scalar tau, beta;
+    Matrix<Scalar, 2, 1> ess;
+    v.makeHouseholder(ess, tau, beta);
+    
+    if (beta != Scalar(0)) // if v is not zero
+    {
+      if (firstIteration && k > il)
+        m_matT.coeffRef(k,k-1) = -m_matT.coeff(k,k-1);
+      else if (!firstIteration)
+        m_matT.coeffRef(k,k-1) = beta;
+
+      // These Householder transformations form the O(n^3) part of the algorithm
+      m_matT.block(k, k, 3, size-k).applyHouseholderOnTheLeft(ess, tau, workspace);
+      m_matT.block(0, k, (std::min)(iu,k+3) + 1, 3).applyHouseholderOnTheRight(ess, tau, workspace);
+      if (computeU)
+        m_matU.block(0, k, size, 3).applyHouseholderOnTheRight(ess, tau, workspace);
+    }
+  }
+
+  Matrix<Scalar, 2, 1> v = m_matT.template block<2,1>(iu-1, iu-2);
+  Scalar tau, beta;
+  Matrix<Scalar, 1, 1> ess;
+  v.makeHouseholder(ess, tau, beta);
+
+  if (beta != Scalar(0)) // if v is not zero
+  {
+    m_matT.coeffRef(iu-1, iu-2) = beta;
+    m_matT.block(iu-1, iu-1, 2, size-iu+1).applyHouseholderOnTheLeft(ess, tau, workspace);
+    m_matT.block(0, iu-1, iu+1, 2).applyHouseholderOnTheRight(ess, tau, workspace);
+    if (computeU)
+      m_matU.block(0, iu-1, size, 2).applyHouseholderOnTheRight(ess, tau, workspace);
+  }
+
+  // clean up pollution due to round-off errors
+  for (Index i = im+2; i <= iu; ++i)
+  {
+    m_matT.coeffRef(i,i-2) = Scalar(0);
+    if (i > im+2)
+      m_matT.coeffRef(i,i-3) = Scalar(0);
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_REAL_SCHUR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
new file mode 100644
index 00000000..2c225171
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
@@ -0,0 +1,77 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Real Schur needed to real unsymmetrical eigenvalues/eigenvectors.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_REAL_SCHUR_LAPACKE_H
+#define EIGEN_REAL_SCHUR_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_SCHUR_REAL(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX, LAPACKE_PREFIX_U, EIGCOLROW, LAPACKE_COLROW) \
+template<> template<typename InputType> inline \
+RealSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >& \
+RealSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >::compute(const EigenBase<InputType>& matrix, bool computeU) \
+{ \
+  eigen_assert(matrix.cols() == matrix.rows()); \
+\
+  lapack_int n = internal::convert_index<lapack_int>(matrix.cols()), sdim, info; \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  char jobvs, sort='N'; \
+  LAPACK_##LAPACKE_PREFIX_U##_SELECT2 select = 0; \
+  jobvs = (computeU) ? 'V' : 'N'; \
+  m_matU.resize(n, n); \
+  lapack_int ldvs  = internal::convert_index<lapack_int>(m_matU.outerStride()); \
+  m_matT = matrix; \
+  lapack_int lda = internal::convert_index<lapack_int>(m_matT.outerStride()); \
+  Matrix<EIGTYPE, Dynamic, Dynamic> wr, wi; \
+  wr.resize(n, 1); wi.resize(n, 1); \
+  info = LAPACKE_##LAPACKE_PREFIX##gees( matrix_order, jobvs, sort, select, n, (LAPACKE_TYPE*)m_matT.data(), lda, &sdim, (LAPACKE_TYPE*)wr.data(), (LAPACKE_TYPE*)wi.data(), (LAPACKE_TYPE*)m_matU.data(), ldvs ); \
+  if(info == 0) \
+    m_info = Success; \
+  else \
+    m_info = NoConvergence; \
+\
+  m_isInitialized = true; \
+  m_matUisUptodate = computeU; \
+  return *this; \
+\
+}
+
+EIGEN_LAPACKE_SCHUR_REAL(double,   double, d, D, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_REAL(float,    float,  s, S, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SCHUR_REAL(double,   double, d, D, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SCHUR_REAL(float,    float,  s, S, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_REAL_SCHUR_LAPACKE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
new file mode 100644
index 00000000..14692365
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
@@ -0,0 +1,904 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SELFADJOINTEIGENSOLVER_H
+#define EIGEN_SELFADJOINTEIGENSOLVER_H
+
+#include "./Tridiagonalization.h"
+
+namespace Eigen { 
+
+template<typename _MatrixType>
+class GeneralizedSelfAdjointEigenSolver;
+
+namespace internal {
+template<typename SolverType,int Size,bool IsComplex> struct direct_selfadjoint_eigenvalues;
+
+template<typename MatrixType, typename DiagType, typename SubDiagType>
+EIGEN_DEVICE_FUNC
+ComputationInfo computeFromTridiagonal_impl(DiagType& diag, SubDiagType& subdiag, const Index maxIterations, bool computeEigenvectors, MatrixType& eivec);
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class SelfAdjointEigenSolver
+  *
+  * \brief Computes eigenvalues and eigenvectors of selfadjoint matrices
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * eigendecomposition; this is expected to be an instantiation of the Matrix
+  * class template.
+  *
+  * A matrix \f$ A \f$ is selfadjoint if it equals its adjoint. For real
+  * matrices, this means that the matrix is symmetric: it equals its
+  * transpose. This class computes the eigenvalues and eigenvectors of a
+  * selfadjoint matrix. These are the scalars \f$ \lambda \f$ and vectors
+  * \f$ v \f$ such that \f$ Av = \lambda v \f$.  The eigenvalues of a
+  * selfadjoint matrix are always real. If \f$ D \f$ is a diagonal matrix with
+  * the eigenvalues on the diagonal, and \f$ V \f$ is a matrix with the
+  * eigenvectors as its columns, then \f$ A = V D V^{-1} \f$. This is called the
+  * eigendecomposition.
+  *
+  * For a selfadjoint matrix, \f$ V \f$ is unitary, meaning its inverse is equal
+  * to its adjoint, \f$ V^{-1} = V^{\dagger} \f$. If \f$ A \f$ is real, then
+  * \f$ V \f$ is also real and therefore orthogonal, meaning its inverse is
+  * equal to its transpose, \f$ V^{-1} = V^T \f$.
+  *
+  * The algorithm exploits the fact that the matrix is selfadjoint, making it
+  * faster and more accurate than the general purpose eigenvalue algorithms
+  * implemented in EigenSolver and ComplexEigenSolver.
+  *
+  * Only the \b lower \b triangular \b part of the input matrix is referenced.
+  *
+  * Call the function compute() to compute the eigenvalues and eigenvectors of
+  * a given matrix. Alternatively, you can use the
+  * SelfAdjointEigenSolver(const MatrixType&, int) constructor which computes
+  * the eigenvalues and eigenvectors at construction time. Once the eigenvalue
+  * and eigenvectors are computed, they can be retrieved with the eigenvalues()
+  * and eigenvectors() functions.
+  *
+  * The documentation for SelfAdjointEigenSolver(const MatrixType&, int)
+  * contains an example of the typical use of this class.
+  *
+  * To solve the \em generalized eigenvalue problem \f$ Av = \lambda Bv \f$ and
+  * the likes, see the class GeneralizedSelfAdjointEigenSolver.
+  *
+  * \sa MatrixBase::eigenvalues(), class EigenSolver, class ComplexEigenSolver
+  */
+template<typename _MatrixType> class SelfAdjointEigenSolver
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    enum {
+      Size = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      Options = MatrixType::Options,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+    /** \brief Scalar type for matrices of type \p _MatrixType. */
+    typedef typename MatrixType::Scalar Scalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    
+    typedef Matrix<Scalar,Size,Size,ColMajor,MaxColsAtCompileTime,MaxColsAtCompileTime> EigenvectorsType;
+
+    /** \brief Real scalar type for \p _MatrixType.
+      *
+      * This is just \c Scalar if #Scalar is real (e.g., \c float or
+      * \c double), and the type of the real part of \c Scalar if #Scalar is
+      * complex.
+      */
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    
+    friend struct internal::direct_selfadjoint_eigenvalues<SelfAdjointEigenSolver,Size,NumTraits<Scalar>::IsComplex>;
+
+    /** \brief Type for vector of eigenvalues as returned by eigenvalues().
+      *
+      * This is a column vector with entries of type #RealScalar.
+      * The length of the vector is the size of \p _MatrixType.
+      */
+    typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVectorType;
+    typedef Tridiagonalization<MatrixType> TridiagonalizationType;
+    typedef typename TridiagonalizationType::SubDiagonalType SubDiagonalType;
+
+    /** \brief Default constructor for fixed-size matrices.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute(). This constructor
+      * can only be used if \p _MatrixType is a fixed-size matrix; use
+      * SelfAdjointEigenSolver(Index) for dynamic-size matrices.
+      *
+      * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver.out
+      */
+    EIGEN_DEVICE_FUNC
+    SelfAdjointEigenSolver()
+        : m_eivec(),
+          m_eivalues(),
+          m_subdiag(),
+          m_hcoeffs(),
+          m_info(InvalidInput),
+          m_isInitialized(false),
+          m_eigenvectorsOk(false)
+    { }
+
+    /** \brief Constructor, pre-allocates memory for dynamic-size matrices.
+      *
+      * \param [in]  size  Positive integer, size of the matrix whose
+      * eigenvalues and eigenvectors will be computed.
+      *
+      * This constructor is useful for dynamic-size matrices, when the user
+      * intends to perform decompositions via compute(). The \p size
+      * parameter is only used as a hint. It is not an error to give a wrong
+      * \p size, but it may impair performance.
+      *
+      * \sa compute() for an example
+      */
+    EIGEN_DEVICE_FUNC
+    explicit SelfAdjointEigenSolver(Index size)
+        : m_eivec(size, size),
+          m_eivalues(size),
+          m_subdiag(size > 1 ? size - 1 : 1),
+          m_hcoeffs(size > 1 ? size - 1 : 1),
+          m_isInitialized(false),
+          m_eigenvectorsOk(false)
+    {}
+
+    /** \brief Constructor; computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose eigendecomposition is to
+      *    be computed. Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+      *
+      * This constructor calls compute(const MatrixType&, int) to compute the
+      * eigenvalues of the matrix \p matrix. The eigenvectors are computed if
+      * \p options equals #ComputeEigenvectors.
+      *
+      * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.out
+      *
+      * \sa compute(const MatrixType&, int)
+      */
+    template<typename InputType>
+    EIGEN_DEVICE_FUNC
+    explicit SelfAdjointEigenSolver(const EigenBase<InputType>& matrix, int options = ComputeEigenvectors)
+      : m_eivec(matrix.rows(), matrix.cols()),
+        m_eivalues(matrix.cols()),
+        m_subdiag(matrix.rows() > 1 ? matrix.rows() - 1 : 1),
+        m_hcoeffs(matrix.cols() > 1 ? matrix.cols() - 1 : 1),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false)
+    {
+      compute(matrix.derived(), options);
+    }
+
+    /** \brief Computes eigendecomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose eigendecomposition is to
+      *    be computed. Only the lower triangular part of the matrix is referenced.
+      * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+      * \returns    Reference to \c *this
+      *
+      * This function computes the eigenvalues of \p matrix.  The eigenvalues()
+      * function can be used to retrieve them.  If \p options equals #ComputeEigenvectors,
+      * then the eigenvectors are also computed and can be retrieved by
+      * calling eigenvectors().
+      *
+      * This implementation uses a symmetric QR algorithm. The matrix is first
+      * reduced to tridiagonal form using the Tridiagonalization class. The
+      * tridiagonal matrix is then brought to diagonal form with implicit
+      * symmetric QR steps with Wilkinson shift. Details can be found in
+      * Section 8.3 of Golub \& Van Loan, <i>%Matrix Computations</i>.
+      *
+      * The cost of the computation is about \f$ 9n^3 \f$ if the eigenvectors
+      * are required and \f$ 4n^3/3 \f$ if they are not required.
+      *
+      * This method reuses the memory in the SelfAdjointEigenSolver object that
+      * was allocated when the object was constructed, if the size of the
+      * matrix does not change.
+      *
+      * Example: \include SelfAdjointEigenSolver_compute_MatrixType.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_compute_MatrixType.out
+      *
+      * \sa SelfAdjointEigenSolver(const MatrixType&, int)
+      */
+    template<typename InputType>
+    EIGEN_DEVICE_FUNC
+    SelfAdjointEigenSolver& compute(const EigenBase<InputType>& matrix, int options = ComputeEigenvectors);
+    
+    /** \brief Computes eigendecomposition of given matrix using a closed-form algorithm
+      *
+      * This is a variant of compute(const MatrixType&, int options) which
+      * directly solves the underlying polynomial equation.
+      * 
+      * Currently only 2x2 and 3x3 matrices for which the sizes are known at compile time are supported (e.g., Matrix3d).
+      * 
+      * This method is usually significantly faster than the QR iterative algorithm
+      * but it might also be less accurate. It is also worth noting that
+      * for 3x3 matrices it involves trigonometric operations which are
+      * not necessarily available for all scalar types.
+      * 
+      * For the 3x3 case, we observed the following worst case relative error regarding the eigenvalues:
+      *   - double: 1e-8
+      *   - float:  1e-3
+      *
+      * \sa compute(const MatrixType&, int options)
+      */
+    EIGEN_DEVICE_FUNC
+    SelfAdjointEigenSolver& computeDirect(const MatrixType& matrix, int options = ComputeEigenvectors);
+
+    /**
+      *\brief Computes the eigen decomposition from a tridiagonal symmetric matrix
+      *
+      * \param[in] diag The vector containing the diagonal of the matrix.
+      * \param[in] subdiag The subdiagonal of the matrix.
+      * \param[in] options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+      * \returns Reference to \c *this
+      *
+      * This function assumes that the matrix has been reduced to tridiagonal form.
+      *
+      * \sa compute(const MatrixType&, int) for more information
+      */
+    SelfAdjointEigenSolver& computeFromTridiagonal(const RealVectorType& diag, const SubDiagonalType& subdiag , int options=ComputeEigenvectors);
+
+    /** \brief Returns the eigenvectors of given matrix.
+      *
+      * \returns  A const reference to the matrix whose columns are the eigenvectors.
+      *
+      * \pre The eigenvectors have been computed before.
+      *
+      * Column \f$ k \f$ of the returned matrix is an eigenvector corresponding
+      * to eigenvalue number \f$ k \f$ as returned by eigenvalues().  The
+      * eigenvectors are normalized to have (Euclidean) norm equal to one. If
+      * this object was used to solve the eigenproblem for the selfadjoint
+      * matrix \f$ A \f$, then the matrix returned by this function is the
+      * matrix \f$ V \f$ in the eigendecomposition \f$ A = V D V^{-1} \f$.
+      *
+      * For a selfadjoint matrix, \f$ V \f$ is unitary, meaning its inverse is equal
+      * to its adjoint, \f$ V^{-1} = V^{\dagger} \f$. If \f$ A \f$ is real, then
+      * \f$ V \f$ is also real and therefore orthogonal, meaning its inverse is
+      * equal to its transpose, \f$ V^{-1} = V^T \f$.
+      *
+      * Example: \include SelfAdjointEigenSolver_eigenvectors.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_eigenvectors.out
+      *
+      * \sa eigenvalues()
+      */
+    EIGEN_DEVICE_FUNC
+    const EigenvectorsType& eigenvectors() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec;
+    }
+
+    /** \brief Returns the eigenvalues of given matrix.
+      *
+      * \returns A const reference to the column vector containing the eigenvalues.
+      *
+      * \pre The eigenvalues have been computed before.
+      *
+      * The eigenvalues are repeated according to their algebraic multiplicity,
+      * so there are as many eigenvalues as rows in the matrix. The eigenvalues
+      * are sorted in increasing order.
+      *
+      * Example: \include SelfAdjointEigenSolver_eigenvalues.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_eigenvalues.out
+      *
+      * \sa eigenvectors(), MatrixBase::eigenvalues()
+      */
+    EIGEN_DEVICE_FUNC
+    const RealVectorType& eigenvalues() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      return m_eivalues;
+    }
+
+    /** \brief Computes the positive-definite square root of the matrix.
+      *
+      * \returns the positive-definite square root of the matrix
+      *
+      * \pre The eigenvalues and eigenvectors of a positive-definite matrix
+      * have been computed before.
+      *
+      * The square root of a positive-definite matrix \f$ A \f$ is the
+      * positive-definite matrix whose square equals \f$ A \f$. This function
+      * uses the eigendecomposition \f$ A = V D V^{-1} \f$ to compute the
+      * square root as \f$ A^{1/2} = V D^{1/2} V^{-1} \f$.
+      *
+      * Example: \include SelfAdjointEigenSolver_operatorSqrt.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_operatorSqrt.out
+      *
+      * \sa operatorInverseSqrt(), <a href="unsupported/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
+      */
+    EIGEN_DEVICE_FUNC
+    MatrixType operatorSqrt() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec * m_eivalues.cwiseSqrt().asDiagonal() * m_eivec.adjoint();
+    }
+
+    /** \brief Computes the inverse square root of the matrix.
+      *
+      * \returns the inverse positive-definite square root of the matrix
+      *
+      * \pre The eigenvalues and eigenvectors of a positive-definite matrix
+      * have been computed before.
+      *
+      * This function uses the eigendecomposition \f$ A = V D V^{-1} \f$ to
+      * compute the inverse square root as \f$ V D^{-1/2} V^{-1} \f$. This is
+      * cheaper than first computing the square root with operatorSqrt() and
+      * then its inverse with MatrixBase::inverse().
+      *
+      * Example: \include SelfAdjointEigenSolver_operatorInverseSqrt.cpp
+      * Output: \verbinclude SelfAdjointEigenSolver_operatorInverseSqrt.out
+      *
+      * \sa operatorSqrt(), MatrixBase::inverse(), <a href="unsupported/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
+      */
+    EIGEN_DEVICE_FUNC
+    MatrixType operatorInverseSqrt() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+      return m_eivec * m_eivalues.cwiseInverse().cwiseSqrt().asDiagonal() * m_eivec.adjoint();
+    }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+      */
+    EIGEN_DEVICE_FUNC
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Maximum number of iterations.
+      *
+      * The algorithm terminates if it does not converge within m_maxIterations * n iterations, where n
+      * denotes the size of the matrix. This value is currently set to 30 (copied from LAPACK).
+      */
+    static const int m_maxIterations = 30;
+
+  protected:
+    static EIGEN_DEVICE_FUNC
+    void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+    
+    EigenvectorsType m_eivec;
+    RealVectorType m_eivalues;
+    typename TridiagonalizationType::SubDiagonalType m_subdiag;
+    typename TridiagonalizationType::CoeffVectorType m_hcoeffs;
+    ComputationInfo m_info;
+    bool m_isInitialized;
+    bool m_eigenvectorsOk;
+};
+
+namespace internal {
+/** \internal
+  *
+  * \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  * Performs a QR step on a tridiagonal symmetric matrix represented as a
+  * pair of two vectors \a diag and \a subdiag.
+  *
+  * \param diag the diagonal part of the input selfadjoint tridiagonal matrix
+  * \param subdiag the sub-diagonal part of the input selfadjoint tridiagonal matrix
+  * \param start starting index of the submatrix to work on
+  * \param end last+1 index of the submatrix to work on
+  * \param matrixQ pointer to the column-major matrix holding the eigenvectors, can be 0
+  * \param n size of the input matrix
+  *
+  * For compilation efficiency reasons, this procedure does not use eigen expression
+  * for its arguments.
+  *
+  * Implemented from Golub's "Matrix Computations", algorithm 8.3.2:
+  * "implicit symmetric QR step with Wilkinson shift"
+  */
+template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC
+static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n);
+}
+
+template<typename MatrixType>
+template<typename InputType>
+EIGEN_DEVICE_FUNC
+SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
+::compute(const EigenBase<InputType>& a_matrix, int options)
+{
+  check_template_parameters();
+  
+  const InputType &matrix(a_matrix.derived());
+  
+  EIGEN_USING_STD(abs);
+  eigen_assert(matrix.cols() == matrix.rows());
+  eigen_assert((options&~(EigVecMask|GenEigMask))==0
+          && (options&EigVecMask)!=EigVecMask
+          && "invalid option parameter");
+  bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+  Index n = matrix.cols();
+  m_eivalues.resize(n,1);
+
+  if(n==1)
+  {
+    m_eivec = matrix;
+    m_eivalues.coeffRef(0,0) = numext::real(m_eivec.coeff(0,0));
+    if(computeEigenvectors)
+      m_eivec.setOnes(n,n);
+    m_info = Success;
+    m_isInitialized = true;
+    m_eigenvectorsOk = computeEigenvectors;
+    return *this;
+  }
+
+  // declare some aliases
+  RealVectorType& diag = m_eivalues;
+  EigenvectorsType& mat = m_eivec;
+
+  // map the matrix coefficients to [-1:1] to avoid over- and underflow.
+  mat = matrix.template triangularView<Lower>();
+  RealScalar scale = mat.cwiseAbs().maxCoeff();
+  if(scale==RealScalar(0)) scale = RealScalar(1);
+  mat.template triangularView<Lower>() /= scale;
+  m_subdiag.resize(n-1);
+  m_hcoeffs.resize(n-1);
+  internal::tridiagonalization_inplace(mat, diag, m_subdiag, m_hcoeffs, computeEigenvectors);
+
+  m_info = internal::computeFromTridiagonal_impl(diag, m_subdiag, m_maxIterations, computeEigenvectors, m_eivec);
+  
+  // scale back the eigen values
+  m_eivalues *= scale;
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+  return *this;
+}
+
+template<typename MatrixType>
+SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
+::computeFromTridiagonal(const RealVectorType& diag, const SubDiagonalType& subdiag , int options)
+{
+  //TODO : Add an option to scale the values beforehand
+  bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+
+  m_eivalues = diag;
+  m_subdiag = subdiag;
+  if (computeEigenvectors)
+  {
+    m_eivec.setIdentity(diag.size(), diag.size());
+  }
+  m_info = internal::computeFromTridiagonal_impl(m_eivalues, m_subdiag, m_maxIterations, computeEigenvectors, m_eivec);
+
+  m_isInitialized = true;
+  m_eigenvectorsOk = computeEigenvectors;
+  return *this;
+}
+
+namespace internal {
+/**
+  * \internal
+  * \brief Compute the eigendecomposition from a tridiagonal matrix
+  *
+  * \param[in,out] diag : On input, the diagonal of the matrix, on output the eigenvalues
+  * \param[in,out] subdiag : The subdiagonal part of the matrix (entries are modified during the decomposition)
+  * \param[in] maxIterations : the maximum number of iterations
+  * \param[in] computeEigenvectors : whether the eigenvectors have to be computed or not
+  * \param[out] eivec : The matrix to store the eigenvectors if computeEigenvectors==true. Must be allocated on input.
+  * \returns \c Success or \c NoConvergence
+  */
+template<typename MatrixType, typename DiagType, typename SubDiagType>
+EIGEN_DEVICE_FUNC
+ComputationInfo computeFromTridiagonal_impl(DiagType& diag, SubDiagType& subdiag, const Index maxIterations, bool computeEigenvectors, MatrixType& eivec)
+{
+  ComputationInfo info;
+  typedef typename MatrixType::Scalar Scalar;
+
+  Index n = diag.size();
+  Index end = n-1;
+  Index start = 0;
+  Index iter = 0; // total number of iterations
+  
+  typedef typename DiagType::RealScalar RealScalar;
+  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar precision_inv = RealScalar(1)/NumTraits<RealScalar>::epsilon();
+  while (end>0)
+  {
+    for (Index i = start; i<end; ++i) {
+      if (numext::abs(subdiag[i]) < considerAsZero) {
+        subdiag[i] = RealScalar(0);
+      } else {
+        // abs(subdiag[i]) <= epsilon * sqrt(abs(diag[i]) + abs(diag[i+1]))
+        // Scaled to prevent underflows.
+        const RealScalar scaled_subdiag = precision_inv * subdiag[i];
+        if (scaled_subdiag * scaled_subdiag <= (numext::abs(diag[i])+numext::abs(diag[i+1]))) {
+          subdiag[i] = RealScalar(0);
+        }
+      }
+    }
+
+    // find the largest unreduced block at the end of the matrix.
+    while (end>0 && subdiag[end-1]==RealScalar(0))
+    {
+      end--;
+    }
+    if (end<=0)
+      break;
+
+    // if we spent too many iterations, we give up
+    iter++;
+    if(iter > maxIterations * n) break;
+
+    start = end - 1;
+    while (start>0 && subdiag[start-1]!=0)
+      start--;
+
+    internal::tridiagonal_qr_step<MatrixType::Flags&RowMajorBit ? RowMajor : ColMajor>(diag.data(), subdiag.data(), start, end, computeEigenvectors ? eivec.data() : (Scalar*)0, n);
+  }
+  if (iter <= maxIterations * n)
+    info = Success;
+  else
+    info = NoConvergence;
+
+  // Sort eigenvalues and corresponding vectors.
+  // TODO make the sort optional ?
+  // TODO use a better sort algorithm !!
+  if (info == Success)
+  {
+    for (Index i = 0; i < n-1; ++i)
+    {
+      Index k;
+      diag.segment(i,n-i).minCoeff(&k);
+      if (k > 0)
+      {
+        numext::swap(diag[i], diag[k+i]);
+        if(computeEigenvectors)
+          eivec.col(i).swap(eivec.col(k+i));
+      }
+    }
+  }
+  return info;
+}
+  
+template<typename SolverType,int Size,bool IsComplex> struct direct_selfadjoint_eigenvalues
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(SolverType& eig, const typename SolverType::MatrixType& A, int options)
+  { eig.compute(A,options); }
+};
+
+template<typename SolverType> struct direct_selfadjoint_eigenvalues<SolverType,3,false>
+{
+  typedef typename SolverType::MatrixType MatrixType;
+  typedef typename SolverType::RealVectorType VectorType;
+  typedef typename SolverType::Scalar Scalar;
+  typedef typename SolverType::EigenvectorsType EigenvectorsType;
+  
+
+  /** \internal
+   * Computes the roots of the characteristic polynomial of \a m.
+   * For numerical stability m.trace() should be near zero and to avoid over- or underflow m should be normalized.
+   */
+  EIGEN_DEVICE_FUNC
+  static inline void computeRoots(const MatrixType& m, VectorType& roots)
+  {
+    EIGEN_USING_STD(sqrt)
+    EIGEN_USING_STD(atan2)
+    EIGEN_USING_STD(cos)
+    EIGEN_USING_STD(sin)
+    const Scalar s_inv3 = Scalar(1)/Scalar(3);
+    const Scalar s_sqrt3 = sqrt(Scalar(3));
+
+    // The characteristic equation is x^3 - c2*x^2 + c1*x - c0 = 0.  The
+    // eigenvalues are the roots to this equation, all guaranteed to be
+    // real-valued, because the matrix is symmetric.
+    Scalar c0 = m(0,0)*m(1,1)*m(2,2) + Scalar(2)*m(1,0)*m(2,0)*m(2,1) - m(0,0)*m(2,1)*m(2,1) - m(1,1)*m(2,0)*m(2,0) - m(2,2)*m(1,0)*m(1,0);
+    Scalar c1 = m(0,0)*m(1,1) - m(1,0)*m(1,0) + m(0,0)*m(2,2) - m(2,0)*m(2,0) + m(1,1)*m(2,2) - m(2,1)*m(2,1);
+    Scalar c2 = m(0,0) + m(1,1) + m(2,2);
+
+    // Construct the parameters used in classifying the roots of the equation
+    // and in solving the equation for the roots in closed form.
+    Scalar c2_over_3 = c2*s_inv3;
+    Scalar a_over_3 = (c2*c2_over_3 - c1)*s_inv3;
+    a_over_3 = numext::maxi(a_over_3, Scalar(0));
+
+    Scalar half_b = Scalar(0.5)*(c0 + c2_over_3*(Scalar(2)*c2_over_3*c2_over_3 - c1));
+
+    Scalar q = a_over_3*a_over_3*a_over_3 - half_b*half_b;
+    q = numext::maxi(q, Scalar(0));
+
+    // Compute the eigenvalues by solving for the roots of the polynomial.
+    Scalar rho = sqrt(a_over_3);
+    Scalar theta = atan2(sqrt(q),half_b)*s_inv3;  // since sqrt(q) > 0, atan2 is in [0, pi] and theta is in [0, pi/3]
+    Scalar cos_theta = cos(theta);
+    Scalar sin_theta = sin(theta);
+    // roots are already sorted, since cos is monotonically decreasing on [0, pi]
+    roots(0) = c2_over_3 - rho*(cos_theta + s_sqrt3*sin_theta); // == 2*rho*cos(theta+2pi/3)
+    roots(1) = c2_over_3 - rho*(cos_theta - s_sqrt3*sin_theta); // == 2*rho*cos(theta+ pi/3)
+    roots(2) = c2_over_3 + Scalar(2)*rho*cos_theta;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline bool extract_kernel(MatrixType& mat, Ref<VectorType> res, Ref<VectorType> representative)
+  {
+    EIGEN_USING_STD(abs);
+    EIGEN_USING_STD(sqrt);
+    Index i0;
+    // Find non-zero column i0 (by construction, there must exist a non zero coefficient on the diagonal):
+    mat.diagonal().cwiseAbs().maxCoeff(&i0);
+    // mat.col(i0) is a good candidate for an orthogonal vector to the current eigenvector,
+    // so let's save it:
+    representative = mat.col(i0);
+    Scalar n0, n1;
+    VectorType c0, c1;
+    n0 = (c0 = representative.cross(mat.col((i0+1)%3))).squaredNorm();
+    n1 = (c1 = representative.cross(mat.col((i0+2)%3))).squaredNorm();
+    if(n0>n1) res = c0/sqrt(n0);
+    else      res = c1/sqrt(n1);
+
+    return true;
+  }
+
+  EIGEN_DEVICE_FUNC
+  static inline void run(SolverType& solver, const MatrixType& mat, int options)
+  {
+    eigen_assert(mat.cols() == 3 && mat.cols() == mat.rows());
+    eigen_assert((options&~(EigVecMask|GenEigMask))==0
+            && (options&EigVecMask)!=EigVecMask
+            && "invalid option parameter");
+    bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+    
+    EigenvectorsType& eivecs = solver.m_eivec;
+    VectorType& eivals = solver.m_eivalues;
+  
+    // Shift the matrix to the mean eigenvalue and map the matrix coefficients to [-1:1] to avoid over- and underflow.
+    Scalar shift = mat.trace() / Scalar(3);
+    // TODO Avoid this copy. Currently it is necessary to suppress bogus values when determining maxCoeff and for computing the eigenvectors later
+    MatrixType scaledMat = mat.template selfadjointView<Lower>();
+    scaledMat.diagonal().array() -= shift;
+    Scalar scale = scaledMat.cwiseAbs().maxCoeff();
+    if(scale > 0) scaledMat /= scale;   // TODO for scale==0 we could save the remaining operations
+
+    // compute the eigenvalues
+    computeRoots(scaledMat,eivals);
+
+    // compute the eigenvectors
+    if(computeEigenvectors)
+    {
+      if((eivals(2)-eivals(0))<=Eigen::NumTraits<Scalar>::epsilon())
+      {
+        // All three eigenvalues are numerically the same
+        eivecs.setIdentity();
+      }
+      else
+      {
+        MatrixType tmp;
+        tmp = scaledMat;
+
+        // Compute the eigenvector of the most distinct eigenvalue
+        Scalar d0 = eivals(2) - eivals(1);
+        Scalar d1 = eivals(1) - eivals(0);
+        Index k(0), l(2);
+        if(d0 > d1)
+        {
+          numext::swap(k,l);
+          d0 = d1;
+        }
+
+        // Compute the eigenvector of index k
+        {
+          tmp.diagonal().array () -= eivals(k);
+          // By construction, 'tmp' is of rank 2, and its kernel corresponds to the respective eigenvector.
+          extract_kernel(tmp, eivecs.col(k), eivecs.col(l));
+        }
+
+        // Compute eigenvector of index l
+        if(d0<=2*Eigen::NumTraits<Scalar>::epsilon()*d1)
+        {
+          // If d0 is too small, then the two other eigenvalues are numerically the same,
+          // and thus we only have to ortho-normalize the near orthogonal vector we saved above.
+          eivecs.col(l) -= eivecs.col(k).dot(eivecs.col(l))*eivecs.col(l);
+          eivecs.col(l).normalize();
+        }
+        else
+        {
+          tmp = scaledMat;
+          tmp.diagonal().array () -= eivals(l);
+
+          VectorType dummy;
+          extract_kernel(tmp, eivecs.col(l), dummy);
+        }
+
+        // Compute last eigenvector from the other two
+        eivecs.col(1) = eivecs.col(2).cross(eivecs.col(0)).normalized();
+      }
+    }
+
+    // Rescale back to the original size.
+    eivals *= scale;
+    eivals.array() += shift;
+    
+    solver.m_info = Success;
+    solver.m_isInitialized = true;
+    solver.m_eigenvectorsOk = computeEigenvectors;
+  }
+};
+
+// 2x2 direct eigenvalues decomposition, code from Hauke Heibel
+template<typename SolverType> 
+struct direct_selfadjoint_eigenvalues<SolverType,2,false>
+{
+  typedef typename SolverType::MatrixType MatrixType;
+  typedef typename SolverType::RealVectorType VectorType;
+  typedef typename SolverType::Scalar Scalar;
+  typedef typename SolverType::EigenvectorsType EigenvectorsType;
+  
+  EIGEN_DEVICE_FUNC
+  static inline void computeRoots(const MatrixType& m, VectorType& roots)
+  {
+    EIGEN_USING_STD(sqrt);
+    const Scalar t0 = Scalar(0.5) * sqrt( numext::abs2(m(0,0)-m(1,1)) + Scalar(4)*numext::abs2(m(1,0)));
+    const Scalar t1 = Scalar(0.5) * (m(0,0) + m(1,1));
+    roots(0) = t1 - t0;
+    roots(1) = t1 + t0;
+  }
+  
+  EIGEN_DEVICE_FUNC
+  static inline void run(SolverType& solver, const MatrixType& mat, int options)
+  {
+    EIGEN_USING_STD(sqrt);
+    EIGEN_USING_STD(abs);
+    
+    eigen_assert(mat.cols() == 2 && mat.cols() == mat.rows());
+    eigen_assert((options&~(EigVecMask|GenEigMask))==0
+            && (options&EigVecMask)!=EigVecMask
+            && "invalid option parameter");
+    bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors;
+    
+    EigenvectorsType& eivecs = solver.m_eivec;
+    VectorType& eivals = solver.m_eivalues;
+  
+    // Shift the matrix to the mean eigenvalue and map the matrix coefficients to [-1:1] to avoid over- and underflow.
+    Scalar shift = mat.trace() / Scalar(2);
+    MatrixType scaledMat = mat;
+    scaledMat.coeffRef(0,1) = mat.coeff(1,0);
+    scaledMat.diagonal().array() -= shift;
+    Scalar scale = scaledMat.cwiseAbs().maxCoeff();
+    if(scale > Scalar(0))
+      scaledMat /= scale;
+
+    // Compute the eigenvalues
+    computeRoots(scaledMat,eivals);
+
+    // compute the eigen vectors
+    if(computeEigenvectors)
+    {
+      if((eivals(1)-eivals(0))<=abs(eivals(1))*Eigen::NumTraits<Scalar>::epsilon())
+      {
+        eivecs.setIdentity();
+      }
+      else
+      {
+        scaledMat.diagonal().array () -= eivals(1);
+        Scalar a2 = numext::abs2(scaledMat(0,0));
+        Scalar c2 = numext::abs2(scaledMat(1,1));
+        Scalar b2 = numext::abs2(scaledMat(1,0));
+        if(a2>c2)
+        {
+          eivecs.col(1) << -scaledMat(1,0), scaledMat(0,0);
+          eivecs.col(1) /= sqrt(a2+b2);
+        }
+        else
+        {
+          eivecs.col(1) << -scaledMat(1,1), scaledMat(1,0);
+          eivecs.col(1) /= sqrt(c2+b2);
+        }
+
+        eivecs.col(0) << eivecs.col(1).unitOrthogonal();
+      }
+    }
+
+    // Rescale back to the original size.
+    eivals *= scale;
+    eivals.array() += shift;
+
+    solver.m_info = Success;
+    solver.m_isInitialized = true;
+    solver.m_eigenvectorsOk = computeEigenvectors;
+  }
+};
+
+}
+
+template<typename MatrixType>
+EIGEN_DEVICE_FUNC
+SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>
+::computeDirect(const MatrixType& matrix, int options)
+{
+  internal::direct_selfadjoint_eigenvalues<SelfAdjointEigenSolver,Size,NumTraits<Scalar>::IsComplex>::run(*this,matrix,options);
+  return *this;
+}
+
+namespace internal {
+
+// Francis implicit QR step.
+template<int StorageOrder,typename RealScalar, typename Scalar, typename Index>
+EIGEN_DEVICE_FUNC
+static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n)
+{
+  // Wilkinson Shift.
+  RealScalar td = (diag[end-1] - diag[end])*RealScalar(0.5);
+  RealScalar e = subdiag[end-1];
+  // Note that thanks to scaling, e^2 or td^2 cannot overflow, however they can still
+  // underflow thus leading to inf/NaN values when using the following commented code:
+  //   RealScalar e2 = numext::abs2(subdiag[end-1]);
+  //   RealScalar mu = diag[end] - e2 / (td + (td>0 ? 1 : -1) * sqrt(td*td + e2));
+  // This explain the following, somewhat more complicated, version:
+  RealScalar mu = diag[end];
+  if(td==RealScalar(0)) {
+    mu -= numext::abs(e);
+  } else if (e != RealScalar(0)) {
+    const RealScalar e2 = numext::abs2(e);
+    const RealScalar h = numext::hypot(td,e);
+    if(e2 == RealScalar(0)) {
+      mu -= e / ((td + (td>RealScalar(0) ? h : -h)) / e);
+    } else {
+      mu -= e2 / (td + (td>RealScalar(0) ? h : -h)); 
+    }
+  }
+
+  RealScalar x = diag[start] - mu;
+  RealScalar z = subdiag[start];
+  // If z ever becomes zero, the Givens rotation will be the identity and
+  // z will stay zero for all future iterations.
+  for (Index k = start; k < end && z != RealScalar(0); ++k)
+  {
+    JacobiRotation<RealScalar> rot;
+    rot.makeGivens(x, z);
+
+    // do T = G' T G
+    RealScalar sdk = rot.s() * diag[k] + rot.c() * subdiag[k];
+    RealScalar dkp1 = rot.s() * subdiag[k] + rot.c() * diag[k+1];
+
+    diag[k] = rot.c() * (rot.c() * diag[k] - rot.s() * subdiag[k]) - rot.s() * (rot.c() * subdiag[k] - rot.s() * diag[k+1]);
+    diag[k+1] = rot.s() * sdk + rot.c() * dkp1;
+    subdiag[k] = rot.c() * sdk - rot.s() * dkp1;
+    
+    if (k > start)
+      subdiag[k - 1] = rot.c() * subdiag[k-1] - rot.s() * z;
+
+    // "Chasing the bulge" to return to triangular form.
+    x = subdiag[k];
+    if (k < end - 1)
+    {
+      z = -rot.s() * subdiag[k+1];
+      subdiag[k + 1] = rot.c() * subdiag[k+1];
+    }
+    
+    // apply the givens rotation to the unit matrix Q = Q * G
+    if (matrixQ)
+    {
+      // FIXME if StorageOrder == RowMajor this operation is not very efficient
+      Map<Matrix<Scalar,Dynamic,Dynamic,StorageOrder> > q(matrixQ,n,n);
+      q.applyOnTheRight(k,k+1,rot);
+    }
+  }
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SELFADJOINTEIGENSOLVER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
new file mode 100644
index 00000000..b0c947dc
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
@@ -0,0 +1,87 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Self-adjoint eigenvalues/eigenvectors.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_SAEIGENSOLVER_LAPACKE_H
+#define EIGEN_SAEIGENSOLVER_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_EIG_SELFADJ_2(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_NAME, EIGCOLROW ) \
+template<> template<typename InputType> inline \
+SelfAdjointEigenSolver<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >& \
+SelfAdjointEigenSolver<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >::compute(const EigenBase<InputType>& matrix, int options) \
+{ \
+  eigen_assert(matrix.cols() == matrix.rows()); \
+  eigen_assert((options&~(EigVecMask|GenEigMask))==0 \
+          && (options&EigVecMask)!=EigVecMask \
+          && "invalid option parameter"); \
+  bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors; \
+  lapack_int n = internal::convert_index<lapack_int>(matrix.cols()), lda, info; \
+  m_eivalues.resize(n,1); \
+  m_subdiag.resize(n-1); \
+  m_eivec = matrix; \
+\
+  if(n==1) \
+  { \
+    m_eivalues.coeffRef(0,0) = numext::real(m_eivec.coeff(0,0)); \
+    if(computeEigenvectors) m_eivec.setOnes(n,n); \
+    m_info = Success; \
+    m_isInitialized = true; \
+    m_eigenvectorsOk = computeEigenvectors; \
+    return *this; \
+  } \
+\
+  lda = internal::convert_index<lapack_int>(m_eivec.outerStride()); \
+  char jobz, uplo='L'/*, range='A'*/; \
+  jobz = computeEigenvectors ? 'V' : 'N'; \
+\
+  info = LAPACKE_##LAPACKE_NAME( LAPACK_COL_MAJOR, jobz, uplo, n, (LAPACKE_TYPE*)m_eivec.data(), lda, (LAPACKE_RTYPE*)m_eivalues.data() ); \
+  m_info = (info==0) ? Success : NoConvergence; \
+  m_isInitialized = true; \
+  m_eigenvectorsOk = computeEigenvectors; \
+  return *this; \
+}
+
+#define EIGEN_LAPACKE_EIG_SELFADJ(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_NAME )              \
+        EIGEN_LAPACKE_EIG_SELFADJ_2(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_NAME, ColMajor )  \
+        EIGEN_LAPACKE_EIG_SELFADJ_2(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_NAME, RowMajor ) 
+
+EIGEN_LAPACKE_EIG_SELFADJ(double,   double,                double, dsyev)
+EIGEN_LAPACKE_EIG_SELFADJ(float,    float,                 float,  ssyev)
+EIGEN_LAPACKE_EIG_SELFADJ(dcomplex, lapack_complex_double, double, zheev)
+EIGEN_LAPACKE_EIG_SELFADJ(scomplex, lapack_complex_float,  float,  cheev)
+
+} // end namespace Eigen
+
+#endif // EIGEN_SAEIGENSOLVER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/Tridiagonalization.h b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/Tridiagonalization.h
new file mode 100644
index 00000000..674c92a3
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Eigenvalues/Tridiagonalization.h
@@ -0,0 +1,561 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRIDIAGONALIZATION_H
+#define EIGEN_TRIDIAGONALIZATION_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatrixType> struct TridiagonalizationMatrixTReturnType;
+template<typename MatrixType>
+struct traits<TridiagonalizationMatrixTReturnType<MatrixType> >
+  : public traits<typename MatrixType::PlainObject>
+{
+  typedef typename MatrixType::PlainObject ReturnType; // FIXME shall it be a BandMatrix?
+  enum { Flags = 0 };
+};
+
+template<typename MatrixType, typename CoeffVectorType>
+EIGEN_DEVICE_FUNC
+void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs);
+}
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  *
+  * \class Tridiagonalization
+  *
+  * \brief Tridiagonal decomposition of a selfadjoint matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the
+  * tridiagonal decomposition; this is expected to be an instantiation of the
+  * Matrix class template.
+  *
+  * This class performs a tridiagonal decomposition of a selfadjoint matrix \f$ A \f$ such that:
+  * \f$ A = Q T Q^* \f$ where \f$ Q \f$ is unitary and \f$ T \f$ a real symmetric tridiagonal matrix.
+  *
+  * A tridiagonal matrix is a matrix which has nonzero elements only on the
+  * main diagonal and the first diagonal below and above it. The Hessenberg
+  * decomposition of a selfadjoint matrix is in fact a tridiagonal
+  * decomposition. This class is used in SelfAdjointEigenSolver to compute the
+  * eigenvalues and eigenvectors of a selfadjoint matrix.
+  *
+  * Call the function compute() to compute the tridiagonal decomposition of a
+  * given matrix. Alternatively, you can use the Tridiagonalization(const MatrixType&)
+  * constructor which computes the tridiagonal Schur decomposition at
+  * construction time. Once the decomposition is computed, you can use the
+  * matrixQ() and matrixT() functions to retrieve the matrices Q and T in the
+  * decomposition.
+  *
+  * The documentation of Tridiagonalization(const MatrixType&) contains an
+  * example of the typical use of this class.
+  *
+  * \sa class HessenbergDecomposition, class SelfAdjointEigenSolver
+  */
+template<typename _MatrixType> class Tridiagonalization
+{
+  public:
+
+    /** \brief Synonym for the template parameter \p _MatrixType. */
+    typedef _MatrixType MatrixType;
+
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+
+    enum {
+      Size = MatrixType::RowsAtCompileTime,
+      SizeMinusOne = Size == Dynamic ? Dynamic : (Size > 1 ? Size - 1 : 1),
+      Options = MatrixType::Options,
+      MaxSize = MatrixType::MaxRowsAtCompileTime,
+      MaxSizeMinusOne = MaxSize == Dynamic ? Dynamic : (MaxSize > 1 ? MaxSize - 1 : 1)
+    };
+
+    typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType;
+    typedef typename internal::plain_col_type<MatrixType, RealScalar>::type DiagonalType;
+    typedef Matrix<RealScalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> SubDiagonalType;
+    typedef typename internal::remove_all<typename MatrixType::RealReturnType>::type MatrixTypeRealView;
+    typedef internal::TridiagonalizationMatrixTReturnType<MatrixTypeRealView> MatrixTReturnType;
+
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+              typename internal::add_const_on_value_type<typename Diagonal<const MatrixType>::RealReturnType>::type,
+              const Diagonal<const MatrixType>
+            >::type DiagonalReturnType;
+
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+              typename internal::add_const_on_value_type<typename Diagonal<const MatrixType, -1>::RealReturnType>::type,
+              const Diagonal<const MatrixType, -1>
+            >::type SubDiagonalReturnType;
+
+    /** \brief Return type of matrixQ() */
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename CoeffVectorType::ConjugateReturnType>::type> HouseholderSequenceType;
+
+    /** \brief Default constructor.
+      *
+      * \param [in]  size  Positive integer, size of the matrix whose tridiagonal
+      * decomposition will be computed.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via compute().  The \p size parameter is only
+      * used as a hint. It is not an error to give a wrong \p size, but it may
+      * impair performance.
+      *
+      * \sa compute() for an example.
+      */
+    explicit Tridiagonalization(Index size = Size==Dynamic ? 2 : Size)
+      : m_matrix(size,size),
+        m_hCoeffs(size > 1 ? size-1 : 1),
+        m_isInitialized(false)
+    {}
+
+    /** \brief Constructor; computes tridiagonal decomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose tridiagonal decomposition
+      * is to be computed.
+      *
+      * This constructor calls compute() to compute the tridiagonal decomposition.
+      *
+      * Example: \include Tridiagonalization_Tridiagonalization_MatrixType.cpp
+      * Output: \verbinclude Tridiagonalization_Tridiagonalization_MatrixType.out
+      */
+    template<typename InputType>
+    explicit Tridiagonalization(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_hCoeffs(matrix.cols() > 1 ? matrix.cols()-1 : 1),
+        m_isInitialized(false)
+    {
+      internal::tridiagonalization_inplace(m_matrix, m_hCoeffs);
+      m_isInitialized = true;
+    }
+
+    /** \brief Computes tridiagonal decomposition of given matrix.
+      *
+      * \param[in]  matrix  Selfadjoint matrix whose tridiagonal decomposition
+      * is to be computed.
+      * \returns    Reference to \c *this
+      *
+      * The tridiagonal decomposition is computed by bringing the columns of
+      * the matrix successively in the required form using Householder
+      * reflections. The cost is \f$ 4n^3/3 \f$ flops, where \f$ n \f$ denotes
+      * the size of the given matrix.
+      *
+      * This method reuses of the allocated data in the Tridiagonalization
+      * object, if the size of the matrix does not change.
+      *
+      * Example: \include Tridiagonalization_compute.cpp
+      * Output: \verbinclude Tridiagonalization_compute.out
+      */
+    template<typename InputType>
+    Tridiagonalization& compute(const EigenBase<InputType>& matrix)
+    {
+      m_matrix = matrix.derived();
+      m_hCoeffs.resize(matrix.rows()-1, 1);
+      internal::tridiagonalization_inplace(m_matrix, m_hCoeffs);
+      m_isInitialized = true;
+      return *this;
+    }
+
+    /** \brief Returns the Householder coefficients.
+      *
+      * \returns a const reference to the vector of Householder coefficients
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * The Householder coefficients allow the reconstruction of the matrix
+      * \f$ Q \f$ in the tridiagonal decomposition from the packed data.
+      *
+      * Example: \include Tridiagonalization_householderCoefficients.cpp
+      * Output: \verbinclude Tridiagonalization_householderCoefficients.out
+      *
+      * \sa packedMatrix(), \ref Householder_Module "Householder module"
+      */
+    inline CoeffVectorType householderCoefficients() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return m_hCoeffs;
+    }
+
+    /** \brief Returns the internal representation of the decomposition
+      *
+      *	\returns a const reference to a matrix with the internal representation
+      *	         of the decomposition.
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * The returned matrix contains the following information:
+      *  - the strict upper triangular part is equal to the input matrix A.
+      *  - the diagonal and lower sub-diagonal represent the real tridiagonal
+      *    symmetric matrix T.
+      *  - the rest of the lower part contains the Householder vectors that,
+      *    combined with Householder coefficients returned by
+      *    householderCoefficients(), allows to reconstruct the matrix Q as
+      *       \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
+      *    Here, the matrices \f$ H_i \f$ are the Householder transformations
+      *       \f$ H_i = (I - h_i v_i v_i^T) \f$
+      *    where \f$ h_i \f$ is the \f$ i \f$th Householder coefficient and
+      *    \f$ v_i \f$ is the Householder vector defined by
+      *       \f$ v_i = [ 0, \ldots, 0, 1, M(i+2,i), \ldots, M(N-1,i) ]^T \f$
+      *    with M the matrix returned by this function.
+      *
+      * See LAPACK for further details on this packed storage.
+      *
+      * Example: \include Tridiagonalization_packedMatrix.cpp
+      * Output: \verbinclude Tridiagonalization_packedMatrix.out
+      *
+      * \sa householderCoefficients()
+      */
+    inline const MatrixType& packedMatrix() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return m_matrix;
+    }
+
+    /** \brief Returns the unitary matrix Q in the decomposition
+      *
+      * \returns object representing the matrix Q
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * This function returns a light-weight object of template class
+      * HouseholderSequence. You can either apply it directly to a matrix or
+      * you can convert it to a matrix of type #MatrixType.
+      *
+      * \sa Tridiagonalization(const MatrixType&) for an example,
+      *     matrixT(), class HouseholderSequence
+      */
+    HouseholderSequenceType matrixQ() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return HouseholderSequenceType(m_matrix, m_hCoeffs.conjugate())
+             .setLength(m_matrix.rows() - 1)
+             .setShift(1);
+    }
+
+    /** \brief Returns an expression of the tridiagonal matrix T in the decomposition
+      *
+      * \returns expression object representing the matrix T
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * Currently, this function can be used to extract the matrix T from internal
+      * data and copy it to a dense matrix object. In most cases, it may be
+      * sufficient to directly use the packed matrix or the vector expressions
+      * returned by diagonal() and subDiagonal() instead of creating a new
+      * dense copy matrix with this function.
+      *
+      * \sa Tridiagonalization(const MatrixType&) for an example,
+      * matrixQ(), packedMatrix(), diagonal(), subDiagonal()
+      */
+    MatrixTReturnType matrixT() const
+    {
+      eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+      return MatrixTReturnType(m_matrix.real());
+    }
+
+    /** \brief Returns the diagonal of the tridiagonal matrix T in the decomposition.
+      *
+      * \returns expression representing the diagonal of T
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * Example: \include Tridiagonalization_diagonal.cpp
+      * Output: \verbinclude Tridiagonalization_diagonal.out
+      *
+      * \sa matrixT(), subDiagonal()
+      */
+    DiagonalReturnType diagonal() const;
+
+    /** \brief Returns the subdiagonal of the tridiagonal matrix T in the decomposition.
+      *
+      * \returns expression representing the subdiagonal of T
+      *
+      * \pre Either the constructor Tridiagonalization(const MatrixType&) or
+      * the member function compute(const MatrixType&) has been called before
+      * to compute the tridiagonal decomposition of a matrix.
+      *
+      * \sa diagonal() for an example, matrixT()
+      */
+    SubDiagonalReturnType subDiagonal() const;
+
+  protected:
+
+    MatrixType m_matrix;
+    CoeffVectorType m_hCoeffs;
+    bool m_isInitialized;
+};
+
+template<typename MatrixType>
+typename Tridiagonalization<MatrixType>::DiagonalReturnType
+Tridiagonalization<MatrixType>::diagonal() const
+{
+  eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+  return m_matrix.diagonal().real();
+}
+
+template<typename MatrixType>
+typename Tridiagonalization<MatrixType>::SubDiagonalReturnType
+Tridiagonalization<MatrixType>::subDiagonal() const
+{
+  eigen_assert(m_isInitialized && "Tridiagonalization is not initialized.");
+  return m_matrix.template diagonal<-1>().real();
+}
+
+namespace internal {
+
+/** \internal
+  * Performs a tridiagonal decomposition of the selfadjoint matrix \a matA in-place.
+  *
+  * \param[in,out] matA On input the selfadjoint matrix. Only the \b lower triangular part is referenced.
+  *                     On output, the strict upper part is left unchanged, and the lower triangular part
+  *                     represents the T and Q matrices in packed format has detailed below.
+  * \param[out]    hCoeffs returned Householder coefficients (see below)
+  *
+  * On output, the tridiagonal selfadjoint matrix T is stored in the diagonal
+  * and lower sub-diagonal of the matrix \a matA.
+  * The unitary matrix Q is represented in a compact way as a product of
+  * Householder reflectors \f$ H_i \f$ such that:
+  *       \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
+  * The Householder reflectors are defined as
+  *       \f$ H_i = (I - h_i v_i v_i^T) \f$
+  * where \f$ h_i = hCoeffs[i]\f$ is the \f$ i \f$th Householder coefficient and
+  * \f$ v_i \f$ is the Householder vector defined by
+  *       \f$ v_i = [ 0, \ldots, 0, 1, matA(i+2,i), \ldots, matA(N-1,i) ]^T \f$.
+  *
+  * Implemented from Golub's "Matrix Computations", algorithm 8.3.1.
+  *
+  * \sa Tridiagonalization::packedMatrix()
+  */
+template<typename MatrixType, typename CoeffVectorType>
+EIGEN_DEVICE_FUNC
+void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs)
+{
+  using numext::conj;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  Index n = matA.rows();
+  eigen_assert(n==matA.cols());
+  eigen_assert(n==hCoeffs.size()+1 || n==1);
+
+  for (Index i = 0; i<n-1; ++i)
+  {
+    Index remainingSize = n-i-1;
+    RealScalar beta;
+    Scalar h;
+    matA.col(i).tail(remainingSize).makeHouseholderInPlace(h, beta);
+
+    // Apply similarity transformation to remaining columns,
+    // i.e., A = H A H' where H = I - h v v' and v = matA.col(i).tail(n-i-1)
+    matA.col(i).coeffRef(i+1) = 1;
+
+    hCoeffs.tail(n-i-1).noalias() = (matA.bottomRightCorner(remainingSize,remainingSize).template selfadjointView<Lower>()
+                                  * (conj(h) * matA.col(i).tail(remainingSize)));
+
+    hCoeffs.tail(n-i-1) += (conj(h)*RealScalar(-0.5)*(hCoeffs.tail(remainingSize).dot(matA.col(i).tail(remainingSize)))) * matA.col(i).tail(n-i-1);
+
+    matA.bottomRightCorner(remainingSize, remainingSize).template selfadjointView<Lower>()
+      .rankUpdate(matA.col(i).tail(remainingSize), hCoeffs.tail(remainingSize), Scalar(-1));
+
+    matA.col(i).coeffRef(i+1) = beta;
+    hCoeffs.coeffRef(i) = h;
+  }
+}
+
+// forward declaration, implementation at the end of this file
+template<typename MatrixType,
+         int Size=MatrixType::ColsAtCompileTime,
+         bool IsComplex=NumTraits<typename MatrixType::Scalar>::IsComplex>
+struct tridiagonalization_inplace_selector;
+
+/** \brief Performs a full tridiagonalization in place
+  *
+  * \param[in,out]  mat  On input, the selfadjoint matrix whose tridiagonal
+  *    decomposition is to be computed. Only the lower triangular part referenced.
+  *    The rest is left unchanged. On output, the orthogonal matrix Q
+  *    in the decomposition if \p extractQ is true.
+  * \param[out]  diag  The diagonal of the tridiagonal matrix T in the
+  *    decomposition.
+  * \param[out]  subdiag  The subdiagonal of the tridiagonal matrix T in
+  *    the decomposition.
+  * \param[in]  extractQ  If true, the orthogonal matrix Q in the
+  *    decomposition is computed and stored in \p mat.
+  *
+  * Computes the tridiagonal decomposition of the selfadjoint matrix \p mat in place
+  * such that \f$ mat = Q T Q^* \f$ where \f$ Q \f$ is unitary and \f$ T \f$ a real
+  * symmetric tridiagonal matrix.
+  *
+  * The tridiagonal matrix T is passed to the output parameters \p diag and \p subdiag. If
+  * \p extractQ is true, then the orthogonal matrix Q is passed to \p mat. Otherwise the lower
+  * part of the matrix \p mat is destroyed.
+  *
+  * The vectors \p diag and \p subdiag are not resized. The function
+  * assumes that they are already of the correct size. The length of the
+  * vector \p diag should equal the number of rows in \p mat, and the
+  * length of the vector \p subdiag should be one left.
+  *
+  * This implementation contains an optimized path for 3-by-3 matrices
+  * which is especially useful for plane fitting.
+  *
+  * \note Currently, it requires two temporary vectors to hold the intermediate
+  * Householder coefficients, and to reconstruct the matrix Q from the Householder
+  * reflectors.
+  *
+  * Example (this uses the same matrix as the example in
+  *    Tridiagonalization::Tridiagonalization(const MatrixType&)):
+  *    \include Tridiagonalization_decomposeInPlace.cpp
+  * Output: \verbinclude Tridiagonalization_decomposeInPlace.out
+  *
+  * \sa class Tridiagonalization
+  */
+template<typename MatrixType, typename DiagonalType, typename SubDiagonalType, typename CoeffVectorType>
+EIGEN_DEVICE_FUNC
+void tridiagonalization_inplace(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag,
+                                CoeffVectorType& hcoeffs, bool extractQ)
+{
+  eigen_assert(mat.cols()==mat.rows() && diag.size()==mat.rows() && subdiag.size()==mat.rows()-1);
+  tridiagonalization_inplace_selector<MatrixType>::run(mat, diag, subdiag, hcoeffs, extractQ);
+}
+
+/** \internal
+  * General full tridiagonalization
+  */
+template<typename MatrixType, int Size, bool IsComplex>
+struct tridiagonalization_inplace_selector
+{
+  typedef typename Tridiagonalization<MatrixType>::CoeffVectorType CoeffVectorType;
+  typedef typename Tridiagonalization<MatrixType>::HouseholderSequenceType HouseholderSequenceType;
+  template<typename DiagonalType, typename SubDiagonalType>
+  static EIGEN_DEVICE_FUNC
+      void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, CoeffVectorType& hCoeffs, bool extractQ)
+  {
+    tridiagonalization_inplace(mat, hCoeffs);
+    diag = mat.diagonal().real();
+    subdiag = mat.template diagonal<-1>().real();
+    if(extractQ)
+      mat = HouseholderSequenceType(mat, hCoeffs.conjugate())
+            .setLength(mat.rows() - 1)
+            .setShift(1);
+  }
+};
+
+/** \internal
+  * Specialization for 3x3 real matrices.
+  * Especially useful for plane fitting.
+  */
+template<typename MatrixType>
+struct tridiagonalization_inplace_selector<MatrixType,3,false>
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  template<typename DiagonalType, typename SubDiagonalType, typename CoeffVectorType>
+  static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, CoeffVectorType&, bool extractQ)
+  {
+    using std::sqrt;
+    const RealScalar tol = (std::numeric_limits<RealScalar>::min)();
+    diag[0] = mat(0,0);
+    RealScalar v1norm2 = numext::abs2(mat(2,0));
+    if(v1norm2 <= tol)
+    {
+      diag[1] = mat(1,1);
+      diag[2] = mat(2,2);
+      subdiag[0] = mat(1,0);
+      subdiag[1] = mat(2,1);
+      if (extractQ)
+        mat.setIdentity();
+    }
+    else
+    {
+      RealScalar beta = sqrt(numext::abs2(mat(1,0)) + v1norm2);
+      RealScalar invBeta = RealScalar(1)/beta;
+      Scalar m01 = mat(1,0) * invBeta;
+      Scalar m02 = mat(2,0) * invBeta;
+      Scalar q = RealScalar(2)*m01*mat(2,1) + m02*(mat(2,2) - mat(1,1));
+      diag[1] = mat(1,1) + m02*q;
+      diag[2] = mat(2,2) - m02*q;
+      subdiag[0] = beta;
+      subdiag[1] = mat(2,1) - m01 * q;
+      if (extractQ)
+      {
+        mat << 1,   0,    0,
+               0, m01,  m02,
+               0, m02, -m01;
+      }
+    }
+  }
+};
+
+/** \internal
+  * Trivial specialization for 1x1 matrices
+  */
+template<typename MatrixType, bool IsComplex>
+struct tridiagonalization_inplace_selector<MatrixType,1,IsComplex>
+{
+  typedef typename MatrixType::Scalar Scalar;
+
+  template<typename DiagonalType, typename SubDiagonalType, typename CoeffVectorType>
+  static EIGEN_DEVICE_FUNC
+  void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType&, CoeffVectorType&, bool extractQ)
+  {
+    diag(0,0) = numext::real(mat(0,0));
+    if(extractQ)
+      mat(0,0) = Scalar(1);
+  }
+};
+
+/** \internal
+  * \eigenvalues_module \ingroup Eigenvalues_Module
+  *
+  * \brief Expression type for return value of Tridiagonalization::matrixT()
+  *
+  * \tparam MatrixType type of underlying dense matrix
+  */
+template<typename MatrixType> struct TridiagonalizationMatrixTReturnType
+: public ReturnByValue<TridiagonalizationMatrixTReturnType<MatrixType> >
+{
+  public:
+    /** \brief Constructor.
+      *
+      * \param[in] mat The underlying dense matrix
+      */
+    TridiagonalizationMatrixTReturnType(const MatrixType& mat) : m_matrix(mat) { }
+
+    template <typename ResultType>
+    inline void evalTo(ResultType& result) const
+    {
+      result.setZero();
+      result.template diagonal<1>() = m_matrix.template diagonal<-1>().conjugate();
+      result.diagonal() = m_matrix.diagonal();
+      result.template diagonal<-1>() = m_matrix.template diagonal<-1>();
+    }
+
+    EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
+    EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRIDIAGONALIZATION_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/AlignedBox.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/AlignedBox.h
new file mode 100644
index 00000000..55a9d0ae
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/AlignedBox.h
@@ -0,0 +1,486 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// Function void Eigen::AlignedBox::transform(const Transform& transform)
+// is provided under the following license agreement:
+//
+// Software License Agreement (BSD License)
+//
+// Copyright (c) 2011-2014, Willow Garage, Inc.
+// Copyright (c) 2014-2015, Open Source Robotics Foundation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//  * Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//  * Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//  * Neither the name of Open Source Robotics Foundation nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef EIGEN_ALIGNEDBOX_H
+#define EIGEN_ALIGNEDBOX_H
+
+namespace Eigen {
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  *
+  * \class AlignedBox
+  *
+  * \brief An axis aligned box
+  *
+  * \tparam _Scalar the type of the scalar coefficients
+  * \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
+  *
+  * This class represents an axis aligned box as a pair of the minimal and maximal corners.
+  * \warning The result of most methods is undefined when applied to an empty box. You can check for empty boxes using isEmpty().
+  * \sa alignedboxtypedefs
+  */
+template <typename _Scalar, int _AmbientDim>
+class AlignedBox
+{
+public:
+EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
+  enum { AmbientDimAtCompileTime = _AmbientDim };
+  typedef _Scalar                                   Scalar;
+  typedef NumTraits<Scalar>                         ScalarTraits;
+  typedef Eigen::Index                              Index; ///< \deprecated since Eigen 3.3
+  typedef typename ScalarTraits::Real               RealScalar;
+  typedef typename ScalarTraits::NonInteger         NonInteger;
+  typedef Matrix<Scalar,AmbientDimAtCompileTime,1>  VectorType;
+  typedef CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const VectorType, const VectorType> VectorTypeSum;
+
+  /** Define constants to name the corners of a 1D, 2D or 3D axis aligned bounding box */
+  enum CornerType
+  {
+    /** 1D names @{ */
+    Min=0, Max=1,
+    /** @} */
+
+    /** Identifier for 2D corner @{ */
+    BottomLeft=0, BottomRight=1,
+    TopLeft=2, TopRight=3,
+    /** @} */
+
+    /** Identifier for 3D corner  @{ */
+    BottomLeftFloor=0, BottomRightFloor=1,
+    TopLeftFloor=2, TopRightFloor=3,
+    BottomLeftCeil=4, BottomRightCeil=5,
+    TopLeftCeil=6, TopRightCeil=7
+    /** @} */
+  };
+
+
+  /** Default constructor initializing a null box. */
+  EIGEN_DEVICE_FUNC inline AlignedBox()
+  { if (EIGEN_CONST_CONDITIONAL(AmbientDimAtCompileTime!=Dynamic)) setEmpty(); }
+
+  /** Constructs a null box with \a _dim the dimension of the ambient space. */
+  EIGEN_DEVICE_FUNC inline explicit AlignedBox(Index _dim) : m_min(_dim), m_max(_dim)
+  { setEmpty(); }
+
+  /** Constructs a box with extremities \a _min and \a _max.
+   * \warning If either component of \a _min is larger than the same component of \a _max, the constructed box is empty. */
+  template<typename OtherVectorType1, typename OtherVectorType2>
+  EIGEN_DEVICE_FUNC inline AlignedBox(const OtherVectorType1& _min, const OtherVectorType2& _max) : m_min(_min), m_max(_max) {}
+
+  /** Constructs a box containing a single point \a p. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline explicit AlignedBox(const MatrixBase<Derived>& p) : m_min(p), m_max(m_min)
+  { }
+
+  EIGEN_DEVICE_FUNC ~AlignedBox() {}
+
+  /** \returns the dimension in which the box holds */
+  EIGEN_DEVICE_FUNC inline Index dim() const { return AmbientDimAtCompileTime==Dynamic ? m_min.size() : Index(AmbientDimAtCompileTime); }
+
+  /** \deprecated use isEmpty() */
+  EIGEN_DEVICE_FUNC inline bool isNull() const { return isEmpty(); }
+
+  /** \deprecated use setEmpty() */
+  EIGEN_DEVICE_FUNC inline void setNull() { setEmpty(); }
+
+  /** \returns true if the box is empty.
+   * \sa setEmpty */
+  EIGEN_DEVICE_FUNC inline bool isEmpty() const { return (m_min.array() > m_max.array()).any(); }
+
+  /** Makes \c *this an empty box.
+   * \sa isEmpty */
+  EIGEN_DEVICE_FUNC inline void setEmpty()
+  {
+    m_min.setConstant( ScalarTraits::highest() );
+    m_max.setConstant( ScalarTraits::lowest() );
+  }
+
+  /** \returns the minimal corner */
+  EIGEN_DEVICE_FUNC inline const VectorType& (min)() const { return m_min; }
+  /** \returns a non const reference to the minimal corner */
+  EIGEN_DEVICE_FUNC inline VectorType& (min)() { return m_min; }
+  /** \returns the maximal corner */
+  EIGEN_DEVICE_FUNC inline const VectorType& (max)() const { return m_max; }
+  /** \returns a non const reference to the maximal corner */
+  EIGEN_DEVICE_FUNC inline VectorType& (max)() { return m_max; }
+
+  /** \returns the center of the box */
+  EIGEN_DEVICE_FUNC inline const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(VectorTypeSum, RealScalar, quotient)
+  center() const
+  { return (m_min+m_max)/RealScalar(2); }
+
+  /** \returns the lengths of the sides of the bounding box.
+    * Note that this function does not get the same
+    * result for integral or floating scalar types: see
+    */
+  EIGEN_DEVICE_FUNC inline const CwiseBinaryOp< internal::scalar_difference_op<Scalar,Scalar>, const VectorType, const VectorType> sizes() const
+  { return m_max - m_min; }
+
+  /** \returns the volume of the bounding box */
+  EIGEN_DEVICE_FUNC inline Scalar volume() const
+  { return sizes().prod(); }
+
+  /** \returns an expression for the bounding box diagonal vector
+    * if the length of the diagonal is needed: diagonal().norm()
+    * will provide it.
+    */
+  EIGEN_DEVICE_FUNC inline CwiseBinaryOp< internal::scalar_difference_op<Scalar,Scalar>, const VectorType, const VectorType> diagonal() const
+  { return sizes(); }
+
+  /** \returns the vertex of the bounding box at the corner defined by
+    * the corner-id corner. It works only for a 1D, 2D or 3D bounding box.
+    * For 1D bounding boxes corners are named by 2 enum constants:
+    * BottomLeft and BottomRight.
+    * For 2D bounding boxes, corners are named by 4 enum constants:
+    * BottomLeft, BottomRight, TopLeft, TopRight.
+    * For 3D bounding boxes, the following names are added:
+    * BottomLeftCeil, BottomRightCeil, TopLeftCeil, TopRightCeil.
+    */
+  EIGEN_DEVICE_FUNC inline VectorType corner(CornerType corner) const
+  {
+    EIGEN_STATIC_ASSERT(_AmbientDim <= 3, THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE);
+
+    VectorType res;
+
+    Index mult = 1;
+    for(Index d=0; d<dim(); ++d)
+    {
+      if( mult & corner ) res[d] = m_max[d];
+      else                res[d] = m_min[d];
+      mult *= 2;
+    }
+    return res;
+  }
+
+  /** \returns a random point inside the bounding box sampled with
+   * a uniform distribution */
+  EIGEN_DEVICE_FUNC inline VectorType sample() const
+  {
+    VectorType r(dim());
+    for(Index d=0; d<dim(); ++d)
+    {
+      if(!ScalarTraits::IsInteger)
+      {
+        r[d] = m_min[d] + (m_max[d]-m_min[d])
+             * internal::random<Scalar>(Scalar(0), Scalar(1));
+      }
+      else
+        r[d] = internal::random(m_min[d], m_max[d]);
+    }
+    return r;
+  }
+
+  /** \returns true if the point \a p is inside the box \c *this. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline bool contains(const MatrixBase<Derived>& p) const
+  {
+    typename internal::nested_eval<Derived,2>::type p_n(p.derived());
+    return (m_min.array()<=p_n.array()).all() && (p_n.array()<=m_max.array()).all();
+  }
+
+  /** \returns true if the box \a b is entirely inside the box \c *this. */
+  EIGEN_DEVICE_FUNC inline bool contains(const AlignedBox& b) const
+  { return (m_min.array()<=(b.min)().array()).all() && ((b.max)().array()<=m_max.array()).all(); }
+
+  /** \returns true if the box \a b is intersecting the box \c *this.
+   * \sa intersection, clamp */
+  EIGEN_DEVICE_FUNC inline bool intersects(const AlignedBox& b) const
+  { return (m_min.array()<=(b.max)().array()).all() && ((b.min)().array()<=m_max.array()).all(); }
+
+  /** Extends \c *this such that it contains the point \a p and returns a reference to \c *this.
+   * \sa extend(const AlignedBox&) */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline AlignedBox& extend(const MatrixBase<Derived>& p)
+  {
+    typename internal::nested_eval<Derived,2>::type p_n(p.derived());
+    m_min = m_min.cwiseMin(p_n);
+    m_max = m_max.cwiseMax(p_n);
+    return *this;
+  }
+
+  /** Extends \c *this such that it contains the box \a b and returns a reference to \c *this.
+   * \sa merged, extend(const MatrixBase&) */
+  EIGEN_DEVICE_FUNC inline AlignedBox& extend(const AlignedBox& b)
+  {
+    m_min = m_min.cwiseMin(b.m_min);
+    m_max = m_max.cwiseMax(b.m_max);
+    return *this;
+  }
+
+  /** Clamps \c *this by the box \a b and returns a reference to \c *this.
+   * \note If the boxes don't intersect, the resulting box is empty.
+   * \sa intersection(), intersects() */
+  EIGEN_DEVICE_FUNC inline AlignedBox& clamp(const AlignedBox& b)
+  {
+    m_min = m_min.cwiseMax(b.m_min);
+    m_max = m_max.cwiseMin(b.m_max);
+    return *this;
+  }
+
+  /** Returns an AlignedBox that is the intersection of \a b and \c *this
+   * \note If the boxes don't intersect, the resulting box is empty.
+   * \sa intersects(), clamp, contains()  */
+  EIGEN_DEVICE_FUNC inline AlignedBox intersection(const AlignedBox& b) const
+  {return AlignedBox(m_min.cwiseMax(b.m_min), m_max.cwiseMin(b.m_max)); }
+
+  /** Returns an AlignedBox that is the union of \a b and \c *this.
+   * \note Merging with an empty box may result in a box bigger than \c *this.
+   * \sa extend(const AlignedBox&) */
+  EIGEN_DEVICE_FUNC inline AlignedBox merged(const AlignedBox& b) const
+  { return AlignedBox(m_min.cwiseMin(b.m_min), m_max.cwiseMax(b.m_max)); }
+
+  /** Translate \c *this by the vector \a t and returns a reference to \c *this. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline AlignedBox& translate(const MatrixBase<Derived>& a_t)
+  {
+    const typename internal::nested_eval<Derived,2>::type t(a_t.derived());
+    m_min += t;
+    m_max += t;
+    return *this;
+  }
+
+  /** \returns a copy of \c *this translated by the vector \a t. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline AlignedBox translated(const MatrixBase<Derived>& a_t) const
+  {
+    AlignedBox result(m_min, m_max);
+    result.translate(a_t);
+    return result;
+  }
+
+  /** \returns the squared distance between the point \a p and the box \c *this,
+    * and zero if \a p is inside the box.
+    * \sa exteriorDistance(const MatrixBase&), squaredExteriorDistance(const AlignedBox&)
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Scalar squaredExteriorDistance(const MatrixBase<Derived>& p) const;
+
+  /** \returns the squared distance between the boxes \a b and \c *this,
+    * and zero if the boxes intersect.
+    * \sa exteriorDistance(const AlignedBox&), squaredExteriorDistance(const MatrixBase&)
+    */
+  EIGEN_DEVICE_FUNC inline Scalar squaredExteriorDistance(const AlignedBox& b) const;
+
+  /** \returns the distance between the point \a p and the box \c *this,
+    * and zero if \a p is inside the box.
+    * \sa squaredExteriorDistance(const MatrixBase&), exteriorDistance(const AlignedBox&)
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline NonInteger exteriorDistance(const MatrixBase<Derived>& p) const
+  { EIGEN_USING_STD(sqrt) return sqrt(NonInteger(squaredExteriorDistance(p))); }
+
+  /** \returns the distance between the boxes \a b and \c *this,
+    * and zero if the boxes intersect.
+    * \sa squaredExteriorDistance(const AlignedBox&), exteriorDistance(const MatrixBase&)
+    */
+  EIGEN_DEVICE_FUNC inline NonInteger exteriorDistance(const AlignedBox& b) const
+  { EIGEN_USING_STD(sqrt) return sqrt(NonInteger(squaredExteriorDistance(b))); }
+
+  /**
+   * Specialization of transform for pure translation.
+   */
+  template<int Mode, int Options>
+  EIGEN_DEVICE_FUNC inline void transform(
+      const typename Transform<Scalar, AmbientDimAtCompileTime, Mode, Options>::TranslationType& translation)
+  {
+    this->translate(translation);
+  }
+
+  /**
+   * Transforms this box by \a transform and recomputes it to
+   * still be an axis-aligned box.
+   *
+   * \note This method is provided under BSD license (see the top of this file).
+   */
+  template<int Mode, int Options>
+  EIGEN_DEVICE_FUNC inline void transform(const Transform<Scalar, AmbientDimAtCompileTime, Mode, Options>& transform)
+  {
+    // Only Affine and Isometry transforms are currently supported.
+    EIGEN_STATIC_ASSERT(Mode == Affine || Mode == AffineCompact || Mode == Isometry, THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS);
+
+    // Method adapted from FCL src/shape/geometric_shapes_utility.cpp#computeBV<AABB, Box>(...)
+    // https://github.com/flexible-collision-library/fcl/blob/fcl-0.4/src/shape/geometric_shapes_utility.cpp#L292
+    //
+    // Here's a nice explanation why it works: https://zeuxcg.org/2010/10/17/aabb-from-obb-with-component-wise-abs/
+
+    // two times rotated extent
+    const VectorType rotated_extent_2 = transform.linear().cwiseAbs() * sizes();
+    // two times new center
+    const VectorType rotated_center_2 = transform.linear() * (this->m_max + this->m_min) +
+        Scalar(2) * transform.translation();
+
+    this->m_max = (rotated_center_2 + rotated_extent_2) / Scalar(2);
+    this->m_min = (rotated_center_2 - rotated_extent_2) / Scalar(2);
+  }
+
+  /**
+   * \returns a copy of \c *this transformed by \a transform and recomputed to
+   * still be an axis-aligned box.
+   */
+  template<int Mode, int Options>
+  EIGEN_DEVICE_FUNC AlignedBox transformed(const Transform<Scalar, AmbientDimAtCompileTime, Mode, Options>& transform) const
+  {
+    AlignedBox result(m_min, m_max);
+    result.transform(transform);
+    return result;
+  }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<AlignedBox,
+           AlignedBox<NewScalarType,AmbientDimAtCompileTime> >::type cast() const
+  {
+    return typename internal::cast_return_type<AlignedBox,
+                    AlignedBox<NewScalarType,AmbientDimAtCompileTime> >::type(*this);
+  }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit AlignedBox(const AlignedBox<OtherScalarType,AmbientDimAtCompileTime>& other)
+  {
+    m_min = (other.min)().template cast<Scalar>();
+    m_max = (other.max)().template cast<Scalar>();
+  }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const AlignedBox& other, const RealScalar& prec = ScalarTraits::dummy_precision()) const
+  { return m_min.isApprox(other.m_min, prec) && m_max.isApprox(other.m_max, prec); }
+
+protected:
+
+  VectorType m_min, m_max;
+};
+
+
+
+template<typename Scalar,int AmbientDim>
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Scalar AlignedBox<Scalar,AmbientDim>::squaredExteriorDistance(const MatrixBase<Derived>& a_p) const
+{
+  typename internal::nested_eval<Derived,2*AmbientDim>::type p(a_p.derived());
+  Scalar dist2(0);
+  Scalar aux;
+  for (Index k=0; k<dim(); ++k)
+  {
+    if( m_min[k] > p[k] )
+    {
+      aux = m_min[k] - p[k];
+      dist2 += aux*aux;
+    }
+    else if( p[k] > m_max[k] )
+    {
+      aux = p[k] - m_max[k];
+      dist2 += aux*aux;
+    }
+  }
+  return dist2;
+}
+
+template<typename Scalar,int AmbientDim>
+EIGEN_DEVICE_FUNC inline Scalar AlignedBox<Scalar,AmbientDim>::squaredExteriorDistance(const AlignedBox& b) const
+{
+  Scalar dist2(0);
+  Scalar aux;
+  for (Index k=0; k<dim(); ++k)
+  {
+    if( m_min[k] > b.m_max[k] )
+    {
+      aux = m_min[k] - b.m_max[k];
+      dist2 += aux*aux;
+    }
+    else if( b.m_min[k] > m_max[k] )
+    {
+      aux = b.m_min[k] - m_max[k];
+      dist2 += aux*aux;
+    }
+  }
+  return dist2;
+}
+
+/** \defgroup alignedboxtypedefs Global aligned box typedefs
+  *
+  * \ingroup Geometry_Module
+  *
+  * Eigen defines several typedef shortcuts for most common aligned box types.
+  *
+  * The general patterns are the following:
+  *
+  * \c AlignedBoxSizeType where \c Size can be \c 1, \c 2,\c 3,\c 4 for fixed size boxes or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double.
+  *
+  * For example, \c AlignedBox3d is a fixed-size 3x3 aligned box type of doubles, and \c AlignedBoxXf is a dynamic-size aligned box of floats.
+  *
+  * \sa class AlignedBox
+  */
+
+#define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix)    \
+/** \ingroup alignedboxtypedefs */                                 \
+typedef AlignedBox<Type, Size>   AlignedBox##SizeSuffix##TypeSuffix;
+
+#define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 1, 1) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4) \
+EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Dynamic, X)
+
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(int,                  i)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(float,                f)
+EIGEN_MAKE_TYPEDEFS_ALL_SIZES(double,               d)
+
+#undef EIGEN_MAKE_TYPEDEFS_ALL_SIZES
+#undef EIGEN_MAKE_TYPEDEFS
+
+} // end namespace Eigen
+
+#endif // EIGEN_ALIGNEDBOX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/AngleAxis.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/AngleAxis.h
new file mode 100644
index 00000000..78328b6b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/AngleAxis.h
@@ -0,0 +1,247 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ANGLEAXIS_H
+#define EIGEN_ANGLEAXIS_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class AngleAxis
+  *
+  * \brief Represents a 3D rotation as a rotation angle around an arbitrary 3D axis
+  *
+  * \param _Scalar the scalar type, i.e., the type of the coefficients.
+  *
+  * \warning When setting up an AngleAxis object, the axis vector \b must \b be \b normalized.
+  *
+  * The following two typedefs are provided for convenience:
+  * \li \c AngleAxisf for \c float
+  * \li \c AngleAxisd for \c double
+  *
+  * Combined with MatrixBase::Unit{X,Y,Z}, AngleAxis can be used to easily
+  * mimic Euler-angles. Here is an example:
+  * \include AngleAxis_mimic_euler.cpp
+  * Output: \verbinclude AngleAxis_mimic_euler.out
+  *
+  * \note This class is not aimed to be used to store a rotation transformation,
+  * but rather to make easier the creation of other rotation (Quaternion, rotation Matrix)
+  * and transformation objects.
+  *
+  * \sa class Quaternion, class Transform, MatrixBase::UnitX()
+  */
+
+namespace internal {
+template<typename _Scalar> struct traits<AngleAxis<_Scalar> >
+{
+  typedef _Scalar Scalar;
+};
+}
+
+template<typename _Scalar>
+class AngleAxis : public RotationBase<AngleAxis<_Scalar>,3>
+{
+  typedef RotationBase<AngleAxis<_Scalar>,3> Base;
+
+public:
+
+  using Base::operator*;
+
+  enum { Dim = 3 };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  typedef Matrix<Scalar,3,3> Matrix3;
+  typedef Matrix<Scalar,3,1> Vector3;
+  typedef Quaternion<Scalar> QuaternionType;
+
+protected:
+
+  Vector3 m_axis;
+  Scalar m_angle;
+
+public:
+
+  /** Default constructor without initialization. */
+  EIGEN_DEVICE_FUNC AngleAxis() {}
+  /** Constructs and initialize the angle-axis rotation from an \a angle in radian
+    * and an \a axis which \b must \b be \b normalized.
+    *
+    * \warning If the \a axis vector is not normalized, then the angle-axis object
+    *          represents an invalid rotation. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC 
+  inline AngleAxis(const Scalar& angle, const MatrixBase<Derived>& axis) : m_axis(axis), m_angle(angle) {}
+  /** Constructs and initialize the angle-axis rotation from a quaternion \a q.
+    * This function implicitly normalizes the quaternion \a q.
+    */
+  template<typename QuatDerived> 
+  EIGEN_DEVICE_FUNC inline explicit AngleAxis(const QuaternionBase<QuatDerived>& q) { *this = q; }
+  /** Constructs and initialize the angle-axis rotation from a 3x3 rotation matrix. */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline explicit AngleAxis(const MatrixBase<Derived>& m) { *this = m; }
+
+  /** \returns the value of the rotation angle in radian */
+  EIGEN_DEVICE_FUNC Scalar angle() const { return m_angle; }
+  /** \returns a read-write reference to the stored angle in radian */
+  EIGEN_DEVICE_FUNC Scalar& angle() { return m_angle; }
+
+  /** \returns the rotation axis */
+  EIGEN_DEVICE_FUNC const Vector3& axis() const { return m_axis; }
+  /** \returns a read-write reference to the stored rotation axis.
+    *
+    * \warning The rotation axis must remain a \b unit vector.
+    */
+  EIGEN_DEVICE_FUNC Vector3& axis() { return m_axis; }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline QuaternionType operator* (const AngleAxis& other) const
+  { return QuaternionType(*this) * QuaternionType(other); }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline QuaternionType operator* (const QuaternionType& other) const
+  { return QuaternionType(*this) * other; }
+
+  /** Concatenates two rotations */
+  friend EIGEN_DEVICE_FUNC inline QuaternionType operator* (const QuaternionType& a, const AngleAxis& b)
+  { return a * QuaternionType(b); }
+
+  /** \returns the inverse rotation, i.e., an angle-axis with opposite rotation angle */
+  EIGEN_DEVICE_FUNC AngleAxis inverse() const
+  { return AngleAxis(-m_angle, m_axis); }
+
+  template<class QuatDerived>
+  EIGEN_DEVICE_FUNC AngleAxis& operator=(const QuaternionBase<QuatDerived>& q);
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC AngleAxis& operator=(const MatrixBase<Derived>& m);
+
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC AngleAxis& fromRotationMatrix(const MatrixBase<Derived>& m);
+  EIGEN_DEVICE_FUNC Matrix3 toRotationMatrix(void) const;
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<AngleAxis,AngleAxis<NewScalarType> >::type cast() const
+  { return typename internal::cast_return_type<AngleAxis,AngleAxis<NewScalarType> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit AngleAxis(const AngleAxis<OtherScalarType>& other)
+  {
+    m_axis = other.axis().template cast<Scalar>();
+    m_angle = Scalar(other.angle());
+  }
+
+  EIGEN_DEVICE_FUNC static inline const AngleAxis Identity() { return AngleAxis(Scalar(0), Vector3::UnitX()); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const AngleAxis& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_axis.isApprox(other.m_axis, prec) && internal::isApprox(m_angle,other.m_angle, prec); }
+};
+
+/** \ingroup Geometry_Module
+  * single precision angle-axis type */
+typedef AngleAxis<float> AngleAxisf;
+/** \ingroup Geometry_Module
+  * double precision angle-axis type */
+typedef AngleAxis<double> AngleAxisd;
+
+/** Set \c *this from a \b unit quaternion.
+  *
+  * The resulting axis is normalized, and the computed angle is in the [0,pi] range.
+  * 
+  * This function implicitly normalizes the quaternion \a q.
+  */
+template<typename Scalar>
+template<typename QuatDerived>
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const QuaternionBase<QuatDerived>& q)
+{
+  EIGEN_USING_STD(atan2)
+  EIGEN_USING_STD(abs)
+  Scalar n = q.vec().norm();
+  if(n<NumTraits<Scalar>::epsilon())
+    n = q.vec().stableNorm();
+
+  if (n != Scalar(0))
+  {
+    m_angle = Scalar(2)*atan2(n, abs(q.w()));
+    if(q.w() < Scalar(0))
+      n = -n;
+    m_axis  = q.vec() / n;
+  }
+  else
+  {
+    m_angle = Scalar(0);
+    m_axis << Scalar(1), Scalar(0), Scalar(0);
+  }
+  return *this;
+}
+
+/** Set \c *this from a 3x3 rotation matrix \a mat.
+  */
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const MatrixBase<Derived>& mat)
+{
+  // Since a direct conversion would not be really faster,
+  // let's use the robust Quaternion implementation:
+  return *this = QuaternionType(mat);
+}
+
+/**
+* \brief Sets \c *this from a 3x3 rotation matrix.
+**/
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
+{
+  return *this = QuaternionType(mat);
+}
+
+/** Constructs and \returns an equivalent 3x3 rotation matrix.
+  */
+template<typename Scalar>
+typename AngleAxis<Scalar>::Matrix3
+EIGEN_DEVICE_FUNC AngleAxis<Scalar>::toRotationMatrix(void) const
+{
+  EIGEN_USING_STD(sin)
+  EIGEN_USING_STD(cos)
+  Matrix3 res;
+  Vector3 sin_axis  = sin(m_angle) * m_axis;
+  Scalar c = cos(m_angle);
+  Vector3 cos1_axis = (Scalar(1)-c) * m_axis;
+
+  Scalar tmp;
+  tmp = cos1_axis.x() * m_axis.y();
+  res.coeffRef(0,1) = tmp - sin_axis.z();
+  res.coeffRef(1,0) = tmp + sin_axis.z();
+
+  tmp = cos1_axis.x() * m_axis.z();
+  res.coeffRef(0,2) = tmp + sin_axis.y();
+  res.coeffRef(2,0) = tmp - sin_axis.y();
+
+  tmp = cos1_axis.y() * m_axis.z();
+  res.coeffRef(1,2) = tmp - sin_axis.x();
+  res.coeffRef(2,1) = tmp + sin_axis.x();
+
+  res.diagonal() = (cos1_axis.cwiseProduct(m_axis)).array() + c;
+
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ANGLEAXIS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/EulerAngles.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/EulerAngles.h
new file mode 100644
index 00000000..19b734ca
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/EulerAngles.h
@@ -0,0 +1,114 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EULERANGLES_H
+#define EIGEN_EULERANGLES_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  *
+  * \returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (\a a0,\a a1,\a a2)
+  *
+  * Each of the three parameters \a a0,\a a1,\a a2 represents the respective rotation axis as an integer in {0,1,2}.
+  * For instance, in:
+  * \code Vector3f ea = mat.eulerAngles(2, 0, 2); \endcode
+  * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
+  * we have the following equality:
+  * \code
+  * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
+  *      * AngleAxisf(ea[1], Vector3f::UnitX())
+  *      * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode
+  * This corresponds to the right-multiply conventions (with right hand side frames).
+  * 
+  * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].
+  * 
+  * \sa class AngleAxis
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Matrix<typename MatrixBase<Derived>::Scalar,3,1>
+MatrixBase<Derived>::eulerAngles(Index a0, Index a1, Index a2) const
+{
+  EIGEN_USING_STD(atan2)
+  EIGEN_USING_STD(sin)
+  EIGEN_USING_STD(cos)
+  /* Implemented from Graphics Gems IV */
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Derived,3,3)
+
+  Matrix<Scalar,3,1> res;
+  typedef Matrix<typename Derived::Scalar,2,1> Vector2;
+
+  const Index odd = ((a0+1)%3 == a1) ? 0 : 1;
+  const Index i = a0;
+  const Index j = (a0 + 1 + odd)%3;
+  const Index k = (a0 + 2 - odd)%3;
+  
+  if (a0==a2)
+  {
+    res[0] = atan2(coeff(j,i), coeff(k,i));
+    if((odd && res[0]<Scalar(0)) || ((!odd) && res[0]>Scalar(0)))
+    {
+      if(res[0] > Scalar(0)) {
+        res[0] -= Scalar(EIGEN_PI);
+      }
+      else {
+        res[0] += Scalar(EIGEN_PI);
+      }
+      Scalar s2 = Vector2(coeff(j,i), coeff(k,i)).norm();
+      res[1] = -atan2(s2, coeff(i,i));
+    }
+    else
+    {
+      Scalar s2 = Vector2(coeff(j,i), coeff(k,i)).norm();
+      res[1] = atan2(s2, coeff(i,i));
+    }
+    
+    // With a=(0,1,0), we have i=0; j=1; k=2, and after computing the first two angles,
+    // we can compute their respective rotation, and apply its inverse to M. Since the result must
+    // be a rotation around x, we have:
+    //
+    //  c2  s1.s2 c1.s2                   1  0   0 
+    //  0   c1    -s1       *    M    =   0  c3  s3
+    //  -s2 s1.c2 c1.c2                   0 -s3  c3
+    //
+    //  Thus:  m11.c1 - m21.s1 = c3  &   m12.c1 - m22.s1 = s3
+    
+    Scalar s1 = sin(res[0]);
+    Scalar c1 = cos(res[0]);
+    res[2] = atan2(c1*coeff(j,k)-s1*coeff(k,k), c1*coeff(j,j) - s1 * coeff(k,j));
+  } 
+  else
+  {
+    res[0] = atan2(coeff(j,k), coeff(k,k));
+    Scalar c2 = Vector2(coeff(i,i), coeff(i,j)).norm();
+    if((odd && res[0]<Scalar(0)) || ((!odd) && res[0]>Scalar(0))) {
+      if(res[0] > Scalar(0)) {
+        res[0] -= Scalar(EIGEN_PI);
+      }
+      else {
+        res[0] += Scalar(EIGEN_PI);
+      }
+      res[1] = atan2(-coeff(i,k), -c2);
+    }
+    else
+      res[1] = atan2(-coeff(i,k), c2);
+    Scalar s1 = sin(res[0]);
+    Scalar c1 = cos(res[0]);
+    res[2] = atan2(s1*coeff(k,i)-c1*coeff(j,i), c1*coeff(j,j) - s1 * coeff(k,j));
+  }
+  if (!odd)
+    res = -res;
+  
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_EULERANGLES_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Homogeneous.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Homogeneous.h
new file mode 100644
index 00000000..94083ac5
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Homogeneous.h
@@ -0,0 +1,501 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOMOGENEOUS_H
+#define EIGEN_HOMOGENEOUS_H
+
+namespace Eigen {
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Homogeneous
+  *
+  * \brief Expression of one (or a set of) homogeneous vector(s)
+  *
+  * \param MatrixType the type of the object in which we are making homogeneous
+  *
+  * This class represents an expression of one (or a set of) homogeneous vector(s).
+  * It is the return type of MatrixBase::homogeneous() and most of the time
+  * this is the only way it is used.
+  *
+  * \sa MatrixBase::homogeneous()
+  */
+
+namespace internal {
+
+template<typename MatrixType,int Direction>
+struct traits<Homogeneous<MatrixType,Direction> >
+ : traits<MatrixType>
+{
+  typedef typename traits<MatrixType>::StorageKind StorageKind;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    RowsPlusOne = (MatrixType::RowsAtCompileTime != Dynamic) ?
+                  int(MatrixType::RowsAtCompileTime) + 1 : Dynamic,
+    ColsPlusOne = (MatrixType::ColsAtCompileTime != Dynamic) ?
+                  int(MatrixType::ColsAtCompileTime) + 1 : Dynamic,
+    RowsAtCompileTime = Direction==Vertical  ?  RowsPlusOne : MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = Direction==Horizontal ? ColsPlusOne : MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    TmpFlags = _MatrixTypeNested::Flags & HereditaryBits,
+    Flags = ColsAtCompileTime==1 ? (TmpFlags & ~RowMajorBit)
+          : RowsAtCompileTime==1 ? (TmpFlags | RowMajorBit)
+          : TmpFlags
+  };
+};
+
+template<typename MatrixType,typename Lhs> struct homogeneous_left_product_impl;
+template<typename MatrixType,typename Rhs> struct homogeneous_right_product_impl;
+
+} // end namespace internal
+
+template<typename MatrixType,int _Direction> class Homogeneous
+  : public MatrixBase<Homogeneous<MatrixType,_Direction> >, internal::no_assignment_operator
+{
+  public:
+
+    typedef MatrixType NestedExpression;
+    enum { Direction = _Direction };
+
+    typedef MatrixBase<Homogeneous> Base;
+    EIGEN_DENSE_PUBLIC_INTERFACE(Homogeneous)
+
+    EIGEN_DEVICE_FUNC explicit inline Homogeneous(const MatrixType& matrix)
+      : m_matrix(matrix)
+    {}
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows() + (int(Direction)==Vertical   ? 1 : 0); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols() + (int(Direction)==Horizontal ? 1 : 0); }
+
+    EIGEN_DEVICE_FUNC const NestedExpression& nestedExpression() const { return m_matrix; }
+
+    template<typename Rhs>
+    EIGEN_DEVICE_FUNC inline const Product<Homogeneous,Rhs>
+    operator* (const MatrixBase<Rhs>& rhs) const
+    {
+      eigen_assert(int(Direction)==Horizontal);
+      return Product<Homogeneous,Rhs>(*this,rhs.derived());
+    }
+
+    template<typename Lhs> friend
+    EIGEN_DEVICE_FUNC inline const Product<Lhs,Homogeneous>
+    operator* (const MatrixBase<Lhs>& lhs, const Homogeneous& rhs)
+    {
+      eigen_assert(int(Direction)==Vertical);
+      return Product<Lhs,Homogeneous>(lhs.derived(),rhs);
+    }
+
+    template<typename Scalar, int Dim, int Mode, int Options> friend
+    EIGEN_DEVICE_FUNC inline const Product<Transform<Scalar,Dim,Mode,Options>, Homogeneous >
+    operator* (const Transform<Scalar,Dim,Mode,Options>& lhs, const Homogeneous& rhs)
+    {
+      eigen_assert(int(Direction)==Vertical);
+      return Product<Transform<Scalar,Dim,Mode,Options>, Homogeneous>(lhs,rhs);
+    }
+
+    template<typename Func>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::result_of<Func(Scalar,Scalar)>::type
+    redux(const Func& func) const
+    {
+      return func(m_matrix.redux(func), Scalar(1));
+    }
+
+  protected:
+    typename MatrixType::Nested m_matrix;
+};
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns a vector expression that is one longer than the vector argument, with the value 1 symbolically appended as the last coefficient.
+  *
+  * This can be used to convert affine coordinates to homogeneous coordinates.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include MatrixBase_homogeneous.cpp
+  * Output: \verbinclude MatrixBase_homogeneous.out
+  *
+  * \sa VectorwiseOp::homogeneous(), class Homogeneous
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::HomogeneousReturnType
+MatrixBase<Derived>::homogeneous() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return HomogeneousReturnType(derived());
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns an expression where the value 1 is symbolically appended as the final coefficient to each column (or row) of the matrix.
+  *
+  * This can be used to convert affine coordinates to homogeneous coordinates.
+  *
+  * Example: \include VectorwiseOp_homogeneous.cpp
+  * Output: \verbinclude VectorwiseOp_homogeneous.out
+  *
+  * \sa MatrixBase::homogeneous(), class Homogeneous */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC inline Homogeneous<ExpressionType,Direction>
+VectorwiseOp<ExpressionType,Direction>::homogeneous() const
+{
+  return HomogeneousReturnType(_expression());
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \brief homogeneous normalization
+  *
+  * \returns a vector expression of the N-1 first coefficients of \c *this divided by that last coefficient.
+  *
+  * This can be used to convert homogeneous coordinates to affine coordinates.
+  *
+  * It is essentially a shortcut for:
+  * \code
+    this->head(this->size()-1)/this->coeff(this->size()-1);
+    \endcode
+  *
+  * Example: \include MatrixBase_hnormalized.cpp
+  * Output: \verbinclude MatrixBase_hnormalized.out
+  *
+  * \sa VectorwiseOp::hnormalized() */
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline const typename MatrixBase<Derived>::HNormalizedReturnType
+MatrixBase<Derived>::hnormalized() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+  return ConstStartMinusOne(derived(),0,0,
+    ColsAtCompileTime==1?size()-1:1,
+    ColsAtCompileTime==1?1:size()-1) / coeff(size()-1);
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \brief column or row-wise homogeneous normalization
+  *
+  * \returns an expression of the first N-1 coefficients of each column (or row) of \c *this divided by the last coefficient of each column (or row).
+  *
+  * This can be used to convert homogeneous coordinates to affine coordinates.
+  *
+  * It is conceptually equivalent to calling MatrixBase::hnormalized() to each column (or row) of \c *this.
+  *
+  * Example: \include DirectionWise_hnormalized.cpp
+  * Output: \verbinclude DirectionWise_hnormalized.out
+  *
+  * \sa MatrixBase::hnormalized() */
+template<typename ExpressionType, int Direction>
+EIGEN_DEVICE_FUNC inline const typename VectorwiseOp<ExpressionType,Direction>::HNormalizedReturnType
+VectorwiseOp<ExpressionType,Direction>::hnormalized() const
+{
+  return HNormalized_Block(_expression(),0,0,
+      Direction==Vertical   ? _expression().rows()-1 : _expression().rows(),
+      Direction==Horizontal ? _expression().cols()-1 : _expression().cols()).cwiseQuotient(
+      Replicate<HNormalized_Factors,
+                Direction==Vertical   ? HNormalized_SizeMinusOne : 1,
+                Direction==Horizontal ? HNormalized_SizeMinusOne : 1>
+        (HNormalized_Factors(_expression(),
+          Direction==Vertical    ? _expression().rows()-1:0,
+          Direction==Horizontal  ? _expression().cols()-1:0,
+          Direction==Vertical    ? 1 : _expression().rows(),
+          Direction==Horizontal  ? 1 : _expression().cols()),
+         Direction==Vertical   ? _expression().rows()-1 : 1,
+         Direction==Horizontal ? _expression().cols()-1 : 1));
+}
+
+namespace internal {
+
+template<typename MatrixOrTransformType>
+struct take_matrix_for_product
+{
+  typedef MatrixOrTransformType type;
+  EIGEN_DEVICE_FUNC static const type& run(const type &x) { return x; }
+};
+
+template<typename Scalar, int Dim, int Mode,int Options>
+struct take_matrix_for_product<Transform<Scalar, Dim, Mode, Options> >
+{
+  typedef Transform<Scalar, Dim, Mode, Options> TransformType;
+  typedef typename internal::add_const<typename TransformType::ConstAffinePart>::type type;
+  EIGEN_DEVICE_FUNC static type run (const TransformType& x) { return x.affine(); }
+};
+
+template<typename Scalar, int Dim, int Options>
+struct take_matrix_for_product<Transform<Scalar, Dim, Projective, Options> >
+{
+  typedef Transform<Scalar, Dim, Projective, Options> TransformType;
+  typedef typename TransformType::MatrixType type;
+  EIGEN_DEVICE_FUNC static const type& run (const TransformType& x) { return x.matrix(); }
+};
+
+template<typename MatrixType,typename Lhs>
+struct traits<homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> >
+{
+  typedef typename take_matrix_for_product<Lhs>::type LhsMatrixType;
+  typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+  typedef typename remove_all<LhsMatrixType>::type LhsMatrixTypeCleaned;
+  typedef typename make_proper_matrix_type<
+                 typename traits<MatrixTypeCleaned>::Scalar,
+                 LhsMatrixTypeCleaned::RowsAtCompileTime,
+                 MatrixTypeCleaned::ColsAtCompileTime,
+                 MatrixTypeCleaned::PlainObject::Options,
+                 LhsMatrixTypeCleaned::MaxRowsAtCompileTime,
+                 MatrixTypeCleaned::MaxColsAtCompileTime>::type ReturnType;
+};
+
+template<typename MatrixType,typename Lhs>
+struct homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs>
+  : public ReturnByValue<homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> >
+{
+  typedef typename traits<homogeneous_left_product_impl>::LhsMatrixType LhsMatrixType;
+  typedef typename remove_all<LhsMatrixType>::type LhsMatrixTypeCleaned;
+  typedef typename remove_all<typename LhsMatrixTypeCleaned::Nested>::type LhsMatrixTypeNested;
+  EIGEN_DEVICE_FUNC homogeneous_left_product_impl(const Lhs& lhs, const MatrixType& rhs)
+    : m_lhs(take_matrix_for_product<Lhs>::run(lhs)),
+      m_rhs(rhs)
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  inline Index rows() const EIGEN_NOEXCEPT { return m_lhs.rows(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  inline Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+  template<typename Dest> EIGEN_DEVICE_FUNC void evalTo(Dest& dst) const
+  {
+    // FIXME investigate how to allow lazy evaluation of this product when possible
+    dst = Block<const LhsMatrixTypeNested,
+              LhsMatrixTypeNested::RowsAtCompileTime,
+              LhsMatrixTypeNested::ColsAtCompileTime==Dynamic?Dynamic:LhsMatrixTypeNested::ColsAtCompileTime-1>
+            (m_lhs,0,0,m_lhs.rows(),m_lhs.cols()-1) * m_rhs;
+    dst += m_lhs.col(m_lhs.cols()-1).rowwise()
+            .template replicate<MatrixType::ColsAtCompileTime>(m_rhs.cols());
+  }
+
+  typename LhsMatrixTypeCleaned::Nested m_lhs;
+  typename MatrixType::Nested m_rhs;
+};
+
+template<typename MatrixType,typename Rhs>
+struct traits<homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> >
+{
+  typedef typename make_proper_matrix_type<typename traits<MatrixType>::Scalar,
+                 MatrixType::RowsAtCompileTime,
+                 Rhs::ColsAtCompileTime,
+                 MatrixType::PlainObject::Options,
+                 MatrixType::MaxRowsAtCompileTime,
+                 Rhs::MaxColsAtCompileTime>::type ReturnType;
+};
+
+template<typename MatrixType,typename Rhs>
+struct homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs>
+  : public ReturnByValue<homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> >
+{
+  typedef typename remove_all<typename Rhs::Nested>::type RhsNested;
+  EIGEN_DEVICE_FUNC homogeneous_right_product_impl(const MatrixType& lhs, const Rhs& rhs)
+    : m_lhs(lhs), m_rhs(rhs)
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index rows() const EIGEN_NOEXCEPT { return m_lhs.rows(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+  template<typename Dest> EIGEN_DEVICE_FUNC void evalTo(Dest& dst) const
+  {
+    // FIXME investigate how to allow lazy evaluation of this product when possible
+    dst = m_lhs * Block<const RhsNested,
+                        RhsNested::RowsAtCompileTime==Dynamic?Dynamic:RhsNested::RowsAtCompileTime-1,
+                        RhsNested::ColsAtCompileTime>
+            (m_rhs,0,0,m_rhs.rows()-1,m_rhs.cols());
+    dst += m_rhs.row(m_rhs.rows()-1).colwise()
+            .template replicate<MatrixType::RowsAtCompileTime>(m_lhs.rows());
+  }
+
+  typename MatrixType::Nested m_lhs;
+  typename Rhs::Nested m_rhs;
+};
+
+template<typename ArgType,int Direction>
+struct evaluator_traits<Homogeneous<ArgType,Direction> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename ArgType::StorageKind>::Kind Kind;
+  typedef HomogeneousShape Shape;
+};
+
+template<> struct AssignmentKind<DenseShape,HomogeneousShape> { typedef Dense2Dense Kind; };
+
+
+template<typename ArgType,int Direction>
+struct unary_evaluator<Homogeneous<ArgType,Direction>, IndexBased>
+  : evaluator<typename Homogeneous<ArgType,Direction>::PlainObject >
+{
+  typedef Homogeneous<ArgType,Direction> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
+    : Base(), m_temp(op)
+  {
+    ::new (static_cast<Base*>(this)) Base(m_temp);
+  }
+
+protected:
+  PlainObject m_temp;
+};
+
+// dense = homogeneous
+template< typename DstXprType, typename ArgType, typename Scalar>
+struct Assignment<DstXprType, Homogeneous<ArgType,Vertical>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense>
+{
+  typedef Homogeneous<ArgType,Vertical> SrcXprType;
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst.template topRows<ArgType::RowsAtCompileTime>(src.nestedExpression().rows()) = src.nestedExpression();
+    dst.row(dst.rows()-1).setOnes();
+  }
+};
+
+// dense = homogeneous
+template< typename DstXprType, typename ArgType, typename Scalar>
+struct Assignment<DstXprType, Homogeneous<ArgType,Horizontal>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense>
+{
+  typedef Homogeneous<ArgType,Horizontal> SrcXprType;
+  EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst.template leftCols<ArgType::ColsAtCompileTime>(src.nestedExpression().cols()) = src.nestedExpression();
+    dst.col(dst.cols()-1).setOnes();
+  }
+};
+
+template<typename LhsArg, typename Rhs, int ProductTag>
+struct generic_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs, HomogeneousShape, DenseShape, ProductTag>
+{
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const Homogeneous<LhsArg,Horizontal>& lhs, const Rhs& rhs)
+  {
+    homogeneous_right_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs>(lhs.nestedExpression(), rhs).evalTo(dst);
+  }
+};
+
+template<typename Lhs,typename Rhs>
+struct homogeneous_right_product_refactoring_helper
+{
+  enum {
+    Dim  = Lhs::ColsAtCompileTime,
+    Rows = Lhs::RowsAtCompileTime
+  };
+  typedef typename Rhs::template ConstNRowsBlockXpr<Dim>::Type          LinearBlockConst;
+  typedef typename remove_const<LinearBlockConst>::type                 LinearBlock;
+  typedef typename Rhs::ConstRowXpr                                     ConstantColumn;
+  typedef Replicate<const ConstantColumn,Rows,1>                        ConstantBlock;
+  typedef Product<Lhs,LinearBlock,LazyProduct>                          LinearProduct;
+  typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, HomogeneousShape, DenseShape>
+ : public evaluator<typename homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs>::Xpr>
+{
+  typedef Product<Lhs, Rhs, LazyProduct> XprType;
+  typedef homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs> helper;
+  typedef typename helper::ConstantBlock ConstantBlock;
+  typedef typename helper::Xpr RefactoredXpr;
+  typedef evaluator<RefactoredXpr> Base;
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(  xpr.lhs().nestedExpression() .lazyProduct(  xpr.rhs().template topRows<helper::Dim>(xpr.lhs().nestedExpression().cols()) )
+            + ConstantBlock(xpr.rhs().row(xpr.rhs().rows()-1),xpr.lhs().rows(), 1) )
+  {}
+};
+
+template<typename Lhs, typename RhsArg, int ProductTag>
+struct generic_product_impl<Lhs, Homogeneous<RhsArg,Vertical>, DenseShape, HomogeneousShape, ProductTag>
+{
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const Lhs& lhs, const Homogeneous<RhsArg,Vertical>& rhs)
+  {
+    homogeneous_left_product_impl<Homogeneous<RhsArg,Vertical>, Lhs>(lhs, rhs.nestedExpression()).evalTo(dst);
+  }
+};
+
+// TODO: the following specialization is to address a regression from 3.2 to 3.3
+// In the future, this path should be optimized.
+template<typename Lhs, typename RhsArg, int ProductTag>
+struct generic_product_impl<Lhs, Homogeneous<RhsArg,Vertical>, TriangularShape, HomogeneousShape, ProductTag>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Homogeneous<RhsArg,Vertical>& rhs)
+  {
+    dst.noalias() = lhs * rhs.eval();
+  }
+};
+
+template<typename Lhs,typename Rhs>
+struct homogeneous_left_product_refactoring_helper
+{
+  enum {
+    Dim = Rhs::RowsAtCompileTime,
+    Cols = Rhs::ColsAtCompileTime
+  };
+  typedef typename Lhs::template ConstNColsBlockXpr<Dim>::Type          LinearBlockConst;
+  typedef typename remove_const<LinearBlockConst>::type                 LinearBlock;
+  typedef typename Lhs::ConstColXpr                                     ConstantColumn;
+  typedef Replicate<const ConstantColumn,1,Cols>                        ConstantBlock;
+  typedef Product<LinearBlock,Rhs,LazyProduct>                          LinearProduct;
+  typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr;
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, HomogeneousShape>
+ : public evaluator<typename homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression>::Xpr>
+{
+  typedef Product<Lhs, Rhs, LazyProduct> XprType;
+  typedef homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression> helper;
+  typedef typename helper::ConstantBlock ConstantBlock;
+  typedef typename helper::Xpr RefactoredXpr;
+  typedef evaluator<RefactoredXpr> Base;
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+    : Base(   xpr.lhs().template leftCols<helper::Dim>(xpr.rhs().nestedExpression().rows()) .lazyProduct( xpr.rhs().nestedExpression() )
+            + ConstantBlock(xpr.lhs().col(xpr.lhs().cols()-1),1,xpr.rhs().cols()) )
+  {}
+};
+
+template<typename Scalar, int Dim, int Mode,int Options, typename RhsArg, int ProductTag>
+struct generic_product_impl<Transform<Scalar,Dim,Mode,Options>, Homogeneous<RhsArg,Vertical>, DenseShape, HomogeneousShape, ProductTag>
+{
+  typedef Transform<Scalar,Dim,Mode,Options> TransformType;
+  template<typename Dest>
+  EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const TransformType& lhs, const Homogeneous<RhsArg,Vertical>& rhs)
+  {
+    homogeneous_left_product_impl<Homogeneous<RhsArg,Vertical>, TransformType>(lhs, rhs.nestedExpression()).evalTo(dst);
+  }
+};
+
+template<typename ExpressionType, int Side, bool Transposed>
+struct permutation_matrix_product<ExpressionType, Side, Transposed, HomogeneousShape>
+  : public permutation_matrix_product<ExpressionType, Side, Transposed, DenseShape>
+{};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_HOMOGENEOUS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Hyperplane.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Hyperplane.h
new file mode 100644
index 00000000..cebe0355
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Hyperplane.h
@@ -0,0 +1,282 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HYPERPLANE_H
+#define EIGEN_HYPERPLANE_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Hyperplane
+  *
+  * \brief A hyperplane
+  *
+  * A hyperplane is an affine subspace of dimension n-1 in a space of dimension n.
+  * For example, a hyperplane in a plane is a line; a hyperplane in 3-space is a plane.
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
+  *             Notice that the dimension of the hyperplane is _AmbientDim-1.
+  *
+  * This class represents an hyperplane as the zero set of the implicit equation
+  * \f$ n \cdot x + d = 0 \f$ where \f$ n \f$ is a unit normal vector of the plane (linear part)
+  * and \f$ d \f$ is the distance (offset) to the origin.
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+class Hyperplane
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
+  enum {
+    AmbientDimAtCompileTime = _AmbientDim,
+    Options = _Options
+  };
+  typedef _Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  typedef Matrix<Scalar,AmbientDimAtCompileTime,1> VectorType;
+  typedef Matrix<Scalar,Index(AmbientDimAtCompileTime)==Dynamic
+                        ? Dynamic
+                        : Index(AmbientDimAtCompileTime)+1,1,Options> Coefficients;
+  typedef Block<Coefficients,AmbientDimAtCompileTime,1> NormalReturnType;
+  typedef const Block<const Coefficients,AmbientDimAtCompileTime,1> ConstNormalReturnType;
+
+  /** Default constructor without initialization */
+  EIGEN_DEVICE_FUNC inline Hyperplane() {}
+  
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC Hyperplane(const Hyperplane<Scalar,AmbientDimAtCompileTime,OtherOptions>& other)
+   : m_coeffs(other.coeffs())
+  {}
+
+  /** Constructs a dynamic-size hyperplane with \a _dim the dimension
+    * of the ambient space */
+  EIGEN_DEVICE_FUNC inline explicit Hyperplane(Index _dim) : m_coeffs(_dim+1) {}
+
+  /** Construct a plane from its normal \a n and a point \a e onto the plane.
+    * \warning the vector normal is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC inline Hyperplane(const VectorType& n, const VectorType& e)
+    : m_coeffs(n.size()+1)
+  {
+    normal() = n;
+    offset() = -n.dot(e);
+  }
+
+  /** Constructs a plane from its normal \a n and distance to the origin \a d
+    * such that the algebraic equation of the plane is \f$ n \cdot x + d = 0 \f$.
+    * \warning the vector normal is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC inline Hyperplane(const VectorType& n, const Scalar& d)
+    : m_coeffs(n.size()+1)
+  {
+    normal() = n;
+    offset() = d;
+  }
+
+  /** Constructs a hyperplane passing through the two points. If the dimension of the ambient space
+    * is greater than 2, then there isn't uniqueness, so an arbitrary choice is made.
+    */
+  EIGEN_DEVICE_FUNC static inline Hyperplane Through(const VectorType& p0, const VectorType& p1)
+  {
+    Hyperplane result(p0.size());
+    result.normal() = (p1 - p0).unitOrthogonal();
+    result.offset() = -p0.dot(result.normal());
+    return result;
+  }
+
+  /** Constructs a hyperplane passing through the three points. The dimension of the ambient space
+    * is required to be exactly 3.
+    */
+  EIGEN_DEVICE_FUNC static inline Hyperplane Through(const VectorType& p0, const VectorType& p1, const VectorType& p2)
+  {
+    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 3)
+    Hyperplane result(p0.size());
+    VectorType v0(p2 - p0), v1(p1 - p0);
+    result.normal() = v0.cross(v1);
+    RealScalar norm = result.normal().norm();
+    if(norm <= v0.norm() * v1.norm() * NumTraits<RealScalar>::epsilon())
+    {
+      Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();
+      JacobiSVD<Matrix<Scalar,2,3> > svd(m, ComputeFullV);
+      result.normal() = svd.matrixV().col(2);
+    }
+    else
+      result.normal() /= norm;
+    result.offset() = -p0.dot(result.normal());
+    return result;
+  }
+
+  /** Constructs a hyperplane passing through the parametrized line \a parametrized.
+    * If the dimension of the ambient space is greater than 2, then there isn't uniqueness,
+    * so an arbitrary choice is made.
+    */
+  // FIXME to be consistent with the rest this could be implemented as a static Through function ??
+  EIGEN_DEVICE_FUNC explicit Hyperplane(const ParametrizedLine<Scalar, AmbientDimAtCompileTime>& parametrized)
+  {
+    normal() = parametrized.direction().unitOrthogonal();
+    offset() = -parametrized.origin().dot(normal());
+  }
+
+  EIGEN_DEVICE_FUNC ~Hyperplane() {}
+
+  /** \returns the dimension in which the plane holds */
+  EIGEN_DEVICE_FUNC inline Index dim() const { return AmbientDimAtCompileTime==Dynamic ? m_coeffs.size()-1 : Index(AmbientDimAtCompileTime); }
+
+  /** normalizes \c *this */
+  EIGEN_DEVICE_FUNC void normalize(void)
+  {
+    m_coeffs /= normal().norm();
+  }
+
+  /** \returns the signed distance between the plane \c *this and a point \a p.
+    * \sa absDistance()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar signedDistance(const VectorType& p) const { return normal().dot(p) + offset(); }
+
+  /** \returns the absolute distance between the plane \c *this and a point \a p.
+    * \sa signedDistance()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar absDistance(const VectorType& p) const { return numext::abs(signedDistance(p)); }
+
+  /** \returns the projection of a point \a p onto the plane \c *this.
+    */
+  EIGEN_DEVICE_FUNC inline VectorType projection(const VectorType& p) const { return p - signedDistance(p) * normal(); }
+
+  /** \returns a constant reference to the unit normal vector of the plane, which corresponds
+    * to the linear part of the implicit equation.
+    */
+  EIGEN_DEVICE_FUNC inline ConstNormalReturnType normal() const { return ConstNormalReturnType(m_coeffs,0,0,dim(),1); }
+
+  /** \returns a non-constant reference to the unit normal vector of the plane, which corresponds
+    * to the linear part of the implicit equation.
+    */
+  EIGEN_DEVICE_FUNC inline NormalReturnType normal() { return NormalReturnType(m_coeffs,0,0,dim(),1); }
+
+  /** \returns the distance to the origin, which is also the "constant term" of the implicit equation
+    * \warning the vector normal is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC inline const Scalar& offset() const { return m_coeffs.coeff(dim()); }
+
+  /** \returns a non-constant reference to the distance to the origin, which is also the constant part
+    * of the implicit equation */
+  EIGEN_DEVICE_FUNC inline Scalar& offset() { return m_coeffs(dim()); }
+
+  /** \returns a constant reference to the coefficients c_i of the plane equation:
+    * \f$ c_0*x_0 + ... + c_{d-1}*x_{d-1} + c_d = 0 \f$
+    */
+  EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs; }
+
+  /** \returns a non-constant reference to the coefficients c_i of the plane equation:
+    * \f$ c_0*x_0 + ... + c_{d-1}*x_{d-1} + c_d = 0 \f$
+    */
+  EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
+
+  /** \returns the intersection of *this with \a other.
+    *
+    * \warning The ambient space must be a plane, i.e. have dimension 2, so that \c *this and \a other are lines.
+    *
+    * \note If \a other is approximately parallel to *this, this method will return any point on *this.
+    */
+  EIGEN_DEVICE_FUNC VectorType intersection(const Hyperplane& other) const
+  {
+    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)
+    Scalar det = coeffs().coeff(0) * other.coeffs().coeff(1) - coeffs().coeff(1) * other.coeffs().coeff(0);
+    // since the line equations ax+by=c are normalized with a^2+b^2=1, the following tests
+    // whether the two lines are approximately parallel.
+    if(internal::isMuchSmallerThan(det, Scalar(1)))
+    {   // special case where the two lines are approximately parallel. Pick any point on the first line.
+        if(numext::abs(coeffs().coeff(1))>numext::abs(coeffs().coeff(0)))
+            return VectorType(coeffs().coeff(1), -coeffs().coeff(2)/coeffs().coeff(1)-coeffs().coeff(0));
+        else
+            return VectorType(-coeffs().coeff(2)/coeffs().coeff(0)-coeffs().coeff(1), coeffs().coeff(0));
+    }
+    else
+    {   // general case
+        Scalar invdet = Scalar(1) / det;
+        return VectorType(invdet*(coeffs().coeff(1)*other.coeffs().coeff(2)-other.coeffs().coeff(1)*coeffs().coeff(2)),
+                          invdet*(other.coeffs().coeff(0)*coeffs().coeff(2)-coeffs().coeff(0)*other.coeffs().coeff(2)));
+    }
+  }
+
+  /** Applies the transformation matrix \a mat to \c *this and returns a reference to \c *this.
+    *
+    * \param mat the Dim x Dim transformation matrix
+    * \param traits specifies whether the matrix \a mat represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    */
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC inline Hyperplane& transform(const MatrixBase<XprType>& mat, TransformTraits traits = Affine)
+  {
+    if (traits==Affine)
+    {
+      normal() = mat.inverse().transpose() * normal();
+      m_coeffs /= normal().norm();
+    }
+    else if (traits==Isometry)
+      normal() = mat * normal();
+    else
+    {
+      eigen_assert(0 && "invalid traits value in Hyperplane::transform()");
+    }
+    return *this;
+  }
+
+  /** Applies the transformation \a t to \c *this and returns a reference to \c *this.
+    *
+    * \param t the transformation of dimension Dim
+    * \param traits specifies whether the transformation \a t represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    *               Other kind of transformations are not supported.
+    */
+  template<int TrOptions>
+  EIGEN_DEVICE_FUNC inline Hyperplane& transform(const Transform<Scalar,AmbientDimAtCompileTime,Affine,TrOptions>& t,
+                                TransformTraits traits = Affine)
+  {
+    transform(t.linear(), traits);
+    offset() -= normal().dot(t.translation());
+    return *this;
+  }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Hyperplane,
+           Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type cast() const
+  {
+    return typename internal::cast_return_type<Hyperplane,
+                    Hyperplane<NewScalarType,AmbientDimAtCompileTime,Options> >::type(*this);
+  }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline explicit Hyperplane(const Hyperplane<OtherScalarType,AmbientDimAtCompileTime,OtherOptions>& other)
+  { m_coeffs = other.coeffs().template cast<Scalar>(); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC bool isApprox(const Hyperplane<Scalar,AmbientDimAtCompileTime,OtherOptions>& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_coeffs.isApprox(other.m_coeffs, prec); }
+
+protected:
+
+  Coefficients m_coeffs;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_HYPERPLANE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/OrthoMethods.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/OrthoMethods.h
new file mode 100644
index 00000000..524aebe1
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/OrthoMethods.h
@@ -0,0 +1,235 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ORTHOMETHODS_H
+#define EIGEN_ORTHOMETHODS_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns the cross product of \c *this and \a other
+  *
+  * Here is a very good explanation of cross-product: http://xkcd.com/199/
+  * 
+  * With complex numbers, the cross product is implemented as
+  * \f$ (\mathbf{a}+i\mathbf{b}) \times (\mathbf{c}+i\mathbf{d}) = (\mathbf{a} \times \mathbf{c} - \mathbf{b} \times \mathbf{d}) - i(\mathbf{a} \times \mathbf{d} - \mathbf{b} \times \mathbf{c})\f$
+  * 
+  * \sa MatrixBase::cross3()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename MatrixBase<Derived>::template cross_product_return_type<OtherDerived>::type
+#else
+typename MatrixBase<Derived>::PlainObject
+#endif
+MatrixBase<Derived>::cross(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived,3)
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3)
+
+  // Note that there is no need for an expression here since the compiler
+  // optimize such a small temporary very well (even within a complex expression)
+  typename internal::nested_eval<Derived,2>::type lhs(derived());
+  typename internal::nested_eval<OtherDerived,2>::type rhs(other.derived());
+  return typename cross_product_return_type<OtherDerived>::type(
+    numext::conj(lhs.coeff(1) * rhs.coeff(2) - lhs.coeff(2) * rhs.coeff(1)),
+    numext::conj(lhs.coeff(2) * rhs.coeff(0) - lhs.coeff(0) * rhs.coeff(2)),
+    numext::conj(lhs.coeff(0) * rhs.coeff(1) - lhs.coeff(1) * rhs.coeff(0))
+  );
+}
+
+namespace internal {
+
+template< int Arch,typename VectorLhs,typename VectorRhs,
+          typename Scalar = typename VectorLhs::Scalar,
+          bool Vectorizable = bool((VectorLhs::Flags&VectorRhs::Flags)&PacketAccessBit)>
+struct cross3_impl {
+  EIGEN_DEVICE_FUNC static inline typename internal::plain_matrix_type<VectorLhs>::type
+  run(const VectorLhs& lhs, const VectorRhs& rhs)
+  {
+    return typename internal::plain_matrix_type<VectorLhs>::type(
+      numext::conj(lhs.coeff(1) * rhs.coeff(2) - lhs.coeff(2) * rhs.coeff(1)),
+      numext::conj(lhs.coeff(2) * rhs.coeff(0) - lhs.coeff(0) * rhs.coeff(2)),
+      numext::conj(lhs.coeff(0) * rhs.coeff(1) - lhs.coeff(1) * rhs.coeff(0)),
+      0
+    );
+  }
+};
+
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns the cross product of \c *this and \a other using only the x, y, and z coefficients
+  *
+  * The size of \c *this and \a other must be four. This function is especially useful
+  * when using 4D vectors instead of 3D ones to get advantage of SSE/AltiVec vectorization.
+  *
+  * \sa MatrixBase::cross()
+  */
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::cross3(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived,4)
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,4)
+
+  typedef typename internal::nested_eval<Derived,2>::type DerivedNested;
+  typedef typename internal::nested_eval<OtherDerived,2>::type OtherDerivedNested;
+  DerivedNested lhs(derived());
+  OtherDerivedNested rhs(other.derived());
+
+  return internal::cross3_impl<Architecture::Target,
+                        typename internal::remove_all<DerivedNested>::type,
+                        typename internal::remove_all<OtherDerivedNested>::type>::run(lhs,rhs);
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns a matrix expression of the cross product of each column or row
+  * of the referenced expression with the \a other vector.
+  *
+  * The referenced matrix must have one dimension equal to 3.
+  * The result matrix has the same dimensions than the referenced one.
+  *
+  * \sa MatrixBase::cross() */
+template<typename ExpressionType, int Direction>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC 
+const typename VectorwiseOp<ExpressionType,Direction>::CrossReturnType
+VectorwiseOp<ExpressionType,Direction>::cross(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  
+  typename internal::nested_eval<ExpressionType,2>::type mat(_expression());
+  typename internal::nested_eval<OtherDerived,2>::type vec(other.derived());
+
+  CrossReturnType res(_expression().rows(),_expression().cols());
+  if(Direction==Vertical)
+  {
+    eigen_assert(CrossReturnType::RowsAtCompileTime==3 && "the matrix must have exactly 3 rows");
+    res.row(0) = (mat.row(1) * vec.coeff(2) - mat.row(2) * vec.coeff(1)).conjugate();
+    res.row(1) = (mat.row(2) * vec.coeff(0) - mat.row(0) * vec.coeff(2)).conjugate();
+    res.row(2) = (mat.row(0) * vec.coeff(1) - mat.row(1) * vec.coeff(0)).conjugate();
+  }
+  else
+  {
+    eigen_assert(CrossReturnType::ColsAtCompileTime==3 && "the matrix must have exactly 3 columns");
+    res.col(0) = (mat.col(1) * vec.coeff(2) - mat.col(2) * vec.coeff(1)).conjugate();
+    res.col(1) = (mat.col(2) * vec.coeff(0) - mat.col(0) * vec.coeff(2)).conjugate();
+    res.col(2) = (mat.col(0) * vec.coeff(1) - mat.col(1) * vec.coeff(0)).conjugate();
+  }
+  return res;
+}
+
+namespace internal {
+
+template<typename Derived, int Size = Derived::SizeAtCompileTime>
+struct unitOrthogonal_selector
+{
+  typedef typename plain_matrix_type<Derived>::type VectorType;
+  typedef typename traits<Derived>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar,2,1> Vector2;
+  EIGEN_DEVICE_FUNC
+  static inline VectorType run(const Derived& src)
+  {
+    VectorType perp = VectorType::Zero(src.size());
+    Index maxi = 0;
+    Index sndi = 0;
+    src.cwiseAbs().maxCoeff(&maxi);
+    if (maxi==0)
+      sndi = 1;
+    RealScalar invnm = RealScalar(1)/(Vector2() << src.coeff(sndi),src.coeff(maxi)).finished().norm();
+    perp.coeffRef(maxi) = -numext::conj(src.coeff(sndi)) * invnm;
+    perp.coeffRef(sndi) =  numext::conj(src.coeff(maxi)) * invnm;
+
+    return perp;
+   }
+};
+
+template<typename Derived>
+struct unitOrthogonal_selector<Derived,3>
+{
+  typedef typename plain_matrix_type<Derived>::type VectorType;
+  typedef typename traits<Derived>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  EIGEN_DEVICE_FUNC
+  static inline VectorType run(const Derived& src)
+  {
+    VectorType perp;
+    /* Let us compute the crossed product of *this with a vector
+     * that is not too close to being colinear to *this.
+     */
+
+    /* unless the x and y coords are both close to zero, we can
+     * simply take ( -y, x, 0 ) and normalize it.
+     */
+    if((!isMuchSmallerThan(src.x(), src.z()))
+    || (!isMuchSmallerThan(src.y(), src.z())))
+    {
+      RealScalar invnm = RealScalar(1)/src.template head<2>().norm();
+      perp.coeffRef(0) = -numext::conj(src.y())*invnm;
+      perp.coeffRef(1) = numext::conj(src.x())*invnm;
+      perp.coeffRef(2) = 0;
+    }
+    /* if both x and y are close to zero, then the vector is close
+     * to the z-axis, so it's far from colinear to the x-axis for instance.
+     * So we take the crossed product with (1,0,0) and normalize it.
+     */
+    else
+    {
+      RealScalar invnm = RealScalar(1)/src.template tail<2>().norm();
+      perp.coeffRef(0) = 0;
+      perp.coeffRef(1) = -numext::conj(src.z())*invnm;
+      perp.coeffRef(2) = numext::conj(src.y())*invnm;
+    }
+
+    return perp;
+   }
+};
+
+template<typename Derived>
+struct unitOrthogonal_selector<Derived,2>
+{
+  typedef typename plain_matrix_type<Derived>::type VectorType;
+  EIGEN_DEVICE_FUNC
+  static inline VectorType run(const Derived& src)
+  { return VectorType(-numext::conj(src.y()), numext::conj(src.x())).normalized(); }
+};
+
+} // end namespace internal
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \returns a unit vector which is orthogonal to \c *this
+  *
+  * The size of \c *this must be at least 2. If the size is exactly 2,
+  * then the returned vector is a counter clock wise rotation of \c *this, i.e., (-y,x).normalized().
+  *
+  * \sa cross()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::PlainObject
+MatrixBase<Derived>::unitOrthogonal() const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return internal::unitOrthogonal_selector<Derived>::run(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ORTHOMETHODS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/ParametrizedLine.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/ParametrizedLine.h
new file mode 100644
index 00000000..584f5008
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/ParametrizedLine.h
@@ -0,0 +1,232 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARAMETRIZEDLINE_H
+#define EIGEN_PARAMETRIZEDLINE_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class ParametrizedLine
+  *
+  * \brief A parametrized line
+  *
+  * A parametrized line is defined by an origin point \f$ \mathbf{o} \f$ and a unit
+  * direction vector \f$ \mathbf{d} \f$ such that the line corresponds to
+  * the set \f$ l(t) = \mathbf{o} + t \mathbf{d} \f$, \f$ t \in \mathbf{R} \f$.
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+class ParametrizedLine
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
+  enum {
+    AmbientDimAtCompileTime = _AmbientDim,
+    Options = _Options
+  };
+  typedef _Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  typedef Matrix<Scalar,AmbientDimAtCompileTime,1,Options> VectorType;
+
+  /** Default constructor without initialization */
+  EIGEN_DEVICE_FUNC inline ParametrizedLine() {}
+  
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC ParametrizedLine(const ParametrizedLine<Scalar,AmbientDimAtCompileTime,OtherOptions>& other)
+   : m_origin(other.origin()), m_direction(other.direction())
+  {}
+
+  /** Constructs a dynamic-size line with \a _dim the dimension
+    * of the ambient space */
+  EIGEN_DEVICE_FUNC inline explicit ParametrizedLine(Index _dim) : m_origin(_dim), m_direction(_dim) {}
+
+  /** Initializes a parametrized line of direction \a direction and origin \a origin.
+    * \warning the vector direction is assumed to be normalized.
+    */
+  EIGEN_DEVICE_FUNC ParametrizedLine(const VectorType& origin, const VectorType& direction)
+    : m_origin(origin), m_direction(direction) {}
+
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC explicit ParametrizedLine(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane);
+
+  /** Constructs a parametrized line going from \a p0 to \a p1. */
+  EIGEN_DEVICE_FUNC static inline ParametrizedLine Through(const VectorType& p0, const VectorType& p1)
+  { return ParametrizedLine(p0, (p1-p0).normalized()); }
+
+  EIGEN_DEVICE_FUNC ~ParametrizedLine() {}
+
+  /** \returns the dimension in which the line holds */
+  EIGEN_DEVICE_FUNC inline Index dim() const { return m_direction.size(); }
+
+  EIGEN_DEVICE_FUNC const VectorType& origin() const { return m_origin; }
+  EIGEN_DEVICE_FUNC VectorType& origin() { return m_origin; }
+
+  EIGEN_DEVICE_FUNC const VectorType& direction() const { return m_direction; }
+  EIGEN_DEVICE_FUNC VectorType& direction() { return m_direction; }
+
+  /** \returns the squared distance of a point \a p to its projection onto the line \c *this.
+    * \sa distance()
+    */
+  EIGEN_DEVICE_FUNC RealScalar squaredDistance(const VectorType& p) const
+  {
+    VectorType diff = p - origin();
+    return (diff - direction().dot(diff) * direction()).squaredNorm();
+  }
+  /** \returns the distance of a point \a p to its projection onto the line \c *this.
+    * \sa squaredDistance()
+    */
+  EIGEN_DEVICE_FUNC RealScalar distance(const VectorType& p) const { EIGEN_USING_STD(sqrt) return sqrt(squaredDistance(p)); }
+
+  /** \returns the projection of a point \a p onto the line \c *this. */
+  EIGEN_DEVICE_FUNC VectorType projection(const VectorType& p) const
+  { return origin() + direction().dot(p-origin()) * direction(); }
+
+  EIGEN_DEVICE_FUNC VectorType pointAt(const Scalar& t) const;
+  
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC Scalar intersectionParameter(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
+ 
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC Scalar intersection(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
+  
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC VectorType intersectionPoint(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const;
+
+  /** Applies the transformation matrix \a mat to \c *this and returns a reference to \c *this.
+    *
+    * \param mat the Dim x Dim transformation matrix
+    * \param traits specifies whether the matrix \a mat represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    */
+  template<typename XprType>
+  EIGEN_DEVICE_FUNC inline ParametrizedLine& transform(const MatrixBase<XprType>& mat, TransformTraits traits = Affine)
+  {
+    if (traits==Affine)
+      direction() = (mat * direction()).normalized();
+    else if (traits==Isometry)
+      direction() = mat * direction();
+    else
+    {
+      eigen_assert(0 && "invalid traits value in ParametrizedLine::transform()");
+    }
+    origin() = mat * origin();
+    return *this;
+  }
+
+  /** Applies the transformation \a t to \c *this and returns a reference to \c *this.
+    *
+    * \param t the transformation of dimension Dim
+    * \param traits specifies whether the transformation \a t represents an #Isometry
+    *               or a more generic #Affine transformation. The default is #Affine.
+    *               Other kind of transformations are not supported.
+    */
+  template<int TrOptions>
+  EIGEN_DEVICE_FUNC inline ParametrizedLine& transform(const Transform<Scalar,AmbientDimAtCompileTime,Affine,TrOptions>& t,
+                                                       TransformTraits traits = Affine)
+  {
+    transform(t.linear(), traits);
+    origin() += t.translation();
+    return *this;
+  }
+
+/** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<ParametrizedLine,
+           ParametrizedLine<NewScalarType,AmbientDimAtCompileTime,Options> >::type cast() const
+  {
+    return typename internal::cast_return_type<ParametrizedLine,
+                    ParametrizedLine<NewScalarType,AmbientDimAtCompileTime,Options> >::type(*this);
+  }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline explicit ParametrizedLine(const ParametrizedLine<OtherScalarType,AmbientDimAtCompileTime,OtherOptions>& other)
+  {
+    m_origin = other.origin().template cast<Scalar>();
+    m_direction = other.direction().template cast<Scalar>();
+  }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const ParametrizedLine& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_origin.isApprox(other.m_origin, prec) && m_direction.isApprox(other.m_direction, prec); }
+
+protected:
+
+  VectorType m_origin, m_direction;
+};
+
+/** Constructs a parametrized line from a 2D hyperplane
+  *
+  * \warning the ambient space must have dimension 2 such that the hyperplane actually describes a line
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline ParametrizedLine<_Scalar, _AmbientDim,_Options>::ParametrizedLine(const Hyperplane<_Scalar, _AmbientDim,OtherOptions>& hyperplane)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(VectorType, 2)
+  direction() = hyperplane.normal().unitOrthogonal();
+  origin() = -hyperplane.normal()*hyperplane.offset();
+}
+
+/** \returns the point at \a t along this line
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+EIGEN_DEVICE_FUNC inline typename ParametrizedLine<_Scalar, _AmbientDim,_Options>::VectorType
+ParametrizedLine<_Scalar, _AmbientDim,_Options>::pointAt(const _Scalar& t) const
+{
+  return origin() + (direction()*t); 
+}
+
+/** \returns the parameter value of the intersection between \c *this and the given \a hyperplane
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline _Scalar ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersectionParameter(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
+{
+  return -(hyperplane.offset()+hyperplane.normal().dot(origin()))
+          / hyperplane.normal().dot(direction());
+}
+
+
+/** \deprecated use intersectionParameter()
+  * \returns the parameter value of the intersection between \c *this and the given \a hyperplane
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline _Scalar ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersection(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
+{
+  return intersectionParameter(hyperplane);
+}
+
+/** \returns the point of the intersection between \c *this and the given hyperplane
+  */
+template <typename _Scalar, int _AmbientDim, int _Options>
+template <int OtherOptions>
+EIGEN_DEVICE_FUNC inline typename ParametrizedLine<_Scalar, _AmbientDim,_Options>::VectorType
+ParametrizedLine<_Scalar, _AmbientDim,_Options>::intersectionPoint(const Hyperplane<_Scalar, _AmbientDim, OtherOptions>& hyperplane) const
+{
+  return pointAt(intersectionParameter(hyperplane));
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARAMETRIZEDLINE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Quaternion.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Quaternion.h
new file mode 100644
index 00000000..3259e592
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Quaternion.h
@@ -0,0 +1,870 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Mathieu Gautier <mathieu.gautier@cea.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_QUATERNION_H
+#define EIGEN_QUATERNION_H
+namespace Eigen { 
+
+
+/***************************************************************************
+* Definition of QuaternionBase<Derived>
+* The implementation is at the end of the file
+***************************************************************************/
+
+namespace internal {
+template<typename Other,
+         int OtherRows=Other::RowsAtCompileTime,
+         int OtherCols=Other::ColsAtCompileTime>
+struct quaternionbase_assign_impl;
+}
+
+/** \geometry_module \ingroup Geometry_Module
+  * \class QuaternionBase
+  * \brief Base class for quaternion expressions
+  * \tparam Derived derived type (CRTP)
+  * \sa class Quaternion
+  */
+template<class Derived>
+class QuaternionBase : public RotationBase<Derived, 3>
+{
+ public:
+  typedef RotationBase<Derived, 3> Base;
+
+  using Base::operator*;
+  using Base::derived;
+
+  typedef typename internal::traits<Derived>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef typename internal::traits<Derived>::Coefficients Coefficients;
+  typedef typename Coefficients::CoeffReturnType CoeffReturnType;
+  typedef typename internal::conditional<bool(internal::traits<Derived>::Flags&LvalueBit),
+                                        Scalar&, CoeffReturnType>::type NonConstCoeffReturnType;
+
+
+  enum {
+    Flags = Eigen::internal::traits<Derived>::Flags
+  };
+
+ // typedef typename Matrix<Scalar,4,1> Coefficients;
+  /** the type of a 3D vector */
+  typedef Matrix<Scalar,3,1> Vector3;
+  /** the equivalent rotation matrix type */
+  typedef Matrix<Scalar,3,3> Matrix3;
+  /** the equivalent angle-axis type */
+  typedef AngleAxis<Scalar> AngleAxisType;
+
+
+
+  /** \returns the \c x coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType x() const { return this->derived().coeffs().coeff(0); }
+  /** \returns the \c y coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType y() const { return this->derived().coeffs().coeff(1); }
+  /** \returns the \c z coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType z() const { return this->derived().coeffs().coeff(2); }
+  /** \returns the \c w coefficient */
+  EIGEN_DEVICE_FUNC inline CoeffReturnType w() const { return this->derived().coeffs().coeff(3); }
+
+  /** \returns a reference to the \c x coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType x() { return this->derived().coeffs().x(); }
+  /** \returns a reference to the \c y coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType y() { return this->derived().coeffs().y(); }
+  /** \returns a reference to the \c z coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType z() { return this->derived().coeffs().z(); }
+  /** \returns a reference to the \c w coefficient (if Derived is a non-const lvalue) */
+  EIGEN_DEVICE_FUNC inline NonConstCoeffReturnType w() { return this->derived().coeffs().w(); }
+
+  /** \returns a read-only vector expression of the imaginary part (x,y,z) */
+  EIGEN_DEVICE_FUNC inline const VectorBlock<const Coefficients,3> vec() const { return coeffs().template head<3>(); }
+
+  /** \returns a vector expression of the imaginary part (x,y,z) */
+  EIGEN_DEVICE_FUNC inline VectorBlock<Coefficients,3> vec() { return coeffs().template head<3>(); }
+
+  /** \returns a read-only vector expression of the coefficients (x,y,z,w) */
+  EIGEN_DEVICE_FUNC inline const typename internal::traits<Derived>::Coefficients& coeffs() const { return derived().coeffs(); }
+
+  /** \returns a vector expression of the coefficients (x,y,z,w) */
+  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Coefficients& coeffs() { return derived().coeffs(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE QuaternionBase<Derived>& operator=(const QuaternionBase<Derived>& other);
+  template<class OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const QuaternionBase<OtherDerived>& other);
+
+// disabled this copy operator as it is giving very strange compilation errors when compiling
+// test_stdvector with GCC 4.4.2. This looks like a GCC bug though, so feel free to re-enable it if it's
+// useful; however notice that we already have the templated operator= above and e.g. in MatrixBase
+// we didn't have to add, in addition to templated operator=, such a non-templated copy operator.
+//  Derived& operator=(const QuaternionBase& other)
+//  { return operator=<Derived>(other); }
+
+  EIGEN_DEVICE_FUNC Derived& operator=(const AngleAxisType& aa);
+  template<class OtherDerived> EIGEN_DEVICE_FUNC Derived& operator=(const MatrixBase<OtherDerived>& m);
+
+  /** \returns a quaternion representing an identity rotation
+    * \sa MatrixBase::Identity()
+    */
+  EIGEN_DEVICE_FUNC static inline Quaternion<Scalar> Identity() { return Quaternion<Scalar>(Scalar(1), Scalar(0), Scalar(0), Scalar(0)); }
+
+  /** \sa QuaternionBase::Identity(), MatrixBase::setIdentity()
+    */
+  EIGEN_DEVICE_FUNC inline QuaternionBase& setIdentity() { coeffs() << Scalar(0), Scalar(0), Scalar(0), Scalar(1); return *this; }
+
+  /** \returns the squared norm of the quaternion's coefficients
+    * \sa QuaternionBase::norm(), MatrixBase::squaredNorm()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar squaredNorm() const { return coeffs().squaredNorm(); }
+
+  /** \returns the norm of the quaternion's coefficients
+    * \sa QuaternionBase::squaredNorm(), MatrixBase::norm()
+    */
+  EIGEN_DEVICE_FUNC inline Scalar norm() const { return coeffs().norm(); }
+
+  /** Normalizes the quaternion \c *this
+    * \sa normalized(), MatrixBase::normalize() */
+  EIGEN_DEVICE_FUNC inline void normalize() { coeffs().normalize(); }
+  /** \returns a normalized copy of \c *this
+    * \sa normalize(), MatrixBase::normalized() */
+  EIGEN_DEVICE_FUNC inline Quaternion<Scalar> normalized() const { return Quaternion<Scalar>(coeffs().normalized()); }
+
+    /** \returns the dot product of \c *this and \a other
+    * Geometrically speaking, the dot product of two unit quaternions
+    * corresponds to the cosine of half the angle between the two rotations.
+    * \sa angularDistance()
+    */
+  template<class OtherDerived> EIGEN_DEVICE_FUNC inline Scalar dot(const QuaternionBase<OtherDerived>& other) const { return coeffs().dot(other.coeffs()); }
+
+  template<class OtherDerived> EIGEN_DEVICE_FUNC Scalar angularDistance(const QuaternionBase<OtherDerived>& other) const;
+
+  /** \returns an equivalent 3x3 rotation matrix */
+  EIGEN_DEVICE_FUNC inline Matrix3 toRotationMatrix() const;
+
+  /** \returns the quaternion which transform \a a into \a b through a rotation */
+  template<typename Derived1, typename Derived2>
+  EIGEN_DEVICE_FUNC Derived& setFromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b);
+
+  template<class OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion<Scalar> operator* (const QuaternionBase<OtherDerived>& q) const;
+  template<class OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator*= (const QuaternionBase<OtherDerived>& q);
+
+  /** \returns the quaternion describing the inverse rotation */
+  EIGEN_DEVICE_FUNC Quaternion<Scalar> inverse() const;
+
+  /** \returns the conjugated quaternion */
+  EIGEN_DEVICE_FUNC Quaternion<Scalar> conjugate() const;
+
+  template<class OtherDerived> EIGEN_DEVICE_FUNC Quaternion<Scalar> slerp(const Scalar& t, const QuaternionBase<OtherDerived>& other) const;
+
+  /** \returns true if each coefficients of \c *this and \a other are all exactly equal.
+    * \warning When using floating point scalar values you probably should rather use a
+    *          fuzzy comparison such as isApprox()
+    * \sa isApprox(), operator!= */
+  template<class OtherDerived>
+  EIGEN_DEVICE_FUNC inline bool operator==(const QuaternionBase<OtherDerived>& other) const
+  { return coeffs() == other.coeffs(); }
+
+  /** \returns true if at least one pair of coefficients of \c *this and \a other are not exactly equal to each other.
+    * \warning When using floating point scalar values you probably should rather use a
+    *          fuzzy comparison such as isApprox()
+    * \sa isApprox(), operator== */
+  template<class OtherDerived>
+  EIGEN_DEVICE_FUNC inline bool operator!=(const QuaternionBase<OtherDerived>& other) const
+  { return coeffs() != other.coeffs(); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  template<class OtherDerived>
+  EIGEN_DEVICE_FUNC bool isApprox(const QuaternionBase<OtherDerived>& other, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return coeffs().isApprox(other.coeffs(), prec); }
+
+  /** return the result vector of \a v through the rotation*/
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Vector3 _transformVector(const Vector3& v) const;
+
+  #ifdef EIGEN_PARSED_BY_DOXYGEN
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Derived,Quaternion<NewScalarType> >::type cast() const;
+
+  #else
+
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline
+  typename internal::enable_if<internal::is_same<Scalar,NewScalarType>::value,const Derived&>::type cast() const
+  {
+    return derived();
+  }
+
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline
+  typename internal::enable_if<!internal::is_same<Scalar,NewScalarType>::value,Quaternion<NewScalarType> >::type cast() const
+  {
+    return Quaternion<NewScalarType>(coeffs().template cast<NewScalarType>());
+  }
+  #endif
+
+#ifndef EIGEN_NO_IO
+  friend std::ostream& operator<<(std::ostream& s, const QuaternionBase<Derived>& q) {
+    s << q.x() << "i + " << q.y() << "j + " << q.z() << "k" << " + " << q.w();
+    return s;
+  }
+#endif
+
+#ifdef EIGEN_QUATERNIONBASE_PLUGIN
+# include EIGEN_QUATERNIONBASE_PLUGIN
+#endif
+protected:
+  EIGEN_DEFAULT_COPY_CONSTRUCTOR(QuaternionBase)
+  EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(QuaternionBase)
+};
+
+/***************************************************************************
+* Definition/implementation of Quaternion<Scalar>
+***************************************************************************/
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Quaternion
+  *
+  * \brief The quaternion class used to represent 3D orientations and rotations
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _Options controls the memory alignment of the coefficients. Can be \# AutoAlign or \# DontAlign. Default is AutoAlign.
+  *
+  * This class represents a quaternion \f$ w+xi+yj+zk \f$ that is a convenient representation of
+  * orientations and rotations of objects in three dimensions. Compared to other representations
+  * like Euler angles or 3x3 matrices, quaternions offer the following advantages:
+  * \li \b compact storage (4 scalars)
+  * \li \b efficient to compose (28 flops),
+  * \li \b stable spherical interpolation
+  *
+  * The following two typedefs are provided for convenience:
+  * \li \c Quaternionf for \c float
+  * \li \c Quaterniond for \c double
+  *
+  * \warning Operations interpreting the quaternion as rotation have undefined behavior if the quaternion is not normalized.
+  *
+  * \sa  class AngleAxis, class Transform
+  */
+
+namespace internal {
+template<typename _Scalar,int _Options>
+struct traits<Quaternion<_Scalar,_Options> >
+{
+  typedef Quaternion<_Scalar,_Options> PlainObject;
+  typedef _Scalar Scalar;
+  typedef Matrix<_Scalar,4,1,_Options> Coefficients;
+  enum{
+    Alignment = internal::traits<Coefficients>::Alignment,
+    Flags = LvalueBit
+  };
+};
+}
+
+template<typename _Scalar, int _Options>
+class Quaternion : public QuaternionBase<Quaternion<_Scalar,_Options> >
+{
+public:
+  typedef QuaternionBase<Quaternion<_Scalar,_Options> > Base;
+  enum { NeedsAlignment = internal::traits<Quaternion>::Alignment>0 };
+
+  typedef _Scalar Scalar;
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Quaternion)
+  using Base::operator*=;
+
+  typedef typename internal::traits<Quaternion>::Coefficients Coefficients;
+  typedef typename Base::AngleAxisType AngleAxisType;
+
+  /** Default constructor leaving the quaternion uninitialized. */
+  EIGEN_DEVICE_FUNC inline Quaternion() {}
+
+  /** Constructs and initializes the quaternion \f$ w+xi+yj+zk \f$ from
+    * its four coefficients \a w, \a x, \a y and \a z.
+    *
+    * \warning Note the order of the arguments: the real \a w coefficient first,
+    * while internally the coefficients are stored in the following order:
+    * [\c x, \c y, \c z, \c w]
+    */
+  EIGEN_DEVICE_FUNC inline Quaternion(const Scalar& w, const Scalar& x, const Scalar& y, const Scalar& z) : m_coeffs(x, y, z, w){}
+
+  /** Constructs and initialize a quaternion from the array data */
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const Scalar* data) : m_coeffs(data) {}
+
+  /** Copy constructor */
+  template<class Derived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion(const QuaternionBase<Derived>& other) { this->Base::operator=(other); }
+
+  /** Constructs and initializes a quaternion from the angle-axis \a aa */
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const AngleAxisType& aa) { *this = aa; }
+
+  /** Constructs and initializes a quaternion from either:
+    *  - a rotation matrix expression,
+    *  - a 4D vector expression representing quaternion coefficients.
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const MatrixBase<Derived>& other) { *this = other; }
+
+  /** Explicit copy constructor with scalar conversion */
+  template<typename OtherScalar, int OtherOptions>
+  EIGEN_DEVICE_FUNC explicit inline Quaternion(const Quaternion<OtherScalar, OtherOptions>& other)
+  { m_coeffs = other.coeffs().template cast<Scalar>(); }
+
+#if EIGEN_HAS_RVALUE_REFERENCES
+  // We define a copy constructor, which means we don't get an implicit move constructor or assignment operator.
+  /** Default move constructor */
+  EIGEN_DEVICE_FUNC inline Quaternion(Quaternion&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_constructible<Scalar>::value)
+    : m_coeffs(std::move(other.coeffs()))
+  {}
+
+  /** Default move assignment operator */
+  EIGEN_DEVICE_FUNC Quaternion& operator=(Quaternion&& other) EIGEN_NOEXCEPT_IF(std::is_nothrow_move_assignable<Scalar>::value)
+  {
+    m_coeffs = std::move(other.coeffs());
+    return *this;
+  }
+#endif
+
+  EIGEN_DEVICE_FUNC static Quaternion UnitRandom();
+
+  template<typename Derived1, typename Derived2>
+  EIGEN_DEVICE_FUNC static Quaternion FromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b);
+
+  EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs;}
+  EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs;}
+
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(bool(NeedsAlignment))
+  
+#ifdef EIGEN_QUATERNION_PLUGIN
+# include EIGEN_QUATERNION_PLUGIN
+#endif
+
+protected:
+  Coefficients m_coeffs;
+  
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    static EIGEN_STRONG_INLINE void _check_template_params()
+    {
+      EIGEN_STATIC_ASSERT( (_Options & DontAlign) == _Options,
+        INVALID_MATRIX_TEMPLATE_PARAMETERS)
+    }
+#endif
+};
+
+/** \ingroup Geometry_Module
+  * single precision quaternion type */
+typedef Quaternion<float> Quaternionf;
+/** \ingroup Geometry_Module
+  * double precision quaternion type */
+typedef Quaternion<double> Quaterniond;
+
+/***************************************************************************
+* Specialization of Map<Quaternion<Scalar>>
+***************************************************************************/
+
+namespace internal {
+  template<typename _Scalar, int _Options>
+  struct traits<Map<Quaternion<_Scalar>, _Options> > : traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> >
+  {
+    typedef Map<Matrix<_Scalar,4,1>, _Options> Coefficients;
+  };
+}
+
+namespace internal {
+  template<typename _Scalar, int _Options>
+  struct traits<Map<const Quaternion<_Scalar>, _Options> > : traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> >
+  {
+    typedef Map<const Matrix<_Scalar,4,1>, _Options> Coefficients;
+    typedef traits<Quaternion<_Scalar, (int(_Options)&Aligned)==Aligned ? AutoAlign : DontAlign> > TraitsBase;
+    enum {
+      Flags = TraitsBase::Flags & ~LvalueBit
+    };
+  };
+}
+
+/** \ingroup Geometry_Module
+  * \brief Quaternion expression mapping a constant memory buffer
+  *
+  * \tparam _Scalar the type of the Quaternion coefficients
+  * \tparam _Options see class Map
+  *
+  * This is a specialization of class Map for Quaternion. This class allows to view
+  * a 4 scalar memory buffer as an Eigen's Quaternion object.
+  *
+  * \sa class Map, class Quaternion, class QuaternionBase
+  */
+template<typename _Scalar, int _Options>
+class Map<const Quaternion<_Scalar>, _Options >
+  : public QuaternionBase<Map<const Quaternion<_Scalar>, _Options> >
+{
+  public:
+    typedef QuaternionBase<Map<const Quaternion<_Scalar>, _Options> > Base;
+
+    typedef _Scalar Scalar;
+    typedef typename internal::traits<Map>::Coefficients Coefficients;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
+    using Base::operator*=;
+
+    /** Constructs a Mapped Quaternion object from the pointer \a coeffs
+      *
+      * The pointer \a coeffs must reference the four coefficients of Quaternion in the following order:
+      * \code *coeffs == {x, y, z, w} \endcode
+      *
+      * If the template parameter _Options is set to #Aligned, then the pointer coeffs must be aligned. */
+    EIGEN_DEVICE_FUNC explicit EIGEN_STRONG_INLINE Map(const Scalar* coeffs) : m_coeffs(coeffs) {}
+
+    EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs;}
+
+  protected:
+    const Coefficients m_coeffs;
+};
+
+/** \ingroup Geometry_Module
+  * \brief Expression of a quaternion from a memory buffer
+  *
+  * \tparam _Scalar the type of the Quaternion coefficients
+  * \tparam _Options see class Map
+  *
+  * This is a specialization of class Map for Quaternion. This class allows to view
+  * a 4 scalar memory buffer as an Eigen's  Quaternion object.
+  *
+  * \sa class Map, class Quaternion, class QuaternionBase
+  */
+template<typename _Scalar, int _Options>
+class Map<Quaternion<_Scalar>, _Options >
+  : public QuaternionBase<Map<Quaternion<_Scalar>, _Options> >
+{
+  public:
+    typedef QuaternionBase<Map<Quaternion<_Scalar>, _Options> > Base;
+
+    typedef _Scalar Scalar;
+    typedef typename internal::traits<Map>::Coefficients Coefficients;
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
+    using Base::operator*=;
+
+    /** Constructs a Mapped Quaternion object from the pointer \a coeffs
+      *
+      * The pointer \a coeffs must reference the four coefficients of Quaternion in the following order:
+      * \code *coeffs == {x, y, z, w} \endcode
+      *
+      * If the template parameter _Options is set to #Aligned, then the pointer coeffs must be aligned. */
+    EIGEN_DEVICE_FUNC explicit EIGEN_STRONG_INLINE Map(Scalar* coeffs) : m_coeffs(coeffs) {}
+
+    EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
+    EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs; }
+
+  protected:
+    Coefficients m_coeffs;
+};
+
+/** \ingroup Geometry_Module
+  * Map an unaligned array of single precision scalars as a quaternion */
+typedef Map<Quaternion<float>, 0>         QuaternionMapf;
+/** \ingroup Geometry_Module
+  * Map an unaligned array of double precision scalars as a quaternion */
+typedef Map<Quaternion<double>, 0>        QuaternionMapd;
+/** \ingroup Geometry_Module
+  * Map a 16-byte aligned array of single precision scalars as a quaternion */
+typedef Map<Quaternion<float>, Aligned>   QuaternionMapAlignedf;
+/** \ingroup Geometry_Module
+  * Map a 16-byte aligned array of double precision scalars as a quaternion */
+typedef Map<Quaternion<double>, Aligned>  QuaternionMapAlignedd;
+
+/***************************************************************************
+* Implementation of QuaternionBase methods
+***************************************************************************/
+
+// Generic Quaternion * Quaternion product
+// This product can be specialized for a given architecture via the Arch template argument.
+namespace internal {
+template<int Arch, class Derived1, class Derived2, typename Scalar> struct quat_product
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Quaternion<Scalar> run(const QuaternionBase<Derived1>& a, const QuaternionBase<Derived2>& b){
+    return Quaternion<Scalar>
+    (
+      a.w() * b.w() - a.x() * b.x() - a.y() * b.y() - a.z() * b.z(),
+      a.w() * b.x() + a.x() * b.w() + a.y() * b.z() - a.z() * b.y(),
+      a.w() * b.y() + a.y() * b.w() + a.z() * b.x() - a.x() * b.z(),
+      a.w() * b.z() + a.z() * b.w() + a.x() * b.y() - a.y() * b.x()
+    );
+  }
+};
+}
+
+/** \returns the concatenation of two rotations as a quaternion-quaternion product */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion<typename internal::traits<Derived>::Scalar>
+QuaternionBase<Derived>::operator* (const QuaternionBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<typename Derived::Scalar, typename OtherDerived::Scalar>::value),
+   YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  return internal::quat_product<Architecture::Target, Derived, OtherDerived,
+                         typename internal::traits<Derived>::Scalar>::run(*this, other);
+}
+
+/** \sa operator*(Quaternion) */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator*= (const QuaternionBase<OtherDerived>& other)
+{
+  derived() = derived() * other.derived();
+  return derived();
+}
+
+/** Rotation of a vector by a quaternion.
+  * \remarks If the quaternion is used to rotate several points (>1)
+  * then it is much more efficient to first convert it to a 3x3 Matrix.
+  * Comparison of the operation cost for n transformations:
+  *   - Quaternion2:    30n
+  *   - Via a Matrix3: 24 + 15n
+  */
+template <class Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename QuaternionBase<Derived>::Vector3
+QuaternionBase<Derived>::_transformVector(const Vector3& v) const
+{
+    // Note that this algorithm comes from the optimization by hand
+    // of the conversion to a Matrix followed by a Matrix/Vector product.
+    // It appears to be much faster than the common algorithm found
+    // in the literature (30 versus 39 flops). It also requires two
+    // Vector3 as temporaries.
+    Vector3 uv = this->vec().cross(v);
+    uv += uv;
+    return v + this->w() * uv + this->vec().cross(uv);
+}
+
+template<class Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE QuaternionBase<Derived>& QuaternionBase<Derived>::operator=(const QuaternionBase<Derived>& other)
+{
+  coeffs() = other.coeffs();
+  return derived();
+}
+
+template<class Derived>
+template<class OtherDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator=(const QuaternionBase<OtherDerived>& other)
+{
+  coeffs() = other.coeffs();
+  return derived();
+}
+
+/** Set \c *this from an angle-axis \a aa and returns a reference to \c *this
+  */
+template<class Derived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator=(const AngleAxisType& aa)
+{
+  EIGEN_USING_STD(cos)
+  EIGEN_USING_STD(sin)
+  Scalar ha = Scalar(0.5)*aa.angle(); // Scalar(0.5) to suppress precision loss warnings
+  this->w() = cos(ha);
+  this->vec() = sin(ha) * aa.axis();
+  return derived();
+}
+
+/** Set \c *this from the expression \a xpr:
+  *   - if \a xpr is a 4x1 vector, then \a xpr is assumed to be a quaternion
+  *   - if \a xpr is a 3x3 matrix, then \a xpr is assumed to be rotation matrix
+  *     and \a xpr is converted to a quaternion
+  */
+
+template<class Derived>
+template<class MatrixDerived>
+EIGEN_DEVICE_FUNC inline Derived& QuaternionBase<Derived>::operator=(const MatrixBase<MatrixDerived>& xpr)
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<typename Derived::Scalar, typename MatrixDerived::Scalar>::value),
+   YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  internal::quaternionbase_assign_impl<MatrixDerived>::run(*this, xpr.derived());
+  return derived();
+}
+
+/** Convert the quaternion to a 3x3 rotation matrix. The quaternion is required to
+  * be normalized, otherwise the result is undefined.
+  */
+template<class Derived>
+EIGEN_DEVICE_FUNC inline typename QuaternionBase<Derived>::Matrix3
+QuaternionBase<Derived>::toRotationMatrix(void) const
+{
+  // NOTE if inlined, then gcc 4.2 and 4.4 get rid of the temporary (not gcc 4.3 !!)
+  // if not inlined then the cost of the return by value is huge ~ +35%,
+  // however, not inlining this function is an order of magnitude slower, so
+  // it has to be inlined, and so the return by value is not an issue
+  Matrix3 res;
+
+  const Scalar tx  = Scalar(2)*this->x();
+  const Scalar ty  = Scalar(2)*this->y();
+  const Scalar tz  = Scalar(2)*this->z();
+  const Scalar twx = tx*this->w();
+  const Scalar twy = ty*this->w();
+  const Scalar twz = tz*this->w();
+  const Scalar txx = tx*this->x();
+  const Scalar txy = ty*this->x();
+  const Scalar txz = tz*this->x();
+  const Scalar tyy = ty*this->y();
+  const Scalar tyz = tz*this->y();
+  const Scalar tzz = tz*this->z();
+
+  res.coeffRef(0,0) = Scalar(1)-(tyy+tzz);
+  res.coeffRef(0,1) = txy-twz;
+  res.coeffRef(0,2) = txz+twy;
+  res.coeffRef(1,0) = txy+twz;
+  res.coeffRef(1,1) = Scalar(1)-(txx+tzz);
+  res.coeffRef(1,2) = tyz-twx;
+  res.coeffRef(2,0) = txz-twy;
+  res.coeffRef(2,1) = tyz+twx;
+  res.coeffRef(2,2) = Scalar(1)-(txx+tyy);
+
+  return res;
+}
+
+/** Sets \c *this to be a quaternion representing a rotation between
+  * the two arbitrary vectors \a a and \a b. In other words, the built
+  * rotation represent a rotation sending the line of direction \a a
+  * to the line of direction \a b, both lines passing through the origin.
+  *
+  * \returns a reference to \c *this.
+  *
+  * Note that the two input vectors do \b not have to be normalized, and
+  * do not need to have the same norm.
+  */
+template<class Derived>
+template<typename Derived1, typename Derived2>
+EIGEN_DEVICE_FUNC inline Derived& QuaternionBase<Derived>::setFromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b)
+{
+  EIGEN_USING_STD(sqrt)
+  Vector3 v0 = a.normalized();
+  Vector3 v1 = b.normalized();
+  Scalar c = v1.dot(v0);
+
+  // if dot == -1, vectors are nearly opposites
+  // => accurately compute the rotation axis by computing the
+  //    intersection of the two planes. This is done by solving:
+  //       x^T v0 = 0
+  //       x^T v1 = 0
+  //    under the constraint:
+  //       ||x|| = 1
+  //    which yields a singular value problem
+  if (c < Scalar(-1)+NumTraits<Scalar>::dummy_precision())
+  {
+    c = numext::maxi(c,Scalar(-1));
+    Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();
+    JacobiSVD<Matrix<Scalar,2,3> > svd(m, ComputeFullV);
+    Vector3 axis = svd.matrixV().col(2);
+
+    Scalar w2 = (Scalar(1)+c)*Scalar(0.5);
+    this->w() = sqrt(w2);
+    this->vec() = axis * sqrt(Scalar(1) - w2);
+    return derived();
+  }
+  Vector3 axis = v0.cross(v1);
+  Scalar s = sqrt((Scalar(1)+c)*Scalar(2));
+  Scalar invs = Scalar(1)/s;
+  this->vec() = axis * invs;
+  this->w() = s * Scalar(0.5);
+
+  return derived();
+}
+
+/** \returns a random unit quaternion following a uniform distribution law on SO(3)
+  *
+  * \note The implementation is based on http://planning.cs.uiuc.edu/node198.html
+  */
+template<typename Scalar, int Options>
+EIGEN_DEVICE_FUNC Quaternion<Scalar,Options> Quaternion<Scalar,Options>::UnitRandom()
+{
+  EIGEN_USING_STD(sqrt)
+  EIGEN_USING_STD(sin)
+  EIGEN_USING_STD(cos)
+  const Scalar u1 = internal::random<Scalar>(0, 1),
+               u2 = internal::random<Scalar>(0, 2*EIGEN_PI),
+               u3 = internal::random<Scalar>(0, 2*EIGEN_PI);
+  const Scalar a = sqrt(Scalar(1) - u1),
+               b = sqrt(u1);
+  return Quaternion (a * sin(u2), a * cos(u2), b * sin(u3), b * cos(u3));
+}
+
+
+/** Returns a quaternion representing a rotation between
+  * the two arbitrary vectors \a a and \a b. In other words, the built
+  * rotation represent a rotation sending the line of direction \a a
+  * to the line of direction \a b, both lines passing through the origin.
+  *
+  * \returns resulting quaternion
+  *
+  * Note that the two input vectors do \b not have to be normalized, and
+  * do not need to have the same norm.
+  */
+template<typename Scalar, int Options>
+template<typename Derived1, typename Derived2>
+EIGEN_DEVICE_FUNC Quaternion<Scalar,Options> Quaternion<Scalar,Options>::FromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b)
+{
+    Quaternion quat;
+    quat.setFromTwoVectors(a, b);
+    return quat;
+}
+
+
+/** \returns the multiplicative inverse of \c *this
+  * Note that in most cases, i.e., if you simply want the opposite rotation,
+  * and/or the quaternion is normalized, then it is enough to use the conjugate.
+  *
+  * \sa QuaternionBase::conjugate()
+  */
+template <class Derived>
+EIGEN_DEVICE_FUNC inline Quaternion<typename internal::traits<Derived>::Scalar> QuaternionBase<Derived>::inverse() const
+{
+  // FIXME should this function be called multiplicativeInverse and conjugate() be called inverse() or opposite()  ??
+  Scalar n2 = this->squaredNorm();
+  if (n2 > Scalar(0))
+    return Quaternion<Scalar>(conjugate().coeffs() / n2);
+  else
+  {
+    // return an invalid result to flag the error
+    return Quaternion<Scalar>(Coefficients::Zero());
+  }
+}
+
+// Generic conjugate of a Quaternion
+namespace internal {
+template<int Arch, class Derived, typename Scalar> struct quat_conj
+{
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Quaternion<Scalar> run(const QuaternionBase<Derived>& q){
+    return Quaternion<Scalar>(q.w(),-q.x(),-q.y(),-q.z());
+  }
+};
+}
+                         
+/** \returns the conjugate of the \c *this which is equal to the multiplicative inverse
+  * if the quaternion is normalized.
+  * The conjugate of a quaternion represents the opposite rotation.
+  *
+  * \sa Quaternion2::inverse()
+  */
+template <class Derived>
+EIGEN_DEVICE_FUNC inline Quaternion<typename internal::traits<Derived>::Scalar>
+QuaternionBase<Derived>::conjugate() const
+{
+  return internal::quat_conj<Architecture::Target, Derived,
+                         typename internal::traits<Derived>::Scalar>::run(*this);
+                         
+}
+
+/** \returns the angle (in radian) between two rotations
+  * \sa dot()
+  */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar
+QuaternionBase<Derived>::angularDistance(const QuaternionBase<OtherDerived>& other) const
+{
+  EIGEN_USING_STD(atan2)
+  Quaternion<Scalar> d = (*this) * other.conjugate();
+  return Scalar(2) * atan2( d.vec().norm(), numext::abs(d.w()) );
+}
+
+ 
+    
+/** \returns the spherical linear interpolation between the two quaternions
+  * \c *this and \a other at the parameter \a t in [0;1].
+  * 
+  * This represents an interpolation for a constant motion between \c *this and \a other,
+  * see also http://en.wikipedia.org/wiki/Slerp.
+  */
+template <class Derived>
+template <class OtherDerived>
+EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar>
+QuaternionBase<Derived>::slerp(const Scalar& t, const QuaternionBase<OtherDerived>& other) const
+{
+  EIGEN_USING_STD(acos)
+  EIGEN_USING_STD(sin)
+  const Scalar one = Scalar(1) - NumTraits<Scalar>::epsilon();
+  Scalar d = this->dot(other);
+  Scalar absD = numext::abs(d);
+
+  Scalar scale0;
+  Scalar scale1;
+
+  if(absD>=one)
+  {
+    scale0 = Scalar(1) - t;
+    scale1 = t;
+  }
+  else
+  {
+    // theta is the angle between the 2 quaternions
+    Scalar theta = acos(absD);
+    Scalar sinTheta = sin(theta);
+
+    scale0 = sin( ( Scalar(1) - t ) * theta) / sinTheta;
+    scale1 = sin( ( t * theta) ) / sinTheta;
+  }
+  if(d<Scalar(0)) scale1 = -scale1;
+
+  return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());
+}
+
+namespace internal {
+
+// set from a rotation matrix
+template<typename Other>
+struct quaternionbase_assign_impl<Other,3,3>
+{
+  typedef typename Other::Scalar Scalar;
+  template<class Derived> EIGEN_DEVICE_FUNC static inline void run(QuaternionBase<Derived>& q, const Other& a_mat)
+  {
+    const typename internal::nested_eval<Other,2>::type mat(a_mat);
+    EIGEN_USING_STD(sqrt)
+    // This algorithm comes from  "Quaternion Calculus and Fast Animation",
+    // Ken Shoemake, 1987 SIGGRAPH course notes
+    Scalar t = mat.trace();
+    if (t > Scalar(0))
+    {
+      t = sqrt(t + Scalar(1.0));
+      q.w() = Scalar(0.5)*t;
+      t = Scalar(0.5)/t;
+      q.x() = (mat.coeff(2,1) - mat.coeff(1,2)) * t;
+      q.y() = (mat.coeff(0,2) - mat.coeff(2,0)) * t;
+      q.z() = (mat.coeff(1,0) - mat.coeff(0,1)) * t;
+    }
+    else
+    {
+      Index i = 0;
+      if (mat.coeff(1,1) > mat.coeff(0,0))
+        i = 1;
+      if (mat.coeff(2,2) > mat.coeff(i,i))
+        i = 2;
+      Index j = (i+1)%3;
+      Index k = (j+1)%3;
+
+      t = sqrt(mat.coeff(i,i)-mat.coeff(j,j)-mat.coeff(k,k) + Scalar(1.0));
+      q.coeffs().coeffRef(i) = Scalar(0.5) * t;
+      t = Scalar(0.5)/t;
+      q.w() = (mat.coeff(k,j)-mat.coeff(j,k))*t;
+      q.coeffs().coeffRef(j) = (mat.coeff(j,i)+mat.coeff(i,j))*t;
+      q.coeffs().coeffRef(k) = (mat.coeff(k,i)+mat.coeff(i,k))*t;
+    }
+  }
+};
+
+// set from a vector of coefficients assumed to be a quaternion
+template<typename Other>
+struct quaternionbase_assign_impl<Other,4,1>
+{
+  typedef typename Other::Scalar Scalar;
+  template<class Derived> EIGEN_DEVICE_FUNC static inline void run(QuaternionBase<Derived>& q, const Other& vec)
+  {
+    q.coeffs() = vec;
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_QUATERNION_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Rotation2D.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Rotation2D.h
new file mode 100644
index 00000000..d0bd5756
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Rotation2D.h
@@ -0,0 +1,199 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ROTATION2D_H
+#define EIGEN_ROTATION2D_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Rotation2D
+  *
+  * \brief Represents a rotation/orientation in a 2 dimensional space.
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  *
+  * This class is equivalent to a single scalar representing a counter clock wise rotation
+  * as a single angle in radian. It provides some additional features such as the automatic
+  * conversion from/to a 2x2 rotation matrix. Moreover this class aims to provide a similar
+  * interface to Quaternion in order to facilitate the writing of generic algorithms
+  * dealing with rotations.
+  *
+  * \sa class Quaternion, class Transform
+  */
+
+namespace internal {
+
+template<typename _Scalar> struct traits<Rotation2D<_Scalar> >
+{
+  typedef _Scalar Scalar;
+};
+} // end namespace internal
+
+template<typename _Scalar>
+class Rotation2D : public RotationBase<Rotation2D<_Scalar>,2>
+{
+  typedef RotationBase<Rotation2D<_Scalar>,2> Base;
+
+public:
+
+  using Base::operator*;
+
+  enum { Dim = 2 };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  typedef Matrix<Scalar,2,1> Vector2;
+  typedef Matrix<Scalar,2,2> Matrix2;
+
+protected:
+
+  Scalar m_angle;
+
+public:
+
+  /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */
+  EIGEN_DEVICE_FUNC explicit inline Rotation2D(const Scalar& a) : m_angle(a) {}
+  
+  /** Default constructor wihtout initialization. The represented rotation is undefined. */
+  EIGEN_DEVICE_FUNC Rotation2D() {}
+
+  /** Construct a 2D rotation from a 2x2 rotation matrix \a mat.
+    *
+    * \sa fromRotationMatrix()
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC explicit Rotation2D(const MatrixBase<Derived>& m)
+  {
+    fromRotationMatrix(m.derived());
+  }
+
+  /** \returns the rotation angle */
+  EIGEN_DEVICE_FUNC inline Scalar angle() const { return m_angle; }
+
+  /** \returns a read-write reference to the rotation angle */
+  EIGEN_DEVICE_FUNC inline Scalar& angle() { return m_angle; }
+  
+  /** \returns the rotation angle in [0,2pi] */
+  EIGEN_DEVICE_FUNC inline Scalar smallestPositiveAngle() const {
+    Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
+    return tmp<Scalar(0) ? tmp + Scalar(2*EIGEN_PI) : tmp;
+  }
+  
+  /** \returns the rotation angle in [-pi,pi] */
+  EIGEN_DEVICE_FUNC inline Scalar smallestAngle() const {
+    Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
+    if(tmp>Scalar(EIGEN_PI))       tmp -= Scalar(2*EIGEN_PI);
+    else if(tmp<-Scalar(EIGEN_PI)) tmp += Scalar(2*EIGEN_PI);
+    return tmp;
+  }
+
+  /** \returns the inverse rotation */
+  EIGEN_DEVICE_FUNC inline Rotation2D inverse() const { return Rotation2D(-m_angle); }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline Rotation2D operator*(const Rotation2D& other) const
+  { return Rotation2D(m_angle + other.m_angle); }
+
+  /** Concatenates two rotations */
+  EIGEN_DEVICE_FUNC inline Rotation2D& operator*=(const Rotation2D& other)
+  { m_angle += other.m_angle; return *this; }
+
+  /** Applies the rotation to a 2D vector */
+  EIGEN_DEVICE_FUNC Vector2 operator* (const Vector2& vec) const
+  { return toRotationMatrix() * vec; }
+  
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC Rotation2D& fromRotationMatrix(const MatrixBase<Derived>& m);
+  EIGEN_DEVICE_FUNC Matrix2 toRotationMatrix() const;
+
+  /** Set \c *this from a 2x2 rotation matrix \a mat.
+    * In other words, this function extract the rotation angle from the rotation matrix.
+    *
+    * This method is an alias for fromRotationMatrix()
+    *
+    * \sa fromRotationMatrix()
+    */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC Rotation2D& operator=(const  MatrixBase<Derived>& m)
+  { return fromRotationMatrix(m.derived()); }
+
+  /** \returns the spherical interpolation between \c *this and \a other using
+    * parameter \a t. It is in fact equivalent to a linear interpolation.
+    */
+  EIGEN_DEVICE_FUNC inline Rotation2D slerp(const Scalar& t, const Rotation2D& other) const
+  {
+    Scalar dist = Rotation2D(other.m_angle-m_angle).smallestAngle();
+    return Rotation2D(m_angle + dist*t);
+  }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type cast() const
+  { return typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other)
+  {
+    m_angle = Scalar(other.angle());
+  }
+
+  EIGEN_DEVICE_FUNC static inline Rotation2D Identity() { return Rotation2D(0); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Rotation2D& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return internal::isApprox(m_angle,other.m_angle, prec); }
+  
+};
+
+/** \ingroup Geometry_Module
+  * single precision 2D rotation type */
+typedef Rotation2D<float> Rotation2Df;
+/** \ingroup Geometry_Module
+  * double precision 2D rotation type */
+typedef Rotation2D<double> Rotation2Dd;
+
+/** Set \c *this from a 2x2 rotation matrix \a mat.
+  * In other words, this function extract the rotation angle
+  * from the rotation matrix.
+  */
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
+{
+  EIGEN_USING_STD(atan2)
+  EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
+  m_angle = atan2(mat.coeff(1,0), mat.coeff(0,0));
+  return *this;
+}
+
+/** Constructs and \returns an equivalent 2x2 rotation matrix.
+  */
+template<typename Scalar>
+typename Rotation2D<Scalar>::Matrix2
+EIGEN_DEVICE_FUNC Rotation2D<Scalar>::toRotationMatrix(void) const
+{
+  EIGEN_USING_STD(sin)
+  EIGEN_USING_STD(cos)
+  Scalar sinA = sin(m_angle);
+  Scalar cosA = cos(m_angle);
+  return (Matrix2() << cosA, -sinA, sinA, cosA).finished();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_ROTATION2D_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/RotationBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/RotationBase.h
new file mode 100644
index 00000000..f0ee0bd0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/RotationBase.h
@@ -0,0 +1,206 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ROTATIONBASE_H
+#define EIGEN_ROTATIONBASE_H
+
+namespace Eigen { 
+
+// forward declaration
+namespace internal {
+template<typename RotationDerived, typename MatrixType, bool IsVector=MatrixType::IsVectorAtCompileTime>
+struct rotation_base_generic_product_selector;
+}
+
+/** \class RotationBase
+  *
+  * \brief Common base class for compact rotation representations
+  *
+  * \tparam Derived is the derived type, i.e., a rotation type
+  * \tparam _Dim the dimension of the space
+  */
+template<typename Derived, int _Dim>
+class RotationBase
+{
+  public:
+    enum { Dim = _Dim };
+    /** the scalar type of the coefficients */
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+
+    /** corresponding linear transformation matrix type */
+    typedef Matrix<Scalar,Dim,Dim> RotationMatrixType;
+    typedef Matrix<Scalar,Dim,1> VectorType;
+
+  public:
+    EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    EIGEN_DEVICE_FUNC inline Derived& derived() { return *static_cast<Derived*>(this); }
+
+    /** \returns an equivalent rotation matrix */
+    EIGEN_DEVICE_FUNC inline RotationMatrixType toRotationMatrix() const { return derived().toRotationMatrix(); }
+
+    /** \returns an equivalent rotation matrix 
+      * This function is added to be conform with the Transform class' naming scheme.
+      */
+    EIGEN_DEVICE_FUNC inline RotationMatrixType matrix() const { return derived().toRotationMatrix(); }
+
+    /** \returns the inverse rotation */
+    EIGEN_DEVICE_FUNC inline Derived inverse() const { return derived().inverse(); }
+
+    /** \returns the concatenation of the rotation \c *this with a translation \a t */
+    EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Isometry> operator*(const Translation<Scalar,Dim>& t) const
+    { return Transform<Scalar,Dim,Isometry>(*this) * t; }
+
+    /** \returns the concatenation of the rotation \c *this with a uniform scaling \a s */
+    EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const UniformScaling<Scalar>& s) const
+    { return toRotationMatrix() * s.factor(); }
+
+    /** \returns the concatenation of the rotation \c *this with a generic expression \a e
+      * \a e can be:
+      *  - a DimxDim linear transformation matrix
+      *  - a DimxDim diagonal matrix (axis aligned scaling)
+      *  - a vector of size Dim
+      */
+    template<typename OtherDerived>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::rotation_base_generic_product_selector<Derived,OtherDerived,OtherDerived::IsVectorAtCompileTime>::ReturnType
+    operator*(const EigenBase<OtherDerived>& e) const
+    { return internal::rotation_base_generic_product_selector<Derived,OtherDerived>::run(derived(), e.derived()); }
+
+    /** \returns the concatenation of a linear transformation \a l with the rotation \a r */
+    template<typename OtherDerived> friend
+    EIGEN_DEVICE_FUNC inline RotationMatrixType operator*(const EigenBase<OtherDerived>& l, const Derived& r)
+    { return l.derived() * r.toRotationMatrix(); }
+
+    /** \returns the concatenation of a scaling \a l with the rotation \a r */
+    EIGEN_DEVICE_FUNC friend inline Transform<Scalar,Dim,Affine> operator*(const DiagonalMatrix<Scalar,Dim>& l, const Derived& r)
+    { 
+      Transform<Scalar,Dim,Affine> res(r);
+      res.linear().applyOnTheLeft(l);
+      return res;
+    }
+
+    /** \returns the concatenation of the rotation \c *this with a transformation \a t */
+    template<int Mode, int Options>
+    EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode> operator*(const Transform<Scalar,Dim,Mode,Options>& t) const
+    { return toRotationMatrix() * t; }
+
+    template<typename OtherVectorType>
+    EIGEN_DEVICE_FUNC inline VectorType _transformVector(const OtherVectorType& v) const
+    { return toRotationMatrix() * v; }
+};
+
+namespace internal {
+
+// implementation of the generic product rotation * matrix
+template<typename RotationDerived, typename MatrixType>
+struct rotation_base_generic_product_selector<RotationDerived,MatrixType,false>
+{
+  enum { Dim = RotationDerived::Dim };
+  typedef Matrix<typename RotationDerived::Scalar,Dim,Dim> ReturnType;
+  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const MatrixType& m)
+  { return r.toRotationMatrix() * m; }
+};
+
+template<typename RotationDerived, typename Scalar, int Dim, int MaxDim>
+struct rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix<Scalar,Dim,MaxDim>, false >
+{
+  typedef Transform<Scalar,Dim,Affine> ReturnType;
+  EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const DiagonalMatrix<Scalar,Dim,MaxDim>& m)
+  {
+    ReturnType res(r);
+    res.linear() *= m;
+    return res;
+  }
+};
+
+template<typename RotationDerived,typename OtherVectorType>
+struct rotation_base_generic_product_selector<RotationDerived,OtherVectorType,true>
+{
+  enum { Dim = RotationDerived::Dim };
+  typedef Matrix<typename RotationDerived::Scalar,Dim,1> ReturnType;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE ReturnType run(const RotationDerived& r, const OtherVectorType& v)
+  {
+    return r._transformVector(v);
+  }
+};
+
+} // end namespace internal
+
+/** \geometry_module
+  *
+  * \brief Constructs a Dim x Dim rotation matrix from the rotation \a r
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Storage, int _MaxRows, int _MaxCols>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
+::Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
+{
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix,int(OtherDerived::Dim),int(OtherDerived::Dim))
+  *this = r.toRotationMatrix();
+}
+
+/** \geometry_module
+  *
+  * \brief Set a Dim x Dim rotation matrix from the rotation \a r
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Storage, int _MaxRows, int _MaxCols>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols>
+::operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r)
+{
+  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix,int(OtherDerived::Dim),int(OtherDerived::Dim))
+  return *this = r.toRotationMatrix();
+}
+
+namespace internal {
+
+/** \internal
+  *
+  * Helper function to return an arbitrary rotation object to a rotation matrix.
+  *
+  * \tparam Scalar the numeric type of the matrix coefficients
+  * \tparam Dim the dimension of the current space
+  *
+  * It returns a Dim x Dim fixed size matrix.
+  *
+  * Default specializations are provided for:
+  *   - any scalar type (2D),
+  *   - any matrix expression,
+  *   - any type based on RotationBase (e.g., Quaternion, AngleAxis, Rotation2D)
+  *
+  * Currently toRotationMatrix is only used by Transform.
+  *
+  * \sa class Transform, class Rotation2D, class Quaternion, class AngleAxis
+  */
+template<typename Scalar, int Dim>
+EIGEN_DEVICE_FUNC static inline Matrix<Scalar,2,2> toRotationMatrix(const Scalar& s)
+{
+  EIGEN_STATIC_ASSERT(Dim==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
+  return Rotation2D<Scalar>(s).toRotationMatrix();
+}
+
+template<typename Scalar, int Dim, typename OtherDerived>
+EIGEN_DEVICE_FUNC static inline Matrix<Scalar,Dim,Dim> toRotationMatrix(const RotationBase<OtherDerived,Dim>& r)
+{
+  return r.toRotationMatrix();
+}
+
+template<typename Scalar, int Dim, typename OtherDerived>
+EIGEN_DEVICE_FUNC static inline const MatrixBase<OtherDerived>& toRotationMatrix(const MatrixBase<OtherDerived>& mat)
+{
+  EIGEN_STATIC_ASSERT(OtherDerived::RowsAtCompileTime==Dim && OtherDerived::ColsAtCompileTime==Dim,
+    YOU_MADE_A_PROGRAMMING_MISTAKE)
+  return mat;
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_ROTATIONBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Scaling.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Scaling.h
new file mode 100644
index 00000000..d352f1f2
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Scaling.h
@@ -0,0 +1,188 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SCALING_H
+#define EIGEN_SCALING_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class UniformScaling
+  *
+  * \brief Represents a generic uniform scaling transformation
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients.
+  *
+  * This class represent a uniform scaling transformation. It is the return
+  * type of Scaling(Scalar), and most of the time this is the only way it
+  * is used. In particular, this class is not aimed to be used to store a scaling transformation,
+  * but rather to make easier the constructions and updates of Transform objects.
+  *
+  * To represent an axis aligned scaling, use the DiagonalMatrix class.
+  *
+  * \sa Scaling(), class DiagonalMatrix, MatrixBase::asDiagonal(), class Translation, class Transform
+  */
+
+namespace internal
+{
+  // This helper helps nvcc+MSVC to properly parse this file.
+  // See bug 1412.
+  template <typename Scalar, int Dim, int Mode>
+  struct uniformscaling_times_affine_returntype
+  {
+    enum
+    {
+      NewMode = int(Mode) == int(Isometry) ? Affine : Mode
+    };
+    typedef Transform <Scalar, Dim, NewMode> type;
+  };
+}
+
+template<typename _Scalar>
+class UniformScaling
+{
+public:
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+
+protected:
+
+  Scalar m_factor;
+
+public:
+
+  /** Default constructor without initialization. */
+  UniformScaling() {}
+  /** Constructs and initialize a uniform scaling transformation */
+  explicit inline UniformScaling(const Scalar& s) : m_factor(s) {}
+
+  inline const Scalar& factor() const { return m_factor; }
+  inline Scalar& factor() { return m_factor; }
+
+  /** Concatenates two uniform scaling */
+  inline UniformScaling operator* (const UniformScaling& other) const
+  { return UniformScaling(m_factor * other.factor()); }
+
+  /** Concatenates a uniform scaling and a translation */
+  template<int Dim>
+  inline Transform<Scalar,Dim,Affine> operator* (const Translation<Scalar,Dim>& t) const;
+
+  /** Concatenates a uniform scaling and an affine transformation */
+  template<int Dim, int Mode, int Options>
+  inline typename
+	internal::uniformscaling_times_affine_returntype<Scalar,Dim,Mode>::type
+	operator* (const Transform<Scalar, Dim, Mode, Options>& t) const
+  {
+    typename internal::uniformscaling_times_affine_returntype<Scalar,Dim,Mode>::type res = t;
+    res.prescale(factor());
+    return res;
+  }
+
+  /** Concatenates a uniform scaling and a linear transformation matrix */
+  // TODO returns an expression
+  template<typename Derived>
+  inline typename Eigen::internal::plain_matrix_type<Derived>::type operator* (const MatrixBase<Derived>& other) const
+  { return other * m_factor; }
+
+  template<typename Derived,int Dim>
+  inline Matrix<Scalar,Dim,Dim> operator*(const RotationBase<Derived,Dim>& r) const
+  { return r.toRotationMatrix() * m_factor; }
+
+  /** \returns the inverse scaling */
+  inline UniformScaling inverse() const
+  { return UniformScaling(Scalar(1)/m_factor); }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  inline UniformScaling<NewScalarType> cast() const
+  { return UniformScaling<NewScalarType>(NewScalarType(m_factor)); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  inline explicit UniformScaling(const UniformScaling<OtherScalarType>& other)
+  { m_factor = Scalar(other.factor()); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  bool isApprox(const UniformScaling& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return internal::isApprox(m_factor, other.factor(), prec); }
+
+};
+
+/** \addtogroup Geometry_Module */
+//@{
+
+/** Concatenates a linear transformation matrix and a uniform scaling
+  * \relates UniformScaling
+  */
+// NOTE this operator is defined in MatrixBase and not as a friend function
+// of UniformScaling to fix an internal crash of Intel's ICC
+template<typename Derived,typename Scalar>
+EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,Scalar,product)
+operator*(const MatrixBase<Derived>& matrix, const UniformScaling<Scalar>& s)
+{ return matrix.derived() * s.factor(); }
+
+/** Constructs a uniform scaling from scale factor \a s */
+inline UniformScaling<float> Scaling(float s) { return UniformScaling<float>(s); }
+/** Constructs a uniform scaling from scale factor \a s */
+inline UniformScaling<double> Scaling(double s) { return UniformScaling<double>(s); }
+/** Constructs a uniform scaling from scale factor \a s */
+template<typename RealScalar>
+inline UniformScaling<std::complex<RealScalar> > Scaling(const std::complex<RealScalar>& s)
+{ return UniformScaling<std::complex<RealScalar> >(s); }
+
+/** Constructs a 2D axis aligned scaling */
+template<typename Scalar>
+inline DiagonalMatrix<Scalar,2> Scaling(const Scalar& sx, const Scalar& sy)
+{ return DiagonalMatrix<Scalar,2>(sx, sy); }
+/** Constructs a 3D axis aligned scaling */
+template<typename Scalar>
+inline DiagonalMatrix<Scalar,3> Scaling(const Scalar& sx, const Scalar& sy, const Scalar& sz)
+{ return DiagonalMatrix<Scalar,3>(sx, sy, sz); }
+
+/** Constructs an axis aligned scaling expression from vector expression \a coeffs
+  * This is an alias for coeffs.asDiagonal()
+  */
+template<typename Derived>
+inline const DiagonalWrapper<const Derived> Scaling(const MatrixBase<Derived>& coeffs)
+{ return coeffs.asDiagonal(); }
+
+/** \deprecated */
+typedef DiagonalMatrix<float, 2> AlignedScaling2f;
+/** \deprecated */
+typedef DiagonalMatrix<double,2> AlignedScaling2d;
+/** \deprecated */
+typedef DiagonalMatrix<float, 3> AlignedScaling3f;
+/** \deprecated */
+typedef DiagonalMatrix<double,3> AlignedScaling3d;
+//@}
+
+template<typename Scalar>
+template<int Dim>
+inline Transform<Scalar,Dim,Affine>
+UniformScaling<Scalar>::operator* (const Translation<Scalar,Dim>& t) const
+{
+  Transform<Scalar,Dim,Affine> res;
+  res.matrix().setZero();
+  res.linear().diagonal().fill(factor());
+  res.translation() = factor() * t.vector();
+  res(Dim,Dim) = Scalar(1);
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SCALING_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Transform.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Transform.h
new file mode 100644
index 00000000..52b8c2a4
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Transform.h
@@ -0,0 +1,1563 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2010 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSFORM_H
+#define EIGEN_TRANSFORM_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Transform>
+struct transform_traits
+{
+  enum
+  {
+    Dim = Transform::Dim,
+    HDim = Transform::HDim,
+    Mode = Transform::Mode,
+    IsProjective = (int(Mode)==int(Projective))
+  };
+};
+
+template< typename TransformType,
+          typename MatrixType,
+          int Case = transform_traits<TransformType>::IsProjective ? 0
+                   : int(MatrixType::RowsAtCompileTime) == int(transform_traits<TransformType>::HDim) ? 1
+                   : 2,
+          int RhsCols = MatrixType::ColsAtCompileTime>
+struct transform_right_product_impl;
+
+template< typename Other,
+          int Mode,
+          int Options,
+          int Dim,
+          int HDim,
+          int OtherRows=Other::RowsAtCompileTime,
+          int OtherCols=Other::ColsAtCompileTime>
+struct transform_left_product_impl;
+
+template< typename Lhs,
+          typename Rhs,
+          bool AnyProjective =
+            transform_traits<Lhs>::IsProjective ||
+            transform_traits<Rhs>::IsProjective>
+struct transform_transform_product_impl;
+
+template< typename Other,
+          int Mode,
+          int Options,
+          int Dim,
+          int HDim,
+          int OtherRows=Other::RowsAtCompileTime,
+          int OtherCols=Other::ColsAtCompileTime>
+struct transform_construct_from_matrix;
+
+template<typename TransformType> struct transform_take_affine_part;
+
+template<typename _Scalar, int _Dim, int _Mode, int _Options>
+struct traits<Transform<_Scalar,_Dim,_Mode,_Options> >
+{
+  typedef _Scalar Scalar;
+  typedef Eigen::Index StorageIndex;
+  typedef Dense StorageKind;
+  enum {
+    Dim1 = _Dim==Dynamic ? _Dim : _Dim + 1,
+    RowsAtCompileTime = _Mode==Projective ? Dim1 : _Dim,
+    ColsAtCompileTime = Dim1,
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    Flags = 0
+  };
+};
+
+template<int Mode> struct transform_make_affine;
+
+} // end namespace internal
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Transform
+  *
+  * \brief Represents an homogeneous transformation in a N dimensional space
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients
+  * \tparam _Dim the dimension of the space
+  * \tparam _Mode the type of the transformation. Can be:
+  *              - #Affine: the transformation is stored as a (Dim+1)^2 matrix,
+  *                         where the last row is assumed to be [0 ... 0 1].
+  *              - #AffineCompact: the transformation is stored as a (Dim)x(Dim+1) matrix.
+  *              - #Projective: the transformation is stored as a (Dim+1)^2 matrix
+  *                             without any assumption.
+  *              - #Isometry: same as #Affine with the additional assumption that
+  *                           the linear part represents a rotation. This assumption is exploited
+  *                           to speed up some functions such as inverse() and rotation().
+  * \tparam _Options has the same meaning as in class Matrix. It allows to specify DontAlign and/or RowMajor.
+  *                  These Options are passed directly to the underlying matrix type.
+  *
+  * The homography is internally represented and stored by a matrix which
+  * is available through the matrix() method. To understand the behavior of
+  * this class you have to think a Transform object as its internal
+  * matrix representation. The chosen convention is right multiply:
+  *
+  * \code v' = T * v \endcode
+  *
+  * Therefore, an affine transformation matrix M is shaped like this:
+  *
+  * \f$ \left( \begin{array}{cc}
+  * linear & translation\\
+  * 0 ... 0 & 1
+  * \end{array} \right) \f$
+  *
+  * Note that for a projective transformation the last row can be anything,
+  * and then the interpretation of different parts might be slightly different.
+  *
+  * However, unlike a plain matrix, the Transform class provides many features
+  * simplifying both its assembly and usage. In particular, it can be composed
+  * with any other transformations (Transform,Translation,RotationBase,DiagonalMatrix)
+  * and can be directly used to transform implicit homogeneous vectors. All these
+  * operations are handled via the operator*. For the composition of transformations,
+  * its principle consists to first convert the right/left hand sides of the product
+  * to a compatible (Dim+1)^2 matrix and then perform a pure matrix product.
+  * Of course, internally, operator* tries to perform the minimal number of operations
+  * according to the nature of each terms. Likewise, when applying the transform
+  * to points, the latters are automatically promoted to homogeneous vectors
+  * before doing the matrix product. The conventions to homogeneous representations
+  * are performed as follow:
+  *
+  * \b Translation t (Dim)x(1):
+  * \f$ \left( \begin{array}{cc}
+  * I & t \\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *
+  * \b Rotation R (Dim)x(Dim):
+  * \f$ \left( \begin{array}{cc}
+  * R & 0\\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *<!--
+  * \b Linear \b Matrix L (Dim)x(Dim):
+  * \f$ \left( \begin{array}{cc}
+  * L & 0\\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *
+  * \b Affine \b Matrix A (Dim)x(Dim+1):
+  * \f$ \left( \begin{array}{c}
+  * A\\
+  * 0\,...\,0\,1
+  * \end{array} \right) \f$
+  *-->
+  * \b Scaling \b DiagonalMatrix S (Dim)x(Dim):
+  * \f$ \left( \begin{array}{cc}
+  * S & 0\\
+  * 0\,...\,0 & 1
+  * \end{array} \right) \f$
+  *
+  * \b Column \b point v (Dim)x(1):
+  * \f$ \left( \begin{array}{c}
+  * v\\
+  * 1
+  * \end{array} \right) \f$
+  *
+  * \b Set \b of \b column \b points V1...Vn (Dim)x(n):
+  * \f$ \left( \begin{array}{ccc}
+  * v_1 & ... & v_n\\
+  * 1 & ... & 1
+  * \end{array} \right) \f$
+  *
+  * The concatenation of a Transform object with any kind of other transformation
+  * always returns a Transform object.
+  *
+  * A little exception to the "as pure matrix product" rule is the case of the
+  * transformation of non homogeneous vectors by an affine transformation. In
+  * that case the last matrix row can be ignored, and the product returns non
+  * homogeneous vectors.
+  *
+  * Since, for instance, a Dim x Dim matrix is interpreted as a linear transformation,
+  * it is not possible to directly transform Dim vectors stored in a Dim x Dim matrix.
+  * The solution is either to use a Dim x Dynamic matrix or explicitly request a
+  * vector transformation by making the vector homogeneous:
+  * \code
+  * m' = T * m.colwise().homogeneous();
+  * \endcode
+  * Note that there is zero overhead.
+  *
+  * Conversion methods from/to Qt's QMatrix and QTransform are available if the
+  * preprocessor token EIGEN_QT_SUPPORT is defined.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_TRANSFORM_PLUGIN.
+  *
+  * \sa class Matrix, class Quaternion
+  */
+template<typename _Scalar, int _Dim, int _Mode, int _Options>
+class Transform
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim==Dynamic ? Dynamic : (_Dim+1)*(_Dim+1))
+  enum {
+    Mode = _Mode,
+    Options = _Options,
+    Dim = _Dim,     ///< space dimension in which the transformation holds
+    HDim = _Dim+1,  ///< size of a respective homogeneous vector
+    Rows = int(Mode)==(AffineCompact) ? Dim : HDim
+  };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  typedef Eigen::Index StorageIndex;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  /** type of the matrix used to represent the transformation */
+  typedef typename internal::make_proper_matrix_type<Scalar,Rows,HDim,Options>::type MatrixType;
+  /** constified MatrixType */
+  typedef const MatrixType ConstMatrixType;
+  /** type of the matrix used to represent the linear part of the transformation */
+  typedef Matrix<Scalar,Dim,Dim,Options> LinearMatrixType;
+  /** type of read/write reference to the linear part of the transformation */
+  typedef Block<MatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (int(Options)&RowMajor)==0> LinearPart;
+  /** type of read reference to the linear part of the transformation */
+  typedef const Block<ConstMatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (int(Options)&RowMajor)==0> ConstLinearPart;
+  /** type of read/write reference to the affine part of the transformation */
+  typedef typename internal::conditional<int(Mode)==int(AffineCompact),
+                              MatrixType&,
+                              Block<MatrixType,Dim,HDim> >::type AffinePart;
+  /** type of read reference to the affine part of the transformation */
+  typedef typename internal::conditional<int(Mode)==int(AffineCompact),
+                              const MatrixType&,
+                              const Block<const MatrixType,Dim,HDim> >::type ConstAffinePart;
+  /** type of a vector */
+  typedef Matrix<Scalar,Dim,1> VectorType;
+  /** type of a read/write reference to the translation part of the rotation */
+  typedef Block<MatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & RowMajorBit)> TranslationPart;
+  /** type of a read reference to the translation part of the rotation */
+  typedef const Block<ConstMatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & RowMajorBit)> ConstTranslationPart;
+  /** corresponding translation type */
+  typedef Translation<Scalar,Dim> TranslationType;
+
+  // this intermediate enum is needed to avoid an ICE with gcc 3.4 and 4.0
+  enum { TransformTimeDiagonalMode = ((Mode==int(Isometry))?Affine:int(Mode)) };
+  /** The return type of the product between a diagonal matrix and a transform */
+  typedef Transform<Scalar,Dim,TransformTimeDiagonalMode> TransformTimeDiagonalReturnType;
+
+protected:
+
+  MatrixType m_matrix;
+
+public:
+
+  /** Default constructor without initialization of the meaningful coefficients.
+    * If Mode==Affine or Mode==Isometry, then the last row is set to [0 ... 0 1] */
+  EIGEN_DEVICE_FUNC inline Transform()
+  {
+    check_template_params();
+    internal::transform_make_affine<(int(Mode)==Affine || int(Mode)==Isometry) ? Affine : AffineCompact>::run(m_matrix);
+  }
+
+  EIGEN_DEVICE_FUNC inline explicit Transform(const TranslationType& t)
+  {
+    check_template_params();
+    *this = t;
+  }
+  EIGEN_DEVICE_FUNC inline explicit Transform(const UniformScaling<Scalar>& s)
+  {
+    check_template_params();
+    *this = s;
+  }
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline explicit Transform(const RotationBase<Derived, Dim>& r)
+  {
+    check_template_params();
+    *this = r;
+  }
+
+  typedef internal::transform_take_affine_part<Transform> take_affine_part;
+
+  /** Constructs and initializes a transformation from a Dim^2 or a (Dim+1)^2 matrix. */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline explicit Transform(const EigenBase<OtherDerived>& other)
+  {
+    EIGEN_STATIC_ASSERT((internal::is_same<Scalar,typename OtherDerived::Scalar>::value),
+      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY);
+
+    check_template_params();
+    internal::transform_construct_from_matrix<OtherDerived,Mode,Options,Dim,HDim>::run(this, other.derived());
+  }
+
+  /** Set \c *this from a Dim^2 or (Dim+1)^2 matrix. */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline Transform& operator=(const EigenBase<OtherDerived>& other)
+  {
+    EIGEN_STATIC_ASSERT((internal::is_same<Scalar,typename OtherDerived::Scalar>::value),
+      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY);
+
+    internal::transform_construct_from_matrix<OtherDerived,Mode,Options,Dim,HDim>::run(this, other.derived());
+    return *this;
+  }
+
+  template<int OtherOptions>
+  EIGEN_DEVICE_FUNC inline Transform(const Transform<Scalar,Dim,Mode,OtherOptions>& other)
+  {
+    check_template_params();
+    // only the options change, we can directly copy the matrices
+    m_matrix = other.matrix();
+  }
+
+  template<int OtherMode,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline Transform(const Transform<Scalar,Dim,OtherMode,OtherOptions>& other)
+  {
+    check_template_params();
+    // prevent conversions as:
+    // Affine | AffineCompact | Isometry = Projective
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Projective), Mode==int(Projective)),
+                        YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION)
+
+    // prevent conversions as:
+    // Isometry = Affine | AffineCompact
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Affine)||OtherMode==int(AffineCompact), Mode!=int(Isometry)),
+                        YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION)
+
+    enum { ModeIsAffineCompact = Mode == int(AffineCompact),
+           OtherModeIsAffineCompact = OtherMode == int(AffineCompact)
+    };
+
+    if(EIGEN_CONST_CONDITIONAL(ModeIsAffineCompact == OtherModeIsAffineCompact))
+    {
+      // We need the block expression because the code is compiled for all
+      // combinations of transformations and will trigger a compile time error
+      // if one tries to assign the matrices directly
+      m_matrix.template block<Dim,Dim+1>(0,0) = other.matrix().template block<Dim,Dim+1>(0,0);
+      makeAffine();
+    }
+    else if(EIGEN_CONST_CONDITIONAL(OtherModeIsAffineCompact))
+    {
+      typedef typename Transform<Scalar,Dim,OtherMode,OtherOptions>::MatrixType OtherMatrixType;
+      internal::transform_construct_from_matrix<OtherMatrixType,Mode,Options,Dim,HDim>::run(this, other.matrix());
+    }
+    else
+    {
+      // here we know that Mode == AffineCompact and OtherMode != AffineCompact.
+      // if OtherMode were Projective, the static assert above would already have caught it.
+      // So the only possibility is that OtherMode == Affine
+      linear() = other.linear();
+      translation() = other.translation();
+    }
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC Transform(const ReturnByValue<OtherDerived>& other)
+  {
+    check_template_params();
+    other.evalTo(*this);
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC Transform& operator=(const ReturnByValue<OtherDerived>& other)
+  {
+    other.evalTo(*this);
+    return *this;
+  }
+
+  #ifdef EIGEN_QT_SUPPORT
+  inline Transform(const QMatrix& other);
+  inline Transform& operator=(const QMatrix& other);
+  inline QMatrix toQMatrix(void) const;
+  inline Transform(const QTransform& other);
+  inline Transform& operator=(const QTransform& other);
+  inline QTransform toQTransform(void) const;
+  #endif
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return int(Mode)==int(Projective) ? m_matrix.cols() : (m_matrix.cols()-1); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
+
+  /** shortcut for m_matrix(row,col);
+    * \sa MatrixBase::operator(Index,Index) const */
+  EIGEN_DEVICE_FUNC inline Scalar operator() (Index row, Index col) const { return m_matrix(row,col); }
+  /** shortcut for m_matrix(row,col);
+    * \sa MatrixBase::operator(Index,Index) */
+  EIGEN_DEVICE_FUNC inline Scalar& operator() (Index row, Index col) { return m_matrix(row,col); }
+
+  /** \returns a read-only expression of the transformation matrix */
+  EIGEN_DEVICE_FUNC inline const MatrixType& matrix() const { return m_matrix; }
+  /** \returns a writable expression of the transformation matrix */
+  EIGEN_DEVICE_FUNC inline MatrixType& matrix() { return m_matrix; }
+
+  /** \returns a read-only expression of the linear part of the transformation */
+  EIGEN_DEVICE_FUNC inline ConstLinearPart linear() const { return ConstLinearPart(m_matrix,0,0); }
+  /** \returns a writable expression of the linear part of the transformation */
+  EIGEN_DEVICE_FUNC inline LinearPart linear() { return LinearPart(m_matrix,0,0); }
+
+  /** \returns a read-only expression of the Dim x HDim affine part of the transformation */
+  EIGEN_DEVICE_FUNC inline ConstAffinePart affine() const { return take_affine_part::run(m_matrix); }
+  /** \returns a writable expression of the Dim x HDim affine part of the transformation */
+  EIGEN_DEVICE_FUNC inline AffinePart affine() { return take_affine_part::run(m_matrix); }
+
+  /** \returns a read-only expression of the translation vector of the transformation */
+  EIGEN_DEVICE_FUNC inline ConstTranslationPart translation() const { return ConstTranslationPart(m_matrix,0,Dim); }
+  /** \returns a writable expression of the translation vector of the transformation */
+  EIGEN_DEVICE_FUNC inline TranslationPart translation() { return TranslationPart(m_matrix,0,Dim); }
+
+  /** \returns an expression of the product between the transform \c *this and a matrix expression \a other.
+    *
+    * The right-hand-side \a other can be either:
+    * \li an homogeneous vector of size Dim+1,
+    * \li a set of homogeneous vectors of size Dim+1 x N,
+    * \li a transformation matrix of size Dim+1 x Dim+1.
+    *
+    * Moreover, if \c *this represents an affine transformation (i.e., Mode!=Projective), then \a other can also be:
+    * \li a point of size Dim (computes: \code this->linear() * other + this->translation()\endcode),
+    * \li a set of N points as a Dim x N matrix (computes: \code (this->linear() * other).colwise() + this->translation()\endcode),
+    *
+    * In all cases, the return type is a matrix or vector of same sizes as the right-hand-side \a other.
+    *
+    * If you want to interpret \a other as a linear or affine transformation, then first convert it to a Transform<> type,
+    * or do your own cooking.
+    *
+    * Finally, if you want to apply Affine transformations to vectors, then explicitly apply the linear part only:
+    * \code
+    * Affine3f A;
+    * Vector3f v1, v2;
+    * v2 = A.linear() * v1;
+    * \endcode
+    *
+    */
+  // note: this function is defined here because some compilers cannot find the respective declaration
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename internal::transform_right_product_impl<Transform, OtherDerived>::ResultType
+  operator * (const EigenBase<OtherDerived> &other) const
+  { return internal::transform_right_product_impl<Transform, OtherDerived>::run(*this,other.derived()); }
+
+  /** \returns the product expression of a transformation matrix \a a times a transform \a b
+    *
+    * The left hand side \a other can be either:
+    * \li a linear transformation matrix of size Dim x Dim,
+    * \li an affine transformation matrix of size Dim x Dim+1,
+    * \li a general transformation matrix of size Dim+1 x Dim+1.
+    */
+  template<typename OtherDerived> friend
+  EIGEN_DEVICE_FUNC inline const typename internal::transform_left_product_impl<OtherDerived,Mode,Options,_Dim,_Dim+1>::ResultType
+    operator * (const EigenBase<OtherDerived> &a, const Transform &b)
+  { return internal::transform_left_product_impl<OtherDerived,Mode,Options,Dim,HDim>::run(a.derived(),b); }
+
+  /** \returns The product expression of a transform \a a times a diagonal matrix \a b
+    *
+    * The rhs diagonal matrix is interpreted as an affine scaling transformation. The
+    * product results in a Transform of the same type (mode) as the lhs only if the lhs
+    * mode is no isometry. In that case, the returned transform is an affinity.
+    */
+  template<typename DiagonalDerived>
+  EIGEN_DEVICE_FUNC inline const TransformTimeDiagonalReturnType
+    operator * (const DiagonalBase<DiagonalDerived> &b) const
+  {
+    TransformTimeDiagonalReturnType res(*this);
+    res.linearExt() *= b;
+    return res;
+  }
+
+  /** \returns The product expression of a diagonal matrix \a a times a transform \a b
+    *
+    * The lhs diagonal matrix is interpreted as an affine scaling transformation. The
+    * product results in a Transform of the same type (mode) as the lhs only if the lhs
+    * mode is no isometry. In that case, the returned transform is an affinity.
+    */
+  template<typename DiagonalDerived>
+  EIGEN_DEVICE_FUNC friend inline TransformTimeDiagonalReturnType
+    operator * (const DiagonalBase<DiagonalDerived> &a, const Transform &b)
+  {
+    TransformTimeDiagonalReturnType res;
+    res.linear().noalias() = a*b.linear();
+    res.translation().noalias() = a*b.translation();
+    if (EIGEN_CONST_CONDITIONAL(Mode!=int(AffineCompact)))
+      res.matrix().row(Dim) = b.matrix().row(Dim);
+    return res;
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline Transform& operator*=(const EigenBase<OtherDerived>& other) { return *this = *this * other; }
+
+  /** Concatenates two transformations */
+  EIGEN_DEVICE_FUNC inline const Transform operator * (const Transform& other) const
+  {
+    return internal::transform_transform_product_impl<Transform,Transform>::run(*this,other);
+  }
+
+  #if EIGEN_COMP_ICC
+private:
+  // this intermediate structure permits to workaround a bug in ICC 11:
+  //   error: template instantiation resulted in unexpected function type of "Eigen::Transform<double, 3, 32, 0>
+  //             (const Eigen::Transform<double, 3, 2, 0> &) const"
+  //  (the meaning of a name may have changed since the template declaration -- the type of the template is:
+  // "Eigen::internal::transform_transform_product_impl<Eigen::Transform<double, 3, 32, 0>,
+  //     Eigen::Transform<double, 3, Mode, Options>, <expression>>::ResultType (const Eigen::Transform<double, 3, Mode, Options> &) const")
+  //
+  template<int OtherMode,int OtherOptions> struct icc_11_workaround
+  {
+    typedef internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> > ProductType;
+    typedef typename ProductType::ResultType ResultType;
+  };
+
+public:
+  /** Concatenates two different transformations */
+  template<int OtherMode,int OtherOptions>
+  inline typename icc_11_workaround<OtherMode,OtherOptions>::ResultType
+    operator * (const Transform<Scalar,Dim,OtherMode,OtherOptions>& other) const
+  {
+    typedef typename icc_11_workaround<OtherMode,OtherOptions>::ProductType ProductType;
+    return ProductType::run(*this,other);
+  }
+  #else
+  /** Concatenates two different transformations */
+  template<int OtherMode,int OtherOptions>
+  EIGEN_DEVICE_FUNC inline typename internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> >::ResultType
+    operator * (const Transform<Scalar,Dim,OtherMode,OtherOptions>& other) const
+  {
+    return internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> >::run(*this,other);
+  }
+  #endif
+
+  /** \sa MatrixBase::setIdentity() */
+  EIGEN_DEVICE_FUNC void setIdentity() { m_matrix.setIdentity(); }
+
+  /**
+   * \brief Returns an identity transformation.
+   * \todo In the future this function should be returning a Transform expression.
+   */
+  EIGEN_DEVICE_FUNC static const Transform Identity()
+  {
+    return Transform(MatrixType::Identity());
+  }
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& scale(const MatrixBase<OtherDerived> &other);
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& prescale(const MatrixBase<OtherDerived> &other);
+
+  EIGEN_DEVICE_FUNC inline Transform& scale(const Scalar& s);
+  EIGEN_DEVICE_FUNC inline Transform& prescale(const Scalar& s);
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& translate(const MatrixBase<OtherDerived> &other);
+
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC
+  inline Transform& pretranslate(const MatrixBase<OtherDerived> &other);
+
+  template<typename RotationType>
+  EIGEN_DEVICE_FUNC
+  inline Transform& rotate(const RotationType& rotation);
+
+  template<typename RotationType>
+  EIGEN_DEVICE_FUNC
+  inline Transform& prerotate(const RotationType& rotation);
+
+  EIGEN_DEVICE_FUNC Transform& shear(const Scalar& sx, const Scalar& sy);
+  EIGEN_DEVICE_FUNC Transform& preshear(const Scalar& sx, const Scalar& sy);
+
+  EIGEN_DEVICE_FUNC inline Transform& operator=(const TranslationType& t);
+
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator*=(const TranslationType& t) { return translate(t.vector()); }
+
+  EIGEN_DEVICE_FUNC inline Transform operator*(const TranslationType& t) const;
+
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator=(const UniformScaling<Scalar>& t);
+
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator*=(const UniformScaling<Scalar>& s) { return scale(s.factor()); }
+
+  EIGEN_DEVICE_FUNC
+  inline TransformTimeDiagonalReturnType operator*(const UniformScaling<Scalar>& s) const
+  {
+    TransformTimeDiagonalReturnType res = *this;
+    res.scale(s.factor());
+    return res;
+  }
+
+  EIGEN_DEVICE_FUNC
+  inline Transform& operator*=(const DiagonalMatrix<Scalar,Dim>& s) { linearExt() *= s; return *this; }
+
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Transform& operator=(const RotationBase<Derived,Dim>& r);
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Transform& operator*=(const RotationBase<Derived,Dim>& r) { return rotate(r.toRotationMatrix()); }
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline Transform operator*(const RotationBase<Derived,Dim>& r) const;
+
+  typedef typename internal::conditional<int(Mode)==Isometry,ConstLinearPart,const LinearMatrixType>::type RotationReturnType;
+  EIGEN_DEVICE_FUNC RotationReturnType rotation() const;
+
+  template<typename RotationMatrixType, typename ScalingMatrixType>
+  EIGEN_DEVICE_FUNC
+  void computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const;
+  template<typename ScalingMatrixType, typename RotationMatrixType>
+  EIGEN_DEVICE_FUNC
+  void computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const;
+
+  template<typename PositionDerived, typename OrientationType, typename ScaleDerived>
+  EIGEN_DEVICE_FUNC
+  Transform& fromPositionOrientationScale(const MatrixBase<PositionDerived> &position,
+    const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale);
+
+  EIGEN_DEVICE_FUNC
+  inline Transform inverse(TransformTraits traits = (TransformTraits)Mode) const;
+
+  /** \returns a const pointer to the column major internal matrix */
+  EIGEN_DEVICE_FUNC const Scalar* data() const { return m_matrix.data(); }
+  /** \returns a non-const pointer to the column major internal matrix */
+  EIGEN_DEVICE_FUNC Scalar* data() { return m_matrix.data(); }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode,Options> >::type cast() const
+  { return typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode,Options> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Transform(const Transform<OtherScalarType,Dim,Mode,Options>& other)
+  {
+    check_template_params();
+    m_matrix = other.matrix().template cast<Scalar>();
+  }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Transform& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_matrix.isApprox(other.m_matrix, prec); }
+
+  /** Sets the last row to [0 ... 0 1]
+    */
+  EIGEN_DEVICE_FUNC void makeAffine()
+  {
+    internal::transform_make_affine<int(Mode)>::run(m_matrix);
+  }
+
+  /** \internal
+    * \returns the Dim x Dim linear part if the transformation is affine,
+    *          and the HDim x Dim part for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,Dim> linearExt()
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,Dim>(0,0); }
+  /** \internal
+    * \returns the Dim x Dim linear part if the transformation is affine,
+    *          and the HDim x Dim part for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline const Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,Dim> linearExt() const
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,Dim>(0,0); }
+
+  /** \internal
+    * \returns the translation part if the transformation is affine,
+    *          and the last column for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,1> translationExt()
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,1>(0,Dim); }
+  /** \internal
+    * \returns the translation part if the transformation is affine,
+    *          and the last column for projective transformations.
+    */
+  EIGEN_DEVICE_FUNC inline const Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,1> translationExt() const
+  { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,1>(0,Dim); }
+
+
+  #ifdef EIGEN_TRANSFORM_PLUGIN
+  #include EIGEN_TRANSFORM_PLUGIN
+  #endif
+
+protected:
+  #ifndef EIGEN_PARSED_BY_DOXYGEN
+    EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void check_template_params()
+    {
+      EIGEN_STATIC_ASSERT((Options & (DontAlign|RowMajor)) == Options, INVALID_MATRIX_TEMPLATE_PARAMETERS)
+    }
+  #endif
+
+};
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,Isometry> Isometry2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,Isometry> Isometry3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,Isometry> Isometry2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,Isometry> Isometry3d;
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,Affine> Affine2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,Affine> Affine3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,Affine> Affine2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,Affine> Affine3d;
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,AffineCompact> AffineCompact2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,AffineCompact> AffineCompact3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,AffineCompact> AffineCompact2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,AffineCompact> AffineCompact3d;
+
+/** \ingroup Geometry_Module */
+typedef Transform<float,2,Projective> Projective2f;
+/** \ingroup Geometry_Module */
+typedef Transform<float,3,Projective> Projective3f;
+/** \ingroup Geometry_Module */
+typedef Transform<double,2,Projective> Projective2d;
+/** \ingroup Geometry_Module */
+typedef Transform<double,3,Projective> Projective3d;
+
+/**************************
+*** Optional QT support ***
+**************************/
+
+#ifdef EIGEN_QT_SUPPORT
+/** Initializes \c *this from a QMatrix assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode,int Options>
+Transform<Scalar,Dim,Mode,Options>::Transform(const QMatrix& other)
+{
+  check_template_params();
+  *this = other;
+}
+
+/** Set \c *this from a QMatrix assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode,int Options>
+Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const QMatrix& other)
+{
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy();
+  else
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy(),
+                0, 0, 1;
+  return *this;
+}
+
+/** \returns a QMatrix from \c *this assuming the dimension is 2.
+  *
+  * \warning this conversion might loss data if \c *this is not affine
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+QMatrix Transform<Scalar,Dim,Mode,Options>::toQMatrix(void) const
+{
+  check_template_params();
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  return QMatrix(m_matrix.coeff(0,0), m_matrix.coeff(1,0),
+                 m_matrix.coeff(0,1), m_matrix.coeff(1,1),
+                 m_matrix.coeff(0,2), m_matrix.coeff(1,2));
+}
+
+/** Initializes \c *this from a QTransform assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode,int Options>
+Transform<Scalar,Dim,Mode,Options>::Transform(const QTransform& other)
+{
+  check_template_params();
+  *this = other;
+}
+
+/** Set \c *this from a QTransform assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const QTransform& other)
+{
+  check_template_params();
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy();
+  else
+    m_matrix << other.m11(), other.m21(), other.dx(),
+                other.m12(), other.m22(), other.dy(),
+                other.m13(), other.m23(), other.m33();
+  return *this;
+}
+
+/** \returns a QTransform from \c *this assuming the dimension is 2.
+  *
+  * This function is available only if the token EIGEN_QT_SUPPORT is defined.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+QTransform Transform<Scalar,Dim,Mode,Options>::toQTransform(void) const
+{
+  EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
+    return QTransform(m_matrix.coeff(0,0), m_matrix.coeff(1,0),
+                      m_matrix.coeff(0,1), m_matrix.coeff(1,1),
+                      m_matrix.coeff(0,2), m_matrix.coeff(1,2));
+  else
+    return QTransform(m_matrix.coeff(0,0), m_matrix.coeff(1,0), m_matrix.coeff(2,0),
+                      m_matrix.coeff(0,1), m_matrix.coeff(1,1), m_matrix.coeff(2,1),
+                      m_matrix.coeff(0,2), m_matrix.coeff(1,2), m_matrix.coeff(2,2));
+}
+#endif
+
+/*********************
+*** Procedural API ***
+*********************/
+
+/** Applies on the right the non uniform scale transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \sa prescale()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::scale(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  linearExt().noalias() = (linearExt() * other.asDiagonal());
+  return *this;
+}
+
+/** Applies on the right a uniform scale of a factor \a c to \c *this
+  * and returns a reference to \c *this.
+  * \sa prescale(Scalar)
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::scale(const Scalar& s)
+{
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  linearExt() *= s;
+  return *this;
+}
+
+/** Applies on the left the non uniform scale transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \sa scale()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::prescale(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  affine().noalias() = (other.asDiagonal() * affine());
+  return *this;
+}
+
+/** Applies on the left a uniform scale of a factor \a c to \c *this
+  * and returns a reference to \c *this.
+  * \sa scale(Scalar)
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::prescale(const Scalar& s)
+{
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  m_matrix.template topRows<Dim>() *= s;
+  return *this;
+}
+
+/** Applies on the right the translation matrix represented by the vector \a other
+  * to \c *this and returns a reference to \c *this.
+  * \sa pretranslate()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::translate(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  translationExt() += linearExt() * other;
+  return *this;
+}
+
+/** Applies on the left the translation matrix represented by the vector \a other
+  * to \c *this and returns a reference to \c *this.
+  * \sa translate()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::pretranslate(const MatrixBase<OtherDerived> &other)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
+  if(EIGEN_CONST_CONDITIONAL(int(Mode)==int(Projective)))
+    affine() += other * m_matrix.row(Dim);
+  else
+    translation() += other;
+  return *this;
+}
+
+/** Applies on the right the rotation represented by the rotation \a rotation
+  * to \c *this and returns a reference to \c *this.
+  *
+  * The template parameter \a RotationType is the type of the rotation which
+  * must be known by internal::toRotationMatrix<>.
+  *
+  * Natively supported types includes:
+  *   - any scalar (2D),
+  *   - a Dim x Dim matrix expression,
+  *   - a Quaternion (3D),
+  *   - a AngleAxis (3D)
+  *
+  * This mechanism is easily extendable to support user types such as Euler angles,
+  * or a pair of Quaternion for 4D rotations.
+  *
+  * \sa rotate(Scalar), class Quaternion, class AngleAxis, prerotate(RotationType)
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename RotationType>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::rotate(const RotationType& rotation)
+{
+  linearExt() *= internal::toRotationMatrix<Scalar,Dim>(rotation);
+  return *this;
+}
+
+/** Applies on the left the rotation represented by the rotation \a rotation
+  * to \c *this and returns a reference to \c *this.
+  *
+  * See rotate() for further details.
+  *
+  * \sa rotate()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename RotationType>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::prerotate(const RotationType& rotation)
+{
+  m_matrix.template block<Dim,HDim>(0,0) = internal::toRotationMatrix<Scalar,Dim>(rotation)
+                                         * m_matrix.template block<Dim,HDim>(0,0);
+  return *this;
+}
+
+/** Applies on the right the shear transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \warning 2D only.
+  * \sa preshear()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::shear(const Scalar& sx, const Scalar& sy)
+{
+  EIGEN_STATIC_ASSERT(int(Dim)==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  VectorType tmp = linear().col(0)*sy + linear().col(1);
+  linear() << linear().col(0) + linear().col(1)*sx, tmp;
+  return *this;
+}
+
+/** Applies on the left the shear transformation represented
+  * by the vector \a other to \c *this and returns a reference to \c *this.
+  * \warning 2D only.
+  * \sa shear()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::preshear(const Scalar& sx, const Scalar& sy)
+{
+  EIGEN_STATIC_ASSERT(int(Dim)==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
+  m_matrix.template block<Dim,HDim>(0,0) = LinearMatrixType(1, sx, sy, 1) * m_matrix.template block<Dim,HDim>(0,0);
+  return *this;
+}
+
+/******************************************************
+*** Scaling, Translation and Rotation compatibility ***
+******************************************************/
+
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const TranslationType& t)
+{
+  linear().setIdentity();
+  translation() = t.vector();
+  makeAffine();
+  return *this;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const TranslationType& t) const
+{
+  Transform res = *this;
+  res.translate(t.vector());
+  return res;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const UniformScaling<Scalar>& s)
+{
+  m_matrix.setZero();
+  linear().diagonal().fill(s.factor());
+  makeAffine();
+  return *this;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const RotationBase<Derived,Dim>& r)
+{
+  linear() = internal::toRotationMatrix<Scalar,Dim>(r);
+  translation().setZero();
+  makeAffine();
+  return *this;
+}
+
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename Derived>
+EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const RotationBase<Derived,Dim>& r) const
+{
+  Transform res = *this;
+  res.rotate(r.derived());
+  return res;
+}
+
+/************************
+*** Special functions ***
+************************/
+
+namespace internal {
+template<int Mode> struct transform_rotation_impl {
+  template<typename TransformType>
+  EIGEN_DEVICE_FUNC static inline
+  const typename TransformType::LinearMatrixType run(const TransformType& t)
+  {
+    typedef typename TransformType::LinearMatrixType LinearMatrixType;
+    LinearMatrixType result;
+    t.computeRotationScaling(&result, (LinearMatrixType*)0);
+    return result;
+  }
+};
+template<> struct transform_rotation_impl<Isometry> {
+  template<typename TransformType>
+  EIGEN_DEVICE_FUNC static inline
+  typename TransformType::ConstLinearPart run(const TransformType& t)
+  {
+    return t.linear();
+  }
+};
+}
+/** \returns the rotation part of the transformation
+  *
+  * If Mode==Isometry, then this method is an alias for linear(),
+  * otherwise it calls computeRotationScaling() to extract the rotation
+  * through a SVD decomposition.
+  *
+  * \svd_module
+  *
+  * \sa computeRotationScaling(), computeScalingRotation(), class SVD
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC
+typename Transform<Scalar,Dim,Mode,Options>::RotationReturnType
+Transform<Scalar,Dim,Mode,Options>::rotation() const
+{
+  return internal::transform_rotation_impl<Mode>::run(*this);
+}
+
+
+/** decomposes the linear part of the transformation as a product rotation x scaling, the scaling being
+  * not necessarily positive.
+  *
+  * If either pointer is zero, the corresponding computation is skipped.
+  *
+  *
+  *
+  * \svd_module
+  *
+  * \sa computeScalingRotation(), rotation(), class SVD
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename RotationMatrixType, typename ScalingMatrixType>
+EIGEN_DEVICE_FUNC void Transform<Scalar,Dim,Mode,Options>::computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const
+{
+  // Note that JacobiSVD is faster than BDCSVD for small matrices.
+  JacobiSVD<LinearMatrixType> svd(linear(), ComputeFullU | ComputeFullV);
+
+  Scalar x = (svd.matrixU() * svd.matrixV().adjoint()).determinant() < Scalar(0) ? Scalar(-1) : Scalar(1); // so x has absolute value 1
+  VectorType sv(svd.singularValues());
+  sv.coeffRef(Dim-1) *= x;
+  if(scaling) *scaling = svd.matrixV() * sv.asDiagonal() * svd.matrixV().adjoint();
+  if(rotation)
+  {
+    LinearMatrixType m(svd.matrixU());
+    m.col(Dim-1) *= x;
+    *rotation = m * svd.matrixV().adjoint();
+  }
+}
+
+/** decomposes the linear part of the transformation as a product scaling x rotation, the scaling being
+  * not necessarily positive.
+  *
+  * If either pointer is zero, the corresponding computation is skipped.
+  *
+  *
+  *
+  * \svd_module
+  *
+  * \sa computeRotationScaling(), rotation(), class SVD
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename ScalingMatrixType, typename RotationMatrixType>
+EIGEN_DEVICE_FUNC void Transform<Scalar,Dim,Mode,Options>::computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const
+{
+  // Note that JacobiSVD is faster than BDCSVD for small matrices.
+  JacobiSVD<LinearMatrixType> svd(linear(), ComputeFullU | ComputeFullV);
+
+  Scalar x = (svd.matrixU() * svd.matrixV().adjoint()).determinant() < Scalar(0) ? Scalar(-1) : Scalar(1); // so x has absolute value 1
+  VectorType sv(svd.singularValues());
+  sv.coeffRef(Dim-1) *= x;
+  if(scaling) *scaling = svd.matrixU() * sv.asDiagonal() * svd.matrixU().adjoint();
+  if(rotation)
+  {
+    LinearMatrixType m(svd.matrixU());
+    m.col(Dim-1) *= x;
+    *rotation = m * svd.matrixV().adjoint();
+  }
+}
+
+/** Convenient method to set \c *this from a position, orientation and scale
+  * of a 3D object.
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+template<typename PositionDerived, typename OrientationType, typename ScaleDerived>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
+Transform<Scalar,Dim,Mode,Options>::fromPositionOrientationScale(const MatrixBase<PositionDerived> &position,
+  const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale)
+{
+  linear() = internal::toRotationMatrix<Scalar,Dim>(orientation);
+  linear() *= scale.asDiagonal();
+  translation() = position;
+  makeAffine();
+  return *this;
+}
+
+namespace internal {
+
+template<int Mode>
+struct transform_make_affine
+{
+  template<typename MatrixType>
+  EIGEN_DEVICE_FUNC static void run(MatrixType &mat)
+  {
+    static const int Dim = MatrixType::ColsAtCompileTime-1;
+    mat.template block<1,Dim>(Dim,0).setZero();
+    mat.coeffRef(Dim,Dim) = typename MatrixType::Scalar(1);
+  }
+};
+
+template<>
+struct transform_make_affine<AffineCompact>
+{
+  template<typename MatrixType> EIGEN_DEVICE_FUNC static void run(MatrixType &) { }
+};
+
+// selector needed to avoid taking the inverse of a 3x4 matrix
+template<typename TransformType, int Mode=TransformType::Mode>
+struct projective_transform_inverse
+{
+  EIGEN_DEVICE_FUNC static inline void run(const TransformType&, TransformType&)
+  {}
+};
+
+template<typename TransformType>
+struct projective_transform_inverse<TransformType, Projective>
+{
+  EIGEN_DEVICE_FUNC static inline void run(const TransformType& m, TransformType& res)
+  {
+    res.matrix() = m.matrix().inverse();
+  }
+};
+
+} // end namespace internal
+
+
+/**
+  *
+  * \returns the inverse transformation according to some given knowledge
+  * on \c *this.
+  *
+  * \param hint allows to optimize the inversion process when the transformation
+  * is known to be not a general transformation (optional). The possible values are:
+  *  - #Projective if the transformation is not necessarily affine, i.e., if the
+  *    last row is not guaranteed to be [0 ... 0 1]
+  *  - #Affine if the last row can be assumed to be [0 ... 0 1]
+  *  - #Isometry if the transformation is only a concatenations of translations
+  *    and rotations.
+  *  The default is the template class parameter \c Mode.
+  *
+  * \warning unless \a traits is always set to NoShear or NoScaling, this function
+  * requires the generic inverse method of MatrixBase defined in the LU module. If
+  * you forget to include this module, then you will get hard to debug linking errors.
+  *
+  * \sa MatrixBase::inverse()
+  */
+template<typename Scalar, int Dim, int Mode, int Options>
+EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>
+Transform<Scalar,Dim,Mode,Options>::inverse(TransformTraits hint) const
+{
+  Transform res;
+  if (hint == Projective)
+  {
+    internal::projective_transform_inverse<Transform>::run(*this, res);
+  }
+  else
+  {
+    if (hint == Isometry)
+    {
+      res.matrix().template topLeftCorner<Dim,Dim>() = linear().transpose();
+    }
+    else if(hint&Affine)
+    {
+      res.matrix().template topLeftCorner<Dim,Dim>() = linear().inverse();
+    }
+    else
+    {
+      eigen_assert(false && "Invalid transform traits in Transform::Inverse");
+    }
+    // translation and remaining parts
+    res.matrix().template topRightCorner<Dim,1>()
+      = - res.matrix().template topLeftCorner<Dim,Dim>() * translation();
+    res.makeAffine(); // we do need this, because in the beginning res is uninitialized
+  }
+  return res;
+}
+
+namespace internal {
+
+/*****************************************************
+*** Specializations of take affine part            ***
+*****************************************************/
+
+template<typename TransformType> struct transform_take_affine_part {
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef typename TransformType::AffinePart AffinePart;
+  typedef typename TransformType::ConstAffinePart ConstAffinePart;
+  static inline AffinePart run(MatrixType& m)
+  { return m.template block<TransformType::Dim,TransformType::HDim>(0,0); }
+  static inline ConstAffinePart run(const MatrixType& m)
+  { return m.template block<TransformType::Dim,TransformType::HDim>(0,0); }
+};
+
+template<typename Scalar, int Dim, int Options>
+struct transform_take_affine_part<Transform<Scalar,Dim,AffineCompact, Options> > {
+  typedef typename Transform<Scalar,Dim,AffineCompact,Options>::MatrixType MatrixType;
+  static inline MatrixType& run(MatrixType& m) { return m; }
+  static inline const MatrixType& run(const MatrixType& m) { return m; }
+};
+
+/*****************************************************
+*** Specializations of construct from matrix       ***
+*****************************************************/
+
+template<typename Other, int Mode, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, Dim,Dim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
+  {
+    transform->linear() = other;
+    transform->translation().setZero();
+    transform->makeAffine();
+  }
+};
+
+template<typename Other, int Mode, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, Dim,HDim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
+  {
+    transform->affine() = other;
+    transform->makeAffine();
+  }
+};
+
+template<typename Other, int Mode, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, HDim,HDim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
+  { transform->matrix() = other; }
+};
+
+template<typename Other, int Options, int Dim, int HDim>
+struct transform_construct_from_matrix<Other, AffineCompact,Options,Dim,HDim, HDim,HDim>
+{
+  static inline void run(Transform<typename Other::Scalar,Dim,AffineCompact,Options> *transform, const Other& other)
+  { transform->matrix() = other.template block<Dim,HDim>(0,0); }
+};
+
+/**********************************************************
+***   Specializations of operator* with rhs EigenBase   ***
+**********************************************************/
+
+template<int LhsMode,int RhsMode>
+struct transform_product_result
+{
+  enum
+  {
+    Mode =
+      (LhsMode == (int)Projective    || RhsMode == (int)Projective    ) ? Projective :
+      (LhsMode == (int)Affine        || RhsMode == (int)Affine        ) ? Affine :
+      (LhsMode == (int)AffineCompact || RhsMode == (int)AffineCompact ) ? AffineCompact :
+      (LhsMode == (int)Isometry      || RhsMode == (int)Isometry      ) ? Isometry : Projective
+  };
+};
+
+template< typename TransformType, typename MatrixType, int RhsCols>
+struct transform_right_product_impl< TransformType, MatrixType, 0, RhsCols>
+{
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    return T.matrix() * other;
+  }
+};
+
+template< typename TransformType, typename MatrixType, int RhsCols>
+struct transform_right_product_impl< TransformType, MatrixType, 1, RhsCols>
+{
+  enum {
+    Dim = TransformType::Dim,
+    HDim = TransformType::HDim,
+    OtherRows = MatrixType::RowsAtCompileTime,
+    OtherCols = MatrixType::ColsAtCompileTime
+  };
+
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    EIGEN_STATIC_ASSERT(OtherRows==HDim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
+
+    typedef Block<ResultType, Dim, OtherCols, int(MatrixType::RowsAtCompileTime)==Dim> TopLeftLhs;
+
+    ResultType res(other.rows(),other.cols());
+    TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() = T.affine() * other;
+    res.row(OtherRows-1) = other.row(OtherRows-1);
+
+    return res;
+  }
+};
+
+template< typename TransformType, typename MatrixType, int RhsCols>
+struct transform_right_product_impl< TransformType, MatrixType, 2, RhsCols>
+{
+  enum {
+    Dim = TransformType::Dim,
+    HDim = TransformType::HDim,
+    OtherRows = MatrixType::RowsAtCompileTime,
+    OtherCols = MatrixType::ColsAtCompileTime
+  };
+
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    EIGEN_STATIC_ASSERT(OtherRows==Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
+
+    typedef Block<ResultType, Dim, OtherCols, true> TopLeftLhs;
+    ResultType res(Replicate<typename TransformType::ConstTranslationPart, 1, OtherCols>(T.translation(),1,other.cols()));
+    TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() += T.linear() * other;
+
+    return res;
+  }
+};
+
+template< typename TransformType, typename MatrixType >
+struct transform_right_product_impl< TransformType, MatrixType, 2, 1> // rhs is a vector of size Dim
+{
+  typedef typename TransformType::MatrixType TransformMatrix;
+  enum {
+    Dim = TransformType::Dim,
+    HDim = TransformType::HDim,
+    OtherRows = MatrixType::RowsAtCompileTime,
+    WorkingRows = EIGEN_PLAIN_ENUM_MIN(TransformMatrix::RowsAtCompileTime,HDim)
+  };
+
+  typedef typename MatrixType::PlainObject ResultType;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
+  {
+    EIGEN_STATIC_ASSERT(OtherRows==Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
+
+    Matrix<typename ResultType::Scalar, Dim+1, 1> rhs;
+    rhs.template head<Dim>() = other; rhs[Dim] = typename ResultType::Scalar(1);
+    Matrix<typename ResultType::Scalar, WorkingRows, 1> res(T.matrix() * rhs);
+    return res.template head<Dim>();
+  }
+};
+
+/**********************************************************
+***   Specializations of operator* with lhs EigenBase   ***
+**********************************************************/
+
+// generic HDim x HDim matrix * T => Projective
+template<typename Other,int Mode, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, HDim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef Transform<typename Other::Scalar,Dim,Projective,Options> ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  { return ResultType(other * tr.matrix()); }
+};
+
+// generic HDim x HDim matrix * AffineCompact => Projective
+template<typename Other, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,AffineCompact,Options,Dim,HDim, HDim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,AffineCompact,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef Transform<typename Other::Scalar,Dim,Projective,Options> ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  {
+    ResultType res;
+    res.matrix().noalias() = other.template block<HDim,Dim>(0,0) * tr.matrix();
+    res.matrix().col(Dim) += other.col(Dim);
+    return res;
+  }
+};
+
+// affine matrix * T
+template<typename Other,int Mode, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, Dim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef TransformType ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  {
+    ResultType res;
+    res.affine().noalias() = other * tr.matrix();
+    res.matrix().row(Dim) = tr.matrix().row(Dim);
+    return res;
+  }
+};
+
+// affine matrix * AffineCompact
+template<typename Other, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,AffineCompact,Options,Dim,HDim, Dim,HDim>
+{
+  typedef Transform<typename Other::Scalar,Dim,AffineCompact,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef TransformType ResultType;
+  static ResultType run(const Other& other,const TransformType& tr)
+  {
+    ResultType res;
+    res.matrix().noalias() = other.template block<Dim,Dim>(0,0) * tr.matrix();
+    res.translation() += other.col(Dim);
+    return res;
+  }
+};
+
+// linear matrix * T
+template<typename Other,int Mode, int Options, int Dim, int HDim>
+struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, Dim,Dim>
+{
+  typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
+  typedef typename TransformType::MatrixType MatrixType;
+  typedef TransformType ResultType;
+  static ResultType run(const Other& other, const TransformType& tr)
+  {
+    TransformType res;
+    if(Mode!=int(AffineCompact))
+      res.matrix().row(Dim) = tr.matrix().row(Dim);
+    res.matrix().template topRows<Dim>().noalias()
+      = other * tr.matrix().template topRows<Dim>();
+    return res;
+  }
+};
+
+/**********************************************************
+*** Specializations of operator* with another Transform ***
+**********************************************************/
+
+template<typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode,LhsOptions>,Transform<Scalar,Dim,RhsMode,RhsOptions>,false >
+{
+  enum { ResultMode = transform_product_result<LhsMode,RhsMode>::Mode };
+  typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,ResultMode,LhsOptions> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    ResultType res;
+    res.linear() = lhs.linear() * rhs.linear();
+    res.translation() = lhs.linear() * rhs.translation() + lhs.translation();
+    res.makeAffine();
+    return res;
+  }
+};
+
+template<typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode,LhsOptions>,Transform<Scalar,Dim,RhsMode,RhsOptions>,true >
+{
+  typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,Projective> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    return ResultType( lhs.matrix() * rhs.matrix() );
+  }
+};
+
+template<typename Scalar, int Dim, int LhsOptions, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,AffineCompact,LhsOptions>,Transform<Scalar,Dim,Projective,RhsOptions>,true >
+{
+  typedef Transform<Scalar,Dim,AffineCompact,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,Projective,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,Projective> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    ResultType res;
+    res.matrix().template topRows<Dim>() = lhs.matrix() * rhs.matrix();
+    res.matrix().row(Dim) = rhs.matrix().row(Dim);
+    return res;
+  }
+};
+
+template<typename Scalar, int Dim, int LhsOptions, int RhsOptions>
+struct transform_transform_product_impl<Transform<Scalar,Dim,Projective,LhsOptions>,Transform<Scalar,Dim,AffineCompact,RhsOptions>,true >
+{
+  typedef Transform<Scalar,Dim,Projective,LhsOptions> Lhs;
+  typedef Transform<Scalar,Dim,AffineCompact,RhsOptions> Rhs;
+  typedef Transform<Scalar,Dim,Projective> ResultType;
+  static ResultType run(const Lhs& lhs, const Rhs& rhs)
+  {
+    ResultType res(lhs.matrix().template leftCols<Dim>() * rhs.matrix());
+    res.matrix().col(Dim) += lhs.matrix().col(Dim);
+    return res;
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSFORM_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Translation.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Translation.h
new file mode 100644
index 00000000..8c229012
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Translation.h
@@ -0,0 +1,202 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TRANSLATION_H
+#define EIGEN_TRANSLATION_H
+
+namespace Eigen { 
+
+/** \geometry_module \ingroup Geometry_Module
+  *
+  * \class Translation
+  *
+  * \brief Represents a translation transformation
+  *
+  * \tparam _Scalar the scalar type, i.e., the type of the coefficients.
+  * \tparam _Dim the  dimension of the space, can be a compile time value or Dynamic
+  *
+  * \note This class is not aimed to be used to store a translation transformation,
+  * but rather to make easier the constructions and updates of Transform objects.
+  *
+  * \sa class Scaling, class Transform
+  */
+template<typename _Scalar, int _Dim>
+class Translation
+{
+public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim)
+  /** dimension of the space */
+  enum { Dim = _Dim };
+  /** the scalar type of the coefficients */
+  typedef _Scalar Scalar;
+  /** corresponding vector type */
+  typedef Matrix<Scalar,Dim,1> VectorType;
+  /** corresponding linear transformation matrix type */
+  typedef Matrix<Scalar,Dim,Dim> LinearMatrixType;
+  /** corresponding affine transformation type */
+  typedef Transform<Scalar,Dim,Affine> AffineTransformType;
+  /** corresponding isometric transformation type */
+  typedef Transform<Scalar,Dim,Isometry> IsometryTransformType;
+
+protected:
+
+  VectorType m_coeffs;
+
+public:
+
+  /** Default constructor without initialization. */
+  EIGEN_DEVICE_FUNC Translation() {}
+  /**  */
+  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy)
+  {
+    eigen_assert(Dim==2);
+    m_coeffs.x() = sx;
+    m_coeffs.y() = sy;
+  }
+  /**  */
+  EIGEN_DEVICE_FUNC inline Translation(const Scalar& sx, const Scalar& sy, const Scalar& sz)
+  {
+    eigen_assert(Dim==3);
+    m_coeffs.x() = sx;
+    m_coeffs.y() = sy;
+    m_coeffs.z() = sz;
+  }
+  /** Constructs and initialize the translation transformation from a vector of translation coefficients */
+  EIGEN_DEVICE_FUNC explicit inline Translation(const VectorType& vector) : m_coeffs(vector) {}
+
+  /** \brief Returns the x-translation by value. **/
+  EIGEN_DEVICE_FUNC inline Scalar x() const { return m_coeffs.x(); }
+  /** \brief Returns the y-translation by value. **/
+  EIGEN_DEVICE_FUNC inline Scalar y() const { return m_coeffs.y(); }
+  /** \brief Returns the z-translation by value. **/
+  EIGEN_DEVICE_FUNC inline Scalar z() const { return m_coeffs.z(); }
+
+  /** \brief Returns the x-translation as a reference. **/
+  EIGEN_DEVICE_FUNC inline Scalar& x() { return m_coeffs.x(); }
+  /** \brief Returns the y-translation as a reference. **/
+  EIGEN_DEVICE_FUNC inline Scalar& y() { return m_coeffs.y(); }
+  /** \brief Returns the z-translation as a reference. **/
+  EIGEN_DEVICE_FUNC inline Scalar& z() { return m_coeffs.z(); }
+
+  EIGEN_DEVICE_FUNC const VectorType& vector() const { return m_coeffs; }
+  EIGEN_DEVICE_FUNC VectorType& vector() { return m_coeffs; }
+
+  EIGEN_DEVICE_FUNC const VectorType& translation() const { return m_coeffs; }
+  EIGEN_DEVICE_FUNC VectorType& translation() { return m_coeffs; }
+
+  /** Concatenates two translation */
+  EIGEN_DEVICE_FUNC inline Translation operator* (const Translation& other) const
+  { return Translation(m_coeffs + other.m_coeffs); }
+
+  /** Concatenates a translation and a uniform scaling */
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator* (const UniformScaling<Scalar>& other) const;
+
+  /** Concatenates a translation and a linear transformation */
+  template<typename OtherDerived>
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator* (const EigenBase<OtherDerived>& linear) const;
+
+  /** Concatenates a translation and a rotation */
+  template<typename Derived>
+  EIGEN_DEVICE_FUNC inline IsometryTransformType operator*(const RotationBase<Derived,Dim>& r) const
+  { return *this * IsometryTransformType(r); }
+
+  /** \returns the concatenation of a linear transformation \a l with the translation \a t */
+  // its a nightmare to define a templated friend function outside its declaration
+  template<typename OtherDerived> friend
+  EIGEN_DEVICE_FUNC inline AffineTransformType operator*(const EigenBase<OtherDerived>& linear, const Translation& t)
+  {
+    AffineTransformType res;
+    res.matrix().setZero();
+    res.linear() = linear.derived();
+    res.translation() = linear.derived() * t.m_coeffs;
+    res.matrix().row(Dim).setZero();
+    res(Dim,Dim) = Scalar(1);
+    return res;
+  }
+
+  /** Concatenates a translation and a transformation */
+  template<int Mode, int Options>
+  EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode> operator* (const Transform<Scalar,Dim,Mode,Options>& t) const
+  {
+    Transform<Scalar,Dim,Mode> res = t;
+    res.pretranslate(m_coeffs);
+    return res;
+  }
+
+  /** Applies translation to vector */
+  template<typename Derived>
+  inline typename internal::enable_if<Derived::IsVectorAtCompileTime,VectorType>::type
+  operator* (const MatrixBase<Derived>& vec) const
+  { return m_coeffs + vec.derived(); }
+
+  /** \returns the inverse translation (opposite) */
+  Translation inverse() const { return Translation(-m_coeffs); }
+
+  static const Translation Identity() { return Translation(VectorType::Zero()); }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType
+    *
+    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
+    * then this function smartly returns a const reference to \c *this.
+    */
+  template<typename NewScalarType>
+  EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::type cast() const
+  { return typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::type(*this); }
+
+  /** Copy constructor with scalar type conversion */
+  template<typename OtherScalarType>
+  EIGEN_DEVICE_FUNC inline explicit Translation(const Translation<OtherScalarType,Dim>& other)
+  { m_coeffs = other.vector().template cast<Scalar>(); }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+    * determined by \a prec.
+    *
+    * \sa MatrixBase::isApprox() */
+  EIGEN_DEVICE_FUNC bool isApprox(const Translation& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
+  { return m_coeffs.isApprox(other.m_coeffs, prec); }
+
+};
+
+/** \addtogroup Geometry_Module */
+//@{
+typedef Translation<float, 2> Translation2f;
+typedef Translation<double,2> Translation2d;
+typedef Translation<float, 3> Translation3f;
+typedef Translation<double,3> Translation3d;
+//@}
+
+template<typename Scalar, int Dim>
+EIGEN_DEVICE_FUNC inline typename Translation<Scalar,Dim>::AffineTransformType
+Translation<Scalar,Dim>::operator* (const UniformScaling<Scalar>& other) const
+{
+  AffineTransformType res;
+  res.matrix().setZero();
+  res.linear().diagonal().fill(other.factor());
+  res.translation() = m_coeffs;
+  res(Dim,Dim) = Scalar(1);
+  return res;
+}
+
+template<typename Scalar, int Dim>
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC inline typename Translation<Scalar,Dim>::AffineTransformType
+Translation<Scalar,Dim>::operator* (const EigenBase<OtherDerived>& linear) const
+{
+  AffineTransformType res;
+  res.matrix().setZero();
+  res.linear() = linear.derived();
+  res.translation() = m_coeffs;
+  res.matrix().row(Dim).setZero();
+  res(Dim,Dim) = Scalar(1);
+  return res;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_TRANSLATION_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Umeyama.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Umeyama.h
new file mode 100644
index 00000000..6b755008
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/Umeyama.h
@@ -0,0 +1,166 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UMEYAMA_H
+#define EIGEN_UMEYAMA_H
+
+// This file requires the user to include 
+// * Eigen/Core
+// * Eigen/LU 
+// * Eigen/SVD
+// * Eigen/Array
+
+namespace Eigen { 
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+// These helpers are required since it allows to use mixed types as parameters
+// for the Umeyama. The problem with mixed parameters is that the return type
+// cannot trivially be deduced when float and double types are mixed.
+namespace internal {
+
+// Compile time return type deduction for different MatrixBase types.
+// Different means here different alignment and parameters but the same underlying
+// real scalar type.
+template<typename MatrixType, typename OtherMatrixType>
+struct umeyama_transform_matrix_type
+{
+  enum {
+    MinRowsAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(MatrixType::RowsAtCompileTime, OtherMatrixType::RowsAtCompileTime),
+
+    // When possible we want to choose some small fixed size value since the result
+    // is likely to fit on the stack. So here, EIGEN_SIZE_MIN_PREFER_DYNAMIC is not what we want.
+    HomogeneousDimension = int(MinRowsAtCompileTime) == Dynamic ? Dynamic : int(MinRowsAtCompileTime)+1
+  };
+
+  typedef Matrix<typename traits<MatrixType>::Scalar,
+    HomogeneousDimension,
+    HomogeneousDimension,
+    AutoAlign | (traits<MatrixType>::Flags & RowMajorBit ? RowMajor : ColMajor),
+    HomogeneousDimension,
+    HomogeneousDimension
+  > type;
+};
+
+}
+
+#endif
+
+/**
+* \geometry_module \ingroup Geometry_Module
+*
+* \brief Returns the transformation between two point sets.
+*
+* The algorithm is based on:
+* "Least-squares estimation of transformation parameters between two point patterns",
+* Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573
+*
+* It estimates parameters \f$ c, \mathbf{R}, \f$ and \f$ \mathbf{t} \f$ such that
+* \f{align*}
+*   \frac{1}{n} \sum_{i=1}^n \vert\vert y_i - (c\mathbf{R}x_i + \mathbf{t}) \vert\vert_2^2
+* \f}
+* is minimized.
+*
+* The algorithm is based on the analysis of the covariance matrix
+* \f$ \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \f$
+* of the input point sets \f$ \mathbf{x} \f$ and \f$ \mathbf{y} \f$ where 
+* \f$d\f$ is corresponding to the dimension (which is typically small).
+* The analysis is involving the SVD having a complexity of \f$O(d^3)\f$
+* though the actual computational effort lies in the covariance
+* matrix computation which has an asymptotic lower bound of \f$O(dm)\f$ when 
+* the input point sets have dimension \f$d \times m\f$.
+*
+* Currently the method is working only for floating point matrices.
+*
+* \todo Should the return type of umeyama() become a Transform?
+*
+* \param src Source points \f$ \mathbf{x} = \left( x_1, \hdots, x_n \right) \f$.
+* \param dst Destination points \f$ \mathbf{y} = \left( y_1, \hdots, y_n \right) \f$.
+* \param with_scaling Sets \f$ c=1 \f$ when <code>false</code> is passed.
+* \return The homogeneous transformation 
+* \f{align*}
+*   T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix}
+* \f}
+* minimizing the residual above. This transformation is always returned as an 
+* Eigen::Matrix.
+*/
+template <typename Derived, typename OtherDerived>
+typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type
+umeyama(const MatrixBase<Derived>& src, const MatrixBase<OtherDerived>& dst, bool with_scaling = true)
+{
+  typedef typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type TransformationMatrixType;
+  typedef typename internal::traits<TransformationMatrixType>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename internal::traits<OtherDerived>::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  enum { Dimension = EIGEN_SIZE_MIN_PREFER_DYNAMIC(Derived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime) };
+
+  typedef Matrix<Scalar, Dimension, 1> VectorType;
+  typedef Matrix<Scalar, Dimension, Dimension> MatrixType;
+  typedef typename internal::plain_matrix_type_row_major<Derived>::type RowMajorMatrixType;
+
+  const Index m = src.rows(); // dimension
+  const Index n = src.cols(); // number of measurements
+
+  // required for demeaning ...
+  const RealScalar one_over_n = RealScalar(1) / static_cast<RealScalar>(n);
+
+  // computation of mean
+  const VectorType src_mean = src.rowwise().sum() * one_over_n;
+  const VectorType dst_mean = dst.rowwise().sum() * one_over_n;
+
+  // demeaning of src and dst points
+  const RowMajorMatrixType src_demean = src.colwise() - src_mean;
+  const RowMajorMatrixType dst_demean = dst.colwise() - dst_mean;
+
+  // Eq. (36)-(37)
+  const Scalar src_var = src_demean.rowwise().squaredNorm().sum() * one_over_n;
+
+  // Eq. (38)
+  const MatrixType sigma = one_over_n * dst_demean * src_demean.transpose();
+
+  JacobiSVD<MatrixType> svd(sigma, ComputeFullU | ComputeFullV);
+
+  // Initialize the resulting transformation with an identity matrix...
+  TransformationMatrixType Rt = TransformationMatrixType::Identity(m+1,m+1);
+
+  // Eq. (39)
+  VectorType S = VectorType::Ones(m);
+
+  if  ( svd.matrixU().determinant() * svd.matrixV().determinant() < 0 )
+    S(m-1) = -1;
+
+  // Eq. (40) and (43)
+  Rt.block(0,0,m,m).noalias() = svd.matrixU() * S.asDiagonal() * svd.matrixV().transpose();
+
+  if (with_scaling)
+  {
+    // Eq. (42)
+    const Scalar c = Scalar(1)/src_var * svd.singularValues().dot(S);
+
+    // Eq. (41)
+    Rt.col(m).head(m) = dst_mean;
+    Rt.col(m).head(m).noalias() -= c*Rt.topLeftCorner(m,m)*src_mean;
+    Rt.block(0,0,m,m) *= c;
+  }
+  else
+  {
+    Rt.col(m).head(m) = dst_mean;
+    Rt.col(m).head(m).noalias() -= Rt.topLeftCorner(m,m)*src_mean;
+  }
+
+  return Rt;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_UMEYAMA_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/arch/Geometry_SIMD.h b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/arch/Geometry_SIMD.h
new file mode 100644
index 00000000..9af6a9af
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Geometry/arch/Geometry_SIMD.h
@@ -0,0 +1,168 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Rohit Garg <rpg.314@gmail.com>
+// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GEOMETRY_SIMD_H
+#define EIGEN_GEOMETRY_SIMD_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<class Derived, class OtherDerived>
+struct quat_product<Architecture::Target, Derived, OtherDerived, float>
+{
+  enum {
+    AAlignment = traits<Derived>::Alignment,
+    BAlignment = traits<OtherDerived>::Alignment,
+    ResAlignment = traits<Quaternion<float> >::Alignment
+  };
+  static inline Quaternion<float> run(const QuaternionBase<Derived>& _a, const QuaternionBase<OtherDerived>& _b)
+  {
+    evaluator<typename Derived::Coefficients> ae(_a.coeffs());
+    evaluator<typename OtherDerived::Coefficients> be(_b.coeffs());
+    Quaternion<float> res;
+    const float neg_zero = numext::bit_cast<float>(0x80000000u);
+    const float arr[4] = {0.f, 0.f, 0.f, neg_zero};
+    const Packet4f mask = ploadu<Packet4f>(arr);
+    Packet4f a = ae.template packet<AAlignment,Packet4f>(0);
+    Packet4f b = be.template packet<BAlignment,Packet4f>(0);
+    Packet4f s1 = pmul(vec4f_swizzle1(a,1,2,0,2),vec4f_swizzle1(b,2,0,1,2));
+    Packet4f s2 = pmul(vec4f_swizzle1(a,3,3,3,1),vec4f_swizzle1(b,0,1,2,1));
+    pstoret<float,Packet4f,ResAlignment>(
+              &res.x(),
+              padd(psub(pmul(a,vec4f_swizzle1(b,3,3,3,3)),
+                                    pmul(vec4f_swizzle1(a,2,0,1,0),
+                                               vec4f_swizzle1(b,1,2,0,0))),
+                         pxor(mask,padd(s1,s2))));
+    
+    return res;
+  }
+};
+
+template<class Derived>
+struct quat_conj<Architecture::Target, Derived, float>
+{
+  enum {
+    ResAlignment = traits<Quaternion<float> >::Alignment
+  };
+  static inline Quaternion<float> run(const QuaternionBase<Derived>& q)
+  {
+    evaluator<typename Derived::Coefficients> qe(q.coeffs());
+    Quaternion<float> res;
+    const float neg_zero = numext::bit_cast<float>(0x80000000u);
+    const float arr[4] = {neg_zero, neg_zero, neg_zero,0.f};
+    const Packet4f mask = ploadu<Packet4f>(arr);
+    pstoret<float,Packet4f,ResAlignment>(&res.x(), pxor(mask, qe.template packet<traits<Derived>::Alignment,Packet4f>(0)));
+    return res;
+  }
+};
+
+
+template<typename VectorLhs,typename VectorRhs>
+struct cross3_impl<Architecture::Target,VectorLhs,VectorRhs,float,true>
+{
+  enum {
+    ResAlignment = traits<typename plain_matrix_type<VectorLhs>::type>::Alignment
+  };
+  static inline typename plain_matrix_type<VectorLhs>::type
+  run(const VectorLhs& lhs, const VectorRhs& rhs)
+  {
+    evaluator<VectorLhs> lhs_eval(lhs);
+    evaluator<VectorRhs> rhs_eval(rhs);
+    Packet4f a = lhs_eval.template packet<traits<VectorLhs>::Alignment,Packet4f>(0);
+    Packet4f b = rhs_eval.template packet<traits<VectorRhs>::Alignment,Packet4f>(0);
+    Packet4f mul1 = pmul(vec4f_swizzle1(a,1,2,0,3),vec4f_swizzle1(b,2,0,1,3));
+    Packet4f mul2 = pmul(vec4f_swizzle1(a,2,0,1,3),vec4f_swizzle1(b,1,2,0,3));
+    typename plain_matrix_type<VectorLhs>::type res;
+    pstoret<float,Packet4f,ResAlignment>(&res.x(),psub(mul1,mul2));
+    return res;
+  }
+};
+
+
+
+#if (defined EIGEN_VECTORIZE_SSE) || (EIGEN_ARCH_ARM64)
+
+template<class Derived, class OtherDerived>
+struct quat_product<Architecture::Target, Derived, OtherDerived, double>
+{
+  enum {
+    BAlignment = traits<OtherDerived>::Alignment,
+    ResAlignment = traits<Quaternion<double> >::Alignment
+  };
+
+  static inline Quaternion<double> run(const QuaternionBase<Derived>& _a, const QuaternionBase<OtherDerived>& _b)
+  {
+  Quaternion<double> res;
+
+  evaluator<typename Derived::Coefficients> ae(_a.coeffs());
+  evaluator<typename OtherDerived::Coefficients> be(_b.coeffs());
+
+  const double* a = _a.coeffs().data();
+  Packet2d b_xy = be.template packet<BAlignment,Packet2d>(0);
+  Packet2d b_zw = be.template packet<BAlignment,Packet2d>(2);
+  Packet2d a_xx = pset1<Packet2d>(a[0]);
+  Packet2d a_yy = pset1<Packet2d>(a[1]);
+  Packet2d a_zz = pset1<Packet2d>(a[2]);
+  Packet2d a_ww = pset1<Packet2d>(a[3]);
+
+  // two temporaries:
+  Packet2d t1, t2;
+
+  /*
+   * t1 = ww*xy + yy*zw
+   * t2 = zz*xy - xx*zw
+   * res.xy = t1 +/- swap(t2)
+   */
+  t1 = padd(pmul(a_ww, b_xy), pmul(a_yy, b_zw));
+  t2 = psub(pmul(a_zz, b_xy), pmul(a_xx, b_zw));
+  pstoret<double,Packet2d,ResAlignment>(&res.x(), paddsub(t1, preverse(t2)));
+  
+  /*
+   * t1 = ww*zw - yy*xy
+   * t2 = zz*zw + xx*xy
+   * res.zw = t1 -/+ swap(t2) = swap( swap(t1) +/- t2)
+   */
+  t1 = psub(pmul(a_ww, b_zw), pmul(a_yy, b_xy));
+  t2 = padd(pmul(a_zz, b_zw), pmul(a_xx, b_xy));
+  pstoret<double,Packet2d,ResAlignment>(&res.z(), preverse(paddsub(preverse(t1), t2)));
+
+  return res;
+}
+};
+
+template<class Derived>
+struct quat_conj<Architecture::Target, Derived, double>
+{
+  enum {
+    ResAlignment = traits<Quaternion<double> >::Alignment
+  };
+  static inline Quaternion<double> run(const QuaternionBase<Derived>& q)
+  {
+    evaluator<typename Derived::Coefficients> qe(q.coeffs());
+    Quaternion<double> res;
+    const double neg_zero = numext::bit_cast<double>(0x8000000000000000ull);
+    const double arr1[2] = {neg_zero, neg_zero};
+    const double arr2[2] = {neg_zero,  0.0};
+    const Packet2d mask0 = ploadu<Packet2d>(arr1);
+    const Packet2d mask2 = ploadu<Packet2d>(arr2);
+    pstoret<double,Packet2d,ResAlignment>(&res.x(), pxor(mask0, qe.template packet<traits<Derived>::Alignment,Packet2d>(0)));
+    pstoret<double,Packet2d,ResAlignment>(&res.z(), pxor(mask2, qe.template packet<traits<Derived>::Alignment,Packet2d>(2)));
+    return res;
+  }
+};
+
+#endif // end EIGEN_VECTORIZE_SSE_OR_EIGEN_ARCH_ARM64
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_GEOMETRY_SIMD_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Householder/BlockHouseholder.h b/C++/yolo_bytetrack_old/include/Eigen/src/Householder/BlockHouseholder.h
new file mode 100644
index 00000000..39ce1c2a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Householder/BlockHouseholder.h
@@ -0,0 +1,110 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Vincent Lejeune
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BLOCK_HOUSEHOLDER_H
+#define EIGEN_BLOCK_HOUSEHOLDER_H
+
+// This file contains some helper function to deal with block householder reflectors
+
+namespace Eigen { 
+
+namespace internal {
+  
+/** \internal */
+// template<typename TriangularFactorType,typename VectorsType,typename CoeffsType>
+// void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs)
+// {
+//   typedef typename VectorsType::Scalar Scalar;
+//   const Index nbVecs = vectors.cols();
+//   eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs);
+// 
+//   for(Index i = 0; i < nbVecs; i++)
+//   {
+//     Index rs = vectors.rows() - i;
+//     // Warning, note that hCoeffs may alias with vectors.
+//     // It is then necessary to copy it before modifying vectors(i,i). 
+//     typename CoeffsType::Scalar h = hCoeffs(i);
+//     // This hack permits to pass trough nested Block<> and Transpose<> expressions.
+//     Scalar *Vii_ptr = const_cast<Scalar*>(vectors.data() + vectors.outerStride()*i + vectors.innerStride()*i);
+//     Scalar Vii = *Vii_ptr;
+//     *Vii_ptr = Scalar(1);
+//     triFactor.col(i).head(i).noalias() = -h * vectors.block(i, 0, rs, i).adjoint()
+//                                        * vectors.col(i).tail(rs);
+//     *Vii_ptr = Vii;
+//     // FIXME add .noalias() once the triangular product can work inplace
+//     triFactor.col(i).head(i) = triFactor.block(0,0,i,i).template triangularView<Upper>()
+//                              * triFactor.col(i).head(i);
+//     triFactor(i,i) = hCoeffs(i);
+//   }
+// }
+
+/** \internal */
+// This variant avoid modifications in vectors
+template<typename TriangularFactorType,typename VectorsType,typename CoeffsType>
+void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs)
+{
+  const Index nbVecs = vectors.cols();
+  eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs);
+
+  for(Index i = nbVecs-1; i >=0 ; --i)
+  {
+    Index rs = vectors.rows() - i - 1;
+    Index rt = nbVecs-i-1;
+
+    if(rt>0)
+    {
+      triFactor.row(i).tail(rt).noalias() = -hCoeffs(i) * vectors.col(i).tail(rs).adjoint()
+                                                        * vectors.bottomRightCorner(rs, rt).template triangularView<UnitLower>();
+            
+      // FIXME use the following line with .noalias() once the triangular product can work inplace
+      // triFactor.row(i).tail(rt) = triFactor.row(i).tail(rt) * triFactor.bottomRightCorner(rt,rt).template triangularView<Upper>();
+      for(Index j=nbVecs-1; j>i; --j)
+      {
+        typename TriangularFactorType::Scalar z = triFactor(i,j);
+        triFactor(i,j) = z * triFactor(j,j);
+        if(nbVecs-j-1>0)
+          triFactor.row(i).tail(nbVecs-j-1) += z * triFactor.row(j).tail(nbVecs-j-1);
+      }
+      
+    }
+    triFactor(i,i) = hCoeffs(i);
+  }
+}
+
+/** \internal
+  * if forward then perform   mat = H0 * H1 * H2 * mat
+  * otherwise perform         mat = H2 * H1 * H0 * mat
+  */
+template<typename MatrixType,typename VectorsType,typename CoeffsType>
+void apply_block_householder_on_the_left(MatrixType& mat, const VectorsType& vectors, const CoeffsType& hCoeffs, bool forward)
+{
+  enum { TFactorSize = MatrixType::ColsAtCompileTime };
+  Index nbVecs = vectors.cols();
+  Matrix<typename MatrixType::Scalar, TFactorSize, TFactorSize, RowMajor> T(nbVecs,nbVecs);
+  
+  if(forward) make_block_householder_triangular_factor(T, vectors, hCoeffs);
+  else        make_block_householder_triangular_factor(T, vectors, hCoeffs.conjugate());  
+  const TriangularView<const VectorsType, UnitLower> V(vectors);
+
+  // A -= V T V^* A
+  Matrix<typename MatrixType::Scalar,VectorsType::ColsAtCompileTime,MatrixType::ColsAtCompileTime,
+         (VectorsType::MaxColsAtCompileTime==1 && MatrixType::MaxColsAtCompileTime!=1)?RowMajor:ColMajor,
+         VectorsType::MaxColsAtCompileTime,MatrixType::MaxColsAtCompileTime> tmp = V.adjoint() * mat;
+  // FIXME add .noalias() once the triangular product can work inplace
+  if(forward) tmp = T.template triangularView<Upper>()           * tmp;
+  else        tmp = T.template triangularView<Upper>().adjoint() * tmp;
+  mat.noalias() -= V * tmp;
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BLOCK_HOUSEHOLDER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Householder/Householder.h b/C++/yolo_bytetrack_old/include/Eigen/src/Householder/Householder.h
new file mode 100644
index 00000000..5bc037f0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Householder/Householder.h
@@ -0,0 +1,176 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOUSEHOLDER_H
+#define EIGEN_HOUSEHOLDER_H
+
+namespace Eigen { 
+
+namespace internal {
+template<int n> struct decrement_size
+{
+  enum {
+    ret = n==Dynamic ? n : n-1
+  };
+};
+}
+
+/** Computes the elementary reflector H such that:
+  * \f$ H *this = [ beta 0 ... 0]^T \f$
+  * where the transformation H is:
+  * \f$ H = I - tau v v^*\f$
+  * and the vector v is:
+  * \f$ v^T = [1 essential^T] \f$
+  *
+  * The essential part of the vector \c v is stored in *this.
+  * 
+  * On output:
+  * \param tau the scaling factor of the Householder transformation
+  * \param beta the result of H * \c *this
+  *
+  * \sa MatrixBase::makeHouseholder(), MatrixBase::applyHouseholderOnTheLeft(),
+  *     MatrixBase::applyHouseholderOnTheRight()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+void MatrixBase<Derived>::makeHouseholderInPlace(Scalar& tau, RealScalar& beta)
+{
+  VectorBlock<Derived, internal::decrement_size<Base::SizeAtCompileTime>::ret> essentialPart(derived(), 1, size()-1);
+  makeHouseholder(essentialPart, tau, beta);
+}
+
+/** Computes the elementary reflector H such that:
+  * \f$ H *this = [ beta 0 ... 0]^T \f$
+  * where the transformation H is:
+  * \f$ H = I - tau v v^*\f$
+  * and the vector v is:
+  * \f$ v^T = [1 essential^T] \f$
+  *
+  * On output:
+  * \param essential the essential part of the vector \c v
+  * \param tau the scaling factor of the Householder transformation
+  * \param beta the result of H * \c *this
+  *
+  * \sa MatrixBase::makeHouseholderInPlace(), MatrixBase::applyHouseholderOnTheLeft(),
+  *     MatrixBase::applyHouseholderOnTheRight()
+  */
+template<typename Derived>
+template<typename EssentialPart>
+EIGEN_DEVICE_FUNC
+void MatrixBase<Derived>::makeHouseholder(
+  EssentialPart& essential,
+  Scalar& tau,
+  RealScalar& beta) const
+{
+  using std::sqrt;
+  using numext::conj;
+  
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(EssentialPart)
+  VectorBlock<const Derived, EssentialPart::SizeAtCompileTime> tail(derived(), 1, size()-1);
+  
+  RealScalar tailSqNorm = size()==1 ? RealScalar(0) : tail.squaredNorm();
+  Scalar c0 = coeff(0);
+  const RealScalar tol = (std::numeric_limits<RealScalar>::min)();
+
+  if(tailSqNorm <= tol && numext::abs2(numext::imag(c0))<=tol)
+  {
+    tau = RealScalar(0);
+    beta = numext::real(c0);
+    essential.setZero();
+  }
+  else
+  {
+    beta = sqrt(numext::abs2(c0) + tailSqNorm);
+    if (numext::real(c0)>=RealScalar(0))
+      beta = -beta;
+    essential = tail / (c0 - beta);
+    tau = conj((beta - c0) / beta);
+  }
+}
+
+/** Apply the elementary reflector H given by
+  * \f$ H = I - tau v v^*\f$
+  * with
+  * \f$ v^T = [1 essential^T] \f$
+  * from the left to a vector or matrix.
+  *
+  * On input:
+  * \param essential the essential part of the vector \c v
+  * \param tau the scaling factor of the Householder transformation
+  * \param workspace a pointer to working space with at least
+  *                  this->cols() entries
+  *
+  * \sa MatrixBase::makeHouseholder(), MatrixBase::makeHouseholderInPlace(), 
+  *     MatrixBase::applyHouseholderOnTheRight()
+  */
+template<typename Derived>
+template<typename EssentialPart>
+EIGEN_DEVICE_FUNC
+void MatrixBase<Derived>::applyHouseholderOnTheLeft(
+  const EssentialPart& essential,
+  const Scalar& tau,
+  Scalar* workspace)
+{
+  if(rows() == 1)
+  {
+    *this *= Scalar(1)-tau;
+  }
+  else if(tau!=Scalar(0))
+  {
+    Map<typename internal::plain_row_type<PlainObject>::type> tmp(workspace,cols());
+    Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(derived(), 1, 0, rows()-1, cols());
+    tmp.noalias() = essential.adjoint() * bottom;
+    tmp += this->row(0);
+    this->row(0) -= tau * tmp;
+    bottom.noalias() -= tau * essential * tmp;
+  }
+}
+
+/** Apply the elementary reflector H given by
+  * \f$ H = I - tau v v^*\f$
+  * with
+  * \f$ v^T = [1 essential^T] \f$
+  * from the right to a vector or matrix.
+  *
+  * On input:
+  * \param essential the essential part of the vector \c v
+  * \param tau the scaling factor of the Householder transformation
+  * \param workspace a pointer to working space with at least
+  *                  this->rows() entries
+  *
+  * \sa MatrixBase::makeHouseholder(), MatrixBase::makeHouseholderInPlace(), 
+  *     MatrixBase::applyHouseholderOnTheLeft()
+  */
+template<typename Derived>
+template<typename EssentialPart>
+EIGEN_DEVICE_FUNC
+void MatrixBase<Derived>::applyHouseholderOnTheRight(
+  const EssentialPart& essential,
+  const Scalar& tau,
+  Scalar* workspace)
+{
+  if(cols() == 1)
+  {
+    *this *= Scalar(1)-tau;
+  }
+  else if(tau!=Scalar(0))
+  {
+    Map<typename internal::plain_col_type<PlainObject>::type> tmp(workspace,rows());
+    Block<Derived, Derived::RowsAtCompileTime, EssentialPart::SizeAtCompileTime> right(derived(), 0, 1, rows(), cols()-1);
+    tmp.noalias() = right * essential;
+    tmp += this->col(0);
+    this->col(0) -= tau * tmp;
+    right.noalias() -= tau * tmp * essential.adjoint();
+  }
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_HOUSEHOLDER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Householder/HouseholderSequence.h b/C++/yolo_bytetrack_old/include/Eigen/src/Householder/HouseholderSequence.h
new file mode 100644
index 00000000..022f6c3d
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Householder/HouseholderSequence.h
@@ -0,0 +1,545 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOUSEHOLDER_SEQUENCE_H
+#define EIGEN_HOUSEHOLDER_SEQUENCE_H
+
+namespace Eigen {
+
+/** \ingroup Householder_Module
+  * \householder_module
+  * \class HouseholderSequence
+  * \brief Sequence of Householder reflections acting on subspaces with decreasing size
+  * \tparam VectorsType type of matrix containing the Householder vectors
+  * \tparam CoeffsType  type of vector containing the Householder coefficients
+  * \tparam Side        either OnTheLeft (the default) or OnTheRight
+  *
+  * This class represents a product sequence of Householder reflections where the first Householder reflection
+  * acts on the whole space, the second Householder reflection leaves the one-dimensional subspace spanned by
+  * the first unit vector invariant, the third Householder reflection leaves the two-dimensional subspace
+  * spanned by the first two unit vectors invariant, and so on up to the last reflection which leaves all but
+  * one dimensions invariant and acts only on the last dimension. Such sequences of Householder reflections
+  * are used in several algorithms to zero out certain parts of a matrix. Indeed, the methods
+  * HessenbergDecomposition::matrixQ(), Tridiagonalization::matrixQ(), HouseholderQR::householderQ(),
+  * and ColPivHouseholderQR::householderQ() all return a %HouseholderSequence.
+  *
+  * More precisely, the class %HouseholderSequence represents an \f$ n \times n \f$ matrix \f$ H \f$ of the
+  * form \f$ H = \prod_{i=0}^{n-1} H_i \f$ where the i-th Householder reflection is \f$ H_i = I - h_i v_i
+  * v_i^* \f$. The i-th Householder coefficient \f$ h_i \f$ is a scalar and the i-th Householder vector \f$
+  * v_i \f$ is a vector of the form
+  * \f[
+  * v_i = [\underbrace{0, \ldots, 0}_{i-1\mbox{ zeros}}, 1, \underbrace{*, \ldots,*}_{n-i\mbox{ arbitrary entries}} ].
+  * \f]
+  * The last \f$ n-i \f$ entries of \f$ v_i \f$ are called the essential part of the Householder vector.
+  *
+  * Typical usages are listed below, where H is a HouseholderSequence:
+  * \code
+  * A.applyOnTheRight(H);             // A = A * H
+  * A.applyOnTheLeft(H);              // A = H * A
+  * A.applyOnTheRight(H.adjoint());   // A = A * H^*
+  * A.applyOnTheLeft(H.adjoint());    // A = H^* * A
+  * MatrixXd Q = H;                   // conversion to a dense matrix
+  * \endcode
+  * In addition to the adjoint, you can also apply the inverse (=adjoint), the transpose, and the conjugate operators.
+  *
+  * See the documentation for HouseholderSequence(const VectorsType&, const CoeffsType&) for an example.
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+
+namespace internal {
+
+template<typename VectorsType, typename CoeffsType, int Side>
+struct traits<HouseholderSequence<VectorsType,CoeffsType,Side> >
+{
+  typedef typename VectorsType::Scalar Scalar;
+  typedef typename VectorsType::StorageIndex StorageIndex;
+  typedef typename VectorsType::StorageKind StorageKind;
+  enum {
+    RowsAtCompileTime = Side==OnTheLeft ? traits<VectorsType>::RowsAtCompileTime
+                                        : traits<VectorsType>::ColsAtCompileTime,
+    ColsAtCompileTime = RowsAtCompileTime,
+    MaxRowsAtCompileTime = Side==OnTheLeft ? traits<VectorsType>::MaxRowsAtCompileTime
+                                           : traits<VectorsType>::MaxColsAtCompileTime,
+    MaxColsAtCompileTime = MaxRowsAtCompileTime,
+    Flags = 0
+  };
+};
+
+struct HouseholderSequenceShape {};
+
+template<typename VectorsType, typename CoeffsType, int Side>
+struct evaluator_traits<HouseholderSequence<VectorsType,CoeffsType,Side> >
+  : public evaluator_traits_base<HouseholderSequence<VectorsType,CoeffsType,Side> >
+{
+  typedef HouseholderSequenceShape Shape;
+};
+
+template<typename VectorsType, typename CoeffsType, int Side>
+struct hseq_side_dependent_impl
+{
+  typedef Block<const VectorsType, Dynamic, 1> EssentialVectorType;
+  typedef HouseholderSequence<VectorsType, CoeffsType, OnTheLeft> HouseholderSequenceType;
+  static EIGEN_DEVICE_FUNC inline const EssentialVectorType essentialVector(const HouseholderSequenceType& h, Index k)
+  {
+    Index start = k+1+h.m_shift;
+    return Block<const VectorsType,Dynamic,1>(h.m_vectors, start, k, h.rows()-start, 1);
+  }
+};
+
+template<typename VectorsType, typename CoeffsType>
+struct hseq_side_dependent_impl<VectorsType, CoeffsType, OnTheRight>
+{
+  typedef Transpose<Block<const VectorsType, 1, Dynamic> > EssentialVectorType;
+  typedef HouseholderSequence<VectorsType, CoeffsType, OnTheRight> HouseholderSequenceType;
+  static inline const EssentialVectorType essentialVector(const HouseholderSequenceType& h, Index k)
+  {
+    Index start = k+1+h.m_shift;
+    return Block<const VectorsType,1,Dynamic>(h.m_vectors, k, start, 1, h.rows()-start).transpose();
+  }
+};
+
+template<typename OtherScalarType, typename MatrixType> struct matrix_type_times_scalar_type
+{
+  typedef typename ScalarBinaryOpTraits<OtherScalarType, typename MatrixType::Scalar>::ReturnType
+    ResultScalar;
+  typedef Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime,
+                 0, MatrixType::MaxRowsAtCompileTime, MatrixType::MaxColsAtCompileTime> Type;
+};
+
+} // end namespace internal
+
+template<typename VectorsType, typename CoeffsType, int Side> class HouseholderSequence
+  : public EigenBase<HouseholderSequence<VectorsType,CoeffsType,Side> >
+{
+    typedef typename internal::hseq_side_dependent_impl<VectorsType,CoeffsType,Side>::EssentialVectorType EssentialVectorType;
+
+  public:
+    enum {
+      RowsAtCompileTime = internal::traits<HouseholderSequence>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<HouseholderSequence>::ColsAtCompileTime,
+      MaxRowsAtCompileTime = internal::traits<HouseholderSequence>::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = internal::traits<HouseholderSequence>::MaxColsAtCompileTime
+    };
+    typedef typename internal::traits<HouseholderSequence>::Scalar Scalar;
+
+    typedef HouseholderSequence<
+      typename internal::conditional<NumTraits<Scalar>::IsComplex,
+        typename internal::remove_all<typename VectorsType::ConjugateReturnType>::type,
+        VectorsType>::type,
+      typename internal::conditional<NumTraits<Scalar>::IsComplex,
+        typename internal::remove_all<typename CoeffsType::ConjugateReturnType>::type,
+        CoeffsType>::type,
+      Side
+    > ConjugateReturnType;
+
+    typedef HouseholderSequence<
+      VectorsType,
+      typename internal::conditional<NumTraits<Scalar>::IsComplex,
+        typename internal::remove_all<typename CoeffsType::ConjugateReturnType>::type,
+        CoeffsType>::type,
+      Side
+    > AdjointReturnType;
+
+    typedef HouseholderSequence<
+      typename internal::conditional<NumTraits<Scalar>::IsComplex,
+        typename internal::remove_all<typename VectorsType::ConjugateReturnType>::type,
+        VectorsType>::type,
+      CoeffsType,
+      Side
+    > TransposeReturnType;
+
+    typedef HouseholderSequence<
+      typename internal::add_const<VectorsType>::type,
+      typename internal::add_const<CoeffsType>::type,
+      Side
+    > ConstHouseholderSequence;
+
+    /** \brief Constructor.
+      * \param[in]  v      %Matrix containing the essential parts of the Householder vectors
+      * \param[in]  h      Vector containing the Householder coefficients
+      *
+      * Constructs the Householder sequence with coefficients given by \p h and vectors given by \p v. The
+      * i-th Householder coefficient \f$ h_i \f$ is given by \p h(i) and the essential part of the i-th
+      * Householder vector \f$ v_i \f$ is given by \p v(k,i) with \p k > \p i (the subdiagonal part of the
+      * i-th column). If \p v has fewer columns than rows, then the Householder sequence contains as many
+      * Householder reflections as there are columns.
+      *
+      * \note The %HouseholderSequence object stores \p v and \p h by reference.
+      *
+      * Example: \include HouseholderSequence_HouseholderSequence.cpp
+      * Output: \verbinclude HouseholderSequence_HouseholderSequence.out
+      *
+      * \sa setLength(), setShift()
+      */
+    EIGEN_DEVICE_FUNC
+    HouseholderSequence(const VectorsType& v, const CoeffsType& h)
+      : m_vectors(v), m_coeffs(h), m_reverse(false), m_length(v.diagonalSize()),
+        m_shift(0)
+    {
+    }
+
+    /** \brief Copy constructor. */
+    EIGEN_DEVICE_FUNC
+    HouseholderSequence(const HouseholderSequence& other)
+      : m_vectors(other.m_vectors),
+        m_coeffs(other.m_coeffs),
+        m_reverse(other.m_reverse),
+        m_length(other.m_length),
+        m_shift(other.m_shift)
+    {
+    }
+
+    /** \brief Number of rows of transformation viewed as a matrix.
+      * \returns Number of rows
+      * \details This equals the dimension of the space that the transformation acts on.
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index rows() const EIGEN_NOEXCEPT { return Side==OnTheLeft ? m_vectors.rows() : m_vectors.cols(); }
+
+    /** \brief Number of columns of transformation viewed as a matrix.
+      * \returns Number of columns
+      * \details This equals the dimension of the space that the transformation acts on.
+      */
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    Index cols() const EIGEN_NOEXCEPT { return rows(); }
+
+    /** \brief Essential part of a Householder vector.
+      * \param[in]  k  Index of Householder reflection
+      * \returns    Vector containing non-trivial entries of k-th Householder vector
+      *
+      * This function returns the essential part of the Householder vector \f$ v_i \f$. This is a vector of
+      * length \f$ n-i \f$ containing the last \f$ n-i \f$ entries of the vector
+      * \f[
+      * v_i = [\underbrace{0, \ldots, 0}_{i-1\mbox{ zeros}}, 1, \underbrace{*, \ldots,*}_{n-i\mbox{ arbitrary entries}} ].
+      * \f]
+      * The index \f$ i \f$ equals \p k + shift(), corresponding to the k-th column of the matrix \p v
+      * passed to the constructor.
+      *
+      * \sa setShift(), shift()
+      */
+    EIGEN_DEVICE_FUNC
+    const EssentialVectorType essentialVector(Index k) const
+    {
+      eigen_assert(k >= 0 && k < m_length);
+      return internal::hseq_side_dependent_impl<VectorsType,CoeffsType,Side>::essentialVector(*this, k);
+    }
+
+    /** \brief %Transpose of the Householder sequence. */
+    TransposeReturnType transpose() const
+    {
+      return TransposeReturnType(m_vectors.conjugate(), m_coeffs)
+              .setReverseFlag(!m_reverse)
+              .setLength(m_length)
+              .setShift(m_shift);
+    }
+
+    /** \brief Complex conjugate of the Householder sequence. */
+    ConjugateReturnType conjugate() const
+    {
+      return ConjugateReturnType(m_vectors.conjugate(), m_coeffs.conjugate())
+             .setReverseFlag(m_reverse)
+             .setLength(m_length)
+             .setShift(m_shift);
+    }
+
+    /** \returns an expression of the complex conjugate of \c *this if Cond==true,
+     *           returns \c *this otherwise.
+     */
+    template<bool Cond>
+    EIGEN_DEVICE_FUNC
+    inline typename internal::conditional<Cond,ConjugateReturnType,ConstHouseholderSequence>::type
+    conjugateIf() const
+    {
+      typedef typename internal::conditional<Cond,ConjugateReturnType,ConstHouseholderSequence>::type ReturnType;
+      return ReturnType(m_vectors.template conjugateIf<Cond>(), m_coeffs.template conjugateIf<Cond>());
+    }
+
+    /** \brief Adjoint (conjugate transpose) of the Householder sequence. */
+    AdjointReturnType adjoint() const
+    {
+      return AdjointReturnType(m_vectors, m_coeffs.conjugate())
+              .setReverseFlag(!m_reverse)
+              .setLength(m_length)
+              .setShift(m_shift);
+    }
+
+    /** \brief Inverse of the Householder sequence (equals the adjoint). */
+    AdjointReturnType inverse() const { return adjoint(); }
+
+    /** \internal */
+    template<typename DestType>
+    inline EIGEN_DEVICE_FUNC
+    void evalTo(DestType& dst) const
+    {
+      Matrix<Scalar, DestType::RowsAtCompileTime, 1,
+             AutoAlign|ColMajor, DestType::MaxRowsAtCompileTime, 1> workspace(rows());
+      evalTo(dst, workspace);
+    }
+
+    /** \internal */
+    template<typename Dest, typename Workspace>
+    EIGEN_DEVICE_FUNC
+    void evalTo(Dest& dst, Workspace& workspace) const
+    {
+      workspace.resize(rows());
+      Index vecs = m_length;
+      if(internal::is_same_dense(dst,m_vectors))
+      {
+        // in-place
+        dst.diagonal().setOnes();
+        dst.template triangularView<StrictlyUpper>().setZero();
+        for(Index k = vecs-1; k >= 0; --k)
+        {
+          Index cornerSize = rows() - k - m_shift;
+          if(m_reverse)
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheRight(essentialVector(k), m_coeffs.coeff(k), workspace.data());
+          else
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheLeft(essentialVector(k), m_coeffs.coeff(k), workspace.data());
+
+          // clear the off diagonal vector
+          dst.col(k).tail(rows()-k-1).setZero();
+        }
+        // clear the remaining columns if needed
+        for(Index k = 0; k<cols()-vecs ; ++k)
+          dst.col(k).tail(rows()-k-1).setZero();
+      }
+      else if(m_length>BlockSize)
+      {
+        dst.setIdentity(rows(), rows());
+        if(m_reverse)
+          applyThisOnTheLeft(dst,workspace,true);
+        else
+          applyThisOnTheLeft(dst,workspace,true);
+      }
+      else
+      {
+        dst.setIdentity(rows(), rows());
+        for(Index k = vecs-1; k >= 0; --k)
+        {
+          Index cornerSize = rows() - k - m_shift;
+          if(m_reverse)
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheRight(essentialVector(k), m_coeffs.coeff(k), workspace.data());
+          else
+            dst.bottomRightCorner(cornerSize, cornerSize)
+               .applyHouseholderOnTheLeft(essentialVector(k), m_coeffs.coeff(k), workspace.data());
+        }
+      }
+    }
+
+    /** \internal */
+    template<typename Dest> inline void applyThisOnTheRight(Dest& dst) const
+    {
+      Matrix<Scalar,1,Dest::RowsAtCompileTime,RowMajor,1,Dest::MaxRowsAtCompileTime> workspace(dst.rows());
+      applyThisOnTheRight(dst, workspace);
+    }
+
+    /** \internal */
+    template<typename Dest, typename Workspace>
+    inline void applyThisOnTheRight(Dest& dst, Workspace& workspace) const
+    {
+      workspace.resize(dst.rows());
+      for(Index k = 0; k < m_length; ++k)
+      {
+        Index actual_k = m_reverse ? m_length-k-1 : k;
+        dst.rightCols(rows()-m_shift-actual_k)
+           .applyHouseholderOnTheRight(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
+      }
+    }
+
+    /** \internal */
+    template<typename Dest> inline void applyThisOnTheLeft(Dest& dst, bool inputIsIdentity = false) const
+    {
+      Matrix<Scalar,1,Dest::ColsAtCompileTime,RowMajor,1,Dest::MaxColsAtCompileTime> workspace;
+      applyThisOnTheLeft(dst, workspace, inputIsIdentity);
+    }
+
+    /** \internal */
+    template<typename Dest, typename Workspace>
+    inline void applyThisOnTheLeft(Dest& dst, Workspace& workspace, bool inputIsIdentity = false) const
+    {
+      if(inputIsIdentity && m_reverse)
+        inputIsIdentity = false;
+      // if the entries are large enough, then apply the reflectors by block
+      if(m_length>=BlockSize && dst.cols()>1)
+      {
+        // Make sure we have at least 2 useful blocks, otherwise it is point-less:
+        Index blockSize = m_length<Index(2*BlockSize) ? (m_length+1)/2 : Index(BlockSize);
+        for(Index i = 0; i < m_length; i+=blockSize)
+        {
+          Index end = m_reverse ? (std::min)(m_length,i+blockSize) : m_length-i;
+          Index k = m_reverse ? i : (std::max)(Index(0),end-blockSize);
+          Index bs = end-k;
+          Index start = k + m_shift;
+
+          typedef Block<typename internal::remove_all<VectorsType>::type,Dynamic,Dynamic> SubVectorsType;
+          SubVectorsType sub_vecs1(m_vectors.const_cast_derived(), Side==OnTheRight ? k : start,
+                                                                   Side==OnTheRight ? start : k,
+                                                                   Side==OnTheRight ? bs : m_vectors.rows()-start,
+                                                                   Side==OnTheRight ? m_vectors.cols()-start : bs);
+          typename internal::conditional<Side==OnTheRight, Transpose<SubVectorsType>, SubVectorsType&>::type sub_vecs(sub_vecs1);
+
+          Index dstStart = dst.rows()-rows()+m_shift+k;
+          Index dstRows  = rows()-m_shift-k;
+          Block<Dest,Dynamic,Dynamic> sub_dst(dst,
+                                              dstStart,
+                                              inputIsIdentity ? dstStart : 0,
+                                              dstRows,
+                                              inputIsIdentity ? dstRows : dst.cols());
+          apply_block_householder_on_the_left(sub_dst, sub_vecs, m_coeffs.segment(k, bs), !m_reverse);
+        }
+      }
+      else
+      {
+        workspace.resize(dst.cols());
+        for(Index k = 0; k < m_length; ++k)
+        {
+          Index actual_k = m_reverse ? k : m_length-k-1;
+          Index dstStart = rows()-m_shift-actual_k;
+          dst.bottomRightCorner(dstStart, inputIsIdentity ? dstStart : dst.cols())
+            .applyHouseholderOnTheLeft(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
+        }
+      }
+    }
+
+    /** \brief Computes the product of a Householder sequence with a matrix.
+      * \param[in]  other  %Matrix being multiplied.
+      * \returns    Expression object representing the product.
+      *
+      * This function computes \f$ HM \f$ where \f$ H \f$ is the Householder sequence represented by \p *this
+      * and \f$ M \f$ is the matrix \p other.
+      */
+    template<typename OtherDerived>
+    typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type operator*(const MatrixBase<OtherDerived>& other) const
+    {
+      typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type
+        res(other.template cast<typename internal::matrix_type_times_scalar_type<Scalar,OtherDerived>::ResultScalar>());
+      applyThisOnTheLeft(res, internal::is_identity<OtherDerived>::value && res.rows()==res.cols());
+      return res;
+    }
+
+    template<typename _VectorsType, typename _CoeffsType, int _Side> friend struct internal::hseq_side_dependent_impl;
+
+    /** \brief Sets the length of the Householder sequence.
+      * \param [in]  length  New value for the length.
+      *
+      * By default, the length \f$ n \f$ of the Householder sequence \f$ H = H_0 H_1 \ldots H_{n-1} \f$ is set
+      * to the number of columns of the matrix \p v passed to the constructor, or the number of rows if that
+      * is smaller. After this function is called, the length equals \p length.
+      *
+      * \sa length()
+      */
+    EIGEN_DEVICE_FUNC
+    HouseholderSequence& setLength(Index length)
+    {
+      m_length = length;
+      return *this;
+    }
+
+    /** \brief Sets the shift of the Householder sequence.
+      * \param [in]  shift  New value for the shift.
+      *
+      * By default, a %HouseholderSequence object represents \f$ H = H_0 H_1 \ldots H_{n-1} \f$ and the i-th
+      * column of the matrix \p v passed to the constructor corresponds to the i-th Householder
+      * reflection. After this function is called, the object represents \f$ H = H_{\mathrm{shift}}
+      * H_{\mathrm{shift}+1} \ldots H_{n-1} \f$ and the i-th column of \p v corresponds to the (shift+i)-th
+      * Householder reflection.
+      *
+      * \sa shift()
+      */
+    EIGEN_DEVICE_FUNC
+    HouseholderSequence& setShift(Index shift)
+    {
+      m_shift = shift;
+      return *this;
+    }
+
+    EIGEN_DEVICE_FUNC
+    Index length() const { return m_length; }  /**< \brief Returns the length of the Householder sequence. */
+
+    EIGEN_DEVICE_FUNC
+    Index shift() const { return m_shift; }    /**< \brief Returns the shift of the Householder sequence. */
+
+    /* Necessary for .adjoint() and .conjugate() */
+    template <typename VectorsType2, typename CoeffsType2, int Side2> friend class HouseholderSequence;
+
+  protected:
+
+    /** \internal
+      * \brief Sets the reverse flag.
+      * \param [in]  reverse  New value of the reverse flag.
+      *
+      * By default, the reverse flag is not set. If the reverse flag is set, then this object represents
+      * \f$ H^r = H_{n-1} \ldots H_1 H_0 \f$ instead of \f$ H = H_0 H_1 \ldots H_{n-1} \f$.
+      * \note For real valued HouseholderSequence this is equivalent to transposing \f$ H \f$.
+      *
+      * \sa reverseFlag(), transpose(), adjoint()
+      */
+    HouseholderSequence& setReverseFlag(bool reverse)
+    {
+      m_reverse = reverse;
+      return *this;
+    }
+
+    bool reverseFlag() const { return m_reverse; }     /**< \internal \brief Returns the reverse flag. */
+
+    typename VectorsType::Nested m_vectors;
+    typename CoeffsType::Nested m_coeffs;
+    bool m_reverse;
+    Index m_length;
+    Index m_shift;
+    enum { BlockSize = 48 };
+};
+
+/** \brief Computes the product of a matrix with a Householder sequence.
+  * \param[in]  other  %Matrix being multiplied.
+  * \param[in]  h      %HouseholderSequence being multiplied.
+  * \returns    Expression object representing the product.
+  *
+  * This function computes \f$ MH \f$ where \f$ M \f$ is the matrix \p other and \f$ H \f$ is the
+  * Householder sequence represented by \p h.
+  */
+template<typename OtherDerived, typename VectorsType, typename CoeffsType, int Side>
+typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::Type operator*(const MatrixBase<OtherDerived>& other, const HouseholderSequence<VectorsType,CoeffsType,Side>& h)
+{
+  typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::Type
+    res(other.template cast<typename internal::matrix_type_times_scalar_type<typename VectorsType::Scalar,OtherDerived>::ResultScalar>());
+  h.applyThisOnTheRight(res);
+  return res;
+}
+
+/** \ingroup Householder_Module \householder_module
+  * \brief Convenience function for constructing a Householder sequence.
+  * \returns A HouseholderSequence constructed from the specified arguments.
+  */
+template<typename VectorsType, typename CoeffsType>
+HouseholderSequence<VectorsType,CoeffsType> householderSequence(const VectorsType& v, const CoeffsType& h)
+{
+  return HouseholderSequence<VectorsType,CoeffsType,OnTheLeft>(v, h);
+}
+
+/** \ingroup Householder_Module \householder_module
+  * \brief Convenience function for constructing a Householder sequence.
+  * \returns A HouseholderSequence constructed from the specified arguments.
+  * \details This function differs from householderSequence() in that the template argument \p OnTheSide of
+  * the constructed HouseholderSequence is set to OnTheRight, instead of the default OnTheLeft.
+  */
+template<typename VectorsType, typename CoeffsType>
+HouseholderSequence<VectorsType,CoeffsType,OnTheRight> rightHouseholderSequence(const VectorsType& v, const CoeffsType& h)
+{
+  return HouseholderSequence<VectorsType,CoeffsType,OnTheRight>(v, h);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_HOUSEHOLDER_SEQUENCE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
new file mode 100644
index 00000000..a117fc15
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BASIC_PRECONDITIONERS_H
+#define EIGEN_BASIC_PRECONDITIONERS_H
+
+namespace Eigen {
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A preconditioner based on the digonal entries
+  *
+  * This class allows to approximately solve for A.x = b problems assuming A is a diagonal matrix.
+  * In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for:
+    \code
+    A.diagonal().asDiagonal() . x = b
+    \endcode
+  *
+  * \tparam _Scalar the type of the scalar.
+  *
+  * \implsparsesolverconcept
+  *
+  * This preconditioner is suitable for both selfadjoint and general problems.
+  * The diagonal entries are pre-inverted and stored into a dense vector.
+  *
+  * \note A variant that has yet to be implemented would attempt to preserve the norm of each column.
+  *
+  * \sa class LeastSquareDiagonalPreconditioner, class ConjugateGradient
+  */
+template <typename _Scalar>
+class DiagonalPreconditioner
+{
+    typedef _Scalar Scalar;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+  public:
+    typedef typename Vector::StorageIndex StorageIndex;
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+
+    DiagonalPreconditioner() : m_isInitialized(false) {}
+
+    template<typename MatType>
+    explicit DiagonalPreconditioner(const MatType& mat) : m_invdiag(mat.cols())
+    {
+      compute(mat);
+    }
+
+    EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_invdiag.size(); }
+    EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_invdiag.size(); }
+
+    template<typename MatType>
+    DiagonalPreconditioner& analyzePattern(const MatType& )
+    {
+      return *this;
+    }
+
+    template<typename MatType>
+    DiagonalPreconditioner& factorize(const MatType& mat)
+    {
+      m_invdiag.resize(mat.cols());
+      for(int j=0; j<mat.outerSize(); ++j)
+      {
+        typename MatType::InnerIterator it(mat,j);
+        while(it && it.index()!=j) ++it;
+        if(it && it.index()==j && it.value()!=Scalar(0))
+          m_invdiag(j) = Scalar(1)/it.value();
+        else
+          m_invdiag(j) = Scalar(1);
+      }
+      m_isInitialized = true;
+      return *this;
+    }
+
+    template<typename MatType>
+    DiagonalPreconditioner& compute(const MatType& mat)
+    {
+      return factorize(mat);
+    }
+
+    /** \internal */
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const Rhs& b, Dest& x) const
+    {
+      x = m_invdiag.array() * b.array() ;
+    }
+
+    template<typename Rhs> inline const Solve<DiagonalPreconditioner, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "DiagonalPreconditioner is not initialized.");
+      eigen_assert(m_invdiag.size()==b.rows()
+                && "DiagonalPreconditioner::solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<DiagonalPreconditioner, Rhs>(*this, b.derived());
+    }
+
+    ComputationInfo info() { return Success; }
+
+  protected:
+    Vector m_invdiag;
+    bool m_isInitialized;
+};
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief Jacobi preconditioner for LeastSquaresConjugateGradient
+  *
+  * This class allows to approximately solve for A' A x  = A' b problems assuming A' A is a diagonal matrix.
+  * In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for:
+    \code
+    (A.adjoint() * A).diagonal().asDiagonal() * x = b
+    \endcode
+  *
+  * \tparam _Scalar the type of the scalar.
+  *
+  * \implsparsesolverconcept
+  *
+  * The diagonal entries are pre-inverted and stored into a dense vector.
+  *
+  * \sa class LeastSquaresConjugateGradient, class DiagonalPreconditioner
+  */
+template <typename _Scalar>
+class LeastSquareDiagonalPreconditioner : public DiagonalPreconditioner<_Scalar>
+{
+    typedef _Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef DiagonalPreconditioner<_Scalar> Base;
+    using Base::m_invdiag;
+  public:
+
+    LeastSquareDiagonalPreconditioner() : Base() {}
+
+    template<typename MatType>
+    explicit LeastSquareDiagonalPreconditioner(const MatType& mat) : Base()
+    {
+      compute(mat);
+    }
+
+    template<typename MatType>
+    LeastSquareDiagonalPreconditioner& analyzePattern(const MatType& )
+    {
+      return *this;
+    }
+
+    template<typename MatType>
+    LeastSquareDiagonalPreconditioner& factorize(const MatType& mat)
+    {
+      // Compute the inverse squared-norm of each column of mat
+      m_invdiag.resize(mat.cols());
+      if(MatType::IsRowMajor)
+      {
+        m_invdiag.setZero();
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          for(typename MatType::InnerIterator it(mat,j); it; ++it)
+            m_invdiag(it.index()) += numext::abs2(it.value());
+        }
+        for(Index j=0; j<mat.cols(); ++j)
+          if(numext::real(m_invdiag(j))>RealScalar(0))
+            m_invdiag(j) = RealScalar(1)/numext::real(m_invdiag(j));
+      }
+      else
+      {
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          RealScalar sum = mat.col(j).squaredNorm();
+          if(sum>RealScalar(0))
+            m_invdiag(j) = RealScalar(1)/sum;
+          else
+            m_invdiag(j) = RealScalar(1);
+        }
+      }
+      Base::m_isInitialized = true;
+      return *this;
+    }
+
+    template<typename MatType>
+    LeastSquareDiagonalPreconditioner& compute(const MatType& mat)
+    {
+      return factorize(mat);
+    }
+
+    ComputationInfo info() { return Success; }
+
+  protected:
+};
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A naive preconditioner which approximates any matrix as the identity matrix
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa class DiagonalPreconditioner
+  */
+class IdentityPreconditioner
+{
+  public:
+
+    IdentityPreconditioner() {}
+
+    template<typename MatrixType>
+    explicit IdentityPreconditioner(const MatrixType& ) {}
+
+    template<typename MatrixType>
+    IdentityPreconditioner& analyzePattern(const MatrixType& ) { return *this; }
+
+    template<typename MatrixType>
+    IdentityPreconditioner& factorize(const MatrixType& ) { return *this; }
+
+    template<typename MatrixType>
+    IdentityPreconditioner& compute(const MatrixType& ) { return *this; }
+
+    template<typename Rhs>
+    inline const Rhs& solve(const Rhs& b) const { return b; }
+
+    ComputationInfo info() { return Success; }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_BASIC_PRECONDITIONERS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
new file mode 100644
index 00000000..153acef6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
@@ -0,0 +1,212 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BICGSTAB_H
+#define EIGEN_BICGSTAB_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Low-level bi conjugate gradient stabilized algorithm
+  * \param mat The matrix A
+  * \param rhs The right hand side vector b
+  * \param x On input and initial solution, on output the computed solution.
+  * \param precond A preconditioner being able to efficiently solve for an
+  *                approximation of Ax=b (regardless of b)
+  * \param iters On input the max number of iteration, on output the number of performed iterations.
+  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
+  * \return false in the case of numerical issue, for example a break down of BiCGSTAB. 
+  */
+template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+bool bicgstab(const MatrixType& mat, const Rhs& rhs, Dest& x,
+              const Preconditioner& precond, Index& iters,
+              typename Dest::RealScalar& tol_error)
+{
+  using std::sqrt;
+  using std::abs;
+  typedef typename Dest::RealScalar RealScalar;
+  typedef typename Dest::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,1> VectorType;
+  RealScalar tol = tol_error;
+  Index maxIters = iters;
+
+  Index n = mat.cols();
+  VectorType r  = rhs - mat * x;
+  VectorType r0 = r;
+  
+  RealScalar r0_sqnorm = r0.squaredNorm();
+  RealScalar rhs_sqnorm = rhs.squaredNorm();
+  if(rhs_sqnorm == 0)
+  {
+    x.setZero();
+    return true;
+  }
+  Scalar rho    = 1;
+  Scalar alpha  = 1;
+  Scalar w      = 1;
+  
+  VectorType v = VectorType::Zero(n), p = VectorType::Zero(n);
+  VectorType y(n),  z(n);
+  VectorType kt(n), ks(n);
+
+  VectorType s(n), t(n);
+
+  RealScalar tol2 = tol*tol*rhs_sqnorm;
+  RealScalar eps2 = NumTraits<Scalar>::epsilon()*NumTraits<Scalar>::epsilon();
+  Index i = 0;
+  Index restarts = 0;
+
+  while ( r.squaredNorm() > tol2 && i<maxIters )
+  {
+    Scalar rho_old = rho;
+
+    rho = r0.dot(r);
+    if (abs(rho) < eps2*r0_sqnorm)
+    {
+      // The new residual vector became too orthogonal to the arbitrarily chosen direction r0
+      // Let's restart with a new r0:
+      r  = rhs - mat * x;
+      r0 = r;
+      rho = r0_sqnorm = r.squaredNorm();
+      if(restarts++ == 0)
+        i = 0;
+    }
+    Scalar beta = (rho/rho_old) * (alpha / w);
+    p = r + beta * (p - w * v);
+    
+    y = precond.solve(p);
+    
+    v.noalias() = mat * y;
+
+    alpha = rho / r0.dot(v);
+    s = r - alpha * v;
+
+    z = precond.solve(s);
+    t.noalias() = mat * z;
+
+    RealScalar tmp = t.squaredNorm();
+    if(tmp>RealScalar(0))
+      w = t.dot(s) / tmp;
+    else
+      w = Scalar(0);
+    x += alpha * y + w * z;
+    r = s - w * t;
+    ++i;
+  }
+  tol_error = sqrt(r.squaredNorm()/rhs_sqnorm);
+  iters = i;
+  return true; 
+}
+
+}
+
+template< typename _MatrixType,
+          typename _Preconditioner = DiagonalPreconditioner<typename _MatrixType::Scalar> >
+class BiCGSTAB;
+
+namespace internal {
+
+template< typename _MatrixType, typename _Preconditioner>
+struct traits<BiCGSTAB<_MatrixType,_Preconditioner> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Preconditioner Preconditioner;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A bi conjugate gradient stabilized solver for sparse square problems
+  *
+  * This class allows to solve for A.x = b sparse linear problems using a bi conjugate gradient
+  * stabilized algorithm. The vectors x and b can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, can be a dense or a sparse matrix.
+  * \tparam _Preconditioner the type of the preconditioner. Default is DiagonalPreconditioner
+  *
+  * \implsparsesolverconcept
+  *
+  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
+  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * 
+  * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
+  * 
+  * \b Performance: when using sparse matrices, best performance is achied for a row-major sparse matrix format.
+  * Moreover, in this case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
+  * See \ref TopicMultiThreading for details.
+  * 
+  * This class can be used as the direct solver classes. Here is a typical usage example:
+  * \include BiCGSTAB_simple.cpp
+  * 
+  * By default the iterations start with x=0 as an initial guess of the solution.
+  * One can control the start using the solveWithGuess() method.
+  * 
+  * BiCGSTAB can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
+  *
+  * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+  */
+template< typename _MatrixType, typename _Preconditioner>
+class BiCGSTAB : public IterativeSolverBase<BiCGSTAB<_MatrixType,_Preconditioner> >
+{
+  typedef IterativeSolverBase<BiCGSTAB> Base;
+  using Base::matrix;
+  using Base::m_error;
+  using Base::m_iterations;
+  using Base::m_info;
+  using Base::m_isInitialized;
+public:
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef _Preconditioner Preconditioner;
+
+public:
+
+  /** Default constructor. */
+  BiCGSTAB() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    * 
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    * 
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit BiCGSTAB(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  ~BiCGSTAB() {}
+
+  /** \internal */
+  template<typename Rhs,typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const
+  {    
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+    
+    bool ret = internal::bicgstab(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error);
+
+    m_info = (!ret) ? NumericalIssue
+           : m_error <= Base::m_tolerance ? Success
+           : NoConvergence;
+  }
+
+protected:
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_BICGSTAB_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
new file mode 100644
index 00000000..5d8c6b43
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
@@ -0,0 +1,229 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONJUGATE_GRADIENT_H
+#define EIGEN_CONJUGATE_GRADIENT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Low-level conjugate gradient algorithm
+  * \param mat The matrix A
+  * \param rhs The right hand side vector b
+  * \param x On input and initial solution, on output the computed solution.
+  * \param precond A preconditioner being able to efficiently solve for an
+  *                approximation of Ax=b (regardless of b)
+  * \param iters On input the max number of iteration, on output the number of performed iterations.
+  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
+  */
+template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+EIGEN_DONT_INLINE
+void conjugate_gradient(const MatrixType& mat, const Rhs& rhs, Dest& x,
+                        const Preconditioner& precond, Index& iters,
+                        typename Dest::RealScalar& tol_error)
+{
+  using std::sqrt;
+  using std::abs;
+  typedef typename Dest::RealScalar RealScalar;
+  typedef typename Dest::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,1> VectorType;
+  
+  RealScalar tol = tol_error;
+  Index maxIters = iters;
+  
+  Index n = mat.cols();
+
+  VectorType residual = rhs - mat * x; //initial residual
+
+  RealScalar rhsNorm2 = rhs.squaredNorm();
+  if(rhsNorm2 == 0) 
+  {
+    x.setZero();
+    iters = 0;
+    tol_error = 0;
+    return;
+  }
+  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+  RealScalar threshold = numext::maxi(RealScalar(tol*tol*rhsNorm2),considerAsZero);
+  RealScalar residualNorm2 = residual.squaredNorm();
+  if (residualNorm2 < threshold)
+  {
+    iters = 0;
+    tol_error = sqrt(residualNorm2 / rhsNorm2);
+    return;
+  }
+
+  VectorType p(n);
+  p = precond.solve(residual);      // initial search direction
+
+  VectorType z(n), tmp(n);
+  RealScalar absNew = numext::real(residual.dot(p));  // the square of the absolute value of r scaled by invM
+  Index i = 0;
+  while(i < maxIters)
+  {
+    tmp.noalias() = mat * p;                    // the bottleneck of the algorithm
+
+    Scalar alpha = absNew / p.dot(tmp);         // the amount we travel on dir
+    x += alpha * p;                             // update solution
+    residual -= alpha * tmp;                    // update residual
+    
+    residualNorm2 = residual.squaredNorm();
+    if(residualNorm2 < threshold)
+      break;
+    
+    z = precond.solve(residual);                // approximately solve for "A z = residual"
+
+    RealScalar absOld = absNew;
+    absNew = numext::real(residual.dot(z));     // update the absolute value of r
+    RealScalar beta = absNew / absOld;          // calculate the Gram-Schmidt value used to create the new search direction
+    p = z + beta * p;                           // update search direction
+    i++;
+  }
+  tol_error = sqrt(residualNorm2 / rhsNorm2);
+  iters = i;
+}
+
+}
+
+template< typename _MatrixType, int _UpLo=Lower,
+          typename _Preconditioner = DiagonalPreconditioner<typename _MatrixType::Scalar> >
+class ConjugateGradient;
+
+namespace internal {
+
+template< typename _MatrixType, int _UpLo, typename _Preconditioner>
+struct traits<ConjugateGradient<_MatrixType,_UpLo,_Preconditioner> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Preconditioner Preconditioner;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A conjugate gradient solver for sparse (or dense) self-adjoint problems
+  *
+  * This class allows to solve for A.x = b linear problems using an iterative conjugate gradient algorithm.
+  * The matrix A must be selfadjoint. The matrix A and the vectors x and b can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the matrix A, can be a dense or a sparse matrix.
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower,
+  *               \c Upper, or \c Lower|Upper in which the full matrix entries will be considered.
+  *               Default is \c Lower, best performance is \c Lower|Upper.
+  * \tparam _Preconditioner the type of the preconditioner. Default is DiagonalPreconditioner
+  *
+  * \implsparsesolverconcept
+  *
+  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
+  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * 
+  * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
+  * 
+  * \b Performance: Even though the default value of \c _UpLo is \c Lower, significantly higher performance is
+  * achieved when using a complete matrix and \b Lower|Upper as the \a _UpLo template parameter. Moreover, in this
+  * case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
+  * See \ref TopicMultiThreading for details.
+  * 
+  * This class can be used as the direct solver classes. Here is a typical usage example:
+    \code
+    int n = 10000;
+    VectorXd x(n), b(n);
+    SparseMatrix<double> A(n,n);
+    // fill A and b
+    ConjugateGradient<SparseMatrix<double>, Lower|Upper> cg;
+    cg.compute(A);
+    x = cg.solve(b);
+    std::cout << "#iterations:     " << cg.iterations() << std::endl;
+    std::cout << "estimated error: " << cg.error()      << std::endl;
+    // update b, and solve again
+    x = cg.solve(b);
+    \endcode
+  * 
+  * By default the iterations start with x=0 as an initial guess of the solution.
+  * One can control the start using the solveWithGuess() method.
+  * 
+  * ConjugateGradient can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
+  *
+  * \sa class LeastSquaresConjugateGradient, class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+  */
+template< typename _MatrixType, int _UpLo, typename _Preconditioner>
+class ConjugateGradient : public IterativeSolverBase<ConjugateGradient<_MatrixType,_UpLo,_Preconditioner> >
+{
+  typedef IterativeSolverBase<ConjugateGradient> Base;
+  using Base::matrix;
+  using Base::m_error;
+  using Base::m_iterations;
+  using Base::m_info;
+  using Base::m_isInitialized;
+public:
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef _Preconditioner Preconditioner;
+
+  enum {
+    UpLo = _UpLo
+  };
+
+public:
+
+  /** Default constructor. */
+  ConjugateGradient() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    * 
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    * 
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit ConjugateGradient(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  ~ConjugateGradient() {}
+
+  /** \internal */
+  template<typename Rhs,typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const
+  {
+    typedef typename Base::MatrixWrapper MatrixWrapper;
+    typedef typename Base::ActualMatrixType ActualMatrixType;
+    enum {
+      TransposeInput  =   (!MatrixWrapper::MatrixFree)
+                      &&  (UpLo==(Lower|Upper))
+                      &&  (!MatrixType::IsRowMajor)
+                      &&  (!NumTraits<Scalar>::IsComplex)
+    };
+    typedef typename internal::conditional<TransposeInput,Transpose<const ActualMatrixType>, ActualMatrixType const&>::type RowMajorWrapper;
+    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(MatrixWrapper::MatrixFree,UpLo==(Lower|Upper)),MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY);
+    typedef typename internal::conditional<UpLo==(Lower|Upper),
+                                           RowMajorWrapper,
+                                           typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type
+                                          >::type SelfAdjointWrapper;
+
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+
+    RowMajorWrapper row_mat(matrix());
+    internal::conjugate_gradient(SelfAdjointWrapper(row_mat), b, x, Base::m_preconditioner, m_iterations, m_error);
+    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
+  }
+
+protected:
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_CONJUGATE_GRADIENT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
new file mode 100644
index 00000000..7803fd81
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
@@ -0,0 +1,394 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INCOMPLETE_CHOlESKY_H
+#define EIGEN_INCOMPLETE_CHOlESKY_H
+
+#include <vector>
+#include <list>
+
+namespace Eigen {
+/**
+  * \brief Modified Incomplete Cholesky with dual threshold
+  *
+  * References : C-J. Lin and J. J. Moré, Incomplete Cholesky Factorizations with
+  *              Limited memory, SIAM J. Sci. Comput.  21(1), pp. 24-45, 1999
+  *
+  * \tparam Scalar the scalar type of the input matrices
+  * \tparam _UpLo The triangular part that will be used for the computations. It can be Lower
+    *               or Upper. Default is Lower.
+  * \tparam _OrderingType The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<int>,
+  *                       unless EIGEN_MPL2_ONLY is defined, in which case the default is NaturalOrdering<int>.
+  *
+  * \implsparsesolverconcept
+  *
+  * It performs the following incomplete factorization: \f$ S P A P' S \approx L L' \f$
+  * where L is a lower triangular factor, S is a diagonal scaling matrix, and P is a
+  * fill-in reducing permutation as computed by the ordering method.
+  *
+  * \b Shifting \b strategy: Let \f$ B = S P A P' S \f$  be the scaled matrix on which the factorization is carried out,
+  * and \f$ \beta \f$ be the minimum value of the diagonal. If \f$ \beta > 0 \f$ then, the factorization is directly performed
+  * on the matrix B. Otherwise, the factorization is performed on the shifted matrix \f$ B + (\sigma+|\beta| I \f$ where
+  * \f$ \sigma \f$ is the initial shift value as returned and set by setInitialShift() method. The default value is \f$ \sigma = 10^{-3} \f$.
+  * If the factorization fails, then the shift in doubled until it succeed or a maximum of ten attempts. If it still fails, as returned by
+  * the info() method, then you can either increase the initial shift, or better use another preconditioning technique.
+  *
+  */
+template <typename Scalar, int _UpLo = Lower, typename _OrderingType = AMDOrdering<int> >
+class IncompleteCholesky : public SparseSolverBase<IncompleteCholesky<Scalar,_UpLo,_OrderingType> >
+{
+  protected:
+    typedef SparseSolverBase<IncompleteCholesky<Scalar,_UpLo,_OrderingType> > Base;
+    using Base::m_isInitialized;
+  public:
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef _OrderingType OrderingType;
+    typedef typename OrderingType::PermutationType PermutationType;
+    typedef typename PermutationType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> FactorType;
+    typedef Matrix<Scalar,Dynamic,1> VectorSx;
+    typedef Matrix<RealScalar,Dynamic,1> VectorRx;
+    typedef Matrix<StorageIndex,Dynamic, 1> VectorIx;
+    typedef std::vector<std::list<StorageIndex> > VectorList;
+    enum { UpLo = _UpLo };
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+  public:
+
+    /** Default constructor leaving the object in a partly non-initialized stage.
+      *
+      * You must call compute() or the pair analyzePattern()/factorize() to make it valid.
+      *
+      * \sa IncompleteCholesky(const MatrixType&)
+      */
+    IncompleteCholesky() : m_initialShift(1e-3),m_analysisIsOk(false),m_factorizationIsOk(false) {}
+
+    /** Constructor computing the incomplete factorization for the given matrix \a matrix.
+      */
+    template<typename MatrixType>
+    IncompleteCholesky(const MatrixType& matrix) : m_initialShift(1e-3),m_analysisIsOk(false),m_factorizationIsOk(false)
+    {
+      compute(matrix);
+    }
+
+    /** \returns number of rows of the factored matrix */
+    EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_L.rows(); }
+
+    /** \returns number of columns of the factored matrix */
+    EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_L.cols(); }
+
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * It triggers an assertion if \c *this has not been initialized through the respective constructor,
+      * or a call to compute() or analyzePattern().
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "IncompleteCholesky is not initialized.");
+      return m_info;
+    }
+
+    /** \brief Set the initial shift parameter \f$ \sigma \f$.
+      */
+    void setInitialShift(RealScalar shift) { m_initialShift = shift; }
+
+    /** \brief Computes the fill reducing permutation vector using the sparsity pattern of \a mat
+      */
+    template<typename MatrixType>
+    void analyzePattern(const MatrixType& mat)
+    {
+      OrderingType ord;
+      PermutationType pinv;
+      ord(mat.template selfadjointView<UpLo>(), pinv);
+      if(pinv.size()>0) m_perm = pinv.inverse();
+      else              m_perm.resize(0);
+      m_L.resize(mat.rows(), mat.cols());
+      m_analysisIsOk = true;
+      m_isInitialized = true;
+      m_info = Success;
+    }
+
+    /** \brief Performs the numerical factorization of the input matrix \a mat
+      *
+      * The method analyzePattern() or compute() must have been called beforehand
+      * with a matrix having the same pattern.
+      *
+      * \sa compute(), analyzePattern()
+      */
+    template<typename MatrixType>
+    void factorize(const MatrixType& mat);
+
+    /** Computes or re-computes the incomplete Cholesky factorization of the input matrix \a mat
+      *
+      * It is a shortcut for a sequential call to the analyzePattern() and factorize() methods.
+      *
+      * \sa analyzePattern(), factorize()
+      */
+    template<typename MatrixType>
+    void compute(const MatrixType& mat)
+    {
+      analyzePattern(mat);
+      factorize(mat);
+    }
+
+    // internal
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const Rhs& b, Dest& x) const
+    {
+      eigen_assert(m_factorizationIsOk && "factorize() should be called first");
+      if (m_perm.rows() == b.rows())  x = m_perm * b;
+      else                            x = b;
+      x = m_scale.asDiagonal() * x;
+      x = m_L.template triangularView<Lower>().solve(x);
+      x = m_L.adjoint().template triangularView<Upper>().solve(x);
+      x = m_scale.asDiagonal() * x;
+      if (m_perm.rows() == b.rows())
+        x = m_perm.inverse() * x;
+    }
+
+    /** \returns the sparse lower triangular factor L */
+    const FactorType& matrixL() const { eigen_assert("m_factorizationIsOk"); return m_L; }
+
+    /** \returns a vector representing the scaling factor S */
+    const VectorRx& scalingS() const { eigen_assert("m_factorizationIsOk"); return m_scale; }
+
+    /** \returns the fill-in reducing permutation P (can be empty for a natural ordering) */
+    const PermutationType& permutationP() const { eigen_assert("m_analysisIsOk"); return m_perm; }
+
+  protected:
+    FactorType m_L;              // The lower part stored in CSC
+    VectorRx m_scale;            // The vector for scaling the matrix
+    RealScalar m_initialShift;   // The initial shift parameter
+    bool m_analysisIsOk;
+    bool m_factorizationIsOk;
+    ComputationInfo m_info;
+    PermutationType m_perm;
+
+  private:
+    inline void updateList(Ref<const VectorIx> colPtr, Ref<VectorIx> rowIdx, Ref<VectorSx> vals, const Index& col, const Index& jk, VectorIx& firstElt, VectorList& listCol);
+};
+
+// Based on the following paper:
+//   C-J. Lin and J. J. Moré, Incomplete Cholesky Factorizations with
+//   Limited memory, SIAM J. Sci. Comput.  21(1), pp. 24-45, 1999
+//   http://ftp.mcs.anl.gov/pub/tech_reports/reports/P682.pdf
+template<typename Scalar, int _UpLo, typename OrderingType>
+template<typename _MatrixType>
+void IncompleteCholesky<Scalar,_UpLo, OrderingType>::factorize(const _MatrixType& mat)
+{
+  using std::sqrt;
+  eigen_assert(m_analysisIsOk && "analyzePattern() should be called first");
+
+  // Dropping strategy : Keep only the p largest elements per column, where p is the number of elements in the column of the original matrix. Other strategies will be added
+
+  // Apply the fill-reducing permutation computed in analyzePattern()
+  if (m_perm.rows() == mat.rows() ) // To detect the null permutation
+  {
+    // The temporary is needed to make sure that the diagonal entry is properly sorted
+    FactorType tmp(mat.rows(), mat.cols());
+    tmp = mat.template selfadjointView<_UpLo>().twistedBy(m_perm);
+    m_L.template selfadjointView<Lower>() = tmp.template selfadjointView<Lower>();
+  }
+  else
+  {
+    m_L.template selfadjointView<Lower>() = mat.template selfadjointView<_UpLo>();
+  }
+
+  Index n = m_L.cols();
+  Index nnz = m_L.nonZeros();
+  Map<VectorSx> vals(m_L.valuePtr(), nnz);         //values
+  Map<VectorIx> rowIdx(m_L.innerIndexPtr(), nnz);  //Row indices
+  Map<VectorIx> colPtr( m_L.outerIndexPtr(), n+1); // Pointer to the beginning of each row
+  VectorIx firstElt(n-1); // for each j, points to the next entry in vals that will be used in the factorization
+  VectorList listCol(n);  // listCol(j) is a linked list of columns to update column j
+  VectorSx col_vals(n);   // Store a  nonzero values in each column
+  VectorIx col_irow(n);   // Row indices of nonzero elements in each column
+  VectorIx col_pattern(n);
+  col_pattern.fill(-1);
+  StorageIndex col_nnz;
+
+
+  // Computes the scaling factors
+  m_scale.resize(n);
+  m_scale.setZero();
+  for (Index j = 0; j < n; j++)
+    for (Index k = colPtr[j]; k < colPtr[j+1]; k++)
+    {
+      m_scale(j) += numext::abs2(vals(k));
+      if(rowIdx[k]!=j)
+        m_scale(rowIdx[k]) += numext::abs2(vals(k));
+    }
+
+  m_scale = m_scale.cwiseSqrt().cwiseSqrt();
+
+  for (Index j = 0; j < n; ++j)
+    if(m_scale(j)>(std::numeric_limits<RealScalar>::min)())
+      m_scale(j) = RealScalar(1)/m_scale(j);
+    else
+      m_scale(j) = 1;
+
+  // TODO disable scaling if not needed, i.e., if it is roughly uniform? (this will make solve() faster)
+
+  // Scale and compute the shift for the matrix
+  RealScalar mindiag = NumTraits<RealScalar>::highest();
+  for (Index j = 0; j < n; j++)
+  {
+    for (Index k = colPtr[j]; k < colPtr[j+1]; k++)
+      vals[k] *= (m_scale(j)*m_scale(rowIdx[k]));
+    eigen_internal_assert(rowIdx[colPtr[j]]==j && "IncompleteCholesky: only the lower triangular part must be stored");
+    mindiag = numext::mini(numext::real(vals[colPtr[j]]), mindiag);
+  }
+
+  FactorType L_save = m_L;
+
+  RealScalar shift = 0;
+  if(mindiag <= RealScalar(0.))
+    shift = m_initialShift - mindiag;
+
+  m_info = NumericalIssue;
+
+  // Try to perform the incomplete factorization using the current shift
+  int iter = 0;
+  do
+  {
+    // Apply the shift to the diagonal elements of the matrix
+    for (Index j = 0; j < n; j++)
+      vals[colPtr[j]] += shift;
+
+    // jki version of the Cholesky factorization
+    Index j=0;
+    for (; j < n; ++j)
+    {
+      // Left-looking factorization of the j-th column
+      // First, load the j-th column into col_vals
+      Scalar diag = vals[colPtr[j]];  // It is assumed that only the lower part is stored
+      col_nnz = 0;
+      for (Index i = colPtr[j] + 1; i < colPtr[j+1]; i++)
+      {
+        StorageIndex l = rowIdx[i];
+        col_vals(col_nnz) = vals[i];
+        col_irow(col_nnz) = l;
+        col_pattern(l) = col_nnz;
+        col_nnz++;
+      }
+      {
+        typename std::list<StorageIndex>::iterator k;
+        // Browse all previous columns that will update column j
+        for(k = listCol[j].begin(); k != listCol[j].end(); k++)
+        {
+          Index jk = firstElt(*k); // First element to use in the column
+          eigen_internal_assert(rowIdx[jk]==j);
+          Scalar v_j_jk = numext::conj(vals[jk]);
+
+          jk += 1;
+          for (Index i = jk; i < colPtr[*k+1]; i++)
+          {
+            StorageIndex l = rowIdx[i];
+            if(col_pattern[l]<0)
+            {
+              col_vals(col_nnz) = vals[i] * v_j_jk;
+              col_irow[col_nnz] = l;
+              col_pattern(l) = col_nnz;
+              col_nnz++;
+            }
+            else
+              col_vals(col_pattern[l]) -= vals[i] * v_j_jk;
+          }
+          updateList(colPtr,rowIdx,vals, *k, jk, firstElt, listCol);
+        }
+      }
+
+      // Scale the current column
+      if(numext::real(diag) <= 0)
+      {
+        if(++iter>=10)
+          return;
+
+        // increase shift
+        shift = numext::maxi(m_initialShift,RealScalar(2)*shift);
+        // restore m_L, col_pattern, and listCol
+        vals = Map<const VectorSx>(L_save.valuePtr(), nnz);
+        rowIdx = Map<const VectorIx>(L_save.innerIndexPtr(), nnz);
+        colPtr = Map<const VectorIx>(L_save.outerIndexPtr(), n+1);
+        col_pattern.fill(-1);
+        for(Index i=0; i<n; ++i)
+          listCol[i].clear();
+
+        break;
+      }
+
+      RealScalar rdiag = sqrt(numext::real(diag));
+      vals[colPtr[j]] = rdiag;
+      for (Index k = 0; k<col_nnz; ++k)
+      {
+        Index i = col_irow[k];
+        //Scale
+        col_vals(k) /= rdiag;
+        //Update the remaining diagonals with col_vals
+        vals[colPtr[i]] -= numext::abs2(col_vals(k));
+      }
+      // Select the largest p elements
+      // p is the original number of elements in the column (without the diagonal)
+      Index p = colPtr[j+1] - colPtr[j] - 1 ;
+      Ref<VectorSx> cvals = col_vals.head(col_nnz);
+      Ref<VectorIx> cirow = col_irow.head(col_nnz);
+      internal::QuickSplit(cvals,cirow, p);
+      // Insert the largest p elements in the matrix
+      Index cpt = 0;
+      for (Index i = colPtr[j]+1; i < colPtr[j+1]; i++)
+      {
+        vals[i] = col_vals(cpt);
+        rowIdx[i] = col_irow(cpt);
+        // restore col_pattern:
+        col_pattern(col_irow(cpt)) = -1;
+        cpt++;
+      }
+      // Get the first smallest row index and put it after the diagonal element
+      Index jk = colPtr(j)+1;
+      updateList(colPtr,rowIdx,vals,j,jk,firstElt,listCol);
+    }
+
+    if(j==n)
+    {
+      m_factorizationIsOk = true;
+      m_info = Success;
+    }
+  } while(m_info!=Success);
+}
+
+template<typename Scalar, int _UpLo, typename OrderingType>
+inline void IncompleteCholesky<Scalar,_UpLo, OrderingType>::updateList(Ref<const VectorIx> colPtr, Ref<VectorIx> rowIdx, Ref<VectorSx> vals, const Index& col, const Index& jk, VectorIx& firstElt, VectorList& listCol)
+{
+  if (jk < colPtr(col+1) )
+  {
+    Index p = colPtr(col+1) - jk;
+    Index minpos;
+    rowIdx.segment(jk,p).minCoeff(&minpos);
+    minpos += jk;
+    if (rowIdx(minpos) != rowIdx(jk))
+    {
+      //Swap
+      std::swap(rowIdx(jk),rowIdx(minpos));
+      std::swap(vals(jk),vals(minpos));
+    }
+    firstElt(col) = internal::convert_index<StorageIndex,Index>(jk);
+    listCol[rowIdx(jk)].push_back(internal::convert_index<StorageIndex,Index>(col));
+  }
+}
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
new file mode 100644
index 00000000..cdcf709e
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
@@ -0,0 +1,453 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INCOMPLETE_LUT_H
+#define EIGEN_INCOMPLETE_LUT_H
+
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+  * Compute a quick-sort split of a vector
+  * On output, the vector row is permuted such that its elements satisfy
+  * abs(row(i)) >= abs(row(ncut)) if i<ncut
+  * abs(row(i)) <= abs(row(ncut)) if i>ncut
+  * \param row The vector of values
+  * \param ind The array of index for the elements in @p row
+  * \param ncut  The number of largest elements to keep
+  **/
+template <typename VectorV, typename VectorI>
+Index QuickSplit(VectorV &row, VectorI &ind, Index ncut)
+{
+  typedef typename VectorV::RealScalar RealScalar;
+  using std::swap;
+  using std::abs;
+  Index mid;
+  Index n = row.size(); /* length of the vector */
+  Index first, last ;
+
+  ncut--; /* to fit the zero-based indices */
+  first = 0;
+  last = n-1;
+  if (ncut < first || ncut > last ) return 0;
+
+  do {
+    mid = first;
+    RealScalar abskey = abs(row(mid));
+    for (Index j = first + 1; j <= last; j++) {
+      if ( abs(row(j)) > abskey) {
+        ++mid;
+        swap(row(mid), row(j));
+        swap(ind(mid), ind(j));
+      }
+    }
+    /* Interchange for the pivot element */
+    swap(row(mid), row(first));
+    swap(ind(mid), ind(first));
+
+    if (mid > ncut) last = mid - 1;
+    else if (mid < ncut ) first = mid + 1;
+  } while (mid != ncut );
+
+  return 0; /* mid is equal to ncut */
+}
+
+}// end namespace internal
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \class IncompleteLUT
+  * \brief Incomplete LU factorization with dual-threshold strategy
+  *
+  * \implsparsesolverconcept
+  *
+  * During the numerical factorization, two dropping rules are used :
+  *  1) any element whose magnitude is less than some tolerance is dropped.
+  *    This tolerance is obtained by multiplying the input tolerance @p droptol
+  *    by the average magnitude of all the original elements in the current row.
+  *  2) After the elimination of the row, only the @p fill largest elements in
+  *    the L part and the @p fill largest elements in the U part are kept
+  *    (in addition to the diagonal element ). Note that @p fill is computed from
+  *    the input parameter @p fillfactor which is used the ratio to control the fill_in
+  *    relatively to the initial number of nonzero elements.
+  *
+  * The two extreme cases are when @p droptol=0 (to keep all the @p fill*2 largest elements)
+  * and when @p fill=n/2 with @p droptol being different to zero.
+  *
+  * References : Yousef Saad, ILUT: A dual threshold incomplete LU factorization,
+  *              Numerical Linear Algebra with Applications, 1(4), pp 387-402, 1994.
+  *
+  * NOTE : The following implementation is derived from the ILUT implementation
+  * in the SPARSKIT package, Copyright (C) 2005, the Regents of the University of Minnesota
+  *  released under the terms of the GNU LGPL:
+  *    http://www-users.cs.umn.edu/~saad/software/SPARSKIT/README
+  * However, Yousef Saad gave us permission to relicense his ILUT code to MPL2.
+  * See the Eigen mailing list archive, thread: ILUT, date: July 8, 2012:
+  *   http://listengine.tuxfamily.org/lists.tuxfamily.org/eigen/2012/07/msg00064.html
+  * alternatively, on GMANE:
+  *   http://comments.gmane.org/gmane.comp.lib.eigen/3302
+  */
+template <typename _Scalar, typename _StorageIndex = int>
+class IncompleteLUT : public SparseSolverBase<IncompleteLUT<_Scalar, _StorageIndex> >
+{
+  protected:
+    typedef SparseSolverBase<IncompleteLUT> Base;
+    using Base::m_isInitialized;
+  public:
+    typedef _Scalar Scalar;
+    typedef _StorageIndex StorageIndex;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+    typedef SparseMatrix<Scalar,RowMajor,StorageIndex> FactorType;
+
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+
+  public:
+
+    IncompleteLUT()
+      : m_droptol(NumTraits<Scalar>::dummy_precision()), m_fillfactor(10),
+        m_analysisIsOk(false), m_factorizationIsOk(false)
+    {}
+
+    template<typename MatrixType>
+    explicit IncompleteLUT(const MatrixType& mat, const RealScalar& droptol=NumTraits<Scalar>::dummy_precision(), int fillfactor = 10)
+      : m_droptol(droptol),m_fillfactor(fillfactor),
+        m_analysisIsOk(false),m_factorizationIsOk(false)
+    {
+      eigen_assert(fillfactor != 0);
+      compute(mat);
+    }
+
+    EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_lu.rows(); }
+
+    EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_lu.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "IncompleteLUT is not initialized.");
+      return m_info;
+    }
+
+    template<typename MatrixType>
+    void analyzePattern(const MatrixType& amat);
+
+    template<typename MatrixType>
+    void factorize(const MatrixType& amat);
+
+    /**
+      * Compute an incomplete LU factorization with dual threshold on the matrix mat
+      * No pivoting is done in this version
+      *
+      **/
+    template<typename MatrixType>
+    IncompleteLUT& compute(const MatrixType& amat)
+    {
+      analyzePattern(amat);
+      factorize(amat);
+      return *this;
+    }
+
+    void setDroptol(const RealScalar& droptol);
+    void setFillfactor(int fillfactor);
+
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const Rhs& b, Dest& x) const
+    {
+      x = m_Pinv * b;
+      x = m_lu.template triangularView<UnitLower>().solve(x);
+      x = m_lu.template triangularView<Upper>().solve(x);
+      x = m_P * x;
+    }
+
+protected:
+
+    /** keeps off-diagonal entries; drops diagonal entries */
+    struct keep_diag {
+      inline bool operator() (const Index& row, const Index& col, const Scalar&) const
+      {
+        return row!=col;
+      }
+    };
+
+protected:
+
+    FactorType m_lu;
+    RealScalar m_droptol;
+    int m_fillfactor;
+    bool m_analysisIsOk;
+    bool m_factorizationIsOk;
+    ComputationInfo m_info;
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_P;     // Fill-reducing permutation
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_Pinv;  // Inverse permutation
+};
+
+/**
+ * Set control parameter droptol
+ *  \param droptol   Drop any element whose magnitude is less than this tolerance
+ **/
+template<typename Scalar, typename StorageIndex>
+void IncompleteLUT<Scalar,StorageIndex>::setDroptol(const RealScalar& droptol)
+{
+  this->m_droptol = droptol;
+}
+
+/**
+ * Set control parameter fillfactor
+ * \param fillfactor  This is used to compute the  number @p fill_in of largest elements to keep on each row.
+ **/
+template<typename Scalar, typename StorageIndex>
+void IncompleteLUT<Scalar,StorageIndex>::setFillfactor(int fillfactor)
+{
+  this->m_fillfactor = fillfactor;
+}
+
+template <typename Scalar, typename StorageIndex>
+template<typename _MatrixType>
+void IncompleteLUT<Scalar,StorageIndex>::analyzePattern(const _MatrixType& amat)
+{
+  // Compute the Fill-reducing permutation
+  // Since ILUT does not perform any numerical pivoting,
+  // it is highly preferable to keep the diagonal through symmetric permutations.
+  // To this end, let's symmetrize the pattern and perform AMD on it.
+  SparseMatrix<Scalar,ColMajor, StorageIndex> mat1 = amat;
+  SparseMatrix<Scalar,ColMajor, StorageIndex> mat2 = amat.transpose();
+  // FIXME for a matrix with nearly symmetric pattern, mat2+mat1 is the appropriate choice.
+  //       on the other hand for a really non-symmetric pattern, mat2*mat1 should be preferred...
+  SparseMatrix<Scalar,ColMajor, StorageIndex> AtA = mat2 + mat1;
+  AMDOrdering<StorageIndex> ordering;
+  ordering(AtA,m_P);
+  m_Pinv  = m_P.inverse(); // cache the inverse permutation
+  m_analysisIsOk = true;
+  m_factorizationIsOk = false;
+  m_isInitialized = true;
+}
+
+template <typename Scalar, typename StorageIndex>
+template<typename _MatrixType>
+void IncompleteLUT<Scalar,StorageIndex>::factorize(const _MatrixType& amat)
+{
+  using std::sqrt;
+  using std::swap;
+  using std::abs;
+  using internal::convert_index;
+
+  eigen_assert((amat.rows() == amat.cols()) && "The factorization should be done on a square matrix");
+  Index n = amat.cols();  // Size of the matrix
+  m_lu.resize(n,n);
+  // Declare Working vectors and variables
+  Vector u(n) ;     // real values of the row -- maximum size is n --
+  VectorI ju(n);   // column position of the values in u -- maximum size  is n
+  VectorI jr(n);   // Indicate the position of the nonzero elements in the vector u -- A zero location is indicated by -1
+
+  // Apply the fill-reducing permutation
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  SparseMatrix<Scalar,RowMajor, StorageIndex> mat;
+  mat = amat.twistedBy(m_Pinv);
+
+  // Initialization
+  jr.fill(-1);
+  ju.fill(0);
+  u.fill(0);
+
+  // number of largest elements to keep in each row:
+  Index fill_in = (amat.nonZeros()*m_fillfactor)/n + 1;
+  if (fill_in > n) fill_in = n;
+
+  // number of largest nonzero elements to keep in the L and the U part of the current row:
+  Index nnzL = fill_in/2;
+  Index nnzU = nnzL;
+  m_lu.reserve(n * (nnzL + nnzU + 1));
+
+  // global loop over the rows of the sparse matrix
+  for (Index ii = 0; ii < n; ii++)
+  {
+    // 1 - copy the lower and the upper part of the row i of mat in the working vector u
+
+    Index sizeu = 1; // number of nonzero elements in the upper part of the current row
+    Index sizel = 0; // number of nonzero elements in the lower part of the current row
+    ju(ii)    = convert_index<StorageIndex>(ii);
+    u(ii)     = 0;
+    jr(ii)    = convert_index<StorageIndex>(ii);
+    RealScalar rownorm = 0;
+
+    typename FactorType::InnerIterator j_it(mat, ii); // Iterate through the current row ii
+    for (; j_it; ++j_it)
+    {
+      Index k = j_it.index();
+      if (k < ii)
+      {
+        // copy the lower part
+        ju(sizel) = convert_index<StorageIndex>(k);
+        u(sizel) = j_it.value();
+        jr(k) = convert_index<StorageIndex>(sizel);
+        ++sizel;
+      }
+      else if (k == ii)
+      {
+        u(ii) = j_it.value();
+      }
+      else
+      {
+        // copy the upper part
+        Index jpos = ii + sizeu;
+        ju(jpos) = convert_index<StorageIndex>(k);
+        u(jpos) = j_it.value();
+        jr(k) = convert_index<StorageIndex>(jpos);
+        ++sizeu;
+      }
+      rownorm += numext::abs2(j_it.value());
+    }
+
+    // 2 - detect possible zero row
+    if(rownorm==0)
+    {
+      m_info = NumericalIssue;
+      return;
+    }
+    // Take the 2-norm of the current row as a relative tolerance
+    rownorm = sqrt(rownorm);
+
+    // 3 - eliminate the previous nonzero rows
+    Index jj = 0;
+    Index len = 0;
+    while (jj < sizel)
+    {
+      // In order to eliminate in the correct order,
+      // we must select first the smallest column index among  ju(jj:sizel)
+      Index k;
+      Index minrow = ju.segment(jj,sizel-jj).minCoeff(&k); // k is relative to the segment
+      k += jj;
+      if (minrow != ju(jj))
+      {
+        // swap the two locations
+        Index j = ju(jj);
+        swap(ju(jj), ju(k));
+        jr(minrow) = convert_index<StorageIndex>(jj);
+        jr(j) = convert_index<StorageIndex>(k);
+        swap(u(jj), u(k));
+      }
+      // Reset this location
+      jr(minrow) = -1;
+
+      // Start elimination
+      typename FactorType::InnerIterator ki_it(m_lu, minrow);
+      while (ki_it && ki_it.index() < minrow) ++ki_it;
+      eigen_internal_assert(ki_it && ki_it.col()==minrow);
+      Scalar fact = u(jj) / ki_it.value();
+
+      // drop too small elements
+      if(abs(fact) <= m_droptol)
+      {
+        jj++;
+        continue;
+      }
+
+      // linear combination of the current row ii and the row minrow
+      ++ki_it;
+      for (; ki_it; ++ki_it)
+      {
+        Scalar prod = fact * ki_it.value();
+        Index j     = ki_it.index();
+        Index jpos  = jr(j);
+        if (jpos == -1) // fill-in element
+        {
+          Index newpos;
+          if (j >= ii) // dealing with the upper part
+          {
+            newpos = ii + sizeu;
+            sizeu++;
+            eigen_internal_assert(sizeu<=n);
+          }
+          else // dealing with the lower part
+          {
+            newpos = sizel;
+            sizel++;
+            eigen_internal_assert(sizel<=ii);
+          }
+          ju(newpos) = convert_index<StorageIndex>(j);
+          u(newpos) = -prod;
+          jr(j) = convert_index<StorageIndex>(newpos);
+        }
+        else
+          u(jpos) -= prod;
+      }
+      // store the pivot element
+      u(len)  = fact;
+      ju(len) = convert_index<StorageIndex>(minrow);
+      ++len;
+
+      jj++;
+    } // end of the elimination on the row ii
+
+    // reset the upper part of the pointer jr to zero
+    for(Index k = 0; k <sizeu; k++) jr(ju(ii+k)) = -1;
+
+    // 4 - partially sort and insert the elements in the m_lu matrix
+
+    // sort the L-part of the row
+    sizel = len;
+    len = (std::min)(sizel, nnzL);
+    typename Vector::SegmentReturnType ul(u.segment(0, sizel));
+    typename VectorI::SegmentReturnType jul(ju.segment(0, sizel));
+    internal::QuickSplit(ul, jul, len);
+
+    // store the largest m_fill elements of the L part
+    m_lu.startVec(ii);
+    for(Index k = 0; k < len; k++)
+      m_lu.insertBackByOuterInnerUnordered(ii,ju(k)) = u(k);
+
+    // store the diagonal element
+    // apply a shifting rule to avoid zero pivots (we are doing an incomplete factorization)
+    if (u(ii) == Scalar(0))
+      u(ii) = sqrt(m_droptol) * rownorm;
+    m_lu.insertBackByOuterInnerUnordered(ii, ii) = u(ii);
+
+    // sort the U-part of the row
+    // apply the dropping rule first
+    len = 0;
+    for(Index k = 1; k < sizeu; k++)
+    {
+      if(abs(u(ii+k)) > m_droptol * rownorm )
+      {
+        ++len;
+        u(ii + len)  = u(ii + k);
+        ju(ii + len) = ju(ii + k);
+      }
+    }
+    sizeu = len + 1; // +1 to take into account the diagonal element
+    len = (std::min)(sizeu, nnzU);
+    typename Vector::SegmentReturnType uu(u.segment(ii+1, sizeu-1));
+    typename VectorI::SegmentReturnType juu(ju.segment(ii+1, sizeu-1));
+    internal::QuickSplit(uu, juu, len);
+
+    // store the largest elements of the U part
+    for(Index k = ii + 1; k < ii + len; k++)
+      m_lu.insertBackByOuterInnerUnordered(ii,ju(k)) = u(k);
+  }
+  m_lu.finalize();
+  m_lu.makeCompressed();
+
+  m_factorizationIsOk = true;
+  m_info = Success;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_INCOMPLETE_LUT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
new file mode 100644
index 00000000..28a0c510
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
@@ -0,0 +1,444 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ITERATIVE_SOLVER_BASE_H
+#define EIGEN_ITERATIVE_SOLVER_BASE_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatrixType>
+struct is_ref_compatible_impl
+{
+private:
+  template <typename T0>
+  struct any_conversion
+  {
+    template <typename T> any_conversion(const volatile T&);
+    template <typename T> any_conversion(T&);
+  };
+  struct yes {int a[1];};
+  struct no  {int a[2];};
+
+  template<typename T>
+  static yes test(const Ref<const T>&, int);
+  template<typename T>
+  static no  test(any_conversion<T>, ...);
+
+public:
+  static MatrixType ms_from;
+  enum { value = sizeof(test<MatrixType>(ms_from, 0))==sizeof(yes) };
+};
+
+template<typename MatrixType>
+struct is_ref_compatible
+{
+  enum { value = is_ref_compatible_impl<typename remove_all<MatrixType>::type>::value };
+};
+
+template<typename MatrixType, bool MatrixFree = !internal::is_ref_compatible<MatrixType>::value>
+class generic_matrix_wrapper;
+
+// We have an explicit matrix at hand, compatible with Ref<>
+template<typename MatrixType>
+class generic_matrix_wrapper<MatrixType,false>
+{
+public:
+  typedef Ref<const MatrixType> ActualMatrixType;
+  template<int UpLo> struct ConstSelfAdjointViewReturnType {
+    typedef typename ActualMatrixType::template ConstSelfAdjointViewReturnType<UpLo>::Type Type;
+  };
+
+  enum {
+    MatrixFree = false
+  };
+
+  generic_matrix_wrapper()
+    : m_dummy(0,0), m_matrix(m_dummy)
+  {}
+
+  template<typename InputType>
+  generic_matrix_wrapper(const InputType &mat)
+    : m_matrix(mat)
+  {}
+
+  const ActualMatrixType& matrix() const
+  {
+    return m_matrix;
+  }
+
+  template<typename MatrixDerived>
+  void grab(const EigenBase<MatrixDerived> &mat)
+  {
+    m_matrix.~Ref<const MatrixType>();
+    ::new (&m_matrix) Ref<const MatrixType>(mat.derived());
+  }
+
+  void grab(const Ref<const MatrixType> &mat)
+  {
+    if(&(mat.derived()) != &m_matrix)
+    {
+      m_matrix.~Ref<const MatrixType>();
+      ::new (&m_matrix) Ref<const MatrixType>(mat);
+    }
+  }
+
+protected:
+  MatrixType m_dummy; // used to default initialize the Ref<> object
+  ActualMatrixType m_matrix;
+};
+
+// MatrixType is not compatible with Ref<> -> matrix-free wrapper
+template<typename MatrixType>
+class generic_matrix_wrapper<MatrixType,true>
+{
+public:
+  typedef MatrixType ActualMatrixType;
+  template<int UpLo> struct ConstSelfAdjointViewReturnType
+  {
+    typedef ActualMatrixType Type;
+  };
+
+  enum {
+    MatrixFree = true
+  };
+
+  generic_matrix_wrapper()
+    : mp_matrix(0)
+  {}
+
+  generic_matrix_wrapper(const MatrixType &mat)
+    : mp_matrix(&mat)
+  {}
+
+  const ActualMatrixType& matrix() const
+  {
+    return *mp_matrix;
+  }
+
+  void grab(const MatrixType &mat)
+  {
+    mp_matrix = &mat;
+  }
+
+protected:
+  const ActualMatrixType *mp_matrix;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief Base class for linear iterative solvers
+  *
+  * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+  */
+template< typename Derived>
+class IterativeSolverBase : public SparseSolverBase<Derived>
+{
+protected:
+  typedef SparseSolverBase<Derived> Base;
+  using Base::m_isInitialized;
+
+public:
+  typedef typename internal::traits<Derived>::MatrixType MatrixType;
+  typedef typename internal::traits<Derived>::Preconditioner Preconditioner;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  enum {
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+  };
+
+public:
+
+  using Base::derived;
+
+  /** Default constructor. */
+  IterativeSolverBase()
+  {
+    init();
+  }
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    *
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    *
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit IterativeSolverBase(const EigenBase<MatrixDerived>& A)
+    : m_matrixWrapper(A.derived())
+  {
+    init();
+    compute(matrix());
+  }
+
+  ~IterativeSolverBase() {}
+
+  /** Initializes the iterative solver for the sparsity pattern of the matrix \a A for further solving \c Ax=b problems.
+    *
+    * Currently, this function mostly calls analyzePattern on the preconditioner. In the future
+    * we might, for instance, implement column reordering for faster matrix vector products.
+    */
+  template<typename MatrixDerived>
+  Derived& analyzePattern(const EigenBase<MatrixDerived>& A)
+  {
+    grab(A.derived());
+    m_preconditioner.analyzePattern(matrix());
+    m_isInitialized = true;
+    m_analysisIsOk = true;
+    m_info = m_preconditioner.info();
+    return derived();
+  }
+
+  /** Initializes the iterative solver with the numerical values of the matrix \a A for further solving \c Ax=b problems.
+    *
+    * Currently, this function mostly calls factorize on the preconditioner.
+    *
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  Derived& factorize(const EigenBase<MatrixDerived>& A)
+  {
+    eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+    grab(A.derived());
+    m_preconditioner.factorize(matrix());
+    m_factorizationIsOk = true;
+    m_info = m_preconditioner.info();
+    return derived();
+  }
+
+  /** Initializes the iterative solver with the matrix \a A for further solving \c Ax=b problems.
+    *
+    * Currently, this function mostly initializes/computes the preconditioner. In the future
+    * we might, for instance, implement column reordering for faster matrix vector products.
+    *
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  Derived& compute(const EigenBase<MatrixDerived>& A)
+  {
+    grab(A.derived());
+    m_preconditioner.compute(matrix());
+    m_isInitialized = true;
+    m_analysisIsOk = true;
+    m_factorizationIsOk = true;
+    m_info = m_preconditioner.info();
+    return derived();
+  }
+
+  /** \internal */
+  EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return matrix().rows(); }
+
+  /** \internal */
+  EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return matrix().cols(); }
+
+  /** \returns the tolerance threshold used by the stopping criteria.
+    * \sa setTolerance()
+    */
+  RealScalar tolerance() const { return m_tolerance; }
+
+  /** Sets the tolerance threshold used by the stopping criteria.
+    *
+    * This value is used as an upper bound to the relative residual error: |Ax-b|/|b|.
+    * The default value is the machine precision given by NumTraits<Scalar>::epsilon()
+    */
+  Derived& setTolerance(const RealScalar& tolerance)
+  {
+    m_tolerance = tolerance;
+    return derived();
+  }
+
+  /** \returns a read-write reference to the preconditioner for custom configuration. */
+  Preconditioner& preconditioner() { return m_preconditioner; }
+
+  /** \returns a read-only reference to the preconditioner. */
+  const Preconditioner& preconditioner() const { return m_preconditioner; }
+
+  /** \returns the max number of iterations.
+    * It is either the value set by setMaxIterations or, by default,
+    * twice the number of columns of the matrix.
+    */
+  Index maxIterations() const
+  {
+    return (m_maxIterations<0) ? 2*matrix().cols() : m_maxIterations;
+  }
+
+  /** Sets the max number of iterations.
+    * Default is twice the number of columns of the matrix.
+    */
+  Derived& setMaxIterations(Index maxIters)
+  {
+    m_maxIterations = maxIters;
+    return derived();
+  }
+
+  /** \returns the number of iterations performed during the last solve */
+  Index iterations() const
+  {
+    eigen_assert(m_isInitialized && "ConjugateGradient is not initialized.");
+    return m_iterations;
+  }
+
+  /** \returns the tolerance error reached during the last solve.
+    * It is a close approximation of the true relative residual error |Ax-b|/|b|.
+    */
+  RealScalar error() const
+  {
+    eigen_assert(m_isInitialized && "ConjugateGradient is not initialized.");
+    return m_error;
+  }
+
+  /** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A
+    * and \a x0 as an initial solution.
+    *
+    * \sa solve(), compute()
+    */
+  template<typename Rhs,typename Guess>
+  inline const SolveWithGuess<Derived, Rhs, Guess>
+  solveWithGuess(const MatrixBase<Rhs>& b, const Guess& x0) const
+  {
+    eigen_assert(m_isInitialized && "Solver is not initialized.");
+    eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
+    return SolveWithGuess<Derived, Rhs, Guess>(derived(), b.derived(), x0);
+  }
+
+  /** \returns Success if the iterations converged, and NoConvergence otherwise. */
+  ComputationInfo info() const
+  {
+    eigen_assert(m_isInitialized && "IterativeSolverBase is not initialized.");
+    return m_info;
+  }
+
+  /** \internal */
+  template<typename Rhs, typename DestDerived>
+  void _solve_with_guess_impl(const Rhs& b, SparseMatrixBase<DestDerived> &aDest) const
+  {
+    eigen_assert(rows()==b.rows());
+
+    Index rhsCols = b.cols();
+    Index size = b.rows();
+    DestDerived& dest(aDest.derived());
+    typedef typename DestDerived::Scalar DestScalar;
+    Eigen::Matrix<DestScalar,Dynamic,1> tb(size);
+    Eigen::Matrix<DestScalar,Dynamic,1> tx(cols());
+    // We do not directly fill dest because sparse expressions have to be free of aliasing issue.
+    // For non square least-square problems, b and dest might not have the same size whereas they might alias each-other.
+    typename DestDerived::PlainObject tmp(cols(),rhsCols);
+    ComputationInfo global_info = Success;
+    for(Index k=0; k<rhsCols; ++k)
+    {
+      tb = b.col(k);
+      tx = dest.col(k);
+      derived()._solve_vector_with_guess_impl(tb,tx);
+      tmp.col(k) = tx.sparseView(0);
+
+      // The call to _solve_vector_with_guess_impl updates m_info, so if it failed for a previous column
+      // we need to restore it to the worst value.
+      if(m_info==NumericalIssue)
+        global_info = NumericalIssue;
+      else if(m_info==NoConvergence)
+        global_info = NoConvergence;
+    }
+    m_info = global_info;
+    dest.swap(tmp);
+  }
+
+  template<typename Rhs, typename DestDerived>
+  typename internal::enable_if<Rhs::ColsAtCompileTime!=1 && DestDerived::ColsAtCompileTime!=1>::type
+  _solve_with_guess_impl(const Rhs& b, MatrixBase<DestDerived> &aDest) const
+  {
+    eigen_assert(rows()==b.rows());
+
+    Index rhsCols = b.cols();
+    DestDerived& dest(aDest.derived());
+    ComputationInfo global_info = Success;
+    for(Index k=0; k<rhsCols; ++k)
+    {
+      typename DestDerived::ColXpr xk(dest,k);
+      typename Rhs::ConstColXpr bk(b,k);
+      derived()._solve_vector_with_guess_impl(bk,xk);
+
+      // The call to _solve_vector_with_guess updates m_info, so if it failed for a previous column
+      // we need to restore it to the worst value.
+      if(m_info==NumericalIssue)
+        global_info = NumericalIssue;
+      else if(m_info==NoConvergence)
+        global_info = NoConvergence;
+    }
+    m_info = global_info;
+  }
+
+  template<typename Rhs, typename DestDerived>
+  typename internal::enable_if<Rhs::ColsAtCompileTime==1 || DestDerived::ColsAtCompileTime==1>::type
+  _solve_with_guess_impl(const Rhs& b, MatrixBase<DestDerived> &dest) const
+  {
+    derived()._solve_vector_with_guess_impl(b,dest.derived());
+  }
+
+  /** \internal default initial guess = 0 */
+  template<typename Rhs,typename Dest>
+  void _solve_impl(const Rhs& b, Dest& x) const
+  {
+    x.setZero();
+    derived()._solve_with_guess_impl(b,x);
+  }
+
+protected:
+  void init()
+  {
+    m_isInitialized = false;
+    m_analysisIsOk = false;
+    m_factorizationIsOk = false;
+    m_maxIterations = -1;
+    m_tolerance = NumTraits<Scalar>::epsilon();
+  }
+
+  typedef internal::generic_matrix_wrapper<MatrixType> MatrixWrapper;
+  typedef typename MatrixWrapper::ActualMatrixType ActualMatrixType;
+
+  const ActualMatrixType& matrix() const
+  {
+    return m_matrixWrapper.matrix();
+  }
+
+  template<typename InputType>
+  void grab(const InputType &A)
+  {
+    m_matrixWrapper.grab(A);
+  }
+
+  MatrixWrapper m_matrixWrapper;
+  Preconditioner m_preconditioner;
+
+  Index m_maxIterations;
+  RealScalar m_tolerance;
+
+  mutable RealScalar m_error;
+  mutable Index m_iterations;
+  mutable ComputationInfo m_info;
+  mutable bool m_analysisIsOk, m_factorizationIsOk;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_ITERATIVE_SOLVER_BASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
new file mode 100644
index 00000000..203fd0ec
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
@@ -0,0 +1,198 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
+#define EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Low-level conjugate gradient algorithm for least-square problems
+  * \param mat The matrix A
+  * \param rhs The right hand side vector b
+  * \param x On input and initial solution, on output the computed solution.
+  * \param precond A preconditioner being able to efficiently solve for an
+  *                approximation of A'Ax=b (regardless of b)
+  * \param iters On input the max number of iteration, on output the number of performed iterations.
+  * \param tol_error On input the tolerance error, on output an estimation of the relative error.
+  */
+template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+EIGEN_DONT_INLINE
+void least_square_conjugate_gradient(const MatrixType& mat, const Rhs& rhs, Dest& x,
+                                     const Preconditioner& precond, Index& iters,
+                                     typename Dest::RealScalar& tol_error)
+{
+  using std::sqrt;
+  using std::abs;
+  typedef typename Dest::RealScalar RealScalar;
+  typedef typename Dest::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,1> VectorType;
+  
+  RealScalar tol = tol_error;
+  Index maxIters = iters;
+  
+  Index m = mat.rows(), n = mat.cols();
+
+  VectorType residual        = rhs - mat * x;
+  VectorType normal_residual = mat.adjoint() * residual;
+
+  RealScalar rhsNorm2 = (mat.adjoint()*rhs).squaredNorm();
+  if(rhsNorm2 == 0) 
+  {
+    x.setZero();
+    iters = 0;
+    tol_error = 0;
+    return;
+  }
+  RealScalar threshold = tol*tol*rhsNorm2;
+  RealScalar residualNorm2 = normal_residual.squaredNorm();
+  if (residualNorm2 < threshold)
+  {
+    iters = 0;
+    tol_error = sqrt(residualNorm2 / rhsNorm2);
+    return;
+  }
+  
+  VectorType p(n);
+  p = precond.solve(normal_residual);                         // initial search direction
+
+  VectorType z(n), tmp(m);
+  RealScalar absNew = numext::real(normal_residual.dot(p));  // the square of the absolute value of r scaled by invM
+  Index i = 0;
+  while(i < maxIters)
+  {
+    tmp.noalias() = mat * p;
+
+    Scalar alpha = absNew / tmp.squaredNorm();      // the amount we travel on dir
+    x += alpha * p;                                 // update solution
+    residual -= alpha * tmp;                        // update residual
+    normal_residual = mat.adjoint() * residual;     // update residual of the normal equation
+    
+    residualNorm2 = normal_residual.squaredNorm();
+    if(residualNorm2 < threshold)
+      break;
+    
+    z = precond.solve(normal_residual);             // approximately solve for "A'A z = normal_residual"
+
+    RealScalar absOld = absNew;
+    absNew = numext::real(normal_residual.dot(z));  // update the absolute value of r
+    RealScalar beta = absNew / absOld;              // calculate the Gram-Schmidt value used to create the new search direction
+    p = z + beta * p;                               // update search direction
+    i++;
+  }
+  tol_error = sqrt(residualNorm2 / rhsNorm2);
+  iters = i;
+}
+
+}
+
+template< typename _MatrixType,
+          typename _Preconditioner = LeastSquareDiagonalPreconditioner<typename _MatrixType::Scalar> >
+class LeastSquaresConjugateGradient;
+
+namespace internal {
+
+template< typename _MatrixType, typename _Preconditioner>
+struct traits<LeastSquaresConjugateGradient<_MatrixType,_Preconditioner> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Preconditioner Preconditioner;
+};
+
+}
+
+/** \ingroup IterativeLinearSolvers_Module
+  * \brief A conjugate gradient solver for sparse (or dense) least-square problems
+  *
+  * This class allows to solve for A x = b linear problems using an iterative conjugate gradient algorithm.
+  * The matrix A can be non symmetric and rectangular, but the matrix A' A should be positive-definite to guaranty stability.
+  * Otherwise, the SparseLU or SparseQR classes might be preferable.
+  * The matrix A and the vectors x and b can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the matrix A, can be a dense or a sparse matrix.
+  * \tparam _Preconditioner the type of the preconditioner. Default is LeastSquareDiagonalPreconditioner
+  *
+  * \implsparsesolverconcept
+  * 
+  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
+  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * 
+  * This class can be used as the direct solver classes. Here is a typical usage example:
+    \code
+    int m=1000000, n = 10000;
+    VectorXd x(n), b(m);
+    SparseMatrix<double> A(m,n);
+    // fill A and b
+    LeastSquaresConjugateGradient<SparseMatrix<double> > lscg;
+    lscg.compute(A);
+    x = lscg.solve(b);
+    std::cout << "#iterations:     " << lscg.iterations() << std::endl;
+    std::cout << "estimated error: " << lscg.error()      << std::endl;
+    // update b, and solve again
+    x = lscg.solve(b);
+    \endcode
+  * 
+  * By default the iterations start with x=0 as an initial guess of the solution.
+  * One can control the start using the solveWithGuess() method.
+  * 
+  * \sa class ConjugateGradient, SparseLU, SparseQR
+  */
+template< typename _MatrixType, typename _Preconditioner>
+class LeastSquaresConjugateGradient : public IterativeSolverBase<LeastSquaresConjugateGradient<_MatrixType,_Preconditioner> >
+{
+  typedef IterativeSolverBase<LeastSquaresConjugateGradient> Base;
+  using Base::matrix;
+  using Base::m_error;
+  using Base::m_iterations;
+  using Base::m_info;
+  using Base::m_isInitialized;
+public:
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef _Preconditioner Preconditioner;
+
+public:
+
+  /** Default constructor. */
+  LeastSquaresConjugateGradient() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+    * 
+    * This constructor is a shortcut for the default constructor followed
+    * by a call to compute().
+    * 
+    * \warning this class stores a reference to the matrix A as well as some
+    * precomputed values that depend on it. Therefore, if \a A is changed
+    * this class becomes invalid. Call compute() to update it with the new
+    * matrix A, or modify a copy of A.
+    */
+  template<typename MatrixDerived>
+  explicit LeastSquaresConjugateGradient(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  ~LeastSquaresConjugateGradient() {}
+
+  /** \internal */
+  template<typename Rhs,typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const
+  {
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+
+    internal::least_square_conjugate_gradient(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error);
+    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
+  }
+
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
new file mode 100644
index 00000000..7b896575
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
@@ -0,0 +1,117 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SOLVEWITHGUESS_H
+#define EIGEN_SOLVEWITHGUESS_H
+
+namespace Eigen {
+
+template<typename Decomposition, typename RhsType, typename GuessType> class SolveWithGuess;
+
+/** \class SolveWithGuess
+  * \ingroup IterativeLinearSolvers_Module
+  *
+  * \brief Pseudo expression representing a solving operation
+  *
+  * \tparam Decomposition the type of the matrix or decomposion object
+  * \tparam Rhstype the type of the right-hand side
+  *
+  * This class represents an expression of A.solve(B)
+  * and most of the time this is the only way it is used.
+  *
+  */
+namespace internal {
+
+
+template<typename Decomposition, typename RhsType, typename GuessType>
+struct traits<SolveWithGuess<Decomposition, RhsType, GuessType> >
+  : traits<Solve<Decomposition,RhsType> >
+{};
+
+}
+
+
+template<typename Decomposition, typename RhsType, typename GuessType>
+class SolveWithGuess : public internal::generic_xpr_base<SolveWithGuess<Decomposition,RhsType,GuessType>, MatrixXpr, typename internal::traits<RhsType>::StorageKind>::type
+{
+public:
+  typedef typename internal::traits<SolveWithGuess>::Scalar Scalar;
+  typedef typename internal::traits<SolveWithGuess>::PlainObject PlainObject;
+  typedef typename internal::generic_xpr_base<SolveWithGuess<Decomposition,RhsType,GuessType>, MatrixXpr, typename internal::traits<RhsType>::StorageKind>::type Base;
+  typedef typename internal::ref_selector<SolveWithGuess>::type Nested;
+
+  SolveWithGuess(const Decomposition &dec, const RhsType &rhs, const GuessType &guess)
+    : m_dec(dec), m_rhs(rhs), m_guess(guess)
+  {}
+
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  Index rows() const EIGEN_NOEXCEPT { return m_dec.cols(); }
+  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+  Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); }
+
+  EIGEN_DEVICE_FUNC const Decomposition& dec()   const { return m_dec; }
+  EIGEN_DEVICE_FUNC const RhsType&       rhs()   const { return m_rhs; }
+  EIGEN_DEVICE_FUNC const GuessType&     guess() const { return m_guess; }
+
+protected:
+  const Decomposition &m_dec;
+  const RhsType       &m_rhs;
+  const GuessType     &m_guess;
+
+private:
+  Scalar coeff(Index row, Index col) const;
+  Scalar coeff(Index i) const;
+};
+
+namespace internal {
+
+// Evaluator of SolveWithGuess -> eval into a temporary
+template<typename Decomposition, typename RhsType, typename GuessType>
+struct evaluator<SolveWithGuess<Decomposition,RhsType, GuessType> >
+  : public evaluator<typename SolveWithGuess<Decomposition,RhsType,GuessType>::PlainObject>
+{
+  typedef SolveWithGuess<Decomposition,RhsType,GuessType> SolveType;
+  typedef typename SolveType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  evaluator(const SolveType& solve)
+    : m_result(solve.rows(), solve.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    m_result = solve.guess();
+    solve.dec()._solve_with_guess_impl(solve.rhs(), m_result);
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+// Specialization for "dst = dec.solveWithGuess(rhs)"
+// NOTE we need to specialize it for Dense2Dense to avoid ambiguous specialization error and a Sparse2Sparse specialization must exist somewhere
+template<typename DstXprType, typename DecType, typename RhsType, typename GuessType, typename Scalar>
+struct Assignment<DstXprType, SolveWithGuess<DecType,RhsType,GuessType>, internal::assign_op<Scalar,Scalar>, Dense2Dense>
+{
+  typedef SolveWithGuess<DecType,RhsType,GuessType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    dst = src.guess();
+    src.dec()._solve_with_guess_impl(src.rhs(), dst/*, src.guess()*/);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SOLVEWITHGUESS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/Jacobi/Jacobi.h b/C++/yolo_bytetrack_old/include/Eigen/src/Jacobi/Jacobi.h
new file mode 100644
index 00000000..76668a57
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/Jacobi/Jacobi.h
@@ -0,0 +1,483 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_JACOBI_H
+#define EIGEN_JACOBI_H
+
+namespace Eigen {
+
+/** \ingroup Jacobi_Module
+  * \jacobi_module
+  * \class JacobiRotation
+  * \brief Rotation given by a cosine-sine pair.
+  *
+  * This class represents a Jacobi or Givens rotation.
+  * This is a 2D rotation in the plane \c J of angle \f$ \theta \f$ defined by
+  * its cosine \c c and sine \c s as follow:
+  * \f$ J = \left ( \begin{array}{cc} c & \overline s \\ -s  & \overline c \end{array} \right ) \f$
+  *
+  * You can apply the respective counter-clockwise rotation to a column vector \c v by
+  * applying its adjoint on the left: \f$ v = J^* v \f$ that translates to the following Eigen code:
+  * \code
+  * v.applyOnTheLeft(J.adjoint());
+  * \endcode
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar> class JacobiRotation
+{
+  public:
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    /** Default constructor without any initialization. */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation() {}
+
+    /** Construct a planar rotation from a cosine-sine pair (\a c, \c s). */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation(const Scalar& c, const Scalar& s) : m_c(c), m_s(s) {}
+
+    EIGEN_DEVICE_FUNC Scalar& c() { return m_c; }
+    EIGEN_DEVICE_FUNC Scalar c() const { return m_c; }
+    EIGEN_DEVICE_FUNC Scalar& s() { return m_s; }
+    EIGEN_DEVICE_FUNC Scalar s() const { return m_s; }
+
+    /** Concatenates two planar rotation */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation operator*(const JacobiRotation& other)
+    {
+      using numext::conj;
+      return JacobiRotation(m_c * other.m_c - conj(m_s) * other.m_s,
+                            conj(m_c * conj(other.m_s) + conj(m_s) * conj(other.m_c)));
+    }
+
+    /** Returns the transposed transformation */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation transpose() const { using numext::conj; return JacobiRotation(m_c, -conj(m_s)); }
+
+    /** Returns the adjoint transformation */
+    EIGEN_DEVICE_FUNC
+    JacobiRotation adjoint() const { using numext::conj; return JacobiRotation(conj(m_c), -m_s); }
+
+    template<typename Derived>
+    EIGEN_DEVICE_FUNC
+    bool makeJacobi(const MatrixBase<Derived>&, Index p, Index q);
+    EIGEN_DEVICE_FUNC
+    bool makeJacobi(const RealScalar& x, const Scalar& y, const RealScalar& z);
+
+    EIGEN_DEVICE_FUNC
+    void makeGivens(const Scalar& p, const Scalar& q, Scalar* r=0);
+
+  protected:
+    EIGEN_DEVICE_FUNC
+    void makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::true_type);
+    EIGEN_DEVICE_FUNC
+    void makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type);
+
+    Scalar m_c, m_s;
+};
+
+/** Makes \c *this as a Jacobi rotation \a J such that applying \a J on both the right and left sides of the selfadjoint 2x2 matrix
+  * \f$ B = \left ( \begin{array}{cc} x & y \\ \overline y & z \end{array} \right )\f$ yields a diagonal matrix \f$ A = J^* B J \f$
+  *
+  * \sa MatrixBase::makeJacobi(const MatrixBase<Derived>&, Index, Index), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+bool JacobiRotation<Scalar>::makeJacobi(const RealScalar& x, const Scalar& y, const RealScalar& z)
+{
+  using std::sqrt;
+  using std::abs;
+
+  RealScalar deno = RealScalar(2)*abs(y);
+  if(deno < (std::numeric_limits<RealScalar>::min)())
+  {
+    m_c = Scalar(1);
+    m_s = Scalar(0);
+    return false;
+  }
+  else
+  {
+    RealScalar tau = (x-z)/deno;
+    RealScalar w = sqrt(numext::abs2(tau) + RealScalar(1));
+    RealScalar t;
+    if(tau>RealScalar(0))
+    {
+      t = RealScalar(1) / (tau + w);
+    }
+    else
+    {
+      t = RealScalar(1) / (tau - w);
+    }
+    RealScalar sign_t = t > RealScalar(0) ? RealScalar(1) : RealScalar(-1);
+    RealScalar n = RealScalar(1) / sqrt(numext::abs2(t)+RealScalar(1));
+    m_s = - sign_t * (numext::conj(y) / abs(y)) * abs(t) * n;
+    m_c = n;
+    return true;
+  }
+}
+
+/** Makes \c *this as a Jacobi rotation \c J such that applying \a J on both the right and left sides of the 2x2 selfadjoint matrix
+  * \f$ B = \left ( \begin{array}{cc} \text{this}_{pp} & \text{this}_{pq} \\ (\text{this}_{pq})^* & \text{this}_{qq} \end{array} \right )\f$ yields
+  * a diagonal matrix \f$ A = J^* B J \f$
+  *
+  * Example: \include Jacobi_makeJacobi.cpp
+  * Output: \verbinclude Jacobi_makeJacobi.out
+  *
+  * \sa JacobiRotation::makeJacobi(RealScalar, Scalar, RealScalar), MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar>
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+inline bool JacobiRotation<Scalar>::makeJacobi(const MatrixBase<Derived>& m, Index p, Index q)
+{
+  return makeJacobi(numext::real(m.coeff(p,p)), m.coeff(p,q), numext::real(m.coeff(q,q)));
+}
+
+/** Makes \c *this as a Givens rotation \c G such that applying \f$ G^* \f$ to the left of the vector
+  * \f$ V = \left ( \begin{array}{c} p \\ q \end{array} \right )\f$ yields:
+  * \f$ G^* V = \left ( \begin{array}{c} r \\ 0 \end{array} \right )\f$.
+  *
+  * The value of \a r is returned if \a r is not null (the default is null).
+  * Also note that G is built such that the cosine is always real.
+  *
+  * Example: \include Jacobi_makeGivens.cpp
+  * Output: \verbinclude Jacobi_makeGivens.out
+  *
+  * This function implements the continuous Givens rotation generation algorithm
+  * found in Anderson (2000), Discontinuous Plane Rotations and the Symmetric Eigenvalue Problem.
+  * LAPACK Working Note 150, University of Tennessee, UT-CS-00-454, December 4, 2000.
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r)
+{
+  makeGivens(p, q, r, typename internal::conditional<NumTraits<Scalar>::IsComplex, internal::true_type, internal::false_type>::type());
+}
+
+
+// specialization for complexes
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::true_type)
+{
+  using std::sqrt;
+  using std::abs;
+  using numext::conj;
+
+  if(q==Scalar(0))
+  {
+    m_c = numext::real(p)<0 ? Scalar(-1) : Scalar(1);
+    m_s = 0;
+    if(r) *r = m_c * p;
+  }
+  else if(p==Scalar(0))
+  {
+    m_c = 0;
+    m_s = -q/abs(q);
+    if(r) *r = abs(q);
+  }
+  else
+  {
+    RealScalar p1 = numext::norm1(p);
+    RealScalar q1 = numext::norm1(q);
+    if(p1>=q1)
+    {
+      Scalar ps = p / p1;
+      RealScalar p2 = numext::abs2(ps);
+      Scalar qs = q / p1;
+      RealScalar q2 = numext::abs2(qs);
+
+      RealScalar u = sqrt(RealScalar(1) + q2/p2);
+      if(numext::real(p)<RealScalar(0))
+        u = -u;
+
+      m_c = Scalar(1)/u;
+      m_s = -qs*conj(ps)*(m_c/p2);
+      if(r) *r = p * u;
+    }
+    else
+    {
+      Scalar ps = p / q1;
+      RealScalar p2 = numext::abs2(ps);
+      Scalar qs = q / q1;
+      RealScalar q2 = numext::abs2(qs);
+
+      RealScalar u = q1 * sqrt(p2 + q2);
+      if(numext::real(p)<RealScalar(0))
+        u = -u;
+
+      p1 = abs(p);
+      ps = p/p1;
+      m_c = p1/u;
+      m_s = -conj(ps) * (q/u);
+      if(r) *r = ps * u;
+    }
+  }
+}
+
+// specialization for reals
+template<typename Scalar>
+EIGEN_DEVICE_FUNC
+void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type)
+{
+  using std::sqrt;
+  using std::abs;
+  if(q==Scalar(0))
+  {
+    m_c = p<Scalar(0) ? Scalar(-1) : Scalar(1);
+    m_s = Scalar(0);
+    if(r) *r = abs(p);
+  }
+  else if(p==Scalar(0))
+  {
+    m_c = Scalar(0);
+    m_s = q<Scalar(0) ? Scalar(1) : Scalar(-1);
+    if(r) *r = abs(q);
+  }
+  else if(abs(p) > abs(q))
+  {
+    Scalar t = q/p;
+    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
+    if(p<Scalar(0))
+      u = -u;
+    m_c = Scalar(1)/u;
+    m_s = -t * m_c;
+    if(r) *r = p * u;
+  }
+  else
+  {
+    Scalar t = p/q;
+    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
+    if(q<Scalar(0))
+      u = -u;
+    m_s = -Scalar(1)/u;
+    m_c = -t * m_s;
+    if(r) *r = q * u;
+  }
+
+}
+
+/****************************************************************************************
+*   Implementation of MatrixBase methods
+****************************************************************************************/
+
+namespace internal {
+/** \jacobi_module
+  * Applies the clock wise 2D rotation \a j to the set of 2D vectors of coordinates \a x and \a y:
+  * \f$ \left ( \begin{array}{cc} x \\ y \end{array} \right )  =  J \left ( \begin{array}{cc} x \\ y \end{array} \right ) \f$
+  *
+  * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()
+  */
+template<typename VectorX, typename VectorY, typename OtherScalar>
+EIGEN_DEVICE_FUNC
+void apply_rotation_in_the_plane(DenseBase<VectorX>& xpr_x, DenseBase<VectorY>& xpr_y, const JacobiRotation<OtherScalar>& j);
+}
+
+/** \jacobi_module
+  * Applies the rotation in the plane \a j to the rows \a p and \a q of \c *this, i.e., it computes B = J * B,
+  * with \f$ B = \left ( \begin{array}{cc} \text{*this.row}(p) \\ \text{*this.row}(q) \end{array} \right ) \f$.
+  *
+  * \sa class JacobiRotation, MatrixBase::applyOnTheRight(), internal::apply_rotation_in_the_plane()
+  */
+template<typename Derived>
+template<typename OtherScalar>
+EIGEN_DEVICE_FUNC
+inline void MatrixBase<Derived>::applyOnTheLeft(Index p, Index q, const JacobiRotation<OtherScalar>& j)
+{
+  RowXpr x(this->row(p));
+  RowXpr y(this->row(q));
+  internal::apply_rotation_in_the_plane(x, y, j);
+}
+
+/** \ingroup Jacobi_Module
+  * Applies the rotation in the plane \a j to the columns \a p and \a q of \c *this, i.e., it computes B = B * J
+  * with \f$ B = \left ( \begin{array}{cc} \text{*this.col}(p) & \text{*this.col}(q) \end{array} \right ) \f$.
+  *
+  * \sa class JacobiRotation, MatrixBase::applyOnTheLeft(), internal::apply_rotation_in_the_plane()
+  */
+template<typename Derived>
+template<typename OtherScalar>
+EIGEN_DEVICE_FUNC
+inline void MatrixBase<Derived>::applyOnTheRight(Index p, Index q, const JacobiRotation<OtherScalar>& j)
+{
+  ColXpr x(this->col(p));
+  ColXpr y(this->col(q));
+  internal::apply_rotation_in_the_plane(x, y, j.transpose());
+}
+
+namespace internal {
+
+template<typename Scalar, typename OtherScalar,
+         int SizeAtCompileTime, int MinAlignment, bool Vectorizable>
+struct apply_rotation_in_the_plane_selector
+{
+  static EIGEN_DEVICE_FUNC
+  inline void run(Scalar *x, Index incrx, Scalar *y, Index incry, Index size, OtherScalar c, OtherScalar s)
+  {
+    for(Index i=0; i<size; ++i)
+    {
+      Scalar xi = *x;
+      Scalar yi = *y;
+      *x =  c * xi + numext::conj(s) * yi;
+      *y = -s * xi + numext::conj(c) * yi;
+      x += incrx;
+      y += incry;
+    }
+  }
+};
+
+template<typename Scalar, typename OtherScalar,
+         int SizeAtCompileTime, int MinAlignment>
+struct apply_rotation_in_the_plane_selector<Scalar,OtherScalar,SizeAtCompileTime,MinAlignment,true /* vectorizable */>
+{
+  static inline void run(Scalar *x, Index incrx, Scalar *y, Index incry, Index size, OtherScalar c, OtherScalar s)
+  {
+    enum {
+      PacketSize = packet_traits<Scalar>::size,
+      OtherPacketSize = packet_traits<OtherScalar>::size
+    };
+    typedef typename packet_traits<Scalar>::type Packet;
+    typedef typename packet_traits<OtherScalar>::type OtherPacket;
+
+    /*** dynamic-size vectorized paths ***/
+    if(SizeAtCompileTime == Dynamic && ((incrx==1 && incry==1) || PacketSize == 1))
+    {
+      // both vectors are sequentially stored in memory => vectorization
+      enum { Peeling = 2 };
+
+      Index alignedStart = internal::first_default_aligned(y, size);
+      Index alignedEnd = alignedStart + ((size-alignedStart)/PacketSize)*PacketSize;
+
+      const OtherPacket pc = pset1<OtherPacket>(c);
+      const OtherPacket ps = pset1<OtherPacket>(s);
+      conj_helper<OtherPacket,Packet,NumTraits<OtherScalar>::IsComplex,false> pcj;
+      conj_helper<OtherPacket,Packet,false,false> pm;
+
+      for(Index i=0; i<alignedStart; ++i)
+      {
+        Scalar xi = x[i];
+        Scalar yi = y[i];
+        x[i] =  c * xi + numext::conj(s) * yi;
+        y[i] = -s * xi + numext::conj(c) * yi;
+      }
+
+      Scalar* EIGEN_RESTRICT px = x + alignedStart;
+      Scalar* EIGEN_RESTRICT py = y + alignedStart;
+
+      if(internal::first_default_aligned(x, size)==alignedStart)
+      {
+        for(Index i=alignedStart; i<alignedEnd; i+=PacketSize)
+        {
+          Packet xi = pload<Packet>(px);
+          Packet yi = pload<Packet>(py);
+          pstore(px, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+          pstore(py, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+          px += PacketSize;
+          py += PacketSize;
+        }
+      }
+      else
+      {
+        Index peelingEnd = alignedStart + ((size-alignedStart)/(Peeling*PacketSize))*(Peeling*PacketSize);
+        for(Index i=alignedStart; i<peelingEnd; i+=Peeling*PacketSize)
+        {
+          Packet xi   = ploadu<Packet>(px);
+          Packet xi1  = ploadu<Packet>(px+PacketSize);
+          Packet yi   = pload <Packet>(py);
+          Packet yi1  = pload <Packet>(py+PacketSize);
+          pstoreu(px, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+          pstoreu(px+PacketSize, padd(pm.pmul(pc,xi1),pcj.pmul(ps,yi1)));
+          pstore (py, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+          pstore (py+PacketSize, psub(pcj.pmul(pc,yi1),pm.pmul(ps,xi1)));
+          px += Peeling*PacketSize;
+          py += Peeling*PacketSize;
+        }
+        if(alignedEnd!=peelingEnd)
+        {
+          Packet xi = ploadu<Packet>(x+peelingEnd);
+          Packet yi = pload <Packet>(y+peelingEnd);
+          pstoreu(x+peelingEnd, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+          pstore (y+peelingEnd, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+        }
+      }
+
+      for(Index i=alignedEnd; i<size; ++i)
+      {
+        Scalar xi = x[i];
+        Scalar yi = y[i];
+        x[i] =  c * xi + numext::conj(s) * yi;
+        y[i] = -s * xi + numext::conj(c) * yi;
+      }
+    }
+
+    /*** fixed-size vectorized path ***/
+    else if(SizeAtCompileTime != Dynamic && MinAlignment>0) // FIXME should be compared to the required alignment
+    {
+      const OtherPacket pc = pset1<OtherPacket>(c);
+      const OtherPacket ps = pset1<OtherPacket>(s);
+      conj_helper<OtherPacket,Packet,NumTraits<OtherPacket>::IsComplex,false> pcj;
+      conj_helper<OtherPacket,Packet,false,false> pm;
+      Scalar* EIGEN_RESTRICT px = x;
+      Scalar* EIGEN_RESTRICT py = y;
+      for(Index i=0; i<size; i+=PacketSize)
+      {
+        Packet xi = pload<Packet>(px);
+        Packet yi = pload<Packet>(py);
+        pstore(px, padd(pm.pmul(pc,xi),pcj.pmul(ps,yi)));
+        pstore(py, psub(pcj.pmul(pc,yi),pm.pmul(ps,xi)));
+        px += PacketSize;
+        py += PacketSize;
+      }
+    }
+
+    /*** non-vectorized path ***/
+    else
+    {
+      apply_rotation_in_the_plane_selector<Scalar,OtherScalar,SizeAtCompileTime,MinAlignment,false>::run(x,incrx,y,incry,size,c,s);
+    }
+  }
+};
+
+template<typename VectorX, typename VectorY, typename OtherScalar>
+EIGEN_DEVICE_FUNC
+void /*EIGEN_DONT_INLINE*/ apply_rotation_in_the_plane(DenseBase<VectorX>& xpr_x, DenseBase<VectorY>& xpr_y, const JacobiRotation<OtherScalar>& j)
+{
+  typedef typename VectorX::Scalar Scalar;
+  const bool Vectorizable =    (int(VectorX::Flags) & int(VectorY::Flags) & PacketAccessBit)
+                            && (int(packet_traits<Scalar>::size) == int(packet_traits<OtherScalar>::size));
+
+  eigen_assert(xpr_x.size() == xpr_y.size());
+  Index size = xpr_x.size();
+  Index incrx = xpr_x.derived().innerStride();
+  Index incry = xpr_y.derived().innerStride();
+
+  Scalar* EIGEN_RESTRICT x = &xpr_x.derived().coeffRef(0);
+  Scalar* EIGEN_RESTRICT y = &xpr_y.derived().coeffRef(0);
+
+  OtherScalar c = j.c();
+  OtherScalar s = j.s();
+  if (c==OtherScalar(1) && s==OtherScalar(0))
+    return;
+
+  apply_rotation_in_the_plane_selector<
+    Scalar,OtherScalar,
+    VectorX::SizeAtCompileTime,
+    EIGEN_PLAIN_ENUM_MIN(evaluator<VectorX>::Alignment, evaluator<VectorY>::Alignment),
+    Vectorizable>::run(x,incrx,y,incry,size,c,s);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_JACOBI_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/KLUSupport/KLUSupport.h b/C++/yolo_bytetrack_old/include/Eigen/src/KLUSupport/KLUSupport.h
new file mode 100644
index 00000000..215db35b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/KLUSupport/KLUSupport.h
@@ -0,0 +1,358 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Kyle Macfarlan <kyle.macfarlan@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_KLUSUPPORT_H
+#define EIGEN_KLUSUPPORT_H
+
+namespace Eigen {
+
+/* TODO extract L, extract U, compute det, etc... */
+
+/** \ingroup KLUSupport_Module
+  * \brief A sparse LU factorization and solver based on KLU
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LU factorization
+  * using the KLU library. The sparse matrix A must be squared and full rank.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * \warning The input matrix A should be in a \b compressed and \b column-major form.
+  * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class UmfPackLU, class SparseLU
+  */
+
+
+inline int klu_solve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B [ ], klu_common *Common, double) {
+   return klu_solve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), B, Common);
+}
+
+inline int klu_solve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex<double>B[], klu_common *Common, std::complex<double>) {
+   return klu_z_solve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), &numext::real_ref(B[0]), Common);
+}
+
+inline int klu_tsolve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B[], klu_common *Common, double) {
+   return klu_tsolve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), B, Common);
+}
+
+inline int klu_tsolve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex<double>B[], klu_common *Common, std::complex<double>) {
+   return klu_z_tsolve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), &numext::real_ref(B[0]), 0, Common);
+}
+
+inline klu_numeric* klu_factor(int Ap [ ], int Ai [ ], double Ax [ ], klu_symbolic *Symbolic, klu_common *Common, double) {
+   return klu_factor(Ap, Ai, Ax, Symbolic, Common);
+}
+
+inline klu_numeric* klu_factor(int Ap[], int Ai[], std::complex<double> Ax[], klu_symbolic *Symbolic, klu_common *Common, std::complex<double>) {
+   return klu_z_factor(Ap, Ai, &numext::real_ref(Ax[0]), Symbolic, Common);
+}
+
+
+template<typename _MatrixType>
+class KLU : public SparseSolverBase<KLU<_MatrixType> >
+{
+  protected:
+    typedef SparseSolverBase<KLU<_MatrixType> > Base;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
+    typedef SparseMatrix<Scalar> LUMatrixType;
+    typedef SparseMatrix<Scalar,ColMajor,int> KLUMatrixType;
+    typedef Ref<const KLUMatrixType, StandardCompressedFormat> KLUMatrixRef;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    KLU()
+      : m_dummy(0,0), mp_matrix(m_dummy)
+    {
+      init();
+    }
+
+    template<typename InputMatrixType>
+    explicit KLU(const InputMatrixType& matrix)
+      : mp_matrix(matrix)
+    {
+      init();
+      compute(matrix);
+    }
+
+    ~KLU()
+    {
+      if(m_symbolic) klu_free_symbolic(&m_symbolic,&m_common);
+      if(m_numeric)  klu_free_numeric(&m_numeric,&m_common);
+    }
+
+    EIGEN_CONSTEXPR inline Index rows() const EIGEN_NOEXCEPT { return mp_matrix.rows(); }
+    EIGEN_CONSTEXPR inline Index cols() const EIGEN_NOEXCEPT { return mp_matrix.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+#if 0 // not implemented yet
+    inline const LUMatrixType& matrixL() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_l;
+    }
+
+    inline const LUMatrixType& matrixU() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_u;
+    }
+
+    inline const IntColVectorType& permutationP() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_p;
+    }
+
+    inline const IntRowVectorType& permutationQ() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_q;
+    }
+#endif
+    /** Computes the sparse Cholesky decomposition of \a matrix
+     *  Note that the matrix should be column-major, and in compressed format for best performance.
+     *  \sa SparseMatrix::makeCompressed().
+     */
+    template<typename InputMatrixType>
+    void compute(const InputMatrixType& matrix)
+    {
+      if(m_symbolic) klu_free_symbolic(&m_symbolic, &m_common);
+      if(m_numeric)  klu_free_numeric(&m_numeric, &m_common);
+      grab(matrix.derived());
+      analyzePattern_impl();
+      factorize_impl();
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize(), compute()
+      */
+    template<typename InputMatrixType>
+    void analyzePattern(const InputMatrixType& matrix)
+    {
+      if(m_symbolic) klu_free_symbolic(&m_symbolic, &m_common);
+      if(m_numeric)  klu_free_numeric(&m_numeric, &m_common);
+
+      grab(matrix.derived());
+
+      analyzePattern_impl();
+    }
+
+
+    /** Provides access to the control settings array used by KLU.
+      *
+      * See KLU documentation for details.
+      */
+    inline const klu_common& kluCommon() const
+    {
+      return m_common;
+    }
+
+    /** Provides access to the control settings array used by UmfPack.
+      *
+      * If this array contains NaN's, the default values are used.
+      *
+      * See KLU documentation for details.
+      */
+    inline klu_common& kluCommon()
+    {
+      return m_common;
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the pattern anylysis has been performed.
+      *
+      * \sa analyzePattern(), compute()
+      */
+    template<typename InputMatrixType>
+    void factorize(const InputMatrixType& matrix)
+    {
+      eigen_assert(m_analysisIsOk && "KLU: you must first call analyzePattern()");
+      if(m_numeric)
+        klu_free_numeric(&m_numeric,&m_common);
+
+      grab(matrix.derived());
+
+      factorize_impl();
+    }
+
+    /** \internal */
+    template<typename BDerived,typename XDerived>
+    bool _solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const;
+
+#if 0 // not implemented yet
+    Scalar determinant() const;
+
+    void extractData() const;
+#endif
+
+  protected:
+
+    void init()
+    {
+      m_info                  = InvalidInput;
+      m_isInitialized         = false;
+      m_numeric               = 0;
+      m_symbolic              = 0;
+      m_extractedDataAreDirty = true;
+
+      klu_defaults(&m_common);
+    }
+
+    void analyzePattern_impl()
+    {
+      m_info = InvalidInput;
+      m_analysisIsOk = false;
+      m_factorizationIsOk = false;
+      m_symbolic = klu_analyze(internal::convert_index<int>(mp_matrix.rows()),
+                                     const_cast<StorageIndex*>(mp_matrix.outerIndexPtr()), const_cast<StorageIndex*>(mp_matrix.innerIndexPtr()),
+                                     &m_common);
+      if (m_symbolic) {
+         m_isInitialized = true;
+         m_info = Success;
+         m_analysisIsOk = true;
+         m_extractedDataAreDirty = true;
+      }
+    }
+
+    void factorize_impl()
+    {
+
+      m_numeric = klu_factor(const_cast<StorageIndex*>(mp_matrix.outerIndexPtr()), const_cast<StorageIndex*>(mp_matrix.innerIndexPtr()), const_cast<Scalar*>(mp_matrix.valuePtr()),
+                                    m_symbolic, &m_common, Scalar());
+
+
+      m_info = m_numeric ? Success : NumericalIssue;
+      m_factorizationIsOk = m_numeric ? 1 : 0;
+      m_extractedDataAreDirty = true;
+    }
+
+    template<typename MatrixDerived>
+    void grab(const EigenBase<MatrixDerived> &A)
+    {
+      mp_matrix.~KLUMatrixRef();
+      ::new (&mp_matrix) KLUMatrixRef(A.derived());
+    }
+
+    void grab(const KLUMatrixRef &A)
+    {
+      if(&(A.derived()) != &mp_matrix)
+      {
+        mp_matrix.~KLUMatrixRef();
+        ::new (&mp_matrix) KLUMatrixRef(A);
+      }
+    }
+
+    // cached data to reduce reallocation, etc.
+#if 0 // not implemented yet
+    mutable LUMatrixType m_l;
+    mutable LUMatrixType m_u;
+    mutable IntColVectorType m_p;
+    mutable IntRowVectorType m_q;
+#endif
+
+    KLUMatrixType m_dummy;
+    KLUMatrixRef mp_matrix;
+
+    klu_numeric* m_numeric;
+    klu_symbolic* m_symbolic;
+    klu_common m_common;
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+    mutable bool m_extractedDataAreDirty;
+
+  private:
+    KLU(const KLU& ) { }
+};
+
+#if 0 // not implemented yet
+template<typename MatrixType>
+void KLU<MatrixType>::extractData() const
+{
+  if (m_extractedDataAreDirty)
+  {
+     eigen_assert(false && "KLU: extractData Not Yet Implemented");
+
+    // get size of the data
+    int lnz, unz, rows, cols, nz_udiag;
+    umfpack_get_lunz(&lnz, &unz, &rows, &cols, &nz_udiag, m_numeric, Scalar());
+
+    // allocate data
+    m_l.resize(rows,(std::min)(rows,cols));
+    m_l.resizeNonZeros(lnz);
+
+    m_u.resize((std::min)(rows,cols),cols);
+    m_u.resizeNonZeros(unz);
+
+    m_p.resize(rows);
+    m_q.resize(cols);
+
+    // extract
+    umfpack_get_numeric(m_l.outerIndexPtr(), m_l.innerIndexPtr(), m_l.valuePtr(),
+                        m_u.outerIndexPtr(), m_u.innerIndexPtr(), m_u.valuePtr(),
+                        m_p.data(), m_q.data(), 0, 0, 0, m_numeric);
+
+    m_extractedDataAreDirty = false;
+  }
+}
+
+template<typename MatrixType>
+typename KLU<MatrixType>::Scalar KLU<MatrixType>::determinant() const
+{
+  eigen_assert(false && "KLU: extractData Not Yet Implemented");
+  return Scalar();
+}
+#endif
+
+template<typename MatrixType>
+template<typename BDerived,typename XDerived>
+bool KLU<MatrixType>::_solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const
+{
+  Index rhsCols = b.cols();
+  EIGEN_STATIC_ASSERT((XDerived::Flags&RowMajorBit)==0, THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or analyzePattern()/factorize()");
+
+  x = b;
+  int info = klu_solve(m_symbolic, m_numeric, b.rows(), rhsCols, x.const_cast_derived().data(), const_cast<klu_common*>(&m_common), Scalar());
+
+  m_info = info!=0 ? Success : NumericalIssue;
+  return true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_KLUSUPPORT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/LU/Determinant.h b/C++/yolo_bytetrack_old/include/Eigen/src/LU/Determinant.h
new file mode 100644
index 00000000..3a41e6fc
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/LU/Determinant.h
@@ -0,0 +1,117 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_DETERMINANT_H
+#define EIGEN_DETERMINANT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+inline const typename Derived::Scalar bruteforce_det3_helper
+(const MatrixBase<Derived>& matrix, int a, int b, int c)
+{
+  return matrix.coeff(0,a)
+         * (matrix.coeff(1,b) * matrix.coeff(2,c) - matrix.coeff(1,c) * matrix.coeff(2,b));
+}
+
+template<typename Derived,
+         int DeterminantType = Derived::RowsAtCompileTime
+> struct determinant_impl
+{
+  static inline typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    if(Derived::ColsAtCompileTime==Dynamic && m.rows()==0)
+      return typename traits<Derived>::Scalar(1);
+    return m.partialPivLu().determinant();
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 1>
+{
+  static inline EIGEN_DEVICE_FUNC
+  typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    return m.coeff(0,0);
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 2>
+{
+  static inline EIGEN_DEVICE_FUNC
+  typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    return m.coeff(0,0) * m.coeff(1,1) - m.coeff(1,0) * m.coeff(0,1);
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 3>
+{
+  static inline EIGEN_DEVICE_FUNC
+  typename traits<Derived>::Scalar run(const Derived& m)
+  {
+    return bruteforce_det3_helper(m,0,1,2)
+          - bruteforce_det3_helper(m,1,0,2)
+          + bruteforce_det3_helper(m,2,0,1);
+  }
+};
+
+template<typename Derived> struct determinant_impl<Derived, 4>
+{
+  typedef typename traits<Derived>::Scalar Scalar;
+  static EIGEN_DEVICE_FUNC
+  Scalar run(const Derived& m)
+  {
+    Scalar d2_01 = det2(m, 0, 1);
+    Scalar d2_02 = det2(m, 0, 2);
+    Scalar d2_03 = det2(m, 0, 3);
+    Scalar d2_12 = det2(m, 1, 2);
+    Scalar d2_13 = det2(m, 1, 3);
+    Scalar d2_23 = det2(m, 2, 3);
+    Scalar d3_0 = det3(m, 1,d2_23, 2,d2_13, 3,d2_12);
+    Scalar d3_1 = det3(m, 0,d2_23, 2,d2_03, 3,d2_02);
+    Scalar d3_2 = det3(m, 0,d2_13, 1,d2_03, 3,d2_01);
+    Scalar d3_3 = det3(m, 0,d2_12, 1,d2_02, 2,d2_01);
+    return internal::pmadd(-m(0,3),d3_0, m(1,3)*d3_1) +
+           internal::pmadd(-m(2,3),d3_2, m(3,3)*d3_3);
+  }
+protected:
+  static EIGEN_DEVICE_FUNC
+  Scalar det2(const Derived& m, Index i0, Index i1)
+  {
+    return m(i0,0) * m(i1,1) - m(i1,0) * m(i0,1);
+  }
+
+  static EIGEN_DEVICE_FUNC
+  Scalar det3(const Derived& m, Index i0, const Scalar& d0, Index i1, const Scalar& d1, Index i2, const Scalar& d2)
+  {
+    return internal::pmadd(m(i0,2), d0, internal::pmadd(-m(i1,2), d1, m(i2,2)*d2));
+  }
+};
+
+} // end namespace internal
+
+/** \lu_module
+  *
+  * \returns the determinant of this matrix
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+inline typename internal::traits<Derived>::Scalar MatrixBase<Derived>::determinant() const
+{
+  eigen_assert(rows() == cols());
+  typedef typename internal::nested_eval<Derived,Base::RowsAtCompileTime>::type Nested;
+  return internal::determinant_impl<typename internal::remove_all<Nested>::type>::run(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_DETERMINANT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/LU/FullPivLU.h b/C++/yolo_bytetrack_old/include/Eigen/src/LU/FullPivLU.h
new file mode 100644
index 00000000..ba1749fa
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/LU/FullPivLU.h
@@ -0,0 +1,877 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LU_H
+#define EIGEN_LU_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _MatrixType> struct traits<FullPivLU<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+} // end namespace internal
+
+/** \ingroup LU_Module
+  *
+  * \class FullPivLU
+  *
+  * \brief LU decomposition of a matrix with complete pivoting, and related features
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the LU decomposition
+  *
+  * This class represents a LU decomposition of any matrix, with complete pivoting: the matrix A is
+  * decomposed as \f$ A = P^{-1} L U Q^{-1} \f$ where L is unit-lower-triangular, U is
+  * upper-triangular, and P and Q are permutation matrices. This is a rank-revealing LU
+  * decomposition. The eigenvalues (diagonal coefficients) of U are sorted in such a way that any
+  * zeros are at the end.
+  *
+  * This decomposition provides the generic approach to solving systems of linear equations, computing
+  * the rank, invertibility, inverse, kernel, and determinant.
+  *
+  * This LU decomposition is very stable and well tested with large matrices. However there are use cases where the SVD
+  * decomposition is inherently more stable and/or flexible. For example, when computing the kernel of a matrix,
+  * working with the SVD allows to select the smallest singular values of the matrix, something that
+  * the LU decomposition doesn't see.
+  *
+  * The data of the LU decomposition can be directly accessed through the methods matrixLU(),
+  * permutationP(), permutationQ().
+  *
+  * As an example, here is how the original matrix can be retrieved:
+  * \include class_FullPivLU.cpp
+  * Output: \verbinclude class_FullPivLU.out
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * \sa MatrixBase::fullPivLu(), MatrixBase::determinant(), MatrixBase::inverse()
+  */
+template<typename _MatrixType> class FullPivLU
+  : public SolverBase<FullPivLU<_MatrixType> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<FullPivLU> Base;
+    friend class SolverBase<FullPivLU>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(FullPivLU)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename internal::plain_row_type<MatrixType, StorageIndex>::type IntRowVectorType;
+    typedef typename internal::plain_col_type<MatrixType, StorageIndex>::type IntColVectorType;
+    typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationQType;
+    typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationPType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via LU::compute(const MatrixType&).
+      */
+    FullPivLU();
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa FullPivLU()
+      */
+    FullPivLU(Index rows, Index cols);
+
+    /** Constructor.
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *               It is required to be nonzero.
+      */
+    template<typename InputType>
+    explicit FullPivLU(const EigenBase<InputType>& matrix);
+
+    /** \brief Constructs a LU factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa FullPivLU(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit FullPivLU(EigenBase<InputType>& matrix);
+
+    /** Computes the LU decomposition of the given matrix.
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *               It is required to be nonzero.
+      *
+      * \returns a reference to *this
+      */
+    template<typename InputType>
+    FullPivLU& compute(const EigenBase<InputType>& matrix) {
+      m_lu = matrix.derived();
+      computeInPlace();
+      return *this;
+    }
+
+    /** \returns the LU decomposition matrix: the upper-triangular part is U, the
+      * unit-lower-triangular part is L (at least for square matrices; in the non-square
+      * case, special care is needed, see the documentation of class FullPivLU).
+      *
+      * \sa matrixL(), matrixU()
+      */
+    inline const MatrixType& matrixLU() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_lu;
+    }
+
+    /** \returns the number of nonzero pivots in the LU decomposition.
+      * Here nonzero is meant in the exact sense, not in a fuzzy sense.
+      * So that notion isn't really intrinsically interesting, but it is
+      * still useful when implementing algorithms.
+      *
+      * \sa rank()
+      */
+    inline Index nonzeroPivots() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_nonzero_pivots;
+    }
+
+    /** \returns the absolute value of the biggest pivot, i.e. the biggest
+      *          diagonal coefficient of U.
+      */
+    RealScalar maxPivot() const { return m_maxpivot; }
+
+    /** \returns the permutation matrix P
+      *
+      * \sa permutationQ()
+      */
+    EIGEN_DEVICE_FUNC inline const PermutationPType& permutationP() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_p;
+    }
+
+    /** \returns the permutation matrix Q
+      *
+      * \sa permutationP()
+      */
+    inline const PermutationQType& permutationQ() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_q;
+    }
+
+    /** \returns the kernel of the matrix, also called its null-space. The columns of the returned matrix
+      * will form a basis of the kernel.
+      *
+      * \note If the kernel has dimension zero, then the returned matrix is a column-vector filled with zeros.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      *
+      * Example: \include FullPivLU_kernel.cpp
+      * Output: \verbinclude FullPivLU_kernel.out
+      *
+      * \sa image()
+      */
+    inline const internal::kernel_retval<FullPivLU> kernel() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return internal::kernel_retval<FullPivLU>(*this);
+    }
+
+    /** \returns the image of the matrix, also called its column-space. The columns of the returned matrix
+      * will form a basis of the image (column-space).
+      *
+      * \param originalMatrix the original matrix, of which *this is the LU decomposition.
+      *                       The reason why it is needed to pass it here, is that this allows
+      *                       a large optimization, as otherwise this method would need to reconstruct it
+      *                       from the LU decomposition.
+      *
+      * \note If the image has dimension zero, then the returned matrix is a column-vector filled with zeros.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      *
+      * Example: \include FullPivLU_image.cpp
+      * Output: \verbinclude FullPivLU_image.out
+      *
+      * \sa kernel()
+      */
+    inline const internal::image_retval<FullPivLU>
+      image(const MatrixType& originalMatrix) const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return internal::image_retval<FullPivLU>(*this, originalMatrix);
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \return a solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the LU decomposition.
+      *
+      * \param b the right-hand-side of the equation to solve. Can be a vector or a matrix,
+      *          the only requirement in order for the equation to make sense is that
+      *          b.rows()==A.rows(), where A is the matrix of which *this is the LU decomposition.
+      *
+      * \returns a solution.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      * \note_about_using_kernel_to_study_multiple_solutions
+      *
+      * Example: \include FullPivLU_solve.cpp
+      * Output: \verbinclude FullPivLU_solve.out
+      *
+      * \sa TriangularView::solve(), kernel(), inverse()
+      */
+    template<typename Rhs>
+    inline const Solve<FullPivLU, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of which \c *this is
+        the LU decomposition.
+      */
+    inline RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    /** \returns the determinant of the matrix of which
+      * *this is the LU decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the LU decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note For fixed-size matrices of size up to 4, MatrixBase::determinant() offers
+      *       optimized paths.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      *
+      * \sa MatrixBase::determinant()
+      */
+    typename internal::traits<MatrixType>::Scalar determinant() const;
+
+    /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
+      * who need to determine when pivots are to be considered nonzero. This is not used for the
+      * LU decomposition itself.
+      *
+      * When it needs to get the threshold value, Eigen calls threshold(). By default, this
+      * uses a formula to automatically determine a reasonable threshold.
+      * Once you have called the present method setThreshold(const RealScalar&),
+      * your value is used instead.
+      *
+      * \param threshold The new value to use as the threshold.
+      *
+      * A pivot will be considered nonzero if its absolute value is strictly greater than
+      *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+      * where maxpivot is the biggest pivot.
+      *
+      * If you want to come back to the default behavior, call setThreshold(Default_t)
+      */
+    FullPivLU& setThreshold(const RealScalar& threshold)
+    {
+      m_usePrescribedThreshold = true;
+      m_prescribedThreshold = threshold;
+      return *this;
+    }
+
+    /** Allows to come back to the default behavior, letting Eigen use its default formula for
+      * determining the threshold.
+      *
+      * You should pass the special object Eigen::Default as parameter here.
+      * \code lu.setThreshold(Eigen::Default); \endcode
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    FullPivLU& setThreshold(Default_t)
+    {
+      m_usePrescribedThreshold = false;
+      return *this;
+    }
+
+    /** Returns the threshold that will be used by certain methods such as rank().
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    RealScalar threshold() const
+    {
+      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+      return m_usePrescribedThreshold ? m_prescribedThreshold
+      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
+      // and turns out to be identical to Higham's formula used already in LDLt.
+          : NumTraits<Scalar>::epsilon() * RealScalar(m_lu.diagonalSize());
+    }
+
+    /** \returns the rank of the matrix of which *this is the LU decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index rank() const
+    {
+      using std::abs;
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
+      Index result = 0;
+      for(Index i = 0; i < m_nonzero_pivots; ++i)
+        result += (abs(m_lu.coeff(i,i)) > premultiplied_threshold);
+      return result;
+    }
+
+    /** \returns the dimension of the kernel of the matrix of which *this is the LU decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index dimensionOfKernel() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return cols() - rank();
+    }
+
+    /** \returns true if the matrix of which *this is the LU decomposition represents an injective
+      *          linear map, i.e. has trivial kernel; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInjective() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return rank() == cols();
+    }
+
+    /** \returns true if the matrix of which *this is the LU decomposition represents a surjective
+      *          linear map; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isSurjective() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return rank() == rows();
+    }
+
+    /** \returns true if the matrix of which *this is the LU decomposition is invertible.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInvertible() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return isInjective() && (m_lu.rows() == m_lu.cols());
+    }
+
+    /** \returns the inverse of the matrix of which *this is the LU decomposition.
+      *
+      * \note If this matrix is not invertible, the returned matrix has undefined coefficients.
+      *       Use isInvertible() to first determine whether this matrix is invertible.
+      *
+      * \sa MatrixBase::inverse()
+      */
+    inline const Inverse<FullPivLU> inverse() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the inverse of a non-square matrix!");
+      return Inverse<FullPivLU>(*this);
+    }
+
+    MatrixType reconstructedMatrix() const;
+
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index rows() const EIGEN_NOEXCEPT { return m_lu.rows(); }
+    EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
+    inline Index cols() const EIGEN_NOEXCEPT { return m_lu.cols(); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_lu;
+    PermutationPType m_p;
+    PermutationQType m_q;
+    IntColVectorType m_rowsTranspositions;
+    IntRowVectorType m_colsTranspositions;
+    Index m_nonzero_pivots;
+    RealScalar m_l1_norm;
+    RealScalar m_maxpivot, m_prescribedThreshold;
+    signed char m_det_pq;
+    bool m_isInitialized, m_usePrescribedThreshold;
+};
+
+template<typename MatrixType>
+FullPivLU<MatrixType>::FullPivLU()
+  : m_isInitialized(false), m_usePrescribedThreshold(false)
+{
+}
+
+template<typename MatrixType>
+FullPivLU<MatrixType>::FullPivLU(Index rows, Index cols)
+  : m_lu(rows, cols),
+    m_p(rows),
+    m_q(cols),
+    m_rowsTranspositions(rows),
+    m_colsTranspositions(cols),
+    m_isInitialized(false),
+    m_usePrescribedThreshold(false)
+{
+}
+
+template<typename MatrixType>
+template<typename InputType>
+FullPivLU<MatrixType>::FullPivLU(const EigenBase<InputType>& matrix)
+  : m_lu(matrix.rows(), matrix.cols()),
+    m_p(matrix.rows()),
+    m_q(matrix.cols()),
+    m_rowsTranspositions(matrix.rows()),
+    m_colsTranspositions(matrix.cols()),
+    m_isInitialized(false),
+    m_usePrescribedThreshold(false)
+{
+  compute(matrix.derived());
+}
+
+template<typename MatrixType>
+template<typename InputType>
+FullPivLU<MatrixType>::FullPivLU(EigenBase<InputType>& matrix)
+  : m_lu(matrix.derived()),
+    m_p(matrix.rows()),
+    m_q(matrix.cols()),
+    m_rowsTranspositions(matrix.rows()),
+    m_colsTranspositions(matrix.cols()),
+    m_isInitialized(false),
+    m_usePrescribedThreshold(false)
+{
+  computeInPlace();
+}
+
+template<typename MatrixType>
+void FullPivLU<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  // the permutations are stored as int indices, so just to be sure:
+  eigen_assert(m_lu.rows()<=NumTraits<int>::highest() && m_lu.cols()<=NumTraits<int>::highest());
+
+  m_l1_norm = m_lu.cwiseAbs().colwise().sum().maxCoeff();
+
+  const Index size = m_lu.diagonalSize();
+  const Index rows = m_lu.rows();
+  const Index cols = m_lu.cols();
+
+  // will store the transpositions, before we accumulate them at the end.
+  // can't accumulate on-the-fly because that will be done in reverse order for the rows.
+  m_rowsTranspositions.resize(m_lu.rows());
+  m_colsTranspositions.resize(m_lu.cols());
+  Index number_of_transpositions = 0; // number of NONTRIVIAL transpositions, i.e. m_rowsTranspositions[i]!=i
+
+  m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case)
+  m_maxpivot = RealScalar(0);
+
+  for(Index k = 0; k < size; ++k)
+  {
+    // First, we need to find the pivot.
+
+    // biggest coefficient in the remaining bottom-right corner (starting at row k, col k)
+    Index row_of_biggest_in_corner, col_of_biggest_in_corner;
+    typedef internal::scalar_score_coeff_op<Scalar> Scoring;
+    typedef typename Scoring::result_type Score;
+    Score biggest_in_corner;
+    biggest_in_corner = m_lu.bottomRightCorner(rows-k, cols-k)
+                        .unaryExpr(Scoring())
+                        .maxCoeff(&row_of_biggest_in_corner, &col_of_biggest_in_corner);
+    row_of_biggest_in_corner += k; // correct the values! since they were computed in the corner,
+    col_of_biggest_in_corner += k; // need to add k to them.
+
+    if(biggest_in_corner==Score(0))
+    {
+      // before exiting, make sure to initialize the still uninitialized transpositions
+      // in a sane state without destroying what we already have.
+      m_nonzero_pivots = k;
+      for(Index i = k; i < size; ++i)
+      {
+        m_rowsTranspositions.coeffRef(i) = internal::convert_index<StorageIndex>(i);
+        m_colsTranspositions.coeffRef(i) = internal::convert_index<StorageIndex>(i);
+      }
+      break;
+    }
+
+    RealScalar abs_pivot = internal::abs_knowing_score<Scalar>()(m_lu(row_of_biggest_in_corner, col_of_biggest_in_corner), biggest_in_corner);
+    if(abs_pivot > m_maxpivot) m_maxpivot = abs_pivot;
+
+    // Now that we've found the pivot, we need to apply the row/col swaps to
+    // bring it to the location (k,k).
+
+    m_rowsTranspositions.coeffRef(k) = internal::convert_index<StorageIndex>(row_of_biggest_in_corner);
+    m_colsTranspositions.coeffRef(k) = internal::convert_index<StorageIndex>(col_of_biggest_in_corner);
+    if(k != row_of_biggest_in_corner) {
+      m_lu.row(k).swap(m_lu.row(row_of_biggest_in_corner));
+      ++number_of_transpositions;
+    }
+    if(k != col_of_biggest_in_corner) {
+      m_lu.col(k).swap(m_lu.col(col_of_biggest_in_corner));
+      ++number_of_transpositions;
+    }
+
+    // Now that the pivot is at the right location, we update the remaining
+    // bottom-right corner by Gaussian elimination.
+
+    if(k<rows-1)
+      m_lu.col(k).tail(rows-k-1) /= m_lu.coeff(k,k);
+    if(k<size-1)
+      m_lu.block(k+1,k+1,rows-k-1,cols-k-1).noalias() -= m_lu.col(k).tail(rows-k-1) * m_lu.row(k).tail(cols-k-1);
+  }
+
+  // the main loop is over, we still have to accumulate the transpositions to find the
+  // permutations P and Q
+
+  m_p.setIdentity(rows);
+  for(Index k = size-1; k >= 0; --k)
+    m_p.applyTranspositionOnTheRight(k, m_rowsTranspositions.coeff(k));
+
+  m_q.setIdentity(cols);
+  for(Index k = 0; k < size; ++k)
+    m_q.applyTranspositionOnTheRight(k, m_colsTranspositions.coeff(k));
+
+  m_det_pq = (number_of_transpositions%2) ? -1 : 1;
+
+  m_isInitialized = true;
+}
+
+template<typename MatrixType>
+typename internal::traits<MatrixType>::Scalar FullPivLU<MatrixType>::determinant() const
+{
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the determinant of a non-square matrix!");
+  return Scalar(m_det_pq) * Scalar(m_lu.diagonal().prod());
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: \f$ P^{-1} L U Q^{-1} \f$.
+ * This function is provided for debug purposes. */
+template<typename MatrixType>
+MatrixType FullPivLU<MatrixType>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  const Index smalldim = (std::min)(m_lu.rows(), m_lu.cols());
+  // LU
+  MatrixType res(m_lu.rows(),m_lu.cols());
+  // FIXME the .toDenseMatrix() should not be needed...
+  res = m_lu.leftCols(smalldim)
+            .template triangularView<UnitLower>().toDenseMatrix()
+      * m_lu.topRows(smalldim)
+            .template triangularView<Upper>().toDenseMatrix();
+
+  // P^{-1}(LU)
+  res = m_p.inverse() * res;
+
+  // (P^{-1}LU)Q^{-1}
+  res = res * m_q.inverse();
+
+  return res;
+}
+
+/********* Implementation of kernel() **************************************************/
+
+namespace internal {
+template<typename _MatrixType>
+struct kernel_retval<FullPivLU<_MatrixType> >
+  : kernel_retval_base<FullPivLU<_MatrixType> >
+{
+  EIGEN_MAKE_KERNEL_HELPERS(FullPivLU<_MatrixType>)
+
+  enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(
+            MatrixType::MaxColsAtCompileTime,
+            MatrixType::MaxRowsAtCompileTime)
+  };
+
+  template<typename Dest> void evalTo(Dest& dst) const
+  {
+    using std::abs;
+    const Index cols = dec().matrixLU().cols(), dimker = cols - rank();
+    if(dimker == 0)
+    {
+      // The Kernel is just {0}, so it doesn't have a basis properly speaking, but let's
+      // avoid crashing/asserting as that depends on floating point calculations. Let's
+      // just return a single column vector filled with zeros.
+      dst.setZero();
+      return;
+    }
+
+    /* Let us use the following lemma:
+      *
+      * Lemma: If the matrix A has the LU decomposition PAQ = LU,
+      * then Ker A = Q(Ker U).
+      *
+      * Proof: trivial: just keep in mind that P, Q, L are invertible.
+      */
+
+    /* Thus, all we need to do is to compute Ker U, and then apply Q.
+      *
+      * U is upper triangular, with eigenvalues sorted so that any zeros appear at the end.
+      * Thus, the diagonal of U ends with exactly
+      * dimKer zero's. Let us use that to construct dimKer linearly
+      * independent vectors in Ker U.
+      */
+
+    Matrix<Index, Dynamic, 1, 0, MaxSmallDimAtCompileTime, 1> pivots(rank());
+    RealScalar premultiplied_threshold = dec().maxPivot() * dec().threshold();
+    Index p = 0;
+    for(Index i = 0; i < dec().nonzeroPivots(); ++i)
+      if(abs(dec().matrixLU().coeff(i,i)) > premultiplied_threshold)
+        pivots.coeffRef(p++) = i;
+    eigen_internal_assert(p == rank());
+
+    // we construct a temporaty trapezoid matrix m, by taking the U matrix and
+    // permuting the rows and cols to bring the nonnegligible pivots to the top of
+    // the main diagonal. We need that to be able to apply our triangular solvers.
+    // FIXME when we get triangularView-for-rectangular-matrices, this can be simplified
+    Matrix<typename MatrixType::Scalar, Dynamic, Dynamic, MatrixType::Options,
+           MaxSmallDimAtCompileTime, MatrixType::MaxColsAtCompileTime>
+      m(dec().matrixLU().block(0, 0, rank(), cols));
+    for(Index i = 0; i < rank(); ++i)
+    {
+      if(i) m.row(i).head(i).setZero();
+      m.row(i).tail(cols-i) = dec().matrixLU().row(pivots.coeff(i)).tail(cols-i);
+    }
+    m.block(0, 0, rank(), rank());
+    m.block(0, 0, rank(), rank()).template triangularView<StrictlyLower>().setZero();
+    for(Index i = 0; i < rank(); ++i)
+      m.col(i).swap(m.col(pivots.coeff(i)));
+
+    // ok, we have our trapezoid matrix, we can apply the triangular solver.
+    // notice that the math behind this suggests that we should apply this to the
+    // negative of the RHS, but for performance we just put the negative sign elsewhere, see below.
+    m.topLeftCorner(rank(), rank())
+     .template triangularView<Upper>().solveInPlace(
+        m.topRightCorner(rank(), dimker)
+      );
+
+    // now we must undo the column permutation that we had applied!
+    for(Index i = rank()-1; i >= 0; --i)
+      m.col(i).swap(m.col(pivots.coeff(i)));
+
+    // see the negative sign in the next line, that's what we were talking about above.
+    for(Index i = 0; i < rank(); ++i) dst.row(dec().permutationQ().indices().coeff(i)) = -m.row(i).tail(dimker);
+    for(Index i = rank(); i < cols; ++i) dst.row(dec().permutationQ().indices().coeff(i)).setZero();
+    for(Index k = 0; k < dimker; ++k) dst.coeffRef(dec().permutationQ().indices().coeff(rank()+k), k) = Scalar(1);
+  }
+};
+
+/***** Implementation of image() *****************************************************/
+
+template<typename _MatrixType>
+struct image_retval<FullPivLU<_MatrixType> >
+  : image_retval_base<FullPivLU<_MatrixType> >
+{
+  EIGEN_MAKE_IMAGE_HELPERS(FullPivLU<_MatrixType>)
+
+  enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(
+            MatrixType::MaxColsAtCompileTime,
+            MatrixType::MaxRowsAtCompileTime)
+  };
+
+  template<typename Dest> void evalTo(Dest& dst) const
+  {
+    using std::abs;
+    if(rank() == 0)
+    {
+      // The Image is just {0}, so it doesn't have a basis properly speaking, but let's
+      // avoid crashing/asserting as that depends on floating point calculations. Let's
+      // just return a single column vector filled with zeros.
+      dst.setZero();
+      return;
+    }
+
+    Matrix<Index, Dynamic, 1, 0, MaxSmallDimAtCompileTime, 1> pivots(rank());
+    RealScalar premultiplied_threshold = dec().maxPivot() * dec().threshold();
+    Index p = 0;
+    for(Index i = 0; i < dec().nonzeroPivots(); ++i)
+      if(abs(dec().matrixLU().coeff(i,i)) > premultiplied_threshold)
+        pivots.coeffRef(p++) = i;
+    eigen_internal_assert(p == rank());
+
+    for(Index i = 0; i < rank(); ++i)
+      dst.col(i) = originalMatrix().col(dec().permutationQ().indices().coeff(pivots.coeff(i)));
+  }
+};
+
+/***** Implementation of solve() *****************************************************/
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void FullPivLU<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  /* The decomposition PAQ = LU can be rewritten as A = P^{-1} L U Q^{-1}.
+  * So we proceed as follows:
+  * Step 1: compute c = P * rhs.
+  * Step 2: replace c by the solution x to Lx = c. Exists because L is invertible.
+  * Step 3: replace c by the solution x to Ux = c. May or may not exist.
+  * Step 4: result = Q * c;
+  */
+
+  const Index rows = this->rows(),
+              cols = this->cols(),
+              nonzero_pivots = this->rank();
+  const Index smalldim = (std::min)(rows, cols);
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs.rows(), rhs.cols());
+
+  // Step 1
+  c = permutationP() * rhs;
+
+  // Step 2
+  m_lu.topLeftCorner(smalldim,smalldim)
+      .template triangularView<UnitLower>()
+      .solveInPlace(c.topRows(smalldim));
+  if(rows>cols)
+    c.bottomRows(rows-cols) -= m_lu.bottomRows(rows-cols) * c.topRows(cols);
+
+  // Step 3
+  m_lu.topLeftCorner(nonzero_pivots, nonzero_pivots)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(nonzero_pivots));
+
+  // Step 4
+  for(Index i = 0; i < nonzero_pivots; ++i)
+    dst.row(permutationQ().indices().coeff(i)) = c.row(i);
+  for(Index i = nonzero_pivots; i < m_lu.cols(); ++i)
+    dst.row(permutationQ().indices().coeff(i)).setZero();
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void FullPivLU<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  /* The decomposition PAQ = LU can be rewritten as A = P^{-1} L U Q^{-1},
+   * and since permutations are real and unitary, we can write this
+   * as   A^T = Q U^T L^T P,
+   * So we proceed as follows:
+   * Step 1: compute c = Q^T rhs.
+   * Step 2: replace c by the solution x to U^T x = c. May or may not exist.
+   * Step 3: replace c by the solution x to L^T x = c.
+   * Step 4: result = P^T c.
+   * If Conjugate is true, replace "^T" by "^*" above.
+   */
+
+  const Index rows = this->rows(), cols = this->cols(),
+    nonzero_pivots = this->rank();
+  const Index smalldim = (std::min)(rows, cols);
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs.rows(), rhs.cols());
+
+  // Step 1
+  c = permutationQ().inverse() * rhs;
+
+  // Step 2
+  m_lu.topLeftCorner(nonzero_pivots, nonzero_pivots)
+      .template triangularView<Upper>()
+      .transpose()
+      .template conjugateIf<Conjugate>()
+      .solveInPlace(c.topRows(nonzero_pivots));
+
+  // Step 3
+  m_lu.topLeftCorner(smalldim, smalldim)
+      .template triangularView<UnitLower>()
+      .transpose()
+      .template conjugateIf<Conjugate>()
+      .solveInPlace(c.topRows(smalldim));
+
+  // Step 4
+  PermutationPType invp = permutationP().inverse().eval();
+  for(Index i = 0; i < smalldim; ++i)
+    dst.row(invp.indices().coeff(i)) = c.row(i);
+  for(Index i = smalldim; i < rows; ++i)
+    dst.row(invp.indices().coeff(i)).setZero();
+}
+
+#endif
+
+namespace internal {
+
+
+/***** Implementation of inverse() *****************************************************/
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<FullPivLU<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename FullPivLU<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef FullPivLU<MatrixType> LuType;
+  typedef Inverse<LuType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename MatrixType::Scalar> &)
+  {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+} // end namespace internal
+
+/******* MatrixBase methods *****************************************************************/
+
+/** \lu_module
+  *
+  * \return the full-pivoting LU decomposition of \c *this.
+  *
+  * \sa class FullPivLU
+  */
+template<typename Derived>
+inline const FullPivLU<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::fullPivLu() const
+{
+  return FullPivLU<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_LU_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/LU/InverseImpl.h b/C++/yolo_bytetrack_old/include/Eigen/src/LU/InverseImpl.h
new file mode 100644
index 00000000..a40cefa9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/LU/InverseImpl.h
@@ -0,0 +1,432 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_INVERSE_IMPL_H
+#define EIGEN_INVERSE_IMPL_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/**********************************
+*** General case implementation ***
+**********************************/
+
+template<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime>
+struct compute_inverse
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    result = matrix.partialPivLu().inverse();
+  }
+};
+
+template<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime>
+struct compute_inverse_and_det_with_check { /* nothing! general case not supported. */ };
+
+/****************************
+*** Size 1 implementation ***
+****************************/
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    typedef typename MatrixType::Scalar Scalar;
+    internal::evaluator<MatrixType> matrixEval(matrix);
+    result.coeffRef(0,0) = Scalar(1) / matrixEval.coeff(0,0);
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 1>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& result,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    using std::abs;
+    determinant = matrix.coeff(0,0);
+    invertible = abs(determinant) > absDeterminantThreshold;
+    if(invertible) result.coeffRef(0,0) = typename ResultType::Scalar(1) / determinant;
+  }
+};
+
+/****************************
+*** Size 2 implementation ***
+****************************/
+
+template<typename MatrixType, typename ResultType>
+EIGEN_DEVICE_FUNC 
+inline void compute_inverse_size2_helper(
+    const MatrixType& matrix, const typename ResultType::Scalar& invdet,
+    ResultType& result)
+{
+  typename ResultType::Scalar temp = matrix.coeff(0,0);
+  result.coeffRef(0,0) =  matrix.coeff(1,1) * invdet;
+  result.coeffRef(1,0) = -matrix.coeff(1,0) * invdet;
+  result.coeffRef(0,1) = -matrix.coeff(0,1) * invdet;
+  result.coeffRef(1,1) =  temp * invdet;
+}
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 2>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    typedef typename ResultType::Scalar Scalar;
+    const Scalar invdet = typename MatrixType::Scalar(1) / matrix.determinant();
+    compute_inverse_size2_helper(matrix, invdet, result);
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 2>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    using std::abs;
+    typedef typename ResultType::Scalar Scalar;
+    determinant = matrix.determinant();
+    invertible = abs(determinant) > absDeterminantThreshold;
+    if(!invertible) return;
+    const Scalar invdet = Scalar(1) / determinant;
+    compute_inverse_size2_helper(matrix, invdet, inverse);
+  }
+};
+
+/****************************
+*** Size 3 implementation ***
+****************************/
+
+template<typename MatrixType, int i, int j>
+EIGEN_DEVICE_FUNC 
+inline typename MatrixType::Scalar cofactor_3x3(const MatrixType& m)
+{
+  enum {
+    i1 = (i+1) % 3,
+    i2 = (i+2) % 3,
+    j1 = (j+1) % 3,
+    j2 = (j+2) % 3
+  };
+  return m.coeff(i1, j1) * m.coeff(i2, j2)
+       - m.coeff(i1, j2) * m.coeff(i2, j1);
+}
+
+template<typename MatrixType, typename ResultType>
+EIGEN_DEVICE_FUNC
+inline void compute_inverse_size3_helper(
+    const MatrixType& matrix,
+    const typename ResultType::Scalar& invdet,
+    const Matrix<typename ResultType::Scalar,3,1>& cofactors_col0,
+    ResultType& result)
+{
+  // Compute cofactors in a way that avoids aliasing issues.
+  typedef typename ResultType::Scalar Scalar;
+  const Scalar c01 = cofactor_3x3<MatrixType,0,1>(matrix) * invdet;
+  const Scalar c11 = cofactor_3x3<MatrixType,1,1>(matrix) * invdet;
+  const Scalar c02 = cofactor_3x3<MatrixType,0,2>(matrix) * invdet;
+  result.coeffRef(1,2) =  cofactor_3x3<MatrixType,2,1>(matrix) * invdet;
+  result.coeffRef(2,1) =  cofactor_3x3<MatrixType,1,2>(matrix) * invdet;
+  result.coeffRef(2,2) =  cofactor_3x3<MatrixType,2,2>(matrix) * invdet;
+  result.coeffRef(1,0) =  c01;
+  result.coeffRef(1,1) =  c11;
+  result.coeffRef(2,0) =  c02;  
+  result.row(0) = cofactors_col0 * invdet;
+}
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 3>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(const MatrixType& matrix, ResultType& result)
+  {
+    typedef typename ResultType::Scalar Scalar;
+    Matrix<typename MatrixType::Scalar,3,1> cofactors_col0;
+    cofactors_col0.coeffRef(0) =  cofactor_3x3<MatrixType,0,0>(matrix);
+    cofactors_col0.coeffRef(1) =  cofactor_3x3<MatrixType,1,0>(matrix);
+    cofactors_col0.coeffRef(2) =  cofactor_3x3<MatrixType,2,0>(matrix);
+    const Scalar det = (cofactors_col0.cwiseProduct(matrix.col(0))).sum();
+    const Scalar invdet = Scalar(1) / det;
+    compute_inverse_size3_helper(matrix, invdet, cofactors_col0, result);
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 3>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    typedef typename ResultType::Scalar Scalar;
+    Matrix<Scalar,3,1> cofactors_col0;
+    cofactors_col0.coeffRef(0) =  cofactor_3x3<MatrixType,0,0>(matrix);
+    cofactors_col0.coeffRef(1) =  cofactor_3x3<MatrixType,1,0>(matrix);
+    cofactors_col0.coeffRef(2) =  cofactor_3x3<MatrixType,2,0>(matrix);
+    determinant = (cofactors_col0.cwiseProduct(matrix.col(0))).sum();
+    invertible = Eigen::numext::abs(determinant) > absDeterminantThreshold;
+    if(!invertible) return;
+    const Scalar invdet = Scalar(1) / determinant;
+    compute_inverse_size3_helper(matrix, invdet, cofactors_col0, inverse);
+  }
+};
+
+/****************************
+*** Size 4 implementation ***
+****************************/
+
+template<typename Derived>
+EIGEN_DEVICE_FUNC 
+inline const typename Derived::Scalar general_det3_helper
+(const MatrixBase<Derived>& matrix, int i1, int i2, int i3, int j1, int j2, int j3)
+{
+  return matrix.coeff(i1,j1)
+         * (matrix.coeff(i2,j2) * matrix.coeff(i3,j3) - matrix.coeff(i2,j3) * matrix.coeff(i3,j2));
+}
+
+template<typename MatrixType, int i, int j>
+EIGEN_DEVICE_FUNC 
+inline typename MatrixType::Scalar cofactor_4x4(const MatrixType& matrix)
+{
+  enum {
+    i1 = (i+1) % 4,
+    i2 = (i+2) % 4,
+    i3 = (i+3) % 4,
+    j1 = (j+1) % 4,
+    j2 = (j+2) % 4,
+    j3 = (j+3) % 4
+  };
+  return general_det3_helper(matrix, i1, i2, i3, j1, j2, j3)
+       + general_det3_helper(matrix, i2, i3, i1, j1, j2, j3)
+       + general_det3_helper(matrix, i3, i1, i2, j1, j2, j3);
+}
+
+template<int Arch, typename Scalar, typename MatrixType, typename ResultType>
+struct compute_inverse_size4
+{
+  EIGEN_DEVICE_FUNC
+  static void run(const MatrixType& matrix, ResultType& result)
+  {
+    result.coeffRef(0,0) =  cofactor_4x4<MatrixType,0,0>(matrix);
+    result.coeffRef(1,0) = -cofactor_4x4<MatrixType,0,1>(matrix);
+    result.coeffRef(2,0) =  cofactor_4x4<MatrixType,0,2>(matrix);
+    result.coeffRef(3,0) = -cofactor_4x4<MatrixType,0,3>(matrix);
+    result.coeffRef(0,2) =  cofactor_4x4<MatrixType,2,0>(matrix);
+    result.coeffRef(1,2) = -cofactor_4x4<MatrixType,2,1>(matrix);
+    result.coeffRef(2,2) =  cofactor_4x4<MatrixType,2,2>(matrix);
+    result.coeffRef(3,2) = -cofactor_4x4<MatrixType,2,3>(matrix);
+    result.coeffRef(0,1) = -cofactor_4x4<MatrixType,1,0>(matrix);
+    result.coeffRef(1,1) =  cofactor_4x4<MatrixType,1,1>(matrix);
+    result.coeffRef(2,1) = -cofactor_4x4<MatrixType,1,2>(matrix);
+    result.coeffRef(3,1) =  cofactor_4x4<MatrixType,1,3>(matrix);
+    result.coeffRef(0,3) = -cofactor_4x4<MatrixType,3,0>(matrix);
+    result.coeffRef(1,3) =  cofactor_4x4<MatrixType,3,1>(matrix);
+    result.coeffRef(2,3) = -cofactor_4x4<MatrixType,3,2>(matrix);
+    result.coeffRef(3,3) =  cofactor_4x4<MatrixType,3,3>(matrix);
+    result /= (matrix.col(0).cwiseProduct(result.row(0).transpose())).sum();
+  }
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse<MatrixType, ResultType, 4>
+ : compute_inverse_size4<Architecture::Target, typename MatrixType::Scalar,
+                            MatrixType, ResultType>
+{
+};
+
+template<typename MatrixType, typename ResultType>
+struct compute_inverse_and_det_with_check<MatrixType, ResultType, 4>
+{
+  EIGEN_DEVICE_FUNC
+  static inline void run(
+    const MatrixType& matrix,
+    const typename MatrixType::RealScalar& absDeterminantThreshold,
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible
+  )
+  {
+    using std::abs;
+    determinant = matrix.determinant();
+    invertible = abs(determinant) > absDeterminantThreshold;
+    if(invertible && extract_data(matrix) != extract_data(inverse)) {
+      compute_inverse<MatrixType, ResultType>::run(matrix, inverse);
+    }
+    else if(invertible) {
+      MatrixType matrix_t = matrix;
+      compute_inverse<MatrixType, ResultType>::run(matrix_t, inverse);
+    }
+  }
+};
+
+/*************************
+*** MatrixBase methods ***
+*************************/
+
+} // end namespace internal
+
+namespace internal {
+
+// Specialization for "dense = dense_xpr.inverse()"
+template<typename DstXprType, typename XprType>
+struct Assignment<DstXprType, Inverse<XprType>, internal::assign_op<typename DstXprType::Scalar,typename XprType::Scalar>, Dense2Dense>
+{
+  typedef Inverse<XprType> SrcXprType;
+  EIGEN_DEVICE_FUNC
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename XprType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    
+    const int Size = EIGEN_PLAIN_ENUM_MIN(XprType::ColsAtCompileTime,DstXprType::ColsAtCompileTime);
+    EIGEN_ONLY_USED_FOR_DEBUG(Size);
+    eigen_assert(( (Size<=1) || (Size>4) || (extract_data(src.nestedExpression())!=extract_data(dst)))
+              && "Aliasing problem detected in inverse(), you need to do inverse().eval() here.");
+
+    typedef typename internal::nested_eval<XprType,XprType::ColsAtCompileTime>::type  ActualXprType;
+    typedef typename internal::remove_all<ActualXprType>::type                        ActualXprTypeCleanded;
+    
+    ActualXprType actual_xpr(src.nestedExpression());
+    
+    compute_inverse<ActualXprTypeCleanded, DstXprType>::run(actual_xpr, dst);
+  }
+};
+
+  
+} // end namespace internal
+
+/** \lu_module
+  *
+  * \returns the matrix inverse of this matrix.
+  *
+  * For small fixed sizes up to 4x4, this method uses cofactors.
+  * In the general case, this method uses class PartialPivLU.
+  *
+  * \note This matrix must be invertible, otherwise the result is undefined. If you need an
+  * invertibility check, do the following:
+  * \li for fixed sizes up to 4x4, use computeInverseAndDetWithCheck().
+  * \li for the general case, use class FullPivLU.
+  *
+  * Example: \include MatrixBase_inverse.cpp
+  * Output: \verbinclude MatrixBase_inverse.out
+  *
+  * \sa computeInverseAndDetWithCheck()
+  */
+template<typename Derived>
+EIGEN_DEVICE_FUNC
+inline const Inverse<Derived> MatrixBase<Derived>::inverse() const
+{
+  EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsInteger,THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES)
+  eigen_assert(rows() == cols());
+  return Inverse<Derived>(derived());
+}
+
+/** \lu_module
+  *
+  * Computation of matrix inverse and determinant, with invertibility check.
+  *
+  * This is only for fixed-size square matrices of size up to 4x4.
+  *
+  * Notice that it will trigger a copy of input matrix when trying to do the inverse in place.
+  *
+  * \param inverse Reference to the matrix in which to store the inverse.
+  * \param determinant Reference to the variable in which to store the determinant.
+  * \param invertible Reference to the bool variable in which to store whether the matrix is invertible.
+  * \param absDeterminantThreshold Optional parameter controlling the invertibility check.
+  *                                The matrix will be declared invertible if the absolute value of its
+  *                                determinant is greater than this threshold.
+  *
+  * Example: \include MatrixBase_computeInverseAndDetWithCheck.cpp
+  * Output: \verbinclude MatrixBase_computeInverseAndDetWithCheck.out
+  *
+  * \sa inverse(), computeInverseWithCheck()
+  */
+template<typename Derived>
+template<typename ResultType>
+inline void MatrixBase<Derived>::computeInverseAndDetWithCheck(
+    ResultType& inverse,
+    typename ResultType::Scalar& determinant,
+    bool& invertible,
+    const RealScalar& absDeterminantThreshold
+  ) const
+{
+  // i'd love to put some static assertions there, but SFINAE means that they have no effect...
+  eigen_assert(rows() == cols());
+  // for 2x2, it's worth giving a chance to avoid evaluating.
+  // for larger sizes, evaluating has negligible cost and limits code size.
+  typedef typename internal::conditional<
+    RowsAtCompileTime == 2,
+    typename internal::remove_all<typename internal::nested_eval<Derived, 2>::type>::type,
+    PlainObject
+  >::type MatrixType;
+  internal::compute_inverse_and_det_with_check<MatrixType, ResultType>::run
+    (derived(), absDeterminantThreshold, inverse, determinant, invertible);
+}
+
+/** \lu_module
+  *
+  * Computation of matrix inverse, with invertibility check.
+  *
+  * This is only for fixed-size square matrices of size up to 4x4.
+  *
+  * Notice that it will trigger a copy of input matrix when trying to do the inverse in place.
+  *
+  * \param inverse Reference to the matrix in which to store the inverse.
+  * \param invertible Reference to the bool variable in which to store whether the matrix is invertible.
+  * \param absDeterminantThreshold Optional parameter controlling the invertibility check.
+  *                                The matrix will be declared invertible if the absolute value of its
+  *                                determinant is greater than this threshold.
+  *
+  * Example: \include MatrixBase_computeInverseWithCheck.cpp
+  * Output: \verbinclude MatrixBase_computeInverseWithCheck.out
+  *
+  * \sa inverse(), computeInverseAndDetWithCheck()
+  */
+template<typename Derived>
+template<typename ResultType>
+inline void MatrixBase<Derived>::computeInverseWithCheck(
+    ResultType& inverse,
+    bool& invertible,
+    const RealScalar& absDeterminantThreshold
+  ) const
+{
+  Scalar determinant;
+  // i'd love to put some static assertions there, but SFINAE means that they have no effect...
+  eigen_assert(rows() == cols());
+  computeInverseAndDetWithCheck(inverse,determinant,invertible,absDeterminantThreshold);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_INVERSE_IMPL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/LU/PartialPivLU.h b/C++/yolo_bytetrack_old/include/Eigen/src/LU/PartialPivLU.h
new file mode 100644
index 00000000..34aed724
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/LU/PartialPivLU.h
@@ -0,0 +1,624 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARTIALLU_H
+#define EIGEN_PARTIALLU_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _MatrixType> struct traits<PartialPivLU<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  typedef traits<_MatrixType> BaseTraits;
+  enum {
+    Flags = BaseTraits::Flags & RowMajorBit,
+    CoeffReadCost = Dynamic
+  };
+};
+
+template<typename T,typename Derived>
+struct enable_if_ref;
+// {
+//   typedef Derived type;
+// };
+
+template<typename T,typename Derived>
+struct enable_if_ref<Ref<T>,Derived> {
+  typedef Derived type;
+};
+
+} // end namespace internal
+
+/** \ingroup LU_Module
+  *
+  * \class PartialPivLU
+  *
+  * \brief LU decomposition of a matrix with partial pivoting, and related features
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the LU decomposition
+  *
+  * This class represents a LU decomposition of a \b square \b invertible matrix, with partial pivoting: the matrix A
+  * is decomposed as A = PLU where L is unit-lower-triangular, U is upper-triangular, and P
+  * is a permutation matrix.
+  *
+  * Typically, partial pivoting LU decomposition is only considered numerically stable for square invertible
+  * matrices. Thus LAPACK's dgesv and dgesvx require the matrix to be square and invertible. The present class
+  * does the same. It will assert that the matrix is square, but it won't (actually it can't) check that the
+  * matrix is invertible: it is your task to check that you only use this decomposition on invertible matrices.
+  *
+  * The guaranteed safe alternative, working for all matrices, is the full pivoting LU decomposition, provided
+  * by class FullPivLU.
+  *
+  * This is \b not a rank-revealing LU decomposition. Many features are intentionally absent from this class,
+  * such as rank computation. If you need these features, use class FullPivLU.
+  *
+  * This LU decomposition is suitable to invert invertible matrices. It is what MatrixBase::inverse() uses
+  * in the general case.
+  * On the other hand, it is \b not suitable to determine whether a given matrix is invertible.
+  *
+  * The data of the LU decomposition can be directly accessed through the methods matrixLU(), permutationP().
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * \sa MatrixBase::partialPivLu(), MatrixBase::determinant(), MatrixBase::inverse(), MatrixBase::computeInverse(), class FullPivLU
+  */
+template<typename _MatrixType> class PartialPivLU
+  : public SolverBase<PartialPivLU<_MatrixType> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<PartialPivLU> Base;
+    friend class SolverBase<PartialPivLU>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(PartialPivLU)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType;
+    typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via PartialPivLU::compute(const MatrixType&).
+      */
+    PartialPivLU();
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa PartialPivLU()
+      */
+    explicit PartialPivLU(Index size);
+
+    /** Constructor.
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *
+      * \warning The matrix should have full rank (e.g. if it's square, it should be invertible).
+      * If you need to deal with non-full rank, use class FullPivLU instead.
+      */
+    template<typename InputType>
+    explicit PartialPivLU(const EigenBase<InputType>& matrix);
+
+    /** Constructor for \link InplaceDecomposition inplace decomposition \endlink
+      *
+      * \param matrix the matrix of which to compute the LU decomposition.
+      *
+      * \warning The matrix should have full rank (e.g. if it's square, it should be invertible).
+      * If you need to deal with non-full rank, use class FullPivLU instead.
+      */
+    template<typename InputType>
+    explicit PartialPivLU(EigenBase<InputType>& matrix);
+
+    template<typename InputType>
+    PartialPivLU& compute(const EigenBase<InputType>& matrix) {
+      m_lu = matrix.derived();
+      compute();
+      return *this;
+    }
+
+    /** \returns the LU decomposition matrix: the upper-triangular part is U, the
+      * unit-lower-triangular part is L (at least for square matrices; in the non-square
+      * case, special care is needed, see the documentation of class FullPivLU).
+      *
+      * \sa matrixL(), matrixU()
+      */
+    inline const MatrixType& matrixLU() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return m_lu;
+    }
+
+    /** \returns the permutation matrix P.
+      */
+    inline const PermutationType& permutationP() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return m_p;
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** This method returns the solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the LU decomposition.
+      *
+      * \param b the right-hand-side of the equation to solve. Can be a vector or a matrix,
+      *          the only requirement in order for the equation to make sense is that
+      *          b.rows()==A.rows(), where A is the matrix of which *this is the LU decomposition.
+      *
+      * \returns the solution.
+      *
+      * Example: \include PartialPivLU_solve.cpp
+      * Output: \verbinclude PartialPivLU_solve.out
+      *
+      * Since this PartialPivLU class assumes anyway that the matrix A is invertible, the solution
+      * theoretically exists and is unique regardless of b.
+      *
+      * \sa TriangularView::solve(), inverse(), computeInverse()
+      */
+    template<typename Rhs>
+    inline const Solve<PartialPivLU, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    /** \returns an estimate of the reciprocal condition number of the matrix of which \c *this is
+        the LU decomposition.
+      */
+    inline RealScalar rcond() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return internal::rcond_estimate_helper(m_l1_norm, *this);
+    }
+
+    /** \returns the inverse of the matrix of which *this is the LU decomposition.
+      *
+      * \warning The matrix being decomposed here is assumed to be invertible. If you need to check for
+      *          invertibility, use class FullPivLU instead.
+      *
+      * \sa MatrixBase::inverse(), LU::inverse()
+      */
+    inline const Inverse<PartialPivLU> inverse() const
+    {
+      eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+      return Inverse<PartialPivLU>(*this);
+    }
+
+    /** \returns the determinant of the matrix of which
+      * *this is the LU decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the LU decomposition has already been computed.
+      *
+      * \note For fixed-size matrices of size up to 4, MatrixBase::determinant() offers
+      *       optimized paths.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      *
+      * \sa MatrixBase::determinant()
+      */
+    Scalar determinant() const;
+
+    MatrixType reconstructedMatrix() const;
+
+    EIGEN_CONSTEXPR inline Index rows() const EIGEN_NOEXCEPT { return m_lu.rows(); }
+    EIGEN_CONSTEXPR inline Index cols() const EIGEN_NOEXCEPT { return m_lu.cols(); }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    void _solve_impl(const RhsType &rhs, DstType &dst) const {
+     /* The decomposition PA = LU can be rewritten as A = P^{-1} L U.
+      * So we proceed as follows:
+      * Step 1: compute c = Pb.
+      * Step 2: replace c by the solution x to Lx = c.
+      * Step 3: replace c by the solution x to Ux = c.
+      */
+
+      // Step 1
+      dst = permutationP() * rhs;
+
+      // Step 2
+      m_lu.template triangularView<UnitLower>().solveInPlace(dst);
+
+      // Step 3
+      m_lu.template triangularView<Upper>().solveInPlace(dst);
+    }
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const {
+     /* The decomposition PA = LU can be rewritten as A^T = U^T L^T P.
+      * So we proceed as follows:
+      * Step 1: compute c as the solution to L^T c = b
+      * Step 2: replace c by the solution x to U^T x = c.
+      * Step 3: update  c = P^-1 c.
+      */
+
+      eigen_assert(rhs.rows() == m_lu.cols());
+
+      // Step 1
+      dst = m_lu.template triangularView<Upper>().transpose()
+                .template conjugateIf<Conjugate>().solve(rhs);
+      // Step 2
+      m_lu.template triangularView<UnitLower>().transpose()
+          .template conjugateIf<Conjugate>().solveInPlace(dst);
+      // Step 3
+      dst = permutationP().transpose() * dst;
+    }
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void compute();
+
+    MatrixType m_lu;
+    PermutationType m_p;
+    TranspositionType m_rowsTranspositions;
+    RealScalar m_l1_norm;
+    signed char m_det_p;
+    bool m_isInitialized;
+};
+
+template<typename MatrixType>
+PartialPivLU<MatrixType>::PartialPivLU()
+  : m_lu(),
+    m_p(),
+    m_rowsTranspositions(),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+}
+
+template<typename MatrixType>
+PartialPivLU<MatrixType>::PartialPivLU(Index size)
+  : m_lu(size, size),
+    m_p(size),
+    m_rowsTranspositions(size),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+}
+
+template<typename MatrixType>
+template<typename InputType>
+PartialPivLU<MatrixType>::PartialPivLU(const EigenBase<InputType>& matrix)
+  : m_lu(matrix.rows(),matrix.cols()),
+    m_p(matrix.rows()),
+    m_rowsTranspositions(matrix.rows()),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+  compute(matrix.derived());
+}
+
+template<typename MatrixType>
+template<typename InputType>
+PartialPivLU<MatrixType>::PartialPivLU(EigenBase<InputType>& matrix)
+  : m_lu(matrix.derived()),
+    m_p(matrix.rows()),
+    m_rowsTranspositions(matrix.rows()),
+    m_l1_norm(0),
+    m_det_p(0),
+    m_isInitialized(false)
+{
+  compute();
+}
+
+namespace internal {
+
+/** \internal This is the blocked version of fullpivlu_unblocked() */
+template<typename Scalar, int StorageOrder, typename PivIndex, int SizeAtCompileTime=Dynamic>
+struct partial_lu_impl
+{
+  static const int UnBlockedBound = 16;
+  static const bool UnBlockedAtCompileTime = SizeAtCompileTime!=Dynamic && SizeAtCompileTime<=UnBlockedBound;
+  static const int ActualSizeAtCompileTime = UnBlockedAtCompileTime ? SizeAtCompileTime : Dynamic;
+  // Remaining rows and columns at compile-time:
+  static const int RRows = SizeAtCompileTime==2 ? 1 : Dynamic;
+  static const int RCols = SizeAtCompileTime==2 ? 1 : Dynamic;
+  typedef Matrix<Scalar, ActualSizeAtCompileTime, ActualSizeAtCompileTime, StorageOrder> MatrixType;
+  typedef Ref<MatrixType> MatrixTypeRef;
+  typedef Ref<Matrix<Scalar, Dynamic, Dynamic, StorageOrder> > BlockType;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  /** \internal performs the LU decomposition in-place of the matrix \a lu
+    * using an unblocked algorithm.
+    *
+    * In addition, this function returns the row transpositions in the
+    * vector \a row_transpositions which must have a size equal to the number
+    * of columns of the matrix \a lu, and an integer \a nb_transpositions
+    * which returns the actual number of transpositions.
+    *
+    * \returns The index of the first pivot which is exactly zero if any, or a negative number otherwise.
+    */
+  static Index unblocked_lu(MatrixTypeRef& lu, PivIndex* row_transpositions, PivIndex& nb_transpositions)
+  {
+    typedef scalar_score_coeff_op<Scalar> Scoring;
+    typedef typename Scoring::result_type Score;
+    const Index rows = lu.rows();
+    const Index cols = lu.cols();
+    const Index size = (std::min)(rows,cols);
+    // For small compile-time matrices it is worth processing the last row separately:
+    //  speedup: +100% for 2x2, +10% for others.
+    const Index endk = UnBlockedAtCompileTime ? size-1 : size;
+    nb_transpositions = 0;
+    Index first_zero_pivot = -1;
+    for(Index k = 0; k < endk; ++k)
+    {
+      int rrows = internal::convert_index<int>(rows-k-1);
+      int rcols = internal::convert_index<int>(cols-k-1);
+
+      Index row_of_biggest_in_col;
+      Score biggest_in_corner
+        = lu.col(k).tail(rows-k).unaryExpr(Scoring()).maxCoeff(&row_of_biggest_in_col);
+      row_of_biggest_in_col += k;
+
+      row_transpositions[k] = PivIndex(row_of_biggest_in_col);
+
+      if(biggest_in_corner != Score(0))
+      {
+        if(k != row_of_biggest_in_col)
+        {
+          lu.row(k).swap(lu.row(row_of_biggest_in_col));
+          ++nb_transpositions;
+        }
+
+        lu.col(k).tail(fix<RRows>(rrows)) /= lu.coeff(k,k);
+      }
+      else if(first_zero_pivot==-1)
+      {
+        // the pivot is exactly zero, we record the index of the first pivot which is exactly 0,
+        // and continue the factorization such we still have A = PLU
+        first_zero_pivot = k;
+      }
+
+      if(k<rows-1)
+        lu.bottomRightCorner(fix<RRows>(rrows),fix<RCols>(rcols)).noalias() -= lu.col(k).tail(fix<RRows>(rrows)) * lu.row(k).tail(fix<RCols>(rcols));
+    }
+
+    // special handling of the last entry
+    if(UnBlockedAtCompileTime)
+    {
+      Index k = endk;
+      row_transpositions[k] = PivIndex(k);
+      if (Scoring()(lu(k, k)) == Score(0) && first_zero_pivot == -1)
+        first_zero_pivot = k;
+    }
+
+    return first_zero_pivot;
+  }
+
+  /** \internal performs the LU decomposition in-place of the matrix represented
+    * by the variables \a rows, \a cols, \a lu_data, and \a lu_stride using a
+    * recursive, blocked algorithm.
+    *
+    * In addition, this function returns the row transpositions in the
+    * vector \a row_transpositions which must have a size equal to the number
+    * of columns of the matrix \a lu, and an integer \a nb_transpositions
+    * which returns the actual number of transpositions.
+    *
+    * \returns The index of the first pivot which is exactly zero if any, or a negative number otherwise.
+    *
+    * \note This very low level interface using pointers, etc. is to:
+    *   1 - reduce the number of instantiations to the strict minimum
+    *   2 - avoid infinite recursion of the instantiations with Block<Block<Block<...> > >
+    */
+  static Index blocked_lu(Index rows, Index cols, Scalar* lu_data, Index luStride, PivIndex* row_transpositions, PivIndex& nb_transpositions, Index maxBlockSize=256)
+  {
+    MatrixTypeRef lu = MatrixType::Map(lu_data,rows, cols, OuterStride<>(luStride));
+
+    const Index size = (std::min)(rows,cols);
+
+    // if the matrix is too small, no blocking:
+    if(UnBlockedAtCompileTime || size<=UnBlockedBound)
+    {
+      return unblocked_lu(lu, row_transpositions, nb_transpositions);
+    }
+
+    // automatically adjust the number of subdivisions to the size
+    // of the matrix so that there is enough sub blocks:
+    Index blockSize;
+    {
+      blockSize = size/8;
+      blockSize = (blockSize/16)*16;
+      blockSize = (std::min)((std::max)(blockSize,Index(8)), maxBlockSize);
+    }
+
+    nb_transpositions = 0;
+    Index first_zero_pivot = -1;
+    for(Index k = 0; k < size; k+=blockSize)
+    {
+      Index bs = (std::min)(size-k,blockSize); // actual size of the block
+      Index trows = rows - k - bs; // trailing rows
+      Index tsize = size - k - bs; // trailing size
+
+      // partition the matrix:
+      //                          A00 | A01 | A02
+      // lu  = A_0 | A_1 | A_2 =  A10 | A11 | A12
+      //                          A20 | A21 | A22
+      BlockType A_0 = lu.block(0,0,rows,k);
+      BlockType A_2 = lu.block(0,k+bs,rows,tsize);
+      BlockType A11 = lu.block(k,k,bs,bs);
+      BlockType A12 = lu.block(k,k+bs,bs,tsize);
+      BlockType A21 = lu.block(k+bs,k,trows,bs);
+      BlockType A22 = lu.block(k+bs,k+bs,trows,tsize);
+
+      PivIndex nb_transpositions_in_panel;
+      // recursively call the blocked LU algorithm on [A11^T A21^T]^T
+      // with a very small blocking size:
+      Index ret = blocked_lu(trows+bs, bs, &lu.coeffRef(k,k), luStride,
+                   row_transpositions+k, nb_transpositions_in_panel, 16);
+      if(ret>=0 && first_zero_pivot==-1)
+        first_zero_pivot = k+ret;
+
+      nb_transpositions += nb_transpositions_in_panel;
+      // update permutations and apply them to A_0
+      for(Index i=k; i<k+bs; ++i)
+      {
+        Index piv = (row_transpositions[i] += internal::convert_index<PivIndex>(k));
+        A_0.row(i).swap(A_0.row(piv));
+      }
+
+      if(trows)
+      {
+        // apply permutations to A_2
+        for(Index i=k;i<k+bs; ++i)
+          A_2.row(i).swap(A_2.row(row_transpositions[i]));
+
+        // A12 = A11^-1 A12
+        A11.template triangularView<UnitLower>().solveInPlace(A12);
+
+        A22.noalias() -= A21 * A12;
+      }
+    }
+    return first_zero_pivot;
+  }
+};
+
+/** \internal performs the LU decomposition with partial pivoting in-place.
+  */
+template<typename MatrixType, typename TranspositionType>
+void partial_lu_inplace(MatrixType& lu, TranspositionType& row_transpositions, typename TranspositionType::StorageIndex& nb_transpositions)
+{
+  // Special-case of zero matrix.
+  if (lu.rows() == 0 || lu.cols() == 0) {
+    nb_transpositions = 0;
+    return;
+  }
+  eigen_assert(lu.cols() == row_transpositions.size());
+  eigen_assert(row_transpositions.size() < 2 || (&row_transpositions.coeffRef(1)-&row_transpositions.coeffRef(0)) == 1);
+
+  partial_lu_impl
+    < typename MatrixType::Scalar, MatrixType::Flags&RowMajorBit?RowMajor:ColMajor,
+      typename TranspositionType::StorageIndex,
+      EIGEN_SIZE_MIN_PREFER_FIXED(MatrixType::RowsAtCompileTime,MatrixType::ColsAtCompileTime)>
+    ::blocked_lu(lu.rows(), lu.cols(), &lu.coeffRef(0,0), lu.outerStride(), &row_transpositions.coeffRef(0), nb_transpositions);
+}
+
+} // end namespace internal
+
+template<typename MatrixType>
+void PartialPivLU<MatrixType>::compute()
+{
+  check_template_parameters();
+
+  // the row permutation is stored as int indices, so just to be sure:
+  eigen_assert(m_lu.rows()<NumTraits<int>::highest());
+
+  if(m_lu.cols()>0)
+    m_l1_norm = m_lu.cwiseAbs().colwise().sum().maxCoeff();
+  else
+    m_l1_norm = RealScalar(0);
+
+  eigen_assert(m_lu.rows() == m_lu.cols() && "PartialPivLU is only for square (and moreover invertible) matrices");
+  const Index size = m_lu.rows();
+
+  m_rowsTranspositions.resize(size);
+
+  typename TranspositionType::StorageIndex nb_transpositions;
+  internal::partial_lu_inplace(m_lu, m_rowsTranspositions, nb_transpositions);
+  m_det_p = (nb_transpositions%2) ? -1 : 1;
+
+  m_p = m_rowsTranspositions;
+
+  m_isInitialized = true;
+}
+
+template<typename MatrixType>
+typename PartialPivLU<MatrixType>::Scalar PartialPivLU<MatrixType>::determinant() const
+{
+  eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+  return Scalar(m_det_p) * m_lu.diagonal().prod();
+}
+
+/** \returns the matrix represented by the decomposition,
+ * i.e., it returns the product: P^{-1} L U.
+ * This function is provided for debug purpose. */
+template<typename MatrixType>
+MatrixType PartialPivLU<MatrixType>::reconstructedMatrix() const
+{
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  // LU
+  MatrixType res = m_lu.template triangularView<UnitLower>().toDenseMatrix()
+                 * m_lu.template triangularView<Upper>();
+
+  // P^{-1}(LU)
+  res = m_p.inverse() * res;
+
+  return res;
+}
+
+/***** Implementation details *****************************************************/
+
+namespace internal {
+
+/***** Implementation of inverse() *****************************************************/
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<PartialPivLU<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename PartialPivLU<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef PartialPivLU<MatrixType> LuType;
+  typedef Inverse<LuType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename LuType::Scalar> &)
+  {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+} // end namespace internal
+
+/******** MatrixBase methods *******/
+
+/** \lu_module
+  *
+  * \return the partial-pivoting LU decomposition of \c *this.
+  *
+  * \sa class PartialPivLU
+  */
+template<typename Derived>
+inline const PartialPivLU<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::partialPivLu() const
+{
+  return PartialPivLU<PlainObject>(eval());
+}
+
+/** \lu_module
+  *
+  * Synonym of partialPivLu().
+  *
+  * \return the partial-pivoting LU decomposition of \c *this.
+  *
+  * \sa class PartialPivLU
+  */
+template<typename Derived>
+inline const PartialPivLU<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::lu() const
+{
+  return PartialPivLU<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIALLU_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/LU/PartialPivLU_LAPACKE.h b/C++/yolo_bytetrack_old/include/Eigen/src/LU/PartialPivLU_LAPACKE.h
new file mode 100644
index 00000000..755168a9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/LU/PartialPivLU_LAPACKE.h
@@ -0,0 +1,83 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *     LU decomposition with partial pivoting based on LAPACKE_?getrf function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_PARTIALLU_LAPACK_H
+#define EIGEN_PARTIALLU_LAPACK_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_LU_PARTPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX) \
+template<int StorageOrder> \
+struct partial_lu_impl<EIGTYPE, StorageOrder, lapack_int> \
+{ \
+  /* \internal performs the LU decomposition in-place of the matrix represented */ \
+  static lapack_int blocked_lu(Index rows, Index cols, EIGTYPE* lu_data, Index luStride, lapack_int* row_transpositions, lapack_int& nb_transpositions, lapack_int maxBlockSize=256) \
+  { \
+    EIGEN_UNUSED_VARIABLE(maxBlockSize);\
+    lapack_int matrix_order, first_zero_pivot; \
+    lapack_int m, n, lda, *ipiv, info; \
+    EIGTYPE* a; \
+/* Set up parameters for ?getrf */ \
+    matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
+    lda = convert_index<lapack_int>(luStride); \
+    a = lu_data; \
+    ipiv = row_transpositions; \
+    m = convert_index<lapack_int>(rows); \
+    n = convert_index<lapack_int>(cols); \
+    nb_transpositions = 0; \
+\
+    info = LAPACKE_##LAPACKE_PREFIX##getrf( matrix_order, m, n, (LAPACKE_TYPE*)a, lda, ipiv ); \
+\
+    for(int i=0;i<m;i++) { ipiv[i]--; if (ipiv[i]!=i) nb_transpositions++; } \
+\
+    eigen_assert(info >= 0); \
+/* something should be done with nb_transpositions */ \
+\
+    first_zero_pivot = info; \
+    return first_zero_pivot; \
+  } \
+};
+
+EIGEN_LAPACKE_LU_PARTPIV(double, double, d)
+EIGEN_LAPACKE_LU_PARTPIV(float, float, s)
+EIGEN_LAPACKE_LU_PARTPIV(dcomplex, lapack_complex_double, z)
+EIGEN_LAPACKE_LU_PARTPIV(scomplex, lapack_complex_float,  c)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARTIALLU_LAPACK_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/LU/arch/InverseSize4.h b/C++/yolo_bytetrack_old/include/Eigen/src/LU/arch/InverseSize4.h
new file mode 100644
index 00000000..a232ffc0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/LU/arch/InverseSize4.h
@@ -0,0 +1,351 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2001 Intel Corporation
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// The algorithm below is a reimplementation of former \src\LU\Inverse_SSE.h using PacketMath.
+// inv(M) = M#/|M|, where inv(M), M# and |M| denote the inverse of M,
+// adjugate of M and determinant of M respectively. M# is computed block-wise
+// using specific formulae. For proof, see:
+// https://lxjk.github.io/2017/09/03/Fast-4x4-Matrix-Inverse-with-SSE-SIMD-Explained.html
+// Variable names are adopted from \src\LU\Inverse_SSE.h.
+//
+// The SSE code for the 4x4 float and double matrix inverse in former (deprecated) \src\LU\Inverse_SSE.h
+// comes from the following Intel's library:
+// http://software.intel.com/en-us/articles/optimized-matrix-library-for-use-with-the-intel-pentiumr-4-processors-sse2-instructions/
+//
+// Here is the respective copyright and license statement:
+//
+//   Copyright (c) 2001 Intel Corporation.
+//
+// Permition is granted to use, copy, distribute and prepare derivative works
+// of this library for any purpose and without fee, provided, that the above
+// copyright notice and this statement appear in all copies.
+// Intel makes no representations about the suitability of this software for
+// any purpose, and specifically disclaims all warranties.
+// See LEGAL.TXT for all the legal information.
+//
+// TODO: Unify implementations of different data types (i.e. float and double).
+#ifndef EIGEN_INVERSE_SIZE_4_H
+#define EIGEN_INVERSE_SIZE_4_H
+
+namespace Eigen
+{
+namespace internal
+{
+template <typename MatrixType, typename ResultType>
+struct compute_inverse_size4<Architecture::Target, float, MatrixType, ResultType>
+{
+  enum
+  {
+    MatrixAlignment = traits<MatrixType>::Alignment,
+    ResultAlignment = traits<ResultType>::Alignment,
+    StorageOrdersMatch = (MatrixType::Flags & RowMajorBit) == (ResultType::Flags & RowMajorBit)
+  };
+  typedef typename conditional<(MatrixType::Flags & LinearAccessBit), MatrixType const &, typename MatrixType::PlainObject>::type ActualMatrixType;
+
+  static void run(const MatrixType &mat, ResultType &result)
+  {
+    ActualMatrixType matrix(mat);
+
+    const float* data = matrix.data();
+    const Index stride = matrix.innerStride();
+    Packet4f _L1 = ploadt<Packet4f,MatrixAlignment>(data);
+    Packet4f _L2 = ploadt<Packet4f,MatrixAlignment>(data + stride*4);
+    Packet4f _L3 = ploadt<Packet4f,MatrixAlignment>(data + stride*8);
+    Packet4f _L4 = ploadt<Packet4f,MatrixAlignment>(data + stride*12);
+
+    // Four 2x2 sub-matrices of the input matrix
+    // input = [[A, B],
+    //          [C, D]]
+    Packet4f A, B, C, D;
+
+    if (!StorageOrdersMatch)
+    {
+      A = vec4f_unpacklo(_L1, _L2);
+      B = vec4f_unpacklo(_L3, _L4);
+      C = vec4f_unpackhi(_L1, _L2);
+      D = vec4f_unpackhi(_L3, _L4);
+    }
+    else
+    {
+      A = vec4f_movelh(_L1, _L2);
+      B = vec4f_movehl(_L2, _L1);
+      C = vec4f_movelh(_L3, _L4);
+      D = vec4f_movehl(_L4, _L3);
+    }
+
+    Packet4f AB, DC;
+
+    // AB = A# * B, where A# denotes the adjugate of A, and * denotes matrix product.
+    AB = pmul(vec4f_swizzle2(A, A, 3, 3, 0, 0), B);
+    AB = psub(AB, pmul(vec4f_swizzle2(A, A, 1, 1, 2, 2), vec4f_swizzle2(B, B, 2, 3, 0, 1)));
+
+    // DC = D#*C
+    DC = pmul(vec4f_swizzle2(D, D, 3, 3, 0, 0), C);
+    DC = psub(DC, pmul(vec4f_swizzle2(D, D, 1, 1, 2, 2), vec4f_swizzle2(C, C, 2, 3, 0, 1)));
+
+    // determinants of the sub-matrices
+    Packet4f dA, dB, dC, dD;
+
+    dA = pmul(vec4f_swizzle2(A, A, 3, 3, 1, 1), A);
+    dA = psub(dA, vec4f_movehl(dA, dA));
+
+    dB = pmul(vec4f_swizzle2(B, B, 3, 3, 1, 1), B);
+    dB = psub(dB, vec4f_movehl(dB, dB));
+
+    dC = pmul(vec4f_swizzle2(C, C, 3, 3, 1, 1), C);
+    dC = psub(dC, vec4f_movehl(dC, dC));
+
+    dD = pmul(vec4f_swizzle2(D, D, 3, 3, 1, 1), D);
+    dD = psub(dD, vec4f_movehl(dD, dD));
+
+    Packet4f d, d1, d2;
+
+    d = pmul(vec4f_swizzle2(DC, DC, 0, 2, 1, 3), AB);
+    d = padd(d, vec4f_movehl(d, d));
+    d = padd(d, vec4f_swizzle2(d, d, 1, 0, 0, 0));
+    d1 = pmul(dA, dD);
+    d2 = pmul(dB, dC);
+
+    // determinant of the input matrix, det = |A||D| + |B||C| - trace(A#*B*D#*C)
+    Packet4f det = vec4f_duplane(psub(padd(d1, d2), d), 0);
+
+    // reciprocal of the determinant of the input matrix, rd = 1/det
+    Packet4f rd = pdiv(pset1<Packet4f>(1.0f), det);
+
+    // Four sub-matrices of the inverse
+    Packet4f iA, iB, iC, iD;
+
+    // iD = D*|A| - C*A#*B
+    iD = pmul(vec4f_swizzle2(C, C, 0, 0, 2, 2), vec4f_movelh(AB, AB));
+    iD = padd(iD, pmul(vec4f_swizzle2(C, C, 1, 1, 3, 3), vec4f_movehl(AB, AB)));
+    iD = psub(pmul(D, vec4f_duplane(dA, 0)), iD);
+
+    // iA = A*|D| - B*D#*C
+    iA = pmul(vec4f_swizzle2(B, B, 0, 0, 2, 2), vec4f_movelh(DC, DC));
+    iA = padd(iA, pmul(vec4f_swizzle2(B, B, 1, 1, 3, 3), vec4f_movehl(DC, DC)));
+    iA = psub(pmul(A, vec4f_duplane(dD, 0)), iA);
+
+    // iB = C*|B| - D * (A#B)# = C*|B| - D*B#*A
+    iB = pmul(D, vec4f_swizzle2(AB, AB, 3, 0, 3, 0));
+    iB = psub(iB, pmul(vec4f_swizzle2(D, D, 1, 0, 3, 2), vec4f_swizzle2(AB, AB, 2, 1, 2, 1)));
+    iB = psub(pmul(C, vec4f_duplane(dB, 0)), iB);
+
+    // iC = B*|C| - A * (D#C)# = B*|C| - A*C#*D
+    iC = pmul(A, vec4f_swizzle2(DC, DC, 3, 0, 3, 0));
+    iC = psub(iC, pmul(vec4f_swizzle2(A, A, 1, 0, 3, 2), vec4f_swizzle2(DC, DC, 2, 1, 2, 1)));
+    iC = psub(pmul(B, vec4f_duplane(dC, 0)), iC);
+
+    const float sign_mask[4] = {0.0f, numext::bit_cast<float>(0x80000000u), numext::bit_cast<float>(0x80000000u), 0.0f};
+    const Packet4f p4f_sign_PNNP = ploadu<Packet4f>(sign_mask);
+    rd = pxor(rd, p4f_sign_PNNP);
+    iA = pmul(iA, rd);
+    iB = pmul(iB, rd);
+    iC = pmul(iC, rd);
+    iD = pmul(iD, rd);
+
+    Index res_stride = result.outerStride();
+    float *res = result.data();
+
+    pstoret<float, Packet4f, ResultAlignment>(res + 0, vec4f_swizzle2(iA, iB, 3, 1, 3, 1));
+    pstoret<float, Packet4f, ResultAlignment>(res + res_stride, vec4f_swizzle2(iA, iB, 2, 0, 2, 0));
+    pstoret<float, Packet4f, ResultAlignment>(res + 2 * res_stride, vec4f_swizzle2(iC, iD, 3, 1, 3, 1));
+    pstoret<float, Packet4f, ResultAlignment>(res + 3 * res_stride, vec4f_swizzle2(iC, iD, 2, 0, 2, 0));
+  }
+};
+
+#if !(defined EIGEN_VECTORIZE_NEON && !(EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG))
+// same algorithm as above, except that each operand is split into
+// halves for two registers to hold.
+template <typename MatrixType, typename ResultType>
+struct compute_inverse_size4<Architecture::Target, double, MatrixType, ResultType>
+{
+  enum
+  {
+    MatrixAlignment = traits<MatrixType>::Alignment,
+    ResultAlignment = traits<ResultType>::Alignment,
+    StorageOrdersMatch = (MatrixType::Flags & RowMajorBit) == (ResultType::Flags & RowMajorBit)
+  };
+  typedef typename conditional<(MatrixType::Flags & LinearAccessBit),
+                               MatrixType const &,
+                               typename MatrixType::PlainObject>::type
+      ActualMatrixType;
+
+  static void run(const MatrixType &mat, ResultType &result)
+  {
+    ActualMatrixType matrix(mat);
+
+    // Four 2x2 sub-matrices of the input matrix, each is further divided into upper and lower
+    // row e.g. A1, upper row of A, A2, lower row of A
+    // input = [[A, B],  =  [[[A1, [B1,
+    //          [C, D]]        A2], B2]],
+    //                       [[C1, [D1,
+    //                         C2], D2]]]
+
+    Packet2d A1, A2, B1, B2, C1, C2, D1, D2;
+
+    const double* data = matrix.data();
+    const Index stride = matrix.innerStride();
+    if (StorageOrdersMatch)
+    {
+      A1 = ploadt<Packet2d,MatrixAlignment>(data + stride*0);
+      B1 = ploadt<Packet2d,MatrixAlignment>(data + stride*2);
+      A2 = ploadt<Packet2d,MatrixAlignment>(data + stride*4);
+      B2 = ploadt<Packet2d,MatrixAlignment>(data + stride*6);
+      C1 = ploadt<Packet2d,MatrixAlignment>(data + stride*8);
+      D1 = ploadt<Packet2d,MatrixAlignment>(data + stride*10);
+      C2 = ploadt<Packet2d,MatrixAlignment>(data + stride*12);
+      D2 = ploadt<Packet2d,MatrixAlignment>(data + stride*14);
+    }
+    else
+    {
+      Packet2d temp;
+      A1 = ploadt<Packet2d,MatrixAlignment>(data + stride*0);
+      C1 = ploadt<Packet2d,MatrixAlignment>(data + stride*2);
+      A2 = ploadt<Packet2d,MatrixAlignment>(data + stride*4);
+      C2 = ploadt<Packet2d,MatrixAlignment>(data + stride*6);
+      temp = A1;
+      A1 = vec2d_unpacklo(A1, A2);
+      A2 = vec2d_unpackhi(temp, A2);
+
+      temp = C1;
+      C1 = vec2d_unpacklo(C1, C2);
+      C2 = vec2d_unpackhi(temp, C2);
+
+      B1 = ploadt<Packet2d,MatrixAlignment>(data + stride*8);
+      D1 = ploadt<Packet2d,MatrixAlignment>(data + stride*10);
+      B2 = ploadt<Packet2d,MatrixAlignment>(data + stride*12);
+      D2 = ploadt<Packet2d,MatrixAlignment>(data + stride*14);
+
+      temp = B1;
+      B1 = vec2d_unpacklo(B1, B2);
+      B2 = vec2d_unpackhi(temp, B2);
+
+      temp = D1;
+      D1 = vec2d_unpacklo(D1, D2);
+      D2 = vec2d_unpackhi(temp, D2);
+    }
+
+    // determinants of the sub-matrices
+    Packet2d dA, dB, dC, dD;
+
+    dA = vec2d_swizzle2(A2, A2, 1);
+    dA = pmul(A1, dA);
+    dA = psub(dA, vec2d_duplane(dA, 1));
+
+    dB = vec2d_swizzle2(B2, B2, 1);
+    dB = pmul(B1, dB);
+    dB = psub(dB, vec2d_duplane(dB, 1));
+
+    dC = vec2d_swizzle2(C2, C2, 1);
+    dC = pmul(C1, dC);
+    dC = psub(dC, vec2d_duplane(dC, 1));
+
+    dD = vec2d_swizzle2(D2, D2, 1);
+    dD = pmul(D1, dD);
+    dD = psub(dD, vec2d_duplane(dD, 1));
+
+    Packet2d DC1, DC2, AB1, AB2;
+
+    // AB = A# * B, where A# denotes the adjugate of A, and * denotes matrix product.
+    AB1 = pmul(B1, vec2d_duplane(A2, 1));
+    AB2 = pmul(B2, vec2d_duplane(A1, 0));
+    AB1 = psub(AB1, pmul(B2, vec2d_duplane(A1, 1)));
+    AB2 = psub(AB2, pmul(B1, vec2d_duplane(A2, 0)));
+
+    // DC = D#*C
+    DC1 = pmul(C1, vec2d_duplane(D2, 1));
+    DC2 = pmul(C2, vec2d_duplane(D1, 0));
+    DC1 = psub(DC1, pmul(C2, vec2d_duplane(D1, 1)));
+    DC2 = psub(DC2, pmul(C1, vec2d_duplane(D2, 0)));
+
+    Packet2d d1, d2;
+
+    // determinant of the input matrix, det = |A||D| + |B||C| - trace(A#*B*D#*C)
+    Packet2d det;
+
+    // reciprocal of the determinant of the input matrix, rd = 1/det
+    Packet2d rd;
+
+    d1 = pmul(AB1, vec2d_swizzle2(DC1, DC2, 0));
+    d2 = pmul(AB2, vec2d_swizzle2(DC1, DC2, 3));
+    rd = padd(d1, d2);
+    rd = padd(rd, vec2d_duplane(rd, 1));
+
+    d1 = pmul(dA, dD);
+    d2 = pmul(dB, dC);
+
+    det = padd(d1, d2);
+    det = psub(det, rd);
+    det = vec2d_duplane(det, 0);
+    rd = pdiv(pset1<Packet2d>(1.0), det);
+
+    // rows of four sub-matrices of the inverse
+    Packet2d iA1, iA2, iB1, iB2, iC1, iC2, iD1, iD2;
+
+    // iD = D*|A| - C*A#*B
+    iD1 = pmul(AB1, vec2d_duplane(C1, 0));
+    iD2 = pmul(AB1, vec2d_duplane(C2, 0));
+    iD1 = padd(iD1, pmul(AB2, vec2d_duplane(C1, 1)));
+    iD2 = padd(iD2, pmul(AB2, vec2d_duplane(C2, 1)));
+    dA = vec2d_duplane(dA, 0);
+    iD1 = psub(pmul(D1, dA), iD1);
+    iD2 = psub(pmul(D2, dA), iD2);
+
+    // iA = A*|D| - B*D#*C
+    iA1 = pmul(DC1, vec2d_duplane(B1, 0));
+    iA2 = pmul(DC1, vec2d_duplane(B2, 0));
+    iA1 = padd(iA1, pmul(DC2, vec2d_duplane(B1, 1)));
+    iA2 = padd(iA2, pmul(DC2, vec2d_duplane(B2, 1)));
+    dD = vec2d_duplane(dD, 0);
+    iA1 = psub(pmul(A1, dD), iA1);
+    iA2 = psub(pmul(A2, dD), iA2);
+
+    // iB = C*|B| - D * (A#B)# = C*|B| - D*B#*A
+    iB1 = pmul(D1, vec2d_swizzle2(AB2, AB1, 1));
+    iB2 = pmul(D2, vec2d_swizzle2(AB2, AB1, 1));
+    iB1 = psub(iB1, pmul(vec2d_swizzle2(D1, D1, 1), vec2d_swizzle2(AB2, AB1, 2)));
+    iB2 = psub(iB2, pmul(vec2d_swizzle2(D2, D2, 1), vec2d_swizzle2(AB2, AB1, 2)));
+    dB = vec2d_duplane(dB, 0);
+    iB1 = psub(pmul(C1, dB), iB1);
+    iB2 = psub(pmul(C2, dB), iB2);
+
+    // iC = B*|C| - A * (D#C)# = B*|C| - A*C#*D
+    iC1 = pmul(A1, vec2d_swizzle2(DC2, DC1, 1));
+    iC2 = pmul(A2, vec2d_swizzle2(DC2, DC1, 1));
+    iC1 = psub(iC1, pmul(vec2d_swizzle2(A1, A1, 1), vec2d_swizzle2(DC2, DC1, 2)));
+    iC2 = psub(iC2, pmul(vec2d_swizzle2(A2, A2, 1), vec2d_swizzle2(DC2, DC1, 2)));
+    dC = vec2d_duplane(dC, 0);
+    iC1 = psub(pmul(B1, dC), iC1);
+    iC2 = psub(pmul(B2, dC), iC2);
+
+    const double sign_mask1[2] = {0.0, numext::bit_cast<double>(0x8000000000000000ull)};
+    const double sign_mask2[2] = {numext::bit_cast<double>(0x8000000000000000ull), 0.0};
+    const Packet2d sign_PN = ploadu<Packet2d>(sign_mask1);
+    const Packet2d sign_NP = ploadu<Packet2d>(sign_mask2);
+    d1 = pxor(rd, sign_PN);
+    d2 = pxor(rd, sign_NP);
+
+    Index res_stride = result.outerStride();
+    double *res = result.data();
+    pstoret<double, Packet2d, ResultAlignment>(res + 0, pmul(vec2d_swizzle2(iA2, iA1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res + res_stride, pmul(vec2d_swizzle2(iA2, iA1, 0), d2));
+    pstoret<double, Packet2d, ResultAlignment>(res + 2, pmul(vec2d_swizzle2(iB2, iB1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res + res_stride + 2, pmul(vec2d_swizzle2(iB2, iB1, 0), d2));
+    pstoret<double, Packet2d, ResultAlignment>(res + 2 * res_stride, pmul(vec2d_swizzle2(iC2, iC1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res + 3 * res_stride, pmul(vec2d_swizzle2(iC2, iC1, 0), d2));
+    pstoret<double, Packet2d, ResultAlignment>(res + 2 * res_stride + 2, pmul(vec2d_swizzle2(iD2, iD1, 3), d1));
+    pstoret<double, Packet2d, ResultAlignment>(res + 3 * res_stride + 2, pmul(vec2d_swizzle2(iD2, iD1, 0), d2));
+  }
+};
+#endif
+} // namespace internal
+} // namespace Eigen
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/MetisSupport/MetisSupport.h b/C++/yolo_bytetrack_old/include/Eigen/src/MetisSupport/MetisSupport.h
new file mode 100644
index 00000000..4c15304a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/MetisSupport/MetisSupport.h
@@ -0,0 +1,137 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#ifndef METIS_SUPPORT_H
+#define METIS_SUPPORT_H
+
+namespace Eigen {
+/**
+ * Get the fill-reducing ordering from the METIS package
+ * 
+ * If A is the original matrix and Ap is the permuted matrix, 
+ * the fill-reducing permutation is defined as follows :
+ * Row (column) i of A is the matperm(i) row (column) of Ap. 
+ * WARNING: As computed by METIS, this corresponds to the vector iperm (instead of perm)
+ */
+template <typename StorageIndex>
+class MetisOrdering
+{
+public:
+  typedef PermutationMatrix<Dynamic,Dynamic,StorageIndex> PermutationType;
+  typedef Matrix<StorageIndex,Dynamic,1> IndexVector; 
+  
+  template <typename MatrixType>
+  void get_symmetrized_graph(const MatrixType& A)
+  {
+    Index m = A.cols(); 
+    eigen_assert((A.rows() == A.cols()) && "ONLY FOR SQUARED MATRICES");
+    // Get the transpose of the input matrix 
+    MatrixType At = A.transpose(); 
+    // Get the number of nonzeros elements in each row/col of At+A
+    Index TotNz = 0; 
+    IndexVector visited(m); 
+    visited.setConstant(-1); 
+    for (StorageIndex j = 0; j < m; j++)
+    {
+      // Compute the union structure of of A(j,:) and At(j,:)
+      visited(j) = j; // Do not include the diagonal element
+      // Get the nonzeros in row/column j of A
+      for (typename MatrixType::InnerIterator it(A, j); it; ++it)
+      {
+        Index idx = it.index(); // Get the row index (for column major) or column index (for row major)
+        if (visited(idx) != j ) 
+        {
+          visited(idx) = j; 
+          ++TotNz; 
+        }
+      }
+      //Get the nonzeros in row/column j of At
+      for (typename MatrixType::InnerIterator it(At, j); it; ++it)
+      {
+        Index idx = it.index(); 
+        if(visited(idx) != j)
+        {
+          visited(idx) = j; 
+          ++TotNz; 
+        }
+      }
+    }
+    // Reserve place for A + At
+    m_indexPtr.resize(m+1);
+    m_innerIndices.resize(TotNz); 
+
+    // Now compute the real adjacency list of each column/row 
+    visited.setConstant(-1); 
+    StorageIndex CurNz = 0; 
+    for (StorageIndex j = 0; j < m; j++)
+    {
+      m_indexPtr(j) = CurNz; 
+      
+      visited(j) = j; // Do not include the diagonal element
+      // Add the pattern of row/column j of A to A+At
+      for (typename MatrixType::InnerIterator it(A,j); it; ++it)
+      {
+        StorageIndex idx = it.index(); // Get the row index (for column major) or column index (for row major)
+        if (visited(idx) != j ) 
+        {
+          visited(idx) = j; 
+          m_innerIndices(CurNz) = idx; 
+          CurNz++; 
+        }
+      }
+      //Add the pattern of row/column j of At to A+At
+      for (typename MatrixType::InnerIterator it(At, j); it; ++it)
+      {
+        StorageIndex idx = it.index(); 
+        if(visited(idx) != j)
+        {
+          visited(idx) = j; 
+          m_innerIndices(CurNz) = idx; 
+          ++CurNz; 
+        }
+      }
+    }
+    m_indexPtr(m) = CurNz;    
+  }
+  
+  template <typename MatrixType>
+  void operator() (const MatrixType& A, PermutationType& matperm)
+  {
+     StorageIndex m = internal::convert_index<StorageIndex>(A.cols()); // must be StorageIndex, because it is passed by address to METIS
+     IndexVector perm(m),iperm(m); 
+    // First, symmetrize the matrix graph. 
+     get_symmetrized_graph(A); 
+     int output_error;
+     
+     // Call the fill-reducing routine from METIS 
+     output_error = METIS_NodeND(&m, m_indexPtr.data(), m_innerIndices.data(), NULL, NULL, perm.data(), iperm.data());
+     
+    if(output_error != METIS_OK) 
+    {
+      //FIXME The ordering interface should define a class of possible errors 
+     std::cerr << "ERROR WHILE CALLING THE METIS PACKAGE \n"; 
+     return; 
+    }
+    
+    // Get the fill-reducing permutation 
+    //NOTE:  If Ap is the permuted matrix then perm and iperm vectors are defined as follows 
+    // Row (column) i of Ap is the perm(i) row(column) of A, and row (column) i of A is the iperm(i) row(column) of Ap
+    
+     matperm.resize(m);
+     for (int j = 0; j < m; j++)
+       matperm.indices()(iperm(j)) = j;
+   
+  }
+  
+  protected:
+    IndexVector m_indexPtr; // Pointer to the adjacenccy list of each row/column
+    IndexVector m_innerIndices; // Adjacency list 
+};
+
+}// end namespace eigen 
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/OrderingMethods/Amd.h b/C++/yolo_bytetrack_old/include/Eigen/src/OrderingMethods/Amd.h
new file mode 100644
index 00000000..7ca3f33b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/OrderingMethods/Amd.h
@@ -0,0 +1,435 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*
+NOTE: this routine has been adapted from the CSparse library:
+
+Copyright (c) 2006, Timothy A. Davis.
+http://www.suitesparse.com
+
+The author of CSparse, Timothy A. Davis., has executed a license with Google LLC
+to permit distribution of this code and derivative works as part of Eigen under
+the Mozilla Public License v. 2.0, as stated at the top of this file.
+*/
+
+#ifndef EIGEN_SPARSE_AMD_H
+#define EIGEN_SPARSE_AMD_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<typename T> inline T amd_flip(const T& i) { return -i-2; }
+template<typename T> inline T amd_unflip(const T& i) { return i<0 ? amd_flip(i) : i; }
+template<typename T0, typename T1> inline bool amd_marked(const T0* w, const T1& j) { return w[j]<0; }
+template<typename T0, typename T1> inline void amd_mark(const T0* w, const T1& j) { return w[j] = amd_flip(w[j]); }
+
+/* clear w */
+template<typename StorageIndex>
+static StorageIndex cs_wclear (StorageIndex mark, StorageIndex lemax, StorageIndex *w, StorageIndex n)
+{
+  StorageIndex k;
+  if(mark < 2 || (mark + lemax < 0))
+  {
+    for(k = 0; k < n; k++)
+      if(w[k] != 0)
+        w[k] = 1;
+    mark = 2;
+  }
+  return (mark);     /* at this point, w[0..n-1] < mark holds */
+}
+
+/* depth-first search and postorder of a tree rooted at node j */
+template<typename StorageIndex>
+StorageIndex cs_tdfs(StorageIndex j, StorageIndex k, StorageIndex *head, const StorageIndex *next, StorageIndex *post, StorageIndex *stack)
+{
+  StorageIndex i, p, top = 0;
+  if(!head || !next || !post || !stack) return (-1);    /* check inputs */
+  stack[0] = j;                 /* place j on the stack */
+  while (top >= 0)                /* while (stack is not empty) */
+  {
+    p = stack[top];           /* p = top of stack */
+    i = head[p];              /* i = youngest child of p */
+    if(i == -1)
+    {
+      top--;                 /* p has no unordered children left */
+      post[k++] = p;        /* node p is the kth postordered node */
+    }
+    else
+    {
+      head[p] = next[i];   /* remove i from children of p */
+      stack[++top] = i;     /* start dfs on child node i */
+    }
+  }
+  return k;
+}
+
+
+/** \internal
+  * \ingroup OrderingMethods_Module 
+  * Approximate minimum degree ordering algorithm.
+  *
+  * \param[in] C the input selfadjoint matrix stored in compressed column major format.
+  * \param[out] perm the permutation P reducing the fill-in of the input matrix \a C
+  *
+  * Note that the input matrix \a C must be complete, that is both the upper and lower parts have to be stored, as well as the diagonal entries.
+  * On exit the values of C are destroyed */
+template<typename Scalar, typename StorageIndex>
+void minimum_degree_ordering(SparseMatrix<Scalar,ColMajor,StorageIndex>& C, PermutationMatrix<Dynamic,Dynamic,StorageIndex>& perm)
+{
+  using std::sqrt;
+  
+  StorageIndex d, dk, dext, lemax = 0, e, elenk, eln, i, j, k, k1,
+                k2, k3, jlast, ln, dense, nzmax, mindeg = 0, nvi, nvj, nvk, mark, wnvi,
+                ok, nel = 0, p, p1, p2, p3, p4, pj, pk, pk1, pk2, pn, q, t, h;
+  
+  StorageIndex n = StorageIndex(C.cols());
+  dense = std::max<StorageIndex> (16, StorageIndex(10 * sqrt(double(n))));   /* find dense threshold */
+  dense = (std::min)(n-2, dense);
+  
+  StorageIndex cnz = StorageIndex(C.nonZeros());
+  perm.resize(n+1);
+  t = cnz + cnz/5 + 2*n;                 /* add elbow room to C */
+  C.resizeNonZeros(t);
+  
+  // get workspace
+  ei_declare_aligned_stack_constructed_variable(StorageIndex,W,8*(n+1),0);
+  StorageIndex* len     = W;
+  StorageIndex* nv      = W +   (n+1);
+  StorageIndex* next    = W + 2*(n+1);
+  StorageIndex* head    = W + 3*(n+1);
+  StorageIndex* elen    = W + 4*(n+1);
+  StorageIndex* degree  = W + 5*(n+1);
+  StorageIndex* w       = W + 6*(n+1);
+  StorageIndex* hhead   = W + 7*(n+1);
+  StorageIndex* last    = perm.indices().data();                              /* use P as workspace for last */
+  
+  /* --- Initialize quotient graph ---------------------------------------- */
+  StorageIndex* Cp = C.outerIndexPtr();
+  StorageIndex* Ci = C.innerIndexPtr();
+  for(k = 0; k < n; k++)
+    len[k] = Cp[k+1] - Cp[k];
+  len[n] = 0;
+  nzmax = t;
+  
+  for(i = 0; i <= n; i++)
+  {
+    head[i]   = -1;                     // degree list i is empty
+    last[i]   = -1;
+    next[i]   = -1;
+    hhead[i]  = -1;                     // hash list i is empty 
+    nv[i]     = 1;                      // node i is just one node
+    w[i]      = 1;                      // node i is alive
+    elen[i]   = 0;                      // Ek of node i is empty
+    degree[i] = len[i];                 // degree of node i
+  }
+  mark = internal::cs_wclear<StorageIndex>(0, 0, w, n);         /* clear w */
+  
+  /* --- Initialize degree lists ------------------------------------------ */
+  for(i = 0; i < n; i++)
+  {
+    bool has_diag = false;
+    for(p = Cp[i]; p<Cp[i+1]; ++p)
+      if(Ci[p]==i)
+      {
+        has_diag = true;
+        break;
+      }
+   
+    d = degree[i];
+    if(d == 1 && has_diag)           /* node i is empty */
+    {
+      elen[i] = -2;                 /* element i is dead */
+      nel++;
+      Cp[i] = -1;                   /* i is a root of assembly tree */
+      w[i] = 0;
+    }
+    else if(d > dense || !has_diag)  /* node i is dense or has no structural diagonal element */
+    {
+      nv[i] = 0;                    /* absorb i into element n */
+      elen[i] = -1;                 /* node i is dead */
+      nel++;
+      Cp[i] = amd_flip (n);
+      nv[n]++;
+    }
+    else
+    {
+      if(head[d] != -1) last[head[d]] = i;
+      next[i] = head[d];           /* put node i in degree list d */
+      head[d] = i;
+    }
+  }
+  
+  elen[n] = -2;                         /* n is a dead element */
+  Cp[n] = -1;                           /* n is a root of assembly tree */
+  w[n] = 0;                             /* n is a dead element */
+  
+  while (nel < n)                         /* while (selecting pivots) do */
+  {
+    /* --- Select node of minimum approximate degree -------------------- */
+    for(k = -1; mindeg < n && (k = head[mindeg]) == -1; mindeg++) {}
+    if(next[k] != -1) last[next[k]] = -1;
+    head[mindeg] = next[k];          /* remove k from degree list */
+    elenk = elen[k];                  /* elenk = |Ek| */
+    nvk = nv[k];                      /* # of nodes k represents */
+    nel += nvk;                        /* nv[k] nodes of A eliminated */
+    
+    /* --- Garbage collection ------------------------------------------- */
+    if(elenk > 0 && cnz + mindeg >= nzmax)
+    {
+      for(j = 0; j < n; j++)
+      {
+        if((p = Cp[j]) >= 0)      /* j is a live node or element */
+        {
+          Cp[j] = Ci[p];          /* save first entry of object */
+          Ci[p] = amd_flip (j);    /* first entry is now amd_flip(j) */
+        }
+      }
+      for(q = 0, p = 0; p < cnz; ) /* scan all of memory */
+      {
+        if((j = amd_flip (Ci[p++])) >= 0)  /* found object j */
+        {
+          Ci[q] = Cp[j];       /* restore first entry of object */
+          Cp[j] = q++;          /* new pointer to object j */
+          for(k3 = 0; k3 < len[j]-1; k3++) Ci[q++] = Ci[p++];
+        }
+      }
+      cnz = q;                       /* Ci[cnz...nzmax-1] now free */
+    }
+    
+    /* --- Construct new element ---------------------------------------- */
+    dk = 0;
+    nv[k] = -nvk;                     /* flag k as in Lk */
+    p = Cp[k];
+    pk1 = (elenk == 0) ? p : cnz;      /* do in place if elen[k] == 0 */
+    pk2 = pk1;
+    for(k1 = 1; k1 <= elenk + 1; k1++)
+    {
+      if(k1 > elenk)
+      {
+        e = k;                     /* search the nodes in k */
+        pj = p;                    /* list of nodes starts at Ci[pj]*/
+        ln = len[k] - elenk;      /* length of list of nodes in k */
+      }
+      else
+      {
+        e = Ci[p++];              /* search the nodes in e */
+        pj = Cp[e];
+        ln = len[e];              /* length of list of nodes in e */
+      }
+      for(k2 = 1; k2 <= ln; k2++)
+      {
+        i = Ci[pj++];
+        if((nvi = nv[i]) <= 0) continue; /* node i dead, or seen */
+        dk += nvi;                 /* degree[Lk] += size of node i */
+        nv[i] = -nvi;             /* negate nv[i] to denote i in Lk*/
+        Ci[pk2++] = i;            /* place i in Lk */
+        if(next[i] != -1) last[next[i]] = last[i];
+        if(last[i] != -1)         /* remove i from degree list */
+        {
+          next[last[i]] = next[i];
+        }
+        else
+        {
+          head[degree[i]] = next[i];
+        }
+      }
+      if(e != k)
+      {
+        Cp[e] = amd_flip (k);      /* absorb e into k */
+        w[e] = 0;                 /* e is now a dead element */
+      }
+    }
+    if(elenk != 0) cnz = pk2;         /* Ci[cnz...nzmax] is free */
+    degree[k] = dk;                   /* external degree of k - |Lk\i| */
+    Cp[k] = pk1;                      /* element k is in Ci[pk1..pk2-1] */
+    len[k] = pk2 - pk1;
+    elen[k] = -2;                     /* k is now an element */
+    
+    /* --- Find set differences ----------------------------------------- */
+    mark = internal::cs_wclear<StorageIndex>(mark, lemax, w, n);  /* clear w if necessary */
+    for(pk = pk1; pk < pk2; pk++)    /* scan 1: find |Le\Lk| */
+    {
+      i = Ci[pk];
+      if((eln = elen[i]) <= 0) continue;/* skip if elen[i] empty */
+      nvi = -nv[i];                      /* nv[i] was negated */
+      wnvi = mark - nvi;
+      for(p = Cp[i]; p <= Cp[i] + eln - 1; p++)  /* scan Ei */
+      {
+        e = Ci[p];
+        if(w[e] >= mark)
+        {
+          w[e] -= nvi;          /* decrement |Le\Lk| */
+        }
+        else if(w[e] != 0)        /* ensure e is a live element */
+        {
+          w[e] = degree[e] + wnvi; /* 1st time e seen in scan 1 */
+        }
+      }
+    }
+    
+    /* --- Degree update ------------------------------------------------ */
+    for(pk = pk1; pk < pk2; pk++)    /* scan2: degree update */
+    {
+      i = Ci[pk];                   /* consider node i in Lk */
+      p1 = Cp[i];
+      p2 = p1 + elen[i] - 1;
+      pn = p1;
+      for(h = 0, d = 0, p = p1; p <= p2; p++)    /* scan Ei */
+      {
+        e = Ci[p];
+        if(w[e] != 0)             /* e is an unabsorbed element */
+        {
+          dext = w[e] - mark;   /* dext = |Le\Lk| */
+          if(dext > 0)
+          {
+            d += dext;         /* sum up the set differences */
+            Ci[pn++] = e;     /* keep e in Ei */
+            h += e;            /* compute the hash of node i */
+          }
+          else
+          {
+            Cp[e] = amd_flip (k);  /* aggressive absorb. e->k */
+            w[e] = 0;             /* e is a dead element */
+          }
+        }
+      }
+      elen[i] = pn - p1 + 1;        /* elen[i] = |Ei| */
+      p3 = pn;
+      p4 = p1 + len[i];
+      for(p = p2 + 1; p < p4; p++) /* prune edges in Ai */
+      {
+        j = Ci[p];
+        if((nvj = nv[j]) <= 0) continue; /* node j dead or in Lk */
+        d += nvj;                  /* degree(i) += |j| */
+        Ci[pn++] = j;             /* place j in node list of i */
+        h += j;                    /* compute hash for node i */
+      }
+      if(d == 0)                     /* check for mass elimination */
+      {
+        Cp[i] = amd_flip (k);      /* absorb i into k */
+        nvi = -nv[i];
+        dk -= nvi;                 /* |Lk| -= |i| */
+        nvk += nvi;                /* |k| += nv[i] */
+        nel += nvi;
+        nv[i] = 0;
+        elen[i] = -1;             /* node i is dead */
+      }
+      else
+      {
+        degree[i] = std::min<StorageIndex> (degree[i], d);   /* update degree(i) */
+        Ci[pn] = Ci[p3];         /* move first node to end */
+        Ci[p3] = Ci[p1];         /* move 1st el. to end of Ei */
+        Ci[p1] = k;               /* add k as 1st element in of Ei */
+        len[i] = pn - p1 + 1;     /* new len of adj. list of node i */
+        h %= n;                    /* finalize hash of i */
+        next[i] = hhead[h];      /* place i in hash bucket */
+        hhead[h] = i;
+        last[i] = h;      /* save hash of i in last[i] */
+      }
+    }                                   /* scan2 is done */
+    degree[k] = dk;                   /* finalize |Lk| */
+    lemax = std::max<StorageIndex>(lemax, dk);
+    mark = internal::cs_wclear<StorageIndex>(mark+lemax, lemax, w, n);    /* clear w */
+    
+    /* --- Supernode detection ------------------------------------------ */
+    for(pk = pk1; pk < pk2; pk++)
+    {
+      i = Ci[pk];
+      if(nv[i] >= 0) continue;         /* skip if i is dead */
+      h = last[i];                      /* scan hash bucket of node i */
+      i = hhead[h];
+      hhead[h] = -1;                    /* hash bucket will be empty */
+      for(; i != -1 && next[i] != -1; i = next[i], mark++)
+      {
+        ln = len[i];
+        eln = elen[i];
+        for(p = Cp[i]+1; p <= Cp[i] + ln-1; p++) w[Ci[p]] = mark;
+        jlast = i;
+        for(j = next[i]; j != -1; ) /* compare i with all j */
+        {
+          ok = (len[j] == ln) && (elen[j] == eln);
+          for(p = Cp[j] + 1; ok && p <= Cp[j] + ln - 1; p++)
+          {
+            if(w[Ci[p]] != mark) ok = 0;    /* compare i and j*/
+          }
+          if(ok)                     /* i and j are identical */
+          {
+            Cp[j] = amd_flip (i);  /* absorb j into i */
+            nv[i] += nv[j];
+            nv[j] = 0;
+            elen[j] = -1;         /* node j is dead */
+            j = next[j];          /* delete j from hash bucket */
+            next[jlast] = j;
+          }
+          else
+          {
+            jlast = j;             /* j and i are different */
+            j = next[j];
+          }
+        }
+      }
+    }
+    
+    /* --- Finalize new element------------------------------------------ */
+    for(p = pk1, pk = pk1; pk < pk2; pk++)   /* finalize Lk */
+    {
+      i = Ci[pk];
+      if((nvi = -nv[i]) <= 0) continue;/* skip if i is dead */
+      nv[i] = nvi;                      /* restore nv[i] */
+      d = degree[i] + dk - nvi;         /* compute external degree(i) */
+      d = std::min<StorageIndex> (d, n - nel - nvi);
+      if(head[d] != -1) last[head[d]] = i;
+      next[i] = head[d];               /* put i back in degree list */
+      last[i] = -1;
+      head[d] = i;
+      mindeg = std::min<StorageIndex> (mindeg, d);       /* find new minimum degree */
+      degree[i] = d;
+      Ci[p++] = i;                      /* place i in Lk */
+    }
+    nv[k] = nvk;                      /* # nodes absorbed into k */
+    if((len[k] = p-pk1) == 0)         /* length of adj list of element k*/
+    {
+      Cp[k] = -1;                   /* k is a root of the tree */
+      w[k] = 0;                     /* k is now a dead element */
+    }
+    if(elenk != 0) cnz = p;           /* free unused space in Lk */
+  }
+  
+  /* --- Postordering ----------------------------------------------------- */
+  for(i = 0; i < n; i++) Cp[i] = amd_flip (Cp[i]);/* fix assembly tree */
+  for(j = 0; j <= n; j++) head[j] = -1;
+  for(j = n; j >= 0; j--)              /* place unordered nodes in lists */
+  {
+    if(nv[j] > 0) continue;          /* skip if j is an element */
+    next[j] = head[Cp[j]];          /* place j in list of its parent */
+    head[Cp[j]] = j;
+  }
+  for(e = n; e >= 0; e--)              /* place elements in lists */
+  {
+    if(nv[e] <= 0) continue;         /* skip unless e is an element */
+    if(Cp[e] != -1)
+    {
+      next[e] = head[Cp[e]];      /* place e in list of its parent */
+      head[Cp[e]] = e;
+    }
+  }
+  for(k = 0, i = 0; i <= n; i++)       /* postorder the assembly tree */
+  {
+    if(Cp[i] == -1) k = internal::cs_tdfs<StorageIndex>(i, k, head, next, perm.indices().data(), w);
+  }
+  
+  perm.indices().conservativeResize(n);
+}
+
+} // namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_AMD_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/OrderingMethods/Eigen_Colamd.h b/C++/yolo_bytetrack_old/include/Eigen/src/OrderingMethods/Eigen_Colamd.h
new file mode 100644
index 00000000..8e339a70
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/OrderingMethods/Eigen_Colamd.h
@@ -0,0 +1,1863 @@
+// // This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Desire Nuentsa Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is modified from the colamd/symamd library. The copyright is below
+
+//   The authors of the code itself are Stefan I. Larimore and Timothy A.
+//   Davis (davis@cise.ufl.edu), University of Florida.  The algorithm was
+//   developed in collaboration with John Gilbert, Xerox PARC, and Esmond
+//   Ng, Oak Ridge National Laboratory.
+//
+//     Date:
+//
+//   September 8, 2003.  Version 2.3.
+//
+//     Acknowledgements:
+//
+//   This work was supported by the National Science Foundation, under
+//   grants DMS-9504974 and DMS-9803599.
+//
+//     Notice:
+//
+//   Copyright (c) 1998-2003 by the University of Florida.
+//   All Rights Reserved.
+//
+//   THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+//   EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+//
+//   Permission is hereby granted to use, copy, modify, and/or distribute
+//   this program, provided that the Copyright, this License, and the
+//   Availability of the original version is retained on all copies and made
+//   accessible to the end-user of any code or package that includes COLAMD
+//   or any modified version of COLAMD.
+//
+//     Availability:
+//
+//   The colamd/symamd library is available at
+//
+//       http://www.suitesparse.com
+
+
+#ifndef EIGEN_COLAMD_H
+#define EIGEN_COLAMD_H
+
+namespace internal {
+
+namespace Colamd {
+
+/* Ensure that debugging is turned off: */
+#ifndef COLAMD_NDEBUG
+#define COLAMD_NDEBUG
+#endif /* NDEBUG */
+
+
+/* ========================================================================== */
+/* === Knob and statistics definitions ====================================== */
+/* ========================================================================== */
+
+/* size of the knobs [ ] array.  Only knobs [0..1] are currently used. */
+const int NKnobs = 20;
+
+/* number of output statistics.  Only stats [0..6] are currently used. */
+const int NStats = 20;
+
+/* Indices into knobs and stats array. */
+enum KnobsStatsIndex {
+  /* knobs [0] and stats [0]: dense row knob and output statistic. */
+  DenseRow = 0,
+
+  /* knobs [1] and stats [1]: dense column knob and output statistic. */
+  DenseCol = 1,
+
+  /* stats [2]: memory defragmentation count output statistic */
+  DefragCount = 2,
+
+  /* stats [3]: colamd status:  zero OK, > 0 warning or notice, < 0 error */
+  Status = 3,
+
+  /* stats [4..6]: error info, or info on jumbled columns */
+  Info1 = 4,
+  Info2 = 5,
+  Info3 = 6
+};
+
+/* error codes returned in stats [3]: */
+enum Status {
+  Ok = 0,
+  OkButJumbled = 1,
+  ErrorANotPresent = -1,
+  ErrorPNotPresent = -2,
+  ErrorNrowNegative = -3,
+  ErrorNcolNegative = -4,
+  ErrorNnzNegative = -5,
+  ErrorP0Nonzero = -6,
+  ErrorATooSmall = -7,
+  ErrorColLengthNegative = -8,
+  ErrorRowIndexOutOfBounds = -9,
+  ErrorOutOfMemory = -10,
+  ErrorInternalError = -999
+};
+/* ========================================================================== */
+/* === Definitions ========================================================== */
+/* ========================================================================== */
+
+template <typename IndexType>
+IndexType ones_complement(const IndexType r) {
+  return (-(r)-1);
+}
+
+/* -------------------------------------------------------------------------- */
+const int Empty = -1;
+
+/* Row and column status */
+enum RowColumnStatus {
+  Alive = 0,
+  Dead = -1
+};
+
+/* Column status */
+enum ColumnStatus {
+  DeadPrincipal = -1,
+  DeadNonPrincipal = -2
+};
+
+/* ========================================================================== */
+/* === Colamd reporting mechanism =========================================== */
+/* ========================================================================== */
+
+// == Row and Column structures ==
+template <typename IndexType>
+struct ColStructure
+{
+  IndexType start ;   /* index for A of first row in this column, or Dead */
+  /* if column is dead */
+  IndexType length ;  /* number of rows in this column */
+  union
+  {
+    IndexType thickness ; /* number of original columns represented by this */
+    /* col, if the column is alive */
+    IndexType parent ;  /* parent in parent tree super-column structure, if */
+    /* the column is dead */
+  } shared1 ;
+  union
+  {
+    IndexType score ; /* the score used to maintain heap, if col is alive */
+    IndexType order ; /* pivot ordering of this column, if col is dead */
+  } shared2 ;
+  union
+  {
+    IndexType headhash ;  /* head of a hash bucket, if col is at the head of */
+    /* a degree list */
+    IndexType hash ;  /* hash value, if col is not in a degree list */
+    IndexType prev ;  /* previous column in degree list, if col is in a */
+    /* degree list (but not at the head of a degree list) */
+  } shared3 ;
+  union
+  {
+    IndexType degree_next ; /* next column, if col is in a degree list */
+    IndexType hash_next ;   /* next column, if col is in a hash list */
+  } shared4 ;
+
+  inline bool is_dead() const { return start < Alive; }
+
+  inline bool is_alive() const { return start >= Alive; }
+
+  inline bool is_dead_principal() const { return start == DeadPrincipal; }
+
+  inline void kill_principal() { start = DeadPrincipal; }
+
+  inline void kill_non_principal() { start = DeadNonPrincipal; }
+
+};
+
+template <typename IndexType>
+struct RowStructure
+{
+  IndexType start ;   /* index for A of first col in this row */
+  IndexType length ;  /* number of principal columns in this row */
+  union
+  {
+    IndexType degree ;  /* number of principal & non-principal columns in row */
+    IndexType p ;   /* used as a row pointer in init_rows_cols () */
+  } shared1 ;
+  union
+  {
+    IndexType mark ;  /* for computing set differences and marking dead rows*/
+    IndexType first_column ;/* first column in row (used in garbage collection) */
+  } shared2 ;
+
+  inline bool is_dead() const { return shared2.mark < Alive; }
+
+  inline bool is_alive() const { return shared2.mark >= Alive; }
+
+  inline void kill() { shared2.mark = Dead; }
+
+};
+
+/* ========================================================================== */
+/* === Colamd recommended memory size ======================================= */
+/* ========================================================================== */
+
+/*
+  The recommended length Alen of the array A passed to colamd is given by
+  the COLAMD_RECOMMENDED (nnz, n_row, n_col) macro.  It returns -1 if any
+  argument is negative.  2*nnz space is required for the row and column
+  indices of the matrix. colamd_c (n_col) + colamd_r (n_row) space is
+  required for the Col and Row arrays, respectively, which are internal to
+  colamd.  An additional n_col space is the minimal amount of "elbow room",
+  and nnz/5 more space is recommended for run time efficiency.
+
+  This macro is not needed when using symamd.
+
+  Explicit typecast to IndexType added Sept. 23, 2002, COLAMD version 2.2, to avoid
+  gcc -pedantic warning messages.
+*/
+template <typename IndexType>
+inline IndexType colamd_c(IndexType n_col)
+{ return IndexType( ((n_col) + 1) * sizeof (ColStructure<IndexType>) / sizeof (IndexType) ) ; }
+
+template <typename IndexType>
+inline IndexType  colamd_r(IndexType n_row)
+{ return IndexType(((n_row) + 1) * sizeof (RowStructure<IndexType>) / sizeof (IndexType)); }
+
+// Prototypes of non-user callable routines
+template <typename IndexType>
+static IndexType init_rows_cols (IndexType n_row, IndexType n_col, RowStructure<IndexType> Row [], ColStructure<IndexType> col [], IndexType A [], IndexType p [], IndexType stats[NStats] );
+
+template <typename IndexType>
+static void init_scoring (IndexType n_row, IndexType n_col, RowStructure<IndexType> Row [], ColStructure<IndexType> Col [], IndexType A [], IndexType head [], double knobs[NKnobs], IndexType *p_n_row2, IndexType *p_n_col2, IndexType *p_max_deg);
+
+template <typename IndexType>
+static IndexType find_ordering (IndexType n_row, IndexType n_col, IndexType Alen, RowStructure<IndexType> Row [], ColStructure<IndexType> Col [], IndexType A [], IndexType head [], IndexType n_col2, IndexType max_deg, IndexType pfree);
+
+template <typename IndexType>
+static void order_children (IndexType n_col, ColStructure<IndexType> Col [], IndexType p []);
+
+template <typename IndexType>
+static void detect_super_cols (ColStructure<IndexType> Col [], IndexType A [], IndexType head [], IndexType row_start, IndexType row_length ) ;
+
+template <typename IndexType>
+static IndexType garbage_collection (IndexType n_row, IndexType n_col, RowStructure<IndexType> Row [], ColStructure<IndexType> Col [], IndexType A [], IndexType *pfree) ;
+
+template <typename IndexType>
+static inline  IndexType clear_mark (IndexType n_row, RowStructure<IndexType> Row [] ) ;
+
+/* === No debugging ========================================================= */
+
+#define COLAMD_DEBUG0(params) ;
+#define COLAMD_DEBUG1(params) ;
+#define COLAMD_DEBUG2(params) ;
+#define COLAMD_DEBUG3(params) ;
+#define COLAMD_DEBUG4(params) ;
+
+#define COLAMD_ASSERT(expression) ((void) 0)
+
+
+/**
+ * \brief Returns the recommended value of Alen
+ *
+ * Returns recommended value of Alen for use by colamd.
+ * Returns -1 if any input argument is negative.
+ * The use of this routine or macro is optional.
+ * Note that the macro uses its arguments   more than once,
+ * so be careful for side effects, if you pass expressions as arguments to COLAMD_RECOMMENDED.
+ *
+ * \param nnz nonzeros in A
+ * \param n_row number of rows in A
+ * \param n_col number of columns in A
+ * \return recommended value of Alen for use by colamd
+ */
+template <typename IndexType>
+inline IndexType recommended ( IndexType nnz, IndexType n_row, IndexType n_col)
+{
+  if ((nnz) < 0 || (n_row) < 0 || (n_col) < 0)
+    return (-1);
+  else
+    return (2 * (nnz) + colamd_c (n_col) + colamd_r (n_row) + (n_col) + ((nnz) / 5));
+}
+
+/**
+ * \brief set default parameters  The use of this routine is optional.
+ *
+ * Colamd: rows with more than (knobs [DenseRow] * n_col)
+ * entries are removed prior to ordering.  Columns with more than
+ * (knobs [DenseCol] * n_row) entries are removed prior to
+ * ordering, and placed last in the output column ordering.
+ *
+ * DenseRow and DenseCol are defined as 0 and 1,
+ * respectively, in colamd.h.  Default values of these two knobs
+ * are both 0.5.  Currently, only knobs [0] and knobs [1] are
+ * used, but future versions may use more knobs.  If so, they will
+ * be properly set to their defaults by the future version of
+ * colamd_set_defaults, so that the code that calls colamd will
+ * not need to change, assuming that you either use
+ * colamd_set_defaults, or pass a (double *) NULL pointer as the
+ * knobs array to colamd or symamd.
+ *
+ * \param knobs parameter settings for colamd
+ */
+
+static inline void set_defaults(double knobs[NKnobs])
+{
+  /* === Local variables ================================================== */
+
+  int i ;
+
+  if (!knobs)
+  {
+    return ;      /* no knobs to initialize */
+  }
+  for (i = 0 ; i < NKnobs ; i++)
+  {
+    knobs [i] = 0 ;
+  }
+  knobs [Colamd::DenseRow] = 0.5 ;  /* ignore rows over 50% dense */
+  knobs [Colamd::DenseCol] = 0.5 ;  /* ignore columns over 50% dense */
+}
+
+/**
+ * \brief  Computes a column ordering using the column approximate minimum degree ordering
+ *
+ * Computes a column ordering (Q) of A such that P(AQ)=LU or
+ * (AQ)'AQ=LL' have less fill-in and require fewer floating point
+ * operations than factorizing the unpermuted matrix A or A'A,
+ * respectively.
+ *
+ *
+ * \param n_row number of rows in A
+ * \param n_col number of columns in A
+ * \param Alen, size of the array A
+ * \param A row indices of the matrix, of size ALen
+ * \param p column pointers of A, of size n_col+1
+ * \param knobs parameter settings for colamd
+ * \param stats colamd output statistics and error codes
+ */
+template <typename IndexType>
+static bool compute_ordering(IndexType n_row, IndexType n_col, IndexType Alen, IndexType *A, IndexType *p, double knobs[NKnobs], IndexType stats[NStats])
+{
+  /* === Local variables ================================================== */
+
+  IndexType i ;     /* loop index */
+  IndexType nnz ;     /* nonzeros in A */
+  IndexType Row_size ;    /* size of Row [], in integers */
+  IndexType Col_size ;    /* size of Col [], in integers */
+  IndexType need ;      /* minimum required length of A */
+  Colamd::RowStructure<IndexType> *Row ;   /* pointer into A of Row [0..n_row] array */
+  Colamd::ColStructure<IndexType> *Col ;   /* pointer into A of Col [0..n_col] array */
+  IndexType n_col2 ;    /* number of non-dense, non-empty columns */
+  IndexType n_row2 ;    /* number of non-dense, non-empty rows */
+  IndexType ngarbage ;    /* number of garbage collections performed */
+  IndexType max_deg ;   /* maximum row degree */
+  double default_knobs [NKnobs] ; /* default knobs array */
+
+
+  /* === Check the input arguments ======================================== */
+
+  if (!stats)
+  {
+    COLAMD_DEBUG0 (("colamd: stats not present\n")) ;
+    return (false) ;
+  }
+  for (i = 0 ; i < NStats ; i++)
+  {
+    stats [i] = 0 ;
+  }
+  stats [Colamd::Status] = Colamd::Ok ;
+  stats [Colamd::Info1] = -1 ;
+  stats [Colamd::Info2] = -1 ;
+
+  if (!A)   /* A is not present */
+  {
+    stats [Colamd::Status] = Colamd::ErrorANotPresent ;
+    COLAMD_DEBUG0 (("colamd: A not present\n")) ;
+    return (false) ;
+  }
+
+  if (!p)   /* p is not present */
+  {
+    stats [Colamd::Status] = Colamd::ErrorPNotPresent ;
+    COLAMD_DEBUG0 (("colamd: p not present\n")) ;
+    return (false) ;
+  }
+
+  if (n_row < 0)  /* n_row must be >= 0 */
+  {
+    stats [Colamd::Status] = Colamd::ErrorNrowNegative ;
+    stats [Colamd::Info1] = n_row ;
+    COLAMD_DEBUG0 (("colamd: nrow negative %d\n", n_row)) ;
+    return (false) ;
+  }
+
+  if (n_col < 0)  /* n_col must be >= 0 */
+  {
+    stats [Colamd::Status] = Colamd::ErrorNcolNegative ;
+    stats [Colamd::Info1] = n_col ;
+    COLAMD_DEBUG0 (("colamd: ncol negative %d\n", n_col)) ;
+    return (false) ;
+  }
+
+  nnz = p [n_col] ;
+  if (nnz < 0)  /* nnz must be >= 0 */
+  {
+    stats [Colamd::Status] = Colamd::ErrorNnzNegative ;
+    stats [Colamd::Info1] = nnz ;
+    COLAMD_DEBUG0 (("colamd: number of entries negative %d\n", nnz)) ;
+    return (false) ;
+  }
+
+  if (p [0] != 0)
+  {
+    stats [Colamd::Status] = Colamd::ErrorP0Nonzero ;
+    stats [Colamd::Info1] = p [0] ;
+    COLAMD_DEBUG0 (("colamd: p[0] not zero %d\n", p [0])) ;
+    return (false) ;
+  }
+
+  /* === If no knobs, set default knobs =================================== */
+
+  if (!knobs)
+  {
+    set_defaults (default_knobs) ;
+    knobs = default_knobs ;
+  }
+
+  /* === Allocate the Row and Col arrays from array A ===================== */
+
+  Col_size = colamd_c (n_col) ;
+  Row_size = colamd_r (n_row) ;
+  need = 2*nnz + n_col + Col_size + Row_size ;
+
+  if (need > Alen)
+  {
+    /* not enough space in array A to perform the ordering */
+    stats [Colamd::Status] = Colamd::ErrorATooSmall ;
+    stats [Colamd::Info1] = need ;
+    stats [Colamd::Info2] = Alen ;
+    COLAMD_DEBUG0 (("colamd: Need Alen >= %d, given only Alen = %d\n", need,Alen));
+    return (false) ;
+  }
+
+  Alen -= Col_size + Row_size ;
+  Col = (ColStructure<IndexType> *) &A [Alen] ;
+  Row = (RowStructure<IndexType> *) &A [Alen + Col_size] ;
+
+  /* === Construct the row and column data structures ===================== */
+
+  if (!Colamd::init_rows_cols (n_row, n_col, Row, Col, A, p, stats))
+  {
+    /* input matrix is invalid */
+    COLAMD_DEBUG0 (("colamd: Matrix invalid\n")) ;
+    return (false) ;
+  }
+
+  /* === Initialize scores, kill dense rows/columns ======================= */
+
+  Colamd::init_scoring (n_row, n_col, Row, Col, A, p, knobs,
+		&n_row2, &n_col2, &max_deg) ;
+
+  /* === Order the supercolumns =========================================== */
+
+  ngarbage = Colamd::find_ordering (n_row, n_col, Alen, Row, Col, A, p,
+			    n_col2, max_deg, 2*nnz) ;
+
+  /* === Order the non-principal columns ================================== */
+
+  Colamd::order_children (n_col, Col, p) ;
+
+  /* === Return statistics in stats ======================================= */
+
+  stats [Colamd::DenseRow] = n_row - n_row2 ;
+  stats [Colamd::DenseCol] = n_col - n_col2 ;
+  stats [Colamd::DefragCount] = ngarbage ;
+  COLAMD_DEBUG0 (("colamd: done.\n")) ;
+  return (true) ;
+}
+
+/* ========================================================================== */
+/* === NON-USER-CALLABLE ROUTINES: ========================================== */
+/* ========================================================================== */
+
+/* There are no user-callable routines beyond this point in the file */
+
+/* ========================================================================== */
+/* === init_rows_cols ======================================================= */
+/* ========================================================================== */
+
+/*
+  Takes the column form of the matrix in A and creates the row form of the
+  matrix.  Also, row and column attributes are stored in the Col and Row
+  structs.  If the columns are un-sorted or contain duplicate row indices,
+  this routine will also sort and remove duplicate row indices from the
+  column form of the matrix.  Returns false if the matrix is invalid,
+  true otherwise.  Not user-callable.
+*/
+template <typename IndexType>
+static IndexType init_rows_cols  /* returns true if OK, or false otherwise */
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows of A */
+    IndexType n_col,      /* number of columns of A */
+    RowStructure<IndexType> Row [],    /* of size n_row+1 */
+    ColStructure<IndexType> Col [],    /* of size n_col+1 */
+    IndexType A [],     /* row indices of A, of size Alen */
+    IndexType p [],     /* pointers to columns in A, of size n_col+1 */
+    IndexType stats [NStats]  /* colamd statistics */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType col ;     /* a column index */
+  IndexType row ;     /* a row index */
+  IndexType *cp ;     /* a column pointer */
+  IndexType *cp_end ;   /* a pointer to the end of a column */
+  IndexType *rp ;     /* a row pointer */
+  IndexType *rp_end ;   /* a pointer to the end of a row */
+  IndexType last_row ;    /* previous row */
+
+  /* === Initialize columns, and check column pointers ==================== */
+
+  for (col = 0 ; col < n_col ; col++)
+  {
+    Col [col].start = p [col] ;
+    Col [col].length = p [col+1] - p [col] ;
+
+    if ((Col [col].length) < 0) // extra parentheses to work-around gcc bug 10200
+    {
+      /* column pointers must be non-decreasing */
+      stats [Colamd::Status] = Colamd::ErrorColLengthNegative ;
+      stats [Colamd::Info1] = col ;
+      stats [Colamd::Info2] = Col [col].length ;
+      COLAMD_DEBUG0 (("colamd: col %d length %d < 0\n", col, Col [col].length)) ;
+      return (false) ;
+    }
+
+    Col [col].shared1.thickness = 1 ;
+    Col [col].shared2.score = 0 ;
+    Col [col].shared3.prev = Empty ;
+    Col [col].shared4.degree_next = Empty ;
+  }
+
+  /* p [0..n_col] no longer needed, used as "head" in subsequent routines */
+
+  /* === Scan columns, compute row degrees, and check row indices ========= */
+
+  stats [Info3] = 0 ;  /* number of duplicate or unsorted row indices*/
+
+  for (row = 0 ; row < n_row ; row++)
+  {
+    Row [row].length = 0 ;
+    Row [row].shared2.mark = -1 ;
+  }
+
+  for (col = 0 ; col < n_col ; col++)
+  {
+    last_row = -1 ;
+
+    cp = &A [p [col]] ;
+    cp_end = &A [p [col+1]] ;
+
+    while (cp < cp_end)
+    {
+      row = *cp++ ;
+
+      /* make sure row indices within range */
+      if (row < 0 || row >= n_row)
+      {
+	stats [Colamd::Status] = Colamd::ErrorRowIndexOutOfBounds ;
+	stats [Colamd::Info1] = col ;
+	stats [Colamd::Info2] = row ;
+	stats [Colamd::Info3] = n_row ;
+	COLAMD_DEBUG0 (("colamd: row %d col %d out of bounds\n", row, col)) ;
+	return (false) ;
+      }
+
+      if (row <= last_row || Row [row].shared2.mark == col)
+      {
+	/* row index are unsorted or repeated (or both), thus col */
+	/* is jumbled.  This is a notice, not an error condition. */
+	stats [Colamd::Status] = Colamd::OkButJumbled ;
+	stats [Colamd::Info1] = col ;
+	stats [Colamd::Info2] = row ;
+	(stats [Colamd::Info3]) ++ ;
+	COLAMD_DEBUG1 (("colamd: row %d col %d unsorted/duplicate\n",row,col));
+      }
+
+      if (Row [row].shared2.mark != col)
+      {
+	Row [row].length++ ;
+      }
+      else
+      {
+	/* this is a repeated entry in the column, */
+	/* it will be removed */
+	Col [col].length-- ;
+      }
+
+      /* mark the row as having been seen in this column */
+      Row [row].shared2.mark = col ;
+
+      last_row = row ;
+    }
+  }
+
+  /* === Compute row pointers ============================================= */
+
+  /* row form of the matrix starts directly after the column */
+  /* form of matrix in A */
+  Row [0].start = p [n_col] ;
+  Row [0].shared1.p = Row [0].start ;
+  Row [0].shared2.mark = -1 ;
+  for (row = 1 ; row < n_row ; row++)
+  {
+    Row [row].start = Row [row-1].start + Row [row-1].length ;
+    Row [row].shared1.p = Row [row].start ;
+    Row [row].shared2.mark = -1 ;
+  }
+
+  /* === Create row form ================================================== */
+
+  if (stats [Status] == OkButJumbled)
+  {
+    /* if cols jumbled, watch for repeated row indices */
+    for (col = 0 ; col < n_col ; col++)
+    {
+      cp = &A [p [col]] ;
+      cp_end = &A [p [col+1]] ;
+      while (cp < cp_end)
+      {
+	row = *cp++ ;
+	if (Row [row].shared2.mark != col)
+	{
+	  A [(Row [row].shared1.p)++] = col ;
+	  Row [row].shared2.mark = col ;
+	}
+      }
+    }
+  }
+  else
+  {
+    /* if cols not jumbled, we don't need the mark (this is faster) */
+    for (col = 0 ; col < n_col ; col++)
+    {
+      cp = &A [p [col]] ;
+      cp_end = &A [p [col+1]] ;
+      while (cp < cp_end)
+      {
+	A [(Row [*cp++].shared1.p)++] = col ;
+      }
+    }
+  }
+
+  /* === Clear the row marks and set row degrees ========================== */
+
+  for (row = 0 ; row < n_row ; row++)
+  {
+    Row [row].shared2.mark = 0 ;
+    Row [row].shared1.degree = Row [row].length ;
+  }
+
+  /* === See if we need to re-create columns ============================== */
+
+  if (stats [Status] == OkButJumbled)
+  {
+    COLAMD_DEBUG0 (("colamd: reconstructing column form, matrix jumbled\n")) ;
+
+
+    /* === Compute col pointers ========================================= */
+
+    /* col form of the matrix starts at A [0]. */
+    /* Note, we may have a gap between the col form and the row */
+    /* form if there were duplicate entries, if so, it will be */
+    /* removed upon the first garbage collection */
+    Col [0].start = 0 ;
+    p [0] = Col [0].start ;
+    for (col = 1 ; col < n_col ; col++)
+    {
+      /* note that the lengths here are for pruned columns, i.e. */
+      /* no duplicate row indices will exist for these columns */
+      Col [col].start = Col [col-1].start + Col [col-1].length ;
+      p [col] = Col [col].start ;
+    }
+
+    /* === Re-create col form =========================================== */
+
+    for (row = 0 ; row < n_row ; row++)
+    {
+      rp = &A [Row [row].start] ;
+      rp_end = rp + Row [row].length ;
+      while (rp < rp_end)
+      {
+	A [(p [*rp++])++] = row ;
+      }
+    }
+  }
+
+  /* === Done.  Matrix is not (or no longer) jumbled ====================== */
+
+  return (true) ;
+}
+
+
+/* ========================================================================== */
+/* === init_scoring ========================================================= */
+/* ========================================================================== */
+
+/*
+  Kills dense or empty columns and rows, calculates an initial score for
+  each column, and places all columns in the degree lists.  Not user-callable.
+*/
+template <typename IndexType>
+static void init_scoring
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows of A */
+    IndexType n_col,      /* number of columns of A */
+    RowStructure<IndexType> Row [],    /* of size n_row+1 */
+    ColStructure<IndexType> Col [],    /* of size n_col+1 */
+    IndexType A [],     /* column form and row form of A */
+    IndexType head [],    /* of size n_col+1 */
+    double knobs [NKnobs],/* parameters */
+    IndexType *p_n_row2,    /* number of non-dense, non-empty rows */
+    IndexType *p_n_col2,    /* number of non-dense, non-empty columns */
+    IndexType *p_max_deg    /* maximum row degree */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType c ;     /* a column index */
+  IndexType r, row ;    /* a row index */
+  IndexType *cp ;     /* a column pointer */
+  IndexType deg ;     /* degree of a row or column */
+  IndexType *cp_end ;   /* a pointer to the end of a column */
+  IndexType *new_cp ;   /* new column pointer */
+  IndexType col_length ;    /* length of pruned column */
+  IndexType score ;     /* current column score */
+  IndexType n_col2 ;    /* number of non-dense, non-empty columns */
+  IndexType n_row2 ;    /* number of non-dense, non-empty rows */
+  IndexType dense_row_count ; /* remove rows with more entries than this */
+  IndexType dense_col_count ; /* remove cols with more entries than this */
+  IndexType min_score ;   /* smallest column score */
+  IndexType max_deg ;   /* maximum row degree */
+  IndexType next_col ;    /* Used to add to degree list.*/
+
+
+  /* === Extract knobs ==================================================== */
+
+  dense_row_count = numext::maxi(IndexType(0), numext::mini(IndexType(knobs [Colamd::DenseRow] * n_col), n_col)) ;
+  dense_col_count = numext::maxi(IndexType(0), numext::mini(IndexType(knobs [Colamd::DenseCol] * n_row), n_row)) ;
+  COLAMD_DEBUG1 (("colamd: densecount: %d %d\n", dense_row_count, dense_col_count)) ;
+  max_deg = 0 ;
+  n_col2 = n_col ;
+  n_row2 = n_row ;
+
+  /* === Kill empty columns =============================================== */
+
+  /* Put the empty columns at the end in their natural order, so that LU */
+  /* factorization can proceed as far as possible. */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    deg = Col [c].length ;
+    if (deg == 0)
+    {
+      /* this is a empty column, kill and order it last */
+      Col [c].shared2.order = --n_col2 ;
+      Col[c].kill_principal() ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: null columns killed: %d\n", n_col - n_col2)) ;
+
+  /* === Kill dense columns =============================================== */
+
+  /* Put the dense columns at the end, in their natural order */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    /* skip any dead columns */
+    if (Col[c].is_dead())
+    {
+      continue ;
+    }
+    deg = Col [c].length ;
+    if (deg > dense_col_count)
+    {
+      /* this is a dense column, kill and order it last */
+      Col [c].shared2.order = --n_col2 ;
+      /* decrement the row degrees */
+      cp = &A [Col [c].start] ;
+      cp_end = cp + Col [c].length ;
+      while (cp < cp_end)
+      {
+	Row [*cp++].shared1.degree-- ;
+      }
+      Col[c].kill_principal() ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: Dense and null columns killed: %d\n", n_col - n_col2)) ;
+
+  /* === Kill dense and empty rows ======================================== */
+
+  for (r = 0 ; r < n_row ; r++)
+  {
+    deg = Row [r].shared1.degree ;
+    COLAMD_ASSERT (deg >= 0 && deg <= n_col) ;
+    if (deg > dense_row_count || deg == 0)
+    {
+      /* kill a dense or empty row */
+      Row[r].kill() ;
+      --n_row2 ;
+    }
+    else
+    {
+      /* keep track of max degree of remaining rows */
+      max_deg = numext::maxi(max_deg, deg) ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: Dense and null rows killed: %d\n", n_row - n_row2)) ;
+
+  /* === Compute initial column scores ==================================== */
+
+  /* At this point the row degrees are accurate.  They reflect the number */
+  /* of "live" (non-dense) columns in each row.  No empty rows exist. */
+  /* Some "live" columns may contain only dead rows, however.  These are */
+  /* pruned in the code below. */
+
+  /* now find the initial matlab score for each column */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    /* skip dead column */
+    if (Col[c].is_dead())
+    {
+      continue ;
+    }
+    score = 0 ;
+    cp = &A [Col [c].start] ;
+    new_cp = cp ;
+    cp_end = cp + Col [c].length ;
+    while (cp < cp_end)
+    {
+      /* get a row */
+      row = *cp++ ;
+      /* skip if dead */
+      if (Row[row].is_dead())
+      {
+	continue ;
+      }
+      /* compact the column */
+      *new_cp++ = row ;
+      /* add row's external degree */
+      score += Row [row].shared1.degree - 1 ;
+      /* guard against integer overflow */
+      score = numext::mini(score, n_col) ;
+    }
+    /* determine pruned column length */
+    col_length = (IndexType) (new_cp - &A [Col [c].start]) ;
+    if (col_length == 0)
+    {
+      /* a newly-made null column (all rows in this col are "dense" */
+      /* and have already been killed) */
+      COLAMD_DEBUG2 (("Newly null killed: %d\n", c)) ;
+      Col [c].shared2.order = --n_col2 ;
+      Col[c].kill_principal() ;
+    }
+    else
+    {
+      /* set column length and set score */
+      COLAMD_ASSERT (score >= 0) ;
+      COLAMD_ASSERT (score <= n_col) ;
+      Col [c].length = col_length ;
+      Col [c].shared2.score = score ;
+    }
+  }
+  COLAMD_DEBUG1 (("colamd: Dense, null, and newly-null columns killed: %d\n",
+		  n_col-n_col2)) ;
+
+  /* At this point, all empty rows and columns are dead.  All live columns */
+  /* are "clean" (containing no dead rows) and simplicial (no supercolumns */
+  /* yet).  Rows may contain dead columns, but all live rows contain at */
+  /* least one live column. */
+
+  /* === Initialize degree lists ========================================== */
+
+
+  /* clear the hash buckets */
+  for (c = 0 ; c <= n_col ; c++)
+  {
+    head [c] = Empty ;
+  }
+  min_score = n_col ;
+  /* place in reverse order, so low column indices are at the front */
+  /* of the lists.  This is to encourage natural tie-breaking */
+  for (c = n_col-1 ; c >= 0 ; c--)
+  {
+    /* only add principal columns to degree lists */
+    if (Col[c].is_alive())
+    {
+      COLAMD_DEBUG4 (("place %d score %d minscore %d ncol %d\n",
+		      c, Col [c].shared2.score, min_score, n_col)) ;
+
+      /* === Add columns score to DList =============================== */
+
+      score = Col [c].shared2.score ;
+
+      COLAMD_ASSERT (min_score >= 0) ;
+      COLAMD_ASSERT (min_score <= n_col) ;
+      COLAMD_ASSERT (score >= 0) ;
+      COLAMD_ASSERT (score <= n_col) ;
+      COLAMD_ASSERT (head [score] >= Empty) ;
+
+      /* now add this column to dList at proper score location */
+      next_col = head [score] ;
+      Col [c].shared3.prev = Empty ;
+      Col [c].shared4.degree_next = next_col ;
+
+      /* if there already was a column with the same score, set its */
+      /* previous pointer to this new column */
+      if (next_col != Empty)
+      {
+	Col [next_col].shared3.prev = c ;
+      }
+      head [score] = c ;
+
+      /* see if this score is less than current min */
+      min_score = numext::mini(min_score, score) ;
+
+
+    }
+  }
+
+
+  /* === Return number of remaining columns, and max row degree =========== */
+
+  *p_n_col2 = n_col2 ;
+  *p_n_row2 = n_row2 ;
+  *p_max_deg = max_deg ;
+}
+
+
+/* ========================================================================== */
+/* === find_ordering ======================================================== */
+/* ========================================================================== */
+
+/*
+  Order the principal columns of the supercolumn form of the matrix
+  (no supercolumns on input).  Uses a minimum approximate column minimum
+  degree ordering method.  Not user-callable.
+*/
+template <typename IndexType>
+static IndexType find_ordering /* return the number of garbage collections */
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows of A */
+    IndexType n_col,      /* number of columns of A */
+    IndexType Alen,     /* size of A, 2*nnz + n_col or larger */
+    RowStructure<IndexType> Row [],    /* of size n_row+1 */
+    ColStructure<IndexType> Col [],    /* of size n_col+1 */
+    IndexType A [],     /* column form and row form of A */
+    IndexType head [],    /* of size n_col+1 */
+    IndexType n_col2,     /* Remaining columns to order */
+    IndexType max_deg,    /* Maximum row degree */
+    IndexType pfree     /* index of first free slot (2*nnz on entry) */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType k ;     /* current pivot ordering step */
+  IndexType pivot_col ;   /* current pivot column */
+  IndexType *cp ;     /* a column pointer */
+  IndexType *rp ;     /* a row pointer */
+  IndexType pivot_row ;   /* current pivot row */
+  IndexType *new_cp ;   /* modified column pointer */
+  IndexType *new_rp ;   /* modified row pointer */
+  IndexType pivot_row_start ; /* pointer to start of pivot row */
+  IndexType pivot_row_degree ;  /* number of columns in pivot row */
+  IndexType pivot_row_length ;  /* number of supercolumns in pivot row */
+  IndexType pivot_col_score ; /* score of pivot column */
+  IndexType needed_memory ;   /* free space needed for pivot row */
+  IndexType *cp_end ;   /* pointer to the end of a column */
+  IndexType *rp_end ;   /* pointer to the end of a row */
+  IndexType row ;     /* a row index */
+  IndexType col ;     /* a column index */
+  IndexType max_score ;   /* maximum possible score */
+  IndexType cur_score ;   /* score of current column */
+  unsigned int hash ;   /* hash value for supernode detection */
+  IndexType head_column ;   /* head of hash bucket */
+  IndexType first_col ;   /* first column in hash bucket */
+  IndexType tag_mark ;    /* marker value for mark array */
+  IndexType row_mark ;    /* Row [row].shared2.mark */
+  IndexType set_difference ;  /* set difference size of row with pivot row */
+  IndexType min_score ;   /* smallest column score */
+  IndexType col_thickness ;   /* "thickness" (no. of columns in a supercol) */
+  IndexType max_mark ;    /* maximum value of tag_mark */
+  IndexType pivot_col_thickness ; /* number of columns represented by pivot col */
+  IndexType prev_col ;    /* Used by Dlist operations. */
+  IndexType next_col ;    /* Used by Dlist operations. */
+  IndexType ngarbage ;    /* number of garbage collections performed */
+
+
+  /* === Initialization and clear mark ==================================== */
+
+  max_mark = INT_MAX - n_col ;  /* INT_MAX defined in <limits.h> */
+  tag_mark = Colamd::clear_mark (n_row, Row) ;
+  min_score = 0 ;
+  ngarbage = 0 ;
+  COLAMD_DEBUG1 (("colamd: Ordering, n_col2=%d\n", n_col2)) ;
+
+  /* === Order the columns ================================================ */
+
+  for (k = 0 ; k < n_col2 ; /* 'k' is incremented below */)
+  {
+
+    /* === Select pivot column, and order it ============================ */
+
+    /* make sure degree list isn't empty */
+    COLAMD_ASSERT (min_score >= 0) ;
+    COLAMD_ASSERT (min_score <= n_col) ;
+    COLAMD_ASSERT (head [min_score] >= Empty) ;
+
+    /* get pivot column from head of minimum degree list */
+    while (min_score < n_col && head [min_score] == Empty)
+    {
+      min_score++ ;
+    }
+    pivot_col = head [min_score] ;
+    COLAMD_ASSERT (pivot_col >= 0 && pivot_col <= n_col) ;
+    next_col = Col [pivot_col].shared4.degree_next ;
+    head [min_score] = next_col ;
+    if (next_col != Empty)
+    {
+      Col [next_col].shared3.prev = Empty ;
+    }
+
+    COLAMD_ASSERT (Col[pivot_col].is_alive()) ;
+    COLAMD_DEBUG3 (("Pivot col: %d\n", pivot_col)) ;
+
+    /* remember score for defrag check */
+    pivot_col_score = Col [pivot_col].shared2.score ;
+
+    /* the pivot column is the kth column in the pivot order */
+    Col [pivot_col].shared2.order = k ;
+
+    /* increment order count by column thickness */
+    pivot_col_thickness = Col [pivot_col].shared1.thickness ;
+    k += pivot_col_thickness ;
+    COLAMD_ASSERT (pivot_col_thickness > 0) ;
+
+    /* === Garbage_collection, if necessary ============================= */
+
+    needed_memory = numext::mini(pivot_col_score, n_col - k) ;
+    if (pfree + needed_memory >= Alen)
+    {
+      pfree = Colamd::garbage_collection (n_row, n_col, Row, Col, A, &A [pfree]) ;
+      ngarbage++ ;
+      /* after garbage collection we will have enough */
+      COLAMD_ASSERT (pfree + needed_memory < Alen) ;
+      /* garbage collection has wiped out the Row[].shared2.mark array */
+      tag_mark = Colamd::clear_mark (n_row, Row) ;
+
+    }
+
+    /* === Compute pivot row pattern ==================================== */
+
+    /* get starting location for this new merged row */
+    pivot_row_start = pfree ;
+
+    /* initialize new row counts to zero */
+    pivot_row_degree = 0 ;
+
+    /* tag pivot column as having been visited so it isn't included */
+    /* in merged pivot row */
+    Col [pivot_col].shared1.thickness = -pivot_col_thickness ;
+
+    /* pivot row is the union of all rows in the pivot column pattern */
+    cp = &A [Col [pivot_col].start] ;
+    cp_end = cp + Col [pivot_col].length ;
+    while (cp < cp_end)
+    {
+      /* get a row */
+      row = *cp++ ;
+      COLAMD_DEBUG4 (("Pivot col pattern %d %d\n", Row[row].is_alive(), row)) ;
+      /* skip if row is dead */
+      if (Row[row].is_dead())
+      {
+	continue ;
+      }
+      rp = &A [Row [row].start] ;
+      rp_end = rp + Row [row].length ;
+      while (rp < rp_end)
+      {
+	/* get a column */
+	col = *rp++ ;
+	/* add the column, if alive and untagged */
+	col_thickness = Col [col].shared1.thickness ;
+	if (col_thickness > 0 && Col[col].is_alive())
+	{
+	  /* tag column in pivot row */
+	  Col [col].shared1.thickness = -col_thickness ;
+	  COLAMD_ASSERT (pfree < Alen) ;
+	  /* place column in pivot row */
+	  A [pfree++] = col ;
+	  pivot_row_degree += col_thickness ;
+	}
+      }
+    }
+
+    /* clear tag on pivot column */
+    Col [pivot_col].shared1.thickness = pivot_col_thickness ;
+    max_deg = numext::maxi(max_deg, pivot_row_degree) ;
+
+
+    /* === Kill all rows used to construct pivot row ==================== */
+
+    /* also kill pivot row, temporarily */
+    cp = &A [Col [pivot_col].start] ;
+    cp_end = cp + Col [pivot_col].length ;
+    while (cp < cp_end)
+    {
+      /* may be killing an already dead row */
+      row = *cp++ ;
+      COLAMD_DEBUG3 (("Kill row in pivot col: %d\n", row)) ;
+      Row[row].kill() ;
+    }
+
+    /* === Select a row index to use as the new pivot row =============== */
+
+    pivot_row_length = pfree - pivot_row_start ;
+    if (pivot_row_length > 0)
+    {
+      /* pick the "pivot" row arbitrarily (first row in col) */
+      pivot_row = A [Col [pivot_col].start] ;
+      COLAMD_DEBUG3 (("Pivotal row is %d\n", pivot_row)) ;
+    }
+    else
+    {
+      /* there is no pivot row, since it is of zero length */
+      pivot_row = Empty ;
+      COLAMD_ASSERT (pivot_row_length == 0) ;
+    }
+    COLAMD_ASSERT (Col [pivot_col].length > 0 || pivot_row_length == 0) ;
+
+    /* === Approximate degree computation =============================== */
+
+    /* Here begins the computation of the approximate degree.  The column */
+    /* score is the sum of the pivot row "length", plus the size of the */
+    /* set differences of each row in the column minus the pattern of the */
+    /* pivot row itself.  The column ("thickness") itself is also */
+    /* excluded from the column score (we thus use an approximate */
+    /* external degree). */
+
+    /* The time taken by the following code (compute set differences, and */
+    /* add them up) is proportional to the size of the data structure */
+    /* being scanned - that is, the sum of the sizes of each column in */
+    /* the pivot row.  Thus, the amortized time to compute a column score */
+    /* is proportional to the size of that column (where size, in this */
+    /* context, is the column "length", or the number of row indices */
+    /* in that column).  The number of row indices in a column is */
+    /* monotonically non-decreasing, from the length of the original */
+    /* column on input to colamd. */
+
+    /* === Compute set differences ====================================== */
+
+    COLAMD_DEBUG3 (("** Computing set differences phase. **\n")) ;
+
+    /* pivot row is currently dead - it will be revived later. */
+
+    COLAMD_DEBUG3 (("Pivot row: ")) ;
+    /* for each column in pivot row */
+    rp = &A [pivot_row_start] ;
+    rp_end = rp + pivot_row_length ;
+    while (rp < rp_end)
+    {
+      col = *rp++ ;
+      COLAMD_ASSERT (Col[col].is_alive() && col != pivot_col) ;
+      COLAMD_DEBUG3 (("Col: %d\n", col)) ;
+
+      /* clear tags used to construct pivot row pattern */
+      col_thickness = -Col [col].shared1.thickness ;
+      COLAMD_ASSERT (col_thickness > 0) ;
+      Col [col].shared1.thickness = col_thickness ;
+
+      /* === Remove column from degree list =========================== */
+
+      cur_score = Col [col].shared2.score ;
+      prev_col = Col [col].shared3.prev ;
+      next_col = Col [col].shared4.degree_next ;
+      COLAMD_ASSERT (cur_score >= 0) ;
+      COLAMD_ASSERT (cur_score <= n_col) ;
+      COLAMD_ASSERT (cur_score >= Empty) ;
+      if (prev_col == Empty)
+      {
+	head [cur_score] = next_col ;
+      }
+      else
+      {
+	Col [prev_col].shared4.degree_next = next_col ;
+      }
+      if (next_col != Empty)
+      {
+	Col [next_col].shared3.prev = prev_col ;
+      }
+
+      /* === Scan the column ========================================== */
+
+      cp = &A [Col [col].start] ;
+      cp_end = cp + Col [col].length ;
+      while (cp < cp_end)
+      {
+	/* get a row */
+	row = *cp++ ;
+	/* skip if dead */
+	if (Row[row].is_dead())
+	{
+	  continue ;
+	}
+  row_mark = Row [row].shared2.mark ;
+	COLAMD_ASSERT (row != pivot_row) ;
+	set_difference = row_mark - tag_mark ;
+	/* check if the row has been seen yet */
+	if (set_difference < 0)
+	{
+	  COLAMD_ASSERT (Row [row].shared1.degree <= max_deg) ;
+	  set_difference = Row [row].shared1.degree ;
+	}
+	/* subtract column thickness from this row's set difference */
+	set_difference -= col_thickness ;
+	COLAMD_ASSERT (set_difference >= 0) ;
+	/* absorb this row if the set difference becomes zero */
+	if (set_difference == 0)
+	{
+	  COLAMD_DEBUG3 (("aggressive absorption. Row: %d\n", row)) ;
+	  Row[row].kill() ;
+	}
+	else
+	{
+	  /* save the new mark */
+	  Row [row].shared2.mark = set_difference + tag_mark ;
+	}
+      }
+    }
+
+
+    /* === Add up set differences for each column ======================= */
+
+    COLAMD_DEBUG3 (("** Adding set differences phase. **\n")) ;
+
+    /* for each column in pivot row */
+    rp = &A [pivot_row_start] ;
+    rp_end = rp + pivot_row_length ;
+    while (rp < rp_end)
+    {
+      /* get a column */
+      col = *rp++ ;
+      COLAMD_ASSERT (Col[col].is_alive() && col != pivot_col) ;
+      hash = 0 ;
+      cur_score = 0 ;
+      cp = &A [Col [col].start] ;
+      /* compact the column */
+      new_cp = cp ;
+      cp_end = cp + Col [col].length ;
+
+      COLAMD_DEBUG4 (("Adding set diffs for Col: %d.\n", col)) ;
+
+      while (cp < cp_end)
+      {
+	/* get a row */
+	row = *cp++ ;
+	COLAMD_ASSERT(row >= 0 && row < n_row) ;
+	/* skip if dead */
+	if (Row [row].is_dead())
+	{
+	  continue ;
+	}
+  row_mark = Row [row].shared2.mark ;
+	COLAMD_ASSERT (row_mark > tag_mark) ;
+	/* compact the column */
+	*new_cp++ = row ;
+	/* compute hash function */
+	hash += row ;
+	/* add set difference */
+	cur_score += row_mark - tag_mark ;
+	/* integer overflow... */
+	cur_score = numext::mini(cur_score, n_col) ;
+      }
+
+      /* recompute the column's length */
+      Col [col].length = (IndexType) (new_cp - &A [Col [col].start]) ;
+
+      /* === Further mass elimination ================================= */
+
+      if (Col [col].length == 0)
+      {
+	COLAMD_DEBUG4 (("further mass elimination. Col: %d\n", col)) ;
+	/* nothing left but the pivot row in this column */
+	Col[col].kill_principal() ;
+	pivot_row_degree -= Col [col].shared1.thickness ;
+	COLAMD_ASSERT (pivot_row_degree >= 0) ;
+	/* order it */
+	Col [col].shared2.order = k ;
+	/* increment order count by column thickness */
+	k += Col [col].shared1.thickness ;
+      }
+      else
+      {
+	/* === Prepare for supercolumn detection ==================== */
+
+	COLAMD_DEBUG4 (("Preparing supercol detection for Col: %d.\n", col)) ;
+
+	/* save score so far */
+	Col [col].shared2.score = cur_score ;
+
+	/* add column to hash table, for supercolumn detection */
+	hash %= n_col + 1 ;
+
+	COLAMD_DEBUG4 ((" Hash = %d, n_col = %d.\n", hash, n_col)) ;
+	COLAMD_ASSERT (hash <= n_col) ;
+
+	head_column = head [hash] ;
+	if (head_column > Empty)
+	{
+	  /* degree list "hash" is non-empty, use prev (shared3) of */
+	  /* first column in degree list as head of hash bucket */
+	  first_col = Col [head_column].shared3.headhash ;
+	  Col [head_column].shared3.headhash = col ;
+	}
+	else
+	{
+	  /* degree list "hash" is empty, use head as hash bucket */
+	  first_col = - (head_column + 2) ;
+	  head [hash] = - (col + 2) ;
+	}
+	Col [col].shared4.hash_next = first_col ;
+
+	/* save hash function in Col [col].shared3.hash */
+	Col [col].shared3.hash = (IndexType) hash ;
+	COLAMD_ASSERT (Col[col].is_alive()) ;
+      }
+    }
+
+    /* The approximate external column degree is now computed.  */
+
+    /* === Supercolumn detection ======================================== */
+
+    COLAMD_DEBUG3 (("** Supercolumn detection phase. **\n")) ;
+
+    Colamd::detect_super_cols (Col, A, head, pivot_row_start, pivot_row_length) ;
+
+    /* === Kill the pivotal column ====================================== */
+
+    Col[pivot_col].kill_principal() ;
+
+    /* === Clear mark =================================================== */
+
+    tag_mark += (max_deg + 1) ;
+    if (tag_mark >= max_mark)
+    {
+      COLAMD_DEBUG2 (("clearing tag_mark\n")) ;
+      tag_mark = Colamd::clear_mark (n_row, Row) ;
+    }
+
+    /* === Finalize the new pivot row, and column scores ================ */
+
+    COLAMD_DEBUG3 (("** Finalize scores phase. **\n")) ;
+
+    /* for each column in pivot row */
+    rp = &A [pivot_row_start] ;
+    /* compact the pivot row */
+    new_rp = rp ;
+    rp_end = rp + pivot_row_length ;
+    while (rp < rp_end)
+    {
+      col = *rp++ ;
+      /* skip dead columns */
+      if (Col[col].is_dead())
+      {
+	continue ;
+      }
+      *new_rp++ = col ;
+      /* add new pivot row to column */
+      A [Col [col].start + (Col [col].length++)] = pivot_row ;
+
+      /* retrieve score so far and add on pivot row's degree. */
+      /* (we wait until here for this in case the pivot */
+      /* row's degree was reduced due to mass elimination). */
+      cur_score = Col [col].shared2.score + pivot_row_degree ;
+
+      /* calculate the max possible score as the number of */
+      /* external columns minus the 'k' value minus the */
+      /* columns thickness */
+      max_score = n_col - k - Col [col].shared1.thickness ;
+
+      /* make the score the external degree of the union-of-rows */
+      cur_score -= Col [col].shared1.thickness ;
+
+      /* make sure score is less or equal than the max score */
+      cur_score = numext::mini(cur_score, max_score) ;
+      COLAMD_ASSERT (cur_score >= 0) ;
+
+      /* store updated score */
+      Col [col].shared2.score = cur_score ;
+
+      /* === Place column back in degree list ========================= */
+
+      COLAMD_ASSERT (min_score >= 0) ;
+      COLAMD_ASSERT (min_score <= n_col) ;
+      COLAMD_ASSERT (cur_score >= 0) ;
+      COLAMD_ASSERT (cur_score <= n_col) ;
+      COLAMD_ASSERT (head [cur_score] >= Empty) ;
+      next_col = head [cur_score] ;
+      Col [col].shared4.degree_next = next_col ;
+      Col [col].shared3.prev = Empty ;
+      if (next_col != Empty)
+      {
+	Col [next_col].shared3.prev = col ;
+      }
+      head [cur_score] = col ;
+
+      /* see if this score is less than current min */
+      min_score = numext::mini(min_score, cur_score) ;
+
+    }
+
+    /* === Resurrect the new pivot row ================================== */
+
+    if (pivot_row_degree > 0)
+    {
+      /* update pivot row length to reflect any cols that were killed */
+      /* during super-col detection and mass elimination */
+      Row [pivot_row].start  = pivot_row_start ;
+      Row [pivot_row].length = (IndexType) (new_rp - &A[pivot_row_start]) ;
+      Row [pivot_row].shared1.degree = pivot_row_degree ;
+      Row [pivot_row].shared2.mark = 0 ;
+      /* pivot row is no longer dead */
+    }
+  }
+
+  /* === All principal columns have now been ordered ====================== */
+
+  return (ngarbage) ;
+}
+
+
+/* ========================================================================== */
+/* === order_children ======================================================= */
+/* ========================================================================== */
+
+/*
+  The find_ordering routine has ordered all of the principal columns (the
+  representatives of the supercolumns).  The non-principal columns have not
+  yet been ordered.  This routine orders those columns by walking up the
+  parent tree (a column is a child of the column which absorbed it).  The
+  final permutation vector is then placed in p [0 ... n_col-1], with p [0]
+  being the first column, and p [n_col-1] being the last.  It doesn't look
+  like it at first glance, but be assured that this routine takes time linear
+  in the number of columns.  Although not immediately obvious, the time
+  taken by this routine is O (n_col), that is, linear in the number of
+  columns.  Not user-callable.
+*/
+template <typename IndexType>
+static inline  void order_children
+(
+  /* === Parameters ======================================================= */
+
+  IndexType n_col,      /* number of columns of A */
+  ColStructure<IndexType> Col [],    /* of size n_col+1 */
+  IndexType p []      /* p [0 ... n_col-1] is the column permutation*/
+  )
+{
+  /* === Local variables ================================================== */
+
+  IndexType i ;     /* loop counter for all columns */
+  IndexType c ;     /* column index */
+  IndexType parent ;    /* index of column's parent */
+  IndexType order ;     /* column's order */
+
+  /* === Order each non-principal column ================================== */
+
+  for (i = 0 ; i < n_col ; i++)
+  {
+    /* find an un-ordered non-principal column */
+    COLAMD_ASSERT (col_is_dead(Col, i)) ;
+    if (!Col[i].is_dead_principal() && Col [i].shared2.order == Empty)
+    {
+      parent = i ;
+      /* once found, find its principal parent */
+      do
+      {
+	parent = Col [parent].shared1.parent ;
+      } while (!Col[parent].is_dead_principal()) ;
+
+      /* now, order all un-ordered non-principal columns along path */
+      /* to this parent.  collapse tree at the same time */
+      c = i ;
+      /* get order of parent */
+      order = Col [parent].shared2.order ;
+
+      do
+      {
+	COLAMD_ASSERT (Col [c].shared2.order == Empty) ;
+
+	/* order this column */
+	Col [c].shared2.order = order++ ;
+	/* collaps tree */
+	Col [c].shared1.parent = parent ;
+
+	/* get immediate parent of this column */
+	c = Col [c].shared1.parent ;
+
+	/* continue until we hit an ordered column.  There are */
+	/* guaranteed not to be anymore unordered columns */
+	/* above an ordered column */
+      } while (Col [c].shared2.order == Empty) ;
+
+      /* re-order the super_col parent to largest order for this group */
+      Col [parent].shared2.order = order ;
+    }
+  }
+
+  /* === Generate the permutation ========================================= */
+
+  for (c = 0 ; c < n_col ; c++)
+  {
+    p [Col [c].shared2.order] = c ;
+  }
+}
+
+
+/* ========================================================================== */
+/* === detect_super_cols ==================================================== */
+/* ========================================================================== */
+
+/*
+  Detects supercolumns by finding matches between columns in the hash buckets.
+  Check amongst columns in the set A [row_start ... row_start + row_length-1].
+  The columns under consideration are currently *not* in the degree lists,
+  and have already been placed in the hash buckets.
+
+  The hash bucket for columns whose hash function is equal to h is stored
+  as follows:
+
+  if head [h] is >= 0, then head [h] contains a degree list, so:
+
+  head [h] is the first column in degree bucket h.
+  Col [head [h]].headhash gives the first column in hash bucket h.
+
+  otherwise, the degree list is empty, and:
+
+  -(head [h] + 2) is the first column in hash bucket h.
+
+  For a column c in a hash bucket, Col [c].shared3.prev is NOT a "previous
+  column" pointer.  Col [c].shared3.hash is used instead as the hash number
+  for that column.  The value of Col [c].shared4.hash_next is the next column
+  in the same hash bucket.
+
+  Assuming no, or "few" hash collisions, the time taken by this routine is
+  linear in the sum of the sizes (lengths) of each column whose score has
+  just been computed in the approximate degree computation.
+  Not user-callable.
+*/
+template <typename IndexType>
+static void detect_super_cols
+(
+  /* === Parameters ======================================================= */
+
+  ColStructure<IndexType> Col [],    /* of size n_col+1 */
+  IndexType A [],     /* row indices of A */
+  IndexType head [],    /* head of degree lists and hash buckets */
+  IndexType row_start,    /* pointer to set of columns to check */
+  IndexType row_length    /* number of columns to check */
+)
+{
+  /* === Local variables ================================================== */
+
+  IndexType hash ;      /* hash value for a column */
+  IndexType *rp ;     /* pointer to a row */
+  IndexType c ;     /* a column index */
+  IndexType super_c ;   /* column index of the column to absorb into */
+  IndexType *cp1 ;      /* column pointer for column super_c */
+  IndexType *cp2 ;      /* column pointer for column c */
+  IndexType length ;    /* length of column super_c */
+  IndexType prev_c ;    /* column preceding c in hash bucket */
+  IndexType i ;     /* loop counter */
+  IndexType *rp_end ;   /* pointer to the end of the row */
+  IndexType col ;     /* a column index in the row to check */
+  IndexType head_column ;   /* first column in hash bucket or degree list */
+  IndexType first_col ;   /* first column in hash bucket */
+
+  /* === Consider each column in the row ================================== */
+
+  rp = &A [row_start] ;
+  rp_end = rp + row_length ;
+  while (rp < rp_end)
+  {
+    col = *rp++ ;
+    if (Col[col].is_dead())
+    {
+      continue ;
+    }
+
+    /* get hash number for this column */
+    hash = Col [col].shared3.hash ;
+    COLAMD_ASSERT (hash <= n_col) ;
+
+    /* === Get the first column in this hash bucket ===================== */
+
+    head_column = head [hash] ;
+    if (head_column > Empty)
+    {
+      first_col = Col [head_column].shared3.headhash ;
+    }
+    else
+    {
+      first_col = - (head_column + 2) ;
+    }
+
+    /* === Consider each column in the hash bucket ====================== */
+
+    for (super_c = first_col ; super_c != Empty ;
+	 super_c = Col [super_c].shared4.hash_next)
+    {
+      COLAMD_ASSERT (Col [super_c].is_alive()) ;
+      COLAMD_ASSERT (Col [super_c].shared3.hash == hash) ;
+      length = Col [super_c].length ;
+
+      /* prev_c is the column preceding column c in the hash bucket */
+      prev_c = super_c ;
+
+      /* === Compare super_c with all columns after it ================ */
+
+      for (c = Col [super_c].shared4.hash_next ;
+	   c != Empty ; c = Col [c].shared4.hash_next)
+      {
+	COLAMD_ASSERT (c != super_c) ;
+	COLAMD_ASSERT (Col[c].is_alive()) ;
+	COLAMD_ASSERT (Col [c].shared3.hash == hash) ;
+
+	/* not identical if lengths or scores are different */
+	if (Col [c].length != length ||
+	    Col [c].shared2.score != Col [super_c].shared2.score)
+	{
+	  prev_c = c ;
+	  continue ;
+	}
+
+	/* compare the two columns */
+	cp1 = &A [Col [super_c].start] ;
+	cp2 = &A [Col [c].start] ;
+
+	for (i = 0 ; i < length ; i++)
+	{
+	  /* the columns are "clean" (no dead rows) */
+	  COLAMD_ASSERT ( cp1->is_alive() );
+	  COLAMD_ASSERT ( cp2->is_alive() );
+	  /* row indices will same order for both supercols, */
+	  /* no gather scatter necessary */
+	  if (*cp1++ != *cp2++)
+	  {
+	    break ;
+	  }
+	}
+
+	/* the two columns are different if the for-loop "broke" */
+	if (i != length)
+	{
+	  prev_c = c ;
+	  continue ;
+	}
+
+	/* === Got it!  two columns are identical =================== */
+
+	COLAMD_ASSERT (Col [c].shared2.score == Col [super_c].shared2.score) ;
+
+	Col [super_c].shared1.thickness += Col [c].shared1.thickness ;
+	Col [c].shared1.parent = super_c ;
+	Col[c].kill_non_principal() ;
+	/* order c later, in order_children() */
+	Col [c].shared2.order = Empty ;
+	/* remove c from hash bucket */
+	Col [prev_c].shared4.hash_next = Col [c].shared4.hash_next ;
+      }
+    }
+
+    /* === Empty this hash bucket ======================================= */
+
+    if (head_column > Empty)
+    {
+      /* corresponding degree list "hash" is not empty */
+      Col [head_column].shared3.headhash = Empty ;
+    }
+    else
+    {
+      /* corresponding degree list "hash" is empty */
+      head [hash] = Empty ;
+    }
+  }
+}
+
+
+/* ========================================================================== */
+/* === garbage_collection =================================================== */
+/* ========================================================================== */
+
+/*
+  Defragments and compacts columns and rows in the workspace A.  Used when
+  all available memory has been used while performing row merging.  Returns
+  the index of the first free position in A, after garbage collection.  The
+  time taken by this routine is linear is the size of the array A, which is
+  itself linear in the number of nonzeros in the input matrix.
+  Not user-callable.
+*/
+template <typename IndexType>
+static IndexType garbage_collection  /* returns the new value of pfree */
+  (
+    /* === Parameters ======================================================= */
+
+    IndexType n_row,      /* number of rows */
+    IndexType n_col,      /* number of columns */
+    RowStructure<IndexType> Row [],    /* row info */
+    ColStructure<IndexType> Col [],    /* column info */
+    IndexType A [],     /* A [0 ... Alen-1] holds the matrix */
+    IndexType *pfree      /* &A [0] ... pfree is in use */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType *psrc ;     /* source pointer */
+  IndexType *pdest ;    /* destination pointer */
+  IndexType j ;     /* counter */
+  IndexType r ;     /* a row index */
+  IndexType c ;     /* a column index */
+  IndexType length ;    /* length of a row or column */
+
+  /* === Defragment the columns =========================================== */
+
+  pdest = &A[0] ;
+  for (c = 0 ; c < n_col ; c++)
+  {
+    if (Col[c].is_alive())
+    {
+      psrc = &A [Col [c].start] ;
+
+      /* move and compact the column */
+      COLAMD_ASSERT (pdest <= psrc) ;
+      Col [c].start = (IndexType) (pdest - &A [0]) ;
+      length = Col [c].length ;
+      for (j = 0 ; j < length ; j++)
+      {
+	r = *psrc++ ;
+	if (Row[r].is_alive())
+	{
+	  *pdest++ = r ;
+	}
+      }
+      Col [c].length = (IndexType) (pdest - &A [Col [c].start]) ;
+    }
+  }
+
+  /* === Prepare to defragment the rows =================================== */
+
+  for (r = 0 ; r < n_row ; r++)
+  {
+    if (Row[r].is_alive())
+    {
+      if (Row [r].length == 0)
+      {
+        /* this row is of zero length.  cannot compact it, so kill it */
+        COLAMD_DEBUG3 (("Defrag row kill\n")) ;
+        Row[r].kill() ;
+      }
+      else
+      {
+        /* save first column index in Row [r].shared2.first_column */
+        psrc = &A [Row [r].start] ;
+        Row [r].shared2.first_column = *psrc ;
+        COLAMD_ASSERT (Row[r].is_alive()) ;
+        /* flag the start of the row with the one's complement of row */
+        *psrc = ones_complement(r) ;
+
+      }
+    }
+  }
+
+  /* === Defragment the rows ============================================== */
+
+  psrc = pdest ;
+  while (psrc < pfree)
+  {
+    /* find a negative number ... the start of a row */
+    if (*psrc++ < 0)
+    {
+      psrc-- ;
+      /* get the row index */
+      r = ones_complement(*psrc) ;
+      COLAMD_ASSERT (r >= 0 && r < n_row) ;
+      /* restore first column index */
+      *psrc = Row [r].shared2.first_column ;
+      COLAMD_ASSERT (Row[r].is_alive()) ;
+
+      /* move and compact the row */
+      COLAMD_ASSERT (pdest <= psrc) ;
+      Row [r].start = (IndexType) (pdest - &A [0]) ;
+      length = Row [r].length ;
+      for (j = 0 ; j < length ; j++)
+      {
+	c = *psrc++ ;
+	if (Col[c].is_alive())
+	{
+	  *pdest++ = c ;
+	}
+      }
+      Row [r].length = (IndexType) (pdest - &A [Row [r].start]) ;
+
+    }
+  }
+  /* ensure we found all the rows */
+  COLAMD_ASSERT (debug_rows == 0) ;
+
+  /* === Return the new value of pfree ==================================== */
+
+  return ((IndexType) (pdest - &A [0])) ;
+}
+
+
+/* ========================================================================== */
+/* === clear_mark =========================================================== */
+/* ========================================================================== */
+
+/*
+  Clears the Row [].shared2.mark array, and returns the new tag_mark.
+  Return value is the new tag_mark.  Not user-callable.
+*/
+template <typename IndexType>
+static inline  IndexType clear_mark  /* return the new value for tag_mark */
+  (
+      /* === Parameters ======================================================= */
+
+    IndexType n_row,    /* number of rows in A */
+    RowStructure<IndexType> Row [] /* Row [0 ... n_row-1].shared2.mark is set to zero */
+    )
+{
+  /* === Local variables ================================================== */
+
+  IndexType r ;
+
+  for (r = 0 ; r < n_row ; r++)
+  {
+    if (Row[r].is_alive())
+    {
+      Row [r].shared2.mark = 0 ;
+    }
+  }
+  return (1) ;
+}
+
+} // namespace Colamd
+
+} // namespace internal
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/OrderingMethods/Ordering.h b/C++/yolo_bytetrack_old/include/Eigen/src/OrderingMethods/Ordering.h
new file mode 100644
index 00000000..c5789701
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/OrderingMethods/Ordering.h
@@ -0,0 +1,153 @@
+ 
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012  Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ORDERING_H
+#define EIGEN_ORDERING_H
+
+namespace Eigen {
+  
+#include "Eigen_Colamd.h"
+
+namespace internal {
+    
+/** \internal
+  * \ingroup OrderingMethods_Module
+  * \param[in] A the input non-symmetric matrix
+  * \param[out] symmat the symmetric pattern A^T+A from the input matrix \a A.
+  * FIXME: The values should not be considered here
+  */
+template<typename MatrixType> 
+void ordering_helper_at_plus_a(const MatrixType& A, MatrixType& symmat)
+{
+  MatrixType C;
+  C = A.transpose(); // NOTE: Could be  costly
+  for (int i = 0; i < C.rows(); i++) 
+  {
+      for (typename MatrixType::InnerIterator it(C, i); it; ++it)
+        it.valueRef() = typename MatrixType::Scalar(0);
+  }
+  symmat = C + A;
+}
+    
+}
+
+/** \ingroup OrderingMethods_Module
+  * \class AMDOrdering
+  *
+  * Functor computing the \em approximate \em minimum \em degree ordering
+  * If the matrix is not structurally symmetric, an ordering of A^T+A is computed
+  * \tparam  StorageIndex The type of indices of the matrix 
+  * \sa COLAMDOrdering
+  */
+template <typename StorageIndex>
+class AMDOrdering
+{
+  public:
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+    
+    /** Compute the permutation vector from a sparse matrix
+     * This routine is much faster if the input matrix is column-major     
+     */
+    template <typename MatrixType>
+    void operator()(const MatrixType& mat, PermutationType& perm)
+    {
+      // Compute the symmetric pattern
+      SparseMatrix<typename MatrixType::Scalar, ColMajor, StorageIndex> symm;
+      internal::ordering_helper_at_plus_a(mat,symm); 
+    
+      // Call the AMD routine 
+      //m_mat.prune(keep_diag());
+      internal::minimum_degree_ordering(symm, perm);
+    }
+    
+    /** Compute the permutation with a selfadjoint matrix */
+    template <typename SrcType, unsigned int SrcUpLo> 
+    void operator()(const SparseSelfAdjointView<SrcType, SrcUpLo>& mat, PermutationType& perm)
+    { 
+      SparseMatrix<typename SrcType::Scalar, ColMajor, StorageIndex> C; C = mat;
+      
+      // Call the AMD routine 
+      // m_mat.prune(keep_diag()); //Remove the diagonal elements 
+      internal::minimum_degree_ordering(C, perm);
+    }
+};
+
+/** \ingroup OrderingMethods_Module
+  * \class NaturalOrdering
+  *
+  * Functor computing the natural ordering (identity)
+  * 
+  * \note Returns an empty permutation matrix
+  * \tparam  StorageIndex The type of indices of the matrix 
+  */
+template <typename StorageIndex>
+class NaturalOrdering
+{
+  public:
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+    
+    /** Compute the permutation vector from a column-major sparse matrix */
+    template <typename MatrixType>
+    void operator()(const MatrixType& /*mat*/, PermutationType& perm)
+    {
+      perm.resize(0); 
+    }
+    
+};
+
+/** \ingroup OrderingMethods_Module
+  * \class COLAMDOrdering
+  *
+  * \tparam  StorageIndex The type of indices of the matrix 
+  * 
+  * Functor computing the \em column \em approximate \em minimum \em degree ordering 
+  * The matrix should be in column-major and \b compressed format (see SparseMatrix::makeCompressed()).
+  */
+template<typename StorageIndex>
+class COLAMDOrdering
+{
+  public:
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType; 
+    typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
+    
+    /** Compute the permutation vector \a perm form the sparse matrix \a mat
+      * \warning The input sparse matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+      */
+    template <typename MatrixType>
+    void operator() (const MatrixType& mat, PermutationType& perm)
+    {
+      eigen_assert(mat.isCompressed() && "COLAMDOrdering requires a sparse matrix in compressed mode. Call .makeCompressed() before passing it to COLAMDOrdering");
+      
+      StorageIndex m = StorageIndex(mat.rows());
+      StorageIndex n = StorageIndex(mat.cols());
+      StorageIndex nnz = StorageIndex(mat.nonZeros());
+      // Get the recommended value of Alen to be used by colamd
+      StorageIndex Alen = internal::Colamd::recommended(nnz, m, n); 
+      // Set the default parameters
+      double knobs [internal::Colamd::NKnobs]; 
+      StorageIndex stats [internal::Colamd::NStats];
+      internal::Colamd::set_defaults(knobs);
+      
+      IndexVector p(n+1), A(Alen); 
+      for(StorageIndex i=0; i <= n; i++)   p(i) = mat.outerIndexPtr()[i];
+      for(StorageIndex i=0; i < nnz; i++)  A(i) = mat.innerIndexPtr()[i];
+      // Call Colamd routine to compute the ordering 
+      StorageIndex info = internal::Colamd::compute_ordering(m, n, Alen, A.data(), p.data(), knobs, stats); 
+      EIGEN_UNUSED_VARIABLE(info);
+      eigen_assert( info && "COLAMD failed " );
+      
+      perm.resize(n);
+      for (StorageIndex i = 0; i < n; i++) perm.indices()(p(i)) = i;
+    }
+};
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/PaStiXSupport/PaStiXSupport.h b/C++/yolo_bytetrack_old/include/Eigen/src/PaStiXSupport/PaStiXSupport.h
new file mode 100644
index 00000000..37426877
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/PaStiXSupport/PaStiXSupport.h
@@ -0,0 +1,678 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PASTIXSUPPORT_H
+#define EIGEN_PASTIXSUPPORT_H
+
+namespace Eigen { 
+
+#if defined(DCOMPLEX)
+  #define PASTIX_COMPLEX  COMPLEX
+  #define PASTIX_DCOMPLEX DCOMPLEX
+#else
+  #define PASTIX_COMPLEX  std::complex<float>
+  #define PASTIX_DCOMPLEX std::complex<double>
+#endif
+
+/** \ingroup PaStiXSupport_Module
+  * \brief Interface to the PaStix solver
+  * 
+  * This class is used to solve the linear systems A.X = B via the PaStix library. 
+  * The matrix can be either real or complex, symmetric or not.
+  *
+  * \sa TutorialSparseDirectSolvers
+  */
+template<typename _MatrixType, bool IsStrSym = false> class PastixLU;
+template<typename _MatrixType, int Options> class PastixLLT;
+template<typename _MatrixType, int Options> class PastixLDLT;
+
+namespace internal
+{
+    
+  template<class Pastix> struct pastix_traits;
+
+  template<typename _MatrixType>
+  struct pastix_traits< PastixLU<_MatrixType> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pastix_traits< PastixLLT<_MatrixType,Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pastix_traits< PastixLDLT<_MatrixType,Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+  
+  inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, float *vals, int *perm, int * invp, float *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    s_pastix(pastix_data, pastix_comm, n, ptr, idx, vals, perm, invp, x, nbrhs, iparm, dparm); 
+  }
+  
+  inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, double *vals, int *perm, int * invp, double *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    d_pastix(pastix_data, pastix_comm, n, ptr, idx, vals, perm, invp, x, nbrhs, iparm, dparm); 
+  }
+  
+  inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, std::complex<float> *vals, int *perm, int * invp, std::complex<float> *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    c_pastix(pastix_data, pastix_comm, n, ptr, idx, reinterpret_cast<PASTIX_COMPLEX*>(vals), perm, invp, reinterpret_cast<PASTIX_COMPLEX*>(x), nbrhs, iparm, dparm); 
+  }
+  
+  inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, std::complex<double> *vals, int *perm, int * invp, std::complex<double> *x, int nbrhs, int *iparm, double *dparm)
+  {
+    if (n == 0) { ptr = NULL; idx = NULL; vals = NULL; }
+    if (nbrhs == 0) {x = NULL; nbrhs=1;}
+    z_pastix(pastix_data, pastix_comm, n, ptr, idx, reinterpret_cast<PASTIX_DCOMPLEX*>(vals), perm, invp, reinterpret_cast<PASTIX_DCOMPLEX*>(x), nbrhs, iparm, dparm); 
+  }
+
+  // Convert the matrix  to Fortran-style Numbering
+  template <typename MatrixType>
+  void c_to_fortran_numbering (MatrixType& mat)
+  {
+    if ( !(mat.outerIndexPtr()[0]) ) 
+    { 
+      int i;
+      for(i = 0; i <= mat.rows(); ++i)
+        ++mat.outerIndexPtr()[i];
+      for(i = 0; i < mat.nonZeros(); ++i)
+        ++mat.innerIndexPtr()[i];
+    }
+  }
+  
+  // Convert to C-style Numbering
+  template <typename MatrixType>
+  void fortran_to_c_numbering (MatrixType& mat)
+  {
+    // Check the Numbering
+    if ( mat.outerIndexPtr()[0] == 1 ) 
+    { // Convert to C-style numbering
+      int i;
+      for(i = 0; i <= mat.rows(); ++i)
+        --mat.outerIndexPtr()[i];
+      for(i = 0; i < mat.nonZeros(); ++i)
+        --mat.innerIndexPtr()[i];
+    }
+  }
+}
+
+// This is the base class to interface with PaStiX functions. 
+// Users should not used this class directly. 
+template <class Derived>
+class PastixBase : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    
+    typedef typename internal::pastix_traits<Derived>::MatrixType _MatrixType;
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef SparseMatrix<Scalar, ColMajor> ColSpMatrix;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+  public:
+    
+    PastixBase() : m_initisOk(false), m_analysisIsOk(false), m_factorizationIsOk(false), m_pastixdata(0), m_size(0)
+    {
+      init();
+    }
+    
+    ~PastixBase() 
+    {
+      clean();
+    }
+    
+    template<typename Rhs,typename Dest>
+    bool _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &x) const;
+    
+    /** Returns a reference to the integer vector IPARM of PaStiX parameters
+      * to modify the default parameters. 
+      * The statistics related to the different phases of factorization and solve are saved here as well
+      * \sa analyzePattern() factorize()
+      */
+    Array<StorageIndex,IPARM_SIZE,1>& iparm()
+    {
+      return m_iparm; 
+    }
+    
+    /** Return a reference to a particular index parameter of the IPARM vector 
+     * \sa iparm()
+     */
+    
+    int& iparm(int idxparam)
+    {
+      return m_iparm(idxparam);
+    }
+    
+     /** Returns a reference to the double vector DPARM of PaStiX parameters 
+      * The statistics related to the different phases of factorization and solve are saved here as well
+      * \sa analyzePattern() factorize()
+      */
+    Array<double,DPARM_SIZE,1>& dparm()
+    {
+      return m_dparm; 
+    }
+    
+    
+    /** Return a reference to a particular index parameter of the DPARM vector 
+     * \sa dparm()
+     */
+    double& dparm(int idxparam)
+    {
+      return m_dparm(idxparam);
+    }
+    
+    inline Index cols() const { return m_size; }
+    inline Index rows() const { return m_size; }
+    
+     /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the PaStiX reports a problem
+      *          \c InvalidInput if the input matrix is invalid
+      *
+      * \sa iparm()          
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+    
+  protected:
+
+    // Initialize the Pastix data structure, check the matrix
+    void init(); 
+    
+    // Compute the ordering and the symbolic factorization
+    void analyzePattern(ColSpMatrix& mat);
+    
+    // Compute the numerical factorization
+    void factorize(ColSpMatrix& mat);
+    
+    // Free all the data allocated by Pastix
+    void clean()
+    {
+      eigen_assert(m_initisOk && "The Pastix structure should be allocated first"); 
+      m_iparm(IPARM_START_TASK) = API_TASK_CLEAN;
+      m_iparm(IPARM_END_TASK) = API_TASK_CLEAN;
+      internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, 0, 0, 0, (Scalar*)0,
+                             m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
+    }
+    
+    void compute(ColSpMatrix& mat);
+    
+    int m_initisOk; 
+    int m_analysisIsOk;
+    int m_factorizationIsOk;
+    mutable ComputationInfo m_info; 
+    mutable pastix_data_t *m_pastixdata; // Data structure for pastix
+    mutable int m_comm; // The MPI communicator identifier
+    mutable Array<int,IPARM_SIZE,1> m_iparm; // integer vector for the input parameters
+    mutable Array<double,DPARM_SIZE,1> m_dparm; // Scalar vector for the input parameters
+    mutable Matrix<StorageIndex,Dynamic,1> m_perm;  // Permutation vector
+    mutable Matrix<StorageIndex,Dynamic,1> m_invp;  // Inverse permutation vector
+    mutable int m_size; // Size of the matrix 
+}; 
+
+ /** Initialize the PaStiX data structure. 
+   *A first call to this function fills iparm and dparm with the default PaStiX parameters
+   * \sa iparm() dparm()
+   */
+template <class Derived>
+void PastixBase<Derived>::init()
+{
+  m_size = 0; 
+  m_iparm.setZero(IPARM_SIZE);
+  m_dparm.setZero(DPARM_SIZE);
+  
+  m_iparm(IPARM_MODIFY_PARAMETER) = API_NO;
+  pastix(&m_pastixdata, MPI_COMM_WORLD,
+         0, 0, 0, 0,
+         0, 0, 0, 1, m_iparm.data(), m_dparm.data());
+  
+  m_iparm[IPARM_MATRIX_VERIFICATION] = API_NO;
+  m_iparm[IPARM_VERBOSE]             = API_VERBOSE_NOT;
+  m_iparm[IPARM_ORDERING]            = API_ORDER_SCOTCH;
+  m_iparm[IPARM_INCOMPLETE]          = API_NO;
+  m_iparm[IPARM_OOC_LIMIT]           = 2000;
+  m_iparm[IPARM_RHS_MAKING]          = API_RHS_B;
+  m_iparm(IPARM_MATRIX_VERIFICATION) = API_NO;
+  
+  m_iparm(IPARM_START_TASK) = API_TASK_INIT;
+  m_iparm(IPARM_END_TASK) = API_TASK_INIT;
+  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, 0, 0, 0, (Scalar*)0,
+                         0, 0, 0, 0, m_iparm.data(), m_dparm.data());
+  
+  // Check the returned error
+  if(m_iparm(IPARM_ERROR_NUMBER)) {
+    m_info = InvalidInput;
+    m_initisOk = false;
+  }
+  else { 
+    m_info = Success;
+    m_initisOk = true;
+  }
+}
+
+template <class Derived>
+void PastixBase<Derived>::compute(ColSpMatrix& mat)
+{
+  eigen_assert(mat.rows() == mat.cols() && "The input matrix should be squared");
+  
+  analyzePattern(mat);  
+  factorize(mat);
+  
+  m_iparm(IPARM_MATRIX_VERIFICATION) = API_NO;
+}
+
+
+template <class Derived>
+void PastixBase<Derived>::analyzePattern(ColSpMatrix& mat)
+{                         
+  eigen_assert(m_initisOk && "The initialization of PaSTiX failed");
+  
+  // clean previous calls
+  if(m_size>0)
+    clean();
+  
+  m_size = internal::convert_index<int>(mat.rows());
+  m_perm.resize(m_size);
+  m_invp.resize(m_size);
+  
+  m_iparm(IPARM_START_TASK) = API_TASK_ORDERING;
+  m_iparm(IPARM_END_TASK) = API_TASK_ANALYSE;
+  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, m_size, mat.outerIndexPtr(), mat.innerIndexPtr(),
+               mat.valuePtr(), m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
+  
+  // Check the returned error
+  if(m_iparm(IPARM_ERROR_NUMBER))
+  {
+    m_info = NumericalIssue;
+    m_analysisIsOk = false;
+  }
+  else
+  { 
+    m_info = Success;
+    m_analysisIsOk = true;
+  }
+}
+
+template <class Derived>
+void PastixBase<Derived>::factorize(ColSpMatrix& mat)
+{
+//   if(&m_cpyMat != &mat) m_cpyMat = mat;
+  eigen_assert(m_analysisIsOk && "The analysis phase should be called before the factorization phase");
+  m_iparm(IPARM_START_TASK) = API_TASK_NUMFACT;
+  m_iparm(IPARM_END_TASK) = API_TASK_NUMFACT;
+  m_size = internal::convert_index<int>(mat.rows());
+  
+  internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, m_size, mat.outerIndexPtr(), mat.innerIndexPtr(),
+               mat.valuePtr(), m_perm.data(), m_invp.data(), 0, 0, m_iparm.data(), m_dparm.data());
+  
+  // Check the returned error
+  if(m_iparm(IPARM_ERROR_NUMBER))
+  {
+    m_info = NumericalIssue;
+    m_factorizationIsOk = false;
+    m_isInitialized = false;
+  }
+  else
+  {
+    m_info = Success;
+    m_factorizationIsOk = true;
+    m_isInitialized = true;
+  }
+}
+
+/* Solve the system */
+template<typename Base>
+template<typename Rhs,typename Dest>
+bool PastixBase<Base>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &x) const
+{
+  eigen_assert(m_isInitialized && "The matrix should be factorized first");
+  EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
+                     THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  int rhs = 1;
+  
+  x = b; /* on return, x is overwritten by the computed solution */
+  
+  for (int i = 0; i < b.cols(); i++){
+    m_iparm[IPARM_START_TASK]          = API_TASK_SOLVE;
+    m_iparm[IPARM_END_TASK]            = API_TASK_REFINE;
+  
+    internal::eigen_pastix(&m_pastixdata, MPI_COMM_WORLD, internal::convert_index<int>(x.rows()), 0, 0, 0,
+                           m_perm.data(), m_invp.data(), &x(0, i), rhs, m_iparm.data(), m_dparm.data());
+  }
+  
+  // Check the returned error
+  m_info = m_iparm(IPARM_ERROR_NUMBER)==0 ? Success : NumericalIssue;
+  
+  return m_iparm(IPARM_ERROR_NUMBER)==0;
+}
+
+/** \ingroup PaStiXSupport_Module
+  * \class PastixLU
+  * \brief Sparse direct LU solver based on PaStiX library
+  * 
+  * This class is used to solve the linear systems A.X = B with a supernodal LU 
+  * factorization in the PaStiX library. The matrix A should be squared and nonsingular
+  * PaStiX requires that the matrix A has a symmetric structural pattern. 
+  * This interface can symmetrize the input matrix otherwise. 
+  * The vectors or matrices X and B can be either dense or sparse.
+  * 
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam IsStrSym Indicates if the input matrix has a symmetric pattern, default is false
+  * NOTE : Note that if the analysis and factorization phase are called separately, 
+  * the input matrix will be symmetrized at each call, hence it is advised to 
+  * symmetrize the matrix in a end-user program and set \p IsStrSym to true
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  * 
+  */
+template<typename _MatrixType, bool IsStrSym>
+class PastixLU : public PastixBase< PastixLU<_MatrixType> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef PastixBase<PastixLU<MatrixType> > Base;
+    typedef typename Base::ColSpMatrix ColSpMatrix;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    
+  public:
+    PastixLU() : Base()
+    {
+      init();
+    }
+    
+    explicit PastixLU(const MatrixType& matrix):Base()
+    {
+      init();
+      compute(matrix);
+    }
+    /** Compute the LU supernodal factorization of \p matrix. 
+      * iparm and dparm can be used to tune the PaStiX parameters. 
+      * see the PaStiX user's manual
+      * \sa analyzePattern() factorize()
+      */
+    void compute (const MatrixType& matrix)
+    {
+      m_structureIsUptodate = false;
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::compute(temp);
+    }
+    /** Compute the LU symbolic factorization of \p matrix using its sparsity pattern. 
+      * Several ordering methods can be used at this step. See the PaStiX user's manual. 
+      * The result of this operation can be used with successive matrices having the same pattern as \p matrix
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      m_structureIsUptodate = false;
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::analyzePattern(temp);
+    }
+
+    /** Compute the LU supernodal factorization of \p matrix
+      * WARNING The matrix \p matrix should have the same structural pattern 
+      * as the same used in the analysis phase.
+      * \sa analyzePattern()
+      */ 
+    void factorize(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::factorize(temp);
+    }
+  protected:
+    
+    void init()
+    {
+      m_structureIsUptodate = false;
+      m_iparm(IPARM_SYM) = API_SYM_NO;
+      m_iparm(IPARM_FACTORIZATION) = API_FACT_LU;
+    }
+    
+    void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
+    {
+      if(IsStrSym)
+        out = matrix;
+      else
+      {
+        if(!m_structureIsUptodate)
+        {
+          // update the transposed structure
+          m_transposedStructure = matrix.transpose();
+          
+          // Set the elements of the matrix to zero 
+          for (Index j=0; j<m_transposedStructure.outerSize(); ++j) 
+            for(typename ColSpMatrix::InnerIterator it(m_transposedStructure, j); it; ++it)
+              it.valueRef() = 0.0;
+
+          m_structureIsUptodate = true;
+        }
+        
+        out = m_transposedStructure + matrix;
+      }
+      internal::c_to_fortran_numbering(out);
+    }
+    
+    using Base::m_iparm;
+    using Base::m_dparm;
+    
+    ColSpMatrix m_transposedStructure;
+    bool m_structureIsUptodate;
+};
+
+/** \ingroup PaStiXSupport_Module
+  * \class PastixLLT
+  * \brief A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library
+  * 
+  * This class is used to solve the linear systems A.X = B via a LL^T supernodal Cholesky factorization
+  * available in the PaStiX library. The matrix A should be symmetric and positive definite
+  * WARNING Selfadjoint complex matrices are not supported in the current version of PaStiX
+  * The vectors or matrices X and B can be either dense or sparse
+  * 
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam UpLo The part of the matrix to use : Lower or Upper. The default is Lower as required by PaStiX
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo>
+class PastixLLT : public PastixBase< PastixLLT<_MatrixType, _UpLo> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef PastixBase<PastixLLT<MatrixType, _UpLo> > Base;
+    typedef typename Base::ColSpMatrix ColSpMatrix;
+    
+  public:
+    enum { UpLo = _UpLo };
+    PastixLLT() : Base()
+    {
+      init();
+    }
+    
+    explicit PastixLLT(const MatrixType& matrix):Base()
+    {
+      init();
+      compute(matrix);
+    }
+
+    /** Compute the L factor of the LL^T supernodal factorization of \p matrix 
+      * \sa analyzePattern() factorize()
+      */
+    void compute (const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::compute(temp);
+    }
+
+     /** Compute the LL^T symbolic factorization of \p matrix using its sparsity pattern
+      * The result of this operation can be used with successive matrices having the same pattern as \p matrix
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::analyzePattern(temp);
+    }
+      /** Compute the LL^T supernodal numerical factorization of \p matrix 
+        * \sa analyzePattern()
+        */
+    void factorize(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::factorize(temp);
+    }
+  protected:
+    using Base::m_iparm;
+    
+    void init()
+    {
+      m_iparm(IPARM_SYM) = API_SYM_YES;
+      m_iparm(IPARM_FACTORIZATION) = API_FACT_LLT;
+    }
+    
+    void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
+    {
+      out.resize(matrix.rows(), matrix.cols());
+      // Pastix supports only lower, column-major matrices 
+      out.template selfadjointView<Lower>() = matrix.template selfadjointView<UpLo>();
+      internal::c_to_fortran_numbering(out);
+    }
+};
+
+/** \ingroup PaStiXSupport_Module
+  * \class PastixLDLT
+  * \brief A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library
+  * 
+  * This class is used to solve the linear systems A.X = B via a LDL^T supernodal Cholesky factorization
+  * available in the PaStiX library. The matrix A should be symmetric and positive definite
+  * WARNING Selfadjoint complex matrices are not supported in the current version of PaStiX
+  * The vectors or matrices X and B can be either dense or sparse
+  * 
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam UpLo The part of the matrix to use : Lower or Upper. The default is Lower as required by PaStiX
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLDLT
+  */
+template<typename _MatrixType, int _UpLo>
+class PastixLDLT : public PastixBase< PastixLDLT<_MatrixType, _UpLo> >
+{
+  public:
+    typedef _MatrixType MatrixType;
+    typedef PastixBase<PastixLDLT<MatrixType, _UpLo> > Base; 
+    typedef typename Base::ColSpMatrix ColSpMatrix;
+    
+  public:
+    enum { UpLo = _UpLo };
+    PastixLDLT():Base()
+    {
+      init();
+    }
+    
+    explicit PastixLDLT(const MatrixType& matrix):Base()
+    {
+      init();
+      compute(matrix);
+    }
+
+    /** Compute the L and D factors of the LDL^T factorization of \p matrix 
+      * \sa analyzePattern() factorize()
+      */
+    void compute (const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::compute(temp);
+    }
+
+    /** Compute the LDL^T symbolic factorization of \p matrix using its sparsity pattern
+      * The result of this operation can be used with successive matrices having the same pattern as \p matrix
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    { 
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::analyzePattern(temp);
+    }
+    /** Compute the LDL^T supernodal numerical factorization of \p matrix 
+      * 
+      */
+    void factorize(const MatrixType& matrix)
+    {
+      ColSpMatrix temp;
+      grabMatrix(matrix, temp);
+      Base::factorize(temp);
+    }
+
+  protected:
+    using Base::m_iparm;
+    
+    void init()
+    {
+      m_iparm(IPARM_SYM) = API_SYM_YES;
+      m_iparm(IPARM_FACTORIZATION) = API_FACT_LDLT;
+    }
+    
+    void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
+    {
+      // Pastix supports only lower, column-major matrices 
+      out.resize(matrix.rows(), matrix.cols());
+      out.template selfadjointView<Lower>() = matrix.template selfadjointView<UpLo>();
+      internal::c_to_fortran_numbering(out);
+    }
+};
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/PardisoSupport/PardisoSupport.h b/C++/yolo_bytetrack_old/include/Eigen/src/PardisoSupport/PardisoSupport.h
new file mode 100644
index 00000000..f89b79bd
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/PardisoSupport/PardisoSupport.h
@@ -0,0 +1,545 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to Intel(R) MKL PARDISO
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_PARDISOSUPPORT_H
+#define EIGEN_PARDISOSUPPORT_H
+
+namespace Eigen { 
+
+template<typename _MatrixType> class PardisoLU;
+template<typename _MatrixType, int Options=Upper> class PardisoLLT;
+template<typename _MatrixType, int Options=Upper> class PardisoLDLT;
+
+namespace internal
+{
+  template<typename IndexType>
+  struct pardiso_run_selector
+  {
+    static IndexType run( _MKL_DSS_HANDLE_t pt, IndexType maxfct, IndexType mnum, IndexType type, IndexType phase, IndexType n, void *a,
+                      IndexType *ia, IndexType *ja, IndexType *perm, IndexType nrhs, IndexType *iparm, IndexType msglvl, void *b, void *x)
+    {
+      IndexType error = 0;
+      ::pardiso(pt, &maxfct, &mnum, &type, &phase, &n, a, ia, ja, perm, &nrhs, iparm, &msglvl, b, x, &error);
+      return error;
+    }
+  };
+  template<>
+  struct pardiso_run_selector<long long int>
+  {
+    typedef long long int IndexType;
+    static IndexType run( _MKL_DSS_HANDLE_t pt, IndexType maxfct, IndexType mnum, IndexType type, IndexType phase, IndexType n, void *a,
+                      IndexType *ia, IndexType *ja, IndexType *perm, IndexType nrhs, IndexType *iparm, IndexType msglvl, void *b, void *x)
+    {
+      IndexType error = 0;
+      ::pardiso_64(pt, &maxfct, &mnum, &type, &phase, &n, a, ia, ja, perm, &nrhs, iparm, &msglvl, b, x, &error);
+      return error;
+    }
+  };
+
+  template<class Pardiso> struct pardiso_traits;
+
+  template<typename _MatrixType>
+  struct pardiso_traits< PardisoLU<_MatrixType> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pardiso_traits< PardisoLLT<_MatrixType, Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;
+  };
+
+  template<typename _MatrixType, int Options>
+  struct pardiso_traits< PardisoLDLT<_MatrixType, Options> >
+  {
+    typedef _MatrixType MatrixType;
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef typename _MatrixType::StorageIndex StorageIndex;    
+  };
+
+} // end namespace internal
+
+template<class Derived>
+class PardisoImpl : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+    
+    typedef internal::pardiso_traits<Derived> Traits;
+  public:
+    using Base::_solve_impl;
+    
+    typedef typename Traits::MatrixType MatrixType;
+    typedef typename Traits::Scalar Scalar;
+    typedef typename Traits::RealScalar RealScalar;
+    typedef typename Traits::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,RowMajor,StorageIndex> SparseMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef Matrix<StorageIndex, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<StorageIndex, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
+    typedef Array<StorageIndex,64,1,DontAlign> ParameterType;
+    enum {
+      ScalarIsComplex = NumTraits<Scalar>::IsComplex,
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+
+    PardisoImpl()
+      : m_analysisIsOk(false), m_factorizationIsOk(false)
+    {
+      eigen_assert((sizeof(StorageIndex) >= sizeof(_INTEGER_t) && sizeof(StorageIndex) <= 8) && "Non-supported index type");
+      m_iparm.setZero();
+      m_msglvl = 0; // No output
+      m_isInitialized = false;
+    }
+
+    ~PardisoImpl()
+    {
+      pardisoRelease();
+    }
+
+    inline Index cols() const { return m_size; }
+    inline Index rows() const { return m_size; }
+  
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    /** \warning for advanced usage only.
+      * \returns a reference to the parameter array controlling PARDISO.
+      * See the PARDISO manual to know how to use it. */
+    ParameterType& pardisoParameterArray()
+    {
+      return m_iparm;
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    Derived& analyzePattern(const MatrixType& matrix);
+    
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    Derived& factorize(const MatrixType& matrix);
+
+    Derived& compute(const MatrixType& matrix);
+
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
+
+  protected:
+    void pardisoRelease()
+    {
+      if(m_isInitialized) // Factorization ran at least once
+      {
+        internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, -1, internal::convert_index<StorageIndex>(m_size),0, 0, 0, m_perm.data(), 0,
+                                                          m_iparm.data(), m_msglvl, NULL, NULL);
+        m_isInitialized = false;
+      }
+    }
+
+    void pardisoInit(int type)
+    {
+      m_type = type;
+      bool symmetric = std::abs(m_type) < 10;
+      m_iparm[0] = 1;   // No solver default
+      m_iparm[1] = 2;   // use Metis for the ordering
+      m_iparm[2] = 0;   // Reserved. Set to zero. (??Numbers of processors, value of OMP_NUM_THREADS??)
+      m_iparm[3] = 0;   // No iterative-direct algorithm
+      m_iparm[4] = 0;   // No user fill-in reducing permutation
+      m_iparm[5] = 0;   // Write solution into x, b is left unchanged
+      m_iparm[6] = 0;   // Not in use
+      m_iparm[7] = 2;   // Max numbers of iterative refinement steps
+      m_iparm[8] = 0;   // Not in use
+      m_iparm[9] = 13;  // Perturb the pivot elements with 1E-13
+      m_iparm[10] = symmetric ? 0 : 1; // Use nonsymmetric permutation and scaling MPS
+      m_iparm[11] = 0;  // Not in use
+      m_iparm[12] = symmetric ? 0 : 1;  // Maximum weighted matching algorithm is switched-off (default for symmetric).
+                                        // Try m_iparm[12] = 1 in case of inappropriate accuracy
+      m_iparm[13] = 0;  // Output: Number of perturbed pivots
+      m_iparm[14] = 0;  // Not in use
+      m_iparm[15] = 0;  // Not in use
+      m_iparm[16] = 0;  // Not in use
+      m_iparm[17] = -1; // Output: Number of nonzeros in the factor LU
+      m_iparm[18] = -1; // Output: Mflops for LU factorization
+      m_iparm[19] = 0;  // Output: Numbers of CG Iterations
+      
+      m_iparm[20] = 0;  // 1x1 pivoting
+      m_iparm[26] = 0;  // No matrix checker
+      m_iparm[27] = (sizeof(RealScalar) == 4) ? 1 : 0;
+      m_iparm[34] = 1;  // C indexing
+      m_iparm[36] = 0;  // CSR
+      m_iparm[59] = 0;  // 0 - In-Core ; 1 - Automatic switch between In-Core and Out-of-Core modes ; 2 - Out-of-Core
+      
+      memset(m_pt, 0, sizeof(m_pt));
+    }
+
+  protected:
+    // cached data to reduce reallocation, etc.
+    
+    void manageErrorCode(Index error) const
+    {
+      switch(error)
+      {
+        case 0:
+          m_info = Success;
+          break;
+        case -4:
+        case -7:
+          m_info = NumericalIssue;
+          break;
+        default:
+          m_info = InvalidInput;
+      }
+    }
+
+    mutable SparseMatrixType m_matrix;
+    mutable ComputationInfo m_info;
+    bool m_analysisIsOk, m_factorizationIsOk;
+    StorageIndex m_type, m_msglvl;
+    mutable void *m_pt[64];
+    mutable ParameterType m_iparm;
+    mutable IntColVectorType m_perm;
+    Index m_size;
+    
+};
+
+template<class Derived>
+Derived& PardisoImpl<Derived>::compute(const MatrixType& a)
+{
+  m_size = a.rows();
+  eigen_assert(a.rows() == a.cols());
+
+  pardisoRelease();
+  m_perm.setZero(m_size);
+  derived().getMatrix(a);
+  
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 12, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+  manageErrorCode(error);
+  m_analysisIsOk = true;
+  m_factorizationIsOk = true;
+  m_isInitialized = true;
+  return derived();
+}
+
+template<class Derived>
+Derived& PardisoImpl<Derived>::analyzePattern(const MatrixType& a)
+{
+  m_size = a.rows();
+  eigen_assert(m_size == a.cols());
+
+  pardisoRelease();
+  m_perm.setZero(m_size);
+  derived().getMatrix(a);
+  
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 11, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+  
+  manageErrorCode(error);
+  m_analysisIsOk = true;
+  m_factorizationIsOk = false;
+  m_isInitialized = true;
+  return derived();
+}
+
+template<class Derived>
+Derived& PardisoImpl<Derived>::factorize(const MatrixType& a)
+{
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  eigen_assert(m_size == a.rows() && m_size == a.cols());
+  
+  derived().getMatrix(a);
+
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 22, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+  
+  manageErrorCode(error);
+  m_factorizationIsOk = true;
+  return derived();
+}
+
+template<class Derived>
+template<typename BDerived,typename XDerived>
+void PardisoImpl<Derived>::_solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived>& x) const
+{
+  if(m_iparm[0] == 0) // Factorization was not computed
+  {
+    m_info = InvalidInput;
+    return;
+  }
+
+  //Index n = m_matrix.rows();
+  Index nrhs = Index(b.cols());
+  eigen_assert(m_size==b.rows());
+  eigen_assert(((MatrixBase<BDerived>::Flags & RowMajorBit) == 0 || nrhs == 1) && "Row-major right hand sides are not supported");
+  eigen_assert(((MatrixBase<XDerived>::Flags & RowMajorBit) == 0 || nrhs == 1) && "Row-major matrices of unknowns are not supported");
+  eigen_assert(((nrhs == 1) || b.outerStride() == b.rows()));
+
+
+//  switch (transposed) {
+//    case SvNoTrans    : m_iparm[11] = 0 ; break;
+//    case SvTranspose  : m_iparm[11] = 2 ; break;
+//    case SvAdjoint    : m_iparm[11] = 1 ; break;
+//    default:
+//      //std::cerr << "Eigen: transposition  option \"" << transposed << "\" not supported by the PARDISO backend\n";
+//      m_iparm[11] = 0;
+//  }
+
+  Scalar* rhs_ptr = const_cast<Scalar*>(b.derived().data());
+  Matrix<Scalar,Dynamic,Dynamic,ColMajor> tmp;
+  
+  // Pardiso cannot solve in-place
+  if(rhs_ptr == x.derived().data())
+  {
+    tmp = b;
+    rhs_ptr = tmp.data();
+  }
+  
+  Index error;
+  error = internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, 33, internal::convert_index<StorageIndex>(m_size),
+                                                            m_matrix.valuePtr(), m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(),
+                                                            m_perm.data(), internal::convert_index<StorageIndex>(nrhs), m_iparm.data(), m_msglvl,
+                                                            rhs_ptr, x.derived().data());
+
+  manageErrorCode(error);
+}
+
+
+/** \ingroup PardisoSupport_Module
+  * \class PardisoLU
+  * \brief A sparse direct LU factorization and solver based on the PARDISO library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a direct LU factorization
+  * using the Intel MKL PARDISO library. The sparse matrix A must be squared and invertible.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:
+  * \code solver.pardisoParameterArray()[59] = 1; \endcode
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  */
+template<typename MatrixType>
+class PardisoLU : public PardisoImpl< PardisoLU<MatrixType> >
+{
+  protected:
+    typedef PardisoImpl<PardisoLU> Base;
+    using Base::pardisoInit;
+    using Base::m_matrix;
+    friend class PardisoImpl< PardisoLU<MatrixType> >;
+
+  public:
+
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+
+    using Base::compute;
+    using Base::solve;
+
+    PardisoLU()
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 13 : 11);
+    }
+
+    explicit PardisoLU(const MatrixType& matrix)
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 13 : 11);
+      compute(matrix);
+    }
+  protected:
+    void getMatrix(const MatrixType& matrix)
+    {
+      m_matrix = matrix;
+      m_matrix.makeCompressed();
+    }
+};
+
+/** \ingroup PardisoSupport_Module
+  * \class PardisoLLT
+  * \brief A sparse direct Cholesky (LLT) factorization and solver based on the PARDISO library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LL^T Cholesky factorization
+  * using the Intel MKL PARDISO library. The sparse matrix A must be selfajoint and positive definite.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:
+  * \code solver.pardisoParameterArray()[59] = 1; \endcode
+  *
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam UpLo can be any bitwise combination of Upper, Lower. The default is Upper, meaning only the upper triangular part has to be used.
+  *         Upper|Lower can be used to tell both triangular parts can be used as input.
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLLT
+  */
+template<typename MatrixType, int _UpLo>
+class PardisoLLT : public PardisoImpl< PardisoLLT<MatrixType,_UpLo> >
+{
+  protected:
+    typedef PardisoImpl< PardisoLLT<MatrixType,_UpLo> > Base;
+    using Base::pardisoInit;
+    using Base::m_matrix;
+    friend class PardisoImpl< PardisoLLT<MatrixType,_UpLo> >;
+
+  public:
+
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    enum { UpLo = _UpLo };
+    using Base::compute;
+
+    PardisoLLT()
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 4 : 2);
+    }
+
+    explicit PardisoLLT(const MatrixType& matrix)
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? 4 : 2);
+      compute(matrix);
+    }
+    
+  protected:
+    
+    void getMatrix(const MatrixType& matrix)
+    {
+      // PARDISO supports only upper, row-major matrices
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> p_null;
+      m_matrix.resize(matrix.rows(), matrix.cols());
+      m_matrix.template selfadjointView<Upper>() = matrix.template selfadjointView<UpLo>().twistedBy(p_null);
+      m_matrix.makeCompressed();
+    }
+};
+
+/** \ingroup PardisoSupport_Module
+  * \class PardisoLDLT
+  * \brief A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LDL^T Cholesky factorization
+  * using the Intel MKL PARDISO library. The sparse matrix A is assumed to be selfajoint and positive definite.
+  * For complex matrices, A can also be symmetric only, see the \a Options template parameter.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:
+  * \code solver.pardisoParameterArray()[59] = 1; \endcode
+  *
+  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam Options can be any bitwise combination of Upper, Lower, and Symmetric. The default is Upper, meaning only the upper triangular part has to be used.
+  *         Symmetric can be used for symmetric, non-selfadjoint complex matrices, the default being to assume a selfadjoint matrix.
+  *         Upper|Lower can be used to tell both triangular parts can be used as input.
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SimplicialLDLT
+  */
+template<typename MatrixType, int Options>
+class PardisoLDLT : public PardisoImpl< PardisoLDLT<MatrixType,Options> >
+{
+  protected:
+    typedef PardisoImpl< PardisoLDLT<MatrixType,Options> > Base;
+    using Base::pardisoInit;
+    using Base::m_matrix;
+    friend class PardisoImpl< PardisoLDLT<MatrixType,Options> >;
+
+  public:
+
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    using Base::compute;
+    enum { UpLo = Options&(Upper|Lower) };
+
+    PardisoLDLT()
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? ( bool(Options&Symmetric) ? 6 : -4 ) : -2);
+    }
+
+    explicit PardisoLDLT(const MatrixType& matrix)
+      : Base()
+    {
+      pardisoInit(Base::ScalarIsComplex ? ( bool(Options&Symmetric) ? 6 : -4 ) : -2);
+      compute(matrix);
+    }
+    
+    void getMatrix(const MatrixType& matrix)
+    {
+      // PARDISO supports only upper, row-major matrices
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> p_null;
+      m_matrix.resize(matrix.rows(), matrix.cols());
+      m_matrix.template selfadjointView<Upper>() = matrix.template selfadjointView<UpLo>().twistedBy(p_null);
+      m_matrix.makeCompressed();
+    }
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_PARDISOSUPPORT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/QR/ColPivHouseholderQR.h b/C++/yolo_bytetrack_old/include/Eigen/src/QR/ColPivHouseholderQR.h
new file mode 100644
index 00000000..9b677e9b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/QR/ColPivHouseholderQR.h
@@ -0,0 +1,674 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
+#define EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename _MatrixType> struct traits<ColPivHouseholderQR<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+} // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  * \class ColPivHouseholderQR
+  *
+  * \brief Householder rank-revealing QR decomposition of a matrix with column-pivoting
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the QR decomposition
+  *
+  * This class performs a rank-revealing QR decomposition of a matrix \b A into matrices \b P, \b Q and \b R
+  * such that
+  * \f[
+  *  \mathbf{A} \, \mathbf{P} = \mathbf{Q} \, \mathbf{R}
+  * \f]
+  * by using Householder transformations. Here, \b P is a permutation matrix, \b Q a unitary matrix and \b R an
+  * upper triangular matrix.
+  *
+  * This decomposition performs column pivoting in order to be rank-revealing and improve
+  * numerical stability. It is slower than HouseholderQR, and faster than FullPivHouseholderQR.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::colPivHouseholderQr()
+  */
+template<typename _MatrixType> class ColPivHouseholderQR
+        : public SolverBase<ColPivHouseholderQR<_MatrixType> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<ColPivHouseholderQR> Base;
+    friend class SolverBase<ColPivHouseholderQR>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(ColPivHouseholderQR)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+    typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationType;
+    typedef typename internal::plain_row_type<MatrixType, Index>::type IntRowVectorType;
+    typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+    typedef typename internal::plain_row_type<MatrixType, RealScalar>::type RealRowVectorType;
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename HCoeffsType::ConjugateReturnType>::type> HouseholderSequenceType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+  private:
+
+    typedef typename PermutationType::StorageIndex PermIndexType;
+
+  public:
+
+    /**
+    * \brief Default Constructor.
+    *
+    * The default constructor is useful in cases in which the user intends to
+    * perform decompositions via ColPivHouseholderQR::compute(const MatrixType&).
+    */
+    ColPivHouseholderQR()
+      : m_qr(),
+        m_hCoeffs(),
+        m_colsPermutation(),
+        m_colsTranspositions(),
+        m_temp(),
+        m_colNormsUpdated(),
+        m_colNormsDirect(),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa ColPivHouseholderQR()
+      */
+    ColPivHouseholderQR(Index rows, Index cols)
+      : m_qr(rows, cols),
+        m_hCoeffs((std::min)(rows,cols)),
+        m_colsPermutation(PermIndexType(cols)),
+        m_colsTranspositions(cols),
+        m_temp(cols),
+        m_colNormsUpdated(cols),
+        m_colNormsDirect(cols),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This constructor computes the QR factorization of the matrix \a matrix by calling
+      * the method compute(). It is a short cut for:
+      *
+      * \code
+      * ColPivHouseholderQR<MatrixType> qr(matrix.rows(), matrix.cols());
+      * qr.compute(matrix);
+      * \endcode
+      *
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit ColPivHouseholderQR(const EigenBase<InputType>& matrix)
+      : m_qr(matrix.rows(), matrix.cols()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_colsPermutation(PermIndexType(matrix.cols())),
+        m_colsTranspositions(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_colNormsUpdated(matrix.cols()),
+        m_colNormsDirect(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa ColPivHouseholderQR(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit ColPivHouseholderQR(EigenBase<InputType>& matrix)
+      : m_qr(matrix.derived()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_colsPermutation(PermIndexType(matrix.cols())),
+        m_colsTranspositions(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_colNormsUpdated(matrix.cols()),
+        m_colNormsDirect(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      computeInPlace();
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** This method finds a solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the QR decomposition, if any exists.
+      *
+      * \param b the right-hand-side of the equation to solve.
+      *
+      * \returns a solution.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      *
+      * Example: \include ColPivHouseholderQR_solve.cpp
+      * Output: \verbinclude ColPivHouseholderQR_solve.out
+      */
+    template<typename Rhs>
+    inline const Solve<ColPivHouseholderQR, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    HouseholderSequenceType householderQ() const;
+    HouseholderSequenceType matrixQ() const
+    {
+      return householderQ();
+    }
+
+    /** \returns a reference to the matrix where the Householder QR decomposition is stored
+      */
+    const MatrixType& matrixQR() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_qr;
+    }
+
+    /** \returns a reference to the matrix where the result Householder QR is stored
+     * \warning The strict lower part of this matrix contains internal values.
+     * Only the upper triangular part should be referenced. To get it, use
+     * \code matrixR().template triangularView<Upper>() \endcode
+     * For rank-deficient matrices, use
+     * \code
+     * matrixR().topLeftCorner(rank(), rank()).template triangularView<Upper>()
+     * \endcode
+     */
+    const MatrixType& matrixR() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_qr;
+    }
+
+    template<typename InputType>
+    ColPivHouseholderQR& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns a const reference to the column permutation matrix */
+    const PermutationType& colsPermutation() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_colsPermutation;
+    }
+
+    /** \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar absDeterminant() const;
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's inherent
+      * to determinant computation.
+      *
+      * \sa absDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar logAbsDeterminant() const;
+
+    /** \returns the rank of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index rank() const
+    {
+      using std::abs;
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
+      Index result = 0;
+      for(Index i = 0; i < m_nonzero_pivots; ++i)
+        result += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);
+      return result;
+    }
+
+    /** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index dimensionOfKernel() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return cols() - rank();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents an injective
+      *          linear map, i.e. has trivial kernel; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInjective() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return rank() == cols();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents a surjective
+      *          linear map; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isSurjective() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return rank() == rows();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition is invertible.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInvertible() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return isInjective() && isSurjective();
+    }
+
+    /** \returns the inverse of the matrix of which *this is the QR decomposition.
+      *
+      * \note If this matrix is not invertible, the returned matrix has undefined coefficients.
+      *       Use isInvertible() to first determine whether this matrix is invertible.
+      */
+    inline const Inverse<ColPivHouseholderQR> inverse() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return Inverse<ColPivHouseholderQR>(*this);
+    }
+
+    inline Index rows() const { return m_qr.rows(); }
+    inline Index cols() const { return m_qr.cols(); }
+
+    /** \returns a const reference to the vector of Householder coefficients used to represent the factor \c Q.
+      *
+      * For advanced uses only.
+      */
+    const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
+
+    /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
+      * who need to determine when pivots are to be considered nonzero. This is not used for the
+      * QR decomposition itself.
+      *
+      * When it needs to get the threshold value, Eigen calls threshold(). By default, this
+      * uses a formula to automatically determine a reasonable threshold.
+      * Once you have called the present method setThreshold(const RealScalar&),
+      * your value is used instead.
+      *
+      * \param threshold The new value to use as the threshold.
+      *
+      * A pivot will be considered nonzero if its absolute value is strictly greater than
+      *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+      * where maxpivot is the biggest pivot.
+      *
+      * If you want to come back to the default behavior, call setThreshold(Default_t)
+      */
+    ColPivHouseholderQR& setThreshold(const RealScalar& threshold)
+    {
+      m_usePrescribedThreshold = true;
+      m_prescribedThreshold = threshold;
+      return *this;
+    }
+
+    /** Allows to come back to the default behavior, letting Eigen use its default formula for
+      * determining the threshold.
+      *
+      * You should pass the special object Eigen::Default as parameter here.
+      * \code qr.setThreshold(Eigen::Default); \endcode
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    ColPivHouseholderQR& setThreshold(Default_t)
+    {
+      m_usePrescribedThreshold = false;
+      return *this;
+    }
+
+    /** Returns the threshold that will be used by certain methods such as rank().
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    RealScalar threshold() const
+    {
+      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+      return m_usePrescribedThreshold ? m_prescribedThreshold
+      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
+      // and turns out to be identical to Higham's formula used already in LDLt.
+                                      : NumTraits<Scalar>::epsilon() * RealScalar(m_qr.diagonalSize());
+    }
+
+    /** \returns the number of nonzero pivots in the QR decomposition.
+      * Here nonzero is meant in the exact sense, not in a fuzzy sense.
+      * So that notion isn't really intrinsically interesting, but it is
+      * still useful when implementing algorithms.
+      *
+      * \sa rank()
+      */
+    inline Index nonzeroPivots() const
+    {
+      eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+      return m_nonzero_pivots;
+    }
+
+    /** \returns the absolute value of the biggest pivot, i.e. the biggest
+      *          diagonal coefficient of R.
+      */
+    RealScalar maxPivot() const { return m_maxpivot; }
+
+    /** \brief Reports whether the QR factorization was successful.
+      *
+      * \note This function always returns \c Success. It is provided for compatibility
+      * with other factorization routines.
+      * \returns \c Success
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return Success;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    friend class CompleteOrthogonalDecomposition<MatrixType>;
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_qr;
+    HCoeffsType m_hCoeffs;
+    PermutationType m_colsPermutation;
+    IntRowVectorType m_colsTranspositions;
+    RowVectorType m_temp;
+    RealRowVectorType m_colNormsUpdated;
+    RealRowVectorType m_colNormsDirect;
+    bool m_isInitialized, m_usePrescribedThreshold;
+    RealScalar m_prescribedThreshold, m_maxpivot;
+    Index m_nonzero_pivots;
+    Index m_det_pq;
+};
+
+template<typename MatrixType>
+typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::absDeterminant() const
+{
+  using std::abs;
+  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return abs(m_qr.diagonal().prod());
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::logAbsDeterminant() const
+{
+  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return m_qr.diagonal().cwiseAbs().array().log().sum();
+}
+
+/** Performs the QR factorization of the given matrix \a matrix. The result of
+  * the factorization is stored into \c *this, and a reference to \c *this
+  * is returned.
+  *
+  * \sa class ColPivHouseholderQR, ColPivHouseholderQR(const MatrixType&)
+  */
+template<typename MatrixType>
+template<typename InputType>
+ColPivHouseholderQR<MatrixType>& ColPivHouseholderQR<MatrixType>::compute(const EigenBase<InputType>& matrix)
+{
+  m_qr = matrix.derived();
+  computeInPlace();
+  return *this;
+}
+
+template<typename MatrixType>
+void ColPivHouseholderQR<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  // the column permutation is stored as int indices, so just to be sure:
+  eigen_assert(m_qr.cols()<=NumTraits<int>::highest());
+
+  using std::abs;
+
+  Index rows = m_qr.rows();
+  Index cols = m_qr.cols();
+  Index size = m_qr.diagonalSize();
+
+  m_hCoeffs.resize(size);
+
+  m_temp.resize(cols);
+
+  m_colsTranspositions.resize(m_qr.cols());
+  Index number_of_transpositions = 0;
+
+  m_colNormsUpdated.resize(cols);
+  m_colNormsDirect.resize(cols);
+  for (Index k = 0; k < cols; ++k) {
+    // colNormsDirect(k) caches the most recent directly computed norm of
+    // column k.
+    m_colNormsDirect.coeffRef(k) = m_qr.col(k).norm();
+    m_colNormsUpdated.coeffRef(k) = m_colNormsDirect.coeffRef(k);
+  }
+
+  RealScalar threshold_helper =  numext::abs2<RealScalar>(m_colNormsUpdated.maxCoeff() * NumTraits<RealScalar>::epsilon()) / RealScalar(rows);
+  RealScalar norm_downdate_threshold = numext::sqrt(NumTraits<RealScalar>::epsilon());
+
+  m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case)
+  m_maxpivot = RealScalar(0);
+
+  for(Index k = 0; k < size; ++k)
+  {
+    // first, we look up in our table m_colNormsUpdated which column has the biggest norm
+    Index biggest_col_index;
+    RealScalar biggest_col_sq_norm = numext::abs2(m_colNormsUpdated.tail(cols-k).maxCoeff(&biggest_col_index));
+    biggest_col_index += k;
+
+    // Track the number of meaningful pivots but do not stop the decomposition to make
+    // sure that the initial matrix is properly reproduced. See bug 941.
+    if(m_nonzero_pivots==size && biggest_col_sq_norm < threshold_helper * RealScalar(rows-k))
+      m_nonzero_pivots = k;
+
+    // apply the transposition to the columns
+    m_colsTranspositions.coeffRef(k) = biggest_col_index;
+    if(k != biggest_col_index) {
+      m_qr.col(k).swap(m_qr.col(biggest_col_index));
+      std::swap(m_colNormsUpdated.coeffRef(k), m_colNormsUpdated.coeffRef(biggest_col_index));
+      std::swap(m_colNormsDirect.coeffRef(k), m_colNormsDirect.coeffRef(biggest_col_index));
+      ++number_of_transpositions;
+    }
+
+    // generate the householder vector, store it below the diagonal
+    RealScalar beta;
+    m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);
+
+    // apply the householder transformation to the diagonal coefficient
+    m_qr.coeffRef(k,k) = beta;
+
+    // remember the maximum absolute value of diagonal coefficients
+    if(abs(beta) > m_maxpivot) m_maxpivot = abs(beta);
+
+    // apply the householder transformation
+    m_qr.bottomRightCorner(rows-k, cols-k-1)
+        .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));
+
+    // update our table of norms of the columns
+    for (Index j = k + 1; j < cols; ++j) {
+      // The following implements the stable norm downgrade step discussed in
+      // http://www.netlib.org/lapack/lawnspdf/lawn176.pdf
+      // and used in LAPACK routines xGEQPF and xGEQP3.
+      // See lines 278-297 in http://www.netlib.org/lapack/explore-html/dc/df4/sgeqpf_8f_source.html
+      if (m_colNormsUpdated.coeffRef(j) != RealScalar(0)) {
+        RealScalar temp = abs(m_qr.coeffRef(k, j)) / m_colNormsUpdated.coeffRef(j);
+        temp = (RealScalar(1) + temp) * (RealScalar(1) - temp);
+        temp = temp <  RealScalar(0) ? RealScalar(0) : temp;
+        RealScalar temp2 = temp * numext::abs2<RealScalar>(m_colNormsUpdated.coeffRef(j) /
+                                                           m_colNormsDirect.coeffRef(j));
+        if (temp2 <= norm_downdate_threshold) {
+          // The updated norm has become too inaccurate so re-compute the column
+          // norm directly.
+          m_colNormsDirect.coeffRef(j) = m_qr.col(j).tail(rows - k - 1).norm();
+          m_colNormsUpdated.coeffRef(j) = m_colNormsDirect.coeffRef(j);
+        } else {
+          m_colNormsUpdated.coeffRef(j) *= numext::sqrt(temp);
+        }
+      }
+    }
+  }
+
+  m_colsPermutation.setIdentity(PermIndexType(cols));
+  for(PermIndexType k = 0; k < size/*m_nonzero_pivots*/; ++k)
+    m_colsPermutation.applyTranspositionOnTheRight(k, PermIndexType(m_colsTranspositions.coeff(k)));
+
+  m_det_pq = (number_of_transpositions%2) ? -1 : 1;
+  m_isInitialized = true;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void ColPivHouseholderQR<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  const Index nonzero_pivots = nonzeroPivots();
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs);
+
+  c.applyOnTheLeft(householderQ().setLength(nonzero_pivots).adjoint() );
+
+  m_qr.topLeftCorner(nonzero_pivots, nonzero_pivots)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(nonzero_pivots));
+
+  for(Index i = 0; i < nonzero_pivots; ++i) dst.row(m_colsPermutation.indices().coeff(i)) = c.row(i);
+  for(Index i = nonzero_pivots; i < cols(); ++i) dst.row(m_colsPermutation.indices().coeff(i)).setZero();
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void ColPivHouseholderQR<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  const Index nonzero_pivots = nonzeroPivots();
+
+  if(nonzero_pivots == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(m_colsPermutation.transpose()*rhs);
+
+  m_qr.topLeftCorner(nonzero_pivots, nonzero_pivots)
+        .template triangularView<Upper>()
+        .transpose().template conjugateIf<Conjugate>()
+        .solveInPlace(c.topRows(nonzero_pivots));
+
+  dst.topRows(nonzero_pivots) = c.topRows(nonzero_pivots);
+  dst.bottomRows(rows()-nonzero_pivots).setZero();
+
+  dst.applyOnTheLeft(householderQ().setLength(nonzero_pivots).template conjugateIf<!Conjugate>() );
+}
+#endif
+
+namespace internal {
+
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<ColPivHouseholderQR<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename ColPivHouseholderQR<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef ColPivHouseholderQR<MatrixType> QrType;
+  typedef Inverse<QrType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename QrType::Scalar> &)
+  {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+
+} // end namespace internal
+
+/** \returns the matrix Q as a sequence of householder transformations.
+  * You can extract the meaningful part only by using:
+  * \code qr.householderQ().setLength(qr.nonzeroPivots()) \endcode*/
+template<typename MatrixType>
+typename ColPivHouseholderQR<MatrixType>::HouseholderSequenceType ColPivHouseholderQR<MatrixType>
+  ::householderQ() const
+{
+  eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
+  return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate());
+}
+
+/** \return the column-pivoting Householder QR decomposition of \c *this.
+  *
+  * \sa class ColPivHouseholderQR
+  */
+template<typename Derived>
+const ColPivHouseholderQR<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::colPivHouseholderQr() const
+{
+  return ColPivHouseholderQR<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h b/C++/yolo_bytetrack_old/include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
new file mode 100644
index 00000000..4e9651f8
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
@@ -0,0 +1,97 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Householder QR decomposition of a matrix with column pivoting based on
+ *    LAPACKE_?geqp3 function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
+#define EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_QR_COLPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX, EIGCOLROW, LAPACKE_COLROW) \
+template<> template<typename InputType> inline \
+ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >& \
+ColPivHouseholderQR<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> >::compute( \
+              const EigenBase<InputType>& matrix) \
+\
+{ \
+  using std::abs; \
+  typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> MatrixType; \
+  typedef MatrixType::RealScalar RealScalar; \
+  Index rows = matrix.rows();\
+  Index cols = matrix.cols();\
+\
+  m_qr = matrix;\
+  Index size = m_qr.diagonalSize();\
+  m_hCoeffs.resize(size);\
+\
+  m_colsTranspositions.resize(cols);\
+  /*Index number_of_transpositions = 0;*/ \
+\
+  m_nonzero_pivots = 0; \
+  m_maxpivot = RealScalar(0);\
+  m_colsPermutation.resize(cols); \
+  m_colsPermutation.indices().setZero(); \
+\
+  lapack_int lda = internal::convert_index<lapack_int,Index>(m_qr.outerStride()); \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  LAPACKE_##LAPACKE_PREFIX##geqp3( matrix_order, internal::convert_index<lapack_int,Index>(rows), internal::convert_index<lapack_int,Index>(cols), \
+                              (LAPACKE_TYPE*)m_qr.data(), lda, (lapack_int*)m_colsPermutation.indices().data(), (LAPACKE_TYPE*)m_hCoeffs.data()); \
+  m_isInitialized = true; \
+  m_maxpivot=m_qr.diagonal().cwiseAbs().maxCoeff(); \
+  m_hCoeffs.adjointInPlace(); \
+  RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold(); \
+  lapack_int *perm = m_colsPermutation.indices().data(); \
+  for(Index i=0;i<size;i++) { \
+    m_nonzero_pivots += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);\
+  } \
+  for(Index i=0;i<cols;i++) perm[i]--;\
+\
+  /*m_det_pq = (number_of_transpositions%2) ? -1 : 1;  // TODO: It's not needed now; fix upon availability in Eigen */ \
+\
+  return *this; \
+}
+
+EIGEN_LAPACKE_QR_COLPIV(double,   double,        d, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(float,    float,         s, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(dcomplex, lapack_complex_double, z, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(scomplex, lapack_complex_float,  c, ColMajor, LAPACK_COL_MAJOR)
+
+EIGEN_LAPACKE_QR_COLPIV(double,   double,        d, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(float,    float,         s, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(dcomplex, lapack_complex_double, z, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_QR_COLPIV(scomplex, lapack_complex_float,  c, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/QR/CompleteOrthogonalDecomposition.h b/C++/yolo_bytetrack_old/include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
new file mode 100644
index 00000000..486d3373
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/QR/CompleteOrthogonalDecomposition.h
@@ -0,0 +1,635 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Rasmus Munk Larsen <rmlarsen@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
+#define EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
+
+namespace Eigen {
+
+namespace internal {
+template <typename _MatrixType>
+struct traits<CompleteOrthogonalDecomposition<_MatrixType> >
+    : traits<_MatrixType> {
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+}  // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  * \class CompleteOrthogonalDecomposition
+  *
+  * \brief Complete orthogonal decomposition (COD) of a matrix.
+  *
+  * \param MatrixType the type of the matrix of which we are computing the COD.
+  *
+  * This class performs a rank-revealing complete orthogonal decomposition of a
+  * matrix  \b A into matrices \b P, \b Q, \b T, and \b Z such that
+  * \f[
+  *  \mathbf{A} \, \mathbf{P} = \mathbf{Q} \,
+  *                     \begin{bmatrix} \mathbf{T} &  \mathbf{0} \\
+  *                                     \mathbf{0} & \mathbf{0} \end{bmatrix} \, \mathbf{Z}
+  * \f]
+  * by using Householder transformations. Here, \b P is a permutation matrix,
+  * \b Q and \b Z are unitary matrices and \b T an upper triangular matrix of
+  * size rank-by-rank. \b A may be rank deficient.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::completeOrthogonalDecomposition()
+  */
+template <typename _MatrixType> class CompleteOrthogonalDecomposition
+          : public SolverBase<CompleteOrthogonalDecomposition<_MatrixType> >
+{
+ public:
+  typedef _MatrixType MatrixType;
+  typedef SolverBase<CompleteOrthogonalDecomposition> Base;
+
+  template<typename Derived>
+  friend struct internal::solve_assertion;
+
+  EIGEN_GENERIC_PUBLIC_INTERFACE(CompleteOrthogonalDecomposition)
+  enum {
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+  };
+  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+  typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime>
+      PermutationType;
+  typedef typename internal::plain_row_type<MatrixType, Index>::type
+      IntRowVectorType;
+  typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+  typedef typename internal::plain_row_type<MatrixType, RealScalar>::type
+      RealRowVectorType;
+  typedef HouseholderSequence<
+      MatrixType, typename internal::remove_all<
+                      typename HCoeffsType::ConjugateReturnType>::type>
+      HouseholderSequenceType;
+  typedef typename MatrixType::PlainObject PlainObject;
+
+ private:
+  typedef typename PermutationType::Index PermIndexType;
+
+ public:
+  /**
+   * \brief Default Constructor.
+   *
+   * The default constructor is useful in cases in which the user intends to
+   * perform decompositions via
+   * \c CompleteOrthogonalDecomposition::compute(const* MatrixType&).
+   */
+  CompleteOrthogonalDecomposition() : m_cpqr(), m_zCoeffs(), m_temp() {}
+
+  /** \brief Default Constructor with memory preallocation
+   *
+   * Like the default constructor but with preallocation of the internal data
+   * according to the specified problem \a size.
+   * \sa CompleteOrthogonalDecomposition()
+   */
+  CompleteOrthogonalDecomposition(Index rows, Index cols)
+      : m_cpqr(rows, cols), m_zCoeffs((std::min)(rows, cols)), m_temp(cols) {}
+
+  /** \brief Constructs a complete orthogonal decomposition from a given
+   * matrix.
+   *
+   * This constructor computes the complete orthogonal decomposition of the
+   * matrix \a matrix by calling the method compute(). The default
+   * threshold for rank determination will be used. It is a short cut for:
+   *
+   * \code
+   * CompleteOrthogonalDecomposition<MatrixType> cod(matrix.rows(),
+   *                                                 matrix.cols());
+   * cod.setThreshold(Default);
+   * cod.compute(matrix);
+   * \endcode
+   *
+   * \sa compute()
+   */
+  template <typename InputType>
+  explicit CompleteOrthogonalDecomposition(const EigenBase<InputType>& matrix)
+      : m_cpqr(matrix.rows(), matrix.cols()),
+        m_zCoeffs((std::min)(matrix.rows(), matrix.cols())),
+        m_temp(matrix.cols())
+  {
+    compute(matrix.derived());
+  }
+
+  /** \brief Constructs a complete orthogonal decomposition from a given matrix
+    *
+    * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+    *
+    * \sa CompleteOrthogonalDecomposition(const EigenBase&)
+    */
+  template<typename InputType>
+  explicit CompleteOrthogonalDecomposition(EigenBase<InputType>& matrix)
+    : m_cpqr(matrix.derived()),
+      m_zCoeffs((std::min)(matrix.rows(), matrix.cols())),
+      m_temp(matrix.cols())
+  {
+    computeInPlace();
+  } 
+
+  #ifdef EIGEN_PARSED_BY_DOXYGEN
+  /** This method computes the minimum-norm solution X to a least squares
+   * problem \f[\mathrm{minimize} \|A X - B\|, \f] where \b A is the matrix of
+   * which \c *this is the complete orthogonal decomposition.
+   *
+   * \param b the right-hand sides of the problem to solve.
+   *
+   * \returns a solution.
+   *
+   */
+  template <typename Rhs>
+  inline const Solve<CompleteOrthogonalDecomposition, Rhs> solve(
+      const MatrixBase<Rhs>& b) const;
+  #endif
+
+  HouseholderSequenceType householderQ(void) const;
+  HouseholderSequenceType matrixQ(void) const { return m_cpqr.householderQ(); }
+
+  /** \returns the matrix \b Z.
+   */
+  MatrixType matrixZ() const {
+    MatrixType Z = MatrixType::Identity(m_cpqr.cols(), m_cpqr.cols());
+    applyZOnTheLeftInPlace<false>(Z);
+    return Z;
+  }
+
+  /** \returns a reference to the matrix where the complete orthogonal
+   * decomposition is stored
+   */
+  const MatrixType& matrixQTZ() const { return m_cpqr.matrixQR(); }
+
+  /** \returns a reference to the matrix where the complete orthogonal
+   * decomposition is stored.
+   * \warning The strict lower part and \code cols() - rank() \endcode right
+   * columns of this matrix contains internal values.
+   * Only the upper triangular part should be referenced. To get it, use
+   * \code matrixT().template triangularView<Upper>() \endcode
+   * For rank-deficient matrices, use
+   * \code
+   * matrixR().topLeftCorner(rank(), rank()).template triangularView<Upper>()
+   * \endcode
+   */
+  const MatrixType& matrixT() const { return m_cpqr.matrixQR(); }
+
+  template <typename InputType>
+  CompleteOrthogonalDecomposition& compute(const EigenBase<InputType>& matrix) {
+    // Compute the column pivoted QR factorization A P = Q R.
+    m_cpqr.compute(matrix);
+    computeInPlace();
+    return *this;
+  }
+
+  /** \returns a const reference to the column permutation matrix */
+  const PermutationType& colsPermutation() const {
+    return m_cpqr.colsPermutation();
+  }
+
+  /** \returns the absolute value of the determinant of the matrix of which
+   * *this is the complete orthogonal decomposition. It has only linear
+   * complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the complete orthogonal decomposition has already been computed.
+   *
+   * \note This is only for square matrices.
+   *
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() instead.
+   *
+   * \sa logAbsDeterminant(), MatrixBase::determinant()
+   */
+  typename MatrixType::RealScalar absDeterminant() const;
+
+  /** \returns the natural log of the absolute value of the determinant of the
+   * matrix of which *this is the complete orthogonal decomposition. It has
+   * only linear complexity (that is, O(n) where n is the dimension of the
+   * square matrix) as the complete orthogonal decomposition has already been
+   * computed.
+   *
+   * \note This is only for square matrices.
+   *
+   * \note This method is useful to work around the risk of overflow/underflow
+   * that's inherent to determinant computation.
+   *
+   * \sa absDeterminant(), MatrixBase::determinant()
+   */
+  typename MatrixType::RealScalar logAbsDeterminant() const;
+
+  /** \returns the rank of the matrix of which *this is the complete orthogonal
+   * decomposition.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline Index rank() const { return m_cpqr.rank(); }
+
+  /** \returns the dimension of the kernel of the matrix of which *this is the
+   * complete orthogonal decomposition.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline Index dimensionOfKernel() const { return m_cpqr.dimensionOfKernel(); }
+
+  /** \returns true if the matrix of which *this is the decomposition represents
+   * an injective linear map, i.e. has trivial kernel; false otherwise.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline bool isInjective() const { return m_cpqr.isInjective(); }
+
+  /** \returns true if the matrix of which *this is the decomposition represents
+   * a surjective linear map; false otherwise.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline bool isSurjective() const { return m_cpqr.isSurjective(); }
+
+  /** \returns true if the matrix of which *this is the complete orthogonal
+   * decomposition is invertible.
+   *
+   * \note This method has to determine which pivots should be considered
+   * nonzero. For that, it uses the threshold value that you can control by
+   * calling setThreshold(const RealScalar&).
+   */
+  inline bool isInvertible() const { return m_cpqr.isInvertible(); }
+
+  /** \returns the pseudo-inverse of the matrix of which *this is the complete
+   * orthogonal decomposition.
+   * \warning: Do not compute \c this->pseudoInverse()*rhs to solve a linear systems.
+   * It is more efficient and numerically stable to call \c this->solve(rhs).
+   */
+  inline const Inverse<CompleteOrthogonalDecomposition> pseudoInverse() const
+  {
+    eigen_assert(m_cpqr.m_isInitialized && "CompleteOrthogonalDecomposition is not initialized.");
+    return Inverse<CompleteOrthogonalDecomposition>(*this);
+  }
+
+  inline Index rows() const { return m_cpqr.rows(); }
+  inline Index cols() const { return m_cpqr.cols(); }
+
+  /** \returns a const reference to the vector of Householder coefficients used
+   * to represent the factor \c Q.
+   *
+   * For advanced uses only.
+   */
+  inline const HCoeffsType& hCoeffs() const { return m_cpqr.hCoeffs(); }
+
+  /** \returns a const reference to the vector of Householder coefficients
+   * used to represent the factor \c Z.
+   *
+   * For advanced uses only.
+   */
+  const HCoeffsType& zCoeffs() const { return m_zCoeffs; }
+
+  /** Allows to prescribe a threshold to be used by certain methods, such as
+   * rank(), who need to determine when pivots are to be considered nonzero.
+   * Most be called before calling compute().
+   *
+   * When it needs to get the threshold value, Eigen calls threshold(). By
+   * default, this uses a formula to automatically determine a reasonable
+   * threshold. Once you have called the present method
+   * setThreshold(const RealScalar&), your value is used instead.
+   *
+   * \param threshold The new value to use as the threshold.
+   *
+   * A pivot will be considered nonzero if its absolute value is strictly
+   * greater than
+   *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+   * where maxpivot is the biggest pivot.
+   *
+   * If you want to come back to the default behavior, call
+   * setThreshold(Default_t)
+   */
+  CompleteOrthogonalDecomposition& setThreshold(const RealScalar& threshold) {
+    m_cpqr.setThreshold(threshold);
+    return *this;
+  }
+
+  /** Allows to come back to the default behavior, letting Eigen use its default
+   * formula for determining the threshold.
+   *
+   * You should pass the special object Eigen::Default as parameter here.
+   * \code qr.setThreshold(Eigen::Default); \endcode
+   *
+   * See the documentation of setThreshold(const RealScalar&).
+   */
+  CompleteOrthogonalDecomposition& setThreshold(Default_t) {
+    m_cpqr.setThreshold(Default);
+    return *this;
+  }
+
+  /** Returns the threshold that will be used by certain methods such as rank().
+   *
+   * See the documentation of setThreshold(const RealScalar&).
+   */
+  RealScalar threshold() const { return m_cpqr.threshold(); }
+
+  /** \returns the number of nonzero pivots in the complete orthogonal
+   * decomposition. Here nonzero is meant in the exact sense, not in a
+   * fuzzy sense. So that notion isn't really intrinsically interesting,
+   * but it is still useful when implementing algorithms.
+   *
+   * \sa rank()
+   */
+  inline Index nonzeroPivots() const { return m_cpqr.nonzeroPivots(); }
+
+  /** \returns the absolute value of the biggest pivot, i.e. the biggest
+   *          diagonal coefficient of R.
+   */
+  inline RealScalar maxPivot() const { return m_cpqr.maxPivot(); }
+
+  /** \brief Reports whether the complete orthogonal decomposition was
+   * successful.
+   *
+   * \note This function always returns \c Success. It is provided for
+   * compatibility
+   * with other factorization routines.
+   * \returns \c Success
+   */
+  ComputationInfo info() const {
+    eigen_assert(m_cpqr.m_isInitialized && "Decomposition is not initialized.");
+    return Success;
+  }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  template <typename RhsType, typename DstType>
+  void _solve_impl(const RhsType& rhs, DstType& dst) const;
+
+  template<bool Conjugate, typename RhsType, typename DstType>
+  void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+#endif
+
+ protected:
+  static void check_template_parameters() {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+  }
+
+  template<bool Transpose_, typename Rhs>
+  void _check_solve_assertion(const Rhs& b) const {
+      EIGEN_ONLY_USED_FOR_DEBUG(b);
+      eigen_assert(m_cpqr.m_isInitialized && "CompleteOrthogonalDecomposition is not initialized.");
+      eigen_assert((Transpose_?derived().cols():derived().rows())==b.rows() && "CompleteOrthogonalDecomposition::solve(): invalid number of rows of the right hand side matrix b");
+  }
+
+  void computeInPlace();
+
+  /** Overwrites \b rhs with \f$ \mathbf{Z} * \mathbf{rhs} \f$ or
+   *  \f$ \mathbf{\overline Z} * \mathbf{rhs} \f$ if \c Conjugate 
+   *  is set to \c true.
+   */
+  template <bool Conjugate, typename Rhs>
+  void applyZOnTheLeftInPlace(Rhs& rhs) const;
+
+  /** Overwrites \b rhs with \f$ \mathbf{Z}^* * \mathbf{rhs} \f$.
+   */
+  template <typename Rhs>
+  void applyZAdjointOnTheLeftInPlace(Rhs& rhs) const;
+
+  ColPivHouseholderQR<MatrixType> m_cpqr;
+  HCoeffsType m_zCoeffs;
+  RowVectorType m_temp;
+};
+
+template <typename MatrixType>
+typename MatrixType::RealScalar
+CompleteOrthogonalDecomposition<MatrixType>::absDeterminant() const {
+  return m_cpqr.absDeterminant();
+}
+
+template <typename MatrixType>
+typename MatrixType::RealScalar
+CompleteOrthogonalDecomposition<MatrixType>::logAbsDeterminant() const {
+  return m_cpqr.logAbsDeterminant();
+}
+
+/** Performs the complete orthogonal decomposition of the given matrix \a
+ * matrix. The result of the factorization is stored into \c *this, and a
+ * reference to \c *this is returned.
+ *
+ * \sa class CompleteOrthogonalDecomposition,
+ * CompleteOrthogonalDecomposition(const MatrixType&)
+ */
+template <typename MatrixType>
+void CompleteOrthogonalDecomposition<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  // the column permutation is stored as int indices, so just to be sure:
+  eigen_assert(m_cpqr.cols() <= NumTraits<int>::highest());
+
+  const Index rank = m_cpqr.rank();
+  const Index cols = m_cpqr.cols();
+  const Index rows = m_cpqr.rows();
+  m_zCoeffs.resize((std::min)(rows, cols));
+  m_temp.resize(cols);
+
+  if (rank < cols) {
+    // We have reduced the (permuted) matrix to the form
+    //   [R11 R12]
+    //   [ 0  R22]
+    // where R11 is r-by-r (r = rank) upper triangular, R12 is
+    // r-by-(n-r), and R22 is empty or the norm of R22 is negligible.
+    // We now compute the complete orthogonal decomposition by applying
+    // Householder transformations from the right to the upper trapezoidal
+    // matrix X = [R11 R12] to zero out R12 and obtain the factorization
+    // [R11 R12] = [T11 0] * Z, where T11 is r-by-r upper triangular and
+    // Z = Z(0) * Z(1) ... Z(r-1) is an n-by-n orthogonal matrix.
+    // We store the data representing Z in R12 and m_zCoeffs.
+    for (Index k = rank - 1; k >= 0; --k) {
+      if (k != rank - 1) {
+        // Given the API for Householder reflectors, it is more convenient if
+        // we swap the leading parts of columns k and r-1 (zero-based) to form
+        // the matrix X_k = [X(0:k, k), X(0:k, r:n)]
+        m_cpqr.m_qr.col(k).head(k + 1).swap(
+            m_cpqr.m_qr.col(rank - 1).head(k + 1));
+      }
+      // Construct Householder reflector Z(k) to zero out the last row of X_k,
+      // i.e. choose Z(k) such that
+      // [X(k, k), X(k, r:n)] * Z(k) = [beta, 0, .., 0].
+      RealScalar beta;
+      m_cpqr.m_qr.row(k)
+          .tail(cols - rank + 1)
+          .makeHouseholderInPlace(m_zCoeffs(k), beta);
+      m_cpqr.m_qr(k, rank - 1) = beta;
+      if (k > 0) {
+        // Apply Z(k) to the first k rows of X_k
+        m_cpqr.m_qr.topRightCorner(k, cols - rank + 1)
+            .applyHouseholderOnTheRight(
+                m_cpqr.m_qr.row(k).tail(cols - rank).adjoint(), m_zCoeffs(k),
+                &m_temp(0));
+      }
+      if (k != rank - 1) {
+        // Swap X(0:k,k) back to its proper location.
+        m_cpqr.m_qr.col(k).head(k + 1).swap(
+            m_cpqr.m_qr.col(rank - 1).head(k + 1));
+      }
+    }
+  }
+}
+
+template <typename MatrixType>
+template <bool Conjugate, typename Rhs>
+void CompleteOrthogonalDecomposition<MatrixType>::applyZOnTheLeftInPlace(
+    Rhs& rhs) const {
+  const Index cols = this->cols();
+  const Index nrhs = rhs.cols();
+  const Index rank = this->rank();
+  Matrix<typename Rhs::Scalar, Dynamic, 1> temp((std::max)(cols, nrhs));
+  for (Index k = rank-1; k >= 0; --k) {
+    if (k != rank - 1) {
+      rhs.row(k).swap(rhs.row(rank - 1));
+    }
+    rhs.middleRows(rank - 1, cols - rank + 1)
+        .applyHouseholderOnTheLeft(
+            matrixQTZ().row(k).tail(cols - rank).transpose().template conjugateIf<!Conjugate>(), zCoeffs().template conjugateIf<Conjugate>()(k),
+            &temp(0));
+    if (k != rank - 1) {
+      rhs.row(k).swap(rhs.row(rank - 1));
+    }
+  }
+}
+
+template <typename MatrixType>
+template <typename Rhs>
+void CompleteOrthogonalDecomposition<MatrixType>::applyZAdjointOnTheLeftInPlace(
+    Rhs& rhs) const {
+  const Index cols = this->cols();
+  const Index nrhs = rhs.cols();
+  const Index rank = this->rank();
+  Matrix<typename Rhs::Scalar, Dynamic, 1> temp((std::max)(cols, nrhs));
+  for (Index k = 0; k < rank; ++k) {
+    if (k != rank - 1) {
+      rhs.row(k).swap(rhs.row(rank - 1));
+    }
+    rhs.middleRows(rank - 1, cols - rank + 1)
+        .applyHouseholderOnTheLeft(
+            matrixQTZ().row(k).tail(cols - rank).adjoint(), zCoeffs()(k),
+            &temp(0));
+    if (k != rank - 1) {
+      rhs.row(k).swap(rhs.row(rank - 1));
+    }
+  }
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template <typename _MatrixType>
+template <typename RhsType, typename DstType>
+void CompleteOrthogonalDecomposition<_MatrixType>::_solve_impl(
+    const RhsType& rhs, DstType& dst) const {
+  const Index rank = this->rank();
+  if (rank == 0) {
+    dst.setZero();
+    return;
+  }
+
+  // Compute c = Q^* * rhs
+  typename RhsType::PlainObject c(rhs);
+  c.applyOnTheLeft(matrixQ().setLength(rank).adjoint());
+
+  // Solve T z = c(1:rank, :)
+  dst.topRows(rank) = matrixT()
+                          .topLeftCorner(rank, rank)
+                          .template triangularView<Upper>()
+                          .solve(c.topRows(rank));
+
+  const Index cols = this->cols();
+  if (rank < cols) {
+    // Compute y = Z^* * [ z ]
+    //                   [ 0 ]
+    dst.bottomRows(cols - rank).setZero();
+    applyZAdjointOnTheLeftInPlace(dst);
+  }
+
+  // Undo permutation to get x = P^{-1} * y.
+  dst = colsPermutation() * dst;
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void CompleteOrthogonalDecomposition<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  const Index rank = this->rank();
+
+  if (rank == 0) {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(colsPermutation().transpose()*rhs);
+
+  if (rank < cols()) {
+    applyZOnTheLeftInPlace<!Conjugate>(c);
+  }
+
+  matrixT().topLeftCorner(rank, rank)
+           .template triangularView<Upper>()
+           .transpose().template conjugateIf<Conjugate>()
+           .solveInPlace(c.topRows(rank));
+
+  dst.topRows(rank) = c.topRows(rank);
+  dst.bottomRows(rows()-rank).setZero();
+
+  dst.applyOnTheLeft(householderQ().setLength(rank).template conjugateIf<!Conjugate>() );
+}
+#endif
+
+namespace internal {
+
+template<typename MatrixType>
+struct traits<Inverse<CompleteOrthogonalDecomposition<MatrixType> > >
+  : traits<typename Transpose<typename MatrixType::PlainObject>::PlainObject>
+{
+  enum { Flags = 0 };
+};
+
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<CompleteOrthogonalDecomposition<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename CompleteOrthogonalDecomposition<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef CompleteOrthogonalDecomposition<MatrixType> CodType;
+  typedef Inverse<CodType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename CodType::Scalar> &)
+  {
+    typedef Matrix<typename CodType::Scalar, CodType::RowsAtCompileTime, CodType::RowsAtCompileTime, 0, CodType::MaxRowsAtCompileTime, CodType::MaxRowsAtCompileTime> IdentityMatrixType;
+    dst = src.nestedExpression().solve(IdentityMatrixType::Identity(src.cols(), src.cols()));
+  }
+};
+
+} // end namespace internal
+
+/** \returns the matrix Q as a sequence of householder transformations */
+template <typename MatrixType>
+typename CompleteOrthogonalDecomposition<MatrixType>::HouseholderSequenceType
+CompleteOrthogonalDecomposition<MatrixType>::householderQ() const {
+  return m_cpqr.householderQ();
+}
+
+/** \return the complete orthogonal decomposition of \c *this.
+  *
+  * \sa class CompleteOrthogonalDecomposition
+  */
+template <typename Derived>
+const CompleteOrthogonalDecomposition<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::completeOrthogonalDecomposition() const {
+  return CompleteOrthogonalDecomposition<PlainObject>(eval());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/QR/FullPivHouseholderQR.h b/C++/yolo_bytetrack_old/include/Eigen/src/QR/FullPivHouseholderQR.h
new file mode 100644
index 00000000..d0664a1d
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/QR/FullPivHouseholderQR.h
@@ -0,0 +1,713 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
+#define EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename _MatrixType> struct traits<FullPivHouseholderQR<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+template<typename MatrixType> struct FullPivHouseholderQRMatrixQReturnType;
+
+template<typename MatrixType>
+struct traits<FullPivHouseholderQRMatrixQReturnType<MatrixType> >
+{
+  typedef typename MatrixType::PlainObject ReturnType;
+};
+
+} // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  * \class FullPivHouseholderQR
+  *
+  * \brief Householder rank-revealing QR decomposition of a matrix with full pivoting
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the QR decomposition
+  *
+  * This class performs a rank-revealing QR decomposition of a matrix \b A into matrices \b P, \b P', \b Q and \b R
+  * such that 
+  * \f[
+  *  \mathbf{P} \, \mathbf{A} \, \mathbf{P}' = \mathbf{Q} \, \mathbf{R}
+  * \f]
+  * by using Householder transformations. Here, \b P and \b P' are permutation matrices, \b Q a unitary matrix 
+  * and \b R an upper triangular matrix.
+  *
+  * This decomposition performs a very prudent full pivoting in order to be rank-revealing and achieve optimal
+  * numerical stability. The trade-off is that it is slower than HouseholderQR and ColPivHouseholderQR.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  * 
+  * \sa MatrixBase::fullPivHouseholderQr()
+  */
+template<typename _MatrixType> class FullPivHouseholderQR
+        : public SolverBase<FullPivHouseholderQR<_MatrixType> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<FullPivHouseholderQR> Base;
+    friend class SolverBase<FullPivHouseholderQR>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(FullPivHouseholderQR)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef internal::FullPivHouseholderQRMatrixQReturnType<MatrixType> MatrixQReturnType;
+    typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+    typedef Matrix<StorageIndex, 1,
+                   EIGEN_SIZE_MIN_PREFER_DYNAMIC(ColsAtCompileTime,RowsAtCompileTime), RowMajor, 1,
+                   EIGEN_SIZE_MIN_PREFER_FIXED(MaxColsAtCompileTime,MaxRowsAtCompileTime)> IntDiagSizeVectorType;
+    typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationType;
+    typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+    typedef typename internal::plain_col_type<MatrixType>::type ColVectorType;
+    typedef typename MatrixType::PlainObject PlainObject;
+
+    /** \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via FullPivHouseholderQR::compute(const MatrixType&).
+      */
+    FullPivHouseholderQR()
+      : m_qr(),
+        m_hCoeffs(),
+        m_rows_transpositions(),
+        m_cols_transpositions(),
+        m_cols_permutation(),
+        m_temp(),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa FullPivHouseholderQR()
+      */
+    FullPivHouseholderQR(Index rows, Index cols)
+      : m_qr(rows, cols),
+        m_hCoeffs((std::min)(rows,cols)),
+        m_rows_transpositions((std::min)(rows,cols)),
+        m_cols_transpositions((std::min)(rows,cols)),
+        m_cols_permutation(cols),
+        m_temp(cols),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false) {}
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This constructor computes the QR factorization of the matrix \a matrix by calling
+      * the method compute(). It is a short cut for:
+      * 
+      * \code
+      * FullPivHouseholderQR<MatrixType> qr(matrix.rows(), matrix.cols());
+      * qr.compute(matrix);
+      * \endcode
+      * 
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit FullPivHouseholderQR(const EigenBase<InputType>& matrix)
+      : m_qr(matrix.rows(), matrix.cols()),
+        m_hCoeffs((std::min)(matrix.rows(), matrix.cols())),
+        m_rows_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_permutation(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      compute(matrix.derived());
+    }
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
+      *
+      * \sa FullPivHouseholderQR(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit FullPivHouseholderQR(EigenBase<InputType>& matrix)
+      : m_qr(matrix.derived()),
+        m_hCoeffs((std::min)(matrix.rows(), matrix.cols())),
+        m_rows_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_transpositions((std::min)(matrix.rows(), matrix.cols())),
+        m_cols_permutation(matrix.cols()),
+        m_temp(matrix.cols()),
+        m_isInitialized(false),
+        m_usePrescribedThreshold(false)
+    {
+      computeInPlace();
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** This method finds a solution x to the equation Ax=b, where A is the matrix of which
+      * \c *this is the QR decomposition.
+      *
+      * \param b the right-hand-side of the equation to solve.
+      *
+      * \returns the exact or least-square solution if the rank is greater or equal to the number of columns of A,
+      * and an arbitrary solution otherwise.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      *
+      * Example: \include FullPivHouseholderQR_solve.cpp
+      * Output: \verbinclude FullPivHouseholderQR_solve.out
+      */
+    template<typename Rhs>
+    inline const Solve<FullPivHouseholderQR, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    /** \returns Expression object representing the matrix Q
+      */
+    MatrixQReturnType matrixQ(void) const;
+
+    /** \returns a reference to the matrix where the Householder QR decomposition is stored
+      */
+    const MatrixType& matrixQR() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return m_qr;
+    }
+
+    template<typename InputType>
+    FullPivHouseholderQR& compute(const EigenBase<InputType>& matrix);
+
+    /** \returns a const reference to the column permutation matrix */
+    const PermutationType& colsPermutation() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return m_cols_permutation;
+    }
+
+    /** \returns a const reference to the vector of indices representing the rows transpositions */
+    const IntDiagSizeVectorType& rowsTranspositions() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return m_rows_transpositions;
+    }
+
+    /** \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar absDeterminant() const;
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's inherent
+      * to determinant computation.
+      *
+      * \sa absDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar logAbsDeterminant() const;
+
+    /** \returns the rank of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index rank() const
+    {
+      using std::abs;
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
+      Index result = 0;
+      for(Index i = 0; i < m_nonzero_pivots; ++i)
+        result += (abs(m_qr.coeff(i,i)) > premultiplied_threshold);
+      return result;
+    }
+
+    /** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline Index dimensionOfKernel() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return cols() - rank();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents an injective
+      *          linear map, i.e. has trivial kernel; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInjective() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return rank() == cols();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition represents a surjective
+      *          linear map; false otherwise.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isSurjective() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return rank() == rows();
+    }
+
+    /** \returns true if the matrix of which *this is the QR decomposition is invertible.
+      *
+      * \note This method has to determine which pivots should be considered nonzero.
+      *       For that, it uses the threshold value that you can control by calling
+      *       setThreshold(const RealScalar&).
+      */
+    inline bool isInvertible() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return isInjective() && isSurjective();
+    }
+
+    /** \returns the inverse of the matrix of which *this is the QR decomposition.
+      *
+      * \note If this matrix is not invertible, the returned matrix has undefined coefficients.
+      *       Use isInvertible() to first determine whether this matrix is invertible.
+      */
+    inline const Inverse<FullPivHouseholderQR> inverse() const
+    {
+      eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+      return Inverse<FullPivHouseholderQR>(*this);
+    }
+
+    inline Index rows() const { return m_qr.rows(); }
+    inline Index cols() const { return m_qr.cols(); }
+    
+    /** \returns a const reference to the vector of Householder coefficients used to represent the factor \c Q.
+      * 
+      * For advanced uses only.
+      */
+    const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
+
+    /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
+      * who need to determine when pivots are to be considered nonzero. This is not used for the
+      * QR decomposition itself.
+      *
+      * When it needs to get the threshold value, Eigen calls threshold(). By default, this
+      * uses a formula to automatically determine a reasonable threshold.
+      * Once you have called the present method setThreshold(const RealScalar&),
+      * your value is used instead.
+      *
+      * \param threshold The new value to use as the threshold.
+      *
+      * A pivot will be considered nonzero if its absolute value is strictly greater than
+      *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+      * where maxpivot is the biggest pivot.
+      *
+      * If you want to come back to the default behavior, call setThreshold(Default_t)
+      */
+    FullPivHouseholderQR& setThreshold(const RealScalar& threshold)
+    {
+      m_usePrescribedThreshold = true;
+      m_prescribedThreshold = threshold;
+      return *this;
+    }
+
+    /** Allows to come back to the default behavior, letting Eigen use its default formula for
+      * determining the threshold.
+      *
+      * You should pass the special object Eigen::Default as parameter here.
+      * \code qr.setThreshold(Eigen::Default); \endcode
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    FullPivHouseholderQR& setThreshold(Default_t)
+    {
+      m_usePrescribedThreshold = false;
+      return *this;
+    }
+
+    /** Returns the threshold that will be used by certain methods such as rank().
+      *
+      * See the documentation of setThreshold(const RealScalar&).
+      */
+    RealScalar threshold() const
+    {
+      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+      return m_usePrescribedThreshold ? m_prescribedThreshold
+      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
+      // and turns out to be identical to Higham's formula used already in LDLt.
+                                      : NumTraits<Scalar>::epsilon() * RealScalar(m_qr.diagonalSize());
+    }
+
+    /** \returns the number of nonzero pivots in the QR decomposition.
+      * Here nonzero is meant in the exact sense, not in a fuzzy sense.
+      * So that notion isn't really intrinsically interesting, but it is
+      * still useful when implementing algorithms.
+      *
+      * \sa rank()
+      */
+    inline Index nonzeroPivots() const
+    {
+      eigen_assert(m_isInitialized && "LU is not initialized.");
+      return m_nonzero_pivots;
+    }
+
+    /** \returns the absolute value of the biggest pivot, i.e. the biggest
+      *          diagonal coefficient of U.
+      */
+    RealScalar maxPivot() const { return m_maxpivot; }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_qr;
+    HCoeffsType m_hCoeffs;
+    IntDiagSizeVectorType m_rows_transpositions;
+    IntDiagSizeVectorType m_cols_transpositions;
+    PermutationType m_cols_permutation;
+    RowVectorType m_temp;
+    bool m_isInitialized, m_usePrescribedThreshold;
+    RealScalar m_prescribedThreshold, m_maxpivot;
+    Index m_nonzero_pivots;
+    RealScalar m_precision;
+    Index m_det_pq;
+};
+
+template<typename MatrixType>
+typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::absDeterminant() const
+{
+  using std::abs;
+  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return abs(m_qr.diagonal().prod());
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::logAbsDeterminant() const
+{
+  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return m_qr.diagonal().cwiseAbs().array().log().sum();
+}
+
+/** Performs the QR factorization of the given matrix \a matrix. The result of
+  * the factorization is stored into \c *this, and a reference to \c *this
+  * is returned.
+  *
+  * \sa class FullPivHouseholderQR, FullPivHouseholderQR(const MatrixType&)
+  */
+template<typename MatrixType>
+template<typename InputType>
+FullPivHouseholderQR<MatrixType>& FullPivHouseholderQR<MatrixType>::compute(const EigenBase<InputType>& matrix)
+{
+  m_qr = matrix.derived();
+  computeInPlace();
+  return *this;
+}
+
+template<typename MatrixType>
+void FullPivHouseholderQR<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+
+  using std::abs;
+  Index rows = m_qr.rows();
+  Index cols = m_qr.cols();
+  Index size = (std::min)(rows,cols);
+
+  
+  m_hCoeffs.resize(size);
+
+  m_temp.resize(cols);
+
+  m_precision = NumTraits<Scalar>::epsilon() * RealScalar(size);
+
+  m_rows_transpositions.resize(size);
+  m_cols_transpositions.resize(size);
+  Index number_of_transpositions = 0;
+
+  RealScalar biggest(0);
+
+  m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case)
+  m_maxpivot = RealScalar(0);
+
+  for (Index k = 0; k < size; ++k)
+  {
+    Index row_of_biggest_in_corner, col_of_biggest_in_corner;
+    typedef internal::scalar_score_coeff_op<Scalar> Scoring;
+    typedef typename Scoring::result_type Score;
+
+    Score score = m_qr.bottomRightCorner(rows-k, cols-k)
+                      .unaryExpr(Scoring())
+                      .maxCoeff(&row_of_biggest_in_corner, &col_of_biggest_in_corner);
+    row_of_biggest_in_corner += k;
+    col_of_biggest_in_corner += k;
+    RealScalar biggest_in_corner = internal::abs_knowing_score<Scalar>()(m_qr(row_of_biggest_in_corner, col_of_biggest_in_corner), score);
+    if(k==0) biggest = biggest_in_corner;
+
+    // if the corner is negligible, then we have less than full rank, and we can finish early
+    if(internal::isMuchSmallerThan(biggest_in_corner, biggest, m_precision))
+    {
+      m_nonzero_pivots = k;
+      for(Index i = k; i < size; i++)
+      {
+        m_rows_transpositions.coeffRef(i) = internal::convert_index<StorageIndex>(i);
+        m_cols_transpositions.coeffRef(i) = internal::convert_index<StorageIndex>(i);
+        m_hCoeffs.coeffRef(i) = Scalar(0);
+      }
+      break;
+    }
+
+    m_rows_transpositions.coeffRef(k) = internal::convert_index<StorageIndex>(row_of_biggest_in_corner);
+    m_cols_transpositions.coeffRef(k) = internal::convert_index<StorageIndex>(col_of_biggest_in_corner);
+    if(k != row_of_biggest_in_corner) {
+      m_qr.row(k).tail(cols-k).swap(m_qr.row(row_of_biggest_in_corner).tail(cols-k));
+      ++number_of_transpositions;
+    }
+    if(k != col_of_biggest_in_corner) {
+      m_qr.col(k).swap(m_qr.col(col_of_biggest_in_corner));
+      ++number_of_transpositions;
+    }
+
+    RealScalar beta;
+    m_qr.col(k).tail(rows-k).makeHouseholderInPlace(m_hCoeffs.coeffRef(k), beta);
+    m_qr.coeffRef(k,k) = beta;
+
+    // remember the maximum absolute value of diagonal coefficients
+    if(abs(beta) > m_maxpivot) m_maxpivot = abs(beta);
+
+    m_qr.bottomRightCorner(rows-k, cols-k-1)
+        .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k+1));
+  }
+
+  m_cols_permutation.setIdentity(cols);
+  for(Index k = 0; k < size; ++k)
+    m_cols_permutation.applyTranspositionOnTheRight(k, m_cols_transpositions.coeff(k));
+
+  m_det_pq = (number_of_transpositions%2) ? -1 : 1;
+  m_isInitialized = true;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void FullPivHouseholderQR<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  const Index l_rank = rank();
+
+  // FIXME introduce nonzeroPivots() and use it here. and more generally,
+  // make the same improvements in this dec as in FullPivLU.
+  if(l_rank==0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs);
+
+  Matrix<typename RhsType::Scalar,1,RhsType::ColsAtCompileTime> temp(rhs.cols());
+  for (Index k = 0; k < l_rank; ++k)
+  {
+    Index remainingSize = rows()-k;
+    c.row(k).swap(c.row(m_rows_transpositions.coeff(k)));
+    c.bottomRightCorner(remainingSize, rhs.cols())
+      .applyHouseholderOnTheLeft(m_qr.col(k).tail(remainingSize-1),
+                               m_hCoeffs.coeff(k), &temp.coeffRef(0));
+  }
+
+  m_qr.topLeftCorner(l_rank, l_rank)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(l_rank));
+
+  for(Index i = 0; i < l_rank; ++i) dst.row(m_cols_permutation.indices().coeff(i)) = c.row(i);
+  for(Index i = l_rank; i < cols(); ++i) dst.row(m_cols_permutation.indices().coeff(i)).setZero();
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void FullPivHouseholderQR<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  const Index l_rank = rank();
+
+  if(l_rank == 0)
+  {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(m_cols_permutation.transpose()*rhs);
+
+  m_qr.topLeftCorner(l_rank, l_rank)
+         .template triangularView<Upper>()
+         .transpose().template conjugateIf<Conjugate>()
+         .solveInPlace(c.topRows(l_rank));
+
+  dst.topRows(l_rank) = c.topRows(l_rank);
+  dst.bottomRows(rows()-l_rank).setZero();
+
+  Matrix<Scalar, 1, DstType::ColsAtCompileTime> temp(dst.cols());
+  const Index size = (std::min)(rows(), cols());
+  for (Index k = size-1; k >= 0; --k)
+  {
+    Index remainingSize = rows()-k;
+
+    dst.bottomRightCorner(remainingSize, dst.cols())
+       .applyHouseholderOnTheLeft(m_qr.col(k).tail(remainingSize-1).template conjugateIf<!Conjugate>(),
+                                  m_hCoeffs.template conjugateIf<Conjugate>().coeff(k), &temp.coeffRef(0));
+
+    dst.row(k).swap(dst.row(m_rows_transpositions.coeff(k)));
+  }
+}
+#endif
+
+namespace internal {
+  
+template<typename DstXprType, typename MatrixType>
+struct Assignment<DstXprType, Inverse<FullPivHouseholderQR<MatrixType> >, internal::assign_op<typename DstXprType::Scalar,typename FullPivHouseholderQR<MatrixType>::Scalar>, Dense2Dense>
+{
+  typedef FullPivHouseholderQR<MatrixType> QrType;
+  typedef Inverse<QrType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename QrType::Scalar> &)
+  {    
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+
+/** \ingroup QR_Module
+  *
+  * \brief Expression type for return value of FullPivHouseholderQR::matrixQ()
+  *
+  * \tparam MatrixType type of underlying dense matrix
+  */
+template<typename MatrixType> struct FullPivHouseholderQRMatrixQReturnType
+  : public ReturnByValue<FullPivHouseholderQRMatrixQReturnType<MatrixType> >
+{
+public:
+  typedef typename FullPivHouseholderQR<MatrixType>::IntDiagSizeVectorType IntDiagSizeVectorType;
+  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+  typedef Matrix<typename MatrixType::Scalar, 1, MatrixType::RowsAtCompileTime, RowMajor, 1,
+                 MatrixType::MaxRowsAtCompileTime> WorkVectorType;
+
+  FullPivHouseholderQRMatrixQReturnType(const MatrixType&       qr,
+                                        const HCoeffsType&      hCoeffs,
+                                        const IntDiagSizeVectorType& rowsTranspositions)
+    : m_qr(qr),
+      m_hCoeffs(hCoeffs),
+      m_rowsTranspositions(rowsTranspositions)
+  {}
+
+  template <typename ResultType>
+  void evalTo(ResultType& result) const
+  {
+    const Index rows = m_qr.rows();
+    WorkVectorType workspace(rows);
+    evalTo(result, workspace);
+  }
+
+  template <typename ResultType>
+  void evalTo(ResultType& result, WorkVectorType& workspace) const
+  {
+    using numext::conj;
+    // compute the product H'_0 H'_1 ... H'_n-1,
+    // where H_k is the k-th Householder transformation I - h_k v_k v_k'
+    // and v_k is the k-th Householder vector [1,m_qr(k+1,k), m_qr(k+2,k), ...]
+    const Index rows = m_qr.rows();
+    const Index cols = m_qr.cols();
+    const Index size = (std::min)(rows, cols);
+    workspace.resize(rows);
+    result.setIdentity(rows, rows);
+    for (Index k = size-1; k >= 0; k--)
+    {
+      result.block(k, k, rows-k, rows-k)
+            .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), conj(m_hCoeffs.coeff(k)), &workspace.coeffRef(k));
+      result.row(k).swap(result.row(m_rowsTranspositions.coeff(k)));
+    }
+  }
+
+  Index rows() const { return m_qr.rows(); }
+  Index cols() const { return m_qr.rows(); }
+
+protected:
+  typename MatrixType::Nested m_qr;
+  typename HCoeffsType::Nested m_hCoeffs;
+  typename IntDiagSizeVectorType::Nested m_rowsTranspositions;
+};
+
+// template<typename MatrixType>
+// struct evaluator<FullPivHouseholderQRMatrixQReturnType<MatrixType> >
+//  : public evaluator<ReturnByValue<FullPivHouseholderQRMatrixQReturnType<MatrixType> > >
+// {};
+
+} // end namespace internal
+
+template<typename MatrixType>
+inline typename FullPivHouseholderQR<MatrixType>::MatrixQReturnType FullPivHouseholderQR<MatrixType>::matrixQ() const
+{
+  eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
+  return MatrixQReturnType(m_qr, m_hCoeffs, m_rows_transpositions);
+}
+
+/** \return the full-pivoting Householder QR decomposition of \c *this.
+  *
+  * \sa class FullPivHouseholderQR
+  */
+template<typename Derived>
+const FullPivHouseholderQR<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::fullPivHouseholderQr() const
+{
+  return FullPivHouseholderQR<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/QR/HouseholderQR.h b/C++/yolo_bytetrack_old/include/Eigen/src/QR/HouseholderQR.h
new file mode 100644
index 00000000..801739fb
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/QR/HouseholderQR.h
@@ -0,0 +1,434 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2010 Vincent Lejeune
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_QR_H
+#define EIGEN_QR_H
+
+namespace Eigen { 
+
+namespace internal {
+template<typename _MatrixType> struct traits<HouseholderQR<_MatrixType> >
+ : traits<_MatrixType>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+
+} // end namespace internal
+
+/** \ingroup QR_Module
+  *
+  *
+  * \class HouseholderQR
+  *
+  * \brief Householder QR decomposition of a matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the QR decomposition
+  *
+  * This class performs a QR decomposition of a matrix \b A into matrices \b Q and \b R
+  * such that 
+  * \f[
+  *  \mathbf{A} = \mathbf{Q} \, \mathbf{R}
+  * \f]
+  * by using Householder transformations. Here, \b Q a unitary matrix and \b R an upper triangular matrix.
+  * The result is stored in a compact way compatible with LAPACK.
+  *
+  * Note that no pivoting is performed. This is \b not a rank-revealing decomposition.
+  * If you want that feature, use FullPivHouseholderQR or ColPivHouseholderQR instead.
+  *
+  * This Householder QR decomposition is faster, but less numerically stable and less feature-full than
+  * FullPivHouseholderQR or ColPivHouseholderQR.
+  *
+  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+  *
+  * \sa MatrixBase::householderQr()
+  */
+template<typename _MatrixType> class HouseholderQR
+        : public SolverBase<HouseholderQR<_MatrixType> >
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef SolverBase<HouseholderQR> Base;
+    friend class SolverBase<HouseholderQR>;
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(HouseholderQR)
+    enum {
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, (MatrixType::Flags&RowMajorBit) ? RowMajor : ColMajor, MaxRowsAtCompileTime, MaxRowsAtCompileTime> MatrixQType;
+    typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
+    typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
+    typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename HCoeffsType::ConjugateReturnType>::type> HouseholderSequenceType;
+
+    /**
+      * \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via HouseholderQR::compute(const MatrixType&).
+      */
+    HouseholderQR() : m_qr(), m_hCoeffs(), m_temp(), m_isInitialized(false) {}
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem \a size.
+      * \sa HouseholderQR()
+      */
+    HouseholderQR(Index rows, Index cols)
+      : m_qr(rows, cols),
+        m_hCoeffs((std::min)(rows,cols)),
+        m_temp(cols),
+        m_isInitialized(false) {}
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This constructor computes the QR factorization of the matrix \a matrix by calling
+      * the method compute(). It is a short cut for:
+      * 
+      * \code
+      * HouseholderQR<MatrixType> qr(matrix.rows(), matrix.cols());
+      * qr.compute(matrix);
+      * \endcode
+      * 
+      * \sa compute()
+      */
+    template<typename InputType>
+    explicit HouseholderQR(const EigenBase<InputType>& matrix)
+      : m_qr(matrix.rows(), matrix.cols()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_temp(matrix.cols()),
+        m_isInitialized(false)
+    {
+      compute(matrix.derived());
+    }
+
+
+    /** \brief Constructs a QR factorization from a given matrix
+      *
+      * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when
+      * \c MatrixType is a Eigen::Ref.
+      *
+      * \sa HouseholderQR(const EigenBase&)
+      */
+    template<typename InputType>
+    explicit HouseholderQR(EigenBase<InputType>& matrix)
+      : m_qr(matrix.derived()),
+        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
+        m_temp(matrix.cols()),
+        m_isInitialized(false)
+    {
+      computeInPlace();
+    }
+
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** This method finds a solution x to the equation Ax=b, where A is the matrix of which
+      * *this is the QR decomposition, if any exists.
+      *
+      * \param b the right-hand-side of the equation to solve.
+      *
+      * \returns a solution.
+      *
+      * \note_about_checking_solutions
+      *
+      * \note_about_arbitrary_choice_of_solution
+      *
+      * Example: \include HouseholderQR_solve.cpp
+      * Output: \verbinclude HouseholderQR_solve.out
+      */
+    template<typename Rhs>
+    inline const Solve<HouseholderQR, Rhs>
+    solve(const MatrixBase<Rhs>& b) const;
+    #endif
+
+    /** This method returns an expression of the unitary matrix Q as a sequence of Householder transformations.
+      *
+      * The returned expression can directly be used to perform matrix products. It can also be assigned to a dense Matrix object.
+      * Here is an example showing how to recover the full or thin matrix Q, as well as how to perform matrix products using operator*:
+      *
+      * Example: \include HouseholderQR_householderQ.cpp
+      * Output: \verbinclude HouseholderQR_householderQ.out
+      */
+    HouseholderSequenceType householderQ() const
+    {
+      eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+      return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate());
+    }
+
+    /** \returns a reference to the matrix where the Householder QR decomposition is stored
+      * in a LAPACK-compatible way.
+      */
+    const MatrixType& matrixQR() const
+    {
+        eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+        return m_qr;
+    }
+
+    template<typename InputType>
+    HouseholderQR& compute(const EigenBase<InputType>& matrix) {
+      m_qr = matrix.derived();
+      computeInPlace();
+      return *this;
+    }
+
+    /** \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar absDeterminant() const;
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition. It has only linear complexity
+      * (that is, O(n) where n is the dimension of the square matrix)
+      * as the QR decomposition has already been computed.
+      *
+      * \note This is only for square matrices.
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's inherent
+      * to determinant computation.
+      *
+      * \sa absDeterminant(), MatrixBase::determinant()
+      */
+    typename MatrixType::RealScalar logAbsDeterminant() const;
+
+    inline Index rows() const { return m_qr.rows(); }
+    inline Index cols() const { return m_qr.cols(); }
+
+    /** \returns a const reference to the vector of Householder coefficients used to represent the factor \c Q.
+      * 
+      * For advanced uses only.
+      */
+    const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename RhsType, typename DstType>
+    void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+    template<bool Conjugate, typename RhsType, typename DstType>
+    void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+    #endif
+
+  protected:
+
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+    }
+
+    void computeInPlace();
+
+    MatrixType m_qr;
+    HCoeffsType m_hCoeffs;
+    RowVectorType m_temp;
+    bool m_isInitialized;
+};
+
+template<typename MatrixType>
+typename MatrixType::RealScalar HouseholderQR<MatrixType>::absDeterminant() const
+{
+  using std::abs;
+  eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return abs(m_qr.diagonal().prod());
+}
+
+template<typename MatrixType>
+typename MatrixType::RealScalar HouseholderQR<MatrixType>::logAbsDeterminant() const
+{
+  eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return m_qr.diagonal().cwiseAbs().array().log().sum();
+}
+
+namespace internal {
+
+/** \internal */
+template<typename MatrixQR, typename HCoeffs>
+void householder_qr_inplace_unblocked(MatrixQR& mat, HCoeffs& hCoeffs, typename MatrixQR::Scalar* tempData = 0)
+{
+  typedef typename MatrixQR::Scalar Scalar;
+  typedef typename MatrixQR::RealScalar RealScalar;
+  Index rows = mat.rows();
+  Index cols = mat.cols();
+  Index size = (std::min)(rows,cols);
+
+  eigen_assert(hCoeffs.size() == size);
+
+  typedef Matrix<Scalar,MatrixQR::ColsAtCompileTime,1> TempType;
+  TempType tempVector;
+  if(tempData==0)
+  {
+    tempVector.resize(cols);
+    tempData = tempVector.data();
+  }
+
+  for(Index k = 0; k < size; ++k)
+  {
+    Index remainingRows = rows - k;
+    Index remainingCols = cols - k - 1;
+
+    RealScalar beta;
+    mat.col(k).tail(remainingRows).makeHouseholderInPlace(hCoeffs.coeffRef(k), beta);
+    mat.coeffRef(k,k) = beta;
+
+    // apply H to remaining part of m_qr from the left
+    mat.bottomRightCorner(remainingRows, remainingCols)
+        .applyHouseholderOnTheLeft(mat.col(k).tail(remainingRows-1), hCoeffs.coeffRef(k), tempData+k+1);
+  }
+}
+
+/** \internal */
+template<typename MatrixQR, typename HCoeffs,
+  typename MatrixQRScalar = typename MatrixQR::Scalar,
+  bool InnerStrideIsOne = (MatrixQR::InnerStrideAtCompileTime == 1 && HCoeffs::InnerStrideAtCompileTime == 1)>
+struct householder_qr_inplace_blocked
+{
+  // This is specialized for LAPACK-supported Scalar types in HouseholderQR_LAPACKE.h
+  static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index maxBlockSize=32,
+      typename MatrixQR::Scalar* tempData = 0)
+  {
+    typedef typename MatrixQR::Scalar Scalar;
+    typedef Block<MatrixQR,Dynamic,Dynamic> BlockType;
+
+    Index rows = mat.rows();
+    Index cols = mat.cols();
+    Index size = (std::min)(rows, cols);
+
+    typedef Matrix<Scalar,Dynamic,1,ColMajor,MatrixQR::MaxColsAtCompileTime,1> TempType;
+    TempType tempVector;
+    if(tempData==0)
+    {
+      tempVector.resize(cols);
+      tempData = tempVector.data();
+    }
+
+    Index blockSize = (std::min)(maxBlockSize,size);
+
+    Index k = 0;
+    for (k = 0; k < size; k += blockSize)
+    {
+      Index bs = (std::min)(size-k,blockSize);  // actual size of the block
+      Index tcols = cols - k - bs;              // trailing columns
+      Index brows = rows-k;                     // rows of the block
+
+      // partition the matrix:
+      //        A00 | A01 | A02
+      // mat  = A10 | A11 | A12
+      //        A20 | A21 | A22
+      // and performs the qr dec of [A11^T A12^T]^T
+      // and update [A21^T A22^T]^T using level 3 operations.
+      // Finally, the algorithm continue on A22
+
+      BlockType A11_21 = mat.block(k,k,brows,bs);
+      Block<HCoeffs,Dynamic,1> hCoeffsSegment = hCoeffs.segment(k,bs);
+
+      householder_qr_inplace_unblocked(A11_21, hCoeffsSegment, tempData);
+
+      if(tcols)
+      {
+        BlockType A21_22 = mat.block(k,k+bs,brows,tcols);
+        apply_block_householder_on_the_left(A21_22,A11_21,hCoeffsSegment, false); // false == backward
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename _MatrixType>
+template<typename RhsType, typename DstType>
+void HouseholderQR<_MatrixType>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  const Index rank = (std::min)(rows(), cols());
+
+  typename RhsType::PlainObject c(rhs);
+
+  c.applyOnTheLeft(householderQ().setLength(rank).adjoint() );
+
+  m_qr.topLeftCorner(rank, rank)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(rank));
+
+  dst.topRows(rank) = c.topRows(rank);
+  dst.bottomRows(cols()-rank).setZero();
+}
+
+template<typename _MatrixType>
+template<bool Conjugate, typename RhsType, typename DstType>
+void HouseholderQR<_MatrixType>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  const Index rank = (std::min)(rows(), cols());
+
+  typename RhsType::PlainObject c(rhs);
+
+  m_qr.topLeftCorner(rank, rank)
+      .template triangularView<Upper>()
+      .transpose().template conjugateIf<Conjugate>()
+      .solveInPlace(c.topRows(rank));
+
+  dst.topRows(rank) = c.topRows(rank);
+  dst.bottomRows(rows()-rank).setZero();
+
+  dst.applyOnTheLeft(householderQ().setLength(rank).template conjugateIf<!Conjugate>() );
+}
+#endif
+
+/** Performs the QR factorization of the given matrix \a matrix. The result of
+  * the factorization is stored into \c *this, and a reference to \c *this
+  * is returned.
+  *
+  * \sa class HouseholderQR, HouseholderQR(const MatrixType&)
+  */
+template<typename MatrixType>
+void HouseholderQR<MatrixType>::computeInPlace()
+{
+  check_template_parameters();
+  
+  Index rows = m_qr.rows();
+  Index cols = m_qr.cols();
+  Index size = (std::min)(rows,cols);
+
+  m_hCoeffs.resize(size);
+
+  m_temp.resize(cols);
+
+  internal::householder_qr_inplace_blocked<MatrixType, HCoeffsType>::run(m_qr, m_hCoeffs, 48, m_temp.data());
+
+  m_isInitialized = true;
+}
+
+/** \return the Householder QR decomposition of \c *this.
+  *
+  * \sa class HouseholderQR
+  */
+template<typename Derived>
+const HouseholderQR<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::householderQr() const
+{
+  return HouseholderQR<PlainObject>(eval());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_QR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/QR/HouseholderQR_LAPACKE.h b/C++/yolo_bytetrack_old/include/Eigen/src/QR/HouseholderQR_LAPACKE.h
new file mode 100644
index 00000000..1dc7d536
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/QR/HouseholderQR_LAPACKE.h
@@ -0,0 +1,68 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Householder QR decomposition of a matrix w/o pivoting based on
+ *    LAPACKE_?geqrf function.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_QR_LAPACKE_H
+#define EIGEN_QR_LAPACKE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_QR_NOPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX) \
+template<typename MatrixQR, typename HCoeffs> \
+struct householder_qr_inplace_blocked<MatrixQR, HCoeffs, EIGTYPE, true> \
+{ \
+  static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index = 32, \
+      typename MatrixQR::Scalar* = 0) \
+  { \
+    lapack_int m = (lapack_int) mat.rows(); \
+    lapack_int n = (lapack_int) mat.cols(); \
+    lapack_int lda = (lapack_int) mat.outerStride(); \
+    lapack_int matrix_order = (MatrixQR::IsRowMajor) ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
+    LAPACKE_##LAPACKE_PREFIX##geqrf( matrix_order, m, n, (LAPACKE_TYPE*)mat.data(), lda, (LAPACKE_TYPE*)hCoeffs.data()); \
+    hCoeffs.adjointInPlace(); \
+  } \
+};
+
+EIGEN_LAPACKE_QR_NOPIV(double, double, d)
+EIGEN_LAPACKE_QR_NOPIV(float, float, s)
+EIGEN_LAPACKE_QR_NOPIV(dcomplex, lapack_complex_double, z)
+EIGEN_LAPACKE_QR_NOPIV(scomplex, lapack_complex_float, c)
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_QR_LAPACKE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h b/C++/yolo_bytetrack_old/include/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
new file mode 100644
index 00000000..013c7ae7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
@@ -0,0 +1,335 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SUITESPARSEQRSUPPORT_H
+#define EIGEN_SUITESPARSEQRSUPPORT_H
+
+namespace Eigen {
+  
+  template<typename MatrixType> class SPQR; 
+  template<typename SPQRType> struct SPQRMatrixQReturnType; 
+  template<typename SPQRType> struct SPQRMatrixQTransposeReturnType; 
+  template <typename SPQRType, typename Derived> struct SPQR_QProduct;
+  namespace internal {
+    template <typename SPQRType> struct traits<SPQRMatrixQReturnType<SPQRType> >
+    {
+      typedef typename SPQRType::MatrixType ReturnType;
+    };
+    template <typename SPQRType> struct traits<SPQRMatrixQTransposeReturnType<SPQRType> >
+    {
+      typedef typename SPQRType::MatrixType ReturnType;
+    };
+    template <typename SPQRType, typename Derived> struct traits<SPQR_QProduct<SPQRType, Derived> >
+    {
+      typedef typename Derived::PlainObject ReturnType;
+    };
+  } // End namespace internal
+  
+/**
+  * \ingroup SPQRSupport_Module
+  * \class SPQR
+  * \brief Sparse QR factorization based on SuiteSparseQR library
+  *
+  * This class is used to perform a multithreaded and multifrontal rank-revealing QR decomposition
+  * of sparse matrices. The result is then used to solve linear leasts_square systems.
+  * Clearly, a QR factorization is returned such that A*P = Q*R where :
+  *
+  * P is the column permutation. Use colsPermutation() to get it.
+  *
+  * Q is the orthogonal matrix represented as Householder reflectors.
+  * Use matrixQ() to get an expression and matrixQ().transpose() to get the transpose.
+  * You can then apply it to a vector.
+  *
+  * R is the sparse triangular factor. Use matrixQR() to get it as SparseMatrix.
+  * NOTE : The Index type of R is always SuiteSparse_long. You can get it with SPQR::Index
+  *
+  * \tparam _MatrixType The type of the sparse matrix A, must be a column-major SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  *
+  */
+template<typename _MatrixType>
+class SPQR : public SparseSolverBase<SPQR<_MatrixType> >
+{
+  protected:
+    typedef SparseSolverBase<SPQR<_MatrixType> > Base;
+    using Base::m_isInitialized;
+  public:
+    typedef typename _MatrixType::Scalar Scalar;
+    typedef typename _MatrixType::RealScalar RealScalar;
+    typedef SuiteSparse_long StorageIndex ;
+    typedef SparseMatrix<Scalar, ColMajor, StorageIndex> MatrixType;
+    typedef Map<PermutationMatrix<Dynamic, Dynamic, StorageIndex> > PermutationType;
+    enum {
+      ColsAtCompileTime = Dynamic,
+      MaxColsAtCompileTime = Dynamic
+    };
+  public:
+    SPQR() 
+      : m_analysisIsOk(false),
+        m_factorizationIsOk(false),
+        m_isRUpToDate(false),
+        m_ordering(SPQR_ORDERING_DEFAULT),
+        m_allow_tol(SPQR_DEFAULT_TOL),
+        m_tolerance (NumTraits<Scalar>::epsilon()),
+        m_cR(0),
+        m_E(0),
+        m_H(0),
+        m_HPinv(0),
+        m_HTau(0),
+        m_useDefaultThreshold(true)
+    { 
+      cholmod_l_start(&m_cc);
+    }
+    
+    explicit SPQR(const _MatrixType& matrix)
+      : m_analysisIsOk(false),
+        m_factorizationIsOk(false),
+        m_isRUpToDate(false),
+        m_ordering(SPQR_ORDERING_DEFAULT),
+        m_allow_tol(SPQR_DEFAULT_TOL),
+        m_tolerance (NumTraits<Scalar>::epsilon()),
+        m_cR(0),
+        m_E(0),
+        m_H(0),
+        m_HPinv(0),
+        m_HTau(0),
+        m_useDefaultThreshold(true)
+    {
+      cholmod_l_start(&m_cc);
+      compute(matrix);
+    }
+    
+    ~SPQR()
+    {
+      SPQR_free();
+      cholmod_l_finish(&m_cc);
+    }
+    void SPQR_free()
+    {
+      cholmod_l_free_sparse(&m_H, &m_cc);
+      cholmod_l_free_sparse(&m_cR, &m_cc);
+      cholmod_l_free_dense(&m_HTau, &m_cc);
+      std::free(m_E);
+      std::free(m_HPinv);
+    }
+
+    void compute(const _MatrixType& matrix)
+    {
+      if(m_isInitialized) SPQR_free();
+
+      MatrixType mat(matrix);
+      
+      /* Compute the default threshold as in MatLab, see:
+       * Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
+       * Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011, Page 8:3 
+       */
+      RealScalar pivotThreshold = m_tolerance;
+      if(m_useDefaultThreshold) 
+      {
+        RealScalar max2Norm = 0.0;
+        for (int j = 0; j < mat.cols(); j++) max2Norm = numext::maxi(max2Norm, mat.col(j).norm());
+        if(max2Norm==RealScalar(0))
+          max2Norm = RealScalar(1);
+        pivotThreshold = 20 * (mat.rows() + mat.cols()) * max2Norm * NumTraits<RealScalar>::epsilon();
+      }
+      cholmod_sparse A; 
+      A = viewAsCholmod(mat);
+      m_rows = matrix.rows();
+      Index col = matrix.cols();
+      m_rank = SuiteSparseQR<Scalar>(m_ordering, pivotThreshold, col, &A, 
+                             &m_cR, &m_E, &m_H, &m_HPinv, &m_HTau, &m_cc);
+
+      if (!m_cR)
+      {
+        m_info = NumericalIssue;
+        m_isInitialized = false;
+        return;
+      }
+      m_info = Success;
+      m_isInitialized = true;
+      m_isRUpToDate = false;
+    }
+    /** 
+     * Get the number of rows of the input matrix and the Q matrix
+     */
+    inline Index rows() const {return m_rows; }
+    
+    /** 
+     * Get the number of columns of the input matrix. 
+     */
+    inline Index cols() const { return m_cR->ncol; }
+    
+    template<typename Rhs, typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_isInitialized && " The QR factorization should be computed first, call compute()");
+      eigen_assert(b.cols()==1 && "This method is for vectors only");
+
+      //Compute Q^T * b
+      typename Dest::PlainObject y, y2;
+      y = matrixQ().transpose() * b;
+      
+      // Solves with the triangular matrix R
+      Index rk = this->rank();
+      y2 = y;
+      y.resize((std::max)(cols(),Index(y.rows())),y.cols());
+      y.topRows(rk) = this->matrixR().topLeftCorner(rk, rk).template triangularView<Upper>().solve(y2.topRows(rk));
+
+      // Apply the column permutation 
+      // colsPermutation() performs a copy of the permutation,
+      // so let's apply it manually:
+      for(Index i = 0; i < rk; ++i) dest.row(m_E[i]) = y.row(i);
+      for(Index i = rk; i < cols(); ++i) dest.row(m_E[i]).setZero();
+      
+//       y.bottomRows(y.rows()-rk).setZero();
+//       dest = colsPermutation() * y.topRows(cols());
+      
+      m_info = Success;
+    }
+    
+    /** \returns the sparse triangular factor R. It is a sparse matrix
+     */
+    const MatrixType matrixR() const
+    {
+      eigen_assert(m_isInitialized && " The QR factorization should be computed first, call compute()");
+      if(!m_isRUpToDate) {
+        m_R = viewAsEigen<Scalar,ColMajor, typename MatrixType::StorageIndex>(*m_cR);
+        m_isRUpToDate = true;
+      }
+      return m_R;
+    }
+    /// Get an expression of the matrix Q
+    SPQRMatrixQReturnType<SPQR> matrixQ() const
+    {
+      return SPQRMatrixQReturnType<SPQR>(*this);
+    }
+    /// Get the permutation that was applied to columns of A
+    PermutationType colsPermutation() const
+    { 
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return PermutationType(m_E, m_cR->ncol);
+    }
+    /**
+     * Gets the rank of the matrix. 
+     * It should be equal to matrixQR().cols if the matrix is full-rank
+     */
+    Index rank() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_cc.SPQR_istat[4];
+    }
+    /// Set the fill-reducing ordering method to be used
+    void setSPQROrdering(int ord) { m_ordering = ord;}
+    /// Set the tolerance tol to treat columns with 2-norm < =tol as zero
+    void setPivotThreshold(const RealScalar& tol)
+    {
+      m_useDefaultThreshold = false;
+      m_tolerance = tol;
+    }
+    
+    /** \returns a pointer to the SPQR workspace */
+    cholmod_common *cholmodCommon() const { return &m_cc; }
+    
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the sparse QR can not be computed
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+  protected:
+    bool m_analysisIsOk;
+    bool m_factorizationIsOk;
+    mutable bool m_isRUpToDate;
+    mutable ComputationInfo m_info;
+    int m_ordering; // Ordering method to use, see SPQR's manual
+    int m_allow_tol; // Allow to use some tolerance during numerical factorization.
+    RealScalar m_tolerance; // treat columns with 2-norm below this tolerance as zero
+    mutable cholmod_sparse *m_cR; // The sparse R factor in cholmod format
+    mutable MatrixType m_R; // The sparse matrix R in Eigen format
+    mutable StorageIndex *m_E; // The permutation applied to columns
+    mutable cholmod_sparse *m_H;  //The householder vectors
+    mutable StorageIndex *m_HPinv; // The row permutation of H
+    mutable cholmod_dense *m_HTau; // The Householder coefficients
+    mutable Index m_rank; // The rank of the matrix
+    mutable cholmod_common m_cc; // Workspace and parameters
+    bool m_useDefaultThreshold;     // Use default threshold
+    Index m_rows;
+    template<typename ,typename > friend struct SPQR_QProduct;
+};
+
+template <typename SPQRType, typename Derived>
+struct SPQR_QProduct : ReturnByValue<SPQR_QProduct<SPQRType,Derived> >
+{
+  typedef typename SPQRType::Scalar Scalar;
+  typedef typename SPQRType::StorageIndex StorageIndex;
+  //Define the constructor to get reference to argument types
+  SPQR_QProduct(const SPQRType& spqr, const Derived& other, bool transpose) : m_spqr(spqr),m_other(other),m_transpose(transpose) {}
+  
+  inline Index rows() const { return m_transpose ? m_spqr.rows() : m_spqr.cols(); }
+  inline Index cols() const { return m_other.cols(); }
+  // Assign to a vector
+  template<typename ResType>
+  void evalTo(ResType& res) const
+  {
+    cholmod_dense y_cd;
+    cholmod_dense *x_cd; 
+    int method = m_transpose ? SPQR_QTX : SPQR_QX; 
+    cholmod_common *cc = m_spqr.cholmodCommon();
+    y_cd = viewAsCholmod(m_other.const_cast_derived());
+    x_cd = SuiteSparseQR_qmult<Scalar>(method, m_spqr.m_H, m_spqr.m_HTau, m_spqr.m_HPinv, &y_cd, cc);
+    res = Matrix<Scalar,ResType::RowsAtCompileTime,ResType::ColsAtCompileTime>::Map(reinterpret_cast<Scalar*>(x_cd->x), x_cd->nrow, x_cd->ncol);
+    cholmod_l_free_dense(&x_cd, cc);
+  }
+  const SPQRType& m_spqr; 
+  const Derived& m_other; 
+  bool m_transpose; 
+  
+};
+template<typename SPQRType>
+struct SPQRMatrixQReturnType{
+  
+  SPQRMatrixQReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
+  template<typename Derived>
+  SPQR_QProduct<SPQRType, Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SPQR_QProduct<SPQRType,Derived>(m_spqr,other.derived(),false);
+  }
+  SPQRMatrixQTransposeReturnType<SPQRType> adjoint() const
+  {
+    return SPQRMatrixQTransposeReturnType<SPQRType>(m_spqr);
+  }
+  // To use for operations with the transpose of Q
+  SPQRMatrixQTransposeReturnType<SPQRType> transpose() const
+  {
+    return SPQRMatrixQTransposeReturnType<SPQRType>(m_spqr);
+  }
+  const SPQRType& m_spqr;
+};
+
+template<typename SPQRType>
+struct SPQRMatrixQTransposeReturnType{
+  SPQRMatrixQTransposeReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
+  template<typename Derived>
+  SPQR_QProduct<SPQRType,Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SPQR_QProduct<SPQRType,Derived>(m_spqr,other.derived(), true);
+  }
+  const SPQRType& m_spqr;
+};
+
+}// End namespace Eigen
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SVD/BDCSVD.h b/C++/yolo_bytetrack_old/include/Eigen/src/SVD/BDCSVD.h
new file mode 100644
index 00000000..17f8e443
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SVD/BDCSVD.h
@@ -0,0 +1,1366 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+// 
+// We used the "A Divide-And-Conquer Algorithm for the Bidiagonal SVD"
+// research report written by Ming Gu and Stanley C.Eisenstat
+// The code variable names correspond to the names they used in their 
+// report
+//
+// Copyright (C) 2013 Gauthier Brun <brun.gauthier@gmail.com>
+// Copyright (C) 2013 Nicolas Carre <nicolas.carre@ensimag.fr>
+// Copyright (C) 2013 Jean Ceccato <jean.ceccato@ensimag.fr>
+// Copyright (C) 2013 Pierre Zoppitelli <pierre.zoppitelli@ensimag.fr>
+// Copyright (C) 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
+// Copyright (C) 2014-2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BDCSVD_H
+#define EIGEN_BDCSVD_H
+// #define EIGEN_BDCSVD_DEBUG_VERBOSE
+// #define EIGEN_BDCSVD_SANITY_CHECKS
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+#undef eigen_internal_assert
+#define eigen_internal_assert(X) assert(X);
+#endif
+
+namespace Eigen {
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+IOFormat bdcsvdfmt(8, 0, ", ", "\n", "  [", "]");
+#endif
+  
+template<typename _MatrixType> class BDCSVD;
+
+namespace internal {
+
+template<typename _MatrixType> 
+struct traits<BDCSVD<_MatrixType> >
+        : traits<_MatrixType>
+{
+  typedef _MatrixType MatrixType;
+};  
+
+} // end namespace internal
+  
+  
+/** \ingroup SVD_Module
+ *
+ *
+ * \class BDCSVD
+ *
+ * \brief class Bidiagonal Divide and Conquer SVD
+ *
+ * \tparam _MatrixType the type of the matrix of which we are computing the SVD decomposition
+ *
+ * This class first reduces the input matrix to bi-diagonal form using class UpperBidiagonalization,
+ * and then performs a divide-and-conquer diagonalization. Small blocks are diagonalized using class JacobiSVD.
+ * You can control the switching size with the setSwitchSize() method, default is 16.
+ * For small matrice (<16), it is thus preferable to directly use JacobiSVD. For larger ones, BDCSVD is highly
+ * recommended and can several order of magnitude faster.
+ *
+ * \warning this algorithm is unlikely to provide accurate result when compiled with unsafe math optimizations.
+ * For instance, this concerns Intel's compiler (ICC), which performs such optimization by default unless
+ * you compile with the \c -fp-model \c precise option. Likewise, the \c -ffast-math option of GCC or clang will
+ * significantly degrade the accuracy.
+ *
+ * \sa class JacobiSVD
+ */
+template<typename _MatrixType> 
+class BDCSVD : public SVDBase<BDCSVD<_MatrixType> >
+{
+  typedef SVDBase<BDCSVD> Base;
+    
+public:
+  using Base::rows;
+  using Base::cols;
+  using Base::computeU;
+  using Base::computeV;
+  
+  typedef _MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+  typedef typename NumTraits<RealScalar>::Literal Literal;
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime, 
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime, 
+    DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime), 
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime, 
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime, 
+    MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime, MaxColsAtCompileTime), 
+    MatrixOptions = MatrixType::Options
+  };
+
+  typedef typename Base::MatrixUType MatrixUType;
+  typedef typename Base::MatrixVType MatrixVType;
+  typedef typename Base::SingularValuesType SingularValuesType;
+  
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> MatrixX;
+  typedef Matrix<RealScalar, Dynamic, Dynamic, ColMajor> MatrixXr;
+  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
+  typedef Array<RealScalar, Dynamic, 1> ArrayXr;
+  typedef Array<Index,1,Dynamic> ArrayXi;
+  typedef Ref<ArrayXr> ArrayRef;
+  typedef Ref<ArrayXi> IndicesRef;
+
+  /** \brief Default Constructor.
+   *
+   * The default constructor is useful in cases in which the user intends to
+   * perform decompositions via BDCSVD::compute(const MatrixType&).
+   */
+  BDCSVD() : m_algoswap(16), m_isTranspose(false), m_compU(false), m_compV(false), m_numIters(0)
+  {}
+
+
+  /** \brief Default Constructor with memory preallocation
+   *
+   * Like the default constructor but with preallocation of the internal data
+   * according to the specified problem size.
+   * \sa BDCSVD()
+   */
+  BDCSVD(Index rows, Index cols, unsigned int computationOptions = 0)
+    : m_algoswap(16), m_numIters(0)
+  {
+    allocate(rows, cols, computationOptions);
+  }
+
+  /** \brief Constructor performing the decomposition of given matrix.
+   *
+   * \param matrix the matrix to decompose
+   * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+   *                           By default, none is computed. This is a bit - field, the possible bits are #ComputeFullU, #ComputeThinU, 
+   *                           #ComputeFullV, #ComputeThinV.
+   *
+   * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+   * available with the (non - default) FullPivHouseholderQR preconditioner.
+   */
+  BDCSVD(const MatrixType& matrix, unsigned int computationOptions = 0)
+    : m_algoswap(16), m_numIters(0)
+  {
+    compute(matrix, computationOptions);
+  }
+
+  ~BDCSVD() 
+  {
+  }
+  
+  /** \brief Method performing the decomposition of given matrix using custom options.
+   *
+   * \param matrix the matrix to decompose
+   * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+   *                           By default, none is computed. This is a bit - field, the possible bits are #ComputeFullU, #ComputeThinU, 
+   *                           #ComputeFullV, #ComputeThinV.
+   *
+   * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+   * available with the (non - default) FullPivHouseholderQR preconditioner.
+   */
+  BDCSVD& compute(const MatrixType& matrix, unsigned int computationOptions);
+
+  /** \brief Method performing the decomposition of given matrix using current options.
+   *
+   * \param matrix the matrix to decompose
+   *
+   * This method uses the current \a computationOptions, as already passed to the constructor or to compute(const MatrixType&, unsigned int).
+   */
+  BDCSVD& compute(const MatrixType& matrix)
+  {
+    return compute(matrix, this->m_computationOptions);
+  }
+
+  void setSwitchSize(int s) 
+  {
+    eigen_assert(s>3 && "BDCSVD the size of the algo switch has to be greater than 3");
+    m_algoswap = s;
+  }
+ 
+private:
+  void allocate(Index rows, Index cols, unsigned int computationOptions);
+  void divide(Index firstCol, Index lastCol, Index firstRowW, Index firstColW, Index shift);
+  void computeSVDofM(Index firstCol, Index n, MatrixXr& U, VectorType& singVals, MatrixXr& V);
+  void computeSingVals(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm, VectorType& singVals, ArrayRef shifts, ArrayRef mus);
+  void perturbCol0(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm, const VectorType& singVals, const ArrayRef& shifts, const ArrayRef& mus, ArrayRef zhat);
+  void computeSingVecs(const ArrayRef& zhat, const ArrayRef& diag, const IndicesRef& perm, const VectorType& singVals, const ArrayRef& shifts, const ArrayRef& mus, MatrixXr& U, MatrixXr& V);
+  void deflation43(Index firstCol, Index shift, Index i, Index size);
+  void deflation44(Index firstColu , Index firstColm, Index firstRowW, Index firstColW, Index i, Index j, Index size);
+  void deflation(Index firstCol, Index lastCol, Index k, Index firstRowW, Index firstColW, Index shift);
+  template<typename HouseholderU, typename HouseholderV, typename NaiveU, typename NaiveV>
+  void copyUV(const HouseholderU &householderU, const HouseholderV &householderV, const NaiveU &naiveU, const NaiveV &naivev);
+  void structured_update(Block<MatrixXr,Dynamic,Dynamic> A, const MatrixXr &B, Index n1);
+  static RealScalar secularEq(RealScalar x, const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm, const ArrayRef& diagShifted, RealScalar shift);
+
+protected:
+  MatrixXr m_naiveU, m_naiveV;
+  MatrixXr m_computed;
+  Index m_nRec;
+  ArrayXr m_workspace;
+  ArrayXi m_workspaceI;
+  int m_algoswap;
+  bool m_isTranspose, m_compU, m_compV;
+  
+  using Base::m_singularValues;
+  using Base::m_diagSize;
+  using Base::m_computeFullU;
+  using Base::m_computeFullV;
+  using Base::m_computeThinU;
+  using Base::m_computeThinV;
+  using Base::m_matrixU;
+  using Base::m_matrixV;
+  using Base::m_info;
+  using Base::m_isInitialized;
+  using Base::m_nonzeroSingularValues;
+
+public:  
+  int m_numIters;
+}; //end class BDCSVD
+
+
+// Method to allocate and initialize matrix and attributes
+template<typename MatrixType>
+void BDCSVD<MatrixType>::allocate(Eigen::Index rows, Eigen::Index cols, unsigned int computationOptions)
+{
+  m_isTranspose = (cols > rows);
+
+  if (Base::allocate(rows, cols, computationOptions))
+    return;
+  
+  m_computed = MatrixXr::Zero(m_diagSize + 1, m_diagSize );
+  m_compU = computeV();
+  m_compV = computeU();
+  if (m_isTranspose)
+    std::swap(m_compU, m_compV);
+  
+  if (m_compU) m_naiveU = MatrixXr::Zero(m_diagSize + 1, m_diagSize + 1 );
+  else         m_naiveU = MatrixXr::Zero(2, m_diagSize + 1 );
+  
+  if (m_compV) m_naiveV = MatrixXr::Zero(m_diagSize, m_diagSize);
+  
+  m_workspace.resize((m_diagSize+1)*(m_diagSize+1)*3);
+  m_workspaceI.resize(3*m_diagSize);
+}// end allocate
+
+template<typename MatrixType>
+BDCSVD<MatrixType>& BDCSVD<MatrixType>::compute(const MatrixType& matrix, unsigned int computationOptions) 
+{
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "\n\n\n======================================================================================================================\n\n\n";
+#endif
+  allocate(matrix.rows(), matrix.cols(), computationOptions);
+  using std::abs;
+
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  
+  //**** step -1 - If the problem is too small, directly falls back to JacobiSVD and return
+  if(matrix.cols() < m_algoswap)
+  {
+    // FIXME this line involves temporaries
+    JacobiSVD<MatrixType> jsvd(matrix,computationOptions);
+    m_isInitialized = true;
+    m_info = jsvd.info();
+    if (m_info == Success || m_info == NoConvergence) {
+      if(computeU()) m_matrixU = jsvd.matrixU();
+      if(computeV()) m_matrixV = jsvd.matrixV();
+      m_singularValues = jsvd.singularValues();
+      m_nonzeroSingularValues = jsvd.nonzeroSingularValues();
+    }
+    return *this;
+  }
+  
+  //**** step 0 - Copy the input matrix and apply scaling to reduce over/under-flows
+  RealScalar scale = matrix.cwiseAbs().template maxCoeff<PropagateNaN>();
+  if (!(numext::isfinite)(scale)) {
+    m_isInitialized = true;
+    m_info = InvalidInput;
+    return *this;
+  }
+
+  if(scale==Literal(0)) scale = Literal(1);
+  MatrixX copy;
+  if (m_isTranspose) copy = matrix.adjoint()/scale;
+  else               copy = matrix/scale;
+  
+  //**** step 1 - Bidiagonalization
+  // FIXME this line involves temporaries
+  internal::UpperBidiagonalization<MatrixX> bid(copy);
+
+  //**** step 2 - Divide & Conquer
+  m_naiveU.setZero();
+  m_naiveV.setZero();
+  // FIXME this line involves a temporary matrix
+  m_computed.topRows(m_diagSize) = bid.bidiagonal().toDenseMatrix().transpose();
+  m_computed.template bottomRows<1>().setZero();
+  divide(0, m_diagSize - 1, 0, 0, 0);
+  if (m_info != Success && m_info != NoConvergence) {
+    m_isInitialized = true;
+    return *this;
+  }
+    
+  //**** step 3 - Copy singular values and vectors
+  for (int i=0; i<m_diagSize; i++)
+  {
+    RealScalar a = abs(m_computed.coeff(i, i));
+    m_singularValues.coeffRef(i) = a * scale;
+    if (a<considerZero)
+    {
+      m_nonzeroSingularValues = i;
+      m_singularValues.tail(m_diagSize - i - 1).setZero();
+      break;
+    }
+    else if (i == m_diagSize - 1)
+    {
+      m_nonzeroSingularValues = i + 1;
+      break;
+    }
+  }
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+//   std::cout << "m_naiveU\n" << m_naiveU << "\n\n";
+//   std::cout << "m_naiveV\n" << m_naiveV << "\n\n";
+#endif
+  if(m_isTranspose) copyUV(bid.householderV(), bid.householderU(), m_naiveV, m_naiveU);
+  else              copyUV(bid.householderU(), bid.householderV(), m_naiveU, m_naiveV);
+
+  m_isInitialized = true;
+  return *this;
+}// end compute
+
+
+template<typename MatrixType>
+template<typename HouseholderU, typename HouseholderV, typename NaiveU, typename NaiveV>
+void BDCSVD<MatrixType>::copyUV(const HouseholderU &householderU, const HouseholderV &householderV, const NaiveU &naiveU, const NaiveV &naiveV)
+{
+  // Note exchange of U and V: m_matrixU is set from m_naiveV and vice versa
+  if (computeU())
+  {
+    Index Ucols = m_computeThinU ? m_diagSize : householderU.cols();
+    m_matrixU = MatrixX::Identity(householderU.cols(), Ucols);
+    m_matrixU.topLeftCorner(m_diagSize, m_diagSize) = naiveV.template cast<Scalar>().topLeftCorner(m_diagSize, m_diagSize);
+    householderU.applyThisOnTheLeft(m_matrixU); // FIXME this line involves a temporary buffer
+  }
+  if (computeV())
+  {
+    Index Vcols = m_computeThinV ? m_diagSize : householderV.cols();
+    m_matrixV = MatrixX::Identity(householderV.cols(), Vcols);
+    m_matrixV.topLeftCorner(m_diagSize, m_diagSize) = naiveU.template cast<Scalar>().topLeftCorner(m_diagSize, m_diagSize);
+    householderV.applyThisOnTheLeft(m_matrixV); // FIXME this line involves a temporary buffer
+  }
+}
+
+/** \internal
+  * Performs A = A * B exploiting the special structure of the matrix A. Splitting A as:
+  *  A = [A1]
+  *      [A2]
+  * such that A1.rows()==n1, then we assume that at least half of the columns of A1 and A2 are zeros.
+  * We can thus pack them prior to the the matrix product. However, this is only worth the effort if the matrix is large
+  * enough.
+  */
+template<typename MatrixType>
+void BDCSVD<MatrixType>::structured_update(Block<MatrixXr,Dynamic,Dynamic> A, const MatrixXr &B, Index n1)
+{
+  Index n = A.rows();
+  if(n>100)
+  {
+    // If the matrices are large enough, let's exploit the sparse structure of A by
+    // splitting it in half (wrt n1), and packing the non-zero columns.
+    Index n2 = n - n1;
+    Map<MatrixXr> A1(m_workspace.data()      , n1, n);
+    Map<MatrixXr> A2(m_workspace.data()+ n1*n, n2, n);
+    Map<MatrixXr> B1(m_workspace.data()+  n*n, n,  n);
+    Map<MatrixXr> B2(m_workspace.data()+2*n*n, n,  n);
+    Index k1=0, k2=0;
+    for(Index j=0; j<n; ++j)
+    {
+      if( (A.col(j).head(n1).array()!=Literal(0)).any() )
+      {
+        A1.col(k1) = A.col(j).head(n1);
+        B1.row(k1) = B.row(j);
+        ++k1;
+      }
+      if( (A.col(j).tail(n2).array()!=Literal(0)).any() )
+      {
+        A2.col(k2) = A.col(j).tail(n2);
+        B2.row(k2) = B.row(j);
+        ++k2;
+      }
+    }
+  
+    A.topRows(n1).noalias()    = A1.leftCols(k1) * B1.topRows(k1);
+    A.bottomRows(n2).noalias() = A2.leftCols(k2) * B2.topRows(k2);
+  }
+  else
+  {
+    Map<MatrixXr,Aligned> tmp(m_workspace.data(),n,n);
+    tmp.noalias() = A*B;
+    A = tmp;
+  }
+}
+
+// The divide algorithm is done "in place", we are always working on subsets of the same matrix. The divide methods takes as argument the 
+// place of the submatrix we are currently working on.
+
+//@param firstCol : The Index of the first column of the submatrix of m_computed and for m_naiveU;
+//@param lastCol : The Index of the last column of the submatrix of m_computed and for m_naiveU; 
+// lastCol + 1 - firstCol is the size of the submatrix.
+//@param firstRowW : The Index of the first row of the matrix W that we are to change. (see the reference paper section 1 for more information on W)
+//@param firstRowW : Same as firstRowW with the column.
+//@param shift : Each time one takes the left submatrix, one must add 1 to the shift. Why? Because! We actually want the last column of the U submatrix 
+// to become the first column (*coeff) and to shift all the other columns to the right. There are more details on the reference paper.
+template<typename MatrixType>
+void BDCSVD<MatrixType>::divide(Eigen::Index firstCol, Eigen::Index lastCol, Eigen::Index firstRowW, Eigen::Index firstColW, Eigen::Index shift)
+{
+  // requires rows = cols + 1;
+  using std::pow;
+  using std::sqrt;
+  using std::abs;
+  const Index n = lastCol - firstCol + 1;
+  const Index k = n/2;
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  RealScalar alphaK;
+  RealScalar betaK; 
+  RealScalar r0; 
+  RealScalar lambda, phi, c0, s0;
+  VectorType l, f;
+  // We use the other algorithm which is more efficient for small 
+  // matrices.
+  if (n < m_algoswap)
+  {
+    // FIXME this line involves temporaries
+    JacobiSVD<MatrixXr> b(m_computed.block(firstCol, firstCol, n + 1, n), ComputeFullU | (m_compV ? ComputeFullV : 0));
+    m_info = b.info();
+    if (m_info != Success && m_info != NoConvergence) return;
+    if (m_compU)
+      m_naiveU.block(firstCol, firstCol, n + 1, n + 1).real() = b.matrixU();
+    else 
+    {
+      m_naiveU.row(0).segment(firstCol, n + 1).real() = b.matrixU().row(0);
+      m_naiveU.row(1).segment(firstCol, n + 1).real() = b.matrixU().row(n);
+    }
+    if (m_compV) m_naiveV.block(firstRowW, firstColW, n, n).real() = b.matrixV();
+    m_computed.block(firstCol + shift, firstCol + shift, n + 1, n).setZero();
+    m_computed.diagonal().segment(firstCol + shift, n) = b.singularValues().head(n);
+    return;
+  }
+  // We use the divide and conquer algorithm
+  alphaK =  m_computed(firstCol + k, firstCol + k);
+  betaK = m_computed(firstCol + k + 1, firstCol + k);
+  // The divide must be done in that order in order to have good results. Divide change the data inside the submatrices
+  // and the divide of the right submatrice reads one column of the left submatrice. That's why we need to treat the 
+  // right submatrix before the left one. 
+  divide(k + 1 + firstCol, lastCol, k + 1 + firstRowW, k + 1 + firstColW, shift);
+  if (m_info != Success && m_info != NoConvergence) return;
+  divide(firstCol, k - 1 + firstCol, firstRowW, firstColW + 1, shift + 1);
+  if (m_info != Success && m_info != NoConvergence) return;
+
+  if (m_compU)
+  {
+    lambda = m_naiveU(firstCol + k, firstCol + k);
+    phi = m_naiveU(firstCol + k + 1, lastCol + 1);
+  } 
+  else 
+  {
+    lambda = m_naiveU(1, firstCol + k);
+    phi = m_naiveU(0, lastCol + 1);
+  }
+  r0 = sqrt((abs(alphaK * lambda) * abs(alphaK * lambda)) + abs(betaK * phi) * abs(betaK * phi));
+  if (m_compU)
+  {
+    l = m_naiveU.row(firstCol + k).segment(firstCol, k);
+    f = m_naiveU.row(firstCol + k + 1).segment(firstCol + k + 1, n - k - 1);
+  } 
+  else 
+  {
+    l = m_naiveU.row(1).segment(firstCol, k);
+    f = m_naiveU.row(0).segment(firstCol + k + 1, n - k - 1);
+  }
+  if (m_compV) m_naiveV(firstRowW+k, firstColW) = Literal(1);
+  if (r0<considerZero)
+  {
+    c0 = Literal(1);
+    s0 = Literal(0);
+  }
+  else
+  {
+    c0 = alphaK * lambda / r0;
+    s0 = betaK * phi / r0;
+  }
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+  
+  if (m_compU)
+  {
+    MatrixXr q1 (m_naiveU.col(firstCol + k).segment(firstCol, k + 1));     
+    // we shiftW Q1 to the right
+    for (Index i = firstCol + k - 1; i >= firstCol; i--) 
+      m_naiveU.col(i + 1).segment(firstCol, k + 1) = m_naiveU.col(i).segment(firstCol, k + 1);
+    // we shift q1 at the left with a factor c0
+    m_naiveU.col(firstCol).segment( firstCol, k + 1) = (q1 * c0);
+    // last column = q1 * - s0
+    m_naiveU.col(lastCol + 1).segment(firstCol, k + 1) = (q1 * ( - s0));
+    // first column = q2 * s0
+    m_naiveU.col(firstCol).segment(firstCol + k + 1, n - k) = m_naiveU.col(lastCol + 1).segment(firstCol + k + 1, n - k) * s0; 
+    // q2 *= c0
+    m_naiveU.col(lastCol + 1).segment(firstCol + k + 1, n - k) *= c0;
+  } 
+  else 
+  {
+    RealScalar q1 = m_naiveU(0, firstCol + k);
+    // we shift Q1 to the right
+    for (Index i = firstCol + k - 1; i >= firstCol; i--) 
+      m_naiveU(0, i + 1) = m_naiveU(0, i);
+    // we shift q1 at the left with a factor c0
+    m_naiveU(0, firstCol) = (q1 * c0);
+    // last column = q1 * - s0
+    m_naiveU(0, lastCol + 1) = (q1 * ( - s0));
+    // first column = q2 * s0
+    m_naiveU(1, firstCol) = m_naiveU(1, lastCol + 1) *s0; 
+    // q2 *= c0
+    m_naiveU(1, lastCol + 1) *= c0;
+    m_naiveU.row(1).segment(firstCol + 1, k).setZero();
+    m_naiveU.row(0).segment(firstCol + k + 1, n - k - 1).setZero();
+  }
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+  
+  m_computed(firstCol + shift, firstCol + shift) = r0;
+  m_computed.col(firstCol + shift).segment(firstCol + shift + 1, k) = alphaK * l.transpose().real();
+  m_computed.col(firstCol + shift).segment(firstCol + shift + k + 1, n - k - 1) = betaK * f.transpose().real();
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  ArrayXr tmp1 = (m_computed.block(firstCol+shift, firstCol+shift, n, n)).jacobiSvd().singularValues();
+#endif
+  // Second part: try to deflate singular values in combined matrix
+  deflation(firstCol, lastCol, k, firstRowW, firstColW, shift);
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  ArrayXr tmp2 = (m_computed.block(firstCol+shift, firstCol+shift, n, n)).jacobiSvd().singularValues();
+  std::cout << "\n\nj1 = " << tmp1.transpose().format(bdcsvdfmt) << "\n";
+  std::cout << "j2 = " << tmp2.transpose().format(bdcsvdfmt) << "\n\n";
+  std::cout << "err:      " << ((tmp1-tmp2).abs()>1e-12*tmp2.abs()).transpose() << "\n";
+  static int count = 0;
+  std::cout << "# " << ++count << "\n\n";
+  assert((tmp1-tmp2).matrix().norm() < 1e-14*tmp2.matrix().norm());
+//   assert(count<681);
+//   assert(((tmp1-tmp2).abs()<1e-13*tmp2.abs()).all());
+#endif
+  
+  // Third part: compute SVD of combined matrix
+  MatrixXr UofSVD, VofSVD;
+  VectorType singVals;
+  computeSVDofM(firstCol + shift, n, UofSVD, singVals, VofSVD);
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(UofSVD.allFinite());
+  assert(VofSVD.allFinite());
+#endif
+  
+  if (m_compU)
+    structured_update(m_naiveU.block(firstCol, firstCol, n + 1, n + 1), UofSVD, (n+2)/2);
+  else
+  {
+    Map<Matrix<RealScalar,2,Dynamic>,Aligned> tmp(m_workspace.data(),2,n+1);
+    tmp.noalias() = m_naiveU.middleCols(firstCol, n+1) * UofSVD;
+    m_naiveU.middleCols(firstCol, n + 1) = tmp;
+  }
+  
+  if (m_compV)  structured_update(m_naiveV.block(firstRowW, firstColW, n, n), VofSVD, (n+1)/2);
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+  
+  m_computed.block(firstCol + shift, firstCol + shift, n, n).setZero();
+  m_computed.block(firstCol + shift, firstCol + shift, n, n).diagonal() = singVals;
+}// end divide
+
+// Compute SVD of m_computed.block(firstCol, firstCol, n + 1, n); this block only has non-zeros in
+// the first column and on the diagonal and has undergone deflation, so diagonal is in increasing
+// order except for possibly the (0,0) entry. The computed SVD is stored U, singVals and V, except
+// that if m_compV is false, then V is not computed. Singular values are sorted in decreasing order.
+//
+// TODO Opportunities for optimization: better root finding algo, better stopping criterion, better
+// handling of round-off errors, be consistent in ordering
+// For instance, to solve the secular equation using FMM, see http://www.stat.uchicago.edu/~lekheng/courses/302/classics/greengard-rokhlin.pdf
+template <typename MatrixType>
+void BDCSVD<MatrixType>::computeSVDofM(Eigen::Index firstCol, Eigen::Index n, MatrixXr& U, VectorType& singVals, MatrixXr& V)
+{
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  using std::abs;
+  ArrayRef col0 = m_computed.col(firstCol).segment(firstCol, n);
+  m_workspace.head(n) =  m_computed.block(firstCol, firstCol, n, n).diagonal();
+  ArrayRef diag = m_workspace.head(n);
+  diag(0) = Literal(0);
+
+  // Allocate space for singular values and vectors
+  singVals.resize(n);
+  U.resize(n+1, n+1);
+  if (m_compV) V.resize(n, n);
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  if (col0.hasNaN() || diag.hasNaN())
+    std::cout << "\n\nHAS NAN\n\n";
+#endif
+  
+  // Many singular values might have been deflated, the zero ones have been moved to the end,
+  // but others are interleaved and we must ignore them at this stage.
+  // To this end, let's compute a permutation skipping them:
+  Index actual_n = n;
+  while(actual_n>1 && diag(actual_n-1)==Literal(0)) {--actual_n; eigen_internal_assert(col0(actual_n)==Literal(0)); }
+  Index m = 0; // size of the deflated problem
+  for(Index k=0;k<actual_n;++k)
+    if(abs(col0(k))>considerZero)
+      m_workspaceI(m++) = k;
+  Map<ArrayXi> perm(m_workspaceI.data(),m);
+  
+  Map<ArrayXr> shifts(m_workspace.data()+1*n, n);
+  Map<ArrayXr> mus(m_workspace.data()+2*n, n);
+  Map<ArrayXr> zhat(m_workspace.data()+3*n, n);
+
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "computeSVDofM using:\n";
+  std::cout << "  z: " << col0.transpose() << "\n";
+  std::cout << "  d: " << diag.transpose() << "\n";
+#endif
+  
+  // Compute singVals, shifts, and mus
+  computeSingVals(col0, diag, perm, singVals, shifts, mus);
+  
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "  j:        " << (m_computed.block(firstCol, firstCol, n, n)).jacobiSvd().singularValues().transpose().reverse() << "\n\n";
+  std::cout << "  sing-val: " << singVals.transpose() << "\n";
+  std::cout << "  mu:       " << mus.transpose() << "\n";
+  std::cout << "  shift:    " << shifts.transpose() << "\n";
+  
+  {
+    std::cout << "\n\n    mus:    " << mus.head(actual_n).transpose() << "\n\n";
+    std::cout << "    check1 (expect0) : " << ((singVals.array()-(shifts+mus)) / singVals.array()).head(actual_n).transpose() << "\n\n";
+    assert((((singVals.array()-(shifts+mus)) / singVals.array()).head(actual_n) >= 0).all());
+    std::cout << "    check2 (>0)      : " << ((singVals.array()-diag) / singVals.array()).head(actual_n).transpose() << "\n\n";
+    assert((((singVals.array()-diag) / singVals.array()).head(actual_n) >= 0).all());
+  }
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(singVals.allFinite());
+  assert(mus.allFinite());
+  assert(shifts.allFinite());
+#endif
+  
+  // Compute zhat
+  perturbCol0(col0, diag, perm, singVals, shifts, mus, zhat);
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "  zhat: " << zhat.transpose() << "\n";
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(zhat.allFinite());
+#endif
+  
+  computeSingVecs(zhat, diag, perm, singVals, shifts, mus, U, V);
+  
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "U^T U: " << (U.transpose() * U - MatrixXr(MatrixXr::Identity(U.cols(),U.cols()))).norm() << "\n";
+  std::cout << "V^T V: " << (V.transpose() * V - MatrixXr(MatrixXr::Identity(V.cols(),V.cols()))).norm() << "\n";
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+  assert(U.allFinite());
+  assert(V.allFinite());
+//   assert((U.transpose() * U - MatrixXr(MatrixXr::Identity(U.cols(),U.cols()))).norm() < 100*NumTraits<RealScalar>::epsilon() * n);
+//   assert((V.transpose() * V - MatrixXr(MatrixXr::Identity(V.cols(),V.cols()))).norm() < 100*NumTraits<RealScalar>::epsilon() * n);
+#endif
+  
+  // Because of deflation, the singular values might not be completely sorted.
+  // Fortunately, reordering them is a O(n) problem
+  for(Index i=0; i<actual_n-1; ++i)
+  {
+    if(singVals(i)>singVals(i+1))
+    {
+      using std::swap;
+      swap(singVals(i),singVals(i+1));
+      U.col(i).swap(U.col(i+1));
+      if(m_compV) V.col(i).swap(V.col(i+1));
+    }
+  }
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  {
+    bool singular_values_sorted = (((singVals.segment(1,actual_n-1)-singVals.head(actual_n-1))).array() >= 0).all();
+    if(!singular_values_sorted)
+      std::cout << "Singular values are not sorted: " << singVals.segment(1,actual_n).transpose() << "\n";
+    assert(singular_values_sorted);
+  }
+#endif
+  
+  // Reverse order so that singular values in increased order
+  // Because of deflation, the zeros singular-values are already at the end
+  singVals.head(actual_n).reverseInPlace();
+  U.leftCols(actual_n).rowwise().reverseInPlace();
+  if (m_compV) V.leftCols(actual_n).rowwise().reverseInPlace();
+  
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  JacobiSVD<MatrixXr> jsvd(m_computed.block(firstCol, firstCol, n, n) );
+  std::cout << "  * j:        " << jsvd.singularValues().transpose() << "\n\n";
+  std::cout << "  * sing-val: " << singVals.transpose() << "\n";
+//   std::cout << "  * err:      " << ((jsvd.singularValues()-singVals)>1e-13*singVals.norm()).transpose() << "\n";
+#endif
+}
+
+template <typename MatrixType>
+typename BDCSVD<MatrixType>::RealScalar BDCSVD<MatrixType>::secularEq(RealScalar mu, const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm, const ArrayRef& diagShifted, RealScalar shift)
+{
+  Index m = perm.size();
+  RealScalar res = Literal(1);
+  for(Index i=0; i<m; ++i)
+  {
+    Index j = perm(i);
+    // The following expression could be rewritten to involve only a single division,
+    // but this would make the expression more sensitive to overflow.
+    res += (col0(j) / (diagShifted(j) - mu)) * (col0(j) / (diag(j) + shift + mu));
+  }
+  return res;
+
+}
+
+template <typename MatrixType>
+void BDCSVD<MatrixType>::computeSingVals(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm,
+                                         VectorType& singVals, ArrayRef shifts, ArrayRef mus)
+{
+  using std::abs;
+  using std::swap;
+  using std::sqrt;
+
+  Index n = col0.size();
+  Index actual_n = n;
+  // Note that here actual_n is computed based on col0(i)==0 instead of diag(i)==0 as above
+  // because 1) we have diag(i)==0 => col0(i)==0 and 2) if col0(i)==0, then diag(i) is already a singular value.
+  while(actual_n>1 && col0(actual_n-1)==Literal(0)) --actual_n;
+
+  for (Index k = 0; k < n; ++k)
+  {
+    if (col0(k) == Literal(0) || actual_n==1)
+    {
+      // if col0(k) == 0, then entry is deflated, so singular value is on diagonal
+      // if actual_n==1, then the deflated problem is already diagonalized
+      singVals(k) = k==0 ? col0(0) : diag(k);
+      mus(k) = Literal(0);
+      shifts(k) = k==0 ? col0(0) : diag(k);
+      continue;
+    } 
+
+    // otherwise, use secular equation to find singular value
+    RealScalar left = diag(k);
+    RealScalar right; // was: = (k != actual_n-1) ? diag(k+1) : (diag(actual_n-1) + col0.matrix().norm());
+    if(k==actual_n-1)
+      right = (diag(actual_n-1) + col0.matrix().norm());
+    else
+    {
+      // Skip deflated singular values,
+      // recall that at this stage we assume that z[j]!=0 and all entries for which z[j]==0 have been put aside.
+      // This should be equivalent to using perm[]
+      Index l = k+1;
+      while(col0(l)==Literal(0)) { ++l; eigen_internal_assert(l<actual_n); }
+      right = diag(l);
+    }
+
+    // first decide whether it's closer to the left end or the right end
+    RealScalar mid = left + (right-left) / Literal(2);
+    RealScalar fMid = secularEq(mid, col0, diag, perm, diag, Literal(0));
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+    std::cout << "right-left = " << right-left << "\n";
+//     std::cout << "fMid = " << fMid << " " << secularEq(mid-left, col0, diag, perm, ArrayXr(diag-left), left)
+//                            << " " << secularEq(mid-right, col0, diag, perm, ArrayXr(diag-right), right)   << "\n";
+    std::cout << "     = " << secularEq(left+RealScalar(0.000001)*(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.1)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.2)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.3)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.4)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.49)    *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.5)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.51)    *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.6)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.7)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.8)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.9)     *(right-left), col0, diag, perm, diag, 0)
+              << " "       << secularEq(left+RealScalar(0.999999)*(right-left), col0, diag, perm, diag, 0) << "\n";
+#endif
+    RealScalar shift = (k == actual_n-1 || fMid > Literal(0)) ? left : right;
+    
+    // measure everything relative to shift
+    Map<ArrayXr> diagShifted(m_workspace.data()+4*n, n);
+    diagShifted = diag - shift;
+
+    if(k!=actual_n-1)
+    {
+      // check that after the shift, f(mid) is still negative:
+      RealScalar midShifted = (right - left) / RealScalar(2);
+      if(shift==right)
+        midShifted = -midShifted;
+      RealScalar fMidShifted = secularEq(midShifted, col0, diag, perm, diagShifted, shift);
+      if(fMidShifted>0)
+      {
+        // fMid was erroneous, fix it:
+        shift =  fMidShifted > Literal(0) ? left : right;
+        diagShifted = diag - shift;
+      }
+    }
+    
+    // initial guess
+    RealScalar muPrev, muCur;
+    if (shift == left)
+    {
+      muPrev = (right - left) * RealScalar(0.1);
+      if (k == actual_n-1) muCur = right - left;
+      else                 muCur = (right - left) * RealScalar(0.5);
+    }
+    else
+    {
+      muPrev = -(right - left) * RealScalar(0.1);
+      muCur = -(right - left) * RealScalar(0.5);
+    }
+
+    RealScalar fPrev = secularEq(muPrev, col0, diag, perm, diagShifted, shift);
+    RealScalar fCur = secularEq(muCur, col0, diag, perm, diagShifted, shift);
+    if (abs(fPrev) < abs(fCur))
+    {
+      swap(fPrev, fCur);
+      swap(muPrev, muCur);
+    }
+
+    // rational interpolation: fit a function of the form a / mu + b through the two previous
+    // iterates and use its zero to compute the next iterate
+    bool useBisection = fPrev*fCur>Literal(0);
+    while (fCur!=Literal(0) && abs(muCur - muPrev) > Literal(8) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(abs(muCur), abs(muPrev)) && abs(fCur - fPrev)>NumTraits<RealScalar>::epsilon() && !useBisection)
+    {
+      ++m_numIters;
+
+      // Find a and b such that the function f(mu) = a / mu + b matches the current and previous samples.
+      RealScalar a = (fCur - fPrev) / (Literal(1)/muCur - Literal(1)/muPrev);
+      RealScalar b = fCur - a / muCur;
+      // And find mu such that f(mu)==0:
+      RealScalar muZero = -a/b;
+      RealScalar fZero = secularEq(muZero, col0, diag, perm, diagShifted, shift);
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+      assert((numext::isfinite)(fZero));
+#endif
+      
+      muPrev = muCur;
+      fPrev = fCur;
+      muCur = muZero;
+      fCur = fZero;
+      
+      if (shift == left  && (muCur < Literal(0) || muCur > right - left)) useBisection = true;
+      if (shift == right && (muCur < -(right - left) || muCur > Literal(0))) useBisection = true;
+      if (abs(fCur)>abs(fPrev)) useBisection = true;
+    }
+
+    // fall back on bisection method if rational interpolation did not work
+    if (useBisection)
+    {
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "useBisection for k = " << k << ", actual_n = " << actual_n << "\n";
+#endif
+      RealScalar leftShifted, rightShifted;
+      if (shift == left)
+      {
+        // to avoid overflow, we must have mu > max(real_min, |z(k)|/sqrt(real_max)),
+        // the factor 2 is to be more conservative
+        leftShifted = numext::maxi<RealScalar>( (std::numeric_limits<RealScalar>::min)(), Literal(2) * abs(col0(k)) / sqrt((std::numeric_limits<RealScalar>::max)()) );
+
+        // check that we did it right:
+        eigen_internal_assert( (numext::isfinite)( (col0(k)/leftShifted)*(col0(k)/(diag(k)+shift+leftShifted)) ) );
+        // I don't understand why the case k==0 would be special there:
+        // if (k == 0) rightShifted = right - left; else
+        rightShifted = (k==actual_n-1) ? right : ((right - left) * RealScalar(0.51)); // theoretically we can take 0.5, but let's be safe
+      }
+      else
+      {
+        leftShifted = -(right - left) * RealScalar(0.51);
+        if(k+1<n)
+          rightShifted = -numext::maxi<RealScalar>( (std::numeric_limits<RealScalar>::min)(), abs(col0(k+1)) / sqrt((std::numeric_limits<RealScalar>::max)()) );
+        else
+          rightShifted = -(std::numeric_limits<RealScalar>::min)();
+      }
+
+      RealScalar fLeft = secularEq(leftShifted, col0, diag, perm, diagShifted, shift);
+      eigen_internal_assert(fLeft<Literal(0));
+
+#if defined EIGEN_INTERNAL_DEBUGGING || defined EIGEN_BDCSVD_SANITY_CHECKS
+      RealScalar fRight = secularEq(rightShifted, col0, diag, perm, diagShifted, shift);
+#endif
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+      if(!(numext::isfinite)(fLeft))
+        std::cout << "f(" << leftShifted << ") =" << fLeft << " ; " << left << " " << shift << " " << right << "\n";
+      assert((numext::isfinite)(fLeft));
+
+      if(!(numext::isfinite)(fRight))
+        std::cout << "f(" << rightShifted << ") =" << fRight << " ; " << left << " " << shift << " " << right << "\n";
+      // assert((numext::isfinite)(fRight));
+#endif
+    
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      if(!(fLeft * fRight<0))
+      {
+        std::cout << "f(leftShifted) using  leftShifted=" << leftShifted << " ;  diagShifted(1:10):" << diagShifted.head(10).transpose()  << "\n ; "
+                  << "left==shift=" << bool(left==shift) << " ; left-shift = " << (left-shift) << "\n";
+        std::cout << "k=" << k << ", " <<  fLeft << " * " << fRight << " == " << fLeft * fRight << "  ;  "
+                  << "[" << left << " .. " << right << "] -> [" << leftShifted << " " << rightShifted << "], shift=" << shift
+                  << " ,  f(right)=" << secularEq(0,     col0, diag, perm, diagShifted, shift)
+                           << " == " << secularEq(right, col0, diag, perm, diag, 0) << " == " << fRight << "\n";
+      }
+#endif
+      eigen_internal_assert(fLeft * fRight < Literal(0));
+
+      if(fLeft<Literal(0))
+      {
+        while (rightShifted - leftShifted > Literal(2) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(abs(leftShifted), abs(rightShifted)))
+        {
+          RealScalar midShifted = (leftShifted + rightShifted) / Literal(2);
+          fMid = secularEq(midShifted, col0, diag, perm, diagShifted, shift);
+          eigen_internal_assert((numext::isfinite)(fMid));
+
+          if (fLeft * fMid < Literal(0))
+          {
+            rightShifted = midShifted;
+          }
+          else
+          {
+            leftShifted = midShifted;
+            fLeft = fMid;
+          }
+        }
+        muCur = (leftShifted + rightShifted) / Literal(2);
+      }
+      else 
+      {
+        // We have a problem as shifting on the left or right give either a positive or negative value
+        // at the middle of [left,right]...
+        // Instead fo abbording or entering an infinite loop,
+        // let's just use the middle as the estimated zero-crossing:
+        muCur = (right - left) * RealScalar(0.5);
+        if(shift == right)
+          muCur = -muCur;
+      }
+    }
+      
+    singVals[k] = shift + muCur;
+    shifts[k] = shift;
+    mus[k] = muCur;
+
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+    if(k+1<n)
+      std::cout << "found " << singVals[k] << " == " << shift << " + " << muCur << " from " << diag(k) << " .. "  << diag(k+1) << "\n";
+#endif
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+    assert(k==0 || singVals[k]>=singVals[k-1]);
+    assert(singVals[k]>=diag(k));
+#endif
+
+    // perturb singular value slightly if it equals diagonal entry to avoid division by zero later
+    // (deflation is supposed to avoid this from happening)
+    // - this does no seem to be necessary anymore -
+//     if (singVals[k] == left) singVals[k] *= 1 + NumTraits<RealScalar>::epsilon();
+//     if (singVals[k] == right) singVals[k] *= 1 - NumTraits<RealScalar>::epsilon();
+  }
+}
+
+
+// zhat is perturbation of col0 for which singular vectors can be computed stably (see Section 3.1)
+template <typename MatrixType>
+void BDCSVD<MatrixType>::perturbCol0
+   (const ArrayRef& col0, const ArrayRef& diag, const IndicesRef &perm, const VectorType& singVals,
+    const ArrayRef& shifts, const ArrayRef& mus, ArrayRef zhat)
+{
+  using std::sqrt;
+  Index n = col0.size();
+  Index m = perm.size();
+  if(m==0)
+  {
+    zhat.setZero();
+    return;
+  }
+  Index lastIdx = perm(m-1);
+  // The offset permits to skip deflated entries while computing zhat
+  for (Index k = 0; k < n; ++k)
+  {
+    if (col0(k) == Literal(0)) // deflated
+      zhat(k) = Literal(0);
+    else
+    {
+      // see equation (3.6)
+      RealScalar dk = diag(k);
+      RealScalar prod = (singVals(lastIdx) + dk) * (mus(lastIdx) + (shifts(lastIdx) - dk));
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+      if(prod<0) {
+        std::cout << "k = " << k << " ;  z(k)=" << col0(k) << ", diag(k)=" << dk << "\n";
+        std::cout << "prod = " << "(" << singVals(lastIdx) << " + " << dk << ") * (" << mus(lastIdx) << " + (" << shifts(lastIdx) << " - " << dk << "))" << "\n";
+        std::cout << "     = " << singVals(lastIdx) + dk << " * " << mus(lastIdx) + (shifts(lastIdx) - dk) <<  "\n";
+      }
+      assert(prod>=0);
+#endif
+
+      for(Index l = 0; l<m; ++l)
+      {
+        Index i = perm(l);
+        if(i!=k)
+        {
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+          if(i>=k && (l==0 || l-1>=m))
+          {
+            std::cout << "Error in perturbCol0\n";
+            std::cout << "  " << k << "/" << n << " "  << l << "/" << m << " " << i << "/" << n << " ; " << col0(k) << " " << diag(k) << " "  <<  "\n";
+            std::cout << "  " <<diag(i) << "\n";
+            Index j = (i<k /*|| l==0*/) ? i : perm(l-1);
+            std::cout << "  " << "j=" << j << "\n";
+          }
+#endif
+          Index j = i<k ? i : perm(l-1);
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+          if(!(dk!=Literal(0) || diag(i)!=Literal(0)))
+          {
+            std::cout << "k=" << k << ", i=" << i << ", l=" << l << ", perm.size()=" << perm.size() << "\n";
+          }
+          assert(dk!=Literal(0) || diag(i)!=Literal(0));
+#endif
+          prod *= ((singVals(j)+dk) / ((diag(i)+dk))) * ((mus(j)+(shifts(j)-dk)) / ((diag(i)-dk)));
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+          assert(prod>=0);
+#endif
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+          if(i!=k && numext::abs(((singVals(j)+dk)*(mus(j)+(shifts(j)-dk)))/((diag(i)+dk)*(diag(i)-dk)) - 1) > 0.9 )
+            std::cout << "     " << ((singVals(j)+dk)*(mus(j)+(shifts(j)-dk)))/((diag(i)+dk)*(diag(i)-dk)) << " == (" << (singVals(j)+dk) << " * " << (mus(j)+(shifts(j)-dk))
+                       << ") / (" << (diag(i)+dk) << " * " << (diag(i)-dk) << ")\n";
+#endif
+        }
+      }
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "zhat(" << k << ") =  sqrt( " << prod << ")  ;  " << (singVals(lastIdx) + dk) << " * " << mus(lastIdx) + shifts(lastIdx) << " - " << dk << "\n";
+#endif
+      RealScalar tmp = sqrt(prod);
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+      assert((numext::isfinite)(tmp));
+#endif
+      zhat(k) = col0(k) > Literal(0) ? RealScalar(tmp) : RealScalar(-tmp);
+    }
+  }
+}
+
+// compute singular vectors
+template <typename MatrixType>
+void BDCSVD<MatrixType>::computeSingVecs
+   (const ArrayRef& zhat, const ArrayRef& diag, const IndicesRef &perm, const VectorType& singVals,
+    const ArrayRef& shifts, const ArrayRef& mus, MatrixXr& U, MatrixXr& V)
+{
+  Index n = zhat.size();
+  Index m = perm.size();
+  
+  for (Index k = 0; k < n; ++k)
+  {
+    if (zhat(k) == Literal(0))
+    {
+      U.col(k) = VectorType::Unit(n+1, k);
+      if (m_compV) V.col(k) = VectorType::Unit(n, k);
+    }
+    else
+    {
+      U.col(k).setZero();
+      for(Index l=0;l<m;++l)
+      {
+        Index i = perm(l);
+        U(i,k) = zhat(i)/(((diag(i) - shifts(k)) - mus(k)) )/( (diag(i) + singVals[k]));
+      }
+      U(n,k) = Literal(0);
+      U.col(k).normalize();
+    
+      if (m_compV)
+      {
+        V.col(k).setZero();
+        for(Index l=1;l<m;++l)
+        {
+          Index i = perm(l);
+          V(i,k) = diag(i) * zhat(i) / (((diag(i) - shifts(k)) - mus(k)) )/( (diag(i) + singVals[k]));
+        }
+        V(0,k) = Literal(-1);
+        V.col(k).normalize();
+      }
+    }
+  }
+  U.col(n) = VectorType::Unit(n+1, n);
+}
+
+
+// page 12_13
+// i >= 1, di almost null and zi non null.
+// We use a rotation to zero out zi applied to the left of M
+template <typename MatrixType>
+void BDCSVD<MatrixType>::deflation43(Eigen::Index firstCol, Eigen::Index shift, Eigen::Index i, Eigen::Index size)
+{
+  using std::abs;
+  using std::sqrt;
+  using std::pow;
+  Index start = firstCol + shift;
+  RealScalar c = m_computed(start, start);
+  RealScalar s = m_computed(start+i, start);
+  RealScalar r = numext::hypot(c,s);
+  if (r == Literal(0))
+  {
+    m_computed(start+i, start+i) = Literal(0);
+    return;
+  }
+  m_computed(start,start) = r;  
+  m_computed(start+i, start) = Literal(0);
+  m_computed(start+i, start+i) = Literal(0);
+  
+  JacobiRotation<RealScalar> J(c/r,-s/r);
+  if (m_compU)  m_naiveU.middleRows(firstCol, size+1).applyOnTheRight(firstCol, firstCol+i, J);
+  else          m_naiveU.applyOnTheRight(firstCol, firstCol+i, J);
+}// end deflation 43
+
+
+// page 13
+// i,j >= 1, i!=j and |di - dj| < epsilon * norm2(M)
+// We apply two rotations to have zj = 0;
+// TODO deflation44 is still broken and not properly tested
+template <typename MatrixType>
+void BDCSVD<MatrixType>::deflation44(Eigen::Index firstColu , Eigen::Index firstColm, Eigen::Index firstRowW, Eigen::Index firstColW, Eigen::Index i, Eigen::Index j, Eigen::Index size)
+{
+  using std::abs;
+  using std::sqrt;
+  using std::conj;
+  using std::pow;
+  RealScalar c = m_computed(firstColm+i, firstColm);
+  RealScalar s = m_computed(firstColm+j, firstColm);
+  RealScalar r = sqrt(numext::abs2(c) + numext::abs2(s));
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "deflation 4.4: " << i << "," << j << " -> " << c << " " << s << " " << r << " ; "
+    << m_computed(firstColm + i-1, firstColm)  << " "
+    << m_computed(firstColm + i, firstColm)  << " "
+    << m_computed(firstColm + i+1, firstColm) << " "
+    << m_computed(firstColm + i+2, firstColm) << "\n";
+  std::cout << m_computed(firstColm + i-1, firstColm + i-1)  << " "
+    << m_computed(firstColm + i, firstColm+i)  << " "
+    << m_computed(firstColm + i+1, firstColm+i+1) << " "
+    << m_computed(firstColm + i+2, firstColm+i+2) << "\n";
+#endif
+  if (r==Literal(0))
+  {
+    m_computed(firstColm + i, firstColm + i) = m_computed(firstColm + j, firstColm + j);
+    return;
+  }
+  c/=r;
+  s/=r;
+  m_computed(firstColm + i, firstColm) = r;
+  m_computed(firstColm + j, firstColm + j) = m_computed(firstColm + i, firstColm + i);
+  m_computed(firstColm + j, firstColm) = Literal(0);
+
+  JacobiRotation<RealScalar> J(c,-s);
+  if (m_compU)  m_naiveU.middleRows(firstColu, size+1).applyOnTheRight(firstColu + i, firstColu + j, J);
+  else          m_naiveU.applyOnTheRight(firstColu+i, firstColu+j, J);
+  if (m_compV)  m_naiveV.middleRows(firstRowW, size).applyOnTheRight(firstColW + i, firstColW + j, J);
+}// end deflation 44
+
+
+// acts on block from (firstCol+shift, firstCol+shift) to (lastCol+shift, lastCol+shift) [inclusive]
+template <typename MatrixType>
+void BDCSVD<MatrixType>::deflation(Eigen::Index firstCol, Eigen::Index lastCol, Eigen::Index k, Eigen::Index firstRowW, Eigen::Index firstColW, Eigen::Index shift)
+{
+  using std::sqrt;
+  using std::abs;
+  const Index length = lastCol + 1 - firstCol;
+  
+  Block<MatrixXr,Dynamic,1> col0(m_computed, firstCol+shift, firstCol+shift, length, 1);
+  Diagonal<MatrixXr> fulldiag(m_computed);
+  VectorBlock<Diagonal<MatrixXr>,Dynamic> diag(fulldiag, firstCol+shift, length);
+  
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  RealScalar maxDiag = diag.tail((std::max)(Index(1),length-1)).cwiseAbs().maxCoeff();
+  RealScalar epsilon_strict = numext::maxi<RealScalar>(considerZero,NumTraits<RealScalar>::epsilon() * maxDiag);
+  RealScalar epsilon_coarse = Literal(8) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(col0.cwiseAbs().maxCoeff(), maxDiag);
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE  
+  std::cout << "\ndeflate:" << diag.head(k+1).transpose() << "  |  " << diag.segment(k+1,length-k-1).transpose() << "\n";
+#endif
+  
+  //condition 4.1
+  if (diag(0) < epsilon_coarse)
+  { 
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+    std::cout << "deflation 4.1, because " << diag(0) << " < " << epsilon_coarse << "\n";
+#endif
+    diag(0) = epsilon_coarse;
+  }
+
+  //condition 4.2
+  for (Index i=1;i<length;++i)
+    if (abs(col0(i)) < epsilon_strict)
+    {
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "deflation 4.2, set z(" << i << ") to zero because " << abs(col0(i)) << " < " << epsilon_strict << "  (diag(" << i << ")=" << diag(i) << ")\n";
+#endif
+      col0(i) = Literal(0);
+    }
+
+  //condition 4.3
+  for (Index i=1;i<length; i++)
+    if (diag(i) < epsilon_coarse)
+    {
+#ifdef  EIGEN_BDCSVD_DEBUG_VERBOSE
+      std::cout << "deflation 4.3, cancel z(" << i << ")=" << col0(i) << " because diag(" << i << ")=" << diag(i) << " < " << epsilon_coarse << "\n";
+#endif
+      deflation43(firstCol, shift, i, length);
+    }
+
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "to be sorted: " << diag.transpose() << "\n\n";
+  std::cout << "            : " << col0.transpose() << "\n\n";
+#endif
+  {
+    // Check for total deflation
+    // If we have a total deflation, then we have to consider col0(0)==diag(0) as a singular value during sorting
+    bool total_deflation = (col0.tail(length-1).array()<considerZero).all();
+    
+    // Sort the diagonal entries, since diag(1:k-1) and diag(k:length) are already sorted, let's do a sorted merge.
+    // First, compute the respective permutation.
+    Index *permutation = m_workspaceI.data();
+    {
+      permutation[0] = 0;
+      Index p = 1;
+      
+      // Move deflated diagonal entries at the end.
+      for(Index i=1; i<length; ++i)
+        if(abs(diag(i))<considerZero)
+          permutation[p++] = i;
+        
+      Index i=1, j=k+1;
+      for( ; p < length; ++p)
+      {
+             if (i > k)             permutation[p] = j++;
+        else if (j >= length)       permutation[p] = i++;
+        else if (diag(i) < diag(j)) permutation[p] = j++;
+        else                        permutation[p] = i++;
+      }
+    }
+    
+    // If we have a total deflation, then we have to insert diag(0) at the right place
+    if(total_deflation)
+    {
+      for(Index i=1; i<length; ++i)
+      {
+        Index pi = permutation[i];
+        if(abs(diag(pi))<considerZero || diag(0)<diag(pi))
+          permutation[i-1] = permutation[i];
+        else
+        {
+          permutation[i-1] = 0;
+          break;
+        }
+      }
+    }
+    
+    // Current index of each col, and current column of each index
+    Index *realInd = m_workspaceI.data()+length;
+    Index *realCol = m_workspaceI.data()+2*length;
+    
+    for(int pos = 0; pos< length; pos++)
+    {
+      realCol[pos] = pos;
+      realInd[pos] = pos;
+    }
+    
+    for(Index i = total_deflation?0:1; i < length; i++)
+    {
+      const Index pi = permutation[length - (total_deflation ? i+1 : i)];
+      const Index J = realCol[pi];
+      
+      using std::swap;
+      // swap diagonal and first column entries:
+      swap(diag(i), diag(J));
+      if(i!=0 && J!=0) swap(col0(i), col0(J));
+
+      // change columns
+      if (m_compU) m_naiveU.col(firstCol+i).segment(firstCol, length + 1).swap(m_naiveU.col(firstCol+J).segment(firstCol, length + 1));
+      else         m_naiveU.col(firstCol+i).segment(0, 2)                .swap(m_naiveU.col(firstCol+J).segment(0, 2));
+      if (m_compV) m_naiveV.col(firstColW + i).segment(firstRowW, length).swap(m_naiveV.col(firstColW + J).segment(firstRowW, length));
+
+      //update real pos
+      const Index realI = realInd[i];
+      realCol[realI] = J;
+      realCol[pi] = i;
+      realInd[J] = realI;
+      realInd[i] = pi;
+    }
+  }
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+  std::cout << "sorted: " << diag.transpose().format(bdcsvdfmt) << "\n";
+  std::cout << "      : " << col0.transpose() << "\n\n";
+#endif
+    
+  //condition 4.4
+  {
+    Index i = length-1;
+    while(i>0 && (abs(diag(i))<considerZero || abs(col0(i))<considerZero)) --i;
+    for(; i>1;--i)
+       if( (diag(i) - diag(i-1)) < NumTraits<RealScalar>::epsilon()*maxDiag )
+      {
+#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
+        std::cout << "deflation 4.4 with i = " << i << " because " << diag(i) << " - " << diag(i-1) << " == " << (diag(i) - diag(i-1)) << " < " << NumTraits<RealScalar>::epsilon()*/*diag(i)*/maxDiag << "\n";
+#endif
+        eigen_internal_assert(abs(diag(i) - diag(i-1))<epsilon_coarse && " diagonal entries are not properly sorted");
+        deflation44(firstCol, firstCol + shift, firstRowW, firstColW, i-1, i, length);
+      }
+  }
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  for(Index j=2;j<length;++j)
+    assert(diag(j-1)<=diag(j) || abs(diag(j))<considerZero);
+#endif
+  
+#ifdef EIGEN_BDCSVD_SANITY_CHECKS
+  assert(m_naiveU.allFinite());
+  assert(m_naiveV.allFinite());
+  assert(m_computed.allFinite());
+#endif
+}//end deflation
+
+/** \svd_module
+  *
+  * \return the singular value decomposition of \c *this computed by Divide & Conquer algorithm
+  *
+  * \sa class BDCSVD
+  */
+template<typename Derived>
+BDCSVD<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::bdcSvd(unsigned int computationOptions) const
+{
+  return BDCSVD<PlainObject>(*this, computationOptions);
+}
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SVD/JacobiSVD.h b/C++/yolo_bytetrack_old/include/Eigen/src/SVD/JacobiSVD.h
new file mode 100644
index 00000000..9d95acdf
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SVD/JacobiSVD.h
@@ -0,0 +1,812 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2013-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_JACOBISVD_H
+#define EIGEN_JACOBISVD_H
+
+namespace Eigen { 
+
+namespace internal {
+// forward declaration (needed by ICC)
+// the empty body is required by MSVC
+template<typename MatrixType, int QRPreconditioner,
+         bool IsComplex = NumTraits<typename MatrixType::Scalar>::IsComplex>
+struct svd_precondition_2x2_block_to_be_real {};
+
+/*** QR preconditioners (R-SVD)
+ ***
+ *** Their role is to reduce the problem of computing the SVD to the case of a square matrix.
+ *** This approach, known as R-SVD, is an optimization for rectangular-enough matrices, and is a requirement for
+ *** JacobiSVD which by itself is only able to work on square matrices.
+ ***/
+
+enum { PreconditionIfMoreColsThanRows, PreconditionIfMoreRowsThanCols };
+
+template<typename MatrixType, int QRPreconditioner, int Case>
+struct qr_preconditioner_should_do_anything
+{
+  enum { a = MatrixType::RowsAtCompileTime != Dynamic &&
+             MatrixType::ColsAtCompileTime != Dynamic &&
+             MatrixType::ColsAtCompileTime <= MatrixType::RowsAtCompileTime,
+         b = MatrixType::RowsAtCompileTime != Dynamic &&
+             MatrixType::ColsAtCompileTime != Dynamic &&
+             MatrixType::RowsAtCompileTime <= MatrixType::ColsAtCompileTime,
+         ret = !( (QRPreconditioner == NoQRPreconditioner) ||
+                  (Case == PreconditionIfMoreColsThanRows && bool(a)) ||
+                  (Case == PreconditionIfMoreRowsThanCols && bool(b)) )
+  };
+};
+
+template<typename MatrixType, int QRPreconditioner, int Case,
+         bool DoAnything = qr_preconditioner_should_do_anything<MatrixType, QRPreconditioner, Case>::ret
+> struct qr_preconditioner_impl {};
+
+template<typename MatrixType, int QRPreconditioner, int Case>
+class qr_preconditioner_impl<MatrixType, QRPreconditioner, Case, false>
+{
+public:
+  void allocate(const JacobiSVD<MatrixType, QRPreconditioner>&) {}
+  bool run(JacobiSVD<MatrixType, QRPreconditioner>&, const MatrixType&)
+  {
+    return false;
+  }
+};
+
+/*** preconditioner using FullPivHouseholderQR ***/
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime
+  };
+  typedef Matrix<Scalar, 1, RowsAtCompileTime, RowMajor, 1, MaxRowsAtCompileTime> WorkspaceType;
+
+  void allocate(const JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.rows(), svd.cols());
+    }
+    if (svd.m_computeFullU) m_workspace.resize(svd.rows());
+  }
+
+  bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.rows() > matrix.cols())
+    {
+      m_qr.compute(matrix);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).template triangularView<Upper>();
+      if(svd.m_computeFullU) m_qr.matrixQ().evalTo(svd.m_matrixU, m_workspace);
+      if(svd.computeV()) svd.m_matrixV = m_qr.colsPermutation();
+      return true;
+    }
+    return false;
+  }
+private:
+  typedef FullPivHouseholderQR<MatrixType> QRType;
+  QRType m_qr;
+  WorkspaceType m_workspace;
+};
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    Options = MatrixType::Options
+  };
+
+  typedef typename internal::make_proper_matrix_type<
+    Scalar, ColsAtCompileTime, RowsAtCompileTime, Options, MaxColsAtCompileTime, MaxRowsAtCompileTime
+  >::type TransposeTypeWithSameStorageOrder;
+
+  void allocate(const JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.cols(), svd.rows());
+    }
+    m_adjoint.resize(svd.cols(), svd.rows());
+    if (svd.m_computeFullV) m_workspace.resize(svd.cols());
+  }
+
+  bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.cols() > matrix.rows())
+    {
+      m_adjoint = matrix.adjoint();
+      m_qr.compute(m_adjoint);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).template triangularView<Upper>().adjoint();
+      if(svd.m_computeFullV) m_qr.matrixQ().evalTo(svd.m_matrixV, m_workspace);
+      if(svd.computeU()) svd.m_matrixU = m_qr.colsPermutation();
+      return true;
+    }
+    else return false;
+  }
+private:
+  typedef FullPivHouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  QRType m_qr;
+  TransposeTypeWithSameStorageOrder m_adjoint;
+  typename internal::plain_row_type<MatrixType>::type m_workspace;
+};
+
+/*** preconditioner using ColPivHouseholderQR ***/
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true>
+{
+public:
+  void allocate(const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.rows(), svd.cols());
+    }
+    if (svd.m_computeFullU) m_workspace.resize(svd.rows());
+    else if (svd.m_computeThinU) m_workspace.resize(svd.cols());
+  }
+
+  bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.rows() > matrix.cols())
+    {
+      m_qr.compute(matrix);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).template triangularView<Upper>();
+      if(svd.m_computeFullU) m_qr.householderQ().evalTo(svd.m_matrixU, m_workspace);
+      else if(svd.m_computeThinU)
+      {
+        svd.m_matrixU.setIdentity(matrix.rows(), matrix.cols());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixU, m_workspace);
+      }
+      if(svd.computeV()) svd.m_matrixV = m_qr.colsPermutation();
+      return true;
+    }
+    return false;
+  }
+
+private:
+  typedef ColPivHouseholderQR<MatrixType> QRType;
+  QRType m_qr;
+  typename internal::plain_col_type<MatrixType>::type m_workspace;
+};
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    Options = MatrixType::Options
+  };
+
+  typedef typename internal::make_proper_matrix_type<
+    Scalar, ColsAtCompileTime, RowsAtCompileTime, Options, MaxColsAtCompileTime, MaxRowsAtCompileTime
+  >::type TransposeTypeWithSameStorageOrder;
+
+  void allocate(const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd)
+  {
+    if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.cols(), svd.rows());
+    }
+    if (svd.m_computeFullV) m_workspace.resize(svd.cols());
+    else if (svd.m_computeThinV) m_workspace.resize(svd.rows());
+    m_adjoint.resize(svd.cols(), svd.rows());
+  }
+
+  bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.cols() > matrix.rows())
+    {
+      m_adjoint = matrix.adjoint();
+      m_qr.compute(m_adjoint);
+
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).template triangularView<Upper>().adjoint();
+      if(svd.m_computeFullV) m_qr.householderQ().evalTo(svd.m_matrixV, m_workspace);
+      else if(svd.m_computeThinV)
+      {
+        svd.m_matrixV.setIdentity(matrix.cols(), matrix.rows());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixV, m_workspace);
+      }
+      if(svd.computeU()) svd.m_matrixU = m_qr.colsPermutation();
+      return true;
+    }
+    else return false;
+  }
+
+private:
+  typedef ColPivHouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  QRType m_qr;
+  TransposeTypeWithSameStorageOrder m_adjoint;
+  typename internal::plain_row_type<MatrixType>::type m_workspace;
+};
+
+/*** preconditioner using HouseholderQR ***/
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true>
+{
+public:
+  void allocate(const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd)
+  {
+    if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.rows(), svd.cols());
+    }
+    if (svd.m_computeFullU) m_workspace.resize(svd.rows());
+    else if (svd.m_computeThinU) m_workspace.resize(svd.cols());
+  }
+
+  bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.rows() > matrix.cols())
+    {
+      m_qr.compute(matrix);
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.cols(),matrix.cols()).template triangularView<Upper>();
+      if(svd.m_computeFullU) m_qr.householderQ().evalTo(svd.m_matrixU, m_workspace);
+      else if(svd.m_computeThinU)
+      {
+        svd.m_matrixU.setIdentity(matrix.rows(), matrix.cols());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixU, m_workspace);
+      }
+      if(svd.computeV()) svd.m_matrixV.setIdentity(matrix.cols(), matrix.cols());
+      return true;
+    }
+    return false;
+  }
+private:
+  typedef HouseholderQR<MatrixType> QRType;
+  QRType m_qr;
+  typename internal::plain_col_type<MatrixType>::type m_workspace;
+};
+
+template<typename MatrixType>
+class qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true>
+{
+public:
+  typedef typename MatrixType::Scalar Scalar;
+  enum
+  {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    Options = MatrixType::Options
+  };
+
+  typedef typename internal::make_proper_matrix_type<
+    Scalar, ColsAtCompileTime, RowsAtCompileTime, Options, MaxColsAtCompileTime, MaxRowsAtCompileTime
+  >::type TransposeTypeWithSameStorageOrder;
+
+  void allocate(const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd)
+  {
+    if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols())
+    {
+      m_qr.~QRType();
+      ::new (&m_qr) QRType(svd.cols(), svd.rows());
+    }
+    if (svd.m_computeFullV) m_workspace.resize(svd.cols());
+    else if (svd.m_computeThinV) m_workspace.resize(svd.rows());
+    m_adjoint.resize(svd.cols(), svd.rows());
+  }
+
+  bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const MatrixType& matrix)
+  {
+    if(matrix.cols() > matrix.rows())
+    {
+      m_adjoint = matrix.adjoint();
+      m_qr.compute(m_adjoint);
+
+      svd.m_workMatrix = m_qr.matrixQR().block(0,0,matrix.rows(),matrix.rows()).template triangularView<Upper>().adjoint();
+      if(svd.m_computeFullV) m_qr.householderQ().evalTo(svd.m_matrixV, m_workspace);
+      else if(svd.m_computeThinV)
+      {
+        svd.m_matrixV.setIdentity(matrix.cols(), matrix.rows());
+        m_qr.householderQ().applyThisOnTheLeft(svd.m_matrixV, m_workspace);
+      }
+      if(svd.computeU()) svd.m_matrixU.setIdentity(matrix.rows(), matrix.rows());
+      return true;
+    }
+    else return false;
+  }
+
+private:
+  typedef HouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  QRType m_qr;
+  TransposeTypeWithSameStorageOrder m_adjoint;
+  typename internal::plain_row_type<MatrixType>::type m_workspace;
+};
+
+/*** 2x2 SVD implementation
+ ***
+ *** JacobiSVD consists in performing a series of 2x2 SVD subproblems
+ ***/
+
+template<typename MatrixType, int QRPreconditioner>
+struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, false>
+{
+  typedef JacobiSVD<MatrixType, QRPreconditioner> SVD;
+  typedef typename MatrixType::RealScalar RealScalar;
+  static bool run(typename SVD::WorkMatrixType&, SVD&, Index, Index, RealScalar&) { return true; }
+};
+
+template<typename MatrixType, int QRPreconditioner>
+struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, true>
+{
+  typedef JacobiSVD<MatrixType, QRPreconditioner> SVD;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  static bool run(typename SVD::WorkMatrixType& work_matrix, SVD& svd, Index p, Index q, RealScalar& maxDiagEntry)
+  {
+    using std::sqrt;
+    using std::abs;
+    Scalar z;
+    JacobiRotation<Scalar> rot;
+    RealScalar n = sqrt(numext::abs2(work_matrix.coeff(p,p)) + numext::abs2(work_matrix.coeff(q,p)));
+
+    const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+    const RealScalar precision = NumTraits<Scalar>::epsilon();
+
+    if(n==0)
+    {
+      // make sure first column is zero
+      work_matrix.coeffRef(p,p) = work_matrix.coeffRef(q,p) = Scalar(0);
+
+      if(abs(numext::imag(work_matrix.coeff(p,q)))>considerAsZero)
+      {
+        // work_matrix.coeff(p,q) can be zero if work_matrix.coeff(q,p) is not zero but small enough to underflow when computing n
+        z = abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q);
+        work_matrix.row(p) *= z;
+        if(svd.computeU()) svd.m_matrixU.col(p) *= conj(z);
+      }
+      if(abs(numext::imag(work_matrix.coeff(q,q)))>considerAsZero)
+      {
+        z = abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q);
+        work_matrix.row(q) *= z;
+        if(svd.computeU()) svd.m_matrixU.col(q) *= conj(z);
+      }
+      // otherwise the second row is already zero, so we have nothing to do.
+    }
+    else
+    {
+      rot.c() = conj(work_matrix.coeff(p,p)) / n;
+      rot.s() = work_matrix.coeff(q,p) / n;
+      work_matrix.applyOnTheLeft(p,q,rot);
+      if(svd.computeU()) svd.m_matrixU.applyOnTheRight(p,q,rot.adjoint());
+      if(abs(numext::imag(work_matrix.coeff(p,q)))>considerAsZero)
+      {
+        z = abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q);
+        work_matrix.col(q) *= z;
+        if(svd.computeV()) svd.m_matrixV.col(q) *= z;
+      }
+      if(abs(numext::imag(work_matrix.coeff(q,q)))>considerAsZero)
+      {
+        z = abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q);
+        work_matrix.row(q) *= z;
+        if(svd.computeU()) svd.m_matrixU.col(q) *= conj(z);
+      }
+    }
+
+    // update largest diagonal entry
+    maxDiagEntry = numext::maxi<RealScalar>(maxDiagEntry,numext::maxi<RealScalar>(abs(work_matrix.coeff(p,p)), abs(work_matrix.coeff(q,q))));
+    // and check whether the 2x2 block is already diagonal
+    RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
+    return abs(work_matrix.coeff(p,q))>threshold || abs(work_matrix.coeff(q,p)) > threshold;
+  }
+};
+
+template<typename _MatrixType, int QRPreconditioner> 
+struct traits<JacobiSVD<_MatrixType,QRPreconditioner> >
+        : traits<_MatrixType>
+{
+  typedef _MatrixType MatrixType;
+};
+
+} // end namespace internal
+
+/** \ingroup SVD_Module
+  *
+  *
+  * \class JacobiSVD
+  *
+  * \brief Two-sided Jacobi SVD decomposition of a rectangular matrix
+  *
+  * \tparam _MatrixType the type of the matrix of which we are computing the SVD decomposition
+  * \tparam QRPreconditioner this optional parameter allows to specify the type of QR decomposition that will be used internally
+  *                        for the R-SVD step for non-square matrices. See discussion of possible values below.
+  *
+  * SVD decomposition consists in decomposing any n-by-p matrix \a A as a product
+  *   \f[ A = U S V^* \f]
+  * where \a U is a n-by-n unitary, \a V is a p-by-p unitary, and \a S is a n-by-p real positive matrix which is zero outside of its main diagonal;
+  * the diagonal entries of S are known as the \em singular \em values of \a A and the columns of \a U and \a V are known as the left
+  * and right \em singular \em vectors of \a A respectively.
+  *
+  * Singular values are always sorted in decreasing order.
+  *
+  * This JacobiSVD decomposition computes only the singular values by default. If you want \a U or \a V, you need to ask for them explicitly.
+  *
+  * You can ask for only \em thin \a U or \a V to be computed, meaning the following. In case of a rectangular n-by-p matrix, letting \a m be the
+  * smaller value among \a n and \a p, there are only \a m singular vectors; the remaining columns of \a U and \a V do not correspond to actual
+  * singular vectors. Asking for \em thin \a U or \a V means asking for only their \a m first columns to be formed. So \a U is then a n-by-m matrix,
+  * and \a V is then a p-by-m matrix. Notice that thin \a U and \a V are all you need for (least squares) solving.
+  *
+  * Here's an example demonstrating basic usage:
+  * \include JacobiSVD_basic.cpp
+  * Output: \verbinclude JacobiSVD_basic.out
+  *
+  * This JacobiSVD class is a two-sided Jacobi R-SVD decomposition, ensuring optimal reliability and accuracy. The downside is that it's slower than
+  * bidiagonalizing SVD algorithms for large square matrices; however its complexity is still \f$ O(n^2p) \f$ where \a n is the smaller dimension and
+  * \a p is the greater dimension, meaning that it is still of the same order of complexity as the faster bidiagonalizing R-SVD algorithms.
+  * In particular, like any R-SVD, it takes advantage of non-squareness in that its complexity is only linear in the greater dimension.
+  *
+  * If the input matrix has inf or nan coefficients, the result of the computation is undefined, but the computation is guaranteed to
+  * terminate in finite (and reasonable) time.
+  *
+  * The possible values for QRPreconditioner are:
+  * \li ColPivHouseholderQRPreconditioner is the default. In practice it's very safe. It uses column-pivoting QR.
+  * \li FullPivHouseholderQRPreconditioner, is the safest and slowest. It uses full-pivoting QR.
+  *     Contrary to other QRs, it doesn't allow computing thin unitaries.
+  * \li HouseholderQRPreconditioner is the fastest, and less safe and accurate than the pivoting variants. It uses non-pivoting QR.
+  *     This is very similar in safety and accuracy to the bidiagonalization process used by bidiagonalizing SVD algorithms (since bidiagonalization
+  *     is inherently non-pivoting). However the resulting SVD is still more reliable than bidiagonalizing SVDs because the Jacobi-based iterarive
+  *     process is more reliable than the optimized bidiagonal SVD iterations.
+  * \li NoQRPreconditioner allows not to use a QR preconditioner at all. This is useful if you know that you will only be computing
+  *     JacobiSVD decompositions of square matrices. Non-square matrices require a QR preconditioner. Using this option will result in
+  *     faster compilation and smaller executable code. It won't significantly speed up computation, since JacobiSVD is always checking
+  *     if QR preconditioning is needed before applying it anyway.
+  *
+  * \sa MatrixBase::jacobiSvd()
+  */
+template<typename _MatrixType, int QRPreconditioner> class JacobiSVD
+ : public SVDBase<JacobiSVD<_MatrixType,QRPreconditioner> >
+{
+    typedef SVDBase<JacobiSVD> Base;
+  public:
+
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime),
+      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+      MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime,MaxColsAtCompileTime),
+      MatrixOptions = MatrixType::Options
+    };
+
+    typedef typename Base::MatrixUType MatrixUType;
+    typedef typename Base::MatrixVType MatrixVType;
+    typedef typename Base::SingularValuesType SingularValuesType;
+    
+    typedef typename internal::plain_row_type<MatrixType>::type RowType;
+    typedef typename internal::plain_col_type<MatrixType>::type ColType;
+    typedef Matrix<Scalar, DiagSizeAtCompileTime, DiagSizeAtCompileTime,
+                   MatrixOptions, MaxDiagSizeAtCompileTime, MaxDiagSizeAtCompileTime>
+            WorkMatrixType;
+
+    /** \brief Default Constructor.
+      *
+      * The default constructor is useful in cases in which the user intends to
+      * perform decompositions via JacobiSVD::compute(const MatrixType&).
+      */
+    JacobiSVD()
+    {}
+
+
+    /** \brief Default Constructor with memory preallocation
+      *
+      * Like the default constructor but with preallocation of the internal data
+      * according to the specified problem size.
+      * \sa JacobiSVD()
+      */
+    JacobiSVD(Index rows, Index cols, unsigned int computationOptions = 0)
+    {
+      allocate(rows, cols, computationOptions);
+    }
+
+    /** \brief Constructor performing the decomposition of given matrix.
+     *
+     * \param matrix the matrix to decompose
+     * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+     *                           By default, none is computed. This is a bit-field, the possible bits are #ComputeFullU, #ComputeThinU,
+     *                           #ComputeFullV, #ComputeThinV.
+     *
+     * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+     * available with the (non-default) FullPivHouseholderQR preconditioner.
+     */
+    explicit JacobiSVD(const MatrixType& matrix, unsigned int computationOptions = 0)
+    {
+      compute(matrix, computationOptions);
+    }
+
+    /** \brief Method performing the decomposition of given matrix using custom options.
+     *
+     * \param matrix the matrix to decompose
+     * \param computationOptions optional parameter allowing to specify if you want full or thin U or V unitaries to be computed.
+     *                           By default, none is computed. This is a bit-field, the possible bits are #ComputeFullU, #ComputeThinU,
+     *                           #ComputeFullV, #ComputeThinV.
+     *
+     * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
+     * available with the (non-default) FullPivHouseholderQR preconditioner.
+     */
+    JacobiSVD& compute(const MatrixType& matrix, unsigned int computationOptions);
+
+    /** \brief Method performing the decomposition of given matrix using current options.
+     *
+     * \param matrix the matrix to decompose
+     *
+     * This method uses the current \a computationOptions, as already passed to the constructor or to compute(const MatrixType&, unsigned int).
+     */
+    JacobiSVD& compute(const MatrixType& matrix)
+    {
+      return compute(matrix, m_computationOptions);
+    }
+
+    using Base::computeU;
+    using Base::computeV;
+    using Base::rows;
+    using Base::cols;
+    using Base::rank;
+
+  private:
+    void allocate(Index rows, Index cols, unsigned int computationOptions);
+
+  protected:
+    using Base::m_matrixU;
+    using Base::m_matrixV;
+    using Base::m_singularValues;
+    using Base::m_info;
+    using Base::m_isInitialized;
+    using Base::m_isAllocated;
+    using Base::m_usePrescribedThreshold;
+    using Base::m_computeFullU;
+    using Base::m_computeThinU;
+    using Base::m_computeFullV;
+    using Base::m_computeThinV;
+    using Base::m_computationOptions;
+    using Base::m_nonzeroSingularValues;
+    using Base::m_rows;
+    using Base::m_cols;
+    using Base::m_diagSize;
+    using Base::m_prescribedThreshold;
+    WorkMatrixType m_workMatrix;
+
+    template<typename __MatrixType, int _QRPreconditioner, bool _IsComplex>
+    friend struct internal::svd_precondition_2x2_block_to_be_real;
+    template<typename __MatrixType, int _QRPreconditioner, int _Case, bool _DoAnything>
+    friend struct internal::qr_preconditioner_impl;
+
+    internal::qr_preconditioner_impl<MatrixType, QRPreconditioner, internal::PreconditionIfMoreColsThanRows> m_qr_precond_morecols;
+    internal::qr_preconditioner_impl<MatrixType, QRPreconditioner, internal::PreconditionIfMoreRowsThanCols> m_qr_precond_morerows;
+    MatrixType m_scaledMatrix;
+};
+
+template<typename MatrixType, int QRPreconditioner>
+void JacobiSVD<MatrixType, QRPreconditioner>::allocate(Eigen::Index rows, Eigen::Index cols, unsigned int computationOptions)
+{
+  eigen_assert(rows >= 0 && cols >= 0);
+
+  if (m_isAllocated &&
+      rows == m_rows &&
+      cols == m_cols &&
+      computationOptions == m_computationOptions)
+  {
+    return;
+  }
+
+  m_rows = rows;
+  m_cols = cols;
+  m_info = Success;
+  m_isInitialized = false;
+  m_isAllocated = true;
+  m_computationOptions = computationOptions;
+  m_computeFullU = (computationOptions & ComputeFullU) != 0;
+  m_computeThinU = (computationOptions & ComputeThinU) != 0;
+  m_computeFullV = (computationOptions & ComputeFullV) != 0;
+  m_computeThinV = (computationOptions & ComputeThinV) != 0;
+  eigen_assert(!(m_computeFullU && m_computeThinU) && "JacobiSVD: you can't ask for both full and thin U");
+  eigen_assert(!(m_computeFullV && m_computeThinV) && "JacobiSVD: you can't ask for both full and thin V");
+  eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) &&
+              "JacobiSVD: thin U and V are only available when your matrix has a dynamic number of columns.");
+  if (QRPreconditioner == FullPivHouseholderQRPreconditioner)
+  {
+      eigen_assert(!(m_computeThinU || m_computeThinV) &&
+              "JacobiSVD: can't compute thin U or thin V with the FullPivHouseholderQR preconditioner. "
+              "Use the ColPivHouseholderQR preconditioner instead.");
+  }
+  m_diagSize = (std::min)(m_rows, m_cols);
+  m_singularValues.resize(m_diagSize);
+  if(RowsAtCompileTime==Dynamic)
+    m_matrixU.resize(m_rows, m_computeFullU ? m_rows
+                            : m_computeThinU ? m_diagSize
+                            : 0);
+  if(ColsAtCompileTime==Dynamic)
+    m_matrixV.resize(m_cols, m_computeFullV ? m_cols
+                            : m_computeThinV ? m_diagSize
+                            : 0);
+  m_workMatrix.resize(m_diagSize, m_diagSize);
+  
+  if(m_cols>m_rows)   m_qr_precond_morecols.allocate(*this);
+  if(m_rows>m_cols)   m_qr_precond_morerows.allocate(*this);
+  if(m_rows!=m_cols)  m_scaledMatrix.resize(rows,cols);
+}
+
+template<typename MatrixType, int QRPreconditioner>
+JacobiSVD<MatrixType, QRPreconditioner>&
+JacobiSVD<MatrixType, QRPreconditioner>::compute(const MatrixType& matrix, unsigned int computationOptions)
+{
+  using std::abs;
+  allocate(matrix.rows(), matrix.cols(), computationOptions);
+
+  // currently we stop when we reach precision 2*epsilon as the last bit of precision can require an unreasonable number of iterations,
+  // only worsening the precision of U and V as we accumulate more rotations
+  const RealScalar precision = RealScalar(2) * NumTraits<Scalar>::epsilon();
+
+  // limit for denormal numbers to be considered zero in order to avoid infinite loops (see bug 286)
+  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+
+  // Scaling factor to reduce over/under-flows
+  RealScalar scale = matrix.cwiseAbs().template maxCoeff<PropagateNaN>();
+  if (!(numext::isfinite)(scale)) {
+    m_isInitialized = true;
+    m_info = InvalidInput;
+    return *this;
+  }
+  if(scale==RealScalar(0)) scale = RealScalar(1);
+  
+  /*** step 1. The R-SVD step: we use a QR decomposition to reduce to the case of a square matrix */
+
+  if(m_rows!=m_cols)
+  {
+    m_scaledMatrix = matrix / scale;
+    m_qr_precond_morecols.run(*this, m_scaledMatrix);
+    m_qr_precond_morerows.run(*this, m_scaledMatrix);
+  }
+  else
+  {
+    m_workMatrix = matrix.block(0,0,m_diagSize,m_diagSize) / scale;
+    if(m_computeFullU) m_matrixU.setIdentity(m_rows,m_rows);
+    if(m_computeThinU) m_matrixU.setIdentity(m_rows,m_diagSize);
+    if(m_computeFullV) m_matrixV.setIdentity(m_cols,m_cols);
+    if(m_computeThinV) m_matrixV.setIdentity(m_cols, m_diagSize);
+  }
+
+  /*** step 2. The main Jacobi SVD iteration. ***/
+  RealScalar maxDiagEntry = m_workMatrix.cwiseAbs().diagonal().maxCoeff();
+
+  bool finished = false;
+  while(!finished)
+  {
+    finished = true;
+
+    // do a sweep: for all index pairs (p,q), perform SVD of the corresponding 2x2 sub-matrix
+
+    for(Index p = 1; p < m_diagSize; ++p)
+    {
+      for(Index q = 0; q < p; ++q)
+      {
+        // if this 2x2 sub-matrix is not diagonal already...
+        // notice that this comparison will evaluate to false if any NaN is involved, ensuring that NaN's don't
+        // keep us iterating forever. Similarly, small denormal numbers are considered zero.
+        RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
+        if(abs(m_workMatrix.coeff(p,q))>threshold || abs(m_workMatrix.coeff(q,p)) > threshold)
+        {
+          finished = false;
+          // perform SVD decomposition of 2x2 sub-matrix corresponding to indices p,q to make it diagonal
+          // the complex to real operation returns true if the updated 2x2 block is not already diagonal
+          if(internal::svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner>::run(m_workMatrix, *this, p, q, maxDiagEntry))
+          {
+            JacobiRotation<RealScalar> j_left, j_right;
+            internal::real_2x2_jacobi_svd(m_workMatrix, p, q, &j_left, &j_right);
+
+            // accumulate resulting Jacobi rotations
+            m_workMatrix.applyOnTheLeft(p,q,j_left);
+            if(computeU()) m_matrixU.applyOnTheRight(p,q,j_left.transpose());
+
+            m_workMatrix.applyOnTheRight(p,q,j_right);
+            if(computeV()) m_matrixV.applyOnTheRight(p,q,j_right);
+
+            // keep track of the largest diagonal coefficient
+            maxDiagEntry = numext::maxi<RealScalar>(maxDiagEntry,numext::maxi<RealScalar>(abs(m_workMatrix.coeff(p,p)), abs(m_workMatrix.coeff(q,q))));
+          }
+        }
+      }
+    }
+  }
+
+  /*** step 3. The work matrix is now diagonal, so ensure it's positive so its diagonal entries are the singular values ***/
+
+  for(Index i = 0; i < m_diagSize; ++i)
+  {
+    // For a complex matrix, some diagonal coefficients might note have been
+    // treated by svd_precondition_2x2_block_to_be_real, and the imaginary part
+    // of some diagonal entry might not be null.
+    if(NumTraits<Scalar>::IsComplex && abs(numext::imag(m_workMatrix.coeff(i,i)))>considerAsZero)
+    {
+      RealScalar a = abs(m_workMatrix.coeff(i,i));
+      m_singularValues.coeffRef(i) = abs(a);
+      if(computeU()) m_matrixU.col(i) *= m_workMatrix.coeff(i,i)/a;
+    }
+    else
+    {
+      // m_workMatrix.coeff(i,i) is already real, no difficulty:
+      RealScalar a = numext::real(m_workMatrix.coeff(i,i));
+      m_singularValues.coeffRef(i) = abs(a);
+      if(computeU() && (a<RealScalar(0))) m_matrixU.col(i) = -m_matrixU.col(i);
+    }
+  }
+  
+  m_singularValues *= scale;
+
+  /*** step 4. Sort singular values in descending order and compute the number of nonzero singular values ***/
+
+  m_nonzeroSingularValues = m_diagSize;
+  for(Index i = 0; i < m_diagSize; i++)
+  {
+    Index pos;
+    RealScalar maxRemainingSingularValue = m_singularValues.tail(m_diagSize-i).maxCoeff(&pos);
+    if(maxRemainingSingularValue == RealScalar(0))
+    {
+      m_nonzeroSingularValues = i;
+      break;
+    }
+    if(pos)
+    {
+      pos += i;
+      std::swap(m_singularValues.coeffRef(i), m_singularValues.coeffRef(pos));
+      if(computeU()) m_matrixU.col(pos).swap(m_matrixU.col(i));
+      if(computeV()) m_matrixV.col(pos).swap(m_matrixV.col(i));
+    }
+  }
+
+  m_isInitialized = true;
+  return *this;
+}
+
+/** \svd_module
+  *
+  * \return the singular value decomposition of \c *this computed by two-sided
+  * Jacobi transformations.
+  *
+  * \sa class JacobiSVD
+  */
+template<typename Derived>
+JacobiSVD<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::jacobiSvd(unsigned int computationOptions) const
+{
+  return JacobiSVD<PlainObject>(*this, computationOptions);
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_JACOBISVD_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SVD/JacobiSVD_LAPACKE.h b/C++/yolo_bytetrack_old/include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
new file mode 100644
index 00000000..ff0516f6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SVD/JacobiSVD_LAPACKE.h
@@ -0,0 +1,91 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to LAPACKe
+ *    Singular Value Decomposition - SVD.
+ ********************************************************************************
+*/
+
+#ifndef EIGEN_JACOBISVD_LAPACKE_H
+#define EIGEN_JACOBISVD_LAPACKE_H
+
+namespace Eigen { 
+
+/** \internal Specialization for the data types supported by LAPACKe */
+
+#define EIGEN_LAPACKE_SVD(EIGTYPE, LAPACKE_TYPE, LAPACKE_RTYPE, LAPACKE_PREFIX, EIGCOLROW, LAPACKE_COLROW) \
+template<> inline \
+JacobiSVD<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>, ColPivHouseholderQRPreconditioner>& \
+JacobiSVD<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>, ColPivHouseholderQRPreconditioner>::compute(const Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic>& matrix, unsigned int computationOptions) \
+{ \
+  typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW, Dynamic, Dynamic> MatrixType; \
+  /*typedef MatrixType::Scalar Scalar;*/ \
+  /*typedef MatrixType::RealScalar RealScalar;*/ \
+  allocate(matrix.rows(), matrix.cols(), computationOptions); \
+\
+  /*const RealScalar precision = RealScalar(2) * NumTraits<Scalar>::epsilon();*/ \
+  m_nonzeroSingularValues = m_diagSize; \
+\
+  lapack_int lda = internal::convert_index<lapack_int>(matrix.outerStride()), ldu, ldvt; \
+  lapack_int matrix_order = LAPACKE_COLROW; \
+  char jobu, jobvt; \
+  LAPACKE_TYPE *u, *vt, dummy; \
+  jobu  = (m_computeFullU) ? 'A' : (m_computeThinU) ? 'S' : 'N'; \
+  jobvt = (m_computeFullV) ? 'A' : (m_computeThinV) ? 'S' : 'N'; \
+  if (computeU()) { \
+    ldu  = internal::convert_index<lapack_int>(m_matrixU.outerStride()); \
+    u    = (LAPACKE_TYPE*)m_matrixU.data(); \
+  } else { ldu=1; u=&dummy; }\
+  MatrixType localV; \
+  lapack_int vt_rows = (m_computeFullV) ? internal::convert_index<lapack_int>(m_cols) : (m_computeThinV) ? internal::convert_index<lapack_int>(m_diagSize) : 1; \
+  if (computeV()) { \
+    localV.resize(vt_rows, m_cols); \
+    ldvt  = internal::convert_index<lapack_int>(localV.outerStride()); \
+    vt   = (LAPACKE_TYPE*)localV.data(); \
+  } else { ldvt=1; vt=&dummy; }\
+  Matrix<LAPACKE_RTYPE, Dynamic, Dynamic> superb; superb.resize(m_diagSize, 1); \
+  MatrixType m_temp; m_temp = matrix; \
+  LAPACKE_##LAPACKE_PREFIX##gesvd( matrix_order, jobu, jobvt, internal::convert_index<lapack_int>(m_rows), internal::convert_index<lapack_int>(m_cols), (LAPACKE_TYPE*)m_temp.data(), lda, (LAPACKE_RTYPE*)m_singularValues.data(), u, ldu, vt, ldvt, superb.data()); \
+  if (computeV()) m_matrixV = localV.adjoint(); \
+ /* for(int i=0;i<m_diagSize;i++) if (m_singularValues.coeffRef(i) < precision) { m_nonzeroSingularValues--; m_singularValues.coeffRef(i)=RealScalar(0);}*/ \
+  m_isInitialized = true; \
+  return *this; \
+}
+
+EIGEN_LAPACKE_SVD(double,   double,                double, d, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SVD(float,    float,                 float , s, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SVD(dcomplex, lapack_complex_double, double, z, ColMajor, LAPACK_COL_MAJOR)
+EIGEN_LAPACKE_SVD(scomplex, lapack_complex_float,  float , c, ColMajor, LAPACK_COL_MAJOR)
+
+EIGEN_LAPACKE_SVD(double,   double,                double, d, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SVD(float,    float,                 float , s, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SVD(dcomplex, lapack_complex_double, double, z, RowMajor, LAPACK_ROW_MAJOR)
+EIGEN_LAPACKE_SVD(scomplex, lapack_complex_float,  float , c, RowMajor, LAPACK_ROW_MAJOR)
+
+} // end namespace Eigen
+
+#endif // EIGEN_JACOBISVD_LAPACKE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SVD/SVDBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/SVD/SVDBase.h
new file mode 100644
index 00000000..bc7ab88b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SVD/SVDBase.h
@@ -0,0 +1,376 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// Copyright (C) 2013 Gauthier Brun <brun.gauthier@gmail.com>
+// Copyright (C) 2013 Nicolas Carre <nicolas.carre@ensimag.fr>
+// Copyright (C) 2013 Jean Ceccato <jean.ceccato@ensimag.fr>
+// Copyright (C) 2013 Pierre Zoppitelli <pierre.zoppitelli@ensimag.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SVDBASE_H
+#define EIGEN_SVDBASE_H
+
+namespace Eigen {
+
+namespace internal {
+template<typename Derived> struct traits<SVDBase<Derived> >
+ : traits<Derived>
+{
+  typedef MatrixXpr XprKind;
+  typedef SolverStorage StorageKind;
+  typedef int StorageIndex;
+  enum { Flags = 0 };
+};
+}
+
+/** \ingroup SVD_Module
+ *
+ *
+ * \class SVDBase
+ *
+ * \brief Base class of SVD algorithms
+ *
+ * \tparam Derived the type of the actual SVD decomposition
+ *
+ * SVD decomposition consists in decomposing any n-by-p matrix \a A as a product
+ *   \f[ A = U S V^* \f]
+ * where \a U is a n-by-n unitary, \a V is a p-by-p unitary, and \a S is a n-by-p real positive matrix which is zero outside of its main diagonal;
+ * the diagonal entries of S are known as the \em singular \em values of \a A and the columns of \a U and \a V are known as the left
+ * and right \em singular \em vectors of \a A respectively.
+ *
+ * Singular values are always sorted in decreasing order.
+ *
+ * 
+ * You can ask for only \em thin \a U or \a V to be computed, meaning the following. In case of a rectangular n-by-p matrix, letting \a m be the
+ * smaller value among \a n and \a p, there are only \a m singular vectors; the remaining columns of \a U and \a V do not correspond to actual
+ * singular vectors. Asking for \em thin \a U or \a V means asking for only their \a m first columns to be formed. So \a U is then a n-by-m matrix,
+ * and \a V is then a p-by-m matrix. Notice that thin \a U and \a V are all you need for (least squares) solving.
+ * 
+ * The status of the computation can be retrived using the \a info() method. Unless \a info() returns \a Success, the results should be not
+ * considered well defined.
+ *  
+ * If the input matrix has inf or nan coefficients, the result of the computation is undefined, and \a info() will return \a InvalidInput, but the computation is guaranteed to
+ * terminate in finite (and reasonable) time.
+ * \sa class BDCSVD, class JacobiSVD
+ */
+template<typename Derived> class SVDBase
+ : public SolverBase<SVDBase<Derived> >
+{
+public: 
+   
+  template<typename Derived_>
+  friend struct internal::solve_assertion;
+
+  typedef typename internal::traits<Derived>::MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+  typedef typename Eigen::internal::traits<SVDBase>::StorageIndex StorageIndex;
+  typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime),
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime,MaxColsAtCompileTime),
+    MatrixOptions = MatrixType::Options
+  };
+
+  typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, MatrixOptions, MaxRowsAtCompileTime, MaxRowsAtCompileTime> MatrixUType;
+  typedef Matrix<Scalar, ColsAtCompileTime, ColsAtCompileTime, MatrixOptions, MaxColsAtCompileTime, MaxColsAtCompileTime> MatrixVType;
+  typedef typename internal::plain_diag_type<MatrixType, RealScalar>::type SingularValuesType;
+  
+  Derived& derived() { return *static_cast<Derived*>(this); }
+  const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+  /** \returns the \a U matrix.
+   *
+   * For the SVD decomposition of a n-by-p matrix, letting \a m be the minimum of \a n and \a p,
+   * the U matrix is n-by-n if you asked for \link Eigen::ComputeFullU ComputeFullU \endlink, and is n-by-m if you asked for \link Eigen::ComputeThinU ComputeThinU \endlink.
+   *
+   * The \a m first columns of \a U are the left singular vectors of the matrix being decomposed.
+   *
+   * This method asserts that you asked for \a U to be computed.
+   */
+  const MatrixUType& matrixU() const
+  {
+    _check_compute_assertions();
+    eigen_assert(computeU() && "This SVD decomposition didn't compute U. Did you ask for it?");
+    return m_matrixU;
+  }
+
+  /** \returns the \a V matrix.
+   *
+   * For the SVD decomposition of a n-by-p matrix, letting \a m be the minimum of \a n and \a p,
+   * the V matrix is p-by-p if you asked for \link Eigen::ComputeFullV ComputeFullV \endlink, and is p-by-m if you asked for \link Eigen::ComputeThinV ComputeThinV \endlink.
+   *
+   * The \a m first columns of \a V are the right singular vectors of the matrix being decomposed.
+   *
+   * This method asserts that you asked for \a V to be computed.
+   */
+  const MatrixVType& matrixV() const
+  {
+    _check_compute_assertions();
+    eigen_assert(computeV() && "This SVD decomposition didn't compute V. Did you ask for it?");
+    return m_matrixV;
+  }
+
+  /** \returns the vector of singular values.
+   *
+   * For the SVD decomposition of a n-by-p matrix, letting \a m be the minimum of \a n and \a p, the
+   * returned vector has size \a m.  Singular values are always sorted in decreasing order.
+   */
+  const SingularValuesType& singularValues() const
+  {
+    _check_compute_assertions();
+    return m_singularValues;
+  }
+
+  /** \returns the number of singular values that are not exactly 0 */
+  Index nonzeroSingularValues() const
+  {
+    _check_compute_assertions();
+    return m_nonzeroSingularValues;
+  }
+  
+  /** \returns the rank of the matrix of which \c *this is the SVD.
+    *
+    * \note This method has to determine which singular values should be considered nonzero.
+    *       For that, it uses the threshold value that you can control by calling
+    *       setThreshold(const RealScalar&).
+    */
+  inline Index rank() const
+  {
+    using std::abs;
+    _check_compute_assertions();
+    if(m_singularValues.size()==0) return 0;
+    RealScalar premultiplied_threshold = numext::maxi<RealScalar>(m_singularValues.coeff(0) * threshold(), (std::numeric_limits<RealScalar>::min)());
+    Index i = m_nonzeroSingularValues-1;
+    while(i>=0 && m_singularValues.coeff(i) < premultiplied_threshold) --i;
+    return i+1;
+  }
+  
+  /** Allows to prescribe a threshold to be used by certain methods, such as rank() and solve(),
+    * which need to determine when singular values are to be considered nonzero.
+    * This is not used for the SVD decomposition itself.
+    *
+    * When it needs to get the threshold value, Eigen calls threshold().
+    * The default is \c NumTraits<Scalar>::epsilon()
+    *
+    * \param threshold The new value to use as the threshold.
+    *
+    * A singular value will be considered nonzero if its value is strictly greater than
+    *  \f$ \vert singular value \vert \leqslant threshold \times \vert max singular value \vert \f$.
+    *
+    * If you want to come back to the default behavior, call setThreshold(Default_t)
+    */
+  Derived& setThreshold(const RealScalar& threshold)
+  {
+    m_usePrescribedThreshold = true;
+    m_prescribedThreshold = threshold;
+    return derived();
+  }
+
+  /** Allows to come back to the default behavior, letting Eigen use its default formula for
+    * determining the threshold.
+    *
+    * You should pass the special object Eigen::Default as parameter here.
+    * \code svd.setThreshold(Eigen::Default); \endcode
+    *
+    * See the documentation of setThreshold(const RealScalar&).
+    */
+  Derived& setThreshold(Default_t)
+  {
+    m_usePrescribedThreshold = false;
+    return derived();
+  }
+
+  /** Returns the threshold that will be used by certain methods such as rank().
+    *
+    * See the documentation of setThreshold(const RealScalar&).
+    */
+  RealScalar threshold() const
+  {
+    eigen_assert(m_isInitialized || m_usePrescribedThreshold);
+    // this temporary is needed to workaround a MSVC issue
+    Index diagSize = (std::max<Index>)(1,m_diagSize);
+    return m_usePrescribedThreshold ? m_prescribedThreshold
+                                    : RealScalar(diagSize)*NumTraits<Scalar>::epsilon();
+  }
+
+  /** \returns true if \a U (full or thin) is asked for in this SVD decomposition */
+  inline bool computeU() const { return m_computeFullU || m_computeThinU; }
+  /** \returns true if \a V (full or thin) is asked for in this SVD decomposition */
+  inline bool computeV() const { return m_computeFullV || m_computeThinV; }
+
+  inline Index rows() const { return m_rows; }
+  inline Index cols() const { return m_cols; }
+  
+  #ifdef EIGEN_PARSED_BY_DOXYGEN
+  /** \returns a (least squares) solution of \f$ A x = b \f$ using the current SVD decomposition of A.
+    *
+    * \param b the right-hand-side of the equation to solve.
+    *
+    * \note Solving requires both U and V to be computed. Thin U and V are enough, there is no need for full U or V.
+    *
+    * \note SVD solving is implicitly least-squares. Thus, this method serves both purposes of exact solving and least-squares solving.
+    * In other words, the returned solution is guaranteed to minimize the Euclidean norm \f$ \Vert A x - b \Vert \f$.
+    */
+  template<typename Rhs>
+  inline const Solve<Derived, Rhs>
+  solve(const MatrixBase<Rhs>& b) const;
+  #endif
+
+
+  /** \brief Reports whether previous computation was successful.
+   *
+   * \returns \c Success if computation was successful.
+   */
+  EIGEN_DEVICE_FUNC
+  ComputationInfo info() const
+  {
+    eigen_assert(m_isInitialized && "SVD is not initialized.");
+    return m_info;
+  }
+
+  #ifndef EIGEN_PARSED_BY_DOXYGEN
+  template<typename RhsType, typename DstType>
+  void _solve_impl(const RhsType &rhs, DstType &dst) const;
+
+  template<bool Conjugate, typename RhsType, typename DstType>
+  void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
+  #endif
+
+protected:
+
+  static void check_template_parameters()
+  {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
+  }
+
+  void _check_compute_assertions() const {
+    eigen_assert(m_isInitialized && "SVD is not initialized.");
+  }
+
+  template<bool Transpose_, typename Rhs>
+  void _check_solve_assertion(const Rhs& b) const {
+      EIGEN_ONLY_USED_FOR_DEBUG(b);
+      _check_compute_assertions();
+      eigen_assert(computeU() && computeV() && "SVDBase::solve(): Both unitaries U and V are required to be computed (thin unitaries suffice).");
+      eigen_assert((Transpose_?cols():rows())==b.rows() && "SVDBase::solve(): invalid number of rows of the right hand side matrix b");
+  }
+
+  // return true if already allocated
+  bool allocate(Index rows, Index cols, unsigned int computationOptions) ;
+
+  MatrixUType m_matrixU;
+  MatrixVType m_matrixV;
+  SingularValuesType m_singularValues;
+  ComputationInfo m_info;
+  bool m_isInitialized, m_isAllocated, m_usePrescribedThreshold;
+  bool m_computeFullU, m_computeThinU;
+  bool m_computeFullV, m_computeThinV;
+  unsigned int m_computationOptions;
+  Index m_nonzeroSingularValues, m_rows, m_cols, m_diagSize;
+  RealScalar m_prescribedThreshold;
+
+  /** \brief Default Constructor.
+   *
+   * Default constructor of SVDBase
+   */
+  SVDBase()
+    : m_info(Success),
+      m_isInitialized(false),
+      m_isAllocated(false),
+      m_usePrescribedThreshold(false),
+      m_computeFullU(false),
+      m_computeThinU(false),
+      m_computeFullV(false),
+      m_computeThinV(false),
+      m_computationOptions(0),
+      m_rows(-1), m_cols(-1), m_diagSize(0)
+  {
+    check_template_parameters();
+  }
+
+
+};
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename Derived>
+template<typename RhsType, typename DstType>
+void SVDBase<Derived>::_solve_impl(const RhsType &rhs, DstType &dst) const
+{
+  // A = U S V^*
+  // So A^{-1} = V S^{-1} U^*
+
+  Matrix<typename RhsType::Scalar, Dynamic, RhsType::ColsAtCompileTime, 0, MatrixType::MaxRowsAtCompileTime, RhsType::MaxColsAtCompileTime> tmp;
+  Index l_rank = rank();
+  tmp.noalias() =  m_matrixU.leftCols(l_rank).adjoint() * rhs;
+  tmp = m_singularValues.head(l_rank).asDiagonal().inverse() * tmp;
+  dst = m_matrixV.leftCols(l_rank) * tmp;
+}
+
+template<typename Derived>
+template<bool Conjugate, typename RhsType, typename DstType>
+void SVDBase<Derived>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
+{
+  // A = U S V^*
+  // So  A^{-*} = U S^{-1} V^*
+  // And A^{-T} = U_conj S^{-1} V^T
+  Matrix<typename RhsType::Scalar, Dynamic, RhsType::ColsAtCompileTime, 0, MatrixType::MaxRowsAtCompileTime, RhsType::MaxColsAtCompileTime> tmp;
+  Index l_rank = rank();
+
+  tmp.noalias() =  m_matrixV.leftCols(l_rank).transpose().template conjugateIf<Conjugate>() * rhs;
+  tmp = m_singularValues.head(l_rank).asDiagonal().inverse() * tmp;
+  dst = m_matrixU.template conjugateIf<!Conjugate>().leftCols(l_rank) * tmp;
+}
+#endif
+
+template<typename MatrixType>
+bool SVDBase<MatrixType>::allocate(Index rows, Index cols, unsigned int computationOptions)
+{
+  eigen_assert(rows >= 0 && cols >= 0);
+
+  if (m_isAllocated &&
+      rows == m_rows &&
+      cols == m_cols &&
+      computationOptions == m_computationOptions)
+  {
+    return true;
+  }
+
+  m_rows = rows;
+  m_cols = cols;
+  m_info = Success;
+  m_isInitialized = false;
+  m_isAllocated = true;
+  m_computationOptions = computationOptions;
+  m_computeFullU = (computationOptions & ComputeFullU) != 0;
+  m_computeThinU = (computationOptions & ComputeThinU) != 0;
+  m_computeFullV = (computationOptions & ComputeFullV) != 0;
+  m_computeThinV = (computationOptions & ComputeThinV) != 0;
+  eigen_assert(!(m_computeFullU && m_computeThinU) && "SVDBase: you can't ask for both full and thin U");
+  eigen_assert(!(m_computeFullV && m_computeThinV) && "SVDBase: you can't ask for both full and thin V");
+  eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) &&
+	       "SVDBase: thin U and V are only available when your matrix has a dynamic number of columns.");
+
+  m_diagSize = (std::min)(m_rows, m_cols);
+  m_singularValues.resize(m_diagSize);
+  if(RowsAtCompileTime==Dynamic)
+    m_matrixU.resize(m_rows, m_computeFullU ? m_rows : m_computeThinU ? m_diagSize : 0);
+  if(ColsAtCompileTime==Dynamic)
+    m_matrixV.resize(m_cols, m_computeFullV ? m_cols : m_computeThinV ? m_diagSize : 0);
+
+  return false;
+}
+
+}// end namespace
+
+#endif // EIGEN_SVDBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SVD/UpperBidiagonalization.h b/C++/yolo_bytetrack_old/include/Eigen/src/SVD/UpperBidiagonalization.h
new file mode 100644
index 00000000..997defc4
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SVD/UpperBidiagonalization.h
@@ -0,0 +1,414 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2013-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BIDIAGONALIZATION_H
+#define EIGEN_BIDIAGONALIZATION_H
+
+namespace Eigen { 
+
+namespace internal {
+// UpperBidiagonalization will probably be replaced by a Bidiagonalization class, don't want to make it stable API.
+// At the same time, it's useful to keep for now as it's about the only thing that is testing the BandMatrix class.
+
+template<typename _MatrixType> class UpperBidiagonalization
+{
+  public:
+
+    typedef _MatrixType MatrixType;
+    enum {
+      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      ColsAtCompileTimeMinusOne = internal::decrement_size<ColsAtCompileTime>::ret
+    };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
+    typedef Matrix<Scalar, 1, ColsAtCompileTime> RowVectorType;
+    typedef Matrix<Scalar, RowsAtCompileTime, 1> ColVectorType;
+    typedef BandMatrix<RealScalar, ColsAtCompileTime, ColsAtCompileTime, 1, 0, RowMajor> BidiagonalType;
+    typedef Matrix<Scalar, ColsAtCompileTime, 1> DiagVectorType;
+    typedef Matrix<Scalar, ColsAtCompileTimeMinusOne, 1> SuperDiagVectorType;
+    typedef HouseholderSequence<
+              const MatrixType,
+              const typename internal::remove_all<typename Diagonal<const MatrixType,0>::ConjugateReturnType>::type
+            > HouseholderUSequenceType;
+    typedef HouseholderSequence<
+              const typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type,
+              Diagonal<const MatrixType,1>,
+              OnTheRight
+            > HouseholderVSequenceType;
+    
+    /**
+    * \brief Default Constructor.
+    *
+    * The default constructor is useful in cases in which the user intends to
+    * perform decompositions via Bidiagonalization::compute(const MatrixType&).
+    */
+    UpperBidiagonalization() : m_householder(), m_bidiagonal(), m_isInitialized(false) {}
+
+    explicit UpperBidiagonalization(const MatrixType& matrix)
+      : m_householder(matrix.rows(), matrix.cols()),
+        m_bidiagonal(matrix.cols(), matrix.cols()),
+        m_isInitialized(false)
+    {
+      compute(matrix);
+    }
+    
+    UpperBidiagonalization& compute(const MatrixType& matrix);
+    UpperBidiagonalization& computeUnblocked(const MatrixType& matrix);
+    
+    const MatrixType& householder() const { return m_householder; }
+    const BidiagonalType& bidiagonal() const { return m_bidiagonal; }
+    
+    const HouseholderUSequenceType householderU() const
+    {
+      eigen_assert(m_isInitialized && "UpperBidiagonalization is not initialized.");
+      return HouseholderUSequenceType(m_householder, m_householder.diagonal().conjugate());
+    }
+
+    const HouseholderVSequenceType householderV() // const here gives nasty errors and i'm lazy
+    {
+      eigen_assert(m_isInitialized && "UpperBidiagonalization is not initialized.");
+      return HouseholderVSequenceType(m_householder.conjugate(), m_householder.const_derived().template diagonal<1>())
+             .setLength(m_householder.cols()-1)
+             .setShift(1);
+    }
+    
+  protected:
+    MatrixType m_householder;
+    BidiagonalType m_bidiagonal;
+    bool m_isInitialized;
+};
+
+// Standard upper bidiagonalization without fancy optimizations
+// This version should be faster for small matrix size
+template<typename MatrixType>
+void upperbidiagonalization_inplace_unblocked(MatrixType& mat,
+                                              typename MatrixType::RealScalar *diagonal,
+                                              typename MatrixType::RealScalar *upper_diagonal,
+                                              typename MatrixType::Scalar* tempData = 0)
+{
+  typedef typename MatrixType::Scalar Scalar;
+
+  Index rows = mat.rows();
+  Index cols = mat.cols();
+
+  typedef Matrix<Scalar,Dynamic,1,ColMajor,MatrixType::MaxRowsAtCompileTime,1> TempType;
+  TempType tempVector;
+  if(tempData==0)
+  {
+    tempVector.resize(rows);
+    tempData = tempVector.data();
+  }
+
+  for (Index k = 0; /* breaks at k==cols-1 below */ ; ++k)
+  {
+    Index remainingRows = rows - k;
+    Index remainingCols = cols - k - 1;
+
+    // construct left householder transform in-place in A
+    mat.col(k).tail(remainingRows)
+       .makeHouseholderInPlace(mat.coeffRef(k,k), diagonal[k]);
+    // apply householder transform to remaining part of A on the left
+    mat.bottomRightCorner(remainingRows, remainingCols)
+       .applyHouseholderOnTheLeft(mat.col(k).tail(remainingRows-1), mat.coeff(k,k), tempData);
+
+    if(k == cols-1) break;
+
+    // construct right householder transform in-place in mat
+    mat.row(k).tail(remainingCols)
+       .makeHouseholderInPlace(mat.coeffRef(k,k+1), upper_diagonal[k]);
+    // apply householder transform to remaining part of mat on the left
+    mat.bottomRightCorner(remainingRows-1, remainingCols)
+       .applyHouseholderOnTheRight(mat.row(k).tail(remainingCols-1).adjoint(), mat.coeff(k,k+1), tempData);
+  }
+}
+
+/** \internal
+  * Helper routine for the block reduction to upper bidiagonal form.
+  *
+  * Let's partition the matrix A:
+  * 
+  *      | A00 A01 |
+  *  A = |         |
+  *      | A10 A11 |
+  *
+  * This function reduces to bidiagonal form the left \c rows x \a blockSize vertical panel [A00/A10]
+  * and the \a blockSize x \c cols horizontal panel [A00 A01] of the matrix \a A. The bottom-right block A11
+  * is updated using matrix-matrix products:
+  *   A22 -= V * Y^T - X * U^T
+  * where V and U contains the left and right Householder vectors. U and V are stored in A10, and A01
+  * respectively, and the update matrices X and Y are computed during the reduction.
+  * 
+  */
+template<typename MatrixType>
+void upperbidiagonalization_blocked_helper(MatrixType& A,
+                                           typename MatrixType::RealScalar *diagonal,
+                                           typename MatrixType::RealScalar *upper_diagonal,
+                                           Index bs,
+                                           Ref<Matrix<typename MatrixType::Scalar, Dynamic, Dynamic,
+                                                      traits<MatrixType>::Flags & RowMajorBit> > X,
+                                           Ref<Matrix<typename MatrixType::Scalar, Dynamic, Dynamic,
+                                                      traits<MatrixType>::Flags & RowMajorBit> > Y)
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename NumTraits<RealScalar>::Literal Literal;
+  enum { StorageOrder = traits<MatrixType>::Flags & RowMajorBit };
+  typedef InnerStride<int(StorageOrder) == int(ColMajor) ? 1 : Dynamic> ColInnerStride;
+  typedef InnerStride<int(StorageOrder) == int(ColMajor) ? Dynamic : 1> RowInnerStride;
+  typedef Ref<Matrix<Scalar, Dynamic, 1>, 0, ColInnerStride>    SubColumnType;
+  typedef Ref<Matrix<Scalar, 1, Dynamic>, 0, RowInnerStride>    SubRowType;
+  typedef Ref<Matrix<Scalar, Dynamic, Dynamic, StorageOrder > > SubMatType;
+  
+  Index brows = A.rows();
+  Index bcols = A.cols();
+
+  Scalar tau_u, tau_u_prev(0), tau_v;
+
+  for(Index k = 0; k < bs; ++k)
+  {
+    Index remainingRows = brows - k;
+    Index remainingCols = bcols - k - 1;
+
+    SubMatType X_k1( X.block(k,0, remainingRows,k) );
+    SubMatType V_k1( A.block(k,0, remainingRows,k) );
+
+    // 1 - update the k-th column of A
+    SubColumnType v_k = A.col(k).tail(remainingRows);
+          v_k -= V_k1 * Y.row(k).head(k).adjoint();
+    if(k) v_k -= X_k1 * A.col(k).head(k);
+    
+    // 2 - construct left Householder transform in-place
+    v_k.makeHouseholderInPlace(tau_v, diagonal[k]);
+       
+    if(k+1<bcols)
+    {
+      SubMatType Y_k  ( Y.block(k+1,0, remainingCols, k+1) );
+      SubMatType U_k1 ( A.block(0,k+1, k,remainingCols) );
+      
+      // this eases the application of Householder transforAions
+      // A(k,k) will store tau_v later
+      A(k,k) = Scalar(1);
+
+      // 3 - Compute y_k^T = tau_v * ( A^T*v_k - Y_k-1*V_k-1^T*v_k - U_k-1*X_k-1^T*v_k )
+      {
+        SubColumnType y_k( Y.col(k).tail(remainingCols) );
+        
+        // let's use the beginning of column k of Y as a temporary vector
+        SubColumnType tmp( Y.col(k).head(k) );
+        y_k.noalias()  = A.block(k,k+1, remainingRows,remainingCols).adjoint() * v_k; // bottleneck
+        tmp.noalias()  = V_k1.adjoint()  * v_k;
+        y_k.noalias() -= Y_k.leftCols(k) * tmp;
+        tmp.noalias()  = X_k1.adjoint()  * v_k;
+        y_k.noalias() -= U_k1.adjoint()  * tmp;
+        y_k *= numext::conj(tau_v);
+      }
+
+      // 4 - update k-th row of A (it will become u_k)
+      SubRowType u_k( A.row(k).tail(remainingCols) );
+      u_k = u_k.conjugate();
+      {
+        u_k -= Y_k * A.row(k).head(k+1).adjoint();
+        if(k) u_k -= U_k1.adjoint() * X.row(k).head(k).adjoint();
+      }
+
+      // 5 - construct right Householder transform in-place
+      u_k.makeHouseholderInPlace(tau_u, upper_diagonal[k]);
+
+      // this eases the application of Householder transformations
+      // A(k,k+1) will store tau_u later
+      A(k,k+1) = Scalar(1);
+
+      // 6 - Compute x_k = tau_u * ( A*u_k - X_k-1*U_k-1^T*u_k - V_k*Y_k^T*u_k )
+      {
+        SubColumnType x_k ( X.col(k).tail(remainingRows-1) );
+        
+        // let's use the beginning of column k of X as a temporary vectors
+        // note that tmp0 and tmp1 overlaps
+        SubColumnType tmp0 ( X.col(k).head(k) ),
+                      tmp1 ( X.col(k).head(k+1) );
+                    
+        x_k.noalias()   = A.block(k+1,k+1, remainingRows-1,remainingCols) * u_k.transpose(); // bottleneck
+        tmp0.noalias()  = U_k1 * u_k.transpose();
+        x_k.noalias()  -= X_k1.bottomRows(remainingRows-1) * tmp0;
+        tmp1.noalias()  = Y_k.adjoint() * u_k.transpose();
+        x_k.noalias()  -= A.block(k+1,0, remainingRows-1,k+1) * tmp1;
+        x_k *= numext::conj(tau_u);
+        tau_u = numext::conj(tau_u);
+        u_k = u_k.conjugate();
+      }
+
+      if(k>0) A.coeffRef(k-1,k) = tau_u_prev;
+      tau_u_prev = tau_u;
+    }
+    else
+      A.coeffRef(k-1,k) = tau_u_prev;
+
+    A.coeffRef(k,k) = tau_v;
+  }
+  
+  if(bs<bcols)
+    A.coeffRef(bs-1,bs) = tau_u_prev;
+
+  // update A22
+  if(bcols>bs && brows>bs)
+  {
+    SubMatType A11( A.bottomRightCorner(brows-bs,bcols-bs) );
+    SubMatType A10( A.block(bs,0, brows-bs,bs) );
+    SubMatType A01( A.block(0,bs, bs,bcols-bs) );
+    Scalar tmp = A01(bs-1,0);
+    A01(bs-1,0) = Literal(1);
+    A11.noalias() -= A10 * Y.topLeftCorner(bcols,bs).bottomRows(bcols-bs).adjoint();
+    A11.noalias() -= X.topLeftCorner(brows,bs).bottomRows(brows-bs) * A01;
+    A01(bs-1,0) = tmp;
+  }
+}
+
+/** \internal
+  *
+  * Implementation of a block-bidiagonal reduction.
+  * It is based on the following paper:
+  *   The Design of a Parallel Dense Linear Algebra Software Library: Reduction to Hessenberg, Tridiagonal, and Bidiagonal Form.
+  *   by Jaeyoung Choi, Jack J. Dongarra, David W. Walker. (1995)
+  *   section 3.3
+  */
+template<typename MatrixType, typename BidiagType>
+void upperbidiagonalization_inplace_blocked(MatrixType& A, BidiagType& bidiagonal,
+                                            Index maxBlockSize=32,
+                                            typename MatrixType::Scalar* /*tempData*/ = 0)
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Block<MatrixType,Dynamic,Dynamic> BlockType;
+
+  Index rows = A.rows();
+  Index cols = A.cols();
+  Index size = (std::min)(rows, cols);
+
+  // X and Y are work space
+  enum { StorageOrder = traits<MatrixType>::Flags & RowMajorBit };
+  Matrix<Scalar,
+         MatrixType::RowsAtCompileTime,
+         Dynamic,
+         StorageOrder,
+         MatrixType::MaxRowsAtCompileTime> X(rows,maxBlockSize);
+  Matrix<Scalar,
+         MatrixType::ColsAtCompileTime,
+         Dynamic,
+         StorageOrder,
+         MatrixType::MaxColsAtCompileTime> Y(cols,maxBlockSize);
+  Index blockSize = (std::min)(maxBlockSize,size);
+
+  Index k = 0;
+  for(k = 0; k < size; k += blockSize)
+  {
+    Index bs = (std::min)(size-k,blockSize);  // actual size of the block
+    Index brows = rows - k;                   // rows of the block
+    Index bcols = cols - k;                   // columns of the block
+
+    // partition the matrix A:
+    // 
+    //      | A00 A01 A02 |
+    //      |             |
+    // A  = | A10 A11 A12 |
+    //      |             |
+    //      | A20 A21 A22 |
+    //
+    // where A11 is a bs x bs diagonal block,
+    // and let:
+    //      | A11 A12 |
+    //  B = |         |
+    //      | A21 A22 |
+
+    BlockType B = A.block(k,k,brows,bcols);
+    
+    // This stage performs the bidiagonalization of A11, A21, A12, and updating of A22.
+    // Finally, the algorithm continue on the updated A22.
+    //
+    // However, if B is too small, or A22 empty, then let's use an unblocked strategy
+    if(k+bs==cols || bcols<48) // somewhat arbitrary threshold
+    {
+      upperbidiagonalization_inplace_unblocked(B,
+                                               &(bidiagonal.template diagonal<0>().coeffRef(k)),
+                                               &(bidiagonal.template diagonal<1>().coeffRef(k)),
+                                               X.data()
+                                              );
+      break; // We're done
+    }
+    else
+    {
+      upperbidiagonalization_blocked_helper<BlockType>( B,
+                                                        &(bidiagonal.template diagonal<0>().coeffRef(k)),
+                                                        &(bidiagonal.template diagonal<1>().coeffRef(k)),
+                                                        bs,
+                                                        X.topLeftCorner(brows,bs),
+                                                        Y.topLeftCorner(bcols,bs)
+                                                      );
+    }
+  }
+}
+
+template<typename _MatrixType>
+UpperBidiagonalization<_MatrixType>& UpperBidiagonalization<_MatrixType>::computeUnblocked(const _MatrixType& matrix)
+{
+  Index rows = matrix.rows();
+  Index cols = matrix.cols();
+  EIGEN_ONLY_USED_FOR_DEBUG(cols);
+
+  eigen_assert(rows >= cols && "UpperBidiagonalization is only for Arices satisfying rows>=cols.");
+
+  m_householder = matrix;
+
+  ColVectorType temp(rows);
+
+  upperbidiagonalization_inplace_unblocked(m_householder,
+                                           &(m_bidiagonal.template diagonal<0>().coeffRef(0)),
+                                           &(m_bidiagonal.template diagonal<1>().coeffRef(0)),
+                                           temp.data());
+
+  m_isInitialized = true;
+  return *this;
+}
+
+template<typename _MatrixType>
+UpperBidiagonalization<_MatrixType>& UpperBidiagonalization<_MatrixType>::compute(const _MatrixType& matrix)
+{
+  Index rows = matrix.rows();
+  Index cols = matrix.cols();
+  EIGEN_ONLY_USED_FOR_DEBUG(rows);
+  EIGEN_ONLY_USED_FOR_DEBUG(cols);
+
+  eigen_assert(rows >= cols && "UpperBidiagonalization is only for Arices satisfying rows>=cols.");
+
+  m_householder = matrix;
+  upperbidiagonalization_inplace_blocked(m_householder, m_bidiagonal);
+            
+  m_isInitialized = true;
+  return *this;
+}
+
+#if 0
+/** \return the Householder QR decomposition of \c *this.
+  *
+  * \sa class Bidiagonalization
+  */
+template<typename Derived>
+const UpperBidiagonalization<typename MatrixBase<Derived>::PlainObject>
+MatrixBase<Derived>::bidiagonalization() const
+{
+  return UpperBidiagonalization<PlainObject>(eval());
+}
+#endif
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_BIDIAGONALIZATION_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCholesky/SimplicialCholesky.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCholesky/SimplicialCholesky.h
new file mode 100644
index 00000000..9f93e325
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCholesky/SimplicialCholesky.h
@@ -0,0 +1,697 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SIMPLICIAL_CHOLESKY_H
+#define EIGEN_SIMPLICIAL_CHOLESKY_H
+
+namespace Eigen { 
+
+enum SimplicialCholeskyMode {
+  SimplicialCholeskyLLT,
+  SimplicialCholeskyLDLT
+};
+
+namespace internal {
+  template<typename CholMatrixType, typename InputMatrixType>
+  struct simplicial_cholesky_grab_input {
+    typedef CholMatrixType const * ConstCholMatrixPtr;
+    static void run(const InputMatrixType& input, ConstCholMatrixPtr &pmat, CholMatrixType &tmp)
+    {
+      tmp = input;
+      pmat = &tmp;
+    }
+  };
+  
+  template<typename MatrixType>
+  struct simplicial_cholesky_grab_input<MatrixType,MatrixType> {
+    typedef MatrixType const * ConstMatrixPtr;
+    static void run(const MatrixType& input, ConstMatrixPtr &pmat, MatrixType &/*tmp*/)
+    {
+      pmat = &input;
+    }
+  };
+} // end namespace internal
+
+/** \ingroup SparseCholesky_Module
+  * \brief A base class for direct sparse Cholesky factorizations
+  *
+  * This is a base class for LL^T and LDL^T Cholesky factorizations of sparse matrices that are
+  * selfadjoint and positive definite. These factorizations allow for solving A.X = B where
+  * X and B can be either dense or sparse.
+  * 
+  * In order to reduce the fill-in, a symmetric permutation P is applied prior to the factorization
+  * such that the factorized matrix is P A P^-1.
+  *
+  * \tparam Derived the type of the derived class, that is the actual factorization type.
+  *
+  */
+template<typename Derived>
+class SimplicialCholeskyBase : public SparseSolverBase<Derived>
+{
+    typedef SparseSolverBase<Derived> Base;
+    using Base::m_isInitialized;
+    
+  public:
+    typedef typename internal::traits<Derived>::MatrixType MatrixType;
+    typedef typename internal::traits<Derived>::OrderingType OrderingType;
+    enum { UpLo = internal::traits<Derived>::UpLo };
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> CholMatrixType;
+    typedef CholMatrixType const * ConstCholMatrixPtr;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+    
+    using Base::derived;
+
+    /** Default constructor */
+    SimplicialCholeskyBase()
+      : m_info(Success),
+        m_factorizationIsOk(false),
+        m_analysisIsOk(false),
+        m_shiftOffset(0),
+        m_shiftScale(1)
+    {}
+
+    explicit SimplicialCholeskyBase(const MatrixType& matrix)
+      : m_info(Success),
+        m_factorizationIsOk(false),
+        m_analysisIsOk(false),
+        m_shiftOffset(0),
+        m_shiftScale(1)
+    {
+      derived().compute(matrix);
+    }
+
+    ~SimplicialCholeskyBase()
+    {
+    }
+
+    Derived& derived() { return *static_cast<Derived*>(this); }
+    const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    
+    inline Index cols() const { return m_matrix.cols(); }
+    inline Index rows() const { return m_matrix.rows(); }
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+    
+    /** \returns the permutation P
+      * \sa permutationPinv() */
+    const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& permutationP() const
+    { return m_P; }
+    
+    /** \returns the inverse P^-1 of the permutation P
+      * \sa permutationP() */
+    const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& permutationPinv() const
+    { return m_Pinv; }
+
+    /** Sets the shift parameters that will be used to adjust the diagonal coefficients during the numerical factorization.
+      *
+      * During the numerical factorization, the diagonal coefficients are transformed by the following linear model:\n
+      * \c d_ii = \a offset + \a scale * \c d_ii
+      *
+      * The default is the identity transformation with \a offset=0, and \a scale=1.
+      *
+      * \returns a reference to \c *this.
+      */
+    Derived& setShift(const RealScalar& offset, const RealScalar& scale = 1)
+    {
+      m_shiftOffset = offset;
+      m_shiftScale = scale;
+      return derived();
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal */
+    template<typename Stream>
+    void dumpMemory(Stream& s)
+    {
+      int total = 0;
+      s << "  L:        " << ((total+=(m_matrix.cols()+1) * sizeof(int) + m_matrix.nonZeros()*(sizeof(int)+sizeof(Scalar))) >> 20) << "Mb" << "\n";
+      s << "  diag:     " << ((total+=m_diag.size() * sizeof(Scalar)) >> 20) << "Mb" << "\n";
+      s << "  tree:     " << ((total+=m_parent.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  nonzeros: " << ((total+=m_nonZerosPerCol.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  perm:     " << ((total+=m_P.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  perm^-1:  " << ((total+=m_Pinv.size() * sizeof(int)) >> 20) << "Mb" << "\n";
+      s << "  TOTAL:    " << (total>> 20) << "Mb" << "\n";
+    }
+
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      eigen_assert(m_matrix.rows()==b.rows());
+
+      if(m_info!=Success)
+        return;
+
+      if(m_P.size()>0)
+        dest = m_P * b;
+      else
+        dest = b;
+
+      if(m_matrix.nonZeros()>0) // otherwise L==I
+        derived().matrixL().solveInPlace(dest);
+
+      if(m_diag.size()>0)
+        dest = m_diag.asDiagonal().inverse() * dest;
+
+      if (m_matrix.nonZeros()>0) // otherwise U==I
+        derived().matrixU().solveInPlace(dest);
+
+      if(m_P.size()>0)
+        dest = m_Pinv * dest;
+    }
+    
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const SparseMatrixBase<Rhs> &b, SparseMatrixBase<Dest> &dest) const
+    {
+      internal::solve_sparse_through_dense_panels(derived(), b, dest);
+    }
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+  protected:
+    
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    template<bool DoLDLT>
+    void compute(const MatrixType& matrix)
+    {
+      eigen_assert(matrix.rows()==matrix.cols());
+      Index size = matrix.cols();
+      CholMatrixType tmp(size,size);
+      ConstCholMatrixPtr pmat;
+      ordering(matrix, pmat, tmp);
+      analyzePattern_preordered(*pmat, DoLDLT);
+      factorize_preordered<DoLDLT>(*pmat);
+    }
+    
+    template<bool DoLDLT>
+    void factorize(const MatrixType& a)
+    {
+      eigen_assert(a.rows()==a.cols());
+      Index size = a.cols();
+      CholMatrixType tmp(size,size);
+      ConstCholMatrixPtr pmat;
+      
+      if(m_P.size() == 0 && (int(UpLo) & int(Upper)) == Upper)
+      {
+        // If there is no ordering, try to directly use the input matrix without any copy
+        internal::simplicial_cholesky_grab_input<CholMatrixType,MatrixType>::run(a, pmat, tmp);
+      }
+      else
+      {
+        tmp.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>().twistedBy(m_P);
+        pmat = &tmp;
+      }
+      
+      factorize_preordered<DoLDLT>(*pmat);
+    }
+
+    template<bool DoLDLT>
+    void factorize_preordered(const CholMatrixType& a);
+
+    void analyzePattern(const MatrixType& a, bool doLDLT)
+    {
+      eigen_assert(a.rows()==a.cols());
+      Index size = a.cols();
+      CholMatrixType tmp(size,size);
+      ConstCholMatrixPtr pmat;
+      ordering(a, pmat, tmp);
+      analyzePattern_preordered(*pmat,doLDLT);
+    }
+    void analyzePattern_preordered(const CholMatrixType& a, bool doLDLT);
+    
+    void ordering(const MatrixType& a, ConstCholMatrixPtr &pmat, CholMatrixType& ap);
+
+    /** keeps off-diagonal entries; drops diagonal entries */
+    struct keep_diag {
+      inline bool operator() (const Index& row, const Index& col, const Scalar&) const
+      {
+        return row!=col;
+      }
+    };
+
+    mutable ComputationInfo m_info;
+    bool m_factorizationIsOk;
+    bool m_analysisIsOk;
+    
+    CholMatrixType m_matrix;
+    VectorType m_diag;                                // the diagonal coefficients (LDLT mode)
+    VectorI m_parent;                                 // elimination tree
+    VectorI m_nonZerosPerCol;
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_P;     // the permutation
+    PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_Pinv;  // the inverse permutation
+
+    RealScalar m_shiftOffset;
+    RealScalar m_shiftScale;
+};
+
+template<typename _MatrixType, int _UpLo = Lower, typename _Ordering = AMDOrdering<typename _MatrixType::StorageIndex> > class SimplicialLLT;
+template<typename _MatrixType, int _UpLo = Lower, typename _Ordering = AMDOrdering<typename _MatrixType::StorageIndex> > class SimplicialLDLT;
+template<typename _MatrixType, int _UpLo = Lower, typename _Ordering = AMDOrdering<typename _MatrixType::StorageIndex> > class SimplicialCholesky;
+
+namespace internal {
+
+template<typename _MatrixType, int _UpLo, typename _Ordering> struct traits<SimplicialLLT<_MatrixType,_UpLo,_Ordering> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Ordering OrderingType;
+  enum { UpLo = _UpLo };
+  typedef typename MatrixType::Scalar                         Scalar;
+  typedef typename MatrixType::StorageIndex                   StorageIndex;
+  typedef SparseMatrix<Scalar, ColMajor, StorageIndex>        CholMatrixType;
+  typedef TriangularView<const CholMatrixType, Eigen::Lower>  MatrixL;
+  typedef TriangularView<const typename CholMatrixType::AdjointReturnType, Eigen::Upper>   MatrixU;
+  static inline MatrixL getL(const CholMatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const CholMatrixType& m) { return MatrixU(m.adjoint()); }
+};
+
+template<typename _MatrixType,int _UpLo, typename _Ordering> struct traits<SimplicialLDLT<_MatrixType,_UpLo,_Ordering> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Ordering OrderingType;
+  enum { UpLo = _UpLo };
+  typedef typename MatrixType::Scalar                             Scalar;
+  typedef typename MatrixType::StorageIndex                       StorageIndex;
+  typedef SparseMatrix<Scalar, ColMajor, StorageIndex>            CholMatrixType;
+  typedef TriangularView<const CholMatrixType, Eigen::UnitLower>  MatrixL;
+  typedef TriangularView<const typename CholMatrixType::AdjointReturnType, Eigen::UnitUpper> MatrixU;
+  static inline MatrixL getL(const CholMatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const CholMatrixType& m) { return MatrixU(m.adjoint()); }
+};
+
+template<typename _MatrixType, int _UpLo, typename _Ordering> struct traits<SimplicialCholesky<_MatrixType,_UpLo,_Ordering> >
+{
+  typedef _MatrixType MatrixType;
+  typedef _Ordering OrderingType;
+  enum { UpLo = _UpLo };
+};
+
+}
+
+/** \ingroup SparseCholesky_Module
+  * \class SimplicialLLT
+  * \brief A direct sparse LLT Cholesky factorizations
+  *
+  * This class provides a LL^T Cholesky factorizations of sparse matrices that are
+  * selfadjoint and positive definite. The factorization allows for solving A.X = B where
+  * X and B can be either dense or sparse.
+  * 
+  * In order to reduce the fill-in, a symmetric permutation P is applied prior to the factorization
+  * such that the factorized matrix is P A P^-1.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  * \tparam _Ordering The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa class SimplicialLDLT, class AMDOrdering, class NaturalOrdering
+  */
+template<typename _MatrixType, int _UpLo, typename _Ordering>
+    class SimplicialLLT : public SimplicialCholeskyBase<SimplicialLLT<_MatrixType,_UpLo,_Ordering> >
+{
+public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef SimplicialCholeskyBase<SimplicialLLT> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,Index> CholMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef internal::traits<SimplicialLLT> Traits;
+    typedef typename Traits::MatrixL  MatrixL;
+    typedef typename Traits::MatrixU  MatrixU;
+public:
+    /** Default constructor */
+    SimplicialLLT() : Base() {}
+    /** Constructs and performs the LLT factorization of \a matrix */
+    explicit SimplicialLLT(const MatrixType& matrix)
+        : Base(matrix) {}
+
+    /** \returns an expression of the factor L */
+    inline const MatrixL matrixL() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LLT not factorized");
+        return Traits::getL(Base::m_matrix);
+    }
+
+    /** \returns an expression of the factor U (= L^*) */
+    inline const MatrixU matrixU() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LLT not factorized");
+        return Traits::getU(Base::m_matrix);
+    }
+    
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    SimplicialLLT& compute(const MatrixType& matrix)
+    {
+      Base::template compute<false>(matrix);
+      return *this;
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& a)
+    {
+      Base::analyzePattern(a, false);
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& a)
+    {
+      Base::template factorize<false>(a);
+    }
+
+    /** \returns the determinant of the underlying matrix from the current factorization */
+    Scalar determinant() const
+    {
+      Scalar detL = Base::m_matrix.diagonal().prod();
+      return numext::abs2(detL);
+    }
+};
+
+/** \ingroup SparseCholesky_Module
+  * \class SimplicialLDLT
+  * \brief A direct sparse LDLT Cholesky factorizations without square root.
+  *
+  * This class provides a LDL^T Cholesky factorizations without square root of sparse matrices that are
+  * selfadjoint and positive definite. The factorization allows for solving A.X = B where
+  * X and B can be either dense or sparse.
+  * 
+  * In order to reduce the fill-in, a symmetric permutation P is applied prior to the factorization
+  * such that the factorized matrix is P A P^-1.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  * \tparam _UpLo the triangular part that will be used for the computations. It can be Lower
+  *               or Upper. Default is Lower.
+  * \tparam _Ordering The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa class SimplicialLLT, class AMDOrdering, class NaturalOrdering
+  */
+template<typename _MatrixType, int _UpLo, typename _Ordering>
+    class SimplicialLDLT : public SimplicialCholeskyBase<SimplicialLDLT<_MatrixType,_UpLo,_Ordering> >
+{
+public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef SimplicialCholeskyBase<SimplicialLDLT> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> CholMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef internal::traits<SimplicialLDLT> Traits;
+    typedef typename Traits::MatrixL  MatrixL;
+    typedef typename Traits::MatrixU  MatrixU;
+public:
+    /** Default constructor */
+    SimplicialLDLT() : Base() {}
+
+    /** Constructs and performs the LLT factorization of \a matrix */
+    explicit SimplicialLDLT(const MatrixType& matrix)
+        : Base(matrix) {}
+
+    /** \returns a vector expression of the diagonal D */
+    inline const VectorType vectorD() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LDLT not factorized");
+        return Base::m_diag;
+    }
+    /** \returns an expression of the factor L */
+    inline const MatrixL matrixL() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LDLT not factorized");
+        return Traits::getL(Base::m_matrix);
+    }
+
+    /** \returns an expression of the factor U (= L^*) */
+    inline const MatrixU matrixU() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial LDLT not factorized");
+        return Traits::getU(Base::m_matrix);
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    SimplicialLDLT& compute(const MatrixType& matrix)
+    {
+      Base::template compute<true>(matrix);
+      return *this;
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& a)
+    {
+      Base::analyzePattern(a, true);
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& a)
+    {
+      Base::template factorize<true>(a);
+    }
+
+    /** \returns the determinant of the underlying matrix from the current factorization */
+    Scalar determinant() const
+    {
+      return Base::m_diag.prod();
+    }
+};
+
+/** \deprecated use SimplicialLDLT or class SimplicialLLT
+  * \ingroup SparseCholesky_Module
+  * \class SimplicialCholesky
+  *
+  * \sa class SimplicialLDLT, class SimplicialLLT
+  */
+template<typename _MatrixType, int _UpLo, typename _Ordering>
+    class SimplicialCholesky : public SimplicialCholeskyBase<SimplicialCholesky<_MatrixType,_UpLo,_Ordering> >
+{
+public:
+    typedef _MatrixType MatrixType;
+    enum { UpLo = _UpLo };
+    typedef SimplicialCholeskyBase<SimplicialCholesky> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> CholMatrixType;
+    typedef Matrix<Scalar,Dynamic,1> VectorType;
+    typedef internal::traits<SimplicialCholesky> Traits;
+    typedef internal::traits<SimplicialLDLT<MatrixType,UpLo> > LDLTTraits;
+    typedef internal::traits<SimplicialLLT<MatrixType,UpLo>  > LLTTraits;
+  public:
+    SimplicialCholesky() : Base(), m_LDLT(true) {}
+
+    explicit SimplicialCholesky(const MatrixType& matrix)
+      : Base(), m_LDLT(true)
+    {
+      compute(matrix);
+    }
+
+    SimplicialCholesky& setMode(SimplicialCholeskyMode mode)
+    {
+      switch(mode)
+      {
+      case SimplicialCholeskyLLT:
+        m_LDLT = false;
+        break;
+      case SimplicialCholeskyLDLT:
+        m_LDLT = true;
+        break;
+      default:
+        break;
+      }
+
+      return *this;
+    }
+
+    inline const VectorType vectorD() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial Cholesky not factorized");
+        return Base::m_diag;
+    }
+    inline const CholMatrixType rawMatrix() const {
+        eigen_assert(Base::m_factorizationIsOk && "Simplicial Cholesky not factorized");
+        return Base::m_matrix;
+    }
+    
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    SimplicialCholesky& compute(const MatrixType& matrix)
+    {
+      if(m_LDLT)
+        Base::template compute<true>(matrix);
+      else
+        Base::template compute<false>(matrix);
+      return *this;
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& a)
+    {
+      Base::analyzePattern(a, m_LDLT);
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& a)
+    {
+      if(m_LDLT)
+        Base::template factorize<true>(a);
+      else
+        Base::template factorize<false>(a);
+    }
+
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(Base::m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
+      eigen_assert(Base::m_matrix.rows()==b.rows());
+
+      if(Base::m_info!=Success)
+        return;
+
+      if(Base::m_P.size()>0)
+        dest = Base::m_P * b;
+      else
+        dest = b;
+
+      if(Base::m_matrix.nonZeros()>0) // otherwise L==I
+      {
+        if(m_LDLT)
+          LDLTTraits::getL(Base::m_matrix).solveInPlace(dest);
+        else
+          LLTTraits::getL(Base::m_matrix).solveInPlace(dest);
+      }
+
+      if(Base::m_diag.size()>0)
+        dest = Base::m_diag.real().asDiagonal().inverse() * dest;
+
+      if (Base::m_matrix.nonZeros()>0) // otherwise I==I
+      {
+        if(m_LDLT)
+          LDLTTraits::getU(Base::m_matrix).solveInPlace(dest);
+        else
+          LLTTraits::getU(Base::m_matrix).solveInPlace(dest);
+      }
+
+      if(Base::m_P.size()>0)
+        dest = Base::m_Pinv * dest;
+    }
+    
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const SparseMatrixBase<Rhs> &b, SparseMatrixBase<Dest> &dest) const
+    {
+      internal::solve_sparse_through_dense_panels(*this, b, dest);
+    }
+    
+    Scalar determinant() const
+    {
+      if(m_LDLT)
+      {
+        return Base::m_diag.prod();
+      }
+      else
+      {
+        Scalar detL = Diagonal<const CholMatrixType>(Base::m_matrix).prod();
+        return numext::abs2(detL);
+      }
+    }
+    
+  protected:
+    bool m_LDLT;
+};
+
+template<typename Derived>
+void SimplicialCholeskyBase<Derived>::ordering(const MatrixType& a, ConstCholMatrixPtr &pmat, CholMatrixType& ap)
+{
+  eigen_assert(a.rows()==a.cols());
+  const Index size = a.rows();
+  pmat = &ap;
+  // Note that ordering methods compute the inverse permutation
+  if(!internal::is_same<OrderingType,NaturalOrdering<Index> >::value)
+  {
+    {
+      CholMatrixType C;
+      C = a.template selfadjointView<UpLo>();
+      
+      OrderingType ordering;
+      ordering(C,m_Pinv);
+    }
+
+    if(m_Pinv.size()>0) m_P = m_Pinv.inverse();
+    else                m_P.resize(0);
+    
+    ap.resize(size,size);
+    ap.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>().twistedBy(m_P);
+  }
+  else
+  {
+    m_Pinv.resize(0);
+    m_P.resize(0);
+    if(int(UpLo)==int(Lower) || MatrixType::IsRowMajor)
+    {
+      // we have to transpose the lower part to to the upper one
+      ap.resize(size,size);
+      ap.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>();
+    }
+    else
+      internal::simplicial_cholesky_grab_input<CholMatrixType,MatrixType>::run(a, pmat, ap);
+  }  
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SIMPLICIAL_CHOLESKY_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
new file mode 100644
index 00000000..72e1740c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
@@ -0,0 +1,174 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*
+NOTE: these functions have been adapted from the LDL library:
+
+LDL Copyright (c) 2005 by Timothy A. Davis.  All Rights Reserved.
+
+The author of LDL, Timothy A. Davis., has executed a license with Google LLC
+to permit distribution of this code and derivative works as part of Eigen under
+the Mozilla Public License v. 2.0, as stated at the top of this file.
+ */
+
+#ifndef EIGEN_SIMPLICIAL_CHOLESKY_IMPL_H
+#define EIGEN_SIMPLICIAL_CHOLESKY_IMPL_H
+
+namespace Eigen {
+
+template<typename Derived>
+void SimplicialCholeskyBase<Derived>::analyzePattern_preordered(const CholMatrixType& ap, bool doLDLT)
+{
+  const StorageIndex size = StorageIndex(ap.rows());
+  m_matrix.resize(size, size);
+  m_parent.resize(size);
+  m_nonZerosPerCol.resize(size);
+
+  ei_declare_aligned_stack_constructed_variable(StorageIndex, tags, size, 0);
+
+  for(StorageIndex k = 0; k < size; ++k)
+  {
+    /* L(k,:) pattern: all nodes reachable in etree from nz in A(0:k-1,k) */
+    m_parent[k] = -1;             /* parent of k is not yet known */
+    tags[k] = k;                  /* mark node k as visited */
+    m_nonZerosPerCol[k] = 0;      /* count of nonzeros in column k of L */
+    for(typename CholMatrixType::InnerIterator it(ap,k); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if(i < k)
+      {
+        /* follow path from i to root of etree, stop at flagged node */
+        for(; tags[i] != k; i = m_parent[i])
+        {
+          /* find parent of i if not yet determined */
+          if (m_parent[i] == -1)
+            m_parent[i] = k;
+          m_nonZerosPerCol[i]++;        /* L (k,i) is nonzero */
+          tags[i] = k;                  /* mark i as visited */
+        }
+      }
+    }
+  }
+
+  /* construct Lp index array from m_nonZerosPerCol column counts */
+  StorageIndex* Lp = m_matrix.outerIndexPtr();
+  Lp[0] = 0;
+  for(StorageIndex k = 0; k < size; ++k)
+    Lp[k+1] = Lp[k] + m_nonZerosPerCol[k] + (doLDLT ? 0 : 1);
+
+  m_matrix.resizeNonZeros(Lp[size]);
+
+  m_isInitialized     = true;
+  m_info              = Success;
+  m_analysisIsOk      = true;
+  m_factorizationIsOk = false;
+}
+
+
+template<typename Derived>
+template<bool DoLDLT>
+void SimplicialCholeskyBase<Derived>::factorize_preordered(const CholMatrixType& ap)
+{
+  using std::sqrt;
+
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  eigen_assert(ap.rows()==ap.cols());
+  eigen_assert(m_parent.size()==ap.rows());
+  eigen_assert(m_nonZerosPerCol.size()==ap.rows());
+
+  const StorageIndex size = StorageIndex(ap.rows());
+  const StorageIndex* Lp = m_matrix.outerIndexPtr();
+  StorageIndex* Li = m_matrix.innerIndexPtr();
+  Scalar* Lx = m_matrix.valuePtr();
+
+  ei_declare_aligned_stack_constructed_variable(Scalar, y, size, 0);
+  ei_declare_aligned_stack_constructed_variable(StorageIndex,  pattern, size, 0);
+  ei_declare_aligned_stack_constructed_variable(StorageIndex,  tags, size, 0);
+
+  bool ok = true;
+  m_diag.resize(DoLDLT ? size : 0);
+
+  for(StorageIndex k = 0; k < size; ++k)
+  {
+    // compute nonzero pattern of kth row of L, in topological order
+    y[k] = Scalar(0);                     // Y(0:k) is now all zero
+    StorageIndex top = size;               // stack for pattern is empty
+    tags[k] = k;                    // mark node k as visited
+    m_nonZerosPerCol[k] = 0;        // count of nonzeros in column k of L
+    for(typename CholMatrixType::InnerIterator it(ap,k); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if(i <= k)
+      {
+        y[i] += numext::conj(it.value());            /* scatter A(i,k) into Y (sum duplicates) */
+        Index len;
+        for(len = 0; tags[i] != k; i = m_parent[i])
+        {
+          pattern[len++] = i;     /* L(k,i) is nonzero */
+          tags[i] = k;            /* mark i as visited */
+        }
+        while(len > 0)
+          pattern[--top] = pattern[--len];
+      }
+    }
+
+    /* compute numerical values kth row of L (a sparse triangular solve) */
+
+    RealScalar d = numext::real(y[k]) * m_shiftScale + m_shiftOffset;    // get D(k,k), apply the shift function, and clear Y(k)
+    y[k] = Scalar(0);
+    for(; top < size; ++top)
+    {
+      Index i = pattern[top];       /* pattern[top:n-1] is pattern of L(:,k) */
+      Scalar yi = y[i];             /* get and clear Y(i) */
+      y[i] = Scalar(0);
+
+      /* the nonzero entry L(k,i) */
+      Scalar l_ki;
+      if(DoLDLT)
+        l_ki = yi / numext::real(m_diag[i]);
+      else
+        yi = l_ki = yi / Lx[Lp[i]];
+
+      Index p2 = Lp[i] + m_nonZerosPerCol[i];
+      Index p;
+      for(p = Lp[i] + (DoLDLT ? 0 : 1); p < p2; ++p)
+        y[Li[p]] -= numext::conj(Lx[p]) * yi;
+      d -= numext::real(l_ki * numext::conj(yi));
+      Li[p] = k;                          /* store L(k,i) in column form of L */
+      Lx[p] = l_ki;
+      ++m_nonZerosPerCol[i];              /* increment count of nonzeros in col i */
+    }
+    if(DoLDLT)
+    {
+      m_diag[k] = d;
+      if(d == RealScalar(0))
+      {
+        ok = false;                         /* failure, D(k,k) is zero */
+        break;
+      }
+    }
+    else
+    {
+      Index p = Lp[k] + m_nonZerosPerCol[k]++;
+      Li[p] = k ;                /* store L(k,k) = sqrt (d) in column k */
+      if(d <= RealScalar(0)) {
+        ok = false;              /* failure, matrix is not positive definite */
+        break;
+      }
+      Lx[p] = sqrt(d) ;
+    }
+  }
+
+  m_info = ok ? Success : NumericalIssue;
+  m_factorizationIsOk = true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SIMPLICIAL_CHOLESKY_IMPL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/AmbiVector.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/AmbiVector.h
new file mode 100644
index 00000000..2cb7747c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/AmbiVector.h
@@ -0,0 +1,378 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_AMBIVECTOR_H
+#define EIGEN_AMBIVECTOR_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal
+  * Hybrid sparse/dense vector class designed for intensive read-write operations.
+  *
+  * See BasicSparseLLT and SparseProduct for usage examples.
+  */
+template<typename _Scalar, typename _StorageIndex>
+class AmbiVector
+{
+  public:
+    typedef _Scalar Scalar;
+    typedef _StorageIndex StorageIndex;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    explicit AmbiVector(Index size)
+      : m_buffer(0), m_zero(0), m_size(0), m_end(0), m_allocatedSize(0), m_allocatedElements(0), m_mode(-1)
+    {
+      resize(size);
+    }
+
+    void init(double estimatedDensity);
+    void init(int mode);
+
+    Index nonZeros() const;
+
+    /** Specifies a sub-vector to work on */
+    void setBounds(Index start, Index end) { m_start = convert_index(start); m_end = convert_index(end); }
+
+    void setZero();
+
+    void restart();
+    Scalar& coeffRef(Index i);
+    Scalar& coeff(Index i);
+
+    class Iterator;
+
+    ~AmbiVector() { delete[] m_buffer; }
+
+    void resize(Index size)
+    {
+      if (m_allocatedSize < size)
+        reallocate(size);
+      m_size = convert_index(size);
+    }
+
+    StorageIndex size() const { return m_size; }
+
+  protected:
+    StorageIndex convert_index(Index idx)
+    {
+      return internal::convert_index<StorageIndex>(idx);
+    }
+
+    void reallocate(Index size)
+    {
+      // if the size of the matrix is not too large, let's allocate a bit more than needed such
+      // that we can handle dense vector even in sparse mode.
+      delete[] m_buffer;
+      if (size<1000)
+      {
+        Index allocSize = (size * sizeof(ListEl) + sizeof(Scalar) - 1)/sizeof(Scalar);
+        m_allocatedElements = convert_index((allocSize*sizeof(Scalar))/sizeof(ListEl));
+        m_buffer = new Scalar[allocSize];
+      }
+      else
+      {
+        m_allocatedElements = convert_index((size*sizeof(Scalar))/sizeof(ListEl));
+        m_buffer = new Scalar[size];
+      }
+      m_size = convert_index(size);
+      m_start = 0;
+      m_end = m_size;
+    }
+
+    void reallocateSparse()
+    {
+      Index copyElements = m_allocatedElements;
+      m_allocatedElements = (std::min)(StorageIndex(m_allocatedElements*1.5),m_size);
+      Index allocSize = m_allocatedElements * sizeof(ListEl);
+      allocSize = (allocSize + sizeof(Scalar) - 1)/sizeof(Scalar);
+      Scalar* newBuffer = new Scalar[allocSize];
+      std::memcpy(newBuffer,  m_buffer,  copyElements * sizeof(ListEl));
+      delete[] m_buffer;
+      m_buffer = newBuffer;
+    }
+
+  protected:
+    // element type of the linked list
+    struct ListEl
+    {
+      StorageIndex next;
+      StorageIndex index;
+      Scalar value;
+    };
+
+    // used to store data in both mode
+    Scalar* m_buffer;
+    Scalar m_zero;
+    StorageIndex m_size;
+    StorageIndex m_start;
+    StorageIndex m_end;
+    StorageIndex m_allocatedSize;
+    StorageIndex m_allocatedElements;
+    StorageIndex m_mode;
+
+    // linked list mode
+    StorageIndex m_llStart;
+    StorageIndex m_llCurrent;
+    StorageIndex m_llSize;
+};
+
+/** \returns the number of non zeros in the current sub vector */
+template<typename _Scalar,typename _StorageIndex>
+Index AmbiVector<_Scalar,_StorageIndex>::nonZeros() const
+{
+  if (m_mode==IsSparse)
+    return m_llSize;
+  else
+    return m_end - m_start;
+}
+
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::init(double estimatedDensity)
+{
+  if (estimatedDensity>0.1)
+    init(IsDense);
+  else
+    init(IsSparse);
+}
+
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::init(int mode)
+{
+  m_mode = mode;
+  // This is only necessary in sparse mode, but we set these unconditionally to avoid some maybe-uninitialized warnings
+  // if (m_mode==IsSparse)
+  {
+    m_llSize = 0;
+    m_llStart = -1;
+  }
+}
+
+/** Must be called whenever we might perform a write access
+  * with an index smaller than the previous one.
+  *
+  * Don't worry, this function is extremely cheap.
+  */
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::restart()
+{
+  m_llCurrent = m_llStart;
+}
+
+/** Set all coefficients of current subvector to zero */
+template<typename _Scalar,typename _StorageIndex>
+void AmbiVector<_Scalar,_StorageIndex>::setZero()
+{
+  if (m_mode==IsDense)
+  {
+    for (Index i=m_start; i<m_end; ++i)
+      m_buffer[i] = Scalar(0);
+  }
+  else
+  {
+    eigen_assert(m_mode==IsSparse);
+    m_llSize = 0;
+    m_llStart = -1;
+  }
+}
+
+template<typename _Scalar,typename _StorageIndex>
+_Scalar& AmbiVector<_Scalar,_StorageIndex>::coeffRef(Index i)
+{
+  if (m_mode==IsDense)
+    return m_buffer[i];
+  else
+  {
+    ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer);
+    // TODO factorize the following code to reduce code generation
+    eigen_assert(m_mode==IsSparse);
+    if (m_llSize==0)
+    {
+      // this is the first element
+      m_llStart = 0;
+      m_llCurrent = 0;
+      ++m_llSize;
+      llElements[0].value = Scalar(0);
+      llElements[0].index = convert_index(i);
+      llElements[0].next = -1;
+      return llElements[0].value;
+    }
+    else if (i<llElements[m_llStart].index)
+    {
+      // this is going to be the new first element of the list
+      ListEl& el = llElements[m_llSize];
+      el.value = Scalar(0);
+      el.index = convert_index(i);
+      el.next = m_llStart;
+      m_llStart = m_llSize;
+      ++m_llSize;
+      m_llCurrent = m_llStart;
+      return el.value;
+    }
+    else
+    {
+      StorageIndex nextel = llElements[m_llCurrent].next;
+      eigen_assert(i>=llElements[m_llCurrent].index && "you must call restart() before inserting an element with lower or equal index");
+      while (nextel >= 0 && llElements[nextel].index<=i)
+      {
+        m_llCurrent = nextel;
+        nextel = llElements[nextel].next;
+      }
+
+      if (llElements[m_llCurrent].index==i)
+      {
+        // the coefficient already exists and we found it !
+        return llElements[m_llCurrent].value;
+      }
+      else
+      {
+        if (m_llSize>=m_allocatedElements)
+        {
+          reallocateSparse();
+          llElements = reinterpret_cast<ListEl*>(m_buffer);
+        }
+        eigen_internal_assert(m_llSize<m_allocatedElements && "internal error: overflow in sparse mode");
+        // let's insert a new coefficient
+        ListEl& el = llElements[m_llSize];
+        el.value = Scalar(0);
+        el.index = convert_index(i);
+        el.next = llElements[m_llCurrent].next;
+        llElements[m_llCurrent].next = m_llSize;
+        ++m_llSize;
+        return el.value;
+      }
+    }
+  }
+}
+
+template<typename _Scalar,typename _StorageIndex>
+_Scalar& AmbiVector<_Scalar,_StorageIndex>::coeff(Index i)
+{
+  if (m_mode==IsDense)
+    return m_buffer[i];
+  else
+  {
+    ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer);
+    eigen_assert(m_mode==IsSparse);
+    if ((m_llSize==0) || (i<llElements[m_llStart].index))
+    {
+      return m_zero;
+    }
+    else
+    {
+      Index elid = m_llStart;
+      while (elid >= 0 && llElements[elid].index<i)
+        elid = llElements[elid].next;
+
+      if (llElements[elid].index==i)
+        return llElements[m_llCurrent].value;
+      else
+        return m_zero;
+    }
+  }
+}
+
+/** Iterator over the nonzero coefficients */
+template<typename _Scalar,typename _StorageIndex>
+class AmbiVector<_Scalar,_StorageIndex>::Iterator
+{
+  public:
+    typedef _Scalar Scalar;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    /** Default constructor
+      * \param vec the vector on which we iterate
+      * \param epsilon the minimal value used to prune zero coefficients.
+      * In practice, all coefficients having a magnitude smaller than \a epsilon
+      * are skipped.
+      */
+    explicit Iterator(const AmbiVector& vec, const RealScalar& epsilon = 0)
+      : m_vector(vec)
+    {
+      using std::abs;
+      m_epsilon = epsilon;
+      m_isDense = m_vector.m_mode==IsDense;
+      if (m_isDense)
+      {
+        m_currentEl = 0;   // this is to avoid a compilation warning
+        m_cachedValue = 0; // this is to avoid a compilation warning
+        m_cachedIndex = m_vector.m_start-1;
+        ++(*this);
+      }
+      else
+      {
+        ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer);
+        m_currentEl = m_vector.m_llStart;
+        while (m_currentEl>=0 && abs(llElements[m_currentEl].value)<=m_epsilon)
+          m_currentEl = llElements[m_currentEl].next;
+        if (m_currentEl<0)
+        {
+          m_cachedValue = 0; // this is to avoid a compilation warning
+          m_cachedIndex = -1;
+        }
+        else
+        {
+          m_cachedIndex = llElements[m_currentEl].index;
+          m_cachedValue = llElements[m_currentEl].value;
+        }
+      }
+    }
+
+    StorageIndex index() const { return m_cachedIndex; }
+    Scalar value() const { return m_cachedValue; }
+
+    operator bool() const { return m_cachedIndex>=0; }
+
+    Iterator& operator++()
+    {
+      using std::abs;
+      if (m_isDense)
+      {
+        do {
+          ++m_cachedIndex;
+        } while (m_cachedIndex<m_vector.m_end && abs(m_vector.m_buffer[m_cachedIndex])<=m_epsilon);
+        if (m_cachedIndex<m_vector.m_end)
+          m_cachedValue = m_vector.m_buffer[m_cachedIndex];
+        else
+          m_cachedIndex=-1;
+      }
+      else
+      {
+        ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer);
+        do {
+          m_currentEl = llElements[m_currentEl].next;
+        } while (m_currentEl>=0 && abs(llElements[m_currentEl].value)<=m_epsilon);
+        if (m_currentEl<0)
+        {
+          m_cachedIndex = -1;
+        }
+        else
+        {
+          m_cachedIndex = llElements[m_currentEl].index;
+          m_cachedValue = llElements[m_currentEl].value;
+        }
+      }
+      return *this;
+    }
+
+  protected:
+    const AmbiVector& m_vector; // the target vector
+    StorageIndex m_currentEl;   // the current element in sparse/linked-list mode
+    RealScalar m_epsilon;       // epsilon used to prune zero coefficients
+    StorageIndex m_cachedIndex; // current coordinate
+    Scalar m_cachedValue;       // current value
+    bool m_isDense;             // mode of the vector
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_AMBIVECTOR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/CompressedStorage.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/CompressedStorage.h
new file mode 100644
index 00000000..acd986fa
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/CompressedStorage.h
@@ -0,0 +1,274 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_COMPRESSED_STORAGE_H
+#define EIGEN_COMPRESSED_STORAGE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \internal
+  * Stores a sparse set of values as a list of values and a list of indices.
+  *
+  */
+template<typename _Scalar,typename _StorageIndex>
+class CompressedStorage
+{
+  public:
+
+    typedef _Scalar Scalar;
+    typedef _StorageIndex StorageIndex;
+
+  protected:
+
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  public:
+
+    CompressedStorage()
+      : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
+    {}
+
+    explicit CompressedStorage(Index size)
+      : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
+    {
+      resize(size);
+    }
+
+    CompressedStorage(const CompressedStorage& other)
+      : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
+    {
+      *this = other;
+    }
+
+    CompressedStorage& operator=(const CompressedStorage& other)
+    {
+      resize(other.size());
+      if(other.size()>0)
+      {
+        internal::smart_copy(other.m_values,  other.m_values  + m_size, m_values);
+        internal::smart_copy(other.m_indices, other.m_indices + m_size, m_indices);
+      }
+      return *this;
+    }
+
+    void swap(CompressedStorage& other)
+    {
+      std::swap(m_values, other.m_values);
+      std::swap(m_indices, other.m_indices);
+      std::swap(m_size, other.m_size);
+      std::swap(m_allocatedSize, other.m_allocatedSize);
+    }
+
+    ~CompressedStorage()
+    {
+      delete[] m_values;
+      delete[] m_indices;
+    }
+
+    void reserve(Index size)
+    {
+      Index newAllocatedSize = m_size + size;
+      if (newAllocatedSize > m_allocatedSize)
+        reallocate(newAllocatedSize);
+    }
+
+    void squeeze()
+    {
+      if (m_allocatedSize>m_size)
+        reallocate(m_size);
+    }
+
+    void resize(Index size, double reserveSizeFactor = 0)
+    {
+      if (m_allocatedSize<size)
+      {
+        Index realloc_size = (std::min<Index>)(NumTraits<StorageIndex>::highest(),  size + Index(reserveSizeFactor*double(size)));
+        if(realloc_size<size)
+          internal::throw_std_bad_alloc();
+        reallocate(realloc_size);
+      }
+      m_size = size;
+    }
+
+    void append(const Scalar& v, Index i)
+    {
+      Index id = m_size;
+      resize(m_size+1, 1);
+      m_values[id] = v;
+      m_indices[id] = internal::convert_index<StorageIndex>(i);
+    }
+
+    inline Index size() const { return m_size; }
+    inline Index allocatedSize() const { return m_allocatedSize; }
+    inline void clear() { m_size = 0; }
+
+    const Scalar* valuePtr() const { return m_values; }
+    Scalar* valuePtr() { return m_values; }
+    const StorageIndex* indexPtr() const { return m_indices; }
+    StorageIndex* indexPtr() { return m_indices; }
+
+    inline Scalar& value(Index i) { eigen_internal_assert(m_values!=0); return m_values[i]; }
+    inline const Scalar& value(Index i) const { eigen_internal_assert(m_values!=0); return m_values[i]; }
+
+    inline StorageIndex& index(Index i) { eigen_internal_assert(m_indices!=0); return m_indices[i]; }
+    inline const StorageIndex& index(Index i) const { eigen_internal_assert(m_indices!=0); return m_indices[i]; }
+
+    /** \returns the largest \c k such that for all \c j in [0,k) index[\c j]\<\a key */
+    inline Index searchLowerIndex(Index key) const
+    {
+      return searchLowerIndex(0, m_size, key);
+    }
+
+    /** \returns the largest \c k in [start,end) such that for all \c j in [start,k) index[\c j]\<\a key */
+    inline Index searchLowerIndex(Index start, Index end, Index key) const
+    {
+      while(end>start)
+      {
+        Index mid = (end+start)>>1;
+        if (m_indices[mid]<key)
+          start = mid+1;
+        else
+          end = mid;
+      }
+      return start;
+    }
+
+    /** \returns the stored value at index \a key
+      * If the value does not exist, then the value \a defaultValue is returned without any insertion. */
+    inline Scalar at(Index key, const Scalar& defaultValue = Scalar(0)) const
+    {
+      if (m_size==0)
+        return defaultValue;
+      else if (key==m_indices[m_size-1])
+        return m_values[m_size-1];
+      // ^^  optimization: let's first check if it is the last coefficient
+      // (very common in high level algorithms)
+      const Index id = searchLowerIndex(0,m_size-1,key);
+      return ((id<m_size) && (m_indices[id]==key)) ? m_values[id] : defaultValue;
+    }
+
+    /** Like at(), but the search is performed in the range [start,end) */
+    inline Scalar atInRange(Index start, Index end, Index key, const Scalar &defaultValue = Scalar(0)) const
+    {
+      if (start>=end)
+        return defaultValue;
+      else if (end>start && key==m_indices[end-1])
+        return m_values[end-1];
+      // ^^  optimization: let's first check if it is the last coefficient
+      // (very common in high level algorithms)
+      const Index id = searchLowerIndex(start,end-1,key);
+      return ((id<end) && (m_indices[id]==key)) ? m_values[id] : defaultValue;
+    }
+
+    /** \returns a reference to the value at index \a key
+      * If the value does not exist, then the value \a defaultValue is inserted
+      * such that the keys are sorted. */
+    inline Scalar& atWithInsertion(Index key, const Scalar& defaultValue = Scalar(0))
+    {
+      Index id = searchLowerIndex(0,m_size,key);
+      if (id>=m_size || m_indices[id]!=key)
+      {
+        if (m_allocatedSize<m_size+1)
+        {
+          m_allocatedSize = 2*(m_size+1);
+          internal::scoped_array<Scalar> newValues(m_allocatedSize);
+          internal::scoped_array<StorageIndex> newIndices(m_allocatedSize);
+
+          // copy first chunk
+          internal::smart_copy(m_values,  m_values +id, newValues.ptr());
+          internal::smart_copy(m_indices, m_indices+id, newIndices.ptr());
+
+          // copy the rest
+          if(m_size>id)
+          {
+            internal::smart_copy(m_values +id,  m_values +m_size, newValues.ptr() +id+1);
+            internal::smart_copy(m_indices+id,  m_indices+m_size, newIndices.ptr()+id+1);
+          }
+          std::swap(m_values,newValues.ptr());
+          std::swap(m_indices,newIndices.ptr());
+        }
+        else if(m_size>id)
+        {
+          internal::smart_memmove(m_values +id, m_values +m_size, m_values +id+1);
+          internal::smart_memmove(m_indices+id, m_indices+m_size, m_indices+id+1);
+        }
+        m_size++;
+        m_indices[id] = internal::convert_index<StorageIndex>(key);
+        m_values[id] = defaultValue;
+      }
+      return m_values[id];
+    }
+
+    void moveChunk(Index from, Index to, Index chunkSize)
+    {
+      eigen_internal_assert(to+chunkSize <= m_size);
+      if(to>from && from+chunkSize>to)
+      {
+        // move backward
+        internal::smart_memmove(m_values+from,  m_values+from+chunkSize,  m_values+to);
+        internal::smart_memmove(m_indices+from, m_indices+from+chunkSize, m_indices+to);
+      }
+      else
+      {
+        internal::smart_copy(m_values+from,  m_values+from+chunkSize,  m_values+to);
+        internal::smart_copy(m_indices+from, m_indices+from+chunkSize, m_indices+to);
+      }
+    }
+
+    void prune(const Scalar& reference, const RealScalar& epsilon = NumTraits<RealScalar>::dummy_precision())
+    {
+      Index k = 0;
+      Index n = size();
+      for (Index i=0; i<n; ++i)
+      {
+        if (!internal::isMuchSmallerThan(value(i), reference, epsilon))
+        {
+          value(k) = value(i);
+          index(k) = index(i);
+          ++k;
+        }
+      }
+      resize(k,0);
+    }
+
+  protected:
+
+    inline void reallocate(Index size)
+    {
+      #ifdef EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN
+        EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN
+      #endif
+      eigen_internal_assert(size!=m_allocatedSize);
+      internal::scoped_array<Scalar> newValues(size);
+      internal::scoped_array<StorageIndex> newIndices(size);
+      Index copySize = (std::min)(size, m_size);
+      if (copySize>0) {
+        internal::smart_copy(m_values, m_values+copySize, newValues.ptr());
+        internal::smart_copy(m_indices, m_indices+copySize, newIndices.ptr());
+      }
+      std::swap(m_values,newValues.ptr());
+      std::swap(m_indices,newIndices.ptr());
+      m_allocatedSize = size;
+    }
+
+  protected:
+    Scalar* m_values;
+    StorageIndex* m_indices;
+    Index m_size;
+    Index m_allocatedSize;
+
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_COMPRESSED_STORAGE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h
new file mode 100644
index 00000000..94865025
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h
@@ -0,0 +1,352 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
+#define EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType>
+static void conservative_sparse_sparse_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res, bool sortedInsertion = false)
+{
+  typedef typename remove_all<Lhs>::type::Scalar LhsScalar;
+  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
+  typedef typename remove_all<ResultType>::type::Scalar ResScalar;
+
+  // make sure to call innerSize/outerSize since we fake the storage order.
+  Index rows = lhs.innerSize();
+  Index cols = rhs.outerSize();
+  eigen_assert(lhs.outerSize() == rhs.innerSize());
+
+  ei_declare_aligned_stack_constructed_variable(bool,   mask,     rows, 0);
+  ei_declare_aligned_stack_constructed_variable(ResScalar, values,   rows, 0);
+  ei_declare_aligned_stack_constructed_variable(Index,  indices,  rows, 0);
+
+  std::memset(mask,0,sizeof(bool)*rows);
+
+  evaluator<Lhs> lhsEval(lhs);
+  evaluator<Rhs> rhsEval(rhs);
+
+  // estimate the number of non zero entries
+  // given a rhs column containing Y non zeros, we assume that the respective Y columns
+  // of the lhs differs in average of one non zeros, thus the number of non zeros for
+  // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
+  // per column of the lhs.
+  // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
+  Index estimated_nnz_prod = lhsEval.nonZerosEstimate() + rhsEval.nonZerosEstimate();
+
+  res.setZero();
+  res.reserve(Index(estimated_nnz_prod));
+  // we compute each column of the result, one after the other
+  for (Index j=0; j<cols; ++j)
+  {
+
+    res.startVec(j);
+    Index nnz = 0;
+    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
+    {
+      RhsScalar y = rhsIt.value();
+      Index k = rhsIt.index();
+      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, k); lhsIt; ++lhsIt)
+      {
+        Index i = lhsIt.index();
+        LhsScalar x = lhsIt.value();
+        if(!mask[i])
+        {
+          mask[i] = true;
+          values[i] = x * y;
+          indices[nnz] = i;
+          ++nnz;
+        }
+        else
+          values[i] += x * y;
+      }
+    }
+    if(!sortedInsertion)
+    {
+      // unordered insertion
+      for(Index k=0; k<nnz; ++k)
+      {
+        Index i = indices[k];
+        res.insertBackByOuterInnerUnordered(j,i) = values[i];
+        mask[i] = false;
+      }
+    }
+    else
+    {
+      // alternative ordered insertion code:
+      const Index t200 = rows/11; // 11 == (log2(200)*1.39)
+      const Index t = (rows*100)/139;
+
+      // FIXME reserve nnz non zeros
+      // FIXME implement faster sorting algorithms for very small nnz
+      // if the result is sparse enough => use a quick sort
+      // otherwise => loop through the entire vector
+      // In order to avoid to perform an expensive log2 when the
+      // result is clearly very sparse we use a linear bound up to 200.
+      if((nnz<200 && nnz<t200) || nnz * numext::log2(int(nnz)) < t)
+      {
+        if(nnz>1) std::sort(indices,indices+nnz);
+        for(Index k=0; k<nnz; ++k)
+        {
+          Index i = indices[k];
+          res.insertBackByOuterInner(j,i) = values[i];
+          mask[i] = false;
+        }
+      }
+      else
+      {
+        // dense path
+        for(Index i=0; i<rows; ++i)
+        {
+          if(mask[i])
+          {
+            mask[i] = false;
+            res.insertBackByOuterInner(j,i) = values[i];
+          }
+        }
+      }
+    }
+  }
+  res.finalize();
+}
+
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType,
+  int LhsStorageOrder = (traits<Lhs>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+  int RhsStorageOrder = (traits<Rhs>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+  int ResStorageOrder = (traits<ResultType>::Flags&RowMajorBit) ? RowMajor : ColMajor>
+struct conservative_sparse_sparse_product_selector;
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor>
+{
+  typedef typename remove_all<Lhs>::type LhsCleaned;
+  typedef typename LhsCleaned::Scalar Scalar;
+
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorMatrix;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorMatrixAux;
+    typedef typename sparse_eval<ColMajorMatrixAux,ResultType::RowsAtCompileTime,ResultType::ColsAtCompileTime,ColMajorMatrixAux::Flags>::type ColMajorMatrix;
+
+    // If the result is tall and thin (in the extreme case a column vector)
+    // then it is faster to sort the coefficients inplace instead of transposing twice.
+    // FIXME, the following heuristic is probably not very good.
+    if(lhs.rows()>rhs.cols())
+    {
+      ColMajorMatrix resCol(lhs.rows(),rhs.cols());
+      // perform sorted insertion
+      internal::conservative_sparse_sparse_product_impl<Lhs,Rhs,ColMajorMatrix>(lhs, rhs, resCol, true);
+      res = resCol.markAsRValue();
+    }
+    else
+    {
+      ColMajorMatrixAux resCol(lhs.rows(),rhs.cols());
+      // resort to transpose to sort the entries
+      internal::conservative_sparse_sparse_product_impl<Lhs,Rhs,ColMajorMatrixAux>(lhs, rhs, resCol, false);
+      RowMajorMatrix resRow(resCol);
+      res = resRow.markAsRValue();
+    }
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorRhs;
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorRes;
+    RowMajorRhs rhsRow = rhs;
+    RowMajorRes resRow(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<RowMajorRhs,Lhs,RowMajorRes>(rhsRow, lhs, resRow);
+    res = resRow;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorLhs;
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorRes;
+    RowMajorLhs lhsRow = lhs;
+    RowMajorRes resRow(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Rhs,RowMajorLhs,RowMajorRes>(rhs, lhsRow, resRow);
+    res = resRow;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorMatrix;
+    RowMajorMatrix resRow(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Rhs,Lhs,RowMajorMatrix>(rhs, lhs, resRow);
+    res = resRow;
+  }
+};
+
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor>
+{
+  typedef typename traits<typename remove_all<Lhs>::type>::Scalar Scalar;
+
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorMatrix;
+    ColMajorMatrix resCol(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Lhs,Rhs,ColMajorMatrix>(lhs, rhs, resCol);
+    res = resCol;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorLhs;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRes;
+    ColMajorLhs lhsCol = lhs;
+    ColMajorRes resCol(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<ColMajorLhs,Rhs,ColMajorRes>(lhsCol, rhs, resCol);
+    res = resCol;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRhs;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRes;
+    ColMajorRhs rhsCol = rhs;
+    ColMajorRes resCol(lhs.rows(), rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Lhs,ColMajorRhs,ColMajorRes>(lhs, rhsCol, resCol);
+    res = resCol;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct conservative_sparse_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename ResultType::Scalar,RowMajor,typename ResultType::StorageIndex> RowMajorMatrix;
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorMatrix;
+    RowMajorMatrix resRow(lhs.rows(),rhs.cols());
+    internal::conservative_sparse_sparse_product_impl<Rhs,Lhs,RowMajorMatrix>(rhs, lhs, resRow);
+    // sort the non zeros:
+    ColMajorMatrix resCol(resRow);
+    res = resCol;
+  }
+};
+
+} // end namespace internal
+
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType>
+static void sparse_sparse_to_dense_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+{
+  typedef typename remove_all<Lhs>::type::Scalar LhsScalar;
+  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
+  Index cols = rhs.outerSize();
+  eigen_assert(lhs.outerSize() == rhs.innerSize());
+
+  evaluator<Lhs> lhsEval(lhs);
+  evaluator<Rhs> rhsEval(rhs);
+
+  for (Index j=0; j<cols; ++j)
+  {
+    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
+    {
+      RhsScalar y = rhsIt.value();
+      Index k = rhsIt.index();
+      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, k); lhsIt; ++lhsIt)
+      {
+        Index i = lhsIt.index();
+        LhsScalar x = lhsIt.value();
+        res.coeffRef(i,j) += x * y;
+      }
+    }
+  }
+}
+
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, typename ResultType,
+  int LhsStorageOrder = (traits<Lhs>::Flags&RowMajorBit) ? RowMajor : ColMajor,
+  int RhsStorageOrder = (traits<Rhs>::Flags&RowMajorBit) ? RowMajor : ColMajor>
+struct sparse_sparse_to_dense_product_selector;
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    internal::sparse_sparse_to_dense_product_impl<Lhs,Rhs,ResultType>(lhs, rhs, res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorLhs;
+    ColMajorLhs lhsCol(lhs);
+    internal::sparse_sparse_to_dense_product_impl<ColMajorLhs,Rhs,ResultType>(lhsCol, rhs, res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename ResultType::StorageIndex> ColMajorRhs;
+    ColMajorRhs rhsCol(rhs);
+    internal::sparse_sparse_to_dense_product_impl<Lhs,ColMajorRhs,ResultType>(lhs, rhsCol, res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_to_dense_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor>
+{
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res)
+  {
+    Transpose<ResultType> trRes(res);
+    internal::sparse_sparse_to_dense_product_impl<Rhs,Lhs,Transpose<ResultType> >(rhs, lhs, trRes);
+  }
+};
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/MappedSparseMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/MappedSparseMatrix.h
new file mode 100644
index 00000000..67718c85
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/MappedSparseMatrix.h
@@ -0,0 +1,67 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MAPPED_SPARSEMATRIX_H
+#define EIGEN_MAPPED_SPARSEMATRIX_H
+
+namespace Eigen {
+
+/** \deprecated Use Map<SparseMatrix<> >
+  * \class MappedSparseMatrix
+  *
+  * \brief Sparse matrix
+  *
+  * \param _Scalar the scalar type, i.e. the type of the coefficients
+  *
+  * See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme.
+  *
+  */
+namespace internal {
+template<typename _Scalar, int _Flags, typename _StorageIndex>
+struct traits<MappedSparseMatrix<_Scalar, _Flags, _StorageIndex> > : traits<SparseMatrix<_Scalar, _Flags, _StorageIndex> >
+{};
+} // end namespace internal
+
+template<typename _Scalar, int _Flags, typename _StorageIndex>
+class MappedSparseMatrix
+  : public Map<SparseMatrix<_Scalar, _Flags, _StorageIndex> >
+{
+    typedef Map<SparseMatrix<_Scalar, _Flags, _StorageIndex> > Base;
+
+  public:
+    
+    typedef typename Base::StorageIndex StorageIndex;
+    typedef typename Base::Scalar Scalar;
+
+    inline MappedSparseMatrix(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr, StorageIndex* innerIndexPtr, Scalar* valuePtr, StorageIndex* innerNonZeroPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZeroPtr)
+    {}
+
+    /** Empty destructor */
+    inline ~MappedSparseMatrix() {}
+};
+
+namespace internal {
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct evaluator<MappedSparseMatrix<_Scalar,_Options,_StorageIndex> >
+  : evaluator<SparseCompressedBase<MappedSparseMatrix<_Scalar,_Options,_StorageIndex> > >
+{
+  typedef MappedSparseMatrix<_Scalar,_Options,_StorageIndex> XprType;
+  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MAPPED_SPARSEMATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseAssign.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseAssign.h
new file mode 100644
index 00000000..905485c8
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseAssign.h
@@ -0,0 +1,270 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEASSIGN_H
+#define EIGEN_SPARSEASSIGN_H
+
+namespace Eigen { 
+
+template<typename Derived>    
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator=(const EigenBase<OtherDerived> &other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  // TODO use the evaluator mechanism
+  other.evalTo(derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+inline Derived& SparseMatrixBase<Derived>::operator=(const SparseMatrixBase<OtherDerived>& other)
+{
+  // by default sparse evaluation do not alias, so we can safely bypass the generic call_assignment routine
+  internal::Assignment<Derived,OtherDerived,internal::assign_op<Scalar,typename OtherDerived::Scalar> >
+          ::run(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+inline Derived& SparseMatrixBase<Derived>::operator=(const Derived& other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived());
+  return derived();
+}
+
+namespace internal {
+
+template<>
+struct storage_kind_to_evaluator_kind<Sparse> {
+  typedef IteratorBased Kind;
+};
+
+template<>
+struct storage_kind_to_shape<Sparse> {
+  typedef SparseShape Shape;
+};
+
+struct Sparse2Sparse {};
+struct Sparse2Dense  {};
+
+template<> struct AssignmentKind<SparseShape, SparseShape>           { typedef Sparse2Sparse Kind; };
+template<> struct AssignmentKind<SparseShape, SparseTriangularShape> { typedef Sparse2Sparse Kind; };
+template<> struct AssignmentKind<DenseShape,  SparseShape>           { typedef Sparse2Dense  Kind; };
+template<> struct AssignmentKind<DenseShape,  SparseTriangularShape> { typedef Sparse2Dense  Kind; };
+
+
+template<typename DstXprType, typename SrcXprType>
+void assign_sparse_to_sparse(DstXprType &dst, const SrcXprType &src)
+{
+  typedef typename DstXprType::Scalar Scalar;
+  typedef internal::evaluator<DstXprType> DstEvaluatorType;
+  typedef internal::evaluator<SrcXprType> SrcEvaluatorType;
+
+  SrcEvaluatorType srcEvaluator(src);
+
+  const bool transpose = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit);
+  const Index outerEvaluationSize = (SrcEvaluatorType::Flags&RowMajorBit) ? src.rows() : src.cols();
+  if ((!transpose) && src.isRValue())
+  {
+    // eval without temporary
+    dst.resize(src.rows(), src.cols());
+    dst.setZero();
+    dst.reserve((std::min)(src.rows()*src.cols(), (std::max)(src.rows(),src.cols())*2));
+    for (Index j=0; j<outerEvaluationSize; ++j)
+    {
+      dst.startVec(j);
+      for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it)
+      {
+        Scalar v = it.value();
+        dst.insertBackByOuterInner(j,it.index()) = v;
+      }
+    }
+    dst.finalize();
+  }
+  else
+  {
+    // eval through a temporary
+    eigen_assert(( ((internal::traits<DstXprType>::SupportedAccessPatterns & OuterRandomAccessPattern)==OuterRandomAccessPattern) ||
+              (!((DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit)))) &&
+              "the transpose operation is supposed to be handled in SparseMatrix::operator=");
+
+    enum { Flip = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit) };
+
+    
+    DstXprType temp(src.rows(), src.cols());
+
+    temp.reserve((std::min)(src.rows()*src.cols(), (std::max)(src.rows(),src.cols())*2));
+    for (Index j=0; j<outerEvaluationSize; ++j)
+    {
+      temp.startVec(j);
+      for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it)
+      {
+        Scalar v = it.value();
+        temp.insertBackByOuterInner(Flip?it.index():j,Flip?j:it.index()) = v;
+      }
+    }
+    temp.finalize();
+
+    dst = temp.markAsRValue();
+  }
+}
+
+// Generic Sparse to Sparse assignment
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Sparse>
+{
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  {
+    assign_sparse_to_sparse(dst.derived(), src.derived());
+  }
+};
+
+// Generic Sparse to Dense assignment
+template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
+struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Dense, Weak>
+{
+  static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
+  {
+    if(internal::is_same<Functor,internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> >::value)
+      dst.setZero();
+    
+    internal::evaluator<SrcXprType> srcEval(src);
+    resize_if_allowed(dst, src, func);
+    internal::evaluator<DstXprType> dstEval(dst);
+    
+    const Index outerEvaluationSize = (internal::evaluator<SrcXprType>::Flags&RowMajorBit) ? src.rows() : src.cols();
+    for (Index j=0; j<outerEvaluationSize; ++j)
+      for (typename internal::evaluator<SrcXprType>::InnerIterator i(srcEval,j); i; ++i)
+        func.assignCoeff(dstEval.coeffRef(i.row(),i.col()), i.value());
+  }
+};
+
+// Specialization for dense ?= dense +/- sparse and dense ?= sparse +/- dense
+template<typename DstXprType, typename Func1, typename Func2>
+struct assignment_from_dense_op_sparse
+{
+  template<typename SrcXprType, typename InitialFunc>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  void run(DstXprType &dst, const SrcXprType &src, const InitialFunc& /*func*/)
+  {
+    #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_DENSE_OP_SPARSE_PLUGIN
+    EIGEN_SPARSE_ASSIGNMENT_FROM_DENSE_OP_SPARSE_PLUGIN
+    #endif
+
+    call_assignment_no_alias(dst, src.lhs(), Func1());
+    call_assignment_no_alias(dst, src.rhs(), Func2());
+  }
+
+  // Specialization for dense1 = sparse + dense2; -> dense1 = dense2; dense1 += sparse;
+  template<typename Lhs, typename Rhs, typename Scalar>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  typename internal::enable_if<internal::is_same<typename internal::evaluator_traits<Rhs>::Shape,DenseShape>::value>::type
+  run(DstXprType &dst, const CwiseBinaryOp<internal::scalar_sum_op<Scalar,Scalar>, const Lhs, const Rhs> &src,
+      const internal::assign_op<typename DstXprType::Scalar,Scalar>& /*func*/)
+  {
+    #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_ADD_DENSE_PLUGIN
+    EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_ADD_DENSE_PLUGIN
+    #endif
+
+    // Apply the dense matrix first, then the sparse one.
+    call_assignment_no_alias(dst, src.rhs(), Func1());
+    call_assignment_no_alias(dst, src.lhs(), Func2());
+  }
+
+  // Specialization for dense1 = sparse - dense2; -> dense1 = -dense2; dense1 += sparse;
+  template<typename Lhs, typename Rhs, typename Scalar>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+  typename internal::enable_if<internal::is_same<typename internal::evaluator_traits<Rhs>::Shape,DenseShape>::value>::type
+  run(DstXprType &dst, const CwiseBinaryOp<internal::scalar_difference_op<Scalar,Scalar>, const Lhs, const Rhs> &src,
+      const internal::assign_op<typename DstXprType::Scalar,Scalar>& /*func*/)
+  {
+    #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_SUB_DENSE_PLUGIN
+    EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_SUB_DENSE_PLUGIN
+    #endif
+
+    // Apply the dense matrix first, then the sparse one.
+    call_assignment_no_alias(dst, -src.rhs(), Func1());
+    call_assignment_no_alias(dst,  src.lhs(), add_assign_op<typename DstXprType::Scalar,typename Lhs::Scalar>());
+  }
+};
+
+#define EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(ASSIGN_OP,BINOP,ASSIGN_OP2) \
+  template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar> \
+  struct Assignment<DstXprType, CwiseBinaryOp<internal::BINOP<Scalar,Scalar>, const Lhs, const Rhs>, internal::ASSIGN_OP<typename DstXprType::Scalar,Scalar>, \
+                    Sparse2Dense, \
+                    typename internal::enable_if<   internal::is_same<typename internal::evaluator_traits<Lhs>::Shape,DenseShape>::value \
+                                                 || internal::is_same<typename internal::evaluator_traits<Rhs>::Shape,DenseShape>::value>::type> \
+    : assignment_from_dense_op_sparse<DstXprType, internal::ASSIGN_OP<typename DstXprType::Scalar,typename Lhs::Scalar>, internal::ASSIGN_OP2<typename DstXprType::Scalar,typename Rhs::Scalar> > \
+  {}
+
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(assign_op,    scalar_sum_op,add_assign_op);
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(add_assign_op,scalar_sum_op,add_assign_op);
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(sub_assign_op,scalar_sum_op,sub_assign_op);
+
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(assign_op,    scalar_difference_op,sub_assign_op);
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(add_assign_op,scalar_difference_op,sub_assign_op);
+EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(sub_assign_op,scalar_difference_op,add_assign_op);
+
+
+// Specialization for "dst = dec.solve(rhs)"
+// NOTE we need to specialize it for Sparse2Sparse to avoid ambiguous specialization error
+template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
+struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar,Scalar>, Sparse2Sparse>
+{
+  typedef Solve<DecType,RhsType> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+
+    src.dec()._solve_impl(src.rhs(), dst);
+  }
+};
+
+struct Diagonal2Sparse {};
+
+template<> struct AssignmentKind<SparseShape,DiagonalShape> { typedef Diagonal2Sparse Kind; };
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Sparse>
+{
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  typedef typename DstXprType::Scalar Scalar;
+
+  template<int Options, typename AssignFunc>
+  static void run(SparseMatrix<Scalar,Options,StorageIndex> &dst, const SrcXprType &src, const AssignFunc &func)
+  { dst.assignDiagonal(src.diagonal(), func); }
+  
+  template<typename DstDerived>
+  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.derived().diagonal() = src.diagonal(); }
+  
+  template<typename DstDerived>
+  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.derived().diagonal() += src.diagonal(); }
+  
+  template<typename DstDerived>
+  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
+  { dst.derived().diagonal() -= src.diagonal(); }
+};
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEASSIGN_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseBlock.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseBlock.h
new file mode 100644
index 00000000..5b4f6cc9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseBlock.h
@@ -0,0 +1,571 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_BLOCK_H
+#define EIGEN_SPARSE_BLOCK_H
+
+namespace Eigen {
+
+// Subset of columns or rows
+template<typename XprType, int BlockRows, int BlockCols>
+class BlockImpl<XprType,BlockRows,BlockCols,true,Sparse>
+  : public SparseMatrixBase<Block<XprType,BlockRows,BlockCols,true> >
+{
+    typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested;
+    typedef Block<XprType, BlockRows, BlockCols, true> BlockType;
+public:
+    enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
+protected:
+    enum { OuterSize = IsRowMajor ? BlockRows : BlockCols };
+    typedef SparseMatrixBase<BlockType> Base;
+    using Base::convert_index;
+public:
+    EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
+
+    inline BlockImpl(XprType& xpr, Index i)
+      : m_matrix(xpr), m_outerStart(convert_index(i)), m_outerSize(OuterSize)
+    {}
+
+    inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : m_matrix(xpr), m_outerStart(convert_index(IsRowMajor ? startRow : startCol)), m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols))
+    {}
+
+    EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+    Index nonZeros() const
+    {
+      typedef internal::evaluator<XprType> EvaluatorType;
+      EvaluatorType matEval(m_matrix);
+      Index nnz = 0;
+      Index end = m_outerStart + m_outerSize.value();
+      for(Index j=m_outerStart; j<end; ++j)
+        for(typename EvaluatorType::InnerIterator it(matEval, j); it; ++it)
+          ++nnz;
+      return nnz;
+    }
+
+    inline const Scalar coeff(Index row, Index col) const
+    {
+      return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 :  m_outerStart));
+    }
+
+    inline const Scalar coeff(Index index) const
+    {
+      return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index :  m_outerStart);
+    }
+
+    inline const XprType& nestedExpression() const { return m_matrix; }
+    inline XprType& nestedExpression() { return m_matrix; }
+    Index startRow() const { return IsRowMajor ? m_outerStart : 0; }
+    Index startCol() const { return IsRowMajor ? 0 : m_outerStart; }
+    Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+  protected:
+
+    typename internal::ref_selector<XprType>::non_const_type m_matrix;
+    Index m_outerStart;
+    const internal::variable_if_dynamic<Index, OuterSize> m_outerSize;
+
+  protected:
+    // Disable assignment with clear error message.
+    // Note that simply removing operator= yields compilation errors with ICC+MSVC
+    template<typename T>
+    BlockImpl& operator=(const T&)
+    {
+      EIGEN_STATIC_ASSERT(sizeof(T)==0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY);
+      return *this;
+    }
+};
+
+
+/***************************************************************************
+* specialization for SparseMatrix
+***************************************************************************/
+
+namespace internal {
+
+template<typename SparseMatrixType, int BlockRows, int BlockCols>
+class sparse_matrix_block_impl
+  : public SparseCompressedBase<Block<SparseMatrixType,BlockRows,BlockCols,true> >
+{
+    typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _MatrixTypeNested;
+    typedef Block<SparseMatrixType, BlockRows, BlockCols, true> BlockType;
+    typedef SparseCompressedBase<Block<SparseMatrixType,BlockRows,BlockCols,true> > Base;
+    using Base::convert_index;
+public:
+    enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
+    EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
+protected:
+    typedef typename Base::IndexVector IndexVector;
+    enum { OuterSize = IsRowMajor ? BlockRows : BlockCols };
+public:
+
+    inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index i)
+      : m_matrix(xpr), m_outerStart(convert_index(i)), m_outerSize(OuterSize)
+    {}
+
+    inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : m_matrix(xpr), m_outerStart(convert_index(IsRowMajor ? startRow : startCol)), m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols))
+    {}
+
+    template<typename OtherDerived>
+    inline BlockType& operator=(const SparseMatrixBase<OtherDerived>& other)
+    {
+      typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _NestedMatrixType;
+      _NestedMatrixType& matrix = m_matrix;
+      // This assignment is slow if this vector set is not empty
+      // and/or it is not at the end of the nonzeros of the underlying matrix.
+
+      // 1 - eval to a temporary to avoid transposition and/or aliasing issues
+      Ref<const SparseMatrix<Scalar, IsRowMajor ? RowMajor : ColMajor, StorageIndex> > tmp(other.derived());
+      eigen_internal_assert(tmp.outerSize()==m_outerSize.value());
+
+      // 2 - let's check whether there is enough allocated memory
+      Index nnz           = tmp.nonZeros();
+      Index start         = m_outerStart==0 ? 0 : m_matrix.outerIndexPtr()[m_outerStart]; // starting position of the current block
+      Index end           = m_matrix.outerIndexPtr()[m_outerStart+m_outerSize.value()]; // ending position of the current block
+      Index block_size    = end - start;                                                // available room in the current block
+      Index tail_size     = m_matrix.outerIndexPtr()[m_matrix.outerSize()] - end;
+
+      Index free_size     = m_matrix.isCompressed()
+                          ? Index(matrix.data().allocatedSize()) + block_size
+                          : block_size;
+
+      Index tmp_start = tmp.outerIndexPtr()[0];
+
+      bool update_trailing_pointers = false;
+      if(nnz>free_size)
+      {
+        // realloc manually to reduce copies
+        typename SparseMatrixType::Storage newdata(m_matrix.data().allocatedSize() - block_size + nnz);
+
+        internal::smart_copy(m_matrix.valuePtr(),       m_matrix.valuePtr() + start,      newdata.valuePtr());
+        internal::smart_copy(m_matrix.innerIndexPtr(),  m_matrix.innerIndexPtr() + start, newdata.indexPtr());
+
+        internal::smart_copy(tmp.valuePtr() + tmp_start,      tmp.valuePtr() + tmp_start + nnz,       newdata.valuePtr() + start);
+        internal::smart_copy(tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz,  newdata.indexPtr() + start);
+
+        internal::smart_copy(matrix.valuePtr()+end,       matrix.valuePtr()+end + tail_size,      newdata.valuePtr()+start+nnz);
+        internal::smart_copy(matrix.innerIndexPtr()+end,  matrix.innerIndexPtr()+end + tail_size, newdata.indexPtr()+start+nnz);
+
+        newdata.resize(m_matrix.outerIndexPtr()[m_matrix.outerSize()] - block_size + nnz);
+
+        matrix.data().swap(newdata);
+
+        update_trailing_pointers = true;
+      }
+      else
+      {
+        if(m_matrix.isCompressed() && nnz!=block_size)
+        {
+          // no need to realloc, simply copy the tail at its respective position and insert tmp
+          matrix.data().resize(start + nnz + tail_size);
+
+          internal::smart_memmove(matrix.valuePtr()+end,      matrix.valuePtr() + end+tail_size,      matrix.valuePtr() + start+nnz);
+          internal::smart_memmove(matrix.innerIndexPtr()+end, matrix.innerIndexPtr() + end+tail_size, matrix.innerIndexPtr() + start+nnz);
+
+          update_trailing_pointers = true;
+        }
+
+        internal::smart_copy(tmp.valuePtr() + tmp_start,      tmp.valuePtr() + tmp_start + nnz,       matrix.valuePtr() + start);
+        internal::smart_copy(tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz,  matrix.innerIndexPtr() + start);
+      }
+
+      // update outer index pointers and innerNonZeros
+      if(IsVectorAtCompileTime)
+      {
+        if(!m_matrix.isCompressed())
+          matrix.innerNonZeroPtr()[m_outerStart] = StorageIndex(nnz);
+        matrix.outerIndexPtr()[m_outerStart] = StorageIndex(start);
+      }
+      else
+      {
+        StorageIndex p = StorageIndex(start);
+        for(Index k=0; k<m_outerSize.value(); ++k)
+        {
+          StorageIndex nnz_k = internal::convert_index<StorageIndex>(tmp.innerVector(k).nonZeros());
+          if(!m_matrix.isCompressed())
+            matrix.innerNonZeroPtr()[m_outerStart+k] = nnz_k;
+          matrix.outerIndexPtr()[m_outerStart+k] = p;
+          p += nnz_k;
+        }
+      }
+
+      if(update_trailing_pointers)
+      {
+        StorageIndex offset = internal::convert_index<StorageIndex>(nnz - block_size);
+        for(Index k = m_outerStart + m_outerSize.value(); k<=matrix.outerSize(); ++k)
+        {
+          matrix.outerIndexPtr()[k] += offset;
+        }
+      }
+
+      return derived();
+    }
+
+    inline BlockType& operator=(const BlockType& other)
+    {
+      return operator=<BlockType>(other);
+    }
+
+    inline const Scalar* valuePtr() const
+    { return m_matrix.valuePtr(); }
+    inline Scalar* valuePtr()
+    { return m_matrix.valuePtr(); }
+
+    inline const StorageIndex* innerIndexPtr() const
+    { return m_matrix.innerIndexPtr(); }
+    inline StorageIndex* innerIndexPtr()
+    { return m_matrix.innerIndexPtr(); }
+
+    inline const StorageIndex* outerIndexPtr() const
+    { return m_matrix.outerIndexPtr() + m_outerStart; }
+    inline StorageIndex* outerIndexPtr()
+    { return m_matrix.outerIndexPtr() + m_outerStart; }
+
+    inline const StorageIndex* innerNonZeroPtr() const
+    { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr()+m_outerStart); }
+    inline StorageIndex* innerNonZeroPtr()
+    { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr()+m_outerStart); }
+
+    bool isCompressed() const { return m_matrix.innerNonZeroPtr()==0; }
+
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      return m_matrix.coeffRef(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 :  m_outerStart));
+    }
+
+    inline const Scalar coeff(Index row, Index col) const
+    {
+      return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 :  m_outerStart));
+    }
+
+    inline const Scalar coeff(Index index) const
+    {
+      return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index :  m_outerStart);
+    }
+
+    const Scalar& lastCoeff() const
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(sparse_matrix_block_impl);
+      eigen_assert(Base::nonZeros()>0);
+      if(m_matrix.isCompressed())
+        return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart+1]-1];
+      else
+        return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart]+m_matrix.innerNonZeroPtr()[m_outerStart]-1];
+    }
+
+    EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+    inline const SparseMatrixType& nestedExpression() const { return m_matrix; }
+    inline SparseMatrixType& nestedExpression() { return m_matrix; }
+    Index startRow() const { return IsRowMajor ? m_outerStart : 0; }
+    Index startCol() const { return IsRowMajor ? 0 : m_outerStart; }
+    Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
+    Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
+
+  protected:
+
+    typename internal::ref_selector<SparseMatrixType>::non_const_type m_matrix;
+    Index m_outerStart;
+    const internal::variable_if_dynamic<Index, OuterSize> m_outerSize;
+
+};
+
+} // namespace internal
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+class BlockImpl<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true,Sparse>
+  : public internal::sparse_matrix_block_impl<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols>
+{
+public:
+  typedef _StorageIndex StorageIndex;
+  typedef SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType;
+  typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,BlockCols> Base;
+  inline BlockImpl(SparseMatrixType& xpr, Index i)
+    : Base(xpr, i)
+  {}
+
+  inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+    : Base(xpr, startRow, startCol, blockRows, blockCols)
+  {}
+
+  using Base::operator=;
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+class BlockImpl<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true,Sparse>
+  : public internal::sparse_matrix_block_impl<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols>
+{
+public:
+  typedef _StorageIndex StorageIndex;
+  typedef const SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType;
+  typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,BlockCols> Base;
+  inline BlockImpl(SparseMatrixType& xpr, Index i)
+    : Base(xpr, i)
+  {}
+
+  inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+    : Base(xpr, startRow, startCol, blockRows, blockCols)
+  {}
+
+  using Base::operator=;
+private:
+  template<typename Derived> BlockImpl(const SparseMatrixBase<Derived>& xpr, Index i);
+  template<typename Derived> BlockImpl(const SparseMatrixBase<Derived>& xpr);
+};
+
+//----------
+
+/** Generic implementation of sparse Block expression.
+  * Real-only.
+  */
+template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
+class BlockImpl<XprType,BlockRows,BlockCols,InnerPanel,Sparse>
+  : public SparseMatrixBase<Block<XprType,BlockRows,BlockCols,InnerPanel> >, internal::no_assignment_operator
+{
+    typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
+    typedef SparseMatrixBase<BlockType> Base;
+    using Base::convert_index;
+public:
+    enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
+    EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
+
+    typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested;
+
+    /** Column or Row constructor
+      */
+    inline BlockImpl(XprType& xpr, Index i)
+      : m_matrix(xpr),
+        m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? convert_index(i) : 0),
+        m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? convert_index(i) : 0),
+        m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
+        m_blockCols(BlockCols==1 ? 1 : xpr.cols())
+    {}
+
+    /** Dynamic-size constructor
+      */
+    inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
+      : m_matrix(xpr), m_startRow(convert_index(startRow)), m_startCol(convert_index(startCol)), m_blockRows(convert_index(blockRows)), m_blockCols(convert_index(blockCols))
+    {}
+
+    inline Index rows() const { return m_blockRows.value(); }
+    inline Index cols() const { return m_blockCols.value(); }
+
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      return m_matrix.coeffRef(row + m_startRow.value(), col + m_startCol.value());
+    }
+
+    inline const Scalar coeff(Index row, Index col) const
+    {
+      return m_matrix.coeff(row + m_startRow.value(), col + m_startCol.value());
+    }
+
+    inline Scalar& coeffRef(Index index)
+    {
+      return m_matrix.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                               m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    inline const Scalar coeff(Index index) const
+    {
+      return m_matrix.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
+                            m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
+    }
+
+    inline const XprType& nestedExpression() const { return m_matrix; }
+    inline XprType& nestedExpression() { return m_matrix; }
+    Index startRow() const { return m_startRow.value(); }
+    Index startCol() const { return m_startCol.value(); }
+    Index blockRows() const { return m_blockRows.value(); }
+    Index blockCols() const { return m_blockCols.value(); }
+
+  protected:
+//     friend class internal::GenericSparseBlockInnerIteratorImpl<XprType,BlockRows,BlockCols,InnerPanel>;
+    friend struct internal::unary_evaluator<Block<XprType,BlockRows,BlockCols,InnerPanel>, internal::IteratorBased, Scalar >;
+
+    Index nonZeros() const { return Dynamic; }
+
+    typename internal::ref_selector<XprType>::non_const_type m_matrix;
+    const internal::variable_if_dynamic<Index, XprType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
+    const internal::variable_if_dynamic<Index, XprType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
+    const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_blockRows;
+    const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_blockCols;
+
+  protected:
+    // Disable assignment with clear error message.
+    // Note that simply removing operator= yields compilation errors with ICC+MSVC
+    template<typename T>
+    BlockImpl& operator=(const T&)
+    {
+      EIGEN_STATIC_ASSERT(sizeof(T)==0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY);
+      return *this;
+    }
+
+};
+
+namespace internal {
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+struct unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased >
+ : public evaluator_base<Block<ArgType,BlockRows,BlockCols,InnerPanel> >
+{
+    class InnerVectorInnerIterator;
+    class OuterVectorInnerIterator;
+  public:
+    typedef Block<ArgType,BlockRows,BlockCols,InnerPanel> XprType;
+    typedef typename XprType::StorageIndex StorageIndex;
+    typedef typename XprType::Scalar Scalar;
+
+    enum {
+      IsRowMajor = XprType::IsRowMajor,
+
+      OuterVector =  (BlockCols==1 && ArgType::IsRowMajor)
+                    | // FIXME | instead of || to please GCC 4.4.0 stupid warning "suggest parentheses around &&".
+                      // revert to || as soon as not needed anymore.
+                     (BlockRows==1 && !ArgType::IsRowMajor),
+
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+
+    typedef typename internal::conditional<OuterVector,OuterVectorInnerIterator,InnerVectorInnerIterator>::type InnerIterator;
+
+    explicit unary_evaluator(const XprType& op)
+      : m_argImpl(op.nestedExpression()), m_block(op)
+    {}
+
+    inline Index nonZerosEstimate() const {
+      const Index nnz = m_block.nonZeros();
+      if(nnz < 0) {
+        // Scale the non-zero estimate for the underlying expression linearly with block size.
+        // Return zero if the underlying block is empty.
+        const Index nested_sz = m_block.nestedExpression().size();        
+        return nested_sz == 0 ? 0 : m_argImpl.nonZerosEstimate() * m_block.size() / nested_sz;
+      }
+      return nnz;
+    }
+
+  protected:
+    typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+
+    evaluator<ArgType> m_argImpl;
+    const XprType &m_block;
+};
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+class unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased>::InnerVectorInnerIterator
+ : public EvalIterator
+{
+  // NOTE MSVC fails to compile if we don't explicitely "import" IsRowMajor from unary_evaluator
+  //      because the base class EvalIterator has a private IsRowMajor enum too. (bug #1786)
+  // NOTE We cannot call it IsRowMajor because it would shadow unary_evaluator::IsRowMajor
+  enum { XprIsRowMajor = unary_evaluator::IsRowMajor };
+  const XprType& m_block;
+  Index m_end;
+public:
+
+  EIGEN_STRONG_INLINE InnerVectorInnerIterator(const unary_evaluator& aEval, Index outer)
+    : EvalIterator(aEval.m_argImpl, outer + (XprIsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol())),
+      m_block(aEval.m_block),
+      m_end(XprIsRowMajor ? aEval.m_block.startCol()+aEval.m_block.blockCols() : aEval.m_block.startRow()+aEval.m_block.blockRows())
+  {
+    while( (EvalIterator::operator bool()) && (EvalIterator::index() < (XprIsRowMajor ? m_block.startCol() : m_block.startRow())) )
+      EvalIterator::operator++();
+  }
+
+  inline StorageIndex index() const { return EvalIterator::index() - convert_index<StorageIndex>(XprIsRowMajor ? m_block.startCol() : m_block.startRow()); }
+  inline Index outer()  const { return EvalIterator::outer() - (XprIsRowMajor ? m_block.startRow() : m_block.startCol()); }
+  inline Index row()    const { return EvalIterator::row()   - m_block.startRow(); }
+  inline Index col()    const { return EvalIterator::col()   - m_block.startCol(); }
+
+  inline operator bool() const { return EvalIterator::operator bool() && EvalIterator::index() < m_end; }
+};
+
+template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
+class unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased>::OuterVectorInnerIterator
+{
+  // NOTE see above
+  enum { XprIsRowMajor = unary_evaluator::IsRowMajor };
+  const unary_evaluator& m_eval;
+  Index m_outerPos;
+  const Index m_innerIndex;
+  Index m_end;
+  EvalIterator m_it;
+public:
+
+  EIGEN_STRONG_INLINE OuterVectorInnerIterator(const unary_evaluator& aEval, Index outer)
+    : m_eval(aEval),
+      m_outerPos( (XprIsRowMajor ? aEval.m_block.startCol() : aEval.m_block.startRow()) ),
+      m_innerIndex(XprIsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol()),
+      m_end(XprIsRowMajor ? aEval.m_block.startCol()+aEval.m_block.blockCols() : aEval.m_block.startRow()+aEval.m_block.blockRows()),
+      m_it(m_eval.m_argImpl, m_outerPos)
+  {
+    EIGEN_UNUSED_VARIABLE(outer);
+    eigen_assert(outer==0);
+
+    while(m_it && m_it.index() < m_innerIndex) ++m_it;
+    if((!m_it) || (m_it.index()!=m_innerIndex))
+      ++(*this);
+  }
+
+  inline StorageIndex index() const { return convert_index<StorageIndex>(m_outerPos - (XprIsRowMajor ? m_eval.m_block.startCol() : m_eval.m_block.startRow())); }
+  inline Index outer()  const { return 0; }
+  inline Index row()    const { return XprIsRowMajor ? 0 : index(); }
+  inline Index col()    const { return XprIsRowMajor ? index() : 0; }
+
+  inline Scalar value() const { return m_it.value(); }
+  inline Scalar& valueRef() { return m_it.valueRef(); }
+
+  inline OuterVectorInnerIterator& operator++()
+  {
+    // search next non-zero entry
+    while(++m_outerPos<m_end)
+    {
+      // Restart iterator at the next inner-vector:
+      m_it.~EvalIterator();
+      ::new (&m_it) EvalIterator(m_eval.m_argImpl, m_outerPos);
+      // search for the key m_innerIndex in the current outer-vector
+      while(m_it && m_it.index() < m_innerIndex) ++m_it;
+      if(m_it && m_it.index()==m_innerIndex) break;
+    }
+    return *this;
+  }
+
+  inline operator bool() const { return m_outerPos < m_end; }
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+struct unary_evaluator<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true>, IteratorBased>
+  : evaluator<SparseCompressedBase<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> > >
+{
+  typedef Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> XprType;
+  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  explicit unary_evaluator(const XprType &xpr) : Base(xpr) {}
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
+struct unary_evaluator<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true>, IteratorBased>
+  : evaluator<SparseCompressedBase<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> > >
+{
+  typedef Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> XprType;
+  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  explicit unary_evaluator(const XprType &xpr) : Base(xpr) {}
+};
+
+} // end namespace internal
+
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_BLOCK_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseColEtree.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseColEtree.h
new file mode 100644
index 00000000..ebe02d1a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseColEtree.h
@@ -0,0 +1,206 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+/* 
+ 
+ * NOTE: This file is the modified version of sp_coletree.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.1) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * August 1, 2008
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSE_COLETREE_H
+#define SPARSE_COLETREE_H
+
+namespace Eigen {
+
+namespace internal {
+
+/** Find the root of the tree/set containing the vertex i : Use Path halving */ 
+template<typename Index, typename IndexVector>
+Index etree_find (Index i, IndexVector& pp)
+{
+  Index p = pp(i); // Parent 
+  Index gp = pp(p); // Grand parent 
+  while (gp != p) 
+  {
+    pp(i) = gp; // Parent pointer on find path is changed to former grand parent
+    i = gp; 
+    p = pp(i);
+    gp = pp(p);
+  }
+  return p; 
+}
+
+/** Compute the column elimination tree of a sparse matrix
+  * \param mat The matrix in column-major format. 
+  * \param parent The elimination tree
+  * \param firstRowElt The column index of the first element in each row
+  * \param perm The permutation to apply to the column of \b mat
+  */
+template <typename MatrixType, typename IndexVector>
+int coletree(const MatrixType& mat, IndexVector& parent, IndexVector& firstRowElt, typename MatrixType::StorageIndex *perm=0)
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  StorageIndex nc = convert_index<StorageIndex>(mat.cols()); // Number of columns
+  StorageIndex m = convert_index<StorageIndex>(mat.rows());
+  StorageIndex diagSize = (std::min)(nc,m);
+  IndexVector root(nc); // root of subtree of etree 
+  root.setZero();
+  IndexVector pp(nc); // disjoint sets 
+  pp.setZero(); // Initialize disjoint sets 
+  parent.resize(mat.cols());
+  //Compute first nonzero column in each row 
+  firstRowElt.resize(m);
+  firstRowElt.setConstant(nc);
+  firstRowElt.segment(0, diagSize).setLinSpaced(diagSize, 0, diagSize-1);
+  bool found_diag;
+  for (StorageIndex col = 0; col < nc; col++)
+  {
+    StorageIndex pcol = col;
+    if(perm) pcol  = perm[col];
+    for (typename MatrixType::InnerIterator it(mat, pcol); it; ++it)
+    { 
+      Index row = it.row();
+      firstRowElt(row) = (std::min)(firstRowElt(row), col);
+    }
+  }
+  /* Compute etree by Liu's algorithm for symmetric matrices,
+          except use (firstRowElt[r],c) in place of an edge (r,c) of A.
+    Thus each row clique in A'*A is replaced by a star
+    centered at its first vertex, which has the same fill. */
+  StorageIndex rset, cset, rroot;
+  for (StorageIndex col = 0; col < nc; col++) 
+  {
+    found_diag = col>=m;
+    pp(col) = col; 
+    cset = col; 
+    root(cset) = col; 
+    parent(col) = nc; 
+    /* The diagonal element is treated here even if it does not exist in the matrix
+     * hence the loop is executed once more */ 
+    StorageIndex pcol = col;
+    if(perm) pcol  = perm[col];
+    for (typename MatrixType::InnerIterator it(mat, pcol); it||!found_diag; ++it)
+    { //  A sequence of interleaved find and union is performed 
+      Index i = col;
+      if(it) i = it.index();
+      if (i == col) found_diag = true;
+      
+      StorageIndex row = firstRowElt(i);
+      if (row >= col) continue; 
+      rset = internal::etree_find(row, pp); // Find the name of the set containing row
+      rroot = root(rset);
+      if (rroot != col) 
+      {
+        parent(rroot) = col; 
+        pp(cset) = rset; 
+        cset = rset; 
+        root(cset) = col; 
+      }
+    }
+  }
+  return 0;  
+}
+
+/** 
+  * Depth-first search from vertex n.  No recursion.
+  * This routine was contributed by Cédric Doucet, CEDRAT Group, Meylan, France.
+*/
+template <typename IndexVector>
+void nr_etdfs (typename IndexVector::Scalar n, IndexVector& parent, IndexVector& first_kid, IndexVector& next_kid, IndexVector& post, typename IndexVector::Scalar postnum)
+{
+  typedef typename IndexVector::Scalar StorageIndex;
+  StorageIndex current = n, first, next;
+  while (postnum != n) 
+  {
+    // No kid for the current node
+    first = first_kid(current);
+    
+    // no kid for the current node
+    if (first == -1) 
+    {
+      // Numbering this node because it has no kid 
+      post(current) = postnum++;
+      
+      // looking for the next kid 
+      next = next_kid(current); 
+      while (next == -1) 
+      {
+        // No more kids : back to the parent node
+        current = parent(current); 
+        // numbering the parent node 
+        post(current) = postnum++;
+        
+        // Get the next kid 
+        next = next_kid(current); 
+      }
+      // stopping criterion 
+      if (postnum == n+1) return; 
+      
+      // Updating current node 
+      current = next; 
+    }
+    else 
+    {
+      current = first; 
+    }
+  }
+}
+
+
+/**
+  * \brief Post order a tree 
+  * \param n the number of nodes
+  * \param parent Input tree
+  * \param post postordered tree
+  */
+template <typename IndexVector>
+void treePostorder(typename IndexVector::Scalar n, IndexVector& parent, IndexVector& post)
+{
+  typedef typename IndexVector::Scalar StorageIndex;
+  IndexVector first_kid, next_kid; // Linked list of children 
+  StorageIndex postnum; 
+  // Allocate storage for working arrays and results 
+  first_kid.resize(n+1); 
+  next_kid.setZero(n+1);
+  post.setZero(n+1);
+  
+  // Set up structure describing children
+  first_kid.setConstant(-1); 
+  for (StorageIndex v = n-1; v >= 0; v--) 
+  {
+    StorageIndex dad = parent(v);
+    next_kid(v) = first_kid(dad); 
+    first_kid(dad) = v; 
+  }
+  
+  // Depth-first search from dummy root vertex #n
+  postnum = 0; 
+  internal::nr_etdfs(n, parent, first_kid, next_kid, post, postnum);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // SPARSE_COLETREE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseCompressedBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseCompressedBase.h
new file mode 100644
index 00000000..6a2c7a8c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseCompressedBase.h
@@ -0,0 +1,370 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_COMPRESSED_BASE_H
+#define EIGEN_SPARSE_COMPRESSED_BASE_H
+
+namespace Eigen { 
+
+template<typename Derived> class SparseCompressedBase;
+  
+namespace internal {
+
+template<typename Derived>
+struct traits<SparseCompressedBase<Derived> > : traits<Derived>
+{};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  * \class SparseCompressedBase
+  * \brief Common base class for sparse [compressed]-{row|column}-storage format.
+  *
+  * This class defines the common interface for all derived classes implementing the compressed sparse storage format, such as:
+  *  - SparseMatrix
+  *  - Ref<SparseMatrixType,Options>
+  *  - Map<SparseMatrixType>
+  *
+  */
+template<typename Derived>
+class SparseCompressedBase
+  : public SparseMatrixBase<Derived>
+{
+  public:
+    typedef SparseMatrixBase<Derived> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(SparseCompressedBase)
+    using Base::operator=;
+    using Base::IsRowMajor;
+    
+    class InnerIterator;
+    class ReverseInnerIterator;
+    
+  protected:
+    typedef typename Base::IndexVector IndexVector;
+    Eigen::Map<IndexVector> innerNonZeros() { return Eigen::Map<IndexVector>(innerNonZeroPtr(), isCompressed()?0:derived().outerSize()); }
+    const  Eigen::Map<const IndexVector> innerNonZeros() const { return Eigen::Map<const IndexVector>(innerNonZeroPtr(), isCompressed()?0:derived().outerSize()); }
+        
+  public:
+    
+    /** \returns the number of non zero coefficients */
+    inline Index nonZeros() const
+    {
+      if(Derived::IsVectorAtCompileTime && outerIndexPtr()==0)
+        return derived().nonZeros();
+      else if(isCompressed())
+        return outerIndexPtr()[derived().outerSize()]-outerIndexPtr()[0];
+      else if(derived().outerSize()==0)
+        return 0;
+      else
+        return innerNonZeros().sum();
+    }
+    
+    /** \returns a const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline const Scalar* valuePtr() const { return derived().valuePtr(); }
+    /** \returns a non-const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline Scalar* valuePtr() { return derived().valuePtr(); }
+
+    /** \returns a const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline const StorageIndex* innerIndexPtr() const { return derived().innerIndexPtr(); }
+    /** \returns a non-const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline StorageIndex* innerIndexPtr() { return derived().innerIndexPtr(); }
+
+    /** \returns a const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 for SparseVector
+      * \sa valuePtr(), innerIndexPtr() */
+    inline const StorageIndex* outerIndexPtr() const { return derived().outerIndexPtr(); }
+    /** \returns a non-const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 for SparseVector
+      * \sa valuePtr(), innerIndexPtr() */
+    inline StorageIndex* outerIndexPtr() { return derived().outerIndexPtr(); }
+
+    /** \returns a const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline const StorageIndex* innerNonZeroPtr() const { return derived().innerNonZeroPtr(); }
+    /** \returns a non-const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline StorageIndex* innerNonZeroPtr() { return derived().innerNonZeroPtr(); }
+    
+    /** \returns whether \c *this is in compressed form. */
+    inline bool isCompressed() const { return innerNonZeroPtr()==0; }
+
+    /** \returns a read-only view of the stored coefficients as a 1D array expression.
+      *
+      * \warning this method is for \b compressed \b storage \b only, and it will trigger an assertion otherwise.
+      *
+      * \sa valuePtr(), isCompressed() */
+    const Map<const Array<Scalar,Dynamic,1> > coeffs() const { eigen_assert(isCompressed()); return Array<Scalar,Dynamic,1>::Map(valuePtr(),nonZeros()); }
+
+    /** \returns a read-write view of the stored coefficients as a 1D array expression
+      *
+      * \warning this method is for \b compressed \b storage \b only, and it will trigger an assertion otherwise.
+      *
+      * Here is an example:
+      * \include SparseMatrix_coeffs.cpp
+      * and the output is:
+      * \include SparseMatrix_coeffs.out
+      *
+      * \sa valuePtr(), isCompressed() */
+    Map<Array<Scalar,Dynamic,1> > coeffs() { eigen_assert(isCompressed()); return Array<Scalar,Dynamic,1>::Map(valuePtr(),nonZeros()); }
+
+  protected:
+    /** Default constructor. Do nothing. */
+    SparseCompressedBase() {}
+
+    /** \internal return the index of the coeff at (row,col) or just before if it does not exist.
+      * This is an analogue of std::lower_bound.
+      */
+    internal::LowerBoundIndex lower_bound(Index row, Index col) const
+    {
+      eigen_internal_assert(row>=0 && row<this->rows() && col>=0 && col<this->cols());
+
+      const Index outer = Derived::IsRowMajor ? row : col;
+      const Index inner = Derived::IsRowMajor ? col : row;
+
+      Index start = this->outerIndexPtr()[outer];
+      Index end = this->isCompressed() ? this->outerIndexPtr()[outer+1] : this->outerIndexPtr()[outer] + this->innerNonZeroPtr()[outer];
+      eigen_assert(end>=start && "you are using a non finalized sparse matrix or written coefficient does not exist");
+      internal::LowerBoundIndex p;
+      p.value = std::lower_bound(this->innerIndexPtr()+start, this->innerIndexPtr()+end,inner) - this->innerIndexPtr();
+      p.found = (p.value<end) && (this->innerIndexPtr()[p.value]==inner);
+      return p;
+    }
+
+    friend struct internal::evaluator<SparseCompressedBase<Derived> >;
+
+  private:
+    template<typename OtherDerived> explicit SparseCompressedBase(const SparseCompressedBase<OtherDerived>&);
+};
+
+template<typename Derived>
+class SparseCompressedBase<Derived>::InnerIterator
+{
+  public:
+    InnerIterator()
+      : m_values(0), m_indices(0), m_outer(0), m_id(0), m_end(0)
+    {}
+
+    InnerIterator(const InnerIterator& other)
+      : m_values(other.m_values), m_indices(other.m_indices), m_outer(other.m_outer), m_id(other.m_id), m_end(other.m_end)
+    {}
+
+    InnerIterator& operator=(const InnerIterator& other)
+    {
+      m_values = other.m_values;
+      m_indices = other.m_indices;
+      const_cast<OuterType&>(m_outer).setValue(other.m_outer.value());
+      m_id = other.m_id;
+      m_end = other.m_end;
+      return *this;
+    }
+
+    InnerIterator(const SparseCompressedBase& mat, Index outer)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer)
+    {
+      if(Derived::IsVectorAtCompileTime && mat.outerIndexPtr()==0)
+      {
+        m_id = 0;
+        m_end = mat.nonZeros();
+      }
+      else
+      {
+        m_id = mat.outerIndexPtr()[outer];
+        if(mat.isCompressed())
+          m_end = mat.outerIndexPtr()[outer+1];
+        else
+          m_end = m_id + mat.innerNonZeroPtr()[outer];
+      }
+    }
+
+    explicit InnerIterator(const SparseCompressedBase& mat)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(0), m_id(0), m_end(mat.nonZeros())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    explicit InnerIterator(const internal::CompressedStorage<Scalar,StorageIndex>& data)
+      : m_values(data.valuePtr()), m_indices(data.indexPtr()), m_outer(0), m_id(0), m_end(data.size())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    inline InnerIterator& operator++() { m_id++; return *this; }
+    inline InnerIterator& operator+=(Index i) { m_id += i ; return *this; }
+
+    inline InnerIterator operator+(Index i) 
+    { 
+        InnerIterator result = *this;
+        result += i;
+        return result;
+    }
+
+    inline const Scalar& value() const { return m_values[m_id]; }
+    inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id]); }
+
+    inline StorageIndex index() const { return m_indices[m_id]; }
+    inline Index outer() const { return m_outer.value(); }
+    inline Index row() const { return IsRowMajor ? m_outer.value() : index(); }
+    inline Index col() const { return IsRowMajor ? index() : m_outer.value(); }
+
+    inline operator bool() const { return (m_id < m_end); }
+
+  protected:
+    const Scalar* m_values;
+    const StorageIndex* m_indices;
+    typedef internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTime?0:Dynamic> OuterType;
+    const OuterType m_outer;
+    Index m_id;
+    Index m_end;
+  private:
+    // If you get here, then you're not using the right InnerIterator type, e.g.:
+    //   SparseMatrix<double,RowMajor> A;
+    //   SparseMatrix<double>::InnerIterator it(A,0);
+    template<typename T> InnerIterator(const SparseMatrixBase<T>&, Index outer);
+};
+
+template<typename Derived>
+class SparseCompressedBase<Derived>::ReverseInnerIterator
+{
+  public:
+    ReverseInnerIterator(const SparseCompressedBase& mat, Index outer)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer)
+    {
+      if(Derived::IsVectorAtCompileTime && mat.outerIndexPtr()==0)
+      {
+        m_start = 0;
+        m_id = mat.nonZeros();
+      }
+      else
+      {
+        m_start = mat.outerIndexPtr()[outer];
+        if(mat.isCompressed())
+          m_id = mat.outerIndexPtr()[outer+1];
+        else
+          m_id = m_start + mat.innerNonZeroPtr()[outer];
+      }
+    }
+
+    explicit ReverseInnerIterator(const SparseCompressedBase& mat)
+      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(0), m_start(0), m_id(mat.nonZeros())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    explicit ReverseInnerIterator(const internal::CompressedStorage<Scalar,StorageIndex>& data)
+      : m_values(data.valuePtr()), m_indices(data.indexPtr()), m_outer(0), m_start(0), m_id(data.size())
+    {
+      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    }
+
+    inline ReverseInnerIterator& operator--() { --m_id; return *this; }
+    inline ReverseInnerIterator& operator-=(Index i) { m_id -= i; return *this; }
+
+    inline ReverseInnerIterator operator-(Index i) 
+    {
+        ReverseInnerIterator result = *this;
+        result -= i;
+        return result;
+    }
+
+    inline const Scalar& value() const { return m_values[m_id-1]; }
+    inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id-1]); }
+
+    inline StorageIndex index() const { return m_indices[m_id-1]; }
+    inline Index outer() const { return m_outer.value(); }
+    inline Index row() const { return IsRowMajor ? m_outer.value() : index(); }
+    inline Index col() const { return IsRowMajor ? index() : m_outer.value(); }
+
+    inline operator bool() const { return (m_id > m_start); }
+
+  protected:
+    const Scalar* m_values;
+    const StorageIndex* m_indices;
+    typedef internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTime?0:Dynamic> OuterType;
+    const OuterType m_outer;
+    Index m_start;
+    Index m_id;
+};
+
+namespace internal {
+
+template<typename Derived>
+struct evaluator<SparseCompressedBase<Derived> >
+  : evaluator_base<Derived>
+{
+  typedef typename Derived::Scalar Scalar;
+  typedef typename Derived::InnerIterator InnerIterator;
+  
+  enum {
+    CoeffReadCost = NumTraits<Scalar>::ReadCost,
+    Flags = Derived::Flags
+  };
+  
+  evaluator() : m_matrix(0), m_zero(0)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  explicit evaluator(const Derived &mat) : m_matrix(&mat), m_zero(0)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_matrix->nonZeros();
+  }
+  
+  operator Derived&() { return m_matrix->const_cast_derived(); }
+  operator const Derived&() const { return *m_matrix; }
+  
+  typedef typename DenseCoeffsBase<Derived,ReadOnlyAccessors>::CoeffReturnType CoeffReturnType;
+  const Scalar& coeff(Index row, Index col) const
+  {
+    Index p = find(row,col);
+
+    if(p==Dynamic)
+      return m_zero;
+    else
+      return m_matrix->const_cast_derived().valuePtr()[p];
+  }
+
+  Scalar& coeffRef(Index row, Index col)
+  {
+    Index p = find(row,col);
+    eigen_assert(p!=Dynamic && "written coefficient does not exist");
+    return m_matrix->const_cast_derived().valuePtr()[p];
+  }
+
+protected:
+
+  Index find(Index row, Index col) const
+  {
+    internal::LowerBoundIndex p = m_matrix->lower_bound(row,col);
+    return p.found ? p.value : Dynamic;
+  }
+
+  const Derived *m_matrix;
+  const Scalar m_zero;
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_COMPRESSED_BASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseCwiseBinaryOp.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
new file mode 100644
index 00000000..9b0d3f98
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
@@ -0,0 +1,722 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_CWISE_BINARY_OP_H
+#define EIGEN_SPARSE_CWISE_BINARY_OP_H
+
+namespace Eigen { 
+
+// Here we have to handle 3 cases:
+//  1 - sparse op dense
+//  2 - dense op sparse
+//  3 - sparse op sparse
+// We also need to implement a 4th iterator for:
+//  4 - dense op dense
+// Finally, we also need to distinguish between the product and other operations :
+//                configuration      returned mode
+//  1 - sparse op dense    product      sparse
+//                         generic      dense
+//  2 - dense op sparse    product      sparse
+//                         generic      dense
+//  3 - sparse op sparse   product      sparse
+//                         generic      sparse
+//  4 - dense op dense     product      dense
+//                         generic      dense
+//
+// TODO to ease compiler job, we could specialize product/quotient with a scalar
+//      and fallback to cwise-unary evaluator using bind1st_op and bind2nd_op.
+
+template<typename BinaryOp, typename Lhs, typename Rhs>
+class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Sparse>
+  : public SparseMatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+  public:
+    typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived;
+    typedef SparseMatrixBase<Derived> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Derived)
+    CwiseBinaryOpImpl()
+    {
+      EIGEN_STATIC_ASSERT((
+                (!internal::is_same<typename internal::traits<Lhs>::StorageKind,
+                                    typename internal::traits<Rhs>::StorageKind>::value)
+            ||  ((internal::evaluator<Lhs>::Flags&RowMajorBit) == (internal::evaluator<Rhs>::Flags&RowMajorBit))),
+            THE_STORAGE_ORDER_OF_BOTH_SIDES_MUST_MATCH);
+    }
+};
+
+namespace internal {
+
+  
+// Generic "sparse OP sparse"
+template<typename XprType> struct binary_sparse_evaluator;
+
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IteratorBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+protected:
+  typedef typename evaluator<Lhs>::InnerIterator  LhsIterator;
+  typedef typename evaluator<Rhs>::InnerIterator  RhsIterator;
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+public:
+
+  class InnerIterator
+  {
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor)
+    {
+      this->operator++();
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      if (m_lhsIter && m_rhsIter && (m_lhsIter.index() == m_rhsIter.index()))
+      {
+        m_id = m_lhsIter.index();
+        m_value = m_functor(m_lhsIter.value(), m_rhsIter.value());
+        ++m_lhsIter;
+        ++m_rhsIter;
+      }
+      else if (m_lhsIter && (!m_rhsIter || (m_lhsIter.index() < m_rhsIter.index())))
+      {
+        m_id = m_lhsIter.index();
+        m_value = m_functor(m_lhsIter.value(), Scalar(0));
+        ++m_lhsIter;
+      }
+      else if (m_rhsIter && (!m_lhsIter || (m_lhsIter.index() > m_rhsIter.index())))
+      {
+        m_id = m_rhsIter.index();
+        m_value = m_functor(Scalar(0), m_rhsIter.value());
+        ++m_rhsIter;
+      }
+      else
+      {
+        m_value = Scalar(0); // this is to avoid a compilation warning
+        m_id = -1;
+      }
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return m_value; }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return Lhs::IsRowMajor ? m_lhsIter.row() : index(); }
+    EIGEN_STRONG_INLINE Index col() const { return Lhs::IsRowMajor ? index() : m_lhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_id>=0; }
+
+  protected:
+    LhsIterator m_lhsIter;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+    Scalar m_value;
+    StorageIndex m_id;
+  };
+  
+  
+  enum {
+    CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluator<Rhs>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+  
+  explicit binary_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_lhsImpl.nonZerosEstimate() + m_rhsImpl.nonZerosEstimate();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<Lhs> m_lhsImpl;
+  evaluator<Rhs> m_rhsImpl;
+};
+
+// dense op sparse
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IteratorBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+protected:
+  typedef typename evaluator<Rhs>::InnerIterator  RhsIterator;
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(Rhs::Flags)&RowMajorBit)==RowMajorBit };
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
+      : m_lhsEval(aEval.m_lhsImpl), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor), m_value(0), m_id(-1), m_innerSize(aEval.m_expr.rhs().innerSize())
+    {
+      this->operator++();
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_id;
+      if(m_id<m_innerSize)
+      {
+        Scalar lhsVal = m_lhsEval.coeff(IsRowMajor?m_rhsIter.outer():m_id,
+                                        IsRowMajor?m_id:m_rhsIter.outer());
+        if(m_rhsIter && m_rhsIter.index()==m_id)
+        {
+          m_value = m_functor(lhsVal, m_rhsIter.value());
+          ++m_rhsIter;
+        }
+        else
+          m_value = m_functor(lhsVal, Scalar(0));
+      }
+
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const { eigen_internal_assert(m_id<m_innerSize); return m_value; }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
+    EIGEN_STRONG_INLINE Index outer() const { return m_rhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return IsRowMajor ? m_rhsIter.outer() : m_id; }
+    EIGEN_STRONG_INLINE Index col() const { return IsRowMajor ? m_id : m_rhsIter.outer(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_id<m_innerSize; }
+
+  protected:
+    const evaluator<Lhs> &m_lhsEval;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+    Scalar m_value;
+    StorageIndex m_id;
+    StorageIndex m_innerSize;
+  };
+
+
+  enum {
+    CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluator<Rhs>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+
+  explicit binary_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()),
+      m_rhsImpl(xpr.rhs()),
+      m_expr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  inline Index nonZerosEstimate() const {
+    return m_expr.size();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<Lhs> m_lhsImpl;
+  evaluator<Rhs> m_rhsImpl;
+  const XprType &m_expr;
+};
+
+// sparse op dense
+template<typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IndexBased>
+  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
+{
+protected:
+  typedef typename evaluator<Lhs>::InnerIterator  LhsIterator;
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  typedef typename traits<XprType>::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(Lhs::Flags)&RowMajorBit)==RowMajorBit };
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsEval(aEval.m_rhsImpl), m_functor(aEval.m_functor), m_value(0), m_id(-1), m_innerSize(aEval.m_expr.lhs().innerSize())
+    {
+      this->operator++();
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_id;
+      if(m_id<m_innerSize)
+      {
+        Scalar rhsVal = m_rhsEval.coeff(IsRowMajor?m_lhsIter.outer():m_id,
+                                        IsRowMajor?m_id:m_lhsIter.outer());
+        if(m_lhsIter && m_lhsIter.index()==m_id)
+        {
+          m_value = m_functor(m_lhsIter.value(), rhsVal);
+          ++m_lhsIter;
+        }
+        else
+          m_value = m_functor(Scalar(0),rhsVal);
+      }
+
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const { eigen_internal_assert(m_id<m_innerSize); return m_value; }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return IsRowMajor ? m_lhsIter.outer() : m_id; }
+    EIGEN_STRONG_INLINE Index col() const { return IsRowMajor ? m_id : m_lhsIter.outer(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_id<m_innerSize; }
+
+  protected:
+    LhsIterator m_lhsIter;
+    const evaluator<Rhs> &m_rhsEval;
+    const BinaryOp& m_functor;
+    Scalar m_value;
+    StorageIndex m_id;
+    StorageIndex m_innerSize;
+  };
+
+
+  enum {
+    CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluator<Rhs>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+
+  explicit binary_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()),
+      m_rhsImpl(xpr.rhs()),
+      m_expr(xpr)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+
+  inline Index nonZerosEstimate() const {
+    return m_expr.size();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<Lhs> m_lhsImpl;
+  evaluator<Rhs> m_rhsImpl;
+  const XprType &m_expr;
+};
+
+template<typename T,
+         typename LhsKind   = typename evaluator_traits<typename T::Lhs>::Kind,
+         typename RhsKind   = typename evaluator_traits<typename T::Rhs>::Kind,
+         typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
+         typename RhsScalar = typename traits<typename T::Rhs>::Scalar> struct sparse_conjunction_evaluator;
+
+// "sparse .* sparse"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IteratorBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "dense .* sparse"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IndexBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "sparse .* dense"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IteratorBased, IndexBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// "sparse ./ dense"
+template<typename T1, typename T2, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_quotient_op<T1,T2>, Lhs, Rhs>, IteratorBased, IndexBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_quotient_op<T1,T2>, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_quotient_op<T1,T2>, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// "sparse && sparse"
+template<typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IteratorBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "dense && sparse"
+template<typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IndexBased, IteratorBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+// "sparse && dense"
+template<typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IteratorBased, IndexBased>
+  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
+{
+  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
+  typedef sparse_conjunction_evaluator<XprType> Base;
+  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// "sparse ^ sparse"
+template<typename XprType>
+struct sparse_conjunction_evaluator<XprType, IteratorBased, IteratorBased>
+  : evaluator_base<XprType>
+{
+protected:
+  typedef typename XprType::Functor BinaryOp;
+  typedef typename XprType::Lhs LhsArg;
+  typedef typename XprType::Rhs RhsArg;
+  typedef typename evaluator<LhsArg>::InnerIterator  LhsIterator;
+  typedef typename evaluator<RhsArg>::InnerIterator  RhsIterator;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename traits<XprType>::Scalar Scalar;
+public:
+
+  class InnerIterator
+  {
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor)
+    {
+      while (m_lhsIter && m_rhsIter && (m_lhsIter.index() != m_rhsIter.index()))
+      {
+        if (m_lhsIter.index() < m_rhsIter.index())
+          ++m_lhsIter;
+        else
+          ++m_rhsIter;
+      }
+    }
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_lhsIter;
+      ++m_rhsIter;
+      while (m_lhsIter && m_rhsIter && (m_lhsIter.index() != m_rhsIter.index()))
+      {
+        if (m_lhsIter.index() < m_rhsIter.index())
+          ++m_lhsIter;
+        else
+          ++m_rhsIter;
+      }
+      return *this;
+    }
+    
+    EIGEN_STRONG_INLINE Scalar value() const { return m_functor(m_lhsIter.value(), m_rhsIter.value()); }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_lhsIter.index(); }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return m_lhsIter.row(); }
+    EIGEN_STRONG_INLINE Index col() const { return m_lhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return (m_lhsIter && m_rhsIter); }
+
+  protected:
+    LhsIterator m_lhsIter;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+  };
+  
+  
+  enum {
+    CoeffReadCost = int(evaluator<LhsArg>::CoeffReadCost) + int(evaluator<RhsArg>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+  
+  explicit sparse_conjunction_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return (std::min)(m_lhsImpl.nonZerosEstimate(), m_rhsImpl.nonZerosEstimate());
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<LhsArg> m_lhsImpl;
+  evaluator<RhsArg> m_rhsImpl;
+};
+
+// "dense ^ sparse"
+template<typename XprType>
+struct sparse_conjunction_evaluator<XprType, IndexBased, IteratorBased>
+  : evaluator_base<XprType>
+{
+protected:
+  typedef typename XprType::Functor BinaryOp;
+  typedef typename XprType::Lhs LhsArg;
+  typedef typename XprType::Rhs RhsArg;
+  typedef evaluator<LhsArg> LhsEvaluator;
+  typedef typename evaluator<RhsArg>::InnerIterator  RhsIterator;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename traits<XprType>::Scalar Scalar;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(RhsArg::Flags)&RowMajorBit)==RowMajorBit };
+
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
+      : m_lhsEval(aEval.m_lhsImpl), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor), m_outer(outer)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_rhsIter;
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const
+    { return m_functor(m_lhsEval.coeff(IsRowMajor?m_outer:m_rhsIter.index(),IsRowMajor?m_rhsIter.index():m_outer), m_rhsIter.value()); }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_rhsIter.index(); }
+    EIGEN_STRONG_INLINE Index outer() const { return m_rhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return m_rhsIter.row(); }
+    EIGEN_STRONG_INLINE Index col() const { return m_rhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_rhsIter; }
+    
+  protected:
+    const LhsEvaluator &m_lhsEval;
+    RhsIterator m_rhsIter;
+    const BinaryOp& m_functor;
+    const Index m_outer;
+  };
+  
+  
+  enum {
+    CoeffReadCost = int(evaluator<LhsArg>::CoeffReadCost) + int(evaluator<RhsArg>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+  
+  explicit sparse_conjunction_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_rhsImpl.nonZerosEstimate();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<LhsArg> m_lhsImpl;
+  evaluator<RhsArg> m_rhsImpl;
+};
+
+// "sparse ^ dense"
+template<typename XprType>
+struct sparse_conjunction_evaluator<XprType, IteratorBased, IndexBased>
+  : evaluator_base<XprType>
+{
+protected:
+  typedef typename XprType::Functor BinaryOp;
+  typedef typename XprType::Lhs LhsArg;
+  typedef typename XprType::Rhs RhsArg;
+  typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
+  typedef evaluator<RhsArg> RhsEvaluator;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename traits<XprType>::Scalar Scalar;
+public:
+
+  class InnerIterator
+  {
+    enum { IsRowMajor = (int(LhsArg::Flags)&RowMajorBit)==RowMajorBit };
+
+  public:
+    
+    EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
+      : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsEval(aEval.m_rhsImpl), m_functor(aEval.m_functor), m_outer(outer)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    {
+      ++m_lhsIter;
+      return *this;
+    }
+
+    EIGEN_STRONG_INLINE Scalar value() const
+    { return m_functor(m_lhsIter.value(),
+                       m_rhsEval.coeff(IsRowMajor?m_outer:m_lhsIter.index(),IsRowMajor?m_lhsIter.index():m_outer)); }
+
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_lhsIter.index(); }
+    EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
+    EIGEN_STRONG_INLINE Index row() const { return m_lhsIter.row(); }
+    EIGEN_STRONG_INLINE Index col() const { return m_lhsIter.col(); }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_lhsIter; }
+    
+  protected:
+    LhsIterator m_lhsIter;
+    const evaluator<RhsArg> &m_rhsEval;
+    const BinaryOp& m_functor;
+    const Index m_outer;
+  };
+  
+  
+  enum {
+    CoeffReadCost = int(evaluator<LhsArg>::CoeffReadCost) + int(evaluator<RhsArg>::CoeffReadCost) + int(functor_traits<BinaryOp>::Cost),
+    Flags = XprType::Flags
+  };
+  
+  explicit sparse_conjunction_evaluator(const XprType& xpr)
+    : m_functor(xpr.functor()),
+      m_lhsImpl(xpr.lhs()), 
+      m_rhsImpl(xpr.rhs())  
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_lhsImpl.nonZerosEstimate();
+  }
+
+protected:
+  const BinaryOp m_functor;
+  evaluator<LhsArg> m_lhsImpl;
+  evaluator<RhsArg> m_rhsImpl;
+};
+
+}
+
+/***************************************************************************
+* Implementation of SparseMatrixBase and SparseCwise functions/operators
+***************************************************************************/
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator+=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator-=(const EigenBase<OtherDerived> &other)
+{
+  call_assignment(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_STRONG_INLINE Derived &
+SparseMatrixBase<Derived>::operator-=(const SparseMatrixBase<OtherDerived> &other)
+{
+  return derived() = derived() - other.derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_STRONG_INLINE Derived &
+SparseMatrixBase<Derived>::operator+=(const SparseMatrixBase<OtherDerived>& other)
+{
+  return derived() = derived() + other.derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator+=(const DiagonalBase<OtherDerived>& other)
+{
+  call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator-=(const DiagonalBase<OtherDerived>& other)
+{
+  call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
+  return derived();
+}
+    
+template<typename Derived>
+template<typename OtherDerived>
+EIGEN_STRONG_INLINE const typename SparseMatrixBase<Derived>::template CwiseProductDenseReturnType<OtherDerived>::Type
+SparseMatrixBase<Derived>::cwiseProduct(const MatrixBase<OtherDerived> &other) const
+{
+  return typename CwiseProductDenseReturnType<OtherDerived>::Type(derived(), other.derived());
+}
+
+template<typename DenseDerived, typename SparseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>
+operator+(const MatrixBase<DenseDerived> &a, const SparseMatrixBase<SparseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
+}
+
+template<typename SparseDerived, typename DenseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>
+operator+(const SparseMatrixBase<SparseDerived> &a, const MatrixBase<DenseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
+}
+
+template<typename DenseDerived, typename SparseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>
+operator-(const MatrixBase<DenseDerived> &a, const SparseMatrixBase<SparseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
+}
+
+template<typename SparseDerived, typename DenseDerived>
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>
+operator-(const SparseMatrixBase<SparseDerived> &a, const MatrixBase<DenseDerived> &b)
+{
+  return CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_CWISE_BINARY_OP_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseCwiseUnaryOp.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseCwiseUnaryOp.h
new file mode 100644
index 00000000..32dac0f7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseCwiseUnaryOp.h
@@ -0,0 +1,150 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_CWISE_UNARY_OP_H
+#define EIGEN_SPARSE_CWISE_UNARY_OP_H
+
+namespace Eigen { 
+
+namespace internal {
+  
+template<typename UnaryOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>
+  : public evaluator_base<CwiseUnaryOp<UnaryOp,ArgType> >
+{
+  public:
+    typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;
+
+    class InnerIterator;
+    
+    enum {
+      CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<UnaryOp>::Cost),
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression())
+    {
+      EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
+      EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+    }
+    
+    inline Index nonZerosEstimate() const {
+      return m_argImpl.nonZerosEstimate();
+    }
+
+  protected:
+    typedef typename evaluator<ArgType>::InnerIterator        EvalIterator;
+    
+    const UnaryOp m_functor;
+    evaluator<ArgType> m_argImpl;
+};
+
+template<typename UnaryOp, typename ArgType>
+class unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>::InnerIterator
+    : public unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>::EvalIterator
+{
+  protected:
+    typedef typename XprType::Scalar Scalar;
+    typedef typename unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, IteratorBased>::EvalIterator Base;
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
+      : Base(unaryOp.m_argImpl,outer), m_functor(unaryOp.m_functor)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    { Base::operator++(); return *this; }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return m_functor(Base::value()); }
+
+  protected:
+    const UnaryOp m_functor;
+  private:
+    Scalar& valueRef();
+};
+
+template<typename ViewOp, typename ArgType>
+struct unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>
+  : public evaluator_base<CwiseUnaryView<ViewOp,ArgType> >
+{
+  public:
+    typedef CwiseUnaryView<ViewOp, ArgType> XprType;
+
+    class InnerIterator;
+    
+    enum {
+      CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<ViewOp>::Cost),
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression())
+    {
+      EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<ViewOp>::Cost);
+      EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+    }
+
+  protected:
+    typedef typename evaluator<ArgType>::InnerIterator        EvalIterator;
+    
+    const ViewOp m_functor;
+    evaluator<ArgType> m_argImpl;
+};
+
+template<typename ViewOp, typename ArgType>
+class unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>::InnerIterator
+    : public unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>::EvalIterator
+{
+  protected:
+    typedef typename XprType::Scalar Scalar;
+    typedef typename unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, IteratorBased>::EvalIterator Base;
+  public:
+
+    EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
+      : Base(unaryOp.m_argImpl,outer), m_functor(unaryOp.m_functor)
+    {}
+
+    EIGEN_STRONG_INLINE InnerIterator& operator++()
+    { Base::operator++(); return *this; }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return m_functor(Base::value()); }
+    EIGEN_STRONG_INLINE Scalar& valueRef() { return m_functor(Base::valueRef()); }
+
+  protected:
+    const ViewOp m_functor;
+};
+
+} // end namespace internal
+
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+SparseMatrixBase<Derived>::operator*=(const Scalar& other)
+{
+  typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
+  internal::evaluator<Derived> thisEval(derived());
+  for (Index j=0; j<outerSize(); ++j)
+    for (EvalIterator i(thisEval,j); i; ++i)
+      i.valueRef() *= other;
+  return derived();
+}
+
+template<typename Derived>
+EIGEN_STRONG_INLINE Derived&
+SparseMatrixBase<Derived>::operator/=(const Scalar& other)
+{
+  typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
+  internal::evaluator<Derived> thisEval(derived());
+  for (Index j=0; j<outerSize(); ++j)
+    for (EvalIterator i(thisEval,j); i; ++i)
+      i.valueRef() /= other;
+  return derived();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_CWISE_UNARY_OP_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseDenseProduct.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseDenseProduct.h
new file mode 100644
index 00000000..f005a18a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseDenseProduct.h
@@ -0,0 +1,342 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEDENSEPRODUCT_H
+#define EIGEN_SPARSEDENSEPRODUCT_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template <> struct product_promote_storage_type<Sparse,Dense, OuterProduct> { typedef Sparse ret; };
+template <> struct product_promote_storage_type<Dense,Sparse, OuterProduct> { typedef Sparse ret; };
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType,
+         typename AlphaType,
+         int LhsStorageOrder = ((SparseLhsType::Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor,
+         bool ColPerCol = ((DenseRhsType::Flags&RowMajorBit)==0) || DenseRhsType::ColsAtCompileTime==1>
+struct sparse_time_dense_product_impl;
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, typename DenseResType::Scalar, RowMajor, true>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef typename evaluator<Lhs>::InnerIterator LhsInnerIterator;
+  typedef evaluator<Lhs> LhsEval;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
+  {
+    LhsEval lhsEval(lhs);
+    
+    Index n = lhs.outerSize();
+#ifdef EIGEN_HAS_OPENMP
+    Eigen::initParallel();
+    Index threads = Eigen::nbThreads();
+#endif
+    
+    for(Index c=0; c<rhs.cols(); ++c)
+    {
+#ifdef EIGEN_HAS_OPENMP
+      // This 20000 threshold has been found experimentally on 2D and 3D Poisson problems.
+      // It basically represents the minimal amount of work to be done to be worth it.
+      if(threads>1 && lhsEval.nonZerosEstimate() > 20000)
+      {
+        #pragma omp parallel for schedule(dynamic,(n+threads*4-1)/(threads*4)) num_threads(threads)
+        for(Index i=0; i<n; ++i)
+          processRow(lhsEval,rhs,res,alpha,i,c);
+      }
+      else
+#endif
+      {
+        for(Index i=0; i<n; ++i)
+          processRow(lhsEval,rhs,res,alpha,i,c);
+      }
+    }
+  }
+  
+  static void processRow(const LhsEval& lhsEval, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha, Index i, Index col)
+  {
+    typename Res::Scalar tmp(0);
+    for(LhsInnerIterator it(lhsEval,i); it ;++it)
+      tmp += it.value() * rhs.coeff(it.index(),col);
+    res.coeffRef(i,col) += alpha * tmp;
+  }
+  
+};
+
+// FIXME: what is the purpose of the following specialization? Is it for the BlockedSparse format?
+// -> let's disable it for now as it is conflicting with generic scalar*matrix and matrix*scalar operators
+// template<typename T1, typename T2/*, int _Options, typename _StrideType*/>
+// struct ScalarBinaryOpTraits<T1, Ref<T2/*, _Options, _StrideType*/> >
+// {
+//   enum {
+//     Defined = 1
+//   };
+//   typedef typename CwiseUnaryOp<scalar_multiple2_op<T1, typename T2::Scalar>, T2>::PlainObject ReturnType;
+// };
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, AlphaType, ColMajor, true>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename LhsEval::InnerIterator LhsInnerIterator;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index c=0; c<rhs.cols(); ++c)
+    {
+      for(Index j=0; j<lhs.outerSize(); ++j)
+      {
+//        typename Res::Scalar rhs_j = alpha * rhs.coeff(j,c);
+        typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha * rhs.coeff(j,c));
+        for(LhsInnerIterator it(lhsEval,j); it ;++it)
+          res.coeffRef(it.index(),c) += it.value() * rhs_j;
+      }
+    }
+  }
+};
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, typename DenseResType::Scalar, RowMajor, false>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename LhsEval::InnerIterator LhsInnerIterator;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
+  {
+    Index n = lhs.rows();
+    LhsEval lhsEval(lhs);
+
+#ifdef EIGEN_HAS_OPENMP
+    Eigen::initParallel();
+    Index threads = Eigen::nbThreads();
+    // This 20000 threshold has been found experimentally on 2D and 3D Poisson problems.
+    // It basically represents the minimal amount of work to be done to be worth it.
+    if(threads>1 && lhsEval.nonZerosEstimate()*rhs.cols() > 20000)
+    {
+      #pragma omp parallel for schedule(dynamic,(n+threads*4-1)/(threads*4)) num_threads(threads)
+      for(Index i=0; i<n; ++i)
+        processRow(lhsEval,rhs,res,alpha,i);
+    }
+    else
+#endif
+    {
+      for(Index i=0; i<n; ++i)
+        processRow(lhsEval, rhs, res, alpha, i);
+    }
+  }
+
+  static void processRow(const LhsEval& lhsEval, const DenseRhsType& rhs, Res& res, const typename Res::Scalar& alpha, Index i)
+  {
+    typename Res::RowXpr res_i(res.row(i));
+    for(LhsInnerIterator it(lhsEval,i); it ;++it)
+      res_i += (alpha*it.value()) * rhs.row(it.index());
+  }
+};
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType>
+struct sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, typename DenseResType::Scalar, ColMajor, false>
+{
+  typedef typename internal::remove_all<SparseLhsType>::type Lhs;
+  typedef typename internal::remove_all<DenseRhsType>::type Rhs;
+  typedef typename internal::remove_all<DenseResType>::type Res;
+  typedef typename evaluator<Lhs>::InnerIterator LhsInnerIterator;
+  static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
+  {
+    evaluator<Lhs> lhsEval(lhs);
+    for(Index j=0; j<lhs.outerSize(); ++j)
+    {
+      typename Rhs::ConstRowXpr rhs_j(rhs.row(j));
+      for(LhsInnerIterator it(lhsEval,j); it ;++it)
+        res.row(it.index()) += (alpha*it.value()) * rhs_j;
+    }
+  }
+};
+
+template<typename SparseLhsType, typename DenseRhsType, typename DenseResType,typename AlphaType>
+inline void sparse_time_dense_product(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
+{
+  sparse_time_dense_product_impl<SparseLhsType,DenseRhsType,DenseResType, AlphaType>::run(lhs, rhs, res, alpha);
+}
+
+} // end namespace internal
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseShape, DenseShape, ProductType>
+ : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,SparseShape,DenseShape,ProductType> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    typedef typename nested_eval<Lhs,((Rhs::Flags&RowMajorBit)==0) ? 1 : Rhs::ColsAtCompileTime>::type LhsNested;
+    typedef typename nested_eval<Rhs,((Lhs::Flags&RowMajorBit)==0) ? 1 : Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    internal::sparse_time_dense_product(lhsNested, rhsNested, dst, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseTriangularShape, DenseShape, ProductType>
+  : generic_product_impl<Lhs, Rhs, SparseShape, DenseShape, ProductType>
+{};
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, DenseShape, SparseShape, ProductType>
+  : generic_product_impl_base<Lhs,Rhs,generic_product_impl<Lhs,Rhs,DenseShape,SparseShape,ProductType> >
+{
+  typedef typename Product<Lhs,Rhs>::Scalar Scalar;
+  
+  template<typename Dst>
+  static void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
+  {
+    typedef typename nested_eval<Lhs,((Rhs::Flags&RowMajorBit)==0) ? Dynamic : 1>::type LhsNested;
+    typedef typename nested_eval<Rhs,((Lhs::Flags&RowMajorBit)==RowMajorBit) ? 1 : Lhs::RowsAtCompileTime>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    
+    // transpose everything
+    Transpose<Dst> dstT(dst);
+    internal::sparse_time_dense_product(rhsNested.transpose(), lhsNested.transpose(), dstT, alpha);
+  }
+};
+
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, DenseShape, SparseTriangularShape, ProductType>
+  : generic_product_impl<Lhs, Rhs, DenseShape, SparseShape, ProductType>
+{};
+
+template<typename LhsT, typename RhsT, bool NeedToTranspose>
+struct sparse_dense_outer_product_evaluator
+{
+protected:
+  typedef typename conditional<NeedToTranspose,RhsT,LhsT>::type Lhs1;
+  typedef typename conditional<NeedToTranspose,LhsT,RhsT>::type ActualRhs;
+  typedef Product<LhsT,RhsT,DefaultProduct> ProdXprType;
+  
+  // if the actual left-hand side is a dense vector,
+  // then build a sparse-view so that we can seamlessly iterate over it.
+  typedef typename conditional<is_same<typename internal::traits<Lhs1>::StorageKind,Sparse>::value,
+            Lhs1, SparseView<Lhs1> >::type ActualLhs;
+  typedef typename conditional<is_same<typename internal::traits<Lhs1>::StorageKind,Sparse>::value,
+            Lhs1 const&, SparseView<Lhs1> >::type LhsArg;
+            
+  typedef evaluator<ActualLhs> LhsEval;
+  typedef evaluator<ActualRhs> RhsEval;
+  typedef typename evaluator<ActualLhs>::InnerIterator LhsIterator;
+  typedef typename ProdXprType::Scalar Scalar;
+  
+public:
+  enum {
+    Flags = NeedToTranspose ? RowMajorBit : 0,
+    CoeffReadCost = HugeCost
+  };
+  
+  class InnerIterator : public LhsIterator
+  {
+  public:
+    InnerIterator(const sparse_dense_outer_product_evaluator &xprEval, Index outer)
+      : LhsIterator(xprEval.m_lhsXprImpl, 0),
+        m_outer(outer),
+        m_empty(false),
+        m_factor(get(xprEval.m_rhsXprImpl, outer, typename internal::traits<ActualRhs>::StorageKind() ))
+    {}
+    
+    EIGEN_STRONG_INLINE Index outer() const { return m_outer; }
+    EIGEN_STRONG_INLINE Index row()   const { return NeedToTranspose ? m_outer : LhsIterator::index(); }
+    EIGEN_STRONG_INLINE Index col()   const { return NeedToTranspose ? LhsIterator::index() : m_outer; }
+
+    EIGEN_STRONG_INLINE Scalar value() const { return LhsIterator::value() * m_factor; }
+    EIGEN_STRONG_INLINE operator bool() const { return LhsIterator::operator bool() && (!m_empty); }
+    
+  protected:
+    Scalar get(const RhsEval &rhs, Index outer, Dense = Dense()) const
+    {
+      return rhs.coeff(outer);
+    }
+    
+    Scalar get(const RhsEval &rhs, Index outer, Sparse = Sparse())
+    {
+      typename RhsEval::InnerIterator it(rhs, outer);
+      if (it && it.index()==0 && it.value()!=Scalar(0))
+        return it.value();
+      m_empty = true;
+      return Scalar(0);
+    }
+    
+    Index m_outer;
+    bool m_empty;
+    Scalar m_factor;
+  };
+  
+  sparse_dense_outer_product_evaluator(const Lhs1 &lhs, const ActualRhs &rhs)
+     : m_lhs(lhs), m_lhsXprImpl(m_lhs), m_rhsXprImpl(rhs)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  // transpose case
+  sparse_dense_outer_product_evaluator(const ActualRhs &rhs, const Lhs1 &lhs)
+     : m_lhs(lhs), m_lhsXprImpl(m_lhs), m_rhsXprImpl(rhs)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+    
+protected:
+  const LhsArg m_lhs;
+  evaluator<ActualLhs> m_lhsXprImpl;
+  evaluator<ActualRhs> m_rhsXprImpl;
+};
+
+// sparse * dense outer product
+template<typename Lhs, typename Rhs>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, OuterProduct, SparseShape, DenseShape>
+  : sparse_dense_outer_product_evaluator<Lhs,Rhs, Lhs::IsRowMajor>
+{
+  typedef sparse_dense_outer_product_evaluator<Lhs,Rhs, Lhs::IsRowMajor> Base;
+  
+  typedef Product<Lhs, Rhs> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+
+  explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.lhs(), xpr.rhs())
+  {}
+  
+};
+
+template<typename Lhs, typename Rhs>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, OuterProduct, DenseShape, SparseShape>
+  : sparse_dense_outer_product_evaluator<Lhs,Rhs, Rhs::IsRowMajor>
+{
+  typedef sparse_dense_outer_product_evaluator<Lhs,Rhs, Rhs::IsRowMajor> Base;
+  
+  typedef Product<Lhs, Rhs> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+
+  explicit product_evaluator(const XprType& xpr)
+    : Base(xpr.lhs(), xpr.rhs())
+  {}
+  
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEDENSEPRODUCT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseDiagonalProduct.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseDiagonalProduct.h
new file mode 100644
index 00000000..941c03be
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseDiagonalProduct.h
@@ -0,0 +1,138 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_DIAGONAL_PRODUCT_H
+#define EIGEN_SPARSE_DIAGONAL_PRODUCT_H
+
+namespace Eigen { 
+
+// The product of a diagonal matrix with a sparse matrix can be easily
+// implemented using expression template.
+// We have two consider very different cases:
+// 1 - diag * row-major sparse
+//     => each inner vector <=> scalar * sparse vector product
+//     => so we can reuse CwiseUnaryOp::InnerIterator
+// 2 - diag * col-major sparse
+//     => each inner vector <=> densevector * sparse vector cwise product
+//     => again, we can reuse specialization of CwiseBinaryOp::InnerIterator
+//        for that particular case
+// The two other cases are symmetric.
+
+namespace internal {
+
+enum {
+  SDP_AsScalarProduct,
+  SDP_AsCwiseProduct
+};
+  
+template<typename SparseXprType, typename DiagonalCoeffType, int SDP_Tag>
+struct sparse_diagonal_product_evaluator;
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, DiagonalShape, SparseShape>
+  : public sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType, Rhs::Flags&RowMajorBit?SDP_AsScalarProduct:SDP_AsCwiseProduct>
+{
+  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  enum { CoeffReadCost = HugeCost, Flags = Rhs::Flags&RowMajorBit, Alignment = 0 }; // FIXME CoeffReadCost & Flags
+  
+  typedef sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType, Rhs::Flags&RowMajorBit?SDP_AsScalarProduct:SDP_AsCwiseProduct> Base;
+  explicit product_evaluator(const XprType& xpr) : Base(xpr.rhs(), xpr.lhs().diagonal()) {}
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, SparseShape, DiagonalShape>
+  : public sparse_diagonal_product_evaluator<Lhs, Transpose<const typename Rhs::DiagonalVectorType>, Lhs::Flags&RowMajorBit?SDP_AsCwiseProduct:SDP_AsScalarProduct>
+{
+  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  enum { CoeffReadCost = HugeCost, Flags = Lhs::Flags&RowMajorBit, Alignment = 0 }; // FIXME CoeffReadCost & Flags
+  
+  typedef sparse_diagonal_product_evaluator<Lhs, Transpose<const typename Rhs::DiagonalVectorType>, Lhs::Flags&RowMajorBit?SDP_AsCwiseProduct:SDP_AsScalarProduct> Base;
+  explicit product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs().diagonal().transpose()) {}
+};
+
+template<typename SparseXprType, typename DiagonalCoeffType>
+struct sparse_diagonal_product_evaluator<SparseXprType, DiagonalCoeffType, SDP_AsScalarProduct>
+{
+protected:
+  typedef typename evaluator<SparseXprType>::InnerIterator SparseXprInnerIterator;
+  typedef typename SparseXprType::Scalar Scalar;
+  
+public:
+  class InnerIterator : public SparseXprInnerIterator
+  {
+  public:
+    InnerIterator(const sparse_diagonal_product_evaluator &xprEval, Index outer)
+      : SparseXprInnerIterator(xprEval.m_sparseXprImpl, outer),
+        m_coeff(xprEval.m_diagCoeffImpl.coeff(outer))
+    {}
+    
+    EIGEN_STRONG_INLINE Scalar value() const { return m_coeff * SparseXprInnerIterator::value(); }
+  protected:
+    typename DiagonalCoeffType::Scalar m_coeff;
+  };
+  
+  sparse_diagonal_product_evaluator(const SparseXprType &sparseXpr, const DiagonalCoeffType &diagCoeff)
+    : m_sparseXprImpl(sparseXpr), m_diagCoeffImpl(diagCoeff)
+  {}
+
+  Index nonZerosEstimate() const { return m_sparseXprImpl.nonZerosEstimate(); }
+    
+protected:
+  evaluator<SparseXprType> m_sparseXprImpl;
+  evaluator<DiagonalCoeffType> m_diagCoeffImpl;
+};
+
+
+template<typename SparseXprType, typename DiagCoeffType>
+struct sparse_diagonal_product_evaluator<SparseXprType, DiagCoeffType, SDP_AsCwiseProduct>
+{
+  typedef typename SparseXprType::Scalar Scalar;
+  typedef typename SparseXprType::StorageIndex StorageIndex;
+  
+  typedef typename nested_eval<DiagCoeffType,SparseXprType::IsRowMajor ? SparseXprType::RowsAtCompileTime
+                                                                       : SparseXprType::ColsAtCompileTime>::type DiagCoeffNested;
+  
+  class InnerIterator
+  {
+    typedef typename evaluator<SparseXprType>::InnerIterator SparseXprIter;
+  public:
+    InnerIterator(const sparse_diagonal_product_evaluator &xprEval, Index outer)
+      : m_sparseIter(xprEval.m_sparseXprEval, outer), m_diagCoeffNested(xprEval.m_diagCoeffNested)
+    {}
+    
+    inline Scalar value() const { return m_sparseIter.value() * m_diagCoeffNested.coeff(index()); }
+    inline StorageIndex index() const  { return m_sparseIter.index(); }
+    inline Index outer() const  { return m_sparseIter.outer(); }
+    inline Index col() const    { return SparseXprType::IsRowMajor ? m_sparseIter.index() : m_sparseIter.outer(); }
+    inline Index row() const    { return SparseXprType::IsRowMajor ? m_sparseIter.outer() : m_sparseIter.index(); }
+    
+    EIGEN_STRONG_INLINE InnerIterator& operator++() { ++m_sparseIter; return *this; }
+    inline operator bool() const  { return m_sparseIter; }
+    
+  protected:
+    SparseXprIter m_sparseIter;
+    DiagCoeffNested m_diagCoeffNested;
+  };
+  
+  sparse_diagonal_product_evaluator(const SparseXprType &sparseXpr, const DiagCoeffType &diagCoeff)
+    : m_sparseXprEval(sparseXpr), m_diagCoeffNested(diagCoeff)
+  {}
+
+  Index nonZerosEstimate() const { return m_sparseXprEval.nonZerosEstimate(); }
+    
+protected:
+  evaluator<SparseXprType> m_sparseXprEval;
+  DiagCoeffNested m_diagCoeffNested;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_DIAGONAL_PRODUCT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseDot.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseDot.h
new file mode 100644
index 00000000..38bc4aa9
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseDot.h
@@ -0,0 +1,98 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_DOT_H
+#define EIGEN_SPARSE_DOT_H
+
+namespace Eigen { 
+
+template<typename Derived>
+template<typename OtherDerived>
+typename internal::traits<Derived>::Scalar
+SparseMatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  eigen_assert(size() == other.size());
+  eigen_assert(other.size()>0 && "you are using a non initialized vector");
+
+  internal::evaluator<Derived> thisEval(derived());
+  typename internal::evaluator<Derived>::InnerIterator i(thisEval, 0);
+  Scalar res(0);
+  while (i)
+  {
+    res += numext::conj(i.value()) * other.coeff(i.index());
+    ++i;
+  }
+  return res;
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+typename internal::traits<Derived>::Scalar
+SparseMatrixBase<Derived>::dot(const SparseMatrixBase<OtherDerived>& other) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  eigen_assert(size() == other.size());
+
+  internal::evaluator<Derived> thisEval(derived());
+  typename internal::evaluator<Derived>::InnerIterator i(thisEval, 0);
+  
+  internal::evaluator<OtherDerived>  otherEval(other.derived());
+  typename internal::evaluator<OtherDerived>::InnerIterator j(otherEval, 0);
+
+  Scalar res(0);
+  while (i && j)
+  {
+    if (i.index()==j.index())
+    {
+      res += numext::conj(i.value()) * j.value();
+      ++i; ++j;
+    }
+    else if (i.index()<j.index())
+      ++i;
+    else
+      ++j;
+  }
+  return res;
+}
+
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+SparseMatrixBase<Derived>::squaredNorm() const
+{
+  return numext::real((*this).cwiseAbs2().sum());
+}
+
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+SparseMatrixBase<Derived>::norm() const
+{
+  using std::sqrt;
+  return sqrt(squaredNorm());
+}
+
+template<typename Derived>
+inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
+SparseMatrixBase<Derived>::blueNorm() const
+{
+  return internal::blueNorm_impl(*this);
+}
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_DOT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseFuzzy.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseFuzzy.h
new file mode 100644
index 00000000..7d47eb94
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseFuzzy.h
@@ -0,0 +1,29 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_FUZZY_H
+#define EIGEN_SPARSE_FUZZY_H
+
+namespace Eigen {
+  
+template<typename Derived>
+template<typename OtherDerived>
+bool SparseMatrixBase<Derived>::isApprox(const SparseMatrixBase<OtherDerived>& other, const RealScalar &prec) const
+{
+  const typename internal::nested_eval<Derived,2,PlainObject>::type actualA(derived());
+  typename internal::conditional<bool(IsRowMajor)==bool(OtherDerived::IsRowMajor),
+    const typename internal::nested_eval<OtherDerived,2,PlainObject>::type,
+    const PlainObject>::type actualB(other.derived());
+
+  return (actualA - actualB).squaredNorm() <= prec * prec * numext::mini(actualA.squaredNorm(), actualB.squaredNorm());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_FUZZY_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseMap.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseMap.h
new file mode 100644
index 00000000..f99be337
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseMap.h
@@ -0,0 +1,305 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_MAP_H
+#define EIGEN_SPARSE_MAP_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct traits<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  typedef traits<PlainObjectType> TraitsBase;
+  enum {
+    Flags = TraitsBase::Flags & (~NestByRefBit)
+  };
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct traits<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  typedef traits<PlainObjectType> TraitsBase;
+  enum {
+    Flags = TraitsBase::Flags & (~ (NestByRefBit | LvalueBit))
+  };
+};
+
+} // end namespace internal
+
+template<typename Derived,
+         int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
+> class SparseMapBase;
+
+/** \ingroup SparseCore_Module
+  * class SparseMapBase
+  * \brief Common base class for Map and Ref instance of sparse matrix and vector.
+  */
+template<typename Derived>
+class SparseMapBase<Derived,ReadOnlyAccessors>
+  : public SparseCompressedBase<Derived>
+{
+  public:
+    typedef SparseCompressedBase<Derived> Base;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    enum { IsRowMajor = Base::IsRowMajor };
+    using Base::operator=;
+  protected:
+    
+    typedef typename internal::conditional<
+                         bool(internal::is_lvalue<Derived>::value),
+                         Scalar *, const Scalar *>::type ScalarPointer;
+    typedef typename internal::conditional<
+                         bool(internal::is_lvalue<Derived>::value),
+                         StorageIndex *, const StorageIndex *>::type IndexPointer;
+
+    Index   m_outerSize;
+    Index   m_innerSize;
+    Array<StorageIndex,2,1>  m_zero_nnz;
+    IndexPointer  m_outerIndex;
+    IndexPointer  m_innerIndices;
+    ScalarPointer m_values;
+    IndexPointer  m_innerNonZeros;
+
+  public:
+
+    /** \copydoc SparseMatrixBase::rows() */
+    inline Index rows() const { return IsRowMajor ? m_outerSize : m_innerSize; }
+    /** \copydoc SparseMatrixBase::cols() */
+    inline Index cols() const { return IsRowMajor ? m_innerSize : m_outerSize; }
+    /** \copydoc SparseMatrixBase::innerSize() */
+    inline Index innerSize() const { return m_innerSize; }
+    /** \copydoc SparseMatrixBase::outerSize() */
+    inline Index outerSize() const { return m_outerSize; }
+    /** \copydoc SparseCompressedBase::nonZeros */
+    inline Index nonZeros() const { return m_zero_nnz[1]; }
+    
+    /** \copydoc SparseCompressedBase::isCompressed */
+    bool isCompressed() const { return m_innerNonZeros==0; }
+
+    //----------------------------------------
+    // direct access interface
+    /** \copydoc SparseMatrix::valuePtr */
+    inline const Scalar* valuePtr() const { return m_values; }
+    /** \copydoc SparseMatrix::innerIndexPtr */
+    inline const StorageIndex* innerIndexPtr() const { return m_innerIndices; }
+    /** \copydoc SparseMatrix::outerIndexPtr */
+    inline const StorageIndex* outerIndexPtr() const { return m_outerIndex; }
+    /** \copydoc SparseMatrix::innerNonZeroPtr */
+    inline const StorageIndex* innerNonZeroPtr() const { return m_innerNonZeros; }
+    //----------------------------------------
+
+    /** \copydoc SparseMatrix::coeff */
+    inline Scalar coeff(Index row, Index col) const
+    {
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      Index start = m_outerIndex[outer];
+      Index end = isCompressed() ? m_outerIndex[outer+1] : start + m_innerNonZeros[outer];
+      if (start==end)
+        return Scalar(0);
+      else if (end>0 && inner==m_innerIndices[end-1])
+        return m_values[end-1];
+      // ^^  optimization: let's first check if it is the last coefficient
+      // (very common in high level algorithms)
+
+      const StorageIndex* r = std::lower_bound(&m_innerIndices[start],&m_innerIndices[end-1],inner);
+      const Index id = r-&m_innerIndices[0];
+      return ((*r==inner) && (id<end)) ? m_values[id] : Scalar(0);
+    }
+
+    inline SparseMapBase(Index rows, Index cols, Index nnz, IndexPointer outerIndexPtr, IndexPointer innerIndexPtr,
+                              ScalarPointer valuePtr, IndexPointer innerNonZerosPtr = 0)
+      : m_outerSize(IsRowMajor?rows:cols), m_innerSize(IsRowMajor?cols:rows), m_zero_nnz(0,internal::convert_index<StorageIndex>(nnz)), m_outerIndex(outerIndexPtr),
+        m_innerIndices(innerIndexPtr), m_values(valuePtr), m_innerNonZeros(innerNonZerosPtr)
+    {}
+
+    // for vectors
+    inline SparseMapBase(Index size, Index nnz, IndexPointer innerIndexPtr, ScalarPointer valuePtr)
+      : m_outerSize(1), m_innerSize(size), m_zero_nnz(0,internal::convert_index<StorageIndex>(nnz)), m_outerIndex(m_zero_nnz.data()),
+        m_innerIndices(innerIndexPtr), m_values(valuePtr), m_innerNonZeros(0)
+    {}
+
+    /** Empty destructor */
+    inline ~SparseMapBase() {}
+
+  protected:
+    inline SparseMapBase() {}
+};
+
+/** \ingroup SparseCore_Module
+  * class SparseMapBase
+  * \brief Common base class for writable Map and Ref instance of sparse matrix and vector.
+  */
+template<typename Derived>
+class SparseMapBase<Derived,WriteAccessors>
+  : public SparseMapBase<Derived,ReadOnlyAccessors>
+{
+    typedef MapBase<Derived, ReadOnlyAccessors> ReadOnlyMapBase;
+    
+  public:
+    typedef SparseMapBase<Derived, ReadOnlyAccessors> Base;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    enum { IsRowMajor = Base::IsRowMajor };
+    
+    using Base::operator=;
+
+  public:
+    
+    //----------------------------------------
+    // direct access interface
+    using Base::valuePtr;
+    using Base::innerIndexPtr;
+    using Base::outerIndexPtr;
+    using Base::innerNonZeroPtr;
+    /** \copydoc SparseMatrix::valuePtr */
+    inline Scalar* valuePtr()              { return Base::m_values; }
+    /** \copydoc SparseMatrix::innerIndexPtr */
+    inline StorageIndex* innerIndexPtr()   { return Base::m_innerIndices; }
+    /** \copydoc SparseMatrix::outerIndexPtr */
+    inline StorageIndex* outerIndexPtr()   { return Base::m_outerIndex; }
+    /** \copydoc SparseMatrix::innerNonZeroPtr */
+    inline StorageIndex* innerNonZeroPtr() { return Base::m_innerNonZeros; }
+    //----------------------------------------
+
+    /** \copydoc SparseMatrix::coeffRef */
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      Index start = Base::m_outerIndex[outer];
+      Index end = Base::isCompressed() ? Base::m_outerIndex[outer+1] : start + Base::m_innerNonZeros[outer];
+      eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix");
+      eigen_assert(end>start && "coeffRef cannot be called on a zero coefficient");
+      StorageIndex* r = std::lower_bound(&Base::m_innerIndices[start],&Base::m_innerIndices[end],inner);
+      const Index id = r - &Base::m_innerIndices[0];
+      eigen_assert((*r==inner) && (id<end) && "coeffRef cannot be called on a zero coefficient");
+      return const_cast<Scalar*>(Base::m_values)[id];
+    }
+    
+    inline SparseMapBase(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr, StorageIndex* innerIndexPtr,
+                         Scalar* valuePtr, StorageIndex* innerNonZerosPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
+    {}
+
+    // for vectors
+    inline SparseMapBase(Index size, Index nnz, StorageIndex* innerIndexPtr, Scalar* valuePtr)
+      : Base(size, nnz, innerIndexPtr, valuePtr)
+    {}
+
+    /** Empty destructor */
+    inline ~SparseMapBase() {}
+
+  protected:
+    inline SparseMapBase() {}
+};
+
+/** \ingroup SparseCore_Module
+  *
+  * \brief Specialization of class Map for SparseMatrix-like storage.
+  *
+  * \tparam SparseMatrixType the equivalent sparse matrix type of the referenced data, it must be a template instance of class SparseMatrix.
+  *
+  * \sa class Map, class SparseMatrix, class Ref<SparseMatrixType,Options>
+  */
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public SparseMapBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+#else
+template<typename SparseMatrixType>
+class Map<SparseMatrixType>
+  : public SparseMapBase<Derived,WriteAccessors>
+#endif
+{
+  public:
+    typedef SparseMapBase<Map> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Map)
+    enum { IsRowMajor = Base::IsRowMajor };
+
+  public:
+
+    /** Constructs a read-write Map to a sparse matrix of size \a rows x \a cols, containing \a nnz non-zero coefficients,
+      * stored as a sparse format as defined by the pointers \a outerIndexPtr, \a innerIndexPtr, and \a valuePtr.
+      * If the optional parameter \a innerNonZerosPtr is the null pointer, then a standard compressed format is assumed.
+      *
+      * This constructor is available only if \c SparseMatrixType is non-const.
+      *
+      * More details on the expected storage schemes are given in the \ref TutorialSparse "manual pages".
+      */
+    inline Map(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr,
+               StorageIndex* innerIndexPtr, Scalar* valuePtr, StorageIndex* innerNonZerosPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
+    {}
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** Empty destructor */
+    inline ~Map() {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public SparseMapBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+{
+  public:
+    typedef SparseMapBase<Map> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Map)
+    enum { IsRowMajor = Base::IsRowMajor };
+
+  public:
+#endif
+    /** This is the const version of the above constructor.
+      *
+      * This constructor is available only if \c SparseMatrixType is const, e.g.:
+      * \code Map<const SparseMatrix<double> >  \endcode
+      */
+    inline Map(Index rows, Index cols, Index nnz, const StorageIndex* outerIndexPtr,
+               const StorageIndex* innerIndexPtr, const Scalar* valuePtr, const StorageIndex* innerNonZerosPtr = 0)
+      : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
+    {}
+
+    /** Empty destructor */
+    inline ~Map() {}
+};
+
+namespace internal {
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_MAP_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseMatrix.h
new file mode 100644
index 00000000..616b4a0c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseMatrix.h
@@ -0,0 +1,1518 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEMATRIX_H
+#define EIGEN_SPARSEMATRIX_H
+
+namespace Eigen { 
+
+/** \ingroup SparseCore_Module
+  *
+  * \class SparseMatrix
+  *
+  * \brief A versatible sparse matrix representation
+  *
+  * This class implements a more versatile variants of the common \em compressed row/column storage format.
+  * Each colmun's (resp. row) non zeros are stored as a pair of value with associated row (resp. colmiun) index.
+  * All the non zeros are stored in a single large buffer. Unlike the \em compressed format, there might be extra
+  * space in between the nonzeros of two successive colmuns (resp. rows) such that insertion of new non-zero
+  * can be done with limited memory reallocation and copies.
+  *
+  * A call to the function makeCompressed() turns the matrix into the standard \em compressed format
+  * compatible with many library.
+  *
+  * More details on this storage sceheme are given in the \ref TutorialSparse "manual pages".
+  *
+  * \tparam _Scalar the scalar type, i.e. the type of the coefficients
+  * \tparam _Options Union of bit flags controlling the storage scheme. Currently the only possibility
+  *                 is ColMajor or RowMajor. The default is 0 which means column-major.
+  * \tparam _StorageIndex the type of the indices. It has to be a \b signed type (e.g., short, int, std::ptrdiff_t). Default is \c int.
+  *
+  * \warning In %Eigen 3.2, the undocumented type \c SparseMatrix::Index was improperly defined as the storage index type (e.g., int),
+  *          whereas it is now (starting from %Eigen 3.3) deprecated and always defined as Eigen::Index.
+  *          Codes making use of \c SparseMatrix::Index, might thus likely have to be changed to use \c SparseMatrix::StorageIndex instead.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_SPARSEMATRIX_PLUGIN.
+  */
+
+namespace internal {
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct traits<SparseMatrix<_Scalar, _Options, _StorageIndex> >
+{
+  typedef _Scalar Scalar;
+  typedef _StorageIndex StorageIndex;
+  typedef Sparse StorageKind;
+  typedef MatrixXpr XprKind;
+  enum {
+    RowsAtCompileTime = Dynamic,
+    ColsAtCompileTime = Dynamic,
+    MaxRowsAtCompileTime = Dynamic,
+    MaxColsAtCompileTime = Dynamic,
+    Flags = _Options | NestByRefBit | LvalueBit | CompressedAccessBit,
+    SupportedAccessPatterns = InnerRandomAccessPattern
+  };
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int DiagIndex>
+struct traits<Diagonal<SparseMatrix<_Scalar, _Options, _StorageIndex>, DiagIndex> >
+{
+  typedef SparseMatrix<_Scalar, _Options, _StorageIndex> MatrixType;
+  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
+  typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
+
+  typedef _Scalar Scalar;
+  typedef Dense StorageKind;
+  typedef _StorageIndex StorageIndex;
+  typedef MatrixXpr XprKind;
+
+  enum {
+    RowsAtCompileTime = Dynamic,
+    ColsAtCompileTime = 1,
+    MaxRowsAtCompileTime = Dynamic,
+    MaxColsAtCompileTime = 1,
+    Flags = LvalueBit
+  };
+};
+
+template<typename _Scalar, int _Options, typename _StorageIndex, int DiagIndex>
+struct traits<Diagonal<const SparseMatrix<_Scalar, _Options, _StorageIndex>, DiagIndex> >
+ : public traits<Diagonal<SparseMatrix<_Scalar, _Options, _StorageIndex>, DiagIndex> >
+{
+  enum {
+    Flags = 0
+  };
+};
+
+} // end namespace internal
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+class SparseMatrix
+  : public SparseCompressedBase<SparseMatrix<_Scalar, _Options, _StorageIndex> >
+{
+    typedef SparseCompressedBase<SparseMatrix> Base;
+    using Base::convert_index;
+    friend class SparseVector<_Scalar,0,_StorageIndex>;
+    template<typename, typename, typename, typename, typename>
+    friend struct internal::Assignment;
+  public:
+    using Base::isCompressed;
+    using Base::nonZeros;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(SparseMatrix)
+    using Base::operator+=;
+    using Base::operator-=;
+
+    typedef MappedSparseMatrix<Scalar,Flags> Map;
+    typedef Diagonal<SparseMatrix> DiagonalReturnType;
+    typedef Diagonal<const SparseMatrix> ConstDiagonalReturnType;
+    typedef typename Base::InnerIterator InnerIterator;
+    typedef typename Base::ReverseInnerIterator ReverseInnerIterator;
+    
+
+    using Base::IsRowMajor;
+    typedef internal::CompressedStorage<Scalar,StorageIndex> Storage;
+    enum {
+      Options = _Options
+    };
+
+    typedef typename Base::IndexVector IndexVector;
+    typedef typename Base::ScalarVector ScalarVector;
+  protected:
+    typedef SparseMatrix<Scalar,(Flags&~RowMajorBit)|(IsRowMajor?RowMajorBit:0)> TransposedSparseMatrix;
+
+    Index m_outerSize;
+    Index m_innerSize;
+    StorageIndex* m_outerIndex;
+    StorageIndex* m_innerNonZeros;     // optional, if null then the data is compressed
+    Storage m_data;
+
+  public:
+    
+    /** \returns the number of rows of the matrix */
+    inline Index rows() const { return IsRowMajor ? m_outerSize : m_innerSize; }
+    /** \returns the number of columns of the matrix */
+    inline Index cols() const { return IsRowMajor ? m_innerSize : m_outerSize; }
+
+    /** \returns the number of rows (resp. columns) of the matrix if the storage order column major (resp. row major) */
+    inline Index innerSize() const { return m_innerSize; }
+    /** \returns the number of columns (resp. rows) of the matrix if the storage order column major (resp. row major) */
+    inline Index outerSize() const { return m_outerSize; }
+    
+    /** \returns a const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline const Scalar* valuePtr() const { return m_data.valuePtr(); }
+    /** \returns a non-const pointer to the array of values.
+      * This function is aimed at interoperability with other libraries.
+      * \sa innerIndexPtr(), outerIndexPtr() */
+    inline Scalar* valuePtr() { return m_data.valuePtr(); }
+
+    /** \returns a const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline const StorageIndex* innerIndexPtr() const { return m_data.indexPtr(); }
+    /** \returns a non-const pointer to the array of inner indices.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), outerIndexPtr() */
+    inline StorageIndex* innerIndexPtr() { return m_data.indexPtr(); }
+
+    /** \returns a const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), innerIndexPtr() */
+    inline const StorageIndex* outerIndexPtr() const { return m_outerIndex; }
+    /** \returns a non-const pointer to the array of the starting positions of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \sa valuePtr(), innerIndexPtr() */
+    inline StorageIndex* outerIndexPtr() { return m_outerIndex; }
+
+    /** \returns a const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline const StorageIndex* innerNonZeroPtr() const { return m_innerNonZeros; }
+    /** \returns a non-const pointer to the array of the number of non zeros of the inner vectors.
+      * This function is aimed at interoperability with other libraries.
+      * \warning it returns the null pointer 0 in compressed mode */
+    inline StorageIndex* innerNonZeroPtr() { return m_innerNonZeros; }
+
+    /** \internal */
+    inline Storage& data() { return m_data; }
+    /** \internal */
+    inline const Storage& data() const { return m_data; }
+
+    /** \returns the value of the matrix at position \a i, \a j
+      * This function returns Scalar(0) if the element is an explicit \em zero */
+    inline Scalar coeff(Index row, Index col) const
+    {
+      eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
+      
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+      Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
+      return m_data.atInRange(m_outerIndex[outer], end, StorageIndex(inner));
+    }
+
+    /** \returns a non-const reference to the value of the matrix at position \a i, \a j
+      *
+      * If the element does not exist then it is inserted via the insert(Index,Index) function
+      * which itself turns the matrix into a non compressed form if that was not the case.
+      *
+      * This is a O(log(nnz_j)) operation (binary search) plus the cost of insert(Index,Index)
+      * function if the element does not already exist.
+      */
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
+      
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      Index start = m_outerIndex[outer];
+      Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
+      eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix");
+      if(end<=start)
+        return insert(row,col);
+      const Index p = m_data.searchLowerIndex(start,end-1,StorageIndex(inner));
+      if((p<end) && (m_data.index(p)==inner))
+        return m_data.value(p);
+      else
+        return insert(row,col);
+    }
+
+    /** \returns a reference to a novel non zero coefficient with coordinates \a row x \a col.
+      * The non zero coefficient must \b not already exist.
+      *
+      * If the matrix \c *this is in compressed mode, then \c *this is turned into uncompressed
+      * mode while reserving room for 2 x this->innerSize() non zeros if reserve(Index) has not been called earlier.
+      * In this case, the insertion procedure is optimized for a \e sequential insertion mode where elements are assumed to be
+      * inserted by increasing outer-indices.
+      * 
+      * If that's not the case, then it is strongly recommended to either use a triplet-list to assemble the matrix, or to first
+      * call reserve(const SizesType &) to reserve the appropriate number of non-zero elements per inner vector.
+      *
+      * Assuming memory has been appropriately reserved, this function performs a sorted insertion in O(1)
+      * if the elements of each inner vector are inserted in increasing inner index order, and in O(nnz_j) for a random insertion.
+      *
+      */
+    Scalar& insert(Index row, Index col);
+
+  public:
+
+    /** Removes all non zeros but keep allocated memory
+      *
+      * This function does not free the currently allocated memory. To release as much as memory as possible,
+      * call \code mat.data().squeeze(); \endcode after resizing it.
+      * 
+      * \sa resize(Index,Index), data()
+      */
+    inline void setZero()
+    {
+      m_data.clear();
+      memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(StorageIndex));
+      if(m_innerNonZeros)
+        memset(m_innerNonZeros, 0, (m_outerSize)*sizeof(StorageIndex));
+    }
+
+    /** Preallocates \a reserveSize non zeros.
+      *
+      * Precondition: the matrix must be in compressed mode. */
+    inline void reserve(Index reserveSize)
+    {
+      eigen_assert(isCompressed() && "This function does not make sense in non compressed mode.");
+      m_data.reserve(reserveSize);
+    }
+    
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** Preallocates \a reserveSize[\c j] non zeros for each column (resp. row) \c j.
+      *
+      * This function turns the matrix in non-compressed mode.
+      * 
+      * The type \c SizesType must expose the following interface:
+        \code
+        typedef value_type;
+        const value_type& operator[](i) const;
+        \endcode
+      * for \c i in the [0,this->outerSize()[ range.
+      * Typical choices include std::vector<int>, Eigen::VectorXi, Eigen::VectorXi::Constant, etc.
+      */
+    template<class SizesType>
+    inline void reserve(const SizesType& reserveSizes);
+    #else
+    template<class SizesType>
+    inline void reserve(const SizesType& reserveSizes, const typename SizesType::value_type& enableif =
+    #if (!EIGEN_COMP_MSVC) || (EIGEN_COMP_MSVC>=1500) // MSVC 2005 fails to compile with this typename
+        typename
+    #endif
+        SizesType::value_type())
+    {
+      EIGEN_UNUSED_VARIABLE(enableif);
+      reserveInnerVectors(reserveSizes);
+    }
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+  protected:
+    template<class SizesType>
+    inline void reserveInnerVectors(const SizesType& reserveSizes)
+    {
+      if(isCompressed())
+      {
+        Index totalReserveSize = 0;
+        // turn the matrix into non-compressed mode
+        m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+        if (!m_innerNonZeros) internal::throw_std_bad_alloc();
+        
+        // temporarily use m_innerSizes to hold the new starting points.
+        StorageIndex* newOuterIndex = m_innerNonZeros;
+        
+        StorageIndex count = 0;
+        for(Index j=0; j<m_outerSize; ++j)
+        {
+          newOuterIndex[j] = count;
+          count += reserveSizes[j] + (m_outerIndex[j+1]-m_outerIndex[j]);
+          totalReserveSize += reserveSizes[j];
+        }
+        m_data.reserve(totalReserveSize);
+        StorageIndex previousOuterIndex = m_outerIndex[m_outerSize];
+        for(Index j=m_outerSize-1; j>=0; --j)
+        {
+          StorageIndex innerNNZ = previousOuterIndex - m_outerIndex[j];
+          for(Index i=innerNNZ-1; i>=0; --i)
+          {
+            m_data.index(newOuterIndex[j]+i) = m_data.index(m_outerIndex[j]+i);
+            m_data.value(newOuterIndex[j]+i) = m_data.value(m_outerIndex[j]+i);
+          }
+          previousOuterIndex = m_outerIndex[j];
+          m_outerIndex[j] = newOuterIndex[j];
+          m_innerNonZeros[j] = innerNNZ;
+        }
+        if(m_outerSize>0)
+          m_outerIndex[m_outerSize] = m_outerIndex[m_outerSize-1] + m_innerNonZeros[m_outerSize-1] + reserveSizes[m_outerSize-1];
+        
+        m_data.resize(m_outerIndex[m_outerSize]);
+      }
+      else
+      {
+        StorageIndex* newOuterIndex = static_cast<StorageIndex*>(std::malloc((m_outerSize+1)*sizeof(StorageIndex)));
+        if (!newOuterIndex) internal::throw_std_bad_alloc();
+        
+        StorageIndex count = 0;
+        for(Index j=0; j<m_outerSize; ++j)
+        {
+          newOuterIndex[j] = count;
+          StorageIndex alreadyReserved = (m_outerIndex[j+1]-m_outerIndex[j]) - m_innerNonZeros[j];
+          StorageIndex toReserve = std::max<StorageIndex>(reserveSizes[j], alreadyReserved);
+          count += toReserve + m_innerNonZeros[j];
+        }
+        newOuterIndex[m_outerSize] = count;
+        
+        m_data.resize(count);
+        for(Index j=m_outerSize-1; j>=0; --j)
+        {
+          Index offset = newOuterIndex[j] - m_outerIndex[j];
+          if(offset>0)
+          {
+            StorageIndex innerNNZ = m_innerNonZeros[j];
+            for(Index i=innerNNZ-1; i>=0; --i)
+            {
+              m_data.index(newOuterIndex[j]+i) = m_data.index(m_outerIndex[j]+i);
+              m_data.value(newOuterIndex[j]+i) = m_data.value(m_outerIndex[j]+i);
+            }
+          }
+        }
+        
+        std::swap(m_outerIndex, newOuterIndex);
+        std::free(newOuterIndex);
+      }
+      
+    }
+  public:
+
+    //--- low level purely coherent filling ---
+
+    /** \internal
+      * \returns a reference to the non zero coefficient at position \a row, \a col assuming that:
+      * - the nonzero does not already exist
+      * - the new coefficient is the last one according to the storage order
+      *
+      * Before filling a given inner vector you must call the statVec(Index) function.
+      *
+      * After an insertion session, you should call the finalize() function.
+      *
+      * \sa insert, insertBackByOuterInner, startVec */
+    inline Scalar& insertBack(Index row, Index col)
+    {
+      return insertBackByOuterInner(IsRowMajor?row:col, IsRowMajor?col:row);
+    }
+
+    /** \internal
+      * \sa insertBack, startVec */
+    inline Scalar& insertBackByOuterInner(Index outer, Index inner)
+    {
+      eigen_assert(Index(m_outerIndex[outer+1]) == m_data.size() && "Invalid ordered insertion (invalid outer index)");
+      eigen_assert( (m_outerIndex[outer+1]-m_outerIndex[outer]==0 || m_data.index(m_data.size()-1)<inner) && "Invalid ordered insertion (invalid inner index)");
+      Index p = m_outerIndex[outer+1];
+      ++m_outerIndex[outer+1];
+      m_data.append(Scalar(0), inner);
+      return m_data.value(p);
+    }
+
+    /** \internal
+      * \warning use it only if you know what you are doing */
+    inline Scalar& insertBackByOuterInnerUnordered(Index outer, Index inner)
+    {
+      Index p = m_outerIndex[outer+1];
+      ++m_outerIndex[outer+1];
+      m_data.append(Scalar(0), inner);
+      return m_data.value(p);
+    }
+
+    /** \internal
+      * \sa insertBack, insertBackByOuterInner */
+    inline void startVec(Index outer)
+    {
+      eigen_assert(m_outerIndex[outer]==Index(m_data.size()) && "You must call startVec for each inner vector sequentially");
+      eigen_assert(m_outerIndex[outer+1]==0 && "You must call startVec for each inner vector sequentially");
+      m_outerIndex[outer+1] = m_outerIndex[outer];
+    }
+
+    /** \internal
+      * Must be called after inserting a set of non zero entries using the low level compressed API.
+      */
+    inline void finalize()
+    {
+      if(isCompressed())
+      {
+        StorageIndex size = internal::convert_index<StorageIndex>(m_data.size());
+        Index i = m_outerSize;
+        // find the last filled column
+        while (i>=0 && m_outerIndex[i]==0)
+          --i;
+        ++i;
+        while (i<=m_outerSize)
+        {
+          m_outerIndex[i] = size;
+          ++i;
+        }
+      }
+    }
+
+    //---
+
+    template<typename InputIterators>
+    void setFromTriplets(const InputIterators& begin, const InputIterators& end);
+
+    template<typename InputIterators,typename DupFunctor>
+    void setFromTriplets(const InputIterators& begin, const InputIterators& end, DupFunctor dup_func);
+
+    void sumupDuplicates() { collapseDuplicates(internal::scalar_sum_op<Scalar,Scalar>()); }
+
+    template<typename DupFunctor>
+    void collapseDuplicates(DupFunctor dup_func = DupFunctor());
+
+    //---
+    
+    /** \internal
+      * same as insert(Index,Index) except that the indices are given relative to the storage order */
+    Scalar& insertByOuterInner(Index j, Index i)
+    {
+      return insert(IsRowMajor ? j : i, IsRowMajor ? i : j);
+    }
+
+    /** Turns the matrix into the \em compressed format.
+      */
+    void makeCompressed()
+    {
+      if(isCompressed())
+        return;
+      
+      eigen_internal_assert(m_outerIndex!=0 && m_outerSize>0);
+      
+      Index oldStart = m_outerIndex[1];
+      m_outerIndex[1] = m_innerNonZeros[0];
+      for(Index j=1; j<m_outerSize; ++j)
+      {
+        Index nextOldStart = m_outerIndex[j+1];
+        Index offset = oldStart - m_outerIndex[j];
+        if(offset>0)
+        {
+          for(Index k=0; k<m_innerNonZeros[j]; ++k)
+          {
+            m_data.index(m_outerIndex[j]+k) = m_data.index(oldStart+k);
+            m_data.value(m_outerIndex[j]+k) = m_data.value(oldStart+k);
+          }
+        }
+        m_outerIndex[j+1] = m_outerIndex[j] + m_innerNonZeros[j];
+        oldStart = nextOldStart;
+      }
+      std::free(m_innerNonZeros);
+      m_innerNonZeros = 0;
+      m_data.resize(m_outerIndex[m_outerSize]);
+      m_data.squeeze();
+    }
+
+    /** Turns the matrix into the uncompressed mode */
+    void uncompress()
+    {
+      if(m_innerNonZeros != 0)
+        return; 
+      m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+      for (Index i = 0; i < m_outerSize; i++)
+      {
+        m_innerNonZeros[i] = m_outerIndex[i+1] - m_outerIndex[i]; 
+      }
+    }
+
+    /** Suppresses all nonzeros which are \b much \b smaller \b than \a reference under the tolerance \a epsilon */
+    void prune(const Scalar& reference, const RealScalar& epsilon = NumTraits<RealScalar>::dummy_precision())
+    {
+      prune(default_prunning_func(reference,epsilon));
+    }
+    
+    /** Turns the matrix into compressed format, and suppresses all nonzeros which do not satisfy the predicate \a keep.
+      * The functor type \a KeepFunc must implement the following function:
+      * \code
+      * bool operator() (const Index& row, const Index& col, const Scalar& value) const;
+      * \endcode
+      * \sa prune(Scalar,RealScalar)
+      */
+    template<typename KeepFunc>
+    void prune(const KeepFunc& keep = KeepFunc())
+    {
+      // TODO optimize the uncompressed mode to avoid moving and allocating the data twice
+      makeCompressed();
+
+      StorageIndex k = 0;
+      for(Index j=0; j<m_outerSize; ++j)
+      {
+        Index previousStart = m_outerIndex[j];
+        m_outerIndex[j] = k;
+        Index end = m_outerIndex[j+1];
+        for(Index i=previousStart; i<end; ++i)
+        {
+          if(keep(IsRowMajor?j:m_data.index(i), IsRowMajor?m_data.index(i):j, m_data.value(i)))
+          {
+            m_data.value(k) = m_data.value(i);
+            m_data.index(k) = m_data.index(i);
+            ++k;
+          }
+        }
+      }
+      m_outerIndex[m_outerSize] = k;
+      m_data.resize(k,0);
+    }
+
+    /** Resizes the matrix to a \a rows x \a cols matrix leaving old values untouched.
+      *
+      * If the sizes of the matrix are decreased, then the matrix is turned to \b uncompressed-mode
+      * and the storage of the out of bounds coefficients is kept and reserved.
+      * Call makeCompressed() to pack the entries and squeeze extra memory.
+      *
+      * \sa reserve(), setZero(), makeCompressed()
+      */
+    void conservativeResize(Index rows, Index cols) 
+    {
+      // No change
+      if (this->rows() == rows && this->cols() == cols) return;
+      
+      // If one dimension is null, then there is nothing to be preserved
+      if(rows==0 || cols==0) return resize(rows,cols);
+
+      Index innerChange = IsRowMajor ? cols - this->cols() : rows - this->rows();
+      Index outerChange = IsRowMajor ? rows - this->rows() : cols - this->cols();
+      StorageIndex newInnerSize = convert_index(IsRowMajor ? cols : rows);
+
+      // Deals with inner non zeros
+      if (m_innerNonZeros)
+      {
+        // Resize m_innerNonZeros
+        StorageIndex *newInnerNonZeros = static_cast<StorageIndex*>(std::realloc(m_innerNonZeros, (m_outerSize + outerChange) * sizeof(StorageIndex)));
+        if (!newInnerNonZeros) internal::throw_std_bad_alloc();
+        m_innerNonZeros = newInnerNonZeros;
+        
+        for(Index i=m_outerSize; i<m_outerSize+outerChange; i++)          
+          m_innerNonZeros[i] = 0;
+      } 
+      else if (innerChange < 0) 
+      {
+        // Inner size decreased: allocate a new m_innerNonZeros
+        m_innerNonZeros = static_cast<StorageIndex*>(std::malloc((m_outerSize + outerChange) * sizeof(StorageIndex)));
+        if (!m_innerNonZeros) internal::throw_std_bad_alloc();
+        for(Index i = 0; i < m_outerSize + (std::min)(outerChange, Index(0)); i++)
+          m_innerNonZeros[i] = m_outerIndex[i+1] - m_outerIndex[i];
+        for(Index i = m_outerSize; i < m_outerSize + outerChange; i++)
+          m_innerNonZeros[i] = 0;
+      }
+      
+      // Change the m_innerNonZeros in case of a decrease of inner size
+      if (m_innerNonZeros && innerChange < 0)
+      {
+        for(Index i = 0; i < m_outerSize + (std::min)(outerChange, Index(0)); i++)
+        {
+          StorageIndex &n = m_innerNonZeros[i];
+          StorageIndex start = m_outerIndex[i];
+          while (n > 0 && m_data.index(start+n-1) >= newInnerSize) --n; 
+        }
+      }
+      
+      m_innerSize = newInnerSize;
+
+      // Re-allocate outer index structure if necessary
+      if (outerChange == 0)
+        return;
+          
+      StorageIndex *newOuterIndex = static_cast<StorageIndex*>(std::realloc(m_outerIndex, (m_outerSize + outerChange + 1) * sizeof(StorageIndex)));
+      if (!newOuterIndex) internal::throw_std_bad_alloc();
+      m_outerIndex = newOuterIndex;
+      if (outerChange > 0)
+      {
+        StorageIndex lastIdx = m_outerSize == 0 ? 0 : m_outerIndex[m_outerSize];
+        for(Index i=m_outerSize; i<m_outerSize+outerChange+1; i++)          
+          m_outerIndex[i] = lastIdx; 
+      }
+      m_outerSize += outerChange;
+    }
+    
+    /** Resizes the matrix to a \a rows x \a cols matrix and initializes it to zero.
+      * 
+      * This function does not free the currently allocated memory. To release as much as memory as possible,
+      * call \code mat.data().squeeze(); \endcode after resizing it.
+      * 
+      * \sa reserve(), setZero()
+      */
+    void resize(Index rows, Index cols)
+    {
+      const Index outerSize = IsRowMajor ? rows : cols;
+      m_innerSize = IsRowMajor ? cols : rows;
+      m_data.clear();
+      if (m_outerSize != outerSize || m_outerSize==0)
+      {
+        std::free(m_outerIndex);
+        m_outerIndex = static_cast<StorageIndex*>(std::malloc((outerSize + 1) * sizeof(StorageIndex)));
+        if (!m_outerIndex) internal::throw_std_bad_alloc();
+        
+        m_outerSize = outerSize;
+      }
+      if(m_innerNonZeros)
+      {
+        std::free(m_innerNonZeros);
+        m_innerNonZeros = 0;
+      }
+      memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(StorageIndex));
+    }
+
+    /** \internal
+      * Resize the nonzero vector to \a size */
+    void resizeNonZeros(Index size)
+    {
+      m_data.resize(size);
+    }
+
+    /** \returns a const expression of the diagonal coefficients. */
+    const ConstDiagonalReturnType diagonal() const { return ConstDiagonalReturnType(*this); }
+    
+    /** \returns a read-write expression of the diagonal coefficients.
+      * \warning If the diagonal entries are written, then all diagonal
+      * entries \b must already exist, otherwise an assertion will be raised.
+      */
+    DiagonalReturnType diagonal() { return DiagonalReturnType(*this); }
+
+    /** Default constructor yielding an empty \c 0 \c x \c 0 matrix */
+    inline SparseMatrix()
+      : m_outerSize(-1), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      resize(0, 0);
+    }
+
+    /** Constructs a \a rows \c x \a cols empty matrix */
+    inline SparseMatrix(Index rows, Index cols)
+      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      resize(rows, cols);
+    }
+
+    /** Constructs a sparse matrix from the sparse expression \a other */
+    template<typename OtherDerived>
+    inline SparseMatrix(const SparseMatrixBase<OtherDerived>& other)
+      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+      check_template_parameters();
+      const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
+      if (needToTranspose)
+        *this = other.derived();
+      else
+      {
+        #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+          EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+        #endif
+        internal::call_assignment_no_alias(*this, other.derived());
+      }
+    }
+    
+    /** Constructs a sparse matrix from the sparse selfadjoint view \a other */
+    template<typename OtherDerived, unsigned int UpLo>
+    inline SparseMatrix(const SparseSelfAdjointView<OtherDerived, UpLo>& other)
+      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      Base::operator=(other);
+    }
+
+    /** Copy constructor (it performs a deep copy) */
+    inline SparseMatrix(const SparseMatrix& other)
+      : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    /** \brief Copy constructor with in-place evaluation */
+    template<typename OtherDerived>
+    SparseMatrix(const ReturnByValue<OtherDerived>& other)
+      : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      initAssignment(other);
+      other.evalTo(*this);
+    }
+    
+    /** \brief Copy constructor with in-place evaluation */
+    template<typename OtherDerived>
+    explicit SparseMatrix(const DiagonalBase<OtherDerived>& other)
+      : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
+    {
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    /** Swaps the content of two sparse matrices of the same type.
+      * This is a fast operation that simply swaps the underlying pointers and parameters. */
+    inline void swap(SparseMatrix& other)
+    {
+      //EIGEN_DBG_SPARSE(std::cout << "SparseMatrix:: swap\n");
+      std::swap(m_outerIndex, other.m_outerIndex);
+      std::swap(m_innerSize, other.m_innerSize);
+      std::swap(m_outerSize, other.m_outerSize);
+      std::swap(m_innerNonZeros, other.m_innerNonZeros);
+      m_data.swap(other.m_data);
+    }
+
+    /** Sets *this to the identity matrix.
+      * This function also turns the matrix into compressed mode, and drop any reserved memory. */
+    inline void setIdentity()
+    {
+      eigen_assert(rows() == cols() && "ONLY FOR SQUARED MATRICES");
+      this->m_data.resize(rows());
+      Eigen::Map<IndexVector>(this->m_data.indexPtr(), rows()).setLinSpaced(0, StorageIndex(rows()-1));
+      Eigen::Map<ScalarVector>(this->m_data.valuePtr(), rows()).setOnes();
+      Eigen::Map<IndexVector>(this->m_outerIndex, rows()+1).setLinSpaced(0, StorageIndex(rows()));
+      std::free(m_innerNonZeros);
+      m_innerNonZeros = 0;
+    }
+    inline SparseMatrix& operator=(const SparseMatrix& other)
+    {
+      if (other.isRValue())
+      {
+        swap(other.const_cast_derived());
+      }
+      else if(this!=&other)
+      {
+        #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+          EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+        #endif
+        initAssignment(other);
+        if(other.isCompressed())
+        {
+          internal::smart_copy(other.m_outerIndex, other.m_outerIndex + m_outerSize + 1, m_outerIndex);
+          m_data = other.m_data;
+        }
+        else
+        {
+          Base::operator=(other);
+        }
+      }
+      return *this;
+    }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename OtherDerived>
+    inline SparseMatrix& operator=(const EigenBase<OtherDerived>& other)
+    { return Base::operator=(other.derived()); }
+
+    template<typename Lhs, typename Rhs>
+    inline SparseMatrix& operator=(const Product<Lhs,Rhs,AliasFreeProduct>& other);
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+    template<typename OtherDerived>
+    EIGEN_DONT_INLINE SparseMatrix& operator=(const SparseMatrixBase<OtherDerived>& other);
+
+    friend std::ostream & operator << (std::ostream & s, const SparseMatrix& m)
+    {
+      EIGEN_DBG_SPARSE(
+        s << "Nonzero entries:\n";
+        if(m.isCompressed())
+        {
+          for (Index i=0; i<m.nonZeros(); ++i)
+            s << "(" << m.m_data.value(i) << "," << m.m_data.index(i) << ") ";
+        }
+        else
+        {
+          for (Index i=0; i<m.outerSize(); ++i)
+          {
+            Index p = m.m_outerIndex[i];
+            Index pe = m.m_outerIndex[i]+m.m_innerNonZeros[i];
+            Index k=p;
+            for (; k<pe; ++k) {
+              s << "(" << m.m_data.value(k) << "," << m.m_data.index(k) << ") ";
+            }
+            for (; k<m.m_outerIndex[i+1]; ++k) {
+              s << "(_,_) ";
+            }
+          }
+        }
+        s << std::endl;
+        s << std::endl;
+        s << "Outer pointers:\n";
+        for (Index i=0; i<m.outerSize(); ++i) {
+          s << m.m_outerIndex[i] << " ";
+        }
+        s << " $" << std::endl;
+        if(!m.isCompressed())
+        {
+          s << "Inner non zeros:\n";
+          for (Index i=0; i<m.outerSize(); ++i) {
+            s << m.m_innerNonZeros[i] << " ";
+          }
+          s << " $" << std::endl;
+        }
+        s << std::endl;
+      );
+      s << static_cast<const SparseMatrixBase<SparseMatrix>&>(m);
+      return s;
+    }
+
+    /** Destructor */
+    inline ~SparseMatrix()
+    {
+      std::free(m_outerIndex);
+      std::free(m_innerNonZeros);
+    }
+
+    /** Overloaded for performance */
+    Scalar sum() const;
+    
+#   ifdef EIGEN_SPARSEMATRIX_PLUGIN
+#     include EIGEN_SPARSEMATRIX_PLUGIN
+#   endif
+
+protected:
+
+    template<typename Other>
+    void initAssignment(const Other& other)
+    {
+      resize(other.rows(), other.cols());
+      if(m_innerNonZeros)
+      {
+        std::free(m_innerNonZeros);
+        m_innerNonZeros = 0;
+      }
+    }
+
+    /** \internal
+      * \sa insert(Index,Index) */
+    EIGEN_DONT_INLINE Scalar& insertCompressed(Index row, Index col);
+
+    /** \internal
+      * A vector object that is equal to 0 everywhere but v at the position i */
+    class SingletonVector
+    {
+        StorageIndex m_index;
+        StorageIndex m_value;
+      public:
+        typedef StorageIndex value_type;
+        SingletonVector(Index i, Index v)
+          : m_index(convert_index(i)), m_value(convert_index(v))
+        {}
+
+        StorageIndex operator[](Index i) const { return i==m_index ? m_value : 0; }
+    };
+
+    /** \internal
+      * \sa insert(Index,Index) */
+    EIGEN_DONT_INLINE Scalar& insertUncompressed(Index row, Index col);
+
+public:
+    /** \internal
+      * \sa insert(Index,Index) */
+    EIGEN_STRONG_INLINE Scalar& insertBackUncompressed(Index row, Index col)
+    {
+      const Index outer = IsRowMajor ? row : col;
+      const Index inner = IsRowMajor ? col : row;
+
+      eigen_assert(!isCompressed());
+      eigen_assert(m_innerNonZeros[outer]<=(m_outerIndex[outer+1] - m_outerIndex[outer]));
+
+      Index p = m_outerIndex[outer] + m_innerNonZeros[outer]++;
+      m_data.index(p) = convert_index(inner);
+      return (m_data.value(p) = Scalar(0));
+    }
+protected:
+    struct IndexPosPair {
+      IndexPosPair(Index a_i, Index a_p) : i(a_i), p(a_p) {}
+      Index i;
+      Index p;
+    };
+
+    /** \internal assign \a diagXpr to the diagonal of \c *this
+      * There are different strategies:
+      *   1 - if *this is overwritten (Func==assign_op) or *this is empty, then we can work treat *this as a dense vector expression.
+      *   2 - otherwise, for each diagonal coeff,
+      *     2.a - if it already exists, then we update it,
+      *     2.b - otherwise, if *this is uncompressed and that the current inner-vector has empty room for at least 1 element, then we perform an in-place insertion.
+      *     2.c - otherwise, we'll have to reallocate and copy everything, so instead of doing so for each new element, it is recorded in a std::vector.
+      *   3 - at the end, if some entries failed to be inserted in-place, then we alloc a new buffer, copy each chunk at the right position, and insert the new elements.
+      * 
+      * TODO: some piece of code could be isolated and reused for a general in-place update strategy.
+      * TODO: if we start to defer the insertion of some elements (i.e., case 2.c executed once),
+      *       then it *might* be better to disable case 2.b since they will have to be copied anyway.
+      */
+    template<typename DiagXpr, typename Func>
+    void assignDiagonal(const DiagXpr diagXpr, const Func& assignFunc)
+    {
+      Index n = diagXpr.size();
+
+      const bool overwrite = internal::is_same<Func, internal::assign_op<Scalar,Scalar> >::value;
+      if(overwrite)
+      {
+        if((this->rows()!=n) || (this->cols()!=n))
+          this->resize(n, n);
+      }
+
+      if(m_data.size()==0 || overwrite)
+      {
+        typedef Array<StorageIndex,Dynamic,1> ArrayXI;  
+        this->makeCompressed();
+        this->resizeNonZeros(n);
+        Eigen::Map<ArrayXI>(this->innerIndexPtr(), n).setLinSpaced(0,StorageIndex(n)-1);
+        Eigen::Map<ArrayXI>(this->outerIndexPtr(), n+1).setLinSpaced(0,StorageIndex(n));
+        Eigen::Map<Array<Scalar,Dynamic,1> > values = this->coeffs();
+        values.setZero();
+        internal::call_assignment_no_alias(values, diagXpr, assignFunc);
+      }
+      else
+      {
+        bool isComp = isCompressed();
+        internal::evaluator<DiagXpr> diaEval(diagXpr);
+        std::vector<IndexPosPair> newEntries;
+
+        // 1 - try in-place update and record insertion failures
+        for(Index i = 0; i<n; ++i)
+        {
+          internal::LowerBoundIndex lb = this->lower_bound(i,i);
+          Index p = lb.value;
+          if(lb.found)
+          {
+            // the coeff already exists
+            assignFunc.assignCoeff(m_data.value(p), diaEval.coeff(i));
+          }
+          else if((!isComp) && m_innerNonZeros[i] < (m_outerIndex[i+1]-m_outerIndex[i]))
+          {
+            // non compressed mode with local room for inserting one element
+            m_data.moveChunk(p, p+1, m_outerIndex[i]+m_innerNonZeros[i]-p);
+            m_innerNonZeros[i]++;
+            m_data.value(p) = Scalar(0);
+            m_data.index(p) = StorageIndex(i);
+            assignFunc.assignCoeff(m_data.value(p), diaEval.coeff(i));
+          }
+          else
+          {
+            // defer insertion
+            newEntries.push_back(IndexPosPair(i,p));
+          }
+        }
+        // 2 - insert deferred entries
+        Index n_entries = Index(newEntries.size());
+        if(n_entries>0)
+        {
+          Storage newData(m_data.size()+n_entries);
+          Index prev_p = 0;
+          Index prev_i = 0;
+          for(Index k=0; k<n_entries;++k)
+          {
+            Index i = newEntries[k].i;
+            Index p = newEntries[k].p;
+            internal::smart_copy(m_data.valuePtr()+prev_p, m_data.valuePtr()+p, newData.valuePtr()+prev_p+k);
+            internal::smart_copy(m_data.indexPtr()+prev_p, m_data.indexPtr()+p, newData.indexPtr()+prev_p+k);
+            for(Index j=prev_i;j<i;++j)
+              m_outerIndex[j+1] += k;
+            if(!isComp)
+              m_innerNonZeros[i]++;
+            prev_p = p;
+            prev_i = i;
+            newData.value(p+k) = Scalar(0);
+            newData.index(p+k) = StorageIndex(i);
+            assignFunc.assignCoeff(newData.value(p+k), diaEval.coeff(i));
+          }
+          {
+            internal::smart_copy(m_data.valuePtr()+prev_p, m_data.valuePtr()+m_data.size(), newData.valuePtr()+prev_p+n_entries);
+            internal::smart_copy(m_data.indexPtr()+prev_p, m_data.indexPtr()+m_data.size(), newData.indexPtr()+prev_p+n_entries);
+            for(Index j=prev_i+1;j<=m_outerSize;++j)
+              m_outerIndex[j] += n_entries;
+          }
+          m_data.swap(newData);
+        }
+      }
+    }
+
+private:
+  static void check_template_parameters()
+  {
+    EIGEN_STATIC_ASSERT(NumTraits<StorageIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE);
+    EIGEN_STATIC_ASSERT((Options&(ColMajor|RowMajor))==Options,INVALID_MATRIX_TEMPLATE_PARAMETERS);
+  }
+
+  struct default_prunning_func {
+    default_prunning_func(const Scalar& ref, const RealScalar& eps) : reference(ref), epsilon(eps) {}
+    inline bool operator() (const Index&, const Index&, const Scalar& value) const
+    {
+      return !internal::isMuchSmallerThan(value, reference, epsilon);
+    }
+    Scalar reference;
+    RealScalar epsilon;
+  };
+};
+
+namespace internal {
+
+template<typename InputIterator, typename SparseMatrixType, typename DupFunctor>
+void set_from_triplets(const InputIterator& begin, const InputIterator& end, SparseMatrixType& mat, DupFunctor dup_func)
+{
+  enum { IsRowMajor = SparseMatrixType::IsRowMajor };
+  typedef typename SparseMatrixType::Scalar Scalar;
+  typedef typename SparseMatrixType::StorageIndex StorageIndex;
+  SparseMatrix<Scalar,IsRowMajor?ColMajor:RowMajor,StorageIndex> trMat(mat.rows(),mat.cols());
+
+  if(begin!=end)
+  {
+    // pass 1: count the nnz per inner-vector
+    typename SparseMatrixType::IndexVector wi(trMat.outerSize());
+    wi.setZero();
+    for(InputIterator it(begin); it!=end; ++it)
+    {
+      eigen_assert(it->row()>=0 && it->row()<mat.rows() && it->col()>=0 && it->col()<mat.cols());
+      wi(IsRowMajor ? it->col() : it->row())++;
+    }
+
+    // pass 2: insert all the elements into trMat
+    trMat.reserve(wi);
+    for(InputIterator it(begin); it!=end; ++it)
+      trMat.insertBackUncompressed(it->row(),it->col()) = it->value();
+
+    // pass 3:
+    trMat.collapseDuplicates(dup_func);
+  }
+
+  // pass 4: transposed copy -> implicit sorting
+  mat = trMat;
+}
+
+}
+
+
+/** Fill the matrix \c *this with the list of \em triplets defined by the iterator range \a begin - \a end.
+  *
+  * A \em triplet is a tuple (i,j,value) defining a non-zero element.
+  * The input list of triplets does not have to be sorted, and can contains duplicated elements.
+  * In any case, the result is a \b sorted and \b compressed sparse matrix where the duplicates have been summed up.
+  * This is a \em O(n) operation, with \em n the number of triplet elements.
+  * The initial contents of \c *this is destroyed.
+  * The matrix \c *this must be properly resized beforehand using the SparseMatrix(Index,Index) constructor,
+  * or the resize(Index,Index) method. The sizes are not extracted from the triplet list.
+  *
+  * The \a InputIterators value_type must provide the following interface:
+  * \code
+  * Scalar value() const; // the value
+  * Scalar row() const;   // the row index i
+  * Scalar col() const;   // the column index j
+  * \endcode
+  * See for instance the Eigen::Triplet template class.
+  *
+  * Here is a typical usage example:
+  * \code
+    typedef Triplet<double> T;
+    std::vector<T> tripletList;
+    tripletList.reserve(estimation_of_entries);
+    for(...)
+    {
+      // ...
+      tripletList.push_back(T(i,j,v_ij));
+    }
+    SparseMatrixType m(rows,cols);
+    m.setFromTriplets(tripletList.begin(), tripletList.end());
+    // m is ready to go!
+  * \endcode
+  *
+  * \warning The list of triplets is read multiple times (at least twice). Therefore, it is not recommended to define
+  * an abstract iterator over a complex data-structure that would be expensive to evaluate. The triplets should rather
+  * be explicitly stored into a std::vector for instance.
+  */
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename InputIterators>
+void SparseMatrix<Scalar,_Options,_StorageIndex>::setFromTriplets(const InputIterators& begin, const InputIterators& end)
+{
+  internal::set_from_triplets<InputIterators, SparseMatrix<Scalar,_Options,_StorageIndex> >(begin, end, *this, internal::scalar_sum_op<Scalar,Scalar>());
+}
+
+/** The same as setFromTriplets but when duplicates are met the functor \a dup_func is applied:
+  * \code
+  * value = dup_func(OldValue, NewValue)
+  * \endcode 
+  * Here is a C++11 example keeping the latest entry only:
+  * \code
+  * mat.setFromTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });
+  * \endcode
+  */
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename InputIterators,typename DupFunctor>
+void SparseMatrix<Scalar,_Options,_StorageIndex>::setFromTriplets(const InputIterators& begin, const InputIterators& end, DupFunctor dup_func)
+{
+  internal::set_from_triplets<InputIterators, SparseMatrix<Scalar,_Options,_StorageIndex>, DupFunctor>(begin, end, *this, dup_func);
+}
+
+/** \internal */
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename DupFunctor>
+void SparseMatrix<Scalar,_Options,_StorageIndex>::collapseDuplicates(DupFunctor dup_func)
+{
+  eigen_assert(!isCompressed());
+  // TODO, in practice we should be able to use m_innerNonZeros for that task
+  IndexVector wi(innerSize());
+  wi.fill(-1);
+  StorageIndex count = 0;
+  // for each inner-vector, wi[inner_index] will hold the position of first element into the index/value buffers
+  for(Index j=0; j<outerSize(); ++j)
+  {
+    StorageIndex start   = count;
+    Index oldEnd  = m_outerIndex[j]+m_innerNonZeros[j];
+    for(Index k=m_outerIndex[j]; k<oldEnd; ++k)
+    {
+      Index i = m_data.index(k);
+      if(wi(i)>=start)
+      {
+        // we already meet this entry => accumulate it
+        m_data.value(wi(i)) = dup_func(m_data.value(wi(i)), m_data.value(k));
+      }
+      else
+      {
+        m_data.value(count) = m_data.value(k);
+        m_data.index(count) = m_data.index(k);
+        wi(i) = count;
+        ++count;
+      }
+    }
+    m_outerIndex[j] = start;
+  }
+  m_outerIndex[m_outerSize] = count;
+
+  // turn the matrix into compressed form
+  std::free(m_innerNonZeros);
+  m_innerNonZeros = 0;
+  m_data.resize(m_outerIndex[m_outerSize]);
+}
+
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename OtherDerived>
+EIGEN_DONT_INLINE SparseMatrix<Scalar,_Options,_StorageIndex>& SparseMatrix<Scalar,_Options,_StorageIndex>::operator=(const SparseMatrixBase<OtherDerived>& other)
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+  #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+    EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+  #endif
+      
+  const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
+  if (needToTranspose)
+  {
+    #ifdef EIGEN_SPARSE_TRANSPOSED_COPY_PLUGIN
+      EIGEN_SPARSE_TRANSPOSED_COPY_PLUGIN
+    #endif
+    // two passes algorithm:
+    //  1 - compute the number of coeffs per dest inner vector
+    //  2 - do the actual copy/eval
+    // Since each coeff of the rhs has to be evaluated twice, let's evaluate it if needed
+    typedef typename internal::nested_eval<OtherDerived,2,typename internal::plain_matrix_type<OtherDerived>::type >::type OtherCopy;
+    typedef typename internal::remove_all<OtherCopy>::type _OtherCopy;
+    typedef internal::evaluator<_OtherCopy> OtherCopyEval;
+    OtherCopy otherCopy(other.derived());
+    OtherCopyEval otherCopyEval(otherCopy);
+
+    SparseMatrix dest(other.rows(),other.cols());
+    Eigen::Map<IndexVector> (dest.m_outerIndex,dest.outerSize()).setZero();
+
+    // pass 1
+    // FIXME the above copy could be merged with that pass
+    for (Index j=0; j<otherCopy.outerSize(); ++j)
+      for (typename OtherCopyEval::InnerIterator it(otherCopyEval, j); it; ++it)
+        ++dest.m_outerIndex[it.index()];
+
+    // prefix sum
+    StorageIndex count = 0;
+    IndexVector positions(dest.outerSize());
+    for (Index j=0; j<dest.outerSize(); ++j)
+    {
+      StorageIndex tmp = dest.m_outerIndex[j];
+      dest.m_outerIndex[j] = count;
+      positions[j] = count;
+      count += tmp;
+    }
+    dest.m_outerIndex[dest.outerSize()] = count;
+    // alloc
+    dest.m_data.resize(count);
+    // pass 2
+    for (StorageIndex j=0; j<otherCopy.outerSize(); ++j)
+    {
+      for (typename OtherCopyEval::InnerIterator it(otherCopyEval, j); it; ++it)
+      {
+        Index pos = positions[it.index()]++;
+        dest.m_data.index(pos) = j;
+        dest.m_data.value(pos) = it.value();
+      }
+    }
+    this->swap(dest);
+    return *this;
+  }
+  else
+  {
+    if(other.isRValue())
+    {
+      initAssignment(other.derived());
+    }
+    // there is no special optimization
+    return Base::operator=(other.derived());
+  }
+}
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+typename SparseMatrix<_Scalar,_Options,_StorageIndex>::Scalar& SparseMatrix<_Scalar,_Options,_StorageIndex>::insert(Index row, Index col)
+{
+  eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
+  
+  const Index outer = IsRowMajor ? row : col;
+  const Index inner = IsRowMajor ? col : row;
+  
+  if(isCompressed())
+  {
+    if(nonZeros()==0)
+    {
+      // reserve space if not already done
+      if(m_data.allocatedSize()==0)
+        m_data.reserve(2*m_innerSize);
+      
+      // turn the matrix into non-compressed mode
+      m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+      if(!m_innerNonZeros) internal::throw_std_bad_alloc();
+      
+      memset(m_innerNonZeros, 0, (m_outerSize)*sizeof(StorageIndex));
+      
+      // pack all inner-vectors to the end of the pre-allocated space
+      // and allocate the entire free-space to the first inner-vector
+      StorageIndex end = convert_index(m_data.allocatedSize());
+      for(Index j=1; j<=m_outerSize; ++j)
+        m_outerIndex[j] = end;
+    }
+    else
+    {
+      // turn the matrix into non-compressed mode
+      m_innerNonZeros = static_cast<StorageIndex*>(std::malloc(m_outerSize * sizeof(StorageIndex)));
+      if(!m_innerNonZeros) internal::throw_std_bad_alloc();
+      for(Index j=0; j<m_outerSize; ++j)
+        m_innerNonZeros[j] = m_outerIndex[j+1]-m_outerIndex[j];
+    }
+  }
+  
+  // check whether we can do a fast "push back" insertion
+  Index data_end = m_data.allocatedSize();
+  
+  // First case: we are filling a new inner vector which is packed at the end.
+  // We assume that all remaining inner-vectors are also empty and packed to the end.
+  if(m_outerIndex[outer]==data_end)
+  {
+    eigen_internal_assert(m_innerNonZeros[outer]==0);
+    
+    // pack previous empty inner-vectors to end of the used-space
+    // and allocate the entire free-space to the current inner-vector.
+    StorageIndex p = convert_index(m_data.size());
+    Index j = outer;
+    while(j>=0 && m_innerNonZeros[j]==0)
+      m_outerIndex[j--] = p;
+    
+    // push back the new element
+    ++m_innerNonZeros[outer];
+    m_data.append(Scalar(0), inner);
+    
+    // check for reallocation
+    if(data_end != m_data.allocatedSize())
+    {
+      // m_data has been reallocated
+      //  -> move remaining inner-vectors back to the end of the free-space
+      //     so that the entire free-space is allocated to the current inner-vector.
+      eigen_internal_assert(data_end < m_data.allocatedSize());
+      StorageIndex new_end = convert_index(m_data.allocatedSize());
+      for(Index k=outer+1; k<=m_outerSize; ++k)
+        if(m_outerIndex[k]==data_end)
+          m_outerIndex[k] = new_end;
+    }
+    return m_data.value(p);
+  }
+  
+  // Second case: the next inner-vector is packed to the end
+  // and the current inner-vector end match the used-space.
+  if(m_outerIndex[outer+1]==data_end && m_outerIndex[outer]+m_innerNonZeros[outer]==m_data.size())
+  {
+    eigen_internal_assert(outer+1==m_outerSize || m_innerNonZeros[outer+1]==0);
+    
+    // add space for the new element
+    ++m_innerNonZeros[outer];
+    m_data.resize(m_data.size()+1);
+    
+    // check for reallocation
+    if(data_end != m_data.allocatedSize())
+    {
+      // m_data has been reallocated
+      //  -> move remaining inner-vectors back to the end of the free-space
+      //     so that the entire free-space is allocated to the current inner-vector.
+      eigen_internal_assert(data_end < m_data.allocatedSize());
+      StorageIndex new_end = convert_index(m_data.allocatedSize());
+      for(Index k=outer+1; k<=m_outerSize; ++k)
+        if(m_outerIndex[k]==data_end)
+          m_outerIndex[k] = new_end;
+    }
+    
+    // and insert it at the right position (sorted insertion)
+    Index startId = m_outerIndex[outer];
+    Index p = m_outerIndex[outer]+m_innerNonZeros[outer]-1;
+    while ( (p > startId) && (m_data.index(p-1) > inner) )
+    {
+      m_data.index(p) = m_data.index(p-1);
+      m_data.value(p) = m_data.value(p-1);
+      --p;
+    }
+    
+    m_data.index(p) = convert_index(inner);
+    return (m_data.value(p) = Scalar(0));
+  }
+  
+  if(m_data.size() != m_data.allocatedSize())
+  {
+    // make sure the matrix is compatible to random un-compressed insertion:
+    m_data.resize(m_data.allocatedSize());
+    this->reserveInnerVectors(Array<StorageIndex,Dynamic,1>::Constant(m_outerSize, 2));
+  }
+  
+  return insertUncompressed(row,col);
+}
+    
+template<typename _Scalar, int _Options, typename _StorageIndex>
+EIGEN_DONT_INLINE typename SparseMatrix<_Scalar,_Options,_StorageIndex>::Scalar& SparseMatrix<_Scalar,_Options,_StorageIndex>::insertUncompressed(Index row, Index col)
+{
+  eigen_assert(!isCompressed());
+
+  const Index outer = IsRowMajor ? row : col;
+  const StorageIndex inner = convert_index(IsRowMajor ? col : row);
+
+  Index room = m_outerIndex[outer+1] - m_outerIndex[outer];
+  StorageIndex innerNNZ = m_innerNonZeros[outer];
+  if(innerNNZ>=room)
+  {
+    // this inner vector is full, we need to reallocate the whole buffer :(
+    reserve(SingletonVector(outer,std::max<StorageIndex>(2,innerNNZ)));
+  }
+
+  Index startId = m_outerIndex[outer];
+  Index p = startId + m_innerNonZeros[outer];
+  while ( (p > startId) && (m_data.index(p-1) > inner) )
+  {
+    m_data.index(p) = m_data.index(p-1);
+    m_data.value(p) = m_data.value(p-1);
+    --p;
+  }
+  eigen_assert((p<=startId || m_data.index(p-1)!=inner) && "you cannot insert an element that already exists, you must call coeffRef to this end");
+
+  m_innerNonZeros[outer]++;
+
+  m_data.index(p) = inner;
+  return (m_data.value(p) = Scalar(0));
+}
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+EIGEN_DONT_INLINE typename SparseMatrix<_Scalar,_Options,_StorageIndex>::Scalar& SparseMatrix<_Scalar,_Options,_StorageIndex>::insertCompressed(Index row, Index col)
+{
+  eigen_assert(isCompressed());
+
+  const Index outer = IsRowMajor ? row : col;
+  const Index inner = IsRowMajor ? col : row;
+
+  Index previousOuter = outer;
+  if (m_outerIndex[outer+1]==0)
+  {
+    // we start a new inner vector
+    while (previousOuter>=0 && m_outerIndex[previousOuter]==0)
+    {
+      m_outerIndex[previousOuter] = convert_index(m_data.size());
+      --previousOuter;
+    }
+    m_outerIndex[outer+1] = m_outerIndex[outer];
+  }
+
+  // here we have to handle the tricky case where the outerIndex array
+  // starts with: [ 0 0 0 0 0 1 ...] and we are inserted in, e.g.,
+  // the 2nd inner vector...
+  bool isLastVec = (!(previousOuter==-1 && m_data.size()!=0))
+                && (std::size_t(m_outerIndex[outer+1]) == m_data.size());
+
+  std::size_t startId = m_outerIndex[outer];
+  // FIXME let's make sure sizeof(long int) == sizeof(std::size_t)
+  std::size_t p = m_outerIndex[outer+1];
+  ++m_outerIndex[outer+1];
+
+  double reallocRatio = 1;
+  if (m_data.allocatedSize()<=m_data.size())
+  {
+    // if there is no preallocated memory, let's reserve a minimum of 32 elements
+    if (m_data.size()==0)
+    {
+      m_data.reserve(32);
+    }
+    else
+    {
+      // we need to reallocate the data, to reduce multiple reallocations
+      // we use a smart resize algorithm based on the current filling ratio
+      // in addition, we use double to avoid integers overflows
+      double nnzEstimate = double(m_outerIndex[outer])*double(m_outerSize)/double(outer+1);
+      reallocRatio = (nnzEstimate-double(m_data.size()))/double(m_data.size());
+      // furthermore we bound the realloc ratio to:
+      //   1) reduce multiple minor realloc when the matrix is almost filled
+      //   2) avoid to allocate too much memory when the matrix is almost empty
+      reallocRatio = (std::min)((std::max)(reallocRatio,1.5),8.);
+    }
+  }
+  m_data.resize(m_data.size()+1,reallocRatio);
+
+  if (!isLastVec)
+  {
+    if (previousOuter==-1)
+    {
+      // oops wrong guess.
+      // let's correct the outer offsets
+      for (Index k=0; k<=(outer+1); ++k)
+        m_outerIndex[k] = 0;
+      Index k=outer+1;
+      while(m_outerIndex[k]==0)
+        m_outerIndex[k++] = 1;
+      while (k<=m_outerSize && m_outerIndex[k]!=0)
+        m_outerIndex[k++]++;
+      p = 0;
+      --k;
+      k = m_outerIndex[k]-1;
+      while (k>0)
+      {
+        m_data.index(k) = m_data.index(k-1);
+        m_data.value(k) = m_data.value(k-1);
+        k--;
+      }
+    }
+    else
+    {
+      // we are not inserting into the last inner vec
+      // update outer indices:
+      Index j = outer+2;
+      while (j<=m_outerSize && m_outerIndex[j]!=0)
+        m_outerIndex[j++]++;
+      --j;
+      // shift data of last vecs:
+      Index k = m_outerIndex[j]-1;
+      while (k>=Index(p))
+      {
+        m_data.index(k) = m_data.index(k-1);
+        m_data.value(k) = m_data.value(k-1);
+        k--;
+      }
+    }
+  }
+
+  while ( (p > startId) && (m_data.index(p-1) > inner) )
+  {
+    m_data.index(p) = m_data.index(p-1);
+    m_data.value(p) = m_data.value(p-1);
+    --p;
+  }
+
+  m_data.index(p) = inner;
+  return (m_data.value(p) = Scalar(0));
+}
+
+namespace internal {
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct evaluator<SparseMatrix<_Scalar,_Options,_StorageIndex> >
+  : evaluator<SparseCompressedBase<SparseMatrix<_Scalar,_Options,_StorageIndex> > >
+{
+  typedef evaluator<SparseCompressedBase<SparseMatrix<_Scalar,_Options,_StorageIndex> > > Base;
+  typedef SparseMatrix<_Scalar,_Options,_StorageIndex> SparseMatrixType;
+  evaluator() : Base() {}
+  explicit evaluator(const SparseMatrixType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEMATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseMatrixBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseMatrixBase.h
new file mode 100644
index 00000000..229449f0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -0,0 +1,398 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEMATRIXBASE_H
+#define EIGEN_SPARSEMATRIXBASE_H
+
+namespace Eigen { 
+
+/** \ingroup SparseCore_Module
+  *
+  * \class SparseMatrixBase
+  *
+  * \brief Base class of any sparse matrices or sparse expressions
+  *
+  * \tparam Derived is the derived type, e.g. a sparse matrix type, or an expression, etc.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_SPARSEMATRIXBASE_PLUGIN.
+  */
+template<typename Derived> class SparseMatrixBase
+  : public EigenBase<Derived>
+{
+  public:
+
+    typedef typename internal::traits<Derived>::Scalar Scalar;
+    
+    /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.
+      *
+      * It is an alias for the Scalar type */
+    typedef Scalar value_type;
+    
+    typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+    typedef typename internal::traits<Derived>::StorageKind StorageKind;
+
+    /** The integer type used to \b store indices within a SparseMatrix.
+      * For a \c SparseMatrix<Scalar,Options,IndexType> it an alias of the third template parameter \c IndexType. */
+    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+
+    typedef typename internal::add_const_on_value_type_if_arithmetic<
+                         typename internal::packet_traits<Scalar>::type
+                     >::type PacketReturnType;
+
+    typedef SparseMatrixBase StorageBaseType;
+
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+    
+    template<typename OtherDerived>
+    Derived& operator=(const EigenBase<OtherDerived> &other);
+
+    enum {
+
+      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
+        /**< The number of rows at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
+
+      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
+        /**< The number of columns at compile-time. This is just a copy of the value provided
+          * by the \a Derived type. If a value is not known at compile-time,
+          * it is set to the \a Dynamic constant.
+          * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
+
+
+      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
+                                                   internal::traits<Derived>::ColsAtCompileTime>::ret),
+        /**< This is equal to the number of coefficients, i.e. the number of
+          * rows times the number of columns, or to \a Dynamic if this is not
+          * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
+
+      MaxRowsAtCompileTime = RowsAtCompileTime,
+      MaxColsAtCompileTime = ColsAtCompileTime,
+
+      MaxSizeAtCompileTime = (internal::size_at_compile_time<MaxRowsAtCompileTime,
+                                                      MaxColsAtCompileTime>::ret),
+
+      IsVectorAtCompileTime = RowsAtCompileTime == 1 || ColsAtCompileTime == 1,
+        /**< This is set to true if either the number of rows or the number of
+          * columns is known at compile-time to be equal to 1. Indeed, in that case,
+          * we are dealing with a column-vector (if there is only one column) or with
+          * a row-vector (if there is only one row). */
+
+      NumDimensions = int(MaxSizeAtCompileTime) == 1 ? 0 : bool(IsVectorAtCompileTime) ? 1 : 2,
+        /**< This value is equal to Tensor::NumDimensions, i.e. 0 for scalars, 1 for vectors,
+         * and 2 for matrices.
+         */
+
+      Flags = internal::traits<Derived>::Flags,
+        /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
+          * constructed from this one. See the \ref flags "list of flags".
+          */
+
+      IsRowMajor = Flags&RowMajorBit ? 1 : 0,
+      
+      InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime)
+                             : int(IsRowMajor) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
+
+      #ifndef EIGEN_PARSED_BY_DOXYGEN
+      _HasDirectAccess = (int(Flags)&DirectAccessBit) ? 1 : 0 // workaround sunCC
+      #endif
+    };
+
+    /** \internal the return type of MatrixBase::adjoint() */
+    typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                        CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Eigen::Transpose<const Derived> >,
+                        Transpose<const Derived>
+                     >::type AdjointReturnType;
+    typedef Transpose<Derived> TransposeReturnType;
+    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
+
+    // FIXME storage order do not match evaluator storage order
+    typedef SparseMatrix<Scalar, Flags&RowMajorBit ? RowMajor : ColMajor, StorageIndex> PlainObject;
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** This is the "real scalar" type; if the \a Scalar type is already real numbers
+      * (e.g. int, float or double) then \a RealScalar is just the same as \a Scalar. If
+      * \a Scalar is \a std::complex<T> then RealScalar is \a T.
+      *
+      * \sa class NumTraits
+      */
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+
+    /** \internal the return type of coeff()
+      */
+    typedef typename internal::conditional<_HasDirectAccess, const Scalar&, Scalar>::type CoeffReturnType;
+
+    /** \internal Represents a matrix with all coefficients equal to one another*/
+    typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Matrix<Scalar,Dynamic,Dynamic> > ConstantReturnType;
+
+    /** type of the equivalent dense matrix */
+    typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> DenseMatrixType;
+    /** type of the equivalent square matrix */
+    typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime),
+                          EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
+
+    inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    inline Derived& derived() { return *static_cast<Derived*>(this); }
+    inline Derived& const_cast_derived() const
+    { return *static_cast<Derived*>(const_cast<SparseMatrixBase*>(this)); }
+
+    typedef EigenBase<Derived> Base;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::SparseMatrixBase
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+#define EIGEN_DOC_UNARY_ADDONS(METHOD,OP)           /** <p>This method does not change the sparsity of \c *this: the OP is applied to explicitly stored coefficients only. \sa SparseCompressedBase::coeffs() </p> */
+#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL      /** <p> \warning This method returns a read-only expression for any sparse matrices. \sa \ref TutorialSparse_SubMatrices "Sparse block operations" </p> */
+#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND) /** <p> \warning This method returns a read-write expression for COND sparse matrices only. Otherwise, the returned expression is read-only. \sa \ref TutorialSparse_SubMatrices "Sparse block operations" </p> */
+#else
+#define EIGEN_DOC_UNARY_ADDONS(X,Y)
+#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND)
+#endif
+#   include "../plugins/CommonCwiseUnaryOps.h"
+#   include "../plugins/CommonCwiseBinaryOps.h"
+#   include "../plugins/MatrixCwiseUnaryOps.h"
+#   include "../plugins/MatrixCwiseBinaryOps.h"
+#   include "../plugins/BlockMethods.h"
+#   ifdef EIGEN_SPARSEMATRIXBASE_PLUGIN
+#     include EIGEN_SPARSEMATRIXBASE_PLUGIN
+#   endif
+#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
+#undef EIGEN_DOC_UNARY_ADDONS
+#undef EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+#undef EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF
+
+    /** \returns the number of rows. \sa cols() */
+    inline Index rows() const { return derived().rows(); }
+    /** \returns the number of columns. \sa rows() */
+    inline Index cols() const { return derived().cols(); }
+    /** \returns the number of coefficients, which is \a rows()*cols().
+      * \sa rows(), cols(). */
+    inline Index size() const { return rows() * cols(); }
+    /** \returns true if either the number of rows or the number of columns is equal to 1.
+      * In other words, this function returns
+      * \code rows()==1 || cols()==1 \endcode
+      * \sa rows(), cols(), IsVectorAtCompileTime. */
+    inline bool isVector() const { return rows()==1 || cols()==1; }
+    /** \returns the size of the storage major dimension,
+      * i.e., the number of columns for a columns major matrix, and the number of rows otherwise */
+    Index outerSize() const { return (int(Flags)&RowMajorBit) ? this->rows() : this->cols(); }
+    /** \returns the size of the inner dimension according to the storage order,
+      * i.e., the number of rows for a columns major matrix, and the number of cols otherwise */
+    Index innerSize() const { return (int(Flags)&RowMajorBit) ? this->cols() : this->rows(); }
+
+    bool isRValue() const { return m_isRValue; }
+    Derived& markAsRValue() { m_isRValue = true; return derived(); }
+
+    SparseMatrixBase() : m_isRValue(false) { /* TODO check flags */ }
+
+    
+    template<typename OtherDerived>
+    Derived& operator=(const ReturnByValue<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    inline Derived& operator=(const SparseMatrixBase<OtherDerived>& other);
+
+    inline Derived& operator=(const Derived& other);
+
+  protected:
+
+    template<typename OtherDerived>
+    inline Derived& assign(const OtherDerived& other);
+
+    template<typename OtherDerived>
+    inline void assignGeneric(const OtherDerived& other);
+
+  public:
+
+    friend std::ostream & operator << (std::ostream & s, const SparseMatrixBase& m)
+    {
+      typedef typename Derived::Nested Nested;
+      typedef typename internal::remove_all<Nested>::type NestedCleaned;
+
+      if (Flags&RowMajorBit)
+      {
+        Nested nm(m.derived());
+        internal::evaluator<NestedCleaned> thisEval(nm);
+        for (Index row=0; row<nm.outerSize(); ++row)
+        {
+          Index col = 0;
+          for (typename internal::evaluator<NestedCleaned>::InnerIterator it(thisEval, row); it; ++it)
+          {
+            for ( ; col<it.index(); ++col)
+              s << "0 ";
+            s << it.value() << " ";
+            ++col;
+          }
+          for ( ; col<m.cols(); ++col)
+            s << "0 ";
+          s << std::endl;
+        }
+      }
+      else
+      {
+        Nested nm(m.derived());
+        internal::evaluator<NestedCleaned> thisEval(nm);
+        if (m.cols() == 1) {
+          Index row = 0;
+          for (typename internal::evaluator<NestedCleaned>::InnerIterator it(thisEval, 0); it; ++it)
+          {
+            for ( ; row<it.index(); ++row)
+              s << "0" << std::endl;
+            s << it.value() << std::endl;
+            ++row;
+          }
+          for ( ; row<m.rows(); ++row)
+            s << "0" << std::endl;
+        }
+        else
+        {
+          SparseMatrix<Scalar, RowMajorBit, StorageIndex> trans = m;
+          s << static_cast<const SparseMatrixBase<SparseMatrix<Scalar, RowMajorBit, StorageIndex> >&>(trans);
+        }
+      }
+      return s;
+    }
+
+    template<typename OtherDerived>
+    Derived& operator+=(const SparseMatrixBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    Derived& operator-=(const SparseMatrixBase<OtherDerived>& other);
+    
+    template<typename OtherDerived>
+    Derived& operator+=(const DiagonalBase<OtherDerived>& other);
+    template<typename OtherDerived>
+    Derived& operator-=(const DiagonalBase<OtherDerived>& other);
+
+    template<typename OtherDerived>
+    Derived& operator+=(const EigenBase<OtherDerived> &other);
+    template<typename OtherDerived>
+    Derived& operator-=(const EigenBase<OtherDerived> &other);
+
+    Derived& operator*=(const Scalar& other);
+    Derived& operator/=(const Scalar& other);
+
+    template<typename OtherDerived> struct CwiseProductDenseReturnType {
+      typedef CwiseBinaryOp<internal::scalar_product_op<typename ScalarBinaryOpTraits<
+                                                          typename internal::traits<Derived>::Scalar,
+                                                          typename internal::traits<OtherDerived>::Scalar
+                                                        >::ReturnType>,
+                            const Derived,
+                            const OtherDerived
+                          > Type;
+    };
+
+    template<typename OtherDerived>
+    EIGEN_STRONG_INLINE const typename CwiseProductDenseReturnType<OtherDerived>::Type
+    cwiseProduct(const MatrixBase<OtherDerived> &other) const;
+
+    // sparse * diagonal
+    template<typename OtherDerived>
+    const Product<Derived,OtherDerived>
+    operator*(const DiagonalBase<OtherDerived> &other) const
+    { return Product<Derived,OtherDerived>(derived(), other.derived()); }
+
+    // diagonal * sparse
+    template<typename OtherDerived> friend
+    const Product<OtherDerived,Derived>
+    operator*(const DiagonalBase<OtherDerived> &lhs, const SparseMatrixBase& rhs)
+    { return Product<OtherDerived,Derived>(lhs.derived(), rhs.derived()); }
+    
+    // sparse * sparse
+    template<typename OtherDerived>
+    const Product<Derived,OtherDerived,AliasFreeProduct>
+    operator*(const SparseMatrixBase<OtherDerived> &other) const;
+    
+    // sparse * dense
+    template<typename OtherDerived>
+    const Product<Derived,OtherDerived>
+    operator*(const MatrixBase<OtherDerived> &other) const
+    { return Product<Derived,OtherDerived>(derived(), other.derived()); }
+    
+    // dense * sparse
+    template<typename OtherDerived> friend
+    const Product<OtherDerived,Derived>
+    operator*(const MatrixBase<OtherDerived> &lhs, const SparseMatrixBase& rhs)
+    { return Product<OtherDerived,Derived>(lhs.derived(), rhs.derived()); }
+    
+     /** \returns an expression of P H P^-1 where H is the matrix represented by \c *this */
+    SparseSymmetricPermutationProduct<Derived,Upper|Lower> twistedBy(const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& perm) const
+    {
+      return SparseSymmetricPermutationProduct<Derived,Upper|Lower>(derived(), perm);
+    }
+
+    template<typename OtherDerived>
+    Derived& operator*=(const SparseMatrixBase<OtherDerived>& other);
+
+    template<int Mode>
+    inline const TriangularView<const Derived, Mode> triangularView() const;
+    
+    template<unsigned int UpLo> struct SelfAdjointViewReturnType { typedef SparseSelfAdjointView<Derived, UpLo> Type; };
+    template<unsigned int UpLo> struct ConstSelfAdjointViewReturnType { typedef const SparseSelfAdjointView<const Derived, UpLo> Type; };
+
+    template<unsigned int UpLo> inline 
+    typename ConstSelfAdjointViewReturnType<UpLo>::Type selfadjointView() const;
+    template<unsigned int UpLo> inline
+    typename SelfAdjointViewReturnType<UpLo>::Type selfadjointView();
+
+    template<typename OtherDerived> Scalar dot(const MatrixBase<OtherDerived>& other) const;
+    template<typename OtherDerived> Scalar dot(const SparseMatrixBase<OtherDerived>& other) const;
+    RealScalar squaredNorm() const;
+    RealScalar norm()  const;
+    RealScalar blueNorm() const;
+
+    TransposeReturnType transpose() { return TransposeReturnType(derived()); }
+    const ConstTransposeReturnType transpose() const { return ConstTransposeReturnType(derived()); }
+    const AdjointReturnType adjoint() const { return AdjointReturnType(transpose()); }
+
+    DenseMatrixType toDense() const
+    {
+      return DenseMatrixType(derived());
+    }
+
+    template<typename OtherDerived>
+    bool isApprox(const SparseMatrixBase<OtherDerived>& other,
+                  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const;
+
+    template<typename OtherDerived>
+    bool isApprox(const MatrixBase<OtherDerived>& other,
+                  const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const
+    { return toDense().isApprox(other,prec); }
+
+    /** \returns the matrix or vector obtained by evaluating this expression.
+      *
+      * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
+      * a const reference, in order to avoid a useless copy.
+      */
+    inline const typename internal::eval<Derived>::type eval() const
+    { return typename internal::eval<Derived>::type(derived()); }
+
+    Scalar sum() const;
+    
+    inline const SparseView<Derived>
+    pruned(const Scalar& reference = Scalar(0), const RealScalar& epsilon = NumTraits<Scalar>::dummy_precision()) const;
+
+  protected:
+
+    bool m_isRValue;
+
+    static inline StorageIndex convert_index(const Index idx) {
+      return internal::convert_index<StorageIndex>(idx);
+    }
+  private:
+    template<typename Dest> void evalTo(Dest &) const;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEMATRIXBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparsePermutation.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparsePermutation.h
new file mode 100644
index 00000000..ef38357a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparsePermutation.h
@@ -0,0 +1,178 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_PERMUTATION_H
+#define EIGEN_SPARSE_PERMUTATION_H
+
+// This file implements sparse * permutation products
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename ExpressionType, int Side, bool Transposed>
+struct permutation_matrix_product<ExpressionType, Side, Transposed, SparseShape>
+{
+    typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
+    typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
+
+    typedef typename MatrixTypeCleaned::Scalar Scalar;
+    typedef typename MatrixTypeCleaned::StorageIndex StorageIndex;
+
+    enum {
+      SrcStorageOrder = MatrixTypeCleaned::Flags&RowMajorBit ? RowMajor : ColMajor,
+      MoveOuter = SrcStorageOrder==RowMajor ? Side==OnTheLeft : Side==OnTheRight
+    };
+    
+    typedef typename internal::conditional<MoveOuter,
+        SparseMatrix<Scalar,SrcStorageOrder,StorageIndex>,
+        SparseMatrix<Scalar,int(SrcStorageOrder)==RowMajor?ColMajor:RowMajor,StorageIndex> >::type ReturnType;
+
+    template<typename Dest,typename PermutationType>
+    static inline void run(Dest& dst, const PermutationType& perm, const ExpressionType& xpr)
+    {
+      MatrixType mat(xpr);
+      if(MoveOuter)
+      {
+        SparseMatrix<Scalar,SrcStorageOrder,StorageIndex> tmp(mat.rows(), mat.cols());
+        Matrix<StorageIndex,Dynamic,1> sizes(mat.outerSize());
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          Index jp = perm.indices().coeff(j);
+          sizes[((Side==OnTheLeft) ^ Transposed) ? jp : j] = StorageIndex(mat.innerVector(((Side==OnTheRight) ^ Transposed) ? jp : j).nonZeros());
+        }
+        tmp.reserve(sizes);
+        for(Index j=0; j<mat.outerSize(); ++j)
+        {
+          Index jp = perm.indices().coeff(j);
+          Index jsrc = ((Side==OnTheRight) ^ Transposed) ? jp : j;
+          Index jdst = ((Side==OnTheLeft) ^ Transposed) ? jp : j;
+          for(typename MatrixTypeCleaned::InnerIterator it(mat,jsrc); it; ++it)
+            tmp.insertByOuterInner(jdst,it.index()) = it.value();
+        }
+        dst = tmp;
+      }
+      else
+      {
+        SparseMatrix<Scalar,int(SrcStorageOrder)==RowMajor?ColMajor:RowMajor,StorageIndex> tmp(mat.rows(), mat.cols());
+        Matrix<StorageIndex,Dynamic,1> sizes(tmp.outerSize());
+        sizes.setZero();
+        PermutationMatrix<Dynamic,Dynamic,StorageIndex> perm_cpy;
+        if((Side==OnTheLeft) ^ Transposed)
+          perm_cpy = perm;
+        else
+          perm_cpy = perm.transpose();
+
+        for(Index j=0; j<mat.outerSize(); ++j)
+          for(typename MatrixTypeCleaned::InnerIterator it(mat,j); it; ++it)
+            sizes[perm_cpy.indices().coeff(it.index())]++;
+        tmp.reserve(sizes);
+        for(Index j=0; j<mat.outerSize(); ++j)
+          for(typename MatrixTypeCleaned::InnerIterator it(mat,j); it; ++it)
+            tmp.insertByOuterInner(perm_cpy.indices().coeff(it.index()),j) = it.value();
+        dst = tmp;
+      }
+    }
+};
+
+}
+
+namespace internal {
+
+template <int ProductTag> struct product_promote_storage_type<Sparse,             PermutationStorage, ProductTag> { typedef Sparse ret; };
+template <int ProductTag> struct product_promote_storage_type<PermutationStorage, Sparse,             ProductTag> { typedef Sparse ret; };
+
+// TODO, the following two overloads are only needed to define the right temporary type through 
+// typename traits<permutation_sparse_matrix_product<Rhs,Lhs,OnTheRight,false> >::ReturnType
+// whereas it should be correctly handled by traits<Product<> >::PlainObject
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, AliasFreeProduct>, ProductTag, PermutationShape, SparseShape>
+  : public evaluator<typename permutation_matrix_product<Rhs,OnTheLeft,false,SparseShape>::ReturnType>
+{
+  typedef Product<Lhs, Rhs, AliasFreeProduct> XprType;
+  typedef typename permutation_matrix_product<Rhs,OnTheLeft,false,SparseShape>::ReturnType PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+
+  explicit product_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<Lhs, Rhs, PermutationShape, SparseShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+template<typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, AliasFreeProduct>, ProductTag, SparseShape, PermutationShape >
+  : public evaluator<typename permutation_matrix_product<Lhs,OnTheRight,false,SparseShape>::ReturnType>
+{
+  typedef Product<Lhs, Rhs, AliasFreeProduct> XprType;
+  typedef typename permutation_matrix_product<Lhs,OnTheRight,false,SparseShape>::ReturnType PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  enum {
+    Flags = Base::Flags | EvalBeforeNestingBit
+  };
+
+  explicit product_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<Lhs, Rhs, SparseShape, PermutationShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+/** \returns the matrix with the permutation applied to the columns
+  */
+template<typename SparseDerived, typename PermDerived>
+inline const Product<SparseDerived, PermDerived, AliasFreeProduct>
+operator*(const SparseMatrixBase<SparseDerived>& matrix, const PermutationBase<PermDerived>& perm)
+{ return Product<SparseDerived, PermDerived, AliasFreeProduct>(matrix.derived(), perm.derived()); }
+
+/** \returns the matrix with the permutation applied to the rows
+  */
+template<typename SparseDerived, typename PermDerived>
+inline const Product<PermDerived, SparseDerived, AliasFreeProduct>
+operator*( const PermutationBase<PermDerived>& perm, const SparseMatrixBase<SparseDerived>& matrix)
+{ return  Product<PermDerived, SparseDerived, AliasFreeProduct>(perm.derived(), matrix.derived()); }
+
+
+/** \returns the matrix with the inverse permutation applied to the columns.
+  */
+template<typename SparseDerived, typename PermutationType>
+inline const Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>
+operator*(const SparseMatrixBase<SparseDerived>& matrix, const InverseImpl<PermutationType, PermutationStorage>& tperm)
+{
+  return Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>(matrix.derived(), tperm.derived());
+}
+
+/** \returns the matrix with the inverse permutation applied to the rows.
+  */
+template<typename SparseDerived, typename PermutationType>
+inline const Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>
+operator*(const InverseImpl<PermutationType,PermutationStorage>& tperm, const SparseMatrixBase<SparseDerived>& matrix)
+{
+  return Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>(tperm.derived(), matrix.derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_SELFADJOINTVIEW_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseProduct.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseProduct.h
new file mode 100644
index 00000000..af8a7744
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseProduct.h
@@ -0,0 +1,181 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEPRODUCT_H
+#define EIGEN_SPARSEPRODUCT_H
+
+namespace Eigen { 
+
+/** \returns an expression of the product of two sparse matrices.
+  * By default a conservative product preserving the symbolic non zeros is performed.
+  * The automatic pruning of the small values can be achieved by calling the pruned() function
+  * in which case a totally different product algorithm is employed:
+  * \code
+  * C = (A*B).pruned();             // suppress numerical zeros (exact)
+  * C = (A*B).pruned(ref);
+  * C = (A*B).pruned(ref,epsilon);
+  * \endcode
+  * where \c ref is a meaningful non zero reference value.
+  * */
+template<typename Derived>
+template<typename OtherDerived>
+inline const Product<Derived,OtherDerived,AliasFreeProduct>
+SparseMatrixBase<Derived>::operator*(const SparseMatrixBase<OtherDerived> &other) const
+{
+  return Product<Derived,OtherDerived,AliasFreeProduct>(derived(), other.derived());
+}
+
+namespace internal {
+
+// sparse * sparse
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
+{
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
+  {
+    evalTo(dst, lhs, rhs, typename evaluator_traits<Dest>::Shape());
+  }
+
+  // dense += sparse * sparse
+  template<typename Dest,typename ActualLhs>
+  static void addTo(Dest& dst, const ActualLhs& lhs, const Rhs& rhs, typename enable_if<is_same<typename evaluator_traits<Dest>::Shape,DenseShape>::value,int*>::type* = 0)
+  {
+    typedef typename nested_eval<ActualLhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    internal::sparse_sparse_to_dense_product_selector<typename remove_all<LhsNested>::type,
+                                                      typename remove_all<RhsNested>::type, Dest>::run(lhsNested,rhsNested,dst);
+  }
+
+  // dense -= sparse * sparse
+  template<typename Dest>
+  static void subTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, typename enable_if<is_same<typename evaluator_traits<Dest>::Shape,DenseShape>::value,int*>::type* = 0)
+  {
+    addTo(dst, -lhs, rhs);
+  }
+
+protected:
+
+  // sparse = sparse * sparse
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, SparseShape)
+  {
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhs);
+    internal::conservative_sparse_sparse_product_selector<typename remove_all<LhsNested>::type,
+                                                          typename remove_all<RhsNested>::type, Dest>::run(lhsNested,rhsNested,dst);
+  }
+
+  // dense = sparse * sparse
+  template<typename Dest>
+  static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, DenseShape)
+  {
+    dst.setZero();
+    addTo(dst, lhs, rhs);
+  }
+};
+
+// sparse * sparse-triangular
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseShape, SparseTriangularShape, ProductType>
+ : public generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
+{};
+
+// sparse-triangular * sparse
+template<typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, SparseTriangularShape, SparseShape, ProductType>
+ : public generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
+{};
+
+// dense = sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template< typename DstXprType, typename Lhs, typename Rhs>
+struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
+{
+  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
+  {
+    Index dstRows = src.rows();
+    Index dstCols = src.cols();
+    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
+      dst.resize(dstRows, dstCols);
+    
+    generic_product_impl<Lhs, Rhs>::evalTo(dst,src.lhs(),src.rhs());
+  }
+};
+
+// dense += sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template< typename DstXprType, typename Lhs, typename Rhs>
+struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::add_assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
+{
+  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
+  {
+    generic_product_impl<Lhs, Rhs>::addTo(dst,src.lhs(),src.rhs());
+  }
+};
+
+// dense -= sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template< typename DstXprType, typename Lhs, typename Rhs>
+struct Assignment<DstXprType, Product<Lhs,Rhs,AliasFreeProduct>, internal::sub_assign_op<typename DstXprType::Scalar,typename Product<Lhs,Rhs,AliasFreeProduct>::Scalar>, Sparse2Dense>
+{
+  typedef Product<Lhs,Rhs,AliasFreeProduct> SrcXprType;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &)
+  {
+    generic_product_impl<Lhs, Rhs>::subTo(dst,src.lhs(),src.rhs());
+  }
+};
+
+template<typename Lhs, typename Rhs, int Options>
+struct unary_evaluator<SparseView<Product<Lhs, Rhs, Options> >, IteratorBased>
+ : public evaluator<typename Product<Lhs, Rhs, DefaultProduct>::PlainObject>
+{
+  typedef SparseView<Product<Lhs, Rhs, Options> > XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  explicit unary_evaluator(const XprType& xpr)
+    : m_result(xpr.rows(), xpr.cols())
+  {
+    using std::abs;
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(xpr.nestedExpression().lhs());
+    RhsNested rhsNested(xpr.nestedExpression().rhs());
+
+    internal::sparse_sparse_product_with_pruning_selector<typename remove_all<LhsNested>::type,
+                                                          typename remove_all<RhsNested>::type, PlainObject>::run(lhsNested,rhsNested,m_result,
+                                                                                                                  abs(xpr.reference())*xpr.epsilon());
+  }
+
+protected:
+  PlainObject m_result;
+};
+
+} // end namespace internal
+
+// sparse matrix = sparse-product (can be sparse*sparse, sparse*perm, etc.)
+template<typename Scalar, int _Options, typename _StorageIndex>
+template<typename Lhs, typename Rhs>
+SparseMatrix<Scalar,_Options,_StorageIndex>& SparseMatrix<Scalar,_Options,_StorageIndex>::operator=(const Product<Lhs,Rhs,AliasFreeProduct>& src)
+{
+  // std::cout << "in Assignment : " << DstOptions << "\n";
+  SparseMatrix dst(src.rows(),src.cols());
+  internal::generic_product_impl<Lhs, Rhs>::evalTo(dst,src.lhs(),src.rhs());
+  this->swap(dst);
+  return *this;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEPRODUCT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseRedux.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseRedux.h
new file mode 100644
index 00000000..45877496
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseRedux.h
@@ -0,0 +1,49 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEREDUX_H
+#define EIGEN_SPARSEREDUX_H
+
+namespace Eigen { 
+
+template<typename Derived>
+typename internal::traits<Derived>::Scalar
+SparseMatrixBase<Derived>::sum() const
+{
+  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
+  Scalar res(0);
+  internal::evaluator<Derived> thisEval(derived());
+  for (Index j=0; j<outerSize(); ++j)
+    for (typename internal::evaluator<Derived>::InnerIterator iter(thisEval,j); iter; ++iter)
+      res += iter.value();
+  return res;
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+typename internal::traits<SparseMatrix<_Scalar,_Options,_Index> >::Scalar
+SparseMatrix<_Scalar,_Options,_Index>::sum() const
+{
+  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
+  if(this->isCompressed())
+    return Matrix<Scalar,1,Dynamic>::Map(m_data.valuePtr(), m_data.size()).sum();
+  else
+    return Base::sum();
+}
+
+template<typename _Scalar, int _Options, typename _Index>
+typename internal::traits<SparseVector<_Scalar,_Options, _Index> >::Scalar
+SparseVector<_Scalar,_Options,_Index>::sum() const
+{
+  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
+  return Matrix<Scalar,1,Dynamic>::Map(m_data.valuePtr(), m_data.size()).sum();
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEREDUX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseRef.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseRef.h
new file mode 100644
index 00000000..748f87d6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseRef.h
@@ -0,0 +1,397 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_REF_H
+#define EIGEN_SPARSE_REF_H
+
+namespace Eigen {
+
+enum {
+  StandardCompressedFormat = 2 /**< used by Ref<SparseMatrix> to specify whether the input storage must be in standard compressed form */
+};
+  
+namespace internal {
+
+template<typename Derived> class SparseRefBase;
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  enum {
+    Options = _Options,
+    Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit
+  };
+
+  template<typename Derived> struct match {
+    enum {
+      StorageOrderMatch = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime || ((PlainObjectType::Flags&RowMajorBit)==(Derived::Flags&RowMajorBit)),
+      MatchAtCompileTime = (Derived::Flags&CompressedAccessBit) && StorageOrderMatch
+    };
+    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
+  };
+  
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+{
+  enum {
+    Flags = (traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >::Flags | CompressedAccessBit | NestByRefBit) & ~LvalueBit
+  };
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<SparseVector<MatScalar,MatOptions,MatIndex> >
+{
+  typedef SparseVector<MatScalar,MatOptions,MatIndex> PlainObjectType;
+  enum {
+    Options = _Options,
+    Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit
+  };
+
+  template<typename Derived> struct match {
+    enum {
+      MatchAtCompileTime = (Derived::Flags&CompressedAccessBit) && Derived::IsVectorAtCompileTime
+    };
+    typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
+  };
+
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType>
+struct traits<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+  : public traits<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> >
+{
+  enum {
+    Flags = (traits<SparseVector<MatScalar,MatOptions,MatIndex> >::Flags | CompressedAccessBit | NestByRefBit) & ~LvalueBit
+  };
+};
+
+template<typename Derived>
+struct traits<SparseRefBase<Derived> > : public traits<Derived> {};
+
+template<typename Derived> class SparseRefBase
+  : public SparseMapBase<Derived>
+{
+public:
+
+  typedef SparseMapBase<Derived> Base;
+  EIGEN_SPARSE_PUBLIC_INTERFACE(SparseRefBase)
+
+  SparseRefBase()
+    : Base(RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime, 0, 0, 0, 0, 0)
+  {}
+  
+protected:
+
+  template<typename Expression>
+  void construct(Expression& expr)
+  {
+    if(expr.outerIndexPtr()==0)
+      ::new (static_cast<Base*>(this)) Base(expr.size(), expr.nonZeros(), expr.innerIndexPtr(), expr.valuePtr());
+    else
+      ::new (static_cast<Base*>(this)) Base(expr.rows(), expr.cols(), expr.nonZeros(), expr.outerIndexPtr(), expr.innerIndexPtr(), expr.valuePtr(), expr.innerNonZeroPtr());
+  }
+};
+
+} // namespace internal
+
+
+/** 
+  * \ingroup SparseCore_Module
+  *
+  * \brief A sparse matrix expression referencing an existing sparse expression
+  *
+  * \tparam SparseMatrixType the equivalent sparse matrix type of the referenced data, it must be a template instance of class SparseMatrix.
+  * \tparam Options specifies whether the a standard compressed format is required \c Options is  \c #StandardCompressedFormat, or \c 0.
+  *                The default is \c 0.
+  *
+  * \sa class Ref
+  */
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType >
+  : public internal::SparseRefBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType > >
+#else
+template<typename SparseMatrixType, int Options>
+class Ref<SparseMatrixType, Options>
+  : public SparseMapBase<Derived,WriteAccessors> // yes, that's weird to use Derived here, but that works!
+#endif
+{
+    typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType;
+    typedef internal::traits<Ref> Traits;
+    template<int OtherOptions>
+    inline Ref(const SparseMatrix<MatScalar,OtherOptions,MatIndex>& expr);
+    template<int OtherOptions>
+    inline Ref(const MappedSparseMatrix<MatScalar,OtherOptions,MatIndex>& expr);
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<int OtherOptions>
+    inline Ref(SparseMatrix<MatScalar,OtherOptions,MatIndex>& expr)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseMatrix<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
+      Base::construct(expr.derived());
+    }
+    
+    template<int OtherOptions>
+    inline Ref(MappedSparseMatrix<MatScalar,OtherOptions,MatIndex>& expr)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseMatrix<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
+      Base::construct(expr.derived());
+    }
+    
+    template<typename Derived>
+    inline Ref(const SparseCompressedBase<Derived>& expr)
+    #else
+    /** Implicit constructor from any sparse expression (2D matrix or 1D vector) */
+    template<typename Derived>
+    inline Ref(SparseCompressedBase<Derived>& expr)
+    #endif
+    {
+      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) );
+      Base::construct(expr.const_cast_derived());
+    }
+};
+
+// this is the const ref version
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public internal::SparseRefBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+{
+    typedef SparseMatrix<MatScalar,MatOptions,MatIndex> TPlainObjectType;
+    typedef internal::traits<Ref> Traits;
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+    template<typename Derived>
+    inline Ref(const SparseMatrixBase<Derived>& expr) : m_hasCopy(false)
+    {
+      construct(expr.derived(), typename Traits::template match<Derived>::type());
+    }
+
+    inline Ref(const Ref& other) : Base(other), m_hasCopy(false) {
+      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
+    }
+
+    template<typename OtherRef>
+    inline Ref(const RefBase<OtherRef>& other) : m_hasCopy(false) {
+      construct(other.derived(), typename Traits::template match<OtherRef>::type());
+    }
+
+    ~Ref() {
+      if(m_hasCopy) {
+        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
+        obj->~TPlainObjectType();
+      }
+    }
+
+  protected:
+
+    template<typename Expression>
+    void construct(const Expression& expr,internal::true_type)
+    {
+      if((Options & int(StandardCompressedFormat)) && (!expr.isCompressed()))
+      {
+        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
+        ::new (obj) TPlainObjectType(expr);
+        m_hasCopy = true;
+        Base::construct(*obj);
+      }
+      else
+      {
+        Base::construct(expr);
+      }
+    }
+
+    template<typename Expression>
+    void construct(const Expression& expr, internal::false_type)
+    {
+      TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
+      ::new (obj) TPlainObjectType(expr);
+      m_hasCopy = true;
+      Base::construct(*obj);
+    }
+
+  protected:
+    typename internal::aligned_storage<sizeof(TPlainObjectType), EIGEN_ALIGNOF(TPlainObjectType)>::type m_storage;
+    bool m_hasCopy;
+};
+
+
+
+/**
+  * \ingroup SparseCore_Module
+  *
+  * \brief A sparse vector expression referencing an existing sparse vector expression
+  *
+  * \tparam SparseVectorType the equivalent sparse vector type of the referenced data, it must be a template instance of class SparseVector.
+  *
+  * \sa class Ref
+  */
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType >
+  : public internal::SparseRefBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType > >
+#else
+template<typename SparseVectorType>
+class Ref<SparseVectorType>
+  : public SparseMapBase<Derived,WriteAccessors>
+#endif
+{
+    typedef SparseVector<MatScalar,MatOptions,MatIndex> PlainObjectType;
+    typedef internal::traits<Ref> Traits;
+    template<int OtherOptions>
+    inline Ref(const SparseVector<MatScalar,OtherOptions,MatIndex>& expr);
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<int OtherOptions>
+    inline Ref(SparseVector<MatScalar,OtherOptions,MatIndex>& expr)
+    {
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseVector<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      Base::construct(expr.derived());
+    }
+
+    template<typename Derived>
+    inline Ref(const SparseCompressedBase<Derived>& expr)
+    #else
+    /** Implicit constructor from any 1D sparse vector expression */
+    template<typename Derived>
+    inline Ref(SparseCompressedBase<Derived>& expr)
+    #endif
+    {
+      EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
+      EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+      Base::construct(expr.const_cast_derived());
+    }
+};
+
+// this is the const ref version
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+class Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType>
+  : public internal::SparseRefBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+{
+    typedef SparseVector<MatScalar,MatOptions,MatIndex> TPlainObjectType;
+    typedef internal::traits<Ref> Traits;
+  public:
+
+    typedef internal::SparseRefBase<Ref> Base;
+    EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
+
+    template<typename Derived>
+    inline Ref(const SparseMatrixBase<Derived>& expr) : m_hasCopy(false)
+    {
+      construct(expr.derived(), typename Traits::template match<Derived>::type());
+    }
+
+    inline Ref(const Ref& other) : Base(other), m_hasCopy(false) {
+      // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
+    }
+
+    template<typename OtherRef>
+    inline Ref(const RefBase<OtherRef>& other) : m_hasCopy(false) {
+      construct(other.derived(), typename Traits::template match<OtherRef>::type());
+    }
+
+    ~Ref() {
+      if(m_hasCopy) {
+        TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
+        obj->~TPlainObjectType();
+      }
+    }
+
+  protected:
+
+    template<typename Expression>
+    void construct(const Expression& expr,internal::true_type)
+    {
+      Base::construct(expr);
+    }
+
+    template<typename Expression>
+    void construct(const Expression& expr, internal::false_type)
+    {
+      TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage);
+      ::new (obj) TPlainObjectType(expr);
+      m_hasCopy = true;
+      Base::construct(*obj);
+    }
+
+  protected:
+    typename internal::aligned_storage<sizeof(TPlainObjectType), EIGEN_ALIGNOF(TPlainObjectType)>::type m_storage;
+    bool m_hasCopy;
+};
+
+namespace internal {
+
+// FIXME shall we introduce a general evaluatior_ref that we can specialize for any sparse object once, and thus remove this copy-pasta thing...
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;  
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
+struct evaluator<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
+  : evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
+{
+  typedef evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base;
+  typedef Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType;
+  evaluator() : Base() {}
+  explicit evaluator(const XprType &mat) : Base(mat) {}
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_REF_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseSelfAdjointView.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseSelfAdjointView.h
new file mode 100644
index 00000000..85b00e10
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseSelfAdjointView.h
@@ -0,0 +1,659 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_SELFADJOINTVIEW_H
+#define EIGEN_SPARSE_SELFADJOINTVIEW_H
+
+namespace Eigen { 
+  
+/** \ingroup SparseCore_Module
+  * \class SparseSelfAdjointView
+  *
+  * \brief Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix.
+  *
+  * \param MatrixType the type of the dense matrix storing the coefficients
+  * \param Mode can be either \c #Lower or \c #Upper
+  *
+  * This class is an expression of a sefladjoint matrix from a triangular part of a matrix
+  * with given dense storage of the coefficients. It is the return type of MatrixBase::selfadjointView()
+  * and most of the time this is the only way that it is used.
+  *
+  * \sa SparseMatrixBase::selfadjointView()
+  */
+namespace internal {
+  
+template<typename MatrixType, unsigned int Mode>
+struct traits<SparseSelfAdjointView<MatrixType,Mode> > : traits<MatrixType> {
+};
+
+template<int SrcMode,int DstMode,typename MatrixType,int DestOrder>
+void permute_symm_to_symm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm = 0);
+
+template<int Mode,typename MatrixType,int DestOrder>
+void permute_symm_to_fullsymm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm = 0);
+
+}
+
+template<typename MatrixType, unsigned int _Mode> class SparseSelfAdjointView
+  : public EigenBase<SparseSelfAdjointView<MatrixType,_Mode> >
+{
+  public:
+    
+    enum {
+      Mode = _Mode,
+      TransposeMode = ((Mode & Upper) ? Lower : 0) | ((Mode & Lower) ? Upper : 0),
+      RowsAtCompileTime = internal::traits<SparseSelfAdjointView>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<SparseSelfAdjointView>::ColsAtCompileTime
+    };
+
+    typedef EigenBase<SparseSelfAdjointView> Base;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+    typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+    typedef typename internal::remove_all<MatrixTypeNested>::type _MatrixTypeNested;
+    
+    explicit inline SparseSelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
+    {
+      eigen_assert(rows()==cols() && "SelfAdjointView is only for squared matrices");
+    }
+
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+
+    /** \internal \returns a reference to the nested matrix */
+    const _MatrixTypeNested& matrix() const { return m_matrix; }
+    typename internal::remove_reference<MatrixTypeNested>::type& matrix() { return m_matrix; }
+
+    /** \returns an expression of the matrix product between a sparse self-adjoint matrix \c *this and a sparse matrix \a rhs.
+      *
+      * Note that there is no algorithmic advantage of performing such a product compared to a general sparse-sparse matrix product.
+      * Indeed, the SparseSelfadjointView operand is first copied into a temporary SparseMatrix before computing the product.
+      */
+    template<typename OtherDerived>
+    Product<SparseSelfAdjointView, OtherDerived>
+    operator*(const SparseMatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<SparseSelfAdjointView, OtherDerived>(*this, rhs.derived());
+    }
+
+    /** \returns an expression of the matrix product between a sparse matrix \a lhs and a sparse self-adjoint matrix \a rhs.
+      *
+      * Note that there is no algorithmic advantage of performing such a product compared to a general sparse-sparse matrix product.
+      * Indeed, the SparseSelfadjointView operand is first copied into a temporary SparseMatrix before computing the product.
+      */
+    template<typename OtherDerived> friend
+    Product<OtherDerived, SparseSelfAdjointView>
+    operator*(const SparseMatrixBase<OtherDerived>& lhs, const SparseSelfAdjointView& rhs)
+    {
+      return Product<OtherDerived, SparseSelfAdjointView>(lhs.derived(), rhs);
+    }
+    
+    /** Efficient sparse self-adjoint matrix times dense vector/matrix product */
+    template<typename OtherDerived>
+    Product<SparseSelfAdjointView,OtherDerived>
+    operator*(const MatrixBase<OtherDerived>& rhs) const
+    {
+      return Product<SparseSelfAdjointView,OtherDerived>(*this, rhs.derived());
+    }
+
+    /** Efficient dense vector/matrix times sparse self-adjoint matrix product */
+    template<typename OtherDerived> friend
+    Product<OtherDerived,SparseSelfAdjointView>
+    operator*(const MatrixBase<OtherDerived>& lhs, const SparseSelfAdjointView& rhs)
+    {
+      return Product<OtherDerived,SparseSelfAdjointView>(lhs.derived(), rhs);
+    }
+
+    /** Perform a symmetric rank K update of the selfadjoint matrix \c *this:
+      * \f$ this = this + \alpha ( u u^* ) \f$ where \a u is a vector or matrix.
+      *
+      * \returns a reference to \c *this
+      *
+      * To perform \f$ this = this + \alpha ( u^* u ) \f$ you can simply
+      * call this function with u.adjoint().
+      */
+    template<typename DerivedU>
+    SparseSelfAdjointView& rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha = Scalar(1));
+    
+    /** \returns an expression of P H P^-1 */
+    // TODO implement twists in a more evaluator friendly fashion
+    SparseSymmetricPermutationProduct<_MatrixTypeNested,Mode> twistedBy(const PermutationMatrix<Dynamic,Dynamic,StorageIndex>& perm) const
+    {
+      return SparseSymmetricPermutationProduct<_MatrixTypeNested,Mode>(m_matrix, perm);
+    }
+
+    template<typename SrcMatrixType,int SrcMode>
+    SparseSelfAdjointView& operator=(const SparseSymmetricPermutationProduct<SrcMatrixType,SrcMode>& permutedMatrix)
+    {
+      internal::call_assignment_no_alias_no_transpose(*this, permutedMatrix);
+      return *this;
+    }
+
+    SparseSelfAdjointView& operator=(const SparseSelfAdjointView& src)
+    {
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> pnull;
+      return *this = src.twistedBy(pnull);
+    }
+
+    // Since we override the copy-assignment operator, we need to explicitly re-declare the copy-constructor
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(SparseSelfAdjointView)
+
+    template<typename SrcMatrixType,unsigned int SrcMode>
+    SparseSelfAdjointView& operator=(const SparseSelfAdjointView<SrcMatrixType,SrcMode>& src)
+    {
+      PermutationMatrix<Dynamic,Dynamic,StorageIndex> pnull;
+      return *this = src.twistedBy(pnull);
+    }
+    
+    void resize(Index rows, Index cols)
+    {
+      EIGEN_ONLY_USED_FOR_DEBUG(rows);
+      EIGEN_ONLY_USED_FOR_DEBUG(cols);
+      eigen_assert(rows == this->rows() && cols == this->cols()
+                && "SparseSelfadjointView::resize() does not actually allow to resize.");
+    }
+    
+  protected:
+
+    MatrixTypeNested m_matrix;
+    //mutable VectorI m_countPerRow;
+    //mutable VectorI m_countPerCol;
+  private:
+    template<typename Dest> void evalTo(Dest &) const;
+};
+
+/***************************************************************************
+* Implementation of SparseMatrixBase methods
+***************************************************************************/
+
+template<typename Derived>
+template<unsigned int UpLo>
+typename SparseMatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type SparseMatrixBase<Derived>::selfadjointView() const
+{
+  return SparseSelfAdjointView<const Derived, UpLo>(derived());
+}
+
+template<typename Derived>
+template<unsigned int UpLo>
+typename SparseMatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type SparseMatrixBase<Derived>::selfadjointView()
+{
+  return SparseSelfAdjointView<Derived, UpLo>(derived());
+}
+
+/***************************************************************************
+* Implementation of SparseSelfAdjointView methods
+***************************************************************************/
+
+template<typename MatrixType, unsigned int Mode>
+template<typename DerivedU>
+SparseSelfAdjointView<MatrixType,Mode>&
+SparseSelfAdjointView<MatrixType,Mode>::rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha)
+{
+  SparseMatrix<Scalar,(MatrixType::Flags&RowMajorBit)?RowMajor:ColMajor> tmp = u * u.adjoint();
+  if(alpha==Scalar(0))
+    m_matrix = tmp.template triangularView<Mode>();
+  else
+    m_matrix += alpha * tmp.template triangularView<Mode>();
+
+  return *this;
+}
+
+namespace internal {
+  
+// TODO currently a selfadjoint expression has the form SelfAdjointView<.,.>
+//      in the future selfadjoint-ness should be defined by the expression traits
+//      such that Transpose<SelfAdjointView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
+template<typename MatrixType, unsigned int Mode>
+struct evaluator_traits<SparseSelfAdjointView<MatrixType,Mode> >
+{
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef SparseSelfAdjointShape Shape;
+};
+
+struct SparseSelfAdjoint2Sparse {};
+
+template<> struct AssignmentKind<SparseShape,SparseSelfAdjointShape> { typedef SparseSelfAdjoint2Sparse Kind; };
+template<> struct AssignmentKind<SparseSelfAdjointShape,SparseShape> { typedef Sparse2Sparse Kind; };
+
+template< typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse>
+{
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  typedef internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> AssignOpType;
+
+  template<typename DestScalar,int StorageOrder>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const AssignOpType&/*func*/)
+  {
+    internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), dst);
+  }
+
+  // FIXME: the handling of += and -= in sparse matrices should be cleanup so that next two overloads could be reduced to:
+  template<typename DestScalar,int StorageOrder,typename AssignFunc>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const AssignFunc& func)
+  {
+    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
+    run(tmp, src, AssignOpType());
+    call_assignment_no_alias_no_transpose(dst, tmp, func);
+  }
+
+  template<typename DestScalar,int StorageOrder>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src,
+                  const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>& /* func */)
+  {
+    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
+    run(tmp, src, AssignOpType());
+    dst += tmp;
+  }
+
+  template<typename DestScalar,int StorageOrder>
+  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src,
+                  const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>& /* func */)
+  {
+    SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
+    run(tmp, src, AssignOpType());
+    dst -= tmp;
+  }
+  
+  template<typename DestScalar>
+  static void run(DynamicSparseMatrix<DestScalar,ColMajor,StorageIndex>& dst, const SrcXprType &src, const AssignOpType&/*func*/)
+  {
+    // TODO directly evaluate into dst;
+    SparseMatrix<DestScalar,ColMajor,StorageIndex> tmp(dst.rows(),dst.cols());
+    internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), tmp);
+    dst = tmp;
+  }
+};
+
+} // end namespace internal
+
+/***************************************************************************
+* Implementation of sparse self-adjoint time dense matrix
+***************************************************************************/
+
+namespace internal {
+
+template<int Mode, typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>
+inline void sparse_selfadjoint_time_dense_product(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
+{
+  EIGEN_ONLY_USED_FOR_DEBUG(alpha);
+  
+  typedef typename internal::nested_eval<SparseLhsType,DenseRhsType::MaxColsAtCompileTime>::type SparseLhsTypeNested;
+  typedef typename internal::remove_all<SparseLhsTypeNested>::type SparseLhsTypeNestedCleaned;
+  typedef evaluator<SparseLhsTypeNestedCleaned> LhsEval;
+  typedef typename LhsEval::InnerIterator LhsIterator;
+  typedef typename SparseLhsType::Scalar LhsScalar;
+  
+  enum {
+    LhsIsRowMajor = (LhsEval::Flags&RowMajorBit)==RowMajorBit,
+    ProcessFirstHalf =
+              ((Mode&(Upper|Lower))==(Upper|Lower))
+          || ( (Mode&Upper) && !LhsIsRowMajor)
+          || ( (Mode&Lower) && LhsIsRowMajor),
+    ProcessSecondHalf = !ProcessFirstHalf
+  };
+  
+  SparseLhsTypeNested lhs_nested(lhs);
+  LhsEval lhsEval(lhs_nested);
+
+  // work on one column at once
+  for (Index k=0; k<rhs.cols(); ++k)
+  {
+    for (Index j=0; j<lhs.outerSize(); ++j)
+    {
+      LhsIterator i(lhsEval,j);
+      // handle diagonal coeff
+      if (ProcessSecondHalf)
+      {
+        while (i && i.index()<j) ++i;
+        if(i && i.index()==j)
+        {
+          res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
+          ++i;
+        }
+      }
+
+      // premultiplied rhs for scatters
+      typename ScalarBinaryOpTraits<AlphaType, typename DenseRhsType::Scalar>::ReturnType rhs_j(alpha*rhs(j,k));
+      // accumulator for partial scalar product
+      typename DenseResType::Scalar res_j(0);
+      for(; (ProcessFirstHalf ? i && i.index() < j : i) ; ++i)
+      {
+        LhsScalar lhs_ij = i.value();
+        if(!LhsIsRowMajor) lhs_ij = numext::conj(lhs_ij);
+        res_j += lhs_ij * rhs.coeff(i.index(),k);
+        res(i.index(),k) += numext::conj(lhs_ij) * rhs_j;
+      }
+      res.coeffRef(j,k) += alpha * res_j;
+
+      // handle diagonal coeff
+      if (ProcessFirstHalf && i && (i.index()==j))
+        res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
+    }
+  }
+}
+
+
+template<typename LhsView, typename Rhs, int ProductType>
+struct generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType>
+: generic_product_impl_base<LhsView, Rhs, generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType> >
+{
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const LhsView& lhsView, const Rhs& rhs, const typename Dest::Scalar& alpha)
+  {
+    typedef typename LhsView::_MatrixTypeNested Lhs;
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhsView.matrix());
+    RhsNested rhsNested(rhs);
+    
+    internal::sparse_selfadjoint_time_dense_product<LhsView::Mode>(lhsNested, rhsNested, dst, alpha);
+  }
+};
+
+template<typename Lhs, typename RhsView, int ProductType>
+struct generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType>
+: generic_product_impl_base<Lhs, RhsView, generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType> >
+{
+  template<typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const RhsView& rhsView, const typename Dest::Scalar& alpha)
+  {
+    typedef typename RhsView::_MatrixTypeNested Rhs;
+    typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
+    typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
+    LhsNested lhsNested(lhs);
+    RhsNested rhsNested(rhsView.matrix());
+    
+    // transpose everything
+    Transpose<Dest> dstT(dst);
+    internal::sparse_selfadjoint_time_dense_product<RhsView::TransposeMode>(rhsNested.transpose(), lhsNested.transpose(), dstT, alpha);
+  }
+};
+
+// NOTE: these two overloads are needed to evaluate the sparse selfadjoint view into a full sparse matrix
+// TODO: maybe the copy could be handled by generic_product_impl so that these overloads would not be needed anymore
+
+template<typename LhsView, typename Rhs, int ProductTag>
+struct product_evaluator<Product<LhsView, Rhs, DefaultProduct>, ProductTag, SparseSelfAdjointShape, SparseShape>
+  : public evaluator<typename Product<typename Rhs::PlainObject, Rhs, DefaultProduct>::PlainObject>
+{
+  typedef Product<LhsView, Rhs, DefaultProduct> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  product_evaluator(const XprType& xpr)
+    : m_lhs(xpr.lhs()), m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<typename Rhs::PlainObject, Rhs, SparseShape, SparseShape, ProductTag>::evalTo(m_result, m_lhs, xpr.rhs());
+  }
+  
+protected:
+  typename Rhs::PlainObject m_lhs;
+  PlainObject m_result;
+};
+
+template<typename Lhs, typename RhsView, int ProductTag>
+struct product_evaluator<Product<Lhs, RhsView, DefaultProduct>, ProductTag, SparseShape, SparseSelfAdjointShape>
+  : public evaluator<typename Product<Lhs, typename Lhs::PlainObject, DefaultProduct>::PlainObject>
+{
+  typedef Product<Lhs, RhsView, DefaultProduct> XprType;
+  typedef typename XprType::PlainObject PlainObject;
+  typedef evaluator<PlainObject> Base;
+
+  product_evaluator(const XprType& xpr)
+    : m_rhs(xpr.rhs()), m_result(xpr.rows(), xpr.cols())
+  {
+    ::new (static_cast<Base*>(this)) Base(m_result);
+    generic_product_impl<Lhs, typename Lhs::PlainObject, SparseShape, SparseShape, ProductTag>::evalTo(m_result, xpr.lhs(), m_rhs);
+  }
+  
+protected:
+  typename Lhs::PlainObject m_rhs;
+  PlainObject m_result;
+};
+
+} // namespace internal
+
+/***************************************************************************
+* Implementation of symmetric copies and permutations
+***************************************************************************/
+namespace internal {
+
+template<int Mode,typename MatrixType,int DestOrder>
+void permute_symm_to_fullsymm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm)
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef SparseMatrix<Scalar,DestOrder,StorageIndex> Dest;
+  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+  typedef evaluator<MatrixType> MatEval;
+  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
+  
+  MatEval matEval(mat);
+  Dest& dest(_dest.derived());
+  enum {
+    StorageOrderMatch = int(Dest::IsRowMajor) == int(MatrixType::IsRowMajor)
+  };
+  
+  Index size = mat.rows();
+  VectorI count;
+  count.resize(size);
+  count.setZero();
+  dest.resize(size,size);
+  for(Index j = 0; j<size; ++j)
+  {
+    Index jp = perm ? perm[j] : j;
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      Index i = it.index();
+      Index r = it.row();
+      Index c = it.col();
+      Index ip = perm ? perm[i] : i;
+      if(Mode==int(Upper|Lower))
+        count[StorageOrderMatch ? jp : ip]++;
+      else if(r==c)
+        count[ip]++;
+      else if(( Mode==Lower && r>c) || ( Mode==Upper && r<c))
+      {
+        count[ip]++;
+        count[jp]++;
+      }
+    }
+  }
+  Index nnz = count.sum();
+  
+  // reserve space
+  dest.resizeNonZeros(nnz);
+  dest.outerIndexPtr()[0] = 0;
+  for(Index j=0; j<size; ++j)
+    dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
+  for(Index j=0; j<size; ++j)
+    count[j] = dest.outerIndexPtr()[j];
+  
+  // copy data
+  for(StorageIndex j = 0; j<size; ++j)
+  {
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      StorageIndex i = internal::convert_index<StorageIndex>(it.index());
+      Index r = it.row();
+      Index c = it.col();
+      
+      StorageIndex jp = perm ? perm[j] : j;
+      StorageIndex ip = perm ? perm[i] : i;
+      
+      if(Mode==int(Upper|Lower))
+      {
+        Index k = count[StorageOrderMatch ? jp : ip]++;
+        dest.innerIndexPtr()[k] = StorageOrderMatch ? ip : jp;
+        dest.valuePtr()[k] = it.value();
+      }
+      else if(r==c)
+      {
+        Index k = count[ip]++;
+        dest.innerIndexPtr()[k] = ip;
+        dest.valuePtr()[k] = it.value();
+      }
+      else if(( (Mode&Lower)==Lower && r>c) || ( (Mode&Upper)==Upper && r<c))
+      {
+        if(!StorageOrderMatch)
+          std::swap(ip,jp);
+        Index k = count[jp]++;
+        dest.innerIndexPtr()[k] = ip;
+        dest.valuePtr()[k] = it.value();
+        k = count[ip]++;
+        dest.innerIndexPtr()[k] = jp;
+        dest.valuePtr()[k] = numext::conj(it.value());
+      }
+    }
+  }
+}
+
+template<int _SrcMode,int _DstMode,typename MatrixType,int DstOrder>
+void permute_symm_to_symm(const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DstOrder,typename MatrixType::StorageIndex>& _dest, const typename MatrixType::StorageIndex* perm)
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef typename MatrixType::Scalar Scalar;
+  SparseMatrix<Scalar,DstOrder,StorageIndex>& dest(_dest.derived());
+  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+  typedef evaluator<MatrixType> MatEval;
+  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
+
+  enum {
+    SrcOrder = MatrixType::IsRowMajor ? RowMajor : ColMajor,
+    StorageOrderMatch = int(SrcOrder) == int(DstOrder),
+    DstMode = DstOrder==RowMajor ? (_DstMode==Upper ? Lower : Upper) : _DstMode,
+    SrcMode = SrcOrder==RowMajor ? (_SrcMode==Upper ? Lower : Upper) : _SrcMode
+  };
+
+  MatEval matEval(mat);
+  
+  Index size = mat.rows();
+  VectorI count(size);
+  count.setZero();
+  dest.resize(size,size);
+  for(StorageIndex j = 0; j<size; ++j)
+  {
+    StorageIndex jp = perm ? perm[j] : j;
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
+        continue;
+                  
+      StorageIndex ip = perm ? perm[i] : i;
+      count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
+    }
+  }
+  dest.outerIndexPtr()[0] = 0;
+  for(Index j=0; j<size; ++j)
+    dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
+  dest.resizeNonZeros(dest.outerIndexPtr()[size]);
+  for(Index j=0; j<size; ++j)
+    count[j] = dest.outerIndexPtr()[j];
+  
+  for(StorageIndex j = 0; j<size; ++j)
+  {
+    
+    for(MatIterator it(matEval,j); it; ++it)
+    {
+      StorageIndex i = it.index();
+      if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
+        continue;
+                  
+      StorageIndex jp = perm ? perm[j] : j;
+      StorageIndex ip = perm? perm[i] : i;
+      
+      Index k = count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
+      dest.innerIndexPtr()[k] = int(DstMode)==int(Lower) ? (std::max)(ip,jp) : (std::min)(ip,jp);
+      
+      if(!StorageOrderMatch) std::swap(ip,jp);
+      if( ((int(DstMode)==int(Lower) && ip<jp) || (int(DstMode)==int(Upper) && ip>jp)))
+        dest.valuePtr()[k] = numext::conj(it.value());
+      else
+        dest.valuePtr()[k] = it.value();
+    }
+  }
+}
+
+}
+
+// TODO implement twists in a more evaluator friendly fashion
+
+namespace internal {
+
+template<typename MatrixType, int Mode>
+struct traits<SparseSymmetricPermutationProduct<MatrixType,Mode> > : traits<MatrixType> {
+};
+
+}
+
+template<typename MatrixType,int Mode>
+class SparseSymmetricPermutationProduct
+  : public EigenBase<SparseSymmetricPermutationProduct<MatrixType,Mode> >
+{
+  public:
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    enum {
+      RowsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::RowsAtCompileTime,
+      ColsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::ColsAtCompileTime
+    };
+  protected:
+    typedef PermutationMatrix<Dynamic,Dynamic,StorageIndex> Perm;
+  public:
+    typedef Matrix<StorageIndex,Dynamic,1> VectorI;
+    typedef typename MatrixType::Nested MatrixTypeNested;
+    typedef typename internal::remove_all<MatrixTypeNested>::type NestedExpression;
+    
+    SparseSymmetricPermutationProduct(const MatrixType& mat, const Perm& perm)
+      : m_matrix(mat), m_perm(perm)
+    {}
+    
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+        
+    const NestedExpression& matrix() const { return m_matrix; }
+    const Perm& perm() const { return m_perm; }
+    
+  protected:
+    MatrixTypeNested m_matrix;
+    const Perm& m_perm;
+
+};
+
+namespace internal {
+  
+template<typename DstXprType, typename MatrixType, int Mode, typename Scalar>
+struct Assignment<DstXprType, SparseSymmetricPermutationProduct<MatrixType,Mode>, internal::assign_op<Scalar,typename MatrixType::Scalar>, Sparse2Sparse>
+{
+  typedef SparseSymmetricPermutationProduct<MatrixType,Mode> SrcXprType;
+  typedef typename DstXprType::StorageIndex DstIndex;
+  template<int Options>
+  static void run(SparseMatrix<Scalar,Options,DstIndex> &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename MatrixType::Scalar> &)
+  {
+    // internal::permute_symm_to_fullsymm<Mode>(m_matrix,_dest,m_perm.indices().data());
+    SparseMatrix<Scalar,(Options&RowMajor)==RowMajor ? ColMajor : RowMajor, DstIndex> tmp;
+    internal::permute_symm_to_fullsymm<Mode>(src.matrix(),tmp,src.perm().indices().data());
+    dst = tmp;
+  }
+  
+  template<typename DestType,unsigned int DestMode>
+  static void run(SparseSelfAdjointView<DestType,DestMode>& dst, const SrcXprType &src, const internal::assign_op<Scalar,typename MatrixType::Scalar> &)
+  {
+    internal::permute_symm_to_symm<Mode,DestMode>(src.matrix(),dst.matrix(),src.perm().indices().data());
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_SELFADJOINTVIEW_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseSolverBase.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseSolverBase.h
new file mode 100644
index 00000000..b4c9a422
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseSolverBase.h
@@ -0,0 +1,124 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSESOLVERBASE_H
+#define EIGEN_SPARSESOLVERBASE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+  /** \internal
+  * Helper functions to solve with a sparse right-hand-side and result.
+  * The rhs is decomposed into small vertical panels which are solved through dense temporaries.
+  */
+template<typename Decomposition, typename Rhs, typename Dest>
+typename enable_if<Rhs::ColsAtCompileTime!=1 && Dest::ColsAtCompileTime!=1>::type
+solve_sparse_through_dense_panels(const Decomposition &dec, const Rhs& rhs, Dest &dest)
+{
+  EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  typedef typename Dest::Scalar DestScalar;
+  // we process the sparse rhs per block of NbColsAtOnce columns temporarily stored into a dense matrix.
+  static const Index NbColsAtOnce = 4;
+  Index rhsCols = rhs.cols();
+  Index size = rhs.rows();
+  // the temporary matrices do not need more columns than NbColsAtOnce:
+  Index tmpCols = (std::min)(rhsCols, NbColsAtOnce); 
+  Eigen::Matrix<DestScalar,Dynamic,Dynamic> tmp(size,tmpCols);
+  Eigen::Matrix<DestScalar,Dynamic,Dynamic> tmpX(size,tmpCols);
+  for(Index k=0; k<rhsCols; k+=NbColsAtOnce)
+  {
+    Index actualCols = std::min<Index>(rhsCols-k, NbColsAtOnce);
+    tmp.leftCols(actualCols) = rhs.middleCols(k,actualCols);
+    tmpX.leftCols(actualCols) = dec.solve(tmp.leftCols(actualCols));
+    dest.middleCols(k,actualCols) = tmpX.leftCols(actualCols).sparseView();
+  }
+}
+
+// Overload for vector as rhs
+template<typename Decomposition, typename Rhs, typename Dest>
+typename enable_if<Rhs::ColsAtCompileTime==1 || Dest::ColsAtCompileTime==1>::type
+solve_sparse_through_dense_panels(const Decomposition &dec, const Rhs& rhs, Dest &dest)
+{
+  typedef typename Dest::Scalar DestScalar;
+  Index size = rhs.rows();
+  Eigen::Matrix<DestScalar,Dynamic,1> rhs_dense(rhs);
+  Eigen::Matrix<DestScalar,Dynamic,1> dest_dense(size);
+  dest_dense = dec.solve(rhs_dense);
+  dest = dest_dense.sparseView();
+}
+
+} // end namespace internal
+
+/** \class SparseSolverBase
+  * \ingroup SparseCore_Module
+  * \brief A base class for sparse solvers
+  *
+  * \tparam Derived the actual type of the solver.
+  *
+  */
+template<typename Derived>
+class SparseSolverBase : internal::noncopyable
+{
+  public:
+
+    /** Default constructor */
+    SparseSolverBase()
+      : m_isInitialized(false)
+    {}
+
+    ~SparseSolverBase()
+    {}
+
+    Derived& derived() { return *static_cast<Derived*>(this); }
+    const Derived& derived() const { return *static_cast<const Derived*>(this); }
+    
+    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<Derived, Rhs>
+    solve(const MatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "Solver is not initialized.");
+      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<Derived, Rhs>(derived(), b.derived());
+    }
+    
+    /** \returns an expression of the solution x of \f$ A x = b \f$ using the current decomposition of A.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<Derived, Rhs>
+    solve(const SparseMatrixBase<Rhs>& b) const
+    {
+      eigen_assert(m_isInitialized && "Solver is not initialized.");
+      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
+      return Solve<Derived, Rhs>(derived(), b.derived());
+    }
+    
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal default implementation of solving with a sparse rhs */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const SparseMatrixBase<Rhs> &b, SparseMatrixBase<Dest> &dest) const
+    {
+      internal::solve_sparse_through_dense_panels(derived(), b.derived(), dest.derived());
+    }
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+
+  protected:
+    
+    mutable bool m_isInitialized;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSESOLVERBASE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseSparseProductWithPruning.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseSparseProductWithPruning.h
new file mode 100644
index 00000000..88820a48
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseSparseProductWithPruning.h
@@ -0,0 +1,198 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
+#define EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
+
+namespace Eigen { 
+
+namespace internal {
+
+
+// perform a pseudo in-place sparse * sparse product assuming all matrices are col major
+template<typename Lhs, typename Rhs, typename ResultType>
+static void sparse_sparse_product_with_pruning_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res, const typename ResultType::RealScalar& tolerance)
+{
+  // return sparse_sparse_product_with_pruning_impl2(lhs,rhs,res);
+
+  typedef typename remove_all<Rhs>::type::Scalar RhsScalar;
+  typedef typename remove_all<ResultType>::type::Scalar ResScalar;
+  typedef typename remove_all<Lhs>::type::StorageIndex StorageIndex;
+
+  // make sure to call innerSize/outerSize since we fake the storage order.
+  Index rows = lhs.innerSize();
+  Index cols = rhs.outerSize();
+  //Index size = lhs.outerSize();
+  eigen_assert(lhs.outerSize() == rhs.innerSize());
+
+  // allocate a temporary buffer
+  AmbiVector<ResScalar,StorageIndex> tempVector(rows);
+
+  // mimics a resizeByInnerOuter:
+  if(ResultType::IsRowMajor)
+    res.resize(cols, rows);
+  else
+    res.resize(rows, cols);
+  
+  evaluator<Lhs> lhsEval(lhs);
+  evaluator<Rhs> rhsEval(rhs);
+  
+  // estimate the number of non zero entries
+  // given a rhs column containing Y non zeros, we assume that the respective Y columns
+  // of the lhs differs in average of one non zeros, thus the number of non zeros for
+  // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
+  // per column of the lhs.
+  // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
+  Index estimated_nnz_prod = lhsEval.nonZerosEstimate() + rhsEval.nonZerosEstimate();
+
+  res.reserve(estimated_nnz_prod);
+  double ratioColRes = double(estimated_nnz_prod)/(double(lhs.rows())*double(rhs.cols()));
+  for (Index j=0; j<cols; ++j)
+  {
+    // FIXME:
+    //double ratioColRes = (double(rhs.innerVector(j).nonZeros()) + double(lhs.nonZeros())/double(lhs.cols()))/double(lhs.rows());
+    // let's do a more accurate determination of the nnz ratio for the current column j of res
+    tempVector.init(ratioColRes);
+    tempVector.setZero();
+    for (typename evaluator<Rhs>::InnerIterator rhsIt(rhsEval, j); rhsIt; ++rhsIt)
+    {
+      // FIXME should be written like this: tmp += rhsIt.value() * lhs.col(rhsIt.index())
+      tempVector.restart();
+      RhsScalar x = rhsIt.value();
+      for (typename evaluator<Lhs>::InnerIterator lhsIt(lhsEval, rhsIt.index()); lhsIt; ++lhsIt)
+      {
+        tempVector.coeffRef(lhsIt.index()) += lhsIt.value() * x;
+      }
+    }
+    res.startVec(j);
+    for (typename AmbiVector<ResScalar,StorageIndex>::Iterator it(tempVector,tolerance); it; ++it)
+      res.insertBackByOuterInner(j,it.index()) = it.value();
+  }
+  res.finalize();
+}
+
+template<typename Lhs, typename Rhs, typename ResultType,
+  int LhsStorageOrder = traits<Lhs>::Flags&RowMajorBit,
+  int RhsStorageOrder = traits<Rhs>::Flags&RowMajorBit,
+  int ResStorageOrder = traits<ResultType>::Flags&RowMajorBit>
+struct sparse_sparse_product_with_pruning_selector;
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typename remove_all<ResultType>::type _res(res.rows(), res.cols());
+    internal::sparse_sparse_product_with_pruning_impl<Lhs,Rhs,ResultType>(lhs, rhs, _res, tolerance);
+    res.swap(_res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    // we need a col-major matrix to hold the result
+    typedef SparseMatrix<typename ResultType::Scalar,ColMajor,typename ResultType::StorageIndex> SparseTemporaryType;
+    SparseTemporaryType _res(res.rows(), res.cols());
+    internal::sparse_sparse_product_with_pruning_impl<Lhs,Rhs,SparseTemporaryType>(lhs, rhs, _res, tolerance);
+    res = _res;
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    // let's transpose the product to get a column x column product
+    typename remove_all<ResultType>::type _res(res.rows(), res.cols());
+    internal::sparse_sparse_product_with_pruning_impl<Rhs,Lhs,ResultType>(rhs, lhs, _res, tolerance);
+    res.swap(_res);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixLhs;
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixRhs;
+    ColMajorMatrixLhs colLhs(lhs);
+    ColMajorMatrixRhs colRhs(rhs);
+    internal::sparse_sparse_product_with_pruning_impl<ColMajorMatrixLhs,ColMajorMatrixRhs,ResultType>(colLhs, colRhs, res, tolerance);
+
+    // let's transpose the product to get a column x column product
+//     typedef SparseMatrix<typename ResultType::Scalar> SparseTemporaryType;
+//     SparseTemporaryType _res(res.cols(), res.rows());
+//     sparse_sparse_product_with_pruning_impl<Rhs,Lhs,SparseTemporaryType>(rhs, lhs, _res);
+//     res = _res.transpose();
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,RowMajor,typename Lhs::StorageIndex> RowMajorMatrixLhs;
+    RowMajorMatrixLhs rowLhs(lhs);
+    sparse_sparse_product_with_pruning_selector<RowMajorMatrixLhs,Rhs,ResultType,RowMajor,RowMajor>(rowLhs,rhs,res,tolerance);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,RowMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,RowMajor,typename Lhs::StorageIndex> RowMajorMatrixRhs;
+    RowMajorMatrixRhs rowRhs(rhs);
+    sparse_sparse_product_with_pruning_selector<Lhs,RowMajorMatrixRhs,ResultType,RowMajor,RowMajor,RowMajor>(lhs,rowRhs,res,tolerance);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,ColMajor,RowMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Rhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixRhs;
+    ColMajorMatrixRhs colRhs(rhs);
+    internal::sparse_sparse_product_with_pruning_impl<Lhs,ColMajorMatrixRhs,ResultType>(lhs, colRhs, res, tolerance);
+  }
+};
+
+template<typename Lhs, typename Rhs, typename ResultType>
+struct sparse_sparse_product_with_pruning_selector<Lhs,Rhs,ResultType,RowMajor,ColMajor,ColMajor>
+{
+  typedef typename ResultType::RealScalar RealScalar;
+  static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance)
+  {
+    typedef SparseMatrix<typename Lhs::Scalar,ColMajor,typename Lhs::StorageIndex> ColMajorMatrixLhs;
+    ColMajorMatrixLhs colLhs(lhs);
+    internal::sparse_sparse_product_with_pruning_impl<ColMajorMatrixLhs,Rhs,ResultType>(colLhs, rhs, res, tolerance);
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseTranspose.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseTranspose.h
new file mode 100644
index 00000000..3757d4c6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseTranspose.h
@@ -0,0 +1,92 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSETRANSPOSE_H
+#define EIGEN_SPARSETRANSPOSE_H
+
+namespace Eigen { 
+
+namespace internal {
+  template<typename MatrixType,int CompressedAccess=int(MatrixType::Flags&CompressedAccessBit)>
+  class SparseTransposeImpl
+    : public SparseMatrixBase<Transpose<MatrixType> >
+  {};
+  
+  template<typename MatrixType>
+  class SparseTransposeImpl<MatrixType,CompressedAccessBit>
+    : public SparseCompressedBase<Transpose<MatrixType> >
+  {
+    typedef SparseCompressedBase<Transpose<MatrixType> > Base;
+  public:
+    using Base::derived;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::StorageIndex StorageIndex;
+
+    inline Index nonZeros() const { return derived().nestedExpression().nonZeros(); }
+    
+    inline const Scalar* valuePtr() const { return derived().nestedExpression().valuePtr(); }
+    inline const StorageIndex* innerIndexPtr() const { return derived().nestedExpression().innerIndexPtr(); }
+    inline const StorageIndex* outerIndexPtr() const { return derived().nestedExpression().outerIndexPtr(); }
+    inline const StorageIndex* innerNonZeroPtr() const { return derived().nestedExpression().innerNonZeroPtr(); }
+
+    inline Scalar* valuePtr() { return derived().nestedExpression().valuePtr(); }
+    inline StorageIndex* innerIndexPtr() { return derived().nestedExpression().innerIndexPtr(); }
+    inline StorageIndex* outerIndexPtr() { return derived().nestedExpression().outerIndexPtr(); }
+    inline StorageIndex* innerNonZeroPtr() { return derived().nestedExpression().innerNonZeroPtr(); }
+  };
+}
+  
+template<typename MatrixType> class TransposeImpl<MatrixType,Sparse>
+  : public internal::SparseTransposeImpl<MatrixType>
+{
+  protected:
+    typedef internal::SparseTransposeImpl<MatrixType> Base;
+};
+
+namespace internal {
+  
+template<typename ArgType>
+struct unary_evaluator<Transpose<ArgType>, IteratorBased>
+  : public evaluator_base<Transpose<ArgType> >
+{
+    typedef typename evaluator<ArgType>::InnerIterator        EvalIterator;
+  public:
+    typedef Transpose<ArgType> XprType;
+    
+    inline Index nonZerosEstimate() const {
+      return m_argImpl.nonZerosEstimate();
+    }
+
+    class InnerIterator : public EvalIterator
+    {
+    public:
+      EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
+        : EvalIterator(unaryOp.m_argImpl,outer)
+      {}
+      
+      Index row() const { return EvalIterator::col(); }
+      Index col() const { return EvalIterator::row(); }
+    };
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& op) :m_argImpl(op.nestedExpression()) {}
+
+  protected:
+    evaluator<ArgType> m_argImpl;
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSETRANSPOSE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseTriangularView.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseTriangularView.h
new file mode 100644
index 00000000..9ac12026
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseTriangularView.h
@@ -0,0 +1,189 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_TRIANGULARVIEW_H
+#define EIGEN_SPARSE_TRIANGULARVIEW_H
+
+namespace Eigen {
+
+/** \ingroup SparseCore_Module
+  *
+  * \brief Base class for a triangular part in a \b sparse matrix
+  *
+  * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be instantiated.
+  * It extends class TriangularView with additional methods which are available for sparse expressions only.
+  *
+  * \sa class TriangularView, SparseMatrixBase::triangularView()
+  */
+template<typename MatrixType, unsigned int Mode> class TriangularViewImpl<MatrixType,Mode,Sparse>
+  : public SparseMatrixBase<TriangularView<MatrixType,Mode> >
+{
+    enum { SkipFirst = ((Mode&Lower) && !(MatrixType::Flags&RowMajorBit))
+                    || ((Mode&Upper) &&  (MatrixType::Flags&RowMajorBit)),
+           SkipLast = !SkipFirst,
+           SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
+           HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
+    };
+    
+    typedef TriangularView<MatrixType,Mode> TriangularViewType;
+    
+  protected:
+    // dummy solve function to make TriangularView happy.
+    void solve() const;
+
+    typedef SparseMatrixBase<TriangularViewType> Base;
+  public:
+    
+    EIGEN_SPARSE_PUBLIC_INTERFACE(TriangularViewType)
+    
+    typedef typename MatrixType::Nested MatrixTypeNested;
+    typedef typename internal::remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
+    typedef typename internal::remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
+
+    template<typename RhsType, typename DstType>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE void _solve_impl(const RhsType &rhs, DstType &dst) const {
+      if(!(internal::is_same<RhsType,DstType>::value && internal::extract_data(dst) == internal::extract_data(rhs)))
+        dst = rhs;
+      this->solveInPlace(dst);
+    }
+
+    /** Applies the inverse of \c *this to the dense vector or matrix \a other, "in-place" */
+    template<typename OtherDerived> void solveInPlace(MatrixBase<OtherDerived>& other) const;
+
+    /** Applies the inverse of \c *this to the sparse vector or matrix \a other, "in-place" */
+    template<typename OtherDerived> void solveInPlace(SparseMatrixBase<OtherDerived>& other) const;
+  
+};
+
+namespace internal {
+
+template<typename ArgType, unsigned int Mode>
+struct unary_evaluator<TriangularView<ArgType,Mode>, IteratorBased>
+ : evaluator_base<TriangularView<ArgType,Mode> >
+{
+  typedef TriangularView<ArgType,Mode> XprType;
+  
+protected:
+  
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::StorageIndex StorageIndex;
+  typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  
+  enum { SkipFirst = ((Mode&Lower) && !(ArgType::Flags&RowMajorBit))
+                    || ((Mode&Upper) &&  (ArgType::Flags&RowMajorBit)),
+         SkipLast = !SkipFirst,
+         SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
+         HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
+  };
+  
+public:
+  
+  enum {
+    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+    Flags = XprType::Flags
+  };
+    
+  explicit unary_evaluator(const XprType &xpr) : m_argImpl(xpr.nestedExpression()), m_arg(xpr.nestedExpression()) {}
+  
+  inline Index nonZerosEstimate() const {
+    return m_argImpl.nonZerosEstimate();
+  }
+  
+  class InnerIterator : public EvalIterator
+  {
+      typedef EvalIterator Base;
+    public:
+
+      EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& xprEval, Index outer)
+        : Base(xprEval.m_argImpl,outer), m_returnOne(false), m_containsDiag(Base::outer()<xprEval.m_arg.innerSize())
+      {
+        if(SkipFirst)
+        {
+          while((*this) && ((HasUnitDiag||SkipDiag)  ? this->index()<=outer : this->index()<outer))
+            Base::operator++();
+          if(HasUnitDiag)
+            m_returnOne = m_containsDiag;
+        }
+        else if(HasUnitDiag && ((!Base::operator bool()) || Base::index()>=Base::outer()))
+        {
+          if((!SkipFirst) && Base::operator bool())
+            Base::operator++();
+          m_returnOne = m_containsDiag;
+        }
+      }
+
+      EIGEN_STRONG_INLINE InnerIterator& operator++()
+      {
+        if(HasUnitDiag && m_returnOne)
+          m_returnOne = false;
+        else
+        {
+          Base::operator++();
+          if(HasUnitDiag && (!SkipFirst) && ((!Base::operator bool()) || Base::index()>=Base::outer()))
+          {
+            if((!SkipFirst) && Base::operator bool())
+              Base::operator++();
+            m_returnOne = m_containsDiag;
+          }
+        }
+        return *this;
+      }
+      
+      EIGEN_STRONG_INLINE operator bool() const
+      {
+        if(HasUnitDiag && m_returnOne)
+          return true;
+        if(SkipFirst) return  Base::operator bool();
+        else
+        {
+          if (SkipDiag) return (Base::operator bool() && this->index() < this->outer());
+          else return (Base::operator bool() && this->index() <= this->outer());
+        }
+      }
+
+//       inline Index row() const { return (ArgType::Flags&RowMajorBit ? Base::outer() : this->index()); }
+//       inline Index col() const { return (ArgType::Flags&RowMajorBit ? this->index() : Base::outer()); }
+      inline StorageIndex index() const
+      {
+        if(HasUnitDiag && m_returnOne)  return internal::convert_index<StorageIndex>(Base::outer());
+        else                            return Base::index();
+      }
+      inline Scalar value() const
+      {
+        if(HasUnitDiag && m_returnOne)  return Scalar(1);
+        else                            return Base::value();
+      }
+
+    protected:
+      bool m_returnOne;
+      bool m_containsDiag;
+    private:
+      Scalar& valueRef();
+  };
+  
+protected:
+  evaluator<ArgType> m_argImpl;
+  const ArgType& m_arg;
+};
+
+} // end namespace internal
+
+template<typename Derived>
+template<int Mode>
+inline const TriangularView<const Derived, Mode>
+SparseMatrixBase<Derived>::triangularView() const
+{
+  return TriangularView<const Derived, Mode>(derived());
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSE_TRIANGULARVIEW_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseUtil.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseUtil.h
new file mode 100644
index 00000000..ceb93688
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseUtil.h
@@ -0,0 +1,186 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEUTIL_H
+#define EIGEN_SPARSEUTIL_H
+
+namespace Eigen { 
+
+#ifdef NDEBUG
+#define EIGEN_DBG_SPARSE(X)
+#else
+#define EIGEN_DBG_SPARSE(X) X
+#endif
+
+#define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, Op) \
+template<typename OtherDerived> \
+EIGEN_STRONG_INLINE Derived& operator Op(const Eigen::SparseMatrixBase<OtherDerived>& other) \
+{ \
+  return Base::operator Op(other.derived()); \
+} \
+EIGEN_STRONG_INLINE Derived& operator Op(const Derived& other) \
+{ \
+  return Base::operator Op(other); \
+}
+
+#define EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, Op) \
+template<typename Other> \
+EIGEN_STRONG_INLINE Derived& operator Op(const Other& scalar) \
+{ \
+  return Base::operator Op(scalar); \
+}
+
+#define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATORS(Derived) \
+EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, =)
+
+
+#define EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) \
+  EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)
+
+  
+const int CoherentAccessPattern     = 0x1;
+const int InnerRandomAccessPattern  = 0x2 | CoherentAccessPattern;
+const int OuterRandomAccessPattern  = 0x4 | CoherentAccessPattern;
+const int RandomAccessPattern       = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern;
+
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class SparseMatrix;
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class DynamicSparseMatrix;
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class SparseVector;
+template<typename _Scalar, int _Flags = 0, typename _StorageIndex = int>  class MappedSparseMatrix;
+
+template<typename MatrixType, unsigned int UpLo>  class SparseSelfAdjointView;
+template<typename Lhs, typename Rhs>              class SparseDiagonalProduct;
+template<typename MatrixType> class SparseView;
+
+template<typename Lhs, typename Rhs>        class SparseSparseProduct;
+template<typename Lhs, typename Rhs>        class SparseTimeDenseProduct;
+template<typename Lhs, typename Rhs>        class DenseTimeSparseProduct;
+template<typename Lhs, typename Rhs, bool Transpose> class SparseDenseOuterProduct;
+
+template<typename Lhs, typename Rhs> struct SparseSparseProductReturnType;
+template<typename Lhs, typename Rhs,
+         int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct DenseSparseProductReturnType;
+         
+template<typename Lhs, typename Rhs,
+         int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct SparseDenseProductReturnType;
+template<typename MatrixType,int UpLo> class SparseSymmetricPermutationProduct;
+
+namespace internal {
+
+template<typename T,int Rows,int Cols,int Flags> struct sparse_eval;
+
+template<typename T> struct eval<T,Sparse>
+  : sparse_eval<T, traits<T>::RowsAtCompileTime,traits<T>::ColsAtCompileTime,traits<T>::Flags>
+{};
+
+template<typename T,int Cols,int Flags> struct sparse_eval<T,1,Cols,Flags> {
+    typedef typename traits<T>::Scalar _Scalar;
+    typedef typename traits<T>::StorageIndex _StorageIndex;
+  public:
+    typedef SparseVector<_Scalar, RowMajor, _StorageIndex> type;
+};
+
+template<typename T,int Rows,int Flags> struct sparse_eval<T,Rows,1,Flags> {
+    typedef typename traits<T>::Scalar _Scalar;
+    typedef typename traits<T>::StorageIndex _StorageIndex;
+  public:
+    typedef SparseVector<_Scalar, ColMajor, _StorageIndex> type;
+};
+
+// TODO this seems almost identical to plain_matrix_type<T, Sparse>
+template<typename T,int Rows,int Cols,int Flags> struct sparse_eval {
+    typedef typename traits<T>::Scalar _Scalar;
+    typedef typename traits<T>::StorageIndex _StorageIndex;
+    enum { _Options = ((Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor };
+  public:
+    typedef SparseMatrix<_Scalar, _Options, _StorageIndex> type;
+};
+
+template<typename T,int Flags> struct sparse_eval<T,1,1,Flags> {
+    typedef typename traits<T>::Scalar _Scalar;
+  public:
+    typedef Matrix<_Scalar, 1, 1> type;
+};
+
+template<typename T> struct plain_matrix_type<T,Sparse>
+{
+  typedef typename traits<T>::Scalar _Scalar;
+  typedef typename traits<T>::StorageIndex _StorageIndex;
+  enum { _Options = ((evaluator<T>::Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor };
+  public:
+    typedef SparseMatrix<_Scalar, _Options, _StorageIndex> type;
+};
+
+template<typename T>
+struct plain_object_eval<T,Sparse>
+  : sparse_eval<T, traits<T>::RowsAtCompileTime,traits<T>::ColsAtCompileTime, evaluator<T>::Flags>
+{};
+
+template<typename Decomposition, typename RhsType>
+struct solve_traits<Decomposition,RhsType,Sparse>
+{
+  typedef typename sparse_eval<RhsType, RhsType::RowsAtCompileTime, RhsType::ColsAtCompileTime,traits<RhsType>::Flags>::type PlainObject;
+};
+
+template<typename Derived>
+struct generic_xpr_base<Derived, MatrixXpr, Sparse>
+{
+  typedef SparseMatrixBase<Derived> type;
+};
+
+struct SparseTriangularShape  { static std::string debugName() { return "SparseTriangularShape"; } };
+struct SparseSelfAdjointShape { static std::string debugName() { return "SparseSelfAdjointShape"; } };
+
+template<> struct glue_shapes<SparseShape,SelfAdjointShape> { typedef SparseSelfAdjointShape type;  };
+template<> struct glue_shapes<SparseShape,TriangularShape > { typedef SparseTriangularShape  type;  };
+
+// return type of SparseCompressedBase::lower_bound;
+struct LowerBoundIndex {
+  LowerBoundIndex() : value(-1), found(false) {}
+  LowerBoundIndex(Index val, bool ok) : value(val), found(ok) {}
+  Index value;
+  bool found;
+};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  *
+  * \class Triplet
+  *
+  * \brief A small structure to hold a non zero as a triplet (i,j,value).
+  *
+  * \sa SparseMatrix::setFromTriplets()
+  */
+template<typename Scalar, typename StorageIndex=typename SparseMatrix<Scalar>::StorageIndex >
+class Triplet
+{
+public:
+  Triplet() : m_row(0), m_col(0), m_value(0) {}
+
+  Triplet(const StorageIndex& i, const StorageIndex& j, const Scalar& v = Scalar(0))
+    : m_row(i), m_col(j), m_value(v)
+  {}
+
+  /** \returns the row index of the element */
+  const StorageIndex& row() const { return m_row; }
+
+  /** \returns the column index of the element */
+  const StorageIndex& col() const { return m_col; }
+
+  /** \returns the value of the element */
+  const Scalar& value() const { return m_value; }
+protected:
+  StorageIndex m_row, m_col;
+  Scalar m_value;
+};
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEUTIL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseVector.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseVector.h
new file mode 100644
index 00000000..05779be6
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseVector.h
@@ -0,0 +1,478 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEVECTOR_H
+#define EIGEN_SPARSEVECTOR_H
+
+namespace Eigen { 
+
+/** \ingroup SparseCore_Module
+  * \class SparseVector
+  *
+  * \brief a sparse vector class
+  *
+  * \tparam _Scalar the scalar type, i.e. the type of the coefficients
+  *
+  * See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme.
+  *
+  * This class can be extended with the help of the plugin mechanism described on the page
+  * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_SPARSEVECTOR_PLUGIN.
+  */
+
+namespace internal {
+template<typename _Scalar, int _Options, typename _StorageIndex>
+struct traits<SparseVector<_Scalar, _Options, _StorageIndex> >
+{
+  typedef _Scalar Scalar;
+  typedef _StorageIndex StorageIndex;
+  typedef Sparse StorageKind;
+  typedef MatrixXpr XprKind;
+  enum {
+    IsColVector = (_Options & RowMajorBit) ? 0 : 1,
+
+    RowsAtCompileTime = IsColVector ? Dynamic : 1,
+    ColsAtCompileTime = IsColVector ? 1 : Dynamic,
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    Flags = _Options | NestByRefBit | LvalueBit | (IsColVector ? 0 : RowMajorBit) | CompressedAccessBit,
+    SupportedAccessPatterns = InnerRandomAccessPattern
+  };
+};
+
+// Sparse-Vector-Assignment kinds:
+enum {
+  SVA_RuntimeSwitch,
+  SVA_Inner,
+  SVA_Outer
+};
+
+template< typename Dest, typename Src,
+          int AssignmentKind = !bool(Src::IsVectorAtCompileTime) ? SVA_RuntimeSwitch
+                             : Src::InnerSizeAtCompileTime==1 ? SVA_Outer
+                             : SVA_Inner>
+struct sparse_vector_assign_selector;
+
+}
+
+template<typename _Scalar, int _Options, typename _StorageIndex>
+class SparseVector
+  : public SparseCompressedBase<SparseVector<_Scalar, _Options, _StorageIndex> >
+{
+    typedef SparseCompressedBase<SparseVector> Base;
+    using Base::convert_index;
+  public:
+    EIGEN_SPARSE_PUBLIC_INTERFACE(SparseVector)
+    EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(SparseVector, +=)
+    EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(SparseVector, -=)
+    
+    typedef internal::CompressedStorage<Scalar,StorageIndex> Storage;
+    enum { IsColVector = internal::traits<SparseVector>::IsColVector };
+    
+    enum {
+      Options = _Options
+    };
+    
+    EIGEN_STRONG_INLINE Index rows() const { return IsColVector ? m_size : 1; }
+    EIGEN_STRONG_INLINE Index cols() const { return IsColVector ? 1 : m_size; }
+    EIGEN_STRONG_INLINE Index innerSize() const { return m_size; }
+    EIGEN_STRONG_INLINE Index outerSize() const { return 1; }
+
+    EIGEN_STRONG_INLINE const Scalar* valuePtr() const { return m_data.valuePtr(); }
+    EIGEN_STRONG_INLINE Scalar* valuePtr() { return m_data.valuePtr(); }
+
+    EIGEN_STRONG_INLINE const StorageIndex* innerIndexPtr() const { return m_data.indexPtr(); }
+    EIGEN_STRONG_INLINE StorageIndex* innerIndexPtr() { return m_data.indexPtr(); }
+
+    inline const StorageIndex* outerIndexPtr() const { return 0; }
+    inline StorageIndex* outerIndexPtr() { return 0; }
+    inline const StorageIndex* innerNonZeroPtr() const { return 0; }
+    inline StorageIndex* innerNonZeroPtr() { return 0; }
+    
+    /** \internal */
+    inline Storage& data() { return m_data; }
+    /** \internal */
+    inline const Storage& data() const { return m_data; }
+
+    inline Scalar coeff(Index row, Index col) const
+    {
+      eigen_assert(IsColVector ? (col==0 && row>=0 && row<m_size) : (row==0 && col>=0 && col<m_size));
+      return coeff(IsColVector ? row : col);
+    }
+    inline Scalar coeff(Index i) const
+    {
+      eigen_assert(i>=0 && i<m_size);
+      return m_data.at(StorageIndex(i));
+    }
+
+    inline Scalar& coeffRef(Index row, Index col)
+    {
+      eigen_assert(IsColVector ? (col==0 && row>=0 && row<m_size) : (row==0 && col>=0 && col<m_size));
+      return coeffRef(IsColVector ? row : col);
+    }
+
+    /** \returns a reference to the coefficient value at given index \a i
+      * This operation involes a log(rho*size) binary search. If the coefficient does not
+      * exist yet, then a sorted insertion into a sequential buffer is performed.
+      *
+      * This insertion might be very costly if the number of nonzeros above \a i is large.
+      */
+    inline Scalar& coeffRef(Index i)
+    {
+      eigen_assert(i>=0 && i<m_size);
+
+      return m_data.atWithInsertion(StorageIndex(i));
+    }
+
+  public:
+
+    typedef typename Base::InnerIterator InnerIterator;
+    typedef typename Base::ReverseInnerIterator ReverseInnerIterator;
+
+    inline void setZero() { m_data.clear(); }
+
+    /** \returns the number of non zero coefficients */
+    inline Index nonZeros() const  { return m_data.size(); }
+
+    inline void startVec(Index outer)
+    {
+      EIGEN_UNUSED_VARIABLE(outer);
+      eigen_assert(outer==0);
+    }
+
+    inline Scalar& insertBackByOuterInner(Index outer, Index inner)
+    {
+      EIGEN_UNUSED_VARIABLE(outer);
+      eigen_assert(outer==0);
+      return insertBack(inner);
+    }
+    inline Scalar& insertBack(Index i)
+    {
+      m_data.append(0, i);
+      return m_data.value(m_data.size()-1);
+    }
+    
+    Scalar& insertBackByOuterInnerUnordered(Index outer, Index inner)
+    {
+      EIGEN_UNUSED_VARIABLE(outer);
+      eigen_assert(outer==0);
+      return insertBackUnordered(inner);
+    }
+    inline Scalar& insertBackUnordered(Index i)
+    {
+      m_data.append(0, i);
+      return m_data.value(m_data.size()-1);
+    }
+
+    inline Scalar& insert(Index row, Index col)
+    {
+      eigen_assert(IsColVector ? (col==0 && row>=0 && row<m_size) : (row==0 && col>=0 && col<m_size));
+      
+      Index inner = IsColVector ? row : col;
+      Index outer = IsColVector ? col : row;
+      EIGEN_ONLY_USED_FOR_DEBUG(outer);
+      eigen_assert(outer==0);
+      return insert(inner);
+    }
+    Scalar& insert(Index i)
+    {
+      eigen_assert(i>=0 && i<m_size);
+      
+      Index startId = 0;
+      Index p = Index(m_data.size()) - 1;
+      // TODO smart realloc
+      m_data.resize(p+2,1);
+
+      while ( (p >= startId) && (m_data.index(p) > i) )
+      {
+        m_data.index(p+1) = m_data.index(p);
+        m_data.value(p+1) = m_data.value(p);
+        --p;
+      }
+      m_data.index(p+1) = convert_index(i);
+      m_data.value(p+1) = 0;
+      return m_data.value(p+1);
+    }
+
+    /**
+      */
+    inline void reserve(Index reserveSize) { m_data.reserve(reserveSize); }
+
+
+    inline void finalize() {}
+
+    /** \copydoc SparseMatrix::prune(const Scalar&,const RealScalar&) */
+    void prune(const Scalar& reference, const RealScalar& epsilon = NumTraits<RealScalar>::dummy_precision())
+    {
+      m_data.prune(reference,epsilon);
+    }
+
+    /** Resizes the sparse vector to \a rows x \a cols
+      *
+      * This method is provided for compatibility with matrices.
+      * For a column vector, \a cols must be equal to 1.
+      * For a row vector, \a rows must be equal to 1.
+      *
+      * \sa resize(Index)
+      */
+    void resize(Index rows, Index cols)
+    {
+      eigen_assert((IsColVector ? cols : rows)==1 && "Outer dimension must equal 1");
+      resize(IsColVector ? rows : cols);
+    }
+
+    /** Resizes the sparse vector to \a newSize
+      * This method deletes all entries, thus leaving an empty sparse vector
+      *
+      * \sa  conservativeResize(), setZero() */
+    void resize(Index newSize)
+    {
+      m_size = newSize;
+      m_data.clear();
+    }
+
+    /** Resizes the sparse vector to \a newSize, while leaving old values untouched.
+      *
+      * If the size of the vector is decreased, then the storage of the out-of bounds coefficients is kept and reserved.
+      * Call .data().squeeze() to free extra memory.
+      *
+      * \sa reserve(), setZero()
+      */
+    void conservativeResize(Index newSize)
+    {
+      if (newSize < m_size)
+      {
+        Index i = 0;
+        while (i<m_data.size() && m_data.index(i)<newSize) ++i;
+        m_data.resize(i);
+      }
+      m_size = newSize;
+    }
+
+    void resizeNonZeros(Index size) { m_data.resize(size); }
+
+    inline SparseVector() : m_size(0) { check_template_parameters(); resize(0); }
+
+    explicit inline SparseVector(Index size) : m_size(0) { check_template_parameters(); resize(size); }
+
+    inline SparseVector(Index rows, Index cols) : m_size(0) { check_template_parameters(); resize(rows,cols); }
+
+    template<typename OtherDerived>
+    inline SparseVector(const SparseMatrixBase<OtherDerived>& other)
+      : m_size(0)
+    {
+      #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+        EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
+      #endif
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    inline SparseVector(const SparseVector& other)
+      : Base(other), m_size(0)
+    {
+      check_template_parameters();
+      *this = other.derived();
+    }
+
+    /** Swaps the values of \c *this and \a other.
+      * Overloaded for performance: this version performs a \em shallow swap by swapping pointers and attributes only.
+      * \sa SparseMatrixBase::swap()
+      */
+    inline void swap(SparseVector& other)
+    {
+      std::swap(m_size, other.m_size);
+      m_data.swap(other.m_data);
+    }
+
+    template<int OtherOptions>
+    inline void swap(SparseMatrix<Scalar,OtherOptions,StorageIndex>& other)
+    {
+      eigen_assert(other.outerSize()==1);
+      std::swap(m_size, other.m_innerSize);
+      m_data.swap(other.m_data);
+    }
+
+    inline SparseVector& operator=(const SparseVector& other)
+    {
+      if (other.isRValue())
+      {
+        swap(other.const_cast_derived());
+      }
+      else
+      {
+        resize(other.size());
+        m_data = other.m_data;
+      }
+      return *this;
+    }
+
+    template<typename OtherDerived>
+    inline SparseVector& operator=(const SparseMatrixBase<OtherDerived>& other)
+    {
+      SparseVector tmp(other.size());
+      internal::sparse_vector_assign_selector<SparseVector,OtherDerived>::run(tmp,other.derived());
+      this->swap(tmp);
+      return *this;
+    }
+
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    template<typename Lhs, typename Rhs>
+    inline SparseVector& operator=(const SparseSparseProduct<Lhs,Rhs>& product)
+    {
+      return Base::operator=(product);
+    }
+    #endif
+
+    friend std::ostream & operator << (std::ostream & s, const SparseVector& m)
+    {
+      for (Index i=0; i<m.nonZeros(); ++i)
+        s << "(" << m.m_data.value(i) << "," << m.m_data.index(i) << ") ";
+      s << std::endl;
+      return s;
+    }
+
+    /** Destructor */
+    inline ~SparseVector() {}
+
+    /** Overloaded for performance */
+    Scalar sum() const;
+
+  public:
+
+    /** \internal \deprecated use setZero() and reserve() */
+    EIGEN_DEPRECATED void startFill(Index reserve)
+    {
+      setZero();
+      m_data.reserve(reserve);
+    }
+
+    /** \internal \deprecated use insertBack(Index,Index) */
+    EIGEN_DEPRECATED Scalar& fill(Index r, Index c)
+    {
+      eigen_assert(r==0 || c==0);
+      return fill(IsColVector ? r : c);
+    }
+
+    /** \internal \deprecated use insertBack(Index) */
+    EIGEN_DEPRECATED Scalar& fill(Index i)
+    {
+      m_data.append(0, i);
+      return m_data.value(m_data.size()-1);
+    }
+
+    /** \internal \deprecated use insert(Index,Index) */
+    EIGEN_DEPRECATED Scalar& fillrand(Index r, Index c)
+    {
+      eigen_assert(r==0 || c==0);
+      return fillrand(IsColVector ? r : c);
+    }
+
+    /** \internal \deprecated use insert(Index) */
+    EIGEN_DEPRECATED Scalar& fillrand(Index i)
+    {
+      return insert(i);
+    }
+
+    /** \internal \deprecated use finalize() */
+    EIGEN_DEPRECATED void endFill() {}
+    
+    // These two functions were here in the 3.1 release, so let's keep them in case some code rely on them.
+    /** \internal \deprecated use data() */
+    EIGEN_DEPRECATED Storage& _data() { return m_data; }
+    /** \internal \deprecated use data() */
+    EIGEN_DEPRECATED const Storage& _data() const { return m_data; }
+    
+#   ifdef EIGEN_SPARSEVECTOR_PLUGIN
+#     include EIGEN_SPARSEVECTOR_PLUGIN
+#   endif
+
+protected:
+  
+    static void check_template_parameters()
+    {
+      EIGEN_STATIC_ASSERT(NumTraits<StorageIndex>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE);
+      EIGEN_STATIC_ASSERT((_Options&(ColMajor|RowMajor))==Options,INVALID_MATRIX_TEMPLATE_PARAMETERS);
+    }
+    
+    Storage m_data;
+    Index m_size;
+};
+
+namespace internal {
+
+template<typename _Scalar, int _Options, typename _Index>
+struct evaluator<SparseVector<_Scalar,_Options,_Index> >
+  : evaluator_base<SparseVector<_Scalar,_Options,_Index> >
+{
+  typedef SparseVector<_Scalar,_Options,_Index> SparseVectorType;
+  typedef evaluator_base<SparseVectorType> Base;
+  typedef typename SparseVectorType::InnerIterator InnerIterator;
+  typedef typename SparseVectorType::ReverseInnerIterator ReverseInnerIterator;
+  
+  enum {
+    CoeffReadCost = NumTraits<_Scalar>::ReadCost,
+    Flags = SparseVectorType::Flags
+  };
+
+  evaluator() : Base() {}
+  
+  explicit evaluator(const SparseVectorType &mat) : m_matrix(&mat)
+  {
+    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+  }
+  
+  inline Index nonZerosEstimate() const {
+    return m_matrix->nonZeros();
+  }
+  
+  operator SparseVectorType&() { return m_matrix->const_cast_derived(); }
+  operator const SparseVectorType&() const { return *m_matrix; }
+  
+  const SparseVectorType *m_matrix;
+};
+
+template< typename Dest, typename Src>
+struct sparse_vector_assign_selector<Dest,Src,SVA_Inner> {
+  static void run(Dest& dst, const Src& src) {
+    eigen_internal_assert(src.innerSize()==src.size());
+    typedef internal::evaluator<Src> SrcEvaluatorType;
+    SrcEvaluatorType srcEval(src);
+    for(typename SrcEvaluatorType::InnerIterator it(srcEval, 0); it; ++it)
+      dst.insert(it.index()) = it.value();
+  }
+};
+
+template< typename Dest, typename Src>
+struct sparse_vector_assign_selector<Dest,Src,SVA_Outer> {
+  static void run(Dest& dst, const Src& src) {
+    eigen_internal_assert(src.outerSize()==src.size());
+    typedef internal::evaluator<Src> SrcEvaluatorType;
+    SrcEvaluatorType srcEval(src);
+    for(Index i=0; i<src.size(); ++i)
+    {
+      typename SrcEvaluatorType::InnerIterator it(srcEval, i);
+      if(it)
+        dst.insert(i) = it.value();
+    }
+  }
+};
+
+template< typename Dest, typename Src>
+struct sparse_vector_assign_selector<Dest,Src,SVA_RuntimeSwitch> {
+  static void run(Dest& dst, const Src& src) {
+    if(src.outerSize()==1)  sparse_vector_assign_selector<Dest,Src,SVA_Inner>::run(dst, src);
+    else                    sparse_vector_assign_selector<Dest,Src,SVA_Outer>::run(dst, src);
+  }
+};
+
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEVECTOR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseView.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseView.h
new file mode 100644
index 00000000..92b3d1f7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/SparseView.h
@@ -0,0 +1,254 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2010 Daniel Lowengrub <lowdanie@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEVIEW_H
+#define EIGEN_SPARSEVIEW_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename MatrixType>
+struct traits<SparseView<MatrixType> > : traits<MatrixType>
+{
+  typedef typename MatrixType::StorageIndex StorageIndex;
+  typedef Sparse StorageKind;
+  enum {
+    Flags = int(traits<MatrixType>::Flags) & (RowMajorBit)
+  };
+};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  * \class SparseView
+  *
+  * \brief Expression of a dense or sparse matrix with zero or too small values removed
+  *
+  * \tparam MatrixType the type of the object of which we are removing the small entries
+  *
+  * This class represents an expression of a given dense or sparse matrix with
+  * entries smaller than \c reference * \c epsilon are removed.
+  * It is the return type of MatrixBase::sparseView() and SparseMatrixBase::pruned()
+  * and most of the time this is the only way it is used.
+  *
+  * \sa MatrixBase::sparseView(), SparseMatrixBase::pruned()
+  */
+template<typename MatrixType>
+class SparseView : public SparseMatrixBase<SparseView<MatrixType> >
+{
+  typedef typename MatrixType::Nested MatrixTypeNested;
+  typedef typename internal::remove_all<MatrixTypeNested>::type _MatrixTypeNested;
+  typedef SparseMatrixBase<SparseView > Base;
+public:
+  EIGEN_SPARSE_PUBLIC_INTERFACE(SparseView)
+  typedef typename internal::remove_all<MatrixType>::type NestedExpression;
+
+  explicit SparseView(const MatrixType& mat, const Scalar& reference = Scalar(0),
+                      const RealScalar &epsilon = NumTraits<Scalar>::dummy_precision())
+    : m_matrix(mat), m_reference(reference), m_epsilon(epsilon) {}
+
+  inline Index rows() const { return m_matrix.rows(); }
+  inline Index cols() const { return m_matrix.cols(); }
+
+  inline Index innerSize() const { return m_matrix.innerSize(); }
+  inline Index outerSize() const { return m_matrix.outerSize(); }
+  
+  /** \returns the nested expression */
+  const typename internal::remove_all<MatrixTypeNested>::type&
+  nestedExpression() const { return m_matrix; }
+  
+  Scalar reference() const { return m_reference; }
+  RealScalar epsilon() const { return m_epsilon; }
+  
+protected:
+  MatrixTypeNested m_matrix;
+  Scalar m_reference;
+  RealScalar m_epsilon;
+};
+
+namespace internal {
+
+// TODO find a way to unify the two following variants
+// This is tricky because implementing an inner iterator on top of an IndexBased evaluator is
+// not easy because the evaluators do not expose the sizes of the underlying expression.
+  
+template<typename ArgType>
+struct unary_evaluator<SparseView<ArgType>, IteratorBased>
+  : public evaluator_base<SparseView<ArgType> >
+{
+    typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  public:
+    typedef SparseView<ArgType> XprType;
+    
+    class InnerIterator : public EvalIterator
+    {
+      protected:
+        typedef typename XprType::Scalar Scalar;
+      public:
+
+        EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& sve, Index outer)
+          : EvalIterator(sve.m_argImpl,outer), m_view(sve.m_view)
+        {
+          incrementToNonZero();
+        }
+
+        EIGEN_STRONG_INLINE InnerIterator& operator++()
+        {
+          EvalIterator::operator++();
+          incrementToNonZero();
+          return *this;
+        }
+
+        using EvalIterator::value;
+
+      protected:
+        const XprType &m_view;
+
+      private:
+        void incrementToNonZero()
+        {
+          while((bool(*this)) && internal::isMuchSmallerThan(value(), m_view.reference(), m_view.epsilon()))
+          {
+            EvalIterator::operator++();
+          }
+        }
+    };
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_view(xpr) {}
+
+  protected:
+    evaluator<ArgType> m_argImpl;
+    const XprType &m_view;
+};
+
+template<typename ArgType>
+struct unary_evaluator<SparseView<ArgType>, IndexBased>
+  : public evaluator_base<SparseView<ArgType> >
+{
+  public:
+    typedef SparseView<ArgType> XprType;
+  protected:
+    enum { IsRowMajor = (XprType::Flags&RowMajorBit)==RowMajorBit };
+    typedef typename XprType::Scalar Scalar;
+    typedef typename XprType::StorageIndex StorageIndex;
+  public:
+    
+    class InnerIterator
+    {
+      public:
+
+        EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& sve, Index outer)
+          : m_sve(sve), m_inner(0), m_outer(outer), m_end(sve.m_view.innerSize())
+        {
+          incrementToNonZero();
+        }
+
+        EIGEN_STRONG_INLINE InnerIterator& operator++()
+        {
+          m_inner++;
+          incrementToNonZero();
+          return *this;
+        }
+
+        EIGEN_STRONG_INLINE Scalar value() const
+        {
+          return (IsRowMajor) ? m_sve.m_argImpl.coeff(m_outer, m_inner)
+                              : m_sve.m_argImpl.coeff(m_inner, m_outer);
+        }
+
+        EIGEN_STRONG_INLINE StorageIndex index() const { return m_inner; }
+        inline Index row() const { return IsRowMajor ? m_outer : index(); }
+        inline Index col() const { return IsRowMajor ? index() : m_outer; }
+
+        EIGEN_STRONG_INLINE operator bool() const { return m_inner < m_end && m_inner>=0; }
+
+      protected:
+        const unary_evaluator &m_sve;
+        Index m_inner;
+        const Index m_outer;
+        const Index m_end;
+
+      private:
+        void incrementToNonZero()
+        {
+          while((bool(*this)) && internal::isMuchSmallerThan(value(), m_sve.m_view.reference(), m_sve.m_view.epsilon()))
+          {
+            m_inner++;
+          }
+        }
+    };
+    
+    enum {
+      CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
+      Flags = XprType::Flags
+    };
+    
+    explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_view(xpr) {}
+
+  protected:
+    evaluator<ArgType> m_argImpl;
+    const XprType &m_view;
+};
+
+} // end namespace internal
+
+/** \ingroup SparseCore_Module
+  *
+  * \returns a sparse expression of the dense expression \c *this with values smaller than
+  * \a reference * \a epsilon removed.
+  *
+  * This method is typically used when prototyping to convert a quickly assembled dense Matrix \c D to a SparseMatrix \c S:
+  * \code
+  * MatrixXd D(n,m);
+  * SparseMatrix<double> S;
+  * S = D.sparseView();             // suppress numerical zeros (exact)
+  * S = D.sparseView(reference);
+  * S = D.sparseView(reference,epsilon);
+  * \endcode
+  * where \a reference is a meaningful non zero reference value,
+  * and \a epsilon is a tolerance factor defaulting to NumTraits<Scalar>::dummy_precision().
+  *
+  * \sa SparseMatrixBase::pruned(), class SparseView */
+template<typename Derived>
+const SparseView<Derived> MatrixBase<Derived>::sparseView(const Scalar& reference,
+                                                          const typename NumTraits<Scalar>::Real& epsilon) const
+{
+  return SparseView<Derived>(derived(), reference, epsilon);
+}
+
+/** \returns an expression of \c *this with values smaller than
+  * \a reference * \a epsilon removed.
+  *
+  * This method is typically used in conjunction with the product of two sparse matrices
+  * to automatically prune the smallest values as follows:
+  * \code
+  * C = (A*B).pruned();             // suppress numerical zeros (exact)
+  * C = (A*B).pruned(ref);
+  * C = (A*B).pruned(ref,epsilon);
+  * \endcode
+  * where \c ref is a meaningful non zero reference value.
+  * */
+template<typename Derived>
+const SparseView<Derived>
+SparseMatrixBase<Derived>::pruned(const Scalar& reference,
+                                  const RealScalar& epsilon) const
+{
+  return SparseView<Derived>(derived(), reference, epsilon);
+}
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/TriangularSolver.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/TriangularSolver.h
new file mode 100644
index 00000000..f9c56ba7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseCore/TriangularSolver.h
@@ -0,0 +1,315 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSETRIANGULARSOLVER_H
+#define EIGEN_SPARSETRIANGULARSOLVER_H
+
+namespace Eigen { 
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Mode,
+  int UpLo = (Mode & Lower)
+           ? Lower
+           : (Mode & Upper)
+           ? Upper
+           : -1,
+  int StorageOrder = int(traits<Lhs>::Flags) & RowMajorBit>
+struct sparse_solve_triangular_selector;
+
+// forward substitution, row-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,RowMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=0; i<lhs.rows(); ++i)
+      {
+        Scalar tmp = other.coeff(i,col);
+        Scalar lastVal(0);
+        Index lastIndex = 0;
+        for(LhsIterator it(lhsEval, i); it; ++it)
+        {
+          lastVal = it.value();
+          lastIndex = it.index();
+          if(lastIndex==i)
+            break;
+          tmp -= lastVal * other.coeff(lastIndex,col);
+        }
+        if (Mode & UnitDiag)
+          other.coeffRef(i,col) = tmp;
+        else
+        {
+          eigen_assert(lastIndex==i);
+          other.coeffRef(i,col) = tmp/lastVal;
+        }
+      }
+    }
+  }
+};
+
+// backward substitution, row-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,RowMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=lhs.rows()-1 ; i>=0 ; --i)
+      {
+        Scalar tmp = other.coeff(i,col);
+        Scalar l_ii(0);
+        LhsIterator it(lhsEval, i);
+        while(it && it.index()<i)
+          ++it;
+        if(!(Mode & UnitDiag))
+        {
+          eigen_assert(it && it.index()==i);
+          l_ii = it.value();
+          ++it;
+        }
+        else if (it && it.index() == i)
+          ++it;
+        for(; it; ++it)
+        {
+          tmp -= it.value() * other.coeff(it.index(),col);
+        }
+
+        if (Mode & UnitDiag)  other.coeffRef(i,col) = tmp;
+        else                  other.coeffRef(i,col) = tmp/l_ii;
+      }
+    }
+  }
+};
+
+// forward substitution, col-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,ColMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=0; i<lhs.cols(); ++i)
+      {
+        Scalar& tmp = other.coeffRef(i,col);
+        if (tmp!=Scalar(0)) // optimization when other is actually sparse
+        {
+          LhsIterator it(lhsEval, i);
+          while(it && it.index()<i)
+            ++it;
+          if(!(Mode & UnitDiag))
+          {
+            eigen_assert(it && it.index()==i);
+            tmp /= it.value();
+          }
+          if (it && it.index()==i)
+            ++it;
+          for(; it; ++it)
+            other.coeffRef(it.index(), col) -= tmp * it.value();
+        }
+      }
+    }
+  }
+};
+
+// backward substitution, col-major
+template<typename Lhs, typename Rhs, int Mode>
+struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,ColMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef evaluator<Lhs> LhsEval;
+  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    LhsEval lhsEval(lhs);
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      for(Index i=lhs.cols()-1; i>=0; --i)
+      {
+        Scalar& tmp = other.coeffRef(i,col);
+        if (tmp!=Scalar(0)) // optimization when other is actually sparse
+        {
+          if(!(Mode & UnitDiag))
+          {
+            // TODO replace this by a binary search. make sure the binary search is safe for partially sorted elements
+            LhsIterator it(lhsEval, i);
+            while(it && it.index()!=i)
+              ++it;
+            eigen_assert(it && it.index()==i);
+            other.coeffRef(i,col) /= it.value();
+          }
+          LhsIterator it(lhsEval, i);
+          for(; it && it.index()<i; ++it)
+            other.coeffRef(it.index(), col) -= tmp * it.value();
+        }
+      }
+    }
+  }
+};
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+template<typename ExpressionType,unsigned int Mode>
+template<typename OtherDerived>
+void TriangularViewImpl<ExpressionType,Mode,Sparse>::solveInPlace(MatrixBase<OtherDerived>& other) const
+{
+  eigen_assert(derived().cols() == derived().rows() && derived().cols() == other.rows());
+  eigen_assert((!(Mode & ZeroDiag)) && bool(Mode & (Upper|Lower)));
+
+  enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit };
+
+  typedef typename internal::conditional<copy,
+    typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
+  OtherCopy otherCopy(other.derived());
+
+  internal::sparse_solve_triangular_selector<ExpressionType, typename internal::remove_reference<OtherCopy>::type, Mode>::run(derived().nestedExpression(), otherCopy);
+
+  if (copy)
+    other = otherCopy;
+}
+#endif
+
+// pure sparse path
+
+namespace internal {
+
+template<typename Lhs, typename Rhs, int Mode,
+  int UpLo = (Mode & Lower)
+           ? Lower
+           : (Mode & Upper)
+           ? Upper
+           : -1,
+  int StorageOrder = int(Lhs::Flags) & (RowMajorBit)>
+struct sparse_solve_triangular_sparse_selector;
+
+// forward substitution, col-major
+template<typename Lhs, typename Rhs, int Mode, int UpLo>
+struct sparse_solve_triangular_sparse_selector<Lhs,Rhs,Mode,UpLo,ColMajor>
+{
+  typedef typename Rhs::Scalar Scalar;
+  typedef typename promote_index_type<typename traits<Lhs>::StorageIndex,
+                                      typename traits<Rhs>::StorageIndex>::type StorageIndex;
+  static void run(const Lhs& lhs, Rhs& other)
+  {
+    const bool IsLower = (UpLo==Lower);
+    AmbiVector<Scalar,StorageIndex> tempVector(other.rows()*2);
+    tempVector.setBounds(0,other.rows());
+
+    Rhs res(other.rows(), other.cols());
+    res.reserve(other.nonZeros());
+
+    for(Index col=0 ; col<other.cols() ; ++col)
+    {
+      // FIXME estimate number of non zeros
+      tempVector.init(.99/*float(other.col(col).nonZeros())/float(other.rows())*/);
+      tempVector.setZero();
+      tempVector.restart();
+      for (typename Rhs::InnerIterator rhsIt(other, col); rhsIt; ++rhsIt)
+      {
+        tempVector.coeffRef(rhsIt.index()) = rhsIt.value();
+      }
+
+      for(Index i=IsLower?0:lhs.cols()-1;
+          IsLower?i<lhs.cols():i>=0;
+          i+=IsLower?1:-1)
+      {
+        tempVector.restart();
+        Scalar& ci = tempVector.coeffRef(i);
+        if (ci!=Scalar(0))
+        {
+          // find
+          typename Lhs::InnerIterator it(lhs, i);
+          if(!(Mode & UnitDiag))
+          {
+            if (IsLower)
+            {
+              eigen_assert(it.index()==i);
+              ci /= it.value();
+            }
+            else
+              ci /= lhs.coeff(i,i);
+          }
+          tempVector.restart();
+          if (IsLower)
+          {
+            if (it.index()==i)
+              ++it;
+            for(; it; ++it)
+              tempVector.coeffRef(it.index()) -= ci * it.value();
+          }
+          else
+          {
+            for(; it && it.index()<i; ++it)
+              tempVector.coeffRef(it.index()) -= ci * it.value();
+          }
+        }
+      }
+
+
+      Index count = 0;
+      // FIXME compute a reference value to filter zeros
+      for (typename AmbiVector<Scalar,StorageIndex>::Iterator it(tempVector/*,1e-12*/); it; ++it)
+      {
+        ++ count;
+//         std::cerr << "fill " << it.index() << ", " << col << "\n";
+//         std::cout << it.value() << "  ";
+        // FIXME use insertBack
+        res.insert(it.index(), col) = it.value();
+      }
+//       std::cout << "tempVector.nonZeros() == " << int(count) << " / " << (other.rows()) << "\n";
+    }
+    res.finalize();
+    other = res.markAsRValue();
+  }
+};
+
+} // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename ExpressionType,unsigned int Mode>
+template<typename OtherDerived>
+void TriangularViewImpl<ExpressionType,Mode,Sparse>::solveInPlace(SparseMatrixBase<OtherDerived>& other) const
+{
+  eigen_assert(derived().cols() == derived().rows() && derived().cols() == other.rows());
+  eigen_assert( (!(Mode & ZeroDiag)) && bool(Mode & (Upper|Lower)));
+
+//   enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit };
+
+//   typedef typename internal::conditional<copy,
+//     typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
+//   OtherCopy otherCopy(other.derived());
+
+  internal::sparse_solve_triangular_sparse_selector<ExpressionType, OtherDerived, Mode>::run(derived().nestedExpression(), other.derived());
+
+//   if (copy)
+//     other = otherCopy;
+}
+#endif
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSETRIANGULARSOLVER_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU.h
new file mode 100644
index 00000000..0c8d8939
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU.h
@@ -0,0 +1,923 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_SPARSE_LU_H
+#define EIGEN_SPARSE_LU_H
+
+namespace Eigen {
+
+template <typename _MatrixType, typename _OrderingType = COLAMDOrdering<typename _MatrixType::StorageIndex> > class SparseLU;
+template <typename MappedSparseMatrixType> struct SparseLUMatrixLReturnType;
+template <typename MatrixLType, typename MatrixUType> struct SparseLUMatrixUReturnType;
+
+template <bool Conjugate,class SparseLUType>
+class SparseLUTransposeView : public SparseSolverBase<SparseLUTransposeView<Conjugate,SparseLUType> >
+{
+protected:
+  typedef SparseSolverBase<SparseLUTransposeView<Conjugate,SparseLUType> > APIBase;
+  using APIBase::m_isInitialized;
+public:
+  typedef typename SparseLUType::Scalar Scalar;
+  typedef typename SparseLUType::StorageIndex StorageIndex;
+  typedef typename SparseLUType::MatrixType MatrixType;
+  typedef typename SparseLUType::OrderingType OrderingType;
+
+  enum {
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+  };
+
+  SparseLUTransposeView() : m_sparseLU(NULL) {}
+  SparseLUTransposeView(const SparseLUTransposeView& view) {
+    this->m_sparseLU = view.m_sparseLU;
+  }
+  void setIsInitialized(const bool isInitialized) {this->m_isInitialized = isInitialized;}
+  void setSparseLU(SparseLUType* sparseLU) {m_sparseLU = sparseLU;}
+  using APIBase::_solve_impl;
+  template<typename Rhs, typename Dest>
+  bool _solve_impl(const MatrixBase<Rhs> &B, MatrixBase<Dest> &X_base) const
+  {
+    Dest& X(X_base.derived());
+    eigen_assert(m_sparseLU->info() == Success && "The matrix should be factorized first");
+    EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
+                        THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+
+
+    // this ugly const_cast_derived() helps to detect aliasing when applying the permutations
+    for(Index j = 0; j < B.cols(); ++j){
+      X.col(j) = m_sparseLU->colsPermutation() * B.const_cast_derived().col(j);
+    }
+    //Forward substitution with transposed or adjoint of U
+    m_sparseLU->matrixU().template solveTransposedInPlace<Conjugate>(X);
+
+    //Backward substitution with transposed or adjoint of L
+    m_sparseLU->matrixL().template solveTransposedInPlace<Conjugate>(X);
+
+    // Permute back the solution
+    for (Index j = 0; j < B.cols(); ++j)
+      X.col(j) = m_sparseLU->rowsPermutation().transpose() * X.col(j);
+    return true;
+  }
+  inline Index rows() const { return m_sparseLU->rows(); }
+  inline Index cols() const { return m_sparseLU->cols(); }
+
+private:
+  SparseLUType *m_sparseLU;
+  SparseLUTransposeView& operator=(const SparseLUTransposeView&);
+};
+
+
+/** \ingroup SparseLU_Module
+  * \class SparseLU
+  * 
+  * \brief Sparse supernodal LU factorization for general matrices
+  * 
+  * This class implements the supernodal LU factorization for general matrices.
+  * It uses the main techniques from the sequential SuperLU package 
+  * (http://crd-legacy.lbl.gov/~xiaoye/SuperLU/). It handles transparently real 
+  * and complex arithmetic with single and double precision, depending on the 
+  * scalar type of your input matrix. 
+  * The code has been optimized to provide BLAS-3 operations during supernode-panel updates. 
+  * It benefits directly from the built-in high-performant Eigen BLAS routines. 
+  * Moreover, when the size of a supernode is very small, the BLAS calls are avoided to 
+  * enable a better optimization from the compiler. For best performance, 
+  * you should compile it with NDEBUG flag to avoid the numerous bounds checking on vectors. 
+  * 
+  * An important parameter of this class is the ordering method. It is used to reorder the columns 
+  * (and eventually the rows) of the matrix to reduce the number of new elements that are created during 
+  * numerical factorization. The cheapest method available is COLAMD. 
+  * See  \link OrderingMethods_Module the OrderingMethods module \endlink for the list of 
+  * built-in and external ordering methods. 
+  *
+  * Simple example with key steps 
+  * \code
+  * VectorXd x(n), b(n);
+  * SparseMatrix<double> A;
+  * SparseLU<SparseMatrix<double>, COLAMDOrdering<int> >   solver;
+  * // fill A and b;
+  * // Compute the ordering permutation vector from the structural pattern of A
+  * solver.analyzePattern(A); 
+  * // Compute the numerical factorization 
+  * solver.factorize(A); 
+  * //Use the factors to solve the linear system 
+  * x = solver.solve(b); 
+  * \endcode
+  * 
+  * \warning The input matrix A should be in a \b compressed and \b column-major form.
+  * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
+  * 
+  * \note Unlike the initial SuperLU implementation, there is no step to equilibrate the matrix. 
+  * For badly scaled matrices, this step can be useful to reduce the pivoting during factorization. 
+  * If this is the case for your matrices, you can try the basic scaling method at
+  *  "unsupported/Eigen/src/IterativeSolvers/Scaling.h"
+  * 
+  * \tparam _MatrixType The type of the sparse matrix. It must be a column-major SparseMatrix<>
+  * \tparam _OrderingType The ordering method to use, either AMD, COLAMD or METIS. Default is COLMAD
+  *
+  * \implsparsesolverconcept
+  * 
+  * \sa \ref TutorialSparseSolverConcept
+  * \sa \ref OrderingMethods_Module
+  */
+template <typename _MatrixType, typename _OrderingType>
+class SparseLU : public SparseSolverBase<SparseLU<_MatrixType,_OrderingType> >, public internal::SparseLUImpl<typename _MatrixType::Scalar, typename _MatrixType::StorageIndex>
+{
+  protected:
+    typedef SparseSolverBase<SparseLU<_MatrixType,_OrderingType> > APIBase;
+    using APIBase::m_isInitialized;
+  public:
+    using APIBase::_solve_impl;
+    
+    typedef _MatrixType MatrixType; 
+    typedef _OrderingType OrderingType;
+    typedef typename MatrixType::Scalar Scalar; 
+    typedef typename MatrixType::RealScalar RealScalar; 
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> NCMatrix;
+    typedef internal::MappedSuperNodalMatrix<Scalar, StorageIndex> SCMatrix;
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+    typedef internal::SparseLUImpl<Scalar, StorageIndex> Base;
+
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+  public:
+
+    SparseLU():m_lastError(""),m_Ustore(0,0,0,0,0,0),m_symmetricmode(false),m_diagpivotthresh(1.0),m_detPermR(1)
+    {
+      initperfvalues(); 
+    }
+    explicit SparseLU(const MatrixType& matrix)
+      : m_lastError(""),m_Ustore(0,0,0,0,0,0),m_symmetricmode(false),m_diagpivotthresh(1.0),m_detPermR(1)
+    {
+      initperfvalues(); 
+      compute(matrix);
+    }
+    
+    ~SparseLU()
+    {
+      // Free all explicit dynamic pointers 
+    }
+    
+    void analyzePattern (const MatrixType& matrix);
+    void factorize (const MatrixType& matrix);
+    void simplicialfactorize(const MatrixType& matrix);
+    
+    /**
+      * Compute the symbolic and numeric factorization of the input sparse matrix.
+      * The input matrix should be in column-major storage. 
+      */
+    void compute (const MatrixType& matrix)
+    {
+      // Analyze 
+      analyzePattern(matrix); 
+      //Factorize
+      factorize(matrix);
+    } 
+
+    /** \returns an expression of the transposed of the factored matrix.
+      *
+      * A typical usage is to solve for the transposed problem A^T x = b:
+      * \code
+      * solver.compute(A);
+      * x = solver.transpose().solve(b);
+      * \endcode
+      *
+      * \sa adjoint(), solve()
+      */
+    const SparseLUTransposeView<false,SparseLU<_MatrixType,_OrderingType> > transpose()
+    {
+      SparseLUTransposeView<false,  SparseLU<_MatrixType,_OrderingType> > transposeView;
+      transposeView.setSparseLU(this);
+      transposeView.setIsInitialized(this->m_isInitialized);
+      return transposeView;
+    }
+
+
+    /** \returns an expression of the adjoint of the factored matrix
+      *
+      * A typical usage is to solve for the adjoint problem A' x = b:
+      * \code
+      * solver.compute(A);
+      * x = solver.adjoint().solve(b);
+      * \endcode
+      *
+      * For real scalar types, this function is equivalent to transpose().
+      *
+      * \sa transpose(), solve()
+      */
+    const SparseLUTransposeView<true, SparseLU<_MatrixType,_OrderingType> > adjoint()
+    {
+      SparseLUTransposeView<true,  SparseLU<_MatrixType,_OrderingType> > adjointView;
+      adjointView.setSparseLU(this);
+      adjointView.setIsInitialized(this->m_isInitialized);
+      return adjointView;
+    }
+    
+    inline Index rows() const { return m_mat.rows(); }
+    inline Index cols() const { return m_mat.cols(); }
+    /** Indicate that the pattern of the input matrix is symmetric */
+    void isSymmetric(bool sym)
+    {
+      m_symmetricmode = sym;
+    }
+    
+    /** \returns an expression of the matrix L, internally stored as supernodes
+      * The only operation available with this expression is the triangular solve
+      * \code
+      * y = b; matrixL().solveInPlace(y);
+      * \endcode
+      */
+    SparseLUMatrixLReturnType<SCMatrix> matrixL() const
+    {
+      return SparseLUMatrixLReturnType<SCMatrix>(m_Lstore);
+    }
+    /** \returns an expression of the matrix U,
+      * The only operation available with this expression is the triangular solve
+      * \code
+      * y = b; matrixU().solveInPlace(y);
+      * \endcode
+      */
+    SparseLUMatrixUReturnType<SCMatrix,MappedSparseMatrix<Scalar,ColMajor,StorageIndex> > matrixU() const
+    {
+      return SparseLUMatrixUReturnType<SCMatrix, MappedSparseMatrix<Scalar,ColMajor,StorageIndex> >(m_Lstore, m_Ustore);
+    }
+
+    /**
+      * \returns a reference to the row matrix permutation \f$ P_r \f$ such that \f$P_r A P_c^T = L U\f$
+      * \sa colsPermutation()
+      */
+    inline const PermutationType& rowsPermutation() const
+    {
+      return m_perm_r;
+    }
+    /**
+      * \returns a reference to the column matrix permutation\f$ P_c^T \f$ such that \f$P_r A P_c^T = L U\f$
+      * \sa rowsPermutation()
+      */
+    inline const PermutationType& colsPermutation() const
+    {
+      return m_perm_c;
+    }
+    /** Set the threshold used for a diagonal entry to be an acceptable pivot. */
+    void setPivotThreshold(const RealScalar& thresh)
+    {
+      m_diagpivotthresh = thresh; 
+    }
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** \returns the solution X of \f$ A X = B \f$ using the current decomposition of A.
+      *
+      * \warning the destination matrix X in X = this->solve(B) must be colmun-major.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<SparseLU, Rhs> solve(const MatrixBase<Rhs>& B) const;
+#endif // EIGEN_PARSED_BY_DOXYGEN
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the LU factorization reports a problem, zero diagonal for instance
+      *          \c InvalidInput if the input matrix is invalid
+      *
+      * \sa iparm()          
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+    
+    /**
+      * \returns A string describing the type of error
+      */
+    std::string lastErrorMessage() const
+    {
+      return m_lastError; 
+    }
+
+    template<typename Rhs, typename Dest>
+    bool _solve_impl(const MatrixBase<Rhs> &B, MatrixBase<Dest> &X_base) const
+    {
+      Dest& X(X_base.derived());
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first");
+      EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
+                        THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+      
+      // Permute the right hand side to form X = Pr*B
+      // on return, X is overwritten by the computed solution
+      X.resize(B.rows(),B.cols());
+
+      // this ugly const_cast_derived() helps to detect aliasing when applying the permutations
+      for(Index j = 0; j < B.cols(); ++j)
+        X.col(j) = rowsPermutation() * B.const_cast_derived().col(j);
+      
+      //Forward substitution with L
+      this->matrixL().solveInPlace(X);
+      this->matrixU().solveInPlace(X);
+      
+      // Permute back the solution 
+      for (Index j = 0; j < B.cols(); ++j)
+        X.col(j) = colsPermutation().inverse() * X.col(j);
+      
+      return true; 
+    }
+    
+    /**
+      * \returns the absolute value of the determinant of the matrix of which
+      * *this is the QR decomposition.
+      *
+      * \warning a determinant can be very big or small, so for matrices
+      * of large enough dimension, there is a risk of overflow/underflow.
+      * One way to work around that is to use logAbsDeterminant() instead.
+      *
+      * \sa logAbsDeterminant(), signDeterminant()
+      */
+    Scalar absDeterminant()
+    {
+      using std::abs;
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      // Initialize with the determinant of the row matrix
+      Scalar det = Scalar(1.);
+      // Note that the diagonal blocks of U are stored in supernodes,
+      // which are available in the  L part :)
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.index() == j)
+          {
+            det *= abs(it.value());
+            break;
+          }
+        }
+      }
+      return det;
+    }
+
+    /** \returns the natural log of the absolute value of the determinant of the matrix
+      * of which **this is the QR decomposition
+      *
+      * \note This method is useful to work around the risk of overflow/underflow that's
+      * inherent to the determinant computation.
+      *
+      * \sa absDeterminant(), signDeterminant()
+      */
+    Scalar logAbsDeterminant() const
+    {
+      using std::log;
+      using std::abs;
+
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      Scalar det = Scalar(0.);
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.row() < j) continue;
+          if(it.row() == j)
+          {
+            det += log(abs(it.value()));
+            break;
+          }
+        }
+      }
+      return det;
+    }
+
+    /** \returns A number representing the sign of the determinant
+      *
+      * \sa absDeterminant(), logAbsDeterminant()
+      */
+    Scalar signDeterminant()
+    {
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      // Initialize with the determinant of the row matrix
+      Index det = 1;
+      // Note that the diagonal blocks of U are stored in supernodes,
+      // which are available in the  L part :)
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.index() == j)
+          {
+            if(it.value()<0)
+              det = -det;
+            else if(it.value()==0)
+              return 0;
+            break;
+          }
+        }
+      }
+      return det * m_detPermR * m_detPermC;
+    }
+    
+    /** \returns The determinant of the matrix.
+      *
+      * \sa absDeterminant(), logAbsDeterminant()
+      */
+    Scalar determinant()
+    {
+      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
+      // Initialize with the determinant of the row matrix
+      Scalar det = Scalar(1.);
+      // Note that the diagonal blocks of U are stored in supernodes,
+      // which are available in the  L part :)
+      for (Index j = 0; j < this->cols(); ++j)
+      {
+        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
+        {
+          if(it.index() == j)
+          {
+            det *= it.value();
+            break;
+          }
+        }
+      }
+      return (m_detPermR * m_detPermC) > 0 ? det : -det;
+    }
+
+    Index nnzL() const { return m_nnzL; };
+    Index nnzU() const { return m_nnzU; };
+
+  protected:
+    // Functions 
+    void initperfvalues()
+    {
+      m_perfv.panel_size = 16;
+      m_perfv.relax = 1; 
+      m_perfv.maxsuper = 128; 
+      m_perfv.rowblk = 16; 
+      m_perfv.colblk = 8; 
+      m_perfv.fillfactor = 20;  
+    }
+      
+    // Variables 
+    mutable ComputationInfo m_info;
+    bool m_factorizationIsOk;
+    bool m_analysisIsOk;
+    std::string m_lastError;
+    NCMatrix m_mat; // The input (permuted ) matrix 
+    SCMatrix m_Lstore; // The lower triangular matrix (supernodal)
+    MappedSparseMatrix<Scalar,ColMajor,StorageIndex> m_Ustore; // The upper triangular matrix
+    PermutationType m_perm_c; // Column permutation 
+    PermutationType m_perm_r ; // Row permutation
+    IndexVector m_etree; // Column elimination tree 
+    
+    typename Base::GlobalLU_t m_glu; 
+                               
+    // SparseLU options 
+    bool m_symmetricmode;
+    // values for performance 
+    internal::perfvalues m_perfv;
+    RealScalar m_diagpivotthresh; // Specifies the threshold used for a diagonal entry to be an acceptable pivot
+    Index m_nnzL, m_nnzU; // Nonzeros in L and U factors
+    Index m_detPermR, m_detPermC; // Determinants of the permutation matrices
+  private:
+    // Disable copy constructor 
+    SparseLU (const SparseLU& );
+}; // End class SparseLU
+
+
+
+// Functions needed by the anaysis phase
+/** 
+  * Compute the column permutation to minimize the fill-in
+  * 
+  *  - Apply this permutation to the input matrix - 
+  * 
+  *  - Compute the column elimination tree on the permuted matrix 
+  * 
+  *  - Postorder the elimination tree and the column permutation
+  * 
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseLU<MatrixType, OrderingType>::analyzePattern(const MatrixType& mat)
+{
+  
+  //TODO  It is possible as in SuperLU to compute row and columns scaling vectors to equilibrate the matrix mat.
+  
+  // Firstly, copy the whole input matrix. 
+  m_mat = mat;
+  
+  // Compute fill-in ordering
+  OrderingType ord; 
+  ord(m_mat,m_perm_c);
+  
+  // Apply the permutation to the column of the input  matrix
+  if (m_perm_c.size())
+  {
+    m_mat.uncompress(); //NOTE: The effect of this command is only to create the InnerNonzeros pointers. FIXME : This vector is filled but not subsequently used.  
+    // Then, permute only the column pointers
+    ei_declare_aligned_stack_constructed_variable(StorageIndex,outerIndexPtr,mat.cols()+1,mat.isCompressed()?const_cast<StorageIndex*>(mat.outerIndexPtr()):0);
+    
+    // If the input matrix 'mat' is uncompressed, then the outer-indices do not match the ones of m_mat, and a copy is thus needed.
+    if(!mat.isCompressed()) 
+      IndexVector::Map(outerIndexPtr, mat.cols()+1) = IndexVector::Map(m_mat.outerIndexPtr(),mat.cols()+1);
+    
+    // Apply the permutation and compute the nnz per column.
+    for (Index i = 0; i < mat.cols(); i++)
+    {
+      m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
+      m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i+1] - outerIndexPtr[i];
+    }
+  }
+  
+  // Compute the column elimination tree of the permuted matrix 
+  IndexVector firstRowElt;
+  internal::coletree(m_mat, m_etree,firstRowElt); 
+     
+  // In symmetric mode, do not do postorder here
+  if (!m_symmetricmode) {
+    IndexVector post, iwork; 
+    // Post order etree
+    internal::treePostorder(StorageIndex(m_mat.cols()), m_etree, post); 
+      
+   
+    // Renumber etree in postorder 
+    Index m = m_mat.cols(); 
+    iwork.resize(m+1);
+    for (Index i = 0; i < m; ++i) iwork(post(i)) = post(m_etree(i));
+    m_etree = iwork;
+    
+    // Postmultiply A*Pc by post, i.e reorder the matrix according to the postorder of the etree
+    PermutationType post_perm(m); 
+    for (Index i = 0; i < m; i++) 
+      post_perm.indices()(i) = post(i); 
+        
+    // Combine the two permutations : postorder the permutation for future use
+    if(m_perm_c.size()) {
+      m_perm_c = post_perm * m_perm_c;
+    }
+    
+  } // end postordering 
+  
+  m_analysisIsOk = true; 
+}
+
+// Functions needed by the numerical factorization phase
+
+
+/** 
+  *  - Numerical factorization 
+  *  - Interleaved with the symbolic factorization 
+  * On exit,  info is 
+  * 
+  *    = 0: successful factorization
+  * 
+  *    > 0: if info = i, and i is
+  * 
+  *       <= A->ncol: U(i,i) is exactly zero. The factorization has
+  *          been completed, but the factor U is exactly singular,
+  *          and division by zero will occur if it is used to solve a
+  *          system of equations.
+  * 
+  *       > A->ncol: number of bytes allocated when memory allocation
+  *         failure occurred, plus A->ncol. If lwork = -1, it is
+  *         the estimated amount of space needed, plus A->ncol.  
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseLU<MatrixType, OrderingType>::factorize(const MatrixType& matrix)
+{
+  using internal::emptyIdxLU;
+  eigen_assert(m_analysisIsOk && "analyzePattern() should be called first"); 
+  eigen_assert((matrix.rows() == matrix.cols()) && "Only for squared matrices");
+  
+  m_isInitialized = true;
+  
+  // Apply the column permutation computed in analyzepattern()
+  //   m_mat = matrix * m_perm_c.inverse(); 
+  m_mat = matrix;
+  if (m_perm_c.size()) 
+  {
+    m_mat.uncompress(); //NOTE: The effect of this command is only to create the InnerNonzeros pointers.
+    //Then, permute only the column pointers
+    const StorageIndex * outerIndexPtr;
+    if (matrix.isCompressed()) outerIndexPtr = matrix.outerIndexPtr();
+    else
+    {
+      StorageIndex* outerIndexPtr_t = new StorageIndex[matrix.cols()+1];
+      for(Index i = 0; i <= matrix.cols(); i++) outerIndexPtr_t[i] = m_mat.outerIndexPtr()[i];
+      outerIndexPtr = outerIndexPtr_t;
+    }
+    for (Index i = 0; i < matrix.cols(); i++)
+    {
+      m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
+      m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i+1] - outerIndexPtr[i];
+    }
+    if(!matrix.isCompressed()) delete[] outerIndexPtr;
+  } 
+  else 
+  { //FIXME This should not be needed if the empty permutation is handled transparently
+    m_perm_c.resize(matrix.cols());
+    for(StorageIndex i = 0; i < matrix.cols(); ++i) m_perm_c.indices()(i) = i;
+  }
+  
+  Index m = m_mat.rows();
+  Index n = m_mat.cols();
+  Index nnz = m_mat.nonZeros();
+  Index maxpanel = m_perfv.panel_size * m;
+  // Allocate working storage common to the factor routines
+  Index lwork = 0;
+  Index info = Base::memInit(m, n, nnz, lwork, m_perfv.fillfactor, m_perfv.panel_size, m_glu); 
+  if (info) 
+  {
+    m_lastError = "UNABLE TO ALLOCATE WORKING MEMORY\n\n" ;
+    m_factorizationIsOk = false;
+    return ; 
+  }
+  
+  // Set up pointers for integer working arrays 
+  IndexVector segrep(m); segrep.setZero();
+  IndexVector parent(m); parent.setZero();
+  IndexVector xplore(m); xplore.setZero();
+  IndexVector repfnz(maxpanel);
+  IndexVector panel_lsub(maxpanel);
+  IndexVector xprune(n); xprune.setZero();
+  IndexVector marker(m*internal::LUNoMarker); marker.setZero();
+  
+  repfnz.setConstant(-1); 
+  panel_lsub.setConstant(-1);
+  
+  // Set up pointers for scalar working arrays 
+  ScalarVector dense; 
+  dense.setZero(maxpanel);
+  ScalarVector tempv; 
+  tempv.setZero(internal::LUnumTempV(m, m_perfv.panel_size, m_perfv.maxsuper, /*m_perfv.rowblk*/m) );
+  
+  // Compute the inverse of perm_c
+  PermutationType iperm_c(m_perm_c.inverse()); 
+  
+  // Identify initial relaxed snodes
+  IndexVector relax_end(n);
+  if ( m_symmetricmode == true ) 
+    Base::heap_relax_snode(n, m_etree, m_perfv.relax, marker, relax_end);
+  else
+    Base::relax_snode(n, m_etree, m_perfv.relax, marker, relax_end);
+  
+  
+  m_perm_r.resize(m); 
+  m_perm_r.indices().setConstant(-1);
+  marker.setConstant(-1);
+  m_detPermR = 1; // Record the determinant of the row permutation
+  
+  m_glu.supno(0) = emptyIdxLU; m_glu.xsup.setConstant(0);
+  m_glu.xsup(0) = m_glu.xlsub(0) = m_glu.xusub(0) = m_glu.xlusup(0) = Index(0);
+  
+  // Work on one 'panel' at a time. A panel is one of the following :
+  //  (a) a relaxed supernode at the bottom of the etree, or
+  //  (b) panel_size contiguous columns, <panel_size> defined by the user
+  Index jcol; 
+  Index pivrow; // Pivotal row number in the original row matrix
+  Index nseg1; // Number of segments in U-column above panel row jcol
+  Index nseg; // Number of segments in each U-column 
+  Index irep; 
+  Index i, k, jj; 
+  for (jcol = 0; jcol < n; )
+  {
+    // Adjust panel size so that a panel won't overlap with the next relaxed snode. 
+    Index panel_size = m_perfv.panel_size; // upper bound on panel width
+    for (k = jcol + 1; k < (std::min)(jcol+panel_size, n); k++)
+    {
+      if (relax_end(k) != emptyIdxLU) 
+      {
+        panel_size = k - jcol; 
+        break; 
+      }
+    }
+    if (k == n) 
+      panel_size = n - jcol; 
+      
+    // Symbolic outer factorization on a panel of columns 
+    Base::panel_dfs(m, panel_size, jcol, m_mat, m_perm_r.indices(), nseg1, dense, panel_lsub, segrep, repfnz, xprune, marker, parent, xplore, m_glu); 
+    
+    // Numeric sup-panel updates in topological order 
+    Base::panel_bmod(m, panel_size, jcol, nseg1, dense, tempv, segrep, repfnz, m_glu); 
+    
+    // Sparse LU within the panel, and below the panel diagonal 
+    for ( jj = jcol; jj< jcol + panel_size; jj++) 
+    {
+      k = (jj - jcol) * m; // Column index for w-wide arrays 
+      
+      nseg = nseg1; // begin after all the panel segments
+      //Depth-first-search for the current column
+      VectorBlock<IndexVector> panel_lsubk(panel_lsub, k, m);
+      VectorBlock<IndexVector> repfnz_k(repfnz, k, m); 
+      info = Base::column_dfs(m, jj, m_perm_r.indices(), m_perfv.maxsuper, nseg, panel_lsubk, segrep, repfnz_k, xprune, marker, parent, xplore, m_glu); 
+      if ( info ) 
+      {
+        m_lastError =  "UNABLE TO EXPAND MEMORY IN COLUMN_DFS() ";
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      // Numeric updates to this column 
+      VectorBlock<ScalarVector> dense_k(dense, k, m); 
+      VectorBlock<IndexVector> segrep_k(segrep, nseg1, m-nseg1); 
+      info = Base::column_bmod(jj, (nseg - nseg1), dense_k, tempv, segrep_k, repfnz_k, jcol, m_glu); 
+      if ( info ) 
+      {
+        m_lastError = "UNABLE TO EXPAND MEMORY IN COLUMN_BMOD() ";
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      
+      // Copy the U-segments to ucol(*)
+      info = Base::copy_to_ucol(jj, nseg, segrep, repfnz_k ,m_perm_r.indices(), dense_k, m_glu); 
+      if ( info ) 
+      {
+        m_lastError = "UNABLE TO EXPAND MEMORY IN COPY_TO_UCOL() ";
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      
+      // Form the L-segment 
+      info = Base::pivotL(jj, m_diagpivotthresh, m_perm_r.indices(), iperm_c.indices(), pivrow, m_glu);
+      if ( info ) 
+      {
+        m_lastError = "THE MATRIX IS STRUCTURALLY SINGULAR ... ZERO COLUMN AT ";
+        std::ostringstream returnInfo;
+        returnInfo << info; 
+        m_lastError += returnInfo.str();
+        m_info = NumericalIssue; 
+        m_factorizationIsOk = false; 
+        return; 
+      }
+      
+      // Update the determinant of the row permutation matrix
+      // FIXME: the following test is not correct, we should probably take iperm_c into account and pivrow is not directly the row pivot.
+      if (pivrow != jj) m_detPermR = -m_detPermR;
+
+      // Prune columns (0:jj-1) using column jj
+      Base::pruneL(jj, m_perm_r.indices(), pivrow, nseg, segrep, repfnz_k, xprune, m_glu); 
+      
+      // Reset repfnz for this column 
+      for (i = 0; i < nseg; i++)
+      {
+        irep = segrep(i); 
+        repfnz_k(irep) = emptyIdxLU; 
+      }
+    } // end SparseLU within the panel  
+    jcol += panel_size;  // Move to the next panel
+  } // end for -- end elimination 
+  
+  m_detPermR = m_perm_r.determinant();
+  m_detPermC = m_perm_c.determinant();
+  
+  // Count the number of nonzeros in factors 
+  Base::countnz(n, m_nnzL, m_nnzU, m_glu); 
+  // Apply permutation  to the L subscripts 
+  Base::fixupL(n, m_perm_r.indices(), m_glu);
+  
+  // Create supernode matrix L 
+  m_Lstore.setInfos(m, n, m_glu.lusup, m_glu.xlusup, m_glu.lsub, m_glu.xlsub, m_glu.supno, m_glu.xsup); 
+  // Create the column major upper sparse matrix  U; 
+  new (&m_Ustore) MappedSparseMatrix<Scalar, ColMajor, StorageIndex> ( m, n, m_nnzU, m_glu.xusub.data(), m_glu.usub.data(), m_glu.ucol.data() );
+  
+  m_info = Success;
+  m_factorizationIsOk = true;
+}
+
+template<typename MappedSupernodalType>
+struct SparseLUMatrixLReturnType : internal::no_assignment_operator
+{
+  typedef typename MappedSupernodalType::Scalar Scalar;
+  explicit SparseLUMatrixLReturnType(const MappedSupernodalType& mapL) : m_mapL(mapL)
+  { }
+  Index rows() const { return m_mapL.rows(); }
+  Index cols() const { return m_mapL.cols(); }
+  template<typename Dest>
+  void solveInPlace( MatrixBase<Dest> &X) const
+  {
+    m_mapL.solveInPlace(X);
+  }
+  template<bool Conjugate, typename Dest>
+  void solveTransposedInPlace( MatrixBase<Dest> &X) const
+  {
+    m_mapL.template solveTransposedInPlace<Conjugate>(X);
+  }
+
+  const MappedSupernodalType& m_mapL;
+};
+
+template<typename MatrixLType, typename MatrixUType>
+struct SparseLUMatrixUReturnType : internal::no_assignment_operator
+{
+  typedef typename MatrixLType::Scalar Scalar;
+  SparseLUMatrixUReturnType(const MatrixLType& mapL, const MatrixUType& mapU)
+  : m_mapL(mapL),m_mapU(mapU)
+  { }
+  Index rows() const { return m_mapL.rows(); }
+  Index cols() const { return m_mapL.cols(); }
+
+  template<typename Dest>   void solveInPlace(MatrixBase<Dest> &X) const
+  {
+    Index nrhs = X.cols();
+    Index n    = X.rows();
+    // Backward solve with U
+    for (Index k = m_mapL.nsuper(); k >= 0; k--)
+    {
+      Index fsupc = m_mapL.supToCol()[k];
+      Index lda = m_mapL.colIndexPtr()[fsupc+1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
+      Index nsupc = m_mapL.supToCol()[k+1] - fsupc;
+      Index luptr = m_mapL.colIndexPtr()[fsupc];
+
+      if (nsupc == 1)
+      {
+        for (Index j = 0; j < nrhs; j++)
+        {
+          X(fsupc, j) /= m_mapL.valuePtr()[luptr];
+        }
+      }
+      else
+      {
+        // FIXME: the following lines should use Block expressions and not Map!
+        Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(m_mapL.valuePtr()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+        Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X.coeffRef(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
+        U = A.template triangularView<Upper>().solve(U);
+      }
+
+      for (Index j = 0; j < nrhs; ++j)
+      {
+        for (Index jcol = fsupc; jcol < fsupc + nsupc; jcol++)
+        {
+          typename MatrixUType::InnerIterator it(m_mapU, jcol);
+          for ( ; it; ++it)
+          {
+            Index irow = it.index();
+            X(irow, j) -= X(jcol, j) * it.value();
+          }
+        }
+      }
+    } // End For U-solve
+  }
+
+  template<bool Conjugate, typename Dest>   void solveTransposedInPlace(MatrixBase<Dest> &X) const
+  {
+    using numext::conj;
+    Index nrhs = X.cols();
+    Index n    = X.rows();
+    // Forward solve with U
+    for (Index k = 0; k <=  m_mapL.nsuper(); k++)
+    {
+      Index fsupc = m_mapL.supToCol()[k];
+      Index lda = m_mapL.colIndexPtr()[fsupc+1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
+      Index nsupc = m_mapL.supToCol()[k+1] - fsupc;
+      Index luptr = m_mapL.colIndexPtr()[fsupc];
+
+      for (Index j = 0; j < nrhs; ++j)
+      {
+        for (Index jcol = fsupc; jcol < fsupc + nsupc; jcol++)
+        {
+          typename MatrixUType::InnerIterator it(m_mapU, jcol);
+          for ( ; it; ++it)
+          {
+            Index irow = it.index();
+            X(jcol, j) -= X(irow, j) * (Conjugate? conj(it.value()): it.value());
+          }
+        }
+      }
+      if (nsupc == 1)
+      {
+        for (Index j = 0; j < nrhs; j++)
+        {
+          X(fsupc, j) /= (Conjugate? conj(m_mapL.valuePtr()[luptr]) : m_mapL.valuePtr()[luptr]);
+        }
+      }
+      else
+      {
+        Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(m_mapL.valuePtr()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+        Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
+        if(Conjugate)
+          U = A.adjoint().template triangularView<Lower>().solve(U);
+        else
+          U = A.transpose().template triangularView<Lower>().solve(U);
+      }
+    }// End For U-solve
+  }
+
+
+  const MatrixLType& m_mapL;
+  const MatrixUType& m_mapU;
+};
+
+} // End namespace Eigen 
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLUImpl.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLUImpl.h
new file mode 100644
index 00000000..fc0cfc4d
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLUImpl.h
@@ -0,0 +1,66 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#ifndef SPARSELU_IMPL_H
+#define SPARSELU_IMPL_H
+
+namespace Eigen {
+namespace internal {
+  
+/** \ingroup SparseLU_Module
+  * \class SparseLUImpl
+  * Base class for sparseLU
+  */
+template <typename Scalar, typename StorageIndex>
+class SparseLUImpl
+{
+  public:
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector; 
+    typedef Matrix<Scalar,Dynamic,Dynamic,ColMajor> ScalarMatrix;
+    typedef Map<ScalarMatrix, 0,  OuterStride<> > MappedMatrixBlock;
+    typedef typename ScalarVector::RealScalar RealScalar; 
+    typedef Ref<Matrix<Scalar,Dynamic,1> > BlockScalarVector;
+    typedef Ref<Matrix<StorageIndex,Dynamic,1> > BlockIndexVector;
+    typedef LU_GlobalLU_t<IndexVector, ScalarVector> GlobalLU_t; 
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> MatrixType; 
+    
+  protected:
+     template <typename VectorType>
+     Index expand(VectorType& vec, Index& length, Index nbElts, Index keep_prev, Index& num_expansions);
+     Index memInit(Index m, Index n, Index annz, Index lwork, Index fillratio, Index panel_size,  GlobalLU_t& glu); 
+     template <typename VectorType>
+     Index memXpand(VectorType& vec, Index& maxlen, Index nbElts, MemType memtype, Index& num_expansions);
+     void heap_relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end); 
+     void relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end); 
+     Index snode_dfs(const Index jcol, const Index kcol,const MatrixType& mat,  IndexVector& xprune, IndexVector& marker, GlobalLU_t& glu); 
+     Index snode_bmod (const Index jcol, const Index fsupc, ScalarVector& dense, GlobalLU_t& glu);
+     Index pivotL(const Index jcol, const RealScalar& diagpivotthresh, IndexVector& perm_r, IndexVector& iperm_c, Index& pivrow, GlobalLU_t& glu);
+     template <typename Traits>
+     void dfs_kernel(const StorageIndex jj, IndexVector& perm_r,
+                    Index& nseg, IndexVector& panel_lsub, IndexVector& segrep,
+                    Ref<IndexVector> repfnz_col, IndexVector& xprune, Ref<IndexVector> marker, IndexVector& parent,
+                    IndexVector& xplore, GlobalLU_t& glu, Index& nextl_col, Index krow, Traits& traits);
+     void panel_dfs(const Index m, const Index w, const Index jcol, MatrixType& A, IndexVector& perm_r, Index& nseg, ScalarVector& dense, IndexVector& panel_lsub, IndexVector& segrep, IndexVector& repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu);
+    
+     void panel_bmod(const Index m, const Index w, const Index jcol, const Index nseg, ScalarVector& dense, ScalarVector& tempv, IndexVector& segrep, IndexVector& repfnz, GlobalLU_t& glu);
+     Index column_dfs(const Index m, const Index jcol, IndexVector& perm_r, Index maxsuper, Index& nseg,  BlockIndexVector lsub_col, IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu);
+     Index column_bmod(const Index jcol, const Index nseg, BlockScalarVector dense, ScalarVector& tempv, BlockIndexVector segrep, BlockIndexVector repfnz, Index fpanelc, GlobalLU_t& glu); 
+     Index copy_to_ucol(const Index jcol, const Index nseg, IndexVector& segrep, BlockIndexVector repfnz ,IndexVector& perm_r, BlockScalarVector dense, GlobalLU_t& glu); 
+     void pruneL(const Index jcol, const IndexVector& perm_r, const Index pivrow, const Index nseg, const IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, GlobalLU_t& glu);
+     void countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu); 
+     void fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu); 
+     
+     template<typename , typename >
+     friend struct column_dfs_traits;
+}; 
+
+} // end namespace internal
+} // namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_Memory.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_Memory.h
new file mode 100644
index 00000000..349bfd58
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_Memory.h
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]memory.c files in SuperLU 
+ 
+ * -- SuperLU routine (version 3.1) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * August 1, 2008
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+
+#ifndef EIGEN_SPARSELU_MEMORY
+#define EIGEN_SPARSELU_MEMORY
+
+namespace Eigen {
+namespace internal {
+  
+enum { LUNoMarker = 3 };
+enum {emptyIdxLU = -1};
+inline Index LUnumTempV(Index& m, Index& w, Index& t, Index& b)
+{
+  return (std::max)(m, (t+b)*w);
+}
+
+template< typename Scalar>
+inline Index LUTempSpace(Index&m, Index& w)
+{
+  return (2*w + 4 + LUNoMarker) * m * sizeof(Index) + (w + 1) * m * sizeof(Scalar);
+}
+
+
+
+
+/** 
+  * Expand the existing storage to accommodate more fill-ins
+  * \param vec Valid pointer to the vector to allocate or expand
+  * \param[in,out] length  At input, contain the current length of the vector that is to be increased. At output, length of the newly allocated vector
+  * \param[in] nbElts Current number of elements in the factors
+  * \param keep_prev  1: use length  and do not expand the vector; 0: compute new_len and expand
+  * \param[in,out] num_expansions Number of times the memory has been expanded
+  */
+template <typename Scalar, typename StorageIndex>
+template <typename VectorType>
+Index  SparseLUImpl<Scalar,StorageIndex>::expand(VectorType& vec, Index& length, Index nbElts, Index keep_prev, Index& num_expansions) 
+{
+  
+  float alpha = 1.5; // Ratio of the memory increase 
+  Index new_len; // New size of the allocated memory
+  
+  if(num_expansions == 0 || keep_prev) 
+    new_len = length ; // First time allocate requested
+  else 
+    new_len = (std::max)(length+1,Index(alpha * length));
+  
+  VectorType old_vec; // Temporary vector to hold the previous values   
+  if (nbElts > 0 )
+    old_vec = vec.segment(0,nbElts); 
+  
+  //Allocate or expand the current vector
+#ifdef EIGEN_EXCEPTIONS
+  try
+#endif
+  {
+    vec.resize(new_len); 
+  }
+#ifdef EIGEN_EXCEPTIONS
+  catch(std::bad_alloc& )
+#else
+  if(!vec.size())
+#endif
+  {
+    if (!num_expansions)
+    {
+      // First time to allocate from LUMemInit()
+      // Let LUMemInit() deals with it.
+      return -1;
+    }
+    if (keep_prev)
+    {
+      // In this case, the memory length should not not be reduced
+      return new_len;
+    }
+    else 
+    {
+      // Reduce the size and increase again 
+      Index tries = 0; // Number of attempts
+      do 
+      {
+        alpha = (alpha + 1)/2;
+        new_len = (std::max)(length+1,Index(alpha * length));
+#ifdef EIGEN_EXCEPTIONS
+        try
+#endif
+        {
+          vec.resize(new_len); 
+        }
+#ifdef EIGEN_EXCEPTIONS
+        catch(std::bad_alloc& )
+#else
+        if (!vec.size())
+#endif
+        {
+          tries += 1; 
+          if ( tries > 10) return new_len; 
+        }
+      } while (!vec.size());
+    }
+  }
+  //Copy the previous values to the newly allocated space 
+  if (nbElts > 0)
+    vec.segment(0, nbElts) = old_vec;   
+   
+  
+  length  = new_len;
+  if(num_expansions) ++num_expansions;
+  return 0; 
+}
+
+/**
+ * \brief  Allocate various working space for the numerical factorization phase.
+ * \param m number of rows of the input matrix 
+ * \param n number of columns 
+ * \param annz number of initial nonzeros in the matrix 
+ * \param lwork  if lwork=-1, this routine returns an estimated size of the required memory
+ * \param glu persistent data to facilitate multiple factors : will be deleted later ??
+ * \param fillratio estimated ratio of fill in the factors
+ * \param panel_size Size of a panel
+ * \return an estimated size of the required memory if lwork = -1; otherwise, return the size of actually allocated memory when allocation failed, and 0 on success
+ * \note Unlike SuperLU, this routine does not support successive factorization with the same pattern and the same row permutation
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::memInit(Index m, Index n, Index annz, Index lwork, Index fillratio, Index panel_size,  GlobalLU_t& glu)
+{
+  Index& num_expansions = glu.num_expansions; //No memory expansions so far
+  num_expansions = 0;
+  glu.nzumax = glu.nzlumax = (std::min)(fillratio * (annz+1) / n, m) * n; // estimated number of nonzeros in U 
+  glu.nzlmax = (std::max)(Index(4), fillratio) * (annz+1) / 4; // estimated  nnz in L factor
+  // Return the estimated size to the user if necessary
+  Index tempSpace;
+  tempSpace = (2*panel_size + 4 + LUNoMarker) * m * sizeof(Index) + (panel_size + 1) * m * sizeof(Scalar);
+  if (lwork == emptyIdxLU) 
+  {
+    Index estimated_size;
+    estimated_size = (5 * n + 5) * sizeof(Index)  + tempSpace
+                    + (glu.nzlmax + glu.nzumax) * sizeof(Index) + (glu.nzlumax+glu.nzumax) *  sizeof(Scalar) + n; 
+    return estimated_size;
+  }
+  
+  // Setup the required space 
+  
+  // First allocate Integer pointers for L\U factors
+  glu.xsup.resize(n+1);
+  glu.supno.resize(n+1);
+  glu.xlsub.resize(n+1);
+  glu.xlusup.resize(n+1);
+  glu.xusub.resize(n+1);
+
+  // Reserve memory for L/U factors
+  do 
+  {
+    if(     (expand<ScalarVector>(glu.lusup, glu.nzlumax, 0, 0, num_expansions)<0)
+        ||  (expand<ScalarVector>(glu.ucol,  glu.nzumax,  0, 0, num_expansions)<0)
+        ||  (expand<IndexVector> (glu.lsub,  glu.nzlmax,  0, 0, num_expansions)<0)
+        ||  (expand<IndexVector> (glu.usub,  glu.nzumax,  0, 1, num_expansions)<0) )
+    {
+      //Reduce the estimated size and retry
+      glu.nzlumax /= 2;
+      glu.nzumax /= 2;
+      glu.nzlmax /= 2;
+      if (glu.nzlumax < annz ) return glu.nzlumax; 
+    }
+  } while (!glu.lusup.size() || !glu.ucol.size() || !glu.lsub.size() || !glu.usub.size());
+  
+  ++num_expansions;
+  return 0;
+  
+} // end LuMemInit
+
+/** 
+ * \brief Expand the existing storage 
+ * \param vec vector to expand 
+ * \param[in,out] maxlen On input, previous size of vec (Number of elements to copy ). on output, new size
+ * \param nbElts current number of elements in the vector.
+ * \param memtype Type of the element to expand
+ * \param num_expansions Number of expansions 
+ * \return 0 on success, > 0 size of the memory allocated so far
+ */
+template <typename Scalar, typename StorageIndex>
+template <typename VectorType>
+Index SparseLUImpl<Scalar,StorageIndex>::memXpand(VectorType& vec, Index& maxlen, Index nbElts, MemType memtype, Index& num_expansions)
+{
+  Index failed_size; 
+  if (memtype == USUB)
+     failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 1, num_expansions);
+  else
+    failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 0, num_expansions);
+
+  if (failed_size)
+    return failed_size; 
+  
+  return 0 ;  
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // EIGEN_SPARSELU_MEMORY
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_Structs.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_Structs.h
new file mode 100644
index 00000000..cf5ec449
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_Structs.h
@@ -0,0 +1,110 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ * NOTE: This file comes from a partly modified version of files slu_[s,d,c,z]defs.h
+ * -- SuperLU routine (version 4.1) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November, 2010
+ * 
+ * Global data structures used in LU factorization -
+ * 
+ *   nsuper: #supernodes = nsuper + 1, numbered [0, nsuper].
+ *   (xsup,supno): supno[i] is the supernode no to which i belongs;
+ *  xsup(s) points to the beginning of the s-th supernode.
+ *  e.g.   supno 0 1 2 2 3 3 3 4 4 4 4 4   (n=12)
+ *          xsup 0 1 2 4 7 12
+ *  Note: dfs will be performed on supernode rep. relative to the new 
+ *        row pivoting ordering
+ *
+ *   (xlsub,lsub): lsub[*] contains the compressed subscript of
+ *  rectangular supernodes; xlsub[j] points to the starting
+ *  location of the j-th column in lsub[*]. Note that xlsub 
+ *  is indexed by column.
+ *  Storage: original row subscripts
+ *
+ *      During the course of sparse LU factorization, we also use
+ *  (xlsub,lsub) for the purpose of symmetric pruning. For each
+ *  supernode {s,s+1,...,t=s+r} with first column s and last
+ *  column t, the subscript set
+ *    lsub[j], j=xlsub[s], .., xlsub[s+1]-1
+ *  is the structure of column s (i.e. structure of this supernode).
+ *  It is used for the storage of numerical values.
+ *  Furthermore,
+ *    lsub[j], j=xlsub[t], .., xlsub[t+1]-1
+ *  is the structure of the last column t of this supernode.
+ *  It is for the purpose of symmetric pruning. Therefore, the
+ *  structural subscripts can be rearranged without making physical
+ *  interchanges among the numerical values.
+ *
+ *  However, if the supernode has only one column, then we
+ *  only keep one set of subscripts. For any subscript interchange
+ *  performed, similar interchange must be done on the numerical
+ *  values.
+ *
+ *  The last column structures (for pruning) will be removed
+ *  after the numercial LU factorization phase.
+ *
+ *   (xlusup,lusup): lusup[*] contains the numerical values of the
+ *  rectangular supernodes; xlusup[j] points to the starting
+ *  location of the j-th column in storage vector lusup[*]
+ *  Note: xlusup is indexed by column.
+ *  Each rectangular supernode is stored by column-major
+ *  scheme, consistent with Fortran 2-dim array storage.
+ *
+ *   (xusub,ucol,usub): ucol[*] stores the numerical values of
+ *  U-columns outside the rectangular supernodes. The row
+ *  subscript of nonzero ucol[k] is stored in usub[k].
+ *  xusub[i] points to the starting location of column i in ucol.
+ *  Storage: new row subscripts; that is subscripts of PA.
+ */
+
+#ifndef EIGEN_LU_STRUCTS
+#define EIGEN_LU_STRUCTS
+namespace Eigen {
+namespace internal {
+  
+typedef enum {LUSUP, UCOL, LSUB, USUB, LLVL, ULVL} MemType; 
+
+template <typename IndexVector, typename ScalarVector>
+struct LU_GlobalLU_t {
+  typedef typename IndexVector::Scalar StorageIndex; 
+  IndexVector xsup; //First supernode column ... xsup(s) points to the beginning of the s-th supernode
+  IndexVector supno; // Supernode number corresponding to this column (column to supernode mapping)
+  ScalarVector  lusup; // nonzero values of L ordered by columns 
+  IndexVector lsub; // Compressed row indices of L rectangular supernodes. 
+  IndexVector xlusup; // pointers to the beginning of each column in lusup
+  IndexVector xlsub; // pointers to the beginning of each column in lsub
+  Index   nzlmax; // Current max size of lsub
+  Index   nzlumax; // Current max size of lusup
+  ScalarVector  ucol; // nonzero values of U ordered by columns 
+  IndexVector usub; // row indices of U columns in ucol
+  IndexVector xusub; // Pointers to the beginning of each column of U in ucol 
+  Index   nzumax; // Current max size of ucol
+  Index   n; // Number of columns in the matrix  
+  Index   num_expansions; 
+};
+
+// Values to set for performance
+struct perfvalues {
+  Index panel_size; // a panel consists of at most <panel_size> consecutive columns
+  Index relax; // To control degree of relaxing supernodes. If the number of nodes (columns) 
+                // in a subtree of the elimination tree is less than relax, this subtree is considered 
+                // as one supernode regardless of the row structures of those columns
+  Index maxsuper; // The maximum size for a supernode in complete LU
+  Index rowblk; // The minimum row dimension for 2-D blocking to be used;
+  Index colblk; // The minimum column dimension for 2-D blocking to be used;
+  Index fillfactor; // The estimated fills factors for L and U, compared with A
+}; 
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // EIGEN_LU_STRUCTS
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h
new file mode 100644
index 00000000..0be293d1
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h
@@ -0,0 +1,375 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
+#define EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
+
+namespace Eigen {
+namespace internal {
+
+/** \ingroup SparseLU_Module
+ * \brief a class to manipulate the L supernodal factor from the SparseLU factorization
+ * 
+ * This class  contain the data to easily store 
+ * and manipulate the supernodes during the factorization and solution phase of Sparse LU. 
+ * Only the lower triangular matrix has supernodes.
+ * 
+ * NOTE : This class corresponds to the SCformat structure in SuperLU
+ * 
+ */
+/* TODO
+ * InnerIterator as for sparsematrix 
+ * SuperInnerIterator to iterate through all supernodes 
+ * Function for triangular solve
+ */
+template <typename _Scalar, typename _StorageIndex>
+class MappedSuperNodalMatrix
+{
+  public:
+    typedef _Scalar Scalar; 
+    typedef _StorageIndex StorageIndex;
+    typedef Matrix<StorageIndex,Dynamic,1> IndexVector;
+    typedef Matrix<Scalar,Dynamic,1> ScalarVector;
+  public:
+    MappedSuperNodalMatrix()
+    {
+      
+    }
+    MappedSuperNodalMatrix(Index m, Index n,  ScalarVector& nzval, IndexVector& nzval_colptr, IndexVector& rowind,
+             IndexVector& rowind_colptr, IndexVector& col_to_sup, IndexVector& sup_to_col )
+    {
+      setInfos(m, n, nzval, nzval_colptr, rowind, rowind_colptr, col_to_sup, sup_to_col);
+    }
+    
+    ~MappedSuperNodalMatrix()
+    {
+      
+    }
+    /**
+     * Set appropriate pointers for the lower triangular supernodal matrix
+     * These infos are available at the end of the numerical factorization
+     * FIXME This class will be modified such that it can be use in the course 
+     * of the factorization.
+     */
+    void setInfos(Index m, Index n, ScalarVector& nzval, IndexVector& nzval_colptr, IndexVector& rowind,
+             IndexVector& rowind_colptr, IndexVector& col_to_sup, IndexVector& sup_to_col )
+    {
+      m_row = m;
+      m_col = n; 
+      m_nzval = nzval.data(); 
+      m_nzval_colptr = nzval_colptr.data(); 
+      m_rowind = rowind.data(); 
+      m_rowind_colptr = rowind_colptr.data(); 
+      m_nsuper = col_to_sup(n); 
+      m_col_to_sup = col_to_sup.data(); 
+      m_sup_to_col = sup_to_col.data(); 
+    }
+    
+    /**
+     * Number of rows
+     */
+    Index rows() const { return m_row; }
+    
+    /**
+     * Number of columns
+     */
+    Index cols() const { return m_col; }
+    
+    /**
+     * Return the array of nonzero values packed by column
+     * 
+     * The size is nnz
+     */
+    Scalar* valuePtr() {  return m_nzval; }
+    
+    const Scalar* valuePtr() const 
+    {
+      return m_nzval; 
+    }
+    /**
+     * Return the pointers to the beginning of each column in \ref valuePtr()
+     */
+    StorageIndex* colIndexPtr()
+    {
+      return m_nzval_colptr; 
+    }
+    
+    const StorageIndex* colIndexPtr() const
+    {
+      return m_nzval_colptr; 
+    }
+    
+    /**
+     * Return the array of compressed row indices of all supernodes
+     */
+    StorageIndex* rowIndex()  { return m_rowind; }
+    
+    const StorageIndex* rowIndex() const
+    {
+      return m_rowind; 
+    }
+    
+    /**
+     * Return the location in \em rowvaluePtr() which starts each column
+     */
+    StorageIndex* rowIndexPtr() { return m_rowind_colptr; }
+    
+    const StorageIndex* rowIndexPtr() const
+    {
+      return m_rowind_colptr; 
+    }
+    
+    /** 
+     * Return the array of column-to-supernode mapping 
+     */
+    StorageIndex* colToSup()  { return m_col_to_sup; }
+    
+    const StorageIndex* colToSup() const
+    {
+      return m_col_to_sup;       
+    }
+    /**
+     * Return the array of supernode-to-column mapping
+     */
+    StorageIndex* supToCol() { return m_sup_to_col; }
+    
+    const StorageIndex* supToCol() const
+    {
+      return m_sup_to_col;
+    }
+    
+    /**
+     * Return the number of supernodes
+     */
+    Index nsuper() const
+    {
+      return m_nsuper; 
+    }
+    
+    class InnerIterator; 
+    template<typename Dest>
+    void solveInPlace( MatrixBase<Dest>&X) const;
+    template<bool Conjugate, typename Dest>
+    void solveTransposedInPlace( MatrixBase<Dest>&X) const;
+
+    
+      
+      
+    
+  protected:
+    Index m_row; // Number of rows
+    Index m_col; // Number of columns
+    Index m_nsuper; // Number of supernodes
+    Scalar* m_nzval; //array of nonzero values packed by column
+    StorageIndex* m_nzval_colptr; //nzval_colptr[j] Stores the location in nzval[] which starts column j
+    StorageIndex* m_rowind; // Array of compressed row indices of rectangular supernodes
+    StorageIndex* m_rowind_colptr; //rowind_colptr[j] stores the location in rowind[] which starts column j
+    StorageIndex* m_col_to_sup; // col_to_sup[j] is the supernode number to which column j belongs
+    StorageIndex* m_sup_to_col; //sup_to_col[s] points to the starting column of the s-th supernode
+    
+  private :
+};
+
+/**
+  * \brief InnerIterator class to iterate over nonzero values of the current column in the supernodal matrix L
+  * 
+  */
+template<typename Scalar, typename StorageIndex>
+class MappedSuperNodalMatrix<Scalar,StorageIndex>::InnerIterator
+{
+  public:
+     InnerIterator(const MappedSuperNodalMatrix& mat, Index outer)
+      : m_matrix(mat),
+        m_outer(outer),
+        m_supno(mat.colToSup()[outer]),
+        m_idval(mat.colIndexPtr()[outer]),
+        m_startidval(m_idval),
+        m_endidval(mat.colIndexPtr()[outer+1]),
+        m_idrow(mat.rowIndexPtr()[mat.supToCol()[mat.colToSup()[outer]]]),
+        m_endidrow(mat.rowIndexPtr()[mat.supToCol()[mat.colToSup()[outer]]+1])
+    {}
+    inline InnerIterator& operator++()
+    { 
+      m_idval++; 
+      m_idrow++;
+      return *this;
+    }
+    inline Scalar value() const { return m_matrix.valuePtr()[m_idval]; }
+    
+    inline Scalar& valueRef() { return const_cast<Scalar&>(m_matrix.valuePtr()[m_idval]); }
+    
+    inline Index index() const { return m_matrix.rowIndex()[m_idrow]; }
+    inline Index row() const { return index(); }
+    inline Index col() const { return m_outer; }
+    
+    inline Index supIndex() const { return m_supno; }
+    
+    inline operator bool() const 
+    { 
+      return ( (m_idval < m_endidval) && (m_idval >= m_startidval)
+                && (m_idrow < m_endidrow) );
+    }
+    
+  protected:
+    const MappedSuperNodalMatrix& m_matrix; // Supernodal lower triangular matrix 
+    const Index m_outer;                    // Current column 
+    const Index m_supno;                    // Current SuperNode number
+    Index m_idval;                          // Index to browse the values in the current column
+    const Index m_startidval;               // Start of the column value
+    const Index m_endidval;                 // End of the column value
+    Index m_idrow;                          // Index to browse the row indices 
+    Index m_endidrow;                       // End index of row indices of the current column
+};
+
+/**
+ * \brief Solve with the supernode triangular matrix
+ * 
+ */
+template<typename Scalar, typename Index_>
+template<typename Dest>
+void MappedSuperNodalMatrix<Scalar,Index_>::solveInPlace( MatrixBase<Dest>&X) const
+{
+    /* Explicit type conversion as the Index type of MatrixBase<Dest> may be wider than Index */
+//    eigen_assert(X.rows() <= NumTraits<Index>::highest());
+//    eigen_assert(X.cols() <= NumTraits<Index>::highest());
+    Index n    = int(X.rows());
+    Index nrhs = Index(X.cols());
+    const Scalar * Lval = valuePtr();                 // Nonzero values 
+    Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor> work(n, nrhs);     // working vector
+    work.setZero();
+    for (Index k = 0; k <= nsuper(); k ++)
+    {
+      Index fsupc = supToCol()[k];                    // First column of the current supernode 
+      Index istart = rowIndexPtr()[fsupc];            // Pointer index to the subscript of the current column
+      Index nsupr = rowIndexPtr()[fsupc+1] - istart;  // Number of rows in the current supernode
+      Index nsupc = supToCol()[k+1] - fsupc;          // Number of columns in the current supernode
+      Index nrow = nsupr - nsupc;                     // Number of rows in the non-diagonal part of the supernode
+      Index irow;                                     //Current index row
+      
+      if (nsupc == 1 )
+      {
+        for (Index j = 0; j < nrhs; j++)
+        {
+          InnerIterator it(*this, fsupc);
+          ++it; // Skip the diagonal element
+          for (; it; ++it)
+          {
+            irow = it.row();
+            X(irow, j) -= X(fsupc, j) * it.value();
+          }
+        }
+      }
+      else
+      {
+        // The supernode has more than one column 
+        Index luptr = colIndexPtr()[fsupc]; 
+        Index lda = colIndexPtr()[fsupc+1] - luptr;
+        
+        // Triangular solve 
+        Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(Lval[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+        Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
+        U = A.template triangularView<UnitLower>().solve(U); 
+        
+        // Matrix-vector product 
+        new (&A) Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > ( &(Lval[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
+        work.topRows(nrow).noalias() = A * U;
+        
+        //Begin Scatter 
+        for (Index j = 0; j < nrhs; j++)
+        {
+          Index iptr = istart + nsupc; 
+          for (Index i = 0; i < nrow; i++)
+          {
+            irow = rowIndex()[iptr]; 
+            X(irow, j) -= work(i, j); // Scatter operation
+            work(i, j) = Scalar(0); 
+            iptr++;
+          }
+        }
+      }
+    } 
+}
+
+template<typename Scalar, typename Index_>
+template<bool Conjugate, typename Dest>
+void MappedSuperNodalMatrix<Scalar,Index_>::solveTransposedInPlace( MatrixBase<Dest>&X) const
+{
+    using numext::conj;
+  Index n    = int(X.rows());
+  Index nrhs = Index(X.cols());
+  const Scalar * Lval = valuePtr();                 // Nonzero values
+  Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor> work(n, nrhs);     // working vector
+  work.setZero();
+  for (Index k = nsuper(); k >= 0; k--)
+  {
+    Index fsupc = supToCol()[k];                    // First column of the current supernode
+    Index istart = rowIndexPtr()[fsupc];            // Pointer index to the subscript of the current column
+    Index nsupr = rowIndexPtr()[fsupc+1] - istart;  // Number of rows in the current supernode
+    Index nsupc = supToCol()[k+1] - fsupc;          // Number of columns in the current supernode
+    Index nrow = nsupr - nsupc;                     // Number of rows in the non-diagonal part of the supernode
+    Index irow;                                     //Current index row
+
+    if (nsupc == 1 )
+    {
+      for (Index j = 0; j < nrhs; j++)
+      {
+        InnerIterator it(*this, fsupc);
+        ++it; // Skip the diagonal element
+        for (; it; ++it)
+        {
+          irow = it.row();
+          X(fsupc,j) -= X(irow, j) * (Conjugate?conj(it.value()):it.value());
+        }
+      }
+    }
+    else
+    {
+      // The supernode has more than one column
+      Index luptr = colIndexPtr()[fsupc];
+      Index lda = colIndexPtr()[fsupc+1] - luptr;
+
+      //Begin Gather
+      for (Index j = 0; j < nrhs; j++)
+      {
+        Index iptr = istart + nsupc;
+        for (Index i = 0; i < nrow; i++)
+        {
+          irow = rowIndex()[iptr];
+          work.topRows(nrow)(i,j)= X(irow,j); // Gather operation
+          iptr++;
+        }
+      }
+
+      // Matrix-vector product with transposed submatrix
+      Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > A( &(Lval[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
+      Map< Matrix<Scalar,Dynamic,Dest::ColsAtCompileTime, ColMajor>, 0, OuterStride<> > U (&(X(fsupc,0)), nsupc, nrhs, OuterStride<>(n) );
+      if(Conjugate)
+        U = U - A.adjoint() * work.topRows(nrow);
+      else
+        U = U - A.transpose() * work.topRows(nrow);
+
+      // Triangular solve (of transposed diagonal block)
+      new (&A) Map<const Matrix<Scalar,Dynamic,Dynamic, ColMajor>, 0, OuterStride<> > ( &(Lval[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+      if(Conjugate)
+        U = A.adjoint().template triangularView<UnitUpper>().solve(U);
+      else
+        U = A.transpose().template triangularView<UnitUpper>().solve(U);
+
+    }
+
+  }
+}
+
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSELU_MATRIX_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_Utils.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_Utils.h
new file mode 100644
index 00000000..9e3dab44
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_Utils.h
@@ -0,0 +1,80 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+#ifndef EIGEN_SPARSELU_UTILS_H
+#define EIGEN_SPARSELU_UTILS_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Count Nonzero elements in the factors
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu)
+{
+ nnzL = 0; 
+ nnzU = (glu.xusub)(n); 
+ Index nsuper = (glu.supno)(n); 
+ Index jlen; 
+ Index i, j, fsupc;
+ if (n <= 0 ) return; 
+ // For each supernode
+ for (i = 0; i <= nsuper; i++)
+ {
+   fsupc = glu.xsup(i); 
+   jlen = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
+   
+   for (j = fsupc; j < glu.xsup(i+1); j++)
+   {
+     nnzL += jlen; 
+     nnzU += j - fsupc + 1; 
+     jlen--; 
+   }
+ }
+}
+
+/**
+ * \brief Fix up the data storage lsub for L-subscripts. 
+ * 
+ * It removes the subscripts sets for structural pruning, 
+ * and applies permutation to the remaining subscripts
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu)
+{
+  Index fsupc, i, j, k, jstart; 
+  
+  StorageIndex nextl = 0; 
+  Index nsuper = (glu.supno)(n); 
+  
+  // For each supernode 
+  for (i = 0; i <= nsuper; i++)
+  {
+    fsupc = glu.xsup(i); 
+    jstart = glu.xlsub(fsupc); 
+    glu.xlsub(fsupc) = nextl; 
+    for (j = jstart; j < glu.xlsub(fsupc + 1); j++)
+    {
+      glu.lsub(nextl) = perm_r(glu.lsub(j)); // Now indexed into P*A
+      nextl++;
+    }
+    for (k = fsupc+1; k < glu.xsup(i+1); k++)
+      glu.xlsub(k) = nextl; // other columns in supernode i
+  }
+  
+  glu.xlsub(n) = nextl; 
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // EIGEN_SPARSELU_UTILS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_column_bmod.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_column_bmod.h
new file mode 100644
index 00000000..b57f0680
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_column_bmod.h
@@ -0,0 +1,181 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of xcolumn_bmod.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_COLUMN_BMOD_H
+#define SPARSELU_COLUMN_BMOD_H
+
+namespace Eigen {
+
+namespace internal {
+/**
+ * \brief Performs numeric block updates (sup-col) in topological order
+ * 
+ * \param jcol current column to update
+ * \param nseg Number of segments in the U part
+ * \param dense Store the full representation of the column
+ * \param tempv working array 
+ * \param segrep segment representative ...
+ * \param repfnz ??? First nonzero column in each row ???  ...
+ * \param fpanelc First column in the current panel
+ * \param glu Global LU data. 
+ * \return 0 - successful return 
+ *         > 0 - number of bytes allocated when run out of space
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::column_bmod(const Index jcol, const Index nseg, BlockScalarVector dense, ScalarVector& tempv,
+                                                     BlockIndexVector segrep, BlockIndexVector repfnz, Index fpanelc, GlobalLU_t& glu)
+{
+  Index  jsupno, k, ksub, krep, ksupno; 
+  Index lptr, nrow, isub, irow, nextlu, new_next, ufirst; 
+  Index fsupc, nsupc, nsupr, luptr, kfnz, no_zeros; 
+  /* krep = representative of current k-th supernode
+    * fsupc =  first supernodal column
+    * nsupc = number of columns in a supernode
+    * nsupr = number of rows in a supernode
+    * luptr = location of supernodal LU-block in storage
+    * kfnz = first nonz in the k-th supernodal segment
+    * no_zeros = no lf leading zeros in a supernodal U-segment
+    */
+  
+  jsupno = glu.supno(jcol);
+  // For each nonzero supernode segment of U[*,j] in topological order 
+  k = nseg - 1; 
+  Index d_fsupc; // distance between the first column of the current panel and the 
+               // first column of the current snode
+  Index fst_col; // First column within small LU update
+  Index segsize; 
+  for (ksub = 0; ksub < nseg; ksub++)
+  {
+    krep = segrep(k); k--; 
+    ksupno = glu.supno(krep); 
+    if (jsupno != ksupno )
+    {
+      // outside the rectangular supernode 
+      fsupc = glu.xsup(ksupno); 
+      fst_col = (std::max)(fsupc, fpanelc); 
+      
+      // Distance from the current supernode to the current panel; 
+      // d_fsupc = 0 if fsupc > fpanelc
+      d_fsupc = fst_col - fsupc; 
+      
+      luptr = glu.xlusup(fst_col) + d_fsupc; 
+      lptr = glu.xlsub(fsupc) + d_fsupc; 
+      
+      kfnz = repfnz(krep); 
+      kfnz = (std::max)(kfnz, fpanelc); 
+      
+      segsize = krep - kfnz + 1; 
+      nsupc = krep - fst_col + 1; 
+      nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
+      nrow = nsupr - d_fsupc - nsupc;
+      Index lda = glu.xlusup(fst_col+1) - glu.xlusup(fst_col);
+      
+      
+      // Perform a triangular solver and block update, 
+      // then scatter the result of sup-col update to dense
+      no_zeros = kfnz - fst_col; 
+      if(segsize==1)
+        LU_kernel_bmod<1>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+      else
+        LU_kernel_bmod<Dynamic>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+    } // end if jsupno 
+  } // end for each segment
+  
+  // Process the supernodal portion of  L\U[*,j]
+  nextlu = glu.xlusup(jcol); 
+  fsupc = glu.xsup(jsupno);
+  
+  // copy the SPA dense into L\U[*,j]
+  Index mem; 
+  new_next = nextlu + glu.xlsub(fsupc + 1) - glu.xlsub(fsupc); 
+  Index offset = internal::first_multiple<Index>(new_next, internal::packet_traits<Scalar>::size) - new_next;
+  if(offset)
+    new_next += offset;
+  while (new_next > glu.nzlumax )
+  {
+    mem = memXpand<ScalarVector>(glu.lusup, glu.nzlumax, nextlu, LUSUP, glu.num_expansions);  
+    if (mem) return mem; 
+  }
+  
+  for (isub = glu.xlsub(fsupc); isub < glu.xlsub(fsupc+1); isub++)
+  {
+    irow = glu.lsub(isub);
+    glu.lusup(nextlu) = dense(irow);
+    dense(irow) = Scalar(0.0); 
+    ++nextlu; 
+  }
+  
+  if(offset)
+  {
+    glu.lusup.segment(nextlu,offset).setZero();
+    nextlu += offset;
+  }
+  glu.xlusup(jcol + 1) = StorageIndex(nextlu);  // close L\U(*,jcol); 
+  
+  /* For more updates within the panel (also within the current supernode),
+   * should start from the first column of the panel, or the first column
+   * of the supernode, whichever is bigger. There are two cases:
+   *  1) fsupc < fpanelc, then fst_col <-- fpanelc
+   *  2) fsupc >= fpanelc, then fst_col <-- fsupc
+   */
+  fst_col = (std::max)(fsupc, fpanelc); 
+  
+  if (fst_col  < jcol)
+  {
+    // Distance between the current supernode and the current panel
+    // d_fsupc = 0 if fsupc >= fpanelc
+    d_fsupc = fst_col - fsupc; 
+    
+    lptr = glu.xlsub(fsupc) + d_fsupc; 
+    luptr = glu.xlusup(fst_col) + d_fsupc; 
+    nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); // leading dimension
+    nsupc = jcol - fst_col; // excluding jcol 
+    nrow = nsupr - d_fsupc - nsupc; 
+    
+    // points to the beginning of jcol in snode L\U(jsupno) 
+    ufirst = glu.xlusup(jcol) + d_fsupc; 
+    Index lda = glu.xlusup(jcol+1) - glu.xlusup(jcol);
+    MappedMatrixBlock A( &(glu.lusup.data()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
+    VectorBlock<ScalarVector> u(glu.lusup, ufirst, nsupc); 
+    u = A.template triangularView<UnitLower>().solve(u); 
+    
+    new (&A) MappedMatrixBlock ( &(glu.lusup.data()[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
+    VectorBlock<ScalarVector> l(glu.lusup, ufirst+nsupc, nrow); 
+    l.noalias() -= A * u;
+    
+  } // End if fst_col
+  return 0; 
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_COLUMN_BMOD_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_column_dfs.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_column_dfs.h
new file mode 100644
index 00000000..5a2c941b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_column_dfs.h
@@ -0,0 +1,179 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]column_dfs.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_COLUMN_DFS_H
+#define SPARSELU_COLUMN_DFS_H
+
+template <typename Scalar, typename StorageIndex> class SparseLUImpl;
+namespace Eigen {
+
+namespace internal {
+
+template<typename IndexVector, typename ScalarVector>
+struct column_dfs_traits : no_assignment_operator
+{
+  typedef typename ScalarVector::Scalar Scalar;
+  typedef typename IndexVector::Scalar StorageIndex;
+  column_dfs_traits(Index jcol, Index& jsuper, typename SparseLUImpl<Scalar, StorageIndex>::GlobalLU_t& glu, SparseLUImpl<Scalar, StorageIndex>& luImpl)
+   : m_jcol(jcol), m_jsuper_ref(jsuper), m_glu(glu), m_luImpl(luImpl)
+ {}
+  bool update_segrep(Index /*krep*/, Index /*jj*/)
+  {
+    return true;
+  }
+  void mem_expand(IndexVector& lsub, Index& nextl, Index chmark)
+  {
+    if (nextl >= m_glu.nzlmax)
+      m_luImpl.memXpand(lsub, m_glu.nzlmax, nextl, LSUB, m_glu.num_expansions); 
+    if (chmark != (m_jcol-1)) m_jsuper_ref = emptyIdxLU;
+  }
+  enum { ExpandMem = true };
+  
+  Index m_jcol;
+  Index& m_jsuper_ref;
+  typename SparseLUImpl<Scalar, StorageIndex>::GlobalLU_t& m_glu;
+  SparseLUImpl<Scalar, StorageIndex>& m_luImpl;
+};
+
+
+/**
+ * \brief Performs a symbolic factorization on column jcol and decide the supernode boundary
+ * 
+ * A supernode representative is the last column of a supernode.
+ * The nonzeros in U[*,j] are segments that end at supernodes representatives. 
+ * The routine returns a list of the supernodal representatives 
+ * in topological order of the dfs that generates them. 
+ * The location of the first nonzero in each supernodal segment 
+ * (supernodal entry location) is also returned. 
+ * 
+ * \param m number of rows in the matrix
+ * \param jcol Current column 
+ * \param perm_r Row permutation
+ * \param maxsuper  Maximum number of column allowed in a supernode
+ * \param [in,out] nseg Number of segments in current U[*,j] - new segments appended
+ * \param lsub_col defines the rhs vector to start the dfs
+ * \param [in,out] segrep Segment representatives - new segments appended 
+ * \param repfnz  First nonzero location in each row
+ * \param xprune 
+ * \param marker  marker[i] == jj, if i was visited during dfs of current column jj;
+ * \param parent
+ * \param xplore working array
+ * \param glu global LU data 
+ * \return 0 success
+ *         > 0 number of bytes allocated when run out of space
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::column_dfs(const Index m, const Index jcol, IndexVector& perm_r, Index maxsuper, Index& nseg,
+                                                    BlockIndexVector lsub_col, IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune,
+                                                    IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu)
+{
+  
+  Index jsuper = glu.supno(jcol); 
+  Index nextl = glu.xlsub(jcol); 
+  VectorBlock<IndexVector> marker2(marker, 2*m, m); 
+  
+  
+  column_dfs_traits<IndexVector, ScalarVector> traits(jcol, jsuper, glu, *this);
+  
+  // For each nonzero in A(*,jcol) do dfs 
+  for (Index k = 0; ((k < m) ? lsub_col[k] != emptyIdxLU : false) ; k++)
+  {
+    Index krow = lsub_col(k); 
+    lsub_col(k) = emptyIdxLU; 
+    Index kmark = marker2(krow); 
+    
+    // krow was visited before, go to the next nonz; 
+    if (kmark == jcol) continue;
+    
+    dfs_kernel(StorageIndex(jcol), perm_r, nseg, glu.lsub, segrep, repfnz, xprune, marker2, parent,
+                   xplore, glu, nextl, krow, traits);
+  } // for each nonzero ... 
+  
+  Index fsupc;
+  StorageIndex nsuper = glu.supno(jcol);
+  StorageIndex jcolp1 = StorageIndex(jcol) + 1;
+  Index jcolm1 = jcol - 1;
+  
+  // check to see if j belongs in the same supernode as j-1
+  if ( jcol == 0 )
+  { // Do nothing for column 0 
+    nsuper = glu.supno(0) = 0 ;
+  }
+  else 
+  {
+    fsupc = glu.xsup(nsuper); 
+    StorageIndex jptr = glu.xlsub(jcol); // Not yet compressed
+    StorageIndex jm1ptr = glu.xlsub(jcolm1); 
+    
+    // Use supernodes of type T2 : see SuperLU paper
+    if ( (nextl-jptr != jptr-jm1ptr-1) ) jsuper = emptyIdxLU;
+    
+    // Make sure the number of columns in a supernode doesn't
+    // exceed threshold
+    if ( (jcol - fsupc) >= maxsuper) jsuper = emptyIdxLU; 
+    
+    /* If jcol starts a new supernode, reclaim storage space in
+     * glu.lsub from previous supernode. Note we only store 
+     * the subscript set of the first and last columns of 
+     * a supernode. (first for num values, last for pruning)
+     */
+    if (jsuper == emptyIdxLU)
+    { // starts a new supernode 
+      if ( (fsupc < jcolm1-1) ) 
+      { // >= 3 columns in nsuper
+        StorageIndex ito = glu.xlsub(fsupc+1);
+        glu.xlsub(jcolm1) = ito; 
+        StorageIndex istop = ito + jptr - jm1ptr; 
+        xprune(jcolm1) = istop; // initialize xprune(jcol-1)
+        glu.xlsub(jcol) = istop; 
+        
+        for (StorageIndex ifrom = jm1ptr; ifrom < nextl; ++ifrom, ++ito)
+          glu.lsub(ito) = glu.lsub(ifrom); 
+        nextl = ito;  // = istop + length(jcol)
+      }
+      nsuper++; 
+      glu.supno(jcol) = nsuper; 
+    } // if a new supernode 
+  } // end else:  jcol > 0
+  
+  // Tidy up the pointers before exit
+  glu.xsup(nsuper+1) = jcolp1; 
+  glu.supno(jcolp1) = nsuper; 
+  xprune(jcol) = StorageIndex(nextl);  // Initialize upper bound for pruning
+  glu.xlsub(jcolp1) = StorageIndex(nextl); 
+  
+  return 0; 
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h
new file mode 100644
index 00000000..c32d8d8b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h
@@ -0,0 +1,107 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]copy_to_ucol.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_COPY_TO_UCOL_H
+#define SPARSELU_COPY_TO_UCOL_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Performs numeric block updates (sup-col) in topological order
+ * 
+ * \param jcol current column to update
+ * \param nseg Number of segments in the U part
+ * \param segrep segment representative ...
+ * \param repfnz First nonzero column in each row  ...
+ * \param perm_r Row permutation 
+ * \param dense Store the full representation of the column
+ * \param glu Global LU data. 
+ * \return 0 - successful return 
+ *         > 0 - number of bytes allocated when run out of space
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::copy_to_ucol(const Index jcol, const Index nseg, IndexVector& segrep,
+                                                      BlockIndexVector repfnz ,IndexVector& perm_r, BlockScalarVector dense, GlobalLU_t& glu)
+{  
+  Index ksub, krep, ksupno; 
+    
+  Index jsupno = glu.supno(jcol);
+  
+  // For each nonzero supernode segment of U[*,j] in topological order 
+  Index k = nseg - 1, i; 
+  StorageIndex nextu = glu.xusub(jcol); 
+  Index kfnz, isub, segsize; 
+  Index new_next,irow; 
+  Index fsupc, mem; 
+  for (ksub = 0; ksub < nseg; ksub++)
+  {
+    krep = segrep(k); k--; 
+    ksupno = glu.supno(krep); 
+    if (jsupno != ksupno ) // should go into ucol(); 
+    {
+      kfnz = repfnz(krep); 
+      if (kfnz != emptyIdxLU)
+      { // Nonzero U-segment 
+        fsupc = glu.xsup(ksupno); 
+        isub = glu.xlsub(fsupc) + kfnz - fsupc; 
+        segsize = krep - kfnz + 1; 
+        new_next = nextu + segsize; 
+        while (new_next > glu.nzumax) 
+        {
+          mem = memXpand<ScalarVector>(glu.ucol, glu.nzumax, nextu, UCOL, glu.num_expansions); 
+          if (mem) return mem; 
+          mem = memXpand<IndexVector>(glu.usub, glu.nzumax, nextu, USUB, glu.num_expansions); 
+          if (mem) return mem; 
+          
+        }
+        
+        for (i = 0; i < segsize; i++)
+        {
+          irow = glu.lsub(isub); 
+          glu.usub(nextu) = perm_r(irow); // Unlike the L part, the U part is stored in its final order
+          glu.ucol(nextu) = dense(irow); 
+          dense(irow) = Scalar(0.0); 
+          nextu++;
+          isub++;
+        }
+        
+      } // end nonzero U-segment 
+      
+    } // end if jsupno 
+    
+  } // end for each segment
+  glu.xusub(jcol + 1) = nextu; // close U(*,jcol)
+  return 0; 
+}
+
+} // namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_COPY_TO_UCOL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_gemm_kernel.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_gemm_kernel.h
new file mode 100644
index 00000000..e37c2fe0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_gemm_kernel.h
@@ -0,0 +1,280 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSELU_GEMM_KERNEL_H
+#define EIGEN_SPARSELU_GEMM_KERNEL_H
+
+namespace Eigen {
+
+namespace internal {
+
+
+/** \internal
+  * A general matrix-matrix product kernel optimized for the SparseLU factorization.
+  *  - A, B, and C must be column major
+  *  - lda and ldc must be multiples of the respective packet size
+  *  - C must have the same alignment as A
+  */
+template<typename Scalar>
+EIGEN_DONT_INLINE
+void sparselu_gemm(Index m, Index n, Index d, const Scalar* A, Index lda, const Scalar* B, Index ldb, Scalar* C, Index ldc)
+{
+  using namespace Eigen::internal;
+  
+  typedef typename packet_traits<Scalar>::type Packet;
+  enum {
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+    PacketSize = packet_traits<Scalar>::size,
+    PM = 8,                             // peeling in M
+    RN = 2,                             // register blocking
+    RK = NumberOfRegisters>=16 ? 4 : 2, // register blocking
+    BM = 4096/sizeof(Scalar),           // number of rows of A-C per chunk
+    SM = PM*PacketSize                  // step along M
+  };
+  Index d_end = (d/RK)*RK;    // number of columns of A (rows of B) suitable for full register blocking
+  Index n_end = (n/RN)*RN;    // number of columns of B-C suitable for processing RN columns at once
+  Index i0 = internal::first_default_aligned(A,m);
+  
+  eigen_internal_assert(((lda%PacketSize)==0) && ((ldc%PacketSize)==0) && (i0==internal::first_default_aligned(C,m)));
+  
+  // handle the non aligned rows of A and C without any optimization:
+  for(Index i=0; i<i0; ++i)
+  {
+    for(Index j=0; j<n; ++j)
+    {
+      Scalar c = C[i+j*ldc];
+      for(Index k=0; k<d; ++k)
+        c += B[k+j*ldb] * A[i+k*lda];
+      C[i+j*ldc] = c;
+    }
+  }
+  // process the remaining rows per chunk of BM rows
+  for(Index ib=i0; ib<m; ib+=BM)
+  {
+    Index actual_b = std::min<Index>(BM, m-ib);                 // actual number of rows
+    Index actual_b_end1 = (actual_b/SM)*SM;                   // actual number of rows suitable for peeling
+    Index actual_b_end2 = (actual_b/PacketSize)*PacketSize;   // actual number of rows suitable for vectorization
+    
+    // Let's process two columns of B-C at once
+    for(Index j=0; j<n_end; j+=RN)
+    {
+      const Scalar* Bc0 = B+(j+0)*ldb;
+      const Scalar* Bc1 = B+(j+1)*ldb;
+      
+      for(Index k=0; k<d_end; k+=RK)
+      {
+        
+        // load and expand a RN x RK block of B
+        Packet b00, b10, b20, b30, b01, b11, b21, b31;
+                  { b00 = pset1<Packet>(Bc0[0]); }
+                  { b10 = pset1<Packet>(Bc0[1]); }
+        if(RK==4) { b20 = pset1<Packet>(Bc0[2]); }
+        if(RK==4) { b30 = pset1<Packet>(Bc0[3]); }
+                  { b01 = pset1<Packet>(Bc1[0]); }
+                  { b11 = pset1<Packet>(Bc1[1]); }
+        if(RK==4) { b21 = pset1<Packet>(Bc1[2]); }
+        if(RK==4) { b31 = pset1<Packet>(Bc1[3]); }
+        
+        Packet a0, a1, a2, a3, c0, c1, t0, t1;
+        
+        const Scalar* A0 = A+ib+(k+0)*lda;
+        const Scalar* A1 = A+ib+(k+1)*lda;
+        const Scalar* A2 = A+ib+(k+2)*lda;
+        const Scalar* A3 = A+ib+(k+3)*lda;
+        
+        Scalar* C0 = C+ib+(j+0)*ldc;
+        Scalar* C1 = C+ib+(j+1)*ldc;
+        
+                  a0 = pload<Packet>(A0);
+                  a1 = pload<Packet>(A1);
+        if(RK==4)
+        {
+          a2 = pload<Packet>(A2);
+          a3 = pload<Packet>(A3);
+        }
+        else
+        {
+          // workaround "may be used uninitialized in this function" warning
+          a2 = a3 = a0;
+        }
+        
+#define KMADD(c, a, b, tmp) {tmp = b; tmp = pmul(a,tmp); c = padd(c,tmp);}
+#define WORK(I)  \
+                     c0 = pload<Packet>(C0+i+(I)*PacketSize);    \
+                     c1 = pload<Packet>(C1+i+(I)*PacketSize);    \
+                     KMADD(c0, a0, b00, t0)                      \
+                     KMADD(c1, a0, b01, t1)                      \
+                     a0 = pload<Packet>(A0+i+(I+1)*PacketSize);  \
+                     KMADD(c0, a1, b10, t0)                      \
+                     KMADD(c1, a1, b11, t1)                      \
+                     a1 = pload<Packet>(A1+i+(I+1)*PacketSize);  \
+          if(RK==4){ KMADD(c0, a2, b20, t0)                     }\
+          if(RK==4){ KMADD(c1, a2, b21, t1)                     }\
+          if(RK==4){ a2 = pload<Packet>(A2+i+(I+1)*PacketSize); }\
+          if(RK==4){ KMADD(c0, a3, b30, t0)                     }\
+          if(RK==4){ KMADD(c1, a3, b31, t1)                     }\
+          if(RK==4){ a3 = pload<Packet>(A3+i+(I+1)*PacketSize); }\
+                     pstore(C0+i+(I)*PacketSize, c0);            \
+                     pstore(C1+i+(I)*PacketSize, c1)
+        
+        // process rows of A' - C' with aggressive vectorization and peeling 
+        for(Index i=0; i<actual_b_end1; i+=PacketSize*8)
+        {
+          EIGEN_ASM_COMMENT("SPARSELU_GEMML_KERNEL1");
+                    prefetch((A0+i+(5)*PacketSize));
+                    prefetch((A1+i+(5)*PacketSize));
+          if(RK==4) prefetch((A2+i+(5)*PacketSize));
+          if(RK==4) prefetch((A3+i+(5)*PacketSize));
+
+          WORK(0);
+          WORK(1);
+          WORK(2);
+          WORK(3);
+          WORK(4);
+          WORK(5);
+          WORK(6);
+          WORK(7);
+        }
+        // process the remaining rows with vectorization only
+        for(Index i=actual_b_end1; i<actual_b_end2; i+=PacketSize)
+        {
+          WORK(0);
+        }
+#undef WORK
+        // process the remaining rows without vectorization
+        for(Index i=actual_b_end2; i<actual_b; ++i)
+        {
+          if(RK==4)
+          {
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1]+A2[i]*Bc0[2]+A3[i]*Bc0[3];
+            C1[i] += A0[i]*Bc1[0]+A1[i]*Bc1[1]+A2[i]*Bc1[2]+A3[i]*Bc1[3];
+          }
+          else
+          {
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1];
+            C1[i] += A0[i]*Bc1[0]+A1[i]*Bc1[1];
+          }
+        }
+        
+        Bc0 += RK;
+        Bc1 += RK;
+      } // peeled loop on k
+    } // peeled loop on the columns j
+    // process the last column (we now perform a matrix-vector product)
+    if((n-n_end)>0)
+    {
+      const Scalar* Bc0 = B+(n-1)*ldb;
+      
+      for(Index k=0; k<d_end; k+=RK)
+      {
+        
+        // load and expand a 1 x RK block of B
+        Packet b00, b10, b20, b30;
+                  b00 = pset1<Packet>(Bc0[0]);
+                  b10 = pset1<Packet>(Bc0[1]);
+        if(RK==4) b20 = pset1<Packet>(Bc0[2]);
+        if(RK==4) b30 = pset1<Packet>(Bc0[3]);
+        
+        Packet a0, a1, a2, a3, c0, t0/*, t1*/;
+        
+        const Scalar* A0 = A+ib+(k+0)*lda;
+        const Scalar* A1 = A+ib+(k+1)*lda;
+        const Scalar* A2 = A+ib+(k+2)*lda;
+        const Scalar* A3 = A+ib+(k+3)*lda;
+        
+        Scalar* C0 = C+ib+(n_end)*ldc;
+        
+                  a0 = pload<Packet>(A0);
+                  a1 = pload<Packet>(A1);
+        if(RK==4)
+        {
+          a2 = pload<Packet>(A2);
+          a3 = pload<Packet>(A3);
+        }
+        else
+        {
+          // workaround "may be used uninitialized in this function" warning
+          a2 = a3 = a0;
+        }
+        
+#define WORK(I) \
+                   c0 = pload<Packet>(C0+i+(I)*PacketSize);     \
+                   KMADD(c0, a0, b00, t0)                       \
+                   a0 = pload<Packet>(A0+i+(I+1)*PacketSize);   \
+                   KMADD(c0, a1, b10, t0)                       \
+                   a1 = pload<Packet>(A1+i+(I+1)*PacketSize);   \
+        if(RK==4){ KMADD(c0, a2, b20, t0)                      }\
+        if(RK==4){ a2 = pload<Packet>(A2+i+(I+1)*PacketSize);  }\
+        if(RK==4){ KMADD(c0, a3, b30, t0)                      }\
+        if(RK==4){ a3 = pload<Packet>(A3+i+(I+1)*PacketSize);  }\
+                   pstore(C0+i+(I)*PacketSize, c0);
+        
+        // aggressive vectorization and peeling
+        for(Index i=0; i<actual_b_end1; i+=PacketSize*8)
+        {
+          EIGEN_ASM_COMMENT("SPARSELU_GEMML_KERNEL2");
+          WORK(0);
+          WORK(1);
+          WORK(2);
+          WORK(3);
+          WORK(4);
+          WORK(5);
+          WORK(6);
+          WORK(7);
+        }
+        // vectorization only
+        for(Index i=actual_b_end1; i<actual_b_end2; i+=PacketSize)
+        {
+          WORK(0);
+        }
+        // remaining scalars
+        for(Index i=actual_b_end2; i<actual_b; ++i)
+        {
+          if(RK==4) 
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1]+A2[i]*Bc0[2]+A3[i]*Bc0[3];
+          else
+            C0[i] += A0[i]*Bc0[0]+A1[i]*Bc0[1];
+        }
+        
+        Bc0 += RK;
+#undef WORK
+      }
+    }
+    
+    // process the last columns of A, corresponding to the last rows of B
+    Index rd = d-d_end;
+    if(rd>0)
+    {
+      for(Index j=0; j<n; ++j)
+      {
+        enum {
+          Alignment = PacketSize>1 ? Aligned : 0
+        };
+        typedef Map<Matrix<Scalar,Dynamic,1>, Alignment > MapVector;
+        typedef Map<const Matrix<Scalar,Dynamic,1>, Alignment > ConstMapVector;
+        if(rd==1)       MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b);
+        
+        else if(rd==2)  MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b)
+                                                        + B[1+d_end+j*ldb] * ConstMapVector(A+(d_end+1)*lda+ib, actual_b);
+        
+        else            MapVector(C+j*ldc+ib,actual_b) += B[0+d_end+j*ldb] * ConstMapVector(A+(d_end+0)*lda+ib, actual_b)
+                                                        + B[1+d_end+j*ldb] * ConstMapVector(A+(d_end+1)*lda+ib, actual_b)
+                                                        + B[2+d_end+j*ldb] * ConstMapVector(A+(d_end+2)*lda+ib, actual_b);
+      }
+    }
+  
+  } // blocking on the rows of A and C
+}
+#undef KMADD
+
+} // namespace internal
+
+} // namespace Eigen
+
+#endif // EIGEN_SPARSELU_GEMM_KERNEL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h
new file mode 100644
index 00000000..6f75d500
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h
@@ -0,0 +1,126 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* This file is a modified version of heap_relax_snode.c file in SuperLU
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+
+#ifndef SPARSELU_HEAP_RELAX_SNODE_H
+#define SPARSELU_HEAP_RELAX_SNODE_H
+
+namespace Eigen {
+namespace internal {
+
+/** 
+ * \brief Identify the initial relaxed supernodes
+ * 
+ * This routine applied to a symmetric elimination tree. 
+ * It assumes that the matrix has been reordered according to the postorder of the etree
+ * \param n The number of columns
+ * \param et elimination tree 
+ * \param relax_columns Maximum number of columns allowed in a relaxed snode 
+ * \param descendants Number of descendants of each node in the etree
+ * \param relax_end last column in a supernode
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::heap_relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end)
+{
+  
+  // The etree may not be postordered, but its heap ordered  
+  IndexVector post;
+  internal::treePostorder(StorageIndex(n), et, post); // Post order etree
+  IndexVector inv_post(n+1); 
+  for (StorageIndex i = 0; i < n+1; ++i) inv_post(post(i)) = i; // inv_post = post.inverse()???
+  
+  // Renumber etree in postorder 
+  IndexVector iwork(n);
+  IndexVector et_save(n+1);
+  for (Index i = 0; i < n; ++i)
+  {
+    iwork(post(i)) = post(et(i));
+  }
+  et_save = et; // Save the original etree
+  et = iwork; 
+  
+  // compute the number of descendants of each node in the etree
+  relax_end.setConstant(emptyIdxLU);
+  Index j, parent; 
+  descendants.setZero();
+  for (j = 0; j < n; j++) 
+  {
+    parent = et(j);
+    if (parent != n) // not the dummy root
+      descendants(parent) += descendants(j) + 1;
+  }
+  // Identify the relaxed supernodes by postorder traversal of the etree
+  Index snode_start; // beginning of a snode 
+  StorageIndex k;
+  Index nsuper_et_post = 0; // Number of relaxed snodes in postordered etree 
+  Index nsuper_et = 0; // Number of relaxed snodes in the original etree 
+  StorageIndex l; 
+  for (j = 0; j < n; )
+  {
+    parent = et(j);
+    snode_start = j; 
+    while ( parent != n && descendants(parent) < relax_columns ) 
+    {
+      j = parent; 
+      parent = et(j);
+    }
+    // Found a supernode in postordered etree, j is the last column 
+    ++nsuper_et_post;
+    k = StorageIndex(n);
+    for (Index i = snode_start; i <= j; ++i)
+      k = (std::min)(k, inv_post(i));
+    l = inv_post(j);
+    if ( (l - k) == (j - snode_start) )  // Same number of columns in the snode
+    {
+      // This is also a supernode in the original etree
+      relax_end(k) = l; // Record last column 
+      ++nsuper_et; 
+    }
+    else 
+    {
+      for (Index i = snode_start; i <= j; ++i) 
+      {
+        l = inv_post(i);
+        if (descendants(i) == 0) 
+        {
+          relax_end(l) = l;
+          ++nsuper_et;
+        }
+      }
+    }
+    j++;
+    // Search for a new leaf
+    while (descendants(j) != 0 && j < n) j++;
+  } // End postorder traversal of the etree
+  
+  // Recover the original etree
+  et = et_save; 
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // SPARSELU_HEAP_RELAX_SNODE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_kernel_bmod.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_kernel_bmod.h
new file mode 100644
index 00000000..8c1b3e8b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_kernel_bmod.h
@@ -0,0 +1,130 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef SPARSELU_KERNEL_BMOD_H
+#define SPARSELU_KERNEL_BMOD_H
+
+namespace Eigen {
+namespace internal {
+  
+template <int SegSizeAtCompileTime> struct LU_kernel_bmod
+{
+  /** \internal
+    * \brief Performs numeric block updates from a given supernode to a single column
+    *
+    * \param segsize Size of the segment (and blocks ) to use for updates
+    * \param[in,out] dense Packed values of the original matrix
+    * \param tempv temporary vector to use for updates
+    * \param lusup array containing the supernodes
+    * \param lda Leading dimension in the supernode
+    * \param nrow Number of rows in the rectangular part of the supernode
+    * \param lsub compressed row subscripts of supernodes
+    * \param lptr pointer to the first column of the current supernode in lsub
+    * \param no_zeros Number of nonzeros elements before the diagonal part of the supernode
+    */
+  template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+  static EIGEN_DONT_INLINE void run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv, ScalarVector& lusup, Index& luptr, const Index lda,
+                                    const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros);
+};
+
+template <int SegSizeAtCompileTime>
+template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+EIGEN_DONT_INLINE void LU_kernel_bmod<SegSizeAtCompileTime>::run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv, ScalarVector& lusup, Index& luptr, const Index lda,
+                                                                  const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros)
+{
+  typedef typename ScalarVector::Scalar Scalar;
+  // First, copy U[*,j] segment from dense(*) to tempv(*)
+  // The result of triangular solve is in tempv[*]; 
+    // The result of matric-vector update is in dense[*]
+  Index isub = lptr + no_zeros; 
+  Index i;
+  Index irow;
+  for (i = 0; i < ((SegSizeAtCompileTime==Dynamic)?segsize:SegSizeAtCompileTime); i++)
+  {
+    irow = lsub(isub); 
+    tempv(i) = dense(irow); 
+    ++isub; 
+  }
+  // Dense triangular solve -- start effective triangle
+  luptr += lda * no_zeros + no_zeros; 
+  // Form Eigen matrix and vector 
+  Map<Matrix<Scalar,SegSizeAtCompileTime,SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > A( &(lusup.data()[luptr]), segsize, segsize, OuterStride<>(lda) );
+  Map<Matrix<Scalar,SegSizeAtCompileTime,1> > u(tempv.data(), segsize);
+  
+  u = A.template triangularView<UnitLower>().solve(u); 
+  
+  // Dense matrix-vector product y <-- B*x 
+  luptr += segsize;
+  const Index PacketSize = internal::packet_traits<Scalar>::size;
+  Index ldl = internal::first_multiple(nrow, PacketSize);
+  Map<Matrix<Scalar,Dynamic,SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > B( &(lusup.data()[luptr]), nrow, segsize, OuterStride<>(lda) );
+  Index aligned_offset = internal::first_default_aligned(tempv.data()+segsize, PacketSize);
+  Index aligned_with_B_offset = (PacketSize-internal::first_default_aligned(B.data(), PacketSize))%PacketSize;
+  Map<Matrix<Scalar,Dynamic,1>, 0, OuterStride<> > l(tempv.data()+segsize+aligned_offset+aligned_with_B_offset, nrow, OuterStride<>(ldl) );
+  
+  l.setZero();
+  internal::sparselu_gemm<Scalar>(l.rows(), l.cols(), B.cols(), B.data(), B.outerStride(), u.data(), u.outerStride(), l.data(), l.outerStride());
+  
+  // Scatter tempv[] into SPA dense[] as a temporary storage 
+  isub = lptr + no_zeros;
+  for (i = 0; i < ((SegSizeAtCompileTime==Dynamic)?segsize:SegSizeAtCompileTime); i++)
+  {
+    irow = lsub(isub++); 
+    dense(irow) = tempv(i);
+  }
+  
+  // Scatter l into SPA dense[]
+  for (i = 0; i < nrow; i++)
+  {
+    irow = lsub(isub++); 
+    dense(irow) -= l(i);
+  } 
+}
+
+template <> struct LU_kernel_bmod<1>
+{
+  template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+  static EIGEN_DONT_INLINE void run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr,
+                                    const Index lda, const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros);
+};
+
+
+template <typename BlockScalarVector, typename ScalarVector, typename IndexVector>
+EIGEN_DONT_INLINE void LU_kernel_bmod<1>::run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr,
+                                              const Index lda, const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros)
+{
+  typedef typename ScalarVector::Scalar Scalar;
+  typedef typename IndexVector::Scalar StorageIndex;
+  Scalar f = dense(lsub(lptr + no_zeros));
+  luptr += lda * no_zeros + no_zeros + 1;
+  const Scalar* a(lusup.data() + luptr);
+  const StorageIndex*  irow(lsub.data()+lptr + no_zeros + 1);
+  Index i = 0;
+  for (; i+1 < nrow; i+=2)
+  {
+    Index i0 = *(irow++);
+    Index i1 = *(irow++);
+    Scalar a0 = *(a++);
+    Scalar a1 = *(a++);
+    Scalar d0 = dense.coeff(i0);
+    Scalar d1 = dense.coeff(i1);
+    d0 -= f*a0;
+    d1 -= f*a1;
+    dense.coeffRef(i0) = d0;
+    dense.coeffRef(i1) = d1;
+  }
+  if(i<nrow)
+    dense.coeffRef(*(irow++)) -= f * *(a++);
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif // SPARSELU_KERNEL_BMOD_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_panel_bmod.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_panel_bmod.h
new file mode 100644
index 00000000..f052001c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_panel_bmod.h
@@ -0,0 +1,223 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]panel_bmod.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PANEL_BMOD_H
+#define SPARSELU_PANEL_BMOD_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Performs numeric block updates (sup-panel) in topological order.
+ * 
+ * Before entering this routine, the original nonzeros in the panel
+ * were already copied into the spa[m,w]
+ * 
+ * \param m number of rows in the matrix
+ * \param w Panel size
+ * \param jcol Starting  column of the panel
+ * \param nseg Number of segments in the U part
+ * \param dense Store the full representation of the panel 
+ * \param tempv working array 
+ * \param segrep segment representative... first row in the segment
+ * \param repfnz First nonzero rows
+ * \param glu Global LU data. 
+ * 
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::panel_bmod(const Index m, const Index w, const Index jcol, 
+                                            const Index nseg, ScalarVector& dense, ScalarVector& tempv,
+                                            IndexVector& segrep, IndexVector& repfnz, GlobalLU_t& glu)
+{
+  
+  Index ksub,jj,nextl_col; 
+  Index fsupc, nsupc, nsupr, nrow; 
+  Index krep, kfnz; 
+  Index lptr; // points to the row subscripts of a supernode 
+  Index luptr; // ...
+  Index segsize,no_zeros ; 
+  // For each nonz supernode segment of U[*,j] in topological order
+  Index k = nseg - 1; 
+  const Index PacketSize = internal::packet_traits<Scalar>::size;
+  
+  for (ksub = 0; ksub < nseg; ksub++)
+  { // For each updating supernode
+    /* krep = representative of current k-th supernode
+     * fsupc =  first supernodal column
+     * nsupc = number of columns in a supernode
+     * nsupr = number of rows in a supernode
+     */
+    krep = segrep(k); k--; 
+    fsupc = glu.xsup(glu.supno(krep)); 
+    nsupc = krep - fsupc + 1; 
+    nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
+    nrow = nsupr - nsupc; 
+    lptr = glu.xlsub(fsupc); 
+    
+    // loop over the panel columns to detect the actual number of columns and rows
+    Index u_rows = 0;
+    Index u_cols = 0;
+    for (jj = jcol; jj < jcol + w; jj++)
+    {
+      nextl_col = (jj-jcol) * m; 
+      VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+      
+      kfnz = repfnz_col(krep); 
+      if ( kfnz == emptyIdxLU ) 
+        continue; // skip any zero segment
+      
+      segsize = krep - kfnz + 1;
+      u_cols++;
+      u_rows = (std::max)(segsize,u_rows);
+    }
+    
+    if(nsupc >= 2)
+    { 
+      Index ldu = internal::first_multiple<Index>(u_rows, PacketSize);
+      Map<ScalarMatrix, Aligned,  OuterStride<> > U(tempv.data(), u_rows, u_cols, OuterStride<>(ldu));
+      
+      // gather U
+      Index u_col = 0;
+      for (jj = jcol; jj < jcol + w; jj++)
+      {
+        nextl_col = (jj-jcol) * m; 
+        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
+        
+        kfnz = repfnz_col(krep); 
+        if ( kfnz == emptyIdxLU ) 
+          continue; // skip any zero segment
+        
+        segsize = krep - kfnz + 1;
+        luptr = glu.xlusup(fsupc);    
+        no_zeros = kfnz - fsupc; 
+        
+        Index isub = lptr + no_zeros;
+        Index off = u_rows-segsize;
+        for (Index i = 0; i < off; i++) U(i,u_col) = 0;
+        for (Index i = 0; i < segsize; i++)
+        {
+          Index irow = glu.lsub(isub); 
+          U(i+off,u_col) = dense_col(irow); 
+          ++isub; 
+        }
+        u_col++;
+      }
+      // solve U = A^-1 U
+      luptr = glu.xlusup(fsupc);
+      Index lda = glu.xlusup(fsupc+1) - glu.xlusup(fsupc);
+      no_zeros = (krep - u_rows + 1) - fsupc;
+      luptr += lda * no_zeros + no_zeros;
+      MappedMatrixBlock A(glu.lusup.data()+luptr, u_rows, u_rows, OuterStride<>(lda) );
+      U = A.template triangularView<UnitLower>().solve(U);
+      
+      // update
+      luptr += u_rows;
+      MappedMatrixBlock B(glu.lusup.data()+luptr, nrow, u_rows, OuterStride<>(lda) );
+      eigen_assert(tempv.size()>w*ldu + nrow*w + 1);
+      
+      Index ldl = internal::first_multiple<Index>(nrow, PacketSize);
+      Index offset = (PacketSize-internal::first_default_aligned(B.data(), PacketSize)) % PacketSize;
+      MappedMatrixBlock L(tempv.data()+w*ldu+offset, nrow, u_cols, OuterStride<>(ldl));
+      
+      L.setZero();
+      internal::sparselu_gemm<Scalar>(L.rows(), L.cols(), B.cols(), B.data(), B.outerStride(), U.data(), U.outerStride(), L.data(), L.outerStride());
+      
+      // scatter U and L
+      u_col = 0;
+      for (jj = jcol; jj < jcol + w; jj++)
+      {
+        nextl_col = (jj-jcol) * m; 
+        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
+        
+        kfnz = repfnz_col(krep); 
+        if ( kfnz == emptyIdxLU ) 
+          continue; // skip any zero segment
+        
+        segsize = krep - kfnz + 1;
+        no_zeros = kfnz - fsupc; 
+        Index isub = lptr + no_zeros;
+        
+        Index off = u_rows-segsize;
+        for (Index i = 0; i < segsize; i++)
+        {
+          Index irow = glu.lsub(isub++); 
+          dense_col(irow) = U.coeff(i+off,u_col);
+          U.coeffRef(i+off,u_col) = 0;
+        }
+        
+        // Scatter l into SPA dense[]
+        for (Index i = 0; i < nrow; i++)
+        {
+          Index irow = glu.lsub(isub++); 
+          dense_col(irow) -= L.coeff(i,u_col);
+          L.coeffRef(i,u_col) = 0;
+        }
+        u_col++;
+      }
+    }
+    else // level 2 only
+    {
+      // Sequence through each column in the panel
+      for (jj = jcol; jj < jcol + w; jj++)
+      {
+        nextl_col = (jj-jcol) * m; 
+        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
+        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
+        
+        kfnz = repfnz_col(krep); 
+        if ( kfnz == emptyIdxLU ) 
+          continue; // skip any zero segment
+        
+        segsize = krep - kfnz + 1;
+        luptr = glu.xlusup(fsupc);
+        
+        Index lda = glu.xlusup(fsupc+1)-glu.xlusup(fsupc);// nsupr
+        
+        // Perform a trianglar solve and block update, 
+        // then scatter the result of sup-col update to dense[]
+        no_zeros = kfnz - fsupc; 
+              if(segsize==1)  LU_kernel_bmod<1>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+        else  if(segsize==2)  LU_kernel_bmod<2>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+        else  if(segsize==3)  LU_kernel_bmod<3>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
+        else                  LU_kernel_bmod<Dynamic>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros); 
+      } // End for each column in the panel 
+    }
+    
+  } // End for each updating supernode
+} // end panel bmod
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // SPARSELU_PANEL_BMOD_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_panel_dfs.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_panel_dfs.h
new file mode 100644
index 00000000..155df733
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_panel_dfs.h
@@ -0,0 +1,258 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]panel_dfs.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PANEL_DFS_H
+#define SPARSELU_PANEL_DFS_H
+
+namespace Eigen {
+
+namespace internal {
+  
+template<typename IndexVector>
+struct panel_dfs_traits
+{
+  typedef typename IndexVector::Scalar StorageIndex;
+  panel_dfs_traits(Index jcol, StorageIndex* marker)
+    : m_jcol(jcol), m_marker(marker)
+  {}
+  bool update_segrep(Index krep, StorageIndex jj)
+  {
+    if(m_marker[krep]<m_jcol)
+    {
+      m_marker[krep] = jj; 
+      return true;
+    }
+    return false;
+  }
+  void mem_expand(IndexVector& /*glu.lsub*/, Index /*nextl*/, Index /*chmark*/) {}
+  enum { ExpandMem = false };
+  Index m_jcol;
+  StorageIndex* m_marker;
+};
+
+
+template <typename Scalar, typename StorageIndex>
+template <typename Traits>
+void SparseLUImpl<Scalar,StorageIndex>::dfs_kernel(const StorageIndex jj, IndexVector& perm_r,
+                   Index& nseg, IndexVector& panel_lsub, IndexVector& segrep,
+                   Ref<IndexVector> repfnz_col, IndexVector& xprune, Ref<IndexVector> marker, IndexVector& parent,
+                   IndexVector& xplore, GlobalLU_t& glu,
+                   Index& nextl_col, Index krow, Traits& traits
+                  )
+{
+  
+  StorageIndex kmark = marker(krow);
+      
+  // For each unmarked krow of jj
+  marker(krow) = jj; 
+  StorageIndex kperm = perm_r(krow); 
+  if (kperm == emptyIdxLU ) {
+    // krow is in L : place it in structure of L(*, jj)
+    panel_lsub(nextl_col++) = StorageIndex(krow);  // krow is indexed into A
+    
+    traits.mem_expand(panel_lsub, nextl_col, kmark);
+  }
+  else 
+  {
+    // krow is in U : if its supernode-representative krep
+    // has been explored, update repfnz(*)
+    // krep = supernode representative of the current row
+    StorageIndex krep = glu.xsup(glu.supno(kperm)+1) - 1; 
+    // First nonzero element in the current column:
+    StorageIndex myfnz = repfnz_col(krep); 
+    
+    if (myfnz != emptyIdxLU )
+    {
+      // Representative visited before
+      if (myfnz > kperm ) repfnz_col(krep) = kperm; 
+      
+    }
+    else 
+    {
+      // Otherwise, perform dfs starting at krep
+      StorageIndex oldrep = emptyIdxLU; 
+      parent(krep) = oldrep; 
+      repfnz_col(krep) = kperm; 
+      StorageIndex xdfs =  glu.xlsub(krep); 
+      Index maxdfs = xprune(krep); 
+      
+      StorageIndex kpar;
+      do 
+      {
+        // For each unmarked kchild of krep
+        while (xdfs < maxdfs) 
+        {
+          StorageIndex kchild = glu.lsub(xdfs); 
+          xdfs++; 
+          StorageIndex chmark = marker(kchild); 
+          
+          if (chmark != jj ) 
+          {
+            marker(kchild) = jj; 
+            StorageIndex chperm = perm_r(kchild); 
+            
+            if (chperm == emptyIdxLU) 
+            {
+              // case kchild is in L: place it in L(*, j)
+              panel_lsub(nextl_col++) = kchild;
+              traits.mem_expand(panel_lsub, nextl_col, chmark);
+            }
+            else
+            {
+              // case kchild is in U :
+              // chrep = its supernode-rep. If its rep has been explored, 
+              // update its repfnz(*)
+              StorageIndex chrep = glu.xsup(glu.supno(chperm)+1) - 1; 
+              myfnz = repfnz_col(chrep); 
+              
+              if (myfnz != emptyIdxLU) 
+              { // Visited before 
+                if (myfnz > chperm) 
+                  repfnz_col(chrep) = chperm; 
+              }
+              else 
+              { // Cont. dfs at snode-rep of kchild
+                xplore(krep) = xdfs; 
+                oldrep = krep; 
+                krep = chrep; // Go deeper down G(L)
+                parent(krep) = oldrep; 
+                repfnz_col(krep) = chperm; 
+                xdfs = glu.xlsub(krep); 
+                maxdfs = xprune(krep); 
+                
+              } // end if myfnz != -1
+            } // end if chperm == -1 
+                
+          } // end if chmark !=jj
+        } // end while xdfs < maxdfs
+        
+        // krow has no more unexplored nbrs :
+        //    Place snode-rep krep in postorder DFS, if this 
+        //    segment is seen for the first time. (Note that 
+        //    "repfnz(krep)" may change later.)
+        //    Baktrack dfs to its parent
+        if(traits.update_segrep(krep,jj))
+        //if (marker1(krep) < jcol )
+        {
+          segrep(nseg) = krep; 
+          ++nseg; 
+          //marker1(krep) = jj; 
+        }
+        
+        kpar = parent(krep); // Pop recursion, mimic recursion 
+        if (kpar == emptyIdxLU) 
+          break; // dfs done 
+        krep = kpar; 
+        xdfs = xplore(krep); 
+        maxdfs = xprune(krep); 
+
+      } while (kpar != emptyIdxLU); // Do until empty stack 
+      
+    } // end if (myfnz = -1)
+
+  } // end if (kperm == -1)   
+}
+
+/**
+ * \brief Performs a symbolic factorization on a panel of columns [jcol, jcol+w)
+ * 
+ * A supernode representative is the last column of a supernode.
+ * The nonzeros in U[*,j] are segments that end at supernodes representatives
+ * 
+ * The routine returns a list of the supernodal representatives 
+ * in topological order of the dfs that generates them. This list is 
+ * a superset of the topological order of each individual column within 
+ * the panel.
+ * The location of the first nonzero in each supernodal segment 
+ * (supernodal entry location) is also returned. Each column has 
+ * a separate list for this purpose. 
+ * 
+ * Two markers arrays are used for dfs :
+ *    marker[i] == jj, if i was visited during dfs of current column jj;
+ *    marker1[i] >= jcol, if i was visited by earlier columns in this panel; 
+ * 
+ * \param[in] m number of rows in the matrix
+ * \param[in] w Panel size
+ * \param[in] jcol Starting  column of the panel
+ * \param[in] A Input matrix in column-major storage
+ * \param[in] perm_r Row permutation
+ * \param[out] nseg Number of U segments
+ * \param[out] dense Accumulate the column vectors of the panel
+ * \param[out] panel_lsub Subscripts of the row in the panel 
+ * \param[out] segrep Segment representative i.e first nonzero row of each segment
+ * \param[out] repfnz First nonzero location in each row
+ * \param[out] xprune The pruned elimination tree
+ * \param[out] marker work vector
+ * \param  parent The elimination tree
+ * \param xplore work vector
+ * \param glu The global data structure
+ * 
+ */
+
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::panel_dfs(const Index m, const Index w, const Index jcol, MatrixType& A, IndexVector& perm_r, Index& nseg, ScalarVector& dense, IndexVector& panel_lsub, IndexVector& segrep, IndexVector& repfnz, IndexVector& xprune, IndexVector& marker, IndexVector& parent, IndexVector& xplore, GlobalLU_t& glu)
+{
+  Index nextl_col; // Next available position in panel_lsub[*,jj] 
+  
+  // Initialize pointers 
+  VectorBlock<IndexVector> marker1(marker, m, m); 
+  nseg = 0; 
+  
+  panel_dfs_traits<IndexVector> traits(jcol, marker1.data());
+  
+  // For each column in the panel 
+  for (StorageIndex jj = StorageIndex(jcol); jj < jcol + w; jj++) 
+  {
+    nextl_col = (jj - jcol) * m; 
+    
+    VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero location in each row
+    VectorBlock<ScalarVector> dense_col(dense,nextl_col, m); // Accumulate a column vector here
+    
+    
+    // For each nnz in A[*, jj] do depth first search
+    for (typename MatrixType::InnerIterator it(A, jj); it; ++it)
+    {
+      Index krow = it.row(); 
+      dense_col(krow) = it.value();
+      
+      StorageIndex kmark = marker(krow); 
+      if (kmark == jj) 
+        continue; // krow visited before, go to the next nonzero
+      
+      dfs_kernel(jj, perm_r, nseg, panel_lsub, segrep, repfnz_col, xprune, marker, parent,
+                   xplore, glu, nextl_col, krow, traits);
+    }// end for nonzeros in column jj
+    
+  } // end for column jj
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_PANEL_DFS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_pivotL.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_pivotL.h
new file mode 100644
index 00000000..a86dac93
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_pivotL.h
@@ -0,0 +1,137 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of xpivotL.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PIVOTL_H
+#define SPARSELU_PIVOTL_H
+
+namespace Eigen {
+namespace internal {
+  
+/**
+ * \brief Performs the numerical pivotin on the current column of L, and the CDIV operation.
+ * 
+ * Pivot policy :
+ * (1) Compute thresh = u * max_(i>=j) abs(A_ij);
+ * (2) IF user specifies pivot row k and abs(A_kj) >= thresh THEN
+ *           pivot row = k;
+ *       ELSE IF abs(A_jj) >= thresh THEN
+ *           pivot row = j;
+ *       ELSE
+ *           pivot row = m;
+ * 
+ *   Note: If you absolutely want to use a given pivot order, then set u=0.0.
+ * 
+ * \param jcol The current column of L
+ * \param diagpivotthresh diagonal pivoting threshold
+ * \param[in,out] perm_r Row permutation (threshold pivoting)
+ * \param[in] iperm_c column permutation - used to finf diagonal of Pc*A*Pc'
+ * \param[out] pivrow  The pivot row
+ * \param glu Global LU data
+ * \return 0 if success, i > 0 if U(i,i) is exactly zero 
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+Index SparseLUImpl<Scalar,StorageIndex>::pivotL(const Index jcol, const RealScalar& diagpivotthresh, IndexVector& perm_r, IndexVector& iperm_c, Index& pivrow, GlobalLU_t& glu)
+{
+  
+  Index fsupc = (glu.xsup)((glu.supno)(jcol)); // First column in the supernode containing the column jcol
+  Index nsupc = jcol - fsupc; // Number of columns in the supernode portion, excluding jcol; nsupc >=0
+  Index lptr = glu.xlsub(fsupc); // pointer to the starting location of the row subscripts for this supernode portion
+  Index nsupr = glu.xlsub(fsupc+1) - lptr; // Number of rows in the supernode
+  Index lda = glu.xlusup(fsupc+1) - glu.xlusup(fsupc); // leading dimension
+  Scalar* lu_sup_ptr = &(glu.lusup.data()[glu.xlusup(fsupc)]); // Start of the current supernode
+  Scalar* lu_col_ptr = &(glu.lusup.data()[glu.xlusup(jcol)]); // Start of jcol in the supernode
+  StorageIndex* lsub_ptr = &(glu.lsub.data()[lptr]); // Start of row indices of the supernode
+  
+  // Determine the largest abs numerical value for partial pivoting 
+  Index diagind = iperm_c(jcol); // diagonal index 
+  RealScalar pivmax(-1.0);
+  Index pivptr = nsupc; 
+  Index diag = emptyIdxLU; 
+  RealScalar rtemp;
+  Index isub, icol, itemp, k; 
+  for (isub = nsupc; isub < nsupr; ++isub) {
+    using std::abs;
+    rtemp = abs(lu_col_ptr[isub]);
+    if (rtemp > pivmax) {
+      pivmax = rtemp; 
+      pivptr = isub;
+    } 
+    if (lsub_ptr[isub] == diagind) diag = isub;
+  }
+  
+  // Test for singularity
+  if ( pivmax <= RealScalar(0.0) ) {
+    // if pivmax == -1, the column is structurally empty, otherwise it is only numerically zero
+    pivrow = pivmax < RealScalar(0.0) ? diagind : lsub_ptr[pivptr];
+    perm_r(pivrow) = StorageIndex(jcol);
+    return (jcol+1);
+  }
+  
+  RealScalar thresh = diagpivotthresh * pivmax; 
+  
+  // Choose appropriate pivotal element 
+  
+  {
+    // Test if the diagonal element can be used as a pivot (given the threshold value)
+    if (diag >= 0 ) 
+    {
+      // Diagonal element exists
+      using std::abs;
+      rtemp = abs(lu_col_ptr[diag]);
+      if (rtemp != RealScalar(0.0) && rtemp >= thresh) pivptr = diag;
+    }
+    pivrow = lsub_ptr[pivptr];
+  }
+  
+  // Record pivot row
+  perm_r(pivrow) = StorageIndex(jcol);
+  // Interchange row subscripts
+  if (pivptr != nsupc )
+  {
+    std::swap( lsub_ptr[pivptr], lsub_ptr[nsupc] );
+    // Interchange numerical values as well, for the two rows in the whole snode
+    // such that L is indexed the same way as A
+    for (icol = 0; icol <= nsupc; icol++)
+    {
+      itemp = pivptr + icol * lda; 
+      std::swap(lu_sup_ptr[itemp], lu_sup_ptr[nsupc + icol * lda]);
+    }
+  }
+  // cdiv operations
+  Scalar temp = Scalar(1.0) / lu_col_ptr[nsupc];
+  for (k = nsupc+1; k < nsupr; k++)
+    lu_col_ptr[k] *= temp; 
+  return 0;
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_PIVOTL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_pruneL.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_pruneL.h
new file mode 100644
index 00000000..ad32fed5
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_pruneL.h
@@ -0,0 +1,136 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* 
+ 
+ * NOTE: This file is the modified version of [s,d,c,z]pruneL.c file in SuperLU 
+ 
+ * -- SuperLU routine (version 2.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * November 15, 1997
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+#ifndef SPARSELU_PRUNEL_H
+#define SPARSELU_PRUNEL_H
+
+namespace Eigen {
+namespace internal {
+
+/**
+ * \brief Prunes the L-structure.
+ *
+ * It prunes the L-structure  of supernodes whose L-structure contains the current pivot row "pivrow"
+ * 
+ * 
+ * \param jcol The current column of L
+ * \param[in] perm_r Row permutation
+ * \param[out] pivrow  The pivot row
+ * \param nseg Number of segments
+ * \param segrep 
+ * \param repfnz
+ * \param[out] xprune 
+ * \param glu Global LU data
+ * 
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::pruneL(const Index jcol, const IndexVector& perm_r, const Index pivrow, const Index nseg,
+                                               const IndexVector& segrep, BlockIndexVector repfnz, IndexVector& xprune, GlobalLU_t& glu)
+{
+  // For each supernode-rep irep in U(*,j]
+  Index jsupno = glu.supno(jcol); 
+  Index i,irep,irep1; 
+  bool movnum, do_prune = false; 
+  Index kmin = 0, kmax = 0, minloc, maxloc,krow; 
+  for (i = 0; i < nseg; i++)
+  {
+    irep = segrep(i); 
+    irep1 = irep + 1; 
+    do_prune = false; 
+    
+    // Don't prune with a zero U-segment 
+    if (repfnz(irep) == emptyIdxLU) continue; 
+    
+    // If a snode overlaps with the next panel, then the U-segment
+    // is fragmented into two parts -- irep and irep1. We should let 
+    // pruning occur at the rep-column in irep1s snode. 
+    if (glu.supno(irep) == glu.supno(irep1) ) continue; // don't prune 
+    
+    // If it has not been pruned & it has a nonz in row L(pivrow,i)
+    if (glu.supno(irep) != jsupno )
+    {
+      if ( xprune (irep) >= glu.xlsub(irep1) )
+      {
+        kmin = glu.xlsub(irep);
+        kmax = glu.xlsub(irep1) - 1; 
+        for (krow = kmin; krow <= kmax; krow++)
+        {
+          if (glu.lsub(krow) == pivrow) 
+          {
+            do_prune = true; 
+            break; 
+          }
+        }
+      }
+      
+      if (do_prune) 
+      {
+        // do a quicksort-type partition
+        // movnum=true means that the num values have to be exchanged
+        movnum = false; 
+        if (irep == glu.xsup(glu.supno(irep)) ) // Snode of size 1 
+          movnum = true; 
+        
+        while (kmin <= kmax)
+        {
+          if (perm_r(glu.lsub(kmax)) == emptyIdxLU)
+            kmax--; 
+          else if ( perm_r(glu.lsub(kmin)) != emptyIdxLU)
+            kmin++;
+          else 
+          {
+            // kmin below pivrow (not yet pivoted), and kmax
+            // above pivrow: interchange the two suscripts
+            std::swap(glu.lsub(kmin), glu.lsub(kmax)); 
+            
+            // If the supernode has only one column, then we 
+            // only keep one set of subscripts. For any subscript
+            // intercnahge performed, similar interchange must be 
+            // done on the numerical values. 
+            if (movnum) 
+            {
+              minloc = glu.xlusup(irep) + ( kmin - glu.xlsub(irep) ); 
+              maxloc = glu.xlusup(irep) + ( kmax - glu.xlsub(irep) ); 
+              std::swap(glu.lusup(minloc), glu.lusup(maxloc)); 
+            }
+            kmin++;
+            kmax--;
+          }
+        } // end while 
+        
+        xprune(irep) = StorageIndex(kmin);  //Pruning 
+      } // end if do_prune 
+    } // end pruning 
+  } // End for each U-segment
+}
+
+} // end namespace internal
+} // end namespace Eigen
+
+#endif // SPARSELU_PRUNEL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_relax_snode.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_relax_snode.h
new file mode 100644
index 00000000..c408d01b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseLU/SparseLU_relax_snode.h
@@ -0,0 +1,83 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/* This file is a modified version of heap_relax_snode.c file in SuperLU
+ * -- SuperLU routine (version 3.0) --
+ * Univ. of California Berkeley, Xerox Palo Alto Research Center,
+ * and Lawrence Berkeley National Lab.
+ * October 15, 2003
+ *
+ * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+ * EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program for any
+ * purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is
+ * granted, provided the above notices are retained, and a notice that
+ * the code was modified is included with the above copyright notice.
+ */
+
+#ifndef SPARSELU_RELAX_SNODE_H
+#define SPARSELU_RELAX_SNODE_H
+
+namespace Eigen {
+
+namespace internal {
+ 
+/** 
+ * \brief Identify the initial relaxed supernodes
+ * 
+ * This routine is applied to a column elimination tree. 
+ * It assumes that the matrix has been reordered according to the postorder of the etree
+ * \param n  the number of columns
+ * \param et elimination tree 
+ * \param relax_columns Maximum number of columns allowed in a relaxed snode 
+ * \param descendants Number of descendants of each node in the etree
+ * \param relax_end last column in a supernode
+ */
+template <typename Scalar, typename StorageIndex>
+void SparseLUImpl<Scalar,StorageIndex>::relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end)
+{
+  
+  // compute the number of descendants of each node in the etree
+  Index parent; 
+  relax_end.setConstant(emptyIdxLU);
+  descendants.setZero();
+  for (Index j = 0; j < n; j++) 
+  {
+    parent = et(j);
+    if (parent != n) // not the dummy root
+      descendants(parent) += descendants(j) + 1;
+  }
+  // Identify the relaxed supernodes by postorder traversal of the etree
+  Index snode_start; // beginning of a snode 
+  for (Index j = 0; j < n; )
+  {
+    parent = et(j);
+    snode_start = j; 
+    while ( parent != n && descendants(parent) < relax_columns ) 
+    {
+      j = parent; 
+      parent = et(j);
+    }
+    // Found a supernode in postordered etree, j is the last column 
+    relax_end(snode_start) = StorageIndex(j); // Record last column
+    j++;
+    // Search for a new leaf
+    while (descendants(j) != 0 && j < n) j++;
+  } // End postorder traversal of the etree
+  
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SparseQR/SparseQR.h b/C++/yolo_bytetrack_old/include/Eigen/src/SparseQR/SparseQR.h
new file mode 100644
index 00000000..d1fb96f5
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SparseQR/SparseQR.h
@@ -0,0 +1,758 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012-2013 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
+// Copyright (C) 2012-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSE_QR_H
+#define EIGEN_SPARSE_QR_H
+
+namespace Eigen {
+
+template<typename MatrixType, typename OrderingType> class SparseQR;
+template<typename SparseQRType> struct SparseQRMatrixQReturnType;
+template<typename SparseQRType> struct SparseQRMatrixQTransposeReturnType;
+template<typename SparseQRType, typename Derived> struct SparseQR_QProduct;
+namespace internal {
+  template <typename SparseQRType> struct traits<SparseQRMatrixQReturnType<SparseQRType> >
+  {
+    typedef typename SparseQRType::MatrixType ReturnType;
+    typedef typename ReturnType::StorageIndex StorageIndex;
+    typedef typename ReturnType::StorageKind StorageKind;
+    enum {
+      RowsAtCompileTime = Dynamic,
+      ColsAtCompileTime = Dynamic
+    };
+  };
+  template <typename SparseQRType> struct traits<SparseQRMatrixQTransposeReturnType<SparseQRType> >
+  {
+    typedef typename SparseQRType::MatrixType ReturnType;
+  };
+  template <typename SparseQRType, typename Derived> struct traits<SparseQR_QProduct<SparseQRType, Derived> >
+  {
+    typedef typename Derived::PlainObject ReturnType;
+  };
+} // End namespace internal
+
+/**
+  * \ingroup SparseQR_Module
+  * \class SparseQR
+  * \brief Sparse left-looking QR factorization with numerical column pivoting
+  * 
+  * This class implements a left-looking QR decomposition of sparse matrices
+  * with numerical column pivoting.
+  * When a column has a norm less than a given tolerance
+  * it is implicitly permuted to the end. The QR factorization thus obtained is 
+  * given by A*P = Q*R where R is upper triangular or trapezoidal. 
+  * 
+  * P is the column permutation which is the product of the fill-reducing and the
+  * numerical permutations. Use colsPermutation() to get it.
+  * 
+  * Q is the orthogonal matrix represented as products of Householder reflectors. 
+  * Use matrixQ() to get an expression and matrixQ().adjoint() to get the adjoint.
+  * You can then apply it to a vector.
+  * 
+  * R is the sparse triangular or trapezoidal matrix. The later occurs when A is rank-deficient.
+  * matrixR().topLeftCorner(rank(), rank()) always returns a triangular factor of full rank.
+  * 
+  * \tparam _MatrixType The type of the sparse matrix A, must be a column-major SparseMatrix<>
+  * \tparam _OrderingType The fill-reducing ordering method. See the \link OrderingMethods_Module 
+  *  OrderingMethods \endlink module for the list of built-in and external ordering methods.
+  * 
+  * \implsparsesolverconcept
+  *
+  * The numerical pivoting strategy and default threshold are the same as in SuiteSparse QR, and
+  * detailed in the following paper:
+  * <i>
+  * Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
+  * Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011.
+  * </i>
+  * Even though it is qualified as "rank-revealing", this strategy might fail for some 
+  * rank deficient problems. When this class is used to solve linear or least-square problems
+  * it is thus strongly recommended to check the accuracy of the computed solution. If it
+  * failed, it usually helps to increase the threshold with setPivotThreshold.
+  * 
+  * \warning The input sparse matrix A must be in compressed mode (see SparseMatrix::makeCompressed()).
+  * \warning For complex matrices matrixQ().transpose() will actually return the adjoint matrix.
+  * 
+  */
+template<typename _MatrixType, typename _OrderingType>
+class SparseQR : public SparseSolverBase<SparseQR<_MatrixType,_OrderingType> >
+{
+  protected:
+    typedef SparseSolverBase<SparseQR<_MatrixType,_OrderingType> > Base;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    typedef _MatrixType MatrixType;
+    typedef _OrderingType OrderingType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> QRMatrixType;
+    typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
+    typedef Matrix<Scalar, Dynamic, 1> ScalarVector;
+    typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+    
+  public:
+    SparseQR () :  m_analysisIsok(false), m_lastError(""), m_useDefaultThreshold(true),m_isQSorted(false),m_isEtreeOk(false)
+    { }
+    
+    /** Construct a QR factorization of the matrix \a mat.
+      * 
+      * \warning The matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+      * 
+      * \sa compute()
+      */
+    explicit SparseQR(const MatrixType& mat) : m_analysisIsok(false), m_lastError(""), m_useDefaultThreshold(true),m_isQSorted(false),m_isEtreeOk(false)
+    {
+      compute(mat);
+    }
+    
+    /** Computes the QR factorization of the sparse matrix \a mat.
+      * 
+      * \warning The matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+      * 
+      * \sa analyzePattern(), factorize()
+      */
+    void compute(const MatrixType& mat)
+    {
+      analyzePattern(mat);
+      factorize(mat);
+    }
+    void analyzePattern(const MatrixType& mat);
+    void factorize(const MatrixType& mat);
+    
+    /** \returns the number of rows of the represented matrix. 
+      */
+    inline Index rows() const { return m_pmat.rows(); }
+    
+    /** \returns the number of columns of the represented matrix. 
+      */
+    inline Index cols() const { return m_pmat.cols();}
+    
+    /** \returns a const reference to the \b sparse upper triangular matrix R of the QR factorization.
+      * \warning The entries of the returned matrix are not sorted. This means that using it in algorithms
+      *          expecting sorted entries will fail. This include random coefficient accesses (SpaseMatrix::coeff()),
+      *          and coefficient-wise operations. Matrix products and triangular solves are fine though.
+      *
+      * To sort the entries, you can assign it to a row-major matrix, and if a column-major matrix
+      * is required, you can copy it again:
+      * \code
+      * SparseMatrix<double>          R  = qr.matrixR();  // column-major, not sorted!
+      * SparseMatrix<double,RowMajor> Rr = qr.matrixR();  // row-major, sorted
+      * SparseMatrix<double>          Rc = Rr;            // column-major, sorted
+      * \endcode
+      */
+    const QRMatrixType& matrixR() const { return m_R; }
+    
+    /** \returns the number of non linearly dependent columns as determined by the pivoting threshold.
+      *
+      * \sa setPivotThreshold()
+      */
+    Index rank() const
+    {
+      eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+      return m_nonzeropivots; 
+    }
+    
+    /** \returns an expression of the matrix Q as products of sparse Householder reflectors.
+    * The common usage of this function is to apply it to a dense matrix or vector
+    * \code
+    * VectorXd B1, B2;
+    * // Initialize B1
+    * B2 = matrixQ() * B1;
+    * \endcode
+    *
+    * To get a plain SparseMatrix representation of Q:
+    * \code
+    * SparseMatrix<double> Q;
+    * Q = SparseQR<SparseMatrix<double> >(A).matrixQ();
+    * \endcode
+    * Internally, this call simply performs a sparse product between the matrix Q
+    * and a sparse identity matrix. However, due to the fact that the sparse
+    * reflectors are stored unsorted, two transpositions are needed to sort
+    * them before performing the product.
+    */
+    SparseQRMatrixQReturnType<SparseQR> matrixQ() const 
+    { return SparseQRMatrixQReturnType<SparseQR>(*this); }
+    
+    /** \returns a const reference to the column permutation P that was applied to A such that A*P = Q*R
+      * It is the combination of the fill-in reducing permutation and numerical column pivoting.
+      */
+    const PermutationType& colsPermutation() const
+    { 
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_outputPerm_c;
+    }
+    
+    /** \returns A string describing the type of error.
+      * This method is provided to ease debugging, not to handle errors.
+      */
+    std::string lastErrorMessage() const { return m_lastError; }
+    
+    /** \internal */
+    template<typename Rhs, typename Dest>
+    bool _solve_impl(const MatrixBase<Rhs> &B, MatrixBase<Dest> &dest) const
+    {
+      eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+      eigen_assert(this->rows() == B.rows() && "SparseQR::solve() : invalid number of rows in the right hand side matrix");
+
+      Index rank = this->rank();
+      
+      // Compute Q^* * b;
+      typename Dest::PlainObject y, b;
+      y = this->matrixQ().adjoint() * B;
+      b = y;
+      
+      // Solve with the triangular matrix R
+      y.resize((std::max<Index>)(cols(),y.rows()),y.cols());
+      y.topRows(rank) = this->matrixR().topLeftCorner(rank, rank).template triangularView<Upper>().solve(b.topRows(rank));
+      y.bottomRows(y.rows()-rank).setZero();
+      
+      // Apply the column permutation
+      if (m_perm_c.size())  dest = colsPermutation() * y.topRows(cols());
+      else                  dest = y.topRows(cols());
+      
+      m_info = Success;
+      return true;
+    }
+
+    /** Sets the threshold that is used to determine linearly dependent columns during the factorization.
+      *
+      * In practice, if during the factorization the norm of the column that has to be eliminated is below
+      * this threshold, then the entire column is treated as zero, and it is moved at the end.
+      */
+    void setPivotThreshold(const RealScalar& threshold)
+    {
+      m_useDefaultThreshold = false;
+      m_threshold = threshold;
+    }
+    
+    /** \returns the solution X of \f$ A X = B \f$ using the current decomposition of A.
+      *
+      * \sa compute()
+      */
+    template<typename Rhs>
+    inline const Solve<SparseQR, Rhs> solve(const MatrixBase<Rhs>& B) const 
+    {
+      eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+      eigen_assert(this->rows() == B.rows() && "SparseQR::solve() : invalid number of rows in the right hand side matrix");
+      return Solve<SparseQR, Rhs>(*this, B.derived());
+    }
+    template<typename Rhs>
+    inline const Solve<SparseQR, Rhs> solve(const SparseMatrixBase<Rhs>& B) const
+    {
+          eigen_assert(m_isInitialized && "The factorization should be called first, use compute()");
+          eigen_assert(this->rows() == B.rows() && "SparseQR::solve() : invalid number of rows in the right hand side matrix");
+          return Solve<SparseQR, Rhs>(*this, B.derived());
+    }
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the QR factorization reports a numerical problem
+      *          \c InvalidInput if the input matrix is invalid
+      *
+      * \sa iparm()          
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+
+    /** \internal */
+    inline void _sort_matrix_Q()
+    {
+      if(this->m_isQSorted) return;
+      // The matrix Q is sorted during the transposition
+      SparseMatrix<Scalar, RowMajor, Index> mQrm(this->m_Q);
+      this->m_Q = mQrm;
+      this->m_isQSorted = true;
+    }
+
+    
+  protected:
+    bool m_analysisIsok;
+    bool m_factorizationIsok;
+    mutable ComputationInfo m_info;
+    std::string m_lastError;
+    QRMatrixType m_pmat;            // Temporary matrix
+    QRMatrixType m_R;               // The triangular factor matrix
+    QRMatrixType m_Q;               // The orthogonal reflectors
+    ScalarVector m_hcoeffs;         // The Householder coefficients
+    PermutationType m_perm_c;       // Fill-reducing  Column  permutation
+    PermutationType m_pivotperm;    // The permutation for rank revealing
+    PermutationType m_outputPerm_c; // The final column permutation
+    RealScalar m_threshold;         // Threshold to determine null Householder reflections
+    bool m_useDefaultThreshold;     // Use default threshold
+    Index m_nonzeropivots;          // Number of non zero pivots found
+    IndexVector m_etree;            // Column elimination tree
+    IndexVector m_firstRowElt;      // First element in each row
+    bool m_isQSorted;               // whether Q is sorted or not
+    bool m_isEtreeOk;               // whether the elimination tree match the initial input matrix
+    
+    template <typename, typename > friend struct SparseQR_QProduct;
+    
+};
+
+/** \brief Preprocessing step of a QR factorization 
+  * 
+  * \warning The matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
+  * 
+  * In this step, the fill-reducing permutation is computed and applied to the columns of A
+  * and the column elimination tree is computed as well. Only the sparsity pattern of \a mat is exploited.
+  * 
+  * \note In this step it is assumed that there is no empty row in the matrix \a mat.
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseQR<MatrixType,OrderingType>::analyzePattern(const MatrixType& mat)
+{
+  eigen_assert(mat.isCompressed() && "SparseQR requires a sparse matrix in compressed mode. Call .makeCompressed() before passing it to SparseQR");
+  // Copy to a column major matrix if the input is rowmajor
+  typename internal::conditional<MatrixType::IsRowMajor,QRMatrixType,const MatrixType&>::type matCpy(mat);
+  // Compute the column fill reducing ordering
+  OrderingType ord; 
+  ord(matCpy, m_perm_c); 
+  Index n = mat.cols();
+  Index m = mat.rows();
+  Index diagSize = (std::min)(m,n);
+  
+  if (!m_perm_c.size())
+  {
+    m_perm_c.resize(n);
+    m_perm_c.indices().setLinSpaced(n, 0,StorageIndex(n-1));
+  }
+  
+  // Compute the column elimination tree of the permuted matrix
+  m_outputPerm_c = m_perm_c.inverse();
+  internal::coletree(matCpy, m_etree, m_firstRowElt, m_outputPerm_c.indices().data());
+  m_isEtreeOk = true;
+  
+  m_R.resize(m, n);
+  m_Q.resize(m, diagSize);
+  
+  // Allocate space for nonzero elements: rough estimation
+  m_R.reserve(2*mat.nonZeros()); //FIXME Get a more accurate estimation through symbolic factorization with the etree
+  m_Q.reserve(2*mat.nonZeros());
+  m_hcoeffs.resize(diagSize);
+  m_analysisIsok = true;
+}
+
+/** \brief Performs the numerical QR factorization of the input matrix
+  * 
+  * The function SparseQR::analyzePattern(const MatrixType&) must have been called beforehand with
+  * a matrix having the same sparsity pattern than \a mat.
+  * 
+  * \param mat The sparse column-major matrix
+  */
+template <typename MatrixType, typename OrderingType>
+void SparseQR<MatrixType,OrderingType>::factorize(const MatrixType& mat)
+{
+  using std::abs;
+  
+  eigen_assert(m_analysisIsok && "analyzePattern() should be called before this step");
+  StorageIndex m = StorageIndex(mat.rows());
+  StorageIndex n = StorageIndex(mat.cols());
+  StorageIndex diagSize = (std::min)(m,n);
+  IndexVector mark((std::max)(m,n)); mark.setConstant(-1);  // Record the visited nodes
+  IndexVector Ridx(n), Qidx(m);                             // Store temporarily the row indexes for the current column of R and Q
+  Index nzcolR, nzcolQ;                                     // Number of nonzero for the current column of R and Q
+  ScalarVector tval(m);                                     // The dense vector used to compute the current column
+  RealScalar pivotThreshold = m_threshold;
+  
+  m_R.setZero();
+  m_Q.setZero();
+  m_pmat = mat;
+  if(!m_isEtreeOk)
+  {
+    m_outputPerm_c = m_perm_c.inverse();
+    internal::coletree(m_pmat, m_etree, m_firstRowElt, m_outputPerm_c.indices().data());
+    m_isEtreeOk = true;
+  }
+
+  m_pmat.uncompress(); // To have the innerNonZeroPtr allocated
+  
+  // Apply the fill-in reducing permutation lazily:
+  {
+    // If the input is row major, copy the original column indices,
+    // otherwise directly use the input matrix
+    // 
+    IndexVector originalOuterIndicesCpy;
+    const StorageIndex *originalOuterIndices = mat.outerIndexPtr();
+    if(MatrixType::IsRowMajor)
+    {
+      originalOuterIndicesCpy = IndexVector::Map(m_pmat.outerIndexPtr(),n+1);
+      originalOuterIndices = originalOuterIndicesCpy.data();
+    }
+    
+    for (int i = 0; i < n; i++)
+    {
+      Index p = m_perm_c.size() ? m_perm_c.indices()(i) : i;
+      m_pmat.outerIndexPtr()[p] = originalOuterIndices[i]; 
+      m_pmat.innerNonZeroPtr()[p] = originalOuterIndices[i+1] - originalOuterIndices[i]; 
+    }
+  }
+  
+  /* Compute the default threshold as in MatLab, see:
+   * Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
+   * Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011, Page 8:3 
+   */
+  if(m_useDefaultThreshold) 
+  {
+    RealScalar max2Norm = 0.0;
+    for (int j = 0; j < n; j++) max2Norm = numext::maxi(max2Norm, m_pmat.col(j).norm());
+    if(max2Norm==RealScalar(0))
+      max2Norm = RealScalar(1);
+    pivotThreshold = 20 * (m + n) * max2Norm * NumTraits<RealScalar>::epsilon();
+  }
+  
+  // Initialize the numerical permutation
+  m_pivotperm.setIdentity(n);
+  
+  StorageIndex nonzeroCol = 0; // Record the number of valid pivots
+  m_Q.startVec(0);
+
+  // Left looking rank-revealing QR factorization: compute a column of R and Q at a time
+  for (StorageIndex col = 0; col < n; ++col)
+  {
+    mark.setConstant(-1);
+    m_R.startVec(col);
+    mark(nonzeroCol) = col;
+    Qidx(0) = nonzeroCol;
+    nzcolR = 0; nzcolQ = 1;
+    bool found_diag = nonzeroCol>=m;
+    tval.setZero(); 
+    
+    // Symbolic factorization: find the nonzero locations of the column k of the factors R and Q, i.e.,
+    // all the nodes (with indexes lower than rank) reachable through the column elimination tree (etree) rooted at node k.
+    // Note: if the diagonal entry does not exist, then its contribution must be explicitly added,
+    // thus the trick with found_diag that permits to do one more iteration on the diagonal element if this one has not been found.
+    for (typename QRMatrixType::InnerIterator itp(m_pmat, col); itp || !found_diag; ++itp)
+    {
+      StorageIndex curIdx = nonzeroCol;
+      if(itp) curIdx = StorageIndex(itp.row());
+      if(curIdx == nonzeroCol) found_diag = true;
+      
+      // Get the nonzeros indexes of the current column of R
+      StorageIndex st = m_firstRowElt(curIdx); // The traversal of the etree starts here
+      if (st < 0 )
+      {
+        m_lastError = "Empty row found during numerical factorization";
+        m_info = InvalidInput;
+        return;
+      }
+
+      // Traverse the etree 
+      Index bi = nzcolR;
+      for (; mark(st) != col; st = m_etree(st))
+      {
+        Ridx(nzcolR) = st;  // Add this row to the list,
+        mark(st) = col;     // and mark this row as visited
+        nzcolR++;
+      }
+
+      // Reverse the list to get the topological ordering
+      Index nt = nzcolR-bi;
+      for(Index i = 0; i < nt/2; i++) std::swap(Ridx(bi+i), Ridx(nzcolR-i-1));
+       
+      // Copy the current (curIdx,pcol) value of the input matrix
+      if(itp) tval(curIdx) = itp.value();
+      else    tval(curIdx) = Scalar(0);
+      
+      // Compute the pattern of Q(:,k)
+      if(curIdx > nonzeroCol && mark(curIdx) != col ) 
+      {
+        Qidx(nzcolQ) = curIdx;  // Add this row to the pattern of Q,
+        mark(curIdx) = col;     // and mark it as visited
+        nzcolQ++;
+      }
+    }
+
+    // Browse all the indexes of R(:,col) in reverse order
+    for (Index i = nzcolR-1; i >= 0; i--)
+    {
+      Index curIdx = Ridx(i);
+      
+      // Apply the curIdx-th householder vector to the current column (temporarily stored into tval)
+      Scalar tdot(0);
+      
+      // First compute q' * tval
+      tdot = m_Q.col(curIdx).dot(tval);
+
+      tdot *= m_hcoeffs(curIdx);
+      
+      // Then update tval = tval - q * tau
+      // FIXME: tval -= tdot * m_Q.col(curIdx) should amount to the same (need to check/add support for efficient "dense ?= sparse")
+      for (typename QRMatrixType::InnerIterator itq(m_Q, curIdx); itq; ++itq)
+        tval(itq.row()) -= itq.value() * tdot;
+
+      // Detect fill-in for the current column of Q
+      if(m_etree(Ridx(i)) == nonzeroCol)
+      {
+        for (typename QRMatrixType::InnerIterator itq(m_Q, curIdx); itq; ++itq)
+        {
+          StorageIndex iQ = StorageIndex(itq.row());
+          if (mark(iQ) != col)
+          {
+            Qidx(nzcolQ++) = iQ;  // Add this row to the pattern of Q,
+            mark(iQ) = col;       // and mark it as visited
+          }
+        }
+      }
+    } // End update current column
+    
+    Scalar tau = RealScalar(0);
+    RealScalar beta = 0;
+    
+    if(nonzeroCol < diagSize)
+    {
+      // Compute the Householder reflection that eliminate the current column
+      // FIXME this step should call the Householder module.
+      Scalar c0 = nzcolQ ? tval(Qidx(0)) : Scalar(0);
+      
+      // First, the squared norm of Q((col+1):m, col)
+      RealScalar sqrNorm = 0.;
+      for (Index itq = 1; itq < nzcolQ; ++itq) sqrNorm += numext::abs2(tval(Qidx(itq)));
+      if(sqrNorm == RealScalar(0) && numext::imag(c0) == RealScalar(0))
+      {
+        beta = numext::real(c0);
+        tval(Qidx(0)) = 1;
+      }
+      else
+      {
+        using std::sqrt;
+        beta = sqrt(numext::abs2(c0) + sqrNorm);
+        if(numext::real(c0) >= RealScalar(0))
+          beta = -beta;
+        tval(Qidx(0)) = 1;
+        for (Index itq = 1; itq < nzcolQ; ++itq)
+          tval(Qidx(itq)) /= (c0 - beta);
+        tau = numext::conj((beta-c0) / beta);
+          
+      }
+    }
+
+    // Insert values in R
+    for (Index  i = nzcolR-1; i >= 0; i--)
+    {
+      Index curIdx = Ridx(i);
+      if(curIdx < nonzeroCol) 
+      {
+        m_R.insertBackByOuterInnerUnordered(col, curIdx) = tval(curIdx);
+        tval(curIdx) = Scalar(0.);
+      }
+    }
+
+    if(nonzeroCol < diagSize && abs(beta) >= pivotThreshold)
+    {
+      m_R.insertBackByOuterInner(col, nonzeroCol) = beta;
+      // The householder coefficient
+      m_hcoeffs(nonzeroCol) = tau;
+      // Record the householder reflections
+      for (Index itq = 0; itq < nzcolQ; ++itq)
+      {
+        Index iQ = Qidx(itq);
+        m_Q.insertBackByOuterInnerUnordered(nonzeroCol,iQ) = tval(iQ);
+        tval(iQ) = Scalar(0.);
+      }
+      nonzeroCol++;
+      if(nonzeroCol<diagSize)
+        m_Q.startVec(nonzeroCol);
+    }
+    else
+    {
+      // Zero pivot found: move implicitly this column to the end
+      for (Index j = nonzeroCol; j < n-1; j++) 
+        std::swap(m_pivotperm.indices()(j), m_pivotperm.indices()[j+1]);
+      
+      // Recompute the column elimination tree
+      internal::coletree(m_pmat, m_etree, m_firstRowElt, m_pivotperm.indices().data());
+      m_isEtreeOk = false;
+    }
+  }
+  
+  m_hcoeffs.tail(diagSize-nonzeroCol).setZero();
+  
+  // Finalize the column pointers of the sparse matrices R and Q
+  m_Q.finalize();
+  m_Q.makeCompressed();
+  m_R.finalize();
+  m_R.makeCompressed();
+  m_isQSorted = false;
+
+  m_nonzeropivots = nonzeroCol;
+  
+  if(nonzeroCol<n)
+  {
+    // Permute the triangular factor to put the 'dead' columns to the end
+    QRMatrixType tempR(m_R);
+    m_R = tempR * m_pivotperm;
+    
+    // Update the column permutation
+    m_outputPerm_c = m_outputPerm_c * m_pivotperm;
+  }
+  
+  m_isInitialized = true; 
+  m_factorizationIsok = true;
+  m_info = Success;
+}
+
+template <typename SparseQRType, typename Derived>
+struct SparseQR_QProduct : ReturnByValue<SparseQR_QProduct<SparseQRType, Derived> >
+{
+  typedef typename SparseQRType::QRMatrixType MatrixType;
+  typedef typename SparseQRType::Scalar Scalar;
+  // Get the references 
+  SparseQR_QProduct(const SparseQRType& qr, const Derived& other, bool transpose) : 
+  m_qr(qr),m_other(other),m_transpose(transpose) {}
+  inline Index rows() const { return m_qr.matrixQ().rows(); }
+  inline Index cols() const { return m_other.cols(); }
+  
+  // Assign to a vector
+  template<typename DesType>
+  void evalTo(DesType& res) const
+  {
+    Index m = m_qr.rows();
+    Index n = m_qr.cols();
+    Index diagSize = (std::min)(m,n);
+    res = m_other;
+    if (m_transpose)
+    {
+      eigen_assert(m_qr.m_Q.rows() == m_other.rows() && "Non conforming object sizes");
+      //Compute res = Q' * other column by column
+      for(Index j = 0; j < res.cols(); j++){
+        for (Index k = 0; k < diagSize; k++)
+        {
+          Scalar tau = Scalar(0);
+          tau = m_qr.m_Q.col(k).dot(res.col(j));
+          if(tau==Scalar(0)) continue;
+          tau = tau * m_qr.m_hcoeffs(k);
+          res.col(j) -= tau * m_qr.m_Q.col(k);
+        }
+      }
+    }
+    else
+    {
+      eigen_assert(m_qr.matrixQ().cols() == m_other.rows() && "Non conforming object sizes");
+
+      res.conservativeResize(rows(), cols());
+
+      // Compute res = Q * other column by column
+      for(Index j = 0; j < res.cols(); j++)
+      {
+        Index start_k = internal::is_identity<Derived>::value ? numext::mini(j,diagSize-1) : diagSize-1;
+        for (Index k = start_k; k >=0; k--)
+        {
+          Scalar tau = Scalar(0);
+          tau = m_qr.m_Q.col(k).dot(res.col(j));
+          if(tau==Scalar(0)) continue;
+          tau = tau * numext::conj(m_qr.m_hcoeffs(k));
+          res.col(j) -= tau * m_qr.m_Q.col(k);
+        }
+      }
+    }
+  }
+  
+  const SparseQRType& m_qr;
+  const Derived& m_other;
+  bool m_transpose; // TODO this actually means adjoint
+};
+
+template<typename SparseQRType>
+struct SparseQRMatrixQReturnType : public EigenBase<SparseQRMatrixQReturnType<SparseQRType> >
+{  
+  typedef typename SparseQRType::Scalar Scalar;
+  typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
+  enum {
+    RowsAtCompileTime = Dynamic,
+    ColsAtCompileTime = Dynamic
+  };
+  explicit SparseQRMatrixQReturnType(const SparseQRType& qr) : m_qr(qr) {}
+  template<typename Derived>
+  SparseQR_QProduct<SparseQRType, Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SparseQR_QProduct<SparseQRType,Derived>(m_qr,other.derived(),false);
+  }
+  // To use for operations with the adjoint of Q
+  SparseQRMatrixQTransposeReturnType<SparseQRType> adjoint() const
+  {
+    return SparseQRMatrixQTransposeReturnType<SparseQRType>(m_qr);
+  }
+  inline Index rows() const { return m_qr.rows(); }
+  inline Index cols() const { return m_qr.rows(); }
+  // To use for operations with the transpose of Q FIXME this is the same as adjoint at the moment
+  SparseQRMatrixQTransposeReturnType<SparseQRType> transpose() const
+  {
+    return SparseQRMatrixQTransposeReturnType<SparseQRType>(m_qr);
+  }
+  const SparseQRType& m_qr;
+};
+
+// TODO this actually represents the adjoint of Q
+template<typename SparseQRType>
+struct SparseQRMatrixQTransposeReturnType
+{
+  explicit SparseQRMatrixQTransposeReturnType(const SparseQRType& qr) : m_qr(qr) {}
+  template<typename Derived>
+  SparseQR_QProduct<SparseQRType,Derived> operator*(const MatrixBase<Derived>& other)
+  {
+    return SparseQR_QProduct<SparseQRType,Derived>(m_qr,other.derived(), true);
+  }
+  const SparseQRType& m_qr;
+};
+
+namespace internal {
+  
+template<typename SparseQRType>
+struct evaluator_traits<SparseQRMatrixQReturnType<SparseQRType> >
+{
+  typedef typename SparseQRType::MatrixType MatrixType;
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef SparseShape Shape;
+};
+
+template< typename DstXprType, typename SparseQRType>
+struct Assignment<DstXprType, SparseQRMatrixQReturnType<SparseQRType>, internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>, Sparse2Sparse>
+{
+  typedef SparseQRMatrixQReturnType<SparseQRType> SrcXprType;
+  typedef typename DstXprType::Scalar Scalar;
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &/*func*/)
+  {
+    typename DstXprType::PlainObject idMat(src.rows(), src.cols());
+    idMat.setIdentity();
+    // Sort the sparse householder reflectors if needed
+    const_cast<SparseQRType *>(&src.m_qr)->_sort_matrix_Q();
+    dst = SparseQR_QProduct<SparseQRType, DstXprType>(src.m_qr, idMat, false);
+  }
+};
+
+template< typename DstXprType, typename SparseQRType>
+struct Assignment<DstXprType, SparseQRMatrixQReturnType<SparseQRType>, internal::assign_op<typename DstXprType::Scalar,typename DstXprType::Scalar>, Sparse2Dense>
+{
+  typedef SparseQRMatrixQReturnType<SparseQRType> SrcXprType;
+  typedef typename DstXprType::Scalar Scalar;
+  typedef typename DstXprType::StorageIndex StorageIndex;
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &/*func*/)
+  {
+    dst = src.m_qr.matrixQ() * DstXprType::Identity(src.m_qr.rows(), src.m_qr.rows());
+  }
+};
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/StdDeque.h b/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/StdDeque.h
new file mode 100644
index 00000000..6d47e757
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/StdDeque.h
@@ -0,0 +1,116 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDDEQUE_H
+#define EIGEN_STDDEQUE_H
+
+#include "details.h"
+
+/**
+ * This section contains a convenience MACRO which allows an easy specialization of
+ * std::deque such that for data types with alignment issues the correct allocator
+ * is used automatically.
+ */
+#define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...) \
+namespace std \
+{ \
+  template<> \
+  class deque<__VA_ARGS__, std::allocator<__VA_ARGS__> >           \
+    : public deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \
+  { \
+    typedef deque<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > deque_base; \
+  public: \
+    typedef __VA_ARGS__ value_type; \
+    typedef deque_base::allocator_type allocator_type; \
+    typedef deque_base::size_type size_type;  \
+    typedef deque_base::iterator iterator;  \
+    explicit deque(const allocator_type& a = allocator_type()) : deque_base(a) {}  \
+    template<typename InputIterator> \
+    deque(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : deque_base(first, last, a) {} \
+    deque(const deque& c) : deque_base(c) {}  \
+    explicit deque(size_type num, const value_type& val = value_type()) : deque_base(num, val) {} \
+    deque(iterator start_, iterator end_) : deque_base(start_, end_) {}  \
+    deque& operator=(const deque& x) {  \
+      deque_base::operator=(x);  \
+      return *this;  \
+    } \
+  }; \
+}
+
+// check whether we really need the std::deque specialization
+#if !EIGEN_HAS_CXX11_CONTAINERS && !(defined(_GLIBCXX_DEQUE) && (!EIGEN_GNUC_AT_LEAST(4,1))) /* Note that before gcc-4.1 we already have: std::deque::resize(size_type,const T&). */
+
+namespace std {
+
+#define EIGEN_STD_DEQUE_SPECIALIZATION_BODY \
+  public:  \
+    typedef T value_type; \
+    typedef typename deque_base::allocator_type allocator_type; \
+    typedef typename deque_base::size_type size_type;  \
+    typedef typename deque_base::iterator iterator;  \
+    typedef typename deque_base::const_iterator const_iterator;  \
+    explicit deque(const allocator_type& a = allocator_type()) : deque_base(a) {}  \
+    template<typename InputIterator> \
+    deque(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
+    : deque_base(first, last, a) {} \
+    deque(const deque& c) : deque_base(c) {}  \
+    explicit deque(size_type num, const value_type& val = value_type()) : deque_base(num, val) {} \
+    deque(iterator start_, iterator end_) : deque_base(start_, end_) {}  \
+    deque& operator=(const deque& x) {  \
+      deque_base::operator=(x);  \
+      return *this;  \
+    }
+
+  template<typename T>
+  class deque<T,EIGEN_ALIGNED_ALLOCATOR<T> >
+    : public deque<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                   Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> >
+{
+  typedef deque<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > deque_base;
+  EIGEN_STD_DEQUE_SPECIALIZATION_BODY
+
+  void resize(size_type new_size)
+  { resize(new_size, T()); }
+
+#if defined(_DEQUE_)
+  // workaround MSVC std::deque implementation
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (deque_base::size() < new_size)
+      deque_base::_Insert_n(deque_base::end(), new_size - deque_base::size(), x);
+    else if (new_size < deque_base::size())
+      deque_base::erase(deque_base::begin() + new_size, deque_base::end());
+  }
+  void push_back(const value_type& x)
+  { deque_base::push_back(x); } 
+  void push_front(const value_type& x)
+  { deque_base::push_front(x); }
+  using deque_base::insert;  
+  iterator insert(const_iterator position, const value_type& x)
+  { return deque_base::insert(position,x); }
+  void insert(const_iterator position, size_type new_size, const value_type& x)
+  { deque_base::insert(position, new_size, x); }
+#else
+  // default implementation which should always work.
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (new_size < deque_base::size())
+      deque_base::erase(deque_base::begin() + new_size, deque_base::end());
+    else if (new_size > deque_base::size())
+      deque_base::insert(deque_base::end(), new_size - deque_base::size(), x);
+  }
+#endif
+  };
+}
+
+#endif // check whether specialization is actually required
+
+#endif // EIGEN_STDDEQUE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/StdList.h b/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/StdList.h
new file mode 100644
index 00000000..8ba3fada
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/StdList.h
@@ -0,0 +1,106 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDLIST_H
+#define EIGEN_STDLIST_H
+
+#include "details.h"
+
+/**
+ * This section contains a convenience MACRO which allows an easy specialization of
+ * std::list such that for data types with alignment issues the correct allocator
+ * is used automatically.
+ */
+#define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...) \
+namespace std \
+{ \
+  template<> \
+  class list<__VA_ARGS__, std::allocator<__VA_ARGS__> >           \
+    : public list<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \
+  { \
+    typedef list<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > list_base; \
+  public: \
+    typedef __VA_ARGS__ value_type; \
+    typedef list_base::allocator_type allocator_type; \
+    typedef list_base::size_type size_type;  \
+    typedef list_base::iterator iterator;  \
+    explicit list(const allocator_type& a = allocator_type()) : list_base(a) {}  \
+    template<typename InputIterator> \
+    list(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : list_base(first, last, a) {} \
+    list(const list& c) : list_base(c) {}  \
+    explicit list(size_type num, const value_type& val = value_type()) : list_base(num, val) {} \
+    list(iterator start_, iterator end_) : list_base(start_, end_) {}  \
+    list& operator=(const list& x) {  \
+      list_base::operator=(x);  \
+      return *this;  \
+    } \
+  }; \
+}
+
+// check whether we really need the std::list specialization
+#if !EIGEN_HAS_CXX11_CONTAINERS && !(defined(_GLIBCXX_LIST) && (!EIGEN_GNUC_AT_LEAST(4,1))) /* Note that before gcc-4.1 we already have: std::list::resize(size_type,const T&). */
+
+namespace std
+{
+
+#define EIGEN_STD_LIST_SPECIALIZATION_BODY \
+  public:  \
+    typedef T value_type; \
+    typedef typename list_base::allocator_type allocator_type; \
+    typedef typename list_base::size_type size_type;  \
+    typedef typename list_base::iterator iterator;  \
+    typedef typename list_base::const_iterator const_iterator;  \
+    explicit list(const allocator_type& a = allocator_type()) : list_base(a) {}  \
+    template<typename InputIterator> \
+    list(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
+    : list_base(first, last, a) {} \
+    list(const list& c) : list_base(c) {}  \
+    explicit list(size_type num, const value_type& val = value_type()) : list_base(num, val) {} \
+    list(iterator start_, iterator end_) : list_base(start_, end_) {}  \
+    list& operator=(const list& x) {  \
+    list_base::operator=(x);  \
+    return *this; \
+  }
+
+  template<typename T>
+  class list<T,EIGEN_ALIGNED_ALLOCATOR<T> >
+    : public list<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                  Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> >
+  {
+    typedef list<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                 Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > list_base;
+    EIGEN_STD_LIST_SPECIALIZATION_BODY
+
+    void resize(size_type new_size)
+    { resize(new_size, T()); }
+
+    void resize(size_type new_size, const value_type& x)
+    {
+      if (list_base::size() < new_size)
+        list_base::insert(list_base::end(), new_size - list_base::size(), x);
+      else
+        while (new_size < list_base::size()) list_base::pop_back();
+    }
+
+#if defined(_LIST_)
+    // workaround MSVC std::list implementation
+    void push_back(const value_type& x)
+    { list_base::push_back(x); } 
+    using list_base::insert;  
+    iterator insert(const_iterator position, const value_type& x)
+    { return list_base::insert(position,x); }
+    void insert(const_iterator position, size_type new_size, const value_type& x)
+    { list_base::insert(position, new_size, x); }
+#endif
+  };
+}
+
+#endif // check whether specialization is actually required
+
+#endif // EIGEN_STDLIST_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/StdVector.h b/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/StdVector.h
new file mode 100644
index 00000000..9fcf19bc
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/StdVector.h
@@ -0,0 +1,131 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STDVECTOR_H
+#define EIGEN_STDVECTOR_H
+
+#include "details.h"
+
+/**
+ * This section contains a convenience MACRO which allows an easy specialization of
+ * std::vector such that for data types with alignment issues the correct allocator
+ * is used automatically.
+ */
+#define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...) \
+namespace std \
+{ \
+  template<> \
+  class vector<__VA_ARGS__, std::allocator<__VA_ARGS__> >  \
+    : public vector<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > \
+  { \
+    typedef vector<__VA_ARGS__, EIGEN_ALIGNED_ALLOCATOR<__VA_ARGS__> > vector_base; \
+  public: \
+    typedef __VA_ARGS__ value_type; \
+    typedef vector_base::allocator_type allocator_type; \
+    typedef vector_base::size_type size_type;  \
+    typedef vector_base::iterator iterator;  \
+    explicit vector(const allocator_type& a = allocator_type()) : vector_base(a) {}  \
+    template<typename InputIterator> \
+    vector(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) : vector_base(first, last, a) {} \
+    vector(const vector& c) : vector_base(c) {}  \
+    explicit vector(size_type num, const value_type& val = value_type()) : vector_base(num, val) {} \
+    vector(iterator start_, iterator end_) : vector_base(start_, end_) {}  \
+    vector& operator=(const vector& x) {  \
+      vector_base::operator=(x);  \
+      return *this;  \
+    } \
+  }; \
+}
+
+// Don't specialize if containers are implemented according to C++11
+#if !EIGEN_HAS_CXX11_CONTAINERS
+
+namespace std {
+
+#define EIGEN_STD_VECTOR_SPECIALIZATION_BODY \
+  public:  \
+    typedef T value_type; \
+    typedef typename vector_base::allocator_type allocator_type; \
+    typedef typename vector_base::size_type size_type;  \
+    typedef typename vector_base::iterator iterator;  \
+    typedef typename vector_base::const_iterator const_iterator;  \
+    explicit vector(const allocator_type& a = allocator_type()) : vector_base(a) {}  \
+    template<typename InputIterator> \
+    vector(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
+    : vector_base(first, last, a) {} \
+    vector(const vector& c) : vector_base(c) {}  \
+    explicit vector(size_type num, const value_type& val = value_type()) : vector_base(num, val) {} \
+    vector(iterator start_, iterator end_) : vector_base(start_, end_) {}  \
+    vector& operator=(const vector& x) {  \
+      vector_base::operator=(x);  \
+      return *this;  \
+    }
+
+  template<typename T>
+  class vector<T,EIGEN_ALIGNED_ALLOCATOR<T> >
+    : public vector<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                    Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> >
+{
+  typedef vector<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T),
+                 Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T)> > vector_base;
+  EIGEN_STD_VECTOR_SPECIALIZATION_BODY
+
+  void resize(size_type new_size)
+  { resize(new_size, T()); }
+
+#if defined(_VECTOR_)
+  // workaround MSVC std::vector implementation
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (vector_base::size() < new_size)
+      vector_base::_Insert_n(vector_base::end(), new_size - vector_base::size(), x);
+    else if (new_size < vector_base::size())
+      vector_base::erase(vector_base::begin() + new_size, vector_base::end());
+  }
+  void push_back(const value_type& x)
+  { vector_base::push_back(x); } 
+  using vector_base::insert;  
+  iterator insert(const_iterator position, const value_type& x)
+  { return vector_base::insert(position,x); }
+  void insert(const_iterator position, size_type new_size, const value_type& x)
+  { vector_base::insert(position, new_size, x); }
+#elif defined(_GLIBCXX_VECTOR) && (!(EIGEN_GNUC_AT_LEAST(4,1)))
+  /* Note that before gcc-4.1 we already have: std::vector::resize(size_type,const T&).
+   * However, this specialization is still needed to make the above EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION trick to work. */
+  void resize(size_type new_size, const value_type& x)
+  {
+    vector_base::resize(new_size,x);
+  }
+#elif defined(_GLIBCXX_VECTOR) && EIGEN_GNUC_AT_LEAST(4,2)
+  // workaround GCC std::vector implementation
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (new_size < vector_base::size())
+      vector_base::_M_erase_at_end(this->_M_impl._M_start + new_size);
+    else
+      vector_base::insert(vector_base::end(), new_size - vector_base::size(), x);
+  }
+#else
+  // either GCC 4.1 or non-GCC
+  // default implementation which should always work.
+  void resize(size_type new_size, const value_type& x)
+  {
+    if (new_size < vector_base::size())
+      vector_base::erase(vector_base::begin() + new_size, vector_base::end());
+    else if (new_size > vector_base::size())
+      vector_base::insert(vector_base::end(), new_size - vector_base::size(), x);
+  }
+#endif
+  };
+}
+#endif // !EIGEN_HAS_CXX11_CONTAINERS
+
+
+#endif // EIGEN_STDVECTOR_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/details.h b/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/details.h
new file mode 100644
index 00000000..2cfd13e0
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/StlSupport/details.h
@@ -0,0 +1,84 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_STL_DETAILS_H
+#define EIGEN_STL_DETAILS_H
+
+#ifndef EIGEN_ALIGNED_ALLOCATOR
+  #define EIGEN_ALIGNED_ALLOCATOR Eigen::aligned_allocator
+#endif
+
+namespace Eigen {
+
+  // This one is needed to prevent reimplementing the whole std::vector.
+  template <class T>
+  class aligned_allocator_indirection : public EIGEN_ALIGNED_ALLOCATOR<T>
+  {
+  public:
+    typedef std::size_t     size_type;
+    typedef std::ptrdiff_t  difference_type;
+    typedef T*              pointer;
+    typedef const T*        const_pointer;
+    typedef T&              reference;
+    typedef const T&        const_reference;
+    typedef T               value_type;
+
+    template<class U>
+    struct rebind
+    {
+      typedef aligned_allocator_indirection<U> other;
+    };
+
+    aligned_allocator_indirection() {}
+    aligned_allocator_indirection(const aligned_allocator_indirection& ) : EIGEN_ALIGNED_ALLOCATOR<T>() {}
+    aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<T>& ) {}
+    template<class U>
+    aligned_allocator_indirection(const aligned_allocator_indirection<U>& ) {}
+    template<class U>
+    aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<U>& ) {}
+    ~aligned_allocator_indirection() {}
+  };
+
+#if EIGEN_COMP_MSVC
+
+  // sometimes, MSVC detects, at compile time, that the argument x
+  // in std::vector::resize(size_t s,T x) won't be aligned and generate an error
+  // even if this function is never called. Whence this little wrapper.
+#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) \
+  typename Eigen::internal::conditional< \
+    Eigen::internal::is_arithmetic<T>::value, \
+    T, \
+    Eigen::internal::workaround_msvc_stl_support<T> \
+  >::type
+
+  namespace internal {
+  template<typename T> struct workaround_msvc_stl_support : public T
+  {
+    inline workaround_msvc_stl_support() : T() {}
+    inline workaround_msvc_stl_support(const T& other) : T(other) {}
+    inline operator T& () { return *static_cast<T*>(this); }
+    inline operator const T& () const { return *static_cast<const T*>(this); }
+    template<typename OtherT>
+    inline T& operator=(const OtherT& other)
+    { T::operator=(other); return *this; }
+    inline workaround_msvc_stl_support& operator=(const workaround_msvc_stl_support& other)
+    { T::operator=(other); return *this; }
+  };
+  }
+
+#else
+
+#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) T
+
+#endif
+
+}
+
+#endif // EIGEN_STL_DETAILS_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/SuperLUSupport/SuperLUSupport.h b/C++/yolo_bytetrack_old/include/Eigen/src/SuperLUSupport/SuperLUSupport.h
new file mode 100644
index 00000000..d1d3ad7f
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/SuperLUSupport/SuperLUSupport.h
@@ -0,0 +1,1025 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SUPERLUSUPPORT_H
+#define EIGEN_SUPERLUSUPPORT_H
+
+namespace Eigen {
+
+#if defined(SUPERLU_MAJOR_VERSION) && (SUPERLU_MAJOR_VERSION >= 5)
+#define DECL_GSSVX(PREFIX,FLOATTYPE,KEYTYPE)		\
+    extern "C" {                                                                                          \
+      extern void PREFIX##gssvx(superlu_options_t *, SuperMatrix *, int *, int *, int *,                  \
+                                char *, FLOATTYPE *, FLOATTYPE *, SuperMatrix *, SuperMatrix *,           \
+                                void *, int, SuperMatrix *, SuperMatrix *,                                \
+                                FLOATTYPE *, FLOATTYPE *, FLOATTYPE *, FLOATTYPE *,                       \
+                                GlobalLU_t *, mem_usage_t *, SuperLUStat_t *, int *);                     \
+    }                                                                                                     \
+    inline float SuperLU_gssvx(superlu_options_t *options, SuperMatrix *A,                                \
+         int *perm_c, int *perm_r, int *etree, char *equed,                                               \
+         FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L,                                                      \
+         SuperMatrix *U, void *work, int lwork,                                                           \
+         SuperMatrix *B, SuperMatrix *X,                                                                  \
+         FLOATTYPE *recip_pivot_growth,                                                                   \
+         FLOATTYPE *rcond, FLOATTYPE *ferr, FLOATTYPE *berr,                                              \
+         SuperLUStat_t *stats, int *info, KEYTYPE) {                                                      \
+    mem_usage_t mem_usage;                                                                                \
+    GlobalLU_t gLU;                                                                                       \
+    PREFIX##gssvx(options, A, perm_c, perm_r, etree, equed, R, C, L,                                      \
+         U, work, lwork, B, X, recip_pivot_growth, rcond,                                                 \
+         ferr, berr, &gLU, &mem_usage, stats, info);                                                      \
+    return mem_usage.for_lu; /* bytes used by the factor storage */                                       \
+  }
+#else // version < 5.0
+#define DECL_GSSVX(PREFIX,FLOATTYPE,KEYTYPE)		\
+    extern "C" {                                                                                          \
+      extern void PREFIX##gssvx(superlu_options_t *, SuperMatrix *, int *, int *, int *,                  \
+                                char *, FLOATTYPE *, FLOATTYPE *, SuperMatrix *, SuperMatrix *,           \
+                                void *, int, SuperMatrix *, SuperMatrix *,                                \
+                                FLOATTYPE *, FLOATTYPE *, FLOATTYPE *, FLOATTYPE *,                       \
+                                mem_usage_t *, SuperLUStat_t *, int *);                                   \
+    }                                                                                                     \
+    inline float SuperLU_gssvx(superlu_options_t *options, SuperMatrix *A,                                \
+         int *perm_c, int *perm_r, int *etree, char *equed,                                               \
+         FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L,                                                      \
+         SuperMatrix *U, void *work, int lwork,                                                           \
+         SuperMatrix *B, SuperMatrix *X,                                                                  \
+         FLOATTYPE *recip_pivot_growth,                                                                   \
+         FLOATTYPE *rcond, FLOATTYPE *ferr, FLOATTYPE *berr,                                              \
+         SuperLUStat_t *stats, int *info, KEYTYPE) {                                                      \
+    mem_usage_t mem_usage;                                                                                \
+    PREFIX##gssvx(options, A, perm_c, perm_r, etree, equed, R, C, L,                                      \
+         U, work, lwork, B, X, recip_pivot_growth, rcond,                                                 \
+         ferr, berr, &mem_usage, stats, info);                                                            \
+    return mem_usage.for_lu; /* bytes used by the factor storage */                                       \
+  }
+#endif
+
+DECL_GSSVX(s,float,float)
+DECL_GSSVX(c,float,std::complex<float>)
+DECL_GSSVX(d,double,double)
+DECL_GSSVX(z,double,std::complex<double>)
+
+#ifdef MILU_ALPHA
+#define EIGEN_SUPERLU_HAS_ILU
+#endif
+
+#ifdef EIGEN_SUPERLU_HAS_ILU
+
+// similarly for the incomplete factorization using gsisx
+#define DECL_GSISX(PREFIX,FLOATTYPE,KEYTYPE)                                                    \
+    extern "C" {                                                                                \
+      extern void PREFIX##gsisx(superlu_options_t *, SuperMatrix *, int *, int *, int *,        \
+                         char *, FLOATTYPE *, FLOATTYPE *, SuperMatrix *, SuperMatrix *,        \
+                         void *, int, SuperMatrix *, SuperMatrix *, FLOATTYPE *, FLOATTYPE *,   \
+                         mem_usage_t *, SuperLUStat_t *, int *);                        \
+    }                                                                                           \
+    inline float SuperLU_gsisx(superlu_options_t *options, SuperMatrix *A,                      \
+         int *perm_c, int *perm_r, int *etree, char *equed,                                     \
+         FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L,                                            \
+         SuperMatrix *U, void *work, int lwork,                                                 \
+         SuperMatrix *B, SuperMatrix *X,                                                        \
+         FLOATTYPE *recip_pivot_growth,                                                         \
+         FLOATTYPE *rcond,                                                                      \
+         SuperLUStat_t *stats, int *info, KEYTYPE) {                                            \
+    mem_usage_t mem_usage;                                                              \
+    PREFIX##gsisx(options, A, perm_c, perm_r, etree, equed, R, C, L,                            \
+         U, work, lwork, B, X, recip_pivot_growth, rcond,                                       \
+         &mem_usage, stats, info);                                                              \
+    return mem_usage.for_lu; /* bytes used by the factor storage */                             \
+  }
+
+DECL_GSISX(s,float,float)
+DECL_GSISX(c,float,std::complex<float>)
+DECL_GSISX(d,double,double)
+DECL_GSISX(z,double,std::complex<double>)
+
+#endif
+
+template<typename MatrixType>
+struct SluMatrixMapHelper;
+
+/** \internal
+  *
+  * A wrapper class for SuperLU matrices. It supports only compressed sparse matrices
+  * and dense matrices. Supernodal and other fancy format are not supported by this wrapper.
+  *
+  * This wrapper class mainly aims to avoids the need of dynamic allocation of the storage structure.
+  */
+struct SluMatrix : SuperMatrix
+{
+  SluMatrix()
+  {
+    Store = &storage;
+  }
+
+  SluMatrix(const SluMatrix& other)
+    : SuperMatrix(other)
+  {
+    Store = &storage;
+    storage = other.storage;
+  }
+
+  SluMatrix& operator=(const SluMatrix& other)
+  {
+    SuperMatrix::operator=(static_cast<const SuperMatrix&>(other));
+    Store = &storage;
+    storage = other.storage;
+    return *this;
+  }
+
+  struct
+  {
+    union {int nnz;int lda;};
+    void *values;
+    int *innerInd;
+    int *outerInd;
+  } storage;
+
+  void setStorageType(Stype_t t)
+  {
+    Stype = t;
+    if (t==SLU_NC || t==SLU_NR || t==SLU_DN)
+      Store = &storage;
+    else
+    {
+      eigen_assert(false && "storage type not supported");
+      Store = 0;
+    }
+  }
+
+  template<typename Scalar>
+  void setScalarType()
+  {
+    if (internal::is_same<Scalar,float>::value)
+      Dtype = SLU_S;
+    else if (internal::is_same<Scalar,double>::value)
+      Dtype = SLU_D;
+    else if (internal::is_same<Scalar,std::complex<float> >::value)
+      Dtype = SLU_C;
+    else if (internal::is_same<Scalar,std::complex<double> >::value)
+      Dtype = SLU_Z;
+    else
+    {
+      eigen_assert(false && "Scalar type not supported by SuperLU");
+    }
+  }
+
+  template<typename MatrixType>
+  static SluMatrix Map(MatrixBase<MatrixType>& _mat)
+  {
+    MatrixType& mat(_mat.derived());
+    eigen_assert( ((MatrixType::Flags&RowMajorBit)!=RowMajorBit) && "row-major dense matrices are not supported by SuperLU");
+    SluMatrix res;
+    res.setStorageType(SLU_DN);
+    res.setScalarType<typename MatrixType::Scalar>();
+    res.Mtype     = SLU_GE;
+
+    res.nrow      = internal::convert_index<int>(mat.rows());
+    res.ncol      = internal::convert_index<int>(mat.cols());
+
+    res.storage.lda       = internal::convert_index<int>(MatrixType::IsVectorAtCompileTime ? mat.size() : mat.outerStride());
+    res.storage.values    = (void*)(mat.data());
+    return res;
+  }
+
+  template<typename MatrixType>
+  static SluMatrix Map(SparseMatrixBase<MatrixType>& a_mat)
+  {
+    MatrixType &mat(a_mat.derived());
+    SluMatrix res;
+    if ((MatrixType::Flags&RowMajorBit)==RowMajorBit)
+    {
+      res.setStorageType(SLU_NR);
+      res.nrow      = internal::convert_index<int>(mat.cols());
+      res.ncol      = internal::convert_index<int>(mat.rows());
+    }
+    else
+    {
+      res.setStorageType(SLU_NC);
+      res.nrow      = internal::convert_index<int>(mat.rows());
+      res.ncol      = internal::convert_index<int>(mat.cols());
+    }
+
+    res.Mtype       = SLU_GE;
+
+    res.storage.nnz       = internal::convert_index<int>(mat.nonZeros());
+    res.storage.values    = mat.valuePtr();
+    res.storage.innerInd  = mat.innerIndexPtr();
+    res.storage.outerInd  = mat.outerIndexPtr();
+
+    res.setScalarType<typename MatrixType::Scalar>();
+
+    // FIXME the following is not very accurate
+    if (int(MatrixType::Flags) & int(Upper))
+      res.Mtype = SLU_TRU;
+    if (int(MatrixType::Flags) & int(Lower))
+      res.Mtype = SLU_TRL;
+
+    eigen_assert(((int(MatrixType::Flags) & int(SelfAdjoint))==0) && "SelfAdjoint matrix shape not supported by SuperLU");
+
+    return res;
+  }
+};
+
+template<typename Scalar, int Rows, int Cols, int Options, int MRows, int MCols>
+struct SluMatrixMapHelper<Matrix<Scalar,Rows,Cols,Options,MRows,MCols> >
+{
+  typedef Matrix<Scalar,Rows,Cols,Options,MRows,MCols> MatrixType;
+  static void run(MatrixType& mat, SluMatrix& res)
+  {
+    eigen_assert( ((Options&RowMajor)!=RowMajor) && "row-major dense matrices is not supported by SuperLU");
+    res.setStorageType(SLU_DN);
+    res.setScalarType<Scalar>();
+    res.Mtype     = SLU_GE;
+
+    res.nrow      = mat.rows();
+    res.ncol      = mat.cols();
+
+    res.storage.lda       = mat.outerStride();
+    res.storage.values    = mat.data();
+  }
+};
+
+template<typename Derived>
+struct SluMatrixMapHelper<SparseMatrixBase<Derived> >
+{
+  typedef Derived MatrixType;
+  static void run(MatrixType& mat, SluMatrix& res)
+  {
+    if ((MatrixType::Flags&RowMajorBit)==RowMajorBit)
+    {
+      res.setStorageType(SLU_NR);
+      res.nrow      = mat.cols();
+      res.ncol      = mat.rows();
+    }
+    else
+    {
+      res.setStorageType(SLU_NC);
+      res.nrow      = mat.rows();
+      res.ncol      = mat.cols();
+    }
+
+    res.Mtype       = SLU_GE;
+
+    res.storage.nnz       = mat.nonZeros();
+    res.storage.values    = mat.valuePtr();
+    res.storage.innerInd  = mat.innerIndexPtr();
+    res.storage.outerInd  = mat.outerIndexPtr();
+
+    res.setScalarType<typename MatrixType::Scalar>();
+
+    // FIXME the following is not very accurate
+    if (MatrixType::Flags & Upper)
+      res.Mtype = SLU_TRU;
+    if (MatrixType::Flags & Lower)
+      res.Mtype = SLU_TRL;
+
+    eigen_assert(((MatrixType::Flags & SelfAdjoint)==0) && "SelfAdjoint matrix shape not supported by SuperLU");
+  }
+};
+
+namespace internal {
+
+template<typename MatrixType>
+SluMatrix asSluMatrix(MatrixType& mat)
+{
+  return SluMatrix::Map(mat);
+}
+
+/** View a Super LU matrix as an Eigen expression */
+template<typename Scalar, int Flags, typename Index>
+MappedSparseMatrix<Scalar,Flags,Index> map_superlu(SluMatrix& sluMat)
+{
+  eigen_assert(((Flags&RowMajor)==RowMajor && sluMat.Stype == SLU_NR)
+         || ((Flags&ColMajor)==ColMajor && sluMat.Stype == SLU_NC));
+
+  Index outerSize = (Flags&RowMajor)==RowMajor ? sluMat.ncol : sluMat.nrow;
+
+  return MappedSparseMatrix<Scalar,Flags,Index>(
+    sluMat.nrow, sluMat.ncol, sluMat.storage.outerInd[outerSize],
+    sluMat.storage.outerInd, sluMat.storage.innerInd, reinterpret_cast<Scalar*>(sluMat.storage.values) );
+}
+
+} // end namespace internal
+
+/** \ingroup SuperLUSupport_Module
+  * \class SuperLUBase
+  * \brief The base class for the direct and incomplete LU factorization of SuperLU
+  */
+template<typename _MatrixType, typename Derived>
+class SuperLUBase : public SparseSolverBase<Derived>
+{
+  protected:
+    typedef SparseSolverBase<Derived> Base;
+    using Base::derived;
+    using Base::m_isInitialized;
+  public:
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;    
+    typedef Map<PermutationMatrix<Dynamic,Dynamic,int> > PermutationMap;
+    typedef SparseMatrix<Scalar> LUMatrixType;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    SuperLUBase() {}
+
+    ~SuperLUBase()
+    {
+      clearFactors();
+    }
+    
+    inline Index rows() const { return m_matrix.rows(); }
+    inline Index cols() const { return m_matrix.cols(); }
+    
+    /** \returns a reference to the Super LU option object to configure the  Super LU algorithms. */
+    inline superlu_options_t& options() { return m_sluOptions; }
+    
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix */
+    void compute(const MatrixType& matrix)
+    {
+      derived().analyzePattern(matrix);
+      derived().factorize(matrix);
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& /*matrix*/)
+    {
+      m_isInitialized = true;
+      m_info = Success;
+      m_analysisIsOk = true;
+      m_factorizationIsOk = false;
+    }
+    
+    template<typename Stream>
+    void dumpMemory(Stream& /*s*/)
+    {}
+    
+  protected:
+    
+    void initFactorization(const MatrixType& a)
+    {
+      set_default_options(&this->m_sluOptions);
+      
+      const Index size = a.rows();
+      m_matrix = a;
+
+      m_sluA = internal::asSluMatrix(m_matrix);
+      clearFactors();
+
+      m_p.resize(size);
+      m_q.resize(size);
+      m_sluRscale.resize(size);
+      m_sluCscale.resize(size);
+      m_sluEtree.resize(size);
+
+      // set empty B and X
+      m_sluB.setStorageType(SLU_DN);
+      m_sluB.setScalarType<Scalar>();
+      m_sluB.Mtype          = SLU_GE;
+      m_sluB.storage.values = 0;
+      m_sluB.nrow           = 0;
+      m_sluB.ncol           = 0;
+      m_sluB.storage.lda    = internal::convert_index<int>(size);
+      m_sluX                = m_sluB;
+      
+      m_extractedDataAreDirty = true;
+    }
+    
+    void init()
+    {
+      m_info = InvalidInput;
+      m_isInitialized = false;
+      m_sluL.Store = 0;
+      m_sluU.Store = 0;
+    }
+    
+    void extractData() const;
+
+    void clearFactors()
+    {
+      if(m_sluL.Store)
+        Destroy_SuperNode_Matrix(&m_sluL);
+      if(m_sluU.Store)
+        Destroy_CompCol_Matrix(&m_sluU);
+
+      m_sluL.Store = 0;
+      m_sluU.Store = 0;
+
+      memset(&m_sluL,0,sizeof m_sluL);
+      memset(&m_sluU,0,sizeof m_sluU);
+    }
+
+    // cached data to reduce reallocation, etc.
+    mutable LUMatrixType m_l;
+    mutable LUMatrixType m_u;
+    mutable IntColVectorType m_p;
+    mutable IntRowVectorType m_q;
+
+    mutable LUMatrixType m_matrix;  // copy of the factorized matrix
+    mutable SluMatrix m_sluA;
+    mutable SuperMatrix m_sluL, m_sluU;
+    mutable SluMatrix m_sluB, m_sluX;
+    mutable SuperLUStat_t m_sluStat;
+    mutable superlu_options_t m_sluOptions;
+    mutable std::vector<int> m_sluEtree;
+    mutable Matrix<RealScalar,Dynamic,1> m_sluRscale, m_sluCscale;
+    mutable Matrix<RealScalar,Dynamic,1> m_sluFerr, m_sluBerr;
+    mutable char m_sluEqued;
+
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+    mutable bool m_extractedDataAreDirty;
+    
+  private:
+    SuperLUBase(SuperLUBase& ) { }
+};
+
+
+/** \ingroup SuperLUSupport_Module
+  * \class SuperLU
+  * \brief A sparse direct LU factorization and solver based on the SuperLU library
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a direct LU factorization
+  * using the SuperLU library. The sparse matrix A must be squared and invertible. The vectors or matrices
+  * X and B can be either dense or sparse.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \warning This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  */
+template<typename _MatrixType>
+class SuperLU : public SuperLUBase<_MatrixType,SuperLU<_MatrixType> >
+{
+  public:
+    typedef SuperLUBase<_MatrixType,SuperLU> Base;
+    typedef _MatrixType MatrixType;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+    typedef typename Base::StorageIndex StorageIndex;
+    typedef typename Base::IntRowVectorType IntRowVectorType;
+    typedef typename Base::IntColVectorType IntColVectorType;   
+    typedef typename Base::PermutationMap PermutationMap;
+    typedef typename Base::LUMatrixType LUMatrixType;
+    typedef TriangularView<LUMatrixType, Lower|UnitDiag>  LMatrixType;
+    typedef TriangularView<LUMatrixType,  Upper>          UMatrixType;
+
+  public:
+    using Base::_solve_impl;
+
+    SuperLU() : Base() { init(); }
+
+    explicit SuperLU(const MatrixType& matrix) : Base()
+    {
+      init();
+      Base::compute(matrix);
+    }
+
+    ~SuperLU()
+    {
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      m_info = InvalidInput;
+      m_isInitialized = false;
+      Base::analyzePattern(matrix);
+    }
+    
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& matrix);
+    
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
+    
+    inline const LMatrixType& matrixL() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_l;
+    }
+
+    inline const UMatrixType& matrixU() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_u;
+    }
+
+    inline const IntColVectorType& permutationP() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_p;
+    }
+
+    inline const IntRowVectorType& permutationQ() const
+    {
+      if (m_extractedDataAreDirty) this->extractData();
+      return m_q;
+    }
+    
+    Scalar determinant() const;
+    
+  protected:
+    
+    using Base::m_matrix;
+    using Base::m_sluOptions;
+    using Base::m_sluA;
+    using Base::m_sluB;
+    using Base::m_sluX;
+    using Base::m_p;
+    using Base::m_q;
+    using Base::m_sluEtree;
+    using Base::m_sluEqued;
+    using Base::m_sluRscale;
+    using Base::m_sluCscale;
+    using Base::m_sluL;
+    using Base::m_sluU;
+    using Base::m_sluStat;
+    using Base::m_sluFerr;
+    using Base::m_sluBerr;
+    using Base::m_l;
+    using Base::m_u;
+    
+    using Base::m_analysisIsOk;
+    using Base::m_factorizationIsOk;
+    using Base::m_extractedDataAreDirty;
+    using Base::m_isInitialized;
+    using Base::m_info;
+    
+    void init()
+    {
+      Base::init();
+      
+      set_default_options(&this->m_sluOptions);
+      m_sluOptions.PrintStat        = NO;
+      m_sluOptions.ConditionNumber  = NO;
+      m_sluOptions.Trans            = NOTRANS;
+      m_sluOptions.ColPerm          = COLAMD;
+    }
+    
+    
+  private:
+    SuperLU(SuperLU& ) { }
+};
+
+template<typename MatrixType>
+void SuperLU<MatrixType>::factorize(const MatrixType& a)
+{
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  if(!m_analysisIsOk)
+  {
+    m_info = InvalidInput;
+    return;
+  }
+  
+  this->initFactorization(a);
+  
+  m_sluOptions.ColPerm = COLAMD;
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+  RealScalar ferr, berr;
+
+  StatInit(&m_sluStat);
+  SuperLU_gssvx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0],
+                &m_sluEqued, &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &ferr, &berr,
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+
+  m_extractedDataAreDirty = true;
+
+  // FIXME how to better check for errors ???
+  m_info = info == 0 ? Success : NumericalIssue;
+  m_factorizationIsOk = true;
+}
+
+template<typename MatrixType>
+template<typename Rhs,typename Dest>
+void SuperLU<MatrixType>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest>& x) const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or analyzePattern()/factorize()");
+
+  const Index rhsCols = b.cols();
+  eigen_assert(m_matrix.rows()==b.rows());
+
+  m_sluOptions.Trans = NOTRANS;
+  m_sluOptions.Fact = FACTORED;
+  m_sluOptions.IterRefine = NOREFINE;
+  
+
+  m_sluFerr.resize(rhsCols);
+  m_sluBerr.resize(rhsCols);
+  
+  Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b);
+  Ref<const Matrix<typename Dest::Scalar,Dynamic,Dynamic,ColMajor> > x_ref(x);
+  
+  m_sluB = SluMatrix::Map(b_ref.const_cast_derived());
+  m_sluX = SluMatrix::Map(x_ref.const_cast_derived());
+  
+  typename Rhs::PlainObject b_cpy;
+  if(m_sluEqued!='N')
+  {
+    b_cpy = b;
+    m_sluB = SluMatrix::Map(b_cpy.const_cast_derived());  
+  }
+
+  StatInit(&m_sluStat);
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+  SuperLU_gssvx(&m_sluOptions, &m_sluA,
+                m_q.data(), m_p.data(),
+                &m_sluEtree[0], &m_sluEqued,
+                &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &m_sluFerr[0], &m_sluBerr[0],
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+  
+  if(x.derived().data() != x_ref.data())
+    x = x_ref;
+  
+  m_info = info==0 ? Success : NumericalIssue;
+}
+
+// the code of this extractData() function has been adapted from the SuperLU's Matlab support code,
+//
+//  Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
+//
+//  THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
+//  EXPRESSED OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+//
+template<typename MatrixType, typename Derived>
+void SuperLUBase<MatrixType,Derived>::extractData() const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for extracting factors, you must first call either compute() or analyzePattern()/factorize()");
+  if (m_extractedDataAreDirty)
+  {
+    int         upper;
+    int         fsupc, istart, nsupr;
+    int         lastl = 0, lastu = 0;
+    SCformat    *Lstore = static_cast<SCformat*>(m_sluL.Store);
+    NCformat    *Ustore = static_cast<NCformat*>(m_sluU.Store);
+    Scalar      *SNptr;
+
+    const Index size = m_matrix.rows();
+    m_l.resize(size,size);
+    m_l.resizeNonZeros(Lstore->nnz);
+    m_u.resize(size,size);
+    m_u.resizeNonZeros(Ustore->nnz);
+
+    int* Lcol = m_l.outerIndexPtr();
+    int* Lrow = m_l.innerIndexPtr();
+    Scalar* Lval = m_l.valuePtr();
+
+    int* Ucol = m_u.outerIndexPtr();
+    int* Urow = m_u.innerIndexPtr();
+    Scalar* Uval = m_u.valuePtr();
+
+    Ucol[0] = 0;
+    Ucol[0] = 0;
+
+    /* for each supernode */
+    for (int k = 0; k <= Lstore->nsuper; ++k)
+    {
+      fsupc   = L_FST_SUPC(k);
+      istart  = L_SUB_START(fsupc);
+      nsupr   = L_SUB_START(fsupc+1) - istart;
+      upper   = 1;
+
+      /* for each column in the supernode */
+      for (int j = fsupc; j < L_FST_SUPC(k+1); ++j)
+      {
+        SNptr = &((Scalar*)Lstore->nzval)[L_NZ_START(j)];
+
+        /* Extract U */
+        for (int i = U_NZ_START(j); i < U_NZ_START(j+1); ++i)
+        {
+          Uval[lastu] = ((Scalar*)Ustore->nzval)[i];
+          /* Matlab doesn't like explicit zero. */
+          if (Uval[lastu] != 0.0)
+            Urow[lastu++] = U_SUB(i);
+        }
+        for (int i = 0; i < upper; ++i)
+        {
+          /* upper triangle in the supernode */
+          Uval[lastu] = SNptr[i];
+          /* Matlab doesn't like explicit zero. */
+          if (Uval[lastu] != 0.0)
+            Urow[lastu++] = L_SUB(istart+i);
+        }
+        Ucol[j+1] = lastu;
+
+        /* Extract L */
+        Lval[lastl] = 1.0; /* unit diagonal */
+        Lrow[lastl++] = L_SUB(istart + upper - 1);
+        for (int i = upper; i < nsupr; ++i)
+        {
+          Lval[lastl] = SNptr[i];
+          /* Matlab doesn't like explicit zero. */
+          if (Lval[lastl] != 0.0)
+            Lrow[lastl++] = L_SUB(istart+i);
+        }
+        Lcol[j+1] = lastl;
+
+        ++upper;
+      } /* for j ... */
+
+    } /* for k ... */
+
+    // squeeze the matrices :
+    m_l.resizeNonZeros(lastl);
+    m_u.resizeNonZeros(lastu);
+
+    m_extractedDataAreDirty = false;
+  }
+}
+
+template<typename MatrixType>
+typename SuperLU<MatrixType>::Scalar SuperLU<MatrixType>::determinant() const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for computing the determinant, you must first call either compute() or analyzePattern()/factorize()");
+  
+  if (m_extractedDataAreDirty)
+    this->extractData();
+
+  Scalar det = Scalar(1);
+  for (int j=0; j<m_u.cols(); ++j)
+  {
+    if (m_u.outerIndexPtr()[j+1]-m_u.outerIndexPtr()[j] > 0)
+    {
+      int lastId = m_u.outerIndexPtr()[j+1]-1;
+      eigen_assert(m_u.innerIndexPtr()[lastId]<=j);
+      if (m_u.innerIndexPtr()[lastId]==j)
+        det *= m_u.valuePtr()[lastId];
+    }
+  }
+  if(PermutationMap(m_p.data(),m_p.size()).determinant()*PermutationMap(m_q.data(),m_q.size()).determinant()<0)
+    det = -det;
+  if(m_sluEqued!='N')
+    return det/m_sluRscale.prod()/m_sluCscale.prod();
+  else
+    return det;
+}
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+#define EIGEN_SUPERLU_HAS_ILU
+#endif
+
+#ifdef EIGEN_SUPERLU_HAS_ILU
+
+/** \ingroup SuperLUSupport_Module
+  * \class SuperILU
+  * \brief A sparse direct \b incomplete LU factorization and solver based on the SuperLU library
+  *
+  * This class allows to solve for an approximate solution of A.X = B sparse linear problems via an incomplete LU factorization
+  * using the SuperLU library. This class is aimed to be used as a preconditioner of the iterative linear solvers.
+  *
+  * \warning This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.
+  *
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class IncompleteLUT, class ConjugateGradient, class BiCGSTAB
+  */
+
+template<typename _MatrixType>
+class SuperILU : public SuperLUBase<_MatrixType,SuperILU<_MatrixType> >
+{
+  public:
+    typedef SuperLUBase<_MatrixType,SuperILU> Base;
+    typedef _MatrixType MatrixType;
+    typedef typename Base::Scalar Scalar;
+    typedef typename Base::RealScalar RealScalar;
+
+  public:
+    using Base::_solve_impl;
+
+    SuperILU() : Base() { init(); }
+
+    SuperILU(const MatrixType& matrix) : Base()
+    {
+      init();
+      Base::compute(matrix);
+    }
+
+    ~SuperILU()
+    {
+    }
+    
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      * 
+      * \sa factorize()
+      */
+    void analyzePattern(const MatrixType& matrix)
+    {
+      Base::analyzePattern(matrix);
+    }
+    
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
+      *
+      * \sa analyzePattern()
+      */
+    void factorize(const MatrixType& matrix);
+    
+    #ifndef EIGEN_PARSED_BY_DOXYGEN
+    /** \internal */
+    template<typename Rhs,typename Dest>
+    void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
+    #endif // EIGEN_PARSED_BY_DOXYGEN
+    
+  protected:
+    
+    using Base::m_matrix;
+    using Base::m_sluOptions;
+    using Base::m_sluA;
+    using Base::m_sluB;
+    using Base::m_sluX;
+    using Base::m_p;
+    using Base::m_q;
+    using Base::m_sluEtree;
+    using Base::m_sluEqued;
+    using Base::m_sluRscale;
+    using Base::m_sluCscale;
+    using Base::m_sluL;
+    using Base::m_sluU;
+    using Base::m_sluStat;
+    using Base::m_sluFerr;
+    using Base::m_sluBerr;
+    using Base::m_l;
+    using Base::m_u;
+    
+    using Base::m_analysisIsOk;
+    using Base::m_factorizationIsOk;
+    using Base::m_extractedDataAreDirty;
+    using Base::m_isInitialized;
+    using Base::m_info;
+
+    void init()
+    {
+      Base::init();
+      
+      ilu_set_default_options(&m_sluOptions);
+      m_sluOptions.PrintStat        = NO;
+      m_sluOptions.ConditionNumber  = NO;
+      m_sluOptions.Trans            = NOTRANS;
+      m_sluOptions.ColPerm          = MMD_AT_PLUS_A;
+      
+      // no attempt to preserve column sum
+      m_sluOptions.ILU_MILU = SILU;
+      // only basic ILU(k) support -- no direct control over memory consumption
+      // better to use ILU_DropRule = DROP_BASIC | DROP_AREA
+      // and set ILU_FillFactor to max memory growth
+      m_sluOptions.ILU_DropRule = DROP_BASIC;
+      m_sluOptions.ILU_DropTol = NumTraits<Scalar>::dummy_precision()*10;
+    }
+    
+  private:
+    SuperILU(SuperILU& ) { }
+};
+
+template<typename MatrixType>
+void SuperILU<MatrixType>::factorize(const MatrixType& a)
+{
+  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  if(!m_analysisIsOk)
+  {
+    m_info = InvalidInput;
+    return;
+  }
+  
+  this->initFactorization(a);
+
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+
+  StatInit(&m_sluStat);
+  SuperLU_gsisx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0],
+                &m_sluEqued, &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+
+  // FIXME how to better check for errors ???
+  m_info = info == 0 ? Success : NumericalIssue;
+  m_factorizationIsOk = true;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template<typename MatrixType>
+template<typename Rhs,typename Dest>
+void SuperILU<MatrixType>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest>& x) const
+{
+  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or analyzePattern()/factorize()");
+
+  const int rhsCols = b.cols();
+  eigen_assert(m_matrix.rows()==b.rows());
+
+  m_sluOptions.Trans = NOTRANS;
+  m_sluOptions.Fact = FACTORED;
+  m_sluOptions.IterRefine = NOREFINE;
+
+  m_sluFerr.resize(rhsCols);
+  m_sluBerr.resize(rhsCols);
+  
+  Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b);
+  Ref<const Matrix<typename Dest::Scalar,Dynamic,Dynamic,ColMajor> > x_ref(x);
+  
+  m_sluB = SluMatrix::Map(b_ref.const_cast_derived());
+  m_sluX = SluMatrix::Map(x_ref.const_cast_derived());
+
+  typename Rhs::PlainObject b_cpy;
+  if(m_sluEqued!='N')
+  {
+    b_cpy = b;
+    m_sluB = SluMatrix::Map(b_cpy.const_cast_derived());  
+  }
+  
+  int info = 0;
+  RealScalar recip_pivot_growth, rcond;
+
+  StatInit(&m_sluStat);
+  SuperLU_gsisx(&m_sluOptions, &m_sluA,
+                m_q.data(), m_p.data(),
+                &m_sluEtree[0], &m_sluEqued,
+                &m_sluRscale[0], &m_sluCscale[0],
+                &m_sluL, &m_sluU,
+                NULL, 0,
+                &m_sluB, &m_sluX,
+                &recip_pivot_growth, &rcond,
+                &m_sluStat, &info, Scalar());
+  StatFree(&m_sluStat);
+  
+  if(x.derived().data() != x_ref.data())
+    x = x_ref;
+
+  m_info = info==0 ? Success : NumericalIssue;
+}
+#endif
+
+#endif
+
+} // end namespace Eigen
+
+#endif // EIGEN_SUPERLUSUPPORT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/UmfPackSupport/UmfPackSupport.h b/C++/yolo_bytetrack_old/include/Eigen/src/UmfPackSupport/UmfPackSupport.h
new file mode 100644
index 00000000..e3a333f8
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/UmfPackSupport/UmfPackSupport.h
@@ -0,0 +1,642 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_UMFPACKSUPPORT_H
+#define EIGEN_UMFPACKSUPPORT_H
+
+// for compatibility with super old version of umfpack,
+// not sure this is really needed, but this is harmless.
+#ifndef SuiteSparse_long
+#ifdef UF_long
+#define SuiteSparse_long UF_long
+#else
+#error neither SuiteSparse_long nor UF_long are defined
+#endif
+#endif
+
+namespace Eigen {
+
+/* TODO extract L, extract U, compute det, etc... */
+
+// generic double/complex<double> wrapper functions:
+
+
+ // Defaults
+inline void umfpack_defaults(double control[UMFPACK_CONTROL], double, int)
+{ umfpack_di_defaults(control); }
+
+inline void umfpack_defaults(double control[UMFPACK_CONTROL], std::complex<double>, int)
+{ umfpack_zi_defaults(control); }
+
+inline void umfpack_defaults(double control[UMFPACK_CONTROL], double, SuiteSparse_long)
+{ umfpack_dl_defaults(control); }
+
+inline void umfpack_defaults(double control[UMFPACK_CONTROL], std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_defaults(control); }
+
+// Report info
+inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, int)
+{ umfpack_di_report_info(control, info);}
+
+inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex<double>, int)
+{ umfpack_zi_report_info(control, info);}
+
+inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], double, SuiteSparse_long)
+{ umfpack_dl_report_info(control, info);}
+
+inline void umfpack_report_info(double control[UMFPACK_CONTROL], double info[UMFPACK_INFO], std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_report_info(control, info);}
+
+// Report status
+inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, double, int)
+{ umfpack_di_report_status(control, status);}
+
+inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, std::complex<double>, int)
+{ umfpack_zi_report_status(control, status);}
+
+inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, double, SuiteSparse_long)
+{ umfpack_dl_report_status(control, status);}
+
+inline void umfpack_report_status(double control[UMFPACK_CONTROL], int status, std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_report_status(control, status);}
+
+// report control
+inline void umfpack_report_control(double control[UMFPACK_CONTROL], double, int)
+{ umfpack_di_report_control(control);}
+
+inline void umfpack_report_control(double control[UMFPACK_CONTROL], std::complex<double>, int)
+{ umfpack_zi_report_control(control);}
+
+inline void umfpack_report_control(double control[UMFPACK_CONTROL], double, SuiteSparse_long)
+{ umfpack_dl_report_control(control);}
+
+inline void umfpack_report_control(double control[UMFPACK_CONTROL], std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_report_control(control);}
+
+// Free numeric
+inline void umfpack_free_numeric(void **Numeric, double, int)
+{ umfpack_di_free_numeric(Numeric); *Numeric = 0; }
+
+inline void umfpack_free_numeric(void **Numeric, std::complex<double>, int)
+{ umfpack_zi_free_numeric(Numeric); *Numeric = 0; }
+
+inline void umfpack_free_numeric(void **Numeric, double, SuiteSparse_long)
+{ umfpack_dl_free_numeric(Numeric); *Numeric = 0; }
+
+inline void umfpack_free_numeric(void **Numeric, std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_free_numeric(Numeric); *Numeric = 0; }
+
+// Free symbolic
+inline void umfpack_free_symbolic(void **Symbolic, double, int)
+{ umfpack_di_free_symbolic(Symbolic); *Symbolic = 0; }
+
+inline void umfpack_free_symbolic(void **Symbolic, std::complex<double>, int)
+{ umfpack_zi_free_symbolic(Symbolic); *Symbolic = 0; }
+
+inline void umfpack_free_symbolic(void **Symbolic, double, SuiteSparse_long)
+{ umfpack_dl_free_symbolic(Symbolic); *Symbolic = 0; }
+
+inline void umfpack_free_symbolic(void **Symbolic, std::complex<double>, SuiteSparse_long)
+{ umfpack_zl_free_symbolic(Symbolic); *Symbolic = 0; }
+
+// Symbolic
+inline int umfpack_symbolic(int n_row,int n_col,
+                            const int Ap[], const int Ai[], const double Ax[], void **Symbolic,
+                            const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
+{
+  return umfpack_di_symbolic(n_row,n_col,Ap,Ai,Ax,Symbolic,Control,Info);
+}
+
+inline int umfpack_symbolic(int n_row,int n_col,
+                            const int Ap[], const int Ai[], const std::complex<double> Ax[], void **Symbolic,
+                            const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
+{
+  return umfpack_zi_symbolic(n_row,n_col,Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Control,Info);
+}
+inline SuiteSparse_long umfpack_symbolic( SuiteSparse_long n_row,SuiteSparse_long n_col,
+                                          const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[], void **Symbolic,
+                                          const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
+{
+  return umfpack_dl_symbolic(n_row,n_col,Ap,Ai,Ax,Symbolic,Control,Info);
+}
+
+inline SuiteSparse_long umfpack_symbolic( SuiteSparse_long n_row,SuiteSparse_long n_col,
+                                          const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex<double> Ax[], void **Symbolic,
+                                          const double Control [UMFPACK_CONTROL], double Info [UMFPACK_INFO])
+{
+  return umfpack_zl_symbolic(n_row,n_col,Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Control,Info);
+}
+
+// Numeric
+inline int umfpack_numeric( const int Ap[], const int Ai[], const double Ax[],
+                            void *Symbolic, void **Numeric,
+                            const double Control[UMFPACK_CONTROL],double Info [UMFPACK_INFO])
+{
+  return umfpack_di_numeric(Ap,Ai,Ax,Symbolic,Numeric,Control,Info);
+}
+
+inline int umfpack_numeric( const int Ap[], const int Ai[], const std::complex<double> Ax[],
+                            void *Symbolic, void **Numeric,
+                            const double Control[UMFPACK_CONTROL],double Info [UMFPACK_INFO])
+{
+  return umfpack_zi_numeric(Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Numeric,Control,Info);
+}
+inline SuiteSparse_long umfpack_numeric(const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[],
+                                        void *Symbolic, void **Numeric,
+                                        const double Control[UMFPACK_CONTROL],double Info [UMFPACK_INFO])
+{
+  return umfpack_dl_numeric(Ap,Ai,Ax,Symbolic,Numeric,Control,Info);
+}
+
+inline SuiteSparse_long umfpack_numeric(const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex<double> Ax[],
+                                        void *Symbolic, void **Numeric,
+                                        const double Control[UMFPACK_CONTROL],double Info [UMFPACK_INFO])
+{
+  return umfpack_zl_numeric(Ap,Ai,&numext::real_ref(Ax[0]),0,Symbolic,Numeric,Control,Info);
+}
+
+// solve
+inline int umfpack_solve( int sys, const int Ap[], const int Ai[], const double Ax[],
+                          double X[], const double B[], void *Numeric,
+                          const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
+{
+  return umfpack_di_solve(sys,Ap,Ai,Ax,X,B,Numeric,Control,Info);
+}
+
+inline int umfpack_solve( int sys, const int Ap[], const int Ai[], const std::complex<double> Ax[],
+                          std::complex<double> X[], const std::complex<double> B[], void *Numeric,
+                          const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
+{
+  return umfpack_zi_solve(sys,Ap,Ai,&numext::real_ref(Ax[0]),0,&numext::real_ref(X[0]),0,&numext::real_ref(B[0]),0,Numeric,Control,Info);
+}
+
+inline SuiteSparse_long umfpack_solve(int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const double Ax[],
+                                      double X[], const double B[], void *Numeric,
+                                      const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
+{
+  return umfpack_dl_solve(sys,Ap,Ai,Ax,X,B,Numeric,Control,Info);
+}
+
+inline SuiteSparse_long umfpack_solve(int sys, const SuiteSparse_long Ap[], const SuiteSparse_long Ai[], const std::complex<double> Ax[],
+                                      std::complex<double> X[], const std::complex<double> B[], void *Numeric,
+                                      const double Control[UMFPACK_CONTROL], double Info[UMFPACK_INFO])
+{
+  return umfpack_zl_solve(sys,Ap,Ai,&numext::real_ref(Ax[0]),0,&numext::real_ref(X[0]),0,&numext::real_ref(B[0]),0,Numeric,Control,Info);
+}
+
+// Get Lunz
+inline int umfpack_get_lunz(int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, double)
+{
+  return umfpack_di_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
+}
+
+inline int umfpack_get_lunz(int *lnz, int *unz, int *n_row, int *n_col, int *nz_udiag, void *Numeric, std::complex<double>)
+{
+  return umfpack_zi_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
+}
+
+inline SuiteSparse_long umfpack_get_lunz( SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row, SuiteSparse_long *n_col,
+                                          SuiteSparse_long *nz_udiag, void *Numeric, double)
+{
+  return umfpack_dl_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
+}
+
+inline SuiteSparse_long umfpack_get_lunz( SuiteSparse_long *lnz, SuiteSparse_long *unz, SuiteSparse_long *n_row, SuiteSparse_long *n_col,
+                                          SuiteSparse_long *nz_udiag, void *Numeric, std::complex<double>)
+{
+  return umfpack_zl_get_lunz(lnz,unz,n_row,n_col,nz_udiag,Numeric);
+}
+
+// Get Numeric
+inline int umfpack_get_numeric(int Lp[], int Lj[], double Lx[], int Up[], int Ui[], double Ux[],
+                               int P[], int Q[], double Dx[], int *do_recip, double Rs[], void *Numeric)
+{
+  return umfpack_di_get_numeric(Lp,Lj,Lx,Up,Ui,Ux,P,Q,Dx,do_recip,Rs,Numeric);
+}
+
+inline int umfpack_get_numeric(int Lp[], int Lj[], std::complex<double> Lx[], int Up[], int Ui[], std::complex<double> Ux[],
+                               int P[], int Q[], std::complex<double> Dx[], int *do_recip, double Rs[], void *Numeric)
+{
+  double& lx0_real = numext::real_ref(Lx[0]);
+  double& ux0_real = numext::real_ref(Ux[0]);
+  double& dx0_real = numext::real_ref(Dx[0]);
+  return umfpack_zi_get_numeric(Lp,Lj,Lx?&lx0_real:0,0,Up,Ui,Ux?&ux0_real:0,0,P,Q,
+                                Dx?&dx0_real:0,0,do_recip,Rs,Numeric);
+}
+inline SuiteSparse_long umfpack_get_numeric(SuiteSparse_long Lp[], SuiteSparse_long Lj[], double Lx[], SuiteSparse_long Up[], SuiteSparse_long Ui[], double Ux[],
+                                            SuiteSparse_long P[], SuiteSparse_long Q[], double Dx[], SuiteSparse_long *do_recip, double Rs[], void *Numeric)
+{
+  return umfpack_dl_get_numeric(Lp,Lj,Lx,Up,Ui,Ux,P,Q,Dx,do_recip,Rs,Numeric);
+}
+
+inline SuiteSparse_long umfpack_get_numeric(SuiteSparse_long Lp[], SuiteSparse_long Lj[], std::complex<double> Lx[], SuiteSparse_long Up[], SuiteSparse_long Ui[], std::complex<double> Ux[],
+                                            SuiteSparse_long P[], SuiteSparse_long Q[], std::complex<double> Dx[], SuiteSparse_long *do_recip, double Rs[], void *Numeric)
+{
+  double& lx0_real = numext::real_ref(Lx[0]);
+  double& ux0_real = numext::real_ref(Ux[0]);
+  double& dx0_real = numext::real_ref(Dx[0]);
+  return umfpack_zl_get_numeric(Lp,Lj,Lx?&lx0_real:0,0,Up,Ui,Ux?&ux0_real:0,0,P,Q,
+                                Dx?&dx0_real:0,0,do_recip,Rs,Numeric);
+}
+
+// Get Determinant
+inline int umfpack_get_determinant(double *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], int)
+{
+  return umfpack_di_get_determinant(Mx,Ex,NumericHandle,User_Info);
+}
+
+inline int umfpack_get_determinant(std::complex<double> *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], int)
+{
+  double& mx_real = numext::real_ref(*Mx);
+  return umfpack_zi_get_determinant(&mx_real,0,Ex,NumericHandle,User_Info);
+}
+
+inline SuiteSparse_long umfpack_get_determinant(double *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], SuiteSparse_long)
+{
+  return umfpack_dl_get_determinant(Mx,Ex,NumericHandle,User_Info);
+}
+
+inline SuiteSparse_long umfpack_get_determinant(std::complex<double> *Mx, double *Ex, void *NumericHandle, double User_Info [UMFPACK_INFO], SuiteSparse_long)
+{
+  double& mx_real = numext::real_ref(*Mx);
+  return umfpack_zl_get_determinant(&mx_real,0,Ex,NumericHandle,User_Info);
+}
+
+
+/** \ingroup UmfPackSupport_Module
+  * \brief A sparse LU factorization and solver based on UmfPack
+  *
+  * This class allows to solve for A.X = B sparse linear problems via a LU factorization
+  * using the UmfPack library. The sparse matrix A must be squared and full rank.
+  * The vectors or matrices X and B can be either dense or sparse.
+  *
+  * \warning The input matrix A should be in a \b compressed and \b column-major form.
+  * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
+  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
+  *
+  * \implsparsesolverconcept
+  *
+  * \sa \ref TutorialSparseSolverConcept, class SparseLU
+  */
+template<typename _MatrixType>
+class UmfPackLU : public SparseSolverBase<UmfPackLU<_MatrixType> >
+{
+  protected:
+    typedef SparseSolverBase<UmfPackLU<_MatrixType> > Base;
+    using Base::m_isInitialized;
+  public:
+    using Base::_solve_impl;
+    typedef _MatrixType MatrixType;
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    typedef typename MatrixType::StorageIndex StorageIndex;
+    typedef Matrix<Scalar,Dynamic,1> Vector;
+    typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
+    typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
+    typedef SparseMatrix<Scalar> LUMatrixType;
+    typedef SparseMatrix<Scalar,ColMajor,StorageIndex> UmfpackMatrixType;
+    typedef Ref<const UmfpackMatrixType, StandardCompressedFormat> UmfpackMatrixRef;
+    enum {
+      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+    };
+
+  public:
+
+    typedef Array<double, UMFPACK_CONTROL, 1> UmfpackControl;
+    typedef Array<double, UMFPACK_INFO, 1> UmfpackInfo;
+
+    UmfPackLU()
+      : m_dummy(0,0), mp_matrix(m_dummy)
+    {
+      init();
+    }
+
+    template<typename InputMatrixType>
+    explicit UmfPackLU(const InputMatrixType& matrix)
+      : mp_matrix(matrix)
+    {
+      init();
+      compute(matrix);
+    }
+
+    ~UmfPackLU()
+    {
+      if(m_symbolic) umfpack_free_symbolic(&m_symbolic,Scalar(), StorageIndex());
+      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar(), StorageIndex());
+    }
+
+    inline Index rows() const { return mp_matrix.rows(); }
+    inline Index cols() const { return mp_matrix.cols(); }
+
+    /** \brief Reports whether previous computation was successful.
+      *
+      * \returns \c Success if computation was successful,
+      *          \c NumericalIssue if the matrix.appears to be negative.
+      */
+    ComputationInfo info() const
+    {
+      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+      return m_info;
+    }
+
+    inline const LUMatrixType& matrixL() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_l;
+    }
+
+    inline const LUMatrixType& matrixU() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_u;
+    }
+
+    inline const IntColVectorType& permutationP() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_p;
+    }
+
+    inline const IntRowVectorType& permutationQ() const
+    {
+      if (m_extractedDataAreDirty) extractData();
+      return m_q;
+    }
+
+    /** Computes the sparse Cholesky decomposition of \a matrix
+     *  Note that the matrix should be column-major, and in compressed format for best performance.
+     *  \sa SparseMatrix::makeCompressed().
+     */
+    template<typename InputMatrixType>
+    void compute(const InputMatrixType& matrix)
+    {
+      if(m_symbolic) umfpack_free_symbolic(&m_symbolic,Scalar(),StorageIndex());
+      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar(),StorageIndex());
+      grab(matrix.derived());
+      analyzePattern_impl();
+      factorize_impl();
+    }
+
+    /** Performs a symbolic decomposition on the sparcity of \a matrix.
+      *
+      * This function is particularly useful when solving for several problems having the same structure.
+      *
+      * \sa factorize(), compute()
+      */
+    template<typename InputMatrixType>
+    void analyzePattern(const InputMatrixType& matrix)
+    {
+      if(m_symbolic) umfpack_free_symbolic(&m_symbolic,Scalar(),StorageIndex());
+      if(m_numeric)  umfpack_free_numeric(&m_numeric,Scalar(),StorageIndex());
+
+      grab(matrix.derived());
+
+      analyzePattern_impl();
+    }
+
+    /** Provides the return status code returned by UmfPack during the numeric
+      * factorization.
+      *
+      * \sa factorize(), compute()
+      */
+    inline int umfpackFactorizeReturncode() const
+    {
+      eigen_assert(m_numeric && "UmfPackLU: you must first call factorize()");
+      return m_fact_errorCode;
+    }
+
+    /** Provides access to the control settings array used by UmfPack.
+      *
+      * If this array contains NaN's, the default values are used.
+      *
+      * See UMFPACK documentation for details.
+      */
+    inline const UmfpackControl& umfpackControl() const
+    {
+      return m_control;
+    }
+
+    /** Provides access to the control settings array used by UmfPack.
+      *
+      * If this array contains NaN's, the default values are used.
+      *
+      * See UMFPACK documentation for details.
+      */
+    inline UmfpackControl& umfpackControl()
+    {
+      return m_control;
+    }
+
+    /** Performs a numeric decomposition of \a matrix
+      *
+      * The given matrix must has the same sparcity than the matrix on which the pattern anylysis has been performed.
+      *
+      * \sa analyzePattern(), compute()
+      */
+    template<typename InputMatrixType>
+    void factorize(const InputMatrixType& matrix)
+    {
+      eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
+      if(m_numeric)
+        umfpack_free_numeric(&m_numeric,Scalar(),StorageIndex());
+
+      grab(matrix.derived());
+
+      factorize_impl();
+    }
+
+    /** Prints the current UmfPack control settings.
+      *
+      * \sa umfpackControl()
+      */
+    void printUmfpackControl()
+    {
+      umfpack_report_control(m_control.data(), Scalar(),StorageIndex());
+    }
+
+    /** Prints statistics collected by UmfPack.
+      *
+      * \sa analyzePattern(), compute()
+      */
+    void printUmfpackInfo()
+    {
+      eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
+      umfpack_report_info(m_control.data(), m_umfpackInfo.data(), Scalar(),StorageIndex());
+    }
+
+    /** Prints the status of the previous factorization operation performed by UmfPack (symbolic or numerical factorization).
+      *
+      * \sa analyzePattern(), compute()
+      */
+    void printUmfpackStatus() {
+      eigen_assert(m_analysisIsOk && "UmfPackLU: you must first call analyzePattern()");
+      umfpack_report_status(m_control.data(), m_fact_errorCode, Scalar(),StorageIndex());
+    }
+
+    /** \internal */
+    template<typename BDerived,typename XDerived>
+    bool _solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const;
+
+    Scalar determinant() const;
+
+    void extractData() const;
+
+  protected:
+
+    void init()
+    {
+      m_info                  = InvalidInput;
+      m_isInitialized         = false;
+      m_numeric               = 0;
+      m_symbolic              = 0;
+      m_extractedDataAreDirty = true;
+
+      umfpack_defaults(m_control.data(), Scalar(),StorageIndex());
+    }
+
+    void analyzePattern_impl()
+    {
+      m_fact_errorCode = umfpack_symbolic(internal::convert_index<StorageIndex>(mp_matrix.rows()),
+                                          internal::convert_index<StorageIndex>(mp_matrix.cols()),
+                                          mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
+                                          &m_symbolic, m_control.data(), m_umfpackInfo.data());
+
+      m_isInitialized = true;
+      m_info = m_fact_errorCode ? InvalidInput : Success;
+      m_analysisIsOk = true;
+      m_factorizationIsOk = false;
+      m_extractedDataAreDirty = true;
+    }
+
+    void factorize_impl()
+    {
+
+      m_fact_errorCode = umfpack_numeric(mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
+                                         m_symbolic, &m_numeric, m_control.data(), m_umfpackInfo.data());
+
+      m_info = m_fact_errorCode == UMFPACK_OK ? Success : NumericalIssue;
+      m_factorizationIsOk = true;
+      m_extractedDataAreDirty = true;
+    }
+
+    template<typename MatrixDerived>
+    void grab(const EigenBase<MatrixDerived> &A)
+    {
+      mp_matrix.~UmfpackMatrixRef();
+      ::new (&mp_matrix) UmfpackMatrixRef(A.derived());
+    }
+
+    void grab(const UmfpackMatrixRef &A)
+    {
+      if(&(A.derived()) != &mp_matrix)
+      {
+        mp_matrix.~UmfpackMatrixRef();
+        ::new (&mp_matrix) UmfpackMatrixRef(A);
+      }
+    }
+
+    // cached data to reduce reallocation, etc.
+    mutable LUMatrixType m_l;
+    StorageIndex m_fact_errorCode;
+    UmfpackControl m_control;
+    mutable UmfpackInfo m_umfpackInfo;
+
+    mutable LUMatrixType m_u;
+    mutable IntColVectorType m_p;
+    mutable IntRowVectorType m_q;
+
+    UmfpackMatrixType m_dummy;
+    UmfpackMatrixRef mp_matrix;
+
+    void* m_numeric;
+    void* m_symbolic;
+
+    mutable ComputationInfo m_info;
+    int m_factorizationIsOk;
+    int m_analysisIsOk;
+    mutable bool m_extractedDataAreDirty;
+
+  private:
+    UmfPackLU(const UmfPackLU& ) { }
+};
+
+
+template<typename MatrixType>
+void UmfPackLU<MatrixType>::extractData() const
+{
+  if (m_extractedDataAreDirty)
+  {
+    // get size of the data
+    StorageIndex lnz, unz, rows, cols, nz_udiag;
+    umfpack_get_lunz(&lnz, &unz, &rows, &cols, &nz_udiag, m_numeric, Scalar());
+
+    // allocate data
+    m_l.resize(rows,(std::min)(rows,cols));
+    m_l.resizeNonZeros(lnz);
+
+    m_u.resize((std::min)(rows,cols),cols);
+    m_u.resizeNonZeros(unz);
+
+    m_p.resize(rows);
+    m_q.resize(cols);
+
+    // extract
+    umfpack_get_numeric(m_l.outerIndexPtr(), m_l.innerIndexPtr(), m_l.valuePtr(),
+                        m_u.outerIndexPtr(), m_u.innerIndexPtr(), m_u.valuePtr(),
+                        m_p.data(), m_q.data(), 0, 0, 0, m_numeric);
+
+    m_extractedDataAreDirty = false;
+  }
+}
+
+template<typename MatrixType>
+typename UmfPackLU<MatrixType>::Scalar UmfPackLU<MatrixType>::determinant() const
+{
+  Scalar det;
+  umfpack_get_determinant(&det, 0, m_numeric, 0, StorageIndex());
+  return det;
+}
+
+template<typename MatrixType>
+template<typename BDerived,typename XDerived>
+bool UmfPackLU<MatrixType>::_solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const
+{
+  Index rhsCols = b.cols();
+  eigen_assert((BDerived::Flags&RowMajorBit)==0 && "UmfPackLU backend does not support non col-major rhs yet");
+  eigen_assert((XDerived::Flags&RowMajorBit)==0 && "UmfPackLU backend does not support non col-major result yet");
+  eigen_assert(b.derived().data() != x.derived().data() && " Umfpack does not support inplace solve");
+
+  Scalar* x_ptr = 0;
+  Matrix<Scalar,Dynamic,1> x_tmp;
+  if(x.innerStride()!=1)
+  {
+    x_tmp.resize(x.rows());
+    x_ptr = x_tmp.data();
+  }
+  for (int j=0; j<rhsCols; ++j)
+  {
+    if(x.innerStride()==1)
+      x_ptr = &x.col(j).coeffRef(0);
+    StorageIndex errorCode = umfpack_solve(UMFPACK_A,
+                                mp_matrix.outerIndexPtr(), mp_matrix.innerIndexPtr(), mp_matrix.valuePtr(),
+                                x_ptr, &b.const_cast_derived().col(j).coeffRef(0),
+                                m_numeric, m_control.data(), m_umfpackInfo.data());
+    if(x.innerStride()!=1)
+      x.col(j) = x_tmp;
+    if (errorCode!=0)
+      return false;
+  }
+
+  return true;
+}
+
+} // end namespace Eigen
+
+#endif // EIGEN_UMFPACKSUPPORT_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/misc/Image.h b/C++/yolo_bytetrack_old/include/Eigen/src/misc/Image.h
new file mode 100644
index 00000000..b8b8a045
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/misc/Image.h
@@ -0,0 +1,82 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MISC_IMAGE_H
+#define EIGEN_MISC_IMAGE_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \class image_retval_base
+  *
+  */
+template<typename DecompositionType>
+struct traits<image_retval_base<DecompositionType> >
+{
+  typedef typename DecompositionType::MatrixType MatrixType;
+  typedef Matrix<
+    typename MatrixType::Scalar,
+    MatrixType::RowsAtCompileTime, // the image is a subspace of the destination space, whose
+                                   // dimension is the number of rows of the original matrix
+    Dynamic,                       // we don't know at compile time the dimension of the image (the rank)
+    MatrixType::Options,
+    MatrixType::MaxRowsAtCompileTime, // the image matrix will consist of columns from the original matrix,
+    MatrixType::MaxColsAtCompileTime  // so it has the same number of rows and at most as many columns.
+  > ReturnType;
+};
+
+template<typename _DecompositionType> struct image_retval_base
+ : public ReturnByValue<image_retval_base<_DecompositionType> >
+{
+  typedef _DecompositionType DecompositionType;
+  typedef typename DecompositionType::MatrixType MatrixType;
+  typedef ReturnByValue<image_retval_base> Base;
+
+  image_retval_base(const DecompositionType& dec, const MatrixType& originalMatrix)
+    : m_dec(dec), m_rank(dec.rank()),
+      m_cols(m_rank == 0 ? 1 : m_rank),
+      m_originalMatrix(originalMatrix)
+  {}
+
+  inline Index rows() const { return m_dec.rows(); }
+  inline Index cols() const { return m_cols; }
+  inline Index rank() const { return m_rank; }
+  inline const DecompositionType& dec() const { return m_dec; }
+  inline const MatrixType& originalMatrix() const { return m_originalMatrix; }
+
+  template<typename Dest> inline void evalTo(Dest& dst) const
+  {
+    static_cast<const image_retval<DecompositionType>*>(this)->evalTo(dst);
+  }
+
+  protected:
+    const DecompositionType& m_dec;
+    Index m_rank, m_cols;
+    const MatrixType& m_originalMatrix;
+};
+
+} // end namespace internal
+
+#define EIGEN_MAKE_IMAGE_HELPERS(DecompositionType) \
+  typedef typename DecompositionType::MatrixType MatrixType; \
+  typedef typename MatrixType::Scalar Scalar; \
+  typedef typename MatrixType::RealScalar RealScalar; \
+  typedef Eigen::internal::image_retval_base<DecompositionType> Base; \
+  using Base::dec; \
+  using Base::originalMatrix; \
+  using Base::rank; \
+  using Base::rows; \
+  using Base::cols; \
+  image_retval(const DecompositionType& dec, const MatrixType& originalMatrix) \
+    : Base(dec, originalMatrix) {}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MISC_IMAGE_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/misc/Kernel.h b/C++/yolo_bytetrack_old/include/Eigen/src/misc/Kernel.h
new file mode 100644
index 00000000..bef5d6ff
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/misc/Kernel.h
@@ -0,0 +1,79 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_MISC_KERNEL_H
+#define EIGEN_MISC_KERNEL_H
+
+namespace Eigen { 
+
+namespace internal {
+
+/** \class kernel_retval_base
+  *
+  */
+template<typename DecompositionType>
+struct traits<kernel_retval_base<DecompositionType> >
+{
+  typedef typename DecompositionType::MatrixType MatrixType;
+  typedef Matrix<
+    typename MatrixType::Scalar,
+    MatrixType::ColsAtCompileTime, // the number of rows in the "kernel matrix"
+                                   // is the number of cols of the original matrix
+                                   // so that the product "matrix * kernel = zero" makes sense
+    Dynamic,                       // we don't know at compile-time the dimension of the kernel
+    MatrixType::Options,
+    MatrixType::MaxColsAtCompileTime, // see explanation for 2nd template parameter
+    MatrixType::MaxColsAtCompileTime // the kernel is a subspace of the domain space,
+                                     // whose dimension is the number of columns of the original matrix
+  > ReturnType;
+};
+
+template<typename _DecompositionType> struct kernel_retval_base
+ : public ReturnByValue<kernel_retval_base<_DecompositionType> >
+{
+  typedef _DecompositionType DecompositionType;
+  typedef ReturnByValue<kernel_retval_base> Base;
+
+  explicit kernel_retval_base(const DecompositionType& dec)
+    : m_dec(dec),
+      m_rank(dec.rank()),
+      m_cols(m_rank==dec.cols() ? 1 : dec.cols() - m_rank)
+  {}
+
+  inline Index rows() const { return m_dec.cols(); }
+  inline Index cols() const { return m_cols; }
+  inline Index rank() const { return m_rank; }
+  inline const DecompositionType& dec() const { return m_dec; }
+
+  template<typename Dest> inline void evalTo(Dest& dst) const
+  {
+    static_cast<const kernel_retval<DecompositionType>*>(this)->evalTo(dst);
+  }
+
+  protected:
+    const DecompositionType& m_dec;
+    Index m_rank, m_cols;
+};
+
+} // end namespace internal
+
+#define EIGEN_MAKE_KERNEL_HELPERS(DecompositionType) \
+  typedef typename DecompositionType::MatrixType MatrixType; \
+  typedef typename MatrixType::Scalar Scalar; \
+  typedef typename MatrixType::RealScalar RealScalar; \
+  typedef Eigen::internal::kernel_retval_base<DecompositionType> Base; \
+  using Base::dec; \
+  using Base::rank; \
+  using Base::rows; \
+  using Base::cols; \
+  kernel_retval(const DecompositionType& dec) : Base(dec) {}
+
+} // end namespace Eigen
+
+#endif // EIGEN_MISC_KERNEL_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/misc/RealSvd2x2.h b/C++/yolo_bytetrack_old/include/Eigen/src/misc/RealSvd2x2.h
new file mode 100644
index 00000000..abb4d3c2
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/misc/RealSvd2x2.h
@@ -0,0 +1,55 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2013-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_REALSVD2X2_H
+#define EIGEN_REALSVD2X2_H
+
+namespace Eigen {
+
+namespace internal {
+
+template<typename MatrixType, typename RealScalar, typename Index>
+void real_2x2_jacobi_svd(const MatrixType& matrix, Index p, Index q,
+                         JacobiRotation<RealScalar> *j_left,
+                         JacobiRotation<RealScalar> *j_right)
+{
+  using std::sqrt;
+  using std::abs;
+  Matrix<RealScalar,2,2> m;
+  m << numext::real(matrix.coeff(p,p)), numext::real(matrix.coeff(p,q)),
+       numext::real(matrix.coeff(q,p)), numext::real(matrix.coeff(q,q));
+  JacobiRotation<RealScalar> rot1;
+  RealScalar t = m.coeff(0,0) + m.coeff(1,1);
+  RealScalar d = m.coeff(1,0) - m.coeff(0,1);
+
+  if(abs(d) < (std::numeric_limits<RealScalar>::min)())
+  {
+    rot1.s() = RealScalar(0);
+    rot1.c() = RealScalar(1);
+  }
+  else
+  {
+    // If d!=0, then t/d cannot overflow because the magnitude of the
+    // entries forming d are not too small compared to the ones forming t.
+    RealScalar u = t / d;
+    RealScalar tmp = sqrt(RealScalar(1) + numext::abs2(u));
+    rot1.s() = RealScalar(1) / tmp;
+    rot1.c() = u / tmp;
+  }
+  m.applyOnTheLeft(0,1,rot1);
+  j_right->makeJacobi(m,0,1);
+  *j_left = rot1 * j_right->transpose();
+}
+
+} // end namespace internal
+
+} // end namespace Eigen
+
+#endif // EIGEN_REALSVD2X2_H
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/misc/blas.h b/C++/yolo_bytetrack_old/include/Eigen/src/misc/blas.h
new file mode 100644
index 00000000..25215b15
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/misc/blas.h
@@ -0,0 +1,440 @@
+#ifndef BLAS_H
+#define BLAS_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define BLASFUNC(FUNC) FUNC##_
+
+#ifdef __WIN64__
+typedef long long BLASLONG;
+typedef unsigned long long BLASULONG;
+#else
+typedef long BLASLONG;
+typedef unsigned long BLASULONG;
+#endif
+
+int    BLASFUNC(xerbla)(const char *, int *info, int);
+
+float  BLASFUNC(sdot)  (int *, float  *, int *, float  *, int *);
+float  BLASFUNC(sdsdot)(int *, float  *,        float  *, int *, float  *, int *);
+
+double BLASFUNC(dsdot) (int *, float  *, int *, float  *, int *);
+double BLASFUNC(ddot)  (int *, double *, int *, double *, int *);
+double BLASFUNC(qdot)  (int *, double *, int *, double *, int *);
+
+int  BLASFUNC(cdotuw)  (int *, float  *, int *, float  *, int *, float*);
+int  BLASFUNC(cdotcw)  (int *, float  *, int *, float  *, int *, float*);
+int  BLASFUNC(zdotuw)  (int *, double  *, int *, double  *, int *, double*);
+int  BLASFUNC(zdotcw)  (int *, double  *, int *, double  *, int *, double*);
+
+int    BLASFUNC(saxpy) (const int *, const float  *, const float  *, const int *, float  *, const int *);
+int    BLASFUNC(daxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(qaxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(caxpy) (const int *, const float  *, const float  *, const int *, float  *, const int *);
+int    BLASFUNC(zaxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(xaxpy) (const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(caxpyc)(const int *, const float  *, const float  *, const int *, float  *, const int *);
+int    BLASFUNC(zaxpyc)(const int *, const double *, const double *, const int *, double *, const int *);
+int    BLASFUNC(xaxpyc)(const int *, const double *, const double *, const int *, double *, const int *);
+
+int    BLASFUNC(scopy) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(dcopy) (int *, double *, int *, double *, int *);
+int    BLASFUNC(qcopy) (int *, double *, int *, double *, int *);
+int    BLASFUNC(ccopy) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(zcopy) (int *, double *, int *, double *, int *);
+int    BLASFUNC(xcopy) (int *, double *, int *, double *, int *);
+
+int    BLASFUNC(sswap) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(dswap) (int *, double *, int *, double *, int *);
+int    BLASFUNC(qswap) (int *, double *, int *, double *, int *);
+int    BLASFUNC(cswap) (int *, float  *, int *, float  *, int *);
+int    BLASFUNC(zswap) (int *, double *, int *, double *, int *);
+int    BLASFUNC(xswap) (int *, double *, int *, double *, int *);
+
+float  BLASFUNC(sasum) (int *, float  *, int *);
+float  BLASFUNC(scasum)(int *, float  *, int *);
+double BLASFUNC(dasum) (int *, double *, int *);
+double BLASFUNC(qasum) (int *, double *, int *);
+double BLASFUNC(dzasum)(int *, double *, int *);
+double BLASFUNC(qxasum)(int *, double *, int *);
+
+int    BLASFUNC(isamax)(int *, float  *, int *);
+int    BLASFUNC(idamax)(int *, double *, int *);
+int    BLASFUNC(iqamax)(int *, double *, int *);
+int    BLASFUNC(icamax)(int *, float  *, int *);
+int    BLASFUNC(izamax)(int *, double *, int *);
+int    BLASFUNC(ixamax)(int *, double *, int *);
+
+int    BLASFUNC(ismax) (int *, float  *, int *);
+int    BLASFUNC(idmax) (int *, double *, int *);
+int    BLASFUNC(iqmax) (int *, double *, int *);
+int    BLASFUNC(icmax) (int *, float  *, int *);
+int    BLASFUNC(izmax) (int *, double *, int *);
+int    BLASFUNC(ixmax) (int *, double *, int *);
+
+int    BLASFUNC(isamin)(int *, float  *, int *);
+int    BLASFUNC(idamin)(int *, double *, int *);
+int    BLASFUNC(iqamin)(int *, double *, int *);
+int    BLASFUNC(icamin)(int *, float  *, int *);
+int    BLASFUNC(izamin)(int *, double *, int *);
+int    BLASFUNC(ixamin)(int *, double *, int *);
+
+int    BLASFUNC(ismin)(int *, float  *, int *);
+int    BLASFUNC(idmin)(int *, double *, int *);
+int    BLASFUNC(iqmin)(int *, double *, int *);
+int    BLASFUNC(icmin)(int *, float  *, int *);
+int    BLASFUNC(izmin)(int *, double *, int *);
+int    BLASFUNC(ixmin)(int *, double *, int *);
+
+float  BLASFUNC(samax) (int *, float  *, int *);
+double BLASFUNC(damax) (int *, double *, int *);
+double BLASFUNC(qamax) (int *, double *, int *);
+float  BLASFUNC(scamax)(int *, float  *, int *);
+double BLASFUNC(dzamax)(int *, double *, int *);
+double BLASFUNC(qxamax)(int *, double *, int *);
+
+float  BLASFUNC(samin) (int *, float  *, int *);
+double BLASFUNC(damin) (int *, double *, int *);
+double BLASFUNC(qamin) (int *, double *, int *);
+float  BLASFUNC(scamin)(int *, float  *, int *);
+double BLASFUNC(dzamin)(int *, double *, int *);
+double BLASFUNC(qxamin)(int *, double *, int *);
+
+float  BLASFUNC(smax)  (int *, float  *, int *);
+double BLASFUNC(dmax)  (int *, double *, int *);
+double BLASFUNC(qmax)  (int *, double *, int *);
+float  BLASFUNC(scmax) (int *, float  *, int *);
+double BLASFUNC(dzmax) (int *, double *, int *);
+double BLASFUNC(qxmax) (int *, double *, int *);
+
+float  BLASFUNC(smin)  (int *, float  *, int *);
+double BLASFUNC(dmin)  (int *, double *, int *);
+double BLASFUNC(qmin)  (int *, double *, int *);
+float  BLASFUNC(scmin) (int *, float  *, int *);
+double BLASFUNC(dzmin) (int *, double *, int *);
+double BLASFUNC(qxmin) (int *, double *, int *);
+
+int    BLASFUNC(sscal) (int *,  float  *, float  *, int *);
+int    BLASFUNC(dscal) (int *,  double *, double *, int *);
+int    BLASFUNC(qscal) (int *,  double *, double *, int *);
+int    BLASFUNC(cscal) (int *,  float  *, float  *, int *);
+int    BLASFUNC(zscal) (int *,  double *, double *, int *);
+int    BLASFUNC(xscal) (int *,  double *, double *, int *);
+int    BLASFUNC(csscal)(int *,  float  *, float  *, int *);
+int    BLASFUNC(zdscal)(int *,  double *, double *, int *);
+int    BLASFUNC(xqscal)(int *,  double *, double *, int *);
+
+float  BLASFUNC(snrm2) (int *, float  *, int *);
+float  BLASFUNC(scnrm2)(int *, float  *, int *);
+
+double BLASFUNC(dnrm2) (int *, double *, int *);
+double BLASFUNC(qnrm2) (int *, double *, int *);
+double BLASFUNC(dznrm2)(int *, double *, int *);
+double BLASFUNC(qxnrm2)(int *, double *, int *);
+
+int    BLASFUNC(srot)  (int *, float  *, int *, float  *, int *, float  *, float  *);
+int    BLASFUNC(drot)  (int *, double *, int *, double *, int *, double *, double *);
+int    BLASFUNC(qrot)  (int *, double *, int *, double *, int *, double *, double *);
+int    BLASFUNC(csrot) (int *, float  *, int *, float  *, int *, float  *, float  *);
+int    BLASFUNC(zdrot) (int *, double *, int *, double *, int *, double *, double *);
+int    BLASFUNC(xqrot) (int *, double *, int *, double *, int *, double *, double *);
+
+int    BLASFUNC(srotg) (float  *, float  *, float  *, float  *);
+int    BLASFUNC(drotg) (double *, double *, double *, double *);
+int    BLASFUNC(qrotg) (double *, double *, double *, double *);
+int    BLASFUNC(crotg) (float  *, float  *, float  *, float  *);
+int    BLASFUNC(zrotg) (double *, double *, double *, double *);
+int    BLASFUNC(xrotg) (double *, double *, double *, double *);
+
+int    BLASFUNC(srotmg)(float  *, float  *, float  *, float  *, float  *);
+int    BLASFUNC(drotmg)(double *, double *, double *, double *, double *);
+
+int    BLASFUNC(srotm) (int *, float  *, int *, float  *, int *, float  *);
+int    BLASFUNC(drotm) (int *, double *, int *, double *, int *, double *);
+int    BLASFUNC(qrotm) (int *, double *, int *, double *, int *, double *);
+
+/* Level 2 routines */
+
+int BLASFUNC(sger)(int *,    int *, float *,  float *, int *,
+		   float *,  int *, float *,  int *);
+int BLASFUNC(dger)(int *,    int *, double *, double *, int *,
+		   double *, int *, double *, int *);
+int BLASFUNC(qger)(int *,    int *, double *, double *, int *,
+		   double *, int *, double *, int *);
+int BLASFUNC(cgeru)(int *,    int *, float *,  float *, int *,
+		    float *,  int *, float *,  int *);
+int BLASFUNC(cgerc)(int *,    int *, float *,  float *, int *,
+		    float *,  int *, float *,  int *);
+int BLASFUNC(zgeru)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+int BLASFUNC(zgerc)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+int BLASFUNC(xgeru)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+int BLASFUNC(xgerc)(int *,    int *, double *, double *, int *,
+		    double *, int *, double *, int *);
+
+int BLASFUNC(sgemv)(const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(cgemv)(const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xgemv)(const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(strsv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dtrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrsv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(ztrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrsv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(stpsv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(dtpsv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(qtpsv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(ctpsv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(ztpsv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(xtpsv) (char *, char *, char *, int *, double *, double *, int *);
+
+int BLASFUNC(strmv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dtrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrmv) (const char *, const char *, const char *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(ztrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrmv) (const char *, const char *, const char *, const int *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(stpmv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(dtpmv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(qtpmv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(ctpmv) (char *, char *, char *, int *, float  *, float  *, int *);
+int BLASFUNC(ztpmv) (char *, char *, char *, int *, double *, double *, int *);
+int BLASFUNC(xtpmv) (char *, char *, char *, int *, double *, double *, int *);
+
+int BLASFUNC(stbmv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(dtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(qtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(ctbmv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(ztbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(xtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+
+int BLASFUNC(stbsv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(dtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(qtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(ctbsv) (char *, char *, char *, int *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(ztbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+int BLASFUNC(xtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *);
+
+int BLASFUNC(ssymv) (const char *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(sspmv) (char *, int *, float  *, float *,
+		     float  *, int *, float *, float *, int *);
+int BLASFUNC(dspmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+int BLASFUNC(qspmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+
+int BLASFUNC(ssyr) (const char *, const int *, const float   *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dsyr) (const char *, const int *, const double  *, const double *, const int *, double *, const int *);
+int BLASFUNC(qsyr) (const char *, const int *, const double  *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(ssyr2) (const char *, const int *, const float   *, const float  *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(dsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(qsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(csyr2) (const char *, const int *, const float   *, const float  *, const int *, const float  *, const int *, float  *, const int *);
+int BLASFUNC(zsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+int BLASFUNC(xsyr2) (const char *, const int *, const double  *, const double *, const int *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(sspr) (char *, int *, float   *, float  *, int *,
+		    float  *);
+int BLASFUNC(dspr) (char *, int *, double  *, double *, int *,
+		    double *);
+int BLASFUNC(qspr) (char *, int *, double  *, double *, int *,
+		    double *);
+
+int BLASFUNC(sspr2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *);
+int BLASFUNC(dspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(qspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(cspr2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *);
+int BLASFUNC(zspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(xspr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+
+int BLASFUNC(cher) (char *, int *, float   *, float  *, int *,
+		    float  *, int *);
+int BLASFUNC(zher) (char *, int *, double  *, double *, int *,
+		    double *, int *);
+int BLASFUNC(xher) (char *, int *, double  *, double *, int *,
+		    double *, int *);
+
+int BLASFUNC(chpr) (char *, int *, float   *, float  *, int *, float  *);
+int BLASFUNC(zhpr) (char *, int *, double  *, double *, int *, double *);
+int BLASFUNC(xhpr) (char *, int *, double  *, double *, int *, double *);
+
+int BLASFUNC(cher2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *, int *);
+int BLASFUNC(zher2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *, int *);
+int BLASFUNC(xher2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *, int *);
+
+int BLASFUNC(chpr2) (char *, int *, float   *,
+		     float  *, int *, float  *, int *, float  *);
+int BLASFUNC(zhpr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+int BLASFUNC(xhpr2) (char *, int *, double  *,
+		     double *, int *, double *, int *, double *);
+
+int BLASFUNC(chemv) (const char *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zhemv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xhemv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(chpmv) (char *, int *, float  *, float *,
+		     float  *, int *, float *, float *, int *);
+int BLASFUNC(zhpmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+int BLASFUNC(xhpmv) (char *, int *, double  *, double *,
+		     double  *, int *, double *, double *, int *);
+
+int BLASFUNC(snorm)(char *, int *, int *, float  *, int *);
+int BLASFUNC(dnorm)(char *, int *, int *, double *, int *);
+int BLASFUNC(cnorm)(char *, int *, int *, float  *, int *);
+int BLASFUNC(znorm)(char *, int *, int *, double *, int *);
+
+int BLASFUNC(sgbmv)(char *, int *, int *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(dgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(qgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(cgbmv)(char *, int *, int *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(xgbmv)(char *, int *, int *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+
+int BLASFUNC(ssbmv)(char *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(dsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(qsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(csbmv)(char *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(xsbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+
+int BLASFUNC(chbmv)(char *, int *, int *, float  *, float  *, int *,
+		    float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zhbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+int BLASFUNC(xhbmv)(char *, int *, int *, double *, double *, int *,
+		    double *, int *, double *, double *, int *);
+
+/* Level 3 routines */
+
+int BLASFUNC(sgemm)(const char *, const char *, const int *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(cgemm)(const char *, const char *, const int *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(cgemm3m)(char *, char *, int *, int *, int *, float *,
+	   float  *, int *, float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zgemm3m)(char *, char *, int *, int *, int *, double *,
+	   double *, int *, double *, int *, double *, double *, int *);
+int BLASFUNC(xgemm3m)(char *, char *, int *, int *, int *, double *,
+	   double *, int *, double *, int *, double *, double *, int *);
+
+int BLASFUNC(sge2mm)(char *, char *, char *, int *, int *,
+		     float *, float  *, int *, float  *, int *,
+		     float *, float  *, int *);
+int BLASFUNC(dge2mm)(char *, char *, char *, int *, int *,
+		     double *, double  *, int *, double  *, int *,
+		     double *, double  *, int *);
+int BLASFUNC(cge2mm)(char *, char *, char *, int *, int *,
+		     float *, float  *, int *, float  *, int *,
+		     float *, float  *, int *);
+int BLASFUNC(zge2mm)(char *, char *, char *, int *, int *,
+		     double *, double  *, int *, double  *, int *,
+		     double *, double  *, int *);
+
+int BLASFUNC(strsm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(dtrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(ztrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(strmm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(dtrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(qtrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(ctrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,  const float *,  const int *, float *,  const int *);
+int BLASFUNC(ztrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+int BLASFUNC(xtrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, double *, const int *);
+
+int BLASFUNC(ssymm)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(csymm)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(csymm3m)(char *, char *, int *, int *, float  *, float  *, int *, float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zsymm3m)(char *, char *, int *, int *, double *, double *, int *, double *, int *, double *, double *, int *);
+int BLASFUNC(xsymm3m)(char *, char *, int *, int *, double *, double *, int *, double *, int *, double *, double *, int *);
+
+int BLASFUNC(ssyrk)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(qsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(csyrk)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(ssyr2k)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(dsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(qsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(csyr2k)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(xsyr2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+
+int BLASFUNC(chemm)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zhemm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xhemm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(chemm3m)(char *, char *, int *, int *, float  *, float  *, int *,
+	   float  *, int *, float  *, float  *, int *);
+int BLASFUNC(zhemm3m)(char *, char *, int *, int *, double *, double *, int *,
+	   double *, int *, double *, double *, int *);
+int BLASFUNC(xhemm3m)(char *, char *, int *, int *, double *, double *, int *,
+	   double *, int *, double *, double *, int *);
+
+int BLASFUNC(cherk)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zherk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xherk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, double *, const int *);
+
+int BLASFUNC(cher2k)(const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zher2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xher2k)(const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(cher2m)(const char *, const char *, const char *, const int *, const int *, const float  *, const float  *, const int *, const float *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zher2m)(const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+int BLASFUNC(xher2m)(const char *, const char *, const char *, const int *, const int *, const double *, const double *, const int *, const double*, const int *, const double *, double *, const int *);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/misc/lapack.h b/C++/yolo_bytetrack_old/include/Eigen/src/misc/lapack.h
new file mode 100644
index 00000000..249f3575
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/misc/lapack.h
@@ -0,0 +1,152 @@
+#ifndef LAPACK_H
+#define LAPACK_H
+
+#include "blas.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+int BLASFUNC(csymv) (const char *, const int *, const float  *, const float  *, const int *, const float  *, const int *, const float  *, float  *, const int *);
+int BLASFUNC(zsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+int BLASFUNC(xsymv) (const char *, const int *, const double *, const double *, const int *, const double *, const int *, const double *, double *, const int *);
+
+
+int BLASFUNC(cspmv) (char *, int *, float  *, float *,
+         float  *, int *, float *, float *, int *);
+int BLASFUNC(zspmv) (char *, int *, double  *, double *,
+         double  *, int *, double *, double *, int *);
+int BLASFUNC(xspmv) (char *, int *, double  *, double *,
+         double  *, int *, double *, double *, int *);
+
+int BLASFUNC(csyr) (char *, int *, float   *, float  *, int *,
+        float  *, int *);
+int BLASFUNC(zsyr) (char *, int *, double  *, double *, int *,
+        double *, int *);
+int BLASFUNC(xsyr) (char *, int *, double  *, double *, int *,
+        double *, int *);
+
+int BLASFUNC(cspr) (char *, int *, float   *, float  *, int *,
+        float  *);
+int BLASFUNC(zspr) (char *, int *, double  *, double *, int *,
+        double *);
+int BLASFUNC(xspr) (char *, int *, double  *, double *, int *,
+        double *);
+
+int BLASFUNC(sgemt)(char *, int *, int *, float  *, float  *, int *,
+        float  *, int *);
+int BLASFUNC(dgemt)(char *, int *, int *, double *, double *, int *,
+        double *, int *);
+int BLASFUNC(cgemt)(char *, int *, int *, float  *, float  *, int *,
+        float  *, int *);
+int BLASFUNC(zgemt)(char *, int *, int *, double *, double *, int *,
+        double *, int *);
+
+int BLASFUNC(sgema)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(dgema)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+int BLASFUNC(cgema)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(zgema)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+
+int BLASFUNC(sgems)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(dgems)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+int BLASFUNC(cgems)(char *, char *, int *, int *, float  *,
+        float  *, int *, float *, float  *, int *, float *, int *);
+int BLASFUNC(zgems)(char *, char *, int *, int *, double *,
+        double *, int *, double*, double *, int *, double*, int *);
+
+int BLASFUNC(sgetf2)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(dgetf2)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(qgetf2)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(cgetf2)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(zgetf2)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(xgetf2)(int *, int *, double *, int *, int *, int *);
+
+int BLASFUNC(sgetrf)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(dgetrf)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(qgetrf)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(cgetrf)(int *, int *, float  *, int *, int *, int *);
+int BLASFUNC(zgetrf)(int *, int *, double *, int *, int *, int *);
+int BLASFUNC(xgetrf)(int *, int *, double *, int *, int *, int *);
+
+int BLASFUNC(slaswp)(int *, float  *, int *, int *, int *, int *, int *);
+int BLASFUNC(dlaswp)(int *, double *, int *, int *, int *, int *, int *);
+int BLASFUNC(qlaswp)(int *, double *, int *, int *, int *, int *, int *);
+int BLASFUNC(claswp)(int *, float  *, int *, int *, int *, int *, int *);
+int BLASFUNC(zlaswp)(int *, double *, int *, int *, int *, int *, int *);
+int BLASFUNC(xlaswp)(int *, double *, int *, int *, int *, int *, int *);
+
+int BLASFUNC(sgetrs)(char *, int *, int *, float  *, int *, int *, float  *, int *, int *);
+int BLASFUNC(dgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+int BLASFUNC(qgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+int BLASFUNC(cgetrs)(char *, int *, int *, float  *, int *, int *, float  *, int *, int *);
+int BLASFUNC(zgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+int BLASFUNC(xgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *);
+
+int BLASFUNC(sgesv)(int *, int *, float  *, int *, int *, float *, int *, int *);
+int BLASFUNC(dgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+int BLASFUNC(qgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+int BLASFUNC(cgesv)(int *, int *, float  *, int *, int *, float *, int *, int *);
+int BLASFUNC(zgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+int BLASFUNC(xgesv)(int *, int *, double *, int *, int *, double*, int *, int *);
+
+int BLASFUNC(spotf2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dpotf2)(char *, int *, double *, int *, int *);
+int BLASFUNC(qpotf2)(char *, int *, double *, int *, int *);
+int BLASFUNC(cpotf2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zpotf2)(char *, int *, double *, int *, int *);
+int BLASFUNC(xpotf2)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(spotrf)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dpotrf)(char *, int *, double *, int *, int *);
+int BLASFUNC(qpotrf)(char *, int *, double *, int *, int *);
+int BLASFUNC(cpotrf)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zpotrf)(char *, int *, double *, int *, int *);
+int BLASFUNC(xpotrf)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(slauu2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dlauu2)(char *, int *, double *, int *, int *);
+int BLASFUNC(qlauu2)(char *, int *, double *, int *, int *);
+int BLASFUNC(clauu2)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zlauu2)(char *, int *, double *, int *, int *);
+int BLASFUNC(xlauu2)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(slauum)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dlauum)(char *, int *, double *, int *, int *);
+int BLASFUNC(qlauum)(char *, int *, double *, int *, int *);
+int BLASFUNC(clauum)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zlauum)(char *, int *, double *, int *, int *);
+int BLASFUNC(xlauum)(char *, int *, double *, int *, int *);
+
+int BLASFUNC(strti2)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(dtrti2)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(qtrti2)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(ctrti2)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(ztrti2)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(xtrti2)(char *, char *, int *, double *, int *, int *);
+
+int BLASFUNC(strtri)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(dtrtri)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(qtrtri)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(ctrtri)(char *, char *, int *, float  *, int *, int *);
+int BLASFUNC(ztrtri)(char *, char *, int *, double *, int *, int *);
+int BLASFUNC(xtrtri)(char *, char *, int *, double *, int *, int *);
+
+int BLASFUNC(spotri)(char *, int *, float  *, int *, int *);
+int BLASFUNC(dpotri)(char *, int *, double *, int *, int *);
+int BLASFUNC(qpotri)(char *, int *, double *, int *, int *);
+int BLASFUNC(cpotri)(char *, int *, float  *, int *, int *);
+int BLASFUNC(zpotri)(char *, int *, double *, int *, int *);
+int BLASFUNC(xpotri)(char *, int *, double *, int *, int *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/misc/lapacke.h b/C++/yolo_bytetrack_old/include/Eigen/src/misc/lapacke.h
new file mode 100644
index 00000000..3d8e24f5
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/misc/lapacke.h
@@ -0,0 +1,16292 @@
+/*****************************************************************************
+  Copyright (c) 2010, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************
+* Contents: Native C interface to LAPACK
+* Author: Intel Corporation
+* Generated November, 2011
+*****************************************************************************/
+
+#ifndef _MKL_LAPACKE_H_
+
+#ifndef _LAPACKE_H_
+#define _LAPACKE_H_
+
+/*
+*  Turn on HAVE_LAPACK_CONFIG_H to redefine C-LAPACK datatypes
+*/
+#ifdef HAVE_LAPACK_CONFIG_H
+#include "lapacke_config.h"
+#endif
+
+#include <stdlib.h>
+
+#ifndef lapack_int
+#define lapack_int     int
+#endif
+
+#ifndef lapack_logical
+#define lapack_logical lapack_int
+#endif
+
+/* Complex types are structures equivalent to the
+* Fortran complex types COMPLEX(4) and COMPLEX(8).
+*
+* One can also redefine the types with his own types
+* for example by including in the code definitions like
+*
+* #define lapack_complex_float std::complex<float>
+* #define lapack_complex_double std::complex<double>
+*
+* or define these types in the command line:
+*
+* -Dlapack_complex_float="std::complex<float>"
+* -Dlapack_complex_double="std::complex<double>"
+*/
+
+#ifndef LAPACK_COMPLEX_CUSTOM
+
+/* Complex type (single precision) */
+#ifndef lapack_complex_float
+#include <complex.h>
+#define lapack_complex_float    float _Complex
+#endif
+
+#ifndef lapack_complex_float_real
+#define lapack_complex_float_real(z)       (creal(z))
+#endif
+
+#ifndef lapack_complex_float_imag
+#define lapack_complex_float_imag(z)       (cimag(z))
+#endif
+
+lapack_complex_float lapack_make_complex_float( float re, float im );
+
+/* Complex type (double precision) */
+#ifndef lapack_complex_double
+#include <complex.h>
+#define lapack_complex_double   double _Complex
+#endif
+
+#ifndef lapack_complex_double_real
+#define lapack_complex_double_real(z)      (creal(z))
+#endif
+
+#ifndef lapack_complex_double_imag
+#define lapack_complex_double_imag(z)       (cimag(z))
+#endif
+
+lapack_complex_double lapack_make_complex_double( double re, double im );
+
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifndef LAPACKE_malloc
+#define LAPACKE_malloc( size ) malloc( size )
+#endif
+#ifndef LAPACKE_free
+#define LAPACKE_free( p )      free( p )
+#endif
+
+#define LAPACK_C2INT( x ) (lapack_int)(*((float*)&x ))
+#define LAPACK_Z2INT( x ) (lapack_int)(*((double*)&x ))
+
+#define LAPACK_ROW_MAJOR               101
+#define LAPACK_COL_MAJOR               102
+
+#define LAPACK_WORK_MEMORY_ERROR       -1010
+#define LAPACK_TRANSPOSE_MEMORY_ERROR  -1011
+
+/* Callback logical functions of one, two, or three arguments are used
+*  to select eigenvalues to sort to the top left of the Schur form.
+*  The value is selected if function returns TRUE (non-zero). */
+
+typedef lapack_logical (*LAPACK_S_SELECT2) ( const float*, const float* );
+typedef lapack_logical (*LAPACK_S_SELECT3)
+    ( const float*, const float*, const float* );
+typedef lapack_logical (*LAPACK_D_SELECT2) ( const double*, const double* );
+typedef lapack_logical (*LAPACK_D_SELECT3)
+    ( const double*, const double*, const double* );
+
+typedef lapack_logical (*LAPACK_C_SELECT1) ( const lapack_complex_float* );
+typedef lapack_logical (*LAPACK_C_SELECT2)
+    ( const lapack_complex_float*, const lapack_complex_float* );
+typedef lapack_logical (*LAPACK_Z_SELECT1) ( const lapack_complex_double* );
+typedef lapack_logical (*LAPACK_Z_SELECT2)
+    ( const lapack_complex_double*, const lapack_complex_double* );
+
+#include "lapacke_mangling.h"
+
+#define LAPACK_lsame LAPACK_GLOBAL(lsame,LSAME)
+lapack_logical LAPACK_lsame( char* ca,  char* cb,
+                              lapack_int lca, lapack_int lcb );
+
+/* C-LAPACK function prototypes */
+
+lapack_int LAPACKE_sbdsdc( int matrix_order, char uplo, char compq,
+                           lapack_int n, float* d, float* e, float* u,
+                           lapack_int ldu, float* vt, lapack_int ldvt, float* q,
+                           lapack_int* iq );
+lapack_int LAPACKE_dbdsdc( int matrix_order, char uplo, char compq,
+                           lapack_int n, double* d, double* e, double* u,
+                           lapack_int ldu, double* vt, lapack_int ldvt,
+                           double* q, lapack_int* iq );
+
+lapack_int LAPACKE_sbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           float* d, float* e, float* vt, lapack_int ldvt,
+                           float* u, lapack_int ldu, float* c, lapack_int ldc );
+lapack_int LAPACKE_dbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           double* d, double* e, double* vt, lapack_int ldvt,
+                           double* u, lapack_int ldu, double* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_cbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           float* d, float* e, lapack_complex_float* vt,
+                           lapack_int ldvt, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_zbdsqr( int matrix_order, char uplo, lapack_int n,
+                           lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                           double* d, double* e, lapack_complex_double* vt,
+                           lapack_int ldvt, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* c,
+                           lapack_int ldc );
+
+lapack_int LAPACKE_sdisna( char job, lapack_int m, lapack_int n, const float* d,
+                           float* sep );
+lapack_int LAPACKE_ddisna( char job, lapack_int m, lapack_int n,
+                           const double* d, double* sep );
+
+lapack_int LAPACKE_sgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, float* ab, lapack_int ldab, float* d,
+                           float* e, float* q, lapack_int ldq, float* pt,
+                           lapack_int ldpt, float* c, lapack_int ldc );
+lapack_int LAPACKE_dgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, double* ab, lapack_int ldab,
+                           double* d, double* e, double* q, lapack_int ldq,
+                           double* pt, lapack_int ldpt, double* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_cgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, lapack_complex_float* ab,
+                           lapack_int ldab, float* d, float* e,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* pt, lapack_int ldpt,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zgbbrd( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int ncc, lapack_int kl,
+                           lapack_int ku, lapack_complex_double* ab,
+                           lapack_int ldab, double* d, double* e,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* pt, lapack_int ldpt,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* ab,
+                           lapack_int ldab, const lapack_int* ipiv, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* ab,
+                           lapack_int ldab, const lapack_int* ipiv,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zgbcon( int matrix_order, char norm, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* ab,
+                           lapack_int ldab, float* r, float* c, float* rowcnd,
+                           float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* ab,
+                           lapack_int ldab, double* r, double* c,
+                           double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           float* r, float* c, float* rowcnd, float* colcnd,
+                           float* amax );
+lapack_int LAPACKE_zgbequ( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           double* r, double* c, double* rowcnd, double* colcnd,
+                           double* amax );
+
+lapack_int LAPACKE_sgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku, const float* ab,
+                            lapack_int ldab, float* r, float* c, float* rowcnd,
+                            float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku, const double* ab,
+                            lapack_int ldab, double* r, double* c,
+                            double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku,
+                            const lapack_complex_float* ab, lapack_int ldab,
+                            float* r, float* c, float* rowcnd, float* colcnd,
+                            float* amax );
+lapack_int LAPACKE_zgbequb( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_int kl, lapack_int ku,
+                            const lapack_complex_double* ab, lapack_int ldab,
+                            double* r, double* c, double* rowcnd,
+                            double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const float* ab, lapack_int ldab, const float* afb,
+                           lapack_int ldafb, const lapack_int* ipiv,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const double* ab, lapack_int ldab, const double* afb,
+                           lapack_int ldafb, const lapack_int* ipiv,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* afb, lapack_int ldafb,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgbrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* afb, lapack_int ldafb,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const float* ab, lapack_int ldab,
+                            const float* afb, lapack_int ldafb,
+                            const lapack_int* ipiv, const float* r,
+                            const float* c, const float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const double* ab, lapack_int ldab,
+                            const double* afb, lapack_int ldafb,
+                            const lapack_int* ipiv, const double* r,
+                            const double* c, const double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const lapack_complex_float* ab,
+                            lapack_int ldab, const lapack_complex_float* afb,
+                            lapack_int ldafb, const lapack_int* ipiv,
+                            const float* r, const float* c,
+                            const lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zgbrfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, const lapack_complex_double* ab,
+                            lapack_int ldab, const lapack_complex_double* afb,
+                            lapack_int ldafb, const lapack_int* ipiv,
+                            const double* r, const double* c,
+                            const lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_sgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs, float* ab,
+                          lapack_int ldab, lapack_int* ipiv, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs, double* ab,
+                          lapack_int ldab, lapack_int* ipiv, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs,
+                          lapack_complex_float* ab, lapack_int ldab,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zgbsv( int matrix_order, lapack_int n, lapack_int kl,
+                          lapack_int ku, lapack_int nrhs,
+                          lapack_complex_double* ab, lapack_int ldab,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_sgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, float* ab, lapack_int ldab,
+                           float* afb, lapack_int ldafb, lapack_int* ipiv,
+                           char* equed, float* r, float* c, float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr,
+                           float* rpivot );
+lapack_int LAPACKE_dgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, double* ab, lapack_int ldab,
+                           double* afb, lapack_int ldafb, lapack_int* ipiv,
+                           char* equed, double* r, double* c, double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr,
+                           double* rpivot );
+lapack_int LAPACKE_cgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, lapack_complex_float* ab,
+                           lapack_int ldab, lapack_complex_float* afb,
+                           lapack_int ldafb, lapack_int* ipiv, char* equed,
+                           float* r, float* c, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr, float* rpivot );
+lapack_int LAPACKE_zgbsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int kl, lapack_int ku,
+                           lapack_int nrhs, lapack_complex_double* ab,
+                           lapack_int ldab, lapack_complex_double* afb,
+                           lapack_int ldafb, lapack_int* ipiv, char* equed,
+                           double* r, double* c, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, double* rcond, double* ferr,
+                           double* berr, double* rpivot );
+
+lapack_int LAPACKE_sgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, float* ab, lapack_int ldab,
+                            float* afb, lapack_int ldafb, lapack_int* ipiv,
+                            char* equed, float* r, float* c, float* b,
+                            lapack_int ldb, float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, double* ab, lapack_int ldab,
+                            double* afb, lapack_int ldafb, lapack_int* ipiv,
+                            char* equed, double* r, double* c, double* b,
+                            lapack_int ldb, double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+lapack_int LAPACKE_cgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, lapack_complex_float* ab,
+                            lapack_int ldab, lapack_complex_float* afb,
+                            lapack_int ldafb, lapack_int* ipiv, char* equed,
+                            float* r, float* c, lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* rpvgrw,
+                            float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zgbsvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int kl, lapack_int ku,
+                            lapack_int nrhs, lapack_complex_double* ab,
+                            lapack_int ldab, lapack_complex_double* afb,
+                            lapack_int ldafb, lapack_int* ipiv, char* equed,
+                            double* r, double* c, lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* rpvgrw,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_sgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, float* ab,
+                           lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_dgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, double* ab,
+                           lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_cgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zgbtrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_sgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const float* ab, lapack_int ldab,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const double* ab, lapack_int ldab,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zgbtrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int kl, lapack_int ku, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_sgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* scale,
+                           lapack_int m, float* v, lapack_int ldv );
+lapack_int LAPACKE_dgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* scale,
+                           lapack_int m, double* v, lapack_int ldv );
+lapack_int LAPACKE_cgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* scale,
+                           lapack_int m, lapack_complex_float* v,
+                           lapack_int ldv );
+lapack_int LAPACKE_zgebak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* scale,
+                           lapack_int m, lapack_complex_double* v,
+                           lapack_int ldv );
+
+lapack_int LAPACKE_sgebal( int matrix_order, char job, lapack_int n, float* a,
+                           lapack_int lda, lapack_int* ilo, lapack_int* ihi,
+                           float* scale );
+lapack_int LAPACKE_dgebal( int matrix_order, char job, lapack_int n, double* a,
+                           lapack_int lda, lapack_int* ilo, lapack_int* ihi,
+                           double* scale );
+lapack_int LAPACKE_cgebal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ilo, lapack_int* ihi, float* scale );
+lapack_int LAPACKE_zgebal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ilo, lapack_int* ihi, double* scale );
+
+lapack_int LAPACKE_sgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* d, float* e,
+                           float* tauq, float* taup );
+lapack_int LAPACKE_dgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* d, double* e,
+                           double* tauq, double* taup );
+lapack_int LAPACKE_cgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda, float* d,
+                           float* e, lapack_complex_float* tauq,
+                           lapack_complex_float* taup );
+lapack_int LAPACKE_zgebrd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda, double* d,
+                           double* e, lapack_complex_double* tauq,
+                           lapack_complex_double* taup );
+
+lapack_int LAPACKE_sgecon( int matrix_order, char norm, lapack_int n,
+                           const float* a, lapack_int lda, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dgecon( int matrix_order, char norm, lapack_int n,
+                           const double* a, lapack_int lda, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_cgecon( int matrix_order, char norm, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_zgecon( int matrix_order, char norm, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double anorm, double* rcond );
+
+lapack_int LAPACKE_sgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const float* a, lapack_int lda, float* r, float* c,
+                           float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const double* a, lapack_int lda, double* r,
+                           double* c, double* rowcnd, double* colcnd,
+                           double* amax );
+lapack_int LAPACKE_cgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float* r, float* c, float* rowcnd, float* colcnd,
+                           float* amax );
+lapack_int LAPACKE_zgeequ( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double* r, double* c, double* rowcnd, double* colcnd,
+                           double* amax );
+
+lapack_int LAPACKE_sgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const float* a, lapack_int lda, float* r, float* c,
+                            float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const double* a, lapack_int lda, double* r,
+                            double* c, double* rowcnd, double* colcnd,
+                            double* amax );
+lapack_int LAPACKE_cgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* r, float* c, float* rowcnd, float* colcnd,
+                            float* amax );
+lapack_int LAPACKE_zgeequb( int matrix_order, lapack_int m, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* r, double* c, double* rowcnd,
+                            double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_S_SELECT2 select, lapack_int n, float* a,
+                          lapack_int lda, lapack_int* sdim, float* wr,
+                          float* wi, float* vs, lapack_int ldvs );
+lapack_int LAPACKE_dgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_D_SELECT2 select, lapack_int n, double* a,
+                          lapack_int lda, lapack_int* sdim, double* wr,
+                          double* wi, double* vs, lapack_int ldvs );
+lapack_int LAPACKE_cgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_C_SELECT1 select, lapack_int n,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_int* sdim, lapack_complex_float* w,
+                          lapack_complex_float* vs, lapack_int ldvs );
+lapack_int LAPACKE_zgees( int matrix_order, char jobvs, char sort,
+                          LAPACK_Z_SELECT1 select, lapack_int n,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_int* sdim, lapack_complex_double* w,
+                          lapack_complex_double* vs, lapack_int ldvs );
+
+lapack_int LAPACKE_sgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_S_SELECT2 select, char sense, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* sdim,
+                           float* wr, float* wi, float* vs, lapack_int ldvs,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_dgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_D_SELECT2 select, char sense, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* sdim,
+                           double* wr, double* wi, double* vs, lapack_int ldvs,
+                           double* rconde, double* rcondv );
+lapack_int LAPACKE_cgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_C_SELECT1 select, char sense, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* sdim, lapack_complex_float* w,
+                           lapack_complex_float* vs, lapack_int ldvs,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_zgeesx( int matrix_order, char jobvs, char sort,
+                           LAPACK_Z_SELECT1 select, char sense, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* sdim, lapack_complex_double* w,
+                           lapack_complex_double* vs, lapack_int ldvs,
+                           double* rconde, double* rcondv );
+
+lapack_int LAPACKE_sgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, float* a, lapack_int lda, float* wr,
+                          float* wi, float* vl, lapack_int ldvl, float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_dgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, double* a, lapack_int lda, double* wr,
+                          double* wi, double* vl, lapack_int ldvl, double* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_cgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* w, lapack_complex_float* vl,
+                          lapack_int ldvl, lapack_complex_float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_zgeev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* w,
+                          lapack_complex_double* vl, lapack_int ldvl,
+                          lapack_complex_double* vr, lapack_int ldvr );
+
+lapack_int LAPACKE_sgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, float* a,
+                           lapack_int lda, float* wr, float* wi, float* vl,
+                           lapack_int ldvl, float* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, float* scale,
+                           float* abnrm, float* rconde, float* rcondv );
+lapack_int LAPACKE_dgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, double* a,
+                           lapack_int lda, double* wr, double* wi, double* vl,
+                           lapack_int ldvl, double* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, double* scale,
+                           double* abnrm, double* rconde, double* rcondv );
+lapack_int LAPACKE_cgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* w, lapack_complex_float* vl,
+                           lapack_int ldvl, lapack_complex_float* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           float* scale, float* abnrm, float* rconde,
+                           float* rcondv );
+lapack_int LAPACKE_zgeevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* w, lapack_complex_double* vl,
+                           lapack_int ldvl, lapack_complex_double* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           double* scale, double* abnrm, double* rconde,
+                           double* rcondv );
+
+lapack_int LAPACKE_sgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, float* a, lapack_int lda,
+                           float* tau );
+lapack_int LAPACKE_dgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, double* a, lapack_int lda,
+                           double* tau );
+lapack_int LAPACKE_cgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* tau );
+lapack_int LAPACKE_zgehrd( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgejsv( int matrix_order, char joba, char jobu, char jobv,
+                           char jobr, char jobt, char jobp, lapack_int m,
+                           lapack_int n, float* a, lapack_int lda, float* sva,
+                           float* u, lapack_int ldu, float* v, lapack_int ldv,
+                           float* stat, lapack_int* istat );
+lapack_int LAPACKE_dgejsv( int matrix_order, char joba, char jobu, char jobv,
+                           char jobr, char jobt, char jobp, lapack_int m,
+                           lapack_int n, double* a, lapack_int lda, double* sva,
+                           double* u, lapack_int ldu, double* v, lapack_int ldv,
+                           double* stat, lapack_int* istat );
+
+lapack_int LAPACKE_sgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgelq2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgelqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs, float* a,
+                          lapack_int lda, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs, double* a,
+                          lapack_int lda, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgels( int matrix_order, char trans, lapack_int m,
+                          lapack_int n, lapack_int nrhs,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_dgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_cgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_zgelsd( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+
+lapack_int LAPACKE_sgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_dgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_cgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float* s, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_zgelss( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double* s, double rcond,
+                           lapack_int* rank );
+
+lapack_int LAPACKE_sgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, lapack_int* jpvt, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_dgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, lapack_int* jpvt,
+                           double rcond, lapack_int* rank );
+lapack_int LAPACKE_cgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_int* jpvt, float rcond,
+                           lapack_int* rank );
+lapack_int LAPACKE_zgelsy( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_int* jpvt, double rcond,
+                           lapack_int* rank );
+
+lapack_int LAPACKE_sgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqlf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* jpvt,
+                           float* tau );
+lapack_int LAPACKE_dgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* jpvt,
+                           double* tau );
+lapack_int LAPACKE_cgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqp3( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* jpvt,
+                           float* tau );
+lapack_int LAPACKE_dgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* jpvt,
+                           double* tau );
+lapack_int LAPACKE_cgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqpf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* jpvt, lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqr2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* tau );
+lapack_int LAPACKE_zgeqrfp( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const float* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const double* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgerfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs, const float* a,
+                            lapack_int lda, const float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* r,
+                            const float* c, const float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs, const double* a,
+                            lapack_int lda, const double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* r,
+                            const double* c, const double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* r,
+                            const float* c, const lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zgerfsx( int matrix_order, char trans, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* r,
+                            const double* c, const lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_sgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_cgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zgerqf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_sgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, float* a, lapack_int lda, float* s,
+                           float* u, lapack_int ldu, float* vt,
+                           lapack_int ldvt );
+lapack_int LAPACKE_dgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, double* a, lapack_int lda, double* s,
+                           double* u, lapack_int ldu, double* vt,
+                           lapack_int ldvt );
+lapack_int LAPACKE_cgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float* s, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* vt,
+                           lapack_int ldvt );
+lapack_int LAPACKE_zgesdd( int matrix_order, char jobz, lapack_int m,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double* s, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* vt,
+                           lapack_int ldvt );
+
+lapack_int LAPACKE_sgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* a, lapack_int lda, lapack_int* ipiv, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* a, lapack_int lda, lapack_int* ipiv,
+                          double* b, lapack_int ldb );
+lapack_int LAPACKE_cgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dsgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                           double* a, lapack_int lda, lapack_int* ipiv,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           lapack_int* iter );
+lapack_int LAPACKE_zcgesv( int matrix_order, lapack_int n, lapack_int nrhs,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, lapack_int* iter );
+
+lapack_int LAPACKE_sgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, float* a, lapack_int lda,
+                           float* s, float* u, lapack_int ldu, float* vt,
+                           lapack_int ldvt, float* superb );
+lapack_int LAPACKE_dgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, double* a,
+                           lapack_int lda, double* s, double* u, lapack_int ldu,
+                           double* vt, lapack_int ldvt, double* superb );
+lapack_int LAPACKE_cgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float* s, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* vt,
+                           lapack_int ldvt, float* superb );
+lapack_int LAPACKE_zgesvd( int matrix_order, char jobu, char jobvt,
+                           lapack_int m, lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double* s, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* vt,
+                           lapack_int ldvt, double* superb );
+
+lapack_int LAPACKE_sgesvj( int matrix_order, char joba, char jobu, char jobv,
+                           lapack_int m, lapack_int n, float* a, lapack_int lda,
+                           float* sva, lapack_int mv, float* v, lapack_int ldv,
+                           float* stat );
+lapack_int LAPACKE_dgesvj( int matrix_order, char joba, char jobu, char jobv,
+                           lapack_int m, lapack_int n, double* a,
+                           lapack_int lda, double* sva, lapack_int mv,
+                           double* v, lapack_int ldv, double* stat );
+
+lapack_int LAPACKE_sgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, float* a,
+                           lapack_int lda, float* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, float* r, float* c,
+                           float* b, lapack_int ldb, float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr,
+                           float* rpivot );
+lapack_int LAPACKE_dgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, double* a,
+                           lapack_int lda, double* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, double* r, double* c,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr,
+                           double* rpivot );
+lapack_int LAPACKE_cgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, float* r, float* c,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr,
+                           float* rpivot );
+lapack_int LAPACKE_zgesvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* af, lapack_int ldaf,
+                           lapack_int* ipiv, char* equed, double* r, double* c,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr,
+                           double* rpivot );
+
+lapack_int LAPACKE_sgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs, float* a,
+                            lapack_int lda, float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* r, float* c,
+                            float* b, lapack_int ldb, float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs, double* a,
+                            lapack_int lda, double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* r, double* c,
+                            double* b, lapack_int ldb, double* x,
+                            lapack_int ldx, double* rcond, double* rpvgrw,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* r, float* c,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zgesvxx( int matrix_order, char fact, char trans,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* r, double* c,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_sgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zgetf2( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zgetrf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetri( int matrix_order, lapack_int n, float* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dgetri( int matrix_order, lapack_int n, double* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_cgetri( int matrix_order, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_zgetri( int matrix_order, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgetrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* lscale,
+                           const float* rscale, lapack_int m, float* v,
+                           lapack_int ldv );
+lapack_int LAPACKE_dggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* lscale,
+                           const double* rscale, lapack_int m, double* v,
+                           lapack_int ldv );
+lapack_int LAPACKE_cggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const float* lscale,
+                           const float* rscale, lapack_int m,
+                           lapack_complex_float* v, lapack_int ldv );
+lapack_int LAPACKE_zggbak( int matrix_order, char job, char side, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, const double* lscale,
+                           const double* rscale, lapack_int m,
+                           lapack_complex_double* v, lapack_int ldv );
+
+lapack_int LAPACKE_sggbal( int matrix_order, char job, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, float* lscale,
+                           float* rscale );
+lapack_int LAPACKE_dggbal( int matrix_order, char job, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, double* lscale,
+                           double* rscale );
+lapack_int LAPACKE_cggbal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, float* lscale,
+                           float* rscale );
+lapack_int LAPACKE_zggbal( int matrix_order, char job, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_int* ilo, lapack_int* ihi, double* lscale,
+                           double* rscale );
+
+lapack_int LAPACKE_sgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_S_SELECT3 selctg, lapack_int n, float* a,
+                          lapack_int lda, float* b, lapack_int ldb,
+                          lapack_int* sdim, float* alphar, float* alphai,
+                          float* beta, float* vsl, lapack_int ldvsl, float* vsr,
+                          lapack_int ldvsr );
+lapack_int LAPACKE_dgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_D_SELECT3 selctg, lapack_int n, double* a,
+                          lapack_int lda, double* b, lapack_int ldb,
+                          lapack_int* sdim, double* alphar, double* alphai,
+                          double* beta, double* vsl, lapack_int ldvsl,
+                          double* vsr, lapack_int ldvsr );
+lapack_int LAPACKE_cgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_C_SELECT2 selctg, lapack_int n,
+                          lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* b, lapack_int ldb,
+                          lapack_int* sdim, lapack_complex_float* alpha,
+                          lapack_complex_float* beta, lapack_complex_float* vsl,
+                          lapack_int ldvsl, lapack_complex_float* vsr,
+                          lapack_int ldvsr );
+lapack_int LAPACKE_zgges( int matrix_order, char jobvsl, char jobvsr, char sort,
+                          LAPACK_Z_SELECT2 selctg, lapack_int n,
+                          lapack_complex_double* a, lapack_int lda,
+                          lapack_complex_double* b, lapack_int ldb,
+                          lapack_int* sdim, lapack_complex_double* alpha,
+                          lapack_complex_double* beta,
+                          lapack_complex_double* vsl, lapack_int ldvsl,
+                          lapack_complex_double* vsr, lapack_int ldvsr );
+
+lapack_int LAPACKE_sggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_S_SELECT3 selctg, char sense,
+                           lapack_int n, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, lapack_int* sdim, float* alphar,
+                           float* alphai, float* beta, float* vsl,
+                           lapack_int ldvsl, float* vsr, lapack_int ldvsr,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_dggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_D_SELECT3 selctg, char sense,
+                           lapack_int n, double* a, lapack_int lda, double* b,
+                           lapack_int ldb, lapack_int* sdim, double* alphar,
+                           double* alphai, double* beta, double* vsl,
+                           lapack_int ldvsl, double* vsr, lapack_int ldvsr,
+                           double* rconde, double* rcondv );
+lapack_int LAPACKE_cggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_C_SELECT2 selctg, char sense,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_int* sdim,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta,
+                           lapack_complex_float* vsl, lapack_int ldvsl,
+                           lapack_complex_float* vsr, lapack_int ldvsr,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_zggesx( int matrix_order, char jobvsl, char jobvsr,
+                           char sort, LAPACK_Z_SELECT2 selctg, char sense,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_int* sdim,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* vsl, lapack_int ldvsl,
+                           lapack_complex_double* vsr, lapack_int ldvsr,
+                           double* rconde, double* rcondv );
+
+lapack_int LAPACKE_sggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, float* a, lapack_int lda, float* b,
+                          lapack_int ldb, float* alphar, float* alphai,
+                          float* beta, float* vl, lapack_int ldvl, float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_dggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, double* a, lapack_int lda, double* b,
+                          lapack_int ldb, double* alphar, double* alphai,
+                          double* beta, double* vl, lapack_int ldvl, double* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_cggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* b, lapack_int ldb,
+                          lapack_complex_float* alpha,
+                          lapack_complex_float* beta, lapack_complex_float* vl,
+                          lapack_int ldvl, lapack_complex_float* vr,
+                          lapack_int ldvr );
+lapack_int LAPACKE_zggev( int matrix_order, char jobvl, char jobvr,
+                          lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* b,
+                          lapack_int ldb, lapack_complex_double* alpha,
+                          lapack_complex_double* beta,
+                          lapack_complex_double* vl, lapack_int ldvl,
+                          lapack_complex_double* vr, lapack_int ldvr );
+
+lapack_int LAPACKE_sggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           float* alphar, float* alphai, float* beta, float* vl,
+                           lapack_int ldvl, float* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, float* lscale,
+                           float* rscale, float* abnrm, float* bbnrm,
+                           float* rconde, float* rcondv );
+lapack_int LAPACKE_dggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double* alphar, double* alphai, double* beta,
+                           double* vl, lapack_int ldvl, double* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           double* lscale, double* rscale, double* abnrm,
+                           double* bbnrm, double* rconde, double* rcondv );
+lapack_int LAPACKE_cggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta, lapack_complex_float* vl,
+                           lapack_int ldvl, lapack_complex_float* vr,
+                           lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
+                           float* lscale, float* rscale, float* abnrm,
+                           float* bbnrm, float* rconde, float* rcondv );
+lapack_int LAPACKE_zggevx( int matrix_order, char balanc, char jobvl,
+                           char jobvr, char sense, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* vl, lapack_int ldvl,
+                           lapack_complex_double* vr, lapack_int ldvr,
+                           lapack_int* ilo, lapack_int* ihi, double* lscale,
+                           double* rscale, double* abnrm, double* bbnrm,
+                           double* rconde, double* rcondv );
+
+lapack_int LAPACKE_sggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* d, float* x, float* y );
+lapack_int LAPACKE_dggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, double* a, lapack_int lda, double* b,
+                           lapack_int ldb, double* d, double* x, double* y );
+lapack_int LAPACKE_cggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* d,
+                           lapack_complex_float* x, lapack_complex_float* y );
+lapack_int LAPACKE_zggglm( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* d,
+                           lapack_complex_double* x, lapack_complex_double* y );
+
+lapack_int LAPACKE_sgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           float* a, lapack_int lda, float* b, lapack_int ldb,
+                           float* q, lapack_int ldq, float* z, lapack_int ldz );
+lapack_int LAPACKE_dgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           double* a, lapack_int lda, double* b, lapack_int ldb,
+                           double* q, lapack_int ldq, double* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_cgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zgghrd( int matrix_order, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, float* a, lapack_int lda, float* b,
+                           lapack_int ldb, float* c, float* d, float* x );
+lapack_int LAPACKE_dgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, double* a, lapack_int lda, double* b,
+                           lapack_int ldb, double* c, double* d, double* x );
+lapack_int LAPACKE_cgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* c,
+                           lapack_complex_float* d, lapack_complex_float* x );
+lapack_int LAPACKE_zgglse( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int p, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* c,
+                           lapack_complex_double* d, lapack_complex_double* x );
+
+lapack_int LAPACKE_sggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, float* a, lapack_int lda, float* taua,
+                           float* b, lapack_int ldb, float* taub );
+lapack_int LAPACKE_dggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, double* a, lapack_int lda,
+                           double* taua, double* b, lapack_int ldb,
+                           double* taub );
+lapack_int LAPACKE_cggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* taua,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* taub );
+lapack_int LAPACKE_zggqrf( int matrix_order, lapack_int n, lapack_int m,
+                           lapack_int p, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* taua,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* taub );
+
+lapack_int LAPACKE_sggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, float* a, lapack_int lda, float* taua,
+                           float* b, lapack_int ldb, float* taub );
+lapack_int LAPACKE_dggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, double* a, lapack_int lda,
+                           double* taua, double* b, lapack_int ldb,
+                           double* taub );
+lapack_int LAPACKE_cggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* taua,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* taub );
+lapack_int LAPACKE_zggrqf( int matrix_order, lapack_int m, lapack_int p,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* taua,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* taub );
+
+lapack_int LAPACKE_sggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           float* alpha, float* beta, float* u, lapack_int ldu,
+                           float* v, lapack_int ldv, float* q, lapack_int ldq,
+                           lapack_int* iwork );
+lapack_int LAPACKE_dggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double* alpha, double* beta, double* u,
+                           lapack_int ldu, double* v, lapack_int ldv, double* q,
+                           lapack_int ldq, lapack_int* iwork );
+lapack_int LAPACKE_cggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           float* alpha, float* beta, lapack_complex_float* u,
+                           lapack_int ldu, lapack_complex_float* v,
+                           lapack_int ldv, lapack_complex_float* q,
+                           lapack_int ldq, lapack_int* iwork );
+lapack_int LAPACKE_zggsvd( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int n, lapack_int p,
+                           lapack_int* k, lapack_int* l,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           double* alpha, double* beta,
+                           lapack_complex_double* u, lapack_int ldu,
+                           lapack_complex_double* v, lapack_int ldv,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_int* iwork );
+
+lapack_int LAPACKE_sggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb, float tola,
+                           float tolb, lapack_int* k, lapack_int* l, float* u,
+                           lapack_int ldu, float* v, lapack_int ldv, float* q,
+                           lapack_int ldq );
+lapack_int LAPACKE_dggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double tola, double tolb, lapack_int* k,
+                           lapack_int* l, double* u, lapack_int ldu, double* v,
+                           lapack_int ldv, double* q, lapack_int ldq );
+lapack_int LAPACKE_cggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb, float tola,
+                           float tolb, lapack_int* k, lapack_int* l,
+                           lapack_complex_float* u, lapack_int ldu,
+                           lapack_complex_float* v, lapack_int ldv,
+                           lapack_complex_float* q, lapack_int ldq );
+lapack_int LAPACKE_zggsvp( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           double tola, double tolb, lapack_int* k,
+                           lapack_int* l, lapack_complex_double* u,
+                           lapack_int ldu, lapack_complex_double* v,
+                           lapack_int ldv, lapack_complex_double* q,
+                           lapack_int ldq );
+
+lapack_int LAPACKE_sgtcon( char norm, lapack_int n, const float* dl,
+                           const float* d, const float* du, const float* du2,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_dgtcon( char norm, lapack_int n, const double* dl,
+                           const double* d, const double* du, const double* du2,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_cgtcon( char norm, lapack_int n,
+                           const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           const lapack_complex_float* du2,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zgtcon( char norm, lapack_int n,
+                           const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           const lapack_complex_double* du2,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* dl, const float* d,
+                           const float* du, const float* dlf, const float* df,
+                           const float* duf, const float* du2,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* dl, const double* d,
+                           const double* du, const double* dlf,
+                           const double* df, const double* duf,
+                           const double* du2, const lapack_int* ipiv,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           const lapack_complex_float* dlf,
+                           const lapack_complex_float* df,
+                           const lapack_complex_float* duf,
+                           const lapack_complex_float* du2,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgtrfs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           const lapack_complex_double* dlf,
+                           const lapack_complex_double* df,
+                           const lapack_complex_double* duf,
+                           const lapack_complex_double* du2,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* dl, float* d, float* du, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* dl, double* d, double* du, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_float* dl, lapack_complex_float* d,
+                          lapack_complex_float* du, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          lapack_complex_double* dl, lapack_complex_double* d,
+                          lapack_complex_double* du, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_sgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, const float* dl,
+                           const float* d, const float* du, float* dlf,
+                           float* df, float* duf, float* du2, lapack_int* ipiv,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs, const double* dl,
+                           const double* d, const double* du, double* dlf,
+                           double* df, double* duf, double* du2,
+                           lapack_int* ipiv, const double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           lapack_complex_float* dlf, lapack_complex_float* df,
+                           lapack_complex_float* duf, lapack_complex_float* du2,
+                           lapack_int* ipiv, const lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zgtsvx( int matrix_order, char fact, char trans,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           lapack_complex_double* dlf,
+                           lapack_complex_double* df,
+                           lapack_complex_double* duf,
+                           lapack_complex_double* du2, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_sgttrf( lapack_int n, float* dl, float* d, float* du,
+                           float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_dgttrf( lapack_int n, double* dl, double* d, double* du,
+                           double* du2, lapack_int* ipiv );
+lapack_int LAPACKE_cgttrf( lapack_int n, lapack_complex_float* dl,
+                           lapack_complex_float* d, lapack_complex_float* du,
+                           lapack_complex_float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_zgttrf( lapack_int n, lapack_complex_double* dl,
+                           lapack_complex_double* d, lapack_complex_double* du,
+                           lapack_complex_double* du2, lapack_int* ipiv );
+
+lapack_int LAPACKE_sgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const float* dl, const float* d,
+                           const float* du, const float* du2,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const double* dl, const double* d,
+                           const double* du, const double* du2,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_cgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* dl,
+                           const lapack_complex_float* d,
+                           const lapack_complex_float* du,
+                           const lapack_complex_float* du2,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zgttrs( int matrix_order, char trans, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* dl,
+                           const lapack_complex_double* d,
+                           const lapack_complex_double* du,
+                           const lapack_complex_double* du2,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_chbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, lapack_complex_float* ab,
+                          lapack_int ldab, float* w, lapack_complex_float* z,
+                          lapack_int ldz );
+lapack_int LAPACKE_zhbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, lapack_complex_double* ab,
+                          lapack_int ldab, double* w, lapack_complex_double* z,
+                          lapack_int ldz );
+
+lapack_int LAPACKE_chbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_float* ab,
+                           lapack_int ldab, float* w, lapack_complex_float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_zhbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_double* ab,
+                           lapack_int ldab, double* w, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_chbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* q, lapack_int ldq, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* bb, lapack_int ldbb,
+                           lapack_complex_float* x, lapack_int ldx );
+lapack_int LAPACKE_zhbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* bb, lapack_int ldbb,
+                           lapack_complex_double* x, lapack_int ldx );
+
+lapack_int LAPACKE_chbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb,
+                          lapack_complex_float* ab, lapack_int ldab,
+                          lapack_complex_float* bb, lapack_int ldbb, float* w,
+                          lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb,
+                          lapack_complex_double* ab, lapack_int ldab,
+                          lapack_complex_double* bb, lapack_int ldbb, double* w,
+                          lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* bb, lapack_int ldbb, float* w,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* bb, lapack_int ldbb,
+                           double* w, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_chbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* bb, lapack_int ldbb,
+                           lapack_complex_float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* bb, lapack_int ldbb,
+                           lapack_complex_double* q, lapack_int ldq, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_float* ab,
+                           lapack_int ldab, float* d, float* e,
+                           lapack_complex_float* q, lapack_int ldq );
+lapack_int LAPACKE_zhbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_double* ab,
+                           lapack_int ldab, double* d, double* e,
+                           lapack_complex_double* q, lapack_int ldq );
+
+lapack_int LAPACKE_checon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zhecon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_cheequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* s, float* scond, float* amax );
+lapack_int LAPACKE_zheequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_cheev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_zheev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_double* a, lapack_int lda, double* w );
+
+lapack_int LAPACKE_cheevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_zheevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           double* w );
+
+lapack_int LAPACKE_cheevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float vl, float vu, lapack_int il,
+                           lapack_int iu, float abstol, lapack_int* m, float* w,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_zheevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double vl, double vu, lapack_int il,
+                           lapack_int iu, double abstol, lapack_int* m,
+                           double* w, lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* isuppz );
+
+lapack_int LAPACKE_cheevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, float vl, float vu, lapack_int il,
+                           lapack_int iu, float abstol, lapack_int* m, float* w,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_zheevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, double vl, double vu, lapack_int il,
+                           lapack_int iu, double abstol, lapack_int* m,
+                           double* w, lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chegst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zhegst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_chegv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_float* a,
+                          lapack_int lda, lapack_complex_float* b,
+                          lapack_int ldb, float* w );
+lapack_int LAPACKE_zhegv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* b,
+                          lapack_int ldb, double* w );
+
+lapack_int LAPACKE_chegvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float* w );
+lapack_int LAPACKE_zhegvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double* w );
+
+lapack_int LAPACKE_chegvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhegvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_cherfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zherfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_cherfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* s,
+                            const lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zherfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* s,
+                            const lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_chesv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zhesv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chesvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zhesvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_chesvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* s,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zhesvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* s,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_chetrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda, float* d,
+                           float* e, lapack_complex_float* tau );
+lapack_int LAPACKE_zhetrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda, double* d,
+                           double* e, lapack_complex_double* tau );
+
+lapack_int LAPACKE_chetrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zhetrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_chetri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_zhetri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv );
+
+lapack_int LAPACKE_chetrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zhetrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, float alpha,
+                          const lapack_complex_float* a, lapack_int lda,
+                          float beta, lapack_complex_float* c );
+lapack_int LAPACKE_zhfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, double alpha,
+                          const lapack_complex_double* a, lapack_int lda,
+                          double beta, lapack_complex_double* c );
+
+lapack_int LAPACKE_shgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           float* h, lapack_int ldh, float* t, lapack_int ldt,
+                           float* alphar, float* alphai, float* beta, float* q,
+                           lapack_int ldq, float* z, lapack_int ldz );
+lapack_int LAPACKE_dhgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           double* h, lapack_int ldh, double* t, lapack_int ldt,
+                           double* alphar, double* alphai, double* beta,
+                           double* q, lapack_int ldq, double* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_chgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_float* h, lapack_int ldh,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta, lapack_complex_float* q,
+                           lapack_int ldq, lapack_complex_float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_zhgeqz( int matrix_order, char job, char compq, char compz,
+                           lapack_int n, lapack_int ilo, lapack_int ihi,
+                           lapack_complex_double* h, lapack_int ldh,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zhpcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_chpev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_float* ap, float* w,
+                          lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_complex_double* ap, double* w,
+                          lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_float* ap, float* w,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_complex_double* ap, double* w,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_float* ap, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_zhpevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_complex_double* ap, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chpgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_float* ap,
+                           const lapack_complex_float* bp );
+lapack_int LAPACKE_zhpgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, lapack_complex_double* ap,
+                           const lapack_complex_double* bp );
+
+lapack_int LAPACKE_chpgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_float* ap,
+                          lapack_complex_float* bp, float* w,
+                          lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, lapack_complex_double* ap,
+                          lapack_complex_double* bp, double* w,
+                          lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_float* ap,
+                           lapack_complex_float* bp, float* w,
+                           lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zhpgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_double* ap,
+                           lapack_complex_double* bp, double* w,
+                           lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_chpgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_float* ap, lapack_complex_float* bp,
+                           float vl, float vu, lapack_int il, lapack_int iu,
+                           float abstol, lapack_int* m, float* w,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_zhpgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n,
+                           lapack_complex_double* ap, lapack_complex_double* bp,
+                           double vl, double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_chprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_complex_float* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zhprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_complex_double* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_chpsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* ap,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zhpsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* ap,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_chpsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           lapack_complex_float* afp, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zhpsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           lapack_complex_double* afp, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_chptrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, float* d, float* e,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zhptrd( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, double* d, double* e,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_chptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zhptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_chptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, const lapack_int* ipiv );
+lapack_int LAPACKE_zhptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, const lapack_int* ipiv );
+
+lapack_int LAPACKE_chptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zhptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_shsein( int matrix_order, char job, char eigsrc, char initv,
+                           lapack_logical* select, lapack_int n, const float* h,
+                           lapack_int ldh, float* wr, const float* wi,
+                           float* vl, lapack_int ldvl, float* vr,
+                           lapack_int ldvr, lapack_int mm, lapack_int* m,
+                           lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_dhsein( int matrix_order, char job, char eigsrc, char initv,
+                           lapack_logical* select, lapack_int n,
+                           const double* h, lapack_int ldh, double* wr,
+                           const double* wi, double* vl, lapack_int ldvl,
+                           double* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m, lapack_int* ifaill,
+                           lapack_int* ifailr );
+lapack_int LAPACKE_chsein( int matrix_order, char job, char eigsrc, char initv,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* h, lapack_int ldh,
+                           lapack_complex_float* w, lapack_complex_float* vl,
+                           lapack_int ldvl, lapack_complex_float* vr,
+                           lapack_int ldvr, lapack_int mm, lapack_int* m,
+                           lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_zhsein( int matrix_order, char job, char eigsrc, char initv,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* h, lapack_int ldh,
+                           lapack_complex_double* w, lapack_complex_double* vl,
+                           lapack_int ldvl, lapack_complex_double* vr,
+                           lapack_int ldvr, lapack_int mm, lapack_int* m,
+                           lapack_int* ifaill, lapack_int* ifailr );
+
+lapack_int LAPACKE_shseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, float* h,
+                           lapack_int ldh, float* wr, float* wi, float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_dhseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi, double* h,
+                           lapack_int ldh, double* wr, double* wi, double* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_chseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi,
+                           lapack_complex_float* h, lapack_int ldh,
+                           lapack_complex_float* w, lapack_complex_float* z,
+                           lapack_int ldz );
+lapack_int LAPACKE_zhseqr( int matrix_order, char job, char compz, lapack_int n,
+                           lapack_int ilo, lapack_int ihi,
+                           lapack_complex_double* h, lapack_int ldh,
+                           lapack_complex_double* w, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_clacgv( lapack_int n, lapack_complex_float* x,
+                           lapack_int incx );
+lapack_int LAPACKE_zlacgv( lapack_int n, lapack_complex_double* x,
+                           lapack_int incx );
+
+lapack_int LAPACKE_slacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const float* a, lapack_int lda, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dlacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const double* a, lapack_int lda, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_clacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zlacpy( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_zlag2c( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_float* sa, lapack_int ldsa );
+
+lapack_int LAPACKE_slag2d( int matrix_order, lapack_int m, lapack_int n,
+                           const float* sa, lapack_int ldsa, double* a,
+                           lapack_int lda );
+
+lapack_int LAPACKE_dlag2s( int matrix_order, lapack_int m, lapack_int n,
+                           const double* a, lapack_int lda, float* sa,
+                           lapack_int ldsa );
+
+lapack_int LAPACKE_clag2z( int matrix_order, lapack_int m, lapack_int n,
+                           const lapack_complex_float* sa, lapack_int ldsa,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* d,
+                           float* a, lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_dlagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* d,
+                           double* a, lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_clagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const float* d,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* iseed );
+lapack_int LAPACKE_zlagge( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int kl, lapack_int ku, const double* d,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* iseed );
+
+float LAPACKE_slamch( char cmach );
+double LAPACKE_dlamch( char cmach );
+
+float LAPACKE_slange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const float* a, lapack_int lda );
+double LAPACKE_dlange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const double* a, lapack_int lda );
+float LAPACKE_clange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda );
+double LAPACKE_zlange( int matrix_order, char norm, lapack_int m,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda );
+
+float LAPACKE_clanhe( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda );
+double LAPACKE_zlanhe( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda );
+
+float LAPACKE_slansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const float* a, lapack_int lda );
+double LAPACKE_dlansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const double* a, lapack_int lda );
+float LAPACKE_clansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda );
+double LAPACKE_zlansy( int matrix_order, char norm, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda );
+
+float LAPACKE_slantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const float* a,
+                           lapack_int lda );
+double LAPACKE_dlantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const double* a,
+                           lapack_int lda );
+float LAPACKE_clantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda );
+double LAPACKE_zlantr( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int m, lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda );
+
+
+lapack_int LAPACKE_slarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const float* v, lapack_int ldv,
+                           const float* t, lapack_int ldt, float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_dlarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const double* v, lapack_int ldv,
+                           const double* t, lapack_int ldt, double* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_clarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const lapack_complex_float* v,
+                           lapack_int ldv, const lapack_complex_float* t,
+                           lapack_int ldt, lapack_complex_float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_zlarfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, const lapack_complex_double* v,
+                           lapack_int ldv, const lapack_complex_double* t,
+                           lapack_int ldt, lapack_complex_double* c,
+                           lapack_int ldc );
+
+lapack_int LAPACKE_slarfg( lapack_int n, float* alpha, float* x,
+                           lapack_int incx, float* tau );
+lapack_int LAPACKE_dlarfg( lapack_int n, double* alpha, double* x,
+                           lapack_int incx, double* tau );
+lapack_int LAPACKE_clarfg( lapack_int n, lapack_complex_float* alpha,
+                           lapack_complex_float* x, lapack_int incx,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_zlarfg( lapack_int n, lapack_complex_double* alpha,
+                           lapack_complex_double* x, lapack_int incx,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_slarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k, const float* v,
+                           lapack_int ldv, const float* tau, float* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_dlarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k, const double* v,
+                           lapack_int ldv, const double* tau, double* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_clarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k,
+                           const lapack_complex_float* v, lapack_int ldv,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zlarft( int matrix_order, char direct, char storev,
+                           lapack_int n, lapack_int k,
+                           const lapack_complex_double* v, lapack_int ldv,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_slarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const float* v, float tau, float* c,
+                           lapack_int ldc, float* work );
+lapack_int LAPACKE_dlarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const double* v, double tau, double* c,
+                           lapack_int ldc, double* work );
+lapack_int LAPACKE_clarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const lapack_complex_float* v,
+                           lapack_complex_float tau, lapack_complex_float* c,
+                           lapack_int ldc, lapack_complex_float* work );
+lapack_int LAPACKE_zlarfx( int matrix_order, char side, lapack_int m,
+                           lapack_int n, const lapack_complex_double* v,
+                           lapack_complex_double tau, lapack_complex_double* c,
+                           lapack_int ldc, lapack_complex_double* work );
+
+lapack_int LAPACKE_slarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           float* x );
+lapack_int LAPACKE_dlarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           double* x );
+lapack_int LAPACKE_clarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           lapack_complex_float* x );
+lapack_int LAPACKE_zlarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
+                           lapack_complex_double* x );
+
+lapack_int LAPACKE_slaset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, float alpha, float beta, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dlaset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, double alpha, double beta, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_claset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, lapack_complex_float alpha,
+                           lapack_complex_float beta, lapack_complex_float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_zlaset( int matrix_order, char uplo, lapack_int m,
+                           lapack_int n, lapack_complex_double alpha,
+                           lapack_complex_double beta, lapack_complex_double* a,
+                           lapack_int lda );
+
+lapack_int LAPACKE_slasrt( char id, lapack_int n, float* d );
+lapack_int LAPACKE_dlasrt( char id, lapack_int n, double* d );
+
+lapack_int LAPACKE_slaswp( int matrix_order, lapack_int n, float* a,
+                           lapack_int lda, lapack_int k1, lapack_int k2,
+                           const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_dlaswp( int matrix_order, lapack_int n, double* a,
+                           lapack_int lda, lapack_int k1, lapack_int k2,
+                           const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_claswp( int matrix_order, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int k1, lapack_int k2, const lapack_int* ipiv,
+                           lapack_int incx );
+lapack_int LAPACKE_zlaswp( int matrix_order, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int k1, lapack_int k2, const lapack_int* ipiv,
+                           lapack_int incx );
+
+lapack_int LAPACKE_slatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, float* d,
+                           lapack_int mode, float cond, float dmax,
+                           lapack_int kl, lapack_int ku, char pack, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dlatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, double* d,
+                           lapack_int mode, double cond, double dmax,
+                           lapack_int kl, lapack_int ku, char pack, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_clatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, float* d,
+                           lapack_int mode, float cond, float dmax,
+                           lapack_int kl, lapack_int ku, char pack,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlatms( int matrix_order, lapack_int m, lapack_int n,
+                           char dist, lapack_int* iseed, char sym, double* d,
+                           lapack_int mode, double cond, double dmax,
+                           lapack_int kl, lapack_int ku, char pack,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slauum( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dlauum( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_clauum( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlauum( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_sopgtr( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, const float* tau, float* q,
+                           lapack_int ldq );
+lapack_int LAPACKE_dopgtr( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, const double* tau, double* q,
+                           lapack_int ldq );
+
+lapack_int LAPACKE_sopmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const float* ap,
+                           const float* tau, float* c, lapack_int ldc );
+lapack_int LAPACKE_dopmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const double* ap,
+                           const double* tau, double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sorgbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, double* a,
+                           lapack_int lda, const double* tau );
+
+lapack_int LAPACKE_sorghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, float* a, lapack_int lda,
+                           const float* tau );
+lapack_int LAPACKE_dorgrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, double* a, lapack_int lda,
+                           const double* tau );
+
+lapack_int LAPACKE_sorgtr( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, const float* tau );
+lapack_int LAPACKE_dorgtr( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, const double* tau );
+
+lapack_int LAPACKE_sormbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const float* a, lapack_int lda,
+                           const float* tau, float* c, lapack_int ldc );
+lapack_int LAPACKE_dormhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const double* a, lapack_int lda,
+                           const double* tau, double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const float* a, lapack_int lda, const float* tau,
+                           float* c, lapack_int ldc );
+lapack_int LAPACKE_dormrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const double* a, lapack_int lda, const double* tau,
+                           double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const float* a, lapack_int lda,
+                           const float* tau, float* c, lapack_int ldc );
+lapack_int LAPACKE_dormrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const double* a, lapack_int lda,
+                           const double* tau, double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sormtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const float* a,
+                           lapack_int lda, const float* tau, float* c,
+                           lapack_int ldc );
+lapack_int LAPACKE_dormtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n, const double* a,
+                           lapack_int lda, const double* tau, double* c,
+                           lapack_int ldc );
+
+lapack_int LAPACKE_spbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const float* ab, lapack_int ldab,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_dpbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const double* ab, lapack_int ldab,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cpbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_float* ab,
+                           lapack_int ldab, float anorm, float* rcond );
+lapack_int LAPACKE_zpbcon( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_double* ab,
+                           lapack_int ldab, double anorm, double* rcond );
+
+lapack_int LAPACKE_spbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const float* ab, lapack_int ldab,
+                           float* s, float* scond, float* amax );
+lapack_int LAPACKE_dpbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const double* ab, lapack_int ldab,
+                           double* s, double* scond, double* amax );
+lapack_int LAPACKE_cpbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_float* ab,
+                           lapack_int ldab, float* s, float* scond,
+                           float* amax );
+lapack_int LAPACKE_zpbequ( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, const lapack_complex_double* ab,
+                           lapack_int ldab, double* s, double* scond,
+                           double* amax );
+
+lapack_int LAPACKE_spbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const float* ab,
+                           lapack_int ldab, const float* afb, lapack_int ldafb,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dpbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const double* ab,
+                           lapack_int ldab, const double* afb, lapack_int ldafb,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cpbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* afb, lapack_int ldafb,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zpbrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* afb, lapack_int ldafb,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_spbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, float* bb, lapack_int ldbb );
+lapack_int LAPACKE_dpbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, double* bb, lapack_int ldbb );
+lapack_int LAPACKE_cpbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, lapack_complex_float* bb,
+                           lapack_int ldbb );
+lapack_int LAPACKE_zpbstf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kb, lapack_complex_double* bb,
+                           lapack_int ldbb );
+
+lapack_int LAPACKE_spbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs, float* ab,
+                          lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs, double* ab,
+                          lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs,
+                          lapack_complex_float* ab, lapack_int ldab,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int kd, lapack_int nrhs,
+                          lapack_complex_double* ab, lapack_int ldab,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, float* ab,
+                           lapack_int ldab, float* afb, lapack_int ldafb,
+                           char* equed, float* s, float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, double* ab,
+                           lapack_int ldab, double* afb, lapack_int ldafb,
+                           char* equed, double* s, double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* afb, lapack_int ldafb,
+                           char* equed, float* s, lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* afb, lapack_int ldafb,
+                           char* equed, double* s, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, double* rcond, double* ferr,
+                           double* berr );
+
+lapack_int LAPACKE_spbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, float* ab, lapack_int ldab );
+lapack_int LAPACKE_dpbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, double* ab, lapack_int ldab );
+lapack_int LAPACKE_cpbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_float* ab,
+                           lapack_int ldab );
+lapack_int LAPACKE_zpbtrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_complex_double* ab,
+                           lapack_int ldab );
+
+lapack_int LAPACKE_spbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const float* ab,
+                           lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs, const double* ab,
+                           lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbtrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, float* a );
+lapack_int LAPACKE_dpftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, double* a );
+lapack_int LAPACKE_cpftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftrf( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, float* a );
+lapack_int LAPACKE_dpftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, double* a );
+lapack_int LAPACKE_cpftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftri( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs, const float* a,
+                           float* b, lapack_int ldb );
+lapack_int LAPACKE_dpftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs, const double* a,
+                           double* b, lapack_int ldb );
+lapack_int LAPACKE_cpftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* a,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpftrs( int matrix_order, char transr, char uplo,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* a,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spocon( int matrix_order, char uplo, lapack_int n,
+                           const float* a, lapack_int lda, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dpocon( int matrix_order, char uplo, lapack_int n,
+                           const double* a, lapack_int lda, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_cpocon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_zpocon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double anorm, double* rcond );
+
+lapack_int LAPACKE_spoequ( int matrix_order, lapack_int n, const float* a,
+                           lapack_int lda, float* s, float* scond,
+                           float* amax );
+lapack_int LAPACKE_dpoequ( int matrix_order, lapack_int n, const double* a,
+                           lapack_int lda, double* s, double* scond,
+                           double* amax );
+lapack_int LAPACKE_cpoequ( int matrix_order, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequ( int matrix_order, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_spoequb( int matrix_order, lapack_int n, const float* a,
+                            lapack_int lda, float* s, float* scond,
+                            float* amax );
+lapack_int LAPACKE_dpoequb( int matrix_order, lapack_int n, const double* a,
+                            lapack_int lda, double* s, double* scond,
+                            double* amax );
+lapack_int LAPACKE_cpoequb( int matrix_order, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequb( int matrix_order, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_sporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const float* af, lapack_int ldaf, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const double* af, lapack_int ldaf, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_complex_float* b,
+                           lapack_int ldb, lapack_complex_float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_zporfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+
+lapack_int LAPACKE_sporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const float* a,
+                            lapack_int lda, const float* af, lapack_int ldaf,
+                            const float* s, const float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const double* a,
+                            lapack_int lda, const double* af, lapack_int ldaf,
+                            const double* s, const double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const float* s, const lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zporfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const double* s, const lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_sposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* a, lapack_int lda, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* a, lapack_int lda, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* a,
+                          lapack_int lda, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zposv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* a,
+                          lapack_int lda, lapack_complex_double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dsposv( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           lapack_int* iter );
+lapack_int LAPACKE_zcposv( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, lapack_complex_double* x,
+                           lapack_int ldx, lapack_int* iter );
+
+lapack_int LAPACKE_sposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, float* a, lapack_int lda, float* af,
+                           lapack_int ldaf, char* equed, float* s, float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_dposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, double* a, lapack_int lda,
+                           double* af, lapack_int ldaf, char* equed, double* s,
+                           double* b, lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+lapack_int LAPACKE_cposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* af,
+                           lapack_int ldaf, char* equed, float* s,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zposvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* af,
+                           lapack_int ldaf, char* equed, double* s,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_sposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, float* a,
+                            lapack_int lda, float* af, lapack_int ldaf,
+                            char* equed, float* s, float* b, lapack_int ldb,
+                            float* x, lapack_int ldx, float* rcond,
+                            float* rpvgrw, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_dposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, double* a,
+                            lapack_int lda, double* af, lapack_int ldaf,
+                            char* equed, double* s, double* b, lapack_int ldb,
+                            double* x, lapack_int ldx, double* rcond,
+                            double* rpvgrw, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+lapack_int LAPACKE_cposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            char* equed, float* s, lapack_complex_float* b,
+                            lapack_int ldb, lapack_complex_float* x,
+                            lapack_int ldx, float* rcond, float* rpvgrw,
+                            float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zposvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            char* equed, double* s, lapack_complex_double* b,
+                            lapack_int ldb, lapack_complex_double* x,
+                            lapack_int ldx, double* rcond, double* rpvgrw,
+                            double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_spotrf( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dpotrf( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_cpotrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotri( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dpotri( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_cpotri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           float* b, lapack_int ldb );
+lapack_int LAPACKE_dpotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           double* b, lapack_int ldb );
+lapack_int LAPACKE_cpotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zpotrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_sppcon( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, float anorm, float* rcond );
+lapack_int LAPACKE_dppcon( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, double anorm, double* rcond );
+lapack_int LAPACKE_cppcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_zppcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sppequ( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, float* s, float* scond,
+                           float* amax );
+lapack_int LAPACKE_dppequ( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, double* s, double* scond,
+                           double* amax );
+lapack_int LAPACKE_cppequ( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap, float* s,
+                           float* scond, float* amax );
+lapack_int LAPACKE_zppequ( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap, double* s,
+                           double* scond, double* amax );
+
+lapack_int LAPACKE_spprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, const float* afp,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dpprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, const double* afp,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_cpprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_complex_float* afp,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zpprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_complex_double* afp,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* ap, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* ap, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_cppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* ap,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zppsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* ap,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, float* ap, float* afp, char* equed,
+                           float* s, float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, double* ap, double* afp,
+                           char* equed, double* s, double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_float* ap,
+                           lapack_complex_float* afp, char* equed, float* s,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zppsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, lapack_complex_double* ap,
+                           lapack_complex_double* afp, char* equed, double* s,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_spptrf( int matrix_order, char uplo, lapack_int n,
+                           float* ap );
+lapack_int LAPACKE_dpptrf( int matrix_order, char uplo, lapack_int n,
+                           double* ap );
+lapack_int LAPACKE_cpptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_zpptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptri( int matrix_order, char uplo, lapack_int n,
+                           float* ap );
+lapack_int LAPACKE_dpptri( int matrix_order, char uplo, lapack_int n,
+                           double* ap );
+lapack_int LAPACKE_cpptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_zpptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dpptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_cpptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spstrf( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, lapack_int* piv, lapack_int* rank,
+                           float tol );
+lapack_int LAPACKE_dpstrf( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, lapack_int* piv, lapack_int* rank,
+                           double tol );
+lapack_int LAPACKE_cpstrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* piv, lapack_int* rank, float tol );
+lapack_int LAPACKE_zpstrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* piv, lapack_int* rank, double tol );
+
+lapack_int LAPACKE_sptcon( lapack_int n, const float* d, const float* e,
+                           float anorm, float* rcond );
+lapack_int LAPACKE_dptcon( lapack_int n, const double* d, const double* e,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cptcon( lapack_int n, const float* d,
+                           const lapack_complex_float* e, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_zptcon( lapack_int n, const double* d,
+                           const lapack_complex_double* e, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_spteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dpteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, double* z, lapack_int ldz );
+lapack_int LAPACKE_cpteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zpteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_sptrfs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const float* d, const float* e, const float* df,
+                           const float* ef, const float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dptrfs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const double* d, const double* e, const double* df,
+                           const double* ef, const double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* ferr,
+                           double* berr );
+lapack_int LAPACKE_cptrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* d,
+                           const lapack_complex_float* e, const float* df,
+                           const lapack_complex_float* ef,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zptrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* d,
+                           const lapack_complex_double* e, const double* df,
+                           const lapack_complex_double* ef,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* d, float* e, float* b, lapack_int ldb );
+lapack_int LAPACKE_dptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* d, double* e, double* b, lapack_int ldb );
+lapack_int LAPACKE_cptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          float* d, lapack_complex_float* e,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zptsv( int matrix_order, lapack_int n, lapack_int nrhs,
+                          double* d, lapack_complex_double* e,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const float* d, const float* e,
+                           float* df, float* ef, const float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const double* d, const double* e,
+                           double* df, double* ef, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+lapack_int LAPACKE_cptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const float* d,
+                           const lapack_complex_float* e, float* df,
+                           lapack_complex_float* ef,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zptsvx( int matrix_order, char fact, lapack_int n,
+                           lapack_int nrhs, const double* d,
+                           const lapack_complex_double* e, double* df,
+                           lapack_complex_double* ef,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_spttrf( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dpttrf( lapack_int n, double* d, double* e );
+lapack_int LAPACKE_cpttrf( lapack_int n, float* d, lapack_complex_float* e );
+lapack_int LAPACKE_zpttrf( lapack_int n, double* d, lapack_complex_double* e );
+
+lapack_int LAPACKE_spttrs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const float* d, const float* e, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dpttrs( int matrix_order, lapack_int n, lapack_int nrhs,
+                           const double* d, const double* e, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_cpttrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* d,
+                           const lapack_complex_float* e,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpttrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* d,
+                           const lapack_complex_double* e,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, float* ab, lapack_int ldab, float* w,
+                          float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int kd, double* ab, lapack_int ldab, double* w,
+                          double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, float* ab, lapack_int ldab, float* w,
+                           float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int kd, double* ab, lapack_int ldab,
+                           double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd, float* ab,
+                           lapack_int ldab, float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsbevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int kd, double* ab,
+                           lapack_int ldab, double* q, lapack_int ldq,
+                           double vl, double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, float* ab,
+                           lapack_int ldab, const float* bb, lapack_int ldbb,
+                           float* x, lapack_int ldx );
+lapack_int LAPACKE_dsbgst( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, double* ab,
+                           lapack_int ldab, const double* bb, lapack_int ldbb,
+                           double* x, lapack_int ldx );
+
+lapack_int LAPACKE_ssbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb, float* ab,
+                          lapack_int ldab, float* bb, lapack_int ldbb, float* w,
+                          float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbgv( int matrix_order, char jobz, char uplo, lapack_int n,
+                          lapack_int ka, lapack_int kb, double* ab,
+                          lapack_int ldab, double* bb, lapack_int ldbb,
+                          double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, float* ab,
+                           lapack_int ldab, float* bb, lapack_int ldbb,
+                           float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dsbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           lapack_int ka, lapack_int kb, double* ab,
+                           lapack_int ldab, double* bb, lapack_int ldbb,
+                           double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_ssbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           float* ab, lapack_int ldab, float* bb,
+                           lapack_int ldbb, float* q, lapack_int ldq, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           double* ab, lapack_int ldab, double* bb,
+                           lapack_int ldbb, double* q, lapack_int ldq,
+                           double vl, double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, float* ab, lapack_int ldab, float* d,
+                           float* e, float* q, lapack_int ldq );
+lapack_int LAPACKE_dsbtrd( int matrix_order, char vect, char uplo, lapack_int n,
+                           lapack_int kd, double* ab, lapack_int ldab,
+                           double* d, double* e, double* q, lapack_int ldq );
+
+lapack_int LAPACKE_ssfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, float alpha,
+                          const float* a, lapack_int lda, float beta,
+                          float* c );
+lapack_int LAPACKE_dsfrk( int matrix_order, char transr, char uplo, char trans,
+                          lapack_int n, lapack_int k, double alpha,
+                          const double* a, lapack_int lda, double beta,
+                          double* c );
+
+lapack_int LAPACKE_sspcon( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, const lapack_int* ipiv, float anorm,
+                           float* rcond );
+lapack_int LAPACKE_dspcon( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, const lapack_int* ipiv,
+                           double anorm, double* rcond );
+lapack_int LAPACKE_cspcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zspcon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_sspev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          float* ap, float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          double* ap, double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           float* ap, float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           double* ap, double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, float* ap, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dspevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, double* ap, double vl, double vu,
+                           lapack_int il, lapack_int iu, double abstol,
+                           lapack_int* m, double* w, double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_sspgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, float* ap, const float* bp );
+lapack_int LAPACKE_dspgst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, double* ap, const double* bp );
+
+lapack_int LAPACKE_sspgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, float* ap, float* bp,
+                          float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspgv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, double* ap, double* bp,
+                          double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, float* ap, float* bp,
+                           float* w, float* z, lapack_int ldz );
+lapack_int LAPACKE_dspgvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, double* ap, double* bp,
+                           double* w, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sspgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, float* ap,
+                           float* bp, float vl, float vu, lapack_int il,
+                           lapack_int iu, float abstol, lapack_int* m, float* w,
+                           float* z, lapack_int ldz, lapack_int* ifail );
+lapack_int LAPACKE_dspgvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, double* ap,
+                           double* bp, double vl, double vu, lapack_int il,
+                           lapack_int iu, double abstol, lapack_int* m,
+                           double* w, double* z, lapack_int ldz,
+                           lapack_int* ifail );
+
+lapack_int LAPACKE_ssprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, const float* afp,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dsprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, const double* afp,
+                           const lapack_int* ipiv, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_csprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_complex_float* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zsprfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_complex_double* afp,
+                           const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_sspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* ap, lapack_int* ipiv,
+                          float* b, lapack_int ldb );
+lapack_int LAPACKE_dspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* ap, lapack_int* ipiv,
+                          double* b, lapack_int ldb );
+lapack_int LAPACKE_cspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* ap,
+                          lapack_int* ipiv, lapack_complex_float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_zspsv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* ap,
+                          lapack_int* ipiv, lapack_complex_double* b,
+                          lapack_int ldb );
+
+lapack_int LAPACKE_sspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap, float* afp,
+                           lapack_int* ipiv, const float* b, lapack_int ldb,
+                           float* x, lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap, double* afp,
+                           lapack_int* ipiv, const double* b, lapack_int ldb,
+                           double* x, lapack_int ldx, double* rcond,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_cspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           lapack_complex_float* afp, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zspsvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           lapack_complex_double* afp, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_ssptrd( int matrix_order, char uplo, lapack_int n, float* ap,
+                           float* d, float* e, float* tau );
+lapack_int LAPACKE_dsptrd( int matrix_order, char uplo, lapack_int n,
+                           double* ap, double* d, double* e, double* tau );
+
+lapack_int LAPACKE_ssptrf( int matrix_order, char uplo, lapack_int n, float* ap,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_dsptrf( int matrix_order, char uplo, lapack_int n,
+                           double* ap, lapack_int* ipiv );
+lapack_int LAPACKE_csptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zsptrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_ssptri( int matrix_order, char uplo, lapack_int n, float* ap,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_dsptri( int matrix_order, char uplo, lapack_int n,
+                           double* ap, const lapack_int* ipiv );
+lapack_int LAPACKE_csptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* ap, const lapack_int* ipiv );
+lapack_int LAPACKE_zsptri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* ap, const lapack_int* ipiv );
+
+lapack_int LAPACKE_ssptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* ap,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dsptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* ap,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_csptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* ap,
+                           const lapack_int* ipiv, lapack_complex_float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_zsptrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* ap,
+                           const lapack_int* ipiv, lapack_complex_double* b,
+                           lapack_int ldb );
+
+lapack_int LAPACKE_sstebz( char range, char order, lapack_int n, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           const float* d, const float* e, lapack_int* m,
+                           lapack_int* nsplit, float* w, lapack_int* iblock,
+                           lapack_int* isplit );
+lapack_int LAPACKE_dstebz( char range, char order, lapack_int n, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, const double* d, const double* e,
+                           lapack_int* m, lapack_int* nsplit, double* w,
+                           lapack_int* iblock, lapack_int* isplit );
+
+lapack_int LAPACKE_sstedc( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dstedc( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, double* z, lapack_int ldz );
+lapack_int LAPACKE_cstedc( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zstedc( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_sstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_dstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* isuppz );
+lapack_int LAPACKE_cstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* isuppz );
+lapack_int LAPACKE_zstegr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* isuppz );
+
+lapack_int LAPACKE_sstein( int matrix_order, lapack_int n, const float* d,
+                           const float* e, lapack_int m, const float* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           float* z, lapack_int ldz, lapack_int* ifailv );
+lapack_int LAPACKE_dstein( int matrix_order, lapack_int n, const double* d,
+                           const double* e, lapack_int m, const double* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           double* z, lapack_int ldz, lapack_int* ifailv );
+lapack_int LAPACKE_cstein( int matrix_order, lapack_int n, const float* d,
+                           const float* e, lapack_int m, const float* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int* ifailv );
+lapack_int LAPACKE_zstein( int matrix_order, lapack_int n, const double* d,
+                           const double* e, lapack_int m, const double* w,
+                           const lapack_int* iblock, const lapack_int* isplit,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* ifailv );
+
+lapack_int LAPACKE_sstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, lapack_int* m,
+                           float* w, float* z, lapack_int ldz, lapack_int nzc,
+                           lapack_int* isuppz, lapack_logical* tryrac );
+lapack_int LAPACKE_dstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           lapack_int* m, double* w, double* z, lapack_int ldz,
+                           lapack_int nzc, lapack_int* isuppz,
+                           lapack_logical* tryrac );
+lapack_int LAPACKE_cstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, lapack_int* m,
+                           float* w, lapack_complex_float* z, lapack_int ldz,
+                           lapack_int nzc, lapack_int* isuppz,
+                           lapack_logical* tryrac );
+lapack_int LAPACKE_zstemr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           lapack_int* m, double* w, lapack_complex_double* z,
+                           lapack_int ldz, lapack_int nzc, lapack_int* isuppz,
+                           lapack_logical* tryrac );
+
+lapack_int LAPACKE_ssteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dsteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, double* z, lapack_int ldz );
+lapack_int LAPACKE_csteqr( int matrix_order, char compz, lapack_int n, float* d,
+                           float* e, lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zsteqr( int matrix_order, char compz, lapack_int n,
+                           double* d, double* e, lapack_complex_double* z,
+                           lapack_int ldz );
+
+lapack_int LAPACKE_ssterf( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dsterf( lapack_int n, double* d, double* e );
+
+lapack_int LAPACKE_sstev( int matrix_order, char jobz, lapack_int n, float* d,
+                          float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dstev( int matrix_order, char jobz, lapack_int n, double* d,
+                          double* e, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sstevd( int matrix_order, char jobz, lapack_int n, float* d,
+                           float* e, float* z, lapack_int ldz );
+lapack_int LAPACKE_dstevd( int matrix_order, char jobz, lapack_int n, double* d,
+                           double* e, double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sstevr( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_dstevr( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* isuppz );
+
+lapack_int LAPACKE_sstevx( int matrix_order, char jobz, char range,
+                           lapack_int n, float* d, float* e, float vl, float vu,
+                           lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dstevx( int matrix_order, char jobz, char range,
+                           lapack_int n, double* d, double* e, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssycon( int matrix_order, char uplo, lapack_int n,
+                           const float* a, lapack_int lda,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_dsycon( int matrix_order, char uplo, lapack_int n,
+                           const double* a, lapack_int lda,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+lapack_int LAPACKE_csycon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv, float anorm, float* rcond );
+lapack_int LAPACKE_zsycon( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv, double anorm,
+                           double* rcond );
+
+lapack_int LAPACKE_ssyequb( int matrix_order, char uplo, lapack_int n,
+                            const float* a, lapack_int lda, float* s,
+                            float* scond, float* amax );
+lapack_int LAPACKE_dsyequb( int matrix_order, char uplo, lapack_int n,
+                            const double* a, lapack_int lda, double* s,
+                            double* scond, double* amax );
+lapack_int LAPACKE_csyequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_float* a, lapack_int lda,
+                            float* s, float* scond, float* amax );
+lapack_int LAPACKE_zsyequb( int matrix_order, char uplo, lapack_int n,
+                            const lapack_complex_double* a, lapack_int lda,
+                            double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_ssyev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_dsyev( int matrix_order, char jobz, char uplo, lapack_int n,
+                          double* a, lapack_int lda, double* w );
+
+lapack_int LAPACKE_ssyevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           float* a, lapack_int lda, float* w );
+lapack_int LAPACKE_dsyevd( int matrix_order, char jobz, char uplo, lapack_int n,
+                           double* a, lapack_int lda, double* w );
+
+lapack_int LAPACKE_ssyevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, float* a, lapack_int lda, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* isuppz );
+lapack_int LAPACKE_dsyevr( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, double* a, lapack_int lda, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* isuppz );
+
+lapack_int LAPACKE_ssyevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, float* a, lapack_int lda, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsyevx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, double* a, lapack_int lda, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssygst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, float* a, lapack_int lda,
+                           const float* b, lapack_int ldb );
+lapack_int LAPACKE_dsygst( int matrix_order, lapack_int itype, char uplo,
+                           lapack_int n, double* a, lapack_int lda,
+                           const double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssygv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, float* a, lapack_int lda,
+                          float* b, lapack_int ldb, float* w );
+lapack_int LAPACKE_dsygv( int matrix_order, lapack_int itype, char jobz,
+                          char uplo, lapack_int n, double* a, lapack_int lda,
+                          double* b, lapack_int ldb, double* w );
+
+lapack_int LAPACKE_ssygvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, float* a, lapack_int lda,
+                           float* b, lapack_int ldb, float* w );
+lapack_int LAPACKE_dsygvd( int matrix_order, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, double* a, lapack_int lda,
+                           double* b, lapack_int ldb, double* w );
+
+lapack_int LAPACKE_ssygvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb, float vl,
+                           float vu, lapack_int il, lapack_int iu, float abstol,
+                           lapack_int* m, float* w, float* z, lapack_int ldz,
+                           lapack_int* ifail );
+lapack_int LAPACKE_dsygvx( int matrix_order, lapack_int itype, char jobz,
+                           char range, char uplo, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb, double vl,
+                           double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail );
+
+lapack_int LAPACKE_ssyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const float* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const float* b,
+                           lapack_int ldb, float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dsyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const double* af, lapack_int ldaf,
+                           const lapack_int* ipiv, const double* b,
+                           lapack_int ldb, double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_csyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_zsyrfs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* af,
+                           lapack_int ldaf, const lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_ssyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const float* a,
+                            lapack_int lda, const float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* s,
+                            const float* b, lapack_int ldb, float* x,
+                            lapack_int ldx, float* rcond, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dsyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs, const double* a,
+                            lapack_int lda, const double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* s,
+                            const double* b, lapack_int ldb, double* x,
+                            lapack_int ldx, double* rcond, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+lapack_int LAPACKE_csyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_float* a, lapack_int lda,
+                            const lapack_complex_float* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const float* s,
+                            const lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* berr, lapack_int n_err_bnds,
+                            float* err_bnds_norm, float* err_bnds_comp,
+                            lapack_int nparams, float* params );
+lapack_int LAPACKE_zsyrfsx( int matrix_order, char uplo, char equed,
+                            lapack_int n, lapack_int nrhs,
+                            const lapack_complex_double* a, lapack_int lda,
+                            const lapack_complex_double* af, lapack_int ldaf,
+                            const lapack_int* ipiv, const double* s,
+                            const lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* berr, lapack_int n_err_bnds,
+                            double* err_bnds_norm, double* err_bnds_comp,
+                            lapack_int nparams, double* params );
+
+lapack_int LAPACKE_ssysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, float* a, lapack_int lda,
+                          lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dsysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, double* a, lapack_int lda,
+                          lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_csysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_float* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zsysv( int matrix_order, char uplo, lapack_int n,
+                          lapack_int nrhs, lapack_complex_double* a,
+                          lapack_int lda, lapack_int* ipiv,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           float* af, lapack_int ldaf, lapack_int* ipiv,
+                           const float* b, lapack_int ldb, float* x,
+                           lapack_int ldx, float* rcond, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dsysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           double* af, lapack_int ldaf, lapack_int* ipiv,
+                           const double* b, lapack_int ldb, double* x,
+                           lapack_int ldx, double* rcond, double* ferr,
+                           double* berr );
+lapack_int LAPACKE_csysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* x, lapack_int ldx,
+                           float* rcond, float* ferr, float* berr );
+lapack_int LAPACKE_zsysvx( int matrix_order, char fact, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* af,
+                           lapack_int ldaf, lapack_int* ipiv,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* x, lapack_int ldx,
+                           double* rcond, double* ferr, double* berr );
+
+lapack_int LAPACKE_ssysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, float* a,
+                            lapack_int lda, float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* s, float* b,
+                            lapack_int ldb, float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_dsysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs, double* a,
+                            lapack_int lda, double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* s, double* b,
+                            lapack_int ldb, double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+lapack_int LAPACKE_csysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, float* s,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* x, lapack_int ldx,
+                            float* rcond, float* rpvgrw, float* berr,
+                            lapack_int n_err_bnds, float* err_bnds_norm,
+                            float* err_bnds_comp, lapack_int nparams,
+                            float* params );
+lapack_int LAPACKE_zsysvxx( int matrix_order, char fact, char uplo,
+                            lapack_int n, lapack_int nrhs,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* af, lapack_int ldaf,
+                            lapack_int* ipiv, char* equed, double* s,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* x, lapack_int ldx,
+                            double* rcond, double* rpvgrw, double* berr,
+                            lapack_int n_err_bnds, double* err_bnds_norm,
+                            double* err_bnds_comp, lapack_int nparams,
+                            double* params );
+
+lapack_int LAPACKE_ssytrd( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, float* d, float* e, float* tau );
+lapack_int LAPACKE_dsytrd( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, double* d, double* e, double* tau );
+
+lapack_int LAPACKE_ssytrf( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dsytrf( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_csytrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_int* ipiv );
+lapack_int LAPACKE_zsytrf( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_int* ipiv );
+
+lapack_int LAPACKE_ssytri( int matrix_order, char uplo, lapack_int n, float* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dsytri( int matrix_order, char uplo, lapack_int n, double* a,
+                           lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_csytri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_int* ipiv );
+lapack_int LAPACKE_zsytri( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_int* ipiv );
+
+lapack_int LAPACKE_ssytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const float* a, lapack_int lda,
+                           const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_dsytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const double* a, lapack_int lda,
+                           const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_csytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zsytrs( int matrix_order, char uplo, lapack_int n,
+                           lapack_int nrhs, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_int* ipiv,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd, const float* ab,
+                           lapack_int ldab, float* rcond );
+lapack_int LAPACKE_dtbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd, const double* ab,
+                           lapack_int ldab, double* rcond );
+lapack_int LAPACKE_ctbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           float* rcond );
+lapack_int LAPACKE_ztbcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, lapack_int kd,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           double* rcond );
+
+lapack_int LAPACKE_stbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const float* ab, lapack_int ldab, const float* b,
+                           lapack_int ldb, const float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_dtbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const double* ab, lapack_int ldab, const double* b,
+                           lapack_int ldb, const double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+lapack_int LAPACKE_ctbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_ztbrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_stbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const float* ab, lapack_int ldab, float* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_dtbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const double* ab, lapack_int ldab, double* b,
+                           lapack_int ldb );
+lapack_int LAPACKE_ctbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_float* ab, lapack_int ldab,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztbtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int kd, lapack_int nrhs,
+                           const lapack_complex_double* ab, lapack_int ldab,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          float alpha, const float* a, float* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_dtfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          double alpha, const double* a, double* b,
+                          lapack_int ldb );
+lapack_int LAPACKE_ctfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          lapack_complex_float alpha,
+                          const lapack_complex_float* a,
+                          lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztfsm( int matrix_order, char transr, char side, char uplo,
+                          char trans, char diag, lapack_int m, lapack_int n,
+                          lapack_complex_double alpha,
+                          const lapack_complex_double* a,
+                          lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, float* a );
+lapack_int LAPACKE_dtftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, double* a );
+lapack_int LAPACKE_ctftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_ztftri( int matrix_order, char transr, char uplo, char diag,
+                           lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_stfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* arf, float* ap );
+lapack_int LAPACKE_dtfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* arf, double* ap );
+lapack_int LAPACKE_ctfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* arf,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_ztfttp( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* arf,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_stfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* arf, float* a,
+                           lapack_int lda );
+lapack_int LAPACKE_dtfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* arf, double* a,
+                           lapack_int lda );
+lapack_int LAPACKE_ctfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* arf,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztfttr( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* arf,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_stgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const float* s, lapack_int lds, const float* p,
+                           lapack_int ldp, float* vl, lapack_int ldvl,
+                           float* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_dtgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const double* s, lapack_int lds, const double* p,
+                           lapack_int ldp, double* vl, lapack_int ldvl,
+                           double* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_ctgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* s, lapack_int lds,
+                           const lapack_complex_float* p, lapack_int ldp,
+                           lapack_complex_float* vl, lapack_int ldvl,
+                           lapack_complex_float* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztgevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* s, lapack_int lds,
+                           const lapack_complex_double* p, lapack_int ldp,
+                           lapack_complex_double* vl, lapack_int ldvl,
+                           lapack_complex_double* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+
+lapack_int LAPACKE_stgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb, float* q,
+                           lapack_int ldq, float* z, lapack_int ldz,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_dtgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n, double* a,
+                           lapack_int lda, double* b, lapack_int ldb, double* q,
+                           lapack_int ldq, double* z, lapack_int ldz,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_ctgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* z, lapack_int ldz,
+                           lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztgexc( int matrix_order, lapack_logical wantq,
+                           lapack_logical wantz, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_stgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n, float* a,
+                           lapack_int lda, float* b, lapack_int ldb,
+                           float* alphar, float* alphai, float* beta, float* q,
+                           lapack_int ldq, float* z, lapack_int ldz,
+                           lapack_int* m, float* pl, float* pr, float* dif );
+lapack_int LAPACKE_dtgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n,
+                           double* a, lapack_int lda, double* b, lapack_int ldb,
+                           double* alphar, double* alphai, double* beta,
+                           double* q, lapack_int ldq, double* z, lapack_int ldz,
+                           lapack_int* m, double* pl, double* pr, double* dif );
+lapack_int LAPACKE_ctgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* alpha,
+                           lapack_complex_float* beta, lapack_complex_float* q,
+                           lapack_int ldq, lapack_complex_float* z,
+                           lapack_int ldz, lapack_int* m, float* pl, float* pr,
+                           float* dif );
+lapack_int LAPACKE_ztgsen( int matrix_order, lapack_int ijob,
+                           lapack_logical wantq, lapack_logical wantz,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* alpha,
+                           lapack_complex_double* beta,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* z, lapack_int ldz,
+                           lapack_int* m, double* pl, double* pr, double* dif );
+
+lapack_int LAPACKE_stgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, float* a, lapack_int lda,
+                           float* b, lapack_int ldb, float tola, float tolb,
+                           float* alpha, float* beta, float* u, lapack_int ldu,
+                           float* v, lapack_int ldv, float* q, lapack_int ldq,
+                           lapack_int* ncycle );
+lapack_int LAPACKE_dtgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, double* a,
+                           lapack_int lda, double* b, lapack_int ldb,
+                           double tola, double tolb, double* alpha,
+                           double* beta, double* u, lapack_int ldu, double* v,
+                           lapack_int ldv, double* q, lapack_int ldq,
+                           lapack_int* ncycle );
+lapack_int LAPACKE_ctgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* b,
+                           lapack_int ldb, float tola, float tolb, float* alpha,
+                           float* beta, lapack_complex_float* u, lapack_int ldu,
+                           lapack_complex_float* v, lapack_int ldv,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_int* ncycle );
+lapack_int LAPACKE_ztgsja( int matrix_order, char jobu, char jobv, char jobq,
+                           lapack_int m, lapack_int p, lapack_int n,
+                           lapack_int k, lapack_int l, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* b,
+                           lapack_int ldb, double tola, double tolb,
+                           double* alpha, double* beta,
+                           lapack_complex_double* u, lapack_int ldu,
+                           lapack_complex_double* v, lapack_int ldv,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_int* ncycle );
+
+lapack_int LAPACKE_stgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const float* a, lapack_int lda, const float* b,
+                           lapack_int ldb, const float* vl, lapack_int ldvl,
+                           const float* vr, lapack_int ldvr, float* s,
+                           float* dif, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_dtgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const double* a, lapack_int lda, const double* b,
+                           lapack_int ldb, const double* vl, lapack_int ldvl,
+                           const double* vr, lapack_int ldvr, double* s,
+                           double* dif, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ctgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* vl, lapack_int ldvl,
+                           const lapack_complex_float* vr, lapack_int ldvr,
+                           float* s, float* dif, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztgsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* vl, lapack_int ldvl,
+                           const lapack_complex_double* vr, lapack_int ldvr,
+                           double* s, double* dif, lapack_int mm,
+                           lapack_int* m );
+
+lapack_int LAPACKE_stgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n, const float* a,
+                           lapack_int lda, const float* b, lapack_int ldb,
+                           float* c, lapack_int ldc, const float* d,
+                           lapack_int ldd, const float* e, lapack_int lde,
+                           float* f, lapack_int ldf, float* scale, float* dif );
+lapack_int LAPACKE_dtgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n, const double* a,
+                           lapack_int lda, const double* b, lapack_int ldb,
+                           double* c, lapack_int ldc, const double* d,
+                           lapack_int ldd, const double* e, lapack_int lde,
+                           double* f, lapack_int ldf, double* scale,
+                           double* dif );
+lapack_int LAPACKE_ctgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* c, lapack_int ldc,
+                           const lapack_complex_float* d, lapack_int ldd,
+                           const lapack_complex_float* e, lapack_int lde,
+                           lapack_complex_float* f, lapack_int ldf,
+                           float* scale, float* dif );
+lapack_int LAPACKE_ztgsyl( int matrix_order, char trans, lapack_int ijob,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* c, lapack_int ldc,
+                           const lapack_complex_double* d, lapack_int ldd,
+                           const lapack_complex_double* e, lapack_int lde,
+                           lapack_complex_double* f, lapack_int ldf,
+                           double* scale, double* dif );
+
+lapack_int LAPACKE_stpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const float* ap, float* rcond );
+lapack_int LAPACKE_dtpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const double* ap, double* rcond );
+lapack_int LAPACKE_ctpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_float* ap,
+                           float* rcond );
+lapack_int LAPACKE_ztpcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_double* ap,
+                           double* rcond );
+
+lapack_int LAPACKE_stprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* ap,
+                           const float* b, lapack_int ldb, const float* x,
+                           lapack_int ldx, float* ferr, float* berr );
+lapack_int LAPACKE_dtprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* ap,
+                           const double* b, lapack_int ldb, const double* x,
+                           lapack_int ldx, double* ferr, double* berr );
+lapack_int LAPACKE_ctprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* ap,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_ztprfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* ap,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_stptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           float* ap );
+lapack_int LAPACKE_dtptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           double* ap );
+lapack_int LAPACKE_ctptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_ztptri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_stptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* ap,
+                           float* b, lapack_int ldb );
+lapack_int LAPACKE_dtptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* ap,
+                           double* b, lapack_int ldb );
+lapack_int LAPACKE_ctptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* ap,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztptrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* ap,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* ap, float* arf );
+lapack_int LAPACKE_dtpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* ap, double* arf );
+lapack_int LAPACKE_ctpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* ap,
+                           lapack_complex_float* arf );
+lapack_int LAPACKE_ztpttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* ap,
+                           lapack_complex_double* arf );
+
+lapack_int LAPACKE_stpttr( int matrix_order, char uplo, lapack_int n,
+                           const float* ap, float* a, lapack_int lda );
+lapack_int LAPACKE_dtpttr( int matrix_order, char uplo, lapack_int n,
+                           const double* ap, double* a, lapack_int lda );
+lapack_int LAPACKE_ctpttr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztpttr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_strcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const float* a, lapack_int lda,
+                           float* rcond );
+lapack_int LAPACKE_dtrcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const double* a, lapack_int lda,
+                           double* rcond );
+lapack_int LAPACKE_ctrcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda, float* rcond );
+lapack_int LAPACKE_ztrcon( int matrix_order, char norm, char uplo, char diag,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda, double* rcond );
+
+lapack_int LAPACKE_strevc( int matrix_order, char side, char howmny,
+                           lapack_logical* select, lapack_int n, const float* t,
+                           lapack_int ldt, float* vl, lapack_int ldvl,
+                           float* vr, lapack_int ldvr, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_dtrevc( int matrix_order, char side, char howmny,
+                           lapack_logical* select, lapack_int n,
+                           const double* t, lapack_int ldt, double* vl,
+                           lapack_int ldvl, double* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ctrevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* vl, lapack_int ldvl,
+                           lapack_complex_float* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztrevc( int matrix_order, char side, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* vl, lapack_int ldvl,
+                           lapack_complex_double* vr, lapack_int ldvr,
+                           lapack_int mm, lapack_int* m );
+
+lapack_int LAPACKE_strexc( int matrix_order, char compq, lapack_int n, float* t,
+                           lapack_int ldt, float* q, lapack_int ldq,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_dtrexc( int matrix_order, char compq, lapack_int n,
+                           double* t, lapack_int ldt, double* q, lapack_int ldq,
+                           lapack_int* ifst, lapack_int* ilst );
+lapack_int LAPACKE_ctrexc( int matrix_order, char compq, lapack_int n,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztrexc( int matrix_order, char compq, lapack_int n,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_strrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* a,
+                           lapack_int lda, const float* b, lapack_int ldb,
+                           const float* x, lapack_int ldx, float* ferr,
+                           float* berr );
+lapack_int LAPACKE_dtrrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* a,
+                           lapack_int lda, const double* b, lapack_int ldb,
+                           const double* x, lapack_int ldx, double* ferr,
+                           double* berr );
+lapack_int LAPACKE_ctrrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           const lapack_complex_float* x, lapack_int ldx,
+                           float* ferr, float* berr );
+lapack_int LAPACKE_ztrrfs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           const lapack_complex_double* x, lapack_int ldx,
+                           double* ferr, double* berr );
+
+lapack_int LAPACKE_strsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n, float* t,
+                           lapack_int ldt, float* q, lapack_int ldq, float* wr,
+                           float* wi, lapack_int* m, float* s, float* sep );
+lapack_int LAPACKE_dtrsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n,
+                           double* t, lapack_int ldt, double* q, lapack_int ldq,
+                           double* wr, double* wi, lapack_int* m, double* s,
+                           double* sep );
+lapack_int LAPACKE_ctrsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* q, lapack_int ldq,
+                           lapack_complex_float* w, lapack_int* m, float* s,
+                           float* sep );
+lapack_int LAPACKE_ztrsen( int matrix_order, char job, char compq,
+                           const lapack_logical* select, lapack_int n,
+                           lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* q, lapack_int ldq,
+                           lapack_complex_double* w, lapack_int* m, double* s,
+                           double* sep );
+
+lapack_int LAPACKE_strsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const float* t, lapack_int ldt, const float* vl,
+                           lapack_int ldvl, const float* vr, lapack_int ldvr,
+                           float* s, float* sep, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_dtrsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const double* t, lapack_int ldt, const double* vl,
+                           lapack_int ldvl, const double* vr, lapack_int ldvr,
+                           double* s, double* sep, lapack_int mm,
+                           lapack_int* m );
+lapack_int LAPACKE_ctrsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_float* t, lapack_int ldt,
+                           const lapack_complex_float* vl, lapack_int ldvl,
+                           const lapack_complex_float* vr, lapack_int ldvr,
+                           float* s, float* sep, lapack_int mm, lapack_int* m );
+lapack_int LAPACKE_ztrsna( int matrix_order, char job, char howmny,
+                           const lapack_logical* select, lapack_int n,
+                           const lapack_complex_double* t, lapack_int ldt,
+                           const lapack_complex_double* vl, lapack_int ldvl,
+                           const lapack_complex_double* vr, lapack_int ldvr,
+                           double* s, double* sep, lapack_int mm,
+                           lapack_int* m );
+
+lapack_int LAPACKE_strsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const float* a, lapack_int lda, const float* b,
+                           lapack_int ldb, float* c, lapack_int ldc,
+                           float* scale );
+lapack_int LAPACKE_dtrsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const double* a, lapack_int lda, const double* b,
+                           lapack_int ldb, double* c, lapack_int ldc,
+                           double* scale );
+lapack_int LAPACKE_ctrsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* b, lapack_int ldb,
+                           lapack_complex_float* c, lapack_int ldc,
+                           float* scale );
+lapack_int LAPACKE_ztrsyl( int matrix_order, char trana, char tranb,
+                           lapack_int isgn, lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* c, lapack_int ldc,
+                           double* scale );
+
+lapack_int LAPACKE_strtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           float* a, lapack_int lda );
+lapack_int LAPACKE_dtrtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           double* a, lapack_int lda );
+lapack_int LAPACKE_ctrtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztrtri( int matrix_order, char uplo, char diag, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_strtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const float* a,
+                           lapack_int lda, float* b, lapack_int ldb );
+lapack_int LAPACKE_dtrtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs, const double* a,
+                           lapack_int lda, double* b, lapack_int ldb );
+lapack_int LAPACKE_ctrtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztrtrs( int matrix_order, char uplo, char trans, char diag,
+                           lapack_int n, lapack_int nrhs,
+                           const lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_strttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const float* a, lapack_int lda,
+                           float* arf );
+lapack_int LAPACKE_dtrttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const double* a, lapack_int lda,
+                           double* arf );
+lapack_int LAPACKE_ctrttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* arf );
+lapack_int LAPACKE_ztrttf( int matrix_order, char transr, char uplo,
+                           lapack_int n, const lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* arf );
+
+lapack_int LAPACKE_strttp( int matrix_order, char uplo, lapack_int n,
+                           const float* a, lapack_int lda, float* ap );
+lapack_int LAPACKE_dtrttp( int matrix_order, char uplo, lapack_int n,
+                           const double* a, lapack_int lda, double* ap );
+lapack_int LAPACKE_ctrttp( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* ap );
+lapack_int LAPACKE_ztrttp( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* ap );
+
+lapack_int LAPACKE_stzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           float* a, lapack_int lda, float* tau );
+lapack_int LAPACKE_dtzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           double* a, lapack_int lda, double* tau );
+lapack_int LAPACKE_ctzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* tau );
+lapack_int LAPACKE_ztzrzf( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungbr( int matrix_order, char vect, lapack_int m,
+                           lapack_int n, lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cunghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zunghr( int matrix_order, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cunglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zunglq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungql( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungqr( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau );
+lapack_int LAPACKE_zungrq( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cungtr( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau );
+lapack_int LAPACKE_zungtr( int matrix_order, char uplo, lapack_int n,
+                           lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau );
+
+lapack_int LAPACKE_cunmbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmbr( int matrix_order, char vect, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmhr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int ilo,
+                           lapack_int ihi, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmlq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmql( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmqr( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmrq( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const lapack_complex_float* a,
+                           lapack_int lda, const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmrz( int matrix_order, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           lapack_int l, const lapack_complex_double* a,
+                           lapack_int lda, const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cunmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_float* a, lapack_int lda,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zunmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_cupgtr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* q, lapack_int ldq );
+lapack_int LAPACKE_zupgtr( int matrix_order, char uplo, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* q, lapack_int ldq );
+
+lapack_int LAPACKE_cupmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_float* ap,
+                           const lapack_complex_float* tau,
+                           lapack_complex_float* c, lapack_int ldc );
+lapack_int LAPACKE_zupmtr( int matrix_order, char side, char uplo, char trans,
+                           lapack_int m, lapack_int n,
+                           const lapack_complex_double* ap,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc );
+
+lapack_int LAPACKE_sbdsdc_work( int matrix_order, char uplo, char compq,
+                                lapack_int n, float* d, float* e, float* u,
+                                lapack_int ldu, float* vt, lapack_int ldvt,
+                                float* q, lapack_int* iq, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dbdsdc_work( int matrix_order, char uplo, char compq,
+                                lapack_int n, double* d, double* e, double* u,
+                                lapack_int ldu, double* vt, lapack_int ldvt,
+                                double* q, lapack_int* iq, double* work,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                float* d, float* e, float* vt, lapack_int ldvt,
+                                float* u, lapack_int ldu, float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_dbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                double* d, double* e, double* vt,
+                                lapack_int ldvt, double* u, lapack_int ldu,
+                                double* c, lapack_int ldc, double* work );
+lapack_int LAPACKE_cbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                float* d, float* e, lapack_complex_float* vt,
+                                lapack_int ldvt, lapack_complex_float* u,
+                                lapack_int ldu, lapack_complex_float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_zbdsqr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int ncvt, lapack_int nru, lapack_int ncc,
+                                double* d, double* e, lapack_complex_double* vt,
+                                lapack_int ldvt, lapack_complex_double* u,
+                                lapack_int ldu, lapack_complex_double* c,
+                                lapack_int ldc, double* work );
+
+lapack_int LAPACKE_sdisna_work( char job, lapack_int m, lapack_int n,
+                                const float* d, float* sep );
+lapack_int LAPACKE_ddisna_work( char job, lapack_int m, lapack_int n,
+                                const double* d, double* sep );
+
+lapack_int LAPACKE_sgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, float* ab, lapack_int ldab,
+                                float* d, float* e, float* q, lapack_int ldq,
+                                float* pt, lapack_int ldpt, float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_dgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, double* ab, lapack_int ldab,
+                                double* d, double* e, double* q, lapack_int ldq,
+                                double* pt, lapack_int ldpt, double* c,
+                                lapack_int ldc, double* work );
+lapack_int LAPACKE_cgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, lapack_complex_float* ab,
+                                lapack_int ldab, float* d, float* e,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* pt, lapack_int ldpt,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgbbrd_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int ncc, lapack_int kl,
+                                lapack_int ku, lapack_complex_double* ab,
+                                lapack_int ldab, double* d, double* e,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* pt, lapack_int ldpt,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                double anorm, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zgbcon_work( int matrix_order, char norm, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* ab,
+                                lapack_int ldab, float* r, float* c,
+                                float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* ab,
+                                lapack_int ldab, double* r, double* c,
+                                double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                float* r, float* c, float* rowcnd,
+                                float* colcnd, float* amax );
+lapack_int LAPACKE_zgbequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, double* r, double* c,
+                                double* rowcnd, double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku, const float* ab,
+                                 lapack_int ldab, float* r, float* c,
+                                 float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_dgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku, const double* ab,
+                                 lapack_int ldab, double* r, double* c,
+                                 double* rowcnd, double* colcnd, double* amax );
+lapack_int LAPACKE_cgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku,
+                                 const lapack_complex_float* ab,
+                                 lapack_int ldab, float* r, float* c,
+                                 float* rowcnd, float* colcnd, float* amax );
+lapack_int LAPACKE_zgbequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_int kl, lapack_int ku,
+                                 const lapack_complex_double* ab,
+                                 lapack_int ldab, double* r, double* c,
+                                 double* rowcnd, double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const float* ab, lapack_int ldab,
+                                const float* afb, lapack_int ldafb,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const double* ab, lapack_int ldab,
+                                const double* afb, lapack_int ldafb,
+                                const lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_complex_float* afb,
+                                lapack_int ldafb, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgbrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab,
+                                const lapack_complex_double* afb,
+                                lapack_int ldafb, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, const float* ab,
+                                 lapack_int ldab, const float* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const float* r, const float* c, const float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, const double* ab,
+                                 lapack_int ldab, const double* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs,
+                                 const lapack_complex_float* ab,
+                                 lapack_int ldab,
+                                 const lapack_complex_float* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const float* r, const float* c,
+                                 const lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zgbrfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs,
+                                 const lapack_complex_double* ab,
+                                 lapack_int ldab,
+                                 const lapack_complex_double* afb,
+                                 lapack_int ldafb, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs, float* ab,
+                               lapack_int ldab, lapack_int* ipiv, float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs, double* ab,
+                               lapack_int ldab, lapack_int* ipiv, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
+                               lapack_int ku, lapack_int nrhs,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+
+lapack_int LAPACKE_sgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, float* ab, lapack_int ldab,
+                                float* afb, lapack_int ldafb, lapack_int* ipiv,
+                                char* equed, float* r, float* c, float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, double* ab, lapack_int ldab,
+                                double* afb, lapack_int ldafb, lapack_int* ipiv,
+                                char* equed, double* r, double* c, double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, lapack_complex_float* ab,
+                                lapack_int ldab, lapack_complex_float* afb,
+                                lapack_int ldafb, lapack_int* ipiv, char* equed,
+                                float* r, float* c, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zgbsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int kl, lapack_int ku,
+                                lapack_int nrhs, lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* afb,
+                                lapack_int ldafb, lapack_int* ipiv, char* equed,
+                                double* r, double* c, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_sgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, float* ab, lapack_int ldab,
+                                 float* afb, lapack_int ldafb, lapack_int* ipiv,
+                                 char* equed, float* r, float* c, float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, double* ab, lapack_int ldab,
+                                 double* afb, lapack_int ldafb,
+                                 lapack_int* ipiv, char* equed, double* r,
+                                 double* c, double* b, lapack_int ldb,
+                                 double* x, lapack_int ldx, double* rcond,
+                                 double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, lapack_complex_float* ab,
+                                 lapack_int ldab, lapack_complex_float* afb,
+                                 lapack_int ldafb, lapack_int* ipiv,
+                                 char* equed, float* r, float* c,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zgbsvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int kl, lapack_int ku,
+                                 lapack_int nrhs, lapack_complex_double* ab,
+                                 lapack_int ldab, lapack_complex_double* afb,
+                                 lapack_int ldafb, lapack_int* ipiv,
+                                 char* equed, double* r, double* c,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, float* ab,
+                                lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_dgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, double* ab,
+                                lapack_int ldab, lapack_int* ipiv );
+lapack_int LAPACKE_cgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_int* ipiv );
+lapack_int LAPACKE_zgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_int* ipiv );
+
+lapack_int LAPACKE_sgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const float* ab, lapack_int ldab,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const double* ab, lapack_int ldab,
+                                const lapack_int* ipiv, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zgbtrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int kl, lapack_int ku, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* scale, lapack_int m, float* v,
+                                lapack_int ldv );
+lapack_int LAPACKE_dgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* scale, lapack_int m, double* v,
+                                lapack_int ldv );
+lapack_int LAPACKE_cgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* scale, lapack_int m,
+                                lapack_complex_float* v, lapack_int ldv );
+lapack_int LAPACKE_zgebak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* scale, lapack_int m,
+                                lapack_complex_double* v, lapack_int ldv );
+
+lapack_int LAPACKE_sgebal_work( int matrix_order, char job, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ilo,
+                                lapack_int* ihi, float* scale );
+lapack_int LAPACKE_dgebal_work( int matrix_order, char job, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ilo,
+                                lapack_int* ihi, double* scale );
+lapack_int LAPACKE_cgebal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ilo, lapack_int* ihi,
+                                float* scale );
+lapack_int LAPACKE_zgebal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ilo, lapack_int* ihi,
+                                double* scale );
+
+lapack_int LAPACKE_sgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* d, float* e,
+                                float* tauq, float* taup, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* d, double* e,
+                                double* tauq, double* taup, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_cgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float* d, float* e, lapack_complex_float* tauq,
+                                lapack_complex_float* taup,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgebrd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double* d, double* e,
+                                lapack_complex_double* tauq,
+                                lapack_complex_double* taup,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgecon_work( int matrix_order, char norm, lapack_int n,
+                                const float* a, lapack_int lda, float anorm,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgecon_work( int matrix_order, char norm, lapack_int n,
+                                const double* a, lapack_int lda, double anorm,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgecon_work( int matrix_order, char norm, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float anorm, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgecon_work( int matrix_order, char norm, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const float* a, lapack_int lda, float* r,
+                                float* c, float* rowcnd, float* colcnd,
+                                float* amax );
+lapack_int LAPACKE_dgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda, double* r,
+                                double* c, double* rowcnd, double* colcnd,
+                                double* amax );
+lapack_int LAPACKE_cgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* r, float* c, float* rowcnd,
+                                float* colcnd, float* amax );
+lapack_int LAPACKE_zgeequ_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* r, double* c, double* rowcnd,
+                                double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const float* a, lapack_int lda, float* r,
+                                 float* c, float* rowcnd, float* colcnd,
+                                 float* amax );
+lapack_int LAPACKE_dgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const double* a, lapack_int lda, double* r,
+                                 double* c, double* rowcnd, double* colcnd,
+                                 double* amax );
+lapack_int LAPACKE_cgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* r, float* c, float* rowcnd,
+                                 float* colcnd, float* amax );
+lapack_int LAPACKE_zgeequb_work( int matrix_order, lapack_int m, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* r, double* c, double* rowcnd,
+                                 double* colcnd, double* amax );
+
+lapack_int LAPACKE_sgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_S_SELECT2 select, lapack_int n, float* a,
+                               lapack_int lda, lapack_int* sdim, float* wr,
+                               float* wi, float* vs, lapack_int ldvs,
+                               float* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_dgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_D_SELECT2 select, lapack_int n, double* a,
+                               lapack_int lda, lapack_int* sdim, double* wr,
+                               double* wi, double* vs, lapack_int ldvs,
+                               double* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_cgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_C_SELECT1 select, lapack_int n,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_int* sdim, lapack_complex_float* w,
+                               lapack_complex_float* vs, lapack_int ldvs,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork, lapack_logical* bwork );
+lapack_int LAPACKE_zgees_work( int matrix_order, char jobvs, char sort,
+                               LAPACK_Z_SELECT1 select, lapack_int n,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_int* sdim, lapack_complex_double* w,
+                               lapack_complex_double* vs, lapack_int ldvs,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_S_SELECT2 select, char sense,
+                                lapack_int n, float* a, lapack_int lda,
+                                lapack_int* sdim, float* wr, float* wi,
+                                float* vs, lapack_int ldvs, float* rconde,
+                                float* rcondv, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_dgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_D_SELECT2 select, char sense,
+                                lapack_int n, double* a, lapack_int lda,
+                                lapack_int* sdim, double* wr, double* wi,
+                                double* vs, lapack_int ldvs, double* rconde,
+                                double* rcondv, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_cgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_C_SELECT1 select, char sense,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_int* sdim,
+                                lapack_complex_float* w,
+                                lapack_complex_float* vs, lapack_int ldvs,
+                                float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_logical* bwork );
+lapack_int LAPACKE_zgeesx_work( int matrix_order, char jobvs, char sort,
+                                LAPACK_Z_SELECT1 select, char sense,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_int* sdim,
+                                lapack_complex_double* w,
+                                lapack_complex_double* vs, lapack_int ldvs,
+                                double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, float* a, lapack_int lda,
+                               float* wr, float* wi, float* vl, lapack_int ldvl,
+                               float* vr, lapack_int ldvr, float* work,
+                               lapack_int lwork );
+lapack_int LAPACKE_dgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, double* a, lapack_int lda,
+                               double* wr, double* wi, double* vl,
+                               lapack_int ldvl, double* vr, lapack_int ldvr,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* w,
+                               lapack_complex_float* vl, lapack_int ldvl,
+                               lapack_complex_float* vr, lapack_int ldvr,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zgeev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_double* a,
+                               lapack_int lda, lapack_complex_double* w,
+                               lapack_complex_double* vl, lapack_int ldvl,
+                               lapack_complex_double* vr, lapack_int ldvr,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork );
+
+lapack_int LAPACKE_sgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, float* a,
+                                lapack_int lda, float* wr, float* wi, float* vl,
+                                lapack_int ldvl, float* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, float* scale,
+                                float* abnrm, float* rconde, float* rcondv,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, double* a,
+                                lapack_int lda, double* wr, double* wi,
+                                double* vl, lapack_int ldvl, double* vr,
+                                lapack_int ldvr, lapack_int* ilo,
+                                lapack_int* ihi, double* scale, double* abnrm,
+                                double* rconde, double* rcondv, double* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_cgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* w,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, float* scale,
+                                float* abnrm, float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork );
+lapack_int LAPACKE_zgeevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* w,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, double* scale,
+                                double* abnrm, double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_sgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, float* a, lapack_int lda,
+                                float* tau, float* work, lapack_int lwork );
+lapack_int LAPACKE_dgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, double* a, lapack_int lda,
+                                double* tau, double* work, lapack_int lwork );
+lapack_int LAPACKE_cgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgejsv_work( int matrix_order, char joba, char jobu,
+                                char jobv, char jobr, char jobt, char jobp,
+                                lapack_int m, lapack_int n, float* a,
+                                lapack_int lda, float* sva, float* u,
+                                lapack_int ldu, float* v, lapack_int ldv,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgejsv_work( int matrix_order, char joba, char jobu,
+                                char jobv, char jobr, char jobt, char jobp,
+                                lapack_int m, lapack_int n, double* a,
+                                lapack_int lda, double* sva, double* u,
+                                lapack_int ldu, double* v, lapack_int ldv,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work );
+lapack_int LAPACKE_dgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work );
+lapack_int LAPACKE_cgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zgelq2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_sgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgelqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs, float* a,
+                               lapack_int lda, float* b, lapack_int ldb,
+                               float* work, lapack_int lwork );
+lapack_int LAPACKE_dgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs, double* a,
+                               lapack_int lda, double* b, lapack_int ldb,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_cgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgels_work( int matrix_order, char trans, lapack_int m,
+                               lapack_int n, lapack_int nrhs,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* s,
+                                double rcond, lapack_int* rank, double* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_cgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_zgelsd_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, double* s, double rcond,
+                                lapack_int* rank, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* s,
+                                double rcond, lapack_int* rank, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_cgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, float* s, float rcond,
+                                lapack_int* rank, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zgelss_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, double* s, double rcond,
+                                lapack_int* rank, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_sgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, lapack_int* jpvt,
+                                float rcond, lapack_int* rank, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, lapack_int* jpvt,
+                                double rcond, lapack_int* rank, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_cgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_int* jpvt, float rcond,
+                                lapack_int* rank, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zgelsy_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_int* jpvt, double rcond,
+                                lapack_int* rank, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_sgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* jpvt,
+                                float* tau, float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* jpvt,
+                                double* tau, double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork );
+lapack_int LAPACKE_zgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_sgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* jpvt,
+                                float* tau, float* work );
+lapack_int LAPACKE_dgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* jpvt,
+                                double* tau, double* work );
+lapack_int LAPACKE_cgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_float* tau,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* jpvt, lapack_complex_double* tau,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work );
+lapack_int LAPACKE_dgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work );
+lapack_int LAPACKE_cgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_sgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* tau,
+                                 float* work, lapack_int lwork );
+lapack_int LAPACKE_dgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* tau,
+                                 double* work, lapack_int lwork );
+lapack_int LAPACKE_cgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* tau,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* tau,
+                                 lapack_complex_double* work,
+                                 lapack_int lwork );
+
+lapack_int LAPACKE_sgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const float* af, lapack_int ldaf,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgerfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs, const float* a,
+                                 lapack_int lda, const float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* r, const float* c, const float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs, const double* a,
+                                 lapack_int lda, const double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* r, const float* c,
+                                 const lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zgerfsx_work( int matrix_order, char trans, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* r, const double* c,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgerqf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* s, float* u, lapack_int ldu, float* vt,
+                                lapack_int ldvt, float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* s, double* u, lapack_int ldu,
+                                double* vt, lapack_int ldvt, double* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_cgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, float* s,
+                                lapack_complex_float* u, lapack_int ldu,
+                                lapack_complex_float* vt, lapack_int ldvt,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int* iwork );
+lapack_int LAPACKE_zgesdd_work( int matrix_order, char jobz, lapack_int m,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, double* s,
+                                lapack_complex_double* u, lapack_int ldu,
+                                lapack_complex_double* vt, lapack_int ldvt,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int* iwork );
+
+lapack_int LAPACKE_sgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* a, lapack_int lda, lapack_int* ipiv,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* a, lapack_int lda, lapack_int* ipiv,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_cgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dsgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                double* a, lapack_int lda, lapack_int* ipiv,
+                                double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* work, float* swork,
+                                lapack_int* iter );
+lapack_int LAPACKE_zcgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, lapack_complex_double* work,
+                                lapack_complex_float* swork, double* rwork,
+                                lapack_int* iter );
+
+lapack_int LAPACKE_sgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n, float* a,
+                                lapack_int lda, float* s, float* u,
+                                lapack_int ldu, float* vt, lapack_int ldvt,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n, double* a,
+                                lapack_int lda, double* s, double* u,
+                                lapack_int ldu, double* vt, lapack_int ldvt,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float* s, lapack_complex_float* u,
+                                lapack_int ldu, lapack_complex_float* vt,
+                                lapack_int ldvt, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zgesvd_work( int matrix_order, char jobu, char jobvt,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double* s, lapack_complex_double* u,
+                                lapack_int ldu, lapack_complex_double* vt,
+                                lapack_int ldvt, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_sgesvj_work( int matrix_order, char joba, char jobu,
+                                char jobv, lapack_int m, lapack_int n, float* a,
+                                lapack_int lda, float* sva, lapack_int mv,
+                                float* v, lapack_int ldv, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dgesvj_work( int matrix_order, char joba, char jobu,
+                                char jobv, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* sva,
+                                lapack_int mv, double* v, lapack_int ldv,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, float* a,
+                                lapack_int lda, float* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, float* r,
+                                float* c, float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, double* a,
+                                lapack_int lda, double* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, double* r,
+                                double* c, double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, float* r,
+                                float* c, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zgesvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                lapack_int* ipiv, char* equed, double* r,
+                                double* c, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_sgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs, float* a,
+                                 lapack_int lda, float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* r,
+                                 float* c, float* b, lapack_int ldb, float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs, double* a,
+                                 lapack_int lda, double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* r,
+                                 double* c, double* b, lapack_int ldb,
+                                 double* x, lapack_int ldx, double* rcond,
+                                 double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* r,
+                                 float* c, lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params,
+                                 lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgesvxx_work( int matrix_order, char fact, char trans,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* r,
+                                 double* c, lapack_complex_double* b,
+                                 lapack_int ldb, lapack_complex_double* x,
+                                 lapack_int ldx, double* rcond, double* rpvgrw,
+                                 double* berr, lapack_int n_err_bnds,
+                                 double* err_bnds_norm, double* err_bnds_comp,
+                                 lapack_int nparams, double* params,
+                                 lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv );
+lapack_int LAPACKE_zgetf2_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_dgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ipiv );
+lapack_int LAPACKE_cgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv );
+lapack_int LAPACKE_zgetrf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv );
+
+lapack_int LAPACKE_sgetri_work( int matrix_order, lapack_int n, float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dgetri_work( int matrix_order, lapack_int n, double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_cgetri_work( int matrix_order, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgetri_work( int matrix_order, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_cgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgetrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* lscale, const float* rscale,
+                                lapack_int m, float* v, lapack_int ldv );
+lapack_int LAPACKE_dggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* lscale, const double* rscale,
+                                lapack_int m, double* v, lapack_int ldv );
+lapack_int LAPACKE_cggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const float* lscale, const float* rscale,
+                                lapack_int m, lapack_complex_float* v,
+                                lapack_int ldv );
+lapack_int LAPACKE_zggbak_work( int matrix_order, char job, char side,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                const double* lscale, const double* rscale,
+                                lapack_int m, lapack_complex_double* v,
+                                lapack_int ldv );
+
+lapack_int LAPACKE_sggbal_work( int matrix_order, char job, lapack_int n,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, lapack_int* ilo,
+                                lapack_int* ihi, float* lscale, float* rscale,
+                                float* work );
+lapack_int LAPACKE_dggbal_work( int matrix_order, char job, lapack_int n,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, lapack_int* ilo,
+                                lapack_int* ihi, double* lscale, double* rscale,
+                                double* work );
+lapack_int LAPACKE_cggbal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_int* ilo, lapack_int* ihi, float* lscale,
+                                float* rscale, float* work );
+lapack_int LAPACKE_zggbal_work( int matrix_order, char job, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_int* ilo, lapack_int* ihi,
+                                double* lscale, double* rscale, double* work );
+
+lapack_int LAPACKE_sgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_S_SELECT3 selctg, lapack_int n,
+                               float* a, lapack_int lda, float* b,
+                               lapack_int ldb, lapack_int* sdim, float* alphar,
+                               float* alphai, float* beta, float* vsl,
+                               lapack_int ldvsl, float* vsr, lapack_int ldvsr,
+                               float* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_dgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_D_SELECT3 selctg, lapack_int n,
+                               double* a, lapack_int lda, double* b,
+                               lapack_int ldb, lapack_int* sdim, double* alphar,
+                               double* alphai, double* beta, double* vsl,
+                               lapack_int ldvsl, double* vsr, lapack_int ldvsr,
+                               double* work, lapack_int lwork,
+                               lapack_logical* bwork );
+lapack_int LAPACKE_cgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_C_SELECT2 selctg, lapack_int n,
+                               lapack_complex_float* a, lapack_int lda,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_int* sdim, lapack_complex_float* alpha,
+                               lapack_complex_float* beta,
+                               lapack_complex_float* vsl, lapack_int ldvsl,
+                               lapack_complex_float* vsr, lapack_int ldvsr,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork, lapack_logical* bwork );
+lapack_int LAPACKE_zgges_work( int matrix_order, char jobvsl, char jobvsr,
+                               char sort, LAPACK_Z_SELECT2 selctg, lapack_int n,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_int* sdim, lapack_complex_double* alpha,
+                               lapack_complex_double* beta,
+                               lapack_complex_double* vsl, lapack_int ldvsl,
+                               lapack_complex_double* vsr, lapack_int ldvsr,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_S_SELECT3 selctg, char sense,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, lapack_int* sdim,
+                                float* alphar, float* alphai, float* beta,
+                                float* vsl, lapack_int ldvsl, float* vsr,
+                                lapack_int ldvsr, float* rconde, float* rcondv,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_dggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_D_SELECT3 selctg, char sense,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, lapack_int* sdim,
+                                double* alphar, double* alphai, double* beta,
+                                double* vsl, lapack_int ldvsl, double* vsr,
+                                lapack_int ldvsr, double* rconde,
+                                double* rcondv, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_cggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_C_SELECT2 selctg, char sense,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_int* sdim,
+                                lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* vsl, lapack_int ldvsl,
+                                lapack_complex_float* vsr, lapack_int ldvsr,
+                                float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int* iwork,
+                                lapack_int liwork, lapack_logical* bwork );
+lapack_int LAPACKE_zggesx_work( int matrix_order, char jobvsl, char jobvsr,
+                                char sort, LAPACK_Z_SELECT2 selctg, char sense,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_int* sdim,
+                                lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* vsl, lapack_int ldvsl,
+                                lapack_complex_double* vsr, lapack_int ldvsr,
+                                double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int* iwork,
+                                lapack_int liwork, lapack_logical* bwork );
+
+lapack_int LAPACKE_sggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, float* a, lapack_int lda, float* b,
+                               lapack_int ldb, float* alphar, float* alphai,
+                               float* beta, float* vl, lapack_int ldvl,
+                               float* vr, lapack_int ldvr, float* work,
+                               lapack_int lwork );
+lapack_int LAPACKE_dggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, double* a, lapack_int lda,
+                               double* b, lapack_int ldb, double* alphar,
+                               double* alphai, double* beta, double* vl,
+                               lapack_int ldvl, double* vr, lapack_int ldvr,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_cggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* b,
+                               lapack_int ldb, lapack_complex_float* alpha,
+                               lapack_complex_float* beta,
+                               lapack_complex_float* vl, lapack_int ldvl,
+                               lapack_complex_float* vr, lapack_int ldvr,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zggev_work( int matrix_order, char jobvl, char jobvr,
+                               lapack_int n, lapack_complex_double* a,
+                               lapack_int lda, lapack_complex_double* b,
+                               lapack_int ldb, lapack_complex_double* alpha,
+                               lapack_complex_double* beta,
+                               lapack_complex_double* vl, lapack_int ldvl,
+                               lapack_complex_double* vr, lapack_int ldvr,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork );
+
+lapack_int LAPACKE_sggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float* alphar, float* alphai, float* beta,
+                                float* vl, lapack_int ldvl, float* vr,
+                                lapack_int ldvr, lapack_int* ilo,
+                                lapack_int* ihi, float* lscale, float* rscale,
+                                float* abnrm, float* bbnrm, float* rconde,
+                                float* rcondv, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_logical* bwork );
+lapack_int LAPACKE_dggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* alphar, double* alphai, double* beta,
+                                double* vl, lapack_int ldvl, double* vr,
+                                lapack_int ldvr, lapack_int* ilo,
+                                lapack_int* ihi, double* lscale, double* rscale,
+                                double* abnrm, double* bbnrm, double* rconde,
+                                double* rcondv, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_logical* bwork );
+lapack_int LAPACKE_cggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi, float* lscale,
+                                float* rscale, float* abnrm, float* bbnrm,
+                                float* rconde, float* rcondv,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int* iwork,
+                                lapack_logical* bwork );
+lapack_int LAPACKE_zggevx_work( int matrix_order, char balanc, char jobvl,
+                                char jobvr, char sense, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int* ilo, lapack_int* ihi,
+                                double* lscale, double* rscale, double* abnrm,
+                                double* bbnrm, double* rconde, double* rcondv,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int* iwork,
+                                lapack_logical* bwork );
+
+lapack_int LAPACKE_sggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* d, float* x,
+                                float* y, float* work, lapack_int lwork );
+lapack_int LAPACKE_dggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* d, double* x,
+                                double* y, double* work, lapack_int lwork );
+lapack_int LAPACKE_cggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* d,
+                                lapack_complex_float* x,
+                                lapack_complex_float* y,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zggglm_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* d,
+                                lapack_complex_double* x,
+                                lapack_complex_double* y,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float* q, lapack_int ldq,
+                                float* z, lapack_int ldz );
+lapack_int LAPACKE_dgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double* q, lapack_int ldq,
+                                double* z, lapack_int ldz );
+lapack_int LAPACKE_cgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz );
+lapack_int LAPACKE_zgghrd_work( int matrix_order, char compq, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz );
+
+lapack_int LAPACKE_sgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float* c, float* d,
+                                float* x, float* work, lapack_int lwork );
+lapack_int LAPACKE_dgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* c, double* d,
+                                double* x, double* work, lapack_int lwork );
+lapack_int LAPACKE_cgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* c,
+                                lapack_complex_float* d,
+                                lapack_complex_float* x,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zgglse_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* c,
+                                lapack_complex_double* d,
+                                lapack_complex_double* x,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, float* a, lapack_int lda,
+                                float* taua, float* b, lapack_int ldb,
+                                float* taub, float* work, lapack_int lwork );
+lapack_int LAPACKE_dggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, double* a, lapack_int lda,
+                                double* taua, double* b, lapack_int ldb,
+                                double* taub, double* work, lapack_int lwork );
+lapack_int LAPACKE_cggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* taua,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* taub,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zggqrf_work( int matrix_order, lapack_int n, lapack_int m,
+                                lapack_int p, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* taua,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* taub,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* taua, float* b, lapack_int ldb,
+                                float* taub, float* work, lapack_int lwork );
+lapack_int LAPACKE_dggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* taua, double* b, lapack_int ldb,
+                                double* taub, double* work, lapack_int lwork );
+lapack_int LAPACKE_cggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* taua,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* taub,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zggrqf_work( int matrix_order, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* taua,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* taub,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float* alpha, float* beta,
+                                float* u, lapack_int ldu, float* v,
+                                lapack_int ldv, float* q, lapack_int ldq,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double* alpha, double* beta,
+                                double* u, lapack_int ldu, double* v,
+                                lapack_int ldv, double* q, lapack_int ldq,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float* alpha, float* beta,
+                                lapack_complex_float* u, lapack_int ldu,
+                                lapack_complex_float* v, lapack_int ldv,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_zggsvd_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int n,
+                                lapack_int p, lapack_int* k, lapack_int* l,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double* alpha, double* beta,
+                                lapack_complex_double* u, lapack_int ldu,
+                                lapack_complex_double* v, lapack_int ldv,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_sggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, float tola,
+                                float tolb, lapack_int* k, lapack_int* l,
+                                float* u, lapack_int ldu, float* v,
+                                lapack_int ldv, float* q, lapack_int ldq,
+                                lapack_int* iwork, float* tau, float* work );
+lapack_int LAPACKE_dggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double tola,
+                                double tolb, lapack_int* k, lapack_int* l,
+                                double* u, lapack_int ldu, double* v,
+                                lapack_int ldv, double* q, lapack_int ldq,
+                                lapack_int* iwork, double* tau, double* work );
+lapack_int LAPACKE_cggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb, float tola, float tolb,
+                                lapack_int* k, lapack_int* l,
+                                lapack_complex_float* u, lapack_int ldu,
+                                lapack_complex_float* v, lapack_int ldv,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_int* iwork, float* rwork,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zggsvp_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, double tola, double tolb,
+                                lapack_int* k, lapack_int* l,
+                                lapack_complex_double* u, lapack_int ldu,
+                                lapack_complex_double* v, lapack_int ldv,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_int* iwork, double* rwork,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_sgtcon_work( char norm, lapack_int n, const float* dl,
+                                const float* d, const float* du,
+                                const float* du2, const lapack_int* ipiv,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgtcon_work( char norm, lapack_int n, const double* dl,
+                                const double* d, const double* du,
+                                const double* du2, const lapack_int* ipiv,
+                                double anorm, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgtcon_work( char norm, lapack_int n,
+                                const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                const lapack_complex_float* du2,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zgtcon_work( char norm, lapack_int n,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                const lapack_complex_double* du2,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_sgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* dl,
+                                const float* d, const float* du,
+                                const float* dlf, const float* df,
+                                const float* duf, const float* du2,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* dl,
+                                const double* d, const double* du,
+                                const double* dlf, const double* df,
+                                const double* duf, const double* du2,
+                                const lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                const lapack_complex_float* dlf,
+                                const lapack_complex_float* df,
+                                const lapack_complex_float* duf,
+                                const lapack_complex_float* du2,
+                                const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgtrfs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                const lapack_complex_double* dlf,
+                                const lapack_complex_double* df,
+                                const lapack_complex_double* duf,
+                                const lapack_complex_double* du2,
+                                const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* dl, float* d, float* du, float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* dl, double* d, double* du, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_float* dl,
+                               lapack_complex_float* d,
+                               lapack_complex_float* du,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               lapack_complex_double* dl,
+                               lapack_complex_double* d,
+                               lapack_complex_double* du,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, const float* dl,
+                                const float* d, const float* du, float* dlf,
+                                float* df, float* duf, float* du2,
+                                lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs, const double* dl,
+                                const double* d, const double* du, double* dlf,
+                                double* df, double* duf, double* du2,
+                                lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                lapack_complex_float* dlf,
+                                lapack_complex_float* df,
+                                lapack_complex_float* duf,
+                                lapack_complex_float* du2, lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zgtsvx_work( int matrix_order, char fact, char trans,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                lapack_complex_double* dlf,
+                                lapack_complex_double* df,
+                                lapack_complex_double* duf,
+                                lapack_complex_double* du2, lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sgttrf_work( lapack_int n, float* dl, float* d, float* du,
+                                float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_dgttrf_work( lapack_int n, double* dl, double* d, double* du,
+                                double* du2, lapack_int* ipiv );
+lapack_int LAPACKE_cgttrf_work( lapack_int n, lapack_complex_float* dl,
+                                lapack_complex_float* d,
+                                lapack_complex_float* du,
+                                lapack_complex_float* du2, lapack_int* ipiv );
+lapack_int LAPACKE_zgttrf_work( lapack_int n, lapack_complex_double* dl,
+                                lapack_complex_double* d,
+                                lapack_complex_double* du,
+                                lapack_complex_double* du2, lapack_int* ipiv );
+
+lapack_int LAPACKE_sgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const float* dl,
+                                const float* d, const float* du,
+                                const float* du2, const lapack_int* ipiv,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const double* dl,
+                                const double* d, const double* du,
+                                const double* du2, const lapack_int* ipiv,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_cgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* dl,
+                                const lapack_complex_float* d,
+                                const lapack_complex_float* du,
+                                const lapack_complex_float* du2,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zgttrs_work( int matrix_order, char trans, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* dl,
+                                const lapack_complex_double* d,
+                                const lapack_complex_double* du,
+                                const lapack_complex_double* du2,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               float* w, lapack_complex_float* z,
+                               lapack_int ldz, lapack_complex_float* work,
+                               float* rwork );
+lapack_int LAPACKE_zhbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               double* w, lapack_complex_double* z,
+                               lapack_int ldz, lapack_complex_double* work,
+                               double* rwork );
+
+lapack_int LAPACKE_chbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* q, lapack_int ldq,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                float* rwork, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_zhbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_complex_double* q, lapack_int ldq,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                double* rwork, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_chbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_complex_float* bb, lapack_int ldbb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                const lapack_complex_double* bb,
+                                lapack_int ldbb, lapack_complex_double* x,
+                                lapack_int ldx, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_chbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               lapack_complex_float* bb, lapack_int ldbb,
+                               float* w, lapack_complex_float* z,
+                               lapack_int ldz, lapack_complex_float* work,
+                               float* rwork );
+lapack_int LAPACKE_zhbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               lapack_complex_double* bb, lapack_int ldbb,
+                               double* w, lapack_complex_double* z,
+                               lapack_int ldz, lapack_complex_double* work,
+                               double* rwork );
+
+lapack_int LAPACKE_chbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* bb, lapack_int ldbb,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_complex_double* bb, lapack_int ldbb,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, lapack_complex_float* ab,
+                                lapack_int ldab, lapack_complex_float* bb,
+                                lapack_int ldbb, lapack_complex_float* q,
+                                lapack_int ldq, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* bb,
+                                lapack_int ldbb, lapack_complex_double* q,
+                                lapack_int ldq, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                float* d, float* e, lapack_complex_float* q,
+                                lapack_int ldq, lapack_complex_float* work );
+lapack_int LAPACKE_zhbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                double* d, double* e, lapack_complex_double* q,
+                                lapack_int ldq, lapack_complex_double* work );
+
+lapack_int LAPACKE_checon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zhecon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_cheequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* s, float* scond, float* amax,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_zheequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* s, double* scond, double* amax,
+                                 lapack_complex_double* work );
+
+lapack_int LAPACKE_cheev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, float* w,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zheev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_double* a,
+                               lapack_int lda, double* w,
+                               lapack_complex_double* work, lapack_int lwork,
+                               double* rwork );
+
+lapack_int LAPACKE_cheevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, float* w,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_zheevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, double* w,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_cheevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_int* isuppz,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_zheevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_int* isuppz,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_cheevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zheevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chegst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zhegst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_chegv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* b,
+                               lapack_int ldb, float* w,
+                               lapack_complex_float* work, lapack_int lwork,
+                               float* rwork );
+lapack_int LAPACKE_zhegv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n,
+                               lapack_complex_double* a, lapack_int lda,
+                               lapack_complex_double* b, lapack_int ldb,
+                               double* w, lapack_complex_double* work,
+                               lapack_int lwork, double* rwork );
+
+lapack_int LAPACKE_chegvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float* w, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhegvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double* w, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chegvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhegvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_cherfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zherfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_cherfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* s, const lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zherfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* s,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_chesv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zhesv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_chesvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                lapack_int* ipiv, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zhesvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_chesvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* s,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zhesvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* s,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_chetrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                float* d, float* e, lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zhetrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                double* d, double* e,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_chetrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_zhetrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_chetri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zhetri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_chetrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zhetrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_chfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               float alpha, const lapack_complex_float* a,
+                               lapack_int lda, float beta,
+                               lapack_complex_float* c );
+lapack_int LAPACKE_zhfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               double alpha, const lapack_complex_double* a,
+                               lapack_int lda, double beta,
+                               lapack_complex_double* c );
+
+lapack_int LAPACKE_shgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, float* h, lapack_int ldh,
+                                float* t, lapack_int ldt, float* alphar,
+                                float* alphai, float* beta, float* q,
+                                lapack_int ldq, float* z, lapack_int ldz,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dhgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, double* h, lapack_int ldh,
+                                double* t, lapack_int ldt, double* alphar,
+                                double* alphai, double* beta, double* q,
+                                lapack_int ldq, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_chgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_float* h,
+                                lapack_int ldh, lapack_complex_float* t,
+                                lapack_int ldt, lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork );
+lapack_int LAPACKE_zhgeqz_work( int matrix_order, char job, char compq,
+                                char compz, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_double* h,
+                                lapack_int ldh, lapack_complex_double* t,
+                                lapack_int ldt, lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_chpcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zhpcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_chpev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_float* ap, float* w,
+                               lapack_complex_float* z, lapack_int ldz,
+                               lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhpev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_complex_double* ap,
+                               double* w, lapack_complex_double* z,
+                               lapack_int ldz, lapack_complex_double* work,
+                               double* rwork );
+
+lapack_int LAPACKE_chpevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_float* ap,
+                                float* w, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zhpevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_complex_double* ap,
+                                double* w, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_chpevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* ap, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhpevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* ap, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chpgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_float* ap,
+                                const lapack_complex_float* bp );
+lapack_int LAPACKE_zhpgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, lapack_complex_double* ap,
+                                const lapack_complex_double* bp );
+
+lapack_int LAPACKE_chpgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n,
+                               lapack_complex_float* ap,
+                               lapack_complex_float* bp, float* w,
+                               lapack_complex_float* z, lapack_int ldz,
+                               lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhpgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n,
+                               lapack_complex_double* ap,
+                               lapack_complex_double* bp, double* w,
+                               lapack_complex_double* z, lapack_int ldz,
+                               lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_chpgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                lapack_complex_float* bp, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_zhpgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                lapack_complex_double* bp, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_chpgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                lapack_complex_float* bp, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_zhpgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                lapack_complex_double* bp, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_chprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_complex_float* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_chpsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* ap,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zhpsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* ap,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+
+lapack_int LAPACKE_chpsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* afp, lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zhpsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* afp, lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_chptrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap, float* d, float* e,
+                                lapack_complex_float* tau );
+lapack_int LAPACKE_zhptrd_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap, double* d, double* e,
+                                lapack_complex_double* tau );
+
+lapack_int LAPACKE_chptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zhptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_chptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zhptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_chptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zhptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_shsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, lapack_logical* select,
+                                lapack_int n, const float* h, lapack_int ldh,
+                                float* wr, const float* wi, float* vl,
+                                lapack_int ldvl, float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, float* work,
+                                lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_dhsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, lapack_logical* select,
+                                lapack_int n, const double* h, lapack_int ldh,
+                                double* wr, const double* wi, double* vl,
+                                lapack_int ldvl, double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, double* work,
+                                lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_chsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, const lapack_logical* select,
+                                lapack_int n, const lapack_complex_float* h,
+                                lapack_int ldh, lapack_complex_float* w,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_float* work, float* rwork,
+                                lapack_int* ifaill, lapack_int* ifailr );
+lapack_int LAPACKE_zhsein_work( int matrix_order, char job, char eigsrc,
+                                char initv, const lapack_logical* select,
+                                lapack_int n, const lapack_complex_double* h,
+                                lapack_int ldh, lapack_complex_double* w,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, double* rwork,
+                                lapack_int* ifaill, lapack_int* ifailr );
+
+lapack_int LAPACKE_shseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                float* h, lapack_int ldh, float* wr, float* wi,
+                                float* z, lapack_int ldz, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dhseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                double* h, lapack_int ldh, double* wr,
+                                double* wi, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_chseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_float* h, lapack_int ldh,
+                                lapack_complex_float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zhseqr_work( int matrix_order, char job, char compz,
+                                lapack_int n, lapack_int ilo, lapack_int ihi,
+                                lapack_complex_double* h, lapack_int ldh,
+                                lapack_complex_double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_clacgv_work( lapack_int n, lapack_complex_float* x,
+                                lapack_int incx );
+lapack_int LAPACKE_zlacgv_work( lapack_int n, lapack_complex_double* x,
+                                lapack_int incx );
+
+lapack_int LAPACKE_slacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dlacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_clacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zlacpy_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_zlag2c_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_float* sa, lapack_int ldsa );
+
+lapack_int LAPACKE_slag2d_work( int matrix_order, lapack_int m, lapack_int n,
+                                const float* sa, lapack_int ldsa, double* a,
+                                lapack_int lda );
+
+lapack_int LAPACKE_dlag2s_work( int matrix_order, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda, float* sa,
+                                lapack_int ldsa );
+
+lapack_int LAPACKE_clag2z_work( int matrix_order, lapack_int m, lapack_int n,
+                                const lapack_complex_float* sa, lapack_int ldsa,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* d,
+                                float* a, lapack_int lda, lapack_int* iseed,
+                                float* work );
+lapack_int LAPACKE_dlagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* d,
+                                double* a, lapack_int lda, lapack_int* iseed,
+                                double* work );
+lapack_int LAPACKE_clagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const float* d,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* iseed, lapack_complex_float* work );
+lapack_int LAPACKE_zlagge_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int kl, lapack_int ku, const double* d,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* iseed,
+                                lapack_complex_double* work );
+                                
+lapack_int LAPACKE_claghe_work( int matrix_order, lapack_int n, lapack_int k,
+                                const float* d, lapack_complex_float* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zlaghe_work( int matrix_order, lapack_int n, lapack_int k,
+                                const double* d, lapack_complex_double* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_slagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const float* d, float* a, lapack_int lda,
+                                lapack_int* iseed, float* work );
+lapack_int LAPACKE_dlagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const double* d, double* a, lapack_int lda,
+                                lapack_int* iseed, double* work );
+lapack_int LAPACKE_clagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const float* d, lapack_complex_float* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zlagsy_work( int matrix_order, lapack_int n, lapack_int k,
+                                const double* d, lapack_complex_double* a,
+                                lapack_int lda, lapack_int* iseed,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_slapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n, float* x,
+                                lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_dlapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n, double* x,
+                                lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_clapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_float* x, lapack_int ldx,
+                                lapack_int* k );
+lapack_int LAPACKE_zlapmr_work( int matrix_order, lapack_logical forwrd,
+                                lapack_int m, lapack_int n,
+                                lapack_complex_double* x, lapack_int ldx,
+                                lapack_int* k );
+
+lapack_int LAPACKE_slartgp_work( float f, float g, float* cs, float* sn,
+                                 float* r );
+lapack_int LAPACKE_dlartgp_work( double f, double g, double* cs, double* sn,
+                                 double* r );
+
+lapack_int LAPACKE_slartgs_work( float x, float y, float sigma, float* cs,
+                                 float* sn );
+lapack_int LAPACKE_dlartgs_work( double x, double y, double sigma, double* cs,
+                                 double* sn );
+                                
+float LAPACKE_slapy2_work( float x, float y );
+double LAPACKE_dlapy2_work( double x, double y );
+
+float LAPACKE_slapy3_work( float x, float y, float z );
+double LAPACKE_dlapy3_work( double x, double y, double z );
+
+float LAPACKE_slamch_work( char cmach );
+double LAPACKE_dlamch_work( char cmach );
+
+float LAPACKE_slange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* work );
+double LAPACKE_dlange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* work );
+float LAPACKE_clange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_zlange_work( int matrix_order, char norm, lapack_int m,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, double* work );
+
+float LAPACKE_clanhe_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_zlanhe_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, double* work );
+
+float LAPACKE_slansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* work );
+double LAPACKE_dlansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* work );
+float LAPACKE_clansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_zlansy_work( int matrix_order, char norm, char uplo,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, double* work );
+
+float LAPACKE_slantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n, const float* a,
+                                lapack_int lda, float* work );
+double LAPACKE_dlantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda, double* work );
+float LAPACKE_clantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* work );
+double LAPACKE_zlantr_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* work );
+
+lapack_int LAPACKE_slarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, const float* v,
+                                lapack_int ldv, const float* t, lapack_int ldt,
+                                float* c, lapack_int ldc, float* work,
+                                lapack_int ldwork );
+lapack_int LAPACKE_dlarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, const double* v,
+                                lapack_int ldv, const double* t, lapack_int ldt,
+                                double* c, lapack_int ldc, double* work,
+                                lapack_int ldwork );
+lapack_int LAPACKE_clarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_float* v, lapack_int ldv,
+                                const lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int ldwork );
+lapack_int LAPACKE_zlarfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_double* v, lapack_int ldv,
+                                const lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work,
+                                lapack_int ldwork );
+
+lapack_int LAPACKE_slarfg_work( lapack_int n, float* alpha, float* x,
+                                lapack_int incx, float* tau );
+lapack_int LAPACKE_dlarfg_work( lapack_int n, double* alpha, double* x,
+                                lapack_int incx, double* tau );
+lapack_int LAPACKE_clarfg_work( lapack_int n, lapack_complex_float* alpha,
+                                lapack_complex_float* x, lapack_int incx,
+                                lapack_complex_float* tau );
+lapack_int LAPACKE_zlarfg_work( lapack_int n, lapack_complex_double* alpha,
+                                lapack_complex_double* x, lapack_int incx,
+                                lapack_complex_double* tau );
+
+lapack_int LAPACKE_slarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k, const float* v,
+                                lapack_int ldv, const float* tau, float* t,
+                                lapack_int ldt );
+lapack_int LAPACKE_dlarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k, const double* v,
+                                lapack_int ldv, const double* tau, double* t,
+                                lapack_int ldt );
+lapack_int LAPACKE_clarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_float* v, lapack_int ldv,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zlarft_work( int matrix_order, char direct, char storev,
+                                lapack_int n, lapack_int k,
+                                const lapack_complex_double* v, lapack_int ldv,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_slarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const float* v, float tau,
+                                float* c, lapack_int ldc, float* work );
+lapack_int LAPACKE_dlarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const double* v, double tau,
+                                double* c, lapack_int ldc, double* work );
+lapack_int LAPACKE_clarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const lapack_complex_float* v,
+                                lapack_complex_float tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zlarfx_work( int matrix_order, char side, lapack_int m,
+                                lapack_int n, const lapack_complex_double* v,
+                                lapack_complex_double tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_slarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, float* x );
+lapack_int LAPACKE_dlarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, double* x );
+lapack_int LAPACKE_clarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, lapack_complex_float* x );
+lapack_int LAPACKE_zlarnv_work( lapack_int idist, lapack_int* iseed,
+                                lapack_int n, lapack_complex_double* x );
+
+lapack_int LAPACKE_slaset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, float alpha, float beta, float* a,
+                                lapack_int lda );
+lapack_int LAPACKE_dlaset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, double alpha, double beta,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_claset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, lapack_complex_float alpha,
+                                lapack_complex_float beta,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlaset_work( int matrix_order, char uplo, lapack_int m,
+                                lapack_int n, lapack_complex_double alpha,
+                                lapack_complex_double beta,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_slasrt_work( char id, lapack_int n, float* d );
+lapack_int LAPACKE_dlasrt_work( char id, lapack_int n, double* d );
+
+lapack_int LAPACKE_slaswp_work( int matrix_order, lapack_int n, float* a,
+                                lapack_int lda, lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_dlaswp_work( int matrix_order, lapack_int n, double* a,
+                                lapack_int lda, lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_claswp_work( int matrix_order, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+lapack_int LAPACKE_zlaswp_work( int matrix_order, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int k1, lapack_int k2,
+                                const lapack_int* ipiv, lapack_int incx );
+
+lapack_int LAPACKE_slatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                float* d, lapack_int mode, float cond,
+                                float dmax, lapack_int kl, lapack_int ku,
+                                char pack, float* a, lapack_int lda,
+                                float* work );
+lapack_int LAPACKE_dlatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                double* d, lapack_int mode, double cond,
+                                double dmax, lapack_int kl, lapack_int ku,
+                                char pack, double* a, lapack_int lda,
+                                double* work );
+lapack_int LAPACKE_clatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                float* d, lapack_int mode, float cond,
+                                float dmax, lapack_int kl, lapack_int ku,
+                                char pack, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* work );
+lapack_int LAPACKE_zlatms_work( int matrix_order, lapack_int m, lapack_int n,
+                                char dist, lapack_int* iseed, char sym,
+                                double* d, lapack_int mode, double cond,
+                                double dmax, lapack_int kl, lapack_int ku,
+                                char pack, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* work );
+
+lapack_int LAPACKE_slauum_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda );
+lapack_int LAPACKE_dlauum_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_clauum_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zlauum_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_sopgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, const float* tau, float* q,
+                                lapack_int ldq, float* work );
+lapack_int LAPACKE_dopgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, const double* tau, double* q,
+                                lapack_int ldq, double* work );
+
+lapack_int LAPACKE_sopmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const float* ap, const float* tau, float* c,
+                                lapack_int ldc, float* work );
+lapack_int LAPACKE_dopmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const double* ap, const double* tau, double* c,
+                                lapack_int ldc, double* work );
+
+lapack_int LAPACKE_sorgbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k, float* a,
+                                lapack_int lda, const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k, double* a,
+                                lapack_int lda, const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, float* a, lapack_int lda,
+                                const float* tau, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorgrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, double* a, lapack_int lda,
+                                const double* tau, double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_sorgtr_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, const float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dorgtr_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, const double* tau,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_sormtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const float* a, lapack_int lda,
+                                const float* tau, float* c, lapack_int ldc,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dormtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const double* tau, double* c, lapack_int ldc,
+                                double* work, lapack_int lwork );
+
+lapack_int LAPACKE_spbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const float* ab, lapack_int ldab,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dpbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const double* ab,
+                                lapack_int ldab, double anorm, double* rcond,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cpbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_float* ab,
+                                lapack_int ldab, float anorm, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpbcon_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_double* ab,
+                                lapack_int ldab, double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const float* ab, lapack_int ldab,
+                                float* s, float* scond, float* amax );
+lapack_int LAPACKE_dpbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const double* ab,
+                                lapack_int ldab, double* s, double* scond,
+                                double* amax );
+lapack_int LAPACKE_cpbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_float* ab,
+                                lapack_int ldab, float* s, float* scond,
+                                float* amax );
+lapack_int LAPACKE_zpbequ_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, const lapack_complex_double* ab,
+                                lapack_int ldab, double* s, double* scond,
+                                double* amax );
+
+lapack_int LAPACKE_spbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs, const float* ab,
+                                lapack_int ldab, const float* afb,
+                                lapack_int ldafb, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dpbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const double* ab, lapack_int ldab,
+                                const double* afb, lapack_int ldafb,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cpbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                const lapack_complex_float* afb,
+                                lapack_int ldafb, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpbrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab,
+                                const lapack_complex_double* afb,
+                                lapack_int ldafb,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, float* bb, lapack_int ldbb );
+lapack_int LAPACKE_dpbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, double* bb, lapack_int ldbb );
+lapack_int LAPACKE_cpbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, lapack_complex_float* bb,
+                                lapack_int ldbb );
+lapack_int LAPACKE_zpbstf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kb, lapack_complex_double* bb,
+                                lapack_int ldbb );
+
+lapack_int LAPACKE_spbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs, float* ab,
+                               lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs, double* ab,
+                               lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs,
+                               lapack_complex_float* ab, lapack_int ldab,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int kd, lapack_int nrhs,
+                               lapack_complex_double* ab, lapack_int ldab,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                float* ab, lapack_int ldab, float* afb,
+                                lapack_int ldafb, char* equed, float* s,
+                                float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dpbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                double* ab, lapack_int ldab, double* afb,
+                                lapack_int ldafb, char* equed, double* s,
+                                double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, double* work, lapack_int* iwork );
+lapack_int LAPACKE_cpbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* afb, lapack_int ldafb,
+                                char* equed, float* s, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zpbsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int kd, lapack_int nrhs,
+                                lapack_complex_double* ab, lapack_int ldab,
+                                lapack_complex_double* afb, lapack_int ldafb,
+                                char* equed, double* s,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, float* ab, lapack_int ldab );
+lapack_int LAPACKE_dpbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, double* ab, lapack_int ldab );
+lapack_int LAPACKE_cpbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_complex_float* ab,
+                                lapack_int ldab );
+lapack_int LAPACKE_zpbtrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_complex_double* ab,
+                                lapack_int ldab );
+
+lapack_int LAPACKE_spbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs, const float* ab,
+                                lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dpbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const double* ab, lapack_int ldab, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cpbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpbtrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int kd, lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_spftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, float* a );
+lapack_int LAPACKE_dpftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, double* a );
+lapack_int LAPACKE_cpftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftrf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, float* a );
+lapack_int LAPACKE_dpftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, double* a );
+lapack_int LAPACKE_cpftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_float* a );
+lapack_int LAPACKE_zpftri_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_complex_double* a );
+
+lapack_int LAPACKE_spftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs, const float* a,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dpftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs, const double* a,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_cpftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpftrs_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spocon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* a, lapack_int lda, float anorm,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dpocon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* a, lapack_int lda, double anorm,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cpocon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float anorm, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpocon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double anorm, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spoequ_work( int matrix_order, lapack_int n, const float* a,
+                                lapack_int lda, float* s, float* scond,
+                                float* amax );
+lapack_int LAPACKE_dpoequ_work( int matrix_order, lapack_int n, const double* a,
+                                lapack_int lda, double* s, double* scond,
+                                double* amax );
+lapack_int LAPACKE_cpoequ_work( int matrix_order, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequ_work( int matrix_order, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_spoequb_work( int matrix_order, lapack_int n, const float* a,
+                                 lapack_int lda, float* s, float* scond,
+                                 float* amax );
+lapack_int LAPACKE_dpoequb_work( int matrix_order, lapack_int n,
+                                 const double* a, lapack_int lda, double* s,
+                                 double* scond, double* amax );
+lapack_int LAPACKE_cpoequb_work( int matrix_order, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* s, float* scond, float* amax );
+lapack_int LAPACKE_zpoequb_work( int matrix_order, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* s, double* scond, double* amax );
+
+lapack_int LAPACKE_sporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const float* af, lapack_int ldaf,
+                                const float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const double* af,
+                                lapack_int ldaf, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zporfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const float* a,
+                                 lapack_int lda, const float* af,
+                                 lapack_int ldaf, const float* s,
+                                 const float* b, lapack_int ldb, float* x,
+                                 lapack_int ldx, float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const double* a,
+                                 lapack_int lda, const double* af,
+                                 lapack_int ldaf, const double* s,
+                                 const double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const float* s,
+                                 const lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zporfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const double* s,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_sposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* a, lapack_int lda,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* a, lapack_int lda,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_cposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* a,
+                               lapack_int lda, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zposv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* a,
+                               lapack_int lda, lapack_complex_double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dsposv_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, double* a, lapack_int lda,
+                                double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* work, float* swork,
+                                lapack_int* iter );
+lapack_int LAPACKE_zcposv_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, lapack_complex_double* work,
+                                lapack_complex_float* swork, double* rwork,
+                                lapack_int* iter );
+
+lapack_int LAPACKE_sposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, float* a,
+                                lapack_int lda, float* af, lapack_int ldaf,
+                                char* equed, float* s, float* b, lapack_int ldb,
+                                float* x, lapack_int ldx, float* rcond,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, double* a,
+                                lapack_int lda, double* af, lapack_int ldaf,
+                                char* equed, double* s, double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                char* equed, float* s, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zposvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                char* equed, double* s,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, float* a,
+                                 lapack_int lda, float* af, lapack_int ldaf,
+                                 char* equed, float* s, float* b,
+                                 lapack_int ldb, float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, double* a,
+                                 lapack_int lda, double* af, lapack_int ldaf,
+                                 char* equed, double* s, double* b,
+                                 lapack_int ldb, double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_cposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 char* equed, float* s, lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params,
+                                 lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zposvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 char* equed, double* s,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_spotrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda );
+lapack_int LAPACKE_dpotrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_cpotrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotri_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda );
+lapack_int LAPACKE_dpotri_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda );
+lapack_int LAPACKE_cpotri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zpotri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_spotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                float* b, lapack_int ldb );
+lapack_int LAPACKE_dpotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, double* b, lapack_int ldb );
+lapack_int LAPACKE_cpotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zpotrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_sppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, float anorm, float* rcond,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, double anorm, double* rcond,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap, float anorm,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zppcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap, double anorm,
+                                double* rcond, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_sppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, float* s, float* scond,
+                                float* amax );
+lapack_int LAPACKE_dppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, double* s, double* scond,
+                                double* amax );
+lapack_int LAPACKE_cppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap, float* s,
+                                float* scond, float* amax );
+lapack_int LAPACKE_zppequ_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap, double* s,
+                                double* scond, double* amax );
+
+lapack_int LAPACKE_spprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap,
+                                const float* afp, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dpprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap,
+                                const double* afp, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cpprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_complex_float* afp,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zpprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* afp,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* ap, float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_dppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* ap, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* ap,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zppsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* ap,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, float* ap,
+                                float* afp, char* equed, float* s, float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, double* ap,
+                                double* afp, char* equed, double* s, double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_float* ap,
+                                lapack_complex_float* afp, char* equed,
+                                float* s, lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_zppsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                lapack_complex_double* ap,
+                                lapack_complex_double* afp, char* equed,
+                                double* s, lapack_complex_double* b,
+                                lapack_int ldb, lapack_complex_double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_spptrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap );
+lapack_int LAPACKE_dpptrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap );
+lapack_int LAPACKE_cpptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_zpptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptri_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap );
+lapack_int LAPACKE_dpptri_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap );
+lapack_int LAPACKE_cpptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_zpptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_spptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dpptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cpptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_spstrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* piv,
+                                lapack_int* rank, float tol, float* work );
+lapack_int LAPACKE_dpstrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* piv,
+                                lapack_int* rank, double tol, double* work );
+lapack_int LAPACKE_cpstrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* piv, lapack_int* rank, float tol,
+                                float* work );
+lapack_int LAPACKE_zpstrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* piv, lapack_int* rank, double tol,
+                                double* work );
+
+lapack_int LAPACKE_sptcon_work( lapack_int n, const float* d, const float* e,
+                                float anorm, float* rcond, float* work );
+lapack_int LAPACKE_dptcon_work( lapack_int n, const double* d, const double* e,
+                                double anorm, double* rcond, double* work );
+lapack_int LAPACKE_cptcon_work( lapack_int n, const float* d,
+                                const lapack_complex_float* e, float anorm,
+                                float* rcond, float* work );
+lapack_int LAPACKE_zptcon_work( lapack_int n, const double* d,
+                                const lapack_complex_double* e, double anorm,
+                                double* rcond, double* work );
+
+lapack_int LAPACKE_spteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work );
+lapack_int LAPACKE_dpteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work );
+lapack_int LAPACKE_cpteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, lapack_complex_float* z,
+                                lapack_int ldz, float* work );
+lapack_int LAPACKE_zpteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, lapack_complex_double* z,
+                                lapack_int ldz, double* work );
+
+lapack_int LAPACKE_sptrfs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const float* d, const float* e, const float* df,
+                                const float* ef, const float* b, lapack_int ldb,
+                                float* x, lapack_int ldx, float* ferr,
+                                float* berr, float* work );
+lapack_int LAPACKE_dptrfs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const double* d, const double* e,
+                                const double* df, const double* ef,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work );
+lapack_int LAPACKE_cptrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* d,
+                                const lapack_complex_float* e, const float* df,
+                                const lapack_complex_float* ef,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zptrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const lapack_complex_double* e,
+                                const double* df,
+                                const lapack_complex_double* ef,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* d, float* e, float* b, lapack_int ldb );
+lapack_int LAPACKE_dptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* d, double* e, double* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_cptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               float* d, lapack_complex_float* e,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                               double* d, lapack_complex_double* e,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const float* d, const float* e,
+                                float* df, float* ef, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work );
+lapack_int LAPACKE_dptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const double* e, double* df, double* ef,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* rcond, double* ferr,
+                                double* berr, double* work );
+lapack_int LAPACKE_cptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const float* d,
+                                const lapack_complex_float* e, float* df,
+                                lapack_complex_float* ef,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zptsvx_work( int matrix_order, char fact, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const lapack_complex_double* e, double* df,
+                                lapack_complex_double* ef,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_spttrf_work( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dpttrf_work( lapack_int n, double* d, double* e );
+lapack_int LAPACKE_cpttrf_work( lapack_int n, float* d,
+                                lapack_complex_float* e );
+lapack_int LAPACKE_zpttrf_work( lapack_int n, double* d,
+                                lapack_complex_double* e );
+
+lapack_int LAPACKE_spttrs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const float* d, const float* e, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dpttrs_work( int matrix_order, lapack_int n, lapack_int nrhs,
+                                const double* d, const double* e, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_cpttrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* d,
+                                const lapack_complex_float* e,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zpttrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* d,
+                                const lapack_complex_double* e,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd, float* ab,
+                               lapack_int ldab, float* w, float* z,
+                               lapack_int ldz, float* work );
+lapack_int LAPACKE_dsbev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int kd, double* ab,
+                               lapack_int ldab, double* w, double* z,
+                               lapack_int ldz, double* work );
+
+lapack_int LAPACKE_ssbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd, float* ab,
+                                lapack_int ldab, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsbevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int kd, double* ab,
+                                lapack_int ldab, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                float* ab, lapack_int ldab, float* q,
+                                lapack_int ldq, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dsbevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int kd,
+                                double* ab, lapack_int ldab, double* q,
+                                lapack_int ldq, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_ssbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                float* ab, lapack_int ldab, const float* bb,
+                                lapack_int ldbb, float* x, lapack_int ldx,
+                                float* work );
+lapack_int LAPACKE_dsbgst_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                double* ab, lapack_int ldab, const double* bb,
+                                lapack_int ldbb, double* x, lapack_int ldx,
+                                double* work );
+
+lapack_int LAPACKE_ssbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               float* ab, lapack_int ldab, float* bb,
+                               lapack_int ldbb, float* w, float* z,
+                               lapack_int ldz, float* work );
+lapack_int LAPACKE_dsbgv_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, lapack_int ka, lapack_int kb,
+                               double* ab, lapack_int ldab, double* bb,
+                               lapack_int ldbb, double* w, double* z,
+                               lapack_int ldz, double* work );
+
+lapack_int LAPACKE_ssbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                float* ab, lapack_int ldab, float* bb,
+                                lapack_int ldbb, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsbgvd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, lapack_int ka, lapack_int kb,
+                                double* ab, lapack_int ldab, double* bb,
+                                lapack_int ldbb, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, float* ab, lapack_int ldab,
+                                float* bb, lapack_int ldbb, float* q,
+                                lapack_int ldq, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dsbgvx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, lapack_int ka,
+                                lapack_int kb, double* ab, lapack_int ldab,
+                                double* bb, lapack_int ldbb, double* q,
+                                lapack_int ldq, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_ssbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd, float* ab,
+                                lapack_int ldab, float* d, float* e, float* q,
+                                lapack_int ldq, float* work );
+lapack_int LAPACKE_dsbtrd_work( int matrix_order, char vect, char uplo,
+                                lapack_int n, lapack_int kd, double* ab,
+                                lapack_int ldab, double* d, double* e,
+                                double* q, lapack_int ldq, double* work );
+
+lapack_int LAPACKE_ssfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               float alpha, const float* a, lapack_int lda,
+                               float beta, float* c );
+lapack_int LAPACKE_dsfrk_work( int matrix_order, char transr, char uplo,
+                               char trans, lapack_int n, lapack_int k,
+                               double alpha, const double* a, lapack_int lda,
+                               double beta, double* c );
+
+lapack_int LAPACKE_sspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, const lapack_int* ipiv,
+                                float anorm, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, const lapack_int* ipiv,
+                                double anorm, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_cspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zspcon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_sspev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, float* ap, float* w, float* z,
+                               lapack_int ldz, float* work );
+lapack_int LAPACKE_dspev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, double* ap, double* w, double* z,
+                               lapack_int ldz, double* work );
+
+lapack_int LAPACKE_sspevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, float* ap, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dspevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, double* ap, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sspevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, float* ap, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dspevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, double* ap, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, double* work,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_sspgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, float* ap, const float* bp );
+lapack_int LAPACKE_dspgst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, double* ap, const double* bp );
+
+lapack_int LAPACKE_sspgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, float* ap, float* bp,
+                               float* w, float* z, lapack_int ldz,
+                               float* work );
+lapack_int LAPACKE_dspgv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, double* ap, double* bp,
+                               double* w, double* z, lapack_int ldz,
+                               double* work );
+
+lapack_int LAPACKE_sspgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, float* ap, float* bp,
+                                float* w, float* z, lapack_int ldz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dspgvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, double* ap, double* bp,
+                                double* w, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sspgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, float* ap,
+                                float* bp, float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, float* z, lapack_int ldz, float* work,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_dspgvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, double* ap,
+                                double* bp, double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, double* z, lapack_int ldz,
+                                double* work, lapack_int* iwork,
+                                lapack_int* ifail );
+
+lapack_int LAPACKE_ssprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap,
+                                const float* afp, const lapack_int* ipiv,
+                                const float* b, lapack_int ldb, float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dsprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap,
+                                const double* afp, const lapack_int* ipiv,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_csprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_complex_float* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zsprfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* afp,
+                                const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_sspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* ap, lapack_int* ipiv,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* ap, lapack_int* ipiv,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_cspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* ap,
+                               lapack_int* ipiv, lapack_complex_float* b,
+                               lapack_int ldb );
+lapack_int LAPACKE_zspsv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* ap,
+                               lapack_int* ipiv, lapack_complex_double* b,
+                               lapack_int ldb );
+
+lapack_int LAPACKE_sspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const float* ap,
+                                float* afp, lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const double* ap,
+                                double* afp, lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_cspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* afp, lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zspsvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* afp, lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_ssptrd_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap, float* d, float* e, float* tau );
+lapack_int LAPACKE_dsptrd_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap, double* d, double* e, double* tau );
+
+lapack_int LAPACKE_ssptrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_dsptrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap, lapack_int* ipiv );
+lapack_int LAPACKE_csptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap, lapack_int* ipiv );
+lapack_int LAPACKE_zsptrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap, lapack_int* ipiv );
+
+lapack_int LAPACKE_ssptri_work( int matrix_order, char uplo, lapack_int n,
+                                float* ap, const lapack_int* ipiv,
+                                float* work );
+lapack_int LAPACKE_dsptri_work( int matrix_order, char uplo, lapack_int n,
+                                double* ap, const lapack_int* ipiv,
+                                double* work );
+lapack_int LAPACKE_csptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zsptri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_ssptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* ap,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dsptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* ap,
+                                const lapack_int* ipiv, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_csptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* ap,
+                                const lapack_int* ipiv, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_zsptrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_sstebz_work( char range, char order, lapack_int n, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, const float* d, const float* e,
+                                lapack_int* m, lapack_int* nsplit, float* w,
+                                lapack_int* iblock, lapack_int* isplit,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dstebz_work( char range, char order, lapack_int n, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, const double* d, const double* e,
+                                lapack_int* m, lapack_int* nsplit, double* w,
+                                lapack_int* iblock, lapack_int* isplit,
+                                double* work, lapack_int* iwork );
+
+lapack_int LAPACKE_sstedc_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dstedc_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_cstedc_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, lapack_complex_float* z,
+                                lapack_int ldz, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zstedc_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, lapack_complex_double* z,
+                                lapack_int ldz, lapack_complex_double* work,
+                                lapack_int lwork, double* rwork,
+                                lapack_int lrwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_sstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, lapack_int* isuppz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_cstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zstegr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int* isuppz, double* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_sstein_work( int matrix_order, lapack_int n, const float* d,
+                                const float* e, lapack_int m, const float* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+lapack_int LAPACKE_dstein_work( int matrix_order, lapack_int n, const double* d,
+                                const double* e, lapack_int m, const double* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit, double* z,
+                                lapack_int ldz, double* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+lapack_int LAPACKE_cstein_work( int matrix_order, lapack_int n, const float* d,
+                                const float* e, lapack_int m, const float* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit,
+                                lapack_complex_float* z, lapack_int ldz,
+                                float* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+lapack_int LAPACKE_zstein_work( int matrix_order, lapack_int n, const double* d,
+                                const double* e, lapack_int m, const double* w,
+                                const lapack_int* iblock,
+                                const lapack_int* isplit,
+                                lapack_complex_double* z, lapack_int ldz,
+                                double* work, lapack_int* iwork,
+                                lapack_int* ifailv );
+
+lapack_int LAPACKE_sstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int nzc,
+                                lapack_int* isuppz, lapack_logical* tryrac,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, lapack_int nzc,
+                                lapack_int* isuppz, lapack_logical* tryrac,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_cstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, float* w,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int nzc, lapack_int* isuppz,
+                                lapack_logical* tryrac, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_zstemr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                lapack_int* m, double* w,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int nzc, lapack_int* isuppz,
+                                lapack_logical* tryrac, double* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_ssteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work );
+lapack_int LAPACKE_dsteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work );
+lapack_int LAPACKE_csteqr_work( int matrix_order, char compz, lapack_int n,
+                                float* d, float* e, lapack_complex_float* z,
+                                lapack_int ldz, float* work );
+lapack_int LAPACKE_zsteqr_work( int matrix_order, char compz, lapack_int n,
+                                double* d, double* e, lapack_complex_double* z,
+                                lapack_int ldz, double* work );
+
+lapack_int LAPACKE_ssterf_work( lapack_int n, float* d, float* e );
+lapack_int LAPACKE_dsterf_work( lapack_int n, double* d, double* e );
+
+lapack_int LAPACKE_sstev_work( int matrix_order, char jobz, lapack_int n,
+                               float* d, float* e, float* z, lapack_int ldz,
+                               float* work );
+lapack_int LAPACKE_dstev_work( int matrix_order, char jobz, lapack_int n,
+                               double* d, double* e, double* z, lapack_int ldz,
+                               double* work );
+
+lapack_int LAPACKE_sstevd_work( int matrix_order, char jobz, lapack_int n,
+                                float* d, float* e, float* z, lapack_int ldz,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dstevd_work( int matrix_order, char jobz, lapack_int n,
+                                double* d, double* e, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sstevr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dstevr_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, lapack_int* isuppz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_sstevx_work( int matrix_order, char jobz, char range,
+                                lapack_int n, float* d, float* e, float vl,
+                                float vu, lapack_int il, lapack_int iu,
+                                float abstol, lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dstevx_work( int matrix_order, char jobz, char range,
+                                lapack_int n, double* d, double* e, double vl,
+                                double vu, lapack_int il, lapack_int iu,
+                                double abstol, lapack_int* m, double* w,
+                                double* z, lapack_int ldz, double* work,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_ssycon_work( int matrix_order, char uplo, lapack_int n,
+                                const float* a, lapack_int lda,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dsycon_work( int matrix_order, char uplo, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_csycon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv, float anorm,
+                                float* rcond, lapack_complex_float* work );
+lapack_int LAPACKE_zsycon_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv, double anorm,
+                                double* rcond, lapack_complex_double* work );
+
+lapack_int LAPACKE_ssyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const float* a, lapack_int lda, float* s,
+                                 float* scond, float* amax, float* work );
+lapack_int LAPACKE_dsyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const double* a, lapack_int lda, double* s,
+                                 double* scond, double* amax, double* work );
+lapack_int LAPACKE_csyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 float* s, float* scond, float* amax,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_zsyequb_work( int matrix_order, char uplo, lapack_int n,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 double* s, double* scond, double* amax,
+                                 lapack_complex_double* work );
+
+lapack_int LAPACKE_ssyev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, float* a, lapack_int lda, float* w,
+                               float* work, lapack_int lwork );
+lapack_int LAPACKE_dsyev_work( int matrix_order, char jobz, char uplo,
+                               lapack_int n, double* a, lapack_int lda,
+                               double* w, double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssyevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, float* a, lapack_int lda,
+                                float* w, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsyevd_work( int matrix_order, char jobz, char uplo,
+                                lapack_int n, double* a, lapack_int lda,
+                                double* w, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssyevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, float* a,
+                                lapack_int lda, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, lapack_int* isuppz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dsyevr_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, double* a,
+                                lapack_int lda, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, lapack_int* isuppz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssyevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, float* a,
+                                lapack_int lda, float vl, float vu,
+                                lapack_int il, lapack_int iu, float abstol,
+                                lapack_int* m, float* w, float* z,
+                                lapack_int ldz, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int* ifail );
+lapack_int LAPACKE_dsyevx_work( int matrix_order, char jobz, char range,
+                                char uplo, lapack_int n, double* a,
+                                lapack_int lda, double vl, double vu,
+                                lapack_int il, lapack_int iu, double abstol,
+                                lapack_int* m, double* w, double* z,
+                                lapack_int ldz, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_ssygst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, float* a, lapack_int lda,
+                                const float* b, lapack_int ldb );
+lapack_int LAPACKE_dsygst_work( int matrix_order, lapack_int itype, char uplo,
+                                lapack_int n, double* a, lapack_int lda,
+                                const double* b, lapack_int ldb );
+
+lapack_int LAPACKE_ssygv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, float* a,
+                               lapack_int lda, float* b, lapack_int ldb,
+                               float* w, float* work, lapack_int lwork );
+lapack_int LAPACKE_dsygv_work( int matrix_order, lapack_int itype, char jobz,
+                               char uplo, lapack_int n, double* a,
+                               lapack_int lda, double* b, lapack_int ldb,
+                               double* w, double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssygvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float* w, float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dsygvd_work( int matrix_order, lapack_int itype, char jobz,
+                                char uplo, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* w, double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+
+lapack_int LAPACKE_ssygvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float vl, float vu, lapack_int il,
+                                lapack_int iu, float abstol, lapack_int* m,
+                                float* w, float* z, lapack_int ldz, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int* ifail );
+lapack_int LAPACKE_dsygvx_work( int matrix_order, lapack_int itype, char jobz,
+                                char range, char uplo, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double vl, double vu, lapack_int il,
+                                lapack_int iu, double abstol, lapack_int* m,
+                                double* w, double* z, lapack_int ldz,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int* ifail );
+
+lapack_int LAPACKE_ssyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const float* af, lapack_int ldaf,
+                                const lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dsyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const double* b, lapack_int ldb, double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                double* work, lapack_int* iwork );
+lapack_int LAPACKE_csyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_zsyrfs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_complex_double* af,
+                                lapack_int ldaf, const lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_ssyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const float* a,
+                                 lapack_int lda, const float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* s, const float* b, lapack_int ldb,
+                                 float* x, lapack_int ldx, float* rcond,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dsyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs, const double* a,
+                                 lapack_int lda, const double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* s, const double* b,
+                                 lapack_int ldb, double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, double* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_csyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_float* a, lapack_int lda,
+                                 const lapack_complex_float* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const float* s, const lapack_complex_float* b,
+                                 lapack_int ldb, lapack_complex_float* x,
+                                 lapack_int ldx, float* rcond, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zsyrfsx_work( int matrix_order, char uplo, char equed,
+                                 lapack_int n, lapack_int nrhs,
+                                 const lapack_complex_double* a, lapack_int lda,
+                                 const lapack_complex_double* af,
+                                 lapack_int ldaf, const lapack_int* ipiv,
+                                 const double* s,
+                                 const lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_ssysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, float* a, lapack_int lda,
+                               lapack_int* ipiv, float* b, lapack_int ldb,
+                               float* work, lapack_int lwork );
+lapack_int LAPACKE_dsysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, double* a, lapack_int lda,
+                               lapack_int* ipiv, double* b, lapack_int ldb,
+                               double* work, lapack_int lwork );
+lapack_int LAPACKE_csysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_float* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_float* b, lapack_int ldb,
+                               lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zsysv_work( int matrix_order, char uplo, lapack_int n,
+                               lapack_int nrhs, lapack_complex_double* a,
+                               lapack_int lda, lapack_int* ipiv,
+                               lapack_complex_double* b, lapack_int ldb,
+                               lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const float* a,
+                                lapack_int lda, float* af, lapack_int ldaf,
+                                lapack_int* ipiv, const float* b,
+                                lapack_int ldb, float* x, lapack_int ldx,
+                                float* rcond, float* ferr, float* berr,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dsysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs, const double* a,
+                                lapack_int lda, double* af, lapack_int ldaf,
+                                lapack_int* ipiv, const double* b,
+                                lapack_int ldb, double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_csysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* af, lapack_int ldaf,
+                                lapack_int* ipiv, const lapack_complex_float* b,
+                                lapack_int ldb, lapack_complex_float* x,
+                                lapack_int ldx, float* rcond, float* ferr,
+                                float* berr, lapack_complex_float* work,
+                                lapack_int lwork, float* rwork );
+lapack_int LAPACKE_zsysvx_work( int matrix_order, char fact, char uplo,
+                                lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* af, lapack_int ldaf,
+                                lapack_int* ipiv,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* x, lapack_int ldx,
+                                double* rcond, double* ferr, double* berr,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork );
+
+lapack_int LAPACKE_ssysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, float* a,
+                                 lapack_int lda, float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* s,
+                                 float* b, lapack_int ldb, float* x,
+                                 lapack_int ldx, float* rcond, float* rpvgrw,
+                                 float* berr, lapack_int n_err_bnds,
+                                 float* err_bnds_norm, float* err_bnds_comp,
+                                 lapack_int nparams, float* params, float* work,
+                                 lapack_int* iwork );
+lapack_int LAPACKE_dsysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs, double* a,
+                                 lapack_int lda, double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* s,
+                                 double* b, lapack_int ldb, double* x,
+                                 lapack_int ldx, double* rcond, double* rpvgrw,
+                                 double* berr, lapack_int n_err_bnds,
+                                 double* err_bnds_norm, double* err_bnds_comp,
+                                 lapack_int nparams, double* params,
+                                 double* work, lapack_int* iwork );
+lapack_int LAPACKE_csysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, float* s,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* x, lapack_int ldx,
+                                 float* rcond, float* rpvgrw, float* berr,
+                                 lapack_int n_err_bnds, float* err_bnds_norm,
+                                 float* err_bnds_comp, lapack_int nparams,
+                                 float* params, lapack_complex_float* work,
+                                 float* rwork );
+lapack_int LAPACKE_zsysvxx_work( int matrix_order, char fact, char uplo,
+                                 lapack_int n, lapack_int nrhs,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* af, lapack_int ldaf,
+                                 lapack_int* ipiv, char* equed, double* s,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* x, lapack_int ldx,
+                                 double* rcond, double* rpvgrw, double* berr,
+                                 lapack_int n_err_bnds, double* err_bnds_norm,
+                                 double* err_bnds_comp, lapack_int nparams,
+                                 double* params, lapack_complex_double* work,
+                                 double* rwork );
+
+lapack_int LAPACKE_ssytrd_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, float* d, float* e,
+                                float* tau, float* work, lapack_int lwork );
+lapack_int LAPACKE_dsytrd_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, double* d, double* e,
+                                double* tau, double* work, lapack_int lwork );
+
+lapack_int LAPACKE_ssytrf_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda, lapack_int* ipiv,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dsytrf_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda, lapack_int* ipiv,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_csytrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_zsytrf_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_int* ipiv, lapack_complex_double* work,
+                                lapack_int lwork );
+
+lapack_int LAPACKE_ssytri_work( int matrix_order, char uplo, lapack_int n,
+                                float* a, lapack_int lda,
+                                const lapack_int* ipiv, float* work );
+lapack_int LAPACKE_dsytri_work( int matrix_order, char uplo, lapack_int n,
+                                double* a, lapack_int lda,
+                                const lapack_int* ipiv, double* work );
+lapack_int LAPACKE_csytri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zsytri_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_int* ipiv,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_ssytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const float* a, lapack_int lda,
+                                const lapack_int* ipiv, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dsytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                double* b, lapack_int ldb );
+lapack_int LAPACKE_csytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_zsytrs_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_int nrhs, const lapack_complex_double* a,
+                                lapack_int lda, const lapack_int* ipiv,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const float* ab, lapack_int ldab, float* rcond,
+                                float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const double* ab, lapack_int ldab,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const lapack_complex_float* ab, lapack_int ldab,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_ztbcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, lapack_int kd,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const float* ab,
+                                lapack_int ldab, const float* b, lapack_int ldb,
+                                const float* x, lapack_int ldx, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const double* ab,
+                                lapack_int ldab, const double* b,
+                                lapack_int ldb, const double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const lapack_complex_float* ab,
+                                lapack_int ldab, const lapack_complex_float* b,
+                                lapack_int ldb, const lapack_complex_float* x,
+                                lapack_int ldx, float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztbrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, const lapack_complex_double* b,
+                                lapack_int ldb, const lapack_complex_double* x,
+                                lapack_int ldx, double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const float* ab,
+                                lapack_int ldab, float* b, lapack_int ldb );
+lapack_int LAPACKE_dtbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const double* ab,
+                                lapack_int ldab, double* b, lapack_int ldb );
+lapack_int LAPACKE_ctbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs, const lapack_complex_float* ab,
+                                lapack_int ldab, lapack_complex_float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_ztbtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int kd,
+                                lapack_int nrhs,
+                                const lapack_complex_double* ab,
+                                lapack_int ldab, lapack_complex_double* b,
+                                lapack_int ldb );
+
+lapack_int LAPACKE_stfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, float alpha, const float* a,
+                               float* b, lapack_int ldb );
+lapack_int LAPACKE_dtfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, double alpha, const double* a,
+                               double* b, lapack_int ldb );
+lapack_int LAPACKE_ctfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, lapack_complex_float alpha,
+                               const lapack_complex_float* a,
+                               lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztfsm_work( int matrix_order, char transr, char side,
+                               char uplo, char trans, char diag, lapack_int m,
+                               lapack_int n, lapack_complex_double alpha,
+                               const lapack_complex_double* a,
+                               lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n, float* a );
+lapack_int LAPACKE_dtftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n, double* a );
+lapack_int LAPACKE_ctftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n,
+                                lapack_complex_float* a );
+lapack_int LAPACKE_ztftri_work( int matrix_order, char transr, char uplo,
+                                char diag, lapack_int n,
+                                lapack_complex_double* a );
+
+lapack_int LAPACKE_stfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* arf, float* ap );
+lapack_int LAPACKE_dtfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* arf, double* ap );
+lapack_int LAPACKE_ctfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* arf,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_ztfttp_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* arf,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_stfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* arf, float* a,
+                                lapack_int lda );
+lapack_int LAPACKE_dtfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* arf, double* a,
+                                lapack_int lda );
+lapack_int LAPACKE_ctfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* arf,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztfttr_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* arf,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_stgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const float* s, lapack_int lds, const float* p,
+                                lapack_int ldp, float* vl, lapack_int ldvl,
+                                float* vr, lapack_int ldvr, lapack_int mm,
+                                lapack_int* m, float* work );
+lapack_int LAPACKE_dtgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const double* s, lapack_int lds,
+                                const double* p, lapack_int ldp, double* vl,
+                                lapack_int ldvl, double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, double* work );
+lapack_int LAPACKE_ctgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_float* s, lapack_int lds,
+                                const lapack_complex_float* p, lapack_int ldp,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztgevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_double* s, lapack_int lds,
+                                const lapack_complex_double* p, lapack_int ldp,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n, float* a,
+                                lapack_int lda, float* b, lapack_int ldb,
+                                float* q, lapack_int ldq, float* z,
+                                lapack_int ldz, lapack_int* ifst,
+                                lapack_int* ilst, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dtgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* q, lapack_int ldq, double* z,
+                                lapack_int ldz, lapack_int* ifst,
+                                lapack_int* ilst, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_ctgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztgexc_work( int matrix_order, lapack_logical wantq,
+                                lapack_logical wantz, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_stgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float* alphar, float* alphai,
+                                float* beta, float* q, lapack_int ldq, float* z,
+                                lapack_int ldz, lapack_int* m, float* pl,
+                                float* pr, float* dif, float* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+lapack_int LAPACKE_dtgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double* alphar, double* alphai,
+                                double* beta, double* q, lapack_int ldq,
+                                double* z, lapack_int ldz, lapack_int* m,
+                                double* pl, double* pr, double* dif,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_ctgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* alpha,
+                                lapack_complex_float* beta,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* z, lapack_int ldz,
+                                lapack_int* m, float* pl, float* pr, float* dif,
+                                lapack_complex_float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_ztgsen_work( int matrix_order, lapack_int ijob,
+                                lapack_logical wantq, lapack_logical wantz,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* alpha,
+                                lapack_complex_double* beta,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* z, lapack_int ldz,
+                                lapack_int* m, double* pl, double* pr,
+                                double* dif, lapack_complex_double* work,
+                                lapack_int lwork, lapack_int* iwork,
+                                lapack_int liwork );
+
+lapack_int LAPACKE_stgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                float* a, lapack_int lda, float* b,
+                                lapack_int ldb, float tola, float tolb,
+                                float* alpha, float* beta, float* u,
+                                lapack_int ldu, float* v, lapack_int ldv,
+                                float* q, lapack_int ldq, float* work,
+                                lapack_int* ncycle );
+lapack_int LAPACKE_dtgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                double* a, lapack_int lda, double* b,
+                                lapack_int ldb, double tola, double tolb,
+                                double* alpha, double* beta, double* u,
+                                lapack_int ldu, double* v, lapack_int ldv,
+                                double* q, lapack_int ldq, double* work,
+                                lapack_int* ncycle );
+lapack_int LAPACKE_ctgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                float tola, float tolb, float* alpha,
+                                float* beta, lapack_complex_float* u,
+                                lapack_int ldu, lapack_complex_float* v,
+                                lapack_int ldv, lapack_complex_float* q,
+                                lapack_int ldq, lapack_complex_float* work,
+                                lapack_int* ncycle );
+lapack_int LAPACKE_ztgsja_work( int matrix_order, char jobu, char jobv,
+                                char jobq, lapack_int m, lapack_int p,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                double tola, double tolb, double* alpha,
+                                double* beta, lapack_complex_double* u,
+                                lapack_int ldu, lapack_complex_double* v,
+                                lapack_int ldv, lapack_complex_double* q,
+                                lapack_int ldq, lapack_complex_double* work,
+                                lapack_int* ncycle );
+
+lapack_int LAPACKE_stgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const float* a, lapack_int lda, const float* b,
+                                lapack_int ldb, const float* vl,
+                                lapack_int ldvl, const float* vr,
+                                lapack_int ldvr, float* s, float* dif,
+                                lapack_int mm, lapack_int* m, float* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_dtgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const double* b, lapack_int ldb,
+                                const double* vl, lapack_int ldvl,
+                                const double* vr, lapack_int ldvr, double* s,
+                                double* dif, lapack_int mm, lapack_int* m,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                const lapack_complex_float* vl, lapack_int ldvl,
+                                const lapack_complex_float* vr, lapack_int ldvr,
+                                float* s, float* dif, lapack_int mm,
+                                lapack_int* m, lapack_complex_float* work,
+                                lapack_int lwork, lapack_int* iwork );
+lapack_int LAPACKE_ztgsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                const lapack_complex_double* vl,
+                                lapack_int ldvl,
+                                const lapack_complex_double* vr,
+                                lapack_int ldvr, double* s, double* dif,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, lapack_int lwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_stgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n, const float* a,
+                                lapack_int lda, const float* b, lapack_int ldb,
+                                float* c, lapack_int ldc, const float* d,
+                                lapack_int ldd, const float* e, lapack_int lde,
+                                float* f, lapack_int ldf, float* scale,
+                                float* dif, float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dtgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n, const double* a,
+                                lapack_int lda, const double* b, lapack_int ldb,
+                                double* c, lapack_int ldc, const double* d,
+                                lapack_int ldd, const double* e, lapack_int lde,
+                                double* f, lapack_int ldf, double* scale,
+                                double* dif, double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* c, lapack_int ldc,
+                                const lapack_complex_float* d, lapack_int ldd,
+                                const lapack_complex_float* e, lapack_int lde,
+                                lapack_complex_float* f, lapack_int ldf,
+                                float* scale, float* dif,
+                                lapack_complex_float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ztgsyl_work( int matrix_order, char trans, lapack_int ijob,
+                                lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* c, lapack_int ldc,
+                                const lapack_complex_double* d, lapack_int ldd,
+                                const lapack_complex_double* e, lapack_int lde,
+                                lapack_complex_double* f, lapack_int ldf,
+                                double* scale, double* dif,
+                                lapack_complex_double* work, lapack_int lwork,
+                                lapack_int* iwork );
+
+lapack_int LAPACKE_stpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const float* ap,
+                                float* rcond, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const double* ap,
+                                double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_float* ap, float* rcond,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztpcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_double* ap, double* rcond,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* ap, const float* b, lapack_int ldb,
+                                const float* x, lapack_int ldx, float* ferr,
+                                float* berr, float* work, lapack_int* iwork );
+lapack_int LAPACKE_dtprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* ap, const double* b,
+                                lapack_int ldb, const double* x, lapack_int ldx,
+                                double* ferr, double* berr, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                const lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztprfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                const lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_stptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, float* ap );
+lapack_int LAPACKE_dtptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, double* ap );
+lapack_int LAPACKE_ctptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_float* ap );
+lapack_int LAPACKE_ztptri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_double* ap );
+
+lapack_int LAPACKE_stptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* ap, float* b, lapack_int ldb );
+lapack_int LAPACKE_dtptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* ap, double* b, lapack_int ldb );
+lapack_int LAPACKE_ctptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztptrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_stpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* ap, float* arf );
+lapack_int LAPACKE_dtpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* ap, double* arf );
+lapack_int LAPACKE_ctpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* ap,
+                                lapack_complex_float* arf );
+lapack_int LAPACKE_ztpttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* ap,
+                                lapack_complex_double* arf );
+
+lapack_int LAPACKE_stpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const float* ap, float* a, lapack_int lda );
+lapack_int LAPACKE_dtpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const double* ap, double* a, lapack_int lda );
+lapack_int LAPACKE_ctpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_ztpttr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_strcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const float* a,
+                                lapack_int lda, float* rcond, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dtrcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n, const double* a,
+                                lapack_int lda, double* rcond, double* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctrcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                float* rcond, lapack_complex_float* work,
+                                float* rwork );
+lapack_int LAPACKE_ztrcon_work( int matrix_order, char norm, char uplo,
+                                char diag, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                double* rcond, lapack_complex_double* work,
+                                double* rwork );
+
+lapack_int LAPACKE_strevc_work( int matrix_order, char side, char howmny,
+                                lapack_logical* select, lapack_int n,
+                                const float* t, lapack_int ldt, float* vl,
+                                lapack_int ldvl, float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, float* work );
+lapack_int LAPACKE_dtrevc_work( int matrix_order, char side, char howmny,
+                                lapack_logical* select, lapack_int n,
+                                const double* t, lapack_int ldt, double* vl,
+                                lapack_int ldvl, double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m, double* work );
+lapack_int LAPACKE_ctrevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* vl, lapack_int ldvl,
+                                lapack_complex_float* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztrevc_work( int matrix_order, char side, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* vl, lapack_int ldvl,
+                                lapack_complex_double* vr, lapack_int ldvr,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_strexc_work( int matrix_order, char compq, lapack_int n,
+                                float* t, lapack_int ldt, float* q,
+                                lapack_int ldq, lapack_int* ifst,
+                                lapack_int* ilst, float* work );
+lapack_int LAPACKE_dtrexc_work( int matrix_order, char compq, lapack_int n,
+                                double* t, lapack_int ldt, double* q,
+                                lapack_int ldq, lapack_int* ifst,
+                                lapack_int* ilst, double* work );
+lapack_int LAPACKE_ctrexc_work( int matrix_order, char compq, lapack_int n,
+                                lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_int ifst, lapack_int ilst );
+lapack_int LAPACKE_ztrexc_work( int matrix_order, char compq, lapack_int n,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_int ifst, lapack_int ilst );
+
+lapack_int LAPACKE_strrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* a, lapack_int lda, const float* b,
+                                lapack_int ldb, const float* x, lapack_int ldx,
+                                float* ferr, float* berr, float* work,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dtrrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* a, lapack_int lda,
+                                const double* b, lapack_int ldb,
+                                const double* x, lapack_int ldx, double* ferr,
+                                double* berr, double* work, lapack_int* iwork );
+lapack_int LAPACKE_ctrrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                const lapack_complex_float* x, lapack_int ldx,
+                                float* ferr, float* berr,
+                                lapack_complex_float* work, float* rwork );
+lapack_int LAPACKE_ztrrfs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                const lapack_complex_double* x, lapack_int ldx,
+                                double* ferr, double* berr,
+                                lapack_complex_double* work, double* rwork );
+
+lapack_int LAPACKE_strsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                float* t, lapack_int ldt, float* q,
+                                lapack_int ldq, float* wr, float* wi,
+                                lapack_int* m, float* s, float* sep,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_dtrsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                double* t, lapack_int ldt, double* q,
+                                lapack_int ldq, double* wr, double* wi,
+                                lapack_int* m, double* s, double* sep,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork, lapack_int liwork );
+lapack_int LAPACKE_ctrsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* w, lapack_int* m,
+                                float* s, float* sep,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_ztrsen_work( int matrix_order, char job, char compq,
+                                const lapack_logical* select, lapack_int n,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* w, lapack_int* m,
+                                double* s, double* sep,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_strsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const float* t, lapack_int ldt, const float* vl,
+                                lapack_int ldvl, const float* vr,
+                                lapack_int ldvr, float* s, float* sep,
+                                lapack_int mm, lapack_int* m, float* work,
+                                lapack_int ldwork, lapack_int* iwork );
+lapack_int LAPACKE_dtrsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const double* t, lapack_int ldt,
+                                const double* vl, lapack_int ldvl,
+                                const double* vr, lapack_int ldvr, double* s,
+                                double* sep, lapack_int mm, lapack_int* m,
+                                double* work, lapack_int ldwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ctrsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_float* t, lapack_int ldt,
+                                const lapack_complex_float* vl, lapack_int ldvl,
+                                const lapack_complex_float* vr, lapack_int ldvr,
+                                float* s, float* sep, lapack_int mm,
+                                lapack_int* m, lapack_complex_float* work,
+                                lapack_int ldwork, float* rwork );
+lapack_int LAPACKE_ztrsna_work( int matrix_order, char job, char howmny,
+                                const lapack_logical* select, lapack_int n,
+                                const lapack_complex_double* t, lapack_int ldt,
+                                const lapack_complex_double* vl,
+                                lapack_int ldvl,
+                                const lapack_complex_double* vr,
+                                lapack_int ldvr, double* s, double* sep,
+                                lapack_int mm, lapack_int* m,
+                                lapack_complex_double* work, lapack_int ldwork,
+                                double* rwork );
+
+lapack_int LAPACKE_strsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const float* a, lapack_int lda, const float* b,
+                                lapack_int ldb, float* c, lapack_int ldc,
+                                float* scale );
+lapack_int LAPACKE_dtrsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const double* a, lapack_int lda,
+                                const double* b, lapack_int ldb, double* c,
+                                lapack_int ldc, double* scale );
+lapack_int LAPACKE_ctrsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* b, lapack_int ldb,
+                                lapack_complex_float* c, lapack_int ldc,
+                                float* scale );
+lapack_int LAPACKE_ztrsyl_work( int matrix_order, char trana, char tranb,
+                                lapack_int isgn, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* c, lapack_int ldc,
+                                double* scale );
+
+lapack_int LAPACKE_strtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, float* a, lapack_int lda );
+lapack_int LAPACKE_dtrtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, double* a, lapack_int lda );
+lapack_int LAPACKE_ctrtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_float* a,
+                                lapack_int lda );
+lapack_int LAPACKE_ztrtri_work( int matrix_order, char uplo, char diag,
+                                lapack_int n, lapack_complex_double* a,
+                                lapack_int lda );
+
+lapack_int LAPACKE_strtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const float* a, lapack_int lda, float* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_dtrtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const double* a, lapack_int lda, double* b,
+                                lapack_int ldb );
+lapack_int LAPACKE_ctrtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztrtrs_work( int matrix_order, char uplo, char trans,
+                                char diag, lapack_int n, lapack_int nrhs,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_strttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const float* a, lapack_int lda,
+                                float* arf );
+lapack_int LAPACKE_dtrttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const double* a, lapack_int lda,
+                                double* arf );
+lapack_int LAPACKE_ctrttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* arf );
+lapack_int LAPACKE_ztrttf_work( int matrix_order, char transr, char uplo,
+                                lapack_int n, const lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* arf );
+
+lapack_int LAPACKE_strttp_work( int matrix_order, char uplo, lapack_int n,
+                                const float* a, lapack_int lda, float* ap );
+lapack_int LAPACKE_dtrttp_work( int matrix_order, char uplo, lapack_int n,
+                                const double* a, lapack_int lda, double* ap );
+lapack_int LAPACKE_ctrttp_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* ap );
+lapack_int LAPACKE_ztrttp_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* ap );
+
+lapack_int LAPACKE_stzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                float* a, lapack_int lda, float* tau,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_dtzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                double* a, lapack_int lda, double* tau,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_ctzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_ztzrzf_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungbr_work( int matrix_order, char vect, lapack_int m,
+                                lapack_int n, lapack_int k,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunghr_work( int matrix_order, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunglq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungql_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungqr_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungrq_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int k, lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cungtr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zungtr_work( int matrix_order, char uplo, lapack_int n,
+                                lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmbr_work( int matrix_order, char vect, char side,
+                                char trans, lapack_int m, lapack_int n,
+                                lapack_int k, const lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmhr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int ilo,
+                                lapack_int ihi, const lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmlq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmql_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmqr_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmrq_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const lapack_complex_float* a,
+                                lapack_int lda, const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmrz_work( int matrix_order, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                lapack_int l, const lapack_complex_double* a,
+                                lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cunmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_float* a, lapack_int lda,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_zunmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork );
+
+lapack_int LAPACKE_cupgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* q, lapack_int ldq,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zupgtr_work( int matrix_order, char uplo, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* q, lapack_int ldq,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_cupmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_float* ap,
+                                const lapack_complex_float* tau,
+                                lapack_complex_float* c, lapack_int ldc,
+                                lapack_complex_float* work );
+lapack_int LAPACKE_zupmtr_work( int matrix_order, char side, char uplo,
+                                char trans, lapack_int m, lapack_int n,
+                                const lapack_complex_double* ap,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_claghe( int matrix_order, lapack_int n, lapack_int k,
+                           const float* d, lapack_complex_float* a,
+                           lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_zlaghe( int matrix_order, lapack_int n, lapack_int k,
+                           const double* d, lapack_complex_double* a,
+                           lapack_int lda, lapack_int* iseed );
+
+lapack_int LAPACKE_slagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const float* d, float* a, lapack_int lda,
+                           lapack_int* iseed );
+lapack_int LAPACKE_dlagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const double* d, double* a, lapack_int lda,
+                           lapack_int* iseed );
+lapack_int LAPACKE_clagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const float* d, lapack_complex_float* a,
+                           lapack_int lda, lapack_int* iseed );
+lapack_int LAPACKE_zlagsy( int matrix_order, lapack_int n, lapack_int k,
+                           const double* d, lapack_complex_double* a,
+                           lapack_int lda, lapack_int* iseed );
+
+lapack_int LAPACKE_slapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, float* x, lapack_int ldx,
+                           lapack_int* k );
+lapack_int LAPACKE_dlapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, double* x,
+                           lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_clapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, lapack_complex_float* x,
+                           lapack_int ldx, lapack_int* k );
+lapack_int LAPACKE_zlapmr( int matrix_order, lapack_logical forwrd,
+                           lapack_int m, lapack_int n, lapack_complex_double* x,
+                           lapack_int ldx, lapack_int* k );
+
+
+float LAPACKE_slapy2( float x, float y );
+double LAPACKE_dlapy2( double x, double y );
+
+float LAPACKE_slapy3( float x, float y, float z );
+double LAPACKE_dlapy3( double x, double y, double z );
+
+lapack_int LAPACKE_slartgp( float f, float g, float* cs, float* sn, float* r );
+lapack_int LAPACKE_dlartgp( double f, double g, double* cs, double* sn,
+                            double* r );
+
+lapack_int LAPACKE_slartgs( float x, float y, float sigma, float* cs,
+                            float* sn );
+lapack_int LAPACKE_dlartgs( double x, double y, double sigma, double* cs,
+                            double* sn );
+
+
+//LAPACK 3.3.0
+lapack_int LAPACKE_cbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, float* theta, float* phi,
+                           lapack_complex_float* u1, lapack_int ldu1,
+                           lapack_complex_float* u2, lapack_int ldu2,
+                           lapack_complex_float* v1t, lapack_int ldv1t,
+                           lapack_complex_float* v2t, lapack_int ldv2t,
+                           float* b11d, float* b11e, float* b12d, float* b12e,
+                           float* b21d, float* b21e, float* b22d, float* b22e );
+lapack_int LAPACKE_cbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                float* theta, float* phi,
+                                lapack_complex_float* u1, lapack_int ldu1,
+                                lapack_complex_float* u2, lapack_int ldu2,
+                                lapack_complex_float* v1t, lapack_int ldv1t,
+                                lapack_complex_float* v2t, lapack_int ldv2t,
+                                float* b11d, float* b11e, float* b12d,
+                                float* b12e, float* b21d, float* b21e,
+                                float* b22d, float* b22e, float* rwork,
+                                lapack_int lrwork );
+lapack_int LAPACKE_cheswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_cheswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_chetri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_chetri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_chetri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_chetri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_float* work, lapack_int nb );
+lapack_int LAPACKE_chetrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_float* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_chetrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_csyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_csyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, lapack_complex_float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_csyswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_csyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_csytri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_csytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_csytri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_csytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_float* work, lapack_int nb );
+lapack_int LAPACKE_csytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_float* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_csytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_cunbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_float* x11, lapack_int ldx11,
+                           lapack_complex_float* x12, lapack_int ldx12,
+                           lapack_complex_float* x21, lapack_int ldx21,
+                           lapack_complex_float* x22, lapack_int ldx22,
+                           float* theta, float* phi,
+                           lapack_complex_float* taup1,
+                           lapack_complex_float* taup2,
+                           lapack_complex_float* tauq1,
+                           lapack_complex_float* tauq2 );
+lapack_int LAPACKE_cunbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                lapack_complex_float* x11, lapack_int ldx11,
+                                lapack_complex_float* x12, lapack_int ldx12,
+                                lapack_complex_float* x21, lapack_int ldx21,
+                                lapack_complex_float* x22, lapack_int ldx22,
+                                float* theta, float* phi,
+                                lapack_complex_float* taup1,
+                                lapack_complex_float* taup2,
+                                lapack_complex_float* tauq1,
+                                lapack_complex_float* tauq2,
+                                lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_cuncsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_float* x11, lapack_int ldx11,
+                           lapack_complex_float* x12, lapack_int ldx12,
+                           lapack_complex_float* x21, lapack_int ldx21,
+                           lapack_complex_float* x22, lapack_int ldx22,
+                           float* theta, lapack_complex_float* u1,
+                           lapack_int ldu1, lapack_complex_float* u2,
+                           lapack_int ldu2, lapack_complex_float* v1t,
+                           lapack_int ldv1t, lapack_complex_float* v2t,
+                           lapack_int ldv2t );
+lapack_int LAPACKE_cuncsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, lapack_complex_float* x11,
+                                lapack_int ldx11, lapack_complex_float* x12,
+                                lapack_int ldx12, lapack_complex_float* x21,
+                                lapack_int ldx21, lapack_complex_float* x22,
+                                lapack_int ldx22, float* theta,
+                                lapack_complex_float* u1, lapack_int ldu1,
+                                lapack_complex_float* u2, lapack_int ldu2,
+                                lapack_complex_float* v1t, lapack_int ldv1t,
+                                lapack_complex_float* v2t, lapack_int ldv2t,
+                                lapack_complex_float* work, lapack_int lwork,
+                                float* rwork, lapack_int lrwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, double* theta,
+                           double* phi, double* u1, lapack_int ldu1, double* u2,
+                           lapack_int ldu2, double* v1t, lapack_int ldv1t,
+                           double* v2t, lapack_int ldv2t, double* b11d,
+                           double* b11e, double* b12d, double* b12e,
+                           double* b21d, double* b21e, double* b22d,
+                           double* b22e );
+lapack_int LAPACKE_dbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                double* theta, double* phi, double* u1,
+                                lapack_int ldu1, double* u2, lapack_int ldu2,
+                                double* v1t, lapack_int ldv1t, double* v2t,
+                                lapack_int ldv2t, double* b11d, double* b11e,
+                                double* b12d, double* b12e, double* b21d,
+                                double* b21e, double* b22d, double* b22e,
+                                double* work, lapack_int lwork );
+lapack_int LAPACKE_dorbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           double* x11, lapack_int ldx11, double* x12,
+                           lapack_int ldx12, double* x21, lapack_int ldx21,
+                           double* x22, lapack_int ldx22, double* theta,
+                           double* phi, double* taup1, double* taup2,
+                           double* tauq1, double* tauq2 );
+lapack_int LAPACKE_dorbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                double* x11, lapack_int ldx11, double* x12,
+                                lapack_int ldx12, double* x21, lapack_int ldx21,
+                                double* x22, lapack_int ldx22, double* theta,
+                                double* phi, double* taup1, double* taup2,
+                                double* tauq1, double* tauq2, double* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_dorcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           double* x11, lapack_int ldx11, double* x12,
+                           lapack_int ldx12, double* x21, lapack_int ldx21,
+                           double* x22, lapack_int ldx22, double* theta,
+                           double* u1, lapack_int ldu1, double* u2,
+                           lapack_int ldu2, double* v1t, lapack_int ldv1t,
+                           double* v2t, lapack_int ldv2t );
+lapack_int LAPACKE_dorcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, double* x11, lapack_int ldx11,
+                                double* x12, lapack_int ldx12, double* x21,
+                                lapack_int ldx21, double* x22, lapack_int ldx22,
+                                double* theta, double* u1, lapack_int ldu1,
+                                double* u2, lapack_int ldu2, double* v1t,
+                                lapack_int ldv1t, double* v2t, lapack_int ldv2t,
+                                double* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_dsyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            double* a, lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dsyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, double* a, lapack_int lda,
+                                 const lapack_int* ipiv, double* work );
+lapack_int LAPACKE_dsyswapr( int matrix_order, char uplo, lapack_int n,
+                             double* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_dsyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  double* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_dsytri2( int matrix_order, char uplo, lapack_int n,
+                            double* a, lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_dsytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 double* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_dsytri2x( int matrix_order, char uplo, lapack_int n,
+                             double* a, lapack_int lda, const lapack_int* ipiv,
+                             lapack_int nb );
+lapack_int LAPACKE_dsytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  double* a, lapack_int lda,
+                                  const lapack_int* ipiv, double* work,
+                                  lapack_int nb );
+lapack_int LAPACKE_dsytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const double* a, lapack_int lda,
+                            const lapack_int* ipiv, double* b, lapack_int ldb );
+lapack_int LAPACKE_dsytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 double* b, lapack_int ldb, double* work );
+lapack_int LAPACKE_sbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, float* theta, float* phi,
+                           float* u1, lapack_int ldu1, float* u2,
+                           lapack_int ldu2, float* v1t, lapack_int ldv1t,
+                           float* v2t, lapack_int ldv2t, float* b11d,
+                           float* b11e, float* b12d, float* b12e, float* b21d,
+                           float* b21e, float* b22d, float* b22e );
+lapack_int LAPACKE_sbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                float* theta, float* phi, float* u1,
+                                lapack_int ldu1, float* u2, lapack_int ldu2,
+                                float* v1t, lapack_int ldv1t, float* v2t,
+                                lapack_int ldv2t, float* b11d, float* b11e,
+                                float* b12d, float* b12e, float* b21d,
+                                float* b21e, float* b22d, float* b22e,
+                                float* work, lapack_int lwork );
+lapack_int LAPACKE_sorbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q, float* x11,
+                           lapack_int ldx11, float* x12, lapack_int ldx12,
+                           float* x21, lapack_int ldx21, float* x22,
+                           lapack_int ldx22, float* theta, float* phi,
+                           float* taup1, float* taup2, float* tauq1,
+                           float* tauq2 );
+lapack_int LAPACKE_sorbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                float* x11, lapack_int ldx11, float* x12,
+                                lapack_int ldx12, float* x21, lapack_int ldx21,
+                                float* x22, lapack_int ldx22, float* theta,
+                                float* phi, float* taup1, float* taup2,
+                                float* tauq1, float* tauq2, float* work,
+                                lapack_int lwork );
+lapack_int LAPACKE_sorcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q, float* x11,
+                           lapack_int ldx11, float* x12, lapack_int ldx12,
+                           float* x21, lapack_int ldx21, float* x22,
+                           lapack_int ldx22, float* theta, float* u1,
+                           lapack_int ldu1, float* u2, lapack_int ldu2,
+                           float* v1t, lapack_int ldv1t, float* v2t,
+                           lapack_int ldv2t );
+lapack_int LAPACKE_sorcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, float* x11, lapack_int ldx11,
+                                float* x12, lapack_int ldx12, float* x21,
+                                lapack_int ldx21, float* x22, lapack_int ldx22,
+                                float* theta, float* u1, lapack_int ldu1,
+                                float* u2, lapack_int ldu2, float* v1t,
+                                lapack_int ldv1t, float* v2t, lapack_int ldv2t,
+                                float* work, lapack_int lwork,
+                                lapack_int* iwork );
+lapack_int LAPACKE_ssyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            float* a, lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_ssyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, float* a, lapack_int lda,
+                                 const lapack_int* ipiv, float* work );
+lapack_int LAPACKE_ssyswapr( int matrix_order, char uplo, lapack_int n,
+                             float* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_ssyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  float* a, lapack_int i1, lapack_int i2 );
+lapack_int LAPACKE_ssytri2( int matrix_order, char uplo, lapack_int n, float* a,
+                            lapack_int lda, const lapack_int* ipiv );
+lapack_int LAPACKE_ssytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 float* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_float* work, lapack_int lwork );
+lapack_int LAPACKE_ssytri2x( int matrix_order, char uplo, lapack_int n,
+                             float* a, lapack_int lda, const lapack_int* ipiv,
+                             lapack_int nb );
+lapack_int LAPACKE_ssytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  float* a, lapack_int lda,
+                                  const lapack_int* ipiv, float* work,
+                                  lapack_int nb );
+lapack_int LAPACKE_ssytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const float* a, lapack_int lda,
+                            const lapack_int* ipiv, float* b, lapack_int ldb );
+lapack_int LAPACKE_ssytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const float* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 float* b, lapack_int ldb, float* work );
+lapack_int LAPACKE_zbbcsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, lapack_int m,
+                           lapack_int p, lapack_int q, double* theta,
+                           double* phi, lapack_complex_double* u1,
+                           lapack_int ldu1, lapack_complex_double* u2,
+                           lapack_int ldu2, lapack_complex_double* v1t,
+                           lapack_int ldv1t, lapack_complex_double* v2t,
+                           lapack_int ldv2t, double* b11d, double* b11e,
+                           double* b12d, double* b12e, double* b21d,
+                           double* b21e, double* b22d, double* b22e );
+lapack_int LAPACKE_zbbcsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                double* theta, double* phi,
+                                lapack_complex_double* u1, lapack_int ldu1,
+                                lapack_complex_double* u2, lapack_int ldu2,
+                                lapack_complex_double* v1t, lapack_int ldv1t,
+                                lapack_complex_double* v2t, lapack_int ldv2t,
+                                double* b11d, double* b11e, double* b12d,
+                                double* b12e, double* b21d, double* b21e,
+                                double* b22d, double* b22e, double* rwork,
+                                lapack_int lrwork );
+lapack_int LAPACKE_zheswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_zheswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_zhetri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_zhetri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_zhetri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_zhetri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_double* work, lapack_int nb );
+lapack_int LAPACKE_zhetrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_double* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_double* b, lapack_int ldb );
+lapack_int LAPACKE_zhetrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* work );
+lapack_int LAPACKE_zsyconv( int matrix_order, char uplo, char way, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_zsyconv_work( int matrix_order, char uplo, char way,
+                                 lapack_int n, lapack_complex_double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_double* work );
+lapack_int LAPACKE_zsyswapr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int i1,
+                             lapack_int i2 );
+lapack_int LAPACKE_zsyswapr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int i1,
+                                  lapack_int i2 );
+lapack_int LAPACKE_zsytri2( int matrix_order, char uplo, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            const lapack_int* ipiv );
+lapack_int LAPACKE_zsytri2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 const lapack_int* ipiv,
+                                 lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_zsytri2x( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double* a, lapack_int lda,
+                             const lapack_int* ipiv, lapack_int nb );
+lapack_int LAPACKE_zsytri2x_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double* a, lapack_int lda,
+                                  const lapack_int* ipiv,
+                                  lapack_complex_double* work, lapack_int nb );
+lapack_int LAPACKE_zsytrs2( int matrix_order, char uplo, lapack_int n,
+                            lapack_int nrhs, const lapack_complex_double* a,
+                            lapack_int lda, const lapack_int* ipiv,
+                            lapack_complex_double* b, lapack_int ldb );
+lapack_int LAPACKE_zsytrs2_work( int matrix_order, char uplo, lapack_int n,
+                                 lapack_int nrhs, const lapack_complex_double* a,
+                                 lapack_int lda, const lapack_int* ipiv,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* work );
+lapack_int LAPACKE_zunbdb( int matrix_order, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_double* x11, lapack_int ldx11,
+                           lapack_complex_double* x12, lapack_int ldx12,
+                           lapack_complex_double* x21, lapack_int ldx21,
+                           lapack_complex_double* x22, lapack_int ldx22,
+                           double* theta, double* phi,
+                           lapack_complex_double* taup1,
+                           lapack_complex_double* taup2,
+                           lapack_complex_double* tauq1,
+                           lapack_complex_double* tauq2 );
+lapack_int LAPACKE_zunbdb_work( int matrix_order, char trans, char signs,
+                                lapack_int m, lapack_int p, lapack_int q,
+                                lapack_complex_double* x11, lapack_int ldx11,
+                                lapack_complex_double* x12, lapack_int ldx12,
+                                lapack_complex_double* x21, lapack_int ldx21,
+                                lapack_complex_double* x22, lapack_int ldx22,
+                                double* theta, double* phi,
+                                lapack_complex_double* taup1,
+                                lapack_complex_double* taup2,
+                                lapack_complex_double* tauq1,
+                                lapack_complex_double* tauq2,
+                                lapack_complex_double* work, lapack_int lwork );
+lapack_int LAPACKE_zuncsd( int matrix_order, char jobu1, char jobu2,
+                           char jobv1t, char jobv2t, char trans, char signs,
+                           lapack_int m, lapack_int p, lapack_int q,
+                           lapack_complex_double* x11, lapack_int ldx11,
+                           lapack_complex_double* x12, lapack_int ldx12,
+                           lapack_complex_double* x21, lapack_int ldx21,
+                           lapack_complex_double* x22, lapack_int ldx22,
+                           double* theta, lapack_complex_double* u1,
+                           lapack_int ldu1, lapack_complex_double* u2,
+                           lapack_int ldu2, lapack_complex_double* v1t,
+                           lapack_int ldv1t, lapack_complex_double* v2t,
+                           lapack_int ldv2t );
+lapack_int LAPACKE_zuncsd_work( int matrix_order, char jobu1, char jobu2,
+                                char jobv1t, char jobv2t, char trans,
+                                char signs, lapack_int m, lapack_int p,
+                                lapack_int q, lapack_complex_double* x11,
+                                lapack_int ldx11, lapack_complex_double* x12,
+                                lapack_int ldx12, lapack_complex_double* x21,
+                                lapack_int ldx21, lapack_complex_double* x22,
+                                lapack_int ldx22, double* theta,
+                                lapack_complex_double* u1, lapack_int ldu1,
+                                lapack_complex_double* u2, lapack_int ldu2,
+                                lapack_complex_double* v1t, lapack_int ldv1t,
+                                lapack_complex_double* v2t, lapack_int ldv2t,
+                                lapack_complex_double* work, lapack_int lwork,
+                                double* rwork, lapack_int lrwork,
+                                lapack_int* iwork );
+//LAPACK 3.4.0
+lapack_int LAPACKE_sgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const float* v, lapack_int ldv,
+                            const float* t, lapack_int ldt, float* c,
+                            lapack_int ldc );
+lapack_int LAPACKE_dgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const double* v, lapack_int ldv,
+                            const double* t, lapack_int ldt, double* c,
+                            lapack_int ldc );
+lapack_int LAPACKE_cgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const lapack_complex_float* v,
+                            lapack_int ldv, const lapack_complex_float* t,
+                            lapack_int ldt, lapack_complex_float* c,
+                            lapack_int ldc );
+lapack_int LAPACKE_zgemqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int nb, const lapack_complex_double* v,
+                            lapack_int ldv, const lapack_complex_double* t,
+                            lapack_int ldt, lapack_complex_double* c,
+                            lapack_int ldc );
+
+lapack_int LAPACKE_sgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, float* a, lapack_int lda, float* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_dgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, double* a, lapack_int lda, double* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_cgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_zgeqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int nb, lapack_complex_double* a,
+                           lapack_int lda, lapack_complex_double* t,
+                           lapack_int ldt );
+
+lapack_int LAPACKE_sgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_dgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_cgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_sgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_dgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* t,
+                            lapack_int ldt );
+lapack_int LAPACKE_cgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt3( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb, const float* v,
+                            lapack_int ldv, const float* t, lapack_int ldt,
+                            float* a, lapack_int lda, float* b,
+                            lapack_int ldb );
+lapack_int LAPACKE_dtpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb, const double* v,
+                            lapack_int ldv, const double* t, lapack_int ldt,
+                            double* a, lapack_int lda, double* b,
+                            lapack_int ldb );
+lapack_int LAPACKE_ctpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb,
+                            const lapack_complex_float* v, lapack_int ldv,
+                            const lapack_complex_float* t, lapack_int ldt,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* b, lapack_int ldb );
+lapack_int LAPACKE_ztpmqrt( int matrix_order, char side, char trans,
+                            lapack_int m, lapack_int n, lapack_int k,
+                            lapack_int l, lapack_int nb,
+                            const lapack_complex_double* v, lapack_int ldv,
+                            const lapack_complex_double* t, lapack_int ldt,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* b, lapack_int ldb );
+
+lapack_int LAPACKE_dtpqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int l, lapack_int nb, double* a,
+                           lapack_int lda, double* b, lapack_int ldb, double* t,
+                           lapack_int ldt );
+lapack_int LAPACKE_ctpqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int l, lapack_int nb, lapack_complex_float* a,
+                           lapack_int lda, lapack_complex_float* t,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_int ldt );
+lapack_int LAPACKE_ztpqrt( int matrix_order, lapack_int m, lapack_int n,
+                           lapack_int l, lapack_int nb,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            float* a, lapack_int lda, float* b, lapack_int ldb,
+                            float* t, lapack_int ldt );
+lapack_int LAPACKE_dtpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            double* a, lapack_int lda, double* b,
+                            lapack_int ldb, double* t, lapack_int ldt );
+lapack_int LAPACKE_ctpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_float* a, lapack_int lda,
+                            lapack_complex_float* b, lapack_int ldb,
+                            lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_ztpqrt2( int matrix_order, lapack_int m, lapack_int n,
+                            lapack_complex_double* a, lapack_int lda,
+                            lapack_complex_double* b, lapack_int ldb,
+                            lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l, const float* v,
+                           lapack_int ldv, const float* t, lapack_int ldt,
+                           float* a, lapack_int lda, float* b, lapack_int ldb,
+                           lapack_int myldwork );
+lapack_int LAPACKE_dtprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l, const double* v,
+                           lapack_int ldv, const double* t, lapack_int ldt,
+                           double* a, lapack_int lda, double* b, lapack_int ldb,
+                           lapack_int myldwork );
+lapack_int LAPACKE_ctprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l,
+                           const lapack_complex_float* v, lapack_int ldv,
+                           const lapack_complex_float* t, lapack_int ldt,
+                           lapack_complex_float* a, lapack_int lda,
+                           lapack_complex_float* b, lapack_int ldb,
+                           lapack_int myldwork );
+lapack_int LAPACKE_ztprfb( int matrix_order, char side, char trans, char direct,
+                           char storev, lapack_int m, lapack_int n,
+                           lapack_int k, lapack_int l,
+                           const lapack_complex_double* v, lapack_int ldv,
+                           const lapack_complex_double* t, lapack_int ldt,
+                           lapack_complex_double* a, lapack_int lda,
+                           lapack_complex_double* b, lapack_int ldb,
+                           lapack_int myldwork );
+
+lapack_int LAPACKE_sgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const float* v, lapack_int ldv,
+                                 const float* t, lapack_int ldt, float* c,
+                                 lapack_int ldc, float* work );
+lapack_int LAPACKE_dgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const double* v, lapack_int ldv,
+                                 const double* t, lapack_int ldt, double* c,
+                                 lapack_int ldc, double* work );
+lapack_int LAPACKE_cgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const lapack_complex_float* v,
+                                 lapack_int ldv, const lapack_complex_float* t,
+                                 lapack_int ldt, lapack_complex_float* c,
+                                 lapack_int ldc, lapack_complex_float* work );
+lapack_int LAPACKE_zgemqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int nb, const lapack_complex_double* v,
+                                 lapack_int ldv, const lapack_complex_double* t,
+                                 lapack_int ldt, lapack_complex_double* c,
+                                 lapack_int ldc, lapack_complex_double* work );
+
+lapack_int LAPACKE_sgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, float* a, lapack_int lda,
+                                float* t, lapack_int ldt, float* work );
+lapack_int LAPACKE_dgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, double* a, lapack_int lda,
+                                double* t, lapack_int ldt, double* work );
+lapack_int LAPACKE_cgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, lapack_complex_float* a,
+                                lapack_int lda, lapack_complex_float* t,
+                                lapack_int ldt, lapack_complex_float* work );
+lapack_int LAPACKE_zgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int nb, lapack_complex_double* a,
+                                lapack_int lda, lapack_complex_double* t,
+                                lapack_int ldt, lapack_complex_double* work );
+
+lapack_int LAPACKE_sgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_dgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_cgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_sgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_dgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* t,
+                                 lapack_int ldt );
+lapack_int LAPACKE_cgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_zgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb, const float* v,
+                                 lapack_int ldv, const float* t, lapack_int ldt,
+                                 float* a, lapack_int lda, float* b,
+                                 lapack_int ldb, float* work );
+lapack_int LAPACKE_dtpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb, const double* v,
+                                 lapack_int ldv, const double* t,
+                                 lapack_int ldt, double* a, lapack_int lda,
+                                 double* b, lapack_int ldb, double* work );
+lapack_int LAPACKE_ctpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb,
+                                 const lapack_complex_float* v, lapack_int ldv,
+                                 const lapack_complex_float* t, lapack_int ldt,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* work );
+lapack_int LAPACKE_ztpmqrt_work( int matrix_order, char side, char trans,
+                                 lapack_int m, lapack_int n, lapack_int k,
+                                 lapack_int l, lapack_int nb,
+                                 const lapack_complex_double* v, lapack_int ldv,
+                                 const lapack_complex_double* t, lapack_int ldt,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* work );
+
+lapack_int LAPACKE_dtpqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int l, lapack_int nb, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                double* t, lapack_int ldt, double* work );
+lapack_int LAPACKE_ctpqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int l, lapack_int nb,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* t,
+                                lapack_complex_float* b, lapack_int ldb,
+                                lapack_int ldt, lapack_complex_float* work );
+lapack_int LAPACKE_ztpqrt_work( int matrix_order, lapack_int m, lapack_int n,
+                                lapack_int l, lapack_int nb,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* work );
+
+lapack_int LAPACKE_stpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 float* a, lapack_int lda, float* b,
+                                 lapack_int ldb, float* t, lapack_int ldt );
+lapack_int LAPACKE_dtpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 double* a, lapack_int lda, double* b,
+                                 lapack_int ldb, double* t, lapack_int ldt );
+lapack_int LAPACKE_ctpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_float* a, lapack_int lda,
+                                 lapack_complex_float* b, lapack_int ldb,
+                                 lapack_complex_float* t, lapack_int ldt );
+lapack_int LAPACKE_ztpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
+                                 lapack_complex_double* a, lapack_int lda,
+                                 lapack_complex_double* b, lapack_int ldb,
+                                 lapack_complex_double* t, lapack_int ldt );
+
+lapack_int LAPACKE_stprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const float* v, lapack_int ldv, const float* t,
+                                lapack_int ldt, float* a, lapack_int lda,
+                                float* b, lapack_int ldb, const float* mywork,
+                                lapack_int myldwork );
+lapack_int LAPACKE_dtprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const double* v, lapack_int ldv,
+                                const double* t, lapack_int ldt, double* a,
+                                lapack_int lda, double* b, lapack_int ldb,
+                                const double* mywork, lapack_int myldwork );
+lapack_int LAPACKE_ctprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const lapack_complex_float* v, lapack_int ldv,
+                                const lapack_complex_float* t, lapack_int ldt,
+                                lapack_complex_float* a, lapack_int lda,
+                                lapack_complex_float* b, lapack_int ldb,
+                                const float* mywork, lapack_int myldwork );
+lapack_int LAPACKE_ztprfb_work( int matrix_order, char side, char trans,
+                                char direct, char storev, lapack_int m,
+                                lapack_int n, lapack_int k, lapack_int l,
+                                const lapack_complex_double* v, lapack_int ldv,
+                                const lapack_complex_double* t, lapack_int ldt,
+                                lapack_complex_double* a, lapack_int lda,
+                                lapack_complex_double* b, lapack_int ldb,
+                                const double* mywork, lapack_int myldwork );
+//LAPACK 3.X.X
+lapack_int LAPACKE_csyr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_float alpha,
+                             const lapack_complex_float* x, lapack_int incx,
+                             lapack_complex_float* a, lapack_int lda );
+lapack_int LAPACKE_zsyr( int matrix_order, char uplo, lapack_int n,
+                             lapack_complex_double alpha,
+                             const lapack_complex_double* x, lapack_int incx,
+                             lapack_complex_double* a, lapack_int lda );
+
+lapack_int LAPACKE_csyr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_float alpha,
+                                  const lapack_complex_float* x,
+                                  lapack_int incx, lapack_complex_float* a,
+                                  lapack_int lda );
+lapack_int LAPACKE_zsyr_work( int matrix_order, char uplo, lapack_int n,
+                                  lapack_complex_double alpha,
+                                  const lapack_complex_double* x,
+                                  lapack_int incx, lapack_complex_double* a,
+                                  lapack_int lda );
+
+
+
+#define LAPACK_sgetrf LAPACK_GLOBAL(sgetrf,SGETRF)
+#define LAPACK_dgetrf LAPACK_GLOBAL(dgetrf,DGETRF)
+#define LAPACK_cgetrf LAPACK_GLOBAL(cgetrf,CGETRF)
+#define LAPACK_zgetrf LAPACK_GLOBAL(zgetrf,ZGETRF)
+#define LAPACK_sgbtrf LAPACK_GLOBAL(sgbtrf,SGBTRF)
+#define LAPACK_dgbtrf LAPACK_GLOBAL(dgbtrf,DGBTRF)
+#define LAPACK_cgbtrf LAPACK_GLOBAL(cgbtrf,CGBTRF)
+#define LAPACK_zgbtrf LAPACK_GLOBAL(zgbtrf,ZGBTRF)
+#define LAPACK_sgttrf LAPACK_GLOBAL(sgttrf,SGTTRF)
+#define LAPACK_dgttrf LAPACK_GLOBAL(dgttrf,DGTTRF)
+#define LAPACK_cgttrf LAPACK_GLOBAL(cgttrf,CGTTRF)
+#define LAPACK_zgttrf LAPACK_GLOBAL(zgttrf,ZGTTRF)
+#define LAPACK_spotrf LAPACK_GLOBAL(spotrf,SPOTRF)
+#define LAPACK_dpotrf LAPACK_GLOBAL(dpotrf,DPOTRF)
+#define LAPACK_cpotrf LAPACK_GLOBAL(cpotrf,CPOTRF)
+#define LAPACK_zpotrf LAPACK_GLOBAL(zpotrf,ZPOTRF)
+#define LAPACK_dpstrf LAPACK_GLOBAL(dpstrf,DPSTRF)
+#define LAPACK_spstrf LAPACK_GLOBAL(spstrf,SPSTRF)
+#define LAPACK_zpstrf LAPACK_GLOBAL(zpstrf,ZPSTRF)
+#define LAPACK_cpstrf LAPACK_GLOBAL(cpstrf,CPSTRF)
+#define LAPACK_dpftrf LAPACK_GLOBAL(dpftrf,DPFTRF)
+#define LAPACK_spftrf LAPACK_GLOBAL(spftrf,SPFTRF)
+#define LAPACK_zpftrf LAPACK_GLOBAL(zpftrf,ZPFTRF)
+#define LAPACK_cpftrf LAPACK_GLOBAL(cpftrf,CPFTRF)
+#define LAPACK_spptrf LAPACK_GLOBAL(spptrf,SPPTRF)
+#define LAPACK_dpptrf LAPACK_GLOBAL(dpptrf,DPPTRF)
+#define LAPACK_cpptrf LAPACK_GLOBAL(cpptrf,CPPTRF)
+#define LAPACK_zpptrf LAPACK_GLOBAL(zpptrf,ZPPTRF)
+#define LAPACK_spbtrf LAPACK_GLOBAL(spbtrf,SPBTRF)
+#define LAPACK_dpbtrf LAPACK_GLOBAL(dpbtrf,DPBTRF)
+#define LAPACK_cpbtrf LAPACK_GLOBAL(cpbtrf,CPBTRF)
+#define LAPACK_zpbtrf LAPACK_GLOBAL(zpbtrf,ZPBTRF)
+#define LAPACK_spttrf LAPACK_GLOBAL(spttrf,SPTTRF)
+#define LAPACK_dpttrf LAPACK_GLOBAL(dpttrf,DPTTRF)
+#define LAPACK_cpttrf LAPACK_GLOBAL(cpttrf,CPTTRF)
+#define LAPACK_zpttrf LAPACK_GLOBAL(zpttrf,ZPTTRF)
+#define LAPACK_ssytrf LAPACK_GLOBAL(ssytrf,SSYTRF)
+#define LAPACK_dsytrf LAPACK_GLOBAL(dsytrf,DSYTRF)
+#define LAPACK_csytrf LAPACK_GLOBAL(csytrf,CSYTRF)
+#define LAPACK_zsytrf LAPACK_GLOBAL(zsytrf,ZSYTRF)
+#define LAPACK_chetrf LAPACK_GLOBAL(chetrf,CHETRF)
+#define LAPACK_zhetrf LAPACK_GLOBAL(zhetrf,ZHETRF)
+#define LAPACK_ssptrf LAPACK_GLOBAL(ssptrf,SSPTRF)
+#define LAPACK_dsptrf LAPACK_GLOBAL(dsptrf,DSPTRF)
+#define LAPACK_csptrf LAPACK_GLOBAL(csptrf,CSPTRF)
+#define LAPACK_zsptrf LAPACK_GLOBAL(zsptrf,ZSPTRF)
+#define LAPACK_chptrf LAPACK_GLOBAL(chptrf,CHPTRF)
+#define LAPACK_zhptrf LAPACK_GLOBAL(zhptrf,ZHPTRF)
+#define LAPACK_sgetrs LAPACK_GLOBAL(sgetrs,SGETRS)
+#define LAPACK_dgetrs LAPACK_GLOBAL(dgetrs,DGETRS)
+#define LAPACK_cgetrs LAPACK_GLOBAL(cgetrs,CGETRS)
+#define LAPACK_zgetrs LAPACK_GLOBAL(zgetrs,ZGETRS)
+#define LAPACK_sgbtrs LAPACK_GLOBAL(sgbtrs,SGBTRS)
+#define LAPACK_dgbtrs LAPACK_GLOBAL(dgbtrs,DGBTRS)
+#define LAPACK_cgbtrs LAPACK_GLOBAL(cgbtrs,CGBTRS)
+#define LAPACK_zgbtrs LAPACK_GLOBAL(zgbtrs,ZGBTRS)
+#define LAPACK_sgttrs LAPACK_GLOBAL(sgttrs,SGTTRS)
+#define LAPACK_dgttrs LAPACK_GLOBAL(dgttrs,DGTTRS)
+#define LAPACK_cgttrs LAPACK_GLOBAL(cgttrs,CGTTRS)
+#define LAPACK_zgttrs LAPACK_GLOBAL(zgttrs,ZGTTRS)
+#define LAPACK_spotrs LAPACK_GLOBAL(spotrs,SPOTRS)
+#define LAPACK_dpotrs LAPACK_GLOBAL(dpotrs,DPOTRS)
+#define LAPACK_cpotrs LAPACK_GLOBAL(cpotrs,CPOTRS)
+#define LAPACK_zpotrs LAPACK_GLOBAL(zpotrs,ZPOTRS)
+#define LAPACK_dpftrs LAPACK_GLOBAL(dpftrs,DPFTRS)
+#define LAPACK_spftrs LAPACK_GLOBAL(spftrs,SPFTRS)
+#define LAPACK_zpftrs LAPACK_GLOBAL(zpftrs,ZPFTRS)
+#define LAPACK_cpftrs LAPACK_GLOBAL(cpftrs,CPFTRS)
+#define LAPACK_spptrs LAPACK_GLOBAL(spptrs,SPPTRS)
+#define LAPACK_dpptrs LAPACK_GLOBAL(dpptrs,DPPTRS)
+#define LAPACK_cpptrs LAPACK_GLOBAL(cpptrs,CPPTRS)
+#define LAPACK_zpptrs LAPACK_GLOBAL(zpptrs,ZPPTRS)
+#define LAPACK_spbtrs LAPACK_GLOBAL(spbtrs,SPBTRS)
+#define LAPACK_dpbtrs LAPACK_GLOBAL(dpbtrs,DPBTRS)
+#define LAPACK_cpbtrs LAPACK_GLOBAL(cpbtrs,CPBTRS)
+#define LAPACK_zpbtrs LAPACK_GLOBAL(zpbtrs,ZPBTRS)
+#define LAPACK_spttrs LAPACK_GLOBAL(spttrs,SPTTRS)
+#define LAPACK_dpttrs LAPACK_GLOBAL(dpttrs,DPTTRS)
+#define LAPACK_cpttrs LAPACK_GLOBAL(cpttrs,CPTTRS)
+#define LAPACK_zpttrs LAPACK_GLOBAL(zpttrs,ZPTTRS)
+#define LAPACK_ssytrs LAPACK_GLOBAL(ssytrs,SSYTRS)
+#define LAPACK_dsytrs LAPACK_GLOBAL(dsytrs,DSYTRS)
+#define LAPACK_csytrs LAPACK_GLOBAL(csytrs,CSYTRS)
+#define LAPACK_zsytrs LAPACK_GLOBAL(zsytrs,ZSYTRS)
+#define LAPACK_chetrs LAPACK_GLOBAL(chetrs,CHETRS)
+#define LAPACK_zhetrs LAPACK_GLOBAL(zhetrs,ZHETRS)
+#define LAPACK_ssptrs LAPACK_GLOBAL(ssptrs,SSPTRS)
+#define LAPACK_dsptrs LAPACK_GLOBAL(dsptrs,DSPTRS)
+#define LAPACK_csptrs LAPACK_GLOBAL(csptrs,CSPTRS)
+#define LAPACK_zsptrs LAPACK_GLOBAL(zsptrs,ZSPTRS)
+#define LAPACK_chptrs LAPACK_GLOBAL(chptrs,CHPTRS)
+#define LAPACK_zhptrs LAPACK_GLOBAL(zhptrs,ZHPTRS)
+#define LAPACK_strtrs LAPACK_GLOBAL(strtrs,STRTRS)
+#define LAPACK_dtrtrs LAPACK_GLOBAL(dtrtrs,DTRTRS)
+#define LAPACK_ctrtrs LAPACK_GLOBAL(ctrtrs,CTRTRS)
+#define LAPACK_ztrtrs LAPACK_GLOBAL(ztrtrs,ZTRTRS)
+#define LAPACK_stptrs LAPACK_GLOBAL(stptrs,STPTRS)
+#define LAPACK_dtptrs LAPACK_GLOBAL(dtptrs,DTPTRS)
+#define LAPACK_ctptrs LAPACK_GLOBAL(ctptrs,CTPTRS)
+#define LAPACK_ztptrs LAPACK_GLOBAL(ztptrs,ZTPTRS)
+#define LAPACK_stbtrs LAPACK_GLOBAL(stbtrs,STBTRS)
+#define LAPACK_dtbtrs LAPACK_GLOBAL(dtbtrs,DTBTRS)
+#define LAPACK_ctbtrs LAPACK_GLOBAL(ctbtrs,CTBTRS)
+#define LAPACK_ztbtrs LAPACK_GLOBAL(ztbtrs,ZTBTRS)
+#define LAPACK_sgecon LAPACK_GLOBAL(sgecon,SGECON)
+#define LAPACK_dgecon LAPACK_GLOBAL(dgecon,DGECON)
+#define LAPACK_cgecon LAPACK_GLOBAL(cgecon,CGECON)
+#define LAPACK_zgecon LAPACK_GLOBAL(zgecon,ZGECON)
+#define LAPACK_sgbcon LAPACK_GLOBAL(sgbcon,SGBCON)
+#define LAPACK_dgbcon LAPACK_GLOBAL(dgbcon,DGBCON)
+#define LAPACK_cgbcon LAPACK_GLOBAL(cgbcon,CGBCON)
+#define LAPACK_zgbcon LAPACK_GLOBAL(zgbcon,ZGBCON)
+#define LAPACK_sgtcon LAPACK_GLOBAL(sgtcon,SGTCON)
+#define LAPACK_dgtcon LAPACK_GLOBAL(dgtcon,DGTCON)
+#define LAPACK_cgtcon LAPACK_GLOBAL(cgtcon,CGTCON)
+#define LAPACK_zgtcon LAPACK_GLOBAL(zgtcon,ZGTCON)
+#define LAPACK_spocon LAPACK_GLOBAL(spocon,SPOCON)
+#define LAPACK_dpocon LAPACK_GLOBAL(dpocon,DPOCON)
+#define LAPACK_cpocon LAPACK_GLOBAL(cpocon,CPOCON)
+#define LAPACK_zpocon LAPACK_GLOBAL(zpocon,ZPOCON)
+#define LAPACK_sppcon LAPACK_GLOBAL(sppcon,SPPCON)
+#define LAPACK_dppcon LAPACK_GLOBAL(dppcon,DPPCON)
+#define LAPACK_cppcon LAPACK_GLOBAL(cppcon,CPPCON)
+#define LAPACK_zppcon LAPACK_GLOBAL(zppcon,ZPPCON)
+#define LAPACK_spbcon LAPACK_GLOBAL(spbcon,SPBCON)
+#define LAPACK_dpbcon LAPACK_GLOBAL(dpbcon,DPBCON)
+#define LAPACK_cpbcon LAPACK_GLOBAL(cpbcon,CPBCON)
+#define LAPACK_zpbcon LAPACK_GLOBAL(zpbcon,ZPBCON)
+#define LAPACK_sptcon LAPACK_GLOBAL(sptcon,SPTCON)
+#define LAPACK_dptcon LAPACK_GLOBAL(dptcon,DPTCON)
+#define LAPACK_cptcon LAPACK_GLOBAL(cptcon,CPTCON)
+#define LAPACK_zptcon LAPACK_GLOBAL(zptcon,ZPTCON)
+#define LAPACK_ssycon LAPACK_GLOBAL(ssycon,SSYCON)
+#define LAPACK_dsycon LAPACK_GLOBAL(dsycon,DSYCON)
+#define LAPACK_csycon LAPACK_GLOBAL(csycon,CSYCON)
+#define LAPACK_zsycon LAPACK_GLOBAL(zsycon,ZSYCON)
+#define LAPACK_checon LAPACK_GLOBAL(checon,CHECON)
+#define LAPACK_zhecon LAPACK_GLOBAL(zhecon,ZHECON)
+#define LAPACK_sspcon LAPACK_GLOBAL(sspcon,SSPCON)
+#define LAPACK_dspcon LAPACK_GLOBAL(dspcon,DSPCON)
+#define LAPACK_cspcon LAPACK_GLOBAL(cspcon,CSPCON)
+#define LAPACK_zspcon LAPACK_GLOBAL(zspcon,ZSPCON)
+#define LAPACK_chpcon LAPACK_GLOBAL(chpcon,CHPCON)
+#define LAPACK_zhpcon LAPACK_GLOBAL(zhpcon,ZHPCON)
+#define LAPACK_strcon LAPACK_GLOBAL(strcon,STRCON)
+#define LAPACK_dtrcon LAPACK_GLOBAL(dtrcon,DTRCON)
+#define LAPACK_ctrcon LAPACK_GLOBAL(ctrcon,CTRCON)
+#define LAPACK_ztrcon LAPACK_GLOBAL(ztrcon,ZTRCON)
+#define LAPACK_stpcon LAPACK_GLOBAL(stpcon,STPCON)
+#define LAPACK_dtpcon LAPACK_GLOBAL(dtpcon,DTPCON)
+#define LAPACK_ctpcon LAPACK_GLOBAL(ctpcon,CTPCON)
+#define LAPACK_ztpcon LAPACK_GLOBAL(ztpcon,ZTPCON)
+#define LAPACK_stbcon LAPACK_GLOBAL(stbcon,STBCON)
+#define LAPACK_dtbcon LAPACK_GLOBAL(dtbcon,DTBCON)
+#define LAPACK_ctbcon LAPACK_GLOBAL(ctbcon,CTBCON)
+#define LAPACK_ztbcon LAPACK_GLOBAL(ztbcon,ZTBCON)
+#define LAPACK_sgerfs LAPACK_GLOBAL(sgerfs,SGERFS)
+#define LAPACK_dgerfs LAPACK_GLOBAL(dgerfs,DGERFS)
+#define LAPACK_cgerfs LAPACK_GLOBAL(cgerfs,CGERFS)
+#define LAPACK_zgerfs LAPACK_GLOBAL(zgerfs,ZGERFS)
+#define LAPACK_dgerfsx LAPACK_GLOBAL(dgerfsx,DGERFSX)
+#define LAPACK_sgerfsx LAPACK_GLOBAL(sgerfsx,SGERFSX)
+#define LAPACK_zgerfsx LAPACK_GLOBAL(zgerfsx,ZGERFSX)
+#define LAPACK_cgerfsx LAPACK_GLOBAL(cgerfsx,CGERFSX)
+#define LAPACK_sgbrfs LAPACK_GLOBAL(sgbrfs,SGBRFS)
+#define LAPACK_dgbrfs LAPACK_GLOBAL(dgbrfs,DGBRFS)
+#define LAPACK_cgbrfs LAPACK_GLOBAL(cgbrfs,CGBRFS)
+#define LAPACK_zgbrfs LAPACK_GLOBAL(zgbrfs,ZGBRFS)
+#define LAPACK_dgbrfsx LAPACK_GLOBAL(dgbrfsx,DGBRFSX)
+#define LAPACK_sgbrfsx LAPACK_GLOBAL(sgbrfsx,SGBRFSX)
+#define LAPACK_zgbrfsx LAPACK_GLOBAL(zgbrfsx,ZGBRFSX)
+#define LAPACK_cgbrfsx LAPACK_GLOBAL(cgbrfsx,CGBRFSX)
+#define LAPACK_sgtrfs LAPACK_GLOBAL(sgtrfs,SGTRFS)
+#define LAPACK_dgtrfs LAPACK_GLOBAL(dgtrfs,DGTRFS)
+#define LAPACK_cgtrfs LAPACK_GLOBAL(cgtrfs,CGTRFS)
+#define LAPACK_zgtrfs LAPACK_GLOBAL(zgtrfs,ZGTRFS)
+#define LAPACK_sporfs LAPACK_GLOBAL(sporfs,SPORFS)
+#define LAPACK_dporfs LAPACK_GLOBAL(dporfs,DPORFS)
+#define LAPACK_cporfs LAPACK_GLOBAL(cporfs,CPORFS)
+#define LAPACK_zporfs LAPACK_GLOBAL(zporfs,ZPORFS)
+#define LAPACK_dporfsx LAPACK_GLOBAL(dporfsx,DPORFSX)
+#define LAPACK_sporfsx LAPACK_GLOBAL(sporfsx,SPORFSX)
+#define LAPACK_zporfsx LAPACK_GLOBAL(zporfsx,ZPORFSX)
+#define LAPACK_cporfsx LAPACK_GLOBAL(cporfsx,CPORFSX)
+#define LAPACK_spprfs LAPACK_GLOBAL(spprfs,SPPRFS)
+#define LAPACK_dpprfs LAPACK_GLOBAL(dpprfs,DPPRFS)
+#define LAPACK_cpprfs LAPACK_GLOBAL(cpprfs,CPPRFS)
+#define LAPACK_zpprfs LAPACK_GLOBAL(zpprfs,ZPPRFS)
+#define LAPACK_spbrfs LAPACK_GLOBAL(spbrfs,SPBRFS)
+#define LAPACK_dpbrfs LAPACK_GLOBAL(dpbrfs,DPBRFS)
+#define LAPACK_cpbrfs LAPACK_GLOBAL(cpbrfs,CPBRFS)
+#define LAPACK_zpbrfs LAPACK_GLOBAL(zpbrfs,ZPBRFS)
+#define LAPACK_sptrfs LAPACK_GLOBAL(sptrfs,SPTRFS)
+#define LAPACK_dptrfs LAPACK_GLOBAL(dptrfs,DPTRFS)
+#define LAPACK_cptrfs LAPACK_GLOBAL(cptrfs,CPTRFS)
+#define LAPACK_zptrfs LAPACK_GLOBAL(zptrfs,ZPTRFS)
+#define LAPACK_ssyrfs LAPACK_GLOBAL(ssyrfs,SSYRFS)
+#define LAPACK_dsyrfs LAPACK_GLOBAL(dsyrfs,DSYRFS)
+#define LAPACK_csyrfs LAPACK_GLOBAL(csyrfs,CSYRFS)
+#define LAPACK_zsyrfs LAPACK_GLOBAL(zsyrfs,ZSYRFS)
+#define LAPACK_dsyrfsx LAPACK_GLOBAL(dsyrfsx,DSYRFSX)
+#define LAPACK_ssyrfsx LAPACK_GLOBAL(ssyrfsx,SSYRFSX)
+#define LAPACK_zsyrfsx LAPACK_GLOBAL(zsyrfsx,ZSYRFSX)
+#define LAPACK_csyrfsx LAPACK_GLOBAL(csyrfsx,CSYRFSX)
+#define LAPACK_cherfs LAPACK_GLOBAL(cherfs,CHERFS)
+#define LAPACK_zherfs LAPACK_GLOBAL(zherfs,ZHERFS)
+#define LAPACK_zherfsx LAPACK_GLOBAL(zherfsx,ZHERFSX)
+#define LAPACK_cherfsx LAPACK_GLOBAL(cherfsx,CHERFSX)
+#define LAPACK_ssprfs LAPACK_GLOBAL(ssprfs,SSPRFS)
+#define LAPACK_dsprfs LAPACK_GLOBAL(dsprfs,DSPRFS)
+#define LAPACK_csprfs LAPACK_GLOBAL(csprfs,CSPRFS)
+#define LAPACK_zsprfs LAPACK_GLOBAL(zsprfs,ZSPRFS)
+#define LAPACK_chprfs LAPACK_GLOBAL(chprfs,CHPRFS)
+#define LAPACK_zhprfs LAPACK_GLOBAL(zhprfs,ZHPRFS)
+#define LAPACK_strrfs LAPACK_GLOBAL(strrfs,STRRFS)
+#define LAPACK_dtrrfs LAPACK_GLOBAL(dtrrfs,DTRRFS)
+#define LAPACK_ctrrfs LAPACK_GLOBAL(ctrrfs,CTRRFS)
+#define LAPACK_ztrrfs LAPACK_GLOBAL(ztrrfs,ZTRRFS)
+#define LAPACK_stprfs LAPACK_GLOBAL(stprfs,STPRFS)
+#define LAPACK_dtprfs LAPACK_GLOBAL(dtprfs,DTPRFS)
+#define LAPACK_ctprfs LAPACK_GLOBAL(ctprfs,CTPRFS)
+#define LAPACK_ztprfs LAPACK_GLOBAL(ztprfs,ZTPRFS)
+#define LAPACK_stbrfs LAPACK_GLOBAL(stbrfs,STBRFS)
+#define LAPACK_dtbrfs LAPACK_GLOBAL(dtbrfs,DTBRFS)
+#define LAPACK_ctbrfs LAPACK_GLOBAL(ctbrfs,CTBRFS)
+#define LAPACK_ztbrfs LAPACK_GLOBAL(ztbrfs,ZTBRFS)
+#define LAPACK_sgetri LAPACK_GLOBAL(sgetri,SGETRI)
+#define LAPACK_dgetri LAPACK_GLOBAL(dgetri,DGETRI)
+#define LAPACK_cgetri LAPACK_GLOBAL(cgetri,CGETRI)
+#define LAPACK_zgetri LAPACK_GLOBAL(zgetri,ZGETRI)
+#define LAPACK_spotri LAPACK_GLOBAL(spotri,SPOTRI)
+#define LAPACK_dpotri LAPACK_GLOBAL(dpotri,DPOTRI)
+#define LAPACK_cpotri LAPACK_GLOBAL(cpotri,CPOTRI)
+#define LAPACK_zpotri LAPACK_GLOBAL(zpotri,ZPOTRI)
+#define LAPACK_dpftri LAPACK_GLOBAL(dpftri,DPFTRI)
+#define LAPACK_spftri LAPACK_GLOBAL(spftri,SPFTRI)
+#define LAPACK_zpftri LAPACK_GLOBAL(zpftri,ZPFTRI)
+#define LAPACK_cpftri LAPACK_GLOBAL(cpftri,CPFTRI)
+#define LAPACK_spptri LAPACK_GLOBAL(spptri,SPPTRI)
+#define LAPACK_dpptri LAPACK_GLOBAL(dpptri,DPPTRI)
+#define LAPACK_cpptri LAPACK_GLOBAL(cpptri,CPPTRI)
+#define LAPACK_zpptri LAPACK_GLOBAL(zpptri,ZPPTRI)
+#define LAPACK_ssytri LAPACK_GLOBAL(ssytri,SSYTRI)
+#define LAPACK_dsytri LAPACK_GLOBAL(dsytri,DSYTRI)
+#define LAPACK_csytri LAPACK_GLOBAL(csytri,CSYTRI)
+#define LAPACK_zsytri LAPACK_GLOBAL(zsytri,ZSYTRI)
+#define LAPACK_chetri LAPACK_GLOBAL(chetri,CHETRI)
+#define LAPACK_zhetri LAPACK_GLOBAL(zhetri,ZHETRI)
+#define LAPACK_ssptri LAPACK_GLOBAL(ssptri,SSPTRI)
+#define LAPACK_dsptri LAPACK_GLOBAL(dsptri,DSPTRI)
+#define LAPACK_csptri LAPACK_GLOBAL(csptri,CSPTRI)
+#define LAPACK_zsptri LAPACK_GLOBAL(zsptri,ZSPTRI)
+#define LAPACK_chptri LAPACK_GLOBAL(chptri,CHPTRI)
+#define LAPACK_zhptri LAPACK_GLOBAL(zhptri,ZHPTRI)
+#define LAPACK_strtri LAPACK_GLOBAL(strtri,STRTRI)
+#define LAPACK_dtrtri LAPACK_GLOBAL(dtrtri,DTRTRI)
+#define LAPACK_ctrtri LAPACK_GLOBAL(ctrtri,CTRTRI)
+#define LAPACK_ztrtri LAPACK_GLOBAL(ztrtri,ZTRTRI)
+#define LAPACK_dtftri LAPACK_GLOBAL(dtftri,DTFTRI)
+#define LAPACK_stftri LAPACK_GLOBAL(stftri,STFTRI)
+#define LAPACK_ztftri LAPACK_GLOBAL(ztftri,ZTFTRI)
+#define LAPACK_ctftri LAPACK_GLOBAL(ctftri,CTFTRI)
+#define LAPACK_stptri LAPACK_GLOBAL(stptri,STPTRI)
+#define LAPACK_dtptri LAPACK_GLOBAL(dtptri,DTPTRI)
+#define LAPACK_ctptri LAPACK_GLOBAL(ctptri,CTPTRI)
+#define LAPACK_ztptri LAPACK_GLOBAL(ztptri,ZTPTRI)
+#define LAPACK_sgeequ LAPACK_GLOBAL(sgeequ,SGEEQU)
+#define LAPACK_dgeequ LAPACK_GLOBAL(dgeequ,DGEEQU)
+#define LAPACK_cgeequ LAPACK_GLOBAL(cgeequ,CGEEQU)
+#define LAPACK_zgeequ LAPACK_GLOBAL(zgeequ,ZGEEQU)
+#define LAPACK_dgeequb LAPACK_GLOBAL(dgeequb,DGEEQUB)
+#define LAPACK_sgeequb LAPACK_GLOBAL(sgeequb,SGEEQUB)
+#define LAPACK_zgeequb LAPACK_GLOBAL(zgeequb,ZGEEQUB)
+#define LAPACK_cgeequb LAPACK_GLOBAL(cgeequb,CGEEQUB)
+#define LAPACK_sgbequ LAPACK_GLOBAL(sgbequ,SGBEQU)
+#define LAPACK_dgbequ LAPACK_GLOBAL(dgbequ,DGBEQU)
+#define LAPACK_cgbequ LAPACK_GLOBAL(cgbequ,CGBEQU)
+#define LAPACK_zgbequ LAPACK_GLOBAL(zgbequ,ZGBEQU)
+#define LAPACK_dgbequb LAPACK_GLOBAL(dgbequb,DGBEQUB)
+#define LAPACK_sgbequb LAPACK_GLOBAL(sgbequb,SGBEQUB)
+#define LAPACK_zgbequb LAPACK_GLOBAL(zgbequb,ZGBEQUB)
+#define LAPACK_cgbequb LAPACK_GLOBAL(cgbequb,CGBEQUB)
+#define LAPACK_spoequ LAPACK_GLOBAL(spoequ,SPOEQU)
+#define LAPACK_dpoequ LAPACK_GLOBAL(dpoequ,DPOEQU)
+#define LAPACK_cpoequ LAPACK_GLOBAL(cpoequ,CPOEQU)
+#define LAPACK_zpoequ LAPACK_GLOBAL(zpoequ,ZPOEQU)
+#define LAPACK_dpoequb LAPACK_GLOBAL(dpoequb,DPOEQUB)
+#define LAPACK_spoequb LAPACK_GLOBAL(spoequb,SPOEQUB)
+#define LAPACK_zpoequb LAPACK_GLOBAL(zpoequb,ZPOEQUB)
+#define LAPACK_cpoequb LAPACK_GLOBAL(cpoequb,CPOEQUB)
+#define LAPACK_sppequ LAPACK_GLOBAL(sppequ,SPPEQU)
+#define LAPACK_dppequ LAPACK_GLOBAL(dppequ,DPPEQU)
+#define LAPACK_cppequ LAPACK_GLOBAL(cppequ,CPPEQU)
+#define LAPACK_zppequ LAPACK_GLOBAL(zppequ,ZPPEQU)
+#define LAPACK_spbequ LAPACK_GLOBAL(spbequ,SPBEQU)
+#define LAPACK_dpbequ LAPACK_GLOBAL(dpbequ,DPBEQU)
+#define LAPACK_cpbequ LAPACK_GLOBAL(cpbequ,CPBEQU)
+#define LAPACK_zpbequ LAPACK_GLOBAL(zpbequ,ZPBEQU)
+#define LAPACK_dsyequb LAPACK_GLOBAL(dsyequb,DSYEQUB)
+#define LAPACK_ssyequb LAPACK_GLOBAL(ssyequb,SSYEQUB)
+#define LAPACK_zsyequb LAPACK_GLOBAL(zsyequb,ZSYEQUB)
+#define LAPACK_csyequb LAPACK_GLOBAL(csyequb,CSYEQUB)
+#define LAPACK_zheequb LAPACK_GLOBAL(zheequb,ZHEEQUB)
+#define LAPACK_cheequb LAPACK_GLOBAL(cheequb,CHEEQUB)
+#define LAPACK_sgesv LAPACK_GLOBAL(sgesv,SGESV)
+#define LAPACK_dgesv LAPACK_GLOBAL(dgesv,DGESV)
+#define LAPACK_cgesv LAPACK_GLOBAL(cgesv,CGESV)
+#define LAPACK_zgesv LAPACK_GLOBAL(zgesv,ZGESV)
+#define LAPACK_dsgesv LAPACK_GLOBAL(dsgesv,DSGESV)
+#define LAPACK_zcgesv LAPACK_GLOBAL(zcgesv,ZCGESV)
+#define LAPACK_sgesvx LAPACK_GLOBAL(sgesvx,SGESVX)
+#define LAPACK_dgesvx LAPACK_GLOBAL(dgesvx,DGESVX)
+#define LAPACK_cgesvx LAPACK_GLOBAL(cgesvx,CGESVX)
+#define LAPACK_zgesvx LAPACK_GLOBAL(zgesvx,ZGESVX)
+#define LAPACK_dgesvxx LAPACK_GLOBAL(dgesvxx,DGESVXX)
+#define LAPACK_sgesvxx LAPACK_GLOBAL(sgesvxx,SGESVXX)
+#define LAPACK_zgesvxx LAPACK_GLOBAL(zgesvxx,ZGESVXX)
+#define LAPACK_cgesvxx LAPACK_GLOBAL(cgesvxx,CGESVXX)
+#define LAPACK_sgbsv LAPACK_GLOBAL(sgbsv,SGBSV)
+#define LAPACK_dgbsv LAPACK_GLOBAL(dgbsv,DGBSV)
+#define LAPACK_cgbsv LAPACK_GLOBAL(cgbsv,CGBSV)
+#define LAPACK_zgbsv LAPACK_GLOBAL(zgbsv,ZGBSV)
+#define LAPACK_sgbsvx LAPACK_GLOBAL(sgbsvx,SGBSVX)
+#define LAPACK_dgbsvx LAPACK_GLOBAL(dgbsvx,DGBSVX)
+#define LAPACK_cgbsvx LAPACK_GLOBAL(cgbsvx,CGBSVX)
+#define LAPACK_zgbsvx LAPACK_GLOBAL(zgbsvx,ZGBSVX)
+#define LAPACK_dgbsvxx LAPACK_GLOBAL(dgbsvxx,DGBSVXX)
+#define LAPACK_sgbsvxx LAPACK_GLOBAL(sgbsvxx,SGBSVXX)
+#define LAPACK_zgbsvxx LAPACK_GLOBAL(zgbsvxx,ZGBSVXX)
+#define LAPACK_cgbsvxx LAPACK_GLOBAL(cgbsvxx,CGBSVXX)
+#define LAPACK_sgtsv LAPACK_GLOBAL(sgtsv,SGTSV)
+#define LAPACK_dgtsv LAPACK_GLOBAL(dgtsv,DGTSV)
+#define LAPACK_cgtsv LAPACK_GLOBAL(cgtsv,CGTSV)
+#define LAPACK_zgtsv LAPACK_GLOBAL(zgtsv,ZGTSV)
+#define LAPACK_sgtsvx LAPACK_GLOBAL(sgtsvx,SGTSVX)
+#define LAPACK_dgtsvx LAPACK_GLOBAL(dgtsvx,DGTSVX)
+#define LAPACK_cgtsvx LAPACK_GLOBAL(cgtsvx,CGTSVX)
+#define LAPACK_zgtsvx LAPACK_GLOBAL(zgtsvx,ZGTSVX)
+#define LAPACK_sposv LAPACK_GLOBAL(sposv,SPOSV)
+#define LAPACK_dposv LAPACK_GLOBAL(dposv,DPOSV)
+#define LAPACK_cposv LAPACK_GLOBAL(cposv,CPOSV)
+#define LAPACK_zposv LAPACK_GLOBAL(zposv,ZPOSV)
+#define LAPACK_dsposv LAPACK_GLOBAL(dsposv,DSPOSV)
+#define LAPACK_zcposv LAPACK_GLOBAL(zcposv,ZCPOSV)
+#define LAPACK_sposvx LAPACK_GLOBAL(sposvx,SPOSVX)
+#define LAPACK_dposvx LAPACK_GLOBAL(dposvx,DPOSVX)
+#define LAPACK_cposvx LAPACK_GLOBAL(cposvx,CPOSVX)
+#define LAPACK_zposvx LAPACK_GLOBAL(zposvx,ZPOSVX)
+#define LAPACK_dposvxx LAPACK_GLOBAL(dposvxx,DPOSVXX)
+#define LAPACK_sposvxx LAPACK_GLOBAL(sposvxx,SPOSVXX)
+#define LAPACK_zposvxx LAPACK_GLOBAL(zposvxx,ZPOSVXX)
+#define LAPACK_cposvxx LAPACK_GLOBAL(cposvxx,CPOSVXX)
+#define LAPACK_sppsv LAPACK_GLOBAL(sppsv,SPPSV)
+#define LAPACK_dppsv LAPACK_GLOBAL(dppsv,DPPSV)
+#define LAPACK_cppsv LAPACK_GLOBAL(cppsv,CPPSV)
+#define LAPACK_zppsv LAPACK_GLOBAL(zppsv,ZPPSV)
+#define LAPACK_sppsvx LAPACK_GLOBAL(sppsvx,SPPSVX)
+#define LAPACK_dppsvx LAPACK_GLOBAL(dppsvx,DPPSVX)
+#define LAPACK_cppsvx LAPACK_GLOBAL(cppsvx,CPPSVX)
+#define LAPACK_zppsvx LAPACK_GLOBAL(zppsvx,ZPPSVX)
+#define LAPACK_spbsv LAPACK_GLOBAL(spbsv,SPBSV)
+#define LAPACK_dpbsv LAPACK_GLOBAL(dpbsv,DPBSV)
+#define LAPACK_cpbsv LAPACK_GLOBAL(cpbsv,CPBSV)
+#define LAPACK_zpbsv LAPACK_GLOBAL(zpbsv,ZPBSV)
+#define LAPACK_spbsvx LAPACK_GLOBAL(spbsvx,SPBSVX)
+#define LAPACK_dpbsvx LAPACK_GLOBAL(dpbsvx,DPBSVX)
+#define LAPACK_cpbsvx LAPACK_GLOBAL(cpbsvx,CPBSVX)
+#define LAPACK_zpbsvx LAPACK_GLOBAL(zpbsvx,ZPBSVX)
+#define LAPACK_sptsv LAPACK_GLOBAL(sptsv,SPTSV)
+#define LAPACK_dptsv LAPACK_GLOBAL(dptsv,DPTSV)
+#define LAPACK_cptsv LAPACK_GLOBAL(cptsv,CPTSV)
+#define LAPACK_zptsv LAPACK_GLOBAL(zptsv,ZPTSV)
+#define LAPACK_sptsvx LAPACK_GLOBAL(sptsvx,SPTSVX)
+#define LAPACK_dptsvx LAPACK_GLOBAL(dptsvx,DPTSVX)
+#define LAPACK_cptsvx LAPACK_GLOBAL(cptsvx,CPTSVX)
+#define LAPACK_zptsvx LAPACK_GLOBAL(zptsvx,ZPTSVX)
+#define LAPACK_ssysv LAPACK_GLOBAL(ssysv,SSYSV)
+#define LAPACK_dsysv LAPACK_GLOBAL(dsysv,DSYSV)
+#define LAPACK_csysv LAPACK_GLOBAL(csysv,CSYSV)
+#define LAPACK_zsysv LAPACK_GLOBAL(zsysv,ZSYSV)
+#define LAPACK_ssysvx LAPACK_GLOBAL(ssysvx,SSYSVX)
+#define LAPACK_dsysvx LAPACK_GLOBAL(dsysvx,DSYSVX)
+#define LAPACK_csysvx LAPACK_GLOBAL(csysvx,CSYSVX)
+#define LAPACK_zsysvx LAPACK_GLOBAL(zsysvx,ZSYSVX)
+#define LAPACK_dsysvxx LAPACK_GLOBAL(dsysvxx,DSYSVXX)
+#define LAPACK_ssysvxx LAPACK_GLOBAL(ssysvxx,SSYSVXX)
+#define LAPACK_zsysvxx LAPACK_GLOBAL(zsysvxx,ZSYSVXX)
+#define LAPACK_csysvxx LAPACK_GLOBAL(csysvxx,CSYSVXX)
+#define LAPACK_chesv LAPACK_GLOBAL(chesv,CHESV)
+#define LAPACK_zhesv LAPACK_GLOBAL(zhesv,ZHESV)
+#define LAPACK_chesvx LAPACK_GLOBAL(chesvx,CHESVX)
+#define LAPACK_zhesvx LAPACK_GLOBAL(zhesvx,ZHESVX)
+#define LAPACK_zhesvxx LAPACK_GLOBAL(zhesvxx,ZHESVXX)
+#define LAPACK_chesvxx LAPACK_GLOBAL(chesvxx,CHESVXX)
+#define LAPACK_sspsv LAPACK_GLOBAL(sspsv,SSPSV)
+#define LAPACK_dspsv LAPACK_GLOBAL(dspsv,DSPSV)
+#define LAPACK_cspsv LAPACK_GLOBAL(cspsv,CSPSV)
+#define LAPACK_zspsv LAPACK_GLOBAL(zspsv,ZSPSV)
+#define LAPACK_sspsvx LAPACK_GLOBAL(sspsvx,SSPSVX)
+#define LAPACK_dspsvx LAPACK_GLOBAL(dspsvx,DSPSVX)
+#define LAPACK_cspsvx LAPACK_GLOBAL(cspsvx,CSPSVX)
+#define LAPACK_zspsvx LAPACK_GLOBAL(zspsvx,ZSPSVX)
+#define LAPACK_chpsv LAPACK_GLOBAL(chpsv,CHPSV)
+#define LAPACK_zhpsv LAPACK_GLOBAL(zhpsv,ZHPSV)
+#define LAPACK_chpsvx LAPACK_GLOBAL(chpsvx,CHPSVX)
+#define LAPACK_zhpsvx LAPACK_GLOBAL(zhpsvx,ZHPSVX)
+#define LAPACK_sgeqrf LAPACK_GLOBAL(sgeqrf,SGEQRF)
+#define LAPACK_dgeqrf LAPACK_GLOBAL(dgeqrf,DGEQRF)
+#define LAPACK_cgeqrf LAPACK_GLOBAL(cgeqrf,CGEQRF)
+#define LAPACK_zgeqrf LAPACK_GLOBAL(zgeqrf,ZGEQRF)
+#define LAPACK_sgeqpf LAPACK_GLOBAL(sgeqpf,SGEQPF)
+#define LAPACK_dgeqpf LAPACK_GLOBAL(dgeqpf,DGEQPF)
+#define LAPACK_cgeqpf LAPACK_GLOBAL(cgeqpf,CGEQPF)
+#define LAPACK_zgeqpf LAPACK_GLOBAL(zgeqpf,ZGEQPF)
+#define LAPACK_sgeqp3 LAPACK_GLOBAL(sgeqp3,SGEQP3)
+#define LAPACK_dgeqp3 LAPACK_GLOBAL(dgeqp3,DGEQP3)
+#define LAPACK_cgeqp3 LAPACK_GLOBAL(cgeqp3,CGEQP3)
+#define LAPACK_zgeqp3 LAPACK_GLOBAL(zgeqp3,ZGEQP3)
+#define LAPACK_sorgqr LAPACK_GLOBAL(sorgqr,SORGQR)
+#define LAPACK_dorgqr LAPACK_GLOBAL(dorgqr,DORGQR)
+#define LAPACK_sormqr LAPACK_GLOBAL(sormqr,SORMQR)
+#define LAPACK_dormqr LAPACK_GLOBAL(dormqr,DORMQR)
+#define LAPACK_cungqr LAPACK_GLOBAL(cungqr,CUNGQR)
+#define LAPACK_zungqr LAPACK_GLOBAL(zungqr,ZUNGQR)
+#define LAPACK_cunmqr LAPACK_GLOBAL(cunmqr,CUNMQR)
+#define LAPACK_zunmqr LAPACK_GLOBAL(zunmqr,ZUNMQR)
+#define LAPACK_sgelqf LAPACK_GLOBAL(sgelqf,SGELQF)
+#define LAPACK_dgelqf LAPACK_GLOBAL(dgelqf,DGELQF)
+#define LAPACK_cgelqf LAPACK_GLOBAL(cgelqf,CGELQF)
+#define LAPACK_zgelqf LAPACK_GLOBAL(zgelqf,ZGELQF)
+#define LAPACK_sorglq LAPACK_GLOBAL(sorglq,SORGLQ)
+#define LAPACK_dorglq LAPACK_GLOBAL(dorglq,DORGLQ)
+#define LAPACK_sormlq LAPACK_GLOBAL(sormlq,SORMLQ)
+#define LAPACK_dormlq LAPACK_GLOBAL(dormlq,DORMLQ)
+#define LAPACK_cunglq LAPACK_GLOBAL(cunglq,CUNGLQ)
+#define LAPACK_zunglq LAPACK_GLOBAL(zunglq,ZUNGLQ)
+#define LAPACK_cunmlq LAPACK_GLOBAL(cunmlq,CUNMLQ)
+#define LAPACK_zunmlq LAPACK_GLOBAL(zunmlq,ZUNMLQ)
+#define LAPACK_sgeqlf LAPACK_GLOBAL(sgeqlf,SGEQLF)
+#define LAPACK_dgeqlf LAPACK_GLOBAL(dgeqlf,DGEQLF)
+#define LAPACK_cgeqlf LAPACK_GLOBAL(cgeqlf,CGEQLF)
+#define LAPACK_zgeqlf LAPACK_GLOBAL(zgeqlf,ZGEQLF)
+#define LAPACK_sorgql LAPACK_GLOBAL(sorgql,SORGQL)
+#define LAPACK_dorgql LAPACK_GLOBAL(dorgql,DORGQL)
+#define LAPACK_cungql LAPACK_GLOBAL(cungql,CUNGQL)
+#define LAPACK_zungql LAPACK_GLOBAL(zungql,ZUNGQL)
+#define LAPACK_sormql LAPACK_GLOBAL(sormql,SORMQL)
+#define LAPACK_dormql LAPACK_GLOBAL(dormql,DORMQL)
+#define LAPACK_cunmql LAPACK_GLOBAL(cunmql,CUNMQL)
+#define LAPACK_zunmql LAPACK_GLOBAL(zunmql,ZUNMQL)
+#define LAPACK_sgerqf LAPACK_GLOBAL(sgerqf,SGERQF)
+#define LAPACK_dgerqf LAPACK_GLOBAL(dgerqf,DGERQF)
+#define LAPACK_cgerqf LAPACK_GLOBAL(cgerqf,CGERQF)
+#define LAPACK_zgerqf LAPACK_GLOBAL(zgerqf,ZGERQF)
+#define LAPACK_sorgrq LAPACK_GLOBAL(sorgrq,SORGRQ)
+#define LAPACK_dorgrq LAPACK_GLOBAL(dorgrq,DORGRQ)
+#define LAPACK_cungrq LAPACK_GLOBAL(cungrq,CUNGRQ)
+#define LAPACK_zungrq LAPACK_GLOBAL(zungrq,ZUNGRQ)
+#define LAPACK_sormrq LAPACK_GLOBAL(sormrq,SORMRQ)
+#define LAPACK_dormrq LAPACK_GLOBAL(dormrq,DORMRQ)
+#define LAPACK_cunmrq LAPACK_GLOBAL(cunmrq,CUNMRQ)
+#define LAPACK_zunmrq LAPACK_GLOBAL(zunmrq,ZUNMRQ)
+#define LAPACK_stzrzf LAPACK_GLOBAL(stzrzf,STZRZF)
+#define LAPACK_dtzrzf LAPACK_GLOBAL(dtzrzf,DTZRZF)
+#define LAPACK_ctzrzf LAPACK_GLOBAL(ctzrzf,CTZRZF)
+#define LAPACK_ztzrzf LAPACK_GLOBAL(ztzrzf,ZTZRZF)
+#define LAPACK_sormrz LAPACK_GLOBAL(sormrz,SORMRZ)
+#define LAPACK_dormrz LAPACK_GLOBAL(dormrz,DORMRZ)
+#define LAPACK_cunmrz LAPACK_GLOBAL(cunmrz,CUNMRZ)
+#define LAPACK_zunmrz LAPACK_GLOBAL(zunmrz,ZUNMRZ)
+#define LAPACK_sggqrf LAPACK_GLOBAL(sggqrf,SGGQRF)
+#define LAPACK_dggqrf LAPACK_GLOBAL(dggqrf,DGGQRF)
+#define LAPACK_cggqrf LAPACK_GLOBAL(cggqrf,CGGQRF)
+#define LAPACK_zggqrf LAPACK_GLOBAL(zggqrf,ZGGQRF)
+#define LAPACK_sggrqf LAPACK_GLOBAL(sggrqf,SGGRQF)
+#define LAPACK_dggrqf LAPACK_GLOBAL(dggrqf,DGGRQF)
+#define LAPACK_cggrqf LAPACK_GLOBAL(cggrqf,CGGRQF)
+#define LAPACK_zggrqf LAPACK_GLOBAL(zggrqf,ZGGRQF)
+#define LAPACK_sgebrd LAPACK_GLOBAL(sgebrd,SGEBRD)
+#define LAPACK_dgebrd LAPACK_GLOBAL(dgebrd,DGEBRD)
+#define LAPACK_cgebrd LAPACK_GLOBAL(cgebrd,CGEBRD)
+#define LAPACK_zgebrd LAPACK_GLOBAL(zgebrd,ZGEBRD)
+#define LAPACK_sgbbrd LAPACK_GLOBAL(sgbbrd,SGBBRD)
+#define LAPACK_dgbbrd LAPACK_GLOBAL(dgbbrd,DGBBRD)
+#define LAPACK_cgbbrd LAPACK_GLOBAL(cgbbrd,CGBBRD)
+#define LAPACK_zgbbrd LAPACK_GLOBAL(zgbbrd,ZGBBRD)
+#define LAPACK_sorgbr LAPACK_GLOBAL(sorgbr,SORGBR)
+#define LAPACK_dorgbr LAPACK_GLOBAL(dorgbr,DORGBR)
+#define LAPACK_sormbr LAPACK_GLOBAL(sormbr,SORMBR)
+#define LAPACK_dormbr LAPACK_GLOBAL(dormbr,DORMBR)
+#define LAPACK_cungbr LAPACK_GLOBAL(cungbr,CUNGBR)
+#define LAPACK_zungbr LAPACK_GLOBAL(zungbr,ZUNGBR)
+#define LAPACK_cunmbr LAPACK_GLOBAL(cunmbr,CUNMBR)
+#define LAPACK_zunmbr LAPACK_GLOBAL(zunmbr,ZUNMBR)
+#define LAPACK_sbdsqr LAPACK_GLOBAL(sbdsqr,SBDSQR)
+#define LAPACK_dbdsqr LAPACK_GLOBAL(dbdsqr,DBDSQR)
+#define LAPACK_cbdsqr LAPACK_GLOBAL(cbdsqr,CBDSQR)
+#define LAPACK_zbdsqr LAPACK_GLOBAL(zbdsqr,ZBDSQR)
+#define LAPACK_sbdsdc LAPACK_GLOBAL(sbdsdc,SBDSDC)
+#define LAPACK_dbdsdc LAPACK_GLOBAL(dbdsdc,DBDSDC)
+#define LAPACK_ssytrd LAPACK_GLOBAL(ssytrd,SSYTRD)
+#define LAPACK_dsytrd LAPACK_GLOBAL(dsytrd,DSYTRD)
+#define LAPACK_sorgtr LAPACK_GLOBAL(sorgtr,SORGTR)
+#define LAPACK_dorgtr LAPACK_GLOBAL(dorgtr,DORGTR)
+#define LAPACK_sormtr LAPACK_GLOBAL(sormtr,SORMTR)
+#define LAPACK_dormtr LAPACK_GLOBAL(dormtr,DORMTR)
+#define LAPACK_chetrd LAPACK_GLOBAL(chetrd,CHETRD)
+#define LAPACK_zhetrd LAPACK_GLOBAL(zhetrd,ZHETRD)
+#define LAPACK_cungtr LAPACK_GLOBAL(cungtr,CUNGTR)
+#define LAPACK_zungtr LAPACK_GLOBAL(zungtr,ZUNGTR)
+#define LAPACK_cunmtr LAPACK_GLOBAL(cunmtr,CUNMTR)
+#define LAPACK_zunmtr LAPACK_GLOBAL(zunmtr,ZUNMTR)
+#define LAPACK_ssptrd LAPACK_GLOBAL(ssptrd,SSPTRD)
+#define LAPACK_dsptrd LAPACK_GLOBAL(dsptrd,DSPTRD)
+#define LAPACK_sopgtr LAPACK_GLOBAL(sopgtr,SOPGTR)
+#define LAPACK_dopgtr LAPACK_GLOBAL(dopgtr,DOPGTR)
+#define LAPACK_sopmtr LAPACK_GLOBAL(sopmtr,SOPMTR)
+#define LAPACK_dopmtr LAPACK_GLOBAL(dopmtr,DOPMTR)
+#define LAPACK_chptrd LAPACK_GLOBAL(chptrd,CHPTRD)
+#define LAPACK_zhptrd LAPACK_GLOBAL(zhptrd,ZHPTRD)
+#define LAPACK_cupgtr LAPACK_GLOBAL(cupgtr,CUPGTR)
+#define LAPACK_zupgtr LAPACK_GLOBAL(zupgtr,ZUPGTR)
+#define LAPACK_cupmtr LAPACK_GLOBAL(cupmtr,CUPMTR)
+#define LAPACK_zupmtr LAPACK_GLOBAL(zupmtr,ZUPMTR)
+#define LAPACK_ssbtrd LAPACK_GLOBAL(ssbtrd,SSBTRD)
+#define LAPACK_dsbtrd LAPACK_GLOBAL(dsbtrd,DSBTRD)
+#define LAPACK_chbtrd LAPACK_GLOBAL(chbtrd,CHBTRD)
+#define LAPACK_zhbtrd LAPACK_GLOBAL(zhbtrd,ZHBTRD)
+#define LAPACK_ssterf LAPACK_GLOBAL(ssterf,SSTERF)
+#define LAPACK_dsterf LAPACK_GLOBAL(dsterf,DSTERF)
+#define LAPACK_ssteqr LAPACK_GLOBAL(ssteqr,SSTEQR)
+#define LAPACK_dsteqr LAPACK_GLOBAL(dsteqr,DSTEQR)
+#define LAPACK_csteqr LAPACK_GLOBAL(csteqr,CSTEQR)
+#define LAPACK_zsteqr LAPACK_GLOBAL(zsteqr,ZSTEQR)
+#define LAPACK_sstemr LAPACK_GLOBAL(sstemr,SSTEMR)
+#define LAPACK_dstemr LAPACK_GLOBAL(dstemr,DSTEMR)
+#define LAPACK_cstemr LAPACK_GLOBAL(cstemr,CSTEMR)
+#define LAPACK_zstemr LAPACK_GLOBAL(zstemr,ZSTEMR)
+#define LAPACK_sstedc LAPACK_GLOBAL(sstedc,SSTEDC)
+#define LAPACK_dstedc LAPACK_GLOBAL(dstedc,DSTEDC)
+#define LAPACK_cstedc LAPACK_GLOBAL(cstedc,CSTEDC)
+#define LAPACK_zstedc LAPACK_GLOBAL(zstedc,ZSTEDC)
+#define LAPACK_sstegr LAPACK_GLOBAL(sstegr,SSTEGR)
+#define LAPACK_dstegr LAPACK_GLOBAL(dstegr,DSTEGR)
+#define LAPACK_cstegr LAPACK_GLOBAL(cstegr,CSTEGR)
+#define LAPACK_zstegr LAPACK_GLOBAL(zstegr,ZSTEGR)
+#define LAPACK_spteqr LAPACK_GLOBAL(spteqr,SPTEQR)
+#define LAPACK_dpteqr LAPACK_GLOBAL(dpteqr,DPTEQR)
+#define LAPACK_cpteqr LAPACK_GLOBAL(cpteqr,CPTEQR)
+#define LAPACK_zpteqr LAPACK_GLOBAL(zpteqr,ZPTEQR)
+#define LAPACK_sstebz LAPACK_GLOBAL(sstebz,SSTEBZ)
+#define LAPACK_dstebz LAPACK_GLOBAL(dstebz,DSTEBZ)
+#define LAPACK_sstein LAPACK_GLOBAL(sstein,SSTEIN)
+#define LAPACK_dstein LAPACK_GLOBAL(dstein,DSTEIN)
+#define LAPACK_cstein LAPACK_GLOBAL(cstein,CSTEIN)
+#define LAPACK_zstein LAPACK_GLOBAL(zstein,ZSTEIN)
+#define LAPACK_sdisna LAPACK_GLOBAL(sdisna,SDISNA)
+#define LAPACK_ddisna LAPACK_GLOBAL(ddisna,DDISNA)
+#define LAPACK_ssygst LAPACK_GLOBAL(ssygst,SSYGST)
+#define LAPACK_dsygst LAPACK_GLOBAL(dsygst,DSYGST)
+#define LAPACK_chegst LAPACK_GLOBAL(chegst,CHEGST)
+#define LAPACK_zhegst LAPACK_GLOBAL(zhegst,ZHEGST)
+#define LAPACK_sspgst LAPACK_GLOBAL(sspgst,SSPGST)
+#define LAPACK_dspgst LAPACK_GLOBAL(dspgst,DSPGST)
+#define LAPACK_chpgst LAPACK_GLOBAL(chpgst,CHPGST)
+#define LAPACK_zhpgst LAPACK_GLOBAL(zhpgst,ZHPGST)
+#define LAPACK_ssbgst LAPACK_GLOBAL(ssbgst,SSBGST)
+#define LAPACK_dsbgst LAPACK_GLOBAL(dsbgst,DSBGST)
+#define LAPACK_chbgst LAPACK_GLOBAL(chbgst,CHBGST)
+#define LAPACK_zhbgst LAPACK_GLOBAL(zhbgst,ZHBGST)
+#define LAPACK_spbstf LAPACK_GLOBAL(spbstf,SPBSTF)
+#define LAPACK_dpbstf LAPACK_GLOBAL(dpbstf,DPBSTF)
+#define LAPACK_cpbstf LAPACK_GLOBAL(cpbstf,CPBSTF)
+#define LAPACK_zpbstf LAPACK_GLOBAL(zpbstf,ZPBSTF)
+#define LAPACK_sgehrd LAPACK_GLOBAL(sgehrd,SGEHRD)
+#define LAPACK_dgehrd LAPACK_GLOBAL(dgehrd,DGEHRD)
+#define LAPACK_cgehrd LAPACK_GLOBAL(cgehrd,CGEHRD)
+#define LAPACK_zgehrd LAPACK_GLOBAL(zgehrd,ZGEHRD)
+#define LAPACK_sorghr LAPACK_GLOBAL(sorghr,SORGHR)
+#define LAPACK_dorghr LAPACK_GLOBAL(dorghr,DORGHR)
+#define LAPACK_sormhr LAPACK_GLOBAL(sormhr,SORMHR)
+#define LAPACK_dormhr LAPACK_GLOBAL(dormhr,DORMHR)
+#define LAPACK_cunghr LAPACK_GLOBAL(cunghr,CUNGHR)
+#define LAPACK_zunghr LAPACK_GLOBAL(zunghr,ZUNGHR)
+#define LAPACK_cunmhr LAPACK_GLOBAL(cunmhr,CUNMHR)
+#define LAPACK_zunmhr LAPACK_GLOBAL(zunmhr,ZUNMHR)
+#define LAPACK_sgebal LAPACK_GLOBAL(sgebal,SGEBAL)
+#define LAPACK_dgebal LAPACK_GLOBAL(dgebal,DGEBAL)
+#define LAPACK_cgebal LAPACK_GLOBAL(cgebal,CGEBAL)
+#define LAPACK_zgebal LAPACK_GLOBAL(zgebal,ZGEBAL)
+#define LAPACK_sgebak LAPACK_GLOBAL(sgebak,SGEBAK)
+#define LAPACK_dgebak LAPACK_GLOBAL(dgebak,DGEBAK)
+#define LAPACK_cgebak LAPACK_GLOBAL(cgebak,CGEBAK)
+#define LAPACK_zgebak LAPACK_GLOBAL(zgebak,ZGEBAK)
+#define LAPACK_shseqr LAPACK_GLOBAL(shseqr,SHSEQR)
+#define LAPACK_dhseqr LAPACK_GLOBAL(dhseqr,DHSEQR)
+#define LAPACK_chseqr LAPACK_GLOBAL(chseqr,CHSEQR)
+#define LAPACK_zhseqr LAPACK_GLOBAL(zhseqr,ZHSEQR)
+#define LAPACK_shsein LAPACK_GLOBAL(shsein,SHSEIN)
+#define LAPACK_dhsein LAPACK_GLOBAL(dhsein,DHSEIN)
+#define LAPACK_chsein LAPACK_GLOBAL(chsein,CHSEIN)
+#define LAPACK_zhsein LAPACK_GLOBAL(zhsein,ZHSEIN)
+#define LAPACK_strevc LAPACK_GLOBAL(strevc,STREVC)
+#define LAPACK_dtrevc LAPACK_GLOBAL(dtrevc,DTREVC)
+#define LAPACK_ctrevc LAPACK_GLOBAL(ctrevc,CTREVC)
+#define LAPACK_ztrevc LAPACK_GLOBAL(ztrevc,ZTREVC)
+#define LAPACK_strsna LAPACK_GLOBAL(strsna,STRSNA)
+#define LAPACK_dtrsna LAPACK_GLOBAL(dtrsna,DTRSNA)
+#define LAPACK_ctrsna LAPACK_GLOBAL(ctrsna,CTRSNA)
+#define LAPACK_ztrsna LAPACK_GLOBAL(ztrsna,ZTRSNA)
+#define LAPACK_strexc LAPACK_GLOBAL(strexc,STREXC)
+#define LAPACK_dtrexc LAPACK_GLOBAL(dtrexc,DTREXC)
+#define LAPACK_ctrexc LAPACK_GLOBAL(ctrexc,CTREXC)
+#define LAPACK_ztrexc LAPACK_GLOBAL(ztrexc,ZTREXC)
+#define LAPACK_strsen LAPACK_GLOBAL(strsen,STRSEN)
+#define LAPACK_dtrsen LAPACK_GLOBAL(dtrsen,DTRSEN)
+#define LAPACK_ctrsen LAPACK_GLOBAL(ctrsen,CTRSEN)
+#define LAPACK_ztrsen LAPACK_GLOBAL(ztrsen,ZTRSEN)
+#define LAPACK_strsyl LAPACK_GLOBAL(strsyl,STRSYL)
+#define LAPACK_dtrsyl LAPACK_GLOBAL(dtrsyl,DTRSYL)
+#define LAPACK_ctrsyl LAPACK_GLOBAL(ctrsyl,CTRSYL)
+#define LAPACK_ztrsyl LAPACK_GLOBAL(ztrsyl,ZTRSYL)
+#define LAPACK_sgghrd LAPACK_GLOBAL(sgghrd,SGGHRD)
+#define LAPACK_dgghrd LAPACK_GLOBAL(dgghrd,DGGHRD)
+#define LAPACK_cgghrd LAPACK_GLOBAL(cgghrd,CGGHRD)
+#define LAPACK_zgghrd LAPACK_GLOBAL(zgghrd,ZGGHRD)
+#define LAPACK_sggbal LAPACK_GLOBAL(sggbal,SGGBAL)
+#define LAPACK_dggbal LAPACK_GLOBAL(dggbal,DGGBAL)
+#define LAPACK_cggbal LAPACK_GLOBAL(cggbal,CGGBAL)
+#define LAPACK_zggbal LAPACK_GLOBAL(zggbal,ZGGBAL)
+#define LAPACK_sggbak LAPACK_GLOBAL(sggbak,SGGBAK)
+#define LAPACK_dggbak LAPACK_GLOBAL(dggbak,DGGBAK)
+#define LAPACK_cggbak LAPACK_GLOBAL(cggbak,CGGBAK)
+#define LAPACK_zggbak LAPACK_GLOBAL(zggbak,ZGGBAK)
+#define LAPACK_shgeqz LAPACK_GLOBAL(shgeqz,SHGEQZ)
+#define LAPACK_dhgeqz LAPACK_GLOBAL(dhgeqz,DHGEQZ)
+#define LAPACK_chgeqz LAPACK_GLOBAL(chgeqz,CHGEQZ)
+#define LAPACK_zhgeqz LAPACK_GLOBAL(zhgeqz,ZHGEQZ)
+#define LAPACK_stgevc LAPACK_GLOBAL(stgevc,STGEVC)
+#define LAPACK_dtgevc LAPACK_GLOBAL(dtgevc,DTGEVC)
+#define LAPACK_ctgevc LAPACK_GLOBAL(ctgevc,CTGEVC)
+#define LAPACK_ztgevc LAPACK_GLOBAL(ztgevc,ZTGEVC)
+#define LAPACK_stgexc LAPACK_GLOBAL(stgexc,STGEXC)
+#define LAPACK_dtgexc LAPACK_GLOBAL(dtgexc,DTGEXC)
+#define LAPACK_ctgexc LAPACK_GLOBAL(ctgexc,CTGEXC)
+#define LAPACK_ztgexc LAPACK_GLOBAL(ztgexc,ZTGEXC)
+#define LAPACK_stgsen LAPACK_GLOBAL(stgsen,STGSEN)
+#define LAPACK_dtgsen LAPACK_GLOBAL(dtgsen,DTGSEN)
+#define LAPACK_ctgsen LAPACK_GLOBAL(ctgsen,CTGSEN)
+#define LAPACK_ztgsen LAPACK_GLOBAL(ztgsen,ZTGSEN)
+#define LAPACK_stgsyl LAPACK_GLOBAL(stgsyl,STGSYL)
+#define LAPACK_dtgsyl LAPACK_GLOBAL(dtgsyl,DTGSYL)
+#define LAPACK_ctgsyl LAPACK_GLOBAL(ctgsyl,CTGSYL)
+#define LAPACK_ztgsyl LAPACK_GLOBAL(ztgsyl,ZTGSYL)
+#define LAPACK_stgsna LAPACK_GLOBAL(stgsna,STGSNA)
+#define LAPACK_dtgsna LAPACK_GLOBAL(dtgsna,DTGSNA)
+#define LAPACK_ctgsna LAPACK_GLOBAL(ctgsna,CTGSNA)
+#define LAPACK_ztgsna LAPACK_GLOBAL(ztgsna,ZTGSNA)
+#define LAPACK_sggsvp LAPACK_GLOBAL(sggsvp,SGGSVP)
+#define LAPACK_dggsvp LAPACK_GLOBAL(dggsvp,DGGSVP)
+#define LAPACK_cggsvp LAPACK_GLOBAL(cggsvp,CGGSVP)
+#define LAPACK_zggsvp LAPACK_GLOBAL(zggsvp,ZGGSVP)
+#define LAPACK_stgsja LAPACK_GLOBAL(stgsja,STGSJA)
+#define LAPACK_dtgsja LAPACK_GLOBAL(dtgsja,DTGSJA)
+#define LAPACK_ctgsja LAPACK_GLOBAL(ctgsja,CTGSJA)
+#define LAPACK_ztgsja LAPACK_GLOBAL(ztgsja,ZTGSJA)
+#define LAPACK_sgels LAPACK_GLOBAL(sgels,SGELS)
+#define LAPACK_dgels LAPACK_GLOBAL(dgels,DGELS)
+#define LAPACK_cgels LAPACK_GLOBAL(cgels,CGELS)
+#define LAPACK_zgels LAPACK_GLOBAL(zgels,ZGELS)
+#define LAPACK_sgelsy LAPACK_GLOBAL(sgelsy,SGELSY)
+#define LAPACK_dgelsy LAPACK_GLOBAL(dgelsy,DGELSY)
+#define LAPACK_cgelsy LAPACK_GLOBAL(cgelsy,CGELSY)
+#define LAPACK_zgelsy LAPACK_GLOBAL(zgelsy,ZGELSY)
+#define LAPACK_sgelss LAPACK_GLOBAL(sgelss,SGELSS)
+#define LAPACK_dgelss LAPACK_GLOBAL(dgelss,DGELSS)
+#define LAPACK_cgelss LAPACK_GLOBAL(cgelss,CGELSS)
+#define LAPACK_zgelss LAPACK_GLOBAL(zgelss,ZGELSS)
+#define LAPACK_sgelsd LAPACK_GLOBAL(sgelsd,SGELSD)
+#define LAPACK_dgelsd LAPACK_GLOBAL(dgelsd,DGELSD)
+#define LAPACK_cgelsd LAPACK_GLOBAL(cgelsd,CGELSD)
+#define LAPACK_zgelsd LAPACK_GLOBAL(zgelsd,ZGELSD)
+#define LAPACK_sgglse LAPACK_GLOBAL(sgglse,SGGLSE)
+#define LAPACK_dgglse LAPACK_GLOBAL(dgglse,DGGLSE)
+#define LAPACK_cgglse LAPACK_GLOBAL(cgglse,CGGLSE)
+#define LAPACK_zgglse LAPACK_GLOBAL(zgglse,ZGGLSE)
+#define LAPACK_sggglm LAPACK_GLOBAL(sggglm,SGGGLM)
+#define LAPACK_dggglm LAPACK_GLOBAL(dggglm,DGGGLM)
+#define LAPACK_cggglm LAPACK_GLOBAL(cggglm,CGGGLM)
+#define LAPACK_zggglm LAPACK_GLOBAL(zggglm,ZGGGLM)
+#define LAPACK_ssyev LAPACK_GLOBAL(ssyev,SSYEV)
+#define LAPACK_dsyev LAPACK_GLOBAL(dsyev,DSYEV)
+#define LAPACK_cheev LAPACK_GLOBAL(cheev,CHEEV)
+#define LAPACK_zheev LAPACK_GLOBAL(zheev,ZHEEV)
+#define LAPACK_ssyevd LAPACK_GLOBAL(ssyevd,SSYEVD)
+#define LAPACK_dsyevd LAPACK_GLOBAL(dsyevd,DSYEVD)
+#define LAPACK_cheevd LAPACK_GLOBAL(cheevd,CHEEVD)
+#define LAPACK_zheevd LAPACK_GLOBAL(zheevd,ZHEEVD)
+#define LAPACK_ssyevx LAPACK_GLOBAL(ssyevx,SSYEVX)
+#define LAPACK_dsyevx LAPACK_GLOBAL(dsyevx,DSYEVX)
+#define LAPACK_cheevx LAPACK_GLOBAL(cheevx,CHEEVX)
+#define LAPACK_zheevx LAPACK_GLOBAL(zheevx,ZHEEVX)
+#define LAPACK_ssyevr LAPACK_GLOBAL(ssyevr,SSYEVR)
+#define LAPACK_dsyevr LAPACK_GLOBAL(dsyevr,DSYEVR)
+#define LAPACK_cheevr LAPACK_GLOBAL(cheevr,CHEEVR)
+#define LAPACK_zheevr LAPACK_GLOBAL(zheevr,ZHEEVR)
+#define LAPACK_sspev LAPACK_GLOBAL(sspev,SSPEV)
+#define LAPACK_dspev LAPACK_GLOBAL(dspev,DSPEV)
+#define LAPACK_chpev LAPACK_GLOBAL(chpev,CHPEV)
+#define LAPACK_zhpev LAPACK_GLOBAL(zhpev,ZHPEV)
+#define LAPACK_sspevd LAPACK_GLOBAL(sspevd,SSPEVD)
+#define LAPACK_dspevd LAPACK_GLOBAL(dspevd,DSPEVD)
+#define LAPACK_chpevd LAPACK_GLOBAL(chpevd,CHPEVD)
+#define LAPACK_zhpevd LAPACK_GLOBAL(zhpevd,ZHPEVD)
+#define LAPACK_sspevx LAPACK_GLOBAL(sspevx,SSPEVX)
+#define LAPACK_dspevx LAPACK_GLOBAL(dspevx,DSPEVX)
+#define LAPACK_chpevx LAPACK_GLOBAL(chpevx,CHPEVX)
+#define LAPACK_zhpevx LAPACK_GLOBAL(zhpevx,ZHPEVX)
+#define LAPACK_ssbev LAPACK_GLOBAL(ssbev,SSBEV)
+#define LAPACK_dsbev LAPACK_GLOBAL(dsbev,DSBEV)
+#define LAPACK_chbev LAPACK_GLOBAL(chbev,CHBEV)
+#define LAPACK_zhbev LAPACK_GLOBAL(zhbev,ZHBEV)
+#define LAPACK_ssbevd LAPACK_GLOBAL(ssbevd,SSBEVD)
+#define LAPACK_dsbevd LAPACK_GLOBAL(dsbevd,DSBEVD)
+#define LAPACK_chbevd LAPACK_GLOBAL(chbevd,CHBEVD)
+#define LAPACK_zhbevd LAPACK_GLOBAL(zhbevd,ZHBEVD)
+#define LAPACK_ssbevx LAPACK_GLOBAL(ssbevx,SSBEVX)
+#define LAPACK_dsbevx LAPACK_GLOBAL(dsbevx,DSBEVX)
+#define LAPACK_chbevx LAPACK_GLOBAL(chbevx,CHBEVX)
+#define LAPACK_zhbevx LAPACK_GLOBAL(zhbevx,ZHBEVX)
+#define LAPACK_sstev LAPACK_GLOBAL(sstev,SSTEV)
+#define LAPACK_dstev LAPACK_GLOBAL(dstev,DSTEV)
+#define LAPACK_sstevd LAPACK_GLOBAL(sstevd,SSTEVD)
+#define LAPACK_dstevd LAPACK_GLOBAL(dstevd,DSTEVD)
+#define LAPACK_sstevx LAPACK_GLOBAL(sstevx,SSTEVX)
+#define LAPACK_dstevx LAPACK_GLOBAL(dstevx,DSTEVX)
+#define LAPACK_sstevr LAPACK_GLOBAL(sstevr,SSTEVR)
+#define LAPACK_dstevr LAPACK_GLOBAL(dstevr,DSTEVR)
+#define LAPACK_sgees LAPACK_GLOBAL(sgees,SGEES)
+#define LAPACK_dgees LAPACK_GLOBAL(dgees,DGEES)
+#define LAPACK_cgees LAPACK_GLOBAL(cgees,CGEES)
+#define LAPACK_zgees LAPACK_GLOBAL(zgees,ZGEES)
+#define LAPACK_sgeesx LAPACK_GLOBAL(sgeesx,SGEESX)
+#define LAPACK_dgeesx LAPACK_GLOBAL(dgeesx,DGEESX)
+#define LAPACK_cgeesx LAPACK_GLOBAL(cgeesx,CGEESX)
+#define LAPACK_zgeesx LAPACK_GLOBAL(zgeesx,ZGEESX)
+#define LAPACK_sgeev LAPACK_GLOBAL(sgeev,SGEEV)
+#define LAPACK_dgeev LAPACK_GLOBAL(dgeev,DGEEV)
+#define LAPACK_cgeev LAPACK_GLOBAL(cgeev,CGEEV)
+#define LAPACK_zgeev LAPACK_GLOBAL(zgeev,ZGEEV)
+#define LAPACK_sgeevx LAPACK_GLOBAL(sgeevx,SGEEVX)
+#define LAPACK_dgeevx LAPACK_GLOBAL(dgeevx,DGEEVX)
+#define LAPACK_cgeevx LAPACK_GLOBAL(cgeevx,CGEEVX)
+#define LAPACK_zgeevx LAPACK_GLOBAL(zgeevx,ZGEEVX)
+#define LAPACK_sgesvd LAPACK_GLOBAL(sgesvd,SGESVD)
+#define LAPACK_dgesvd LAPACK_GLOBAL(dgesvd,DGESVD)
+#define LAPACK_cgesvd LAPACK_GLOBAL(cgesvd,CGESVD)
+#define LAPACK_zgesvd LAPACK_GLOBAL(zgesvd,ZGESVD)
+#define LAPACK_sgesdd LAPACK_GLOBAL(sgesdd,SGESDD)
+#define LAPACK_dgesdd LAPACK_GLOBAL(dgesdd,DGESDD)
+#define LAPACK_cgesdd LAPACK_GLOBAL(cgesdd,CGESDD)
+#define LAPACK_zgesdd LAPACK_GLOBAL(zgesdd,ZGESDD)
+#define LAPACK_dgejsv LAPACK_GLOBAL(dgejsv,DGEJSV)
+#define LAPACK_sgejsv LAPACK_GLOBAL(sgejsv,SGEJSV)
+#define LAPACK_dgesvj LAPACK_GLOBAL(dgesvj,DGESVJ)
+#define LAPACK_sgesvj LAPACK_GLOBAL(sgesvj,SGESVJ)
+#define LAPACK_sggsvd LAPACK_GLOBAL(sggsvd,SGGSVD)
+#define LAPACK_dggsvd LAPACK_GLOBAL(dggsvd,DGGSVD)
+#define LAPACK_cggsvd LAPACK_GLOBAL(cggsvd,CGGSVD)
+#define LAPACK_zggsvd LAPACK_GLOBAL(zggsvd,ZGGSVD)
+#define LAPACK_ssygv LAPACK_GLOBAL(ssygv,SSYGV)
+#define LAPACK_dsygv LAPACK_GLOBAL(dsygv,DSYGV)
+#define LAPACK_chegv LAPACK_GLOBAL(chegv,CHEGV)
+#define LAPACK_zhegv LAPACK_GLOBAL(zhegv,ZHEGV)
+#define LAPACK_ssygvd LAPACK_GLOBAL(ssygvd,SSYGVD)
+#define LAPACK_dsygvd LAPACK_GLOBAL(dsygvd,DSYGVD)
+#define LAPACK_chegvd LAPACK_GLOBAL(chegvd,CHEGVD)
+#define LAPACK_zhegvd LAPACK_GLOBAL(zhegvd,ZHEGVD)
+#define LAPACK_ssygvx LAPACK_GLOBAL(ssygvx,SSYGVX)
+#define LAPACK_dsygvx LAPACK_GLOBAL(dsygvx,DSYGVX)
+#define LAPACK_chegvx LAPACK_GLOBAL(chegvx,CHEGVX)
+#define LAPACK_zhegvx LAPACK_GLOBAL(zhegvx,ZHEGVX)
+#define LAPACK_sspgv LAPACK_GLOBAL(sspgv,SSPGV)
+#define LAPACK_dspgv LAPACK_GLOBAL(dspgv,DSPGV)
+#define LAPACK_chpgv LAPACK_GLOBAL(chpgv,CHPGV)
+#define LAPACK_zhpgv LAPACK_GLOBAL(zhpgv,ZHPGV)
+#define LAPACK_sspgvd LAPACK_GLOBAL(sspgvd,SSPGVD)
+#define LAPACK_dspgvd LAPACK_GLOBAL(dspgvd,DSPGVD)
+#define LAPACK_chpgvd LAPACK_GLOBAL(chpgvd,CHPGVD)
+#define LAPACK_zhpgvd LAPACK_GLOBAL(zhpgvd,ZHPGVD)
+#define LAPACK_sspgvx LAPACK_GLOBAL(sspgvx,SSPGVX)
+#define LAPACK_dspgvx LAPACK_GLOBAL(dspgvx,DSPGVX)
+#define LAPACK_chpgvx LAPACK_GLOBAL(chpgvx,CHPGVX)
+#define LAPACK_zhpgvx LAPACK_GLOBAL(zhpgvx,ZHPGVX)
+#define LAPACK_ssbgv LAPACK_GLOBAL(ssbgv,SSBGV)
+#define LAPACK_dsbgv LAPACK_GLOBAL(dsbgv,DSBGV)
+#define LAPACK_chbgv LAPACK_GLOBAL(chbgv,CHBGV)
+#define LAPACK_zhbgv LAPACK_GLOBAL(zhbgv,ZHBGV)
+#define LAPACK_ssbgvd LAPACK_GLOBAL(ssbgvd,SSBGVD)
+#define LAPACK_dsbgvd LAPACK_GLOBAL(dsbgvd,DSBGVD)
+#define LAPACK_chbgvd LAPACK_GLOBAL(chbgvd,CHBGVD)
+#define LAPACK_zhbgvd LAPACK_GLOBAL(zhbgvd,ZHBGVD)
+#define LAPACK_ssbgvx LAPACK_GLOBAL(ssbgvx,SSBGVX)
+#define LAPACK_dsbgvx LAPACK_GLOBAL(dsbgvx,DSBGVX)
+#define LAPACK_chbgvx LAPACK_GLOBAL(chbgvx,CHBGVX)
+#define LAPACK_zhbgvx LAPACK_GLOBAL(zhbgvx,ZHBGVX)
+#define LAPACK_sgges LAPACK_GLOBAL(sgges,SGGES)
+#define LAPACK_dgges LAPACK_GLOBAL(dgges,DGGES)
+#define LAPACK_cgges LAPACK_GLOBAL(cgges,CGGES)
+#define LAPACK_zgges LAPACK_GLOBAL(zgges,ZGGES)
+#define LAPACK_sggesx LAPACK_GLOBAL(sggesx,SGGESX)
+#define LAPACK_dggesx LAPACK_GLOBAL(dggesx,DGGESX)
+#define LAPACK_cggesx LAPACK_GLOBAL(cggesx,CGGESX)
+#define LAPACK_zggesx LAPACK_GLOBAL(zggesx,ZGGESX)
+#define LAPACK_sggev LAPACK_GLOBAL(sggev,SGGEV)
+#define LAPACK_dggev LAPACK_GLOBAL(dggev,DGGEV)
+#define LAPACK_cggev LAPACK_GLOBAL(cggev,CGGEV)
+#define LAPACK_zggev LAPACK_GLOBAL(zggev,ZGGEV)
+#define LAPACK_sggevx LAPACK_GLOBAL(sggevx,SGGEVX)
+#define LAPACK_dggevx LAPACK_GLOBAL(dggevx,DGGEVX)
+#define LAPACK_cggevx LAPACK_GLOBAL(cggevx,CGGEVX)
+#define LAPACK_zggevx LAPACK_GLOBAL(zggevx,ZGGEVX)
+#define LAPACK_dsfrk LAPACK_GLOBAL(dsfrk,DSFRK)
+#define LAPACK_ssfrk LAPACK_GLOBAL(ssfrk,SSFRK)
+#define LAPACK_zhfrk LAPACK_GLOBAL(zhfrk,ZHFRK)
+#define LAPACK_chfrk LAPACK_GLOBAL(chfrk,CHFRK)
+#define LAPACK_dtfsm LAPACK_GLOBAL(dtfsm,DTFSM)
+#define LAPACK_stfsm LAPACK_GLOBAL(stfsm,STFSM)
+#define LAPACK_ztfsm LAPACK_GLOBAL(ztfsm,ZTFSM)
+#define LAPACK_ctfsm LAPACK_GLOBAL(ctfsm,CTFSM)
+#define LAPACK_dtfttp LAPACK_GLOBAL(dtfttp,DTFTTP)
+#define LAPACK_stfttp LAPACK_GLOBAL(stfttp,STFTTP)
+#define LAPACK_ztfttp LAPACK_GLOBAL(ztfttp,ZTFTTP)
+#define LAPACK_ctfttp LAPACK_GLOBAL(ctfttp,CTFTTP)
+#define LAPACK_dtfttr LAPACK_GLOBAL(dtfttr,DTFTTR)
+#define LAPACK_stfttr LAPACK_GLOBAL(stfttr,STFTTR)
+#define LAPACK_ztfttr LAPACK_GLOBAL(ztfttr,ZTFTTR)
+#define LAPACK_ctfttr LAPACK_GLOBAL(ctfttr,CTFTTR)
+#define LAPACK_dtpttf LAPACK_GLOBAL(dtpttf,DTPTTF)
+#define LAPACK_stpttf LAPACK_GLOBAL(stpttf,STPTTF)
+#define LAPACK_ztpttf LAPACK_GLOBAL(ztpttf,ZTPTTF)
+#define LAPACK_ctpttf LAPACK_GLOBAL(ctpttf,CTPTTF)
+#define LAPACK_dtpttr LAPACK_GLOBAL(dtpttr,DTPTTR)
+#define LAPACK_stpttr LAPACK_GLOBAL(stpttr,STPTTR)
+#define LAPACK_ztpttr LAPACK_GLOBAL(ztpttr,ZTPTTR)
+#define LAPACK_ctpttr LAPACK_GLOBAL(ctpttr,CTPTTR)
+#define LAPACK_dtrttf LAPACK_GLOBAL(dtrttf,DTRTTF)
+#define LAPACK_strttf LAPACK_GLOBAL(strttf,STRTTF)
+#define LAPACK_ztrttf LAPACK_GLOBAL(ztrttf,ZTRTTF)
+#define LAPACK_ctrttf LAPACK_GLOBAL(ctrttf,CTRTTF)
+#define LAPACK_dtrttp LAPACK_GLOBAL(dtrttp,DTRTTP)
+#define LAPACK_strttp LAPACK_GLOBAL(strttp,STRTTP)
+#define LAPACK_ztrttp LAPACK_GLOBAL(ztrttp,ZTRTTP)
+#define LAPACK_ctrttp LAPACK_GLOBAL(ctrttp,CTRTTP)
+#define LAPACK_sgeqrfp LAPACK_GLOBAL(sgeqrfp,SGEQRFP)
+#define LAPACK_dgeqrfp LAPACK_GLOBAL(dgeqrfp,DGEQRFP)
+#define LAPACK_cgeqrfp LAPACK_GLOBAL(cgeqrfp,CGEQRFP)
+#define LAPACK_zgeqrfp LAPACK_GLOBAL(zgeqrfp,ZGEQRFP)
+#define LAPACK_clacgv LAPACK_GLOBAL(clacgv,CLACGV)
+#define LAPACK_zlacgv LAPACK_GLOBAL(zlacgv,ZLACGV)
+#define LAPACK_slarnv LAPACK_GLOBAL(slarnv,SLARNV)
+#define LAPACK_dlarnv LAPACK_GLOBAL(dlarnv,DLARNV)
+#define LAPACK_clarnv LAPACK_GLOBAL(clarnv,CLARNV)
+#define LAPACK_zlarnv LAPACK_GLOBAL(zlarnv,ZLARNV)
+#define LAPACK_sgeqr2 LAPACK_GLOBAL(sgeqr2,SGEQR2)
+#define LAPACK_dgeqr2 LAPACK_GLOBAL(dgeqr2,DGEQR2)
+#define LAPACK_cgeqr2 LAPACK_GLOBAL(cgeqr2,CGEQR2)
+#define LAPACK_zgeqr2 LAPACK_GLOBAL(zgeqr2,ZGEQR2)
+#define LAPACK_slacpy LAPACK_GLOBAL(slacpy,SLACPY)
+#define LAPACK_dlacpy LAPACK_GLOBAL(dlacpy,DLACPY)
+#define LAPACK_clacpy LAPACK_GLOBAL(clacpy,CLACPY)
+#define LAPACK_zlacpy LAPACK_GLOBAL(zlacpy,ZLACPY)
+#define LAPACK_sgetf2 LAPACK_GLOBAL(sgetf2,SGETF2)
+#define LAPACK_dgetf2 LAPACK_GLOBAL(dgetf2,DGETF2)
+#define LAPACK_cgetf2 LAPACK_GLOBAL(cgetf2,CGETF2)
+#define LAPACK_zgetf2 LAPACK_GLOBAL(zgetf2,ZGETF2)
+#define LAPACK_slaswp LAPACK_GLOBAL(slaswp,SLASWP)
+#define LAPACK_dlaswp LAPACK_GLOBAL(dlaswp,DLASWP)
+#define LAPACK_claswp LAPACK_GLOBAL(claswp,CLASWP)
+#define LAPACK_zlaswp LAPACK_GLOBAL(zlaswp,ZLASWP)
+#define LAPACK_slange LAPACK_GLOBAL(slange,SLANGE)
+#define LAPACK_dlange LAPACK_GLOBAL(dlange,DLANGE)
+#define LAPACK_clange LAPACK_GLOBAL(clange,CLANGE)
+#define LAPACK_zlange LAPACK_GLOBAL(zlange,ZLANGE)
+#define LAPACK_clanhe LAPACK_GLOBAL(clanhe,CLANHE)
+#define LAPACK_zlanhe LAPACK_GLOBAL(zlanhe,ZLANHE)
+#define LAPACK_slansy LAPACK_GLOBAL(slansy,SLANSY)
+#define LAPACK_dlansy LAPACK_GLOBAL(dlansy,DLANSY)
+#define LAPACK_clansy LAPACK_GLOBAL(clansy,CLANSY)
+#define LAPACK_zlansy LAPACK_GLOBAL(zlansy,ZLANSY)
+#define LAPACK_slantr LAPACK_GLOBAL(slantr,SLANTR)
+#define LAPACK_dlantr LAPACK_GLOBAL(dlantr,DLANTR)
+#define LAPACK_clantr LAPACK_GLOBAL(clantr,CLANTR)
+#define LAPACK_zlantr LAPACK_GLOBAL(zlantr,ZLANTR)
+#define LAPACK_slamch LAPACK_GLOBAL(slamch,SLAMCH)
+#define LAPACK_dlamch LAPACK_GLOBAL(dlamch,DLAMCH)
+#define LAPACK_sgelq2 LAPACK_GLOBAL(sgelq2,SGELQ2)
+#define LAPACK_dgelq2 LAPACK_GLOBAL(dgelq2,DGELQ2)
+#define LAPACK_cgelq2 LAPACK_GLOBAL(cgelq2,CGELQ2)
+#define LAPACK_zgelq2 LAPACK_GLOBAL(zgelq2,ZGELQ2)
+#define LAPACK_slarfb LAPACK_GLOBAL(slarfb,SLARFB)
+#define LAPACK_dlarfb LAPACK_GLOBAL(dlarfb,DLARFB)
+#define LAPACK_clarfb LAPACK_GLOBAL(clarfb,CLARFB)
+#define LAPACK_zlarfb LAPACK_GLOBAL(zlarfb,ZLARFB)
+#define LAPACK_slarfg LAPACK_GLOBAL(slarfg,SLARFG)
+#define LAPACK_dlarfg LAPACK_GLOBAL(dlarfg,DLARFG)
+#define LAPACK_clarfg LAPACK_GLOBAL(clarfg,CLARFG)
+#define LAPACK_zlarfg LAPACK_GLOBAL(zlarfg,ZLARFG)
+#define LAPACK_slarft LAPACK_GLOBAL(slarft,SLARFT)
+#define LAPACK_dlarft LAPACK_GLOBAL(dlarft,DLARFT)
+#define LAPACK_clarft LAPACK_GLOBAL(clarft,CLARFT)
+#define LAPACK_zlarft LAPACK_GLOBAL(zlarft,ZLARFT)
+#define LAPACK_slarfx LAPACK_GLOBAL(slarfx,SLARFX)
+#define LAPACK_dlarfx LAPACK_GLOBAL(dlarfx,DLARFX)
+#define LAPACK_clarfx LAPACK_GLOBAL(clarfx,CLARFX)
+#define LAPACK_zlarfx LAPACK_GLOBAL(zlarfx,ZLARFX)
+#define LAPACK_slatms LAPACK_GLOBAL(slatms,SLATMS)
+#define LAPACK_dlatms LAPACK_GLOBAL(dlatms,DLATMS)
+#define LAPACK_clatms LAPACK_GLOBAL(clatms,CLATMS)
+#define LAPACK_zlatms LAPACK_GLOBAL(zlatms,ZLATMS)
+#define LAPACK_slag2d LAPACK_GLOBAL(slag2d,SLAG2D)
+#define LAPACK_dlag2s LAPACK_GLOBAL(dlag2s,DLAG2S)
+#define LAPACK_clag2z LAPACK_GLOBAL(clag2z,CLAG2Z)
+#define LAPACK_zlag2c LAPACK_GLOBAL(zlag2c,ZLAG2C)
+#define LAPACK_slauum LAPACK_GLOBAL(slauum,SLAUUM)
+#define LAPACK_dlauum LAPACK_GLOBAL(dlauum,DLAUUM)
+#define LAPACK_clauum LAPACK_GLOBAL(clauum,CLAUUM)
+#define LAPACK_zlauum LAPACK_GLOBAL(zlauum,ZLAUUM)
+#define LAPACK_slagge LAPACK_GLOBAL(slagge,SLAGGE)
+#define LAPACK_dlagge LAPACK_GLOBAL(dlagge,DLAGGE)
+#define LAPACK_clagge LAPACK_GLOBAL(clagge,CLAGGE)
+#define LAPACK_zlagge LAPACK_GLOBAL(zlagge,ZLAGGE)
+#define LAPACK_slaset LAPACK_GLOBAL(slaset,SLASET)
+#define LAPACK_dlaset LAPACK_GLOBAL(dlaset,DLASET)
+#define LAPACK_claset LAPACK_GLOBAL(claset,CLASET)
+#define LAPACK_zlaset LAPACK_GLOBAL(zlaset,ZLASET)
+#define LAPACK_slasrt LAPACK_GLOBAL(slasrt,SLASRT)
+#define LAPACK_dlasrt LAPACK_GLOBAL(dlasrt,DLASRT)
+#define LAPACK_slagsy LAPACK_GLOBAL(slagsy,SLAGSY)
+#define LAPACK_dlagsy LAPACK_GLOBAL(dlagsy,DLAGSY)
+#define LAPACK_clagsy LAPACK_GLOBAL(clagsy,CLAGSY)
+#define LAPACK_zlagsy LAPACK_GLOBAL(zlagsy,ZLAGSY)
+#define LAPACK_claghe LAPACK_GLOBAL(claghe,CLAGHE)
+#define LAPACK_zlaghe LAPACK_GLOBAL(zlaghe,ZLAGHE)
+#define LAPACK_slapmr LAPACK_GLOBAL(slapmr,SLAPMR)
+#define LAPACK_dlapmr LAPACK_GLOBAL(dlapmr,DLAPMR)
+#define LAPACK_clapmr LAPACK_GLOBAL(clapmr,CLAPMR)
+#define LAPACK_zlapmr LAPACK_GLOBAL(zlapmr,ZLAPMR)
+#define LAPACK_slapy2 LAPACK_GLOBAL(slapy2,SLAPY2)
+#define LAPACK_dlapy2 LAPACK_GLOBAL(dlapy2,DLAPY2)
+#define LAPACK_slapy3 LAPACK_GLOBAL(slapy3,SLAPY3)
+#define LAPACK_dlapy3 LAPACK_GLOBAL(dlapy3,DLAPY3)
+#define LAPACK_slartgp LAPACK_GLOBAL(slartgp,SLARTGP)
+#define LAPACK_dlartgp LAPACK_GLOBAL(dlartgp,DLARTGP)
+#define LAPACK_slartgs LAPACK_GLOBAL(slartgs,SLARTGS)
+#define LAPACK_dlartgs LAPACK_GLOBAL(dlartgs,DLARTGS)
+// LAPACK 3.3.0
+#define LAPACK_cbbcsd LAPACK_GLOBAL(cbbcsd,CBBCSD)
+#define LAPACK_cheswapr LAPACK_GLOBAL(cheswapr,CHESWAPR)
+#define LAPACK_chetri2 LAPACK_GLOBAL(chetri2,CHETRI2)
+#define LAPACK_chetri2x LAPACK_GLOBAL(chetri2x,CHETRI2X)
+#define LAPACK_chetrs2 LAPACK_GLOBAL(chetrs2,CHETRS2)
+#define LAPACK_csyconv LAPACK_GLOBAL(csyconv,CSYCONV)
+#define LAPACK_csyswapr LAPACK_GLOBAL(csyswapr,CSYSWAPR)
+#define LAPACK_csytri2 LAPACK_GLOBAL(csytri2,CSYTRI2)
+#define LAPACK_csytri2x LAPACK_GLOBAL(csytri2x,CSYTRI2X)
+#define LAPACK_csytrs2 LAPACK_GLOBAL(csytrs2,CSYTRS2)
+#define LAPACK_cunbdb LAPACK_GLOBAL(cunbdb,CUNBDB)
+#define LAPACK_cuncsd LAPACK_GLOBAL(cuncsd,CUNCSD)
+#define LAPACK_dbbcsd LAPACK_GLOBAL(dbbcsd,DBBCSD)
+#define LAPACK_dorbdb LAPACK_GLOBAL(dorbdb,DORBDB)
+#define LAPACK_dorcsd LAPACK_GLOBAL(dorcsd,DORCSD)
+#define LAPACK_dsyconv LAPACK_GLOBAL(dsyconv,DSYCONV)
+#define LAPACK_dsyswapr LAPACK_GLOBAL(dsyswapr,DSYSWAPR)
+#define LAPACK_dsytri2 LAPACK_GLOBAL(dsytri2,DSYTRI2)
+#define LAPACK_dsytri2x LAPACK_GLOBAL(dsytri2x,DSYTRI2X)
+#define LAPACK_dsytrs2 LAPACK_GLOBAL(dsytrs2,DSYTRS2)
+#define LAPACK_sbbcsd LAPACK_GLOBAL(sbbcsd,SBBCSD)
+#define LAPACK_sorbdb LAPACK_GLOBAL(sorbdb,SORBDB)
+#define LAPACK_sorcsd LAPACK_GLOBAL(sorcsd,SORCSD)
+#define LAPACK_ssyconv LAPACK_GLOBAL(ssyconv,SSYCONV)
+#define LAPACK_ssyswapr LAPACK_GLOBAL(ssyswapr,SSYSWAPR)
+#define LAPACK_ssytri2 LAPACK_GLOBAL(ssytri2,SSYTRI2)
+#define LAPACK_ssytri2x LAPACK_GLOBAL(ssytri2x,SSYTRI2X)
+#define LAPACK_ssytrs2 LAPACK_GLOBAL(ssytrs2,SSYTRS2)
+#define LAPACK_zbbcsd LAPACK_GLOBAL(zbbcsd,ZBBCSD)
+#define LAPACK_zheswapr LAPACK_GLOBAL(zheswapr,ZHESWAPR)
+#define LAPACK_zhetri2 LAPACK_GLOBAL(zhetri2,ZHETRI2)
+#define LAPACK_zhetri2x LAPACK_GLOBAL(zhetri2x,ZHETRI2X)
+#define LAPACK_zhetrs2 LAPACK_GLOBAL(zhetrs2,ZHETRS2)
+#define LAPACK_zsyconv LAPACK_GLOBAL(zsyconv,ZSYCONV)
+#define LAPACK_zsyswapr LAPACK_GLOBAL(zsyswapr,ZSYSWAPR)
+#define LAPACK_zsytri2 LAPACK_GLOBAL(zsytri2,ZSYTRI2)
+#define LAPACK_zsytri2x LAPACK_GLOBAL(zsytri2x,ZSYTRI2X)
+#define LAPACK_zsytrs2 LAPACK_GLOBAL(zsytrs2,ZSYTRS2)
+#define LAPACK_zunbdb LAPACK_GLOBAL(zunbdb,ZUNBDB)
+#define LAPACK_zuncsd LAPACK_GLOBAL(zuncsd,ZUNCSD)
+// LAPACK 3.4.0
+#define LAPACK_sgemqrt LAPACK_GLOBAL(sgemqrt,SGEMQRT)
+#define LAPACK_dgemqrt LAPACK_GLOBAL(dgemqrt,DGEMQRT)
+#define LAPACK_cgemqrt LAPACK_GLOBAL(cgemqrt,CGEMQRT)
+#define LAPACK_zgemqrt LAPACK_GLOBAL(zgemqrt,ZGEMQRT)
+#define LAPACK_sgeqrt LAPACK_GLOBAL(sgeqrt,SGEQRT)
+#define LAPACK_dgeqrt LAPACK_GLOBAL(dgeqrt,DGEQRT)
+#define LAPACK_cgeqrt LAPACK_GLOBAL(cgeqrt,CGEQRT)
+#define LAPACK_zgeqrt LAPACK_GLOBAL(zgeqrt,ZGEQRT)
+#define LAPACK_sgeqrt2 LAPACK_GLOBAL(sgeqrt2,SGEQRT2)
+#define LAPACK_dgeqrt2 LAPACK_GLOBAL(dgeqrt2,DGEQRT2)
+#define LAPACK_cgeqrt2 LAPACK_GLOBAL(cgeqrt2,CGEQRT2)
+#define LAPACK_zgeqrt2 LAPACK_GLOBAL(zgeqrt2,ZGEQRT2)
+#define LAPACK_sgeqrt3 LAPACK_GLOBAL(sgeqrt3,SGEQRT3)
+#define LAPACK_dgeqrt3 LAPACK_GLOBAL(dgeqrt3,DGEQRT3)
+#define LAPACK_cgeqrt3 LAPACK_GLOBAL(cgeqrt3,CGEQRT3)
+#define LAPACK_zgeqrt3 LAPACK_GLOBAL(zgeqrt3,ZGEQRT3)
+#define LAPACK_stpmqrt LAPACK_GLOBAL(stpmqrt,STPMQRT)
+#define LAPACK_dtpmqrt LAPACK_GLOBAL(dtpmqrt,DTPMQRT)
+#define LAPACK_ctpmqrt LAPACK_GLOBAL(ctpmqrt,CTPMQRT)
+#define LAPACK_ztpmqrt LAPACK_GLOBAL(ztpmqrt,ZTPMQRT)
+#define LAPACK_dtpqrt LAPACK_GLOBAL(dtpqrt,DTPQRT)
+#define LAPACK_ctpqrt LAPACK_GLOBAL(ctpqrt,CTPQRT)
+#define LAPACK_ztpqrt LAPACK_GLOBAL(ztpqrt,ZTPQRT)
+#define LAPACK_stpqrt2 LAPACK_GLOBAL(stpqrt2,STPQRT2)
+#define LAPACK_dtpqrt2 LAPACK_GLOBAL(dtpqrt2,DTPQRT2)
+#define LAPACK_ctpqrt2 LAPACK_GLOBAL(ctpqrt2,CTPQRT2)
+#define LAPACK_ztpqrt2 LAPACK_GLOBAL(ztpqrt2,ZTPQRT2)
+#define LAPACK_stprfb LAPACK_GLOBAL(stprfb,STPRFB)
+#define LAPACK_dtprfb LAPACK_GLOBAL(dtprfb,DTPRFB)
+#define LAPACK_ctprfb LAPACK_GLOBAL(ctprfb,CTPRFB)
+#define LAPACK_ztprfb LAPACK_GLOBAL(ztprfb,ZTPRFB)
+// LAPACK 3.X.X
+#define LAPACK_csyr LAPACK_GLOBAL(csyr,CSYR)
+#define LAPACK_zsyr LAPACK_GLOBAL(zsyr,ZSYR)
+
+
+void LAPACK_sgetrf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgetrf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgetrf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_zgetrf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_sgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, float* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, double* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_zgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_sgttrf( lapack_int* n, float* dl, float* d, float* du, float* du2,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgttrf( lapack_int* n, double* dl, double* d, double* du,
+                    double* du2, lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgttrf( lapack_int* n, lapack_complex_float* dl,
+                    lapack_complex_float* d, lapack_complex_float* du,
+                    lapack_complex_float* du2, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_zgttrf( lapack_int* n, lapack_complex_double* dl,
+                    lapack_complex_double* d, lapack_complex_double* du,
+                    lapack_complex_double* du2, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_spotrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dpotrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_cpotrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_zpotrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dpstrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* piv, lapack_int* rank, double* tol,
+                    double* work, lapack_int *info );
+void LAPACK_spstrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* piv, lapack_int* rank, float* tol, float* work,
+                    lapack_int *info );
+void LAPACK_zpstrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* piv, lapack_int* rank,
+                    double* tol, double* work, lapack_int *info );
+void LAPACK_cpstrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* piv, lapack_int* rank,
+                    float* tol, float* work, lapack_int *info );
+void LAPACK_dpftrf( char* transr, char* uplo, lapack_int* n, double* a,
+                    lapack_int *info );
+void LAPACK_spftrf( char* transr, char* uplo, lapack_int* n, float* a,
+                    lapack_int *info );
+void LAPACK_zpftrf( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int *info );
+void LAPACK_cpftrf( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int *info );
+void LAPACK_spptrf( char* uplo, lapack_int* n, float* ap, lapack_int *info );
+void LAPACK_dpptrf( char* uplo, lapack_int* n, double* ap, lapack_int *info );
+void LAPACK_cpptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_zpptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_spbtrf( char* uplo, lapack_int* n, lapack_int* kd, float* ab,
+                    lapack_int* ldab, lapack_int *info );
+void LAPACK_dpbtrf( char* uplo, lapack_int* n, lapack_int* kd, double* ab,
+                    lapack_int* ldab, lapack_int *info );
+void LAPACK_cpbtrf( char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_int *info );
+void LAPACK_zpbtrf( char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_int *info );
+void LAPACK_spttrf( lapack_int* n, float* d, float* e, lapack_int *info );
+void LAPACK_dpttrf( lapack_int* n, double* d, double* e, lapack_int *info );
+void LAPACK_cpttrf( lapack_int* n, float* d, lapack_complex_float* e,
+                    lapack_int *info );
+void LAPACK_zpttrf( lapack_int* n, double* d, lapack_complex_double* e,
+                    lapack_int *info );
+void LAPACK_ssytrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ipiv, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dsytrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ipiv, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_csytrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zsytrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_chetrf( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zhetrf( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ssptrf( char* uplo, lapack_int* n, float* ap, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_dsptrf( char* uplo, lapack_int* n, double* ap, lapack_int* ipiv,
+                    lapack_int *info );
+void LAPACK_csptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_zsptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_chptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_zhptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_sgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* a, lapack_int* lda, const lapack_int* ipiv,
+                    float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const lapack_int* ipiv,
+                    double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_sgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const float* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const double* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_cgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_float* ab,
+                    lapack_int* ldab, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_double* ab,
+                    lapack_int* ldab, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_sgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* dl, const float* d, const float* du,
+                    const float* du2, const lapack_int* ipiv, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* dl, const double* d, const double* du,
+                    const double* du2, const lapack_int* ipiv, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du,
+                    const lapack_complex_float* du2, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du,
+                    const lapack_complex_double* du2, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_spotrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_spftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* a, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_spptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_cpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_spbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const float* ab, lapack_int* ldab, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const double* ab, lapack_int* ldab, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_cpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_spttrs( lapack_int* n, lapack_int* nrhs, const float* d,
+                    const float* e, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dpttrs( lapack_int* n, lapack_int* nrhs, const double* d,
+                    const double* e, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_cpttrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const lapack_complex_float* e, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zpttrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const lapack_complex_double* e,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ssytrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, const lapack_int* ipiv, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dsytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const lapack_int* ipiv,
+                    double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_csytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zsytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_chetrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_zhetrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_ssptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, const lapack_int* ipiv, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dsptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, const lapack_int* ipiv, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_csptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zsptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_chptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, const lapack_int* ipiv,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zhptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, const lapack_int* ipiv,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_strtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dtrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* a, lapack_int* lda,
+                    double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_ctrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ztrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_stptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* ap, float* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_dtptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* ap, double* b,
+                    lapack_int* ldb, lapack_int *info );
+void LAPACK_ctptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* ap,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ztptrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* ap,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_stbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const float* ab,
+                    lapack_int* ldab, float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dtbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const double* ab,
+                    lapack_int* ldab, double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ctbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_ztbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_sgecon( char* norm, lapack_int* n, const float* a, lapack_int* lda,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgecon( char* norm, lapack_int* n, const double* a, lapack_int* lda,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgecon( char* norm, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* anorm, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgecon( char* norm, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, double* anorm, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const float* ab, lapack_int* ldab, const lapack_int* ipiv,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const double* ab, lapack_int* ldab, const lapack_int* ipiv,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgtcon( char* norm, lapack_int* n, const float* dl, const float* d,
+                    const float* du, const float* du2, const lapack_int* ipiv,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgtcon( char* norm, lapack_int* n, const double* dl,
+                    const double* d, const double* du, const double* du2,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgtcon( char* norm, lapack_int* n, const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du,
+                    const lapack_complex_float* du2, const lapack_int* ipiv,
+                    float* anorm, float* rcond, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zgtcon( char* norm, lapack_int* n, const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du,
+                    const lapack_complex_double* du2, const lapack_int* ipiv,
+                    double* anorm, double* rcond, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_spocon( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                    float* anorm, float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dpocon( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cpocon( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* anorm, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zpocon( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, double* anorm, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sppcon( char* uplo, lapack_int* n, const float* ap, float* anorm,
+                    float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dppcon( char* uplo, lapack_int* n, const double* ap, double* anorm,
+                    double* rcond, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cppcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    float* anorm, float* rcond, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zppcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    double* anorm, double* rcond, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_spbcon( char* uplo, lapack_int* n, lapack_int* kd, const float* ab,
+                    lapack_int* ldab, float* anorm, float* rcond, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dpbcon( char* uplo, lapack_int* n, lapack_int* kd, const double* ab,
+                    lapack_int* ldab, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cpbcon( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    float* anorm, float* rcond, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zpbcon( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    double* anorm, double* rcond, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sptcon( lapack_int* n, const float* d, const float* e, float* anorm,
+                    float* rcond, float* work, lapack_int *info );
+void LAPACK_dptcon( lapack_int* n, const double* d, const double* e,
+                    double* anorm, double* rcond, double* work,
+                    lapack_int *info );
+void LAPACK_cptcon( lapack_int* n, const float* d,
+                    const lapack_complex_float* e, float* anorm, float* rcond,
+                    float* work, lapack_int *info );
+void LAPACK_zptcon( lapack_int* n, const double* d,
+                    const lapack_complex_double* e, double* anorm,
+                    double* rcond, double* work, lapack_int *info );
+void LAPACK_ssycon( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dsycon( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_csycon( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv, float* anorm,
+                    float* rcond, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zsycon( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv, double* anorm,
+                    double* rcond, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_checon( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv, float* anorm,
+                    float* rcond, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zhecon( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv, double* anorm,
+                    double* rcond, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_sspcon( char* uplo, lapack_int* n, const float* ap,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dspcon( char* uplo, lapack_int* n, const double* ap,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cspcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zspcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_chpcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_int* ipiv, float* anorm, float* rcond,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zhpcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_int* ipiv, double* anorm, double* rcond,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_strcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const float* a, lapack_int* lda, float* rcond, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtrcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const double* a, lapack_int* lda, double* rcond,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_ctrcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    float* rcond, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztrcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    double* rcond, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const float* ap, float* rcond, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const double* ap, double* rcond, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_float* ap, float* rcond,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztpcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    const lapack_complex_double* ap, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const float* ab, lapack_int* ldab,
+                    float* rcond, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dtbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const double* ab, lapack_int* ldab,
+                    double* rcond, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const lapack_complex_float* ab,
+                    lapack_int* ldab, float* rcond, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_ztbcon( char* norm, char* uplo, char* diag, lapack_int* n,
+                    lapack_int* kd, const lapack_complex_double* ab,
+                    lapack_int* ldab, double* rcond,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* a, lapack_int* lda, const float* af,
+                    lapack_int* ldaf, const lapack_int* ipiv, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
+                    float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const double* af,
+                    lapack_int* ldaf, const lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const double* a, lapack_int* lda, const double* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const double* r,
+                     const double* c, const double* b, lapack_int* ldb,
+                     double* x, lapack_int* ldx, double* rcond, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const float* a, lapack_int* lda, const float* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const float* r,
+                     const float* c, const float* b, lapack_int* ldb, float* x,
+                     lapack_int* ldx, float* rcond, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const double* r, const double* c,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const float* r, const float* c,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const float* ab, lapack_int* ldab,
+                    const float* afb, lapack_int* ldafb, const lapack_int* ipiv,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const double* ab, lapack_int* ldab,
+                    const double* afb, lapack_int* ldafb,
+                    const lapack_int* ipiv, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_float* ab,
+                    lapack_int* ldab, const lapack_complex_float* afb,
+                    lapack_int* ldafb, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
+                    lapack_int* nrhs, const lapack_complex_double* ab,
+                    lapack_int* ldab, const lapack_complex_double* afb,
+                    lapack_int* ldafb, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_dgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, const double* ab,
+                     lapack_int* ldab, const double* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const double* r, const double* c,
+                     const double* b, lapack_int* ldb, double* x,
+                     lapack_int* ldx, double* rcond, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, const float* ab,
+                     lapack_int* ldab, const float* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const float* r, const float* c,
+                     const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params, float* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_zgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs,
+                     const lapack_complex_double* ab, lapack_int* ldab,
+                     const lapack_complex_double* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const double* r, const double* c,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs,
+                     const lapack_complex_float* ab, lapack_int* ldab,
+                     const lapack_complex_float* afb, lapack_int* ldafb,
+                     const lapack_int* ipiv, const float* r, const float* c,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* dl, const float* d, const float* du,
+                    const float* dlf, const float* df, const float* duf,
+                    const float* du2, const lapack_int* ipiv, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
+                    float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* dl, const double* d, const double* du,
+                    const double* dlf, const double* df, const double* duf,
+                    const double* du2, const lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du,
+                    const lapack_complex_float* dlf,
+                    const lapack_complex_float* df,
+                    const lapack_complex_float* duf,
+                    const lapack_complex_float* du2, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du,
+                    const lapack_complex_double* dlf,
+                    const lapack_complex_double* df,
+                    const lapack_complex_double* duf,
+                    const lapack_complex_double* du2, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sporfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, const float* af, lapack_int* ldaf,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const double* af,
+                    lapack_int* ldaf, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_dporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const double* a, lapack_int* lda, const double* af,
+                     lapack_int* ldaf, const double* s, const double* b,
+                     lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params, double* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_sporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const float* a, lapack_int* lda, const float* af,
+                     lapack_int* ldaf, const float* s, const float* b,
+                     lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const double* s, const lapack_complex_double* b,
+                     lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                     double* rcond, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const float* s, const lapack_complex_float* b,
+                     lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                     float* rcond, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_spprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, const float* afp, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
+                    float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, const double* afp, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap,
+                    const lapack_complex_float* afp,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap,
+                    const lapack_complex_double* afp,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_spbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const float* ab, lapack_int* ldab, const float* afb,
+                    lapack_int* ldafb, const float* b, lapack_int* ldb,
+                    float* x, lapack_int* ldx, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const double* ab, lapack_int* ldab, const double* afb,
+                    lapack_int* ldafb, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_complex_float* afb, lapack_int* ldafb,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_complex_double* afb, lapack_int* ldafb,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sptrfs( lapack_int* n, lapack_int* nrhs, const float* d,
+                    const float* e, const float* df, const float* ef,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int *info );
+void LAPACK_dptrfs( lapack_int* n, lapack_int* nrhs, const double* d,
+                    const double* e, const double* df, const double* ef,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* ferr, double* berr, double* work,
+                    lapack_int *info );
+void LAPACK_cptrfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const lapack_complex_float* e, const float* df,
+                    const lapack_complex_float* ef,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zptrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const lapack_complex_double* e,
+                    const double* df, const lapack_complex_double* ef,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_ssyrfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
+                    lapack_int* lda, const float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const float* b, lapack_int* ldb,
+                    float* x, lapack_int* ldx, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dsyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, const double* af,
+                    lapack_int* ldaf, const lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_csyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zsyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dsyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const double* a, lapack_int* lda, const double* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const double* s,
+                     const double* b, lapack_int* ldb, double* x,
+                     lapack_int* ldx, double* rcond, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_ssyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const float* a, lapack_int* lda, const float* af,
+                     lapack_int* ldaf, const lapack_int* ipiv, const float* s,
+                     const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params, float* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_zsyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const double* s,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_csyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const float* s,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_cherfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zherfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* af, lapack_int* ldaf,
+                    const lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_zherfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_complex_double* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const double* s,
+                     const lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cherfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
+                     const lapack_complex_float* a, lapack_int* lda,
+                     const lapack_complex_float* af, lapack_int* ldaf,
+                     const lapack_int* ipiv, const float* s,
+                     const lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_ssprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, const float* afp, const lapack_int* ipiv,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dsprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, const double* afp, const lapack_int* ipiv,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_csprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap,
+                    const lapack_complex_float* afp, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zsprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap,
+                    const lapack_complex_double* afp, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_chprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap,
+                    const lapack_complex_float* afp, const lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap,
+                    const lapack_complex_double* afp, const lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* ferr,
+                    double* berr, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_strrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* a, lapack_int* lda,
+                    const float* b, lapack_int* ldb, const float* x,
+                    lapack_int* ldx, float* ferr, float* berr, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* a, lapack_int* lda,
+                    const double* b, lapack_int* ldb, const double* x,
+                    lapack_int* ldx, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* b,
+                    lapack_int* ldb, const lapack_complex_float* x,
+                    lapack_int* ldx, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* b,
+                    lapack_int* ldb, const lapack_complex_double* x,
+                    lapack_int* ldx, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const float* ap, const float* b,
+                    lapack_int* ldb, const float* x, lapack_int* ldx,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dtprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const double* ap, const double* b,
+                    lapack_int* ldb, const double* x, lapack_int* ldx,
+                    double* ferr, double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_float* ap,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    const lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztprfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* nrhs, const lapack_complex_double* ap,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    const lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_stbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const float* ab,
+                    lapack_int* ldab, const float* b, lapack_int* ldb,
+                    const float* x, lapack_int* ldx, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dtbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs, const double* ab,
+                    lapack_int* ldab, const double* b, lapack_int* ldb,
+                    const double* x, lapack_int* ldx, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    const lapack_complex_float* x, lapack_int* ldx, float* ferr,
+                    float* berr, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
+                    lapack_int* kd, lapack_int* nrhs,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    const lapack_complex_double* x, lapack_int* ldx,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgetri( lapack_int* n, float* a, lapack_int* lda,
+                    const lapack_int* ipiv, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgetri( lapack_int* n, double* a, lapack_int* lda,
+                    const lapack_int* ipiv, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgetri( lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zgetri( lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    const lapack_int* ipiv, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_spotri( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dpotri( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_cpotri( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_zpotri( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dpftri( char* transr, char* uplo, lapack_int* n, double* a,
+                    lapack_int *info );
+void LAPACK_spftri( char* transr, char* uplo, lapack_int* n, float* a,
+                    lapack_int *info );
+void LAPACK_zpftri( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int *info );
+void LAPACK_cpftri( char* transr, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int *info );
+void LAPACK_spptri( char* uplo, lapack_int* n, float* ap, lapack_int *info );
+void LAPACK_dpptri( char* uplo, lapack_int* n, double* ap, lapack_int *info );
+void LAPACK_cpptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_zpptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_ssytri( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    const lapack_int* ipiv, float* work, lapack_int *info );
+void LAPACK_dsytri( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    const lapack_int* ipiv, double* work, lapack_int *info );
+void LAPACK_csytri( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zsytri( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_chetri( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zhetri( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, const lapack_int* ipiv,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_ssptri( char* uplo, lapack_int* n, float* ap,
+                    const lapack_int* ipiv, float* work, lapack_int *info );
+void LAPACK_dsptri( char* uplo, lapack_int* n, double* ap,
+                    const lapack_int* ipiv, double* work, lapack_int *info );
+void LAPACK_csptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    const lapack_int* ipiv, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zsptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    const lapack_int* ipiv, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_chptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    const lapack_int* ipiv, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zhptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    const lapack_int* ipiv, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_strtri( char* uplo, char* diag, lapack_int* n, float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dtrtri( char* uplo, char* diag, lapack_int* n, double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_ctrtri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_ztrtri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dtftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    double* a, lapack_int *info );
+void LAPACK_stftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    float* a, lapack_int *info );
+void LAPACK_ztftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_double* a, lapack_int *info );
+void LAPACK_ctftri( char* transr, char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_float* a, lapack_int *info );
+void LAPACK_stptri( char* uplo, char* diag, lapack_int* n, float* ap,
+                    lapack_int *info );
+void LAPACK_dtptri( char* uplo, char* diag, lapack_int* n, double* ap,
+                    lapack_int *info );
+void LAPACK_ctptri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_float* ap, lapack_int *info );
+void LAPACK_ztptri( char* uplo, char* diag, lapack_int* n,
+                    lapack_complex_double* ap, lapack_int *info );
+void LAPACK_sgeequ( lapack_int* m, lapack_int* n, const float* a,
+                    lapack_int* lda, float* r, float* c, float* rowcnd,
+                    float* colcnd, float* amax, lapack_int *info );
+void LAPACK_dgeequ( lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, double* r, double* c, double* rowcnd,
+                    double* colcnd, double* amax, lapack_int *info );
+void LAPACK_cgeequ( lapack_int* m, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* r, float* c, float* rowcnd,
+                    float* colcnd, float* amax, lapack_int *info );
+void LAPACK_zgeequ( lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* r,
+                    double* c, double* rowcnd, double* colcnd, double* amax,
+                    lapack_int *info );
+void LAPACK_dgeequb( lapack_int* m, lapack_int* n, const double* a,
+                     lapack_int* lda, double* r, double* c, double* rowcnd,
+                     double* colcnd, double* amax, lapack_int *info );
+void LAPACK_sgeequb( lapack_int* m, lapack_int* n, const float* a,
+                     lapack_int* lda, float* r, float* c, float* rowcnd,
+                     float* colcnd, float* amax, lapack_int *info );
+void LAPACK_zgeequb( lapack_int* m, lapack_int* n,
+                     const lapack_complex_double* a, lapack_int* lda, double* r,
+                     double* c, double* rowcnd, double* colcnd, double* amax,
+                     lapack_int *info );
+void LAPACK_cgeequb( lapack_int* m, lapack_int* n,
+                     const lapack_complex_float* a, lapack_int* lda, float* r,
+                     float* c, float* rowcnd, float* colcnd, float* amax,
+                     lapack_int *info );
+void LAPACK_sgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const float* ab, lapack_int* ldab, float* r,
+                    float* c, float* rowcnd, float* colcnd, float* amax,
+                    lapack_int *info );
+void LAPACK_dgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const double* ab, lapack_int* ldab,
+                    double* r, double* c, double* rowcnd, double* colcnd,
+                    double* amax, lapack_int *info );
+void LAPACK_cgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const lapack_complex_float* ab,
+                    lapack_int* ldab, float* r, float* c, float* rowcnd,
+                    float* colcnd, float* amax, lapack_int *info );
+void LAPACK_zgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const lapack_complex_double* ab,
+                    lapack_int* ldab, double* r, double* c, double* rowcnd,
+                    double* colcnd, double* amax, lapack_int *info );
+void LAPACK_dgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const double* ab, lapack_int* ldab,
+                     double* r, double* c, double* rowcnd, double* colcnd,
+                     double* amax, lapack_int *info );
+void LAPACK_sgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const float* ab, lapack_int* ldab,
+                     float* r, float* c, float* rowcnd, float* colcnd,
+                     float* amax, lapack_int *info );
+void LAPACK_zgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const lapack_complex_double* ab,
+                     lapack_int* ldab, double* r, double* c, double* rowcnd,
+                     double* colcnd, double* amax, lapack_int *info );
+void LAPACK_cgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, const lapack_complex_float* ab,
+                     lapack_int* ldab, float* r, float* c, float* rowcnd,
+                     float* colcnd, float* amax, lapack_int *info );
+void LAPACK_spoequ( lapack_int* n, const float* a, lapack_int* lda, float* s,
+                    float* scond, float* amax, lapack_int *info );
+void LAPACK_dpoequ( lapack_int* n, const double* a, lapack_int* lda, double* s,
+                    double* scond, double* amax, lapack_int *info );
+void LAPACK_cpoequ( lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, float* s, float* scond, float* amax,
+                    lapack_int *info );
+void LAPACK_zpoequ( lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, double* s, double* scond, double* amax,
+                    lapack_int *info );
+void LAPACK_dpoequb( lapack_int* n, const double* a, lapack_int* lda, double* s,
+                     double* scond, double* amax, lapack_int *info );
+void LAPACK_spoequb( lapack_int* n, const float* a, lapack_int* lda, float* s,
+                     float* scond, float* amax, lapack_int *info );
+void LAPACK_zpoequb( lapack_int* n, const lapack_complex_double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     lapack_int *info );
+void LAPACK_cpoequb( lapack_int* n, const lapack_complex_float* a,
+                     lapack_int* lda, float* s, float* scond, float* amax,
+                     lapack_int *info );
+void LAPACK_sppequ( char* uplo, lapack_int* n, const float* ap, float* s,
+                    float* scond, float* amax, lapack_int *info );
+void LAPACK_dppequ( char* uplo, lapack_int* n, const double* ap, double* s,
+                    double* scond, double* amax, lapack_int *info );
+void LAPACK_cppequ( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    float* s, float* scond, float* amax, lapack_int *info );
+void LAPACK_zppequ( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    double* s, double* scond, double* amax, lapack_int *info );
+void LAPACK_spbequ( char* uplo, lapack_int* n, lapack_int* kd, const float* ab,
+                    lapack_int* ldab, float* s, float* scond, float* amax,
+                    lapack_int *info );
+void LAPACK_dpbequ( char* uplo, lapack_int* n, lapack_int* kd, const double* ab,
+                    lapack_int* ldab, double* s, double* scond, double* amax,
+                    lapack_int *info );
+void LAPACK_cpbequ( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_float* ab, lapack_int* ldab, float* s,
+                    float* scond, float* amax, lapack_int *info );
+void LAPACK_zpbequ( char* uplo, lapack_int* n, lapack_int* kd,
+                    const lapack_complex_double* ab, lapack_int* ldab,
+                    double* s, double* scond, double* amax, lapack_int *info );
+void LAPACK_dsyequb( char* uplo, lapack_int* n, const double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     double* work, lapack_int *info );
+void LAPACK_ssyequb( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                     float* s, float* scond, float* amax, float* work,
+                     lapack_int *info );
+void LAPACK_zsyequb( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_csyequb( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                     lapack_int* lda, float* s, float* scond, float* amax,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_zheequb( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                     lapack_int* lda, double* s, double* scond, double* amax,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_cheequb( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                     lapack_int* lda, float* s, float* scond, float* amax,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_sgesv( lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda,
+                   lapack_int* ipiv, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dgesv( lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda,
+                   lapack_int* ipiv, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_float* a,
+                   lapack_int* lda, lapack_int* ipiv, lapack_complex_float* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_zgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* a,
+                   lapack_int* lda, lapack_int* ipiv, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_dsgesv( lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda,
+                    lapack_int* ipiv, double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* work, float* swork,
+                    lapack_int* iter, lapack_int *info );
+void LAPACK_zcgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    lapack_complex_double* work, lapack_complex_float* swork,
+                    double* rwork, lapack_int* iter, lapack_int *info );
+void LAPACK_sgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, float* r, float* c, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, double* r, double* c,
+                    double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, float* r, float* c,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, char* equed, double* r, double* c,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                     double* rcond, double* rpvgrw, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* r, float* c,
+                     float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* rpvgrw, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* r, float* c,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, float* ab, lapack_int* ldab,
+                   lapack_int* ipiv, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, double* ab, lapack_int* ldab,
+                   lapack_int* ipiv, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, lapack_complex_float* ab, lapack_int* ldab,
+                   lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_zgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
+                   lapack_int* nrhs, lapack_complex_double* ab,
+                   lapack_int* ldab, lapack_int* ipiv, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_sgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, float* ab,
+                    lapack_int* ldab, float* afb, lapack_int* ldafb,
+                    lapack_int* ipiv, char* equed, float* r, float* c, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, double* ab,
+                    lapack_int* ldab, double* afb, lapack_int* ldafb,
+                    lapack_int* ipiv, char* equed, double* r, double* c,
+                    double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, lapack_complex_float* ab,
+                    lapack_int* ldab, lapack_complex_float* afb,
+                    lapack_int* ldafb, lapack_int* ipiv, char* equed, float* r,
+                    float* c, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, lapack_int* nrhs, lapack_complex_double* ab,
+                    lapack_int* ldab, lapack_complex_double* afb,
+                    lapack_int* ldafb, lapack_int* ipiv, char* equed, double* r,
+                    double* c, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, double* ab,
+                     lapack_int* ldab, double* afb, lapack_int* ldafb,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     double* b, lapack_int* ldb, double* x, lapack_int* ldx,
+                     double* rcond, double* rpvgrw, double* berr,
+                     lapack_int* n_err_bnds, double* err_bnds_norm,
+                     double* err_bnds_comp, lapack_int* nparams, double* params,
+                     double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, float* ab,
+                     lapack_int* ldab, float* afb, lapack_int* ldafb,
+                     lapack_int* ipiv, char* equed, float* r, float* c,
+                     float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                     float* rcond, float* rpvgrw, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs,
+                     lapack_complex_double* ab, lapack_int* ldab,
+                     lapack_complex_double* afb, lapack_int* ldafb,
+                     lapack_int* ipiv, char* equed, double* r, double* c,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
+                     lapack_int* ku, lapack_int* nrhs, lapack_complex_float* ab,
+                     lapack_int* ldab, lapack_complex_float* afb,
+                     lapack_int* ldafb, lapack_int* ipiv, char* equed, float* r,
+                     float* c, lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sgtsv( lapack_int* n, lapack_int* nrhs, float* dl, float* d,
+                   float* du, float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dgtsv( lapack_int* n, lapack_int* nrhs, double* dl, double* d,
+                   double* du, double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cgtsv( lapack_int* n, lapack_int* nrhs, lapack_complex_float* dl,
+                   lapack_complex_float* d, lapack_complex_float* du,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zgtsv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* dl,
+                   lapack_complex_double* d, lapack_complex_double* du,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_sgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const float* dl, const float* d, const float* du,
+                    float* dlf, float* df, float* duf, float* du2,
+                    lapack_int* ipiv, const float* b, lapack_int* ldb, float* x,
+                    lapack_int* ldx, float* rcond, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const double* dl, const double* d, const double* du,
+                    double* dlf, double* df, double* duf, double* du2,
+                    lapack_int* ipiv, const double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* rcond, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* dl,
+                    const lapack_complex_float* d,
+                    const lapack_complex_float* du, lapack_complex_float* dlf,
+                    lapack_complex_float* df, lapack_complex_float* duf,
+                    lapack_complex_float* du2, lapack_int* ipiv,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* dl,
+                    const lapack_complex_double* d,
+                    const lapack_complex_double* du, lapack_complex_double* dlf,
+                    lapack_complex_double* df, lapack_complex_double* duf,
+                    lapack_complex_double* du2, lapack_int* ipiv,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sposv( char* uplo, lapack_int* n, lapack_int* nrhs, float* a,
+                   lapack_int* lda, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dposv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
+                   lapack_int* lda, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cposv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zposv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dsposv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* work, float* swork,
+                    lapack_int* iter, lapack_int *info );
+void LAPACK_zcposv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx,
+                    lapack_complex_double* work, lapack_complex_float* swork,
+                    double* rwork, lapack_int* iter, lapack_int *info );
+void LAPACK_sposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                    char* equed, float* s, float* b, lapack_int* ldb, float* x,
+                    lapack_int* ldx, float* rcond, float* ferr, float* berr,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                    char* equed, double* s, double* b, lapack_int* ldb,
+                    double* x, lapack_int* ldx, double* rcond, double* ferr,
+                    double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf, char* equed,
+                    float* s, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf, char* equed,
+                    double* s, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_dposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                     char* equed, double* s, double* b, lapack_int* ldb,
+                     double* x, lapack_int* ldx, double* rcond, double* rpvgrw,
+                     double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params, double* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_sposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                     char* equed, float* s, float* b, lapack_int* ldb, float* x,
+                     lapack_int* ldx, float* rcond, float* rpvgrw, float* berr,
+                     lapack_int* n_err_bnds, float* err_bnds_norm,
+                     float* err_bnds_comp, lapack_int* nparams, float* params,
+                     float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_zposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf, char* equed,
+                     double* s, lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_cposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf, char* equed,
+                     float* s, lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sppsv( char* uplo, lapack_int* n, lapack_int* nrhs, float* ap,
+                   float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dppsv( char* uplo, lapack_int* n, lapack_int* nrhs, double* ap,
+                   double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cppsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* ap, lapack_complex_float* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_zppsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* ap, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_sppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    float* ap, float* afp, char* equed, float* s, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    double* ap, double* afp, char* equed, double* s, double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* ap, lapack_complex_float* afp,
+                    char* equed, float* s, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* ap, lapack_complex_double* afp,
+                    char* equed, double* s, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_spbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   float* ab, lapack_int* ldab, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   double* ab, lapack_int* ldab, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   lapack_complex_float* ab, lapack_int* ldab,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
+                   lapack_complex_double* ab, lapack_int* ldab,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_spbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, float* ab, lapack_int* ldab, float* afb,
+                    lapack_int* ldafb, char* equed, float* s, float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, double* ab, lapack_int* ldab, double* afb,
+                    lapack_int* ldafb, char* equed, double* s, double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_cpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, lapack_complex_float* ab,
+                    lapack_int* ldab, lapack_complex_float* afb,
+                    lapack_int* ldafb, char* equed, float* s,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_int* nrhs, lapack_complex_double* ab,
+                    lapack_int* ldab, lapack_complex_double* afb,
+                    lapack_int* ldafb, char* equed, double* s,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sptsv( lapack_int* n, lapack_int* nrhs, float* d, float* e,
+                   float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_dptsv( lapack_int* n, lapack_int* nrhs, double* d, double* e,
+                   double* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_cptsv( lapack_int* n, lapack_int* nrhs, float* d,
+                   lapack_complex_float* e, lapack_complex_float* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_zptsv( lapack_int* n, lapack_int* nrhs, double* d,
+                   lapack_complex_double* e, lapack_complex_double* b,
+                   lapack_int* ldb, lapack_int *info );
+void LAPACK_sptsvx( char* fact, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const float* e, float* df, float* ef, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int *info );
+void LAPACK_dptsvx( char* fact, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const double* e, double* df, double* ef,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* rcond, double* ferr, double* berr,
+                    double* work, lapack_int *info );
+void LAPACK_cptsvx( char* fact, lapack_int* n, lapack_int* nrhs, const float* d,
+                    const lapack_complex_float* e, float* df,
+                    lapack_complex_float* ef, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zptsvx( char* fact, lapack_int* n, lapack_int* nrhs,
+                    const double* d, const lapack_complex_double* e, double* df,
+                    lapack_complex_double* ef, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_ssysv( char* uplo, lapack_int* n, lapack_int* nrhs, float* a,
+                   lapack_int* lda, lapack_int* ipiv, float* b, lapack_int* ldb,
+                   float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dsysv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
+                   lapack_int* lda, lapack_int* ipiv, double* b,
+                   lapack_int* ldb, double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_csysv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_zsysv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_ssysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* a, lapack_int* lda, float* af,
+                    lapack_int* ldaf, lapack_int* ipiv, const float* b,
+                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                    float* ferr, float* berr, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dsysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* a, lapack_int* lda, double* af,
+                    lapack_int* ldaf, lapack_int* ipiv, const double* b,
+                    lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                    double* ferr, double* berr, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_csysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zsysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_dsysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     double* a, lapack_int* lda, double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* s, double* b,
+                     lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params, double* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_ssysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     float* a, lapack_int* lda, float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* s, float* b,
+                     lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params, float* work,
+                     lapack_int* iwork, lapack_int *info );
+void LAPACK_zsysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* s,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_csysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* s,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_chesv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_zhesv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_chesvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhesvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* af, lapack_int* ldaf,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_zhesvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, double* s,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* x, lapack_int* ldx, double* rcond,
+                     double* rpvgrw, double* berr, lapack_int* n_err_bnds,
+                     double* err_bnds_norm, double* err_bnds_comp,
+                     lapack_int* nparams, double* params,
+                     lapack_complex_double* work, double* rwork,
+                     lapack_int *info );
+void LAPACK_chesvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* af, lapack_int* ldaf,
+                     lapack_int* ipiv, char* equed, float* s,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* x, lapack_int* ldx, float* rcond,
+                     float* rpvgrw, float* berr, lapack_int* n_err_bnds,
+                     float* err_bnds_norm, float* err_bnds_comp,
+                     lapack_int* nparams, float* params,
+                     lapack_complex_float* work, float* rwork,
+                     lapack_int *info );
+void LAPACK_sspsv( char* uplo, lapack_int* n, lapack_int* nrhs, float* ap,
+                   lapack_int* ipiv, float* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_dspsv( char* uplo, lapack_int* n, lapack_int* nrhs, double* ap,
+                   lapack_int* ipiv, double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_cspsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* ap, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zspsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* ap, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_sspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const float* ap, float* afp, lapack_int* ipiv,
+                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr, float* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const double* ap, double* afp, lapack_int* ipiv,
+                    const double* b, lapack_int* ldb, double* x,
+                    lapack_int* ldx, double* rcond, double* ferr, double* berr,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, lapack_complex_float* afp,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, lapack_complex_double* afp,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_chpsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* ap, lapack_int* ipiv,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
+void LAPACK_zhpsv( char* uplo, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* ap, lapack_int* ipiv,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_int *info );
+void LAPACK_chpsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_float* ap, lapack_complex_float* afp,
+                    lapack_int* ipiv, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
+                    float* rcond, float* ferr, float* berr,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhpsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
+                    const lapack_complex_double* ap, lapack_complex_double* afp,
+                    lapack_int* ipiv, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
+                    double* rcond, double* ferr, double* berr,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sgeqrf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgeqrf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgeqrf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgeqrf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgeqpf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* jpvt, float* tau, float* work,
+                    lapack_int *info );
+void LAPACK_dgeqpf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* jpvt, double* tau, double* work,
+                    lapack_int *info );
+void LAPACK_cgeqpf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    float* rwork, lapack_int *info );
+void LAPACK_zgeqpf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgeqp3( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* jpvt, float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgeqp3( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* jpvt, double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgeqp3( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int *info );
+void LAPACK_zgeqp3( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* jpvt,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int *info );
+void LAPACK_sorgqr( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgqr( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungqr( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungqr( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmqr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgelqf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgelqf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgelqf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgelqf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sorglq( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorglq( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cunglq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zunglq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmlq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgeqlf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgeqlf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgeqlf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgeqlf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sorgql( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgql( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungql( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungql( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cunmql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmql( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgerqf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgerqf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgerqf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgerqf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sorgrq( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgrq( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungrq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungrq( lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cunmrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmrq( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_stzrzf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dtzrzf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ctzrzf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ztzrzf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l, const float* a,
+                    lapack_int* lda, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dormrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l, const double* a,
+                    lapack_int* lda, const double* tau, double* c,
+                    lapack_int* ldc, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmrz( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* k, lapack_int* l,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sggqrf( lapack_int* n, lapack_int* m, lapack_int* p, float* a,
+                    lapack_int* lda, float* taua, float* b, lapack_int* ldb,
+                    float* taub, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dggqrf( lapack_int* n, lapack_int* m, lapack_int* p, double* a,
+                    lapack_int* lda, double* taua, double* b, lapack_int* ldb,
+                    double* taub, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cggqrf( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* taua, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* taub,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zggqrf( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* taua, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* taub,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sggrqf( lapack_int* m, lapack_int* p, lapack_int* n, float* a,
+                    lapack_int* lda, float* taua, float* b, lapack_int* ldb,
+                    float* taub, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dggrqf( lapack_int* m, lapack_int* p, lapack_int* n, double* a,
+                    lapack_int* lda, double* taua, double* b, lapack_int* ldb,
+                    double* taub, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cggrqf( lapack_int* m, lapack_int* p, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* taua, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* taub,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zggrqf( lapack_int* m, lapack_int* p, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* taua, lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* taub,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgebrd( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* d, float* e, float* tauq, float* taup, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgebrd( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* d, double* e, double* tauq, double* taup,
+                    double* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_cgebrd( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, float* d, float* e,
+                    lapack_complex_float* tauq, lapack_complex_float* taup,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zgebrd( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, double* d, double* e,
+                    lapack_complex_double* tauq, lapack_complex_double* taup,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, float* ab, lapack_int* ldab,
+                    float* d, float* e, float* q, lapack_int* ldq, float* pt,
+                    lapack_int* ldpt, float* c, lapack_int* ldc, float* work,
+                    lapack_int *info );
+void LAPACK_dgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, double* ab,
+                    lapack_int* ldab, double* d, double* e, double* q,
+                    lapack_int* ldq, double* pt, lapack_int* ldpt, double* c,
+                    lapack_int* ldc, double* work, lapack_int *info );
+void LAPACK_cgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, lapack_complex_float* ab,
+                    lapack_int* ldab, float* d, float* e,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* pt, lapack_int* ldpt,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
+                    lapack_int* kl, lapack_int* ku, lapack_complex_double* ab,
+                    lapack_int* ldab, double* d, double* e,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* pt, lapack_int* ldpt,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_sorgbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    float* a, lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorgbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    double* a, lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k, const float* a,
+                    lapack_int* lda, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dormbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k, const double* a,
+                    lapack_int* lda, const double* tau, double* c,
+                    lapack_int* ldc, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cungbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zungbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmbr( char* vect, char* side, char* trans, lapack_int* m,
+                    lapack_int* n, lapack_int* k,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, float* d, float* e,
+                    float* vt, lapack_int* ldvt, float* u, lapack_int* ldu,
+                    float* c, lapack_int* ldc, float* work, lapack_int *info );
+void LAPACK_dbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, double* d, double* e,
+                    double* vt, lapack_int* ldvt, double* u, lapack_int* ldu,
+                    double* c, lapack_int* ldc, double* work,
+                    lapack_int *info );
+void LAPACK_cbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, float* d, float* e,
+                    lapack_complex_float* vt, lapack_int* ldvt,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* c, lapack_int* ldc, float* work,
+                    lapack_int *info );
+void LAPACK_zbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
+                    lapack_int* nru, lapack_int* ncc, double* d, double* e,
+                    lapack_complex_double* vt, lapack_int* ldvt,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* c, lapack_int* ldc, double* work,
+                    lapack_int *info );
+void LAPACK_sbdsdc( char* uplo, char* compq, lapack_int* n, float* d, float* e,
+                    float* u, lapack_int* ldu, float* vt, lapack_int* ldvt,
+                    float* q, lapack_int* iq, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dbdsdc( char* uplo, char* compq, lapack_int* n, double* d,
+                    double* e, double* u, lapack_int* ldu, double* vt,
+                    lapack_int* ldvt, double* q, lapack_int* iq, double* work,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ssytrd( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    float* d, float* e, float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dsytrd( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    double* d, double* e, double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sorgtr( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    const float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dorgtr( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    const double* tau, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_sormtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const float* a, lapack_int* lda,
+                    const float* tau, float* c, lapack_int* ldc, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dormtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const double* a, lapack_int* lda,
+                    const double* tau, double* c, lapack_int* ldc, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_chetrd( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, float* d, float* e,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zhetrd( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, double* d, double* e,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cungtr( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zungtr( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_zunmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ssptrd( char* uplo, lapack_int* n, float* ap, float* d, float* e,
+                    float* tau, lapack_int *info );
+void LAPACK_dsptrd( char* uplo, lapack_int* n, double* ap, double* d, double* e,
+                    double* tau, lapack_int *info );
+void LAPACK_sopgtr( char* uplo, lapack_int* n, const float* ap,
+                    const float* tau, float* q, lapack_int* ldq, float* work,
+                    lapack_int *info );
+void LAPACK_dopgtr( char* uplo, lapack_int* n, const double* ap,
+                    const double* tau, double* q, lapack_int* ldq, double* work,
+                    lapack_int *info );
+void LAPACK_sopmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const float* ap, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int *info );
+void LAPACK_dopmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const double* ap, const double* tau,
+                    double* c, lapack_int* ldc, double* work,
+                    lapack_int *info );
+void LAPACK_chptrd( char* uplo, lapack_int* n, lapack_complex_float* ap,
+                    float* d, float* e, lapack_complex_float* tau,
+                    lapack_int *info );
+void LAPACK_zhptrd( char* uplo, lapack_int* n, lapack_complex_double* ap,
+                    double* d, double* e, lapack_complex_double* tau,
+                    lapack_int *info );
+void LAPACK_cupgtr( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_complex_float* tau, lapack_complex_float* q,
+                    lapack_int* ldq, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zupgtr( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_complex_double* tau, lapack_complex_double* q,
+                    lapack_int* ldq, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_cupmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* ap,
+                    const lapack_complex_float* tau, lapack_complex_float* c,
+                    lapack_int* ldc, lapack_complex_float* work,
+                    lapack_int *info );
+void LAPACK_zupmtr( char* side, char* uplo, char* trans, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* ap,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_ssbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    float* ab, lapack_int* ldab, float* d, float* e, float* q,
+                    lapack_int* ldq, float* work, lapack_int *info );
+void LAPACK_dsbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    double* ab, lapack_int* ldab, double* d, double* e,
+                    double* q, lapack_int* ldq, double* work,
+                    lapack_int *info );
+void LAPACK_chbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_float* ab, lapack_int* ldab, float* d,
+                    float* e, lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zhbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_double* ab, lapack_int* ldab, double* d,
+                    double* e, lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_ssterf( lapack_int* n, float* d, float* e, lapack_int *info );
+void LAPACK_dsterf( lapack_int* n, double* d, double* e, lapack_int *info );
+void LAPACK_ssteqr( char* compz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dsteqr( char* compz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_csteqr( char* compz, lapack_int* n, float* d, float* e,
+                    lapack_complex_float* z, lapack_int* ldz, float* work,
+                    lapack_int *info );
+void LAPACK_zsteqr( char* compz, lapack_int* n, double* d, double* e,
+                    lapack_complex_double* z, lapack_int* ldz, double* work,
+                    lapack_int *info );
+void LAPACK_sstemr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    lapack_int* nzc, lapack_int* isuppz, lapack_logical* tryrac,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dstemr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, lapack_int* m, double* w, double* z,
+                    lapack_int* ldz, lapack_int* nzc, lapack_int* isuppz,
+                    lapack_logical* tryrac, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cstemr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_int* nzc, lapack_int* isuppz,
+                    lapack_logical* tryrac, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_zstemr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, lapack_int* m, double* w,
+                    lapack_complex_double* z, lapack_int* ldz, lapack_int* nzc,
+                    lapack_int* isuppz, lapack_logical* tryrac, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_sstedc( char* compz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dstedc( char* compz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cstedc( char* compz, lapack_int* n, float* d, float* e,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zstedc( char* compz, lapack_int* n, double* d, double* e,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sstegr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, lapack_int* isuppz, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_dstegr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, lapack_int* isuppz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_cstegr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_int* isuppz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_zstegr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_int* isuppz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_spteqr( char* compz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dpteqr( char* compz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_cpteqr( char* compz, lapack_int* n, float* d, float* e,
+                    lapack_complex_float* z, lapack_int* ldz, float* work,
+                    lapack_int *info );
+void LAPACK_zpteqr( char* compz, lapack_int* n, double* d, double* e,
+                    lapack_complex_double* z, lapack_int* ldz, double* work,
+                    lapack_int *info );
+void LAPACK_sstebz( char* range, char* order, lapack_int* n, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    const float* d, const float* e, lapack_int* m,
+                    lapack_int* nsplit, float* w, lapack_int* iblock,
+                    lapack_int* isplit, float* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dstebz( char* range, char* order, lapack_int* n, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    const double* d, const double* e, lapack_int* m,
+                    lapack_int* nsplit, double* w, lapack_int* iblock,
+                    lapack_int* isplit, double* work, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_sstein( lapack_int* n, const float* d, const float* e,
+                    lapack_int* m, const float* w, const lapack_int* iblock,
+                    const lapack_int* isplit, float* z, lapack_int* ldz,
+                    float* work, lapack_int* iwork, lapack_int* ifailv,
+                    lapack_int *info );
+void LAPACK_dstein( lapack_int* n, const double* d, const double* e,
+                    lapack_int* m, const double* w, const lapack_int* iblock,
+                    const lapack_int* isplit, double* z, lapack_int* ldz,
+                    double* work, lapack_int* iwork, lapack_int* ifailv,
+                    lapack_int *info );
+void LAPACK_cstein( lapack_int* n, const float* d, const float* e,
+                    lapack_int* m, const float* w, const lapack_int* iblock,
+                    const lapack_int* isplit, lapack_complex_float* z,
+                    lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifailv, lapack_int *info );
+void LAPACK_zstein( lapack_int* n, const double* d, const double* e,
+                    lapack_int* m, const double* w, const lapack_int* iblock,
+                    const lapack_int* isplit, lapack_complex_double* z,
+                    lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifailv, lapack_int *info );
+void LAPACK_sdisna( char* job, lapack_int* m, lapack_int* n, const float* d,
+                    float* sep, lapack_int *info );
+void LAPACK_ddisna( char* job, lapack_int* m, lapack_int* n, const double* d,
+                    double* sep, lapack_int *info );
+void LAPACK_ssygst( lapack_int* itype, char* uplo, lapack_int* n, float* a,
+                    lapack_int* lda, const float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_dsygst( lapack_int* itype, char* uplo, lapack_int* n, double* a,
+                    lapack_int* lda, const double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_chegst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_zhegst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int *info );
+void LAPACK_sspgst( lapack_int* itype, char* uplo, lapack_int* n, float* ap,
+                    const float* bp, lapack_int *info );
+void LAPACK_dspgst( lapack_int* itype, char* uplo, lapack_int* n, double* ap,
+                    const double* bp, lapack_int *info );
+void LAPACK_chpgst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, const lapack_complex_float* bp,
+                    lapack_int *info );
+void LAPACK_zhpgst( lapack_int* itype, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, const lapack_complex_double* bp,
+                    lapack_int *info );
+void LAPACK_ssbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, float* ab, lapack_int* ldab,
+                    const float* bb, lapack_int* ldbb, float* x,
+                    lapack_int* ldx, float* work, lapack_int *info );
+void LAPACK_dsbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, double* ab, lapack_int* ldab,
+                    const double* bb, lapack_int* ldbb, double* x,
+                    lapack_int* ldx, double* work, lapack_int *info );
+void LAPACK_chbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
+                    const lapack_complex_float* bb, lapack_int* ldbb,
+                    lapack_complex_float* x, lapack_int* ldx,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
+                    const lapack_complex_double* bb, lapack_int* ldbb,
+                    lapack_complex_double* x, lapack_int* ldx,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_spbstf( char* uplo, lapack_int* n, lapack_int* kb, float* bb,
+                    lapack_int* ldbb, lapack_int *info );
+void LAPACK_dpbstf( char* uplo, lapack_int* n, lapack_int* kb, double* bb,
+                    lapack_int* ldbb, lapack_int *info );
+void LAPACK_cpbstf( char* uplo, lapack_int* n, lapack_int* kb,
+                    lapack_complex_float* bb, lapack_int* ldbb,
+                    lapack_int *info );
+void LAPACK_zpbstf( char* uplo, lapack_int* n, lapack_int* kb,
+                    lapack_complex_double* bb, lapack_int* ldbb,
+                    lapack_int *info );
+void LAPACK_sgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a,
+                    lapack_int* lda, float* tau, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a,
+                    lapack_int* lda, double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sorghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a,
+                    lapack_int* lda, const float* tau, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dorghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a,
+                    lapack_int* lda, const double* tau, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sormhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, const float* a,
+                    lapack_int* lda, const float* tau, float* c,
+                    lapack_int* ldc, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dormhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, const double* a,
+                    lapack_int* lda, const double* tau, double* c,
+                    lapack_int* ldc, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zunghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
+                    lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cunmhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* tau, lapack_complex_float* c,
+                    lapack_int* ldc, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zunmhr( char* side, char* trans, lapack_int* m, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* tau, lapack_complex_double* c,
+                    lapack_int* ldc, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sgebal( char* job, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ilo, lapack_int* ihi, float* scale,
+                    lapack_int *info );
+void LAPACK_dgebal( char* job, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ilo, lapack_int* ihi, double* scale,
+                    lapack_int *info );
+void LAPACK_cgebal( char* job, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ilo, lapack_int* ihi,
+                    float* scale, lapack_int *info );
+void LAPACK_zgebal( char* job, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ilo, lapack_int* ihi,
+                    double* scale, lapack_int *info );
+void LAPACK_sgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* scale, lapack_int* m,
+                    float* v, lapack_int* ldv, lapack_int *info );
+void LAPACK_dgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* scale, lapack_int* m,
+                    double* v, lapack_int* ldv, lapack_int *info );
+void LAPACK_cgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* scale, lapack_int* m,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_zgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* scale, lapack_int* m,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_shseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, float* h, lapack_int* ldh, float* wr,
+                    float* wi, float* z, lapack_int* ldz, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dhseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, double* h, lapack_int* ldh, double* wr,
+                    double* wi, double* z, lapack_int* ldz, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_chseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_float* h, lapack_int* ldh,
+                    lapack_complex_float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zhseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_double* h, lapack_int* ldh,
+                    lapack_complex_double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_shsein( char* job, char* eigsrc, char* initv,
+                    lapack_logical* select, lapack_int* n, const float* h,
+                    lapack_int* ldh, float* wr, const float* wi, float* vl,
+                    lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, float* work,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_dhsein( char* job, char* eigsrc, char* initv,
+                    lapack_logical* select, lapack_int* n, const double* h,
+                    lapack_int* ldh, double* wr, const double* wi, double* vl,
+                    lapack_int* ldvl, double* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, double* work,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_chsein( char* job, char* eigsrc, char* initv,
+                    const lapack_logical* select, lapack_int* n,
+                    const lapack_complex_float* h, lapack_int* ldh,
+                    lapack_complex_float* w, lapack_complex_float* vl,
+                    lapack_int* ldvl, lapack_complex_float* vr,
+                    lapack_int* ldvr, lapack_int* mm, lapack_int* m,
+                    lapack_complex_float* work, float* rwork,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_zhsein( char* job, char* eigsrc, char* initv,
+                    const lapack_logical* select, lapack_int* n,
+                    const lapack_complex_double* h, lapack_int* ldh,
+                    lapack_complex_double* w, lapack_complex_double* vl,
+                    lapack_int* ldvl, lapack_complex_double* vr,
+                    lapack_int* ldvr, lapack_int* mm, lapack_int* m,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
+void LAPACK_strevc( char* side, char* howmny, lapack_logical* select,
+                    lapack_int* n, const float* t, lapack_int* ldt, float* vl,
+                    lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, float* work,
+                    lapack_int *info );
+void LAPACK_dtrevc( char* side, char* howmny, lapack_logical* select,
+                    lapack_int* n, const double* t, lapack_int* ldt, double* vl,
+                    lapack_int* ldvl, double* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, double* work,
+                    lapack_int *info );
+void LAPACK_ctrevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* vl, lapack_int* ldvl,
+                    lapack_complex_float* vr, lapack_int* ldvr, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztrevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* vl, lapack_int* ldvl,
+                    lapack_complex_double* vr, lapack_int* ldvr, lapack_int* mm,
+                    lapack_int* m, lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_strsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const float* t, lapack_int* ldt,
+                    const float* vl, lapack_int* ldvl, const float* vr,
+                    lapack_int* ldvr, float* s, float* sep, lapack_int* mm,
+                    lapack_int* m, float* work, lapack_int* ldwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dtrsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const double* t, lapack_int* ldt,
+                    const double* vl, lapack_int* ldvl, const double* vr,
+                    lapack_int* ldvr, double* s, double* sep, lapack_int* mm,
+                    lapack_int* m, double* work, lapack_int* ldwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctrsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_float* t,
+                    lapack_int* ldt, const lapack_complex_float* vl,
+                    lapack_int* ldvl, const lapack_complex_float* vr,
+                    lapack_int* ldvr, float* s, float* sep, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work,
+                    lapack_int* ldwork, float* rwork, lapack_int *info );
+void LAPACK_ztrsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_double* t,
+                    lapack_int* ldt, const lapack_complex_double* vl,
+                    lapack_int* ldvl, const lapack_complex_double* vr,
+                    lapack_int* ldvr, double* s, double* sep, lapack_int* mm,
+                    lapack_int* m, lapack_complex_double* work,
+                    lapack_int* ldwork, double* rwork, lapack_int *info );
+void LAPACK_strexc( char* compq, lapack_int* n, float* t, lapack_int* ldt,
+                    float* q, lapack_int* ldq, lapack_int* ifst,
+                    lapack_int* ilst, float* work, lapack_int *info );
+void LAPACK_dtrexc( char* compq, lapack_int* n, double* t, lapack_int* ldt,
+                    double* q, lapack_int* ldq, lapack_int* ifst,
+                    lapack_int* ilst, double* work, lapack_int *info );
+void LAPACK_ctrexc( char* compq, lapack_int* n, lapack_complex_float* t,
+                    lapack_int* ldt, lapack_complex_float* q, lapack_int* ldq,
+                    lapack_int* ifst, lapack_int* ilst, lapack_int *info );
+void LAPACK_ztrexc( char* compq, lapack_int* n, lapack_complex_double* t,
+                    lapack_int* ldt, lapack_complex_double* q, lapack_int* ldq,
+                    lapack_int* ifst, lapack_int* ilst, lapack_int *info );
+void LAPACK_strsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, float* t, lapack_int* ldt, float* q,
+                    lapack_int* ldq, float* wr, float* wi, lapack_int* m,
+                    float* s, float* sep, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dtrsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, double* t, lapack_int* ldt, double* q,
+                    lapack_int* ldq, double* wr, double* wi, lapack_int* m,
+                    double* s, double* sep, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_ctrsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* w, lapack_int* m, float* s,
+                    float* sep, lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_ztrsen( char* job, char* compq, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* w, lapack_int* m, double* s,
+                    double* sep, lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_strsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const float* a, lapack_int* lda,
+                    const float* b, lapack_int* ldb, float* c, lapack_int* ldc,
+                    float* scale, lapack_int *info );
+void LAPACK_dtrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const double* a, lapack_int* lda,
+                    const double* b, lapack_int* ldb, double* c,
+                    lapack_int* ldc, double* scale, lapack_int *info );
+void LAPACK_ctrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* b,
+                    lapack_int* ldb, lapack_complex_float* c, lapack_int* ldc,
+                    float* scale, lapack_int *info );
+void LAPACK_ztrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* b,
+                    lapack_int* ldb, lapack_complex_double* c, lapack_int* ldc,
+                    double* scale, lapack_int *info );
+void LAPACK_sgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* q, lapack_int* ldq, float* z,
+                    lapack_int* ldz, lapack_int *info );
+void LAPACK_dgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* q, lapack_int* ldq, double* z,
+                    lapack_int* ldz, lapack_int *info );
+void LAPACK_cgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_int *info );
+void LAPACK_zgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_int *info );
+void LAPACK_sggbal( char* job, lapack_int* n, float* a, lapack_int* lda,
+                    float* b, lapack_int* ldb, lapack_int* ilo, lapack_int* ihi,
+                    float* lscale, float* rscale, float* work,
+                    lapack_int *info );
+void LAPACK_dggbal( char* job, lapack_int* n, double* a, lapack_int* lda,
+                    double* b, lapack_int* ldb, lapack_int* ilo,
+                    lapack_int* ihi, double* lscale, double* rscale,
+                    double* work, lapack_int *info );
+void LAPACK_cggbal( char* job, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                    lapack_int* ilo, lapack_int* ihi, float* lscale,
+                    float* rscale, float* work, lapack_int *info );
+void LAPACK_zggbal( char* job, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                    lapack_int* ilo, lapack_int* ihi, double* lscale,
+                    double* rscale, double* work, lapack_int *info );
+void LAPACK_sggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* lscale, const float* rscale,
+                    lapack_int* m, float* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_dggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* lscale, const double* rscale,
+                    lapack_int* m, double* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_cggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const float* lscale, const float* rscale,
+                    lapack_int* m, lapack_complex_float* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_zggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
+                    lapack_int* ihi, const double* lscale, const double* rscale,
+                    lapack_int* m, lapack_complex_double* v, lapack_int* ldv,
+                    lapack_int *info );
+void LAPACK_shgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, float* h, lapack_int* ldh,
+                    float* t, lapack_int* ldt, float* alphar, float* alphai,
+                    float* beta, float* q, lapack_int* ldq, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dhgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, double* h,
+                    lapack_int* ldh, double* t, lapack_int* ldt, double* alphar,
+                    double* alphai, double* beta, double* q, lapack_int* ldq,
+                    double* z, lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_chgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, lapack_complex_float* h,
+                    lapack_int* ldh, lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zhgeqz( char* job, char* compq, char* compz, lapack_int* n,
+                    lapack_int* ilo, lapack_int* ihi, lapack_complex_double* h,
+                    lapack_int* ldh, lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_stgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const float* s, lapack_int* lds,
+                    const float* p, lapack_int* ldp, float* vl,
+                    lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, float* work,
+                    lapack_int *info );
+void LAPACK_dtgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const double* s, lapack_int* lds,
+                    const double* p, lapack_int* ldp, double* vl,
+                    lapack_int* ldvl, double* vr, lapack_int* ldvr,
+                    lapack_int* mm, lapack_int* m, double* work,
+                    lapack_int *info );
+void LAPACK_ctgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_float* s,
+                    lapack_int* lds, const lapack_complex_float* p,
+                    lapack_int* ldp, lapack_complex_float* vl, lapack_int* ldvl,
+                    lapack_complex_float* vr, lapack_int* ldvr, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work, float* rwork,
+                    lapack_int *info );
+void LAPACK_ztgevc( char* side, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_double* s,
+                    lapack_int* lds, const lapack_complex_double* p,
+                    lapack_int* ldp, lapack_complex_double* vl,
+                    lapack_int* ldvl, lapack_complex_double* vr,
+                    lapack_int* ldvr, lapack_int* mm, lapack_int* m,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int *info );
+void LAPACK_stgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* q, lapack_int* ldq, float* z, lapack_int* ldz,
+                    lapack_int* ifst, lapack_int* ilst, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dtgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* q, lapack_int* ldq, double* z, lapack_int* ldz,
+                    lapack_int* ifst, lapack_int* ilst, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_ctgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz, lapack_int* ifst,
+                    lapack_int* ilst, lapack_int *info );
+void LAPACK_ztgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz, lapack_int* ifst,
+                    lapack_int* ilst, lapack_int *info );
+void LAPACK_stgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* alphar, float* alphai, float* beta,
+                    float* q, lapack_int* ldq, float* z, lapack_int* ldz,
+                    lapack_int* m, float* pl, float* pr, float* dif,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dtgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* alphar, double* alphai,
+                    double* beta, double* q, lapack_int* ldq, double* z,
+                    lapack_int* ldz, lapack_int* m, double* pl, double* pr,
+                    double* dif, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_ctgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* z, lapack_int* ldz, lapack_int* m,
+                    float* pl, float* pr, float* dif,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_ztgsen( lapack_int* ijob, lapack_logical* wantq,
+                    lapack_logical* wantz, const lapack_logical* select,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* z, lapack_int* ldz, lapack_int* m,
+                    double* pl, double* pr, double* dif,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_stgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const float* a, lapack_int* lda, const float* b,
+                    lapack_int* ldb, float* c, lapack_int* ldc, const float* d,
+                    lapack_int* ldd, const float* e, lapack_int* lde, float* f,
+                    lapack_int* ldf, float* scale, float* dif, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_dtgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const double* a, lapack_int* lda, const double* b,
+                    lapack_int* ldb, double* c, lapack_int* ldc,
+                    const double* d, lapack_int* ldd, const double* e,
+                    lapack_int* lde, double* f, lapack_int* ldf, double* scale,
+                    double* dif, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ctgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    const lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    const lapack_complex_float* d, lapack_int* ldd,
+                    const lapack_complex_float* e, lapack_int* lde,
+                    lapack_complex_float* f, lapack_int* ldf, float* scale,
+                    float* dif, lapack_complex_float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ztgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    const lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    const lapack_complex_double* d, lapack_int* ldd,
+                    const lapack_complex_double* e, lapack_int* lde,
+                    lapack_complex_double* f, lapack_int* ldf, double* scale,
+                    double* dif, lapack_complex_double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_stgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const float* a, lapack_int* lda,
+                    const float* b, lapack_int* ldb, const float* vl,
+                    lapack_int* ldvl, const float* vr, lapack_int* ldvr,
+                    float* s, float* dif, lapack_int* mm, lapack_int* m,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dtgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const double* a, lapack_int* lda,
+                    const double* b, lapack_int* ldb, const double* vl,
+                    lapack_int* ldvl, const double* vr, lapack_int* ldvr,
+                    double* s, double* dif, lapack_int* mm, lapack_int* m,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_ctgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, const lapack_complex_float* b,
+                    lapack_int* ldb, const lapack_complex_float* vl,
+                    lapack_int* ldvl, const lapack_complex_float* vr,
+                    lapack_int* ldvr, float* s, float* dif, lapack_int* mm,
+                    lapack_int* m, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_ztgsna( char* job, char* howmny, const lapack_logical* select,
+                    lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, const lapack_complex_double* b,
+                    lapack_int* ldb, const lapack_complex_double* vl,
+                    lapack_int* ldvl, const lapack_complex_double* vr,
+                    lapack_int* ldvr, double* s, double* dif, lapack_int* mm,
+                    lapack_int* m, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_sggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, float* a, lapack_int* lda,
+                    float* b, lapack_int* ldb, float* tola, float* tolb,
+                    lapack_int* k, lapack_int* l, float* u, lapack_int* ldu,
+                    float* v, lapack_int* ldv, float* q, lapack_int* ldq,
+                    lapack_int* iwork, float* tau, float* work,
+                    lapack_int *info );
+void LAPACK_dggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, double* a, lapack_int* lda,
+                    double* b, lapack_int* ldb, double* tola, double* tolb,
+                    lapack_int* k, lapack_int* l, double* u, lapack_int* ldu,
+                    double* v, lapack_int* ldv, double* q, lapack_int* ldq,
+                    lapack_int* iwork, double* tau, double* work,
+                    lapack_int *info );
+void LAPACK_cggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                    float* tola, float* tolb, lapack_int* k, lapack_int* l,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_complex_float* q, lapack_int* ldq, lapack_int* iwork,
+                    float* rwork, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                    double* tola, double* tolb, lapack_int* k, lapack_int* l,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_int* iwork, double* rwork,
+                    lapack_complex_double* tau, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_stgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* tola, float* tolb, float* alpha, float* beta,
+                    float* u, lapack_int* ldu, float* v, lapack_int* ldv,
+                    float* q, lapack_int* ldq, float* work, lapack_int* ncycle,
+                    lapack_int *info );
+void LAPACK_dtgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* tola, double* tolb, double* alpha, double* beta,
+                    double* u, lapack_int* ldu, double* v, lapack_int* ldv,
+                    double* q, lapack_int* ldq, double* work,
+                    lapack_int* ncycle, lapack_int *info );
+void LAPACK_ctgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* tola,
+                    float* tolb, float* alpha, float* beta,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* work, lapack_int* ncycle,
+                    lapack_int *info );
+void LAPACK_ztgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* tola,
+                    double* tolb, double* alpha, double* beta,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* work, lapack_int* ncycle,
+                    lapack_int *info );
+void LAPACK_sgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                   float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                   double* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_cgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_zgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_sgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb,
+                    lapack_int* jpvt, float* rcond, lapack_int* rank,
+                    float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb,
+                    lapack_int* jpvt, double* rcond, lapack_int* rank,
+                    double* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_cgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, lapack_int* jpvt,
+                    float* rcond, lapack_int* rank, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int *info );
+void LAPACK_zgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, lapack_int* jpvt,
+                    double* rcond, lapack_int* rank,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int *info );
+void LAPACK_zgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_dgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* s,
+                    float* rcond, lapack_int* rank, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_zgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* s,
+                    double* rcond, lapack_int* rank,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_sgglse( lapack_int* m, lapack_int* n, lapack_int* p, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* c,
+                    float* d, float* x, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dgglse( lapack_int* m, lapack_int* n, lapack_int* p, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* c,
+                    double* d, double* x, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cgglse( lapack_int* m, lapack_int* n, lapack_int* p,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* c, lapack_complex_float* d,
+                    lapack_complex_float* x, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zgglse( lapack_int* m, lapack_int* n, lapack_int* p,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* c, lapack_complex_double* d,
+                    lapack_complex_double* x, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sggglm( lapack_int* n, lapack_int* m, lapack_int* p, float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb, float* d,
+                    float* x, float* y, float* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_dggglm( lapack_int* n, lapack_int* m, lapack_int* p, double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb, double* d,
+                    double* x, double* y, double* work, lapack_int* lwork,
+                    lapack_int *info );
+void LAPACK_cggglm( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* d, lapack_complex_float* x,
+                    lapack_complex_float* y, lapack_complex_float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_zggglm( lapack_int* n, lapack_int* m, lapack_int* p,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* d, lapack_complex_double* x,
+                    lapack_complex_double* y, lapack_complex_double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_ssyev( char* jobz, char* uplo, lapack_int* n, float* a,
+                   lapack_int* lda, float* w, float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_dsyev( char* jobz, char* uplo, lapack_int* n, double* a,
+                   lapack_int* lda, double* w, double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_cheev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda, float* w,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zheev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda, double* w,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_int *info );
+void LAPACK_ssyevd( char* jobz, char* uplo, lapack_int* n, float* a,
+                    lapack_int* lda, float* w, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dsyevd( char* jobz, char* uplo, lapack_int* n, double* a,
+                    lapack_int* lda, double* w, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cheevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* w,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zheevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* w,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssyevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    float* a, lapack_int* lda, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dsyevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    double* a, lapack_int* lda, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, double* z, lapack_int* ldz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_cheevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_zheevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_ssyevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    float* a, lapack_int* lda, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    lapack_int* isuppz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dsyevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    double* a, lapack_int* lda, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, double* z, lapack_int* ldz,
+                    lapack_int* isuppz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_cheevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_int* isuppz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zheevr( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_int* isuppz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sspev( char* jobz, char* uplo, lapack_int* n, float* ap, float* w,
+                   float* z, lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dspev( char* jobz, char* uplo, lapack_int* n, double* ap, double* w,
+                   double* z, lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_chpev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* ap, float* w, lapack_complex_float* z,
+                   lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                   lapack_int *info );
+void LAPACK_zhpev( char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* ap, double* w,
+                   lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_sspevd( char* jobz, char* uplo, lapack_int* n, float* ap, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dspevd( char* jobz, char* uplo, lapack_int* n, double* ap,
+                    double* w, double* z, lapack_int* ldz, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_chpevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* lrwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_zhpevd( char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sspevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    float* ap, float* vl, float* vu, lapack_int* il,
+                    lapack_int* iu, float* abstol, lapack_int* m, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dspevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    double* ap, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_chpevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_zhpevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_ssbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   float* ab, lapack_int* ldab, float* w, float* z,
+                   lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dsbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   double* ab, lapack_int* ldab, double* w, double* z,
+                   lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_chbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   lapack_complex_float* ab, lapack_int* ldab, float* w,
+                   lapack_complex_float* z, lapack_int* ldz,
+                   lapack_complex_float* work, float* rwork, lapack_int *info );
+void LAPACK_zhbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                   lapack_complex_double* ab, lapack_int* ldab, double* w,
+                   lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_ssbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    float* ab, lapack_int* ldab, float* w, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dsbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    double* ab, lapack_int* ldab, double* w, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_chbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_float* ab, lapack_int* ldab, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
+                    lapack_complex_double* ab, lapack_int* ldab, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, float* ab, lapack_int* ldab, float* q,
+                    lapack_int* ldq, float* vl, float* vu, lapack_int* il,
+                    lapack_int* iu, float* abstol, lapack_int* m, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dsbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, double* ab, lapack_int* ldab, double* q,
+                    lapack_int* ldq, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_chbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* q, lapack_int* ldq, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_zhbevx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* kd, lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* q, lapack_int* ldq, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_sstev( char* jobz, lapack_int* n, float* d, float* e, float* z,
+                   lapack_int* ldz, float* work, lapack_int *info );
+void LAPACK_dstev( char* jobz, lapack_int* n, double* d, double* e, double* z,
+                   lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_sstevd( char* jobz, lapack_int* n, float* d, float* e, float* z,
+                    lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_dstevd( char* jobz, lapack_int* n, double* d, double* e, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_sstevx( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dstevx( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_sstevr( char* jobz, char* range, lapack_int* n, float* d, float* e,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, lapack_int* isuppz, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_dstevr( char* jobz, char* range, lapack_int* n, double* d,
+                    double* e, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, lapack_int* isuppz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sgees( char* jobvs, char* sort, LAPACK_S_SELECT2 select,
+                   lapack_int* n, float* a, lapack_int* lda, lapack_int* sdim,
+                   float* wr, float* wi, float* vs, lapack_int* ldvs,
+                   float* work, lapack_int* lwork, lapack_logical* bwork,
+                   lapack_int *info );
+void LAPACK_dgees( char* jobvs, char* sort, LAPACK_D_SELECT2 select,
+                   lapack_int* n, double* a, lapack_int* lda, lapack_int* sdim,
+                   double* wr, double* wi, double* vs, lapack_int* ldvs,
+                   double* work, lapack_int* lwork, lapack_logical* bwork,
+                   lapack_int *info );
+void LAPACK_cgees( char* jobvs, char* sort, LAPACK_C_SELECT1 select,
+                   lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                   lapack_int* sdim, lapack_complex_float* w,
+                   lapack_complex_float* vs, lapack_int* ldvs,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_logical* bwork, lapack_int *info );
+void LAPACK_zgees( char* jobvs, char* sort, LAPACK_Z_SELECT1 select,
+                   lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                   lapack_int* sdim, lapack_complex_double* w,
+                   lapack_complex_double* vs, lapack_int* ldvs,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_logical* bwork, lapack_int *info );
+void LAPACK_sgeesx( char* jobvs, char* sort, LAPACK_S_SELECT2 select,
+                    char* sense, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* sdim, float* wr, float* wi, float* vs,
+                    lapack_int* ldvs, float* rconde, float* rcondv, float* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_logical* bwork, lapack_int *info );
+void LAPACK_dgeesx( char* jobvs, char* sort, LAPACK_D_SELECT2 select,
+                    char* sense, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* sdim, double* wr, double* wi, double* vs,
+                    lapack_int* ldvs, double* rconde, double* rcondv,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_cgeesx( char* jobvs, char* sort, LAPACK_C_SELECT1 select,
+                    char* sense, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* sdim, lapack_complex_float* w,
+                    lapack_complex_float* vs, lapack_int* ldvs, float* rconde,
+                    float* rcondv, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_zgeesx( char* jobvs, char* sort, LAPACK_Z_SELECT1 select,
+                    char* sense, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* sdim, lapack_complex_double* w,
+                    lapack_complex_double* vs, lapack_int* ldvs, double* rconde,
+                    double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_sgeev( char* jobvl, char* jobvr, lapack_int* n, float* a,
+                   lapack_int* lda, float* wr, float* wi, float* vl,
+                   lapack_int* ldvl, float* vr, lapack_int* ldvr, float* work,
+                   lapack_int* lwork, lapack_int *info );
+void LAPACK_dgeev( char* jobvl, char* jobvr, lapack_int* n, double* a,
+                   lapack_int* lda, double* wr, double* wi, double* vl,
+                   lapack_int* ldvl, double* vr, lapack_int* ldvr, double* work,
+                   lapack_int* lwork, lapack_int *info );
+void LAPACK_cgeev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* w, lapack_complex_float* vl,
+                   lapack_int* ldvl, lapack_complex_float* vr, lapack_int* ldvr,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zgeev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* w, lapack_complex_double* vl,
+                   lapack_int* ldvl, lapack_complex_double* vr,
+                   lapack_int* ldvr, lapack_complex_double* work,
+                   lapack_int* lwork, double* rwork, lapack_int *info );
+void LAPACK_sgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, float* a, lapack_int* lda, float* wr,
+                    float* wi, float* vl, lapack_int* ldvl, float* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    float* scale, float* abnrm, float* rconde, float* rcondv,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_dgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, double* a, lapack_int* lda, double* wr,
+                    double* wi, double* vl, lapack_int* ldvl, double* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    double* scale, double* abnrm, double* rconde,
+                    double* rcondv, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_cgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* w, lapack_complex_float* vl,
+                    lapack_int* ldvl, lapack_complex_float* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    float* scale, float* abnrm, float* rconde, float* rcondv,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* w, lapack_complex_double* vl,
+                    lapack_int* ldvl, lapack_complex_double* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    double* scale, double* abnrm, double* rconde,
+                    double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int *info );
+void LAPACK_sgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    float* a, lapack_int* lda, float* s, float* u,
+                    lapack_int* ldu, float* vt, lapack_int* ldvt, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_dgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    double* a, lapack_int* lda, double* s, double* u,
+                    lapack_int* ldu, double* vt, lapack_int* ldvt, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_cgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* s,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* vt, lapack_int* ldvt,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int *info );
+void LAPACK_zgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* s,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* vt, lapack_int* ldvt,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int *info );
+void LAPACK_sgesdd( char* jobz, lapack_int* m, lapack_int* n, float* a,
+                    lapack_int* lda, float* s, float* u, lapack_int* ldu,
+                    float* vt, lapack_int* ldvt, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dgesdd( char* jobz, lapack_int* m, lapack_int* n, double* a,
+                    lapack_int* lda, double* s, double* u, lapack_int* ldu,
+                    double* vt, lapack_int* ldvt, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_cgesdd( char* jobz, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda, float* s,
+                    lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* vt, lapack_int* ldvt,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_zgesdd( char* jobz, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda, double* s,
+                    lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* vt, lapack_int* ldvt,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* iwork, lapack_int *info );
+void LAPACK_dgejsv( char* joba, char* jobu, char* jobv, char* jobr, char* jobt,
+                    char* jobp, lapack_int* m, lapack_int* n, double* a,
+                    lapack_int* lda, double* sva, double* u, lapack_int* ldu,
+                    double* v, lapack_int* ldv, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_sgejsv( char* joba, char* jobu, char* jobv, char* jobr, char* jobt,
+                    char* jobp, lapack_int* m, lapack_int* n, float* a,
+                    lapack_int* lda, float* sva, float* u, lapack_int* ldu,
+                    float* v, lapack_int* ldv, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_dgesvj( char* joba, char* jobu, char* jobv, lapack_int* m,
+                    lapack_int* n, double* a, lapack_int* lda, double* sva,
+                    lapack_int* mv, double* v, lapack_int* ldv, double* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sgesvj( char* joba, char* jobu, char* jobv, lapack_int* m,
+                    lapack_int* n, float* a, lapack_int* lda, float* sva,
+                    lapack_int* mv, float* v, lapack_int* ldv, float* work,
+                    lapack_int* lwork, lapack_int *info );
+void LAPACK_sggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* alpha, float* beta, float* u, lapack_int* ldu,
+                    float* v, lapack_int* ldv, float* q, lapack_int* ldq,
+                    float* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_dggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* alpha, double* beta, double* u, lapack_int* ldu,
+                    double* v, lapack_int* ldv, double* q, lapack_int* ldq,
+                    double* work, lapack_int* iwork, lapack_int *info );
+void LAPACK_cggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* alpha,
+                    float* beta, lapack_complex_float* u, lapack_int* ldu,
+                    lapack_complex_float* v, lapack_int* ldv,
+                    lapack_complex_float* q, lapack_int* ldq,
+                    lapack_complex_float* work, float* rwork, lapack_int* iwork,
+                    lapack_int *info );
+void LAPACK_zggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
+                    lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* alpha,
+                    double* beta, lapack_complex_double* u, lapack_int* ldu,
+                    lapack_complex_double* v, lapack_int* ldv,
+                    lapack_complex_double* q, lapack_int* ldq,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int *info );
+void LAPACK_ssygv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                   float* w, float* work, lapack_int* lwork, lapack_int *info );
+void LAPACK_dsygv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                   double* w, double* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_chegv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb, float* w,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zhegv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb, double* w,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_int *info );
+void LAPACK_ssygvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    float* w, float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dsygvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* w, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_chegvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* w,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhegvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* w,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssygvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* vl, float* vu, lapack_int* il,
+                    lapack_int* iu, float* abstol, lapack_int* m, float* w,
+                    float* z, lapack_int* ldz, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_dsygvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_chegvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, float* vl,
+                    float* vu, lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_zhegvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_sspgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   float* ap, float* bp, float* w, float* z, lapack_int* ldz,
+                   float* work, lapack_int *info );
+void LAPACK_dspgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   double* ap, double* bp, double* w, double* z,
+                   lapack_int* ldz, double* work, lapack_int *info );
+void LAPACK_chpgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_float* ap, lapack_complex_float* bp, float* w,
+                   lapack_complex_float* z, lapack_int* ldz,
+                   lapack_complex_float* work, float* rwork, lapack_int *info );
+void LAPACK_zhpgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                   lapack_complex_double* ap, lapack_complex_double* bp,
+                   double* w, lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_sspgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    float* ap, float* bp, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dspgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    double* ap, double* bp, double* w, double* z,
+                    lapack_int* ldz, double* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_int* liwork, lapack_int *info );
+void LAPACK_chpgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_float* ap, lapack_complex_float* bp,
+                    float* w, lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhpgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
+                    lapack_complex_double* ap, lapack_complex_double* bp,
+                    double* w, lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_sspgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, float* ap, float* bp, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* iwork, lapack_int* ifail,
+                    lapack_int *info );
+void LAPACK_dspgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, double* ap, double* bp, double* vl,
+                    double* vu, lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, double* z, lapack_int* ldz,
+                    double* work, lapack_int* iwork, lapack_int* ifail,
+                    lapack_int *info );
+void LAPACK_chpgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_float* ap,
+                    lapack_complex_float* bp, float* vl, float* vu,
+                    lapack_int* il, lapack_int* iu, float* abstol,
+                    lapack_int* m, float* w, lapack_complex_float* z,
+                    lapack_int* ldz, lapack_complex_float* work, float* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_zhpgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
+                    lapack_int* n, lapack_complex_double* ap,
+                    lapack_complex_double* bp, double* vl, double* vu,
+                    lapack_int* il, lapack_int* iu, double* abstol,
+                    lapack_int* m, double* w, lapack_complex_double* z,
+                    lapack_int* ldz, lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_ssbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, float* ab, lapack_int* ldab, float* bb,
+                   lapack_int* ldbb, float* w, float* z, lapack_int* ldz,
+                   float* work, lapack_int *info );
+void LAPACK_dsbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, double* ab, lapack_int* ldab, double* bb,
+                   lapack_int* ldbb, double* w, double* z, lapack_int* ldz,
+                   double* work, lapack_int *info );
+void LAPACK_chbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
+                   lapack_complex_float* bb, lapack_int* ldbb, float* w,
+                   lapack_complex_float* z, lapack_int* ldz,
+                   lapack_complex_float* work, float* rwork, lapack_int *info );
+void LAPACK_zhbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                   lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
+                   lapack_complex_double* bb, lapack_int* ldbb, double* w,
+                   lapack_complex_double* z, lapack_int* ldz,
+                   lapack_complex_double* work, double* rwork,
+                   lapack_int *info );
+void LAPACK_ssbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, float* ab, lapack_int* ldab, float* bb,
+                    lapack_int* ldbb, float* w, float* z, lapack_int* ldz,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_dsbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, double* ab, lapack_int* ldab, double* bb,
+                    lapack_int* ldbb, double* w, double* z, lapack_int* ldz,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_chbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
+                    lapack_complex_float* bb, lapack_int* ldbb, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
+                    lapack_int *info );
+void LAPACK_zhbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
+                    lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
+                    lapack_complex_double* bb, lapack_int* ldbb, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_int *info );
+void LAPACK_ssbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, float* ab, lapack_int* ldab,
+                    float* bb, lapack_int* ldbb, float* q, lapack_int* ldq,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w, float* z,
+                    lapack_int* ldz, float* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_dsbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, double* ab,
+                    lapack_int* ldab, double* bb, lapack_int* ldbb, double* q,
+                    lapack_int* ldq, double* vl, double* vu, lapack_int* il,
+                    lapack_int* iu, double* abstol, lapack_int* m, double* w,
+                    double* z, lapack_int* ldz, double* work, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_chbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, lapack_complex_float* ab,
+                    lapack_int* ldab, lapack_complex_float* bb,
+                    lapack_int* ldbb, lapack_complex_float* q, lapack_int* ldq,
+                    float* vl, float* vu, lapack_int* il, lapack_int* iu,
+                    float* abstol, lapack_int* m, float* w,
+                    lapack_complex_float* z, lapack_int* ldz,
+                    lapack_complex_float* work, float* rwork, lapack_int* iwork,
+                    lapack_int* ifail, lapack_int *info );
+void LAPACK_zhbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
+                    lapack_int* ka, lapack_int* kb, lapack_complex_double* ab,
+                    lapack_int* ldab, lapack_complex_double* bb,
+                    lapack_int* ldbb, lapack_complex_double* q, lapack_int* ldq,
+                    double* vl, double* vu, lapack_int* il, lapack_int* iu,
+                    double* abstol, lapack_int* m, double* w,
+                    lapack_complex_double* z, lapack_int* ldz,
+                    lapack_complex_double* work, double* rwork,
+                    lapack_int* iwork, lapack_int* ifail, lapack_int *info );
+void LAPACK_sgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_S_SELECT3 selctg, lapack_int* n, float* a,
+                   lapack_int* lda, float* b, lapack_int* ldb, lapack_int* sdim,
+                   float* alphar, float* alphai, float* beta, float* vsl,
+                   lapack_int* ldvsl, float* vsr, lapack_int* ldvsr,
+                   float* work, lapack_int* lwork, lapack_logical* bwork,
+                   lapack_int *info );
+void LAPACK_dgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_D_SELECT3 selctg, lapack_int* n, double* a,
+                   lapack_int* lda, double* b, lapack_int* ldb,
+                   lapack_int* sdim, double* alphar, double* alphai,
+                   double* beta, double* vsl, lapack_int* ldvsl, double* vsr,
+                   lapack_int* ldvsr, double* work, lapack_int* lwork,
+                   lapack_logical* bwork, lapack_int *info );
+void LAPACK_cgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_C_SELECT2 selctg, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb, lapack_int* sdim,
+                   lapack_complex_float* alpha, lapack_complex_float* beta,
+                   lapack_complex_float* vsl, lapack_int* ldvsl,
+                   lapack_complex_float* vsr, lapack_int* ldvsr,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_logical* bwork, lapack_int *info );
+void LAPACK_zgges( char* jobvsl, char* jobvsr, char* sort,
+                   LAPACK_Z_SELECT2 selctg, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb, lapack_int* sdim,
+                   lapack_complex_double* alpha, lapack_complex_double* beta,
+                   lapack_complex_double* vsl, lapack_int* ldvsl,
+                   lapack_complex_double* vsr, lapack_int* ldvsr,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_logical* bwork, lapack_int *info );
+void LAPACK_sggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_S_SELECT3 selctg, char* sense, lapack_int* n,
+                    float* a, lapack_int* lda, float* b, lapack_int* ldb,
+                    lapack_int* sdim, float* alphar, float* alphai, float* beta,
+                    float* vsl, lapack_int* ldvsl, float* vsr,
+                    lapack_int* ldvsr, float* rconde, float* rcondv,
+                    float* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_dggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_D_SELECT3 selctg, char* sense, lapack_int* n,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    lapack_int* sdim, double* alphar, double* alphai,
+                    double* beta, double* vsl, lapack_int* ldvsl, double* vsr,
+                    lapack_int* ldvsr, double* rconde, double* rcondv,
+                    double* work, lapack_int* lwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_cggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_C_SELECT2 selctg, char* sense, lapack_int* n,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb, lapack_int* sdim,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* vsl, lapack_int* ldvsl,
+                    lapack_complex_float* vsr, lapack_int* ldvsr, float* rconde,
+                    float* rcondv, lapack_complex_float* work,
+                    lapack_int* lwork, float* rwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_zggesx( char* jobvsl, char* jobvsr, char* sort,
+                    LAPACK_Z_SELECT2 selctg, char* sense, lapack_int* n,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb, lapack_int* sdim,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* vsl, lapack_int* ldvsl,
+                    lapack_complex_double* vsr, lapack_int* ldvsr,
+                    double* rconde, double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_int* liwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_sggev( char* jobvl, char* jobvr, lapack_int* n, float* a,
+                   lapack_int* lda, float* b, lapack_int* ldb, float* alphar,
+                   float* alphai, float* beta, float* vl, lapack_int* ldvl,
+                   float* vr, lapack_int* ldvr, float* work, lapack_int* lwork,
+                   lapack_int *info );
+void LAPACK_dggev( char* jobvl, char* jobvr, lapack_int* n, double* a,
+                   lapack_int* lda, double* b, lapack_int* ldb, double* alphar,
+                   double* alphai, double* beta, double* vl, lapack_int* ldvl,
+                   double* vr, lapack_int* ldvr, double* work,
+                   lapack_int* lwork, lapack_int *info );
+void LAPACK_cggev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_float* a, lapack_int* lda,
+                   lapack_complex_float* b, lapack_int* ldb,
+                   lapack_complex_float* alpha, lapack_complex_float* beta,
+                   lapack_complex_float* vl, lapack_int* ldvl,
+                   lapack_complex_float* vr, lapack_int* ldvr,
+                   lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                   lapack_int *info );
+void LAPACK_zggev( char* jobvl, char* jobvr, lapack_int* n,
+                   lapack_complex_double* a, lapack_int* lda,
+                   lapack_complex_double* b, lapack_int* ldb,
+                   lapack_complex_double* alpha, lapack_complex_double* beta,
+                   lapack_complex_double* vl, lapack_int* ldvl,
+                   lapack_complex_double* vr, lapack_int* ldvr,
+                   lapack_complex_double* work, lapack_int* lwork,
+                   double* rwork, lapack_int *info );
+void LAPACK_sggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, float* alphar, float* alphai, float* beta,
+                    float* vl, lapack_int* ldvl, float* vr, lapack_int* ldvr,
+                    lapack_int* ilo, lapack_int* ihi, float* lscale,
+                    float* rscale, float* abnrm, float* bbnrm, float* rconde,
+                    float* rcondv, float* work, lapack_int* lwork,
+                    lapack_int* iwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_dggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, double* alphar, double* alphai,
+                    double* beta, double* vl, lapack_int* ldvl, double* vr,
+                    lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
+                    double* lscale, double* rscale, double* abnrm,
+                    double* bbnrm, double* rconde, double* rcondv, double* work,
+                    lapack_int* lwork, lapack_int* iwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_cggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* vl, lapack_int* ldvl,
+                    lapack_complex_float* vr, lapack_int* ldvr, lapack_int* ilo,
+                    lapack_int* ihi, float* lscale, float* rscale, float* abnrm,
+                    float* bbnrm, float* rconde, float* rcondv,
+                    lapack_complex_float* work, lapack_int* lwork, float* rwork,
+                    lapack_int* iwork, lapack_logical* bwork,
+                    lapack_int *info );
+void LAPACK_zggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
+                    lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* vl, lapack_int* ldvl,
+                    lapack_complex_double* vr, lapack_int* ldvr,
+                    lapack_int* ilo, lapack_int* ihi, double* lscale,
+                    double* rscale, double* abnrm, double* bbnrm,
+                    double* rconde, double* rcondv, lapack_complex_double* work,
+                    lapack_int* lwork, double* rwork, lapack_int* iwork,
+                    lapack_logical* bwork, lapack_int *info );
+void LAPACK_dsfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, double* alpha, const double* a,
+                   lapack_int* lda, double* beta, double* c );
+void LAPACK_ssfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, float* alpha, const float* a, lapack_int* lda,
+                   float* beta, float* c );
+void LAPACK_zhfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, double* alpha, const lapack_complex_double* a,
+                   lapack_int* lda, double* beta, lapack_complex_double* c );
+void LAPACK_chfrk( char* transr, char* uplo, char* trans, lapack_int* n,
+                   lapack_int* k, float* alpha, const lapack_complex_float* a,
+                   lapack_int* lda, float* beta, lapack_complex_float* c );
+void LAPACK_dtfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n, double* alpha,
+                   const double* a, double* b, lapack_int* ldb );
+void LAPACK_stfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n, float* alpha,
+                   const float* a, float* b, lapack_int* ldb );
+void LAPACK_ztfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n,
+                   lapack_complex_double* alpha, const lapack_complex_double* a,
+                   lapack_complex_double* b, lapack_int* ldb );
+void LAPACK_ctfsm( char* transr, char* side, char* uplo, char* trans,
+                   char* diag, lapack_int* m, lapack_int* n,
+                   lapack_complex_float* alpha, const lapack_complex_float* a,
+                   lapack_complex_float* b, lapack_int* ldb );
+void LAPACK_dtfttp( char* transr, char* uplo, lapack_int* n, const double* arf,
+                    double* ap, lapack_int *info );
+void LAPACK_stfttp( char* transr, char* uplo, lapack_int* n, const float* arf,
+                    float* ap, lapack_int *info );
+void LAPACK_ztfttp( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* arf, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_ctfttp( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* arf, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_dtfttr( char* transr, char* uplo, lapack_int* n, const double* arf,
+                    double* a, lapack_int* lda, lapack_int *info );
+void LAPACK_stfttr( char* transr, char* uplo, lapack_int* n, const float* arf,
+                    float* a, lapack_int* lda, lapack_int *info );
+void LAPACK_ztfttr( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* arf, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_ctfttr( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* arf, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_dtpttf( char* transr, char* uplo, lapack_int* n, const double* ap,
+                    double* arf, lapack_int *info );
+void LAPACK_stpttf( char* transr, char* uplo, lapack_int* n, const float* ap,
+                    float* arf, lapack_int *info );
+void LAPACK_ztpttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* ap, lapack_complex_double* arf,
+                    lapack_int *info );
+void LAPACK_ctpttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* ap, lapack_complex_float* arf,
+                    lapack_int *info );
+void LAPACK_dtpttr( char* uplo, lapack_int* n, const double* ap, double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_stpttr( char* uplo, lapack_int* n, const float* ap, float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_ztpttr( char* uplo, lapack_int* n, const lapack_complex_double* ap,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_ctpttr( char* uplo, lapack_int* n, const lapack_complex_float* ap,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dtrttf( char* transr, char* uplo, lapack_int* n, const double* a,
+                    lapack_int* lda, double* arf, lapack_int *info );
+void LAPACK_strttf( char* transr, char* uplo, lapack_int* n, const float* a,
+                    lapack_int* lda, float* arf, lapack_int *info );
+void LAPACK_ztrttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* arf, lapack_int *info );
+void LAPACK_ctrttf( char* transr, char* uplo, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* arf, lapack_int *info );
+void LAPACK_dtrttp( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
+                    double* ap, lapack_int *info );
+void LAPACK_strttp( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
+                    float* ap, lapack_int *info );
+void LAPACK_ztrttp( char* uplo, lapack_int* n, const lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* ap,
+                    lapack_int *info );
+void LAPACK_ctrttp( char* uplo, lapack_int* n, const lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* ap,
+                    lapack_int *info );
+void LAPACK_sgeqrfp( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* tau, float* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_dgeqrfp( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* tau, double* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_cgeqrfp( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* tau,
+                     lapack_complex_float* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_zgeqrfp( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* tau,
+                     lapack_complex_double* work, lapack_int* lwork,
+                     lapack_int *info );
+void LAPACK_clacgv( lapack_int* n, lapack_complex_float* x, lapack_int* incx );
+void LAPACK_zlacgv( lapack_int* n, lapack_complex_double* x, lapack_int* incx );
+void LAPACK_slarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    float* x );
+void LAPACK_dlarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    double* x );
+void LAPACK_clarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    lapack_complex_float* x );
+void LAPACK_zlarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
+                    lapack_complex_double* x );
+void LAPACK_sgeqr2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int *info );
+void LAPACK_dgeqr2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int *info );
+void LAPACK_cgeqr2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgeqr2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slacpy( char* uplo, lapack_int* m, lapack_int* n, const float* a,
+                    lapack_int* lda, float* b, lapack_int* ldb );
+void LAPACK_dlacpy( char* uplo, lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, double* b, lapack_int* ldb );
+void LAPACK_clacpy( char* uplo, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb );
+void LAPACK_zlacpy( char* uplo, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb );
+void LAPACK_sgetf2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_dgetf2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int* ipiv, lapack_int *info );
+void LAPACK_cgetf2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_zgetf2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* ipiv, lapack_int *info );
+void LAPACK_slaswp( lapack_int* n, float* a, lapack_int* lda, lapack_int* k1,
+                    lapack_int* k2, const lapack_int* ipiv, lapack_int* incx );
+void LAPACK_dlaswp( lapack_int* n, double* a, lapack_int* lda, lapack_int* k1,
+                    lapack_int* k2, const lapack_int* ipiv, lapack_int* incx );
+void LAPACK_claswp( lapack_int* n, lapack_complex_float* a, lapack_int* lda,
+                    lapack_int* k1, lapack_int* k2, const lapack_int* ipiv,
+                    lapack_int* incx );
+void LAPACK_zlaswp( lapack_int* n, lapack_complex_double* a, lapack_int* lda,
+                    lapack_int* k1, lapack_int* k2, const lapack_int* ipiv,
+                    lapack_int* incx );
+float LAPACK_slange( char* norm, lapack_int* m, lapack_int* n, const float* a,
+                    lapack_int* lda, float* work );
+double LAPACK_dlange( char* norm, lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, double* work );
+float LAPACK_clange( char* norm, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda, float* work );
+double LAPACK_zlange( char* norm, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* work );
+float LAPACK_clanhe( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda, float* work );
+double LAPACK_zlanhe( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* work );
+float LAPACK_slansy( char* norm, char* uplo, lapack_int* n, const float* a,
+                    lapack_int* lda, float* work );
+double LAPACK_dlansy( char* norm, char* uplo, lapack_int* n, const double* a,
+                    lapack_int* lda, double* work );
+float LAPACK_clansy( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_float* a, lapack_int* lda, float* work );
+double LAPACK_zlansy( char* norm, char* uplo, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda, double* work );
+float LAPACK_slantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const float* a, lapack_int* lda, float* work );
+double LAPACK_dlantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const double* a, lapack_int* lda, double* work );
+float LAPACK_clantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const lapack_complex_float* a, lapack_int* lda,
+                    float* work );
+double LAPACK_zlantr( char* norm, char* uplo, char* diag, lapack_int* m,
+                    lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
+                    double* work );
+float LAPACK_slamch( char* cmach );
+double LAPACK_dlamch( char* cmach );
+void LAPACK_sgelq2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                    float* tau, float* work, lapack_int *info );
+void LAPACK_dgelq2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                    double* tau, double* work, lapack_int *info );
+void LAPACK_cgelq2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_complex_float* tau,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgelq2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_complex_double* tau,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, const float* v,
+                    lapack_int* ldv, const float* t, lapack_int* ldt, float* c,
+                    lapack_int* ldc, float* work, lapack_int* ldwork );
+void LAPACK_dlarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k,
+                    const double* v, lapack_int* ldv, const double* t,
+                    lapack_int* ldt, double* c, lapack_int* ldc, double* work,
+                    lapack_int* ldwork );
+void LAPACK_clarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k,
+                    const lapack_complex_float* v, lapack_int* ldv,
+                    const lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work, lapack_int* ldwork );
+void LAPACK_zlarfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k,
+                    const lapack_complex_double* v, lapack_int* ldv,
+                    const lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work, lapack_int* ldwork );
+void LAPACK_slarfg( lapack_int* n, float* alpha, float* x, lapack_int* incx,
+                    float* tau );
+void LAPACK_dlarfg( lapack_int* n, double* alpha, double* x, lapack_int* incx,
+                    double* tau );
+void LAPACK_clarfg( lapack_int* n, lapack_complex_float* alpha,
+                    lapack_complex_float* x, lapack_int* incx,
+                    lapack_complex_float* tau );
+void LAPACK_zlarfg( lapack_int* n, lapack_complex_double* alpha,
+                    lapack_complex_double* x, lapack_int* incx,
+                    lapack_complex_double* tau );
+void LAPACK_slarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const float* v, lapack_int* ldv, const float* tau, float* t,
+                    lapack_int* ldt );
+void LAPACK_dlarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const double* v, lapack_int* ldv, const double* tau,
+                    double* t, lapack_int* ldt );
+void LAPACK_clarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const lapack_complex_float* v, lapack_int* ldv,
+                    const lapack_complex_float* tau, lapack_complex_float* t,
+                    lapack_int* ldt );
+void LAPACK_zlarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
+                    const lapack_complex_double* v, lapack_int* ldv,
+                    const lapack_complex_double* tau, lapack_complex_double* t,
+                    lapack_int* ldt );
+void LAPACK_slarfx( char* side, lapack_int* m, lapack_int* n, const float* v,
+                    float* tau, float* c, lapack_int* ldc, float* work );
+void LAPACK_dlarfx( char* side, lapack_int* m, lapack_int* n, const double* v,
+                    double* tau, double* c, lapack_int* ldc, double* work );
+void LAPACK_clarfx( char* side, lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* v, lapack_complex_float* tau,
+                    lapack_complex_float* c, lapack_int* ldc,
+                    lapack_complex_float* work );
+void LAPACK_zlarfx( char* side, lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* v, lapack_complex_double* tau,
+                    lapack_complex_double* c, lapack_int* ldc,
+                    lapack_complex_double* work );
+void LAPACK_slatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, float* d, lapack_int* mode, float* cond,
+                    float* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    float* a, lapack_int* lda, float* work, lapack_int *info );
+void LAPACK_dlatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, double* d, lapack_int* mode, double* cond,
+                    double* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    double* a, lapack_int* lda, double* work,
+                    lapack_int *info );
+void LAPACK_clatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, float* d, lapack_int* mode, float* cond,
+                    float* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
+                    char* sym, double* d, lapack_int* mode, double* cond,
+                    double* dmax, lapack_int* kl, lapack_int* ku, char* pack,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slag2d( lapack_int* m, lapack_int* n, const float* sa,
+                    lapack_int* ldsa, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dlag2s( lapack_int* m, lapack_int* n, const double* a,
+                    lapack_int* lda, float* sa, lapack_int* ldsa,
+                    lapack_int *info );
+void LAPACK_clag2z( lapack_int* m, lapack_int* n,
+                    const lapack_complex_float* sa, lapack_int* ldsa,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_zlag2c( lapack_int* m, lapack_int* n,
+                    const lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_float* sa, lapack_int* ldsa,
+                    lapack_int *info );
+void LAPACK_slauum( char* uplo, lapack_int* n, float* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_dlauum( char* uplo, lapack_int* n, double* a, lapack_int* lda,
+                    lapack_int *info );
+void LAPACK_clauum( char* uplo, lapack_int* n, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_zlauum( char* uplo, lapack_int* n, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int *info );
+void LAPACK_slagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const float* d, float* a, lapack_int* lda,
+                    lapack_int* iseed, float* work, lapack_int *info );
+void LAPACK_dlagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const double* d, double* a, lapack_int* lda,
+                    lapack_int* iseed, double* work, lapack_int *info );
+void LAPACK_clagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const float* d, lapack_complex_float* a,
+                    lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlagge( lapack_int* m, lapack_int* n, lapack_int* kl,
+                    lapack_int* ku, const double* d, lapack_complex_double* a,
+                    lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_slaset( char* uplo, lapack_int* m, lapack_int* n, float* alpha,
+                    float* beta, float* a, lapack_int* lda );
+void LAPACK_dlaset( char* uplo, lapack_int* m, lapack_int* n, double* alpha,
+                    double* beta, double* a, lapack_int* lda );
+void LAPACK_claset( char* uplo, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* alpha, lapack_complex_float* beta,
+                    lapack_complex_float* a, lapack_int* lda );
+void LAPACK_zlaset( char* uplo, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* alpha, lapack_complex_double* beta,
+                    lapack_complex_double* a, lapack_int* lda );
+void LAPACK_slasrt( char* id, lapack_int* n, float* d, lapack_int *info );
+void LAPACK_dlasrt( char* id, lapack_int* n, double* d, lapack_int *info );
+void LAPACK_claghe( lapack_int* n, lapack_int* k, const float* d,
+                    lapack_complex_float* a, lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlaghe( lapack_int* n, lapack_int* k, const double* d,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int* iseed, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_slagsy( lapack_int* n, lapack_int* k, const float* d, float* a,
+                    lapack_int* lda, lapack_int* iseed, float* work,
+                    lapack_int *info );
+void LAPACK_dlagsy( lapack_int* n, lapack_int* k, const double* d, double* a,
+                    lapack_int* lda, lapack_int* iseed, double* work,
+                    lapack_int *info );
+void LAPACK_clagsy( lapack_int* n, lapack_int* k, const float* d,
+                    lapack_complex_float* a, lapack_int* lda, lapack_int* iseed,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zlagsy( lapack_int* n, lapack_int* k, const double* d,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_int* iseed, lapack_complex_double* work,
+                    lapack_int *info );
+void LAPACK_slapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    float* x, lapack_int* ldx, lapack_int* k );
+void LAPACK_dlapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    double* x, lapack_int* ldx, lapack_int* k );
+void LAPACK_clapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    lapack_complex_float* x, lapack_int* ldx, lapack_int* k );
+void LAPACK_zlapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
+                    lapack_complex_double* x, lapack_int* ldx, lapack_int* k );
+float LAPACK_slapy2( float* x, float* y );
+double LAPACK_dlapy2( double* x, double* y );
+float LAPACK_slapy3( float* x, float* y, float* z );
+double LAPACK_dlapy3( double* x, double* y, double* z );
+void LAPACK_slartgp( float* f, float* g, float* cs, float* sn, float* r );
+void LAPACK_dlartgp( double* f, double* g, double* cs, double* sn, double* r );
+void LAPACK_slartgs( float* x, float* y, float* sigma, float* cs, float* sn );
+void LAPACK_dlartgs( double* x, double* y, double* sigma, double* cs,
+                     double* sn );
+// LAPACK 3.3.0
+void LAPACK_cbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    float* theta, float* phi,
+                    lapack_complex_float* u1, lapack_int* ldu1,
+                    lapack_complex_float* u2, lapack_int* ldu2,
+                    lapack_complex_float* v1t, lapack_int* ldv1t,
+                    lapack_complex_float* v2t, lapack_int* ldv2t,
+                    float* b11d, float* b11e, float* b12d,
+                    float* b12e, float* b21d, float* b21e,
+                    float* b22d, float* b22e, float* rwork,
+                    lapack_int* lrwork , lapack_int *info );
+void LAPACK_cheswapr( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_chetri2( char* uplo, lapack_int* n,
+                     lapack_complex_float* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_chetri2x( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_float* work, lapack_int* nb , lapack_int *info );
+void LAPACK_chetrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const lapack_complex_float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* work , lapack_int *info );
+void LAPACK_csyconv( char* uplo, char* way,
+                     lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_float* work , lapack_int *info );
+void LAPACK_csyswapr( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_csytri2( char* uplo, lapack_int* n,
+                     lapack_complex_float* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_csytri2x( char* uplo, lapack_int* n,
+                      lapack_complex_float* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_float* work, lapack_int* nb , lapack_int *info );
+void LAPACK_csytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const lapack_complex_float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* work , lapack_int *info );
+void LAPACK_cunbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    lapack_complex_float* x11, lapack_int* ldx11,
+                    lapack_complex_float* x12, lapack_int* ldx12,
+                    lapack_complex_float* x21, lapack_int* ldx21,
+                    lapack_complex_float* x22, lapack_int* ldx22,
+                    float* theta, float* phi,
+                    lapack_complex_float* taup1,
+                    lapack_complex_float* taup2,
+                    lapack_complex_float* tauq1,
+                    lapack_complex_float* tauq2,
+                    lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_cuncsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, lapack_complex_float* x11,
+                    lapack_int* ldx11, lapack_complex_float* x12,
+                    lapack_int* ldx12, lapack_complex_float* x21,
+                    lapack_int* ldx21, lapack_complex_float* x22,
+                    lapack_int* ldx22, float* theta,
+                    lapack_complex_float* u1, lapack_int* ldu1,
+                    lapack_complex_float* u2, lapack_int* ldu2,
+                    lapack_complex_float* v1t, lapack_int* ldv1t,
+                    lapack_complex_float* v2t, lapack_int* ldv2t,
+                    lapack_complex_float* work, lapack_int* lwork,
+                    float* rwork, lapack_int* lrwork,
+                    lapack_int* iwork , lapack_int *info );
+void LAPACK_dbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    double* theta, double* phi, double* u1,
+                    lapack_int* ldu1, double* u2, lapack_int* ldu2,
+                    double* v1t, lapack_int* ldv1t, double* v2t,
+                    lapack_int* ldv2t, double* b11d, double* b11e,
+                    double* b12d, double* b12e, double* b21d,
+                    double* b21e, double* b22d, double* b22e,
+                    double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_dorbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    double* x11, lapack_int* ldx11, double* x12,
+                    lapack_int* ldx12, double* x21, lapack_int* ldx21,
+                    double* x22, lapack_int* ldx22, double* theta,
+                    double* phi, double* taup1, double* taup2,
+                    double* tauq1, double* tauq2, double* work,
+                    lapack_int* lwork , lapack_int *info );
+void LAPACK_dorcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, double* x11, lapack_int* ldx11,
+                    double* x12, lapack_int* ldx12, double* x21,
+                    lapack_int* ldx21, double* x22, lapack_int* ldx22,
+                    double* theta, double* u1, lapack_int* ldu1,
+                    double* u2, lapack_int* ldu2, double* v1t,
+                    lapack_int* ldv1t, double* v2t, lapack_int* ldv2t,
+                    double* work, lapack_int* lwork,
+                    lapack_int* iwork , lapack_int *info );
+void LAPACK_dsyconv( char* uplo, char* way,
+                     lapack_int* n, double* a, lapack_int* lda,
+                     const lapack_int* ipiv, double* work , lapack_int *info );
+void LAPACK_dsyswapr( char* uplo, lapack_int* n,
+                      double* a, lapack_int* i1, lapack_int* i2 );
+void LAPACK_dsytri2( char* uplo, lapack_int* n,
+                     double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_dsytri2x( char* uplo, lapack_int* n,
+                      double* a, lapack_int* lda,
+                      const lapack_int* ipiv, double* work,
+                      lapack_int* nb , lapack_int *info );
+void LAPACK_dsytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const double* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     double* b, lapack_int* ldb, double* work , lapack_int *info );
+void LAPACK_sbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    float* theta, float* phi, float* u1,
+                    lapack_int* ldu1, float* u2, lapack_int* ldu2,
+                    float* v1t, lapack_int* ldv1t, float* v2t,
+                    lapack_int* ldv2t, float* b11d, float* b11e,
+                    float* b12d, float* b12e, float* b21d,
+                    float* b21e, float* b22d, float* b22e,
+                    float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_sorbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    float* x11, lapack_int* ldx11, float* x12,
+                    lapack_int* ldx12, float* x21, lapack_int* ldx21,
+                    float* x22, lapack_int* ldx22, float* theta,
+                    float* phi, float* taup1, float* taup2,
+                    float* tauq1, float* tauq2, float* work,
+                    lapack_int* lwork , lapack_int *info );
+void LAPACK_sorcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, float* x11, lapack_int* ldx11,
+                    float* x12, lapack_int* ldx12, float* x21,
+                    lapack_int* ldx21, float* x22, lapack_int* ldx22,
+                    float* theta, float* u1, lapack_int* ldu1,
+                    float* u2, lapack_int* ldu2, float* v1t,
+                    lapack_int* ldv1t, float* v2t, lapack_int* ldv2t,
+                    float* work, lapack_int* lwork,
+                    lapack_int* iwork , lapack_int *info );
+void LAPACK_ssyconv( char* uplo, char* way,
+                     lapack_int* n, float* a, lapack_int* lda,
+                     const lapack_int* ipiv, float* work , lapack_int *info );
+void LAPACK_ssyswapr( char* uplo, lapack_int* n,
+                      float* a, lapack_int* i1, lapack_int* i2 );
+void LAPACK_ssytri2( char* uplo, lapack_int* n,
+                     float* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_ssytri2x( char* uplo, lapack_int* n,
+                      float* a, lapack_int* lda,
+                      const lapack_int* ipiv, float* work,
+                      lapack_int* nb , lapack_int *info );
+void LAPACK_ssytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs, const float* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     float* b, lapack_int* ldb, float* work , lapack_int *info );
+void LAPACK_zbbcsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    double* theta, double* phi,
+                    lapack_complex_double* u1, lapack_int* ldu1,
+                    lapack_complex_double* u2, lapack_int* ldu2,
+                    lapack_complex_double* v1t, lapack_int* ldv1t,
+                    lapack_complex_double* v2t, lapack_int* ldv2t,
+                    double* b11d, double* b11e, double* b12d,
+                    double* b12e, double* b21d, double* b21e,
+                    double* b22d, double* b22e, double* rwork,
+                    lapack_int* lrwork , lapack_int *info );
+void LAPACK_zheswapr( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_zhetri2( char* uplo, lapack_int* n,
+                     lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_zhetri2x( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_double* work, lapack_int* nb , lapack_int *info );
+void LAPACK_zhetrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* work , lapack_int *info );
+void LAPACK_zsyconv( char* uplo, char* way,
+                     lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, const lapack_int* ipiv,
+                     lapack_complex_double* work , lapack_int *info );
+void LAPACK_zsyswapr( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* i1,
+                      lapack_int* i2 );
+void LAPACK_zsytri2( char* uplo, lapack_int* n,
+                     lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_zsytri2x( char* uplo, lapack_int* n,
+                      lapack_complex_double* a, lapack_int* lda,
+                      const lapack_int* ipiv,
+                      lapack_complex_double* work, lapack_int* nb , lapack_int *info );
+void LAPACK_zsytrs2( char* uplo, lapack_int* n,
+                     lapack_int* nrhs,
+                     const lapack_complex_double* a, lapack_int* lda,
+                     const lapack_int* ipiv,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* work , lapack_int *info );
+void LAPACK_zunbdb( char* trans, char* signs,
+                    lapack_int* m, lapack_int* p, lapack_int* q,
+                    lapack_complex_double* x11, lapack_int* ldx11,
+                    lapack_complex_double* x12, lapack_int* ldx12,
+                    lapack_complex_double* x21, lapack_int* ldx21,
+                    lapack_complex_double* x22, lapack_int* ldx22,
+                    double* theta, double* phi,
+                    lapack_complex_double* taup1,
+                    lapack_complex_double* taup2,
+                    lapack_complex_double* tauq1,
+                    lapack_complex_double* tauq2,
+                    lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
+void LAPACK_zuncsd( char* jobu1, char* jobu2,
+                    char* jobv1t, char* jobv2t, char* trans,
+                    char* signs, lapack_int* m, lapack_int* p,
+                    lapack_int* q, lapack_complex_double* x11,
+                    lapack_int* ldx11, lapack_complex_double* x12,
+                    lapack_int* ldx12, lapack_complex_double* x21,
+                    lapack_int* ldx21, lapack_complex_double* x22,
+                    lapack_int* ldx22, double* theta,
+                    lapack_complex_double* u1, lapack_int* ldu1,
+                    lapack_complex_double* u2, lapack_int* ldu2,
+                    lapack_complex_double* v1t, lapack_int* ldv1t,
+                    lapack_complex_double* v2t, lapack_int* ldv2t,
+                    lapack_complex_double* work, lapack_int* lwork,
+                    double* rwork, lapack_int* lrwork,
+                    lapack_int* iwork , lapack_int *info );
+// LAPACK 3.4.0
+void LAPACK_sgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb, const float* v,
+                     lapack_int* ldv, const float* t, lapack_int* ldt, float* c,
+                     lapack_int* ldc, float* work, lapack_int *info );
+void LAPACK_dgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb, const double* v,
+                     lapack_int* ldv, const double* t, lapack_int* ldt,
+                     double* c, lapack_int* ldc, double* work,
+                     lapack_int *info );
+void LAPACK_cgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb,
+                     const lapack_complex_float* v, lapack_int* ldv,
+                     const lapack_complex_float* t, lapack_int* ldt,
+                     lapack_complex_float* c, lapack_int* ldc,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* nb,
+                     const lapack_complex_double* v, lapack_int* ldv,
+                     const lapack_complex_double* t, lapack_int* ldt,
+                     lapack_complex_double* c, lapack_int* ldc,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_sgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb, float* a,
+                    lapack_int* lda, float* t, lapack_int* ldt, float* work,
+                    lapack_int *info );
+void LAPACK_dgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb, double* a,
+                    lapack_int* lda, double* t, lapack_int* ldt, double* work,
+                    lapack_int *info );
+void LAPACK_cgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_zgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_sgeqrt2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_dgeqrt2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_cgeqrt2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_zgeqrt2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_sgeqrt3( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_dgeqrt3( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* t, lapack_int* ldt, lapack_int *info );
+void LAPACK_cgeqrt3( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_zgeqrt3( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_stpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const float* v, lapack_int* ldv, const float* t,
+                     lapack_int* ldt, float* a, lapack_int* lda, float* b,
+                     lapack_int* ldb, float* work, lapack_int *info );
+void LAPACK_dtpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const double* v, lapack_int* ldv, const double* t,
+                     lapack_int* ldt, double* a, lapack_int* lda, double* b,
+                     lapack_int* ldb, double* work, lapack_int *info );
+void LAPACK_ctpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const lapack_complex_float* v, lapack_int* ldv,
+                     const lapack_complex_float* t, lapack_int* ldt,
+                     lapack_complex_float* a, lapack_int* lda,
+                     lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* work, lapack_int *info );
+void LAPACK_ztpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
+                     lapack_int* k, lapack_int* l, lapack_int* nb,
+                     const lapack_complex_double* v, lapack_int* ldv,
+                     const lapack_complex_double* t, lapack_int* ldt,
+                     lapack_complex_double* a, lapack_int* lda,
+                     lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* work, lapack_int *info );
+void LAPACK_dtpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
+                    double* a, lapack_int* lda, double* b, lapack_int* ldb,
+                    double* t, lapack_int* ldt, double* work,
+                    lapack_int *info );
+void LAPACK_ctpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* t, lapack_complex_float* b,
+                    lapack_int* ldb, lapack_int* ldt,
+                    lapack_complex_float* work, lapack_int *info );
+void LAPACK_ztpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* work, lapack_int *info );
+void LAPACK_stpqrt2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
+                     float* b, lapack_int* ldb, float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_dtpqrt2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
+                     double* b, lapack_int* ldb, double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_ctpqrt2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
+                     lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
+                     lapack_complex_float* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_ztpqrt2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
+                     lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
+                     lapack_complex_double* t, lapack_int* ldt,
+                     lapack_int *info );
+void LAPACK_stprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const float* v, lapack_int* ldv, const float* t,
+                    lapack_int* ldt, float* a, lapack_int* lda, float* b,
+                    lapack_int* ldb, const float* mywork,
+                    lapack_int* myldwork );
+void LAPACK_dtprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const double* v, lapack_int* ldv, const double* t,
+                    lapack_int* ldt, double* a, lapack_int* lda, double* b,
+                    lapack_int* ldb, const double* mywork,
+                    lapack_int* myldwork );
+void LAPACK_ctprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const lapack_complex_float* v, lapack_int* ldv,
+                    const lapack_complex_float* t, lapack_int* ldt,
+                    lapack_complex_float* a, lapack_int* lda,
+                    lapack_complex_float* b, lapack_int* ldb,
+                    const float* mywork, lapack_int* myldwork );
+void LAPACK_ztprfb( char* side, char* trans, char* direct, char* storev,
+                    lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
+                    const lapack_complex_double* v, lapack_int* ldv,
+                    const lapack_complex_double* t, lapack_int* ldt,
+                    lapack_complex_double* a, lapack_int* lda,
+                    lapack_complex_double* b, lapack_int* ldb,
+                    const double* mywork, lapack_int* myldwork );
+// LAPACK 3.X.X
+void LAPACK_csyr( char* uplo, lapack_int* n, lapack_complex_float* alpha,
+                      const lapack_complex_float* x, lapack_int* incx,
+                      lapack_complex_float* a, lapack_int* lda );
+void LAPACK_zsyr( char* uplo, lapack_int* n, lapack_complex_double* alpha,
+                      const lapack_complex_double* x, lapack_int* incx,
+                      lapack_complex_double* a, lapack_int* lda );
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _LAPACKE_H_ */
+
+#endif /* _MKL_LAPACKE_H_ */
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/misc/lapacke_mangling.h b/C++/yolo_bytetrack_old/include/Eigen/src/misc/lapacke_mangling.h
new file mode 100644
index 00000000..6211fd14
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/misc/lapacke_mangling.h
@@ -0,0 +1,17 @@
+#ifndef LAPACK_HEADER_INCLUDED
+#define LAPACK_HEADER_INCLUDED
+
+#ifndef LAPACK_GLOBAL
+#if defined(LAPACK_GLOBAL_PATTERN_LC) || defined(ADD_)
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname##_
+#elif defined(LAPACK_GLOBAL_PATTERN_UC) || defined(UPPER)
+#define LAPACK_GLOBAL(lcname,UCNAME)  UCNAME
+#elif defined(LAPACK_GLOBAL_PATTERN_MC) || defined(NOCHANGE)
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname
+#else
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname##_
+#endif
+#endif
+
+#endif
+
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/plugins/ArrayCwiseBinaryOps.h b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
new file mode 100644
index 00000000..0e5d5445
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/ArrayCwiseBinaryOps.h
@@ -0,0 +1,358 @@
+
+/** \returns an expression of the coefficient wise product of \c *this and \a other
+  *
+  * \sa MatrixBase::cwiseProduct
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)
+operator*(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient wise quotient of \c *this and \a other
+  *
+  * \sa MatrixBase::cwiseQuotient
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar,typename OtherDerived::Scalar>, const Derived, const OtherDerived>
+operator/(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_quotient_op<Scalar,typename OtherDerived::Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise min of \c *this and \a other
+  *
+  * Example: \include Cwise_min.cpp
+  * Output: \verbinclude Cwise_min.out
+  *
+  * \sa max()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(min,min)
+
+/** \returns an expression of the coefficient-wise min of \c *this and scalar \a other
+  *
+  * \sa max()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived,
+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+min
+#else
+(min)
+#endif
+(const Scalar &other) const
+{
+  return (min)(Derived::PlainObject::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise max of \c *this and \a other
+  *
+  * Example: \include Cwise_max.cpp
+  * Output: \verbinclude Cwise_max.out
+  *
+  * \sa min()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(max,max)
+
+/** \returns an expression of the coefficient-wise max of \c *this and scalar \a other
+  *
+  * \sa min()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived,
+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+max
+#else
+(max)
+#endif
+(const Scalar &other) const
+{
+  return (max)(Derived::PlainObject::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise absdiff of \c *this and \a other
+  *
+  * Example: \include Cwise_absolute_difference.cpp
+  * Output: \verbinclude Cwise_absolute_difference.out
+  *
+  * \sa absolute_difference()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(absolute_difference,absolute_difference)
+
+/** \returns an expression of the coefficient-wise absolute_difference of \c *this and scalar \a other
+  *
+  * \sa absolute_difference()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_absolute_difference_op<Scalar,Scalar>, const Derived,
+                                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> >
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+absolute_difference
+#else
+(absolute_difference)
+#endif
+(const Scalar &other) const
+{
+  return (absolute_difference)(Derived::PlainObject::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise power of \c *this to the given array of \a exponents.
+  *
+  * This function computes the coefficient-wise power.
+  *
+  * Example: \include Cwise_array_power_array.cpp
+  * Output: \verbinclude Cwise_array_power_array.out
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(pow,pow)
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(pow,pow)
+#else
+/** \returns an expression of the coefficients of \c *this rasied to the constant power \a exponent
+  *
+  * \tparam T is the scalar type of \a exponent. It must be compatible with the scalar type of the given expression.
+  *
+  * This function computes the coefficient-wise power. The function MatrixBase::pow() in the
+  * unsupported module MatrixFunctions computes the matrix power.
+  *
+  * Example: \include Cwise_pow.cpp
+  * Output: \verbinclude Cwise_pow.out
+  *
+  * \sa ArrayBase::pow(ArrayBase), square(), cube(), exp(), log()
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_pow_op<Scalar,T>,Derived,Constant<T> > pow(const T& exponent) const;
+#endif
+
+
+// TODO code generating macros could be moved to Macros.h and could include generation of documentation
+#define EIGEN_MAKE_CWISE_COMP_OP(OP, COMPARATOR) \
+template<typename OtherDerived> \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_cmp_op<Scalar, typename OtherDerived::Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const OtherDerived> \
+OP(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
+{ \
+  return CwiseBinaryOp<internal::scalar_cmp_op<Scalar, typename OtherDerived::Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const OtherDerived>(derived(), other.derived()); \
+}\
+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar, internal::cmp_ ## COMPARATOR>, const Derived, const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> > Cmp ## COMPARATOR ## ReturnType; \
+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar, internal::cmp_ ## COMPARATOR>, const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject>, const Derived > RCmp ## COMPARATOR ## ReturnType; \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Cmp ## COMPARATOR ## ReturnType \
+OP(const Scalar& s) const { \
+  return this->OP(Derived::PlainObject::Constant(rows(), cols(), s)); \
+} \
+EIGEN_DEVICE_FUNC friend EIGEN_STRONG_INLINE const RCmp ## COMPARATOR ## ReturnType \
+OP(const Scalar& s, const EIGEN_CURRENT_STORAGE_BASE_CLASS<Derived>& d) { \
+  return Derived::PlainObject::Constant(d.rows(), d.cols(), s).OP(d); \
+}
+
+#define EIGEN_MAKE_CWISE_COMP_R_OP(OP, R_OP, RCOMPARATOR) \
+template<typename OtherDerived> \
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_cmp_op<typename OtherDerived::Scalar, Scalar, internal::cmp_##RCOMPARATOR>, const OtherDerived, const Derived> \
+OP(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
+{ \
+  return CwiseBinaryOp<internal::scalar_cmp_op<typename OtherDerived::Scalar, Scalar, internal::cmp_##RCOMPARATOR>, const OtherDerived, const Derived>(other.derived(), derived()); \
+} \
+EIGEN_DEVICE_FUNC \
+inline const RCmp ## RCOMPARATOR ## ReturnType \
+OP(const Scalar& s) const { \
+  return Derived::PlainObject::Constant(rows(), cols(), s).R_OP(*this); \
+} \
+friend inline const Cmp ## RCOMPARATOR ## ReturnType \
+OP(const Scalar& s, const Derived& d) { \
+  return d.R_OP(Derived::PlainObject::Constant(d.rows(), d.cols(), s)); \
+}
+
+
+
+/** \returns an expression of the coefficient-wise \< operator of *this and \a other
+  *
+  * Example: \include Cwise_less.cpp
+  * Output: \verbinclude Cwise_less.out
+  *
+  * \sa all(), any(), operator>(), operator<=()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator<, LT)
+
+/** \returns an expression of the coefficient-wise \<= operator of *this and \a other
+  *
+  * Example: \include Cwise_less_equal.cpp
+  * Output: \verbinclude Cwise_less_equal.out
+  *
+  * \sa all(), any(), operator>=(), operator<()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator<=, LE)
+
+/** \returns an expression of the coefficient-wise \> operator of *this and \a other
+  *
+  * Example: \include Cwise_greater.cpp
+  * Output: \verbinclude Cwise_greater.out
+  *
+  * \sa all(), any(), operator>=(), operator<()
+  */
+EIGEN_MAKE_CWISE_COMP_R_OP(operator>, operator<, LT)
+
+/** \returns an expression of the coefficient-wise \>= operator of *this and \a other
+  *
+  * Example: \include Cwise_greater_equal.cpp
+  * Output: \verbinclude Cwise_greater_equal.out
+  *
+  * \sa all(), any(), operator>(), operator<=()
+  */
+EIGEN_MAKE_CWISE_COMP_R_OP(operator>=, operator<=, LE)
+
+/** \returns an expression of the coefficient-wise == operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include Cwise_equal_equal.cpp
+  * Output: \verbinclude Cwise_equal_equal.out
+  *
+  * \sa all(), any(), isApprox(), isMuchSmallerThan()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator==, EQ)
+
+/** \returns an expression of the coefficient-wise != operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include Cwise_not_equal.cpp
+  * Output: \verbinclude Cwise_not_equal.out
+  *
+  * \sa all(), any(), isApprox(), isMuchSmallerThan()
+  */
+EIGEN_MAKE_CWISE_COMP_OP(operator!=, NEQ)
+
+
+#undef EIGEN_MAKE_CWISE_COMP_OP
+#undef EIGEN_MAKE_CWISE_COMP_R_OP
+
+// scalar addition
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP(operator+,sum)
+#else
+/** \returns an expression of \c *this with each coeff incremented by the constant \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  *
+  * Example: \include Cwise_plus.cpp
+  * Output: \verbinclude Cwise_plus.out
+  *
+  * \sa operator+=(), operator-()
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_sum_op<Scalar,T>,Derived,Constant<T> > operator+(const T& scalar) const;
+/** \returns an expression of \a expr with each coeff incremented by the constant \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T> friend
+const CwiseBinaryOp<internal::scalar_sum_op<T,Scalar>,Constant<T>,Derived> operator+(const T& scalar, const StorageBaseType& expr);
+#endif
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP(operator-,difference)
+#else
+/** \returns an expression of \c *this with each coeff decremented by the constant \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  *
+  * Example: \include Cwise_minus.cpp
+  * Output: \verbinclude Cwise_minus.out
+  *
+  * \sa operator+=(), operator-()
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_difference_op<Scalar,T>,Derived,Constant<T> > operator-(const T& scalar) const;
+/** \returns an expression of the constant matrix of value \a scalar decremented by the coefficients of \a expr
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T> friend
+const CwiseBinaryOp<internal::scalar_difference_op<T,Scalar>,Constant<T>,Derived> operator-(const T& scalar, const StorageBaseType& expr);
+#endif
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(operator/,quotient)
+#else
+  /**
+    * \brief Component-wise division of the scalar \a s by array elements of \a a.
+    *
+    * \tparam Scalar is the scalar type of \a x. It must be compatible with the scalar type of the given array expression (\c Derived::Scalar).
+    */
+  template<typename T> friend
+  inline const CwiseBinaryOp<internal::scalar_quotient_op<T,Scalar>,Constant<T>,Derived>
+  operator/(const T& s,const StorageBaseType& a);
+#endif
+
+/** \returns an expression of the coefficient-wise ^ operator of *this and \a other
+ *
+ * \warning this operator is for expression of bool only.
+ *
+ * Example: \include Cwise_boolean_xor.cpp
+ * Output: \verbinclude Cwise_boolean_xor.out
+ *
+ * \sa operator&&(), select()
+ */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<internal::scalar_boolean_xor_op, const Derived, const OtherDerived>
+operator^(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return CwiseBinaryOp<internal::scalar_boolean_xor_op, const Derived, const OtherDerived>(derived(),other.derived());
+}
+
+// NOTE disabled until we agree on argument order
+#if 0
+/** \cpp11 \returns an expression of the coefficient-wise polygamma function.
+  *
+  * \specialfunctions_module
+  *
+  * It returns the \a n -th derivative of the digamma(psi) evaluated at \c *this.
+  *
+  * \warning Be careful with the order of the parameters: x.polygamma(n) is equivalent to polygamma(n,x)
+  *
+  * \sa Eigen::polygamma()
+  */
+template<typename DerivedN>
+inline const CwiseBinaryOp<internal::scalar_polygamma_op<Scalar>, const DerivedN, const Derived>
+polygamma(const EIGEN_CURRENT_STORAGE_BASE_CLASS<DerivedN> &n) const
+{
+  return CwiseBinaryOp<internal::scalar_polygamma_op<Scalar>, const DerivedN, const Derived>(n.derived(), this->derived());
+}
+#endif
+
+/** \returns an expression of the coefficient-wise zeta function.
+  *
+  * \specialfunctions_module
+  *
+  * It returns the Riemann zeta function of two arguments \c *this and \a q:
+  *
+  * \param q is the shift, it must be > 0
+  *
+  * \note *this is the exponent, it must be > 1.
+  * \note This function supports only float and double scalar types. To support other scalar types, the user has
+  * to provide implementations of zeta(T,T) for any scalar type T to be supported.
+  *
+  * This method is an alias for zeta(*this,q);
+  *
+  * \sa Eigen::zeta()
+  */
+template<typename DerivedQ>
+inline const CwiseBinaryOp<internal::scalar_zeta_op<Scalar>, const Derived, const DerivedQ>
+zeta(const EIGEN_CURRENT_STORAGE_BASE_CLASS<DerivedQ> &q) const
+{
+  return CwiseBinaryOp<internal::scalar_zeta_op<Scalar>, const Derived, const DerivedQ>(this->derived(), q.derived());
+}
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/plugins/ArrayCwiseUnaryOps.h b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
new file mode 100644
index 00000000..13c55f4b
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/ArrayCwiseUnaryOps.h
@@ -0,0 +1,696 @@
+
+
+typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> AbsReturnType;
+typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> ArgReturnType;
+typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> Abs2ReturnType;
+typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> SqrtReturnType;
+typedef CwiseUnaryOp<internal::scalar_rsqrt_op<Scalar>, const Derived> RsqrtReturnType;
+typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> SignReturnType;
+typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> InverseReturnType;
+typedef CwiseUnaryOp<internal::scalar_boolean_not_op<Scalar>, const Derived> BooleanNotReturnType;
+
+typedef CwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived> ExpReturnType;
+typedef CwiseUnaryOp<internal::scalar_expm1_op<Scalar>, const Derived> Expm1ReturnType;
+typedef CwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived> LogReturnType;
+typedef CwiseUnaryOp<internal::scalar_log1p_op<Scalar>, const Derived> Log1pReturnType;
+typedef CwiseUnaryOp<internal::scalar_log10_op<Scalar>, const Derived> Log10ReturnType;
+typedef CwiseUnaryOp<internal::scalar_log2_op<Scalar>, const Derived> Log2ReturnType;
+typedef CwiseUnaryOp<internal::scalar_cos_op<Scalar>, const Derived> CosReturnType;
+typedef CwiseUnaryOp<internal::scalar_sin_op<Scalar>, const Derived> SinReturnType;
+typedef CwiseUnaryOp<internal::scalar_tan_op<Scalar>, const Derived> TanReturnType;
+typedef CwiseUnaryOp<internal::scalar_acos_op<Scalar>, const Derived> AcosReturnType;
+typedef CwiseUnaryOp<internal::scalar_asin_op<Scalar>, const Derived> AsinReturnType;
+typedef CwiseUnaryOp<internal::scalar_atan_op<Scalar>, const Derived> AtanReturnType;
+typedef CwiseUnaryOp<internal::scalar_tanh_op<Scalar>, const Derived> TanhReturnType;
+typedef CwiseUnaryOp<internal::scalar_logistic_op<Scalar>, const Derived> LogisticReturnType;
+typedef CwiseUnaryOp<internal::scalar_sinh_op<Scalar>, const Derived> SinhReturnType;
+#if EIGEN_HAS_CXX11_MATH
+typedef CwiseUnaryOp<internal::scalar_atanh_op<Scalar>, const Derived> AtanhReturnType;
+typedef CwiseUnaryOp<internal::scalar_asinh_op<Scalar>, const Derived> AsinhReturnType;
+typedef CwiseUnaryOp<internal::scalar_acosh_op<Scalar>, const Derived> AcoshReturnType;
+#endif
+typedef CwiseUnaryOp<internal::scalar_cosh_op<Scalar>, const Derived> CoshReturnType;
+typedef CwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived> SquareReturnType;
+typedef CwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived> CubeReturnType;
+typedef CwiseUnaryOp<internal::scalar_round_op<Scalar>, const Derived> RoundReturnType;
+typedef CwiseUnaryOp<internal::scalar_rint_op<Scalar>, const Derived> RintReturnType;
+typedef CwiseUnaryOp<internal::scalar_floor_op<Scalar>, const Derived> FloorReturnType;
+typedef CwiseUnaryOp<internal::scalar_ceil_op<Scalar>, const Derived> CeilReturnType;
+typedef CwiseUnaryOp<internal::scalar_isnan_op<Scalar>, const Derived> IsNaNReturnType;
+typedef CwiseUnaryOp<internal::scalar_isinf_op<Scalar>, const Derived> IsInfReturnType;
+typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar>, const Derived> IsFiniteReturnType;
+
+/** \returns an expression of the coefficient-wise absolute value of \c *this
+  *
+  * Example: \include Cwise_abs.cpp
+  * Output: \verbinclude Cwise_abs.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs">Math functions</a>, abs2()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const AbsReturnType
+abs() const
+{
+  return AbsReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise phase angle of \c *this
+  *
+  * Example: \include Cwise_arg.cpp
+  * Output: \verbinclude Cwise_arg.out
+  *
+  * \sa abs()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const ArgReturnType
+arg() const
+{
+  return ArgReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise squared absolute value of \c *this
+  *
+  * Example: \include Cwise_abs2.cpp
+  * Output: \verbinclude Cwise_abs2.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs2">Math functions</a>, abs(), square()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const Abs2ReturnType
+abs2() const
+{
+  return Abs2ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise exponential of *this.
+  *
+  * This function computes the coefficient-wise exponential. The function MatrixBase::exp() in the
+  * unsupported module MatrixFunctions computes the matrix exponential.
+  *
+  * Example: \include Cwise_exp.cpp
+  * Output: \verbinclude Cwise_exp.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_exp">Math functions</a>, pow(), log(), sin(), cos()
+  */
+EIGEN_DEVICE_FUNC
+inline const ExpReturnType
+exp() const
+{
+  return ExpReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise exponential of *this minus 1.
+  *
+  * In exact arithmetic, \c x.expm1() is equivalent to \c x.exp() - 1,
+  * however, with finite precision, this function is much more accurate when \c x is close to zero.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_expm1">Math functions</a>, exp()
+  */
+EIGEN_DEVICE_FUNC
+inline const Expm1ReturnType
+expm1() const
+{
+  return Expm1ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise logarithm of *this.
+  *
+  * This function computes the coefficient-wise logarithm. The function MatrixBase::log() in the
+  * unsupported module MatrixFunctions computes the matrix logarithm.
+  *
+  * Example: \include Cwise_log.cpp
+  * Output: \verbinclude Cwise_log.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log">Math functions</a>, log()
+  */
+EIGEN_DEVICE_FUNC
+inline const LogReturnType
+log() const
+{
+  return LogReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise logarithm of 1 plus \c *this.
+  *
+  * In exact arithmetic, \c x.log() is equivalent to \c (x+1).log(),
+  * however, with finite precision, this function is much more accurate when \c x is close to zero.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log1p">Math functions</a>, log()
+  */
+EIGEN_DEVICE_FUNC
+inline const Log1pReturnType
+log1p() const
+{
+  return Log1pReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise base-10 logarithm of *this.
+  *
+  * This function computes the coefficient-wise base-10 logarithm.
+  *
+  * Example: \include Cwise_log10.cpp
+  * Output: \verbinclude Cwise_log10.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log10">Math functions</a>, log()
+  */
+EIGEN_DEVICE_FUNC
+inline const Log10ReturnType
+log10() const
+{
+  return Log10ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise base-2 logarithm of *this.
+  *
+  * This function computes the coefficient-wise base-2 logarithm.
+  *
+  */
+EIGEN_DEVICE_FUNC
+inline const Log2ReturnType
+log2() const
+{
+  return Log2ReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise square root of *this.
+  *
+  * This function computes the coefficient-wise square root. The function MatrixBase::sqrt() in the
+  * unsupported module MatrixFunctions computes the matrix square root.
+  *
+  * Example: \include Cwise_sqrt.cpp
+  * Output: \verbinclude Cwise_sqrt.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sqrt">Math functions</a>, pow(), square()
+  */
+EIGEN_DEVICE_FUNC
+inline const SqrtReturnType
+sqrt() const
+{
+  return SqrtReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse square root of *this.
+  *
+  * This function computes the coefficient-wise inverse square root.
+  *
+  * Example: \include Cwise_sqrt.cpp
+  * Output: \verbinclude Cwise_sqrt.out
+  *
+  * \sa pow(), square()
+  */
+EIGEN_DEVICE_FUNC
+inline const RsqrtReturnType
+rsqrt() const
+{
+  return RsqrtReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise signum of *this.
+  *
+  * This function computes the coefficient-wise signum.
+  *
+  * Example: \include Cwise_sign.cpp
+  * Output: \verbinclude Cwise_sign.out
+  *
+  * \sa pow(), square()
+  */
+EIGEN_DEVICE_FUNC
+inline const SignReturnType
+sign() const
+{
+  return SignReturnType(derived());
+}
+
+
+/** \returns an expression of the coefficient-wise cosine of *this.
+  *
+  * This function computes the coefficient-wise cosine. The function MatrixBase::cos() in the
+  * unsupported module MatrixFunctions computes the matrix cosine.
+  *
+  * Example: \include Cwise_cos.cpp
+  * Output: \verbinclude Cwise_cos.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cos">Math functions</a>, sin(), acos()
+  */
+EIGEN_DEVICE_FUNC
+inline const CosReturnType
+cos() const
+{
+  return CosReturnType(derived());
+}
+
+
+/** \returns an expression of the coefficient-wise sine of *this.
+  *
+  * This function computes the coefficient-wise sine. The function MatrixBase::sin() in the
+  * unsupported module MatrixFunctions computes the matrix sine.
+  *
+  * Example: \include Cwise_sin.cpp
+  * Output: \verbinclude Cwise_sin.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sin">Math functions</a>, cos(), asin()
+  */
+EIGEN_DEVICE_FUNC
+inline const SinReturnType
+sin() const
+{
+  return SinReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise tan of *this.
+  *
+  * Example: \include Cwise_tan.cpp
+  * Output: \verbinclude Cwise_tan.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tan">Math functions</a>, cos(), sin()
+  */
+EIGEN_DEVICE_FUNC
+inline const TanReturnType
+tan() const
+{
+  return TanReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise arc tan of *this.
+  *
+  * Example: \include Cwise_atan.cpp
+  * Output: \verbinclude Cwise_atan.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atan">Math functions</a>, tan(), asin(), acos()
+  */
+EIGEN_DEVICE_FUNC
+inline const AtanReturnType
+atan() const
+{
+  return AtanReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise arc cosine of *this.
+  *
+  * Example: \include Cwise_acos.cpp
+  * Output: \verbinclude Cwise_acos.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acos">Math functions</a>, cos(), asin()
+  */
+EIGEN_DEVICE_FUNC
+inline const AcosReturnType
+acos() const
+{
+  return AcosReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise arc sine of *this.
+  *
+  * Example: \include Cwise_asin.cpp
+  * Output: \verbinclude Cwise_asin.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asin">Math functions</a>, sin(), acos()
+  */
+EIGEN_DEVICE_FUNC
+inline const AsinReturnType
+asin() const
+{
+  return AsinReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise hyperbolic tan of *this.
+  *
+  * Example: \include Cwise_tanh.cpp
+  * Output: \verbinclude Cwise_tanh.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tanh">Math functions</a>, tan(), sinh(), cosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const TanhReturnType
+tanh() const
+{
+  return TanhReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise hyperbolic sin of *this.
+  *
+  * Example: \include Cwise_sinh.cpp
+  * Output: \verbinclude Cwise_sinh.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sinh">Math functions</a>, sin(), tanh(), cosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const SinhReturnType
+sinh() const
+{
+  return SinhReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise hyperbolic cos of *this.
+  *
+  * Example: \include Cwise_cosh.cpp
+  * Output: \verbinclude Cwise_cosh.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cosh">Math functions</a>, tanh(), sinh(), cosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const CoshReturnType
+cosh() const
+{
+  return CoshReturnType(derived());
+}
+
+#if EIGEN_HAS_CXX11_MATH
+/** \returns an expression of the coefficient-wise inverse hyperbolic tan of *this.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atanh">Math functions</a>, atanh(), asinh(), acosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const AtanhReturnType
+atanh() const
+{
+  return AtanhReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse hyperbolic sin of *this.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asinh">Math functions</a>, atanh(), asinh(), acosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const AsinhReturnType
+asinh() const
+{
+  return AsinhReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse hyperbolic cos of *this.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acosh">Math functions</a>, atanh(), asinh(), acosh()
+  */
+EIGEN_DEVICE_FUNC
+inline const AcoshReturnType
+acosh() const
+{
+  return AcoshReturnType(derived());
+}
+#endif
+
+/** \returns an expression of the coefficient-wise logistic of *this.
+  */
+EIGEN_DEVICE_FUNC
+inline const LogisticReturnType
+logistic() const
+{
+  return LogisticReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse of *this.
+  *
+  * Example: \include Cwise_inverse.cpp
+  * Output: \verbinclude Cwise_inverse.out
+  *
+  * \sa operator/(), operator*()
+  */
+EIGEN_DEVICE_FUNC
+inline const InverseReturnType
+inverse() const
+{
+  return InverseReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise square of *this.
+  *
+  * Example: \include Cwise_square.cpp
+  * Output: \verbinclude Cwise_square.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_squareE">Math functions</a>, abs2(), cube(), pow()
+  */
+EIGEN_DEVICE_FUNC
+inline const SquareReturnType
+square() const
+{
+  return SquareReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise cube of *this.
+  *
+  * Example: \include Cwise_cube.cpp
+  * Output: \verbinclude Cwise_cube.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cube">Math functions</a>, square(), pow()
+  */
+EIGEN_DEVICE_FUNC
+inline const CubeReturnType
+cube() const
+{
+  return CubeReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise rint of *this.
+  *
+  * Example: \include Cwise_rint.cpp
+  * Output: \verbinclude Cwise_rint.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_rint">Math functions</a>, ceil(), floor()
+  */
+EIGEN_DEVICE_FUNC
+inline const RintReturnType
+rint() const
+{
+  return RintReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise round of *this.
+  *
+  * Example: \include Cwise_round.cpp
+  * Output: \verbinclude Cwise_round.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_round">Math functions</a>, ceil(), floor()
+  */
+EIGEN_DEVICE_FUNC
+inline const RoundReturnType
+round() const
+{
+  return RoundReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise floor of *this.
+  *
+  * Example: \include Cwise_floor.cpp
+  * Output: \verbinclude Cwise_floor.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_floor">Math functions</a>, ceil(), round()
+  */
+EIGEN_DEVICE_FUNC
+inline const FloorReturnType
+floor() const
+{
+  return FloorReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise ceil of *this.
+  *
+  * Example: \include Cwise_ceil.cpp
+  * Output: \verbinclude Cwise_ceil.out
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ceil">Math functions</a>, floor(), round()
+  */
+EIGEN_DEVICE_FUNC
+inline const CeilReturnType
+ceil() const
+{
+  return CeilReturnType(derived());
+}
+
+template<int N> struct ShiftRightXpr {
+  typedef CwiseUnaryOp<internal::scalar_shift_right_op<Scalar, N>, const Derived> Type;
+};
+
+/** \returns an expression of \c *this with the \a Scalar type arithmetically
+  * shifted right by \a N bit positions.
+  *
+  * The template parameter \a N specifies the number of bit positions to shift.
+  * 
+  * \sa shiftLeft()
+  */
+template<int N>
+EIGEN_DEVICE_FUNC
+typename ShiftRightXpr<N>::Type
+shiftRight() const
+{
+  return typename ShiftRightXpr<N>::Type(derived());
+}
+
+
+template<int N> struct ShiftLeftXpr {
+  typedef CwiseUnaryOp<internal::scalar_shift_left_op<Scalar, N>, const Derived> Type;
+};
+
+/** \returns an expression of \c *this with the \a Scalar type logically
+  * shifted left by \a N bit positions.
+  *
+  * The template parameter \a N specifies the number of bit positions to shift.
+  *
+  * \sa shiftRight()
+  */
+template<int N>
+EIGEN_DEVICE_FUNC
+typename ShiftLeftXpr<N>::Type
+shiftLeft() const
+{
+  return typename ShiftLeftXpr<N>::Type(derived());
+}
+
+/** \returns an expression of the coefficient-wise isnan of *this.
+  *
+  * Example: \include Cwise_isNaN.cpp
+  * Output: \verbinclude Cwise_isNaN.out
+  *
+  * \sa isfinite(), isinf()
+  */
+EIGEN_DEVICE_FUNC
+inline const IsNaNReturnType
+isNaN() const
+{
+  return IsNaNReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise isinf of *this.
+  *
+  * Example: \include Cwise_isInf.cpp
+  * Output: \verbinclude Cwise_isInf.out
+  *
+  * \sa isnan(), isfinite()
+  */
+EIGEN_DEVICE_FUNC
+inline const IsInfReturnType
+isInf() const
+{
+  return IsInfReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise isfinite of *this.
+  *
+  * Example: \include Cwise_isFinite.cpp
+  * Output: \verbinclude Cwise_isFinite.out
+  *
+  * \sa isnan(), isinf()
+  */
+EIGEN_DEVICE_FUNC
+inline const IsFiniteReturnType
+isFinite() const
+{
+  return IsFiniteReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise ! operator of *this
+  *
+  * \warning this operator is for expression of bool only.
+  *
+  * Example: \include Cwise_boolean_not.cpp
+  * Output: \verbinclude Cwise_boolean_not.out
+  *
+  * \sa operator!=()
+  */
+EIGEN_DEVICE_FUNC
+inline const BooleanNotReturnType
+operator!() const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return BooleanNotReturnType(derived());
+}
+
+
+// --- SpecialFunctions module ---
+
+typedef CwiseUnaryOp<internal::scalar_lgamma_op<Scalar>, const Derived> LgammaReturnType;
+typedef CwiseUnaryOp<internal::scalar_digamma_op<Scalar>, const Derived> DigammaReturnType;
+typedef CwiseUnaryOp<internal::scalar_erf_op<Scalar>, const Derived> ErfReturnType;
+typedef CwiseUnaryOp<internal::scalar_erfc_op<Scalar>, const Derived> ErfcReturnType;
+typedef CwiseUnaryOp<internal::scalar_ndtri_op<Scalar>, const Derived> NdtriReturnType;
+
+/** \cpp11 \returns an expression of the coefficient-wise ln(|gamma(*this)|).
+  *
+  * \specialfunctions_module
+  *
+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
+  * or float/double in non c++11 mode, the user has to provide implementations of lgamma(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_lgamma">Math functions</a>, digamma()
+  */
+EIGEN_DEVICE_FUNC
+inline const LgammaReturnType
+lgamma() const
+{
+  return LgammaReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise digamma (psi, derivative of lgamma).
+  *
+  * \specialfunctions_module
+  *
+  * \note This function supports only float and double scalar types. To support other scalar types,
+  * the user has to provide implementations of digamma(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_digamma">Math functions</a>, Eigen::digamma(), Eigen::polygamma(), lgamma()
+  */
+EIGEN_DEVICE_FUNC
+inline const DigammaReturnType
+digamma() const
+{
+  return DigammaReturnType(derived());
+}
+
+/** \cpp11 \returns an expression of the coefficient-wise Gauss error
+  * function of *this.
+  *
+  * \specialfunctions_module
+  *
+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
+  * or float/double in non c++11 mode, the user has to provide implementations of erf(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erf">Math functions</a>, erfc()
+  */
+EIGEN_DEVICE_FUNC
+inline const ErfReturnType
+erf() const
+{
+  return ErfReturnType(derived());
+}
+
+/** \cpp11 \returns an expression of the coefficient-wise Complementary error
+  * function of *this.
+  *
+  * \specialfunctions_module
+  *
+  * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
+  * or float/double in non c++11 mode, the user has to provide implementations of erfc(T) for any scalar
+  * type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erfc">Math functions</a>, erf()
+  */
+EIGEN_DEVICE_FUNC
+inline const ErfcReturnType
+erfc() const
+{
+  return ErfcReturnType(derived());
+}
+
+/** \returns an expression of the coefficient-wise inverse of the CDF of the Normal distribution function
+  * function of *this.
+  *
+  * \specialfunctions_module
+  * 
+  * In other words, considering `x = ndtri(y)`, it returns the argument, x, for which the area under the
+  * Gaussian probability density function (integrated from minus infinity to x) is equal to y.
+  *
+  * \note This function supports only float and double scalar types. To support other scalar types,
+  * the user has to provide implementations of ndtri(T) for any scalar type T to be supported.
+  *
+  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ndtri">Math functions</a>
+  */
+EIGEN_DEVICE_FUNC
+inline const NdtriReturnType
+ndtri() const
+{
+  return NdtriReturnType(derived());
+}
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/plugins/BlockMethods.h b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/BlockMethods.h
new file mode 100644
index 00000000..63a52a6f
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/BlockMethods.h
@@ -0,0 +1,1442 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+/// \internal expression type of a column */
+typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr;
+typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ConstColXpr;
+/// \internal expression type of a row */
+typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr;
+typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr;
+/// \internal expression type of a block of whole columns */
+typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr;
+typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ConstColsBlockXpr;
+/// \internal expression type of a block of whole rows */
+typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr;
+typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr;
+/// \internal expression type of a block of whole columns */
+template<int N> struct NColsBlockXpr { typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };
+template<int N> struct ConstNColsBlockXpr { typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };
+/// \internal expression type of a block of whole rows */
+template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };
+template<int N> struct ConstNRowsBlockXpr { typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };
+/// \internal expression of a block */
+typedef Block<Derived> BlockXpr;
+typedef const Block<const Derived> ConstBlockXpr;
+/// \internal expression of a block of fixed sizes */
+template<int Rows, int Cols> struct FixedBlockXpr { typedef Block<Derived,Rows,Cols> Type; };
+template<int Rows, int Cols> struct ConstFixedBlockXpr { typedef Block<const Derived,Rows,Cols> Type; };
+
+typedef VectorBlock<Derived> SegmentReturnType;
+typedef const VectorBlock<const Derived> ConstSegmentReturnType;
+template<int Size> struct FixedSegmentReturnType { typedef VectorBlock<Derived, Size> Type; };
+template<int Size> struct ConstFixedSegmentReturnType { typedef const VectorBlock<const Derived, Size> Type; };
+
+/// \internal inner-vector
+typedef Block<Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true>       InnerVectorReturnType;
+typedef Block<const Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true> ConstInnerVectorReturnType;
+
+/// \internal set of inner-vectors
+typedef Block<Derived,Dynamic,Dynamic,true> InnerVectorsReturnType;
+typedef Block<const Derived,Dynamic,Dynamic,true> ConstInnerVectorsReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+/// \returns an expression of a block in \c *this with either dynamic or fixed sizes.
+///
+/// \param  startRow  the first row in the block
+/// \param  startCol  the first column in the block
+/// \param  blockRows number of rows in the block, specified at either run-time or compile-time
+/// \param  blockCols number of columns in the block, specified at either run-time or compile-time
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example using runtime (aka dynamic) sizes: \include MatrixBase_block_int_int_int_int.cpp
+/// Output: \verbinclude MatrixBase_block_int_int_int_int.out
+///
+/// \newin{3.4}:
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. In the later case, \c n plays the role of a runtime fallback value in case \c N equals Eigen::Dynamic.
+/// Here is an example with a fixed number of rows \c NRows and dynamic number of columns \c cols:
+/// \code
+/// mat.block(i,j,fix<NRows>,cols)
+/// \endcode
+///
+/// This function thus fully covers the features offered by the following overloads block<NRows,NCols>(Index, Index),
+/// and block<NRows,NCols>(Index, Index, Index, Index) that are thus obsolete. Indeed, this generic version avoids
+/// redundancy, it preserves the argument order, and prevents the need to rely on the template keyword in templated code.
+///
+/// but with less redundancy and more consistency as it does not modify the argument order
+/// and seamlessly enable hybrid fixed/dynamic sizes.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size matrix, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block, fix, fix<N>(int)
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename FixedBlockXpr<...,...>::Type
+#endif
+block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type(
+            derived(), startRow, startCol, internal::get_runtime_value(blockRows), internal::get_runtime_value(blockCols));
+}
+
+/// This is the const version of block(Index,Index,NRowsType,NColsType)
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type(
+            derived(), startRow, startCol, internal::get_runtime_value(blockRows), internal::get_runtime_value(blockCols));
+}
+
+
+
+/// \returns a expression of a top-right corner of \c *this with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example with dynamic sizes: \include MatrixBase_topRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_topRightCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename FixedBlockXpr<...,...>::Type
+#endif
+topRightCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of topRightCorner(NRowsType, NColsType).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+topRightCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size top-right corner of \c *this.
+///
+/// \tparam CRows the number of rows in the corner
+/// \tparam CCols the number of columns in the corner
+///
+/// Example: \include MatrixBase_template_int_int_topRightCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topRightCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block, block<int,int>(Index,Index)
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type topRightCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
+}
+
+/// This is the const version of topRightCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
+}
+
+/// \returns an expression of a top-right corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_topRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topRightCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
+}
+
+/// This is the const version of topRightCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
+}
+
+
+
+/// \returns an expression of a top-left corner of \c *this  with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_topLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_topLeftCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename FixedBlockXpr<...,...>::Type
+#endif
+topLeftCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of topLeftCorner(Index, Index).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+topLeftCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size top-left corner of \c *this.
+///
+/// The template parameters CRows and CCols are the number of rows and columns in the corner.
+///
+/// Example: \include MatrixBase_template_int_int_topLeftCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topLeftCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
+}
+
+/// This is the const version of topLeftCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
+}
+
+/// \returns an expression of a top-left corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_topLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_topLeftCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);
+}
+
+/// This is the const version of topLeftCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);
+}
+
+
+
+/// \returns an expression of a bottom-right corner of \c *this  with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_bottomRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename FixedBlockXpr<...,...>::Type
+#endif
+bottomRightCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of bottomRightCorner(NRowsType, NColsType).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstFixedBlockXpr<...,...>::Type
+#endif
+bottomRightCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size bottom-right corner of \c *this.
+///
+/// The template parameters CRows and CCols are the number of rows and columns in the corner.
+///
+/// Example: \include MatrixBase_template_int_int_bottomRightCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
+}
+
+/// This is the const version of bottomRightCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
+}
+
+/// \returns an expression of a bottom-right corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
+}
+
+/// This is the const version of bottomRightCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
+}
+
+
+
+/// \returns an expression of a bottom-left corner of \c *this  with either dynamic or fixed sizes.
+///
+/// \param cRows the number of rows in the corner
+/// \param cCols the number of columns in the corner
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_bottomLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out
+///
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename FixedBlockXpr<...,...>::Type
+#endif
+bottomLeftCorner(NRowsType cRows, NColsType cCols)
+{
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), 0,
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// This is the const version of bottomLeftCorner(NRowsType, NColsType).
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename ConstFixedBlockXpr<...,...>::Type
+#endif
+bottomLeftCorner(NRowsType cRows, NColsType cCols) const
+{
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(cRows), 0,
+                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+}
+
+/// \returns an expression of a fixed-size bottom-left corner of \c *this.
+///
+/// The template parameters CRows and CCols are the number of rows and columns in the corner.
+///
+/// Example: \include MatrixBase_template_int_int_bottomLeftCorner.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner()
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
+}
+
+/// This is the const version of bottomLeftCorner<int, int>().
+template<int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner() const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
+}
+
+/// \returns an expression of a bottom-left corner of \c *this.
+///
+/// \tparam CRows number of rows in corner as specified at compile-time
+/// \tparam CCols number of columns in corner as specified at compile-time
+/// \param  cRows number of rows in corner as specified at run-time
+/// \param  cCols number of columns in corner as specified at run-time
+///
+/// This function is mainly useful for corners where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a cRows should equal \a CRows unless
+/// \a CRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner_int_int.out
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa class Block
+///
+template<int CRows, int CCols>
+EIGEN_STRONG_INLINE
+typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols)
+{
+  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
+}
+
+/// This is the const version of bottomLeftCorner<int, int>(Index, Index).
+template<int CRows, int CCols>
+EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols) const
+{
+  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
+}
+
+
+
+/// \returns a block consisting of the top rows of \c *this.
+///
+/// \param n the number of rows in the block
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+///
+/// Example: \include MatrixBase_topRows_int.cpp
+/// Output: \verbinclude MatrixBase_topRows_int.out
+///
+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+typename NRowsBlockXpr<...>::Type
+#endif
+topRows(NRowsType n)
+{
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(n), cols());
+}
+
+/// This is the const version of topRows(NRowsType).
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+const typename ConstNRowsBlockXpr<...>::Type
+#endif
+topRows(NRowsType n) const
+{
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), 0, 0, internal::get_runtime_value(n), cols());
+}
+
+/// \returns a block consisting of the top rows of \c *this.
+///
+/// \tparam N the number of rows in the block as specified at compile-time
+/// \param n the number of rows in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_topRows.cpp
+/// Output: \verbinclude MatrixBase_template_int_topRows.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NRowsBlockXpr<N>::Type topRows(Index n = N)
+{
+  return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
+}
+
+/// This is the const version of topRows<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const
+{
+  return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
+}
+
+
+
+/// \returns a block consisting of the bottom rows of \c *this.
+///
+/// \param n the number of rows in the block
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+///
+/// Example: \include MatrixBase_bottomRows_int.cpp
+/// Output: \verbinclude MatrixBase_bottomRows_int.out
+///
+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+typename NRowsBlockXpr<...>::Type
+#endif
+bottomRows(NRowsType n)
+{
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
+}
+
+/// This is the const version of bottomRows(NRowsType).
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+const typename ConstNRowsBlockXpr<...>::Type
+#endif
+bottomRows(NRowsType n) const
+{
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
+}
+
+/// \returns a block consisting of the bottom rows of \c *this.
+///
+/// \tparam N the number of rows in the block as specified at compile-time
+/// \param n the number of rows in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_bottomRows.cpp
+/// Output: \verbinclude MatrixBase_template_int_bottomRows.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NRowsBlockXpr<N>::Type bottomRows(Index n = N)
+{
+  return typename NRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
+}
+
+/// This is the const version of bottomRows<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const
+{
+  return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
+}
+
+
+
+/// \returns a block consisting of a range of rows of \c *this.
+///
+/// \param startRow the index of the first row in the block
+/// \param n the number of rows in the block
+/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
+///
+/// Example: \include DenseBase_middleRows_int.cpp
+/// Output: \verbinclude DenseBase_middleRows_int.out
+///
+/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+typename NRowsBlockXpr<...>::Type
+#endif
+middleRows(Index startRow, NRowsType n)
+{
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), startRow, 0, internal::get_runtime_value(n), cols());
+}
+
+/// This is the const version of middleRows(Index,NRowsType).
+template<typename NRowsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+#else
+const typename ConstNRowsBlockXpr<...>::Type
+#endif
+middleRows(Index startRow, NRowsType n) const
+{
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+            (derived(), startRow, 0, internal::get_runtime_value(n), cols());
+}
+
+/// \returns a block consisting of a range of rows of \c *this.
+///
+/// \tparam N the number of rows in the block as specified at compile-time
+/// \param startRow the index of the first row in the block
+/// \param n the number of rows in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include DenseBase_template_int_middleRows.cpp
+/// Output: \verbinclude DenseBase_template_int_middleRows.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N)
+{
+  return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
+}
+
+/// This is the const version of middleRows<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) const
+{
+  return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
+}
+
+
+
+/// \returns a block consisting of the left columns of \c *this.
+///
+/// \param n the number of columns in the block
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_leftCols_int.cpp
+/// Output: \verbinclude MatrixBase_leftCols_int.out
+///
+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename NColsBlockXpr<...>::Type
+#endif
+leftCols(NColsType n)
+{
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, rows(), internal::get_runtime_value(n));
+}
+
+/// This is the const version of leftCols(NColsType).
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstNColsBlockXpr<...>::Type
+#endif
+leftCols(NColsType n) const
+{
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, 0, rows(), internal::get_runtime_value(n));
+}
+
+/// \returns a block consisting of the left columns of \c *this.
+///
+/// \tparam N the number of columns in the block as specified at compile-time
+/// \param n the number of columns in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_leftCols.cpp
+/// Output: \verbinclude MatrixBase_template_int_leftCols.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NColsBlockXpr<N>::Type leftCols(Index n = N)
+{
+  return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
+}
+
+/// This is the const version of leftCols<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const
+{
+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
+}
+
+
+
+/// \returns a block consisting of the right columns of \c *this.
+///
+/// \param n the number of columns in the block
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include MatrixBase_rightCols_int.cpp
+/// Output: \verbinclude MatrixBase_rightCols_int.out
+///
+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename NColsBlockXpr<...>::Type
+#endif
+rightCols(NColsType n)
+{
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
+}
+
+/// This is the const version of rightCols(NColsType).
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstNColsBlockXpr<...>::Type
+#endif
+rightCols(NColsType n) const
+{
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
+}
+
+/// \returns a block consisting of the right columns of \c *this.
+///
+/// \tparam N the number of columns in the block as specified at compile-time
+/// \param n the number of columns in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_rightCols.cpp
+/// Output: \verbinclude MatrixBase_template_int_rightCols.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NColsBlockXpr<N>::Type rightCols(Index n = N)
+{
+  return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
+}
+
+/// This is the const version of rightCols<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const
+{
+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
+}
+
+
+
+/// \returns a block consisting of a range of columns of \c *this.
+///
+/// \param startCol the index of the first column in the block
+/// \param numCols the number of columns in the block
+/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
+///
+/// Example: \include DenseBase_middleCols_int.cpp
+/// Output: \verbinclude DenseBase_middleCols_int.out
+///
+/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+typename NColsBlockXpr<...>::Type
+#endif
+middleCols(Index startCol, NColsType numCols)
+{
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
+}
+
+/// This is the const version of middleCols(Index,NColsType).
+template<typename NColsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+#else
+const typename ConstNColsBlockXpr<...>::Type
+#endif
+middleCols(Index startCol, NColsType numCols) const
+{
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+            (derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
+}
+
+/// \returns a block consisting of a range of columns of \c *this.
+///
+/// \tparam N the number of columns in the block as specified at compile-time
+/// \param startCol the index of the first column in the block
+/// \param n the number of columns in the block as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include DenseBase_template_int_middleCols.cpp
+/// Output: \verbinclude DenseBase_template_int_middleCols.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename NColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N)
+{
+  return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
+}
+
+/// This is the const version of middleCols<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) const
+{
+  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
+}
+
+
+
+/// \returns a fixed-size expression of a block of \c *this.
+///
+/// The template parameters \a NRows and \a NCols are the number of
+/// rows and columns in the block.
+///
+/// \param startRow the first row in the block
+/// \param startCol the first column in the block
+///
+/// Example: \include MatrixBase_block_int_int.cpp
+/// Output: \verbinclude MatrixBase_block_int_int.out
+///
+/// \note The usage of of this overload is discouraged from %Eigen 3.4, better used the generic
+/// block(Index,Index,NRowsType,NColsType), here is the one-to-one equivalence:
+/// \code
+/// mat.template block<NRows,NCols>(i,j)  <-->  mat.block(i,j,fix<NRows>,fix<NCols>)
+/// \endcode
+///
+/// \note since block is a templated member, the keyword template has to be used
+/// if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol)
+{
+  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
+}
+
+/// This is the const version of block<>(Index, Index). */
+template<int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol) const
+{
+  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
+}
+
+/// \returns an expression of a block of \c *this.
+///
+/// \tparam NRows number of rows in block as specified at compile-time
+/// \tparam NCols number of columns in block as specified at compile-time
+/// \param  startRow  the first row in the block
+/// \param  startCol  the first column in the block
+/// \param  blockRows number of rows in block as specified at run-time
+/// \param  blockCols number of columns in block as specified at run-time
+///
+/// This function is mainly useful for blocks where the number of rows is specified at compile-time
+/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
+/// information should not contradict. In other words, \a blockRows should equal \a NRows unless
+/// \a NRows is \a Dynamic, and the same for the number of columns.
+///
+/// Example: \include MatrixBase_template_int_int_block_int_int_int_int.cpp
+/// Output: \verbinclude MatrixBase_template_int_int_block_int_int_int_int.out
+///
+/// \note The usage of of this overload is discouraged from %Eigen 3.4, better used the generic
+/// block(Index,Index,NRowsType,NColsType), here is the one-to-one complete equivalence:
+/// \code
+/// mat.template block<NRows,NCols>(i,j,rows,cols)     <-->  mat.block(i,j,fix<NRows>(rows),fix<NCols>(cols))
+/// \endcode
+/// If we known that, e.g., NRows==Dynamic and NCols!=Dynamic, then the equivalence becomes:
+/// \code
+/// mat.template block<Dynamic,NCols>(i,j,rows,NCols)  <-->  mat.block(i,j,rows,fix<NCols>)
+/// \endcode
+///
+EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
+///
+/// \sa block(Index,Index,NRowsType,NColsType), class Block
+///
+template<int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
+                                                  Index blockRows, Index blockCols)
+{
+  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
+}
+
+/// This is the const version of block<>(Index, Index, Index, Index).
+template<int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
+                                                              Index blockRows, Index blockCols) const
+{
+  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
+}
+
+/// \returns an expression of the \a i-th column of \c *this. Note that the numbering starts at 0.
+///
+/// Example: \include MatrixBase_col.cpp
+/// Output: \verbinclude MatrixBase_col.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+/**
+  * \sa row(), class Block */
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+ColXpr col(Index i)
+{
+  return ColXpr(derived(), i);
+}
+
+/// This is the const version of col().
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+ConstColXpr col(Index i) const
+{
+  return ConstColXpr(derived(), i);
+}
+
+/// \returns an expression of the \a i-th row of \c *this. Note that the numbering starts at 0.
+///
+/// Example: \include MatrixBase_row.cpp
+/// Output: \verbinclude MatrixBase_row.out
+///
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+/**
+  * \sa col(), class Block */
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+RowXpr row(Index i)
+{
+  return RowXpr(derived(), i);
+}
+
+/// This is the const version of row(). */
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+ConstRowXpr row(Index i) const
+{
+  return ConstRowXpr(derived(), i);
+}
+
+/// \returns an expression of a segment (i.e. a vector block) in \c *this with either dynamic or fixed sizes.
+///
+/// \only_for_vectors
+///
+/// \param start the first coefficient in the segment
+/// \param n the number of coefficients in the segment
+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
+///
+/// Example: \include MatrixBase_segment_int_int.cpp
+/// Output: \verbinclude MatrixBase_segment_int_int.out
+///
+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+/// \sa block(Index,Index,NRowsType,NColsType), fix<N>, fix<N>(int), class Block
+///
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+typename FixedSegmentReturnType<...>::Type
+#endif
+segment(Index start, NType n)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), start, internal::get_runtime_value(n));
+}
+
+
+/// This is the const version of segment(Index,NType).
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+const typename ConstFixedSegmentReturnType<...>::Type
+#endif
+segment(Index start, NType n) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), start, internal::get_runtime_value(n));
+}
+
+/// \returns an expression of the first coefficients of \c *this with either dynamic or fixed sizes.
+///
+/// \only_for_vectors
+///
+/// \param n the number of coefficients in the segment
+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
+///
+/// Example: \include MatrixBase_start_int.cpp
+/// Output: \verbinclude MatrixBase_start_int.out
+///
+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+/// \sa class Block, block(Index,Index)
+///
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+typename FixedSegmentReturnType<...>::Type
+#endif
+head(NType n)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+              (derived(), 0, internal::get_runtime_value(n));
+}
+
+/// This is the const version of head(NType).
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+const typename ConstFixedSegmentReturnType<...>::Type
+#endif
+head(NType n) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), 0, internal::get_runtime_value(n));
+}
+
+/// \returns an expression of a last coefficients of \c *this with either dynamic or fixed sizes.
+///
+/// \only_for_vectors
+///
+/// \param n the number of coefficients in the segment
+/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
+///
+/// Example: \include MatrixBase_end_int.cpp
+/// Output: \verbinclude MatrixBase_end_int.out
+///
+/// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments.
+/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+///
+/// \note Even in the case that the returned expression has dynamic size, in the case
+/// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
+/// which means that evaluating it does not cause a dynamic memory allocation.
+///
+/// \sa class Block, block(Index,Index)
+///
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+typename FixedSegmentReturnType<...>::Type
+#endif
+tail(NType n)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
+}
+
+/// This is the const version of tail(Index).
+template<typename NType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+#else
+const typename ConstFixedSegmentReturnType<...>::Type
+#endif
+tail(NType n) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+            (derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
+}
+
+/// \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this
+///
+/// \only_for_vectors
+///
+/// \tparam N the number of coefficients in the segment as specified at compile-time
+/// \param start the index of the first element in the segment
+/// \param n the number of coefficients in the segment as specified at compile-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_segment.cpp
+/// Output: \verbinclude MatrixBase_template_int_segment.out
+///
+/// \sa segment(Index,NType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<N>::Type(derived(), start, n);
+}
+
+/// This is the const version of segment<int>(Index).
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n);
+}
+
+/// \returns a fixed-size expression of the first coefficients of \c *this.
+///
+/// \only_for_vectors
+///
+/// \tparam N the number of coefficients in the segment as specified at compile-time
+/// \param  n the number of coefficients in the segment as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_start.cpp
+/// Output: \verbinclude MatrixBase_template_int_start.out
+///
+/// \sa head(NType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedSegmentReturnType<N>::Type head(Index n = N)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<N>::Type(derived(), 0, n);
+}
+
+/// This is the const version of head<int>().
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n);
+}
+
+/// \returns a fixed-size expression of the last coefficients of \c *this.
+///
+/// \only_for_vectors
+///
+/// \tparam N the number of coefficients in the segment as specified at compile-time
+/// \param  n the number of coefficients in the segment as specified at run-time
+///
+/// The compile-time and run-time information should not contradict. In other words,
+/// \a n should equal \a N unless \a N is \a Dynamic.
+///
+/// Example: \include MatrixBase_template_int_end.cpp
+/// Output: \verbinclude MatrixBase_template_int_end.out
+///
+/// \sa tail(NType), class Block
+///
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename FixedSegmentReturnType<N>::Type tail(Index n = N)
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename FixedSegmentReturnType<N>::Type(derived(), size() - n);
+}
+
+/// This is the const version of tail<int>.
+template<int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n);
+}
+
+/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+/// is col-major (resp. row-major).
+///
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+InnerVectorReturnType innerVector(Index outer)
+{ return InnerVectorReturnType(derived(), outer); }
+
+/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+/// is col-major (resp. row-major). Read-only.
+///
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const ConstInnerVectorReturnType innerVector(Index outer) const
+{ return ConstInnerVectorReturnType(derived(), outer); }
+
+/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+/// is col-major (resp. row-major).
+///
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+InnerVectorsReturnType
+innerVectors(Index outerStart, Index outerSize)
+{
+  return Block<Derived,Dynamic,Dynamic,true>(derived(),
+                                             IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
+                                             IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
+
+}
+
+/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
+/// is col-major (resp. row-major). Read-only.
+///
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+const ConstInnerVectorsReturnType
+innerVectors(Index outerStart, Index outerSize) const
+{
+  return Block<const Derived,Dynamic,Dynamic,true>(derived(),
+                                                  IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
+                                                  IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
+
+}
+
+/** \returns the i-th subvector (column or vector) according to the \c Direction
+  * \sa subVectors()
+  */
+template<DirectionType Direction>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename internal::conditional<Direction==Vertical,ColXpr,RowXpr>::type
+subVector(Index i)
+{
+  return typename internal::conditional<Direction==Vertical,ColXpr,RowXpr>::type(derived(),i);
+}
+
+/** This is the const version of subVector(Index) */
+template<DirectionType Direction>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+typename internal::conditional<Direction==Vertical,ConstColXpr,ConstRowXpr>::type
+subVector(Index i) const
+{
+  return typename internal::conditional<Direction==Vertical,ConstColXpr,ConstRowXpr>::type(derived(),i);
+}
+
+/** \returns the number of subvectors (rows or columns) in the direction \c Direction
+  * \sa subVector(Index)
+  */
+template<DirectionType Direction>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
+Index subVectors() const
+{ return (Direction==Vertical)?cols():rows(); }
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/plugins/CommonCwiseBinaryOps.h b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/CommonCwiseBinaryOps.h
new file mode 100644
index 00000000..8b6730ed
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/CommonCwiseBinaryOps.h
@@ -0,0 +1,115 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is a base class plugin containing common coefficient wise functions.
+
+/** \returns an expression of the difference of \c *this and \a other
+  *
+  * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-().
+  *
+  * \sa class CwiseBinaryOp, operator-=()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(operator-,difference)
+
+/** \returns an expression of the sum of \c *this and \a other
+  *
+  * \note If you want to add a given scalar to all coefficients, see Cwise::operator+().
+  *
+  * \sa class CwiseBinaryOp, operator+=()
+  */
+EIGEN_MAKE_CWISE_BINARY_OP(operator+,sum)
+
+/** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
+  *
+  * The template parameter \a CustomBinaryOp is the type of the functor
+  * of the custom operator (see class CwiseBinaryOp for an example)
+  *
+  * Here is an example illustrating the use of custom functors:
+  * \include class_CwiseBinaryOp.cpp
+  * Output: \verbinclude class_CwiseBinaryOp.out
+  *
+  * \sa class CwiseBinaryOp, operator+(), operator-(), cwiseProduct()
+  */
+template<typename CustomBinaryOp, typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>
+binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other, const CustomBinaryOp& func = CustomBinaryOp()) const
+{
+  return CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>(derived(), other.derived(), func);
+}
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP(operator*,product)
+#else
+/** \returns an expression of \c *this scaled by the scalar factor \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_product_op<Scalar,T>,Derived,Constant<T> > operator*(const T& scalar) const;
+/** \returns an expression of \a expr scaled by the scalar factor \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T> friend
+const CwiseBinaryOp<internal::scalar_product_op<T,Scalar>,Constant<T>,Derived> operator*(const T& scalar, const StorageBaseType& expr);
+#endif
+
+
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(operator/,quotient)
+#else
+/** \returns an expression of \c *this divided by the scalar value \a scalar
+  *
+  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
+  */
+template<typename T>
+const CwiseBinaryOp<internal::scalar_quotient_op<Scalar,T>,Derived,Constant<T> > operator/(const T& scalar) const;
+#endif
+
+/** \returns an expression of the coefficient-wise boolean \b and operator of \c *this and \a other
+  *
+  * \warning this operator is for expression of bool only.
+  *
+  * Example: \include Cwise_boolean_and.cpp
+  * Output: \verbinclude Cwise_boolean_and.out
+  *
+  * \sa operator||(), select()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<internal::scalar_boolean_and_op, const Derived, const OtherDerived>
+operator&&(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return CwiseBinaryOp<internal::scalar_boolean_and_op, const Derived, const OtherDerived>(derived(),other.derived());
+}
+
+/** \returns an expression of the coefficient-wise boolean \b or operator of \c *this and \a other
+  *
+  * \warning this operator is for expression of bool only.
+  *
+  * Example: \include Cwise_boolean_or.cpp
+  * Output: \verbinclude Cwise_boolean_or.out
+  *
+  * \sa operator&&(), select()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<internal::scalar_boolean_or_op, const Derived, const OtherDerived>
+operator||(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  EIGEN_STATIC_ASSERT((internal::is_same<bool,Scalar>::value && internal::is_same<bool,typename OtherDerived::Scalar>::value),
+                      THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_OF_BOOL);
+  return CwiseBinaryOp<internal::scalar_boolean_or_op, const Derived, const OtherDerived>(derived(),other.derived());
+}
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/plugins/CommonCwiseUnaryOps.h b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/CommonCwiseUnaryOps.h
new file mode 100644
index 00000000..5418dc41
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/CommonCwiseUnaryOps.h
@@ -0,0 +1,177 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is a base class plugin containing common coefficient wise functions.
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+/** \internal the return type of conjugate() */
+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                    const CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const Derived>,
+                    const Derived&
+                  >::type ConjugateReturnType;
+/** \internal the return type of real() const */
+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                    const CwiseUnaryOp<internal::scalar_real_op<Scalar>, const Derived>,
+                    const Derived&
+                  >::type RealReturnType;
+/** \internal the return type of real() */
+typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
+                    CwiseUnaryView<internal::scalar_real_ref_op<Scalar>, Derived>,
+                    Derived&
+                  >::type NonConstRealReturnType;
+/** \internal the return type of imag() const */
+typedef CwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived> ImagReturnType;
+/** \internal the return type of imag() */
+typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> NonConstImagReturnType;
+
+typedef CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const Derived> NegativeReturnType;
+
+#endif // not EIGEN_PARSED_BY_DOXYGEN
+
+/// \returns an expression of the opposite of \c *this
+///
+EIGEN_DOC_UNARY_ADDONS(operator-,opposite)
+///
+EIGEN_DEVICE_FUNC
+inline const NegativeReturnType
+operator-() const { return NegativeReturnType(derived()); }
+
+
+template<class NewType> struct CastXpr { typedef typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<Scalar, NewType>, const Derived> >::type Type; };
+
+/// \returns an expression of \c *this with the \a Scalar type casted to
+/// \a NewScalar.
+///
+/// The template parameter \a NewScalar is the type we are casting the scalars to.
+///
+EIGEN_DOC_UNARY_ADDONS(cast,conversion function)
+///
+/// \sa class CwiseUnaryOp
+///
+template<typename NewType>
+EIGEN_DEVICE_FUNC
+typename CastXpr<NewType>::Type
+cast() const
+{
+  return typename CastXpr<NewType>::Type(derived());
+}
+
+/// \returns an expression of the complex conjugate of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(conjugate,complex conjugate)
+///
+/// \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_conj">Math functions</a>, MatrixBase::adjoint()
+EIGEN_DEVICE_FUNC
+inline ConjugateReturnType
+conjugate() const
+{
+  return ConjugateReturnType(derived());
+}
+
+/// \returns an expression of the complex conjugate of \c *this if Cond==true, returns derived() otherwise.
+///
+EIGEN_DOC_UNARY_ADDONS(conjugate,complex conjugate)
+///
+/// \sa conjugate()
+template<bool Cond>
+EIGEN_DEVICE_FUNC
+inline typename internal::conditional<Cond,ConjugateReturnType,const Derived&>::type
+conjugateIf() const
+{
+  typedef typename internal::conditional<Cond,ConjugateReturnType,const Derived&>::type ReturnType;
+  return ReturnType(derived());
+}
+
+/// \returns a read-only expression of the real part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(real,real part function)
+///
+/// \sa imag()
+EIGEN_DEVICE_FUNC
+inline RealReturnType
+real() const { return RealReturnType(derived()); }
+
+/// \returns an read-only expression of the imaginary part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(imag,imaginary part function)
+///
+/// \sa real()
+EIGEN_DEVICE_FUNC
+inline const ImagReturnType
+imag() const { return ImagReturnType(derived()); }
+
+/// \brief Apply a unary operator coefficient-wise
+/// \param[in]  func  Functor implementing the unary operator
+/// \tparam  CustomUnaryOp Type of \a func
+/// \returns An expression of a custom coefficient-wise unary operator \a func of *this
+///
+/// The function \c ptr_fun() from the C++ standard library can be used to make functors out of normal functions.
+///
+/// Example:
+/// \include class_CwiseUnaryOp_ptrfun.cpp
+/// Output: \verbinclude class_CwiseUnaryOp_ptrfun.out
+///
+/// Genuine functors allow for more possibilities, for instance it may contain a state.
+///
+/// Example:
+/// \include class_CwiseUnaryOp.cpp
+/// Output: \verbinclude class_CwiseUnaryOp.out
+///
+EIGEN_DOC_UNARY_ADDONS(unaryExpr,unary function)
+///
+/// \sa unaryViewExpr, binaryExpr, class CwiseUnaryOp
+///
+template<typename CustomUnaryOp>
+EIGEN_DEVICE_FUNC
+inline const CwiseUnaryOp<CustomUnaryOp, const Derived>
+unaryExpr(const CustomUnaryOp& func = CustomUnaryOp()) const
+{
+  return CwiseUnaryOp<CustomUnaryOp, const Derived>(derived(), func);
+}
+
+/// \returns an expression of a custom coefficient-wise unary operator \a func of *this
+///
+/// The template parameter \a CustomUnaryOp is the type of the functor
+/// of the custom unary operator.
+///
+/// Example:
+/// \include class_CwiseUnaryOp.cpp
+/// Output: \verbinclude class_CwiseUnaryOp.out
+///
+EIGEN_DOC_UNARY_ADDONS(unaryViewExpr,unary function)
+///
+/// \sa unaryExpr, binaryExpr class CwiseUnaryOp
+///
+template<typename CustomViewOp>
+EIGEN_DEVICE_FUNC
+inline const CwiseUnaryView<CustomViewOp, const Derived>
+unaryViewExpr(const CustomViewOp& func = CustomViewOp()) const
+{
+  return CwiseUnaryView<CustomViewOp, const Derived>(derived(), func);
+}
+
+/// \returns a non const expression of the real part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(real,real part function)
+///
+/// \sa imag()
+EIGEN_DEVICE_FUNC
+inline NonConstRealReturnType
+real() { return NonConstRealReturnType(derived()); }
+
+/// \returns a non const expression of the imaginary part of \c *this.
+///
+EIGEN_DOC_UNARY_ADDONS(imag,imaginary part function)
+///
+/// \sa real()
+EIGEN_DEVICE_FUNC
+inline NonConstImagReturnType
+imag() { return NonConstImagReturnType(derived()); }
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/plugins/IndexedViewMethods.h b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/IndexedViewMethods.h
new file mode 100644
index 00000000..5bfb19ac
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/IndexedViewMethods.h
@@ -0,0 +1,262 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#if !defined(EIGEN_PARSED_BY_DOXYGEN)
+
+// This file is automatically included twice to generate const and non-const versions
+
+#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#define EIGEN_INDEXED_VIEW_METHOD_CONST const
+#define EIGEN_INDEXED_VIEW_METHOD_TYPE  ConstIndexedViewType
+#else
+#define EIGEN_INDEXED_VIEW_METHOD_CONST
+#define EIGEN_INDEXED_VIEW_METHOD_TYPE IndexedViewType
+#endif
+
+#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+protected:
+
+// define some aliases to ease readability
+
+template<typename Indices>
+struct IvcRowType : public internal::IndexedViewCompatibleType<Indices,RowsAtCompileTime> {};
+
+template<typename Indices>
+struct IvcColType : public internal::IndexedViewCompatibleType<Indices,ColsAtCompileTime> {};
+
+template<typename Indices>
+struct IvcType : public internal::IndexedViewCompatibleType<Indices,SizeAtCompileTime> {};
+
+typedef typename internal::IndexedViewCompatibleType<Index,1>::type IvcIndex;
+
+template<typename Indices>
+typename IvcRowType<Indices>::type
+ivcRow(const Indices& indices) const {
+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,RowsAtCompileTime>(derived().rows()),Specialized);
+}
+
+template<typename Indices>
+typename IvcColType<Indices>::type
+ivcCol(const Indices& indices) const {
+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,ColsAtCompileTime>(derived().cols()),Specialized);
+}
+
+template<typename Indices>
+typename IvcColType<Indices>::type
+ivcSize(const Indices& indices) const {
+  return internal::makeIndexedViewCompatible(indices, internal::variable_if_dynamic<Index,SizeAtCompileTime>(derived().size()),Specialized);
+}
+
+public:
+
+#endif
+
+template<typename RowIndices, typename ColIndices>
+struct EIGEN_INDEXED_VIEW_METHOD_TYPE {
+  typedef IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,
+                      typename IvcRowType<RowIndices>::type,
+                      typename IvcColType<ColIndices>::type> type;
+};
+
+// This is the generic version
+
+template<typename RowIndices, typename ColIndices>
+typename internal::enable_if<internal::valid_indexed_view_overload<RowIndices,ColIndices>::value
+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsIndexedView,
+  typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type >::type
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type
+            (derived(), ivcRow(rowIndices), ivcCol(colIndices));
+}
+
+// The following overload returns a Block<> object
+
+template<typename RowIndices, typename ColIndices>
+typename internal::enable_if<internal::valid_indexed_view_overload<RowIndices,ColIndices>::value
+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsBlock,
+  typename internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::BlockType>::type
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  typedef typename internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::BlockType BlockType;
+  typename IvcRowType<RowIndices>::type actualRowIndices = ivcRow(rowIndices);
+  typename IvcColType<ColIndices>::type actualColIndices = ivcCol(colIndices);
+  return BlockType(derived(),
+                   internal::first(actualRowIndices),
+                   internal::first(actualColIndices),
+                   internal::size(actualRowIndices),
+                   internal::size(actualColIndices));
+}
+
+// The following overload returns a Scalar
+
+template<typename RowIndices, typename ColIndices>
+typename internal::enable_if<internal::valid_indexed_view_overload<RowIndices,ColIndices>::value
+  && internal::traits<typename EIGEN_INDEXED_VIEW_METHOD_TYPE<RowIndices,ColIndices>::type>::ReturnAsScalar,
+  CoeffReturnType >::type
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return Base::operator()(internal::eval_expr_given_size(rowIndices,rows()),internal::eval_expr_given_size(colIndices,cols()));
+}
+
+#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+// The following three overloads are needed to handle raw Index[N] arrays.
+
+template<typename RowIndicesT, std::size_t RowIndicesN, typename ColIndices>
+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],typename IvcColType<ColIndices>::type>
+operator()(const RowIndicesT (&rowIndices)[RowIndicesN], const ColIndices& colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],typename IvcColType<ColIndices>::type>
+                    (derived(), rowIndices, ivcCol(colIndices));
+}
+
+template<typename RowIndices, typename ColIndicesT, std::size_t ColIndicesN>
+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcRowType<RowIndices>::type, const ColIndicesT (&)[ColIndicesN]>
+operator()(const RowIndices& rowIndices, const ColIndicesT (&colIndices)[ColIndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcRowType<RowIndices>::type,const ColIndicesT (&)[ColIndicesN]>
+                    (derived(), ivcRow(rowIndices), colIndices);
+}
+
+template<typename RowIndicesT, std::size_t RowIndicesN, typename ColIndicesT, std::size_t ColIndicesN>
+IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN], const ColIndicesT (&)[ColIndicesN]>
+operator()(const RowIndicesT (&rowIndices)[RowIndicesN], const ColIndicesT (&colIndices)[ColIndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const RowIndicesT (&)[RowIndicesN],const ColIndicesT (&)[ColIndicesN]>
+                    (derived(), rowIndices, colIndices);
+}
+
+#endif // EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+// Overloads for 1D vectors/arrays
+
+template<typename Indices>
+typename internal::enable_if<
+  IsRowMajor && (!(internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1 || internal::is_valid_index_type<Indices>::value)),
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,typename IvcType<Indices>::type> >::type
+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,typename IvcType<Indices>::type>
+            (derived(), IvcIndex(0), ivcCol(indices));
+}
+
+template<typename Indices>
+typename internal::enable_if<
+  (!IsRowMajor) && (!(internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1 || internal::is_valid_index_type<Indices>::value)),
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcType<Indices>::type,IvcIndex> >::type
+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,typename IvcType<Indices>::type,IvcIndex>
+            (derived(), ivcRow(indices), IvcIndex(0));
+}
+
+template<typename Indices>
+typename internal::enable_if<
+  (internal::get_compile_time_incr<typename IvcType<Indices>::type>::value==1) && (!internal::is_valid_index_type<Indices>::value) && (!symbolic::is_symbolic<Indices>::value),
+  VectorBlock<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,internal::array_size<Indices>::value> >::type
+operator()(const Indices& indices) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  typename IvcType<Indices>::type actualIndices = ivcSize(indices);
+  return VectorBlock<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,internal::array_size<Indices>::value>
+            (derived(), internal::first(actualIndices), internal::size(actualIndices));
+}
+
+template<typename IndexType>
+typename internal::enable_if<symbolic::is_symbolic<IndexType>::value, CoeffReturnType >::type
+operator()(const IndexType& id) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  return Base::operator()(internal::eval_expr_given_size(id,size()));
+}
+
+#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+template<typename IndicesT, std::size_t IndicesN>
+typename internal::enable_if<IsRowMajor,
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,const IndicesT (&)[IndicesN]> >::type
+operator()(const IndicesT (&indices)[IndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,const IndicesT (&)[IndicesN]>
+            (derived(), IvcIndex(0), indices);
+}
+
+template<typename IndicesT, std::size_t IndicesN>
+typename internal::enable_if<!IsRowMajor,
+  IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const IndicesT (&)[IndicesN],IvcIndex> >::type
+operator()(const IndicesT (&indices)[IndicesN]) EIGEN_INDEXED_VIEW_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  return IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,const IndicesT (&)[IndicesN],IvcIndex>
+            (derived(), indices, IvcIndex(0));
+}
+
+#endif // EIGEN_HAS_STATIC_ARRAY_TEMPLATE
+
+#undef EIGEN_INDEXED_VIEW_METHOD_CONST
+#undef EIGEN_INDEXED_VIEW_METHOD_TYPE
+
+#ifndef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#define EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#include "IndexedViewMethods.h"
+#undef EIGEN_INDEXED_VIEW_METHOD_2ND_PASS
+#endif
+
+#else // EIGEN_PARSED_BY_DOXYGEN
+
+/**
+  * \returns a generic submatrix view defined by the rows and columns indexed \a rowIndices and \a colIndices respectively.
+  *
+  * Each parameter must either be:
+  *  - An integer indexing a single row or column
+  *  - Eigen::all indexing the full set of respective rows or columns in increasing order
+  *  - An ArithmeticSequence as returned by the Eigen::seq and Eigen::seqN functions
+  *  - Any %Eigen's vector/array of integers or expressions
+  *  - Plain C arrays: \c int[N]
+  *  - And more generally any type exposing the following two member functions:
+  * \code
+  * <integral type> operator[](<integral type>) const;
+  * <integral type> size() const;
+  * \endcode
+  * where \c <integral \c type>  stands for any integer type compatible with Eigen::Index (i.e. \c std::ptrdiff_t).
+  *
+  * The last statement implies compatibility with \c std::vector, \c std::valarray, \c std::array, many of the Range-v3's ranges, etc.
+  *
+  * If the submatrix can be represented using a starting position \c (i,j) and positive sizes \c (rows,columns), then this
+  * method will returns a Block object after extraction of the relevant information from the passed arguments. This is the case
+  * when all arguments are either:
+  *  - An integer
+  *  - Eigen::all
+  *  - An ArithmeticSequence with compile-time increment strictly equal to 1, as returned by Eigen::seq(a,b), and Eigen::seqN(a,N).
+  *
+  * Otherwise a more general IndexedView<Derived,RowIndices',ColIndices'> object will be returned, after conversion of the inputs
+  * to more suitable types \c RowIndices' and \c ColIndices'.
+  *
+  * For 1D vectors and arrays, you better use the operator()(const Indices&) overload, which behave the same way but taking a single parameter.
+  *
+  * See also this <a href="https://stackoverflow.com/questions/46110917/eigen-replicate-items-along-one-dimension-without-useless-allocations">question</a> and its answer for an example of how to duplicate coefficients.
+  *
+  * \sa operator()(const Indices&), class Block, class IndexedView, DenseBase::block(Index,Index,Index,Index)
+  */
+template<typename RowIndices, typename ColIndices>
+IndexedView_or_Block
+operator()(const RowIndices& rowIndices, const ColIndices& colIndices);
+
+/** This is an overload of operator()(const RowIndices&, const ColIndices&) for 1D vectors or arrays
+  *
+  * \only_for_vectors
+  */
+template<typename Indices>
+IndexedView_or_VectorBlock
+operator()(const Indices& indices);
+
+#endif  // EIGEN_PARSED_BY_DOXYGEN
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/plugins/MatrixCwiseBinaryOps.h b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
new file mode 100644
index 00000000..a0feef87
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/MatrixCwiseBinaryOps.h
@@ -0,0 +1,152 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is a base class plugin containing matrix specifics coefficient wise functions.
+
+/** \returns an expression of the Schur product (coefficient wise product) of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseProduct.cpp
+  * Output: \verbinclude MatrixBase_cwiseProduct.out
+  *
+  * \sa class CwiseBinaryOp, cwiseAbs2
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)
+cwiseProduct(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived,OtherDerived,product)(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise == operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include MatrixBase_cwiseEqual.cpp
+  * Output: \verbinclude MatrixBase_cwiseEqual.out
+  *
+  * \sa cwiseNotEqual(), isApprox(), isMuchSmallerThan()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<numext::equal_to<Scalar>, const Derived, const OtherDerived>
+cwiseEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<numext::equal_to<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise != operator of *this and \a other
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * Example: \include MatrixBase_cwiseNotEqual.cpp
+  * Output: \verbinclude MatrixBase_cwiseNotEqual.out
+  *
+  * \sa cwiseEqual(), isApprox(), isMuchSmallerThan()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+inline const CwiseBinaryOp<numext::not_equal_to<Scalar>, const Derived, const OtherDerived>
+cwiseNotEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<numext::not_equal_to<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise min of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseMin.cpp
+  * Output: \verbinclude MatrixBase_cwiseMin.out
+  *
+  * \sa class CwiseBinaryOp, max()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const OtherDerived>
+cwiseMin(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise min of *this and scalar \a other
+  *
+  * \sa class CwiseBinaryOp, min()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar>, const Derived, const ConstantReturnType>
+cwiseMin(const Scalar &other) const
+{
+  return cwiseMin(Derived::Constant(rows(), cols(), other));
+}
+
+/** \returns an expression of the coefficient-wise max of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseMax.cpp
+  * Output: \verbinclude MatrixBase_cwiseMax.out
+  *
+  * \sa class CwiseBinaryOp, min()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const OtherDerived>
+cwiseMax(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+/** \returns an expression of the coefficient-wise max of *this and scalar \a other
+  *
+  * \sa class CwiseBinaryOp, min()
+  */
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar>, const Derived, const ConstantReturnType>
+cwiseMax(const Scalar &other) const
+{
+  return cwiseMax(Derived::Constant(rows(), cols(), other));
+}
+
+
+/** \returns an expression of the coefficient-wise quotient of *this and \a other
+  *
+  * Example: \include MatrixBase_cwiseQuotient.cpp
+  * Output: \verbinclude MatrixBase_cwiseQuotient.out
+  *
+  * \sa class CwiseBinaryOp, cwiseProduct(), cwiseInverse()
+  */
+template<typename OtherDerived>
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>
+cwiseQuotient(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
+{
+  return CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>(derived(), other.derived());
+}
+
+typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar,Scalar,internal::cmp_EQ>, const Derived, const ConstantReturnType> CwiseScalarEqualReturnType;
+
+/** \returns an expression of the coefficient-wise == operator of \c *this and a scalar \a s
+  *
+  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
+  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
+  * generally a far better idea to use a fuzzy comparison as provided by isApprox() and
+  * isMuchSmallerThan().
+  *
+  * \sa cwiseEqual(const MatrixBase<OtherDerived> &) const
+  */
+EIGEN_DEVICE_FUNC
+inline const CwiseScalarEqualReturnType
+cwiseEqual(const Scalar& s) const
+{
+  return CwiseScalarEqualReturnType(derived(), Derived::Constant(rows(), cols(), s), internal::scalar_cmp_op<Scalar,Scalar,internal::cmp_EQ>());
+}
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/plugins/MatrixCwiseUnaryOps.h b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
new file mode 100644
index 00000000..0514d8f7
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/MatrixCwiseUnaryOps.h
@@ -0,0 +1,95 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This file is included into the body of the base classes supporting matrix specific coefficient-wise functions.
+// This include MatrixBase and SparseMatrixBase.
+
+
+typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> CwiseAbsReturnType;
+typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> CwiseAbs2ReturnType;
+typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> CwiseArgReturnType;
+typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> CwiseSqrtReturnType;
+typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> CwiseSignReturnType;
+typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> CwiseInverseReturnType;
+
+/// \returns an expression of the coefficient-wise absolute value of \c *this
+///
+/// Example: \include MatrixBase_cwiseAbs.cpp
+/// Output: \verbinclude MatrixBase_cwiseAbs.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseAbs,absolute value)
+///
+/// \sa cwiseAbs2()
+///
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseAbsReturnType
+cwiseAbs() const { return CwiseAbsReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise squared absolute value of \c *this
+///
+/// Example: \include MatrixBase_cwiseAbs2.cpp
+/// Output: \verbinclude MatrixBase_cwiseAbs2.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseAbs2,squared absolute value)
+///
+/// \sa cwiseAbs()
+///
+EIGEN_DEVICE_FUNC
+EIGEN_STRONG_INLINE const CwiseAbs2ReturnType
+cwiseAbs2() const { return CwiseAbs2ReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise square root of *this.
+///
+/// Example: \include MatrixBase_cwiseSqrt.cpp
+/// Output: \verbinclude MatrixBase_cwiseSqrt.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseSqrt,square-root)
+///
+/// \sa cwisePow(), cwiseSquare()
+///
+EIGEN_DEVICE_FUNC
+inline const CwiseSqrtReturnType
+cwiseSqrt() const { return CwiseSqrtReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise signum of *this.
+///
+/// Example: \include MatrixBase_cwiseSign.cpp
+/// Output: \verbinclude MatrixBase_cwiseSign.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseSign,sign function)
+///
+EIGEN_DEVICE_FUNC
+inline const CwiseSignReturnType
+cwiseSign() const { return CwiseSignReturnType(derived()); }
+
+
+/// \returns an expression of the coefficient-wise inverse of *this.
+///
+/// Example: \include MatrixBase_cwiseInverse.cpp
+/// Output: \verbinclude MatrixBase_cwiseInverse.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseInverse,inverse)
+///
+/// \sa cwiseProduct()
+///
+EIGEN_DEVICE_FUNC
+inline const CwiseInverseReturnType
+cwiseInverse() const { return CwiseInverseReturnType(derived()); }
+
+/// \returns an expression of the coefficient-wise phase angle of \c *this
+///
+/// Example: \include MatrixBase_cwiseArg.cpp
+/// Output: \verbinclude MatrixBase_cwiseArg.out
+///
+EIGEN_DOC_UNARY_ADDONS(cwiseArg,arg)
+
+EIGEN_DEVICE_FUNC
+inline const CwiseArgReturnType
+cwiseArg() const { return CwiseArgReturnType(derived()); }
diff --git a/C++/yolo_bytetrack_old/include/Eigen/src/plugins/ReshapedMethods.h b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/ReshapedMethods.h
new file mode 100644
index 00000000..482a6b04
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/Eigen/src/plugins/ReshapedMethods.h
@@ -0,0 +1,149 @@
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+
+/// \returns an expression of \c *this with reshaped sizes.
+///
+/// \param nRows the number of rows in the reshaped expression, specified at either run-time or compile-time, or AutoSize
+/// \param nCols the number of columns in the reshaped expression, specified at either run-time or compile-time, or AutoSize
+/// \tparam Order specifies whether the coefficients should be processed in column-major-order (ColMajor), in row-major-order (RowMajor),
+///               or follows the \em natural order of the nested expression (AutoOrder). The default is ColMajor.
+/// \tparam NRowsType the type of the value handling the number of rows, typically Index.
+/// \tparam NColsType the type of the value handling the number of columns, typically Index.
+///
+/// Dynamic size example: \include MatrixBase_reshaped_int_int.cpp
+/// Output: \verbinclude MatrixBase_reshaped_int_int.out
+///
+/// The number of rows \a nRows and columns \a nCols can also be specified at compile-time by passing Eigen::fix<N>,
+/// or Eigen::fix<N>(n) as arguments. In the later case, \c n plays the role of a runtime fallback value in case \c N equals Eigen::Dynamic.
+/// Here is an example with a fixed number of rows and columns:
+/// \include MatrixBase_reshaped_fixed.cpp
+/// Output: \verbinclude MatrixBase_reshaped_fixed.out
+///
+/// Finally, one of the sizes parameter can be automatically deduced from the other one by passing AutoSize as in the following example:
+/// \include MatrixBase_reshaped_auto.cpp
+/// Output: \verbinclude MatrixBase_reshaped_auto.out
+/// AutoSize does preserve compile-time sizes when possible, i.e., when the sizes of the input are known at compile time \b and
+/// that the other size is passed at compile-time using Eigen::fix<N> as above.
+///
+/// \sa class Reshaped, fix, fix<N>(int)
+///
+template<int Order = ColMajor, typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+inline Reshaped<Derived,...>
+reshaped(NRowsType nRows, NColsType nCols);
+
+/// This is the const version of reshaped(NRowsType,NColsType).
+template<int Order = ColMajor, typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+inline const Reshaped<const Derived,...>
+reshaped(NRowsType nRows, NColsType nCols) const;
+
+/// \returns an expression of \c *this with columns (or rows) stacked to a linear column vector
+///
+/// \tparam Order specifies whether the coefficients should be processed in column-major-order (ColMajor), in row-major-order (RowMajor),
+///               or follows the \em natural order of the nested expression (AutoOrder). The default is ColMajor.
+///
+/// This overloads is essentially a shortcut for `A.reshaped<Order>(AutoSize,fix<1>)`.
+///
+/// - If `Order==ColMajor` (the default), then it returns a column-vector from the stacked columns of \c *this.
+/// - If `Order==RowMajor`, then it returns a column-vector from the stacked rows of \c *this.
+/// - If `Order==AutoOrder`, then it returns a column-vector with elements stacked following the storage order of \c *this.
+///   This mode is the recommended one when the particular ordering of the element is not relevant.
+///
+/// Example:
+/// \include MatrixBase_reshaped_to_vector.cpp
+/// Output: \verbinclude MatrixBase_reshaped_to_vector.out
+///
+/// If you want more control, you can still fall back to reshaped(NRowsType,NColsType).
+///
+/// \sa reshaped(NRowsType,NColsType), class Reshaped
+///
+template<int Order = ColMajor>
+EIGEN_DEVICE_FUNC
+inline Reshaped<Derived,...>
+reshaped();
+
+/// This is the const version of reshaped().
+template<int Order = ColMajor>
+EIGEN_DEVICE_FUNC
+inline const Reshaped<const Derived,...>
+reshaped() const;
+
+#else
+
+// This file is automatically included twice to generate const and non-const versions
+
+#ifndef EIGEN_RESHAPED_METHOD_2ND_PASS
+#define EIGEN_RESHAPED_METHOD_CONST const
+#else
+#define EIGEN_RESHAPED_METHOD_CONST
+#endif
+
+#ifndef EIGEN_RESHAPED_METHOD_2ND_PASS
+
+// This part is included once
+
+#endif
+
+template<typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,
+                internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,
+                internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value>
+reshaped(NRowsType nRows, NColsType nCols) EIGEN_RESHAPED_METHOD_CONST
+{
+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,
+                  internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,
+                  internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value>
+                (derived(),
+                 internal::get_runtime_reshape_size(nRows,internal::get_runtime_value(nCols),size()),
+                 internal::get_runtime_reshape_size(nCols,internal::get_runtime_value(nRows),size()));
+}
+
+template<int Order, typename NRowsType, typename NColsType>
+EIGEN_DEVICE_FUNC
+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,
+                internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,
+                internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value,
+                internal::get_compiletime_reshape_order<Flags,Order>::value>
+reshaped(NRowsType nRows, NColsType nCols) EIGEN_RESHAPED_METHOD_CONST
+{
+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,
+                  internal::get_compiletime_reshape_size<NRowsType,NColsType,SizeAtCompileTime>::value,
+                  internal::get_compiletime_reshape_size<NColsType,NRowsType,SizeAtCompileTime>::value,
+                  internal::get_compiletime_reshape_order<Flags,Order>::value>
+                (derived(),
+                 internal::get_runtime_reshape_size(nRows,internal::get_runtime_value(nCols),size()),
+                 internal::get_runtime_reshape_size(nCols,internal::get_runtime_value(nRows),size()));
+}
+
+// Views as linear vectors
+
+EIGEN_DEVICE_FUNC
+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,SizeAtCompileTime,1>
+reshaped() EIGEN_RESHAPED_METHOD_CONST
+{
+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived,SizeAtCompileTime,1>(derived(),size(),1);
+}
+
+template<int Order>
+EIGEN_DEVICE_FUNC
+inline Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived, SizeAtCompileTime, 1,
+                internal::get_compiletime_reshape_order<Flags,Order>::value>
+reshaped() EIGEN_RESHAPED_METHOD_CONST
+{
+  EIGEN_STATIC_ASSERT(Order==RowMajor || Order==ColMajor || Order==AutoOrder, INVALID_TEMPLATE_PARAMETER);
+  return Reshaped<EIGEN_RESHAPED_METHOD_CONST Derived, SizeAtCompileTime, 1,
+                  internal::get_compiletime_reshape_order<Flags,Order>::value>
+                (derived(), size(), 1);
+}
+
+#undef EIGEN_RESHAPED_METHOD_CONST
+
+#ifndef EIGEN_RESHAPED_METHOD_2ND_PASS
+#define EIGEN_RESHAPED_METHOD_2ND_PASS
+#include "ReshapedMethods.h"
+#undef EIGEN_RESHAPED_METHOD_2ND_PASS
+#endif
+
+#endif // EIGEN_PARSED_BY_DOXYGEN
diff --git a/C++/yolo_bytetrack_old/include/STrack.h b/C++/yolo_bytetrack_old/include/STrack.h
new file mode 100644
index 00000000..752cbefa
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/STrack.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <opencv2/opencv.hpp>
+#include "kalmanFilter.h"
+
+using namespace cv;
+using namespace std;
+
+enum TrackState { New = 0, Tracked, Lost, Removed };
+
+class STrack
+{
+public:
+	STrack(vector<float> tlwh_, float score);
+	~STrack();
+
+	vector<float> static tlbr_to_tlwh(vector<float> &tlbr);
+	void static multi_predict(vector<STrack*> &stracks, byte_kalman::KalmanFilter &kalman_filter);
+	void static_tlwh();
+	void static_tlbr();
+	vector<float> tlwh_to_xyah(vector<float> tlwh_tmp);
+	vector<float> to_xyah();
+	void mark_lost();
+	void mark_removed();
+	int next_id();
+	int end_frame();
+	
+	void activate(byte_kalman::KalmanFilter &kalman_filter, int frame_id);
+	void re_activate(STrack &new_track, int frame_id, bool new_id = false);
+	void update(STrack &new_track, int frame_id);
+
+public:
+	bool is_activated;
+	int track_id;
+	int state;
+
+	vector<float> _tlwh;
+	vector<float> tlwh;
+	vector<float> tlbr;
+	int frame_id;
+	int tracklet_len;
+	int start_frame;
+
+	KAL_MEAN mean;
+	KAL_COVA covariance;
+	float score;
+
+private:
+	byte_kalman::KalmanFilter kalman_filter;
+};
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/include/dataType.h b/C++/yolo_bytetrack_old/include/dataType.h
new file mode 100644
index 00000000..800fead3
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/dataType.h
@@ -0,0 +1,36 @@
+#pragma once
+#define EIGEN_DONT_ALIGN_STATICALLY
+#include <cstddef>
+#include <vector>
+
+#include <Eigen/Core>
+#include <Eigen/Dense>
+typedef Eigen::Matrix<float, 1, 4, Eigen::RowMajor> DETECTBOX;
+typedef Eigen::Matrix<float, -1, 4, Eigen::RowMajor> DETECTBOXSS;
+typedef Eigen::Matrix<float, 1, 128, Eigen::RowMajor> FEATURE;
+typedef Eigen::Matrix<float, Eigen::Dynamic, 128, Eigen::RowMajor> FEATURESS;
+//typedef std::vector<FEATURE> FEATURESS;
+
+//Kalmanfilter
+//typedef Eigen::Matrix<float, 8, 8, Eigen::RowMajor> KAL_FILTER;
+typedef Eigen::Matrix<float, 1, 8, Eigen::RowMajor> KAL_MEAN;
+typedef Eigen::Matrix<float, 8, 8, Eigen::RowMajor> KAL_COVA;
+typedef Eigen::Matrix<float, 1, 4, Eigen::RowMajor> KAL_HMEAN;
+typedef Eigen::Matrix<float, 4, 4, Eigen::RowMajor> KAL_HCOVA;
+using KAL_DATA = std::pair<KAL_MEAN, KAL_COVA>;
+using KAL_HDATA = std::pair<KAL_HMEAN, KAL_HCOVA>;
+
+//main
+using RESULT_DATA = std::pair<int, DETECTBOX>;
+
+//tracker:
+using TRACKER_DATA = std::pair<int, FEATURESS>;
+using MATCH_DATA = std::pair<int, int>;
+typedef struct t {
+	std::vector<MATCH_DATA> matches;
+	std::vector<int> unmatched_tracks;
+	std::vector<int> unmatched_detections;
+}TRACHER_MATCHD;
+
+//linear_assignment:
+typedef Eigen::Matrix<float, -1, -1, Eigen::RowMajor> DYNAMICM;
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/include/kalmanFilter.h b/C++/yolo_bytetrack_old/include/kalmanFilter.h
new file mode 100644
index 00000000..9aebc5af
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/kalmanFilter.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "dataType.h"
+
+namespace byte_kalman
+{
+	class KalmanFilter
+	{
+	public:
+		EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+		static const double chi2inv95[10];
+		KalmanFilter();
+		KAL_DATA initiate(const DETECTBOX& measurement);
+		void predict(KAL_MEAN& mean, KAL_COVA& covariance);
+		KAL_HDATA project(const KAL_MEAN& mean, const KAL_COVA& covariance);
+		KAL_DATA update(const KAL_MEAN& mean,
+			const KAL_COVA& covariance,
+			const DETECTBOX& measurement);
+
+		Eigen::Matrix<float, 1, -1> gating_distance(
+			const KAL_MEAN& mean,
+			const KAL_COVA& covariance,
+			const std::vector<DETECTBOX>& measurements,
+			bool only_position = false);
+
+	private:
+		Eigen::Matrix<float, 8, 8, Eigen::RowMajor> _motion_mat;
+		Eigen::Matrix<float, 4, 8, Eigen::RowMajor> _update_mat;
+		float _std_weight_position;
+		float _std_weight_velocity;
+	};
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/include/lapjv.h b/C++/yolo_bytetrack_old/include/lapjv.h
new file mode 100644
index 00000000..0e34385a
--- /dev/null
+++ b/C++/yolo_bytetrack_old/include/lapjv.h
@@ -0,0 +1,63 @@
+#ifndef LAPJV_H
+#define LAPJV_H
+
+#define LARGE 1000000
+
+#if !defined TRUE
+#define TRUE 1
+#endif
+#if !defined FALSE
+#define FALSE 0
+#endif
+
+#define NEW(x, t, n) if ((x = (t *)malloc(sizeof(t) * (n))) == 0) { return -1; }
+#define FREE(x) if (x != 0) { free(x); x = 0; }
+#define SWAP_INDICES(a, b) { int_t _temp_index = a; a = b; b = _temp_index; }
+
+#if 0
+#include <assert.h>
+#define ASSERT(cond) assert(cond)
+#define PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#define PRINT_COST_ARRAY(a, n) \
+    while (1) { \
+        printf(#a" = ["); \
+        if ((n) > 0) { \
+            printf("%f", (a)[0]); \
+            for (uint_t j = 1; j < n; j++) { \
+                printf(", %f", (a)[j]); \
+            } \
+        } \
+        printf("]\n"); \
+        break; \
+    }
+#define PRINT_INDEX_ARRAY(a, n) \
+    while (1) { \
+        printf(#a" = ["); \
+        if ((n) > 0) { \
+            printf("%d", (a)[0]); \
+            for (uint_t j = 1; j < n; j++) { \
+                printf(", %d", (a)[j]); \
+            } \
+        } \
+        printf("]\n"); \
+        break; \
+    }
+#else
+#define ASSERT(cond)
+#define PRINTF(fmt, ...)
+#define PRINT_COST_ARRAY(a, n)
+#define PRINT_INDEX_ARRAY(a, n)
+#endif
+
+
+typedef signed int int_t;
+typedef unsigned int uint_t;
+typedef double cost_t;
+typedef char boolean;
+typedef enum fp_t { FP_1 = 1, FP_2 = 2, FP_DYNAMIC = 3 } fp_t;
+
+extern int_t lapjv_internal(
+	const uint_t n, cost_t *cost[],
+	int_t *x, int_t *y);
+
+#endif // LAPJV_H
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/model/best_nofocus_new_21x80x80.rknn b/C++/yolo_bytetrack_old/model/best_nofocus_new_21x80x80.rknn
new file mode 100644
index 00000000..feafd043
Binary files /dev/null and b/C++/yolo_bytetrack_old/model/best_nofocus_new_21x80x80.rknn differ
diff --git a/C++/yolo_bytetrack_old/model/labels.txt b/C++/yolo_bytetrack_old/model/labels.txt
new file mode 100644
index 00000000..4d90a288
--- /dev/null
+++ b/C++/yolo_bytetrack_old/model/labels.txt
@@ -0,0 +1,2 @@
+person
+car
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/src/BYTETracker.cpp b/C++/yolo_bytetrack_old/src/BYTETracker.cpp
new file mode 100644
index 00000000..4292678d
--- /dev/null
+++ b/C++/yolo_bytetrack_old/src/BYTETracker.cpp
@@ -0,0 +1,242 @@
+#include "BYTETracker.h"
+#include <fstream>
+#include <iostream>
+
+BYTETracker::BYTETracker(int frame_rate, int track_buffer)
+{
+	track_thresh = 0.5;
+	high_thresh = 0.6;
+	match_thresh = 0.8;
+
+	frame_id = 0;
+	max_time_lost = int(frame_rate / 30.0 * track_buffer);
+	cout << "Init ByteTrack!" << endl;
+}
+
+BYTETracker::~BYTETracker()
+{
+}
+
+vector<STrack> BYTETracker::update(const vector<Object>& objects)
+{
+
+	////////////////// Step 1: Get detections //////////////////
+	this->frame_id++;
+	vector<STrack> activated_stracks;
+	vector<STrack> refind_stracks;
+	vector<STrack> removed_stracks;
+	vector<STrack> lost_stracks;
+	vector<STrack> detections;
+	vector<STrack> detections_low;
+
+	vector<STrack> detections_cp;
+	vector<STrack> tracked_stracks_swap;
+	vector<STrack> resa, resb;
+	vector<STrack> output_stracks;
+
+	vector<STrack*> unconfirmed;
+	vector<STrack*> tracked_stracks;
+	vector<STrack*> strack_pool;
+	vector<STrack*> r_tracked_stracks;
+
+	if (objects.size() > 0)
+	{
+		for (int i = 0; i < objects.size(); i++)
+		{
+			vector<float> tlbr_;
+			tlbr_.resize(4);
+			tlbr_[0] = objects[i].rect.x;
+			tlbr_[1] = objects[i].rect.y;
+			tlbr_[2] = objects[i].rect.x + objects[i].rect.width;
+			tlbr_[3] = objects[i].rect.y + objects[i].rect.height;
+
+			float score = objects[i].prob;
+
+			STrack strack(STrack::tlbr_to_tlwh(tlbr_), score);
+			if (score >= track_thresh)
+			{
+				detections.push_back(strack);
+			}
+			else
+			{
+				detections_low.push_back(strack);
+			}
+			
+		}
+	}
+
+	// Add newly detected tracklets to tracked_stracks
+	for (int i = 0; i < this->tracked_stracks.size(); i++)
+	{
+		if (!this->tracked_stracks[i].is_activated)
+			unconfirmed.push_back(&this->tracked_stracks[i]);
+		else
+			tracked_stracks.push_back(&this->tracked_stracks[i]);
+	}
+
+	////////////////// Step 2: First association, with IoU //////////////////
+	strack_pool = joint_stracks(tracked_stracks, this->lost_stracks);
+	STrack::multi_predict(strack_pool, this->kalman_filter);
+
+	vector<vector<float> > dists;
+	int dist_size = 0, dist_size_size = 0;
+	dists = iou_distance(strack_pool, detections, dist_size, dist_size_size);
+
+	vector<vector<int> > matches;
+	vector<int> u_track, u_detection;
+	linear_assignment(dists, dist_size, dist_size_size, match_thresh, matches, u_track, u_detection);
+
+	for (int i = 0; i < matches.size(); i++)
+	{
+		STrack *track = strack_pool[matches[i][0]];
+		STrack *det = &detections[matches[i][1]];
+		if (track->state == TrackState::Tracked)
+		{	
+			track->update(*det, this->frame_id);
+			activated_stracks.push_back(*track);
+		}
+		else
+		{
+			track->re_activate(*det, this->frame_id, false);
+			refind_stracks.push_back(*track);
+		}
+	}
+
+	////////////////// Step 3: Second association, using low score dets //////////////////
+	for (int i = 0; i < u_detection.size(); i++)
+	{
+		detections_cp.push_back(detections[u_detection[i]]);
+	}
+	detections.clear();
+	detections.assign(detections_low.begin(), detections_low.end());
+	
+	for (int i = 0; i < u_track.size(); i++)
+	{
+		if (strack_pool[u_track[i]]->state == TrackState::Tracked)
+		{
+			r_tracked_stracks.push_back(strack_pool[u_track[i]]);
+		}
+	}
+
+	dists.clear();
+	dists = iou_distance(r_tracked_stracks, detections, dist_size, dist_size_size);
+
+	matches.clear();
+	u_track.clear();
+	u_detection.clear();
+	linear_assignment(dists, dist_size, dist_size_size, 0.5, matches, u_track, u_detection);
+
+	for (int i = 0; i < matches.size(); i++)
+	{
+		STrack *track = r_tracked_stracks[matches[i][0]];
+		STrack *det = &detections[matches[i][1]];
+		if (track->state == TrackState::Tracked)
+		{
+			track->update(*det, this->frame_id);
+			activated_stracks.push_back(*track);
+		}
+		else
+		{
+			track->re_activate(*det, this->frame_id, false);
+			refind_stracks.push_back(*track);
+		}
+	}
+
+	for (int i = 0; i < u_track.size(); i++)
+	{
+		STrack *track = r_tracked_stracks[u_track[i]];
+		if (track->state != TrackState::Lost)
+		{
+			track->mark_lost();
+			lost_stracks.push_back(*track);
+		}
+	}
+
+	// Deal with unconfirmed tracks, usually tracks with only one beginning frame
+	detections.clear();
+	detections.assign(detections_cp.begin(), detections_cp.end());
+
+	dists.clear();
+	dists = iou_distance(unconfirmed, detections, dist_size, dist_size_size);
+
+	matches.clear();
+	vector<int> u_unconfirmed;
+	u_detection.clear();
+	linear_assignment(dists, dist_size, dist_size_size, 0.7, matches, u_unconfirmed, u_detection);
+
+	for (int i = 0; i < matches.size(); i++)
+	{
+		unconfirmed[matches[i][0]]->update(detections[matches[i][1]], this->frame_id);
+		activated_stracks.push_back(*unconfirmed[matches[i][0]]);
+	}
+
+	for (int i = 0; i < u_unconfirmed.size(); i++)
+	{
+		STrack *track = unconfirmed[u_unconfirmed[i]];
+		track->mark_removed();
+		removed_stracks.push_back(*track);
+	}
+
+	////////////////// Step 4: Init new stracks //////////////////
+	for (int i = 0; i < u_detection.size(); i++)
+	{
+		STrack *track = &detections[u_detection[i]];
+		if (track->score < this->high_thresh)
+			continue;
+		track->activate(this->kalman_filter, this->frame_id);
+		activated_stracks.push_back(*track);
+	}
+
+	////////////////// Step 5: Update state //////////////////
+	for (int i = 0; i < this->lost_stracks.size(); i++)
+	{
+		if (this->frame_id - this->lost_stracks[i].end_frame() > this->max_time_lost)
+		{
+			this->lost_stracks[i].mark_removed();
+			removed_stracks.push_back(this->lost_stracks[i]);
+		}
+	}
+	
+	for (int i = 0; i < this->tracked_stracks.size(); i++)
+	{
+		if (this->tracked_stracks[i].state == TrackState::Tracked)
+		{
+			tracked_stracks_swap.push_back(this->tracked_stracks[i]);
+		}
+	}
+	this->tracked_stracks.clear();
+	this->tracked_stracks.assign(tracked_stracks_swap.begin(), tracked_stracks_swap.end());
+
+	this->tracked_stracks = joint_stracks(this->tracked_stracks, activated_stracks);
+	this->tracked_stracks = joint_stracks(this->tracked_stracks, refind_stracks);
+
+	//std::cout << activated_stracks.size() << std::endl;
+
+	this->lost_stracks = sub_stracks(this->lost_stracks, this->tracked_stracks);
+	for (int i = 0; i < lost_stracks.size(); i++)
+	{
+		this->lost_stracks.push_back(lost_stracks[i]);
+	}
+
+	this->lost_stracks = sub_stracks(this->lost_stracks, this->removed_stracks);
+	for (int i = 0; i < removed_stracks.size(); i++)
+	{
+		this->removed_stracks.push_back(removed_stracks[i]);
+	}
+	
+	remove_duplicate_stracks(resa, resb, this->tracked_stracks, this->lost_stracks);
+
+	this->tracked_stracks.clear();
+	this->tracked_stracks.assign(resa.begin(), resa.end());
+	this->lost_stracks.clear();
+	this->lost_stracks.assign(resb.begin(), resb.end());
+	
+	for (int i = 0; i < this->tracked_stracks.size(); i++)
+	{
+		if (this->tracked_stracks[i].is_activated)
+		{
+			output_stracks.push_back(this->tracked_stracks[i]);
+		}
+	}
+	return output_stracks;
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/src/STrack.cpp b/C++/yolo_bytetrack_old/src/STrack.cpp
new file mode 100644
index 00000000..40a54b13
--- /dev/null
+++ b/C++/yolo_bytetrack_old/src/STrack.cpp
@@ -0,0 +1,199 @@
+#include "STrack.h"
+#include "dataType.h"
+#include <iostream>
+
+STrack::STrack(vector<float> tlwh_, float score)
+{
+	_tlwh.resize(4);
+	_tlwh.assign(tlwh_.begin(), tlwh_.end());
+
+	is_activated = false;
+	track_id = 0;
+	state = TrackState::New;
+	
+	tlwh.resize(4);
+	tlbr.resize(4);
+
+	static_tlwh();
+	static_tlbr();
+	frame_id = 0;
+	tracklet_len = 0;
+	this->score = score;
+	start_frame = 0;
+}
+
+STrack::~STrack()
+{
+}
+
+void STrack::activate(byte_kalman::KalmanFilter &kalman_filter, int frame_id)
+{
+	this->kalman_filter = kalman_filter;
+	this->track_id = this->next_id();
+
+	vector<float> _tlwh_tmp(4);
+	_tlwh_tmp[0] = this->_tlwh[0];
+	_tlwh_tmp[1] = this->_tlwh[1];
+	_tlwh_tmp[2] = this->_tlwh[2];
+	_tlwh_tmp[3] = this->_tlwh[3];
+	vector<float> xyah = tlwh_to_xyah(_tlwh_tmp);
+	DETECTBOX xyah_box;
+	xyah_box[0] = xyah[0];
+	xyah_box[1] = xyah[1];
+	xyah_box[2] = xyah[2];
+	xyah_box[3] = xyah[3];
+	auto mc = this->kalman_filter.initiate(xyah_box);
+	this->mean = mc.first;
+	this->covariance = mc.second;
+
+	static_tlwh();
+	static_tlbr();
+
+	this->tracklet_len = 0;
+	this->state = TrackState::Tracked;
+	if (frame_id == 1)
+	{
+		this->is_activated = true;
+	}
+	//this->is_activated = true;
+	this->frame_id = frame_id;
+	this->start_frame = frame_id;
+}
+
+void STrack::re_activate(STrack &new_track, int frame_id, bool new_id)
+{
+	vector<float> xyah = tlwh_to_xyah(new_track.tlwh);
+	DETECTBOX xyah_box;
+	xyah_box[0] = xyah[0];
+	xyah_box[1] = xyah[1];
+	xyah_box[2] = xyah[2];
+	xyah_box[3] = xyah[3];
+	auto mc = this->kalman_filter.update(this->mean, this->covariance, xyah_box);
+	this->mean = mc.first;
+	this->covariance = mc.second;
+
+	static_tlwh();
+	static_tlbr();
+
+	this->tracklet_len = 0;
+	this->state = TrackState::Tracked;
+	this->is_activated = true;
+	this->frame_id = frame_id;
+	this->score = new_track.score;
+	if (new_id)
+		this->track_id = next_id();
+}
+
+void STrack::update(STrack &new_track, int frame_id)
+{
+	this->frame_id = frame_id;
+	this->tracklet_len++;
+
+	vector<float> xyah = tlwh_to_xyah(new_track.tlwh);
+	DETECTBOX xyah_box;
+	xyah_box[0] = xyah[0];
+	xyah_box[1] = xyah[1];
+	xyah_box[2] = xyah[2];
+	xyah_box[3] = xyah[3];
+
+	// cout << "start kf update1" << endl;
+	// cout << this->mean[0] << " " <<  this->mean[1] << " " << this->mean[2] << " " << this->mean[3] << endl;
+	auto mc = this->kalman_filter.update(this->mean, this->covariance, xyah_box);
+	this->mean = mc.first;
+	this->covariance = mc.second;
+	// cout << "end kf update1" << endl;
+
+	static_tlwh();
+	static_tlbr();
+
+	this->state = TrackState::Tracked;
+	this->is_activated = true;
+
+	this->score = new_track.score;
+}
+
+void STrack::static_tlwh()
+{
+	if (this->state == TrackState::New)
+	{
+		tlwh[0] = _tlwh[0];
+		tlwh[1] = _tlwh[1];
+		tlwh[2] = _tlwh[2];
+		tlwh[3] = _tlwh[3];
+		return;
+	}
+
+	tlwh[0] = mean[0];
+	tlwh[1] = mean[1];
+	tlwh[2] = mean[2];
+	tlwh[3] = mean[3];
+
+	tlwh[2] *= tlwh[3];
+	tlwh[0] -= tlwh[2] / 2;
+	tlwh[1] -= tlwh[3] / 2;
+}
+
+void STrack::static_tlbr()
+{
+	tlbr.clear();
+	tlbr.assign(tlwh.begin(), tlwh.end());
+	tlbr[2] += tlbr[0];
+	tlbr[3] += tlbr[1];
+}
+
+vector<float> STrack::tlwh_to_xyah(vector<float> tlwh_tmp)
+{
+	vector<float> tlwh_output = tlwh_tmp;
+	tlwh_output[0] += tlwh_output[2] / 2;
+	tlwh_output[1] += tlwh_output[3] / 2;
+	tlwh_output[2] /= tlwh_output[3];
+	return tlwh_output;
+}
+
+vector<float> STrack::to_xyah()
+{
+	return tlwh_to_xyah(tlwh);
+}
+
+vector<float> STrack::tlbr_to_tlwh(vector<float> &tlbr)
+{
+	tlbr[2] -= tlbr[0];
+	tlbr[3] -= tlbr[1];
+	return tlbr;
+}
+
+void STrack::mark_lost()
+{
+	state = TrackState::Lost;
+}
+
+void STrack::mark_removed()
+{
+	state = TrackState::Removed;
+}
+
+int STrack::next_id()
+{
+	static int _count = 0;
+	_count++;
+	return _count;
+}
+
+int STrack::end_frame()
+{
+	return this->frame_id;
+}
+
+void STrack::multi_predict(vector<STrack*> &stracks, byte_kalman::KalmanFilter &kalman_filter)
+{
+	for (int i = 0; i < stracks.size(); i++)
+	{
+		if (stracks[i]->state != TrackState::Tracked)
+		{
+			stracks[i]->mean[7] = 0;
+		}
+		kalman_filter.predict(stracks[i]->mean, stracks[i]->covariance);
+		stracks[i]->static_tlwh();
+		stracks[i]->static_tlbr();
+	}
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/src/bytetrack.cpp b/C++/yolo_bytetrack_old/src/bytetrack.cpp
new file mode 100644
index 00000000..0e3d0790
--- /dev/null
+++ b/C++/yolo_bytetrack_old/src/bytetrack.cpp
@@ -0,0 +1,998 @@
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <numeric>
+#include <chrono>
+#include <vector>
+#include <openssl/sha.h>
+#include <openssl/evp.h>
+#include <ctime>
+#include <cstring>
+#include <unistd.h>
+#include <atomic>
+#include <thread>
+#include <chrono>
+#include <string>
+#include <dirent.h>
+#include <sys/time.h>
+#include "BYTETracker.h"
+#include "rknn_api.h"
+#include "opencv2/core/core.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/video.hpp"
+#include <unordered_set>
+
+unordered_set<int> low_id; //下行行人id集合
+unordered_set<int> up_id; //上行行人id集合
+unordered_set<int> total_region1; //在基准线下方的行人id存入该集合
+unordered_set<int> total_region2; //在基准线上方的行人id存入该集合
+
+#define CHECK(status) \
+    do\
+    {\
+        auto ret = (status);\
+        if (ret != 0)\
+        {\
+            cerr << "Cuda failure: " << ret << endl;\
+            abort();\
+        }\
+    } while (0)
+
+#define NMS_THRESH 0.45                       // NMS阈值
+#define NUM_ANCHORS 3                        // anchor的数量
+#define NUM_CLASSES 80                        // 类别数
+#define BBOX_CONF_THRESH 0.25                 // 置信度阈值
+#define OBJ_NUMB_MAX_SIZE 64                 // 最多检测的目标数
+#define SAVE_PATH "output.mp4"
+
+static const int INPUT_W = 640;              // 模型输入width
+static const int INPUT_H = 640;              // 模型输入height
+const int anchor[3][6] = {10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326};
+const string label_name[1] = {"person"};
+int step = 1;
+
+#define MAC_ADDRESS_LENGTH 18
+#define LICENSE_KEY_LENGTH 10 // 9 for base64 hash + 18 for timestamp
+#define EXPIRATION_PERIOD_SECONDS 60 // 设定的时间段，单位为秒
+
+static char mac_address[MAC_ADDRESS_LENGTH];
+std::atomic<bool> is_algorithm_running(true);
+
+
+// 获取设备的 MAC 地址
+void get_mac_address(char *mac_address) {
+    FILE *fp;
+    char path[1035];
+
+    // 执行 shell 命令获取 MAC 地址
+    fp = popen("cat /sys/class/net/ens33/address", "r"); // 根据实际情况修改 ens33
+    if (fp == NULL) {
+        perror("Failed to run command");
+        exit(EXIT_FAILURE);
+    }
+
+    // 读取输出
+    if (fgets(path, sizeof(path), fp) != NULL) {
+        strncpy(mac_address, path, MAC_ADDRESS_LENGTH - 1);
+        mac_address[MAC_ADDRESS_LENGTH - 1] = '\0';
+    }
+
+    pclose(fp);
+}
+
+// Base64 编码
+void base64_encode(const unsigned char *input, int length, char *output) {
+    EVP_ENCODE_CTX *ctx = EVP_ENCODE_CTX_new();
+    int outlen;
+    EVP_EncodeInit(ctx);
+    EVP_EncodeUpdate(ctx, (unsigned char *)output, &outlen, input, length);
+    EVP_EncodeFinal(ctx, (unsigned char *)(output + outlen), &outlen);
+    EVP_ENCODE_CTX_free(ctx);
+}
+
+// 生成授权码（使用 SHA-256 哈希算法，并进行 Base64 编码）
+void generate_license_key(const char *mac_address, char *license_key) {
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+    SHA256_CTX sha256;
+    SHA256_Init(&sha256);
+    SHA256_Update(&sha256, mac_address, strlen(mac_address));
+    SHA256_Final(hash, &sha256);
+
+    char base64_output[65];
+    base64_encode(hash, SHA256_DIGEST_LENGTH, base64_output);
+
+    strncpy(license_key, base64_output, LICENSE_KEY_LENGTH - 1);
+    license_key[LICENSE_KEY_LENGTH - 1] = '\0';
+}
+
+// 验证授权码是否有效
+bool validate_license_key(const char *mac_address, const char *input_license_key) {
+    char generated_license_key[LICENSE_KEY_LENGTH];
+    generate_license_key(mac_address, generated_license_key);
+
+    return strcmp(input_license_key, generated_license_key) == 0;
+}
+
+
+// 检查授权是否过期
+void check_license_thread() {
+    // 固定到期时间为 2024 年 7 月 10 日，0 点（UTC 时间）
+    std::tm expiration_time = {};
+    expiration_time.tm_year = 2024 - 1900; // 年份从 1900 年开始计算
+    expiration_time.tm_mon = 7; // 月份从 0 开始计算（7 月为 6）
+    expiration_time.tm_mday = 10; // 日
+
+    // 转换为时间戳
+    std::time_t expiration_timestamp = std::mktime(&expiration_time);
+
+    while (true) {
+        std::this_thread::sleep_for(std::chrono::seconds(1)); // 每秒检查一次
+
+        // 获取当前时间
+        std::time_t now = std::time(nullptr);
+
+        // 检查授权是否过期
+        if (now > expiration_timestamp) {
+            std::cout << "License has expired. Stopping algorithm..." << std::endl;
+            is_algorithm_running.store(false);
+            break;
+        }
+    }
+}
+
+
+cv::Mat static_resize(cv::Mat& img) {
+    float r = min(INPUT_W / (img.cols*1.0), INPUT_H / (img.rows*1.0));
+    // r = std::min(r, 1.0f);
+    int unpad_w = r * img.cols;
+    int unpad_h = r * img.rows;
+    cv::Mat re(unpad_h, unpad_w, CV_8UC3);
+    cv::resize(img, re, re.size());
+    cv::Mat out(INPUT_H, INPUT_W, CV_8UC3, cv::Scalar(114, 114, 114));
+    re.copyTo(out(Rect(0, 0, re.cols, re.rows)));
+    return out;
+}
+
+struct GridAndStride
+{
+    int grid0; // grid_w：模型输入width/stride   width方向的网格数量
+    int grid1; // grid_h：模型输入height/stride    height方向的网格数量
+    int stride; // 下采样倍数，取值有8、16、32
+};
+
+static void check_ret(int ret, string ret_name)
+{
+    // 检查ret是否正确并输出，ret_name表示哪一步
+    if (ret < 0)
+    {
+        cout << ret_name << " error ret=" << ret << endl;
+    }
+}
+
+static void dump_tensor_attr(rknn_tensor_attr *attr)
+{
+    // 打印模型输入和输出的信息
+    printf("  index=%d, name=%s, n_dims=%d, dims=[%d, %d, %d, %d], n_elems=%d, size=%d, fmt=%s, type=%s, qnt_type=%s, "
+           "zp=%d, scale=%f\n",
+           attr->index, attr->name, attr->n_dims, attr->dims[3], attr->dims[2], attr->dims[1], attr->dims[0],
+           attr->n_elems, attr->size, get_format_string(attr->fmt), get_type_string(attr->type),
+           get_qnt_type_string(attr->qnt_type), attr->zp, attr->scale);
+}
+
+// t为结构体，存储了时间信息：1、tv_sec 代表多少秒；2、tv_usec 代表多少微秒， 1000000 微秒 = 1秒
+double __get_us(struct timeval t) { return (t.tv_sec * 1000000 + t.tv_usec);} 
+
+static float sigmoid(float x)
+{
+    return 1.0 / (1.0 + expf(-x));
+}
+
+static float unsigmoid(float y)
+{
+    return -1.0 * logf((1.0 / y) - 1.0);
+}
+
+inline static int32_t __clip(float val, float min, float max)
+{
+    float f = val <= min ? min : (val >= max ? max : val);
+    return f;
+}
+
+static int8_t qnt_f32_to_affine(float f32, int32_t zp, float scale)  // 量化
+{
+    float dst_val = (f32 / scale) + zp;
+    int8_t res = (int8_t)__clip(dst_val, -128, 127);
+    return res;
+}
+
+static uint8_t qnt_f32_to_affine_u8(float f32, int32_t zp, float scale)
+{
+    float dst_val = (f32 / scale) + zp;
+    uint8_t res = (uint8_t)__clip(dst_val, 0, 255);
+    return res;
+}
+
+static float deqnt_affine_to_f32(int8_t qnt, int32_t zp, float scale)  // 反量化
+{
+    return ((float)qnt - (float)zp) * scale;
+}
+
+static float deqnt_affine_u8_to_f32(uint8_t qnt, int32_t zp, float scale) { return ((float)qnt - (float)zp) * scale; }
+
+static void generate_grids_and_stride(const int target_w, const int target_h, vector<int>& strides, vector<GridAndStride>& grid_strides)
+{
+    /*
+        生成网格(直接精确到具体哪个网格)和步幅[没用到]
+        target_w：模型输入width
+        target_h：模型输入height
+        strides：下采样倍数  vector<int> strides = {8, 16, 32};
+        grid_stride：vector<GridAndStride> grid_strides;上面定义了GridAndStride结构体
+    */
+    for (auto stride : strides)
+    {
+        int num_grid_w = target_w / stride;
+        int num_grid_h = target_h / stride;
+        
+        for (int g1 = 0; g1 < num_grid_h; g1++)
+        {
+            for (int g0 = 0; g0 < num_grid_w; g0++)
+            {
+                // printf("generate_grids_and_stride:  %d\t,%d\t,%d\n", g0, g1, stride);
+                grid_strides.push_back((GridAndStride){g0, g1, stride});
+            }
+        }
+    }
+}
+static void generate_grids(const int target_w, const int target_h, vector<int>& strides, vector<GridAndStride>& grid_strides)
+{
+    /*
+        生成网格和步幅
+        target_w：模型输入width
+        target_h：模型输入height
+        strides：下采样倍数  vector<int> strides = {8, 16, 32};
+        grid_stride：vector<GridAndStride> grid_strides;上面定义了GridAndStride结构体
+    */
+    for (auto stride : strides)
+    {
+        int num_grid_w = target_w / stride;
+        int num_grid_h = target_h / stride;
+        grid_strides.push_back((GridAndStride){num_grid_w, num_grid_h, stride});
+        
+    }
+}
+
+static inline float intersection_area(const Object& a, const Object& b)
+{
+    Rect_<float> inter = a.rect & b.rect;
+    return inter.area();
+}
+
+static void qsort_descent_inplace(vector<Object>& faceobjects, int left, int right)
+{
+    int i = left;
+    int j = right;
+    float p = faceobjects[(left + right) / 2].prob;
+
+    while (i <= j)
+    {
+        while (faceobjects[i].prob > p)
+            i++;
+
+        while (faceobjects[j].prob < p)
+            j--;
+
+        if (i <= j)
+        {
+            // swap
+            std::swap(faceobjects[i], faceobjects[j]);
+
+            i++;
+            j--;
+        }
+    }
+
+    #pragma omp parallel sections
+    {
+        #pragma omp section
+        {
+            if (left < j) qsort_descent_inplace(faceobjects, left, j);
+        }
+        #pragma omp section
+        {
+            if (i < right) qsort_descent_inplace(faceobjects, i, right);
+        }
+    }
+}
+
+static void qsort_descent_inplace(vector<Object>& objects)
+{
+    if (objects.empty())
+        return;
+
+    qsort_descent_inplace(objects, 0, objects.size() - 1);
+}
+
+static void nms_sorted_bboxes(const vector<Object>& faceobjects, vector<int>& picked, float nms_threshold)
+{
+    picked.clear();
+
+    const int n = faceobjects.size();
+
+    vector<float> areas(n);
+    for (int i = 0; i < n; i++)
+    {
+        areas[i] = faceobjects[i].rect.area();
+    }
+
+    for (int i = 0; i < n; i++)
+    {
+        const Object& a = faceobjects[i];
+
+        int keep = 1;
+        for (int j = 0; j < (int)picked.size(); j++)
+        {
+            const Object& b = faceobjects[picked[j]];
+
+            // intersection over union
+            float inter_area = intersection_area(a, b);
+            float union_area = areas[i] + areas[picked[j]] - inter_area;
+            // float IoU = inter_area / union_area
+            if (inter_area / union_area > nms_threshold)
+                keep = 0;
+        }
+
+        if (keep)
+            picked.push_back(i);
+    }
+}
+
+static void generate_yolo_proposals(GridAndStride grid_stride, uint8_t *output, int *anchor, float prob_threshold, vector<Object>& objects, int32_t zp, float scale)
+{
+    const int num_class = NUM_CLASSES;
+    const int num_anchors = NUM_ANCHORS;
+    const int grid0 = grid_stride.grid0;
+    const int grid1 = grid_stride.grid1;
+    const int stride = grid_stride.stride;
+    int grid_len = grid0 * grid1;
+    // float thres = unsigmoid(prob_threshold);
+    uint8_t thres_u8 = qnt_f32_to_affine_u8(prob_threshold, zp, scale);
+
+    for (int anchor_idx = 0; anchor_idx < num_anchors; anchor_idx++)
+    {
+        // 三个anchor
+        for (int i = 0; i < grid1; i++)
+        {
+            for (int j = 0; j < grid0; j++)
+            {
+                uint8_t box_objectness = output[(anchor_idx * (num_class + 5) + 4) * grid_len + i * grid0 + j];
+                if (box_objectness >= thres_u8)
+                {
+                    // cout << "box_objectness: " << box_objectness << endl; 
+                    int basic_pos = anchor_idx * (num_class + 5) * grid_len + i * grid0 + j;; // 相当于detection.py中的(PROP_BOX_SIZE * a + 4) * grid_len + i * grid_w + j;
+                    uint8_t *in_ptr = output + basic_pos;
+                    float box_x = (deqnt_affine_u8_to_f32(*in_ptr, zp, scale)) * 2.0 - 0.5;
+                    float box_y = (deqnt_affine_u8_to_f32(in_ptr[grid_len], zp, scale)) * 2.0 - 0.5;
+                    float box_w = (deqnt_affine_u8_to_f32(in_ptr[2 * grid_len], zp, scale)) * 2.0;
+                    float box_h = (deqnt_affine_u8_to_f32(in_ptr[3 * grid_len], zp, scale)) * 2.0;
+                    float x_center = (box_x + j) * (float)stride;
+                    float y_center = (box_y + i) * (float)stride;
+                    float w = box_w * box_w * (float)anchor[anchor_idx * 2];
+                    float h = box_h * box_h * (float)anchor[anchor_idx * 2 + 1];
+                    float x0 = x_center - w * 0.5f;
+                    float y0 = y_center - h * 0.5f;
+
+                    uint8_t maxClassProbs = in_ptr[5 * grid_len];
+                    int maxClassId = 0;
+                    for (int class_idx = 0; class_idx < num_class; class_idx++)
+                    {
+                        uint8_t prob = in_ptr[(5 + class_idx) * grid_len];
+                        if (prob > maxClassProbs)
+                        {
+                            maxClassId = class_idx;
+                            maxClassProbs = prob;
+                        }
+                    }
+
+                    if(maxClassId != 0)
+                        continue;
+
+                    if(maxClassProbs > thres_u8)
+                    {
+                        // cout << "maxClassProbs: " << maxClassProbs << endl;
+                        Object obj;
+                        obj.rect.x = x0;
+                        obj.rect.y = y0;
+                        obj.rect.width = w;
+                        obj.rect.height = h;
+                        obj.label = maxClassId;
+                        obj.prob = (deqnt_affine_u8_to_f32(maxClassProbs, zp, scale));
+
+                        objects.push_back(obj);
+                    }
+                    // for (int class_idx = 0; class_idx < num_class; class_idx++)
+                    // {
+                    //     int8_t box_cls_score = output[(anchor_idx * (num_class + 5) + 5) * grid_len + i * grid0 + j + class_idx];
+                    //     Object obj;
+                    //     obj.rect.x = x0;
+                    //     obj.rect.y = y0;
+                    //     obj.rect.width = w;
+                    //     obj.rect.height = h;
+                    //     obj.label = class_idx;
+                    //     obj.prob = (deqnt_affine_to_f32(box_cls_score, zp, scale));
+
+                    //     objects.push_back(obj);
+                    // }
+                }
+            }
+        }
+    }
+}
+float* blobFromImage(cv::Mat& img){
+    // 归一化操作 将原始图像拉成一维数组了
+    cvtColor(img, img, COLOR_BGR2RGB);
+
+    float* blob = new float[img.total()*3]; //Mat.total()返回Mat的单个通道中的元素总数，该元素等于Mat.size中值的乘积。对于RGB图像，total() = rows*cols。
+    int channels = 3;
+    int img_h = img.rows;
+    int img_w = img.cols;
+    vector<float> mean = {0.485, 0.456, 0.406};
+    vector<float> std = {0.229, 0.224, 0.225};
+    for (size_t c = 0; c < channels; c++) 
+    {
+        for (size_t  h = 0; h < img_h; h++) 
+        {
+            for (size_t w = 0; w < img_w; w++) 
+            {
+                blob[c * img_w * img_h + h * img_w + w] =
+                    (((float)img.at<Vec3b>(h, w)[c]) / 255.0f - mean[c]) / std[c];
+            }
+        }
+    }
+    return blob;
+}
+
+
+static void decode_outputs(rknn_output *outputs, vector<Object>& objects, float resize_scale, const int img_w, const int img_h, int32_t *qnt_zps, float *qnt_scales) {
+        vector<Object> proposals;
+        vector<int> strides = {8, 16, 32};
+        vector<GridAndStride> grid_strides;
+        generate_grids(INPUT_W, INPUT_H, strides, grid_strides);
+        for(int i = 0; i < 3; i++){
+            // 三个尺度
+            generate_yolo_proposals(grid_strides[i], (uint8_t *)outputs[i].buf, (int *)anchor[i], BBOX_CONF_THRESH, proposals, qnt_zps[i], qnt_scales[i]);
+        }
+        std::cout << "num of boxes before nms: " << proposals.size() << std::endl;
+
+        qsort_descent_inplace(proposals);
+
+        vector<int> picked;
+        nms_sorted_bboxes(proposals, picked, NMS_THRESH);
+
+
+        int count = picked.size();
+
+        std::cout << "num of boxes: " << count << std::endl;
+
+        objects.resize(count);
+        for (int i = 0; i < count; i++)
+        {
+            objects[i] = proposals[picked[i]];
+
+            // adjust offset to original unpadded
+            float x0 = (objects[i].rect.x) / resize_scale;
+            float y0 = (objects[i].rect.y) / resize_scale;
+            float x1 = (objects[i].rect.x + objects[i].rect.width) / resize_scale;
+            float y1 = (objects[i].rect.y + objects[i].rect.height) / resize_scale;
+
+            objects[i].rect.x = x0;
+            objects[i].rect.y = y0;
+            objects[i].rect.width = x1 - x0;
+            objects[i].rect.height = y1 - y0;
+            // cout << label_name[objects[i].label] << " @ " << objects[i].prob << endl;
+        }
+}
+
+const float color_list[80][3] =
+{
+    {0.000, 0.447, 0.741},
+    {0.850, 0.325, 0.098},
+    {0.929, 0.694, 0.125},
+    {0.494, 0.184, 0.556},
+    {0.466, 0.674, 0.188},
+    {0.301, 0.745, 0.933},
+    {0.635, 0.078, 0.184},
+    {0.300, 0.300, 0.300},
+    {0.600, 0.600, 0.600},
+    {1.000, 0.000, 0.000},
+    {1.000, 0.500, 0.000},
+    {0.749, 0.749, 0.000},
+    {0.000, 1.000, 0.000},
+    {0.000, 0.000, 1.000},
+    {0.667, 0.000, 1.000},
+    {0.333, 0.333, 0.000},
+    {0.333, 0.667, 0.000},
+    {0.333, 1.000, 0.000},
+    {0.667, 0.333, 0.000},
+    {0.667, 0.667, 0.000},
+    {0.667, 1.000, 0.000},
+    {1.000, 0.333, 0.000},
+    {1.000, 0.667, 0.000},
+    {1.000, 1.000, 0.000},
+    {0.000, 0.333, 0.500},
+    {0.000, 0.667, 0.500},
+    {0.000, 1.000, 0.500},
+    {0.333, 0.000, 0.500},
+    {0.333, 0.333, 0.500},
+    {0.333, 0.667, 0.500},
+    {0.333, 1.000, 0.500},
+    {0.667, 0.000, 0.500},
+    {0.667, 0.333, 0.500},
+    {0.667, 0.667, 0.500},
+    {0.667, 1.000, 0.500},
+    {1.000, 0.000, 0.500},
+    {1.000, 0.333, 0.500},
+    {1.000, 0.667, 0.500},
+    {1.000, 1.000, 0.500},
+    {0.000, 0.333, 1.000},
+    {0.000, 0.667, 1.000},
+    {0.000, 1.000, 1.000},
+    {0.333, 0.000, 1.000},
+    {0.333, 0.333, 1.000},
+    {0.333, 0.667, 1.000},
+    {0.333, 1.000, 1.000},
+    {0.667, 0.000, 1.000},
+    {0.667, 0.333, 1.000},
+    {0.667, 0.667, 1.000},
+    {0.667, 1.000, 1.000},
+    {1.000, 0.000, 1.000},
+    {1.000, 0.333, 1.000},
+    {1.000, 0.667, 1.000},
+    {0.333, 0.000, 0.000},
+    {0.500, 0.000, 0.000},
+    {0.667, 0.000, 0.000},
+    {0.833, 0.000, 0.000},
+    {1.000, 0.000, 0.000},
+    {0.000, 0.167, 0.000},
+    {0.000, 0.333, 0.000},
+    {0.000, 0.500, 0.000},
+    {0.000, 0.667, 0.000},
+    {0.000, 0.833, 0.000},
+    {0.000, 1.000, 0.000},
+    {0.000, 0.000, 0.167},
+    {0.000, 0.000, 0.333},
+    {0.000, 0.000, 0.500},
+    {0.000, 0.000, 0.667},
+    {0.000, 0.000, 0.833},
+    {0.000, 0.000, 1.000},
+    {0.000, 0.000, 0.000},
+    {0.143, 0.143, 0.143},
+    {0.286, 0.286, 0.286},
+    {0.429, 0.429, 0.429},
+    {0.571, 0.571, 0.571},
+    {0.714, 0.714, 0.714},
+    {0.857, 0.857, 0.857},
+    {0.000, 0.447, 0.741},
+    {0.314, 0.717, 0.741},
+    {0.50, 0.5, 0}
+};
+
+static unsigned char *load_data(FILE *fp, size_t ofst, size_t sz)
+{
+    unsigned char *data;
+    int ret;
+
+    data = NULL;
+
+    if (NULL == fp)
+    {
+        return NULL;
+    }
+
+    ret = fseek(fp, ofst, SEEK_SET);
+    if (ret != 0)
+    {
+        printf("blob seek failure.\n");
+        return NULL;
+    }
+
+    data = (unsigned char *)malloc(sz);
+    if (data == NULL)
+    {
+        printf("buffer malloc failure.\n");
+        return NULL;
+    }
+    ret = fread(data, 1, sz, fp);
+    return data;
+}
+
+static unsigned char *load_model(const char *filename, int *model_size)
+{
+    /* 
+    加载rknn模型
+    filename : rknn模型文件路径
+    model_size : 模型的大小
+    */
+    FILE *fp;
+    unsigned char *data;
+
+    fp = fopen(filename, "rb");
+    if (NULL == fp)
+    {
+        printf("Open rknn model file %s failed.\n", filename);
+        return NULL;
+    }
+
+    fseek(fp, 0, SEEK_END);
+    int size = ftell(fp);
+
+    data = load_data(fp, 0, size);
+
+    fclose(fp);
+
+    *model_size = size;
+    return data;
+}
+
+
+void run_algorithm(const std::vector<std::string>& params) 
+{
+    struct timeval start_time, stop_time, begin_time, end_time, start_decode, end_decode, start_track, end_track, start_write, end_write, start_draw, end_draw, start_read, end_read; // 用于计时
+
+    size_t length = params.size();
+
+    const char *model_name = params[0].c_str();
+ 
+    // 开始计时
+    // gettimeofday(&begin_time, NULL);
+    /********************rknn init*********************/
+    string ret_name;
+    ret_name = "rknn_init"; // 表示rknn的步骤名称
+    rknn_context ctx; // 创建rknn_context对象
+    int model_data_size = 0; // 模型的大小
+    unsigned char *model_data = load_model(model_name, &model_data_size); // 加载RKNN模型
+    /* 初始化参数flag
+    RKNN_FLAG_COLLECT_PERF_MASK：用于运行时查询网络各层时间。
+    RKNN_FLAG_MEM_ALLOC_OUTSIDE：用于表示模型输入、输出、权重、中间 tensor 内存全部由用户分配。
+    */
+    // int ret = rknn_init(&ctx, model_data, model_data_size, RKNN_FLAG_COLLECT_PERF_MASK, NULL); // 初始化RKNN
+    int ret = rknn_init(&ctx, model_data, model_data_size, 0);
+    check_ret(ret, ret_name);
+    // 设置NPU核心为自动调度
+    // rknn_core_mask core_mask = RKNN_NPU_CORE_AUTO;
+    // ret = rknn_set_core_mask(ctx, core_mask);
+    
+
+    /********************rknn query*********************/
+    // rknn_query 函数能够查询获取到模型输入输出信息、逐层运行时间、模型推理的总时间、
+    // SDK 版本、内存占用信息、用户自定义字符串等信息。
+    // 版本信息
+    ret_name = "rknn_query";
+    rknn_sdk_version version; // SDK版本信息结构体
+    ret = rknn_query(ctx, RKNN_QUERY_SDK_VERSION, &version, sizeof(rknn_sdk_version));
+    check_ret(ret, ret_name);
+    printf("sdk api version: %s\n", version.api_version);
+    printf("driver version: %s\n", version.drv_version);
+
+    // 输入输出信息
+    rknn_input_output_num io_num;
+    ret = rknn_query(ctx, RKNN_QUERY_IN_OUT_NUM, &io_num, sizeof(io_num));
+    check_ret(ret, ret_name);
+    printf("model input num: %d, output num: %d\n", io_num.n_input, io_num.n_output);
+
+    // 输入输出Tensor属性
+    rknn_tensor_attr input_attrs[io_num.n_input];
+    memset(input_attrs, 0, sizeof(input_attrs)); // 初始化内存
+    for (int i = 0; i < io_num.n_input; i++)
+    {
+        input_attrs[i].index = i; // 输入的索引位置
+        ret = rknn_query(ctx, RKNN_QUERY_INPUT_ATTR, &(input_attrs[i]), sizeof(rknn_tensor_attr));
+        check_ret(ret, ret_name);
+        dump_tensor_attr(&(input_attrs[i]));
+    }
+
+    rknn_tensor_attr output_attrs[io_num.n_output];
+    memset(output_attrs, 0, sizeof(output_attrs));
+    for (int i = 0; i < io_num.n_output; i++)
+    {
+        output_attrs[i].index = i;
+        ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(output_attrs[i]), sizeof(rknn_tensor_attr));
+        check_ret(ret, ret_name);
+        dump_tensor_attr(&(output_attrs[i]));
+    }
+
+    // 模型输入信息
+    int channel = 3;
+    int width = 0;
+    int height = 0;
+    if (input_attrs[0].fmt == RKNN_TENSOR_NCHW)
+    {
+        printf("model is NCHW input fmt\n");
+        channel = input_attrs[0].dims[2];
+        width = input_attrs[0].dims[0];
+        height = input_attrs[0].dims[1];
+    }
+    else
+    {
+        printf("model is NHWC input fmt\n");
+        width = input_attrs[0].dims[1];
+        height = input_attrs[0].dims[2];
+        channel = input_attrs[0].dims[3];
+    }
+
+    
+    const string input_video_path {params[1]};
+    static float* prob = new float[OBJ_NUMB_MAX_SIZE]; //
+
+    //cv::VideoCapture cap(input_video_path);
+    cv::VideoCapture cap;
+    cap.open(input_video_path);
+	if (!cap.isOpened()){
+        printf("video can't open\n");
+    }
+
+	int img_w = cap.get(cv::CAP_PROP_FRAME_WIDTH);
+	int img_h = cap.get(cv::CAP_PROP_FRAME_HEIGHT);
+    int fps = cap.get(cv::CAP_PROP_FPS);
+    double Video_fourcc = cap.get(cv::CAP_PROP_FOURCC);
+    long nFrame = static_cast<long>(cap.get(cv::CAP_PROP_FRAME_COUNT));
+    cout << "video width:" << img_w << '\n' << "video hight:" << img_h << endl;
+    cout << "Total frames: " << nFrame << endl;
+
+    const int baseline = (length > 3) ? std::atoi(params[2].c_str()) : img_h / 2; //如果没有输入，划线纵坐标为视频高度一般
+    const int x_min = (length > 4) ? std::atoi(params[3].c_str()) : 0;
+    const int x_max = (length > 5) ? std::atoi(params[4].c_str()) : img_w;  //如果没有输入，划线横坐标默认为整个视频
+
+    // cv::VideoWriter writer("demo.mp4", VideoWriter::fourcc('m', 'p', '4', 'v'), fps, Size(img_w, img_h));
+    cv::VideoWriter writer;
+    writer = cv::VideoWriter(SAVE_PATH, Video_fourcc, fps, cv::Size(img_w, img_h));
+    cv::Mat img;
+    BYTETracker tracker(fps, 50);
+    int num_frames = 0;
+    int total_ms = 0;
+    gettimeofday(&begin_time, NULL);
+	while (is_algorithm_running.load())
+    {
+        gettimeofday(&start_read, NULL);
+        if(!cap.read(img))
+        {
+            cout <<" Break at cap.read(img) !" << endl;
+            break;
+        }
+        num_frames++;
+        if(num_frames > step && num_frames % step != 0)
+            continue;
+        cout << "Frames index:" << num_frames << endl;
+        if (num_frames % 20 == 0)
+        {
+            cout << "Processing frame " << num_frames << " (" << num_frames * 1000000 / total_ms << " fps)" << endl;
+        }
+		if (img.empty())
+        {
+			break;
+        }
+        cv::Mat pr_img = static_resize(img); // resize图像
+        // cv::imwrite("resize.jpg", pr_img);
+        // float* blob;         
+        // blob = blobFromImage(pr_img); // 归一化图像
+        float resize_scale = min(INPUT_W / (img.cols*1.0), INPUT_H / (img.rows*1.0)); // 图像缩放尺度
+        gettimeofday(&end_read, NULL);
+        printf("read image use %f ms\n", (__get_us(end_read) - __get_us(start_read)) / 1000);
+        /********************rknn inputs set*********************/
+        gettimeofday(&start_time, NULL);
+        ret_name = "rknn_inputs_set";
+        rknn_input inputs[1];
+        memset(inputs, 0, sizeof(inputs));
+    
+        inputs[0].index = 0;                       // 输入的索引位置
+        inputs[0].type = RKNN_TENSOR_UINT8;        // 输入数据类型 采用INT8
+        inputs[0].size = 640 * 640 * 3; // 这里用的是模型的
+        inputs[0].fmt = RKNN_TENSOR_NHWC;        // 输入格式，NHWC
+        inputs[0].pass_through = 0;                // 为0代表需要进行预处理
+        inputs[0].buf = pr_img.data;               // 如果进行resize需要改为resize的data
+
+        ret = rknn_inputs_set(ctx, io_num.n_input, inputs);
+        check_ret(ret, ret_name);
+        gettimeofday(&stop_time, NULL);
+        printf("rknn input %f ms\n", (__get_us(stop_time) - __get_us(start_time)) / 1000);
+        /********************rknn run****************************/
+        gettimeofday(&start_time, NULL);
+        ret_name = "rknn_run";
+        ret = rknn_run(ctx, NULL); // 推理
+        check_ret(ret, ret_name);
+        gettimeofday(&stop_time, NULL);
+        total_ms = total_ms + (__get_us(stop_time) - __get_us(start_time)) / 1000;
+        printf("once run use %f ms\n", (__get_us(stop_time) - __get_us(start_time)) / 1000);
+
+        /********************rknn outputs get****************************/
+        gettimeofday(&start_time, NULL);
+        ret_name = "rknn_outputs_get";
+        float out_scales[3] = {0, 0, 0}; // 存储scales 和 zp
+        int32_t out_zps[3] = {0, 0, 0};
+        // 创建rknn_output对象
+        rknn_output outputs[io_num.n_output];
+        memset(outputs, 0, sizeof(outputs));
+        for (int i = 0; i < io_num.n_output; i++) 
+        { 
+            outputs[i].index = i; // 输出索引
+            // outputs[i].is_prealloc = 0; // 由rknn来分配输出的buf，指向输出数据
+            outputs[i].want_float = 0;
+            out_scales[i] = output_attrs[i].scale;
+            out_zps[i] = output_attrs[i].zp; 
+        }
+        ret = rknn_outputs_get(ctx, io_num.n_output, outputs, NULL);
+        gettimeofday(&stop_time, NULL);
+        printf("rknn output %f ms\n", (__get_us(stop_time) - __get_us(start_time)) / 1000);
+        /********************是否打印推理时间细节****************************/
+        ret_name = "rknn_perf_detail_display";
+        rknn_perf_detail perf_detail;
+        ret = rknn_query(ctx, RKNN_QUERY_PERF_DETAIL, &perf_detail, sizeof(perf_detail));
+        check_ret(ret, ret_name);
+        // printf("%s\n",perf_detail.perf_data);
+
+        // 解码推理结果并进行跟踪
+        gettimeofday(&start_decode, NULL);
+        vector<Object> objects;
+        decode_outputs(outputs, objects, resize_scale, img_w, img_h, out_zps, out_scales);
+        gettimeofday(&end_decode, NULL);
+        printf("decode %f ms\n", (__get_us(end_decode) - __get_us(start_decode)) / 1000);
+        gettimeofday(&start_track, NULL);
+        vector<STrack> output_stracks = tracker.update(objects);
+        gettimeofday(&end_track, NULL);
+        printf("track %f ms\n", (__get_us(end_track) - __get_us(start_track)) / 1000);
+
+        gettimeofday(&start_draw, NULL);
+        // 画检测的框
+        /*
+        for (int i = 0; i < objects.size(); i++)
+        {
+            // objects[i].rect.x = x0;
+            // objects[i].rect.y = y0;
+            // objects[i].rect.width = x1 - x0;
+            // objects[i].rect.height = y1 - y0;
+            
+
+            cv::Scalar s = tracker.get_color(1);
+		    putText(img, label_name[objects[i].label], Point(objects[i].rect.x, objects[i].rect.y - 5), 
+                    0, 0.6, cv::Scalar(0, 0, 255), 2, LINE_AA);
+            rectangle(img, Rect(objects[i].rect.x, objects[i].rect.y, objects[i].rect.width, objects[i].rect.height), s, 2);
+        }
+        */
+        // cv::Mat img2 = img.clone();
+        // for (int i = 0; i < objects.size(); i++)
+        // {
+        //     // objects[i].rect.x = x0;
+        //     // objects[i].rect.y = y0;
+        //     // objects[i].rect.width = x1 - x0;
+        //     // objects[i].rect.height = y1 - y0;
+            
+
+        //     cv::Scalar s = tracker.get_color(1);
+		//     putText(img2, label_name[objects[i].label], Point(objects[i].rect.x, objects[i].rect.y - 5), 
+        //             0, 0.6, cv::Scalar(0, 0, 255), 2, LINE_AA);
+        //     rectangle(img2, Rect(objects[i].rect.x, objects[i].rect.y, objects[i].rect.width, objects[i].rect.height), s, 2);
+        // }
+        // cv::imwrite("detect.jpg", img2);
+
+        // 画跟踪的框
+        
+        
+        for (int i = 0; i < output_stracks.size(); i++)
+		{
+			vector<float> tlwh = output_stracks[i].tlwh;
+			cv::Scalar s = tracker.get_color(output_stracks[i].track_id);
+			// putText(img, format("%d", output_stracks[i].track_id), Point(tlwh[0], tlwh[1] - 5), 
+            //         0, 0.6, cv::Scalar(0, 0, 255), 2, LINE_AA);
+            // rectangle(img, Rect(tlwh[0], tlwh[1], tlwh[2], tlwh[3]), s, 2);
+
+			int x1 = tlwh[0];
+            int y1 = tlwh[1];
+            int cx = int(x1 + tlwh[2] / 2);
+            int cy = y1 + tlwh[3];
+            int id = output_stracks[i].track_id;
+            if(!(cx > x_min && cx < x_max))
+                continue;
+            if(cy > baseline) //下方
+            {
+                if(total_region2.find(id) != total_region2.end() && total_region1.find(id) == total_region1.end())
+                {
+                    low_id.insert(id);
+                    // line(img, cv::Point(0, baseline), cv::Point(img_w, baseline), cv::Scalar(255, 0, 0, 255), 3);
+                }
+                total_region1.insert(id);
+            }
+            else if(cy < baseline) //上方
+            {
+                if(total_region1.find(id) != total_region1.end() && total_region2.find(id) == total_region2.end())
+                {
+                    up_id.insert(id);
+                    // line(img, cv::Point(0, baseline), cv::Point(img_w, baseline), cv::Scalar(255, 0, 0, 255), 3);
+                }
+                total_region2.insert(id);
+            }
+		}
+
+        // line(img, cv::Point(0, baseline), cv::Point(img_w, baseline), cv::Scalar(0, 255, 0, 255), 3);
+        // line(img, cv::Point(246, baseline), cv::Point(690, baseline), cv::Scalar(0, 255, 0, 255), 3);
+        /*
+        for (int i = 0; i < output_stracks.size(); i++)
+		{
+			vector<float> tlwh = output_stracks[i].tlwh;
+			bool vertical = tlwh[2] / tlwh[3] > 1.6;
+			if (tlwh[2] * tlwh[3] > 20 && !vertical)
+			{
+				cv::Scalar s = tracker.get_color(output_stracks[i].track_id);
+				putText(img, format("%d", output_stracks[i].track_id), Point(tlwh[0], tlwh[1] - 5), 
+                        0, 0.6, cv::Scalar(0, 0, 255), 2, LINE_AA);
+                rectangle(img, Rect(tlwh[0], tlwh[1], tlwh[2], tlwh[3]), s, 2);
+			}
+		}
+        */
+        // putText(img, format("frame: %d fps: %d num: %ld down: %d up: %d", num_frames, num_frames * 1000 / total_ms  , output_stracks.size(), low_id.size(), up_id.size()), 
+        //         Point(0, 30), 0, 0.6, cv::Scalar(0, 0, 255), 2, LINE_AA);
+        gettimeofday(&end_draw, NULL);
+        printf("draw %f ms\n", (__get_us(end_draw) - __get_us(start_draw)) / 1000);
+        // gettimeofday(&start_write, NULL);
+        // writer.write(img);
+        // gettimeofday(&end_write, NULL);
+        // printf("write %f ms\n", (__get_us(end_write) - __get_us(start_write)) / 1000);
+    }
+    // 结束计时
+    gettimeofday(&end_time, NULL);
+    cap.release();
+    printf("all time: %f s\n", (__get_us(end_time) - __get_us(begin_time)) / 1000000);
+    printf("up_nums: %d \ndown_nums: %d \n", up_id.size(), low_id.size());
+    double time = (__get_us(end_time) - __get_us(begin_time)) / 1000000;
+    cout << "FPS: " << num_frames / time << endl;
+}
+
+int main(int argc, char** argv){
+    if (argc < 3) 
+    {
+        std::cerr << "Usage: " << argv[0] << " <model path> <video path> [baseline] [x_min] [x_max]" << std::endl;
+        return 1;
+    }
+
+    // 获取设备的 MAC 地址
+    get_mac_address(mac_address);
+    printf("Device MAC Address: %s\n", mac_address);
+
+    // 生成授权码
+    char license_key[LICENSE_KEY_LENGTH];
+    generate_license_key(mac_address, license_key);
+    std::cout << "Generated license key: " << license_key << std::endl;
+
+    // 用户输入授权码
+    char input_license_key[LICENSE_KEY_LENGTH];
+    printf("Enter License Key: ");
+    fgets(input_license_key, LICENSE_KEY_LENGTH + 1, stdin);
+    input_license_key[strcspn(input_license_key, "\n")] = '\0'; // 去除换行符
+
+    // 验证授权码是否有效
+    if (!validate_license_key(mac_address, input_license_key)) {
+        std::cerr << "Invalid license key. Exiting..." << std::endl;
+        return 1;
+    }
+
+    // 解析算法参数
+    std::vector<std::string> algorithm_params;
+    for (int i = 1; i < argc; ++i) {
+        algorithm_params.push_back(argv[i]);
+    }
+
+    // 启动授权过期检查线程
+    std::thread check_thread(check_license_thread);
+
+    // 创建算法运行线程
+    std::thread run_thread(run_algorithm, algorithm_params);
+
+    // 等待算法运行线程结束
+    run_thread.join();
+
+    // 等待检查线程结束
+    check_thread.join();
+
+    return 0;
+
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/src/kalmanFilter.cpp b/C++/yolo_bytetrack_old/src/kalmanFilter.cpp
new file mode 100644
index 00000000..d1226b9c
--- /dev/null
+++ b/C++/yolo_bytetrack_old/src/kalmanFilter.cpp
@@ -0,0 +1,166 @@
+#include "kalmanFilter.h"
+#define EIGEN_DONT_ALIGN_STATICALLY
+#include <Eigen/Cholesky>
+#include <iostream>
+
+namespace byte_kalman
+{
+	const double KalmanFilter::chi2inv95[10] = {
+	0,
+	3.8415,
+	5.9915,
+	7.8147,
+	9.4877,
+	11.070,
+	12.592,
+	14.067,
+	15.507,
+	16.919
+	};
+	KalmanFilter::KalmanFilter()
+	{
+		int ndim = 4;
+		double dt = 1.;
+
+		_motion_mat = Eigen::MatrixXf::Identity(8, 8);
+		for (int i = 0; i < ndim; i++) {
+			_motion_mat(i, ndim + i) = dt;
+		}
+		_update_mat = Eigen::MatrixXf::Identity(4, 8);
+
+		this->_std_weight_position = 1. / 20;
+		this->_std_weight_velocity = 1. / 160;
+	}
+
+	KAL_DATA KalmanFilter::initiate(const DETECTBOX &measurement)
+	{
+		DETECTBOX mean_pos = measurement;
+		DETECTBOX mean_vel;
+		for (int i = 0; i < 4; i++) mean_vel(i) = 0;
+
+		KAL_MEAN mean;
+		for (int i = 0; i < 8; i++) {
+			if (i < 4) mean(i) = mean_pos(i);
+			else mean(i) = mean_vel(i - 4);
+		}
+
+		KAL_MEAN std;
+		std(0) = 2 * _std_weight_position * measurement[3];
+		std(1) = 2 * _std_weight_position * measurement[3];
+		std(2) = 1e-2;
+		std(3) = 2 * _std_weight_position * measurement[3];
+		std(4) = 10 * _std_weight_velocity * measurement[3];
+		std(5) = 10 * _std_weight_velocity * measurement[3];
+		std(6) = 1e-5;
+		std(7) = 10 * _std_weight_velocity * measurement[3];
+
+		KAL_MEAN tmp = std.array().square();
+		KAL_COVA var = tmp.asDiagonal();
+		return std::make_pair(mean, var);
+	}
+
+	void KalmanFilter::predict(KAL_MEAN &mean, KAL_COVA &covariance)
+	{
+		//revise the data;
+		DETECTBOX std_pos;
+		std_pos << _std_weight_position * mean(3),
+			_std_weight_position * mean(3),
+			1e-2,
+			_std_weight_position * mean(3);
+		DETECTBOX std_vel;
+		std_vel << _std_weight_velocity * mean(3),
+			_std_weight_velocity * mean(3),
+			1e-5,
+			_std_weight_velocity * mean(3);
+		KAL_MEAN tmp;
+		tmp.block<1, 4>(0, 0) = std_pos;
+		tmp.block<1, 4>(0, 4) = std_vel;
+		tmp = tmp.array().square();
+		KAL_COVA motion_cov = tmp.asDiagonal();
+		KAL_MEAN mean1 = this->_motion_mat * mean.transpose();
+		KAL_COVA covariance1 = this->_motion_mat * covariance *(_motion_mat.transpose());
+		covariance1 += motion_cov;
+
+		mean = mean1;
+		covariance = covariance1;
+	}
+
+	KAL_HDATA KalmanFilter::project(const KAL_MEAN &mean, const KAL_COVA &covariance)
+	{
+		// std::cout << "kf project" << std::endl;
+		DETECTBOX std;
+		std << _std_weight_position * mean(3), _std_weight_position * mean(3),
+			1e-1, _std_weight_position * mean(3);
+		// std::cout << "**********" << std::endl;
+		KAL_HMEAN mean1 = _update_mat * mean.transpose().eval();
+		// std::cout << "project 1" << std::endl;
+		KAL_HCOVA covariance1 = _update_mat * covariance * (_update_mat.transpose());
+		// std::cout << "project 2" << std::endl;
+		Eigen::Matrix<float, 4, 4> diag = std.asDiagonal();
+		diag = diag.array().square().matrix();
+		covariance1 += diag;
+		//    covariance1.diagonal() << diag;
+		return std::make_pair(mean1, covariance1);
+	}
+
+	KAL_DATA
+		KalmanFilter::update(
+			const KAL_MEAN &mean,
+			const KAL_COVA &covariance,
+			const DETECTBOX &measurement)
+	{
+		// std::cout << "kf update" << std::endl;
+		KAL_HDATA pa = project(mean, covariance);
+		KAL_HMEAN projected_mean = pa.first;
+		KAL_HCOVA projected_cov = pa.second;
+
+		//chol_factor, lower =
+		//scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
+		//kalmain_gain =
+		//scipy.linalg.cho_solve((cho_factor, lower),
+		//np.dot(covariance, self._upadte_mat.T).T,
+		//check_finite=False).T
+		
+		Eigen::Matrix<float, 4, 8> B = (covariance * (_update_mat.transpose())).transpose();
+		// std::cout << "step 1" << std::endl;
+		Eigen::Matrix<float, 8, 4> kalman_gain = (projected_cov.llt().solve(B)).transpose(); // eg.8x4
+		// std::cout << "step 2" << std::endl;
+		Eigen::Matrix<float, 1, 4> innovation = measurement - projected_mean; //eg.1x4
+		// std::cout << "step 3" << std::endl;
+		auto tmp = innovation * (kalman_gain.transpose());
+		// std::cout << "step 4" << std::endl;
+		KAL_MEAN new_mean = (mean.array() + tmp.array()).matrix();
+		// std::cout << "step 5" << std::endl;
+		KAL_COVA new_covariance = covariance - kalman_gain * projected_cov*(kalman_gain.transpose());
+		// std::cout << "step 6" << std::endl;
+		return std::make_pair(new_mean, new_covariance);
+	}
+
+	Eigen::Matrix<float, 1, -1>
+		KalmanFilter::gating_distance(
+			const KAL_MEAN &mean,
+			const KAL_COVA &covariance,
+			const std::vector<DETECTBOX> &measurements,
+			bool only_position)
+	{
+		KAL_HDATA pa = this->project(mean, covariance);
+		if (only_position) {
+			printf("not implement!");
+			exit(0);
+		}
+		KAL_HMEAN mean1 = pa.first;
+		KAL_HCOVA covariance1 = pa.second;
+
+		//    Eigen::Matrix<float, -1, 4, Eigen::RowMajor> d(size, 4);
+		DETECTBOXSS d(measurements.size(), 4);
+		int pos = 0;
+		for (DETECTBOX box : measurements) {
+			d.row(pos++) = box - mean1;
+		}
+		Eigen::Matrix<float, -1, -1, Eigen::RowMajor> factor = covariance1.llt().matrixL();
+		Eigen::Matrix<float, -1, -1> z = factor.triangularView<Eigen::Lower>().solve<Eigen::OnTheRight>(d).transpose();
+		auto zz = ((z.array())*(z.array())).matrix();
+		auto square_maha = zz.colwise().sum();
+		return square_maha;
+	}
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/src/lapjv.cpp b/C++/yolo_bytetrack_old/src/lapjv.cpp
new file mode 100644
index 00000000..169efd51
--- /dev/null
+++ b/C++/yolo_bytetrack_old/src/lapjv.cpp
@@ -0,0 +1,343 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "lapjv.h"
+
+/** Column-reduction and reduction transfer for a dense cost matrix.
+ */
+int_t _ccrrt_dense(const uint_t n, cost_t *cost[],
+	int_t *free_rows, int_t *x, int_t *y, cost_t *v)
+{
+	int_t n_free_rows;
+	boolean *unique;
+
+	for (uint_t i = 0; i < n; i++) {
+		x[i] = -1;
+		v[i] = LARGE;
+		y[i] = 0;
+	}
+	for (uint_t i = 0; i < n; i++) {
+		for (uint_t j = 0; j < n; j++) {
+			const cost_t c = cost[i][j];
+			if (c < v[j]) {
+				v[j] = c;
+				y[j] = i;
+			}
+			PRINTF("i=%d, j=%d, c[i,j]=%f, v[j]=%f y[j]=%d\n", i, j, c, v[j], y[j]);
+		}
+	}
+	PRINT_COST_ARRAY(v, n);
+	PRINT_INDEX_ARRAY(y, n);
+	NEW(unique, boolean, n);
+	memset(unique, TRUE, n);
+	{
+		int_t j = n;
+		do {
+			j--;
+			const int_t i = y[j];
+			if (x[i] < 0) {
+				x[i] = j;
+			}
+			else {
+				unique[i] = FALSE;
+				y[j] = -1;
+			}
+		} while (j > 0);
+	}
+	n_free_rows = 0;
+	for (uint_t i = 0; i < n; i++) {
+		if (x[i] < 0) {
+			free_rows[n_free_rows++] = i;
+		}
+		else if (unique[i]) {
+			const int_t j = x[i];
+			cost_t min = LARGE;
+			for (uint_t j2 = 0; j2 < n; j2++) {
+				if (j2 == (uint_t)j) {
+					continue;
+				}
+				const cost_t c = cost[i][j2] - v[j2];
+				if (c < min) {
+					min = c;
+				}
+			}
+			PRINTF("v[%d] = %f - %f\n", j, v[j], min);
+			v[j] -= min;
+		}
+	}
+	FREE(unique);
+	return n_free_rows;
+}
+
+
+/** Augmenting row reduction for a dense cost matrix.
+ */
+int_t _carr_dense(
+	const uint_t n, cost_t *cost[],
+	const uint_t n_free_rows,
+	int_t *free_rows, int_t *x, int_t *y, cost_t *v)
+{
+	uint_t current = 0;
+	int_t new_free_rows = 0;
+	uint_t rr_cnt = 0;
+	PRINT_INDEX_ARRAY(x, n);
+	PRINT_INDEX_ARRAY(y, n);
+	PRINT_COST_ARRAY(v, n);
+	PRINT_INDEX_ARRAY(free_rows, n_free_rows);
+	while (current < n_free_rows) {
+		int_t i0;
+		int_t j1, j2;
+		cost_t v1, v2, v1_new;
+		boolean v1_lowers;
+
+		rr_cnt++;
+		PRINTF("current = %d rr_cnt = %d\n", current, rr_cnt);
+		const int_t free_i = free_rows[current++];
+		j1 = 0;
+		v1 = cost[free_i][0] - v[0];
+		j2 = -1;
+		v2 = LARGE;
+		for (uint_t j = 1; j < n; j++) {
+			PRINTF("%d = %f %d = %f\n", j1, v1, j2, v2);
+			const cost_t c = cost[free_i][j] - v[j];
+			if (c < v2) {
+				if (c >= v1) {
+					v2 = c;
+					j2 = j;
+				}
+				else {
+					v2 = v1;
+					v1 = c;
+					j2 = j1;
+					j1 = j;
+				}
+			}
+		}
+		i0 = y[j1];
+		v1_new = v[j1] - (v2 - v1);
+		v1_lowers = v1_new < v[j1];
+		PRINTF("%d %d 1=%d,%f 2=%d,%f v1'=%f(%d,%g) \n", free_i, i0, j1, v1, j2, v2, v1_new, v1_lowers, v[j1] - v1_new);
+		if (rr_cnt < current * n) {
+			if (v1_lowers) {
+				v[j1] = v1_new;
+			}
+			else if (i0 >= 0 && j2 >= 0) {
+				j1 = j2;
+				i0 = y[j2];
+			}
+			if (i0 >= 0) {
+				if (v1_lowers) {
+					free_rows[--current] = i0;
+				}
+				else {
+					free_rows[new_free_rows++] = i0;
+				}
+			}
+		}
+		else {
+			PRINTF("rr_cnt=%d >= %d (current=%d * n=%d)\n", rr_cnt, current * n, current, n);
+			if (i0 >= 0) {
+				free_rows[new_free_rows++] = i0;
+			}
+		}
+		x[free_i] = j1;
+		y[j1] = free_i;
+	}
+	return new_free_rows;
+}
+
+
+/** Find columns with minimum d[j] and put them on the SCAN list.
+ */
+uint_t _find_dense(const uint_t n, uint_t lo, cost_t *d, int_t *cols, int_t *y)
+{
+	uint_t hi = lo + 1;
+	cost_t mind = d[cols[lo]];
+	for (uint_t k = hi; k < n; k++) {
+		int_t j = cols[k];
+		if (d[j] <= mind) {
+			if (d[j] < mind) {
+				hi = lo;
+				mind = d[j];
+			}
+			cols[k] = cols[hi];
+			cols[hi++] = j;
+		}
+	}
+	return hi;
+}
+
+
+// Scan all columns in TODO starting from arbitrary column in SCAN
+// and try to decrease d of the TODO columns using the SCAN column.
+int_t _scan_dense(const uint_t n, cost_t *cost[],
+	uint_t *plo, uint_t*phi,
+	cost_t *d, int_t *cols, int_t *pred,
+	int_t *y, cost_t *v)
+{
+	uint_t lo = *plo;
+	uint_t hi = *phi;
+	cost_t h, cred_ij;
+
+	while (lo != hi) {
+		int_t j = cols[lo++];
+		const int_t i = y[j];
+		const cost_t mind = d[j];
+		h = cost[i][j] - v[j] - mind;
+		PRINTF("i=%d j=%d h=%f\n", i, j, h);
+		// For all columns in TODO
+		for (uint_t k = hi; k < n; k++) {
+			j = cols[k];
+			cred_ij = cost[i][j] - v[j] - h;
+			if (cred_ij < d[j]) {
+				d[j] = cred_ij;
+				pred[j] = i;
+				if (cred_ij == mind) {
+					if (y[j] < 0) {
+						return j;
+					}
+					cols[k] = cols[hi];
+					cols[hi++] = j;
+				}
+			}
+		}
+	}
+	*plo = lo;
+	*phi = hi;
+	return -1;
+}
+
+
+/** Single iteration of modified Dijkstra shortest path algorithm as explained in the JV paper.
+ *
+ * This is a dense matrix version.
+ *
+ * \return The closest free column index.
+ */
+int_t find_path_dense(
+	const uint_t n, cost_t *cost[],
+	const int_t start_i,
+	int_t *y, cost_t *v,
+	int_t *pred)
+{
+	uint_t lo = 0, hi = 0;
+	int_t final_j = -1;
+	uint_t n_ready = 0;
+	int_t *cols;
+	cost_t *d;
+
+	NEW(cols, int_t, n);
+	NEW(d, cost_t, n);
+
+	for (uint_t i = 0; i < n; i++) {
+		cols[i] = i;
+		pred[i] = start_i;
+		d[i] = cost[start_i][i] - v[i];
+	}
+	PRINT_COST_ARRAY(d, n);
+	while (final_j == -1) {
+		// No columns left on the SCAN list.
+		if (lo == hi) {
+			PRINTF("%d..%d -> find\n", lo, hi);
+			n_ready = lo;
+			hi = _find_dense(n, lo, d, cols, y);
+			PRINTF("check %d..%d\n", lo, hi);
+			PRINT_INDEX_ARRAY(cols, n);
+			for (uint_t k = lo; k < hi; k++) {
+				const int_t j = cols[k];
+				if (y[j] < 0) {
+					final_j = j;
+				}
+			}
+		}
+		if (final_j == -1) {
+			PRINTF("%d..%d -> scan\n", lo, hi);
+			final_j = _scan_dense(
+				n, cost, &lo, &hi, d, cols, pred, y, v);
+			PRINT_COST_ARRAY(d, n);
+			PRINT_INDEX_ARRAY(cols, n);
+			PRINT_INDEX_ARRAY(pred, n);
+		}
+	}
+
+	PRINTF("found final_j=%d\n", final_j);
+	PRINT_INDEX_ARRAY(cols, n);
+	{
+		const cost_t mind = d[cols[lo]];
+		for (uint_t k = 0; k < n_ready; k++) {
+			const int_t j = cols[k];
+			v[j] += d[j] - mind;
+		}
+	}
+
+	FREE(cols);
+	FREE(d);
+
+	return final_j;
+}
+
+
+/** Augment for a dense cost matrix.
+ */
+int_t _ca_dense(
+	const uint_t n, cost_t *cost[],
+	const uint_t n_free_rows,
+	int_t *free_rows, int_t *x, int_t *y, cost_t *v)
+{
+	int_t *pred;
+
+	NEW(pred, int_t, n);
+
+	for (int_t *pfree_i = free_rows; pfree_i < free_rows + n_free_rows; pfree_i++) {
+		int_t i = -1, j;
+		uint_t k = 0;
+
+		PRINTF("looking at free_i=%d\n", *pfree_i);
+		j = find_path_dense(n, cost, *pfree_i, y, v, pred);
+		ASSERT(j >= 0);
+		ASSERT(j < n);
+		while (i != *pfree_i) {
+			PRINTF("augment %d\n", j);
+			PRINT_INDEX_ARRAY(pred, n);
+			i = pred[j];
+			PRINTF("y[%d]=%d -> %d\n", j, y[j], i);
+			y[j] = i;
+			PRINT_INDEX_ARRAY(x, n);
+			SWAP_INDICES(j, x[i]);
+			k++;
+			if (k >= n) {
+				ASSERT(FALSE);
+			}
+		}
+	}
+	FREE(pred);
+	return 0;
+}
+
+
+/** Solve dense sparse LAP.
+ */
+int lapjv_internal(
+	const uint_t n, cost_t *cost[],
+	int_t *x, int_t *y)
+{
+	int ret;
+	int_t *free_rows;
+	cost_t *v;
+
+	NEW(free_rows, int_t, n);
+	NEW(v, cost_t, n);
+	ret = _ccrrt_dense(n, cost, free_rows, x, y, v);
+	int i = 0;
+	while (ret > 0 && i < 2) {
+		ret = _carr_dense(n, cost, ret, free_rows, x, y, v);
+		i++;
+	}
+	if (ret > 0) {
+		ret = _ca_dense(n, cost, ret, free_rows, x, y, v);
+	}
+	FREE(v);
+	FREE(free_rows);
+	return ret;
+}
\ No newline at end of file
diff --git a/C++/yolo_bytetrack_old/src/utils.cpp b/C++/yolo_bytetrack_old/src/utils.cpp
new file mode 100644
index 00000000..f3fa5acd
--- /dev/null
+++ b/C++/yolo_bytetrack_old/src/utils.cpp
@@ -0,0 +1,432 @@
+#include "BYTETracker.h"
+#include "lapjv.h"
+#include <map>
+#include <iostream>
+using namespace std;
+
+vector<STrack*> BYTETracker::joint_stracks(vector<STrack*> &tlista, vector<STrack> &tlistb)
+{
+	map<int, int> exists;
+	vector<STrack*> res;
+	for (int i = 0; i < tlista.size(); i++)
+	{
+		exists.insert(pair<int, int>(tlista[i]->track_id, 1));
+		res.push_back(tlista[i]);
+	}
+	for (int i = 0; i < tlistb.size(); i++)
+	{
+		int tid = tlistb[i].track_id;
+		if (!exists[tid] || exists.count(tid) == 0)
+		{
+			exists[tid] = 1;
+			res.push_back(&tlistb[i]);
+		}
+	}
+	return res;
+}
+
+vector<STrack> BYTETracker::joint_stracks(vector<STrack> &tlista, vector<STrack> &tlistb)
+{
+	map<int, int> exists;
+	vector<STrack> res;
+	for (int i = 0; i < tlista.size(); i++)
+	{
+		exists.insert(pair<int, int>(tlista[i].track_id, 1));
+		res.push_back(tlista[i]);
+	}
+	for (int i = 0; i < tlistb.size(); i++)
+	{
+		int tid = tlistb[i].track_id;
+		if (!exists[tid] || exists.count(tid) == 0)
+		{
+			exists[tid] = 1;
+			res.push_back(tlistb[i]);
+		}
+	}
+	return res;
+}
+
+vector<STrack> BYTETracker::sub_stracks(vector<STrack> &tlista, vector<STrack> &tlistb)
+{
+	map<int, STrack> stracks;
+	for (int i = 0; i < tlista.size(); i++)
+	{
+		stracks.insert(pair<int, STrack>(tlista[i].track_id, tlista[i]));
+	}
+	for (int i = 0; i < tlistb.size(); i++)
+	{
+		int tid = tlistb[i].track_id;
+		if (stracks.count(tid) != 0)
+		{
+			stracks.erase(tid);
+		}
+	}
+
+	vector<STrack> res;
+	map<int, STrack>::iterator  it;
+	for (it = stracks.begin(); it != stracks.end(); ++it)
+	{
+		res.push_back(it->second);
+	}
+
+	return res;
+}
+
+void BYTETracker::remove_duplicate_stracks(vector<STrack> &resa, vector<STrack> &resb, vector<STrack> &stracksa, vector<STrack> &stracksb)
+{
+	vector<vector<float> > pdist = iou_distance(stracksa, stracksb);
+	vector<pair<int, int> > pairs;
+	for (int i = 0; i < pdist.size(); i++)
+	{
+		for (int j = 0; j < pdist[i].size(); j++)
+		{
+			if (pdist[i][j] < 0.15)
+			{
+				pairs.push_back(pair<int, int>(i, j));
+			}
+		}
+	}
+
+	vector<int> dupa, dupb;
+	for (int i = 0; i < pairs.size(); i++)
+	{
+		int timep = stracksa[pairs[i].first].frame_id - stracksa[pairs[i].first].start_frame;
+		int timeq = stracksb[pairs[i].second].frame_id - stracksb[pairs[i].second].start_frame;
+		if (timep > timeq)
+			dupb.push_back(pairs[i].second);
+		else
+			dupa.push_back(pairs[i].first);
+	}
+
+	for (int i = 0; i < stracksa.size(); i++)
+	{
+		vector<int>::iterator iter = find(dupa.begin(), dupa.end(), i);
+		if (iter == dupa.end())
+		{
+			resa.push_back(stracksa[i]);
+		}
+	}
+
+	for (int i = 0; i < stracksb.size(); i++)
+	{
+		vector<int>::iterator iter = find(dupb.begin(), dupb.end(), i);
+		if (iter == dupb.end())
+		{
+			resb.push_back(stracksb[i]);
+		}
+	}
+}
+
+void BYTETracker::linear_assignment(vector<vector<float> > &cost_matrix, int cost_matrix_size, int cost_matrix_size_size, float thresh,
+	vector<vector<int> > &matches, vector<int> &unmatched_a, vector<int> &unmatched_b)
+{
+	if (cost_matrix.size() == 0)
+	{
+		for (int i = 0; i < cost_matrix_size; i++)
+		{
+			unmatched_a.push_back(i);
+		}
+		for (int i = 0; i < cost_matrix_size_size; i++)
+		{
+			unmatched_b.push_back(i);
+		}
+		return;
+	}
+
+	vector<int> rowsol; vector<int> colsol;
+	float c = lapjv(cost_matrix, rowsol, colsol, true, thresh);
+	for (int i = 0; i < rowsol.size(); i++)
+	{
+		if (rowsol[i] >= 0)
+		{
+			vector<int> match;
+			match.push_back(i);
+			match.push_back(rowsol[i]);
+			matches.push_back(match);
+		}
+		else
+		{
+			unmatched_a.push_back(i);
+		}
+	}
+
+	for (int i = 0; i < colsol.size(); i++)
+	{
+		if (colsol[i] < 0)
+		{
+			unmatched_b.push_back(i);
+		}
+	}
+}
+
+vector<vector<float> > BYTETracker::ious(vector<vector<float> > &atlbrs, vector<vector<float> > &btlbrs)
+{
+	vector<vector<float> > ious;
+	if (atlbrs.size()*btlbrs.size() == 0)
+		return ious;
+
+	ious.resize(atlbrs.size());
+	for (int i = 0; i < ious.size(); i++)
+	{
+		ious[i].resize(btlbrs.size());
+	}
+
+	//bbox_ious
+	for (int k = 0; k < btlbrs.size(); k++)
+	{
+		vector<float> ious_tmp;
+		float box_area = (btlbrs[k][2] - btlbrs[k][0] + 1)*(btlbrs[k][3] - btlbrs[k][1] + 1);
+		for (int n = 0; n < atlbrs.size(); n++)
+		{
+			float iw = min(atlbrs[n][2], btlbrs[k][2]) - max(atlbrs[n][0], btlbrs[k][0]) + 1;
+			if (iw > 0)
+			{
+				float ih = min(atlbrs[n][3], btlbrs[k][3]) - max(atlbrs[n][1], btlbrs[k][1]) + 1;
+				if(ih > 0)
+				{
+					float ua = (atlbrs[n][2] - atlbrs[n][0] + 1)*(atlbrs[n][3] - atlbrs[n][1] + 1) + box_area - iw * ih;
+					ious[n][k] = iw * ih / ua;
+				}
+				else
+				{
+					ious[n][k] = 0.0;
+				}
+			}
+			else
+			{
+				ious[n][k] = 0.0;
+			}
+		}
+	}
+
+	return ious;
+}
+
+vector<vector<float> > BYTETracker::iou_distance(vector<STrack*> &atracks, vector<STrack> &btracks, int &dist_size, int &dist_size_size)
+{
+	vector<vector<float> > cost_matrix;
+	if (atracks.size() * btracks.size() == 0)
+	{
+		dist_size = atracks.size();
+		dist_size_size = btracks.size();
+		return cost_matrix;
+	}
+	vector<vector<float> > atlbrs, btlbrs;
+	for (int i = 0; i < atracks.size(); i++)
+	{
+		atlbrs.push_back(atracks[i]->tlbr);
+	}
+	for (int i = 0; i < btracks.size(); i++)
+	{
+		btlbrs.push_back(btracks[i].tlbr);
+	}
+
+	dist_size = atracks.size();
+	dist_size_size = btracks.size();
+
+	vector<vector<float> > _ious = ious(atlbrs, btlbrs);
+	
+	for (int i = 0; i < _ious.size();i++)
+	{
+		vector<float> _iou;
+		for (int j = 0; j < _ious[i].size(); j++)
+		{
+			_iou.push_back(1 - _ious[i][j]);
+		}
+		cost_matrix.push_back(_iou);
+	}
+
+	return cost_matrix;
+}
+
+vector<vector<float> > BYTETracker::iou_distance(vector<STrack> &atracks, vector<STrack> &btracks)
+{
+	vector<vector<float> > atlbrs, btlbrs;
+	for (int i = 0; i < atracks.size(); i++)
+	{
+		atlbrs.push_back(atracks[i].tlbr);
+	}
+	for (int i = 0; i < btracks.size(); i++)
+	{
+		btlbrs.push_back(btracks[i].tlbr);
+	}
+
+	vector<vector<float> > _ious = ious(atlbrs, btlbrs);
+	vector<vector<float> > cost_matrix;
+	for (int i = 0; i < _ious.size(); i++)
+	{
+		vector<float> _iou;
+		for (int j = 0; j < _ious[i].size(); j++)
+		{
+			_iou.push_back(1 - _ious[i][j]);
+		}
+		cost_matrix.push_back(_iou);
+	}
+
+	return cost_matrix;
+}
+
+double BYTETracker::lapjv(const vector<vector<float> > &cost, vector<int> &rowsol, vector<int> &colsol,
+	bool extend_cost, float cost_limit, bool return_cost)
+{
+	vector<vector<float> > cost_c;
+	cost_c.assign(cost.begin(), cost.end());
+
+	vector<vector<float> > cost_c_extended;
+
+	int n_rows = cost.size();
+	int n_cols = cost[0].size();
+	rowsol.resize(n_rows);
+	colsol.resize(n_cols);
+
+	int n = 0;
+	if (n_rows == n_cols)
+	{
+		n = n_rows;
+	}
+	else
+	{
+		if (!extend_cost)
+		{
+			cout << "set extend_cost=True" << endl;
+			system("pause");
+			exit(0);
+		}
+	}
+		
+	if (extend_cost || cost_limit < LONG_MAX)
+	{
+		n = n_rows + n_cols;
+		cost_c_extended.resize(n);
+		for (int i = 0; i < cost_c_extended.size(); i++)
+			cost_c_extended[i].resize(n);
+
+		if (cost_limit < LONG_MAX)
+		{
+			for (int i = 0; i < cost_c_extended.size(); i++)
+			{
+				for (int j = 0; j < cost_c_extended[i].size(); j++)
+				{
+					cost_c_extended[i][j] = cost_limit / 2.0;
+				}
+			}
+		}
+		else
+		{
+			float cost_max = -1;
+			for (int i = 0; i < cost_c.size(); i++)
+			{
+				for (int j = 0; j < cost_c[i].size(); j++)
+				{
+					if (cost_c[i][j] > cost_max)
+						cost_max = cost_c[i][j];
+				}
+			}
+			for (int i = 0; i < cost_c_extended.size(); i++)
+			{
+				for (int j = 0; j < cost_c_extended[i].size(); j++)
+				{
+					cost_c_extended[i][j] = cost_max + 1;
+				}
+			}
+		}
+
+		for (int i = n_rows; i < cost_c_extended.size(); i++)
+		{
+			for (int j = n_cols; j < cost_c_extended[i].size(); j++)
+			{
+				cost_c_extended[i][j] = 0;
+			}
+		}
+		for (int i = 0; i < n_rows; i++)
+		{
+			for (int j = 0; j < n_cols; j++)
+			{
+				cost_c_extended[i][j] = cost_c[i][j];
+			}
+		}
+
+		cost_c.clear();
+		cost_c.assign(cost_c_extended.begin(), cost_c_extended.end());
+	}
+
+	double **cost_ptr;
+	cost_ptr = new double *[sizeof(double *) * n];
+	for (int i = 0; i < n; i++)
+		cost_ptr[i] = new double[sizeof(double) * n];
+
+	for (int i = 0; i < n; i++)
+	{
+		for (int j = 0; j < n; j++)
+		{
+			cost_ptr[i][j] = cost_c[i][j];
+		}
+	}
+
+	int* x_c = new int[sizeof(int) * n];
+	int *y_c = new int[sizeof(int) * n];
+
+	int ret = lapjv_internal(n, cost_ptr, x_c, y_c);
+	if (ret != 0)
+	{
+		cout << "Calculate Wrong!" << endl;
+		system("pause");
+		exit(0);
+	}
+
+	double opt = 0.0;
+
+	if (n != n_rows)
+	{
+		for (int i = 0; i < n; i++)
+		{
+			if (x_c[i] >= n_cols)
+				x_c[i] = -1;
+			if (y_c[i] >= n_rows)
+				y_c[i] = -1;
+		}
+		for (int i = 0; i < n_rows; i++)
+		{
+			rowsol[i] = x_c[i];
+		}
+		for (int i = 0; i < n_cols; i++)
+		{
+			colsol[i] = y_c[i];
+		}
+
+		if (return_cost)
+		{
+			for (int i = 0; i < rowsol.size(); i++)
+			{
+				if (rowsol[i] != -1)
+				{
+					//cout << i << "\t" << rowsol[i] << "\t" << cost_ptr[i][rowsol[i]] << endl;
+					opt += cost_ptr[i][rowsol[i]];
+				}
+			}
+		}
+	}
+	else if (return_cost)
+	{
+		for (int i = 0; i < rowsol.size(); i++)
+		{
+			opt += cost_ptr[i][rowsol[i]];
+		}
+	}
+
+	for (int i = 0; i < n; i++)
+	{
+		delete[]cost_ptr[i];
+	}
+	delete[]cost_ptr;
+	delete[]x_c;
+	delete[]y_c;
+
+	return opt;
+}
+
+cv::Scalar BYTETracker::get_color(int idx)
+{
+	idx += 3;
+	return cv::Scalar(37 * idx % 255, 17 * idx % 255, 29 * idx % 255);
+}
\ No newline at end of file